From af9fc2bcff31d5baa413039818a9b3e011deccaf Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Sat, 3 Apr 2021 15:06:56 +0100
Subject: [PATCH 001/317] chore: move to typescript

---
 package.json                                  |   2 +-
 src/compiler/{codeframe.js => codeframe.ts}   |  13 +-
 src/compiler/codegen/{events.js => events.ts} |  55 +--
 src/compiler/codegen/{index.js => index.ts}   | 267 +++++++-------
 ...{create-compiler.js => create-compiler.ts} |  28 +-
 src/compiler/directives/{bind.js => bind.ts}  |   6 +-
 .../directives/{index.js => index.ts}         |   2 +-
 .../directives/{model.js => model.ts}         |  39 +-
 src/compiler/directives/{on.js => on.ts}      |   2 +-
 .../{error-detector.js => error-detector.ts}  |  80 +++--
 src/compiler/{helpers.js => helpers.ts}       | 132 ++++---
 src/compiler/{index.js => index.ts}           |   4 +-
 src/compiler/{optimizer.js => optimizer.ts}   |  50 +--
 .../{entity-decoder.js => entity-decoder.ts}  |   4 +-
 .../{filter-parser.js => filter-parser.ts}    |  65 ++--
 .../parser/{html-parser.js => html-parser.ts} |  81 +++--
 src/compiler/parser/{index.js => index.ts}    | 322 +++++++++--------
 .../parser/{text-parser.js => text-parser.ts} |  19 +-
 .../{to-function.js => to-function.ts}        |  42 ++-
 src/core/components/{index.js => index.ts}    |   2 +-
 .../{keep-alive.js => keep-alive.ts}          |  57 +--
 src/core/{config.js => config.ts}             |  47 ++-
 src/core/global-api/{assets.js => assets.ts}  |   9 +-
 src/core/global-api/{extend.js => extend.ts}  |  19 +-
 src/core/global-api/{index.js => index.ts}    |  11 +-
 src/core/global-api/{mixin.js => mixin.ts}    |   3 +-
 src/core/global-api/{use.js => use.ts}        |   8 +-
 src/core/{index.js => index.ts}               |   9 +-
 src/core/instance/{events.js => events.ts}    |  58 +--
 src/core/instance/{index.js => index.ts}      |   7 +-
 src/core/instance/{init.js => init.ts}        |  24 +-
 src/core/instance/{inject.js => inject.ts}    |  37 +-
 .../instance/{lifecycle.js => lifecycle.ts}   |  89 +++--
 src/core/instance/{proxy.js => proxy.ts}      |  57 +--
 ...d-dynamic-keys.js => bind-dynamic-keys.ts} |  13 +-
 ...-listeners.js => bind-object-listeners.ts} |  11 +-
 ...d-object-props.js => bind-object-props.ts} |  24 +-
 .../{check-keycodes.js => check-keycodes.ts}  |   6 +-
 .../render-helpers/{index.js => index.ts}     |   2 +-
 .../{render-list.js => render-list.ts}        |  21 +-
 .../{render-slot.js => render-slot.ts}        |  21 +-
 .../{render-static.js => render-static.ts}    |  14 +-
 .../{resolve-filter.js => resolve-filter.ts}  |   4 +-
 ...coped-slots.js => resolve-scoped-slots.ts} |  16 +-
 .../{resolve-slots.js => resolve-slots.ts}    |  21 +-
 src/core/instance/{render.js => render.ts}    |  58 ++-
 src/core/instance/{state.js => state.ts}      | 133 +++----
 src/core/observer/{array.js => array.ts}      |   4 +-
 src/core/observer/{dep.js => dep.ts}          |  24 +-
 src/core/observer/{index.js => index.ts}      |  82 +++--
 .../observer/{scheduler.js => scheduler.ts}   |  30 +-
 .../observer/{traverse.js => traverse.ts}     |  10 +-
 src/core/observer/{watcher.js => watcher.ts}  |  87 ++---
 src/core/util/{debug.js => debug.ts}          |  65 ++--
 src/core/util/{env.js => env.ts}              |  57 +--
 src/core/util/{error.js => error.ts}          |  12 +-
 src/core/util/{index.js => index.ts}          |   0
 src/core/util/{lang.js => lang.ts}            |  10 +-
 src/core/util/{next-tick.js => next-tick.ts}  |  22 +-
 src/core/util/{options.js => options.ts}      | 186 +++++-----
 src/core/util/{perf.js => perf.ts}            |   2 +-
 src/core/util/{props.js => props.ts}          |  94 ++---
 ...reate-component.js => create-component.ts} |  91 +++--
 .../{create-element.js => create-element.ts}  |  79 +++--
 ...nent.js => create-functional-component.ts} |  63 ++--
 .../{extract-props.js => extract-props.ts}    |  34 +-
 ...-child.js => get-first-component-child.ts} |   5 +-
 src/core/vdom/helpers/{index.js => index.ts}  |   0
 src/core/vdom/helpers/is-async-placeholder.js |   5 -
 src/core/vdom/helpers/is-async-placeholder.ts |   8 +
 .../helpers/{merge-hook.js => merge-hook.ts}  |  10 +-
 ...lize-children.js => normalize-children.ts} |  25 +-
 ...ped-slots.js => normalize-scoped-slots.ts} |  20 +-
 ...omponent.js => resolve-async-component.ts} |  62 ++--
 ...pdate-listeners.js => update-listeners.ts} |  62 ++--
 .../modules/{directives.js => directives.ts}  |  32 +-
 src/core/vdom/modules/{index.js => index.ts}  |   5 +-
 src/core/vdom/modules/{ref.js => ref.ts}      |  16 +-
 src/core/vdom/{patch.js => patch.ts}          | 333 ++++++++++++------
 src/core/vdom/{vnode.js => vnode.ts}          |  65 ++--
 .../compiler/directives/{html.js => html.ts}  |   2 +-
 .../directives/{index.js => index.ts}         |   2 +-
 .../directives/{model.js => model.ts}         |  79 +++--
 .../compiler/directives/{text.js => text.ts}  |   2 +-
 .../web/compiler/{index.js => index.ts}       |   0
 .../compiler/modules/{class.js => class.ts}   |  18 +-
 .../compiler/modules/{index.js => index.ts}   |   6 +-
 .../compiler/modules/{model.js => model.ts}   |  20 +-
 .../compiler/modules/{style.js => style.ts}   |  18 +-
 .../web/compiler/{options.js => options.ts}   |   7 +-
 .../web/compiler/{util.js => util.ts}         |  10 +-
 .../{entry-compiler.js => entry-compiler.ts}  |   0
 ...iler.js => entry-runtime-with-compiler.ts} |  37 +-
 .../{entry-runtime.js => entry-runtime.ts}    |   0
 ...erer.js => entry-server-basic-renderer.ts} |   3 +-
 src/platforms/web/entry-server-renderer.js    |  27 --
 src/platforms/web/entry-server-renderer.ts    |  32 ++
 .../runtime/{class-util.js => class-util.ts}  |   8 +-
 .../runtime/components/{index.js => index.ts} |   2 +-
 ...ransition-group.js => transition-group.ts} |  90 +++--
 .../{transition.js => transition.ts}          |  87 +++--
 .../runtime/directives/{index.js => index.ts} |   2 +-
 .../runtime/directives/{model.js => model.ts} |  49 +--
 .../runtime/directives/{show.js => show.ts}   |  19 +-
 .../web/runtime/{index.js => index.ts}        |  13 +-
 .../runtime/modules/{attrs.js => attrs.ts}    |  30 +-
 .../runtime/modules/{class.js => class.ts}    |  25 +-
 .../modules/{dom-props.js => dom-props.ts}    |  35 +-
 .../runtime/modules/{events.js => events.ts}  |  28 +-
 .../runtime/modules/{index.js => index.ts}    |   9 +-
 .../runtime/modules/{style.js => style.ts}    |  38 +-
 .../modules/{transition.js => transition.ts}  | 127 ++++---
 src/platforms/web/runtime/node-ops.js         |  59 ----
 src/platforms/web/runtime/node-ops.ts         |  68 ++++
 .../web/runtime/{patch.js => patch.ts}        |   0
 ...{transition-util.js => transition-util.ts} | 111 +++---
 .../web/server/{compiler.js => compiler.ts}   |   5 +-
 .../server/directives/{index.js => index.ts}  |   2 +-
 .../server/directives/{model.js => model.ts}  |   9 +-
 .../server/directives/{show.js => show.ts}    |   4 +-
 .../web/server/modules/{attrs.js => attrs.ts} |  19 +-
 .../web/server/modules/{class.js => class.ts} |   3 +-
 .../modules/{dom-props.js => dom-props.ts}    |   7 +-
 .../web/server/modules/{index.js => index.ts} |   7 +-
 .../web/server/modules/{style.js => style.ts} |   5 +-
 src/platforms/web/server/util.js              | 101 ------
 src/platforms/web/server/util.ts              |  99 ++++++
 src/platforms/web/util/{attrs.js => attrs.ts} |  30 +-
 src/platforms/web/util/{class.js => class.ts} |  41 ++-
 .../web/util/{compat.js => compat.ts}         |   6 +-
 src/platforms/web/util/element.js             |  77 ----
 src/platforms/web/util/element.ts             |  78 ++++
 src/platforms/web/util/{index.js => index.ts} |   7 +-
 src/platforms/web/util/{style.js => style.ts} |  21 +-
 .../directives/{index.js => index.ts}         |   2 +-
 .../directives/{model.js => model.ts}         |  11 +-
 .../weex/compiler/{index.js => index.ts}      |  10 +-
 .../compiler/modules/{append.js => append.ts} |  11 +-
 .../compiler/modules/{class.js => class.ts}   |  44 +--
 .../compiler/modules/{index.js => index.ts}   |   8 +-
 .../compiler/modules/{props.js => props.ts}   |   8 +-
 .../{component-root.js => component-root.ts}  |   2 +-
 .../{component.js => component.ts}            |   5 +-
 .../recycle-list/{index.js => index.ts}       |  16 +-
 .../{recycle-list.js => recycle-list.ts}      |   3 +-
 .../modules/recycle-list/{text.js => text.ts} |  11 +-
 .../recycle-list/{v-bind.js => v-bind.ts}     |   4 +-
 .../recycle-list/{v-for.js => v-for.ts}       |   5 +-
 .../modules/recycle-list/{v-if.js => v-if.ts} |  15 +-
 .../modules/recycle-list/{v-on.js => v-on.ts} |   6 +-
 .../recycle-list/{v-once.js => v-once.ts}     |   4 +-
 .../compiler/modules/{style.js => style.ts}   |  63 ++--
 .../{entry-compiler.js => entry-compiler.ts}  |   0
 ...{entry-framework.js => entry-framework.ts} |  63 ++--
 ...me-factory.js => entry-runtime-factory.ts} |   0
 .../runtime/components/{index.js => index.ts} |   2 +-
 .../weex/runtime/components/richtext.js       |  82 -----
 .../weex/runtime/components/richtext.ts       |  90 +++++
 ...ransition-group.js => transition-group.ts} |  68 ++--
 .../{transition.js => transition.ts}          |   2 +-
 .../weex/runtime/directives/index.js          |   2 -
 .../weex/runtime/directives/index.ts          |   1 +
 .../weex/runtime/{index.js => index.ts}       |  15 +-
 .../runtime/modules/{attrs.js => attrs.ts}    |  13 +-
 .../runtime/modules/{class.js => class.ts}    |  29 +-
 .../runtime/modules/{events.js => events.ts}  |  20 +-
 .../runtime/modules/{index.js => index.ts}    |   8 +-
 .../runtime/modules/{style.js => style.ts}    |   8 +-
 .../modules/{transition.js => transition.ts}  | 118 +++++--
 .../weex/runtime/{node-ops.js => node-ops.ts} |  32 +-
 .../weex/runtime/{patch.js => patch.ts}       |   2 +-
 ...mplate.js => render-component-template.ts} |  18 +-
 ...tual-component.js => virtual-component.ts} |  37 +-
 .../runtime/{text-node.js => text-node.ts}    |   2 +-
 .../weex/util/{element.js => element.ts}      |  24 +-
 .../weex/util/{index.js => index.ts}          |   7 +-
 .../weex/util/{parser.js => parser.ts}        |  19 +-
 ...-renderer.js => create-bundle-renderer.ts} | 112 +++---
 .../bundle-renderer/create-bundle-runner.js   | 150 --------
 .../bundle-renderer/create-bundle-runner.ts   | 158 +++++++++
 ...e-map-support.js => source-map-support.ts} |  38 +-
 ...c-renderer.js => create-basic-renderer.ts} |  12 +-
 ...{create-renderer.js => create-renderer.ts} |  90 +++--
 .../{codegen.js => codegen.ts}                |  91 +++--
 .../{index.js => index.ts}                    |   4 +-
 .../{modules.js => modules.ts}                |  89 +++--
 .../{optimizer.js => optimizer.ts}            |  42 +--
 ...{runtime-helpers.js => runtime-helpers.ts} |  58 ++-
 .../{render-context.js => render-context.ts}  |  88 +++--
 .../{render-stream.js => render-stream.ts}    |  57 +--
 src/server/{render.js => render.ts}           | 116 +++---
 ...-mapper.js => create-async-file-mapper.ts} |  20 +-
 .../template-renderer/{index.js => index.ts}  | 230 ++++++------
 .../{parse-template.js => parse-template.ts}  |  19 +-
 ...{template-stream.js => template-stream.ts} |  23 +-
 src/server/{util.js => util.ts}               |   2 +-
 src/server/webpack-plugin/client.js           |  65 ----
 src/server/webpack-plugin/client.ts           |  75 ++++
 .../webpack-plugin/{server.js => server.ts}   |  27 +-
 .../webpack-plugin/{util.js => util.ts}       |  13 +-
 src/server/{write.js => write.ts}             |  25 +-
 src/sfc/{parser.js => parser.ts}              |  30 +-
 src/shared/{constants.js => constants.ts}     |  10 +-
 src/shared/{util.js => util.ts}               | 108 +++---
 tsconfig.json                                 |  43 +++
 typescript/compiler.d.ts                      | 231 ++++++++++++
 typescript/component.d.ts                     | 185 ++++++++++
 typescript/global-api.d.ts                    |  28 ++
 typescript/modules.d.ts                       |  47 +++
 typescript/options.d.ts                       |  97 +++++
 typescript/ssr.d.ts                           |  27 ++
 typescript/vnode.d.ts                         |  86 +++++
 typescript/weex.d.ts                          | 125 +++++++
 yarn.lock                                     |   8 +-
 214 files changed, 5189 insertions(+), 3508 deletions(-)
 rename src/compiler/{codeframe.js => codeframe.ts} (82%)
 rename src/compiler/codegen/{events.js => events.ts} (79%)
 rename src/compiler/codegen/{index.js => index.ts} (72%)
 rename src/compiler/{create-compiler.js => create-compiler.ts} (70%)
 rename src/compiler/directives/{bind.js => bind.ts} (54%)
 rename src/compiler/directives/{index.js => index.ts} (89%)
 rename src/compiler/directives/{model.js => model.ts} (79%)
 rename src/compiler/directives/{on.js => on.ts} (79%)
 rename src/compiler/{error-detector.js => error-detector.ts} (63%)
 rename src/compiler/{helpers.js => helpers.ts} (66%)
 rename src/compiler/{index.js => index.ts} (93%)
 rename src/compiler/{optimizer.js => optimizer.ts} (74%)
 rename src/compiler/parser/{entity-decoder.js => entity-decoder.ts} (80%)
 rename src/compiler/parser/{filter-parser.js => filter-parser.ts} (57%)
 rename src/compiler/parser/{html-parser.js => html-parser.ts} (81%)
 rename src/compiler/parser/{index.js => index.ts} (77%)
 rename src/compiler/parser/{text-parser.js => text-parser.ts} (76%)
 rename src/compiler/{to-function.js => to-function.ts} (67%)
 rename src/core/components/{index.js => index.ts} (81%)
 rename src/core/components/{keep-alive.js => keep-alive.ts} (64%)
 rename src/core/{config.js => config.ts} (69%)
 rename src/core/global-api/{assets.js => assets.ts} (78%)
 rename src/core/global-api/{extend.js => extend.ts} (84%)
 rename src/core/global-api/{index.js => index.ts} (87%)
 rename src/core/global-api/{mixin.js => mixin.ts} (65%)
 rename src/core/global-api/{use.js => use.ts} (65%)
 rename src/core/{index.js => index.ts} (87%)
 rename src/core/instance/{events.js => events.ts} (67%)
 rename src/core/instance/{index.js => index.ts} (80%)
 rename src/core/instance/{init.js => init.ts} (82%)
 rename src/core/instance/{inject.js => inject.ts} (65%)
 rename src/core/instance/{lifecycle.js => lifecycle.ts} (81%)
 rename src/core/instance/{proxy.js => proxy.ts} (52%)
 rename src/core/instance/render-helpers/{bind-dynamic-keys.js => bind-dynamic-keys.ts} (77%)
 rename src/core/instance/render-helpers/{bind-object-listeners.js => bind-object-listeners.ts} (52%)
 rename src/core/instance/render-helpers/{bind-object-props.js => bind-object-props.ts} (68%)
 rename src/core/instance/render-helpers/{check-keycodes.js => check-keycodes.ts} (86%)
 rename src/core/instance/render-helpers/{index.js => index.ts} (95%)
 rename src/core/instance/render-helpers/{render-list.js => render-list.ts} (78%)
 rename src/core/instance/render-helpers/{render-slot.js => render-slot.ts} (67%)
 rename src/core/instance/render-helpers/{render-static.js => render-static.ts} (84%)
 rename src/core/instance/render-helpers/{resolve-filter.js => resolve-filter.ts} (72%)
 rename src/core/instance/render-helpers/{resolve-scoped-slots.js => resolve-scoped-slots.ts} (62%)
 rename src/core/instance/render-helpers/{resolve-slots.js => resolve-slots.ts} (69%)
 rename src/core/instance/{render.js => render.ts} (76%)
 rename src/core/instance/{state.js => state.ts} (73%)
 rename src/core/observer/{array.js => array.ts} (92%)
 rename src/core/observer/{dep.js => dep.ts} (78%)
 rename src/core/observer/{index.js => index.ts} (77%)
 rename src/core/observer/{scheduler.js => scheduler.ts} (90%)
 rename src/core/observer/{traverse.js => traverse.ts} (80%)
 rename src/core/observer/{watcher.js => watcher.ts} (80%)
 rename src/core/util/{debug.js => debug.ts} (55%)
 rename src/core/util/{env.js => env.ts} (64%)
 rename src/core/util/{error.js => error.ts} (87%)
 rename src/core/util/{index.js => index.ts} (100%)
 rename src/core/util/{lang.js => lang.ts} (80%)
 rename src/core/util/{next-tick.js => next-tick.ts} (89%)
 rename src/core/util/{options.js => options.ts} (71%)
 rename src/core/util/{perf.js => perf.ts} (93%)
 rename src/core/util/{props.js => props.ts} (76%)
 rename src/core/vdom/{create-component.js => create-component.ts} (79%)
 rename src/core/vdom/{create-element.js => create-element.ts} (67%)
 rename src/core/vdom/{create-functional-component.js => create-functional-component.ts} (76%)
 rename src/core/vdom/helpers/{extract-props.js => extract-props.ts} (59%)
 rename src/core/vdom/helpers/{get-first-component-child.js => get-first-component-child.ts} (73%)
 rename src/core/vdom/helpers/{index.js => index.ts} (100%)
 delete mode 100644 src/core/vdom/helpers/is-async-placeholder.js
 create mode 100644 src/core/vdom/helpers/is-async-placeholder.ts
 rename src/core/vdom/helpers/{merge-hook.js => merge-hook.ts} (82%)
 rename src/core/vdom/helpers/{normalize-children.js => normalize-children.ts} (84%)
 rename src/core/vdom/helpers/{normalize-scoped-slots.js => normalize-scoped-slots.ts} (85%)
 rename src/core/vdom/helpers/{resolve-async-component.js => resolve-async-component.ts} (70%)
 rename src/core/vdom/helpers/{update-listeners.js => update-listeners.ts} (63%)
 rename src/core/vdom/modules/{directives.js => directives.ts} (76%)
 rename src/core/vdom/modules/{index.js => index.ts} (61%)
 rename src/core/vdom/modules/{ref.js => ref.ts} (65%)
 rename src/core/vdom/{patch.js => patch.ts} (74%)
 rename src/core/vdom/{vnode.js => vnode.ts} (57%)
 rename src/platforms/web/compiler/directives/{html.js => html.ts} (66%)
 rename src/platforms/web/compiler/directives/{index.js => index.ts} (93%)
 rename src/platforms/web/compiler/directives/{model.js => model.ts} (74%)
 rename src/platforms/web/compiler/directives/{text.js => text.ts} (67%)
 rename src/platforms/web/compiler/{index.js => index.ts} (100%)
 rename src/platforms/web/compiler/modules/{class.js => class.ts} (67%)
 rename src/platforms/web/compiler/modules/{index.js => index.ts} (65%)
 rename src/platforms/web/compiler/modules/{model.js => model.ts} (88%)
 rename src/platforms/web/compiler/modules/{style.js => style.ts} (69%)
 rename src/platforms/web/compiler/{options.js => options.ts} (84%)
 rename src/platforms/web/compiler/{util.js => util.ts} (67%)
 rename src/platforms/web/{entry-compiler.js => entry-compiler.ts} (100%)
 rename src/platforms/web/{entry-runtime-with-compiler.js => entry-runtime-with-compiler.ts} (75%)
 rename src/platforms/web/{entry-runtime.js => entry-runtime.ts} (100%)
 rename src/platforms/web/{entry-server-basic-renderer.js => entry-server-basic-renderer.ts} (88%)
 delete mode 100644 src/platforms/web/entry-server-renderer.js
 create mode 100644 src/platforms/web/entry-server-renderer.ts
 rename src/platforms/web/runtime/{class-util.js => class-util.ts} (82%)
 rename src/platforms/web/runtime/components/{index.js => index.ts} (86%)
 rename src/platforms/web/runtime/components/{transition-group.js => transition-group.ts} (75%)
 rename src/platforms/web/runtime/components/{transition.js => transition.ts} (68%)
 rename src/platforms/web/runtime/directives/{index.js => index.ts} (91%)
 rename src/platforms/web/runtime/directives/{model.js => model.ts} (77%)
 rename src/platforms/web/runtime/directives/{show.js => show.ts} (71%)
 rename src/platforms/web/runtime/{index.js => index.ts} (86%)
 rename src/platforms/web/runtime/modules/{attrs.js => attrs.ts} (85%)
 rename src/platforms/web/runtime/modules/{class.js => class.ts} (60%)
 rename src/platforms/web/runtime/modules/{dom-props.js => dom-props.ts} (81%)
 rename src/platforms/web/runtime/modules/{events.js => events.ts} (87%)
 rename src/platforms/web/runtime/modules/{index.js => index.ts} (69%)
 rename src/platforms/web/runtime/modules/{style.js => style.ts} (75%)
 rename src/platforms/web/runtime/modules/{transition.js => transition.ts} (74%)
 delete mode 100644 src/platforms/web/runtime/node-ops.js
 create mode 100644 src/platforms/web/runtime/node-ops.ts
 rename src/platforms/web/runtime/{patch.js => patch.ts} (100%)
 rename src/platforms/web/runtime/{transition-util.js => transition-util.ts} (62%)
 rename src/platforms/web/server/{compiler.js => compiler.ts} (70%)
 rename src/platforms/web/server/directives/{index.js => index.ts} (90%)
 rename src/platforms/web/server/directives/{model.js => model.ts} (82%)
 rename src/platforms/web/server/directives/{show.js => show.ts} (61%)
 rename src/platforms/web/server/modules/{attrs.js => attrs.ts} (78%)
 rename src/platforms/web/server/modules/{class.js => class.ts} (62%)
 rename src/platforms/web/server/modules/{dom-props.js => dom-props.ts} (89%)
 rename src/platforms/web/server/modules/{index.js => index.ts} (67%)
 rename src/platforms/web/server/modules/{style.js => style.ts} (84%)
 delete mode 100644 src/platforms/web/server/util.js
 create mode 100644 src/platforms/web/server/util.ts
 rename src/platforms/web/util/{attrs.js => attrs.ts} (62%)
 rename src/platforms/web/util/{class.js => class.ts} (53%)
 rename src/platforms/web/util/{compat.js => compat.ts} (77%)
 delete mode 100644 src/platforms/web/util/element.js
 create mode 100644 src/platforms/web/util/element.ts
 rename src/platforms/web/util/{index.js => index.ts} (72%)
 rename src/platforms/web/util/{style.js => style.ts} (71%)
 rename src/platforms/weex/compiler/directives/{index.js => index.ts} (84%)
 mode change 100755 => 100644
 rename src/platforms/weex/compiler/directives/{model.js => model.ts} (82%)
 rename src/platforms/weex/compiler/{index.js => index.ts} (86%)
 rename src/platforms/weex/compiler/modules/{append.js => append.ts} (72%)
 rename src/platforms/weex/compiler/modules/{class.js => class.ts} (63%)
 rename src/platforms/weex/compiler/modules/{index.js => index.ts} (69%)
 rename src/platforms/weex/compiler/modules/{props.js => props.ts} (85%)
 rename src/platforms/weex/compiler/modules/recycle-list/{component-root.js => component-root.ts} (81%)
 rename src/platforms/weex/compiler/modules/recycle-list/{component.js => component.ts} (72%)
 rename src/platforms/weex/compiler/modules/recycle-list/{index.js => index.ts} (72%)
 rename src/platforms/weex/compiler/modules/recycle-list/{recycle-list.js => recycle-list.ts} (92%)
 rename src/platforms/weex/compiler/modules/recycle-list/{text.js => text.ts} (69%)
 rename src/platforms/weex/compiler/modules/recycle-list/{v-bind.js => v-bind.ts} (83%)
 rename src/platforms/weex/compiler/modules/recycle-list/{v-for.js => v-for.ts} (80%)
 rename src/platforms/weex/compiler/modules/recycle-list/{v-if.js => v-if.ts} (78%)
 rename src/platforms/weex/compiler/modules/recycle-list/{v-on.js => v-on.ts} (77%)
 rename src/platforms/weex/compiler/modules/recycle-list/{v-once.js => v-once.ts} (74%)
 rename src/platforms/weex/compiler/modules/{style.js => style.ts} (57%)
 rename src/platforms/weex/{entry-compiler.js => entry-compiler.ts} (100%)
 rename src/platforms/weex/{entry-framework.js => entry-framework.ts} (78%)
 rename src/platforms/weex/{entry-runtime-factory.js => entry-runtime-factory.ts} (100%)
 rename src/platforms/weex/runtime/components/{index.js => index.ts} (89%)
 delete mode 100644 src/platforms/weex/runtime/components/richtext.js
 create mode 100644 src/platforms/weex/runtime/components/richtext.ts
 rename src/platforms/weex/runtime/components/{transition-group.js => transition-group.ts} (73%)
 rename src/platforms/weex/runtime/components/{transition.js => transition.ts} (89%)
 delete mode 100755 src/platforms/weex/runtime/directives/index.js
 create mode 100644 src/platforms/weex/runtime/directives/index.ts
 rename src/platforms/weex/runtime/{index.js => index.ts} (80%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/modules/{attrs.js => attrs.ts} (71%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/modules/{class.js => class.ts} (71%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/modules/{events.js => events.ts} (69%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/modules/{index.js => index.ts} (68%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/modules/{style.js => style.ts} (90%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/modules/{transition.js => transition.ts} (70%)
 rename src/platforms/weex/runtime/{node-ops.js => node-ops.ts} (59%)
 mode change 100755 => 100644
 rename src/platforms/weex/runtime/{patch.js => patch.ts} (94%)
 rename src/platforms/weex/runtime/recycle-list/{render-component-template.js => render-component-template.ts} (55%)
 rename src/platforms/weex/runtime/recycle-list/{virtual-component.js => virtual-component.ts} (81%)
 rename src/platforms/weex/runtime/{text-node.js => text-node.ts} (77%)
 rename src/platforms/weex/util/{element.js => element.ts} (58%)
 rename src/platforms/weex/util/{index.js => index.ts} (88%)
 mode change 100755 => 100644
 rename src/platforms/weex/util/{parser.js => parser.ts} (75%)
 rename src/server/bundle-renderer/{create-bundle-renderer.js => create-bundle-renderer.ts} (57%)
 delete mode 100644 src/server/bundle-renderer/create-bundle-runner.js
 create mode 100644 src/server/bundle-renderer/create-bundle-runner.ts
 rename src/server/bundle-renderer/{source-map-support.js => source-map-support.ts} (52%)
 rename src/server/{create-basic-renderer.js => create-basic-renderer.ts} (74%)
 rename src/server/{create-renderer.js => create-renderer.ts} (62%)
 rename src/server/optimizing-compiler/{codegen.js => codegen.ts} (78%)
 rename src/server/optimizing-compiler/{index.js => index.ts} (90%)
 rename src/server/optimizing-compiler/{modules.js => modules.ts} (52%)
 rename src/server/optimizing-compiler/{optimizer.js => optimizer.ts} (77%)
 rename src/server/optimizing-compiler/{runtime-helpers.js => runtime-helpers.ts} (73%)
 rename src/server/{render-context.js => render-context.ts} (67%)
 rename src/server/{render-stream.js => render-stream.ts} (63%)
 rename src/server/{render.js => render.ts} (80%)
 rename src/server/template-renderer/{create-async-file-mapper.js => create-async-file-mapper.ts} (74%)
 rename src/server/template-renderer/{index.js => index.ts} (53%)
 rename src/server/template-renderer/{parse-template.js => parse-template.ts} (67%)
 rename src/server/template-renderer/{template-stream.js => template-stream.ts} (81%)
 rename src/server/{util.js => util.ts} (91%)
 delete mode 100644 src/server/webpack-plugin/client.js
 create mode 100644 src/server/webpack-plugin/client.ts
 rename src/server/webpack-plugin/{server.js => server.ts} (76%)
 rename src/server/webpack-plugin/{util.js => util.ts} (66%)
 rename src/server/{write.js => write.ts} (66%)
 rename src/sfc/{parser.js => parser.ts} (83%)
 rename src/shared/{constants.js => constants.ts} (71%)
 rename src/shared/{util.js => util.ts} (70%)
 create mode 100644 tsconfig.json
 create mode 100644 typescript/compiler.d.ts
 create mode 100644 typescript/component.d.ts
 create mode 100644 typescript/global-api.d.ts
 create mode 100644 typescript/modules.d.ts
 create mode 100644 typescript/options.d.ts
 create mode 100644 typescript/ssr.d.ts
 create mode 100644 typescript/vnode.d.ts
 create mode 100644 typescript/weex.d.ts

diff --git a/package.json b/package.json
index 7d40666d05c..62d894d5bdb 100644
--- a/package.json
+++ b/package.json
@@ -136,7 +136,7 @@
     "serialize-javascript": "^3.1.0",
     "shelljs": "^0.8.1",
     "terser": "^3.10.2",
-    "typescript": "^3.6.4",
+    "typescript": "^4.2.2",
     "webpack": "~4.28.4",
     "weex-js-runtime": "^0.23.6",
     "weex-styler": "^0.3.0",
diff --git a/src/compiler/codeframe.js b/src/compiler/codeframe.ts
similarity index 82%
rename from src/compiler/codeframe.js
rename to src/compiler/codeframe.ts
index 513d318fcc1..037e07ea23c 100644
--- a/src/compiler/codeframe.js
+++ b/src/compiler/codeframe.ts
@@ -2,20 +2,22 @@
 
 const range = 2
 
-export function generateCodeFrame (
+export function generateCodeFrame(
   source: string,
   start: number = 0,
   end: number = source.length
 ): string {
   const lines = source.split(/\r?\n/)
   let count = 0
-  const res = []
+  const res: string[] = []
   for (let i = 0; i < lines.length; i++) {
     count += lines[i].length + 1
     if (count >= start) {
       for (let j = i - range; j <= i + range || end > count; j++) {
         if (j < 0 || j >= lines.length) continue
-        res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`)
+        res.push(
+          `${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`
+        )
         const lineLength = lines[j].length
         if (j === i) {
           // push underline
@@ -36,10 +38,11 @@ export function generateCodeFrame (
   return res.join('\n')
 }
 
-function repeat (str, n) {
+function repeat(str, n) {
   let result = ''
   if (n > 0) {
-    while (true) { // eslint-disable-line
+    while (true) {
+      // eslint-disable-line
       if (n & 1) result += str
       n >>>= 1
       if (n <= 0) break
diff --git a/src/compiler/codegen/events.js b/src/compiler/codegen/events.ts
similarity index 79%
rename from src/compiler/codegen/events.js
rename to src/compiler/codegen/events.ts
index 4b0776115a0..8e4a747d3fc 100644
--- a/src/compiler/codegen/events.js
+++ b/src/compiler/codegen/events.ts
@@ -1,5 +1,7 @@
 /* @flow */
 
+import { __WEEX__ } from 'typescript/weex'
+
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
 const fnInvokeRE = /\([^)]*?\);*$/
 const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
@@ -14,7 +16,7 @@ const keyCodes: { [key: string]: number | Array<number> } = {
   left: 37,
   right: 39,
   down: 40,
-  'delete': [8, 46]
+  delete: [8, 46],
 }
 
 // KeyboardEvent.key aliases
@@ -31,13 +33,13 @@ const keyNames: { [key: string]: string | Array<string> } = {
   right: ['Right', 'ArrowRight'],
   down: ['Down', 'ArrowDown'],
   // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+  delete: ['Backspace', 'Delete', 'Del'],
 }
 
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-const genGuard = condition => `if(${condition})return null;`
+const genGuard = (condition) => `if(${condition})return null;`
 
 const modifierCode: { [key: string]: string } = {
   stop: '$event.stopPropagation();',
@@ -49,10 +51,10 @@ const modifierCode: { [key: string]: string } = {
   meta: genGuard(`!$event.metaKey`),
   left: genGuard(`'button' in $event && $event.button !== 0`),
   middle: genGuard(`'button' in $event && $event.button !== 1`),
-  right: genGuard(`'button' in $event && $event.button !== 2`)
+  right: genGuard(`'button' in $event && $event.button !== 2`),
 }
 
-export function genHandlers (
+export function genHandlers(
   events: ASTElementHandlers,
   isNative: boolean
 ): string {
@@ -61,6 +63,7 @@ export function genHandlers (
   let dynamicHandlers = ``
   for (const name in events) {
     const handlerCode = genHandler(events[name])
+    //@ts-expect-error
     if (events[name] && events[name].dynamic) {
       dynamicHandlers += `${name},${handlerCode},`
     } else {
@@ -77,34 +80,42 @@ export function genHandlers (
 
 // Generate handler code with binding params on Weex
 /* istanbul ignore next */
-function genWeexHandler (params: Array<any>, handlerCode: string) {
+function genWeexHandler(params: Array<any>, handlerCode: string) {
   let innerHandlerCode = handlerCode
-  const exps = params.filter(exp => simplePathRE.test(exp) && exp !== '$event')
-  const bindings = exps.map(exp => ({ '@binding': exp }))
+  const exps = params.filter(
+    (exp) => simplePathRE.test(exp) && exp !== '$event'
+  )
+  const bindings = exps.map((exp) => ({ '@binding': exp }))
   const args = exps.map((exp, i) => {
     const key = `$_${i + 1}`
     innerHandlerCode = innerHandlerCode.replace(exp, key)
     return key
   })
   args.push('$event')
-  return '{\n' +
+  return (
+    '{\n' +
     `handler:function(${args.join(',')}){${innerHandlerCode}},\n` +
     `params:${JSON.stringify(bindings)}\n` +
     '}'
+  )
 }
 
-function genHandler (handler: ASTElementHandler | Array<ASTElementHandler>): string {
+function genHandler(
+  handler: ASTElementHandler | Array<ASTElementHandler>
+): string {
   if (!handler) {
     return 'function(){}'
   }
 
   if (Array.isArray(handler)) {
-    return `[${handler.map(handler => genHandler(handler)).join(',')}]`
+    return `[${handler.map((handler) => genHandler(handler)).join(',')}]`
   }
 
   const isMethodPath = simplePathRE.test(handler.value)
   const isFunctionExpression = fnExpRE.test(handler.value)
-  const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''))
+  const isFunctionInvocation = simplePathRE.test(
+    handler.value.replace(fnInvokeRE, '')
+  )
 
   if (!handler.modifiers) {
     if (isMethodPath || isFunctionExpression) {
@@ -120,7 +131,7 @@ function genHandler (handler: ASTElementHandler | Array<ASTElementHandler>): str
   } else {
     let code = ''
     let genModifierCode = ''
-    const keys = []
+    const keys: string[] = []
     for (const key in handler.modifiers) {
       if (modifierCode[key]) {
         genModifierCode += modifierCode[key]
@@ -129,11 +140,11 @@ function genHandler (handler: ASTElementHandler | Array<ASTElementHandler>): str
           keys.push(key)
         }
       } else if (key === 'exact') {
-        const modifiers: ASTModifiers = (handler.modifiers: any)
+        const modifiers = handler.modifiers
         genModifierCode += genGuard(
           ['ctrl', 'shift', 'alt', 'meta']
-            .filter(keyModifier => !modifiers[keyModifier])
-            .map(keyModifier => `$event.${keyModifier}Key`)
+            .filter((keyModifier) => !modifiers[keyModifier])
+            .map((keyModifier) => `$event.${keyModifier}Key`)
             .join('||')
         )
       } else {
@@ -150,10 +161,10 @@ function genHandler (handler: ASTElementHandler | Array<ASTElementHandler>): str
     const handlerCode = isMethodPath
       ? `return ${handler.value}.apply(null, arguments)`
       : isFunctionExpression
-        ? `return (${handler.value}).apply(null, arguments)`
-        : isFunctionInvocation
-          ? `return ${handler.value}`
-          : handler.value
+      ? `return (${handler.value}).apply(null, arguments)`
+      : isFunctionInvocation
+      ? `return ${handler.value}`
+      : handler.value
     /* istanbul ignore if */
     if (__WEEX__ && handler.params) {
       return genWeexHandler(handler.params, code + handlerCode)
@@ -162,7 +173,7 @@ function genHandler (handler: ASTElementHandler | Array<ASTElementHandler>): str
   }
 }
 
-function genKeyFilter (keys: Array<string>): string {
+function genKeyFilter(keys: Array<string>): string {
   return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
@@ -172,7 +183,7 @@ function genKeyFilter (keys: Array<string>): string {
   )
 }
 
-function genFilterCode (key: string): string {
+function genFilterCode(key: string): string {
   const keyVal = parseInt(key, 10)
   if (keyVal) {
     return `$event.keyCode!==${keyVal}`
diff --git a/src/compiler/codegen/index.js b/src/compiler/codegen/index.ts
similarity index 72%
rename from src/compiler/codegen/index.js
rename to src/compiler/codegen/index.ts
index c4f0195c7ff..e7cc7bd1185 100644
--- a/src/compiler/codegen/index.js
+++ b/src/compiler/codegen/index.ts
@@ -6,29 +6,35 @@ import { camelize, no, extend } from 'shared/util'
 import { baseWarn, pluckModuleFunction } from '../helpers'
 import { emptySlotScopeToken } from '../parser/index'
 
-type TransformFunction = (el: ASTElement, code: string) => string;
-type DataGenFunction = (el: ASTElement) => string;
-type DirectiveFunction = (el: ASTElement, dir: ASTDirective, warn: Function) => boolean;
+type TransformFunction = (el: ASTElement, code: string) => string
+type DataGenFunction = (el: ASTElement) => string
+type DirectiveFunction = (
+  el: ASTElement,
+  dir: ASTDirective,
+  warn: Function
+) => boolean
 
 export class CodegenState {
-  options: CompilerOptions;
-  warn: Function;
-  transforms: Array<TransformFunction>;
-  dataGenFns: Array<DataGenFunction>;
-  directives: { [key: string]: DirectiveFunction };
-  maybeComponent: (el: ASTElement) => boolean;
-  onceId: number;
-  staticRenderFns: Array<string>;
-  pre: boolean;
-
-  constructor (options: CompilerOptions) {
+  options: CompilerOptions
+  warn: Function
+  transforms: Array<TransformFunction>
+  dataGenFns: Array<DataGenFunction>
+  directives: { [key: string]: DirectiveFunction }
+  maybeComponent: (el: ASTElement) => boolean
+  onceId: number
+  staticRenderFns: Array<string>
+  pre: boolean
+
+  constructor(options: CompilerOptions) {
     this.options = options
     this.warn = options.warn || baseWarn
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
     this.transforms = pluckModuleFunction(options.modules, 'transformCode')
     this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
     this.directives = extend(extend({}, baseDirectives), options.directives)
     const isReservedTag = options.isReservedTag || no
-    this.maybeComponent = (el: ASTElement) => !!el.component || !isReservedTag(el.tag)
+    this.maybeComponent = (el: ASTElement) =>
+      !!el.component || !isReservedTag(el.tag)
     this.onceId = 0
     this.staticRenderFns = []
     this.pre = false
@@ -36,24 +42,28 @@ export class CodegenState {
 }
 
 export type CodegenResult = {
-  render: string,
+  render: string
   staticRenderFns: Array<string>
-};
+}
 
-export function generate (
+export function generate(
   ast: ASTElement | void,
   options: CompilerOptions
 ): CodegenResult {
   const state = new CodegenState(options)
   // fix #11483, Root level <script> tags should not be rendered.
-  const code = ast ? (ast.tag === 'script' ? 'null' : genElement(ast, state)) : '_c("div")'
+  const code = ast
+    ? ast.tag === 'script'
+      ? 'null'
+      : genElement(ast, state)
+    : '_c("div")'
   return {
     render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns
+    staticRenderFns: state.staticRenderFns,
   }
 }
 
-export function genElement (el: ASTElement, state: CodegenState): string {
+export function genElement(el: ASTElement, state: CodegenState): string {
   if (el.parent) {
     el.pre = el.pre || el.parent.pre
   }
@@ -97,7 +107,7 @@ export function genElement (el: ASTElement, state: CodegenState): string {
 }
 
 // hoist static sub-trees out
-function genStatic (el: ASTElement, state: CodegenState): string {
+function genStatic(el: ASTElement, state: CodegenState): string {
   el.staticProcessed = true
   // Some elements (templates) need to behave differently inside of a v-pre
   // node.  All pre nodes are static roots, so we can use this as a location to
@@ -108,15 +118,13 @@ function genStatic (el: ASTElement, state: CodegenState): string {
   }
   state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`)
   state.pre = originalPreState
-  return `_m(${
-    state.staticRenderFns.length - 1
-  }${
+  return `_m(${state.staticRenderFns.length - 1}${
     el.staticInFor ? ',true' : ''
   })`
 }
 
 // v-once
-function genOnce (el: ASTElement, state: CodegenState): string {
+function genOnce(el: ASTElement, state: CodegenState): string {
   el.onceProcessed = true
   if (el.if && !el.ifProcessed) {
     return genIf(el, state)
@@ -125,16 +133,17 @@ function genOnce (el: ASTElement, state: CodegenState): string {
     let parent = el.parent
     while (parent) {
       if (parent.for) {
-        key = parent.key
+        key = parent.key!
         break
       }
       parent = parent.parent
     }
     if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        `v-once can only be used inside v-for that is keyed. `,
-        el.rawAttrsMap['v-once']
-      )
+      process.env.NODE_ENV !== 'production' &&
+        state.warn(
+          `v-once can only be used inside v-for that is keyed. `,
+          el.rawAttrsMap['v-once']
+        )
       return genElement(el, state)
     }
     return `_o(${genElement(el, state)},${state.onceId++},${key})`
@@ -143,7 +152,7 @@ function genOnce (el: ASTElement, state: CodegenState): string {
   }
 }
 
-export function genIf (
+export function genIf(
   el: any,
   state: CodegenState,
   altGen?: Function,
@@ -153,7 +162,7 @@ export function genIf (
   return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
 }
 
-function genIfConditions (
+function genIfConditions(
   conditions: ASTIfConditions,
   state: CodegenState,
   altGen?: Function,
@@ -163,28 +172,26 @@ function genIfConditions (
     return altEmpty || '_e()'
   }
 
-  const condition = conditions.shift()
+  const condition = conditions.shift()!
   if (condition.exp) {
-    return `(${condition.exp})?${
-      genTernaryExp(condition.block)
-    }:${
-      genIfConditions(conditions, state, altGen, altEmpty)
-    }`
+    return `(${condition.exp})?${genTernaryExp(
+      condition.block
+    )}:${genIfConditions(conditions, state, altGen, altEmpty)}`
   } else {
     return `${genTernaryExp(condition.block)}`
   }
 
   // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
+  function genTernaryExp(el) {
     return altGen
       ? altGen(el, state)
       : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
+      ? genOnce(el, state)
+      : genElement(el, state)
   }
 }
 
-export function genFor (
+export function genFor(
   el: any,
   state: CodegenState,
   altGen?: Function,
@@ -195,7 +202,8 @@ export function genFor (
   const iterator1 = el.iterator1 ? `,${el.iterator1}` : ''
   const iterator2 = el.iterator2 ? `,${el.iterator2}` : ''
 
-  if (process.env.NODE_ENV !== 'production' &&
+  if (
+    process.env.NODE_ENV !== 'production' &&
     state.maybeComponent(el) &&
     el.tag !== 'slot' &&
     el.tag !== 'template' &&
@@ -203,21 +211,23 @@ export function genFor (
   ) {
     state.warn(
       `<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-      `v-for should have explicit keys. ` +
-      `See https://vuejs.org/guide/list.html#key for more info.`,
+        `v-for should have explicit keys. ` +
+        `See https://vuejs.org/guide/list.html#key for more info.`,
       el.rawAttrsMap['v-for'],
       true /* tip */
     )
   }
 
   el.forProcessed = true // avoid recursion
-  return `${altHelper || '_l'}((${exp}),` +
+  return (
+    `${altHelper || '_l'}((${exp}),` +
     `function(${alias}${iterator1}${iterator2}){` +
-      `return ${(altGen || genElement)(el, state)}` +
+    `return ${(altGen || genElement)(el, state)}` +
     '})'
+  )
 }
 
-export function genData (el: ASTElement, state: CodegenState): string {
+export function genData(el: ASTElement, state: CodegenState): string {
   let data = '{'
 
   // directives first.
@@ -274,13 +284,7 @@ export function genData (el: ASTElement, state: CodegenState): string {
   }
   // component v-model
   if (el.model) {
-    data += `model:{value:${
-      el.model.value
-    },callback:${
-      el.model.callback
-    },expression:${
-      el.model.expression
-    }},`
+    data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`
   }
   // inline-template
   if (el.inlineTemplate) {
@@ -307,7 +311,7 @@ export function genData (el: ASTElement, state: CodegenState): string {
   return data
 }
 
-function genDirectives (el: ASTElement, state: CodegenState): string | void {
+function genDirectives(el: ASTElement, state: CodegenState): string | void {
   const dirs = el.directives
   if (!dirs) return
   let res = 'directives:['
@@ -325,10 +329,10 @@ function genDirectives (el: ASTElement, state: CodegenState): string | void {
     if (needRuntime) {
       hasRuntime = true
       res += `{name:"${dir.name}",rawName:"${dir.rawName}"${
-        dir.value ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}` : ''
-      }${
-        dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''
-      }${
+        dir.value
+          ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+          : ''
+      }${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${
         dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''
       }},`
     }
@@ -338,11 +342,15 @@ function genDirectives (el: ASTElement, state: CodegenState): string | void {
   }
 }
 
-function genInlineTemplate (el: ASTElement, state: CodegenState): ?string {
+function genInlineTemplate(
+  el: ASTElement,
+  state: CodegenState
+): string | undefined {
   const ast = el.children[0]
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    (el.children.length !== 1 || ast.type !== 1)
+  ) {
     state.warn(
       'Inline-template components must have exactly one child element.',
       { start: el.start }
@@ -352,13 +360,13 @@ function genInlineTemplate (el: ASTElement, state: CodegenState): ?string {
     const inlineRenderFns = generate(ast, state.options)
     return `inlineTemplate:{render:function(){${
       inlineRenderFns.render
-    }},staticRenderFns:[${
-      inlineRenderFns.staticRenderFns.map(code => `function(){${code}}`).join(',')
-    }]}`
+    }},staticRenderFns:[${inlineRenderFns.staticRenderFns
+      .map((code) => `function(){${code}}`)
+      .join(',')}]}`
   }
 }
 
-function genScopedSlots (
+function genScopedSlots(
   el: ASTElement,
   slots: { [key: string]: ASTElement },
   state: CodegenState
@@ -367,15 +375,14 @@ function genScopedSlots (
   // components with only scoped slots to skip forced updates from parent.
   // but in some cases we have to bail-out of this optimization
   // for example if the slot contains dynamic names, has v-if or v-for on them...
-  let needsForceUpdate = el.for || Object.keys(slots).some(key => {
-    const slot = slots[key]
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  })
+  let needsForceUpdate =
+    el.for ||
+    Object.keys(slots).some((key) => {
+      const slot = slots[key]
+      return (
+        slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+      )
+    })
 
   // #9534: if a component with scoped slots is inside a conditional branch,
   // it's possible for the same component to be reused but with different
@@ -406,7 +413,7 @@ function genScopedSlots (
   }
 
   const generatedSlots = Object.keys(slots)
-    .map(key => genScopedSlot(slots[key], state))
+    .map((key) => genScopedSlot(slots[key], state))
     .join(',')
 
   return `scopedSlots:_u([${generatedSlots}]${
@@ -419,13 +426,13 @@ function genScopedSlots (
 function hash(str) {
   let hash = 5381
   let i = str.length
-  while(i) {
+  while (i) {
     hash = (hash * 33) ^ str.charCodeAt(--i)
   }
   return hash >>> 0
 }
 
-function containsSlotChild (el: ASTNode): boolean {
+function containsSlotChild(el: ASTNode): boolean {
   if (el.type === 1) {
     if (el.tag === 'slot') {
       return true
@@ -435,10 +442,7 @@ function containsSlotChild (el: ASTNode): boolean {
   return false
 }
 
-function genScopedSlot (
-  el: ASTElement,
-  state: CodegenState
-): string {
+function genScopedSlot(el: ASTElement, state: CodegenState): string {
   const isLegacySyntax = el.attrsMap['slot-scope']
   if (el.if && !el.ifProcessed && !isLegacySyntax) {
     return genIf(el, state, genScopedSlot, `null`)
@@ -446,22 +450,23 @@ function genScopedSlot (
   if (el.for && !el.forProcessed) {
     return genFor(el, state, genScopedSlot)
   }
-  const slotScope = el.slotScope === emptySlotScopeToken
-    ? ``
-    : String(el.slotScope)
-  const fn = `function(${slotScope}){` +
-    `return ${el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)
+  const slotScope =
+    el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope)
+  const fn =
+    `function(${slotScope}){` +
+    `return ${
+      el.tag === 'template'
+        ? el.if && isLegacySyntax
+          ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+          : genChildren(el, state) || 'undefined'
+        : genElement(el, state)
     }}`
   // reverse proxy v-slot without scope on this.$slots
   const reverseProxy = slotScope ? `` : `,proxy:true`
   return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`
 }
 
-export function genChildren (
+export function genChildren(
   el: ASTElement,
   state: CodegenState,
   checkSkip?: boolean,
@@ -472,13 +477,16 @@ export function genChildren (
   if (children.length) {
     const el: any = children[0]
     // optimize single v-for
-    if (children.length === 1 &&
+    if (
+      children.length === 1 &&
       el.for &&
       el.tag !== 'template' &&
       el.tag !== 'slot'
     ) {
       const normalizationType = checkSkip
-        ? state.maybeComponent(el) ? `,1` : `,0`
+        ? state.maybeComponent(el)
+          ? `,1`
+          : `,0`
         : ``
       return `${(altGenElement || genElement)(el, state)}${normalizationType}`
     }
@@ -486,7 +494,7 @@ export function genChildren (
       ? getNormalizationType(children, state.maybeComponent)
       : 0
     const gen = altGenNode || genNode
-    return `[${children.map(c => gen(c, state)).join(',')}]${
+    return `[${children.map((c) => gen(c, state)).join(',')}]${
       normalizationType ? `,${normalizationType}` : ''
     }`
   }
@@ -496,7 +504,7 @@ export function genChildren (
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
+function getNormalizationType(
   children: Array<ASTNode>,
   maybeComponent: (el: ASTElement) => boolean
 ): number {
@@ -506,24 +514,29 @@ function getNormalizationType (
     if (el.type !== 1) {
       continue
     }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(c => needsNormalization(c.block)))) {
+    if (
+      needsNormalization(el) ||
+      (el.ifConditions &&
+        el.ifConditions.some((c) => needsNormalization(c.block)))
+    ) {
       res = 2
       break
     }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(c => maybeComponent(c.block)))) {
+    if (
+      maybeComponent(el) ||
+      (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))
+    ) {
       res = 1
     }
   }
   return res
 }
 
-function needsNormalization (el: ASTElement): boolean {
+function needsNormalization(el: ASTElement): boolean {
   return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
 }
 
-function genNode (node: ASTNode, state: CodegenState): string {
+function genNode(node: ASTNode, state: CodegenState): string {
   if (node.type === 1) {
     return genElement(node, state)
   } else if (node.type === 3 && node.isComment) {
@@ -533,29 +546,33 @@ function genNode (node: ASTNode, state: CodegenState): string {
   }
 }
 
-export function genText (text: ASTText | ASTExpression): string {
-  return `_v(${text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))
+export function genText(text: ASTText | ASTExpression): string {
+  return `_v(${
+    text.type === 2
+      ? text.expression // no need for () because already wrapped in _s()
+      : transformSpecialNewlines(JSON.stringify(text.text))
   })`
 }
 
-export function genComment (comment: ASTText): string {
+export function genComment(comment: ASTText): string {
   return `_e(${JSON.stringify(comment.text)})`
 }
 
-function genSlot (el: ASTElement, state: CodegenState): string {
+function genSlot(el: ASTElement, state: CodegenState): string {
   const slotName = el.slotName || '"default"'
   const children = genChildren(el, state)
   let res = `_t(${slotName}${children ? `,${children}` : ''}`
-  const attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      })))
-    : null
+  const attrs =
+    el.attrs || el.dynamicAttrs
+      ? genProps(
+          (el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+          }))
+        )
+      : null
   const bind = el.attrsMap['v-bind']
   if ((attrs || bind) && !children) {
     res += `,null`
@@ -570,7 +587,7 @@ function genSlot (el: ASTElement, state: CodegenState): string {
 }
 
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
+function genComponent(
   componentName: string,
   el: ASTElement,
   state: CodegenState
@@ -581,7 +598,7 @@ function genComponent (
   })`
 }
 
-function genProps (props: Array<ASTAttr>): string {
+function genProps(props: Array<ASTAttr>): string {
   let staticProps = ``
   let dynamicProps = ``
   for (let i = 0; i < props.length; i++) {
@@ -604,7 +621,7 @@ function genProps (props: Array<ASTAttr>): string {
 }
 
 /* istanbul ignore next */
-function generateValue (value) {
+function generateValue(value) {
   if (typeof value === 'string') {
     return transformSpecialNewlines(value)
   }
@@ -612,8 +629,6 @@ function generateValue (value) {
 }
 
 // #3895, #4268
-function transformSpecialNewlines (text: string): string {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text: string): string {
+  return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
 }
diff --git a/src/compiler/create-compiler.js b/src/compiler/create-compiler.ts
similarity index 70%
rename from src/compiler/create-compiler.js
rename to src/compiler/create-compiler.ts
index 67d2057adf9..6f5f2b9493d 100644
--- a/src/compiler/create-compiler.js
+++ b/src/compiler/create-compiler.ts
@@ -4,24 +4,27 @@ import { extend } from 'shared/util'
 import { detectErrors } from './error-detector'
 import { createCompileToFunctionFn } from './to-function'
 
-export function createCompilerCreator (baseCompile: Function): Function {
-  return function createCompiler (baseOptions: CompilerOptions) {
-    function compile (
+export function createCompilerCreator(baseCompile: Function): Function {
+  return function createCompiler(baseOptions: CompilerOptions) {
+    function compile(
       template: string,
       options?: CompilerOptions
     ): CompiledResult {
       const finalOptions = Object.create(baseOptions)
-      const errors = []
-      const tips = []
+      const errors: WarningMessage[] = []
+      const tips: WarningMessage[] = []
 
       let warn = (msg, range, tip) => {
-        (tip ? tips : errors).push(msg)
+        ;(tip ? tips : errors).push(msg)
       }
 
       if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          options.outputSourceRange
+        ) {
           // $flow-disable-line
-          const leadingSpaceLength = template.match(/^\s*/)[0].length
+          const leadingSpaceLength = template.match(/^\s*/)![0].length
 
           warn = (msg, range, tip) => {
             const data: WarningMessage = { msg }
@@ -33,13 +36,14 @@ export function createCompilerCreator (baseCompile: Function): Function {
                 data.end = range.end + leadingSpaceLength
               }
             }
-            (tip ? tips : errors).push(data)
+            ;(tip ? tips : errors).push(data)
           }
         }
         // merge custom modules
         if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules)
+          finalOptions.modules = (baseOptions.modules || []).concat(
+            options.modules
+          )
         }
         // merge custom directives
         if (options.directives) {
@@ -69,7 +73,7 @@ export function createCompilerCreator (baseCompile: Function): Function {
 
     return {
       compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
+      compileToFunctions: createCompileToFunctionFn(compile),
     }
   }
 }
diff --git a/src/compiler/directives/bind.js b/src/compiler/directives/bind.ts
similarity index 54%
rename from src/compiler/directives/bind.js
rename to src/compiler/directives/bind.ts
index e103572729e..7bf69426d0c 100644
--- a/src/compiler/directives/bind.js
+++ b/src/compiler/directives/bind.ts
@@ -1,11 +1,9 @@
 /* @flow */
 
-export default function bind (el: ASTElement, dir: ASTDirective) {
+export default function bind(el: ASTElement, dir: ASTDirective) {
   el.wrapData = (code: string) => {
     return `_b(${code},'${el.tag}',${dir.value},${
       dir.modifiers && dir.modifiers.prop ? 'true' : 'false'
-    }${
-      dir.modifiers && dir.modifiers.sync ? ',true' : ''
-    })`
+    }${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`
   }
 }
diff --git a/src/compiler/directives/index.js b/src/compiler/directives/index.ts
similarity index 89%
rename from src/compiler/directives/index.js
rename to src/compiler/directives/index.ts
index 8f4342c0da7..3b31e554b60 100644
--- a/src/compiler/directives/index.js
+++ b/src/compiler/directives/index.ts
@@ -7,5 +7,5 @@ import { noop } from 'shared/util'
 export default {
   on,
   bind,
-  cloak: noop
+  cloak: noop,
 }
diff --git a/src/compiler/directives/model.js b/src/compiler/directives/model.ts
similarity index 79%
rename from src/compiler/directives/model.js
rename to src/compiler/directives/model.ts
index c7a4c09b574..a5e69df236e 100644
--- a/src/compiler/directives/model.js
+++ b/src/compiler/directives/model.ts
@@ -3,11 +3,11 @@
 /**
  * Cross-platform code generation for component v-model
  */
-export function genComponentModel (
+export function genComponentModel(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
+  modifiers: ASTModifiers | null
+): void {
   const { number, trim } = modifiers || {}
 
   const baseValueExpression = '$$v'
@@ -26,17 +26,14 @@ export function genComponentModel (
   el.model = {
     value: `(${value})`,
     expression: JSON.stringify(value),
-    callback: `function (${baseValueExpression}) {${assignment}}`
+    callback: `function (${baseValueExpression}) {${assignment}}`,
   }
 }
 
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-export function genAssignmentCode (
-  value: string,
-  assignment: string
-): string {
+export function genAssignmentCode(value: string, assignment: string): string {
   const res = parseModel(value)
   if (res.key === null) {
     return `${value}=${assignment}`
@@ -63,11 +60,11 @@ export function genAssignmentCode (
 let len, str, chr, index, expressionPos, expressionEndPos
 
 type ModelParseResult = {
-  exp: string,
+  exp: string
   key: string | null
 }
 
-export function parseModel (val: string): ModelParseResult {
+export function parseModel(val: string): ModelParseResult {
   // Fix https://github.com/vuejs/vue/pull/7730
   // allow v-model="obj.val " (trailing whitespace)
   val = val.trim()
@@ -78,12 +75,12 @@ export function parseModel (val: string): ModelParseResult {
     if (index > -1) {
       return {
         exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
+        key: '"' + val.slice(index + 1) + '"',
       }
     } else {
       return {
         exp: val,
-        key: null
+        key: null,
       }
     }
   }
@@ -96,30 +93,30 @@ export function parseModel (val: string): ModelParseResult {
     /* istanbul ignore if */
     if (isStringStart(chr)) {
       parseString(chr)
-    } else if (chr === 0x5B) {
+    } else if (chr === 0x5b) {
       parseBracket(chr)
     }
   }
 
   return {
     exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
+    key: val.slice(expressionPos + 1, expressionEndPos),
   }
 }
 
-function next (): number {
+function next(): number {
   return str.charCodeAt(++index)
 }
 
-function eof (): boolean {
+function eof(): boolean {
   return index >= len
 }
 
-function isStringStart (chr: number): boolean {
+function isStringStart(chr: number): boolean {
   return chr === 0x22 || chr === 0x27
 }
 
-function parseBracket (chr: number): void {
+function parseBracket(chr: number): void {
   let inBracket = 1
   expressionPos = index
   while (!eof()) {
@@ -128,8 +125,8 @@ function parseBracket (chr: number): void {
       parseString(chr)
       continue
     }
-    if (chr === 0x5B) inBracket++
-    if (chr === 0x5D) inBracket--
+    if (chr === 0x5b) inBracket++
+    if (chr === 0x5d) inBracket--
     if (inBracket === 0) {
       expressionEndPos = index
       break
@@ -137,7 +134,7 @@ function parseBracket (chr: number): void {
   }
 }
 
-function parseString (chr: number): void {
+function parseString(chr: number): void {
   const stringQuote = chr
   while (!eof()) {
     chr = next()
diff --git a/src/compiler/directives/on.js b/src/compiler/directives/on.ts
similarity index 79%
rename from src/compiler/directives/on.js
rename to src/compiler/directives/on.ts
index 893a678ede8..435ff16bbb0 100644
--- a/src/compiler/directives/on.js
+++ b/src/compiler/directives/on.ts
@@ -2,7 +2,7 @@
 
 import { warn } from 'core/util/index'
 
-export default function on (el: ASTElement, dir: ASTDirective) {
+export default function on(el: ASTElement, dir: ASTDirective) {
   if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
     warn(`v-on without argument does not support modifiers.`)
   }
diff --git a/src/compiler/error-detector.js b/src/compiler/error-detector.ts
similarity index 63%
rename from src/compiler/error-detector.js
rename to src/compiler/error-detector.ts
index 05df8b27d54..e41394c34ed 100644
--- a/src/compiler/error-detector.js
+++ b/src/compiler/error-detector.ts
@@ -2,32 +2,40 @@
 
 import { dirRE, onRE } from './parser/index'
 
-type Range = { start?: number, end?: number };
+type Range = { start?: number; end?: number }
 
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b')
+const prohibitedKeywordRE = new RegExp(
+  '\\b' +
+    (
+      'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+      'super,throw,while,yield,delete,export,import,return,switch,default,' +
+      'extends,finally,continue,debugger,function,arguments'
+    )
+      .split(',')
+      .join('\\b|\\b') +
+    '\\b'
+)
 
 // these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)')
+const unaryOperatorsRE = new RegExp(
+  '\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)'
+)
 
 // strip strings in expressions
 const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
 
 // detect problematic expressions in a template
-export function detectErrors (ast: ?ASTNode, warn: Function) {
+export function detectErrors(ast: ASTNode | undefined, warn: Function) {
   if (ast) {
     checkNode(ast, warn)
   }
 }
 
-function checkNode (node: ASTNode, warn: Function) {
+function checkNode(node: ASTNode, warn: Function) {
   if (node.type === 1) {
     for (const name in node.attrsMap) {
       if (dirRE.test(name)) {
@@ -37,7 +45,12 @@ function checkNode (node: ASTNode, warn: Function) {
           if (name === 'v-for') {
             checkFor(node, `v-for="${value}"`, warn, range)
           } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range)
+            checkFunctionParameterExpression(
+              value,
+              `${name}="${value}"`,
+              warn,
+              range
+            )
           } else if (onRE.test(name)) {
             checkEvent(value, `${name}="${value}"`, warn, range)
           } else {
@@ -56,28 +69,33 @@ function checkNode (node: ASTNode, warn: Function) {
   }
 }
 
-function checkEvent (exp: string, text: string, warn: Function, range?: Range) {
+function checkEvent(exp: string, text: string, warn: Function, range?: Range) {
   const stripped = exp.replace(stripStringRE, '')
   const keywordMatch: any = stripped.match(unaryOperatorsRE)
   if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
     warn(
       `avoid using JavaScript unary operator as property name: ` +
-      `"${keywordMatch[0]}" in expression ${text.trim()}`,
+        `"${keywordMatch[0]}" in expression ${text.trim()}`,
       range
     )
   }
   checkExpression(exp, text, warn, range)
 }
 
-function checkFor (node: ASTElement, text: string, warn: Function, range?: Range) {
+function checkFor(
+  node: ASTElement,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
   checkExpression(node.for || '', text, warn, range)
   checkIdentifier(node.alias, 'v-for alias', text, warn, range)
   checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
   checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
 }
 
-function checkIdentifier (
-  ident: ?string,
+function checkIdentifier(
+  ident: string | null | undefined,
   type: string,
   text: string,
   warn: Function,
@@ -92,36 +110,48 @@ function checkIdentifier (
   }
 }
 
-function checkExpression (exp: string, text: string, warn: Function, range?: Range) {
+function checkExpression(
+  exp: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
   try {
     new Function(`return ${exp}`)
   } catch (e) {
-    const keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE)
+    const keywordMatch = exp
+      .replace(stripStringRE, '')
+      .match(prohibitedKeywordRE)
     if (keywordMatch) {
       warn(
         `avoid using JavaScript keyword as property name: ` +
-        `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
+          `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
         range
       )
     } else {
       warn(
         `invalid expression: ${e.message} in\n\n` +
-        `    ${exp}\n\n` +
-        `  Raw expression: ${text.trim()}\n`,
+          `    ${exp}\n\n` +
+          `  Raw expression: ${text.trim()}\n`,
         range
       )
     }
   }
 }
 
-function checkFunctionParameterExpression (exp: string, text: string, warn: Function, range?: Range) {
+function checkFunctionParameterExpression(
+  exp: string,
+  text: string,
+  warn: Function,
+  range?: Range
+) {
   try {
     new Function(exp, '')
   } catch (e) {
     warn(
       `invalid function parameter expression: ${e.message} in\n\n` +
-      `    ${exp}\n\n` +
-      `  Raw expression: ${text.trim()}\n`,
+        `    ${exp}\n\n` +
+        `  Raw expression: ${text.trim()}\n`,
       range
     )
   }
diff --git a/src/compiler/helpers.js b/src/compiler/helpers.ts
similarity index 66%
rename from src/compiler/helpers.js
rename to src/compiler/helpers.ts
index 7231d684cf4..cbb316d64aa 100644
--- a/src/compiler/helpers.js
+++ b/src/compiler/helpers.ts
@@ -3,76 +3,100 @@
 import { emptyObject } from 'shared/util'
 import { parseFilters } from './parser/filter-parser'
 
-type Range = { start?: number, end?: number };
+type Range = { start?: number; end?: number }
 
 /* eslint-disable no-unused-vars */
-export function baseWarn (msg: string, range?: Range) {
+export function baseWarn(msg: string, range?: Range) {
   console.error(`[Vue compiler]: ${msg}`)
 }
 /* eslint-enable no-unused-vars */
 
-export function pluckModuleFunction<F: Function> (
-  modules: ?Array<Object>,
-  key: string
-): Array<F> {
-  return modules
-    ? modules.map(m => m[key]).filter(_ => _)
-    : []
+export function pluckModuleFunction<T, K extends keyof T>(
+  modules: Array<T> | undefined,
+  key: K
+): Array<T[K]> {
+  return modules ? modules.map((m) => m[key]).filter((_) => _) : []
 }
 
-export function addProp (el: ASTElement, name: string, value: string, range?: Range, dynamic?: boolean) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range))
+export function addProp(
+  el: ASTElement,
+  name: string,
+  value: string,
+  range?: Range,
+  dynamic?: boolean
+) {
+  ;(el.props || (el.props = [])).push(
+    rangeSetItem({ name, value, dynamic }, range)
+  )
   el.plain = false
 }
 
-export function addAttr (el: ASTElement, name: string, value: any, range?: Range, dynamic?: boolean) {
+export function addAttr(
+  el: ASTElement,
+  name: string,
+  value: any,
+  range?: Range,
+  dynamic?: boolean
+) {
   const attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []))
+    ? el.dynamicAttrs || (el.dynamicAttrs = [])
+    : el.attrs || (el.attrs = [])
   attrs.push(rangeSetItem({ name, value, dynamic }, range))
   el.plain = false
 }
 
 // add a raw attr (use this in preTransforms)
-export function addRawAttr (el: ASTElement, name: string, value: any, range?: Range) {
+export function addRawAttr(
+  el: ASTElement,
+  name: string,
+  value: any,
+  range?: Range
+) {
   el.attrsMap[name] = value
   el.attrsList.push(rangeSetItem({ name, value }, range))
 }
 
-export function addDirective (
+export function addDirective(
   el: ASTElement,
   name: string,
   rawName: string,
   value: string,
-  arg: ?string,
-  isDynamicArg: boolean,
-  modifiers: ?ASTModifiers,
+  arg?: string,
+  isDynamicArg?: boolean,
+  modifiers?: ASTModifiers,
   range?: Range
 ) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers
-  }, range))
+  ;(el.directives || (el.directives = [])).push(
+    rangeSetItem(
+      {
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+      },
+      range
+    )
+  )
   el.plain = false
 }
 
-function prependModifierMarker (symbol: string, name: string, dynamic?: boolean): string {
-  return dynamic
-    ? `_p(${name},"${symbol}")`
-    : symbol + name // mark the event as captured
+function prependModifierMarker(
+  symbol: string,
+  name: string,
+  dynamic?: boolean
+): string {
+  return dynamic ? `_p(${name},"${symbol}")` : symbol + name // mark the event as captured
 }
 
-export function addHandler (
+export function addHandler(
   el: ASTElement,
   name: string,
   value: string,
-  modifiers: ?ASTModifiers,
+  modifiers?: ASTModifiers | null,
   important?: boolean,
-  warn?: ?Function,
+  warn?: Function,
   range?: Range,
   dynamic?: boolean
 ) {
@@ -80,12 +104,14 @@ export function addHandler (
   // warn prevent and passive modifier
   /* istanbul ignore if */
   if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
+    process.env.NODE_ENV !== 'production' &&
+    warn &&
+    modifiers.prevent &&
+    modifiers.passive
   ) {
     warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
+      "passive and prevent can't be used together. " +
+        "Passive handler can't prevent default event.",
       range
     )
   }
@@ -149,23 +175,21 @@ export function addHandler (
   el.plain = false
 }
 
-export function getRawBindingAttr (
-  el: ASTElement,
-  name: string
-) {
-  return el.rawAttrsMap[':' + name] ||
+export function getRawBindingAttr(el: ASTElement, name: string) {
+  return (
+    el.rawAttrsMap[':' + name] ||
     el.rawAttrsMap['v-bind:' + name] ||
     el.rawAttrsMap[name]
+  )
 }
 
-export function getBindingAttr (
+export function getBindingAttr(
   el: ASTElement,
   name: string,
   getStatic?: boolean
-): ?string {
+): string | undefined {
   const dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name)
+    getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
   if (dynamicValue != null) {
     return parseFilters(dynamicValue)
   } else if (getStatic !== false) {
@@ -180,11 +204,11 @@ export function getBindingAttr (
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-export function getAndRemoveAttr (
+export function getAndRemoveAttr(
   el: ASTElement,
   name: string,
   removeFromMap?: boolean
-): ?string {
+): string | undefined {
   let val
   if ((val = el.attrsMap[name]) != null) {
     const list = el.attrsList
@@ -201,10 +225,7 @@ export function getAndRemoveAttr (
   return val
 }
 
-export function getAndRemoveAttrByRegex (
-  el: ASTElement,
-  name: RegExp
-) {
+export function getAndRemoveAttrByRegex(el: ASTElement, name: RegExp) {
   const list = el.attrsList
   for (let i = 0, l = list.length; i < l; i++) {
     const attr = list[i]
@@ -215,10 +236,7 @@ export function getAndRemoveAttrByRegex (
   }
 }
 
-function rangeSetItem (
-  item: any,
-  range?: { start?: number, end?: number }
-) {
+function rangeSetItem(item: any, range?: { start?: number; end?: number }) {
   if (range) {
     if (range.start != null) {
       item.start = range.start
diff --git a/src/compiler/index.js b/src/compiler/index.ts
similarity index 93%
rename from src/compiler/index.js
rename to src/compiler/index.ts
index 56b54fd36c6..35da8abc696 100644
--- a/src/compiler/index.js
+++ b/src/compiler/index.ts
@@ -8,7 +8,7 @@ import { createCompilerCreator } from './create-compiler'
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-export const createCompiler = createCompilerCreator(function baseCompile (
+export const createCompiler = createCompilerCreator(function baseCompile(
   template: string,
   options: CompilerOptions
 ): CompiledResult {
@@ -20,6 +20,6 @@ export const createCompiler = createCompilerCreator(function baseCompile (
   return {
     ast,
     render: code.render,
-    staticRenderFns: code.staticRenderFns
+    staticRenderFns: code.staticRenderFns,
   }
 })
diff --git a/src/compiler/optimizer.js b/src/compiler/optimizer.ts
similarity index 74%
rename from src/compiler/optimizer.js
rename to src/compiler/optimizer.ts
index 5f56e74cdee..d33f7036d68 100644
--- a/src/compiler/optimizer.js
+++ b/src/compiler/optimizer.ts
@@ -18,7 +18,10 @@ const genStaticKeysCached = cached(genStaticKeys)
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-export function optimize (root: ?ASTElement, options: CompilerOptions) {
+export function optimize(
+  root: ASTElement | null | undefined,
+  options: CompilerOptions
+) {
   if (!root) return
   isStaticKey = genStaticKeysCached(options.staticKeys || '')
   isPlatformReservedTag = options.isReservedTag || no
@@ -28,14 +31,14 @@ export function optimize (root: ?ASTElement, options: CompilerOptions) {
   markStaticRoots(root, false)
 }
 
-function genStaticKeys (keys: string): Function {
+function genStaticKeys(keys: string): Function {
   return makeMap(
     'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
+      (keys ? ',' + keys : '')
   )
 }
 
-function markStatic (node: ASTNode) {
+function markStatic(node: ASTNode) {
   node.static = isStatic(node)
   if (node.type === 1) {
     // do not make component slot content static. this avoids
@@ -67,7 +70,7 @@ function markStatic (node: ASTNode) {
   }
 }
 
-function markStaticRoots (node: ASTNode, isInFor: boolean) {
+function markStaticRoots(node: ASTNode, isInFor: boolean) {
   if (node.type === 1) {
     if (node.static || node.once) {
       node.staticInFor = isInFor
@@ -75,10 +78,11 @@ function markStaticRoots (node: ASTNode, isInFor: boolean) {
     // For a node to qualify as a static root, it should have children that
     // are not just static text. Otherwise the cost of hoisting out will
     // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
+    if (
+      node.static &&
+      node.children.length &&
+      !(node.children.length === 1 && node.children[0].type === 3)
+    ) {
       node.staticRoot = true
       return
     } else {
@@ -97,24 +101,28 @@ function markStaticRoots (node: ASTNode, isInFor: boolean) {
   }
 }
 
-function isStatic (node: ASTNode): boolean {
-  if (node.type === 2) { // expression
+function isStatic(node: ASTNode): boolean {
+  if (node.type === 2) {
+    // expression
     return false
   }
-  if (node.type === 3) { // text
+  if (node.type === 3) {
+    // text
     return true
   }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
+  return !!(
+    node.pre ||
+    (!node.hasBindings && // no dynamic bindings
+      !node.if &&
+      !node.for && // not v-if or v-for or v-else
+      !isBuiltInTag(node.tag) && // not a built-in
+      isPlatformReservedTag(node.tag) && // not a component
+      !isDirectChildOfTemplateFor(node) &&
+      Object.keys(node).every(isStaticKey))
+  )
 }
 
-function isDirectChildOfTemplateFor (node: ASTElement): boolean {
+function isDirectChildOfTemplateFor(node: ASTElement): boolean {
   while (node.parent) {
     node = node.parent
     if (node.tag !== 'template') {
diff --git a/src/compiler/parser/entity-decoder.js b/src/compiler/parser/entity-decoder.ts
similarity index 80%
rename from src/compiler/parser/entity-decoder.js
rename to src/compiler/parser/entity-decoder.ts
index 2836294f2c9..d681297c3c7 100644
--- a/src/compiler/parser/entity-decoder.js
+++ b/src/compiler/parser/entity-decoder.ts
@@ -3,9 +3,9 @@
 let decoder
 
 export default {
-  decode (html: string): string {
+  decode(html: string): string {
     decoder = decoder || document.createElement('div')
     decoder.innerHTML = html
     return decoder.textContent
-  }
+  },
 }
diff --git a/src/compiler/parser/filter-parser.js b/src/compiler/parser/filter-parser.ts
similarity index 57%
rename from src/compiler/parser/filter-parser.js
rename to src/compiler/parser/filter-parser.ts
index 10939d3fb34..0703a86feb4 100644
--- a/src/compiler/parser/filter-parser.js
+++ b/src/compiler/parser/filter-parser.ts
@@ -2,7 +2,7 @@
 
 const validDivisionCharRE = /[\w).+\-_$\]]/
 
-export function parseFilters (exp: string): string {
+export function parseFilters(exp: string): string {
   let inSingle = false
   let inDouble = false
   let inTemplateString = false
@@ -17,18 +17,20 @@ export function parseFilters (exp: string): string {
     prev = c
     c = exp.charCodeAt(i)
     if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) inSingle = false
+      if (c === 0x27 && prev !== 0x5c) inSingle = false
     } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) inDouble = false
+      if (c === 0x22 && prev !== 0x5c) inDouble = false
     } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) inTemplateString = false
+      if (c === 0x60 && prev !== 0x5c) inTemplateString = false
     } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) inRegex = false
+      if (c === 0x2f && prev !== 0x5c) inRegex = false
     } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
+      c === 0x7c && // pipe
+      exp.charCodeAt(i + 1) !== 0x7c &&
+      exp.charCodeAt(i - 1) !== 0x7c &&
+      !curly &&
+      !square &&
+      !paren
     ) {
       if (expression === undefined) {
         // first filter, end of expression
@@ -39,17 +41,36 @@ export function parseFilters (exp: string): string {
       }
     } else {
       switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
+        case 0x22:
+          inDouble = true
+          break // "
+        case 0x27:
+          inSingle = true
+          break // '
+        case 0x60:
+          inTemplateString = true
+          break // `
+        case 0x28:
+          paren++
+          break // (
+        case 0x29:
+          paren--
+          break // )
+        case 0x5b:
+          square++
+          break // [
+        case 0x5d:
+          square--
+          break // ]
+        case 0x7b:
+          curly++
+          break // {
+        case 0x7d:
+          curly--
+          break // }
       }
-      if (c === 0x2f) { // /
+      if (c === 0x2f) {
+        // /
         let j = i - 1
         let p
         // find first non-whitespace prev char
@@ -70,8 +91,8 @@ export function parseFilters (exp: string): string {
     pushFilter()
   }
 
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
+  function pushFilter() {
+    ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
     lastFilterIndex = i + 1
   }
 
@@ -84,7 +105,7 @@ export function parseFilters (exp: string): string {
   return expression
 }
 
-function wrapFilter (exp: string, filter: string): string {
+function wrapFilter(exp: string, filter: string): string {
   const i = filter.indexOf('(')
   if (i < 0) {
     // _f: resolveFilter
diff --git a/src/compiler/parser/html-parser.js b/src/compiler/parser/html-parser.ts
similarity index 81%
rename from src/compiler/parser/html-parser.js
rename to src/compiler/parser/html-parser.ts
index 37c1fa24d58..2913e650240 100644
--- a/src/compiler/parser/html-parser.js
+++ b/src/compiler/parser/html-parser.ts
@@ -37,22 +37,23 @@ const decodingMap = {
   '&amp;': '&',
   '&#10;': '\n',
   '&#9;': '\t',
-  '&#39;': "'"
+  '&#39;': "'",
 }
 const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
 const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
 
 // #5992
 const isIgnoreNewlineTag = makeMap('pre,textarea', true)
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
+const shouldIgnoreFirstNewline = (tag, html) =>
+  tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
 
-function decodeAttr (value, shouldDecodeNewlines) {
+function decodeAttr(value, shouldDecodeNewlines) {
   const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
-  return value.replace(re, match => decodingMap[match])
+  return value.replace(re, (match) => decodingMap[match])
 }
 
-export function parseHTML (html, options) {
-  const stack = []
+export function parseHTML(html, options) {
+  const stack: any[] = []
   const expectHTML = options.expectHTML
   const isUnaryTag = options.isUnaryTag || no
   const canBeLeftOpenTag = options.canBeLeftOpenTag || no
@@ -70,7 +71,11 @@ export function parseHTML (html, options) {
 
           if (commentEnd >= 0) {
             if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3)
+              options.comment(
+                html.substring(4, commentEnd),
+                index,
+                index + commentEnd + 3
+              )
             }
             advance(commentEnd + 3)
             continue
@@ -146,7 +151,12 @@ export function parseHTML (html, options) {
     } else {
       let endTagLength = 0
       const stackedTag = lastTag.toLowerCase()
-      const reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'))
+      const reStackedTag =
+        reCache[stackedTag] ||
+        (reCache[stackedTag] = new RegExp(
+          '([\\s\\S]*?)(</' + stackedTag + '[^>]*>)',
+          'i'
+        ))
       const rest = html.replace(reStackedTag, function (all, text, endTag) {
         endTagLength = endTag.length
         if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
@@ -169,8 +179,14 @@ export function parseHTML (html, options) {
 
     if (html === last) {
       options.chars && options.chars(html)
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(`Mal-formatted tag at end of template: "${html}"`, { start: index + html.length })
+      if (
+        process.env.NODE_ENV !== 'production' &&
+        !stack.length &&
+        options.warn
+      ) {
+        options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+          start: index + html.length,
+        })
       }
       break
     }
@@ -179,22 +195,25 @@ export function parseHTML (html, options) {
   // Clean up any remaining tags
   parseEndTag()
 
-  function advance (n) {
+  function advance(n) {
     index += n
     html = html.substring(n)
   }
 
-  function parseStartTag () {
+  function parseStartTag() {
     const start = html.match(startTagOpen)
     if (start) {
-      const match = {
+      const match: any = {
         tagName: start[1],
         attrs: [],
-        start: index
+        start: index,
       }
       advance(start[0].length)
       let end, attr
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+      while (
+        !(end = html.match(startTagClose)) &&
+        (attr = html.match(dynamicArgAttribute) || html.match(attribute))
+      ) {
         attr.start = index
         advance(attr[0].length)
         attr.end = index
@@ -209,7 +228,7 @@ export function parseHTML (html, options) {
     }
   }
 
-  function handleStartTag (match) {
+  function handleStartTag(match) {
     const tagName = match.tagName
     const unarySlash = match.unarySlash
 
@@ -229,12 +248,13 @@ export function parseHTML (html, options) {
     for (let i = 0; i < l; i++) {
       const args = match.attrs[i]
       const value = args[3] || args[4] || args[5] || ''
-      const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines
+      const shouldDecodeNewlines =
+        tagName === 'a' && args[1] === 'href'
+          ? options.shouldDecodeNewlinesForHref
+          : options.shouldDecodeNewlines
       attrs[i] = {
         name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
+        value: decodeAttr(value, shouldDecodeNewlines),
       }
       if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
         attrs[i].start = args.start + args[0].match(/^\s*/).length
@@ -243,7 +263,13 @@ export function parseHTML (html, options) {
     }
 
     if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end })
+      stack.push({
+        tag: tagName,
+        lowerCasedTag: tagName.toLowerCase(),
+        attrs: attrs,
+        start: match.start,
+        end: match.end,
+      })
       lastTag = tagName
     }
 
@@ -252,7 +278,7 @@ export function parseHTML (html, options) {
     }
   }
 
-  function parseEndTag (tagName, start, end) {
+  function parseEndTag(tagName?: any, start?: any, end?: any) {
     let pos, lowerCasedTagName
     if (start == null) start = index
     if (end == null) end = index
@@ -273,14 +299,15 @@ export function parseHTML (html, options) {
     if (pos >= 0) {
       // Close all the open elements, up the stack
       for (let i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
+        if (
+          process.env.NODE_ENV !== 'production' &&
           (i > pos || !tagName) &&
           options.warn
         ) {
-          options.warn(
-            `tag <${stack[i].tag}> has no matching end tag.`,
-            { start: stack[i].start, end: stack[i].end }
-          )
+          options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+            start: stack[i].start,
+            end: stack[i].end,
+          })
         }
         if (options.end) {
           options.end(stack[i].tag, start, end)
diff --git a/src/compiler/parser/index.js b/src/compiler/parser/index.ts
similarity index 77%
rename from src/compiler/parser/index.js
rename to src/compiler/parser/index.ts
index d727f8dd4d1..6bc381c0f39 100644
--- a/src/compiler/parser/index.js
+++ b/src/compiler/parser/index.ts
@@ -18,7 +18,7 @@ import {
   getAndRemoveAttr,
   getRawBindingAttr,
   pluckModuleFunction,
-  getAndRemoveAttrByRegex
+  getAndRemoveAttrByRegex,
 } from '../helpers'
 
 export const onRE = /^@|^v-on:/
@@ -57,7 +57,7 @@ let platformMustUseProp
 let platformGetTagNamespace
 let maybeComponent
 
-export function createASTElement (
+export function createASTElement(
   tag: string,
   attrs: Array<ASTAttr>,
   parent: ASTElement | void
@@ -69,17 +69,14 @@ export function createASTElement (
     attrsMap: makeAttrsMap(attrs),
     rawAttrsMap: {},
     parent,
-    children: []
+    children: [],
   }
 }
 
 /**
  * Convert HTML string to AST.
  */
-export function parse (
-  template: string,
-  options: CompilerOptions
-): ASTElement | void {
+export function parse(template: string, options: CompilerOptions): ASTElement {
   warn = options.warn || baseWarn
 
   platformIsPreTag = options.isPreTag || no
@@ -94,7 +91,7 @@ export function parse (
 
   delimiters = options.delimiters
 
-  const stack = []
+  const stack: any[] = []
   const preserveWhitespace = options.preserveWhitespace !== false
   const whitespaceOption = options.whitespace
   let root
@@ -103,14 +100,14 @@ export function parse (
   let inPre = false
   let warned = false
 
-  function warnOnce (msg, range) {
+  function warnOnce(msg, range) {
     if (!warned) {
       warned = true
       warn(msg, range)
     }
   }
 
-  function closeElement (element) {
+  function closeElement(element) {
     trimEndingWhitespace(element)
     if (!inVPre && !element.processed) {
       element = processElement(element, options)
@@ -124,13 +121,13 @@ export function parse (
         }
         addIfCondition(root, {
           exp: element.elseif,
-          block: element
+          block: element,
         })
       } else if (process.env.NODE_ENV !== 'production') {
         warnOnce(
           `Component template should contain exactly one root element. ` +
-          `If you are using v-if on multiple elements, ` +
-          `use v-else-if to chain them instead.`,
+            `If you are using v-if on multiple elements, ` +
+            `use v-else-if to chain them instead.`,
           { start: element.start }
         )
       }
@@ -144,7 +141,9 @@ export function parse (
           // keep it in the children list so that v-else(-if) conditions can
           // find it as the prev node.
           const name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element
+          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[
+            name
+          ] = element
         }
         currentParent.children.push(element)
         element.parent = currentParent
@@ -153,7 +152,7 @@ export function parse (
 
     // final children cleanup
     // filter out scoped slots
-    element.children = element.children.filter(c => !(c: any).slotScope)
+    element.children = element.children.filter((c) => !c.slotScope)
     // remove trailing whitespace node again
     trimEndingWhitespace(element)
 
@@ -170,7 +169,7 @@ export function parse (
     }
   }
 
-  function trimEndingWhitespace (el) {
+  function trimEndingWhitespace(el) {
     // remove trailing whitespace node
     if (!inPre) {
       let lastNode
@@ -184,18 +183,18 @@ export function parse (
     }
   }
 
-  function checkRootConstraints (el) {
+  function checkRootConstraints(el) {
     if (el.tag === 'slot' || el.tag === 'template') {
       warnOnce(
         `Cannot use <${el.tag}> as component root element because it may ` +
-        'contain multiple nodes.',
+          'contain multiple nodes.',
         { start: el.start }
       )
     }
     if (el.attrsMap.hasOwnProperty('v-for')) {
       warnOnce(
         'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
+          'it renders multiple elements.',
         el.rawAttrsMap['v-for']
       )
     }
@@ -210,10 +209,11 @@ export function parse (
     shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
     shouldKeepComment: options.comments,
     outputSourceRange: options.outputSourceRange,
-    start (tag, attrs, unary, start, end) {
+    start(tag, attrs, unary, start, end) {
       // check namespace.
       // inherit parent ns if there is one
-      const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
+      const ns =
+        (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
 
       // handle IE svg bug
       /* istanbul ignore if */
@@ -235,14 +235,14 @@ export function parse (
             return cumulated
           }, {})
         }
-        attrs.forEach(attr => {
+        attrs.forEach((attr) => {
           if (invalidAttributeRE.test(attr.name)) {
             warn(
               `Invalid dynamic argument expression: attribute names cannot contain ` +
-              `spaces, quotes, <, >, / or =.`,
+                `spaces, quotes, <, >, / or =.`,
               {
                 start: attr.start + attr.name.indexOf(`[`),
-                end: attr.start + attr.name.length
+                end: attr.start + attr.name.length,
               }
             )
           }
@@ -251,12 +251,14 @@ export function parse (
 
       if (isForbiddenTag(element) && !isServerRendering()) {
         element.forbidden = true
-        process.env.NODE_ENV !== 'production' && warn(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          `<${tag}>` + ', as they will not be parsed.',
-          { start: element.start }
-        )
+        process.env.NODE_ENV !== 'production' &&
+          warn(
+            'Templates should only be responsible for mapping the state to the ' +
+              'UI. Avoid placing tags with side-effects in your templates, such as ' +
+              `<${tag}>` +
+              ', as they will not be parsed.',
+            { start: element.start }
+          )
       }
 
       // apply pre-transforms
@@ -297,7 +299,7 @@ export function parse (
       }
     },
 
-    end (tag, start, end) {
+    end(tag, start, end) {
       const element = stack[stack.length - 1]
       // pop stack
       stack.length -= 1
@@ -308,7 +310,7 @@ export function parse (
       closeElement(element)
     },
 
-    chars (text: string, start: number, end: number) {
+    chars(text: string, start: number, end: number) {
       if (!currentParent) {
         if (process.env.NODE_ENV !== 'production') {
           if (text === template) {
@@ -317,17 +319,17 @@ export function parse (
               { start }
             )
           } else if ((text = text.trim())) {
-            warnOnce(
-              `text "${text}" outside root element will be ignored.`,
-              { start }
-            )
+            warnOnce(`text "${text}" outside root element will be ignored.`, {
+              start,
+            })
           }
         }
         return
       }
       // IE textarea placeholder bug
       /* istanbul ignore if */
-      if (isIE &&
+      if (
+        isIE &&
         currentParent.tag === 'textarea' &&
         currentParent.attrsMap.placeholder === text
       ) {
@@ -356,22 +358,29 @@ export function parse (
           text = text.replace(whitespaceRE, ' ')
         }
         let res
-        let child: ?ASTNode
+        let child: ASTNode | undefined
         if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
           child = {
             type: 2,
             expression: res.expression,
             tokens: res.tokens,
-            text
+            text,
           }
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
+        } else if (
+          text !== ' ' ||
+          !children.length ||
+          children[children.length - 1].text !== ' '
+        ) {
           child = {
             type: 3,
-            text
+            text,
           }
         }
         if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+          if (
+            process.env.NODE_ENV !== 'production' &&
+            options.outputSourceRange
+          ) {
             child.start = start
             child.end = end
           }
@@ -379,41 +388,44 @@ export function parse (
         }
       }
     },
-    comment (text: string, start, end) {
+    comment(text: string, start, end) {
       // adding anything as a sibling to the root node is forbidden
       // comments should still be allowed, but ignored
       if (currentParent) {
         const child: ASTText = {
           type: 3,
           text,
-          isComment: true
+          isComment: true,
         }
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          options.outputSourceRange
+        ) {
           child.start = start
           child.end = end
         }
         currentParent.children.push(child)
       }
-    }
+    },
   })
   return root
 }
 
-function processPre (el) {
+function processPre(el) {
   if (getAndRemoveAttr(el, 'v-pre') != null) {
     el.pre = true
   }
 }
 
-function processRawAttrs (el) {
+function processRawAttrs(el) {
   const list = el.attrsList
   const len = list.length
   if (len) {
-    const attrs: Array<ASTAttr> = el.attrs = new Array(len)
+    const attrs: Array<ASTAttr> = (el.attrs = new Array(len))
     for (let i = 0; i < len; i++) {
       attrs[i] = {
         name: list[i].name,
-        value: JSON.stringify(list[i].value)
+        value: JSON.stringify(list[i].value),
       }
       if (list[i].start != null) {
         attrs[i].start = list[i].start
@@ -426,19 +438,13 @@ function processRawAttrs (el) {
   }
 }
 
-export function processElement (
-  element: ASTElement,
-  options: CompilerOptions
-) {
+export function processElement(element: ASTElement, options: CompilerOptions) {
   processKey(element)
 
   // determine whether this is a plain element after
   // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  )
+  element.plain =
+    !element.key && !element.scopedSlots && !element.attrsList.length
 
   processRef(element)
   processSlotContent(element)
@@ -451,7 +457,7 @@ export function processElement (
   return element
 }
 
-function processKey (el) {
+function processKey(el) {
   const exp = getBindingAttr(el, 'key')
   if (exp) {
     if (process.env.NODE_ENV !== 'production') {
@@ -464,10 +470,15 @@ function processKey (el) {
       if (el.for) {
         const iterator = el.iterator2 || el.iterator1
         const parent = el.parent
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
+        if (
+          iterator &&
+          iterator === exp &&
+          parent &&
+          parent.tag === 'transition-group'
+        ) {
           warn(
             `Do not use v-for index as key on <transition-group> children, ` +
-            `this is the same as not using keys.`,
+              `this is the same as not using keys.`,
             getRawBindingAttr(el, 'key'),
             true /* tip */
           )
@@ -478,7 +489,7 @@ function processKey (el) {
   }
 }
 
-function processRef (el) {
+function processRef(el) {
   const ref = getBindingAttr(el, 'ref')
   if (ref) {
     el.ref = ref
@@ -486,32 +497,29 @@ function processRef (el) {
   }
 }
 
-export function processFor (el: ASTElement) {
+export function processFor(el: ASTElement) {
   let exp
   if ((exp = getAndRemoveAttr(el, 'v-for'))) {
     const res = parseFor(exp)
     if (res) {
       extend(el, res)
     } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        `Invalid v-for expression: ${exp}`,
-        el.rawAttrsMap['v-for']
-      )
+      warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for'])
     }
   }
 }
 
 type ForParseResult = {
-  for: string;
-  alias: string;
-  iterator1?: string;
-  iterator2?: string;
-};
+  for: string
+  alias: string
+  iterator1?: string
+  iterator2?: string
+}
 
-export function parseFor (exp: string): ?ForParseResult {
+export function parseFor(exp: string): ForParseResult | undefined {
   const inMatch = exp.match(forAliasRE)
   if (!inMatch) return
-  const res = {}
+  const res: any = {}
   res.for = inMatch[2].trim()
   const alias = inMatch[1].trim().replace(stripParensRE, '')
   const iteratorMatch = alias.match(forIteratorRE)
@@ -527,13 +535,13 @@ export function parseFor (exp: string): ?ForParseResult {
   return res
 }
 
-function processIf (el) {
+function processIf(el) {
   const exp = getAndRemoveAttr(el, 'v-if')
   if (exp) {
     el.if = exp
     addIfCondition(el, {
       exp: exp,
-      block: el
+      block: el,
     })
   } else {
     if (getAndRemoveAttr(el, 'v-else') != null) {
@@ -546,23 +554,23 @@ function processIf (el) {
   }
 }
 
-function processIfConditions (el, parent) {
+function processIfConditions(el, parent) {
   const prev = findPrevElement(parent.children)
   if (prev && prev.if) {
     addIfCondition(prev, {
       exp: el.elseif,
-      block: el
+      block: el,
     })
   } else if (process.env.NODE_ENV !== 'production') {
     warn(
-      `v-${el.elseif ? ('else-if="' + el.elseif + '"') : 'else'} ` +
-      `used on element <${el.tag}> without corresponding v-if.`,
+      `v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+        `used on element <${el.tag}> without corresponding v-if.`,
       el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
     )
   }
 }
 
-function findPrevElement (children: Array<any>): ASTElement | void {
+function findPrevElement(children: Array<any>): ASTElement | void {
   let i = children.length
   while (i--) {
     if (children[i].type === 1) {
@@ -571,7 +579,7 @@ function findPrevElement (children: Array<any>): ASTElement | void {
       if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
         warn(
           `text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-          `will be ignored.`,
+            `will be ignored.`,
           children[i]
         )
       }
@@ -580,14 +588,14 @@ function findPrevElement (children: Array<any>): ASTElement | void {
   }
 }
 
-export function addIfCondition (el: ASTElement, condition: ASTIfCondition) {
+export function addIfCondition(el: ASTElement, condition: ASTIfCondition) {
   if (!el.ifConditions) {
     el.ifConditions = []
   }
   el.ifConditions.push(condition)
 }
 
-function processOnce (el) {
+function processOnce(el) {
   const once = getAndRemoveAttr(el, 'v-once')
   if (once != null) {
     el.once = true
@@ -596,7 +604,7 @@ function processOnce (el) {
 
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
+function processSlotContent(el) {
   let slotScope
   if (el.tag === 'template') {
     slotScope = getAndRemoveAttr(el, 'scope')
@@ -604,9 +612,9 @@ function processSlotContent (el) {
     if (process.env.NODE_ENV !== 'production' && slotScope) {
       warn(
         `the "scope" attribute for scoped slots have been deprecated and ` +
-        `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-        `can also be used on plain elements in addition to <template> to ` +
-        `denote scoped slots.`,
+          `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+          `can also be used on plain elements in addition to <template> to ` +
+          `denote scoped slots.`,
         el.rawAttrsMap['scope'],
         true
       )
@@ -617,8 +625,8 @@ function processSlotContent (el) {
     if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
       warn(
         `Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-        `(v-for takes higher priority). Use a wrapper <template> for the ` +
-        `scoped slot to make it clearer.`,
+          `(v-for takes higher priority). Use a wrapper <template> for the ` +
+          `scoped slot to make it clearer.`,
         el.rawAttrsMap['slot-scope'],
         true
       )
@@ -630,7 +638,9 @@ function processSlotContent (el) {
   const slotTarget = getBindingAttr(el, 'slot')
   if (slotTarget) {
     el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot'])
+    el.slotTargetDynamic = !!(
+      el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']
+    )
     // preserve slot as an attribute for native shadow DOM compat
     // only for non-scoped slots.
     if (el.tag !== 'template' && !el.slotScope) {
@@ -646,15 +656,12 @@ function processSlotContent (el) {
       if (slotBinding) {
         if (process.env.NODE_ENV !== 'production') {
           if (el.slotTarget || el.slotScope) {
-            warn(
-              `Unexpected mixed usage of different slot syntaxes.`,
-              el
-            )
+            warn(`Unexpected mixed usage of different slot syntaxes.`, el)
           }
           if (el.parent && !maybeComponent(el.parent)) {
             warn(
               `<template v-slot> can only appear at the root level inside ` +
-              `the receiving component`,
+                `the receiving component`,
               el
             )
           }
@@ -676,15 +683,12 @@ function processSlotContent (el) {
             )
           }
           if (el.slotScope || el.slotTarget) {
-            warn(
-              `Unexpected mixed usage of different slot syntaxes.`,
-              el
-            )
+            warn(`Unexpected mixed usage of different slot syntaxes.`, el)
           }
           if (el.scopedSlots) {
             warn(
               `To avoid scope ambiguity, the default slot should also use ` +
-              `<template> syntax when there are other named slots.`,
+                `<template> syntax when there are other named slots.`,
               slotBinding
             )
           }
@@ -692,7 +696,11 @@ function processSlotContent (el) {
         // add the component's children to its default slot
         const slots = el.scopedSlots || (el.scopedSlots = {})
         const { name, dynamic } = getSlotName(slotBinding)
-        const slotContainer = slots[name] = createASTElement('template', [], el)
+        const slotContainer = (slots[name] = createASTElement(
+          'template',
+          [],
+          el
+        ))
         slotContainer.slotTarget = name
         slotContainer.slotTargetDynamic = dynamic
         slotContainer.children = el.children.filter((c: any) => {
@@ -711,41 +719,38 @@ function processSlotContent (el) {
   }
 }
 
-function getSlotName (binding) {
+function getSlotName(binding) {
   let name = binding.name.replace(slotRE, '')
   if (!name) {
     if (binding.name[0] !== '#') {
       name = 'default'
     } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        `v-slot shorthand syntax requires a slot name.`,
-        binding
-      )
+      warn(`v-slot shorthand syntax requires a slot name.`, binding)
     }
   }
   return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: `"${name}"`, dynamic: false }
+    ? // dynamic [name]
+      { name: name.slice(1, -1), dynamic: true }
+    : // static name
+      { name: `"${name}"`, dynamic: false }
 }
 
 // handle <slot/> outlets
-function processSlotOutlet (el) {
+function processSlotOutlet(el) {
   if (el.tag === 'slot') {
     el.slotName = getBindingAttr(el, 'name')
     if (process.env.NODE_ENV !== 'production' && el.key) {
       warn(
         `\`key\` does not work on <slot> because slots are abstract outlets ` +
-        `and can possibly expand into multiple elements. ` +
-        `Use the key on a wrapping element instead.`,
+          `and can possibly expand into multiple elements. ` +
+          `Use the key on a wrapping element instead.`,
         getRawBindingAttr(el, 'key')
       )
     }
   }
 }
 
-function processComponent (el) {
+function processComponent(el) {
   let binding
   if ((binding = getBindingAttr(el, 'is'))) {
     el.component = binding
@@ -755,7 +760,7 @@ function processComponent (el) {
   }
 }
 
-function processAttrs (el) {
+function processAttrs(el) {
   const list = el.attrsList
   let i, l, name, rawName, value, modifiers, syncGen, isDynamic
   for (i = 0, l = list.length; i < l; i++) {
@@ -768,12 +773,13 @@ function processAttrs (el) {
       modifiers = parseModifiers(name.replace(dirRE, ''))
       // support .foo shorthand syntax for the .prop modifier
       if (process.env.VBIND_PROP_SHORTHAND && propBindRE.test(name)) {
-        (modifiers || (modifiers = {})).prop = true
+        ;(modifiers || (modifiers = {})).prop = true
         name = `.` + name.slice(1).replace(modifierRE, '')
       } else if (modifiers) {
         name = name.replace(modifierRE, '')
       }
-      if (bindRE.test(name)) { // v-bind
+      if (bindRE.test(name)) {
+        // v-bind
         name = name.replace(bindRE, '')
         value = parseFilters(value)
         isDynamic = dynamicArgRE.test(name)
@@ -834,21 +840,24 @@ function processAttrs (el) {
             }
           }
         }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
+        if (
+          (modifiers && modifiers.prop) ||
+          (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))
+        ) {
           addProp(el, name, value, list[i], isDynamic)
         } else {
           addAttr(el, name, value, list[i], isDynamic)
         }
-      } else if (onRE.test(name)) { // v-on
+      } else if (onRE.test(name)) {
+        // v-on
         name = name.replace(onRE, '')
         isDynamic = dynamicArgRE.test(name)
         if (isDynamic) {
           name = name.slice(1, -1)
         }
         addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic)
-      } else { // normal directives
+      } else {
+        // normal directives
         name = name.replace(dirRE, '')
         // parse arg
         const argMatch = name.match(argRE)
@@ -861,7 +870,16 @@ function processAttrs (el) {
             isDynamic = true
           }
         }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i])
+        addDirective(
+          el,
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamic,
+          modifiers,
+          list[i]
+        )
         if (process.env.NODE_ENV !== 'production' && name === 'model') {
           checkForAliasModel(el, value)
         }
@@ -873,9 +891,9 @@ function processAttrs (el) {
         if (res) {
           warn(
             `${name}="${value}": ` +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
+              'Interpolation inside attributes has been removed. ' +
+              'Use v-bind or the colon shorthand instead. For example, ' +
+              'instead of <div id="{{ val }}">, use <div :id="val">.',
             list[i]
           )
         }
@@ -883,17 +901,19 @@ function processAttrs (el) {
       addAttr(el, name, JSON.stringify(value), list[i])
       // #6887 firefox doesn't update muted state if set via attribute
       // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+      if (
+        !el.component &&
+        name === 'muted' &&
+        platformMustUseProp(el.tag, el.attrsMap.type, name)
+      ) {
         addProp(el, name, 'true', list[i])
       }
     }
   }
 }
 
-function checkInFor (el: ASTElement): boolean {
-  let parent = el
+function checkInFor(el: ASTElement): boolean {
+  let parent: ASTElement | void = el
   while (parent) {
     if (parent.for !== undefined) {
       return true
@@ -903,21 +923,25 @@ function checkInFor (el: ASTElement): boolean {
   return false
 }
 
-function parseModifiers (name: string): Object | void {
+function parseModifiers(name: string): Object | void {
   const match = name.match(modifierRE)
   if (match) {
     const ret = {}
-    match.forEach(m => { ret[m.slice(1)] = true })
+    match.forEach((m) => {
+      ret[m.slice(1)] = true
+    })
     return ret
   }
 }
 
-function makeAttrsMap (attrs: Array<Object>): Object {
+function makeAttrsMap(attrs: Array<Record<string, any>>): Record<string, any> {
   const map = {}
   for (let i = 0, l = attrs.length; i < l; i++) {
     if (
       process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
+      map[attrs[i].name] &&
+      !isIE &&
+      !isEdge
     ) {
       warn('duplicate attribute: ' + attrs[i].name, attrs[i])
     }
@@ -927,17 +951,15 @@ function makeAttrsMap (attrs: Array<Object>): Object {
 }
 
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el): boolean {
+function isTextTag(el): boolean {
   return el.tag === 'script' || el.tag === 'style'
 }
 
-function isForbiddenTag (el): boolean {
+function isForbiddenTag(el): boolean {
   return (
     el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
+    (el.tag === 'script' &&
+      (!el.attrsMap.type || el.attrsMap.type === 'text/javascript'))
   )
 }
 
@@ -945,8 +967,8 @@ const ieNSBug = /^xmlns:NS\d+/
 const ieNSPrefix = /^NS\d+:/
 
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  const res = []
+function guardIESVGBug(attrs) {
+  const res: any[] = []
   for (let i = 0; i < attrs.length; i++) {
     const attr = attrs[i]
     if (!ieNSBug.test(attr.name)) {
@@ -957,16 +979,16 @@ function guardIESVGBug (attrs) {
   return res
 }
 
-function checkForAliasModel (el, value) {
+function checkForAliasModel(el, value) {
   let _el = el
   while (_el) {
     if (_el.for && _el.alias === value) {
       warn(
         `<${el.tag} v-model="${value}">: ` +
-        `You are binding v-model directly to a v-for iteration alias. ` +
-        `This will not be able to modify the v-for source array because ` +
-        `writing to the alias is like modifying a function local variable. ` +
-        `Consider using an array of objects and use v-model on an object property instead.`,
+          `You are binding v-model directly to a v-for iteration alias. ` +
+          `This will not be able to modify the v-for source array because ` +
+          `writing to the alias is like modifying a function local variable. ` +
+          `Consider using an array of objects and use v-model on an object property instead.`,
         el.rawAttrsMap['v-model']
       )
     }
diff --git a/src/compiler/parser/text-parser.js b/src/compiler/parser/text-parser.ts
similarity index 76%
rename from src/compiler/parser/text-parser.js
rename to src/compiler/parser/text-parser.ts
index cf82a62484f..bb4dcd7a5eb 100644
--- a/src/compiler/parser/text-parser.js
+++ b/src/compiler/parser/text-parser.ts
@@ -6,34 +6,35 @@ import { parseFilters } from './filter-parser'
 const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
 const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
 
-const buildRegex = cached(delimiters => {
+const buildRegex = cached((delimiters) => {
   const open = delimiters[0].replace(regexEscapeRE, '\\$&')
   const close = delimiters[1].replace(regexEscapeRE, '\\$&')
   return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
 })
 
 type TextParseResult = {
-  expression: string,
+  expression: string
   tokens: Array<string | { '@binding': string }>
 }
 
-export function parseText (
+export function parseText(
   text: string,
   delimiters?: [string, string]
 ): TextParseResult | void {
+  //@ts-expect-error
   const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
   if (!tagRE.test(text)) {
     return
   }
-  const tokens = []
-  const rawTokens = []
-  let lastIndex = tagRE.lastIndex = 0
+  const tokens: string[] = []
+  const rawTokens: any[] = []
+  let lastIndex = (tagRE.lastIndex = 0)
   let match, index, tokenValue
   while ((match = tagRE.exec(text))) {
     index = match.index
     // push text token
     if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index))
+      rawTokens.push((tokenValue = text.slice(lastIndex, index)))
       tokens.push(JSON.stringify(tokenValue))
     }
     // tag token
@@ -43,11 +44,11 @@ export function parseText (
     lastIndex = index + match[0].length
   }
   if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex))
+    rawTokens.push((tokenValue = text.slice(lastIndex)))
     tokens.push(JSON.stringify(tokenValue))
   }
   return {
     expression: tokens.join('+'),
-    tokens: rawTokens
+    tokens: rawTokens,
   }
 }
diff --git a/src/compiler/to-function.js b/src/compiler/to-function.ts
similarity index 67%
rename from src/compiler/to-function.js
rename to src/compiler/to-function.ts
index f607ec351d2..d14f45fbf03 100644
--- a/src/compiler/to-function.js
+++ b/src/compiler/to-function.ts
@@ -3,13 +3,14 @@
 import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
 import { generateCodeFrame } from './codeframe'
+import { Component } from 'typescript/component'
 
 type CompiledFunctionResult = {
-  render: Function;
-  staticRenderFns: Array<Function>;
-};
+  render: Function
+  staticRenderFns: Array<Function>
+}
 
-function createFunction (code, errors) {
+function createFunction(code, errors) {
   try {
     return new Function(code)
   } catch (err) {
@@ -18,10 +19,10 @@ function createFunction (code, errors) {
   }
 }
 
-export function createCompileToFunctionFn (compile: Function): Function {
+export function createCompileToFunctionFn(compile: Function): Function {
   const cache = Object.create(null)
 
-  return function compileToFunctions (
+  return function compileToFunctions(
     template: string,
     options?: CompilerOptions,
     vm?: Component
@@ -39,10 +40,10 @@ export function createCompileToFunctionFn (compile: Function): Function {
         if (e.toString().match(/unsafe-eval|CSP/)) {
           warn(
             'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
+              'environment with Content Security Policy that prohibits unsafe-eval. ' +
+              'The template compiler cannot work in this environment. Consider ' +
+              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+              'templates into render functions.'
           )
         }
       }
@@ -63,35 +64,36 @@ export function createCompileToFunctionFn (compile: Function): Function {
     if (process.env.NODE_ENV !== 'production') {
       if (compiled.errors && compiled.errors.length) {
         if (options.outputSourceRange) {
-          compiled.errors.forEach(e => {
+          compiled.errors.forEach((e) => {
             warn(
               `Error compiling template:\n\n${e.msg}\n\n` +
-              generateCodeFrame(template, e.start, e.end),
+                generateCodeFrame(template, e.start, e.end),
               vm
             )
           })
         } else {
           warn(
             `Error compiling template:\n\n${template}\n\n` +
-            compiled.errors.map(e => `- ${e}`).join('\n') + '\n',
+              compiled.errors.map((e) => `- ${e}`).join('\n') +
+              '\n',
             vm
           )
         }
       }
       if (compiled.tips && compiled.tips.length) {
         if (options.outputSourceRange) {
-          compiled.tips.forEach(e => tip(e.msg, vm))
+          compiled.tips.forEach((e) => tip(e.msg, vm))
         } else {
-          compiled.tips.forEach(msg => tip(msg, vm))
+          compiled.tips.forEach((msg) => tip(msg, vm))
         }
       }
     }
 
     // turn code into functions
-    const res = {}
+    const res: any = {}
     const fnGenErrors = []
     res.render = createFunction(compiled.render, fnGenErrors)
-    res.staticRenderFns = compiled.staticRenderFns.map(code => {
+    res.staticRenderFns = compiled.staticRenderFns.map((code) => {
       return createFunction(code, fnGenErrors)
     })
 
@@ -103,7 +105,11 @@ export function createCompileToFunctionFn (compile: Function): Function {
       if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
         warn(
           `Failed to generate render function:\n\n` +
-          fnGenErrors.map(({ err, code }) => `${err.toString()} in\n\n${code}\n`).join('\n'),
+            fnGenErrors
+              .map(
+                ({ err, code }) => `${(err as any).toString()} in\n\n${code}\n`
+              )
+              .join('\n'),
           vm
         )
       }
diff --git a/src/core/components/index.js b/src/core/components/index.ts
similarity index 81%
rename from src/core/components/index.js
rename to src/core/components/index.ts
index 5461c763841..3c681dae261 100644
--- a/src/core/components/index.js
+++ b/src/core/components/index.ts
@@ -1,5 +1,5 @@
 import KeepAlive from './keep-alive'
 
 export default {
-  KeepAlive
+  KeepAlive,
 }
diff --git a/src/core/components/keep-alive.js b/src/core/components/keep-alive.ts
similarity index 64%
rename from src/core/components/keep-alive.js
rename to src/core/components/keep-alive.ts
index fb4cf1e883b..6af29e4afac 100644
--- a/src/core/components/keep-alive.js
+++ b/src/core/components/keep-alive.ts
@@ -1,15 +1,20 @@
-/* @flow */
+// @ts-nocheck
 
 import { isRegExp, remove } from 'shared/util'
 import { getFirstComponentChild } from 'core/vdom/helpers/index'
+import VNode from 'core/vdom/vnode'
+import { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
 
-type VNodeCache = { [key: string]: ?VNode };
+type VNodeCache = { [key: string]: VNode | null }
 
-function getComponentName (opts: ?VNodeComponentOptions): ?string {
+function getComponentName(opts?: VNodeComponentOptions): string | null {
   return opts && (opts.Ctor.options.name || opts.tag)
 }
 
-function matches (pattern: string | RegExp | Array<string>, name: string): boolean {
+function matches(
+  pattern: string | RegExp | Array<string>,
+  name: string
+): boolean {
   if (Array.isArray(pattern)) {
     return pattern.indexOf(name) > -1
   } else if (typeof pattern === 'string') {
@@ -21,12 +26,12 @@ function matches (pattern: string | RegExp | Array<string>, name: string): boole
   return false
 }
 
-function pruneCache (keepAliveInstance: any, filter: Function) {
+function pruneCache(keepAliveInstance: any, filter: Function) {
   const { cache, keys, _vnode } = keepAliveInstance
   for (const key in cache) {
-    const cachedNode: ?VNode = cache[key]
+    const cachedNode: VNode | null = cache[key]
     if (cachedNode) {
-      const name: ?string = getComponentName(cachedNode.componentOptions)
+      const name = getComponentName(cachedNode.componentOptions)
       if (name && !filter(name)) {
         pruneCacheEntry(cache, key, keys, _vnode)
       }
@@ -34,7 +39,7 @@ function pruneCache (keepAliveInstance: any, filter: Function) {
   }
 }
 
-function pruneCacheEntry (
+function pruneCacheEntry(
   cache: VNodeCache,
   key: string,
   keys: Array<string>,
@@ -50,6 +55,7 @@ function pruneCacheEntry (
 
 const patternTypes: Array<Function> = [String, RegExp, Array]
 
+// TODO use defineComponent
 export default {
   name: 'keep-alive',
   abstract: true,
@@ -57,33 +63,34 @@ export default {
   props: {
     include: patternTypes,
     exclude: patternTypes,
-    max: [String, Number]
+    max: [String, Number],
   },
 
-  created () {
+  created() {
     this.cache = Object.create(null)
     this.keys = []
   },
 
-  destroyed () {
+  destroyed() {
     for (const key in this.cache) {
       pruneCacheEntry(this.cache, key, this.keys)
     }
   },
 
-  mounted () {
-    this.$watch('include', val => {
-      pruneCache(this, name => matches(val, name))
+  mounted() {
+    this.$watch('include', (val) => {
+      pruneCache(this, (name) => matches(val, name))
     })
-    this.$watch('exclude', val => {
-      pruneCache(this, name => !matches(val, name))
+    this.$watch('exclude', (val) => {
+      pruneCache(this, (name) => !matches(val, name))
     })
   },
 
-  render () {
+  render() {
     const slot = this.$slots.default
     const vnode: VNode = getFirstComponentChild(slot)
-    const componentOptions: ?VNodeComponentOptions = vnode && vnode.componentOptions
+    const componentOptions: ?VNodeComponentOptions =
+      vnode && vnode.componentOptions
     if (componentOptions) {
       // check pattern
       const name: ?string = getComponentName(componentOptions)
@@ -98,11 +105,13 @@ export default {
       }
 
       const { cache, keys } = this
-      const key: ?string = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '')
-        : vnode.key
+      const key: ?string =
+        vnode.key == null
+          ? // same constructor may get registered as different local components
+            // so cid alone is not enough (#3269)
+            componentOptions.Ctor.cid +
+            (componentOptions.tag ? `::${componentOptions.tag}` : '')
+          : vnode.key
       if (cache[key]) {
         vnode.componentInstance = cache[key].componentInstance
         // make current key freshest
@@ -120,5 +129,5 @@ export default {
       vnode.data.keepAlive = true
     }
     return vnode || (slot && slot[0])
-  }
+  },
 }
diff --git a/src/core/config.js b/src/core/config.ts
similarity index 69%
rename from src/core/config.js
rename to src/core/config.ts
index cae9d3dd395..c3924c4107e 100644
--- a/src/core/config.js
+++ b/src/core/config.ts
@@ -1,39 +1,36 @@
 /* @flow */
 
-import {
-  no,
-  noop,
-  identity
-} from 'shared/util'
+import { no, noop, identity } from 'shared/util'
 
 import { LIFECYCLE_HOOKS } from 'shared/constants'
+import { Component } from 'typescript/component'
 
 export type Config = {
   // user
-  optionMergeStrategies: { [key: string]: Function };
-  silent: boolean;
-  productionTip: boolean;
-  performance: boolean;
-  devtools: boolean;
-  errorHandler: ?(err: Error, vm: Component, info: string) => void;
-  warnHandler: ?(msg: string, vm: Component, trace: string) => void;
-  ignoredElements: Array<string | RegExp>;
-  keyCodes: { [key: string]: number | Array<number> };
+  optionMergeStrategies: { [key: string]: Function }
+  silent: boolean
+  productionTip: boolean
+  performance: boolean
+  devtools: boolean
+  errorHandler?: (err: Error, vm: Component, info: string) => void
+  warnHandler?: (msg: string, vm: Component, trace: string) => void
+  ignoredElements: Array<string | RegExp>
+  keyCodes: { [key: string]: number | Array<number> }
 
   // platform
-  isReservedTag: (x?: string) => boolean;
-  isReservedAttr: (x?: string) => boolean;
-  parsePlatformTagName: (x: string) => string;
-  isUnknownElement: (x?: string) => boolean;
-  getTagNamespace: (x?: string) => string | void;
-  mustUseProp: (tag: string, type: ?string, name: string) => boolean;
+  isReservedTag: (x?: string) => boolean
+  isReservedAttr: (x?: string) => boolean
+  parsePlatformTagName: (x: string) => string
+  isUnknownElement: (x?: string) => boolean
+  getTagNamespace: (x?: string) => string | void
+  mustUseProp: (tag: string, type?: string, name?: string) => boolean
 
   // private
-  async: boolean;
+  async: boolean
 
   // legacy
-  _lifecycleHooks: Array<string>;
-};
+  _lifecycleHooks: Array<string>
+}
 
 export default ({
   /**
@@ -126,5 +123,5 @@ export default ({
   /**
    * Exposed for legacy reasons
    */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-}: Config)
+  _lifecycleHooks: LIFECYCLE_HOOKS,
+} as unknown) as Config
diff --git a/src/core/global-api/assets.js b/src/core/global-api/assets.ts
similarity index 78%
rename from src/core/global-api/assets.js
rename to src/core/global-api/assets.ts
index d975a6a5977..93cc7fc29d1 100644
--- a/src/core/global-api/assets.js
+++ b/src/core/global-api/assets.ts
@@ -1,16 +1,18 @@
 /* @flow */
 
 import { ASSET_TYPES } from 'shared/constants'
+import { GlobalAPI } from 'typescript/global-api'
 import { isPlainObject, validateComponentName } from '../util/index'
 
-export function initAssetRegisters (Vue: GlobalAPI) {
+export function initAssetRegisters(Vue: GlobalAPI) {
   /**
    * Create asset registration methods.
    */
-  ASSET_TYPES.forEach(type => {
+  ASSET_TYPES.forEach((type) => {
+    // @ts-expect-error function is not exact same type
     Vue[type] = function (
       id: string,
-      definition: Function | Object
+      definition?: Function | Object
     ): Function | Object | void {
       if (!definition) {
         return this.options[type + 's'][id]
@@ -20,6 +22,7 @@ export function initAssetRegisters (Vue: GlobalAPI) {
           validateComponentName(id)
         }
         if (type === 'component' && isPlainObject(definition)) {
+          // @ts-expect-error
           definition.name = definition.name || id
           definition = this.options._base.extend(definition)
         }
diff --git a/src/core/global-api/extend.js b/src/core/global-api/extend.ts
similarity index 84%
rename from src/core/global-api/extend.js
rename to src/core/global-api/extend.ts
index c1bbda3f003..0cb8b4b5091 100644
--- a/src/core/global-api/extend.js
+++ b/src/core/global-api/extend.ts
@@ -1,10 +1,12 @@
 /* @flow */
 
 import { ASSET_TYPES } from 'shared/constants'
+import { Component } from 'typescript/component'
+import { GlobalAPI } from 'typescript/global-api'
 import { defineComputed, proxy } from '../instance/state'
 import { extend, mergeOptions, validateComponentName } from '../util/index'
 
-export function initExtend (Vue: GlobalAPI) {
+export function initExtend(Vue: GlobalAPI) {
   /**
    * Each instance constructor, including Vue, has a unique
    * cid. This enables us to create wrapped "child
@@ -16,7 +18,7 @@ export function initExtend (Vue: GlobalAPI) {
   /**
    * Class inheritance
    */
-  Vue.extend = function (extendOptions: Object): Function {
+  Vue.extend = function (extendOptions: any): Component {
     extendOptions = extendOptions || {}
     const Super = this
     const SuperId = Super.cid
@@ -30,16 +32,13 @@ export function initExtend (Vue: GlobalAPI) {
       validateComponentName(name)
     }
 
-    const Sub = function VueComponent (options) {
+    const Sub = (function VueComponent(this: any, options: any) {
       this._init(options)
-    }
+    } as unknown) as Component
     Sub.prototype = Object.create(Super.prototype)
     Sub.prototype.constructor = Sub
     Sub.cid = cid++
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    )
+    Sub.options = mergeOptions(Super.options, extendOptions)
     Sub['super'] = Super
 
     // For props and computed properties, we define the proxy getters on
@@ -80,14 +79,14 @@ export function initExtend (Vue: GlobalAPI) {
   }
 }
 
-function initProps (Comp) {
+function initProps(Comp: Component) {
   const props = Comp.options.props
   for (const key in props) {
     proxy(Comp.prototype, `_props`, key)
   }
 }
 
-function initComputed (Comp) {
+function initComputed(Comp: Component) {
   const computed = Comp.options.computed
   for (const key in computed) {
     defineComputed(Comp.prototype, key, computed[key])
diff --git a/src/core/global-api/index.js b/src/core/global-api/index.ts
similarity index 87%
rename from src/core/global-api/index.js
rename to src/core/global-api/index.ts
index b3387a891ff..071f76d8f2c 100644
--- a/src/core/global-api/index.js
+++ b/src/core/global-api/index.ts
@@ -15,12 +15,13 @@ import {
   extend,
   nextTick,
   mergeOptions,
-  defineReactive
+  defineReactive,
 } from '../util/index'
+import { GlobalAPI } from 'typescript/global-api'
 
-export function initGlobalAPI (Vue: GlobalAPI) {
+export function initGlobalAPI(Vue: GlobalAPI) {
   // config
-  const configDef = {}
+  const configDef: Record<string, any> = {}
   configDef.get = () => config
   if (process.env.NODE_ENV !== 'production') {
     configDef.set = () => {
@@ -38,7 +39,7 @@ export function initGlobalAPI (Vue: GlobalAPI) {
     warn,
     extend,
     mergeOptions,
-    defineReactive
+    defineReactive,
   }
 
   Vue.set = set
@@ -52,7 +53,7 @@ export function initGlobalAPI (Vue: GlobalAPI) {
   }
 
   Vue.options = Object.create(null)
-  ASSET_TYPES.forEach(type => {
+  ASSET_TYPES.forEach((type) => {
     Vue.options[type + 's'] = Object.create(null)
   })
 
diff --git a/src/core/global-api/mixin.js b/src/core/global-api/mixin.ts
similarity index 65%
rename from src/core/global-api/mixin.js
rename to src/core/global-api/mixin.ts
index 36017a324a2..9d78e2cd3c4 100644
--- a/src/core/global-api/mixin.js
+++ b/src/core/global-api/mixin.ts
@@ -1,8 +1,9 @@
 /* @flow */
 
+import { GlobalAPI } from 'typescript/global-api'
 import { mergeOptions } from '../util/index'
 
-export function initMixin (Vue: GlobalAPI) {
+export function initMixin(Vue: GlobalAPI) {
   Vue.mixin = function (mixin: Object) {
     this.options = mergeOptions(this.options, mixin)
     return this
diff --git a/src/core/global-api/use.js b/src/core/global-api/use.ts
similarity index 65%
rename from src/core/global-api/use.js
rename to src/core/global-api/use.ts
index a5b69988ddc..bdc37b08972 100644
--- a/src/core/global-api/use.js
+++ b/src/core/global-api/use.ts
@@ -1,10 +1,12 @@
 /* @flow */
 
+import { GlobalAPI } from 'typescript/global-api'
 import { toArray } from '../util/index'
 
-export function initUse (Vue: GlobalAPI) {
-  Vue.use = function (plugin: Function | Object) {
-    const installedPlugins = (this._installedPlugins || (this._installedPlugins = []))
+export function initUse(Vue: GlobalAPI) {
+  Vue.use = function (plugin: Function | any) {
+    const installedPlugins =
+      this._installedPlugins || (this._installedPlugins = [])
     if (installedPlugins.indexOf(plugin) > -1) {
       return this
     }
diff --git a/src/core/index.js b/src/core/index.ts
similarity index 87%
rename from src/core/index.js
rename to src/core/index.ts
index daf6203b263..ac6e38e914b 100644
--- a/src/core/index.js
+++ b/src/core/index.ts
@@ -1,3 +1,4 @@
+//@ts-nocheck
 import Vue from './instance/index'
 import { initGlobalAPI } from './global-api/index'
 import { isServerRendering } from 'core/util/env'
@@ -6,19 +7,19 @@ import { FunctionalRenderContext } from 'core/vdom/create-functional-component'
 initGlobalAPI(Vue)
 
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+  get: isServerRendering,
 })
 
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get () {
+  get() {
     /* istanbul ignore next */
     return this.$vnode && this.$vnode.ssrContext
-  }
+  },
 })
 
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+  value: FunctionalRenderContext,
 })
 
 Vue.version = '__VERSION__'
diff --git a/src/core/instance/events.js b/src/core/instance/events.ts
similarity index 67%
rename from src/core/instance/events.js
rename to src/core/instance/events.ts
index 4d5bb552850..413e1cf3da9 100644
--- a/src/core/instance/events.js
+++ b/src/core/instance/events.ts
@@ -1,15 +1,16 @@
 /* @flow */
 
+import { Component } from 'typescript/component'
 import {
   tip,
   toArray,
   hyphenate,
   formatComponentName,
-  invokeWithErrorHandling
+  invokeWithErrorHandling,
 } from '../util/index'
 import { updateListeners } from '../vdom/helpers/index'
 
-export function initEvents (vm: Component) {
+export function initEvents(vm: Component) {
   vm._events = Object.create(null)
   vm._hasHookEvent = false
   // init parent attached events
@@ -21,17 +22,17 @@ export function initEvents (vm: Component) {
 
 let target: any
 
-function add (event, fn) {
+function add(event, fn) {
   target.$on(event, fn)
 }
 
-function remove (event, fn) {
+function remove(event, fn) {
   target.$off(event, fn)
 }
 
-function createOnceHandler (event, fn) {
+function createOnceHandler(event, fn) {
   const _target = target
-  return function onceHandler () {
+  return function onceHandler() {
     const res = fn.apply(null, arguments)
     if (res !== null) {
       _target.$off(event, onceHandler)
@@ -39,26 +40,36 @@ function createOnceHandler (event, fn) {
   }
 }
 
-export function updateComponentListeners (
+export function updateComponentListeners(
   vm: Component,
   listeners: Object,
-  oldListeners: ?Object
+  oldListeners?: Object | null
 ) {
   target = vm
-  updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm)
+  updateListeners(
+    listeners,
+    oldListeners || {},
+    add,
+    remove,
+    createOnceHandler,
+    vm
+  )
   target = undefined
 }
 
-export function eventsMixin (Vue: Class<Component>) {
+export function eventsMixin(Vue: Component) {
   const hookRE = /^hook:/
-  Vue.prototype.$on = function (event: string | Array<string>, fn: Function): Component {
+  Vue.prototype.$on = function (
+    event: string | Array<string>,
+    fn: Function
+  ): Component {
     const vm: Component = this
     if (Array.isArray(event)) {
       for (let i = 0, l = event.length; i < l; i++) {
         vm.$on(event[i], fn)
       }
     } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn)
+      ;(vm._events[event] || (vm._events[event] = [])).push(fn)
       // optimize hook:event cost by using a boolean flag marked at registration
       // instead of a hash lookup
       if (hookRE.test(event)) {
@@ -70,7 +81,7 @@ export function eventsMixin (Vue: Class<Component>) {
 
   Vue.prototype.$once = function (event: string, fn: Function): Component {
     const vm: Component = this
-    function on () {
+    function on() {
       vm.$off(event, on)
       fn.apply(vm, arguments)
     }
@@ -79,7 +90,10 @@ export function eventsMixin (Vue: Class<Component>) {
     return vm
   }
 
-  Vue.prototype.$off = function (event?: string | Array<string>, fn?: Function): Component {
+  Vue.prototype.$off = function (
+    event?: string | Array<string>,
+    fn?: Function
+  ): Component {
     const vm: Component = this
     // all
     if (!arguments.length) {
@@ -94,12 +108,12 @@ export function eventsMixin (Vue: Class<Component>) {
       return vm
     }
     // specific event
-    const cbs = vm._events[event]
+    const cbs = vm._events[event!]
     if (!cbs) {
       return vm
     }
     if (!fn) {
-      vm._events[event] = null
+      vm._events[event!] = null
       return vm
     }
     // specific handler
@@ -122,10 +136,14 @@ export function eventsMixin (Vue: Class<Component>) {
       if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
         tip(
           `Event "${lowerCaseEvent}" is emitted in component ` +
-          `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-          `Note that HTML attributes are case-insensitive and you cannot use ` +
-          `v-on to listen to camelCase events when using in-DOM templates. ` +
-          `You should probably use "${hyphenate(event)}" instead of "${event}".`
+            `${formatComponentName(
+              vm
+            )} but the handler is registered for "${event}". ` +
+            `Note that HTML attributes are case-insensitive and you cannot use ` +
+            `v-on to listen to camelCase events when using in-DOM templates. ` +
+            `You should probably use "${hyphenate(
+              event
+            )}" instead of "${event}".`
         )
       }
     }
diff --git a/src/core/instance/index.js b/src/core/instance/index.ts
similarity index 80%
rename from src/core/instance/index.js
rename to src/core/instance/index.ts
index 8a4402317f5..1d15d1cfb39 100644
--- a/src/core/instance/index.js
+++ b/src/core/instance/index.ts
@@ -1,3 +1,4 @@
+//@ts-nocheck
 import { initMixin } from './init'
 import { stateMixin } from './state'
 import { renderMixin } from './render'
@@ -5,10 +6,8 @@ import { eventsMixin } from './events'
 import { lifecycleMixin } from './lifecycle'
 import { warn } from '../util/index'
 
-function Vue (options) {
-  if (process.env.NODE_ENV !== 'production' &&
-    !(this instanceof Vue)
-  ) {
+function Vue(options) {
+  if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
     warn('Vue is a constructor and should be called with the `new` keyword')
   }
   this._init(options)
diff --git a/src/core/instance/init.js b/src/core/instance/init.ts
similarity index 82%
rename from src/core/instance/init.js
rename to src/core/instance/init.ts
index 7c5ab2da963..addccccc633 100644
--- a/src/core/instance/init.js
+++ b/src/core/instance/init.ts
@@ -9,11 +9,13 @@ import { mark, measure } from '../util/perf'
 import { initLifecycle, callHook } from './lifecycle'
 import { initProvide, initInjections } from './inject'
 import { extend, mergeOptions, formatComponentName } from '../util/index'
+import { Component } from 'typescript/component'
+import { InternalComponentOptions } from 'typescript/options'
 
 let uid = 0
 
-export function initMixin (Vue: Class<Component>) {
-  Vue.prototype._init = function (options?: Object) {
+export function initMixin(Vue: Component) {
+  Vue.prototype._init = function (options?: Record<string, any>) {
     const vm: Component = this
     // a uid
     vm._uid = uid++
@@ -33,10 +35,10 @@ export function initMixin (Vue: Class<Component>) {
       // optimize internal component instantiation
       // since dynamic options merging is pretty slow, and none of the
       // internal component options needs special treatment.
-      initInternalComponent(vm, options)
+      initInternalComponent(vm, options as any)
     } else {
       vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
+        resolveConstructorOptions(vm.constructor as any),
         options || {},
         vm
       )
@@ -71,14 +73,18 @@ export function initMixin (Vue: Class<Component>) {
   }
 }
 
-export function initInternalComponent (vm: Component, options: InternalComponentOptions) {
-  const opts = vm.$options = Object.create(vm.constructor.options)
+export function initInternalComponent(
+  vm: Component,
+  options: InternalComponentOptions
+) {
+  // @ts-ignore
+  const opts = (vm.$options = Object.create(vm.constructor.options))
   // doing this because it's faster than dynamic enumeration.
   const parentVnode = options._parentVnode
   opts.parent = options.parent
   opts._parentVnode = parentVnode
 
-  const vnodeComponentOptions = parentVnode.componentOptions
+  const vnodeComponentOptions = parentVnode.componentOptions!
   opts.propsData = vnodeComponentOptions.propsData
   opts._parentListeners = vnodeComponentOptions.listeners
   opts._renderChildren = vnodeComponentOptions.children
@@ -90,7 +96,7 @@ export function initInternalComponent (vm: Component, options: InternalComponent
   }
 }
 
-export function resolveConstructorOptions (Ctor: Class<Component>) {
+export function resolveConstructorOptions(Ctor: Component) {
   let options = Ctor.options
   if (Ctor.super) {
     const superOptions = resolveConstructorOptions(Ctor.super)
@@ -114,7 +120,7 @@ export function resolveConstructorOptions (Ctor: Class<Component>) {
   return options
 }
 
-function resolveModifiedOptions (Ctor: Class<Component>): ?Object {
+function resolveModifiedOptions(Ctor: Component): Record<string, any> | null {
   let modified
   const latest = Ctor.options
   const sealed = Ctor.sealedOptions
diff --git a/src/core/instance/inject.js b/src/core/instance/inject.ts
similarity index 65%
rename from src/core/instance/inject.js
rename to src/core/instance/inject.ts
index b04184e516a..2ffb3baec4d 100644
--- a/src/core/instance/inject.js
+++ b/src/core/instance/inject.ts
@@ -3,28 +3,31 @@
 import { hasOwn } from 'shared/util'
 import { warn, hasSymbol } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
+import { Component } from 'typescript/component'
 
-export function initProvide (vm: Component) {
+export function initProvide(vm: Component) {
   const provide = vm.$options.provide
   if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide
+    vm._provided =
+      typeof provide === 'function'
+        ? // @ts-expect-error typing not correct
+          provide.call(vm)
+        : provide
   }
 }
 
-export function initInjections (vm: Component) {
+export function initInjections(vm: Component) {
   const result = resolveInject(vm.$options.inject, vm)
   if (result) {
     toggleObserving(false)
-    Object.keys(result).forEach(key => {
+    Object.keys(result).forEach((key) => {
       /* istanbul ignore else */
       if (process.env.NODE_ENV !== 'production') {
         defineReactive(vm, key, result[key], () => {
           warn(
             `Avoid mutating an injected value directly since the changes will be ` +
-            `overwritten whenever the provided component re-renders. ` +
-            `injection being mutated: "${key}"`,
+              `overwritten whenever the provided component re-renders. ` +
+              `injection being mutated: "${key}"`,
             vm
           )
         })
@@ -36,13 +39,14 @@ export function initInjections (vm: Component) {
   }
 }
 
-export function resolveInject (inject: any, vm: Component): ?Object {
+export function resolveInject(
+  inject: any,
+  vm: Component
+): Record<string, any> | undefined | null {
   if (inject) {
     // inject is :any because flow is not smart enough to figure out cached
     const result = Object.create(null)
-    const keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject)
+    const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject)
 
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i]
@@ -55,15 +59,18 @@ export function resolveInject (inject: any, vm: Component): ?Object {
           result[key] = source._provided[provideKey]
           break
         }
+        // @ts-expect-error
         source = source.$parent
       }
       if (!source) {
         if ('default' in inject[key]) {
           const provideDefault = inject[key].default
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault
+          result[key] =
+            typeof provideDefault === 'function'
+              ? provideDefault.call(vm)
+              : provideDefault
         } else if (process.env.NODE_ENV !== 'production') {
+          // @ts-ignore
           warn(`Injection "${key}" not found`, vm)
         }
       }
diff --git a/src/core/instance/lifecycle.js b/src/core/instance/lifecycle.ts
similarity index 81%
rename from src/core/instance/lifecycle.js
rename to src/core/instance/lifecycle.ts
index b7265df0aaf..ea4d84c9b8e 100644
--- a/src/core/instance/lifecycle.js
+++ b/src/core/instance/lifecycle.ts
@@ -3,7 +3,7 @@
 import config from '../config'
 import Watcher from '../observer/watcher'
 import { mark, measure } from '../util/perf'
-import { createEmptyVNode } from '../vdom/vnode'
+import VNode, { createEmptyVNode } from '../vdom/vnode'
 import { updateComponentListeners } from './events'
 import { resolveSlots } from './render-helpers/resolve-slots'
 import { toggleObserving } from '../observer/index'
@@ -15,8 +15,10 @@ import {
   remove,
   emptyObject,
   validateProp,
-  invokeWithErrorHandling
+  invokeWithErrorHandling,
 } from '../util/index'
+import { Component } from 'typescript/component'
+import { MountedComponentVNode } from 'typescript/vnode'
 
 export let activeInstance: any = null
 export let isUpdatingChildComponent: boolean = false
@@ -29,8 +31,8 @@ export function setActiveInstance(vm: Component) {
   }
 }
 
-export function initLifecycle (vm: Component) {
-  const options = vm.$options
+export function initLifecycle(vm: Component) {
+  const options: any = vm.$options
 
   // locate first non-abstract parent
   let parent = options.parent
@@ -47,6 +49,7 @@ export function initLifecycle (vm: Component) {
   vm.$children = []
   vm.$refs = {}
 
+  // @ts-ignore
   vm._watcher = null
   vm._inactive = null
   vm._directInactive = false
@@ -55,7 +58,7 @@ export function initLifecycle (vm: Component) {
   vm._isBeingDestroyed = false
 }
 
-export function lifecycleMixin (Vue: Class<Component>) {
+export function lifecycleMixin(Vue: Component) {
   Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
     const vm: Component = this
     const prevEl = vm.$el
@@ -103,6 +106,7 @@ export function lifecycleMixin (Vue: Class<Component>) {
     vm._isBeingDestroyed = true
     // remove self from parent
     const parent = vm.$parent
+    // @ts-ignore
     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
       remove(parent.$children, vm)
     }
@@ -116,7 +120,9 @@ export function lifecycleMixin (Vue: Class<Component>) {
     }
     // remove reference from data ob
     // frozen object may not have observer.
+    //@ts-expect-error internal usage
     if (vm._data.__ob__) {
+      //@ts-expect-error internal usage
       vm._data.__ob__.vmCount--
     }
     // call the last hook...
@@ -133,27 +139,32 @@ export function lifecycleMixin (Vue: Class<Component>) {
     }
     // release circular reference (#6759)
     if (vm.$vnode) {
+      // @ts-expect-error null is not undefined
       vm.$vnode.parent = null
     }
   }
 }
 
-export function mountComponent (
+export function mountComponent(
   vm: Component,
-  el: ?Element,
+  el: Element | null,
   hydrating?: boolean
 ): Component {
   vm.$el = el
   if (!vm.$options.render) {
+    // @ts-expect-error invalid type
     vm.$options.render = createEmptyVNode
     if (process.env.NODE_ENV !== 'production') {
       /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
+      if (
+        (vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+        vm.$options.el ||
+        el
+      ) {
         warn(
           'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
+            'compiler is not available. Either pre-compile the templates into ' +
+            'render functions, or use the compiler-included build.',
           vm
         )
       } else {
@@ -194,13 +205,19 @@ export function mountComponent (
   // we set this to vm._watcher inside the watcher's constructor
   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
   // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate')
-      }
-    }
-  }, true /* isRenderWatcher */)
+  new Watcher(
+    vm,
+    updateComponent,
+    noop,
+    {
+      before() {
+        if (vm._isMounted && !vm._isDestroyed) {
+          callHook(vm, 'beforeUpdate')
+        }
+      },
+    },
+    true /* isRenderWatcher */
+  )
   hydrating = false
 
   // manually mounted instance, call mounted on self
@@ -212,12 +229,12 @@ export function mountComponent (
   return vm
 }
 
-export function updateChildComponent (
+export function updateChildComponent(
   vm: Component,
-  propsData: ?Object,
-  listeners: ?Object,
-  parentVnode: MountedComponentVNode,
-  renderChildren: ?Array<VNode>
+  propsData?: Object | null,
+  listeners?: Object | null,
+  parentVnode?: MountedComponentVNode,
+  renderChildren?: Array<VNode> | null
 ) {
   if (process.env.NODE_ENV !== 'production') {
     isUpdatingChildComponent = true
@@ -229,7 +246,7 @@ export function updateChildComponent (
   // check if there are dynamic scopedSlots (hand-written or compiled but with
   // dynamic slot names). Static scoped slots compiled from template has the
   // "$stable" marker.
-  const newScopedSlots = parentVnode.data.scopedSlots
+  const newScopedSlots = parentVnode!.data.scopedSlots
   const oldScopedSlots = vm.$scopedSlots
   const hasDynamicScopedSlot = !!(
     (newScopedSlots && !newScopedSlots.$stable) ||
@@ -241,15 +258,20 @@ export function updateChildComponent (
   // update. Dynamic scoped slots may also have changed. In such cases, a forced
   // update is necessary to ensure correctness.
   const needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
+    renderChildren || // has new static slots
+    vm.$options._renderChildren || // has old static slots
     hasDynamicScopedSlot
   )
 
+  // @ts-ignore
   vm.$options._parentVnode = parentVnode
+
+  // @ts-ignore
   vm.$vnode = parentVnode // update vm's placeholder node without re-render
 
-  if (vm._vnode) { // update child tree's parent
+  if (vm._vnode) {
+    // update child tree's parent
+    // @ts-ignore
     vm._vnode.parent = parentVnode
   }
   vm.$options._renderChildren = renderChildren
@@ -257,7 +279,8 @@ export function updateChildComponent (
   // update $attrs and $listeners hash
   // these are also reactive so they may trigger child update if the child
   // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject
+  vm.$attrs = parentVnode!.data.attrs || emptyObject
+  // @ts-ignore
   vm.$listeners = listeners || emptyObject
 
   // update props
@@ -283,7 +306,7 @@ export function updateChildComponent (
 
   // resolve slots + force update if has children
   if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context)
+    vm.$slots = resolveSlots(renderChildren, parentVnode!.context)
     vm.$forceUpdate()
   }
 
@@ -292,14 +315,14 @@ export function updateChildComponent (
   }
 }
 
-function isInInactiveTree (vm) {
+function isInInactiveTree(vm) {
   while (vm && (vm = vm.$parent)) {
     if (vm._inactive) return true
   }
   return false
 }
 
-export function activateChildComponent (vm: Component, direct?: boolean) {
+export function activateChildComponent(vm: Component, direct?: boolean) {
   if (direct) {
     vm._directInactive = false
     if (isInInactiveTree(vm)) {
@@ -317,7 +340,7 @@ export function activateChildComponent (vm: Component, direct?: boolean) {
   }
 }
 
-export function deactivateChildComponent (vm: Component, direct?: boolean) {
+export function deactivateChildComponent(vm: Component, direct?: boolean) {
   if (direct) {
     vm._directInactive = true
     if (isInInactiveTree(vm)) {
@@ -333,7 +356,7 @@ export function deactivateChildComponent (vm: Component, direct?: boolean) {
   }
 }
 
-export function callHook (vm: Component, hook: string) {
+export function callHook(vm: Component, hook: string) {
   // #7573 disable dep collection when invoking lifecycle hooks
   pushTarget()
   const handlers = vm.$options[hook]
diff --git a/src/core/instance/proxy.js b/src/core/instance/proxy.ts
similarity index 52%
rename from src/core/instance/proxy.js
rename to src/core/instance/proxy.ts
index b1884f7118c..f6bd109ff93 100644
--- a/src/core/instance/proxy.js
+++ b/src/core/instance/proxy.ts
@@ -8,18 +8,18 @@ let initProxy
 if (process.env.NODE_ENV !== 'production') {
   const allowedGlobals = makeMap(
     'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-    'require' // for Webpack/Browserify
+      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+      'require' // for Webpack/Browserify
   )
 
   const warnNonPresent = (target, key) => {
     warn(
       `Property or method "${key}" is not defined on the instance but ` +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
+        'referenced during render. Make sure that this property is reactive, ' +
+        'either in the data option, or for class-based components, by ' +
+        'initializing the property. ' +
+        'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
       target
     )
   }
@@ -27,61 +27,66 @@ if (process.env.NODE_ENV !== 'production') {
   const warnReservedPrefix = (target, key) => {
     warn(
       `Property "${key}" must be accessed with "$data.${key}" because ` +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
+        'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+        'prevent conflicts with Vue internals. ' +
+        'See: https://vuejs.org/v2/api/#data',
       target
     )
   }
 
-  const hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy)
+  const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy)
 
   if (hasProxy) {
-    const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact')
+    const isBuiltInModifier = makeMap(
+      'stop,prevent,self,ctrl,shift,alt,meta,exact'
+    )
     config.keyCodes = new Proxy(config.keyCodes, {
-      set (target, key, value) {
+      set(target, key, value) {
         if (isBuiltInModifier(key)) {
-          warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`)
+          warn(
+            `Avoid overwriting built-in modifier in config.keyCodes: .${key}`
+          )
           return false
         } else {
           target[key] = value
           return true
         }
-      }
+      },
     })
   }
 
   const hasHandler = {
-    has (target, key) {
+    has(target, key) {
       const has = key in target
-      const isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data))
+      const isAllowed =
+        allowedGlobals(key) ||
+        (typeof key === 'string' &&
+          key.charAt(0) === '_' &&
+          !(key in target.$data))
       if (!has && !isAllowed) {
         if (key in target.$data) warnReservedPrefix(target, key)
         else warnNonPresent(target, key)
       }
       return has || !isAllowed
-    }
+    },
   }
 
   const getHandler = {
-    get (target, key) {
+    get(target, key) {
       if (typeof key === 'string' && !(key in target)) {
         if (key in target.$data) warnReservedPrefix(target, key)
         else warnNonPresent(target, key)
       }
       return target[key]
-    }
+    },
   }
 
-  initProxy = function initProxy (vm) {
+  initProxy = function initProxy(vm) {
     if (hasProxy) {
       // determine which proxy handler to use
       const options = vm.$options
-      const handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler
+      const handlers =
+        options.render && options.render._withStripped ? getHandler : hasHandler
       vm._renderProxy = new Proxy(vm, handlers)
     } else {
       vm._renderProxy = vm
diff --git a/src/core/instance/render-helpers/bind-dynamic-keys.js b/src/core/instance/render-helpers/bind-dynamic-keys.ts
similarity index 77%
rename from src/core/instance/render-helpers/bind-dynamic-keys.js
rename to src/core/instance/render-helpers/bind-dynamic-keys.ts
index bf920744b81..d9fb03a377e 100644
--- a/src/core/instance/render-helpers/bind-dynamic-keys.js
+++ b/src/core/instance/render-helpers/bind-dynamic-keys.ts
@@ -11,12 +11,19 @@
 
 import { warn } from 'core/util/debug'
 
-export function bindDynamicKeys (baseObj: Object, values: Array<any>): Object {
+export function bindDynamicKeys(
+  baseObj: Record<string, any>,
+  values: Array<any>
+): Object {
   for (let i = 0; i < values.length; i += 2) {
     const key = values[i]
     if (typeof key === 'string' && key) {
       baseObj[values[i]] = values[i + 1]
-    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {
+    } else if (
+      process.env.NODE_ENV !== 'production' &&
+      key !== '' &&
+      key !== null
+    ) {
       // null is a special value for explicitly removing a binding
       warn(
         `Invalid value for dynamic directive argument (expected string or null): ${key}`,
@@ -30,6 +37,6 @@ export function bindDynamicKeys (baseObj: Object, values: Array<any>): Object {
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-export function prependModifier (value: any, symbol: string): any {
+export function prependModifier(value: any, symbol: string): any {
   return typeof value === 'string' ? symbol + value : value
 }
diff --git a/src/core/instance/render-helpers/bind-object-listeners.js b/src/core/instance/render-helpers/bind-object-listeners.ts
similarity index 52%
rename from src/core/instance/render-helpers/bind-object-listeners.js
rename to src/core/instance/render-helpers/bind-object-listeners.ts
index 5bfc7514323..5b839ae3bfe 100644
--- a/src/core/instance/render-helpers/bind-object-listeners.js
+++ b/src/core/instance/render-helpers/bind-object-listeners.ts
@@ -1,16 +1,15 @@
 /* @flow */
 
 import { warn, extend, isPlainObject } from 'core/util/index'
+import { VNodeData } from 'typescript/vnode'
 
-export function bindObjectListeners (data: any, value: any): VNodeData {
+export function bindObjectListeners(data: any, value: any): VNodeData {
   if (value) {
     if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-on without argument expects an Object value',
-        this
-      )
+      process.env.NODE_ENV !== 'production' &&
+        warn('v-on without argument expects an Object value', this)
     } else {
-      const on = data.on = data.on ? extend({}, data.on) : {}
+      const on = (data.on = data.on ? extend({}, data.on) : {})
       for (const key in value) {
         const existing = on[key]
         const ours = value[key]
diff --git a/src/core/instance/render-helpers/bind-object-props.js b/src/core/instance/render-helpers/bind-object-props.ts
similarity index 68%
rename from src/core/instance/render-helpers/bind-object-props.js
rename to src/core/instance/render-helpers/bind-object-props.ts
index f1b34ae2f1e..74cec42640b 100644
--- a/src/core/instance/render-helpers/bind-object-props.js
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -8,13 +8,14 @@ import {
   toObject,
   isReservedAttribute,
   camelize,
-  hyphenate
+  hyphenate,
 } from 'core/util/index'
+import { VNodeData } from 'typescript/vnode'
 
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-export function bindObjectProps (
+export function bindObjectProps(
   data: any,
   tag: string,
   value: any,
@@ -23,27 +24,22 @@ export function bindObjectProps (
 ): VNodeData {
   if (value) {
     if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      )
+      process.env.NODE_ENV !== 'production' &&
+        warn('v-bind without argument expects an Object or Array value', this)
     } else {
       if (Array.isArray(value)) {
         value = toObject(value)
       }
       let hash
       for (const key in value) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
+        if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
           hash = data
         } else {
           const type = data.attrs && data.attrs.type
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {})
+          hash =
+            asProp || config.mustUseProp(tag, type, key)
+              ? data.domProps || (data.domProps = {})
+              : data.attrs || (data.attrs = {})
         }
         const camelizedKey = camelize(key)
         const hyphenatedKey = hyphenate(key)
diff --git a/src/core/instance/render-helpers/check-keycodes.js b/src/core/instance/render-helpers/check-keycodes.ts
similarity index 86%
rename from src/core/instance/render-helpers/check-keycodes.js
rename to src/core/instance/render-helpers/check-keycodes.ts
index c12402b1943..70f77f798fd 100644
--- a/src/core/instance/render-helpers/check-keycodes.js
+++ b/src/core/instance/render-helpers/check-keycodes.ts
@@ -3,7 +3,7 @@
 import config from 'core/config'
 import { hyphenate } from 'shared/util'
 
-function isKeyNotMatch<T> (expect: T | Array<T>, actual: T): boolean {
+function isKeyNotMatch<T>(expect: T | Array<T>, actual: T): boolean {
   if (Array.isArray(expect)) {
     return expect.indexOf(actual) === -1
   } else {
@@ -16,13 +16,13 @@ function isKeyNotMatch<T> (expect: T | Array<T>, actual: T): boolean {
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-export function checkKeyCodes (
+export function checkKeyCodes(
   eventKeyCode: number,
   key: string,
   builtInKeyCode?: number | Array<number>,
   eventKeyName?: string,
   builtInKeyName?: string | Array<string>
-): ?boolean {
+): boolean | null | undefined {
   const mappedKeyCode = config.keyCodes[key] || builtInKeyCode
   if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
     return isKeyNotMatch(builtInKeyName, eventKeyName)
diff --git a/src/core/instance/render-helpers/index.js b/src/core/instance/render-helpers/index.ts
similarity index 95%
rename from src/core/instance/render-helpers/index.js
rename to src/core/instance/render-helpers/index.ts
index 04e7f9cfe1e..64d131c1004 100644
--- a/src/core/instance/render-helpers/index.js
+++ b/src/core/instance/render-helpers/index.ts
@@ -12,7 +12,7 @@ import { bindObjectListeners } from './bind-object-listeners'
 import { resolveScopedSlots } from './resolve-scoped-slots'
 import { bindDynamicKeys, prependModifier } from './bind-dynamic-keys'
 
-export function installRenderHelpers (target: any) {
+export function installRenderHelpers(target: any) {
   target._o = markOnce
   target._n = toNumber
   target._s = toString
diff --git a/src/core/instance/render-helpers/render-list.js b/src/core/instance/render-helpers/render-list.ts
similarity index 78%
rename from src/core/instance/render-helpers/render-list.js
rename to src/core/instance/render-helpers/render-list.ts
index cf68742403a..8f7f6ed9e28 100644
--- a/src/core/instance/render-helpers/render-list.js
+++ b/src/core/instance/render-helpers/render-list.ts
@@ -1,19 +1,18 @@
-/* @flow */
-
 import { isObject, isDef, hasSymbol } from 'core/util/index'
+import VNode from 'core/vdom/vnode'
 
 /**
  * Runtime helper for rendering v-for lists.
  */
-export function renderList (
+export function renderList(
   val: any,
-  render: (
-    val: any,
-    keyOrIndex: string | number,
-    index?: number
-  ) => VNode
-): ?Array<VNode> {
-  let ret: ?Array<VNode>, i, l, keys, key
+  render: (val: any, keyOrIndex: string | number, index?: number) => VNode
+): Array<VNode> | null {
+  let ret: Array<VNode> | null = null,
+    i,
+    l,
+    keys,
+    key
   if (Array.isArray(val) || typeof val === 'string') {
     ret = new Array(val.length)
     for (i = 0, l = val.length; i < l; i++) {
@@ -45,6 +44,6 @@ export function renderList (
   if (!isDef(ret)) {
     ret = []
   }
-  (ret: any)._isVList = true
+  ;(ret as any)._isVList = true
   return ret
 }
diff --git a/src/core/instance/render-helpers/render-slot.js b/src/core/instance/render-helpers/render-slot.ts
similarity index 67%
rename from src/core/instance/render-helpers/render-slot.js
rename to src/core/instance/render-helpers/render-slot.ts
index 52221f4bbc8..94749b1d09f 100644
--- a/src/core/instance/render-helpers/render-slot.js
+++ b/src/core/instance/render-helpers/render-slot.ts
@@ -1,26 +1,23 @@
-/* @flow */
-
 import { extend, warn, isObject } from 'core/util/index'
+import VNode from 'core/vdom/vnode'
 
 /**
  * Runtime helper for rendering <slot>
  */
-export function renderSlot (
+export function renderSlot(
   name: string,
-  fallback: ?Array<VNode>,
-  props: ?Object,
-  bindObject: ?Object
-): ?Array<VNode> {
+  fallback: Array<VNode> | null,
+  props: Record<string, any> | null,
+  bindObject: object | null
+): Array<VNode> | null {
   const scopedSlotFn = this.$scopedSlots[name]
   let nodes
-  if (scopedSlotFn) { // scoped slot
+  if (scopedSlotFn) {
+    // scoped slot
     props = props || {}
     if (bindObject) {
       if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        )
+        warn('slot v-bind without argument expects an Object', this)
       }
       props = extend(extend({}, bindObject), props)
     }
diff --git a/src/core/instance/render-helpers/render-static.js b/src/core/instance/render-helpers/render-static.ts
similarity index 84%
rename from src/core/instance/render-helpers/render-static.js
rename to src/core/instance/render-helpers/render-static.ts
index f56510b3ef3..c6aa669dd59 100644
--- a/src/core/instance/render-helpers/render-static.js
+++ b/src/core/instance/render-helpers/render-static.ts
@@ -1,9 +1,9 @@
-/* @flow */
+import VNode from 'core/vdom/vnode'
 
 /**
  * Runtime helper for rendering static trees.
  */
-export function renderStatic (
+export function renderStatic(
   index: number,
   isInFor: boolean
 ): VNode | Array<VNode> {
@@ -28,7 +28,7 @@ export function renderStatic (
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-export function markOnce (
+export function markOnce(
   tree: VNode | Array<VNode>,
   index: number,
   key: string
@@ -37,11 +37,7 @@ export function markOnce (
   return tree
 }
 
-function markStatic (
-  tree: VNode | Array<VNode>,
-  key: string,
-  isOnce: boolean
-) {
+function markStatic(tree: VNode | Array<VNode>, key: string, isOnce: boolean) {
   if (Array.isArray(tree)) {
     for (let i = 0; i < tree.length; i++) {
       if (tree[i] && typeof tree[i] !== 'string') {
@@ -53,7 +49,7 @@ function markStatic (
   }
 }
 
-function markStaticNode (node, key, isOnce) {
+function markStaticNode(node, key, isOnce) {
   node.isStatic = true
   node.key = key
   node.isOnce = isOnce
diff --git a/src/core/instance/render-helpers/resolve-filter.js b/src/core/instance/render-helpers/resolve-filter.ts
similarity index 72%
rename from src/core/instance/render-helpers/resolve-filter.js
rename to src/core/instance/render-helpers/resolve-filter.ts
index 08a81e1495d..c9de5ce9c60 100644
--- a/src/core/instance/render-helpers/resolve-filter.js
+++ b/src/core/instance/render-helpers/resolve-filter.ts
@@ -1,10 +1,8 @@
-/* @flow */
-
 import { identity, resolveAsset } from 'core/util/index'
 
 /**
  * Runtime helper for resolving filters
  */
-export function resolveFilter (id: string): Function {
+export function resolveFilter(id: string): Function {
   return resolveAsset(this.$options, 'filters', id, true) || identity
 }
diff --git a/src/core/instance/render-helpers/resolve-scoped-slots.js b/src/core/instance/render-helpers/resolve-scoped-slots.ts
similarity index 62%
rename from src/core/instance/render-helpers/resolve-scoped-slots.js
rename to src/core/instance/render-helpers/resolve-scoped-slots.ts
index f11ca0008cd..5caac1bcee6 100644
--- a/src/core/instance/render-helpers/resolve-scoped-slots.js
+++ b/src/core/instance/render-helpers/resolve-scoped-slots.ts
@@ -1,12 +1,12 @@
-/* @flow */
+import { ScopedSlotsData } from 'typescript/vnode'
 
-export function resolveScopedSlots (
-  fns: ScopedSlotsData, // see flow/vnode
-  res?: Object,
+export function resolveScopedSlots(
+  fns: ScopedSlotsData,
+  res?: Record<string, any>,
   // the following are added in 2.6
   hasDynamicKeys?: boolean,
   contentHashKey?: number
-): { [key: string]: Function, $stable: boolean } {
+): { $stable: boolean } & { [key: string]: Function } {
   res = res || { $stable: !hasDynamicKeys }
   for (let i = 0; i < fns.length; i++) {
     const slot = fns[i]
@@ -14,14 +14,16 @@ export function resolveScopedSlots (
       resolveScopedSlots(slot, res, hasDynamicKeys)
     } else if (slot) {
       // marker for reverse proxying v-slot without scope on this.$slots
+      // @ts-expect-error
       if (slot.proxy) {
+        // @ts-expect-error
         slot.fn.proxy = true
       }
       res[slot.key] = slot.fn
     }
   }
   if (contentHashKey) {
-    (res: any).$key = contentHashKey
+    ;(res as any).$key = contentHashKey
   }
-  return res
+  return res as any
 }
diff --git a/src/core/instance/render-helpers/resolve-slots.js b/src/core/instance/render-helpers/resolve-slots.ts
similarity index 69%
rename from src/core/instance/render-helpers/resolve-slots.js
rename to src/core/instance/render-helpers/resolve-slots.ts
index b4f2ef0224f..e8b9e527104 100644
--- a/src/core/instance/render-helpers/resolve-slots.js
+++ b/src/core/instance/render-helpers/resolve-slots.ts
@@ -1,18 +1,19 @@
 /* @flow */
 
 import type VNode from 'core/vdom/vnode'
+import { Component } from 'typescript/component'
 
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-export function resolveSlots (
-  children: ?Array<VNode>,
-  context: ?Component
+export function resolveSlots(
+  children: Array<VNode> | null | undefined,
+  context: Component | null
 ): { [key: string]: Array<VNode> } {
   if (!children || !children.length) {
     return {}
   }
-  const slots = {}
+  const slots: Record<string, any> = {}
   for (let i = 0, l = children.length; i < l; i++) {
     const child = children[i]
     const data = child.data
@@ -22,18 +23,20 @@ export function resolveSlots (
     }
     // named slots should only be respected if the vnode was rendered in the
     // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
+    if (
+      (child.context === context || child.fnContext === context) &&
+      data &&
+      data.slot != null
     ) {
       const name = data.slot
-      const slot = (slots[name] || (slots[name] = []))
+      const slot = slots[name] || (slots[name] = [])
       if (child.tag === 'template') {
         slot.push.apply(slot, child.children || [])
       } else {
         slot.push(child)
       }
     } else {
-      (slots.default || (slots.default = [])).push(child)
+      ;(slots.default || (slots.default = [])).push(child)
     }
   }
   // ignore slots that contains only whitespace
@@ -45,6 +48,6 @@ export function resolveSlots (
   return slots
 }
 
-function isWhitespace (node: VNode): boolean {
+function isWhitespace(node: VNode): boolean {
   return (node.isComment && !node.asyncFactory) || node.text === ' '
 }
diff --git a/src/core/instance/render.js b/src/core/instance/render.ts
similarity index 76%
rename from src/core/instance/render.js
rename to src/core/instance/render.ts
index 15b3ad69f3a..5166a9d9595 100644
--- a/src/core/instance/render.js
+++ b/src/core/instance/render.ts
@@ -5,7 +5,7 @@ import {
   nextTick,
   emptyObject,
   handleError,
-  defineReactive
+  defineReactive,
 } from '../util/index'
 
 import { createElement } from '../vdom/create-element'
@@ -16,11 +16,11 @@ import VNode, { createEmptyVNode } from '../vdom/vnode'
 
 import { isUpdatingChildComponent } from './lifecycle'
 
-export function initRender (vm: Component) {
+export function initRender(vm: Component) {
   vm._vnode = null // the root of the child tree
   vm._staticTrees = null // v-once cached trees
   const options = vm.$options
-  const parentVnode = vm.$vnode = options._parentVnode // the placeholder node in parent tree
+  const parentVnode = (vm.$vnode = options._parentVnode) // the placeholder node in parent tree
   const renderContext = parentVnode && parentVnode.context
   vm.$slots = resolveSlots(options._renderChildren, renderContext)
   vm.$scopedSlots = emptyObject
@@ -39,26 +39,50 @@ export function initRender (vm: Component) {
 
   /* istanbul ignore else */
   if (process.env.NODE_ENV !== 'production') {
-    defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, () => {
-      !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm)
-    }, true)
-    defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-      !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm)
-    }, true)
+    defineReactive(
+      vm,
+      '$attrs',
+      (parentData && parentData.attrs) || emptyObject,
+      () => {
+        !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm)
+      },
+      true
+    )
+    defineReactive(
+      vm,
+      '$listeners',
+      options._parentListeners || emptyObject,
+      () => {
+        !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm)
+      },
+      true
+    )
   } else {
-    defineReactive(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true)
-    defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true)
+    defineReactive(
+      vm,
+      '$attrs',
+      (parentData && parentData.attrs) || emptyObject,
+      null,
+      true
+    )
+    defineReactive(
+      vm,
+      '$listeners',
+      options._parentListeners || emptyObject,
+      null,
+      true
+    )
   }
 }
 
 export let currentRenderingInstance: Component | null = null
 
 // for testing only
-export function setCurrentRenderingInstance (vm: Component) {
+export function setCurrentRenderingInstance(vm: Component) {
   currentRenderingInstance = vm
 }
 
-export function renderMixin (Vue: Class<Component>) {
+export function renderMixin(Vue: Class<Component>) {
   // install runtime convenience helpers
   installRenderHelpers(Vue.prototype)
 
@@ -96,7 +120,11 @@ export function renderMixin (Vue: Class<Component>) {
       /* istanbul ignore else */
       if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
         try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
+          vnode = vm.$options.renderError.call(
+            vm._renderProxy,
+            vm.$createElement,
+            e
+          )
         } catch (e) {
           handleError(e, vm, `renderError`)
           vnode = vm._vnode
@@ -116,7 +144,7 @@ export function renderMixin (Vue: Class<Component>) {
       if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
         warn(
           'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
+            'should return a single root node.',
           vm
         )
       }
diff --git a/src/core/instance/state.js b/src/core/instance/state.ts
similarity index 73%
rename from src/core/instance/state.js
rename to src/core/instance/state.ts
index 67f9dae381d..65398900a72 100644
--- a/src/core/instance/state.js
+++ b/src/core/instance/state.ts
@@ -10,7 +10,7 @@ import {
   del,
   observe,
   defineReactive,
-  toggleObserving
+  toggleObserving,
 } from '../observer/index'
 
 import {
@@ -25,27 +25,27 @@ import {
   validateProp,
   isPlainObject,
   isServerRendering,
-  isReservedAttribute
+  isReservedAttribute,
 } from '../util/index'
 
 const sharedPropertyDefinition = {
   enumerable: true,
   configurable: true,
   get: noop,
-  set: noop
+  set: noop,
 }
 
-export function proxy (target: Object, sourceKey: string, key: string) {
-  sharedPropertyDefinition.get = function proxyGetter () {
+export function proxy(target: Object, sourceKey: string, key: string) {
+  sharedPropertyDefinition.get = function proxyGetter() {
     return this[sourceKey][key]
   }
-  sharedPropertyDefinition.set = function proxySetter (val) {
+  sharedPropertyDefinition.set = function proxySetter(val) {
     this[sourceKey][key] = val
   }
   Object.defineProperty(target, key, sharedPropertyDefinition)
 }
 
-export function initState (vm: Component) {
+export function initState(vm: Component) {
   vm._watchers = []
   const opts = vm.$options
   if (opts.props) initProps(vm, opts.props)
@@ -53,7 +53,7 @@ export function initState (vm: Component) {
   if (opts.data) {
     initData(vm)
   } else {
-    observe(vm._data = {}, true /* asRootData */)
+    observe((vm._data = {}), true /* asRootData */)
   }
   if (opts.computed) initComputed(vm, opts.computed)
   if (opts.watch && opts.watch !== nativeWatch) {
@@ -61,12 +61,12 @@ export function initState (vm: Component) {
   }
 }
 
-function initProps (vm: Component, propsOptions: Object) {
+function initProps(vm: Component, propsOptions: Object) {
   const propsData = vm.$options.propsData || {}
-  const props = vm._props = {}
+  const props = (vm._props = {})
   // cache prop keys so that future props updates can iterate using Array
   // instead of dynamic object key enumeration.
-  const keys = vm.$options._propKeys = []
+  const keys = (vm.$options._propKeys = [])
   const isRoot = !vm.$parent
   // root instance props should be converted
   if (!isRoot) {
@@ -78,8 +78,10 @@ function initProps (vm: Component, propsOptions: Object) {
     /* istanbul ignore else */
     if (process.env.NODE_ENV !== 'production') {
       const hyphenatedKey = hyphenate(key)
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
+      if (
+        isReservedAttribute(hyphenatedKey) ||
+        config.isReservedAttr(hyphenatedKey)
+      ) {
         warn(
           `"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`,
           vm
@@ -89,9 +91,9 @@ function initProps (vm: Component, propsOptions: Object) {
         if (!isRoot && !isUpdatingChildComponent) {
           warn(
             `Avoid mutating a prop directly since the value will be ` +
-            `overwritten whenever the parent component re-renders. ` +
-            `Instead, use a data or computed property based on the prop's ` +
-            `value. Prop being mutated: "${key}"`,
+              `overwritten whenever the parent component re-renders. ` +
+              `Instead, use a data or computed property based on the prop's ` +
+              `value. Prop being mutated: "${key}"`,
             vm
           )
         }
@@ -109,18 +111,17 @@ function initProps (vm: Component, propsOptions: Object) {
   toggleObserving(true)
 }
 
-function initData (vm: Component) {
+function initData(vm: Component) {
   let data = vm.$options.data
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {}
+  data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {}
   if (!isPlainObject(data)) {
     data = {}
-    process.env.NODE_ENV !== 'production' && warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    )
+    process.env.NODE_ENV !== 'production' &&
+      warn(
+        'data functions should return an object:\n' +
+          'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
+        vm
+      )
   }
   // proxy data on instance
   const keys = Object.keys(data)
@@ -131,18 +132,16 @@ function initData (vm: Component) {
     const key = keys[i]
     if (process.env.NODE_ENV !== 'production') {
       if (methods && hasOwn(methods, key)) {
-        warn(
-          `Method "${key}" has already been defined as a data property.`,
-          vm
-        )
+        warn(`Method "${key}" has already been defined as a data property.`, vm)
       }
     }
     if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        `The data property "${key}" is already declared as a prop. ` +
-        `Use prop default value instead.`,
-        vm
-      )
+      process.env.NODE_ENV !== 'production' &&
+        warn(
+          `The data property "${key}" is already declared as a prop. ` +
+            `Use prop default value instead.`,
+          vm
+        )
     } else if (!isReserved(key)) {
       proxy(vm, `_data`, key)
     }
@@ -151,7 +150,7 @@ function initData (vm: Component) {
   observe(data, true /* asRootData */)
 }
 
-export function getData (data: Function, vm: Component): any {
+export function getData(data: Function, vm: Component): any {
   // #7573 disable dep collection when invoking data getters
   pushTarget()
   try {
@@ -166,9 +165,9 @@ export function getData (data: Function, vm: Component): any {
 
 const computedWatcherOptions = { lazy: true }
 
-function initComputed (vm: Component, computed: Object) {
+function initComputed(vm: Component, computed: Object) {
   // $flow-disable-line
-  const watchers = vm._computedWatchers = Object.create(null)
+  const watchers = (vm._computedWatchers = Object.create(null))
   // computed properties are just getters during SSR
   const isSSR = isServerRendering()
 
@@ -176,10 +175,7 @@ function initComputed (vm: Component, computed: Object) {
     const userDef = computed[key]
     const getter = typeof userDef === 'function' ? userDef : userDef.get
     if (process.env.NODE_ENV !== 'production' && getter == null) {
-      warn(
-        `Getter is missing for computed property "${key}".`,
-        vm
-      )
+      warn(`Getter is missing for computed property "${key}".`, vm)
     }
 
     if (!isSSR) {
@@ -207,7 +203,7 @@ function initComputed (vm: Component, computed: Object) {
   }
 }
 
-export function defineComputed (
+export function defineComputed(
   target: any,
   key: string,
   userDef: Object | Function
@@ -226,8 +222,10 @@ export function defineComputed (
       : noop
     sharedPropertyDefinition.set = userDef.set || noop
   }
-  if (process.env.NODE_ENV !== 'production' &&
-      sharedPropertyDefinition.set === noop) {
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    sharedPropertyDefinition.set === noop
+  ) {
     sharedPropertyDefinition.set = function () {
       warn(
         `Computed property "${key}" was assigned to but it has no setter.`,
@@ -238,8 +236,8 @@ export function defineComputed (
   Object.defineProperty(target, key, sharedPropertyDefinition)
 }
 
-function createComputedGetter (key) {
-  return function computedGetter () {
+function createComputedGetter(key) {
+  return function computedGetter() {
     const watcher = this._computedWatchers && this._computedWatchers[key]
     if (watcher) {
       if (watcher.dirty) {
@@ -254,32 +252,31 @@ function createComputedGetter (key) {
 }
 
 function createGetterInvoker(fn) {
-  return function computedGetter () {
+  return function computedGetter() {
     return fn.call(this, this)
   }
 }
 
-function initMethods (vm: Component, methods: Object) {
+function initMethods(vm: Component, methods: Object) {
   const props = vm.$options.props
   for (const key in methods) {
     if (process.env.NODE_ENV !== 'production') {
       if (typeof methods[key] !== 'function') {
         warn(
-          `Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-          `Did you reference the function correctly?`,
+          `Method "${key}" has type "${typeof methods[
+            key
+          ]}" in the component definition. ` +
+            `Did you reference the function correctly?`,
           vm
         )
       }
       if (props && hasOwn(props, key)) {
-        warn(
-          `Method "${key}" has already been defined as a prop.`,
-          vm
-        )
+        warn(`Method "${key}" has already been defined as a prop.`, vm)
       }
-      if ((key in vm) && isReserved(key)) {
+      if (key in vm && isReserved(key)) {
         warn(
           `Method "${key}" conflicts with an existing Vue instance method. ` +
-          `Avoid defining component methods that start with _ or $.`
+            `Avoid defining component methods that start with _ or $.`
         )
       }
     }
@@ -287,7 +284,7 @@ function initMethods (vm: Component, methods: Object) {
   }
 }
 
-function initWatch (vm: Component, watch: Object) {
+function initWatch(vm: Component, watch: Object) {
   for (const key in watch) {
     const handler = watch[key]
     if (Array.isArray(handler)) {
@@ -300,7 +297,7 @@ function initWatch (vm: Component, watch: Object) {
   }
 }
 
-function createWatcher (
+function createWatcher(
   vm: Component,
   expOrFn: string | Function,
   handler: any,
@@ -316,19 +313,23 @@ function createWatcher (
   return vm.$watch(expOrFn, handler, options)
 }
 
-export function stateMixin (Vue: Class<Component>) {
+export function stateMixin(Vue: Class<Component>) {
   // flow somehow has problems with directly declared definition object
   // when using Object.defineProperty, so we have to procedurally build up
   // the object here.
   const dataDef = {}
-  dataDef.get = function () { return this._data }
+  dataDef.get = function () {
+    return this._data
+  }
   const propsDef = {}
-  propsDef.get = function () { return this._props }
+  propsDef.get = function () {
+    return this._props
+  }
   if (process.env.NODE_ENV !== 'production') {
     dataDef.set = function () {
       warn(
         'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
+          'Use nested data properties instead.',
         this
       )
     }
@@ -359,11 +360,15 @@ export function stateMixin (Vue: Class<Component>) {
       try {
         cb.call(vm, watcher.value)
       } catch (error) {
-        handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`)
+        handleError(
+          error,
+          vm,
+          `callback for immediate watcher "${watcher.expression}"`
+        )
       }
       popTarget()
     }
-    return function unwatchFn () {
+    return function unwatchFn() {
       watcher.teardown()
     }
   }
diff --git a/src/core/observer/array.js b/src/core/observer/array.ts
similarity index 92%
rename from src/core/observer/array.js
rename to src/core/observer/array.ts
index 684e37ece58..1a59b511e24 100644
--- a/src/core/observer/array.js
+++ b/src/core/observer/array.ts
@@ -15,7 +15,7 @@ const methodsToPatch = [
   'unshift',
   'splice',
   'sort',
-  'reverse'
+  'reverse',
 ]
 
 /**
@@ -24,7 +24,7 @@ const methodsToPatch = [
 methodsToPatch.forEach(function (method) {
   // cache original method
   const original = arrayProto[method]
-  def(arrayMethods, method, function mutator (...args) {
+  def(arrayMethods, method, function mutator(...args) {
     const result = original.apply(this, args)
     const ob = this.__ob__
     let inserted
diff --git a/src/core/observer/dep.js b/src/core/observer/dep.ts
similarity index 78%
rename from src/core/observer/dep.js
rename to src/core/observer/dep.ts
index 974b9541c28..b03c053a254 100644
--- a/src/core/observer/dep.js
+++ b/src/core/observer/dep.ts
@@ -1,5 +1,3 @@
-/* @flow */
-
 import type Watcher from './watcher'
 import { remove } from '../util/index'
 import config from '../config'
@@ -11,30 +9,30 @@ let uid = 0
  * directives subscribing to it.
  */
 export default class Dep {
-  static target: ?Watcher;
-  id: number;
-  subs: Array<Watcher>;
+  static target?: Watcher | null
+  id: number
+  subs: Array<Watcher>
 
-  constructor () {
+  constructor() {
     this.id = uid++
     this.subs = []
   }
 
-  addSub (sub: Watcher) {
+  addSub(sub: Watcher) {
     this.subs.push(sub)
   }
 
-  removeSub (sub: Watcher) {
+  removeSub(sub: Watcher) {
     remove(this.subs, sub)
   }
 
-  depend () {
+  depend() {
     if (Dep.target) {
       Dep.target.addDep(this)
     }
   }
 
-  notify () {
+  notify() {
     // stabilize the subscriber list first
     const subs = this.subs.slice()
     if (process.env.NODE_ENV !== 'production' && !config.async) {
@@ -53,14 +51,14 @@ export default class Dep {
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null
-const targetStack = []
+const targetStack: Array<Watcher | null | undefined> = []
 
-export function pushTarget (target: ?Watcher) {
+export function pushTarget(target?: Watcher | null) {
   targetStack.push(target)
   Dep.target = target
 }
 
-export function popTarget () {
+export function popTarget() {
   targetStack.pop()
   Dep.target = targetStack[targetStack.length - 1]
 }
diff --git a/src/core/observer/index.js b/src/core/observer/index.ts
similarity index 77%
rename from src/core/observer/index.js
rename to src/core/observer/index.ts
index 545adb64025..d97e6644c9e 100644
--- a/src/core/observer/index.js
+++ b/src/core/observer/index.ts
@@ -1,5 +1,3 @@
-/* @flow */
-
 import Dep from './dep'
 import VNode from '../vdom/vnode'
 import { arrayMethods } from './array'
@@ -13,7 +11,7 @@ import {
   isPrimitive,
   isUndef,
   isValidArrayIndex,
-  isServerRendering
+  isServerRendering,
 } from '../util/index'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
@@ -24,7 +22,7 @@ const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
  */
 export let shouldObserve: boolean = true
 
-export function toggleObserving (value: boolean) {
+export function toggleObserving(value: boolean) {
   shouldObserve = value
 }
 
@@ -35,11 +33,11 @@ export function toggleObserving (value: boolean) {
  * collect dependencies and dispatch updates.
  */
 export class Observer {
-  value: any;
-  dep: Dep;
-  vmCount: number; // number of vms that have this object as root $data
+  value: any
+  dep: Dep
+  vmCount: number // number of vms that have this object as root $data
 
-  constructor (value: any) {
+  constructor(value: any) {
     this.value = value
     this.dep = new Dep()
     this.vmCount = 0
@@ -61,7 +59,7 @@ export class Observer {
    * getter/setters. This method should only be called when
    * value type is Object.
    */
-  walk (obj: Object) {
+  walk(obj: object) {
     const keys = Object.keys(obj)
     for (let i = 0; i < keys.length; i++) {
       defineReactive(obj, keys[i])
@@ -71,7 +69,7 @@ export class Observer {
   /**
    * Observe a list of Array items.
    */
-  observeArray (items: Array<any>) {
+  observeArray(items: Array<any>) {
     for (let i = 0, l = items.length; i < l; i++) {
       observe(items[i])
     }
@@ -84,7 +82,7 @@ export class Observer {
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src: Object) {
+function protoAugment(target, src: Object) {
   /* eslint-disable no-proto */
   target.__proto__ = src
   /* eslint-enable no-proto */
@@ -95,7 +93,7 @@ function protoAugment (target, src: Object) {
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target: Object, src: Object, keys: Array<string>) {
+function copyAugment(target: Object, src: Object, keys: Array<string>) {
   for (let i = 0, l = keys.length; i < l; i++) {
     const key = keys[i]
     def(target, key, src[key])
@@ -107,7 +105,7 @@ function copyAugment (target: Object, src: Object, keys: Array<string>) {
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-export function observe (value: any, asRootData: ?boolean): Observer | void {
+export function observe(value: any, asRootData?: boolean): Observer | void {
   if (!isObject(value) || value instanceof VNode) {
     return
   }
@@ -132,11 +130,11 @@ export function observe (value: any, asRootData: ?boolean): Observer | void {
 /**
  * Define a reactive property on an Object.
  */
-export function defineReactive (
-  obj: Object,
+export function defineReactive(
+  obj: object,
   key: string,
-  val: any,
-  customSetter?: ?Function,
+  val?: any,
+  customSetter?: Function,
   shallow?: boolean
 ) {
   const dep = new Dep()
@@ -157,7 +155,7 @@ export function defineReactive (
   Object.defineProperty(obj, key, {
     enumerable: true,
     configurable: true,
-    get: function reactiveGetter () {
+    get: function reactiveGetter() {
       const value = getter ? getter.call(obj) : val
       if (Dep.target) {
         dep.depend()
@@ -170,7 +168,7 @@ export function defineReactive (
       }
       return value
     },
-    set: function reactiveSetter (newVal) {
+    set: function reactiveSetter(newVal) {
       const value = getter ? getter.call(obj) : val
       /* eslint-disable no-self-compare */
       if (newVal === value || (newVal !== newVal && value !== value)) {
@@ -189,7 +187,7 @@ export function defineReactive (
       }
       childOb = !shallow && observe(newVal)
       dep.notify()
-    }
+    },
   })
 }
 
@@ -198,11 +196,14 @@ export function defineReactive (
  * triggers change notification if the property doesn't
  * already exist.
  */
-export function set (target: Array<any> | Object, key: any, val: any): any {
-  if (process.env.NODE_ENV !== 'production' &&
+export function set(target: Array<any> | Object, key: any, val: any): any {
+  if (
+    process.env.NODE_ENV !== 'production' &&
     (isUndef(target) || isPrimitive(target))
   ) {
-    warn(`Cannot set reactive property on undefined, null, or primitive value: ${(target: any)}`)
+    warn(
+      `Cannot set reactive property on undefined, null, or primitive value: ${target}`
+    )
   }
   if (Array.isArray(target) && isValidArrayIndex(key)) {
     target.length = Math.max(target.length, key)
@@ -213,12 +214,14 @@ export function set (target: Array<any> | Object, key: any, val: any): any {
     target[key] = val
     return val
   }
-  const ob = (target: any).__ob__
+  const ob = (target as any).__ob__
+  // @ts-ignore
   if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    )
+    process.env.NODE_ENV !== 'production' &&
+      warn(
+        'Avoid adding reactive properties to a Vue instance or its root $data ' +
+          'at runtime - declare it upfront in the data option.'
+      )
     return val
   }
   if (!ob) {
@@ -233,22 +236,27 @@ export function set (target: Array<any> | Object, key: any, val: any): any {
 /**
  * Delete a property and trigger change if necessary.
  */
-export function del (target: Array<any> | Object, key: any) {
-  if (process.env.NODE_ENV !== 'production' &&
+export function del(target: Array<any> | Object, key: any) {
+  if (
+    process.env.NODE_ENV !== 'production' &&
     (isUndef(target) || isPrimitive(target))
   ) {
-    warn(`Cannot delete reactive property on undefined, null, or primitive value: ${(target: any)}`)
+    warn(
+      `Cannot delete reactive property on undefined, null, or primitive value: ${target}`
+    )
   }
   if (Array.isArray(target) && isValidArrayIndex(key)) {
     target.splice(key, 1)
     return
   }
-  const ob = (target: any).__ob__
+  const ob = (target as any).__ob__
+  //@ts-ignore
   if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    )
+    process.env.NODE_ENV !== 'production' &&
+      warn(
+        'Avoid deleting properties on a Vue instance or its root $data ' +
+          '- just set it to null.'
+      )
     return
   }
   if (!hasOwn(target, key)) {
@@ -265,7 +273,7 @@ export function del (target: Array<any> | Object, key: any) {
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value: Array<any>) {
+function dependArray(value: Array<any>) {
   for (let e, i = 0, l = value.length; i < l; i++) {
     e = value[i]
     e && e.__ob__ && e.__ob__.dep.depend()
diff --git a/src/core/observer/scheduler.js b/src/core/observer/scheduler.ts
similarity index 90%
rename from src/core/observer/scheduler.js
rename to src/core/observer/scheduler.ts
index ed5c504a50c..ea2aec33eed 100644
--- a/src/core/observer/scheduler.js
+++ b/src/core/observer/scheduler.ts
@@ -4,19 +4,14 @@ import type Watcher from './watcher'
 import config from '../config'
 import { callHook, activateChildComponent } from '../instance/lifecycle'
 
-import {
-  warn,
-  nextTick,
-  devtools,
-  inBrowser,
-  isIE
-} from '../util/index'
+import { warn, nextTick, devtools, inBrowser, isIE } from '../util/index'
+import { Component } from 'typescript/component'
 
 export const MAX_UPDATE_COUNT = 100
 
 const queue: Array<Watcher> = []
 const activatedChildren: Array<Component> = []
-let has: { [key: number]: ?true } = {}
+let has: { [key: number]: true | undefined | null } = {}
 let circular: { [key: number]: number } = {}
 let waiting = false
 let flushing = false
@@ -25,7 +20,7 @@ let index = 0
 /**
  * Reset the scheduler's state.
  */
-function resetSchedulerState () {
+function resetSchedulerState() {
   index = queue.length = activatedChildren.length = 0
   has = {}
   if (process.env.NODE_ENV !== 'production') {
@@ -68,7 +63,7 @@ if (inBrowser && !isIE) {
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
+function flushSchedulerQueue() {
   currentFlushTimestamp = getNow()
   flushing = true
   let watcher, id
@@ -98,11 +93,10 @@ function flushSchedulerQueue () {
       circular[id] = (circular[id] || 0) + 1
       if (circular[id] > MAX_UPDATE_COUNT) {
         warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
+          'You may have an infinite update loop ' +
+            (watcher.user
               ? `in watcher with expression "${watcher.expression}"`
-              : `in a component render function.`
-          ),
+              : `in a component render function.`),
           watcher.vm
         )
         break
@@ -127,7 +121,7 @@ function flushSchedulerQueue () {
   }
 }
 
-function callUpdatedHooks (queue) {
+function callUpdatedHooks(queue) {
   let i = queue.length
   while (i--) {
     const watcher = queue[i]
@@ -142,14 +136,14 @@ function callUpdatedHooks (queue) {
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-export function queueActivatedComponent (vm: Component) {
+export function queueActivatedComponent(vm: Component) {
   // setting _inactive to false here so that a render function can
   // rely on checking whether it's in an inactive tree (e.g. router-view)
   vm._inactive = false
   activatedChildren.push(vm)
 }
 
-function callActivatedHooks (queue) {
+function callActivatedHooks(queue) {
   for (let i = 0; i < queue.length; i++) {
     queue[i]._inactive = true
     activateChildComponent(queue[i], true /* true */)
@@ -161,7 +155,7 @@ function callActivatedHooks (queue) {
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-export function queueWatcher (watcher: Watcher) {
+export function queueWatcher(watcher: Watcher) {
   const id = watcher.id
   if (has[id] == null) {
     has[id] = true
diff --git a/src/core/observer/traverse.js b/src/core/observer/traverse.ts
similarity index 80%
rename from src/core/observer/traverse.js
rename to src/core/observer/traverse.ts
index 6b26524affc..7523cacdabe 100644
--- a/src/core/observer/traverse.js
+++ b/src/core/observer/traverse.ts
@@ -11,15 +11,19 @@ const seenObjects = new Set()
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-export function traverse (val: any) {
+export function traverse(val: any) {
   _traverse(val, seenObjects)
   seenObjects.clear()
 }
 
-function _traverse (val: any, seen: SimpleSet) {
+function _traverse(val: any, seen: SimpleSet) {
   let i, keys
   const isA = Array.isArray(val)
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
+  if (
+    (!isA && !isObject(val)) ||
+    Object.isFrozen(val) ||
+    val instanceof VNode
+  ) {
     return
   }
   if (val.__ob__) {
diff --git a/src/core/observer/watcher.js b/src/core/observer/watcher.ts
similarity index 80%
rename from src/core/observer/watcher.js
rename to src/core/observer/watcher.ts
index 5fbcdf347f2..a336ff044cf 100644
--- a/src/core/observer/watcher.js
+++ b/src/core/observer/watcher.ts
@@ -7,7 +7,7 @@ import {
   parsePath,
   _Set as Set,
   handleError,
-  noop
+  noop,
 } from '../util/index'
 
 import { traverse } from './traverse'
@@ -15,6 +15,7 @@ import { queueWatcher } from './scheduler'
 import Dep, { pushTarget, popTarget } from './dep'
 
 import type { SimpleSet } from '../util/index'
+import { Component } from 'typescript/component'
 
 let uid = 0
 
@@ -24,29 +25,35 @@ let uid = 0
  * This is used for both the $watch() api and directives.
  */
 export default class Watcher {
-  vm: Component;
-  expression: string;
-  cb: Function;
-  id: number;
-  deep: boolean;
-  user: boolean;
-  lazy: boolean;
-  sync: boolean;
-  dirty: boolean;
-  active: boolean;
-  deps: Array<Dep>;
-  newDeps: Array<Dep>;
-  depIds: SimpleSet;
-  newDepIds: SimpleSet;
-  before: ?Function;
-  getter: Function;
-  value: any;
+  vm: Component
+  expression: string
+  cb: Function
+  id: number
+  deep: boolean
+  user: boolean
+  lazy: boolean
+  sync: boolean
+  dirty: boolean
+  active: boolean
+  deps: Array<Dep>
+  newDeps: Array<Dep>
+  depIds: SimpleSet
+  newDepIds: SimpleSet
+  before?: Function
+  getter: Function
+  value: any
 
-  constructor (
+  constructor(
     vm: Component,
     expOrFn: string | Function,
     cb: Function,
-    options?: ?Object,
+    options?: {
+      deep?: boolean
+      user?: boolean
+      lazy?: boolean
+      sync?: boolean
+      before?: Function
+    } | null,
     isRenderWatcher?: boolean
   ) {
     this.vm = vm
@@ -72,9 +79,8 @@ export default class Watcher {
     this.newDeps = []
     this.depIds = new Set()
     this.newDepIds = new Set()
-    this.expression = process.env.NODE_ENV !== 'production'
-      ? expOrFn.toString()
-      : ''
+    this.expression =
+      process.env.NODE_ENV !== 'production' ? expOrFn.toString() : ''
     // parse expression for getter
     if (typeof expOrFn === 'function') {
       this.getter = expOrFn
@@ -82,23 +88,22 @@ export default class Watcher {
       this.getter = parsePath(expOrFn)
       if (!this.getter) {
         this.getter = noop
-        process.env.NODE_ENV !== 'production' && warn(
-          `Failed watching path: "${expOrFn}" ` +
-          'Watcher only accepts simple dot-delimited paths. ' +
-          'For full control, use a function instead.',
-          vm
-        )
+        process.env.NODE_ENV !== 'production' &&
+          warn(
+            `Failed watching path: "${expOrFn}" ` +
+              'Watcher only accepts simple dot-delimited paths. ' +
+              'For full control, use a function instead.',
+            vm
+          )
       }
     }
-    this.value = this.lazy
-      ? undefined
-      : this.get()
+    this.value = this.lazy ? undefined : this.get()
   }
 
   /**
    * Evaluate the getter, and re-collect dependencies.
    */
-  get () {
+  get() {
     pushTarget(this)
     let value
     const vm = this.vm
@@ -125,7 +130,7 @@ export default class Watcher {
   /**
    * Add a dependency to this directive.
    */
-  addDep (dep: Dep) {
+  addDep(dep: Dep) {
     const id = dep.id
     if (!this.newDepIds.has(id)) {
       this.newDepIds.add(id)
@@ -139,7 +144,7 @@ export default class Watcher {
   /**
    * Clean up for dependency collection.
    */
-  cleanupDeps () {
+  cleanupDeps() {
     let i = this.deps.length
     while (i--) {
       const dep = this.deps[i]
@@ -147,7 +152,7 @@ export default class Watcher {
         dep.removeSub(this)
       }
     }
-    let tmp = this.depIds
+    let tmp: any = this.depIds
     this.depIds = this.newDepIds
     this.newDepIds = tmp
     this.newDepIds.clear()
@@ -161,7 +166,7 @@ export default class Watcher {
    * Subscriber interface.
    * Will be called when a dependency changes.
    */
-  update () {
+  update() {
     /* istanbul ignore else */
     if (this.lazy) {
       this.dirty = true
@@ -176,7 +181,7 @@ export default class Watcher {
    * Scheduler job interface.
    * Will be called by the scheduler.
    */
-  run () {
+  run() {
     if (this.active) {
       const value = this.get()
       if (
@@ -207,7 +212,7 @@ export default class Watcher {
    * Evaluate the value of the watcher.
    * This only gets called for lazy watchers.
    */
-  evaluate () {
+  evaluate() {
     this.value = this.get()
     this.dirty = false
   }
@@ -215,7 +220,7 @@ export default class Watcher {
   /**
    * Depend on all deps collected by this watcher.
    */
-  depend () {
+  depend() {
     let i = this.deps.length
     while (i--) {
       this.deps[i].depend()
@@ -225,7 +230,7 @@ export default class Watcher {
   /**
    * Remove self from all dependencies' subscriber list.
    */
-  teardown () {
+  teardown() {
     if (this.active) {
       // remove self from vm's watcher list
       // this is a somewhat expensive operation so we skip it
diff --git a/src/core/util/debug.js b/src/core/util/debug.ts
similarity index 55%
rename from src/core/util/debug.js
rename to src/core/util/debug.ts
index 4aef7b53d4c..43756d0ec27 100644
--- a/src/core/util/debug.js
+++ b/src/core/util/debug.ts
@@ -2,34 +2,32 @@
 
 import config from '../config'
 import { noop } from 'shared/util'
+import { Component } from 'typescript/component'
 
 export let warn = noop
 export let tip = noop
-export let generateComponentTrace = (noop: any) // work around flow check
-export let formatComponentName = (noop: any)
+export let generateComponentTrace: (vm: Component) => string // work around flow check
+export let formatComponentName: (vm: Component, includeFile?: false) => string
 
 if (process.env.NODE_ENV !== 'production') {
   const hasConsole = typeof console !== 'undefined'
   const classifyRE = /(?:^|[-_])(\w)/g
-  const classify = str => str
-    .replace(classifyRE, c => c.toUpperCase())
-    .replace(/[-_]/g, '')
+  const classify = (str) =>
+    str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '')
 
   warn = (msg, vm) => {
     const trace = vm ? generateComponentTrace(vm) : ''
 
     if (config.warnHandler) {
       config.warnHandler.call(null, msg, vm, trace)
-    } else if (hasConsole && (!config.silent)) {
+    } else if (hasConsole && !config.silent) {
       console.error(`[Vue warn]: ${msg}${trace}`)
     }
   }
 
   tip = (msg, vm) => {
-    if (hasConsole && (!config.silent)) {
-      console.warn(`[Vue tip]: ${msg}` + (
-        vm ? generateComponentTrace(vm) : ''
-      ))
+    if (hasConsole && !config.silent) {
+      console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''))
     }
   }
 
@@ -37,10 +35,14 @@ if (process.env.NODE_ENV !== 'production') {
     if (vm.$root === vm) {
       return '<Root>'
     }
-    const options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
+    const options =
+      // @ts-ignore
+      typeof vm === 'function' && vm.cid != null
+        ? // @ts-ignore
+          vm.options
+        : vm._isVue
+        ? // @ts-ignore
+          vm.$options || vm.constructor.options
         : vm
     let name = options.name || options._componentTag
     const file = options.__file
@@ -65,16 +67,17 @@ if (process.env.NODE_ENV !== 'production') {
     return res
   }
 
-  generateComponentTrace = vm => {
+  generateComponentTrace = (vm: Component | undefined) => {
+    // @ts-ignore
     if (vm._isVue && vm.$parent) {
-      const tree = []
+      const tree: any[] = []
       let currentRecursiveSequence = 0
       while (vm) {
         if (tree.length > 0) {
           const last = tree[tree.length - 1]
           if (last.constructor === vm.constructor) {
             currentRecursiveSequence++
-            vm = vm.$parent
+            vm = vm.$parent!
             continue
           } else if (currentRecursiveSequence > 0) {
             tree[tree.length - 1] = [last, currentRecursiveSequence]
@@ -82,19 +85,25 @@ if (process.env.NODE_ENV !== 'production') {
           }
         }
         tree.push(vm)
-        vm = vm.$parent
+        vm = vm.$parent!
       }
-      return '\n\nfound in\n\n' + tree
-        .map((vm, i) => `${
-          i === 0 ? '---> ' : repeat(' ', 5 + i * 2)
-        }${
-          Array.isArray(vm)
-            ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-            : formatComponentName(vm)
-        }`)
-        .join('\n')
+      return (
+        '\n\nfound in\n\n' +
+        tree
+          .map(
+            (vm, i) =>
+              `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${
+                Array.isArray(vm)
+                  ? `${formatComponentName(vm[0])}... (${
+                      vm[1]
+                    } recursive calls)`
+                  : formatComponentName(vm)
+              }`
+          )
+          .join('\n')
+      )
     } else {
-      return `\n\n(found in ${formatComponentName(vm)})`
+      return `\n\n(found in ${formatComponentName(vm!)})`
     }
   }
 }
diff --git a/src/core/util/env.js b/src/core/util/env.ts
similarity index 64%
rename from src/core/util/env.js
rename to src/core/util/env.ts
index 820bacdb405..28fac6b2fcd 100644
--- a/src/core/util/env.js
+++ b/src/core/util/env.ts
@@ -5,31 +5,39 @@ export const hasProto = '__proto__' in {}
 
 // Browser environment sniffing
 export const inBrowser = typeof window !== 'undefined'
-export const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
+// @ts-ignore
+export const inWeex =
+  // @ts-ignore
+  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
+// @ts-ignore
 export const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
 export const UA = inBrowser && window.navigator.userAgent.toLowerCase()
 export const isIE = UA && /msie|trident/.test(UA)
 export const isIE9 = UA && UA.indexOf('msie 9.0') > 0
 export const isEdge = UA && UA.indexOf('edge/') > 0
-export const isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android')
-export const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios')
+export const isAndroid =
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android'
+export const isIOS =
+  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios'
 export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
 export const isPhantomJS = UA && /phantomjs/.test(UA)
 export const isFF = UA && UA.match(/firefox\/(\d+)/)
 
 // Firefox has a "watch" function on Object.prototype...
-export const nativeWatch = ({}).watch
+// @ts-ignore
+export const nativeWatch = {}.watch
 
 export let supportsPassive = false
 if (inBrowser) {
   try {
     const opts = {}
-    Object.defineProperty(opts, 'passive', ({
-      get () {
+    Object.defineProperty(opts, 'passive', {
+      get() {
         /* istanbul ignore next */
         supportsPassive = true
-      }
-    }: Object)) // https://github.com/facebook/flow/issues/285
+      },
+    } as object) // https://github.com/facebook/flow/issues/285
+    // @ts-ignore
     window.addEventListener('test-passive', null, opts)
   } catch (e) {}
 }
@@ -43,7 +51,8 @@ export const isServerRendering = () => {
     if (!inBrowser && !inWeex && typeof global !== 'undefined') {
       // detect presence of vue-server-renderer and avoid
       // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server'
+      _isServer =
+        global['process'] && global['process'].env.VUE_ENV === 'server'
     } else {
       _isServer = false
     }
@@ -52,45 +61,47 @@ export const isServerRendering = () => {
 }
 
 // detect devtools
+// @ts-ignore TODO decalre this types
 export const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__
 
 /* istanbul ignore next */
-export function isNative (Ctor: any): boolean {
+export function isNative(Ctor: any): boolean {
   return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
 }
 
 export const hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys)
+  typeof Symbol !== 'undefined' &&
+  isNative(Symbol) &&
+  typeof Reflect !== 'undefined' &&
+  isNative(Reflect.ownKeys)
 
-let _Set
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
+let _Set // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
   // use native Set when available.
   _Set = Set
 } else {
   // a non-standard Set polyfill that only works with primitive keys.
   _Set = class Set implements SimpleSet {
-    set: Object;
-    constructor () {
+    set: Object
+    constructor() {
       this.set = Object.create(null)
     }
-    has (key: string | number) {
+    has(key: string | number) {
       return this.set[key] === true
     }
-    add (key: string | number) {
+    add(key: string | number) {
       this.set[key] = true
     }
-    clear () {
+    clear() {
       this.set = Object.create(null)
     }
   }
 }
 
 export interface SimpleSet {
-  has(key: string | number): boolean;
-  add(key: string | number): mixed;
-  clear(): void;
+  has(key: string | number): boolean
+  add(key: string | number): any
+  clear(): void
 }
 
 export { _Set }
diff --git a/src/core/util/error.js b/src/core/util/error.ts
similarity index 87%
rename from src/core/util/error.js
rename to src/core/util/error.ts
index 4dbdbc7443d..ed7c5393ed0 100644
--- a/src/core/util/error.js
+++ b/src/core/util/error.ts
@@ -1,12 +1,10 @@
-/* @flow */
-
 import config from '../config'
 import { warn } from './debug'
 import { inBrowser, inWeex } from './env'
 import { isPromise } from 'shared/util'
 import { pushTarget, popTarget } from '../observer/dep'
 
-export function handleError (err: Error, vm: any, info: string) {
+export function handleError(err: Error, vm: any, info: string) {
   // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
   // See: https://github.com/vuejs/vuex/issues/1505
   pushTarget()
@@ -33,7 +31,7 @@ export function handleError (err: Error, vm: any, info: string) {
   }
 }
 
-export function invokeWithErrorHandling (
+export function invokeWithErrorHandling(
   handler: Function,
   context: any,
   args: null | any[],
@@ -44,7 +42,7 @@ export function invokeWithErrorHandling (
   try {
     res = args ? handler.apply(context, args) : handler.call(context)
     if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
+      res.catch((e) => handleError(e, vm, info + ` (Promise/async)`))
       // issue #9511
       // avoid catch triggering multiple times when nested calls
       res._handled = true
@@ -55,7 +53,7 @@ export function invokeWithErrorHandling (
   return res
 }
 
-function globalHandleError (err, vm, info) {
+function globalHandleError(err, vm, info) {
   if (config.errorHandler) {
     try {
       return config.errorHandler.call(null, err, vm, info)
@@ -70,7 +68,7 @@ function globalHandleError (err, vm, info) {
   logError(err, vm, info)
 }
 
-function logError (err, vm, info) {
+function logError(err, vm, info) {
   if (process.env.NODE_ENV !== 'production') {
     warn(`Error in ${info}: "${err.toString()}"`, vm)
   }
diff --git a/src/core/util/index.js b/src/core/util/index.ts
similarity index 100%
rename from src/core/util/index.js
rename to src/core/util/index.ts
diff --git a/src/core/util/lang.js b/src/core/util/lang.ts
similarity index 80%
rename from src/core/util/lang.js
rename to src/core/util/lang.ts
index 89436944d39..e084e30fab9 100644
--- a/src/core/util/lang.js
+++ b/src/core/util/lang.ts
@@ -10,20 +10,20 @@ export const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037
 /**
  * Check if a string starts with $ or _
  */
-export function isReserved (str: string): boolean {
+export function isReserved(str: string): boolean {
   const c = (str + '').charCodeAt(0)
-  return c === 0x24 || c === 0x5F
+  return c === 0x24 || c === 0x5f
 }
 
 /**
  * Define a property.
  */
-export function def (obj: Object, key: string, val: any, enumerable?: boolean) {
+export function def(obj: Object, key: string, val: any, enumerable?: boolean) {
   Object.defineProperty(obj, key, {
     value: val,
     enumerable: !!enumerable,
     writable: true,
-    configurable: true
+    configurable: true,
   })
 }
 
@@ -31,7 +31,7 @@ export function def (obj: Object, key: string, val: any, enumerable?: boolean) {
  * Parse simple path.
  */
 const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`)
-export function parsePath (path: string): any {
+export function parsePath(path: string): any {
   if (bailRE.test(path)) {
     return
   }
diff --git a/src/core/util/next-tick.js b/src/core/util/next-tick.ts
similarity index 89%
rename from src/core/util/next-tick.js
rename to src/core/util/next-tick.ts
index 2efb9a9518d..8d725aa65c9 100644
--- a/src/core/util/next-tick.js
+++ b/src/core/util/next-tick.ts
@@ -7,10 +7,10 @@ import { isIE, isIOS, isNative } from './env'
 
 export let isUsingMicroTask = false
 
-const callbacks = []
+const callbacks: Array<Function> = []
 let pending = false
 
-function flushCallbacks () {
+function flushCallbacks() {
   pending = false
   const copies = callbacks.slice(0)
   callbacks.length = 0
@@ -51,11 +51,13 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
     if (isIOS) setTimeout(noop)
   }
   isUsingMicroTask = true
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
+} else if (
+  !isIE &&
+  typeof MutationObserver !== 'undefined' &&
+  (isNative(MutationObserver) ||
+    // PhantomJS and iOS 7.x
+    MutationObserver.toString() === '[object MutationObserverConstructor]')
+) {
   // Use MutationObserver where native Promise is not available,
   // e.g. PhantomJS, iOS7, Android 4.4
   // (#6466 MutationObserver is unreliable in IE11)
@@ -63,7 +65,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
   const observer = new MutationObserver(flushCallbacks)
   const textNode = document.createTextNode(String(counter))
   observer.observe(textNode, {
-    characterData: true
+    characterData: true,
   })
   timerFunc = () => {
     counter = (counter + 1) % 2
@@ -84,7 +86,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
   }
 }
 
-export function nextTick (cb?: Function, ctx?: Object) {
+export function nextTick(cb?: Function, ctx?: Object) {
   let _resolve
   callbacks.push(() => {
     if (cb) {
@@ -103,7 +105,7 @@ export function nextTick (cb?: Function, ctx?: Object) {
   }
   // $flow-disable-line
   if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
       _resolve = resolve
     })
   }
diff --git a/src/core/util/options.js b/src/core/util/options.ts
similarity index 71%
rename from src/core/util/options.js
rename to src/core/util/options.ts
index 243567859de..f8fce1776dc 100644
--- a/src/core/util/options.js
+++ b/src/core/util/options.ts
@@ -6,10 +6,7 @@ import { set } from '../observer/index'
 import { unicodeRegExp } from './lang'
 import { nativeWatch, hasSymbol } from './env'
 
-import {
-  ASSET_TYPES,
-  LIFECYCLE_HOOKS
-} from 'shared/constants'
+import { ASSET_TYPES, LIFECYCLE_HOOKS } from 'shared/constants'
 
 import {
   extend,
@@ -18,8 +15,10 @@ import {
   toRawType,
   capitalize,
   isBuiltInTag,
-  isPlainObject
+  isPlainObject,
 } from 'shared/util'
+import { Component } from 'typescript/component'
+import { ComponentOptions } from 'typescript/options'
 
 /**
  * Option overwriting strategies are functions that handle
@@ -32,11 +31,16 @@ const strats = config.optionMergeStrategies
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
+  strats.el = strats.propsData = function (
+    parent: any,
+    child: any,
+    vm: any,
+    key: any
+  ) {
     if (!vm) {
       warn(
         `option "${key}" can only be used during instance ` +
-        'creation with the `new` keyword.'
+          'creation with the `new` keyword.'
       )
     }
     return defaultStrat(parent, child)
@@ -46,12 +50,15 @@ if (process.env.NODE_ENV !== 'production') {
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to: Object, from: ?Object): Object {
+function mergeData(
+  to: Record<string | symbol, any>,
+  from: Record<string | symbol, any> | null
+): Record<PropertyKey, any> {
   if (!from) return to
   let key, toVal, fromVal
 
   const keys = hasSymbol
-    ? Reflect.ownKeys(from)
+    ? (Reflect.ownKeys(from) as string[])
     : Object.keys(from)
 
   for (let i = 0; i < keys.length; i++) {
@@ -76,11 +83,11 @@ function mergeData (to: Object, from: ?Object): Object {
 /**
  * Data
  */
-export function mergeDataOrFn (
+export function mergeDataOrFn(
   parentVal: any,
   childVal: any,
   vm?: Component
-): ?Function {
+): Function | null {
   if (!vm) {
     // in a Vue.extend merge, both should be functions
     if (!childVal) {
@@ -94,21 +101,21 @@ export function mergeDataOrFn (
     // merged result of both functions... no need to
     // check if parentVal is a function here because
     // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
+    return function mergedDataFn() {
       return mergeData(
+        // @ts-ignore
         typeof childVal === 'function' ? childVal.call(this, this) : childVal,
+        // @ts-ignore
         typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
       )
     }
   } else {
-    return function mergedInstanceDataFn () {
+    return function mergedInstanceDataFn() {
       // instance merge
-      const instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal
-      const defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal
+      const instanceData =
+        typeof childVal === 'function' ? childVal.call(vm, vm) : childVal
+      const defaultData =
+        typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal
       if (instanceData) {
         return mergeData(instanceData, defaultData)
       } else {
@@ -122,15 +129,16 @@ strats.data = function (
   parentVal: any,
   childVal: any,
   vm?: Component
-): ?Function {
+): Function | null {
   if (!vm) {
     if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      )
+      process.env.NODE_ENV !== 'production' &&
+        warn(
+          'The "data" option should be a function ' +
+            'that returns a per-instance value in component ' +
+            'definitions.',
+          vm
+        )
 
       return parentVal
     }
@@ -143,24 +151,22 @@ strats.data = function (
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal: ?Array<Function>,
-  childVal: ?Function | ?Array<Function>
-): ?Array<Function> {
+function mergeHook(
+  parentVal: Array<Function> | null,
+  childVal: Function | Array<Function> | null
+): Array<Function> | null {
   const res = childVal
     ? parentVal
       ? parentVal.concat(childVal)
       : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
+      ? childVal
+      : [childVal]
     : parentVal
-  return res
-    ? dedupeHooks(res)
-    : res
+  return res ? dedupeHooks(res) : res
 }
 
-function dedupeHooks (hooks) {
-  const res = []
+function dedupeHooks(hooks: any) {
+  const res: Array<any> = []
   for (let i = 0; i < hooks.length; i++) {
     if (res.indexOf(hooks[i]) === -1) {
       res.push(hooks[i])
@@ -169,7 +175,7 @@ function dedupeHooks (hooks) {
   return res
 }
 
-LIFECYCLE_HOOKS.forEach(hook => {
+LIFECYCLE_HOOKS.forEach((hook) => {
   strats[hook] = mergeHook
 })
 
@@ -180,10 +186,10 @@ LIFECYCLE_HOOKS.forEach(hook => {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal: ?Object,
-  childVal: ?Object,
-  vm?: Component,
+function mergeAssets(
+  parentVal: Object | null,
+  childVal: Object | null,
+  vm: Component | null,
   key: string
 ): Object {
   const res = Object.create(parentVal || null)
@@ -206,13 +212,15 @@ ASSET_TYPES.forEach(function (type) {
  * another, so we merge them as arrays.
  */
 strats.watch = function (
-  parentVal: ?Object,
-  childVal: ?Object,
-  vm?: Component,
+  parentVal: Record<string, any> | null,
+  childVal: Record<string, any> | null,
+  vm: Component | null,
   key: string
-): ?Object {
+): Object | null {
   // work around Firefox's Object.prototype.watch...
+  //@ts-expect-error work around
   if (parentVal === nativeWatch) parentVal = undefined
+  //@ts-expect-error work around
   if (childVal === nativeWatch) childVal = undefined
   /* istanbul ignore if */
   if (!childVal) return Object.create(parentVal || null)
@@ -220,7 +228,7 @@ strats.watch = function (
     assertObjectType(key, childVal, vm)
   }
   if (!parentVal) return childVal
-  const ret = {}
+  const ret: Record<string, any> = {}
   extend(ret, parentVal)
   for (const key in childVal) {
     let parent = ret[key]
@@ -230,7 +238,9 @@ strats.watch = function (
     }
     ret[key] = parent
       ? parent.concat(child)
-      : Array.isArray(child) ? child : [child]
+      : Array.isArray(child)
+      ? child
+      : [child]
   }
   return ret
 }
@@ -238,15 +248,12 @@ strats.watch = function (
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal: ?Object,
-  childVal: ?Object,
-  vm?: Component,
+strats.props = strats.methods = strats.inject = strats.computed = function (
+  parentVal: Object | null,
+  childVal: Object | null,
+  vm: Component | null,
   key: string
-): ?Object {
+): Object | null {
   if (childVal && process.env.NODE_ENV !== 'production') {
     assertObjectType(key, childVal, vm)
   }
@@ -262,31 +269,34 @@ strats.provide = mergeDataOrFn
  * Default strategy.
  */
 const defaultStrat = function (parentVal: any, childVal: any): any {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+  return childVal === undefined ? parentVal : childVal
 }
 
 /**
  * Validate component names
  */
-function checkComponents (options: Object) {
+function checkComponents(options: Record<string, any>) {
   for (const key in options.components) {
     validateComponentName(key)
   }
 }
 
-export function validateComponentName (name: string) {
-  if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+export function validateComponentName(name: string) {
+  if (
+    !new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)
+  ) {
     warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
+      'Invalid component name: "' +
+        name +
+        '". Component names ' +
+        'should conform to valid custom element name in html5 specification.'
     )
   }
   if (isBuiltInTag(name) || config.isReservedTag(name)) {
     warn(
       'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
+        'id: ' +
+        name
     )
   }
 }
@@ -295,10 +305,10 @@ export function validateComponentName (name: string) {
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options: Object, vm: ?Component) {
+function normalizeProps(options: Record<string, any>, vm?: Component | null) {
   const props = options.props
   if (!props) return
-  const res = {}
+  const res: Record<string, any> = {}
   let i, val, name
   if (Array.isArray(props)) {
     i = props.length
@@ -315,14 +325,12 @@ function normalizeProps (options: Object, vm: ?Component) {
     for (const key in props) {
       val = props[key]
       name = camelize(key)
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val }
+      res[name] = isPlainObject(val) ? val : { type: val }
     }
   } else if (process.env.NODE_ENV !== 'production') {
     warn(
       `Invalid value for option "props": expected an Array or an Object, ` +
-      `but got ${toRawType(props)}.`,
+        `but got ${toRawType(props)}.`,
       vm
     )
   }
@@ -332,10 +340,10 @@ function normalizeProps (options: Object, vm: ?Component) {
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options: Object, vm: ?Component) {
+function normalizeInject(options: Record<string, any>, vm?: Component | null) {
   const inject = options.inject
   if (!inject) return
-  const normalized = options.inject = {}
+  const normalized: Record<string, any> = (options.inject = {})
   if (Array.isArray(inject)) {
     for (let i = 0; i < inject.length; i++) {
       normalized[inject[i]] = { from: inject[i] }
@@ -350,7 +358,7 @@ function normalizeInject (options: Object, vm: ?Component) {
   } else if (process.env.NODE_ENV !== 'production') {
     warn(
       `Invalid value for option "inject": expected an Array or an Object, ` +
-      `but got ${toRawType(inject)}.`,
+        `but got ${toRawType(inject)}.`,
       vm
     )
   }
@@ -359,7 +367,7 @@ function normalizeInject (options: Object, vm: ?Component) {
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options: Object) {
+function normalizeDirectives(options: Record<string, any>) {
   const dirs = options.directives
   if (dirs) {
     for (const key in dirs) {
@@ -371,11 +379,11 @@ function normalizeDirectives (options: Object) {
   }
 }
 
-function assertObjectType (name: string, value: any, vm: ?Component) {
+function assertObjectType(name: string, value: any, vm: Component | null) {
   if (!isPlainObject(value)) {
     warn(
       `Invalid value for option "${name}": expected an Object, ` +
-      `but got ${toRawType(value)}.`,
+        `but got ${toRawType(value)}.`,
       vm
     )
   }
@@ -385,16 +393,17 @@ function assertObjectType (name: string, value: any, vm: ?Component) {
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-export function mergeOptions (
-  parent: Object,
-  child: Object,
-  vm?: Component
-): Object {
+export function mergeOptions(
+  parent: Record<string, any>,
+  child: Record<string, any>,
+  vm?: Component | null
+): ComponentOptions {
   if (process.env.NODE_ENV !== 'production') {
     checkComponents(child)
   }
 
   if (typeof child === 'function') {
+    // @ts-expect-error
     child = child.options
   }
 
@@ -417,7 +426,7 @@ export function mergeOptions (
     }
   }
 
-  const options = {}
+  const options: ComponentOptions = {} as any
   let key
   for (key in parent) {
     mergeField(key)
@@ -427,7 +436,7 @@ export function mergeOptions (
       mergeField(key)
     }
   }
-  function mergeField (key) {
+  function mergeField(key: any) {
     const strat = strats[key] || defaultStrat
     options[key] = strat(parent[key], child[key], vm, key)
   }
@@ -439,8 +448,8 @@ export function mergeOptions (
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-export function resolveAsset (
-  options: Object,
+export function resolveAsset(
+  options: Record<string, any>,
   type: string,
   id: string,
   warnMissing?: boolean
@@ -459,10 +468,7 @@ export function resolveAsset (
   // fallback to prototype chain
   const res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
   if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    )
+    warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options)
   }
   return res
 }
diff --git a/src/core/util/perf.js b/src/core/util/perf.ts
similarity index 93%
rename from src/core/util/perf.js
rename to src/core/util/perf.ts
index c0c8a277633..f8201ddb6ec 100644
--- a/src/core/util/perf.js
+++ b/src/core/util/perf.ts
@@ -13,7 +13,7 @@ if (process.env.NODE_ENV !== 'production') {
     perf.clearMarks &&
     perf.clearMeasures
   ) {
-    mark = tag => perf.mark(tag)
+    mark = (tag) => perf.mark(tag)
     measure = (name, startTag, endTag) => {
       perf.measure(name, startTag, endTag)
       perf.clearMarks(startTag)
diff --git a/src/core/util/props.js b/src/core/util/props.ts
similarity index 76%
rename from src/core/util/props.js
rename to src/core/util/props.ts
index 5a90f21b5f0..17757c216cc 100644
--- a/src/core/util/props.js
+++ b/src/core/util/props.ts
@@ -8,17 +8,19 @@ import {
   toRawType,
   hyphenate,
   capitalize,
-  isPlainObject
+  isPlainObject,
 } from 'shared/util'
+import { Component } from 'typescript/component'
+import { __WEEX__ } from 'typescript/weex'
 
 type PropOptions = {
-  type: Function | Array<Function> | null,
-  default: any,
-  required: ?boolean,
-  validator: ?Function
-};
+  type: Function | Array<Function> | null
+  default: any
+  required?: boolean
+  validator?: Function
+}
 
-export function validateProp (
+export function validateProp(
   key: string,
   propOptions: Object,
   propsData: Object,
@@ -54,7 +56,7 @@ export function validateProp (
   if (
     process.env.NODE_ENV !== 'production' &&
     // skip validation for weex recycle-list child component props
-    !(__WEEX__ && isObject(value) && ('@binding' in value))
+    !(__WEEX__ && isObject(value) && '@binding' in value)
   ) {
     assertProp(prop, key, value, vm, absent)
   }
@@ -64,7 +66,11 @@ export function validateProp (
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm: ?Component, prop: PropOptions, key: string): any {
+function getPropDefaultValue(
+  vm: Component | undefined,
+  prop: PropOptions,
+  key: string
+): any {
   // no default, return undefined
   if (!hasOwn(prop, 'default')) {
     return undefined
@@ -73,15 +79,19 @@ function getPropDefaultValue (vm: ?Component, prop: PropOptions, key: string): a
   // warn against non-factory defaults for Object & Array
   if (process.env.NODE_ENV !== 'production' && isObject(def)) {
     warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
+      'Invalid default value for prop "' +
+        key +
+        '": ' +
+        'Props with type Object/Array must use a factory function ' +
+        'to return the default value.',
       vm
     )
   }
   // the raw prop value was also undefined from previous render,
   // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
+  if (
+    vm &&
+    vm.$options.propsData &&
     vm.$options.propsData[key] === undefined &&
     vm._props[key] !== undefined
   ) {
@@ -97,26 +107,24 @@ function getPropDefaultValue (vm: ?Component, prop: PropOptions, key: string): a
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
+function assertProp(
   prop: PropOptions,
   name: string,
   value: any,
-  vm: ?Component,
-  absent: boolean
+  vm?: Component,
+  absent?: boolean
 ) {
   if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    )
+    warn('Missing required prop: "' + name + '"', vm)
     return
   }
   if (value == null && !prop.required) {
     return
   }
   let type = prop.type
+  // @ts-ignore
   let valid = !type || type === true
-  const expectedTypes = []
+  const expectedTypes: string[] = []
   if (type) {
     if (!Array.isArray(type)) {
       type = [type]
@@ -128,12 +136,9 @@ function assertProp (
     }
   }
 
-  const haveExpectedTypes = expectedTypes.some(t => t)
+  const haveExpectedTypes = expectedTypes.some((t) => t)
   if (!valid && haveExpectedTypes) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    )
+    warn(getInvalidTypeMessage(name, value, expectedTypes), vm)
     return
   }
   const validator = prop.validator
@@ -149,9 +154,13 @@ function assertProp (
 
 const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/
 
-function assertType (value: any, type: Function, vm: ?Component): {
-  valid: boolean;
-  expectedType: string;
+function assertType(
+  value: any,
+  type: Function,
+  vm?: Component
+): {
+  valid: boolean
+  expectedType: string
 } {
   let valid
   const expectedType = getType(type)
@@ -170,13 +179,13 @@ function assertType (value: any, type: Function, vm: ?Component): {
     try {
       valid = value instanceof type
     } catch (e) {
-      warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-      valid = false;
+      warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm)
+      valid = false
     }
   }
   return {
     valid,
-    expectedType
+    expectedType,
   }
 }
 
@@ -187,16 +196,16 @@ const functionTypeCheckRE = /^\s*function (\w+)/
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
+function getType(fn) {
   const match = fn && fn.toString().match(functionTypeCheckRE)
   return match ? match[1] : ''
 }
 
-function isSameType (a, b) {
+function isSameType(a, b) {
   return getType(a) === getType(b)
 }
 
-function getTypeIndex (type, expectedTypes): number {
+function getTypeIndex(type, expectedTypes): number {
   if (!Array.isArray(expectedTypes)) {
     return isSameType(expectedTypes, type) ? 0 : -1
   }
@@ -208,8 +217,9 @@ function getTypeIndex (type, expectedTypes): number {
   return -1
 }
 
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  let message = `Invalid prop: type check failed for prop "${name}".` +
+function getInvalidTypeMessage(name, value, expectedTypes) {
+  let message =
+    `Invalid prop: type check failed for prop "${name}".` +
     ` Expected ${expectedTypes.map(capitalize).join(', ')}`
   const expectedType = expectedTypes[0]
   const receivedType = toRawType(value)
@@ -230,7 +240,7 @@ function getInvalidTypeMessage (name, value, expectedTypes) {
   return message
 }
 
-function styleValue (value, type) {
+function styleValue(value, type) {
   if (type === 'String') {
     return `"${value}"`
   } else if (type === 'Number') {
@@ -241,10 +251,10 @@ function styleValue (value, type) {
 }
 
 const EXPLICABLE_TYPES = ['string', 'number', 'boolean']
-function isExplicable (value) {
-  return EXPLICABLE_TYPES.some(elem => value.toLowerCase() === elem)
+function isExplicable(value) {
+  return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem)
 }
 
-function isBoolean (...args) {
-  return args.some(elem => elem.toLowerCase() === 'boolean')
+function isBoolean(...args) {
+  return args.some((elem) => elem.toLowerCase() === 'boolean')
 }
diff --git a/src/core/vdom/create-component.js b/src/core/vdom/create-component.ts
similarity index 79%
rename from src/core/vdom/create-component.js
rename to src/core/vdom/create-component.ts
index 380902000df..6ef3a07df22 100644
--- a/src/core/vdom/create-component.js
+++ b/src/core/vdom/create-component.ts
@@ -5,18 +5,12 @@ import { resolveConstructorOptions } from 'core/instance/init'
 import { queueActivatedComponent } from 'core/observer/scheduler'
 import { createFunctionalComponent } from './create-functional-component'
 
-import {
-  warn,
-  isDef,
-  isUndef,
-  isTrue,
-  isObject
-} from '../util/index'
+import { warn, isDef, isUndef, isTrue, isObject } from '../util/index'
 
 import {
   resolveAsyncComponent,
   createAsyncPlaceholder,
-  extractPropsFromVNodeData
+  extractPropsFromVNodeData,
 } from './helpers/index'
 
 import {
@@ -24,17 +18,25 @@ import {
   activeInstance,
   updateChildComponent,
   activateChildComponent,
-  deactivateChildComponent
+  deactivateChildComponent,
 } from '../instance/lifecycle'
 
 import {
   isRecyclableComponent,
-  renderRecyclableComponentTemplate
+  renderRecyclableComponentTemplate,
 } from 'weex/runtime/recycle-list/render-component-template'
+import {
+  MountedComponentVNode,
+  VNodeData,
+  VNodeWithData,
+} from 'typescript/vnode'
+import { Component } from 'typescript/component'
+import { __WEEX__ } from 'typescript/weex'
+import { InternalComponentOptions } from 'typescript/options'
 
 // inline hooks to be invoked on component VNodes during patch
 const componentVNodeHooks = {
-  init (vnode: VNodeWithData, hydrating: boolean): ?boolean {
+  init(vnode: VNodeWithData, hydrating: boolean): boolean | void {
     if (
       vnode.componentInstance &&
       !vnode.componentInstance._isDestroyed &&
@@ -44,17 +46,17 @@ const componentVNodeHooks = {
       const mountedNode: any = vnode // work around flow
       componentVNodeHooks.prepatch(mountedNode, mountedNode)
     } else {
-      const child = vnode.componentInstance = createComponentInstanceForVnode(
+      const child = (vnode.componentInstance = createComponentInstanceForVnode(
         vnode,
         activeInstance
-      )
+      ))
       child.$mount(hydrating ? vnode.elm : undefined, hydrating)
     }
   },
 
-  prepatch (oldVnode: MountedComponentVNode, vnode: MountedComponentVNode) {
+  prepatch(oldVnode: MountedComponentVNode, vnode: MountedComponentVNode) {
     const options = vnode.componentOptions
-    const child = vnode.componentInstance = oldVnode.componentInstance
+    const child = (vnode.componentInstance = oldVnode.componentInstance)
     updateChildComponent(
       child,
       options.propsData, // updated props
@@ -64,7 +66,7 @@ const componentVNodeHooks = {
     )
   },
 
-  insert (vnode: MountedComponentVNode) {
+  insert(vnode: MountedComponentVNode) {
     const { context, componentInstance } = vnode
     if (!componentInstance._isMounted) {
       componentInstance._isMounted = true
@@ -84,7 +86,7 @@ const componentVNodeHooks = {
     }
   },
 
-  destroy (vnode: MountedComponentVNode) {
+  destroy(vnode: MountedComponentVNode) {
     const { componentInstance } = vnode
     if (!componentInstance._isDestroyed) {
       if (!vnode.data.keepAlive) {
@@ -93,16 +95,16 @@ const componentVNodeHooks = {
         deactivateChildComponent(componentInstance, true /* direct */)
       }
     }
-  }
+  },
 }
 
 const hooksToMerge = Object.keys(componentVNodeHooks)
 
-export function createComponent (
-  Ctor: Class<Component> | Function | Object | void,
-  data: ?VNodeData,
+export function createComponent(
+  Ctor: Component | Function | Object | void,
+  data: VNodeData | undefined,
   context: Component,
-  children: ?Array<VNode>,
+  children?: Array<VNode>,
   tag?: string
 ): VNode | Array<VNode> | void {
   if (isUndef(Ctor)) {
@@ -127,6 +129,7 @@ export function createComponent (
 
   // async component
   let asyncFactory
+  // @ts-expect-error
   if (isUndef(Ctor.cid)) {
     asyncFactory = Ctor
     Ctor = resolveAsyncComponent(asyncFactory, baseCtor)
@@ -134,13 +137,7 @@ export function createComponent (
       // return a placeholder node for async component, which is rendered
       // as a comment node but preserves all the raw information for the node.
       // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
+      return createAsyncPlaceholder(asyncFactory, data, context, children, tag)
     }
   }
 
@@ -148,19 +145,28 @@ export function createComponent (
 
   // resolve constructor options in case global mixins are applied after
   // component constructor creation
-  resolveConstructorOptions(Ctor)
+  resolveConstructorOptions(Ctor as Component)
 
   // transform component v-model data into props & events
   if (isDef(data.model)) {
+    // @ts-expect-error
     transformModel(Ctor.options, data)
   }
 
   // extract props
+  // @ts-expect-error
   const propsData = extractPropsFromVNodeData(data, Ctor, tag)
 
   // functional component
+  // @ts-expect-error
   if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
+    return createFunctionalComponent(
+      Ctor as Component,
+      propsData,
+      data,
+      context,
+      children
+    )
   }
 
   // extract listeners, since these needs to be treated as
@@ -170,6 +176,7 @@ export function createComponent (
   // so it gets processed during parent component patch.
   data.on = data.nativeOn
 
+  // @ts-expect-error
   if (isTrue(Ctor.options.abstract)) {
     // abstract components do not keep anything
     // other than props & listeners & slot
@@ -186,10 +193,17 @@ export function createComponent (
   installComponentHooks(data)
 
   // return a placeholder vnode
+  // @ts-expect-error
   const name = Ctor.options.name || tag
   const vnode = new VNode(
+    // @ts-expect-error
     `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`,
-    data, undefined, undefined, undefined, context,
+    data,
+    undefined,
+    undefined,
+    undefined,
+    context,
+    // @ts-expect-error
     { Ctor, propsData, listeners, tag, children },
     asyncFactory
   )
@@ -205,16 +219,16 @@ export function createComponent (
   return vnode
 }
 
-export function createComponentInstanceForVnode (
+export function createComponentInstanceForVnode(
   // we know it's MountedComponentVNode but flow doesn't
   vnode: any,
   // activeInstance in lifecycle state
-  parent: any
+  parent?: any
 ): Component {
   const options: InternalComponentOptions = {
     _isComponent: true,
     _parentVnode: vnode,
-    parent
+    parent,
   }
   // check inline-template render functions
   const inlineTemplate = vnode.data.inlineTemplate
@@ -225,19 +239,20 @@ export function createComponentInstanceForVnode (
   return new vnode.componentOptions.Ctor(options)
 }
 
-function installComponentHooks (data: VNodeData) {
+function installComponentHooks(data: VNodeData) {
   const hooks = data.hook || (data.hook = {})
   for (let i = 0; i < hooksToMerge.length; i++) {
     const key = hooksToMerge[i]
     const existing = hooks[key]
     const toMerge = componentVNodeHooks[key]
+    // @ts-expect-error
     if (existing !== toMerge && !(existing && existing._merged)) {
       hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge
     }
   }
 }
 
-function mergeHook (f1: any, f2: any): Function {
+function mergeHook(f1: any, f2: any): Function {
   const merged = (a, b) => {
     // flow complains about extra args which is why we use any
     f1(a, b)
@@ -249,7 +264,7 @@ function mergeHook (f1: any, f2: any): Function {
 
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data: any) {
+function transformModel(options, data: any) {
   const prop = (options.model && options.model.prop) || 'value'
   const event = (options.model && options.model.event) || 'input'
   ;(data.attrs || (data.attrs = {}))[prop] = data.model.value
diff --git a/src/core/vdom/create-element.js b/src/core/vdom/create-element.ts
similarity index 67%
rename from src/core/vdom/create-element.js
rename to src/core/vdom/create-element.ts
index bc81aa2b89c..d78c685ac57 100644
--- a/src/core/vdom/create-element.js
+++ b/src/core/vdom/create-element.ts
@@ -12,20 +12,20 @@ import {
   isTrue,
   isObject,
   isPrimitive,
-  resolveAsset
+  resolveAsset,
 } from '../util/index'
 
-import {
-  normalizeChildren,
-  simpleNormalizeChildren
-} from './helpers/index'
+import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
+import { Component } from 'typescript/component'
+import { VNodeData } from 'typescript/vnode'
+import { __WEEX__ } from 'typescript/weex'
 
 const SIMPLE_NORMALIZE = 1
 const ALWAYS_NORMALIZE = 2
 
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-export function createElement (
+export function createElement(
   context: Component,
   tag: any,
   data: any,
@@ -44,19 +44,21 @@ export function createElement (
   return _createElement(context, tag, data, children, normalizationType)
 }
 
-export function _createElement (
+export function _createElement(
   context: Component,
-  tag?: string | Class<Component> | Function | Object,
+  tag?: string | Component | Function | Object,
   data?: VNodeData,
   children?: any,
   normalizationType?: number
 ): VNode | Array<VNode> {
-  if (isDef(data) && isDef((data: any).__ob__)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      `Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` +
-      'Always create fresh vnode data objects in each render!',
-      context
-    )
+  if (isDef(data) && isDef((data as any).__ob__)) {
+    process.env.NODE_ENV !== 'production' &&
+      warn(
+        `Avoid using observed data object as vnode data: ${JSON.stringify(
+          data
+        )}\n` + 'Always create fresh vnode data objects in each render!',
+        context
+      )
     return createEmptyVNode()
   }
   // object syntax in v-bind
@@ -68,21 +70,23 @@ export function _createElement (
     return createEmptyVNode()
   }
   // warn against non-primitive key
-  if (process.env.NODE_ENV !== 'production' &&
-    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    isDef(data) &&
+    isDef(data.key) &&
+    !isPrimitive(data.key)
   ) {
+    // @ts-expect-error
     if (!__WEEX__ || !('@binding' in data.key)) {
       warn(
         'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
+          'use string/number value instead.',
         context
       )
     }
   }
   // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
+  if (Array.isArray(children) && typeof children[0] === 'function') {
     data = data || {}
     data.scopedSlots = { default: children[0] }
     children.length = 0
@@ -98,27 +102,36 @@ export function _createElement (
     ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
     if (config.isReservedTag(tag)) {
       // platform built-in elements
-      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn) && data.tag !== 'component') {
+      if (
+        process.env.NODE_ENV !== 'production' &&
+        isDef(data) &&
+        isDef(data.nativeOn) &&
+        data.tag !== 'component'
+      ) {
         warn(
           `The .native modifier for v-on is only valid on components but it was used on <${tag}>.`,
           context
         )
       }
       vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
+        config.parsePlatformTagName(tag),
+        data,
+        children,
+        undefined,
+        undefined,
+        context
       )
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
+    } else if (
+      (!data || !data.pre) &&
+      isDef((Ctor = resolveAsset(context.$options, 'components', tag)))
+    ) {
       // component
       vnode = createComponent(Ctor, data, context, children, tag)
     } else {
       // unknown or unlisted namespaced elements
       // check at runtime because it may get assigned a namespace when its
       // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      )
+      vnode = new VNode(tag, data, children, undefined, undefined, context)
     }
   } else {
     // direct component options / constructor
@@ -135,7 +148,7 @@ export function _createElement (
   }
 }
 
-function applyNS (vnode, ns, force) {
+function applyNS(vnode, ns, force?: boolean) {
   vnode.ns = ns
   if (vnode.tag === 'foreignObject') {
     // use default namespace inside foreignObject
@@ -145,8 +158,10 @@ function applyNS (vnode, ns, force) {
   if (isDef(vnode.children)) {
     for (let i = 0, l = vnode.children.length; i < l; i++) {
       const child = vnode.children[i]
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+      if (
+        isDef(child.tag) &&
+        (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))
+      ) {
         applyNS(child, ns, force)
       }
     }
@@ -156,7 +171,7 @@ function applyNS (vnode, ns, force) {
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
+function registerDeepBindings(data) {
   if (isObject(data.style)) {
     traverse(data.style)
   }
diff --git a/src/core/vdom/create-functional-component.js b/src/core/vdom/create-functional-component.ts
similarity index 76%
rename from src/core/vdom/create-functional-component.js
rename to src/core/vdom/create-functional-component.ts
index c6edf65dfe2..bb552ed3d3c 100644
--- a/src/core/vdom/create-functional-component.js
+++ b/src/core/vdom/create-functional-component.ts
@@ -14,15 +14,17 @@ import {
   hasOwn,
   camelize,
   emptyObject,
-  validateProp
+  validateProp,
 } from '../util/index'
+import { Component } from 'typescript/component'
+import { VNodeData } from 'typescript/vnode'
 
-export function FunctionalRenderContext (
+export function FunctionalRenderContext(
   data: VNodeData,
   props: Object,
-  children: ?Array<VNode>,
+  children: Array<VNode> | undefined,
   parent: Component,
-  Ctor: Class<Component>
+  Ctor: Component
 ) {
   const options = Ctor.options
   // ensure the createElement function in functional components
@@ -53,18 +55,18 @@ export function FunctionalRenderContext (
     if (!this.$slots) {
       normalizeScopedSlots(
         data.scopedSlots,
-        this.$slots = resolveSlots(children, parent)
+        (this.$slots = resolveSlots(children, parent))
       )
     }
     return this.$slots
   }
 
-  Object.defineProperty(this, 'scopedSlots', ({
+  Object.defineProperty(this, 'scopedSlots', {
     enumerable: true,
-    get () {
+    get() {
       return normalizeScopedSlots(data.scopedSlots, this.slots())
-    }
-  }: any))
+    },
+  } as any)
 
   // support for compiled functional template
   if (isCompiled) {
@@ -85,18 +87,19 @@ export function FunctionalRenderContext (
       return vnode
     }
   } else {
-    this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization)
+    this._c = (a, b, c, d) =>
+      createElement(contextVm, a, b, c, d, needNormalization)
   }
 }
 
 installRenderHelpers(FunctionalRenderContext.prototype)
 
-export function createFunctionalComponent (
-  Ctor: Class<Component>,
-  propsData: ?Object,
+export function createFunctionalComponent(
+  Ctor: Component,
+  propsData: Object | undefined,
   data: VNodeData,
   contextVm: Component,
-  children: ?Array<VNode>
+  children?: Array<VNode>
 ): VNode | Array<VNode> | void {
   const options = Ctor.options
   const props = {}
@@ -121,18 +124,36 @@ export function createFunctionalComponent (
   const vnode = options.render.call(null, renderContext._c, renderContext)
 
   if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
+    return cloneAndMarkFunctionalResult(
+      vnode,
+      data,
+      renderContext.parent,
+      options,
+      renderContext
+    )
   } else if (Array.isArray(vnode)) {
     const vnodes = normalizeChildren(vnode) || []
     const res = new Array(vnodes.length)
     for (let i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext)
+      res[i] = cloneAndMarkFunctionalResult(
+        vnodes[i],
+        data,
+        renderContext.parent,
+        options,
+        renderContext
+      )
     }
     return res
   }
 }
 
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
+function cloneAndMarkFunctionalResult(
+  vnode,
+  data,
+  contextVm,
+  options,
+  renderContext
+) {
   // #7817 clone node before setting fnContext, otherwise if the node is reused
   // (e.g. it was from a cached normal slot) the fnContext causes named slots
   // that should not be matched to match.
@@ -140,15 +161,17 @@ function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderCo
   clone.fnContext = contextVm
   clone.fnOptions = options
   if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext
+    ;(clone.devtoolsMeta =
+      // @ts-expect-error
+      clone.devtoolsMeta || {}).renderContext = renderContext
   }
   if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot
+    ;(clone.data || (clone.data = {})).slot = data.slot
   }
   return clone
 }
 
-function mergeProps (to, from) {
+function mergeProps(to, from) {
   for (const key in from) {
     to[camelize(key)] = from[key]
   }
diff --git a/src/core/vdom/helpers/extract-props.js b/src/core/vdom/helpers/extract-props.ts
similarity index 59%
rename from src/core/vdom/helpers/extract-props.js
rename to src/core/vdom/helpers/extract-props.ts
index f2a4166135d..3bde2e81a89 100644
--- a/src/core/vdom/helpers/extract-props.js
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -6,14 +6,16 @@ import {
   isDef,
   isUndef,
   hyphenate,
-  formatComponentName
+  formatComponentName,
 } from 'core/util/index'
+import { Component } from 'typescript/component'
+import { VNodeData } from 'typescript/vnode'
 
-export function extractPropsFromVNodeData (
+export function extractPropsFromVNodeData(
   data: VNodeData,
-  Ctor: Class<Component>,
+  Ctor: Component,
   tag?: string
-): ?Object {
+): object | undefined {
   // we are only extracting raw values here.
   // validation and default values are handled in the child
   // component itself.
@@ -28,30 +30,30 @@ export function extractPropsFromVNodeData (
       const altKey = hyphenate(key)
       if (process.env.NODE_ENV !== 'production') {
         const keyInLowerCase = key.toLowerCase()
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
+        if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
           tip(
             `Prop "${keyInLowerCase}" is passed to component ` +
-            `${formatComponentName(tag || Ctor)}, but the declared prop name is` +
-            ` "${key}". ` +
-            `Note that HTML attributes are case-insensitive and camelCased ` +
-            `props need to use their kebab-case equivalents when using in-DOM ` +
-            `templates. You should probably use "${altKey}" instead of "${key}".`
+              `${formatComponentName(
+                // @ts-ignore
+                tag || Ctor
+              )}, but the declared prop name is` +
+              ` "${key}". ` +
+              `Note that HTML attributes are case-insensitive and camelCased ` +
+              `props need to use their kebab-case equivalents when using in-DOM ` +
+              `templates. You should probably use "${altKey}" instead of "${key}".`
           )
         }
       }
       checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false)
+        checkProp(res, attrs, key, altKey, false)
     }
   }
   return res
 }
 
-function checkProp (
+function checkProp(
   res: Object,
-  hash: ?Object,
+  hash: Object | undefined,
   key: string,
   altKey: string,
   preserve: boolean
diff --git a/src/core/vdom/helpers/get-first-component-child.js b/src/core/vdom/helpers/get-first-component-child.ts
similarity index 73%
rename from src/core/vdom/helpers/get-first-component-child.js
rename to src/core/vdom/helpers/get-first-component-child.ts
index f8649dd8728..664afe0a48f 100644
--- a/src/core/vdom/helpers/get-first-component-child.js
+++ b/src/core/vdom/helpers/get-first-component-child.ts
@@ -1,9 +1,12 @@
 /* @flow */
 
 import { isDef } from 'shared/util'
+import VNode from '../vnode'
 import { isAsyncPlaceholder } from './is-async-placeholder'
 
-export function getFirstComponentChild (children: ?Array<VNode>): ?VNode {
+export function getFirstComponentChild(
+  children?: Array<VNode>
+): VNode | undefined {
   if (Array.isArray(children)) {
     for (let i = 0; i < children.length; i++) {
       const c = children[i]
diff --git a/src/core/vdom/helpers/index.js b/src/core/vdom/helpers/index.ts
similarity index 100%
rename from src/core/vdom/helpers/index.js
rename to src/core/vdom/helpers/index.ts
diff --git a/src/core/vdom/helpers/is-async-placeholder.js b/src/core/vdom/helpers/is-async-placeholder.js
deleted file mode 100644
index 6c4a6596b6a..00000000000
--- a/src/core/vdom/helpers/is-async-placeholder.js
+++ /dev/null
@@ -1,5 +0,0 @@
-/* @flow */
-
-export function isAsyncPlaceholder (node: VNode): boolean {
-  return node.isComment && node.asyncFactory
-}
diff --git a/src/core/vdom/helpers/is-async-placeholder.ts b/src/core/vdom/helpers/is-async-placeholder.ts
new file mode 100644
index 00000000000..3f901578c1a
--- /dev/null
+++ b/src/core/vdom/helpers/is-async-placeholder.ts
@@ -0,0 +1,8 @@
+/* @flow */
+
+import VNode from '../vnode'
+
+export function isAsyncPlaceholder(node: VNode): boolean {
+  // @ts-expect-error not really boolean type
+  return node.isComment && node.asyncFactory
+}
diff --git a/src/core/vdom/helpers/merge-hook.js b/src/core/vdom/helpers/merge-hook.ts
similarity index 82%
rename from src/core/vdom/helpers/merge-hook.js
rename to src/core/vdom/helpers/merge-hook.ts
index 0bb96e8bacb..4fe811660b0 100644
--- a/src/core/vdom/helpers/merge-hook.js
+++ b/src/core/vdom/helpers/merge-hook.ts
@@ -4,14 +4,18 @@ import VNode from '../vnode'
 import { createFnInvoker } from './update-listeners'
 import { remove, isDef, isUndef, isTrue } from 'shared/util'
 
-export function mergeVNodeHook (def: Object, hookKey: string, hook: Function) {
+export function mergeVNodeHook(
+  def: Record<string, any>,
+  hookKey: string,
+  hook: Function
+) {
   if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {})
+    def = def.data!.hook || (def.data!.hook = {})
   }
   let invoker
   const oldHook = def[hookKey]
 
-  function wrappedHook () {
+  function wrappedHook() {
     hook.apply(this, arguments)
     // important: remove merged hook to ensure it's called only once
     // and prevent memory leak
diff --git a/src/core/vdom/helpers/normalize-children.js b/src/core/vdom/helpers/normalize-children.ts
similarity index 84%
rename from src/core/vdom/helpers/normalize-children.js
rename to src/core/vdom/helpers/normalize-children.ts
index a4622ef44dc..201210a17cd 100644
--- a/src/core/vdom/helpers/normalize-children.js
+++ b/src/core/vdom/helpers/normalize-children.ts
@@ -15,7 +15,7 @@ import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-export function simpleNormalizeChildren (children: any) {
+export function simpleNormalizeChildren(children: any) {
   for (let i = 0; i < children.length; i++) {
     if (Array.isArray(children[i])) {
       return Array.prototype.concat.apply([], children)
@@ -28,20 +28,23 @@ export function simpleNormalizeChildren (children: any) {
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-export function normalizeChildren (children: any): ?Array<VNode> {
+export function normalizeChildren(children: any): Array<VNode> | undefined {
   return isPrimitive(children)
     ? [createTextVNode(children)]
     : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
+    ? normalizeArrayChildren(children)
+    : undefined
 }
 
-function isTextNode (node): boolean {
+function isTextNode(node): boolean {
   return isDef(node) && isDef(node.text) && isFalse(node.isComment)
 }
 
-function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNode> {
-  const res = []
+function normalizeArrayChildren(
+  children: any,
+  nestedIndex?: string
+): Array<VNode> {
+  const res: VNode[] = []
   let i, c, lastIndex, last
   for (i = 0; i < children.length; i++) {
     c = children[i]
@@ -54,7 +57,7 @@ function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNo
         c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`)
         // merge adjacent text nodes
         if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]: any).text)
+          res[lastIndex] = createTextVNode(last.text + c[0].text)
           c.shift()
         }
         res.push.apply(res, c)
@@ -75,10 +78,12 @@ function normalizeArrayChildren (children: any, nestedIndex?: string): Array<VNo
         res[lastIndex] = createTextVNode(last.text + c.text)
       } else {
         // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
+        if (
+          isTrue(children._isVList) &&
           isDef(c.tag) &&
           isUndef(c.key) &&
-          isDef(nestedIndex)) {
+          isDef(nestedIndex)
+        ) {
           c.key = `__vlist${nestedIndex}_${i}__`
         }
         res.push(c)
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.js b/src/core/vdom/helpers/normalize-scoped-slots.ts
similarity index 85%
rename from src/core/vdom/helpers/normalize-scoped-slots.js
rename to src/core/vdom/helpers/normalize-scoped-slots.ts
index 1e43fd393f7..24548796c5d 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.js
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -3,8 +3,9 @@
 import { def } from 'core/util/lang'
 import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
 import { emptyObject } from 'shared/util'
+import VNode from '../vnode'
 
-export function normalizeScopedSlots (
+export function normalizeScopedSlots(
   slots: { [key: string]: Function } | void,
   normalSlots: { [key: string]: Array<VNode> },
   prevSlots?: { [key: string]: Function } | void
@@ -46,7 +47,7 @@ export function normalizeScopedSlots (
   // avoriaz seems to mock a non-extensible $scopedSlots object
   // and when that is passed down this would cause an error
   if (slots && Object.isExtensible(slots)) {
-    (slots: any)._normalized = res
+    slots._normalized = res
   }
   def(res, '$stable', isStable)
   def(res, '$key', key)
@@ -57,13 +58,12 @@ export function normalizeScopedSlots (
 function normalizeScopedSlot(normalSlots, key, fn) {
   const normalized = function () {
     let res = arguments.length ? fn.apply(null, arguments) : fn({})
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res)
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
+    res =
+      res && typeof res === 'object' && !Array.isArray(res)
+        ? [res] // single vnode
+        : normalizeChildren(res)
+    return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+      ? undefined
       : res
   }
   // this is a slot using the new v-slot syntax without scope. although it is
@@ -73,7 +73,7 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     Object.defineProperty(normalSlots, key, {
       get: normalized,
       enumerable: true,
-      configurable: true
+      configurable: true,
     })
   }
   return normalized
diff --git a/src/core/vdom/helpers/resolve-async-component.js b/src/core/vdom/helpers/resolve-async-component.ts
similarity index 70%
rename from src/core/vdom/helpers/resolve-async-component.js
rename to src/core/vdom/helpers/resolve-async-component.ts
index 5fc00fab4af..38bcb687ac9 100644
--- a/src/core/vdom/helpers/resolve-async-component.js
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -9,30 +9,27 @@ import {
   isObject,
   hasSymbol,
   isPromise,
-  remove
+  remove,
 } from 'core/util/index'
 
-import { createEmptyVNode } from 'core/vdom/vnode'
+import VNode, { createEmptyVNode } from 'core/vdom/vnode'
 import { currentRenderingInstance } from 'core/instance/render'
+import { VNodeData } from 'typescript/vnode'
+import { Component } from 'typescript/component'
 
-function ensureCtor (comp: any, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
+function ensureCtor(comp: any, base) {
+  if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
     comp = comp.default
   }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
+  return isObject(comp) ? base.extend(comp) : comp
 }
 
-export function createAsyncPlaceholder (
+export function createAsyncPlaceholder(
   factory: Function,
-  data: ?VNodeData,
+  data: VNodeData | undefined,
   context: Component,
-  children: ?Array<VNode>,
-  tag: ?string
+  children: Array<VNode> | undefined,
+  tag?: string
 ): VNode {
   const node = createEmptyVNode()
   node.asyncFactory = factory
@@ -40,10 +37,10 @@ export function createAsyncPlaceholder (
   return node
 }
 
-export function resolveAsyncComponent (
-  factory: Function,
-  baseCtor: Class<Component>
-): Class<Component> | void {
+export function resolveAsyncComponent(
+  factory: { (...args: any[]): any; [keye: string]: any },
+  baseCtor: Component
+): Component | void {
   if (isTrue(factory.error) && isDef(factory.errorComp)) {
     return factory.errorComp
   }
@@ -63,16 +60,16 @@ export function resolveAsyncComponent (
   }
 
   if (owner && !isDef(factory.owners)) {
-    const owners = factory.owners = [owner]
+    const owners = (factory.owners = [owner])
     let sync = true
-    let timerLoading = null
-    let timerTimeout = null
+    let timerLoading: number | null = null
+    let timerTimeout: number | null = null
 
-    ;(owner: any).$on('hook:destroyed', () => remove(owners, owner))
+    owner.$on('hook:destroyed', () => remove(owners, owner))
 
     const forceRender = (renderCompleted: boolean) => {
       for (let i = 0, l = owners.length; i < l; i++) {
-        (owners[i]: any).$forceUpdate()
+        owners[i].$forceUpdate()
       }
 
       if (renderCompleted) {
@@ -88,7 +85,7 @@ export function resolveAsyncComponent (
       }
     }
 
-    const resolve = once((res: Object | Class<Component>) => {
+    const resolve = once((res: Object | Component) => {
       // cache resolved
       factory.resolved = ensureCtor(res, baseCtor)
       // invoke callbacks only if this is not a synchronous resolve
@@ -100,11 +97,12 @@ export function resolveAsyncComponent (
       }
     })
 
-    const reject = once(reason => {
-      process.env.NODE_ENV !== 'production' && warn(
-        `Failed to resolve async component: ${String(factory)}` +
-        (reason ? `\nReason: ${reason}` : '')
-      )
+    const reject = once((reason) => {
+      process.env.NODE_ENV !== 'production' &&
+        warn(
+          `Failed to resolve async component: ${String(factory)}` +
+            (reason ? `\nReason: ${reason}` : '')
+        )
       if (isDef(factory.errorComp)) {
         factory.error = true
         forceRender(true)
@@ -131,6 +129,7 @@ export function resolveAsyncComponent (
           if (res.delay === 0) {
             factory.loading = true
           } else {
+            // @ts-expect-error NodeJS timeout type
             timerLoading = setTimeout(() => {
               timerLoading = null
               if (isUndef(factory.resolved) && isUndef(factory.error)) {
@@ -142,6 +141,7 @@ export function resolveAsyncComponent (
         }
 
         if (isDef(res.timeout)) {
+          // @ts-expect-error NodeJS timeout type
           timerTimeout = setTimeout(() => {
             timerTimeout = null
             if (isUndef(factory.resolved)) {
@@ -158,8 +158,6 @@ export function resolveAsyncComponent (
 
     sync = false
     // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
+    return factory.loading ? factory.loadingComp : factory.resolved
   }
 }
diff --git a/src/core/vdom/helpers/update-listeners.js b/src/core/vdom/helpers/update-listeners.ts
similarity index 63%
rename from src/core/vdom/helpers/update-listeners.js
rename to src/core/vdom/helpers/update-listeners.ts
index dcde7f488fe..5b755f3652f 100644
--- a/src/core/vdom/helpers/update-listeners.js
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -1,22 +1,14 @@
-/* @flow */
-
-import {
-  warn,
-  invokeWithErrorHandling
-} from 'core/util/index'
-import {
-  cached,
-  isUndef,
-  isTrue,
-  isPlainObject
-} from 'shared/util'
+import { warn, invokeWithErrorHandling } from 'core/util/index'
+import { cached, isUndef, isTrue, isPlainObject } from 'shared/util'
+import { Component } from 'typescript/component'
+import { __WEEX__ } from 'typescript/weex'
 
 const normalizeEvent = cached((name: string): {
-  name: string,
-  once: boolean,
-  capture: boolean,
-  passive: boolean,
-  handler?: Function,
+  name: string
+  once: boolean
+  capture: boolean
+  passive: boolean
+  handler?: Function
   params?: Array<any>
 } => {
   const passive = name.charAt(0) === '&'
@@ -29,28 +21,43 @@ const normalizeEvent = cached((name: string): {
     name,
     once,
     capture,
-    passive
+    passive,
   }
 })
 
-export function createFnInvoker (fns: Function | Array<Function>, vm: ?Component): Function {
-  function invoker () {
+export function createFnInvoker(
+  fns: Function | Array<Function>,
+  vm?: Component
+): Function {
+  function invoker() {
     const fns = invoker.fns
     if (Array.isArray(fns)) {
       const cloned = fns.slice()
       for (let i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`)
+        invokeWithErrorHandling(
+          cloned[i],
+          null,
+          arguments as any,
+          vm,
+          `v-on handler`
+        )
       }
     } else {
       // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`)
+      return invokeWithErrorHandling(
+        fns,
+        null,
+        arguments as any,
+        vm,
+        `v-on handler`
+      )
     }
   }
   invoker.fns = fns
   return invoker
 }
 
-export function updateListeners (
+export function updateListeners(
   on: Object,
   oldOn: Object,
   add: Function,
@@ -69,10 +76,11 @@ export function updateListeners (
       event.params = def.params
     }
     if (isUndef(cur)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        `Invalid handler for event "${event.name}": got ` + String(cur),
-        vm
-      )
+      process.env.NODE_ENV !== 'production' &&
+        warn(
+          `Invalid handler for event "${event.name}": got ` + String(cur),
+          vm
+        )
     } else if (isUndef(old)) {
       if (isUndef(cur.fns)) {
         cur = on[name] = createFnInvoker(cur, vm)
diff --git a/src/core/vdom/modules/directives.js b/src/core/vdom/modules/directives.ts
similarity index 76%
rename from src/core/vdom/modules/directives.js
rename to src/core/vdom/modules/directives.ts
index ed76c6272ad..097a241e323 100644
--- a/src/core/vdom/modules/directives.js
+++ b/src/core/vdom/modules/directives.ts
@@ -3,29 +3,35 @@
 import { emptyNode } from 'core/vdom/patch'
 import { resolveAsset, handleError } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
+import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import { Component } from 'typescript/component'
 
 export default {
   create: updateDirectives,
   update: updateDirectives,
-  destroy: function unbindDirectives (vnode: VNodeWithData) {
+  destroy: function unbindDirectives(vnode: VNodeWithData) {
+    // @ts-expect-error emptyNode is not VNodeWithData
     updateDirectives(vnode, emptyNode)
-  }
+  },
 }
 
-function updateDirectives (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateDirectives(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (oldVnode.data.directives || vnode.data.directives) {
     _update(oldVnode, vnode)
   }
 }
 
-function _update (oldVnode, vnode) {
+function _update(oldVnode, vnode) {
   const isCreate = oldVnode === emptyNode
   const isDestroy = vnode === emptyNode
-  const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context)
+  const oldDirs = normalizeDirectives(
+    oldVnode.data.directives,
+    oldVnode.context
+  )
   const newDirs = normalizeDirectives(vnode.data.directives, vnode.context)
 
-  const dirsWithInsert = []
-  const dirsWithPostpatch = []
+  const dirsWithInsert: any[] = []
+  const dirsWithPostpatch: any[] = []
 
   let key, oldDir, dir
   for (key in newDirs) {
@@ -81,8 +87,8 @@ function _update (oldVnode, vnode) {
 
 const emptyModifiers = Object.create(null)
 
-function normalizeDirectives (
-  dirs: ?Array<VNodeDirective>,
+function normalizeDirectives(
+  dirs: Array<VNodeDirective> | undefined,
   vm: Component
 ): { [key: string]: VNodeDirective } {
   const res = Object.create(null)
@@ -104,11 +110,13 @@ function normalizeDirectives (
   return res
 }
 
-function getRawDirName (dir: VNodeDirective): string {
-  return dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
+function getRawDirName(dir: VNodeDirective): string {
+  return (
+    dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
+  )
 }
 
-function callHook (dir, hook, vnode, oldVnode, isDestroy) {
+function callHook(dir, hook, vnode, oldVnode, isDestroy?: any) {
   const fn = dir.def && dir.def[hook]
   if (fn) {
     try {
diff --git a/src/core/vdom/modules/index.js b/src/core/vdom/modules/index.ts
similarity index 61%
rename from src/core/vdom/modules/index.js
rename to src/core/vdom/modules/index.ts
index 727c864604d..e870f33b1b8 100644
--- a/src/core/vdom/modules/index.js
+++ b/src/core/vdom/modules/index.ts
@@ -1,7 +1,4 @@
 import directives from './directives'
 import ref from './ref'
 
-export default [
-  ref,
-  directives
-]
+export default [ref, directives]
diff --git a/src/core/vdom/modules/ref.js b/src/core/vdom/modules/ref.ts
similarity index 65%
rename from src/core/vdom/modules/ref.js
rename to src/core/vdom/modules/ref.ts
index aa9bdcfcfba..91a54a71d34 100644
--- a/src/core/vdom/modules/ref.js
+++ b/src/core/vdom/modules/ref.ts
@@ -1,23 +1,24 @@
 /* @flow */
 
 import { remove, isDef } from 'shared/util'
+import { VNodeWithData } from 'typescript/vnode'
 
 export default {
-  create (_: any, vnode: VNodeWithData) {
+  create(_: any, vnode: VNodeWithData) {
     registerRef(vnode)
   },
-  update (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+  update(oldVnode: VNodeWithData, vnode: VNodeWithData) {
     if (oldVnode.data.ref !== vnode.data.ref) {
       registerRef(oldVnode, true)
       registerRef(vnode)
     }
   },
-  destroy (vnode: VNodeWithData) {
+  destroy(vnode: VNodeWithData) {
     registerRef(vnode, true)
-  }
+  },
 }
 
-export function registerRef (vnode: VNodeWithData, isRemoval: ?boolean) {
+export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
   const key = vnode.data.ref
   if (!isDef(key)) return
 
@@ -26,16 +27,19 @@ export function registerRef (vnode: VNodeWithData, isRemoval: ?boolean) {
   const refs = vm.$refs
   if (isRemoval) {
     if (Array.isArray(refs[key])) {
+      // @ts-expect-error invalid typings
       remove(refs[key], ref)
     } else if (refs[key] === ref) {
       refs[key] = undefined
     }
   } else {
+    // @ts-expect-error invalid typings
     if (vnode.data.refInFor) {
       if (!Array.isArray(refs[key])) {
         refs[key] = [ref]
+        // @ts-expect-error invalid typings
       } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
+        // @ts-expect-error invalid typings
         refs[key].push(ref)
       }
     } else {
diff --git a/src/core/vdom/patch.js b/src/core/vdom/patch.ts
similarity index 74%
rename from src/core/vdom/patch.js
rename to src/core/vdom/patch.ts
index 2052df913b3..6064153c783 100644
--- a/src/core/vdom/patch.js
+++ b/src/core/vdom/patch.ts
@@ -25,39 +25,36 @@ import {
   isTrue,
   makeMap,
   isRegExp,
-  isPrimitive
+  isPrimitive,
 } from '../util/index'
+import { __WEEX__ } from 'typescript/weex'
 
 export const emptyNode = new VNode('', {}, [])
 
 const hooks = ['create', 'activate', 'update', 'remove', 'destroy']
 
-function sameVnode (a, b) {
+function sameVnode(a, b) {
   return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
+    a.key === b.key &&
+    ((a.tag === b.tag &&
+      a.isComment === b.isComment &&
+      isDef(a.data) === isDef(b.data) &&
+      sameInputType(a, b)) ||
+      (isTrue(a.isAsyncPlaceholder) &&
         a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
+        isUndef(b.asyncFactory.error)))
   )
 }
 
-function sameInputType (a, b) {
+function sameInputType(a, b) {
   if (a.tag !== 'input') return true
   let i
-  const typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type
-  const typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
+  const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type
+  const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type
+  return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB))
 }
 
-function createKeyToOldIdx (children, beginIdx, endIdx) {
+function createKeyToOldIdx(children, beginIdx, endIdx) {
   let i, key
   const map = {}
   for (i = beginIdx; i <= endIdx; ++i) {
@@ -67,9 +64,9 @@ function createKeyToOldIdx (children, beginIdx, endIdx) {
   return map
 }
 
-export function createPatchFunction (backend) {
+export function createPatchFunction(backend) {
   let i, j
-  const cbs = {}
+  const cbs: any = {}
 
   const { modules, nodeOps } = backend
 
@@ -82,12 +79,12 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function emptyNodeAt (elm) {
+  function emptyNodeAt(elm) {
     return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
   }
 
-  function createRmCb (childElm, listeners) {
-    function remove () {
+  function createRmCb(childElm, listeners) {
+    function remove() {
       if (--remove.listeners === 0) {
         removeNode(childElm)
       }
@@ -96,7 +93,7 @@ export function createPatchFunction (backend) {
     return remove
   }
 
-  function removeNode (el) {
+  function removeNode(el) {
     const parent = nodeOps.parentNode(el)
     // element may have already been removed due to v-html / v-text
     if (isDef(parent)) {
@@ -104,13 +101,13 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function isUnknownElement (vnode, inVPre) {
+  function isUnknownElement(vnode, inVPre) {
     return (
       !inVPre &&
       !vnode.ns &&
       !(
         config.ignoredElements.length &&
-        config.ignoredElements.some(ignore => {
+        config.ignoredElements.some((ignore) => {
           return isRegExp(ignore)
             ? ignore.test(vnode.tag)
             : ignore === vnode.tag
@@ -122,14 +119,14 @@ export function createPatchFunction (backend) {
 
   let creatingElmInVPre = 0
 
-  function createElm (
+  function createElm(
     vnode,
     insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
+    parentElm?: any,
+    refElm?: any,
+    nested?: any,
+    ownerArray?: any,
+    index?: any
   ) {
     if (isDef(vnode.elm) && isDef(ownerArray)) {
       // This vnode was used in a previous render!
@@ -155,9 +152,11 @@ export function createPatchFunction (backend) {
         }
         if (isUnknownElement(vnode, creatingElmInVPre)) {
           warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
+            'Unknown custom element: <' +
+              tag +
+              '> - did you ' +
+              'register the component correctly? For recursive components, ' +
+              'make sure to provide the "name" option.',
             vnode.context
           )
         }
@@ -207,11 +206,11 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
+  function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
     let i = vnode.data
     if (isDef(i)) {
       const isReactivated = isDef(vnode.componentInstance) && i.keepAlive
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
+      if (isDef((i = i.hook)) && isDef((i = i.init))) {
         i(vnode, false /* hydrating */)
       }
       // after calling the init hook, if the vnode is a child component
@@ -229,9 +228,12 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function initComponent (vnode, insertedVnodeQueue) {
+  function initComponent(vnode, insertedVnodeQueue) {
     if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert)
+      insertedVnodeQueue.push.apply(
+        insertedVnodeQueue,
+        vnode.data.pendingInsert
+      )
       vnode.data.pendingInsert = null
     }
     vnode.elm = vnode.componentInstance.$el
@@ -247,7 +249,7 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
+  function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
     let i
     // hack for #4339: a reactivated component with inner transition
     // does not trigger because the inner node's created hooks are not called
@@ -256,7 +258,7 @@ export function createPatchFunction (backend) {
     let innerNode = vnode
     while (innerNode.componentInstance) {
       innerNode = innerNode.componentInstance._vnode
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
+      if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
         for (i = 0; i < cbs.activate.length; ++i) {
           cbs.activate[i](emptyNode, innerNode)
         }
@@ -269,7 +271,7 @@ export function createPatchFunction (backend) {
     insert(parentElm, vnode.elm, refElm)
   }
 
-  function insert (parent, elm, ref) {
+  function insert(parent, elm, ref) {
     if (isDef(parent)) {
       if (isDef(ref)) {
         if (nodeOps.parentNode(ref) === parent) {
@@ -281,27 +283,35 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function createChildren (vnode, children, insertedVnodeQueue) {
+  function createChildren(vnode, children, insertedVnodeQueue) {
     if (Array.isArray(children)) {
       if (process.env.NODE_ENV !== 'production') {
         checkDuplicateKeys(children)
       }
       for (let i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i)
+        createElm(
+          children[i],
+          insertedVnodeQueue,
+          vnode.elm,
+          null,
+          true,
+          children,
+          i
+        )
       }
     } else if (isPrimitive(vnode.text)) {
       nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)))
     }
   }
 
-  function isPatchable (vnode) {
+  function isPatchable(vnode) {
     while (vnode.componentInstance) {
       vnode = vnode.componentInstance._vnode
     }
     return isDef(vnode.tag)
   }
 
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
+  function invokeCreateHooks(vnode, insertedVnodeQueue) {
     for (let i = 0; i < cbs.create.length; ++i) {
       cbs.create[i](emptyNode, vnode)
     }
@@ -315,64 +325,81 @@ export function createPatchFunction (backend) {
   // set scope id attribute for scoped CSS.
   // this is implemented as a special case to avoid the overhead
   // of going through the normal attribute patching process.
-  function setScope (vnode) {
+  function setScope(vnode) {
     let i
-    if (isDef(i = vnode.fnScopeId)) {
+    if (isDef((i = vnode.fnScopeId))) {
       nodeOps.setStyleScope(vnode.elm, i)
     } else {
       let ancestor = vnode
       while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
+        if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
           nodeOps.setStyleScope(vnode.elm, i)
         }
         ancestor = ancestor.parent
       }
     }
     // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
+    if (
+      isDef((i = activeInstance)) &&
       i !== vnode.context &&
       i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
+      isDef((i = i.$options._scopeId))
     ) {
       nodeOps.setStyleScope(vnode.elm, i)
     }
   }
 
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+  function addVnodes(
+    parentElm,
+    refElm,
+    vnodes,
+    startIdx,
+    endIdx,
+    insertedVnodeQueue
+  ) {
     for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx)
+      createElm(
+        vnodes[startIdx],
+        insertedVnodeQueue,
+        parentElm,
+        refElm,
+        false,
+        vnodes,
+        startIdx
+      )
     }
   }
 
-  function invokeDestroyHook (vnode) {
+  function invokeDestroyHook(vnode) {
     let i, j
     const data = vnode.data
     if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) i(vnode)
+      if (isDef((i = data.hook)) && isDef((i = i.destroy))) i(vnode)
       for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode)
     }
-    if (isDef(i = vnode.children)) {
+    if (isDef((i = vnode.children))) {
       for (j = 0; j < vnode.children.length; ++j) {
         invokeDestroyHook(vnode.children[j])
       }
     }
   }
 
-  function removeVnodes (vnodes, startIdx, endIdx) {
+  function removeVnodes(vnodes, startIdx, endIdx) {
     for (; startIdx <= endIdx; ++startIdx) {
       const ch = vnodes[startIdx]
       if (isDef(ch)) {
         if (isDef(ch.tag)) {
           removeAndInvokeRemoveHook(ch)
           invokeDestroyHook(ch)
-        } else { // Text node
+        } else {
+          // Text node
           removeNode(ch.elm)
         }
       }
     }
   }
 
-  function removeAndInvokeRemoveHook (vnode, rm) {
+  function removeAndInvokeRemoveHook(vnode, rm?: any) {
     if (isDef(rm) || isDef(vnode.data)) {
       let i
       const listeners = cbs.remove.length + 1
@@ -385,13 +412,17 @@ export function createPatchFunction (backend) {
         rm = createRmCb(vnode.elm, listeners)
       }
       // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
+      if (
+        isDef((i = vnode.componentInstance)) &&
+        isDef((i = i._vnode)) &&
+        isDef(i.data)
+      ) {
         removeAndInvokeRemoveHook(i, rm)
       }
       for (i = 0; i < cbs.remove.length; ++i) {
         cbs.remove[i](vnode, rm)
       }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
+      if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
         i(vnode, rm)
       } else {
         rm()
@@ -401,7 +432,13 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+  function updateChildren(
+    parentElm,
+    oldCh,
+    newCh,
+    insertedVnodeQueue,
+    removeOnly
+  ) {
     let oldStartIdx = 0
     let newStartIdx = 0
     let oldEndIdx = oldCh.length - 1
@@ -427,39 +464,100 @@ export function createPatchFunction (backend) {
       } else if (isUndef(oldEndVnode)) {
         oldEndVnode = oldCh[--oldEndIdx]
       } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
+        patchVnode(
+          oldStartVnode,
+          newStartVnode,
+          insertedVnodeQueue,
+          newCh,
+          newStartIdx
+        )
         oldStartVnode = oldCh[++oldStartIdx]
         newStartVnode = newCh[++newStartIdx]
       } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
+        patchVnode(
+          oldEndVnode,
+          newEndVnode,
+          insertedVnodeQueue,
+          newCh,
+          newEndIdx
+        )
         oldEndVnode = oldCh[--oldEndIdx]
         newEndVnode = newCh[--newEndIdx]
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx)
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
+      } else if (sameVnode(oldStartVnode, newEndVnode)) {
+        // Vnode moved right
+        patchVnode(
+          oldStartVnode,
+          newEndVnode,
+          insertedVnodeQueue,
+          newCh,
+          newEndIdx
+        )
+        canMove &&
+          nodeOps.insertBefore(
+            parentElm,
+            oldStartVnode.elm,
+            nodeOps.nextSibling(oldEndVnode.elm)
+          )
         oldStartVnode = oldCh[++oldStartIdx]
         newEndVnode = newCh[--newEndIdx]
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
+      } else if (sameVnode(oldEndVnode, newStartVnode)) {
+        // Vnode moved left
+        patchVnode(
+          oldEndVnode,
+          newStartVnode,
+          insertedVnodeQueue,
+          newCh,
+          newStartIdx
+        )
+        canMove &&
+          nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
         oldEndVnode = oldCh[--oldEndIdx]
         newStartVnode = newCh[++newStartIdx]
       } else {
-        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
+        if (isUndef(oldKeyToIdx))
+          oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
         idxInOld = isDef(newStartVnode.key)
           ? oldKeyToIdx[newStartVnode.key]
           : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
+        if (isUndef(idxInOld)) {
+          // New element
+          createElm(
+            newStartVnode,
+            insertedVnodeQueue,
+            parentElm,
+            oldStartVnode.elm,
+            false,
+            newCh,
+            newStartIdx
+          )
         } else {
           vnodeToMove = oldCh[idxInOld]
           if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx)
+            patchVnode(
+              vnodeToMove,
+              newStartVnode,
+              insertedVnodeQueue,
+              newCh,
+              newStartIdx
+            )
             oldCh[idxInOld] = undefined
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
+            canMove &&
+              nodeOps.insertBefore(
+                parentElm,
+                vnodeToMove.elm,
+                oldStartVnode.elm
+              )
           } else {
             // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
+            createElm(
+              newStartVnode,
+              insertedVnodeQueue,
+              parentElm,
+              oldStartVnode.elm,
+              false,
+              newCh,
+              newStartIdx
+            )
           }
         }
         newStartVnode = newCh[++newStartIdx]
@@ -467,13 +565,20 @@ export function createPatchFunction (backend) {
     }
     if (oldStartIdx > oldEndIdx) {
       refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
+      addVnodes(
+        parentElm,
+        refElm,
+        newCh,
+        newStartIdx,
+        newEndIdx,
+        insertedVnodeQueue
+      )
     } else if (newStartIdx > newEndIdx) {
       removeVnodes(oldCh, oldStartIdx, oldEndIdx)
     }
   }
 
-  function checkDuplicateKeys (children) {
+  function checkDuplicateKeys(children) {
     const seenKeys = {}
     for (let i = 0; i < children.length; i++) {
       const vnode = children[i]
@@ -491,20 +596,20 @@ export function createPatchFunction (backend) {
     }
   }
 
-  function findIdxInOld (node, oldCh, start, end) {
+  function findIdxInOld(node, oldCh, start, end) {
     for (let i = start; i < end; i++) {
       const c = oldCh[i]
       if (isDef(c) && sameVnode(node, c)) return i
     }
   }
 
-  function patchVnode (
+  function patchVnode(
     oldVnode,
     vnode,
     insertedVnodeQueue,
     ownerArray,
     index,
-    removeOnly
+    removeOnly?: any
   ) {
     if (oldVnode === vnode) {
       return
@@ -515,7 +620,7 @@ export function createPatchFunction (backend) {
       vnode = ownerArray[index] = cloneVNode(vnode)
     }
 
-    const elm = vnode.elm = oldVnode.elm
+    const elm = (vnode.elm = oldVnode.elm)
 
     if (isTrue(oldVnode.isAsyncPlaceholder)) {
       if (isDef(vnode.asyncFactory.resolved)) {
@@ -530,7 +635,8 @@ export function createPatchFunction (backend) {
     // note we only do this if the vnode is cloned -
     // if the new node is not cloned it means the render functions have been
     // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
+    if (
+      isTrue(vnode.isStatic) &&
       isTrue(oldVnode.isStatic) &&
       vnode.key === oldVnode.key &&
       (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
@@ -541,7 +647,7 @@ export function createPatchFunction (backend) {
 
     let i
     const data = vnode.data
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
+    if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
       i(oldVnode, vnode)
     }
 
@@ -549,11 +655,12 @@ export function createPatchFunction (backend) {
     const ch = vnode.children
     if (isDef(data) && isPatchable(vnode)) {
       for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode)
-      if (isDef(i = data.hook) && isDef(i = i.update)) i(oldVnode, vnode)
+      if (isDef((i = data.hook)) && isDef((i = i.update))) i(oldVnode, vnode)
     }
     if (isUndef(vnode.text)) {
       if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
+        if (oldCh !== ch)
+          updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
       } else if (isDef(ch)) {
         if (process.env.NODE_ENV !== 'production') {
           checkDuplicateKeys(ch)
@@ -569,11 +676,11 @@ export function createPatchFunction (backend) {
       nodeOps.setTextContent(elm, vnode.text)
     }
     if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
+      if (isDef((i = data.hook)) && isDef((i = i.postpatch))) i(oldVnode, vnode)
     }
   }
 
-  function invokeInsertHook (vnode, queue, initial) {
+  function invokeInsertHook(vnode, queue, initial) {
     // delay insert hooks for component root nodes, invoke them after the
     // element is really inserted
     if (isTrue(initial) && isDef(vnode.parent)) {
@@ -593,7 +700,7 @@ export function createPatchFunction (backend) {
   const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key')
 
   // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
+  function hydrate(elm, vnode, insertedVnodeQueue, inVPre?: boolean) {
     let i
     const { tag, data, children } = vnode
     inVPre = inVPre || (data && data.pre)
@@ -610,8 +717,9 @@ export function createPatchFunction (backend) {
       }
     }
     if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode, true /* hydrating */)
-      if (isDef(i = vnode.componentInstance)) {
+      if (isDef((i = data.hook)) && isDef((i = i.init)))
+        i(vnode, true /* hydrating */)
+      if (isDef((i = vnode.componentInstance))) {
         // child component. it should have hydrated its own tree.
         initComponent(vnode, insertedVnodeQueue)
         return true
@@ -624,10 +732,15 @@ export function createPatchFunction (backend) {
           createChildren(vnode, children, insertedVnodeQueue)
         } else {
           // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
+          if (
+            isDef((i = data)) &&
+            isDef((i = i.domProps)) &&
+            isDef((i = i.innerHTML))
+          ) {
             if (i !== elm.innerHTML) {
               /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
+              if (
+                process.env.NODE_ENV !== 'production' &&
                 typeof console !== 'undefined' &&
                 !hydrationBailed
               ) {
@@ -643,7 +756,10 @@ export function createPatchFunction (backend) {
             let childrenMatch = true
             let childNode = elm.firstChild
             for (let i = 0; i < children.length; i++) {
-              if (!childNode || !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+              if (
+                !childNode ||
+                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)
+              ) {
                 childrenMatch = false
                 break
               }
@@ -653,13 +769,18 @@ export function createPatchFunction (backend) {
             // longer than the virtual children list.
             if (!childrenMatch || childNode) {
               /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
+              if (
+                process.env.NODE_ENV !== 'production' &&
                 typeof console !== 'undefined' &&
                 !hydrationBailed
               ) {
                 hydrationBailed = true
                 console.warn('Parent: ', elm)
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children)
+                console.warn(
+                  'Mismatching childNodes vs. VNodes: ',
+                  elm.childNodes,
+                  children
+                )
               }
               return false
             }
@@ -686,18 +807,20 @@ export function createPatchFunction (backend) {
     return true
   }
 
-  function assertNodeMatch (node, vnode, inVPre) {
+  function assertNodeMatch(node, vnode, inVPre) {
     if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
+      return (
+        vnode.tag.indexOf('vue-component') === 0 ||
+        (!isUnknownElement(vnode, inVPre) &&
+          vnode.tag.toLowerCase() ===
+            (node.tagName && node.tagName.toLowerCase()))
       )
     } else {
       return node.nodeType === (vnode.isComment ? 8 : 3)
     }
   }
 
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
+  return function patch(oldVnode, vnode, hydrating, removeOnly) {
     if (isUndef(vnode)) {
       if (isDef(oldVnode)) invokeDestroyHook(oldVnode)
       return
@@ -731,10 +854,10 @@ export function createPatchFunction (backend) {
             } else if (process.env.NODE_ENV !== 'production') {
               warn(
                 'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
+                  'server-rendered content. This is likely caused by incorrect ' +
+                  'HTML markup, for example nesting block-level elements inside ' +
+                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                  'full client-side render.'
               )
             }
           }
diff --git a/src/core/vdom/vnode.js b/src/core/vdom/vnode.ts
similarity index 57%
rename from src/core/vdom/vnode.js
rename to src/core/vdom/vnode.ts
index bdc17e9f974..ef867750ded 100644
--- a/src/core/vdom/vnode.js
+++ b/src/core/vdom/vnode.ts
@@ -1,38 +1,40 @@
-/* @flow */
+import { Component } from 'typescript/component'
+import { ComponentOptions } from 'typescript/options'
+import { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
 
 export default class VNode {
-  tag: string | void;
-  data: VNodeData | void;
-  children: ?Array<VNode>;
-  text: string | void;
-  elm: Node | void;
-  ns: string | void;
-  context: Component | void; // rendered in this component's scope
-  key: string | number | void;
-  componentOptions: VNodeComponentOptions | void;
-  componentInstance: Component | void; // component instance
-  parent: VNode | void; // component placeholder node
+  tag: string | void
+  data: VNodeData | undefined
+  children?: Array<VNode> | null
+  text: string | void
+  elm: Node | void
+  ns: string | void
+  context: Component | void // rendered in this component's scope
+  key: string | number | void
+  componentOptions: VNodeComponentOptions | undefined
+  componentInstance: Component | void // component instance
+  parent: VNode | undefined // component placeholder node
 
   // strictly internal
-  raw: boolean; // contains raw HTML? (server only)
-  isStatic: boolean; // hoisted static node
-  isRootInsert: boolean; // necessary for enter transition check
-  isComment: boolean; // empty comment placeholder?
-  isCloned: boolean; // is a cloned node?
-  isOnce: boolean; // is a v-once node?
-  asyncFactory: Function | void; // async component factory function
-  asyncMeta: Object | void;
-  isAsyncPlaceholder: boolean;
-  ssrContext: Object | void;
-  fnContext: Component | void; // real context vm for functional nodes
-  fnOptions: ?ComponentOptions; // for SSR caching
-  devtoolsMeta: ?Object; // used to store functional render context for devtools
-  fnScopeId: ?string; // functional scope id support
+  raw: boolean // contains raw HTML? (server only)
+  isStatic: boolean // hoisted static node
+  isRootInsert: boolean // necessary for enter transition check
+  isComment: boolean // empty comment placeholder?
+  isCloned: boolean // is a cloned node?
+  isOnce: boolean // is a v-once node?
+  asyncFactory: Function | void // async component factory function
+  asyncMeta: Object | void
+  isAsyncPlaceholder: boolean
+  ssrContext?: Object | void
+  fnContext: Component | void // real context vm for functional nodes
+  fnOptions?: ComponentOptions | null // for SSR caching
+  devtoolsMeta?: Object | null // used to store functional render context for devtools
+  fnScopeId?: string | null // functional scope id support
 
-  constructor (
+  constructor(
     tag?: string,
     data?: VNodeData,
-    children?: ?Array<VNode>,
+    children?: Array<VNode> | null,
     text?: string,
     elm?: Node,
     context?: Component,
@@ -66,7 +68,7 @@ export default class VNode {
 
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
-  get child (): Component | void {
+  get child(): Component | void {
     return this.componentInstance
   }
 }
@@ -78,7 +80,7 @@ export const createEmptyVNode = (text: string = '') => {
   return node
 }
 
-export function createTextVNode (val: string | number) {
+export function createTextVNode(val: string | number) {
   return new VNode(undefined, undefined, undefined, String(val))
 }
 
@@ -86,8 +88,9 @@ export function createTextVNode (val: string | number) {
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-export function cloneVNode (vnode: VNode): VNode {
+export function cloneVNode(vnode: VNode): VNode {
   const cloned = new VNode(
+    //@ts-expect-error void type not valid here
     vnode.tag,
     vnode.data,
     // #7975
diff --git a/src/platforms/web/compiler/directives/html.js b/src/platforms/web/compiler/directives/html.ts
similarity index 66%
rename from src/platforms/web/compiler/directives/html.js
rename to src/platforms/web/compiler/directives/html.ts
index a4b7062eb6e..631c3652b34 100644
--- a/src/platforms/web/compiler/directives/html.js
+++ b/src/platforms/web/compiler/directives/html.ts
@@ -2,7 +2,7 @@
 
 import { addProp } from 'compiler/helpers'
 
-export default function html (el: ASTElement, dir: ASTDirective) {
+export default function html(el: ASTElement, dir: ASTDirective) {
   if (dir.value) {
     addProp(el, 'innerHTML', `_s(${dir.value})`, dir)
   }
diff --git a/src/platforms/web/compiler/directives/index.js b/src/platforms/web/compiler/directives/index.ts
similarity index 93%
rename from src/platforms/web/compiler/directives/index.js
rename to src/platforms/web/compiler/directives/index.ts
index 0955b51e7aa..2473ae1a735 100644
--- a/src/platforms/web/compiler/directives/index.js
+++ b/src/platforms/web/compiler/directives/index.ts
@@ -5,5 +5,5 @@ import html from './html'
 export default {
   model,
   text,
-  html
+  html,
 }
diff --git a/src/platforms/web/compiler/directives/model.js b/src/platforms/web/compiler/directives/model.ts
similarity index 74%
rename from src/platforms/web/compiler/directives/model.js
rename to src/platforms/web/compiler/directives/model.ts
index a42096109a5..7b9d0f0d4ec 100644
--- a/src/platforms/web/compiler/directives/model.js
+++ b/src/platforms/web/compiler/directives/model.ts
@@ -11,11 +11,11 @@ let warn
 export const RANGE_TOKEN = '__r'
 export const CHECKBOX_RADIO_TOKEN = '__c'
 
-export default function model (
+export default function model(
   el: ASTElement,
   dir: ASTDirective,
   _warn: Function
-): ?boolean {
+): boolean | undefined {
   warn = _warn
   const value = dir.value
   const modifiers = dir.modifiers
@@ -28,7 +28,7 @@ export default function model (
     if (tag === 'input' && type === 'file') {
       warn(
         `<${el.tag} v-model="${value}" type="file">:\n` +
-        `File inputs are read only. Use a v-on:change listener instead.`,
+          `File inputs are read only. Use a v-on:change listener instead.`,
         el.rawAttrsMap['v-model']
       )
     }
@@ -53,9 +53,9 @@ export default function model (
   } else if (process.env.NODE_ENV !== 'production') {
     warn(
       `<${el.tag} v-model="${value}">: ` +
-      `v-model is not supported on this element type. ` +
-      'If you are working with contenteditable, it\'s recommended to ' +
-      'wrap a library dedicated for that purpose inside a custom component.',
+        `v-model is not supported on this element type. ` +
+        "If you are working with contenteditable, it's recommended to " +
+        'wrap a library dedicated for that purpose inside a custom component.',
       el.rawAttrsMap['v-model']
     )
   }
@@ -64,41 +64,51 @@ export default function model (
   return true
 }
 
-function genCheckboxModel (
+function genCheckboxModel(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
+  modifiers?: ASTModifiers | null
 ) {
   const number = modifiers && modifiers.number
   const valueBinding = getBindingAttr(el, 'value') || 'null'
   const trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
   const falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
-  addProp(el, 'checked',
+  addProp(
+    el,
+    'checked',
     `Array.isArray(${value})` +
-    `?_i(${value},${valueBinding})>-1` + (
-      trueValueBinding === 'true'
+      `?_i(${value},${valueBinding})>-1` +
+      (trueValueBinding === 'true'
         ? `:(${value})`
-        : `:_q(${value},${trueValueBinding})`
-    )
+        : `:_q(${value},${trueValueBinding})`)
   )
-  addHandler(el, 'change',
+  addHandler(
+    el,
+    'change',
     `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-    'if(Array.isArray($$a)){' +
+      '$$el=$event.target,' +
+      `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+      'if(Array.isArray($$a)){' +
       `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-      `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-      `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-    `}else{${genAssignmentCode(value, '$$c')}}`,
-    null, true
+      '$$i=_i($$a,$$v);' +
+      `if($$el.checked){$$i<0&&(${genAssignmentCode(
+        value,
+        '$$a.concat([$$v])'
+      )})}` +
+      `else{$$i>-1&&(${genAssignmentCode(
+        value,
+        '$$a.slice(0,$$i).concat($$a.slice($$i+1))'
+      )})}` +
+      `}else{${genAssignmentCode(value, '$$c')}}`,
+    null,
+    true
   )
 }
 
-function genRadioModel (
+function genRadioModel(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
+  modifiers?: ASTModifiers | null
 ) {
   const number = modifiers && modifiers.number
   let valueBinding = getBindingAttr(el, 'value') || 'null'
@@ -107,13 +117,14 @@ function genRadioModel (
   addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
 }
 
-function genSelect (
+function genSelect(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
+  modifiers?: ASTModifiers | null
 ) {
   const number = modifiers && modifiers.number
-  const selectedVal = `Array.prototype.filter` +
+  const selectedVal =
+    `Array.prototype.filter` +
     `.call($event.target.options,function(o){return o.selected})` +
     `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
     `return ${number ? '_n(val)' : 'val'}})`
@@ -124,11 +135,11 @@ function genSelect (
   addHandler(el, 'change', code, null, true)
 }
 
-function genDefaultModel (
+function genDefaultModel(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
+  modifiers?: ASTModifiers | null
+): boolean | void {
   const type = el.attrsMap.type
 
   // warn if v-bind:value conflicts with v-model
@@ -140,7 +151,7 @@ function genDefaultModel (
       const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
       warn(
         `${binding}="${value}" conflicts with v-model on the same element ` +
-        'because the latter already expands to a value binding internally',
+          'because the latter already expands to a value binding internally',
         el.rawAttrsMap[binding]
       )
     }
@@ -148,11 +159,7 @@ function genDefaultModel (
 
   const { lazy, number, trim } = modifiers || {}
   const needCompositionGuard = !lazy && type !== 'range'
-  const event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input'
+  const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'
 
   let valueExpression = '$event.target.value'
   if (trim) {
diff --git a/src/platforms/web/compiler/directives/text.js b/src/platforms/web/compiler/directives/text.ts
similarity index 67%
rename from src/platforms/web/compiler/directives/text.js
rename to src/platforms/web/compiler/directives/text.ts
index c434d3e3686..59bffc79953 100644
--- a/src/platforms/web/compiler/directives/text.js
+++ b/src/platforms/web/compiler/directives/text.ts
@@ -2,7 +2,7 @@
 
 import { addProp } from 'compiler/helpers'
 
-export default function text (el: ASTElement, dir: ASTDirective) {
+export default function text(el: ASTElement, dir: ASTDirective) {
   if (dir.value) {
     addProp(el, 'textContent', `_s(${dir.value})`, dir)
   }
diff --git a/src/platforms/web/compiler/index.js b/src/platforms/web/compiler/index.ts
similarity index 100%
rename from src/platforms/web/compiler/index.js
rename to src/platforms/web/compiler/index.ts
diff --git a/src/platforms/web/compiler/modules/class.js b/src/platforms/web/compiler/modules/class.ts
similarity index 67%
rename from src/platforms/web/compiler/modules/class.js
rename to src/platforms/web/compiler/modules/class.ts
index dcb5a229c2b..a8f4ceb9dda 100644
--- a/src/platforms/web/compiler/modules/class.js
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -1,13 +1,9 @@
 /* @flow */
 
 import { parseText } from 'compiler/parser/text-parser'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
+import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 
-function transformNode (el: ASTElement, options: CompilerOptions) {
+function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
   const staticClass = getAndRemoveAttr(el, 'class')
   if (process.env.NODE_ENV !== 'production' && staticClass) {
@@ -15,9 +11,9 @@ function transformNode (el: ASTElement, options: CompilerOptions) {
     if (res) {
       warn(
         `class="${staticClass}": ` +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
+          'Interpolation inside attributes has been removed. ' +
+          'Use v-bind or the colon shorthand instead. For example, ' +
+          'instead of <div class="{{ val }}">, use <div :class="val">.',
         el.rawAttrsMap['class']
       )
     }
@@ -31,7 +27,7 @@ function transformNode (el: ASTElement, options: CompilerOptions) {
   }
 }
 
-function genData (el: ASTElement): string {
+function genData(el: ASTElement): string {
   let data = ''
   if (el.staticClass) {
     data += `staticClass:${el.staticClass},`
@@ -45,5 +41,5 @@ function genData (el: ASTElement): string {
 export default {
   staticKeys: ['staticClass'],
   transformNode,
-  genData
+  genData,
 }
diff --git a/src/platforms/web/compiler/modules/index.js b/src/platforms/web/compiler/modules/index.ts
similarity index 65%
rename from src/platforms/web/compiler/modules/index.js
rename to src/platforms/web/compiler/modules/index.ts
index 29114a530c2..438f93d2953 100644
--- a/src/platforms/web/compiler/modules/index.js
+++ b/src/platforms/web/compiler/modules/index.ts
@@ -2,8 +2,4 @@ import klass from './class'
 import style from './style'
 import model from './model'
 
-export default [
-  klass,
-  style,
-  model
-]
+export default [klass, style, model]
diff --git a/src/platforms/web/compiler/modules/model.js b/src/platforms/web/compiler/modules/model.ts
similarity index 88%
rename from src/platforms/web/compiler/modules/model.js
rename to src/platforms/web/compiler/modules/model.ts
index ced689029ed..15ba74cc857 100644
--- a/src/platforms/web/compiler/modules/model.js
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -10,20 +10,16 @@
  *   <input v-else :type="type" v-model="data[type]">
  */
 
-import {
-  addRawAttr,
-  getBindingAttr,
-  getAndRemoveAttr
-} from 'compiler/helpers'
+import { addRawAttr, getBindingAttr, getAndRemoveAttr } from 'compiler/helpers'
 
 import {
   processFor,
   processElement,
   addIfCondition,
-  createASTElement
+  createASTElement,
 } from 'compiler/parser/index'
 
-function preTransformNode (el: ASTElement, options: CompilerOptions) {
+function preTransformNode(el: ASTElement, options: CompilerOptions) {
   if (el.tag === 'input') {
     const map = el.attrsMap
     if (!map['v-model']) {
@@ -53,7 +49,7 @@ function preTransformNode (el: ASTElement, options: CompilerOptions) {
       branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra
       addIfCondition(branch0, {
         exp: branch0.if,
-        block: branch0
+        block: branch0,
       })
       // 2. add radio else-if condition
       const branch1 = cloneASTElement(el)
@@ -62,7 +58,7 @@ function preTransformNode (el: ASTElement, options: CompilerOptions) {
       processElement(branch1, options)
       addIfCondition(branch0, {
         exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-        block: branch1
+        block: branch1,
       })
       // 3. other
       const branch2 = cloneASTElement(el)
@@ -71,7 +67,7 @@ function preTransformNode (el: ASTElement, options: CompilerOptions) {
       processElement(branch2, options)
       addIfCondition(branch0, {
         exp: ifCondition,
-        block: branch2
+        block: branch2,
       })
 
       if (hasElse) {
@@ -85,10 +81,10 @@ function preTransformNode (el: ASTElement, options: CompilerOptions) {
   }
 }
 
-function cloneASTElement (el) {
+function cloneASTElement(el) {
   return createASTElement(el.tag, el.attrsList.slice(), el.parent)
 }
 
 export default {
-  preTransformNode
+  preTransformNode,
 }
diff --git a/src/platforms/web/compiler/modules/style.js b/src/platforms/web/compiler/modules/style.ts
similarity index 69%
rename from src/platforms/web/compiler/modules/style.js
rename to src/platforms/web/compiler/modules/style.ts
index 8c6bb98857c..114e94443bd 100644
--- a/src/platforms/web/compiler/modules/style.js
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -2,13 +2,9 @@
 
 import { parseText } from 'compiler/parser/text-parser'
 import { parseStyleText } from 'web/util/style'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
+import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 
-function transformNode (el: ASTElement, options: CompilerOptions) {
+function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
   const staticStyle = getAndRemoveAttr(el, 'style')
   if (staticStyle) {
@@ -18,9 +14,9 @@ function transformNode (el: ASTElement, options: CompilerOptions) {
       if (res) {
         warn(
           `style="${staticStyle}": ` +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
+            'Interpolation inside attributes has been removed. ' +
+            'Use v-bind or the colon shorthand instead. For example, ' +
+            'instead of <div style="{{ val }}">, use <div :style="val">.',
           el.rawAttrsMap['style']
         )
       }
@@ -34,7 +30,7 @@ function transformNode (el: ASTElement, options: CompilerOptions) {
   }
 }
 
-function genData (el: ASTElement): string {
+function genData(el: ASTElement): string {
   let data = ''
   if (el.staticStyle) {
     data += `staticStyle:${el.staticStyle},`
@@ -48,5 +44,5 @@ function genData (el: ASTElement): string {
 export default {
   staticKeys: ['staticStyle'],
   transformNode,
-  genData
+  genData,
 }
diff --git a/src/platforms/web/compiler/options.js b/src/platforms/web/compiler/options.ts
similarity index 84%
rename from src/platforms/web/compiler/options.js
rename to src/platforms/web/compiler/options.ts
index 70c0c488358..975bbe57399 100644
--- a/src/platforms/web/compiler/options.js
+++ b/src/platforms/web/compiler/options.ts
@@ -4,7 +4,7 @@ import {
   isPreTag,
   mustUseProp,
   isReservedTag,
-  getTagNamespace
+  getTagNamespace,
 } from '../util/index'
 
 import modules from './modules/index'
@@ -22,5 +22,6 @@ export const baseOptions: CompilerOptions = {
   canBeLeftOpenTag,
   isReservedTag,
   getTagNamespace,
-  staticKeys: genStaticKeys(modules)
-}
+  // @ts-ignore
+  staticKeys: genStaticKeys(modules),
+} as any
diff --git a/src/platforms/web/compiler/util.js b/src/platforms/web/compiler/util.ts
similarity index 67%
rename from src/platforms/web/compiler/util.js
rename to src/platforms/web/compiler/util.ts
index 7d9394d3783..88fa745dc35 100644
--- a/src/platforms/web/compiler/util.js
+++ b/src/platforms/web/compiler/util.ts
@@ -4,7 +4,7 @@ import { makeMap } from 'shared/util'
 
 export const isUnaryTag = makeMap(
   'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
+    'link,meta,param,source,track,wbr'
 )
 
 // Elements that you can, intentionally, leave open
@@ -17,8 +17,8 @@ export const canBeLeftOpenTag = makeMap(
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 export const isNonPhrasingTag = makeMap(
   'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track'
 )
diff --git a/src/platforms/web/entry-compiler.js b/src/platforms/web/entry-compiler.ts
similarity index 100%
rename from src/platforms/web/entry-compiler.js
rename to src/platforms/web/entry-compiler.ts
diff --git a/src/platforms/web/entry-runtime-with-compiler.js b/src/platforms/web/entry-runtime-with-compiler.ts
similarity index 75%
rename from src/platforms/web/entry-runtime-with-compiler.js
rename to src/platforms/web/entry-runtime-with-compiler.ts
index 2bb46362bf9..0b40274d697 100644
--- a/src/platforms/web/entry-runtime-with-compiler.js
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -7,9 +7,13 @@ import { mark, measure } from 'core/util/perf'
 import Vue from './runtime/index'
 import { query } from './util/index'
 import { compileToFunctions } from './compiler/index'
-import { shouldDecodeNewlines, shouldDecodeNewlinesForHref } from './util/compat'
+import {
+  shouldDecodeNewlines,
+  shouldDecodeNewlinesForHref,
+} from './util/compat'
+import { Component } from 'typescript/component'
 
-const idToTemplate = cached(id => {
+const idToTemplate = cached((id) => {
   const el = query(id)
   return el && el.innerHTML
 })
@@ -23,9 +27,10 @@ Vue.prototype.$mount = function (
 
   /* istanbul ignore if */
   if (el === document.body || el === document.documentElement) {
-    process.env.NODE_ENV !== 'production' && warn(
-      `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
-    )
+    process.env.NODE_ENV !== 'production' &&
+      warn(
+        `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
+      )
     return this
   }
 
@@ -54,6 +59,7 @@ Vue.prototype.$mount = function (
         return this
       }
     } else if (el) {
+      // @ts-expect-error
       template = getOuterHTML(el)
     }
     if (template) {
@@ -62,13 +68,17 @@ Vue.prototype.$mount = function (
         mark('compile')
       }
 
-      const { render, staticRenderFns } = compileToFunctions(template, {
-        outputSourceRange: process.env.NODE_ENV !== 'production',
-        shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref,
-        delimiters: options.delimiters,
-        comments: options.comments
-      }, this)
+      const { render, staticRenderFns } = compileToFunctions(
+        template,
+        {
+          outputSourceRange: process.env.NODE_ENV !== 'production',
+          shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref,
+          delimiters: options.delimiters,
+          comments: options.comments,
+        },
+        this
+      )
       options.render = render
       options.staticRenderFns = staticRenderFns
 
@@ -86,7 +96,7 @@ Vue.prototype.$mount = function (
  * Get outerHTML of elements, taking care
  * of SVG elements in IE as well.
  */
-function getOuterHTML (el: Element): string {
+function getOuterHTML(el: Element): string {
   if (el.outerHTML) {
     return el.outerHTML
   } else {
@@ -96,6 +106,7 @@ function getOuterHTML (el: Element): string {
   }
 }
 
+// @ts-expect-error
 Vue.compile = compileToFunctions
 
 export default Vue
diff --git a/src/platforms/web/entry-runtime.js b/src/platforms/web/entry-runtime.ts
similarity index 100%
rename from src/platforms/web/entry-runtime.js
rename to src/platforms/web/entry-runtime.ts
diff --git a/src/platforms/web/entry-server-basic-renderer.js b/src/platforms/web/entry-server-basic-renderer.ts
similarity index 88%
rename from src/platforms/web/entry-server-basic-renderer.js
rename to src/platforms/web/entry-server-basic-renderer.ts
index c4b973bd10c..836b02b5df0 100644
--- a/src/platforms/web/entry-server-basic-renderer.js
+++ b/src/platforms/web/entry-server-basic-renderer.ts
@@ -6,8 +6,9 @@ import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
 import { createBasicRenderer } from 'server/create-basic-renderer'
 
 export default createBasicRenderer({
+  // @ts-expect-error
   modules,
   directives,
   isUnaryTag,
-  canBeLeftOpenTag
+  canBeLeftOpenTag,
 })
diff --git a/src/platforms/web/entry-server-renderer.js b/src/platforms/web/entry-server-renderer.js
deleted file mode 100644
index f61f601b174..00000000000
--- a/src/platforms/web/entry-server-renderer.js
+++ /dev/null
@@ -1,27 +0,0 @@
-/* @flow */
-
-process.env.VUE_ENV = 'server'
-
-import { extend } from 'shared/util'
-import modules from './server/modules/index'
-import baseDirectives from './server/directives/index'
-import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
-
-import { createRenderer as _createRenderer } from 'server/create-renderer'
-import { createBundleRendererCreator } from 'server/bundle-renderer/create-bundle-renderer'
-
-export function createRenderer (options?: Object = {}): {
-  renderToString: Function,
-  renderToStream: Function
-} {
-  return _createRenderer(extend(extend({}, options), {
-    isUnaryTag,
-    canBeLeftOpenTag,
-    modules,
-    // user can provide server-side implementations for custom directives
-    // when creating the renderer.
-    directives: extend(baseDirectives, options.directives)
-  }))
-}
-
-export const createBundleRenderer = createBundleRendererCreator(createRenderer)
diff --git a/src/platforms/web/entry-server-renderer.ts b/src/platforms/web/entry-server-renderer.ts
new file mode 100644
index 00000000000..a640e6d5810
--- /dev/null
+++ b/src/platforms/web/entry-server-renderer.ts
@@ -0,0 +1,32 @@
+/* @flow */
+
+process.env.VUE_ENV = 'server'
+
+import { extend } from 'shared/util'
+import modules from './server/modules/index'
+import baseDirectives from './server/directives/index'
+import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
+
+import {
+  createRenderer as _createRenderer,
+  Renderer,
+  RenderOptions,
+} from 'server/create-renderer'
+import { createBundleRendererCreator } from 'server/bundle-renderer/create-bundle-renderer'
+
+export function createRenderer(
+  options: RenderOptions | undefined = {}
+): Renderer {
+  return _createRenderer(
+    extend(extend({}, options), {
+      isUnaryTag,
+      canBeLeftOpenTag,
+      modules,
+      // user can provide server-side implementations for custom directives
+      // when creating the renderer.
+      directives: extend(baseDirectives, options.directives),
+    })
+  )
+}
+
+export const createBundleRenderer = createBundleRendererCreator(createRenderer)
diff --git a/src/platforms/web/runtime/class-util.js b/src/platforms/web/runtime/class-util.ts
similarity index 82%
rename from src/platforms/web/runtime/class-util.js
rename to src/platforms/web/runtime/class-util.ts
index 12f0b5e243e..93a19ae7b97 100644
--- a/src/platforms/web/runtime/class-util.js
+++ b/src/platforms/web/runtime/class-util.ts
@@ -6,7 +6,7 @@ const whitespaceRE = /\s+/
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-export function addClass (el: HTMLElement, cls: ?string) {
+export function addClass(el: HTMLElement, cls?: string) {
   /* istanbul ignore if */
   if (!cls || !(cls = cls.trim())) {
     return
@@ -15,7 +15,7 @@ export function addClass (el: HTMLElement, cls: ?string) {
   /* istanbul ignore else */
   if (el.classList) {
     if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.add(c))
+      cls.split(whitespaceRE).forEach((c) => el.classList.add(c))
     } else {
       el.classList.add(cls)
     }
@@ -31,7 +31,7 @@ export function addClass (el: HTMLElement, cls: ?string) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-export function removeClass (el: HTMLElement, cls: ?string) {
+export function removeClass(el: HTMLElement, cls?: string) {
   /* istanbul ignore if */
   if (!cls || !(cls = cls.trim())) {
     return
@@ -40,7 +40,7 @@ export function removeClass (el: HTMLElement, cls: ?string) {
   /* istanbul ignore else */
   if (el.classList) {
     if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.remove(c))
+      cls.split(whitespaceRE).forEach((c) => el.classList.remove(c))
     } else {
       el.classList.remove(cls)
     }
diff --git a/src/platforms/web/runtime/components/index.js b/src/platforms/web/runtime/components/index.ts
similarity index 86%
rename from src/platforms/web/runtime/components/index.js
rename to src/platforms/web/runtime/components/index.ts
index 6bfe5780a5a..cbbaa132aaa 100644
--- a/src/platforms/web/runtime/components/index.js
+++ b/src/platforms/web/runtime/components/index.ts
@@ -3,5 +3,5 @@ import TransitionGroup from './transition-group'
 
 export default {
   Transition,
-  TransitionGroup
+  TransitionGroup,
 }
diff --git a/src/platforms/web/runtime/components/transition-group.js b/src/platforms/web/runtime/components/transition-group.ts
similarity index 75%
rename from src/platforms/web/runtime/components/transition-group.js
rename to src/platforms/web/runtime/components/transition-group.ts
index 084f394cd0d..312d6124095 100644
--- a/src/platforms/web/runtime/components/transition-group.js
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -1,5 +1,3 @@
-/* @flow */
-
 // Provides transition support for list items.
 // supports move transitions using the FLIP technique.
 
@@ -21,20 +19,25 @@ import {
   getTransitionInfo,
   transitionEndEvent,
   addTransitionClass,
-  removeTransitionClass
+  removeTransitionClass,
 } from '../transition-util'
+import VNode from 'core/vdom/vnode'
 
-const props = extend({
-  tag: String,
-  moveClass: String
-}, transitionProps)
+const props = extend(
+  {
+    tag: String,
+    moveClass: String,
+  },
+  transitionProps
+)
 
+// @ts-ignore
 delete props.mode
 
 export default {
   props,
 
-  beforeMount () {
+  beforeMount() {
     const update = this._update
     this._update = (vnode, hydrating) => {
       const restoreActiveInstance = setActiveInstance(this)
@@ -51,12 +54,12 @@ export default {
     }
   },
 
-  render (h: Function) {
+  render(h: Function) {
     const tag: string = this.tag || this.$vnode.data.tag || 'span'
     const map: Object = Object.create(null)
-    const prevChildren: Array<VNode> = this.prevChildren = this.children
+    const prevChildren: Array<VNode> = (this.prevChildren = this.children)
     const rawChildren: Array<VNode> = this.$slots.default || []
-    const children: Array<VNode> = this.children = []
+    const children: Array<VNode> = (this.children = [])
     const transitionData: Object = extractTransitionData(this)
 
     for (let i = 0; i < rawChildren.length; i++) {
@@ -67,8 +70,10 @@ export default {
           map[c.key] = c
           ;(c.data || (c.data = {})).transition = transitionData
         } else if (process.env.NODE_ENV !== 'production') {
-          const opts: ?VNodeComponentOptions = c.componentOptions
-          const name: string = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag
+          const opts = c.componentOptions
+          const name: string = opts
+            ? opts.Ctor.options.name || opts.tag || ''
+            : c.tag
           warn(`<transition-group> children must be keyed: <${name}>`)
         }
       }
@@ -79,8 +84,10 @@ export default {
       const removed: Array<VNode> = []
       for (let i = 0; i < prevChildren.length; i++) {
         const c: VNode = prevChildren[i]
-        c.data.transition = transitionData
+        c.data!.transition = transitionData
+        // @ts-ignore
         c.data.pos = c.elm.getBoundingClientRect()
+        // @ts-ignore
         if (map[c.key]) {
           kept.push(c)
         } else {
@@ -94,9 +101,9 @@ export default {
     return h(tag, null, children)
   },
 
-  updated () {
+  updated() {
     const children: Array<VNode> = this.prevChildren
-    const moveClass: string = this.moveClass || ((this.name || 'v') + '-move')
+    const moveClass: string = this.moveClass || (this.name || 'v') + '-move'
     if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
       return
     }
@@ -113,27 +120,31 @@ export default {
     this._reflow = document.body.offsetHeight
 
     children.forEach((c: VNode) => {
+      // @ts-ignore
       if (c.data.moved) {
         const el: any = c.elm
         const s: any = el.style
         addTransitionClass(el, moveClass)
         s.transform = s.WebkitTransform = s.transitionDuration = ''
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb)
-            el._moveCb = null
-            removeTransitionClass(el, moveClass)
-          }
-        })
+        el.addEventListener(
+          transitionEndEvent,
+          (el._moveCb = function cb(e) {
+            if (e && e.target !== el) {
+              return
+            }
+            if (!e || /transform$/.test(e.propertyName)) {
+              el.removeEventListener(transitionEndEvent, cb)
+              el._moveCb = null
+              removeTransitionClass(el, moveClass)
+            }
+          })
+        )
       }
     })
   },
 
   methods: {
-    hasMove (el: any, moveClass: string): boolean {
+    hasMove(el: any, moveClass: string): boolean {
       /* istanbul ignore if */
       if (!hasTransition) {
         return false
@@ -149,40 +160,51 @@ export default {
       // is applied.
       const clone: HTMLElement = el.cloneNode()
       if (el._transitionClasses) {
-        el._transitionClasses.forEach((cls: string) => { removeClass(clone, cls) })
+        el._transitionClasses.forEach((cls: string) => {
+          removeClass(clone, cls)
+        })
       }
       addClass(clone, moveClass)
       clone.style.display = 'none'
       this.$el.appendChild(clone)
-      const info: Object = getTransitionInfo(clone)
+      const info: any = getTransitionInfo(clone)
       this.$el.removeChild(clone)
       return (this._hasMove = info.hasTransform)
-    }
-  }
+    },
+  },
 }
 
-function callPendingCbs (c: VNode) {
+function callPendingCbs(c: VNode) {
   /* istanbul ignore if */
+  //@ts-ignore
   if (c.elm._moveCb) {
+    //@ts-ignore
     c.elm._moveCb()
   }
   /* istanbul ignore if */
+  //@ts-ignore
   if (c.elm._enterCb) {
+    //@ts-ignore
     c.elm._enterCb()
   }
 }
 
-function recordPosition (c: VNode) {
+function recordPosition(c: VNode) {
+  //@ts-ignore
   c.data.newPos = c.elm.getBoundingClientRect()
 }
 
-function applyTranslation (c: VNode) {
+function applyTranslation(c: VNode) {
+  //@ts-ignore
   const oldPos = c.data.pos
+  //@ts-ignore
   const newPos = c.data.newPos
   const dx = oldPos.left - newPos.left
   const dy = oldPos.top - newPos.top
   if (dx || dy) {
+    //@ts-ignore
     c.data.moved = true
+    //@ts-ignore
     const s = c.elm.style
     s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`
     s.transitionDuration = '0s'
diff --git a/src/platforms/web/runtime/components/transition.js b/src/platforms/web/runtime/components/transition.ts
similarity index 68%
rename from src/platforms/web/runtime/components/transition.js
rename to src/platforms/web/runtime/components/transition.ts
index 84fe82984a1..381c146114e 100644
--- a/src/platforms/web/runtime/components/transition.js
+++ b/src/platforms/web/runtime/components/transition.ts
@@ -8,8 +8,10 @@ import { camelize, extend, isPrimitive } from 'shared/util'
 import {
   mergeVNodeHook,
   isAsyncPlaceholder,
-  getFirstComponentChild
+  getFirstComponentChild,
 } from 'core/vdom/helpers/index'
+import VNode from 'core/vdom/vnode'
+import { Component } from 'typescript/component'
 
 export const transitionProps = {
   name: String,
@@ -26,13 +28,13 @@ export const transitionProps = {
   appearClass: String,
   appearActiveClass: String,
   appearToClass: String,
-  duration: [Number, String, Object]
+  duration: [Number, String, Object],
 }
 
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode: ?VNode): ?VNode {
-  const compOptions: ?VNodeComponentOptions = vnode && vnode.componentOptions
+function getRealChild(vnode?: VNode): VNode | undefined {
+  const compOptions = vnode && vnode.componentOptions
   if (compOptions && compOptions.Ctor.options.abstract) {
     return getRealChild(getFirstComponentChild(compOptions.children))
   } else {
@@ -40,52 +42,53 @@ function getRealChild (vnode: ?VNode): ?VNode {
   }
 }
 
-export function extractTransitionData (comp: Component): Object {
+export function extractTransitionData(comp: Component): Record<string, any> {
   const data = {}
-  const options: ComponentOptions = comp.$options
+  const options = comp.$options
   // props
   for (const key in options.propsData) {
     data[key] = comp[key]
   }
   // events.
   // extract listeners and pass them directly to the transition methods
-  const listeners: ?Object = options._parentListeners
+  const listeners = options._parentListeners
   for (const key in listeners) {
     data[camelize(key)] = listeners[key]
   }
   return data
 }
 
-function placeholder (h: Function, rawChild: VNode): ?VNode {
+function placeholder(h: Function, rawChild: VNode): VNode | undefined {
+  // @ts-expect-error
   if (/\d-keep-alive$/.test(rawChild.tag)) {
     return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
+      props: rawChild.componentOptions!.propsData,
     })
   }
 }
 
-function hasParentTransition (vnode: VNode): ?boolean {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
+function hasParentTransition(vnode: VNode): boolean | undefined {
+  while ((vnode = vnode.parent!)) {
+    if (vnode.data!.transition) {
       return true
     }
   }
 }
 
-function isSameChild (child: VNode, oldChild: VNode): boolean {
+function isSameChild(child: VNode, oldChild: VNode): boolean {
   return oldChild.key === child.key && oldChild.tag === child.tag
 }
 
 const isNotTextNode = (c: VNode) => c.tag || isAsyncPlaceholder(c)
 
-const isVShowDirective = d => d.name === 'show'
+const isVShowDirective = (d) => d.name === 'show'
 
 export default {
   name: 'transition',
   props: transitionProps,
   abstract: true,
 
-  render (h: Function) {
+  render(h: Function) {
     let children: any = this.$slots.default
     if (!children) {
       return
@@ -102,7 +105,7 @@ export default {
     if (process.env.NODE_ENV !== 'production' && children.length > 1) {
       warn(
         '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
+          '<transition-group> for lists.',
         this.$parent
       )
     }
@@ -110,13 +113,13 @@ export default {
     const mode: string = this.mode
 
     // warn invalid mode
-    if (process.env.NODE_ENV !== 'production' &&
-      mode && mode !== 'in-out' && mode !== 'out-in'
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      mode &&
+      mode !== 'in-out' &&
+      mode !== 'out-in'
     ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      )
+      warn('invalid <transition> mode: ' + mode, this.$parent)
     }
 
     const rawChild: VNode = children[0]
@@ -129,7 +132,7 @@ export default {
 
     // apply transition data to child
     // use getRealChild() to ignore abstract components e.g. keep-alive
-    const child: ?VNode = getRealChild(rawChild)
+    const child = getRealChild(rawChild)
     /* istanbul ignore if */
     if (!child) {
       return rawChild
@@ -143,17 +146,22 @@ export default {
     // component instance. This key will be used to remove pending leaving nodes
     // during entering.
     const id: string = `__transition-${this._uid}-`
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
+    child.key =
+      child.key == null
+        ? child.isComment
+          ? id + 'comment'
+          : id + child.tag
+        : isPrimitive(child.key)
+        ? String(child.key).indexOf(id) === 0
+          ? child.key
+          : id + child.key
         : child.key
 
-    const data: Object = (child.data || (child.data = {})).transition = extractTransitionData(this)
+    const data: Object = ((
+      child.data || (child.data = {})
+    ).transition = extractTransitionData(this))
     const oldRawChild: VNode = this._vnode
-    const oldChild: VNode = getRealChild(oldRawChild)
+    const oldChild = getRealChild(oldRawChild)
 
     // mark v-show
     // so that the transition module can hand over the control to the directive
@@ -167,11 +175,14 @@ export default {
       !isSameChild(child, oldChild) &&
       !isAsyncPlaceholder(oldChild) &&
       // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
+      !(
+        oldChild.componentInstance &&
+        oldChild.componentInstance._vnode!.isComment
+      )
     ) {
       // replace old child transition data with fresh one
       // important for dynamic transitions!
-      const oldData: Object = oldChild.data.transition = extend({}, data)
+      const oldData: Object = (oldChild.data.transition = extend({}, data))
       // handle transition mode
       if (mode === 'out-in') {
         // return placeholder node and queue update when leave finishes
@@ -186,13 +197,17 @@ export default {
           return oldRawChild
         }
         let delayedLeave
-        const performLeave = () => { delayedLeave() }
+        const performLeave = () => {
+          delayedLeave()
+        }
         mergeVNodeHook(data, 'afterEnter', performLeave)
         mergeVNodeHook(data, 'enterCancelled', performLeave)
-        mergeVNodeHook(oldData, 'delayLeave', leave => { delayedLeave = leave })
+        mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+          delayedLeave = leave
+        })
       }
     }
 
     return rawChild
-  }
+  },
 }
diff --git a/src/platforms/web/runtime/directives/index.js b/src/platforms/web/runtime/directives/index.ts
similarity index 91%
rename from src/platforms/web/runtime/directives/index.js
rename to src/platforms/web/runtime/directives/index.ts
index b673f11aa61..6409229c35d 100644
--- a/src/platforms/web/runtime/directives/index.js
+++ b/src/platforms/web/runtime/directives/index.ts
@@ -3,5 +3,5 @@ import show from './show'
 
 export default {
   model,
-  show
+  show,
 }
diff --git a/src/platforms/web/runtime/directives/model.js b/src/platforms/web/runtime/directives/model.ts
similarity index 77%
rename from src/platforms/web/runtime/directives/model.js
rename to src/platforms/web/runtime/directives/model.ts
index cba8ded0d94..91f250b0b92 100644
--- a/src/platforms/web/runtime/directives/model.js
+++ b/src/platforms/web/runtime/directives/model.ts
@@ -13,6 +13,7 @@ if (isIE9) {
   // http://www.matts411.com/post/internet-explorer-9-oninput/
   document.addEventListener('selectionchange', () => {
     const el = document.activeElement
+    // @ts-expect-error
     if (el && el.vmodel) {
       trigger(el, 'input')
     }
@@ -20,7 +21,7 @@ if (isIE9) {
 }
 
 const directive = {
-  inserted (el, binding, vnode, oldVnode) {
+  inserted(el, binding, vnode, oldVnode) {
     if (vnode.tag === 'select') {
       // #6903
       if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -49,7 +50,7 @@ const directive = {
     }
   },
 
-  componentUpdated (el, binding, vnode) {
+  componentUpdated(el, binding, vnode) {
     if (vnode.tag === 'select') {
       setSelected(el, binding, vnode.context)
       // in case the options rendered by v-for have changed,
@@ -57,22 +58,23 @@ const directive = {
       // detect such cases and filter out values that no longer has a matching
       // option in the DOM.
       const prevOptions = el._vOptions
-      const curOptions = el._vOptions = [].map.call(el.options, getValue)
+      const curOptions = (el._vOptions = [].map.call(el.options, getValue))
       if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
         // trigger change event if
         // no matching option found for at least one value
         const needReset = el.multiple
-          ? binding.value.some(v => hasNoMatchingOption(v, curOptions))
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions)
+          ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+          : binding.value !== binding.oldValue &&
+            hasNoMatchingOption(binding.value, curOptions)
         if (needReset) {
           trigger(el, 'change')
         }
       }
     }
-  }
+  },
 }
 
-function setSelected (el, binding, vm) {
+function setSelected(el, binding, vm) {
   actuallySetSelected(el, binding, vm)
   /* istanbul ignore if */
   if (isIE || isEdge) {
@@ -82,17 +84,18 @@ function setSelected (el, binding, vm) {
   }
 }
 
-function actuallySetSelected (el, binding, vm) {
+function actuallySetSelected(el, binding, vm) {
   const value = binding.value
   const isMultiple = el.multiple
   if (isMultiple && !Array.isArray(value)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      `<select multiple v-model="${binding.expression}"> ` +
-      `expects an Array value for its binding, but got ${
-        Object.prototype.toString.call(value).slice(8, -1)
-      }`,
-      vm
-    )
+    process.env.NODE_ENV !== 'production' &&
+      warn(
+        `<select multiple v-model="${binding.expression}"> ` +
+          `expects an Array value for its binding, but got ${Object.prototype.toString
+            .call(value)
+            .slice(8, -1)}`,
+        vm
+      )
     return
   }
   let selected, option
@@ -117,28 +120,26 @@ function actuallySetSelected (el, binding, vm) {
   }
 }
 
-function hasNoMatchingOption (value, options) {
-  return options.every(o => !looseEqual(o, value))
+function hasNoMatchingOption(value, options) {
+  return options.every((o) => !looseEqual(o, value))
 }
 
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
+function getValue(option) {
+  return '_value' in option ? option._value : option.value
 }
 
-function onCompositionStart (e) {
+function onCompositionStart(e) {
   e.target.composing = true
 }
 
-function onCompositionEnd (e) {
+function onCompositionEnd(e) {
   // prevent triggering an input event for no reason
   if (!e.target.composing) return
   e.target.composing = false
   trigger(e.target, 'input')
 }
 
-function trigger (el, type) {
+function trigger(el, type) {
   const e = document.createEvent('HTMLEvents')
   e.initEvent(type, true, true)
   el.dispatchEvent(e)
diff --git a/src/platforms/web/runtime/directives/show.js b/src/platforms/web/runtime/directives/show.ts
similarity index 71%
rename from src/platforms/web/runtime/directives/show.js
rename to src/platforms/web/runtime/directives/show.ts
index 17fb5dec20d..182832c298b 100644
--- a/src/platforms/web/runtime/directives/show.js
+++ b/src/platforms/web/runtime/directives/show.ts
@@ -1,20 +1,23 @@
 /* @flow */
 
+import VNode from 'core/vdom/vnode'
+import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 import { enter, leave } from '../modules/transition'
 
 // recursively search for possible transition defined inside the component root
-function locateNode (vnode: VNode): VNodeWithData {
+function locateNode(vnode: VNode | VNodeWithData): VNodeWithData {
+  // @ts-expect-error
   return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
+    ? locateNode(vnode.componentInstance._vnode!)
     : vnode
 }
 
 export default {
-  bind (el: any, { value }: VNodeDirective, vnode: VNodeWithData) {
+  bind(el: any, { value }: VNodeDirective, vnode: VNodeWithData) {
     vnode = locateNode(vnode)
     const transition = vnode.data && vnode.data.transition
-    const originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display
+    const originalDisplay = (el.__vOriginalDisplay =
+      el.style.display === 'none' ? '' : el.style.display)
     if (value && transition) {
       vnode.data.show = true
       enter(vnode, () => {
@@ -25,7 +28,7 @@ export default {
     }
   },
 
-  update (el: any, { value, oldValue }: VNodeDirective, vnode: VNodeWithData) {
+  update(el: any, { value, oldValue }: VNodeDirective, vnode: VNodeWithData) {
     /* istanbul ignore if */
     if (!value === !oldValue) return
     vnode = locateNode(vnode)
@@ -46,7 +49,7 @@ export default {
     }
   },
 
-  unbind (
+  unbind(
     el: any,
     binding: VNodeDirective,
     vnode: VNodeWithData,
@@ -56,5 +59,5 @@ export default {
     if (!isDestroy) {
       el.style.display = el.__vOriginalDisplay
     }
-  }
+  },
 }
diff --git a/src/platforms/web/runtime/index.js b/src/platforms/web/runtime/index.ts
similarity index 86%
rename from src/platforms/web/runtime/index.js
rename to src/platforms/web/runtime/index.ts
index fe29b22aeb1..06e74cf1b55 100644
--- a/src/platforms/web/runtime/index.js
+++ b/src/platforms/web/runtime/index.ts
@@ -1,4 +1,4 @@
-/* @flow */
+//@ts-nocheck
 
 import Vue from 'core/index'
 import config from 'core/config'
@@ -12,7 +12,7 @@ import {
   isReservedTag,
   isReservedAttr,
   getTagNamespace,
-  isUnknownElement
+  isUnknownElement,
 } from 'web/util/index'
 
 import { patch } from './patch'
@@ -55,19 +55,20 @@ if (inBrowser) {
       ) {
         console[console.info ? 'info' : 'log'](
           'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
+            'https://github.com/vuejs/vue-devtools'
         )
       }
     }
-    if (process.env.NODE_ENV !== 'production' &&
+    if (
+      process.env.NODE_ENV !== 'production' &&
       process.env.NODE_ENV !== 'test' &&
       config.productionTip !== false &&
       typeof console !== 'undefined'
     ) {
       console[console.info ? 'info' : 'log'](
         `You are running Vue in development mode.\n` +
-        `Make sure to turn on production mode when deploying for production.\n` +
-        `See more tips at https://vuejs.org/guide/deployment.html`
+          `Make sure to turn on production mode when deploying for production.\n` +
+          `See more tips at https://vuejs.org/guide/deployment.html`
       )
     }
   }, 0)
diff --git a/src/platforms/web/runtime/modules/attrs.js b/src/platforms/web/runtime/modules/attrs.ts
similarity index 85%
rename from src/platforms/web/runtime/modules/attrs.js
rename to src/platforms/web/runtime/modules/attrs.ts
index f6dc500a404..dc1221e6b5d 100644
--- a/src/platforms/web/runtime/modules/attrs.js
+++ b/src/platforms/web/runtime/modules/attrs.ts
@@ -2,11 +2,8 @@
 
 import { isIE, isIE9, isEdge } from 'core/util/env'
 
-import {
-  extend,
-  isDef,
-  isUndef
-} from 'shared/util'
+import { extend, isDef, isUndef } from 'shared/util'
+import { VNodeWithData } from 'typescript/vnode'
 
 import {
   isXlink,
@@ -15,10 +12,10 @@ import {
   isBooleanAttr,
   isEnumeratedAttr,
   isFalsyAttrValue,
-  convertEnumeratedValue
+  convertEnumeratedValue,
 } from 'web/util/index'
 
-function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   const opts = vnode.componentOptions
   if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
     return
@@ -59,7 +56,7 @@ function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
   }
 }
 
-function setAttr (el: Element, key: string, value: any, isInPre: any) {
+function setAttr(el: Element, key: string, value: any, isInPre?: any) {
   if (isInPre || el.tagName.indexOf('-') > -1) {
     baseSetAttr(el, key, value)
   } else if (isBooleanAttr(key)) {
@@ -70,9 +67,7 @@ function setAttr (el: Element, key: string, value: any, isInPre: any) {
     } else {
       // technically allowfullscreen is a boolean attribute for <iframe>,
       // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key
+      value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key
       el.setAttribute(key, value)
     }
   } else if (isEnumeratedAttr(key)) {
@@ -88,7 +83,7 @@ function setAttr (el: Element, key: string, value: any, isInPre: any) {
   }
 }
 
-function baseSetAttr (el, key, value) {
+function baseSetAttr(el, key, value) {
   if (isFalsyAttrValue(value)) {
     el.removeAttribute(key)
   } else {
@@ -97,11 +92,14 @@ function baseSetAttr (el, key, value) {
     // immediately.
     /* istanbul ignore if */
     if (
-      isIE && !isIE9 &&
+      isIE &&
+      !isIE9 &&
       el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
+      key === 'placeholder' &&
+      value !== '' &&
+      !el.__ieph
     ) {
-      const blocker = e => {
+      const blocker = (e) => {
         e.stopImmediatePropagation()
         el.removeEventListener('input', blocker)
       }
@@ -115,5 +113,5 @@ function baseSetAttr (el, key, value) {
 
 export default {
   create: updateAttrs,
-  update: updateAttrs
+  update: updateAttrs,
 }
diff --git a/src/platforms/web/runtime/modules/class.js b/src/platforms/web/runtime/modules/class.ts
similarity index 60%
rename from src/platforms/web/runtime/modules/class.js
rename to src/platforms/web/runtime/modules/class.ts
index 29fd2c111d2..f1e0e70b559 100644
--- a/src/platforms/web/runtime/modules/class.js
+++ b/src/platforms/web/runtime/modules/class.ts
@@ -1,28 +1,19 @@
 /* @flow */
 
-import {
-  isDef,
-  isUndef
-} from 'shared/util'
+import { isDef, isUndef } from 'shared/util'
+import { VNodeData } from 'typescript/vnode'
 
-import {
-  concat,
-  stringifyClass,
-  genClassForVnode
-} from 'web/util/index'
+import { concat, stringifyClass, genClassForVnode } from 'web/util/index'
 
-function updateClass (oldVnode: any, vnode: any) {
+function updateClass(oldVnode: any, vnode: any) {
   const el = vnode.elm
   const data: VNodeData = vnode.data
   const oldData: VNodeData = oldVnode.data
   if (
     isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
+    isUndef(data.class) &&
+    (isUndef(oldData) ||
+      (isUndef(oldData.staticClass) && isUndef(oldData.class)))
   ) {
     return
   }
@@ -44,5 +35,5 @@ function updateClass (oldVnode: any, vnode: any) {
 
 export default {
   create: updateClass,
-  update: updateClass
+  update: updateClass,
 }
diff --git a/src/platforms/web/runtime/modules/dom-props.js b/src/platforms/web/runtime/modules/dom-props.ts
similarity index 81%
rename from src/platforms/web/runtime/modules/dom-props.js
rename to src/platforms/web/runtime/modules/dom-props.ts
index c24994966a0..799fdf7cf87 100644
--- a/src/platforms/web/runtime/modules/dom-props.js
+++ b/src/platforms/web/runtime/modules/dom-props.ts
@@ -1,11 +1,12 @@
 /* @flow */
 
 import { isDef, isUndef, extend, toNumber } from 'shared/util'
+import { VNodeWithData } from 'typescript/vnode'
 import { isSVG } from 'web/util/index'
 
 let svgContainer
 
-function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateDOMProps(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
     return
   }
@@ -48,7 +49,11 @@ function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
       if (shouldUpdateValue(elm, strCur)) {
         elm.value = strCur
       }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
+    } else if (
+      key === 'innerHTML' &&
+      isSVG(elm.tagName) &&
+      isUndef(elm.innerHTML)
+    ) {
       // IE doesn't support innerHTML for SVG elements
       svgContainer = svgContainer || document.createElement('div')
       svgContainer.innerHTML = `<svg>${cur}</svg>`
@@ -76,27 +81,31 @@ function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
 }
 
 // check platforms/web/util/attrs.js acceptValue
-type acceptValueElm = HTMLInputElement | HTMLSelectElement | HTMLOptionElement;
+type acceptValueElm = HTMLInputElement | HTMLSelectElement | HTMLOptionElement
 
-function shouldUpdateValue (elm: acceptValueElm, checkVal: string): boolean {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
+function shouldUpdateValue(elm: acceptValueElm, checkVal: string): boolean {
+  return (
+    //@ts-expect-error
+    !elm.composing &&
+    (elm.tagName === 'OPTION' ||
+      isNotInFocusAndDirty(elm, checkVal) ||
+      isDirtyWithModifiers(elm, checkVal))
+  )
 }
 
-function isNotInFocusAndDirty (elm: acceptValueElm, checkVal: string): boolean {
+function isNotInFocusAndDirty(elm: acceptValueElm, checkVal: string): boolean {
   // return true when textbox (.number and .trim) loses focus and its value is
   // not equal to the updated value
   let notInFocus = true
   // #6157
   // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm } catch (e) {}
+  try {
+    notInFocus = document.activeElement !== elm
+  } catch (e) {}
   return notInFocus && elm.value !== checkVal
 }
 
-function isDirtyWithModifiers (elm: any, newVal: string): boolean {
+function isDirtyWithModifiers(elm: any, newVal: string): boolean {
   const value = elm.value
   const modifiers = elm._vModifiers // injected by v-model runtime
   if (isDef(modifiers)) {
@@ -112,5 +121,5 @@ function isDirtyWithModifiers (elm: any, newVal: string): boolean {
 
 export default {
   create: updateDOMProps,
-  update: updateDOMProps
+  update: updateDOMProps,
 }
diff --git a/src/platforms/web/runtime/modules/events.js b/src/platforms/web/runtime/modules/events.ts
similarity index 87%
rename from src/platforms/web/runtime/modules/events.js
rename to src/platforms/web/runtime/modules/events.ts
index ecb08af32de..8c531aec710 100644
--- a/src/platforms/web/runtime/modules/events.js
+++ b/src/platforms/web/runtime/modules/events.ts
@@ -3,14 +3,18 @@
 import { isDef, isUndef } from 'shared/util'
 import { updateListeners } from 'core/vdom/helpers/index'
 import { isIE, isFF, supportsPassive, isUsingMicroTask } from 'core/util/index'
-import { RANGE_TOKEN, CHECKBOX_RADIO_TOKEN } from 'web/compiler/directives/model'
+import {
+  RANGE_TOKEN,
+  CHECKBOX_RADIO_TOKEN,
+} from 'web/compiler/directives/model'
 import { currentFlushTimestamp } from 'core/observer/scheduler'
+import { VNodeWithData } from 'typescript/vnode'
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
 // user-attached handlers.
-function normalizeEvents (on) {
+function normalizeEvents(on) {
   /* istanbul ignore if */
   if (isDef(on[RANGE_TOKEN])) {
     // IE input[type=range] only supports `change` event
@@ -29,9 +33,9 @@ function normalizeEvents (on) {
 
 let target: any
 
-function createOnceHandler (event, handler, capture) {
+function createOnceHandler(event, handler, capture) {
   const _target = target // save current target element in closure
-  return function onceHandler () {
+  return function onceHandler() {
     const res = handler.apply(null, arguments)
     if (res !== null) {
       remove(event, onceHandler, capture, _target)
@@ -44,7 +48,7 @@ function createOnceHandler (event, handler, capture) {
 // safe to exclude.
 const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53)
 
-function add (
+function add(
   name: string,
   handler: Function,
   capture: boolean,
@@ -59,6 +63,7 @@ function add (
   if (useMicrotaskFix) {
     const attachedTimestamp = currentFlushTimestamp
     const original = handler
+    //@ts-expect-error
     handler = original._wrapper = function (e) {
       if (
         // no bubbling, should always fire.
@@ -83,26 +88,25 @@ function add (
   target.addEventListener(
     name,
     handler,
-    supportsPassive
-      ? { capture, passive }
-      : capture
+    supportsPassive ? { capture, passive } : capture
   )
 }
 
-function remove (
+function remove(
   name: string,
   handler: Function,
   capture: boolean,
   _target?: HTMLElement
 ) {
-  (_target || target).removeEventListener(
+  ;(_target || target).removeEventListener(
     name,
+    //@ts-expect-error
     handler._wrapper || handler,
     capture
   )
 }
 
-function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateDOMListeners(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
     return
   }
@@ -116,5 +120,5 @@ function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
 
 export default {
   create: updateDOMListeners,
-  update: updateDOMListeners
+  update: updateDOMListeners,
 }
diff --git a/src/platforms/web/runtime/modules/index.js b/src/platforms/web/runtime/modules/index.ts
similarity index 69%
rename from src/platforms/web/runtime/modules/index.js
rename to src/platforms/web/runtime/modules/index.ts
index 9f6ad8f956f..f9b21c2da2a 100644
--- a/src/platforms/web/runtime/modules/index.js
+++ b/src/platforms/web/runtime/modules/index.ts
@@ -5,11 +5,4 @@ import domProps from './dom-props'
 import style from './style'
 import transition from './transition'
 
-export default [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-]
+export default [attrs, klass, events, domProps, style, transition]
diff --git a/src/platforms/web/runtime/modules/style.js b/src/platforms/web/runtime/modules/style.ts
similarity index 75%
rename from src/platforms/web/runtime/modules/style.js
rename to src/platforms/web/runtime/modules/style.ts
index 4d2d39dd6ea..1e70ac852a1 100644
--- a/src/platforms/web/runtime/modules/style.js
+++ b/src/platforms/web/runtime/modules/style.ts
@@ -1,7 +1,15 @@
 /* @flow */
 
 import { getStyle, normalizeStyleBinding } from 'web/util/style'
-import { cached, camelize, extend, isDef, isUndef, hyphenate } from 'shared/util'
+import {
+  cached,
+  camelize,
+  extend,
+  isDef,
+  isUndef,
+  hyphenate,
+} from 'shared/util'
+import { VNodeWithData } from 'typescript/vnode'
 
 const cssVarRE = /^--/
 const importantRE = /\s*!important$/
@@ -10,7 +18,11 @@ const setProp = (el, name, val) => {
   if (cssVarRE.test(name)) {
     el.style.setProperty(name, val)
   } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important')
+    el.style.setProperty(
+      hyphenate(name),
+      val.replace(importantRE, ''),
+      'important'
+    )
   } else {
     const normalizedName = normalize(name)
     if (Array.isArray(val)) {
@@ -18,10 +30,10 @@ const setProp = (el, name, val) => {
       // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
       // Set them one by one, and the browser will only set those it can recognize
       for (let i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i]
+        el.style[normalizedName!] = val[i]
       }
     } else {
-      el.style[normalizedName] = val
+      el.style[normalizedName!] = val
     }
   }
 }
@@ -32,7 +44,7 @@ let emptyStyle
 const normalize = cached(function (prop) {
   emptyStyle = emptyStyle || document.createElement('div').style
   prop = camelize(prop)
-  if (prop !== 'filter' && (prop in emptyStyle)) {
+  if (prop !== 'filter' && prop in emptyStyle) {
     return prop
   }
   const capName = prop.charAt(0).toUpperCase() + prop.slice(1)
@@ -44,12 +56,15 @@ const normalize = cached(function (prop) {
   }
 })
 
-function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   const data = vnode.data
   const oldData = oldVnode.data
 
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
+  if (
+    isUndef(data.staticStyle) &&
+    isUndef(data.style) &&
+    isUndef(oldData.staticStyle) &&
+    isUndef(oldData.style)
   ) {
     return
   }
@@ -67,9 +82,8 @@ function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
   // store normalized style under a different key for next diff
   // make sure to clone it if it's reactive, since the user likely wants
   // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style
+  //@ts-expect-error
+  vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style
 
   const newStyle = getStyle(vnode, true)
 
@@ -89,5 +103,5 @@ function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
 
 export default {
   create: updateStyle,
-  update: updateStyle
+  update: updateStyle,
 }
diff --git a/src/platforms/web/runtime/modules/transition.js b/src/platforms/web/runtime/modules/transition.ts
similarity index 74%
rename from src/platforms/web/runtime/modules/transition.js
rename to src/platforms/web/runtime/modules/transition.ts
index 6117097088d..3552f767f5b 100644
--- a/src/platforms/web/runtime/modules/transition.js
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -4,23 +4,19 @@ import { inBrowser, isIE9, warn } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
 import { activeInstance } from 'core/instance/lifecycle'
 
-import {
-  once,
-  isDef,
-  isUndef,
-  isObject,
-  toNumber
-} from 'shared/util'
+import { once, isDef, isUndef, isObject, toNumber } from 'shared/util'
 
 import {
   nextFrame,
   resolveTransition,
   whenTransitionEnds,
   addTransitionClass,
-  removeTransitionClass
+  removeTransitionClass,
 } from '../transition-util'
+import { VNodeWithData } from 'typescript/vnode'
+import VNode from 'core/vdom/vnode'
 
-export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
+export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
   const el: any = vnode.elm
 
   // call leave callback now
@@ -56,7 +52,7 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
     appear,
     afterAppear,
     appearCancelled,
-    duration
+    duration,
   } = data
 
   // activeInstance will always be the <transition> component managing this
@@ -76,33 +72,24 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
     return
   }
 
-  const startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass
-  const activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass
-  const toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass
-
-  const beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter
+  const startClass = isAppear && appearClass ? appearClass : enterClass
+  const activeClass =
+    isAppear && appearActiveClass ? appearActiveClass : enterActiveClass
+  const toClass = isAppear && appearToClass ? appearToClass : enterToClass
+
+  const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter
   const enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
+    ? typeof appear === 'function'
+      ? appear
+      : enter
     : enter
-  const afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter
+  const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter
   const enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
+    ? appearCancelled || enterCancelled
     : enterCancelled
 
   const explicitEnterDuration: any = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
+    isObject(duration) ? duration.enter : duration
   )
 
   if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
@@ -112,11 +99,12 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
   const expectsCSS = css !== false && !isIE9
   const userWantsControl = getHookArgumentsLength(enterHook)
 
-  const cb = el._enterCb = once(() => {
+  const cb = (el._enterCb = once(() => {
     if (expectsCSS) {
       removeTransitionClass(el, toClass)
       removeTransitionClass(el, activeClass)
     }
+    // @ts-expect-error
     if (cb.cancelled) {
       if (expectsCSS) {
         removeTransitionClass(el, startClass)
@@ -126,14 +114,16 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
       afterEnterHook && afterEnterHook(el)
     }
     el._enterCb = null
-  })
+  }))
 
   if (!vnode.data.show) {
     // remove pending leave element on enter by injecting an insert hook
     mergeVNodeHook(vnode, 'insert', () => {
       const parent = el.parentNode
-      const pendingNode = parent && parent._pending && parent._pending[vnode.key]
-      if (pendingNode &&
+      const pendingNode =
+        parent && parent._pending && parent._pending[vnode.key!]
+      if (
+        pendingNode &&
         pendingNode.tag === vnode.tag &&
         pendingNode.elm._leaveCb
       ) {
@@ -150,6 +140,7 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
     addTransitionClass(el, activeClass)
     nextFrame(() => {
       removeTransitionClass(el, startClass)
+      // @ts-expect-error
       if (!cb.cancelled) {
         addTransitionClass(el, toClass)
         if (!userWantsControl) {
@@ -173,7 +164,7 @@ export function enter (vnode: VNodeWithData, toggleDisplay: ?() => void) {
   }
 }
 
-export function leave (vnode: VNodeWithData, rm: Function) {
+export function leave(vnode: VNodeWithData, rm: Function) {
   const el: any = vnode.elm
 
   // call enter callback now
@@ -203,30 +194,29 @@ export function leave (vnode: VNodeWithData, rm: Function) {
     afterLeave,
     leaveCancelled,
     delayLeave,
-    duration
+    duration,
   } = data
 
   const expectsCSS = css !== false && !isIE9
   const userWantsControl = getHookArgumentsLength(leave)
 
   const explicitLeaveDuration: any = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
+    isObject(duration) ? duration.leave : duration
   )
 
   if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
     checkDuration(explicitLeaveDuration, 'leave', vnode)
   }
 
-  const cb = el._leaveCb = once(() => {
+  const cb = (el._leaveCb = once(() => {
     if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null
+      el.parentNode._pending[vnode.key!] = null
     }
     if (expectsCSS) {
       removeTransitionClass(el, leaveToClass)
       removeTransitionClass(el, leaveActiveClass)
     }
+    // @ts-expect-error
     if (cb.cancelled) {
       if (expectsCSS) {
         removeTransitionClass(el, leaveClass)
@@ -237,7 +227,7 @@ export function leave (vnode: VNodeWithData, rm: Function) {
       afterLeave && afterLeave(el)
     }
     el._leaveCb = null
-  })
+  }))
 
   if (delayLeave) {
     delayLeave(performLeave)
@@ -245,14 +235,17 @@ export function leave (vnode: VNodeWithData, rm: Function) {
     performLeave()
   }
 
-  function performLeave () {
+  function performLeave() {
     // the delayed leave may have already been cancelled
+    // @ts-expect-error
     if (cb.cancelled) {
       return
     }
     // record leaving element
     if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key: any)] = vnode
+      ;(el.parentNode._pending || (el.parentNode._pending = {}))[
+        vnode.key!
+      ] = vnode
     }
     beforeLeave && beforeLeave(el)
     if (expectsCSS) {
@@ -260,6 +253,7 @@ export function leave (vnode: VNodeWithData, rm: Function) {
       addTransitionClass(el, leaveActiveClass)
       nextFrame(() => {
         removeTransitionClass(el, leaveClass)
+        // @ts-expect-error
         if (!cb.cancelled) {
           addTransitionClass(el, leaveToClass)
           if (!userWantsControl) {
@@ -280,23 +274,23 @@ export function leave (vnode: VNodeWithData, rm: Function) {
 }
 
 // only used in dev mode
-function checkDuration (val, name, vnode) {
+function checkDuration(val, name, vnode) {
   if (typeof val !== 'number') {
     warn(
       `<transition> explicit ${name} duration is not a valid number - ` +
-      `got ${JSON.stringify(val)}.`,
+        `got ${JSON.stringify(val)}.`,
       vnode.context
     )
   } else if (isNaN(val)) {
     warn(
       `<transition> explicit ${name} duration is NaN - ` +
-      'the duration expression might be incorrect.',
+        'the duration expression might be incorrect.',
       vnode.context
     )
   }
 }
 
-function isValidDuration (val) {
+function isValidDuration(val) {
   return typeof val === 'number' && !isNaN(val)
 }
 
@@ -306,38 +300,41 @@ function isValidDuration (val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength (fn: Function): boolean {
+function getHookArgumentsLength(fn: Function): boolean {
   if (isUndef(fn)) {
     return false
   }
+  // @ts-expect-error
   const invokerFns = fn.fns
   if (isDef(invokerFns)) {
     // invoker
     return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
+      Array.isArray(invokerFns) ? invokerFns[0] : invokerFns
     )
   } else {
+    // @ts-expect-error
     return (fn._length || fn.length) > 1
   }
 }
 
-function _enter (_: any, vnode: VNodeWithData) {
+function _enter(_: any, vnode: VNodeWithData) {
   if (vnode.data.show !== true) {
     enter(vnode)
   }
 }
 
-export default inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove (vnode: VNode, rm: Function) {
-    /* istanbul ignore else */
-    if (vnode.data.show !== true) {
-      leave(vnode, rm)
-    } else {
-      rm()
+export default inBrowser
+  ? {
+      create: _enter,
+      activate: _enter,
+      remove(vnode: VNode, rm: Function) {
+        /* istanbul ignore else */
+        if (vnode.data!.show !== true) {
+          // @ts-expect-error
+          leave(vnode, rm)
+        } else {
+          rm()
+        }
+      },
     }
-  }
-} : {}
+  : {}
diff --git a/src/platforms/web/runtime/node-ops.js b/src/platforms/web/runtime/node-ops.js
deleted file mode 100644
index 3a2978a75dd..00000000000
--- a/src/platforms/web/runtime/node-ops.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/* @flow */
-
-import { namespaceMap } from 'web/util/index'
-
-export function createElement (tagName: string, vnode: VNode): Element {
-  const elm = document.createElement(tagName)
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple')
-  }
-  return elm
-}
-
-export function createElementNS (namespace: string, tagName: string): Element {
-  return document.createElementNS(namespaceMap[namespace], tagName)
-}
-
-export function createTextNode (text: string): Text {
-  return document.createTextNode(text)
-}
-
-export function createComment (text: string): Comment {
-  return document.createComment(text)
-}
-
-export function insertBefore (parentNode: Node, newNode: Node, referenceNode: Node) {
-  parentNode.insertBefore(newNode, referenceNode)
-}
-
-export function removeChild (node: Node, child: Node) {
-  node.removeChild(child)
-}
-
-export function appendChild (node: Node, child: Node) {
-  node.appendChild(child)
-}
-
-export function parentNode (node: Node): ?Node {
-  return node.parentNode
-}
-
-export function nextSibling (node: Node): ?Node {
-  return node.nextSibling
-}
-
-export function tagName (node: Element): string {
-  return node.tagName
-}
-
-export function setTextContent (node: Node, text: string) {
-  node.textContent = text
-}
-
-export function setStyleScope (node: Element, scopeId: string) {
-  node.setAttribute(scopeId, '')
-}
diff --git a/src/platforms/web/runtime/node-ops.ts b/src/platforms/web/runtime/node-ops.ts
new file mode 100644
index 00000000000..d90dc9c0474
--- /dev/null
+++ b/src/platforms/web/runtime/node-ops.ts
@@ -0,0 +1,68 @@
+/* @flow */
+
+import VNode from 'core/vdom/vnode'
+import { namespaceMap } from 'web/util/index'
+
+export function createElement(tagName: string, vnode: VNode): Element {
+  const elm = document.createElement(tagName)
+  if (tagName !== 'select') {
+    return elm
+  }
+  // false or null will remove the attribute but undefined will not
+  if (
+    vnode.data &&
+    vnode.data.attrs &&
+    vnode.data.attrs.multiple !== undefined
+  ) {
+    elm.setAttribute('multiple', 'multiple')
+  }
+  return elm
+}
+
+export function createElementNS(namespace: string, tagName: string): Element {
+  return document.createElementNS(namespaceMap[namespace], tagName)
+}
+
+export function createTextNode(text: string): Text {
+  return document.createTextNode(text)
+}
+
+export function createComment(text: string): Comment {
+  return document.createComment(text)
+}
+
+export function insertBefore(
+  parentNode: Node,
+  newNode: Node,
+  referenceNode: Node
+) {
+  parentNode.insertBefore(newNode, referenceNode)
+}
+
+export function removeChild(node: Node, child: Node) {
+  node.removeChild(child)
+}
+
+export function appendChild(node: Node, child: Node) {
+  node.appendChild(child)
+}
+
+export function parentNode(node: Node) {
+  return node.parentNode
+}
+
+export function nextSibling(node: Node) {
+  return node.nextSibling
+}
+
+export function tagName(node: Element): string {
+  return node.tagName
+}
+
+export function setTextContent(node: Node, text: string) {
+  node.textContent = text
+}
+
+export function setStyleScope(node: Element, scopeId: string) {
+  node.setAttribute(scopeId, '')
+}
diff --git a/src/platforms/web/runtime/patch.js b/src/platforms/web/runtime/patch.ts
similarity index 100%
rename from src/platforms/web/runtime/patch.js
rename to src/platforms/web/runtime/patch.ts
diff --git a/src/platforms/web/runtime/transition-util.js b/src/platforms/web/runtime/transition-util.ts
similarity index 62%
rename from src/platforms/web/runtime/transition-util.js
rename to src/platforms/web/runtime/transition-util.ts
index 0885f973f89..43211877420 100644
--- a/src/platforms/web/runtime/transition-util.js
+++ b/src/platforms/web/runtime/transition-util.ts
@@ -1,10 +1,10 @@
-/* @flow */
-
 import { inBrowser, isIE9 } from 'core/util/index'
 import { addClass, removeClass } from './class-util'
 import { remove, extend, cached } from 'shared/util'
 
-export function resolveTransition (def?: string | Object): ?Object {
+export function resolveTransition(
+  def?: string | Record<string, any>
+): Record<string, any> | undefined {
   if (!def) {
     return
   }
@@ -21,14 +21,14 @@ export function resolveTransition (def?: string | Object): ?Object {
   }
 }
 
-const autoCssTransition: (name: string) => Object = cached(name => {
+const autoCssTransition: (name: string) => Object = cached((name) => {
   return {
     enterClass: `${name}-enter`,
     enterToClass: `${name}-enter-to`,
     enterActiveClass: `${name}-enter-active`,
     leaveClass: `${name}-leave`,
     leaveToClass: `${name}-leave-to`,
-    leaveActiveClass: `${name}-leave-active`
+    leaveActiveClass: `${name}-leave-active`,
   }
 })
 
@@ -43,13 +43,17 @@ export let animationProp = 'animation'
 export let animationEndEvent = 'animationend'
 if (hasTransition) {
   /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
+  if (
+    window.ontransitionend === undefined &&
+    // @ts-expect-error
     window.onwebkittransitionend !== undefined
   ) {
     transitionProp = 'WebkitTransition'
     transitionEndEvent = 'webkitTransitionEnd'
   }
-  if (window.onanimationend === undefined &&
+  if (
+    window.onanimationend === undefined &&
+    // @ts-expect-error
     window.onwebkitanimationend !== undefined
   ) {
     animationProp = 'WebkitAnimation'
@@ -62,43 +66,46 @@ const raf = inBrowser
   ? window.requestAnimationFrame
     ? window.requestAnimationFrame.bind(window)
     : setTimeout
-  : /* istanbul ignore next */ fn => fn()
+  : /* istanbul ignore next */ (fn) => fn()
 
-export function nextFrame (fn: Function) {
+export function nextFrame(fn: Function) {
   raf(() => {
+    // @ts-expect-error
     raf(fn)
   })
 }
 
-export function addTransitionClass (el: any, cls: string) {
-  const transitionClasses = el._transitionClasses || (el._transitionClasses = [])
+export function addTransitionClass(el: any, cls: string) {
+  const transitionClasses =
+    el._transitionClasses || (el._transitionClasses = [])
   if (transitionClasses.indexOf(cls) < 0) {
     transitionClasses.push(cls)
     addClass(el, cls)
   }
 }
 
-export function removeTransitionClass (el: any, cls: string) {
+export function removeTransitionClass(el: any, cls: string) {
   if (el._transitionClasses) {
     remove(el._transitionClasses, cls)
   }
   removeClass(el, cls)
 }
 
-export function whenTransitionEnds (
+export function whenTransitionEnds(
   el: Element,
-  expectedType: ?string,
+  expectedType: string | undefined,
   cb: Function
 ) {
   const { type, timeout, propCount } = getTransitionInfo(el, expectedType)
   if (!type) return cb()
-  const event: string = type === TRANSITION ? transitionEndEvent : animationEndEvent
+  const event: string =
+    type === TRANSITION ? transitionEndEvent : animationEndEvent
   let ended = 0
   const end = () => {
     el.removeEventListener(event, onEnd)
     cb()
   }
-  const onEnd = e => {
+  const onEnd = (e) => {
     if (e.target === el) {
       if (++ended >= propCount) {
         end()
@@ -115,22 +122,39 @@ export function whenTransitionEnds (
 
 const transformRE = /\b(transform|all)(,|$)/
 
-export function getTransitionInfo (el: Element, expectedType?: ?string): {
-  type: ?string;
-  propCount: number;
-  timeout: number;
-  hasTransform: boolean;
+export function getTransitionInfo(
+  el: Element,
+  expectedType?: string
+): {
+  type?: string | null
+  propCount: number
+  timeout: number
+  hasTransform: boolean
 } {
   const styles: any = window.getComputedStyle(el)
   // JSDOM may return undefined for transition properties
-  const transitionDelays: Array<string> = (styles[transitionProp + 'Delay'] || '').split(', ')
-  const transitionDurations: Array<string> = (styles[transitionProp + 'Duration'] || '').split(', ')
-  const transitionTimeout: number = getTimeout(transitionDelays, transitionDurations)
-  const animationDelays: Array<string> = (styles[animationProp + 'Delay'] || '').split(', ')
-  const animationDurations: Array<string> = (styles[animationProp + 'Duration'] || '').split(', ')
-  const animationTimeout: number = getTimeout(animationDelays, animationDurations)
-
-  let type: ?string
+  const transitionDelays: Array<string> = (
+    styles[transitionProp + 'Delay'] || ''
+  ).split(', ')
+  const transitionDurations: Array<string> = (
+    styles[transitionProp + 'Duration'] || ''
+  ).split(', ')
+  const transitionTimeout: number = getTimeout(
+    transitionDelays,
+    transitionDurations
+  )
+  const animationDelays: Array<string> = (
+    styles[animationProp + 'Delay'] || ''
+  ).split(', ')
+  const animationDurations: Array<string> = (
+    styles[animationProp + 'Duration'] || ''
+  ).split(', ')
+  const animationTimeout: number = getTimeout(
+    animationDelays,
+    animationDurations
+  )
+
+  let type: string | undefined | null
   let timeout = 0
   let propCount = 0
   /* istanbul ignore if */
@@ -148,11 +172,12 @@ export function getTransitionInfo (el: Element, expectedType?: ?string): {
     }
   } else {
     timeout = Math.max(transitionTimeout, animationTimeout)
-    type = timeout > 0
-      ? transitionTimeout > animationTimeout
-        ? TRANSITION
-        : ANIMATION
-      : null
+    type =
+      timeout > 0
+        ? transitionTimeout > animationTimeout
+          ? TRANSITION
+          : ANIMATION
+        : null
     propCount = type
       ? type === TRANSITION
         ? transitionDurations.length
@@ -160,31 +185,33 @@ export function getTransitionInfo (el: Element, expectedType?: ?string): {
       : 0
   }
   const hasTransform: boolean =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property'])
+    type === TRANSITION && transformRE.test(styles[transitionProp + 'Property'])
   return {
     type,
     timeout,
     propCount,
-    hasTransform
+    hasTransform,
   }
 }
 
-function getTimeout (delays: Array<string>, durations: Array<string>): number {
+function getTimeout(delays: Array<string>, durations: Array<string>): number {
   /* istanbul ignore next */
   while (delays.length < durations.length) {
     delays = delays.concat(delays)
   }
 
-  return Math.max.apply(null, durations.map((d, i) => {
-    return toMs(d) + toMs(delays[i])
-  }))
+  return Math.max.apply(
+    null,
+    durations.map((d, i) => {
+      return toMs(d) + toMs(delays[i])
+    })
+  )
 }
 
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs (s: string): number {
+function toMs(s: string): number {
   return Number(s.slice(0, -1).replace(',', '.')) * 1000
 }
diff --git a/src/platforms/web/server/compiler.js b/src/platforms/web/server/compiler.ts
similarity index 70%
rename from src/platforms/web/server/compiler.js
rename to src/platforms/web/server/compiler.ts
index 20e57367708..c442633fc80 100644
--- a/src/platforms/web/server/compiler.js
+++ b/src/platforms/web/server/compiler.ts
@@ -5,7 +5,4 @@ import { createCompiler } from 'server/optimizing-compiler/index'
 
 const { compile, compileToFunctions } = createCompiler(baseOptions)
 
-export {
-  compile as ssrCompile,
-  compileToFunctions as ssrCompileToFunctions
-}
+export { compile as ssrCompile, compileToFunctions as ssrCompileToFunctions }
diff --git a/src/platforms/web/server/directives/index.js b/src/platforms/web/server/directives/index.ts
similarity index 90%
rename from src/platforms/web/server/directives/index.js
rename to src/platforms/web/server/directives/index.ts
index fd7fce0a34c..7d999b92556 100644
--- a/src/platforms/web/server/directives/index.js
+++ b/src/platforms/web/server/directives/index.ts
@@ -3,5 +3,5 @@ import model from './model'
 
 export default {
   show,
-  model
+  model,
 }
diff --git a/src/platforms/web/server/directives/model.js b/src/platforms/web/server/directives/model.ts
similarity index 82%
rename from src/platforms/web/server/directives/model.js
rename to src/platforms/web/server/directives/model.ts
index 7962d6c8ac1..705e502f7a4 100644
--- a/src/platforms/web/server/directives/model.js
+++ b/src/platforms/web/server/directives/model.ts
@@ -4,7 +4,7 @@ import { looseEqual, looseIndexOf } from 'shared/util'
 
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
-export default function model (node: VNodeWithData, dir: VNodeDirective) {
+export default function model(node: VNodeWithData, dir: VNodeDirective) {
   if (!node.children) return
   const value = dir.value
   const isMultiple = node.data.attrs && node.data.attrs.multiple
@@ -13,8 +13,7 @@ export default function model (node: VNodeWithData, dir: VNodeDirective) {
     if (option.tag === 'option') {
       if (isMultiple) {
         const selected =
-          Array.isArray(value) &&
-          (looseIndexOf(value, getValue(option)) > -1)
+          Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1
         if (selected) {
           setSelected(option)
         }
@@ -28,7 +27,7 @@ export default function model (node: VNodeWithData, dir: VNodeDirective) {
   }
 }
 
-function getValue (option) {
+function getValue(option) {
   const data = option.data || {}
   return (
     (data.attrs && data.attrs.value) ||
@@ -37,7 +36,7 @@ function getValue (option) {
   )
 }
 
-function setSelected (option) {
+function setSelected(option) {
   const data = option.data || (option.data = {})
   const attrs = data.attrs || (data.attrs = {})
   attrs.selected = ''
diff --git a/src/platforms/web/server/directives/show.js b/src/platforms/web/server/directives/show.ts
similarity index 61%
rename from src/platforms/web/server/directives/show.js
rename to src/platforms/web/server/directives/show.ts
index 7493b27e087..5676348342e 100644
--- a/src/platforms/web/server/directives/show.js
+++ b/src/platforms/web/server/directives/show.ts
@@ -1,6 +1,8 @@
 /* @flow */
 
-export default function show (node: VNodeWithData, dir: VNodeDirective) {
+import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+
+export default function show(node: VNodeWithData, dir: VNodeDirective) {
   if (!dir.value) {
     const style: any = node.data.style || (node.data.style = {})
     if (Array.isArray(style)) {
diff --git a/src/platforms/web/server/modules/attrs.js b/src/platforms/web/server/modules/attrs.ts
similarity index 78%
rename from src/platforms/web/server/modules/attrs.js
rename to src/platforms/web/server/modules/attrs.ts
index e575d13ae30..ead95fe63a4 100644
--- a/src/platforms/web/server/modules/attrs.js
+++ b/src/platforms/web/server/modules/attrs.ts
@@ -2,22 +2,18 @@
 
 import { escape } from '../util'
 
-import {
-  isDef,
-  isUndef,
-  extend
-} from 'shared/util'
+import { isDef, isUndef, extend } from 'shared/util'
 
 import {
   isBooleanAttr,
   isEnumeratedAttr,
   isFalsyAttrValue,
-  convertEnumeratedValue
+  convertEnumeratedValue,
 } from 'web/util/attrs'
 
 import { isSSRUnsafeAttr } from 'web/server/util'
 
-export default function renderAttrs (node: VNodeWithData): string {
+export default function renderAttrs(node: VNodeWithData): string {
   let attrs = node.data.attrs
   let res = ''
 
@@ -26,8 +22,11 @@ export default function renderAttrs (node: VNodeWithData): string {
     let parent = node.parent
     while (isDef(parent)) {
       // Stop fallthrough in case parent has inheritAttrs option set to false
-      if (parent.componentOptions && parent.componentOptions.Ctor.options.inheritAttrs === false) {
-        break;
+      if (
+        parent.componentOptions &&
+        parent.componentOptions.Ctor.options.inheritAttrs === false
+      ) {
+        break
       }
       if (isDef(parent.data) && isDef(parent.data.attrs)) {
         attrs = extend(extend({}, attrs), parent.data.attrs)
@@ -53,7 +52,7 @@ export default function renderAttrs (node: VNodeWithData): string {
   return res
 }
 
-export function renderAttr (key: string, value: string): string {
+export function renderAttr(key: string, value: string): string {
   if (isBooleanAttr(key)) {
     if (!isFalsyAttrValue(value)) {
       return ` ${key}="${key}"`
diff --git a/src/platforms/web/server/modules/class.js b/src/platforms/web/server/modules/class.ts
similarity index 62%
rename from src/platforms/web/server/modules/class.js
rename to src/platforms/web/server/modules/class.ts
index c19040ed9f4..7dc5d39fa05 100644
--- a/src/platforms/web/server/modules/class.js
+++ b/src/platforms/web/server/modules/class.ts
@@ -2,8 +2,9 @@
 
 import { escape } from '../util'
 import { genClassForVnode } from 'web/util/index'
+import { VNodeWithData } from 'typescript/vnode'
 
-export default function renderClass (node: VNodeWithData): ?string {
+export default function renderClass(node: VNodeWithData): string | undefined {
   const classList = genClassForVnode(node)
   if (classList !== '') {
     return ` class="${escape(classList)}"`
diff --git a/src/platforms/web/server/modules/dom-props.js b/src/platforms/web/server/modules/dom-props.ts
similarity index 89%
rename from src/platforms/web/server/modules/dom-props.js
rename to src/platforms/web/server/modules/dom-props.ts
index 6d92badcb85..f165245cfaf 100644
--- a/src/platforms/web/server/modules/dom-props.js
+++ b/src/platforms/web/server/modules/dom-props.ts
@@ -5,7 +5,7 @@ import { renderAttr } from './attrs'
 import { isDef, isUndef, extend, toString } from 'shared/util'
 import { propsToAttrMap, isRenderableAttr } from '../util'
 
-export default function renderDOMProps (node: VNodeWithData): string {
+export default function renderDOMProps(node: VNodeWithData): string {
   let props = node.data.domProps
   let res = ''
 
@@ -32,7 +32,8 @@ export default function renderDOMProps (node: VNodeWithData): string {
     } else {
       // $flow-disable-line (WTF?)
       const attr = propsToAttrMap[key] || key.toLowerCase()
-      if (isRenderableAttr(attr) &&
+      if (
+        isRenderableAttr(attr) &&
         // avoid rendering double-bound props/attrs twice
         !(isDef(attrs) && isDef(attrs[attr]))
       ) {
@@ -43,7 +44,7 @@ export default function renderDOMProps (node: VNodeWithData): string {
   return res
 }
 
-function setText (node, text, raw) {
+function setText(node, text, raw) {
   const child = new VNode(undefined, undefined, undefined, text)
   child.raw = raw
   node.children = [child]
diff --git a/src/platforms/web/server/modules/index.js b/src/platforms/web/server/modules/index.ts
similarity index 67%
rename from src/platforms/web/server/modules/index.js
rename to src/platforms/web/server/modules/index.ts
index 3d15bc509e7..40dd926ff19 100644
--- a/src/platforms/web/server/modules/index.js
+++ b/src/platforms/web/server/modules/index.ts
@@ -3,9 +3,4 @@ import domProps from './dom-props'
 import klass from './class'
 import style from './style'
 
-export default [
-  attrs,
-  domProps,
-  klass,
-  style
-]
+export default [attrs, domProps, klass, style]
diff --git a/src/platforms/web/server/modules/style.js b/src/platforms/web/server/modules/style.ts
similarity index 84%
rename from src/platforms/web/server/modules/style.js
rename to src/platforms/web/server/modules/style.ts
index 4c7c2bbbadc..5e7bbbd6694 100644
--- a/src/platforms/web/server/modules/style.js
+++ b/src/platforms/web/server/modules/style.ts
@@ -3,8 +3,9 @@
 import { escape, noUnitNumericStyleProps } from '../util'
 import { hyphenate } from 'shared/util'
 import { getStyle } from 'web/util/style'
+import { VNodeWithData } from 'typescript/vnode'
 
-export function genStyle (style: Object): string {
+export function genStyle(style: Object): string {
   let styleText = ''
   for (const key in style) {
     const value = style[key]
@@ -33,7 +34,7 @@ function normalizeValue(key: string, value: any): string {
   }
 }
 
-export default function renderStyle (vnode: VNodeWithData): ?string {
+export default function renderStyle(vnode: VNodeWithData): string | undefined {
   const styleText = genStyle(getStyle(vnode, false))
   if (styleText !== '') {
     return ` style=${JSON.stringify(escape(styleText))}`
diff --git a/src/platforms/web/server/util.js b/src/platforms/web/server/util.js
deleted file mode 100644
index 9960ec40260..00000000000
--- a/src/platforms/web/server/util.js
+++ /dev/null
@@ -1,101 +0,0 @@
-/* @flow */
-
-import { makeMap } from 'shared/util'
-
-const isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-  'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-  'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-  'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-  'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-  'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-  'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-  'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-  'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-  'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-  'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-  'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-  'target,title,usemap,value,width,wrap'
-)
-
-const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/ // eslint-disable-line no-control-regex
-export const isSSRUnsafeAttr = (name: string): boolean => {
-  return unsafeAttrCharRE.test(name)
-}
-
-/* istanbul ignore next */
-const isRenderableAttr = (name: string): boolean => {
-  return (
-    isAttr(name) ||
-    name.indexOf('data-') === 0 ||
-    name.indexOf('aria-') === 0
-  )
-}
-export { isRenderableAttr }
-
-export const propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
-}
-
-const ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
-}
-
-export function escape (s: string) {
-  return s.replace(/[<>"&]/g, escapeChar)
-}
-
-function escapeChar (a) {
-  return ESC[a] || a
-}
-
-export const noUnitNumericStyleProps = {
-  "animation-iteration-count": true,
-  "border-image-outset": true,
-  "border-image-slice": true,
-  "border-image-width": true,
-  "box-flex": true,
-  "box-flex-group": true,
-  "box-ordinal-group": true,
-  "column-count": true,
-  "columns": true,
-  "flex": true,
-  "flex-grow": true,
-  "flex-positive": true,
-  "flex-shrink": true,
-  "flex-negative": true,
-  "flex-order": true,
-  "grid-row": true,
-  "grid-row-end": true,
-  "grid-row-span": true,
-  "grid-row-start": true,
-  "grid-column": true,
-  "grid-column-end": true,
-  "grid-column-span": true,
-  "grid-column-start": true,
-  "font-weight": true,
-  "line-clamp": true,
-  "line-height": true,
-  "opacity": true,
-  "order": true,
-  "orphans": true,
-  "tab-size": true,
-  "widows": true,
-  "z-index": true,
-  "zoom": true,
-  // SVG
-  "fill-opacity": true,
-  "flood-opacity": true,
-  "stop-opacity": true,
-  "stroke-dasharray": true,
-  "stroke-dashoffset": true,
-  "stroke-miterlimit": true,
-  "stroke-opacity": true,
-  "stroke-width": true
-}
diff --git a/src/platforms/web/server/util.ts b/src/platforms/web/server/util.ts
new file mode 100644
index 00000000000..2538f1fa0da
--- /dev/null
+++ b/src/platforms/web/server/util.ts
@@ -0,0 +1,99 @@
+/* @flow */
+
+import { makeMap } from 'shared/util'
+
+const isAttr = makeMap(
+  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap'
+)
+
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/ // eslint-disable-line no-control-regex
+export const isSSRUnsafeAttr = (name: string): boolean => {
+  return unsafeAttrCharRE.test(name)
+}
+
+/* istanbul ignore next */
+const isRenderableAttr = (name: string): boolean => {
+  return (
+    isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
+  )
+}
+export { isRenderableAttr }
+
+export const propsToAttrMap = {
+  acceptCharset: 'accept-charset',
+  className: 'class',
+  htmlFor: 'for',
+  httpEquiv: 'http-equiv',
+}
+
+const ESC = {
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  '&': '&amp;',
+}
+
+export function escape(s: string) {
+  return s.replace(/[<>"&]/g, escapeChar)
+}
+
+function escapeChar(a) {
+  return ESC[a] || a
+}
+
+export const noUnitNumericStyleProps = {
+  'animation-iteration-count': true,
+  'border-image-outset': true,
+  'border-image-slice': true,
+  'border-image-width': true,
+  'box-flex': true,
+  'box-flex-group': true,
+  'box-ordinal-group': true,
+  'column-count': true,
+  columns: true,
+  flex: true,
+  'flex-grow': true,
+  'flex-positive': true,
+  'flex-shrink': true,
+  'flex-negative': true,
+  'flex-order': true,
+  'grid-row': true,
+  'grid-row-end': true,
+  'grid-row-span': true,
+  'grid-row-start': true,
+  'grid-column': true,
+  'grid-column-end': true,
+  'grid-column-span': true,
+  'grid-column-start': true,
+  'font-weight': true,
+  'line-clamp': true,
+  'line-height': true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  'tab-size': true,
+  widows: true,
+  'z-index': true,
+  zoom: true,
+  // SVG
+  'fill-opacity': true,
+  'flood-opacity': true,
+  'stop-opacity': true,
+  'stroke-dasharray': true,
+  'stroke-dashoffset': true,
+  'stroke-miterlimit': true,
+  'stroke-opacity': true,
+  'stroke-width': true,
+}
diff --git a/src/platforms/web/util/attrs.js b/src/platforms/web/util/attrs.ts
similarity index 62%
rename from src/platforms/web/util/attrs.js
rename to src/platforms/web/util/attrs.ts
index 212a99d7296..cfde37699f1 100644
--- a/src/platforms/web/util/attrs.js
+++ b/src/platforms/web/util/attrs.ts
@@ -8,9 +8,13 @@ export const isReservedAttr = makeMap('style,class')
 
 // attributes that should be using props for binding
 const acceptValue = makeMap('input,textarea,option,select,progress')
-export const mustUseProp = (tag: string, type: ?string, attr: string): boolean => {
+export const mustUseProp = (
+  tag: string,
+  type: string | null,
+  attr: string
+): boolean => {
   return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
+    (attr === 'value' && acceptValue(tag) && type !== 'button') ||
     (attr === 'selected' && tag === 'option') ||
     (attr === 'checked' && tag === 'input') ||
     (attr === 'muted' && tag === 'video')
@@ -19,24 +23,26 @@ export const mustUseProp = (tag: string, type: ?string, attr: string): boolean =
 
 export const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
 
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only')
+const isValidContentEditableValue = makeMap(
+  'events,caret,typing,plaintext-only'
+)
 
 export const convertEnumeratedValue = (key: string, value: any) => {
   return isFalsyAttrValue(value) || value === 'false'
     ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    : // allow arbitrary string value for contenteditable
+    key === 'contenteditable' && isValidContentEditableValue(value)
+    ? value
+    : 'true'
 }
 
 export const isBooleanAttr = makeMap(
   'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,' +
-  'truespeed,typemustmatch,visible'
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible'
 )
 
 export const xlinkNS = 'http://www.w3.org/1999/xlink'
diff --git a/src/platforms/web/util/class.js b/src/platforms/web/util/class.ts
similarity index 53%
rename from src/platforms/web/util/class.js
rename to src/platforms/web/util/class.ts
index 542dcbc4698..2f42a993990 100644
--- a/src/platforms/web/util/class.js
+++ b/src/platforms/web/util/class.ts
@@ -1,39 +1,42 @@
 /* @flow */
 
+import VNode from 'core/vdom/vnode'
 import { isDef, isObject } from 'shared/util'
+import { VNodeData, VNodeWithData } from 'typescript/vnode'
 
-export function genClassForVnode (vnode: VNodeWithData): string {
+export function genClassForVnode(vnode: VNodeWithData): string {
   let data = vnode.data
-  let parentNode = vnode
-  let childNode = vnode
+  let parentNode: VNode | VNodeWithData | undefined = vnode
+  let childNode: VNode | VNodeWithData = vnode
   while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode
+    childNode = childNode.componentInstance._vnode!
     if (childNode && childNode.data) {
       data = mergeClassData(childNode.data, data)
     }
   }
-  while (isDef(parentNode = parentNode.parent)) {
+  while (isDef((parentNode = parentNode.parent))) {
     if (parentNode && parentNode.data) {
       data = mergeClassData(data, parentNode.data)
     }
   }
-  return renderClass(data.staticClass, data.class)
+  return renderClass(data.staticClass!, data.class)
 }
 
-function mergeClassData (child: VNodeData, parent: VNodeData): {
-  staticClass: string,
+function mergeClassData(
+  child: VNodeData,
+  parent: VNodeData
+): {
+  staticClass: string
   class: any
 } {
   return {
     staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
+    class: isDef(child.class) ? [child.class, parent.class] : parent.class,
   }
 }
 
-export function renderClass (
-  staticClass: ?string,
+export function renderClass(
+  staticClass: string | null | undefined,
   dynamicClass: any
 ): string {
   if (isDef(staticClass) || isDef(dynamicClass)) {
@@ -43,11 +46,11 @@ export function renderClass (
   return ''
 }
 
-export function concat (a: ?string, b: ?string): string {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+export function concat(a?: string | null, b?: string | null): string {
+  return a ? (b ? a + ' ' + b : a) : b || ''
 }
 
-export function stringifyClass (value: any): string {
+export function stringifyClass(value: any): string {
   if (Array.isArray(value)) {
     return stringifyArray(value)
   }
@@ -61,11 +64,11 @@ export function stringifyClass (value: any): string {
   return ''
 }
 
-function stringifyArray (value: Array<any>): string {
+function stringifyArray(value: Array<any>): string {
   let res = ''
   let stringified
   for (let i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
+    if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
       if (res) res += ' '
       res += stringified
     }
@@ -73,7 +76,7 @@ function stringifyArray (value: Array<any>): string {
   return res
 }
 
-function stringifyObject (value: Object): string {
+function stringifyObject(value: Object): string {
   let res = ''
   for (const key in value) {
     if (value[key]) {
diff --git a/src/platforms/web/util/compat.js b/src/platforms/web/util/compat.ts
similarity index 77%
rename from src/platforms/web/util/compat.js
rename to src/platforms/web/util/compat.ts
index d95759cce31..48763c47a18 100644
--- a/src/platforms/web/util/compat.js
+++ b/src/platforms/web/util/compat.ts
@@ -4,7 +4,7 @@ import { inBrowser } from 'core/util/index'
 
 // check whether current browser encodes a char inside attribute values
 let div
-function getShouldDecode (href: boolean): boolean {
+function getShouldDecode(href: boolean): boolean {
   div = div || document.createElement('div')
   div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`
   return div.innerHTML.indexOf('&#10;') > 0
@@ -13,4 +13,6 @@ function getShouldDecode (href: boolean): boolean {
 // #3663: IE encodes newlines inside attribute values while other browsers don't
 export const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false
 // #6828: chrome encodes content in a[href]
-export const shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false
+export const shouldDecodeNewlinesForHref = inBrowser
+  ? getShouldDecode(true)
+  : false
diff --git a/src/platforms/web/util/element.js b/src/platforms/web/util/element.js
deleted file mode 100644
index d6a03f49aa5..00000000000
--- a/src/platforms/web/util/element.js
+++ /dev/null
@@ -1,77 +0,0 @@
-/* @flow */
-
-import { inBrowser } from 'core/util/env'
-import { makeMap } from 'shared/util'
-
-export const namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
-}
-
-export const isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-)
-
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-export const isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-)
-
-export const isPreTag = (tag: ?string): boolean => tag === 'pre'
-
-export const isReservedTag = (tag: string): ?boolean => {
-  return isHTMLTag(tag) || isSVG(tag)
-}
-
-export function getTagNamespace (tag: string): ?string {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
-}
-
-const unknownElementCache = Object.create(null)
-export function isUnknownElement (tag: string): boolean {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase()
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  const el = document.createElement(tag)
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
-}
-
-export const isTextInputType = makeMap('text,number,password,search,email,tel,url')
diff --git a/src/platforms/web/util/element.ts b/src/platforms/web/util/element.ts
new file mode 100644
index 00000000000..8c18153ba23
--- /dev/null
+++ b/src/platforms/web/util/element.ts
@@ -0,0 +1,78 @@
+/* @flow */
+
+import { inBrowser } from 'core/util/env'
+import { makeMap } from 'shared/util'
+
+export const namespaceMap = {
+  svg: 'http://www.w3.org/2000/svg',
+  math: 'http://www.w3.org/1998/Math/MathML',
+}
+
+export const isHTMLTag = makeMap(
+  'html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot'
+)
+
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+export const isSVG = makeMap(
+  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
+  true
+)
+
+export const isPreTag = (tag?: string): boolean => tag === 'pre'
+
+export const isReservedTag = (tag: string): boolean | undefined => {
+  return isHTMLTag(tag) || isSVG(tag)
+}
+
+export function getTagNamespace(tag: string): string | undefined {
+  if (isSVG(tag)) {
+    return 'svg'
+  }
+  // basic support for MathML
+  // note it doesn't support other MathML elements being component roots
+  if (tag === 'math') {
+    return 'math'
+  }
+}
+
+const unknownElementCache = Object.create(null)
+export function isUnknownElement(tag: string): boolean {
+  /* istanbul ignore if */
+  if (!inBrowser) {
+    return true
+  }
+  if (isReservedTag(tag)) {
+    return false
+  }
+  tag = tag.toLowerCase()
+  /* istanbul ignore if */
+  if (unknownElementCache[tag] != null) {
+    return unknownElementCache[tag]
+  }
+  const el = document.createElement(tag)
+  if (tag.indexOf('-') > -1) {
+    // http://stackoverflow.com/a/28210364/1070244
+    return (unknownElementCache[tag] =
+      el.constructor === window.HTMLUnknownElement ||
+      el.constructor === window.HTMLElement)
+  } else {
+    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
+  }
+}
+
+export const isTextInputType = makeMap(
+  'text,number,password,search,email,tel,url'
+)
diff --git a/src/platforms/web/util/index.js b/src/platforms/web/util/index.ts
similarity index 72%
rename from src/platforms/web/util/index.js
rename to src/platforms/web/util/index.ts
index da5e46ed2ff..10c6d78019b 100644
--- a/src/platforms/web/util/index.js
+++ b/src/platforms/web/util/index.ts
@@ -9,13 +9,12 @@ export * from './element'
 /**
  * Query an element selector if it's not an element already.
  */
-export function query (el: string | Element): Element {
+export function query(el: string | Element): Element {
   if (typeof el === 'string') {
     const selected = document.querySelector(el)
     if (!selected) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'Cannot find element: ' + el
-      )
+      process.env.NODE_ENV !== 'production' &&
+        warn('Cannot find element: ' + el)
       return document.createElement('div')
     }
     return selected
diff --git a/src/platforms/web/util/style.js b/src/platforms/web/util/style.ts
similarity index 71%
rename from src/platforms/web/util/style.js
rename to src/platforms/web/util/style.ts
index 46e69e4e28f..b90c47650bf 100644
--- a/src/platforms/web/util/style.js
+++ b/src/platforms/web/util/style.ts
@@ -1,6 +1,8 @@
 /* @flow */
 
+import VNode from 'core/vdom/vnode'
 import { cached, extend, toObject } from 'shared/util'
+import { VNodeData, VNodeWithData } from 'typescript/vnode'
 
 export const parseStyleText = cached(function (cssText) {
   const res = {}
@@ -16,17 +18,15 @@ export const parseStyleText = cached(function (cssText) {
 })
 
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data: VNodeData): ?Object {
+function normalizeStyleData(data: VNodeData): Record<string, any> {
   const style = normalizeStyleBinding(data.style)
   // static style is pre-processed into an object during compilation
   // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+  return data.staticStyle ? extend(data.staticStyle, style) : style
 }
 
 // normalize possible array / string values into Object
-export function normalizeStyleBinding (bindingStyle: any): ?Object {
+export function normalizeStyleBinding(bindingStyle: any): Record<string, any> {
   if (Array.isArray(bindingStyle)) {
     return toObject(bindingStyle)
   }
@@ -40,16 +40,17 @@ export function normalizeStyleBinding (bindingStyle: any): ?Object {
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-export function getStyle (vnode: VNodeWithData, checkChild: boolean): Object {
+export function getStyle(vnode: VNodeWithData, checkChild: boolean): Object {
   const res = {}
   let styleData
 
   if (checkChild) {
-    let childNode = vnode
+    let childNode: VNodeWithData | VNode = vnode
     while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode
+      childNode = childNode.componentInstance._vnode!
       if (
-        childNode && childNode.data &&
+        childNode &&
+        childNode.data &&
         (styleData = normalizeStyleData(childNode.data))
       ) {
         extend(res, styleData)
@@ -61,7 +62,7 @@ export function getStyle (vnode: VNodeWithData, checkChild: boolean): Object {
     extend(res, styleData)
   }
 
-  let parentNode = vnode
+  let parentNode: VNodeWithData | VNode | undefined = vnode
   while ((parentNode = parentNode.parent)) {
     if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
       extend(res, styleData)
diff --git a/src/platforms/weex/compiler/directives/index.js b/src/platforms/weex/compiler/directives/index.ts
old mode 100755
new mode 100644
similarity index 84%
rename from src/platforms/weex/compiler/directives/index.js
rename to src/platforms/weex/compiler/directives/index.ts
index 12ced224ab7..8242af3a02a
--- a/src/platforms/weex/compiler/directives/index.js
+++ b/src/platforms/weex/compiler/directives/index.ts
@@ -1,5 +1,5 @@
 import model from './model'
 
 export default {
-  model
+  model,
 }
diff --git a/src/platforms/weex/compiler/directives/model.js b/src/platforms/weex/compiler/directives/model.ts
similarity index 82%
rename from src/platforms/weex/compiler/directives/model.js
rename to src/platforms/weex/compiler/directives/model.ts
index 6961802d093..f54df16bb01 100644
--- a/src/platforms/weex/compiler/directives/model.js
+++ b/src/platforms/weex/compiler/directives/model.ts
@@ -3,10 +3,7 @@
 import { addHandler, addAttr } from 'compiler/helpers'
 import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
 
-export default function model (
-  el: ASTElement,
-  dir: ASTDirective
-): ?boolean {
+export default function model(el: ASTElement, dir: ASTDirective): void {
   if (el.tag === 'input' || el.tag === 'textarea') {
     genDefaultModel(el, dir.value, dir.modifiers)
   } else {
@@ -14,11 +11,11 @@ export default function model (
   }
 }
 
-function genDefaultModel (
+function genDefaultModel(
   el: ASTElement,
   value: string,
-  modifiers: ?ASTModifiers
-): ?boolean {
+  modifiers: ASTModifiers | null
+) {
   const { lazy, trim, number } = modifiers || {}
   const event = lazy ? 'change' : 'input'
 
diff --git a/src/platforms/weex/compiler/index.js b/src/platforms/weex/compiler/index.ts
similarity index 86%
rename from src/platforms/weex/compiler/index.js
rename to src/platforms/weex/compiler/index.ts
index 94f350b825d..4b7ec5bc811 100644
--- a/src/platforms/weex/compiler/index.js
+++ b/src/platforms/weex/compiler/index.ts
@@ -11,8 +11,9 @@ import {
   mustUseProp,
   isReservedTag,
   canBeLeftOpenTag,
-  getTagNamespace
+  getTagNamespace,
 } from '../util/element'
+import { WeexCompiledResult, WeexCompilerOptions } from 'typescript/weex'
 
 export const baseOptions: WeexCompilerOptions = {
   modules,
@@ -24,12 +25,13 @@ export const baseOptions: WeexCompilerOptions = {
   getTagNamespace,
   preserveWhitespace: false,
   recyclable: false,
-  staticKeys: genStaticKeys(modules)
-}
+  // @ts-ignore
+  staticKeys: genStaticKeys(modules),
+} as any
 
 const compiler = createCompiler(baseOptions)
 
-export function compile (
+export function compile(
   template: string,
   options?: WeexCompilerOptions
 ): WeexCompiledResult {
diff --git a/src/platforms/weex/compiler/modules/append.js b/src/platforms/weex/compiler/modules/append.ts
similarity index 72%
rename from src/platforms/weex/compiler/modules/append.js
rename to src/platforms/weex/compiler/modules/append.ts
index b2c98173b46..2e916faa295 100644
--- a/src/platforms/weex/compiler/modules/append.js
+++ b/src/platforms/weex/compiler/modules/append.ts
@@ -6,8 +6,11 @@ import { makeMap } from 'shared/util'
 // must be sent to the native together.
 const isUnitaryTag = makeMap('cell,header,cell-slot,recycle-list', true)
 
-function preTransformNode (el: ASTElement) {
-  if (isUnitaryTag(el.tag) && !el.attrsList.some(item => item.name === 'append')) {
+function preTransformNode(el: ASTElement) {
+  if (
+    isUnitaryTag(el.tag) &&
+    !el.attrsList.some((item) => item.name === 'append')
+  ) {
     el.attrsMap.append = 'tree'
     el.attrsList.push({ name: 'append', value: 'tree' })
   }
@@ -16,12 +19,12 @@ function preTransformNode (el: ASTElement) {
   }
 }
 
-function genData (el: ASTElement): string {
+function genData(el: ASTElement): string {
   return el.appendAsTree ? `appendAsTree:true,` : ''
 }
 
 export default {
   staticKeys: ['appendAsTree'],
   preTransformNode,
-  genData
+  genData,
 }
diff --git a/src/platforms/weex/compiler/modules/class.js b/src/platforms/weex/compiler/modules/class.ts
similarity index 63%
rename from src/platforms/weex/compiler/modules/class.js
rename to src/platforms/weex/compiler/modules/class.ts
index 05a0182f594..5d3f493b18c 100644
--- a/src/platforms/weex/compiler/modules/class.js
+++ b/src/platforms/weex/compiler/modules/class.ts
@@ -1,26 +1,22 @@
 /* @flow */
 
 import { parseText } from 'compiler/parser/text-parser'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
+import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 
 type StaticClassResult = {
-  dynamic: boolean,
+  dynamic: boolean
   classResult: string
-};
+}
 
-function transformNode (el: ASTElement, options: CompilerOptions) {
+function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
   const staticClass = getAndRemoveAttr(el, 'class')
   const { dynamic, classResult } = parseStaticClass(staticClass, options)
   if (process.env.NODE_ENV !== 'production' && dynamic && staticClass) {
     warn(
       `class="${staticClass}": ` +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
+        'Interpolation inside attributes has been deprecated. ' +
+        'Use v-bind or the colon shorthand instead.',
       el.rawAttrsMap['class']
     )
   }
@@ -35,7 +31,7 @@ function transformNode (el: ASTElement, options: CompilerOptions) {
   }
 }
 
-function genData (el: ASTElement): string {
+function genData(el: ASTElement): string {
   let data = ''
   if (el.staticClass) {
     data += `staticClass:${el.staticClass},`
@@ -46,20 +42,26 @@ function genData (el: ASTElement): string {
   return data
 }
 
-function parseStaticClass (staticClass: ?string, options: CompilerOptions): StaticClassResult {
+function parseStaticClass(
+  staticClass: string | null | undefined,
+  options: CompilerOptions
+): StaticClassResult {
   // "a b c" -> ["a", "b", "c"] => staticClass: ["a", "b", "c"]
   // "a {{x}} c" -> ["a", x, "c"] => classBinding: '["a", x, "c"]'
   let dynamic = false
   let classResult = ''
   if (staticClass) {
-    const classList = staticClass.trim().split(' ').map(name => {
-      const result = parseText(name, options.delimiters)
-      if (result) {
-        dynamic = true
-        return result.expression
-      }
-      return JSON.stringify(name)
-    })
+    const classList = staticClass
+      .trim()
+      .split(' ')
+      .map((name) => {
+        const result = parseText(name, options.delimiters)
+        if (result) {
+          dynamic = true
+          return result.expression
+        }
+        return JSON.stringify(name)
+      })
     if (classList.length) {
       classResult = '[' + classList.join(',') + ']'
     }
@@ -70,5 +72,5 @@ function parseStaticClass (staticClass: ?string, options: CompilerOptions): Stat
 export default {
   staticKeys: ['staticClass'],
   transformNode,
-  genData
+  genData,
 }
diff --git a/src/platforms/weex/compiler/modules/index.js b/src/platforms/weex/compiler/modules/index.ts
similarity index 69%
rename from src/platforms/weex/compiler/modules/index.js
rename to src/platforms/weex/compiler/modules/index.ts
index ac17809e7d4..96a379925aa 100644
--- a/src/platforms/weex/compiler/modules/index.js
+++ b/src/platforms/weex/compiler/modules/index.ts
@@ -4,10 +4,4 @@ import props from './props'
 import append from './append'
 import recycleList from './recycle-list/index'
 
-export default [
-  recycleList,
-  klass,
-  style,
-  props,
-  append
-]
+export default [recycleList, klass, style, props, append]
diff --git a/src/platforms/weex/compiler/modules/props.js b/src/platforms/weex/compiler/modules/props.ts
similarity index 85%
rename from src/platforms/weex/compiler/modules/props.js
rename to src/platforms/weex/compiler/modules/props.ts
index f7e21fe3b41..582d8490c33 100644
--- a/src/platforms/weex/compiler/modules/props.js
+++ b/src/platforms/weex/compiler/modules/props.ts
@@ -4,7 +4,7 @@ import { cached, camelize } from 'shared/util'
 
 const normalize = cached(camelize)
 
-function normalizeKeyName (str: string): string {
+function normalizeKeyName(str: string): string {
   if (str.match(/^v\-/)) {
     return str.replace(/(v-[a-z\-]+\:)([a-z\-]+)$/i, ($, directive, prop) => {
       return directive + normalize(prop)
@@ -13,9 +13,9 @@ function normalizeKeyName (str: string): string {
   return normalize(str)
 }
 
-function transformNode (el: ASTElement) {
+function transformNode(el: ASTElement) {
   if (Array.isArray(el.attrsList)) {
-    el.attrsList.forEach(attr => {
+    el.attrsList.forEach((attr) => {
       if (attr.name && attr.name.match(/\-/)) {
         const realName = normalizeKeyName(attr.name)
         if (el.attrsMap) {
@@ -33,5 +33,5 @@ function transformNode (el: ASTElement) {
   }
 }
 export default {
-  transformNode
+  transformNode,
 }
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component-root.js b/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
similarity index 81%
rename from src/platforms/weex/compiler/modules/recycle-list/component-root.js
rename to src/platforms/weex/compiler/modules/recycle-list/component-root.ts
index 5138799fb6b..cc81f93062a 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/component-root.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
@@ -3,7 +3,7 @@
 import { addAttr } from 'compiler/helpers'
 
 // mark component root nodes as
-export function postTransformComponentRoot (el: ASTElement) {
+export function postTransformComponentRoot(el: ASTElement) {
   if (!el.parent) {
     // component root
     addAttr(el, '@isComponentRoot', 'true')
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component.js b/src/platforms/weex/compiler/modules/recycle-list/component.ts
similarity index 72%
rename from src/platforms/weex/compiler/modules/recycle-list/component.js
rename to src/platforms/weex/compiler/modules/recycle-list/component.ts
index 36d7dfd504f..1d03c8fde13 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/component.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/component.ts
@@ -1,16 +1,17 @@
 /* @flow */
 
 import { addAttr } from 'compiler/helpers'
+import { WeexCompilerOptions } from 'typescript/weex'
 import { RECYCLE_LIST_MARKER } from 'weex/util/index'
 
 // mark components as inside recycle-list so that we know we need to invoke
 // their special @render function instead of render in create-component.js
-export function postTransformComponent (
+export function postTransformComponent(
   el: ASTElement,
   options: WeexCompilerOptions
 ) {
   // $flow-disable-line (we know isReservedTag is there)
-  if (!options.isReservedTag(el.tag) && el.tag !== 'cell-slot') {
+  if (!options.isReservedTag!(el.tag) && el.tag !== 'cell-slot') {
     addAttr(el, RECYCLE_LIST_MARKER, 'true')
   }
 }
diff --git a/src/platforms/weex/compiler/modules/recycle-list/index.js b/src/platforms/weex/compiler/modules/recycle-list/index.ts
similarity index 72%
rename from src/platforms/weex/compiler/modules/recycle-list/index.js
rename to src/platforms/weex/compiler/modules/recycle-list/index.ts
index e75b1746e4a..02096c0264b 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/index.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/index.ts
@@ -9,15 +9,15 @@ import { preTransformVIf } from './v-if'
 import { preTransformVFor } from './v-for'
 import { postTransformVOn } from './v-on'
 import { preTransformVOnce } from './v-once'
+import { WeexCompilerOptions } from 'typescript/weex'
 
-let currentRecycleList = null
+let currentRecycleList: null | ASTElement = null
 
-function shouldCompile (el: ASTElement, options: WeexCompilerOptions) {
-  return options.recyclable ||
-    (currentRecycleList && el !== currentRecycleList)
+function shouldCompile(el: ASTElement, options: WeexCompilerOptions) {
+  return options.recyclable || (currentRecycleList && el !== currentRecycleList)
 }
 
-function preTransformNode (el: ASTElement, options: WeexCompilerOptions) {
+function preTransformNode(el: ASTElement, options: WeexCompilerOptions) {
   if (el.tag === 'recycle-list') {
     preTransformRecycleList(el, options)
     currentRecycleList = el
@@ -30,13 +30,13 @@ function preTransformNode (el: ASTElement, options: WeexCompilerOptions) {
   }
 }
 
-function transformNode (el: ASTElement, options: WeexCompilerOptions) {
+function transformNode(el: ASTElement, options: WeexCompilerOptions) {
   if (shouldCompile(el, options)) {
     // do nothing yet
   }
 }
 
-function postTransformNode (el: ASTElement, options: WeexCompilerOptions) {
+function postTransformNode(el: ASTElement, options: WeexCompilerOptions) {
   if (shouldCompile(el, options)) {
     // mark child component in parent template
     postTransformComponent(el, options)
@@ -56,5 +56,5 @@ function postTransformNode (el: ASTElement, options: WeexCompilerOptions) {
 export default {
   preTransformNode,
   transformNode,
-  postTransformNode
+  postTransformNode,
 }
diff --git a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.js b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
similarity index 92%
rename from src/platforms/weex/compiler/modules/recycle-list/recycle-list.js
rename to src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
index 7fb65167536..f9270403a6f 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
@@ -2,6 +2,7 @@
 
 import { parseFor } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
+import { WeexCompilerOptions } from 'typescript/weex'
 
 /**
  * Map the following syntax to corresponding attrs:
@@ -12,7 +13,7 @@ import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
  * </recycle-list>
  */
 
-export function preTransformRecycleList (
+export function preTransformRecycleList(
   el: ASTElement,
   options: WeexCompilerOptions
 ) {
diff --git a/src/platforms/weex/compiler/modules/recycle-list/text.js b/src/platforms/weex/compiler/modules/recycle-list/text.ts
similarity index 69%
rename from src/platforms/weex/compiler/modules/recycle-list/text.js
rename to src/platforms/weex/compiler/modules/recycle-list/text.ts
index b3cbd06fb31..095c86dce9a 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/text.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/text.ts
@@ -2,10 +2,11 @@
 
 import { addAttr } from 'compiler/helpers'
 
-function genText (node: ASTNode) {
-  const value = node.type === 3
-    ? node.text
-    : node.type === 2
+function genText(node: ASTNode) {
+  const value =
+    node.type === 3
+      ? node.text
+      : node.type === 2
       ? node.tokens.length === 1
         ? node.tokens[0]
         : node.tokens
@@ -13,7 +14,7 @@ function genText (node: ASTNode) {
   return JSON.stringify(value)
 }
 
-export function postTransformText (el: ASTElement) {
+export function postTransformText(el: ASTElement) {
   // weex <text> can only contain text, so the parser
   // always generates a single child.
   if (el.children.length) {
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-bind.js b/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
similarity index 83%
rename from src/platforms/weex/compiler/modules/recycle-list/v-bind.js
rename to src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
index 14f0f687dab..b93a9b7a4aa 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-bind.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
@@ -5,11 +5,11 @@ import { generateBinding } from 'weex/util/parser'
 import { bindRE } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
 
-function parseAttrName (name: string): string {
+function parseAttrName(name: string): string {
   return camelize(name.replace(bindRE, ''))
 }
 
-export function preTransformVBind (el: ASTElement) {
+export function preTransformVBind(el: ASTElement) {
   for (const attr in el.attrsMap) {
     if (bindRE.test(attr)) {
       const name: string = parseAttrName(attr)
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-for.js b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
similarity index 80%
rename from src/platforms/weex/compiler/modules/recycle-list/v-for.js
rename to src/platforms/weex/compiler/modules/recycle-list/v-for.ts
index 9f09e4b4bd7..e6e29f3a084 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-for.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
@@ -2,8 +2,9 @@
 
 import { parseFor } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
+import { WeexCompilerOptions } from 'typescript/weex'
 
-export function preTransformVFor (el: ASTElement, options: WeexCompilerOptions) {
+export function preTransformVFor(el: ASTElement, options: WeexCompilerOptions) {
   const exp = getAndRemoveAttr(el, 'v-for')
   if (!exp) {
     return
@@ -19,7 +20,7 @@ export function preTransformVFor (el: ASTElement, options: WeexCompilerOptions)
 
   const desc: Object = {
     '@expression': res.for,
-    '@alias': res.alias
+    '@alias': res.alias,
   }
   if (res.iterator2) {
     desc['@key'] = res.iterator1
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-if.js b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
similarity index 78%
rename from src/platforms/weex/compiler/modules/recycle-list/v-if.js
rename to src/platforms/weex/compiler/modules/recycle-list/v-if.ts
index d82ba632b1e..2fd85de2562 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-if.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
@@ -2,8 +2,9 @@
 
 import { addIfCondition } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
+import { WeexCompilerOptions } from 'typescript/weex'
 
-function hasConditionDirective (el: ASTElement): boolean {
+function hasConditionDirective(el: ASTElement): boolean {
   for (const attr in el.attrsMap) {
     if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
       return true
@@ -12,11 +13,11 @@ function hasConditionDirective (el: ASTElement): boolean {
   return false
 }
 
-function getPreviousConditions (el: ASTElement): Array<string> {
-  const conditions = []
+function getPreviousConditions(el: ASTElement): Array<string> {
+  const conditions: any[] = []
   if (el.parent && el.parent.children) {
     for (let c = 0, n = el.parent.children.length; c < n; ++c) {
-      // $flow-disable-line
+      // @ts-ignore
       const ifConditions = el.parent.children[c].ifConditions
       if (ifConditions) {
         for (let i = 0, l = ifConditions.length; i < l; ++i) {
@@ -31,7 +32,7 @@ function getPreviousConditions (el: ASTElement): Array<string> {
   return conditions
 }
 
-export function preTransformVIf (el: ASTElement, options: WeexCompilerOptions) {
+export function preTransformVIf(el: ASTElement, options: WeexCompilerOptions) {
   if (hasConditionDirective(el)) {
     let exp
     const ifExp = getAndRemoveAttr(el, 'v-if', true /* remove from attrsMap */)
@@ -52,8 +53,8 @@ export function preTransformVIf (el: ASTElement, options: WeexCompilerOptions) {
           : `!(${prevMatch})` // v-else
       } else if (process.env.NODE_ENV !== 'production' && options.warn) {
         options.warn(
-          `v-${elseifExp ? ('else-if="' + elseifExp + '"') : 'else'} ` +
-          `used on element <${el.tag}> without corresponding v-if.`
+          `v-${elseifExp ? 'else-if="' + elseifExp + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`
         )
         return
       }
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-on.js b/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
similarity index 77%
rename from src/platforms/weex/compiler/modules/recycle-list/v-on.js
rename to src/platforms/weex/compiler/modules/recycle-list/v-on.ts
index aed3ea75531..7207de4cfd3 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-on.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
@@ -2,14 +2,14 @@
 
 const inlineStatementRE = /^\s*([A-Za-z_$0-9\['\."\]]+)*\s*\(\s*(([A-Za-z_$0-9\['\."\]]+)?(\s*,\s*([A-Za-z_$0-9\['\."\]]+))*)\s*\)$/
 
-function parseHandlerParams (handler: ASTElementHandler) {
+function parseHandlerParams(handler: ASTElementHandler) {
   const res = inlineStatementRE.exec(handler.value)
   if (res && res[2]) {
     handler.params = res[2].split(/\s*,\s*/)
   }
 }
 
-export function postTransformVOn (el: ASTElement) {
+export function postTransformVOn(el: ASTElement) {
   const events: ASTElementHandlers | void = el.events
   if (!events) {
     return
@@ -17,7 +17,7 @@ export function postTransformVOn (el: ASTElement) {
   for (const name in events) {
     const handler: ASTElementHandler | Array<ASTElementHandler> = events[name]
     if (Array.isArray(handler)) {
-      handler.map(fn => parseHandlerParams(fn))
+      handler.map((fn) => parseHandlerParams(fn))
     } else {
       parseHandlerParams(handler)
     }
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-once.js b/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
similarity index 74%
rename from src/platforms/weex/compiler/modules/recycle-list/v-once.js
rename to src/platforms/weex/compiler/modules/recycle-list/v-once.ts
index 99380c7f481..22fa78048ad 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-once.js
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
@@ -2,7 +2,7 @@
 
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
 
-function containVOnce (el: ASTElement): boolean {
+function containVOnce(el: ASTElement): boolean {
   for (const attr in el.attrsMap) {
     if (/^v\-once$/i.test(attr)) {
       return true
@@ -11,7 +11,7 @@ function containVOnce (el: ASTElement): boolean {
   return false
 }
 
-export function preTransformVOnce (el: ASTElement) {
+export function preTransformVOnce(el: ASTElement) {
   if (containVOnce(el)) {
     getAndRemoveAttr(el, 'v-once', true)
     addRawAttr(el, '[[once]]', true)
diff --git a/src/platforms/weex/compiler/modules/style.js b/src/platforms/weex/compiler/modules/style.ts
similarity index 57%
rename from src/platforms/weex/compiler/modules/style.js
rename to src/platforms/weex/compiler/modules/style.ts
index 9b0cd446d15..51b3e16e478 100644
--- a/src/platforms/weex/compiler/modules/style.js
+++ b/src/platforms/weex/compiler/modules/style.ts
@@ -2,45 +2,41 @@
 
 import { cached, camelize, isPlainObject } from 'shared/util'
 import { parseText } from 'compiler/parser/text-parser'
-import {
-  getAndRemoveAttr,
-  getBindingAttr,
-  baseWarn
-} from 'compiler/helpers'
+import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 
 type StaticStyleResult = {
-  dynamic: boolean,
-  styleResult: string | Object | void
-};
+  dynamic: boolean
+  styleResult: string | Record<string, any> | void
+}
 
 const normalize = cached(camelize)
 
-function transformNode (el: ASTElement, options: CompilerOptions) {
+function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
   const staticStyle = getAndRemoveAttr(el, 'style')
   const { dynamic, styleResult } = parseStaticStyle(staticStyle, options)
   if (process.env.NODE_ENV !== 'production' && dynamic) {
     warn(
       `style="${String(staticStyle)}": ` +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
+        'Interpolation inside attributes has been deprecated. ' +
+        'Use v-bind or the colon shorthand instead.',
       el.rawAttrsMap['style']
     )
   }
   if (!dynamic && styleResult) {
-    // $flow-disable-line
+    // @ts-ignore
     el.staticStyle = styleResult
   }
   const styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
   if (styleBinding) {
     el.styleBinding = styleBinding
   } else if (dynamic) {
-    // $flow-disable-line
+    // @ts-ignore
     el.styleBinding = styleResult
   }
 }
 
-function genData (el: ASTElement): string {
+function genData(el: ASTElement): string {
   let data = ''
   if (el.staticStyle) {
     data += `staticStyle:${el.staticStyle},`
@@ -51,26 +47,33 @@ function genData (el: ASTElement): string {
   return data
 }
 
-function parseStaticStyle (staticStyle: ?string, options: CompilerOptions): StaticStyleResult {
+function parseStaticStyle(
+  staticStyle: string | null,
+  options: CompilerOptions
+): StaticStyleResult {
   // "width: 200px; height: 200px;" -> {width: 200, height: 200}
   // "width: 200px; height: {{y}}" -> {width: 200, height: y}
   let dynamic = false
   let styleResult = ''
   if (typeof staticStyle === 'string') {
-    const styleList = staticStyle.trim().split(';').map(style => {
-      const result = style.trim().split(':')
-      if (result.length !== 2) {
-        return
-      }
-      const key = normalize(result[0].trim())
-      const value = result[1].trim()
-      const dynamicValue = parseText(value, options.delimiters)
-      if (dynamicValue) {
-        dynamic = true
-        return key + ':' + dynamicValue.expression
-      }
-      return key + ':' + JSON.stringify(value)
-    }).filter(result => result)
+    const styleList = staticStyle
+      .trim()
+      .split(';')
+      .map((style) => {
+        const result = style.trim().split(':')
+        if (result.length !== 2) {
+          return
+        }
+        const key = normalize(result[0].trim())
+        const value = result[1].trim()
+        const dynamicValue = parseText(value, options.delimiters)
+        if (dynamicValue) {
+          dynamic = true
+          return key + ':' + dynamicValue.expression
+        }
+        return key + ':' + JSON.stringify(value)
+      })
+      .filter((result) => result)
     if (styleList.length) {
       styleResult = '{' + styleList.join(',') + '}'
     }
@@ -83,5 +86,5 @@ function parseStaticStyle (staticStyle: ?string, options: CompilerOptions): Stat
 export default {
   staticKeys: ['staticStyle'],
   transformNode,
-  genData
+  genData,
 }
diff --git a/src/platforms/weex/entry-compiler.js b/src/platforms/weex/entry-compiler.ts
similarity index 100%
rename from src/platforms/weex/entry-compiler.js
rename to src/platforms/weex/entry-compiler.ts
diff --git a/src/platforms/weex/entry-framework.js b/src/platforms/weex/entry-framework.ts
similarity index 78%
rename from src/platforms/weex/entry-framework.js
rename to src/platforms/weex/entry-framework.ts
index a23775d4db5..b3c1b094abe 100644
--- a/src/platforms/weex/entry-framework.js
+++ b/src/platforms/weex/entry-framework.ts
@@ -1,5 +1,13 @@
 /* @flow */
 
+import { GlobalAPI } from 'typescript/global-api'
+import {
+  Weex,
+  WeexInstanceContext,
+  WeexInstanceOption,
+  WeexRuntimeContext,
+} from 'typescript/weex'
+
 // this will be preserved during build
 // $flow-disable-line
 const VueFactory = require('./factory')
@@ -9,21 +17,21 @@ const instanceOptions: { [key: string]: WeexInstanceOption } = {}
 /**
  * Create instance context.
  */
-export function createInstanceContext (
+export function createInstanceContext(
   instanceId: string,
   runtimeContext: WeexRuntimeContext,
-  data: Object = {}
+  data: any = {}
 ): WeexInstanceContext {
   const weex: Weex = runtimeContext.weex
-  const instance: WeexInstanceOption = instanceOptions[instanceId] = {
+  const instance: WeexInstanceOption = (instanceOptions[instanceId] = {
     instanceId,
     config: weex.config,
     document: weex.document,
-    data
-  }
+    data,
+  })
 
   // Each instance has a independent `Vue` module instance
-  const Vue = instance.Vue = createVueModuleInstance(instanceId, weex)
+  const Vue = (instance.Vue = createVueModuleInstance(instanceId, weex))
 
   // DEPRECATED
   const timerAPIs = getInstanceTimer(instanceId, weex.requireModule)
@@ -37,13 +45,15 @@ export function createInstanceContext (
  * Destroy an instance with id. It will make sure all memory of
  * this instance released and no more leaks.
  */
-export function destroyInstance (instanceId: string): void {
+export function destroyInstance(instanceId: string): void {
   const instance = instanceOptions[instanceId]
+  //@ts-expect-error
   if (instance && instance.app instanceof instance.Vue) {
     try {
-      instance.app.$destroy()
+      instance.app!.$destroy()
       instance.document.destroy()
     } catch (e) {}
+    //@ts-expect-error
     delete instance.document
     delete instance.app
   }
@@ -55,17 +65,18 @@ export function destroyInstance (instanceId: string): void {
  * It will use `Vue.set` on all keys of the new data. So it's better
  * define all possible meaningful keys when instance created.
  */
-export function refreshInstance (
+export function refreshInstance(
   instanceId: string,
   data: Object
 ): Error | void {
   const instance = instanceOptions[instanceId]
+  //@ts-expect-error
   if (!instance || !(instance.app instanceof instance.Vue)) {
     return new Error(`refreshInstance: instance ${instanceId} not found!`)
   }
   if (instance.Vue && instance.Vue.set) {
     for (const key in data) {
-      instance.Vue.set(instance.app, key, data[key])
+      instance.Vue.set(instance.app!, key, data[key])
     }
   }
   // Finally `refreshFinish` signal needed.
@@ -75,12 +86,10 @@ export function refreshInstance (
 /**
  * Create a fresh instance of Vue for each Weex instance.
  */
-function createVueModuleInstance (
-  instanceId: string,
-  weex: Weex
-): GlobalAPI {
+function createVueModuleInstance(instanceId: string, weex: Weex): GlobalAPI {
   const exports = {}
   VueFactory(exports, weex.document)
+  //@ts-expect-error
   const Vue = exports.Vue
 
   const instance = instanceOptions[instanceId]
@@ -90,12 +99,14 @@ function createVueModuleInstance (
   const weexRegex = /^weex:/i
   const isReservedTag = Vue.config.isReservedTag || (() => false)
   const isRuntimeComponent = Vue.config.isRuntimeComponent || (() => false)
-  Vue.config.isReservedTag = name => {
-    return (!isRuntimeComponent(name) && weex.supports(`@component/${name}`)) ||
+  Vue.config.isReservedTag = (name) => {
+    return (
+      (!isRuntimeComponent(name) && weex.supports(`@component/${name}`)) ||
       isReservedTag(name) ||
       weexRegex.test(name)
+    )
   }
-  Vue.config.parsePlatformTagName = name => name.replace(weexRegex, '')
+  Vue.config.parsePlatformTagName = (name) => name.replace(weexRegex, '')
 
   // expose weex-specific info
   Vue.prototype.$instanceId = instanceId
@@ -108,19 +119,20 @@ function createVueModuleInstance (
   // Hack `Vue` behavior to handle instance information and data
   // before root component created.
   Vue.mixin({
-    beforeCreate () {
+    beforeCreate() {
       const options = this.$options
       // root component (vm)
       if (options.el) {
         // set external data of instance
         const dataOption = options.data
-        const internalData = (typeof dataOption === 'function' ? dataOption() : dataOption) || {}
+        const internalData =
+          (typeof dataOption === 'function' ? dataOption() : dataOption) || {}
         options.data = Object.assign(internalData, instance.data)
         // record instance by id
         instance.app = this
       }
     },
-    mounted () {
+    mounted() {
       const options = this.$options
       // root component (vm)
       if (options.el && weex.document && instance.app === this) {
@@ -129,7 +141,7 @@ function createVueModuleInstance (
           weex.document.taskCenter.send('dom', { action: 'createFinish' }, [])
         } catch (e) {}
       }
-    }
+    },
   })
 
   /**
@@ -153,10 +165,7 @@ function createVueModuleInstance (
  * framework can make sure no side effect of the callback happened after
  * an instance destroyed.
  */
-function getInstanceTimer (
-  instanceId: string,
-  moduleGetter: Function
-): Object {
+function getInstanceTimer(instanceId: string, moduleGetter: Function): Object {
   const instance = instanceOptions[instanceId]
   const timer = moduleGetter('timer')
   const timerAPIs = {
@@ -166,6 +175,7 @@ function getInstanceTimer (
       }
 
       timer.setTimeout(handler, args[1])
+      //@ts-expect-error
       return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
     },
     setInterval: (...args) => {
@@ -174,6 +184,7 @@ function getInstanceTimer (
       }
 
       timer.setInterval(handler, args[1])
+      //@ts-expect-error
       return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
     },
     clearTimeout: (n) => {
@@ -181,7 +192,7 @@ function getInstanceTimer (
     },
     clearInterval: (n) => {
       timer.clearInterval(n)
-    }
+    },
   }
   return timerAPIs
 }
diff --git a/src/platforms/weex/entry-runtime-factory.js b/src/platforms/weex/entry-runtime-factory.ts
similarity index 100%
rename from src/platforms/weex/entry-runtime-factory.js
rename to src/platforms/weex/entry-runtime-factory.ts
diff --git a/src/platforms/weex/runtime/components/index.js b/src/platforms/weex/runtime/components/index.ts
similarity index 89%
rename from src/platforms/weex/runtime/components/index.js
rename to src/platforms/weex/runtime/components/index.ts
index 449db1ad78a..541a002566b 100644
--- a/src/platforms/weex/runtime/components/index.js
+++ b/src/platforms/weex/runtime/components/index.ts
@@ -5,5 +5,5 @@ import TransitionGroup from './transition-group'
 export default {
   Richtext,
   Transition,
-  TransitionGroup
+  TransitionGroup,
 }
diff --git a/src/platforms/weex/runtime/components/richtext.js b/src/platforms/weex/runtime/components/richtext.js
deleted file mode 100644
index a9164c7a698..00000000000
--- a/src/platforms/weex/runtime/components/richtext.js
+++ /dev/null
@@ -1,82 +0,0 @@
-/* @flow */
-
-function getVNodeType (vnode: VNode): string {
-  if (!vnode.tag) {
-    return ''
-  }
-  return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '')
-}
-
-function isSimpleSpan (vnode: VNode): boolean {
-  return vnode.children &&
-    vnode.children.length === 1 &&
-    !vnode.children[0].tag
-}
-
-function parseStyle (vnode: VNode): Object | void {
-  if (!vnode || !vnode.data) {
-    return
-  }
-  const { staticStyle, staticClass } = vnode.data
-  if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
-    const styles = Object.assign({}, staticStyle, vnode.data.style)
-    const cssMap = vnode.context.$options.style || {}
-    const classList = [].concat(staticClass, vnode.data.class)
-    classList.forEach(name => {
-      if (name && cssMap[name]) {
-        Object.assign(styles, cssMap[name])
-      }
-    })
-    return styles
-  }
-}
-
-function convertVNodeChildren (children: Array<VNode>): Array<VNode> | void {
-  if (!children.length) {
-    return
-  }
-
-  return children.map(vnode => {
-    const type: string = getVNodeType(vnode)
-    const props: Object = { type }
-
-    // convert raw text node
-    if (!type) {
-      props.type = 'span'
-      props.attr = {
-        value: (vnode.text || '').trim()
-      }
-    } else {
-      props.style = parseStyle(vnode)
-      if (vnode.data) {
-        props.attr = vnode.data.attrs
-        if (vnode.data.on) {
-          props.events = vnode.data.on
-        }
-      }
-      if (type === 'span' && isSimpleSpan(vnode)) {
-        props.attr = props.attr || {}
-        props.attr.value = vnode.children[0].text.trim()
-        return props
-      }
-    }
-
-    if (vnode.children && vnode.children.length) {
-      props.children = convertVNodeChildren(vnode.children)
-    }
-
-    return props
-  })
-}
-
-export default {
-  name: 'richtext',
-  render (h: Function) {
-    return h('weex:richtext', {
-      on: this._events,
-      attrs: {
-        value: convertVNodeChildren(this.$options._renderChildren || [])
-      }
-    })
-  }
-}
diff --git a/src/platforms/weex/runtime/components/richtext.ts b/src/platforms/weex/runtime/components/richtext.ts
new file mode 100644
index 00000000000..4e9db9c259b
--- /dev/null
+++ b/src/platforms/weex/runtime/components/richtext.ts
@@ -0,0 +1,90 @@
+/* @flow */
+
+import VNode from 'core/vdom/vnode'
+
+function getVNodeType(vnode: VNode): string {
+  if (!vnode.tag) {
+    return ''
+  }
+  return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '')
+}
+
+function isSimpleSpan(vnode: VNode): boolean {
+  return (vnode.children &&
+    vnode.children.length === 1 &&
+    !vnode.children[0].tag) as any
+}
+
+function parseStyle(vnode: VNode): Object | void {
+  if (!vnode || !vnode.data) {
+    return
+  }
+  const { staticStyle, staticClass } = vnode.data
+  if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
+    const styles = Object.assign({}, staticStyle, vnode.data.style)
+    // @ts-expect-error
+    const cssMap = vnode.context!.$options.style || {}
+    const classList = ([] as string[]).concat(staticClass!, vnode.data.class)
+    classList.forEach((name) => {
+      if (name && cssMap[name]) {
+        Object.assign(styles, cssMap[name])
+      }
+    })
+    return styles
+  }
+}
+
+function convertVNodeChildren(
+  children: Array<VNode>
+): Array<VNode> | undefined {
+  if (!children.length) {
+    return
+  }
+
+  return children.map(
+    (vnode): VNode => {
+      const type: string = getVNodeType(vnode)
+      const props: any = { type }
+
+      // convert raw text node
+      if (!type) {
+        props.type = 'span'
+        props.attr = {
+          value: (vnode.text || '').trim(),
+        }
+      } else {
+        props.style = parseStyle(vnode)
+        if (vnode.data) {
+          props.attr = vnode.data.attrs
+          if (vnode.data.on) {
+            props.events = vnode.data.on
+          }
+        }
+        if (type === 'span' && isSimpleSpan(vnode)) {
+          props.attr = props.attr || {}
+          //@ts-expect-error
+          props.attr.value = vnode.children[0].text.trim()
+          return props
+        }
+      }
+
+      if (vnode.children && vnode.children.length) {
+        props.children = convertVNodeChildren(vnode.children)
+      }
+
+      return props
+    }
+  )
+}
+
+export default {
+  name: 'richtext',
+  render(h: Function) {
+    return h('weex:richtext', {
+      on: this._events,
+      attrs: {
+        value: convertVNodeChildren(this.$options._renderChildren || []),
+      },
+    })
+  },
+}
diff --git a/src/platforms/weex/runtime/components/transition-group.js b/src/platforms/weex/runtime/components/transition-group.ts
similarity index 73%
rename from src/platforms/weex/runtime/components/transition-group.js
rename to src/platforms/weex/runtime/components/transition-group.ts
index 4a65965ff55..7333a3fd5a9 100644
--- a/src/platforms/weex/runtime/components/transition-group.js
+++ b/src/platforms/weex/runtime/components/transition-group.ts
@@ -1,40 +1,45 @@
 import { warn, extend } from 'core/util/index'
 import { transitionProps, extractTransitionData } from './transition'
 
-const props = extend({
-  tag: String,
-  moveClass: String
-}, transitionProps)
+const props = extend(
+  {
+    tag: String,
+    moveClass: String,
+  },
+  transitionProps
+)
 
 delete props.mode
 
 export default {
   props,
 
-  created () {
+  created() {
     const dom = this.$requireWeexModule('dom')
-    this.getPosition = el => new Promise((resolve, reject) => {
-      dom.getComponentRect(el.ref, res => {
-        if (!res.result) {
-          reject(new Error(`failed to get rect for element: ${el.tag}`))
-        } else {
-          resolve(res.size)
-        }
+    this.getPosition = (el) =>
+      new Promise((resolve, reject) => {
+        dom.getComponentRect(el.ref, (res) => {
+          if (!res.result) {
+            reject(new Error(`failed to get rect for element: ${el.tag}`))
+          } else {
+            resolve(res.size)
+          }
+        })
       })
-    })
 
     const animation = this.$requireWeexModule('animation')
-    this.animate = (el, options) => new Promise(resolve => {
-      animation.transition(el.ref, options, resolve)
-    })
+    this.animate = (el, options) =>
+      new Promise((resolve) => {
+        animation.transition(el.ref, options, resolve)
+      })
   },
 
-  render (h) {
+  render(h) {
     const tag = this.tag || this.$vnode.data.tag || 'span'
     const map = Object.create(null)
-    const prevChildren = this.prevChildren = this.children
+    const prevChildren = (this.prevChildren = this.children)
     const rawChildren = this.$slots.default || []
-    const children = this.children = []
+    const children: any[] = (this.children = [])
     const transitionData = extractTransitionData(this)
 
     for (let i = 0; i < rawChildren.length; i++) {
@@ -46,18 +51,16 @@ export default {
           ;(c.data || (c.data = {})).transition = transitionData
         } else if (process.env.NODE_ENV !== 'production') {
           const opts = c.componentOptions
-          const name = opts
-            ? (opts.Ctor.options.name || opts.tag)
-            : c.tag
+          const name = opts ? opts.Ctor.options.name || opts.tag : c.tag
           warn(`<transition-group> children must be keyed: <${name}>`)
         }
       }
     }
 
     if (prevChildren) {
-      const kept = []
-      const removed = []
-      prevChildren.forEach(c => {
+      const kept: any[] = []
+      const removed: any[] = []
+      prevChildren.forEach((c) => {
         c.data.transition = transitionData
 
         // TODO: record before patch positions
@@ -75,7 +78,7 @@ export default {
     return h(tag, null, children)
   },
 
-  beforeUpdate () {
+  beforeUpdate() {
     // force removing pass
     this.__patch__(
       this._vnode,
@@ -86,10 +89,11 @@ export default {
     this._vnode = this.kept
   },
 
-  updated () {
+  updated() {
     const children = this.prevChildren
-    const moveClass = this.moveClass || ((this.name || 'v') + '-move')
-    const moveData = children.length && this.getMoveData(children[0].context, moveClass)
+    const moveClass = this.moveClass || (this.name || 'v') + '-move'
+    const moveData =
+      children.length && this.getMoveData(children[0].context, moveClass)
     if (!moveData) {
       return
     }
@@ -129,11 +133,11 @@ export default {
   },
 
   methods: {
-    getMoveData (context, moveClass) {
+    getMoveData(context, moveClass) {
       const stylesheet = context.$options.style || {}
       return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass]
-    }
-  }
+    },
+  },
 }
 
 // function callPendingCbs (c) {
diff --git a/src/platforms/weex/runtime/components/transition.js b/src/platforms/weex/runtime/components/transition.ts
similarity index 89%
rename from src/platforms/weex/runtime/components/transition.js
rename to src/platforms/weex/runtime/components/transition.ts
index 20ba632d036..21203def087 100644
--- a/src/platforms/weex/runtime/components/transition.js
+++ b/src/platforms/weex/runtime/components/transition.ts
@@ -1,7 +1,7 @@
 // reuse same transition component logic from web
 export {
   transitionProps,
-  extractTransitionData
+  extractTransitionData,
 } from 'web/runtime/components/transition'
 
 import Transition from 'web/runtime/components/transition'
diff --git a/src/platforms/weex/runtime/directives/index.js b/src/platforms/weex/runtime/directives/index.js
deleted file mode 100755
index efba7fa6977..00000000000
--- a/src/platforms/weex/runtime/directives/index.js
+++ /dev/null
@@ -1,2 +0,0 @@
-export default {
-}
diff --git a/src/platforms/weex/runtime/directives/index.ts b/src/platforms/weex/runtime/directives/index.ts
new file mode 100644
index 00000000000..b1c6ea436a5
--- /dev/null
+++ b/src/platforms/weex/runtime/directives/index.ts
@@ -0,0 +1 @@
+export default {}
diff --git a/src/platforms/weex/runtime/index.js b/src/platforms/weex/runtime/index.ts
old mode 100755
new mode 100644
similarity index 80%
rename from src/platforms/weex/runtime/index.js
rename to src/platforms/weex/runtime/index.ts
index b8e09305be6..c2b2788d9d6
--- a/src/platforms/weex/runtime/index.js
+++ b/src/platforms/weex/runtime/index.ts
@@ -1,4 +1,4 @@
-/* @flow */
+//@ts-nocheck
 
 import Vue from 'core/index'
 import { patch } from 'weex/runtime/patch'
@@ -11,7 +11,7 @@ import {
   mustUseProp,
   isReservedTag,
   isRuntimeComponent,
-  isUnknownElement
+  isUnknownElement,
 } from 'weex/util/element'
 
 // install platform specific utils
@@ -28,15 +28,8 @@ Vue.options.components = platformComponents
 Vue.prototype.__patch__ = patch
 
 // wrap mount
-Vue.prototype.$mount = function (
-  el?: any,
-  hydrating?: boolean
-): Component {
-  return mountComponent(
-    this,
-    el && query(el, this.$document),
-    hydrating
-  )
+Vue.prototype.$mount = function (el?: any, hydrating?: boolean): Component {
+  return mountComponent(this, el && query(el, this.$document), hydrating)
 }
 
 export default Vue
diff --git a/src/platforms/weex/runtime/modules/attrs.js b/src/platforms/weex/runtime/modules/attrs.ts
old mode 100755
new mode 100644
similarity index 71%
rename from src/platforms/weex/runtime/modules/attrs.js
rename to src/platforms/weex/runtime/modules/attrs.ts
index 1b6185cae70..dd437154593
--- a/src/platforms/weex/runtime/modules/attrs.js
+++ b/src/platforms/weex/runtime/modules/attrs.ts
@@ -1,8 +1,9 @@
 /* @flow */
 
 import { extend } from 'shared/util'
+import { VNodeWithData } from 'typescript/vnode'
 
-function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (!oldVnode.data.attrs && !vnode.data.attrs) {
     return
   }
@@ -21,16 +22,12 @@ function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
     cur = attrs[key]
     old = oldAttrs[key]
     if (old !== cur) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = cur)
-        : elm.setAttr(key, cur)
+      supportBatchUpdate ? (batchedAttrs[key] = cur) : elm.setAttr(key, cur)
     }
   }
   for (key in oldAttrs) {
     if (attrs[key] == null) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = undefined)
-        : elm.setAttr(key)
+      supportBatchUpdate ? (batchedAttrs[key] = undefined) : elm.setAttr(key)
     }
   }
   if (supportBatchUpdate) {
@@ -40,5 +37,5 @@ function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
 
 export default {
   create: updateAttrs,
-  update: updateAttrs
+  update: updateAttrs,
 }
diff --git a/src/platforms/weex/runtime/modules/class.js b/src/platforms/weex/runtime/modules/class.ts
old mode 100755
new mode 100644
similarity index 71%
rename from src/platforms/weex/runtime/modules/class.js
rename to src/platforms/weex/runtime/modules/class.ts
index 0a07bb3b56d..a5020939446
--- a/src/platforms/weex/runtime/modules/class.js
+++ b/src/platforms/weex/runtime/modules/class.ts
@@ -1,14 +1,17 @@
 /* @flow */
 
 import { extend, isObject } from 'shared/util'
+import { Component } from 'typescript/component'
+import { VNodeData, VNodeWithData } from 'typescript/vnode'
 
-function updateClass (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateClass(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   const el = vnode.elm
   const ctx = vnode.context
 
   const data: VNodeData = vnode.data
   const oldData: VNodeData = oldVnode.data
-  if (!data.staticClass &&
+  if (
+    !data.staticClass &&
     !data.class &&
     (!oldData || (!oldData.staticClass && !oldData.class))
   ) {
@@ -32,8 +35,8 @@ function updateClass (oldVnode: VNodeWithData, vnode: VNodeWithData) {
   }
 }
 
-function makeClassList (data: VNodeData): Array<string> {
-  const classList = []
+function makeClassList(data: VNodeData): Array<string> {
+  const classList: any[] = []
   // unlike web, weex vnode staticClass is an Array
   const staticClass: any = data.staticClass
   const dataClass = data.class
@@ -43,23 +46,31 @@ function makeClassList (data: VNodeData): Array<string> {
   if (Array.isArray(dataClass)) {
     classList.push.apply(classList, dataClass)
   } else if (isObject(dataClass)) {
-    classList.push.apply(classList, Object.keys(dataClass).filter(className => dataClass[className]))
+    classList.push.apply(
+      classList,
+      Object.keys(dataClass).filter((className) => dataClass[className])
+    )
   } else if (typeof dataClass === 'string') {
     classList.push.apply(classList, dataClass.trim().split(/\s+/))
   }
   return classList
 }
 
-function getStyle (oldClassList: Array<string>, classList: Array<string>, ctx: Component): Object {
+function getStyle(
+  oldClassList: Array<string>,
+  classList: Array<string>,
+  ctx: Component
+): Object {
   // style is a weex-only injected object
   // compiled from <style> tags in weex files
+  //@ts-expect-error
   const stylesheet: any = ctx.$options.style || {}
   const result = {}
-  classList.forEach(name => {
+  classList.forEach((name) => {
     const style = stylesheet[name]
     extend(result, style)
   })
-  oldClassList.forEach(name => {
+  oldClassList.forEach((name) => {
     const style = stylesheet[name]
     for (const key in style) {
       if (!result.hasOwnProperty(key)) {
@@ -72,5 +83,5 @@ function getStyle (oldClassList: Array<string>, classList: Array<string>, ctx: C
 
 export default {
   create: updateClass,
-  update: updateClass
+  update: updateClass,
 }
diff --git a/src/platforms/weex/runtime/modules/events.js b/src/platforms/weex/runtime/modules/events.ts
old mode 100755
new mode 100644
similarity index 69%
rename from src/platforms/weex/runtime/modules/events.js
rename to src/platforms/weex/runtime/modules/events.ts
index c34719483a8..53340b44034
--- a/src/platforms/weex/runtime/modules/events.js
+++ b/src/platforms/weex/runtime/modules/events.ts
@@ -1,12 +1,13 @@
 /* @flow */
 
 import { updateListeners } from 'core/vdom/helpers/update-listeners'
+import { VNodeWithData } from 'typescript/vnode'
 
 let target: any
 
-function createOnceHandler (event, handler, capture) {
+function createOnceHandler(event, handler, capture) {
   const _target = target // save current target element in closure
-  return function onceHandler () {
+  return function onceHandler() {
     const res = handler.apply(null, arguments)
     if (res !== null) {
       remove(event, onceHandler, capture, _target)
@@ -14,7 +15,7 @@ function createOnceHandler (event, handler, capture) {
   }
 }
 
-function add (
+function add(
   event: string,
   handler: Function,
   capture: boolean,
@@ -28,16 +29,11 @@ function add (
   target.addEvent(event, handler, params)
 }
 
-function remove (
-  event: string,
-  handler: any,
-  capture: any,
-  _target?: any
-) {
-  (_target || target).removeEvent(event)
+function remove(event: string, handler: any, capture: any, _target?: any) {
+  ;(_target || target).removeEvent(event)
 }
 
-function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateDOMListeners(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (!oldVnode.data.on && !vnode.data.on) {
     return
   }
@@ -50,5 +46,5 @@ function updateDOMListeners (oldVnode: VNodeWithData, vnode: VNodeWithData) {
 
 export default {
   create: updateDOMListeners,
-  update: updateDOMListeners
+  update: updateDOMListeners,
 }
diff --git a/src/platforms/weex/runtime/modules/index.js b/src/platforms/weex/runtime/modules/index.ts
old mode 100755
new mode 100644
similarity index 68%
rename from src/platforms/weex/runtime/modules/index.js
rename to src/platforms/weex/runtime/modules/index.ts
index dd38448459a..bc1923b00f7
--- a/src/platforms/weex/runtime/modules/index.js
+++ b/src/platforms/weex/runtime/modules/index.ts
@@ -4,10 +4,4 @@ import events from './events'
 import style from './style'
 import transition from './transition'
 
-export default [
-  attrs,
-  klass,
-  events,
-  style,
-  transition
-]
+export default [attrs, klass, events, style, transition]
diff --git a/src/platforms/weex/runtime/modules/style.js b/src/platforms/weex/runtime/modules/style.ts
old mode 100755
new mode 100644
similarity index 90%
rename from src/platforms/weex/runtime/modules/style.js
rename to src/platforms/weex/runtime/modules/style.ts
index 0ec217b3743..7d982c65c68
--- a/src/platforms/weex/runtime/modules/style.js
+++ b/src/platforms/weex/runtime/modules/style.ts
@@ -4,7 +4,7 @@ import { extend, cached, camelize } from 'shared/util'
 
 const normalize = cached(camelize)
 
-function createStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function createStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (!vnode.data.staticStyle) {
     updateStyle(oldVnode, vnode)
     return
@@ -26,7 +26,7 @@ function createStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
   updateStyle(oldVnode, vnode)
 }
 
-function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
+function updateStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (!oldVnode.data.style && !vnode.data.style) {
     return
   }
@@ -68,7 +68,7 @@ function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
   }
 }
 
-function toObject (arr) {
+function toObject(arr) {
   const res = {}
   for (let i = 0; i < arr.length; i++) {
     if (arr[i]) {
@@ -80,5 +80,5 @@ function toObject (arr) {
 
 export default {
   create: createStyle,
-  update: updateStyle
+  update: updateStyle,
 }
diff --git a/src/platforms/weex/runtime/modules/transition.js b/src/platforms/weex/runtime/modules/transition.ts
similarity index 70%
rename from src/platforms/weex/runtime/modules/transition.js
rename to src/platforms/weex/runtime/modules/transition.ts
index cf872819f31..551d1d7127a 100644
--- a/src/platforms/weex/runtime/modules/transition.js
+++ b/src/platforms/weex/runtime/modules/transition.ts
@@ -6,10 +6,10 @@ import { resolveTransition } from 'web/runtime/transition-util'
 export default {
   create: enter,
   activate: enter,
-  remove: leave
+  remove: leave,
 }
 
-function enter (_, vnode) {
+function enter(_, vnode) {
   const el = vnode.elm
 
   // call leave callback now
@@ -42,7 +42,7 @@ function enter (_, vnode) {
     beforeAppear,
     appear,
     afterAppear,
-    appearCancelled
+    appearCancelled,
   } = data
 
   let context = activeInstance
@@ -61,10 +61,16 @@ function enter (_, vnode) {
   const startClass = isAppear ? appearClass : enterClass
   const toClass = isAppear ? appearToClass : enterToClass
   const activeClass = isAppear ? appearActiveClass : enterActiveClass
-  const beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter
-  const enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter
-  const afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter
-  const enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled
+  const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter
+  const enterHook = isAppear
+    ? typeof appear === 'function'
+      ? appear
+      : enter
+    : enter
+  const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter
+  const enterCancelledHook = isAppear
+    ? appearCancelled || enterCancelled
+    : enterCancelled
 
   const userWantsControl =
     enterHook &&
@@ -74,18 +80,26 @@ function enter (_, vnode) {
 
   const stylesheet = vnode.context.$options.style || {}
   const startState = stylesheet[startClass]
-  const transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {}
-  const endState = getEnterTargetState(el, stylesheet, startClass, toClass, activeClass)
+  const transitionProperties =
+    (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {}
+  const endState = getEnterTargetState(
+    el,
+    stylesheet,
+    startClass,
+    toClass,
+    activeClass
+  )
   const needAnimation = Object.keys(endState).length > 0
 
-  const cb = el._enterCb = once(() => {
+  const cb = (el._enterCb = once(() => {
+    //@ts-expect-error
     if (cb.cancelled) {
       enterCancelledHook && enterCancelledHook(el)
     } else {
       afterEnterHook && afterEnterHook(el)
     }
     el._enterCb = null
-  })
+  }))
 
   // We need to wait until the native element has been inserted, but currently
   // there's no API to do that. So we have to wait "one frame" - not entirely
@@ -93,7 +107,8 @@ function enter (_, vnode) {
   setTimeout(() => {
     const parent = el.parentNode
     const pendingNode = parent && parent._pending && parent._pending[vnode.key]
-    if (pendingNode &&
+    if (
+      pendingNode &&
       pendingNode.context === vnode.context &&
       pendingNode.tag === vnode.tag &&
       pendingNode.elm._leaveCb
@@ -104,12 +119,16 @@ function enter (_, vnode) {
 
     if (needAnimation) {
       const animation = vnode.context.$requireWeexModule('animation')
-      animation.transition(el.ref, {
-        styles: endState,
-        duration: transitionProperties.duration || 0,
-        delay: transitionProperties.delay || 0,
-        timingFunction: transitionProperties.timingFunction || 'linear'
-      }, userWantsControl ? noop : cb)
+      animation.transition(
+        el.ref,
+        {
+          styles: endState,
+          duration: transitionProperties.duration || 0,
+          delay: transitionProperties.delay || 0,
+          timingFunction: transitionProperties.timingFunction || 'linear',
+        },
+        userWantsControl ? noop : cb
+      )
     } else if (!userWantsControl) {
       cb()
     }
@@ -133,7 +152,7 @@ function enter (_, vnode) {
   }
 }
 
-function leave (vnode, rm) {
+function leave(vnode, rm) {
   const el = vnode.elm
 
   // call enter callback now
@@ -159,7 +178,7 @@ function leave (vnode, rm) {
     leave,
     afterLeave,
     leaveCancelled,
-    delayLeave
+    delayLeave,
   } = data
 
   const userWantsControl =
@@ -171,12 +190,16 @@ function leave (vnode, rm) {
   const stylesheet = vnode.context.$options.style || {}
   const startState = stylesheet[leaveClass]
   const endState = stylesheet[leaveToClass] || stylesheet[leaveActiveClass]
-  const transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][leaveActiveClass]) || {}
+  const transitionProperties =
+    (stylesheet['@TRANSITION'] &&
+      stylesheet['@TRANSITION'][leaveActiveClass]) ||
+    {}
 
-  const cb = el._leaveCb = once(() => {
+  const cb = (el._leaveCb = once(() => {
     if (el.parentNode && el.parentNode._pending) {
       el.parentNode._pending[vnode.key] = null
     }
+    //@ts-expect-error
     if (cb.cancelled) {
       leaveCancelled && leaveCancelled(el)
     } else {
@@ -184,7 +207,7 @@ function leave (vnode, rm) {
       afterLeave && afterLeave(el)
     }
     el._leaveCb = null
-  })
+  }))
 
   if (delayLeave) {
     delayLeave(performLeave)
@@ -192,33 +215,44 @@ function leave (vnode, rm) {
     performLeave()
   }
 
-  function performLeave () {
+  function performLeave() {
     const animation = vnode.context.$requireWeexModule('animation')
     // the delayed leave may have already been cancelled
+    //@ts-expect-error
     if (cb.cancelled) {
       return
     }
     // record leaving element
     if (!vnode.data.show) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode
+      ;(el.parentNode._pending || (el.parentNode._pending = {}))[
+        vnode.key
+      ] = vnode
     }
     beforeLeave && beforeLeave(el)
 
     if (startState) {
-      animation.transition(el.ref, {
-        styles: startState
-      }, next)
+      animation.transition(
+        el.ref,
+        {
+          styles: startState,
+        },
+        next
+      )
     } else {
       next()
     }
 
-    function next () {
-      animation.transition(el.ref, {
-        styles: endState,
-        duration: transitionProperties.duration || 0,
-        delay: transitionProperties.delay || 0,
-        timingFunction: transitionProperties.timingFunction || 'linear'
-      }, userWantsControl ? noop : cb)
+    function next() {
+      animation.transition(
+        el.ref,
+        {
+          styles: endState,
+          duration: transitionProperties.duration || 0,
+          delay: transitionProperties.delay || 0,
+          timingFunction: transitionProperties.timingFunction || 'linear',
+        },
+        userWantsControl ? noop : cb
+      )
     }
 
     leave && leave(el, cb)
@@ -229,7 +263,13 @@ function leave (vnode, rm) {
 }
 
 // determine the target animation style for an entering transition.
-function getEnterTargetState (el, stylesheet, startClass, endClass, activeClass) {
+function getEnterTargetState(
+  el,
+  stylesheet,
+  startClass,
+  endClass,
+  activeClass
+) {
   const targetState = {}
   const startState = stylesheet[startClass]
   const endState = stylesheet[endClass]
@@ -246,9 +286,9 @@ function getEnterTargetState (el, stylesheet, startClass, endClass, activeClass)
       ) {
         warn(
           `transition property "${key}" is declared in enter starting class (.${startClass}), ` +
-          `but not declared anywhere in enter ending class (.${endClass}), ` +
-          `enter active cass (.${activeClass}) or the element's default styling. ` +
-          `Note in Weex, CSS properties need explicit values to be transitionable.`
+            `but not declared anywhere in enter ending class (.${endClass}), ` +
+            `enter active cass (.${activeClass}) or the element's default styling. ` +
+            `Note in Weex, CSS properties need explicit values to be transitionable.`
         )
       }
     }
diff --git a/src/platforms/weex/runtime/node-ops.js b/src/platforms/weex/runtime/node-ops.ts
old mode 100755
new mode 100644
similarity index 59%
rename from src/platforms/weex/runtime/node-ops.js
rename to src/platforms/weex/runtime/node-ops.ts
index 0438ec5c150..ca6cccc32fc
--- a/src/platforms/weex/runtime/node-ops.js
+++ b/src/platforms/weex/runtime/node-ops.ts
@@ -1,27 +1,31 @@
 /* @flow */
-declare var document: WeexDocument;
+declare var document: WeexDocument
 
+import { WeexDocument, WeexElement } from 'typescript/weex'
 import TextNode from 'weex/runtime/text-node'
 
 export const namespaceMap = {}
 
-export function createElement (tagName: string): WeexElement {
+export function createElement(tagName: string): WeexElement {
   return document.createElement(tagName)
 }
 
-export function createElementNS (namespace: string, tagName: string): WeexElement {
+export function createElementNS(
+  namespace: string,
+  tagName: string
+): WeexElement {
   return document.createElement(namespace + ':' + tagName)
 }
 
-export function createTextNode (text: string) {
+export function createTextNode(text: string) {
   return new TextNode(text)
 }
 
-export function createComment (text: string) {
+export function createComment(text: string) {
   return document.createComment(text)
 }
 
-export function insertBefore (
+export function insertBefore(
   node: WeexElement,
   target: WeexElement,
   before: WeexElement
@@ -40,7 +44,7 @@ export function insertBefore (
   node.insertBefore(target, before)
 }
 
-export function removeChild (node: WeexElement, child: WeexElement) {
+export function removeChild(node: WeexElement, child: WeexElement) {
   if (child.nodeType === 3) {
     node.setAttr('value', '')
     return
@@ -48,7 +52,7 @@ export function removeChild (node: WeexElement, child: WeexElement) {
   node.removeChild(child)
 }
 
-export function appendChild (node: WeexElement, child: WeexElement) {
+export function appendChild(node: WeexElement, child: WeexElement) {
   if (child.nodeType === 3) {
     if (node.type === 'text') {
       node.setAttr('value', child.text)
@@ -64,28 +68,28 @@ export function appendChild (node: WeexElement, child: WeexElement) {
   node.appendChild(child)
 }
 
-export function parentNode (node: WeexElement): WeexElement | void {
+export function parentNode(node: WeexElement): WeexElement | void {
   return node.parentNode
 }
 
-export function nextSibling (node: WeexElement): WeexElement | void {
+export function nextSibling(node: WeexElement): WeexElement | void {
   return node.nextSibling
 }
 
-export function tagName (node: WeexElement): string {
+export function tagName(node: WeexElement): string {
   return node.type
 }
 
-export function setTextContent (node: WeexElement, text: string) {
+export function setTextContent(node: WeexElement, text: string) {
   if (node.parentNode) {
     node.parentNode.setAttr('value', text)
   }
 }
 
-export function setAttribute (node: WeexElement, key: string, val: any) {
+export function setAttribute(node: WeexElement, key: string, val: any) {
   node.setAttr(key, val)
 }
 
-export function setStyleScope (node: WeexElement, scopeId: string) {
+export function setStyleScope(node: WeexElement, scopeId: string) {
   node.setAttr('@styleScope', scopeId)
 }
diff --git a/src/platforms/weex/runtime/patch.js b/src/platforms/weex/runtime/patch.ts
similarity index 94%
rename from src/platforms/weex/runtime/patch.js
rename to src/platforms/weex/runtime/patch.ts
index 5e70d1436fd..3d0f76a6db8 100644
--- a/src/platforms/weex/runtime/patch.js
+++ b/src/platforms/weex/runtime/patch.ts
@@ -12,5 +12,5 @@ const modules = platformModules.concat(baseModules)
 export const patch: Function = createPatchFunction({
   nodeOps,
   modules,
-  LONG_LIST_THRESHOLD: 10
+  LONG_LIST_THRESHOLD: 10,
 })
diff --git a/src/platforms/weex/runtime/recycle-list/render-component-template.js b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
similarity index 55%
rename from src/platforms/weex/runtime/recycle-list/render-component-template.js
rename to src/platforms/weex/runtime/recycle-list/render-component-template.ts
index 17e8c018bd5..114ef0ecd86 100644
--- a/src/platforms/weex/runtime/recycle-list/render-component-template.js
+++ b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
@@ -5,19 +5,21 @@ import { handleError } from 'core/util/error'
 import { RECYCLE_LIST_MARKER } from 'weex/util/index'
 import { createComponentInstanceForVnode } from 'core/vdom/create-component'
 import { resolveVirtualComponent } from './virtual-component'
+import { MountedComponentVNode, VNodeWithData } from 'typescript/vnode'
+import VNode from 'core/vdom/vnode'
 
-export function isRecyclableComponent (vnode: VNodeWithData): boolean {
-  return vnode.data.attrs
-    ? (RECYCLE_LIST_MARKER in vnode.data.attrs)
-    : false
+export function isRecyclableComponent(vnode: VNodeWithData | VNode): boolean {
+  return vnode.data!.attrs ? RECYCLE_LIST_MARKER in vnode.data!.attrs : false
 }
 
-export function renderRecyclableComponentTemplate (vnode: MountedComponentVNode): VNode {
-  // $flow-disable-line
+export function renderRecyclableComponentTemplate(
+  vnode: MountedComponentVNode | VNode
+): VNode | undefined {
+  //@ts-expect-error
   delete vnode.data.attrs[RECYCLE_LIST_MARKER]
   resolveVirtualComponent(vnode)
   const vm = createComponentInstanceForVnode(vnode)
-  const render = (vm.$options: any)['@render']
+  const render = (vm.$options as any)['@render']
   if (render) {
     try {
       return render.call(vm)
@@ -27,7 +29,7 @@ export function renderRecyclableComponentTemplate (vnode: MountedComponentVNode)
   } else {
     warn(
       `@render function not defined on component used in <recycle-list>. ` +
-      `Make sure to declare \`recyclable="true"\` on the component's template.`,
+        `Make sure to declare \`recyclable="true"\` on the component's template.`,
       vm
     )
   }
diff --git a/src/platforms/weex/runtime/recycle-list/virtual-component.js b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
similarity index 81%
rename from src/platforms/weex/runtime/recycle-list/virtual-component.js
rename to src/platforms/weex/runtime/recycle-list/virtual-component.ts
index e5498d26897..fde0d22e55c 100644
--- a/src/platforms/weex/runtime/recycle-list/virtual-component.js
+++ b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
@@ -10,13 +10,19 @@ import { initRender } from 'core/instance/render'
 import { initEvents } from 'core/instance/events'
 import { initProvide, initInjections } from 'core/instance/inject'
 import { initLifecycle, callHook } from 'core/instance/lifecycle'
-import { initInternalComponent, resolveConstructorOptions } from 'core/instance/init'
+import {
+  initInternalComponent,
+  resolveConstructorOptions,
+} from 'core/instance/init'
 import { registerComponentHook, updateComponentData } from '../../util/index'
+import { Component } from 'typescript/component'
+import VNode from 'core/vdom/vnode'
+import { MountedComponentVNode } from 'typescript/vnode'
 
 let uid = 0
 
 // override Vue.prototype._init
-function initVirtualComponent (options: Object = {}) {
+function initVirtualComponent(options: Record<string, any> = {}) {
   const vm: Component = this
   const componentId = options.componentId
 
@@ -30,9 +36,11 @@ function initVirtualComponent (options: Object = {}) {
     // optimize internal component instantiation
     // since dynamic options merging is pretty slow, and none of the
     // internal component options needs special treatment.
+    //@ts-expect-error
     initInternalComponent(vm, options)
   } else {
     vm.$options = mergeOptions(
+      //@ts-expect-error
       resolveConstructorOptions(vm.constructor),
       options || {},
       vm
@@ -58,9 +66,7 @@ function initVirtualComponent (options: Object = {}) {
 
   // send initial data to native
   const data = vm.$options.data
-  const params = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {}
+  const params = typeof data === 'function' ? getData(data, vm) : data || {}
   if (isPlainObject(params)) {
     updateComponentData(componentId, params)
   }
@@ -69,7 +75,7 @@ function initVirtualComponent (options: Object = {}) {
     callHook(vm, 'beforeMount')
 
     const updateComponent = () => {
-      vm._update(vm._vnode, false)
+      vm._update(vm._vnode!, false)
     }
     new Watcher(vm, updateComponent, noop, null, true)
 
@@ -83,7 +89,7 @@ function initVirtualComponent (options: Object = {}) {
 }
 
 // override Vue.prototype._update
-function updateVirtualComponent (vnode?: VNode) {
+function updateVirtualComponent(vnode?: VNode) {
   const vm: Component = this
   const componentId = vm.$options.componentId
   if (vm._isMounted) {
@@ -100,15 +106,17 @@ function updateVirtualComponent (vnode?: VNode) {
 }
 
 // listening on native callback
-export function resolveVirtualComponent (vnode: MountedComponentVNode): VNode {
-  const BaseCtor = vnode.componentOptions.Ctor
+export function resolveVirtualComponent(
+  vnode: MountedComponentVNode | VNode
+): void {
+  const BaseCtor = vnode.componentOptions!.Ctor
   const VirtualComponent = BaseCtor.extend({})
   const cid = VirtualComponent.cid
   VirtualComponent.prototype._init = initVirtualComponent
   VirtualComponent.prototype._update = updateVirtualComponent
 
-  vnode.componentOptions.Ctor = BaseCtor.extend({
-    beforeCreate () {
+  vnode.componentOptions!.Ctor = BaseCtor.extend({
+    beforeCreate() {
       // const vm: Component = this
 
       // TODO: listen on all events and dispatch them to the
@@ -119,7 +127,7 @@ export function resolveVirtualComponent (vnode: MountedComponentVNode): VNode {
         // const subVm =
         new VirtualComponent({
           componentId,
-          propsData
+          propsData,
         })
         // if (vm._virtualComponents) {
         //   vm._virtualComponents[componentId] = subVm
@@ -128,9 +136,8 @@ export function resolveVirtualComponent (vnode: MountedComponentVNode): VNode {
 
       registerComponentHook(cid, 'lifecycle', 'create', createVirtualComponent)
     },
-    beforeDestroy () {
+    beforeDestroy() {
       delete this._virtualComponents
-    }
+    },
   })
 }
-
diff --git a/src/platforms/weex/runtime/text-node.js b/src/platforms/weex/runtime/text-node.ts
similarity index 77%
rename from src/platforms/weex/runtime/text-node.js
rename to src/platforms/weex/runtime/text-node.ts
index 0720a05a5a6..18143b3110e 100644
--- a/src/platforms/weex/runtime/text-node.js
+++ b/src/platforms/weex/runtime/text-node.ts
@@ -1,6 +1,6 @@
 let latestNodeId = 1
 
-export default function TextNode (text) {
+export default function TextNode(text) {
   this.instanceId = ''
   this.nodeId = latestNodeId++
   this.parentNode = null
diff --git a/src/platforms/weex/util/element.js b/src/platforms/weex/util/element.ts
similarity index 58%
rename from src/platforms/weex/util/element.js
rename to src/platforms/weex/util/element.ts
index 9753918597b..929f48f4705 100644
--- a/src/platforms/weex/util/element.js
+++ b/src/platforms/weex/util/element.ts
@@ -8,18 +8,17 @@ import { makeMap, noop } from 'shared/util'
 
 export const isReservedTag = makeMap(
   'template,script,style,element,content,slot,link,meta,svg,view,' +
-  'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-  'slider,slider-neighbor,indicator,canvas,' +
-  'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-  'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
+    'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
+    'slider,slider-neighbor,indicator,canvas,' +
+    'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
+    'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
   true
 )
 
 // Elements that you can, intentionally, leave open (and which close themselves)
 // more flexible than web
 export const canBeLeftOpenTag = makeMap(
-  'web,spinner,switch,video,textarea,canvas,' +
-  'indicator,marquee,countdown',
+  'web,spinner,switch,video,textarea,canvas,' + 'indicator,marquee,countdown',
   true
 )
 
@@ -28,22 +27,19 @@ export const isRuntimeComponent = makeMap(
   true
 )
 
-export const isUnaryTag = makeMap(
-  'embed,img,image,input,link,meta',
-  true
-)
+export const isUnaryTag = makeMap('embed,img,image,input,link,meta', true)
 
-export function mustUseProp (): boolean {
+export function mustUseProp(): boolean {
   return false
 }
 
-export function getTagNamespace (): void { }
+export function getTagNamespace(): void {}
 
-export function isUnknownElement (): boolean {
+export function isUnknownElement(): boolean {
   return false
 }
 
-export function query (el: string | Element, document: Object) {
+export function query(el: string | Element, document: any) {
   // document is injected by weex factory wrapper
   const placeholder = document.createComment('root')
   placeholder.hasAttribute = placeholder.removeAttribute = noop // hack for patch
diff --git a/src/platforms/weex/util/index.js b/src/platforms/weex/util/index.ts
old mode 100755
new mode 100644
similarity index 88%
rename from src/platforms/weex/util/index.js
rename to src/platforms/weex/util/index.ts
index 8181d70eafb..3c0d531e081
--- a/src/platforms/weex/util/index.js
+++ b/src/platforms/weex/util/index.ts
@@ -1,13 +1,14 @@
 /* @flow */
-declare var document: WeexDocument;
+declare var document: WeexDocument
 
 import { warn } from 'core/util/index'
+import { WeexDocument } from 'typescript/weex'
 
 export const RECYCLE_LIST_MARKER = '@inRecycleList'
 
 // Register the component hook to weex native render engine.
 // The hook will be triggered by native, not javascript.
-export function registerComponentHook (
+export function registerComponentHook(
   componentId: string,
   type: string, // hook type, could be "lifecycle" or "instance"
   hook: string, // hook name
@@ -24,7 +25,7 @@ export function registerComponentHook (
 }
 
 // Updates the state of the component to weex native render engine.
-export function updateComponentData (
+export function updateComponentData(
   componentId: string,
   newData: Object | void,
   callback?: Function
diff --git a/src/platforms/weex/util/parser.js b/src/platforms/weex/util/parser.ts
similarity index 75%
rename from src/platforms/weex/util/parser.js
rename to src/platforms/weex/util/parser.ts
index 081908e82b4..f43c7d08be6 100644
--- a/src/platforms/weex/util/parser.js
+++ b/src/platforms/weex/util/parser.ts
@@ -8,19 +8,22 @@ const acorn = require('acorn') // $flow-disable-line
 const walk = require('acorn/dist/walk') // $flow-disable-line
 const escodegen = require('escodegen')
 
-export function nodeToBinding (node: Object): any {
+export function nodeToBinding(node: any): any {
   switch (node.type) {
-    case 'Literal': return node.value
+    case 'Literal':
+      return node.value
     case 'Identifier':
     case 'UnaryExpression':
     case 'BinaryExpression':
     case 'LogicalExpression':
     case 'ConditionalExpression':
-    case 'MemberExpression': return { '@binding': escodegen.generate(node) }
-    case 'ArrayExpression': return node.elements.map(_ => nodeToBinding(_))
+    case 'MemberExpression':
+      return { '@binding': escodegen.generate(node) }
+    case 'ArrayExpression':
+      return node.elements.map((_) => nodeToBinding(_))
     case 'ObjectExpression': {
       const object = {}
-      node.properties.forEach(prop => {
+      node.properties.forEach((prop) => {
         if (!prop.key || prop.key.type !== 'Identifier') {
           return
         }
@@ -39,7 +42,7 @@ export function nodeToBinding (node: Object): any {
   }
 }
 
-export function generateBinding (exp: ?string): any {
+export function generateBinding(exp?: string): any {
   if (exp && typeof exp === 'string') {
     let ast = null
     try {
@@ -51,9 +54,9 @@ export function generateBinding (exp: ?string): any {
 
     let output = ''
     walk.simple(ast, {
-      Expression (node) {
+      Expression(node) {
         output = nodeToBinding(node)
-      }
+      },
     })
     return output
   }
diff --git a/src/server/bundle-renderer/create-bundle-renderer.js b/src/server/bundle-renderer/create-bundle-renderer.ts
similarity index 57%
rename from src/server/bundle-renderer/create-bundle-renderer.js
rename to src/server/bundle-renderer/create-bundle-renderer.ts
index 05c60c35740..83e192e70ec 100644
--- a/src/server/bundle-renderer/create-bundle-renderer.js
+++ b/src/server/bundle-renderer/create-bundle-renderer.ts
@@ -3,7 +3,10 @@
 import { createPromiseCallback } from '../util'
 import { createBundleRunner } from './create-bundle-runner'
 import type { Renderer, RenderOptions } from '../create-renderer'
-import { createSourceMapConsumers, rewriteErrorTrace } from './source-map-support'
+import {
+  createSourceMapConsumers,
+  rewriteErrorTrace,
+} from './source-map-support'
 
 const fs = require('fs')
 const path = require('path')
@@ -12,7 +15,7 @@ const PassThrough = require('stream').PassThrough
 const INVALID_MSG =
   'Invalid server-rendering bundle format. Should be a string ' +
   'or a bundle Object of type:\n\n' +
-`{
+  `{
   entry: string;
   files: { [filename: string]: string; };
   maps: { [filename: string]: string; };
@@ -21,19 +24,19 @@ const INVALID_MSG =
 // The render bundle can either be a string (single bundled file)
 // or a bundle manifest object generated by vue-ssr-webpack-plugin.
 type RenderBundle = {
-  basedir?: string;
-  entry: string;
-  files: { [filename: string]: string; };
-  maps: { [filename: string]: string; };
-  modules?: { [filename: string]: Array<string> };
-};
+  basedir?: string
+  entry: string
+  files: { [filename: string]: string }
+  maps: { [filename: string]: string }
+  modules?: { [filename: string]: Array<string> }
+}
 
-export function createBundleRendererCreator (
+export function createBundleRendererCreator(
   createRenderer: (options?: RenderOptions) => Renderer
 ) {
-  return function createBundleRenderer (
+  return function createBundleRenderer(
     bundle: string | RenderBundle,
-    rendererOptions?: RenderOptions = {}
+    rendererOptions: RenderOptions = {}
   ) {
     let files, entry, maps
     let basedir = rendererOptions.basedir
@@ -50,6 +53,7 @@ export function createBundleRendererCreator (
         bundle = fs.readFileSync(bundle, 'utf-8')
         if (isJSON) {
           try {
+            // @ts-expect-error
             bundle = JSON.parse(bundle)
           } catch (e) {
             throw new Error(`Invalid JSON bundle file: ${bundle}`)
@@ -70,7 +74,7 @@ export function createBundleRendererCreator (
       }
     } else if (typeof bundle === 'string') {
       entry = '__vue_ssr_bundle__'
-      files = { '__vue_ssr_bundle__': bundle }
+      files = { __vue_ssr_bundle__: bundle }
       maps = {}
     } else {
       throw new Error(INVALID_MSG)
@@ -86,7 +90,7 @@ export function createBundleRendererCreator (
     )
 
     return {
-      renderToString: (context?: Object, cb: any) => {
+      renderToString: (context: Object | undefined, cb: any) => {
         if (typeof context === 'function') {
           cb = context
           context = {}
@@ -94,58 +98,64 @@ export function createBundleRendererCreator (
 
         let promise
         if (!cb) {
-          ({ promise, cb } = createPromiseCallback())
+          ;({ promise, cb } = createPromiseCallback())
         }
 
-        run(context).catch(err => {
-          rewriteErrorTrace(err, maps)
-          cb(err)
-        }).then(app => {
-          if (app) {
-            renderer.renderToString(app, context, (err, res) => {
-              rewriteErrorTrace(err, maps)
-              cb(err, res)
-            })
-          }
-        })
+        run(context)
+          .catch((err) => {
+            rewriteErrorTrace(err, maps)
+            cb(err)
+          })
+          .then((app) => {
+            if (app) {
+              //@ts-expect-error
+              renderer.renderToString(app, context, (err, res) => {
+                rewriteErrorTrace(err, maps)
+                cb(err, res)
+              })
+            }
+          })
 
         return promise
       },
 
       renderToStream: (context?: Object) => {
         const res = new PassThrough()
-        run(context).catch(err => {
-          rewriteErrorTrace(err, maps)
-          // avoid emitting synchronously before user can
-          // attach error listener
-          process.nextTick(() => {
-            res.emit('error', err)
-          })
-        }).then(app => {
-          if (app) {
-            const renderStream = renderer.renderToStream(app, context)
-
-            renderStream.on('error', err => {
-              rewriteErrorTrace(err, maps)
+        run(context)
+          .catch((err) => {
+            rewriteErrorTrace(err, maps)
+            // avoid emitting synchronously before user can
+            // attach error listener
+            process.nextTick(() => {
               res.emit('error', err)
             })
-
-            // relay HTMLStream special events
-            if (rendererOptions && rendererOptions.template) {
-              renderStream.on('beforeStart', () => {
-                res.emit('beforeStart')
-              })
-              renderStream.on('beforeEnd', () => {
-                res.emit('beforeEnd')
+          })
+          .then((app) => {
+            if (app) {
+              //@ts-expect-error
+              const renderStream = renderer.renderToStream(app, context)
+
+              renderStream.on('error', (err) => {
+                rewriteErrorTrace(err, maps)
+                res.emit('error', err)
               })
-            }
 
-            renderStream.pipe(res)
-          }
-        })
+              // relay HTMLStream special events
+              if (rendererOptions && rendererOptions.template) {
+                renderStream.on('beforeStart', () => {
+                  res.emit('beforeStart')
+                })
+                renderStream.on('beforeEnd', () => {
+                  res.emit('beforeEnd')
+                })
+              }
+
+              renderStream.pipe(res)
+            }
+          })
 
         return res
-      }
+      },
     }
   }
 }
diff --git a/src/server/bundle-renderer/create-bundle-runner.js b/src/server/bundle-renderer/create-bundle-runner.js
deleted file mode 100644
index 16c33c4152e..00000000000
--- a/src/server/bundle-renderer/create-bundle-runner.js
+++ /dev/null
@@ -1,150 +0,0 @@
-import { isPlainObject } from 'shared/util'
-
-const vm = require('vm')
-const path = require('path')
-const resolve = require('resolve')
-const NativeModule = require('module')
-
-function createSandbox (context) {
-  const sandbox = {
-    Buffer,
-    console,
-    process,
-    setTimeout,
-    setInterval,
-    setImmediate,
-    clearTimeout,
-    clearInterval,
-    clearImmediate,
-    __VUE_SSR_CONTEXT__: context
-  }
-  sandbox.global = sandbox
-  return sandbox
-}
-
-function compileModule (files, basedir, runInNewContext) {
-  const compiledScripts = {}
-  const resolvedModules = {}
-
-  function getCompiledScript (filename) {
-    if (compiledScripts[filename]) {
-      return compiledScripts[filename]
-    }
-    const code = files[filename]
-    const wrapper = NativeModule.wrap(code)
-    const script = new vm.Script(wrapper, {
-      filename,
-      displayErrors: true
-    })
-    compiledScripts[filename] = script
-    return script
-  }
-
-  function evaluateModule (filename, sandbox, evaluatedFiles = {}) {
-    if (evaluatedFiles[filename]) {
-      return evaluatedFiles[filename]
-    }
-
-    const script = getCompiledScript(filename)
-    const compiledWrapper = runInNewContext === false
-      ? script.runInThisContext()
-      : script.runInNewContext(sandbox)
-    const m = { exports: {}}
-    const r = file => {
-      file = path.posix.join('.', file)
-      if (files[file]) {
-        return evaluateModule(file, sandbox, evaluatedFiles)
-      } else if (basedir) {
-        return require(
-          resolvedModules[file] ||
-          (resolvedModules[file] = resolve.sync(file, { basedir }))
-        )
-      } else {
-        return require(file)
-      }
-    }
-    compiledWrapper.call(m.exports, m.exports, r, m)
-
-    const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-      ? m.exports.default
-      : m.exports
-    evaluatedFiles[filename] = res
-    return res
-  }
-  return evaluateModule
-}
-
-function deepClone (val) {
-  if (isPlainObject(val)) {
-    const res = {}
-    for (const key in val) {
-      res[key] = deepClone(val[key])
-    }
-    return res
-  } else if (Array.isArray(val)) {
-    return val.slice()
-  } else {
-    return val
-  }
-}
-
-export function createBundleRunner (entry, files, basedir, runInNewContext) {
-  const evaluate = compileModule(files, basedir, runInNewContext)
-  if (runInNewContext !== false && runInNewContext !== 'once') {
-    // new context mode: creates a fresh context and re-evaluate the bundle
-    // on each render. Ensures entire application state is fresh for each
-    // render, but incurs extra evaluation cost.
-    return (userContext = {}) => new Promise(resolve => {
-      userContext._registeredComponents = new Set()
-      const res = evaluate(entry, createSandbox(userContext))
-      resolve(typeof res === 'function' ? res(userContext) : res)
-    })
-  } else {
-    // direct mode: instead of re-evaluating the whole bundle on
-    // each render, it simply calls the exported function. This avoids the
-    // module evaluation costs but requires the source code to be structured
-    // slightly differently.
-    let runner // lazy creation so that errors can be caught by user
-    let initialContext
-    return (userContext = {}) => new Promise(resolve => {
-      if (!runner) {
-        const sandbox = runInNewContext === 'once'
-          ? createSandbox()
-          : global
-        // the initial context is only used for collecting possible non-component
-        // styles injected by vue-style-loader.
-        initialContext = sandbox.__VUE_SSR_CONTEXT__ = {}
-        runner = evaluate(entry, sandbox)
-        // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-        // to prevent cross-request pollution.
-        delete sandbox.__VUE_SSR_CONTEXT__
-        if (typeof runner !== 'function') {
-          throw new Error(
-            'bundle export should be a function when using ' +
-            '{ runInNewContext: false }.'
-          )
-        }
-      }
-      userContext._registeredComponents = new Set()
-
-      // vue-style-loader styles imported outside of component lifecycle hooks
-      if (initialContext._styles) {
-        userContext._styles = deepClone(initialContext._styles)
-        // #6353 ensure "styles" is exposed even if no styles are injected
-        // in component lifecycles.
-        // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-        const renderStyles = initialContext._renderStyles
-        if (renderStyles) {
-          Object.defineProperty(userContext, 'styles', {
-            enumerable: true,
-            get () {
-              return renderStyles(userContext._styles)
-            }
-          })
-        }
-      }
-
-      resolve(runner(userContext))
-    })
-  }
-}
diff --git a/src/server/bundle-renderer/create-bundle-runner.ts b/src/server/bundle-renderer/create-bundle-runner.ts
new file mode 100644
index 00000000000..e61fa67f22d
--- /dev/null
+++ b/src/server/bundle-renderer/create-bundle-runner.ts
@@ -0,0 +1,158 @@
+import { isPlainObject } from 'shared/util'
+
+const vm = require('vm')
+const path = require('path')
+const resolve = require('resolve')
+const NativeModule = require('module')
+
+function createSandbox(context?: any) {
+  const sandbox = {
+    Buffer,
+    console,
+    process,
+    setTimeout,
+    setInterval,
+    setImmediate,
+    clearTimeout,
+    clearInterval,
+    clearImmediate,
+    __VUE_SSR_CONTEXT__: context,
+  }
+
+  // @ts-expect-error
+  sandbox.global = sandbox
+  return sandbox
+}
+
+function compileModule(files, basedir, runInNewContext) {
+  const compiledScripts = {}
+  const resolvedModules = {}
+
+  function getCompiledScript(filename) {
+    if (compiledScripts[filename]) {
+      return compiledScripts[filename]
+    }
+    const code = files[filename]
+    const wrapper = NativeModule.wrap(code)
+    const script = new vm.Script(wrapper, {
+      filename,
+      displayErrors: true,
+    })
+    compiledScripts[filename] = script
+    return script
+  }
+
+  function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
+    if (evaluatedFiles[filename]) {
+      return evaluatedFiles[filename]
+    }
+
+    const script = getCompiledScript(filename)
+    const compiledWrapper =
+      runInNewContext === false
+        ? script.runInThisContext()
+        : script.runInNewContext(sandbox)
+    const m = { exports: {} }
+    const r = (file) => {
+      file = path.posix.join('.', file)
+      if (files[file]) {
+        return evaluateModule(file, sandbox, evaluatedFiles)
+      } else if (basedir) {
+        return require(resolvedModules[file] ||
+          (resolvedModules[file] = resolve.sync(file, { basedir })))
+      } else {
+        return require(file)
+      }
+    }
+    compiledWrapper.call(m.exports, m.exports, r, m)
+
+    const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
+      ? // @ts-expect-error
+        m.exports.default
+      : m.exports
+    evaluatedFiles[filename] = res
+    return res
+  }
+  return evaluateModule
+}
+
+function deepClone(val) {
+  if (isPlainObject(val)) {
+    const res = {}
+    for (const key in val) {
+      res[key] = deepClone(val[key])
+    }
+    return res
+  } else if (Array.isArray(val)) {
+    return val.slice()
+  } else {
+    return val
+  }
+}
+
+export function createBundleRunner(entry, files, basedir, runInNewContext) {
+  const evaluate = compileModule(files, basedir, runInNewContext)
+  if (runInNewContext !== false && runInNewContext !== 'once') {
+    // new context mode: creates a fresh context and re-evaluate the bundle
+    // on each render. Ensures entire application state is fresh for each
+    // render, but incurs extra evaluation cost.
+    return (userContext = {}) =>
+      new Promise((resolve) => {
+        // @ts-expect-error
+        userContext._registeredComponents = new Set()
+        const res = evaluate(entry, createSandbox(userContext))
+        resolve(typeof res === 'function' ? res(userContext) : res)
+      })
+  } else {
+    // direct mode: instead of re-evaluating the whole bundle on
+    // each render, it simply calls the exported function. This avoids the
+    // module evaluation costs but requires the source code to be structured
+    // slightly differently.
+    let runner // lazy creation so that errors can be caught by user
+    let initialContext
+    return (userContext = {}) =>
+      new Promise((resolve) => {
+        if (!runner) {
+          const sandbox = runInNewContext === 'once' ? createSandbox() : global
+          // the initial context is only used for collecting possible non-component
+          // styles injected by vue-style-loader.
+          // @ts-expect-error
+          initialContext = sandbox.__VUE_SSR_CONTEXT__ = {}
+          runner = evaluate(entry, sandbox)
+          // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+          // to prevent cross-request pollution.
+          // @ts-expect-error
+          delete sandbox.__VUE_SSR_CONTEXT__
+          if (typeof runner !== 'function') {
+            throw new Error(
+              'bundle export should be a function when using ' +
+                '{ runInNewContext: false }.'
+            )
+          }
+        }
+        // @ts-expect-error
+        userContext._registeredComponents = new Set()
+
+        // vue-style-loader styles imported outside of component lifecycle hooks
+        if (initialContext._styles) {
+          // @ts-expect-error
+          userContext._styles = deepClone(initialContext._styles)
+          // #6353 ensure "styles" is exposed even if no styles are injected
+          // in component lifecycles.
+          // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+          const renderStyles = initialContext._renderStyles
+          if (renderStyles) {
+            Object.defineProperty(userContext, 'styles', {
+              enumerable: true,
+              get() {
+                // @ts-expect-error
+                return renderStyles(userContext._styles)
+              },
+            })
+          }
+        }
+
+        resolve(runner(userContext))
+      })
+  }
+}
diff --git a/src/server/bundle-renderer/source-map-support.js b/src/server/bundle-renderer/source-map-support.ts
similarity index 52%
rename from src/server/bundle-renderer/source-map-support.js
rename to src/server/bundle-renderer/source-map-support.ts
index 1010532e49c..0990afba57b 100644
--- a/src/server/bundle-renderer/source-map-support.js
+++ b/src/server/bundle-renderer/source-map-support.ts
@@ -4,37 +4,49 @@ const SourceMapConsumer = require('source-map').SourceMapConsumer
 
 const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/
 
-export function createSourceMapConsumers (rawMaps: Object) {
+export function createSourceMapConsumers(rawMaps: Object) {
   const maps = {}
-  Object.keys(rawMaps).forEach(file => {
+  Object.keys(rawMaps).forEach((file) => {
     maps[file] = new SourceMapConsumer(rawMaps[file])
   })
   return maps
 }
 
-export function rewriteErrorTrace (e: any, mapConsumers: {
-  [key: string]: SourceMapConsumer
-}) {
+export function rewriteErrorTrace(
+  e: any,
+  mapConsumers: {
+    [key: string]: typeof SourceMapConsumer
+  }
+) {
   if (e && typeof e.stack === 'string') {
-    e.stack = e.stack.split('\n').map(line => {
-      return rewriteTraceLine(line, mapConsumers)
-    }).join('\n')
+    e.stack = e.stack
+      .split('\n')
+      .map((line) => {
+        return rewriteTraceLine(line, mapConsumers)
+      })
+      .join('\n')
   }
 }
 
-function rewriteTraceLine (trace: string, mapConsumers: {
-  [key: string]: SourceMapConsumer
-}) {
+function rewriteTraceLine(
+  trace: string,
+  mapConsumers: {
+    [key: string]: typeof SourceMapConsumer
+  }
+) {
   const m = trace.match(filenameRE)
   const map = m && mapConsumers[m[1]]
   if (m != null && map) {
     const originalPosition = map.originalPositionFor({
       line: Number(m[2]),
-      column: Number(m[3])
+      column: Number(m[3]),
     })
     if (originalPosition.source != null) {
       const { source, line, column } = originalPosition
-      const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`
+      const mappedPosition = `(${source.replace(
+        /^webpack:\/\/\//,
+        ''
+      )}:${String(line)}:${String(column)})`
       return trace.replace(filenameRE, mappedPosition)
     } else {
       return trace
diff --git a/src/server/create-basic-renderer.js b/src/server/create-basic-renderer.ts
similarity index 74%
rename from src/server/create-basic-renderer.js
rename to src/server/create-basic-renderer.ts
index 2d53976d8d5..e5f12bde60c 100644
--- a/src/server/create-basic-renderer.js
+++ b/src/server/create-basic-renderer.ts
@@ -3,16 +3,17 @@
 import { createWriteFunction } from './write'
 import { createRenderFunction } from './render'
 import type { RenderOptions } from './create-renderer'
+import { Component } from 'typescript/component'
 
-export function createBasicRenderer ({
+export function createBasicRenderer({
   modules = [],
   directives = {},
-  isUnaryTag = (() => false),
-  cache
+  isUnaryTag = () => false,
+  cache,
 }: RenderOptions = {}) {
   const render = createRenderFunction(modules, directives, isUnaryTag, cache)
 
-  return function renderToString (
+  return function renderToString(
     component: Component,
     context: any,
     done: any
@@ -22,11 +23,12 @@ export function createBasicRenderer ({
       context = {}
     }
     let result = ''
-    const write = createWriteFunction(text => {
+    const write = createWriteFunction((text) => {
       result += text
       return false
     }, done)
     try {
+      //@ts-expect-error
       render(component, write, context, () => {
         done(null, result)
       })
diff --git a/src/server/create-renderer.js b/src/server/create-renderer.ts
similarity index 62%
rename from src/server/create-renderer.js
rename to src/server/create-renderer.ts
index 502b6fa6d1d..a716553ba51 100644
--- a/src/server/create-renderer.js
+++ b/src/server/create-renderer.ts
@@ -6,61 +6,70 @@ import { createRenderFunction } from './render'
 import { createPromiseCallback } from './util'
 import TemplateRenderer from './template-renderer/index'
 import type { ClientManifest } from './template-renderer/index'
+import { Component } from 'typescript/component'
+import VNode from 'core/vdom/vnode'
+import { Readable } from 'stream'
 
 export type Renderer = {
-  renderToString: (component: Component, context: any, cb: any) => ?Promise<string>;
-  renderToStream: (component: Component, context?: Object) => stream$Readable;
-};
+  renderToString: (
+    component: Component,
+    context: any,
+    cb: any
+  ) => Promise<string> | undefined
+  renderToStream: (component: Component, context?: Object) => Readable
+}
 
 type RenderCache = {
-  get: (key: string, cb?: Function) => string | void;
-  set: (key: string, val: string) => void;
-  has?: (key: string, cb?: Function) => boolean | void;
-};
+  get: (key: string, cb?: Function) => string | void
+  set: (key: string, val: string) => void
+  has?: (key: string, cb?: Function) => boolean | void
+}
 
 export type RenderOptions = {
-  modules?: Array<(vnode: VNode) => ?string>;
-  directives?: Object;
-  isUnaryTag?: Function;
-  cache?: RenderCache;
-  template?: string | (content: string, context: any) => string;
-  inject?: boolean;
-  basedir?: string;
-  shouldPreload?: Function;
-  shouldPrefetch?: Function;
-  clientManifest?: ClientManifest;
-  serializer?: Function;
-  runInNewContext?: boolean | 'once';
-};
+  modules?: Array<(vnode: VNode) => string | null>
+  directives?: Object
+  isUnaryTag?: Function
+  cache?: RenderCache
+  template?: string | ((content: string, context: any) => string)
+  inject?: boolean
+  basedir?: string
+  shouldPreload?: Function
+  shouldPrefetch?: Function
+  clientManifest?: ClientManifest
+  serializer?: Function
+  runInNewContext?: boolean | 'once'
+}
 
-export function createRenderer ({
+export function createRenderer({
   modules = [],
   directives = {},
-  isUnaryTag = (() => false),
+  isUnaryTag = () => false,
   template,
   inject,
   cache,
   shouldPreload,
   shouldPrefetch,
   clientManifest,
-  serializer
+  serializer,
 }: RenderOptions = {}): Renderer {
   const render = createRenderFunction(modules, directives, isUnaryTag, cache)
   const templateRenderer = new TemplateRenderer({
     template,
     inject,
+    // @ts-expect-error
     shouldPreload,
+    // @ts-expect-error
     shouldPrefetch,
     clientManifest,
-    serializer
+    serializer,
   })
 
   return {
-    renderToString (
+    renderToString(
       component: Component,
       context: any,
       cb: any
-    ): ?Promise<string> {
+    ): Promise<string> {
       if (typeof context === 'function') {
         cb = context
         context = {}
@@ -72,16 +81,17 @@ export function createRenderer ({
       // no callback, return Promise
       let promise
       if (!cb) {
-        ({ promise, cb } = createPromiseCallback())
+        ;({ promise, cb } = createPromiseCallback())
       }
 
       let result = ''
-      const write = createWriteFunction(text => {
+      const write = createWriteFunction((text) => {
         result += text
         return false
       }, cb)
       try {
-        render(component, write, context, err => {
+        // @ts-expect-error TODO improve
+        render(component, write, context, (err) => {
           if (err) {
             return cb(err)
           }
@@ -93,9 +103,7 @@ export function createRenderer ({
               const res = templateRenderer.render(result, context)
               if (typeof res !== 'string') {
                 // function template returning promise
-                res
-                  .then(html => cb(null, html))
-                  .catch(cb)
+                res.then((html) => cb(null, html)).catch(cb)
               } else {
                 cb(null, res)
               }
@@ -113,18 +121,18 @@ export function createRenderer ({
       return promise
     },
 
-    renderToStream (
-      component: Component,
-      context?: Object
-    ): stream$Readable {
+    renderToStream(component: Component, context?: Object): Readable {
       if (context) {
         templateRenderer.bindRenderFns(context)
       }
       const renderStream = new RenderStream((write, done) => {
+        // @ts-expect-error
         render(component, write, context, done)
       })
       if (!template) {
+        // @ts-expect-error
         if (context && context.rendered) {
+          // @ts-expect-error
           const rendered = context.rendered
           renderStream.once('beforeEnd', () => {
             rendered(context)
@@ -132,14 +140,18 @@ export function createRenderer ({
         }
         return renderStream
       } else if (typeof template === 'function') {
-        throw new Error(`function template is only supported in renderToString.`)
+        throw new Error(
+          `function template is only supported in renderToString.`
+        )
       } else {
         const templateStream = templateRenderer.createStream(context)
-        renderStream.on('error', err => {
+        renderStream.on('error', (err) => {
           templateStream.emit('error', err)
         })
         renderStream.pipe(templateStream)
+        //@ts-expect-error
         if (context && context.rendered) {
+          //@ts-expect-error
           const rendered = context.rendered
           renderStream.once('beforeEnd', () => {
             rendered(context)
@@ -147,6 +159,6 @@ export function createRenderer ({
         }
         return templateStream
       }
-    }
+    },
   }
 }
diff --git a/src/server/optimizing-compiler/codegen.js b/src/server/optimizing-compiler/codegen.ts
similarity index 78%
rename from src/server/optimizing-compiler/codegen.js
rename to src/server/optimizing-compiler/codegen.ts
index 9399761383a..5d40663a268 100644
--- a/src/server/optimizing-compiler/codegen.js
+++ b/src/server/optimizing-compiler/codegen.ts
@@ -11,7 +11,7 @@ import {
   genText,
   genElement,
   genChildren,
-  CodegenState
+  CodegenState,
 } from 'compiler/codegen/index'
 
 import {
@@ -19,7 +19,7 @@ import {
   genDOMPropSegments,
   genClassSegments,
   genStyleSegments,
-  applyModelTransform
+  applyModelTransform,
 } from './modules'
 
 import { escape } from 'web/server/util'
@@ -27,16 +27,16 @@ import { optimizability } from './optimizer'
 import type { CodegenResult } from 'compiler/codegen/index'
 
 export type StringSegment = {
-  type: number;
-  value: string;
-};
+  type: number
+  value: string
+}
 
 // segment types
 export const RAW = 0
 export const INTERPOLATION = 1
 export const EXPRESSION = 2
 
-export function generate (
+export function generate(
   ast: ASTElement | void,
   options: CompilerOptions
 ): CodegenResult {
@@ -44,11 +44,11 @@ export function generate (
   const code = ast ? genSSRElement(ast, state) : '_c("div")'
   return {
     render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns
+    staticRenderFns: state.staticRenderFns,
   }
 }
 
-function genSSRElement (el: ASTElement, state: CodegenState): string {
+function genSSRElement(el: ASTElement, state: CodegenState): string {
   if (el.for && !el.forProcessed) {
     return genFor(el, state, genSSRElement)
   } else if (el.if && !el.ifProcessed) {
@@ -78,65 +78,63 @@ function genSSRElement (el: ASTElement, state: CodegenState): string {
   }
 }
 
-function genNormalElement (el, state, stringifyChildren) {
+function genNormalElement(el, state, stringifyChildren) {
   const data = el.plain ? undefined : genData(el, state)
   const children = stringifyChildren
     ? `[${genChildrenAsStringNode(el, state)}]`
     : genSSRChildren(el, state, true)
-  return `_c('${el.tag}'${
-    data ? `,${data}` : ''
-  }${
+  return `_c('${el.tag}'${data ? `,${data}` : ''}${
     children ? `,${children}` : ''
   })`
 }
 
-function genSSRChildren (el, state, checkSkip) {
+function genSSRChildren(el, state, checkSkip?: boolean) {
   return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
 }
 
-function genSSRNode (el, state) {
-  return el.type === 1
-    ? genSSRElement(el, state)
-    : genText(el)
+function genSSRNode(el, state) {
+  return el.type === 1 ? genSSRElement(el, state) : genText(el)
 }
 
-function genChildrenAsStringNode (el, state) {
+function genChildrenAsStringNode(el, state) {
   return el.children.length
     ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
     : ''
 }
 
-function genStringElement (el, state) {
+function genStringElement(el, state) {
   return `_ssrNode(${elementToString(el, state)})`
 }
 
-function genStringElementWithChildren (el, state) {
+function genStringElementWithChildren(el, state) {
   const children = genSSRChildren(el, state, true)
-  return `_ssrNode(${
-    flattenSegments(elementToOpenTagSegments(el, state))
-  },"</${el.tag}>"${
-    children ? `,${children}` : ''
-  })`
+  return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${
+    el.tag
+  }>"${children ? `,${children}` : ''})`
 }
 
-function elementToString (el, state) {
+function elementToString(el, state) {
   return `(${flattenSegments(elementToSegments(el, state))})`
 }
 
-function elementToSegments (el, state): Array<StringSegment> {
+function elementToSegments(el, state): Array<StringSegment> {
   // v-for / v-if
   if (el.for && !el.forProcessed) {
     el.forProcessed = true
-    return [{
-      type: EXPRESSION,
-      value: genFor(el, state, elementToString, '_ssrList')
-    }]
+    return [
+      {
+        type: EXPRESSION,
+        value: genFor(el, state, elementToString, '_ssrList'),
+      },
+    ]
   } else if (el.if && !el.ifProcessed) {
     el.ifProcessed = true
-    return [{
-      type: EXPRESSION,
-      value: genIf(el, state, elementToString, '"<!---->"')
-    }]
+    return [
+      {
+        type: EXPRESSION,
+        value: genIf(el, state, elementToString, '"<!---->"'),
+      },
+    ]
   } else if (el.tag === 'template') {
     return childrenToSegments(el, state)
   }
@@ -144,13 +142,14 @@ function elementToSegments (el, state): Array<StringSegment> {
   const openSegments = elementToOpenTagSegments(el, state)
   const childrenSegments = childrenToSegments(el, state)
   const { isUnaryTag } = state.options
-  const close = (isUnaryTag && isUnaryTag(el.tag))
-    ? []
-    : [{ type: RAW, value: `</${el.tag}>` }]
+  const close =
+    isUnaryTag && isUnaryTag(el.tag)
+      ? []
+      : [{ type: RAW, value: `</${el.tag}>` }]
   return openSegments.concat(childrenSegments, close)
 }
 
-function elementToOpenTagSegments (el, state): Array<StringSegment> {
+function elementToOpenTagSegments(el, state): Array<StringSegment> {
   applyModelTransform(el, state)
   let binding
   const segments = [{ type: RAW, value: `<${el.tag}` }]
@@ -197,7 +196,7 @@ function elementToOpenTagSegments (el, state): Array<StringSegment> {
   return segments
 }
 
-function childrenToSegments (el, state): Array<StringSegment> {
+function childrenToSegments(el, state): Array<StringSegment> {
   let binding
   if ((binding = el.attrsMap['v-html'])) {
     return [{ type: EXPRESSION, value: `_s(${binding})` }]
@@ -208,16 +207,14 @@ function childrenToSegments (el, state): Array<StringSegment> {
   if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
     return [{ type: INTERPOLATION, value: `_s(${binding})` }]
   }
-  return el.children
-    ? nodesToSegments(el.children, state)
-    : []
+  return el.children ? nodesToSegments(el.children, state) : []
 }
 
-function nodesToSegments (
+function nodesToSegments(
   children: Array<ASTNode>,
   state: CodegenState
 ): Array<StringSegment> {
-  const segments = []
+  const segments: StringSegment[] = []
   for (let i = 0; i < children.length; i++) {
     const c = children[i]
     if (c.type === 1) {
@@ -235,8 +232,8 @@ function nodesToSegments (
   return segments
 }
 
-function flattenSegments (segments: Array<StringSegment>): string {
-  const mergedSegments = []
+function flattenSegments(segments: Array<StringSegment>): string {
+  const mergedSegments: string[] = []
   let textBuffer = ''
 
   const pushBuffer = () => {
diff --git a/src/server/optimizing-compiler/index.js b/src/server/optimizing-compiler/index.ts
similarity index 90%
rename from src/server/optimizing-compiler/index.js
rename to src/server/optimizing-compiler/index.ts
index 893630d670c..622875d4b68 100644
--- a/src/server/optimizing-compiler/index.js
+++ b/src/server/optimizing-compiler/index.ts
@@ -5,7 +5,7 @@ import { generate } from './codegen'
 import { optimize } from './optimizer'
 import { createCompilerCreator } from 'compiler/create-compiler'
 
-export const createCompiler = createCompilerCreator(function baseCompile (
+export const createCompiler = createCompilerCreator(function baseCompile(
   template: string,
   options: CompilerOptions
 ): CompiledResult {
@@ -15,6 +15,6 @@ export const createCompiler = createCompilerCreator(function baseCompile (
   return {
     ast,
     render: code.render,
-    staticRenderFns: code.staticRenderFns
+    staticRenderFns: code.staticRenderFns,
   }
 })
diff --git a/src/server/optimizing-compiler/modules.js b/src/server/optimizing-compiler/modules.ts
similarity index 52%
rename from src/server/optimizing-compiler/modules.js
rename to src/server/optimizing-compiler/modules.ts
index a1dcfe5e293..f6bf515368b 100644
--- a/src/server/optimizing-compiler/modules.js
+++ b/src/server/optimizing-compiler/modules.ts
@@ -3,18 +3,12 @@
 import {
   RAW,
   // INTERPOLATION,
-  EXPRESSION
+  EXPRESSION,
 } from './codegen'
 
-import {
-  propsToAttrMap,
-  isRenderableAttr
-} from 'web/server/util'
+import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
 
-import {
-  isBooleanAttr,
-  isEnumeratedAttr
-} from 'web/util/attrs'
+import { isBooleanAttr, isEnumeratedAttr } from 'web/util/attrs'
 
 import type { StringSegment } from './codegen'
 import type { CodegenState } from 'compiler/codegen/index'
@@ -23,7 +17,7 @@ const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
 
 // let the model AST transform translate v-model into appropriate
 // props bindings
-export function applyModelTransform (el: ASTElement, state: CodegenState) {
+export function applyModelTransform(el: ASTElement, state: CodegenState) {
   if (el.directives) {
     for (let i = 0; i < el.directives.length; i++) {
       const dir = el.directives[i]
@@ -31,7 +25,7 @@ export function applyModelTransform (el: ASTElement, state: CodegenState) {
         state.directives.model(el, dir, state.warn)
         // remove value for textarea as its converted to text
         if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(p => p.name !== 'value')
+          el.props = el.props.filter((p) => p.name !== 'value')
         }
         break
       }
@@ -39,21 +33,20 @@ export function applyModelTransform (el: ASTElement, state: CodegenState) {
   }
 }
 
-export function genAttrSegments (
-  attrs: Array<ASTAttr>
-): Array<StringSegment> {
+export function genAttrSegments(attrs: Array<ASTAttr>): Array<StringSegment> {
   return attrs.map(({ name, value }) => genAttrSegment(name, value))
 }
 
-export function genDOMPropSegments (
+export function genDOMPropSegments(
   props: Array<ASTAttr>,
-  attrs: ?Array<ASTAttr>
+  attrs: Array<ASTAttr> | null | undefined
 ): Array<StringSegment> {
-  const segments = []
+  const segments: StringSegment[] = []
   props.forEach(({ name, value }) => {
     name = propsToAttrMap[name] || name.toLowerCase()
-    if (isRenderableAttr(name) &&
-      !(attrs && attrs.some(a => a.name === name))
+    if (
+      isRenderableAttr(name) &&
+      !(attrs && attrs.some((a) => a.name === name))
     ) {
       segments.push(genAttrSegment(name, value))
     }
@@ -61,7 +54,7 @@ export function genDOMPropSegments (
   return segments
 }
 
-function genAttrSegment (name: string, value: string): StringSegment {
+function genAttrSegment(name: string, value: string): StringSegment {
   if (plainStringRE.test(value)) {
     // force double quote
     value = value.replace(/^'|'$/g, '"')
@@ -74,51 +67,53 @@ function genAttrSegment (name: string, value: string): StringSegment {
       value: isBooleanAttr(name)
         ? ` ${name}="${name}"`
         : value === '""'
-          ? ` ${name}`
-          : ` ${name}="${JSON.parse(value)}"`
+        ? ` ${name}`
+        : ` ${name}="${JSON.parse(value)}"`,
     }
   } else {
     return {
       type: EXPRESSION,
-      value: `_ssrAttr(${JSON.stringify(name)},${value})`
+      value: `_ssrAttr(${JSON.stringify(name)},${value})`,
     }
   }
 }
 
-export function genClassSegments (
-  staticClass: ?string,
-  classBinding: ?string
+export function genClassSegments(
+  staticClass: string | null | undefined,
+  classBinding: string | null | undefined
 ): Array<StringSegment> {
   if (staticClass && !classBinding) {
     return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }]
   } else {
-    return [{
-      type: EXPRESSION,
-      value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`
-    }]
+    return [
+      {
+        type: EXPRESSION,
+        value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+      },
+    ]
   }
 }
 
-export function genStyleSegments (
-  staticStyle: ?string,
-  parsedStaticStyle: ?string,
-  styleBinding: ?string,
-  vShowExpression: ?string
+export function genStyleSegments(
+  staticStyle: string | null | undefined,
+  parsedStaticStyle: string | null | undefined,
+  styleBinding: string | null | undefined,
+  vShowExpression: string | null | undefined
 ): Array<StringSegment> {
   if (staticStyle && !styleBinding && !vShowExpression) {
     return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }]
   } else {
-    return [{
-      type: EXPRESSION,
-      value: `_ssrStyle(${
-        parsedStaticStyle || 'null'
-      },${
-        styleBinding || 'null'
-      }, ${
-        vShowExpression
-          ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-          : 'null'
-      })`
-    }]
+    return [
+      {
+        type: EXPRESSION,
+        value: `_ssrStyle(${parsedStaticStyle || 'null'},${
+          styleBinding || 'null'
+        }, ${
+          vShowExpression
+            ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+            : 'null'
+        })`,
+      },
+    ]
   }
 }
diff --git a/src/server/optimizing-compiler/optimizer.js b/src/server/optimizing-compiler/optimizer.ts
similarity index 77%
rename from src/server/optimizing-compiler/optimizer.js
rename to src/server/optimizing-compiler/optimizer.ts
index d89cbd0a451..c9134d012e8 100644
--- a/src/server/optimizing-compiler/optimizer.js
+++ b/src/server/optimizing-compiler/optimizer.ts
@@ -14,29 +14,29 @@ import { no, makeMap, isBuiltInTag } from 'shared/util'
 
 // optimizability constants
 export const optimizability = {
-  FALSE: 0,    // whole sub tree un-optimizable
-  FULL: 1,     // whole sub tree optimizable
-  SELF: 2,     // self optimizable but has some un-optimizable children
+  FALSE: 0, // whole sub tree un-optimizable
+  FULL: 1, // whole sub tree optimizable
+  SELF: 2, // self optimizable but has some un-optimizable children
   CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4   // self un-optimizable with some un-optimizable children
+  PARTIAL: 4, // self un-optimizable with some un-optimizable children
 }
 
 let isPlatformReservedTag
 
-export function optimize (root: ?ASTElement, options: CompilerOptions) {
+export function optimize(root: ASTElement | null, options: CompilerOptions) {
   if (!root) return
   isPlatformReservedTag = options.isReservedTag || no
   walk(root, true)
 }
 
-function walk (node: ASTNode, isRoot?: boolean) {
+function walk(node: ASTNode, isRoot?: boolean) {
   if (isUnOptimizableTree(node)) {
     node.ssrOptimizability = optimizability.FALSE
     return
   }
   // root node or nodes with custom directives should always be a VNode
   const selfUnoptimizable = isRoot || hasCustomDirective(node)
-  const check = child => {
+  const check = (child) => {
     if (child.ssrOptimizability !== optimizability.FULL) {
       node.ssrOptimizability = selfUnoptimizable
         ? optimizability.PARTIAL
@@ -59,7 +59,8 @@ function walk (node: ASTNode, isRoot?: boolean) {
         check(block)
       }
     }
-    if (node.ssrOptimizability == null ||
+    if (
+      node.ssrOptimizability == null ||
       (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
     ) {
       node.ssrOptimizability = optimizability.FULL
@@ -71,11 +72,11 @@ function walk (node: ASTNode, isRoot?: boolean) {
   }
 }
 
-function optimizeSiblings (el) {
+function optimizeSiblings(el) {
   const children = el.children
-  const optimizedChildren = []
+  const optimizedChildren: any[] = []
 
-  let currentOptimizableGroup = []
+  let currentOptimizableGroup: any[] = []
   const pushGroup = () => {
     if (currentOptimizableGroup.length) {
       optimizedChildren.push({
@@ -86,7 +87,7 @@ function optimizeSiblings (el) {
         attrsMap: {},
         rawAttrsMap: {},
         children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
+        ssrOptimizability: optimizability.FULL,
       })
     }
     currentOptimizableGroup = []
@@ -107,8 +108,9 @@ function optimizeSiblings (el) {
   return optimizedChildren
 }
 
-function isUnOptimizableTree (node: ASTNode): boolean {
-  if (node.type === 2 || node.type === 3) { // text or expression
+function isUnOptimizableTree(node: ASTNode): boolean {
+  if (node.type === 2 || node.type === 3) {
+    // text or expression
     return false
   }
   return (
@@ -121,21 +123,19 @@ function isUnOptimizableTree (node: ASTNode): boolean {
 
 const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
 
-function hasCustomDirective (node: ASTNode): ?boolean {
-  return (
-    node.type === 1 &&
+function hasCustomDirective(node: ASTNode): boolean {
+  return (node.type === 1 &&
     node.directives &&
-    node.directives.some(d => !isBuiltInDir(d.name))
-  )
+    node.directives.some((d) => !isBuiltInDir(d.name))) as any
 }
 
 // <select v-model> cannot be optimized because it requires a runtime check
 // to determine proper selected option
-function isSelectWithModel (node: ASTNode): boolean {
+function isSelectWithModel(node: ASTNode): boolean {
   return (
     node.type === 1 &&
     node.tag === 'select' &&
     node.directives != null &&
-    node.directives.some(d => d.name === 'model')
+    node.directives.some((d) => d.name === 'model')
   )
 }
diff --git a/src/server/optimizing-compiler/runtime-helpers.js b/src/server/optimizing-compiler/runtime-helpers.ts
similarity index 73%
rename from src/server/optimizing-compiler/runtime-helpers.js
rename to src/server/optimizing-compiler/runtime-helpers.ts
index 6f65de04e59..56a25b16aaf 100644
--- a/src/server/optimizing-compiler/runtime-helpers.js
+++ b/src/server/optimizing-compiler/runtime-helpers.ts
@@ -9,13 +9,11 @@ import { normalizeStyleBinding } from 'web/util/style'
 
 import {
   normalizeChildren,
-  simpleNormalizeChildren
+  simpleNormalizeChildren,
 } from 'core/vdom/helpers/normalize-children'
 
-import {
-  propsToAttrMap,
-  isRenderableAttr
-} from 'web/server/util'
+import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
+import { Component } from 'typescript/component'
 
 const ssrHelpers = {
   _ssrEscape: escape,
@@ -25,30 +23,34 @@ const ssrHelpers = {
   _ssrAttrs: renderAttrs,
   _ssrDOMProps: renderDOMProps,
   _ssrClass: renderSSRClass,
-  _ssrStyle: renderSSRStyle
+  _ssrStyle: renderSSRStyle,
 }
 
-export function installSSRHelpers (vm: Component) {
+export function installSSRHelpers(vm: Component) {
   if (vm._ssrNode) {
     return
   }
   let Vue = vm.constructor
+  // @ts-expect-error
   while (Vue.super) {
+    // @ts-expect-error
     Vue = Vue.super
   }
   extend(Vue.prototype, ssrHelpers)
+  // @ts-expect-error
   if (Vue.FunctionalRenderContext) {
+    // @ts-expect-error
     extend(Vue.FunctionalRenderContext.prototype, ssrHelpers)
   }
 }
 
 class StringNode {
-  isString: boolean;
-  open: string;
-  close: ?string;
-  children: ?Array<any>;
+  isString: boolean
+  open: string
+  close: string | undefined
+  children: Array<any> | undefined
 
-  constructor (
+  constructor(
     open: string,
     close?: string,
     children?: Array<any>,
@@ -58,9 +60,10 @@ class StringNode {
     this.open = open
     this.close = close
     if (children) {
-      this.children = normalizationType === 1
-        ? simpleNormalizeChildren(children)
-        : normalizationType === 2
+      this.children =
+        normalizationType === 1
+          ? simpleNormalizeChildren(children)
+          : normalizationType === 2
           ? normalizeChildren(children)
           : children
     } else {
@@ -69,7 +72,7 @@ class StringNode {
   }
 }
 
-function renderStringNode (
+function renderStringNode(
   open: string,
   close?: string,
   children?: Array<any>,
@@ -78,13 +81,9 @@ function renderStringNode (
   return new StringNode(open, close, children, normalizationType)
 }
 
-function renderStringList (
+function renderStringList(
   val: any,
-  render: (
-    val: any,
-    keyOrIndex: string | number,
-    index?: number
-  ) => string
+  render: (val: any, keyOrIndex: string | number, index?: number) => string
 ): string {
   let ret = ''
   let i, l, keys, key
@@ -106,7 +105,7 @@ function renderStringList (
   return ret
 }
 
-function renderAttrs (obj: Object): string {
+function renderAttrs(obj: Object): string {
   let res = ''
   for (const key in obj) {
     if (isSSRUnsafeAttr(key)) {
@@ -117,7 +116,7 @@ function renderAttrs (obj: Object): string {
   return res
 }
 
-function renderDOMProps (obj: Object): string {
+function renderDOMProps(obj: Object): string {
   let res = ''
   for (const key in obj) {
     const attr = propsToAttrMap[key] || key.toLowerCase()
@@ -128,18 +127,15 @@ function renderDOMProps (obj: Object): string {
   return res
 }
 
-function renderSSRClass (
-  staticClass: ?string,
-  dynamic: any
-): string {
+function renderSSRClass(staticClass: string | null, dynamic: any): string {
   const res = renderClass(staticClass, dynamic)
   return res === '' ? res : ` class="${escape(res)}"`
 }
 
-function renderSSRStyle (
-  staticStyle: ?Object,
+function renderSSRStyle(
+  staticStyle: Record<string, any>,
   dynamic: any,
-  extra: ?Object
+  extra?: Record<string, any>
 ): string {
   const style = {}
   if (staticStyle) extend(style, staticStyle)
diff --git a/src/server/render-context.js b/src/server/render-context.ts
similarity index 67%
rename from src/server/render-context.js
rename to src/server/render-context.ts
index 3da91d0abca..519ca6d383e 100644
--- a/src/server/render-context.js
+++ b/src/server/render-context.ts
@@ -1,47 +1,54 @@
 /* @flow */
 
+import VNode from 'core/vdom/vnode'
 import { isUndef } from 'shared/util'
+import { Component } from 'typescript/component'
 
-type RenderState = {
-  type: 'Element';
-  rendered: number;
-  total: number;
-  children: Array<VNode>;
-  endTag: string;
-} | {
-  type: 'Fragment';
-  rendered: number;
-  total: number;
-  children: Array<VNode>;
-} | {
-  type: 'Component';
-  prevActive: Component;
-} | {
-  type: 'ComponentWithCache';
-  buffer: Array<string>;
-  bufferIndex: number;
-  componentBuffer: Array<Set<Class<Component>>>;
-  key: string;
-};
+type RenderState =
+  | {
+      type: 'Element'
+      rendered: number
+      total: number
+      children: Array<VNode>
+      endTag: string
+    }
+  | {
+      type: 'Fragment'
+      rendered: number
+      total: number
+      children: Array<VNode>
+    }
+  | {
+      type: 'Component'
+      prevActive: Component
+    }
+  | {
+      type: 'ComponentWithCache'
+      buffer: Array<string>
+      bufferIndex: number
+      componentBuffer: Array<Set<Component>>
+      key: string
+    }
 
 export class RenderContext {
-  userContext: ?Object;
-  activeInstance: Component;
-  renderStates: Array<RenderState>;
-  write: (text: string, next: Function) => void;
-  renderNode: (node: VNode, isRoot: boolean, context: RenderContext) => void;
-  next: () => void;
-  done: (err: ?Error) => void;
+  userContext: Record<string, any> | null
+  activeInstance: Component
+  renderStates: Array<RenderState>
+  write: (text: string, next: Function) => void
+  renderNode: (node: VNode, isRoot: boolean, context: RenderContext) => void
+  //@ts-expect-error
+  next: () => void
+  done: (err?: Error) => void
 
-  modules: Array<(node: VNode) => ?string>;
-  directives: Object;
-  isUnaryTag: (tag: string) => boolean;
+  modules: Array<(node: VNode) => string | null>
+  directives: Object
+  isUnaryTag: (tag: string) => boolean
 
-  cache: any;
-  get: ?(key: string, cb: Function) => void;
-  has: ?(key: string, cb: Function) => void;
+  cache: any
+  get?: (key: string, cb: Function) => void
+  has?: (key: string, cb: Function) => void
 
-  constructor (options: Object) {
+  constructor(options: Record<string, any>) {
     this.userContext = options.userContext
     this.activeInstance = options.activeInstance
     this.renderStates = []
@@ -62,10 +69,12 @@ export class RenderContext {
     this.get = cache && normalizeAsync(cache, 'get')
     this.has = cache && normalizeAsync(cache, 'has')
 
+    //@ts-expect-error
     this.next = this.next.bind(this)
   }
 
-  next () {
+  //@ts-expect-error
+  next() {
     // eslint-disable-next-line
     while (true) {
       const lastState = this.renderStates[this.renderStates.length - 1]
@@ -96,19 +105,20 @@ export class RenderContext {
           const { buffer, bufferIndex, componentBuffer, key } = lastState
           const result = {
             html: buffer[bufferIndex],
-            components: componentBuffer[bufferIndex]
+            components: componentBuffer[bufferIndex],
           }
           this.cache.set(key, result)
           if (bufferIndex === 0) {
             // this is a top-level cached component,
             // exit caching mode.
+            //@ts-expect-error
             this.write.caching = false
           } else {
             // parent component is also being cached,
             // merge self into parent's result
             buffer[bufferIndex - 1] += result.html
             const prev = componentBuffer[bufferIndex - 1]
-            result.components.forEach(c => prev.add(c))
+            result.components.forEach((c) => prev.add(c))
           }
           buffer.length = bufferIndex
           componentBuffer.length = bufferIndex
@@ -118,7 +128,7 @@ export class RenderContext {
   }
 }
 
-function normalizeAsync (cache, method) {
+function normalizeAsync(cache, method) {
   const fn = cache[method]
   if (isUndef(fn)) {
     return
diff --git a/src/server/render-stream.js b/src/server/render-stream.ts
similarity index 63%
rename from src/server/render-stream.js
rename to src/server/render-stream.ts
index bc358e20e95..361b3533925 100644
--- a/src/server/render-stream.js
+++ b/src/server/render-stream.ts
@@ -8,38 +8,45 @@
  * Modified by Evan You (@yyx990803)
  */
 
-const stream = require('stream')
+// const stream = require('stream')
+import { Readable } from 'stream'
 
 import { isTrue, isUndef } from 'shared/util'
 import { createWriteFunction } from './write'
 
-export default class RenderStream extends stream.Readable {
-  buffer: string;
-  render: (write: Function, done: Function) => void;
-  expectedSize: number;
-  write: Function;
-  next: Function;
-  end: Function;
-  done: boolean;
+export default class RenderStream extends Readable {
+  buffer: string
+  render: (write: Function, done: Function) => void
+  expectedSize: number
+  write: Function
+  //@ts-expect-error
+  next: Function
+  end: Function
+  //@ts-expect-error
+  done: boolean
 
-  constructor (render: Function) {
+  constructor(render: Function) {
     super()
     this.buffer = ''
+    //@ts-expect-error
     this.render = render
     this.expectedSize = 0
 
-    this.write = createWriteFunction((text, next) => {
-      const n = this.expectedSize
-      this.buffer += text
-      if (this.buffer.length >= n) {
-        this.next = next
-        this.pushBySize(n)
-        return true // we will decide when to call next
+    this.write = createWriteFunction(
+      (text, next) => {
+        const n = this.expectedSize
+        this.buffer += text
+        if (this.buffer.length >= n) {
+          this.next = next
+          this.pushBySize(n)
+          return true // we will decide when to call next
+        }
+        return false
+      },
+      (err) => {
+        this.emit('error', err)
       }
-      return false
-    }, err => {
-      this.emit('error', err)
-    })
+    )
 
     this.end = () => {
       this.emit('beforeEnd')
@@ -49,13 +56,13 @@ export default class RenderStream extends stream.Readable {
     }
   }
 
-  pushBySize (n: number) {
+  pushBySize(n: number) {
     const bufferToPush = this.buffer.substring(0, n)
     this.buffer = this.buffer.substring(n)
     this.push(bufferToPush)
   }
 
-  tryRender () {
+  tryRender() {
     try {
       this.render(this.write, this.end)
     } catch (e) {
@@ -63,7 +70,7 @@ export default class RenderStream extends stream.Readable {
     }
   }
 
-  tryNext () {
+  tryNext() {
     try {
       this.next()
     } catch (e) {
@@ -71,7 +78,7 @@ export default class RenderStream extends stream.Readable {
     }
   }
 
-  _read (n: number) {
+  _read(n: number) {
     this.expectedSize = n
     // it's possible that the last chunk added bumped the buffer up to > 2 * n,
     // which means we will need to go through multiple read calls to drain it
diff --git a/src/server/render.js b/src/server/render.ts
similarity index 80%
rename from src/server/render.js
rename to src/server/render.ts
index 05ba588006d..2ebe6f1bf74 100644
--- a/src/server/render.js
+++ b/src/server/render.ts
@@ -12,11 +12,14 @@ import { isDef, isUndef, isTrue } from 'shared/util'
 
 import {
   createComponent,
-  createComponentInstanceForVnode
+  createComponentInstanceForVnode,
 } from 'core/vdom/create-component'
+import VNode from 'core/vdom/vnode'
+import { VNodeDirective } from 'typescript/vnode'
+import { Component } from 'typescript/component'
 
 let warned = Object.create(null)
-const warnOnce = msg => {
+const warnOnce = (msg) => {
   if (!warned[msg]) {
     warned[msg] = true
     // eslint-disable-next-line no-console
@@ -29,14 +32,18 @@ const onCompilationError = (err, vm) => {
   throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`)
 }
 
-const normalizeRender = vm => {
+const normalizeRender = (vm) => {
   const { render, template, _scopeId } = vm.$options
   if (isUndef(render)) {
     if (template) {
-      const compiled = ssrCompileToFunctions(template, {
-        scopeId: _scopeId,
-        warn: onCompilationError
-      }, vm)
+      const compiled = ssrCompileToFunctions(
+        template,
+        {
+          scopeId: _scopeId,
+          warn: onCompilationError,
+        },
+        vm
+      )
 
       vm.$options.render = compiled.render
       vm.$options.staticRenderFns = compiled.staticRenderFns
@@ -50,12 +57,12 @@ const normalizeRender = vm => {
   }
 }
 
-function waitForServerPrefetch (vm, resolve, reject) {
+function waitForServerPrefetch(vm, resolve, reject) {
   let handlers = vm.$options.serverPrefetch
   if (isDef(handlers)) {
     if (!Array.isArray(handlers)) handlers = [handlers]
     try {
-      const promises = []
+      const promises: Promise<any>[] = []
       for (let i = 0, j = handlers.length; i < j; i++) {
         const result = handlers[i].call(vm, vm)
         if (result && typeof result.then === 'function') {
@@ -71,7 +78,7 @@ function waitForServerPrefetch (vm, resolve, reject) {
   resolve()
 }
 
-function renderNode (node, isRoot, context) {
+function renderNode(node, isRoot, context) {
   if (node.isString) {
     renderStringNode(node, context)
   } else if (isDef(node.componentOptions)) {
@@ -93,7 +100,7 @@ function renderNode (node, isRoot, context) {
   }
 }
 
-function registerComponentForCache (options, write) {
+function registerComponentForCache(options, write) {
   // exposed by vue-loader, need to call this if cache hit because
   // component lifecycle hooks will not be called.
   const register = options._ssrRegister
@@ -103,7 +110,7 @@ function registerComponentForCache (options, write) {
   return register
 }
 
-function renderComponent (node, isRoot, context) {
+function renderComponent(node, isRoot, context) {
   const { write, next, userContext } = context
 
   // check cache hit
@@ -122,13 +129,13 @@ function renderComponent (node, isRoot, context) {
     const key = name + '::' + rawKey
     const { has, get } = context
     if (isDef(has)) {
-      has(key, hit => {
+      has(key, (hit) => {
         if (hit === true && isDef(get)) {
-          get(key, res => {
+          get(key, (res) => {
             if (isDef(registerComponent)) {
               registerComponent(userContext)
             }
-            res.components.forEach(register => register(userContext))
+            res.components.forEach((register) => register(userContext))
             write(res.html, next)
           })
         } else {
@@ -136,12 +143,12 @@ function renderComponent (node, isRoot, context) {
         }
       })
     } else if (isDef(get)) {
-      get(key, res => {
+      get(key, (res) => {
         if (isDef(res)) {
           if (isDef(registerComponent)) {
             registerComponent(userContext)
           }
-          res.components.forEach(register => register(userContext))
+          res.components.forEach((register) => register(userContext))
           write(res.html, next)
         } else {
           renderComponentWithCache(node, isRoot, key, context)
@@ -154,20 +161,20 @@ function renderComponent (node, isRoot, context) {
         `[vue-server-renderer] Component ${
           Ctor.options.name || '(anonymous)'
         } implemented serverCacheKey, ` +
-        'but no cache was provided to the renderer.'
+          'but no cache was provided to the renderer.'
       )
     }
     if (isDef(getKey) && isUndef(name)) {
       warnOnce(
         `[vue-server-renderer] Components that implement "serverCacheKey" ` +
-        `must also define a unique "name" option.`
+          `must also define a unique "name" option.`
       )
     }
     renderComponentInner(node, isRoot, context)
   }
 }
 
-function renderComponentWithCache (node, isRoot, key, context) {
+function renderComponentWithCache(node, isRoot, key, context) {
   const write = context.write
   write.caching = true
   const buffer = write.cacheBuffer
@@ -179,19 +186,19 @@ function renderComponentWithCache (node, isRoot, key, context) {
     key,
     buffer,
     bufferIndex,
-    componentBuffer
+    componentBuffer,
   })
   renderComponentInner(node, isRoot, context)
 }
 
-function renderComponentInner (node, isRoot, context) {
+function renderComponentInner(node, isRoot, context) {
   const prevActive = context.activeInstance
   // expose userContext on vnode
   node.ssrContext = context.userContext
-  const child = context.activeInstance = createComponentInstanceForVnode(
+  const child = (context.activeInstance = createComponentInstanceForVnode(
     node,
     context.activeInstance
-  )
+  ))
   normalizeRender(child)
 
   const resolve = () => {
@@ -199,7 +206,7 @@ function renderComponentInner (node, isRoot, context) {
     childNode.parent = node
     context.renderStates.push({
       type: 'Component',
-      prevActive
+      prevActive,
     })
     renderNode(childNode, isRoot, context)
   }
@@ -209,10 +216,10 @@ function renderComponentInner (node, isRoot, context) {
   waitForServerPrefetch(child, resolve, reject)
 }
 
-function renderAsyncComponent (node, isRoot, context) {
+function renderAsyncComponent(node, isRoot, context) {
   const factory = node.asyncFactory
 
-  const resolve = comp => {
+  const resolve = (comp) => {
     if (comp.__esModule && comp.default) {
       comp = comp.default
     }
@@ -238,7 +245,7 @@ function renderAsyncComponent (node, isRoot, context) {
           type: 'Fragment',
           children: resolvedNode,
           rendered: 0,
-          total: resolvedNode.length
+          total: resolvedNode.length,
         })
         context.next()
       }
@@ -274,7 +281,7 @@ function renderAsyncComponent (node, isRoot, context) {
   }
 }
 
-function renderStringNode (el, context) {
+function renderStringNode(el, context) {
   const { write, next } = context
   if (isUndef(el.children) || el.children.length === 0) {
     write(el.open + (el.close || ''), next)
@@ -285,13 +292,13 @@ function renderStringNode (el, context) {
       children,
       rendered: 0,
       total: children.length,
-      endTag: el.close
+      endTag: el.close,
     })
     write(el.open, next)
   }
 }
 
-function renderElement (el, isRoot, context) {
+function renderElement(el, isRoot, context) {
   const { write, next } = context
 
   if (isTrue(isRoot)) {
@@ -317,34 +324,37 @@ function renderElement (el, isRoot, context) {
       children,
       rendered: 0,
       total: children.length,
-      endTag
+      endTag,
     })
     write(startTag, next)
   }
 }
 
-function hasAncestorData (node: VNode) {
+function hasAncestorData(node: VNode) {
   const parentNode = node.parent
-  return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
+  return (
+    isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
+  )
 }
 
-function getVShowDirectiveInfo (node: VNode): ?VNodeDirective {
+function getVShowDirectiveInfo(node: VNode): VNodeDirective | undefined {
   let dir: VNodeDirective
   let tmp
 
   while (isDef(node)) {
     if (node.data && node.data.directives) {
-      tmp = node.data.directives.find(dir => dir.name === 'show')
+      tmp = node.data.directives.find((dir) => dir.name === 'show')
       if (tmp) {
         dir = tmp
       }
     }
-    node = node.parent
+    node = node.parent!
   }
+  //@ts-expect-error
   return dir
 }
 
-function renderStartingTag (node: VNode, context) {
+function renderStartingTag(node: VNode, context) {
   let markup = `<${node.tag}`
   const { directives, modules } = context
 
@@ -387,44 +397,50 @@ function renderStartingTag (node: VNode, context) {
   // attach scoped CSS ID
   let scopeId
   const activeInstance = context.activeInstance
-  if (isDef(activeInstance) &&
+  if (
+    isDef(activeInstance) &&
     activeInstance !== node.context &&
-    isDef(scopeId = activeInstance.$options._scopeId)
+    isDef((scopeId = activeInstance.$options._scopeId))
   ) {
-    markup += ` ${(scopeId: any)}`
+    markup += ` ${scopeId as any}`
   }
   if (isDef(node.fnScopeId)) {
     markup += ` ${node.fnScopeId}`
   } else {
     while (isDef(node)) {
-      if (isDef(scopeId = node.context.$options._scopeId)) {
+      //@ts-expect-error
+      if (isDef((scopeId = node.context.$options._scopeId))) {
         markup += ` ${scopeId}`
       }
-      node = node.parent
+      node = node.parent!
     }
   }
   return markup + '>'
 }
 
-export function createRenderFunction (
-  modules: Array<(node: VNode) => ?string>,
+export function createRenderFunction(
+  modules: Array<(node: VNode) => string | null>,
   directives: Object,
   isUnaryTag: Function,
   cache: any
 ) {
-  return function render (
+  return function render(
     component: Component,
     write: (text: string, next: Function) => void,
-    userContext: ?Object,
+    userContext: Record<string, any> | null,
     done: Function
   ) {
     warned = Object.create(null)
     const context = new RenderContext({
       activeInstance: component,
       userContext,
-      write, done, renderNode,
-      isUnaryTag, modules, directives,
-      cache
+      write,
+      done,
+      renderNode,
+      isUnaryTag,
+      modules,
+      directives,
+      cache,
     })
     installSSRHelpers(component)
     normalizeRender(component)
diff --git a/src/server/template-renderer/create-async-file-mapper.js b/src/server/template-renderer/create-async-file-mapper.ts
similarity index 74%
rename from src/server/template-renderer/create-async-file-mapper.js
rename to src/server/template-renderer/create-async-file-mapper.ts
index 057fa9083ee..34269f5a8e9 100644
--- a/src/server/template-renderer/create-async-file-mapper.js
+++ b/src/server/template-renderer/create-async-file-mapper.ts
@@ -8,15 +8,13 @@
 
 import type { ClientManifest } from './index'
 
-export type AsyncFileMapper = (files: Array<string>) => Array<string>;
+export type AsyncFileMapper = (files: Array<string>) => Array<string>
 
-export function createMapper (
-  clientManifest: ClientManifest
-): AsyncFileMapper {
+export function createMapper(clientManifest: ClientManifest): AsyncFileMapper {
   const map = createMap(clientManifest)
   // map server-side moduleIds to client-side files
-  return function mapper (moduleIds: Array<string>): Array<string> {
-    const res = new Set()
+  return function mapper(moduleIds: Array<string>): Array<string> {
+    const res = new Set<string>()
     for (let i = 0; i < moduleIds.length; i++) {
       const mapped = map.get(moduleIds[i])
       if (mapped) {
@@ -29,19 +27,19 @@ export function createMapper (
   }
 }
 
-function createMap (clientManifest) {
+function createMap(clientManifest) {
   const map = new Map()
-  Object.keys(clientManifest.modules).forEach(id => {
+  Object.keys(clientManifest.modules).forEach((id) => {
     map.set(id, mapIdToFile(id, clientManifest))
   })
   return map
 }
 
-function mapIdToFile (id, clientManifest) {
-  const files = []
+function mapIdToFile(id, clientManifest) {
+  const files: string[] = []
   const fileIndices = clientManifest.modules[id]
   if (fileIndices) {
-    fileIndices.forEach(index => {
+    fileIndices.forEach((index) => {
       const file = clientManifest.all[index]
       // only include async files or non-js, non-css assets
       if (
diff --git a/src/server/template-renderer/index.js b/src/server/template-renderer/index.ts
similarity index 53%
rename from src/server/template-renderer/index.js
rename to src/server/template-renderer/index.ts
index c8927b2de2c..f3d0603cd60 100644
--- a/src/server/template-renderer/index.js
+++ b/src/server/template-renderer/index.ts
@@ -11,51 +11,56 @@ import type { ParsedTemplate } from './parse-template'
 import type { AsyncFileMapper } from './create-async-file-mapper'
 
 type TemplateRendererOptions = {
-  template?: string | (content: string, context: any) => string;
-  inject?: boolean;
-  clientManifest?: ClientManifest;
-  shouldPreload?: (file: string, type: string) => boolean;
-  shouldPrefetch?: (file: string, type: string) => boolean;
-  serializer?: Function;
-};
+  template?: string | ((content: string, context: any) => string)
+  inject?: boolean
+  clientManifest?: ClientManifest
+  shouldPreload?: (file: string, type: string) => boolean
+  shouldPrefetch?: (file: string, type: string) => boolean
+  serializer?: Function
+}
 
 export type ClientManifest = {
-  publicPath: string;
-  all: Array<string>;
-  initial: Array<string>;
-  async: Array<string>;
+  publicPath: string
+  all: Array<string>
+  initial: Array<string>
+  async: Array<string>
   modules: {
-    [id: string]: Array<number>;
-  },
+    [id: string]: Array<number>
+  }
   hasNoCssVersion?: {
-    [file: string]: boolean;
+    [file: string]: boolean
   }
-};
+}
 
 type Resource = {
-  file: string;
-  extension: string;
-  fileWithoutQuery: string;
-  asType: string;
-};
+  file: string
+  extension: string
+  fileWithoutQuery: string
+  asType: string
+}
 
 export default class TemplateRenderer {
-  options: TemplateRendererOptions;
-  inject: boolean;
-  parsedTemplate: ParsedTemplate | Function | null;
-  publicPath: string;
-  clientManifest: ClientManifest;
-  preloadFiles: Array<Resource>;
-  prefetchFiles: Array<Resource>;
-  mapFiles: AsyncFileMapper;
-  serialize: Function;
+  options: TemplateRendererOptions
+  inject: boolean
+  parsedTemplate: ParsedTemplate | Function | null
+  //@ts-expect-error
+  publicPath: string
+  //@ts-expect-error
+  clientManifest: ClientManifest
+  //@ts-expect-error
+  preloadFiles: Array<Resource>
+  //@ts-expect-error
+  prefetchFiles: Array<Resource>
+  //@ts-expect-error
+  mapFiles: AsyncFileMapper
+  serialize: Function
 
-  constructor (options: TemplateRendererOptions) {
+  constructor(options: TemplateRendererOptions) {
     this.options = options
     this.inject = options.inject !== false
     // if no template option is provided, the renderer is created
     // as a utility object for rendering assets like preload links and scripts.
-    
+
     const { template } = options
     this.parsedTemplate = template
       ? typeof template === 'string'
@@ -64,17 +69,20 @@ export default class TemplateRenderer {
       : null
 
     // function used to serialize initial state JSON
-    this.serialize = options.serializer || (state => {
-      return serialize(state, { isJSON: true })
-    })
+    this.serialize =
+      options.serializer ||
+      ((state) => {
+        return serialize(state, { isJSON: true })
+      })
 
     // extra functionality with client manifest
     if (options.clientManifest) {
-      const clientManifest = this.clientManifest = options.clientManifest
+      const clientManifest = (this.clientManifest = options.clientManifest)
       // ensure publicPath ends with /
-      this.publicPath = clientManifest.publicPath === ''
-        ? ''
-        : clientManifest.publicPath.replace(/([^\/])$/, '$1/')
+      this.publicPath =
+        clientManifest.publicPath === ''
+          ? ''
+          : clientManifest.publicPath.replace(/([^\/])$/, '$1/')
       // preload/prefetch directives
       this.preloadFiles = (clientManifest.initial || []).map(normalizeFile)
       this.prefetchFiles = (clientManifest.async || []).map(normalizeFile)
@@ -83,17 +91,23 @@ export default class TemplateRenderer {
     }
   }
 
-  bindRenderFns (context: Object) {
+  bindRenderFns(context: Record<string, any>) {
     const renderer: any = this
-    ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(type => {
-      context[`render${type}`] = renderer[`render${type}`].bind(renderer, context)
+    ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
+      context[`render${type}`] = renderer[`render${type}`].bind(
+        renderer,
+        context
+      )
     })
     // also expose getPreloadFiles, useful for HTTP/2 push
     context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context)
   }
 
   // render synchronously given rendered app content and render context
-  render (content: string, context: ?Object): string | Promise<string> {
+  render(
+    content: string,
+    context: Record<string, any> | null
+  ): string | Promise<string> {
     const template = this.parsedTemplate
     if (!template) {
       throw new Error('render cannot be called without a template.')
@@ -126,14 +140,19 @@ export default class TemplateRenderer {
     }
   }
 
-  renderStyles (context: Object): string {
+  renderStyles(context: Record<string, any>): string {
     const initial = this.preloadFiles || []
     const async = this.getUsedAsyncFiles(context) || []
     const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file))
     return (
       // render links for css files
       (cssFiles.length
-        ? cssFiles.map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`).join('')
+        ? cssFiles
+            .map(
+              ({ file }) =>
+                `<link rel="stylesheet" href="${this.publicPath}${file}">`
+            )
+            .join('')
         : '') +
       // context.styles is a getter exposed by vue-style-loader which contains
       // the inline component styles collected during SSR
@@ -141,11 +160,11 @@ export default class TemplateRenderer {
     )
   }
 
-  renderResourceHints (context: Object): string {
+  renderResourceHints(context: Object): string {
     return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context)
   }
 
-  getPreloadFiles (context: Object): Array<Resource> {
+  getPreloadFiles(context: Object): Array<Resource> {
     const usedAsyncFiles = this.getUsedAsyncFiles(context)
     if (this.preloadFiles || usedAsyncFiles) {
       return (this.preloadFiles || []).concat(usedAsyncFiles || [])
@@ -154,114 +173,125 @@ export default class TemplateRenderer {
     }
   }
 
-  renderPreloadLinks (context: Object): string {
+  renderPreloadLinks(context: Object): string {
     const files = this.getPreloadFiles(context)
     const shouldPreload = this.options.shouldPreload
     if (files.length) {
-      return files.map(({ file, extension, fileWithoutQuery, asType }) => {
-        let extra = ''
-        // by default, we only preload scripts or css
-        if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-          return ''
-        }
-        // user wants to explicitly control what to preload
-        if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-          return ''
-        }
-        if (asType === 'font') {
-          extra = ` type="font/${extension}" crossorigin`
-        }
-        return `<link rel="preload" href="${
-          this.publicPath}${file
-        }"${
-          asType !== '' ? ` as="${asType}"` : ''
-        }${
-          extra
-        }>`
-      }).join('')
+      return files
+        .map(({ file, extension, fileWithoutQuery, asType }) => {
+          let extra = ''
+          // by default, we only preload scripts or css
+          if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+            return ''
+          }
+          // user wants to explicitly control what to preload
+          if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+            return ''
+          }
+          if (asType === 'font') {
+            extra = ` type="font/${extension}" crossorigin`
+          }
+          return `<link rel="preload" href="${this.publicPath}${file}"${
+            asType !== '' ? ` as="${asType}"` : ''
+          }${extra}>`
+        })
+        .join('')
     } else {
       return ''
     }
   }
 
-  renderPrefetchLinks (context: Object): string {
+  renderPrefetchLinks(context: Object): string {
     const shouldPrefetch = this.options.shouldPrefetch
     if (this.prefetchFiles) {
       const usedAsyncFiles = this.getUsedAsyncFiles(context)
-      const alreadyRendered = file => {
-        return usedAsyncFiles && usedAsyncFiles.some(f => f.file === file)
+      const alreadyRendered = (file) => {
+        return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file)
       }
-      return this.prefetchFiles.map(({ file, fileWithoutQuery, asType }) => {
-        if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-          return ''
-        }
-        if (alreadyRendered(file)) {
-          return ''
-        }
-        return `<link rel="prefetch" href="${this.publicPath}${file}">`
-      }).join('')
+      return this.prefetchFiles
+        .map(({ file, fileWithoutQuery, asType }) => {
+          if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+            return ''
+          }
+          if (alreadyRendered(file)) {
+            return ''
+          }
+          return `<link rel="prefetch" href="${this.publicPath}${file}">`
+        })
+        .join('')
     } else {
       return ''
     }
   }
 
-  renderState (context: Object, options?: Object): string {
-    const {
-      contextKey = 'state',
-      windowKey = '__INITIAL_STATE__'
-    } = options || {}
+  renderState(
+    context: Record<string, any>,
+    options?: Record<string, any>
+  ): string {
+    const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } =
+      options || {}
     const state = this.serialize(context[contextKey])
-    const autoRemove = process.env.NODE_ENV === 'production'
-      ? ';(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());'
-      : ''
+    const autoRemove =
+      process.env.NODE_ENV === 'production'
+        ? ';(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());'
+        : ''
     const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : ''
     return context[contextKey]
       ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
       : ''
   }
 
-  renderScripts (context: Object): string {
+  renderScripts(context: Object): string {
     if (this.clientManifest) {
       const initial = this.preloadFiles.filter(({ file }) => isJS(file))
-      const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file))
+      const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) =>
+        isJS(file)
+      )
       const needed = [initial[0]].concat(async, initial.slice(1))
-      return needed.map(({ file }) => {
-        return `<script src="${this.publicPath}${file}" defer></script>`
-      }).join('')
+      return needed
+        .map(({ file }) => {
+          return `<script src="${this.publicPath}${file}" defer></script>`
+        })
+        .join('')
     } else {
       return ''
     }
   }
 
-  getUsedAsyncFiles (context: Object): ?Array<Resource> {
-    if (!context._mappedFiles && context._registeredComponents && this.mapFiles) {
-      const registered = Array.from(context._registeredComponents)
+  getUsedAsyncFiles(context: Record<string, any>): Array<Resource> | undefined {
+    if (
+      !context._mappedFiles &&
+      context._registeredComponents &&
+      this.mapFiles
+    ) {
+      const registered: any[] = Array.from(context._registeredComponents)
       context._mappedFiles = this.mapFiles(registered).map(normalizeFile)
     }
     return context._mappedFiles
   }
 
   // create a transform stream
-  createStream (context: ?Object): TemplateStream {
+  createStream(context: Record<string, any> | undefined): TemplateStream {
     if (!this.parsedTemplate) {
       throw new Error('createStream cannot be called without a template.')
     }
+    //@ts-expect-error
     return new TemplateStream(this, this.parsedTemplate, context || {})
   }
 }
 
-function normalizeFile (file: string): Resource {
+function normalizeFile(file: string): Resource {
   const withoutQuery = file.replace(/\?.*/, '')
   const extension = path.extname(withoutQuery).slice(1)
   return {
     file,
     extension,
     fileWithoutQuery: withoutQuery,
-    asType: getPreloadType(extension)
+    asType: getPreloadType(extension),
   }
 }
 
-function getPreloadType (ext: string): string {
+function getPreloadType(ext: string): string {
   if (ext === 'js') {
     return 'script'
   } else if (ext === 'css') {
diff --git a/src/server/template-renderer/parse-template.js b/src/server/template-renderer/parse-template.ts
similarity index 67%
rename from src/server/template-renderer/parse-template.js
rename to src/server/template-renderer/parse-template.ts
index 1ccfe899620..d200655e560 100644
--- a/src/server/template-renderer/parse-template.js
+++ b/src/server/template-renderer/parse-template.ts
@@ -3,18 +3,18 @@
 const compile = require('lodash.template')
 const compileOptions = {
   escape: /{{([^{][\s\S]+?[^}])}}/g,
-  interpolate: /{{{([\s\S]+?)}}}/g
+  interpolate: /{{{([\s\S]+?)}}}/g,
 }
 
 export type ParsedTemplate = {
-  head: (data: any) => string;
-  neck: (data: any) => string;
-  tail: (data: any) => string;
-};
+  head: (data: any) => string
+  neck: (data: any) => string
+  tail: (data: any) => string
+}
 
-export function parseTemplate (
+export function parseTemplate(
   template: string,
-  contentPlaceholder?: string = '<!--vue-ssr-outlet-->'
+  contentPlaceholder: string = '<!--vue-ssr-outlet-->'
 ): ParsedTemplate {
   if (typeof template === 'object') {
     return template
@@ -37,6 +37,9 @@ export function parseTemplate (
   return {
     head: compile(template.slice(0, i), compileOptions),
     neck: compile(template.slice(i, j), compileOptions),
-    tail: compile(template.slice(j + contentPlaceholder.length), compileOptions)
+    tail: compile(
+      template.slice(j + contentPlaceholder.length),
+      compileOptions
+    ),
   }
 }
diff --git a/src/server/template-renderer/template-stream.js b/src/server/template-renderer/template-stream.ts
similarity index 81%
rename from src/server/template-renderer/template-stream.js
rename to src/server/template-renderer/template-stream.ts
index ed4db78f65a..8644f09ff13 100644
--- a/src/server/template-renderer/template-stream.js
+++ b/src/server/template-renderer/template-stream.ts
@@ -1,20 +1,21 @@
 /* @flow */
 
-const Transform = require('stream').Transform
+// const Transform = require("stream").Transform;
 import type TemplateRenderer from './index'
 import type { ParsedTemplate } from './parse-template'
+import { Transform } from 'stream'
 
 export default class TemplateStream extends Transform {
-  started: boolean;
-  renderer: TemplateRenderer;
-  template: ParsedTemplate;
-  context: Object;
-  inject: boolean;
+  started: boolean
+  renderer: TemplateRenderer
+  template: ParsedTemplate
+  context: Record<string, any>
+  inject: boolean
 
-  constructor (
+  constructor(
     renderer: TemplateRenderer,
     template: ParsedTemplate,
-    context: Object
+    context: Record<string, any>
   ) {
     super()
     this.started = false
@@ -24,7 +25,7 @@ export default class TemplateStream extends Transform {
     this.inject = renderer.inject
   }
 
-  _transform (data: Buffer | string, encoding: string, done: Function) {
+  _transform(data: Buffer | string, encoding: string, done: Function) {
     if (!this.started) {
       this.emit('beforeStart')
       this.start()
@@ -33,7 +34,7 @@ export default class TemplateStream extends Transform {
     done()
   }
 
-  start () {
+  start() {
     this.started = true
     this.push(this.template.head(this.context))
 
@@ -59,7 +60,7 @@ export default class TemplateStream extends Transform {
     this.push(this.template.neck(this.context))
   }
 
-  _flush (done: Function) {
+  _flush(done: Function) {
     this.emit('beforeEnd')
 
     if (this.inject) {
diff --git a/src/server/util.js b/src/server/util.ts
similarity index 91%
rename from src/server/util.js
rename to src/server/util.ts
index 908f8c9df06..3f85530f137 100644
--- a/src/server/util.js
+++ b/src/server/util.ts
@@ -4,7 +4,7 @@ export const isJS = (file: string): boolean => /\.js(\?[^.]+)?$/.test(file)
 
 export const isCSS = (file: string): boolean => /\.css(\?[^.]+)?$/.test(file)
 
-export function createPromiseCallback () {
+export function createPromiseCallback() {
   let resolve, reject
   const promise: Promise<string> = new Promise((_resolve, _reject) => {
     resolve = _resolve
diff --git a/src/server/webpack-plugin/client.js b/src/server/webpack-plugin/client.js
deleted file mode 100644
index ae2a2498672..00000000000
--- a/src/server/webpack-plugin/client.js
+++ /dev/null
@@ -1,65 +0,0 @@
-const hash = require('hash-sum')
-const uniq = require('lodash.uniq')
-import { isJS, isCSS, onEmit } from './util'
-
-export default class VueSSRClientPlugin {
-  constructor (options = {}) {
-    this.options = Object.assign({
-      filename: 'vue-ssr-client-manifest.json'
-    }, options)
-  }
-
-  apply (compiler) {
-    onEmit(compiler, 'vue-client-plugin', (compilation, cb) => {
-      const stats = compilation.getStats().toJson()
-
-      const allFiles = uniq(stats.assets
-        .map(a => a.name))
-
-      const initialFiles = uniq(Object.keys(stats.entrypoints)
-        .map(name => stats.entrypoints[name].assets)
-        .reduce((assets, all) => all.concat(assets), [])
-        .filter((file) => isJS(file) || isCSS(file)))
-
-      const asyncFiles = allFiles
-        .filter((file) => isJS(file) || isCSS(file))
-        .filter(file => initialFiles.indexOf(file) < 0)
-
-      const manifest = {
-        publicPath: stats.publicPath,
-        all: allFiles,
-        initial: initialFiles,
-        async: asyncFiles,
-        modules: { /* [identifier: string]: Array<index: number> */ }
-      }
-
-      const assetModules = stats.modules.filter(m => m.assets.length)
-      const fileToIndex = file => manifest.all.indexOf(file)
-      stats.modules.forEach(m => {
-        // ignore modules duplicated in multiple chunks
-        if (m.chunks.length === 1) {
-          const cid = m.chunks[0]
-          const chunk = stats.chunks.find(c => c.id === cid)
-          if (!chunk || !chunk.files) {
-            return
-          }
-          const id = m.identifier.replace(/\s\w+$/, '') // remove appended hash
-          const files = manifest.modules[hash(id)] = chunk.files.map(fileToIndex)
-          // find all asset modules associated with the same chunk
-          assetModules.forEach(m => {
-            if (m.chunks.some(id => id === cid)) {
-              files.push.apply(files, m.assets.map(fileToIndex))
-            }
-          })
-        }
-      })
-
-      const json = JSON.stringify(manifest, null, 2)
-      compilation.assets[this.options.filename] = {
-        source: () => json,
-        size: () => json.length
-      }
-      cb()
-    })
-  }
-}
diff --git a/src/server/webpack-plugin/client.ts b/src/server/webpack-plugin/client.ts
new file mode 100644
index 00000000000..344bd82817d
--- /dev/null
+++ b/src/server/webpack-plugin/client.ts
@@ -0,0 +1,75 @@
+const hash = require('hash-sum')
+const uniq = require('lodash.uniq')
+import { isJS, isCSS, onEmit } from './util'
+
+export default class VueSSRClientPlugin {
+  constructor(options = {}) {
+    //@ts-expect-error
+    this.options = Object.assign(
+      {
+        filename: 'vue-ssr-client-manifest.json',
+      },
+      options
+    )
+  }
+
+  apply(compiler) {
+    onEmit(compiler, 'vue-client-plugin', (compilation, cb) => {
+      const stats = compilation.getStats().toJson()
+
+      const allFiles = uniq(stats.assets.map((a) => a.name))
+
+      const initialFiles = uniq(
+        Object.keys(stats.entrypoints)
+          .map((name) => stats.entrypoints[name].assets)
+          .reduce((assets, all) => all.concat(assets), [])
+          .filter((file) => isJS(file) || isCSS(file))
+      )
+
+      const asyncFiles = allFiles
+        .filter((file) => isJS(file) || isCSS(file))
+        .filter((file) => initialFiles.indexOf(file) < 0)
+
+      const manifest = {
+        publicPath: stats.publicPath,
+        all: allFiles,
+        initial: initialFiles,
+        async: asyncFiles,
+        modules: {
+          /* [identifier: string]: Array<index: number> */
+        },
+      }
+
+      const assetModules = stats.modules.filter((m) => m.assets.length)
+      const fileToIndex = (file) => manifest.all.indexOf(file)
+      stats.modules.forEach((m) => {
+        // ignore modules duplicated in multiple chunks
+        if (m.chunks.length === 1) {
+          const cid = m.chunks[0]
+          const chunk = stats.chunks.find((c) => c.id === cid)
+          if (!chunk || !chunk.files) {
+            return
+          }
+          const id = m.identifier.replace(/\s\w+$/, '') // remove appended hash
+          const files = (manifest.modules[hash(id)] = chunk.files.map(
+            fileToIndex
+          ))
+          // find all asset modules associated with the same chunk
+          assetModules.forEach((m) => {
+            if (m.chunks.some((id) => id === cid)) {
+              files.push.apply(files, m.assets.map(fileToIndex))
+            }
+          })
+        }
+      })
+
+      const json = JSON.stringify(manifest, null, 2)
+      //@ts-expect-error
+      compilation.assets[this.options.filename] = {
+        source: () => json,
+        size: () => json.length,
+      }
+      cb()
+    })
+  }
+}
diff --git a/src/server/webpack-plugin/server.js b/src/server/webpack-plugin/server.ts
similarity index 76%
rename from src/server/webpack-plugin/server.js
rename to src/server/webpack-plugin/server.ts
index 305b4bab58b..2693328417f 100644
--- a/src/server/webpack-plugin/server.js
+++ b/src/server/webpack-plugin/server.ts
@@ -1,13 +1,17 @@
 import { validate, isJS, onEmit } from './util'
 
 export default class VueSSRServerPlugin {
-  constructor (options = {}) {
-    this.options = Object.assign({
-      filename: 'vue-ssr-server-bundle.json'
-    }, options)
+  constructor(options = {}) {
+    //@ts-expect-error
+    this.options = Object.assign(
+      {
+        filename: 'vue-ssr-server-bundle.json',
+      },
+      options
+    )
   }
 
-  apply (compiler) {
+  apply(compiler) {
     validate(compiler)
 
     onEmit(compiler, 'vue-server-plugin', (compilation, cb) => {
@@ -25,7 +29,7 @@ export default class VueSSRServerPlugin {
       if (entryAssets.length > 1) {
         throw new Error(
           `Server-side bundle should have one single entry file. ` +
-          `Avoid using CommonsChunkPlugin in the server config.`
+            `Avoid using CommonsChunkPlugin in the server config.`
         )
       }
 
@@ -39,25 +43,28 @@ export default class VueSSRServerPlugin {
       const bundle = {
         entry,
         files: {},
-        maps: {}
+        maps: {},
       }
 
-      stats.assets.forEach(asset => {
+      stats.assets.forEach((asset) => {
         if (isJS(asset.name)) {
           bundle.files[asset.name] = compilation.assets[asset.name].source()
         } else if (asset.name.match(/\.js\.map$/)) {
-          bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source())
+          bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(
+            compilation.assets[asset.name].source()
+          )
         }
         // do not emit anything else for server
         delete compilation.assets[asset.name]
       })
 
       const json = JSON.stringify(bundle, null, 2)
+      //@ts-expect-error
       const filename = this.options.filename
 
       compilation.assets[filename] = {
         source: () => json,
-        size: () => json.length
+        size: () => json.length,
       }
 
       cb()
diff --git a/src/server/webpack-plugin/util.js b/src/server/webpack-plugin/util.ts
similarity index 66%
rename from src/server/webpack-plugin/util.js
rename to src/server/webpack-plugin/util.ts
index 94a204a22b2..4146cb11535 100644
--- a/src/server/webpack-plugin/util.js
+++ b/src/server/webpack-plugin/util.ts
@@ -1,22 +1,25 @@
 const { red, yellow } = require('chalk')
 
 const prefix = `[vue-server-renderer-webpack-plugin]`
-const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`))
-const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`))
+const warn = (exports.warn = (msg) => console.error(red(`${prefix} ${msg}\n`)))
+const tip = (exports.tip = (msg) => console.log(yellow(`${prefix} ${msg}\n`)))
 
-export const validate = compiler => {
+export const validate = (compiler) => {
   if (compiler.options.target !== 'node') {
     warn('webpack config `target` should be "node".')
   }
 
-  if (compiler.options.output && compiler.options.output.libraryTarget !== 'commonjs2') {
+  if (
+    compiler.options.output &&
+    compiler.options.output.libraryTarget !== 'commonjs2'
+  ) {
     warn('webpack config `output.libraryTarget` should be "commonjs2".')
   }
 
   if (!compiler.options.externals) {
     tip(
       'It is recommended to externalize dependencies in the server build for ' +
-      'better build performance.'
+        'better build performance.'
     )
   }
 }
diff --git a/src/server/write.js b/src/server/write.ts
similarity index 66%
rename from src/server/write.js
rename to src/server/write.ts
index 27a5e8a2667..5148d1ef1e9 100644
--- a/src/server/write.js
+++ b/src/server/write.ts
@@ -1,25 +1,26 @@
 /* @flow */
 
 const MAX_STACK_DEPTH = 800
-const noop = _ => _
+const noop = (_) => _
 
-const defer = typeof process !== 'undefined' && process.nextTick
-  ? process.nextTick
-  : typeof Promise !== 'undefined'
-    ? fn => Promise.resolve().then(fn)
+const defer =
+  typeof process !== 'undefined' && process.nextTick
+    ? process.nextTick
+    : typeof Promise !== 'undefined'
+    ? (fn) => Promise.resolve().then(fn)
     : typeof setTimeout !== 'undefined'
-      ? setTimeout
-      : noop
+    ? setTimeout
+    : noop
 
 if (defer === noop) {
   throw new Error(
     'Your JavaScript runtime does not support any asynchronous primitives ' +
-    'that are required by vue-server-renderer. Please use a polyfill for ' +
-    'either Promise or setTimeout.'
+      'that are required by vue-server-renderer. Please use a polyfill for ' +
+      'either Promise or setTimeout.'
   )
 }
 
-export function createWriteFunction (
+export function createWriteFunction(
   write: (text: string, next: Function) => boolean,
   onError: Function
 ): Function {
@@ -32,7 +33,9 @@ export function createWriteFunction (
     if (waitForNext !== true) {
       if (stackDepth >= MAX_STACK_DEPTH) {
         defer(() => {
-          try { next() } catch (e) {
+          try {
+            next()
+          } catch (e) {
             onError(e)
           }
         })
diff --git a/src/sfc/parser.js b/src/sfc/parser.ts
similarity index 83%
rename from src/sfc/parser.js
rename to src/sfc/parser.ts
index 59c5fc3a2c0..6ef98558354 100644
--- a/src/sfc/parser.js
+++ b/src/sfc/parser.ts
@@ -11,21 +11,21 @@ const isSpecialTag = makeMap('script,style,template', true)
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
-export function parseComponent (
+export function parseComponent(
   content: string,
-  options?: Object = {}
+  options: Record<string, any> = {}
 ): SFCDescriptor {
   const sfc: SFCDescriptor = {
     template: null,
     script: null,
     styles: [],
     customBlocks: [],
-    errors: []
+    errors: [],
   }
   let depth = 0
-  let currentBlock: ?SFCBlock = null
+  let currentBlock: SFCBlock | null = null
 
-  let warn = msg => {
+  let warn: any = (msg) => {
     sfc.errors.push(msg)
   }
 
@@ -42,7 +42,7 @@ export function parseComponent (
     }
   }
 
-  function start (
+  function start(
     tag: string,
     attrs: Array<ASTAttr>,
     unary: boolean,
@@ -57,7 +57,7 @@ export function parseComponent (
         attrs: attrs.reduce((cumulated, { name, value }) => {
           cumulated[name] = value || true
           return cumulated
-        }, {})
+        }, {}),
       }
       if (isSpecialTag(tag)) {
         checkAttrs(currentBlock, attrs)
@@ -66,7 +66,8 @@ export function parseComponent (
         } else {
           sfc[tag] = currentBlock
         }
-      } else { // custom blocks
+      } else {
+        // custom blocks
         sfc.customBlocks.push(currentBlock)
       }
     }
@@ -75,7 +76,7 @@ export function parseComponent (
     }
   }
 
-  function checkAttrs (block: SFCBlock, attrs: Array<ASTAttr>) {
+  function checkAttrs(block: SFCBlock, attrs: Array<ASTAttr>) {
     for (let i = 0; i < attrs.length; i++) {
       const attr = attrs[i]
       if (attr.name === 'lang') {
@@ -93,11 +94,12 @@ export function parseComponent (
     }
   }
 
-  function end (tag: string, start: number) {
+  function end(tag: string, start: number) {
     if (depth === 1 && currentBlock) {
       currentBlock.end = start
       let text = content.slice(currentBlock.start, currentBlock.end)
       if (options.deindent !== false) {
+        //@ts-expect-error
         text = deindent(text)
       }
       // pad content so that linters and pre-processors can output correct
@@ -111,14 +113,12 @@ export function parseComponent (
     depth--
   }
 
-  function padContent (block: SFCBlock, pad: true | "line" | "space") {
+  function padContent(block: SFCBlock, pad: true | 'line' | 'space') {
     if (pad === 'space') {
       return content.slice(0, block.start).replace(replaceRE, ' ')
     } else {
       const offset = content.slice(0, block.start).split(splitRE).length
-      const padChar = block.type === 'script' && !block.lang
-        ? '//\n'
-        : '\n'
+      const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
       return Array(offset).join(padChar)
     }
   }
@@ -127,7 +127,7 @@ export function parseComponent (
     warn,
     start,
     end,
-    outputSourceRange: options.outputSourceRange
+    outputSourceRange: options.outputSourceRange,
   })
 
   return sfc
diff --git a/src/shared/constants.js b/src/shared/constants.ts
similarity index 71%
rename from src/shared/constants.js
rename to src/shared/constants.ts
index a8b15e043dd..e4814c0f773 100644
--- a/src/shared/constants.js
+++ b/src/shared/constants.ts
@@ -1,10 +1,6 @@
 export const SSR_ATTR = 'data-server-rendered'
 
-export const ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-]
+export const ASSET_TYPES = ['component', 'directive', 'filter'] as const
 
 export const LIFECYCLE_HOOKS = [
   'beforeCreate',
@@ -18,5 +14,5 @@ export const LIFECYCLE_HOOKS = [
   'activated',
   'deactivated',
   'errorCaptured',
-  'serverPrefetch'
-]
+  'serverPrefetch',
+] as const
diff --git a/src/shared/util.js b/src/shared/util.ts
similarity index 70%
rename from src/shared/util.js
rename to src/shared/util.ts
index 9f240c77b14..49059d6acb4 100644
--- a/src/shared/util.js
+++ b/src/shared/util.ts
@@ -4,26 +4,26 @@ export const emptyObject = Object.freeze({})
 
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-export function isUndef (v: any): boolean %checks {
+export function isUndef(v: any): v is undefined | null {
   return v === undefined || v === null
 }
 
-export function isDef (v: any): boolean %checks {
+export function isDef<T>(v: T): v is NonNullable<T> {
   return v !== undefined && v !== null
 }
 
-export function isTrue (v: any): boolean %checks {
+export function isTrue(v: any): boolean {
   return v === true
 }
 
-export function isFalse (v: any): boolean %checks {
+export function isFalse(v: any): boolean {
   return v === false
 }
 
 /**
  * Check if value is primitive.
  */
-export function isPrimitive (value: any): boolean %checks {
+export function isPrimitive(value: any): boolean {
   return (
     typeof value === 'string' ||
     typeof value === 'number' ||
@@ -38,7 +38,7 @@ export function isPrimitive (value: any): boolean %checks {
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-export function isObject (obj: mixed): boolean %checks {
+export function isObject(obj: any): boolean {
   return obj !== null && typeof obj === 'object'
 }
 
@@ -47,7 +47,7 @@ export function isObject (obj: mixed): boolean %checks {
  */
 const _toString = Object.prototype.toString
 
-export function toRawType (value: any): string {
+export function toRawType(value: any): string {
   return _toString.call(value).slice(8, -1)
 }
 
@@ -55,23 +55,23 @@ export function toRawType (value: any): string {
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-export function isPlainObject (obj: any): boolean {
+export function isPlainObject(obj: any): boolean {
   return _toString.call(obj) === '[object Object]'
 }
 
-export function isRegExp (v: any): boolean {
+export function isRegExp(v: any): v is RegExp {
   return _toString.call(v) === '[object RegExp]'
 }
 
 /**
  * Check if val is a valid array index.
  */
-export function isValidArrayIndex (val: any): boolean {
+export function isValidArrayIndex(val: any): boolean {
   const n = parseFloat(String(val))
   return n >= 0 && Math.floor(n) === n && isFinite(val)
 }
 
-export function isPromise (val: any): boolean {
+export function isPromise(val: any): boolean {
   return (
     isDef(val) &&
     typeof val.then === 'function' &&
@@ -82,19 +82,19 @@ export function isPromise (val: any): boolean {
 /**
  * Convert a value to a string that is actually rendered.
  */
-export function toString (val: any): string {
+export function toString(val: any): string {
   return val == null
     ? ''
     : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+    ? JSON.stringify(val, null, 2)
+    : String(val)
 }
 
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-export function toNumber (val: string): number | string {
+export function toNumber(val: string): number | string {
   const n = parseFloat(val)
   return isNaN(n) ? val : n
 }
@@ -103,18 +103,16 @@ export function toNumber (val: string): number | string {
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-export function makeMap (
+export function makeMap(
   str: string,
   expectsLowerCase?: boolean
-): (key: string) => true | void {
+): (key: string) => true | undefined {
   const map = Object.create(null)
   const list: Array<string> = str.split(',')
   for (let i = 0; i < list.length; i++) {
     map[list[i]] = true
   }
-  return expectsLowerCase
-    ? val => map[val.toLowerCase()]
-    : val => map[val]
+  return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val]
 }
 
 /**
@@ -130,7 +128,7 @@ export const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
 /**
  * Remove an item from an array.
  */
-export function remove (arr: Array<any>, item: any): Array<any> | void {
+export function remove(arr: Array<any>, item: any): Array<any> | void {
   if (arr.length) {
     const index = arr.indexOf(item)
     if (index > -1) {
@@ -143,19 +141,19 @@ export function remove (arr: Array<any>, item: any): Array<any> | void {
  * Check whether an object has the property.
  */
 const hasOwnProperty = Object.prototype.hasOwnProperty
-export function hasOwn (obj: Object | Array<*>, key: string): boolean {
+export function hasOwn(obj: Object | Array<any>, key: string): boolean {
   return hasOwnProperty.call(obj, key)
 }
 
 /**
  * Create a cached version of a pure function.
  */
-export function cached<F: Function> (fn: F): F {
-  const cache = Object.create(null)
-  return (function cachedFn (str: string) {
+export function cached<R>(fn: (str: string) => R): (sr: string) => R {
+  const cache: Record<string, R> = Object.create(null)
+  return function cachedFn(str: string) {
     const hit = cache[str]
     return hit || (cache[str] = fn(str))
-  }: any)
+  }
 }
 
 /**
@@ -163,7 +161,7 @@ export function cached<F: Function> (fn: F): F {
  */
 const camelizeRE = /-(\w)/g
 export const camelize = cached((str: string): string => {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
+  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))
 })
 
 /**
@@ -190,8 +188,8 @@ export const hyphenate = cached((str: string): string => {
  */
 
 /* istanbul ignore next */
-function polyfillBind (fn: Function, ctx: Object): Function {
-  function boundFn (a) {
+function polyfillBind(fn: Function, ctx: Object): Function {
+  function boundFn(a: any) {
     const l = arguments.length
     return l
       ? l > 1
@@ -204,18 +202,17 @@ function polyfillBind (fn: Function, ctx: Object): Function {
   return boundFn
 }
 
-function nativeBind (fn: Function, ctx: Object): Function {
+function nativeBind(fn: Function, ctx: Object): Function {
   return fn.bind(ctx)
 }
 
-export const bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind
+// @ts-expect-error bind cannot be `undefined`
+export const bind = Function.prototype.bind ? nativeBind : polyfillBind
 
 /**
  * Convert an Array-like object to a real Array.
  */
-export function toArray (list: any, start?: number): Array<any> {
+export function toArray(list: any, start?: number): Array<any> {
   start = start || 0
   let i = list.length - start
   const ret: Array<any> = new Array(i)
@@ -228,7 +225,10 @@ export function toArray (list: any, start?: number): Array<any> {
 /**
  * Mix properties into target object.
  */
-export function extend (to: Object, _from: ?Object): Object {
+export function extend(
+  to: Record<PropertyKey, any>,
+  _from?: Record<PropertyKey, any>
+): Record<PropertyKey, any> {
   for (const key in _from) {
     to[key] = _from[key]
   }
@@ -238,7 +238,7 @@ export function extend (to: Object, _from: ?Object): Object {
 /**
  * Merge an Array of Objects into a single Object.
  */
-export function toObject (arr: Array<any>): Object {
+export function toObject(arr: Array<any>): object {
   const res = {}
   for (let i = 0; i < arr.length; i++) {
     if (arr[i]) {
@@ -255,7 +255,7 @@ export function toObject (arr: Array<any>): Object {
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-export function noop (a?: any, b?: any, c?: any) {}
+export function noop(a?: any, b?: any, c?: any) {}
 
 /**
  * Always return false.
@@ -272,17 +272,19 @@ export const identity = (_: any) => _
 /**
  * Generate a string containing static keys from compiler modules.
  */
-export function genStaticKeys (modules: Array<ModuleOptions>): string {
-  return modules.reduce((keys, m) => {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+export function genStaticKeys(modules: Array<ModuleOptions>): string {
+  return modules
+    .reduce((keys, m) => {
+      return keys.concat(m.staticKeys || [])
+    }, [] as string[])
+    .join(',')
 }
 
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-export function looseEqual (a: any, b: any): boolean {
+export function looseEqual(a: any, b: any): boolean {
   if (a === b) return true
   const isObjectA = isObject(a)
   const isObjectB = isObject(b)
@@ -291,17 +293,23 @@ export function looseEqual (a: any, b: any): boolean {
       const isArrayA = Array.isArray(a)
       const isArrayB = Array.isArray(b)
       if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every((e, i) => {
-          return looseEqual(e, b[i])
-        })
+        return (
+          a.length === b.length &&
+          a.every((e: any, i: any) => {
+            return looseEqual(e, b[i])
+          })
+        )
       } else if (a instanceof Date && b instanceof Date) {
         return a.getTime() === b.getTime()
       } else if (!isArrayA && !isArrayB) {
         const keysA = Object.keys(a)
         const keysB = Object.keys(b)
-        return keysA.length === keysB.length && keysA.every(key => {
-          return looseEqual(a[key], b[key])
-        })
+        return (
+          keysA.length === keysB.length &&
+          keysA.every((key) => {
+            return looseEqual(a[key], b[key])
+          })
+        )
       } else {
         /* istanbul ignore next */
         return false
@@ -322,7 +330,7 @@ export function looseEqual (a: any, b: any): boolean {
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-export function looseIndexOf (arr: Array<mixed>, val: mixed): number {
+export function looseIndexOf(arr: Array<unknown>, val: unknown): number {
   for (let i = 0; i < arr.length; i++) {
     if (looseEqual(arr[i], val)) return i
   }
@@ -332,7 +340,7 @@ export function looseIndexOf (arr: Array<mixed>, val: mixed): number {
 /**
  * Ensure a function is called only once.
  */
-export function once (fn: Function): Function {
+export function once(fn: Function): Function {
   let called = false
   return function () {
     if (!called) {
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 00000000000..3c4378bb070
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "dist",
+    "sourceMap": false,
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "allowJs": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "noImplicitThis": false,
+    "noUnusedLocals": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "removeComments": false,
+    "jsx": "preserve",
+    "lib": ["esnext", "dom"],
+    "types": ["jest", "puppeteer", "node"],
+    "rootDir": ".",
+    "paths": {
+      "compiler/*": ["src/compiler/*"],
+      "core/*": ["src/core/*"],
+      "platforms/*": ["src/platforms/*"],
+      "server/*": ["src/server/*"],
+      "sfc/*": ["src/sfc/*"],
+      "shared/*": ["src/shared/*"],
+
+      "web/*": ["src/platforms/web/*"],
+      "weex/*": ["src/platforms/weex/*"]
+    }
+  },
+  "include": [
+    "typescript",
+    "src",
+    // "packages/runtime-dom/types/jsx.d.ts",
+    // "packages/*/__tests__",
+    "test-dts"
+  ],
+
+  "exclude": ["flow"]
+}
diff --git a/typescript/compiler.d.ts b/typescript/compiler.d.ts
new file mode 100644
index 00000000000..b4e2eb72be7
--- /dev/null
+++ b/typescript/compiler.d.ts
@@ -0,0 +1,231 @@
+declare type CompilerOptions = {
+  warn?: Function; // allow customizing warning in different environments; e.g. node
+  modules?: Array<ModuleOptions>; // platform specific modules; e.g. style; class
+  directives?: { [key: string]: Function }; // platform specific directives
+  staticKeys?: string; // a list of AST properties to be considered static; for optimization
+  isUnaryTag?: (tag: string) => boolean | null; // check if a tag is unary for the platform
+  canBeLeftOpenTag?: (tag: string) => boolean | null; // check if a tag can be left opened
+  isReservedTag?: (tag: string) => boolean | null; // check if a tag is a native for the platform
+  preserveWhitespace?: boolean; // preserve whitespace between elements? (Deprecated)
+  whitespace?: "preserve" | "condense"; // whitespace handling strategy
+  optimize?: boolean; // optimize static content?
+
+  // web specific
+  mustUseProp?: (
+    tag: string,
+    type: string | null,
+    name: string
+  ) => boolean; // check if an attribute should be bound as a property
+  isPreTag?: (attr: string) => boolean | null; // check if a tag needs to preserve whitespace
+  getTagNamespace?: (tag: string) => string | null; // check the namespace for a tag
+  expectHTML?: boolean; // only false for non-web builds
+  isFromDOM?: boolean;
+  shouldDecodeTags?: boolean;
+  shouldDecodeNewlines?: boolean;
+  shouldDecodeNewlinesForHref?: boolean;
+  outputSourceRange?: boolean;
+
+  // runtime user-configurable
+  delimiters?: [string, string]; // template delimiters
+  comments?: boolean; // preserve comments in template
+
+  // for ssr optimization compiler
+  scopeId?: string;
+};
+
+declare type WarningMessage = {
+  msg: string;
+  start?: number;
+  end?: number;
+};
+
+declare type CompiledResult = {
+  ast: ASTElement | null;
+  render: string;
+  staticRenderFns: Array<string>;
+  stringRenderFns?: Array<string>;
+  errors?: Array<string | WarningMessage>;
+  tips?: Array<string | WarningMessage>;
+};
+
+declare type ModuleOptions = {
+  // transform an AST node before any attributes are processed
+  // returning an ASTElement from pre/transforms replaces the element
+  preTransformNode: (el: ASTElement) => ASTElement | null;
+  // transform an AST node after built-ins like v-if, v-for are processed
+  transformNode: (el: ASTElement) => ASTElement | null;
+  // transform an AST node after its children have been processed
+  // cannot return replacement in postTransform because tree is already finalized
+  postTransformNode: (el: ASTElement) => void;
+  genData: (el: ASTElement) => string; // generate extra data string for an element
+  transformCode?: (el: ASTElement, code: string) => string; // further transform generated code for an element
+  staticKeys?: Array<string>; // AST properties to be considered static
+};
+
+declare type ASTModifiers = { [key: string]: boolean };
+declare type ASTIfCondition = { exp: string | null; block: ASTElement };
+declare type ASTIfConditions = Array<ASTIfCondition>;
+
+declare type ASTAttr = {
+  name: string;
+  value: any;
+  dynamic?: boolean;
+  start?: number;
+  end?: number;
+};
+
+declare type ASTElementHandler = {
+  value: string;
+  params?: Array<any>;
+  modifiers: ASTModifiers | null;
+  dynamic?: boolean;
+  start?: number;
+  end?: number;
+};
+
+declare type ASTElementHandlers = {
+  [key: string]: ASTElementHandler | Array<ASTElementHandler>;
+};
+
+declare type ASTDirective = {
+  name: string;
+  rawName: string;
+  value: string;
+  arg: string | null;
+  isDynamicArg: boolean;
+  modifiers: ASTModifiers | null;
+  start?: number;
+  end?: number;
+};
+
+declare type ASTNode = ASTElement | ASTText | ASTExpression;
+
+declare type ASTElement = {
+  type: 1;
+  tag: string;
+  attrsList: Array<ASTAttr>;
+  attrsMap: { [key: string]: any };
+  rawAttrsMap: { [key: string]: ASTAttr };
+  parent: ASTElement | void;
+  children: Array<ASTNode>;
+
+  start?: number;
+  end?: number;
+
+  processed?: true;
+
+  static?: boolean;
+  staticRoot?: boolean;
+  staticInFor?: boolean;
+  staticProcessed?: boolean;
+  hasBindings?: boolean;
+
+  text?: string;
+  attrs?: Array<ASTAttr>;
+  dynamicAttrs?: Array<ASTAttr>;
+  props?: Array<ASTAttr>;
+  plain?: boolean;
+  pre?: true;
+  ns?: string;
+
+  component?: string;
+  inlineTemplate?: true;
+  transitionMode?: string | null;
+  slotName?: string | null;
+  slotTarget?: string | null;
+  slotTargetDynamic?: boolean;
+  slotScope?: string | null;
+  scopedSlots?: { [name: string]: ASTElement };
+
+  ref?: string;
+  refInFor?: boolean;
+
+  if?: string;
+  ifProcessed?: boolean;
+  elseif?: string;
+  else?: true;
+  ifConditions?: ASTIfConditions;
+
+  for?: string;
+  forProcessed?: boolean;
+  key?: string;
+  alias?: string;
+  iterator1?: string;
+  iterator2?: string;
+
+  staticClass?: string;
+  classBinding?: string;
+  staticStyle?: string;
+  styleBinding?: string;
+  events?: ASTElementHandlers;
+  nativeEvents?: ASTElementHandlers;
+
+  transition?: string | true;
+  transitionOnAppear?: boolean;
+
+  model?: {
+    value: string;
+    callback: string;
+    expression: string;
+  };
+
+  directives?: Array<ASTDirective>;
+
+  forbidden?: true;
+  once?: true;
+  onceProcessed?: boolean;
+  wrapData?: (code: string) => string;
+  wrapListeners?: (code: string) => string;
+
+  // 2.4 ssr optimization
+  ssrOptimizability?: number;
+
+  // weex specific
+  appendAsTree?: boolean;
+};
+
+declare type ASTExpression = {
+  type: 2;
+  expression: string;
+  text: string;
+  tokens: Array<string | Object>;
+  static?: boolean;
+  // 2.4 ssr optimization
+  ssrOptimizability?: number;
+  start?: number;
+  end?: number;
+};
+
+declare type ASTText = {
+  type: 3;
+  text: string;
+  static?: boolean;
+  isComment?: boolean;
+  // 2.4 ssr optimization
+  ssrOptimizability?: number;
+  start?: number;
+  end?: number;
+};
+
+// SFC-parser related declarations
+
+// an object format describing a single-file component
+declare type SFCDescriptor = {
+  template: SFCBlock | null;
+  script: SFCBlock | null;
+  styles: Array<SFCBlock>;
+  customBlocks: Array<SFCBlock>;
+  errors: Array<string | WarningMessage>;
+};
+
+declare type SFCBlock = {
+  type: string;
+  content: string;
+  attrs: { [attribute: string]: string };
+  start?: number;
+  end?: number;
+  lang?: string;
+  src?: string;
+  scoped?: boolean;
+  module?: string | boolean;
+};
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
new file mode 100644
index 00000000000..f1fb9955c45
--- /dev/null
+++ b/typescript/component.d.ts
@@ -0,0 +1,185 @@
+import type { Config } from "../src/core/config";
+import type VNode from "../src/core/vdom/vnode";
+import type Watcher from "../src/core/observer/watcher";
+import { ComponentOptions } from "./options";
+import { ScopedSlotsData, VNodeChildren, VNodeData } from "./vnode";
+
+declare class Component {
+  // constructor information
+  static cid: number;
+  static options: Object;
+  // extend
+  static extend: (options: Object) => Function;
+  static superOptions: Object;
+  static extendOptions: Object;
+  static sealedOptions: Object;
+  static super: Component;
+  // assets
+  static directive: (
+    id: string,
+    def?: Function | Object
+  ) => Function | Object | void;
+  static component: (id: string, def?: Component | Object) => Component;
+  static filter: (id: string, def?: Function) => Function | void;
+  // functional context constructor
+  static FunctionalRenderContext: Function;
+
+  // public properties
+  $el: any; // so that we can attach __vue__ to it
+  $data: Object;
+  $props: Object;
+  $options: ComponentOptions;
+  $parent: Component | undefined;
+  $root: Component;
+  $children: Array<Component>;
+  $refs: {
+    [key: string]: Component | Element | Array<Component | Element> | undefined;
+  };
+  $slots: { [key: string]: Array<VNode> };
+  $scopedSlots: { [key: string]: () => VNodeChildren };
+  $vnode: VNode; // the placeholder node for the component in parent's render tree
+  $attrs: { [key: string]: string };
+  $listeners: { [key: string]: Function | Array<Function> };
+  $isServer: boolean;
+
+  // public methods
+  $mount: (el?: Element | string, hydrating?: boolean) => Component;
+  $forceUpdate: () => void;
+  $destroy: () => void;
+  $set: <T>(target: Object | Array<T>, key: string | number, val: T) => T;
+  $delete: <T>(target: Object | Array<T>, key: string | number) => void;
+  $watch: (
+    expOrFn: string | Function,
+    cb: Function,
+    options?: Object
+  ) => Function;
+  $on: (event: string | Array<string>, fn: Function) => Component;
+  $once: (event: string, fn: Function) => Component;
+  $off: (event?: string | Array<string>, fn?: Function) => Component;
+  $emit: (event: string, ...args: Array<any>) => Component;
+  $nextTick: (fn: Function) => void | Promise<any>;
+  $createElement: (
+    tag?: string | Component,
+    data?: Object,
+    children?: VNodeChildren
+  ) => VNode;
+
+  // private properties
+  _uid: number | string;
+  _name: string; // this only exists in dev mode
+  _isVue: true;
+  _self: Component;
+  _renderProxy: Component;
+  _renderContext?: Component;
+  _watcher: Watcher;
+  _watchers: Array<Watcher>;
+  _computedWatchers: { [key: string]: Watcher };
+  _data: Object;
+  _props: Object;
+  _events: Record<string, any>;
+  _inactive: boolean | null;
+  _directInactive: boolean;
+  _isMounted: boolean;
+  _isDestroyed: boolean;
+  _isBeingDestroyed: boolean;
+  _vnode?: VNode; // self root node
+  _staticTrees?: Array<VNode>; // v-once cached trees
+  _hasHookEvent: boolean;
+  _provided?: Object;
+  // _virtualComponents?: { [key: string]: Component };
+
+  // private methods
+
+  // lifecycle
+  _init: Function;
+  _mount: (el?: Element | void, hydrating?: boolean) => Component;
+  _update: (vnode: VNode, hydrating?: boolean) => void;
+
+  // rendering
+  _render: () => VNode;
+
+  __patch__: (
+    a: Element | VNode | void,
+    b: VNode | null,
+    hydrating?: boolean,
+    removeOnly?: boolean,
+    parentElm?: any,
+    refElm?: any
+  ) => any;
+
+  // createElement
+
+  // _c is internal that accepts `normalizationType` optimization hint
+  _c: (
+    vnode?: VNode,
+    data?: VNodeData,
+    children?: VNodeChildren,
+    normalizationType?: number
+  ) => VNode | void;
+
+  // renderStatic
+  _m: (index: number, isInFor?: boolean) => VNode | VNodeChildren;
+  // markOnce
+  _o: (
+    vnode: VNode | Array<VNode>,
+    index: number,
+    key: string
+  ) => VNode | VNodeChildren;
+  // toString
+  _s: (value: any) => string;
+  // text to VNode
+  _v: (value: string | number) => VNode;
+  // toNumber
+  _n: (value: string) => number | string;
+  // empty vnode
+  _e: () => VNode;
+  // loose equal
+  _q: (a: any, b: any) => boolean;
+  // loose indexOf
+  _i: (arr: Array<any>, val: any) => number;
+  // resolveFilter
+  _f: (id: string) => Function;
+  // renderList
+  _l: (val: any, render: Function) => Array<VNode> | null;
+  // renderSlot
+  _t: (
+    name: string,
+    fallback?: Array<VNode>,
+    props?: Object
+  ) => Array<VNode> | null;
+  // apply v-bind object
+  _b: (
+    data: any,
+    tag: string,
+    value: any,
+    asProp: boolean,
+    isSync?: boolean
+  ) => VNodeData;
+  // apply v-on object
+  _g: (data: any, value: any) => VNodeData;
+  // check custom keyCode
+  _k: (
+    eventKeyCode: number,
+    key: string,
+    builtInAlias?: number | Array<number>,
+    eventKeyName?: string
+  ) => boolean | null;
+  // resolve scoped slots
+  _u: (
+    scopedSlots: ScopedSlotsData,
+    res?: Object
+  ) => { [key: string]: Function };
+
+  // SSR specific
+  _ssrNode: Function;
+  _ssrList: Function;
+  _ssrEscape: Function;
+  _ssrAttr: Function;
+  _ssrAttrs: Function;
+  _ssrDOMProps: Function;
+  _ssrClass: Function;
+  _ssrStyle: Function;
+
+  // allow dynamic method registration
+  [key: string]: any;
+}
diff --git a/typescript/global-api.d.ts b/typescript/global-api.d.ts
new file mode 100644
index 00000000000..1a34774f155
--- /dev/null
+++ b/typescript/global-api.d.ts
@@ -0,0 +1,28 @@
+import { Config } from "../src/core/config";
+import { Component } from "./component";
+
+declare interface GlobalAPI {
+  cid: number;
+  options: Record<string, any>;
+  config: Config;
+  util: Object;
+
+  extend: (options: Object) => Component;
+  set: <T>(target: Object | Array<T>, key: string | number, value: T) => T;
+  delete: <T>(target: Object | Array<T>, key: string | number) => void;
+  nextTick: (fn: Function, context?: Object) => void | Promise<any>;
+  use: (plugin: Function | Object) => GlobalAPI;
+  mixin: (mixin: Object) => GlobalAPI;
+  compile: (
+    template: string
+  ) => { render: Function; staticRenderFns: Array<Function> };
+
+  directive: (id: string, def?: Function | Object) => Function | Object | void;
+  component: (id: string, def?: Component | Object) => Component;
+  filter: (id: string, def?: Function) => Function | void;
+
+  observable: <T>(value: T) => T;
+
+  // allow dynamic method registration
+  [key: string]: any;
+}
diff --git a/typescript/modules.d.ts b/typescript/modules.d.ts
new file mode 100644
index 00000000000..deb38b7a8f1
--- /dev/null
+++ b/typescript/modules.d.ts
@@ -0,0 +1,47 @@
+declare module 'he' {
+  function escape(html: string): string
+  function decode(html: string): string
+}
+
+declare module 'source-map' {
+  class SourceMapGenerator {
+    setSourceContent(filename: string, content: string): void
+    addMapping(mapping: Object): void
+    toString(): string
+  }
+  class SourceMapConsumer {
+    constructor(map: Object)
+    originalPositionFor(position: {
+      line: number
+      column: number
+    }): {
+      source: string | null
+      line: number | null
+      column: number | null
+    }
+  }
+}
+
+declare module 'lru-cache' {
+  var exports: {
+    (): any
+  }
+}
+
+declare module 'de-indent' {
+  var exports: {
+    (input: string): string
+  }
+}
+
+declare module 'serialize-javascript' {
+  var exports: {
+    (input: string, options: { isJSON: boolean }): string
+  }
+}
+
+declare module 'lodash.template' {
+  var exports: {
+    (input: string, options: { interpolate: RegExp; escape: RegExp }): Function
+  }
+}
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
new file mode 100644
index 00000000000..02c88cec834
--- /dev/null
+++ b/typescript/options.d.ts
@@ -0,0 +1,97 @@
+import VNode from "../src/core/vdom/vnode";
+import { Component } from "./component";
+
+declare type InternalComponentOptions = {
+  _isComponent: true;
+  parent: Component;
+  _parentVnode: VNode;
+  render?: Function;
+  staticRenderFns?: Array<Function>;
+};
+
+type InjectKey = string | Symbol;
+
+declare type ComponentOptions = {
+  componentId?: string;
+
+  // data
+  data: object | Function | void;
+  props?: { [key: string]: PropOptions };
+  propsData?: object;
+  computed?: {
+    [key: string]:
+      | Function
+      | {
+          get?: Function;
+          set?: Function;
+          cache?: boolean;
+        };
+  };
+  methods?: { [key: string]: Function };
+  watch?: { [key: string]: Function | string };
+
+  // DOM
+  el?: string | Element;
+  template?: string;
+  render: (h: () => VNode) => VNode;
+  renderError?: (h: () => VNode, err: Error) => VNode;
+  staticRenderFns?: Array<() => VNode>;
+
+  // lifecycle
+  beforeCreate?: Function;
+  created?: Function;
+  beforeMount?: Function;
+  mounted?: Function;
+  beforeUpdate?: Function;
+  updated?: Function;
+  activated?: Function;
+  deactivated?: Function;
+  beforeDestroy?: Function;
+  destroyed?: Function;
+  errorCaptured?: () => boolean | void;
+  serverPrefetch?: Function;
+
+  // assets
+  directives?: { [key: string]: object };
+  components?: { [key: string]: Component };
+  transitions?: { [key: string]: object };
+  filters?: { [key: string]: Function };
+
+  // context
+  provide?: Record<string | symbol, any> | (() => Record<string | symbol, any>);
+  inject?:
+    | { [key: string]: InjectKey | { from?: InjectKey; default?: any } }
+    | Array<string>;
+
+  // component v-model customization
+  model?: {
+    prop?: string;
+    event?: string;
+  };
+
+  // misc
+  parent?: Component;
+  mixins?: Array<object>;
+  name?: string;
+  extends?: Component | object;
+  delimiters?: [string, string];
+  comments?: boolean;
+  inheritAttrs?: boolean;
+
+  // private
+  _isComponent?: true;
+  _propKeys?: Array<string>;
+  _parentVnode?: VNode;
+  _parentListeners?: object | null;
+  _renderChildren?: Array<VNode> | null;
+  _componentTag: string | null;
+  _scopeId: string | null;
+  _base: Component;
+};
+
+declare type PropOptions = {
+  type: Function | Array<Function> | null;
+  default: any;
+  required: boolean | null;
+  validator: Function | null;
+};
diff --git a/typescript/ssr.d.ts b/typescript/ssr.d.ts
new file mode 100644
index 00000000000..2f351f2164c
--- /dev/null
+++ b/typescript/ssr.d.ts
@@ -0,0 +1,27 @@
+import VNode from "../src/core/vdom/vnode";
+import { Component } from "./component";
+
+declare type ComponentWithCacheContext = {
+  type: "ComponentWithCache";
+  bufferIndex: number;
+  buffer: Array<string>;
+  key: string;
+};
+
+declare type ElementContext = {
+  type: "Element";
+  children: Array<VNode>;
+  rendered: number;
+  endTag: string;
+  total: number;
+};
+
+declare type ComponentContext = {
+  type: "Component";
+  prevActive: Component;
+};
+
+declare type RenderState =
+  | ComponentContext
+  | ComponentWithCacheContext
+  | ElementContext;
diff --git a/typescript/vnode.d.ts b/typescript/vnode.d.ts
new file mode 100644
index 00000000000..ca45d5fd3e9
--- /dev/null
+++ b/typescript/vnode.d.ts
@@ -0,0 +1,86 @@
+import VNode from "../src/core/vdom/vnode";
+import { Component } from "./component";
+
+declare type VNodeChildren =
+  | Array<null | VNode | string | VNodeChildren>
+  | string;
+
+declare type VNodeComponentOptions = {
+  Ctor: Component;
+  propsData?: Object;
+  listeners?: Object;
+  children?: Array<VNode>;
+  tag?: string;
+};
+
+declare type MountedComponentVNode = {
+  context: Component;
+  componentOptions: VNodeComponentOptions;
+  componentInstance: Component;
+  parent: VNode;
+  data: VNodeData;
+};
+
+// interface for vnodes in update modules
+declare type VNodeWithData = {
+  tag: string;
+  data: VNodeData;
+  children: Array<VNode>;
+  text: void;
+  elm: any;
+  ns: string | void;
+  context: Component;
+  key: string | number | undefined;
+  parent?: VNodeWithData;
+  componentOptions?: VNodeComponentOptions;
+  componentInstance?: Component;
+  isRootInsert: boolean;
+};
+
+declare interface VNodeData {
+  key?: string | number;
+  slot?: string;
+  ref?: string;
+  is?: string;
+  pre?: boolean;
+  tag?: string;
+  staticClass?: string;
+  class?: any;
+  staticStyle?: { [key: string]: any };
+  style?: string | Array<Object> | Object;
+  normalizedStyle?: Object;
+  props?: { [key: string]: any };
+  attrs?: { [key: string]: string };
+  domProps?: { [key: string]: any };
+  hook?: { [key: string]: Function };
+  on?: { [key: string]: Function | Array<Function> };
+  nativeOn?: { [key: string]: Function | Array<Function> };
+  transition?: Object;
+  show?: boolean; // marker for v-show
+  inlineTemplate?: {
+    render: Function;
+    staticRenderFns: Array<Function>;
+  };
+  directives?: Array<VNodeDirective>;
+  keepAlive?: boolean;
+  scopedSlots?: { [key: string]: Function };
+  model?: {
+    value: any;
+    callback: Function;
+  };
+}
+
+declare type VNodeDirective = {
+  name: string;
+  rawName: string;
+  value?: any;
+  oldValue?: any;
+  arg?: string;
+  oldArg?: string;
+  modifiers?: ASTModifiers;
+  def?: Object;
+};
+
+declare type ScopedSlotsData = Array<
+  { key: string; fn: Function } | ScopedSlotsData
+>;
diff --git a/typescript/weex.d.ts b/typescript/weex.d.ts
new file mode 100644
index 00000000000..ea138db3587
--- /dev/null
+++ b/typescript/weex.d.ts
@@ -0,0 +1,125 @@
+import { Component } from "./component";
+import { GlobalAPI } from "./global-api";
+
+// global flag to be compiled away
+declare var __WEEX__: boolean;
+
+// global object in Weex
+declare var WXEnvironment: WeexEnvironment;
+
+declare type Weex = {
+  config: WeexConfigAPI;
+  document: WeexDocument;
+  requireModule: (name: string) => Object | void;
+  supports: (condition: string) => boolean | void;
+  isRegisteredModule: (name: string, method?: string) => boolean;
+  isRegisteredComponent: (name: string) => boolean;
+};
+
+declare type WeexConfigAPI = {
+  bundleUrl: string; // === weex.document.URL
+  bundleType: string;
+  env: WeexEnvironment; // === WXEnvironment
+};
+
+declare type WeexEnvironment = {
+  platform: string; // could be "Web", "iOS", "Android"
+  weexVersion: string; // the version of WeexSDK
+
+  osName: string; // could be "iOS", "Android" or others
+  osVersion: string;
+  appName: string; // mobile app name or browser name
+  appVersion: string;
+
+  // information about current running device
+  deviceModel: string; // phone device model
+  deviceWidth: number;
+  deviceHeight: number;
+  scale: number;
+
+  // only available on the web
+  userAgent?: string;
+  dpr?: number;
+  rem?: number;
+};
+
+declare interface WeexDocument {
+  id: string;
+  URL: string;
+  taskCenter: WeexTaskCenter;
+
+  open: () => void;
+  close: () => void;
+  createElement: (tagName: string, props?: Object) => WeexElement;
+  createComment: (text: string) => Object;
+  fireEvent: (type: string) => void;
+  destroy: () => void;
+}
+
+declare interface WeexTaskCenter {
+  instanceId: string;
+  callbackManager: Object;
+  send: (type: string, params: Object, args: Array<any>, options?: Object) => void;
+  registerHook: (componentId: string, type: string, hook: string, fn: Function) => void;
+  updateData: (componentId: string, data: Object | void, callback?: Function) => void;
+}
+
+declare interface WeexElement {
+  nodeType: number;
+  nodeId: string;
+  type: string;
+  ref: string;
+  text?: string;
+
+  parentNode: WeexElement | void;
+  children: Array<WeexElement>;
+  previousSibling: WeexElement | void;
+  nextSibling: WeexElement | void;
+
+  appendChild: (node: WeexElement) => void;
+  removeChild: (node: WeexElement, preserved?: boolean) => void;
+  insertBefore: (node: WeexElement, before: WeexElement) => void;
+  insertAfter: (node: WeexElement, after: WeexElement) => void;
+  setAttr: (key: string, value: any, silent?: boolean) => void;
+  setAttrs: (attrs: Object, silent?: boolean) => void;
+  setStyle: (key: string, value: any, silent?: boolean) => void;
+  setStyles: (attrs: Object, silent?: boolean) => void;
+  addEvent: (type: string, handler: Function, args?: Array<any>) => void;
+  removeEvent: (type: string) => void;
+  fireEvent: (type: string) => void;
+  destroy: () => void;
+}
+
+declare type WeexInstanceOption = {
+  instanceId: string;
+  config: WeexConfigAPI;
+  document: WeexDocument;
+  Vue?: GlobalAPI;
+  app?: Component;
+  data?: Object;
+};
+
+declare type WeexRuntimeContext = {
+  weex: Weex;
+  service: Object;
+  BroadcastChannel?: Function;
+};
+
+declare type WeexInstanceContext = {
+  Vue: GlobalAPI;
+
+  // DEPRECATED
+  setTimeout?: Function;
+  clearTimeout?: Function;
+  setInterval?: Function;
+  clearInterval?: Function;
+};
+
+declare type WeexCompilerOptions = CompilerOptions & {
+  // whether to compile special template for <recycle-list>
+  recyclable?: boolean;
+};
+
+declare type WeexCompiledResult = CompiledResult & {
+  '@render'?: string;
+};
diff --git a/yarn.lock b/yarn.lock
index df84403791f..f03c1e11303 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -7988,10 +7988,10 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-typescript@^3.6.4:
-  version "3.6.4"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.6.4.tgz#b18752bb3792bc1a0281335f7f6ebf1bbfc5b91d"
-  integrity sha512-unoCll1+l+YK4i4F8f22TaNVPRHcD9PA3yCuZ8g5e0qGqlVlJ/8FSateOLLSagn+Yg5+ZwuPkL8LFUc0Jcvksg==
+typescript@^4.2.2:
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.3.tgz#39062d8019912d43726298f09493d598048c1ce3"
+  integrity sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==
 
 uglify-js@^3.1.4:
   version "3.13.0"

From 65b683a5e1429a19d87c7aec9cce4093f1684336 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Sat, 3 Apr 2021 16:36:50 +0100
Subject: [PATCH 002/317] fix build

---
 dist/vue.common.dev.js                        | 20149 ++++++++-------
 dist/vue.common.prod.js                       |     4 +-
 dist/vue.esm.browser.js                       | 20244 ++++++++--------
 dist/vue.esm.browser.min.js                   |     4 +-
 dist/vue.esm.js                               | 20224 ++++++++-------
 dist/vue.js                                   | 20149 ++++++++-------
 dist/vue.min.js                               |     4 +-
 dist/vue.runtime.common.dev.js                | 13572 +++++------
 dist/vue.runtime.common.prod.js               |     4 +-
 dist/vue.runtime.esm.js                       | 13628 +++++------
 dist/vue.runtime.js                           | 13572 +++++------
 dist/vue.runtime.min.js                       |     4 +-
 package.json                                  |     1 +
 packages/vue-server-renderer/basic.js         | 14185 +++++------
 packages/vue-server-renderer/build.dev.js     | 15922 ++++++------
 packages/vue-server-renderer/build.prod.js    |     2 +-
 packages/vue-server-renderer/client-plugin.js |   136 +-
 packages/vue-server-renderer/server-plugin.js |   160 +-
 packages/vue-template-compiler/browser.js     |  8423 +++----
 packages/vue-template-compiler/build.js       |  8564 +++----
 scripts/config.js                             |    63 +-
 src/compiler/codegen/events.ts                |     2 -
 src/compiler/parser/index.ts                  |     2 +-
 src/core/config.ts                            |    10 +-
 src/core/index.ts                             |     1 -
 src/core/instance/index.ts                    |    10 +-
 src/core/instance/lifecycle.ts                |     6 +-
 src/core/instance/proxy.ts                    |     2 +-
 src/core/instance/render.ts                   |    13 +-
 src/core/instance/state.ts                    |    15 +-
 src/core/observer/index.ts                    |     2 +-
 src/core/util/props.ts                        |     1 -
 src/core/vdom/create-component.ts             |     1 -
 src/core/vdom/create-element.ts               |     1 -
 src/core/vdom/create-functional-component.ts  |     4 +-
 src/core/vdom/helpers/update-listeners.ts     |     1 -
 src/core/vdom/patch.ts                        |     1 -
 src/global.d.ts                               |    22 +
 src/platforms/web/compiler/modules/model.ts   |     2 +-
 .../web/entry-runtime-with-compiler.ts        |     1 -
 src/platforms/web/runtime/index.ts            |     5 +-
 src/platforms/web/runtime/modules/style.ts    |     1 -
 src/platforms/web/server/directives/model.ts  |     1 +
 src/platforms/web/server/modules/attrs.ts     |     1 +
 src/platforms/web/server/modules/dom-props.ts |     1 +
 src/platforms/web/util/attrs.ts               |     4 +-
 tsconfig.json                                 |     9 +-
 typescript/component.d.ts                     |    42 +-
 typescript/global-api.d.ts                    |     1 +
 typescript/weex.d.ts                          |     2 +-
 yarn.lock                                     |   137 +
 51 files changed, 79270 insertions(+), 90045 deletions(-)
 create mode 100644 src/global.d.ts

diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index 41f17e2f943..d2b34780db6 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -1,193 +1,159 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
 'use strict';
 
-/*  */
-
+/* @flow */
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
-function isRegExp (v) {
-  return _toString.call(v) === '[object RegExp]'
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Capitalize a string.
  */
 var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -195,1113 +161,987 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
-function toArray (list, start) {
-  start = start || 0;
-  var i = list.length - start;
-  var ret = new Array(i);
-  while (i--) {
-    ret[i] = list[i + start];
-  }
-  return ret
+function toArray(list, start) {
+    start = start || 0;
+    var i = list.length - start;
+    var ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
 }
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys(modules) {
+    return modules
+        .reduce(function (keys, m) {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
+function looseEqual(a, b) {
+    if (a === b)
+        { return true; }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every(function (e, i) {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every(function (key) {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
     }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (var i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            { return i; }
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
+function once(fn) {
+    var called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
 var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: "development" !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: "development" !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Check if a string starts with $ or _
  */
-function isReserved (str) {
-  var c = (str + '').charCodeAt(0);
-  return c === 0x24 || c === 0x5F
+function isReserved(str) {
+    var c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
 }
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
-
 /**
  * Parse simple path.
  */
 var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-function parsePath (path) {
-  if (bailRE.test(path)) {
-    return
-  }
-  var segments = path.split('.');
-  return function (obj) {
-    for (var i = 0; i < segments.length; i++) {
-      if (!obj) { return }
-      obj = obj[segments[i]];
-    }
-    return obj
-  }
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    var segments = path.split('.');
+    return function (obj) {
+        for (var i = 0; i < segments.length; i++) {
+            if (!obj)
+                { return; }
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 var isPhantomJS = UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
-
+// @ts-ignore
+var nativeWatch = {}.watch;
 var supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-        /* istanbul ignore next */
-        supportsPassive = true;
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/(function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function has (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function add (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function clear () {
+            this.set = Object.create(null);
+        };
 
-    return Set;
-  }());
+        return Set;
+    }());
 }
 
-/*  */
-
+/* @flow */
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace);
-    } else if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
-}
-
-/*  */
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
+    };
+    var repeat = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
+                    .join('\n'));
+        }
+        else {
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+        }
+    };
+}
 
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
 };
-
 Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
+    this.subs.push(sub);
 };
-
 Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
+    remove(this.subs, sub);
 };
-
 Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
+    if (Dep.target) {
+        Dep.target.addDep(this);
+    }
 };
-
 Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (!config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (!config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
 };
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
-}
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
-}
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
+}
+
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
 };
 
 var prototypeAccessors = { child: { configurable: true } };
-
 // DEPRECATED: alias for componentInstance for backwards compat.
 /* istanbul ignore next */
 prototypeAccessors.child.get = function () {
-  return this.componentInstance
+    return this.componentInstance;
 };
 
 Object.defineProperties( VNode.prototype, prototypeAccessors );
-
 var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
+    if ( text === void 0 ) text = '';
 
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    var cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
+        }
+        else {
+            copyAugment(value, arrayMethods, arrayKeys);
+        }
+        this.observeArray(value);
+    }
+    else {
+        this.walk(value);
+    }
 };
-
 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive$$1(obj, keys[i]);
+    }
 };
-
 /**
  * Observe a list of Array items.
  */
 Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
 };
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Delete a property and trigger change if necessary.
  */
-function del (target, key) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1);
-    return
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    );
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key];
-  if (!ob) {
-    return
-  }
-  ob.dep.notify();
+function del(target, key) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    var ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
-}
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
-    }
-  }
-  return res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1309,609 +1149,540 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && "development" !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (var key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
-}
-
+function normalizeProps(options, vm) {
+    var props = options.props;
+    if (!props)
+        { return; }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (var key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn("Invalid value for option \"props\": expected an Array or an Object, " +
+            "but got " + (toRawType(props)) + ".", vm);
+    }
+    options.props = res;
+}
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    var inject = options.inject;
+    if (!inject)
+        { return; }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (var i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (var key in inject) {
+            var val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+            "but got " + (toRawType(inject)) + ".", vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
-    }
-  }
-}
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function normalizeDirectives(options) {
+    var dirs = options.directives;
+    if (dirs) {
+        for (var key in dirs) {
+            var def$$1 = dirs[key];
+            if (typeof def$$1 === 'function') {
+                dirs[key] = { bind: def$$1, update: def$$1 };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            "but got " + (toRawType(value)) + ".", vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        var strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        { return assets[id]; }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        { return assets[camelizedId]; }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        { return assets[PascalCaseId]; }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+/* @flow */
+function validateProp(key, propOptions, propsData, vm) {
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            var stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        var prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
-}
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        var t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid: valid,
+        expectedType: expectedType,
+    };
+}
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
-}
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
-}
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
-    }
-  }
-  return -1
-}
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  var expectedValue = styleValue(value, expectedType);
-  var receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += " with value " + expectedValue;
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + receivedValue + ".";
-  }
-  return message
-}
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
-}
-
-function isExplicable (value) {
-  var explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
-}
-
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
-}
-
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
-            }
-          }
+function getType(fn) {
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
         }
-      }
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
-}
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
-}
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
-    try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler');
-      }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += " with value " + (styleValue(value, expectedType));
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += "with value " + (styleValue(value, receivedType)) + ".";
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return ("\"" + value + "\"");
+    }
+    else if (type === 'Number') {
+        return ("" + (Number(value)));
+    }
+    else {
+        return ("" + value);
     }
-  }
-  logError(err, vm, info);
 }
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+}
+function isBoolean() {
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-function logError (err, vm, info) {
-  {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
-/*  */
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            var cur = vm;
+            while ((cur = cur.$parent)) {
+                var hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (var i = 0; i < hooks.length; i++) {
+                        try {
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                { return; }
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    var res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
+}
 
+/* @flow */
 var isUsingMicroTask = false;
-
 var callbacks = [];
 var pending = false;
-
-function flushCallbacks () {
-  pending = false;
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    pending = false;
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // Here we have async deferring wrappers using microtasks.
 // In 2.5 we used (macro) tasks (in combination with microtasks).
 // However, it has subtle problems when state is changed right before repaint
@@ -1924,7 +1695,6 @@ function flushCallbacks () {
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
 var timerFunc;
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1933,3799 +1703,3315 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  var p = Promise.resolve();
-  timerFunc = function () {
-    p.then(flushCallbacks);
-    // In problematic UIWebViews, Promise.then doesn't completely break, but
-    // it can get stuck in a weird state where callbacks are pushed into the
-    // microtask queue but the queue isn't being flushed, until the browser
-    // needs to do some other work, e.g. handle a timer. Therefore we can
-    // "force" the microtask queue to be flushed by adding an empty timer.
-    if (isIOS) { setTimeout(noop); }
-  };
-  isUsingMicroTask = true;
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-  timerFunc = function () {
-    counter = (counter + 1) % 2;
-    textNode.data = String(counter);
-  };
-  isUsingMicroTask = true;
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Technically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = function () {
-    setImmediate(flushCallbacks);
-  };
-} else {
-  // Fallback to setTimeout.
-  timerFunc = function () {
-    setTimeout(flushCallbacks, 0);
-  };
-}
-
-function nextTick (cb, ctx) {
-  var _resolve;
-  callbacks.push(function () {
-    if (cb) {
-      try {
-        cb.call(ctx);
-      } catch (e) {
-        handleError(e, ctx, 'nextTick');
-      }
-    } else if (_resolve) {
-      _resolve(ctx);
-    }
-  });
-  if (!pending) {
-    pending = true;
-    timerFunc();
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(function (resolve) {
-      _resolve = resolve;
-    })
-  }
-}
-
-/*  */
+    var p = Promise.resolve();
+    timerFunc = function () {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            { setTimeout(noop); }
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = function () {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = function () {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = function () {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    var _resolve;
+    callbacks.push(function () {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise(function (resolve) {
+            _resolve = resolve;
+        });
+    }
+}
+
+/* @flow */
 
 var mark;
 var measure;
-
 {
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = function (tag) { return perf.mark(tag); };
-    measure = function (name, startTag, endTag) {
-      perf.measure(name, startTag, endTag);
-      perf.clearMarks(startTag);
-      perf.clearMarks(endTag);
-      // perf.clearMeasures(name)
-    };
-  }
+    var perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
+        measure = function (name, startTag, endTag) {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 var initProxy;
-
 {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var warnNonPresent = function (target, key) {
-    warn(
-      "Property or method \"" + key + "\" is not defined on the instance but " +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
     );
-  };
-
-  var warnReservedPrefix = function (target, key) {
-    warn(
-      "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
-    );
-  };
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
-
-  var hasHandler = {
-    has: function has (target, key) {
-      var has = key in target;
-      var isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-      if (!has && !isAllowed) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return has || !isAllowed
-    }
-  };
-
-  var getHandler = {
-    get: function get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return target[key]
-    }
-  };
-
-  initProxy = function initProxy (vm) {
+    var warnNonPresent = function (target, key) {
+        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    var warnReservedPrefix = function (target, key) {
+        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-      // determine which proxy handler to use
-      var options = vm.$options;
-      var handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler;
-      vm._renderProxy = new Proxy(vm, handlers);
-    } else {
-      vm._renderProxy = vm;
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
     }
-  };
+    var hasHandler = {
+        has: function has(target, key) {
+            var has = key in target;
+            var isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return has || !isAllowed;
+        },
+    };
+    var getHandler = {
+        get: function get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            var options = vm.$options;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-/*  */
-
+/* @flow */
 var seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
-}
-
-/*  */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    var i, keys;
+    var isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        var depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            { _traverse(val[i], seen); }
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            { _traverse(val[keys[i]], seen); }
+    }
+}
 
 var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+    var passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once$$1 ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name: name,
+        once: once$$1,
+        capture: capture,
+        passive: passive,
+    };
 });
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        var arguments$1 = arguments;
+
+        var fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+    var name, def$$1, cur, old, event;
+    for (name in on) {
+        def$$1 = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove$$1(event.name, oldOn[name], event.capture);
+        }
+    }
+}
 
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
-}
-
-/*  */
-
-function mergeVNodeHook (def, hookKey, hook) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {});
-  }
-  var invoker;
-  var oldHook = def[hookKey];
-
-  function wrappedHook () {
-    hook.apply(this, arguments);
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook);
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook]);
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook;
-      invoker.fns.push(wrappedHook);
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook]);
-    }
-  }
-
-  invoker.merged = true;
-  def[hookKey] = invoker;
-}
-
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
-}
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+/* @flow */
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    var invoker;
+    var oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
+}
+
+/* @flow */
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    var res = {};
+    var attrs = data.attrs;
+    var props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
+            {
+                var keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
+}
 
+/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (var i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
-
-function initProvide (vm) {
-  var provide = vm.$options.provide;
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide;
-  }
-}
-
-function initInjections (vm) {
-  var result = resolveInject(vm.$options.inject, vm);
-  if (result) {
-    toggleObserving(false);
-    Object.keys(result).forEach(function (key) {
-      /* istanbul ignore else */
-      {
-        defineReactive$$1(vm, key, result[key], function () {
-          warn(
-            "Avoid mutating an injected value directly since the changes will be " +
-            "overwritten whenever the provided component re-renders. " +
-            "injection being mutated: \"" + key + "\"",
-            vm
-          );
-        });
-      }
-    });
-    toggleObserving(true);
-  }
-}
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            { continue; }
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                }
+                res.push(c);
+            }
         }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else {
-          warn(("Injection \"" + key + "\" not found"), vm);
+    }
+    return res;
+}
+
+/* @flow */
+function initProvide(vm) {
+    var provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    var result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach(function (key) {
+            /* istanbul ignore else */
+            {
+                defineReactive$$1(vm, key, result[key], function () {
+                    warn("Avoid mutating an injected value directly since the changes will be " +
+                        "overwritten whenever the provided component re-renders. " +
+                        "injection being mutated: \"" + key + "\"", vm);
+                });
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                { continue; }
+            var provideKey = inject[key].from;
+            var source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    var provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    // @ts-ignore
+                    warn(("Injection \"" + key + "\" not found"), vm);
+                }
+            }
         }
-      }
+        return result;
     }
-    return result
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+/* @flow */
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return function () { return slots[key]; };
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    var ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
-}
-
-/*  */
-
-/**
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
+}
+
+/**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (!isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+/* @flow */
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
-}
-
-/*  */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+}
 
+/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn('v-bind without argument expects an Object or Array value', this);
         }
-      };
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            var hash;
+            var loop = function ( key ) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    var type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        var on = data.on || (data.on = {});
+                        on[("update:" + key)] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            };
 
-      for (var key in value) loop( key );
+            for (var key in value) loop( key );
+        }
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, ("__static__" + index), false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
+function markOnce(tree, index, key) {
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (var i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
+/* @flow */
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
     }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+    return data;
 }
 
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
-}
-
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
-}
-
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+/* @flow */
+function bindDynamicKeys(baseObj, values) {
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
-    }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+/* @flow */
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+/* @flow */
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    var this$1 = this;
+
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        }
+        return this$1.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get: function get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = function (a, b, c, d) {
+            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (var key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            { mergeProps(props, data.attrs); }
+        if (isDef(data.props))
+            { mergeProps(props, data.props); }
+    }
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (var key in from) {
+        to[camelize(key)] = from[key];
+    }
+}
 
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-    }
-    return res
-  }
-}
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
-}
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
-}
-
-/*  */
-
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
+
+/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init: function init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            var mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch: function prepatch(oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy: function destroy(vnode) {
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
-    }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
-    }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent // activeInstance in lifecycle state
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-    }
-  }
-}
-
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
+        }
+        return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        var slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
+    // @ts-expect-error
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    var options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook$1(f1, f2) {
+    var merged = function (a, b) {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
-}
-
-/*  */
+function transformModel(options, data) {
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
+}
 
+/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (isDef(data) && isDef(data.nativeOn)) {
-        warn(
-          ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-          context
-        );
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      );
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === 'string') {
+        var Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            { applyNS(vnode, ns); }
+        if (isDef(data))
+            { registerDeepBindings(data); }
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
-}
-
-/*  */
-
-function initRender (vm) {
-  vm._vnode = null; // the root of the child tree
-  vm._staticTrees = null; // v-once cached trees
-  var options = vm.$options;
-  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-  var renderContext = parentVnode && parentVnode.context;
-  vm.$slots = resolveSlots(options._renderChildren, renderContext);
-  vm.$scopedSlots = emptyObject;
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  var parentData = parentVnode && parentVnode.data;
-
-  /* istanbul ignore else */
-  {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-    }, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-    }, true);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
+}
+
+/* @flow */
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    var parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        }, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        }, true);
+    }
 }
-
 var currentRenderingInstance = null;
-
-function renderMixin (Vue) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype);
-
-  Vue.prototype.$nextTick = function (fn) {
-    return nextTick(fn, this)
-  };
-
-  Vue.prototype._render = function () {
-    var vm = this;
-    var ref = vm.$options;
-    var render = ref.render;
-    var _parentVnode = ref._parentVnode;
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      );
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode;
-    // render self
-    var vnode;
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm;
-      vnode = render.call(vm._renderProxy, vm.$createElement);
-    } catch (e) {
-      handleError(e, vm, "render");
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-        } catch (e) {
-          handleError(e, vm, "renderError");
-          vnode = vm._vnode;
-        }
-      } else {
-        vnode = vm._vnode;
-      }
-    } finally {
-      currentRenderingInstance = null;
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0];
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        );
-      }
-      vnode = createEmptyVNode();
-    }
-    // set parent
-    vnode.parent = _parentVnode;
-    return vnode
-  };
-}
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
-        }
-      }
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
     };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
+    Vue.prototype._render = function () {
+        var vm = this;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        var vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        catch (e) {
+            handleError(e, vm, "render");
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, "renderError");
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                "timeout (" + (res.timeout) + "ms)"
-              );
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
             }
-          }, res.timeout);
+            vnode = createEmptyVNode();
         }
-      }
-    }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-/*  */
-
-function getFirstComponentChild (children) {
-  if (Array.isArray(children)) {
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
+/* @flow */
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
     }
-  }
+    return isObject(comp) ? base.extend(comp) : comp;
 }
-
-/*  */
-
-/*  */
-
-function initEvents (vm) {
-  vm._events = Object.create(null);
-  vm._hasHookEvent = false;
-  // init parent attached events
-  var listeners = vm.$options._parentListeners;
-  if (listeners) {
-    updateComponentListeners(vm, listeners);
-  }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    return node;
 }
-
-var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
-}
-
-function remove$1 (event, fn) {
-  target.$off(event, fn);
-}
-
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
-    }
-  }
-}
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
-}
-
-function eventsMixin (Vue) {
-  var hookRE = /^hook:/;
-  Vue.prototype.$on = function (event, fn) {
-    var vm = this;
-    if (Array.isArray(event)) {
-      for (var i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn);
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn);
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true;
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$once = function (event, fn) {
-    var vm = this;
-    function on () {
-      vm.$off(event, on);
-      fn.apply(vm, arguments);
-    }
-    on.fn = fn;
-    vm.$on(event, on);
-    return vm
-  };
-
-  Vue.prototype.$off = function (event, fn) {
-    var vm = this;
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null);
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-        vm.$off(event[i$1], fn);
-      }
-      return vm
-    }
-    // specific event
-    var cbs = vm._events[event];
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null;
-      return vm
-    }
-    // specific handler
-    var cb;
-    var i = cbs.length;
-    while (i--) {
-      cb = cbs[i];
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1);
-        break
-      }
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
     }
-    return vm
-  };
-
-  Vue.prototype.$emit = function (event) {
-    var vm = this;
-    {
-      var lowerCaseEvent = event.toLowerCase();
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-          "Note that HTML attributes are case-insensitive and you cannot use " +
-          "v-on to listen to camelCase events when using in-DOM templates. " +
-          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-        );
-      }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
     }
-    var cbs = vm._events[event];
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-      var args = toArray(arguments, 1);
-      var info = "event handler for \"" + event + "\"";
-      for (var i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-      }
+    var owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
     }
-    return vm
-  };
-}
-
-/*  */
-
-var activeInstance = null;
-var isUpdatingChildComponent = false;
-
-function setActiveInstance(vm) {
-  var prevActiveInstance = activeInstance;
-  activeInstance = vm;
-  return function () {
-    activeInstance = prevActiveInstance;
-  }
-}
-
-function initLifecycle (vm) {
-  var options = vm.$options;
-
-  // locate first non-abstract parent
-  var parent = options.parent;
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
-    }
-    parent.$children.push(vm);
-  }
-
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
-
-  vm.$children = [];
-  vm.$refs = {};
-
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
-}
-
-function lifecycleMixin (Vue) {
-  Vue.prototype._update = function (vnode, hydrating) {
-    var vm = this;
-    var prevEl = vm.$el;
-    var prevVnode = vm._vnode;
-    var restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
-    }
-    restoreActiveInstance();
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null;
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm;
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  };
-
-  Vue.prototype.$forceUpdate = function () {
-    var vm = this;
-    if (vm._watcher) {
-      vm._watcher.update();
-    }
-  };
-
-  Vue.prototype.$destroy = function () {
-    var vm = this;
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy');
-    vm._isBeingDestroyed = true;
-    // remove self from parent
-    var parent = vm.$parent;
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
-    }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown();
-    }
-    var i = vm._watchers.length;
-    while (i--) {
-      vm._watchers[i].teardown();
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
-    }
-    // call the last hook...
-    vm._isDestroyed = true;
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
-    // fire destroyed hook
-    callHook(vm, 'destroyed');
-    // turn off all instance listeners.
-    vm.$off();
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null;
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null;
-    }
-  };
-}
-
-function mountComponent (
-  vm,
-  el,
-  hydrating
-) {
-  vm.$el = el;
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode;
-    {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        );
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        );
-      }
-    }
-  }
-  callHook(vm, 'beforeMount');
-
-  var updateComponent;
-  /* istanbul ignore if */
-  if (config.performance && mark) {
-    updateComponent = function () {
-      var name = vm._name;
-      var id = vm._uid;
-      var startTag = "vue-perf-start:" + id;
-      var endTag = "vue-perf-end:" + id;
-
-      mark(startTag);
-      var vnode = vm._render();
-      mark(endTag);
-      measure(("vue " + name + " render"), startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(("vue " + name + " patch"), startTag, endTag);
-    };
-  } else {
-    updateComponent = function () {
-      vm._update(vm._render(), hydrating);
-    };
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before: function before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate');
-      }
-    }
-  }, true /* isRenderWatcher */);
-  hydrating = false;
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  }
-  return vm
-}
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-  {
-    isUpdatingChildComponent = true;
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        var resolve = once(function (res) {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        var reject = once(function (reason) {
+            warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject("timeout (" + (res.timeout) + "ms)");
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
     }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-
-  {
-    isUpdatingChildComponent = false;
-  }
 }
 
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
+/* @flow */
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+/* @flow */
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+            var c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
     }
-    callHook(vm, 'activated');
-  }
 }
 
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
-    }
-    callHook(vm, 'deactivated');
-  }
-}
+/* @flow */
 
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+/* @flow */
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    var listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
     }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
 }
-
-/*  */
-
-var MAX_UPDATE_COUNT = 100;
-
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index = 0;
-
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0;
-  has = {};
-  {
-    circular = {};
-  }
-  waiting = flushing = false;
+var target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    var _target = target;
+    return function onceHandler() {
+        var res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
 }
-
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-var currentFlushTimestamp = 0;
-
-// Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
-
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    target = undefined;
+}
+function eventsMixin(Vue) {
+    var hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        var vm = this;
+        if (Array.isArray(event)) {
+            for (var i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        var vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        var vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
+            }
+            return vm;
+        }
+        // specific event
+        var cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        var cb;
+        var i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        var vm = this;
+        {
+            var lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    "Note that HTML attributes are case-insensitive and you cannot use " +
+                    "v-on to listen to camelCase events when using in-DOM templates. " +
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+            }
+        }
+        var cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            var args = toArray(arguments, 1);
+            var info = "event handler for \"" + event + "\"";
+            for (var i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
+}
+
+/* @flow */
+var activeInstance = null;
+var isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    var prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return function () {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    var options = vm.$options;
+    // locate first non-abstract parent
+    var parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        var vm = this;
+        var prevEl = vm.$el;
+        var prevVnode = vm._vnode;
+        var restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        var vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        var vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook(vm, 'beforeDestroy');
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        var parent = vm.$parent;
+        // @ts-ignore
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        var i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook(vm, 'destroyed');
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            // @ts-expect-error null is not undefined
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                vm.$options.el ||
+                el) {
+                warn('You are using the runtime-only build of Vue where the template ' +
+                    'compiler is not available. Either pre-compile the templates into ' +
+                    'render functions, or use the compiler-included build.', vm);
+            }
+            else {
+                warn('Failed to mount component: template or render function not defined.', vm);
+            }
+        }
+    }
+    callHook(vm, 'beforeMount');
+    var updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+        updateComponent = function () {
+            var name = vm._name;
+            var id = vm._uid;
+            var startTag = "vue-perf-start:" + id;
+            var endTag = "vue-perf-end:" + id;
+            mark(startTag);
+            var vnode = vm._render();
+            mark(endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = function () {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before: function before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook(vm, 'beforeUpdate');
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook(vm, 'mounted');
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            { return true; }
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (var i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'activated');
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (var i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'deactivated');
+    }
+}
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
+    }
+    popTarget();
 }
 
+/* @flow */
+var MAX_UPDATE_COUNT = 100;
+var queue = [];
+var activatedChildren = [];
+var has = {};
+var circular = {};
+var waiting = false;
+var flushing = false;
+var index = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+var currentFlushTimestamp = 0;
+// Async edge case fix requires storing an event listener's attach timestamp.
+var getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = function () { return performance.now(); };
+    }
+}
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow();
-  flushing = true;
-  var watcher, id;
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort(function (a, b) { return a.id - b.id; });
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index];
-    if (watcher.before) {
-      watcher.before();
-    }
-    id = watcher.id;
-    has[id] = null;
-    watcher.run();
-    // in dev build, check and stop circular updates.
-    if (has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1;
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-              : "in a component render function."
-          ),
-          watcher.vm
-        );
-        break
-      }
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    var watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort(function (a, b) { return a.id - b.id; });
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        : "in a component render function."), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
     }
-  }
-
-  // keep copies of post queues before resetting state
-  var activatedQueue = activatedChildren.slice();
-  var updatedQueue = queue.slice();
-
-  resetSchedulerState();
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue);
-  callUpdatedHooks(updatedQueue);
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush');
-  }
 }
-
-function callUpdatedHooks (queue) {
-  var i = queue.length;
-  while (i--) {
-    var watcher = queue[i];
-    var vm = watcher.vm;
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated');
+function callUpdatedHooks(queue) {
+    var i = queue.length;
+    while (i--) {
+        var watcher = queue[i];
+        var vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook(vm, 'updated');
+        }
     }
-  }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-  activatedChildren.push(vm);
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
 }
-
-function callActivatedHooks (queue) {
-  for (var i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true;
-    activateChildComponent(queue[i], true /* true */);
-  }
+function callActivatedHooks(queue) {
+    for (var i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
 }
-
 /**
  * Push a watcher into the watcher queue.
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-function queueWatcher (watcher) {
-  var id = watcher.id;
-  if (has[id] == null) {
-    has[id] = true;
-    if (!flushing) {
-      queue.push(watcher);
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      var i = queue.length - 1;
-      while (i > index && queue[i].id > watcher.id) {
-        i--;
-      }
-      queue.splice(i + 1, 0, watcher);
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true;
-
-      if (!config.async) {
-        flushSchedulerQueue();
-        return
-      }
-      nextTick(flushSchedulerQueue);
+function queueWatcher(watcher) {
+    var id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            var i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (!config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
     }
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 var uid$2 = 0;
-
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher (
-  vm,
-  expOrFn,
-  cb,
-  options,
-  isRenderWatcher
-) {
-  this.vm = vm;
-  if (isRenderWatcher) {
-    vm._watcher = this;
-  }
-  vm._watchers.push(this);
-  // options
-  if (options) {
-    this.deep = !!options.deep;
-    this.user = !!options.user;
-    this.lazy = !!options.lazy;
-    this.sync = !!options.sync;
-    this.before = options.before;
-  } else {
-    this.deep = this.user = this.lazy = this.sync = false;
-  }
-  this.cb = cb;
-  this.id = ++uid$2; // uid for batching
-  this.active = true;
-  this.dirty = this.lazy; // for lazy watchers
-  this.deps = [];
-  this.newDeps = [];
-  this.depIds = new _Set();
-  this.newDepIds = new _Set();
-  this.expression = expOrFn.toString();
-  // parse expression for getter
-  if (typeof expOrFn === 'function') {
-    this.getter = expOrFn;
-  } else {
-    this.getter = parsePath(expOrFn);
-    if (!this.getter) {
-      this.getter = noop;
-      warn(
-        "Failed watching path: \"" + expOrFn + "\" " +
-        'Watcher only accepts simple dot-delimited paths. ' +
-        'For full control, use a function instead.',
-        vm
-      );
-    }
-  }
-  this.value = this.lazy
-    ? undefined
-    : this.get();
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$2; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        expOrFn.toString();
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            warn("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+        }
+    }
+    this.value = this.lazy ? undefined : this.get();
 };
-
 /**
  * Evaluate the getter, and re-collect dependencies.
  */
 Watcher.prototype.get = function get () {
-  pushTarget(this);
-  var value;
-  var vm = this.vm;
-  try {
-    value = this.getter.call(vm, vm);
-  } catch (e) {
-    if (this.user) {
-      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-    } else {
-      throw e
-    }
-  } finally {
-    // "touch" every property so they are all tracked as
-    // dependencies for deep watching
-    if (this.deep) {
-      traverse(value);
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
     }
-    popTarget();
-    this.cleanupDeps();
-  }
-  return value
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+        }
+        else {
+            throw e;
+        }
+    }
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
+        }
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
 };
-
 /**
  * Add a dependency to this directive.
  */
 Watcher.prototype.addDep = function addDep (dep) {
-  var id = dep.id;
-  if (!this.newDepIds.has(id)) {
-    this.newDepIds.add(id);
-    this.newDeps.push(dep);
-    if (!this.depIds.has(id)) {
-      dep.addSub(this);
-    }
-  }
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
 };
-
 /**
  * Clean up for dependency collection.
  */
 Watcher.prototype.cleanupDeps = function cleanupDeps () {
-  var i = this.deps.length;
-  while (i--) {
-    var dep = this.deps[i];
-    if (!this.newDepIds.has(dep.id)) {
-      dep.removeSub(this);
-    }
-  }
-  var tmp = this.depIds;
-  this.depIds = this.newDepIds;
-  this.newDepIds = tmp;
-  this.newDepIds.clear();
-  tmp = this.deps;
-  this.deps = this.newDeps;
-  this.newDeps = tmp;
-  this.newDeps.length = 0;
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
 };
-
 /**
  * Subscriber interface.
  * Will be called when a dependency changes.
  */
 Watcher.prototype.update = function update () {
-  /* istanbul ignore else */
-  if (this.lazy) {
-    this.dirty = true;
-  } else if (this.sync) {
-    this.run();
-  } else {
-    queueWatcher(this);
-  }
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
 };
-
 /**
  * Scheduler job interface.
  * Will be called by the scheduler.
  */
 Watcher.prototype.run = function run () {
-  if (this.active) {
-    var value = this.get();
-    if (
-      value !== this.value ||
-      // Deep watchers and watchers on Object/Arrays should fire even
-      // when the value is the same, because the value may
-      // have mutated.
-      isObject(value) ||
-      this.deep
-    ) {
-      // set new value
-      var oldValue = this.value;
-      this.value = value;
-      if (this.user) {
-        try {
-          this.cb.call(this.vm, value, oldValue);
-        } catch (e) {
-          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
+            if (this.user) {
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
+            }
+            else {
+                this.cb.call(this.vm, value, oldValue);
+            }
         }
-      } else {
-        this.cb.call(this.vm, value, oldValue);
-      }
     }
-  }
 };
-
 /**
  * Evaluate the value of the watcher.
  * This only gets called for lazy watchers.
  */
 Watcher.prototype.evaluate = function evaluate () {
-  this.value = this.get();
-  this.dirty = false;
+    this.value = this.get();
+    this.dirty = false;
 };
-
 /**
  * Depend on all deps collected by this watcher.
  */
 Watcher.prototype.depend = function depend () {
-  var i = this.deps.length;
-  while (i--) {
-    this.deps[i].depend();
-  }
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
 };
-
 /**
  * Remove self from all dependencies' subscriber list.
  */
 Watcher.prototype.teardown = function teardown () {
-  if (this.active) {
-    // remove self from vm's watcher list
-    // this is a somewhat expensive operation so we skip it
-    // if the vm is being destroyed.
-    if (!this.vm._isBeingDestroyed) {
-      remove(this.vm._watchers, this);
-    }
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].removeSub(this);
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove(this.vm._watchers, this);
+        }
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].removeSub(this);
+        }
+        this.active = false;
     }
-    this.active = false;
-  }
 };
 
-/*  */
-
+/* @flow */
 var sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
 };
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    var opts = vm.$options;
+    if (opts.props)
+        { initProps(vm, opts.props); }
+    if (opts.methods)
+        { initMethods(vm, opts.methods); }
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        { initComputed(vm, opts.computed); }
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps(vm, propsOptions) {
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    var loop = function ( key ) {
+        keys.push(key);
+        var value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        {
+            var hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+            }
+            defineReactive$$1(props, key, value, function () {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn("Avoid mutating a prop directly since the value will be " +
+                        "overwritten whenever the parent component re-renders. " +
+                        "Instead, use a data or computed property based on the prop's " +
+                        "value. Prop being mutated: \"" + key + "\"", vm);
+                }
+            });
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, "_props", key);
+        }
+    };
 
-function proxy (target, sourceKey, key) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  };
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function initState (vm) {
-  vm._watchers = [];
-  var opts = vm.$options;
-  if (opts.props) { initProps(vm, opts.props); }
-  if (opts.methods) { initMethods(vm, opts.methods); }
-  if (opts.data) {
-    initData(vm);
-  } else {
-    observe(vm._data = {}, true /* asRootData */);
-  }
-  if (opts.computed) { initComputed(vm, opts.computed); }
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
-  }
-}
-
-function initProps (vm, propsOptions) {
-  var propsData = vm.$options.propsData || {};
-  var props = vm._props = {};
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  var keys = vm.$options._propKeys = [];
-  var isRoot = !vm.$parent;
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false);
-  }
-  var loop = function ( key ) {
-    keys.push(key);
-    var value = validateProp(key, propsOptions, propsData, vm);
-    /* istanbul ignore else */
-    {
-      var hyphenatedKey = hyphenate(key);
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-          vm
-        );
-      }
-      defineReactive$$1(props, key, value, function () {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            "Avoid mutating a prop directly since the value will be " +
-            "overwritten whenever the parent component re-renders. " +
-            "Instead, use a data or computed property based on the prop's " +
-            "value. Prop being mutated: \"" + key + "\"",
-            vm
-          );
-        }
-      });
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, "_props", key);
-    }
-  };
-
-  for (var key in propsOptions) loop( key );
-  toggleObserving(true);
-}
-
-function initData (vm) {
-  var data = vm.$options.data;
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (!isPlainObject(data)) {
-    data = {};
-    warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    );
-  }
-  // proxy data on instance
-  var keys = Object.keys(data);
-  var props = vm.$options.props;
-  var methods = vm.$options.methods;
-  var i = keys.length;
-  while (i--) {
-    var key = keys[i];
-    {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a data property."),
-          vm
-        );
-      }
-    }
-    if (props && hasOwn(props, key)) {
-      warn(
-        "The data property \"" + key + "\" is already declared as a prop. " +
-        "Use prop default value instead.",
-        vm
-      );
-    } else if (!isReserved(key)) {
-      proxy(vm, "_data", key);
-    }
-  }
-  // observe data
-  observe(data, true /* asRootData */);
-}
-
-function getData (data, vm) {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget();
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, "data()");
-    return {}
-  } finally {
-    popTarget();
-  }
+    for (var key in propsOptions) loop( key );
+    toggleObserving(true);
 }
-
-var computedWatcherOptions = { lazy: true };
-
-function initComputed (vm, computed) {
-  // $flow-disable-line
-  var watchers = vm._computedWatchers = Object.create(null);
-  // computed properties are just getters during SSR
-  var isSSR = isServerRendering();
-
-  for (var key in computed) {
-    var userDef = computed[key];
-    var getter = typeof userDef === 'function' ? userDef : userDef.get;
-    if (getter == null) {
-      warn(
-        ("Getter is missing for computed property \"" + key + "\"."),
-        vm
-      );
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      );
-    }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else {
-      if (key in vm.$data) {
-        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-      }
-    }
-  }
-}
-
-function defineComputed (
-  target,
-  key,
-  userDef
-) {
-  var shouldCache = !isServerRendering();
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
-  }
-  if (sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-        this
-      );
-    };
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
+function initData(vm) {
+    var data = vm.$options.data;
+    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        warn('data functions should return an object:\n' +
+                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+    }
+    // proxy data on instance
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
+    while (i--) {
+        var key = keys[i];
+        {
+            if (methods && hasOwn(methods, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            warn("The data property \"" + key + "\" is already declared as a prop. " +
+                    "Use prop default value instead.", vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, "_data", key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
 }
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    var watcher = this._computedWatchers && this._computedWatchers[key];
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate();
-      }
-      if (Dep.target) {
-        watcher.depend();
-      }
-      return watcher.value
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
+    }
+    catch (e) {
+        handleError(e, vm, "data()");
+        return {};
+    }
+    finally {
+        popTarget();
     }
-  }
 }
-
-function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
+var computedWatcherOptions = { lazy: true };
+function initComputed(vm, computed) {
+    // $flow-disable-line
+    var watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+        var userDef = computed[key];
+        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+        if (getter == null) {
+            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else {
+            if (key in vm.$data) {
+                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+            }
+        }
+    }
 }
-
-function initMethods (vm, methods) {
-  var props = vm.$options.props;
-  for (var key in methods) {
-    {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-          "Did you reference the function correctly?",
-          vm
-        );
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a prop."),
-          vm
-        );
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-          "Avoid defining component methods that start with _ or $."
-        );
-      }
+function defineComputed(target, key, userDef) {
+    var shouldCache = !isServerRendering();
+    if (typeof userDef === 'function') {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+        };
     }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-  }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
 }
-
-function initWatch (vm, watch) {
-  for (var key in watch) {
-    var handler = watch[key];
-    if (Array.isArray(handler)) {
-      for (var i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
-      }
-    } else {
-      createWatcher(vm, key, handler);
-    }
-  }
-}
-
-function createWatcher (
-  vm,
-  expOrFn,
-  handler,
-  options
-) {
-  if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler];
-  }
-  return vm.$watch(expOrFn, handler, options)
-}
-
-function stateMixin (Vue) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  var dataDef = {};
-  dataDef.get = function () { return this._data };
-  var propsDef = {};
-  propsDef.get = function () { return this._props };
-  {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      );
+function createComputedGetter(key) {
+    return function computedGetter() {
+        var watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
     };
-    propsDef.set = function () {
-      warn("$props is readonly.", this);
+}
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
     };
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef);
-  Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
-
-  Vue.prototype.$watch = function (
-    expOrFn,
-    cb,
-    options
-  ) {
-    var vm = this;
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
+}
+function initMethods(vm, methods) {
+    var props = vm.$options.props;
+    for (var key in methods) {
+        {
+            if (typeof methods[key] !== 'function') {
+                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                    "Did you reference the function correctly?", vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                    "Avoid defining component methods that start with _ or $.");
+            }
+        }
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+    }
+}
+function initWatch(vm, watch) {
+    for (var key in watch) {
+        var handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (var i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
     }
-    options = options || {};
-    options.user = true;
-    var watcher = new Watcher(vm, expOrFn, cb, options);
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value);
-      } catch (error) {
-        handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-      }
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
     }
-    return function unwatchFn () {
-      watcher.teardown();
+    if (typeof handler === 'string') {
+        handler = vm[handler];
     }
-  };
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    var dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    var propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    {
+        dataDef.set = function () {
+            warn('Avoid replacing instance root $data. ' +
+                'Use nested data properties instead.', this);
+        };
+        propsDef.set = function () {
+            warn("$props is readonly.", this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, '$data', dataDef);
+    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        var vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        var watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            pushTarget();
+            try {
+                cb.call(vm, watcher.value);
+            }
+            catch (error) {
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+            }
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-/*  */
-
+/* @flow */
 var uid$3 = 0;
-
-function initMixin (Vue) {
-  Vue.prototype._init = function (options) {
-    var vm = this;
-    // a uid
-    vm._uid = uid$3++;
-
-    var startTag, endTag;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      startTag = "vue-perf-start:" + (vm._uid);
-      endTag = "vue-perf-end:" + (vm._uid);
-      mark(startTag);
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options);
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      );
+function initMixin(Vue) {
+    Vue.prototype._init = function (options) {
+        var vm = this;
+        // a uid
+        vm._uid = uid$3++;
+        var startTag, endTag;
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        {
+            initProxy(vm);
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook(vm, 'created');
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    // @ts-ignore
+    var opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    var parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    var vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    var options = Ctor.options;
+    if (Ctor.super) {
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            var modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
     }
-    /* istanbul ignore else */
-    {
-      initProxy(vm);
-    }
-    // expose real self
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook(vm, 'created');
-
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      vm._name = formatComponentName(vm, false);
-      mark(endTag);
-      measure(("vue " + (vm._name) + " init"), startTag, endTag);
-    }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el);
-    }
-  };
-}
-
-function initInternalComponent (vm, options) {
-  var opts = vm.$options = Object.create(vm.constructor.options);
-  // doing this because it's faster than dynamic enumeration.
-  var parentVnode = options._parentVnode;
-  opts.parent = options.parent;
-  opts._parentVnode = parentVnode;
-
-  var vnodeComponentOptions = parentVnode.componentOptions;
-  opts.propsData = vnodeComponentOptions.propsData;
-  opts._parentListeners = vnodeComponentOptions.listeners;
-  opts._renderChildren = vnodeComponentOptions.children;
-  opts._componentTag = vnodeComponentOptions.tag;
-
-  if (options.render) {
-    opts.render = options.render;
-    opts.staticRenderFns = options.staticRenderFns;
-  }
-}
-
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
-}
-
-function Vue (options) {
-  if (!(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword');
-  }
-  this._init(options);
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                { modified = {}; }
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
+function Vue(options) {
+    if (!(this instanceof Vue)) {
+        warn('Vue is a constructor and should be called with the `new` keyword');
+    }
+    this._init(options);
+}
+//@ts-ignore
 initMixin(Vue);
+//@ts-ignore
 stateMixin(Vue);
+//@ts-ignore
 eventsMixin(Vue);
+//@ts-ignore
 lifecycleMixin(Vue);
+//@ts-ignore
 renderMixin(Vue);
 
-/*  */
-
-function initUse (Vue) {
-  Vue.use = function (plugin) {
-    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    var args = toArray(arguments, 1);
-    args.unshift(this);
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args);
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args);
-    }
-    installedPlugins.push(plugin);
-    return this
-  };
-}
-
-/*  */
-
-function initMixin$1 (Vue) {
-  Vue.mixin = function (mixin) {
-    this.options = mergeOptions(this.options, mixin);
-    return this
-  };
+/* @flow */
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        var args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-/*  */
-
-function initExtend (Vue) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0;
-  var cid = 1;
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions) {
-    extendOptions = extendOptions || {};
-    var Super = this;
-    var SuperId = Super.cid;
-    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
-    }
-
-    var name = extendOptions.name || Super.options.name;
-    if (name) {
-      validateComponentName(name);
-    }
-
-    var Sub = function VueComponent (options) {
-      this._init(options);
+/* @flow */
+function initMixin$1(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
     };
-    Sub.prototype = Object.create(Super.prototype);
-    Sub.prototype.constructor = Sub;
-    Sub.cid = cid++;
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    );
-    Sub['super'] = Super;
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps$1(Sub);
-    }
-    if (Sub.options.computed) {
-      initComputed$1(Sub);
-    }
-
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend;
-    Sub.mixin = Super.mixin;
-    Sub.use = Super.use;
+}
 
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type];
-    });
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub;
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options;
-    Sub.extendOptions = extendOptions;
-    Sub.sealedOptions = extend({}, Sub.options);
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub;
-    return Sub
-  };
-}
-
-function initProps$1 (Comp) {
-  var props = Comp.options.props;
-  for (var key in props) {
-    proxy(Comp.prototype, "_props", key);
-  }
-}
-
-function initComputed$1 (Comp) {
-  var computed = Comp.options.computed;
-  for (var key in computed) {
-    defineComputed(Comp.prototype, key, computed[key]);
-  }
-}
-
-/*  */
-
-function initAssetRegisters (Vue) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(function (type) {
-    Vue[type] = function (
-      id,
-      definition
-    ) {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
-        /* istanbul ignore if */
-        if (type === 'component') {
-          validateComponentName(id);
+/* @flow */
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    var cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        var Super = this;
+        var SuperId = Super.cid;
+        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
         }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id;
-          definition = this.options._base.extend(definition);
+        var name = extendOptions.name || Super.options.name;
+        if (name) {
+            validateComponentName(name);
         }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition };
+        var Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps$1(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed$1(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
         }
-        this.options[type + 's'][id] = definition;
-        return definition
-      }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
     };
-  });
 }
-
-/*  */
-
-
-
-function getComponentName (opts) {
-  return opts && (opts.Ctor.options.name || opts.tag)
+function initProps$1(Comp) {
+    var props = Comp.options.props;
+    for (var key in props) {
+        proxy(Comp.prototype, "_props", key);
+    }
+}
+function initComputed$1(Comp) {
+    var computed = Comp.options.computed;
+    for (var key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function matches (pattern, name) {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
+/* @flow */
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach(function (type) {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-function pruneCache (keepAliveInstance, filter) {
-  var cache = keepAliveInstance.cache;
-  var keys = keepAliveInstance.keys;
-  var _vnode = keepAliveInstance._vnode;
-  for (var key in cache) {
-    var cachedNode = cache[key];
-    if (cachedNode) {
-      var name = getComponentName(cachedNode.componentOptions);
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
-      }
+// @ts-nocheck
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === 'string') {
+        return pattern.split(',').indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+        var cachedNode = cache[key];
+        if (cachedNode) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
     }
-  }
 }
-
-function pruneCacheEntry (
-  cache,
-  key,
-  keys,
-  current
-) {
-  var cached$$1 = cache[key];
-  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-    cached$$1.componentInstance.$destroy();
-  }
-  cache[key] = null;
-  remove(keys, key);
+function pruneCacheEntry(cache, key, keys, current) {
+    var cached$$1 = cache[key];
+    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+        cached$$1.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove(keys, key);
 }
-
 var patternTypes = [String, RegExp, Array];
-
+// TODO use defineComponent
 var KeepAlive = {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created: function created () {
-    this.cache = Object.create(null);
-    this.keys = [];
-  },
-
-  destroyed: function destroyed () {
-    for (var key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
-    }
-  },
-
-  mounted: function mounted () {
-    var this$1 = this;
-
-    this.$watch('include', function (val) {
-      pruneCache(this$1, function (name) { return matches(val, name); });
-    });
-    this.$watch('exclude', function (val) {
-      pruneCache(this$1, function (name) { return !matches(val, name); });
-    });
-  },
-
-  render: function render () {
-    var slot = this.$slots.default;
-    var vnode = getFirstComponentChild(slot);
-    var componentOptions = vnode && vnode.componentOptions;
-    if (componentOptions) {
-      // check pattern
-      var name = getComponentName(componentOptions);
-      var ref = this;
-      var include = ref.include;
-      var exclude = ref.exclude;
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      var ref$1 = this;
-      var cache = ref$1.cache;
-      var keys = ref$1.keys;
-      var key = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-        : vnode.key;
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
-        // make current key freshest
-        remove(keys, key);
-        keys.push(key);
-      } else {
-        cache[key] = vnode;
-        keys.push(key);
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+    name: 'keep-alive',
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    created: function created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed: function destroyed() {
+        for (var key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
         }
-      }
+    },
+    mounted: function mounted() {
+        var this$1 = this;
 
-      vnode.data.keepAlive = true;
-    }
-    return vnode || (slot && slot[0])
-  }
+        this.$watch('include', function (val) {
+            pruneCache(this$1, function (name) { return matches(val, name); });
+        });
+        this.$watch('exclude', function (val) {
+            pruneCache(this$1, function (name) { return !matches(val, name); });
+        });
+    },
+    render: function render() {
+        var slot = this.$slots.default;
+        var vnode = getFirstComponentChild(slot);
+        var componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
+            var key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove(keys, key);
+                keys.push(key);
+            }
+            else {
+                cache[key] = vnode;
+                keys.push(key);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+            }
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
 var builtInComponents = {
-  KeepAlive: KeepAlive
+    KeepAlive: KeepAlive,
 };
 
-/*  */
-
-function initGlobalAPI (Vue) {
-  // config
-  var configDef = {};
-  configDef.get = function () { return config; };
-  {
-    configDef.set = function () {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      );
+/* @flow */
+function initGlobalAPI(Vue) {
+    // config
+    var configDef = {};
+    configDef.get = function () { return config; };
+    {
+        configDef.set = function () {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn,
+        extend: extend,
+        mergeOptions: mergeOptions,
+        defineReactive: defineReactive$$1,
     };
-  }
-  Object.defineProperty(Vue, 'config', configDef);
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn: warn,
-    extend: extend,
-    mergeOptions: mergeOptions,
-    defineReactive: defineReactive$$1
-  };
-
-  Vue.set = set;
-  Vue.delete = del;
-  Vue.nextTick = nextTick;
-
-  // 2.6 explicit observable API
-  Vue.observable = function (obj) {
-    observe(obj);
-    return obj
-  };
-
-  Vue.options = Object.create(null);
-  ASSET_TYPES.forEach(function (type) {
-    Vue.options[type + 's'] = Object.create(null);
-  });
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue;
-
-  extend(Vue.options.components, builtInComponents);
-
-  initUse(Vue);
-  initMixin$1(Vue);
-  initExtend(Vue);
-  initAssetRegisters(Vue);
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = function (obj) {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach(function (type) {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin$1(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
 initGlobalAPI(Vue);
-
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+    get: isServerRendering,
 });
-
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get: function get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
+    get: function get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
 });
-
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+    value: FunctionalRenderContext,
 });
-
 Vue.version = '2.6.12';
 
-/*  */
-
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
 var convertEnumeratedValue = function (key, value) {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
 var xlinkNS = 'http://www.w3.org/1999/xlink';
-
 var isXlink = function (name) {
-  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-
 var getXlinkProp = function (name) {
-  return isXlink(name) ? name.slice(6, name.length) : ''
+    return isXlink(name) ? name.slice(6, name.length) : '';
 };
-
 var isFalsyAttrValue = function (val) {
-  return val == null || val === false
+    return val == null || val === false;
 };
 
-/*  */
-
-function genClassForVnode (vnode) {
-  var data = vnode.data;
-  var parentNode = vnode;
-  var childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
+/* @flow */
+function genClassForVnode(vnode) {
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
     }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
     }
-  }
-  return renderClass(data.staticClass, data.class)
+    return renderClass(data.staticClass, data.class);
 }
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
 }
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
 }
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyArray (value) {
-  var res = '';
-  var stringified;
-  for (var i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) { res += ' '; }
-      res += stringified;
+function stringifyArray(value) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                { res += ' '; }
+            res += stringified;
+        }
     }
-  }
-  return res
+    return res;
 }
-
-function stringifyObject (value) {
-  var res = '';
-  for (var key in value) {
-    if (value[key]) {
-      if (res) { res += ' '; }
-      res += key;
+function stringifyObject(value) {
+    var res = '';
+    for (var key in value) {
+        if (value[key]) {
+            if (res)
+                { res += ' '; }
+            res += key;
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
 };
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isPreTag = function (tag) { return tag === 'pre'; };
-
 var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 var unknownElementCache = Object.create(null);
-function isUnknownElement (tag) {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase();
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  var el = document.createElement(tag);
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    var el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
 }
-
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
-
+/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
-function query (el) {
-  if (typeof el === 'string') {
-    var selected = document.querySelector(el);
-    if (!selected) {
-      warn(
-        'Cannot find element: ' + el
-      );
-      return document.createElement('div')
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
     }
-    return selected
-  } else {
-    return el
-  }
 }
 
-/*  */
-
-function createElement$1 (tagName, vnode) {
-  var elm = document.createElement(tagName);
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple');
-  }
-  return elm
+/* @flow */
+function createElement$1(tagName, vnode) {
+    var elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
 }
-
-function createElementNS (namespace, tagName) {
-  return document.createElementNS(namespaceMap[namespace], tagName)
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
 }
-
-function createTextNode (text) {
-  return document.createTextNode(text)
+function createTextNode(text) {
+    return document.createTextNode(text);
 }
-
-function createComment (text) {
-  return document.createComment(text)
+function createComment(text) {
+    return document.createComment(text);
 }
-
-function insertBefore (parentNode, newNode, referenceNode) {
-  parentNode.insertBefore(newNode, referenceNode);
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
 }
-
-function removeChild (node, child) {
-  node.removeChild(child);
+function removeChild(node, child) {
+    node.removeChild(child);
 }
-
-function appendChild (node, child) {
-  node.appendChild(child);
+function appendChild(node, child) {
+    node.appendChild(child);
 }
-
-function parentNode (node) {
-  return node.parentNode
+function parentNode(node) {
+    return node.parentNode;
 }
-
-function nextSibling (node) {
-  return node.nextSibling
+function nextSibling(node) {
+    return node.nextSibling;
 }
-
-function tagName (node) {
-  return node.tagName
+function tagName(node) {
+    return node.tagName;
 }
-
-function setTextContent (node, text) {
-  node.textContent = text;
+function setTextContent(node, text) {
+    node.textContent = text;
 }
-
-function setStyleScope (node, scopeId) {
-  node.setAttribute(scopeId, '');
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5743,48 +5029,53 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/*  */
-
+/* @flow */
 var ref = {
-  create: function create (_, vnode) {
-    registerRef(vnode);
-  },
-  update: function update (oldVnode, vnode) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
-    }
-  },
-  destroy: function destroy (vnode) {
-    registerRef(vnode, true);
-  }
+    create: function create(_, vnode) {
+        registerRef(vnode);
+    },
+    update: function update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy: function destroy(vnode) {
+        registerRef(vnode, true);
+    },
 };
-
-function registerRef (vnode, isRemoval) {
-  var key = vnode.data.ref;
-  if (!isDef(key)) { return }
-
-  var vm = vnode.context;
-  var ref = vnode.componentInstance || vnode.elm;
-  var refs = vm.$refs;
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref);
-    } else if (refs[key] === ref) {
-      refs[key] = undefined;
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref];
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref);
-      }
-    } else {
-      refs[key] = ref;
+function registerRef(vnode, isRemoval) {
+    var key = vnode.data.ref;
+    if (!isDef(key))
+        { return; }
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
+    if (isRemoval) {
+        if (Array.isArray(refs[key])) {
+            // @ts-expect-error invalid typings
+            remove(refs[key], ref);
+        }
+        else if (refs[key] === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error invalid typings
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(refs[key])) {
+                refs[key] = [ref];
+                // @ts-expect-error invalid typings
+            }
+            else if (refs[key].indexOf(ref) < 0) {
+                // @ts-expect-error invalid typings
+                refs[key].push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
     }
-  }
 }
 
 /**
@@ -5798,1402 +5089,1297 @@ function registerRef (vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-
 var emptyNode = new VNode('', {}, []);
-
 var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') { return true }
-  var i;
-  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
-}
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  var i, key;
-  var map = {};
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key;
-    if (isDef(key)) { map[key] = i; }
-  }
-  return map
-}
-
-function createPatchFunction (backend) {
-  var i, j;
-  var cbs = {};
-
-  var modules = backend.modules;
-  var nodeOps = backend.nodeOps;
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = [];
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]]);
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove$$1 () {
-      if (--remove$$1.listeners === 0) {
-        removeNode(childElm);
-      }
-    }
-    remove$$1.listeners = listeners;
-    return remove$$1
-  }
-
-  function removeNode (el) {
-    var parent = nodeOps.parentNode(el);
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el);
-    }
-  }
-
-  function isUnknownElement$$1 (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(function (ignore) {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  var creatingElmInVPre = 0;
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode);
-    }
-
-    vnode.isRootInsert = !nested; // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        ((a.tag === b.tag &&
+            a.isComment === b.isComment &&
+            isDef(a.data) === isDef(b.data) &&
+            sameInputType(a, b)) ||
+            (isTrue(a.isAsyncPlaceholder) &&
+                a.asyncFactory === b.asyncFactory &&
+                isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        { return true; }
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    var i, key;
+    var map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            { map[key] = i; }
     }
-
-    var data = vnode.data;
-    var children = vnode.children;
-    var tag = vnode.tag;
-    if (isDef(tag)) {
-      {
-        if (data && data.pre) {
-          creatingElmInVPre++;
-        }
-        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          );
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode);
-      setScope(vnode);
-
-      /* istanbul ignore if */
-      {
-        createChildren(vnode, children, insertedVnodeQueue);
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue);
-        }
-        insert(parentElm, vnode.elm, refElm);
-      }
-
-      if (data && data.pre) {
-        creatingElmInVPre--;
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i = vnode.data;
-    if (isDef(i)) {
-      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */);
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue);
-        insert(parentElm, vnode.elm, refElm);
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+    return map;
+}
+function createPatchFunction(backend) {
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
         }
-        return true
-      }
     }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-      vnode.data.pendingInsert = null;
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
-    vnode.elm = vnode.componentInstance.$el;
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue);
-      setScope(vnode);
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode);
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode);
+    function createRmCb(childElm, listeners) {
+        function remove$$1() {
+            if (--remove$$1.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove$$1.listeners = listeners;
+        return remove$$1;
+    }
+    function removeNode(el) {
+        var parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
     }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i;
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    var innerNode = vnode;
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode;
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode);
-        }
-        insertedVnodeQueue.push(innerNode);
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm);
-  }
-
-  function insert (parent, elm, ref$$1) {
-    if (isDef(parent)) {
-      if (isDef(ref$$1)) {
-        if (nodeOps.parentNode(ref$$1) === parent) {
-          nodeOps.insertBefore(parent, elm, ref$$1);
-        }
-      } else {
-        nodeOps.appendChild(parent, elm);
-      }
-    }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      {
-        checkDuplicateKeys(children);
-      }
-      for (var i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode;
-    }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-      cbs.create[i$1](emptyNode, vnode);
-    }
-    i = vnode.data.hook; // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) { i.create(emptyNode, vnode); }
-      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
-    }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    var i;
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    } else {
-      var ancestor = vnode;
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i);
-        }
-        ancestor = ancestor.parent;
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-    }
-  }
-
-  function invokeDestroyHook (vnode) {
-    var i, j;
-    var data = vnode.data;
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
-    }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j]);
-      }
-    }
-  }
-
-  function removeVnodes (vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      var ch = vnodes[startIdx];
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch);
-          invokeDestroyHook(ch);
-        } else { // Text node
-          removeNode(ch.elm);
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      var i;
-      var listeners = cbs.remove.length + 1;
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners;
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners);
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm);
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm);
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm);
-      } else {
-        rm();
-      }
-    } else {
-      removeNode(vnode.elm);
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    var oldStartIdx = 0;
-    var newStartIdx = 0;
-    var oldEndIdx = oldCh.length - 1;
-    var oldStartVnode = oldCh[0];
-    var oldEndVnode = oldCh[oldEndIdx];
-    var newEndIdx = newCh.length - 1;
-    var newStartVnode = newCh[0];
-    var newEndVnode = newCh[newEndIdx];
-    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    var canMove = !removeOnly;
-
-    {
-      checkDuplicateKeys(newCh);
-    }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx];
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        oldStartVnode = oldCh[++oldStartIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-        oldStartVnode = oldCh[++oldStartIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-        } else {
-          vnodeToMove = oldCh[idxInOld];
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-            oldCh[idxInOld] = undefined;
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          }
-        }
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    var seenKeys = {};
-    for (var i = 0; i < children.length; i++) {
-      var vnode = children[i];
-      var key = vnode.key;
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-            vnode.context
-          );
-        } else {
-          seenKeys[key] = true;
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (var i = start; i < end; i++) {
-      var c = oldCh[i];
-      if (isDef(c) && sameVnode(node, c)) { return i }
-    }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
-    }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode);
-    }
-
-    var elm = vnode.elm = oldVnode.elm;
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-      } else {
-        vnode.isAsyncPlaceholder = true;
-      }
-      return
-    }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance;
-      return
+    function isUnknownElement$$1(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some(function (ignore) {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    var creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        var data = vnode.data;
+        var children = vnode.children;
+        var tag = vnode.tag;
+        if (isDef(tag)) {
+            {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
     }
-
-    var i;
-    var data = vnode.data;
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode);
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i = vnode.data;
+        if (isDef(i)) {
+            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
     }
-
-    var oldCh = oldVnode.children;
-    var ch = vnode.children;
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        var innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref$$1) {
+        if (isDef(parent)) {
+            if (isDef(ref$$1)) {
+                if (nodeOps.parentNode(ref$$1) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref$$1);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            {
+                checkDuplicateKeys(children);
+            }
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                { i.create(emptyNode, vnode); }
+            if (isDef(i.insert))
+                { insertedVnodeQueue.push(vnode); }
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        var i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            var ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        var i, j;
+        var data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                { i(vnode); }
+            for (i = 0; i < cbs.destroy.length; ++i)
+                { cbs.destroy[i](vnode); }
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
     }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-      } else if (isDef(ch)) {
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            var ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            var i;
+            var listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        var oldStartIdx = 0;
+        var newStartIdx = 0;
+        var oldEndIdx = oldCh.length - 1;
+        var oldStartVnode = oldCh[0];
+        var oldEndVnode = oldCh[oldEndIdx];
+        var newEndIdx = newCh.length - 1;
+        var newStartVnode = newCh[0];
+        var newEndVnode = newCh[newEndIdx];
+        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        var canMove = !removeOnly;
         {
-          checkDuplicateKeys(ch);
-        }
-        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-      } else if (isDef(oldCh)) {
-        removeVnodes(oldCh, 0, oldCh.length - 1);
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '');
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text);
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue;
-    } else {
-      for (var i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i]);
-      }
-    }
-  }
-
-  var hydrationBailed = false;
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    var i;
-    var tag = vnode.tag;
-    var data = vnode.data;
-    var children = vnode.children;
-    inVPre = inVPre || (data && data.pre);
-    vnode.elm = elm;
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true;
-      return true
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
     }
-    // assert node match
-    {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue);
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue);
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('server innerHTML: ', i);
-                console.warn('client innerHTML: ', elm.innerHTML);
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            var childrenMatch = true;
-            var childNode = elm.firstChild;
-            for (var i$1 = 0; i$1 < children.length; i$1++) {
-              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false;
-                break
-              }
-              childNode = childNode.nextSibling;
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        var fullInvoke = false;
-        for (var key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true;
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            break
-          }
-        }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class']);
-        }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text;
-    }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement$$1(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-      return
-    }
-
-    var isInitialPatch = false;
-    var insertedVnodeQueue = [];
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true;
-      createElm(vnode, insertedVnodeQueue);
-    } else {
-      var isRealElement = isDef(oldVnode.nodeType);
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR);
-            hydrating = true;
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true);
-              return oldVnode
-            } else {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
-              );
-            }
-          }
-          // either not server-rendered, or hydration failed.
-          // create an empty node and replace it
-          oldVnode = emptyNodeAt(oldVnode);
-        }
-
-        // replacing existing element
-        var oldElm = oldVnode.elm;
-        var parentElm = nodeOps.parentNode(oldElm);
-
-        // create new node
-        createElm(
-          vnode,
-          insertedVnodeQueue,
-          // extremely rare edge case: do not insert if old element is in a
-          // leaving transition. Only happens when combining transition +
-          // keep-alive + HOCs. (#4590)
-          oldElm._leaveCb ? null : parentElm,
-          nodeOps.nextSibling(oldElm)
-        );
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          var ancestor = vnode.parent;
-          var patchable = isPatchable(vnode);
-          while (ancestor) {
-            for (var i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor);
-            }
-            ancestor.elm = vnode.elm;
-            if (patchable) {
-              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                cbs.create[i$1](emptyNode, ancestor);
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              var insert = ancestor.data.hook.insert;
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                  insert.fns[i$2]();
+    function checkDuplicateKeys(children) {
+        var seenKeys = {};
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
+            var key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
                 }
-              }
-            } else {
-              registerRef(ancestor);
             }
-            ancestor = ancestor.parent;
-          }
         }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes([oldVnode], 0, 0);
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode);
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                { return i; }
         }
-      }
     }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-    return vnode.elm
-  }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        var elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        var i;
+        var data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        var oldCh = oldVnode.children;
+        var ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                { cbs.update[i](oldVnode, vnode); }
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                { i(oldVnode, vnode); }
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+            }
+            else if (isDef(ch)) {
+                {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    { nodeOps.setTextContent(elm, ''); }
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                { i(oldVnode, vnode); }
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    var hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        var i;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                { i(vnode, true /* hydrating */); }
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        var childrenMatch = true;
+                        var childNode = elm.firstChild;
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                var fullInvoke = false;
+                for (var key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement$$1(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                { invokeDestroyHook(oldVnode); }
+            return;
+        }
+        var isInitialPatch = false;
+        var insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            var isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                var oldElm = oldVnode.elm;
+                var parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    var ancestor = vnode.parent;
+                    var patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-/*  */
-
+/* @flow */
 var directives = {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode) {
-    updateDirectives(vnode, emptyNode);
-  }
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
 };
-
-function updateDirectives (oldVnode, vnode) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode);
-  }
-}
-
-function _update (oldVnode, vnode) {
-  var isCreate = oldVnode === emptyNode;
-  var isDestroy = vnode === emptyNode;
-  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-  var dirsWithInsert = [];
-  var dirsWithPostpatch = [];
-
-  var key, oldDir, dir;
-  for (key in newDirs) {
-    oldDir = oldDirs[key];
-    dir = newDirs[key];
-    if (!oldDir) {
-      // new directive, bind
-      callHook$1(dir, 'bind', vnode, oldVnode);
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir);
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value;
-      dir.oldArg = oldDir.arg;
-      callHook$1(dir, 'update', vnode, oldVnode);
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir);
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    var callInsert = function () {
-      for (var i = 0; i < dirsWithInsert.length; i++) {
-        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-      }
-    };
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert);
-    } else {
-      callInsert();
-    }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', function () {
-      for (var i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-      }
-    });
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-      }
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook$1(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook$1(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        var callInsert = function () {
+            for (var i = 0; i < dirsWithInsert.length; i++) {
+                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', function () {
+            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
     }
-  }
 }
-
 var emptyModifiers = Object.create(null);
-
-function normalizeDirectives$1 (
-  dirs,
-  vm
-) {
-  var res = Object.create(null);
-  if (!dirs) {
+function normalizeDirectives$1(dirs, vm) {
+    var res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    var i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
     // $flow-disable-line
-    return res
-  }
-  var i, dir;
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i];
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers;
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+}
+function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+    var fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+        }
     }
-    res[getRawDirName(dir)] = dir;
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-  }
-  // $flow-disable-line
-  return res
 }
 
-function getRawDirName (dir) {
-  return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
-}
+var baseModules = [ref, directives];
 
-function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-  var fn = dir.def && dir.def[hook];
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-    } catch (e) {
-      handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
-    }
-  }
-}
-
-var baseModules = [
-  ref,
-  directives
-];
-
-/*  */
-
-function updateAttrs (oldVnode, vnode) {
-  var opts = vnode.componentOptions;
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  var key, cur, old;
-  var elm = vnode.elm;
-  var oldAttrs = oldVnode.data.attrs || {};
-  var attrs = vnode.data.attrs || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__)) {
-    attrs = vnode.data.attrs = extend({}, attrs);
-  }
-
-  for (key in attrs) {
-    cur = attrs[key];
-    old = oldAttrs[key];
-    if (old !== cur) {
-      setAttr(elm, key, cur);
-    }
-  }
-  // #4391: in IE9, setting type can reset value for input[type=radio]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value);
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key);
-      }
-    }
-  }
-}
-
-function setAttr (el, key, value) {
-  if (el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value);
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key;
-      el.setAttribute(key, value);
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value));
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-    } else {
-      el.setAttributeNS(xlinkNS, key, value);
-    }
-  } else {
-    baseSetAttr(el, key, value);
-  }
-}
-
-function baseSetAttr (el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key);
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
+/* @flow */
+function updateAttrs(oldVnode, vnode) {
+    var opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
     /* istanbul ignore if */
-    if (
-      isIE && !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
-    ) {
-      var blocker = function (e) {
-        e.stopImmediatePropagation();
-        el.removeEventListener('input', blocker);
-      };
-      el.addEventListener('input', blocker);
-      // $flow-disable-line
-      el.__ieph = true; /* IE placeholder patched */
-    }
-    el.setAttribute(key, value);
-  }
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            var blocker = function (e) {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
 }
-
 var attrs = {
-  create: updateAttrs,
-  update: updateAttrs
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-/*  */
-
-function updateClass (oldVnode, vnode) {
-  var el = vnode.elm;
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
-  ) {
-    return
-  }
-
-  var cls = genClassForVnode(vnode);
-
-  // handle transition classes
-  var transitionClass = el._transitionClasses;
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass));
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls);
-    el._prevClass = cls;
-  }
+/* @flow */
+function updateClass(oldVnode, vnode) {
+    var el = vnode.elm;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    var cls = genClassForVnode(vnode);
+    // handle transition classes
+    var transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
 }
-
 var klass = {
-  create: updateClass,
-  update: updateClass
+    create: updateClass,
+    update: updateClass,
 };
 
-/*  */
-
+/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function parseFilters(exp) {
+    var inSingle = false;
+    var inDouble = false;
+    var inTemplateString = false;
+    var inRegex = false;
+    var curly = 0;
+    var square = 0;
+    var paren = 0;
+    var lastFilterIndex = 0;
+    var c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                { inSingle = false; }
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                { inDouble = false; }
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                { inTemplateString = false; }
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                { inRegex = false; }
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                var j = i - 1;
+                var p = (void 0);
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        { break; }
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
-    }
-  }
-
-  return expression
-}
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
-}
-
-/*  */
-
-
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    var i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return ("_f(\"" + filter + "\")(" + exp + ")");
+    }
+    else {
+        var name = filter.slice(0, i);
+        var args = filter.slice(i + 1);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+    }
+}
 
+/* @flow */
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    var attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
-}
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-}
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    var events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    var handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        var staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
+function getAndRemoveAttr(el, name, removeFromMap) {
+    var val;
+    if ((val = el.attrsMap[name]) != null) {
+        var list = el.attrsList;
+        for (var i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
     }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
+    if (removeFromMap) {
+        delete el.attrsMap[name];
     }
-  }
+    return val;
 }
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
+function getAndRemoveAttrByRegex(el, name) {
+    var list = el.attrsList;
+    for (var i = 0, l = list.length; i < l; i++) {
+        var attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-    if (range.end != null) {
-      item.end = range.end;
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
     }
-  }
-  return item
+    return item;
 }
 
-/*  */
-
+/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
+    var baseValueExpression = '$$v';
+    var valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            "(typeof " + baseValueExpression + " === 'string'" +
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: ("(" + value + ")"),
+        expression: JSON.stringify(value),
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    var res = parseModel(value);
+    if (res.key === null) {
+        return (value + "=" + assignment);
+    }
+    else {
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -7208,2042 +6394,2134 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
 var len, str, chr, index$1, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index$1 = val.lastIndexOf('.');
-    if (index$1 > -1) {
-      return {
-        exp: val.slice(0, index$1),
-        key: '"' + val.slice(index$1 + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index$1 = val.lastIndexOf('.');
+        if (index$1 > -1) {
+            return {
+                exp: val.slice(0, index$1),
+                key: '"' + val.slice(index$1 + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  str = val;
-  index$1 = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+    str = val;
+    index$1 = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index$1)
+function next() {
+    return str.charCodeAt(++index$1);
 }
-
-function eof () {
-  return index$1 >= len
+function eof() {
+    return index$1 >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index$1;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index$1;
-      break
+function parseBracket(chr) {
+    var inBracket = 1;
+    expressionPos = index$1;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            { inBracket++; }
+        if (chr === 0x5d)
+            { inBracket--; }
+        if (inBracket === 0) {
+            expressionEndPos = index$1;
+            break;
+        }
     }
-  }
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    var stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 var warn$1;
-
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-
-function model (
-  el,
-  dir,
-  _warn
-) {
-  warn$1 = _warn;
-  var value = dir.value;
-  var modifiers = dir.modifiers;
-  var tag = el.tag;
-  var type = el.attrsMap.type;
-
-  {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-        "File inputs are read only. Use a v-on:change listener instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else if (!config.isReservedTag(tag)) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else {
-    warn$1(
-      "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-      "v-model is not supported on this element type. " +
-      'If you are working with contenteditable, it\'s recommended to ' +
-      'wrap a library dedicated for that purpose inside a custom component.',
-      el.rawAttrsMap['v-model']
-    );
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    "Array.isArray(" + value + ")" +
-    "?_i(" + value + "," + valueBinding + ")>-1" + (
-      trueValueBinding === 'true'
-        ? (":(" + value + ")")
-        : (":_q(" + value + "," + trueValueBinding + ")")
-    )
-  );
-  addHandler(el, 'change',
-    "var $$a=" + value + "," +
+function model(el, dir, _warn) {
+    warn$1 = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
+        (trueValueBinding === 'true'
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
+    addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
         "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-    'if(Array.isArray($$a)){' +
-      "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-      "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-      "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-    "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-  addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var selectedVal = "Array.prototype.filter" +
-    ".call($event.target.options,function(o){return o.selected})" +
-    ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-    "return " + (number ? '_n(val)' : 'val') + "})";
-
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  var code = "var $$selectedVal = " + selectedVal + ";";
-  code = code + " " + (genAssignmentCode(value, assignment));
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  {
-    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value$1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$1(
-        binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var number = ref.number;
-  var trim = ref.trim;
-  var needCompositionGuard = !lazy && type !== 'range';
-  var event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  var valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = "$event.target.value.trim()";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = "if($event.target.composing)return;" + code;
-  }
-
-  addProp(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
-}
-
-/*  */
+        'if(Array.isArray($$a)){' +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        '$$i=_i($$a,$$v);' +
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        "return " + (number ? '_n(val)' : 'val') + "})";
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + (genAssignmentCode(value, assignment));
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value$1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', ("(" + value + ")"));
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
+/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
 // user-attached handlers.
-function normalizeEvents (on) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    var event = isIE ? 'change' : 'input';
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-    delete on[RANGE_TOKEN];
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-    delete on[CHECKBOX_RADIO_TOKEN];
-  }
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
 }
-
 var target$1;
-
-function createOnceHandler$1 (event, handler, capture) {
-  var _target = target$1; // save current target element in closure
-  return function onceHandler () {
-    var res = handler.apply(null, arguments);
-    if (res !== null) {
-      remove$2(event, onceHandler, capture, _target);
-    }
-  }
+function createOnceHandler$1(event, handler, capture) {
+    var _target = target$1; // save current target element in closure
+    return function onceHandler() {
+        var res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove$2(event, onceHandler, capture, _target);
+        }
+    };
 }
-
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-function add$1 (
-  name,
-  handler,
-  capture,
-  passive
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    var attachedTimestamp = currentFlushTimestamp;
-    var original = handler;
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    };
-  }
-  target$1.addEventListener(
-    name,
-    handler,
-    supportsPassive
-      ? { capture: capture, passive: passive }
-      : capture
-  );
-}
-
-function remove$2 (
-  name,
-  handler,
-  capture,
-  _target
-) {
-  (_target || target$1).removeEventListener(
-    name,
-    handler._wrapper || handler,
-    capture
-  );
-}
-
-function updateDOMListeners (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  var on = vnode.data.on || {};
-  var oldOn = oldVnode.data.on || {};
-  target$1 = vnode.elm;
-  normalizeEvents(on);
-  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-  target$1 = undefined;
+function add$1(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
+        //@ts-expect-error
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+}
+function remove$2(name, handler, capture, _target) {
+    (_target || target$1).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target$1 = vnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+    target$1 = undefined;
 }
-
 var events = {
-  create: updateDOMListeners,
-  update: updateDOMListeners
+    create: updateDOMListeners,
+    update: updateDOMListeners,
 };
 
-/*  */
-
+/* @flow */
 var svgContainer;
-
-function updateDOMProps (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  var key, cur;
-  var elm = vnode.elm;
-  var oldProps = oldVnode.data.domProps || {};
-  var props = vnode.data.domProps || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
-    props = vnode.data.domProps = extend({}, props);
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      elm[key] = '';
-    }
-  }
-
-  for (key in props) {
-    cur = props[key];
-    // ignore children if the node has textContent or innerHTML,
-    // as these will throw away existing DOM nodes and cause removal errors
-    // on subsequent patches (#3360)
-    if (key === 'textContent' || key === 'innerHTML') {
-      if (vnode.children) { vnode.children.length = 0; }
-      if (cur === oldProps[key]) { continue }
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0]);
-      }
-    }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // store value as _value as well since
-      // non-string values will be stringified
-      elm._value = cur;
-      // avoid resetting cursor position when value is the same
-      var strCur = isUndef(cur) ? '' : String(cur);
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur;
-      }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div');
-      svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-      var svg = svgContainer.firstChild;
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild);
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild);
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecessary `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur;
-      } catch (e) {}
-    }
-  }
-}
-
-// check platforms/web/util/attrs.js acceptValue
-
-
-function shouldUpdateValue (elm, checkVal) {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
-}
-
-function isNotInFocusAndDirty (elm, checkVal) {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  var notInFocus = true;
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm; } catch (e) {}
-  return notInFocus && elm.value !== checkVal
-}
-
-function isDirtyWithModifiers (elm, newVal) {
-  var value = elm.value;
-  var modifiers = elm._vModifiers; // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
-    }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
-    }
-  }
-  return value !== newVal
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    var key, cur;
+    var elm = vnode.elm;
+    var oldProps = oldVnode.data.domProps || {};
+    var props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                { vnode.children.length = 0; }
+            if (cur === oldProps[key])
+                { continue; }
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            var strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+            var svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    var notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    var value = elm.value;
+    var modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
 }
-
 var domProps = {
-  create: updateDOMProps,
-  update: updateDOMProps
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-/*  */
-
+/* @flow */
 var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  var style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    var style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  var res = {};
-  var styleData;
-
-  if (checkChild) {
-    var childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    var res = {};
+    var styleData;
+    if (checkChild) {
+        var childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  var parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    var parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val);
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-  } else {
-    var normalizedName = normalize(name);
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (var i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i];
-      }
-    } else {
-      el.style[normalizedName] = val;
-    }
-  }
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        var normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (var i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
 };
-
 var vendorNames = ['Webkit', 'Moz', 'ms'];
-
 var emptyStyle;
 var normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style;
-  prop = camelize(prop);
-  if (prop !== 'filter' && (prop in emptyStyle)) {
-    return prop
-  }
-  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-  for (var i = 0; i < vendorNames.length; i++) {
-    var name = vendorNames[i] + capName;
-    if (name in emptyStyle) {
-      return name
-    }
-  }
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (var i = 0; i < vendorNames.length; i++) {
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
 });
-
-function updateStyle (oldVnode, vnode) {
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  var cur, name;
-  var el = vnode.elm;
-  var oldStaticStyle = oldData.staticStyle;
-  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  var oldStyle = oldStaticStyle || oldStyleBinding;
-
-  var style = normalizeStyleBinding(vnode.data.style) || {};
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style;
-
-  var newStyle = getStyle(vnode, true);
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      setProp(el, name, '');
+function updateStyle(oldVnode, vnode) {
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    var cur, name;
+    var el = vnode.elm;
+    var oldStaticStyle = oldData.staticStyle;
+    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    var oldStyle = oldStaticStyle || oldStyleBinding;
+    var style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    var newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
     }
-  }
-  for (name in newStyle) {
-    cur = newStyle[name];
-    if (cur !== oldStyle[name]) {
-      // ie9 setting to null has no effect, must use empty string
-      setProp(el, name, cur == null ? '' : cur);
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
     }
-  }
 }
-
 var style = {
-  create: updateStyle,
-  update: updateStyle
+    create: updateStyle,
+    update: updateStyle,
 };
 
-/*  */
-
+/* @flow */
 var whitespaceRE = /\s+/;
-
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-    } else {
-      el.classList.add(cls);
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
     }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    if (cur.indexOf(' ' + cls + ' ') < 0) {
-      el.setAttribute('class', (cur + cls).trim());
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
     }
-  }
 }
-
 /**
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-    } else {
-      el.classList.remove(cls);
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class');
-    }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    var tar = ' ' + cls + ' ';
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ');
-    }
-    cur = cur.trim();
-    if (cur) {
-      el.setAttribute('class', cur);
-    } else {
-      el.removeAttribute('class');
-    }
-  }
-}
-
-/*  */
-
-function resolveTransition (def$$1) {
-  if (!def$$1) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def$$1 === 'object') {
-    var res = {};
-    if (def$$1.css !== false) {
-      extend(res, autoCssTransition(def$$1.name || 'v'));
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
     }
-    extend(res, def$$1);
-    return res
-  } else if (typeof def$$1 === 'string') {
-    return autoCssTransition(def$$1)
-  }
 }
 
+function resolveTransition(def$$1) {
+    if (!def$$1) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def$$1 === 'object') {
+        var res = {};
+        if (def$$1.css !== false) {
+            extend(res, autoCssTransition(def$$1.name || 'v'));
+        }
+        extend(res, def$$1);
+        return res;
+    }
+    else if (typeof def$$1 === 'string') {
+        return autoCssTransition(def$$1);
+    }
+}
 var autoCssTransition = cached(function (name) {
-  return {
-    enterClass: (name + "-enter"),
-    enterToClass: (name + "-enter-to"),
-    enterActiveClass: (name + "-enter-active"),
-    leaveClass: (name + "-leave"),
-    leaveToClass: (name + "-leave-to"),
-    leaveActiveClass: (name + "-leave-active")
-  }
+    return {
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
+    };
 });
-
 var hasTransition = inBrowser && !isIE9;
 var TRANSITION = 'transition';
 var ANIMATION = 'animation';
-
 // Transition property/event sniffing
 var transitionProp = 'transition';
 var transitionEndEvent = 'transitionend';
 var animationProp = 'animation';
 var animationEndEvent = 'animationend';
 if (hasTransition) {
-  /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    transitionProp = 'WebkitTransition';
-    transitionEndEvent = 'webkitTransitionEnd';
-  }
-  if (window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    animationProp = 'WebkitAnimation';
-    animationEndEvent = 'webkitAnimationEnd';
-  }
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
 }
-
 // binding to window is necessary to make hot reload work in IE in strict mode
 var raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ function (fn) { return fn(); };
-
-function nextFrame (fn) {
-  raf(function () {
-    raf(fn);
-  });
-}
-
-function addTransitionClass (el, cls) {
-  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls);
-    addClass(el, cls);
-  }
-}
-
-function removeTransitionClass (el, cls) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls);
-  }
-  removeClass(el, cls);
-}
-
-function whenTransitionEnds (
-  el,
-  expectedType,
-  cb
-) {
-  var ref = getTransitionInfo(el, expectedType);
-  var type = ref.type;
-  var timeout = ref.timeout;
-  var propCount = ref.propCount;
-  if (!type) { return cb() }
-  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-  var ended = 0;
-  var end = function () {
-    el.removeEventListener(event, onEnd);
-    cb();
-  };
-  var onEnd = function (e) {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end();
-      }
-    }
-  };
-  setTimeout(function () {
-    if (ended < propCount) {
-      end();
-    }
-  }, timeout + 1);
-  el.addEventListener(event, onEnd);
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
 }
-
 var transformRE = /\b(transform|all)(,|$)/;
-
-function getTransitionInfo (el, expectedType) {
-  var styles = window.getComputedStyle(el);
-  // JSDOM may return undefined for transition properties
-  var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-  var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-  var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-  var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-  var animationTimeout = getTimeout(animationDelays, animationDurations);
-
-  var type;
-  var timeout = 0;
-  var propCount = 0;
-  /* istanbul ignore if */
-  if (expectedType === TRANSITION) {
-    if (transitionTimeout > 0) {
-      type = TRANSITION;
-      timeout = transitionTimeout;
-      propCount = transitionDurations.length;
-    }
-  } else if (expectedType === ANIMATION) {
-    if (animationTimeout > 0) {
-      type = ANIMATION;
-      timeout = animationTimeout;
-      propCount = animationDurations.length;
-    }
-  } else {
-    timeout = Math.max(transitionTimeout, animationTimeout);
-    type = timeout > 0
-      ? transitionTimeout > animationTimeout
-        ? TRANSITION
-        : ANIMATION
-      : null;
-    propCount = type
-      ? type === TRANSITION
-        ? transitionDurations.length
-        : animationDurations.length
-      : 0;
-  }
-  var hasTransform =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property']);
-  return {
-    type: type,
-    timeout: timeout,
-    propCount: propCount,
-    hasTransform: hasTransform
-  }
-}
-
-function getTimeout (delays, durations) {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
-  }
-
-  return Math.max.apply(null, durations.map(function (d, i) {
-    return toMs(d) + toMs(delays[i])
-  }))
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
 }
-
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs (s) {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
-}
-
-/*  */
-
-function enter (vnode, toggleDisplay) {
-  var el = vnode.elm;
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true;
-    el._leaveCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var enterClass = data.enterClass;
-  var enterToClass = data.enterToClass;
-  var enterActiveClass = data.enterActiveClass;
-  var appearClass = data.appearClass;
-  var appearToClass = data.appearToClass;
-  var appearActiveClass = data.appearActiveClass;
-  var beforeEnter = data.beforeEnter;
-  var enter = data.enter;
-  var afterEnter = data.afterEnter;
-  var enterCancelled = data.enterCancelled;
-  var beforeAppear = data.beforeAppear;
-  var appear = data.appear;
-  var afterAppear = data.afterAppear;
-  var appearCancelled = data.appearCancelled;
-  var duration = data.duration;
-
-  // activeInstance will always be the <transition> component managing this
-  // transition. One edge case to check is when the <transition> is placed
-  // as the root node of a child component. In that case we need to check
-  // <transition>'s parent for appear check.
-  var context = activeInstance;
-  var transitionNode = activeInstance.$vnode;
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context;
-    transitionNode = transitionNode.parent;
-  }
-
-  var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  var startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass;
-  var activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass;
-  var toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass;
-
-  var beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter;
-  var enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
-    : enter;
-  var afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter;
-  var enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
-    : enterCancelled;
-
-  var explicitEnterDuration = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
-  );
-
-  if (explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode);
-  }
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(enterHook);
-
-  var cb = el._enterCb = once(function () {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass);
-      removeTransitionClass(el, activeClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, startClass);
-      }
-      enterCancelledHook && enterCancelledHook(el);
-    } else {
-      afterEnterHook && afterEnterHook(el);
-    }
-    el._enterCb = null;
-  });
-
-  if (!vnode.data.show) {
-    // remove pending leave element on enter by injecting an insert hook
-    mergeVNodeHook(vnode, 'insert', function () {
-      var parent = el.parentNode;
-      var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-      if (pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb();
-      }
-      enterHook && enterHook(el, cb);
-    });
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el);
-  if (expectsCSS) {
-    addTransitionClass(el, startClass);
-    addTransitionClass(el, activeClass);
-    nextFrame(function () {
-      removeTransitionClass(el, startClass);
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass);
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration);
-          } else {
-            whenTransitionEnds(el, type, cb);
-          }
-        }
-      }
-    });
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay();
-    enterHook && enterHook(el, cb);
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb();
-  }
-}
-
-function leave (vnode, rm) {
-  var el = vnode.elm;
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true;
-    el._enterCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var leaveClass = data.leaveClass;
-  var leaveToClass = data.leaveToClass;
-  var leaveActiveClass = data.leaveActiveClass;
-  var beforeLeave = data.beforeLeave;
-  var leave = data.leave;
-  var afterLeave = data.afterLeave;
-  var leaveCancelled = data.leaveCancelled;
-  var delayLeave = data.delayLeave;
-  var duration = data.duration;
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(leave);
-
-  var explicitLeaveDuration = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
-  );
-
-  if (isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode);
-  }
-
-  var cb = el._leaveCb = once(function () {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null;
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+/* @flow */
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
     }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass);
-      removeTransitionClass(el, leaveActiveClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass);
-      }
-      leaveCancelled && leaveCancelled(el);
-    } else {
-      rm();
-      afterLeave && afterLeave(el);
-    }
-    el._leaveCb = null;
-  });
-
-  if (delayLeave) {
-    delayLeave(performLeave);
-  } else {
-    performLeave();
-  }
-
-  function performLeave () {
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
-    }
-    beforeLeave && beforeLeave(el);
-    if (expectsCSS) {
-      addTransitionClass(el, leaveClass);
-      addTransitionClass(el, leaveActiveClass);
-      nextFrame(function () {
-        removeTransitionClass(el, leaveClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-    leave && leave(el, cb);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
     if (!expectsCSS && !userWantsControl) {
-      cb();
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
     }
-  }
 }
-
 // only used in dev mode
-function checkDuration (val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      "<transition> explicit " + name + " duration is not a valid number - " +
-      "got " + (JSON.stringify(val)) + ".",
-      vnode.context
-    );
-  } else if (isNaN(val)) {
-    warn(
-      "<transition> explicit " + name + " duration is NaN - " +
-      'the duration expression might be incorrect.',
-      vnode.context
-    );
-  }
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn("<transition> explicit " + name + " duration is not a valid number - " +
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
 }
-
-function isValidDuration (val) {
-  return typeof val === 'number' && !isNaN(val)
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
 }
-
 /**
  * Normalize a transition hook's argument length. The hook may be:
  * - a merged hook (invoker) with the original in .fns
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength (fn) {
-  if (isUndef(fn)) {
-    return false
-  }
-  var invokerFns = fn.fns;
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
-    )
-  } else {
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter (_, vnode) {
-  if (vnode.data.show !== true) {
-    enter(vnode);
-  }
-}
-
-var transition = inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove: function remove$$1 (vnode, rm) {
-    /* istanbul ignore else */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-      leave(vnode, rm);
-    } else {
-      rm();
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove: function remove$$1(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
     }
-  }
-} : {};
-
-var platformModules = [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-];
+    : {};
 
-/*  */
+var platformModules = [attrs, klass, events, domProps, style, transition];
 
+/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
-
 var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
  * properties to Elements.
  */
-
 /* istanbul ignore if */
 if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', function () {
-    var el = document.activeElement;
-    if (el && el.vmodel) {
-      trigger(el, 'input');
-    }
-  });
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', function () {
+        var el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
 }
-
 var directive = {
-  inserted: function inserted (el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-          directive.componentUpdated(el, binding, vnode);
-        });
-      } else {
-        setSelected(el, binding, vnode.context);
-      }
-      el._vOptions = [].map.call(el.options, getValue);
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers;
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart);
-        el.addEventListener('compositionend', onCompositionEnd);
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd);
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true;
-        }
-      }
-    }
-  },
-
-  componentUpdated: function componentUpdated (el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context);
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      var prevOptions = el._vOptions;
-      var curOptions = el._vOptions = [].map.call(el.options, getValue);
-      if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-        // trigger change event if
-        // no matching option found for at least one value
-        var needReset = el.multiple
-          ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-        if (needReset) {
-          trigger(el, 'change');
-        }
-      }
-    }
-  }
+    inserted: function inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', function () {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated: function componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                // trigger change event if
+                // no matching option found for at least one value
+                var needReset = el.multiple
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
 };
-
-function setSelected (el, binding, vm) {
-  actuallySetSelected(el, binding, vm);
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(function () {
-      actuallySetSelected(el, binding, vm);
-    }, 0);
-  }
-}
-
-function actuallySetSelected (el, binding, vm) {
-  var value = binding.value;
-  var isMultiple = el.multiple;
-  if (isMultiple && !Array.isArray(value)) {
-    warn(
-      "<select multiple v-model=\"" + (binding.expression) + "\"> " +
-      "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
-      vm
-    );
-    return
-  }
-  var selected, option;
-  for (var i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i];
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1;
-      if (option.selected !== selected) {
-        option.selected = selected;
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i;
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(function () {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    var value = binding.value;
+    var isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)), vm);
+        return;
+    }
+    var selected, option;
+    for (var i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
         }
-        return
-      }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
     }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1;
-  }
 }
-
-function hasNoMatchingOption (value, options) {
-  return options.every(function (o) { return !looseEqual(o, value); })
+function hasNoMatchingOption(value, options) {
+    return options.every(function (o) { return !looseEqual(o, value); });
 }
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
 }
-
-function onCompositionStart (e) {
-  e.target.composing = true;
+function onCompositionStart(e) {
+    e.target.composing = true;
 }
-
-function onCompositionEnd (e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) { return }
-  e.target.composing = false;
-  trigger(e.target, 'input');
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        { return; }
+    e.target.composing = false;
+    trigger(e.target, 'input');
 }
-
-function trigger (el, type) {
-  var e = document.createEvent('HTMLEvents');
-  e.initEvent(type, true, true);
-  el.dispatchEvent(e);
+function trigger(el, type) {
+    var e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-/*  */
-
+/* @flow */
 // recursively search for possible transition defined inside the component root
-function locateNode (vnode) {
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
-    : vnode
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
 }
-
 var show = {
-  bind: function bind (el, ref, vnode) {
-    var value = ref.value;
-
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    var originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display;
-    if (value && transition$$1) {
-      vnode.data.show = true;
-      enter(vnode, function () {
-        el.style.display = originalDisplay;
-      });
-    } else {
-      el.style.display = value ? originalDisplay : 'none';
-    }
-  },
-
-  update: function update (el, ref, vnode) {
-    var value = ref.value;
-    var oldValue = ref.oldValue;
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition$$1) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
 
-    /* istanbul ignore if */
-    if (!value === !oldValue) { return }
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    if (transition$$1) {
-      vnode.data.show = true;
-      if (value) {
-        enter(vnode, function () {
-          el.style.display = el.__vOriginalDisplay;
-        });
-      } else {
-        leave(vnode, function () {
-          el.style.display = 'none';
-        });
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none';
-    }
-  },
-
-  unbind: function unbind (
-    el,
-    binding,
-    vnode,
-    oldVnode,
-    isDestroy
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay;
-    }
-  }
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            { return; }
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        if (transition$$1) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, function () {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
 var platformDirectives = {
-  model: directive,
-  show: show
+    model: directive,
+    show: show,
 };
 
-/*  */
-
+/* @flow */
 var transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
 };
-
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode) {
-  var compOptions = vnode && vnode.componentOptions;
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-function extractTransitionData (comp) {
-  var data = {};
-  var options = comp.$options;
-  // props
-  for (var key in options.propsData) {
-    data[key] = comp[key];
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  var listeners = options._parentListeners;
-  for (var key$1 in listeners) {
-    data[camelize(key$1)] = listeners[key$1];
-  }
-  return data
-}
-
-function placeholder (h, rawChild) {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
+function getRealChild(vnode) {
+    var compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    var data = {};
+    var options = comp.$options;
+    // props
+    for (var key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    var listeners = options._parentListeners;
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
 }
-
-function hasParentTransition (vnode) {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
     }
-  }
 }
-
-function isSameChild (child, oldChild) {
-  return oldChild.key === child.key && oldChild.tag === child.tag
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-
 var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
 var isVShowDirective = function (d) { return d.name === 'show'; };
-
 var Transition = {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render: function render (h) {
-    var this$1 = this;
-
-    var children = this.$slots.default;
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode);
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      );
-    }
-
-    var mode = this.mode;
-
-    // warn invalid mode
-    if (mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      );
-    }
-
-    var rawChild = children[0];
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    var child = getRealChild(rawChild);
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    var id = "__transition-" + (this._uid) + "-";
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key;
-
-    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-    var oldRawChild = this._vnode;
-    var oldChild = getRealChild(oldRawChild);
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true;
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      var oldData = oldChild.data.transition = extend({}, data);
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true;
-        mergeVNodeHook(oldData, 'afterLeave', function () {
-          this$1._leaving = false;
-          this$1.$forceUpdate();
-        });
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render: function render(h) {
+        var this$1 = this;
+
+        var children = this.$slots.default;
+        if (!children) {
+            return;
         }
-        var delayedLeave;
-        var performLeave = function () { delayedLeave(); };
-        mergeVNodeHook(data, 'afterEnter', performLeave);
-        mergeVNodeHook(data, 'enterCancelled', performLeave);
-        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-      }
-    }
-
-    return rawChild
-  }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        var mode = this.mode;
+        // warn invalid mode
+        if (mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        var rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        var child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        var id = "__transition-" + (this._uid) + "-";
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        var oldRawChild = this._vnode;
+        var oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            var oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', function () {
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                var delayedLeave;
+                var performLeave = function () {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-/*  */
-
+// Provides transition support for list items.
 var props = extend({
-  tag: String,
-  moveClass: String
+    tag: String,
+    moveClass: String,
 }, transitionProps);
-
+// @ts-ignore
 delete props.mode;
-
 var TransitionGroup = {
-  props: props,
-
-  beforeMount: function beforeMount () {
-    var this$1 = this;
-
-    var update = this._update;
-    this._update = function (vnode, hydrating) {
-      var restoreActiveInstance = setActiveInstance(this$1);
-      // force removing pass
-      this$1.__patch__(
-        this$1._vnode,
-        this$1.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      );
-      this$1._vnode = this$1.kept;
-      restoreActiveInstance();
-      update.call(this$1, vnode, hydrating);
-    };
-  },
-
-  render: function render (h) {
-    var tag = this.tag || this.$vnode.data.tag || 'span';
-    var map = Object.create(null);
-    var prevChildren = this.prevChildren = this.children;
-    var rawChildren = this.$slots.default || [];
-    var children = this.children = [];
-    var transitionData = extractTransitionData(this);
-
-    for (var i = 0; i < rawChildren.length; i++) {
-      var c = rawChildren[i];
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c);
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData;
-        } else {
-          var opts = c.componentOptions;
-          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-          warn(("<transition-group> children must be keyed: <" + name + ">"));
-        }
-      }
-    }
-
-    if (prevChildren) {
-      var kept = [];
-      var removed = [];
-      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-        var c$1 = prevChildren[i$1];
-        c$1.data.transition = transitionData;
-        c$1.data.pos = c$1.elm.getBoundingClientRect();
-        if (map[c$1.key]) {
-          kept.push(c$1);
-        } else {
-          removed.push(c$1);
-        }
-      }
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated: function updated () {
-    var children = this.prevChildren;
-    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs);
-    children.forEach(recordPosition);
-    children.forEach(applyTranslation);
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight;
-
-    children.forEach(function (c) {
-      if (c.data.moved) {
-        var el = c.elm;
-        var s = el.style;
-        addTransitionClass(el, moveClass);
-        s.transform = s.WebkitTransform = s.transitionDuration = '';
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb);
-            el._moveCb = null;
-            removeTransitionClass(el, moveClass);
-          }
+    props: props,
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
+        var update = this._update;
+        this._update = function (vnode, hydrating) {
+            var restoreActiveInstance = setActiveInstance(this$1);
+            // force removing pass
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this$1._vnode = this$1.kept;
+            restoreActiveInstance();
+            update.call(this$1, vnode, hydrating);
+        };
+    },
+    render: function render(h) {
+        var tag = this.tag || this.$vnode.data.tag || 'span';
+        var map = Object.create(null);
+        var prevChildren = (this.prevChildren = this.children);
+        var rawChildren = this.$slots.default || [];
+        var children = (this.children = []);
+        var transitionData = extractTransitionData(this);
+        for (var i = 0; i < rawChildren.length; i++) {
+            var c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else {
+                    var opts = c.componentOptions;
+                    var name = opts
+                        ? opts.Ctor.options.name || opts.tag || ''
+                        : c.tag;
+                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                }
+            }
+        }
+        if (prevChildren) {
+            var kept = [];
+            var removed = [];
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
+                // @ts-ignore
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                // @ts-ignore
+                if (map[c$1.key]) {
+                    kept.push(c$1);
+                }
+                else {
+                    removed.push(c$1);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated: function updated() {
+        var children = this.prevChildren;
+        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach(function (c) {
+            // @ts-ignore
+            if (c.data.moved) {
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
         });
-      }
-    });
-  },
-
-  methods: {
-    hasMove: function hasMove (el, moveClass) {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      var clone = el.cloneNode();
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
-      }
-      addClass(clone, moveClass);
-      clone.style.display = 'none';
-      this.$el.appendChild(clone);
-      var info = getTransitionInfo(clone);
-      this.$el.removeChild(clone);
-      return (this._hasMove = info.hasTransform)
-    }
-  }
+    },
+    methods: {
+        hasMove: function hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            var clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach(function (cls) {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = 'none';
+            this.$el.appendChild(clone);
+            var info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
 };
-
-function callPendingCbs (c) {
-  /* istanbul ignore if */
-  if (c.elm._moveCb) {
-    c.elm._moveCb();
-  }
-  /* istanbul ignore if */
-  if (c.elm._enterCb) {
-    c.elm._enterCb();
-  }
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._moveCb) {
+        //@ts-ignore
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._enterCb) {
+        //@ts-ignore
+        c.elm._enterCb();
+    }
 }
-
-function recordPosition (c) {
-  c.data.newPos = c.elm.getBoundingClientRect();
+function recordPosition(c) {
+    //@ts-ignore
+    c.data.newPos = c.elm.getBoundingClientRect();
 }
-
-function applyTranslation (c) {
-  var oldPos = c.data.pos;
-  var newPos = c.data.newPos;
-  var dx = oldPos.left - newPos.left;
-  var dy = oldPos.top - newPos.top;
-  if (dx || dy) {
-    c.data.moved = true;
-    var s = c.elm.style;
-    s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-    s.transitionDuration = '0s';
-  }
+function applyTranslation(c) {
+    //@ts-ignore
+    var oldPos = c.data.pos;
+    //@ts-ignore
+    var newPos = c.data.newPos;
+    var dx = oldPos.left - newPos.left;
+    var dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        //@ts-ignore
+        c.data.moved = true;
+        //@ts-ignore
+        var s = c.elm.style;
+        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+        s.transitionDuration = '0s';
+    }
 }
 
 var platformComponents = {
-  Transition: Transition,
-  TransitionGroup: TransitionGroup
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
 };
 
-/*  */
-
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp;
 Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
 Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
-
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
 extend(Vue.options.components, platformComponents);
-
 // install platform patch function
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
 // public mount method
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && inBrowser ? query(el) : undefined;
-  return mountComponent(this, el, hydrating)
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
 };
-
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-  setTimeout(function () {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue);
-      } else {
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
-        );
-      }
-    }
-    if (config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      console[console.info ? 'info' : 'log'](
-        "You are running Vue in development mode.\n" +
-        "Make sure to turn on production mode when deploying for production.\n" +
-        "See more tips at https://vuejs.org/guide/deployment.html"
-      );
-    }
-  }, 0);
+    setTimeout(function () {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                "Make sure to turn on production mode when deploying for production.\n" +
+                "See more tips at https://vuejs.org/guide/deployment.html");
+        }
+    }, 0);
 }
 
-/*  */
-
+/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
 var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
-
-/*  */
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  if (staticClass) {
-    var res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        "class=\"" + staticClass + "\": " +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
-}
-
-function genData (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    var tokens = [];
+    var rawTokens = [];
+    var lastIndex = (tagRE.lastIndex = 0);
+    var match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        var exp = parseFilters(match[1].trim());
+        tokens.push(("_s(" + exp + ")"));
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
+/* @flow */
+function transformNode(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        var res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn("class=\"" + staticClass + "\": " +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass);
+    }
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData(el) {
+    var data = '';
+    if (el.staticClass) {
+        data += "staticClass:" + (el.staticClass) + ",";
+    }
+    if (el.classBinding) {
+        data += "class:" + (el.classBinding) + ",";
+    }
+    return data;
+}
 var klass$1 = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData
+    staticKeys: ['staticClass'],
+    transformNode: transformNode,
+    genData: genData,
 };
 
-/*  */
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    {
-      var res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          "style=\"" + staticStyle + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
+/* @flow */
+function transformNode$1(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            var res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn("style=\"" + staticStyle + "\": " +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
     }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
 }
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:(" + (el.styleBinding) + "),";
-  }
-  return data
+function genData$1(el) {
+    var data = '';
+    if (el.staticStyle) {
+        data += "staticStyle:" + (el.staticStyle) + ",";
+    }
+    if (el.styleBinding) {
+        data += "style:(" + (el.styleBinding) + "),";
+    }
+    return data;
 }
-
 var style$1 = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
-};
-
-/*  */
-
-var decoder;
-
-var he = {
-  decode: function decode (html) {
-    decoder = decoder || document.createElement('div');
-    decoder.innerHTML = html;
-    return decoder.textContent
-  }
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode$1,
+    genData: genData$1,
 };
 
-/*  */
+/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+(function(root) {
+
+	// Detect free variables `exports`.
+	var freeExports = typeof exports == 'object' && exports;
+
+	// Detect free variable `module`.
+	var freeModule = typeof module == 'object' && module &&
+		module.exports == freeExports && module;
+
+	// Detect free variable `global`, from Node.js or Browserified code,
+	// and use it as `root`.
+	var freeGlobal = typeof global == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	// All astral symbols.
+	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	// All ASCII symbols (not just printable ASCII) except those listed in the
+	// first column of the overrides table.
+	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+	var regexAsciiWhitelist = /[\x01-\x7F]/g;
+	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+	// code points listed in the first column of the overrides table on
+	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+	var regexEscape = /["&'<>`]/g;
+	var escapeMap = {
+		'"': '&quot;',
+		'&': '&amp;',
+		'\'': '&#x27;',
+		'<': '&lt;',
+		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+		// following is not strictly necessary unless it’s part of a tag or an
+		// unquoted attribute value. We’re only escaping it to support those
+		// situations, and for XML support.
+		'>': '&gt;',
+		// In Internet Explorer ≤ 8, the backtick character can be used
+		// to break out of (un)quoted attribute values or HTML comments.
+		// See http://html5sec.org/#102, http://html5sec.org/#108, and
+		// http://html5sec.org/#133.
+		'`': '&#x60;'
+	};
+
+	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+	/*--------------------------------------------------------------------------*/
+
+	var stringFromCharCode = String.fromCharCode;
+
+	var object = {};
+	var hasOwnProperty = object.hasOwnProperty;
+	var has = function(object, propertyName) {
+		return hasOwnProperty.call(object, propertyName);
+	};
+
+	var contains = function(array, value) {
+		var index = -1;
+		var length = array.length;
+		while (++index < length) {
+			if (array[index] == value) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+	var merge = function(options, defaults) {
+		if (!options) {
+			return defaults;
+		}
+		var result = {};
+		var key;
+		for (key in defaults) {
+			// A `hasOwnProperty` check is not needed here, since only recognized
+			// option names are used anyway. Any others are ignored.
+			result[key] = has(options, key) ? options[key] : defaults[key];
+		}
+		return result;
+	};
+
+	// Modified version of `ucs2encode`; see https://mths.be/punycode.
+	var codePointToSymbol = function(codePoint, strict) {
+		var output = '';
+		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+			// See issue #4:
+			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+			// REPLACEMENT CHARACTER.”
+			if (strict) {
+				parseError('character reference outside the permissible Unicode range');
+			}
+			return '\uFFFD';
+		}
+		if (has(decodeMapNumeric, codePoint)) {
+			if (strict) {
+				parseError('disallowed character reference');
+			}
+			return decodeMapNumeric[codePoint];
+		}
+		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+			parseError('disallowed character reference');
+		}
+		if (codePoint > 0xFFFF) {
+			codePoint -= 0x10000;
+			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+			codePoint = 0xDC00 | codePoint & 0x3FF;
+		}
+		output += stringFromCharCode(codePoint);
+		return output;
+	};
+
+	var hexEscape = function(codePoint) {
+		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+	};
+
+	var decEscape = function(codePoint) {
+		return '&#' + codePoint + ';';
+	};
+
+	var parseError = function(message) {
+		throw Error('Parse error: ' + message);
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var encode = function(string, options) {
+		options = merge(options, encode.options);
+		var strict = options.strict;
+		if (strict && regexInvalidRawCodePoint.test(string)) {
+			parseError('forbidden code point');
+		}
+		var encodeEverything = options.encodeEverything;
+		var useNamedReferences = options.useNamedReferences;
+		var allowUnsafeSymbols = options.allowUnsafeSymbols;
+		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+		var escapeBmpSymbol = function(symbol) {
+			return escapeCodePoint(symbol.charCodeAt(0));
+		};
+
+		if (encodeEverything) {
+			// Encode ASCII symbols.
+			string = string.replace(regexAsciiWhitelist, function(symbol) {
+				// Use named references if requested & possible.
+				if (useNamedReferences && has(encodeMap, symbol)) {
+					return '&' + encodeMap[symbol] + ';';
+				}
+				return escapeBmpSymbol(symbol);
+			});
+			// Shorten a few escapes that represent two symbols, of which at least one
+			// is within the ASCII range.
+			if (useNamedReferences) {
+				string = string
+					.replace(/&gt;\u20D2/g, '&nvgt;')
+					.replace(/&lt;\u20D2/g, '&nvlt;')
+					.replace(/&#x66;&#x6A;/g, '&fjlig;');
+			}
+			// Encode non-ASCII symbols.
+			if (useNamedReferences) {
+				// Encode non-ASCII symbols that can be replaced with a named reference.
+				string = string.replace(regexEncodeNonAscii, function(string) {
+					// Note: there is no need to check `has(encodeMap, string)` here.
+					return '&' + encodeMap[string] + ';';
+				});
+			}
+			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+		} else if (useNamedReferences) {
+			// Apply named character references.
+			// Encode `<>"'&` using named character references.
+			if (!allowUnsafeSymbols) {
+				string = string.replace(regexEscape, function(string) {
+					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+				});
+			}
+			// Shorten escapes that represent two symbols, of which at least one is
+			// `<>"'&`.
+			string = string
+				.replace(/&gt;\u20D2/g, '&nvgt;')
+				.replace(/&lt;\u20D2/g, '&nvlt;');
+			// Encode non-ASCII symbols that can be replaced with a named reference.
+			string = string.replace(regexEncodeNonAscii, function(string) {
+				// Note: there is no need to check `has(encodeMap, string)` here.
+				return '&' + encodeMap[string] + ';';
+			});
+		} else if (!allowUnsafeSymbols) {
+			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+			// using named character references.
+			string = string.replace(regexEscape, escapeBmpSymbol);
+		}
+		return string
+			// Encode astral symbols.
+			.replace(regexAstralSymbols, function($0) {
+				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+				var high = $0.charCodeAt(0);
+				var low = $0.charCodeAt(1);
+				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+				return escapeCodePoint(codePoint);
+			})
+			// Encode any remaining BMP symbols that are not printable ASCII symbols
+			// using a hexadecimal escape.
+			.replace(regexBmpWhitelist, escapeBmpSymbol);
+	};
+	// Expose default options (so they can be overridden globally).
+	encode.options = {
+		'allowUnsafeSymbols': false,
+		'encodeEverything': false,
+		'strict': false,
+		'useNamedReferences': false,
+		'decimal' : false
+	};
+
+	var decode = function(html, options) {
+		options = merge(options, decode.options);
+		var strict = options.strict;
+		if (strict && regexInvalidEntity.test(html)) {
+			parseError('malformed character reference');
+		}
+		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+			var codePoint;
+			var semicolon;
+			var decDigits;
+			var hexDigits;
+			var reference;
+			var next;
+
+			if ($1) {
+				reference = $1;
+				// Note: there is no need to check `has(decodeMap, reference)`.
+				return decodeMap[reference];
+			}
+
+			if ($2) {
+				// Decode named character references without trailing `;`, e.g. `&amp`.
+				// This is only a parse error if it gets converted to `&`, or if it is
+				// followed by `=` in an attribute context.
+				reference = $2;
+				next = $3;
+				if (next && options.isAttributeValue) {
+					if (strict && next == '=') {
+						parseError('`&` did not start a character reference');
+					}
+					return $0;
+				} else {
+					if (strict) {
+						parseError(
+							'named character reference was not terminated by a semicolon'
+						);
+					}
+					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+					return decodeMapLegacy[reference] + (next || '');
+				}
+			}
+
+			if ($4) {
+				// Decode decimal escapes, e.g. `&#119558;`.
+				decDigits = $4;
+				semicolon = $5;
+				if (strict && !semicolon) {
+					parseError('character reference was not terminated by a semicolon');
+				}
+				codePoint = parseInt(decDigits, 10);
+				return codePointToSymbol(codePoint, strict);
+			}
+
+			if ($6) {
+				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+				hexDigits = $6;
+				semicolon = $7;
+				if (strict && !semicolon) {
+					parseError('character reference was not terminated by a semicolon');
+				}
+				codePoint = parseInt(hexDigits, 16);
+				return codePointToSymbol(codePoint, strict);
+			}
+
+			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+			if (strict) {
+				parseError(
+					'named character reference was not terminated by a semicolon'
+				);
+			}
+			return $0;
+		});
+	};
+	// Expose default options (so they can be overridden globally).
+	decode.options = {
+		'isAttributeValue': false,
+		'strict': false
+	};
+
+	var escape = function(string) {
+		return string.replace(regexEscape, function($0) {
+			// Note: there is no need to check `has(escapeMap, $0)` here.
+			return escapeMap[$0];
+		});
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var he = {
+		'version': '1.2.0',
+		'encode': encode,
+		'decode': decode,
+		'escape': escape,
+		'unescape': decode
+	};
+
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define(function() {
+			return he;
+		});
+	}	else if (freeExports && !freeExports.nodeType) {
+		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = he;
+		} else { // in Narwhal or RingoJS v0.7.0-
+			for (var key in he) {
+				has(he, key) && (freeExports[key] = he[key]);
+			}
+		}
+	} else { // in Rhino or a web browser
+		root.he = he;
+	}
+
+}(undefined));
+
+var he = /*#__PURE__*/Object.freeze({
 
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
+});
 
+/* @flow */
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
 var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -9253,309 +8531,287 @@ var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
 var conditionalComment = /^<!\[/;
-
 // Special Elements (can contain anything)
 var isPlainTextElement = makeMap('script,style,textarea', true);
 var reCache = {};
-
 var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
 var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
 var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+function decodeAttr(value, shouldDecodeNewlines) {
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, function (match) { return decodingMap[match]; });
+}
+function parseHTML(html, options) {
+    var stack = [];
+    var expectHTML = options.expectHTML;
+    var isUnaryTag$$1 = options.isUnaryTag || no;
+    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var index = 0;
+    var last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            var textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    var commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    var conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                var doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                var endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    var curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                var startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            var text = (void 0), rest = (void 0), next = (void 0);
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        { break; }
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        var start = html.match(startTagOpen);
+        if (start) {
+            var match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            var end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        var tagName = match.tagName;
+        var unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var l = match.attrs.length;
+        var attrs = new Array(l);
+        for (var i = 0; i < l; i++) {
+            var args = match.attrs[i];
+            var value = args[3] || args[4] || args[5] || '';
+            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        var pos, lowerCasedTagName;
+        if (start == null)
+            { start = index; }
+        if (end == null)
+            { end = index; }
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (var i = stack.length - 1; i >= pos; i--) {
+                if (i > pos || !tagName &&
+                    options.warn) {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
+}
 
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-            }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
-        }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
-        }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
-        }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (!stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
-    }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
-    }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
-    }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (i > pos || !tagName &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
-}
-
-/*  */
-
+/* @flow */
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
 var stripParensRE = /^\(|\)$/g;
 var dynamicArgRE = /^\[.*\]$/;
-
 var argRE = /:(.*)$/;
 var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
 var slotRE = /^v-slot(:|$)|^#/;
-
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE$1 = /\s+/g;
-
+var whitespaceRE$1 = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-
-var decodeHTMLCached = cached(he.decode);
-
+var decodeHTMLCached = cached(undefined);
 var emptySlotScopeToken = "_empty_";
-
 // configurable state
 var warn$2;
 var delimiters;
@@ -9566,1040 +8822,889 @@ var platformIsPreTag;
 var platformMustUseProp;
 var platformGetTagNamespace;
 var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag: tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent: parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$2 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$2(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$2 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    var isReservedTag = options.isReservedTag || no;
+    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    var stack = [];
+    var preserveWhitespace = options.preserveWhitespace !== false;
+    var whitespaceOption = options.whitespace;
+    var root;
+    var currentParent;
+    var inVPre = false;
+    var inPre = false;
+    var warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$2(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
-    }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
-    }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
-    }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$2,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$2(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        warn$2(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce("Component template should contain exactly one root element. " +
+                    "If you are using v-if on multiple elements, " +
+                    "use v-else-if to chain them instead.", { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
         if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        {
-          checkRootConstraints(root);
+            inVPre = false;
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
-        {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE$1, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
-        }
-        currentParent.children.push(child);
-      }
-    }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    {
-      if (el.tag === 'template') {
-        warn$2(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$2(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
-}
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
-}
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else {
-      warn$2(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-}
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
-}
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (var i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            var lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$2,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start: function start(tag, attrs, unary, start$1, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            var element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start$1;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach(function (attr) {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$2("Invalid dynamic argument expression: attribute names cannot contain " +
+                            "spaces, quotes, <, >, / or =.", {
+                            start: attr.start + attr.name.indexOf("["),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn$2('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        "<" + tag + ">" +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (var i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end: function end(tag, start, end$1) {
+            var element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end$1;
+            }
+            closeElement(element);
+        },
+        chars: function chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                            start: start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            var children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE$1, ' ');
+                }
+                var res;
+                var child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text: text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text: text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment: function comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                var child = {
+                    type: 3,
+                    text: text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
     });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    var list = el.attrsList;
+    var len = list.length;
+    if (len) {
+        var attrs = (el.attrs = new Array(len));
+        for (var i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
     }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (var i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    var exp = getBindingAttr(el, 'key');
+    if (exp) {
+        {
+            if (el.tag === 'template') {
+                warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                var iterator = el.iterator2 || el.iterator1;
+                var parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$2("Do not use v-for index as key on <transition-group> children, " +
+                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else {
-    warn$2(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
-}
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (children[i].text !== ' ') {
-        warn$2(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
+function processRef(el) {
+    var ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
     }
-  }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function processFor(el) {
+    var exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        var res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn$2(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+        }
+    }
 }
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function parseFor(exp) {
+    var inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        { return; }
+    var res = {};
+    res.for = inMatch[2].trim();
+    var alias = inMatch[1].trim().replace(stripParensRE, '');
+    var iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    var exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    var prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    var i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn$2("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                    "will be ignored.", children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    var once$$1 = getAndRemoveAttr(el, 'v-once');
+    if (once$$1 != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (slotScope) {
-      warn$2(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (el.attrsMap['v-for']) {
-      warn$2(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    var slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        {
-          if (el.slotTarget || el.slotScope) {
-            warn$2(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$2(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
-        }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        {
-          if (!maybeComponent(el)) {
-            warn$2(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$2(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$2(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
-    }
-  }
-}
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else {
-      warn$2(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn$2("the \"scope\" attribute for scoped slots have been deprecated and " +
+                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                "can also be used on plain elements in addition to <template> to " +
+                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn$2("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                "(v-for takes higher priority). Use a wrapper <template> for the " +
+                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    var slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$2("<template v-slot> can only appear at the root level inside " +
+                            "the receiving component", el);
+                    }
+                }
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn$2("v-slot can only be used on components or <template>.", slotBinding$1);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$2("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding$1);
+                    }
+                }
+                // add the component's children to its default slot
+                var slots = el.scopedSlots || (el.scopedSlots = {});
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    var name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn$2("v-slot shorthand syntax requires a slot name.", binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: ("\"" + name + "\""), dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (el.key) {
-      warn$2(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
-}
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
-}
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          value.trim().length === 0
-        ) {
-          warn$2(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn$2,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$2,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn$2,
-                list[i],
-                true // dynamic
-              );
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn$2(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
-}
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent;
-  }
-  return false
-}
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn$2("`key` does not work on <slot> because slots are abstract outlets " +
+                "and can possibly expand into multiple elements. " +
+                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+function processComponent(el) {
+    var binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
     }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
 }
-
+function processAttrs(el) {
+    var list = el.attrsList;
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn$2(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            { name = 'innerHTML'; }
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, "$event");
+                        if (!isDynamic) {
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$2, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$2, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$2, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                var argMatch = name.match(argRE);
+                var arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                var res = parseText(value, delimiters);
+                if (res) {
+                    warn$2(name + "=\"" + value + "\": " +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    var parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    var match = name.match(modifierRE);
+    if (match) {
+        var ret = {};
+        match.forEach(function (m) {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    var map = {};
+    for (var i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
 var ieNSBug = /^xmlns:NS\d+/;
 var ieNSPrefix = /^NS\d+:/;
-
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$2(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap;
-    if (!map['v-model']) {
-      return
-    }
-
-    var typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
-    }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = "(" + (map['v-bind']) + ").type";
-    }
-
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      var branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      var branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
-    }
-  }
-}
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function guardIESVGBug(attrs) {
+    var res = [];
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    var _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                "You are binding v-model directly to a v-for iteration alias. " +
+                "This will not be able to modify the v-for source array because " +
+                "writing to the alias is like modifying a function local variable. " +
+                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
+/* @flow */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        var map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        var typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = "(" + (map['v-bind']) + ").type";
+        }
+        if (typeBinding) {
+            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            var branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            var branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            var branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
 var model$1 = {
-  preTransformNode: preTransformNode
+    preTransformNode: preTransformNode,
 };
 
-var modules$1 = [
-  klass$1,
-  style$1,
-  model$1
-];
+var modules$1 = [klass$1, style$1, model$1];
 
-/*  */
-
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-  }
+/* @flow */
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-  }
+/* @flow */
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
 var directives$1 = {
-  model: model,
-  text: text,
-  html: html
+    model: model,
+    text: text,
+    html: html,
 };
 
-/*  */
-
+/* @flow */
 var baseOptions = {
-  expectHTML: true,
-  modules: modules$1,
-  directives: directives$1,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys(modules$1)
+    expectHTML: true,
+    modules: modules$1,
+    directives: directives$1,
+    isPreTag: isPreTag,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
+    // @ts-ignore
+    staticKeys: genStaticKeys(modules$1),
 };
 
-/*  */
-
+/* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
-
 var genStaticKeysCached = cached(genStaticKeys$1);
-
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -10611,1349 +9716,1183 @@ var genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize (root, options) {
-  if (!root) { return }
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic$1(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic$1 (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      markStatic$1(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        markStatic$1(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        markStaticRoots(node.ifConditions[i$1].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
-}
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
-    }
-    if (node.for) {
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+function optimize(root, options) {
+    if (!root)
+        { return; }
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic$1(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys$1(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic$1(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            markStatic$1(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
+                markStatic$1(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (var i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
+}
 
+/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
 // KeyboardEvent.keyCode aliases
 var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
 var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
 var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
 var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard("$event.target !== $event.currentTarget"),
+    ctrl: genGuard("!$event.ctrlKey"),
+    shift: genGuard("!$event.shiftKey"),
+    alt: genGuard("!$event.altKey"),
+    meta: genGuard("!$event.metaKey"),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2"),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
-}
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
+function genHandlers(events, isNative) {
+    var prefix = isNative ? 'nativeOn:' : 'on:';
+    var staticHandlers = "";
+    var dynamicHandlers = "";
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
+        }
+        else {
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+        }
     }
-    if (keys.length) {
-      code += genKeyFilter(keys);
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    if (dynamicHandlers) {
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
     }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
+    else {
+        return prefix + staticHandlers;
     }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + "($event)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ")($event)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    return ("function($event){" + code + handlerCode + "}")
-  }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+    }
+    var isMethodPath = simplePathRE.test(handler.value);
+    var isFunctionExpression = fnExpRE.test(handler.value);
+    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+    }
+    else {
+        var code = '';
+        var genModifierCode = '';
+        var keys = [];
+        for (var key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                var modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        var handlerCode = isMethodPath
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            : isFunctionExpression
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                : isFunctionInvocation
+                    ? ("return " + (handler.value))
+                    : handler.value;
+        return ("function($event){" + code + handlerCode + "}");
+    }
+}
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    var keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return ("$event.keyCode!==" + keyVal);
+    }
+    var keyCode = keyCodes[key];
+    var keyName = keyNames[key];
+    return ("_k($event.keyCode," +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
+        "$event.key," +
+        "" + (JSON.stringify(keyName)) +
+        ")");
 }
 
-/*  */
-
-function on (el, dir) {
-  if (dir.modifiers) {
-    warn("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+/* @flow */
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn("v-on without argument does not support modifiers.");
+    }
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+/* @flow */
+function bind$1(el, dir) {
+    el.wrapData = function (code) {
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+    };
 }
 
-/*  */
-
+/* @flow */
 var baseDirectives = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
+    on: on,
+    bind: bind$1,
+    cloak: noop,
 };
 
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
+/* @flow */
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
 };
-
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function generate(ast, options) {
+    var state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    var code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: ("with(this){return " + code + "}"),
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else {
+        // component or element
+        var code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            var data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData$2(el, state);
+            }
+            var children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+        }
+        // module transforms
+        for (var i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    var originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.pre = originalPreState;
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData$2 (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (el.children.length !== 1 || ast.type !== 1) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        var key = '';
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    var condition = conditions.shift();
+    if (condition.exp) {
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+    }
+    else {
+        return ("" + (genTernaryExp(condition.block)));
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    var exp = el.for;
+    var alias = el.alias;
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+            "v-for should have explicit keys. " +
+            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return ((altHelper || '_l') + "((" + exp + ")," +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
+        '})');
+}
+function genData$2(el, state) {
+    var data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    var dirs = genDirectives(el, state);
+    if (dirs)
+        { data += dirs + ','; }
+    // key
+    if (el.key) {
+        data += "key:" + (el.key) + ",";
+    }
+    // ref
+    if (el.ref) {
+        data += "ref:" + (el.ref) + ",";
+    }
+    if (el.refInFor) {
+        data += "refInFor:true,";
+    }
+    // pre
+    if (el.pre) {
+        data += "pre:true,";
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += "tag:\"" + (el.tag) + "\",";
+    }
+    // module data generation functions
+    for (var i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += "attrs:" + (genProps(el.attrs)) + ",";
+    }
+    // DOM props
+    if (el.props) {
+        data += "domProps:" + (genProps(el.props)) + ",";
+    }
+    // event handlers
+    if (el.events) {
+        data += (genHandlers(el.events, false)) + ",";
+    }
+    if (el.nativeEvents) {
+        data += (genHandlers(el.nativeEvents, true)) + ",";
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += "slot:" + (el.slotTarget) + ",";
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+    }
+    // component v-model
+    if (el.model) {
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        var inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += inlineTemplate + ",";
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    var dirs = el.directives;
+    if (!dirs)
+        { return; }
+    var res = 'directives:[';
+    var hasRuntime = false;
+    var i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        var gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
     }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
 }
-
+function genInlineTemplate(el, state) {
+    var ast = el.children[0];
+    if (el.children.length !== 1 || ast.type !== 1) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        var inlineRenderFns = generate(ast, state.options);
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    var needsForceUpdate = el.for ||
+        Object.keys(slots).some(function (key) {
+            var slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    var needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    var generatedSlots = Object.keys(slots)
+        .map(function (key) { return genScopedSlot(slots[key], state); })
+        .join(',');
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+}
 function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
+    var hash = 5381;
+    var i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
 }
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-}
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    var isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, "null");
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+    var fn = "function(" + slotScope + "){" +
+        "return " + (el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)) + "}";
+    // reverse proxy v-slot without scope on this.$slots
+    var reverseProxy = slotScope ? "" : ",proxy:true";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    var children = el.children;
+    if (children.length) {
+        var el$1 = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
+                    ? ",1"
+                    : ",0"
+                : "";
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+        }
+        var normalizationType$1 = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
-}
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-}
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
-}
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? ("," + children) : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function getNormalizationType(children, maybeComponent) {
+    var res = 0;
+    for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return ("_v(" + (text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+}
+function genComment(comment) {
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+}
+function genSlot(el, state) {
+    var slotName = el.slotName || '"default"';
+    var children = genChildren(el, state);
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+        }); }))
+        : null;
+    var bind$$1 = el.attrsMap['v-bind'];
+    if ((attrs || bind$$1) && !children) {
+        res += ",null";
+    }
+    if (attrs) {
+        res += "," + attrs;
+    }
+    if (bind$$1) {
+        res += (attrs ? '' : ',null') + "," + bind$$1;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    var children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+}
+function genProps(props) {
+    var staticProps = "";
+    var dynamicProps = "";
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        var value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += (prop.name) + "," + value + ",";
+        }
+        else {
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+        }
+    }
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    if (dynamicProps) {
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
+/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+var prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+var unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
 var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
-}
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
-}
-
-function checkEvent (exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
+                if (value) {
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else {
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (var i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkEvent(exp, text, warn, range) {
+    var stripped = exp.replace(stripStringRE, '');
+    var keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn("avoid using JavaScript unary operator as property name: " +
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(("var " + ident + "=_"));
+        }
+        catch (e) {
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-    }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
+        new Function(("return " + exp));
+    }
+    catch (e) {
+        var keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn("avoid using JavaScript keyword as property name: " +
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+        }
+        else {
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
+    }
 }
 
-/*  */
-
+/* @flow */
 var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
-    }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
+function generateCodeFrame(source, start, end) {
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
+    var lines = source.split(/\r?\n/);
+    var count = 0;
+    var res = [];
+    for (var i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (var j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    { continue; }
+                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                var lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    var pad = start - (count - lineLength) + 1;
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat$1("^", length$1));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
         }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+    }
+    return res.join('\n');
+}
+function repeat$1(str, n) {
+    var result = '';
+    if (n > 0) {
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                { result += str; }
+            n >>>= 1;
+            if (n <= 0)
+                { break; }
+            str += str;
         }
-      }
     }
+    return result;
+}
 
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
-            }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
+/* @flow */
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
+    catch (err) {
+        errors.push({ err: err, code: code });
+        return noop;
     }
-  }
+}
+function createCompileToFunctionFn(compile) {
+    var cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        var warn$$1 = options.warn || warn;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        var key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        var compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach(function (e) {
+                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                }
+                else {
+                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                }
+            }
+        }
+        // turn code into functions
+        var res = {};
+        var fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn$$1("Failed to generate render function:\n\n" +
+                    fnGenErrors
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+/* @flow */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            var finalOptions = Object.create(baseOptions);
+            var errors = [];
+            var tips = [];
+            var warn = function (msg, range, tip) {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = function (msg, range, tip) {
+                        var data = { msg: msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (var key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            var compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile: compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
+/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  var code = generate(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    var code = generate(ast, options);
+    return {
+        ast: ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
+/* @flow */
 var ref$1 = createCompiler(baseOptions);
 var compile = ref$1.compile;
 var compileToFunctions = ref$1.compileToFunctions;
 
-/*  */
-
+/* @flow */
 // check whether current browser encodes a char inside attribute values
 var div;
-function getShouldDecode (href) {
-  div = div || document.createElement('div');
-  div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
-  return div.innerHTML.indexOf('&#10;') > 0
+function getShouldDecode(href) {
+    div = div || document.createElement('div');
+    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+    return div.innerHTML.indexOf('&#10;') > 0;
 }
-
 // #3663: IE encodes newlines inside attribute values while other browsers don't
 var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
-
-/*  */
+var shouldDecodeNewlinesForHref = inBrowser
+    ? getShouldDecode(true)
+    : false;
 
+/* @flow */
 var idToTemplate = cached(function (id) {
-  var el = query(id);
-  return el && el.innerHTML
+    var el = query(id);
+    return el && el.innerHTML;
 });
-
 var mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && query(el);
-
-  /* istanbul ignore if */
-  if (el === document.body || el === document.documentElement) {
-    warn(
-      "Do not mount Vue to <html> or <body> - mount to normal elements instead."
-    );
-    return this
-  }
-
-  var options = this.$options;
-  // resolve template/el and convert to render function
-  if (!options.render) {
-    var template = options.template;
-    if (template) {
-      if (typeof template === 'string') {
-        if (template.charAt(0) === '#') {
-          template = idToTemplate(template);
-          /* istanbul ignore if */
-          if (!template) {
-            warn(
-              ("Template element not found or is empty: " + (options.template)),
-              this
-            );
-          }
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && query(el);
+    /* istanbul ignore if */
+    if (el === document.body || el === document.documentElement) {
+        warn("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+        return this;
+    }
+    var options = this.$options;
+    // resolve template/el and convert to render function
+    if (!options.render) {
+        var template = options.template;
+        if (template) {
+            if (typeof template === 'string') {
+                if (template.charAt(0) === '#') {
+                    template = idToTemplate(template);
+                    /* istanbul ignore if */
+                    if (!template) {
+                        warn(("Template element not found or is empty: " + (options.template)), this);
+                    }
+                }
+            }
+            else if (template.nodeType) {
+                template = template.innerHTML;
+            }
+            else {
+                {
+                    warn('invalid template option:' + template, this);
+                }
+                return this;
+            }
         }
-      } else if (template.nodeType) {
-        template = template.innerHTML;
-      } else {
-        {
-          warn('invalid template option:' + template, this);
-        }
-        return this
-      }
-    } else if (el) {
-      template = getOuterHTML(el);
-    }
-    if (template) {
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        mark('compile');
-      }
-
-      var ref = compileToFunctions(template, {
-        outputSourceRange: "development" !== 'production',
-        shouldDecodeNewlines: shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
-        delimiters: options.delimiters,
-        comments: options.comments
-      }, this);
-      var render = ref.render;
-      var staticRenderFns = ref.staticRenderFns;
-      options.render = render;
-      options.staticRenderFns = staticRenderFns;
-
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        mark('compile end');
-        measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
-      }
-    }
-  }
-  return mount.call(this, el, hydrating)
+        else if (el) {
+            // @ts-expect-error
+            template = getOuterHTML(el);
+        }
+        if (template) {
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile');
+            }
+            var ref = compileToFunctions(template, {
+                outputSourceRange: "development" !== 'production',
+                shouldDecodeNewlines: shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                delimiters: options.delimiters,
+                comments: options.comments,
+            }, this);
+            var render = ref.render;
+            var staticRenderFns = ref.staticRenderFns;
+            options.render = render;
+            options.staticRenderFns = staticRenderFns;
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile end');
+                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+            }
+        }
+    }
+    return mount.call(this, el, hydrating);
 };
-
 /**
  * Get outerHTML of elements, taking care
  * of SVG elements in IE as well.
  */
-function getOuterHTML (el) {
-  if (el.outerHTML) {
-    return el.outerHTML
-  } else {
-    var container = document.createElement('div');
-    container.appendChild(el.cloneNode(true));
-    return container.innerHTML
-  }
+function getOuterHTML(el) {
+    if (el.outerHTML) {
+        return el.outerHTML;
+    }
+    else {
+        var container = document.createElement('div');
+        container.appendChild(el.cloneNode(true));
+        return container.innerHTML;
+    }
 }
-
 Vue.compile = compileToFunctions;
 
 module.exports = Vue;
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
index afe9a4cdb2b..7673ab64786 100644
--- a/dist/vue.common.prod.js
+++ b/dist/vue.common.prod.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},E=function(e){return e};function N(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return N(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return N(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(N(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B,U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),J=z&&window.navigator.userAgent.toLowerCase(),q=J&&/msie|trident/.test(J),W=J&&J.indexOf("msie 9.0")>0,Z=J&&J.indexOf("edge/")>0,G=(J&&J.indexOf("android"),J&&/iphone|ipad|ipod|ios/.test(J)||"ios"===K),X=(J&&/chrome\/\d+/.test(J),J&&/phantomjs/.test(J),J&&J.match(/firefox\/(\d+)/)),Y={}.watch,Q=!1;if(z)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===B&&(B=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),B},ne=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(pe.prototype,de);var ve=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function he(e){return new pe(void 0,void 0,void 0,String(e))}function me(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=ye[e];R(ge,e,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var _e=Object.getOwnPropertyNames(ge),be=!0;function $e(e){be=e}var we=function(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(U?(t=ge,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ge,_e),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof we?n=e.__ob__:be&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new we(e)),t&&n&&n.vmCount++,n}function xe(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&Ce(t),o.notify())}})}}function ke(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(xe(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Ae(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}we.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)xe(e,t[n])},we.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Oe=F.optionMergeStrategies;function Se(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Se(r,i):ke(e,n,i));return e}function Te(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Se(r,i):i}:t?e?function(){return Se("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ee(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Oe.data=function(e,t,n){return n?Te(e,t,n):t&&"function"!=typeof t?e:Te(e,t)},I.forEach(function(e){Oe[e]=Ee}),M.forEach(function(e){Oe[e+"s"]=Ne}),Oe.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Oe.props=Oe.methods=Oe.inject=Oe.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Oe.provide=Te;var je=function(e,t){return void 0===t?e:t};function De(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=De(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=De(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Oe[r]||je;a[r]=i(e[r],t[r],n,r)}return a}function Le(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Me(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=be;$e(!0),Ce(a),$e(u)}return a}function Ie(e){var t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t,null,"config.errorHandler")}Ue(e,t,n)}function Ue(e,t,n){if(!z&&!V||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),G&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)He(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[he(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=he(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=he(f.text+u):""!==u&&s.push(he(u)):st(u)&&st(f)?s[l]=he(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c;if(Array.isArray(e)||"string"==typeof e)for(r=new Array(e.length),i=0,a=e.length;i<a;i++)r[i]=t(e[i],i);else if("number"==typeof e)for(r=new Array(e),i=0;i<e;i++)r[i]=t(i+1,i);else if(o(e))if(oe&&e[Symbol.iterator]){r=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)r.push(t(l.value,r.length)),l=u.next()}else for(s=Object.keys(e),r=new Array(s.length),i=0,a=s.length;i<a;i++)c=s[i],r[i]=t(e[c],c,i);return n(r)||(r=[]),r._isVList=!0,r}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return Le(this.$options,"filters",e)||E}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=N,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=he,e._e=ve,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Et(e,t,n,r,i){var o=me(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Nt(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){$e(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Me(d,v,n,t)}$e(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=ve();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Me(l,u,r||e);else n(i.attrs)&&Nt(c,i.attrs),n(i.props)&&Nt(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Et(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Et(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return ve();n(a)&&n(a.is)&&(i=a.is);if(!i)return ve();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=Le(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):ve()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(z&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};fn.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},fn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},fn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},fn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},fn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},fn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},fn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},fn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var o=function(o){i.push(o);var a=Me(o,t,n,e);xe(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);$e(!0)}(e,t.props),t.methods&&function(e,t){e.$options.props;for(var n in t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props,i=(e.$options.methods,n.length);for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=De(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=De(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=De($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;xe(t,"$attrs",o&&o.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach(function(n){xe(e,n,t[n])}),$e(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Ae,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate)try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=ve()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:De,defineReactive:xe},e.set=ke,e.delete=Ae,e.nextTick=Ye,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=De(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var En=p("style,class"),Nn=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&Nn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=Le(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a);for(o in(q||Z)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n){e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(q&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Er(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Nr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=q?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=z&&!W,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ei(e){Ti(function(){Ti(e)})}function Ni(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,E=O&&v?v:l,N=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!W,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,E),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),N&&N(i),F&&(Ni(i,S),Ni(i,T),Ei(function(){ji(i,S),R.cancelled||(Ni(i,E),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ni(i,u),Ni(i,p),Ei(function(){ji(i,u),w.cancelled||(Ni(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=me(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=me(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,z?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});W&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),W&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!N(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t,n),(q||Z)&&setTimeout(function(){Ji(e,t,n)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(N(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!N(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=e(t,null,u),this.removed=l}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ni(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=En,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!z)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=z?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&z?Yn(e):void 0,t)},z&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo,go={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},_o=function(e){return(yo=yo||document.createElement("div")).innerHTML=e,yo.textContent},bo=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),$o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),wo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Co=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ko="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ao="((?:"+ko+"\\:)?"+ko+")",Oo=new RegExp("^<"+Ao),So=/^\s*(\/?)>/,To=new RegExp("^<\\/"+Ao+"[^>]*>"),Eo=/^<!DOCTYPE [^>]+>/i,No=/^<!\--/,jo=/^<!\[/,Do=p("script,style,textarea",!0),Lo={},Mo={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Io=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Po=p("pre,textarea",!0),Ro=function(e,t){return e&&Po(e)&&"\n"===t[0]};function Ho(e,t){var n=t?Fo:Io;return e.replace(n,function(e){return Mo[e]})}var Bo,Uo,zo,Vo,Ko,Jo,qo,Wo,Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/\s+/g,sa=g(_o),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Bo=t.warn||Sr,Jo=t.isPreTag||T,qo=t.mustUseProp||T,Wo=t.getTagNamespace||T;t.isReservedTag;zo=Tr(t.modules,"transformNode"),Vo=Tr(t.modules,"preTransformNode"),Ko=Tr(t.modules,"postTransformNode"),Uo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Jo(e.tag)&&(c=!1);for(var f=0;f<Ko.length;f++)Ko[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&Do(r)){var u=0,l=r.toLowerCase(),f=Lo[l]||(Lo[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,function(e,n,r){return u=r.length,Do(l)||"noscript"===l||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ro(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(No.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(jo.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(Eo);if(m){C(m[0].length);continue}var y=e.match(To);if(y){var g=c;C(y[0].length),A(y[1],g,c);continue}var _=x();if(_){k(_),Ro(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(To.test($)||Oo.test($)||No.test($)||jo.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Oo);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(So))&&(r=e.match(xo)||e.match(Co));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&wo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Ho(v,h)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,u,e.start,e.end)}function A(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Bo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||Wo(e);q&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<Vo.length;h++)v=Vo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Jo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u,l,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):f.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(aa," ")),!s&&" "!==e&&(u=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Uo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Nr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var s=Pr(e,ia);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=va(s),l=u.name,f=u.dynamic,p=c[l]=ua("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=p,!0}),p.slotScope=s.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<zo.length;i++)e=zo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&qo(e.tag,e.attrsMap.type,r)?Er(e,r,o,u[t],c):Nr(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Nr(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&qo(e.tag,e.attrsMap.type,r)&&Er(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,go,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Ir(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+n+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",n),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Er(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Er(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:bo,mustUseProp:jn,canBeLeftOpenTag:$o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++){var s=t.ifConditions[o].block;e(s),s.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++)e(t.ifConditions[o].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ea={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Na=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Na("$event.target !== $event.currentTarget"),ctrl:Na("!$event.ctrlKey"),shift:Na("!$event.shiftKey"),alt:Na("!$event.altKey"),meta:Na("!$event.metaKey"),left:Na("'button' in $event && $event.button !== 0"),middle:Na("'button' in $event && $event.button !== 1"),right:Na("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(ja[s])o+=ja[s],Ta[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=Na(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+"($event)":n?"return ("+e.value+")($event)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Ea[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn;delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca),rs=(ns.compile,ns.compileToFunctions);function is(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var os=!!z&&is(!1),as=!!z&&is(!0),ss=g(function(e){var t=Yn(e);return t&&t.innerHTML}),cs=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ss(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=rs(r,{outputSourceRange:!1,shouldDecodeNewlines:os,shouldDecodeNewlinesForHref:as,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return cs.call(this,e,t)},wn.compile=rs,module.exports=wn;
\ No newline at end of file
+"use strict";var e=Object.freeze({});function r(e){return null==e}function t(e){return null!=e}function n(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var i=Object.prototype.toString;function s(e){return"[object Object]"===i.call(e)}function c(e){var r=parseFloat(String(e));return r>=0&&Math.floor(r)===r&&isFinite(e)}function u(e){return t(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===i?JSON.stringify(e,null,2):String(e)}function p(e){var r=parseFloat(e);return isNaN(r)?e:r}function f(e,r){for(var t=Object.create(null),n=e.split(","),a=0;a<n.length;a++)t[n[a]]=!0;return r?function(e){return t[e.toLowerCase()]}:function(e){return t[e]}}var d=f("slot,component",!0),m=f("key,ref,slot,slot-scope,is");function h(e,r){if(e.length){var t=e.indexOf(r);if(t>-1)return e.splice(t,1)}}var v=Object.prototype.hasOwnProperty;function g(e,r){return v.call(e,r)}function b(e){var r=Object.create(null);return function(t){return r[t]||(r[t]=e(t))}}var y=/-(\w)/g,w=b(function(e){return e.replace(y,function(e,r){return r?r.toUpperCase():""})}),A=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),D=/\B([A-Z])/g,x=b(function(e){return e.replace(D,"-$1").toLowerCase()});var q=Function.prototype.bind?function(e,r){return e.bind(r)}:function(e,r){function t(t){var n=arguments.length;return n?n>1?e.apply(r,arguments):e.call(r,t):e.call(r)}return t._length=e.length,t};function k(e,r){r=r||0;for(var t=e.length-r,n=new Array(t);t--;)n[t]=e[t+r];return n}function E(e,r){for(var t in r)e[t]=r[t];return e}function _(e){for(var r={},t=0;t<e.length;t++)e[t]&&E(r,e[t]);return r}function C(e,r,t){}var S=function(e,r,t){return!1},L=function(e){return e};function T(e,r){if(e===r)return!0;var t=o(e),n=o(r);if(!t||!n)return!t&&!n&&String(e)===String(r);try{var a=Array.isArray(e),i=Array.isArray(r);if(a&&i)return e.length===r.length&&e.every(function(e,t){return T(e,r[t])});if(e instanceof Date&&r instanceof Date)return e.getTime()===r.getTime();if(a||i)return!1;var s=Object.keys(e),c=Object.keys(r);return s.length===c.length&&s.every(function(t){return T(e[t],r[t])})}catch(e){return!1}}function $(e,r){for(var t=0;t<e.length;t++)if(T(e[t],r))return t;return-1}function N(e){var r=!1;return function(){r||(r=!0,e.apply(this,arguments))}}var O="data-server-rendered",R=["component","directive","filter"],F=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],B={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:C,parsePlatformTagName:L,mustUseProp:S,async:!0,_lifecycleHooks:F},U=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function V(e,r,t,n){Object.defineProperty(e,r,{value:t,enumerable:!!n,writable:!0,configurable:!0})}var I=new RegExp("[^"+U.source+".$_\\d]");var j,P="__proto__"in{},H="undefined"!=typeof window,M="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,G=M&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),J=z&&/msie|trident/.test(z),K=z&&z.indexOf("msie 9.0")>0,Z=z&&z.indexOf("edge/")>0,Y=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===G),W=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Q={}.watch,X=!1;if(H)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){X=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var re=function(){return void 0===j&&(j=!H&&!M&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),j},te=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ne(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,oe="undefined"!=typeof Symbol&&ne(Symbol)&&"undefined"!=typeof Reflect&&ne(Reflect.ownKeys);ae="undefined"!=typeof Set&&ne(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ie=C,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),r=0,t=e.length;r<t;r++)e[r].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function pe(){ue.pop(),ce.target=ue[ue.length-1]}var fe=function(e,r,t,n,a,o,i,s){this.tag=e,this.data=r,this.children=t,this.text=n,this.elm=a,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=r&&r.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(fe.prototype,de);var me=function(e){void 0===e&&(e="");var r=new fe;return r.text=e,r.isComment=!0,r};function he(e){return new fe(void 0,void 0,void 0,String(e))}function ve(e){var r=new fe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return r.ns=e.ns,r.isStatic=e.isStatic,r.key=e.key,r.isComment=e.isComment,r.fnContext=e.fnContext,r.fnOptions=e.fnOptions,r.fnScopeId=e.fnScopeId,r.asyncMeta=e.asyncMeta,r.isCloned=!0,r}var ge=Array.prototype,be=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var r=ge[e];V(be,e,function(){for(var t=[],n=arguments.length;n--;)t[n]=arguments[n];var a,o=r.apply(this,t),i=this.__ob__;switch(e){case"push":case"unshift":a=t;break;case"splice":a=t.slice(2)}return a&&i.observeArray(a),i.dep.notify(),o})});var ye=Object.getOwnPropertyNames(be),we=!0;function Ae(e){we=e}var De=function(e){var r;this.value=e,this.dep=new ce,this.vmCount=0,V(e,"__ob__",this),Array.isArray(e)?(P?(r=be,e.__proto__=r):function(e,r,t){for(var n=0,a=t.length;n<a;n++){var o=t[n];V(e,o,r[o])}}(e,be,ye),this.observeArray(e)):this.walk(e)};function xe(e,r){var t;if(o(e)&&!(e instanceof fe))return g(e,"__ob__")&&e.__ob__ instanceof De?t=e.__ob__:we&&!re()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(t=new De(e)),r&&t&&t.vmCount++,t}function qe(e,r,t,n,a){var o=new ce,i=Object.getOwnPropertyDescriptor(e,r);if(!i||!1!==i.configurable){var s=i&&i.get,c=i&&i.set;s&&!c||2!==arguments.length||(t=e[r]);var u=!a&&xe(t);Object.defineProperty(e,r,{enumerable:!0,configurable:!0,get:function(){var r=s?s.call(e):t;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(r)&&function e(r){for(var t=void 0,n=0,a=r.length;n<a;n++)(t=r[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&e(t)}(r))),r},set:function(r){var n=s?s.call(e):t;r===n||r!=r&&n!=n||s&&!c||(c?c.call(e,r):t=r,u=!a&&xe(r),o.notify())}})}}function ke(e,r,t){if(Array.isArray(e)&&c(r))return e.length=Math.max(e.length,r),e.splice(r,1,t),t;if(r in e&&!(r in Object.prototype))return e[r]=t,t;var n=e.__ob__;return e._isVue||n&&n.vmCount?t:n?(qe(n.value,r,t),n.dep.notify(),t):(e[r]=t,t)}function Ee(e,r){if(Array.isArray(e)&&c(r))e.splice(r,1);else{var t=e.__ob__;e._isVue||t&&t.vmCount||g(e,r)&&(delete e[r],t&&t.dep.notify())}}De.prototype.walk=function(e){for(var r=Object.keys(e),t=0;t<r.length;t++)qe(e,r[t])},De.prototype.observeArray=function(e){for(var r=0,t=e.length;r<t;r++)xe(e[r])};var _e=B.optionMergeStrategies;function Ce(e,r){if(!r)return e;for(var t,n,a,o=oe?Reflect.ownKeys(r):Object.keys(r),i=0;i<o.length;i++)"__ob__"!==(t=o[i])&&(n=e[t],a=r[t],g(e,t)?n!==a&&s(n)&&s(a)&&Ce(n,a):ke(e,t,a));return e}function Se(e,r,t){return t?function(){var n="function"==typeof r?r.call(t,t):r,a="function"==typeof e?e.call(t,t):e;return n?Ce(n,a):a}:r?e?function(){return Ce("function"==typeof r?r.call(this,this):r,"function"==typeof e?e.call(this,this):e)}:r:e}function Le(e,r){var t=r?e?e.concat(r):Array.isArray(r)?r:[r]:e;return t?function(e){for(var r=[],t=0;t<e.length;t++)-1===r.indexOf(e[t])&&r.push(e[t]);return r}(t):t}function Te(e,r,t,n){var a=Object.create(e||null);return r?E(a,r):a}_e.data=function(e,r,t){return t?Se(e,r,t):r&&"function"!=typeof r?e:Se(e,r)},F.forEach(function(e){_e[e]=Le}),R.forEach(function(e){_e[e+"s"]=Te}),_e.watch=function(e,r,t,n){if(e===Q&&(e=void 0),r===Q&&(r=void 0),!r)return Object.create(e||null);if(!e)return r;var a={};for(var o in E(a,e),r){var i=a[o],s=r[o];i&&!Array.isArray(i)&&(i=[i]),a[o]=i?i.concat(s):Array.isArray(s)?s:[s]}return a},_e.props=_e.methods=_e.inject=_e.computed=function(e,r,t,n){if(!e)return r;var a=Object.create(null);return E(a,e),r&&E(a,r),a},_e.provide=Se;var $e=function(e,r){return void 0===r?e:r};function Ne(e,r,t){if("function"==typeof r&&(r=r.options),function(e,r){var t=e.props;if(t){var n,a,o={};if(Array.isArray(t))for(n=t.length;n--;)"string"==typeof(a=t[n])&&(o[w(a)]={type:null});else if(s(t))for(var i in t)a=t[i],o[w(i)]=s(a)?a:{type:a};e.props=o}}(r),function(e,r){var t=e.inject;if(t){var n=e.inject={};if(Array.isArray(t))for(var a=0;a<t.length;a++)n[t[a]]={from:t[a]};else if(s(t))for(var o in t){var i=t[o];n[o]=s(i)?E({from:o},i):{from:i}}}}(r),function(e){var r=e.directives;if(r)for(var t in r){var n=r[t];"function"==typeof n&&(r[t]={bind:n,update:n})}}(r),!r._base&&(r.extends&&(e=Ne(e,r.extends,t)),r.mixins))for(var n=0,a=r.mixins.length;n<a;n++)e=Ne(e,r.mixins[n],t);var o,i={};for(o in e)c(o);for(o in r)g(e,o)||c(o);function c(n){var a=_e[n]||$e;i[n]=a(e[n],r[n],t,n)}return i}function Oe(e,r,t,n){if("string"==typeof t){var a=e[r];if(g(a,t))return a[t];var o=w(t);if(g(a,o))return a[o];var i=A(o);return g(a,i)?a[i]:a[t]||a[o]||a[i]}}function Re(e,r,t,n){var a=r[e],o=!g(t,e),i=t[e],s=Ve(Boolean,a.type);if(s>-1)if(o&&!g(a,"default"))i=!1;else if(""===i||i===x(e)){var c=Ve(String,a.type);(c<0||s<c)&&(i=!0)}if(void 0===i){i=function(e,r,t){if(!g(r,"default"))return;var n=r.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[t]&&void 0!==e._props[t])return e._props[t];return"function"==typeof n&&"Function"!==Be(r.type)?n.call(e):n}(n,a,e);var u=we;Ae(!0),xe(i),Ae(u)}return i}var Fe=/^\s*function (\w+)/;function Be(e){var r=e&&e.toString().match(Fe);return r?r[1]:""}function Ue(e,r){return Be(e)===Be(r)}function Ve(e,r){if(!Array.isArray(r))return Ue(r,e)?0:-1;for(var t=0,n=r.length;t<n;t++)if(Ue(r[t],e))return t;return-1}function Ie(e,r,t){le();try{if(r)for(var n=r;n=n.$parent;){var a=n.$options.errorCaptured;if(a)for(var o=0;o<a.length;o++)try{if(!1===a[o].call(n,e,r,t))return}catch(e){Pe(e,n,"errorCaptured hook")}}Pe(e,r,t)}finally{pe()}}function je(e,r,t,n,a){var o;try{(o=t?e.apply(r,t):e.call(r))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Ie(e,n,a+" (Promise/async)")}),o._handled=!0)}catch(e){Ie(e,n,a)}return o}function Pe(e,r,t){if(B.errorHandler)try{return B.errorHandler.call(null,e,r,t)}catch(r){r!==e&&He(r,null,"config.errorHandler")}He(e,r,t)}function He(e,r,t){if(!H&&!M||"undefined"==typeof console)throw e;console.error(e)}var Me,Ge=!1,ze=[],Je=!1;function Ke(){Je=!1;var e=ze.slice(0);ze.length=0;for(var r=0;r<e.length;r++)e[r]()}if("undefined"!=typeof Promise&&ne(Promise)){var Ze=Promise.resolve();Me=function(){Ze.then(Ke),Y&&setTimeout(C)},Ge=!0}else if(J||"undefined"==typeof MutationObserver||!ne(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Me="undefined"!=typeof setImmediate&&ne(setImmediate)?function(){setImmediate(Ke)}:function(){setTimeout(Ke,0)};else{var Ye=1,We=new MutationObserver(Ke),Qe=document.createTextNode(String(Ye));We.observe(Qe,{characterData:!0}),Me=function(){Ye=(Ye+1)%2,Qe.data=String(Ye)},Ge=!0}function Xe(e,r){var t;if(ze.push(function(){if(e)try{e.call(r)}catch(e){Ie(e,r,"nextTick")}else t&&t(r)}),Je||(Je=!0,Me()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){t=e})}var er=new ae;function rr(e){!function e(r,t){var n,a;var i=Array.isArray(r);if(!i&&!o(r)||Object.isFrozen(r)||r instanceof fe)return;if(r.__ob__){var s=r.__ob__.dep.id;if(t.has(s))return;t.add(s)}if(i)for(n=r.length;n--;)e(r[n],t);else for(a=Object.keys(r),n=a.length;n--;)e(r[a[n]],t)}(e,er),er.clear()}var tr=b(function(e){var r="&"===e.charAt(0),t="~"===(e=r?e.slice(1):e).charAt(0),n="!"===(e=t?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:t,capture:n,passive:r}});function nr(e,r){function t(){var e=arguments,n=t.fns;if(!Array.isArray(n))return je(n,null,arguments,r,"v-on handler");for(var a=n.slice(),o=0;o<a.length;o++)je(a[o],null,e,r,"v-on handler")}return t.fns=e,t}function ar(e,t,a,o,i,s){var c,u,l,p;for(c in e)u=e[c],l=t[c],p=tr(c),r(u)||(r(l)?(r(u.fns)&&(u=e[c]=nr(u,s)),n(p.once)&&(u=e[c]=i(p.name,u,p.capture)),a(p.name,u,p.capture,p.passive,p.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)r(e[c])&&o((p=tr(c)).name,t[c],p.capture)}function or(e,a,o){var i;e instanceof fe&&(e=e.data.hook||(e.data.hook={}));var s=e[a];function c(){o.apply(this,arguments),h(i.fns,c)}r(s)?i=nr([c]):t(s.fns)&&n(s.merged)?(i=s).fns.push(c):i=nr([s,c]),i.merged=!0,e[a]=i}function ir(e,r,n,a,o){if(t(r)){if(g(r,n))return e[n]=r[n],o||delete r[n],!0;if(g(r,a))return e[n]=r[a],o||delete r[a],!0}return!1}function sr(e){return a(e)?[he(e)]:Array.isArray(e)?function e(o,i){var s=[];var c,u,l,p;for(c=0;c<o.length;c++)r(u=o[c])||"boolean"==typeof u||(l=s.length-1,p=s[l],Array.isArray(u)?u.length>0&&(cr((u=e(u,(i||"")+"_"+c))[0])&&cr(p)&&(s[l]=he(p.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?cr(p)?s[l]=he(p.text+u):""!==u&&s.push(he(u)):cr(u)&&cr(p)?s[l]=he(p.text+u.text):(n(o._isVList)&&t(u.tag)&&r(u.key)&&t(i)&&(u.key="__vlist"+i+"_"+c+"__"),s.push(u)));return s}(e):void 0}function cr(e){return t(e)&&t(e.text)&&!1===e.isComment}function ur(e,r){if(e){for(var t=Object.create(null),n=oe?Reflect.ownKeys(e):Object.keys(e),a=0;a<n.length;a++){var o=n[a];if("__ob__"!==o){for(var i=e[o].from,s=r;s;){if(s._provided&&g(s._provided,i)){t[o]=s._provided[i];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;t[o]="function"==typeof c?c.call(r):c}}}return t}}function lr(e,r){if(!e||!e.length)return{};for(var t={},n=0,a=e.length;n<a;n++){var o=e[n],i=o.data;if(i&&i.attrs&&i.attrs.slot&&delete i.attrs.slot,o.context!==r&&o.fnContext!==r||!i||null==i.slot)(t.default||(t.default=[])).push(o);else{var s=i.slot,c=t[s]||(t[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in t)t[u].every(pr)&&delete t[u];return t}function pr(e){return e.isComment&&!e.asyncFactory||" "===e.text}function fr(r,t,n){var a,o=Object.keys(t).length>0,i=r?!!r.$stable:!o,s=r&&r.$key;if(r){if(r._normalized)return r._normalized;if(i&&n&&n!==e&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in a={},r)r[c]&&"$"!==c[0]&&(a[c]=dr(t,c,r[c]))}else a={};for(var u in t)u in a||(a[u]=mr(t,u));return r&&Object.isExtensible(r)&&(r._normalized=a),V(a,"$stable",i),V(a,"$key",s),V(a,"$hasNormal",o),a}function dr(e,r,t){var n=function(){var e=arguments.length?t.apply(null,arguments):t({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:sr(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return t.proxy&&Object.defineProperty(e,r,{get:n,enumerable:!0,configurable:!0}),n}function mr(e,r){return function(){return e[r]}}function hr(e,r){var n,a,i,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,a=e.length;n<a;n++)c[n]=r(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=r(n+1,n);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(r(l.value,c.length)),l=u.next()}else for(i=Object.keys(e),c=new Array(i.length),n=0,a=i.length;n<a;n++)s=i[n],c[n]=r(e[s],s,n);return t(c)||(c=[]),c._isVList=!0,c}function vr(e,r,t,n){var a,o=this.$scopedSlots[e];o?(t=t||{},n&&(t=E(E({},n),t)),a=o(t)||r):a=this.$slots[e]||r;var i=t&&t.slot;return i?this.$createElement("template",{slot:i},a):a}function gr(e){return Oe(this.$options,"filters",e)||L}function br(e,r){return Array.isArray(e)?-1===e.indexOf(r):e!==r}function yr(e,r,t,n,a){var o=B.keyCodes[r]||t;return a&&n&&!B.keyCodes[r]?br(a,n):o?br(o,e):n?x(n)!==r:void 0}function wr(e,r,t,n,a){if(t)if(o(t)){var i;Array.isArray(t)&&(t=_(t));var s=function(o){if("class"===o||"style"===o||m(o))i=e;else{var s=e.attrs&&e.attrs.type;i=n||B.mustUseProp(r,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(o),u=x(o);c in i||u in i||(i[o]=t[o],a&&((e.on||(e.on={}))["update:"+o]=function(e){t[o]=e}))};for(var c in t)s(c)}else;return e}function Ar(e,r){var t=this._staticTrees||(this._staticTrees=[]),n=t[e];return n&&!r?n:(xr(n=t[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function Dr(e,r,t){return xr(e,"__once__"+r+(t?"_"+t:""),!0),e}function xr(e,r,t){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&qr(e[n],r+"_"+n,t);else qr(e,r,t)}function qr(e,r,t){e.isStatic=!0,e.key=r,e.isOnce=t}function kr(e,r){if(r)if(s(r)){var t=e.on=e.on?E({},e.on):{};for(var n in r){var a=t[n],o=r[n];t[n]=a?[].concat(a,o):o}}else;return e}function Er(e,r,t,n){r=r||{$stable:!t};for(var a=0;a<e.length;a++){var o=e[a];Array.isArray(o)?Er(o,r,t):o&&(o.proxy&&(o.fn.proxy=!0),r[o.key]=o.fn)}return n&&(r.$key=n),r}function _r(e,r){for(var t=0;t<r.length;t+=2){var n=r[t];"string"==typeof n&&n&&(e[r[t]]=r[t+1])}return e}function Cr(e,r){return"string"==typeof e?r+e:e}function Sr(e){e._o=Dr,e._n=p,e._s=l,e._l=hr,e._t=vr,e._q=T,e._i=$,e._m=Ar,e._f=gr,e._k=yr,e._b=wr,e._v=he,e._e=me,e._u=Er,e._g=kr,e._d=_r,e._p=Cr}function Lr(r,t,a,o,i){var s,c=this,u=i.options;g(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=n(u._compiled),p=!l;this.data=r,this.props=t,this.children=a,this.parent=o,this.listeners=r.on||e,this.injections=ur(u.inject,o),this.slots=function(){return c.$slots||fr(r.scopedSlots,c.$slots=lr(a,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return fr(r.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=fr(r.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,r,t,n){var a=Vr(s,e,r,t,n,p);return a&&!Array.isArray(a)&&(a.fnScopeId=u._scopeId,a.fnContext=o),a}:this._c=function(e,r,t,n){return Vr(s,e,r,t,n,p)}}function Tr(e,r,t,n,a){var o=ve(e);return o.fnContext=t,o.fnOptions=n,r.slot&&((o.data||(o.data={})).slot=r.slot),o}function $r(e,r){for(var t in r)e[w(t)]=r[t]}Sr(Lr.prototype);var Nr={init:function(e,r){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var n=e;Nr.prepatch(n,n)}else{(e.componentInstance=function(e,r){var n={_isComponent:!0,_parentVnode:e,parent:r},a=e.data.inlineTemplate;t(a)&&(n.render=a.render,n.staticRenderFns=a.staticRenderFns);return new e.componentOptions.Ctor(n)}(e,Zr)).$mount(r?e.elm:void 0,r)}},prepatch:function(r,t){var n=t.componentOptions;!function(r,t,n,a,o){var i=a.data.scopedSlots,s=r.$scopedSlots,c=!!(i&&!i.$stable||s!==e&&!s.$stable||i&&r.$scopedSlots.$key!==i.$key),u=!!(o||r.$options._renderChildren||c);r.$options._parentVnode=a,r.$vnode=a,r._vnode&&(r._vnode.parent=a);if(r.$options._renderChildren=o,r.$attrs=a.data.attrs||e,r.$listeners=n||e,t&&r.$options.props){Ae(!1);for(var l=r._props,p=r.$options._propKeys||[],f=0;f<p.length;f++){var d=p[f],m=r.$options.props;l[d]=Re(d,m,t,r)}Ae(!0),r.$options.propsData=t}n=n||e;var h=r.$options._parentListeners;r.$options._parentListeners=n,Kr(r,n,h),u&&(r.$slots=lr(o,a.context),r.$forceUpdate())}(t.componentInstance=r.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var r,t=e.context,n=e.componentInstance;n._isMounted||(n._isMounted=!0,Xr(n,"mounted")),e.data.keepAlive&&(t._isMounted?((r=n)._inactive=!1,rt.push(r)):Qr(n,!0))},destroy:function(e){var r=e.componentInstance;r._isDestroyed||(e.data.keepAlive?function e(r,t){if(t&&(r._directInactive=!0,Wr(r)))return;if(!r._inactive){r._inactive=!0;for(var n=0;n<r.$children.length;n++)e(r.$children[n]);Xr(r,"deactivated")}}(r,!0):r.$destroy())}},Or=Object.keys(Nr);function Rr(a,i,s,c,l){if(!r(a)){var p=s.$options._base;if(o(a)&&(a=p.extend(a)),"function"==typeof a){var f;if(r(a.cid)&&void 0===(a=function(e,a){if(n(e.error)&&t(e.errorComp))return e.errorComp;if(t(e.resolved))return e.resolved;var i=jr;i&&t(e.owners)&&-1===e.owners.indexOf(i)&&e.owners.push(i);if(n(e.loading)&&t(e.loadingComp))return e.loadingComp;if(i&&!t(e.owners)){var s=e.owners=[i],c=!0,l=null,p=null;i.$on("hook:destroyed",function(){return h(s,i)});var f=function(e){for(var r=0,t=s.length;r<t;r++)s[r].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==p&&(clearTimeout(p),p=null))},d=N(function(r){e.resolved=Pr(r,a),c?s.length=0:f(!0)}),m=N(function(r){t(e.errorComp)&&(e.error=!0,f(!0))}),v=e(d,m);return o(v)&&(u(v)?r(e.resolved)&&v.then(d,m):u(v.component)&&(v.component.then(d,m),t(v.error)&&(e.errorComp=Pr(v.error,a)),t(v.loading)&&(e.loadingComp=Pr(v.loading,a),0===v.delay?e.loading=!0:l=setTimeout(function(){l=null,r(e.resolved)&&r(e.error)&&(e.loading=!0,f(!1))},v.delay||200)),t(v.timeout)&&(p=setTimeout(function(){p=null,r(e.resolved)&&m(null)},v.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(f=a,p)))return function(e,r,t,n,a){var o=me();return o.asyncFactory=e,o.asyncMeta={data:r,context:t,children:n,tag:a},o}(f,i,s,c,l);i=i||{},At(a),t(i.model)&&function(e,r){var n=e.model&&e.model.prop||"value",a=e.model&&e.model.event||"input";(r.attrs||(r.attrs={}))[n]=r.model.value;var o=r.on||(r.on={}),i=o[a],s=r.model.callback;t(i)?(Array.isArray(i)?-1===i.indexOf(s):i!==s)&&(o[a]=[s].concat(i)):o[a]=s}(a.options,i);var d=function(e,n,a){var o=n.options.props;if(!r(o)){var i={},s=e.attrs,c=e.props;if(t(s)||t(c))for(var u in o){var l=x(u);ir(i,c,u,l,!0)||ir(i,s,u,l,!1)}return i}}(i,a);if(n(a.options.functional))return function(r,n,a,o,i){var s=r.options,c={},u=s.props;if(t(u))for(var l in u)c[l]=Re(l,u,n||e);else t(a.attrs)&&$r(c,a.attrs),t(a.props)&&$r(c,a.props);var p=new Lr(a,c,i,o,r),f=s.render.call(null,p._c,p);if(f instanceof fe)return Tr(f,a,p.parent,s);if(Array.isArray(f)){for(var d=sr(f)||[],m=new Array(d.length),h=0;h<d.length;h++)m[h]=Tr(d[h],a,p.parent,s);return m}}(a,d,i,s,c);var m=i.on;if(i.on=i.nativeOn,n(a.options.abstract)){var v=i.slot;i={},v&&(i.slot=v)}!function(e){for(var r=e.hook||(e.hook={}),t=0;t<Or.length;t++){var n=Or[t],a=r[n],o=Nr[n];a===o||a&&a._merged||(r[n]=a?Fr(o,a):o)}}(i);var g=a.options.name||l;return new fe("vue-component-"+a.cid+(g?"-"+g:""),i,void 0,void 0,void 0,s,{Ctor:a,propsData:d,listeners:m,tag:l,children:c},f)}}}function Fr(e,r){var t=function(t,n){e(t,n),r(t,n)};return t._merged=!0,t}var Br=1,Ur=2;function Vr(e,i,s,c,u,l){return(Array.isArray(s)||a(s))&&(u=c,c=s,s=void 0),n(l)&&(u=Ur),function(e,a,i,s,c){if(t(i)&&t(i.__ob__))return me();t(i)&&t(i.is)&&(a=i.is);if(!a)return me();Array.isArray(s)&&"function"==typeof s[0]&&((i=i||{}).scopedSlots={default:s[0]},s.length=0);c===Ur?s=sr(s):c===Br&&(s=function(e){for(var r=0;r<e.length;r++)if(Array.isArray(e[r]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof a){var p;l=e.$vnode&&e.$vnode.ns||B.getTagNamespace(a),u=B.isReservedTag(a)?new fe(B.parsePlatformTagName(a),i,s,void 0,void 0,e):i&&i.pre||!t(p=Oe(e.$options,"components",a))?new fe(a,i,s,void 0,void 0,e):Rr(p,i,e,s,a)}else u=Rr(a,i,e,s);return Array.isArray(u)?u:t(u)?(t(l)&&function e(a,o,i){a.ns=o;"foreignObject"===a.tag&&(o=void 0,i=!0);if(t(a.children))for(var s=0,c=a.children.length;s<c;s++){var u=a.children[s];t(u.tag)&&(r(u.ns)||n(i)&&"svg"!==u.tag)&&e(u,o,i)}}(u,l),t(i)&&function(e){o(e.style)&&rr(e.style);o(e.class)&&rr(e.class)}(i),u):me()}(e,i,s,c,u)}var Ir,jr=null;function Pr(e,r){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?r.extend(e):e}function Hr(e){return e.isComment&&e.asyncFactory}function Mr(e){if(Array.isArray(e))for(var r=0;r<e.length;r++){var n=e[r];if(t(n)&&(t(n.componentOptions)||Hr(n)))return n}}function Gr(e,r){Ir.$on(e,r)}function zr(e,r){Ir.$off(e,r)}function Jr(e,r){var t=Ir;return function n(){null!==r.apply(null,arguments)&&t.$off(e,n)}}function Kr(e,r,t){Ir=e,ar(r,t||{},Gr,zr,Jr,e),Ir=void 0}var Zr=null;function Yr(e){var r=Zr;return Zr=e,function(){Zr=r}}function Wr(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Qr(e,r){if(r){if(e._directInactive=!1,Wr(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var t=0;t<e.$children.length;t++)Qr(e.$children[t]);Xr(e,"activated")}}function Xr(e,r){le();var t=e.$options[r],n=r+" hook";if(t)for(var a=0,o=t.length;a<o;a++)je(t[a],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+r),pe()}var et=[],rt=[],tt={},nt=!1,at=!1,ot=0;var it=0,st=Date.now;if(H&&!J){var ct=window.performance;ct&&"function"==typeof ct.now&&st()>document.createEvent("Event").timeStamp&&(st=function(){return ct.now()})}function ut(){var e,r;for(it=st(),at=!0,et.sort(function(e,r){return e.id-r.id}),ot=0;ot<et.length;ot++)(e=et[ot]).before&&e.before(),r=e.id,tt[r]=null,e.run();var t=rt.slice(),n=et.slice();ot=et.length=rt.length=0,tt={},nt=at=!1,function(e){for(var r=0;r<e.length;r++)e[r]._inactive=!0,Qr(e[r],!0)}(t),function(e){var r=e.length;for(;r--;){var t=e[r],n=t.vm;n._watcher===t&&n._isMounted&&!n._isDestroyed&&Xr(n,"updated")}}(n),te&&B.devtools&&te.emit("flush")}var lt=0,pt=function(e,r,t,n,a){this.vm=e,a&&(e._watcher=this),e._watchers.push(this),n?(this.deep=!!n.deep,this.user=!!n.user,this.lazy=!!n.lazy,this.sync=!!n.sync,this.before=n.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=t,this.id=++lt,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ae,this.newDepIds=new ae,this.expression="","function"==typeof r?this.getter=r:(this.getter=function(e){if(!I.test(e)){var r=e.split(".");return function(e){for(var t=0;t<r.length;t++){if(!e)return;e=e[r[t]]}return e}}}(r),this.getter||(this.getter=C)),this.value=this.lazy?void 0:this.get()};pt.prototype.get=function(){var e;le(this);var r=this.vm;try{e=this.getter.call(r,r)}catch(e){if(!this.user)throw e;Ie(e,r,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rr(e),pe(),this.cleanupDeps()}return e},pt.prototype.addDep=function(e){var r=e.id;this.newDepIds.has(r)||(this.newDepIds.add(r),this.newDeps.push(e),this.depIds.has(r)||e.addSub(this))},pt.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var r=this.deps[e];this.newDepIds.has(r.id)||r.removeSub(this)}var t=this.depIds;this.depIds=this.newDepIds,this.newDepIds=t,this.newDepIds.clear(),t=this.deps,this.deps=this.newDeps,this.newDeps=t,this.newDeps.length=0},pt.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var r=e.id;if(null==tt[r]){if(tt[r]=!0,at){for(var t=et.length-1;t>ot&&et[t].id>e.id;)t--;et.splice(t+1,0,e)}else et.push(e);nt||(nt=!0,Xe(ut))}}(this)},pt.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var r=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,r)}catch(e){Ie(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,r)}}},pt.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},pt.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},pt.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var ft={enumerable:!0,configurable:!0,get:C,set:C};function dt(e,r,t){ft.get=function(){return this[r][t]},ft.set=function(e){this[r][t]=e},Object.defineProperty(e,t,ft)}function mt(e){e._watchers=[];var r=e.$options;r.props&&function(e,r){var t=e.$options.propsData||{},n=e._props={},a=e.$options._propKeys=[];e.$parent&&Ae(!1);var o=function(o){a.push(o);var i=Re(o,r,t,e);qe(n,o,i),o in e||dt(e,"_props",o)};for(var i in r)o(i);Ae(!0)}(e,r.props),r.methods&&function(e,r){e.$options.props;for(var t in r)e[t]="function"!=typeof r[t]?C:q(r[t],e)}(e,r.methods),r.data?function(e){var r=e.$options.data;s(r=e._data="function"==typeof r?function(e,r){le();try{return e.call(r,r)}catch(e){return Ie(e,r,"data()"),{}}finally{pe()}}(r,e):r||{})||(r={});var t=Object.keys(r),n=e.$options.props,a=(e.$options.methods,t.length);for(;a--;){var o=t[a];n&&g(n,o)||(i=void 0,36!==(i=(o+"").charCodeAt(0))&&95!==i&&dt(e,"_data",o))}var i;xe(r,!0)}(e):xe(e._data={},!0),r.computed&&function(e,r){var t=e._computedWatchers=Object.create(null),n=re();for(var a in r){var o=r[a],i="function"==typeof o?o:o.get;n||(t[a]=new pt(e,i||C,C,ht)),a in e||vt(e,a,o)}}(e,r.computed),r.watch&&r.watch!==Q&&function(e,r){for(var t in r){var n=r[t];if(Array.isArray(n))for(var a=0;a<n.length;a++)yt(e,t,n[a]);else yt(e,t,n)}}(e,r.watch)}var ht={lazy:!0};function vt(e,r,t){var n=!re();"function"==typeof t?(ft.get=n?gt(r):bt(t),ft.set=C):(ft.get=t.get?n&&!1!==t.cache?gt(r):bt(t.get):C,ft.set=t.set||C),Object.defineProperty(e,r,ft)}function gt(e){return function(){var r=this._computedWatchers&&this._computedWatchers[e];if(r)return r.dirty&&r.evaluate(),ce.target&&r.depend(),r.value}}function bt(e){return function(){return e.call(this,this)}}function yt(e,r,t,n){return s(t)&&(n=t,t=t.handler),"string"==typeof t&&(t=e[t]),e.$watch(r,t,n)}var wt=0;function At(e){var r=e.options;if(e.super){var t=At(e.super);if(t!==e.superOptions){e.superOptions=t;var n=function(e){var r,t=e.options,n=e.sealedOptions;for(var a in t)t[a]!==n[a]&&(r||(r={}),r[a]=t[a]);return r}(e);n&&E(e.extendOptions,n),(r=e.options=Ne(t,e.extendOptions)).name&&(r.components[r.name]=e)}}return r}function Dt(e){this._init(e)}function xt(e){e.cid=0;var r=1;e.extend=function(e){e=e||{};var t=this,n=t.cid,a=e._Ctor||(e._Ctor={});if(a[n])return a[n];var o=e.name||t.options.name,i=function(e){this._init(e)};return(i.prototype=Object.create(t.prototype)).constructor=i,i.cid=r++,i.options=Ne(t.options,e),i.super=t,i.options.props&&function(e){var r=e.options.props;for(var t in r)dt(e.prototype,"_props",t)}(i),i.options.computed&&function(e){var r=e.options.computed;for(var t in r)vt(e.prototype,t,r[t])}(i),i.extend=t.extend,i.mixin=t.mixin,i.use=t.use,R.forEach(function(e){i[e]=t[e]}),o&&(i.options.components[o]=i),i.superOptions=t.options,i.extendOptions=e,i.sealedOptions=E({},i.options),a[n]=i,i}}function qt(e){return e&&(e.Ctor.options.name||e.tag)}function kt(e,r){return Array.isArray(e)?e.indexOf(r)>-1:"string"==typeof e?e.split(",").indexOf(r)>-1:(t=e,"[object RegExp]"===i.call(t)&&e.test(r));var t}function Et(e,r){var t=e.cache,n=e.keys,a=e._vnode;for(var o in t){var i=t[o];if(i){var s=qt(i.componentOptions);s&&!r(s)&&_t(t,o,n,a)}}}function _t(e,r,t,n){var a=e[r];!a||n&&a.tag===n.tag||a.componentInstance.$destroy(),e[r]=null,h(t,r)}!function(r){r.prototype._init=function(r){var t=this;t._uid=wt++,t._isVue=!0,r&&r._isComponent?function(e,r){var t=e.$options=Object.create(e.constructor.options),n=r._parentVnode;t.parent=r.parent,t._parentVnode=n;var a=n.componentOptions;t.propsData=a.propsData,t._parentListeners=a.listeners,t._renderChildren=a.children,t._componentTag=a.tag,r.render&&(t.render=r.render,t.staticRenderFns=r.staticRenderFns)}(t,r):t.$options=Ne(At(t.constructor),r||{},t),t._renderProxy=t,t._self=t,function(e){var r=e.$options,t=r.parent;if(t&&!r.abstract){for(;t.$options.abstract&&t.$parent;)t=t.$parent;t.$children.push(e)}e.$parent=t,e.$root=t?t.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(t),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var r=e.$options._parentListeners;r&&Kr(e,r)}(t),function(r){r._vnode=null,r._staticTrees=null;var t=r.$options,n=r.$vnode=t._parentVnode,a=n&&n.context;r.$slots=lr(t._renderChildren,a),r.$scopedSlots=e,r._c=function(e,t,n,a){return Vr(r,e,t,n,a,!1)},r.$createElement=function(e,t,n,a){return Vr(r,e,t,n,a,!0)};var o=n&&n.data;qe(r,"$attrs",o&&o.attrs||e,null,!0),qe(r,"$listeners",t._parentListeners||e,null,!0)}(t),Xr(t,"beforeCreate"),function(e){var r=ur(e.$options.inject,e);r&&(Ae(!1),Object.keys(r).forEach(function(t){qe(e,t,r[t])}),Ae(!0))}(t),mt(t),function(e){var r=e.$options.provide;r&&(e._provided="function"==typeof r?r.call(e):r)}(t),Xr(t,"created"),t.$options.el&&t.$mount(t.$options.el)}}(Dt),function(e){var r={get:function(){return this._data}},t={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",r),Object.defineProperty(e.prototype,"$props",t),e.prototype.$set=ke,e.prototype.$delete=Ee,e.prototype.$watch=function(e,r,t){if(s(r))return yt(this,e,r,t);(t=t||{}).user=!0;var n=new pt(this,e,r,t);if(t.immediate){le();try{r.call(this,n.value)}catch(e){Ie(e,this,'callback for immediate watcher "'+n.expression+'"')}pe()}return function(){n.teardown()}}}(Dt),function(e){var r=/^hook:/;e.prototype.$on=function(e,t){var n=this;if(Array.isArray(e))for(var a=0,o=e.length;a<o;a++)n.$on(e[a],t);else(n._events[e]||(n._events[e]=[])).push(t),r.test(e)&&(n._hasHookEvent=!0);return n},e.prototype.$once=function(e,r){var t=this;function n(){t.$off(e,n),r.apply(t,arguments)}return n.fn=r,t.$on(e,n),t},e.prototype.$off=function(e,r){var t=this;if(!arguments.length)return t._events=Object.create(null),t;if(Array.isArray(e)){for(var n=0,a=e.length;n<a;n++)t.$off(e[n],r);return t}var o,i=t._events[e];if(!i)return t;if(!r)return t._events[e]=null,t;for(var s=i.length;s--;)if((o=i[s])===r||o.fn===r){i.splice(s,1);break}return t},e.prototype.$emit=function(e){var r=this._events[e];if(r){r=r.length>1?k(r):r;for(var t=k(arguments,1),n='event handler for "'+e+'"',a=0,o=r.length;a<o;a++)je(r[a],this,t,this,n)}return this}}(Dt),function(e){e.prototype._update=function(e,r){var t=this,n=t.$el,a=t._vnode,o=Yr(t);t._vnode=e,t.$el=a?t.__patch__(a,e):t.__patch__(t.$el,e,r,!1),o(),n&&(n.__vue__=null),t.$el&&(t.$el.__vue__=t),t.$vnode&&t.$parent&&t.$vnode===t.$parent._vnode&&(t.$parent.$el=t.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Xr(e,"beforeDestroy"),e._isBeingDestroyed=!0;var r=e.$parent;!r||r._isBeingDestroyed||e.$options.abstract||h(r.$children,e),e._watcher&&e._watcher.teardown();for(var t=e._watchers.length;t--;)e._watchers[t].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Xr(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(Dt),function(e){Sr(e.prototype),e.prototype.$nextTick=function(e){return Xe(e,this)},e.prototype._render=function(){var e,r=this,t=r.$options,n=t.render,a=t._parentVnode;a&&(r.$scopedSlots=fr(a.data.scopedSlots,r.$slots,r.$scopedSlots)),r.$vnode=a;try{jr=r,e=n.call(r._renderProxy,r.$createElement)}catch(t){Ie(t,r,"render"),e=r._vnode}finally{jr=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof fe||(e=me()),e.parent=a,e}}(Dt);var Ct=[String,RegExp,Array],St={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Ct,exclude:Ct,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)_t(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(r){Et(e,function(e){return kt(r,e)})}),this.$watch("exclude",function(r){Et(e,function(e){return!kt(r,e)})})},render:function(){var e=this.$slots.default,r=Mr(e),t=r&&r.componentOptions;if(t){var n=qt(t),a=this.include,o=this.exclude;if(a&&(!n||!kt(a,n))||o&&n&&kt(o,n))return r;var i=this.cache,s=this.keys,c=null==r.key?t.Ctor.cid+(t.tag?"::"+t.tag:""):r.key;i[c]?(r.componentInstance=i[c].componentInstance,h(s,c),s.push(c)):(i[c]=r,s.push(c),this.max&&s.length>parseInt(this.max)&&_t(i,s[0],s,this._vnode)),r.data.keepAlive=!0}return r||e&&e[0]}}};!function(e){var r={get:function(){return B}};Object.defineProperty(e,"config",r),e.util={warn:ie,extend:E,mergeOptions:Ne,defineReactive:qe},e.set=ke,e.delete=Ee,e.nextTick=Xe,e.observable=function(e){return xe(e),e},e.options=Object.create(null),R.forEach(function(r){e.options[r+"s"]=Object.create(null)}),e.options._base=e,E(e.options.components,St),function(e){e.use=function(e){var r=this._installedPlugins||(this._installedPlugins=[]);if(r.indexOf(e)>-1)return this;var t=k(arguments,1);return t.unshift(this),"function"==typeof e.install?e.install.apply(e,t):"function"==typeof e&&e.apply(null,t),r.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Ne(this.options,e),this}}(e),xt(e),function(e){R.forEach(function(r){e[r]=function(e,t){return t?("component"===r&&s(t)&&(t.name=t.name||e,t=this.options._base.extend(t)),"directive"===r&&"function"==typeof t&&(t={bind:t,update:t}),this.options[r+"s"][e]=t,t):this.options[r+"s"][e]}})}(e)}(Dt),Object.defineProperty(Dt.prototype,"$isServer",{get:re}),Object.defineProperty(Dt.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Dt,"FunctionalRenderContext",{value:Lr}),Dt.version="2.6.12";var Lt=f("style,class"),Tt=f("input,textarea,option,select,progress"),$t=function(e,r,t){return"value"===t&&Tt(e)&&"button"!==r||"selected"===t&&"option"===e||"checked"===t&&"input"===e||"muted"===t&&"video"===e},Nt=f("contenteditable,draggable,spellcheck"),Ot=f("events,caret,typing,plaintext-only"),Rt=function(e,r){return It(r)||"false"===r?"false":"contenteditable"===e&&Ot(r)?r:"true"},Ft=f("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Bt="http://www.w3.org/1999/xlink",Ut=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Vt=function(e){return Ut(e)?e.slice(6,e.length):""},It=function(e){return null==e||!1===e};function jt(e){for(var r=e.data,n=e,a=e;t(a.componentInstance);)(a=a.componentInstance._vnode)&&a.data&&(r=Pt(a.data,r));for(;t(n=n.parent);)n&&n.data&&(r=Pt(r,n.data));return function(e,r){if(t(e)||t(r))return Ht(e,Mt(r));return""}(r.staticClass,r.class)}function Pt(e,r){return{staticClass:Ht(e.staticClass,r.staticClass),class:t(e.class)?[e.class,r.class]:r.class}}function Ht(e,r){return e?r?e+" "+r:e:r||""}function Mt(e){return Array.isArray(e)?function(e){for(var r,n="",a=0,o=e.length;a<o;a++)t(r=Mt(e[a]))&&""!==r&&(n&&(n+=" "),n+=r);return n}(e):o(e)?function(e){var r="";for(var t in e)e[t]&&(r&&(r+=" "),r+=t);return r}(e):"string"==typeof e?e:""}var Gt={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zt=f("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Jt=f("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Kt=function(e){return zt(e)||Jt(e)};function Zt(e){return Jt(e)?"svg":"math"===e?"math":void 0}var Yt=Object.create(null);var Wt=f("text,number,password,search,email,tel,url");function Qt(e){if("string"==typeof e){var r=document.querySelector(e);return r||document.createElement("div")}return e}var Xt=Object.freeze({createElement:function(e,r){var t=document.createElement(e);return"select"!==e?t:(r.data&&r.data.attrs&&void 0!==r.data.attrs.multiple&&t.setAttribute("multiple","multiple"),t)},createElementNS:function(e,r){return document.createElementNS(Gt[e],r)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,r,t){e.insertBefore(r,t)},removeChild:function(e,r){e.removeChild(r)},appendChild:function(e,r){e.appendChild(r)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,r){e.textContent=r},setStyleScope:function(e,r){e.setAttribute(r,"")}}),en={create:function(e,r){rn(r)},update:function(e,r){e.data.ref!==r.data.ref&&(rn(e,!0),rn(r))},destroy:function(e){rn(e,!0)}};function rn(e,r){var n=e.data.ref;if(t(n)){var a=e.context,o=e.componentInstance||e.elm,i=a.$refs;r?Array.isArray(i[n])?h(i[n],o):i[n]===o&&(i[n]=void 0):e.data.refInFor?Array.isArray(i[n])?i[n].indexOf(o)<0&&i[n].push(o):i[n]=[o]:i[n]=o}}var tn=new fe("",{},[]),nn=["create","activate","update","remove","destroy"];function an(e,a){return e.key===a.key&&(e.tag===a.tag&&e.isComment===a.isComment&&t(e.data)===t(a.data)&&function(e,r){if("input"!==e.tag)return!0;var n,a=t(n=e.data)&&t(n=n.attrs)&&n.type,o=t(n=r.data)&&t(n=n.attrs)&&n.type;return a===o||Wt(a)&&Wt(o)}(e,a)||n(e.isAsyncPlaceholder)&&e.asyncFactory===a.asyncFactory&&r(a.asyncFactory.error))}function on(e,r,n){var a,o,i={};for(a=r;a<=n;++a)t(o=e[a].key)&&(i[o]=a);return i}var sn={create:cn,update:cn,destroy:function(e){cn(e,tn)}};function cn(e,r){(e.data.directives||r.data.directives)&&function(e,r){var t,n,a,o=e===tn,i=r===tn,s=ln(e.data.directives,e.context),c=ln(r.data.directives,r.context),u=[],l=[];for(t in c)n=s[t],a=c[t],n?(a.oldValue=n.value,a.oldArg=n.arg,fn(a,"update",r,e),a.def&&a.def.componentUpdated&&l.push(a)):(fn(a,"bind",r,e),a.def&&a.def.inserted&&u.push(a));if(u.length){var p=function(){for(var t=0;t<u.length;t++)fn(u[t],"inserted",r,e)};o?or(r,"insert",p):p()}l.length&&or(r,"postpatch",function(){for(var t=0;t<l.length;t++)fn(l[t],"componentUpdated",r,e)});if(!o)for(t in s)c[t]||fn(s[t],"unbind",e,e,i)}(e,r)}var un=Object.create(null);function ln(e,r){var t,n,a=Object.create(null);if(!e)return a;for(t=0;t<e.length;t++)(n=e[t]).modifiers||(n.modifiers=un),a[pn(n)]=n,n.def=Oe(r.$options,"directives",n.name);return a}function pn(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fn(e,r,t,n,a){var o=e.def&&e.def[r];if(o)try{o(t.elm,e,t,n,a)}catch(n){Ie(n,t.context,"directive "+e.name+" "+r+" hook")}}var dn=[en,sn];function mn(e,n){var a=n.componentOptions;if(!(t(a)&&!1===a.Ctor.options.inheritAttrs||r(e.data.attrs)&&r(n.data.attrs))){var o,i,s=n.elm,c=e.data.attrs||{},u=n.data.attrs||{};for(o in t(u.__ob__)&&(u=n.data.attrs=E({},u)),u)i=u[o],c[o]!==i&&hn(s,o,i,n.data.pre);for(o in(J||Z)&&u.value!==c.value&&hn(s,"value",u.value),c)r(u[o])&&(Ut(o)?s.removeAttributeNS(Bt,Vt(o)):Nt(o)||s.removeAttribute(o))}}function hn(e,r,t,n){n||e.tagName.indexOf("-")>-1?vn(e,r,t):Ft(r)?It(t)?e.removeAttribute(r):(t="allowfullscreen"===r&&"EMBED"===e.tagName?"true":r,e.setAttribute(r,t)):Nt(r)?e.setAttribute(r,Rt(r,t)):Ut(r)?It(t)?e.removeAttributeNS(Bt,Vt(r)):e.setAttributeNS(Bt,r,t):vn(e,r,t)}function vn(e,r,t){if(It(t))e.removeAttribute(r);else{if(J&&!K&&"TEXTAREA"===e.tagName&&"placeholder"===r&&""!==t&&!e.__ieph){var n=function(r){r.stopImmediatePropagation(),e.removeEventListener("input",n)};e.addEventListener("input",n),e.__ieph=!0}e.setAttribute(r,t)}}var gn={create:mn,update:mn};function bn(e,n){var a=n.elm,o=n.data,i=e.data;if(!(r(o.staticClass)&&r(o.class)&&(r(i)||r(i.staticClass)&&r(i.class)))){var s=jt(n),c=a._transitionClasses;t(c)&&(s=Ht(s,Mt(c))),s!==a._prevClass&&(a.setAttribute("class",s),a._prevClass=s)}}var yn,wn,An,Dn,xn,qn,kn={create:bn,update:bn},En=/[\w).+\-_$\]]/;function _n(e){var r,t,n,a,o,i=!1,s=!1,c=!1,u=!1,l=0,p=0,f=0,d=0;for(n=0;n<e.length;n++)if(t=r,r=e.charCodeAt(n),i)39===r&&92!==t&&(i=!1);else if(s)34===r&&92!==t&&(s=!1);else if(c)96===r&&92!==t&&(c=!1);else if(u)47===r&&92!==t&&(u=!1);else if(124!==r||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||p||f){switch(r){case 34:s=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:f++;break;case 41:f--;break;case 91:p++;break;case 93:p--;break;case 123:l++;break;case 125:l--}if(47===r){for(var m=n-1,h=void 0;m>=0&&" "===(h=e.charAt(m));m--);h&&En.test(h)||(u=!0)}}else void 0===a?(d=n+1,a=e.slice(0,n).trim()):v();function v(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===a?a=e.slice(0,n).trim():0!==d&&v(),o)for(n=0;n<o.length;n++)a=Cn(a,o[n]);return a}function Cn(e,r){var t=r.indexOf("(");if(t<0)return'_f("'+r+'")('+e+")";var n=r.slice(0,t),a=r.slice(t+1);return'_f("'+n+'")('+e+(")"!==a?","+a:a)}function Sn(e,r){console.error("[Vue compiler]: "+e)}function Ln(e,r){return e?e.map(function(e){return e[r]}).filter(function(e){return e}):[]}function Tn(e,r,t,n,a){(e.props||(e.props=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function $n(e,r,t,n,a){(a?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function Nn(e,r,t,n){e.attrsMap[r]=t,e.attrsList.push(In({name:r,value:t},n))}function On(e,r,t,n,a,o,i,s){(e.directives||(e.directives=[])).push(In({name:r,rawName:t,value:n,arg:a,isDynamicArg:o,modifiers:i},s)),e.plain=!1}function Rn(e,r,t){return t?"_p("+r+',"'+e+'")':e+r}function Fn(r,t,n,a,o,i,s,c){var u;(a=a||e).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete a.right):a.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),a.capture&&(delete a.capture,t=Rn("!",t,c)),a.once&&(delete a.once,t=Rn("~",t,c)),a.passive&&(delete a.passive,t=Rn("&",t,c)),a.native?(delete a.native,u=r.nativeEvents||(r.nativeEvents={})):u=r.events||(r.events={});var l=In({value:n.trim(),dynamic:c},s);a!==e&&(l.modifiers=a);var p=u[t];Array.isArray(p)?o?p.unshift(l):p.push(l):u[t]=p?o?[l,p]:[p,l]:l,r.plain=!1}function Bn(e,r,t){var n=Un(e,":"+r)||Un(e,"v-bind:"+r);if(null!=n)return _n(n);if(!1!==t){var a=Un(e,r);if(null!=a)return JSON.stringify(a)}}function Un(e,r,t){var n;if(null!=(n=e.attrsMap[r]))for(var a=e.attrsList,o=0,i=a.length;o<i;o++)if(a[o].name===r){a.splice(o,1);break}return t&&delete e.attrsMap[r],n}function Vn(e,r){for(var t=e.attrsList,n=0,a=t.length;n<a;n++){var o=t[n];if(r.test(o.name))return t.splice(n,1),o}}function In(e,r){return r&&(null!=r.start&&(e.start=r.start),null!=r.end&&(e.end=r.end)),e}function jn(e,r,t){var n=t||{},a=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),a&&(o="_n("+o+")");var i=Pn(r,o);e.model={value:"("+r+")",expression:JSON.stringify(r),callback:"function ($$v) {"+i+"}"}}function Pn(e,r){var t=function(e){if(e=e.trim(),yn=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<yn-1)return(Dn=e.lastIndexOf("."))>-1?{exp:e.slice(0,Dn),key:'"'+e.slice(Dn+1)+'"'}:{exp:e,key:null};wn=e,Dn=xn=qn=0;for(;!Mn();)Gn(An=Hn())?Jn(An):91===An&&zn(An);return{exp:e.slice(0,xn),key:e.slice(xn+1,qn)}}(e);return null===t.key?e+"="+r:"$set("+t.exp+", "+t.key+", "+r+")"}function Hn(){return wn.charCodeAt(++Dn)}function Mn(){return Dn>=yn}function Gn(e){return 34===e||39===e}function zn(e){var r=1;for(xn=Dn;!Mn();)if(Gn(e=Hn()))Jn(e);else if(91===e&&r++,93===e&&r--,0===r){qn=Dn;break}}function Jn(e){for(var r=e;!Mn()&&(e=Hn())!==r;);}var Kn,Zn="__r",Yn="__c";function Wn(e,r,t){var n=Kn;return function a(){null!==r.apply(null,arguments)&&ea(e,a,t,n)}}var Qn=Ge&&!(W&&Number(W[1])<=53);function Xn(e,r,t,n){if(Qn){var a=it,o=r;r=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=a||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Kn.addEventListener(e,r,X?{capture:t,passive:n}:t)}function ea(e,r,t,n){(n||Kn).removeEventListener(e,r._wrapper||r,t)}function ra(e,n){if(!r(e.data.on)||!r(n.data.on)){var a=n.data.on||{},o=e.data.on||{};Kn=n.elm,function(e){if(t(e[Zn])){var r=J?"change":"input";e[r]=[].concat(e[Zn],e[r]||[]),delete e[Zn]}t(e[Yn])&&(e.change=[].concat(e[Yn],e.change||[]),delete e[Yn])}(a),ar(a,o,Xn,ea,Wn,n.context),Kn=void 0}}var ta,na={create:ra,update:ra};function aa(e,n){if(!r(e.data.domProps)||!r(n.data.domProps)){var a,o,i=n.elm,s=e.data.domProps||{},c=n.data.domProps||{};for(a in t(c.__ob__)&&(c=n.data.domProps=E({},c)),s)a in c||(i[a]="");for(a in c){if(o=c[a],"textContent"===a||"innerHTML"===a){if(n.children&&(n.children.length=0),o===s[a])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===a&&"PROGRESS"!==i.tagName){i._value=o;var u=r(o)?"":String(o);oa(i,u)&&(i.value=u)}else if("innerHTML"===a&&Jt(i.tagName)&&r(i.innerHTML)){(ta=ta||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ta.firstChild;i.firstChild;)i.removeChild(i.firstChild);for(;l.firstChild;)i.appendChild(l.firstChild)}else if(o!==s[a])try{i[a]=o}catch(e){}}}}function oa(e,r){return!e.composing&&("OPTION"===e.tagName||function(e,r){var t=!0;try{t=document.activeElement!==e}catch(e){}return t&&e.value!==r}(e,r)||function(e,r){var n=e.value,a=e._vModifiers;if(t(a)){if(a.number)return p(n)!==p(r);if(a.trim)return n.trim()!==r.trim()}return n!==r}(e,r))}var ia={create:aa,update:aa},sa=b(function(e){var r={},t=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(t);n.length>1&&(r[n[0].trim()]=n[1].trim())}}),r});function ca(e){var r=ua(e.style);return e.staticStyle?E(e.staticStyle,r):r}function ua(e){return Array.isArray(e)?_(e):"string"==typeof e?sa(e):e}var la,pa=/^--/,fa=/\s*!important$/,da=function(e,r,t){if(pa.test(r))e.style.setProperty(r,t);else if(fa.test(t))e.style.setProperty(x(r),t.replace(fa,""),"important");else{var n=ha(r);if(Array.isArray(t))for(var a=0,o=t.length;a<o;a++)e.style[n]=t[a];else e.style[n]=t}},ma=["Webkit","Moz","ms"],ha=b(function(e){if(la=la||document.createElement("div").style,"filter"!==(e=w(e))&&e in la)return e;for(var r=e.charAt(0).toUpperCase()+e.slice(1),t=0;t<ma.length;t++){var n=ma[t]+r;if(n in la)return n}});function va(e,n){var a=n.data,o=e.data;if(!(r(a.staticStyle)&&r(a.style)&&r(o.staticStyle)&&r(o.style))){var i,s,c=n.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},p=u||l,f=ua(n.data.style)||{};n.data.normalizedStyle=t(f.__ob__)?E({},f):f;var d=function(e,r){var t,n={};if(r)for(var a=e;a.componentInstance;)(a=a.componentInstance._vnode)&&a.data&&(t=ca(a.data))&&E(n,t);(t=ca(e.data))&&E(n,t);for(var o=e;o=o.parent;)o.data&&(t=ca(o.data))&&E(n,t);return n}(n,!0);for(s in p)r(d[s])&&da(c,s,"");for(s in d)(i=d[s])!==p[s]&&da(c,s,null==i?"":i)}}var ga={create:va,update:va},ba=/\s+/;function ya(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.add(r)}):e.classList.add(r);else{var t=" "+(e.getAttribute("class")||"")+" ";t.indexOf(" "+r+" ")<0&&e.setAttribute("class",(t+r).trim())}}function wa(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.remove(r)}):e.classList.remove(r),e.classList.length||e.removeAttribute("class");else{for(var t=" "+(e.getAttribute("class")||"")+" ",n=" "+r+" ";t.indexOf(n)>=0;)t=t.replace(n," ");(t=t.trim())?e.setAttribute("class",t):e.removeAttribute("class")}}function Aa(e){if(e){if("object"==typeof e){var r={};return!1!==e.css&&E(r,Da(e.name||"v")),E(r,e),r}return"string"==typeof e?Da(e):void 0}}var Da=b(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),xa=H&&!K,qa="transition",ka="animation",Ea="transition",_a="transitionend",Ca="animation",Sa="animationend";xa&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ea="WebkitTransition",_a="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ca="WebkitAnimation",Sa="webkitAnimationEnd"));var La=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ta(e){La(function(){La(e)})}function $a(e,r){var t=e._transitionClasses||(e._transitionClasses=[]);t.indexOf(r)<0&&(t.push(r),ya(e,r))}function Na(e,r){e._transitionClasses&&h(e._transitionClasses,r),wa(e,r)}function Oa(e,r,t){var n=Fa(e,r),a=n.type,o=n.timeout,i=n.propCount;if(!a)return t();var s=a===qa?_a:Sa,c=0,u=function(){e.removeEventListener(s,l),t()},l=function(r){r.target===e&&++c>=i&&u()};setTimeout(function(){c<i&&u()},o+1),e.addEventListener(s,l)}var Ra=/\b(transform|all)(,|$)/;function Fa(e,r){var t,n=window.getComputedStyle(e),a=(n[Ea+"Delay"]||"").split(", "),o=(n[Ea+"Duration"]||"").split(", "),i=Ba(a,o),s=(n[Ca+"Delay"]||"").split(", "),c=(n[Ca+"Duration"]||"").split(", "),u=Ba(s,c),l=0,p=0;return r===qa?i>0&&(t=qa,l=i,p=o.length):r===ka?u>0&&(t=ka,l=u,p=c.length):p=(t=(l=Math.max(i,u))>0?i>u?qa:ka:null)?t===qa?o.length:c.length:0,{type:t,timeout:l,propCount:p,hasTransform:t===qa&&Ra.test(n[Ea+"Property"])}}function Ba(e,r){for(;e.length<r.length;)e=e.concat(e);return Math.max.apply(null,r.map(function(r,t){return Ua(r)+Ua(e[t])}))}function Ua(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Va(e,n){var a=e.elm;t(a._leaveCb)&&(a._leaveCb.cancelled=!0,a._leaveCb());var i=Aa(e.data.transition);if(!r(i)&&!t(a._enterCb)&&1===a.nodeType){for(var s=i.css,c=i.type,u=i.enterClass,l=i.enterToClass,f=i.enterActiveClass,d=i.appearClass,m=i.appearToClass,h=i.appearActiveClass,v=i.beforeEnter,g=i.enter,b=i.afterEnter,y=i.enterCancelled,w=i.beforeAppear,A=i.appear,D=i.afterAppear,x=i.appearCancelled,q=i.duration,k=Zr,E=Zr.$vnode;E&&E.parent;)k=E.context,E=E.parent;var _=!k._isMounted||!e.isRootInsert;if(!_||A||""===A){var C=_&&d?d:u,S=_&&h?h:f,L=_&&m?m:l,T=_&&w||v,$=_&&"function"==typeof A?A:g,O=_&&D||b,R=_&&x||y,F=p(o(q)?q.enter:q),B=!1!==s&&!K,U=Pa($),V=a._enterCb=N(function(){B&&(Na(a,L),Na(a,S)),V.cancelled?(B&&Na(a,C),R&&R(a)):O&&O(a),a._enterCb=null});e.data.show||or(e,"insert",function(){var r=a.parentNode,t=r&&r._pending&&r._pending[e.key];t&&t.tag===e.tag&&t.elm._leaveCb&&t.elm._leaveCb(),$&&$(a,V)}),T&&T(a),B&&($a(a,C),$a(a,S),Ta(function(){Na(a,C),V.cancelled||($a(a,L),U||(ja(F)?setTimeout(V,F):Oa(a,c,V)))})),e.data.show&&(n&&n(),$&&$(a,V)),B||U||V()}}}function Ia(e,n){var a=e.elm;t(a._enterCb)&&(a._enterCb.cancelled=!0,a._enterCb());var i=Aa(e.data.transition);if(r(i)||1!==a.nodeType)return n();if(!t(a._leaveCb)){var s=i.css,c=i.type,u=i.leaveClass,l=i.leaveToClass,f=i.leaveActiveClass,d=i.beforeLeave,m=i.leave,h=i.afterLeave,v=i.leaveCancelled,g=i.delayLeave,b=i.duration,y=!1!==s&&!K,w=Pa(m),A=p(o(b)?b.leave:b),D=a._leaveCb=N(function(){a.parentNode&&a.parentNode._pending&&(a.parentNode._pending[e.key]=null),y&&(Na(a,l),Na(a,f)),D.cancelled?(y&&Na(a,u),v&&v(a)):(n(),h&&h(a)),a._leaveCb=null});g?g(x):x()}function x(){D.cancelled||(!e.data.show&&a.parentNode&&((a.parentNode._pending||(a.parentNode._pending={}))[e.key]=e),d&&d(a),y&&($a(a,u),$a(a,f),Ta(function(){Na(a,u),D.cancelled||($a(a,l),w||(ja(A)?setTimeout(D,A):Oa(a,c,D)))})),m&&m(a,D),y||w||D())}}function ja(e){return"number"==typeof e&&!isNaN(e)}function Pa(e){if(r(e))return!1;var n=e.fns;return t(n)?Pa(Array.isArray(n)?n[0]:n):(e._length||e.length)>1}function Ha(e,r){!0!==r.data.show&&Va(r)}var Ma=function(e){var o,i,s={},c=e.modules,u=e.nodeOps;for(o=0;o<nn.length;++o)for(s[nn[o]]=[],i=0;i<c.length;++i)t(c[i][nn[o]])&&s[nn[o]].push(c[i][nn[o]]);function l(e){var r=u.parentNode(e);t(r)&&u.removeChild(r,e)}function p(e,r,a,o,i,c,l){if(t(e.elm)&&t(c)&&(e=c[l]=ve(e)),e.isRootInsert=!i,!function(e,r,a,o){var i=e.data;if(t(i)){var c=t(e.componentInstance)&&i.keepAlive;if(t(i=i.hook)&&t(i=i.init)&&i(e,!1),t(e.componentInstance))return d(e,r),m(a,e.elm,o),n(c)&&function(e,r,n,a){for(var o,i=e;i.componentInstance;)if(i=i.componentInstance._vnode,t(o=i.data)&&t(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](tn,i);r.push(i);break}m(n,e.elm,a)}(e,r,a,o),!0}}(e,r,a,o)){var p=e.data,f=e.children,v=e.tag;t(v)?(e.elm=e.ns?u.createElementNS(e.ns,v):u.createElement(v,e),b(e),h(e,f,r),t(p)&&g(e,r),m(a,e.elm,o)):n(e.isComment)?(e.elm=u.createComment(e.text),m(a,e.elm,o)):(e.elm=u.createTextNode(e.text),m(a,e.elm,o))}}function d(e,r){t(e.data.pendingInsert)&&(r.push.apply(r,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,v(e)?(g(e,r),b(e)):(rn(e),r.push(e))}function m(e,r,n){t(e)&&(t(n)?u.parentNode(n)===e&&u.insertBefore(e,r,n):u.appendChild(e,r))}function h(e,r,t){if(Array.isArray(r))for(var n=0;n<r.length;++n)p(r[n],t,e.elm,null,!0,r,n);else a(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function v(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return t(e.tag)}function g(e,r){for(var n=0;n<s.create.length;++n)s.create[n](tn,e);t(o=e.data.hook)&&(t(o.create)&&o.create(tn,e),t(o.insert)&&r.push(e))}function b(e){var r;if(t(r=e.fnScopeId))u.setStyleScope(e.elm,r);else for(var n=e;n;)t(r=n.context)&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r),n=n.parent;t(r=Zr)&&r!==e.context&&r!==e.fnContext&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r)}function y(e,r,t,n,a,o){for(;n<=a;++n)p(t[n],o,e,r,!1,t,n)}function w(e){var r,n,a=e.data;if(t(a))for(t(r=a.hook)&&t(r=r.destroy)&&r(e),r=0;r<s.destroy.length;++r)s.destroy[r](e);if(t(r=e.children))for(n=0;n<e.children.length;++n)w(e.children[n])}function A(e,r,n){for(;r<=n;++r){var a=e[r];t(a)&&(t(a.tag)?(D(a),w(a)):l(a.elm))}}function D(e,r){if(t(r)||t(e.data)){var n,a=s.remove.length+1;for(t(r)?r.listeners+=a:r=function(e,r){function t(){0==--t.listeners&&l(e)}return t.listeners=r,t}(e.elm,a),t(n=e.componentInstance)&&t(n=n._vnode)&&t(n.data)&&D(n,r),n=0;n<s.remove.length;++n)s.remove[n](e,r);t(n=e.data.hook)&&t(n=n.remove)?n(e,r):r()}else l(e.elm)}function x(e,r,n,a){for(var o=n;o<a;o++){var i=r[o];if(t(i)&&an(e,i))return o}}function q(e,a,o,i,c,l){if(e!==a){t(a.elm)&&t(i)&&(a=i[c]=ve(a));var f=a.elm=e.elm;if(n(e.isAsyncPlaceholder))t(a.asyncFactory.resolved)?_(e.elm,a,o):a.isAsyncPlaceholder=!0;else if(n(a.isStatic)&&n(e.isStatic)&&a.key===e.key&&(n(a.isCloned)||n(a.isOnce)))a.componentInstance=e.componentInstance;else{var d,m=a.data;t(m)&&t(d=m.hook)&&t(d=d.prepatch)&&d(e,a);var h=e.children,g=a.children;if(t(m)&&v(a)){for(d=0;d<s.update.length;++d)s.update[d](e,a);t(d=m.hook)&&t(d=d.update)&&d(e,a)}r(a.text)?t(h)&&t(g)?h!==g&&function(e,n,a,o,i){for(var s,c,l,f=0,d=0,m=n.length-1,h=n[0],v=n[m],g=a.length-1,b=a[0],w=a[g],D=!i;f<=m&&d<=g;)r(h)?h=n[++f]:r(v)?v=n[--m]:an(h,b)?(q(h,b,o,a,d),h=n[++f],b=a[++d]):an(v,w)?(q(v,w,o,a,g),v=n[--m],w=a[--g]):an(h,w)?(q(h,w,o,a,g),D&&u.insertBefore(e,h.elm,u.nextSibling(v.elm)),h=n[++f],w=a[--g]):an(v,b)?(q(v,b,o,a,d),D&&u.insertBefore(e,v.elm,h.elm),v=n[--m],b=a[++d]):(r(s)&&(s=on(n,f,m)),r(c=t(b.key)?s[b.key]:x(b,n,f,m))?p(b,o,e,h.elm,!1,a,d):an(l=n[c],b)?(q(l,b,o,a,d),n[c]=void 0,D&&u.insertBefore(e,l.elm,h.elm)):p(b,o,e,h.elm,!1,a,d),b=a[++d]);f>m?y(e,r(a[g+1])?null:a[g+1].elm,a,d,g,o):d>g&&A(n,f,m)}(f,h,g,o,l):t(g)?(t(e.text)&&u.setTextContent(f,""),y(f,null,g,0,g.length-1,o)):t(h)?A(h,0,h.length-1):t(e.text)&&u.setTextContent(f,""):e.text!==a.text&&u.setTextContent(f,a.text),t(m)&&t(d=m.hook)&&t(d=d.postpatch)&&d(e,a)}}}function k(e,r,a){if(n(a)&&t(e.parent))e.parent.data.pendingInsert=r;else for(var o=0;o<r.length;++o)r[o].data.hook.insert(r[o])}var E=f("attrs,class,staticClass,staticStyle,key");function _(e,r,a,o){var i,s=r.tag,c=r.data,u=r.children;if(o=o||c&&c.pre,r.elm=e,n(r.isComment)&&t(r.asyncFactory))return r.isAsyncPlaceholder=!0,!0;if(t(c)&&(t(i=c.hook)&&t(i=i.init)&&i(r,!0),t(i=r.componentInstance)))return d(r,a),!0;if(t(s)){if(t(u))if(e.hasChildNodes())if(t(i=c)&&t(i=i.domProps)&&t(i=i.innerHTML)){if(i!==e.innerHTML)return!1}else{for(var l=!0,p=e.firstChild,f=0;f<u.length;f++){if(!p||!_(p,u[f],a,o)){l=!1;break}p=p.nextSibling}if(!l||p)return!1}else h(r,u,a);if(t(c)){var m=!1;for(var v in c)if(!E(v)){m=!0,g(r,a);break}!m&&c.class&&rr(c.class)}}else e.data!==r.text&&(e.data=r.text);return!0}return function(e,a,o,i){if(!r(a)){var c,l=!1,f=[];if(r(e))l=!0,p(a,f);else{var d=t(e.nodeType);if(!d&&an(e,a))q(e,a,f,null,null,i);else{if(d){if(1===e.nodeType&&e.hasAttribute(O)&&(e.removeAttribute(O),o=!0),n(o)&&_(e,a,f))return k(a,f,!0),e;c=e,e=new fe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var m=e.elm,h=u.parentNode(m);if(p(a,f,m._leaveCb?null:h,u.nextSibling(m)),t(a.parent))for(var g=a.parent,b=v(a);g;){for(var y=0;y<s.destroy.length;++y)s.destroy[y](g);if(g.elm=a.elm,b){for(var D=0;D<s.create.length;++D)s.create[D](tn,g);var x=g.data.hook.insert;if(x.merged)for(var E=1;E<x.fns.length;E++)x.fns[E]()}else rn(g);g=g.parent}t(h)?A([e],0,0):t(e.tag)&&w(e)}}return k(a,f,l),a.elm}t(e)&&w(e)}}({nodeOps:Xt,modules:[gn,kn,na,ia,ga,H?{create:Ha,activate:Ha,remove:function(e,r){!0!==e.data.show?Ia(e,r):r()}}:{}].concat(dn)});K&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Qa(e,"input")});var Ga={inserted:function(e,r,t,n){"select"===t.tag?(n.elm&&!n.elm._vOptions?or(t,"postpatch",function(){Ga.componentUpdated(e,r,t)}):za(e,r,t.context),e._vOptions=[].map.call(e.options,Za)):("textarea"===t.tag||Wt(e.type))&&(e._vModifiers=r.modifiers,r.modifiers.lazy||(e.addEventListener("compositionstart",Ya),e.addEventListener("compositionend",Wa),e.addEventListener("change",Wa),K&&(e.vmodel=!0)))},componentUpdated:function(e,r,t){if("select"===t.tag){za(e,r,t.context);var n=e._vOptions,a=e._vOptions=[].map.call(e.options,Za);if(a.some(function(e,r){return!T(e,n[r])}))(e.multiple?r.value.some(function(e){return Ka(e,a)}):r.value!==r.oldValue&&Ka(r.value,a))&&Qa(e,"change")}}};function za(e,r,t){Ja(e,r,t),(J||Z)&&setTimeout(function(){Ja(e,r,t)},0)}function Ja(e,r,t){var n=r.value,a=e.multiple;if(!a||Array.isArray(n)){for(var o,i,s=0,c=e.options.length;s<c;s++)if(i=e.options[s],a)o=$(n,Za(i))>-1,i.selected!==o&&(i.selected=o);else if(T(Za(i),n))return void(e.selectedIndex!==s&&(e.selectedIndex=s));a||(e.selectedIndex=-1)}}function Ka(e,r){return r.every(function(r){return!T(r,e)})}function Za(e){return"_value"in e?e._value:e.value}function Ya(e){e.target.composing=!0}function Wa(e){e.target.composing&&(e.target.composing=!1,Qa(e.target,"input"))}function Qa(e,r){var t=document.createEvent("HTMLEvents");t.initEvent(r,!0,!0),e.dispatchEvent(t)}function Xa(e){return!e.componentInstance||e.data&&e.data.transition?e:Xa(e.componentInstance._vnode)}var eo={model:Ga,show:{bind:function(e,r,t){var n=r.value,a=(t=Xa(t)).data&&t.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;n&&a?(t.data.show=!0,Va(t,function(){e.style.display=o})):e.style.display=n?o:"none"},update:function(e,r,t){var n=r.value;!n!=!r.oldValue&&((t=Xa(t)).data&&t.data.transition?(t.data.show=!0,n?Va(t,function(){e.style.display=e.__vOriginalDisplay}):Ia(t,function(){e.style.display="none"})):e.style.display=n?e.__vOriginalDisplay:"none")},unbind:function(e,r,t,n,a){a||(e.style.display=e.__vOriginalDisplay)}}},ro={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var r=e&&e.componentOptions;return r&&r.Ctor.options.abstract?to(Mr(r.children)):e}function no(e){var r={},t=e.$options;for(var n in t.propsData)r[n]=e[n];var a=t._parentListeners;for(var o in a)r[w(o)]=a[o];return r}function ao(e,r){if(/\d-keep-alive$/.test(r.tag))return e("keep-alive",{props:r.componentOptions.propsData})}var oo=function(e){return e.tag||Hr(e)},io=function(e){return"show"===e.name},so={name:"transition",props:ro,abstract:!0,render:function(e){var r=this,t=this.$slots.default;if(t&&(t=t.filter(oo)).length){var n=this.mode,o=t[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var i=to(o);if(!i)return o;if(this._leaving)return ao(e,o);var s="__transition-"+this._uid+"-";i.key=null==i.key?i.isComment?s+"comment":s+i.tag:a(i.key)?0===String(i.key).indexOf(s)?i.key:s+i.key:i.key;var c=(i.data||(i.data={})).transition=no(this),u=this._vnode,l=to(u);if(i.data.directives&&i.data.directives.some(io)&&(i.data.show=!0),l&&l.data&&!function(e,r){return r.key===e.key&&r.tag===e.tag}(i,l)&&!Hr(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var p=l.data.transition=E({},c);if("out-in"===n)return this._leaving=!0,or(p,"afterLeave",function(){r._leaving=!1,r.$forceUpdate()}),ao(e,o);if("in-out"===n){if(Hr(i))return u;var f,d=function(){f()};or(c,"afterEnter",d),or(c,"enterCancelled",d),or(p,"delayLeave",function(e){f=e})}}return o}}},co=E({tag:String,moveClass:String},ro);function uo(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function lo(e){e.data.newPos=e.elm.getBoundingClientRect()}function po(e){var r=e.data.pos,t=e.data.newPos,n=r.left-t.left,a=r.top-t.top;if(n||a){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+n+"px,"+a+"px)",o.transitionDuration="0s"}}delete co.mode;var fo={Transition:so,TransitionGroup:{props:co,beforeMount:function(){var e=this,r=this._update;this._update=function(t,n){var a=Yr(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,a(),r.call(e,t,n)}},render:function(e){for(var r=this.tag||this.$vnode.data.tag||"span",t=Object.create(null),n=this.prevChildren=this.children,a=this.$slots.default||[],o=this.children=[],i=no(this),s=0;s<a.length;s++){var c=a[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),t[c.key]=c,(c.data||(c.data={})).transition=i)}if(n){for(var u=[],l=[],p=0;p<n.length;p++){var f=n[p];f.data.transition=i,f.data.pos=f.elm.getBoundingClientRect(),t[f.key]?u.push(f):l.push(f)}this.kept=e(r,null,u),this.removed=l}return e(r,null,o)},updated:function(){var e=this.prevChildren,r=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,r)&&(e.forEach(uo),e.forEach(lo),e.forEach(po),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var t=e.elm,n=t.style;$a(t,r),n.transform=n.WebkitTransform=n.transitionDuration="",t.addEventListener(_a,t._moveCb=function e(n){n&&n.target!==t||n&&!/transform$/.test(n.propertyName)||(t.removeEventListener(_a,e),t._moveCb=null,Na(t,r))})}}))},methods:{hasMove:function(e,r){if(!xa)return!1;if(this._hasMove)return this._hasMove;var t=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){wa(t,e)}),ya(t,r),t.style.display="none",this.$el.appendChild(t);var n=Fa(t);return this.$el.removeChild(t),this._hasMove=n.hasTransform}}}};Dt.config.mustUseProp=$t,Dt.config.isReservedTag=Kt,Dt.config.isReservedAttr=Lt,Dt.config.getTagNamespace=Zt,Dt.config.isUnknownElement=function(e){if(!H)return!0;if(Kt(e))return!1;if(e=e.toLowerCase(),null!=Yt[e])return Yt[e];var r=document.createElement(e);return e.indexOf("-")>-1?Yt[e]=r.constructor===window.HTMLUnknownElement||r.constructor===window.HTMLElement:Yt[e]=/HTMLUnknownElement/.test(r.toString())},E(Dt.options.directives,eo),E(Dt.options.components,fo),Dt.prototype.__patch__=H?Ma:C,Dt.prototype.$mount=function(e,r){return function(e,r,t){var n;return e.$el=r,e.$options.render||(e.$options.render=me),Xr(e,"beforeMount"),n=function(){e._update(e._render(),t)},new pt(e,n,C,{before:function(){e._isMounted&&!e._isDestroyed&&Xr(e,"beforeUpdate")}},!0),t=!1,null==e.$vnode&&(e._isMounted=!0,Xr(e,"mounted")),e}(this,e=e&&H?Qt(e):void 0,r)},H&&setTimeout(function(){B.devtools&&te&&te.emit("init",Dt)},0);var mo=/\{\{((?:.|\r?\n)+?)\}\}/g,ho=/[-.*+?^${}()|[\]\/\\]/g,vo=b(function(e){var r=e[0].replace(ho,"\\$&"),t=e[1].replace(ho,"\\$&");return new RegExp(r+"((?:.|\\n)+?)"+t,"g")});var go={staticKeys:["staticClass"],transformNode:function(e,r){r.warn;var t=Un(e,"class");t&&(e.staticClass=JSON.stringify(t));var n=Bn(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var r="";return e.staticClass&&(r+="staticClass:"+e.staticClass+","),e.classBinding&&(r+="class:"+e.classBinding+","),r}};var bo={staticKeys:["staticStyle"],transformNode:function(e,r){r.warn;var t=Un(e,"style");t&&(e.staticStyle=JSON.stringify(sa(t)));var n=Bn(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var r="";return e.staticStyle&&(r+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(r+="style:("+e.styleBinding+"),"),r}};!function(e){var r="object"==typeof exports&&exports,t="object"==typeof module&&module&&module.exports==r&&module,n="object"==typeof global&&global;n.global!==n&&n.window!==n||(e=n);var a=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,o=/[\x01-\x7F]/g,i=/[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,s=/<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g,c={"\xad":"shy","\u200c":"zwnj","\u200d":"zwj","\u200e":"lrm","\u2063":"ic","\u2062":"it","\u2061":"af","\u200f":"rlm","\u200b":"ZeroWidthSpace","\u2060":"NoBreak","\u0311":"DownBreve","\u20db":"tdot","\u20dc":"DotDot","\t":"Tab","\n":"NewLine","\u2008":"puncsp","\u205f":"MediumSpace","\u2009":"thinsp","\u200a":"hairsp","\u2004":"emsp13","\u2002":"ensp","\u2005":"emsp14","\u2003":"emsp","\u2007":"numsp","\xa0":"nbsp","\u205f\u200a":"ThickSpace","\u203e":"oline",_:"lowbar","\u2010":"dash","\u2013":"ndash","\u2014":"mdash","\u2015":"horbar",",":"comma",";":"semi","\u204f":"bsemi",":":"colon","\u2a74":"Colone","!":"excl","\xa1":"iexcl","?":"quest","\xbf":"iquest",".":"period","\u2025":"nldr","\u2026":"mldr","\xb7":"middot","'":"apos","\u2018":"lsquo","\u2019":"rsquo","\u201a":"sbquo","\u2039":"lsaquo","\u203a":"rsaquo",'"':"quot","\u201c":"ldquo","\u201d":"rdquo","\u201e":"bdquo","\xab":"laquo","\xbb":"raquo","(":"lpar",")":"rpar","[":"lsqb","]":"rsqb","{":"lcub","}":"rcub","\u2308":"lceil","\u2309":"rceil","\u230a":"lfloor","\u230b":"rfloor","\u2985":"lopar","\u2986":"ropar","\u298b":"lbrke","\u298c":"rbrke","\u298d":"lbrkslu","\u298e":"rbrksld","\u298f":"lbrksld","\u2990":"rbrkslu","\u2991":"langd","\u2992":"rangd","\u2993":"lparlt","\u2994":"rpargt","\u2995":"gtlPar","\u2996":"ltrPar","\u27e6":"lobrk","\u27e7":"robrk","\u27e8":"lang","\u27e9":"rang","\u27ea":"Lang","\u27eb":"Rang","\u27ec":"loang","\u27ed":"roang","\u2772":"lbbrk","\u2773":"rbbrk","\u2016":"Vert","\xa7":"sect","\xb6":"para","@":"commat","*":"ast","/":"sol",undefined:null,"&":"amp","#":"num","%":"percnt","\u2030":"permil","\u2031":"pertenk","\u2020":"dagger","\u2021":"Dagger","\u2022":"bull","\u2043":"hybull","\u2032":"prime","\u2033":"Prime","\u2034":"tprime","\u2057":"qprime","\u2035":"bprime","\u2041":"caret","`":"grave","\xb4":"acute","\u02dc":"tilde","^":"Hat","\xaf":"macr","\u02d8":"breve","\u02d9":"dot","\xa8":"die","\u02da":"ring","\u02dd":"dblac","\xb8":"cedil","\u02db":"ogon","\u02c6":"circ","\u02c7":"caron","\xb0":"deg","\xa9":"copy","\xae":"reg","\u2117":"copysr","\u2118":"wp","\u211e":"rx","\u2127":"mho","\u2129":"iiota","\u2190":"larr","\u219a":"nlarr","\u2192":"rarr","\u219b":"nrarr","\u2191":"uarr","\u2193":"darr","\u2194":"harr","\u21ae":"nharr","\u2195":"varr","\u2196":"nwarr","\u2197":"nearr","\u2198":"searr","\u2199":"swarr","\u219d":"rarrw","\u219d\u0338":"nrarrw","\u219e":"Larr","\u219f":"Uarr","\u21a0":"Rarr","\u21a1":"Darr","\u21a2":"larrtl","\u21a3":"rarrtl","\u21a4":"mapstoleft","\u21a5":"mapstoup","\u21a6":"map","\u21a7":"mapstodown","\u21a9":"larrhk","\u21aa":"rarrhk","\u21ab":"larrlp","\u21ac":"rarrlp","\u21ad":"harrw","\u21b0":"lsh","\u21b1":"rsh","\u21b2":"ldsh","\u21b3":"rdsh","\u21b5":"crarr","\u21b6":"cularr","\u21b7":"curarr","\u21ba":"olarr","\u21bb":"orarr","\u21bc":"lharu","\u21bd":"lhard","\u21be":"uharr","\u21bf":"uharl","\u21c0":"rharu","\u21c1":"rhard","\u21c2":"dharr","\u21c3":"dharl","\u21c4":"rlarr","\u21c5":"udarr","\u21c6":"lrarr","\u21c7":"llarr","\u21c8":"uuarr","\u21c9":"rrarr","\u21ca":"ddarr","\u21cb":"lrhar","\u21cc":"rlhar","\u21d0":"lArr","\u21cd":"nlArr","\u21d1":"uArr","\u21d2":"rArr","\u21cf":"nrArr","\u21d3":"dArr","\u21d4":"iff","\u21ce":"nhArr","\u21d5":"vArr","\u21d6":"nwArr","\u21d7":"neArr","\u21d8":"seArr","\u21d9":"swArr","\u21da":"lAarr","\u21db":"rAarr","\u21dd":"zigrarr","\u21e4":"larrb","\u21e5":"rarrb","\u21f5":"duarr","\u21fd":"loarr","\u21fe":"roarr","\u21ff":"hoarr","\u2200":"forall","\u2201":"comp","\u2202":"part","\u2202\u0338":"npart","\u2203":"exist","\u2204":"nexist","\u2205":"empty","\u2207":"Del","\u2208":"in","\u2209":"notin","\u220b":"ni","\u220c":"notni","\u03f6":"bepsi","\u220f":"prod","\u2210":"coprod","\u2211":"sum","+":"plus","\xb1":"pm","\xf7":"div","\xd7":"times","<":"lt","\u226e":"nlt","<\u20d2":"nvlt","=":"equals","\u2260":"ne","=\u20e5":"bne","\u2a75":"Equal",">":"gt","\u226f":"ngt",">\u20d2":"nvgt","\xac":"not","|":"vert","\xa6":"brvbar","\u2212":"minus","\u2213":"mp","\u2214":"plusdo","\u2044":"frasl","\u2216":"setmn","\u2217":"lowast","\u2218":"compfn","\u221a":"Sqrt","\u221d":"prop","\u221e":"infin","\u221f":"angrt","\u2220":"ang","\u2220\u20d2":"nang","\u2221":"angmsd","\u2222":"angsph","\u2223":"mid","\u2224":"nmid","\u2225":"par","\u2226":"npar","\u2227":"and","\u2228":"or","\u2229":"cap","\u2229\ufe00":"caps","\u222a":"cup","\u222a\ufe00":"cups","\u222b":"int","\u222c":"Int","\u222d":"tint","\u2a0c":"qint","\u222e":"oint","\u222f":"Conint","\u2230":"Cconint","\u2231":"cwint","\u2232":"cwconint","\u2233":"awconint","\u2234":"there4","\u2235":"becaus","\u2236":"ratio","\u2237":"Colon","\u2238":"minusd","\u223a":"mDDot","\u223b":"homtht","\u223c":"sim","\u2241":"nsim","\u223c\u20d2":"nvsim","\u223d":"bsim","\u223d\u0331":"race","\u223e":"ac","\u223e\u0333":"acE","\u223f":"acd","\u2240":"wr","\u2242":"esim","\u2242\u0338":"nesim","\u2243":"sime","\u2244":"nsime","\u2245":"cong","\u2247":"ncong","\u2246":"simne","\u2248":"ap","\u2249":"nap","\u224a":"ape","\u224b":"apid","\u224b\u0338":"napid","\u224c":"bcong","\u224d":"CupCap","\u226d":"NotCupCap","\u224d\u20d2":"nvap","\u224e":"bump","\u224e\u0338":"nbump","\u224f":"bumpe","\u224f\u0338":"nbumpe","\u2250":"doteq","\u2250\u0338":"nedot","\u2251":"eDot","\u2252":"efDot","\u2253":"erDot","\u2254":"colone","\u2255":"ecolon","\u2256":"ecir","\u2257":"cire","\u2259":"wedgeq","\u225a":"veeeq","\u225c":"trie","\u225f":"equest","\u2261":"equiv","\u2262":"nequiv","\u2261\u20e5":"bnequiv","\u2264":"le","\u2270":"nle","\u2264\u20d2":"nvle","\u2265":"ge","\u2271":"nge","\u2265\u20d2":"nvge","\u2266":"lE","\u2266\u0338":"nlE","\u2267":"gE","\u2267\u0338":"ngE","\u2268\ufe00":"lvnE","\u2268":"lnE","\u2269":"gnE","\u2269\ufe00":"gvnE","\u226a":"ll","\u226a\u0338":"nLtv","\u226a\u20d2":"nLt","\u226b":"gg","\u226b\u0338":"nGtv","\u226b\u20d2":"nGt","\u226c":"twixt","\u2272":"lsim","\u2274":"nlsim","\u2273":"gsim","\u2275":"ngsim","\u2276":"lg","\u2278":"ntlg","\u2277":"gl","\u2279":"ntgl","\u227a":"pr","\u2280":"npr","\u227b":"sc","\u2281":"nsc","\u227c":"prcue","\u22e0":"nprcue","\u227d":"sccue","\u22e1":"nsccue","\u227e":"prsim","\u227f":"scsim","\u227f\u0338":"NotSucceedsTilde","\u2282":"sub","\u2284":"nsub","\u2282\u20d2":"vnsub","\u2283":"sup","\u2285":"nsup","\u2283\u20d2":"vnsup","\u2286":"sube","\u2288":"nsube","\u2287":"supe","\u2289":"nsupe","\u228a\ufe00":"vsubne","\u228a":"subne","\u228b\ufe00":"vsupne","\u228b":"supne","\u228d":"cupdot","\u228e":"uplus","\u228f":"sqsub","\u228f\u0338":"NotSquareSubset","\u2290":"sqsup","\u2290\u0338":"NotSquareSuperset","\u2291":"sqsube","\u22e2":"nsqsube","\u2292":"sqsupe","\u22e3":"nsqsupe","\u2293":"sqcap","\u2293\ufe00":"sqcaps","\u2294":"sqcup","\u2294\ufe00":"sqcups","\u2295":"oplus","\u2296":"ominus","\u2297":"otimes","\u2298":"osol","\u2299":"odot","\u229a":"ocir","\u229b":"oast","\u229d":"odash","\u229e":"plusb","\u229f":"minusb","\u22a0":"timesb","\u22a1":"sdotb","\u22a2":"vdash","\u22ac":"nvdash","\u22a3":"dashv","\u22a4":"top","\u22a5":"bot","\u22a7":"models","\u22a8":"vDash","\u22ad":"nvDash","\u22a9":"Vdash","\u22ae":"nVdash","\u22aa":"Vvdash","\u22ab":"VDash","\u22af":"nVDash","\u22b0":"prurel","\u22b2":"vltri","\u22ea":"nltri","\u22b3":"vrtri","\u22eb":"nrtri","\u22b4":"ltrie","\u22ec":"nltrie","\u22b4\u20d2":"nvltrie","\u22b5":"rtrie","\u22ed":"nrtrie","\u22b5\u20d2":"nvrtrie","\u22b6":"origof","\u22b7":"imof","\u22b8":"mumap","\u22b9":"hercon","\u22ba":"intcal","\u22bb":"veebar","\u22bd":"barvee","\u22be":"angrtvb","\u22bf":"lrtri","\u22c0":"Wedge","\u22c1":"Vee","\u22c2":"xcap","\u22c3":"xcup","\u22c4":"diam","\u22c5":"sdot","\u22c6":"Star","\u22c7":"divonx","\u22c8":"bowtie","\u22c9":"ltimes","\u22ca":"rtimes","\u22cb":"lthree","\u22cc":"rthree","\u22cd":"bsime","\u22ce":"cuvee","\u22cf":"cuwed","\u22d0":"Sub","\u22d1":"Sup","\u22d2":"Cap","\u22d3":"Cup","\u22d4":"fork","\u22d5":"epar","\u22d6":"ltdot","\u22d7":"gtdot","\u22d8":"Ll","\u22d8\u0338":"nLl","\u22d9":"Gg","\u22d9\u0338":"nGg","\u22da\ufe00":"lesg","\u22da":"leg","\u22db":"gel","\u22db\ufe00":"gesl","\u22de":"cuepr","\u22df":"cuesc","\u22e6":"lnsim","\u22e7":"gnsim","\u22e8":"prnsim","\u22e9":"scnsim","\u22ee":"vellip","\u22ef":"ctdot","\u22f0":"utdot","\u22f1":"dtdot","\u22f2":"disin","\u22f3":"isinsv","\u22f4":"isins","\u22f5":"isindot","\u22f5\u0338":"notindot","\u22f6":"notinvc","\u22f7":"notinvb","\u22f9":"isinE","\u22f9\u0338":"notinE","\u22fa":"nisd","\u22fb":"xnis","\u22fc":"nis","\u22fd":"notnivc","\u22fe":"notnivb","\u2305":"barwed","\u2306":"Barwed","\u230c":"drcrop","\u230d":"dlcrop","\u230e":"urcrop","\u230f":"ulcrop","\u2310":"bnot","\u2312":"profline","\u2313":"profsurf","\u2315":"telrec","\u2316":"target","\u231c":"ulcorn","\u231d":"urcorn","\u231e":"dlcorn","\u231f":"drcorn","\u2322":"frown","\u2323":"smile","\u232d":"cylcty","\u232e":"profalar","\u2336":"topbot","\u233d":"ovbar","\u233f":"solbar","\u237c":"angzarr","\u23b0":"lmoust","\u23b1":"rmoust","\u23b4":"tbrk","\u23b5":"bbrk","\u23b6":"bbrktbrk","\u23dc":"OverParenthesis","\u23dd":"UnderParenthesis","\u23de":"OverBrace","\u23df":"UnderBrace","\u23e2":"trpezium","\u23e7":"elinters","\u2423":"blank","\u2500":"boxh","\u2502":"boxv","\u250c":"boxdr","\u2510":"boxdl","\u2514":"boxur","\u2518":"boxul","\u251c":"boxvr","\u2524":"boxvl","\u252c":"boxhd","\u2534":"boxhu","\u253c":"boxvh","\u2550":"boxH","\u2551":"boxV","\u2552":"boxdR","\u2553":"boxDr","\u2554":"boxDR","\u2555":"boxdL","\u2556":"boxDl","\u2557":"boxDL","\u2558":"boxuR","\u2559":"boxUr","\u255a":"boxUR","\u255b":"boxuL","\u255c":"boxUl","\u255d":"boxUL","\u255e":"boxvR","\u255f":"boxVr","\u2560":"boxVR","\u2561":"boxvL","\u2562":"boxVl","\u2563":"boxVL","\u2564":"boxHd","\u2565":"boxhD","\u2566":"boxHD","\u2567":"boxHu","\u2568":"boxhU","\u2569":"boxHU","\u256a":"boxvH","\u256b":"boxVh","\u256c":"boxVH","\u2580":"uhblk","\u2584":"lhblk","\u2588":"block","\u2591":"blk14","\u2592":"blk12","\u2593":"blk34","\u25a1":"squ","\u25aa":"squf","\u25ab":"EmptyVerySmallSquare","\u25ad":"rect","\u25ae":"marker","\u25b1":"fltns","\u25b3":"xutri","\u25b4":"utrif","\u25b5":"utri","\u25b8":"rtrif","\u25b9":"rtri","\u25bd":"xdtri","\u25be":"dtrif","\u25bf":"dtri","\u25c2":"ltrif","\u25c3":"ltri","\u25ca":"loz","\u25cb":"cir","\u25ec":"tridot","\u25ef":"xcirc","\u25f8":"ultri","\u25f9":"urtri","\u25fa":"lltri","\u25fb":"EmptySmallSquare","\u25fc":"FilledSmallSquare","\u2605":"starf","\u2606":"star","\u260e":"phone","\u2640":"female","\u2642":"male","\u2660":"spades","\u2663":"clubs","\u2665":"hearts","\u2666":"diams","\u266a":"sung","\u2713":"check","\u2717":"cross","\u2720":"malt","\u2736":"sext","\u2758":"VerticalSeparator","\u27c8":"bsolhsub","\u27c9":"suphsol","\u27f5":"xlarr","\u27f6":"xrarr","\u27f7":"xharr","\u27f8":"xlArr","\u27f9":"xrArr","\u27fa":"xhArr","\u27fc":"xmap","\u27ff":"dzigrarr","\u2902":"nvlArr","\u2903":"nvrArr","\u2904":"nvHarr","\u2905":"Map","\u290c":"lbarr","\u290d":"rbarr","\u290e":"lBarr","\u290f":"rBarr","\u2910":"RBarr","\u2911":"DDotrahd","\u2912":"UpArrowBar","\u2913":"DownArrowBar","\u2916":"Rarrtl","\u2919":"latail","\u291a":"ratail","\u291b":"lAtail","\u291c":"rAtail","\u291d":"larrfs","\u291e":"rarrfs","\u291f":"larrbfs","\u2920":"rarrbfs","\u2923":"nwarhk","\u2924":"nearhk","\u2925":"searhk","\u2926":"swarhk","\u2927":"nwnear","\u2928":"toea","\u2929":"tosa","\u292a":"swnwar","\u2933":"rarrc","\u2933\u0338":"nrarrc","\u2935":"cudarrr","\u2936":"ldca","\u2937":"rdca","\u2938":"cudarrl","\u2939":"larrpl","\u293c":"curarrm","\u293d":"cularrp","\u2945":"rarrpl","\u2948":"harrcir","\u2949":"Uarrocir","\u294a":"lurdshar","\u294b":"ldrushar","\u294e":"LeftRightVector","\u294f":"RightUpDownVector","\u2950":"DownLeftRightVector","\u2951":"LeftUpDownVector","\u2952":"LeftVectorBar","\u2953":"RightVectorBar","\u2954":"RightUpVectorBar","\u2955":"RightDownVectorBar","\u2956":"DownLeftVectorBar","\u2957":"DownRightVectorBar","\u2958":"LeftUpVectorBar","\u2959":"LeftDownVectorBar","\u295a":"LeftTeeVector","\u295b":"RightTeeVector","\u295c":"RightUpTeeVector","\u295d":"RightDownTeeVector","\u295e":"DownLeftTeeVector","\u295f":"DownRightTeeVector","\u2960":"LeftUpTeeVector","\u2961":"LeftDownTeeVector","\u2962":"lHar","\u2963":"uHar","\u2964":"rHar","\u2965":"dHar","\u2966":"luruhar","\u2967":"ldrdhar","\u2968":"ruluhar","\u2969":"rdldhar","\u296a":"lharul","\u296b":"llhard","\u296c":"rharul","\u296d":"lrhard","\u296e":"udhar","\u296f":"duhar","\u2970":"RoundImplies","\u2971":"erarr","\u2972":"simrarr","\u2973":"larrsim","\u2974":"rarrsim","\u2975":"rarrap","\u2976":"ltlarr","\u2978":"gtrarr","\u2979":"subrarr","\u297b":"suplarr","\u297c":"lfisht","\u297d":"rfisht","\u297e":"ufisht","\u297f":"dfisht","\u299a":"vzigzag","\u299c":"vangrt","\u299d":"angrtvbd","\u29a4":"ange","\u29a5":"range","\u29a6":"dwangle","\u29a7":"uwangle","\u29a8":"angmsdaa","\u29a9":"angmsdab","\u29aa":"angmsdac","\u29ab":"angmsdad","\u29ac":"angmsdae","\u29ad":"angmsdaf","\u29ae":"angmsdag","\u29af":"angmsdah","\u29b0":"bemptyv","\u29b1":"demptyv","\u29b2":"cemptyv","\u29b3":"raemptyv","\u29b4":"laemptyv","\u29b5":"ohbar","\u29b6":"omid","\u29b7":"opar","\u29b9":"operp","\u29bb":"olcross","\u29bc":"odsold","\u29be":"olcir","\u29bf":"ofcir","\u29c0":"olt","\u29c1":"ogt","\u29c2":"cirscir","\u29c3":"cirE","\u29c4":"solb","\u29c5":"bsolb","\u29c9":"boxbox","\u29cd":"trisb","\u29ce":"rtriltri","\u29cf":"LeftTriangleBar","\u29cf\u0338":"NotLeftTriangleBar","\u29d0":"RightTriangleBar","\u29d0\u0338":"NotRightTriangleBar","\u29dc":"iinfin","\u29dd":"infintie","\u29de":"nvinfin","\u29e3":"eparsl","\u29e4":"smeparsl","\u29e5":"eqvparsl","\u29eb":"lozf","\u29f4":"RuleDelayed","\u29f6":"dsol","\u2a00":"xodot","\u2a01":"xoplus","\u2a02":"xotime","\u2a04":"xuplus","\u2a06":"xsqcup","\u2a0d":"fpartint","\u2a10":"cirfnint","\u2a11":"awint","\u2a12":"rppolint","\u2a13":"scpolint","\u2a14":"npolint","\u2a15":"pointint","\u2a16":"quatint","\u2a17":"intlarhk","\u2a22":"pluscir","\u2a23":"plusacir","\u2a24":"simplus","\u2a25":"plusdu","\u2a26":"plussim","\u2a27":"plustwo","\u2a29":"mcomma","\u2a2a":"minusdu","\u2a2d":"loplus","\u2a2e":"roplus","\u2a2f":"Cross","\u2a30":"timesd","\u2a31":"timesbar","\u2a33":"smashp","\u2a34":"lotimes","\u2a35":"rotimes","\u2a36":"otimesas","\u2a37":"Otimes","\u2a38":"odiv","\u2a39":"triplus","\u2a3a":"triminus","\u2a3b":"tritime","\u2a3c":"iprod","\u2a3f":"amalg","\u2a40":"capdot","\u2a42":"ncup","\u2a43":"ncap","\u2a44":"capand","\u2a45":"cupor","\u2a46":"cupcap","\u2a47":"capcup","\u2a48":"cupbrcap","\u2a49":"capbrcup","\u2a4a":"cupcup","\u2a4b":"capcap","\u2a4c":"ccups","\u2a4d":"ccaps","\u2a50":"ccupssm","\u2a53":"And","\u2a54":"Or","\u2a55":"andand","\u2a56":"oror","\u2a57":"orslope","\u2a58":"andslope","\u2a5a":"andv","\u2a5b":"orv","\u2a5c":"andd","\u2a5d":"ord","\u2a5f":"wedbar","\u2a66":"sdote","\u2a6a":"simdot","\u2a6d":"congdot","\u2a6d\u0338":"ncongdot","\u2a6e":"easter","\u2a6f":"apacir","\u2a70":"apE","\u2a70\u0338":"napE","\u2a71":"eplus","\u2a72":"pluse","\u2a73":"Esim","\u2a77":"eDDot","\u2a78":"equivDD","\u2a79":"ltcir","\u2a7a":"gtcir","\u2a7b":"ltquest","\u2a7c":"gtquest","\u2a7d":"les","\u2a7d\u0338":"nles","\u2a7e":"ges","\u2a7e\u0338":"nges","\u2a7f":"lesdot","\u2a80":"gesdot","\u2a81":"lesdoto","\u2a82":"gesdoto","\u2a83":"lesdotor","\u2a84":"gesdotol","\u2a85":"lap","\u2a86":"gap","\u2a87":"lne","\u2a88":"gne","\u2a89":"lnap","\u2a8a":"gnap","\u2a8b":"lEg","\u2a8c":"gEl","\u2a8d":"lsime","\u2a8e":"gsime","\u2a8f":"lsimg","\u2a90":"gsiml","\u2a91":"lgE","\u2a92":"glE","\u2a93":"lesges","\u2a94":"gesles","\u2a95":"els","\u2a96":"egs","\u2a97":"elsdot","\u2a98":"egsdot","\u2a99":"el","\u2a9a":"eg","\u2a9d":"siml","\u2a9e":"simg","\u2a9f":"simlE","\u2aa0":"simgE","\u2aa1":"LessLess","\u2aa1\u0338":"NotNestedLessLess","\u2aa2":"GreaterGreater","\u2aa2\u0338":"NotNestedGreaterGreater","\u2aa4":"glj","\u2aa5":"gla","\u2aa6":"ltcc","\u2aa7":"gtcc","\u2aa8":"lescc","\u2aa9":"gescc","\u2aaa":"smt","\u2aab":"lat","\u2aac":"smte","\u2aac\ufe00":"smtes","\u2aad":"late","\u2aad\ufe00":"lates","\u2aae":"bumpE","\u2aaf":"pre","\u2aaf\u0338":"npre","\u2ab0":"sce","\u2ab0\u0338":"nsce","\u2ab3":"prE","\u2ab4":"scE","\u2ab5":"prnE","\u2ab6":"scnE","\u2ab7":"prap","\u2ab8":"scap","\u2ab9":"prnap","\u2aba":"scnap","\u2abb":"Pr","\u2abc":"Sc","\u2abd":"subdot","\u2abe":"supdot","\u2abf":"subplus","\u2ac0":"supplus","\u2ac1":"submult","\u2ac2":"supmult","\u2ac3":"subedot","\u2ac4":"supedot","\u2ac5":"subE","\u2ac5\u0338":"nsubE","\u2ac6":"supE","\u2ac6\u0338":"nsupE","\u2ac7":"subsim","\u2ac8":"supsim","\u2acb\ufe00":"vsubnE","\u2acb":"subnE","\u2acc\ufe00":"vsupnE","\u2acc":"supnE","\u2acf":"csub","\u2ad0":"csup","\u2ad1":"csube","\u2ad2":"csupe","\u2ad3":"subsup","\u2ad4":"supsub","\u2ad5":"subsub","\u2ad6":"supsup","\u2ad7":"suphsub","\u2ad8":"supdsub","\u2ad9":"forkv","\u2ada":"topfork","\u2adb":"mlcp","\u2ae4":"Dashv","\u2ae6":"Vdashl","\u2ae7":"Barv","\u2ae8":"vBar","\u2ae9":"vBarv","\u2aeb":"Vbar","\u2aec":"Not","\u2aed":"bNot","\u2aee":"rnmid","\u2aef":"cirmid","\u2af0":"midcir","\u2af1":"topcir","\u2af2":"nhpar","\u2af3":"parsim","\u2afd":"parsl","\u2afd\u20e5":"nparsl","\u266d":"flat","\u266e":"natur","\u266f":"sharp","\xa4":"curren","\xa2":"cent",$:"dollar","\xa3":"pound","\xa5":"yen","\u20ac":"euro","\xb9":"sup1","\xbd":"half","\u2153":"frac13","\xbc":"frac14","\u2155":"frac15","\u2159":"frac16","\u215b":"frac18","\xb2":"sup2","\u2154":"frac23","\u2156":"frac25","\xb3":"sup3","\xbe":"frac34","\u2157":"frac35","\u215c":"frac38","\u2158":"frac45","\u215a":"frac56","\u215d":"frac58","\u215e":"frac78","\ud835\udcb6":"ascr","\ud835\udd52":"aopf","\ud835\udd1e":"afr","\ud835\udd38":"Aopf","\ud835\udd04":"Afr","\ud835\udc9c":"Ascr","\xaa":"ordf","\xe1":"aacute","\xc1":"Aacute","\xe0":"agrave","\xc0":"Agrave","\u0103":"abreve","\u0102":"Abreve","\xe2":"acirc","\xc2":"Acirc","\xe5":"aring","\xc5":"angst","\xe4":"auml","\xc4":"Auml","\xe3":"atilde","\xc3":"Atilde","\u0105":"aogon","\u0104":"Aogon","\u0101":"amacr","\u0100":"Amacr","\xe6":"aelig","\xc6":"AElig","\ud835\udcb7":"bscr","\ud835\udd53":"bopf","\ud835\udd1f":"bfr","\ud835\udd39":"Bopf","\u212c":"Bscr","\ud835\udd05":"Bfr","\ud835\udd20":"cfr","\ud835\udcb8":"cscr","\ud835\udd54":"copf","\u212d":"Cfr","\ud835\udc9e":"Cscr","\u2102":"Copf","\u0107":"cacute","\u0106":"Cacute","\u0109":"ccirc","\u0108":"Ccirc","\u010d":"ccaron","\u010c":"Ccaron","\u010b":"cdot","\u010a":"Cdot","\xe7":"ccedil","\xc7":"Ccedil","\u2105":"incare","\ud835\udd21":"dfr","\u2146":"dd","\ud835\udd55":"dopf","\ud835\udcb9":"dscr","\ud835\udc9f":"Dscr","\ud835\udd07":"Dfr","\u2145":"DD","\ud835\udd3b":"Dopf","\u010f":"dcaron","\u010e":"Dcaron","\u0111":"dstrok","\u0110":"Dstrok","\xf0":"eth","\xd0":"ETH","\u2147":"ee","\u212f":"escr","\ud835\udd22":"efr","\ud835\udd56":"eopf","\u2130":"Escr","\ud835\udd08":"Efr","\ud835\udd3c":"Eopf","\xe9":"eacute","\xc9":"Eacute","\xe8":"egrave","\xc8":"Egrave","\xea":"ecirc","\xca":"Ecirc","\u011b":"ecaron","\u011a":"Ecaron","\xeb":"euml","\xcb":"Euml","\u0117":"edot","\u0116":"Edot","\u0119":"eogon","\u0118":"Eogon","\u0113":"emacr","\u0112":"Emacr","\ud835\udd23":"ffr","\ud835\udd57":"fopf","\ud835\udcbb":"fscr","\ud835\udd09":"Ffr","\ud835\udd3d":"Fopf","\u2131":"Fscr","\ufb00":"fflig","\ufb03":"ffilig","\ufb04":"ffllig","\ufb01":"filig",fj:"fjlig","\ufb02":"fllig","\u0192":"fnof","\u210a":"gscr","\ud835\udd58":"gopf","\ud835\udd24":"gfr","\ud835\udca2":"Gscr","\ud835\udd3e":"Gopf","\ud835\udd0a":"Gfr","\u01f5":"gacute","\u011f":"gbreve","\u011e":"Gbreve","\u011d":"gcirc","\u011c":"Gcirc","\u0121":"gdot","\u0120":"Gdot","\u0122":"Gcedil","\ud835\udd25":"hfr","\u210e":"planckh","\ud835\udcbd":"hscr","\ud835\udd59":"hopf","\u210b":"Hscr","\u210c":"Hfr","\u210d":"Hopf","\u0125":"hcirc","\u0124":"Hcirc","\u210f":"hbar","\u0127":"hstrok","\u0126":"Hstrok","\ud835\udd5a":"iopf","\ud835\udd26":"ifr","\ud835\udcbe":"iscr","\u2148":"ii","\ud835\udd40":"Iopf","\u2110":"Iscr","\u2111":"Im","\xed":"iacute","\xcd":"Iacute","\xec":"igrave","\xcc":"Igrave","\xee":"icirc","\xce":"Icirc","\xef":"iuml","\xcf":"Iuml","\u0129":"itilde","\u0128":"Itilde","\u0130":"Idot","\u012f":"iogon","\u012e":"Iogon","\u012b":"imacr","\u012a":"Imacr","\u0133":"ijlig","\u0132":"IJlig","\u0131":"imath","\ud835\udcbf":"jscr","\ud835\udd5b":"jopf","\ud835\udd27":"jfr","\ud835\udca5":"Jscr","\ud835\udd0d":"Jfr","\ud835\udd41":"Jopf","\u0135":"jcirc","\u0134":"Jcirc","\u0237":"jmath","\ud835\udd5c":"kopf","\ud835\udcc0":"kscr","\ud835\udd28":"kfr","\ud835\udca6":"Kscr","\ud835\udd42":"Kopf","\ud835\udd0e":"Kfr","\u0137":"kcedil","\u0136":"Kcedil","\ud835\udd29":"lfr","\ud835\udcc1":"lscr","\u2113":"ell","\ud835\udd5d":"lopf","\u2112":"Lscr","\ud835\udd0f":"Lfr","\ud835\udd43":"Lopf","\u013a":"lacute","\u0139":"Lacute","\u013e":"lcaron","\u013d":"Lcaron","\u013c":"lcedil","\u013b":"Lcedil","\u0142":"lstrok","\u0141":"Lstrok","\u0140":"lmidot","\u013f":"Lmidot","\ud835\udd2a":"mfr","\ud835\udd5e":"mopf","\ud835\udcc2":"mscr","\ud835\udd10":"Mfr","\ud835\udd44":"Mopf","\u2133":"Mscr","\ud835\udd2b":"nfr","\ud835\udd5f":"nopf","\ud835\udcc3":"nscr","\u2115":"Nopf","\ud835\udca9":"Nscr","\ud835\udd11":"Nfr","\u0144":"nacute","\u0143":"Nacute","\u0148":"ncaron","\u0147":"Ncaron","\xf1":"ntilde","\xd1":"Ntilde","\u0146":"ncedil","\u0145":"Ncedil","\u2116":"numero","\u014b":"eng","\u014a":"ENG","\ud835\udd60":"oopf","\ud835\udd2c":"ofr","\u2134":"oscr","\ud835\udcaa":"Oscr","\ud835\udd12":"Ofr","\ud835\udd46":"Oopf","\xba":"ordm","\xf3":"oacute","\xd3":"Oacute","\xf2":"ograve","\xd2":"Ograve","\xf4":"ocirc","\xd4":"Ocirc","\xf6":"ouml","\xd6":"Ouml","\u0151":"odblac","\u0150":"Odblac","\xf5":"otilde","\xd5":"Otilde","\xf8":"oslash","\xd8":"Oslash","\u014d":"omacr","\u014c":"Omacr","\u0153":"oelig","\u0152":"OElig","\ud835\udd2d":"pfr","\ud835\udcc5":"pscr","\ud835\udd61":"popf","\u2119":"Popf","\ud835\udd13":"Pfr","\ud835\udcab":"Pscr","\ud835\udd62":"qopf","\ud835\udd2e":"qfr","\ud835\udcc6":"qscr","\ud835\udcac":"Qscr","\ud835\udd14":"Qfr","\u211a":"Qopf","\u0138":"kgreen","\ud835\udd2f":"rfr","\ud835\udd63":"ropf","\ud835\udcc7":"rscr","\u211b":"Rscr","\u211c":"Re","\u211d":"Ropf","\u0155":"racute","\u0154":"Racute","\u0159":"rcaron","\u0158":"Rcaron","\u0157":"rcedil","\u0156":"Rcedil","\ud835\udd64":"sopf","\ud835\udcc8":"sscr","\ud835\udd30":"sfr","\ud835\udd4a":"Sopf","\ud835\udd16":"Sfr","\ud835\udcae":"Sscr","\u24c8":"oS","\u015b":"sacute","\u015a":"Sacute","\u015d":"scirc","\u015c":"Scirc","\u0161":"scaron","\u0160":"Scaron","\u015f":"scedil","\u015e":"Scedil","\xdf":"szlig","\ud835\udd31":"tfr","\ud835\udcc9":"tscr","\ud835\udd65":"topf","\ud835\udcaf":"Tscr","\ud835\udd17":"Tfr","\ud835\udd4b":"Topf","\u0165":"tcaron","\u0164":"Tcaron","\u0163":"tcedil","\u0162":"Tcedil","\u2122":"trade","\u0167":"tstrok","\u0166":"Tstrok","\ud835\udcca":"uscr","\ud835\udd66":"uopf","\ud835\udd32":"ufr","\ud835\udd4c":"Uopf","\ud835\udd18":"Ufr","\ud835\udcb0":"Uscr","\xfa":"uacute","\xda":"Uacute","\xf9":"ugrave","\xd9":"Ugrave","\u016d":"ubreve","\u016c":"Ubreve","\xfb":"ucirc","\xdb":"Ucirc","\u016f":"uring","\u016e":"Uring","\xfc":"uuml","\xdc":"Uuml","\u0171":"udblac","\u0170":"Udblac","\u0169":"utilde","\u0168":"Utilde","\u0173":"uogon","\u0172":"Uogon","\u016b":"umacr","\u016a":"Umacr","\ud835\udd33":"vfr","\ud835\udd67":"vopf","\ud835\udccb":"vscr","\ud835\udd19":"Vfr","\ud835\udd4d":"Vopf","\ud835\udcb1":"Vscr","\ud835\udd68":"wopf","\ud835\udccc":"wscr","\ud835\udd34":"wfr","\ud835\udcb2":"Wscr","\ud835\udd4e":"Wopf","\ud835\udd1a":"Wfr","\u0175":"wcirc","\u0174":"Wcirc","\ud835\udd35":"xfr","\ud835\udccd":"xscr","\ud835\udd69":"xopf","\ud835\udd4f":"Xopf","\ud835\udd1b":"Xfr","\ud835\udcb3":"Xscr","\ud835\udd36":"yfr","\ud835\udcce":"yscr","\ud835\udd6a":"yopf","\ud835\udcb4":"Yscr","\ud835\udd1c":"Yfr","\ud835\udd50":"Yopf","\xfd":"yacute","\xdd":"Yacute","\u0177":"ycirc","\u0176":"Ycirc","\xff":"yuml","\u0178":"Yuml","\ud835\udccf":"zscr","\ud835\udd37":"zfr","\ud835\udd6b":"zopf","\u2128":"Zfr","\u2124":"Zopf","\ud835\udcb5":"Zscr","\u017a":"zacute","\u0179":"Zacute","\u017e":"zcaron","\u017d":"Zcaron","\u017c":"zdot","\u017b":"Zdot","\u01b5":"imped","\xfe":"thorn","\xde":"THORN","\u0149":"napos","\u03b1":"alpha","\u0391":"Alpha","\u03b2":"beta","\u0392":"Beta","\u03b3":"gamma","\u0393":"Gamma","\u03b4":"delta","\u0394":"Delta","\u03b5":"epsi","\u03f5":"epsiv","\u0395":"Epsilon","\u03dd":"gammad","\u03dc":"Gammad","\u03b6":"zeta","\u0396":"Zeta","\u03b7":"eta","\u0397":"Eta","\u03b8":"theta","\u03d1":"thetav","\u0398":"Theta","\u03b9":"iota","\u0399":"Iota","\u03ba":"kappa","\u03f0":"kappav","\u039a":"Kappa","\u03bb":"lambda","\u039b":"Lambda","\u03bc":"mu","\xb5":"micro","\u039c":"Mu","\u03bd":"nu","\u039d":"Nu","\u03be":"xi","\u039e":"Xi","\u03bf":"omicron","\u039f":"Omicron","\u03c0":"pi","\u03d6":"piv","\u03a0":"Pi","\u03c1":"rho","\u03f1":"rhov","\u03a1":"Rho","\u03c3":"sigma","\u03a3":"Sigma","\u03c2":"sigmaf","\u03c4":"tau","\u03a4":"Tau","\u03c5":"upsi","\u03a5":"Upsilon","\u03d2":"Upsi","\u03c6":"phi","\u03d5":"phiv","\u03a6":"Phi","\u03c7":"chi","\u03a7":"Chi","\u03c8":"psi","\u03a8":"Psi","\u03c9":"omega","\u03a9":"ohm","\u0430":"acy","\u0410":"Acy","\u0431":"bcy","\u0411":"Bcy","\u0432":"vcy","\u0412":"Vcy","\u0433":"gcy","\u0413":"Gcy","\u0453":"gjcy","\u0403":"GJcy","\u0434":"dcy","\u0414":"Dcy","\u0452":"djcy","\u0402":"DJcy","\u0435":"iecy","\u0415":"IEcy","\u0451":"iocy","\u0401":"IOcy","\u0454":"jukcy","\u0404":"Jukcy","\u0436":"zhcy","\u0416":"ZHcy","\u0437":"zcy","\u0417":"Zcy","\u0455":"dscy","\u0405":"DScy","\u0438":"icy","\u0418":"Icy","\u0456":"iukcy","\u0406":"Iukcy","\u0457":"yicy","\u0407":"YIcy","\u0439":"jcy","\u0419":"Jcy","\u0458":"jsercy","\u0408":"Jsercy","\u043a":"kcy","\u041a":"Kcy","\u045c":"kjcy","\u040c":"KJcy","\u043b":"lcy","\u041b":"Lcy","\u0459":"ljcy","\u0409":"LJcy","\u043c":"mcy","\u041c":"Mcy","\u043d":"ncy","\u041d":"Ncy","\u045a":"njcy","\u040a":"NJcy","\u043e":"ocy","\u041e":"Ocy","\u043f":"pcy","\u041f":"Pcy","\u0440":"rcy","\u0420":"Rcy","\u0441":"scy","\u0421":"Scy","\u0442":"tcy","\u0422":"Tcy","\u045b":"tshcy","\u040b":"TSHcy","\u0443":"ucy","\u0423":"Ucy","\u045e":"ubrcy","\u040e":"Ubrcy","\u0444":"fcy","\u0424":"Fcy","\u0445":"khcy","\u0425":"KHcy","\u0446":"tscy","\u0426":"TScy","\u0447":"chcy","\u0427":"CHcy","\u045f":"dzcy","\u040f":"DZcy","\u0448":"shcy","\u0428":"SHcy","\u0449":"shchcy","\u0429":"SHCHcy","\u044a":"hardcy","\u042a":"HARDcy","\u044b":"ycy","\u042b":"Ycy","\u044c":"softcy","\u042c":"SOFTcy","\u044d":"ecy","\u042d":"Ecy","\u044e":"yucy","\u042e":"YUcy","\u044f":"yacy","\u042f":"YAcy","\u2135":"aleph","\u2136":"beth","\u2137":"gimel","\u2138":"daleth"},u=/["&'<>`]/g,l={'"':"&quot;","&":"&amp;","'":"&#x27;","<":"&lt;",">":"&gt;","`":"&#x60;"},p=/&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/,f=/[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/,d=/&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g,m={aacute:"\xe1",Aacute:"\xc1",abreve:"\u0103",Abreve:"\u0102",ac:"\u223e",acd:"\u223f",acE:"\u223e\u0333",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",acy:"\u0430",Acy:"\u0410",aelig:"\xe6",AElig:"\xc6",af:"\u2061",afr:"\ud835\udd1e",Afr:"\ud835\udd04",agrave:"\xe0",Agrave:"\xc0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",Alpha:"\u0391",amacr:"\u0101",Amacr:"\u0100",amalg:"\u2a3f",amp:"&",AMP:"&",and:"\u2227",And:"\u2a53",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",ange:"\u29a4",angle:"\u2220",angmsd:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angst:"\xc5",angzarr:"\u237c",aogon:"\u0105",Aogon:"\u0104",aopf:"\ud835\udd52",Aopf:"\ud835\udd38",ap:"\u2248",apacir:"\u2a6f",ape:"\u224a",apE:"\u2a70",apid:"\u224b",apos:"'",ApplyFunction:"\u2061",approx:"\u2248",approxeq:"\u224a",aring:"\xe5",Aring:"\xc5",ascr:"\ud835\udcb6",Ascr:"\ud835\udc9c",Assign:"\u2254",ast:"*",asymp:"\u2248",asympeq:"\u224d",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",awconint:"\u2233",awint:"\u2a11",backcong:"\u224c",backepsilon:"\u03f6",backprime:"\u2035",backsim:"\u223d",backsimeq:"\u22cd",Backslash:"\u2216",Barv:"\u2ae7",barvee:"\u22bd",barwed:"\u2305",Barwed:"\u2306",barwedge:"\u2305",bbrk:"\u23b5",bbrktbrk:"\u23b6",bcong:"\u224c",bcy:"\u0431",Bcy:"\u0411",bdquo:"\u201e",becaus:"\u2235",because:"\u2235",Because:"\u2235",bemptyv:"\u29b0",bepsi:"\u03f6",bernou:"\u212c",Bernoullis:"\u212c",beta:"\u03b2",Beta:"\u0392",beth:"\u2136",between:"\u226c",bfr:"\ud835\udd1f",Bfr:"\ud835\udd05",bigcap:"\u22c2",bigcirc:"\u25ef",bigcup:"\u22c3",bigodot:"\u2a00",bigoplus:"\u2a01",bigotimes:"\u2a02",bigsqcup:"\u2a06",bigstar:"\u2605",bigtriangledown:"\u25bd",bigtriangleup:"\u25b3",biguplus:"\u2a04",bigvee:"\u22c1",bigwedge:"\u22c0",bkarow:"\u290d",blacklozenge:"\u29eb",blacksquare:"\u25aa",blacktriangle:"\u25b4",blacktriangledown:"\u25be",blacktriangleleft:"\u25c2",blacktriangleright:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bNot:"\u2aed",bopf:"\ud835\udd53",Bopf:"\ud835\udd39",bot:"\u22a5",bottom:"\u22a5",bowtie:"\u22c8",boxbox:"\u29c9",boxdl:"\u2510",boxdL:"\u2555",boxDl:"\u2556",boxDL:"\u2557",boxdr:"\u250c",boxdR:"\u2552",boxDr:"\u2553",boxDR:"\u2554",boxh:"\u2500",boxH:"\u2550",boxhd:"\u252c",boxhD:"\u2565",boxHd:"\u2564",boxHD:"\u2566",boxhu:"\u2534",boxhU:"\u2568",boxHu:"\u2567",boxHU:"\u2569",boxminus:"\u229f",boxplus:"\u229e",boxtimes:"\u22a0",boxul:"\u2518",boxuL:"\u255b",boxUl:"\u255c",boxUL:"\u255d",boxur:"\u2514",boxuR:"\u2558",boxUr:"\u2559",boxUR:"\u255a",boxv:"\u2502",boxV:"\u2551",boxvh:"\u253c",boxvH:"\u256a",boxVh:"\u256b",boxVH:"\u256c",boxvl:"\u2524",boxvL:"\u2561",boxVl:"\u2562",boxVL:"\u2563",boxvr:"\u251c",boxvR:"\u255e",boxVr:"\u255f",boxVR:"\u2560",bprime:"\u2035",breve:"\u02d8",Breve:"\u02d8",brvbar:"\xa6",bscr:"\ud835\udcb7",Bscr:"\u212c",bsemi:"\u204f",bsim:"\u223d",bsime:"\u22cd",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bump:"\u224e",bumpe:"\u224f",bumpE:"\u2aae",bumpeq:"\u224f",Bumpeq:"\u224e",cacute:"\u0107",Cacute:"\u0106",cap:"\u2229",Cap:"\u22d2",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",CapitalDifferentialD:"\u2145",caps:"\u2229\ufe00",caret:"\u2041",caron:"\u02c7",Cayleys:"\u212d",ccaps:"\u2a4d",ccaron:"\u010d",Ccaron:"\u010c",ccedil:"\xe7",Ccedil:"\xc7",ccirc:"\u0109",Ccirc:"\u0108",Cconint:"\u2230",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",Cdot:"\u010a",cedil:"\xb8",Cedilla:"\xb8",cemptyv:"\u29b2",cent:"\xa2",centerdot:"\xb7",CenterDot:"\xb7",cfr:"\ud835\udd20",Cfr:"\u212d",chcy:"\u0447",CHcy:"\u0427",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",Chi:"\u03a7",cir:"\u25cb",circ:"\u02c6",circeq:"\u2257",circlearrowleft:"\u21ba",circlearrowright:"\u21bb",circledast:"\u229b",circledcirc:"\u229a",circleddash:"\u229d",CircleDot:"\u2299",circledR:"\xae",circledS:"\u24c8",CircleMinus:"\u2296",CirclePlus:"\u2295",CircleTimes:"\u2297",cire:"\u2257",cirE:"\u29c3",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",ClockwiseContourIntegral:"\u2232",CloseCurlyDoubleQuote:"\u201d",CloseCurlyQuote:"\u2019",clubs:"\u2663",clubsuit:"\u2663",colon:":",Colon:"\u2237",colone:"\u2254",Colone:"\u2a74",coloneq:"\u2254",comma:",",commat:"@",comp:"\u2201",compfn:"\u2218",complement:"\u2201",complexes:"\u2102",cong:"\u2245",congdot:"\u2a6d",Congruent:"\u2261",conint:"\u222e",Conint:"\u222f",ContourIntegral:"\u222e",copf:"\ud835\udd54",Copf:"\u2102",coprod:"\u2210",Coproduct:"\u2210",copy:"\xa9",COPY:"\xa9",copysr:"\u2117",CounterClockwiseContourIntegral:"\u2233",crarr:"\u21b5",cross:"\u2717",Cross:"\u2a2f",cscr:"\ud835\udcb8",Cscr:"\ud835\udc9e",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",cuesc:"\u22df",cularr:"\u21b6",cularrp:"\u293d",cup:"\u222a",Cup:"\u22d3",cupbrcap:"\u2a48",cupcap:"\u2a46",CupCap:"\u224d",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curarrm:"\u293c",curlyeqprec:"\u22de",curlyeqsucc:"\u22df",curlyvee:"\u22ce",curlywedge:"\u22cf",curren:"\xa4",curvearrowleft:"\u21b6",curvearrowright:"\u21b7",cuvee:"\u22ce",cuwed:"\u22cf",cwconint:"\u2232",cwint:"\u2231",cylcty:"\u232d",dagger:"\u2020",Dagger:"\u2021",daleth:"\u2138",darr:"\u2193",dArr:"\u21d3",Darr:"\u21a1",dash:"\u2010",dashv:"\u22a3",Dashv:"\u2ae4",dbkarow:"\u290f",dblac:"\u02dd",dcaron:"\u010f",Dcaron:"\u010e",dcy:"\u0434",Dcy:"\u0414",dd:"\u2146",DD:"\u2145",ddagger:"\u2021",ddarr:"\u21ca",DDotrahd:"\u2911",ddotseq:"\u2a77",deg:"\xb0",Del:"\u2207",delta:"\u03b4",Delta:"\u0394",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",Dfr:"\ud835\udd07",dHar:"\u2965",dharl:"\u21c3",dharr:"\u21c2",DiacriticalAcute:"\xb4",DiacriticalDot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",DiacriticalGrave:"`",DiacriticalTilde:"\u02dc",diam:"\u22c4",diamond:"\u22c4",Diamond:"\u22c4",diamondsuit:"\u2666",diams:"\u2666",die:"\xa8",DifferentialD:"\u2146",digamma:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",DJcy:"\u0402",dlcorn:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",Dopf:"\ud835\udd3b",dot:"\u02d9",Dot:"\xa8",DotDot:"\u20dc",doteq:"\u2250",doteqdot:"\u2251",DotEqual:"\u2250",dotminus:"\u2238",dotplus:"\u2214",dotsquare:"\u22a1",doublebarwedge:"\u2306",DoubleContourIntegral:"\u222f",DoubleDot:"\xa8",DoubleDownArrow:"\u21d3",DoubleLeftArrow:"\u21d0",DoubleLeftRightArrow:"\u21d4",DoubleLeftTee:"\u2ae4",DoubleLongLeftArrow:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",DoubleLongRightArrow:"\u27f9",DoubleRightArrow:"\u21d2",DoubleRightTee:"\u22a8",DoubleUpArrow:"\u21d1",DoubleUpDownArrow:"\u21d5",DoubleVerticalBar:"\u2225",downarrow:"\u2193",Downarrow:"\u21d3",DownArrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",DownBreve:"\u0311",downdownarrows:"\u21ca",downharpoonleft:"\u21c3",downharpoonright:"\u21c2",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",DownTeeArrow:"\u21a7",drbkarow:"\u2910",drcorn:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",Dscr:"\ud835\udc9f",dscy:"\u0455",DScy:"\u0405",dsol:"\u29f6",dstrok:"\u0111",Dstrok:"\u0110",dtdot:"\u22f1",dtri:"\u25bf",dtrif:"\u25be",duarr:"\u21f5",duhar:"\u296f",dwangle:"\u29a6",dzcy:"\u045f",DZcy:"\u040f",dzigrarr:"\u27ff",eacute:"\xe9",Eacute:"\xc9",easter:"\u2a6e",ecaron:"\u011b",Ecaron:"\u011a",ecir:"\u2256",ecirc:"\xea",Ecirc:"\xca",ecolon:"\u2255",ecy:"\u044d",Ecy:"\u042d",eDDot:"\u2a77",edot:"\u0117",eDot:"\u2251",Edot:"\u0116",ee:"\u2147",efDot:"\u2252",efr:"\ud835\udd22",Efr:"\ud835\udd08",eg:"\u2a9a",egrave:"\xe8",Egrave:"\xc8",egs:"\u2a96",egsdot:"\u2a98",el:"\u2a99",Element:"\u2208",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",Emacr:"\u0112",empty:"\u2205",emptyset:"\u2205",EmptySmallSquare:"\u25fb",emptyv:"\u2205",EmptyVerySmallSquare:"\u25ab",emsp:"\u2003",emsp13:"\u2004",emsp14:"\u2005",eng:"\u014b",ENG:"\u014a",ensp:"\u2002",eogon:"\u0119",Eogon:"\u0118",eopf:"\ud835\udd56",Eopf:"\ud835\udd3c",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",Epsilon:"\u0395",epsiv:"\u03f5",eqcirc:"\u2256",eqcolon:"\u2255",eqsim:"\u2242",eqslantgtr:"\u2a96",eqslantless:"\u2a95",Equal:"\u2a75",equals:"=",EqualTilde:"\u2242",equest:"\u225f",Equilibrium:"\u21cc",equiv:"\u2261",equivDD:"\u2a78",eqvparsl:"\u29e5",erarr:"\u2971",erDot:"\u2253",escr:"\u212f",Escr:"\u2130",esdot:"\u2250",esim:"\u2242",Esim:"\u2a73",eta:"\u03b7",Eta:"\u0397",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",euro:"\u20ac",excl:"!",exist:"\u2203",Exists:"\u2203",expectation:"\u2130",exponentiale:"\u2147",ExponentialE:"\u2147",fallingdotseq:"\u2252",fcy:"\u0444",Fcy:"\u0424",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",Ffr:"\ud835\udd09",filig:"\ufb01",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",Fopf:"\ud835\udd3d",forall:"\u2200",ForAll:"\u2200",fork:"\u22d4",forkv:"\u2ad9",Fouriertrf:"\u2131",fpartint:"\u2a0d",frac12:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",fscr:"\ud835\udcbb",Fscr:"\u2131",gacute:"\u01f5",gamma:"\u03b3",Gamma:"\u0393",gammad:"\u03dd",Gammad:"\u03dc",gap:"\u2a86",gbreve:"\u011f",Gbreve:"\u011e",Gcedil:"\u0122",gcirc:"\u011d",Gcirc:"\u011c",gcy:"\u0433",Gcy:"\u0413",gdot:"\u0121",Gdot:"\u0120",ge:"\u2265",gE:"\u2267",gel:"\u22db",gEl:"\u2a8c",geq:"\u2265",geqq:"\u2267",geqslant:"\u2a7e",ges:"\u2a7e",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",Gfr:"\ud835\udd0a",gg:"\u226b",Gg:"\u22d9",ggg:"\u22d9",gimel:"\u2137",gjcy:"\u0453",GJcy:"\u0403",gl:"\u2277",gla:"\u2aa5",glE:"\u2a92",glj:"\u2aa4",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gnE:"\u2269",gneq:"\u2a88",gneqq:"\u2269",gnsim:"\u22e7",gopf:"\ud835\udd58",Gopf:"\ud835\udd3e",grave:"`",GreaterEqual:"\u2265",GreaterEqualLess:"\u22db",GreaterFullEqual:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",GreaterSlantEqual:"\u2a7e",GreaterTilde:"\u2273",gscr:"\u210a",Gscr:"\ud835\udca2",gsim:"\u2273",gsime:"\u2a8e",gsiml:"\u2a90",gt:">",Gt:"\u226b",GT:">",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrapprox:"\u2a86",gtrarr:"\u2978",gtrdot:"\u22d7",gtreqless:"\u22db",gtreqqless:"\u2a8c",gtrless:"\u2277",gtrsim:"\u2273",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",Hacek:"\u02c7",hairsp:"\u200a",half:"\xbd",hamilt:"\u210b",hardcy:"\u044a",HARDcy:"\u042a",harr:"\u2194",hArr:"\u21d4",harrcir:"\u2948",harrw:"\u21ad",Hat:"^",hbar:"\u210f",hcirc:"\u0125",Hcirc:"\u0124",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",Hfr:"\u210c",HilbertSpace:"\u210b",hksearow:"\u2925",hkswarow:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",hookrightarrow:"\u21aa",hopf:"\ud835\udd59",Hopf:"\u210d",horbar:"\u2015",HorizontalLine:"\u2500",hscr:"\ud835\udcbd",Hscr:"\u210b",hslash:"\u210f",hstrok:"\u0127",Hstrok:"\u0126",HumpDownHump:"\u224e",HumpEqual:"\u224f",hybull:"\u2043",hyphen:"\u2010",iacute:"\xed",Iacute:"\xcd",ic:"\u2063",icirc:"\xee",Icirc:"\xce",icy:"\u0438",Icy:"\u0418",Idot:"\u0130",iecy:"\u0435",IEcy:"\u0415",iexcl:"\xa1",iff:"\u21d4",ifr:"\ud835\udd26",Ifr:"\u2111",igrave:"\xec",Igrave:"\xcc",ii:"\u2148",iiiint:"\u2a0c",iiint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",IJlig:"\u0132",Im:"\u2111",imacr:"\u012b",Imacr:"\u012a",image:"\u2111",ImaginaryI:"\u2148",imagline:"\u2110",imagpart:"\u2111",imath:"\u0131",imof:"\u22b7",imped:"\u01b5",Implies:"\u21d2",in:"\u2208",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",inodot:"\u0131",int:"\u222b",Int:"\u222c",intcal:"\u22ba",integers:"\u2124",Integral:"\u222b",intercal:"\u22ba",Intersection:"\u22c2",intlarhk:"\u2a17",intprod:"\u2a3c",InvisibleComma:"\u2063",InvisibleTimes:"\u2062",iocy:"\u0451",IOcy:"\u0401",iogon:"\u012f",Iogon:"\u012e",iopf:"\ud835\udd5a",Iopf:"\ud835\udd40",iota:"\u03b9",Iota:"\u0399",iprod:"\u2a3c",iquest:"\xbf",iscr:"\ud835\udcbe",Iscr:"\u2110",isin:"\u2208",isindot:"\u22f5",isinE:"\u22f9",isins:"\u22f4",isinsv:"\u22f3",isinv:"\u2208",it:"\u2062",itilde:"\u0129",Itilde:"\u0128",iukcy:"\u0456",Iukcy:"\u0406",iuml:"\xef",Iuml:"\xcf",jcirc:"\u0135",Jcirc:"\u0134",jcy:"\u0439",Jcy:"\u0419",jfr:"\ud835\udd27",Jfr:"\ud835\udd0d",jmath:"\u0237",jopf:"\ud835\udd5b",Jopf:"\ud835\udd41",jscr:"\ud835\udcbf",Jscr:"\ud835\udca5",jsercy:"\u0458",Jsercy:"\u0408",jukcy:"\u0454",Jukcy:"\u0404",kappa:"\u03ba",Kappa:"\u039a",kappav:"\u03f0",kcedil:"\u0137",Kcedil:"\u0136",kcy:"\u043a",Kcy:"\u041a",kfr:"\ud835\udd28",Kfr:"\ud835\udd0e",kgreen:"\u0138",khcy:"\u0445",KHcy:"\u0425",kjcy:"\u045c",KJcy:"\u040c",kopf:"\ud835\udd5c",Kopf:"\ud835\udd42",kscr:"\ud835\udcc0",Kscr:"\ud835\udca6",lAarr:"\u21da",lacute:"\u013a",Lacute:"\u0139",laemptyv:"\u29b4",lagran:"\u2112",lambda:"\u03bb",Lambda:"\u039b",lang:"\u27e8",Lang:"\u27ea",langd:"\u2991",langle:"\u27e8",lap:"\u2a85",Laplacetrf:"\u2112",laquo:"\xab",larr:"\u2190",lArr:"\u21d0",Larr:"\u219e",larrb:"\u21e4",larrbfs:"\u291f",larrfs:"\u291d",larrhk:"\u21a9",larrlp:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",lat:"\u2aab",latail:"\u2919",lAtail:"\u291b",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lBarr:"\u290e",lbbrk:"\u2772",lbrace:"{",lbrack:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",Lcaron:"\u013d",lcedil:"\u013c",Lcedil:"\u013b",lceil:"\u2308",lcub:"{",lcy:"\u043b",Lcy:"\u041b",ldca:"\u2936",ldquo:"\u201c",ldquor:"\u201e",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",lE:"\u2266",LeftAngleBracket:"\u27e8",leftarrow:"\u2190",Leftarrow:"\u21d0",LeftArrow:"\u2190",LeftArrowBar:"\u21e4",LeftArrowRightArrow:"\u21c6",leftarrowtail:"\u21a2",LeftCeiling:"\u2308",LeftDoubleBracket:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",leftharpoondown:"\u21bd",leftharpoonup:"\u21bc",leftleftarrows:"\u21c7",leftrightarrow:"\u2194",Leftrightarrow:"\u21d4",LeftRightArrow:"\u2194",leftrightarrows:"\u21c6",leftrightharpoons:"\u21cb",leftrightsquigarrow:"\u21ad",LeftRightVector:"\u294e",LeftTee:"\u22a3",LeftTeeArrow:"\u21a4",LeftTeeVector:"\u295a",leftthreetimes:"\u22cb",LeftTriangle:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",LeftVectorBar:"\u2952",leg:"\u22da",lEg:"\u2a8b",leq:"\u2264",leqq:"\u2266",leqslant:"\u2a7d",les:"\u2a7d",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessapprox:"\u2a85",lessdot:"\u22d6",lesseqgtr:"\u22da",lesseqqgtr:"\u2a8b",LessEqualGreater:"\u22da",LessFullEqual:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",LessLess:"\u2aa1",lesssim:"\u2272",LessSlantEqual:"\u2a7d",LessTilde:"\u2272",lfisht:"\u297c",lfloor:"\u230a",lfr:"\ud835\udd29",Lfr:"\ud835\udd0f",lg:"\u2276",lgE:"\u2a91",lHar:"\u2962",lhard:"\u21bd",lharu:"\u21bc",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",LJcy:"\u0409",ll:"\u226a",Ll:"\u22d8",llarr:"\u21c7",llcorner:"\u231e",Lleftarrow:"\u21da",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",Lmidot:"\u013f",lmoust:"\u23b0",lmoustache:"\u23b0",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lnE:"\u2268",lneq:"\u2a87",lneqq:"\u2268",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",lobrk:"\u27e6",longleftarrow:"\u27f5",Longleftarrow:"\u27f8",LongLeftArrow:"\u27f5",longleftrightarrow:"\u27f7",Longleftrightarrow:"\u27fa",LongLeftRightArrow:"\u27f7",longmapsto:"\u27fc",longrightarrow:"\u27f6",Longrightarrow:"\u27f9",LongRightArrow:"\u27f6",looparrowleft:"\u21ab",looparrowright:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",Lopf:"\ud835\udd43",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",lowbar:"_",LowerLeftArrow:"\u2199",LowerRightArrow:"\u2198",loz:"\u25ca",lozenge:"\u25ca",lozf:"\u29eb",lpar:"(",lparlt:"\u2993",lrarr:"\u21c6",lrcorner:"\u231f",lrhar:"\u21cb",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",Lscr:"\u2112",lsh:"\u21b0",Lsh:"\u21b0",lsim:"\u2272",lsime:"\u2a8d",lsimg:"\u2a8f",lsqb:"[",lsquo:"\u2018",lsquor:"\u201a",lstrok:"\u0142",Lstrok:"\u0141",lt:"<",Lt:"\u226a",LT:"<",ltcc:"\u2aa6",ltcir:"\u2a79",ltdot:"\u22d6",lthree:"\u22cb",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltri:"\u25c3",ltrie:"\u22b4",ltrif:"\u25c2",ltrPar:"\u2996",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",macr:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",map:"\u21a6",Map:"\u2905",mapsto:"\u21a6",mapstodown:"\u21a7",mapstoleft:"\u21a4",mapstoup:"\u21a5",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",Mcy:"\u041c",mdash:"\u2014",mDDot:"\u223a",measuredangle:"\u2221",MediumSpace:"\u205f",Mellintrf:"\u2133",mfr:"\ud835\udd2a",Mfr:"\ud835\udd10",mho:"\u2127",micro:"\xb5",mid:"\u2223",midast:"*",midcir:"\u2af0",middot:"\xb7",minus:"\u2212",minusb:"\u229f",minusd:"\u2238",minusdu:"\u2a2a",MinusPlus:"\u2213",mlcp:"\u2adb",mldr:"\u2026",mnplus:"\u2213",models:"\u22a7",mopf:"\ud835\udd5e",Mopf:"\ud835\udd44",mp:"\u2213",mscr:"\ud835\udcc2",Mscr:"\u2133",mstpos:"\u223e",mu:"\u03bc",Mu:"\u039c",multimap:"\u22b8",mumap:"\u22b8",nabla:"\u2207",nacute:"\u0144",Nacute:"\u0143",nang:"\u2220\u20d2",nap:"\u2249",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",napprox:"\u2249",natur:"\u266e",natural:"\u266e",naturals:"\u2115",nbsp:"\xa0",nbump:"\u224e\u0338",nbumpe:"\u224f\u0338",ncap:"\u2a43",ncaron:"\u0148",Ncaron:"\u0147",ncedil:"\u0146",Ncedil:"\u0145",ncong:"\u2247",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",Ncy:"\u041d",ndash:"\u2013",ne:"\u2260",nearhk:"\u2924",nearr:"\u2197",neArr:"\u21d7",nearrow:"\u2197",nedot:"\u2250\u0338",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",nequiv:"\u2262",nesear:"\u2928",nesim:"\u2242\u0338",NestedGreaterGreater:"\u226b",NestedLessLess:"\u226a",NewLine:"\n",nexist:"\u2204",nexists:"\u2204",nfr:"\ud835\udd2b",Nfr:"\ud835\udd11",nge:"\u2271",ngE:"\u2267\u0338",ngeq:"\u2271",ngeqq:"\u2267\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",nGg:"\u22d9\u0338",ngsim:"\u2275",ngt:"\u226f",nGt:"\u226b\u20d2",ngtr:"\u226f",nGtv:"\u226b\u0338",nharr:"\u21ae",nhArr:"\u21ce",nhpar:"\u2af2",ni:"\u220b",nis:"\u22fc",nisd:"\u22fa",niv:"\u220b",njcy:"\u045a",NJcy:"\u040a",nlarr:"\u219a",nlArr:"\u21cd",nldr:"\u2025",nle:"\u2270",nlE:"\u2266\u0338",nleftarrow:"\u219a",nLeftarrow:"\u21cd",nleftrightarrow:"\u21ae",nLeftrightarrow:"\u21ce",nleq:"\u2270",nleqq:"\u2266\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",nless:"\u226e",nLl:"\u22d8\u0338",nlsim:"\u2274",nlt:"\u226e",nLt:"\u226a\u20d2",nltri:"\u22ea",nltrie:"\u22ec",nLtv:"\u226a\u0338",nmid:"\u2224",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nopf:"\ud835\udd5f",Nopf:"\u2115",not:"\xac",Not:"\u2aec",NotCongruent:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",NotElement:"\u2209",NotEqual:"\u2260",NotEqualTilde:"\u2242\u0338",NotExists:"\u2204",NotGreater:"\u226f",NotGreaterEqual:"\u2271",NotGreaterFullEqual:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",NotGreaterLess:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",NotGreaterTilde:"\u2275",NotHumpDownHump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",notin:"\u2209",notindot:"\u22f5\u0338",notinE:"\u22f9\u0338",notinva:"\u2209",notinvb:"\u22f7",notinvc:"\u22f6",NotLeftTriangle:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",NotLess:"\u226e",NotLessEqual:"\u2270",NotLessGreater:"\u2278",NotLessLess:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",NotLessTilde:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",notni:"\u220c",notniva:"\u220c",notnivb:"\u22fe",notnivc:"\u22fd",NotPrecedes:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",NotReverseElement:"\u220c",NotRightTriangle:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",NotSubset:"\u2282\u20d2",NotSubsetEqual:"\u2288",NotSucceeds:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",NotSupersetEqual:"\u2289",NotTilde:"\u2241",NotTildeEqual:"\u2244",NotTildeFullEqual:"\u2247",NotTildeTilde:"\u2249",NotVerticalBar:"\u2224",npar:"\u2226",nparallel:"\u2226",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",npr:"\u2280",nprcue:"\u22e0",npre:"\u2aaf\u0338",nprec:"\u2280",npreceq:"\u2aaf\u0338",nrarr:"\u219b",nrArr:"\u21cf",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nrightarrow:"\u219b",nRightarrow:"\u21cf",nrtri:"\u22eb",nrtrie:"\u22ed",nsc:"\u2281",nsccue:"\u22e1",nsce:"\u2ab0\u0338",nscr:"\ud835\udcc3",Nscr:"\ud835\udca9",nshortmid:"\u2224",nshortparallel:"\u2226",nsim:"\u2241",nsime:"\u2244",nsimeq:"\u2244",nsmid:"\u2224",nspar:"\u2226",nsqsube:"\u22e2",nsqsupe:"\u22e3",nsub:"\u2284",nsube:"\u2288",nsubE:"\u2ac5\u0338",nsubset:"\u2282\u20d2",nsubseteq:"\u2288",nsubseteqq:"\u2ac5\u0338",nsucc:"\u2281",nsucceq:"\u2ab0\u0338",nsup:"\u2285",nsupe:"\u2289",nsupE:"\u2ac6\u0338",nsupset:"\u2283\u20d2",nsupseteq:"\u2289",nsupseteqq:"\u2ac6\u0338",ntgl:"\u2279",ntilde:"\xf1",Ntilde:"\xd1",ntlg:"\u2278",ntriangleleft:"\u22ea",ntrianglelefteq:"\u22ec",ntriangleright:"\u22eb",ntrianglerighteq:"\u22ed",nu:"\u03bd",Nu:"\u039d",num:"#",numero:"\u2116",numsp:"\u2007",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvDash:"\u22ad",nVdash:"\u22ae",nVDash:"\u22af",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvHarr:"\u2904",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwarhk:"\u2923",nwarr:"\u2196",nwArr:"\u21d6",nwarrow:"\u2196",nwnear:"\u2927",oacute:"\xf3",Oacute:"\xd3",oast:"\u229b",ocir:"\u229a",ocirc:"\xf4",Ocirc:"\xd4",ocy:"\u043e",Ocy:"\u041e",odash:"\u229d",odblac:"\u0151",Odblac:"\u0150",odiv:"\u2a38",odot:"\u2299",odsold:"\u29bc",oelig:"\u0153",OElig:"\u0152",ofcir:"\u29bf",ofr:"\ud835\udd2c",Ofr:"\ud835\udd12",ogon:"\u02db",ograve:"\xf2",Ograve:"\xd2",ogt:"\u29c1",ohbar:"\u29b5",ohm:"\u03a9",oint:"\u222e",olarr:"\u21ba",olcir:"\u29be",olcross:"\u29bb",oline:"\u203e",olt:"\u29c0",omacr:"\u014d",Omacr:"\u014c",omega:"\u03c9",Omega:"\u03a9",omicron:"\u03bf",Omicron:"\u039f",omid:"\u29b6",ominus:"\u2296",oopf:"\ud835\udd60",Oopf:"\ud835\udd46",opar:"\u29b7",OpenCurlyDoubleQuote:"\u201c",OpenCurlyQuote:"\u2018",operp:"\u29b9",oplus:"\u2295",or:"\u2228",Or:"\u2a54",orarr:"\u21bb",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oS:"\u24c8",oscr:"\u2134",Oscr:"\ud835\udcaa",oslash:"\xf8",Oslash:"\xd8",osol:"\u2298",otilde:"\xf5",Otilde:"\xd5",otimes:"\u2297",Otimes:"\u2a37",otimesas:"\u2a36",ouml:"\xf6",Ouml:"\xd6",ovbar:"\u233d",OverBar:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",OverParenthesis:"\u23dc",par:"\u2225",para:"\xb6",parallel:"\u2225",parsim:"\u2af3",parsl:"\u2afd",part:"\u2202",PartialD:"\u2202",pcy:"\u043f",Pcy:"\u041f",percnt:"%",period:".",permil:"\u2030",perp:"\u22a5",pertenk:"\u2031",pfr:"\ud835\udd2d",Pfr:"\ud835\udd13",phi:"\u03c6",Phi:"\u03a6",phiv:"\u03d5",phmmat:"\u2133",phone:"\u260e",pi:"\u03c0",Pi:"\u03a0",pitchfork:"\u22d4",piv:"\u03d6",planck:"\u210f",planckh:"\u210e",plankv:"\u210f",plus:"+",plusacir:"\u2a23",plusb:"\u229e",pluscir:"\u2a22",plusdo:"\u2214",plusdu:"\u2a25",pluse:"\u2a72",PlusMinus:"\xb1",plusmn:"\xb1",plussim:"\u2a26",plustwo:"\u2a27",pm:"\xb1",Poincareplane:"\u210c",pointint:"\u2a15",popf:"\ud835\udd61",Popf:"\u2119",pound:"\xa3",pr:"\u227a",Pr:"\u2abb",prap:"\u2ab7",prcue:"\u227c",pre:"\u2aaf",prE:"\u2ab3",prec:"\u227a",precapprox:"\u2ab7",preccurlyeq:"\u227c",Precedes:"\u227a",PrecedesEqual:"\u2aaf",PrecedesSlantEqual:"\u227c",PrecedesTilde:"\u227e",preceq:"\u2aaf",precnapprox:"\u2ab9",precneqq:"\u2ab5",precnsim:"\u22e8",precsim:"\u227e",prime:"\u2032",Prime:"\u2033",primes:"\u2119",prnap:"\u2ab9",prnE:"\u2ab5",prnsim:"\u22e8",prod:"\u220f",Product:"\u220f",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prop:"\u221d",Proportion:"\u2237",Proportional:"\u221d",propto:"\u221d",prsim:"\u227e",prurel:"\u22b0",pscr:"\ud835\udcc5",Pscr:"\ud835\udcab",psi:"\u03c8",Psi:"\u03a8",puncsp:"\u2008",qfr:"\ud835\udd2e",Qfr:"\ud835\udd14",qint:"\u2a0c",qopf:"\ud835\udd62",Qopf:"\u211a",qprime:"\u2057",qscr:"\ud835\udcc6",Qscr:"\ud835\udcac",quaternions:"\u210d",quatint:"\u2a16",quest:"?",questeq:"\u225f",quot:'"',QUOT:'"',rAarr:"\u21db",race:"\u223d\u0331",racute:"\u0155",Racute:"\u0154",radic:"\u221a",raemptyv:"\u29b3",rang:"\u27e9",Rang:"\u27eb",rangd:"\u2992",range:"\u29a5",rangle:"\u27e9",raquo:"\xbb",rarr:"\u2192",rArr:"\u21d2",Rarr:"\u21a0",rarrap:"\u2975",rarrb:"\u21e5",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrhk:"\u21aa",rarrlp:"\u21ac",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",Rarrtl:"\u2916",rarrw:"\u219d",ratail:"\u291a",rAtail:"\u291c",ratio:"\u2236",rationals:"\u211a",rbarr:"\u290d",rBarr:"\u290f",RBarr:"\u2910",rbbrk:"\u2773",rbrace:"}",rbrack:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",Rcaron:"\u0158",rcedil:"\u0157",Rcedil:"\u0156",rceil:"\u2309",rcub:"}",rcy:"\u0440",Rcy:"\u0420",rdca:"\u2937",rdldhar:"\u2969",rdquo:"\u201d",rdquor:"\u201d",rdsh:"\u21b3",Re:"\u211c",real:"\u211c",realine:"\u211b",realpart:"\u211c",reals:"\u211d",rect:"\u25ad",reg:"\xae",REG:"\xae",ReverseElement:"\u220b",ReverseEquilibrium:"\u21cb",ReverseUpEquilibrium:"\u296f",rfisht:"\u297d",rfloor:"\u230b",rfr:"\ud835\udd2f",Rfr:"\u211c",rHar:"\u2964",rhard:"\u21c1",rharu:"\u21c0",rharul:"\u296c",rho:"\u03c1",Rho:"\u03a1",rhov:"\u03f1",RightAngleBracket:"\u27e9",rightarrow:"\u2192",Rightarrow:"\u21d2",RightArrow:"\u2192",RightArrowBar:"\u21e5",RightArrowLeftArrow:"\u21c4",rightarrowtail:"\u21a3",RightCeiling:"\u2309",RightDoubleBracket:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rightharpoondown:"\u21c1",rightharpoonup:"\u21c0",rightleftarrows:"\u21c4",rightleftharpoons:"\u21cc",rightrightarrows:"\u21c9",rightsquigarrow:"\u219d",RightTee:"\u22a2",RightTeeArrow:"\u21a6",RightTeeVector:"\u295b",rightthreetimes:"\u22cc",RightTriangle:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",RightVectorBar:"\u2953",ring:"\u02da",risingdotseq:"\u2253",rlarr:"\u21c4",rlhar:"\u21cc",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",robrk:"\u27e7",ropar:"\u2986",ropf:"\ud835\udd63",Ropf:"\u211d",roplus:"\u2a2e",rotimes:"\u2a35",RoundImplies:"\u2970",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rrarr:"\u21c9",Rrightarrow:"\u21db",rsaquo:"\u203a",rscr:"\ud835\udcc7",Rscr:"\u211b",rsh:"\u21b1",Rsh:"\u21b1",rsqb:"]",rsquo:"\u2019",rsquor:"\u2019",rthree:"\u22cc",rtimes:"\u22ca",rtri:"\u25b9",rtrie:"\u22b5",rtrif:"\u25b8",rtriltri:"\u29ce",RuleDelayed:"\u29f4",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",Sacute:"\u015a",sbquo:"\u201a",sc:"\u227b",Sc:"\u2abc",scap:"\u2ab8",scaron:"\u0161",Scaron:"\u0160",sccue:"\u227d",sce:"\u2ab0",scE:"\u2ab4",scedil:"\u015f",Scedil:"\u015e",scirc:"\u015d",Scirc:"\u015c",scnap:"\u2aba",scnE:"\u2ab6",scnsim:"\u22e9",scpolint:"\u2a13",scsim:"\u227f",scy:"\u0441",Scy:"\u0421",sdot:"\u22c5",sdotb:"\u22a1",sdote:"\u2a66",searhk:"\u2925",searr:"\u2198",seArr:"\u21d8",searrow:"\u2198",sect:"\xa7",semi:";",seswar:"\u2929",setminus:"\u2216",setmn:"\u2216",sext:"\u2736",sfr:"\ud835\udd30",Sfr:"\ud835\udd16",sfrown:"\u2322",sharp:"\u266f",shchcy:"\u0449",SHCHcy:"\u0429",shcy:"\u0448",SHcy:"\u0428",ShortDownArrow:"\u2193",ShortLeftArrow:"\u2190",shortmid:"\u2223",shortparallel:"\u2225",ShortRightArrow:"\u2192",ShortUpArrow:"\u2191",shy:"\xad",sigma:"\u03c3",Sigma:"\u03a3",sigmaf:"\u03c2",sigmav:"\u03c2",sim:"\u223c",simdot:"\u2a6a",sime:"\u2243",simeq:"\u2243",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",slarr:"\u2190",SmallCircle:"\u2218",smallsetminus:"\u2216",smashp:"\u2a33",smeparsl:"\u29e4",smid:"\u2223",smile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",SOFTcy:"\u042c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",Sopf:"\ud835\udd4a",spades:"\u2660",spadesuit:"\u2660",spar:"\u2225",sqcap:"\u2293",sqcaps:"\u2293\ufe00",sqcup:"\u2294",sqcups:"\u2294\ufe00",Sqrt:"\u221a",sqsub:"\u228f",sqsube:"\u2291",sqsubset:"\u228f",sqsubseteq:"\u2291",sqsup:"\u2290",sqsupe:"\u2292",sqsupset:"\u2290",sqsupseteq:"\u2292",squ:"\u25a1",square:"\u25a1",Square:"\u25a1",SquareIntersection:"\u2293",SquareSubset:"\u228f",SquareSubsetEqual:"\u2291",SquareSuperset:"\u2290",SquareSupersetEqual:"\u2292",SquareUnion:"\u2294",squarf:"\u25aa",squf:"\u25aa",srarr:"\u2192",sscr:"\ud835\udcc8",Sscr:"\ud835\udcae",ssetmn:"\u2216",ssmile:"\u2323",sstarf:"\u22c6",star:"\u2606",Star:"\u22c6",starf:"\u2605",straightepsilon:"\u03f5",straightphi:"\u03d5",strns:"\xaf",sub:"\u2282",Sub:"\u22d0",subdot:"\u2abd",sube:"\u2286",subE:"\u2ac5",subedot:"\u2ac3",submult:"\u2ac1",subne:"\u228a",subnE:"\u2acb",subplus:"\u2abf",subrarr:"\u2979",subset:"\u2282",Subset:"\u22d0",subseteq:"\u2286",subseteqq:"\u2ac5",SubsetEqual:"\u2286",subsetneq:"\u228a",subsetneqq:"\u2acb",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",succ:"\u227b",succapprox:"\u2ab8",succcurlyeq:"\u227d",Succeeds:"\u227b",SucceedsEqual:"\u2ab0",SucceedsSlantEqual:"\u227d",SucceedsTilde:"\u227f",succeq:"\u2ab0",succnapprox:"\u2aba",succneqq:"\u2ab6",succnsim:"\u22e9",succsim:"\u227f",SuchThat:"\u220b",sum:"\u2211",Sum:"\u2211",sung:"\u266a",sup:"\u2283",Sup:"\u22d1",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supdot:"\u2abe",supdsub:"\u2ad8",supe:"\u2287",supE:"\u2ac6",supedot:"\u2ac4",Superset:"\u2283",SupersetEqual:"\u2287",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supne:"\u228b",supnE:"\u2acc",supplus:"\u2ac0",supset:"\u2283",Supset:"\u22d1",supseteq:"\u2287",supseteqq:"\u2ac6",supsetneq:"\u228b",supsetneqq:"\u2acc",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swarhk:"\u2926",swarr:"\u2199",swArr:"\u21d9",swarrow:"\u2199",swnwar:"\u292a",szlig:"\xdf",Tab:"\t",target:"\u2316",tau:"\u03c4",Tau:"\u03a4",tbrk:"\u23b4",tcaron:"\u0165",Tcaron:"\u0164",tcedil:"\u0163",Tcedil:"\u0162",tcy:"\u0442",Tcy:"\u0422",tdot:"\u20db",telrec:"\u2315",tfr:"\ud835\udd31",Tfr:"\ud835\udd17",there4:"\u2234",therefore:"\u2234",Therefore:"\u2234",theta:"\u03b8",Theta:"\u0398",thetasym:"\u03d1",thetav:"\u03d1",thickapprox:"\u2248",thicksim:"\u223c",ThickSpace:"\u205f\u200a",thinsp:"\u2009",ThinSpace:"\u2009",thkap:"\u2248",thksim:"\u223c",thorn:"\xfe",THORN:"\xde",tilde:"\u02dc",Tilde:"\u223c",TildeEqual:"\u2243",TildeFullEqual:"\u2245",TildeTilde:"\u2248",times:"\xd7",timesb:"\u22a0",timesbar:"\u2a31",timesd:"\u2a30",tint:"\u222d",toea:"\u2928",top:"\u22a4",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",Topf:"\ud835\udd4b",topfork:"\u2ada",tosa:"\u2929",tprime:"\u2034",trade:"\u2122",TRADE:"\u2122",triangle:"\u25b5",triangledown:"\u25bf",triangleleft:"\u25c3",trianglelefteq:"\u22b4",triangleq:"\u225c",triangleright:"\u25b9",trianglerighteq:"\u22b5",tridot:"\u25ec",trie:"\u225c",triminus:"\u2a3a",TripleDot:"\u20db",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",Tscr:"\ud835\udcaf",tscy:"\u0446",TScy:"\u0426",tshcy:"\u045b",TSHcy:"\u040b",tstrok:"\u0167",Tstrok:"\u0166",twixt:"\u226c",twoheadleftarrow:"\u219e",twoheadrightarrow:"\u21a0",uacute:"\xfa",Uacute:"\xda",uarr:"\u2191",uArr:"\u21d1",Uarr:"\u219f",Uarrocir:"\u2949",ubrcy:"\u045e",Ubrcy:"\u040e",ubreve:"\u016d",Ubreve:"\u016c",ucirc:"\xfb",Ucirc:"\xdb",ucy:"\u0443",Ucy:"\u0423",udarr:"\u21c5",udblac:"\u0171",Udblac:"\u0170",udhar:"\u296e",ufisht:"\u297e",ufr:"\ud835\udd32",Ufr:"\ud835\udd18",ugrave:"\xf9",Ugrave:"\xd9",uHar:"\u2963",uharl:"\u21bf",uharr:"\u21be",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",Umacr:"\u016a",uml:"\xa8",UnderBar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",UnionPlus:"\u228e",uogon:"\u0173",Uogon:"\u0172",uopf:"\ud835\udd66",Uopf:"\ud835\udd4c",uparrow:"\u2191",Uparrow:"\u21d1",UpArrow:"\u2191",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",updownarrow:"\u2195",Updownarrow:"\u21d5",UpDownArrow:"\u2195",UpEquilibrium:"\u296e",upharpoonleft:"\u21bf",upharpoonright:"\u21be",uplus:"\u228e",UpperLeftArrow:"\u2196",UpperRightArrow:"\u2197",upsi:"\u03c5",Upsi:"\u03d2",upsih:"\u03d2",upsilon:"\u03c5",Upsilon:"\u03a5",UpTee:"\u22a5",UpTeeArrow:"\u21a5",upuparrows:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",Uring:"\u016e",urtri:"\u25f9",uscr:"\ud835\udcca",Uscr:"\ud835\udcb0",utdot:"\u22f0",utilde:"\u0169",Utilde:"\u0168",utri:"\u25b5",utrif:"\u25b4",uuarr:"\u21c8",uuml:"\xfc",Uuml:"\xdc",uwangle:"\u29a7",vangrt:"\u299c",varepsilon:"\u03f5",varkappa:"\u03f0",varnothing:"\u2205",varphi:"\u03d5",varpi:"\u03d6",varpropto:"\u221d",varr:"\u2195",vArr:"\u21d5",varrho:"\u03f1",varsigma:"\u03c2",varsubsetneq:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vartheta:"\u03d1",vartriangleleft:"\u22b2",vartriangleright:"\u22b3",vBar:"\u2ae8",Vbar:"\u2aeb",vBarv:"\u2ae9",vcy:"\u0432",Vcy:"\u0412",vdash:"\u22a2",vDash:"\u22a8",Vdash:"\u22a9",VDash:"\u22ab",Vdashl:"\u2ae6",vee:"\u2228",Vee:"\u22c1",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",verbar:"|",Verbar:"\u2016",vert:"|",Vert:"\u2016",VerticalBar:"\u2223",VerticalLine:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",VeryThinSpace:"\u200a",vfr:"\ud835\udd33",Vfr:"\ud835\udd19",vltri:"\u22b2",vnsub:"\u2282\u20d2",vnsup:"\u2283\u20d2",vopf:"\ud835\udd67",Vopf:"\ud835\udd4d",vprop:"\u221d",vrtri:"\u22b3",vscr:"\ud835\udccb",Vscr:"\ud835\udcb1",vsubne:"\u228a\ufe00",vsubnE:"\u2acb\ufe00",vsupne:"\u228b\ufe00",vsupnE:"\u2acc\ufe00",Vvdash:"\u22aa",vzigzag:"\u299a",wcirc:"\u0175",Wcirc:"\u0174",wedbar:"\u2a5f",wedge:"\u2227",Wedge:"\u22c0",wedgeq:"\u2259",weierp:"\u2118",wfr:"\ud835\udd34",Wfr:"\ud835\udd1a",wopf:"\ud835\udd68",Wopf:"\ud835\udd4e",wp:"\u2118",wr:"\u2240",wreath:"\u2240",wscr:"\ud835\udccc",Wscr:"\ud835\udcb2",xcap:"\u22c2",xcirc:"\u25ef",xcup:"\u22c3",xdtri:"\u25bd",xfr:"\ud835\udd35",Xfr:"\ud835\udd1b",xharr:"\u27f7",xhArr:"\u27fa",xi:"\u03be",Xi:"\u039e",xlarr:"\u27f5",xlArr:"\u27f8",xmap:"\u27fc",xnis:"\u22fb",xodot:"\u2a00",xopf:"\ud835\udd69",Xopf:"\ud835\udd4f",xoplus:"\u2a01",xotime:"\u2a02",xrarr:"\u27f6",xrArr:"\u27f9",xscr:"\ud835\udccd",Xscr:"\ud835\udcb3",xsqcup:"\u2a06",xuplus:"\u2a04",xutri:"\u25b3",xvee:"\u22c1",xwedge:"\u22c0",yacute:"\xfd",Yacute:"\xdd",yacy:"\u044f",YAcy:"\u042f",ycirc:"\u0177",Ycirc:"\u0176",ycy:"\u044b",Ycy:"\u042b",yen:"\xa5",yfr:"\ud835\udd36",Yfr:"\ud835\udd1c",yicy:"\u0457",YIcy:"\u0407",yopf:"\ud835\udd6a",Yopf:"\ud835\udd50",yscr:"\ud835\udcce",Yscr:"\ud835\udcb4",yucy:"\u044e",YUcy:"\u042e",yuml:"\xff",Yuml:"\u0178",zacute:"\u017a",Zacute:"\u0179",zcaron:"\u017e",Zcaron:"\u017d",zcy:"\u0437",Zcy:"\u0417",zdot:"\u017c",Zdot:"\u017b",zeetrf:"\u2128",ZeroWidthSpace:"\u200b",zeta:"\u03b6",Zeta:"\u0396",zfr:"\ud835\udd37",Zfr:"\u2128",zhcy:"\u0436",ZHcy:"\u0416",zigrarr:"\u21dd",zopf:"\ud835\udd6b",Zopf:"\u2124",zscr:"\ud835\udccf",Zscr:"\ud835\udcb5",zwj:"\u200d",zwnj:"\u200c"},h={aacute:"\xe1",Aacute:"\xc1",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",aelig:"\xe6",AElig:"\xc6",agrave:"\xe0",Agrave:"\xc0",amp:"&",AMP:"&",aring:"\xe5",Aring:"\xc5",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",brvbar:"\xa6",ccedil:"\xe7",Ccedil:"\xc7",cedil:"\xb8",cent:"\xa2",copy:"\xa9",COPY:"\xa9",curren:"\xa4",deg:"\xb0",divide:"\xf7",eacute:"\xe9",Eacute:"\xc9",ecirc:"\xea",Ecirc:"\xca",egrave:"\xe8",Egrave:"\xc8",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",frac12:"\xbd",frac14:"\xbc",frac34:"\xbe",gt:">",GT:">",iacute:"\xed",Iacute:"\xcd",icirc:"\xee",Icirc:"\xce",iexcl:"\xa1",igrave:"\xec",Igrave:"\xcc",iquest:"\xbf",iuml:"\xef",Iuml:"\xcf",laquo:"\xab",lt:"<",LT:"<",macr:"\xaf",micro:"\xb5",middot:"\xb7",nbsp:"\xa0",not:"\xac",ntilde:"\xf1",Ntilde:"\xd1",oacute:"\xf3",Oacute:"\xd3",ocirc:"\xf4",Ocirc:"\xd4",ograve:"\xf2",Ograve:"\xd2",ordf:"\xaa",ordm:"\xba",oslash:"\xf8",Oslash:"\xd8",otilde:"\xf5",Otilde:"\xd5",ouml:"\xf6",Ouml:"\xd6",para:"\xb6",plusmn:"\xb1",pound:"\xa3",quot:'"',QUOT:'"',raquo:"\xbb",reg:"\xae",REG:"\xae",sect:"\xa7",shy:"\xad",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",szlig:"\xdf",thorn:"\xfe",THORN:"\xde",times:"\xd7",uacute:"\xfa",Uacute:"\xda",ucirc:"\xfb",Ucirc:"\xdb",ugrave:"\xf9",Ugrave:"\xd9",uml:"\xa8",uuml:"\xfc",Uuml:"\xdc",yacute:"\xfd",Yacute:"\xdd",yen:"\xa5",yuml:"\xff"},v={0:"\ufffd",128:"\u20ac",130:"\u201a",131:"\u0192",132:"\u201e",133:"\u2026",134:"\u2020",135:"\u2021",136:"\u02c6",137:"\u2030",138:"\u0160",139:"\u2039",140:"\u0152",142:"\u017d",145:"\u2018",146:"\u2019",147:"\u201c",148:"\u201d",149:"\u2022",150:"\u2013",151:"\u2014",152:"\u02dc",153:"\u2122",154:"\u0161",155:"\u203a",156:"\u0153",158:"\u017e",159:"\u0178"},g=[1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65e3,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111],b=String.fromCharCode,y={}.hasOwnProperty,w=function(e,r){return y.call(e,r)},A=function(e,r){if(!e)return r;var t,n={};for(t in r)n[t]=w(e,t)?e[t]:r[t];return n},D=function(e,r){var t="";return e>=55296&&e<=57343||e>1114111?(r&&k("character reference outside the permissible Unicode range"),"\ufffd"):w(v,e)?(r&&k("disallowed character reference"),v[e]):(r&&function(e,r){for(var t=-1,n=e.length;++t<n;)if(e[t]==r)return!0;return!1}(g,e)&&k("disallowed character reference"),e>65535&&(t+=b((e-=65536)>>>10&1023|55296),e=56320|1023&e),t+=b(e))},x=function(e){return"&#x"+e.toString(16).toUpperCase()+";"},q=function(e){return"&#"+e+";"},k=function(e){throw Error("Parse error: "+e)},E=function(e,r){(r=A(r,E.options)).strict&&f.test(e)&&k("forbidden code point");var t=r.encodeEverything,n=r.useNamedReferences,l=r.allowUnsafeSymbols,p=r.decimal?q:x,d=function(e){return p(e.charCodeAt(0))};return t?(e=e.replace(o,function(e){return n&&w(c,e)?"&"+c[e]+";":d(e)}),n&&(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;").replace(/&#x66;&#x6A;/g,"&fjlig;")),n&&(e=e.replace(s,function(e){return"&"+c[e]+";"}))):n?(l||(e=e.replace(u,function(e){return"&"+c[e]+";"})),e=(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;")).replace(s,function(e){return"&"+c[e]+";"})):l||(e=e.replace(u,d)),e.replace(a,function(e){var r=e.charCodeAt(0),t=e.charCodeAt(1);return p(1024*(r-55296)+t-56320+65536)}).replace(i,d)};E.options={allowUnsafeSymbols:!1,encodeEverything:!1,strict:!1,useNamedReferences:!1,decimal:!1};var _=function(e,r){var t=(r=A(r,_.options)).strict;return t&&p.test(e)&&k("malformed character reference"),e.replace(d,function(e,n,a,o,i,s,c,u,l){var p,f,d,v,g,b;return n?m[g=n]:a?(g=a,(b=o)&&r.isAttributeValue?(t&&"="==b&&k("`&` did not start a character reference"),e):(t&&k("named character reference was not terminated by a semicolon"),h[g]+(b||""))):i?(d=i,f=s,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(d,10),D(p,t)):c?(v=c,f=u,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(v,16),D(p,t)):(t&&k("named character reference was not terminated by a semicolon"),e)})};_.options={isAttributeValue:!1,strict:!1};var C={version:"1.2.0",encode:E,decode:_,escape:function(e){return e.replace(u,function(e){return l[e]})},unescape:_};if("function"==typeof define&&"object"==typeof define.amd&&define.amd)define(function(){return C});else if(r&&!r.nodeType)if(t)t.exports=C;else for(var S in C)w(C,S)&&(r[S]=C[S]);else e.he=C}(void 0);var yo=f("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),wo=f("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Ao=f("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Do=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,qo="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+U.source+"]*",ko="((?:"+qo+"\\:)?"+qo+")",Eo=new RegExp("^<"+ko),_o=/^\s*(\/?)>/,Co=new RegExp("^<\\/"+ko+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,Lo=/^<!\--/,To=/^<!\[/,$o=f("script,style,textarea",!0),No={},Oo={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ro=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Bo=f("pre,textarea",!0),Uo=function(e,r){return e&&Bo(e)&&"\n"===r[0]};function Vo(e,r){var t=r?Fo:Ro;return e.replace(t,function(e){return Oo[e]})}var Io,jo,Po,Ho,Mo,Go,zo,Jo,Ko=/^@|^v-on:/,Zo=/^v-|^@|^:|^#/,Yo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Wo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,Xo=/^\[.*\]$/,ei=/:(.*)$/,ri=/^:|^\.|^v-bind:/,ti=/\.[^.\]]+(?=[^\]]*$)/g,ni=/^v-slot(:|$)|^#/,ai=/[\r\n]/,oi=/[ \f\t\r\n]+/g,ii=b(void 0),si="_empty_";function ci(e,r,t){return{type:1,tag:e,attrsList:r,attrsMap:hi(r),rawAttrsMap:{},parent:t,children:[]}}function ui(e,r){Io=r.warn||Sn,Go=r.isPreTag||S,zo=r.mustUseProp||S,Jo=r.getTagNamespace||S;r.isReservedTag;Po=Ln(r.modules,"transformNode"),Ho=Ln(r.modules,"preTransformNode"),Mo=Ln(r.modules,"postTransformNode"),jo=r.delimiters;var t,n,a=[],o=!1!==r.preserveWhitespace,i=r.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=li(e,r)),a.length||e===t||t.if&&(e.elseif||e.else)&&fi(t,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)i=e,(u=function(e){var r=e.length;for(;r--;){if(1===e[r].type)return e[r];e.pop()}}(n.children))&&u.if&&fi(u,{exp:i.elseif,block:i});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var i,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Go(e.tag)&&(c=!1);for(var p=0;p<Mo.length;p++)Mo[p](e,r)}function l(e){if(!c)for(var r;(r=e.children[e.children.length-1])&&3===r.type&&" "===r.text;)e.children.pop()}return function(e,r){for(var t,n,a=[],o=r.expectHTML,i=r.isUnaryTag||S,s=r.canBeLeftOpenTag||S,c=0;e;){if(t=e,n&&$o(n)){var u=0,l=n.toLowerCase(),p=No[l]||(No[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),f=e.replace(p,function(e,t,n){return u=n.length,$o(l)||"noscript"===l||(t=t.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Uo(l,t)&&(t=t.slice(1)),r.chars&&r.chars(t),""});c+=e.length-f.length,e=f,E(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(Lo.test(e)){var m=e.indexOf("--\x3e");if(m>=0){r.shouldKeepComment&&r.comment(e.substring(4,m),c,c+m+3),x(m+3);continue}}if(To.test(e)){var h=e.indexOf("]>");if(h>=0){x(h+2);continue}}var v=e.match(So);if(v){x(v[0].length);continue}var g=e.match(Co);if(g){var b=c;x(g[0].length),E(g[1],b,c);continue}var y=q();if(y){k(y),Uo(y.tagName,e)&&x(1);continue}}var w=void 0,A=void 0,D=void 0;if(d>=0){for(A=e.slice(d);!(Co.test(A)||Eo.test(A)||Lo.test(A)||To.test(A)||(D=A.indexOf("<",1))<0);)d+=D,A=e.slice(d);w=e.substring(0,d)}d<0&&(w=e),w&&x(w.length),r.chars&&w&&r.chars(w,c-w.length,c)}if(e===t){r.chars&&r.chars(e);break}}function x(r){c+=r,e=e.substring(r)}function q(){var r=e.match(Eo);if(r){var t,n,a={tagName:r[1],attrs:[],start:c};for(x(r[0].length);!(t=e.match(_o))&&(n=e.match(xo)||e.match(Do));)n.start=c,x(n[0].length),n.end=c,a.attrs.push(n);if(t)return a.unarySlash=t[1],x(t[0].length),a.end=c,a}}function k(e){var t=e.tagName,c=e.unarySlash;o&&("p"===n&&Ao(t)&&E(n),s(t)&&n===t&&E(t));for(var u=i(t)||!!c,l=e.attrs.length,p=new Array(l),f=0;f<l;f++){var d=e.attrs[f],m=d[3]||d[4]||d[5]||"",h="a"===t&&"href"===d[1]?r.shouldDecodeNewlinesForHref:r.shouldDecodeNewlines;p[f]={name:d[1],value:Vo(m,h)}}u||(a.push({tag:t,lowerCasedTag:t.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=t),r.start&&r.start(t,p,u,e.start,e.end)}function E(e,t,o){var i,s;if(null==t&&(t=c),null==o&&(o=c),e)for(s=e.toLowerCase(),i=a.length-1;i>=0&&a[i].lowerCasedTag!==s;i--);else i=0;if(i>=0){for(var u=a.length-1;u>=i;u--)r.end&&r.end(a[u].tag,t,o);a.length=i,n=i&&a[i-1].tag}else"br"===s?r.start&&r.start(e,[],!0,t,o):"p"===s&&(r.start&&r.start(e,[],!1,t,o),r.end&&r.end(e,t,o))}E()}(e,{warn:Io,expectHTML:r.expectHTML,isUnaryTag:r.isUnaryTag,canBeLeftOpenTag:r.canBeLeftOpenTag,shouldDecodeNewlines:r.shouldDecodeNewlines,shouldDecodeNewlinesForHref:r.shouldDecodeNewlinesForHref,shouldKeepComment:r.comments,outputSourceRange:r.outputSourceRange,start:function(e,o,i,l,p){var f=n&&n.ns||Jo(e);J&&"svg"===f&&(o=function(e){for(var r=[],t=0;t<e.length;t++){var n=e[t];vi.test(n.name)||(n.name=n.name.replace(gi,""),r.push(n))}return r}(o));var d,m=ci(e,o,n);f&&(m.ns=f),"style"!==(d=m).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||re()||(m.forbidden=!0);for(var h=0;h<Ho.length;h++)m=Ho[h](m,r)||m;s||(!function(e){null!=Un(e,"v-pre")&&(e.pre=!0)}(m),m.pre&&(s=!0)),Go(m.tag)&&(c=!0),s?function(e){var r=e.attrsList,t=r.length;if(t)for(var n=e.attrs=new Array(t),a=0;a<t;a++)n[a]={name:r[a].name,value:JSON.stringify(r[a].value)},null!=r[a].start&&(n[a].start=r[a].start,n[a].end=r[a].end);else e.pre||(e.plain=!0)}(m):m.processed||(pi(m),function(e){var r=Un(e,"v-if");if(r)e.if=r,fi(e,{exp:r,block:e});else{null!=Un(e,"v-else")&&(e.else=!0);var t=Un(e,"v-else-if");t&&(e.elseif=t)}}(m),function(e){null!=Un(e,"v-once")&&(e.once=!0)}(m)),t||(t=m),i?u(m):(n=m,a.push(m))},end:function(e,r,t){var o=a[a.length-1];a.length-=1,n=a[a.length-1],u(o)},chars:function(e,r,t){if(n&&(!J||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var a,u,l,p=n.children;if(e=c||e.trim()?"script"===(a=n).tag||"style"===a.tag?e:ii(e):p.length?i?"condense"===i&&ai.test(e)?"":" ":o?" ":"":"")c||"condense"!==i||(e=e.replace(oi," ")),!s&&" "!==e&&(u=function(e,r){var t=r?vo(r):mo;if(t.test(e)){for(var n,a,o,i=[],s=[],c=t.lastIndex=0;n=t.exec(e);){(a=n.index)>c&&(s.push(o=e.slice(c,a)),i.push(JSON.stringify(o)));var u=_n(n[1].trim());i.push("_s("+u+")"),s.push({"@binding":u}),c=a+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),i.push(JSON.stringify(o))),{expression:i.join("+"),tokens:s}}}(e,jo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&p.length&&" "===p[p.length-1].text||(l={type:3,text:e}),l&&p.push(l)}},comment:function(e,r,t){if(n){var a={type:3,text:e,isComment:!0};n.children.push(a)}}}),t}function li(e,r){var t,n;(n=Bn(t=e,"key"))&&(t.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var r=Bn(e,"ref");r&&(e.ref=r,e.refInFor=function(e){var r=e;for(;r;){if(void 0!==r.for)return!0;r=r.parent}return!1}(e))}(e),function(e){var r;"template"===e.tag?(r=Un(e,"scope"),e.slotScope=r||Un(e,"slot-scope")):(r=Un(e,"slot-scope"))&&(e.slotScope=r);var t=Bn(e,"slot");t&&(e.slotTarget='""'===t?'"default"':t,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||$n(e,"slot",t,function(e,r){return e.rawAttrsMap[":"+r]||e.rawAttrsMap["v-bind:"+r]||e.rawAttrsMap[r]}(e,"slot")));if("template"===e.tag){var n=Vn(e,ni);if(n){var a=di(n),o=a.name,i=a.dynamic;e.slotTarget=o,e.slotTargetDynamic=i,e.slotScope=n.value||si}}else{var s=Vn(e,ni);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=di(s),l=u.name,p=u.dynamic,f=c[l]=ci("template",[],e);f.slotTarget=l,f.slotTargetDynamic=p,f.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=f,!0}),f.slotScope=s.value||si,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Bn(e,"name"))}(e),function(e){var r;(r=Bn(e,"is"))&&(e.component=r);null!=Un(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var a=0;a<Po.length;a++)e=Po[a](e,r)||e;return function(e){var r,t,n,a,o,i,s,c,u=e.attrsList;for(r=0,t=u.length;r<t;r++)if(n=a=u[r].name,o=u[r].value,Zo.test(n))if(e.hasBindings=!0,(i=mi(n.replace(Zo,"")))&&(n=n.replace(ti,"")),ri.test(n))n=n.replace(ri,""),o=_n(o),(c=Xo.test(n))&&(n=n.slice(1,-1)),i&&(i.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),i.camel&&!c&&(n=w(n)),i.sync&&(s=Pn(o,"$event"),c?Fn(e,'"update:"+('+n+")",s,null,!1,0,u[r],!0):(Fn(e,"update:"+w(n),s,null,!1,0,u[r]),x(n)!==w(n)&&Fn(e,"update:"+x(n),s,null,!1,0,u[r])))),i&&i.prop||!e.component&&zo(e.tag,e.attrsMap.type,n)?Tn(e,n,o,u[r],c):$n(e,n,o,u[r],c);else if(Ko.test(n))n=n.replace(Ko,""),(c=Xo.test(n))&&(n=n.slice(1,-1)),Fn(e,n,o,i,!1,0,u[r],c);else{var l=(n=n.replace(Zo,"")).match(ei),p=l&&l[1];c=!1,p&&(n=n.slice(0,-(p.length+1)),Xo.test(p)&&(p=p.slice(1,-1),c=!0)),On(e,n,a,o,p,c,i,u[r])}else $n(e,n,JSON.stringify(o),u[r]),!e.component&&"muted"===n&&zo(e.tag,e.attrsMap.type,n)&&Tn(e,n,"true",u[r])}(e),e}function pi(e){var r;if(r=Un(e,"v-for")){var t=function(e){var r=e.match(Yo);if(!r)return;var t={};t.for=r[2].trim();var n=r[1].trim().replace(Qo,""),a=n.match(Wo);a?(t.alias=n.replace(Wo,"").trim(),t.iterator1=a[1].trim(),a[2]&&(t.iterator2=a[2].trim())):t.alias=n;return t}(r);t&&E(e,t)}}function fi(e,r){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(r)}function di(e){var r=e.name.replace(ni,"");return r||"#"!==e.name[0]&&(r="default"),Xo.test(r)?{name:r.slice(1,-1),dynamic:!0}:{name:'"'+r+'"',dynamic:!1}}function mi(e){var r=e.match(ti);if(r){var t={};return r.forEach(function(e){t[e.slice(1)]=!0}),t}}function hi(e){for(var r={},t=0,n=e.length;t<n;t++)r[e[t].name]=e[t].value;return r}var vi=/^xmlns:NS\d+/,gi=/^NS\d+:/;function bi(e){return ci(e.tag,e.attrsList.slice(),e.parent)}var yi=[go,bo,{preTransformNode:function(e,r){if("input"===e.tag){var t,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(t=Bn(e,"type")),n.type||t||!n["v-bind"]||(t="("+n["v-bind"]+").type"),t){var a=Un(e,"v-if",!0),o=a?"&&("+a+")":"",i=null!=Un(e,"v-else",!0),s=Un(e,"v-else-if",!0),c=bi(e);pi(c),Nn(c,"type","checkbox"),li(c,r),c.processed=!0,c.if="("+t+")==='checkbox'"+o,fi(c,{exp:c.if,block:c});var u=bi(e);Un(u,"v-for",!0),Nn(u,"type","radio"),li(u,r),fi(c,{exp:"("+t+")==='radio'"+o,block:u});var l=bi(e);return Un(l,"v-for",!0),Nn(l,":type",t),li(l,r),fi(c,{exp:a,block:l}),i?c.else=!0:s&&(c.elseif=s),c}}}}];var wi,Ai,Di={expectHTML:!0,modules:yi,directives:{model:function(e,r,t){var n=r.value,a=r.modifiers,o=e.tag,i=e.attrsMap.type;if(e.component)return jn(e,n,a),!1;if("select"===o)!function(e,r,t){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(t&&t.number?"_n(val)":"val")+"});";n=n+" "+Pn(r,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Fn(e,"change",n,null,!0)}(e,n,a);else if("input"===o&&"checkbox"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null",o=Bn(e,"true-value")||"true",i=Bn(e,"false-value")||"false";Tn(e,"checked","Array.isArray("+r+")?_i("+r+","+a+")>-1"+("true"===o?":("+r+")":":_q("+r+","+o+")")),Fn(e,"change","var $$a="+r+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+i+");if(Array.isArray($$a)){var $$v="+(n?"_n("+a+")":a)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pn(r,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pn(r,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pn(r,"$$c")+"}",null,!0)}(e,n,a);else if("input"===o&&"radio"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null";Tn(e,"checked","_q("+r+","+(a=n?"_n("+a+")":a)+")"),Fn(e,"change",Pn(r,a),null,!0)}(e,n,a);else if("input"===o||"textarea"===o)!function(e,r,t){var n=e.attrsMap.type,a=t||{},o=a.lazy,i=a.number,s=a.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Zn:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),i&&(l="_n("+l+")");var p=Pn(r,l);c&&(p="if($event.target.composing)return;"+p),Tn(e,"value","("+r+")"),Fn(e,u,p,null,!0),(s||i)&&Fn(e,"blur","$forceUpdate()")}(e,n,a);else if(!B.isReservedTag(o))return jn(e,n,a),!1;return!0},text:function(e,r){r.value&&Tn(e,"textContent","_s("+r.value+")",r)},html:function(e,r){r.value&&Tn(e,"innerHTML","_s("+r.value+")",r)}},isPreTag:function(e){return"pre"===e},isUnaryTag:yo,mustUseProp:$t,canBeLeftOpenTag:wo,isReservedTag:Kt,getTagNamespace:Zt,staticKeys:function(e){return e.reduce(function(e,r){return e.concat(r.staticKeys||[])},[]).join(",")}(yi)},xi=b(function(e){return f("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function qi(e,r){e&&(wi=xi(r.staticKeys||""),Ai=r.isReservedTag||S,function e(r){r.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Ai(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(wi)))}(r);if(1===r.type){if(!Ai(r.tag)&&"slot"!==r.tag&&null==r.attrsMap["inline-template"])return;for(var t=0,n=r.children.length;t<n;t++){var a=r.children[t];e(a),a.static||(r.static=!1)}if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++){var s=r.ifConditions[o].block;e(s),s.static||(r.static=!1)}}}(e),function e(r,t){if(1===r.type){if((r.static||r.once)&&(r.staticInFor=t),r.static&&r.children.length&&(1!==r.children.length||3!==r.children[0].type))return void(r.staticRoot=!0);if(r.staticRoot=!1,r.children)for(var n=0,a=r.children.length;n<a;n++)e(r.children[n],t||!!r.for);if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++)e(r.ifConditions[o].block,t)}}(e,!1))}var ki=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ei=/\([^)]*?\);*$/,_i=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Si={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Li=function(e){return"if("+e+")return null;"},Ti={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Li("$event.target !== $event.currentTarget"),ctrl:Li("!$event.ctrlKey"),shift:Li("!$event.shiftKey"),alt:Li("!$event.altKey"),meta:Li("!$event.metaKey"),left:Li("'button' in $event && $event.button !== 0"),middle:Li("'button' in $event && $event.button !== 1"),right:Li("'button' in $event && $event.button !== 2")};function $i(e,r){var t=r?"nativeOn:":"on:",n="",a="";for(var o in e){var i=Ni(e[o]);e[o]&&e[o].dynamic?a+=o+","+i+",":n+='"'+o+'":'+i+","}return n="{"+n.slice(0,-1)+"}",a?t+"_d("+n+",["+a.slice(0,-1)+"])":t+n}function Ni(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Ni(e)}).join(",")+"]";var r=_i.test(e.value),t=ki.test(e.value),n=_i.test(e.value.replace(Ei,""));if(e.modifiers){var a="",o="",i=[];for(var s in e.modifiers)if(Ti[s])o+=Ti[s],Ci[s]&&i.push(s);else if("exact"===s){var c=e.modifiers;o+=Li(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else i.push(s);return i.length&&(a+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Oi).join("&&")+")return null;"}(i)),o&&(a+=o),"function($event){"+a+(r?"return "+e.value+".apply(null, arguments)":t?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return r||t?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function Oi(e){var r=parseInt(e,10);if(r)return"$event.keyCode!=="+r;var t=Ci[e],n=Si[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(t)+",$event.key,"+JSON.stringify(n)+")"}var Ri={on:function(e,r){e.wrapListeners=function(e){return"_g("+e+","+r.value+")"}},bind:function(e,r){e.wrapData=function(t){return"_b("+t+",'"+e.tag+"',"+r.value+","+(r.modifiers&&r.modifiers.prop?"true":"false")+(r.modifiers&&r.modifiers.sync?",true":"")+")"}},cloak:C},Fi=function(e){this.options=e,this.warn=e.warn||Sn,this.transforms=Ln(e.modules,"transformCode"),this.dataGenFns=Ln(e.modules,"genData"),this.directives=E(E({},Ri),e.directives);var r=e.isReservedTag||S;this.maybeComponent=function(e){return!!e.component||!r(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Bi(e,r){var t=new Fi(r);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ui(e,t):'_c("div")')+"}",staticRenderFns:t.staticRenderFns}}function Ui(e,r){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Vi(e,r);if(e.once&&!e.onceProcessed)return Ii(e,r);if(e.for&&!e.forProcessed)return Pi(e,r);if(e.if&&!e.ifProcessed)return ji(e,r);if("template"!==e.tag||e.slotTarget||r.pre){if("slot"===e.tag)return function(e,r){var t=e.slotName||'"default"',n=zi(e,r),a="_t("+t+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Zi((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,i=e.attrsMap["v-bind"];!o&&!i||n||(a+=",null");o&&(a+=","+o);i&&(a+=(o?"":",null")+","+i);return a+")"}(e,r);var t;if(e.component)t=function(e,r,t){var n=r.inlineTemplate?null:zi(r,t,!0);return"_c("+e+","+Hi(r,t)+(n?","+n:"")+")"}(e.component,e,r);else{var n;(!e.plain||e.pre&&r.maybeComponent(e))&&(n=Hi(e,r));var a=e.inlineTemplate?null:zi(e,r,!0);t="_c('"+e.tag+"'"+(n?","+n:"")+(a?","+a:"")+")"}for(var o=0;o<r.transforms.length;o++)t=r.transforms[o](e,t);return t}return zi(e,r)||"void 0"}function Vi(e,r){e.staticProcessed=!0;var t=r.pre;return e.pre&&(r.pre=e.pre),r.staticRenderFns.push("with(this){return "+Ui(e,r)+"}"),r.pre=t,"_m("+(r.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ii(e,r){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ji(e,r);if(e.staticInFor){for(var t="",n=e.parent;n;){if(n.for){t=n.key;break}n=n.parent}return t?"_o("+Ui(e,r)+","+r.onceId+++","+t+")":Ui(e,r)}return Vi(e,r)}function ji(e,r,t,n){return e.ifProcessed=!0,function e(r,t,n,a){if(!r.length)return a||"_e()";var o=r.shift();return o.exp?"("+o.exp+")?"+i(o.block)+":"+e(r,t,n,a):""+i(o.block);function i(e){return n?n(e,t):e.once?Ii(e,t):Ui(e,t)}}(e.ifConditions.slice(),r,t,n)}function Pi(e,r,t,n){var a=e.for,o=e.alias,i=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+a+"),function("+o+i+s+"){return "+(t||Ui)(e,r)+"})"}function Hi(e,r){var t="{",n=function(e,r){var t=e.directives;if(!t)return;var n,a,o,i,s="directives:[",c=!1;for(n=0,a=t.length;n<a;n++){o=t[n],i=!0;var u=r.directives[o.name];u&&(i=!!u(e,o,r.warn)),i&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,r);n&&(t+=n+","),e.key&&(t+="key:"+e.key+","),e.ref&&(t+="ref:"+e.ref+","),e.refInFor&&(t+="refInFor:true,"),e.pre&&(t+="pre:true,"),e.component&&(t+='tag:"'+e.tag+'",');for(var a=0;a<r.dataGenFns.length;a++)t+=r.dataGenFns[a](e);if(e.attrs&&(t+="attrs:"+Zi(e.attrs)+","),e.props&&(t+="domProps:"+Zi(e.props)+","),e.events&&(t+=$i(e.events,!1)+","),e.nativeEvents&&(t+=$i(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(t+="slot:"+e.slotTarget+","),e.scopedSlots&&(t+=function(e,r,t){var n=e.for||Object.keys(r).some(function(e){var t=r[e];return t.slotTargetDynamic||t.if||t.for||Mi(t)}),a=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==si||o.for){n=!0;break}o.if&&(a=!0),o=o.parent}var i=Object.keys(r).map(function(e){return Gi(r[e],t)}).join(",");return"scopedSlots:_u(["+i+"]"+(n?",null,true":"")+(!n&&a?",null,false,"+function(e){var r=5381,t=e.length;for(;t;)r=33*r^e.charCodeAt(--t);return r>>>0}(i):"")+")"}(e,e.scopedSlots,r)+","),e.model&&(t+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,r){var t=e.children[0];if(t&&1===t.type){var n=Bi(t,r.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,r);o&&(t+=o+",")}return t=t.replace(/,$/,"")+"}",e.dynamicAttrs&&(t="_b("+t+',"'+e.tag+'",'+Zi(e.dynamicAttrs)+")"),e.wrapData&&(t=e.wrapData(t)),e.wrapListeners&&(t=e.wrapListeners(t)),t}function Mi(e){return 1===e.type&&("slot"===e.tag||e.children.some(Mi))}function Gi(e,r){var t=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!t)return ji(e,r,Gi,"null");if(e.for&&!e.forProcessed)return Pi(e,r,Gi);var n=e.slotScope===si?"":String(e.slotScope),a="function("+n+"){return "+("template"===e.tag?e.if&&t?"("+e.if+")?"+(zi(e,r)||"undefined")+":undefined":zi(e,r)||"undefined":Ui(e,r))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+a+o+"}"}function zi(e,r,t,n,a){var o=e.children;if(o.length){var i=o[0];if(1===o.length&&i.for&&"template"!==i.tag&&"slot"!==i.tag){var s=t?r.maybeComponent(i)?",1":",0":"";return""+(n||Ui)(i,r)+s}var c=t?function(e,r){for(var t=0,n=0;n<e.length;n++){var a=e[n];if(1===a.type){if(Ji(a)||a.ifConditions&&a.ifConditions.some(function(e){return Ji(e.block)})){t=2;break}(r(a)||a.ifConditions&&a.ifConditions.some(function(e){return r(e.block)}))&&(t=1)}}return t}(o,r.maybeComponent):0,u=a||Ki;return"["+o.map(function(e){return u(e,r)}).join(",")+"]"+(c?","+c:"")}}function Ji(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Ki(e,r){return 1===e.type?Ui(e,r):3===e.type&&e.isComment?(n=e,"_e("+JSON.stringify(n.text)+")"):"_v("+(2===(t=e).type?t.expression:Yi(JSON.stringify(t.text)))+")";var t,n}function Zi(e){for(var r="",t="",n=0;n<e.length;n++){var a=e[n],o=Yi(a.value);a.dynamic?t+=a.name+","+o+",":r+='"'+a.name+'":'+o+","}return r="{"+r.slice(0,-1)+"}",t?"_d("+r+",["+t.slice(0,-1)+"])":r}function Yi(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Wi(e,r){try{return new Function(e)}catch(t){return r.push({err:t,code:e}),C}}function Qi(e){var r=Object.create(null);return function(t,n,a){(n=E({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+t:t;if(r[o])return r[o];var i=e(t,n),s={},c=[];return s.render=Wi(i.render,c),s.staticRenderFns=i.staticRenderFns.map(function(e){return Wi(e,c)}),r[o]=s}}var Xi,es,rs=(Xi=function(e,r){var t=ui(e.trim(),r);!1!==r.optimize&&qi(t,r);var n=Bi(t,r);return{ast:t,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function r(r,t){var n=Object.create(e),a=[],o=[];if(t)for(var i in t.modules&&(n.modules=(e.modules||[]).concat(t.modules)),t.directives&&(n.directives=E(Object.create(e.directives||null),t.directives)),t)"modules"!==i&&"directives"!==i&&(n[i]=t[i]);n.warn=function(e,r,t){(t?o:a).push(e)};var s=Xi(r.trim(),n);return s.errors=a,s.tips=o,s}return{compile:r,compileToFunctions:Qi(r)}})(Di),ts=(rs.compile,rs.compileToFunctions);function ns(e){return(es=es||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',es.innerHTML.indexOf("&#10;")>0}var as=!!H&&ns(!1),os=!!H&&ns(!0),is=b(function(e){var r=Qt(e);return r&&r.innerHTML}),ss=Dt.prototype.$mount;Dt.prototype.$mount=function(e,r){if((e=e&&Qt(e))===document.body||e===document.documentElement)return this;var t=this.$options;if(!t.render){var n=t.template;if(n)if("string"==typeof n)"#"===n.charAt(0)&&(n=is(n));else{if(!n.nodeType)return this;n=n.innerHTML}else e&&(n=function(e){if(e.outerHTML)return e.outerHTML;var r=document.createElement("div");return r.appendChild(e.cloneNode(!0)),r.innerHTML}(e));if(n){var a=ts(n,{outputSourceRange:!1,shouldDecodeNewlines:as,shouldDecodeNewlinesForHref:os,delimiters:t.delimiters,comments:t.comments},this),o=a.render,i=a.staticRenderFns;t.render=o,t.staticRenderFns=i}}return ss.call(this,e,r)},Dt.compile=ts,module.exports=Dt;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index e08265bd8bc..e19afcbb49d 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -1,191 +1,157 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-/*  */
-
+/* @flow */
 const emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 const _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
-function isRegExp (v) {
-  return _toString.call(v) === '[object RegExp]'
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  const n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  const n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  const map = Object.create(null);
-  const list = str.split(',');
-  for (let i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? val => map[val.toLowerCase()]
-    : val => map[val]
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 const isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    const index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  const cache = Object.create(null);
-  return (function cachedFn (str) {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 const camelizeRE = /-(\w)/g;
 const camelize = cached((str) => {
-  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : '')
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
-
 /**
  * Capitalize a string.
  */
 const capitalize = cached((str) => {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 const hyphenateRE = /\B([A-Z])/g;
 const hyphenate = cached((str) => {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -193,750 +159,640 @@ const hyphenate = cached((str) => {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    const l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-const bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        const l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+const bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
-function toArray (list, start) {
-  start = start || 0;
-  let i = list.length - start;
-  const ret = new Array(i);
-  while (i--) {
-    ret[i] = list[i + start];
-  }
-  return ret
+function toArray(list, start) {
+    start = start || 0;
+    let i = list.length - start;
+    const ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
 }
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (const key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  const res = {};
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 const no = (a, b, c) => false;
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 const identity = (_) => _;
-
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce((keys, m) => {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) return true
-  const isObjectA = isObject(a);
-  const isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      const isArrayA = Array.isArray(a);
-      const isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every((e, i) => {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(key => {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
     }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (let i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) return i
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  let called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
+function once(fn) {
+    let called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
 const SSR_ATTR = 'data-server-rendered';
-
-const ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+const ASSET_TYPES = ['component', 'directive', 'filter'];
 const LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: "development" !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: "development" !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Check if a string starts with $ or _
  */
-function isReserved (str) {
-  const c = (str + '').charCodeAt(0);
-  return c === 0x24 || c === 0x5F
+function isReserved(str) {
+    const c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
 }
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
-
 /**
  * Parse simple path.
  */
 const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath (path) {
-  if (bailRE.test(path)) {
-    return
-  }
-  const segments = path.split('.');
-  return function (obj) {
-    for (let i = 0; i < segments.length; i++) {
-      if (!obj) return
-      obj = obj[segments[i]];
-    }
-    return obj
-  }
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    const segments = path.split('.');
+    return function (obj) {
+        for (let i = 0; i < segments.length; i++) {
+            if (!obj)
+                return;
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 const hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+const inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 const UA = inBrowser && window.navigator.userAgent.toLowerCase();
 const isIE = UA && /msie|trident/.test(UA);
 const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 const isEdge = UA && UA.indexOf('edge/') > 0;
-const isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+const isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 const isPhantomJS = UA && /phantomjs/.test(UA);
 const isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-const nativeWatch = ({}).watch;
-
+// @ts-ignore
+const nativeWatch = {}.watch;
 let supportsPassive = false;
 if (inBrowser) {
-  try {
-    const opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get () {
-        /* istanbul ignore next */
-        supportsPassive = true;
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 let _isServer;
 const isServerRendering = () => {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-const hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-let _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = class Set   {
-    
-    constructor () {
-      this.set = Object.create(null);
-    }
-    has (key) {
-      return this.set[key] === true
-    }
-    add (key) {
-      this.set[key] = true;
-    }
-    clear () {
-      this.set = Object.create(null);
-    }
-  };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        constructor() {
+            this.set = Object.create(null);
+        }
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-/*  */
-
+/* @flow */
 let warn = noop;
 let tip = noop;
-let generateComponentTrace = (noop); // work around flow check
-let formatComponentName = (noop);
-
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 {
-  const hasConsole = typeof console !== 'undefined';
-  const classifyRE = /(?:^|[-_])(\w)/g;
-  const classify = str => str
-    .replace(classifyRE, c => c.toUpperCase())
-    .replace(/[-_]/g, '');
-
-  warn = (msg, vm) => {
-    const trace = vm ? generateComponentTrace(vm) : '';
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace);
-    } else if (hasConsole && (!config.silent)) {
-      console.error(`[Vue warn]: ${msg}${trace}`);
-    }
-  };
-
-  tip = (msg, vm) => {
-    if (hasConsole && (!config.silent)) {
-      console.warn(`[Vue tip]: ${msg}` + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = (vm, includeFile) => {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    const options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    let name = options.name || options._componentTag;
-    const file = options.__file;
-    if (!name && file) {
-      const match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? `<${classify(name)}>` : `<Anonymous>`) +
-      (file && includeFile !== false ? ` at ${file}` : '')
-    )
-  };
-
-  const repeat = (str, n) => {
-    let res = '';
-    while (n) {
-      if (n % 2 === 1) res += str;
-      if (n > 1) str += str;
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = vm => {
-    if (vm._isVue && vm.$parent) {
-      const tree = [];
-      let currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          const last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map((vm, i) => `${
-          i === 0 ? '---> ' : repeat(' ', 5 + i * 2)
-        }${
-          Array.isArray(vm)
-            ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-            : formatComponentName(vm)
-        }`)
-        .join('\n')
-    } else {
-      return `\n\n(found in ${formatComponentName(vm)})`
-    }
-  };
-}
-
-/*  */
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
+}
 
 let uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
 class Dep {
-  
-  
-  
-
-  constructor () {
-    this.id = uid++;
-    this.subs = [];
-  }
-
-  addSub (sub) {
-    this.subs.push(sub);
-  }
-
-  removeSub (sub) {
-    remove(this.subs, sub);
-  }
-
-  depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
     }
-  }
-
-  notify () {
-    // stabilize the subscriber list first
-    const subs = this.subs.slice();
-    if (!config.async) {
-      // subs aren't sorted in scheduler if not running async
-      // we need to sort them now to make sure they fire in correct
-      // order
-      subs.sort((a, b) => a.id - b.id);
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove(this.subs, sub);
     }
-    for (let i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
     }
-  }
 }
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 const targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
 }
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-/*  */
-
 class VNode {
-  
-  
-  
-  
-  
-  
-   // rendered in this component's scope
-  
-  
-   // component instance
-   // component placeholder node
-
-  // strictly internal
-   // contains raw HTML? (server only)
-   // hoisted static node
-   // necessary for enter transition check
-   // empty comment placeholder?
-   // is a cloned node?
-   // is a v-once node?
-   // async component factory function
-  
-  
-  
-   // real context vm for functional nodes
-   // for SSR caching
-   // used to store functional render context for devtools
-   // functional scope id support
-
-  constructor (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-  }
-
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  get child () {
-    return this.componentInstance
-  }
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
 }
-
 const createEmptyVNode = (text = '') => {
-  const node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  const cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    const cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 const arrayProto = Array.prototype;
 const arrayMethods = Object.create(arrayProto);
-
 const methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
 ];
-
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  const original = arrayProto[method];
-  def(arrayMethods, method, function mutator (...args) {
-    const result = original.apply(this, args);
-    const ob = this.__ob__;
-    let inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) ob.observeArray(inserted);
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 let shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
@@ -944,398 +800,343 @@ function toggleObserving (value) {
  * collect dependencies and dispatch updates.
  */
 class Observer {
-  
-  
-   // number of vms that have this object as root $data
-
-  constructor (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
-  }
-
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  walk (obj) {
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
     }
-  }
-
-  /**
-   * Observe a list of Array items.
-   */
-  observeArray (items) {
-    for (let i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive$$1(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
     }
-  }
 }
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (let i = 0, l = keys.length; i < l; i++) {
-    const key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  let ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  const dep = new Dep();
-
-  const property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  const getter = property && property.get;
-  const setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  let childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      const value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      const value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) return
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(`Cannot set reactive property on undefined, null, or primitive value: ${(target)}`);
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  const ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Delete a property and trigger change if necessary.
  */
-function del (target, key) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(`Cannot delete reactive property on undefined, null, or primitive value: ${(target)}`);
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1);
-    return
-  }
-  const ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    );
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key];
-  if (!ob) {
-    return
-  }
-  ob.dep.notify();
+function del(target, key) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    const ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (let e, i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 const strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        `option "${key}" can only be used during instance ` +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) return to
-  let key, toVal, fromVal;
-
-  const keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (let i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') continue
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      const instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      const defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  const res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
-}
-
-function dedupeHooks (hooks) {
-  const res = [];
-  for (let i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
-    }
-  }
-  return res
-}
-
-LIFECYCLE_HOOKS.forEach(hook => {
-  strats[hook] = mergeHook;
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1343,606 +1144,537 @@ LIFECYCLE_HOOKS.forEach(hook => {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  const res = Object.create(parentVal || null);
-  if (childVal) {
-    assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) parentVal = undefined;
-  if (childVal === nativeWatch) childVal = undefined;
-  /* istanbul ignore if */
-  if (!childVal) return Object.create(parentVal || null)
-  {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) return childVal
-  const ret = {};
-  extend(ret, parentVal);
-  for (const key in childVal) {
-    let parent = ret[key];
-    const child = childVal[key];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && "development" !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) return childVal
-  const ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) extend(ret, childVal);
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 const defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (const key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  const props = options.props;
-  if (!props) return
-  const res = {};
-  let i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (const key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else {
-    warn(
-      `Invalid value for option "props": expected an Array or an Object, ` +
-      `but got ${toRawType(props)}.`,
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  const inject = options.inject;
-  if (!inject) return
-  const normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (let i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (const key in inject) {
-      const val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else {
-    warn(
-      `Invalid value for option "inject": expected an Array or an Object, ` +
-      `but got ${toRawType(inject)}.`,
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  const dirs = options.directives;
-  if (dirs) {
-    for (const key in dirs) {
-      const def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
-    }
-  }
-}
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      `Invalid value for option "${name}": expected an Object, ` +
-      `but got ${toRawType(value)}.`,
-      vm
-    );
-  }
+function normalizeDirectives(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def$$1 = dirs[key];
+            if (typeof def$$1 === 'function') {
+                dirs[key] = { bind: def$$1, update: def$$1 };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (let i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  const options = {};
-  let key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    const strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  const assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) return assets[id]
-  const camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) return assets[camelizedId]
-  const PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId]
-  // fallback to prototype chain
-  const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  const prop = propOptions[key];
-  const absent = !hasOwn(propsData, key);
-  let value = propsData[key];
-  // boolean casting
-  const booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      const stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    const prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+/* @flow */
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  const def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  let type = prop.type;
-  let valid = !type || type === true;
-  const expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (let i = 0; i < type.length && !valid; i++) {
-      const assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  const validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
-}
-
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  let valid;
-  const expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    const t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid,
-    expectedType
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    // @ts-ignore
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  const match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
-}
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
-}
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (let i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
-    }
-  }
-  return -1
-}
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  let message = `Invalid prop: type check failed for prop "${name}".` +
-    ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-  const expectedType = expectedTypes[0];
-  const receivedType = toRawType(value);
-  const expectedValue = styleValue(value, expectedType);
-  const receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += ` with value ${expectedValue}`;
-  }
-  message += `, got ${receivedType} `;
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += `with value ${receivedValue}.`;
-  }
-  return message
-}
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return `"${value}"`
-  } else if (type === 'Number') {
-    return `${Number(value)}`
-  } else {
-    return `${value}`
-  }
-}
-
-function isExplicable (value) {
-  const explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(elem => value.toLowerCase() === elem)
-}
-
-function isBoolean (...args) {
-  return args.some(elem => elem.toLowerCase() === 'boolean')
-}
-
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      let cur = vm;
-      while ((cur = cur.$parent)) {
-        const hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (let i = 0; i < hooks.length; i++) {
-            try {
-              const capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) return
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
+}
+
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
             }
-          }
         }
-      }
+        globalHandleError(err, vm, info);
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
-}
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  let res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(e => handleError(e, vm, info + ` (Promise/async)`));
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
-}
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
     try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler');
-      }
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
     }
-  }
-  logError(err, vm, info);
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
 }
-
-function logError (err, vm, info) {
-  {
-    warn(`Error in ${info}: "${err.toString()}"`, vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/*  */
-
+/* @flow */
 let isUsingMicroTask = false;
-
 const callbacks = [];
 let pending = false;
-
-function flushCallbacks () {
-  pending = false;
-  const copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (let i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    pending = false;
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // Here we have async deferring wrappers using microtasks.
 // In 2.5 we used (macro) tasks (in combination with microtasks).
 // However, it has subtle problems when state is changed right before repaint
@@ -1955,7 +1687,6 @@ function flushCallbacks () {
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
 let timerFunc;
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1964,2319 +1695,2026 @@ let timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  const p = Promise.resolve();
-  timerFunc = () => {
-    p.then(flushCallbacks);
-    // In problematic UIWebViews, Promise.then doesn't completely break, but
-    // it can get stuck in a weird state where callbacks are pushed into the
-    // microtask queue but the queue isn't being flushed, until the browser
-    // needs to do some other work, e.g. handle a timer. Therefore we can
-    // "force" the microtask queue to be flushed by adding an empty timer.
-    if (isIOS) setTimeout(noop);
-  };
-  isUsingMicroTask = true;
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  let counter = 1;
-  const observer = new MutationObserver(flushCallbacks);
-  const textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-  timerFunc = () => {
-    counter = (counter + 1) % 2;
-    textNode.data = String(counter);
-  };
-  isUsingMicroTask = true;
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Technically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = () => {
-    setImmediate(flushCallbacks);
-  };
-} else {
-  // Fallback to setTimeout.
-  timerFunc = () => {
-    setTimeout(flushCallbacks, 0);
-  };
-}
-
-function nextTick (cb, ctx) {
-  let _resolve;
-  callbacks.push(() => {
-    if (cb) {
-      try {
-        cb.call(ctx);
-      } catch (e) {
-        handleError(e, ctx, 'nextTick');
-      }
-    } else if (_resolve) {
-      _resolve(ctx);
-    }
-  });
-  if (!pending) {
-    pending = true;
-    timerFunc();
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(resolve => {
-      _resolve = resolve;
-    })
-  }
-}
-
-/*  */
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            setTimeout(noop);
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = () => {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = () => {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    let _resolve;
+    callbacks.push(() => {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise((resolve) => {
+            _resolve = resolve;
+        });
+    }
+}
+
+/* @flow */
 
 let mark;
 let measure;
-
 {
-  const perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = tag => perf.mark(tag);
-    measure = (name, startTag, endTag) => {
-      perf.measure(name, startTag, endTag);
-      perf.clearMarks(startTag);
-      perf.clearMarks(endTag);
-      // perf.clearMeasures(name)
-    };
-  }
+    const perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 let initProxy;
-
 {
-  const allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  const warnNonPresent = (target, key) => {
-    warn(
-      `Property or method "${key}" is not defined on the instance but ` +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
-    );
-  };
-
-  const warnReservedPrefix = (target, key) => {
-    warn(
-      `Property "${key}" must be accessed with "$data.${key}" because ` +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
     );
-  };
-
-  const hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
-
-  const hasHandler = {
-    has (target, key) {
-      const has = key in target;
-      const isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-      if (!has && !isAllowed) {
-        if (key in target.$data) warnReservedPrefix(target, key);
-        else warnNonPresent(target, key);
-      }
-      return has || !isAllowed
-    }
-  };
-
-  const getHandler = {
-    get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) warnReservedPrefix(target, key);
-        else warnNonPresent(target, key);
-      }
-      return target[key]
-    }
-  };
-
-  initProxy = function initProxy (vm) {
+    const warnNonPresent = (target, key) => {
+        warn(`Property or method "${key}" is not defined on the instance but ` +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    const warnReservedPrefix = (target, key) => {
+        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-      // determine which proxy handler to use
-      const options = vm.$options;
-      const handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler;
-      vm._renderProxy = new Proxy(vm, handlers);
-    } else {
-      vm._renderProxy = vm;
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
     }
-  };
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return has || !isAllowed;
+        },
+    };
+    const getHandler = {
+        get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-/*  */
-
+/* @flow */
 const seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  let i, keys;
-  const isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    const depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) _traverse(val[i], seen);
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) _traverse(val[keys[i]], seen);
-  }
-}
-
-/*  */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
+}
 
 const normalizeEvent = cached((name) => {
-  const passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  const once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  const capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name,
-    once: once$$1,
-    capture,
-    passive
-  }
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once$$1 ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once: once$$1,
+        capture,
+        passive,
+    };
 });
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+    let name, def$$1, cur, old, event;
+    for (name in on) {
+        def$$1 = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove$$1(event.name, oldOn[name], event.capture);
+        }
+    }
+}
 
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    const fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      const cloned = fns.slice();
-      for (let i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`)
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  let name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      warn(
-        `Invalid handler for event "${event.name}": got ` + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
-}
-
-/*  */
-
-function mergeVNodeHook (def, hookKey, hook) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {});
-  }
-  let invoker;
-  const oldHook = def[hookKey];
-
-  function wrappedHook () {
-    hook.apply(this, arguments);
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook);
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook]);
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook;
-      invoker.fns.push(wrappedHook);
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook]);
-    }
-  }
-
-  invoker.merged = true;
-  def[hookKey] = invoker;
-}
-
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  const propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  const res = {};
-  const { attrs, props } = data;
-  if (isDef(attrs) || isDef(props)) {
-    for (const key in propOptions) {
-      const altKey = hyphenate(key);
-      {
-        const keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            `Prop "${keyInLowerCase}" is passed to component ` +
-            `${formatComponentName(tag || Ctor)}, but the declared prop name is` +
-            ` "${key}". ` +
-            `Note that HTML attributes are case-insensitive and camelCased ` +
-            `props need to use their kebab-case equivalents when using in-DOM ` +
-            `templates. You should probably use "${altKey}" instead of "${key}".`
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
-}
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+/* @flow */
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    let invoker;
+    const oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
+}
 
+/* @flow */
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (let i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  const res = [];
-  let i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') continue
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = `__vlist${nestedIndex}_${i}__`;
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
-
-function initProvide (vm) {
-  const provide = vm.$options.provide;
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide;
-  }
-}
-
-function initInjections (vm) {
-  const result = resolveInject(vm.$options.inject, vm);
-  if (result) {
-    toggleObserving(false);
-    Object.keys(result).forEach(key => {
-      /* istanbul ignore else */
-      {
-        defineReactive$$1(vm, key, result[key], () => {
-          warn(
-            `Avoid mutating an injected value directly since the changes will be ` +
-            `overwritten whenever the provided component re-renders. ` +
-            `injection being mutated: "${key}"`,
-            vm
-          );
-        });
-      }
-    });
-    toggleObserving(true);
-  }
-}
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    const result = Object.create(null);
-    const keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') continue
-      const provideKey = inject[key].from;
-      let source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
         }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          const provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else {
-          warn(`Injection "${key}" not found`, vm);
+    }
+    return res;
+}
+
+/* @flow */
+function initProvide(vm) {
+    const provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    const result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach((key) => {
+            /* istanbul ignore else */
+            {
+                defineReactive$$1(vm, key, result[key], () => {
+                    warn(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
+                });
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    // @ts-ignore
+                    warn(`Injection "${key}" not found`, vm);
+                }
+            }
         }
-      }
+        return result;
     }
-    return result
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  const slots = {};
-  for (let i = 0, l = children.length; i < l; i++) {
-    const child = children[i];
-    const data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      const name = data.slot;
-      const slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (const name in slots) {
-    if (slots[name].every(isWhitespace)) {
-      delete slots[name];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  let res;
-  const hasNormalSlots = Object.keys(normalSlots).length > 0;
-  const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  const key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (const key in slots) {
-      if (slots[key] && key[0] !== '$') {
-        res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (const key in normalSlots) {
-    if (!(key in res)) {
-      res[key] = proxyNormalSlot(normalSlots, key);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+/* @flow */
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== '$') {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  const normalized = function () {
-    let res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
-}
-
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
 function proxyNormalSlot(slots, key) {
-  return () => slots[key]
+    return () => slots[key];
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  let ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      const iterator = val[Symbol.iterator]();
-      let result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  const scopedSlotFn = this.$scopedSlots[name];
-  let nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (!isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  const target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+/* @flow */
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
-}
-
-/*  */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+}
 
+/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      let hash;
-      for (const key in value) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          const type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        const camelizedKey = camelize(key);
-        const hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            const on = data.on || (data.on = {});
-            on[`update:${key}`] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
         }
-      }
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  const cached = this._staticTrees || (this._staticTrees = []);
-  let tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, `__static__${index}`, false);
-  return tree
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, `__static__${index}`, false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-  return tree
+function markOnce(tree, index, key) {
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (let i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], `${key}_${i}`, isOnce);
-      }
+/* @flow */
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
     }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+    return data;
 }
 
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      const on = data.on = data.on ? extend({}, data.on) : {};
-      for (const key in value) {
-        const existing = on[key];
-        const ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
-}
-
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (let i = 0; i < fns.length; i++) {
-    const slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
-}
-
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (let i = 0; i < values.length; i += 2) {
-    const key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        `Invalid value for dynamic directive argument (expected string or null): ${key}`,
-        this
-      );
-    }
-  }
-  return baseObj
+/* @flow */
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  const options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  let contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  const isCompiled = isTrue(options._compiled);
-  const needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = () => {
-    if (!this.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this.$slots
-  };
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
-    }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = (a, b, c, d) => {
-      const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+/* @flow */
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+/* @flow */
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
     };
-  } else {
-    this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
-
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  const options = Ctor.options;
-  const props = {};
-  const propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (const key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) mergeProps(props, data.attrs);
-    if (isDef(data.props)) mergeProps(props, data.props);
-  }
-
-  const renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  const vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    const vnodes = normalizeChildren(vnode) || [];
-    const res = new Array(vnodes.length);
-    for (let i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
     }
-    return res
-  }
 }
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  const clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
 }
-
-function mergeProps (to, from) {
-  for (const key in from) {
-    to[camelize(key)] = from[key];
-  }
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
-/*  */
+/* @flow */
 
+/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 const componentVNodeHooks = {
-  init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      const mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      const child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch (oldVnode, vnode) {
-    const options = vnode.componentOptions;
-    const child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert (vnode) {
-    const { context, componentInstance } = vnode;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy (vnode) {
-    const { componentInstance } = vnode;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 const hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  const baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    {
-      warn(`Invalid Component definition: ${String(Ctor)}`, context);
-    }
-    return
-  }
-
-  // async component
-  let asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  const listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    const slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
-    }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  const name = Ctor.options.name || tag;
-  const vnode = new VNode(
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`,
-    data, undefined, undefined, undefined, context,
-    { Ctor, propsData, listeners, tag, children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent, // activeInstance in lifecycle state
-) {
-  const options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent
-  };
-  // check inline-template render functions
-  const inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  const hooks = data.hook || (data.hook = {});
-  for (let i = 0; i < hooksToMerge.length; i++) {
-    const key = hooksToMerge[i];
-    const existing = hooks[key];
-    const toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-    }
-  }
-}
-
-function mergeHook$1 (f1, f2) {
-  const merged = (a, b) => {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook$1(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  const prop = (options.model && options.model.prop) || 'value';
-  const event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  const on = data.on || (data.on = {});
-  const existing = on[event];
-  const callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
-}
-
-/*  */
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
+}
 
+/* @flow */
 const SIMPLE_NORMALIZE = 1;
 const ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    warn(
-      `Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  let vnode, ns;
-  if (typeof tag === 'string') {
-    let Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (isDef(data) && isDef(data.nativeOn)) {
-        warn(
-          `The .native modifier for v-on is only valid on components but it was used on <${tag}>.`,
-          context
-        );
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      );
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) applyNS(vnode, ns);
-    if (isDef(data)) registerDeepBindings(data);
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (let i = 0, l = vnode.children.length; i < l; i++) {
-      const child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
-}
-
-/*  */
-
-function initRender (vm) {
-  vm._vnode = null; // the root of the child tree
-  vm._staticTrees = null; // v-once cached trees
-  const options = vm.$options;
-  const parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-  const renderContext = parentVnode && parentVnode.context;
-  vm.$slots = resolveSlots(options._renderChildren, renderContext);
-  vm.$scopedSlots = emptyObject;
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false);
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true);
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  const parentData = parentVnode && parentVnode.data;
-
-  /* istanbul ignore else */
-  {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, () => {
-      !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-    }, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, () => {
-      !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-    }, true);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
+}
+
+/* @flow */
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false);
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true);
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    const parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
+        }, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
+        }, true);
+    }
 }
-
 let currentRenderingInstance = null;
-
-function renderMixin (Vue) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype);
-
-  Vue.prototype.$nextTick = function (fn) {
-    return nextTick(fn, this)
-  };
-
-  Vue.prototype._render = function () {
-    const vm = this;
-    const { render, _parentVnode } = vm.$options;
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      );
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode;
-    // render self
-    let vnode;
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm;
-      vnode = render.call(vm._renderProxy, vm.$createElement);
-    } catch (e) {
-      handleError(e, vm, `render`);
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-        } catch (e) {
-          handleError(e, vm, `renderError`);
-          vnode = vm._vnode;
-        }
-      } else {
-        vnode = vm._vnode;
-      }
-    } finally {
-      currentRenderingInstance = null;
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0];
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        );
-      }
-      vnode = createEmptyVNode();
-    }
-    // set parent
-    vnode.parent = _parentVnode;
-    return vnode
-  };
-}
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  const node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data, context, children, tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  const owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    const owners = factory.owners = [owner];
-    let sync = true;
-    let timerLoading = null;
-    let timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', () => remove(owners, owner));
-
-    const forceRender = (renderCompleted) => {
-      for (let i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
-        }
-      }
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
     };
-
-    const resolve = once((res) => {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    const reject = once(reason => {
-      warn(
-        `Failed to resolve async component: ${String(factory)}` +
-        (reason ? `\nReason: ${reason}` : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    const res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
+    Vue.prototype._render = function () {
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        let vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(() => {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        catch (e) {
+            handleError(e, vm, `render`);
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, `renderError`);
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(() => {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                `timeout (${res.timeout}ms)`
-              );
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
             }
-          }, res.timeout);
+            vnode = createEmptyVNode();
         }
-      }
-    }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-/*  */
-
-function getFirstComponentChild (children) {
-  if (Array.isArray(children)) {
-    for (let i = 0; i < children.length; i++) {
-      const c = children[i];
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
+/* @flow */
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
     }
-  }
+    return isObject(comp) ? base.extend(comp) : comp;
 }
-
-/*  */
-
-/*  */
-
-function initEvents (vm) {
-  vm._events = Object.create(null);
-  vm._hasHookEvent = false;
-  // init parent attached events
-  const listeners = vm.$options._parentListeners;
-  if (listeners) {
-    updateComponentListeners(vm, listeners);
-  }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
 }
-
-let target;
-
-function add (event, fn) {
-  target.$on(event, fn);
-}
-
-function remove$1 (event, fn) {
-  target.$off(event, fn);
-}
-
-function createOnceHandler (event, fn) {
-  const _target = target;
-  return function onceHandler () {
-    const res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
-    }
-  }
-}
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
-}
-
-function eventsMixin (Vue) {
-  const hookRE = /^hook:/;
-  Vue.prototype.$on = function (event, fn) {
-    const vm = this;
-    if (Array.isArray(event)) {
-      for (let i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn);
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn);
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true;
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$once = function (event, fn) {
-    const vm = this;
-    function on () {
-      vm.$off(event, on);
-      fn.apply(vm, arguments);
-    }
-    on.fn = fn;
-    vm.$on(event, on);
-    return vm
-  };
-
-  Vue.prototype.$off = function (event, fn) {
-    const vm = this;
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null);
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (let i = 0, l = event.length; i < l; i++) {
-        vm.$off(event[i], fn);
-      }
-      return vm
-    }
-    // specific event
-    const cbs = vm._events[event];
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null;
-      return vm
-    }
-    // specific handler
-    let cb;
-    let i = cbs.length;
-    while (i--) {
-      cb = cbs[i];
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1);
-        break
-      }
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
     }
-    return vm
-  };
-
-  Vue.prototype.$emit = function (event) {
-    const vm = this;
-    {
-      const lowerCaseEvent = event.toLowerCase();
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          `Event "${lowerCaseEvent}" is emitted in component ` +
-          `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-          `Note that HTML attributes are case-insensitive and you cannot use ` +
-          `v-on to listen to camelCase events when using in-DOM templates. ` +
-          `You should probably use "${hyphenate(event)}" instead of "${event}".`
-        );
-      }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
     }
-    let cbs = vm._events[event];
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-      const args = toArray(arguments, 1);
-      const info = `event handler for "${event}"`;
-      for (let i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-      }
+    const owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
     }
-    return vm
-  };
-}
-
-/*  */
-
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-
-function setActiveInstance(vm) {
-  const prevActiveInstance = activeInstance;
-  activeInstance = vm;
-  return () => {
-    activeInstance = prevActiveInstance;
-  }
-}
-
-function initLifecycle (vm) {
-  const options = vm.$options;
-
-  // locate first non-abstract parent
-  let parent = options.parent;
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
-    }
-    parent.$children.push(vm);
-  }
-
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
-
-  vm.$children = [];
-  vm.$refs = {};
-
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
-}
-
-function lifecycleMixin (Vue) {
-  Vue.prototype._update = function (vnode, hydrating) {
-    const vm = this;
-    const prevEl = vm.$el;
-    const prevVnode = vm._vnode;
-    const restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
-    }
-    restoreActiveInstance();
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null;
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm;
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  };
-
-  Vue.prototype.$forceUpdate = function () {
-    const vm = this;
-    if (vm._watcher) {
-      vm._watcher.update();
-    }
-  };
-
-  Vue.prototype.$destroy = function () {
-    const vm = this;
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy');
-    vm._isBeingDestroyed = true;
-    // remove self from parent
-    const parent = vm.$parent;
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
-    }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown();
-    }
-    let i = vm._watchers.length;
-    while (i--) {
-      vm._watchers[i].teardown();
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
-    }
-    // call the last hook...
-    vm._isDestroyed = true;
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
-    // fire destroyed hook
-    callHook(vm, 'destroyed');
-    // turn off all instance listeners.
-    vm.$off();
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null;
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null;
-    }
-  };
-}
-
-function mountComponent (
-  vm,
-  el,
-  hydrating
-) {
-  vm.$el = el;
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode;
-    {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        );
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        );
-      }
-    }
-  }
-  callHook(vm, 'beforeMount');
-
-  let updateComponent;
-  /* istanbul ignore if */
-  if (config.performance && mark) {
-    updateComponent = () => {
-      const name = vm._name;
-      const id = vm._uid;
-      const startTag = `vue-perf-start:${id}`;
-      const endTag = `vue-perf-end:${id}`;
-
-      mark(startTag);
-      const vnode = vm._render();
-      mark(endTag);
-      measure(`vue ${name} render`, startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(`vue ${name} patch`, startTag, endTag);
-    };
-  } else {
-    updateComponent = () => {
-      vm._update(vm._render(), hydrating);
-    };
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate');
-      }
-    }
-  }, true /* isRenderWatcher */);
-  hydrating = false;
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  }
-  return vm
-}
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-  {
-    isUpdatingChildComponent = true;
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  const newScopedSlots = parentVnode.data.scopedSlots;
-  const oldScopedSlots = vm.$scopedSlots;
-  const hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  const needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    const props = vm._props;
-    const propKeys = vm.$options._propKeys || [];
-    for (let i = 0; i < propKeys.length; i++) {
-      const key = propKeys[i];
-      const propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        const resolve = once((res) => {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        const reject = once((reason) => {
+            warn(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(`timeout (${res.timeout}ms)`);
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
     }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  const oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-
-  {
-    isUpdatingChildComponent = false;
-  }
 }
 
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) return true
-  }
-  return false
+/* @flow */
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (let i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+/* @flow */
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
     }
-    callHook(vm, 'activated');
-  }
 }
 
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (let i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
-    }
-    callHook(vm, 'deactivated');
-  }
-}
+/* @flow */
 
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  const handlers = vm.$options[hook];
-  const info = `${hook} hook`;
-  if (handlers) {
-    for (let i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+/* @flow */
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    const listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
     }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
 }
-
-/*  */
-
-const MAX_UPDATE_COUNT = 100;
-
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index = 0;
-
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0;
-  has = {};
-  {
-    circular = {};
-  }
-  waiting = flushing = false;
+let target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    const _target = target;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
 }
-
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    target = undefined;
+}
+function eventsMixin(Vue) {
+    const hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        const vm = this;
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        const vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        const vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
+            }
+            return vm;
+        }
+        // specific event
+        const cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        let cb;
+        let i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        const vm = this;
+        {
+            const lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+            }
+        }
+        let cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
+}
+
+/* @flow */
+let activeInstance = null;
+let isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    const prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return () => {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    const options = vm.$options;
+    // locate first non-abstract parent
+    let parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        const vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        const vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook(vm, 'beforeDestroy');
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        const parent = vm.$parent;
+        // @ts-ignore
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        let i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook(vm, 'destroyed');
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            // @ts-expect-error null is not undefined
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                vm.$options.el ||
+                el) {
+                warn('You are using the runtime-only build of Vue where the template ' +
+                    'compiler is not available. Either pre-compile the templates into ' +
+                    'render functions, or use the compiler-included build.', vm);
+            }
+            else {
+                warn('Failed to mount component: template or render function not defined.', vm);
+            }
+        }
+    }
+    callHook(vm, 'beforeMount');
+    let updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
+            mark(startTag);
+            const vnode = vm._render();
+            mark(endTag);
+            measure(`vue ${name} render`, startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = () => {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook(vm, 'beforeUpdate');
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook(vm, 'mounted');
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'activated');
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'deactivated');
+    }
+}
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
+    }
+    popTarget();
+}
+
+/* @flow */
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
 let currentFlushTimestamp = 0;
-
 // Async edge case fix requires storing an event listener's attach timestamp.
 let getNow = Date.now;
-
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -4284,1479 +3722,1270 @@ let getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  const performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = () => performance.now();
-  }
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
 }
-
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow();
-  flushing = true;
-  let watcher, id;
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort((a, b) => a.id - b.id);
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index];
-    if (watcher.before) {
-      watcher.before();
-    }
-    id = watcher.id;
-    has[id] = null;
-    watcher.run();
-    // in dev build, check and stop circular updates.
-    if (has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1;
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? `in watcher with expression "${watcher.expression}"`
-              : `in a component render function.`
-          ),
-          watcher.vm
-        );
-        break
-      }
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    let watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort((a, b) => a.id - b.id);
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
     }
-  }
-
-  // keep copies of post queues before resetting state
-  const activatedQueue = activatedChildren.slice();
-  const updatedQueue = queue.slice();
-
-  resetSchedulerState();
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue);
-  callUpdatedHooks(updatedQueue);
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush');
-  }
 }
-
-function callUpdatedHooks (queue) {
-  let i = queue.length;
-  while (i--) {
-    const watcher = queue[i];
-    const vm = watcher.vm;
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated');
+function callUpdatedHooks(queue) {
+    let i = queue.length;
+    while (i--) {
+        const watcher = queue[i];
+        const vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook(vm, 'updated');
+        }
     }
-  }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-  activatedChildren.push(vm);
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
 }
-
-function callActivatedHooks (queue) {
-  for (let i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true;
-    activateChildComponent(queue[i], true /* true */);
-  }
+function callActivatedHooks(queue) {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
 }
-
 /**
  * Push a watcher into the watcher queue.
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-function queueWatcher (watcher) {
-  const id = watcher.id;
-  if (has[id] == null) {
-    has[id] = true;
-    if (!flushing) {
-      queue.push(watcher);
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      let i = queue.length - 1;
-      while (i > index && queue[i].id > watcher.id) {
-        i--;
-      }
-      queue.splice(i + 1, 0, watcher);
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true;
-
-      if (!config.async) {
-        flushSchedulerQueue();
-        return
-      }
-      nextTick(flushSchedulerQueue);
+function queueWatcher(watcher) {
+    const id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            let i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (!config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
     }
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 let uid$2 = 0;
-
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
 class Watcher {
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  
-
-  constructor (
-    vm,
-    expOrFn,
-    cb,
-    options,
-    isRenderWatcher
-  ) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-      vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-      this.deep = !!options.deep;
-      this.user = !!options.user;
-      this.lazy = !!options.lazy;
-      this.sync = !!options.sync;
-      this.before = options.before;
-    } else {
-      this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression = expOrFn.toString();
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-      this.getter = expOrFn;
-    } else {
-      this.getter = parsePath(expOrFn);
-      if (!this.getter) {
-        this.getter = noop;
-        warn(
-          `Failed watching path: "${expOrFn}" ` +
-          'Watcher only accepts simple dot-delimited paths. ' +
-          'For full control, use a function instead.',
-          vm
-        );
-      }
-    }
-    this.value = this.lazy
-      ? undefined
-      : this.get();
-  }
-
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  get () {
-    pushTarget(this);
-    let value;
-    const vm = this.vm;
-    try {
-      value = this.getter.call(vm, vm);
-    } catch (e) {
-      if (this.user) {
-        handleError(e, vm, `getter for watcher "${this.expression}"`);
-      } else {
-        throw e
-      }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value);
-      }
-      popTarget();
-      this.cleanupDeps();
-    }
-    return value
-  }
-
-  /**
-   * Add a dependency to this directive.
-   */
-  addDep (dep) {
-    const id = dep.id;
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id);
-      this.newDeps.push(dep);
-      if (!this.depIds.has(id)) {
-        dep.addSub(this);
-      }
-    }
-  }
-
-  /**
-   * Clean up for dependency collection.
-   */
-  cleanupDeps () {
-    let i = this.deps.length;
-    while (i--) {
-      const dep = this.deps[i];
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this);
-      }
-    }
-    let tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-  }
-
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-      this.dirty = true;
-    } else if (this.sync) {
-      this.run();
-    } else {
-      queueWatcher(this);
-    }
-  }
-
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  run () {
-    if (this.active) {
-      const value = this.get();
-      if (
-        value !== this.value ||
-        // Deep watchers and watchers on Object/Arrays should fire even
-        // when the value is the same, because the value may
-        // have mutated.
-        isObject(value) ||
-        this.deep
-      ) {
-        // set new value
-        const oldValue = this.value;
-        this.value = value;
-        if (this.user) {
-          try {
-            this.cb.call(this.vm, value, oldValue);
-          } catch (e) {
-            handleError(e, this.vm, `callback for watcher "${this.expression}"`);
-          }
-        } else {
-          this.cb.call(this.vm, value, oldValue);
-        }
-      }
-    }
-  }
-
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-  }
-
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  depend () {
-    let i = this.deps.length;
-    while (i--) {
-      this.deps[i].depend();
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$2; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression =
+            expOrFn.toString();
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn(`Failed watching path: "${expOrFn}" ` +
+                        'Watcher only accepts simple dot-delimited paths. ' +
+                        'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy ? undefined : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
+        }
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    }
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
     }
-  }
-
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  teardown () {
-    if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed.
-      if (!this.vm._isBeingDestroyed) {
-        remove(this.vm._watchers, this);
-      }
-      let i = this.deps.length;
-      while (i--) {
-        this.deps[i].removeSub(this);
-      }
-      this.active = false;
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    }
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    }
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    try {
+                        this.cb.call(this.vm, value, oldValue);
+                    }
+                    catch (e) {
+                        handleError(e, this.vm, `callback for watcher "${this.expression}"`);
+                    }
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    }
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
+    }
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    }
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 const sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
 };
-
-function proxy (target, sourceKey, key) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  };
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function initState (vm) {
-  vm._watchers = [];
-  const opts = vm.$options;
-  if (opts.props) initProps(vm, opts.props);
-  if (opts.methods) initMethods(vm, opts.methods);
-  if (opts.data) {
-    initData(vm);
-  } else {
-    observe(vm._data = {}, true /* asRootData */);
-  }
-  if (opts.computed) initComputed(vm, opts.computed);
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
-  }
-}
-
-function initProps (vm, propsOptions) {
-  const propsData = vm.$options.propsData || {};
-  const props = vm._props = {};
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  const keys = vm.$options._propKeys = [];
-  const isRoot = !vm.$parent;
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false);
-  }
-  for (const key in propsOptions) {
-    keys.push(key);
-    const value = validateProp(key, propsOptions, propsData, vm);
-    /* istanbul ignore else */
-    {
-      const hyphenatedKey = hyphenate(key);
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          `"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`,
-          vm
-        );
-      }
-      defineReactive$$1(props, key, value, () => {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            `Avoid mutating a prop directly since the value will be ` +
-            `overwritten whenever the parent component re-renders. ` +
-            `Instead, use a data or computed property based on the prop's ` +
-            `value. Prop being mutated: "${key}"`,
-            vm
-          );
-        }
-      });
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, `_props`, key);
-    }
-  }
-  toggleObserving(true);
-}
-
-function initData (vm) {
-  let data = vm.$options.data;
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (!isPlainObject(data)) {
-    data = {};
-    warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    );
-  }
-  // proxy data on instance
-  const keys = Object.keys(data);
-  const props = vm.$options.props;
-  const methods = vm.$options.methods;
-  let i = keys.length;
-  while (i--) {
-    const key = keys[i];
-    {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          `Method "${key}" has already been defined as a data property.`,
-          vm
-        );
-      }
-    }
-    if (props && hasOwn(props, key)) {
-      warn(
-        `The data property "${key}" is already declared as a prop. ` +
-        `Use prop default value instead.`,
-        vm
-      );
-    } else if (!isReserved(key)) {
-      proxy(vm, `_data`, key);
-    }
-  }
-  // observe data
-  observe(data, true /* asRootData */);
-}
-
-function getData (data, vm) {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget();
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, `data()`);
-    return {}
-  } finally {
-    popTarget();
-  }
-}
-
-const computedWatcherOptions = { lazy: true };
-
-function initComputed (vm, computed) {
-  // $flow-disable-line
-  const watchers = vm._computedWatchers = Object.create(null);
-  // computed properties are just getters during SSR
-  const isSSR = isServerRendering();
-
-  for (const key in computed) {
-    const userDef = computed[key];
-    const getter = typeof userDef === 'function' ? userDef : userDef.get;
-    if (getter == null) {
-      warn(
-        `Getter is missing for computed property "${key}".`,
-        vm
-      );
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      );
-    }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else {
-      if (key in vm.$data) {
-        warn(`The computed property "${key}" is already defined in data.`, vm);
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(`The computed property "${key}" is already defined as a prop.`, vm);
-      }
-    }
-  }
-}
-
-function defineComputed (
-  target,
-  key,
-  userDef
-) {
-  const shouldCache = !isServerRendering();
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
-  }
-  if (sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        `Computed property "${key}" was assigned to but it has no setter.`,
-        this
-      );
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
     };
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    const watcher = this._computedWatchers && this._computedWatchers[key];
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate();
-      }
-      if (Dep.target) {
-        watcher.depend();
-      }
-      return watcher.value
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    const opts = vm.$options;
+    if (opts.props)
+        initProps(vm, opts.props);
+    if (opts.methods)
+        initMethods(vm, opts.methods);
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        initComputed(vm, opts.computed);
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps(vm, propsOptions) {
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    for (const key in propsOptions) {
+        keys.push(key);
+        const value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        {
+            const hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+            }
+            defineReactive$$1(props, key, value, () => {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
+                }
+            });
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, `_props`, key);
+        }
     }
-  }
-}
-
-function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
+    toggleObserving(true);
 }
-
-function initMethods (vm, methods) {
-  const props = vm.$options.props;
-  for (const key in methods) {
-    {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          `Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-          `Did you reference the function correctly?`,
-          vm
-        );
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          `Method "${key}" has already been defined as a prop.`,
-          vm
-        );
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          `Method "${key}" conflicts with an existing Vue instance method. ` +
-          `Avoid defining component methods that start with _ or $.`
-        );
-      }
+function initData(vm) {
+    let data = vm.$options.data;
+    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        warn('data functions should return an object:\n' +
+                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+    }
+    // proxy data on instance
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
+    while (i--) {
+        const key = keys[i];
+        {
+            if (methods && hasOwn(methods, key)) {
+                warn(`Method "${key}" has already been defined as a data property.`, vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            warn(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, `_data`, key);
+        }
     }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-  }
+    // observe data
+    observe(data, true /* asRootData */);
 }
-
-function initWatch (vm, watch) {
-  for (const key in watch) {
-    const handler = watch[key];
-    if (Array.isArray(handler)) {
-      for (let i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
-      }
-    } else {
-      createWatcher(vm, key, handler);
-    }
-  }
-}
-
-function createWatcher (
-  vm,
-  expOrFn,
-  handler,
-  options
-) {
-  if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler];
-  }
-  return vm.$watch(expOrFn, handler, options)
-}
-
-function stateMixin (Vue) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  const dataDef = {};
-  dataDef.get = function () { return this._data };
-  const propsDef = {};
-  propsDef.get = function () { return this._props };
-  {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      );
-    };
-    propsDef.set = function () {
-      warn(`$props is readonly.`, this);
-    };
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef);
-  Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
-
-  Vue.prototype.$watch = function (
-    expOrFn,
-    cb,
-    options
-  ) {
-    const vm = this;
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
     }
-    options = options || {};
-    options.user = true;
-    const watcher = new Watcher(vm, expOrFn, cb, options);
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value);
-      } catch (error) {
-        handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`);
-      }
+    catch (e) {
+        handleError(e, vm, `data()`);
+        return {};
     }
-    return function unwatchFn () {
-      watcher.teardown();
+    finally {
+        popTarget();
     }
-  };
 }
-
-/*  */
-
-let uid$3 = 0;
-
-function initMixin (Vue) {
-  Vue.prototype._init = function (options) {
-    const vm = this;
-    // a uid
-    vm._uid = uid$3++;
-
-    let startTag, endTag;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      startTag = `vue-perf-start:${vm._uid}`;
-      endTag = `vue-perf-end:${vm._uid}`;
-      mark(startTag);
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options);
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      );
+const computedWatcherOptions = { lazy: true };
+function initComputed(vm, computed) {
+    // $flow-disable-line
+    const watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === 'function' ? userDef : userDef.get;
+        if (getter == null) {
+            warn(`Getter is missing for computed property "${key}".`, vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else {
+            if (key in vm.$data) {
+                warn(`The computed property "${key}" is already defined in data.`, vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+        }
     }
-    /* istanbul ignore else */
-    {
-      initProxy(vm);
-    }
-    // expose real self
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook(vm, 'created');
-
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      vm._name = formatComponentName(vm, false);
-      mark(endTag);
-      measure(`vue ${vm._name} init`, startTag, endTag);
-    }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el);
-    }
-  };
-}
-
-function initInternalComponent (vm, options) {
-  const opts = vm.$options = Object.create(vm.constructor.options);
-  // doing this because it's faster than dynamic enumeration.
-  const parentVnode = options._parentVnode;
-  opts.parent = options.parent;
-  opts._parentVnode = parentVnode;
-
-  const vnodeComponentOptions = parentVnode.componentOptions;
-  opts.propsData = vnodeComponentOptions.propsData;
-  opts._parentListeners = vnodeComponentOptions.listeners;
-  opts._renderChildren = vnodeComponentOptions.children;
-  opts._componentTag = vnodeComponentOptions.tag;
-
-  if (options.render) {
-    opts.render = options.render;
-    opts.staticRenderFns = options.staticRenderFns;
-  }
-}
-
-function resolveConstructorOptions (Ctor) {
-  let options = Ctor.options;
-  if (Ctor.super) {
-    const superOptions = resolveConstructorOptions(Ctor.super);
-    const cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      const modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor) {
-  let modified;
-  const latest = Ctor.options;
-  const sealed = Ctor.sealedOptions;
-  for (const key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) modified = {};
-      modified[key] = latest[key];
-    }
-  }
-  return modified
-}
-
-function Vue (options) {
-  if (!(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword');
-  }
-  this._init(options);
 }
-
-initMixin(Vue);
-stateMixin(Vue);
-eventsMixin(Vue);
-lifecycleMixin(Vue);
-renderMixin(Vue);
-
-/*  */
-
-function initUse (Vue) {
-  Vue.use = function (plugin) {
-    const installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    const args = toArray(arguments, 1);
-    args.unshift(this);
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args);
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args);
+function defineComputed(target, key, userDef) {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === 'function') {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
+        };
     }
-    installedPlugins.push(plugin);
-    return this
-  };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
 }
-
-/*  */
-
-function initMixin$1 (Vue) {
-  Vue.mixin = function (mixin) {
-    this.options = mergeOptions(this.options, mixin);
-    return this
-  };
+function createComputedGetter(key) {
+    return function computedGetter() {
+        const watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
 }
-
-/*  */
-
-function initExtend (Vue) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0;
-  let cid = 1;
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions) {
-    extendOptions = extendOptions || {};
-    const Super = this;
-    const SuperId = Super.cid;
-    const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
+        {
+            if (typeof methods[key] !== 'function') {
+                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(`Method "${key}" has already been defined as a prop.`, vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
+            }
+        }
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
     }
-
-    const name = extendOptions.name || Super.options.name;
-    if (name) {
-      validateComponentName(name);
+}
+function initWatch(vm, watch) {
+    for (const key in watch) {
+        const handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (let i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
     }
-
-    const Sub = function VueComponent (options) {
-      this._init(options);
-    };
-    Sub.prototype = Object.create(Super.prototype);
-    Sub.prototype.constructor = Sub;
-    Sub.cid = cid++;
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    );
-    Sub['super'] = Super;
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps$1(Sub);
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
     }
-    if (Sub.options.computed) {
-      initComputed$1(Sub);
+    if (typeof handler === 'string') {
+        handler = vm[handler];
     }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    const dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    const propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    {
+        dataDef.set = function () {
+            warn('Avoid replacing instance root $data. ' +
+                'Use nested data properties instead.', this);
+        };
+        propsDef.set = function () {
+            warn(`$props is readonly.`, this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, '$data', dataDef);
+    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        const vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        const watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            pushTarget();
+            try {
+                cb.call(vm, watcher.value);
+            }
+            catch (error) {
+                handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`);
+            }
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
+}
 
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend;
-    Sub.mixin = Super.mixin;
-    Sub.use = Super.use;
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type];
-    });
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub;
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options;
-    Sub.extendOptions = extendOptions;
-    Sub.sealedOptions = extend({}, Sub.options);
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub;
-    return Sub
-  };
-}
-
-function initProps$1 (Comp) {
-  const props = Comp.options.props;
-  for (const key in props) {
-    proxy(Comp.prototype, `_props`, key);
-  }
-}
-
-function initComputed$1 (Comp) {
-  const computed = Comp.options.computed;
-  for (const key in computed) {
-    defineComputed(Comp.prototype, key, computed[key]);
-  }
-}
-
-/*  */
-
-function initAssetRegisters (Vue) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(type => {
-    Vue[type] = function (
-      id,
-      definition
-    ) {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
+/* @flow */
+let uid$3 = 0;
+function initMixin(Vue) {
+    Vue.prototype._init = function (options) {
+        const vm = this;
+        // a uid
+        vm._uid = uid$3++;
+        let startTag, endTag;
         /* istanbul ignore if */
-        if (type === 'component') {
-          validateComponentName(id);
+        if (config.performance && mark) {
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
+            mark(startTag);
         }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id;
-          definition = this.options._base.extend(definition);
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
         }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition };
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        {
+            initProxy(vm);
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook(vm, 'created');
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
         }
-        this.options[type + 's'][id] = definition;
-        return definition
-      }
     };
-  });
+}
+function initInternalComponent(vm, options) {
+    // @ts-ignore
+    const opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    const parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    const vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-/*  */
-
-
+function Vue(options) {
+    if (!(this instanceof Vue)) {
+        warn('Vue is a constructor and should be called with the `new` keyword');
+    }
+    this._init(options);
+}
+//@ts-ignore
+initMixin(Vue);
+//@ts-ignore
+stateMixin(Vue);
+//@ts-ignore
+eventsMixin(Vue);
+//@ts-ignore
+lifecycleMixin(Vue);
+//@ts-ignore
+renderMixin(Vue);
 
-function getComponentName (opts) {
-  return opts && (opts.Ctor.options.name || opts.tag)
+/* @flow */
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        const args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function matches (pattern, name) {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
+/* @flow */
+function initMixin$1(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function pruneCache (keepAliveInstance, filter) {
-  const { cache, keys, _vnode } = keepAliveInstance;
-  for (const key in cache) {
-    const cachedNode = cache[key];
-    if (cachedNode) {
-      const name = getComponentName(cachedNode.componentOptions);
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
-      }
+/* @flow */
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    let cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        const name = extendOptions.name || Super.options.name;
+        if (name) {
+            validateComponentName(name);
+        }
+        const Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps$1(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed$1(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps$1(Comp) {
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
     }
-  }
 }
-
-function pruneCacheEntry (
-  cache,
-  key,
-  keys,
-  current
-) {
-  const cached$$1 = cache[key];
-  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-    cached$$1.componentInstance.$destroy();
-  }
-  cache[key] = null;
-  remove(keys, key);
+function initComputed$1(Comp) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-const patternTypes = [String, RegExp, Array];
-
-var KeepAlive = {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created () {
-    this.cache = Object.create(null);
-    this.keys = [];
-  },
+/* @flow */
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach((type) => {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
+}
 
-  destroyed () {
-    for (const key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
+// @ts-nocheck
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
     }
-  },
-
-  mounted () {
-    this.$watch('include', val => {
-      pruneCache(this, name => matches(val, name));
-    });
-    this.$watch('exclude', val => {
-      pruneCache(this, name => !matches(val, name));
-    });
-  },
-
-  render () {
-    const slot = this.$slots.default;
-    const vnode = getFirstComponentChild(slot);
-    const componentOptions = vnode && vnode.componentOptions;
-    if (componentOptions) {
-      // check pattern
-      const name = getComponentName(componentOptions);
-      const { include, exclude } = this;
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      const { cache, keys } = this;
-      const key = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? `::${componentOptions.tag}` : '')
-        : vnode.key;
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
-        // make current key freshest
-        remove(keys, key);
-        keys.push(key);
-      } else {
-        cache[key] = vnode;
-        keys.push(key);
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+    else if (typeof pattern === 'string') {
+        return pattern.split(',').indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const cachedNode = cache[key];
+        if (cachedNode) {
+            const name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
         }
-      }
-
-      vnode.data.keepAlive = true;
     }
-    return vnode || (slot && slot[0])
-  }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    const cached$$1 = cache[key];
+    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+        cached$$1.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove(keys, key);
+}
+const patternTypes = [String, RegExp, Array];
+// TODO use defineComponent
+var KeepAlive = {
+    name: 'keep-alive',
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed() {
+        for (const key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted() {
+        this.$watch('include', (val) => {
+            pruneCache(this, (name) => matches(val, name));
+        });
+        this.$watch('exclude', (val) => {
+            pruneCache(this, (name) => !matches(val, name));
+        });
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            const { cache, keys } = this;
+            const key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? `::${componentOptions.tag}` : '')
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove(keys, key);
+                keys.push(key);
+            }
+            else {
+                cache[key] = vnode;
+                keys.push(key);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+            }
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
 var builtInComponents = {
-  KeepAlive
+    KeepAlive,
 };
 
-/*  */
-
-function initGlobalAPI (Vue) {
-  // config
-  const configDef = {};
-  configDef.get = () => config;
-  {
-    configDef.set = () => {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      );
+/* @flow */
+function initGlobalAPI(Vue) {
+    // config
+    const configDef = {};
+    configDef.get = () => config;
+    {
+        configDef.set = () => {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn,
+        extend,
+        mergeOptions,
+        defineReactive: defineReactive$$1,
     };
-  }
-  Object.defineProperty(Vue, 'config', configDef);
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn,
-    extend,
-    mergeOptions,
-    defineReactive: defineReactive$$1
-  };
-
-  Vue.set = set;
-  Vue.delete = del;
-  Vue.nextTick = nextTick;
-
-  // 2.6 explicit observable API
-  Vue.observable = (obj) => {
-    observe(obj);
-    return obj
-  };
-
-  Vue.options = Object.create(null);
-  ASSET_TYPES.forEach(type => {
-    Vue.options[type + 's'] = Object.create(null);
-  });
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue;
-
-  extend(Vue.options.components, builtInComponents);
-
-  initUse(Vue);
-  initMixin$1(Vue);
-  initExtend(Vue);
-  initAssetRegisters(Vue);
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = (obj) => {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach((type) => {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin$1(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
 initGlobalAPI(Vue);
-
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+    get: isServerRendering,
 });
-
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
+    get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
 });
-
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+    value: FunctionalRenderContext,
 });
-
 Vue.version = '2.6.12';
 
-/*  */
-
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 const isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 const acceptValue = makeMap('input,textarea,option,select,progress');
 const mustUseProp = (tag, type, attr) => {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
 const convertEnumeratedValue = (key, value) => {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-const isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
 const xlinkNS = 'http://www.w3.org/1999/xlink';
-
 const isXlink = (name) => {
-  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-
 const getXlinkProp = (name) => {
-  return isXlink(name) ? name.slice(6, name.length) : ''
+    return isXlink(name) ? name.slice(6, name.length) : '';
 };
-
 const isFalsyAttrValue = (val) => {
-  return val == null || val === false
+    return val == null || val === false;
 };
 
-/*  */
-
-function genClassForVnode (vnode) {
-  let data = vnode.data;
-  let parentNode = vnode;
-  let childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
+/* @flow */
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
     }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
     }
-  }
-  return renderClass(data.staticClass, data.class)
+    return renderClass(data.staticClass, data.class);
 }
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
 }
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
 }
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyArray (value) {
-  let res = '';
-  let stringified;
-  for (let i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) res += ' ';
-      res += stringified;
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
     }
-  }
-  return res
+    return res;
 }
-
-function stringifyObject (value) {
-  let res = '';
-  for (const key in value) {
-    if (value[key]) {
-      if (res) res += ' ';
-      res += key;
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 const namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
 };
-
-const isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-const isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 const isPreTag = (tag) => tag === 'pre';
-
 const isReservedTag = (tag) => {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 const unknownElementCache = Object.create(null);
-function isUnknownElement (tag) {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase();
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  const el = document.createElement(tag);
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    const el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
 }
-
 const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
-
+/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
-function query (el) {
-  if (typeof el === 'string') {
-    const selected = document.querySelector(el);
-    if (!selected) {
-      warn(
-        'Cannot find element: ' + el
-      );
-      return document.createElement('div')
+function query(el) {
+    if (typeof el === 'string') {
+        const selected = document.querySelector(el);
+        if (!selected) {
+            warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
     }
-    return selected
-  } else {
-    return el
-  }
 }
 
-/*  */
-
-function createElement$1 (tagName, vnode) {
-  const elm = document.createElement(tagName);
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple');
-  }
-  return elm
+/* @flow */
+function createElement$1(tagName, vnode) {
+    const elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
 }
-
-function createElementNS (namespace, tagName) {
-  return document.createElementNS(namespaceMap[namespace], tagName)
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
 }
-
-function createTextNode (text) {
-  return document.createTextNode(text)
+function createTextNode(text) {
+    return document.createTextNode(text);
 }
-
-function createComment (text) {
-  return document.createComment(text)
+function createComment(text) {
+    return document.createComment(text);
 }
-
-function insertBefore (parentNode, newNode, referenceNode) {
-  parentNode.insertBefore(newNode, referenceNode);
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
 }
-
-function removeChild (node, child) {
-  node.removeChild(child);
+function removeChild(node, child) {
+    node.removeChild(child);
 }
-
-function appendChild (node, child) {
-  node.appendChild(child);
+function appendChild(node, child) {
+    node.appendChild(child);
 }
-
-function parentNode (node) {
-  return node.parentNode
+function parentNode(node) {
+    return node.parentNode;
 }
-
-function nextSibling (node) {
-  return node.nextSibling
+function nextSibling(node) {
+    return node.nextSibling;
 }
-
-function tagName (node) {
-  return node.tagName
+function tagName(node) {
+    return node.tagName;
 }
-
-function setTextContent (node, text) {
-  node.textContent = text;
+function setTextContent(node, text) {
+    node.textContent = text;
 }
-
-function setStyleScope (node, scopeId) {
-  node.setAttribute(scopeId, '');
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5774,48 +5003,53 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/*  */
-
+/* @flow */
 var ref = {
-  create (_, vnode) {
-    registerRef(vnode);
-  },
-  update (oldVnode, vnode) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
-    }
-  },
-  destroy (vnode) {
-    registerRef(vnode, true);
-  }
+    create(_, vnode) {
+        registerRef(vnode);
+    },
+    update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy(vnode) {
+        registerRef(vnode, true);
+    },
 };
-
-function registerRef (vnode, isRemoval) {
-  const key = vnode.data.ref;
-  if (!isDef(key)) return
-
-  const vm = vnode.context;
-  const ref = vnode.componentInstance || vnode.elm;
-  const refs = vm.$refs;
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref);
-    } else if (refs[key] === ref) {
-      refs[key] = undefined;
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref];
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref);
-      }
-    } else {
-      refs[key] = ref;
+function registerRef(vnode, isRemoval) {
+    const key = vnode.data.ref;
+    if (!isDef(key))
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    if (isRemoval) {
+        if (Array.isArray(refs[key])) {
+            // @ts-expect-error invalid typings
+            remove(refs[key], ref);
+        }
+        else if (refs[key] === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error invalid typings
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(refs[key])) {
+                refs[key] = [ref];
+                // @ts-expect-error invalid typings
+            }
+            else if (refs[key].indexOf(ref) < 0) {
+                // @ts-expect-error invalid typings
+                refs[key].push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
     }
-  }
 }
 
 /**
@@ -5829,1397 +5063,1292 @@ function registerRef (vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-
 const emptyNode = new VNode('', {}, []);
-
 const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') return true
-  let i;
-  const typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-  const typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
-}
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  let i, key;
-  const map = {};
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key;
-    if (isDef(key)) map[key] = i;
-  }
-  return map
-}
-
-function createPatchFunction (backend) {
-  let i, j;
-  const cbs = {};
-
-  const { modules, nodeOps } = backend;
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = [];
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]]);
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove$$1 () {
-      if (--remove$$1.listeners === 0) {
-        removeNode(childElm);
-      }
-    }
-    remove$$1.listeners = listeners;
-    return remove$$1
-  }
-
-  function removeNode (el) {
-    const parent = nodeOps.parentNode(el);
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el);
-    }
-  }
-
-  function isUnknownElement$$1 (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(ignore => {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  let creatingElmInVPre = 0;
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode);
-    }
-
-    vnode.isRootInsert = !nested; // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        ((a.tag === b.tag &&
+            a.isComment === b.isComment &&
+            isDef(a.data) === isDef(b.data) &&
+            sameInputType(a, b)) ||
+            (isTrue(a.isAsyncPlaceholder) &&
+                a.asyncFactory === b.asyncFactory &&
+                isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    let i, key;
+    const map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            map[key] = i;
     }
-
-    const data = vnode.data;
-    const children = vnode.children;
-    const tag = vnode.tag;
-    if (isDef(tag)) {
-      {
-        if (data && data.pre) {
-          creatingElmInVPre++;
-        }
-        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          );
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode);
-      setScope(vnode);
-
-      /* istanbul ignore if */
-      {
-        createChildren(vnode, children, insertedVnodeQueue);
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue);
+    return map;
+}
+function createPatchFunction(backend) {
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
         }
+    }
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    }
+    function createRmCb(childElm, listeners) {
+        function remove$$1() {
+            if (--remove$$1.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove$$1.listeners = listeners;
+        return remove$$1;
+    }
+    function removeNode(el) {
+        const parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
+    }
+    function isUnknownElement$$1(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some((ignore) => {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    let creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
+        if (isDef(tag)) {
+            {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i = vnode.data;
+        if (isDef(i)) {
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        let innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
         insert(parentElm, vnode.elm, refElm);
-      }
-
-      if (data && data.pre) {
-        creatingElmInVPre--;
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    let i = vnode.data;
-    if (isDef(i)) {
-      const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */);
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue);
-        insert(parentElm, vnode.elm, refElm);
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+    }
+    function insert(parent, elm, ref$$1) {
+        if (isDef(parent)) {
+            if (isDef(ref$$1)) {
+                if (nodeOps.parentNode(ref$$1) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref$$1);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
         }
-        return true
-      }
     }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-      vnode.data.pendingInsert = null;
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            {
+                checkDuplicateKeys(children);
+            }
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
     }
-    vnode.elm = vnode.componentInstance.$el;
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue);
-      setScope(vnode);
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode);
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode);
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
     }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    let i;
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    let innerNode = vnode;
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode;
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode);
-        }
-        insertedVnodeQueue.push(innerNode);
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm);
-  }
-
-  function insert (parent, elm, ref$$1) {
-    if (isDef(parent)) {
-      if (isDef(ref$$1)) {
-        if (nodeOps.parentNode(ref$$1) === parent) {
-          nodeOps.insertBefore(parent, elm, ref$$1);
-        }
-      } else {
-        nodeOps.appendChild(parent, elm);
-      }
-    }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      {
-        checkDuplicateKeys(children);
-      }
-      for (let i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode;
-    }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (let i = 0; i < cbs.create.length; ++i) {
-      cbs.create[i](emptyNode, vnode);
-    }
-    i = vnode.data.hook; // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) i.create(emptyNode, vnode);
-      if (isDef(i.insert)) insertedVnodeQueue.push(vnode);
-    }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    let i;
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    } else {
-      let ancestor = vnode;
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i);
-        }
-        ancestor = ancestor.parent;
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-    }
-  }
-
-  function invokeDestroyHook (vnode) {
-    let i, j;
-    const data = vnode.data;
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) i(vnode);
-      for (i = 0; i < cbs.destroy.length; ++i) cbs.destroy[i](vnode);
-    }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j]);
-      }
-    }
-  }
-
-  function removeVnodes (vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      const ch = vnodes[startIdx];
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch);
-          invokeDestroyHook(ch);
-        } else { // Text node
-          removeNode(ch.elm);
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      let i;
-      const listeners = cbs.remove.length + 1;
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners;
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners);
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm);
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm);
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm);
-      } else {
-        rm();
-      }
-    } else {
-      removeNode(vnode.elm);
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    let oldStartIdx = 0;
-    let newStartIdx = 0;
-    let oldEndIdx = oldCh.length - 1;
-    let oldStartVnode = oldCh[0];
-    let oldEndVnode = oldCh[oldEndIdx];
-    let newEndIdx = newCh.length - 1;
-    let newStartVnode = newCh[0];
-    let newEndVnode = newCh[newEndIdx];
-    let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    const canMove = !removeOnly;
-
-    {
-      checkDuplicateKeys(newCh);
-    }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx];
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        oldStartVnode = oldCh[++oldStartIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-        oldStartVnode = oldCh[++oldStartIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-        } else {
-          vnodeToMove = oldCh[idxInOld];
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-            oldCh[idxInOld] = undefined;
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          }
-        }
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    const seenKeys = {};
-    for (let i = 0; i < children.length; i++) {
-      const vnode = children[i];
-      const key = vnode.key;
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            `Duplicate keys detected: '${key}'. This may cause an update error.`,
-            vnode.context
-          );
-        } else {
-          seenKeys[key] = true;
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (let i = start; i < end; i++) {
-      const c = oldCh[i];
-      if (isDef(c) && sameVnode(node, c)) return i
-    }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
-    }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode);
-    }
-
-    const elm = vnode.elm = oldVnode.elm;
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-      } else {
-        vnode.isAsyncPlaceholder = true;
-      }
-      return
-    }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance;
-      return
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                i.create(emptyNode, vnode);
+            if (isDef(i.insert))
+                insertedVnodeQueue.push(vnode);
+        }
     }
-
-    let i;
-    const data = vnode.data;
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode);
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        let i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            let ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
     }
-
-    const oldCh = oldVnode.children;
-    const ch = vnode.children;
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode);
-      if (isDef(i = data.hook) && isDef(i = i.update)) i(oldVnode, vnode);
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
     }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-      } else if (isDef(ch)) {
+    function invokeDestroyHook(vnode) {
+        let i, j;
+        const data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                i(vnode);
+            for (i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            let i;
+            const listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        const canMove = !removeOnly;
         {
-          checkDuplicateKeys(ch);
-        }
-        if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '');
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-      } else if (isDef(oldCh)) {
-        removeVnodes(oldCh, 0, oldCh.length - 1);
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '');
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text);
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode);
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue;
-    } else {
-      for (let i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i]);
-      }
-    }
-  }
-
-  let hydrationBailed = false;
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    let i;
-    const { tag, data, children } = vnode;
-    inVPre = inVPre || (data && data.pre);
-    vnode.elm = elm;
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true;
-      return true
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
     }
-    // assert node match
-    {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) i(vnode, true /* hydrating */);
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue);
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue);
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('server innerHTML: ', i);
-                console.warn('client innerHTML: ', elm.innerHTML);
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            let childrenMatch = true;
-            let childNode = elm.firstChild;
-            for (let i = 0; i < children.length; i++) {
-              if (!childNode || !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false;
-                break
-              }
-              childNode = childNode.nextSibling;
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        let fullInvoke = false;
-        for (const key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true;
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            break
-          }
-        }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class']);
-        }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text;
-    }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement$$1(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) invokeDestroyHook(oldVnode);
-      return
-    }
-
-    let isInitialPatch = false;
-    const insertedVnodeQueue = [];
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true;
-      createElm(vnode, insertedVnodeQueue);
-    } else {
-      const isRealElement = isDef(oldVnode.nodeType);
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR);
-            hydrating = true;
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true);
-              return oldVnode
-            } else {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
-              );
-            }
-          }
-          // either not server-rendered, or hydration failed.
-          // create an empty node and replace it
-          oldVnode = emptyNodeAt(oldVnode);
-        }
-
-        // replacing existing element
-        const oldElm = oldVnode.elm;
-        const parentElm = nodeOps.parentNode(oldElm);
-
-        // create new node
-        createElm(
-          vnode,
-          insertedVnodeQueue,
-          // extremely rare edge case: do not insert if old element is in a
-          // leaving transition. Only happens when combining transition +
-          // keep-alive + HOCs. (#4590)
-          oldElm._leaveCb ? null : parentElm,
-          nodeOps.nextSibling(oldElm)
-        );
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          let ancestor = vnode.parent;
-          const patchable = isPatchable(vnode);
-          while (ancestor) {
-            for (let i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor);
-            }
-            ancestor.elm = vnode.elm;
-            if (patchable) {
-              for (let i = 0; i < cbs.create.length; ++i) {
-                cbs.create[i](emptyNode, ancestor);
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              const insert = ancestor.data.hook.insert;
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (let i = 1; i < insert.fns.length; i++) {
-                  insert.fns[i]();
+    function checkDuplicateKeys(children) {
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
                 }
-              }
-            } else {
-              registerRef(ancestor);
             }
-            ancestor = ancestor.parent;
-          }
         }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes([oldVnode], 0, 0);
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode);
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                return i;
         }
-      }
     }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-    return vnode.elm
-  }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        const elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        let i;
+        const data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                i(oldVnode, vnode);
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+            }
+            else if (isDef(ch)) {
+                {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    nodeOps.setTextContent(elm, '');
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                i(oldVnode, vnode);
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    let hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        let i;
+        const { tag, data, children } = vnode;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                i(vnode, true /* hydrating */);
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                let fullInvoke = false;
+                for (const key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement$$1(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                invokeDestroyHook(oldVnode);
+            return;
+        }
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            const isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-/*  */
-
+/* @flow */
 var directives = {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode) {
-    updateDirectives(vnode, emptyNode);
-  }
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
 };
-
-function updateDirectives (oldVnode, vnode) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode);
-  }
-}
-
-function _update (oldVnode, vnode) {
-  const isCreate = oldVnode === emptyNode;
-  const isDestroy = vnode === emptyNode;
-  const oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-  const newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-  const dirsWithInsert = [];
-  const dirsWithPostpatch = [];
-
-  let key, oldDir, dir;
-  for (key in newDirs) {
-    oldDir = oldDirs[key];
-    dir = newDirs[key];
-    if (!oldDir) {
-      // new directive, bind
-      callHook$1(dir, 'bind', vnode, oldVnode);
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir);
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value;
-      dir.oldArg = oldDir.arg;
-      callHook$1(dir, 'update', vnode, oldVnode);
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir);
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    const callInsert = () => {
-      for (let i = 0; i < dirsWithInsert.length; i++) {
-        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-      }
-    };
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert);
-    } else {
-      callInsert();
-    }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', () => {
-      for (let i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-      }
-    });
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-      }
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook$1(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook$1(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
+                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
     }
-  }
 }
-
 const emptyModifiers = Object.create(null);
-
-function normalizeDirectives$1 (
-  dirs,
-  vm
-) {
-  const res = Object.create(null);
-  if (!dirs) {
-    // $flow-disable-line
-    return res
-  }
-  let i, dir;
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i];
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers;
+function normalizeDirectives$1(dirs, vm) {
+    const res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    let i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
     }
-    res[getRawDirName(dir)] = dir;
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-  }
-  // $flow-disable-line
-  return res
+    // $flow-disable-line
+    return res;
 }
-
-function getRawDirName (dir) {
-  return dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`
+function getRawDirName(dir) {
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
 }
-
-function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-  const fn = dir.def && dir.def[hook];
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-    } catch (e) {
-      handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+    const fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+        }
     }
-  }
 }
 
-var baseModules = [
-  ref,
-  directives
-];
+var baseModules = [ref, directives];
 
-/*  */
-
-function updateAttrs (oldVnode, vnode) {
-  const opts = vnode.componentOptions;
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  let key, cur, old;
-  const elm = vnode.elm;
-  const oldAttrs = oldVnode.data.attrs || {};
-  let attrs = vnode.data.attrs || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__)) {
-    attrs = vnode.data.attrs = extend({}, attrs);
-  }
-
-  for (key in attrs) {
-    cur = attrs[key];
-    old = oldAttrs[key];
-    if (old !== cur) {
-      setAttr(elm, key, cur);
-    }
-  }
-  // #4391: in IE9, setting type can reset value for input[type=radio]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value);
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key);
-      }
-    }
-  }
-}
-
-function setAttr (el, key, value) {
-  if (el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value);
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key;
-      el.setAttribute(key, value);
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value));
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-    } else {
-      el.setAttributeNS(xlinkNS, key, value);
-    }
-  } else {
-    baseSetAttr(el, key, value);
-  }
-}
-
-function baseSetAttr (el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key);
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
+/* @flow */
+function updateAttrs(oldVnode, vnode) {
+    const opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
     /* istanbul ignore if */
-    if (
-      isIE && !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
-    ) {
-      const blocker = e => {
-        e.stopImmediatePropagation();
-        el.removeEventListener('input', blocker);
-      };
-      el.addEventListener('input', blocker);
-      // $flow-disable-line
-      el.__ieph = true; /* IE placeholder patched */
-    }
-    el.setAttribute(key, value);
-  }
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            const blocker = (e) => {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
 }
-
 var attrs = {
-  create: updateAttrs,
-  update: updateAttrs
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-/*  */
-
-function updateClass (oldVnode, vnode) {
-  const el = vnode.elm;
-  const data = vnode.data;
-  const oldData = oldVnode.data;
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
-  ) {
-    return
-  }
-
-  let cls = genClassForVnode(vnode);
-
-  // handle transition classes
-  const transitionClass = el._transitionClasses;
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass));
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls);
-    el._prevClass = cls;
-  }
+/* @flow */
+function updateClass(oldVnode, vnode) {
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    let cls = genClassForVnode(vnode);
+    // handle transition classes
+    const transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
 }
-
 var klass = {
-  create: updateClass,
-  update: updateClass
+    create: updateClass,
+    update: updateClass,
 };
 
-/*  */
-
+/* @flow */
 const validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  let inSingle = false;
-  let inDouble = false;
-  let inTemplateString = false;
-  let inRegex = false;
-  let curly = 0;
-  let square = 0;
-  let paren = 0;
-  let lastFilterIndex = 0;
-  let c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) inSingle = false;
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) inDouble = false;
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) inTemplateString = false;
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) inRegex = false;
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        let j = i - 1;
-        let p;
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') break
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
-    }
-  }
-
-  return expression
-}
-
-function wrapFilter (exp, filter) {
-  const i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return `_f("${filter}")(${exp})`
-  } else {
-    const name = filter.slice(0, i);
-    const args = filter.slice(i + 1);
-    return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`
-  }
-}
-
-/*  */
-
-
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
+}
 
+/* @flow */
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(`[Vue compiler]: ${msg}`);
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(m => m[key]).filter(_ => _)
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  const attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name, value, dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? `_p(${name},"${symbol}")`
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = `(${name})==='click'?'contextmenu':(${name})`;
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = `(${name})==='click'?'mouseup':(${name})`;
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  let events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  const handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
-}
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-}
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  const dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    const staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  let val;
-  if ((val = el.attrsMap[name]) != null) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
     }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  const list = el.attrsList;
-  for (let i = 0, l = list.length; i < l; i++) {
-    const attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
+    if (removeFromMap) {
+        delete el.attrsMap[name];
     }
-  }
+    return val;
 }
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-    if (range.end != null) {
-      item.end = range.end;
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
     }
-  }
-  return item
+    return item;
 }
 
-/*  */
-
+/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  const { number, trim } = modifiers || {};
-
-  const baseValueExpression = '$$v';
-  let valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      `(typeof ${baseValueExpression} === 'string'` +
-      `? ${baseValueExpression}.trim()` +
-      `: ${baseValueExpression})`;
-  }
-  if (number) {
-    valueExpression = `_n(${valueExpression})`;
-  }
-  const assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: `(${value})`,
-    expression: JSON.stringify(value),
-    callback: `function (${baseValueExpression}) {${assignment}}`
-  };
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  const res = parseModel(value);
-  if (res.key === null) {
-    return `${value}=${assignment}`
-  } else {
-    return `$set(${res.exp}, ${res.key}, ${assignment})`
-  }
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -7234,2033 +6363,2093 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
 let len, str, chr, index$1, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index$1 = val.lastIndexOf('.');
-    if (index$1 > -1) {
-      return {
-        exp: val.slice(0, index$1),
-        key: '"' + val.slice(index$1 + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index$1 = val.lastIndexOf('.');
+        if (index$1 > -1) {
+            return {
+                exp: val.slice(0, index$1),
+                key: '"' + val.slice(index$1 + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  str = val;
-  index$1 = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+    str = val;
+    index$1 = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index$1)
+function next() {
+    return str.charCodeAt(++index$1);
 }
-
-function eof () {
-  return index$1 >= len
+function eof() {
+    return index$1 >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  let inBracket = 1;
-  expressionPos = index$1;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) inBracket++;
-    if (chr === 0x5D) inBracket--;
-    if (inBracket === 0) {
-      expressionEndPos = index$1;
-      break
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index$1;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index$1;
+            break;
+        }
     }
-  }
 }
-
-function parseString (chr) {
-  const stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 let warn$1;
-
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 const RANGE_TOKEN = '__r';
 const CHECKBOX_RADIO_TOKEN = '__c';
-
-function model (
-  el,
-  dir,
-  _warn
-) {
-  warn$1 = _warn;
-  const value = dir.value;
-  const modifiers = dir.modifiers;
-  const tag = el.tag;
-  const type = el.attrsMap.type;
-
-  {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$1(
-        `<${el.tag} v-model="${value}" type="file">:\n` +
-        `File inputs are read only. Use a v-on:change listener instead.`,
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else if (!config.isReservedTag(tag)) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else {
-    warn$1(
-      `<${el.tag} v-model="${value}">: ` +
-      `v-model is not supported on this element type. ` +
-      'If you are working with contenteditable, it\'s recommended to ' +
-      'wrap a library dedicated for that purpose inside a custom component.',
-      el.rawAttrsMap['v-model']
-    );
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  const number = modifiers && modifiers.number;
-  const valueBinding = getBindingAttr(el, 'value') || 'null';
-  const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    `Array.isArray(${value})` +
-    `?_i(${value},${valueBinding})>-1` + (
-      trueValueBinding === 'true'
-        ? `:(${value})`
-        : `:_q(${value},${trueValueBinding})`
-    )
-  );
-  addHandler(el, 'change',
-    `var $$a=${value},` +
+function model(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
         '$$el=$event.target,' +
         `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-    'if(Array.isArray($$a)){' +
-      `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-      `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-      `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-    `}else{${genAssignmentCode(value, '$$c')}}`,
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  const number = modifiers && modifiers.number;
-  let valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-  addProp(el, 'checked', `_q(${value},${valueBinding})`);
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  const number = modifiers && modifiers.number;
-  const selectedVal = `Array.prototype.filter` +
-    `.call($event.target.options,function(o){return o.selected})` +
-    `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-    `return ${number ? '_n(val)' : 'val'}})`;
-
-  const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  let code = `var $$selectedVal = ${selectedVal};`;
-  code = `${code} ${genAssignmentCode(value, assignment)}`;
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  const type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  {
-    const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value && !typeBinding) {
-      const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$1(
-        `${binding}="${value}" conflicts with v-model on the same element ` +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  const { lazy, number, trim } = modifiers || {};
-  const needCompositionGuard = !lazy && type !== 'range';
-  const event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  let valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = `$event.target.value.trim()`;
-  }
-  if (number) {
-    valueExpression = `_n(${valueExpression})`;
-  }
-
-  let code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = `if($event.target.composing)return;${code}`;
-  }
-
-  addProp(el, 'value', `(${value})`);
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
-}
-
-/*  */
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
+/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
 // user-attached handlers.
-function normalizeEvents (on) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    const event = isIE ? 'change' : 'input';
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-    delete on[RANGE_TOKEN];
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-    delete on[CHECKBOX_RADIO_TOKEN];
-  }
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
 }
-
 let target$1;
-
-function createOnceHandler$1 (event, handler, capture) {
-  const _target = target$1; // save current target element in closure
-  return function onceHandler () {
-    const res = handler.apply(null, arguments);
-    if (res !== null) {
-      remove$2(event, onceHandler, capture, _target);
-    }
-  }
+function createOnceHandler$1(event, handler, capture) {
+    const _target = target$1; // save current target element in closure
+    return function onceHandler() {
+        const res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove$2(event, onceHandler, capture, _target);
+        }
+    };
 }
-
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-function add$1 (
-  name,
-  handler,
-  capture,
-  passive
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    const attachedTimestamp = currentFlushTimestamp;
-    const original = handler;
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    };
-  }
-  target$1.addEventListener(
-    name,
-    handler,
-    supportsPassive
-      ? { capture, passive }
-      : capture
-  );
-}
-
-function remove$2 (
-  name,
-  handler,
-  capture,
-  _target
-) {
-  (_target || target$1).removeEventListener(
-    name,
-    handler._wrapper || handler,
-    capture
-  );
-}
-
-function updateDOMListeners (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  const on = vnode.data.on || {};
-  const oldOn = oldVnode.data.on || {};
-  target$1 = vnode.elm;
-  normalizeEvents(on);
-  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-  target$1 = undefined;
+function add$1(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target$1.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+}
+function remove$2(name, handler, capture, _target) {
+    (_target || target$1).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    target$1 = vnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+    target$1 = undefined;
 }
-
 var events = {
-  create: updateDOMListeners,
-  update: updateDOMListeners
+    create: updateDOMListeners,
+    update: updateDOMListeners,
 };
 
-/*  */
-
+/* @flow */
 let svgContainer;
-
-function updateDOMProps (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  let key, cur;
-  const elm = vnode.elm;
-  const oldProps = oldVnode.data.domProps || {};
-  let props = vnode.data.domProps || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
-    props = vnode.data.domProps = extend({}, props);
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      elm[key] = '';
-    }
-  }
-
-  for (key in props) {
-    cur = props[key];
-    // ignore children if the node has textContent or innerHTML,
-    // as these will throw away existing DOM nodes and cause removal errors
-    // on subsequent patches (#3360)
-    if (key === 'textContent' || key === 'innerHTML') {
-      if (vnode.children) vnode.children.length = 0;
-      if (cur === oldProps[key]) continue
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0]);
-      }
-    }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // store value as _value as well since
-      // non-string values will be stringified
-      elm._value = cur;
-      // avoid resetting cursor position when value is the same
-      const strCur = isUndef(cur) ? '' : String(cur);
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur;
-      }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div');
-      svgContainer.innerHTML = `<svg>${cur}</svg>`;
-      const svg = svgContainer.firstChild;
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild);
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild);
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecessary `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur;
-      } catch (e) {}
-    }
-  }
-}
-
-// check platforms/web/util/attrs.js acceptValue
-
-
-function shouldUpdateValue (elm, checkVal) {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
-}
-
-function isNotInFocusAndDirty (elm, checkVal) {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  let notInFocus = true;
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm; } catch (e) {}
-  return notInFocus && elm.value !== checkVal
-}
-
-function isDirtyWithModifiers (elm, newVal) {
-  const value = elm.value;
-  const modifiers = elm._vModifiers; // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
-    }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
-    }
-  }
-  return value !== newVal
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                vnode.children.length = 0;
+            if (cur === oldProps[key])
+                continue;
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            const strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    let notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
 }
-
 var domProps = {
-  create: updateDOMProps,
-  update: updateDOMProps
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-/*  */
-
+/* @flow */
 const parseStyleText = cached(function (cssText) {
-  const res = {};
-  const listDelimiter = /;(?![^(]*\))/g;
-  const propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      const tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  const style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  const res = {};
-  let styleData;
-
-  if (checkChild) {
-    let childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  let parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    let parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 const cssVarRE = /^--/;
 const importantRE = /\s*!important$/;
 const setProp = (el, name, val) => {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val);
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-  } else {
-    const normalizedName = normalize(name);
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (let i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i];
-      }
-    } else {
-      el.style[normalizedName] = val;
-    }
-  }
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        const normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (let i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
 };
-
 const vendorNames = ['Webkit', 'Moz', 'ms'];
-
 let emptyStyle;
 const normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style;
-  prop = camelize(prop);
-  if (prop !== 'filter' && (prop in emptyStyle)) {
-    return prop
-  }
-  const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-  for (let i = 0; i < vendorNames.length; i++) {
-    const name = vendorNames[i] + capName;
-    if (name in emptyStyle) {
-      return name
-    }
-  }
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
 });
-
-function updateStyle (oldVnode, vnode) {
-  const data = vnode.data;
-  const oldData = oldVnode.data;
-
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  let cur, name;
-  const el = vnode.elm;
-  const oldStaticStyle = oldData.staticStyle;
-  const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  const oldStyle = oldStaticStyle || oldStyleBinding;
-
-  const style = normalizeStyleBinding(vnode.data.style) || {};
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style;
-
-  const newStyle = getStyle(vnode, true);
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      setProp(el, name, '');
+function updateStyle(oldVnode, vnode) {
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    const newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
     }
-  }
-  for (name in newStyle) {
-    cur = newStyle[name];
-    if (cur !== oldStyle[name]) {
-      // ie9 setting to null has no effect, must use empty string
-      setProp(el, name, cur == null ? '' : cur);
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
     }
-  }
 }
-
 var style = {
-  create: updateStyle,
-  update: updateStyle
+    create: updateStyle,
+    update: updateStyle,
 };
 
-/*  */
-
+/* @flow */
 const whitespaceRE = /\s+/;
-
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.add(c));
-    } else {
-      el.classList.add(cls);
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
+        }
+        else {
+            el.classList.add(cls);
+        }
     }
-  } else {
-    const cur = ` ${el.getAttribute('class') || ''} `;
-    if (cur.indexOf(' ' + cls + ' ') < 0) {
-      el.setAttribute('class', (cur + cls).trim());
+    else {
+        const cur = ` ${el.getAttribute('class') || ''} `;
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
     }
-  }
 }
-
 /**
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(c => el.classList.remove(c));
-    } else {
-      el.classList.remove(cls);
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class');
-    }
-  } else {
-    let cur = ` ${el.getAttribute('class') || ''} `;
-    const tar = ' ' + cls + ' ';
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ');
-    }
-    cur = cur.trim();
-    if (cur) {
-      el.setAttribute('class', cur);
-    } else {
-      el.removeAttribute('class');
-    }
-  }
-}
-
-/*  */
-
-function resolveTransition (def$$1) {
-  if (!def$$1) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def$$1 === 'object') {
-    const res = {};
-    if (def$$1.css !== false) {
-      extend(res, autoCssTransition(def$$1.name || 'v'));
-    }
-    extend(res, def$$1);
-    return res
-  } else if (typeof def$$1 === 'string') {
-    return autoCssTransition(def$$1)
-  }
-}
-
-const autoCssTransition = cached(name => {
-  return {
-    enterClass: `${name}-enter`,
-    enterToClass: `${name}-enter-to`,
-    enterActiveClass: `${name}-enter-active`,
-    leaveClass: `${name}-leave`,
-    leaveToClass: `${name}-leave-to`,
-    leaveActiveClass: `${name}-leave-active`
-  }
-});
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
+}
 
+function resolveTransition(def$$1) {
+    if (!def$$1) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def$$1 === 'object') {
+        const res = {};
+        if (def$$1.css !== false) {
+            extend(res, autoCssTransition(def$$1.name || 'v'));
+        }
+        extend(res, def$$1);
+        return res;
+    }
+    else if (typeof def$$1 === 'string') {
+        return autoCssTransition(def$$1);
+    }
+}
+const autoCssTransition = cached((name) => {
+    return {
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
+    };
+});
 const hasTransition = inBrowser && !isIE9;
 const TRANSITION = 'transition';
 const ANIMATION = 'animation';
-
 // Transition property/event sniffing
 let transitionProp = 'transition';
 let transitionEndEvent = 'transitionend';
 let animationProp = 'animation';
 let animationEndEvent = 'animationend';
 if (hasTransition) {
-  /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    transitionProp = 'WebkitTransition';
-    transitionEndEvent = 'webkitTransitionEnd';
-  }
-  if (window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    animationProp = 'WebkitAnimation';
-    animationEndEvent = 'webkitAnimationEnd';
-  }
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
 }
-
 // binding to window is necessary to make hot reload work in IE in strict mode
 const raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ fn => fn();
-
-function nextFrame (fn) {
-  raf(() => {
-    raf(fn);
-  });
-}
-
-function addTransitionClass (el, cls) {
-  const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls);
-    addClass(el, cls);
-  }
-}
-
-function removeTransitionClass (el, cls) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls);
-  }
-  removeClass(el, cls);
-}
-
-function whenTransitionEnds (
-  el,
-  expectedType,
-  cb
-) {
-  const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-  if (!type) return cb()
-  const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-  let ended = 0;
-  const end = () => {
-    el.removeEventListener(event, onEnd);
-    cb();
-  };
-  const onEnd = e => {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end();
-      }
-    }
-  };
-  setTimeout(() => {
-    if (ended < propCount) {
-      end();
-    }
-  }, timeout + 1);
-  el.addEventListener(event, onEnd);
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ (fn) => fn();
+function nextFrame(fn) {
+    raf(() => {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type)
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    const onEnd = (e) => {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(() => {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
 }
-
 const transformRE = /\b(transform|all)(,|$)/;
-
-function getTransitionInfo (el, expectedType) {
-  const styles = window.getComputedStyle(el);
-  // JSDOM may return undefined for transition properties
-  const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-  const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-  const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-  const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-  const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-  const animationTimeout = getTimeout(animationDelays, animationDurations);
-
-  let type;
-  let timeout = 0;
-  let propCount = 0;
-  /* istanbul ignore if */
-  if (expectedType === TRANSITION) {
-    if (transitionTimeout > 0) {
-      type = TRANSITION;
-      timeout = transitionTimeout;
-      propCount = transitionDurations.length;
-    }
-  } else if (expectedType === ANIMATION) {
-    if (animationTimeout > 0) {
-      type = ANIMATION;
-      timeout = animationTimeout;
-      propCount = animationDurations.length;
-    }
-  } else {
-    timeout = Math.max(transitionTimeout, animationTimeout);
-    type = timeout > 0
-      ? transitionTimeout > animationTimeout
-        ? TRANSITION
-        : ANIMATION
-      : null;
-    propCount = type
-      ? type === TRANSITION
-        ? transitionDurations.length
-        : animationDurations.length
-      : 0;
-  }
-  const hasTransform =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property']);
-  return {
-    type,
-    timeout,
-    propCount,
-    hasTransform
-  }
-}
-
-function getTimeout (delays, durations) {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
-  }
-
-  return Math.max.apply(null, durations.map((d, i) => {
-    return toMs(d) + toMs(delays[i])
-  }))
+function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type,
+        timeout,
+        propCount,
+        hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map((d, i) => {
+        return toMs(d) + toMs(delays[i]);
+    }));
 }
-
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs (s) {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
-}
-
-/*  */
-
-function enter (vnode, toggleDisplay) {
-  const el = vnode.elm;
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true;
-    el._leaveCb();
-  }
-
-  const data = resolveTransition(vnode.data.transition);
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  const {
-    css,
-    type,
-    enterClass,
-    enterToClass,
-    enterActiveClass,
-    appearClass,
-    appearToClass,
-    appearActiveClass,
-    beforeEnter,
-    enter,
-    afterEnter,
-    enterCancelled,
-    beforeAppear,
-    appear,
-    afterAppear,
-    appearCancelled,
-    duration
-  } = data;
-
-  // activeInstance will always be the <transition> component managing this
-  // transition. One edge case to check is when the <transition> is placed
-  // as the root node of a child component. In that case we need to check
-  // <transition>'s parent for appear check.
-  let context = activeInstance;
-  let transitionNode = activeInstance.$vnode;
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context;
-    transitionNode = transitionNode.parent;
-  }
-
-  const isAppear = !context._isMounted || !vnode.isRootInsert;
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  const startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass;
-  const activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass;
-  const toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass;
-
-  const beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter;
-  const enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
-    : enter;
-  const afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter;
-  const enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
-    : enterCancelled;
-
-  const explicitEnterDuration = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
-  );
-
-  if (explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode);
-  }
-
-  const expectsCSS = css !== false && !isIE9;
-  const userWantsControl = getHookArgumentsLength(enterHook);
-
-  const cb = el._enterCb = once(() => {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass);
-      removeTransitionClass(el, activeClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, startClass);
-      }
-      enterCancelledHook && enterCancelledHook(el);
-    } else {
-      afterEnterHook && afterEnterHook(el);
-    }
-    el._enterCb = null;
-  });
-
-  if (!vnode.data.show) {
-    // remove pending leave element on enter by injecting an insert hook
-    mergeVNodeHook(vnode, 'insert', () => {
-      const parent = el.parentNode;
-      const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-      if (pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb();
-      }
-      enterHook && enterHook(el, cb);
-    });
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el);
-  if (expectsCSS) {
-    addTransitionClass(el, startClass);
-    addTransitionClass(el, activeClass);
-    nextFrame(() => {
-      removeTransitionClass(el, startClass);
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass);
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration);
-          } else {
-            whenTransitionEnds(el, type, cb);
-          }
-        }
-      }
-    });
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay();
-    enterHook && enterHook(el, cb);
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb();
-  }
-}
-
-function leave (vnode, rm) {
-  const el = vnode.elm;
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true;
-    el._enterCb();
-  }
-
-  const data = resolveTransition(vnode.data.transition);
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  const {
-    css,
-    type,
-    leaveClass,
-    leaveToClass,
-    leaveActiveClass,
-    beforeLeave,
-    leave,
-    afterLeave,
-    leaveCancelled,
-    delayLeave,
-    duration
-  } = data;
-
-  const expectsCSS = css !== false && !isIE9;
-  const userWantsControl = getHookArgumentsLength(leave);
-
-  const explicitLeaveDuration = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
-  );
-
-  if (isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode);
-  }
-
-  const cb = el._leaveCb = once(() => {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null;
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+/* @flow */
+function enter(vnode, toggleDisplay) {
+    const el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
     }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass);
-      removeTransitionClass(el, leaveActiveClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass);
-      }
-      leaveCancelled && leaveCancelled(el);
-    } else {
-      rm();
-      afterLeave && afterLeave(el);
-    }
-    el._leaveCb = null;
-  });
-
-  if (delayLeave) {
-    delayLeave(performLeave);
-  } else {
-    performLeave();
-  }
-
-  function performLeave () {
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
-    }
-    beforeLeave && beforeLeave(el);
-    if (expectsCSS) {
-      addTransitionClass(el, leaveClass);
-      addTransitionClass(el, leaveActiveClass);
-      nextFrame(() => {
-        removeTransitionClass(el, leaveClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-    leave && leave(el, cb);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
     if (!expectsCSS && !userWantsControl) {
-      cb();
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    const el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    const cb = (el._leaveCb = once(() => {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
     }
-  }
 }
-
 // only used in dev mode
-function checkDuration (val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      `<transition> explicit ${name} duration is not a valid number - ` +
-      `got ${JSON.stringify(val)}.`,
-      vnode.context
-    );
-  } else if (isNaN(val)) {
-    warn(
-      `<transition> explicit ${name} duration is NaN - ` +
-      'the duration expression might be incorrect.',
-      vnode.context
-    );
-  }
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn(`<transition> explicit ${name} duration is NaN - ` +
+            'the duration expression might be incorrect.', vnode.context);
+    }
 }
-
-function isValidDuration (val) {
-  return typeof val === 'number' && !isNaN(val)
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
 }
-
 /**
  * Normalize a transition hook's argument length. The hook may be:
  * - a merged hook (invoker) with the original in .fns
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength (fn) {
-  if (isUndef(fn)) {
-    return false
-  }
-  const invokerFns = fn.fns;
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
-    )
-  } else {
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter (_, vnode) {
-  if (vnode.data.show !== true) {
-    enter(vnode);
-  }
-}
-
-var transition = inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove (vnode, rm) {
-    /* istanbul ignore else */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    const invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-      leave(vnode, rm);
-    } else {
-      rm();
-    }
-  }
-} : {};
-
-var platformModules = [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-];
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
+    }
+    : {};
 
-/*  */
+var platformModules = [attrs, klass, events, domProps, style, transition];
 
+/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 const modules = platformModules.concat(baseModules);
-
 const patch = createPatchFunction({ nodeOps, modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
  * properties to Elements.
  */
-
 /* istanbul ignore if */
 if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', () => {
-    const el = document.activeElement;
-    if (el && el.vmodel) {
-      trigger(el, 'input');
-    }
-  });
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
 }
-
 const directive = {
-  inserted (el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-          directive.componentUpdated(el, binding, vnode);
-        });
-      } else {
-        setSelected(el, binding, vnode.context);
-      }
-      el._vOptions = [].map.call(el.options, getValue);
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers;
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart);
-        el.addEventListener('compositionend', onCompositionEnd);
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd);
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true;
-        }
-      }
-    }
-  },
-
-  componentUpdated (el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context);
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      const prevOptions = el._vOptions;
-      const curOptions = el._vOptions = [].map.call(el.options, getValue);
-      if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-        // trigger change event if
-        // no matching option found for at least one value
-        const needReset = el.multiple
-          ? binding.value.some(v => hasNoMatchingOption(v, curOptions))
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-        if (needReset) {
-          trigger(el, 'change');
-        }
-      }
-    }
-  }
+    inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', () => {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                // trigger change event if
+                // no matching option found for at least one value
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
 };
-
-function setSelected (el, binding, vm) {
-  actuallySetSelected(el, binding, vm);
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(() => {
-      actuallySetSelected(el, binding, vm);
-    }, 0);
-  }
-}
-
-function actuallySetSelected (el, binding, vm) {
-  const value = binding.value;
-  const isMultiple = el.multiple;
-  if (isMultiple && !Array.isArray(value)) {
-    warn(
-      `<select multiple v-model="${binding.expression}"> ` +
-      `expects an Array value for its binding, but got ${
-        Object.prototype.toString.call(value).slice(8, -1)
-      }`,
-      vm
-    );
-    return
-  }
-  let selected, option;
-  for (let i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i];
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1;
-      if (option.selected !== selected) {
-        option.selected = selected;
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i;
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(() => {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    const value = binding.value;
+    const isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        warn(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+        return;
+    }
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
         }
-        return
-      }
     }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1;
-  }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
 }
-
-function hasNoMatchingOption (value, options) {
-  return options.every(o => !looseEqual(o, value))
+function hasNoMatchingOption(value, options) {
+    return options.every((o) => !looseEqual(o, value));
 }
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
 }
-
-function onCompositionStart (e) {
-  e.target.composing = true;
+function onCompositionStart(e) {
+    e.target.composing = true;
 }
-
-function onCompositionEnd (e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) return
-  e.target.composing = false;
-  trigger(e.target, 'input');
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        return;
+    e.target.composing = false;
+    trigger(e.target, 'input');
 }
-
-function trigger (el, type) {
-  const e = document.createEvent('HTMLEvents');
-  e.initEvent(type, true, true);
-  el.dispatchEvent(e);
+function trigger(el, type) {
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-/*  */
-
+/* @flow */
 // recursively search for possible transition defined inside the component root
-function locateNode (vnode) {
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
-    : vnode
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
 }
-
 var show = {
-  bind (el, { value }, vnode) {
-    vnode = locateNode(vnode);
-    const transition$$1 = vnode.data && vnode.data.transition;
-    const originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display;
-    if (value && transition$$1) {
-      vnode.data.show = true;
-      enter(vnode, () => {
-        el.style.display = originalDisplay;
-      });
-    } else {
-      el.style.display = value ? originalDisplay : 'none';
-    }
-  },
-
-  update (el, { value, oldValue }, vnode) {
-    /* istanbul ignore if */
-    if (!value === !oldValue) return
-    vnode = locateNode(vnode);
-    const transition$$1 = vnode.data && vnode.data.transition;
-    if (transition$$1) {
-      vnode.data.show = true;
-      if (value) {
-        enter(vnode, () => {
-          el.style.display = el.__vOriginalDisplay;
-        });
-      } else {
-        leave(vnode, () => {
-          el.style.display = 'none';
-        });
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none';
-    }
-  },
-
-  unbind (
-    el,
-    binding,
-    vnode,
-    oldVnode,
-    isDestroy
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay;
-    }
-  }
+    bind(el, { value }, vnode) {
+        vnode = locateNode(vnode);
+        const transition$$1 = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition$$1) {
+            vnode.data.show = true;
+            enter(vnode, () => {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update(el, { value, oldValue }, vnode) {
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        const transition$$1 = vnode.data && vnode.data.transition;
+        if (transition$$1) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, () => {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, () => {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
 var platformDirectives = {
-  model: directive,
-  show
+    model: directive,
+    show,
 };
 
-/*  */
-
+/* @flow */
 const transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
 };
-
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode) {
-  const compOptions = vnode && vnode.componentOptions;
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-function extractTransitionData (comp) {
-  const data = {};
-  const options = comp.$options;
-  // props
-  for (const key in options.propsData) {
-    data[key] = comp[key];
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  const listeners = options._parentListeners;
-  for (const key in listeners) {
-    data[camelize(key)] = listeners[key];
-  }
-  return data
-}
-
-function placeholder (h, rawChild) {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
+function getRealChild(vnode) {
+    const compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    const data = {};
+    const options = comp.$options;
+    // props
+    for (const key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
 }
-
-function hasParentTransition (vnode) {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
     }
-  }
 }
-
-function isSameChild (child, oldChild) {
-  return oldChild.key === child.key && oldChild.tag === child.tag
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-
 const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-
-const isVShowDirective = d => d.name === 'show';
-
+const isVShowDirective = (d) => d.name === 'show';
 var Transition = {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render (h) {
-    let children = this.$slots.default;
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode);
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      );
-    }
-
-    const mode = this.mode;
-
-    // warn invalid mode
-    if (mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      );
-    }
-
-    const rawChild = children[0];
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    const child = getRealChild(rawChild);
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    const id = `__transition-${this._uid}-`;
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key;
-
-    const data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-    const oldRawChild = this._vnode;
-    const oldChild = getRealChild(oldRawChild);
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true;
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      const oldData = oldChild.data.transition = extend({}, data);
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true;
-        mergeVNodeHook(oldData, 'afterLeave', () => {
-          this._leaving = false;
-          this.$forceUpdate();
-        });
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render(h) {
+        let children = this.$slots.default;
+        if (!children) {
+            return;
         }
-        let delayedLeave;
-        const performLeave = () => { delayedLeave(); };
-        mergeVNodeHook(data, 'afterEnter', performLeave);
-        mergeVNodeHook(data, 'enterCancelled', performLeave);
-        mergeVNodeHook(oldData, 'delayLeave', leave => { delayedLeave = leave; });
-      }
-    }
-
-    return rawChild
-  }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        const mode = this.mode;
+        // warn invalid mode
+        if (mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        const rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        const child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        const id = `__transition-${this._uid}-`;
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            const oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-/*  */
-
+// Provides transition support for list items.
 const props = extend({
-  tag: String,
-  moveClass: String
+    tag: String,
+    moveClass: String,
 }, transitionProps);
-
+// @ts-ignore
 delete props.mode;
-
 var TransitionGroup = {
-  props,
-
-  beforeMount () {
-    const update = this._update;
-    this._update = (vnode, hydrating) => {
-      const restoreActiveInstance = setActiveInstance(this);
-      // force removing pass
-      this.__patch__(
-        this._vnode,
-        this.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      );
-      this._vnode = this.kept;
-      restoreActiveInstance();
-      update.call(this, vnode, hydrating);
-    };
-  },
-
-  render (h) {
-    const tag = this.tag || this.$vnode.data.tag || 'span';
-    const map = Object.create(null);
-    const prevChildren = this.prevChildren = this.children;
-    const rawChildren = this.$slots.default || [];
-    const children = this.children = [];
-    const transitionData = extractTransitionData(this);
-
-    for (let i = 0; i < rawChildren.length; i++) {
-      const c = rawChildren[i];
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c);
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData;
-        } else {
-          const opts = c.componentOptions;
-          const name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-          warn(`<transition-group> children must be keyed: <${name}>`);
-        }
-      }
-    }
-
-    if (prevChildren) {
-      const kept = [];
-      const removed = [];
-      for (let i = 0; i < prevChildren.length; i++) {
-        const c = prevChildren[i];
-        c.data.transition = transitionData;
-        c.data.pos = c.elm.getBoundingClientRect();
-        if (map[c.key]) {
-          kept.push(c);
-        } else {
-          removed.push(c);
-        }
-      }
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated () {
-    const children = this.prevChildren;
-    const moveClass = this.moveClass || ((this.name || 'v') + '-move');
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs);
-    children.forEach(recordPosition);
-    children.forEach(applyTranslation);
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight;
-
-    children.forEach((c) => {
-      if (c.data.moved) {
-        const el = c.elm;
-        const s = el.style;
-        addTransitionClass(el, moveClass);
-        s.transform = s.WebkitTransform = s.transitionDuration = '';
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb);
-            el._moveCb = null;
-            removeTransitionClass(el, moveClass);
-          }
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
+            // force removing pass
+            this.__patch__(this._vnode, this.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this._vnode = this.kept;
+            restoreActiveInstance();
+            update.call(this, vnode, hydrating);
+        };
+    },
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || 'span';
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ''
+                        : c.tag;
+                    warn(`<transition-group> children must be keyed: <${name}>`);
+                }
+            }
+        }
+        if (prevChildren) {
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-ignore
+                c.data.pos = c.elm.getBoundingClientRect();
+                // @ts-ignore
+                if (map[c.key]) {
+                    kept.push(c);
+                }
+                else {
+                    removed.push(c);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || 'v') + '-move';
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach((c) => {
+            // @ts-ignore
+            if (c.data.moved) {
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
         });
-      }
-    });
-  },
-
-  methods: {
-    hasMove (el, moveClass) {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      const clone = el.cloneNode();
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach((cls) => { removeClass(clone, cls); });
-      }
-      addClass(clone, moveClass);
-      clone.style.display = 'none';
-      this.$el.appendChild(clone);
-      const info = getTransitionInfo(clone);
-      this.$el.removeChild(clone);
-      return (this._hasMove = info.hasTransform)
-    }
-  }
+    },
+    methods: {
+        hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            const clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach((cls) => {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = 'none';
+            this.$el.appendChild(clone);
+            const info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
 };
-
-function callPendingCbs (c) {
-  /* istanbul ignore if */
-  if (c.elm._moveCb) {
-    c.elm._moveCb();
-  }
-  /* istanbul ignore if */
-  if (c.elm._enterCb) {
-    c.elm._enterCb();
-  }
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._moveCb) {
+        //@ts-ignore
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._enterCb) {
+        //@ts-ignore
+        c.elm._enterCb();
+    }
 }
-
-function recordPosition (c) {
-  c.data.newPos = c.elm.getBoundingClientRect();
+function recordPosition(c) {
+    //@ts-ignore
+    c.data.newPos = c.elm.getBoundingClientRect();
 }
-
-function applyTranslation (c) {
-  const oldPos = c.data.pos;
-  const newPos = c.data.newPos;
-  const dx = oldPos.left - newPos.left;
-  const dy = oldPos.top - newPos.top;
-  if (dx || dy) {
-    c.data.moved = true;
-    const s = c.elm.style;
-    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-    s.transitionDuration = '0s';
-  }
+function applyTranslation(c) {
+    //@ts-ignore
+    const oldPos = c.data.pos;
+    //@ts-ignore
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        //@ts-ignore
+        c.data.moved = true;
+        //@ts-ignore
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = '0s';
+    }
 }
 
 var platformComponents = {
-  Transition,
-  TransitionGroup
+    Transition,
+    TransitionGroup,
 };
 
-/*  */
-
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp;
 Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
 Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
-
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
 extend(Vue.options.components, platformComponents);
-
 // install platform patch function
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
 // public mount method
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && inBrowser ? query(el) : undefined;
-  return mountComponent(this, el, hydrating)
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
 };
-
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-  setTimeout(() => {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue);
-      } else {
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
-        );
-      }
-    }
-    if (config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      console[console.info ? 'info' : 'log'](
-        `You are running Vue in development mode.\n` +
-        `Make sure to turn on production mode when deploying for production.\n` +
-        `See more tips at https://vuejs.org/guide/deployment.html`
-      );
-    }
-  }, 0);
+    setTimeout(() => {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
+        }
+    }, 0);
 }
 
-/*  */
-
+/* @flow */
 const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
-const buildRegex = cached(delimiters => {
-  const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  const tokens = [];
-  const rawTokens = [];
-  let lastIndex = tagRE.lastIndex = 0;
-  let match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    const exp = parseFilters(match[1].trim());
-    tokens.push(`_s(${exp})`);
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
-
-/*  */
-
-function transformNode (el, options) {
-  const warn = options.warn || baseWarn;
-  const staticClass = getAndRemoveAttr(el, 'class');
-  if (staticClass) {
-    const res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        `class="${staticClass}": ` +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
-}
-
-function genData (el) {
-  let data = '';
-  if (el.staticClass) {
-    data += `staticClass:${el.staticClass},`;
-  }
-  if (el.classBinding) {
-    data += `class:${el.classBinding},`;
-  }
-  return data
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
+/* @flow */
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass);
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
 var klass$1 = {
-  staticKeys: ['staticClass'],
-  transformNode,
-  genData
+    staticKeys: ['staticClass'],
+    transformNode,
+    genData,
 };
 
-/*  */
-
-function transformNode$1 (el, options) {
-  const warn = options.warn || baseWarn;
-  const staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    {
-      const res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          `style="${staticStyle}": ` +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
+/* @flow */
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
     }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
 }
-
-function genData$1 (el) {
-  let data = '';
-  if (el.staticStyle) {
-    data += `staticStyle:${el.staticStyle},`;
-  }
-  if (el.styleBinding) {
-    data += `style:(${el.styleBinding}),`;
-  }
-  return data
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
 }
-
 var style$1 = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
-};
-
-/*  */
-
-let decoder;
-
-var he = {
-  decode (html) {
-    decoder = decoder || document.createElement('div');
-    decoder.innerHTML = html;
-    return decoder.textContent
-  }
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode$1,
+    genData: genData$1,
 };
 
-/*  */
+/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+(function(root) {
+
+	// Detect free variables `exports`.
+	var freeExports = typeof exports == 'object' && exports;
+
+	// Detect free variable `module`.
+	var freeModule = typeof module == 'object' && module &&
+		module.exports == freeExports && module;
+
+	// Detect free variable `global`, from Node.js or Browserified code,
+	// and use it as `root`.
+	var freeGlobal = typeof global == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	// All astral symbols.
+	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	// All ASCII symbols (not just printable ASCII) except those listed in the
+	// first column of the overrides table.
+	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+	var regexAsciiWhitelist = /[\x01-\x7F]/g;
+	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+	// code points listed in the first column of the overrides table on
+	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+	var regexEscape = /["&'<>`]/g;
+	var escapeMap = {
+		'"': '&quot;',
+		'&': '&amp;',
+		'\'': '&#x27;',
+		'<': '&lt;',
+		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+		// following is not strictly necessary unless it’s part of a tag or an
+		// unquoted attribute value. We’re only escaping it to support those
+		// situations, and for XML support.
+		'>': '&gt;',
+		// In Internet Explorer ≤ 8, the backtick character can be used
+		// to break out of (un)quoted attribute values or HTML comments.
+		// See http://html5sec.org/#102, http://html5sec.org/#108, and
+		// http://html5sec.org/#133.
+		'`': '&#x60;'
+	};
+
+	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+	/*--------------------------------------------------------------------------*/
+
+	var stringFromCharCode = String.fromCharCode;
+
+	var object = {};
+	var hasOwnProperty = object.hasOwnProperty;
+	var has = function(object, propertyName) {
+		return hasOwnProperty.call(object, propertyName);
+	};
+
+	var contains = function(array, value) {
+		var index = -1;
+		var length = array.length;
+		while (++index < length) {
+			if (array[index] == value) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+	var merge = function(options, defaults) {
+		if (!options) {
+			return defaults;
+		}
+		var result = {};
+		var key;
+		for (key in defaults) {
+			// A `hasOwnProperty` check is not needed here, since only recognized
+			// option names are used anyway. Any others are ignored.
+			result[key] = has(options, key) ? options[key] : defaults[key];
+		}
+		return result;
+	};
+
+	// Modified version of `ucs2encode`; see https://mths.be/punycode.
+	var codePointToSymbol = function(codePoint, strict) {
+		var output = '';
+		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+			// See issue #4:
+			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+			// REPLACEMENT CHARACTER.”
+			if (strict) {
+				parseError('character reference outside the permissible Unicode range');
+			}
+			return '\uFFFD';
+		}
+		if (has(decodeMapNumeric, codePoint)) {
+			if (strict) {
+				parseError('disallowed character reference');
+			}
+			return decodeMapNumeric[codePoint];
+		}
+		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+			parseError('disallowed character reference');
+		}
+		if (codePoint > 0xFFFF) {
+			codePoint -= 0x10000;
+			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+			codePoint = 0xDC00 | codePoint & 0x3FF;
+		}
+		output += stringFromCharCode(codePoint);
+		return output;
+	};
+
+	var hexEscape = function(codePoint) {
+		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+	};
+
+	var decEscape = function(codePoint) {
+		return '&#' + codePoint + ';';
+	};
+
+	var parseError = function(message) {
+		throw Error('Parse error: ' + message);
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var encode = function(string, options) {
+		options = merge(options, encode.options);
+		var strict = options.strict;
+		if (strict && regexInvalidRawCodePoint.test(string)) {
+			parseError('forbidden code point');
+		}
+		var encodeEverything = options.encodeEverything;
+		var useNamedReferences = options.useNamedReferences;
+		var allowUnsafeSymbols = options.allowUnsafeSymbols;
+		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+		var escapeBmpSymbol = function(symbol) {
+			return escapeCodePoint(symbol.charCodeAt(0));
+		};
+
+		if (encodeEverything) {
+			// Encode ASCII symbols.
+			string = string.replace(regexAsciiWhitelist, function(symbol) {
+				// Use named references if requested & possible.
+				if (useNamedReferences && has(encodeMap, symbol)) {
+					return '&' + encodeMap[symbol] + ';';
+				}
+				return escapeBmpSymbol(symbol);
+			});
+			// Shorten a few escapes that represent two symbols, of which at least one
+			// is within the ASCII range.
+			if (useNamedReferences) {
+				string = string
+					.replace(/&gt;\u20D2/g, '&nvgt;')
+					.replace(/&lt;\u20D2/g, '&nvlt;')
+					.replace(/&#x66;&#x6A;/g, '&fjlig;');
+			}
+			// Encode non-ASCII symbols.
+			if (useNamedReferences) {
+				// Encode non-ASCII symbols that can be replaced with a named reference.
+				string = string.replace(regexEncodeNonAscii, function(string) {
+					// Note: there is no need to check `has(encodeMap, string)` here.
+					return '&' + encodeMap[string] + ';';
+				});
+			}
+			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+		} else if (useNamedReferences) {
+			// Apply named character references.
+			// Encode `<>"'&` using named character references.
+			if (!allowUnsafeSymbols) {
+				string = string.replace(regexEscape, function(string) {
+					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+				});
+			}
+			// Shorten escapes that represent two symbols, of which at least one is
+			// `<>"'&`.
+			string = string
+				.replace(/&gt;\u20D2/g, '&nvgt;')
+				.replace(/&lt;\u20D2/g, '&nvlt;');
+			// Encode non-ASCII symbols that can be replaced with a named reference.
+			string = string.replace(regexEncodeNonAscii, function(string) {
+				// Note: there is no need to check `has(encodeMap, string)` here.
+				return '&' + encodeMap[string] + ';';
+			});
+		} else if (!allowUnsafeSymbols) {
+			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+			// using named character references.
+			string = string.replace(regexEscape, escapeBmpSymbol);
+		}
+		return string
+			// Encode astral symbols.
+			.replace(regexAstralSymbols, function($0) {
+				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+				var high = $0.charCodeAt(0);
+				var low = $0.charCodeAt(1);
+				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+				return escapeCodePoint(codePoint);
+			})
+			// Encode any remaining BMP symbols that are not printable ASCII symbols
+			// using a hexadecimal escape.
+			.replace(regexBmpWhitelist, escapeBmpSymbol);
+	};
+	// Expose default options (so they can be overridden globally).
+	encode.options = {
+		'allowUnsafeSymbols': false,
+		'encodeEverything': false,
+		'strict': false,
+		'useNamedReferences': false,
+		'decimal' : false
+	};
+
+	var decode = function(html, options) {
+		options = merge(options, decode.options);
+		var strict = options.strict;
+		if (strict && regexInvalidEntity.test(html)) {
+			parseError('malformed character reference');
+		}
+		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+			var codePoint;
+			var semicolon;
+			var decDigits;
+			var hexDigits;
+			var reference;
+			var next;
+
+			if ($1) {
+				reference = $1;
+				// Note: there is no need to check `has(decodeMap, reference)`.
+				return decodeMap[reference];
+			}
+
+			if ($2) {
+				// Decode named character references without trailing `;`, e.g. `&amp`.
+				// This is only a parse error if it gets converted to `&`, or if it is
+				// followed by `=` in an attribute context.
+				reference = $2;
+				next = $3;
+				if (next && options.isAttributeValue) {
+					if (strict && next == '=') {
+						parseError('`&` did not start a character reference');
+					}
+					return $0;
+				} else {
+					if (strict) {
+						parseError(
+							'named character reference was not terminated by a semicolon'
+						);
+					}
+					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+					return decodeMapLegacy[reference] + (next || '');
+				}
+			}
+
+			if ($4) {
+				// Decode decimal escapes, e.g. `&#119558;`.
+				decDigits = $4;
+				semicolon = $5;
+				if (strict && !semicolon) {
+					parseError('character reference was not terminated by a semicolon');
+				}
+				codePoint = parseInt(decDigits, 10);
+				return codePointToSymbol(codePoint, strict);
+			}
+
+			if ($6) {
+				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+				hexDigits = $6;
+				semicolon = $7;
+				if (strict && !semicolon) {
+					parseError('character reference was not terminated by a semicolon');
+				}
+				codePoint = parseInt(hexDigits, 16);
+				return codePointToSymbol(codePoint, strict);
+			}
+
+			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+			if (strict) {
+				parseError(
+					'named character reference was not terminated by a semicolon'
+				);
+			}
+			return $0;
+		});
+	};
+	// Expose default options (so they can be overridden globally).
+	decode.options = {
+		'isAttributeValue': false,
+		'strict': false
+	};
+
+	var escape = function(string) {
+		return string.replace(regexEscape, function($0) {
+			// Note: there is no need to check `has(escapeMap, $0)` here.
+			return escapeMap[$0];
+		});
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var he = {
+		'version': '1.2.0',
+		'encode': encode,
+		'decode': decode,
+		'escape': escape,
+		'unescape': decode
+	};
+
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define(function() {
+			return he;
+		});
+	}	else if (freeExports && !freeExports.nodeType) {
+		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = he;
+		} else { // in Narwhal or RingoJS v0.7.0-
+			for (var key in he) {
+				has(he, key) && (freeExports[key] = he[key]);
+			}
+		}
+	} else { // in Rhino or a web browser
+		root.he = he;
+	}
+
+}(undefined));
+
+var he = /*#__PURE__*/Object.freeze({
 
-const isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
+});
 
+/* @flow */
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-const canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
 const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
 const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
 const startTagOpen = new RegExp(`^<${qnameCapture}`);
@@ -9270,309 +8459,287 @@ const doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 const comment = /^<!\--/;
 const conditionalComment = /^<!\[/;
-
 // Special Elements (can contain anything)
 const isPlainTextElement = makeMap('script,style,textarea', true);
 const reCache = {};
-
 const decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
 const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
 // #5992
 const isIgnoreNewlineTag = makeMap('pre,textarea', true);
 const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag$$1 = options.isUnaryTag || no;
+    const canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if (i > pos || !tagName &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
+}
 
-function decodeAttr (value, shouldDecodeNewlines) {
-  const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, match => decodingMap[match])
-}
-
-function parseHTML (html, options) {
-  const stack = [];
-  const expectHTML = options.expectHTML;
-  const isUnaryTag$$1 = options.isUnaryTag || no;
-  const canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  let index = 0;
-  let last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      let textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          const commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-            }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          const conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
-        }
-
-        // Doctype:
-        const doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
-        }
-
-        // End tag:
-        const endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          const curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
-        }
-
-        // Start tag:
-        const startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      let text, rest, next;
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) break
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      let endTagLength = 0;
-      const stackedTag = lastTag.toLowerCase();
-      const reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      const rest = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest.length;
-      html = rest;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (!stack.length && options.warn) {
-        options.warn(`Mal-formatted tag at end of template: "${html}"`, { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    const start = html.match(startTagOpen);
-    if (start) {
-      const match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      let end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    const tagName = match.tagName;
-    const unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    const unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    const l = match.attrs.length;
-    const attrs = new Array(l);
-    for (let i = 0; i < l; i++) {
-      const args = match.attrs[i];
-      const value = args[3] || args[4] || args[5] || '';
-      const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
-    }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
-    }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    let pos, lowerCasedTagName;
-    if (start == null) start = index;
-    if (end == null) end = index;
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
-    }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (let i = stack.length - 1; i >= pos; i--) {
-        if (i > pos || !tagName &&
-          options.warn
-        ) {
-          options.warn(
-            `tag <${stack[i].tag}> has no matching end tag.`,
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
-}
-
-/*  */
-
+/* @flow */
 const onRE = /^@|^v-on:/;
 const dirRE = /^v-|^@|^:|^#/;
 const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
 const stripParensRE = /^\(|\)$/g;
 const dynamicArgRE = /^\[.*\]$/;
-
 const argRE = /:(.*)$/;
 const bindRE = /^:|^\.|^v-bind:/;
 const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
 const slotRE = /^v-slot(:|$)|^#/;
-
 const lineBreakRE = /[\r\n]/;
-const whitespaceRE$1 = /\s+/g;
-
+const whitespaceRE$1 = /[ \f\t\r\n]+/g;
 const invalidAttributeRE = /[\s"'<>\/=]/;
-
-const decodeHTMLCached = cached(he.decode);
-
+const decodeHTMLCached = cached(undefined);
 const emptySlotScopeToken = `_empty_`;
-
 // configurable state
 let warn$2;
 let delimiters;
@@ -9583,1036 +8750,885 @@ let platformIsPreTag;
 let platformMustUseProp;
 let platformGetTagNamespace;
 let maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent,
-    children: []
-  }
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$2 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  const isReservedTag = options.isReservedTag || no;
-  maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  const stack = [];
-  const preserveWhitespace = options.preserveWhitespace !== false;
-  const whitespaceOption = options.whitespace;
-  let root;
-  let currentParent;
-  let inVPre = false;
-  let inPre = false;
-  let warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$2(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$2 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$2(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else {
-        warnOnce(
-          `Component template should contain exactly one root element. ` +
-          `If you are using v-if on multiple elements, ` +
-          `use v-else-if to chain them instead.`,
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          const name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
-    }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(c => !(c).slotScope);
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
-    }
-    // apply post-transforms
-    for (let i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
-    }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      let lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        `Cannot use <${el.tag}> as component root element because it may ` +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$2,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start (tag, attrs, unary, start, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      let element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      {
-        if (options.outputSourceRange) {
-          element.start = start;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(attr => {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$2(
-              `Invalid dynamic argument expression: attribute names cannot contain ` +
-              `spaces, quotes, <, >, / or =.`,
-              {
-                start: attr.start + attr.name.indexOf(`[`),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        warn$2(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          `<${tag}>` + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (let i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
         if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        {
-          checkRootConstraints(root);
+            inVPre = false;
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end (tag, start, end) {
-      const element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (options.outputSourceRange) {
-        element.end = end;
-      }
-      closeElement(element);
-    },
-
-    chars (text, start, end) {
-      if (!currentParent) {
-        {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              `text "${text}" outside root element will be ignored.`,
-              { start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      const children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE$1, ' ');
-        }
-        let res;
-        let child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text
-          };
-        }
-        if (child) {
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        const child = {
-          type: 3,
-          text,
-          isComment: true
-        };
-        if (options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
-        }
-        currentParent.children.push(child);
-      }
-    }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  const list = el.attrsList;
-  const len = list.length;
-  if (len) {
-    const attrs = el.attrs = new Array(len);
-    for (let i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (let i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  const exp = getBindingAttr(el, 'key');
-  if (exp) {
-    {
-      if (el.tag === 'template') {
-        warn$2(
-          `<template> cannot be keyed. Place the key on real elements instead.`,
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        const iterator = el.iterator2 || el.iterator1;
-        const parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$2(
-            `Do not use v-for index as key on <transition-group> children, ` +
-            `this is the same as not using keys.`,
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
-}
-
-function processRef (el) {
-  const ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
-}
-
-function processFor (el) {
-  let exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    const res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else {
-      warn$2(
-        `Invalid v-for expression: ${exp}`,
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-}
-
-
-
-function parseFor (exp) {
-  const inMatch = exp.match(forAliasRE);
-  if (!inMatch) return
-  const res = {};
-  res.for = inMatch[2].trim();
-  const alias = inMatch[1].trim().replace(stripParensRE, '');
-  const iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
-}
-
-function processIf (el) {
-  const exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$2,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$2(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn$2('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE$1, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
     });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
     }
-    const elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        {
+            if (el.tag === 'template') {
+                warn$2(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$2(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  const prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else {
-    warn$2(
-      `v-${el.elseif ? ('else-if="' + el.elseif + '"') : 'else'} ` +
-      `used on element <${el.tag}> without corresponding v-if.`,
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
-}
-
-function findPrevElement (children) {
-  let i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (children[i].text !== ' ') {
-        warn$2(
-          `text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-          `will be ignored.`,
-          children[i]
-        );
-      }
-      children.pop();
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
     }
-  }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn$2(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
 }
-
-function processOnce (el) {
-  const once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn$2(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn$2(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once$$1 = getAndRemoveAttr(el, 'v-once');
+    if (once$$1 != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  let slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (slotScope) {
-      warn$2(
-        `the "scope" attribute for scoped slots have been deprecated and ` +
-        `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-        `can also be used on plain elements in addition to <template> to ` +
-        `denote scoped slots.`,
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (el.attrsMap['v-for']) {
-      warn$2(
-        `Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-        `(v-for takes higher priority). Use a wrapper <template> for the ` +
-        `scoped slot to make it clearer.`,
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  const slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    let slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        {
-          if (el.slotTarget || el.slotScope) {
-            warn$2(
-              `Unexpected mixed usage of different slot syntaxes.`,
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$2(
-              `<template v-slot> can only appear at the root level inside ` +
-              `the receiving component`,
-              el
-            );
-          }
-        }
-        const { name, dynamic } = getSlotName(slotBinding);
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        {
-          if (!maybeComponent(el)) {
-            warn$2(
-              `v-slot can only be used on components or <template>.`,
-              slotBinding
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$2(
-              `Unexpected mixed usage of different slot syntaxes.`,
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$2(
-              `To avoid scope ambiguity, the default slot should also use ` +
-              `<template> syntax when there are other named slots.`,
-              slotBinding
-            );
-          }
-        }
-        // add the component's children to its default slot
-        const slots = el.scopedSlots || (el.scopedSlots = {});
-        const { name, dynamic } = getSlotName(slotBinding);
-        const slotContainer = slots[name] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name;
-        slotContainer.slotTargetDynamic = dynamic;
-        slotContainer.children = el.children.filter((c) => {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
-    }
-  }
-}
-
-function getSlotName (binding) {
-  let name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else {
-      warn$2(
-        `v-slot shorthand syntax requires a slot name.`,
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: `"${name}"`, dynamic: false }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn$2(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn$2(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$2(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$2(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn$2(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$2(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$2(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn$2(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (el.key) {
-      warn$2(
-        `\`key\` does not work on <slot> because slots are abstract outlets ` +
-        `and can possibly expand into multiple elements. ` +
-        `Use the key on a wrapping element instead.`,
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
-}
-
-function processComponent (el) {
-  let binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
-}
-
-function processAttrs (el) {
-  const list = el.attrsList;
-  let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          value.trim().length === 0
-        ) {
-          warn$2(
-            `The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') name = 'innerHTML';
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, `$event`);
-            if (!isDynamic) {
-              addHandler(
-                el,
-                `update:${camelize(name)}`,
-                syncGen,
-                null,
-                false,
-                warn$2,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  `update:${hyphenate(name)}`,
-                  syncGen,
-                  null,
-                  false,
-                  warn$2,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                `"update:"+(${name})`,
-                syncGen,
-                null,
-                false,
-                warn$2,
-                list[i],
-                true // dynamic
-              );
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        const argMatch = name.match(argRE);
-        let arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      {
-        const res = parseText(value, delimiters);
-        if (res) {
-          warn$2(
-            `${name}="${value}": ` +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
-}
-
-function checkInFor (el) {
-  let parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent;
-  }
-  return false
-}
-
-function parseModifiers (name) {
-  const match = name.match(modifierRE);
-  if (match) {
-    const ret = {};
-    match.forEach(m => { ret[m.slice(1)] = true; });
-    return ret
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn$2(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function makeAttrsMap (attrs) {
-  const map = {};
-  for (let i = 0, l = attrs.length; i < l; i++) {
-    if (
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
     }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
 }
-
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn$2(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$2, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$2, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$2, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$2(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
 const ieNSBug = /^xmlns:NS\d+/;
 const ieNSPrefix = /^NS\d+:/;
-
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  const res = [];
-  for (let i = 0; i < attrs.length; i++) {
-    const attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  let _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$2(
-        `<${el.tag} v-model="${value}">: ` +
-        `You are binding v-model directly to a v-for iteration alias. ` +
-        `This will not be able to modify the v-for source array because ` +
-        `writing to the alias is like modifying a function local variable. ` +
-        `Consider using an array of objects and use v-model on an object property instead.`,
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    const map = el.attrsMap;
-    if (!map['v-model']) {
-      return
-    }
-
-    let typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
-    }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = `(${map['v-bind']}).type`;
-    }
-
-    if (typeBinding) {
-      const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-      const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      const branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      const branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      const branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
-    }
-  }
-}
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$2(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
+/* @flow */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
 var model$1 = {
-  preTransformNode
+    preTransformNode,
 };
 
-var modules$1 = [
-  klass$1,
-  style$1,
-  model$1
-];
-
-/*  */
+var modules$1 = [klass$1, style$1, model$1];
 
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', `_s(${dir.value})`, dir);
-  }
+/* @flow */
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-  }
+/* @flow */
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
 var directives$1 = {
-  model,
-  text,
-  html
+    model,
+    text,
+    html,
 };
 
-/*  */
-
+/* @flow */
 const baseOptions = {
-  expectHTML: true,
-  modules: modules$1,
-  directives: directives$1,
-  isPreTag,
-  isUnaryTag,
-  mustUseProp,
-  canBeLeftOpenTag,
-  isReservedTag,
-  getTagNamespace,
-  staticKeys: genStaticKeys(modules$1)
+    expectHTML: true,
+    modules: modules$1,
+    directives: directives$1,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    // @ts-ignore
+    staticKeys: genStaticKeys(modules$1),
 };
 
-/*  */
-
+/* @flow */
 let isStaticKey;
 let isPlatformReservedTag;
-
 const genStaticKeysCached = cached(genStaticKeys$1);
-
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -10624,1393 +9640,1175 @@ const genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize (root, options) {
-  if (!root) return
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic$1(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic$1 (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (let i = 0, l = node.children.length; i < l; i++) {
-      const child = node.children[i];
-      markStatic$1(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-        const block = node.ifConditions[i].block;
-        markStatic$1(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (let i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-        markStaticRoots(node.ifConditions[i].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
-}
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
-    }
-    if (node.for) {
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+function optimize(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic$1(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys$1(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic$1(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic$1(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic$1(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
+}
 
+/* @flow */
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 const fnInvokeRE = /\([^)]*?\);*$/;
 const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
 // KeyboardEvent.keyCode aliases
 const keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
 const keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-const genGuard = condition => `if(${condition})return null;`;
-
+const genGuard = (condition) => `if(${condition})return null;`;
 const modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard(`$event.target !== $event.currentTarget`),
-  ctrl: genGuard(`!$event.ctrlKey`),
-  shift: genGuard(`!$event.shiftKey`),
-  alt: genGuard(`!$event.altKey`),
-  meta: genGuard(`!$event.metaKey`),
-  left: genGuard(`'button' in $event && $event.button !== 0`),
-  middle: genGuard(`'button' in $event && $event.button !== 1`),
-  right: genGuard(`'button' in $event && $event.button !== 2`)
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  const prefix = isNative ? 'nativeOn:' : 'on:';
-  let staticHandlers = ``;
-  let dynamicHandlers = ``;
-  for (const name in events) {
-    const handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += `${name},${handlerCode},`;
-    } else {
-      staticHandlers += `"${name}":${handlerCode},`;
-    }
-  }
-  staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-  if (dynamicHandlers) {
-    return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`
-  } else {
-    return prefix + staticHandlers
-  }
-}
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return `[${handler.map(handler => genHandler(handler)).join(',')}]`
-  }
-
-  const isMethodPath = simplePathRE.test(handler.value);
-  const isFunctionExpression = fnExpRE.test(handler.value);
-  const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return `function($event){${
-      isFunctionInvocation ? `return ${handler.value}` : handler.value
-    }}` // inline statement
-  } else {
-    let code = '';
-    let genModifierCode = '';
-    const keys = [];
-    for (const key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        const modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(keyModifier => !modifiers[keyModifier])
-            .map(keyModifier => `$event.${keyModifier}Key`)
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
     }
-    if (keys.length) {
-      code += genKeyFilter(keys);
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
     }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
+    else {
+        return prefix + staticHandlers;
     }
-    const handlerCode = isMethodPath
-      ? `return ${handler.value}($event)`
-      : isFunctionExpression
-        ? `return (${handler.value})($event)`
-        : isFunctionInvocation
-          ? `return ${handler.value}`
-          : handler.value;
-    return `function($event){${code}${handlerCode}}`
-  }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     `if(!$event.type.indexOf('key')&&` +
-    `${keys.map(genFilterCode).join('&&')})return null;`
-  )
+        `${keys.map(genFilterCode).join('&&')})return null;`);
 }
-
-function genFilterCode (key) {
-  const keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return `$event.keyCode!==${keyVal}`
-  }
-  const keyCode = keyCodes[key];
-  const keyName = keyNames[key];
-  return (
-    `_k($event.keyCode,` +
-    `${JSON.stringify(key)},` +
-    `${JSON.stringify(keyCode)},` +
-    `$event.key,` +
-    `${JSON.stringify(keyName)}` +
-    `)`
-  )
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-/*  */
-
-function on (el, dir) {
-  if (dir.modifiers) {
-    warn(`v-on without argument does not support modifiers.`);
-  }
-  el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+/* @flow */
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = (code) => {
-    return `_b(${code},'${el.tag}',${dir.value},${
-      dir.modifiers && dir.modifiers.prop ? 'true' : 'false'
-    }${
-      dir.modifiers && dir.modifiers.sync ? ',true' : ''
-    })`
-  };
+/* @flow */
+function bind$1(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-/*  */
-
+/* @flow */
 var baseDirectives = {
-  on,
-  bind: bind$1,
-  cloak: noop
+    on,
+    bind: bind$1,
+    cloak: noop,
 };
 
-/*  */
-
-
-
-
-
+/* @flow */
 class CodegenState {
-  
-  
-  
-  
-  
-  
-  
-  
-  
-
-  constructor (options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    const isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-  }
-}
-
-
-
-function generate (
-  ast,
-  options
-) {
-  const state = new CodegenState(options);
-  const code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    let code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      let data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      const children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = `_c('${el.tag}'${
-        data ? `,${data}` : '' // data
-      }${
-        children ? `,${children}` : '' // children
-      })`;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
     }
-    // module transforms
-    for (let i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData$2(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  const originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-  state.pre = originalPreState;
-  return `_m(${
-    state.staticRenderFns.length - 1
-  }${
-    el.staticInFor ? ',true' : ''
-  })`
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    let key = '';
-    let parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      state.warn(
-        `v-once can only be used inside v-for that is keyed. `,
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return `_o(${genElement(el, state)},${state.onceId++},${key})`
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  const condition = conditions.shift();
-  if (condition.exp) {
-    return `(${condition.exp})?${
-      genTernaryExp(condition.block)
-    }:${
-      genIfConditions(conditions, state, altGen, altEmpty)
-    }`
-  } else {
-    return `${genTernaryExp(condition.block)}`
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  const exp = el.for;
-  const alias = el.alias;
-  const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-  const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-
-  if (state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      `<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-      `v-for should have explicit keys. ` +
-      `See https://vuejs.org/guide/list.html#key for more info.`,
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return `${altHelper || '_l'}((${exp}),` +
-    `function(${alias}${iterator1}${iterator2}){` +
-      `return ${(altGen || genElement)(el, state)}` +
-    '})'
-}
-
-function genData$2 (el, state) {
-  let data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  const dirs = genDirectives(el, state);
-  if (dirs) data += dirs + ',';
-
-  // key
-  if (el.key) {
-    data += `key:${el.key},`;
-  }
-  // ref
-  if (el.ref) {
-    data += `ref:${el.ref},`;
-  }
-  if (el.refInFor) {
-    data += `refInFor:true,`;
-  }
-  // pre
-  if (el.pre) {
-    data += `pre:true,`;
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += `tag:"${el.tag}",`;
-  }
-  // module data generation functions
-  for (let i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += `attrs:${genProps(el.attrs)},`;
-  }
-  // DOM props
-  if (el.props) {
-    data += `domProps:${genProps(el.props)},`;
-  }
-  // event handlers
-  if (el.events) {
-    data += `${genHandlers(el.events, false)},`;
-  }
-  if (el.nativeEvents) {
-    data += `${genHandlers(el.nativeEvents, true)},`;
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += `slot:${el.slotTarget},`;
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-  }
-  // component v-model
-  if (el.model) {
-    data += `model:{value:${
-      el.model.value
-    },callback:${
-      el.model.callback
-    },expression:${
-      el.model.expression
-    }},`;
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    const inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += `${inlineTemplate},`;
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  const dirs = el.directives;
-  if (!dirs) return
-  let res = 'directives:[';
-  let hasRuntime = false;
-  let i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    const gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += `{name:"${dir.name}",rawName:"${dir.rawName}"${
-        dir.value ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}` : ''
-      }${
-        dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''
-      }${
-        dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''
-      }},`;
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  const ast = el.children[0];
-  if (el.children.length !== 1 || ast.type !== 1) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    const inlineRenderFns = generate(ast, state.options);
-    return `inlineTemplate:{render:function(){${
-      inlineRenderFns.render
-    }},staticRenderFns:[${
-      inlineRenderFns.staticRenderFns.map(code => `function(){${code}}`).join(',')
-    }]}`
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  let needsForceUpdate = el.for || Object.keys(slots).some(key => {
-    const slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  let needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    let parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
-    }
-  }
-
-  const generatedSlots = Object.keys(slots)
-    .map(key => genScopedSlot(slots[key], state))
-    .join(',');
-
-  return `scopedSlots:_u([${generatedSlots}]${
-    needsForceUpdate ? `,null,true` : ``
-  }${
-    !needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``
-  })`
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData$2(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if (el.children.length !== 1 || ast.type !== 1) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
 }
-
 function hash(str) {
-  let hash = 5381;
-  let i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
 }
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el,
-  state
-) {
-  const isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, `null`)
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  const slotScope = el.slotScope === emptySlotScopeToken
-    ? ``
-    : String(el.slotScope);
-  const fn = `function(${slotScope}){` +
-    `return ${el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)
-    }}`;
-  // reverse proxy v-slot without scope on this.$slots
-  const reverseProxy = slotScope ? `` : `,proxy:true`;
-  return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`
-}
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  const children = el.children;
-  if (children.length) {
-    const el = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el.for &&
-      el.tag !== 'template' &&
-      el.tag !== 'slot'
-    ) {
-      const normalizationType = checkSkip
-        ? state.maybeComponent(el) ? `,1` : `,0`
-        : ``;
-      return `${(altGenElement || genElement)(el, state)}${normalizationType}`
-    }
-    const normalizationType = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    const gen = altGenNode || genNode;
-    return `[${children.map(c => gen(c, state)).join(',')}]${
-      normalizationType ? `,${normalizationType}` : ''
-    }`
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  let res = 0;
-  for (let i = 0; i < children.length; i++) {
-    const el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(c => needsNormalization(c.block)))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(c => maybeComponent(c.block)))) {
-      res = 1;
-    }
-  }
-  return res
-}
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-
-function genText (text) {
-  return `_v(${text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))
-  })`
-}
-
-function genComment (comment) {
-  return `_e(${JSON.stringify(comment.text)})`
-}
-
-function genSlot (el, state) {
-  const slotName = el.slotName || '"default"';
-  const children = genChildren(el, state);
-  let res = `_t(${slotName}${children ? `,${children}` : ''}`;
-  const attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      })))
-    : null;
-  const bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += `,null`;
-  }
-  if (attrs) {
-    res += `,${attrs}`;
-  }
-  if (bind$$1) {
-    res += `${attrs ? '' : ',null'},${bind$$1}`;
-  }
-  return res + ')'
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,${children}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+        })))
+        : null;
+    const bind$$1 = el.attrsMap['v-bind'];
+    if ((attrs || bind$$1) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind$$1) {
+        res += `${attrs ? '' : ',null'},${bind$$1}`;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  const children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return `_c(${componentName},${genData$2(el, state)}${
-    children ? `,${children}` : ''
-  })`
-}
-
-function genProps (props) {
-  let staticProps = ``;
-  let dynamicProps = ``;
-  for (let i = 0; i < props.length; i++) {
-    const prop = props[i];
-    const value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += `${prop.name},${value},`;
-    } else {
-      staticProps += `"${prop.name}":${value},`;
-    }
-  }
-  staticProps = `{${staticProps.slice(0, -1)}}`;
-  if (dynamicProps) {
-    return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData$2(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
+/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
 const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
-}
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (const name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        const value = node.attrsMap[name];
-        if (value) {
-          const range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, `v-for="${value}"`, warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, `${name}="${value}"`, warn, range);
-          } else {
-            checkExpression(value, `${name}="${value}"`, warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (let i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
-}
-
-function checkEvent (exp, text, warn, range) {
-  const stripped = exp.replace(stripStringRE, '');
-  const keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      `avoid using JavaScript unary operator as property name: ` +
-      `"${keywordMatch[0]}" in expression ${text.trim()}`,
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(`var ${ident}=_`);
-    } catch (e) {
-      warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-    }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(`return ${exp}`);
-  } catch (e) {
-    const keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        `avoid using JavaScript keyword as property name: ` +
-        `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`,
-        range
-      );
-    } else {
-      warn(
-        `invalid expression: ${e.message} in\n\n` +
-        `    ${exp}\n\n` +
-        `  Raw expression: ${text.trim()}\n`,
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      `invalid function parameter expression: ${e.message} in\n\n` +
-      `    ${exp}\n\n` +
-      `  Raw expression: ${text.trim()}\n`,
-      range
-    );
-  }
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-/*  */
-
+/* @flow */
 const range = 2;
-
-function generateCodeFrame (
-  source,
-  start = 0,
-  end = source.length
-) {
-  const lines = source.split(/\r?\n/);
-  let count = 0;
-  const res = [];
-  for (let i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (let j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) continue
-        res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-        const lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          const pad = start - (count - lineLength) + 1;
-          const length = end > count ? lineLength - pad : end - start;
-          res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-        } else if (j > i) {
-          if (end > count) {
-            const length = Math.min(end - count, lineLength);
-            res.push(`   |  ` + repeat(`^`, length));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat (str, n) {
-  let result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) result += str;
-      n >>>= 1;
-      if (n <= 0) break
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err, code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  const cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    const warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
-    }
-
-    // check cache
-    const key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    const compiled = compile(template, options);
-
-    // check compilation errors/tips
-    {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(e => {
-            warn$$1(
-              `Error compiling template:\n\n${e.msg}\n\n` +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            `Error compiling template:\n\n${template}\n\n` +
-            compiled.errors.map(e => `- ${e}`).join('\n') + '\n',
-            vm
-          );
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
         }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(e => tip(e.msg, vm));
-        } else {
-          compiled.tips.forEach(msg => tip(msg, vm));
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
         }
-      }
     }
+    return result;
+}
 
-    // turn code into functions
-    const res = {};
-    const fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(code => {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          `Failed to generate render function:\n\n` +
-          fnGenErrors.map(({ err, code }) => `${err.toString()} in\n\n${code}\n`).join('\n'),
-          vm
-        );
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      const finalOptions = Object.create(baseOptions);
-      const errors = [];
-      const tips = [];
-
-      let warn = (msg, range, tip) => {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (options.outputSourceRange) {
-          // $flow-disable-line
-          const leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = (msg, range, tip) => {
-            const data = { msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
-            }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (const key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      const compiled = baseCompile(template.trim(), finalOptions);
-      {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
+/* @flow */
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    return {
-      compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
     }
-  }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn$$1 = options.warn || warn;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn$$1(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn$$1(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn$$1(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+/* @flow */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
+/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  const ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  const code = generate(ast, options);
-  return {
-    ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
+/* @flow */
 const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-/*  */
-
+/* @flow */
 // check whether current browser encodes a char inside attribute values
 let div;
-function getShouldDecode (href) {
-  div = div || document.createElement('div');
-  div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-  return div.innerHTML.indexOf('&#10;') > 0
+function getShouldDecode(href) {
+    div = div || document.createElement('div');
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
+    return div.innerHTML.indexOf('&#10;') > 0;
 }
-
 // #3663: IE encodes newlines inside attribute values while other browsers don't
 const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
-
-/*  */
-
-const idToTemplate = cached(id => {
-  const el = query(id);
-  return el && el.innerHTML
+const shouldDecodeNewlinesForHref = inBrowser
+    ? getShouldDecode(true)
+    : false;
+
+/* @flow */
+const idToTemplate = cached((id) => {
+    const el = query(id);
+    return el && el.innerHTML;
 });
-
 const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && query(el);
-
-  /* istanbul ignore if */
-  if (el === document.body || el === document.documentElement) {
-    warn(
-      `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
-    );
-    return this
-  }
-
-  const options = this.$options;
-  // resolve template/el and convert to render function
-  if (!options.render) {
-    let template = options.template;
-    if (template) {
-      if (typeof template === 'string') {
-        if (template.charAt(0) === '#') {
-          template = idToTemplate(template);
-          /* istanbul ignore if */
-          if (!template) {
-            warn(
-              `Template element not found or is empty: ${options.template}`,
-              this
-            );
-          }
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && query(el);
+    /* istanbul ignore if */
+    if (el === document.body || el === document.documentElement) {
+        warn(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
+        return this;
+    }
+    const options = this.$options;
+    // resolve template/el and convert to render function
+    if (!options.render) {
+        let template = options.template;
+        if (template) {
+            if (typeof template === 'string') {
+                if (template.charAt(0) === '#') {
+                    template = idToTemplate(template);
+                    /* istanbul ignore if */
+                    if (!template) {
+                        warn(`Template element not found or is empty: ${options.template}`, this);
+                    }
+                }
+            }
+            else if (template.nodeType) {
+                template = template.innerHTML;
+            }
+            else {
+                {
+                    warn('invalid template option:' + template, this);
+                }
+                return this;
+            }
         }
-      } else if (template.nodeType) {
-        template = template.innerHTML;
-      } else {
-        {
-          warn('invalid template option:' + template, this);
-        }
-        return this
-      }
-    } else if (el) {
-      template = getOuterHTML(el);
-    }
-    if (template) {
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        mark('compile');
-      }
-
-      const { render, staticRenderFns } = compileToFunctions(template, {
-        outputSourceRange: "development" !== 'production',
-        shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref,
-        delimiters: options.delimiters,
-        comments: options.comments
-      }, this);
-      options.render = render;
-      options.staticRenderFns = staticRenderFns;
-
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        mark('compile end');
-        measure(`vue ${this._name} compile`, 'compile', 'compile end');
-      }
-    }
-  }
-  return mount.call(this, el, hydrating)
+        else if (el) {
+            // @ts-expect-error
+            template = getOuterHTML(el);
+        }
+        if (template) {
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile');
+            }
+            const { render, staticRenderFns } = compileToFunctions(template, {
+                outputSourceRange: "development" !== 'production',
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
+                delimiters: options.delimiters,
+                comments: options.comments,
+            }, this);
+            options.render = render;
+            options.staticRenderFns = staticRenderFns;
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
+            }
+        }
+    }
+    return mount.call(this, el, hydrating);
 };
-
 /**
  * Get outerHTML of elements, taking care
  * of SVG elements in IE as well.
  */
-function getOuterHTML (el) {
-  if (el.outerHTML) {
-    return el.outerHTML
-  } else {
-    const container = document.createElement('div');
-    container.appendChild(el.cloneNode(true));
-    return container.innerHTML
-  }
+function getOuterHTML(el) {
+    if (el.outerHTML) {
+        return el.outerHTML;
+    }
+    else {
+        const container = document.createElement('div');
+        container.appendChild(el.cloneNode(true));
+        return container.innerHTML;
+    }
 }
-
 Vue.compile = compileToFunctions;
 
 export default Vue;
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
index 5ee9b2042dc..9a6af5e0c30 100644
--- a/dist/vue.esm.browser.min.js
+++ b/dist/vue.esm.browser.min.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v(t=>t.replace($,(t,e)=>e?e.toUpperCase():"")),b=v(t=>t.charAt(0).toUpperCase()+t.slice(1)),w=/\B([A-Z])/g,C=v(t=>t.replace(w,"-$1").toLowerCase());const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,E=t=>t;function N(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every((t,n)=>N(t,e[n]));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every(n=>N(t[n],e[n]))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(N(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:I};const P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function H(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const B=new RegExp(`[^${P.source}.$_\\d]`);const U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),J=z&&window.navigator.userAgent.toLowerCase(),q=J&&/msie|trident/.test(J),W=J&&J.indexOf("msie 9.0")>0,Z=J&&J.indexOf("edge/")>0,G=(J&&J.indexOf("android"),J&&/iphone|ipad|ipod|ios/.test(J)||"ios"===K),X=(J&&/chrome\/\d+/.test(J),J&&/phantomjs/.test(J),J&&J.match(/firefox\/(\d+)/)),Y={}.watch;let Q,tt=!1;if(z)try{const t={};Object.defineProperty(t,"passive",{get(){tt=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const et=()=>(void 0===Q&&(Q=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Q),nt=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ot(t){return"function"==typeof t&&/native code/.test(t.toString())}const rt="undefined"!=typeof Symbol&&ot(Symbol)&&"undefined"!=typeof Reflect&&ot(Reflect.ownKeys);let st;st="undefined"!=typeof Set&&ot(Set)?Set:class{constructor(){this.set=Object.create(null)}has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let it=S,at=0;class ct{constructor(){this.id=at++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){ct.target&&ct.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}ct.target=null;const lt=[];function ut(t){lt.push(t),ct.target=t}function ft(){lt.pop(),ct.target=lt[lt.length-1]}class dt{constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const pt=(t="")=>{const e=new dt;return e.text=t,e.isComment=!0,e};function ht(t){return new dt(void 0,void 0,void 0,String(t))}function mt(t){const e=new dt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const yt=Array.prototype,gt=Object.create(yt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){const e=yt[t];H(gt,t,function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o})});const vt=Object.getOwnPropertyNames(gt);let $t=!0;function _t(t){$t=t}class bt{constructor(t){var e;this.value=t,this.dep=new ct,this.vmCount=0,H(t,"__ob__",this),Array.isArray(t)?(U?(e=gt,t.__proto__=e):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];H(t,r,e[r])}}(t,gt,vt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)Ct(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)wt(t[e])}}function wt(t,e){if(!s(t)||t instanceof dt)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:$t&&!et()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,o,r){const s=new ct,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&wt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return ct.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&function t(e){for(let n,o=0,r=e.length;o<r;o++)(n=e[o])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&wt(e),s.notify())}})}function xt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(Ct(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function kt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}const At=F.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=rt?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)"__ob__"!==(n=s[i])&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):xt(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},I.forEach(t=>{At[t]=Tt}),M.forEach(function(t){At[t+"s"]=Et}),At.watch=function(t,e,n,o){if(t===Y&&(t=void 0),e===Y&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Nt=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(s=n[r])&&(o[i=_(s)]={type:null});else if(a(n))for(const t in n)s=n[t],o[i=_(t)]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Nt;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);return g(r,i)?r[i]:r[n]||r[s]||r[i]}function Lt(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Ft(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Ft(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Mt(e.type)?o.call(t):o}(o,r,t);const e=$t;_t(!0),wt(i),_t(e)}return i}function Mt(t){const e=t&&t.toString().match(/^\s*function (\w+)/);return e?e[1]:""}function It(t,e){return Mt(t)===Mt(e)}function Ft(t,e){if(!Array.isArray(e))return It(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(It(e[n],t))return n;return-1}function Pt(t,e,n){ut();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Ht(t,o,"errorCaptured hook")}}}Ht(t,e,n)}finally{ft()}}function Rt(t,e,n,o,r){let s;try{(s=n?t.apply(e,n):t.call(e))&&!s._isVue&&l(s)&&!s._handled&&(s.catch(t=>Pt(t,o,r+" (Promise/async)")),s._handled=!0)}catch(t){Pt(t,o,r)}return s}function Ht(t,e,n){if(F.errorHandler)try{return F.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Bt(e,null,"config.errorHandler")}Bt(t,e,n)}function Bt(t,e,n){if(!z&&!V||"undefined"==typeof console)throw t;console.error(t)}let Ut=!1;const zt=[];let Vt,Kt=!1;function Jt(){Kt=!1;const t=zt.slice(0);zt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&ot(Promise)){const t=Promise.resolve();Vt=(()=>{t.then(Jt),G&&setTimeout(S)}),Ut=!0}else if(q||"undefined"==typeof MutationObserver||!ot(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&ot(setImmediate)?()=>{setImmediate(Jt)}:()=>{setTimeout(Jt,0)};else{let t=1;const e=new MutationObserver(Jt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Vt=(()=>{t=(t+1)%2,n.data=String(t)}),Ut=!0}function qt(t,e){let n;if(zt.push(()=>{if(t)try{t.call(e)}catch(t){Pt(t,e,"nextTick")}else n&&n(e)}),Kt||(Kt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(t=>{n=t})}const Wt=new st;function Zt(t){!function t(e,n){let o,r;const i=Array.isArray(e);if(!i&&!s(e)||Object.isFrozen(e)||e instanceof dt)return;if(e.__ob__){const t=e.__ob__.dep.id;if(n.has(t))return;n.add(t)}if(i)for(o=e.length;o--;)t(e[o],n);else for(r=Object.keys(e),o=r.length;o--;)t(e[r[o]],n)}(t,Wt),Wt.clear()}const Gt=v(t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}});function Xt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Rt(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Rt(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function Yt(t,n,r,s,i,a){let c,l,u,f,d;for(c in t)l=u=t[c],f=n[c],d=Gt(c),e(u)||(e(f)?(e(u.fns)&&(u=t[c]=Xt(u,a)),o(d.once)&&(u=t[c]=i(d.name,u,d.capture)),r(d.name,u,d.capture,d.passive,d.params)):u!==f&&(f.fns=u,t[c]=f));for(c in n)e(t[c])&&s((d=Gt(c)).name,n[c],d.capture)}function Qt(t,r,s){let i;t instanceof dt&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Xt([c]):n(a.fns)&&o(a.merged)?(i=a).fns.push(c):i=Xt([a,c]),i.merged=!0,t[r]=i}function te(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function ee(t){return r(t)?[ht(t)]:Array.isArray(t)?function t(s,i){const a=[];let c,l,u,f;for(c=0;c<s.length;c++)e(l=s[c])||"boolean"==typeof l||(u=a.length-1,f=a[u],Array.isArray(l)?l.length>0&&(ne((l=t(l,`${i||""}_${c}`))[0])&&ne(f)&&(a[u]=ht(f.text+l[0].text),l.shift()),a.push.apply(a,l)):r(l)?ne(f)?a[u]=ht(f.text+l):""!==l&&a.push(ht(l)):ne(l)&&ne(f)?a[u]=ht(f.text+l.text):(o(s._isVList)&&n(l.tag)&&e(l.key)&&n(i)&&(l.key=`__vlist${i}_${c}__`),a.push(l)));return a}(t):void 0}function ne(t){return n(t)&&n(t.text)&&!1===t.isComment}function oe(t,e){if(t){const n=Object.create(null),o=rt?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function re(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(se)&&delete n[t];return n}function se(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ie(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ae(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=ce(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),H(r,"$stable",i),H(r,"$key",a),H(r,"$hasNormal",s),r}function ae(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ee(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function ce(t,e){return()=>t[e]}function le(t,e){let o,r,i,a,c;if(Array.isArray(t)||"string"==typeof t)for(o=new Array(t.length),r=0,i=t.length;r<i;r++)o[r]=e(t[r],r);else if("number"==typeof t)for(o=new Array(t),r=0;r<t;r++)o[r]=e(r+1,r);else if(s(t))if(rt&&t[Symbol.iterator]){o=[];const n=t[Symbol.iterator]();let r=n.next();for(;!r.done;)o.push(e(r.value,o.length)),r=n.next()}else for(a=Object.keys(t),o=new Array(a.length),r=0,i=a.length;r<i;r++)c=a[r],o[r]=e(t[c],c,r);return n(o)||(o=[]),o._isVList=!0,o}function ue(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||e):s=this.$slots[t]||e;const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function fe(t){return Dt(this.$options,"filters",t)||E}function de(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function pe(t,e,n,o,r){const s=F.keyCodes[e]||n;return r&&o&&!F.keyCodes[e]?de(r,o):s?de(s,t):o?C(o)!==e:void 0}function he(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||F.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s||c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function me(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e?o:(ge(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),`__static__${t}`,!1),o)}function ye(t,e,n){return ge(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function ge(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&ve(t[o],`${e}_${o}`,n);else ve(t,e,n)}function ve(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function _e(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?_e(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function be(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function we(t,e){return"string"==typeof t?e+t:t}function Ce(t){t._o=ye,t._n=f,t._s=u,t._l=le,t._t=ue,t._q=N,t._i=j,t._m=me,t._f=fe,t._k=pe,t._b=he,t._v=ht,t._e=pt,t._u=_e,t._g=$e,t._d=be,t._p=we}function xe(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s))._original=s:(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=oe(a.inject,s),this.slots=(()=>(this.$slots||ie(e.scopedSlots,this.$slots=re(r,s)),this.$slots)),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ie(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ie(e.scopedSlots,this.$slots)),a._scopeId?this._c=((t,e,n,o)=>{const r=De(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}):this._c=((t,e,n,o)=>De(c,t,e,n,o,u))}function ke(t,e,n,o,r){const s=mt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ae(t,e){for(const n in e)t[_(n)]=e[n]}Ce(xe.prototype);const Oe={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Oe.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,ze)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){_t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Lt(s,i,n,e)}_t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ue(e,o,u),l&&(e.$slots=re(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,qe(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ze.push(o)):Je(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Ke(e)))return;if(!e._inactive){e._inactive=!0;for(let n=0;n<e.$children.length;n++)t(e.$children[n]);qe(e,"deactivated")}}(e,!0):e.$destroy())}},Se=Object.keys(Oe);function Te(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&void 0===(r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Me;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",()=>m(o,i));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D(e=>{t.resolved=Ie(e,r),a?o.length=0:f(!0)}),p=D(e=>{n(t.errorComp)&&(t.error=!0,f(!0))}),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Ie(h.error,r)),n(h.loading)&&(t.loadingComp=Ie(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout(()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))},h.delay||200)),n(h.timeout)&&(u=setTimeout(()=>{u=null,e(t.resolved)&&p(null)},h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d=r,f)))return function(t,e,n,o,r){const s=pt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},mn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);te(i,c,t,e,!0)||te(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Lt(e,l,o||t);else n(r.attrs)&&Ae(c,r.attrs),n(r.props)&&Ae(c,r.props);const u=new xe(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof dt)return ke(f,r,u.parent,a);if(Array.isArray(f)){const t=ee(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=ke(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Se.length;t++){const n=Se[t],o=e[n],r=Oe[n];o===r||o&&o._merged||(e[n]=o?Ee(r,o):r)}}(i);const y=r.options.name||u;return new dt(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Ee(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}const Ne=1,je=2;function De(t,i,a,c,l,u){return(Array.isArray(a)||r(a))&&(l=c,c=a,a=void 0),o(u)&&(l=je),function(t,r,i,a,c){if(n(i)&&n(i.__ob__))return pt();n(i)&&n(i.is)&&(r=i.is);if(!r)return pt();Array.isArray(a)&&"function"==typeof a[0]&&((i=i||{}).scopedSlots={default:a[0]},a.length=0);c===je?a=ee(a):c===Ne&&(a=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(a));let l,u;if("string"==typeof r){let e;u=t.$vnode&&t.$vnode.ns||F.getTagNamespace(r),l=F.isReservedTag(r)?new dt(F.parsePlatformTagName(r),i,a,void 0,void 0,t):i&&i.pre||!n(e=Dt(t.$options,"components",r))?new dt(r,i,a,void 0,void 0,t):Te(e,i,t,a,r)}else l=Te(r,i,t,a);return Array.isArray(l)?l:n(l)?(n(u)&&function t(r,s,i){r.ns=s;"foreignObject"===r.tag&&(s=void 0,i=!0);if(n(r.children))for(let a=0,c=r.children.length;a<c;a++){const c=r.children[a];n(c.tag)&&(e(c.ns)||o(i)&&"svg"!==c.tag)&&t(c,s,i)}}(l,u),n(i)&&function(t){s(t.style)&&Zt(t.style);s(t.class)&&Zt(t.class)}(i),l):pt()}(t,i,a,c,l)}let Le,Me=null;function Ie(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Fe(t){return t.isComment&&t.asyncFactory}function Pe(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||Fe(o)))return o}}function Re(t,e){Le.$on(t,e)}function He(t,e){Le.$off(t,e)}function Be(t,e){const n=Le;return function o(){null!==e.apply(null,arguments)&&n.$off(t,o)}}function Ue(t,e,n){Le=t,Yt(e,n||{},Re,He,Be,t),Le=void 0}let ze=null;function Ve(t){const e=ze;return ze=t,()=>{ze=e}}function Ke(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Je(t,e){if(e){if(t._directInactive=!1,Ke(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)Je(t.$children[e]);qe(t,"activated")}}function qe(t,e){ut();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Rt(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ft()}const We=[],Ze=[];let Ge={},Xe=!1,Ye=!1,Qe=0;let tn=0,en=Date.now;if(z&&!q){const t=window.performance;t&&"function"==typeof t.now&&en()>document.createEvent("Event").timeStamp&&(en=(()=>t.now()))}function nn(){let t,e;for(tn=en(),Ye=!0,We.sort((t,e)=>t.id-e.id),Qe=0;Qe<We.length;Qe++)(t=We[Qe]).before&&t.before(),e=t.id,Ge[e]=null,t.run();const n=Ze.slice(),o=We.slice();Qe=We.length=Ze.length=0,Ge={},Xe=Ye=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,Je(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&qe(o,"updated")}}(o),nt&&F.devtools&&nt.emit("flush")}let on=0;class rn{constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++on,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new st,this.newDepIds=new st,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(B.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;ut(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Pt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Zt(t),ft(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Ge[e]){if(Ge[e]=!0,Ye){let e=We.length-1;for(;e>Qe&&We[e].id>t.id;)e--;We.splice(e+1,0,t)}else We.push(t);Xe||(Xe=!0,qt(nn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Pt(t,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const sn={enumerable:!0,configurable:!0,get:S,set:S};function an(t,e,n){sn.get=function(){return this[e][n]},sn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,sn)}function cn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&_t(!1);for(const s in e){r.push(s);const i=Lt(s,e,n,t);Ct(o,s,i),s in t||an(t,"_props",s)}_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;a(e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Pt(t,e,"data()"),{}}finally{ft()}}(e,t):e||{})||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||R(e)||an(t,"_data",e)}wt(e,!0)}(t):wt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=et();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new rn(t,i||S,S,ln)),r in t||un(t,r,s)}}(t,e.computed),e.watch&&e.watch!==Y&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)pn(t,n,o[e]);else pn(t,n,o)}}(t,e.watch)}const ln={lazy:!0};function un(t,e,n){const o=!et();"function"==typeof n?(sn.get=o?fn(e):dn(n),sn.set=S):(sn.get=n.get?o&&!1!==n.cache?fn(e):dn(n.get):S,sn.set=n.set||S),Object.defineProperty(t,e,sn)}function fn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),ct.target&&e.depend(),e.value}}function dn(t){return function(){return t.call(this,this)}}function pn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let hn=0;function mn(t){let e=t.options;if(t.super){const n=mn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),(e=t.options=jt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function yn(t){this._init(t)}function gn(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)an(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)un(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,M.forEach(function(t){i[t]=n[t]}),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function vn(t){return t&&(t.Ctor.options.name||t.tag)}function $n(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function _n(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=vn(s.componentOptions);i&&!e(i)&&bn(n,t,o,r)}}}function bn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=hn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(mn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ue(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=re(n._renderChildren,r),e.$scopedSlots=t,e._c=((t,n,o,r)=>De(e,t,n,o,r,!1)),e.$createElement=((t,n,o,r)=>De(e,t,n,o,r,!0));const s=o&&o.data;Ct(e,"$attrs",s&&s.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),qe(n,"beforeCreate"),function(t){const e=oe(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(n=>{Ct(t,n,e[n])}),_t(!0))}(n),cn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),qe(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(yn),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=xt,t.prototype.$delete=kt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return pn(o,t,e,n);(n=n||{}).user=!0;const r=new rn(o,t,e,n);if(n.immediate)try{e.call(o,r.value)}catch(t){Pt(t,o,`callback for immediate watcher "${r.expression}"`)}return function(){r.teardown()}}}(yn),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if((r=o[s])===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Rt(n[t],e,o,e,r)}return e}}(yn),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=Ve(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;qe(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),qe(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(yn),function(t){Ce(t.prototype),t.prototype.$nextTick=function(t){return qt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ie(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Me=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Pt(e,t,"render"),o=t._vnode}finally{Me=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof dt||(o=pt()),o.parent=n,o}}(yn);const wn=[String,RegExp,Array];var Cn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:wn,exclude:wn,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)bn(this.cache,t,this.keys)},mounted(){this.$watch("include",t=>{_n(this,e=>$n(t,e))}),this.$watch("exclude",t=>{_n(this,e=>!$n(t,e))})},render(){const t=this.$slots.default,e=Pe(t),n=e&&e.componentOptions;if(n){const t=vn(n),{include:o,exclude:r}=this;if(o&&(!t||!$n(o,t))||r&&t&&$n(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(s[a]=e,i.push(a),this.max&&i.length>parseInt(this.max)&&bn(s,i[0],i,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>F};Object.defineProperty(t,"config",e),t.util={warn:it,extend:A,mergeOptions:jt,defineReactive:Ct},t.set=xt,t.delete=kt,t.nextTick=qt,t.observable=(t=>(wt(t),t)),t.options=Object.create(null),M.forEach(e=>{t.options[e+"s"]=Object.create(null)}),t.options._base=t,A(t.options.components,Cn),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),gn(t),function(t){M.forEach(e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(yn),Object.defineProperty(yn.prototype,"$isServer",{get:et}),Object.defineProperty(yn.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(yn,"FunctionalRenderContext",{value:xe}),yn.version="2.6.12";const xn=d("style,class"),kn=d("input,textarea,option,select,progress"),An=(t,e,n)=>"value"===n&&kn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,On=d("contenteditable,draggable,spellcheck"),Sn=d("events,caret,typing,plaintext-only"),Tn=(t,e)=>Ln(e)||"false"===e?"false":"contenteditable"===t&&Sn(e)?e:"true",En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",jn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Dn=t=>jn(t)?t.slice(6,t.length):"",Ln=t=>null==t||!1===t;function Mn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)(r=r.componentInstance._vnode)&&r.data&&(e=In(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=In(e,o.data));return function(t,e){if(n(t)||n(e))return Fn(t,Pn(e));return""}(e.staticClass,e.class)}function In(t,e){return{staticClass:Fn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Fn(t,e){return t?e?t+" "+e:t:e||""}function Pn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Pn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Rn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Hn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Bn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Un=t=>Hn(t)||Bn(t);function zn(t){return Bn(t)?"svg":"math"===t?"math":void 0}const Vn=Object.create(null);const Kn=d("text,number,password,search,email,tel,url");function Jn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var qn=Object.freeze({createElement:function(t,e){const n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Rn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Wn={create(t,e){Zn(e)},update(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy(t){Zn(t,!0)}};function Zn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs;e?Array.isArray(i[o])?m(i[o],s):i[o]===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(i[o])?i[o].indexOf(s)<0&&i[o].push(s):i[o]=[s]:i[o]=s}const Gn=new dt("",{},[]),Xn=["create","activate","update","remove","destroy"];function Yn(t,r){return t.key===r.key&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Kn(r)&&Kn(s)}(t,r)||o(t.isAsyncPlaceholder)&&t.asyncFactory===r.asyncFactory&&e(r.asyncFactory.error))}function Qn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)n(s=t[r].key)&&(i[s]=r);return i}var to={create:eo,update:eo,destroy:function(t){eo(t,Gn)}};function eo(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Gn,o=e===Gn,r=oo(t.data.directives,t.context),s=oo(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,so(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(so(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)so(i[n],"inserted",e,t)};n?Qt(e,"insert",o):o()}a.length&&Qt(e,"postpatch",()=>{for(let n=0;n<a.length;n++)so(a[n],"componentUpdated",e,t)});if(!n)for(c in r)s[c]||so(r[c],"unbind",t,t,o)}(t,e)}const no=Object.create(null);function oo(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)(r=t[o]).modifiers||(r.modifiers=no),n[ro(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function ro(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function so(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Pt(o,n.context,`directive ${t.name} ${e} hook`)}}var io=[Wn,to];function ao(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],(a=l[s])!==i&&co(c,s,i);for(s in(q||Z)&&u.value!==l.value&&co(c,"value",u.value),l)e(u[s])&&(jn(s)?c.removeAttributeNS(Nn,Dn(s)):On(s)||c.removeAttribute(s))}function co(t,e,n){t.tagName.indexOf("-")>-1?lo(t,e,n):En(e)?Ln(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):On(e)?t.setAttribute(e,Tn(e,n)):jn(e)?Ln(n)?t.removeAttributeNS(Nn,Dn(e)):t.setAttributeNS(Nn,e,n):lo(t,e,n)}function lo(t,e,n){if(Ln(n))t.removeAttribute(e);else{if(q&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var uo={create:ao,update:ao};function fo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Mn(o);const c=r._transitionClasses;n(c)&&(a=Fn(a,Pn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var po={create:fo,update:fo};const ho=/[\w).+\-_$\]]/;function mo(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&" "===(e=t.charAt(n));n--);e&&ho.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=yo(r,s[o]);return r}function yo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function go(t,e){console.error(`[Vue compiler]: ${t}`)}function vo(t,e){return t?t.map(t=>t[e]).filter(t=>t):[]}function $o(t,e,n,o,r){(t.props||(t.props=[])).push(So({name:e,value:n,dynamic:r},o)),t.plain=!1}function _o(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(So({name:e,value:n,dynamic:r},o)),t.plain=!1}function bo(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(So({name:e,value:n},o))}function wo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(So({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function Co(t,e,n){return n?`_p(${e},"${t}")`:t+e}function xo(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=Co("!",n,c)),r.once&&(delete r.once,n=Co("~",n,c)),r.passive&&(delete r.passive,n=Co("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=So({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function ko(t,e,n){const o=Ao(t,":"+e)||Ao(t,"v-bind:"+e);if(null!=o)return mo(o);if(!1!==n){const n=Ao(t,e);if(null!=n)return JSON.stringify(n)}}function Ao(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function Oo(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function So(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function To(t,e,n){const{number:o,trim:r}=n||{};let s="$$v";r&&(s="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(s=`_n(${s})`);const i=Eo(e,s);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${i}}`}}function Eo(t,e){const n=function(t){if(t=t.trim(),No=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<No-1)return(Lo=t.lastIndexOf("."))>-1?{exp:t.slice(0,Lo),key:'"'+t.slice(Lo+1)+'"'}:{exp:t,key:null};jo=t,Lo=Mo=Io=0;for(;!Po();)Ro(Do=Fo())?Bo(Do):91===Do&&Ho(Do);return{exp:t.slice(0,Mo),key:t.slice(Mo+1,Io)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let No,jo,Do,Lo,Mo,Io;function Fo(){return jo.charCodeAt(++Lo)}function Po(){return Lo>=No}function Ro(t){return 34===t||39===t}function Ho(t){let e=1;for(Mo=Lo;!Po();)if(Ro(t=Fo()))Bo(t);else if(91===t&&e++,93===t&&e--,0===e){Io=Lo;break}}function Bo(t){const e=t;for(;!Po()&&(t=Fo())!==e;);}const Uo="__r",zo="__c";let Vo;function Ko(t,e,n){const o=Vo;return function r(){null!==e.apply(null,arguments)&&Wo(t,r,n,o)}}const Jo=Ut&&!(X&&Number(X[1])<=53);function qo(t,e,n,o){if(Jo){const t=tn,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Vo.addEventListener(t,e,tt?{capture:n,passive:o}:n)}function Wo(t,e,n,o){(o||Vo).removeEventListener(t,e._wrapper||e,n)}function Zo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Vo=o.elm,function(t){if(n(t[Uo])){const e=q?"change":"input";t[e]=[].concat(t[Uo],t[e]||[]),delete t[Uo]}n(t[zo])&&(t.change=[].concat(t[zo],t.change||[]),delete t[zo])}(r),Yt(r,s,qo,Wo,Ko,o.context),Vo=void 0}var Go={create:Zo,update:Zo};let Xo;function Yo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Qo(i,t)&&(i.value=t)}else if("innerHTML"===r&&Bn(i.tagName)&&e(i.innerHTML)){(Xo=Xo||document.createElement("div")).innerHTML=`<svg>${s}</svg>`;const t=Xo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Qo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var tr={create:Yo,update:Yo};const er=v(function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}}),e});function nr(t){const e=or(t.style);return t.staticStyle?A(t.staticStyle,e):e}function or(t){return Array.isArray(t)?O(t):"string"==typeof t?er(t):t}const rr=/^--/,sr=/\s*!important$/,ir=(t,e,n)=>{if(rr.test(e))t.style.setProperty(e,n);else if(sr.test(n))t.style.setProperty(C(e),n.replace(sr,""),"important");else{const o=lr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},ar=["Webkit","Moz","ms"];let cr;const lr=v(function(t){if(cr=cr||document.createElement("div").style,"filter"!==(t=_(t))&&t in cr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<ar.length;t++){const n=ar[t]+e;if(n in cr)return n}});function ur(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=or(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)(e=e.componentInstance._vnode)&&e.data&&(o=nr(e.data))&&A(n,o)}(o=nr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=nr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&ir(c,a,"");for(a in p)(i=p[a])!==f[a]&&ir(c,a,null==i?"":i)}var fr={create:ur,update:ur};const dr=/\s+/;function pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach(e=>t.classList.add(e)):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach(e=>t.classList.remove(e)):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function mr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,yr(t.name||"v")),A(e,t),e}return"string"==typeof t?yr(t):void 0}}const yr=v(t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`})),gr=z&&!W,vr="transition",$r="animation";let _r="transition",br="transitionend",wr="animation",Cr="animationend";gr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_r="WebkitTransition",br="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(wr="WebkitAnimation",Cr="webkitAnimationEnd"));const xr=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function kr(t){xr(()=>{xr(t)})}function Ar(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pr(t,e))}function Or(t,e){t._transitionClasses&&m(t._transitionClasses,e),hr(t,e)}function Sr(t,e,n){const{type:o,timeout:r,propCount:s}=Er(t,e);if(!o)return n();const i=o===vr?br:Cr;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout(()=>{a<s&&c()},r+1),t.addEventListener(i,l)}const Tr=/\b(transform|all)(,|$)/;function Er(t,e){const n=window.getComputedStyle(t),o=(n[_r+"Delay"]||"").split(", "),r=(n[_r+"Duration"]||"").split(", "),s=Nr(o,r),i=(n[wr+"Delay"]||"").split(", "),a=(n[wr+"Duration"]||"").split(", "),c=Nr(i,a);let l,u=0,f=0;return e===vr?s>0&&(l=vr,u=s,f=r.length):e===$r?c>0&&(l=$r,u=c,f=a.length):f=(l=(u=Math.max(s,c))>0?s>c?vr:$r:null)?l===vr?r.length:a.length:0,{type:l,timeout:u,propCount:f,hasTransform:l===vr&&Tr.test(n[_r+"Property"])}}function Nr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((e,n)=>jr(e)+jr(t[n])))}function jr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Dr(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=mr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=ze,A=ze.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,E=O&&h?h:u,N=O&&_||y,j=O&&"function"==typeof b?b:g,L=O&&w||v,M=O&&C||$,I=f(s(x)?x.enter:x),F=!1!==a&&!W,P=Ir(j),R=r._enterCb=D(()=>{F&&(Or(r,E),Or(r,T)),R.cancelled?(F&&Or(r,S),M&&M(r)):L&&L(r),r._enterCb=null});t.data.show||Qt(t,"insert",()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)}),N&&N(r),F&&(Ar(r,S),Ar(r,T),kr(()=>{Or(r,S),R.cancelled||(Ar(r,E),P||(Mr(I)?setTimeout(R,I):Sr(r,c,R)))})),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function Lr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=mr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!W,_=Ir(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D(()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(Or(r,u),Or(r,d)),w.cancelled?($&&Or(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null});function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(Ar(r,l),Ar(r,d),kr(()=>{Or(r,l),w.cancelled||(Ar(r,u),_||(Mr(b)?setTimeout(w,b):Sr(r,c,w)))})),h&&h(r,w),$||_||w())}g?g(C):C()}function Mr(t){return"number"==typeof t&&!isNaN(t)}function Ir(t){if(e(t))return!1;const o=t.fns;return n(o)?Ir(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Fr(t,e){!0!==e.data.show&&Dr(e)}const Pr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Xn.length;++s)for(a[Xn[s]]=[],i=0;i<c.length;++i)n(c[i][Xn[s]])&&a[Xn[s]].push(c[i][Xn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=mt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Gn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Zn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Gn,t);n(s=t.data.hook)&&(n(s.create)&&s.create(Gn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=ze)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Yn(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=mt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:Yn(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):Yn(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):Yn(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):Yn(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=Qn(o,p,m)),e(c=n(_.key)?a[_.key]:C(_,o,p,m))?f(_,s,t,y.elm,!1,r,h):Yn(u=o[c],_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h),_=r[++h]);p>m?$(t,d=e(r[v+1])?null:r[v+1].elm,r,h,v,s):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Zt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Yn(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute(L)&&(t.removeAttribute(L),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new dt(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Gn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Zn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:qn,modules:[uo,po,Go,tr,fr,z?{create:Fr,activate:Fr,remove(t,e){!0!==t.data.show?Lr(t,e):e()}}:{}].concat(io)});W&&document.addEventListener("selectionchange",()=>{const t=document.activeElement;t&&t.vmodel&&Jr(t,"input")});const Rr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?Qt(n,"postpatch",()=>{Rr.componentUpdated(t,e,n)}):Hr(t,e,n.context),t._vOptions=[].map.call(t.options,zr)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Vr),t.addEventListener("compositionend",Kr),t.addEventListener("change",Kr),W&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Hr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,zr);if(r.some((t,e)=>!N(t,o[e]))){(t.multiple?e.value.some(t=>Ur(t,r)):e.value!==e.oldValue&&Ur(e.value,r))&&Jr(t,"change")}}}};function Hr(t,e,n){Br(t,e,n),(q||Z)&&setTimeout(()=>{Br(t,e,n)},0)}function Br(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,zr(i))>-1,i.selected!==s&&(i.selected=s);else if(N(zr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Ur(t,e){return e.every(e=>!N(e,t))}function zr(t){return"_value"in t?t._value:t.value}function Vr(t){t.target.composing=!0}function Kr(t){t.target.composing&&(t.target.composing=!1,Jr(t.target,"input"))}function Jr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function qr(t){return!t.componentInstance||t.data&&t.data.transition?t:qr(t.componentInstance._vnode)}var Wr={model:Rr,show:{bind(t,{value:e},n){const o=(n=qr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Dr(n,()=>{t.style.display=r})):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=qr(o)).data&&o.data.transition?(o.data.show=!0,e?Dr(o,()=>{t.style.display=t.__vOriginalDisplay}):Lr(o,()=>{t.style.display="none"})):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}}};const Zr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Gr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Gr(Pe(e.children)):t}function Xr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Yr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Qr=t=>t.tag||Fe(t),ts=t=>"show"===t.name;var es={name:"transition",props:Zr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(!(e=e.filter(Qr)).length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Gr(o);if(!s)return o;if(this._leaving)return Yr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=Xr(this),c=this._vnode,l=Gr(c);if(s.data.directives&&s.data.directives.some(ts)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!Fe(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,Qt(e,"afterLeave",()=>{this._leaving=!1,this.$forceUpdate()}),Yr(t,o);if("in-out"===n){if(Fe(s))return c;let t;const n=()=>{t()};Qt(a,"afterEnter",n),Qt(a,"enterCancelled",n),Qt(e,"delayLeave",e=>{t=e})}}return o}};const ns=A({tag:String,moveClass:String},Zr);function os(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function rs(t){t.data.newPos=t.elm.getBoundingClientRect()}function ss(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete ns.mode;var is={Transition:es,TransitionGroup:{props:ns,beforeMount(){const t=this._update;this._update=((e,n)=>{const o=Ve(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)})},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=Xr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(os),t.forEach(rs),t.forEach(ss),this._reflow=document.body.offsetHeight,t.forEach(t=>{if(t.data.moved){const n=t.elm,o=n.style;Ar(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(br,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(br,t),n._moveCb=null,Or(n,e))})}}))},methods:{hasMove(t,e){if(!gr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(t=>{hr(n,t)}),pr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Er(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};yn.config.mustUseProp=An,yn.config.isReservedTag=Un,yn.config.isReservedAttr=xn,yn.config.getTagNamespace=zn,yn.config.isUnknownElement=function(t){if(!z)return!0;if(Un(t))return!1;if(t=t.toLowerCase(),null!=Vn[t])return Vn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Vn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Vn[t]=/HTMLUnknownElement/.test(e.toString())},A(yn.options.directives,Wr),A(yn.options.components,is),yn.prototype.__patch__=z?Pr:S,yn.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=pt),qe(t,"beforeMount"),o=(()=>{t._update(t._render(),n)}),new rn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&qe(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,qe(t,"mounted")),t}(this,t=t&&z?Jn(t):void 0,e)},z&&setTimeout(()=>{F.devtools&&nt&&nt.emit("init",yn)},0);const as=/\{\{((?:.|\r?\n)+?)\}\}/g,cs=/[-.*+?^${}()|[\]\/\\]/g,ls=v(t=>{const e=t[0].replace(cs,"\\$&"),n=t[1].replace(cs,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")});var us={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=Ao(t,"class");n&&(t.staticClass=JSON.stringify(n));const o=ko(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var fs={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=Ao(t,"style");n&&(t.staticStyle=JSON.stringify(er(n)));const o=ko(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let ds;var ps={decode:t=>((ds=ds||document.createElement("div")).innerHTML=t,ds.textContent)};const hs=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),ms=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ys=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),gs=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,vs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,$s=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${P.source}]*`,_s=`((?:${$s}\\:)?${$s})`,bs=new RegExp(`^<${_s}`),ws=/^\s*(\/?)>/,Cs=new RegExp(`^<\\/${_s}[^>]*>`),xs=/^<!DOCTYPE [^>]+>/i,ks=/^<!\--/,As=/^<!\[/,Os=d("script,style,textarea",!0),Ss={},Ts={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Es=/&(?:lt|gt|quot|amp|#39);/g,Ns=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,js=d("pre,textarea",!0),Ds=(t,e)=>t&&js(t)&&"\n"===e[0];function Ls(t,e){const n=e?Ns:Es;return t.replace(n,t=>Ts[t])}const Ms=/^@|^v-on:/,Is=/^v-|^@|^:|^#/,Fs=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Ps=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Rs=/^\(|\)$/g,Hs=/^\[.*\]$/,Bs=/:(.*)$/,Us=/^:|^\.|^v-bind:/,zs=/\.[^.\]]+(?=[^\]]*$)/g,Vs=/^v-slot(:|$)|^#/,Ks=/[\r\n]/,Js=/\s+/g,qs=v(ps.decode),Ws="_empty_";let Zs,Gs,Xs,Ys,Qs,ti,ei,ni;function oi(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ui(e),rawAttrsMap:{},parent:n,children:[]}}function ri(t,e){Zs=e.warn||go,ti=e.isPreTag||T,ei=e.mustUseProp||T,ni=e.getTagNamespace||T;e.isReservedTag;Xs=vo(e.modules,"transformNode"),Ys=vo(e.modules,"preTransformNode"),Qs=vo(e.modules,"postTransformNode"),Gs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=si(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&ai(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&ai(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter(t=>!t.slotScope),u(t),t.pre&&(a=!1),ti(t.tag)&&(c=!1);for(let n=0;n<Qs.length;n++)Qs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&Os(a)){let n=0;const o=a.toLowerCase(),r=Ss[o]||(Ss[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,function(t,r,s){return n=s.length,Os(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ds(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""});c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(ks.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(As.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(xs);if(n){l(n[0].length);continue}const o=t.match(Cs);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),Ds(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(Cs.test(o)||bs.test(o)||ks.test(o)||As.test(o)||(r=o.indexOf("<",1))<0);)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(bs);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(ws))&&(r=t.match(vs)||t.match(gs));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ys(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ls(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:Zs,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||ni(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];fi.test(o.name)||(o.name=o.name.replace(di,""),e.push(o))}return e}(o));let p=oi(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||et()||(p.forbidden=!0);for(let t=0;t<Ys.length;t++)p=Ys[t](p,e)||p;a||(!function(t){null!=Ao(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),ti(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ii(p),function(t){const e=Ao(t,"v-if");if(e)t.if=e,ai(t,{exp:e,block:t});else{null!=Ao(t,"v-else")&&(t.else=!0);const e=Ao(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=Ao(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(q&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:qs(t):s.length?r?"condense"===r&&Ks.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Js," ")),!a&&" "!==t&&(e=function(t,e){const n=e?ls(e):as;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){(i=s.index)>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=mo(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Gs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function si(t,e){var n;!function(t){const e=ko(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=ko(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=Ao(t,"scope"),t.slotScope=e||Ao(t,"slot-scope")):(e=Ao(t,"slot-scope"))&&(t.slotScope=e);const n=ko(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||_o(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=Oo(t,Vs);if(e){const{name:n,dynamic:o}=ci(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||Ws}}else{const e=Oo(t,Vs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ci(e),s=n[o]=oi("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter(t=>{if(!t.slotScope)return t.parent=s,!0}),s.slotScope=e.value||Ws,t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=ko(n,"name")),function(t){let e;(e=ko(t,"is"))&&(t.component=e);null!=Ao(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Xs.length;n++)t=Xs[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Is.test(r))if(t.hasBindings=!0,(a=li(r.replace(Is,"")))&&(r=r.replace(zs,"")),Us.test(r))r=r.replace(Us,""),i=mo(i),(l=Hs.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&"innerHtml"===(r=_(r))&&(r="innerHTML"),a.camel&&!l&&(r=_(r)),a.sync&&(c=Eo(i,"$event"),l?xo(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(xo(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&xo(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&ei(t.tag,t.attrsMap.type,r)?$o(t,r,i,e[n],l):_o(t,r,i,e[n],l);else if(Ms.test(r))r=r.replace(Ms,""),(l=Hs.test(r))&&(r=r.slice(1,-1)),xo(t,r,i,a,!1,0,e[n],l);else{const o=(r=r.replace(Is,"")).match(Bs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Hs.test(c)&&(c=c.slice(1,-1),l=!0)),wo(t,r,s,i,c,l,a,e[n])}else _o(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&ei(t.tag,t.attrsMap.type,r)&&$o(t,r,"true",e[n])}(t),t}function ii(t){let e;if(e=Ao(t,"v-for")){const n=function(t){const e=t.match(Fs);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Rs,""),r=o.match(Ps);r?(n.alias=o.replace(Ps,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function ai(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ci(t){let e=t.name.replace(Vs,"");return e||"#"!==t.name[0]&&(e="default"),Hs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function li(t){const e=t.match(zs);if(e){const t={};return e.forEach(e=>{t[e.slice(1)]=!0}),t}}function ui(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const fi=/^xmlns:NS\d+/,di=/^NS\d+:/;function pi(t){return oi(t.tag,t.attrsList.slice(),t.parent)}var hi=[us,fs,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=ko(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=Ao(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=Ao(t,"v-else",!0),i=Ao(t,"v-else-if",!0),a=pi(t);ii(a),bo(a,"type","checkbox"),si(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,ai(a,{exp:a.if,block:a});const c=pi(t);Ao(c,"v-for",!0),bo(c,"type","radio"),si(c,e),ai(a,{exp:`(${o})==='radio'`+r,block:c});const l=pi(t);return Ao(l,"v-for",!0),bo(l,":type",o),si(l,e),ai(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const mi={expectHTML:!0,modules:hi,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return To(t,o,r),!1;if("select"===s)!function(t,e,n){let o=`var $$selectedVal = ${'Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;'+`return ${n&&n.number?"_n(val)":"val"}})`};`;o=`${o} ${Eo(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,xo(t,"change",o,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=ko(t,"value")||"null",s=ko(t,"true-value")||"true",i=ko(t,"false-value")||"false";$o(t,"checked",`Array.isArray(${e})`+`?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),xo(t,"change",`var $$a=${e},`+"$$el=$event.target,"+`$$c=$$el.checked?(${s}):(${i});`+"if(Array.isArray($$a)){"+`var $$v=${o?"_n("+r+")":r},`+"$$i=_i($$a,$$v);"+`if($$el.checked){$$i<0&&(${Eo(e,"$$a.concat([$$v])")})}`+`else{$$i>-1&&(${Eo(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}`+`}else{${Eo(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=ko(t,"value")||"null";$o(t,"checked",`_q(${e},${r=o?`_n(${r})`:r})`),xo(t,"change",Eo(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?Uo:"input";let l="$event.target.value";i&&(l="$event.target.value.trim()"),s&&(l=`_n(${l})`);let u=Eo(e,l);a&&(u=`if($event.target.composing)return;${u}`),$o(t,"value",`(${e})`),xo(t,c,u,null,!0),(i||s)&&xo(t,"blur","$forceUpdate()")}(t,o,r);else if(!F.isReservedTag(s))return To(t,o,r),!1;return!0},text:function(t,e){e.value&&$o(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&$o(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:hs,mustUseProp:An,canBeLeftOpenTag:ms,isReservedTag:Un,getTagNamespace:zn,staticKeys:function(t){return t.reduce((t,e)=>t.concat(e.staticKeys||[]),[]).join(",")}(hi)};let yi,gi;const vi=v(function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))});function $i(t,e){t&&(yi=vi(e.staticKeys||""),gi=e.isReservedTag||T,function t(e){e.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!gi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(yi)))}(e);if(1===e.type){if(!gi(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(let n=0,o=e.children.length;n<o;n++){const o=e.children[n];t(o),o.static||(e.static=!1)}if(e.ifConditions)for(let n=1,o=e.ifConditions.length;n<o;n++){const o=e.ifConditions[n].block;t(o),o.static||(e.static=!1)}}}(t),function t(e,n){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=n),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(let o=0,r=e.children.length;o<r;o++)t(e.children[o],n||!!e.for);if(e.ifConditions)for(let o=1,r=e.ifConditions.length;o<r;o++)t(e.ifConditions[o].block,n)}}(t,!1))}const _i=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,bi=/\([^)]*?\);*$/,wi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},ki=t=>`if(${t})return null;`,Ai={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:ki("$event.target !== $event.currentTarget"),ctrl:ki("!$event.ctrlKey"),shift:ki("!$event.shiftKey"),alt:ki("!$event.altKey"),meta:ki("!$event.metaKey"),left:ki("'button' in $event && $event.button !== 0"),middle:ki("'button' in $event && $event.button !== 1"),right:ki("'button' in $event && $event.button !== 2")};function Oi(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Si(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Si(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map(t=>Si(t)).join(",")}]`;const e=wi.test(t.value),n=_i.test(t.value),o=wi.test(t.value.replace(bi,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ai[e])s+=Ai[e],Ci[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=ki(["ctrl","shift","alt","meta"].filter(t=>!e[t]).map(t=>`$event.${t}Key`).join("||"))}else i.push(e);return i.length&&(r+=function(t){return"if(!$event.type.indexOf('key')&&"+`${t.map(Ti).join("&&")})return null;`}(i)),s&&(r+=s),`function($event){${r}${e?`return ${t.value}($event)`:n?`return (${t.value})($event)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ti(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Ci[t],o=xi[t];return"_k($event.keyCode,"+`${JSON.stringify(t)},`+`${JSON.stringify(n)},`+"$event.key,"+`${JSON.stringify(o)}`+")"}var Ei={on:function(t,e){t.wrapListeners=(t=>`_g(${t},${e.value})`)},bind:function(t,e){t.wrapData=(n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`)},cloak:S};class Ni{constructor(t){this.options=t,this.warn=t.warn||go,this.transforms=vo(t.modules,"transformCode"),this.dataGenFns=vo(t.modules,"genData"),this.directives=A(A({},Ei),t.directives);const e=t.isReservedTag||T;this.maybeComponent=(t=>!!t.component||!e(t.tag)),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function ji(t,e){const n=new Ni(e);return{render:`with(this){return ${t?Di(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Di(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Li(t,e);if(t.once&&!t.onceProcessed)return Mi(t,e);if(t.for&&!t.forProcessed)return Fi(t,e);if(t.if&&!t.ifProcessed)return Ii(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Bi(t,e);let r=`_t(${n}${o?`,${o}`:""}`;const s=t.attrs||t.dynamicAttrs?Vi((t.attrs||[]).concat(t.dynamicAttrs||[]).map(t=>({name:_(t.name),value:t.value,dynamic:t.dynamic}))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Bi(e,n,!0);return`_c(${t},${Pi(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Pi(t,e));const r=t.inlineTemplate?null:Bi(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Bi(t,e)||"void 0"}function Li(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Di(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Mi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Ii(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Di(t,e)},${e.onceId++},${n})`:Di(t,e)}return Li(t,e)}function Ii(t,e,n,o){return t.ifProcessed=!0,function t(e,n,o,r){if(!e.length)return r||"_e()";const s=e.shift();return s.exp?`(${s.exp})?${i(s.block)}:${t(e,n,o,r)}`:`${i(s.block)}`;function i(t){return o?o(t,n):t.once?Mi(t,n):Di(t,n)}}(t.ifConditions.slice(),e,n,o)}function Fi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),`+`function(${s}${i}${a}){`+`return ${(n||Di)(t,e)}`+"})"}function Pi(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Vi(t.attrs)},`),t.props&&(n+=`domProps:${Vi(t.props)},`),t.events&&(n+=`${Oi(t.events,!1)},`),t.nativeEvents&&(n+=`${Oi(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some(t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Ri(n)}),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&e.slotScope!==Ws||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map(t=>Hi(e[t],n)).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=ji(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map(t=>`function(){${t}}`).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Vi(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Ri(t){return 1===t.type&&("slot"===t.tag||t.children.some(Ri))}function Hi(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Ii(t,e,Hi,"null");if(t.for&&!t.forProcessed)return Fi(t,e,Hi);const o=t.slotScope===Ws?"":String(t.slotScope),r=`function(${o}){`+`return ${"template"===t.tag?t.if&&n?`(${t.if})?${Bi(t,e)||"undefined"}:undefined`:Bi(t,e)||"undefined":Di(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Bi(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Di)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(Ui(r)||r.ifConditions&&r.ifConditions.some(t=>Ui(t.block))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some(t=>e(t.block)))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||zi;return`[${s.map(t=>a(t,e)).join(",")}]${i?`,${i}`:""}`}}function Ui(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function zi(t,e){return 1===t.type?Di(t,e):3===t.type&&t.isComment?(o=t,`_e(${JSON.stringify(o.text)})`):`_v(${2===(n=t).type?n.expression:Ki(JSON.stringify(n.text))})`;var n,o}function Vi(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Ki(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Ki(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Ji(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function qi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn;delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=Ji(i.render,c),a.staticRenderFns=i.staticRenderFns.map(t=>Ji(t,c)),e[s]=a}}const Wi=(Zi=function(t,e){const n=ri(t.trim(),e);!1!==e.optimize&&$i(n,e);const o=ji(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=((t,e,n)=>{(n?s:r).push(t)});const i=Zi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:qi(e)}});var Zi;const{compile:Gi,compileToFunctions:Xi}=Wi(mi);let Yi;function Qi(t){return(Yi=Yi||document.createElement("div")).innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Yi.innerHTML.indexOf("&#10;")>0}const ta=!!z&&Qi(!1),ea=!!z&&Qi(!0),na=v(t=>{const e=Jn(t);return e&&e.innerHTML}),oa=yn.prototype.$mount;yn.prototype.$mount=function(t,e){if((t=t&&Jn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=na(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Xi(e,{outputSourceRange:!1,shouldDecodeNewlines:ta,shouldDecodeNewlinesForHref:ea,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return oa.call(this,t,e)},yn.compile=Xi;export default yn;
\ No newline at end of file
+const e=Object.freeze({});function t(e){return null==e}function r(e){return null!=e}function n(e){return!0===e}function o(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function s(e){return null!==e&&"object"==typeof e}const a=Object.prototype.toString;function i(e){return"[object Object]"===a.call(e)}function c(e){const t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return r(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||i(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function p(e){const t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){const r=Object.create(null),n=e.split(",");for(let e=0;e<n.length;e++)r[n[e]]=!0;return t?e=>r[e.toLowerCase()]:e=>r[e]}const f=d("slot,component",!0),m=d("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){const r=e.indexOf(t);if(r>-1)return e.splice(r,1)}}const g=Object.prototype.hasOwnProperty;function b(e,t){return g.call(e,t)}function y(e){const t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}const v=/-(\w)/g,w=y(e=>e.replace(v,(e,t)=>t?t.toUpperCase():"")),A=y(e=>e.charAt(0).toUpperCase()+e.slice(1)),D=/\B([A-Z])/g,x=y(e=>e.replace(D,"-$1").toLowerCase());const q=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function r(r){const n=arguments.length;return n?n>1?e.apply(t,arguments):e.call(t,r):e.call(t)}return r._length=e.length,r};function $(e,t){t=t||0;let r=e.length-t;const n=new Array(r);for(;r--;)n[r]=e[r+t];return n}function k(e,t){for(const r in t)e[r]=t[r];return e}function E(e){const t={};for(let r=0;r<e.length;r++)e[r]&&k(t,e[r]);return t}function _(e,t,r){}const C=(e,t,r)=>!1,S=e=>e;function L(e,t){if(e===t)return!0;const r=s(e),n=s(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{const r=Array.isArray(e),n=Array.isArray(t);if(r&&n)return e.length===t.length&&e.every((e,r)=>L(e,t[r]));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(r||n)return!1;{const r=Object.keys(e),n=Object.keys(t);return r.length===n.length&&r.every(r=>L(e[r],t[r]))}}catch(e){return!1}}function T(e,t){for(let r=0;r<e.length;r++)if(L(e[r],t))return r;return-1}function N(e){let t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}const O="data-server-rendered",R=["component","directive","filter"],F=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var B={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:C,isReservedAttr:C,isUnknownElement:C,getTagNamespace:_,parsePlatformTagName:S,mustUseProp:C,async:!0,_lifecycleHooks:F};const U=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function V(e){const t=(e+"").charCodeAt(0);return 36===t||95===t}function I(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}const j=new RegExp(`[^${U.source}.$_\\d]`);const P="__proto__"in{},H="undefined"!=typeof window,M="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,G=M&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),J=z&&/msie|trident/.test(z),K=z&&z.indexOf("msie 9.0")>0,Z=z&&z.indexOf("edge/")>0,Y=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===G),W=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Q={}.watch;let X,ee=!1;if(H)try{const e={};Object.defineProperty(e,"passive",{get(){ee=!0}}),window.addEventListener("test-passive",null,e)}catch(e){}const te=()=>(void 0===X&&(X=!H&&!M&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X),re=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ne(e){return"function"==typeof e&&/native code/.test(e.toString())}const oe="undefined"!=typeof Symbol&&ne(Symbol)&&"undefined"!=typeof Reflect&&ne(Reflect.ownKeys);let se;se="undefined"!=typeof Set&&ne(Set)?Set:class{constructor(){this.set=Object.create(null)}has(e){return!0===this.set[e]}add(e){this.set[e]=!0}clear(){this.set=Object.create(null)}};let ae=_,ie=0;class ce{constructor(){this.id=ie++,this.subs=[]}addSub(e){this.subs.push(e)}removeSub(e){h(this.subs,e)}depend(){ce.target&&ce.target.addDep(this)}notify(){const e=this.subs.slice();for(let t=0,r=e.length;t<r;t++)e[t].update()}}ce.target=null;const le=[];function ue(e){le.push(e),ce.target=e}function pe(){le.pop(),ce.target=le[le.length-1]}class de{constructor(e,t,r,n,o,s,a,i){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=o,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=i,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const fe=(e="")=>{const t=new de;return t.text=e,t.isComment=!0,t};function me(e){return new de(void 0,void 0,void 0,String(e))}function he(e){const t=new de(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}const ge=Array.prototype,be=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){const t=ge[e];I(be,e,function(...r){const n=t.apply(this,r),o=this.__ob__;let s;switch(e){case"push":case"unshift":s=r;break;case"splice":s=r.slice(2)}return s&&o.observeArray(s),o.dep.notify(),n})});const ye=Object.getOwnPropertyNames(be);let ve=!0;function we(e){ve=e}class Ae{constructor(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,I(e,"__ob__",this),Array.isArray(e)?(P?(t=be,e.__proto__=t):function(e,t,r){for(let n=0,o=r.length;n<o;n++){const o=r[n];I(e,o,t[o])}}(e,be,ye),this.observeArray(e)):this.walk(e)}walk(e){const t=Object.keys(e);for(let r=0;r<t.length;r++)xe(e,t[r])}observeArray(e){for(let t=0,r=e.length;t<r;t++)De(e[t])}}function De(e,t){if(!s(e)||e instanceof de)return;let r;return b(e,"__ob__")&&e.__ob__ instanceof Ae?r=e.__ob__:ve&&!te()&&(Array.isArray(e)||i(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Ae(e)),t&&r&&r.vmCount++,r}function xe(e,t,r,n,o){const s=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(a&&!1===a.configurable)return;const i=a&&a.get,c=a&&a.set;i&&!c||2!==arguments.length||(r=e[t]);let l=!o&&De(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){const t=i?i.call(e):r;return ce.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(let r,n=0,o=t.length;n<o;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){const n=i?i.call(e):r;t===n||t!=t&&n!=n||i&&!c||(c?c.call(e,t):r=t,l=!o&&De(t),s.notify())}})}function qe(e,t,r){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;const n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(xe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}function $e(e,t){if(Array.isArray(e)&&c(t))return void e.splice(t,1);const r=e.__ob__;e._isVue||r&&r.vmCount||b(e,t)&&(delete e[t],r&&r.dep.notify())}const ke=B.optionMergeStrategies;function Ee(e,t){if(!t)return e;let r,n,o;const s=oe?Reflect.ownKeys(t):Object.keys(t);for(let a=0;a<s.length;a++)"__ob__"!==(r=s[a])&&(n=e[r],o=t[r],b(e,r)?n!==o&&i(n)&&i(o)&&Ee(n,o):qe(e,r,o));return e}function _e(e,t,r){return r?function(){const n="function"==typeof t?t.call(r,r):t,o="function"==typeof e?e.call(r,r):e;return n?Ee(n,o):o}:t?e?function(){return Ee("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ce(e,t){const r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){const t=[];for(let r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Se(e,t,r,n){const o=Object.create(e||null);return t?k(o,t):o}ke.data=function(e,t,r){return r?_e(e,t,r):t&&"function"!=typeof t?e:_e(e,t)},F.forEach(e=>{ke[e]=Ce}),R.forEach(function(e){ke[e+"s"]=Se}),ke.watch=function(e,t,r,n){if(e===Q&&(e=void 0),t===Q&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;const o={};k(o,e);for(const e in t){let r=o[e];const n=t[e];r&&!Array.isArray(r)&&(r=[r]),o[e]=r?r.concat(n):Array.isArray(n)?n:[n]}return o},ke.props=ke.methods=ke.inject=ke.computed=function(e,t,r,n){if(!e)return t;const o=Object.create(null);return k(o,e),t&&k(o,t),o},ke.provide=_e;const Le=function(e,t){return void 0===t?e:t};function Te(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){const r=e.props;if(!r)return;const n={};let o,s,a;if(Array.isArray(r))for(o=r.length;o--;)"string"==typeof(s=r[o])&&(n[a=w(s)]={type:null});else if(i(r))for(const e in r)s=r[e],n[a=w(e)]=i(s)?s:{type:s};e.props=n}(t),function(e,t){const r=e.inject;if(!r)return;const n=e.inject={};if(Array.isArray(r))for(let e=0;e<r.length;e++)n[r[e]]={from:r[e]};else if(i(r))for(const e in r){const t=r[e];n[e]=i(t)?k({from:e},t):{from:t}}}(t),function(e){const t=e.directives;if(t)for(const e in t){const r=t[e];"function"==typeof r&&(t[e]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Te(e,t.extends,r)),t.mixins))for(let n=0,o=t.mixins.length;n<o;n++)e=Te(e,t.mixins[n],r);const n={};let o;for(o in e)s(o);for(o in t)b(e,o)||s(o);function s(o){const s=ke[o]||Le;n[o]=s(e[o],t[o],r,o)}return n}function Ne(e,t,r,n){if("string"!=typeof r)return;const o=e[t];if(b(o,r))return o[r];const s=w(r);if(b(o,s))return o[s];const a=A(s);return b(o,a)?o[a]:o[r]||o[s]||o[a]}function Oe(e,t,r,n){const o=t[e],s=!b(r,e);let a=r[e];const i=Ue(Boolean,o.type);if(i>-1)if(s&&!b(o,"default"))a=!1;else if(""===a||a===x(e)){const e=Ue(String,o.type);(e<0||i<e)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!b(t,"default"))return;const n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Fe(t.type)?n.call(e):n}(n,o,e);const t=ve;we(!0),De(a),we(t)}return a}const Re=/^\s*function (\w+)/;function Fe(e){const t=e&&e.toString().match(Re);return t?t[1]:""}function Be(e,t){return Fe(e)===Fe(t)}function Ue(e,t){if(!Array.isArray(t))return Be(t,e)?0:-1;for(let r=0,n=t.length;r<n;r++)if(Be(t[r],e))return r;return-1}function Ve(e,t,r){ue();try{if(t){let n=t;for(;n=n.$parent;){const o=n.$options.errorCaptured;if(o)for(let s=0;s<o.length;s++)try{if(!1===o[s].call(n,e,t,r))return}catch(e){je(e,n,"errorCaptured hook")}}}je(e,t,r)}finally{pe()}}function Ie(e,t,r,n,o){let s;try{(s=r?e.apply(t,r):e.call(t))&&!s._isVue&&l(s)&&!s._handled&&(s.catch(e=>Ve(e,n,o+" (Promise/async)")),s._handled=!0)}catch(e){Ve(e,n,o)}return s}function je(e,t,r){if(B.errorHandler)try{return B.errorHandler.call(null,e,t,r)}catch(t){t!==e&&Pe(t,null,"config.errorHandler")}Pe(e,t,r)}function Pe(e,t,r){if(!H&&!M||"undefined"==typeof console)throw e;console.error(e)}let He=!1;const Me=[];let Ge,ze=!1;function Je(){ze=!1;const e=Me.slice(0);Me.length=0;for(let t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&ne(Promise)){const e=Promise.resolve();Ge=(()=>{e.then(Je),Y&&setTimeout(_)}),He=!0}else if(J||"undefined"==typeof MutationObserver||!ne(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ge="undefined"!=typeof setImmediate&&ne(setImmediate)?()=>{setImmediate(Je)}:()=>{setTimeout(Je,0)};else{let e=1;const t=new MutationObserver(Je),r=document.createTextNode(String(e));t.observe(r,{characterData:!0}),Ge=(()=>{e=(e+1)%2,r.data=String(e)}),He=!0}function Ke(e,t){let r;if(Me.push(()=>{if(e)try{e.call(t)}catch(e){Ve(e,t,"nextTick")}else r&&r(t)}),ze||(ze=!0,Ge()),!e&&"undefined"!=typeof Promise)return new Promise(e=>{r=e})}const Ze=new se;function Ye(e){!function e(t,r){let n,o;const a=Array.isArray(t);if(!a&&!s(t)||Object.isFrozen(t)||t instanceof de)return;if(t.__ob__){const e=t.__ob__.dep.id;if(r.has(e))return;r.add(e)}if(a)for(n=t.length;n--;)e(t[n],r);else for(o=Object.keys(t),n=o.length;n--;)e(t[o[n]],r)}(e,Ze),Ze.clear()}const We=y(e=>{const t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function Qe(e,t){function r(){const e=r.fns;if(!Array.isArray(e))return Ie(e,null,arguments,t,"v-on handler");{const r=e.slice();for(let e=0;e<r.length;e++)Ie(r[e],null,arguments,t,"v-on handler")}}return r.fns=e,r}function Xe(e,r,o,s,a,i){let c,l,u,p,d;for(c in e)l=u=e[c],p=r[c],d=We(c),t(u)||(t(p)?(t(u.fns)&&(u=e[c]=Qe(u,i)),n(d.once)&&(u=e[c]=a(d.name,u,d.capture)),o(d.name,u,d.capture,d.passive,d.params)):u!==p&&(p.fns=u,e[c]=p));for(c in r)t(e[c])&&s((d=We(c)).name,r[c],d.capture)}function et(e,o,s){let a;e instanceof de&&(e=e.data.hook||(e.data.hook={}));const i=e[o];function c(){s.apply(this,arguments),h(a.fns,c)}t(i)?a=Qe([c]):r(i.fns)&&n(i.merged)?(a=i).fns.push(c):a=Qe([i,c]),a.merged=!0,e[o]=a}function tt(e,t,n,o,s){if(r(t)){if(b(t,n))return e[n]=t[n],s||delete t[n],!0;if(b(t,o))return e[n]=t[o],s||delete t[o],!0}return!1}function rt(e){return o(e)?[me(e)]:Array.isArray(e)?function e(s,a){const i=[];let c,l,u,p;for(c=0;c<s.length;c++)t(l=s[c])||"boolean"==typeof l||(u=i.length-1,p=i[u],Array.isArray(l)?l.length>0&&(nt((l=e(l,`${a||""}_${c}`))[0])&&nt(p)&&(i[u]=me(p.text+l[0].text),l.shift()),i.push.apply(i,l)):o(l)?nt(p)?i[u]=me(p.text+l):""!==l&&i.push(me(l)):nt(l)&&nt(p)?i[u]=me(p.text+l.text):(n(s._isVList)&&r(l.tag)&&t(l.key)&&r(a)&&(l.key=`__vlist${a}_${c}__`),i.push(l)));return i}(e):void 0}function nt(e){return r(e)&&r(e.text)&&!1===e.isComment}function ot(e,t){if(e){const r=Object.create(null),n=oe?Reflect.ownKeys(e):Object.keys(e);for(let o=0;o<n.length;o++){const s=n[o];if("__ob__"===s)continue;const a=e[s].from;let i=t;for(;i;){if(i._provided&&b(i._provided,a)){r[s]=i._provided[a];break}i=i.$parent}if(!i&&"default"in e[s]){const n=e[s].default;r[s]="function"==typeof n?n.call(t):n}}return r}}function st(e,t){if(!e||!e.length)return{};const r={};for(let n=0,o=e.length;n<o;n++){const o=e[n],s=o.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,o.context!==t&&o.fnContext!==t||!s||null==s.slot)(r.default||(r.default=[])).push(o);else{const e=s.slot,t=r[e]||(r[e]=[]);"template"===o.tag?t.push.apply(t,o.children||[]):t.push(o)}}for(const e in r)r[e].every(at)&&delete r[e];return r}function at(e){return e.isComment&&!e.asyncFactory||" "===e.text}function it(t,r,n){let o;const s=Object.keys(r).length>0,a=t?!!t.$stable:!s,i=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&n&&n!==e&&i===n.$key&&!s&&!n.$hasNormal)return n;o={};for(const e in t)t[e]&&"$"!==e[0]&&(o[e]=ct(r,e,t[e]))}else o={};for(const e in r)e in o||(o[e]=lt(r,e));return t&&Object.isExtensible(t)&&(t._normalized=o),I(o,"$stable",a),I(o,"$key",i),I(o,"$hasNormal",s),o}function ct(e,t,r){const n=function(){let e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:rt(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function lt(e,t){return()=>e[t]}function ut(e,t){let n,o,a,i,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,o=e.length;n<o;n++)c[n]=t(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=t(n+1,n);else if(s(e))if(oe&&e[Symbol.iterator]){c=[];const r=e[Symbol.iterator]();let n=r.next();for(;!n.done;)c.push(t(n.value,c.length)),n=r.next()}else for(a=Object.keys(e),c=new Array(a.length),n=0,o=a.length;n<o;n++)i=a[n],c[n]=t(e[i],i,n);return r(c)||(c=[]),c._isVList=!0,c}function pt(e,t,r,n){const o=this.$scopedSlots[e];let s;o?(r=r||{},n&&(r=k(k({},n),r)),s=o(r)||t):s=this.$slots[e]||t;const a=r&&r.slot;return a?this.$createElement("template",{slot:a},s):s}function dt(e){return Ne(this.$options,"filters",e)||S}function ft(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function mt(e,t,r,n,o){const s=B.keyCodes[t]||r;return o&&n&&!B.keyCodes[t]?ft(o,n):s?ft(s,e):n?x(n)!==t:void 0}function ht(e,t,r,n,o){if(r)if(s(r)){let s;Array.isArray(r)&&(r=E(r));for(const a in r){if("class"===a||"style"===a||m(a))s=e;else{const r=e.attrs&&e.attrs.type;s=n||B.mustUseProp(t,r,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}const i=w(a),c=x(a);if(!(i in s||c in s)&&(s[a]=r[a],o)){(e.on||(e.on={}))[`update:${a}`]=function(e){r[a]=e}}}}else;return e}function gt(e,t){const r=this._staticTrees||(this._staticTrees=[]);let n=r[e];return n&&!t?n:(yt(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),`__static__${e}`,!1),n)}function bt(e,t,r){return yt(e,`__once__${t}${r?`_${r}`:""}`,!0),e}function yt(e,t,r){if(Array.isArray(e))for(let n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&vt(e[n],`${t}_${n}`,r);else vt(e,t,r)}function vt(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function wt(e,t){if(t)if(i(t)){const r=e.on=e.on?k({},e.on):{};for(const e in t){const n=r[e],o=t[e];r[e]=n?[].concat(n,o):o}}else;return e}function At(e,t,r,n){t=t||{$stable:!r};for(let n=0;n<e.length;n++){const o=e[n];Array.isArray(o)?At(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function Dt(e,t){for(let r=0;r<t.length;r+=2){const n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function xt(e,t){return"string"==typeof e?t+e:e}function qt(e){e._o=bt,e._n=p,e._s=u,e._l=ut,e._t=pt,e._q=L,e._i=T,e._m=gt,e._f=dt,e._k=mt,e._b=ht,e._v=me,e._e=fe,e._u=At,e._g=wt,e._d=Dt,e._p=xt}function $t(t,r,o,s,a){const i=a.options;let c;b(s,"_uid")?(c=Object.create(s))._original=s:(c=s,s=s._original);const l=n(i._compiled),u=!l;this.data=t,this.props=r,this.children=o,this.parent=s,this.listeners=t.on||e,this.injections=ot(i.inject,s),this.slots=(()=>(this.$slots||it(t.scopedSlots,this.$slots=st(o,s)),this.$slots)),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return it(t.scopedSlots,this.slots())}}),l&&(this.$options=i,this.$slots=this.slots(),this.$scopedSlots=it(t.scopedSlots,this.$slots)),i._scopeId?this._c=((e,t,r,n)=>{const o=Ot(c,e,t,r,n,u);return o&&!Array.isArray(o)&&(o.fnScopeId=i._scopeId,o.fnContext=s),o}):this._c=((e,t,r,n)=>Ot(c,e,t,r,n,u))}function kt(e,t,r,n,o){const s=he(e);return s.fnContext=r,s.fnOptions=n,t.slot&&((s.data||(s.data={})).slot=t.slot),s}function Et(e,t){for(const r in t)e[w(r)]=t[r]}qt($t.prototype);const _t={init(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){const t=e;_t.prepatch(t,t)}else{(e.componentInstance=function(e,t){const n={_isComponent:!0,_parentVnode:e,parent:t},o=e.data.inlineTemplate;r(o)&&(n.render=o.render,n.staticRenderFns=o.staticRenderFns);return new e.componentOptions.Ctor(n)}(e,Mt)).$mount(t?e.elm:void 0,t)}},prepatch(t,r){const n=r.componentOptions;!function(t,r,n,o,s){const a=o.data.scopedSlots,i=t.$scopedSlots,c=!!(a&&!a.$stable||i!==e&&!i.$stable||a&&t.$scopedSlots.$key!==a.$key),l=!!(s||t.$options._renderChildren||c);t.$options._parentVnode=o,t.$vnode=o,t._vnode&&(t._vnode.parent=o);if(t.$options._renderChildren=s,t.$attrs=o.data.attrs||e,t.$listeners=n||e,r&&t.$options.props){we(!1);const e=t._props,n=t.$options._propKeys||[];for(let o=0;o<n.length;o++){const s=n[o],a=t.$options.props;e[s]=Oe(s,a,r,t)}we(!0),t.$options.propsData=r}n=n||e;const u=t.$options._parentListeners;t.$options._parentListeners=n,Ht(t,n,u),l&&(t.$slots=st(s,o.context),t.$forceUpdate())}(r.componentInstance=t.componentInstance,n.propsData,n.listeners,r,n.children)},insert(e){const{context:t,componentInstance:r}=e;var n;r._isMounted||(r._isMounted=!0,Kt(r,"mounted")),e.data.keepAlive&&(t._isMounted?((n=r)._inactive=!1,Yt.push(n)):Jt(r,!0))},destroy(e){const{componentInstance:t}=e;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(r&&(t._directInactive=!0,zt(t)))return;if(!t._inactive){t._inactive=!0;for(let r=0;r<t.$children.length;r++)e(t.$children[r]);Kt(t,"deactivated")}}(t,!0):t.$destroy())}},Ct=Object.keys(_t);function St(o,a,i,c,u){if(t(o))return;const p=i.$options._base;if(s(o)&&(o=p.extend(o)),"function"!=typeof o)return;let d;if(t(o.cid)&&void 0===(o=function(e,o){if(n(e.error)&&r(e.errorComp))return e.errorComp;if(r(e.resolved))return e.resolved;const a=Ft;a&&r(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(n(e.loading)&&r(e.loadingComp))return e.loadingComp;if(a&&!r(e.owners)){const n=e.owners=[a];let i=!0,c=null,u=null;a.$on("hook:destroyed",()=>h(n,a));const p=e=>{for(let e=0,t=n.length;e<t;e++)n[e].$forceUpdate();e&&(n.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=N(t=>{e.resolved=Bt(t,o),i?n.length=0:p(!0)}),f=N(t=>{r(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,f);return s(m)&&(l(m)?t(e.resolved)&&m.then(d,f):l(m.component)&&(m.component.then(d,f),r(m.error)&&(e.errorComp=Bt(m.error,o)),r(m.loading)&&(e.loadingComp=Bt(m.loading,o),0===m.delay?e.loading=!0:c=setTimeout(()=>{c=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),r(m.timeout)&&(u=setTimeout(()=>{u=null,t(e.resolved)&&f(null)},m.timeout)))),i=!1,e.loading?e.loadingComp:e.resolved}}(d=o,p)))return function(e,t,r,n,o){const s=fe();return s.asyncFactory=e,s.asyncMeta={data:t,context:r,children:n,tag:o},s}(d,a,i,c,u);a=a||{},hr(o),r(a.model)&&function(e,t){const n=e.model&&e.model.prop||"value",o=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[n]=t.model.value;const s=t.on||(t.on={}),a=s[o],i=t.model.callback;r(a)?(Array.isArray(a)?-1===a.indexOf(i):a!==i)&&(s[o]=[i].concat(a)):s[o]=i}(o.options,a);const f=function(e,n,o){const s=n.options.props;if(t(s))return;const a={},{attrs:i,props:c}=e;if(r(i)||r(c))for(const e in s){const t=x(e);tt(a,c,e,t,!0)||tt(a,i,e,t,!1)}return a}(a,o);if(n(o.options.functional))return function(t,n,o,s,a){const i=t.options,c={},l=i.props;if(r(l))for(const t in l)c[t]=Oe(t,l,n||e);else r(o.attrs)&&Et(c,o.attrs),r(o.props)&&Et(c,o.props);const u=new $t(o,c,a,s,t),p=i.render.call(null,u._c,u);if(p instanceof de)return kt(p,o,u.parent,i);if(Array.isArray(p)){const e=rt(p)||[],t=new Array(e.length);for(let r=0;r<e.length;r++)t[r]=kt(e[r],o,u.parent,i);return t}}(o,f,a,i,c);const m=a.on;if(a.on=a.nativeOn,n(o.options.abstract)){const e=a.slot;a={},e&&(a.slot=e)}!function(e){const t=e.hook||(e.hook={});for(let e=0;e<Ct.length;e++){const r=Ct[e],n=t[r],o=_t[r];n===o||n&&n._merged||(t[r]=n?Lt(o,n):o)}}(a);const g=o.options.name||u;return new de(`vue-component-${o.cid}${g?`-${g}`:""}`,a,void 0,void 0,void 0,i,{Ctor:o,propsData:f,listeners:m,tag:u,children:c},d)}function Lt(e,t){const r=(r,n)=>{e(r,n),t(r,n)};return r._merged=!0,r}const Tt=1,Nt=2;function Ot(e,a,i,c,l,u){return(Array.isArray(i)||o(i))&&(l=c,c=i,i=void 0),n(u)&&(l=Nt),function(e,o,a,i,c){if(r(a)&&r(a.__ob__))return fe();r(a)&&r(a.is)&&(o=a.is);if(!o)return fe();Array.isArray(i)&&"function"==typeof i[0]&&((a=a||{}).scopedSlots={default:i[0]},i.length=0);c===Nt?i=rt(i):c===Tt&&(i=function(e){for(let t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));let l,u;if("string"==typeof o){let t;u=e.$vnode&&e.$vnode.ns||B.getTagNamespace(o),l=B.isReservedTag(o)?new de(B.parsePlatformTagName(o),a,i,void 0,void 0,e):a&&a.pre||!r(t=Ne(e.$options,"components",o))?new de(o,a,i,void 0,void 0,e):St(t,a,e,i,o)}else l=St(o,a,e,i);return Array.isArray(l)?l:r(l)?(r(u)&&function e(o,s,a){o.ns=s;"foreignObject"===o.tag&&(s=void 0,a=!0);if(r(o.children))for(let i=0,c=o.children.length;i<c;i++){const c=o.children[i];r(c.tag)&&(t(c.ns)||n(a)&&"svg"!==c.tag)&&e(c,s,a)}}(l,u),r(a)&&function(e){s(e.style)&&Ye(e.style);s(e.class)&&Ye(e.class)}(a),l):fe()}(e,a,i,c,l)}let Rt,Ft=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),s(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function Vt(e){if(Array.isArray(e))for(let t=0;t<e.length;t++){const n=e[t];if(r(n)&&(r(n.componentOptions)||Ut(n)))return n}}function It(e,t){Rt.$on(e,t)}function jt(e,t){Rt.$off(e,t)}function Pt(e,t){const r=Rt;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ht(e,t,r){Rt=e,Xe(t,r||{},It,jt,Pt,e),Rt=void 0}let Mt=null;function Gt(e){const t=Mt;return Mt=e,()=>{Mt=t}}function zt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Jt(e,t){if(t){if(e._directInactive=!1,zt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(let t=0;t<e.$children.length;t++)Jt(e.$children[t]);Kt(e,"activated")}}function Kt(e,t){ue();const r=e.$options[t],n=`${t} hook`;if(r)for(let t=0,o=r.length;t<o;t++)Ie(r[t],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),pe()}const Zt=[],Yt=[];let Wt={},Qt=!1,Xt=!1,er=0;let tr=0,rr=Date.now;if(H&&!J){const e=window.performance;e&&"function"==typeof e.now&&rr()>document.createEvent("Event").timeStamp&&(rr=(()=>e.now()))}function nr(){let e,t;for(tr=rr(),Xt=!0,Zt.sort((e,t)=>e.id-t.id),er=0;er<Zt.length;er++)(e=Zt[er]).before&&e.before(),t=e.id,Wt[t]=null,e.run();const r=Yt.slice(),n=Zt.slice();er=Zt.length=Yt.length=0,Wt={},Qt=Xt=!1,function(e){for(let t=0;t<e.length;t++)e[t]._inactive=!0,Jt(e[t],!0)}(r),function(e){let t=e.length;for(;t--;){const r=e[t],n=r.vm;n._watcher===r&&n._isMounted&&!n._isDestroyed&&Kt(n,"updated")}}(n),re&&B.devtools&&re.emit("flush")}let or=0;class sr{constructor(e,t,r,n,o){this.vm=e,o&&(e._watcher=this),e._watchers.push(this),n?(this.deep=!!n.deep,this.user=!!n.user,this.lazy=!!n.lazy,this.sync=!!n.sync,this.before=n.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=r,this.id=++or,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new se,this.newDepIds=new se,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(j.test(e))return;const t=e.split(".");return function(e){for(let r=0;r<t.length;r++){if(!e)return;e=e[t[r]]}return e}}(t),this.getter||(this.getter=_)),this.value=this.lazy?void 0:this.get()}get(){let e;ue(this);const t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Ve(e,t,`getter for watcher "${this.expression}"`)}finally{this.deep&&Ye(e),pe(),this.cleanupDeps()}return e}addDep(e){const t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))}cleanupDeps(){let e=this.deps.length;for(;e--;){const t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}let t=this.depIds;this.depIds=this.newDepIds,this.newDepIds=t,this.newDepIds.clear(),t=this.deps,this.deps=this.newDeps,this.newDeps=t,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){const t=e.id;if(null==Wt[t]){if(Wt[t]=!0,Xt){let t=Zt.length-1;for(;t>er&&Zt[t].id>e.id;)t--;Zt.splice(t+1,0,e)}else Zt.push(e);Qt||(Qt=!0,Ke(nr))}}(this)}run(){if(this.active){const e=this.get();if(e!==this.value||s(e)||this.deep){const t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Ve(e,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,e,t)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let e=this.deps.length;for(;e--;)this.deps[e].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);let e=this.deps.length;for(;e--;)this.deps[e].removeSub(this);this.active=!1}}}const ar={enumerable:!0,configurable:!0,get:_,set:_};function ir(e,t,r){ar.get=function(){return this[t][r]},ar.set=function(e){this[t][r]=e},Object.defineProperty(e,r,ar)}function cr(e){e._watchers=[];const t=e.$options;t.props&&function(e,t){const r=e.$options.propsData||{},n=e._props={},o=e.$options._propKeys=[];e.$parent&&we(!1);for(const s in t){o.push(s);const a=Oe(s,t,r,e);xe(n,s,a),s in e||ir(e,"_props",s)}we(!0)}(e,t.props),t.methods&&function(e,t){e.$options.props;for(const r in t)e[r]="function"!=typeof t[r]?_:q(t[r],e)}(e,t.methods),t.data?function(e){let t=e.$options.data;i(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Ve(e,t,"data()"),{}}finally{pe()}}(t,e):t||{})||(t={});const r=Object.keys(t),n=e.$options.props;e.$options.methods;let o=r.length;for(;o--;){const t=r[o];n&&b(n,t)||V(t)||ir(e,"_data",t)}De(t,!0)}(e):De(e._data={},!0),t.computed&&function(e,t){const r=e._computedWatchers=Object.create(null),n=te();for(const o in t){const s=t[o],a="function"==typeof s?s:s.get;n||(r[o]=new sr(e,a||_,_,lr)),o in e||ur(e,o,s)}}(e,t.computed),t.watch&&t.watch!==Q&&function(e,t){for(const r in t){const n=t[r];if(Array.isArray(n))for(let t=0;t<n.length;t++)fr(e,r,n[t]);else fr(e,r,n)}}(e,t.watch)}const lr={lazy:!0};function ur(e,t,r){const n=!te();"function"==typeof r?(ar.get=n?pr(t):dr(r),ar.set=_):(ar.get=r.get?n&&!1!==r.cache?pr(t):dr(r.get):_,ar.set=r.set||_),Object.defineProperty(e,t,ar)}function pr(e){return function(){const t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function dr(e){return function(){return e.call(this,this)}}function fr(e,t,r,n){return i(r)&&(n=r,r=r.handler),"string"==typeof r&&(r=e[r]),e.$watch(t,r,n)}let mr=0;function hr(e){let t=e.options;if(e.super){const r=hr(e.super);if(r!==e.superOptions){e.superOptions=r;const n=function(e){let t;const r=e.options,n=e.sealedOptions;for(const e in r)r[e]!==n[e]&&(t||(t={}),t[e]=r[e]);return t}(e);n&&k(e.extendOptions,n),(t=e.options=Te(r,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function gr(e){this._init(e)}function br(e){e.cid=0;let t=1;e.extend=function(e){e=e||{};const r=this,n=r.cid,o=e._Ctor||(e._Ctor={});if(o[n])return o[n];const s=e.name||r.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(r.prototype)).constructor=a,a.cid=t++,a.options=Te(r.options,e),a.super=r,a.options.props&&function(e){const t=e.options.props;for(const r in t)ir(e.prototype,"_props",r)}(a),a.options.computed&&function(e){const t=e.options.computed;for(const r in t)ur(e.prototype,r,t[r])}(a),a.extend=r.extend,a.mixin=r.mixin,a.use=r.use,R.forEach(function(e){a[e]=r[e]}),s&&(a.options.components[s]=a),a.superOptions=r.options,a.extendOptions=e,a.sealedOptions=k({},a.options),o[n]=a,a}}function yr(e){return e&&(e.Ctor.options.name||e.tag)}function vr(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(r=e,"[object RegExp]"===a.call(r)&&e.test(t));var r}function wr(e,t){const{cache:r,keys:n,_vnode:o}=e;for(const e in r){const s=r[e];if(s){const a=yr(s.componentOptions);a&&!t(a)&&Ar(r,e,n,o)}}}function Ar(e,t,r,n){const o=e[t];!o||n&&o.tag===n.tag||o.componentInstance.$destroy(),e[t]=null,h(r,t)}!function(t){t.prototype._init=function(t){const r=this;r._uid=mr++,r._isVue=!0,t&&t._isComponent?function(e,t){const r=e.$options=Object.create(e.constructor.options),n=t._parentVnode;r.parent=t.parent,r._parentVnode=n;const o=n.componentOptions;r.propsData=o.propsData,r._parentListeners=o.listeners,r._renderChildren=o.children,r._componentTag=o.tag,t.render&&(r.render=t.render,r.staticRenderFns=t.staticRenderFns)}(r,t):r.$options=Te(hr(r.constructor),t||{},r),r._renderProxy=r,r._self=r,function(e){const t=e.$options;let r=t.parent;if(r&&!t.abstract){for(;r.$options.abstract&&r.$parent;)r=r.$parent;r.$children.push(e)}e.$parent=r,e.$root=r?r.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(r),function(e){e._events=Object.create(null),e._hasHookEvent=!1;const t=e.$options._parentListeners;t&&Ht(e,t)}(r),function(t){t._vnode=null,t._staticTrees=null;const r=t.$options,n=t.$vnode=r._parentVnode,o=n&&n.context;t.$slots=st(r._renderChildren,o),t.$scopedSlots=e,t._c=((e,r,n,o)=>Ot(t,e,r,n,o,!1)),t.$createElement=((e,r,n,o)=>Ot(t,e,r,n,o,!0));const s=n&&n.data;xe(t,"$attrs",s&&s.attrs||e,null,!0),xe(t,"$listeners",r._parentListeners||e,null,!0)}(r),Kt(r,"beforeCreate"),function(e){const t=ot(e.$options.inject,e);t&&(we(!1),Object.keys(t).forEach(r=>{xe(e,r,t[r])}),we(!0))}(r),cr(r),function(e){const t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(r),Kt(r,"created"),r.$options.el&&r.$mount(r.$options.el)}}(gr),function(e){const t={get:function(){return this._data}},r={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",r),e.prototype.$set=qe,e.prototype.$delete=$e,e.prototype.$watch=function(e,t,r){const n=this;if(i(t))return fr(n,e,t,r);(r=r||{}).user=!0;const o=new sr(n,e,t,r);if(r.immediate){ue();try{t.call(n,o.value)}catch(e){Ve(e,n,`callback for immediate watcher "${o.expression}"`)}pe()}return function(){o.teardown()}}}(gr),function(e){const t=/^hook:/;e.prototype.$on=function(e,r){const n=this;if(Array.isArray(e))for(let t=0,o=e.length;t<o;t++)n.$on(e[t],r);else(n._events[e]||(n._events[e]=[])).push(r),t.test(e)&&(n._hasHookEvent=!0);return n},e.prototype.$once=function(e,t){const r=this;function n(){r.$off(e,n),t.apply(r,arguments)}return n.fn=t,r.$on(e,n),r},e.prototype.$off=function(e,t){const r=this;if(!arguments.length)return r._events=Object.create(null),r;if(Array.isArray(e)){for(let n=0,o=e.length;n<o;n++)r.$off(e[n],t);return r}const n=r._events[e];if(!n)return r;if(!t)return r._events[e]=null,r;let o,s=n.length;for(;s--;)if((o=n[s])===t||o.fn===t){n.splice(s,1);break}return r},e.prototype.$emit=function(e){const t=this;let r=t._events[e];if(r){r=r.length>1?$(r):r;const n=$(arguments,1),o=`event handler for "${e}"`;for(let e=0,s=r.length;e<s;e++)Ie(r[e],t,n,t,o)}return t}}(gr),function(e){e.prototype._update=function(e,t){const r=this,n=r.$el,o=r._vnode,s=Gt(r);r._vnode=e,r.$el=o?r.__patch__(o,e):r.__patch__(r.$el,e,t,!1),s(),n&&(n.__vue__=null),r.$el&&(r.$el.__vue__=r),r.$vnode&&r.$parent&&r.$vnode===r.$parent._vnode&&(r.$parent.$el=r.$el)},e.prototype.$forceUpdate=function(){const e=this;e._watcher&&e._watcher.update()},e.prototype.$destroy=function(){const e=this;if(e._isBeingDestroyed)return;Kt(e,"beforeDestroy"),e._isBeingDestroyed=!0;const t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();let r=e._watchers.length;for(;r--;)e._watchers[r].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Kt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}(gr),function(e){qt(e.prototype),e.prototype.$nextTick=function(e){return Ke(e,this)},e.prototype._render=function(){const e=this,{render:t,_parentVnode:r}=e.$options;let n;r&&(e.$scopedSlots=it(r.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=r;try{Ft=e,n=t.call(e._renderProxy,e.$createElement)}catch(t){Ve(t,e,"render"),n=e._vnode}finally{Ft=null}return Array.isArray(n)&&1===n.length&&(n=n[0]),n instanceof de||(n=fe()),n.parent=r,n}}(gr);const Dr=[String,RegExp,Array];var xr={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Dr,exclude:Dr,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const e in this.cache)Ar(this.cache,e,this.keys)},mounted(){this.$watch("include",e=>{wr(this,t=>vr(e,t))}),this.$watch("exclude",e=>{wr(this,t=>!vr(e,t))})},render(){const e=this.$slots.default,t=Vt(e),r=t&&t.componentOptions;if(r){const e=yr(r),{include:n,exclude:o}=this;if(n&&(!e||!vr(n,e))||o&&e&&vr(o,e))return t;const{cache:s,keys:a}=this,i=null==t.key?r.Ctor.cid+(r.tag?`::${r.tag}`:""):t.key;s[i]?(t.componentInstance=s[i].componentInstance,h(a,i),a.push(i)):(s[i]=t,a.push(i),this.max&&a.length>parseInt(this.max)&&Ar(s,a[0],a,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){const t={get:()=>B};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:k,mergeOptions:Te,defineReactive:xe},e.set=qe,e.delete=$e,e.nextTick=Ke,e.observable=(e=>(De(e),e)),e.options=Object.create(null),R.forEach(t=>{e.options[t+"s"]=Object.create(null)}),e.options._base=e,k(e.options.components,xr),function(e){e.use=function(e){const t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;const r=$(arguments,1);return r.unshift(this),"function"==typeof e.install?e.install.apply(e,r):"function"==typeof e&&e.apply(null,r),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Te(this.options,e),this}}(e),br(e),function(e){R.forEach(t=>{e[t]=function(e,r){return r?("component"===t&&i(r)&&(r.name=r.name||e,r=this.options._base.extend(r)),"directive"===t&&"function"==typeof r&&(r={bind:r,update:r}),this.options[t+"s"][e]=r,r):this.options[t+"s"][e]}})}(e)}(gr),Object.defineProperty(gr.prototype,"$isServer",{get:te}),Object.defineProperty(gr.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(gr,"FunctionalRenderContext",{value:$t}),gr.version="2.6.12";const qr=d("style,class"),$r=d("input,textarea,option,select,progress"),kr=(e,t,r)=>"value"===r&&$r(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e,Er=d("contenteditable,draggable,spellcheck"),_r=d("events,caret,typing,plaintext-only"),Cr=(e,t)=>Or(t)||"false"===t?"false":"contenteditable"===e&&_r(t)?t:"true",Sr=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Lr="http://www.w3.org/1999/xlink",Tr=e=>":"===e.charAt(5)&&"xlink"===e.slice(0,5),Nr=e=>Tr(e)?e.slice(6,e.length):"",Or=e=>null==e||!1===e;function Rr(e){let t=e.data,n=e,o=e;for(;r(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(t=Fr(o.data,t));for(;r(n=n.parent);)n&&n.data&&(t=Fr(t,n.data));return function(e,t){if(r(e)||r(t))return Br(e,Ur(t));return""}(t.staticClass,t.class)}function Fr(e,t){return{staticClass:Br(e.staticClass,t.staticClass),class:r(e.class)?[e.class,t.class]:t.class}}function Br(e,t){return e?t?e+" "+t:e:t||""}function Ur(e){return Array.isArray(e)?function(e){let t,n="";for(let o=0,s=e.length;o<s;o++)r(t=Ur(e[o]))&&""!==t&&(n&&(n+=" "),n+=t);return n}(e):s(e)?function(e){let t="";for(const r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}const Vr={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Ir=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),jr=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Pr=e=>Ir(e)||jr(e);function Hr(e){return jr(e)?"svg":"math"===e?"math":void 0}const Mr=Object.create(null);const Gr=d("text,number,password,search,email,tel,url");function zr(e){if("string"==typeof e){const t=document.querySelector(e);return t||document.createElement("div")}return e}var Jr=Object.freeze({createElement:function(e,t){const r=document.createElement(e);return"select"!==e?r:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&r.setAttribute("multiple","multiple"),r)},createElementNS:function(e,t){return document.createElementNS(Vr[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,r){e.insertBefore(t,r)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Kr={create(e,t){Zr(t)},update(e,t){e.data.ref!==t.data.ref&&(Zr(e,!0),Zr(t))},destroy(e){Zr(e,!0)}};function Zr(e,t){const n=e.data.ref;if(!r(n))return;const o=e.context,s=e.componentInstance||e.elm,a=o.$refs;t?Array.isArray(a[n])?h(a[n],s):a[n]===s&&(a[n]=void 0):e.data.refInFor?Array.isArray(a[n])?a[n].indexOf(s)<0&&a[n].push(s):a[n]=[s]:a[n]=s}const Yr=new de("",{},[]),Wr=["create","activate","update","remove","destroy"];function Qr(e,o){return e.key===o.key&&(e.tag===o.tag&&e.isComment===o.isComment&&r(e.data)===r(o.data)&&function(e,t){if("input"!==e.tag)return!0;let n;const o=r(n=e.data)&&r(n=n.attrs)&&n.type,s=r(n=t.data)&&r(n=n.attrs)&&n.type;return o===s||Gr(o)&&Gr(s)}(e,o)||n(e.isAsyncPlaceholder)&&e.asyncFactory===o.asyncFactory&&t(o.asyncFactory.error))}function Xr(e,t,n){let o,s;const a={};for(o=t;o<=n;++o)r(s=e[o].key)&&(a[s]=o);return a}var en={create:tn,update:tn,destroy:function(e){tn(e,Yr)}};function tn(e,t){(e.data.directives||t.data.directives)&&function(e,t){const r=e===Yr,n=t===Yr,o=nn(e.data.directives,e.context),s=nn(t.data.directives,t.context),a=[],i=[];let c,l,u;for(c in s)l=o[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,sn(u,"update",t,e),u.def&&u.def.componentUpdated&&i.push(u)):(sn(u,"bind",t,e),u.def&&u.def.inserted&&a.push(u));if(a.length){const n=()=>{for(let r=0;r<a.length;r++)sn(a[r],"inserted",t,e)};r?et(t,"insert",n):n()}i.length&&et(t,"postpatch",()=>{for(let r=0;r<i.length;r++)sn(i[r],"componentUpdated",t,e)});if(!r)for(c in o)s[c]||sn(o[c],"unbind",e,e,n)}(e,t)}const rn=Object.create(null);function nn(e,t){const r=Object.create(null);if(!e)return r;let n,o;for(n=0;n<e.length;n++)(o=e[n]).modifiers||(o.modifiers=rn),r[on(o)]=o,o.def=Ne(t.$options,"directives",o.name);return r}function on(e){return e.rawName||`${e.name}.${Object.keys(e.modifiers||{}).join(".")}`}function sn(e,t,r,n,o){const s=e.def&&e.def[t];if(s)try{s(r.elm,e,r,n,o)}catch(n){Ve(n,r.context,`directive ${e.name} ${t} hook`)}}var an=[Kr,en];function cn(e,n){const o=n.componentOptions;if(r(o)&&!1===o.Ctor.options.inheritAttrs)return;if(t(e.data.attrs)&&t(n.data.attrs))return;let s,a,i;const c=n.elm,l=e.data.attrs||{};let u=n.data.attrs||{};for(s in r(u.__ob__)&&(u=n.data.attrs=k({},u)),u)a=u[s],(i=l[s])!==a&&ln(c,s,a,n.data.pre);for(s in(J||Z)&&u.value!==l.value&&ln(c,"value",u.value),l)t(u[s])&&(Tr(s)?c.removeAttributeNS(Lr,Nr(s)):Er(s)||c.removeAttribute(s))}function ln(e,t,r,n){n||e.tagName.indexOf("-")>-1?un(e,t,r):Sr(t)?Or(r)?e.removeAttribute(t):(r="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,r)):Er(t)?e.setAttribute(t,Cr(t,r)):Tr(t)?Or(r)?e.removeAttributeNS(Lr,Nr(t)):e.setAttributeNS(Lr,t,r):un(e,t,r)}function un(e,t,r){if(Or(r))e.removeAttribute(t);else{if(J&&!K&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==r&&!e.__ieph){const t=r=>{r.stopImmediatePropagation(),e.removeEventListener("input",t)};e.addEventListener("input",t),e.__ieph=!0}e.setAttribute(t,r)}}var pn={create:cn,update:cn};function dn(e,n){const o=n.elm,s=n.data,a=e.data;if(t(s.staticClass)&&t(s.class)&&(t(a)||t(a.staticClass)&&t(a.class)))return;let i=Rr(n);const c=o._transitionClasses;r(c)&&(i=Br(i,Ur(c))),i!==o._prevClass&&(o.setAttribute("class",i),o._prevClass=i)}var fn={create:dn,update:dn};const mn=/[\w).+\-_$\]]/;function hn(e){let t,r,n,o,s,a=!1,i=!1,c=!1,l=!1,u=0,p=0,d=0,f=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(i)34===t&&92!==r&&(i=!1);else if(c)96===t&&92!==r&&(c=!1);else if(l)47===t&&92!==r&&(l=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||u||p||d){switch(t){case 34:i=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:p++;break;case 93:p--;break;case 123:u++;break;case 125:u--}if(47===t){let t,r=n-1;for(;r>=0&&" "===(t=e.charAt(r));r--);t&&mn.test(t)||(l=!0)}}else void 0===o?(f=n+1,o=e.slice(0,n).trim()):m();function m(){(s||(s=[])).push(e.slice(f,n).trim()),f=n+1}if(void 0===o?o=e.slice(0,n).trim():0!==f&&m(),s)for(n=0;n<s.length;n++)o=gn(o,s[n]);return o}function gn(e,t){const r=t.indexOf("(");if(r<0)return`_f("${t}")(${e})`;{const n=t.slice(0,r),o=t.slice(r+1);return`_f("${n}")(${e}${")"!==o?","+o:o}`}}function bn(e,t){console.error(`[Vue compiler]: ${e}`)}function yn(e,t){return e?e.map(e=>e[t]).filter(e=>e):[]}function vn(e,t,r,n,o){(e.props||(e.props=[])).push(_n({name:t,value:r,dynamic:o},n)),e.plain=!1}function wn(e,t,r,n,o){(o?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(_n({name:t,value:r,dynamic:o},n)),e.plain=!1}function An(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(_n({name:t,value:r},n))}function Dn(e,t,r,n,o,s,a,i){(e.directives||(e.directives=[])).push(_n({name:t,rawName:r,value:n,arg:o,isDynamicArg:s,modifiers:a},i)),e.plain=!1}function xn(e,t,r){return r?`_p(${t},"${e}")`:e+t}function qn(t,r,n,o,s,a,i,c){let l;(o=o||e).right?c?r=`(${r})==='click'?'contextmenu':(${r})`:"click"===r&&(r="contextmenu",delete o.right):o.middle&&(c?r=`(${r})==='click'?'mouseup':(${r})`:"click"===r&&(r="mouseup")),o.capture&&(delete o.capture,r=xn("!",r,c)),o.once&&(delete o.once,r=xn("~",r,c)),o.passive&&(delete o.passive,r=xn("&",r,c)),o.native?(delete o.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});const u=_n({value:n.trim(),dynamic:c},i);o!==e&&(u.modifiers=o);const p=l[r];Array.isArray(p)?s?p.unshift(u):p.push(u):l[r]=p?s?[u,p]:[p,u]:u,t.plain=!1}function $n(e,t,r){const n=kn(e,":"+t)||kn(e,"v-bind:"+t);if(null!=n)return hn(n);if(!1!==r){const r=kn(e,t);if(null!=r)return JSON.stringify(r)}}function kn(e,t,r){let n;if(null!=(n=e.attrsMap[t])){const r=e.attrsList;for(let e=0,n=r.length;e<n;e++)if(r[e].name===t){r.splice(e,1);break}}return r&&delete e.attrsMap[t],n}function En(e,t){const r=e.attrsList;for(let e=0,n=r.length;e<n;e++){const n=r[e];if(t.test(n.name))return r.splice(e,1),n}}function _n(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Cn(e,t,r){const{number:n,trim:o}=r||{};let s="$$v";o&&(s="(typeof $$v === 'string'? $$v.trim(): $$v)"),n&&(s=`_n(${s})`);const a=Sn(t,s);e.model={value:`(${t})`,expression:JSON.stringify(t),callback:`function ($$v) {${a}}`}}function Sn(e,t){const r=function(e){if(e=e.trim(),Ln=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Ln-1)return(On=e.lastIndexOf("."))>-1?{exp:e.slice(0,On),key:'"'+e.slice(On+1)+'"'}:{exp:e,key:null};Tn=e,On=Rn=Fn=0;for(;!Un();)Vn(Nn=Bn())?jn(Nn):91===Nn&&In(Nn);return{exp:e.slice(0,Rn),key:e.slice(Rn+1,Fn)}}(e);return null===r.key?`${e}=${t}`:`$set(${r.exp}, ${r.key}, ${t})`}let Ln,Tn,Nn,On,Rn,Fn;function Bn(){return Tn.charCodeAt(++On)}function Un(){return On>=Ln}function Vn(e){return 34===e||39===e}function In(e){let t=1;for(Rn=On;!Un();)if(Vn(e=Bn()))jn(e);else if(91===e&&t++,93===e&&t--,0===t){Fn=On;break}}function jn(e){const t=e;for(;!Un()&&(e=Bn())!==t;);}const Pn="__r",Hn="__c";let Mn;function Gn(e,t,r){const n=Mn;return function o(){null!==t.apply(null,arguments)&&Kn(e,o,r,n)}}const zn=He&&!(W&&Number(W[1])<=53);function Jn(e,t,r,n){if(zn){const e=tr,r=t;t=r._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=e||t.timeStamp<=0||t.target.ownerDocument!==document)return r.apply(this,arguments)}}Mn.addEventListener(e,t,ee?{capture:r,passive:n}:r)}function Kn(e,t,r,n){(n||Mn).removeEventListener(e,t._wrapper||t,r)}function Zn(e,n){if(t(e.data.on)&&t(n.data.on))return;const o=n.data.on||{},s=e.data.on||{};Mn=n.elm,function(e){if(r(e[Pn])){const t=J?"change":"input";e[t]=[].concat(e[Pn],e[t]||[]),delete e[Pn]}r(e[Hn])&&(e.change=[].concat(e[Hn],e.change||[]),delete e[Hn])}(o),Xe(o,s,Jn,Kn,Gn,n.context),Mn=void 0}var Yn={create:Zn,update:Zn};let Wn;function Qn(e,n){if(t(e.data.domProps)&&t(n.data.domProps))return;let o,s;const a=n.elm,i=e.data.domProps||{};let c=n.data.domProps||{};for(o in r(c.__ob__)&&(c=n.data.domProps=k({},c)),i)o in c||(a[o]="");for(o in c){if(s=c[o],"textContent"===o||"innerHTML"===o){if(n.children&&(n.children.length=0),s===i[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=s;const e=t(s)?"":String(s);Xn(a,e)&&(a.value=e)}else if("innerHTML"===o&&jr(a.tagName)&&t(a.innerHTML)){(Wn=Wn||document.createElement("div")).innerHTML=`<svg>${s}</svg>`;const e=Wn.firstChild;for(;a.firstChild;)a.removeChild(a.firstChild);for(;e.firstChild;)a.appendChild(e.firstChild)}else if(s!==i[o])try{a[o]=s}catch(e){}}}function Xn(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){let r=!0;try{r=document.activeElement!==e}catch(e){}return r&&e.value!==t}(e,t)||function(e,t){const n=e.value,o=e._vModifiers;if(r(o)){if(o.number)return p(n)!==p(t);if(o.trim)return n.trim()!==t.trim()}return n!==t}(e,t))}var eo={create:Qn,update:Qn};const to=y(function(e){const t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){const n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function ro(e){const t=no(e.style);return e.staticStyle?k(e.staticStyle,t):t}function no(e){return Array.isArray(e)?E(e):"string"==typeof e?to(e):e}const oo=/^--/,so=/\s*!important$/,ao=(e,t,r)=>{if(oo.test(t))e.style.setProperty(t,r);else if(so.test(r))e.style.setProperty(x(t),r.replace(so,""),"important");else{const n=lo(t);if(Array.isArray(r))for(let t=0,o=r.length;t<o;t++)e.style[n]=r[t];else e.style[n]=r}},io=["Webkit","Moz","ms"];let co;const lo=y(function(e){if(co=co||document.createElement("div").style,"filter"!==(e=w(e))&&e in co)return e;const t=e.charAt(0).toUpperCase()+e.slice(1);for(let e=0;e<io.length;e++){const r=io[e]+t;if(r in co)return r}});function uo(e,n){const o=n.data,s=e.data;if(t(o.staticStyle)&&t(o.style)&&t(s.staticStyle)&&t(s.style))return;let a,i;const c=n.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},p=l||u,d=no(n.data.style)||{};n.data.normalizedStyle=r(d.__ob__)?k({},d):d;const f=function(e,t){const r={};let n;if(t){let t=e;for(;t.componentInstance;)(t=t.componentInstance._vnode)&&t.data&&(n=ro(t.data))&&k(r,n)}(n=ro(e.data))&&k(r,n);let o=e;for(;o=o.parent;)o.data&&(n=ro(o.data))&&k(r,n);return r}(n,!0);for(i in p)t(f[i])&&ao(c,i,"");for(i in f)(a=f[i])!==p[i]&&ao(c,i,null==a?"":a)}var po={create:uo,update:uo};const fo=/\s+/;function mo(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(fo).forEach(t=>e.classList.add(t)):e.classList.add(t);else{const r=` ${e.getAttribute("class")||""} `;r.indexOf(" "+t+" ")<0&&e.setAttribute("class",(r+t).trim())}}function ho(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(fo).forEach(t=>e.classList.remove(t)):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{let r=` ${e.getAttribute("class")||""} `;const n=" "+t+" ";for(;r.indexOf(n)>=0;)r=r.replace(n," ");(r=r.trim())?e.setAttribute("class",r):e.removeAttribute("class")}}function go(e){if(e){if("object"==typeof e){const t={};return!1!==e.css&&k(t,bo(e.name||"v")),k(t,e),t}return"string"==typeof e?bo(e):void 0}}const bo=y(e=>({enterClass:`${e}-enter`,enterToClass:`${e}-enter-to`,enterActiveClass:`${e}-enter-active`,leaveClass:`${e}-leave`,leaveToClass:`${e}-leave-to`,leaveActiveClass:`${e}-leave-active`})),yo=H&&!K,vo="transition",wo="animation";let Ao="transition",Do="transitionend",xo="animation",qo="animationend";yo&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ao="WebkitTransition",Do="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(xo="WebkitAnimation",qo="webkitAnimationEnd"));const $o=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:e=>e();function ko(e){$o(()=>{$o(e)})}function Eo(e,t){const r=e._transitionClasses||(e._transitionClasses=[]);r.indexOf(t)<0&&(r.push(t),mo(e,t))}function _o(e,t){e._transitionClasses&&h(e._transitionClasses,t),ho(e,t)}function Co(e,t,r){const{type:n,timeout:o,propCount:s}=Lo(e,t);if(!n)return r();const a=n===vo?Do:qo;let i=0;const c=()=>{e.removeEventListener(a,l),r()},l=t=>{t.target===e&&++i>=s&&c()};setTimeout(()=>{i<s&&c()},o+1),e.addEventListener(a,l)}const So=/\b(transform|all)(,|$)/;function Lo(e,t){const r=window.getComputedStyle(e),n=(r[Ao+"Delay"]||"").split(", "),o=(r[Ao+"Duration"]||"").split(", "),s=To(n,o),a=(r[xo+"Delay"]||"").split(", "),i=(r[xo+"Duration"]||"").split(", "),c=To(a,i);let l,u=0,p=0;return t===vo?s>0&&(l=vo,u=s,p=o.length):t===wo?c>0&&(l=wo,u=c,p=i.length):p=(l=(u=Math.max(s,c))>0?s>c?vo:wo:null)?l===vo?o.length:i.length:0,{type:l,timeout:u,propCount:p,hasTransform:l===vo&&So.test(r[Ao+"Property"])}}function To(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((t,r)=>No(t)+No(e[r])))}function No(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Oo(e,n){const o=e.elm;r(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());const a=go(e.data.transition);if(t(a))return;if(r(o._enterCb)||1!==o.nodeType)return;const{css:i,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:f,appearToClass:m,appearActiveClass:h,beforeEnter:g,enter:b,afterEnter:y,enterCancelled:v,beforeAppear:w,appear:A,afterAppear:D,appearCancelled:x,duration:q}=a;let $=Mt,k=Mt.$vnode;for(;k&&k.parent;)$=k.context,k=k.parent;const E=!$._isMounted||!e.isRootInsert;if(E&&!A&&""!==A)return;const _=E&&f?f:l,C=E&&h?h:d,S=E&&m?m:u,L=E&&w||g,T=E&&"function"==typeof A?A:b,O=E&&D||y,R=E&&x||v,F=p(s(q)?q.enter:q),B=!1!==i&&!K,U=Bo(T),V=o._enterCb=N(()=>{B&&(_o(o,S),_o(o,C)),V.cancelled?(B&&_o(o,_),R&&R(o)):O&&O(o),o._enterCb=null});e.data.show||et(e,"insert",()=>{const t=o.parentNode,r=t&&t._pending&&t._pending[e.key];r&&r.tag===e.tag&&r.elm._leaveCb&&r.elm._leaveCb(),T&&T(o,V)}),L&&L(o),B&&(Eo(o,_),Eo(o,C),ko(()=>{_o(o,_),V.cancelled||(Eo(o,S),U||(Fo(F)?setTimeout(V,F):Co(o,c,V)))})),e.data.show&&(n&&n(),T&&T(o,V)),B||U||V()}function Ro(e,n){const o=e.elm;r(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());const a=go(e.data.transition);if(t(a)||1!==o.nodeType)return n();if(r(o._leaveCb))return;const{css:i,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:f,leave:m,afterLeave:h,leaveCancelled:g,delayLeave:b,duration:y}=a,v=!1!==i&&!K,w=Bo(m),A=p(s(y)?y.leave:y),D=o._leaveCb=N(()=>{o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[e.key]=null),v&&(_o(o,u),_o(o,d)),D.cancelled?(v&&_o(o,l),g&&g(o)):(n(),h&&h(o)),o._leaveCb=null});function x(){D.cancelled||(!e.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[e.key]=e),f&&f(o),v&&(Eo(o,l),Eo(o,d),ko(()=>{_o(o,l),D.cancelled||(Eo(o,u),w||(Fo(A)?setTimeout(D,A):Co(o,c,D)))})),m&&m(o,D),v||w||D())}b?b(x):x()}function Fo(e){return"number"==typeof e&&!isNaN(e)}function Bo(e){if(t(e))return!1;const n=e.fns;return r(n)?Bo(Array.isArray(n)?n[0]:n):(e._length||e.length)>1}function Uo(e,t){!0!==t.data.show&&Oo(t)}const Vo=function(e){let s,a;const i={},{modules:c,nodeOps:l}=e;for(s=0;s<Wr.length;++s)for(i[Wr[s]]=[],a=0;a<c.length;++a)r(c[a][Wr[s]])&&i[Wr[s]].push(c[a][Wr[s]]);function u(e){const t=l.parentNode(e);r(t)&&l.removeChild(t,e)}function p(e,t,o,s,a,c,u){if(r(e.elm)&&r(c)&&(e=c[u]=he(e)),e.isRootInsert=!a,function(e,t,o,s){let a=e.data;if(r(a)){const c=r(e.componentInstance)&&a.keepAlive;if(r(a=a.hook)&&r(a=a.init)&&a(e,!1),r(e.componentInstance))return f(e,t),m(o,e.elm,s),n(c)&&function(e,t,n,o){let s,a=e;for(;a.componentInstance;)if(a=a.componentInstance._vnode,r(s=a.data)&&r(s=s.transition)){for(s=0;s<i.activate.length;++s)i.activate[s](Yr,a);t.push(a);break}m(n,e.elm,o)}(e,t,o,s),!0}}(e,t,o,s))return;const p=e.data,d=e.children,g=e.tag;r(g)?(e.elm=e.ns?l.createElementNS(e.ns,g):l.createElement(g,e),y(e),h(e,d,t),r(p)&&b(e,t),m(o,e.elm,s)):n(e.isComment)?(e.elm=l.createComment(e.text),m(o,e.elm,s)):(e.elm=l.createTextNode(e.text),m(o,e.elm,s))}function f(e,t){r(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,g(e)?(b(e,t),y(e)):(Zr(e),t.push(e))}function m(e,t,n){r(e)&&(r(n)?l.parentNode(n)===e&&l.insertBefore(e,t,n):l.appendChild(e,t))}function h(e,t,r){if(Array.isArray(t))for(let n=0;n<t.length;++n)p(t[n],r,e.elm,null,!0,t,n);else o(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function g(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return r(e.tag)}function b(e,t){for(let t=0;t<i.create.length;++t)i.create[t](Yr,e);r(s=e.data.hook)&&(r(s.create)&&s.create(Yr,e),r(s.insert)&&t.push(e))}function y(e){let t;if(r(t=e.fnScopeId))l.setStyleScope(e.elm,t);else{let n=e;for(;n;)r(t=n.context)&&r(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),n=n.parent}r(t=Mt)&&t!==e.context&&t!==e.fnContext&&r(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function v(e,t,r,n,o,s){for(;n<=o;++n)p(r[n],s,e,t,!1,r,n)}function w(e){let t,n;const o=e.data;if(r(o))for(r(t=o.hook)&&r(t=t.destroy)&&t(e),t=0;t<i.destroy.length;++t)i.destroy[t](e);if(r(t=e.children))for(n=0;n<e.children.length;++n)w(e.children[n])}function A(e,t,n){for(;t<=n;++t){const n=e[t];r(n)&&(r(n.tag)?(D(n),w(n)):u(n.elm))}}function D(e,t){if(r(t)||r(e.data)){let n;const o=i.remove.length+1;for(r(t)?t.listeners+=o:t=function(e,t){function r(){0==--r.listeners&&u(e)}return r.listeners=t,r}(e.elm,o),r(n=e.componentInstance)&&r(n=n._vnode)&&r(n.data)&&D(n,t),n=0;n<i.remove.length;++n)i.remove[n](e,t);r(n=e.data.hook)&&r(n=n.remove)?n(e,t):t()}else u(e.elm)}function x(e,t,n,o){for(let s=n;s<o;s++){const n=t[s];if(r(n)&&Qr(e,n))return s}}function q(e,o,s,a,c,u){if(e===o)return;r(o.elm)&&r(a)&&(o=a[c]=he(o));const d=o.elm=e.elm;if(n(e.isAsyncPlaceholder))return void(r(o.asyncFactory.resolved)?E(e.elm,o,s):o.isAsyncPlaceholder=!0);if(n(o.isStatic)&&n(e.isStatic)&&o.key===e.key&&(n(o.isCloned)||n(o.isOnce)))return void(o.componentInstance=e.componentInstance);let f;const m=o.data;r(m)&&r(f=m.hook)&&r(f=f.prepatch)&&f(e,o);const h=e.children,b=o.children;if(r(m)&&g(o)){for(f=0;f<i.update.length;++f)i.update[f](e,o);r(f=m.hook)&&r(f=f.update)&&f(e,o)}t(o.text)?r(h)&&r(b)?h!==b&&function(e,n,o,s,a){let i,c,u,d,f=0,m=0,h=n.length-1,g=n[0],b=n[h],y=o.length-1,w=o[0],D=o[y];const $=!a;for(;f<=h&&m<=y;)t(g)?g=n[++f]:t(b)?b=n[--h]:Qr(g,w)?(q(g,w,s,o,m),g=n[++f],w=o[++m]):Qr(b,D)?(q(b,D,s,o,y),b=n[--h],D=o[--y]):Qr(g,D)?(q(g,D,s,o,y),$&&l.insertBefore(e,g.elm,l.nextSibling(b.elm)),g=n[++f],D=o[--y]):Qr(b,w)?(q(b,w,s,o,m),$&&l.insertBefore(e,b.elm,g.elm),b=n[--h],w=o[++m]):(t(i)&&(i=Xr(n,f,h)),t(c=r(w.key)?i[w.key]:x(w,n,f,h))?p(w,s,e,g.elm,!1,o,m):Qr(u=n[c],w)?(q(u,w,s,o,m),n[c]=void 0,$&&l.insertBefore(e,u.elm,g.elm)):p(w,s,e,g.elm,!1,o,m),w=o[++m]);f>h?v(e,d=t(o[y+1])?null:o[y+1].elm,o,m,y,s):m>y&&A(n,f,h)}(d,h,b,s,u):r(b)?(r(e.text)&&l.setTextContent(d,""),v(d,null,b,0,b.length-1,s)):r(h)?A(h,0,h.length-1):r(e.text)&&l.setTextContent(d,""):e.text!==o.text&&l.setTextContent(d,o.text),r(m)&&r(f=m.hook)&&r(f=f.postpatch)&&f(e,o)}function $(e,t,o){if(n(o)&&r(e.parent))e.parent.data.pendingInsert=t;else for(let e=0;e<t.length;++e)t[e].data.hook.insert(t[e])}const k=d("attrs,class,staticClass,staticStyle,key");function E(e,t,o,s){let a;const{tag:i,data:c,children:l}=t;if(s=s||c&&c.pre,t.elm=e,n(t.isComment)&&r(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(r(c)&&(r(a=c.hook)&&r(a=a.init)&&a(t,!0),r(a=t.componentInstance)))return f(t,o),!0;if(r(i)){if(r(l))if(e.hasChildNodes())if(r(a=c)&&r(a=a.domProps)&&r(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{let t=!0,r=e.firstChild;for(let e=0;e<l.length;e++){if(!r||!E(r,l[e],o,s)){t=!1;break}r=r.nextSibling}if(!t||r)return!1}else h(t,l,o);if(r(c)){let e=!1;for(const r in c)if(!k(r)){e=!0,b(t,o);break}!e&&c.class&&Ye(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,o,s,a){if(t(o))return void(r(e)&&w(e));let c=!1;const u=[];if(t(e))c=!0,p(o,u);else{const t=r(e.nodeType);if(!t&&Qr(e,o))q(e,o,u,null,null,a);else{if(t){if(1===e.nodeType&&e.hasAttribute(O)&&(e.removeAttribute(O),s=!0),n(s)&&E(e,o,u))return $(o,u,!0),e;d=e,e=new de(l.tagName(d).toLowerCase(),{},[],void 0,d)}const a=e.elm,c=l.parentNode(a);if(p(o,u,a._leaveCb?null:c,l.nextSibling(a)),r(o.parent)){let e=o.parent;const t=g(o);for(;e;){for(let t=0;t<i.destroy.length;++t)i.destroy[t](e);if(e.elm=o.elm,t){for(let t=0;t<i.create.length;++t)i.create[t](Yr,e);const t=e.data.hook.insert;if(t.merged)for(let e=1;e<t.fns.length;e++)t.fns[e]()}else Zr(e);e=e.parent}}r(c)?A([e],0,0):r(e.tag)&&w(e)}}var d;return $(o,u,c),o.elm}}({nodeOps:Jr,modules:[pn,fn,Yn,eo,po,H?{create:Uo,activate:Uo,remove(e,t){!0!==e.data.show?Ro(e,t):t()}}:{}].concat(an)});K&&document.addEventListener("selectionchange",()=>{const e=document.activeElement;e&&e.vmodel&&Jo(e,"input")});const Io={inserted(e,t,r,n){"select"===r.tag?(n.elm&&!n.elm._vOptions?et(r,"postpatch",()=>{Io.componentUpdated(e,t,r)}):jo(e,t,r.context),e._vOptions=[].map.call(e.options,Mo)):("textarea"===r.tag||Gr(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Go),e.addEventListener("compositionend",zo),e.addEventListener("change",zo),K&&(e.vmodel=!0)))},componentUpdated(e,t,r){if("select"===r.tag){jo(e,t,r.context);const n=e._vOptions,o=e._vOptions=[].map.call(e.options,Mo);if(o.some((e,t)=>!L(e,n[t]))){(e.multiple?t.value.some(e=>Ho(e,o)):t.value!==t.oldValue&&Ho(t.value,o))&&Jo(e,"change")}}}};function jo(e,t,r){Po(e,t,r),(J||Z)&&setTimeout(()=>{Po(e,t,r)},0)}function Po(e,t,r){const n=t.value,o=e.multiple;if(o&&!Array.isArray(n))return;let s,a;for(let t=0,r=e.options.length;t<r;t++)if(a=e.options[t],o)s=T(n,Mo(a))>-1,a.selected!==s&&(a.selected=s);else if(L(Mo(a),n))return void(e.selectedIndex!==t&&(e.selectedIndex=t));o||(e.selectedIndex=-1)}function Ho(e,t){return t.every(t=>!L(t,e))}function Mo(e){return"_value"in e?e._value:e.value}function Go(e){e.target.composing=!0}function zo(e){e.target.composing&&(e.target.composing=!1,Jo(e.target,"input"))}function Jo(e,t){const r=document.createEvent("HTMLEvents");r.initEvent(t,!0,!0),e.dispatchEvent(r)}function Ko(e){return!e.componentInstance||e.data&&e.data.transition?e:Ko(e.componentInstance._vnode)}var Zo={model:Io,show:{bind(e,{value:t},r){const n=(r=Ko(r)).data&&r.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;t&&n?(r.data.show=!0,Oo(r,()=>{e.style.display=o})):e.style.display=t?o:"none"},update(e,{value:t,oldValue:r},n){if(!t==!r)return;(n=Ko(n)).data&&n.data.transition?(n.data.show=!0,t?Oo(n,()=>{e.style.display=e.__vOriginalDisplay}):Ro(n,()=>{e.style.display="none"})):e.style.display=t?e.__vOriginalDisplay:"none"},unbind(e,t,r,n,o){o||(e.style.display=e.__vOriginalDisplay)}}};const Yo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Wo(e){const t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?Wo(Vt(t.children)):e}function Qo(e){const t={},r=e.$options;for(const n in r.propsData)t[n]=e[n];const n=r._parentListeners;for(const e in n)t[w(e)]=n[e];return t}function Xo(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}const es=e=>e.tag||Ut(e),ts=e=>"show"===e.name;var rs={name:"transition",props:Yo,abstract:!0,render(e){let t=this.$slots.default;if(!t)return;if(!(t=t.filter(es)).length)return;const r=this.mode,n=t[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return n;const s=Wo(n);if(!s)return n;if(this._leaving)return Xo(e,n);const a=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?a+"comment":a+s.tag:o(s.key)?0===String(s.key).indexOf(a)?s.key:a+s.key:s.key;const i=(s.data||(s.data={})).transition=Qo(this),c=this._vnode,l=Wo(c);if(s.data.directives&&s.data.directives.some(ts)&&(s.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(s,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const t=l.data.transition=k({},i);if("out-in"===r)return this._leaving=!0,et(t,"afterLeave",()=>{this._leaving=!1,this.$forceUpdate()}),Xo(e,n);if("in-out"===r){if(Ut(s))return c;let e;const r=()=>{e()};et(i,"afterEnter",r),et(i,"enterCancelled",r),et(t,"delayLeave",t=>{e=t})}}return n}};const ns=k({tag:String,moveClass:String},Yo);function os(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function ss(e){e.data.newPos=e.elm.getBoundingClientRect()}function as(e){const t=e.data.pos,r=e.data.newPos,n=t.left-r.left,o=t.top-r.top;if(n||o){e.data.moved=!0;const t=e.elm.style;t.transform=t.WebkitTransform=`translate(${n}px,${o}px)`,t.transitionDuration="0s"}}delete ns.mode;var is={Transition:rs,TransitionGroup:{props:ns,beforeMount(){const e=this._update;this._update=((t,r)=>{const n=Gt(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,n(),e.call(this,t,r)})},render(e){const t=this.tag||this.$vnode.data.tag||"span",r=Object.create(null),n=this.prevChildren=this.children,o=this.$slots.default||[],s=this.children=[],a=Qo(this);for(let e=0;e<o.length;e++){const t=o[e];t.tag&&null!=t.key&&0!==String(t.key).indexOf("__vlist")&&(s.push(t),r[t.key]=t,(t.data||(t.data={})).transition=a)}if(n){const o=[],s=[];for(let e=0;e<n.length;e++){const t=n[e];t.data.transition=a,t.data.pos=t.elm.getBoundingClientRect(),r[t.key]?o.push(t):s.push(t)}this.kept=e(t,null,o),this.removed=s}return e(t,null,s)},updated(){const e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(os),e.forEach(ss),e.forEach(as),this._reflow=document.body.offsetHeight,e.forEach(e=>{if(e.data.moved){const r=e.elm,n=r.style;Eo(r,t),n.transform=n.WebkitTransform=n.transitionDuration="",r.addEventListener(Do,r._moveCb=function e(n){n&&n.target!==r||n&&!/transform$/.test(n.propertyName)||(r.removeEventListener(Do,e),r._moveCb=null,_o(r,t))})}}))},methods:{hasMove(e,t){if(!yo)return!1;if(this._hasMove)return this._hasMove;const r=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(e=>{ho(r,e)}),mo(r,t),r.style.display="none",this.$el.appendChild(r);const n=Lo(r);return this.$el.removeChild(r),this._hasMove=n.hasTransform}}}};gr.config.mustUseProp=kr,gr.config.isReservedTag=Pr,gr.config.isReservedAttr=qr,gr.config.getTagNamespace=Hr,gr.config.isUnknownElement=function(e){if(!H)return!0;if(Pr(e))return!1;if(e=e.toLowerCase(),null!=Mr[e])return Mr[e];const t=document.createElement(e);return e.indexOf("-")>-1?Mr[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Mr[e]=/HTMLUnknownElement/.test(t.toString())},k(gr.options.directives,Zo),k(gr.options.components,is),gr.prototype.__patch__=H?Vo:_,gr.prototype.$mount=function(e,t){return function(e,t,r){let n;return e.$el=t,e.$options.render||(e.$options.render=fe),Kt(e,"beforeMount"),n=(()=>{e._update(e._render(),r)}),new sr(e,n,_,{before(){e._isMounted&&!e._isDestroyed&&Kt(e,"beforeUpdate")}},!0),r=!1,null==e.$vnode&&(e._isMounted=!0,Kt(e,"mounted")),e}(this,e=e&&H?zr(e):void 0,t)},H&&setTimeout(()=>{B.devtools&&re&&re.emit("init",gr)},0);const cs=/\{\{((?:.|\r?\n)+?)\}\}/g,ls=/[-.*+?^${}()|[\]\/\\]/g,us=y(e=>{const t=e[0].replace(ls,"\\$&"),r=e[1].replace(ls,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});var ps={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;const r=kn(e,"class");r&&(e.staticClass=JSON.stringify(r));const n=$n(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){let t="";return e.staticClass&&(t+=`staticClass:${e.staticClass},`),e.classBinding&&(t+=`class:${e.classBinding},`),t}};var ds={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;const r=kn(e,"style");r&&(e.staticStyle=JSON.stringify(to(r)));const n=$n(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){let t="";return e.staticStyle&&(t+=`staticStyle:${e.staticStyle},`),e.styleBinding&&(t+=`style:(${e.styleBinding}),`),t}};!function(e){var t="object"==typeof exports&&exports,r="object"==typeof module&&module&&module.exports==t&&module,n="object"==typeof global&&global;n.global!==n&&n.window!==n||(e=n);var o=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,s=/[\x01-\x7F]/g,a=/[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,i=/<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g,c={"\xad":"shy","\u200c":"zwnj","\u200d":"zwj","\u200e":"lrm","\u2063":"ic","\u2062":"it","\u2061":"af","\u200f":"rlm","\u200b":"ZeroWidthSpace","\u2060":"NoBreak","\u0311":"DownBreve","\u20db":"tdot","\u20dc":"DotDot","\t":"Tab","\n":"NewLine","\u2008":"puncsp","\u205f":"MediumSpace","\u2009":"thinsp","\u200a":"hairsp","\u2004":"emsp13","\u2002":"ensp","\u2005":"emsp14","\u2003":"emsp","\u2007":"numsp","\xa0":"nbsp","\u205f\u200a":"ThickSpace","\u203e":"oline",_:"lowbar","\u2010":"dash","\u2013":"ndash","\u2014":"mdash","\u2015":"horbar",",":"comma",";":"semi","\u204f":"bsemi",":":"colon","\u2a74":"Colone","!":"excl","\xa1":"iexcl","?":"quest","\xbf":"iquest",".":"period","\u2025":"nldr","\u2026":"mldr","\xb7":"middot","'":"apos","\u2018":"lsquo","\u2019":"rsquo","\u201a":"sbquo","\u2039":"lsaquo","\u203a":"rsaquo",'"':"quot","\u201c":"ldquo","\u201d":"rdquo","\u201e":"bdquo","\xab":"laquo","\xbb":"raquo","(":"lpar",")":"rpar","[":"lsqb","]":"rsqb","{":"lcub","}":"rcub","\u2308":"lceil","\u2309":"rceil","\u230a":"lfloor","\u230b":"rfloor","\u2985":"lopar","\u2986":"ropar","\u298b":"lbrke","\u298c":"rbrke","\u298d":"lbrkslu","\u298e":"rbrksld","\u298f":"lbrksld","\u2990":"rbrkslu","\u2991":"langd","\u2992":"rangd","\u2993":"lparlt","\u2994":"rpargt","\u2995":"gtlPar","\u2996":"ltrPar","\u27e6":"lobrk","\u27e7":"robrk","\u27e8":"lang","\u27e9":"rang","\u27ea":"Lang","\u27eb":"Rang","\u27ec":"loang","\u27ed":"roang","\u2772":"lbbrk","\u2773":"rbbrk","\u2016":"Vert","\xa7":"sect","\xb6":"para","@":"commat","*":"ast","/":"sol",undefined:null,"&":"amp","#":"num","%":"percnt","\u2030":"permil","\u2031":"pertenk","\u2020":"dagger","\u2021":"Dagger","\u2022":"bull","\u2043":"hybull","\u2032":"prime","\u2033":"Prime","\u2034":"tprime","\u2057":"qprime","\u2035":"bprime","\u2041":"caret","`":"grave","\xb4":"acute","\u02dc":"tilde","^":"Hat","\xaf":"macr","\u02d8":"breve","\u02d9":"dot","\xa8":"die","\u02da":"ring","\u02dd":"dblac","\xb8":"cedil","\u02db":"ogon","\u02c6":"circ","\u02c7":"caron","\xb0":"deg","\xa9":"copy","\xae":"reg","\u2117":"copysr","\u2118":"wp","\u211e":"rx","\u2127":"mho","\u2129":"iiota","\u2190":"larr","\u219a":"nlarr","\u2192":"rarr","\u219b":"nrarr","\u2191":"uarr","\u2193":"darr","\u2194":"harr","\u21ae":"nharr","\u2195":"varr","\u2196":"nwarr","\u2197":"nearr","\u2198":"searr","\u2199":"swarr","\u219d":"rarrw","\u219d\u0338":"nrarrw","\u219e":"Larr","\u219f":"Uarr","\u21a0":"Rarr","\u21a1":"Darr","\u21a2":"larrtl","\u21a3":"rarrtl","\u21a4":"mapstoleft","\u21a5":"mapstoup","\u21a6":"map","\u21a7":"mapstodown","\u21a9":"larrhk","\u21aa":"rarrhk","\u21ab":"larrlp","\u21ac":"rarrlp","\u21ad":"harrw","\u21b0":"lsh","\u21b1":"rsh","\u21b2":"ldsh","\u21b3":"rdsh","\u21b5":"crarr","\u21b6":"cularr","\u21b7":"curarr","\u21ba":"olarr","\u21bb":"orarr","\u21bc":"lharu","\u21bd":"lhard","\u21be":"uharr","\u21bf":"uharl","\u21c0":"rharu","\u21c1":"rhard","\u21c2":"dharr","\u21c3":"dharl","\u21c4":"rlarr","\u21c5":"udarr","\u21c6":"lrarr","\u21c7":"llarr","\u21c8":"uuarr","\u21c9":"rrarr","\u21ca":"ddarr","\u21cb":"lrhar","\u21cc":"rlhar","\u21d0":"lArr","\u21cd":"nlArr","\u21d1":"uArr","\u21d2":"rArr","\u21cf":"nrArr","\u21d3":"dArr","\u21d4":"iff","\u21ce":"nhArr","\u21d5":"vArr","\u21d6":"nwArr","\u21d7":"neArr","\u21d8":"seArr","\u21d9":"swArr","\u21da":"lAarr","\u21db":"rAarr","\u21dd":"zigrarr","\u21e4":"larrb","\u21e5":"rarrb","\u21f5":"duarr","\u21fd":"loarr","\u21fe":"roarr","\u21ff":"hoarr","\u2200":"forall","\u2201":"comp","\u2202":"part","\u2202\u0338":"npart","\u2203":"exist","\u2204":"nexist","\u2205":"empty","\u2207":"Del","\u2208":"in","\u2209":"notin","\u220b":"ni","\u220c":"notni","\u03f6":"bepsi","\u220f":"prod","\u2210":"coprod","\u2211":"sum","+":"plus","\xb1":"pm","\xf7":"div","\xd7":"times","<":"lt","\u226e":"nlt","<\u20d2":"nvlt","=":"equals","\u2260":"ne","=\u20e5":"bne","\u2a75":"Equal",">":"gt","\u226f":"ngt",">\u20d2":"nvgt","\xac":"not","|":"vert","\xa6":"brvbar","\u2212":"minus","\u2213":"mp","\u2214":"plusdo","\u2044":"frasl","\u2216":"setmn","\u2217":"lowast","\u2218":"compfn","\u221a":"Sqrt","\u221d":"prop","\u221e":"infin","\u221f":"angrt","\u2220":"ang","\u2220\u20d2":"nang","\u2221":"angmsd","\u2222":"angsph","\u2223":"mid","\u2224":"nmid","\u2225":"par","\u2226":"npar","\u2227":"and","\u2228":"or","\u2229":"cap","\u2229\ufe00":"caps","\u222a":"cup","\u222a\ufe00":"cups","\u222b":"int","\u222c":"Int","\u222d":"tint","\u2a0c":"qint","\u222e":"oint","\u222f":"Conint","\u2230":"Cconint","\u2231":"cwint","\u2232":"cwconint","\u2233":"awconint","\u2234":"there4","\u2235":"becaus","\u2236":"ratio","\u2237":"Colon","\u2238":"minusd","\u223a":"mDDot","\u223b":"homtht","\u223c":"sim","\u2241":"nsim","\u223c\u20d2":"nvsim","\u223d":"bsim","\u223d\u0331":"race","\u223e":"ac","\u223e\u0333":"acE","\u223f":"acd","\u2240":"wr","\u2242":"esim","\u2242\u0338":"nesim","\u2243":"sime","\u2244":"nsime","\u2245":"cong","\u2247":"ncong","\u2246":"simne","\u2248":"ap","\u2249":"nap","\u224a":"ape","\u224b":"apid","\u224b\u0338":"napid","\u224c":"bcong","\u224d":"CupCap","\u226d":"NotCupCap","\u224d\u20d2":"nvap","\u224e":"bump","\u224e\u0338":"nbump","\u224f":"bumpe","\u224f\u0338":"nbumpe","\u2250":"doteq","\u2250\u0338":"nedot","\u2251":"eDot","\u2252":"efDot","\u2253":"erDot","\u2254":"colone","\u2255":"ecolon","\u2256":"ecir","\u2257":"cire","\u2259":"wedgeq","\u225a":"veeeq","\u225c":"trie","\u225f":"equest","\u2261":"equiv","\u2262":"nequiv","\u2261\u20e5":"bnequiv","\u2264":"le","\u2270":"nle","\u2264\u20d2":"nvle","\u2265":"ge","\u2271":"nge","\u2265\u20d2":"nvge","\u2266":"lE","\u2266\u0338":"nlE","\u2267":"gE","\u2267\u0338":"ngE","\u2268\ufe00":"lvnE","\u2268":"lnE","\u2269":"gnE","\u2269\ufe00":"gvnE","\u226a":"ll","\u226a\u0338":"nLtv","\u226a\u20d2":"nLt","\u226b":"gg","\u226b\u0338":"nGtv","\u226b\u20d2":"nGt","\u226c":"twixt","\u2272":"lsim","\u2274":"nlsim","\u2273":"gsim","\u2275":"ngsim","\u2276":"lg","\u2278":"ntlg","\u2277":"gl","\u2279":"ntgl","\u227a":"pr","\u2280":"npr","\u227b":"sc","\u2281":"nsc","\u227c":"prcue","\u22e0":"nprcue","\u227d":"sccue","\u22e1":"nsccue","\u227e":"prsim","\u227f":"scsim","\u227f\u0338":"NotSucceedsTilde","\u2282":"sub","\u2284":"nsub","\u2282\u20d2":"vnsub","\u2283":"sup","\u2285":"nsup","\u2283\u20d2":"vnsup","\u2286":"sube","\u2288":"nsube","\u2287":"supe","\u2289":"nsupe","\u228a\ufe00":"vsubne","\u228a":"subne","\u228b\ufe00":"vsupne","\u228b":"supne","\u228d":"cupdot","\u228e":"uplus","\u228f":"sqsub","\u228f\u0338":"NotSquareSubset","\u2290":"sqsup","\u2290\u0338":"NotSquareSuperset","\u2291":"sqsube","\u22e2":"nsqsube","\u2292":"sqsupe","\u22e3":"nsqsupe","\u2293":"sqcap","\u2293\ufe00":"sqcaps","\u2294":"sqcup","\u2294\ufe00":"sqcups","\u2295":"oplus","\u2296":"ominus","\u2297":"otimes","\u2298":"osol","\u2299":"odot","\u229a":"ocir","\u229b":"oast","\u229d":"odash","\u229e":"plusb","\u229f":"minusb","\u22a0":"timesb","\u22a1":"sdotb","\u22a2":"vdash","\u22ac":"nvdash","\u22a3":"dashv","\u22a4":"top","\u22a5":"bot","\u22a7":"models","\u22a8":"vDash","\u22ad":"nvDash","\u22a9":"Vdash","\u22ae":"nVdash","\u22aa":"Vvdash","\u22ab":"VDash","\u22af":"nVDash","\u22b0":"prurel","\u22b2":"vltri","\u22ea":"nltri","\u22b3":"vrtri","\u22eb":"nrtri","\u22b4":"ltrie","\u22ec":"nltrie","\u22b4\u20d2":"nvltrie","\u22b5":"rtrie","\u22ed":"nrtrie","\u22b5\u20d2":"nvrtrie","\u22b6":"origof","\u22b7":"imof","\u22b8":"mumap","\u22b9":"hercon","\u22ba":"intcal","\u22bb":"veebar","\u22bd":"barvee","\u22be":"angrtvb","\u22bf":"lrtri","\u22c0":"Wedge","\u22c1":"Vee","\u22c2":"xcap","\u22c3":"xcup","\u22c4":"diam","\u22c5":"sdot","\u22c6":"Star","\u22c7":"divonx","\u22c8":"bowtie","\u22c9":"ltimes","\u22ca":"rtimes","\u22cb":"lthree","\u22cc":"rthree","\u22cd":"bsime","\u22ce":"cuvee","\u22cf":"cuwed","\u22d0":"Sub","\u22d1":"Sup","\u22d2":"Cap","\u22d3":"Cup","\u22d4":"fork","\u22d5":"epar","\u22d6":"ltdot","\u22d7":"gtdot","\u22d8":"Ll","\u22d8\u0338":"nLl","\u22d9":"Gg","\u22d9\u0338":"nGg","\u22da\ufe00":"lesg","\u22da":"leg","\u22db":"gel","\u22db\ufe00":"gesl","\u22de":"cuepr","\u22df":"cuesc","\u22e6":"lnsim","\u22e7":"gnsim","\u22e8":"prnsim","\u22e9":"scnsim","\u22ee":"vellip","\u22ef":"ctdot","\u22f0":"utdot","\u22f1":"dtdot","\u22f2":"disin","\u22f3":"isinsv","\u22f4":"isins","\u22f5":"isindot","\u22f5\u0338":"notindot","\u22f6":"notinvc","\u22f7":"notinvb","\u22f9":"isinE","\u22f9\u0338":"notinE","\u22fa":"nisd","\u22fb":"xnis","\u22fc":"nis","\u22fd":"notnivc","\u22fe":"notnivb","\u2305":"barwed","\u2306":"Barwed","\u230c":"drcrop","\u230d":"dlcrop","\u230e":"urcrop","\u230f":"ulcrop","\u2310":"bnot","\u2312":"profline","\u2313":"profsurf","\u2315":"telrec","\u2316":"target","\u231c":"ulcorn","\u231d":"urcorn","\u231e":"dlcorn","\u231f":"drcorn","\u2322":"frown","\u2323":"smile","\u232d":"cylcty","\u232e":"profalar","\u2336":"topbot","\u233d":"ovbar","\u233f":"solbar","\u237c":"angzarr","\u23b0":"lmoust","\u23b1":"rmoust","\u23b4":"tbrk","\u23b5":"bbrk","\u23b6":"bbrktbrk","\u23dc":"OverParenthesis","\u23dd":"UnderParenthesis","\u23de":"OverBrace","\u23df":"UnderBrace","\u23e2":"trpezium","\u23e7":"elinters","\u2423":"blank","\u2500":"boxh","\u2502":"boxv","\u250c":"boxdr","\u2510":"boxdl","\u2514":"boxur","\u2518":"boxul","\u251c":"boxvr","\u2524":"boxvl","\u252c":"boxhd","\u2534":"boxhu","\u253c":"boxvh","\u2550":"boxH","\u2551":"boxV","\u2552":"boxdR","\u2553":"boxDr","\u2554":"boxDR","\u2555":"boxdL","\u2556":"boxDl","\u2557":"boxDL","\u2558":"boxuR","\u2559":"boxUr","\u255a":"boxUR","\u255b":"boxuL","\u255c":"boxUl","\u255d":"boxUL","\u255e":"boxvR","\u255f":"boxVr","\u2560":"boxVR","\u2561":"boxvL","\u2562":"boxVl","\u2563":"boxVL","\u2564":"boxHd","\u2565":"boxhD","\u2566":"boxHD","\u2567":"boxHu","\u2568":"boxhU","\u2569":"boxHU","\u256a":"boxvH","\u256b":"boxVh","\u256c":"boxVH","\u2580":"uhblk","\u2584":"lhblk","\u2588":"block","\u2591":"blk14","\u2592":"blk12","\u2593":"blk34","\u25a1":"squ","\u25aa":"squf","\u25ab":"EmptyVerySmallSquare","\u25ad":"rect","\u25ae":"marker","\u25b1":"fltns","\u25b3":"xutri","\u25b4":"utrif","\u25b5":"utri","\u25b8":"rtrif","\u25b9":"rtri","\u25bd":"xdtri","\u25be":"dtrif","\u25bf":"dtri","\u25c2":"ltrif","\u25c3":"ltri","\u25ca":"loz","\u25cb":"cir","\u25ec":"tridot","\u25ef":"xcirc","\u25f8":"ultri","\u25f9":"urtri","\u25fa":"lltri","\u25fb":"EmptySmallSquare","\u25fc":"FilledSmallSquare","\u2605":"starf","\u2606":"star","\u260e":"phone","\u2640":"female","\u2642":"male","\u2660":"spades","\u2663":"clubs","\u2665":"hearts","\u2666":"diams","\u266a":"sung","\u2713":"check","\u2717":"cross","\u2720":"malt","\u2736":"sext","\u2758":"VerticalSeparator","\u27c8":"bsolhsub","\u27c9":"suphsol","\u27f5":"xlarr","\u27f6":"xrarr","\u27f7":"xharr","\u27f8":"xlArr","\u27f9":"xrArr","\u27fa":"xhArr","\u27fc":"xmap","\u27ff":"dzigrarr","\u2902":"nvlArr","\u2903":"nvrArr","\u2904":"nvHarr","\u2905":"Map","\u290c":"lbarr","\u290d":"rbarr","\u290e":"lBarr","\u290f":"rBarr","\u2910":"RBarr","\u2911":"DDotrahd","\u2912":"UpArrowBar","\u2913":"DownArrowBar","\u2916":"Rarrtl","\u2919":"latail","\u291a":"ratail","\u291b":"lAtail","\u291c":"rAtail","\u291d":"larrfs","\u291e":"rarrfs","\u291f":"larrbfs","\u2920":"rarrbfs","\u2923":"nwarhk","\u2924":"nearhk","\u2925":"searhk","\u2926":"swarhk","\u2927":"nwnear","\u2928":"toea","\u2929":"tosa","\u292a":"swnwar","\u2933":"rarrc","\u2933\u0338":"nrarrc","\u2935":"cudarrr","\u2936":"ldca","\u2937":"rdca","\u2938":"cudarrl","\u2939":"larrpl","\u293c":"curarrm","\u293d":"cularrp","\u2945":"rarrpl","\u2948":"harrcir","\u2949":"Uarrocir","\u294a":"lurdshar","\u294b":"ldrushar","\u294e":"LeftRightVector","\u294f":"RightUpDownVector","\u2950":"DownLeftRightVector","\u2951":"LeftUpDownVector","\u2952":"LeftVectorBar","\u2953":"RightVectorBar","\u2954":"RightUpVectorBar","\u2955":"RightDownVectorBar","\u2956":"DownLeftVectorBar","\u2957":"DownRightVectorBar","\u2958":"LeftUpVectorBar","\u2959":"LeftDownVectorBar","\u295a":"LeftTeeVector","\u295b":"RightTeeVector","\u295c":"RightUpTeeVector","\u295d":"RightDownTeeVector","\u295e":"DownLeftTeeVector","\u295f":"DownRightTeeVector","\u2960":"LeftUpTeeVector","\u2961":"LeftDownTeeVector","\u2962":"lHar","\u2963":"uHar","\u2964":"rHar","\u2965":"dHar","\u2966":"luruhar","\u2967":"ldrdhar","\u2968":"ruluhar","\u2969":"rdldhar","\u296a":"lharul","\u296b":"llhard","\u296c":"rharul","\u296d":"lrhard","\u296e":"udhar","\u296f":"duhar","\u2970":"RoundImplies","\u2971":"erarr","\u2972":"simrarr","\u2973":"larrsim","\u2974":"rarrsim","\u2975":"rarrap","\u2976":"ltlarr","\u2978":"gtrarr","\u2979":"subrarr","\u297b":"suplarr","\u297c":"lfisht","\u297d":"rfisht","\u297e":"ufisht","\u297f":"dfisht","\u299a":"vzigzag","\u299c":"vangrt","\u299d":"angrtvbd","\u29a4":"ange","\u29a5":"range","\u29a6":"dwangle","\u29a7":"uwangle","\u29a8":"angmsdaa","\u29a9":"angmsdab","\u29aa":"angmsdac","\u29ab":"angmsdad","\u29ac":"angmsdae","\u29ad":"angmsdaf","\u29ae":"angmsdag","\u29af":"angmsdah","\u29b0":"bemptyv","\u29b1":"demptyv","\u29b2":"cemptyv","\u29b3":"raemptyv","\u29b4":"laemptyv","\u29b5":"ohbar","\u29b6":"omid","\u29b7":"opar","\u29b9":"operp","\u29bb":"olcross","\u29bc":"odsold","\u29be":"olcir","\u29bf":"ofcir","\u29c0":"olt","\u29c1":"ogt","\u29c2":"cirscir","\u29c3":"cirE","\u29c4":"solb","\u29c5":"bsolb","\u29c9":"boxbox","\u29cd":"trisb","\u29ce":"rtriltri","\u29cf":"LeftTriangleBar","\u29cf\u0338":"NotLeftTriangleBar","\u29d0":"RightTriangleBar","\u29d0\u0338":"NotRightTriangleBar","\u29dc":"iinfin","\u29dd":"infintie","\u29de":"nvinfin","\u29e3":"eparsl","\u29e4":"smeparsl","\u29e5":"eqvparsl","\u29eb":"lozf","\u29f4":"RuleDelayed","\u29f6":"dsol","\u2a00":"xodot","\u2a01":"xoplus","\u2a02":"xotime","\u2a04":"xuplus","\u2a06":"xsqcup","\u2a0d":"fpartint","\u2a10":"cirfnint","\u2a11":"awint","\u2a12":"rppolint","\u2a13":"scpolint","\u2a14":"npolint","\u2a15":"pointint","\u2a16":"quatint","\u2a17":"intlarhk","\u2a22":"pluscir","\u2a23":"plusacir","\u2a24":"simplus","\u2a25":"plusdu","\u2a26":"plussim","\u2a27":"plustwo","\u2a29":"mcomma","\u2a2a":"minusdu","\u2a2d":"loplus","\u2a2e":"roplus","\u2a2f":"Cross","\u2a30":"timesd","\u2a31":"timesbar","\u2a33":"smashp","\u2a34":"lotimes","\u2a35":"rotimes","\u2a36":"otimesas","\u2a37":"Otimes","\u2a38":"odiv","\u2a39":"triplus","\u2a3a":"triminus","\u2a3b":"tritime","\u2a3c":"iprod","\u2a3f":"amalg","\u2a40":"capdot","\u2a42":"ncup","\u2a43":"ncap","\u2a44":"capand","\u2a45":"cupor","\u2a46":"cupcap","\u2a47":"capcup","\u2a48":"cupbrcap","\u2a49":"capbrcup","\u2a4a":"cupcup","\u2a4b":"capcap","\u2a4c":"ccups","\u2a4d":"ccaps","\u2a50":"ccupssm","\u2a53":"And","\u2a54":"Or","\u2a55":"andand","\u2a56":"oror","\u2a57":"orslope","\u2a58":"andslope","\u2a5a":"andv","\u2a5b":"orv","\u2a5c":"andd","\u2a5d":"ord","\u2a5f":"wedbar","\u2a66":"sdote","\u2a6a":"simdot","\u2a6d":"congdot","\u2a6d\u0338":"ncongdot","\u2a6e":"easter","\u2a6f":"apacir","\u2a70":"apE","\u2a70\u0338":"napE","\u2a71":"eplus","\u2a72":"pluse","\u2a73":"Esim","\u2a77":"eDDot","\u2a78":"equivDD","\u2a79":"ltcir","\u2a7a":"gtcir","\u2a7b":"ltquest","\u2a7c":"gtquest","\u2a7d":"les","\u2a7d\u0338":"nles","\u2a7e":"ges","\u2a7e\u0338":"nges","\u2a7f":"lesdot","\u2a80":"gesdot","\u2a81":"lesdoto","\u2a82":"gesdoto","\u2a83":"lesdotor","\u2a84":"gesdotol","\u2a85":"lap","\u2a86":"gap","\u2a87":"lne","\u2a88":"gne","\u2a89":"lnap","\u2a8a":"gnap","\u2a8b":"lEg","\u2a8c":"gEl","\u2a8d":"lsime","\u2a8e":"gsime","\u2a8f":"lsimg","\u2a90":"gsiml","\u2a91":"lgE","\u2a92":"glE","\u2a93":"lesges","\u2a94":"gesles","\u2a95":"els","\u2a96":"egs","\u2a97":"elsdot","\u2a98":"egsdot","\u2a99":"el","\u2a9a":"eg","\u2a9d":"siml","\u2a9e":"simg","\u2a9f":"simlE","\u2aa0":"simgE","\u2aa1":"LessLess","\u2aa1\u0338":"NotNestedLessLess","\u2aa2":"GreaterGreater","\u2aa2\u0338":"NotNestedGreaterGreater","\u2aa4":"glj","\u2aa5":"gla","\u2aa6":"ltcc","\u2aa7":"gtcc","\u2aa8":"lescc","\u2aa9":"gescc","\u2aaa":"smt","\u2aab":"lat","\u2aac":"smte","\u2aac\ufe00":"smtes","\u2aad":"late","\u2aad\ufe00":"lates","\u2aae":"bumpE","\u2aaf":"pre","\u2aaf\u0338":"npre","\u2ab0":"sce","\u2ab0\u0338":"nsce","\u2ab3":"prE","\u2ab4":"scE","\u2ab5":"prnE","\u2ab6":"scnE","\u2ab7":"prap","\u2ab8":"scap","\u2ab9":"prnap","\u2aba":"scnap","\u2abb":"Pr","\u2abc":"Sc","\u2abd":"subdot","\u2abe":"supdot","\u2abf":"subplus","\u2ac0":"supplus","\u2ac1":"submult","\u2ac2":"supmult","\u2ac3":"subedot","\u2ac4":"supedot","\u2ac5":"subE","\u2ac5\u0338":"nsubE","\u2ac6":"supE","\u2ac6\u0338":"nsupE","\u2ac7":"subsim","\u2ac8":"supsim","\u2acb\ufe00":"vsubnE","\u2acb":"subnE","\u2acc\ufe00":"vsupnE","\u2acc":"supnE","\u2acf":"csub","\u2ad0":"csup","\u2ad1":"csube","\u2ad2":"csupe","\u2ad3":"subsup","\u2ad4":"supsub","\u2ad5":"subsub","\u2ad6":"supsup","\u2ad7":"suphsub","\u2ad8":"supdsub","\u2ad9":"forkv","\u2ada":"topfork","\u2adb":"mlcp","\u2ae4":"Dashv","\u2ae6":"Vdashl","\u2ae7":"Barv","\u2ae8":"vBar","\u2ae9":"vBarv","\u2aeb":"Vbar","\u2aec":"Not","\u2aed":"bNot","\u2aee":"rnmid","\u2aef":"cirmid","\u2af0":"midcir","\u2af1":"topcir","\u2af2":"nhpar","\u2af3":"parsim","\u2afd":"parsl","\u2afd\u20e5":"nparsl","\u266d":"flat","\u266e":"natur","\u266f":"sharp","\xa4":"curren","\xa2":"cent",$:"dollar","\xa3":"pound","\xa5":"yen","\u20ac":"euro","\xb9":"sup1","\xbd":"half","\u2153":"frac13","\xbc":"frac14","\u2155":"frac15","\u2159":"frac16","\u215b":"frac18","\xb2":"sup2","\u2154":"frac23","\u2156":"frac25","\xb3":"sup3","\xbe":"frac34","\u2157":"frac35","\u215c":"frac38","\u2158":"frac45","\u215a":"frac56","\u215d":"frac58","\u215e":"frac78","\ud835\udcb6":"ascr","\ud835\udd52":"aopf","\ud835\udd1e":"afr","\ud835\udd38":"Aopf","\ud835\udd04":"Afr","\ud835\udc9c":"Ascr","\xaa":"ordf","\xe1":"aacute","\xc1":"Aacute","\xe0":"agrave","\xc0":"Agrave","\u0103":"abreve","\u0102":"Abreve","\xe2":"acirc","\xc2":"Acirc","\xe5":"aring","\xc5":"angst","\xe4":"auml","\xc4":"Auml","\xe3":"atilde","\xc3":"Atilde","\u0105":"aogon","\u0104":"Aogon","\u0101":"amacr","\u0100":"Amacr","\xe6":"aelig","\xc6":"AElig","\ud835\udcb7":"bscr","\ud835\udd53":"bopf","\ud835\udd1f":"bfr","\ud835\udd39":"Bopf","\u212c":"Bscr","\ud835\udd05":"Bfr","\ud835\udd20":"cfr","\ud835\udcb8":"cscr","\ud835\udd54":"copf","\u212d":"Cfr","\ud835\udc9e":"Cscr","\u2102":"Copf","\u0107":"cacute","\u0106":"Cacute","\u0109":"ccirc","\u0108":"Ccirc","\u010d":"ccaron","\u010c":"Ccaron","\u010b":"cdot","\u010a":"Cdot","\xe7":"ccedil","\xc7":"Ccedil","\u2105":"incare","\ud835\udd21":"dfr","\u2146":"dd","\ud835\udd55":"dopf","\ud835\udcb9":"dscr","\ud835\udc9f":"Dscr","\ud835\udd07":"Dfr","\u2145":"DD","\ud835\udd3b":"Dopf","\u010f":"dcaron","\u010e":"Dcaron","\u0111":"dstrok","\u0110":"Dstrok","\xf0":"eth","\xd0":"ETH","\u2147":"ee","\u212f":"escr","\ud835\udd22":"efr","\ud835\udd56":"eopf","\u2130":"Escr","\ud835\udd08":"Efr","\ud835\udd3c":"Eopf","\xe9":"eacute","\xc9":"Eacute","\xe8":"egrave","\xc8":"Egrave","\xea":"ecirc","\xca":"Ecirc","\u011b":"ecaron","\u011a":"Ecaron","\xeb":"euml","\xcb":"Euml","\u0117":"edot","\u0116":"Edot","\u0119":"eogon","\u0118":"Eogon","\u0113":"emacr","\u0112":"Emacr","\ud835\udd23":"ffr","\ud835\udd57":"fopf","\ud835\udcbb":"fscr","\ud835\udd09":"Ffr","\ud835\udd3d":"Fopf","\u2131":"Fscr","\ufb00":"fflig","\ufb03":"ffilig","\ufb04":"ffllig","\ufb01":"filig",fj:"fjlig","\ufb02":"fllig","\u0192":"fnof","\u210a":"gscr","\ud835\udd58":"gopf","\ud835\udd24":"gfr","\ud835\udca2":"Gscr","\ud835\udd3e":"Gopf","\ud835\udd0a":"Gfr","\u01f5":"gacute","\u011f":"gbreve","\u011e":"Gbreve","\u011d":"gcirc","\u011c":"Gcirc","\u0121":"gdot","\u0120":"Gdot","\u0122":"Gcedil","\ud835\udd25":"hfr","\u210e":"planckh","\ud835\udcbd":"hscr","\ud835\udd59":"hopf","\u210b":"Hscr","\u210c":"Hfr","\u210d":"Hopf","\u0125":"hcirc","\u0124":"Hcirc","\u210f":"hbar","\u0127":"hstrok","\u0126":"Hstrok","\ud835\udd5a":"iopf","\ud835\udd26":"ifr","\ud835\udcbe":"iscr","\u2148":"ii","\ud835\udd40":"Iopf","\u2110":"Iscr","\u2111":"Im","\xed":"iacute","\xcd":"Iacute","\xec":"igrave","\xcc":"Igrave","\xee":"icirc","\xce":"Icirc","\xef":"iuml","\xcf":"Iuml","\u0129":"itilde","\u0128":"Itilde","\u0130":"Idot","\u012f":"iogon","\u012e":"Iogon","\u012b":"imacr","\u012a":"Imacr","\u0133":"ijlig","\u0132":"IJlig","\u0131":"imath","\ud835\udcbf":"jscr","\ud835\udd5b":"jopf","\ud835\udd27":"jfr","\ud835\udca5":"Jscr","\ud835\udd0d":"Jfr","\ud835\udd41":"Jopf","\u0135":"jcirc","\u0134":"Jcirc","\u0237":"jmath","\ud835\udd5c":"kopf","\ud835\udcc0":"kscr","\ud835\udd28":"kfr","\ud835\udca6":"Kscr","\ud835\udd42":"Kopf","\ud835\udd0e":"Kfr","\u0137":"kcedil","\u0136":"Kcedil","\ud835\udd29":"lfr","\ud835\udcc1":"lscr","\u2113":"ell","\ud835\udd5d":"lopf","\u2112":"Lscr","\ud835\udd0f":"Lfr","\ud835\udd43":"Lopf","\u013a":"lacute","\u0139":"Lacute","\u013e":"lcaron","\u013d":"Lcaron","\u013c":"lcedil","\u013b":"Lcedil","\u0142":"lstrok","\u0141":"Lstrok","\u0140":"lmidot","\u013f":"Lmidot","\ud835\udd2a":"mfr","\ud835\udd5e":"mopf","\ud835\udcc2":"mscr","\ud835\udd10":"Mfr","\ud835\udd44":"Mopf","\u2133":"Mscr","\ud835\udd2b":"nfr","\ud835\udd5f":"nopf","\ud835\udcc3":"nscr","\u2115":"Nopf","\ud835\udca9":"Nscr","\ud835\udd11":"Nfr","\u0144":"nacute","\u0143":"Nacute","\u0148":"ncaron","\u0147":"Ncaron","\xf1":"ntilde","\xd1":"Ntilde","\u0146":"ncedil","\u0145":"Ncedil","\u2116":"numero","\u014b":"eng","\u014a":"ENG","\ud835\udd60":"oopf","\ud835\udd2c":"ofr","\u2134":"oscr","\ud835\udcaa":"Oscr","\ud835\udd12":"Ofr","\ud835\udd46":"Oopf","\xba":"ordm","\xf3":"oacute","\xd3":"Oacute","\xf2":"ograve","\xd2":"Ograve","\xf4":"ocirc","\xd4":"Ocirc","\xf6":"ouml","\xd6":"Ouml","\u0151":"odblac","\u0150":"Odblac","\xf5":"otilde","\xd5":"Otilde","\xf8":"oslash","\xd8":"Oslash","\u014d":"omacr","\u014c":"Omacr","\u0153":"oelig","\u0152":"OElig","\ud835\udd2d":"pfr","\ud835\udcc5":"pscr","\ud835\udd61":"popf","\u2119":"Popf","\ud835\udd13":"Pfr","\ud835\udcab":"Pscr","\ud835\udd62":"qopf","\ud835\udd2e":"qfr","\ud835\udcc6":"qscr","\ud835\udcac":"Qscr","\ud835\udd14":"Qfr","\u211a":"Qopf","\u0138":"kgreen","\ud835\udd2f":"rfr","\ud835\udd63":"ropf","\ud835\udcc7":"rscr","\u211b":"Rscr","\u211c":"Re","\u211d":"Ropf","\u0155":"racute","\u0154":"Racute","\u0159":"rcaron","\u0158":"Rcaron","\u0157":"rcedil","\u0156":"Rcedil","\ud835\udd64":"sopf","\ud835\udcc8":"sscr","\ud835\udd30":"sfr","\ud835\udd4a":"Sopf","\ud835\udd16":"Sfr","\ud835\udcae":"Sscr","\u24c8":"oS","\u015b":"sacute","\u015a":"Sacute","\u015d":"scirc","\u015c":"Scirc","\u0161":"scaron","\u0160":"Scaron","\u015f":"scedil","\u015e":"Scedil","\xdf":"szlig","\ud835\udd31":"tfr","\ud835\udcc9":"tscr","\ud835\udd65":"topf","\ud835\udcaf":"Tscr","\ud835\udd17":"Tfr","\ud835\udd4b":"Topf","\u0165":"tcaron","\u0164":"Tcaron","\u0163":"tcedil","\u0162":"Tcedil","\u2122":"trade","\u0167":"tstrok","\u0166":"Tstrok","\ud835\udcca":"uscr","\ud835\udd66":"uopf","\ud835\udd32":"ufr","\ud835\udd4c":"Uopf","\ud835\udd18":"Ufr","\ud835\udcb0":"Uscr","\xfa":"uacute","\xda":"Uacute","\xf9":"ugrave","\xd9":"Ugrave","\u016d":"ubreve","\u016c":"Ubreve","\xfb":"ucirc","\xdb":"Ucirc","\u016f":"uring","\u016e":"Uring","\xfc":"uuml","\xdc":"Uuml","\u0171":"udblac","\u0170":"Udblac","\u0169":"utilde","\u0168":"Utilde","\u0173":"uogon","\u0172":"Uogon","\u016b":"umacr","\u016a":"Umacr","\ud835\udd33":"vfr","\ud835\udd67":"vopf","\ud835\udccb":"vscr","\ud835\udd19":"Vfr","\ud835\udd4d":"Vopf","\ud835\udcb1":"Vscr","\ud835\udd68":"wopf","\ud835\udccc":"wscr","\ud835\udd34":"wfr","\ud835\udcb2":"Wscr","\ud835\udd4e":"Wopf","\ud835\udd1a":"Wfr","\u0175":"wcirc","\u0174":"Wcirc","\ud835\udd35":"xfr","\ud835\udccd":"xscr","\ud835\udd69":"xopf","\ud835\udd4f":"Xopf","\ud835\udd1b":"Xfr","\ud835\udcb3":"Xscr","\ud835\udd36":"yfr","\ud835\udcce":"yscr","\ud835\udd6a":"yopf","\ud835\udcb4":"Yscr","\ud835\udd1c":"Yfr","\ud835\udd50":"Yopf","\xfd":"yacute","\xdd":"Yacute","\u0177":"ycirc","\u0176":"Ycirc","\xff":"yuml","\u0178":"Yuml","\ud835\udccf":"zscr","\ud835\udd37":"zfr","\ud835\udd6b":"zopf","\u2128":"Zfr","\u2124":"Zopf","\ud835\udcb5":"Zscr","\u017a":"zacute","\u0179":"Zacute","\u017e":"zcaron","\u017d":"Zcaron","\u017c":"zdot","\u017b":"Zdot","\u01b5":"imped","\xfe":"thorn","\xde":"THORN","\u0149":"napos","\u03b1":"alpha","\u0391":"Alpha","\u03b2":"beta","\u0392":"Beta","\u03b3":"gamma","\u0393":"Gamma","\u03b4":"delta","\u0394":"Delta","\u03b5":"epsi","\u03f5":"epsiv","\u0395":"Epsilon","\u03dd":"gammad","\u03dc":"Gammad","\u03b6":"zeta","\u0396":"Zeta","\u03b7":"eta","\u0397":"Eta","\u03b8":"theta","\u03d1":"thetav","\u0398":"Theta","\u03b9":"iota","\u0399":"Iota","\u03ba":"kappa","\u03f0":"kappav","\u039a":"Kappa","\u03bb":"lambda","\u039b":"Lambda","\u03bc":"mu","\xb5":"micro","\u039c":"Mu","\u03bd":"nu","\u039d":"Nu","\u03be":"xi","\u039e":"Xi","\u03bf":"omicron","\u039f":"Omicron","\u03c0":"pi","\u03d6":"piv","\u03a0":"Pi","\u03c1":"rho","\u03f1":"rhov","\u03a1":"Rho","\u03c3":"sigma","\u03a3":"Sigma","\u03c2":"sigmaf","\u03c4":"tau","\u03a4":"Tau","\u03c5":"upsi","\u03a5":"Upsilon","\u03d2":"Upsi","\u03c6":"phi","\u03d5":"phiv","\u03a6":"Phi","\u03c7":"chi","\u03a7":"Chi","\u03c8":"psi","\u03a8":"Psi","\u03c9":"omega","\u03a9":"ohm","\u0430":"acy","\u0410":"Acy","\u0431":"bcy","\u0411":"Bcy","\u0432":"vcy","\u0412":"Vcy","\u0433":"gcy","\u0413":"Gcy","\u0453":"gjcy","\u0403":"GJcy","\u0434":"dcy","\u0414":"Dcy","\u0452":"djcy","\u0402":"DJcy","\u0435":"iecy","\u0415":"IEcy","\u0451":"iocy","\u0401":"IOcy","\u0454":"jukcy","\u0404":"Jukcy","\u0436":"zhcy","\u0416":"ZHcy","\u0437":"zcy","\u0417":"Zcy","\u0455":"dscy","\u0405":"DScy","\u0438":"icy","\u0418":"Icy","\u0456":"iukcy","\u0406":"Iukcy","\u0457":"yicy","\u0407":"YIcy","\u0439":"jcy","\u0419":"Jcy","\u0458":"jsercy","\u0408":"Jsercy","\u043a":"kcy","\u041a":"Kcy","\u045c":"kjcy","\u040c":"KJcy","\u043b":"lcy","\u041b":"Lcy","\u0459":"ljcy","\u0409":"LJcy","\u043c":"mcy","\u041c":"Mcy","\u043d":"ncy","\u041d":"Ncy","\u045a":"njcy","\u040a":"NJcy","\u043e":"ocy","\u041e":"Ocy","\u043f":"pcy","\u041f":"Pcy","\u0440":"rcy","\u0420":"Rcy","\u0441":"scy","\u0421":"Scy","\u0442":"tcy","\u0422":"Tcy","\u045b":"tshcy","\u040b":"TSHcy","\u0443":"ucy","\u0423":"Ucy","\u045e":"ubrcy","\u040e":"Ubrcy","\u0444":"fcy","\u0424":"Fcy","\u0445":"khcy","\u0425":"KHcy","\u0446":"tscy","\u0426":"TScy","\u0447":"chcy","\u0427":"CHcy","\u045f":"dzcy","\u040f":"DZcy","\u0448":"shcy","\u0428":"SHcy","\u0449":"shchcy","\u0429":"SHCHcy","\u044a":"hardcy","\u042a":"HARDcy","\u044b":"ycy","\u042b":"Ycy","\u044c":"softcy","\u042c":"SOFTcy","\u044d":"ecy","\u042d":"Ecy","\u044e":"yucy","\u042e":"YUcy","\u044f":"yacy","\u042f":"YAcy","\u2135":"aleph","\u2136":"beth","\u2137":"gimel","\u2138":"daleth"},l=/["&'<>`]/g,u={'"':"&quot;","&":"&amp;","'":"&#x27;","<":"&lt;",">":"&gt;","`":"&#x60;"},p=/&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/,d=/[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/,f=/&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g,m={aacute:"\xe1",Aacute:"\xc1",abreve:"\u0103",Abreve:"\u0102",ac:"\u223e",acd:"\u223f",acE:"\u223e\u0333",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",acy:"\u0430",Acy:"\u0410",aelig:"\xe6",AElig:"\xc6",af:"\u2061",afr:"\ud835\udd1e",Afr:"\ud835\udd04",agrave:"\xe0",Agrave:"\xc0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",Alpha:"\u0391",amacr:"\u0101",Amacr:"\u0100",amalg:"\u2a3f",amp:"&",AMP:"&",and:"\u2227",And:"\u2a53",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",ange:"\u29a4",angle:"\u2220",angmsd:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angst:"\xc5",angzarr:"\u237c",aogon:"\u0105",Aogon:"\u0104",aopf:"\ud835\udd52",Aopf:"\ud835\udd38",ap:"\u2248",apacir:"\u2a6f",ape:"\u224a",apE:"\u2a70",apid:"\u224b",apos:"'",ApplyFunction:"\u2061",approx:"\u2248",approxeq:"\u224a",aring:"\xe5",Aring:"\xc5",ascr:"\ud835\udcb6",Ascr:"\ud835\udc9c",Assign:"\u2254",ast:"*",asymp:"\u2248",asympeq:"\u224d",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",awconint:"\u2233",awint:"\u2a11",backcong:"\u224c",backepsilon:"\u03f6",backprime:"\u2035",backsim:"\u223d",backsimeq:"\u22cd",Backslash:"\u2216",Barv:"\u2ae7",barvee:"\u22bd",barwed:"\u2305",Barwed:"\u2306",barwedge:"\u2305",bbrk:"\u23b5",bbrktbrk:"\u23b6",bcong:"\u224c",bcy:"\u0431",Bcy:"\u0411",bdquo:"\u201e",becaus:"\u2235",because:"\u2235",Because:"\u2235",bemptyv:"\u29b0",bepsi:"\u03f6",bernou:"\u212c",Bernoullis:"\u212c",beta:"\u03b2",Beta:"\u0392",beth:"\u2136",between:"\u226c",bfr:"\ud835\udd1f",Bfr:"\ud835\udd05",bigcap:"\u22c2",bigcirc:"\u25ef",bigcup:"\u22c3",bigodot:"\u2a00",bigoplus:"\u2a01",bigotimes:"\u2a02",bigsqcup:"\u2a06",bigstar:"\u2605",bigtriangledown:"\u25bd",bigtriangleup:"\u25b3",biguplus:"\u2a04",bigvee:"\u22c1",bigwedge:"\u22c0",bkarow:"\u290d",blacklozenge:"\u29eb",blacksquare:"\u25aa",blacktriangle:"\u25b4",blacktriangledown:"\u25be",blacktriangleleft:"\u25c2",blacktriangleright:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bNot:"\u2aed",bopf:"\ud835\udd53",Bopf:"\ud835\udd39",bot:"\u22a5",bottom:"\u22a5",bowtie:"\u22c8",boxbox:"\u29c9",boxdl:"\u2510",boxdL:"\u2555",boxDl:"\u2556",boxDL:"\u2557",boxdr:"\u250c",boxdR:"\u2552",boxDr:"\u2553",boxDR:"\u2554",boxh:"\u2500",boxH:"\u2550",boxhd:"\u252c",boxhD:"\u2565",boxHd:"\u2564",boxHD:"\u2566",boxhu:"\u2534",boxhU:"\u2568",boxHu:"\u2567",boxHU:"\u2569",boxminus:"\u229f",boxplus:"\u229e",boxtimes:"\u22a0",boxul:"\u2518",boxuL:"\u255b",boxUl:"\u255c",boxUL:"\u255d",boxur:"\u2514",boxuR:"\u2558",boxUr:"\u2559",boxUR:"\u255a",boxv:"\u2502",boxV:"\u2551",boxvh:"\u253c",boxvH:"\u256a",boxVh:"\u256b",boxVH:"\u256c",boxvl:"\u2524",boxvL:"\u2561",boxVl:"\u2562",boxVL:"\u2563",boxvr:"\u251c",boxvR:"\u255e",boxVr:"\u255f",boxVR:"\u2560",bprime:"\u2035",breve:"\u02d8",Breve:"\u02d8",brvbar:"\xa6",bscr:"\ud835\udcb7",Bscr:"\u212c",bsemi:"\u204f",bsim:"\u223d",bsime:"\u22cd",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bump:"\u224e",bumpe:"\u224f",bumpE:"\u2aae",bumpeq:"\u224f",Bumpeq:"\u224e",cacute:"\u0107",Cacute:"\u0106",cap:"\u2229",Cap:"\u22d2",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",CapitalDifferentialD:"\u2145",caps:"\u2229\ufe00",caret:"\u2041",caron:"\u02c7",Cayleys:"\u212d",ccaps:"\u2a4d",ccaron:"\u010d",Ccaron:"\u010c",ccedil:"\xe7",Ccedil:"\xc7",ccirc:"\u0109",Ccirc:"\u0108",Cconint:"\u2230",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",Cdot:"\u010a",cedil:"\xb8",Cedilla:"\xb8",cemptyv:"\u29b2",cent:"\xa2",centerdot:"\xb7",CenterDot:"\xb7",cfr:"\ud835\udd20",Cfr:"\u212d",chcy:"\u0447",CHcy:"\u0427",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",Chi:"\u03a7",cir:"\u25cb",circ:"\u02c6",circeq:"\u2257",circlearrowleft:"\u21ba",circlearrowright:"\u21bb",circledast:"\u229b",circledcirc:"\u229a",circleddash:"\u229d",CircleDot:"\u2299",circledR:"\xae",circledS:"\u24c8",CircleMinus:"\u2296",CirclePlus:"\u2295",CircleTimes:"\u2297",cire:"\u2257",cirE:"\u29c3",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",ClockwiseContourIntegral:"\u2232",CloseCurlyDoubleQuote:"\u201d",CloseCurlyQuote:"\u2019",clubs:"\u2663",clubsuit:"\u2663",colon:":",Colon:"\u2237",colone:"\u2254",Colone:"\u2a74",coloneq:"\u2254",comma:",",commat:"@",comp:"\u2201",compfn:"\u2218",complement:"\u2201",complexes:"\u2102",cong:"\u2245",congdot:"\u2a6d",Congruent:"\u2261",conint:"\u222e",Conint:"\u222f",ContourIntegral:"\u222e",copf:"\ud835\udd54",Copf:"\u2102",coprod:"\u2210",Coproduct:"\u2210",copy:"\xa9",COPY:"\xa9",copysr:"\u2117",CounterClockwiseContourIntegral:"\u2233",crarr:"\u21b5",cross:"\u2717",Cross:"\u2a2f",cscr:"\ud835\udcb8",Cscr:"\ud835\udc9e",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",cuesc:"\u22df",cularr:"\u21b6",cularrp:"\u293d",cup:"\u222a",Cup:"\u22d3",cupbrcap:"\u2a48",cupcap:"\u2a46",CupCap:"\u224d",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curarrm:"\u293c",curlyeqprec:"\u22de",curlyeqsucc:"\u22df",curlyvee:"\u22ce",curlywedge:"\u22cf",curren:"\xa4",curvearrowleft:"\u21b6",curvearrowright:"\u21b7",cuvee:"\u22ce",cuwed:"\u22cf",cwconint:"\u2232",cwint:"\u2231",cylcty:"\u232d",dagger:"\u2020",Dagger:"\u2021",daleth:"\u2138",darr:"\u2193",dArr:"\u21d3",Darr:"\u21a1",dash:"\u2010",dashv:"\u22a3",Dashv:"\u2ae4",dbkarow:"\u290f",dblac:"\u02dd",dcaron:"\u010f",Dcaron:"\u010e",dcy:"\u0434",Dcy:"\u0414",dd:"\u2146",DD:"\u2145",ddagger:"\u2021",ddarr:"\u21ca",DDotrahd:"\u2911",ddotseq:"\u2a77",deg:"\xb0",Del:"\u2207",delta:"\u03b4",Delta:"\u0394",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",Dfr:"\ud835\udd07",dHar:"\u2965",dharl:"\u21c3",dharr:"\u21c2",DiacriticalAcute:"\xb4",DiacriticalDot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",DiacriticalGrave:"`",DiacriticalTilde:"\u02dc",diam:"\u22c4",diamond:"\u22c4",Diamond:"\u22c4",diamondsuit:"\u2666",diams:"\u2666",die:"\xa8",DifferentialD:"\u2146",digamma:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",DJcy:"\u0402",dlcorn:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",Dopf:"\ud835\udd3b",dot:"\u02d9",Dot:"\xa8",DotDot:"\u20dc",doteq:"\u2250",doteqdot:"\u2251",DotEqual:"\u2250",dotminus:"\u2238",dotplus:"\u2214",dotsquare:"\u22a1",doublebarwedge:"\u2306",DoubleContourIntegral:"\u222f",DoubleDot:"\xa8",DoubleDownArrow:"\u21d3",DoubleLeftArrow:"\u21d0",DoubleLeftRightArrow:"\u21d4",DoubleLeftTee:"\u2ae4",DoubleLongLeftArrow:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",DoubleLongRightArrow:"\u27f9",DoubleRightArrow:"\u21d2",DoubleRightTee:"\u22a8",DoubleUpArrow:"\u21d1",DoubleUpDownArrow:"\u21d5",DoubleVerticalBar:"\u2225",downarrow:"\u2193",Downarrow:"\u21d3",DownArrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",DownBreve:"\u0311",downdownarrows:"\u21ca",downharpoonleft:"\u21c3",downharpoonright:"\u21c2",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",DownTeeArrow:"\u21a7",drbkarow:"\u2910",drcorn:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",Dscr:"\ud835\udc9f",dscy:"\u0455",DScy:"\u0405",dsol:"\u29f6",dstrok:"\u0111",Dstrok:"\u0110",dtdot:"\u22f1",dtri:"\u25bf",dtrif:"\u25be",duarr:"\u21f5",duhar:"\u296f",dwangle:"\u29a6",dzcy:"\u045f",DZcy:"\u040f",dzigrarr:"\u27ff",eacute:"\xe9",Eacute:"\xc9",easter:"\u2a6e",ecaron:"\u011b",Ecaron:"\u011a",ecir:"\u2256",ecirc:"\xea",Ecirc:"\xca",ecolon:"\u2255",ecy:"\u044d",Ecy:"\u042d",eDDot:"\u2a77",edot:"\u0117",eDot:"\u2251",Edot:"\u0116",ee:"\u2147",efDot:"\u2252",efr:"\ud835\udd22",Efr:"\ud835\udd08",eg:"\u2a9a",egrave:"\xe8",Egrave:"\xc8",egs:"\u2a96",egsdot:"\u2a98",el:"\u2a99",Element:"\u2208",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",Emacr:"\u0112",empty:"\u2205",emptyset:"\u2205",EmptySmallSquare:"\u25fb",emptyv:"\u2205",EmptyVerySmallSquare:"\u25ab",emsp:"\u2003",emsp13:"\u2004",emsp14:"\u2005",eng:"\u014b",ENG:"\u014a",ensp:"\u2002",eogon:"\u0119",Eogon:"\u0118",eopf:"\ud835\udd56",Eopf:"\ud835\udd3c",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",Epsilon:"\u0395",epsiv:"\u03f5",eqcirc:"\u2256",eqcolon:"\u2255",eqsim:"\u2242",eqslantgtr:"\u2a96",eqslantless:"\u2a95",Equal:"\u2a75",equals:"=",EqualTilde:"\u2242",equest:"\u225f",Equilibrium:"\u21cc",equiv:"\u2261",equivDD:"\u2a78",eqvparsl:"\u29e5",erarr:"\u2971",erDot:"\u2253",escr:"\u212f",Escr:"\u2130",esdot:"\u2250",esim:"\u2242",Esim:"\u2a73",eta:"\u03b7",Eta:"\u0397",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",euro:"\u20ac",excl:"!",exist:"\u2203",Exists:"\u2203",expectation:"\u2130",exponentiale:"\u2147",ExponentialE:"\u2147",fallingdotseq:"\u2252",fcy:"\u0444",Fcy:"\u0424",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",Ffr:"\ud835\udd09",filig:"\ufb01",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",Fopf:"\ud835\udd3d",forall:"\u2200",ForAll:"\u2200",fork:"\u22d4",forkv:"\u2ad9",Fouriertrf:"\u2131",fpartint:"\u2a0d",frac12:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",fscr:"\ud835\udcbb",Fscr:"\u2131",gacute:"\u01f5",gamma:"\u03b3",Gamma:"\u0393",gammad:"\u03dd",Gammad:"\u03dc",gap:"\u2a86",gbreve:"\u011f",Gbreve:"\u011e",Gcedil:"\u0122",gcirc:"\u011d",Gcirc:"\u011c",gcy:"\u0433",Gcy:"\u0413",gdot:"\u0121",Gdot:"\u0120",ge:"\u2265",gE:"\u2267",gel:"\u22db",gEl:"\u2a8c",geq:"\u2265",geqq:"\u2267",geqslant:"\u2a7e",ges:"\u2a7e",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",Gfr:"\ud835\udd0a",gg:"\u226b",Gg:"\u22d9",ggg:"\u22d9",gimel:"\u2137",gjcy:"\u0453",GJcy:"\u0403",gl:"\u2277",gla:"\u2aa5",glE:"\u2a92",glj:"\u2aa4",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gnE:"\u2269",gneq:"\u2a88",gneqq:"\u2269",gnsim:"\u22e7",gopf:"\ud835\udd58",Gopf:"\ud835\udd3e",grave:"`",GreaterEqual:"\u2265",GreaterEqualLess:"\u22db",GreaterFullEqual:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",GreaterSlantEqual:"\u2a7e",GreaterTilde:"\u2273",gscr:"\u210a",Gscr:"\ud835\udca2",gsim:"\u2273",gsime:"\u2a8e",gsiml:"\u2a90",gt:">",Gt:"\u226b",GT:">",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrapprox:"\u2a86",gtrarr:"\u2978",gtrdot:"\u22d7",gtreqless:"\u22db",gtreqqless:"\u2a8c",gtrless:"\u2277",gtrsim:"\u2273",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",Hacek:"\u02c7",hairsp:"\u200a",half:"\xbd",hamilt:"\u210b",hardcy:"\u044a",HARDcy:"\u042a",harr:"\u2194",hArr:"\u21d4",harrcir:"\u2948",harrw:"\u21ad",Hat:"^",hbar:"\u210f",hcirc:"\u0125",Hcirc:"\u0124",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",Hfr:"\u210c",HilbertSpace:"\u210b",hksearow:"\u2925",hkswarow:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",hookrightarrow:"\u21aa",hopf:"\ud835\udd59",Hopf:"\u210d",horbar:"\u2015",HorizontalLine:"\u2500",hscr:"\ud835\udcbd",Hscr:"\u210b",hslash:"\u210f",hstrok:"\u0127",Hstrok:"\u0126",HumpDownHump:"\u224e",HumpEqual:"\u224f",hybull:"\u2043",hyphen:"\u2010",iacute:"\xed",Iacute:"\xcd",ic:"\u2063",icirc:"\xee",Icirc:"\xce",icy:"\u0438",Icy:"\u0418",Idot:"\u0130",iecy:"\u0435",IEcy:"\u0415",iexcl:"\xa1",iff:"\u21d4",ifr:"\ud835\udd26",Ifr:"\u2111",igrave:"\xec",Igrave:"\xcc",ii:"\u2148",iiiint:"\u2a0c",iiint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",IJlig:"\u0132",Im:"\u2111",imacr:"\u012b",Imacr:"\u012a",image:"\u2111",ImaginaryI:"\u2148",imagline:"\u2110",imagpart:"\u2111",imath:"\u0131",imof:"\u22b7",imped:"\u01b5",Implies:"\u21d2",in:"\u2208",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",inodot:"\u0131",int:"\u222b",Int:"\u222c",intcal:"\u22ba",integers:"\u2124",Integral:"\u222b",intercal:"\u22ba",Intersection:"\u22c2",intlarhk:"\u2a17",intprod:"\u2a3c",InvisibleComma:"\u2063",InvisibleTimes:"\u2062",iocy:"\u0451",IOcy:"\u0401",iogon:"\u012f",Iogon:"\u012e",iopf:"\ud835\udd5a",Iopf:"\ud835\udd40",iota:"\u03b9",Iota:"\u0399",iprod:"\u2a3c",iquest:"\xbf",iscr:"\ud835\udcbe",Iscr:"\u2110",isin:"\u2208",isindot:"\u22f5",isinE:"\u22f9",isins:"\u22f4",isinsv:"\u22f3",isinv:"\u2208",it:"\u2062",itilde:"\u0129",Itilde:"\u0128",iukcy:"\u0456",Iukcy:"\u0406",iuml:"\xef",Iuml:"\xcf",jcirc:"\u0135",Jcirc:"\u0134",jcy:"\u0439",Jcy:"\u0419",jfr:"\ud835\udd27",Jfr:"\ud835\udd0d",jmath:"\u0237",jopf:"\ud835\udd5b",Jopf:"\ud835\udd41",jscr:"\ud835\udcbf",Jscr:"\ud835\udca5",jsercy:"\u0458",Jsercy:"\u0408",jukcy:"\u0454",Jukcy:"\u0404",kappa:"\u03ba",Kappa:"\u039a",kappav:"\u03f0",kcedil:"\u0137",Kcedil:"\u0136",kcy:"\u043a",Kcy:"\u041a",kfr:"\ud835\udd28",Kfr:"\ud835\udd0e",kgreen:"\u0138",khcy:"\u0445",KHcy:"\u0425",kjcy:"\u045c",KJcy:"\u040c",kopf:"\ud835\udd5c",Kopf:"\ud835\udd42",kscr:"\ud835\udcc0",Kscr:"\ud835\udca6",lAarr:"\u21da",lacute:"\u013a",Lacute:"\u0139",laemptyv:"\u29b4",lagran:"\u2112",lambda:"\u03bb",Lambda:"\u039b",lang:"\u27e8",Lang:"\u27ea",langd:"\u2991",langle:"\u27e8",lap:"\u2a85",Laplacetrf:"\u2112",laquo:"\xab",larr:"\u2190",lArr:"\u21d0",Larr:"\u219e",larrb:"\u21e4",larrbfs:"\u291f",larrfs:"\u291d",larrhk:"\u21a9",larrlp:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",lat:"\u2aab",latail:"\u2919",lAtail:"\u291b",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lBarr:"\u290e",lbbrk:"\u2772",lbrace:"{",lbrack:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",Lcaron:"\u013d",lcedil:"\u013c",Lcedil:"\u013b",lceil:"\u2308",lcub:"{",lcy:"\u043b",Lcy:"\u041b",ldca:"\u2936",ldquo:"\u201c",ldquor:"\u201e",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",lE:"\u2266",LeftAngleBracket:"\u27e8",leftarrow:"\u2190",Leftarrow:"\u21d0",LeftArrow:"\u2190",LeftArrowBar:"\u21e4",LeftArrowRightArrow:"\u21c6",leftarrowtail:"\u21a2",LeftCeiling:"\u2308",LeftDoubleBracket:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",leftharpoondown:"\u21bd",leftharpoonup:"\u21bc",leftleftarrows:"\u21c7",leftrightarrow:"\u2194",Leftrightarrow:"\u21d4",LeftRightArrow:"\u2194",leftrightarrows:"\u21c6",leftrightharpoons:"\u21cb",leftrightsquigarrow:"\u21ad",LeftRightVector:"\u294e",LeftTee:"\u22a3",LeftTeeArrow:"\u21a4",LeftTeeVector:"\u295a",leftthreetimes:"\u22cb",LeftTriangle:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",LeftVectorBar:"\u2952",leg:"\u22da",lEg:"\u2a8b",leq:"\u2264",leqq:"\u2266",leqslant:"\u2a7d",les:"\u2a7d",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessapprox:"\u2a85",lessdot:"\u22d6",lesseqgtr:"\u22da",lesseqqgtr:"\u2a8b",LessEqualGreater:"\u22da",LessFullEqual:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",LessLess:"\u2aa1",lesssim:"\u2272",LessSlantEqual:"\u2a7d",LessTilde:"\u2272",lfisht:"\u297c",lfloor:"\u230a",lfr:"\ud835\udd29",Lfr:"\ud835\udd0f",lg:"\u2276",lgE:"\u2a91",lHar:"\u2962",lhard:"\u21bd",lharu:"\u21bc",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",LJcy:"\u0409",ll:"\u226a",Ll:"\u22d8",llarr:"\u21c7",llcorner:"\u231e",Lleftarrow:"\u21da",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",Lmidot:"\u013f",lmoust:"\u23b0",lmoustache:"\u23b0",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lnE:"\u2268",lneq:"\u2a87",lneqq:"\u2268",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",lobrk:"\u27e6",longleftarrow:"\u27f5",Longleftarrow:"\u27f8",LongLeftArrow:"\u27f5",longleftrightarrow:"\u27f7",Longleftrightarrow:"\u27fa",LongLeftRightArrow:"\u27f7",longmapsto:"\u27fc",longrightarrow:"\u27f6",Longrightarrow:"\u27f9",LongRightArrow:"\u27f6",looparrowleft:"\u21ab",looparrowright:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",Lopf:"\ud835\udd43",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",lowbar:"_",LowerLeftArrow:"\u2199",LowerRightArrow:"\u2198",loz:"\u25ca",lozenge:"\u25ca",lozf:"\u29eb",lpar:"(",lparlt:"\u2993",lrarr:"\u21c6",lrcorner:"\u231f",lrhar:"\u21cb",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",Lscr:"\u2112",lsh:"\u21b0",Lsh:"\u21b0",lsim:"\u2272",lsime:"\u2a8d",lsimg:"\u2a8f",lsqb:"[",lsquo:"\u2018",lsquor:"\u201a",lstrok:"\u0142",Lstrok:"\u0141",lt:"<",Lt:"\u226a",LT:"<",ltcc:"\u2aa6",ltcir:"\u2a79",ltdot:"\u22d6",lthree:"\u22cb",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltri:"\u25c3",ltrie:"\u22b4",ltrif:"\u25c2",ltrPar:"\u2996",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",macr:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",map:"\u21a6",Map:"\u2905",mapsto:"\u21a6",mapstodown:"\u21a7",mapstoleft:"\u21a4",mapstoup:"\u21a5",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",Mcy:"\u041c",mdash:"\u2014",mDDot:"\u223a",measuredangle:"\u2221",MediumSpace:"\u205f",Mellintrf:"\u2133",mfr:"\ud835\udd2a",Mfr:"\ud835\udd10",mho:"\u2127",micro:"\xb5",mid:"\u2223",midast:"*",midcir:"\u2af0",middot:"\xb7",minus:"\u2212",minusb:"\u229f",minusd:"\u2238",minusdu:"\u2a2a",MinusPlus:"\u2213",mlcp:"\u2adb",mldr:"\u2026",mnplus:"\u2213",models:"\u22a7",mopf:"\ud835\udd5e",Mopf:"\ud835\udd44",mp:"\u2213",mscr:"\ud835\udcc2",Mscr:"\u2133",mstpos:"\u223e",mu:"\u03bc",Mu:"\u039c",multimap:"\u22b8",mumap:"\u22b8",nabla:"\u2207",nacute:"\u0144",Nacute:"\u0143",nang:"\u2220\u20d2",nap:"\u2249",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",napprox:"\u2249",natur:"\u266e",natural:"\u266e",naturals:"\u2115",nbsp:"\xa0",nbump:"\u224e\u0338",nbumpe:"\u224f\u0338",ncap:"\u2a43",ncaron:"\u0148",Ncaron:"\u0147",ncedil:"\u0146",Ncedil:"\u0145",ncong:"\u2247",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",Ncy:"\u041d",ndash:"\u2013",ne:"\u2260",nearhk:"\u2924",nearr:"\u2197",neArr:"\u21d7",nearrow:"\u2197",nedot:"\u2250\u0338",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",nequiv:"\u2262",nesear:"\u2928",nesim:"\u2242\u0338",NestedGreaterGreater:"\u226b",NestedLessLess:"\u226a",NewLine:"\n",nexist:"\u2204",nexists:"\u2204",nfr:"\ud835\udd2b",Nfr:"\ud835\udd11",nge:"\u2271",ngE:"\u2267\u0338",ngeq:"\u2271",ngeqq:"\u2267\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",nGg:"\u22d9\u0338",ngsim:"\u2275",ngt:"\u226f",nGt:"\u226b\u20d2",ngtr:"\u226f",nGtv:"\u226b\u0338",nharr:"\u21ae",nhArr:"\u21ce",nhpar:"\u2af2",ni:"\u220b",nis:"\u22fc",nisd:"\u22fa",niv:"\u220b",njcy:"\u045a",NJcy:"\u040a",nlarr:"\u219a",nlArr:"\u21cd",nldr:"\u2025",nle:"\u2270",nlE:"\u2266\u0338",nleftarrow:"\u219a",nLeftarrow:"\u21cd",nleftrightarrow:"\u21ae",nLeftrightarrow:"\u21ce",nleq:"\u2270",nleqq:"\u2266\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",nless:"\u226e",nLl:"\u22d8\u0338",nlsim:"\u2274",nlt:"\u226e",nLt:"\u226a\u20d2",nltri:"\u22ea",nltrie:"\u22ec",nLtv:"\u226a\u0338",nmid:"\u2224",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nopf:"\ud835\udd5f",Nopf:"\u2115",not:"\xac",Not:"\u2aec",NotCongruent:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",NotElement:"\u2209",NotEqual:"\u2260",NotEqualTilde:"\u2242\u0338",NotExists:"\u2204",NotGreater:"\u226f",NotGreaterEqual:"\u2271",NotGreaterFullEqual:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",NotGreaterLess:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",NotGreaterTilde:"\u2275",NotHumpDownHump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",notin:"\u2209",notindot:"\u22f5\u0338",notinE:"\u22f9\u0338",notinva:"\u2209",notinvb:"\u22f7",notinvc:"\u22f6",NotLeftTriangle:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",NotLess:"\u226e",NotLessEqual:"\u2270",NotLessGreater:"\u2278",NotLessLess:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",NotLessTilde:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",notni:"\u220c",notniva:"\u220c",notnivb:"\u22fe",notnivc:"\u22fd",NotPrecedes:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",NotReverseElement:"\u220c",NotRightTriangle:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",NotSubset:"\u2282\u20d2",NotSubsetEqual:"\u2288",NotSucceeds:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",NotSupersetEqual:"\u2289",NotTilde:"\u2241",NotTildeEqual:"\u2244",NotTildeFullEqual:"\u2247",NotTildeTilde:"\u2249",NotVerticalBar:"\u2224",npar:"\u2226",nparallel:"\u2226",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",npr:"\u2280",nprcue:"\u22e0",npre:"\u2aaf\u0338",nprec:"\u2280",npreceq:"\u2aaf\u0338",nrarr:"\u219b",nrArr:"\u21cf",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nrightarrow:"\u219b",nRightarrow:"\u21cf",nrtri:"\u22eb",nrtrie:"\u22ed",nsc:"\u2281",nsccue:"\u22e1",nsce:"\u2ab0\u0338",nscr:"\ud835\udcc3",Nscr:"\ud835\udca9",nshortmid:"\u2224",nshortparallel:"\u2226",nsim:"\u2241",nsime:"\u2244",nsimeq:"\u2244",nsmid:"\u2224",nspar:"\u2226",nsqsube:"\u22e2",nsqsupe:"\u22e3",nsub:"\u2284",nsube:"\u2288",nsubE:"\u2ac5\u0338",nsubset:"\u2282\u20d2",nsubseteq:"\u2288",nsubseteqq:"\u2ac5\u0338",nsucc:"\u2281",nsucceq:"\u2ab0\u0338",nsup:"\u2285",nsupe:"\u2289",nsupE:"\u2ac6\u0338",nsupset:"\u2283\u20d2",nsupseteq:"\u2289",nsupseteqq:"\u2ac6\u0338",ntgl:"\u2279",ntilde:"\xf1",Ntilde:"\xd1",ntlg:"\u2278",ntriangleleft:"\u22ea",ntrianglelefteq:"\u22ec",ntriangleright:"\u22eb",ntrianglerighteq:"\u22ed",nu:"\u03bd",Nu:"\u039d",num:"#",numero:"\u2116",numsp:"\u2007",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvDash:"\u22ad",nVdash:"\u22ae",nVDash:"\u22af",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvHarr:"\u2904",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwarhk:"\u2923",nwarr:"\u2196",nwArr:"\u21d6",nwarrow:"\u2196",nwnear:"\u2927",oacute:"\xf3",Oacute:"\xd3",oast:"\u229b",ocir:"\u229a",ocirc:"\xf4",Ocirc:"\xd4",ocy:"\u043e",Ocy:"\u041e",odash:"\u229d",odblac:"\u0151",Odblac:"\u0150",odiv:"\u2a38",odot:"\u2299",odsold:"\u29bc",oelig:"\u0153",OElig:"\u0152",ofcir:"\u29bf",ofr:"\ud835\udd2c",Ofr:"\ud835\udd12",ogon:"\u02db",ograve:"\xf2",Ograve:"\xd2",ogt:"\u29c1",ohbar:"\u29b5",ohm:"\u03a9",oint:"\u222e",olarr:"\u21ba",olcir:"\u29be",olcross:"\u29bb",oline:"\u203e",olt:"\u29c0",omacr:"\u014d",Omacr:"\u014c",omega:"\u03c9",Omega:"\u03a9",omicron:"\u03bf",Omicron:"\u039f",omid:"\u29b6",ominus:"\u2296",oopf:"\ud835\udd60",Oopf:"\ud835\udd46",opar:"\u29b7",OpenCurlyDoubleQuote:"\u201c",OpenCurlyQuote:"\u2018",operp:"\u29b9",oplus:"\u2295",or:"\u2228",Or:"\u2a54",orarr:"\u21bb",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oS:"\u24c8",oscr:"\u2134",Oscr:"\ud835\udcaa",oslash:"\xf8",Oslash:"\xd8",osol:"\u2298",otilde:"\xf5",Otilde:"\xd5",otimes:"\u2297",Otimes:"\u2a37",otimesas:"\u2a36",ouml:"\xf6",Ouml:"\xd6",ovbar:"\u233d",OverBar:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",OverParenthesis:"\u23dc",par:"\u2225",para:"\xb6",parallel:"\u2225",parsim:"\u2af3",parsl:"\u2afd",part:"\u2202",PartialD:"\u2202",pcy:"\u043f",Pcy:"\u041f",percnt:"%",period:".",permil:"\u2030",perp:"\u22a5",pertenk:"\u2031",pfr:"\ud835\udd2d",Pfr:"\ud835\udd13",phi:"\u03c6",Phi:"\u03a6",phiv:"\u03d5",phmmat:"\u2133",phone:"\u260e",pi:"\u03c0",Pi:"\u03a0",pitchfork:"\u22d4",piv:"\u03d6",planck:"\u210f",planckh:"\u210e",plankv:"\u210f",plus:"+",plusacir:"\u2a23",plusb:"\u229e",pluscir:"\u2a22",plusdo:"\u2214",plusdu:"\u2a25",pluse:"\u2a72",PlusMinus:"\xb1",plusmn:"\xb1",plussim:"\u2a26",plustwo:"\u2a27",pm:"\xb1",Poincareplane:"\u210c",pointint:"\u2a15",popf:"\ud835\udd61",Popf:"\u2119",pound:"\xa3",pr:"\u227a",Pr:"\u2abb",prap:"\u2ab7",prcue:"\u227c",pre:"\u2aaf",prE:"\u2ab3",prec:"\u227a",precapprox:"\u2ab7",preccurlyeq:"\u227c",Precedes:"\u227a",PrecedesEqual:"\u2aaf",PrecedesSlantEqual:"\u227c",PrecedesTilde:"\u227e",preceq:"\u2aaf",precnapprox:"\u2ab9",precneqq:"\u2ab5",precnsim:"\u22e8",precsim:"\u227e",prime:"\u2032",Prime:"\u2033",primes:"\u2119",prnap:"\u2ab9",prnE:"\u2ab5",prnsim:"\u22e8",prod:"\u220f",Product:"\u220f",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prop:"\u221d",Proportion:"\u2237",Proportional:"\u221d",propto:"\u221d",prsim:"\u227e",prurel:"\u22b0",pscr:"\ud835\udcc5",Pscr:"\ud835\udcab",psi:"\u03c8",Psi:"\u03a8",puncsp:"\u2008",qfr:"\ud835\udd2e",Qfr:"\ud835\udd14",qint:"\u2a0c",qopf:"\ud835\udd62",Qopf:"\u211a",qprime:"\u2057",qscr:"\ud835\udcc6",Qscr:"\ud835\udcac",quaternions:"\u210d",quatint:"\u2a16",quest:"?",questeq:"\u225f",quot:'"',QUOT:'"',rAarr:"\u21db",race:"\u223d\u0331",racute:"\u0155",Racute:"\u0154",radic:"\u221a",raemptyv:"\u29b3",rang:"\u27e9",Rang:"\u27eb",rangd:"\u2992",range:"\u29a5",rangle:"\u27e9",raquo:"\xbb",rarr:"\u2192",rArr:"\u21d2",Rarr:"\u21a0",rarrap:"\u2975",rarrb:"\u21e5",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrhk:"\u21aa",rarrlp:"\u21ac",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",Rarrtl:"\u2916",rarrw:"\u219d",ratail:"\u291a",rAtail:"\u291c",ratio:"\u2236",rationals:"\u211a",rbarr:"\u290d",rBarr:"\u290f",RBarr:"\u2910",rbbrk:"\u2773",rbrace:"}",rbrack:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",Rcaron:"\u0158",rcedil:"\u0157",Rcedil:"\u0156",rceil:"\u2309",rcub:"}",rcy:"\u0440",Rcy:"\u0420",rdca:"\u2937",rdldhar:"\u2969",rdquo:"\u201d",rdquor:"\u201d",rdsh:"\u21b3",Re:"\u211c",real:"\u211c",realine:"\u211b",realpart:"\u211c",reals:"\u211d",rect:"\u25ad",reg:"\xae",REG:"\xae",ReverseElement:"\u220b",ReverseEquilibrium:"\u21cb",ReverseUpEquilibrium:"\u296f",rfisht:"\u297d",rfloor:"\u230b",rfr:"\ud835\udd2f",Rfr:"\u211c",rHar:"\u2964",rhard:"\u21c1",rharu:"\u21c0",rharul:"\u296c",rho:"\u03c1",Rho:"\u03a1",rhov:"\u03f1",RightAngleBracket:"\u27e9",rightarrow:"\u2192",Rightarrow:"\u21d2",RightArrow:"\u2192",RightArrowBar:"\u21e5",RightArrowLeftArrow:"\u21c4",rightarrowtail:"\u21a3",RightCeiling:"\u2309",RightDoubleBracket:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rightharpoondown:"\u21c1",rightharpoonup:"\u21c0",rightleftarrows:"\u21c4",rightleftharpoons:"\u21cc",rightrightarrows:"\u21c9",rightsquigarrow:"\u219d",RightTee:"\u22a2",RightTeeArrow:"\u21a6",RightTeeVector:"\u295b",rightthreetimes:"\u22cc",RightTriangle:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",RightVectorBar:"\u2953",ring:"\u02da",risingdotseq:"\u2253",rlarr:"\u21c4",rlhar:"\u21cc",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",robrk:"\u27e7",ropar:"\u2986",ropf:"\ud835\udd63",Ropf:"\u211d",roplus:"\u2a2e",rotimes:"\u2a35",RoundImplies:"\u2970",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rrarr:"\u21c9",Rrightarrow:"\u21db",rsaquo:"\u203a",rscr:"\ud835\udcc7",Rscr:"\u211b",rsh:"\u21b1",Rsh:"\u21b1",rsqb:"]",rsquo:"\u2019",rsquor:"\u2019",rthree:"\u22cc",rtimes:"\u22ca",rtri:"\u25b9",rtrie:"\u22b5",rtrif:"\u25b8",rtriltri:"\u29ce",RuleDelayed:"\u29f4",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",Sacute:"\u015a",sbquo:"\u201a",sc:"\u227b",Sc:"\u2abc",scap:"\u2ab8",scaron:"\u0161",Scaron:"\u0160",sccue:"\u227d",sce:"\u2ab0",scE:"\u2ab4",scedil:"\u015f",Scedil:"\u015e",scirc:"\u015d",Scirc:"\u015c",scnap:"\u2aba",scnE:"\u2ab6",scnsim:"\u22e9",scpolint:"\u2a13",scsim:"\u227f",scy:"\u0441",Scy:"\u0421",sdot:"\u22c5",sdotb:"\u22a1",sdote:"\u2a66",searhk:"\u2925",searr:"\u2198",seArr:"\u21d8",searrow:"\u2198",sect:"\xa7",semi:";",seswar:"\u2929",setminus:"\u2216",setmn:"\u2216",sext:"\u2736",sfr:"\ud835\udd30",Sfr:"\ud835\udd16",sfrown:"\u2322",sharp:"\u266f",shchcy:"\u0449",SHCHcy:"\u0429",shcy:"\u0448",SHcy:"\u0428",ShortDownArrow:"\u2193",ShortLeftArrow:"\u2190",shortmid:"\u2223",shortparallel:"\u2225",ShortRightArrow:"\u2192",ShortUpArrow:"\u2191",shy:"\xad",sigma:"\u03c3",Sigma:"\u03a3",sigmaf:"\u03c2",sigmav:"\u03c2",sim:"\u223c",simdot:"\u2a6a",sime:"\u2243",simeq:"\u2243",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",slarr:"\u2190",SmallCircle:"\u2218",smallsetminus:"\u2216",smashp:"\u2a33",smeparsl:"\u29e4",smid:"\u2223",smile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",SOFTcy:"\u042c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",Sopf:"\ud835\udd4a",spades:"\u2660",spadesuit:"\u2660",spar:"\u2225",sqcap:"\u2293",sqcaps:"\u2293\ufe00",sqcup:"\u2294",sqcups:"\u2294\ufe00",Sqrt:"\u221a",sqsub:"\u228f",sqsube:"\u2291",sqsubset:"\u228f",sqsubseteq:"\u2291",sqsup:"\u2290",sqsupe:"\u2292",sqsupset:"\u2290",sqsupseteq:"\u2292",squ:"\u25a1",square:"\u25a1",Square:"\u25a1",SquareIntersection:"\u2293",SquareSubset:"\u228f",SquareSubsetEqual:"\u2291",SquareSuperset:"\u2290",SquareSupersetEqual:"\u2292",SquareUnion:"\u2294",squarf:"\u25aa",squf:"\u25aa",srarr:"\u2192",sscr:"\ud835\udcc8",Sscr:"\ud835\udcae",ssetmn:"\u2216",ssmile:"\u2323",sstarf:"\u22c6",star:"\u2606",Star:"\u22c6",starf:"\u2605",straightepsilon:"\u03f5",straightphi:"\u03d5",strns:"\xaf",sub:"\u2282",Sub:"\u22d0",subdot:"\u2abd",sube:"\u2286",subE:"\u2ac5",subedot:"\u2ac3",submult:"\u2ac1",subne:"\u228a",subnE:"\u2acb",subplus:"\u2abf",subrarr:"\u2979",subset:"\u2282",Subset:"\u22d0",subseteq:"\u2286",subseteqq:"\u2ac5",SubsetEqual:"\u2286",subsetneq:"\u228a",subsetneqq:"\u2acb",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",succ:"\u227b",succapprox:"\u2ab8",succcurlyeq:"\u227d",Succeeds:"\u227b",SucceedsEqual:"\u2ab0",SucceedsSlantEqual:"\u227d",SucceedsTilde:"\u227f",succeq:"\u2ab0",succnapprox:"\u2aba",succneqq:"\u2ab6",succnsim:"\u22e9",succsim:"\u227f",SuchThat:"\u220b",sum:"\u2211",Sum:"\u2211",sung:"\u266a",sup:"\u2283",Sup:"\u22d1",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supdot:"\u2abe",supdsub:"\u2ad8",supe:"\u2287",supE:"\u2ac6",supedot:"\u2ac4",Superset:"\u2283",SupersetEqual:"\u2287",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supne:"\u228b",supnE:"\u2acc",supplus:"\u2ac0",supset:"\u2283",Supset:"\u22d1",supseteq:"\u2287",supseteqq:"\u2ac6",supsetneq:"\u228b",supsetneqq:"\u2acc",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swarhk:"\u2926",swarr:"\u2199",swArr:"\u21d9",swarrow:"\u2199",swnwar:"\u292a",szlig:"\xdf",Tab:"\t",target:"\u2316",tau:"\u03c4",Tau:"\u03a4",tbrk:"\u23b4",tcaron:"\u0165",Tcaron:"\u0164",tcedil:"\u0163",Tcedil:"\u0162",tcy:"\u0442",Tcy:"\u0422",tdot:"\u20db",telrec:"\u2315",tfr:"\ud835\udd31",Tfr:"\ud835\udd17",there4:"\u2234",therefore:"\u2234",Therefore:"\u2234",theta:"\u03b8",Theta:"\u0398",thetasym:"\u03d1",thetav:"\u03d1",thickapprox:"\u2248",thicksim:"\u223c",ThickSpace:"\u205f\u200a",thinsp:"\u2009",ThinSpace:"\u2009",thkap:"\u2248",thksim:"\u223c",thorn:"\xfe",THORN:"\xde",tilde:"\u02dc",Tilde:"\u223c",TildeEqual:"\u2243",TildeFullEqual:"\u2245",TildeTilde:"\u2248",times:"\xd7",timesb:"\u22a0",timesbar:"\u2a31",timesd:"\u2a30",tint:"\u222d",toea:"\u2928",top:"\u22a4",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",Topf:"\ud835\udd4b",topfork:"\u2ada",tosa:"\u2929",tprime:"\u2034",trade:"\u2122",TRADE:"\u2122",triangle:"\u25b5",triangledown:"\u25bf",triangleleft:"\u25c3",trianglelefteq:"\u22b4",triangleq:"\u225c",triangleright:"\u25b9",trianglerighteq:"\u22b5",tridot:"\u25ec",trie:"\u225c",triminus:"\u2a3a",TripleDot:"\u20db",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",Tscr:"\ud835\udcaf",tscy:"\u0446",TScy:"\u0426",tshcy:"\u045b",TSHcy:"\u040b",tstrok:"\u0167",Tstrok:"\u0166",twixt:"\u226c",twoheadleftarrow:"\u219e",twoheadrightarrow:"\u21a0",uacute:"\xfa",Uacute:"\xda",uarr:"\u2191",uArr:"\u21d1",Uarr:"\u219f",Uarrocir:"\u2949",ubrcy:"\u045e",Ubrcy:"\u040e",ubreve:"\u016d",Ubreve:"\u016c",ucirc:"\xfb",Ucirc:"\xdb",ucy:"\u0443",Ucy:"\u0423",udarr:"\u21c5",udblac:"\u0171",Udblac:"\u0170",udhar:"\u296e",ufisht:"\u297e",ufr:"\ud835\udd32",Ufr:"\ud835\udd18",ugrave:"\xf9",Ugrave:"\xd9",uHar:"\u2963",uharl:"\u21bf",uharr:"\u21be",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",Umacr:"\u016a",uml:"\xa8",UnderBar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",UnionPlus:"\u228e",uogon:"\u0173",Uogon:"\u0172",uopf:"\ud835\udd66",Uopf:"\ud835\udd4c",uparrow:"\u2191",Uparrow:"\u21d1",UpArrow:"\u2191",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",updownarrow:"\u2195",Updownarrow:"\u21d5",UpDownArrow:"\u2195",UpEquilibrium:"\u296e",upharpoonleft:"\u21bf",upharpoonright:"\u21be",uplus:"\u228e",UpperLeftArrow:"\u2196",UpperRightArrow:"\u2197",upsi:"\u03c5",Upsi:"\u03d2",upsih:"\u03d2",upsilon:"\u03c5",Upsilon:"\u03a5",UpTee:"\u22a5",UpTeeArrow:"\u21a5",upuparrows:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",Uring:"\u016e",urtri:"\u25f9",uscr:"\ud835\udcca",Uscr:"\ud835\udcb0",utdot:"\u22f0",utilde:"\u0169",Utilde:"\u0168",utri:"\u25b5",utrif:"\u25b4",uuarr:"\u21c8",uuml:"\xfc",Uuml:"\xdc",uwangle:"\u29a7",vangrt:"\u299c",varepsilon:"\u03f5",varkappa:"\u03f0",varnothing:"\u2205",varphi:"\u03d5",varpi:"\u03d6",varpropto:"\u221d",varr:"\u2195",vArr:"\u21d5",varrho:"\u03f1",varsigma:"\u03c2",varsubsetneq:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vartheta:"\u03d1",vartriangleleft:"\u22b2",vartriangleright:"\u22b3",vBar:"\u2ae8",Vbar:"\u2aeb",vBarv:"\u2ae9",vcy:"\u0432",Vcy:"\u0412",vdash:"\u22a2",vDash:"\u22a8",Vdash:"\u22a9",VDash:"\u22ab",Vdashl:"\u2ae6",vee:"\u2228",Vee:"\u22c1",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",verbar:"|",Verbar:"\u2016",vert:"|",Vert:"\u2016",VerticalBar:"\u2223",VerticalLine:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",VeryThinSpace:"\u200a",vfr:"\ud835\udd33",Vfr:"\ud835\udd19",vltri:"\u22b2",vnsub:"\u2282\u20d2",vnsup:"\u2283\u20d2",vopf:"\ud835\udd67",Vopf:"\ud835\udd4d",vprop:"\u221d",vrtri:"\u22b3",vscr:"\ud835\udccb",Vscr:"\ud835\udcb1",vsubne:"\u228a\ufe00",vsubnE:"\u2acb\ufe00",vsupne:"\u228b\ufe00",vsupnE:"\u2acc\ufe00",Vvdash:"\u22aa",vzigzag:"\u299a",wcirc:"\u0175",Wcirc:"\u0174",wedbar:"\u2a5f",wedge:"\u2227",Wedge:"\u22c0",wedgeq:"\u2259",weierp:"\u2118",wfr:"\ud835\udd34",Wfr:"\ud835\udd1a",wopf:"\ud835\udd68",Wopf:"\ud835\udd4e",wp:"\u2118",wr:"\u2240",wreath:"\u2240",wscr:"\ud835\udccc",Wscr:"\ud835\udcb2",xcap:"\u22c2",xcirc:"\u25ef",xcup:"\u22c3",xdtri:"\u25bd",xfr:"\ud835\udd35",Xfr:"\ud835\udd1b",xharr:"\u27f7",xhArr:"\u27fa",xi:"\u03be",Xi:"\u039e",xlarr:"\u27f5",xlArr:"\u27f8",xmap:"\u27fc",xnis:"\u22fb",xodot:"\u2a00",xopf:"\ud835\udd69",Xopf:"\ud835\udd4f",xoplus:"\u2a01",xotime:"\u2a02",xrarr:"\u27f6",xrArr:"\u27f9",xscr:"\ud835\udccd",Xscr:"\ud835\udcb3",xsqcup:"\u2a06",xuplus:"\u2a04",xutri:"\u25b3",xvee:"\u22c1",xwedge:"\u22c0",yacute:"\xfd",Yacute:"\xdd",yacy:"\u044f",YAcy:"\u042f",ycirc:"\u0177",Ycirc:"\u0176",ycy:"\u044b",Ycy:"\u042b",yen:"\xa5",yfr:"\ud835\udd36",Yfr:"\ud835\udd1c",yicy:"\u0457",YIcy:"\u0407",yopf:"\ud835\udd6a",Yopf:"\ud835\udd50",yscr:"\ud835\udcce",Yscr:"\ud835\udcb4",yucy:"\u044e",YUcy:"\u042e",yuml:"\xff",Yuml:"\u0178",zacute:"\u017a",Zacute:"\u0179",zcaron:"\u017e",Zcaron:"\u017d",zcy:"\u0437",Zcy:"\u0417",zdot:"\u017c",Zdot:"\u017b",zeetrf:"\u2128",ZeroWidthSpace:"\u200b",zeta:"\u03b6",Zeta:"\u0396",zfr:"\ud835\udd37",Zfr:"\u2128",zhcy:"\u0436",ZHcy:"\u0416",zigrarr:"\u21dd",zopf:"\ud835\udd6b",Zopf:"\u2124",zscr:"\ud835\udccf",Zscr:"\ud835\udcb5",zwj:"\u200d",zwnj:"\u200c"},h={aacute:"\xe1",Aacute:"\xc1",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",aelig:"\xe6",AElig:"\xc6",agrave:"\xe0",Agrave:"\xc0",amp:"&",AMP:"&",aring:"\xe5",Aring:"\xc5",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",brvbar:"\xa6",ccedil:"\xe7",Ccedil:"\xc7",cedil:"\xb8",cent:"\xa2",copy:"\xa9",COPY:"\xa9",curren:"\xa4",deg:"\xb0",divide:"\xf7",eacute:"\xe9",Eacute:"\xc9",ecirc:"\xea",Ecirc:"\xca",egrave:"\xe8",Egrave:"\xc8",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",frac12:"\xbd",frac14:"\xbc",frac34:"\xbe",gt:">",GT:">",iacute:"\xed",Iacute:"\xcd",icirc:"\xee",Icirc:"\xce",iexcl:"\xa1",igrave:"\xec",Igrave:"\xcc",iquest:"\xbf",iuml:"\xef",Iuml:"\xcf",laquo:"\xab",lt:"<",LT:"<",macr:"\xaf",micro:"\xb5",middot:"\xb7",nbsp:"\xa0",not:"\xac",ntilde:"\xf1",Ntilde:"\xd1",oacute:"\xf3",Oacute:"\xd3",ocirc:"\xf4",Ocirc:"\xd4",ograve:"\xf2",Ograve:"\xd2",ordf:"\xaa",ordm:"\xba",oslash:"\xf8",Oslash:"\xd8",otilde:"\xf5",Otilde:"\xd5",ouml:"\xf6",Ouml:"\xd6",para:"\xb6",plusmn:"\xb1",pound:"\xa3",quot:'"',QUOT:'"',raquo:"\xbb",reg:"\xae",REG:"\xae",sect:"\xa7",shy:"\xad",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",szlig:"\xdf",thorn:"\xfe",THORN:"\xde",times:"\xd7",uacute:"\xfa",Uacute:"\xda",ucirc:"\xfb",Ucirc:"\xdb",ugrave:"\xf9",Ugrave:"\xd9",uml:"\xa8",uuml:"\xfc",Uuml:"\xdc",yacute:"\xfd",Yacute:"\xdd",yen:"\xa5",yuml:"\xff"},g={0:"\ufffd",128:"\u20ac",130:"\u201a",131:"\u0192",132:"\u201e",133:"\u2026",134:"\u2020",135:"\u2021",136:"\u02c6",137:"\u2030",138:"\u0160",139:"\u2039",140:"\u0152",142:"\u017d",145:"\u2018",146:"\u2019",147:"\u201c",148:"\u201d",149:"\u2022",150:"\u2013",151:"\u2014",152:"\u02dc",153:"\u2122",154:"\u0161",155:"\u203a",156:"\u0153",158:"\u017e",159:"\u0178"},b=[1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65e3,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111],y=String.fromCharCode,v={}.hasOwnProperty,w=function(e,t){return v.call(e,t)},A=function(e,t){if(!e)return t;var r,n={};for(r in t)n[r]=w(e,r)?e[r]:t[r];return n},D=function(e,t){var r="";return e>=55296&&e<=57343||e>1114111?(t&&$("character reference outside the permissible Unicode range"),"\ufffd"):w(g,e)?(t&&$("disallowed character reference"),g[e]):(t&&function(e,t){for(var r=-1,n=e.length;++r<n;)if(e[r]==t)return!0;return!1}(b,e)&&$("disallowed character reference"),e>65535&&(r+=y((e-=65536)>>>10&1023|55296),e=56320|1023&e),r+=y(e))},x=function(e){return"&#x"+e.toString(16).toUpperCase()+";"},q=function(e){return"&#"+e+";"},$=function(e){throw Error("Parse error: "+e)},k=function(e,t){(t=A(t,k.options)).strict&&d.test(e)&&$("forbidden code point");var r=t.encodeEverything,n=t.useNamedReferences,u=t.allowUnsafeSymbols,p=t.decimal?q:x,f=function(e){return p(e.charCodeAt(0))};return r?(e=e.replace(s,function(e){return n&&w(c,e)?"&"+c[e]+";":f(e)}),n&&(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;").replace(/&#x66;&#x6A;/g,"&fjlig;")),n&&(e=e.replace(i,function(e){return"&"+c[e]+";"}))):n?(u||(e=e.replace(l,function(e){return"&"+c[e]+";"})),e=(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;")).replace(i,function(e){return"&"+c[e]+";"})):u||(e=e.replace(l,f)),e.replace(o,function(e){var t=e.charCodeAt(0),r=e.charCodeAt(1);return p(1024*(t-55296)+r-56320+65536)}).replace(a,f)};k.options={allowUnsafeSymbols:!1,encodeEverything:!1,strict:!1,useNamedReferences:!1,decimal:!1};var E=function(e,t){var r=(t=A(t,E.options)).strict;return r&&p.test(e)&&$("malformed character reference"),e.replace(f,function(e,n,o,s,a,i,c,l,u){var p,d,f,g,b,y;return n?m[b=n]:o?(b=o,(y=s)&&t.isAttributeValue?(r&&"="==y&&$("`&` did not start a character reference"),e):(r&&$("named character reference was not terminated by a semicolon"),h[b]+(y||""))):a?(f=a,d=i,r&&!d&&$("character reference was not terminated by a semicolon"),p=parseInt(f,10),D(p,r)):c?(g=c,d=l,r&&!d&&$("character reference was not terminated by a semicolon"),p=parseInt(g,16),D(p,r)):(r&&$("named character reference was not terminated by a semicolon"),e)})};E.options={isAttributeValue:!1,strict:!1};var _={version:"1.2.0",encode:k,decode:E,escape:function(e){return e.replace(l,function(e){return u[e]})},unescape:E};if("function"==typeof define&&"object"==typeof define.amd&&define.amd)define(function(){return _});else if(t&&!t.nodeType)if(r)r.exports=_;else for(var C in _)w(_,C)&&(t[C]=_[C]);else e.he=_}(void 0);const fs=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),ms=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),hs=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),gs=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,bs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ys=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${U.source}]*`,vs=`((?:${ys}\\:)?${ys})`,ws=new RegExp(`^<${vs}`),As=/^\s*(\/?)>/,Ds=new RegExp(`^<\\/${vs}[^>]*>`),xs=/^<!DOCTYPE [^>]+>/i,qs=/^<!\--/,$s=/^<!\[/,ks=d("script,style,textarea",!0),Es={},_s={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Cs=/&(?:lt|gt|quot|amp|#39);/g,Ss=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ls=d("pre,textarea",!0),Ts=(e,t)=>e&&Ls(e)&&"\n"===t[0];function Ns(e,t){const r=t?Ss:Cs;return e.replace(r,e=>_s[e])}const Os=/^@|^v-on:/,Rs=/^v-|^@|^:|^#/,Fs=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Bs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Us=/^\(|\)$/g,Vs=/^\[.*\]$/,Is=/:(.*)$/,js=/^:|^\.|^v-bind:/,Ps=/\.[^.\]]+(?=[^\]]*$)/g,Hs=/^v-slot(:|$)|^#/,Ms=/[\r\n]/,Gs=/[ \f\t\r\n]+/g,zs=y(void 0),Js="_empty_";let Ks,Zs,Ys,Ws,Qs,Xs,ea,ta;function ra(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:la(t),rawAttrsMap:{},parent:r,children:[]}}function na(e,t){Ks=t.warn||bn,Xs=t.isPreTag||C,ea=t.mustUseProp||C,ta=t.getTagNamespace||C;t.isReservedTag;Ys=yn(t.modules,"transformNode"),Ws=yn(t.modules,"preTransformNode"),Qs=yn(t.modules,"postTransformNode"),Zs=t.delimiters;const r=[],n=!1!==t.preserveWhitespace,o=t.whitespace;let s,a,i=!1,c=!1;function l(e){if(u(e),i||e.processed||(e=oa(e,t)),r.length||e===s||s.if&&(e.elseif||e.else)&&aa(s,{exp:e.elseif,block:e}),a&&!e.forbidden)if(e.elseif||e.else)!function(e,t){const r=function(e){let t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(t.children);r&&r.if&&aa(r,{exp:e.elseif,block:e})}(e,a);else{if(e.slotScope){const t=e.slotTarget||'"default"';(a.scopedSlots||(a.scopedSlots={}))[t]=e}a.children.push(e),e.parent=a}e.children=e.children.filter(e=>!e.slotScope),u(e),e.pre&&(i=!1),Xs(e.tag)&&(c=!1);for(let r=0;r<Qs.length;r++)Qs[r](e,t)}function u(e){if(!c){let t;for(;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}}return function(e,t){const r=[],n=t.expectHTML,o=t.isUnaryTag||C,s=t.canBeLeftOpenTag||C;let a,i,c=0;for(;e;){if(a=e,i&&ks(i)){let r=0;const n=i.toLowerCase(),o=Es[n]||(Es[n]=new RegExp("([\\s\\S]*?)(</"+n+"[^>]*>)","i")),s=e.replace(o,function(e,o,s){return r=s.length,ks(n)||"noscript"===n||(o=o.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ts(n,o)&&(o=o.slice(1)),t.chars&&t.chars(o),""});c+=e.length-s.length,e=s,d(n,c-r,c)}else{let r,n,o,s=e.indexOf("<");if(0===s){if(qs.test(e)){const r=e.indexOf("--\x3e");if(r>=0){t.shouldKeepComment&&t.comment(e.substring(4,r),c,c+r+3),l(r+3);continue}}if($s.test(e)){const t=e.indexOf("]>");if(t>=0){l(t+2);continue}}const r=e.match(xs);if(r){l(r[0].length);continue}const n=e.match(Ds);if(n){const e=c;l(n[0].length),d(n[1],e,c);continue}const o=u();if(o){p(o),Ts(o.tagName,e)&&l(1);continue}}if(s>=0){for(n=e.slice(s);!(Ds.test(n)||ws.test(n)||qs.test(n)||$s.test(n)||(o=n.indexOf("<",1))<0);)s+=o,n=e.slice(s);r=e.substring(0,s)}s<0&&(r=e),r&&l(r.length),t.chars&&r&&t.chars(r,c-r.length,c)}if(e===a){t.chars&&t.chars(e);break}}function l(t){c+=t,e=e.substring(t)}function u(){const t=e.match(ws);if(t){const r={tagName:t[1],attrs:[],start:c};let n,o;for(l(t[0].length);!(n=e.match(As))&&(o=e.match(bs)||e.match(gs));)o.start=c,l(o[0].length),o.end=c,r.attrs.push(o);if(n)return r.unarySlash=n[1],l(n[0].length),r.end=c,r}}function p(e){const a=e.tagName,c=e.unarySlash;n&&("p"===i&&hs(a)&&d(i),s(a)&&i===a&&d(a));const l=o(a)||!!c,u=e.attrs.length,p=new Array(u);for(let r=0;r<u;r++){const n=e.attrs[r],o=n[3]||n[4]||n[5]||"",s="a"===a&&"href"===n[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[r]={name:n[1],value:Ns(o,s)}}l||(r.push({tag:a,lowerCasedTag:a.toLowerCase(),attrs:p,start:e.start,end:e.end}),i=a),t.start&&t.start(a,p,l,e.start,e.end)}function d(e,n,o){let s,a;if(null==n&&(n=c),null==o&&(o=c),e)for(a=e.toLowerCase(),s=r.length-1;s>=0&&r[s].lowerCasedTag!==a;s--);else s=0;if(s>=0){for(let e=r.length-1;e>=s;e--)t.end&&t.end(r[e].tag,n,o);r.length=s,i=s&&r[s-1].tag}else"br"===a?t.start&&t.start(e,[],!0,n,o):"p"===a&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}d()}(e,{warn:Ks,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start(e,n,o,u,p){const d=a&&a.ns||ta(e);J&&"svg"===d&&(n=function(e){const t=[];for(let r=0;r<e.length;r++){const n=e[r];ua.test(n.name)||(n.name=n.name.replace(pa,""),t.push(n))}return t}(n));let f=ra(e,n,a);var m;d&&(f.ns=d),"style"!==(m=f).tag&&("script"!==m.tag||m.attrsMap.type&&"text/javascript"!==m.attrsMap.type)||te()||(f.forbidden=!0);for(let e=0;e<Ws.length;e++)f=Ws[e](f,t)||f;i||(!function(e){null!=kn(e,"v-pre")&&(e.pre=!0)}(f),f.pre&&(i=!0)),Xs(f.tag)&&(c=!0),i?function(e){const t=e.attrsList,r=t.length;if(r){const n=e.attrs=new Array(r);for(let e=0;e<r;e++)n[e]={name:t[e].name,value:JSON.stringify(t[e].value)},null!=t[e].start&&(n[e].start=t[e].start,n[e].end=t[e].end)}else e.pre||(e.plain=!0)}(f):f.processed||(sa(f),function(e){const t=kn(e,"v-if");if(t)e.if=t,aa(e,{exp:t,block:e});else{null!=kn(e,"v-else")&&(e.else=!0);const t=kn(e,"v-else-if");t&&(e.elseif=t)}}(f),function(e){null!=kn(e,"v-once")&&(e.once=!0)}(f)),s||(s=f),o?l(f):(a=f,r.push(f))},end(e,t,n){const o=r[r.length-1];r.length-=1,a=r[r.length-1],l(o)},chars(e,t,r){if(!a)return;if(J&&"textarea"===a.tag&&a.attrsMap.placeholder===e)return;const s=a.children;var l;if(e=c||e.trim()?"script"===(l=a).tag||"style"===l.tag?e:zs(e):s.length?o?"condense"===o&&Ms.test(e)?"":" ":n?" ":"":""){let t,r;c||"condense"!==o||(e=e.replace(Gs," ")),!i&&" "!==e&&(t=function(e,t){const r=t?us(t):cs;if(!r.test(e))return;const n=[],o=[];let s,a,i,c=r.lastIndex=0;for(;s=r.exec(e);){(a=s.index)>c&&(o.push(i=e.slice(c,a)),n.push(JSON.stringify(i)));const t=hn(s[1].trim());n.push(`_s(${t})`),o.push({"@binding":t}),c=a+s[0].length}return c<e.length&&(o.push(i=e.slice(c)),n.push(JSON.stringify(i))),{expression:n.join("+"),tokens:o}}(e,Zs))?r={type:2,expression:t.expression,tokens:t.tokens,text:e}:" "===e&&s.length&&" "===s[s.length-1].text||(r={type:3,text:e}),r&&s.push(r)}},comment(e,t,r){if(a){const t={type:3,text:e,isComment:!0};a.children.push(t)}}}),s}function oa(e,t){var r;!function(e){const t=$n(e,"key");t&&(e.key=t)}(e),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){const t=$n(e,"ref");t&&(e.ref=t,e.refInFor=function(e){let t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){let t;"template"===e.tag?(t=kn(e,"scope"),e.slotScope=t||kn(e,"slot-scope")):(t=kn(e,"slot-scope"))&&(e.slotScope=t);const r=$n(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||wn(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){const t=En(e,Hs);if(t){const{name:r,dynamic:n}=ia(t);e.slotTarget=r,e.slotTargetDynamic=n,e.slotScope=t.value||Js}}else{const t=En(e,Hs);if(t){const r=e.scopedSlots||(e.scopedSlots={}),{name:n,dynamic:o}=ia(t),s=r[n]=ra("template",[],e);s.slotTarget=n,s.slotTargetDynamic=o,s.children=e.children.filter(e=>{if(!e.slotScope)return e.parent=s,!0}),s.slotScope=t.value||Js,e.children=[],e.plain=!1}}}(e),"slot"===(r=e).tag&&(r.slotName=$n(r,"name")),function(e){let t;(t=$n(e,"is"))&&(e.component=t);null!=kn(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(let r=0;r<Ys.length;r++)e=Ys[r](e,t)||e;return function(e){const t=e.attrsList;let r,n,o,s,a,i,c,l;for(r=0,n=t.length;r<n;r++)if(o=s=t[r].name,a=t[r].value,Rs.test(o))if(e.hasBindings=!0,(i=ca(o.replace(Rs,"")))&&(o=o.replace(Ps,"")),js.test(o))o=o.replace(js,""),a=hn(a),(l=Vs.test(o))&&(o=o.slice(1,-1)),i&&(i.prop&&!l&&"innerHtml"===(o=w(o))&&(o="innerHTML"),i.camel&&!l&&(o=w(o)),i.sync&&(c=Sn(a,"$event"),l?qn(e,`"update:"+(${o})`,c,null,!1,0,t[r],!0):(qn(e,`update:${w(o)}`,c,null,!1,0,t[r]),x(o)!==w(o)&&qn(e,`update:${x(o)}`,c,null,!1,0,t[r])))),i&&i.prop||!e.component&&ea(e.tag,e.attrsMap.type,o)?vn(e,o,a,t[r],l):wn(e,o,a,t[r],l);else if(Os.test(o))o=o.replace(Os,""),(l=Vs.test(o))&&(o=o.slice(1,-1)),qn(e,o,a,i,!1,0,t[r],l);else{const n=(o=o.replace(Rs,"")).match(Is);let c=n&&n[1];l=!1,c&&(o=o.slice(0,-(c.length+1)),Vs.test(c)&&(c=c.slice(1,-1),l=!0)),Dn(e,o,s,a,c,l,i,t[r])}else wn(e,o,JSON.stringify(a),t[r]),!e.component&&"muted"===o&&ea(e.tag,e.attrsMap.type,o)&&vn(e,o,"true",t[r])}(e),e}function sa(e){let t;if(t=kn(e,"v-for")){const r=function(e){const t=e.match(Fs);if(!t)return;const r={};r.for=t[2].trim();const n=t[1].trim().replace(Us,""),o=n.match(Bs);o?(r.alias=n.replace(Bs,"").trim(),r.iterator1=o[1].trim(),o[2]&&(r.iterator2=o[2].trim())):r.alias=n;return r}(t);r&&k(e,r)}}function aa(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function ia(e){let t=e.name.replace(Hs,"");return t||"#"!==e.name[0]&&(t="default"),Vs.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:`"${t}"`,dynamic:!1}}function ca(e){const t=e.match(Ps);if(t){const e={};return t.forEach(t=>{e[t.slice(1)]=!0}),e}}function la(e){const t={};for(let r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}const ua=/^xmlns:NS\d+/,pa=/^NS\d+:/;function da(e){return ra(e.tag,e.attrsList.slice(),e.parent)}var fa=[ps,ds,{preTransformNode:function(e,t){if("input"===e.tag){const r=e.attrsMap;if(!r["v-model"])return;let n;if((r[":type"]||r["v-bind:type"])&&(n=$n(e,"type")),r.type||n||!r["v-bind"]||(n=`(${r["v-bind"]}).type`),n){const r=kn(e,"v-if",!0),o=r?`&&(${r})`:"",s=null!=kn(e,"v-else",!0),a=kn(e,"v-else-if",!0),i=da(e);sa(i),An(i,"type","checkbox"),oa(i,t),i.processed=!0,i.if=`(${n})==='checkbox'`+o,aa(i,{exp:i.if,block:i});const c=da(e);kn(c,"v-for",!0),An(c,"type","radio"),oa(c,t),aa(i,{exp:`(${n})==='radio'`+o,block:c});const l=da(e);return kn(l,"v-for",!0),An(l,":type",n),oa(l,t),aa(i,{exp:r,block:l}),s?i.else=!0:a&&(i.elseif=a),i}}}}];const ma={expectHTML:!0,modules:fa,directives:{model:function(e,t,r){const n=t.value,o=t.modifiers,s=e.tag,a=e.attrsMap.type;if(e.component)return Cn(e,n,o),!1;if("select"===s)!function(e,t,r){let n=`var $$selectedVal = ${'Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;'+`return ${r&&r.number?"_n(val)":"val"}})`};`;n=`${n} ${Sn(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,qn(e,"change",n,null,!0)}(e,n,o);else if("input"===s&&"checkbox"===a)!function(e,t,r){const n=r&&r.number,o=$n(e,"value")||"null",s=$n(e,"true-value")||"true",a=$n(e,"false-value")||"false";vn(e,"checked",`Array.isArray(${t})`+`?_i(${t},${o})>-1`+("true"===s?`:(${t})`:`:_q(${t},${s})`)),qn(e,"change",`var $$a=${t},`+"$$el=$event.target,"+`$$c=$$el.checked?(${s}):(${a});`+"if(Array.isArray($$a)){"+`var $$v=${n?"_n("+o+")":o},`+"$$i=_i($$a,$$v);"+`if($$el.checked){$$i<0&&(${Sn(t,"$$a.concat([$$v])")})}`+`else{$$i>-1&&(${Sn(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}`+`}else{${Sn(t,"$$c")}}`,null,!0)}(e,n,o);else if("input"===s&&"radio"===a)!function(e,t,r){const n=r&&r.number;let o=$n(e,"value")||"null";vn(e,"checked",`_q(${t},${o=n?`_n(${o})`:o})`),qn(e,"change",Sn(t,o),null,!0)}(e,n,o);else if("input"===s||"textarea"===s)!function(e,t,r){const n=e.attrsMap.type,{lazy:o,number:s,trim:a}=r||{},i=!o&&"range"!==n,c=o?"change":"range"===n?Pn:"input";let l="$event.target.value";a&&(l="$event.target.value.trim()"),s&&(l=`_n(${l})`);let u=Sn(t,l);i&&(u=`if($event.target.composing)return;${u}`),vn(e,"value",`(${t})`),qn(e,c,u,null,!0),(a||s)&&qn(e,"blur","$forceUpdate()")}(e,n,o);else if(!B.isReservedTag(s))return Cn(e,n,o),!1;return!0},text:function(e,t){t.value&&vn(e,"textContent",`_s(${t.value})`,t)},html:function(e,t){t.value&&vn(e,"innerHTML",`_s(${t.value})`,t)}},isPreTag:e=>"pre"===e,isUnaryTag:fs,mustUseProp:kr,canBeLeftOpenTag:ms,isReservedTag:Pr,getTagNamespace:Hr,staticKeys:function(e){return e.reduce((e,t)=>e.concat(t.staticKeys||[]),[]).join(",")}(fa)};let ha,ga;const ba=y(function(e){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ya(e,t){e&&(ha=ba(t.staticKeys||""),ga=t.isReservedTag||C,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||f(e.tag)||!ga(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(ha)))}(t);if(1===t.type){if(!ga(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let r=0,n=t.children.length;r<n;r++){const n=t.children[r];e(n),n.static||(t.static=!1)}if(t.ifConditions)for(let r=1,n=t.ifConditions.length;r<n;r++){const n=t.ifConditions[r].block;e(n),n.static||(t.static=!1)}}}(e),function e(t,r){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=r),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)e(t.children[n],r||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)e(t.ifConditions[n].block,r)}}(e,!1))}const va=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,wa=/\([^)]*?\);*$/,Aa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Da={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xa={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},qa=e=>`if(${e})return null;`,$a={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:qa("$event.target !== $event.currentTarget"),ctrl:qa("!$event.ctrlKey"),shift:qa("!$event.shiftKey"),alt:qa("!$event.altKey"),meta:qa("!$event.metaKey"),left:qa("'button' in $event && $event.button !== 0"),middle:qa("'button' in $event && $event.button !== 1"),right:qa("'button' in $event && $event.button !== 2")};function ka(e,t){const r=t?"nativeOn:":"on:";let n="",o="";for(const t in e){const r=Ea(e[t]);e[t]&&e[t].dynamic?o+=`${t},${r},`:n+=`"${t}":${r},`}return n=`{${n.slice(0,-1)}}`,o?r+`_d(${n},[${o.slice(0,-1)}])`:r+n}function Ea(e){if(!e)return"function(){}";if(Array.isArray(e))return`[${e.map(e=>Ea(e)).join(",")}]`;const t=Aa.test(e.value),r=va.test(e.value),n=Aa.test(e.value.replace(wa,""));if(e.modifiers){let o="",s="";const a=[];for(const t in e.modifiers)if($a[t])s+=$a[t],Da[t]&&a.push(t);else if("exact"===t){const t=e.modifiers;s+=qa(["ctrl","shift","alt","meta"].filter(e=>!t[e]).map(e=>`$event.${e}Key`).join("||"))}else a.push(t);return a.length&&(o+=function(e){return"if(!$event.type.indexOf('key')&&"+`${e.map(_a).join("&&")})return null;`}(a)),s&&(o+=s),`function($event){${o}${t?`return ${e.value}.apply(null, arguments)`:r?`return (${e.value}).apply(null, arguments)`:n?`return ${e.value}`:e.value}}`}return t||r?e.value:`function($event){${n?`return ${e.value}`:e.value}}`}function _a(e){const t=parseInt(e,10);if(t)return`$event.keyCode!==${t}`;const r=Da[e],n=xa[e];return"_k($event.keyCode,"+`${JSON.stringify(e)},`+`${JSON.stringify(r)},`+"$event.key,"+`${JSON.stringify(n)}`+")"}var Ca={on:function(e,t){e.wrapListeners=(e=>`_g(${e},${t.value})`)},bind:function(e,t){e.wrapData=(r=>`_b(${r},'${e.tag}',${t.value},${t.modifiers&&t.modifiers.prop?"true":"false"}${t.modifiers&&t.modifiers.sync?",true":""})`)},cloak:_};class Sa{constructor(e){this.options=e,this.warn=e.warn||bn,this.transforms=yn(e.modules,"transformCode"),this.dataGenFns=yn(e.modules,"genData"),this.directives=k(k({},Ca),e.directives);const t=e.isReservedTag||C;this.maybeComponent=(e=>!!e.component||!t(e.tag)),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function La(e,t){const r=new Sa(t);return{render:`with(this){return ${e?"script"===e.tag?"null":Ta(e,r):'_c("div")'}}`,staticRenderFns:r.staticRenderFns}}function Ta(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Na(e,t);if(e.once&&!e.onceProcessed)return Oa(e,t);if(e.for&&!e.forProcessed)return Fa(e,t);if(e.if&&!e.ifProcessed)return Ra(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){const r=e.slotName||'"default"',n=Ia(e,t);let o=`_t(${r}${n?`,${n}`:""}`;const s=e.attrs||e.dynamicAttrs?Ha((e.attrs||[]).concat(e.dynamicAttrs||[]).map(e=>({name:w(e.name),value:e.value,dynamic:e.dynamic}))):null,a=e.attrsMap["v-bind"];!s&&!a||n||(o+=",null");s&&(o+=`,${s}`);a&&(o+=`${s?"":",null"},${a}`);return o+")"}(e,t);{let r;if(e.component)r=function(e,t,r){const n=t.inlineTemplate?null:Ia(t,r,!0);return`_c(${e},${Ba(t,r)}${n?`,${n}`:""})`}(e.component,e,t);else{let n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=Ba(e,t));const o=e.inlineTemplate?null:Ia(e,t,!0);r=`_c('${e.tag}'${n?`,${n}`:""}${o?`,${o}`:""})`}for(let n=0;n<t.transforms.length;n++)r=t.transforms[n](e,r);return r}}return Ia(e,t)||"void 0"}function Na(e,t){e.staticProcessed=!0;const r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push(`with(this){return ${Ta(e,t)}}`),t.pre=r,`_m(${t.staticRenderFns.length-1}${e.staticInFor?",true":""})`}function Oa(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ra(e,t);if(e.staticInFor){let r="",n=e.parent;for(;n;){if(n.for){r=n.key;break}n=n.parent}return r?`_o(${Ta(e,t)},${t.onceId++},${r})`:Ta(e,t)}return Na(e,t)}function Ra(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,o){if(!t.length)return o||"_e()";const s=t.shift();return s.exp?`(${s.exp})?${a(s.block)}:${e(t,r,n,o)}`:`${a(s.block)}`;function a(e){return n?n(e,r):e.once?Oa(e,r):Ta(e,r)}}(e.ifConditions.slice(),t,r,n)}function Fa(e,t,r,n){const o=e.for,s=e.alias,a=e.iterator1?`,${e.iterator1}`:"",i=e.iterator2?`,${e.iterator2}`:"";return e.forProcessed=!0,`${n||"_l"}((${o}),`+`function(${s}${a}${i}){`+`return ${(r||Ta)(e,t)}`+"})"}function Ba(e,t){let r="{";const n=function(e,t){const r=e.directives;if(!r)return;let n,o,s,a,i="directives:[",c=!1;for(n=0,o=r.length;n<o;n++){s=r[n],a=!0;const o=t.directives[s.name];o&&(a=!!o(e,s,t.warn)),a&&(c=!0,i+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return i.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+=`key:${e.key},`),e.ref&&(r+=`ref:${e.ref},`),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+=`tag:"${e.tag}",`);for(let n=0;n<t.dataGenFns.length;n++)r+=t.dataGenFns[n](e);if(e.attrs&&(r+=`attrs:${Ha(e.attrs)},`),e.props&&(r+=`domProps:${Ha(e.props)},`),e.events&&(r+=`${ka(e.events,!1)},`),e.nativeEvents&&(r+=`${ka(e.nativeEvents,!0)},`),e.slotTarget&&!e.slotScope&&(r+=`slot:${e.slotTarget},`),e.scopedSlots&&(r+=`${function(e,t,r){let n=e.for||Object.keys(t).some(e=>{const r=t[e];return r.slotTargetDynamic||r.if||r.for||Ua(r)}),o=!!e.if;if(!n){let t=e.parent;for(;t;){if(t.slotScope&&t.slotScope!==Js||t.for){n=!0;break}t.if&&(o=!0),t=t.parent}}const s=Object.keys(t).map(e=>Va(t[e],r)).join(",");return`scopedSlots:_u([${s}]${n?",null,true":""}${!n&&o?`,null,false,${function(e){let t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(s)}`:""})`}(e,e.scopedSlots,t)},`),e.model&&(r+=`model:{value:${e.model.value},callback:${e.model.callback},expression:${e.model.expression}},`),e.inlineTemplate){const n=function(e,t){const r=e.children[0];if(r&&1===r.type){const e=La(r,t.options);return`inlineTemplate:{render:function(){${e.render}},staticRenderFns:[${e.staticRenderFns.map(e=>`function(){${e}}`).join(",")}]}`}}(e,t);n&&(r+=`${n},`)}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r=`_b(${r},"${e.tag}",${Ha(e.dynamicAttrs)})`),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function Ua(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ua))}function Va(e,t){const r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return Ra(e,t,Va,"null");if(e.for&&!e.forProcessed)return Fa(e,t,Va);const n=e.slotScope===Js?"":String(e.slotScope),o=`function(${n}){`+`return ${"template"===e.tag?e.if&&r?`(${e.if})?${Ia(e,t)||"undefined"}:undefined`:Ia(e,t)||"undefined":Ta(e,t)}}`,s=n?"":",proxy:true";return`{key:${e.slotTarget||'"default"'},fn:${o}${s}}`}function Ia(e,t,r,n,o){const s=e.children;if(s.length){const e=s[0];if(1===s.length&&e.for&&"template"!==e.tag&&"slot"!==e.tag){const o=r?t.maybeComponent(e)?",1":",0":"";return`${(n||Ta)(e,t)}${o}`}const a=r?function(e,t){let r=0;for(let n=0;n<e.length;n++){const o=e[n];if(1===o.type){if(ja(o)||o.ifConditions&&o.ifConditions.some(e=>ja(e.block))){r=2;break}(t(o)||o.ifConditions&&o.ifConditions.some(e=>t(e.block)))&&(r=1)}}return r}(s,t.maybeComponent):0,i=o||Pa;return`[${s.map(e=>i(e,t)).join(",")}]${a?`,${a}`:""}`}}function ja(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Pa(e,t){return 1===e.type?Ta(e,t):3===e.type&&e.isComment?(n=e,`_e(${JSON.stringify(n.text)})`):`_v(${2===(r=e).type?r.expression:Ma(JSON.stringify(r.text))})`;var r,n}function Ha(e){let t="",r="";for(let n=0;n<e.length;n++){const o=e[n],s=Ma(o.value);o.dynamic?r+=`${o.name},${s},`:t+=`"${o.name}":${s},`}return t=`{${t.slice(0,-1)}}`,r?`_d(${t},[${r.slice(0,-1)}])`:t}function Ma(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Ga(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),_}}function za(e){const t=Object.create(null);return function(r,n,o){(n=k({},n)).warn;delete n.warn;const s=n.delimiters?String(n.delimiters)+r:r;if(t[s])return t[s];const a=e(r,n),i={},c=[];return i.render=Ga(a.render,c),i.staticRenderFns=a.staticRenderFns.map(e=>Ga(e,c)),t[s]=i}}const Ja=(Ka=function(e,t){const r=na(e.trim(),t);!1!==t.optimize&&ya(r,t);const n=La(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){const n=Object.create(e),o=[],s=[];if(r){r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=k(Object.create(e.directives||null),r.directives));for(const e in r)"modules"!==e&&"directives"!==e&&(n[e]=r[e])}n.warn=((e,t,r)=>{(r?s:o).push(e)});const a=Ka(t.trim(),n);return a.errors=o,a.tips=s,a}return{compile:t,compileToFunctions:za(t)}});var Ka;const{compile:Za,compileToFunctions:Ya}=Ja(ma);let Wa;function Qa(e){return(Wa=Wa||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',Wa.innerHTML.indexOf("&#10;")>0}const Xa=!!H&&Qa(!1),ei=!!H&&Qa(!0),ti=y(e=>{const t=zr(e);return t&&t.innerHTML}),ri=gr.prototype.$mount;gr.prototype.$mount=function(e,t){if((e=e&&zr(e))===document.body||e===document.documentElement)return this;const r=this.$options;if(!r.render){let t=r.template;if(t)if("string"==typeof t)"#"===t.charAt(0)&&(t=ti(t));else{if(!t.nodeType)return this;t=t.innerHTML}else e&&(t=function(e){if(e.outerHTML)return e.outerHTML;{const t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}}(e));if(t){const{render:e,staticRenderFns:n}=Ya(t,{outputSourceRange:!1,shouldDecodeNewlines:Xa,shouldDecodeNewlinesForHref:ei,delimiters:r.delimiters,comments:r.comments},this);r.render=e,r.staticRenderFns=n}}return ri.call(this,e,t)},gr.compile=Ya;export default gr;
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index a3ca9f7e2c6..acbc5a0be94 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -1,191 +1,157 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-/*  */
-
+/* @flow */
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
-function isRegExp (v) {
-  return _toString.call(v) === '[object RegExp]'
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Capitalize a string.
  */
 var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -193,1115 +159,992 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
-function toArray (list, start) {
-  start = start || 0;
-  var i = list.length - start;
-  var ret = new Array(i);
-  while (i--) {
-    ret[i] = list[i + start];
-  }
-  return ret
+function toArray(list, start) {
+    start = start || 0;
+    var i = list.length - start;
+    var ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
 }
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys(modules) {
+    return modules
+        .reduce(function (keys, m) {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
+function looseEqual(a, b) {
+    if (a === b)
+        { return true; }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every(function (e, i) {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every(function (key) {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
     }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (var i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            { return i; }
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
+function once(fn) {
+    var called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
 var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Check if a string starts with $ or _
  */
-function isReserved (str) {
-  var c = (str + '').charCodeAt(0);
-  return c === 0x24 || c === 0x5F
+function isReserved(str) {
+    var c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
 }
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
-
 /**
  * Parse simple path.
  */
 var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-function parsePath (path) {
-  if (bailRE.test(path)) {
-    return
-  }
-  var segments = path.split('.');
-  return function (obj) {
-    for (var i = 0; i < segments.length; i++) {
-      if (!obj) { return }
-      obj = obj[segments[i]];
-    }
-    return obj
-  }
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    var segments = path.split('.');
+    return function (obj) {
+        for (var i = 0; i < segments.length; i++) {
+            if (!obj)
+                { return; }
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 var isPhantomJS = UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
-
+// @ts-ignore
+var nativeWatch = {}.watch;
 var supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-        /* istanbul ignore next */
-        supportsPassive = true;
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/(function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function has (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function add (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function clear () {
+            this.set = Object.create(null);
+        };
 
-    return Set;
-  }());
+        return Set;
+    }());
 }
 
-/*  */
-
+/* @flow */
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace);
-    } else if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
-}
-
-/*  */
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
+    };
+    var repeat = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
+                    .join('\n'));
+        }
+        else {
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+        }
+    };
+}
 
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
 };
-
 Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
+    this.subs.push(sub);
 };
-
 Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
+    remove(this.subs, sub);
 };
-
 Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
+    if (Dep.target) {
+        Dep.target.addDep(this);
+    }
 };
-
 Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
 };
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
-}
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
-}
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
+}
+
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
 };
 
 var prototypeAccessors = { child: { configurable: true } };
-
 // DEPRECATED: alias for componentInstance for backwards compat.
 /* istanbul ignore next */
 prototypeAccessors.child.get = function () {
-  return this.componentInstance
+    return this.componentInstance;
 };
 
 Object.defineProperties( VNode.prototype, prototypeAccessors );
-
 var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
+    if ( text === void 0 ) text = '';
 
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    var cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
+        }
+        else {
+            copyAugment(value, arrayMethods, arrayKeys);
+        }
+        this.observeArray(value);
+    }
+    else {
+        this.walk(value);
+    }
 };
-
 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive$$1(obj, keys[i]);
+    }
 };
-
 /**
  * Observe a list of Array items.
  */
 Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
 };
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Delete a property and trigger change if necessary.
  */
-function del (target, key) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1);
-    return
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    );
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key];
-  if (!ob) {
-    return
-  }
-  ob.dep.notify();
+function del(target, key) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    var ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
-}
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
-    }
-  }
-  return res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1309,613 +1152,542 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (var key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else if (process.env.NODE_ENV !== 'production') {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    var props = options.props;
+    if (!props)
+        { return; }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (var key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("Invalid value for option \"props\": expected an Array or an Object, " +
+            "but got " + (toRawType(props)) + ".", vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    var inject = options.inject;
+    if (!inject)
+        { return; }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (var i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (var key in inject) {
+            var val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+            "but got " + (toRawType(inject)) + ".", vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
-    }
-  }
-}
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function normalizeDirectives(options) {
+    var dirs = options.directives;
+    if (dirs) {
+        for (var key in dirs) {
+            var def$$1 = dirs[key];
+            if (typeof def$$1 === 'function') {
+                dirs[key] = { bind: def$$1, update: def$$1 };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            "but got " + (toRawType(value)) + ".", vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        var strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    // skip validation for weex recycle-list child component props
-    !(false)
-  ) {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        { return assets[id]; }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        { return assets[camelizedId]; }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        { return assets[PascalCaseId]; }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+/* @flow */
+function validateProp(key, propOptions, propsData, vm) {
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            var stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        var prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        // skip validation for weex recycle-list child component props
+        !(false)) {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
-}
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        var t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid: valid,
+        expectedType: expectedType,
+    };
+}
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
-}
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
-}
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
-    }
-  }
-  return -1
-}
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  var expectedValue = styleValue(value, expectedType);
-  var receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += " with value " + expectedValue;
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + receivedValue + ".";
-  }
-  return message
-}
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
-}
-
-function isExplicable (value) {
-  var explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
-}
-
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
-}
-
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
-            }
-          }
+function getType(fn) {
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
         }
-      }
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
-}
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
-}
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
-    try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler');
-      }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += " with value " + (styleValue(value, expectedType));
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += "with value " + (styleValue(value, receivedType)) + ".";
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return ("\"" + value + "\"");
+    }
+    else if (type === 'Number') {
+        return ("" + (Number(value)));
     }
-  }
-  logError(err, vm, info);
+    else {
+        return ("" + value);
+    }
+}
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
+function isBoolean() {
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-function logError (err, vm, info) {
-  if (process.env.NODE_ENV !== 'production') {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
-/*  */
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            var cur = vm;
+            while ((cur = cur.$parent)) {
+                var hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (var i = 0; i < hooks.length; i++) {
+                        try {
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                { return; }
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    var res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    if (process.env.NODE_ENV !== 'production') {
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
+}
 
+/* @flow */
 var isUsingMicroTask = false;
-
 var callbacks = [];
 var pending = false;
-
-function flushCallbacks () {
-  pending = false;
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    pending = false;
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // Here we have async deferring wrappers using microtasks.
 // In 2.5 we used (macro) tasks (in combination with microtasks).
 // However, it has subtle problems when state is changed right before repaint
@@ -1928,7 +1700,6 @@ function flushCallbacks () {
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
 var timerFunc;
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1937,2337 +1708,2053 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  var p = Promise.resolve();
-  timerFunc = function () {
-    p.then(flushCallbacks);
-    // In problematic UIWebViews, Promise.then doesn't completely break, but
-    // it can get stuck in a weird state where callbacks are pushed into the
-    // microtask queue but the queue isn't being flushed, until the browser
-    // needs to do some other work, e.g. handle a timer. Therefore we can
-    // "force" the microtask queue to be flushed by adding an empty timer.
-    if (isIOS) { setTimeout(noop); }
-  };
-  isUsingMicroTask = true;
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-  timerFunc = function () {
-    counter = (counter + 1) % 2;
-    textNode.data = String(counter);
-  };
-  isUsingMicroTask = true;
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Technically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = function () {
-    setImmediate(flushCallbacks);
-  };
-} else {
-  // Fallback to setTimeout.
-  timerFunc = function () {
-    setTimeout(flushCallbacks, 0);
-  };
-}
-
-function nextTick (cb, ctx) {
-  var _resolve;
-  callbacks.push(function () {
-    if (cb) {
-      try {
-        cb.call(ctx);
-      } catch (e) {
-        handleError(e, ctx, 'nextTick');
-      }
-    } else if (_resolve) {
-      _resolve(ctx);
-    }
-  });
-  if (!pending) {
-    pending = true;
-    timerFunc();
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(function (resolve) {
-      _resolve = resolve;
-    })
-  }
-}
-
-/*  */
+    var p = Promise.resolve();
+    timerFunc = function () {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            { setTimeout(noop); }
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = function () {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = function () {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = function () {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    var _resolve;
+    callbacks.push(function () {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise(function (resolve) {
+            _resolve = resolve;
+        });
+    }
+}
+
+/* @flow */
 
 var mark;
 var measure;
-
 if (process.env.NODE_ENV !== 'production') {
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = function (tag) { return perf.mark(tag); };
-    measure = function (name, startTag, endTag) {
-      perf.measure(name, startTag, endTag);
-      perf.clearMarks(startTag);
-      perf.clearMarks(endTag);
-      // perf.clearMeasures(name)
-    };
-  }
+    var perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
+        measure = function (name, startTag, endTag) {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 var initProxy;
-
 if (process.env.NODE_ENV !== 'production') {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var warnNonPresent = function (target, key) {
-    warn(
-      "Property or method \"" + key + "\" is not defined on the instance but " +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
-    );
-  };
-
-  var warnReservedPrefix = function (target, key) {
-    warn(
-      "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
     );
-  };
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
-
-  var hasHandler = {
-    has: function has (target, key) {
-      var has = key in target;
-      var isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-      if (!has && !isAllowed) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return has || !isAllowed
-    }
-  };
-
-  var getHandler = {
-    get: function get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return target[key]
-    }
-  };
-
-  initProxy = function initProxy (vm) {
+    var warnNonPresent = function (target, key) {
+        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    var warnReservedPrefix = function (target, key) {
+        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-      // determine which proxy handler to use
-      var options = vm.$options;
-      var handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler;
-      vm._renderProxy = new Proxy(vm, handlers);
-    } else {
-      vm._renderProxy = vm;
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
     }
-  };
+    var hasHandler = {
+        has: function has(target, key) {
+            var has = key in target;
+            var isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return has || !isAllowed;
+        },
+    };
+    var getHandler = {
+        get: function get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            var options = vm.$options;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-/*  */
-
+/* @flow */
 var seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
-}
-
-/*  */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    var i, keys;
+    var isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        var depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            { _traverse(val[i], seen); }
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            { _traverse(val[keys[i]], seen); }
+    }
+}
 
 var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+    var passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once$$1 ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name: name,
+        once: once$$1,
+        capture: capture,
+        passive: passive,
+    };
 });
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        var arguments$1 = arguments;
+
+        var fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+    var name, def$$1, cur, old, event;
+    for (name in on) {
+        def$$1 = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove$$1(event.name, oldOn[name], event.capture);
+        }
+    }
+}
 
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
-}
-
-/*  */
-
-function mergeVNodeHook (def, hookKey, hook) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {});
-  }
-  var invoker;
-  var oldHook = def[hookKey];
-
-  function wrappedHook () {
-    hook.apply(this, arguments);
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook);
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook]);
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook;
-      invoker.fns.push(wrappedHook);
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook]);
-    }
-  }
-
-  invoker.merged = true;
-  def[hookKey] = invoker;
-}
-
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      if (process.env.NODE_ENV !== 'production') {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
-}
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+/* @flow */
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    var invoker;
+    var oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
+}
+
+/* @flow */
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    var res = {};
+    var attrs = data.attrs;
+    var props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
+            if (process.env.NODE_ENV !== 'production') {
+                var keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
+}
 
+/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (var i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
-
-function initProvide (vm) {
-  var provide = vm.$options.provide;
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide;
-  }
-}
-
-function initInjections (vm) {
-  var result = resolveInject(vm.$options.inject, vm);
-  if (result) {
-    toggleObserving(false);
-    Object.keys(result).forEach(function (key) {
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
-        defineReactive$$1(vm, key, result[key], function () {
-          warn(
-            "Avoid mutating an injected value directly since the changes will be " +
-            "overwritten whenever the provided component re-renders. " +
-            "injection being mutated: \"" + key + "\"",
-            vm
-          );
-        });
-      } else {
-        defineReactive$$1(vm, key, result[key]);
-      }
-    });
-    toggleObserving(true);
-  }
-}
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            { continue; }
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                }
+                res.push(c);
+            }
         }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else if (process.env.NODE_ENV !== 'production') {
-          warn(("Injection \"" + key + "\" not found"), vm);
+    }
+    return res;
+}
+
+/* @flow */
+function initProvide(vm) {
+    var provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    var result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach(function (key) {
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production') {
+                defineReactive$$1(vm, key, result[key], function () {
+                    warn("Avoid mutating an injected value directly since the changes will be " +
+                        "overwritten whenever the provided component re-renders. " +
+                        "injection being mutated: \"" + key + "\"", vm);
+                });
+            }
+            else {
+                defineReactive$$1(vm, key, result[key]);
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                { continue; }
+            var provideKey = inject[key].from;
+            var source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    var provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    // @ts-ignore
+                    warn(("Injection \"" + key + "\" not found"), vm);
+                }
+            }
         }
-      }
+        return result;
     }
-    return result
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+/* @flow */
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return function () { return slots[key]; };
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    var ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
+    ret._isVList = true;
+    return ret;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+/* @flow */
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
-}
-
-/*  */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+}
 
+/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-bind without argument expects an Object or Array value', this);
         }
-      };
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            var hash;
+            var loop = function ( key ) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    var type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        var on = data.on || (data.on = {});
+                        on[("update:" + key)] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            };
 
-      for (var key in value) loop( key );
+            for (var key in value) loop( key );
+        }
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, ("__static__" + index), false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
+function markOnce(tree, index, key) {
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (var i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
+/* @flow */
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
     }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+    return data;
 }
 
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
-}
-
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
-}
-
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+/* @flow */
+function bindDynamicKeys(baseObj, values) {
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (process.env.NODE_ENV !== 'production' &&
+            key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
-    }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+/* @flow */
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+/* @flow */
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    var this$1 = this;
+
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        }
+        return this$1.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get: function get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = function (a, b, c, d) {
+            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (var key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            { mergeProps(props, data.attrs); }
+        if (isDef(data.props))
+            { mergeProps(props, data.props); }
+    }
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    if (process.env.NODE_ENV !== 'production') {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (var key in from) {
+        to[camelize(key)] = from[key];
+    }
+}
 
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-    }
-    return res
-  }
-}
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
-}
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
-}
-
-/*  */
-
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
+
+/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init: function init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            var mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch: function prepatch(oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy: function destroy(vnode) {
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    if (process.env.NODE_ENV !== 'production') {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
-    }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
-    }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent // activeInstance in lifecycle state
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-    }
-  }
-}
-
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        if (process.env.NODE_ENV !== 'production') {
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
+        }
+        return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        var slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
+    // @ts-expect-error
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    var options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook$1(f1, f2) {
+    var merged = function (a, b) {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
-}
-
-/*  */
+function transformModel(options, data) {
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
+}
 
+/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (process.env.NODE_ENV !== 'production' &&
-    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {
-        warn(
-          ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-          context
-        );
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      );
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (process.env.NODE_ENV !== 'production' &&
+        isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === 'string') {
+        var Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (process.env.NODE_ENV !== 'production' &&
+                isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            { applyNS(vnode, ns); }
+        if (isDef(data))
+            { registerDeepBindings(data); }
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
-}
-
-/*  */
-
-function initRender (vm) {
-  vm._vnode = null; // the root of the child tree
-  vm._staticTrees = null; // v-once cached trees
-  var options = vm.$options;
-  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-  var renderContext = parentVnode && parentVnode.context;
-  vm.$slots = resolveSlots(options._renderChildren, renderContext);
-  vm.$scopedSlots = emptyObject;
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  var parentData = parentVnode && parentVnode.data;
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-    }, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-    }, true);
-  } else {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
+}
+
+/* @flow */
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    var parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        }, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        }, true);
+    }
+    else {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
+    }
 }
-
 var currentRenderingInstance = null;
-
-function renderMixin (Vue) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype);
-
-  Vue.prototype.$nextTick = function (fn) {
-    return nextTick(fn, this)
-  };
-
-  Vue.prototype._render = function () {
-    var vm = this;
-    var ref = vm.$options;
-    var render = ref.render;
-    var _parentVnode = ref._parentVnode;
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      );
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode;
-    // render self
-    var vnode;
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm;
-      vnode = render.call(vm._renderProxy, vm.$createElement);
-    } catch (e) {
-      handleError(e, vm, "render");
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-        } catch (e) {
-          handleError(e, vm, "renderError");
-          vnode = vm._vnode;
-        }
-      } else {
-        vnode = vm._vnode;
-      }
-    } finally {
-      currentRenderingInstance = null;
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0];
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        );
-      }
-      vnode = createEmptyVNode();
-    }
-    // set parent
-    vnode.parent = _parentVnode;
-    return vnode
-  };
-}
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
-        }
-      }
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
     };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
+    Vue.prototype._render = function () {
+        var vm = this;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        var vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        catch (e) {
+            handleError(e, vm, "render");
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, "renderError");
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                process.env.NODE_ENV !== 'production'
-                  ? ("timeout (" + (res.timeout) + "ms)")
-                  : null
-              );
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
             }
-          }, res.timeout);
+            vnode = createEmptyVNode();
         }
-      }
-    }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-/*  */
-
-function getFirstComponentChild (children) {
-  if (Array.isArray(children)) {
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
+/* @flow */
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
     }
-  }
+    return isObject(comp) ? base.extend(comp) : comp;
 }
-
-/*  */
-
-/*  */
-
-function initEvents (vm) {
-  vm._events = Object.create(null);
-  vm._hasHookEvent = false;
-  // init parent attached events
-  var listeners = vm.$options._parentListeners;
-  if (listeners) {
-    updateComponentListeners(vm, listeners);
-  }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    return node;
 }
-
-var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
-}
-
-function remove$1 (event, fn) {
-  target.$off(event, fn);
-}
-
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
-    }
-  }
-}
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
-}
-
-function eventsMixin (Vue) {
-  var hookRE = /^hook:/;
-  Vue.prototype.$on = function (event, fn) {
-    var vm = this;
-    if (Array.isArray(event)) {
-      for (var i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn);
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn);
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true;
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$once = function (event, fn) {
-    var vm = this;
-    function on () {
-      vm.$off(event, on);
-      fn.apply(vm, arguments);
-    }
-    on.fn = fn;
-    vm.$on(event, on);
-    return vm
-  };
-
-  Vue.prototype.$off = function (event, fn) {
-    var vm = this;
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null);
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-        vm.$off(event[i$1], fn);
-      }
-      return vm
-    }
-    // specific event
-    var cbs = vm._events[event];
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null;
-      return vm
-    }
-    // specific handler
-    var cb;
-    var i = cbs.length;
-    while (i--) {
-      cb = cbs[i];
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1);
-        break
-      }
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
     }
-    return vm
-  };
-
-  Vue.prototype.$emit = function (event) {
-    var vm = this;
-    if (process.env.NODE_ENV !== 'production') {
-      var lowerCaseEvent = event.toLowerCase();
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-          "Note that HTML attributes are case-insensitive and you cannot use " +
-          "v-on to listen to camelCase events when using in-DOM templates. " +
-          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-        );
-      }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
     }
-    var cbs = vm._events[event];
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-      var args = toArray(arguments, 1);
-      var info = "event handler for \"" + event + "\"";
-      for (var i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-      }
+    var owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
     }
-    return vm
-  };
-}
-
-/*  */
-
-var activeInstance = null;
-var isUpdatingChildComponent = false;
-
-function setActiveInstance(vm) {
-  var prevActiveInstance = activeInstance;
-  activeInstance = vm;
-  return function () {
-    activeInstance = prevActiveInstance;
-  }
-}
-
-function initLifecycle (vm) {
-  var options = vm.$options;
-
-  // locate first non-abstract parent
-  var parent = options.parent;
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
-    }
-    parent.$children.push(vm);
-  }
-
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
-
-  vm.$children = [];
-  vm.$refs = {};
-
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
-}
-
-function lifecycleMixin (Vue) {
-  Vue.prototype._update = function (vnode, hydrating) {
-    var vm = this;
-    var prevEl = vm.$el;
-    var prevVnode = vm._vnode;
-    var restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
-    }
-    restoreActiveInstance();
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null;
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm;
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  };
-
-  Vue.prototype.$forceUpdate = function () {
-    var vm = this;
-    if (vm._watcher) {
-      vm._watcher.update();
-    }
-  };
-
-  Vue.prototype.$destroy = function () {
-    var vm = this;
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy');
-    vm._isBeingDestroyed = true;
-    // remove self from parent
-    var parent = vm.$parent;
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
-    }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown();
-    }
-    var i = vm._watchers.length;
-    while (i--) {
-      vm._watchers[i].teardown();
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
-    }
-    // call the last hook...
-    vm._isDestroyed = true;
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
-    // fire destroyed hook
-    callHook(vm, 'destroyed');
-    // turn off all instance listeners.
-    vm.$off();
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null;
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null;
-    }
-  };
-}
-
-function mountComponent (
-  vm,
-  el,
-  hydrating
-) {
-  vm.$el = el;
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode;
-    if (process.env.NODE_ENV !== 'production') {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        );
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        );
-      }
-    }
-  }
-  callHook(vm, 'beforeMount');
-
-  var updateComponent;
-  /* istanbul ignore if */
-  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-    updateComponent = function () {
-      var name = vm._name;
-      var id = vm._uid;
-      var startTag = "vue-perf-start:" + id;
-      var endTag = "vue-perf-end:" + id;
-
-      mark(startTag);
-      var vnode = vm._render();
-      mark(endTag);
-      measure(("vue " + name + " render"), startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(("vue " + name + " patch"), startTag, endTag);
-    };
-  } else {
-    updateComponent = function () {
-      vm._update(vm._render(), hydrating);
-    };
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before: function before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate');
-      }
-    }
-  }, true /* isRenderWatcher */);
-  hydrating = false;
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  }
-  return vm
-}
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = true;
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        var resolve = once(function (res) {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        var reject = once(function (reason) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(process.env.NODE_ENV !== 'production'
+                                ? ("timeout (" + (res.timeout) + "ms)")
+                                : null);
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
     }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = false;
-  }
 }
 
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
+/* @flow */
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+/* @flow */
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+            var c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
     }
-    callHook(vm, 'activated');
-  }
 }
 
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
-    }
-    callHook(vm, 'deactivated');
-  }
-}
+/* @flow */
 
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+/* @flow */
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    var listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
     }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
 }
-
-/*  */
-
-var MAX_UPDATE_COUNT = 100;
-
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index = 0;
-
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0;
-  has = {};
-  if (process.env.NODE_ENV !== 'production') {
-    circular = {};
-  }
-  waiting = flushing = false;
+var target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    var _target = target;
+    return function onceHandler() {
+        var res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    target = undefined;
+}
+function eventsMixin(Vue) {
+    var hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        var vm = this;
+        if (Array.isArray(event)) {
+            for (var i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        var vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        var vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
+            }
+            return vm;
+        }
+        // specific event
+        var cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        var cb;
+        var i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        var vm = this;
+        if (process.env.NODE_ENV !== 'production') {
+            var lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    "Note that HTML attributes are case-insensitive and you cannot use " +
+                    "v-on to listen to camelCase events when using in-DOM templates. " +
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+            }
+        }
+        var cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            var args = toArray(arguments, 1);
+            var info = "event handler for \"" + event + "\"";
+            for (var i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
+}
+
+/* @flow */
+var activeInstance = null;
+var isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    var prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return function () {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    var options = vm.$options;
+    // locate first non-abstract parent
+    var parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        var vm = this;
+        var prevEl = vm.$el;
+        var prevVnode = vm._vnode;
+        var restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        var vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        var vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook(vm, 'beforeDestroy');
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        var parent = vm.$parent;
+        // @ts-ignore
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        var i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook(vm, 'destroyed');
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            // @ts-expect-error null is not undefined
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        if (process.env.NODE_ENV !== 'production') {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                vm.$options.el ||
+                el) {
+                warn('You are using the runtime-only build of Vue where the template ' +
+                    'compiler is not available. Either pre-compile the templates into ' +
+                    'render functions, or use the compiler-included build.', vm);
+            }
+            else {
+                warn('Failed to mount component: template or render function not defined.', vm);
+            }
+        }
+    }
+    callHook(vm, 'beforeMount');
+    var updateComponent;
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+        updateComponent = function () {
+            var name = vm._name;
+            var id = vm._uid;
+            var startTag = "vue-perf-start:" + id;
+            var endTag = "vue-perf-end:" + id;
+            mark(startTag);
+            var vnode = vm._render();
+            mark(endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = function () {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before: function before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook(vm, 'beforeUpdate');
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook(vm, 'mounted');
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    if (process.env.NODE_ENV !== 'production') {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            { return true; }
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (var i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'activated');
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (var i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'deactivated');
+    }
+}
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
+    }
+    popTarget();
 }
 
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-var currentFlushTimestamp = 0;
-
+/* @flow */
+var MAX_UPDATE_COUNT = 100;
+var queue = [];
+var activatedChildren = [];
+var has = {};
+var circular = {};
+var waiting = false;
+var flushing = false;
+var index = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    if (process.env.NODE_ENV !== 'production') {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+var currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
 var getNow = Date.now;
-
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -4275,1477 +3762,1289 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = function () { return performance.now(); };
+    }
 }
-
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow();
-  flushing = true;
-  var watcher, id;
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort(function (a, b) { return a.id - b.id; });
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index];
-    if (watcher.before) {
-      watcher.before();
-    }
-    id = watcher.id;
-    has[id] = null;
-    watcher.run();
-    // in dev build, check and stop circular updates.
-    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1;
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-              : "in a component render function."
-          ),
-          watcher.vm
-        );
-        break
-      }
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    var watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort(function (a, b) { return a.id - b.id; });
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        : "in a component render function."), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
     }
-  }
-
-  // keep copies of post queues before resetting state
-  var activatedQueue = activatedChildren.slice();
-  var updatedQueue = queue.slice();
-
-  resetSchedulerState();
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue);
-  callUpdatedHooks(updatedQueue);
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush');
-  }
 }
-
-function callUpdatedHooks (queue) {
-  var i = queue.length;
-  while (i--) {
-    var watcher = queue[i];
-    var vm = watcher.vm;
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated');
+function callUpdatedHooks(queue) {
+    var i = queue.length;
+    while (i--) {
+        var watcher = queue[i];
+        var vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook(vm, 'updated');
+        }
     }
-  }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-  activatedChildren.push(vm);
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
 }
-
-function callActivatedHooks (queue) {
-  for (var i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true;
-    activateChildComponent(queue[i], true /* true */);
-  }
+function callActivatedHooks(queue) {
+    for (var i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
 }
-
 /**
  * Push a watcher into the watcher queue.
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-function queueWatcher (watcher) {
-  var id = watcher.id;
-  if (has[id] == null) {
-    has[id] = true;
-    if (!flushing) {
-      queue.push(watcher);
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      var i = queue.length - 1;
-      while (i > index && queue[i].id > watcher.id) {
-        i--;
-      }
-      queue.splice(i + 1, 0, watcher);
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true;
-
-      if (process.env.NODE_ENV !== 'production' && !config.async) {
-        flushSchedulerQueue();
-        return
-      }
-      nextTick(flushSchedulerQueue);
+function queueWatcher(watcher) {
+    var id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            var i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (process.env.NODE_ENV !== 'production' && !config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
     }
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 var uid$2 = 0;
-
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher (
-  vm,
-  expOrFn,
-  cb,
-  options,
-  isRenderWatcher
-) {
-  this.vm = vm;
-  if (isRenderWatcher) {
-    vm._watcher = this;
-  }
-  vm._watchers.push(this);
-  // options
-  if (options) {
-    this.deep = !!options.deep;
-    this.user = !!options.user;
-    this.lazy = !!options.lazy;
-    this.sync = !!options.sync;
-    this.before = options.before;
-  } else {
-    this.deep = this.user = this.lazy = this.sync = false;
-  }
-  this.cb = cb;
-  this.id = ++uid$2; // uid for batching
-  this.active = true;
-  this.dirty = this.lazy; // for lazy watchers
-  this.deps = [];
-  this.newDeps = [];
-  this.depIds = new _Set();
-  this.newDepIds = new _Set();
-  this.expression = process.env.NODE_ENV !== 'production'
-    ? expOrFn.toString()
-    : '';
-  // parse expression for getter
-  if (typeof expOrFn === 'function') {
-    this.getter = expOrFn;
-  } else {
-    this.getter = parsePath(expOrFn);
-    if (!this.getter) {
-      this.getter = noop;
-      process.env.NODE_ENV !== 'production' && warn(
-        "Failed watching path: \"" + expOrFn + "\" " +
-        'Watcher only accepts simple dot-delimited paths. ' +
-        'For full control, use a function instead.',
-        vm
-      );
-    }
-  }
-  this.value = this.lazy
-    ? undefined
-    : this.get();
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$2; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            process.env.NODE_ENV !== 'production' &&
+                warn("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+        }
+    }
+    this.value = this.lazy ? undefined : this.get();
 };
-
 /**
  * Evaluate the getter, and re-collect dependencies.
  */
 Watcher.prototype.get = function get () {
-  pushTarget(this);
-  var value;
-  var vm = this.vm;
-  try {
-    value = this.getter.call(vm, vm);
-  } catch (e) {
-    if (this.user) {
-      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-    } else {
-      throw e
-    }
-  } finally {
-    // "touch" every property so they are all tracked as
-    // dependencies for deep watching
-    if (this.deep) {
-      traverse(value);
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
     }
-    popTarget();
-    this.cleanupDeps();
-  }
-  return value
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+        }
+        else {
+            throw e;
+        }
+    }
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
+        }
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
 };
-
 /**
  * Add a dependency to this directive.
  */
 Watcher.prototype.addDep = function addDep (dep) {
-  var id = dep.id;
-  if (!this.newDepIds.has(id)) {
-    this.newDepIds.add(id);
-    this.newDeps.push(dep);
-    if (!this.depIds.has(id)) {
-      dep.addSub(this);
-    }
-  }
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
 };
-
 /**
  * Clean up for dependency collection.
  */
 Watcher.prototype.cleanupDeps = function cleanupDeps () {
-  var i = this.deps.length;
-  while (i--) {
-    var dep = this.deps[i];
-    if (!this.newDepIds.has(dep.id)) {
-      dep.removeSub(this);
-    }
-  }
-  var tmp = this.depIds;
-  this.depIds = this.newDepIds;
-  this.newDepIds = tmp;
-  this.newDepIds.clear();
-  tmp = this.deps;
-  this.deps = this.newDeps;
-  this.newDeps = tmp;
-  this.newDeps.length = 0;
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
 };
-
 /**
  * Subscriber interface.
  * Will be called when a dependency changes.
  */
 Watcher.prototype.update = function update () {
-  /* istanbul ignore else */
-  if (this.lazy) {
-    this.dirty = true;
-  } else if (this.sync) {
-    this.run();
-  } else {
-    queueWatcher(this);
-  }
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
 };
-
 /**
  * Scheduler job interface.
  * Will be called by the scheduler.
  */
 Watcher.prototype.run = function run () {
-  if (this.active) {
-    var value = this.get();
-    if (
-      value !== this.value ||
-      // Deep watchers and watchers on Object/Arrays should fire even
-      // when the value is the same, because the value may
-      // have mutated.
-      isObject(value) ||
-      this.deep
-    ) {
-      // set new value
-      var oldValue = this.value;
-      this.value = value;
-      if (this.user) {
-        try {
-          this.cb.call(this.vm, value, oldValue);
-        } catch (e) {
-          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
+            if (this.user) {
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
+            }
+            else {
+                this.cb.call(this.vm, value, oldValue);
+            }
         }
-      } else {
-        this.cb.call(this.vm, value, oldValue);
-      }
     }
-  }
 };
-
 /**
  * Evaluate the value of the watcher.
  * This only gets called for lazy watchers.
  */
 Watcher.prototype.evaluate = function evaluate () {
-  this.value = this.get();
-  this.dirty = false;
+    this.value = this.get();
+    this.dirty = false;
 };
-
 /**
  * Depend on all deps collected by this watcher.
  */
 Watcher.prototype.depend = function depend () {
-  var i = this.deps.length;
-  while (i--) {
-    this.deps[i].depend();
-  }
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
 };
-
 /**
  * Remove self from all dependencies' subscriber list.
  */
 Watcher.prototype.teardown = function teardown () {
-  if (this.active) {
-    // remove self from vm's watcher list
-    // this is a somewhat expensive operation so we skip it
-    // if the vm is being destroyed.
-    if (!this.vm._isBeingDestroyed) {
-      remove(this.vm._watchers, this);
-    }
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].removeSub(this);
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove(this.vm._watchers, this);
+        }
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].removeSub(this);
+        }
+        this.active = false;
     }
-    this.active = false;
-  }
 };
 
-/*  */
-
+/* @flow */
 var sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
 };
-
-function proxy (target, sourceKey, key) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  };
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function initState (vm) {
-  vm._watchers = [];
-  var opts = vm.$options;
-  if (opts.props) { initProps(vm, opts.props); }
-  if (opts.methods) { initMethods(vm, opts.methods); }
-  if (opts.data) {
-    initData(vm);
-  } else {
-    observe(vm._data = {}, true /* asRootData */);
-  }
-  if (opts.computed) { initComputed(vm, opts.computed); }
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
-  }
-}
-
-function initProps (vm, propsOptions) {
-  var propsData = vm.$options.propsData || {};
-  var props = vm._props = {};
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  var keys = vm.$options._propKeys = [];
-  var isRoot = !vm.$parent;
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false);
-  }
-  var loop = function ( key ) {
-    keys.push(key);
-    var value = validateProp(key, propsOptions, propsData, vm);
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      var hyphenatedKey = hyphenate(key);
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-          vm
-        );
-      }
-      defineReactive$$1(props, key, value, function () {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            "Avoid mutating a prop directly since the value will be " +
-            "overwritten whenever the parent component re-renders. " +
-            "Instead, use a data or computed property based on the prop's " +
-            "value. Prop being mutated: \"" + key + "\"",
-            vm
-          );
-        }
-      });
-    } else {
-      defineReactive$$1(props, key, value);
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, "_props", key);
-    }
-  };
-
-  for (var key in propsOptions) loop( key );
-  toggleObserving(true);
-}
-
-function initData (vm) {
-  var data = vm.$options.data;
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (!isPlainObject(data)) {
-    data = {};
-    process.env.NODE_ENV !== 'production' && warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    );
-  }
-  // proxy data on instance
-  var keys = Object.keys(data);
-  var props = vm.$options.props;
-  var methods = vm.$options.methods;
-  var i = keys.length;
-  while (i--) {
-    var key = keys[i];
-    if (process.env.NODE_ENV !== 'production') {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a data property."),
-          vm
-        );
-      }
-    }
-    if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "The data property \"" + key + "\" is already declared as a prop. " +
-        "Use prop default value instead.",
-        vm
-      );
-    } else if (!isReserved(key)) {
-      proxy(vm, "_data", key);
-    }
-  }
-  // observe data
-  observe(data, true /* asRootData */);
-}
-
-function getData (data, vm) {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget();
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, "data()");
-    return {}
-  } finally {
-    popTarget();
-  }
-}
-
-var computedWatcherOptions = { lazy: true };
-
-function initComputed (vm, computed) {
-  // $flow-disable-line
-  var watchers = vm._computedWatchers = Object.create(null);
-  // computed properties are just getters during SSR
-  var isSSR = isServerRendering();
-
-  for (var key in computed) {
-    var userDef = computed[key];
-    var getter = typeof userDef === 'function' ? userDef : userDef.get;
-    if (process.env.NODE_ENV !== 'production' && getter == null) {
-      warn(
-        ("Getter is missing for computed property \"" + key + "\"."),
-        vm
-      );
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      );
-    }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else if (process.env.NODE_ENV !== 'production') {
-      if (key in vm.$data) {
-        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-      }
-    }
-  }
-}
-
-function defineComputed (
-  target,
-  key,
-  userDef
-) {
-  var shouldCache = !isServerRendering();
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
-  }
-  if (process.env.NODE_ENV !== 'production' &&
-      sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-        this
-      );
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    var opts = vm.$options;
+    if (opts.props)
+        { initProps(vm, opts.props); }
+    if (opts.methods)
+        { initMethods(vm, opts.methods); }
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        { initComputed(vm, opts.computed); }
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps(vm, propsOptions) {
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    var loop = function ( key ) {
+        keys.push(key);
+        var value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            var hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+            }
+            defineReactive$$1(props, key, value, function () {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn("Avoid mutating a prop directly since the value will be " +
+                        "overwritten whenever the parent component re-renders. " +
+                        "Instead, use a data or computed property based on the prop's " +
+                        "value. Prop being mutated: \"" + key + "\"", vm);
+                }
+            });
+        }
+        else {
+            defineReactive$$1(props, key, value);
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, "_props", key);
+        }
     };
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    var watcher = this._computedWatchers && this._computedWatchers[key];
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate();
-      }
-      if (Dep.target) {
-        watcher.depend();
-      }
-      return watcher.value
-    }
-  }
-}
 
-function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
+    for (var key in propsOptions) loop( key );
+    toggleObserving(true);
 }
-
-function initMethods (vm, methods) {
-  var props = vm.$options.props;
-  for (var key in methods) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-          "Did you reference the function correctly?",
-          vm
-        );
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a prop."),
-          vm
-        );
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-          "Avoid defining component methods that start with _ or $."
-        );
-      }
+function initData(vm) {
+    var data = vm.$options.data;
+    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        process.env.NODE_ENV !== 'production' &&
+            warn('data functions should return an object:\n' +
+                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+    }
+    // proxy data on instance
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
+    while (i--) {
+        var key = keys[i];
+        if (process.env.NODE_ENV !== 'production') {
+            if (methods && hasOwn(methods, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("The data property \"" + key + "\" is already declared as a prop. " +
+                    "Use prop default value instead.", vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, "_data", key);
+        }
     }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-  }
+    // observe data
+    observe(data, true /* asRootData */);
 }
-
-function initWatch (vm, watch) {
-  for (var key in watch) {
-    var handler = watch[key];
-    if (Array.isArray(handler)) {
-      for (var i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
-      }
-    } else {
-      createWatcher(vm, key, handler);
-    }
-  }
-}
-
-function createWatcher (
-  vm,
-  expOrFn,
-  handler,
-  options
-) {
-  if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler];
-  }
-  return vm.$watch(expOrFn, handler, options)
-}
-
-function stateMixin (Vue) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  var dataDef = {};
-  dataDef.get = function () { return this._data };
-  var propsDef = {};
-  propsDef.get = function () { return this._props };
-  if (process.env.NODE_ENV !== 'production') {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      );
-    };
-    propsDef.set = function () {
-      warn("$props is readonly.", this);
-    };
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef);
-  Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
-
-  Vue.prototype.$watch = function (
-    expOrFn,
-    cb,
-    options
-  ) {
-    var vm = this;
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
     }
-    options = options || {};
-    options.user = true;
-    var watcher = new Watcher(vm, expOrFn, cb, options);
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value);
-      } catch (error) {
-        handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-      }
+    catch (e) {
+        handleError(e, vm, "data()");
+        return {};
     }
-    return function unwatchFn () {
-      watcher.teardown();
+    finally {
+        popTarget();
     }
-  };
 }
-
-/*  */
-
-var uid$3 = 0;
-
-function initMixin (Vue) {
-  Vue.prototype._init = function (options) {
-    var vm = this;
-    // a uid
-    vm._uid = uid$3++;
-
-    var startTag, endTag;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      startTag = "vue-perf-start:" + (vm._uid);
-      endTag = "vue-perf-end:" + (vm._uid);
-      mark(startTag);
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options);
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      );
+var computedWatcherOptions = { lazy: true };
+function initComputed(vm, computed) {
+    // $flow-disable-line
+    var watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+        var userDef = computed[key];
+        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== 'production' && getter == null) {
+            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            if (key in vm.$data) {
+                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+            }
+        }
     }
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      initProxy(vm);
-    } else {
-      vm._renderProxy = vm;
-    }
-    // expose real self
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook(vm, 'created');
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      vm._name = formatComponentName(vm, false);
-      mark(endTag);
-      measure(("vue " + (vm._name) + " init"), startTag, endTag);
-    }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el);
-    }
-  };
-}
-
-function initInternalComponent (vm, options) {
-  var opts = vm.$options = Object.create(vm.constructor.options);
-  // doing this because it's faster than dynamic enumeration.
-  var parentVnode = options._parentVnode;
-  opts.parent = options.parent;
-  opts._parentVnode = parentVnode;
-
-  var vnodeComponentOptions = parentVnode.componentOptions;
-  opts.propsData = vnodeComponentOptions.propsData;
-  opts._parentListeners = vnodeComponentOptions.listeners;
-  opts._renderChildren = vnodeComponentOptions.children;
-  opts._componentTag = vnodeComponentOptions.tag;
-
-  if (options.render) {
-    opts.render = options.render;
-    opts.staticRenderFns = options.staticRenderFns;
-  }
-}
-
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
-}
-
-function Vue (options) {
-  if (process.env.NODE_ENV !== 'production' &&
-    !(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword');
-  }
-  this._init(options);
 }
-
-initMixin(Vue);
-stateMixin(Vue);
-eventsMixin(Vue);
-lifecycleMixin(Vue);
-renderMixin(Vue);
-
-/*  */
-
-function initUse (Vue) {
-  Vue.use = function (plugin) {
-    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
+function defineComputed(target, key, userDef) {
+    var shouldCache = !isServerRendering();
+    if (typeof userDef === 'function') {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
     }
-
-    // additional parameters
-    var args = toArray(arguments, 1);
-    args.unshift(this);
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args);
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args);
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+        };
     }
-    installedPlugins.push(plugin);
-    return this
-  };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
 }
-
-/*  */
-
-function initMixin$1 (Vue) {
-  Vue.mixin = function (mixin) {
-    this.options = mergeOptions(this.options, mixin);
-    return this
-  };
+function createComputedGetter(key) {
+    return function computedGetter() {
+        var watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
 }
-
-/*  */
-
-function initExtend (Vue) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0;
-  var cid = 1;
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions) {
-    extendOptions = extendOptions || {};
-    var Super = this;
-    var SuperId = Super.cid;
-    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    var props = vm.$options.props;
+    for (var key in methods) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (typeof methods[key] !== 'function') {
+                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                    "Did you reference the function correctly?", vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                    "Avoid defining component methods that start with _ or $.");
+            }
+        }
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
     }
-
-    var name = extendOptions.name || Super.options.name;
-    if (process.env.NODE_ENV !== 'production' && name) {
-      validateComponentName(name);
+}
+function initWatch(vm, watch) {
+    for (var key in watch) {
+        var handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (var i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
     }
-
-    var Sub = function VueComponent (options) {
-      this._init(options);
-    };
-    Sub.prototype = Object.create(Super.prototype);
-    Sub.prototype.constructor = Sub;
-    Sub.cid = cid++;
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    );
-    Sub['super'] = Super;
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps$1(Sub);
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
     }
-    if (Sub.options.computed) {
-      initComputed$1(Sub);
+    if (typeof handler === 'string') {
+        handler = vm[handler];
     }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    var dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    var propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    if (process.env.NODE_ENV !== 'production') {
+        dataDef.set = function () {
+            warn('Avoid replacing instance root $data. ' +
+                'Use nested data properties instead.', this);
+        };
+        propsDef.set = function () {
+            warn("$props is readonly.", this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, '$data', dataDef);
+    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        var vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        var watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            pushTarget();
+            try {
+                cb.call(vm, watcher.value);
+            }
+            catch (error) {
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+            }
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
+}
 
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend;
-    Sub.mixin = Super.mixin;
-    Sub.use = Super.use;
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type];
-    });
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub;
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options;
-    Sub.extendOptions = extendOptions;
-    Sub.sealedOptions = extend({}, Sub.options);
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub;
-    return Sub
-  };
-}
-
-function initProps$1 (Comp) {
-  var props = Comp.options.props;
-  for (var key in props) {
-    proxy(Comp.prototype, "_props", key);
-  }
-}
-
-function initComputed$1 (Comp) {
-  var computed = Comp.options.computed;
-  for (var key in computed) {
-    defineComputed(Comp.prototype, key, computed[key]);
-  }
-}
-
-/*  */
-
-function initAssetRegisters (Vue) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(function (type) {
-    Vue[type] = function (
-      id,
-      definition
-    ) {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
+/* @flow */
+var uid$3 = 0;
+function initMixin(Vue) {
+    Vue.prototype._init = function (options) {
+        var vm = this;
+        // a uid
+        vm._uid = uid$3++;
+        var startTag, endTag;
         /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && type === 'component') {
-          validateComponentName(id);
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
         }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id;
-          definition = this.options._base.extend(definition);
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            initProxy(vm);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook(vm, 'created');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
         }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition };
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
         }
-        this.options[type + 's'][id] = definition;
-        return definition
-      }
     };
-  });
+}
+function initInternalComponent(vm, options) {
+    // @ts-ignore
+    var opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    var parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    var vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    var options = Ctor.options;
+    if (Ctor.super) {
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            var modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                { modified = {}; }
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-/*  */
-
-
+function Vue(options) {
+    if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
+        warn('Vue is a constructor and should be called with the `new` keyword');
+    }
+    this._init(options);
+}
+//@ts-ignore
+initMixin(Vue);
+//@ts-ignore
+stateMixin(Vue);
+//@ts-ignore
+eventsMixin(Vue);
+//@ts-ignore
+lifecycleMixin(Vue);
+//@ts-ignore
+renderMixin(Vue);
 
-function getComponentName (opts) {
-  return opts && (opts.Ctor.options.name || opts.tag)
+/* @flow */
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        var args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function matches (pattern, name) {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
+/* @flow */
+function initMixin$1(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function pruneCache (keepAliveInstance, filter) {
-  var cache = keepAliveInstance.cache;
-  var keys = keepAliveInstance.keys;
-  var _vnode = keepAliveInstance._vnode;
-  for (var key in cache) {
-    var cachedNode = cache[key];
-    if (cachedNode) {
-      var name = getComponentName(cachedNode.componentOptions);
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
-      }
+/* @flow */
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    var cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        var Super = this;
+        var SuperId = Super.cid;
+        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        var name = extendOptions.name || Super.options.name;
+        if (process.env.NODE_ENV !== 'production' && name) {
+            validateComponentName(name);
+        }
+        var Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps$1(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed$1(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps$1(Comp) {
+    var props = Comp.options.props;
+    for (var key in props) {
+        proxy(Comp.prototype, "_props", key);
+    }
+}
+function initComputed$1(Comp) {
+    var computed = Comp.options.computed;
+    for (var key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
     }
-  }
 }
 
-function pruneCacheEntry (
-  cache,
-  key,
-  keys,
-  current
-) {
-  var cached$$1 = cache[key];
-  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-    cached$$1.componentInstance.$destroy();
-  }
-  cache[key] = null;
-  remove(keys, key);
+/* @flow */
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach(function (type) {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (process.env.NODE_ENV !== 'production' && type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
+// @ts-nocheck
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === 'string') {
+        return pattern.split(',').indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+        var cachedNode = cache[key];
+        if (cachedNode) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    var cached$$1 = cache[key];
+    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+        cached$$1.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove(keys, key);
+}
 var patternTypes = [String, RegExp, Array];
-
+// TODO use defineComponent
 var KeepAlive = {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created: function created () {
-    this.cache = Object.create(null);
-    this.keys = [];
-  },
-
-  destroyed: function destroyed () {
-    for (var key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
-    }
-  },
-
-  mounted: function mounted () {
-    var this$1 = this;
-
-    this.$watch('include', function (val) {
-      pruneCache(this$1, function (name) { return matches(val, name); });
-    });
-    this.$watch('exclude', function (val) {
-      pruneCache(this$1, function (name) { return !matches(val, name); });
-    });
-  },
-
-  render: function render () {
-    var slot = this.$slots.default;
-    var vnode = getFirstComponentChild(slot);
-    var componentOptions = vnode && vnode.componentOptions;
-    if (componentOptions) {
-      // check pattern
-      var name = getComponentName(componentOptions);
-      var ref = this;
-      var include = ref.include;
-      var exclude = ref.exclude;
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      var ref$1 = this;
-      var cache = ref$1.cache;
-      var keys = ref$1.keys;
-      var key = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-        : vnode.key;
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
-        // make current key freshest
-        remove(keys, key);
-        keys.push(key);
-      } else {
-        cache[key] = vnode;
-        keys.push(key);
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+    name: 'keep-alive',
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    created: function created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed: function destroyed() {
+        for (var key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
         }
-      }
+    },
+    mounted: function mounted() {
+        var this$1 = this;
 
-      vnode.data.keepAlive = true;
-    }
-    return vnode || (slot && slot[0])
-  }
+        this.$watch('include', function (val) {
+            pruneCache(this$1, function (name) { return matches(val, name); });
+        });
+        this.$watch('exclude', function (val) {
+            pruneCache(this$1, function (name) { return !matches(val, name); });
+        });
+    },
+    render: function render() {
+        var slot = this.$slots.default;
+        var vnode = getFirstComponentChild(slot);
+        var componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
+            var key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove(keys, key);
+                keys.push(key);
+            }
+            else {
+                cache[key] = vnode;
+                keys.push(key);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+            }
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
 var builtInComponents = {
-  KeepAlive: KeepAlive
+    KeepAlive: KeepAlive,
 };
 
-/*  */
-
-function initGlobalAPI (Vue) {
-  // config
-  var configDef = {};
-  configDef.get = function () { return config; };
-  if (process.env.NODE_ENV !== 'production') {
-    configDef.set = function () {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      );
+/* @flow */
+function initGlobalAPI(Vue) {
+    // config
+    var configDef = {};
+    configDef.get = function () { return config; };
+    if (process.env.NODE_ENV !== 'production') {
+        configDef.set = function () {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn,
+        extend: extend,
+        mergeOptions: mergeOptions,
+        defineReactive: defineReactive$$1,
     };
-  }
-  Object.defineProperty(Vue, 'config', configDef);
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn: warn,
-    extend: extend,
-    mergeOptions: mergeOptions,
-    defineReactive: defineReactive$$1
-  };
-
-  Vue.set = set;
-  Vue.delete = del;
-  Vue.nextTick = nextTick;
-
-  // 2.6 explicit observable API
-  Vue.observable = function (obj) {
-    observe(obj);
-    return obj
-  };
-
-  Vue.options = Object.create(null);
-  ASSET_TYPES.forEach(function (type) {
-    Vue.options[type + 's'] = Object.create(null);
-  });
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue;
-
-  extend(Vue.options.components, builtInComponents);
-
-  initUse(Vue);
-  initMixin$1(Vue);
-  initExtend(Vue);
-  initAssetRegisters(Vue);
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = function (obj) {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach(function (type) {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin$1(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
 initGlobalAPI(Vue);
-
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+    get: isServerRendering,
 });
-
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get: function get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
+    get: function get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
 });
-
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+    value: FunctionalRenderContext,
 });
-
 Vue.version = '2.6.12';
 
-/*  */
-
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
 var convertEnumeratedValue = function (key, value) {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
 var xlinkNS = 'http://www.w3.org/1999/xlink';
-
 var isXlink = function (name) {
-  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-
 var getXlinkProp = function (name) {
-  return isXlink(name) ? name.slice(6, name.length) : ''
+    return isXlink(name) ? name.slice(6, name.length) : '';
 };
-
 var isFalsyAttrValue = function (val) {
-  return val == null || val === false
+    return val == null || val === false;
 };
 
-/*  */
-
-function genClassForVnode (vnode) {
-  var data = vnode.data;
-  var parentNode = vnode;
-  var childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
+/* @flow */
+function genClassForVnode(vnode) {
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
     }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
     }
-  }
-  return renderClass(data.staticClass, data.class)
+    return renderClass(data.staticClass, data.class);
 }
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
 }
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
 }
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyArray (value) {
-  var res = '';
-  var stringified;
-  for (var i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) { res += ' '; }
-      res += stringified;
+function stringifyArray(value) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                { res += ' '; }
+            res += stringified;
+        }
     }
-  }
-  return res
+    return res;
 }
-
-function stringifyObject (value) {
-  var res = '';
-  for (var key in value) {
-    if (value[key]) {
-      if (res) { res += ' '; }
-      res += key;
+function stringifyObject(value) {
+    var res = '';
+    for (var key in value) {
+        if (value[key]) {
+            if (res)
+                { res += ' '; }
+            res += key;
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
 };
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isPreTag = function (tag) { return tag === 'pre'; };
-
 var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 var unknownElementCache = Object.create(null);
-function isUnknownElement (tag) {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase();
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  var el = document.createElement(tag);
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    var el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
 }
-
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
-
+/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
-function query (el) {
-  if (typeof el === 'string') {
-    var selected = document.querySelector(el);
-    if (!selected) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'Cannot find element: ' + el
-      );
-      return document.createElement('div')
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
     }
-    return selected
-  } else {
-    return el
-  }
 }
 
-/*  */
-
-function createElement$1 (tagName, vnode) {
-  var elm = document.createElement(tagName);
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple');
-  }
-  return elm
+/* @flow */
+function createElement$1(tagName, vnode) {
+    var elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
 }
-
-function createElementNS (namespace, tagName) {
-  return document.createElementNS(namespaceMap[namespace], tagName)
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
 }
-
-function createTextNode (text) {
-  return document.createTextNode(text)
+function createTextNode(text) {
+    return document.createTextNode(text);
 }
-
-function createComment (text) {
-  return document.createComment(text)
+function createComment(text) {
+    return document.createComment(text);
 }
-
-function insertBefore (parentNode, newNode, referenceNode) {
-  parentNode.insertBefore(newNode, referenceNode);
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
 }
-
-function removeChild (node, child) {
-  node.removeChild(child);
+function removeChild(node, child) {
+    node.removeChild(child);
 }
-
-function appendChild (node, child) {
-  node.appendChild(child);
+function appendChild(node, child) {
+    node.appendChild(child);
 }
-
-function parentNode (node) {
-  return node.parentNode
+function parentNode(node) {
+    return node.parentNode;
 }
-
-function nextSibling (node) {
-  return node.nextSibling
+function nextSibling(node) {
+    return node.nextSibling;
 }
-
-function tagName (node) {
-  return node.tagName
+function tagName(node) {
+    return node.tagName;
 }
-
-function setTextContent (node, text) {
-  node.textContent = text;
+function setTextContent(node, text) {
+    node.textContent = text;
 }
-
-function setStyleScope (node, scopeId) {
-  node.setAttribute(scopeId, '');
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5763,48 +5062,53 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/*  */
-
+/* @flow */
 var ref = {
-  create: function create (_, vnode) {
-    registerRef(vnode);
-  },
-  update: function update (oldVnode, vnode) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
-    }
-  },
-  destroy: function destroy (vnode) {
-    registerRef(vnode, true);
-  }
+    create: function create(_, vnode) {
+        registerRef(vnode);
+    },
+    update: function update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy: function destroy(vnode) {
+        registerRef(vnode, true);
+    },
 };
-
-function registerRef (vnode, isRemoval) {
-  var key = vnode.data.ref;
-  if (!isDef(key)) { return }
-
-  var vm = vnode.context;
-  var ref = vnode.componentInstance || vnode.elm;
-  var refs = vm.$refs;
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref);
-    } else if (refs[key] === ref) {
-      refs[key] = undefined;
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref];
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref);
-      }
-    } else {
-      refs[key] = ref;
+function registerRef(vnode, isRemoval) {
+    var key = vnode.data.ref;
+    if (!isDef(key))
+        { return; }
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
+    if (isRemoval) {
+        if (Array.isArray(refs[key])) {
+            // @ts-expect-error invalid typings
+            remove(refs[key], ref);
+        }
+        else if (refs[key] === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error invalid typings
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(refs[key])) {
+                refs[key] = [ref];
+                // @ts-expect-error invalid typings
+            }
+            else if (refs[key].indexOf(ref) < 0) {
+                // @ts-expect-error invalid typings
+                refs[key].push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
     }
-  }
 }
 
 /**
@@ -5818,1404 +5122,1300 @@ function registerRef (vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-
 var emptyNode = new VNode('', {}, []);
-
 var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') { return true }
-  var i;
-  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
-}
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  var i, key;
-  var map = {};
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key;
-    if (isDef(key)) { map[key] = i; }
-  }
-  return map
-}
-
-function createPatchFunction (backend) {
-  var i, j;
-  var cbs = {};
-
-  var modules = backend.modules;
-  var nodeOps = backend.nodeOps;
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = [];
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]]);
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove$$1 () {
-      if (--remove$$1.listeners === 0) {
-        removeNode(childElm);
-      }
-    }
-    remove$$1.listeners = listeners;
-    return remove$$1
-  }
-
-  function removeNode (el) {
-    var parent = nodeOps.parentNode(el);
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el);
-    }
-  }
-
-  function isUnknownElement$$1 (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(function (ignore) {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  var creatingElmInVPre = 0;
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode);
-    }
-
-    vnode.isRootInsert = !nested; // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        ((a.tag === b.tag &&
+            a.isComment === b.isComment &&
+            isDef(a.data) === isDef(b.data) &&
+            sameInputType(a, b)) ||
+            (isTrue(a.isAsyncPlaceholder) &&
+                a.asyncFactory === b.asyncFactory &&
+                isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        { return true; }
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    var i, key;
+    var map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            { map[key] = i; }
     }
-
-    var data = vnode.data;
-    var children = vnode.children;
-    var tag = vnode.tag;
-    if (isDef(tag)) {
-      if (process.env.NODE_ENV !== 'production') {
-        if (data && data.pre) {
-          creatingElmInVPre++;
-        }
-        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          );
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode);
-      setScope(vnode);
-
-      /* istanbul ignore if */
-      {
-        createChildren(vnode, children, insertedVnodeQueue);
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue);
-        }
-        insert(parentElm, vnode.elm, refElm);
-      }
-
-      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-        creatingElmInVPre--;
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i = vnode.data;
-    if (isDef(i)) {
-      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */);
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue);
-        insert(parentElm, vnode.elm, refElm);
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+    return map;
+}
+function createPatchFunction(backend) {
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
         }
-        return true
-      }
-    }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-      vnode.data.pendingInsert = null;
     }
-    vnode.elm = vnode.componentInstance.$el;
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue);
-      setScope(vnode);
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode);
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode);
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i;
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    var innerNode = vnode;
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode;
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode);
-        }
-        insertedVnodeQueue.push(innerNode);
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm);
-  }
-
-  function insert (parent, elm, ref$$1) {
-    if (isDef(parent)) {
-      if (isDef(ref$$1)) {
-        if (nodeOps.parentNode(ref$$1) === parent) {
-          nodeOps.insertBefore(parent, elm, ref$$1);
-        }
-      } else {
-        nodeOps.appendChild(parent, elm);
-      }
-    }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      if (process.env.NODE_ENV !== 'production') {
-        checkDuplicateKeys(children);
-      }
-      for (var i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode;
-    }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-      cbs.create[i$1](emptyNode, vnode);
-    }
-    i = vnode.data.hook; // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) { i.create(emptyNode, vnode); }
-      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
-    }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    var i;
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    } else {
-      var ancestor = vnode;
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i);
-        }
-        ancestor = ancestor.parent;
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-    }
-  }
-
-  function invokeDestroyHook (vnode) {
-    var i, j;
-    var data = vnode.data;
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
-    }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j]);
-      }
-    }
-  }
-
-  function removeVnodes (vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      var ch = vnodes[startIdx];
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch);
-          invokeDestroyHook(ch);
-        } else { // Text node
-          removeNode(ch.elm);
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      var i;
-      var listeners = cbs.remove.length + 1;
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners;
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners);
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm);
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm);
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm);
-      } else {
-        rm();
-      }
-    } else {
-      removeNode(vnode.elm);
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    var oldStartIdx = 0;
-    var newStartIdx = 0;
-    var oldEndIdx = oldCh.length - 1;
-    var oldStartVnode = oldCh[0];
-    var oldEndVnode = oldCh[oldEndIdx];
-    var newEndIdx = newCh.length - 1;
-    var newStartVnode = newCh[0];
-    var newEndVnode = newCh[newEndIdx];
-    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    var canMove = !removeOnly;
-
-    if (process.env.NODE_ENV !== 'production') {
-      checkDuplicateKeys(newCh);
-    }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx];
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        oldStartVnode = oldCh[++oldStartIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-        oldStartVnode = oldCh[++oldStartIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-        } else {
-          vnodeToMove = oldCh[idxInOld];
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-            oldCh[idxInOld] = undefined;
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          }
-        }
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    var seenKeys = {};
-    for (var i = 0; i < children.length; i++) {
-      var vnode = children[i];
-      var key = vnode.key;
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-            vnode.context
-          );
-        } else {
-          seenKeys[key] = true;
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (var i = start; i < end; i++) {
-      var c = oldCh[i];
-      if (isDef(c) && sameVnode(node, c)) { return i }
-    }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
-    }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode);
-    }
-
-    var elm = vnode.elm = oldVnode.elm;
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-      } else {
-        vnode.isAsyncPlaceholder = true;
-      }
-      return
-    }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance;
-      return
-    }
-
-    var i;
-    var data = vnode.data;
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode);
+    function createRmCb(childElm, listeners) {
+        function remove$$1() {
+            if (--remove$$1.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove$$1.listeners = listeners;
+        return remove$$1;
+    }
+    function removeNode(el) {
+        var parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
     }
-
-    var oldCh = oldVnode.children;
-    var ch = vnode.children;
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
+    function isUnknownElement$$1(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some(function (ignore) {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    var creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        var data = vnode.data;
+        var children = vnode.children;
+        var tag = vnode.tag;
+        if (isDef(tag)) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
     }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-      } else if (isDef(ch)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkDuplicateKeys(ch);
-        }
-        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-      } else if (isDef(oldCh)) {
-        removeVnodes(oldCh, 0, oldCh.length - 1);
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '');
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text);
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue;
-    } else {
-      for (var i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i]);
-      }
-    }
-  }
-
-  var hydrationBailed = false;
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    var i;
-    var tag = vnode.tag;
-    var data = vnode.data;
-    var children = vnode.children;
-    inVPre = inVPre || (data && data.pre);
-    vnode.elm = elm;
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true;
-      return true
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i = vnode.data;
+        if (isDef(i)) {
+            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
     }
-    // assert node match
-    if (process.env.NODE_ENV !== 'production') {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue);
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue);
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('server innerHTML: ', i);
-                console.warn('client innerHTML: ', elm.innerHTML);
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            var childrenMatch = true;
-            var childNode = elm.firstChild;
-            for (var i$1 = 0; i$1 < children.length; i$1++) {
-              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false;
-                break
-              }
-              childNode = childNode.nextSibling;
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        var fullInvoke = false;
-        for (var key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true;
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
             invokeCreateHooks(vnode, insertedVnodeQueue);
-            break
-          }
-        }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class']);
-        }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text;
-    }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement$$1(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-      return
-    }
-
-    var isInitialPatch = false;
-    var insertedVnodeQueue = [];
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true;
-      createElm(vnode, insertedVnodeQueue);
-    } else {
-      var isRealElement = isDef(oldVnode.nodeType);
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR);
-            hydrating = true;
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true);
-              return oldVnode
-            } else if (process.env.NODE_ENV !== 'production') {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
-              );
-            }
-          }
-          // either not server-rendered, or hydration failed.
-          // create an empty node and replace it
-          oldVnode = emptyNodeAt(oldVnode);
-        }
-
-        // replacing existing element
-        var oldElm = oldVnode.elm;
-        var parentElm = nodeOps.parentNode(oldElm);
-
-        // create new node
-        createElm(
-          vnode,
-          insertedVnodeQueue,
-          // extremely rare edge case: do not insert if old element is in a
-          // leaving transition. Only happens when combining transition +
-          // keep-alive + HOCs. (#4590)
-          oldElm._leaveCb ? null : parentElm,
-          nodeOps.nextSibling(oldElm)
-        );
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          var ancestor = vnode.parent;
-          var patchable = isPatchable(vnode);
-          while (ancestor) {
-            for (var i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor);
-            }
-            ancestor.elm = vnode.elm;
-            if (patchable) {
-              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                cbs.create[i$1](emptyNode, ancestor);
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              var insert = ancestor.data.hook.insert;
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                  insert.fns[i$2]();
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        var innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
                 }
-              }
-            } else {
-              registerRef(ancestor);
+                insertedVnodeQueue.push(innerNode);
+                break;
             }
-            ancestor = ancestor.parent;
-          }
         }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes([oldVnode], 0, 0);
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode);
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref$$1) {
+        if (isDef(parent)) {
+            if (isDef(ref$$1)) {
+                if (nodeOps.parentNode(ref$$1) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref$$1);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
         }
-      }
     }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-    return vnode.elm
-  }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            if (process.env.NODE_ENV !== 'production') {
+                checkDuplicateKeys(children);
+            }
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                { i.create(emptyNode, vnode); }
+            if (isDef(i.insert))
+                { insertedVnodeQueue.push(vnode); }
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        var i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            var ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        var i, j;
+        var data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                { i(vnode); }
+            for (i = 0; i < cbs.destroy.length; ++i)
+                { cbs.destroy[i](vnode); }
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            var ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            var i;
+            var listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        var oldStartIdx = 0;
+        var newStartIdx = 0;
+        var oldEndIdx = oldCh.length - 1;
+        var oldStartVnode = oldCh[0];
+        var oldEndVnode = oldCh[oldEndIdx];
+        var newEndIdx = newCh.length - 1;
+        var newStartVnode = newCh[0];
+        var newEndVnode = newCh[newEndIdx];
+        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        var canMove = !removeOnly;
+        if (process.env.NODE_ENV !== 'production') {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function checkDuplicateKeys(children) {
+        var seenKeys = {};
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
+            var key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                { return i; }
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        var elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        var i;
+        var data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        var oldCh = oldVnode.children;
+        var ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                { cbs.update[i](oldVnode, vnode); }
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                { i(oldVnode, vnode); }
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+            }
+            else if (isDef(ch)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    { nodeOps.setTextContent(elm, ''); }
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                { i(oldVnode, vnode); }
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    var hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        var i;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        if (process.env.NODE_ENV !== 'production') {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                { i(vnode, true /* hydrating */); }
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        var childrenMatch = true;
+                        var childNode = elm.firstChild;
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                var fullInvoke = false;
+                for (var key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement$$1(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                { invokeDestroyHook(oldVnode); }
+            return;
+        }
+        var isInitialPatch = false;
+        var insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            var isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else if (process.env.NODE_ENV !== 'production') {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                var oldElm = oldVnode.elm;
+                var parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    var ancestor = vnode.parent;
+                    var patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-/*  */
-
+/* @flow */
 var directives = {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode) {
-    updateDirectives(vnode, emptyNode);
-  }
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
 };
-
-function updateDirectives (oldVnode, vnode) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode);
-  }
-}
-
-function _update (oldVnode, vnode) {
-  var isCreate = oldVnode === emptyNode;
-  var isDestroy = vnode === emptyNode;
-  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-  var dirsWithInsert = [];
-  var dirsWithPostpatch = [];
-
-  var key, oldDir, dir;
-  for (key in newDirs) {
-    oldDir = oldDirs[key];
-    dir = newDirs[key];
-    if (!oldDir) {
-      // new directive, bind
-      callHook$1(dir, 'bind', vnode, oldVnode);
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir);
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value;
-      dir.oldArg = oldDir.arg;
-      callHook$1(dir, 'update', vnode, oldVnode);
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir);
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    var callInsert = function () {
-      for (var i = 0; i < dirsWithInsert.length; i++) {
-        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-      }
-    };
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert);
-    } else {
-      callInsert();
-    }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', function () {
-      for (var i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-      }
-    });
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-      }
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook$1(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook$1(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        var callInsert = function () {
+            for (var i = 0; i < dirsWithInsert.length; i++) {
+                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', function () {
+            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
     }
-  }
 }
-
 var emptyModifiers = Object.create(null);
-
-function normalizeDirectives$1 (
-  dirs,
-  vm
-) {
-  var res = Object.create(null);
-  if (!dirs) {
+function normalizeDirectives$1(dirs, vm) {
+    var res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    var i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
     // $flow-disable-line
-    return res
-  }
-  var i, dir;
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i];
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers;
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+}
+function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+    var fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+        }
     }
-    res[getRawDirName(dir)] = dir;
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-  }
-  // $flow-disable-line
-  return res
 }
 
-function getRawDirName (dir) {
-  return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
-}
+var baseModules = [ref, directives];
 
-function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-  var fn = dir.def && dir.def[hook];
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-    } catch (e) {
-      handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
-    }
-  }
-}
-
-var baseModules = [
-  ref,
-  directives
-];
-
-/*  */
-
-function updateAttrs (oldVnode, vnode) {
-  var opts = vnode.componentOptions;
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  var key, cur, old;
-  var elm = vnode.elm;
-  var oldAttrs = oldVnode.data.attrs || {};
-  var attrs = vnode.data.attrs || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__)) {
-    attrs = vnode.data.attrs = extend({}, attrs);
-  }
-
-  for (key in attrs) {
-    cur = attrs[key];
-    old = oldAttrs[key];
-    if (old !== cur) {
-      setAttr(elm, key, cur);
-    }
-  }
-  // #4391: in IE9, setting type can reset value for input[type=radio]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value);
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key);
-      }
-    }
-  }
-}
-
-function setAttr (el, key, value) {
-  if (el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value);
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key;
-      el.setAttribute(key, value);
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value));
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-    } else {
-      el.setAttributeNS(xlinkNS, key, value);
-    }
-  } else {
-    baseSetAttr(el, key, value);
-  }
-}
-
-function baseSetAttr (el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key);
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
+/* @flow */
+function updateAttrs(oldVnode, vnode) {
+    var opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
     /* istanbul ignore if */
-    if (
-      isIE && !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
-    ) {
-      var blocker = function (e) {
-        e.stopImmediatePropagation();
-        el.removeEventListener('input', blocker);
-      };
-      el.addEventListener('input', blocker);
-      // $flow-disable-line
-      el.__ieph = true; /* IE placeholder patched */
-    }
-    el.setAttribute(key, value);
-  }
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            var blocker = function (e) {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
 }
-
 var attrs = {
-  create: updateAttrs,
-  update: updateAttrs
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-/*  */
-
-function updateClass (oldVnode, vnode) {
-  var el = vnode.elm;
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
-  ) {
-    return
-  }
-
-  var cls = genClassForVnode(vnode);
-
-  // handle transition classes
-  var transitionClass = el._transitionClasses;
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass));
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls);
-    el._prevClass = cls;
-  }
+/* @flow */
+function updateClass(oldVnode, vnode) {
+    var el = vnode.elm;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    var cls = genClassForVnode(vnode);
+    // handle transition classes
+    var transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
 }
-
 var klass = {
-  create: updateClass,
-  update: updateClass
+    create: updateClass,
+    update: updateClass,
 };
 
-/*  */
-
+/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function parseFilters(exp) {
+    var inSingle = false;
+    var inDouble = false;
+    var inTemplateString = false;
+    var inRegex = false;
+    var curly = 0;
+    var square = 0;
+    var paren = 0;
+    var lastFilterIndex = 0;
+    var c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                { inSingle = false; }
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                { inDouble = false; }
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                { inTemplateString = false; }
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                { inRegex = false; }
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                var j = i - 1;
+                var p = (void 0);
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        { break; }
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
-    }
-  }
-
-  return expression
-}
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
-}
-
-/*  */
-
-
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    var i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return ("_f(\"" + filter + "\")(" + exp + ")");
+    }
+    else {
+        var name = filter.slice(0, i);
+        var args = filter.slice(i + 1);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+    }
+}
 
+/* @flow */
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    var attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
-}
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-}
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    var events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    var handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        var staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
+function getAndRemoveAttr(el, name, removeFromMap) {
+    var val;
+    if ((val = el.attrsMap[name]) != null) {
+        var list = el.attrsList;
+        for (var i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
     }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
+    if (removeFromMap) {
+        delete el.attrsMap[name];
     }
-  }
+    return val;
 }
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
+function getAndRemoveAttrByRegex(el, name) {
+    var list = el.attrsList;
+    for (var i = 0, l = list.length; i < l; i++) {
+        var attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-    if (range.end != null) {
-      item.end = range.end;
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
     }
-  }
-  return item
+    return item;
 }
 
-/*  */
-
+/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
+    var baseValueExpression = '$$v';
+    var valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            "(typeof " + baseValueExpression + " === 'string'" +
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: ("(" + value + ")"),
+        expression: JSON.stringify(value),
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    var res = parseModel(value);
+    if (res.key === null) {
+        return (value + "=" + assignment);
+    }
+    else {
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -7230,2048 +6430,2139 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
 var len, str, chr, index$1, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index$1 = val.lastIndexOf('.');
-    if (index$1 > -1) {
-      return {
-        exp: val.slice(0, index$1),
-        key: '"' + val.slice(index$1 + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index$1 = val.lastIndexOf('.');
+        if (index$1 > -1) {
+            return {
+                exp: val.slice(0, index$1),
+                key: '"' + val.slice(index$1 + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  str = val;
-  index$1 = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+    str = val;
+    index$1 = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index$1)
+function next() {
+    return str.charCodeAt(++index$1);
 }
-
-function eof () {
-  return index$1 >= len
+function eof() {
+    return index$1 >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index$1;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index$1;
-      break
+function parseBracket(chr) {
+    var inBracket = 1;
+    expressionPos = index$1;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            { inBracket++; }
+        if (chr === 0x5d)
+            { inBracket--; }
+        if (inBracket === 0) {
+            expressionEndPos = index$1;
+            break;
+        }
     }
-  }
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    var stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 var warn$1;
-
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-
-function model (
-  el,
-  dir,
-  _warn
-) {
-  warn$1 = _warn;
-  var value = dir.value;
-  var modifiers = dir.modifiers;
-  var tag = el.tag;
-  var type = el.attrsMap.type;
-
-  if (process.env.NODE_ENV !== 'production') {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-        "File inputs are read only. Use a v-on:change listener instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else if (!config.isReservedTag(tag)) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$1(
-      "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-      "v-model is not supported on this element type. " +
-      'If you are working with contenteditable, it\'s recommended to ' +
-      'wrap a library dedicated for that purpose inside a custom component.',
-      el.rawAttrsMap['v-model']
-    );
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    "Array.isArray(" + value + ")" +
-    "?_i(" + value + "," + valueBinding + ")>-1" + (
-      trueValueBinding === 'true'
-        ? (":(" + value + ")")
-        : (":_q(" + value + "," + trueValueBinding + ")")
-    )
-  );
-  addHandler(el, 'change',
-    "var $$a=" + value + "," +
+function model(el, dir, _warn) {
+    warn$1 = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
+        (trueValueBinding === 'true'
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
+    addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
         "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-    'if(Array.isArray($$a)){' +
-      "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-      "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-      "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-    "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-  addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var selectedVal = "Array.prototype.filter" +
-    ".call($event.target.options,function(o){return o.selected})" +
-    ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-    "return " + (number ? '_n(val)' : 'val') + "})";
-
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  var code = "var $$selectedVal = " + selectedVal + ";";
-  code = code + " " + (genAssignmentCode(value, assignment));
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  if (process.env.NODE_ENV !== 'production') {
-    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value$1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$1(
-        binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var number = ref.number;
-  var trim = ref.trim;
-  var needCompositionGuard = !lazy && type !== 'range';
-  var event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  var valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = "$event.target.value.trim()";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = "if($event.target.composing)return;" + code;
-  }
-
-  addProp(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
-}
-
-/*  */
+        'if(Array.isArray($$a)){' +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        '$$i=_i($$a,$$v);' +
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        "return " + (number ? '_n(val)' : 'val') + "})";
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + (genAssignmentCode(value, assignment));
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value$1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', ("(" + value + ")"));
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
+/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
 // user-attached handlers.
-function normalizeEvents (on) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    var event = isIE ? 'change' : 'input';
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-    delete on[RANGE_TOKEN];
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-    delete on[CHECKBOX_RADIO_TOKEN];
-  }
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
 }
-
 var target$1;
-
-function createOnceHandler$1 (event, handler, capture) {
-  var _target = target$1; // save current target element in closure
-  return function onceHandler () {
-    var res = handler.apply(null, arguments);
-    if (res !== null) {
-      remove$2(event, onceHandler, capture, _target);
-    }
-  }
+function createOnceHandler$1(event, handler, capture) {
+    var _target = target$1; // save current target element in closure
+    return function onceHandler() {
+        var res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove$2(event, onceHandler, capture, _target);
+        }
+    };
 }
-
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-function add$1 (
-  name,
-  handler,
-  capture,
-  passive
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    var attachedTimestamp = currentFlushTimestamp;
-    var original = handler;
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    };
-  }
-  target$1.addEventListener(
-    name,
-    handler,
-    supportsPassive
-      ? { capture: capture, passive: passive }
-      : capture
-  );
-}
-
-function remove$2 (
-  name,
-  handler,
-  capture,
-  _target
-) {
-  (_target || target$1).removeEventListener(
-    name,
-    handler._wrapper || handler,
-    capture
-  );
-}
-
-function updateDOMListeners (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  var on = vnode.data.on || {};
-  var oldOn = oldVnode.data.on || {};
-  target$1 = vnode.elm;
-  normalizeEvents(on);
-  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-  target$1 = undefined;
+function add$1(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
+        //@ts-expect-error
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+}
+function remove$2(name, handler, capture, _target) {
+    (_target || target$1).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target$1 = vnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+    target$1 = undefined;
 }
-
 var events = {
-  create: updateDOMListeners,
-  update: updateDOMListeners
+    create: updateDOMListeners,
+    update: updateDOMListeners,
 };
 
-/*  */
-
+/* @flow */
 var svgContainer;
-
-function updateDOMProps (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  var key, cur;
-  var elm = vnode.elm;
-  var oldProps = oldVnode.data.domProps || {};
-  var props = vnode.data.domProps || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
-    props = vnode.data.domProps = extend({}, props);
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      elm[key] = '';
-    }
-  }
-
-  for (key in props) {
-    cur = props[key];
-    // ignore children if the node has textContent or innerHTML,
-    // as these will throw away existing DOM nodes and cause removal errors
-    // on subsequent patches (#3360)
-    if (key === 'textContent' || key === 'innerHTML') {
-      if (vnode.children) { vnode.children.length = 0; }
-      if (cur === oldProps[key]) { continue }
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0]);
-      }
-    }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // store value as _value as well since
-      // non-string values will be stringified
-      elm._value = cur;
-      // avoid resetting cursor position when value is the same
-      var strCur = isUndef(cur) ? '' : String(cur);
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur;
-      }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div');
-      svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-      var svg = svgContainer.firstChild;
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild);
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild);
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecessary `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur;
-      } catch (e) {}
-    }
-  }
-}
-
-// check platforms/web/util/attrs.js acceptValue
-
-
-function shouldUpdateValue (elm, checkVal) {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
-}
-
-function isNotInFocusAndDirty (elm, checkVal) {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  var notInFocus = true;
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm; } catch (e) {}
-  return notInFocus && elm.value !== checkVal
-}
-
-function isDirtyWithModifiers (elm, newVal) {
-  var value = elm.value;
-  var modifiers = elm._vModifiers; // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
-    }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
-    }
-  }
-  return value !== newVal
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    var key, cur;
+    var elm = vnode.elm;
+    var oldProps = oldVnode.data.domProps || {};
+    var props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                { vnode.children.length = 0; }
+            if (cur === oldProps[key])
+                { continue; }
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            var strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+            var svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    var notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    var value = elm.value;
+    var modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
 }
-
 var domProps = {
-  create: updateDOMProps,
-  update: updateDOMProps
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-/*  */
-
+/* @flow */
 var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  var style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    var style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  var res = {};
-  var styleData;
-
-  if (checkChild) {
-    var childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    var res = {};
+    var styleData;
+    if (checkChild) {
+        var childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  var parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    var parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val);
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-  } else {
-    var normalizedName = normalize(name);
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (var i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i];
-      }
-    } else {
-      el.style[normalizedName] = val;
-    }
-  }
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        var normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (var i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
 };
-
 var vendorNames = ['Webkit', 'Moz', 'ms'];
-
 var emptyStyle;
 var normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style;
-  prop = camelize(prop);
-  if (prop !== 'filter' && (prop in emptyStyle)) {
-    return prop
-  }
-  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-  for (var i = 0; i < vendorNames.length; i++) {
-    var name = vendorNames[i] + capName;
-    if (name in emptyStyle) {
-      return name
-    }
-  }
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (var i = 0; i < vendorNames.length; i++) {
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
 });
-
-function updateStyle (oldVnode, vnode) {
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  var cur, name;
-  var el = vnode.elm;
-  var oldStaticStyle = oldData.staticStyle;
-  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  var oldStyle = oldStaticStyle || oldStyleBinding;
-
-  var style = normalizeStyleBinding(vnode.data.style) || {};
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style;
-
-  var newStyle = getStyle(vnode, true);
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      setProp(el, name, '');
+function updateStyle(oldVnode, vnode) {
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    var cur, name;
+    var el = vnode.elm;
+    var oldStaticStyle = oldData.staticStyle;
+    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    var oldStyle = oldStaticStyle || oldStyleBinding;
+    var style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    var newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
     }
-  }
-  for (name in newStyle) {
-    cur = newStyle[name];
-    if (cur !== oldStyle[name]) {
-      // ie9 setting to null has no effect, must use empty string
-      setProp(el, name, cur == null ? '' : cur);
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
     }
-  }
 }
-
 var style = {
-  create: updateStyle,
-  update: updateStyle
+    create: updateStyle,
+    update: updateStyle,
 };
 
-/*  */
-
+/* @flow */
 var whitespaceRE = /\s+/;
-
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-    } else {
-      el.classList.add(cls);
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
     }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    if (cur.indexOf(' ' + cls + ' ') < 0) {
-      el.setAttribute('class', (cur + cls).trim());
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
     }
-  }
 }
-
 /**
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-    } else {
-      el.classList.remove(cls);
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class');
-    }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    var tar = ' ' + cls + ' ';
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ');
-    }
-    cur = cur.trim();
-    if (cur) {
-      el.setAttribute('class', cur);
-    } else {
-      el.removeAttribute('class');
-    }
-  }
-}
-
-/*  */
-
-function resolveTransition (def$$1) {
-  if (!def$$1) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def$$1 === 'object') {
-    var res = {};
-    if (def$$1.css !== false) {
-      extend(res, autoCssTransition(def$$1.name || 'v'));
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
     }
-    extend(res, def$$1);
-    return res
-  } else if (typeof def$$1 === 'string') {
-    return autoCssTransition(def$$1)
-  }
 }
 
+function resolveTransition(def$$1) {
+    if (!def$$1) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def$$1 === 'object') {
+        var res = {};
+        if (def$$1.css !== false) {
+            extend(res, autoCssTransition(def$$1.name || 'v'));
+        }
+        extend(res, def$$1);
+        return res;
+    }
+    else if (typeof def$$1 === 'string') {
+        return autoCssTransition(def$$1);
+    }
+}
 var autoCssTransition = cached(function (name) {
-  return {
-    enterClass: (name + "-enter"),
-    enterToClass: (name + "-enter-to"),
-    enterActiveClass: (name + "-enter-active"),
-    leaveClass: (name + "-leave"),
-    leaveToClass: (name + "-leave-to"),
-    leaveActiveClass: (name + "-leave-active")
-  }
+    return {
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
+    };
 });
-
 var hasTransition = inBrowser && !isIE9;
 var TRANSITION = 'transition';
 var ANIMATION = 'animation';
-
 // Transition property/event sniffing
 var transitionProp = 'transition';
 var transitionEndEvent = 'transitionend';
 var animationProp = 'animation';
 var animationEndEvent = 'animationend';
 if (hasTransition) {
-  /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    transitionProp = 'WebkitTransition';
-    transitionEndEvent = 'webkitTransitionEnd';
-  }
-  if (window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    animationProp = 'WebkitAnimation';
-    animationEndEvent = 'webkitAnimationEnd';
-  }
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
 }
-
 // binding to window is necessary to make hot reload work in IE in strict mode
 var raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ function (fn) { return fn(); };
-
-function nextFrame (fn) {
-  raf(function () {
-    raf(fn);
-  });
-}
-
-function addTransitionClass (el, cls) {
-  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls);
-    addClass(el, cls);
-  }
-}
-
-function removeTransitionClass (el, cls) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls);
-  }
-  removeClass(el, cls);
-}
-
-function whenTransitionEnds (
-  el,
-  expectedType,
-  cb
-) {
-  var ref = getTransitionInfo(el, expectedType);
-  var type = ref.type;
-  var timeout = ref.timeout;
-  var propCount = ref.propCount;
-  if (!type) { return cb() }
-  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-  var ended = 0;
-  var end = function () {
-    el.removeEventListener(event, onEnd);
-    cb();
-  };
-  var onEnd = function (e) {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end();
-      }
-    }
-  };
-  setTimeout(function () {
-    if (ended < propCount) {
-      end();
-    }
-  }, timeout + 1);
-  el.addEventListener(event, onEnd);
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
 }
-
 var transformRE = /\b(transform|all)(,|$)/;
-
-function getTransitionInfo (el, expectedType) {
-  var styles = window.getComputedStyle(el);
-  // JSDOM may return undefined for transition properties
-  var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-  var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-  var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-  var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-  var animationTimeout = getTimeout(animationDelays, animationDurations);
-
-  var type;
-  var timeout = 0;
-  var propCount = 0;
-  /* istanbul ignore if */
-  if (expectedType === TRANSITION) {
-    if (transitionTimeout > 0) {
-      type = TRANSITION;
-      timeout = transitionTimeout;
-      propCount = transitionDurations.length;
-    }
-  } else if (expectedType === ANIMATION) {
-    if (animationTimeout > 0) {
-      type = ANIMATION;
-      timeout = animationTimeout;
-      propCount = animationDurations.length;
-    }
-  } else {
-    timeout = Math.max(transitionTimeout, animationTimeout);
-    type = timeout > 0
-      ? transitionTimeout > animationTimeout
-        ? TRANSITION
-        : ANIMATION
-      : null;
-    propCount = type
-      ? type === TRANSITION
-        ? transitionDurations.length
-        : animationDurations.length
-      : 0;
-  }
-  var hasTransform =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property']);
-  return {
-    type: type,
-    timeout: timeout,
-    propCount: propCount,
-    hasTransform: hasTransform
-  }
-}
-
-function getTimeout (delays, durations) {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
-  }
-
-  return Math.max.apply(null, durations.map(function (d, i) {
-    return toMs(d) + toMs(delays[i])
-  }))
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
 }
-
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs (s) {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
-}
-
-/*  */
-
-function enter (vnode, toggleDisplay) {
-  var el = vnode.elm;
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true;
-    el._leaveCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var enterClass = data.enterClass;
-  var enterToClass = data.enterToClass;
-  var enterActiveClass = data.enterActiveClass;
-  var appearClass = data.appearClass;
-  var appearToClass = data.appearToClass;
-  var appearActiveClass = data.appearActiveClass;
-  var beforeEnter = data.beforeEnter;
-  var enter = data.enter;
-  var afterEnter = data.afterEnter;
-  var enterCancelled = data.enterCancelled;
-  var beforeAppear = data.beforeAppear;
-  var appear = data.appear;
-  var afterAppear = data.afterAppear;
-  var appearCancelled = data.appearCancelled;
-  var duration = data.duration;
-
-  // activeInstance will always be the <transition> component managing this
-  // transition. One edge case to check is when the <transition> is placed
-  // as the root node of a child component. In that case we need to check
-  // <transition>'s parent for appear check.
-  var context = activeInstance;
-  var transitionNode = activeInstance.$vnode;
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context;
-    transitionNode = transitionNode.parent;
-  }
-
-  var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  var startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass;
-  var activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass;
-  var toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass;
-
-  var beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter;
-  var enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
-    : enter;
-  var afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter;
-  var enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
-    : enterCancelled;
-
-  var explicitEnterDuration = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
-  );
-
-  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode);
-  }
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(enterHook);
-
-  var cb = el._enterCb = once(function () {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass);
-      removeTransitionClass(el, activeClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, startClass);
-      }
-      enterCancelledHook && enterCancelledHook(el);
-    } else {
-      afterEnterHook && afterEnterHook(el);
-    }
-    el._enterCb = null;
-  });
-
-  if (!vnode.data.show) {
-    // remove pending leave element on enter by injecting an insert hook
-    mergeVNodeHook(vnode, 'insert', function () {
-      var parent = el.parentNode;
-      var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-      if (pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb();
-      }
-      enterHook && enterHook(el, cb);
-    });
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el);
-  if (expectsCSS) {
-    addTransitionClass(el, startClass);
-    addTransitionClass(el, activeClass);
-    nextFrame(function () {
-      removeTransitionClass(el, startClass);
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass);
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration);
-          } else {
-            whenTransitionEnds(el, type, cb);
-          }
-        }
-      }
-    });
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay();
-    enterHook && enterHook(el, cb);
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb();
-  }
-}
-
-function leave (vnode, rm) {
-  var el = vnode.elm;
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true;
-    el._enterCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var leaveClass = data.leaveClass;
-  var leaveToClass = data.leaveToClass;
-  var leaveActiveClass = data.leaveActiveClass;
-  var beforeLeave = data.beforeLeave;
-  var leave = data.leave;
-  var afterLeave = data.afterLeave;
-  var leaveCancelled = data.leaveCancelled;
-  var delayLeave = data.delayLeave;
-  var duration = data.duration;
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(leave);
-
-  var explicitLeaveDuration = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
-  );
-
-  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode);
-  }
-
-  var cb = el._leaveCb = once(function () {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null;
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+/* @flow */
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
     }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass);
-      removeTransitionClass(el, leaveActiveClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass);
-      }
-      leaveCancelled && leaveCancelled(el);
-    } else {
-      rm();
-      afterLeave && afterLeave(el);
-    }
-    el._leaveCb = null;
-  });
-
-  if (delayLeave) {
-    delayLeave(performLeave);
-  } else {
-    performLeave();
-  }
-
-  function performLeave () {
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
-    }
-    beforeLeave && beforeLeave(el);
-    if (expectsCSS) {
-      addTransitionClass(el, leaveClass);
-      addTransitionClass(el, leaveActiveClass);
-      nextFrame(function () {
-        removeTransitionClass(el, leaveClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-    leave && leave(el, cb);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
     if (!expectsCSS && !userWantsControl) {
-      cb();
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
     }
-  }
 }
-
 // only used in dev mode
-function checkDuration (val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      "<transition> explicit " + name + " duration is not a valid number - " +
-      "got " + (JSON.stringify(val)) + ".",
-      vnode.context
-    );
-  } else if (isNaN(val)) {
-    warn(
-      "<transition> explicit " + name + " duration is NaN - " +
-      'the duration expression might be incorrect.',
-      vnode.context
-    );
-  }
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn("<transition> explicit " + name + " duration is not a valid number - " +
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
 }
-
-function isValidDuration (val) {
-  return typeof val === 'number' && !isNaN(val)
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
 }
-
 /**
  * Normalize a transition hook's argument length. The hook may be:
  * - a merged hook (invoker) with the original in .fns
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength (fn) {
-  if (isUndef(fn)) {
-    return false
-  }
-  var invokerFns = fn.fns;
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
-    )
-  } else {
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter (_, vnode) {
-  if (vnode.data.show !== true) {
-    enter(vnode);
-  }
-}
-
-var transition = inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove: function remove$$1 (vnode, rm) {
-    /* istanbul ignore else */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-      leave(vnode, rm);
-    } else {
-      rm();
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove: function remove$$1(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
     }
-  }
-} : {};
+    : {};
 
-var platformModules = [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-];
-
-/*  */
+var platformModules = [attrs, klass, events, domProps, style, transition];
 
+/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
-
 var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
  * properties to Elements.
  */
-
 /* istanbul ignore if */
 if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', function () {
-    var el = document.activeElement;
-    if (el && el.vmodel) {
-      trigger(el, 'input');
-    }
-  });
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', function () {
+        var el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
 }
-
 var directive = {
-  inserted: function inserted (el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-          directive.componentUpdated(el, binding, vnode);
-        });
-      } else {
-        setSelected(el, binding, vnode.context);
-      }
-      el._vOptions = [].map.call(el.options, getValue);
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers;
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart);
-        el.addEventListener('compositionend', onCompositionEnd);
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd);
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true;
-        }
-      }
-    }
-  },
-
-  componentUpdated: function componentUpdated (el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context);
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      var prevOptions = el._vOptions;
-      var curOptions = el._vOptions = [].map.call(el.options, getValue);
-      if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-        // trigger change event if
-        // no matching option found for at least one value
-        var needReset = el.multiple
-          ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-        if (needReset) {
-          trigger(el, 'change');
-        }
-      }
-    }
-  }
+    inserted: function inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', function () {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated: function componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                // trigger change event if
+                // no matching option found for at least one value
+                var needReset = el.multiple
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
 };
-
-function setSelected (el, binding, vm) {
-  actuallySetSelected(el, binding, vm);
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(function () {
-      actuallySetSelected(el, binding, vm);
-    }, 0);
-  }
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(function () {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
 }
-
-function actuallySetSelected (el, binding, vm) {
-  var value = binding.value;
-  var isMultiple = el.multiple;
-  if (isMultiple && !Array.isArray(value)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      "<select multiple v-model=\"" + (binding.expression) + "\"> " +
-      "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
-      vm
-    );
-    return
-  }
-  var selected, option;
-  for (var i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i];
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1;
-      if (option.selected !== selected) {
-        option.selected = selected;
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i;
+function actuallySetSelected(el, binding, vm) {
+    var value = binding.value;
+    var isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)), vm);
+        return;
+    }
+    var selected, option;
+    for (var i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
         }
-        return
-      }
     }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1;
-  }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
 }
-
-function hasNoMatchingOption (value, options) {
-  return options.every(function (o) { return !looseEqual(o, value); })
+function hasNoMatchingOption(value, options) {
+    return options.every(function (o) { return !looseEqual(o, value); });
 }
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
 }
-
-function onCompositionStart (e) {
-  e.target.composing = true;
+function onCompositionStart(e) {
+    e.target.composing = true;
 }
-
-function onCompositionEnd (e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) { return }
-  e.target.composing = false;
-  trigger(e.target, 'input');
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        { return; }
+    e.target.composing = false;
+    trigger(e.target, 'input');
 }
-
-function trigger (el, type) {
-  var e = document.createEvent('HTMLEvents');
-  e.initEvent(type, true, true);
-  el.dispatchEvent(e);
+function trigger(el, type) {
+    var e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-/*  */
-
+/* @flow */
 // recursively search for possible transition defined inside the component root
-function locateNode (vnode) {
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
-    : vnode
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
 }
-
 var show = {
-  bind: function bind (el, ref, vnode) {
-    var value = ref.value;
-
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    var originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display;
-    if (value && transition$$1) {
-      vnode.data.show = true;
-      enter(vnode, function () {
-        el.style.display = originalDisplay;
-      });
-    } else {
-      el.style.display = value ? originalDisplay : 'none';
-    }
-  },
-
-  update: function update (el, ref, vnode) {
-    var value = ref.value;
-    var oldValue = ref.oldValue;
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition$$1) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
 
-    /* istanbul ignore if */
-    if (!value === !oldValue) { return }
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    if (transition$$1) {
-      vnode.data.show = true;
-      if (value) {
-        enter(vnode, function () {
-          el.style.display = el.__vOriginalDisplay;
-        });
-      } else {
-        leave(vnode, function () {
-          el.style.display = 'none';
-        });
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none';
-    }
-  },
-
-  unbind: function unbind (
-    el,
-    binding,
-    vnode,
-    oldVnode,
-    isDestroy
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay;
-    }
-  }
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            { return; }
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        if (transition$$1) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, function () {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
 var platformDirectives = {
-  model: directive,
-  show: show
+    model: directive,
+    show: show,
 };
 
-/*  */
-
+/* @flow */
 var transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
 };
-
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode) {
-  var compOptions = vnode && vnode.componentOptions;
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-function extractTransitionData (comp) {
-  var data = {};
-  var options = comp.$options;
-  // props
-  for (var key in options.propsData) {
-    data[key] = comp[key];
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  var listeners = options._parentListeners;
-  for (var key$1 in listeners) {
-    data[camelize(key$1)] = listeners[key$1];
-  }
-  return data
-}
-
-function placeholder (h, rawChild) {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
+function getRealChild(vnode) {
+    var compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    var data = {};
+    var options = comp.$options;
+    // props
+    for (var key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    var listeners = options._parentListeners;
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
 }
-
-function hasParentTransition (vnode) {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
     }
-  }
 }
-
-function isSameChild (child, oldChild) {
-  return oldChild.key === child.key && oldChild.tag === child.tag
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-
 var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
 var isVShowDirective = function (d) { return d.name === 'show'; };
-
 var Transition = {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render: function render (h) {
-    var this$1 = this;
-
-    var children = this.$slots.default;
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode);
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      );
-    }
-
-    var mode = this.mode;
-
-    // warn invalid mode
-    if (process.env.NODE_ENV !== 'production' &&
-      mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      );
-    }
-
-    var rawChild = children[0];
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    var child = getRealChild(rawChild);
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    var id = "__transition-" + (this._uid) + "-";
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key;
-
-    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-    var oldRawChild = this._vnode;
-    var oldChild = getRealChild(oldRawChild);
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true;
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      var oldData = oldChild.data.transition = extend({}, data);
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true;
-        mergeVNodeHook(oldData, 'afterLeave', function () {
-          this$1._leaving = false;
-          this$1.$forceUpdate();
-        });
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render: function render(h) {
+        var this$1 = this;
+
+        var children = this.$slots.default;
+        if (!children) {
+            return;
         }
-        var delayedLeave;
-        var performLeave = function () { delayedLeave(); };
-        mergeVNodeHook(data, 'afterEnter', performLeave);
-        mergeVNodeHook(data, 'enterCancelled', performLeave);
-        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-      }
-    }
-
-    return rawChild
-  }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        var mode = this.mode;
+        // warn invalid mode
+        if (process.env.NODE_ENV !== 'production' &&
+            mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        var rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        var child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        var id = "__transition-" + (this._uid) + "-";
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        var oldRawChild = this._vnode;
+        var oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            var oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', function () {
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                var delayedLeave;
+                var performLeave = function () {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-/*  */
-
+// Provides transition support for list items.
 var props = extend({
-  tag: String,
-  moveClass: String
+    tag: String,
+    moveClass: String,
 }, transitionProps);
-
+// @ts-ignore
 delete props.mode;
-
 var TransitionGroup = {
-  props: props,
-
-  beforeMount: function beforeMount () {
-    var this$1 = this;
-
-    var update = this._update;
-    this._update = function (vnode, hydrating) {
-      var restoreActiveInstance = setActiveInstance(this$1);
-      // force removing pass
-      this$1.__patch__(
-        this$1._vnode,
-        this$1.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      );
-      this$1._vnode = this$1.kept;
-      restoreActiveInstance();
-      update.call(this$1, vnode, hydrating);
-    };
-  },
-
-  render: function render (h) {
-    var tag = this.tag || this.$vnode.data.tag || 'span';
-    var map = Object.create(null);
-    var prevChildren = this.prevChildren = this.children;
-    var rawChildren = this.$slots.default || [];
-    var children = this.children = [];
-    var transitionData = extractTransitionData(this);
-
-    for (var i = 0; i < rawChildren.length; i++) {
-      var c = rawChildren[i];
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c);
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData;
-        } else if (process.env.NODE_ENV !== 'production') {
-          var opts = c.componentOptions;
-          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-          warn(("<transition-group> children must be keyed: <" + name + ">"));
-        }
-      }
-    }
-
-    if (prevChildren) {
-      var kept = [];
-      var removed = [];
-      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-        var c$1 = prevChildren[i$1];
-        c$1.data.transition = transitionData;
-        c$1.data.pos = c$1.elm.getBoundingClientRect();
-        if (map[c$1.key]) {
-          kept.push(c$1);
-        } else {
-          removed.push(c$1);
-        }
-      }
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated: function updated () {
-    var children = this.prevChildren;
-    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs);
-    children.forEach(recordPosition);
-    children.forEach(applyTranslation);
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight;
-
-    children.forEach(function (c) {
-      if (c.data.moved) {
-        var el = c.elm;
-        var s = el.style;
-        addTransitionClass(el, moveClass);
-        s.transform = s.WebkitTransform = s.transitionDuration = '';
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb);
-            el._moveCb = null;
-            removeTransitionClass(el, moveClass);
-          }
+    props: props,
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
+        var update = this._update;
+        this._update = function (vnode, hydrating) {
+            var restoreActiveInstance = setActiveInstance(this$1);
+            // force removing pass
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this$1._vnode = this$1.kept;
+            restoreActiveInstance();
+            update.call(this$1, vnode, hydrating);
+        };
+    },
+    render: function render(h) {
+        var tag = this.tag || this.$vnode.data.tag || 'span';
+        var map = Object.create(null);
+        var prevChildren = (this.prevChildren = this.children);
+        var rawChildren = this.$slots.default || [];
+        var children = (this.children = []);
+        var transitionData = extractTransitionData(this);
+        for (var i = 0; i < rawChildren.length; i++) {
+            var c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    var opts = c.componentOptions;
+                    var name = opts
+                        ? opts.Ctor.options.name || opts.tag || ''
+                        : c.tag;
+                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                }
+            }
+        }
+        if (prevChildren) {
+            var kept = [];
+            var removed = [];
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
+                // @ts-ignore
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                // @ts-ignore
+                if (map[c$1.key]) {
+                    kept.push(c$1);
+                }
+                else {
+                    removed.push(c$1);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated: function updated() {
+        var children = this.prevChildren;
+        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach(function (c) {
+            // @ts-ignore
+            if (c.data.moved) {
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
         });
-      }
-    });
-  },
-
-  methods: {
-    hasMove: function hasMove (el, moveClass) {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      var clone = el.cloneNode();
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
-      }
-      addClass(clone, moveClass);
-      clone.style.display = 'none';
-      this.$el.appendChild(clone);
-      var info = getTransitionInfo(clone);
-      this.$el.removeChild(clone);
-      return (this._hasMove = info.hasTransform)
-    }
-  }
+    },
+    methods: {
+        hasMove: function hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            var clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach(function (cls) {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = 'none';
+            this.$el.appendChild(clone);
+            var info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
 };
-
-function callPendingCbs (c) {
-  /* istanbul ignore if */
-  if (c.elm._moveCb) {
-    c.elm._moveCb();
-  }
-  /* istanbul ignore if */
-  if (c.elm._enterCb) {
-    c.elm._enterCb();
-  }
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._moveCb) {
+        //@ts-ignore
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._enterCb) {
+        //@ts-ignore
+        c.elm._enterCb();
+    }
 }
-
-function recordPosition (c) {
-  c.data.newPos = c.elm.getBoundingClientRect();
+function recordPosition(c) {
+    //@ts-ignore
+    c.data.newPos = c.elm.getBoundingClientRect();
 }
-
-function applyTranslation (c) {
-  var oldPos = c.data.pos;
-  var newPos = c.data.newPos;
-  var dx = oldPos.left - newPos.left;
-  var dy = oldPos.top - newPos.top;
-  if (dx || dy) {
-    c.data.moved = true;
-    var s = c.elm.style;
-    s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-    s.transitionDuration = '0s';
-  }
+function applyTranslation(c) {
+    //@ts-ignore
+    var oldPos = c.data.pos;
+    //@ts-ignore
+    var newPos = c.data.newPos;
+    var dx = oldPos.left - newPos.left;
+    var dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        //@ts-ignore
+        c.data.moved = true;
+        //@ts-ignore
+        var s = c.elm.style;
+        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+        s.transitionDuration = '0s';
+    }
 }
 
 var platformComponents = {
-  Transition: Transition,
-  TransitionGroup: TransitionGroup
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
 };
 
-/*  */
-
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp;
 Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
 Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
-
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
 extend(Vue.options.components, platformComponents);
-
 // install platform patch function
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
 // public mount method
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && inBrowser ? query(el) : undefined;
-  return mountComponent(this, el, hydrating)
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
 };
-
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-  setTimeout(function () {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue);
-      } else if (
-        process.env.NODE_ENV !== 'production' &&
-        process.env.NODE_ENV !== 'test'
-      ) {
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
-        );
-      }
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-      process.env.NODE_ENV !== 'test' &&
-      config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      console[console.info ? 'info' : 'log'](
-        "You are running Vue in development mode.\n" +
-        "Make sure to turn on production mode when deploying for production.\n" +
-        "See more tips at https://vuejs.org/guide/deployment.html"
-      );
-    }
-  }, 0);
+    setTimeout(function () {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else if (process.env.NODE_ENV !== 'production' &&
+                process.env.NODE_ENV !== 'test') {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (process.env.NODE_ENV !== 'production' &&
+            process.env.NODE_ENV !== 'test' &&
+            config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                "Make sure to turn on production mode when deploying for production.\n" +
+                "See more tips at https://vuejs.org/guide/deployment.html");
+        }
+    }, 0);
 }
 
-/*  */
-
+/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
 var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
-
-/*  */
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  if (process.env.NODE_ENV !== 'production' && staticClass) {
-    var res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        "class=\"" + staticClass + "\": " +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
-}
-
-function genData (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    var tokens = [];
+    var rawTokens = [];
+    var lastIndex = (tagRE.lastIndex = 0);
+    var match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        var exp = parseFilters(match[1].trim());
+        tokens.push(("_s(" + exp + ")"));
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
+/* @flow */
+function transformNode(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticClass = getAndRemoveAttr(el, 'class');
+    if (process.env.NODE_ENV !== 'production' && staticClass) {
+        var res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn("class=\"" + staticClass + "\": " +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass);
+    }
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData(el) {
+    var data = '';
+    if (el.staticClass) {
+        data += "staticClass:" + (el.staticClass) + ",";
+    }
+    if (el.classBinding) {
+        data += "class:" + (el.classBinding) + ",";
+    }
+    return data;
+}
 var klass$1 = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData
+    staticKeys: ['staticClass'],
+    transformNode: transformNode,
+    genData: genData,
 };
 
-/*  */
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      var res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          "style=\"" + staticStyle + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
+/* @flow */
+function transformNode$1(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            var res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn("style=\"" + staticStyle + "\": " +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
     }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
 }
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:(" + (el.styleBinding) + "),";
-  }
-  return data
+function genData$1(el) {
+    var data = '';
+    if (el.staticStyle) {
+        data += "staticStyle:" + (el.staticStyle) + ",";
+    }
+    if (el.styleBinding) {
+        data += "style:(" + (el.styleBinding) + "),";
+    }
+    return data;
 }
-
 var style$1 = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
-};
-
-/*  */
-
-var decoder;
-
-var he = {
-  decode: function decode (html) {
-    decoder = decoder || document.createElement('div');
-    decoder.innerHTML = html;
-    return decoder.textContent
-  }
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode$1,
+    genData: genData$1,
 };
 
-/*  */
+/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+(function(root) {
+
+	// Detect free variables `exports`.
+	var freeExports = typeof exports == 'object' && exports;
+
+	// Detect free variable `module`.
+	var freeModule = typeof module == 'object' && module &&
+		module.exports == freeExports && module;
+
+	// Detect free variable `global`, from Node.js or Browserified code,
+	// and use it as `root`.
+	var freeGlobal = typeof global == 'object' && global;
+	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+		root = freeGlobal;
+	}
+
+	/*--------------------------------------------------------------------------*/
+
+	// All astral symbols.
+	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+	// All ASCII symbols (not just printable ASCII) except those listed in the
+	// first column of the overrides table.
+	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+	var regexAsciiWhitelist = /[\x01-\x7F]/g;
+	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+	// code points listed in the first column of the overrides table on
+	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+	var regexEscape = /["&'<>`]/g;
+	var escapeMap = {
+		'"': '&quot;',
+		'&': '&amp;',
+		'\'': '&#x27;',
+		'<': '&lt;',
+		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+		// following is not strictly necessary unless it’s part of a tag or an
+		// unquoted attribute value. We’re only escaping it to support those
+		// situations, and for XML support.
+		'>': '&gt;',
+		// In Internet Explorer ≤ 8, the backtick character can be used
+		// to break out of (un)quoted attribute values or HTML comments.
+		// See http://html5sec.org/#102, http://html5sec.org/#108, and
+		// http://html5sec.org/#133.
+		'`': '&#x60;'
+	};
+
+	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+	/*--------------------------------------------------------------------------*/
+
+	var stringFromCharCode = String.fromCharCode;
+
+	var object = {};
+	var hasOwnProperty = object.hasOwnProperty;
+	var has = function(object, propertyName) {
+		return hasOwnProperty.call(object, propertyName);
+	};
+
+	var contains = function(array, value) {
+		var index = -1;
+		var length = array.length;
+		while (++index < length) {
+			if (array[index] == value) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+	var merge = function(options, defaults) {
+		if (!options) {
+			return defaults;
+		}
+		var result = {};
+		var key;
+		for (key in defaults) {
+			// A `hasOwnProperty` check is not needed here, since only recognized
+			// option names are used anyway. Any others are ignored.
+			result[key] = has(options, key) ? options[key] : defaults[key];
+		}
+		return result;
+	};
+
+	// Modified version of `ucs2encode`; see https://mths.be/punycode.
+	var codePointToSymbol = function(codePoint, strict) {
+		var output = '';
+		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+			// See issue #4:
+			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+			// REPLACEMENT CHARACTER.”
+			if (strict) {
+				parseError('character reference outside the permissible Unicode range');
+			}
+			return '\uFFFD';
+		}
+		if (has(decodeMapNumeric, codePoint)) {
+			if (strict) {
+				parseError('disallowed character reference');
+			}
+			return decodeMapNumeric[codePoint];
+		}
+		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+			parseError('disallowed character reference');
+		}
+		if (codePoint > 0xFFFF) {
+			codePoint -= 0x10000;
+			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+			codePoint = 0xDC00 | codePoint & 0x3FF;
+		}
+		output += stringFromCharCode(codePoint);
+		return output;
+	};
+
+	var hexEscape = function(codePoint) {
+		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+	};
+
+	var decEscape = function(codePoint) {
+		return '&#' + codePoint + ';';
+	};
+
+	var parseError = function(message) {
+		throw Error('Parse error: ' + message);
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var encode = function(string, options) {
+		options = merge(options, encode.options);
+		var strict = options.strict;
+		if (strict && regexInvalidRawCodePoint.test(string)) {
+			parseError('forbidden code point');
+		}
+		var encodeEverything = options.encodeEverything;
+		var useNamedReferences = options.useNamedReferences;
+		var allowUnsafeSymbols = options.allowUnsafeSymbols;
+		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+		var escapeBmpSymbol = function(symbol) {
+			return escapeCodePoint(symbol.charCodeAt(0));
+		};
+
+		if (encodeEverything) {
+			// Encode ASCII symbols.
+			string = string.replace(regexAsciiWhitelist, function(symbol) {
+				// Use named references if requested & possible.
+				if (useNamedReferences && has(encodeMap, symbol)) {
+					return '&' + encodeMap[symbol] + ';';
+				}
+				return escapeBmpSymbol(symbol);
+			});
+			// Shorten a few escapes that represent two symbols, of which at least one
+			// is within the ASCII range.
+			if (useNamedReferences) {
+				string = string
+					.replace(/&gt;\u20D2/g, '&nvgt;')
+					.replace(/&lt;\u20D2/g, '&nvlt;')
+					.replace(/&#x66;&#x6A;/g, '&fjlig;');
+			}
+			// Encode non-ASCII symbols.
+			if (useNamedReferences) {
+				// Encode non-ASCII symbols that can be replaced with a named reference.
+				string = string.replace(regexEncodeNonAscii, function(string) {
+					// Note: there is no need to check `has(encodeMap, string)` here.
+					return '&' + encodeMap[string] + ';';
+				});
+			}
+			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+		} else if (useNamedReferences) {
+			// Apply named character references.
+			// Encode `<>"'&` using named character references.
+			if (!allowUnsafeSymbols) {
+				string = string.replace(regexEscape, function(string) {
+					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+				});
+			}
+			// Shorten escapes that represent two symbols, of which at least one is
+			// `<>"'&`.
+			string = string
+				.replace(/&gt;\u20D2/g, '&nvgt;')
+				.replace(/&lt;\u20D2/g, '&nvlt;');
+			// Encode non-ASCII symbols that can be replaced with a named reference.
+			string = string.replace(regexEncodeNonAscii, function(string) {
+				// Note: there is no need to check `has(encodeMap, string)` here.
+				return '&' + encodeMap[string] + ';';
+			});
+		} else if (!allowUnsafeSymbols) {
+			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+			// using named character references.
+			string = string.replace(regexEscape, escapeBmpSymbol);
+		}
+		return string
+			// Encode astral symbols.
+			.replace(regexAstralSymbols, function($0) {
+				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+				var high = $0.charCodeAt(0);
+				var low = $0.charCodeAt(1);
+				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+				return escapeCodePoint(codePoint);
+			})
+			// Encode any remaining BMP symbols that are not printable ASCII symbols
+			// using a hexadecimal escape.
+			.replace(regexBmpWhitelist, escapeBmpSymbol);
+	};
+	// Expose default options (so they can be overridden globally).
+	encode.options = {
+		'allowUnsafeSymbols': false,
+		'encodeEverything': false,
+		'strict': false,
+		'useNamedReferences': false,
+		'decimal' : false
+	};
+
+	var decode = function(html, options) {
+		options = merge(options, decode.options);
+		var strict = options.strict;
+		if (strict && regexInvalidEntity.test(html)) {
+			parseError('malformed character reference');
+		}
+		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+			var codePoint;
+			var semicolon;
+			var decDigits;
+			var hexDigits;
+			var reference;
+			var next;
+
+			if ($1) {
+				reference = $1;
+				// Note: there is no need to check `has(decodeMap, reference)`.
+				return decodeMap[reference];
+			}
+
+			if ($2) {
+				// Decode named character references without trailing `;`, e.g. `&amp`.
+				// This is only a parse error if it gets converted to `&`, or if it is
+				// followed by `=` in an attribute context.
+				reference = $2;
+				next = $3;
+				if (next && options.isAttributeValue) {
+					if (strict && next == '=') {
+						parseError('`&` did not start a character reference');
+					}
+					return $0;
+				} else {
+					if (strict) {
+						parseError(
+							'named character reference was not terminated by a semicolon'
+						);
+					}
+					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+					return decodeMapLegacy[reference] + (next || '');
+				}
+			}
+
+			if ($4) {
+				// Decode decimal escapes, e.g. `&#119558;`.
+				decDigits = $4;
+				semicolon = $5;
+				if (strict && !semicolon) {
+					parseError('character reference was not terminated by a semicolon');
+				}
+				codePoint = parseInt(decDigits, 10);
+				return codePointToSymbol(codePoint, strict);
+			}
+
+			if ($6) {
+				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+				hexDigits = $6;
+				semicolon = $7;
+				if (strict && !semicolon) {
+					parseError('character reference was not terminated by a semicolon');
+				}
+				codePoint = parseInt(hexDigits, 16);
+				return codePointToSymbol(codePoint, strict);
+			}
+
+			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+			if (strict) {
+				parseError(
+					'named character reference was not terminated by a semicolon'
+				);
+			}
+			return $0;
+		});
+	};
+	// Expose default options (so they can be overridden globally).
+	decode.options = {
+		'isAttributeValue': false,
+		'strict': false
+	};
+
+	var escape = function(string) {
+		return string.replace(regexEscape, function($0) {
+			// Note: there is no need to check `has(escapeMap, $0)` here.
+			return escapeMap[$0];
+		});
+	};
+
+	/*--------------------------------------------------------------------------*/
+
+	var he = {
+		'version': '1.2.0',
+		'encode': encode,
+		'decode': decode,
+		'escape': escape,
+		'unescape': decode
+	};
+
+	// Some AMD build optimizers, like r.js, check for specific condition patterns
+	// like the following:
+	if (
+		typeof define == 'function' &&
+		typeof define.amd == 'object' &&
+		define.amd
+	) {
+		define(function() {
+			return he;
+		});
+	}	else if (freeExports && !freeExports.nodeType) {
+		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+			freeModule.exports = he;
+		} else { // in Narwhal or RingoJS v0.7.0-
+			for (var key in he) {
+				has(he, key) && (freeExports[key] = he[key]);
+			}
+		}
+	} else { // in Rhino or a web browser
+		root.he = he;
+	}
+
+}(undefined));
+
+var he = /*#__PURE__*/Object.freeze({
 
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
+});
 
+/* @flow */
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
 var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -9281,310 +8572,289 @@ var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
 var conditionalComment = /^<!\[/;
-
 // Special Elements (can contain anything)
 var isPlainTextElement = makeMap('script,style,textarea', true);
 var reCache = {};
-
 var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
 var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
 var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+function decodeAttr(value, shouldDecodeNewlines) {
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, function (match) { return decodingMap[match]; });
+}
+function parseHTML(html, options) {
+    var stack = [];
+    var expectHTML = options.expectHTML;
+    var isUnaryTag$$1 = options.isUnaryTag || no;
+    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var index = 0;
+    var last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            var textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    var commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    var conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                var doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                var endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    var curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                var startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            var text = (void 0), rest = (void 0), next = (void 0);
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        { break; }
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        var start = html.match(startTagOpen);
+        if (start) {
+            var match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            var end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        var tagName = match.tagName;
+        var unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var l = match.attrs.length;
+        var attrs = new Array(l);
+        for (var i = 0; i < l; i++) {
+            var args = match.attrs[i];
+            var value = args[3] || args[4] || args[5] || '';
+            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        var pos, lowerCasedTagName;
+        if (start == null)
+            { start = index; }
+        if (end == null)
+            { end = index; }
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (var i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
+}
 
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-            }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
-        }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
-        }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
-        }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
-    }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
-    }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
-    }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
-}
-
-/*  */
-
+/* @flow */
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
 var stripParensRE = /^\(|\)$/g;
 var dynamicArgRE = /^\[.*\]$/;
-
 var argRE = /:(.*)$/;
 var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
 var slotRE = /^v-slot(:|$)|^#/;
-
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE$1 = /\s+/g;
-
+var whitespaceRE$1 = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-
-var decodeHTMLCached = cached(he.decode);
-
+var decodeHTMLCached = cached(undefined);
 var emptySlotScopeToken = "_empty_";
-
 // configurable state
 var warn$2;
 var delimiters;
@@ -9595,1042 +8865,894 @@ var platformIsPreTag;
 var platformMustUseProp;
 var platformGetTagNamespace;
 var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag: tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent: parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$2 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$2(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$2 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    var isReservedTag = options.isReservedTag || no;
+    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    var stack = [];
+    var preserveWhitespace = options.preserveWhitespace !== false;
+    var whitespaceOption = options.whitespace;
+    var root;
+    var currentParent;
+    var inVPre = false;
+    var inPre = false;
+    var warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$2(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
-    }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
-    }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
-    }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$2,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$2(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        process.env.NODE_ENV !== 'production' && warn$2(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce("Component template should contain exactly one root element. " +
+                    "If you are using v-if on multiple elements, " +
+                    "use v-else-if to chain them instead.", { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
         if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root);
+            inVPre = false;
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE$1, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
-        }
-        currentParent.children.push(child);
-      }
-    }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn$2(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$2(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
-}
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
-}
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$2(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-}
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
-}
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (var i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            var lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$2,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start: function start(tag, attrs, unary, start$1, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            var element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start$1;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach(function (attr) {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$2("Invalid dynamic argument expression: attribute names cannot contain " +
+                            "spaces, quotes, <, >, / or =.", {
+                            start: attr.start + attr.name.indexOf("["),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$2('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        "<" + tag + ">" +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (var i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end: function end(tag, start, end$1) {
+            var element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end$1;
+            }
+            closeElement(element);
+        },
+        chars: function chars(text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                            start: start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            var children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE$1, ' ');
+                }
+                var res;
+                var child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text: text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text: text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment: function comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                var child = {
+                    type: 3,
+                    text: text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
     });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    var list = el.attrsList;
+    var len = list.length;
+    if (len) {
+        var attrs = (el.attrs = new Array(len));
+        for (var i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
     }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (var i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    var exp = getBindingAttr(el, 'key');
+    if (exp) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (el.tag === 'template') {
+                warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                var iterator = el.iterator2 || el.iterator1;
+                var parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$2("Do not use v-for index as key on <transition-group> children, " +
+                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$2(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
-}
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn$2(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
+function processRef(el) {
+    var ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
     }
-  }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function processFor(el) {
+    var exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        var res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$2(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+        }
+    }
 }
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function parseFor(exp) {
+    var inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        { return; }
+    var res = {};
+    res.for = inMatch[2].trim();
+    var alias = inMatch[1].trim().replace(stripParensRE, '');
+    var iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    var exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    var prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    var i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn$2("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                    "will be ignored.", children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    var once$$1 = getAndRemoveAttr(el, 'v-once');
+    if (once$$1 != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn$2(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn$2(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    var slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn$2(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$2(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
-        }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn$2(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$2(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$2(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
-    }
-  }
-}
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$2(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn$2("the \"scope\" attribute for scoped slots have been deprecated and " +
+                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                "can also be used on plain elements in addition to <template> to " +
+                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn$2("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                "(v-for takes higher priority). Use a wrapper <template> for the " +
+                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    var slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$2("<template v-slot> can only appear at the root level inside " +
+                            "the receiving component", el);
+                    }
+                }
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn$2("v-slot can only be used on components or <template>.", slotBinding$1);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$2("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding$1);
+                    }
+                }
+                // add the component's children to its default slot
+                var slots = el.scopedSlots || (el.scopedSlots = {});
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    var name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$2("v-slot shorthand syntax requires a slot name.", binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: ("\"" + name + "\""), dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn$2(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
-}
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
-}
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn$2(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn$2,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$2,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn$2,
-                list[i],
-                true // dynamic
-              );
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn$2(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
-}
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent;
-  }
-  return false
-}
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn$2("`key` does not work on <slot> because slots are abstract outlets " +
+                "and can possibly expand into multiple elements. " +
+                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+function processComponent(el) {
+    var binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
     }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
 }
-
+function processAttrs(el) {
+    var list = el.attrsList;
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn$2(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            { name = 'innerHTML'; }
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, "$event");
+                        if (!isDynamic) {
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$2, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$2, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$2, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                var argMatch = name.match(argRE);
+                var arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                var res = parseText(value, delimiters);
+                if (res) {
+                    warn$2(name + "=\"" + value + "\": " +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    var parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    var match = name.match(modifierRE);
+    if (match) {
+        var ret = {};
+        match.forEach(function (m) {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    var map = {};
+    for (var i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
 var ieNSBug = /^xmlns:NS\d+/;
 var ieNSPrefix = /^NS\d+:/;
-
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$2(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap;
-    if (!map['v-model']) {
-      return
-    }
-
-    var typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
-    }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = "(" + (map['v-bind']) + ").type";
-    }
-
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      var branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      var branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
-    }
-  }
-}
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function guardIESVGBug(attrs) {
+    var res = [];
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    var _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                "You are binding v-model directly to a v-for iteration alias. " +
+                "This will not be able to modify the v-for source array because " +
+                "writing to the alias is like modifying a function local variable. " +
+                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
+/* @flow */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        var map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        var typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = "(" + (map['v-bind']) + ").type";
+        }
+        if (typeBinding) {
+            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            var branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            var branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            var branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
 var model$1 = {
-  preTransformNode: preTransformNode
+    preTransformNode: preTransformNode,
 };
 
-var modules$1 = [
-  klass$1,
-  style$1,
-  model$1
-];
+var modules$1 = [klass$1, style$1, model$1];
 
-/*  */
-
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-  }
+/* @flow */
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-  }
+/* @flow */
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
 var directives$1 = {
-  model: model,
-  text: text,
-  html: html
+    model: model,
+    text: text,
+    html: html,
 };
 
-/*  */
-
+/* @flow */
 var baseOptions = {
-  expectHTML: true,
-  modules: modules$1,
-  directives: directives$1,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys(modules$1)
+    expectHTML: true,
+    modules: modules$1,
+    directives: directives$1,
+    isPreTag: isPreTag,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
+    // @ts-ignore
+    staticKeys: genStaticKeys(modules$1),
 };
 
-/*  */
-
+/* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
-
 var genStaticKeysCached = cached(genStaticKeys$1);
-
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -10642,1352 +9764,1188 @@ var genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize (root, options) {
-  if (!root) { return }
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic$1(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic$1 (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      markStatic$1(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        markStatic$1(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        markStaticRoots(node.ifConditions[i$1].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
-}
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
-    }
-    if (node.for) {
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+function optimize(root, options) {
+    if (!root)
+        { return; }
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic$1(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys$1(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic$1(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            markStatic$1(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
+                markStatic$1(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (var i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
+}
 
+/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
 // KeyboardEvent.keyCode aliases
 var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
 var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
 var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
 var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard("$event.target !== $event.currentTarget"),
+    ctrl: genGuard("!$event.ctrlKey"),
+    shift: genGuard("!$event.shiftKey"),
+    alt: genGuard("!$event.altKey"),
+    meta: genGuard("!$event.metaKey"),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2"),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
-}
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
+function genHandlers(events, isNative) {
+    var prefix = isNative ? 'nativeOn:' : 'on:';
+    var staticHandlers = "";
+    var dynamicHandlers = "";
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
+        }
+        else {
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+        }
     }
-    if (keys.length) {
-      code += genKeyFilter(keys);
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    if (dynamicHandlers) {
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
     }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
+    else {
+        return prefix + staticHandlers;
     }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + "($event)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ")($event)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    return ("function($event){" + code + handlerCode + "}")
-  }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+    }
+    var isMethodPath = simplePathRE.test(handler.value);
+    var isFunctionExpression = fnExpRE.test(handler.value);
+    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+    }
+    else {
+        var code = '';
+        var genModifierCode = '';
+        var keys = [];
+        for (var key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                var modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        var handlerCode = isMethodPath
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            : isFunctionExpression
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                : isFunctionInvocation
+                    ? ("return " + (handler.value))
+                    : handler.value;
+        return ("function($event){" + code + handlerCode + "}");
+    }
+}
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    var keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return ("$event.keyCode!==" + keyVal);
+    }
+    var keyCode = keyCodes[key];
+    var keyName = keyNames[key];
+    return ("_k($event.keyCode," +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
+        "$event.key," +
+        "" + (JSON.stringify(keyName)) +
+        ")");
 }
 
-/*  */
-
-function on (el, dir) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+/* @flow */
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn("v-on without argument does not support modifiers.");
+    }
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+/* @flow */
+function bind$1(el, dir) {
+    el.wrapData = function (code) {
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+    };
 }
 
-/*  */
-
+/* @flow */
 var baseDirectives = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
+    on: on,
+    bind: bind$1,
+    cloak: noop,
 };
 
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
+/* @flow */
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
 };
-
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function generate(ast, options) {
+    var state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    var code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: ("with(this){return " + code + "}"),
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        var code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            var data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData$2(el, state);
+            }
+            var children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+        }
+        // module transforms
+        for (var i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    var originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.pre = originalPreState;
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData$2 (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        var key = '';
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+    }
+    else {
+        return genStatic(el, state);
     }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
 }
-
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    var condition = conditions.shift();
+    if (condition.exp) {
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+    }
+    else {
+        return ("" + (genTernaryExp(condition.block)));
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    var exp = el.for;
+    var alias = el.alias;
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+            "v-for should have explicit keys. " +
+            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return ((altHelper || '_l') + "((" + exp + ")," +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
+        '})');
+}
+function genData$2(el, state) {
+    var data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    var dirs = genDirectives(el, state);
+    if (dirs)
+        { data += dirs + ','; }
+    // key
+    if (el.key) {
+        data += "key:" + (el.key) + ",";
+    }
+    // ref
+    if (el.ref) {
+        data += "ref:" + (el.ref) + ",";
+    }
+    if (el.refInFor) {
+        data += "refInFor:true,";
+    }
+    // pre
+    if (el.pre) {
+        data += "pre:true,";
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += "tag:\"" + (el.tag) + "\",";
+    }
+    // module data generation functions
+    for (var i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += "attrs:" + (genProps(el.attrs)) + ",";
+    }
+    // DOM props
+    if (el.props) {
+        data += "domProps:" + (genProps(el.props)) + ",";
+    }
+    // event handlers
+    if (el.events) {
+        data += (genHandlers(el.events, false)) + ",";
+    }
+    if (el.nativeEvents) {
+        data += (genHandlers(el.nativeEvents, true)) + ",";
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += "slot:" + (el.slotTarget) + ",";
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+    }
+    // component v-model
+    if (el.model) {
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        var inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += inlineTemplate + ",";
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    var dirs = el.directives;
+    if (!dirs)
+        { return; }
+    var res = 'directives:[';
+    var hasRuntime = false;
+    var i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        var gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    var ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        var inlineRenderFns = generate(ast, state.options);
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    var needsForceUpdate = el.for ||
+        Object.keys(slots).some(function (key) {
+            var slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    var needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    var generatedSlots = Object.keys(slots)
+        .map(function (key) { return genScopedSlot(slots[key], state); })
+        .join(',');
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+}
 function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
+    var hash = 5381;
+    var i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
 }
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-}
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    var isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, "null");
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+    var fn = "function(" + slotScope + "){" +
+        "return " + (el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)) + "}";
+    // reverse proxy v-slot without scope on this.$slots
+    var reverseProxy = slotScope ? "" : ",proxy:true";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    var children = el.children;
+    if (children.length) {
+        var el$1 = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
+                    ? ",1"
+                    : ",0"
+                : "";
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+        }
+        var normalizationType$1 = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
-}
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-}
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
-}
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? ("," + children) : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function getNormalizationType(children, maybeComponent) {
+    var res = 0;
+    for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return ("_v(" + (text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+}
+function genComment(comment) {
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+}
+function genSlot(el, state) {
+    var slotName = el.slotName || '"default"';
+    var children = genChildren(el, state);
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+        }); }))
+        : null;
+    var bind$$1 = el.attrsMap['v-bind'];
+    if ((attrs || bind$$1) && !children) {
+        res += ",null";
+    }
+    if (attrs) {
+        res += "," + attrs;
+    }
+    if (bind$$1) {
+        res += (attrs ? '' : ',null') + "," + bind$$1;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    var children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+}
+function genProps(props) {
+    var staticProps = "";
+    var dynamicProps = "";
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        var value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += (prop.name) + "," + value + ",";
+        }
+        else {
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+        }
+    }
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    if (dynamicProps) {
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
+/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+var prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+var unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
 var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
-}
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
-}
-
-function checkEvent (exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
+                if (value) {
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else {
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (var i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkEvent(exp, text, warn, range) {
+    var stripped = exp.replace(stripStringRE, '');
+    var keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn("avoid using JavaScript unary operator as property name: " +
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(("var " + ident + "=_"));
+        }
+        catch (e) {
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-    }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
+        new Function(("return " + exp));
+    }
+    catch (e) {
+        var keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn("avoid using JavaScript keyword as property name: " +
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+        }
+        else {
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
+    }
 }
 
-/*  */
-
+/* @flow */
 var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
-    }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
+function generateCodeFrame(source, start, end) {
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
+    var lines = source.split(/\r?\n/);
+    var count = 0;
+    var res = [];
+    for (var i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (var j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    { continue; }
+                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                var lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    var pad = start - (count - lineLength) + 1;
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat$1("^", length$1));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
         }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+    }
+    return res.join('\n');
+}
+function repeat$1(str, n) {
+    var result = '';
+    if (n > 0) {
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                { result += str; }
+            n >>>= 1;
+            if (n <= 0)
+                { break; }
+            str += str;
         }
-      }
     }
+    return result;
+}
 
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
-            }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
+/* @flow */
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
+    catch (err) {
+        errors.push({ err: err, code: code });
+        return noop;
     }
-  }
+}
+function createCompileToFunctionFn(compile) {
+    var cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        var warn$$1 = options.warn || warn;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        var key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        var compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach(function (e) {
+                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                }
+                else {
+                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                }
+            }
+        }
+        // turn code into functions
+        var res = {};
+        var fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn$$1("Failed to generate render function:\n\n" +
+                    fnGenErrors
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+/* @flow */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            var finalOptions = Object.create(baseOptions);
+            var errors = [];
+            var tips = [];
+            var warn = function (msg, range, tip) {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = function (msg, range, tip) {
+                        var data = { msg: msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (var key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            var compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile: compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
+/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  var code = generate(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    var code = generate(ast, options);
+    return {
+        ast: ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
+/* @flow */
 var ref$1 = createCompiler(baseOptions);
 var compile = ref$1.compile;
 var compileToFunctions = ref$1.compileToFunctions;
 
-/*  */
-
+/* @flow */
 // check whether current browser encodes a char inside attribute values
 var div;
-function getShouldDecode (href) {
-  div = div || document.createElement('div');
-  div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
-  return div.innerHTML.indexOf('&#10;') > 0
+function getShouldDecode(href) {
+    div = div || document.createElement('div');
+    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+    return div.innerHTML.indexOf('&#10;') > 0;
 }
-
 // #3663: IE encodes newlines inside attribute values while other browsers don't
 var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
-
-/*  */
+var shouldDecodeNewlinesForHref = inBrowser
+    ? getShouldDecode(true)
+    : false;
 
+/* @flow */
 var idToTemplate = cached(function (id) {
-  var el = query(id);
-  return el && el.innerHTML
+    var el = query(id);
+    return el && el.innerHTML;
 });
-
 var mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && query(el);
-
-  /* istanbul ignore if */
-  if (el === document.body || el === document.documentElement) {
-    process.env.NODE_ENV !== 'production' && warn(
-      "Do not mount Vue to <html> or <body> - mount to normal elements instead."
-    );
-    return this
-  }
-
-  var options = this.$options;
-  // resolve template/el and convert to render function
-  if (!options.render) {
-    var template = options.template;
-    if (template) {
-      if (typeof template === 'string') {
-        if (template.charAt(0) === '#') {
-          template = idToTemplate(template);
-          /* istanbul ignore if */
-          if (process.env.NODE_ENV !== 'production' && !template) {
-            warn(
-              ("Template element not found or is empty: " + (options.template)),
-              this
-            );
-          }
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && query(el);
+    /* istanbul ignore if */
+    if (el === document.body || el === document.documentElement) {
+        process.env.NODE_ENV !== 'production' &&
+            warn("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+        return this;
+    }
+    var options = this.$options;
+    // resolve template/el and convert to render function
+    if (!options.render) {
+        var template = options.template;
+        if (template) {
+            if (typeof template === 'string') {
+                if (template.charAt(0) === '#') {
+                    template = idToTemplate(template);
+                    /* istanbul ignore if */
+                    if (process.env.NODE_ENV !== 'production' && !template) {
+                        warn(("Template element not found or is empty: " + (options.template)), this);
+                    }
+                }
+            }
+            else if (template.nodeType) {
+                template = template.innerHTML;
+            }
+            else {
+                if (process.env.NODE_ENV !== 'production') {
+                    warn('invalid template option:' + template, this);
+                }
+                return this;
+            }
         }
-      } else if (template.nodeType) {
-        template = template.innerHTML;
-      } else {
-        if (process.env.NODE_ENV !== 'production') {
-          warn('invalid template option:' + template, this);
-        }
-        return this
-      }
-    } else if (el) {
-      template = getOuterHTML(el);
-    }
-    if (template) {
-      /* istanbul ignore if */
-      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        mark('compile');
-      }
-
-      var ref = compileToFunctions(template, {
-        outputSourceRange: process.env.NODE_ENV !== 'production',
-        shouldDecodeNewlines: shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
-        delimiters: options.delimiters,
-        comments: options.comments
-      }, this);
-      var render = ref.render;
-      var staticRenderFns = ref.staticRenderFns;
-      options.render = render;
-      options.staticRenderFns = staticRenderFns;
-
-      /* istanbul ignore if */
-      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        mark('compile end');
-        measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
-      }
-    }
-  }
-  return mount.call(this, el, hydrating)
+        else if (el) {
+            // @ts-expect-error
+            template = getOuterHTML(el);
+        }
+        if (template) {
+            /* istanbul ignore if */
+            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+                mark('compile');
+            }
+            var ref = compileToFunctions(template, {
+                outputSourceRange: process.env.NODE_ENV !== 'production',
+                shouldDecodeNewlines: shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                delimiters: options.delimiters,
+                comments: options.comments,
+            }, this);
+            var render = ref.render;
+            var staticRenderFns = ref.staticRenderFns;
+            options.render = render;
+            options.staticRenderFns = staticRenderFns;
+            /* istanbul ignore if */
+            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+                mark('compile end');
+                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+            }
+        }
+    }
+    return mount.call(this, el, hydrating);
 };
-
 /**
  * Get outerHTML of elements, taking care
  * of SVG elements in IE as well.
  */
-function getOuterHTML (el) {
-  if (el.outerHTML) {
-    return el.outerHTML
-  } else {
-    var container = document.createElement('div');
-    container.appendChild(el.cloneNode(true));
-    return container.innerHTML
-  }
+function getOuterHTML(el) {
+    if (el.outerHTML) {
+        return el.outerHTML;
+    }
+    else {
+        var container = document.createElement('div');
+        container.appendChild(el.cloneNode(true));
+        return container.innerHTML;
+    }
 }
-
 Vue.compile = compileToFunctions;
 
 export default Vue;
diff --git a/dist/vue.js b/dist/vue.js
index 919aa125129..a5cba7a2552 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
 (function (global, factory) {
@@ -9,189 +9,155 @@
   (global = global || self, global.Vue = factory());
 }(this, function () { 'use strict';
 
-  /*  */
-
+  /* @flow */
   var emptyObject = Object.freeze({});
-
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
-  function isUndef (v) {
-    return v === undefined || v === null
+  function isUndef(v) {
+      return v === undefined || v === null;
   }
-
-  function isDef (v) {
-    return v !== undefined && v !== null
+  function isDef(v) {
+      return v !== undefined && v !== null;
   }
-
-  function isTrue (v) {
-    return v === true
+  function isTrue(v) {
+      return v === true;
   }
-
-  function isFalse (v) {
-    return v === false
+  function isFalse(v) {
+      return v === false;
   }
-
   /**
    * Check if value is primitive.
    */
-  function isPrimitive (value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
   }
-
   /**
    * Quick object check - this is primarily used to tell
    * Objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
-  function isObject (obj) {
-    return obj !== null && typeof obj === 'object'
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
   }
-
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
   var _toString = Object.prototype.toString;
-
-  function toRawType (value) {
-    return _toString.call(value).slice(8, -1)
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
   }
-
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
-  function isPlainObject (obj) {
-    return _toString.call(obj) === '[object Object]'
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
   }
-
-  function isRegExp (v) {
-    return _toString.call(v) === '[object RegExp]'
+  function isRegExp(v) {
+      return _toString.call(v) === '[object RegExp]';
   }
-
   /**
    * Check if val is a valid array index.
    */
-  function isValidArrayIndex (val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
+  function isValidArrayIndex(val) {
+      var n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
-
-  function isPromise (val) {
-    return (
-      isDef(val) &&
-      typeof val.then === 'function' &&
-      typeof val.catch === 'function'
-    )
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
   }
-
   /**
    * Convert a value to a string that is actually rendered.
    */
-  function toString (val) {
-    return val == null
-      ? ''
-      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-        ? JSON.stringify(val, null, 2)
-        : String(val)
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
   }
-
   /**
    * Convert an input value to a number for persistence.
    * If the conversion fails, return original string.
    */
-  function toNumber (val) {
-    var n = parseFloat(val);
-    return isNaN(n) ? val : n
+  function toNumber(val) {
+      var n = parseFloat(val);
+      return isNaN(n) ? val : n;
   }
-
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
-  function makeMap (
-    str,
-    expectsLowerCase
-  ) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) { return map[val.toLowerCase()]; }
-      : function (val) { return map[val]; }
+  function makeMap(str, expectsLowerCase) {
+      var map = Object.create(null);
+      var list = str.split(',');
+      for (var i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
   }
-
   /**
    * Check if a tag is a built-in tag.
    */
   var isBuiltInTag = makeMap('slot,component', true);
-
   /**
    * Check if an attribute is a reserved attribute.
    */
   var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
   /**
    * Remove an item from an array.
    */
-  function remove (arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1)
+  function remove(arr, item) {
+      if (arr.length) {
+          var index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
       }
-    }
   }
-
   /**
    * Check whether an object has the property.
    */
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn (obj, key) {
-    return hasOwnProperty.call(obj, key)
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
   }
-
   /**
    * Create a cached version of a pure function.
    */
-  function cached (fn) {
-    var cache = Object.create(null);
-    return (function cachedFn (str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str))
-    })
+  function cached(fn) {
+      var cache = Object.create(null);
+      return function cachedFn(str) {
+          var hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
   }
-
   /**
    * Camelize a hyphen-delimited string.
    */
   var camelizeRE = /-(\w)/g;
   var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
   });
-
   /**
    * Capitalize a string.
    */
   var capitalize = cached(function (str) {
-    return str.charAt(0).toUpperCase() + str.slice(1)
+      return str.charAt(0).toUpperCase() + str.slice(1);
   });
-
   /**
    * Hyphenate a camelCase string.
    */
   var hyphenateRE = /\B([A-Z])/g;
   var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-
   /**
    * Simple bind polyfill for environments that do not support it,
    * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -199,1113 +165,987 @@
    * But removing it would mean breaking code that was able to run in
    * PhantomJS 1.x, so this must be kept for backward compatibility.
    */
-
   /* istanbul ignore next */
-  function polyfillBind (fn, ctx) {
-    function boundFn (a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx)
-    }
-
-    boundFn._length = fn.length;
-    return boundFn
-  }
-
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
-
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
-
+  function polyfillBind(fn, ctx) {
+      function boundFn(a) {
+          var l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
+  }
+  function nativeBind(fn, ctx) {
+      return fn.bind(ctx);
+  }
+  // @ts-expect-error bind cannot be `undefined`
+  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Convert an Array-like object to a real Array.
    */
-  function toArray (list, start) {
-    start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
-    while (i--) {
-      ret[i] = list[i + start];
-    }
-    return ret
+  function toArray(list, start) {
+      start = start || 0;
+      var i = list.length - start;
+      var ret = new Array(i);
+      while (i--) {
+          ret[i] = list[i + start];
+      }
+      return ret;
   }
-
   /**
    * Mix properties into target object.
    */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to
+  function extend(to, _from) {
+      for (var key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
   }
-
   /**
    * Merge an Array of Objects into a single Object.
    */
-  function toObject (arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-      if (arr[i]) {
-        extend(res, arr[i]);
+  function toObject(arr) {
+      var res = {};
+      for (var i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
       }
-    }
-    return res
+      return res;
   }
-
   /* eslint-disable no-unused-vars */
-
   /**
    * Perform no operation.
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop (a, b, c) {}
-
+  function noop(a, b, c) { }
   /**
    * Always return false.
    */
   var no = function (a, b, c) { return false; };
-
   /* eslint-enable no-unused-vars */
-
   /**
    * Return the same value.
    */
   var identity = function (_) { return _; };
-
   /**
    * Generate a string containing static keys from compiler modules.
    */
-  function genStaticKeys (modules) {
-    return modules.reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, []).join(',')
+  function genStaticKeys(modules) {
+      return modules
+          .reduce(function (keys, m) {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
   }
-
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
-  function looseEqual (a, b) {
-    if (a === b) { return true }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-      try {
-        var isArrayA = Array.isArray(a);
-        var isArrayB = Array.isArray(b);
-        if (isArrayA && isArrayB) {
-          return a.length === b.length && a.every(function (e, i) {
-            return looseEqual(e, b[i])
-          })
-        } else if (a instanceof Date && b instanceof Date) {
-          return a.getTime() === b.getTime()
-        } else if (!isArrayA && !isArrayB) {
-          var keysA = Object.keys(a);
-          var keysB = Object.keys(b);
-          return keysA.length === keysB.length && keysA.every(function (key) {
-            return looseEqual(a[key], b[key])
-          })
-        } else {
-          /* istanbul ignore next */
-          return false
-        }
-      } catch (e) {
-        /* istanbul ignore next */
-        return false
+  function looseEqual(a, b) {
+      if (a === b)
+          { return true; }
+      var isObjectA = isObject(a);
+      var isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              var isArrayA = Array.isArray(a);
+              var isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every(function (e, i) {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  var keysA = Object.keys(a);
+                  var keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every(function (key) {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
       }
-    } else if (!isObjectA && !isObjectB) {
-      return String(a) === String(b)
-    } else {
-      return false
-    }
   }
-
   /**
    * Return the first index at which a loosely equal value can be
    * found in the array (if value is a plain object, the array must
    * contain an object of the same shape), or -1 if it is not present.
    */
-  function looseIndexOf (arr, val) {
-    for (var i = 0; i < arr.length; i++) {
-      if (looseEqual(arr[i], val)) { return i }
-    }
-    return -1
+  function looseIndexOf(arr, val) {
+      for (var i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              { return i; }
+      }
+      return -1;
   }
-
   /**
    * Ensure a function is called only once.
    */
-  function once (fn) {
-    var called = false;
-    return function () {
-      if (!called) {
-        called = true;
-        fn.apply(this, arguments);
-      }
-    }
+  function once(fn) {
+      var called = false;
+      return function () {
+          if (!called) {
+              called = true;
+              fn.apply(this, arguments);
+          }
+      };
   }
 
   var SSR_ATTR = 'data-server-rendered';
-
-  var ASSET_TYPES = [
-    'component',
-    'directive',
-    'filter'
-  ];
-
+  var ASSET_TYPES = ['component', 'directive', 'filter'];
   var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
-  ];
-
-  /*  */
-
-
-
-  var config = ({
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  });
-
-  /*  */
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch' ];
+
+  /* @flow */
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
+  };
 
+  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
   var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
   /**
    * Check if a string starts with $ or _
    */
-  function isReserved (str) {
-    var c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5F
+  function isReserved(str) {
+      var c = (str + '').charCodeAt(0);
+      return c === 0x24 || c === 0x5f;
   }
-
   /**
    * Define a property.
    */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
   }
-
   /**
    * Parse simple path.
    */
   var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-  function parsePath (path) {
-    if (bailRE.test(path)) {
-      return
-    }
-    var segments = path.split('.');
-    return function (obj) {
-      for (var i = 0; i < segments.length; i++) {
-        if (!obj) { return }
-        obj = obj[segments[i]];
-      }
-      return obj
-    }
+  function parsePath(path) {
+      if (bailRE.test(path)) {
+          return;
+      }
+      var segments = path.split('.');
+      return function (obj) {
+          for (var i = 0; i < segments.length; i++) {
+              if (!obj)
+                  { return; }
+              obj = obj[segments[i]];
+          }
+          return obj;
+      };
   }
 
-  /*  */
-
+  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
-
   // Browser environment sniffing
   var inBrowser = typeof window !== 'undefined';
-  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
+  var inWeex = 
+  // @ts-ignore
+  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
   var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
   var isPhantomJS = UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
-
   // Firefox has a "watch" function on Object.prototype...
-  var nativeWatch = ({}).watch;
-
+  // @ts-ignore
+  var nativeWatch = {}.watch;
   var supportsPassive = false;
   if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, 'passive', ({
-        get: function get () {
-          /* istanbul ignore next */
-          supportsPassive = true;
-        }
-      })); // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts);
-    } catch (e) {}
+      try {
+          var opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get: function get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          // @ts-ignore
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
   }
-
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
   var _isServer;
   var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-      } else {
-        _isServer = false;
-      }
-    }
-    return _isServer
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
   };
-
   // detect devtools
+  // @ts-ignore TODO decalre this types
   var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
   /* istanbul ignore next */
-  function isNative (Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-
-  var hasSymbol =
-    typeof Symbol !== 'undefined' && isNative(Symbol) &&
-    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-  var _Set;
-  /* istanbul ignore if */ // $flow-disable-line
-  if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-      function Set () {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has (key) {
-        return this.set[key] === true
-      };
-      Set.prototype.add = function add (key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear () {
-        this.set = Object.create(null);
-      };
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  var hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  var _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = /*@__PURE__*/(function () {
+          function Set() {
+              this.set = Object.create(null);
+          }
+          Set.prototype.has = function has (key) {
+              return this.set[key] === true;
+          };
+          Set.prototype.add = function add (key) {
+              this.set[key] = true;
+          };
+          Set.prototype.clear = function clear () {
+              this.set = Object.create(null);
+          };
 
-      return Set;
-    }());
+          return Set;
+      }());
   }
 
-  /*  */
-
+  /* @flow */
   var warn = noop;
   var tip = noop;
-  var generateComponentTrace = (noop); // work around flow check
-  var formatComponentName = (noop);
-
+  var generateComponentTrace; // work around flow check
+  var formatComponentName;
   {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str
-      .replace(classifyRE, function (c) { return c.toUpperCase(); })
-      .replace(/[-_]/g, ''); };
-
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : '';
-
-      if (config.warnHandler) {
-        config.warnHandler.call(null, msg, vm, trace);
-      } else if (hasConsole && (!config.silent)) {
-        console.error(("[Vue warn]: " + msg + trace));
-      }
-    };
-
-    tip = function (msg, vm) {
-      if (hasConsole && (!config.silent)) {
-        console.warn("[Vue tip]: " + msg + (
-          vm ? generateComponentTrace(vm) : ''
-        ));
-      }
-    };
-
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options = typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-
-      return (
-        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-        (file && includeFile !== false ? (" at " + file) : '')
-      )
-    };
-
-    var repeat = function (str, n) {
-      var res = '';
-      while (n) {
-        if (n % 2 === 1) { res += str; }
-        if (n > 1) { str += str; }
-        n >>= 1;
-      }
-      return res
-    };
-
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
-          }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return '\n\nfound in\n\n' + tree
-          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-              : formatComponentName(vm))); })
-          .join('\n')
-      } else {
-        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-      }
-    };
-  }
-
-  /*  */
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+      warn = function (msg, vm) {
+          var trace = vm ? generateComponentTrace(vm) : '';
+          if (config.warnHandler) {
+              config.warnHandler.call(null, msg, vm, trace);
+          }
+          else if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
+          }
+      };
+      tip = function (msg, vm) {
+          if (hasConsole && !config.silent) {
+              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = function (vm, includeFile) {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          var options = 
+          // @ts-ignore
+          typeof vm === 'function' && vm.cid != null
+              ? // @ts-ignore
+                  vm.options
+              : vm._isVue
+                  ? // @ts-ignore
+                      vm.$options || vm.constructor.options
+                  : vm;
+          var name = options.name || options._componentTag;
+          var file = options.__file;
+          if (!name && file) {
+              var match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
+      };
+      var repeat = function (str, n) {
+          var res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  { res += str; }
+              if (n > 1)
+                  { str += str; }
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = function (vm) {
+          // @ts-ignore
+          if (vm._isVue && vm.$parent) {
+              var tree = [];
+              var currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      var last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
+                      .join('\n'));
+          }
+          else {
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+          }
+      };
+  }
 
   var uid = 0;
-
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep () {
-    this.id = uid++;
-    this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid++;
+      this.subs = [];
   };
-
   Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
+      this.subs.push(sub);
   };
-
   Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
+      remove(this.subs, sub);
   };
-
   Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
+      if (Dep.target) {
+          Dep.target.addDep(this);
+      }
   };
-
   Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-      // subs aren't sorted in scheduler if not running async
-      // we need to sort them now to make sure they fire in correct
-      // order
-      subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      if (!config.async) {
+          // subs aren't sorted in scheduler if not running async
+          // we need to sort them now to make sure they fire in correct
+          // order
+          subs.sort(function (a, b) { return a.id - b.id; });
+      }
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
   };
-
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
   var targetStack = [];
-
-  function pushTarget (target) {
-    targetStack.push(target);
-    Dep.target = target;
-  }
-
-  function popTarget () {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  /*  */
-
-  var VNode = function VNode (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
+  }
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
+  }
+
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
   };
 
   var prototypeAccessors = { child: { configurable: true } };
-
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   prototypeAccessors.child.get = function () {
-    return this.componentInstance
+      return this.componentInstance;
   };
 
   Object.defineProperties( VNode.prototype, prototypeAccessors );
-
   var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
+      if ( text === void 0 ) text = '';
 
-    var node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node
+      var node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
   };
-
-  function createTextVNode (val) {
-    return new VNode(undefined, undefined, undefined, String(val))
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
   }
-
   // optimized shallow clone
   // used for static nodes and slot nodes because they may be reused across
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
-  function cloneVNode (vnode) {
-    var cloned = new VNode(
-      vnode.tag,
-      vnode.data,
+  function cloneVNode(vnode) {
+      var cloned = new VNode(
+      //@ts-expect-error void type not valid here
+      vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
-      vnode.children && vnode.children.slice(),
-      vnode.text,
-      vnode.elm,
-      vnode.context,
-      vnode.componentOptions,
-      vnode.asyncFactory
-    );
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
   }
 
   /*
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-
   var arrayProto = Array.prototype;
   var arrayMethods = Object.create(arrayProto);
-
   var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-  ];
-
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse' ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args;
-          break
-        case 'splice':
-          inserted = args.slice(2);
-          break
-      }
-      if (inserted) { ob.observeArray(inserted); }
-      // notify change
-      ob.dep.notify();
-      return result
-    });
+      // cache original method
+      var original = arrayProto[method];
+      def(arrayMethods, method, function mutator() {
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
+
+          var result = original.apply(this, args);
+          var ob = this.__ob__;
+          var inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              { ob.observeArray(inserted); }
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  /*  */
-
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
   var shouldObserve = true;
-
-  function toggleObserving (value) {
-    shouldObserve = value;
+  function toggleObserving(value) {
+      shouldObserve = value;
   }
-
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
+          }
+          else {
+              copyAugment(value, arrayMethods, arrayKeys);
+          }
+          this.observeArray(value);
+      }
+      else {
+          this.walk(value);
+      }
   };
-
   /**
    * Walk through all properties and convert them into
    * getter/setters. This method should only be called when
    * value type is Object.
    */
   Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
-    }
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive$$1(obj, keys[i]);
+      }
   };
-
   /**
    * Observe a list of Array items.
    */
   Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
   };
-
   // helpers
-
   /**
    * Augment a target Object or Array by intercepting
    * the prototype chain using __proto__
    */
-  function protoAugment (target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
   }
-
   /**
    * Augment a target Object or Array by defining
    * hidden properties.
    */
   /* istanbul ignore next */
-  function copyAugment (target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
+  function copyAugment(target, src, keys) {
+      for (var i = 0, l = keys.length; i < l; i++) {
+          var key = keys[i];
+          def(target, key, src[key]);
+      }
   }
-
   /**
    * Attempt to create an observer instance for a value,
    * returns the new observer if successfully observed,
    * or the existing observer if the value already has one.
    */
-  function observe (value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      var ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
   }
-
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1 (
-    obj,
-    key,
-    val,
-    customSetter,
-    shallow
-  ) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter () {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter (newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) { return }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      }
-    });
+  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+      var dep = new Dep();
+      var property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      var getter = property && property.get;
+      var setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      var childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              var value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              var value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  { return; }
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
   }
-
   /**
    * Set a property on an object. Adds the new property and
    * triggers change notification if the property doesn't
    * already exist.
    */
-  function set (target, key, val) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-        'at runtime - declare it upfront in the data option.'
-      );
-      return val
-    }
-    if (!ob) {
-      target[key] = val;
-      return val
-    }
-    defineReactive$$1(ob.value, key, val);
-    ob.dep.notify();
-    return val
+  function set(target, key, val) {
+      if (isUndef(target) || isPrimitive(target)) {
+          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      var ob = target.__ob__;
+      // @ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive$$1(ob.value, key, val);
+      ob.dep.notify();
+      return val;
   }
-
   /**
    * Delete a property and trigger change if necessary.
    */
-  function del (target, key) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.splice(key, 1);
-      return
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid deleting properties on a Vue instance or its root $data ' +
-        '- just set it to null.'
-      );
-      return
-    }
-    if (!hasOwn(target, key)) {
-      return
-    }
-    delete target[key];
-    if (!ob) {
-      return
-    }
-    ob.dep.notify();
+  function del(target, key) {
+      if (isUndef(target) || isPrimitive(target)) {
+          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.splice(key, 1);
+          return;
+      }
+      var ob = target.__ob__;
+      //@ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                  '- just set it to null.');
+          return;
+      }
+      if (!hasOwn(target, key)) {
+          return;
+      }
+      delete target[key];
+      if (!ob) {
+          return;
+      }
+      ob.dep.notify();
   }
-
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
-  function dependArray (value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
+  function dependArray(value) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
    */
   var strats = config.optionMergeStrategies;
-
   /**
    * Options with restrictions
    */
   {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          "option \"" + key + "\" can only be used during instance " +
-          'creation with the `new` keyword.'
-        );
-      }
-      return defaultStrat(parent, child)
-    };
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn("option \"" + key + "\" can only be used during instance " +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
   }
-
   /**
    * Helper that recursively merges two data objects together.
    */
-  function mergeData (to, from) {
-    if (!from) { return to }
-    var key, toVal, fromVal;
-
-    var keys = hasSymbol
-      ? Reflect.ownKeys(from)
-      : Object.keys(from);
-
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === '__ob__') { continue }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to
+  function mergeData(to, from) {
+      if (!from)
+          { return to; }
+      var key, toVal, fromVal;
+      var keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (var i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              { continue; }
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
   }
-
   /**
    * Data
    */
-  function mergeDataOrFn (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn () {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn () {
-        // instance merge
-        var instanceData = typeof childVal === 'function'
-          ? childVal.call(vm, vm)
-          : childVal;
-        var defaultData = typeof parentVal === 'function'
-          ? parentVal.call(vm, vm)
-          : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
-      }
-    }
-  }
-
-  strats.data = function (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn(
-          'The "data" option should be a function ' +
-          'that returns a per-instance value in component ' +
-          'definitions.',
-          vm
-        );
-
-        return parentVal
-      }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-
-    return mergeDataOrFn(parentVal, childVal, vm)
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(
+              // @ts-ignore
+              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+              // @ts-ignore
+              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
   };
-
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook (
-    parentVal,
-    childVal
-  ) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-          ? childVal
-          : [childVal]
-      : parentVal;
-    return res
-      ? dedupeHooks(res)
-      : res
-  }
-
-  function dedupeHooks (hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
-      }
-    }
-    return res
+  function mergeHook(parentVal, childVal) {
+      var res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      var res = [];
+      for (var i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
   }
-
   LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+      strats[hook] = mergeHook;
   });
-
   /**
    * Assets
    *
@@ -1313,609 +1153,540 @@
    * a three-way merge between constructor options, instance
    * options and parent options.
    */
-  function mergeAssets (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal)
-    } else {
-      return res
-    }
+  function mergeAssets(parentVal, childVal, vm, key) {
+      var res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
   }
-
   ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
+      strats[type + 's'] = mergeAssets;
   });
-
   /**
    * Watchers.
    *
    * Watchers hashes should not overwrite one
    * another, so we merge them as arrays.
    */
-  strats.watch = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    // work around Firefox's Object.prototype.watch...
-    if (parentVal === nativeWatch) { parentVal = undefined; }
-    if (childVal === nativeWatch) { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal) { return Object.create(parentVal || null) }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child) ? child : [child];
-    }
-    return ret
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          { parentVal = undefined; }
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          { childVal = undefined; }
+      /* istanbul ignore if */
+      if (!childVal)
+          { return Object.create(parentVal || null); }
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = {};
+      extend(ret, parentVal);
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
   };
-
   /**
    * Other object hashes.
    */
-  strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== 'production') {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) { extend(ret, childVal); }
-    return ret
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          { extend(ret, childVal); }
+      return ret;
   };
   strats.provide = mergeDataOrFn;
-
   /**
    * Default strategy.
    */
   var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined
-      ? parentVal
-      : childVal
+      return childVal === undefined ? parentVal : childVal;
   };
-
   /**
    * Validate component names
    */
-  function checkComponents (options) {
-    for (var key in options.components) {
-      validateComponentName(key);
-    }
+  function checkComponents(options) {
+      for (var key in options.components) {
+          validateComponentName(key);
+      }
   }
-
-  function validateComponentName (name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-      warn(
-        'Invalid component name: "' + name + '". Component names ' +
-        'should conform to valid custom element name in html5 specification.'
-      );
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-      warn(
-        'Do not use built-in or reserved HTML elements as component ' +
-        'id: ' + name
-      );
-    }
+  function validateComponentName(name) {
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+          warn('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
   }
-
   /**
    * Ensure all props option syntax are normalized into the
    * Object-based format.
    */
-  function normalizeProps (options, vm) {
-    var props = options.props;
-    if (!props) { return }
-    var res = {};
-    var i, val, name;
-    if (Array.isArray(props)) {
-      i = props.length;
-      while (i--) {
-        val = props[i];
-        if (typeof val === 'string') {
-          name = camelize(val);
-          res[name] = { type: null };
-        } else {
-          warn('props must be strings when using array syntax.');
-        }
-      }
-    } else if (isPlainObject(props)) {
-      for (var key in props) {
-        val = props[key];
-        name = camelize(key);
-        res[name] = isPlainObject(val)
-          ? val
-          : { type: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"props\": expected an Array or an Object, " +
-        "but got " + (toRawType(props)) + ".",
-        vm
-      );
-    }
-    options.props = res;
-  }
-
+  function normalizeProps(options, vm) {
+      var props = options.props;
+      if (!props)
+          { return; }
+      var res = {};
+      var i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (var key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"props\": expected an Array or an Object, " +
+              "but got " + (toRawType(props)) + ".", vm);
+      }
+      options.props = res;
+  }
   /**
    * Normalize all injections into Object-based format
    */
-  function normalizeInject (options, vm) {
-    var inject = options.inject;
-    if (!inject) { return }
-    var normalized = options.inject = {};
-    if (Array.isArray(inject)) {
-      for (var i = 0; i < inject.length; i++) {
-        normalized[inject[i]] = { from: inject[i] };
-      }
-    } else if (isPlainObject(inject)) {
-      for (var key in inject) {
-        var val = inject[key];
-        normalized[key] = isPlainObject(val)
-          ? extend({ from: key }, val)
-          : { from: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"inject\": expected an Array or an Object, " +
-        "but got " + (toRawType(inject)) + ".",
-        vm
-      );
-    }
+  function normalizeInject(options, vm) {
+      var inject = options.inject;
+      if (!inject)
+          { return; }
+      var normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (var i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (var key in inject) {
+              var val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+              "but got " + (toRawType(inject)) + ".", vm);
+      }
   }
-
   /**
    * Normalize raw function directives into object format.
    */
-  function normalizeDirectives (options) {
-    var dirs = options.directives;
-    if (dirs) {
-      for (var key in dirs) {
-        var def$$1 = dirs[key];
-        if (typeof def$$1 === 'function') {
-          dirs[key] = { bind: def$$1, update: def$$1 };
-        }
-      }
-    }
-  }
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
-      );
-    }
+  function normalizeDirectives(options) {
+      var dirs = options.directives;
+      if (dirs) {
+          for (var key in dirs) {
+              var def$$1 = dirs[key];
+              if (typeof def$$1 === 'function') {
+                  dirs[key] = { bind: def$$1, update: def$$1 };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn("Invalid value for option \"" + name + "\": expected an Object, " +
+              "but got " + (toRawType(value)) + ".", vm);
+      }
   }
-
   /**
    * Merge two option objects into a new one.
    * Core utility used in both instantiation and inheritance.
    */
-  function mergeOptions (
-    parent,
-    child,
-    vm
-  ) {
-    {
-      checkComponents(child);
-    }
-
-    if (typeof child === 'function') {
-      child = child.options;
-    }
-
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-      if (child.extends) {
-        parent = mergeOptions(parent, child.extends, vm);
-      }
-      if (child.mixins) {
-        for (var i = 0, l = child.mixins.length; i < l; i++) {
-          parent = mergeOptions(parent, child.mixins[i], vm);
-        }
-      }
-    }
-
-    var options = {};
-    var key;
-    for (key in parent) {
-      mergeField(key);
-    }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
-      }
-    }
-    function mergeField (key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (var i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      var options = {};
+      var key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          var strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
   }
-
   /**
    * Resolve an asset.
    * This function is used because child instances need access
    * to assets defined in its ancestor chain.
    */
-  function resolveAsset (
-    options,
-    type,
-    id,
-    warnMissing
-  ) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-      return
-    }
-    var assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id)) { return assets[id] }
-    var camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-    var PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-    // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-      warn(
-        'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-        options
-      );
-    }
-    return res
-  }
-
-  /*  */
-
-
-
-  function validateProp (
-    key,
-    propOptions,
-    propsData,
-    vm
-  ) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
-    // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-      if (absent && !hasOwn(prop, 'default')) {
-        value = false;
-      } else if (value === '' || value === hyphenate(key)) {
-        // only cast empty string / same name to boolean if
-        // boolean has higher priority
-        var stringIndex = getTypeIndex(String, prop.type);
-        if (stringIndex < 0 || booleanIndex < stringIndex) {
-          value = true;
-        }
-      }
-    }
-    // check default value
-    if (value === undefined) {
-      value = getPropDefaultValue(vm, prop, key);
-      // since the default value is a fresh copy,
-      // make sure to observe it.
-      var prevShouldObserve = shouldObserve;
-      toggleObserving(true);
-      observe(value);
-      toggleObserving(prevShouldObserve);
-    }
-    {
-      assertProp(prop, key, value, vm, absent);
-    }
-    return value
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      var assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          { return assets[id]; }
+      var camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          { return assets[camelizedId]; }
+      var PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          { return assets[PascalCaseId]; }
+      // fallback to prototype chain
+      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
+  }
+
+  /* @flow */
+  function validateProp(key, propOptions, propsData, vm) {
+      var prop = propOptions[key];
+      var absent = !hasOwn(propsData, key);
+      var value = propsData[key];
+      // boolean casting
+      var booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              var stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          var prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
   }
-
   /**
    * Get the default value of a prop.
    */
-  function getPropDefaultValue (vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-      return undefined
-    }
-    var def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-      warn(
-        'Invalid default value for prop "' + key + '": ' +
-        'Props with type Object/Array must use a factory function ' +
-        'to return the default value.',
-        vm
-      );
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm && vm.$options.propsData &&
-      vm.$options.propsData[key] === undefined &&
-      vm._props[key] !== undefined
-    ) {
-      return vm._props[key]
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-      ? def.call(vm)
-      : def
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      var def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
   }
-
   /**
    * Assert whether a prop is valid.
    */
-  function assertProp (
-    prop,
-    name,
-    value,
-    vm,
-    absent
-  ) {
-    if (prop.required && absent) {
-      warn(
-        'Missing required prop: "' + name + '"',
-        vm
-      );
-      return
-    }
-    if (value == null && !prop.required) {
-      return
-    }
-    var type = prop.type;
-    var valid = !type || type === true;
-    var expectedTypes = [];
-    if (type) {
-      if (!Array.isArray(type)) {
-        type = [type];
-      }
-      for (var i = 0; i < type.length && !valid; i++) {
-        var assertedType = assertType(value, type[i]);
-        expectedTypes.push(assertedType.expectedType || '');
-        valid = assertedType.valid;
-      }
-    }
-
-    if (!valid) {
-      warn(
-        getInvalidTypeMessage(name, value, expectedTypes),
-        vm
-      );
-      return
-    }
-    var validator = prop.validator;
-    if (validator) {
-      if (!validator(value)) {
-        warn(
-          'Invalid prop: custom validator check failed for prop "' + name + '".',
-          vm
-        );
-      }
-    }
-  }
-
-  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-  function assertType (value, type) {
-    var valid;
-    var expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-      var t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      // for primitive wrapper objects
-      if (!valid && t === 'object') {
-        valid = value instanceof type;
-      }
-    } else if (expectedType === 'Object') {
-      valid = isPlainObject(value);
-    } else if (expectedType === 'Array') {
-      valid = Array.isArray(value);
-    } else {
-      valid = value instanceof type;
-    }
-    return {
-      valid: valid,
-      expectedType: expectedType
-    }
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      var type = prop.type;
+      // @ts-ignore
+      var valid = !type || type === true;
+      var expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (var i = 0; i < type.length && !valid; i++) {
+              var assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+      if (!valid && haveExpectedTypes) {
+          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      var validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
   }
-
+  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      var valid;
+      var expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          var t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid: valid,
+          expectedType: expectedType,
+      };
+  }
+  var functionTypeCheckRE = /^\s*function (\w+)/;
   /**
    * Use function string name to check built-in types,
    * because a simple equality check will fail when running
    * across different vms / iframes.
    */
-  function getType (fn) {
-    var match = fn && fn.toString().match(/^\s*function (\w+)/);
-    return match ? match[1] : ''
-  }
-
-  function isSameType (a, b) {
-    return getType(a) === getType(b)
-  }
-
-  function getTypeIndex (type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-      return isSameType(expectedTypes, type) ? 0 : -1
-    }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
-      if (isSameType(expectedTypes[i], type)) {
-        return i
-      }
-    }
-    return -1
-  }
-
-  function getInvalidTypeMessage (name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-      " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
-    var expectedValue = styleValue(value, expectedType);
-    var receivedValue = styleValue(value, receivedType);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        !isBoolean(expectedType, receivedType)) {
-      message += " with value " + expectedValue;
-    }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-      message += "with value " + receivedValue + ".";
-    }
-    return message
-  }
-
-  function styleValue (value, type) {
-    if (type === 'String') {
-      return ("\"" + value + "\"")
-    } else if (type === 'Number') {
-      return ("" + (Number(value)))
-    } else {
-      return ("" + value)
-    }
-  }
-
-  function isExplicable (value) {
-    var explicitTypes = ['string', 'number', 'boolean'];
-    return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
-  }
-
-  function isBoolean () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
-  }
-
-  /*  */
-
-  function handleError (err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-      if (vm) {
-        var cur = vm;
-        while ((cur = cur.$parent)) {
-          var hooks = cur.$options.errorCaptured;
-          if (hooks) {
-            for (var i = 0; i < hooks.length; i++) {
-              try {
-                var capture = hooks[i].call(cur, err, vm, info) === false;
-                if (capture) { return }
-              } catch (e) {
-                globalHandleError(e, cur, 'errorCaptured hook');
-              }
-            }
+  function getType(fn) {
+      var match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (var i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
           }
-        }
       }
-      globalHandleError(err, vm, info);
-    } finally {
-      popTarget();
-    }
-  }
-
-  function invokeWithErrorHandling (
-    handler,
-    context,
-    args,
-    vm,
-    info
-  ) {
-    var res;
-    try {
-      res = args ? handler.apply(context, args) : handler.call(context);
-      if (res && !res._isVue && isPromise(res) && !res._handled) {
-        res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-        // issue #9511
-        // avoid catch triggering multiple times when nested calls
-        res._handled = true;
-      }
-    } catch (e) {
-      handleError(e, vm, info);
-    }
-    return res
-  }
-
-  function globalHandleError (err, vm, info) {
-    if (config.errorHandler) {
-      try {
-        return config.errorHandler.call(null, err, vm, info)
-      } catch (e) {
-        // if the user intentionally throws the original error in the handler,
-        // do not log it twice
-        if (e !== err) {
-          logError(e, null, 'config.errorHandler');
-        }
+      return -1;
+  }
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
+      var expectedType = expectedTypes[0];
+      var receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += " with value " + (styleValue(value, expectedType));
+      }
+      message += ", got " + receivedType + " ";
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += "with value " + (styleValue(value, receivedType)) + ".";
+      }
+      return message;
+  }
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return ("\"" + value + "\"");
+      }
+      else if (type === 'Number') {
+          return ("" + (Number(value)));
+      }
+      else {
+          return ("" + value);
       }
-    }
-    logError(err, vm, info);
   }
+  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+  }
+  function isBoolean() {
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-  function logError (err, vm, info) {
-    {
-      warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-      console.error(err);
-    } else {
-      throw err
-    }
+      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
-  /*  */
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              var cur = vm;
+              while ((cur = cur.$parent)) {
+                  var hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (var i = 0; i < hooks.length; i++) {
+                          try {
+                              var capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  { return; }
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      var res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      if (config.errorHandler) {
+          try {
+              return config.errorHandler.call(null, err, vm, info);
+          }
+          catch (e) {
+              // if the user intentionally throws the original error in the handler,
+              // do not log it twice
+              if (e !== err) {
+                  logError(e, null, 'config.errorHandler');
+              }
+          }
+      }
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
+  }
 
+  /* @flow */
   var isUsingMicroTask = false;
-
   var callbacks = [];
   var pending = false;
-
-  function flushCallbacks () {
-    pending = false;
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
+  function flushCallbacks() {
+      pending = false;
+      var copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (var i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
   }
-
   // Here we have async deferring wrappers using microtasks.
   // In 2.5 we used (macro) tasks (in combination with microtasks).
   // However, it has subtle problems when state is changed right before repaint
@@ -1928,7 +1699,6 @@
   // sequential events (e.g. #4521, #6690, which have workarounds)
   // or even between bubbling of the same event (#6566).
   var timerFunc;
-
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -1937,3799 +1707,3315 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
-      p.then(flushCallbacks);
-      // In problematic UIWebViews, Promise.then doesn't completely break, but
-      // it can get stuck in a weird state where callbacks are pushed into the
-      // microtask queue but the queue isn't being flushed, until the browser
-      // needs to do some other work, e.g. handle a timer. Therefore we can
-      // "force" the microtask queue to be flushed by adding an empty timer.
-      if (isIOS) { setTimeout(noop); }
-    };
-    isUsingMicroTask = true;
-  } else if (!isIE && typeof MutationObserver !== 'undefined' && (
-    isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]'
-  )) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true
-    });
-    timerFunc = function () {
-      counter = (counter + 1) % 2;
-      textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = function () {
-      setImmediate(flushCallbacks);
-    };
-  } else {
-    // Fallback to setTimeout.
-    timerFunc = function () {
-      setTimeout(flushCallbacks, 0);
-    };
-  }
-
-  function nextTick (cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
-      if (cb) {
-        try {
-          cb.call(ctx);
-        } catch (e) {
-          handleError(e, ctx, 'nextTick');
-        }
-      } else if (_resolve) {
-        _resolve(ctx);
-      }
-    });
-    if (!pending) {
-      pending = true;
-      timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-      return new Promise(function (resolve) {
-        _resolve = resolve;
-      })
-    }
-  }
-
-  /*  */
+      var p = Promise.resolve();
+      timerFunc = function () {
+          p.then(flushCallbacks);
+          // In problematic UIWebViews, Promise.then doesn't completely break, but
+          // it can get stuck in a weird state where callbacks are pushed into the
+          // microtask queue but the queue isn't being flushed, until the browser
+          // needs to do some other work, e.g. handle a timer. Therefore we can
+          // "force" the microtask queue to be flushed by adding an empty timer.
+          if (isIOS)
+              { setTimeout(noop); }
+      };
+      isUsingMicroTask = true;
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      var counter = 1;
+      var observer = new MutationObserver(flushCallbacks);
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+      timerFunc = function () {
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+      // Fallback to setImmediate.
+      // Technically it leverages the (macro) task queue,
+      // but it is still a better choice than setTimeout.
+      timerFunc = function () {
+          setImmediate(flushCallbacks);
+      };
+  }
+  else {
+      // Fallback to setTimeout.
+      timerFunc = function () {
+          setTimeout(flushCallbacks, 0);
+      };
+  }
+  function nextTick(cb, ctx) {
+      var _resolve;
+      callbacks.push(function () {
+          if (cb) {
+              try {
+                  cb.call(ctx);
+              }
+              catch (e) {
+                  handleError(e, ctx, 'nextTick');
+              }
+          }
+          else if (_resolve) {
+              _resolve(ctx);
+          }
+      });
+      if (!pending) {
+          pending = true;
+          timerFunc();
+      }
+      // $flow-disable-line
+      if (!cb && typeof Promise !== 'undefined') {
+          return new Promise(function (resolve) {
+              _resolve = resolve;
+          });
+      }
+  }
+
+  /* @flow */
 
   var mark;
   var measure;
-
   {
-    var perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (
-      perf &&
-      perf.mark &&
-      perf.measure &&
-      perf.clearMarks &&
-      perf.clearMeasures
-    ) {
-      mark = function (tag) { return perf.mark(tag); };
-      measure = function (name, startTag, endTag) {
-        perf.measure(name, startTag, endTag);
-        perf.clearMarks(startTag);
-        perf.clearMarks(endTag);
-        // perf.clearMeasures(name)
-      };
-    }
+      var perf = inBrowser && window.performance;
+      /* istanbul ignore if */
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = function (tag) { return perf.mark(tag); };
+          measure = function (name, startTag, endTag) {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+              // perf.clearMeasures(name)
+          };
+      }
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
-
   var initProxy;
-
   {
-    var allowedGlobals = makeMap(
-      'Infinity,undefined,NaN,isFinite,isNaN,' +
-      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-      'require' // for Webpack/Browserify
-    );
-
-    var warnNonPresent = function (target, key) {
-      warn(
-        "Property or method \"" + key + "\" is not defined on the instance but " +
-        'referenced during render. Make sure that this property is reactive, ' +
-        'either in the data option, or for class-based components, by ' +
-        'initializing the property. ' +
-        'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-        target
+      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
       );
-    };
-
-    var warnReservedPrefix = function (target, key) {
-      warn(
-        "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-        'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-        'prevent conflicts with Vue internals. ' +
-        'See: https://vuejs.org/v2/api/#data',
-        target
-      );
-    };
-
-    var hasProxy =
-      typeof Proxy !== 'undefined' && isNative(Proxy);
-
-    if (hasProxy) {
-      var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-      config.keyCodes = new Proxy(config.keyCodes, {
-        set: function set (target, key, value) {
-          if (isBuiltInModifier(key)) {
-            warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-            return false
-          } else {
-            target[key] = value;
-            return true
-          }
-        }
-      });
-    }
-
-    var hasHandler = {
-      has: function has (target, key) {
-        var has = key in target;
-        var isAllowed = allowedGlobals(key) ||
-          (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-        if (!has && !isAllowed) {
-          if (key in target.$data) { warnReservedPrefix(target, key); }
-          else { warnNonPresent(target, key); }
-        }
-        return has || !isAllowed
-      }
-    };
-
-    var getHandler = {
-      get: function get (target, key) {
-        if (typeof key === 'string' && !(key in target)) {
-          if (key in target.$data) { warnReservedPrefix(target, key); }
-          else { warnNonPresent(target, key); }
-        }
-        return target[key]
-      }
-    };
-
-    initProxy = function initProxy (vm) {
+      var warnNonPresent = function (target, key) {
+          warn("Property or method \"" + key + "\" is not defined on the instance but " +
+              'referenced during render. Make sure that this property is reactive, ' +
+              'either in the data option, or for class-based components, by ' +
+              'initializing the property. ' +
+              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+      };
+      var warnReservedPrefix = function (target, key) {
+          warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+              'prevent conflicts with Vue internals. ' +
+              'See: https://vuejs.org/v2/api/#data', target);
+      };
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
       if (hasProxy) {
-        // determine which proxy handler to use
-        var options = vm.$options;
-        var handlers = options.render && options.render._withStripped
-          ? getHandler
-          : hasHandler;
-        vm._renderProxy = new Proxy(vm, handlers);
-      } else {
-        vm._renderProxy = vm;
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
       }
-    };
+      var hasHandler = {
+          has: function has(target, key) {
+              var has = key in target;
+              var isAllowed = allowedGlobals(key) ||
+                  (typeof key === 'string' &&
+                      key.charAt(0) === '_' &&
+                      !(key in target.$data));
+              if (!has && !isAllowed) {
+                  if (key in target.$data)
+                      { warnReservedPrefix(target, key); }
+                  else
+                      { warnNonPresent(target, key); }
+              }
+              return has || !isAllowed;
+          },
+      };
+      var getHandler = {
+          get: function get(target, key) {
+              if (typeof key === 'string' && !(key in target)) {
+                  if (key in target.$data)
+                      { warnReservedPrefix(target, key); }
+                  else
+                      { warnNonPresent(target, key); }
+              }
+              return target[key];
+          },
+      };
+      initProxy = function initProxy(vm) {
+          if (hasProxy) {
+              // determine which proxy handler to use
+              var options = vm.$options;
+              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              vm._renderProxy = new Proxy(vm, handlers);
+          }
+          else {
+              vm._renderProxy = vm;
+          }
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var seenObjects = new _Set();
-
   /**
    * Recursively traverse an object to evoke all converted
    * getters, so that every nested property inside the object
    * is collected as a "deep" dependency.
    */
-  function traverse (val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-  }
-
-  function _traverse (val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-      return
-    }
-    if (val.__ob__) {
-      var depId = val.__ob__.dep.id;
-      if (seen.has(depId)) {
-        return
-      }
-      seen.add(depId);
-    }
-    if (isA) {
-      i = val.length;
-      while (i--) { _traverse(val[i], seen); }
-    } else {
-      keys = Object.keys(val);
-      i = keys.length;
-      while (i--) { _traverse(val[keys[i]], seen); }
-    }
-  }
-
-  /*  */
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      var i, keys;
+      var isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          var depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              { _traverse(val[i], seen); }
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              { _traverse(val[keys[i]], seen); }
+      }
+  }
 
   var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-      name: name,
-      once: once$$1,
-      capture: capture,
-      passive: passive
-    }
+      var passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once$$1 ? name.slice(1) : name;
+      var capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name: name,
+          once: once$$1,
+          capture: capture,
+          passive: passive,
+      };
   });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          var arguments$1 = arguments;
+
+          var fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              var cloned = fns.slice();
+              for (var i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+      var name, def$$1, cur, old, event;
+      for (name in on) {
+          def$$1 = cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove$$1(event.name, oldOn[name], event.capture);
+          }
+      }
+  }
 
-  function createFnInvoker (fns, vm) {
-    function invoker () {
-      var arguments$1 = arguments;
-
-      var fns = invoker.fns;
-      if (Array.isArray(fns)) {
-        var cloned = fns.slice();
-        for (var i = 0; i < cloned.length; i++) {
-          invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-        }
-      } else {
-        // return handler return value for single handlers
-        return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-      }
-    }
-    invoker.fns = fns;
-    return invoker
-  }
-
-  function updateListeners (
-    on,
-    oldOn,
-    add,
-    remove$$1,
-    createOnceHandler,
-    vm
-  ) {
-    var name, def$$1, cur, old, event;
-    for (name in on) {
-      def$$1 = cur = on[name];
-      old = oldOn[name];
-      event = normalizeEvent(name);
-      if (isUndef(cur)) {
-        warn(
-          "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-          vm
-        );
-      } else if (isUndef(old)) {
-        if (isUndef(cur.fns)) {
-          cur = on[name] = createFnInvoker(cur, vm);
-        }
-        if (isTrue(event.once)) {
-          cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-        }
-        add(event.name, cur, event.capture, event.passive, event.params);
-      } else if (cur !== old) {
-        old.fns = cur;
-        on[name] = old;
-      }
-    }
-    for (name in oldOn) {
-      if (isUndef(on[name])) {
-        event = normalizeEvent(name);
-        remove$$1(event.name, oldOn[name], event.capture);
-      }
-    }
-  }
-
-  /*  */
-
-  function mergeVNodeHook (def, hookKey, hook) {
-    if (def instanceof VNode) {
-      def = def.data.hook || (def.data.hook = {});
-    }
-    var invoker;
-    var oldHook = def[hookKey];
-
-    function wrappedHook () {
-      hook.apply(this, arguments);
-      // important: remove merged hook to ensure it's called only once
-      // and prevent memory leak
-      remove(invoker.fns, wrappedHook);
-    }
-
-    if (isUndef(oldHook)) {
-      // no existing hook
-      invoker = createFnInvoker([wrappedHook]);
-    } else {
-      /* istanbul ignore if */
-      if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-        // already a merged invoker
-        invoker = oldHook;
-        invoker.fns.push(wrappedHook);
-      } else {
-        // existing plain hook
-        invoker = createFnInvoker([oldHook, wrappedHook]);
-      }
-    }
-
-    invoker.merged = true;
-    def[hookKey] = invoker;
-  }
-
-  /*  */
-
-  function extractPropsFromVNodeData (
-    data,
-    Ctor,
-    tag
-  ) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    var propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-      return
-    }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
-    if (isDef(attrs) || isDef(props)) {
-      for (var key in propOptions) {
-        var altKey = hyphenate(key);
-        {
-          var keyInLowerCase = key.toLowerCase();
-          if (
-            key !== keyInLowerCase &&
-            attrs && hasOwn(attrs, keyInLowerCase)
-          ) {
-            tip(
-              "Prop \"" + keyInLowerCase + "\" is passed to component " +
-              (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-              " \"" + key + "\". " +
-              "Note that HTML attributes are case-insensitive and camelCased " +
-              "props need to use their kebab-case equivalents when using in-DOM " +
-              "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-            );
-          }
-        }
-        checkProp(res, props, key, altKey, true) ||
-        checkProp(res, attrs, key, altKey, false);
-      }
-    }
-    return res
-  }
-
-  function checkProp (
-    res,
-    hash,
-    key,
-    altKey,
-    preserve
-  ) {
-    if (isDef(hash)) {
-      if (hasOwn(hash, key)) {
-        res[key] = hash[key];
-        if (!preserve) {
-          delete hash[key];
-        }
-        return true
-      } else if (hasOwn(hash, altKey)) {
-        res[key] = hash[altKey];
-        if (!preserve) {
-          delete hash[altKey];
-        }
-        return true
-      }
-    }
-    return false
-  }
-
-  /*  */
+  /* @flow */
+  function mergeVNodeHook(def, hookKey, hook) {
+      if (def instanceof VNode) {
+          def = def.data.hook || (def.data.hook = {});
+      }
+      var invoker;
+      var oldHook = def[hookKey];
+      function wrappedHook() {
+          hook.apply(this, arguments);
+          // important: remove merged hook to ensure it's called only once
+          // and prevent memory leak
+          remove(invoker.fns, wrappedHook);
+      }
+      if (isUndef(oldHook)) {
+          // no existing hook
+          invoker = createFnInvoker([wrappedHook]);
+      }
+      else {
+          /* istanbul ignore if */
+          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+              // already a merged invoker
+              invoker = oldHook;
+              invoker.fns.push(wrappedHook);
+          }
+          else {
+              // existing plain hook
+              invoker = createFnInvoker([oldHook, wrappedHook]);
+          }
+      }
+      invoker.merged = true;
+      def[hookKey] = invoker;
+  }
+
+  /* @flow */
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      var propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      var res = {};
+      var attrs = data.attrs;
+      var props = data.props;
+      if (isDef(attrs) || isDef(props)) {
+          for (var key in propOptions) {
+              var altKey = hyphenate(key);
+              {
+                  var keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                          (formatComponentName(
+                          // @ts-ignore
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
+                          "Note that HTML attributes are case-insensitive and camelCased " +
+                          "props need to use their kebab-case equivalents when using in-DOM " +
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
+  }
 
+  /* @flow */
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
   // For plain HTML markup, normalization can be completely skipped because the
   // generated render function is guaranteed to return Array<VNode>. There are
   // two cases where extra normalization is needed:
-
   // 1. When the children contains components - because a functional component
   // may return an Array instead of a single root. In this case, just a simple
   // normalization is needed - if any child is an Array, we flatten the whole
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
-  function simpleNormalizeChildren (children) {
-    for (var i = 0; i < children.length; i++) {
-      if (Array.isArray(children[i])) {
-        return Array.prototype.concat.apply([], children)
+  function simpleNormalizeChildren(children) {
+      for (var i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
       }
-    }
-    return children
+      return children;
   }
-
   // 2. When the children contains constructs that always generated nested Arrays,
   // e.g. <template>, <slot>, v-for, or when the children is provided by user
   // with hand-written render functions / JSX. In such cases a full normalization
   // is needed to cater to all possible types of children values.
-  function normalizeChildren (children) {
-    return isPrimitive(children)
-      ? [createTextVNode(children)]
-      : Array.isArray(children)
-        ? normalizeArrayChildren(children)
-        : undefined
-  }
-
-  function isTextNode (node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-  }
-
-  function normalizeArrayChildren (children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-      c = children[i];
-      if (isUndef(c) || typeof c === 'boolean') { continue }
-      lastIndex = res.length - 1;
-      last = res[lastIndex];
-      //  nested
-      if (Array.isArray(c)) {
-        if (c.length > 0) {
-          c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-          // merge adjacent text nodes
-          if (isTextNode(c[0]) && isTextNode(last)) {
-            res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-            c.shift();
-          }
-          res.push.apply(res, c);
-        }
-      } else if (isPrimitive(c)) {
-        if (isTextNode(last)) {
-          // merge adjacent text nodes
-          // this is necessary for SSR hydration because text nodes are
-          // essentially merged when rendered to HTML strings
-          res[lastIndex] = createTextVNode(last.text + c);
-        } else if (c !== '') {
-          // convert primitive to vnode
-          res.push(createTextVNode(c));
-        }
-      } else {
-        if (isTextNode(c) && isTextNode(last)) {
-          // merge adjacent text nodes
-          res[lastIndex] = createTextVNode(last.text + c.text);
-        } else {
-          // default key for nested array children (likely generated by v-for)
-          if (isTrue(children._isVList) &&
-            isDef(c.tag) &&
-            isUndef(c.key) &&
-            isDef(nestedIndex)) {
-            c.key = "__vlist" + nestedIndex + "_" + i + "__";
-          }
-          res.push(c);
-        }
-      }
-    }
-    return res
-  }
-
-  /*  */
-
-  function initProvide (vm) {
-    var provide = vm.$options.provide;
-    if (provide) {
-      vm._provided = typeof provide === 'function'
-        ? provide.call(vm)
-        : provide;
-    }
-  }
-
-  function initInjections (vm) {
-    var result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-      toggleObserving(false);
-      Object.keys(result).forEach(function (key) {
-        /* istanbul ignore else */
-        {
-          defineReactive$$1(vm, key, result[key], function () {
-            warn(
-              "Avoid mutating an injected value directly since the changes will be " +
-              "overwritten whenever the provided component re-renders. " +
-              "injection being mutated: \"" + key + "\"",
-              vm
-            );
-          });
-        }
-      });
-      toggleObserving(true);
-    }
-  }
-
-  function resolveInject (inject, vm) {
-    if (inject) {
-      // inject is :any because flow is not smart enough to figure out cached
-      var result = Object.create(null);
-      var keys = hasSymbol
-        ? Reflect.ownKeys(inject)
-        : Object.keys(inject);
-
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        // #6574 in case the inject object is observed...
-        if (key === '__ob__') { continue }
-        var provideKey = inject[key].from;
-        var source = vm;
-        while (source) {
-          if (source._provided && hasOwn(source._provided, provideKey)) {
-            result[key] = source._provided[provideKey];
-            break
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      var res = [];
+      var i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              { continue; }
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                  }
+                  res.push(c);
+              }
           }
-          source = source.$parent;
-        }
-        if (!source) {
-          if ('default' in inject[key]) {
-            var provideDefault = inject[key].default;
-            result[key] = typeof provideDefault === 'function'
-              ? provideDefault.call(vm)
-              : provideDefault;
-          } else {
-            warn(("Injection \"" + key + "\" not found"), vm);
+      }
+      return res;
+  }
+
+  /* @flow */
+  function initProvide(vm) {
+      var provide = vm.$options.provide;
+      if (provide) {
+          vm._provided =
+              typeof provide === 'function'
+                  ? // @ts-expect-error typing not correct
+                      provide.call(vm)
+                  : provide;
+      }
+  }
+  function initInjections(vm) {
+      var result = resolveInject(vm.$options.inject, vm);
+      if (result) {
+          toggleObserving(false);
+          Object.keys(result).forEach(function (key) {
+              /* istanbul ignore else */
+              {
+                  defineReactive$$1(vm, key, result[key], function () {
+                      warn("Avoid mutating an injected value directly since the changes will be " +
+                          "overwritten whenever the provided component re-renders. " +
+                          "injection being mutated: \"" + key + "\"", vm);
+                  });
+              }
+          });
+          toggleObserving(true);
+      }
+  }
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          var result = Object.create(null);
+          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (var i = 0; i < keys.length; i++) {
+              var key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  { continue; }
+              var provideKey = inject[key].from;
+              var source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      var provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      // @ts-ignore
+                      warn(("Injection \"" + key + "\" not found"), vm);
+                  }
+              }
           }
-        }
+          return result;
       }
-      return result
-    }
   }
 
-  /*  */
-
-
-
+  /* @flow */
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
-  function resolveSlots (
-    children,
-    context
-  ) {
-    if (!children || !children.length) {
-      return {}
-    }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-      var child = children[i];
-      var data = child.data;
-      // remove slot attribute if the node is resolved as a Vue slot node
-      if (data && data.attrs && data.attrs.slot) {
-        delete data.attrs.slot;
-      }
-      // named slots should only be respected if the vnode was rendered in the
-      // same context.
-      if ((child.context === context || child.fnContext === context) &&
-        data && data.slot != null
-      ) {
-        var name = data.slot;
-        var slot = (slots[name] || (slots[name] = []));
-        if (child.tag === 'template') {
-          slot.push.apply(slot, child.children || []);
-        } else {
-          slot.push(child);
-        }
-      } else {
-        (slots.default || (slots.default = [])).push(child);
-      }
-    }
-    // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-      if (slots[name$1].every(isWhitespace)) {
-        delete slots[name$1];
-      }
-    }
-    return slots
-  }
-
-  function isWhitespace (node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' '
-  }
-
-  /*  */
-
-  function normalizeScopedSlots (
-    slots,
-    normalSlots,
-    prevSlots
-  ) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
-    if (!slots) {
-      res = {};
-    } else if (slots._normalized) {
-      // fast path 1: child component re-render only, parent did not change
-      return slots._normalized
-    } else if (
-      isStable &&
-      prevSlots &&
-      prevSlots !== emptyObject &&
-      key === prevSlots.$key &&
-      !hasNormalSlots &&
-      !prevSlots.$hasNormal
-    ) {
-      // fast path 2: stable scoped slots w/ no normal slots to proxy,
-      // only need to normalize once
-      return prevSlots
-    } else {
-      res = {};
-      for (var key$1 in slots) {
-        if (slots[key$1] && key$1[0] !== '$') {
-          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-        }
-      }
-    }
-    // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-      if (!(key$2 in res)) {
-        res[key$2] = proxyNormalSlot(normalSlots, key$2);
-      }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-      (slots)._normalized = res;
-    }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
-    return res
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      var slots = {};
+      for (var i = 0, l = children.length; i < l; i++) {
+          var child = children[i];
+          var data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  }
+
+  /* @flow */
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      var res;
+      var hasNormalSlots = Object.keys(normalSlots).length > 0;
+      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      var key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, '$stable', isStable);
+      def(res, '$key', key);
+      def(res, '$hasNormal', hasNormalSlots);
+      return res;
   }
-
   function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-      var res = arguments.length ? fn.apply(null, arguments) : fn({});
-      res = res && typeof res === 'object' && !Array.isArray(res)
-        ? [res] // single vnode
-        : normalizeChildren(res);
-      return res && (
-        res.length === 0 ||
-        (res.length === 1 && res[0].isComment) // #9658
-      ) ? undefined
-        : res
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-      Object.defineProperty(normalSlots, key, {
-        get: normalized,
-        enumerable: true,
-        configurable: true
-      });
-    }
-    return normalized
+      var normalized = function () {
+          var res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === 'object' && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
   }
-
   function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; }
+      return function () { return slots[key]; };
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering v-for lists.
    */
-  function renderList (
-    val,
-    render
-  ) {
-    var ret, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-      ret = new Array(val.length);
-      for (i = 0, l = val.length; i < l; i++) {
-        ret[i] = render(val[i], i);
-      }
-    } else if (typeof val === 'number') {
-      ret = new Array(val);
-      for (i = 0; i < val; i++) {
-        ret[i] = render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      if (hasSymbol && val[Symbol.iterator]) {
-        ret = [];
-        var iterator = val[Symbol.iterator]();
-        var result = iterator.next();
-        while (!result.done) {
-          ret.push(render(result.value, ret.length));
-          result = iterator.next();
-        }
-      } else {
-        keys = Object.keys(val);
-        ret = new Array(keys.length);
-        for (i = 0, l = keys.length; i < l; i++) {
-          key = keys[i];
-          ret[i] = render(val[key], key, i);
-        }
+  function renderList(val, render) {
+      var ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
       }
-    }
-    if (!isDef(ret)) {
-      ret = [];
-    }
-    (ret)._isVList = true;
-    return ret
-  }
-
-  /*  */
-
-  /**
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              var iterator = val[Symbol.iterator]();
+              var result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
+  }
+
+  /**
    * Runtime helper for rendering <slot>
    */
-  function renderSlot (
-    name,
-    fallback,
-    props,
-    bindObject
-  ) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
-    if (scopedSlotFn) { // scoped slot
-      props = props || {};
-      if (bindObject) {
-        if (!isObject(bindObject)) {
-          warn(
-            'slot v-bind without argument expects an Object',
-            this
-          );
-        }
-        props = extend(extend({}, bindObject), props);
+  function renderSlot(name, fallback, props, bindObject) {
+      var scopedSlotFn = this.$scopedSlots[name];
+      var nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn('slot v-bind without argument expects an Object', this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes = scopedSlotFn(props) || fallback;
+      }
+      else {
+          nodes = this.$slots[name] || fallback;
+      }
+      var target = props && props.slot;
+      if (target) {
+          return this.$createElement('template', { slot: target }, nodes);
+      }
+      else {
+          return nodes;
       }
-      nodes = scopedSlotFn(props) || fallback;
-    } else {
-      nodes = this.$slots[name] || fallback;
-    }
-
-    var target = props && props.slot;
-    if (target) {
-      return this.$createElement('template', { slot: target }, nodes)
-    } else {
-      return nodes
-    }
   }
 
-  /*  */
-
   /**
    * Runtime helper for resolving filters
    */
-  function resolveFilter (id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /*  */
-
-  function isKeyNotMatch (expect, actual) {
-    if (Array.isArray(expect)) {
-      return expect.indexOf(actual) === -1
-    } else {
-      return expect !== actual
-    }
+  /* @flow */
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
   }
-
   /**
    * Runtime helper for checking keyCodes from config.
    * exposed as Vue.prototype._k
    * passing in eventKeyName as last argument separately for backwards compat
    */
-  function checkKeyCodes (
-    eventKeyCode,
-    key,
-    builtInKeyCode,
-    eventKeyName,
-    builtInKeyName
-  ) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-      return isKeyNotMatch(builtInKeyName, eventKeyName)
-    } else if (mappedKeyCode) {
-      return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-    } else if (eventKeyName) {
-      return hyphenate(eventKeyName) !== key
-    }
-  }
-
-  /*  */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+  }
 
+  /* @flow */
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
-  function bindObjectProps (
-    data,
-    tag,
-    value,
-    asProp,
-    isSync
-  ) {
-    if (value) {
-      if (!isObject(value)) {
-        warn(
-          'v-bind without argument expects an Object or Array value',
-          this
-        );
-      } else {
-        if (Array.isArray(value)) {
-          value = toObject(value);
-        }
-        var hash;
-        var loop = function ( key ) {
-          if (
-            key === 'class' ||
-            key === 'style' ||
-            isReservedAttribute(key)
-          ) {
-            hash = data;
-          } else {
-            var type = data.attrs && data.attrs.type;
-            hash = asProp || config.mustUseProp(tag, type, key)
-              ? data.domProps || (data.domProps = {})
-              : data.attrs || (data.attrs = {});
-          }
-          var camelizedKey = camelize(key);
-          var hyphenatedKey = hyphenate(key);
-          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-            hash[key] = value[key];
-
-            if (isSync) {
-              var on = data.on || (data.on = {});
-              on[("update:" + key)] = function ($event) {
-                value[key] = $event;
-              };
-            }
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn('v-bind without argument expects an Object or Array value', this);
           }
-        };
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              var hash;
+              var loop = function ( key ) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      var type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  var camelizedKey = camelize(key);
+                  var hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          var on = data.on || (data.on = {});
+                          on[("update:" + key)] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              };
 
-        for (var key in value) loop( key );
+              for (var key in value) loop( key );
+          }
       }
-    }
-    return data
+      return data;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering static trees.
    */
-  function renderStatic (
-    index,
-    isInFor
-  ) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-      return tree
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(
-      this._renderProxy,
-      null,
-      this // for render fns generated for functional component templates
-    );
-    markStatic(tree, ("__static__" + index), false);
-    return tree
+  function renderStatic(index, isInFor) {
+      var cached = this._staticTrees || (this._staticTrees = []);
+      var tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, ("__static__" + index), false);
+      return tree;
   }
-
   /**
    * Runtime helper for v-once.
    * Effectively it means marking the node as static with a unique key.
    */
-  function markOnce (
-    tree,
-    index,
-    key
-  ) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-    return tree
+  function markOnce(tree, index, key) {
+      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (var i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
-  function markStatic (
-    tree,
-    key,
-    isOnce
-  ) {
-    if (Array.isArray(tree)) {
-      for (var i = 0; i < tree.length; i++) {
-        if (tree[i] && typeof tree[i] !== 'string') {
-          markStaticNode(tree[i], (key + "_" + i), isOnce);
-        }
+  /* @flow */
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn('v-on without argument expects an Object value', this);
+          }
+          else {
+              var on = (data.on = data.on ? extend({}, data.on) : {});
+              for (var key in value) {
+                  var existing = on[key];
+                  var ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
       }
-    } else {
-      markStaticNode(tree, key, isOnce);
-    }
+      return data;
   }
 
-  function markStaticNode (node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (var i = 0; i < fns.length; i++) {
+          var slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
-  /*  */
-
-  function bindObjectListeners (data, value) {
-    if (value) {
-      if (!isPlainObject(value)) {
-        warn(
-          'v-on without argument expects an Object value',
-          this
-        );
-      } else {
-        var on = data.on = data.on ? extend({}, data.on) : {};
-        for (var key in value) {
-          var existing = on[key];
-          var ours = value[key];
-          on[key] = existing ? [].concat(existing, ours) : ours;
-        }
-      }
-    }
-    return data
-  }
-
-  /*  */
-
-  function resolveScopedSlots (
-    fns, // see flow/vnode
-    res,
-    // the following are added in 2.6
-    hasDynamicKeys,
-    contentHashKey
-  ) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-      var slot = fns[i];
-      if (Array.isArray(slot)) {
-        resolveScopedSlots(slot, res, hasDynamicKeys);
-      } else if (slot) {
-        // marker for reverse proxying v-slot without scope on this.$slots
-        if (slot.proxy) {
-          slot.fn.proxy = true;
-        }
-        res[slot.key] = slot.fn;
-      }
-    }
-    if (contentHashKey) {
-      (res).$key = contentHashKey;
-    }
-    return res
-  }
-
-  /*  */
-
-  function bindDynamicKeys (baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-      var key = values[i];
-      if (typeof key === 'string' && key) {
-        baseObj[values[i]] = values[i + 1];
-      } else if (key !== '' && key !== null) {
-        // null is a special value for explicitly removing a binding
-        warn(
-          ("Invalid value for dynamic directive argument (expected string or null): " + key),
-          this
-        );
-      }
-    }
-    return baseObj
+  /* @flow */
+  function bindDynamicKeys(baseObj, values) {
+      for (var i = 0; i < values.length; i += 2) {
+          var key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+          }
+      }
+      return baseObj;
   }
-
   // helper to dynamically append modifier runtime markers to event names.
   // ensure only append when value is already string, otherwise it will be cast
   // to string and cause the type check to miss.
-  function prependModifier (value, symbol) {
-    return typeof value === 'string' ? symbol + value : value
-  }
-
-  /*  */
-
-  function installRenderHelpers (target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-  }
-
-  /*  */
-
-  function FunctionalRenderContext (
-    data,
-    props,
-    children,
-    parent,
-    Ctor
-  ) {
-    var this$1 = this;
-
-    var options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
-    if (hasOwn(parent, '_uid')) {
-      contextVm = Object.create(parent);
-      // $flow-disable-line
-      contextVm._original = parent;
-    } else {
-      // the context vm passed in is a functional context as well.
-      // in this case we want to make sure we are able to get a hold to the
-      // real context instance.
-      contextVm = parent;
-      // $flow-disable-line
-      parent = parent._original;
-    }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
-
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-      if (!this$1.$slots) {
-        normalizeScopedSlots(
-          data.scopedSlots,
-          this$1.$slots = resolveSlots(children, parent)
-        );
-      }
-      return this$1.$slots
-    };
-
-    Object.defineProperty(this, 'scopedSlots', ({
-      enumerable: true,
-      get: function get () {
-        return normalizeScopedSlots(data.scopedSlots, this.slots())
-      }
-    }));
-
-    // support for compiled functional template
-    if (isCompiled) {
-      // exposing $options for renderStatic()
-      this.$options = options;
-      // pre-resolve slots for renderSlot()
-      this.$slots = this.slots();
-      this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-
-    if (options._scopeId) {
-      this._c = function (a, b, c, d) {
-        var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-        if (vnode && !Array.isArray(vnode)) {
-          vnode.fnScopeId = options._scopeId;
-          vnode.fnContext = parent;
-        }
-        return vnode
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
+  }
+
+  /* @flow */
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
+  }
+
+  /* @flow */
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      var this$1 = this;
+
+      var options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      var contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      var isCompiled = isTrue(options._compiled);
+      var needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = function () {
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          }
+          return this$1.$slots;
       };
-    } else {
-      this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-    }
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get: function get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = function (a, b, c, d) {
+              var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+      }
   }
-
   installRenderHelpers(FunctionalRenderContext.prototype);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      var options = Ctor.options;
+      var props = {};
+      var propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (var key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              { mergeProps(props, data.attrs); }
+          if (isDef(data.props))
+              { mergeProps(props, data.props); }
+      }
+      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      var vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          var vnodes = normalizeChildren(vnode) || [];
+          var res = new Array(vnodes.length);
+          for (var i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      var clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (var key in from) {
+          to[camelize(key)] = from[key];
+      }
+  }
 
-  function createFunctionalComponent (
-    Ctor,
-    propsData,
-    data,
-    contextVm,
-    children
-  ) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
-    if (isDef(propOptions)) {
-      for (var key in propOptions) {
-        props[key] = validateProp(key, propOptions, propsData || emptyObject);
-      }
-    } else {
-      if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-      if (isDef(data.props)) { mergeProps(props, data.props); }
-    }
-
-    var renderContext = new FunctionalRenderContext(
-      data,
-      props,
-      children,
-      contextVm,
-      Ctor
-    );
-
-    var vnode = options.render.call(null, renderContext._c, renderContext);
-
-    if (vnode instanceof VNode) {
-      return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-    } else if (Array.isArray(vnode)) {
-      var vnodes = normalizeChildren(vnode) || [];
-      var res = new Array(vnodes.length);
-      for (var i = 0; i < vnodes.length; i++) {
-        res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-      }
-      return res
-    }
-  }
-
-  function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    var clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-      (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-      (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone
-  }
-
-  function mergeProps (to, from) {
-    for (var key in from) {
-      to[camelize(key)] = from[key];
-    }
-  }
-
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  /*  */
+  /* @flow */
 
+  /* @flow */
+
+  /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-    init: function init (vnode, hydrating) {
-      if (
-        vnode.componentInstance &&
-        !vnode.componentInstance._isDestroyed &&
-        vnode.data.keepAlive
-      ) {
-        // kept-alive components, treat as a patch
-        var mountedNode = vnode; // work around flow
-        componentVNodeHooks.prepatch(mountedNode, mountedNode);
-      } else {
-        var child = vnode.componentInstance = createComponentInstanceForVnode(
-          vnode,
-          activeInstance
-        );
-        child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-      }
-    },
-
-    prepatch: function prepatch (oldVnode, vnode) {
-      var options = vnode.componentOptions;
-      var child = vnode.componentInstance = oldVnode.componentInstance;
-      updateChildComponent(
-        child,
-        options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-      );
-    },
-
-    insert: function insert (vnode) {
-      var context = vnode.context;
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isMounted) {
-        componentInstance._isMounted = true;
-        callHook(componentInstance, 'mounted');
-      }
-      if (vnode.data.keepAlive) {
-        if (context._isMounted) {
-          // vue-router#1212
-          // During updates, a kept-alive component's child components may
-          // change, so directly walking the tree here may call activated hooks
-          // on incorrect children. Instead we push them into a queue which will
-          // be processed after the whole patch process ended.
-          queueActivatedComponent(componentInstance);
-        } else {
-          activateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    },
-
-    destroy: function destroy (vnode) {
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isDestroyed) {
-        if (!vnode.data.keepAlive) {
-          componentInstance.$destroy();
-        } else {
-          deactivateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    }
+      init: function init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              var mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch: function prepatch(oldVnode, vnode) {
+          var options = vnode.componentOptions;
+          var child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy: function destroy(vnode) {
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
   };
-
   var hooksToMerge = Object.keys(componentVNodeHooks);
-
-  function createComponent (
-    Ctor,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    if (isUndef(Ctor)) {
-      return
-    }
-
-    var baseCtor = context.$options._base;
-
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-      Ctor = baseCtor.extend(Ctor);
-    }
-
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-      {
-        warn(("Invalid Component definition: " + (String(Ctor))), context);
-      }
-      return
-    }
-
-    // async component
-    var asyncFactory;
-    if (isUndef(Ctor.cid)) {
-      asyncFactory = Ctor;
-      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-      if (Ctor === undefined) {
-        // return a placeholder node for async component, which is rendered
-        // as a comment node but preserves all the raw information for the node.
-        // the information will be used for async server-rendering and hydration.
-        return createAsyncPlaceholder(
-          asyncFactory,
-          data,
-          context,
-          children,
-          tag
-        )
-      }
-    }
-
-    data = data || {};
-
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-      transformModel(Ctor.options, data);
-    }
-
-    // extract props
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-    // functional component
-    if (isTrue(Ctor.options.functional)) {
-      return createFunctionalComponent(Ctor, propsData, data, context, children)
-    }
-
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    var listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-
-    if (isTrue(Ctor.options.abstract)) {
-      // abstract components do not keep anything
-      // other than props & listeners & slot
-
-      // work around flow
-      var slot = data.slot;
-      data = {};
-      if (slot) {
-        data.slot = slot;
-      }
-    }
-
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-
-    // return a placeholder vnode
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-      data, undefined, undefined, undefined, context,
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-      asyncFactory
-    );
-
-    return vnode
-  }
-
-  function createComponentInstanceForVnode (
-    vnode, // we know it's MountedComponentVNode but flow doesn't
-    parent // activeInstance in lifecycle state
-  ) {
-    var options = {
-      _isComponent: true,
-      _parentVnode: vnode,
-      parent: parent
-    };
-    // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-      options.render = inlineTemplate.render;
-      options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options)
-  }
-
-  function installComponentHooks (data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-      var key = hooksToMerge[i];
-      var existing = hooks[key];
-      var toMerge = componentVNodeHooks[key];
-      if (existing !== toMerge && !(existing && existing._merged)) {
-        hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-      }
-    }
-  }
-
-  function mergeHook$1 (f1, f2) {
-    var merged = function (a, b) {
-      // flow complains about extra args which is why we use any
-      f1(a, b);
-      f2(a, b);
-    };
-    merged._merged = true;
-    return merged
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      var baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn(("Invalid Component definition: " + (String(Ctor))), context);
+          }
+          return;
+      }
+      // async component
+      var asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      var listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          var slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      var name = Ctor.options.name || tag;
+      var vnode = new VNode(
+      // @ts-expect-error
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      var options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent: parent,
+      };
+      // check inline-template render functions
+      var inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      var hooks = data.hook || (data.hook = {});
+      for (var i = 0; i < hooksToMerge.length; i++) {
+          var key = hooksToMerge[i];
+          var existing = hooks[key];
+          var toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook$1(f1, f2) {
+      var merged = function (a, b) {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
   }
-
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
-  function transformModel (options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input'
-    ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
-    if (isDef(existing)) {
-      if (
-        Array.isArray(existing)
-          ? existing.indexOf(callback) === -1
-          : existing !== callback
-      ) {
-        on[event] = [callback].concat(existing);
-      }
-    } else {
-      on[event] = callback;
-    }
-  }
-
-  /*  */
+  function transformModel(options, data) {
+      var prop = (options.model && options.model.prop) || 'value';
+      var event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      var on = data.on || (data.on = {});
+      var existing = on[event];
+      var callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
+  }
 
+  /* @flow */
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
-
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType,
-    alwaysNormalize
-  ) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-      normalizationType = children;
-      children = data;
-      data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-      normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType)
-  }
-
-  function _createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType
-  ) {
-    if (isDef(data) && isDef((data).__ob__)) {
-      warn(
-        "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-        'Always create fresh vnode data objects in each render!',
-        context
-      );
-      return createEmptyVNode()
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-      tag = data.is;
-    }
-    if (!tag) {
-      // in case of component :is set to falsy value
-      return createEmptyVNode()
-    }
-    // warn against non-primitive key
-    if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-    ) {
-      {
-        warn(
-          'Avoid using non-primitive value as key, ' +
-          'use string/number value instead.',
-          context
-        );
-      }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) &&
-      typeof children[0] === 'function'
-    ) {
-      data = data || {};
-      data.scopedSlots = { default: children[0] };
-      children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-      children = normalizeChildren(children);
-    } else if (normalizationType === SIMPLE_NORMALIZE) {
-      children = simpleNormalizeChildren(children);
-    }
-    var vnode, ns;
-    if (typeof tag === 'string') {
-      var Ctor;
-      ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-      if (config.isReservedTag(tag)) {
-        // platform built-in elements
-        if (isDef(data) && isDef(data.nativeOn)) {
-          warn(
-            ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-            context
-          );
-        }
-        vnode = new VNode(
-          config.parsePlatformTagName(tag), data, children,
-          undefined, undefined, context
-        );
-      } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-        // component
-        vnode = createComponent(Ctor, data, context, children, tag);
-      } else {
-        // unknown or unlisted namespaced elements
-        // check at runtime because it may get assigned a namespace when its
-        // parent normalizes children
-        vnode = new VNode(
-          tag, data, children,
-          undefined, undefined, context
-        );
-      }
-    } else {
-      // direct component options / constructor
-      vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-      return vnode
-    } else if (isDef(vnode)) {
-      if (isDef(ns)) { applyNS(vnode, ns); }
-      if (isDef(data)) { registerDeepBindings(data); }
-      return vnode
-    } else {
-      return createEmptyVNode()
-    }
-  }
-
-  function applyNS (vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-      // use default namespace inside foreignObject
-      ns = undefined;
-      force = true;
-    }
-    if (isDef(vnode.children)) {
-      for (var i = 0, l = vnode.children.length; i < l; i++) {
-        var child = vnode.children[i];
-        if (isDef(child.tag) && (
-          isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-          applyNS(child, ns, force);
-        }
-      }
-    }
+  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      var vnode, ns;
+      if (typeof tag === 'string') {
+          var Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if (config.isReservedTag(tag)) {
+              // platform built-in elements
+              if (isDef(data) &&
+                  isDef(data.nativeOn) &&
+                  data.tag !== 'component') {
+                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+              }
+              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+          }
+          else if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              { applyNS(vnode, ns); }
+          if (isDef(data))
+              { registerDeepBindings(data); }
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (var i = 0, l = vnode.children.length; i < l; i++) {
+              var child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
   }
-
   // ref #5318
   // necessary to ensure parent re-render when deep bindings like :style and
   // :class are used on slot nodes
-  function registerDeepBindings (data) {
-    if (isObject(data.style)) {
-      traverse(data.style);
-    }
-    if (isObject(data.class)) {
-      traverse(data.class);
-    }
-  }
-
-  /*  */
-
-  function initRender (vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
-
-    /* istanbul ignore else */
-    {
-      defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-        !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-      }, true);
-      defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-        !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-      }, true);
-    }
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
+  }
+
+  /* @flow */
+  function initRender(vm) {
+      vm._vnode = null; // the root of the child tree
+      vm._staticTrees = null; // v-once cached trees
+      var options = vm.$options;
+      var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      var renderContext = parentVnode && parentVnode.context;
+      vm.$slots = resolveSlots(options._renderChildren, renderContext);
+      vm.$scopedSlots = emptyObject;
+      // bind the createElement fn to this instance
+      // so that we get proper render context inside it.
+      // args order: tag, data, children, normalizationType, alwaysNormalize
+      // internal version is used by render functions compiled from templates
+      // @ts-expect-error
+      vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+      // normalization is always applied for the public version, used in
+      // user-written render functions.
+      // @ts-expect-error
+      vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+      // $attrs & $listeners are exposed for easier HOC creation.
+      // they need to be reactive so that HOCs using them are always updated
+      var parentData = parentVnode && parentVnode.data;
+      /* istanbul ignore else */
+      {
+          defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+              !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+          }, true);
+          defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+              !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+          }, true);
+      }
   }
-
   var currentRenderingInstance = null;
-
-  function renderMixin (Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-
-    Vue.prototype.$nextTick = function (fn) {
-      return nextTick(fn, this)
-    };
-
-    Vue.prototype._render = function () {
-      var vm = this;
-      var ref = vm.$options;
-      var render = ref.render;
-      var _parentVnode = ref._parentVnode;
-
-      if (_parentVnode) {
-        vm.$scopedSlots = normalizeScopedSlots(
-          _parentVnode.data.scopedSlots,
-          vm.$slots,
-          vm.$scopedSlots
-        );
-      }
-
-      // set parent vnode. this allows render functions to have access
-      // to the data on the placeholder node.
-      vm.$vnode = _parentVnode;
-      // render self
-      var vnode;
-      try {
-        // There's no need to maintain a stack because all render fns are called
-        // separately from one another. Nested component's render fns are called
-        // when parent component is patched.
-        currentRenderingInstance = vm;
-        vnode = render.call(vm._renderProxy, vm.$createElement);
-      } catch (e) {
-        handleError(e, vm, "render");
-        // return error render result,
-        // or previous vnode to prevent render error causing blank component
-        /* istanbul ignore else */
-        if (vm.$options.renderError) {
-          try {
-            vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-          } catch (e) {
-            handleError(e, vm, "renderError");
-            vnode = vm._vnode;
-          }
-        } else {
-          vnode = vm._vnode;
-        }
-      } finally {
-        currentRenderingInstance = null;
-      }
-      // if the returned array contains only a single node, allow it
-      if (Array.isArray(vnode) && vnode.length === 1) {
-        vnode = vnode[0];
-      }
-      // return empty vnode in case the render function errored out
-      if (!(vnode instanceof VNode)) {
-        if (Array.isArray(vnode)) {
-          warn(
-            'Multiple root nodes returned from render function. Render function ' +
-            'should return a single root node.',
-            vm
-          );
-        }
-        vnode = createEmptyVNode();
-      }
-      // set parent
-      vnode.parent = _parentVnode;
-      return vnode
-    };
-  }
-
-  /*  */
-
-  function ensureCtor (comp, base) {
-    if (
-      comp.__esModule ||
-      (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-    ) {
-      comp = comp.default;
-    }
-    return isObject(comp)
-      ? base.extend(comp)
-      : comp
-  }
-
-  function createAsyncPlaceholder (
-    factory,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    var node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-    return node
-  }
-
-  function resolveAsyncComponent (
-    factory,
-    baseCtor
-  ) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-      return factory.errorComp
-    }
-
-    if (isDef(factory.resolved)) {
-      return factory.resolved
-    }
-
-    var owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-      // already pending
-      factory.owners.push(owner);
-    }
-
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-      return factory.loadingComp
-    }
-
-    if (owner && !isDef(factory.owners)) {
-      var owners = factory.owners = [owner];
-      var sync = true;
-      var timerLoading = null;
-      var timerTimeout = null
-
-      ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-      var forceRender = function (renderCompleted) {
-        for (var i = 0, l = owners.length; i < l; i++) {
-          (owners[i]).$forceUpdate();
-        }
-
-        if (renderCompleted) {
-          owners.length = 0;
-          if (timerLoading !== null) {
-            clearTimeout(timerLoading);
-            timerLoading = null;
-          }
-          if (timerTimeout !== null) {
-            clearTimeout(timerTimeout);
-            timerTimeout = null;
-          }
-        }
+  function renderMixin(Vue) {
+      // install runtime convenience helpers
+      installRenderHelpers(Vue.prototype);
+      Vue.prototype.$nextTick = function (fn) {
+          return nextTick(fn, this);
       };
-
-      var resolve = once(function (res) {
-        // cache resolved
-        factory.resolved = ensureCtor(res, baseCtor);
-        // invoke callbacks only if this is not a synchronous resolve
-        // (async resolves are shimmed as synchronous during SSR)
-        if (!sync) {
-          forceRender(true);
-        } else {
-          owners.length = 0;
-        }
-      });
-
-      var reject = once(function (reason) {
-        warn(
-          "Failed to resolve async component: " + (String(factory)) +
-          (reason ? ("\nReason: " + reason) : '')
-        );
-        if (isDef(factory.errorComp)) {
-          factory.error = true;
-          forceRender(true);
-        }
-      });
-
-      var res = factory(resolve, reject);
-
-      if (isObject(res)) {
-        if (isPromise(res)) {
-          // () => Promise
-          if (isUndef(factory.resolved)) {
-            res.then(resolve, reject);
+      Vue.prototype._render = function () {
+          var vm = this;
+          var ref = vm.$options;
+          var render = ref.render;
+          var _parentVnode = ref._parentVnode;
+          if (_parentVnode) {
+              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
-        } else if (isPromise(res.component)) {
-          res.component.then(resolve, reject);
-
-          if (isDef(res.error)) {
-            factory.errorComp = ensureCtor(res.error, baseCtor);
+          // set parent vnode. this allows render functions to have access
+          // to the data on the placeholder node.
+          vm.$vnode = _parentVnode;
+          // render self
+          var vnode;
+          try {
+              // There's no need to maintain a stack because all render fns are called
+              // separately from one another. Nested component's render fns are called
+              // when parent component is patched.
+              currentRenderingInstance = vm;
+              vnode = render.call(vm._renderProxy, vm.$createElement);
           }
-
-          if (isDef(res.loading)) {
-            factory.loadingComp = ensureCtor(res.loading, baseCtor);
-            if (res.delay === 0) {
-              factory.loading = true;
-            } else {
-              timerLoading = setTimeout(function () {
-                timerLoading = null;
-                if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                  factory.loading = true;
-                  forceRender(false);
-                }
-              }, res.delay || 200);
-            }
+          catch (e) {
+              handleError(e, vm, "render");
+              // return error render result,
+              // or previous vnode to prevent render error causing blank component
+              /* istanbul ignore else */
+              if (vm.$options.renderError) {
+                  try {
+                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                  }
+                  catch (e) {
+                      handleError(e, vm, "renderError");
+                      vnode = vm._vnode;
+                  }
+              }
+              else {
+                  vnode = vm._vnode;
+              }
           }
-
-          if (isDef(res.timeout)) {
-            timerTimeout = setTimeout(function () {
-              timerTimeout = null;
-              if (isUndef(factory.resolved)) {
-                reject(
-                  "timeout (" + (res.timeout) + "ms)"
-                );
+          finally {
+              currentRenderingInstance = null;
+          }
+          // if the returned array contains only a single node, allow it
+          if (Array.isArray(vnode) && vnode.length === 1) {
+              vnode = vnode[0];
+          }
+          // return empty vnode in case the render function errored out
+          if (!(vnode instanceof VNode)) {
+              if (Array.isArray(vnode)) {
+                  warn('Multiple root nodes returned from render function. Render function ' +
+                      'should return a single root node.', vm);
               }
-            }, res.timeout);
+              vnode = createEmptyVNode();
           }
-        }
-      }
-
-      sync = false;
-      // return in case resolved synchronously
-      return factory.loading
-        ? factory.loadingComp
-        : factory.resolved
-    }
-  }
-
-  /*  */
-
-  function isAsyncPlaceholder (node) {
-    return node.isComment && node.asyncFactory
+          // set parent
+          vnode.parent = _parentVnode;
+          return vnode;
+      };
   }
 
-  /*  */
-
-  function getFirstComponentChild (children) {
-    if (Array.isArray(children)) {
-      for (var i = 0; i < children.length; i++) {
-        var c = children[i];
-        if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-          return c
-        }
+  /* @flow */
+  function ensureCtor(comp, base) {
+      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+          comp = comp.default;
       }
-    }
+      return isObject(comp) ? base.extend(comp) : comp;
   }
-
-  /*  */
-
-  /*  */
-
-  function initEvents (vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    var listeners = vm.$options._parentListeners;
-    if (listeners) {
-      updateComponentListeners(vm, listeners);
-    }
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      var node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+      return node;
   }
-
-  var target;
-
-  function add (event, fn) {
-    target.$on(event, fn);
-  }
-
-  function remove$1 (event, fn) {
-    target.$off(event, fn);
-  }
-
-  function createOnceHandler (event, fn) {
-    var _target = target;
-    return function onceHandler () {
-      var res = fn.apply(null, arguments);
-      if (res !== null) {
-        _target.$off(event, onceHandler);
-      }
-    }
-  }
-
-  function updateComponentListeners (
-    vm,
-    listeners,
-    oldListeners
-  ) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
-  }
-
-  function eventsMixin (Vue) {
-    var hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-      var vm = this;
-      if (Array.isArray(event)) {
-        for (var i = 0, l = event.length; i < l; i++) {
-          vm.$on(event[i], fn);
-        }
-      } else {
-        (vm._events[event] || (vm._events[event] = [])).push(fn);
-        // optimize hook:event cost by using a boolean flag marked at registration
-        // instead of a hash lookup
-        if (hookRE.test(event)) {
-          vm._hasHookEvent = true;
-        }
-      }
-      return vm
-    };
-
-    Vue.prototype.$once = function (event, fn) {
-      var vm = this;
-      function on () {
-        vm.$off(event, on);
-        fn.apply(vm, arguments);
-      }
-      on.fn = fn;
-      vm.$on(event, on);
-      return vm
-    };
-
-    Vue.prototype.$off = function (event, fn) {
-      var vm = this;
-      // all
-      if (!arguments.length) {
-        vm._events = Object.create(null);
-        return vm
-      }
-      // array of events
-      if (Array.isArray(event)) {
-        for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-          vm.$off(event[i$1], fn);
-        }
-        return vm
-      }
-      // specific event
-      var cbs = vm._events[event];
-      if (!cbs) {
-        return vm
-      }
-      if (!fn) {
-        vm._events[event] = null;
-        return vm
-      }
-      // specific handler
-      var cb;
-      var i = cbs.length;
-      while (i--) {
-        cb = cbs[i];
-        if (cb === fn || cb.fn === fn) {
-          cbs.splice(i, 1);
-          break
-        }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
       }
-      return vm
-    };
-
-    Vue.prototype.$emit = function (event) {
-      var vm = this;
-      {
-        var lowerCaseEvent = event.toLowerCase();
-        if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-          tip(
-            "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-            (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-            "Note that HTML attributes are case-insensitive and you cannot use " +
-            "v-on to listen to camelCase events when using in-DOM templates. " +
-            "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-          );
-        }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
       }
-      var cbs = vm._events[event];
-      if (cbs) {
-        cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-        var args = toArray(arguments, 1);
-        var info = "event handler for \"" + event + "\"";
-        for (var i = 0, l = cbs.length; i < l; i++) {
-          invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-        }
+      var owner = currentRenderingInstance;
+      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+          // already pending
+          factory.owners.push(owner);
       }
-      return vm
-    };
-  }
-
-  /*  */
-
-  var activeInstance = null;
-  var isUpdatingChildComponent = false;
-
-  function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return function () {
-      activeInstance = prevActiveInstance;
-    }
-  }
-
-  function initLifecycle (vm) {
-    var options = vm.$options;
-
-    // locate first non-abstract parent
-    var parent = options.parent;
-    if (parent && !options.abstract) {
-      while (parent.$options.abstract && parent.$parent) {
-        parent = parent.$parent;
-      }
-      parent.$children.push(vm);
-    }
-
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-
-    vm.$children = [];
-    vm.$refs = {};
-
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-  }
-
-  function lifecycleMixin (Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-      var vm = this;
-      var prevEl = vm.$el;
-      var prevVnode = vm._vnode;
-      var restoreActiveInstance = setActiveInstance(vm);
-      vm._vnode = vnode;
-      // Vue.prototype.__patch__ is injected in entry points
-      // based on the rendering backend used.
-      if (!prevVnode) {
-        // initial render
-        vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-      } else {
-        // updates
-        vm.$el = vm.__patch__(prevVnode, vnode);
-      }
-      restoreActiveInstance();
-      // update __vue__ reference
-      if (prevEl) {
-        prevEl.__vue__ = null;
-      }
-      if (vm.$el) {
-        vm.$el.__vue__ = vm;
-      }
-      // if parent is an HOC, update its $el as well
-      if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-        vm.$parent.$el = vm.$el;
-      }
-      // updated hook is called by the scheduler to ensure that children are
-      // updated in a parent's updated hook.
-    };
-
-    Vue.prototype.$forceUpdate = function () {
-      var vm = this;
-      if (vm._watcher) {
-        vm._watcher.update();
-      }
-    };
-
-    Vue.prototype.$destroy = function () {
-      var vm = this;
-      if (vm._isBeingDestroyed) {
-        return
-      }
-      callHook(vm, 'beforeDestroy');
-      vm._isBeingDestroyed = true;
-      // remove self from parent
-      var parent = vm.$parent;
-      if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-        remove(parent.$children, vm);
-      }
-      // teardown watchers
-      if (vm._watcher) {
-        vm._watcher.teardown();
-      }
-      var i = vm._watchers.length;
-      while (i--) {
-        vm._watchers[i].teardown();
-      }
-      // remove reference from data ob
-      // frozen object may not have observer.
-      if (vm._data.__ob__) {
-        vm._data.__ob__.vmCount--;
-      }
-      // call the last hook...
-      vm._isDestroyed = true;
-      // invoke destroy hooks on current rendered tree
-      vm.__patch__(vm._vnode, null);
-      // fire destroyed hook
-      callHook(vm, 'destroyed');
-      // turn off all instance listeners.
-      vm.$off();
-      // remove __vue__ reference
-      if (vm.$el) {
-        vm.$el.__vue__ = null;
-      }
-      // release circular reference (#6759)
-      if (vm.$vnode) {
-        vm.$vnode.parent = null;
-      }
-    };
-  }
-
-  function mountComponent (
-    vm,
-    el,
-    hydrating
-  ) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-      vm.$options.render = createEmptyVNode;
-      {
-        /* istanbul ignore if */
-        if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-          vm.$options.el || el) {
-          warn(
-            'You are using the runtime-only build of Vue where the template ' +
-            'compiler is not available. Either pre-compile the templates into ' +
-            'render functions, or use the compiler-included build.',
-            vm
-          );
-        } else {
-          warn(
-            'Failed to mount component: template or render function not defined.',
-            vm
-          );
-        }
-      }
-    }
-    callHook(vm, 'beforeMount');
-
-    var updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      updateComponent = function () {
-        var name = vm._name;
-        var id = vm._uid;
-        var startTag = "vue-perf-start:" + id;
-        var endTag = "vue-perf-end:" + id;
-
-        mark(startTag);
-        var vnode = vm._render();
-        mark(endTag);
-        measure(("vue " + name + " render"), startTag, endTag);
-
-        mark(startTag);
-        vm._update(vnode, hydrating);
-        mark(endTag);
-        measure(("vue " + name + " patch"), startTag, endTag);
-      };
-    } else {
-      updateComponent = function () {
-        vm._update(vm._render(), hydrating);
-      };
-    }
-
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-      before: function before () {
-        if (vm._isMounted && !vm._isDestroyed) {
-          callHook(vm, 'beforeUpdate');
-        }
-      }
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-      vm._isMounted = true;
-      callHook(vm, 'mounted');
-    }
-    return vm
-  }
-
-  function updateChildComponent (
-    vm,
-    propsData,
-    listeners,
-    parentVnode,
-    renderChildren
-  ) {
-    {
-      isUpdatingChildComponent = true;
-    }
-
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!(
-      (newScopedSlots && !newScopedSlots.$stable) ||
-      (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-      (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-    );
-
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(
-      renderChildren ||               // has new static slots
-      vm.$options._renderChildren ||  // has old static slots
-      hasDynamicScopedSlot
-    );
-
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-    if (vm._vnode) { // update child tree's parent
-      vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-
-    // update props
-    if (propsData && vm.$options.props) {
-      toggleObserving(false);
-      var props = vm._props;
-      var propKeys = vm.$options._propKeys || [];
-      for (var i = 0; i < propKeys.length; i++) {
-        var key = propKeys[i];
-        var propOptions = vm.$options.props; // wtf flow?
-        props[key] = validateProp(key, propOptions, propsData, vm);
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+      if (owner && !isDef(factory.owners)) {
+          var owners = (factory.owners = [owner]);
+          var sync = true;
+          var timerLoading = null;
+          var timerTimeout = null;
+          owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+          var forceRender = function (renderCompleted) {
+              for (var i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
+              }
+              if (renderCompleted) {
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
+                  }
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
+                  }
+              }
+          };
+          var resolve = once(function (res) {
+              // cache resolved
+              factory.resolved = ensureCtor(res, baseCtor);
+              // invoke callbacks only if this is not a synchronous resolve
+              // (async resolves are shimmed as synchronous during SSR)
+              if (!sync) {
+                  forceRender(true);
+              }
+              else {
+                  owners.length = 0;
+              }
+          });
+          var reject = once(function (reason) {
+              warn("Failed to resolve async component: " + (String(factory)) +
+                      (reason ? ("\nReason: " + reason) : ''));
+              if (isDef(factory.errorComp)) {
+                  factory.error = true;
+                  forceRender(true);
+              }
+          });
+          var res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
+                  // () => Promise
+                  if (isUndef(factory.resolved)) {
+                      res.then(resolve, reject);
+                  }
+              }
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
+                  }
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
+                          factory.loading = true;
+                      }
+                      else {
+                          // @ts-expect-error NodeJS timeout type
+                          timerLoading = setTimeout(function () {
+                              timerLoading = null;
+                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                  factory.loading = true;
+                                  forceRender(false);
+                              }
+                          }, res.delay || 200);
+                      }
+                  }
+                  if (isDef(res.timeout)) {
+                      // @ts-expect-error NodeJS timeout type
+                      timerTimeout = setTimeout(function () {
+                          timerTimeout = null;
+                          if (isUndef(factory.resolved)) {
+                              reject("timeout (" + (res.timeout) + "ms)");
+                          }
+                      }, res.timeout);
+                  }
+              }
+          }
+          sync = false;
+          // return in case resolved synchronously
+          return factory.loading ? factory.loadingComp : factory.resolved;
       }
-      toggleObserving(true);
-      // keep a copy of raw propsData
-      vm.$options.propsData = propsData;
-    }
-
-    // update listeners
-    listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-      vm.$forceUpdate();
-    }
-
-    {
-      isUpdatingChildComponent = false;
-    }
   }
 
-  function isInInactiveTree (vm) {
-    while (vm && (vm = vm.$parent)) {
-      if (vm._inactive) { return true }
-    }
-    return false
+  /* @flow */
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
   }
 
-  function activateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = false;
-      if (isInInactiveTree(vm)) {
-        return
-      }
-    } else if (vm._directInactive) {
-      return
-    }
-    if (vm._inactive || vm._inactive === null) {
-      vm._inactive = false;
-      for (var i = 0; i < vm.$children.length; i++) {
-        activateChildComponent(vm.$children[i]);
+  /* @flow */
+  function getFirstComponentChild(children) {
+      if (Array.isArray(children)) {
+          for (var i = 0; i < children.length; i++) {
+              var c = children[i];
+              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                  return c;
+              }
+          }
       }
-      callHook(vm, 'activated');
-    }
   }
 
-  function deactivateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = true;
-      if (isInInactiveTree(vm)) {
-        return
-      }
-    }
-    if (!vm._inactive) {
-      vm._inactive = true;
-      for (var i = 0; i < vm.$children.length; i++) {
-        deactivateChildComponent(vm.$children[i]);
-      }
-      callHook(vm, 'deactivated');
-    }
-  }
+  /* @flow */
 
-  function callHook (vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
-    if (handlers) {
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+  /* @flow */
+  function initEvents(vm) {
+      vm._events = Object.create(null);
+      vm._hasHookEvent = false;
+      // init parent attached events
+      var listeners = vm.$options._parentListeners;
+      if (listeners) {
+          updateComponentListeners(vm, listeners);
       }
-    }
-    if (vm._hasHookEvent) {
-      vm.$emit('hook:' + hook);
-    }
-    popTarget();
   }
-
-  /*  */
-
-  var MAX_UPDATE_COUNT = 100;
-
-  var queue = [];
-  var activatedChildren = [];
-  var has = {};
-  var circular = {};
-  var waiting = false;
-  var flushing = false;
-  var index = 0;
-
-  /**
-   * Reset the scheduler's state.
-   */
-  function resetSchedulerState () {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-      circular = {};
-    }
-    waiting = flushing = false;
+  var target;
+  function add(event, fn) {
+      target.$on(event, fn);
+  }
+  function remove$1(event, fn) {
+      target.$off(event, fn);
+  }
+  function createOnceHandler(event, fn) {
+      var _target = target;
+      return function onceHandler() {
+          var res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
   }
-
-  // Async edge case #6566 requires saving the timestamp when event listeners are
-  // attached. However, calling performance.now() has a perf overhead especially
-  // if the page has thousands of event listeners. Instead, we take a timestamp
-  // every time the scheduler flushes and use that for all event listeners
-  // attached during that flush.
-  var currentFlushTimestamp = 0;
-
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  var getNow = Date.now;
-
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (
-      performance &&
-      typeof performance.now === 'function' &&
-      getNow() > document.createEvent('Event').timeStamp
-    ) {
-      // if the event timestamp, although evaluated AFTER the Date.now(), is
-      // smaller than it, it means the event is using a hi-res timestamp,
-      // and we need to use the hi-res version for event listener timestamps as
-      // well.
-      getNow = function () { return performance.now(); };
-    }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target = vm;
+      updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+      target = undefined;
+  }
+  function eventsMixin(Vue) {
+      var hookRE = /^hook:/;
+      Vue.prototype.$on = function (event, fn) {
+          var vm = this;
+          if (Array.isArray(event)) {
+              for (var i = 0, l = event.length; i < l; i++) {
+                  vm.$on(event[i], fn);
+              }
+          }
+          else {
+              (vm._events[event] || (vm._events[event] = [])).push(fn);
+              // optimize hook:event cost by using a boolean flag marked at registration
+              // instead of a hash lookup
+              if (hookRE.test(event)) {
+                  vm._hasHookEvent = true;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$once = function (event, fn) {
+          var vm = this;
+          function on() {
+              vm.$off(event, on);
+              fn.apply(vm, arguments);
+          }
+          on.fn = fn;
+          vm.$on(event, on);
+          return vm;
+      };
+      Vue.prototype.$off = function (event, fn) {
+          var vm = this;
+          // all
+          if (!arguments.length) {
+              vm._events = Object.create(null);
+              return vm;
+          }
+          // array of events
+          if (Array.isArray(event)) {
+              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                  vm.$off(event[i$1], fn);
+              }
+              return vm;
+          }
+          // specific event
+          var cbs = vm._events[event];
+          if (!cbs) {
+              return vm;
+          }
+          if (!fn) {
+              vm._events[event] = null;
+              return vm;
+          }
+          // specific handler
+          var cb;
+          var i = cbs.length;
+          while (i--) {
+              cb = cbs[i];
+              if (cb === fn || cb.fn === fn) {
+                  cbs.splice(i, 1);
+                  break;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$emit = function (event) {
+          var vm = this;
+          {
+              var lowerCaseEvent = event.toLowerCase();
+              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                  tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                      "Note that HTML attributes are case-insensitive and you cannot use " +
+                      "v-on to listen to camelCase events when using in-DOM templates. " +
+                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+              }
+          }
+          var cbs = vm._events[event];
+          if (cbs) {
+              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+              var args = toArray(arguments, 1);
+              var info = "event handler for \"" + event + "\"";
+              for (var i = 0, l = cbs.length; i < l; i++) {
+                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+              }
+          }
+          return vm;
+      };
+  }
+
+  /* @flow */
+  var activeInstance = null;
+  var isUpdatingChildComponent = false;
+  function setActiveInstance(vm) {
+      var prevActiveInstance = activeInstance;
+      activeInstance = vm;
+      return function () {
+          activeInstance = prevActiveInstance;
+      };
+  }
+  function initLifecycle(vm) {
+      var options = vm.$options;
+      // locate first non-abstract parent
+      var parent = options.parent;
+      if (parent && !options.abstract) {
+          while (parent.$options.abstract && parent.$parent) {
+              parent = parent.$parent;
+          }
+          parent.$children.push(vm);
+      }
+      vm.$parent = parent;
+      vm.$root = parent ? parent.$root : vm;
+      vm.$children = [];
+      vm.$refs = {};
+      // @ts-ignore
+      vm._watcher = null;
+      vm._inactive = null;
+      vm._directInactive = false;
+      vm._isMounted = false;
+      vm._isDestroyed = false;
+      vm._isBeingDestroyed = false;
+  }
+  function lifecycleMixin(Vue) {
+      Vue.prototype._update = function (vnode, hydrating) {
+          var vm = this;
+          var prevEl = vm.$el;
+          var prevVnode = vm._vnode;
+          var restoreActiveInstance = setActiveInstance(vm);
+          vm._vnode = vnode;
+          // Vue.prototype.__patch__ is injected in entry points
+          // based on the rendering backend used.
+          if (!prevVnode) {
+              // initial render
+              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+          }
+          else {
+              // updates
+              vm.$el = vm.__patch__(prevVnode, vnode);
+          }
+          restoreActiveInstance();
+          // update __vue__ reference
+          if (prevEl) {
+              prevEl.__vue__ = null;
+          }
+          if (vm.$el) {
+              vm.$el.__vue__ = vm;
+          }
+          // if parent is an HOC, update its $el as well
+          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+              vm.$parent.$el = vm.$el;
+          }
+          // updated hook is called by the scheduler to ensure that children are
+          // updated in a parent's updated hook.
+      };
+      Vue.prototype.$forceUpdate = function () {
+          var vm = this;
+          if (vm._watcher) {
+              vm._watcher.update();
+          }
+      };
+      Vue.prototype.$destroy = function () {
+          var vm = this;
+          if (vm._isBeingDestroyed) {
+              return;
+          }
+          callHook(vm, 'beforeDestroy');
+          vm._isBeingDestroyed = true;
+          // remove self from parent
+          var parent = vm.$parent;
+          // @ts-ignore
+          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+              remove(parent.$children, vm);
+          }
+          // teardown watchers
+          if (vm._watcher) {
+              vm._watcher.teardown();
+          }
+          var i = vm._watchers.length;
+          while (i--) {
+              vm._watchers[i].teardown();
+          }
+          // remove reference from data ob
+          // frozen object may not have observer.
+          if (vm._data.__ob__) {
+              vm._data.__ob__.vmCount--;
+          }
+          // call the last hook...
+          vm._isDestroyed = true;
+          // invoke destroy hooks on current rendered tree
+          vm.__patch__(vm._vnode, null);
+          // fire destroyed hook
+          callHook(vm, 'destroyed');
+          // turn off all instance listeners.
+          vm.$off();
+          // remove __vue__ reference
+          if (vm.$el) {
+              vm.$el.__vue__ = null;
+          }
+          // release circular reference (#6759)
+          if (vm.$vnode) {
+              // @ts-expect-error null is not undefined
+              vm.$vnode.parent = null;
+          }
+      };
+  }
+  function mountComponent(vm, el, hydrating) {
+      vm.$el = el;
+      if (!vm.$options.render) {
+          // @ts-expect-error invalid type
+          vm.$options.render = createEmptyVNode;
+          {
+              /* istanbul ignore if */
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                  vm.$options.el ||
+                  el) {
+                  warn('You are using the runtime-only build of Vue where the template ' +
+                      'compiler is not available. Either pre-compile the templates into ' +
+                      'render functions, or use the compiler-included build.', vm);
+              }
+              else {
+                  warn('Failed to mount component: template or render function not defined.', vm);
+              }
+          }
+      }
+      callHook(vm, 'beforeMount');
+      var updateComponent;
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+          updateComponent = function () {
+              var name = vm._name;
+              var id = vm._uid;
+              var startTag = "vue-perf-start:" + id;
+              var endTag = "vue-perf-end:" + id;
+              mark(startTag);
+              var vnode = vm._render();
+              mark(endTag);
+              measure(("vue " + name + " render"), startTag, endTag);
+              mark(startTag);
+              vm._update(vnode, hydrating);
+              mark(endTag);
+              measure(("vue " + name + " patch"), startTag, endTag);
+          };
+      }
+      else {
+          updateComponent = function () {
+              vm._update(vm._render(), hydrating);
+          };
+      }
+      // we set this to vm._watcher inside the watcher's constructor
+      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+      // component's mounted hook), which relies on vm._watcher being already defined
+      new Watcher(vm, updateComponent, noop, {
+          before: function before() {
+              if (vm._isMounted && !vm._isDestroyed) {
+                  callHook(vm, 'beforeUpdate');
+              }
+          },
+      }, true /* isRenderWatcher */);
+      hydrating = false;
+      // manually mounted instance, call mounted on self
+      // mounted is called for render-created child components in its inserted hook
+      if (vm.$vnode == null) {
+          vm._isMounted = true;
+          callHook(vm, 'mounted');
+      }
+      return vm;
+  }
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      {
+          isUpdatingChildComponent = true;
+      }
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      var newScopedSlots = parentVnode.data.scopedSlots;
+      var oldScopedSlots = vm.$scopedSlots;
+      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      var needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      // @ts-ignore
+      vm.$options._parentVnode = parentVnode;
+      // @ts-ignore
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          // @ts-ignore
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      // @ts-ignore
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          var props = vm._props;
+          var propKeys = vm.$options._propKeys || [];
+          for (var i = 0; i < propKeys.length; i++) {
+              var key = propKeys[i];
+              var propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      var oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+      {
+          isUpdatingChildComponent = false;
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              { return true; }
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (var i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, 'activated');
+      }
+  }
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (var i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, 'deactivated');
+      }
+  }
+  function callHook(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      var handlers = vm.$options[hook];
+      var info = hook + " hook";
+      if (handlers) {
+          for (var i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit('hook:' + hook);
+      }
+      popTarget();
   }
 
+  /* @flow */
+  var MAX_UPDATE_COUNT = 100;
+  var queue = [];
+  var activatedChildren = [];
+  var has = {};
+  var circular = {};
+  var waiting = false;
+  var flushing = false;
+  var index = 0;
+  /**
+   * Reset the scheduler's state.
+   */
+  function resetSchedulerState() {
+      index = queue.length = activatedChildren.length = 0;
+      has = {};
+      {
+          circular = {};
+      }
+      waiting = flushing = false;
+  }
+  // Async edge case #6566 requires saving the timestamp when event listeners are
+  // attached. However, calling performance.now() has a perf overhead especially
+  // if the page has thousands of event listeners. Instead, we take a timestamp
+  // every time the scheduler flushes and use that for all event listeners
+  // attached during that flush.
+  var currentFlushTimestamp = 0;
+  // Async edge case fix requires storing an event listener's attach timestamp.
+  var getNow = Date.now;
+  // Determine what event timestamp the browser is using. Annoyingly, the
+  // timestamp can either be hi-res (relative to page load) or low-res
+  // (relative to UNIX epoch), so in order to compare time we have to use the
+  // same timestamp type when saving the flush timestamp.
+  // All IE versions use low-res event timestamps, and have problematic clock
+  // implementations (#9632)
+  if (inBrowser && !isIE) {
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = function () { return performance.now(); };
+      }
+  }
   /**
    * Flush both queues and run the watchers.
    */
-  function flushSchedulerQueue () {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    var watcher, id;
-
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
-
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-      watcher = queue[index];
-      if (watcher.before) {
-        watcher.before();
-      }
-      id = watcher.id;
-      has[id] = null;
-      watcher.run();
-      // in dev build, check and stop circular updates.
-      if (has[id] != null) {
-        circular[id] = (circular[id] || 0) + 1;
-        if (circular[id] > MAX_UPDATE_COUNT) {
-          warn(
-            'You may have an infinite update loop ' + (
-              watcher.user
-                ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                : "in a component render function."
-            ),
-            watcher.vm
-          );
-          break
-        }
+  function flushSchedulerQueue() {
+      currentFlushTimestamp = getNow();
+      flushing = true;
+      var watcher, id;
+      // Sort queue before flush.
+      // This ensures that:
+      // 1. Components are updated from parent to child. (because parent is always
+      //    created before the child)
+      // 2. A component's user watchers are run before its render watcher (because
+      //    user watchers are created before the render watcher)
+      // 3. If a component is destroyed during a parent component's watcher run,
+      //    its watchers can be skipped.
+      queue.sort(function (a, b) { return a.id - b.id; });
+      // do not cache length because more watchers might be pushed
+      // as we run existing watchers
+      for (index = 0; index < queue.length; index++) {
+          watcher = queue[index];
+          if (watcher.before) {
+              watcher.before();
+          }
+          id = watcher.id;
+          has[id] = null;
+          watcher.run();
+          // in dev build, check and stop circular updates.
+          if (has[id] != null) {
+              circular[id] = (circular[id] || 0) + 1;
+              if (circular[id] > MAX_UPDATE_COUNT) {
+                  warn('You may have an infinite update loop ' +
+                      (watcher.user
+                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                          : "in a component render function."), watcher.vm);
+                  break;
+              }
+          }
+      }
+      // keep copies of post queues before resetting state
+      var activatedQueue = activatedChildren.slice();
+      var updatedQueue = queue.slice();
+      resetSchedulerState();
+      // call component updated and activated hooks
+      callActivatedHooks(activatedQueue);
+      callUpdatedHooks(updatedQueue);
+      // devtool hook
+      /* istanbul ignore if */
+      if (devtools && config.devtools) {
+          devtools.emit('flush');
       }
-    }
-
-    // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
-
-    resetSchedulerState();
-
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-      devtools.emit('flush');
-    }
   }
-
-  function callUpdatedHooks (queue) {
-    var i = queue.length;
-    while (i--) {
-      var watcher = queue[i];
-      var vm = watcher.vm;
-      if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'updated');
+  function callUpdatedHooks(queue) {
+      var i = queue.length;
+      while (i--) {
+          var watcher = queue[i];
+          var vm = watcher.vm;
+          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+              callHook(vm, 'updated');
+          }
       }
-    }
   }
-
   /**
    * Queue a kept-alive component that was activated during patch.
    * The queue will be processed after the entire tree has been patched.
    */
-  function queueActivatedComponent (vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+      activatedChildren.push(vm);
   }
-
-  function callActivatedHooks (queue) {
-    for (var i = 0; i < queue.length; i++) {
-      queue[i]._inactive = true;
-      activateChildComponent(queue[i], true /* true */);
-    }
+  function callActivatedHooks(queue) {
+      for (var i = 0; i < queue.length; i++) {
+          queue[i]._inactive = true;
+          activateChildComponent(queue[i], true /* true */);
+      }
   }
-
   /**
    * Push a watcher into the watcher queue.
    * Jobs with duplicate IDs will be skipped unless it's
    * pushed when the queue is being flushed.
    */
-  function queueWatcher (watcher) {
-    var id = watcher.id;
-    if (has[id] == null) {
-      has[id] = true;
-      if (!flushing) {
-        queue.push(watcher);
-      } else {
-        // if already flushing, splice the watcher based on its id
-        // if already past its id, it will be run next immediately.
-        var i = queue.length - 1;
-        while (i > index && queue[i].id > watcher.id) {
-          i--;
-        }
-        queue.splice(i + 1, 0, watcher);
-      }
-      // queue the flush
-      if (!waiting) {
-        waiting = true;
-
-        if (!config.async) {
-          flushSchedulerQueue();
-          return
-        }
-        nextTick(flushSchedulerQueue);
+  function queueWatcher(watcher) {
+      var id = watcher.id;
+      if (has[id] == null) {
+          has[id] = true;
+          if (!flushing) {
+              queue.push(watcher);
+          }
+          else {
+              // if already flushing, splice the watcher based on its id
+              // if already past its id, it will be run next immediately.
+              var i = queue.length - 1;
+              while (i > index && queue[i].id > watcher.id) {
+                  i--;
+              }
+              queue.splice(i + 1, 0, watcher);
+          }
+          // queue the flush
+          if (!waiting) {
+              waiting = true;
+              if (!config.async) {
+                  flushSchedulerQueue();
+                  return;
+              }
+              nextTick(flushSchedulerQueue);
+          }
       }
-    }
   }
 
-  /*  */
-
-
-
+  /* @flow */
   var uid$2 = 0;
-
   /**
    * A watcher parses an expression, collects dependencies,
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = function Watcher (
-    vm,
-    expOrFn,
-    cb,
-    options,
-    isRenderWatcher
-  ) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-      vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-      this.deep = !!options.deep;
-      this.user = !!options.user;
-      this.lazy = !!options.lazy;
-      this.sync = !!options.sync;
-      this.before = options.before;
-    } else {
-      this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression = expOrFn.toString();
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-      this.getter = expOrFn;
-    } else {
-      this.getter = parsePath(expOrFn);
-      if (!this.getter) {
-        this.getter = noop;
-        warn(
-          "Failed watching path: \"" + expOrFn + "\" " +
-          'Watcher only accepts simple dot-delimited paths. ' +
-          'For full control, use a function instead.',
-          vm
-        );
-      }
-    }
-    this.value = this.lazy
-      ? undefined
-      : this.get();
+  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+      this.vm = vm;
+      if (isRenderWatcher) {
+          vm._watcher = this;
+      }
+      vm._watchers.push(this);
+      // options
+      if (options) {
+          this.deep = !!options.deep;
+          this.user = !!options.user;
+          this.lazy = !!options.lazy;
+          this.sync = !!options.sync;
+          this.before = options.before;
+      }
+      else {
+          this.deep = this.user = this.lazy = this.sync = false;
+      }
+      this.cb = cb;
+      this.id = ++uid$2; // uid for batching
+      this.active = true;
+      this.dirty = this.lazy; // for lazy watchers
+      this.deps = [];
+      this.newDeps = [];
+      this.depIds = new _Set();
+      this.newDepIds = new _Set();
+      this.expression =
+          expOrFn.toString();
+      // parse expression for getter
+      if (typeof expOrFn === 'function') {
+          this.getter = expOrFn;
+      }
+      else {
+          this.getter = parsePath(expOrFn);
+          if (!this.getter) {
+              this.getter = noop;
+              warn("Failed watching path: \"" + expOrFn + "\" " +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
+          }
+      }
+      this.value = this.lazy ? undefined : this.get();
   };
-
   /**
    * Evaluate the getter, and re-collect dependencies.
    */
   Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-      value = this.getter.call(vm, vm);
-    } catch (e) {
-      if (this.user) {
-        handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-      } else {
-        throw e
-      }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value);
+      pushTarget(this);
+      var value;
+      var vm = this.vm;
+      try {
+          value = this.getter.call(vm, vm);
       }
-      popTarget();
-      this.cleanupDeps();
-    }
-    return value
+      catch (e) {
+          if (this.user) {
+              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+          }
+          else {
+              throw e;
+          }
+      }
+      finally {
+          // "touch" every property so they are all tracked as
+          // dependencies for deep watching
+          if (this.deep) {
+              traverse(value);
+          }
+          popTarget();
+          this.cleanupDeps();
+      }
+      return value;
   };
-
   /**
    * Add a dependency to this directive.
    */
   Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id);
-      this.newDeps.push(dep);
-      if (!this.depIds.has(id)) {
-        dep.addSub(this);
-      }
-    }
+      var id = dep.id;
+      if (!this.newDepIds.has(id)) {
+          this.newDepIds.add(id);
+          this.newDeps.push(dep);
+          if (!this.depIds.has(id)) {
+              dep.addSub(this);
+          }
+      }
   };
-
   /**
    * Clean up for dependency collection.
    */
   Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-      var dep = this.deps[i];
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this);
-      }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
+      var i = this.deps.length;
+      while (i--) {
+          var dep = this.deps[i];
+          if (!this.newDepIds.has(dep.id)) {
+              dep.removeSub(this);
+          }
+      }
+      var tmp = this.depIds;
+      this.depIds = this.newDepIds;
+      this.newDepIds = tmp;
+      this.newDepIds.clear();
+      tmp = this.deps;
+      this.deps = this.newDeps;
+      this.newDeps = tmp;
+      this.newDeps.length = 0;
   };
-
   /**
    * Subscriber interface.
    * Will be called when a dependency changes.
    */
   Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-      this.dirty = true;
-    } else if (this.sync) {
-      this.run();
-    } else {
-      queueWatcher(this);
-    }
+      /* istanbul ignore else */
+      if (this.lazy) {
+          this.dirty = true;
+      }
+      else if (this.sync) {
+          this.run();
+      }
+      else {
+          queueWatcher(this);
+      }
   };
-
   /**
    * Scheduler job interface.
    * Will be called by the scheduler.
    */
   Watcher.prototype.run = function run () {
-    if (this.active) {
-      var value = this.get();
-      if (
-        value !== this.value ||
-        // Deep watchers and watchers on Object/Arrays should fire even
-        // when the value is the same, because the value may
-        // have mutated.
-        isObject(value) ||
-        this.deep
-      ) {
-        // set new value
-        var oldValue = this.value;
-        this.value = value;
-        if (this.user) {
-          try {
-            this.cb.call(this.vm, value, oldValue);
-          } catch (e) {
-            handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+      if (this.active) {
+          var value = this.get();
+          if (value !== this.value ||
+              // Deep watchers and watchers on Object/Arrays should fire even
+              // when the value is the same, because the value may
+              // have mutated.
+              isObject(value) ||
+              this.deep) {
+              // set new value
+              var oldValue = this.value;
+              this.value = value;
+              if (this.user) {
+                  try {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+                  catch (e) {
+                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  }
+              }
+              else {
+                  this.cb.call(this.vm, value, oldValue);
+              }
           }
-        } else {
-          this.cb.call(this.vm, value, oldValue);
-        }
       }
-    }
   };
-
   /**
    * Evaluate the value of the watcher.
    * This only gets called for lazy watchers.
    */
   Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
+      this.value = this.get();
+      this.dirty = false;
   };
-
   /**
    * Depend on all deps collected by this watcher.
    */
   Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].depend();
-    }
+      var i = this.deps.length;
+      while (i--) {
+          this.deps[i].depend();
+      }
   };
-
   /**
    * Remove self from all dependencies' subscriber list.
    */
   Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed.
-      if (!this.vm._isBeingDestroyed) {
-        remove(this.vm._watchers, this);
-      }
-      var i = this.deps.length;
-      while (i--) {
-        this.deps[i].removeSub(this);
+      if (this.active) {
+          // remove self from vm's watcher list
+          // this is a somewhat expensive operation so we skip it
+          // if the vm is being destroyed.
+          if (!this.vm._isBeingDestroyed) {
+              remove(this.vm._watchers, this);
+          }
+          var i = this.deps.length;
+          while (i--) {
+              this.deps[i].removeSub(this);
+          }
+          this.active = false;
       }
-      this.active = false;
-    }
   };
 
-  /*  */
-
+  /* @flow */
   var sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop
+      enumerable: true,
+      configurable: true,
+      get: noop,
+      set: noop,
   };
+  function proxy(target, sourceKey, key) {
+      sharedPropertyDefinition.get = function proxyGetter() {
+          return this[sourceKey][key];
+      };
+      sharedPropertyDefinition.set = function proxySetter(val) {
+          this[sourceKey][key] = val;
+      };
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function initState(vm) {
+      vm._watchers = [];
+      var opts = vm.$options;
+      if (opts.props)
+          { initProps(vm, opts.props); }
+      if (opts.methods)
+          { initMethods(vm, opts.methods); }
+      if (opts.data) {
+          initData(vm);
+      }
+      else {
+          observe((vm._data = {}), true /* asRootData */);
+      }
+      if (opts.computed)
+          { initComputed(vm, opts.computed); }
+      if (opts.watch && opts.watch !== nativeWatch) {
+          initWatch(vm, opts.watch);
+      }
+  }
+  function initProps(vm, propsOptions) {
+      var propsData = vm.$options.propsData || {};
+      var props = (vm._props = {});
+      // cache prop keys so that future props updates can iterate using Array
+      // instead of dynamic object key enumeration.
+      var keys = (vm.$options._propKeys = []);
+      var isRoot = !vm.$parent;
+      // root instance props should be converted
+      if (!isRoot) {
+          toggleObserving(false);
+      }
+      var loop = function ( key ) {
+          keys.push(key);
+          var value = validateProp(key, propsOptions, propsData, vm);
+          /* istanbul ignore else */
+          {
+              var hyphenatedKey = hyphenate(key);
+              if (isReservedAttribute(hyphenatedKey) ||
+                  config.isReservedAttr(hyphenatedKey)) {
+                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+              }
+              defineReactive$$1(props, key, value, function () {
+                  if (!isRoot && !isUpdatingChildComponent) {
+                      warn("Avoid mutating a prop directly since the value will be " +
+                          "overwritten whenever the parent component re-renders. " +
+                          "Instead, use a data or computed property based on the prop's " +
+                          "value. Prop being mutated: \"" + key + "\"", vm);
+                  }
+              });
+          }
+          // static props are already proxied on the component's prototype
+          // during Vue.extend(). We only need to proxy props defined at
+          // instantiation here.
+          if (!(key in vm)) {
+              proxy(vm, "_props", key);
+          }
+      };
 
-  function proxy (target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter () {
-      return this[sourceKey][key]
-    };
-    sharedPropertyDefinition.set = function proxySetter (val) {
-      this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-
-  function initState (vm) {
-    vm._watchers = [];
-    var opts = vm.$options;
-    if (opts.props) { initProps(vm, opts.props); }
-    if (opts.methods) { initMethods(vm, opts.methods); }
-    if (opts.data) {
-      initData(vm);
-    } else {
-      observe(vm._data = {}, true /* asRootData */);
-    }
-    if (opts.computed) { initComputed(vm, opts.computed); }
-    if (opts.watch && opts.watch !== nativeWatch) {
-      initWatch(vm, opts.watch);
-    }
-  }
-
-  function initProps (vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = vm._props = {};
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    var keys = vm.$options._propKeys = [];
-    var isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-      toggleObserving(false);
-    }
-    var loop = function ( key ) {
-      keys.push(key);
-      var value = validateProp(key, propsOptions, propsData, vm);
-      /* istanbul ignore else */
-      {
-        var hyphenatedKey = hyphenate(key);
-        if (isReservedAttribute(hyphenatedKey) ||
-            config.isReservedAttr(hyphenatedKey)) {
-          warn(
-            ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-            vm
-          );
-        }
-        defineReactive$$1(props, key, value, function () {
-          if (!isRoot && !isUpdatingChildComponent) {
-            warn(
-              "Avoid mutating a prop directly since the value will be " +
-              "overwritten whenever the parent component re-renders. " +
-              "Instead, use a data or computed property based on the prop's " +
-              "value. Prop being mutated: \"" + key + "\"",
-              vm
-            );
-          }
-        });
-      }
-      // static props are already proxied on the component's prototype
-      // during Vue.extend(). We only need to proxy props defined at
-      // instantiation here.
-      if (!(key in vm)) {
-        proxy(vm, "_props", key);
-      }
-    };
-
-    for (var key in propsOptions) loop( key );
-    toggleObserving(true);
-  }
-
-  function initData (vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function'
-      ? getData(data, vm)
-      : data || {};
-    if (!isPlainObject(data)) {
-      data = {};
-      warn(
-        'data functions should return an object:\n' +
-        'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-        vm
-      );
-    }
-    // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
-    while (i--) {
-      var key = keys[i];
-      {
-        if (methods && hasOwn(methods, key)) {
-          warn(
-            ("Method \"" + key + "\" has already been defined as a data property."),
-            vm
-          );
-        }
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          "The data property \"" + key + "\" is already declared as a prop. " +
-          "Use prop default value instead.",
-          vm
-        );
-      } else if (!isReserved(key)) {
-        proxy(vm, "_data", key);
-      }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-  }
-
-  function getData (data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-      return data.call(vm, vm)
-    } catch (e) {
-      handleError(e, vm, "data()");
-      return {}
-    } finally {
-      popTarget();
-    }
+      for (var key in propsOptions) loop( key );
+      toggleObserving(true);
   }
-
-  var computedWatcherOptions = { lazy: true };
-
-  function initComputed (vm, computed) {
-    // $flow-disable-line
-    var watchers = vm._computedWatchers = Object.create(null);
-    // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-
-    for (var key in computed) {
-      var userDef = computed[key];
-      var getter = typeof userDef === 'function' ? userDef : userDef.get;
-      if (getter == null) {
-        warn(
-          ("Getter is missing for computed property \"" + key + "\"."),
-          vm
-        );
-      }
-
-      if (!isSSR) {
-        // create internal watcher for the computed property.
-        watchers[key] = new Watcher(
-          vm,
-          getter || noop,
-          noop,
-          computedWatcherOptions
-        );
-      }
-
-      // component-defined computed properties are already defined on the
-      // component prototype. We only need to define computed properties defined
-      // at instantiation here.
-      if (!(key in vm)) {
-        defineComputed(vm, key, userDef);
-      } else {
-        if (key in vm.$data) {
-          warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-        } else if (vm.$options.props && key in vm.$options.props) {
-          warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-        }
-      }
-    }
-  }
-
-  function defineComputed (
-    target,
-    key,
-    userDef
-  ) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
-      sharedPropertyDefinition.get = shouldCache
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef);
-      sharedPropertyDefinition.set = noop;
-    } else {
-      sharedPropertyDefinition.get = userDef.get
-        ? shouldCache && userDef.cache !== false
-          ? createComputedGetter(key)
-          : createGetterInvoker(userDef.get)
-        : noop;
-      sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-      sharedPropertyDefinition.set = function () {
-        warn(
-          ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-          this
-        );
-      };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
+  function initData(vm) {
+      var data = vm.$options.data;
+      data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+      if (!isPlainObject(data)) {
+          data = {};
+          warn('data functions should return an object:\n' +
+                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+      }
+      // proxy data on instance
+      var keys = Object.keys(data);
+      var props = vm.$options.props;
+      var methods = vm.$options.methods;
+      var i = keys.length;
+      while (i--) {
+          var key = keys[i];
+          {
+              if (methods && hasOwn(methods, key)) {
+                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+              }
+          }
+          if (props && hasOwn(props, key)) {
+              warn("The data property \"" + key + "\" is already declared as a prop. " +
+                      "Use prop default value instead.", vm);
+          }
+          else if (!isReserved(key)) {
+              proxy(vm, "_data", key);
+          }
+      }
+      // observe data
+      observe(data, true /* asRootData */);
   }
-
-  function createComputedGetter (key) {
-    return function computedGetter () {
-      var watcher = this._computedWatchers && this._computedWatchers[key];
-      if (watcher) {
-        if (watcher.dirty) {
-          watcher.evaluate();
-        }
-        if (Dep.target) {
-          watcher.depend();
-        }
-        return watcher.value
+  function getData(data, vm) {
+      // #7573 disable dep collection when invoking data getters
+      pushTarget();
+      try {
+          return data.call(vm, vm);
+      }
+      catch (e) {
+          handleError(e, vm, "data()");
+          return {};
+      }
+      finally {
+          popTarget();
       }
-    }
   }
-
-  function createGetterInvoker(fn) {
-    return function computedGetter () {
-      return fn.call(this, this)
-    }
+  var computedWatcherOptions = { lazy: true };
+  function initComputed(vm, computed) {
+      // $flow-disable-line
+      var watchers = (vm._computedWatchers = Object.create(null));
+      // computed properties are just getters during SSR
+      var isSSR = isServerRendering();
+      for (var key in computed) {
+          var userDef = computed[key];
+          var getter = typeof userDef === 'function' ? userDef : userDef.get;
+          if (getter == null) {
+              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+          }
+          if (!isSSR) {
+              // create internal watcher for the computed property.
+              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+          }
+          // component-defined computed properties are already defined on the
+          // component prototype. We only need to define computed properties defined
+          // at instantiation here.
+          if (!(key in vm)) {
+              defineComputed(vm, key, userDef);
+          }
+          else {
+              if (key in vm.$data) {
+                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+              }
+              else if (vm.$options.props && key in vm.$options.props) {
+                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+              }
+          }
+      }
   }
-
-  function initMethods (vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
-      {
-        if (typeof methods[key] !== 'function') {
-          warn(
-            "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-            "Did you reference the function correctly?",
-            vm
-          );
-        }
-        if (props && hasOwn(props, key)) {
-          warn(
-            ("Method \"" + key + "\" has already been defined as a prop."),
-            vm
-          );
-        }
-        if ((key in vm) && isReserved(key)) {
-          warn(
-            "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-            "Avoid defining component methods that start with _ or $."
-          );
-        }
+  function defineComputed(target, key, userDef) {
+      var shouldCache = !isServerRendering();
+      if (typeof userDef === 'function') {
+          sharedPropertyDefinition.get = shouldCache
+              ? createComputedGetter(key)
+              : createGetterInvoker(userDef);
+          sharedPropertyDefinition.set = noop;
+      }
+      else {
+          sharedPropertyDefinition.get = userDef.get
+              ? shouldCache && userDef.cache !== false
+                  ? createComputedGetter(key)
+                  : createGetterInvoker(userDef.get)
+              : noop;
+          sharedPropertyDefinition.set = userDef.set || noop;
+      }
+      if (sharedPropertyDefinition.set === noop) {
+          sharedPropertyDefinition.set = function () {
+              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+          };
       }
-      vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-    }
+      Object.defineProperty(target, key, sharedPropertyDefinition);
   }
-
-  function initWatch (vm, watch) {
-    for (var key in watch) {
-      var handler = watch[key];
-      if (Array.isArray(handler)) {
-        for (var i = 0; i < handler.length; i++) {
-          createWatcher(vm, key, handler[i]);
-        }
-      } else {
-        createWatcher(vm, key, handler);
-      }
-    }
-  }
-
-  function createWatcher (
-    vm,
-    expOrFn,
-    handler,
-    options
-  ) {
-    if (isPlainObject(handler)) {
-      options = handler;
-      handler = handler.handler;
-    }
-    if (typeof handler === 'string') {
-      handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options)
-  }
-
-  function stateMixin (Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    var dataDef = {};
-    dataDef.get = function () { return this._data };
-    var propsDef = {};
-    propsDef.get = function () { return this._props };
-    {
-      dataDef.set = function () {
-        warn(
-          'Avoid replacing instance root $data. ' +
-          'Use nested data properties instead.',
-          this
-        );
+  function createComputedGetter(key) {
+      return function computedGetter() {
+          var watcher = this._computedWatchers && this._computedWatchers[key];
+          if (watcher) {
+              if (watcher.dirty) {
+                  watcher.evaluate();
+              }
+              if (Dep.target) {
+                  watcher.depend();
+              }
+              return watcher.value;
+          }
       };
-      propsDef.set = function () {
-        warn("$props is readonly.", this);
+  }
+  function createGetterInvoker(fn) {
+      return function computedGetter() {
+          return fn.call(this, this);
       };
-    }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-
-    Vue.prototype.$watch = function (
-      expOrFn,
-      cb,
-      options
-    ) {
-      var vm = this;
-      if (isPlainObject(cb)) {
-        return createWatcher(vm, expOrFn, cb, options)
+  }
+  function initMethods(vm, methods) {
+      var props = vm.$options.props;
+      for (var key in methods) {
+          {
+              if (typeof methods[key] !== 'function') {
+                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                      "Did you reference the function correctly?", vm);
+              }
+              if (props && hasOwn(props, key)) {
+                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+              }
+              if (key in vm && isReserved(key)) {
+                  warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                      "Avoid defining component methods that start with _ or $.");
+              }
+          }
+          vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+      }
+  }
+  function initWatch(vm, watch) {
+      for (var key in watch) {
+          var handler = watch[key];
+          if (Array.isArray(handler)) {
+              for (var i = 0; i < handler.length; i++) {
+                  createWatcher(vm, key, handler[i]);
+              }
+          }
+          else {
+              createWatcher(vm, key, handler);
+          }
       }
-      options = options || {};
-      options.user = true;
-      var watcher = new Watcher(vm, expOrFn, cb, options);
-      if (options.immediate) {
-        try {
-          cb.call(vm, watcher.value);
-        } catch (error) {
-          handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-        }
+  }
+  function createWatcher(vm, expOrFn, handler, options) {
+      if (isPlainObject(handler)) {
+          options = handler;
+          handler = handler.handler;
       }
-      return function unwatchFn () {
-        watcher.teardown();
+      if (typeof handler === 'string') {
+          handler = vm[handler];
       }
-    };
+      return vm.$watch(expOrFn, handler, options);
+  }
+  function stateMixin(Vue) {
+      // flow somehow has problems with directly declared definition object
+      // when using Object.defineProperty, so we have to procedurally build up
+      // the object here.
+      var dataDef = {};
+      dataDef.get = function () {
+          return this._data;
+      };
+      var propsDef = {};
+      propsDef.get = function () {
+          return this._props;
+      };
+      {
+          dataDef.set = function () {
+              warn('Avoid replacing instance root $data. ' +
+                  'Use nested data properties instead.', this);
+          };
+          propsDef.set = function () {
+              warn("$props is readonly.", this);
+          };
+      }
+      Object.defineProperty(Vue.prototype, '$data', dataDef);
+      Object.defineProperty(Vue.prototype, '$props', propsDef);
+      Vue.prototype.$set = set;
+      Vue.prototype.$delete = del;
+      Vue.prototype.$watch = function (expOrFn, cb, options) {
+          var vm = this;
+          if (isPlainObject(cb)) {
+              return createWatcher(vm, expOrFn, cb, options);
+          }
+          options = options || {};
+          options.user = true;
+          var watcher = new Watcher(vm, expOrFn, cb, options);
+          if (options.immediate) {
+              pushTarget();
+              try {
+                  cb.call(vm, watcher.value);
+              }
+              catch (error) {
+                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+              }
+              popTarget();
+          }
+          return function unwatchFn() {
+              watcher.teardown();
+          };
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var uid$3 = 0;
-
-  function initMixin (Vue) {
-    Vue.prototype._init = function (options) {
-      var vm = this;
-      // a uid
-      vm._uid = uid$3++;
-
-      var startTag, endTag;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        startTag = "vue-perf-start:" + (vm._uid);
-        endTag = "vue-perf-end:" + (vm._uid);
-        mark(startTag);
-      }
-
-      // a flag to avoid this being observed
-      vm._isVue = true;
-      // merge options
-      if (options && options._isComponent) {
-        // optimize internal component instantiation
-        // since dynamic options merging is pretty slow, and none of the
-        // internal component options needs special treatment.
-        initInternalComponent(vm, options);
-      } else {
-        vm.$options = mergeOptions(
-          resolveConstructorOptions(vm.constructor),
-          options || {},
-          vm
-        );
+  function initMixin(Vue) {
+      Vue.prototype._init = function (options) {
+          var vm = this;
+          // a uid
+          vm._uid = uid$3++;
+          var startTag, endTag;
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              startTag = "vue-perf-start:" + (vm._uid);
+              endTag = "vue-perf-end:" + (vm._uid);
+              mark(startTag);
+          }
+          // a flag to avoid this being observed
+          vm._isVue = true;
+          // merge options
+          if (options && options._isComponent) {
+              // optimize internal component instantiation
+              // since dynamic options merging is pretty slow, and none of the
+              // internal component options needs special treatment.
+              initInternalComponent(vm, options);
+          }
+          else {
+              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+          }
+          /* istanbul ignore else */
+          {
+              initProxy(vm);
+          }
+          // expose real self
+          vm._self = vm;
+          initLifecycle(vm);
+          initEvents(vm);
+          initRender(vm);
+          callHook(vm, 'beforeCreate');
+          initInjections(vm); // resolve injections before data/props
+          initState(vm);
+          initProvide(vm); // resolve provide after data/props
+          callHook(vm, 'created');
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              vm._name = formatComponentName(vm, false);
+              mark(endTag);
+              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+          }
+          if (vm.$options.el) {
+              vm.$mount(vm.$options.el);
+          }
+      };
+  }
+  function initInternalComponent(vm, options) {
+      // @ts-ignore
+      var opts = (vm.$options = Object.create(vm.constructor.options));
+      // doing this because it's faster than dynamic enumeration.
+      var parentVnode = options._parentVnode;
+      opts.parent = options.parent;
+      opts._parentVnode = parentVnode;
+      var vnodeComponentOptions = parentVnode.componentOptions;
+      opts.propsData = vnodeComponentOptions.propsData;
+      opts._parentListeners = vnodeComponentOptions.listeners;
+      opts._renderChildren = vnodeComponentOptions.children;
+      opts._componentTag = vnodeComponentOptions.tag;
+      if (options.render) {
+          opts.render = options.render;
+          opts.staticRenderFns = options.staticRenderFns;
+      }
+  }
+  function resolveConstructorOptions(Ctor) {
+      var options = Ctor.options;
+      if (Ctor.super) {
+          var superOptions = resolveConstructorOptions(Ctor.super);
+          var cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              var modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
       }
-      /* istanbul ignore else */
-      {
-        initProxy(vm);
-      }
-      // expose real self
-      vm._self = vm;
-      initLifecycle(vm);
-      initEvents(vm);
-      initRender(vm);
-      callHook(vm, 'beforeCreate');
-      initInjections(vm); // resolve injections before data/props
-      initState(vm);
-      initProvide(vm); // resolve provide after data/props
-      callHook(vm, 'created');
-
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        vm._name = formatComponentName(vm, false);
-        mark(endTag);
-        measure(("vue " + (vm._name) + " init"), startTag, endTag);
-      }
-
-      if (vm.$options.el) {
-        vm.$mount(vm.$options.el);
-      }
-    };
-  }
-
-  function initInternalComponent (vm, options) {
-    var opts = vm.$options = Object.create(vm.constructor.options);
-    // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-
-    var vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-
-    if (options.render) {
-      opts.render = options.render;
-      opts.staticRenderFns = options.staticRenderFns;
-    }
-  }
-
-  function resolveConstructorOptions (Ctor) {
-    var options = Ctor.options;
-    if (Ctor.super) {
-      var superOptions = resolveConstructorOptions(Ctor.super);
-      var cachedSuperOptions = Ctor.superOptions;
-      if (superOptions !== cachedSuperOptions) {
-        // super option changed,
-        // need to resolve new options.
-        Ctor.superOptions = superOptions;
-        // check if there are any late-modified/attached options (#4976)
-        var modifiedOptions = resolveModifiedOptions(Ctor);
-        // update base extend options
-        if (modifiedOptions) {
-          extend(Ctor.extendOptions, modifiedOptions);
-        }
-        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-        if (options.name) {
-          options.components[options.name] = Ctor;
-        }
-      }
-    }
-    return options
-  }
-
-  function resolveModifiedOptions (Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
-      if (latest[key] !== sealed[key]) {
-        if (!modified) { modified = {}; }
-        modified[key] = latest[key];
-      }
-    }
-    return modified
-  }
-
-  function Vue (options) {
-    if (!(this instanceof Vue)
-    ) {
-      warn('Vue is a constructor and should be called with the `new` keyword');
-    }
-    this._init(options);
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      var modified;
+      var latest = Ctor.options;
+      var sealed = Ctor.sealedOptions;
+      for (var key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  { modified = {}; }
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
   }
 
+  function Vue(options) {
+      if (!(this instanceof Vue)) {
+          warn('Vue is a constructor and should be called with the `new` keyword');
+      }
+      this._init(options);
+  }
+  //@ts-ignore
   initMixin(Vue);
+  //@ts-ignore
   stateMixin(Vue);
+  //@ts-ignore
   eventsMixin(Vue);
+  //@ts-ignore
   lifecycleMixin(Vue);
+  //@ts-ignore
   renderMixin(Vue);
 
-  /*  */
-
-  function initUse (Vue) {
-    Vue.use = function (plugin) {
-      var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-      if (installedPlugins.indexOf(plugin) > -1) {
-        return this
-      }
-
-      // additional parameters
-      var args = toArray(arguments, 1);
-      args.unshift(this);
-      if (typeof plugin.install === 'function') {
-        plugin.install.apply(plugin, args);
-      } else if (typeof plugin === 'function') {
-        plugin.apply(null, args);
-      }
-      installedPlugins.push(plugin);
-      return this
-    };
-  }
-
-  /*  */
-
-  function initMixin$1 (Vue) {
-    Vue.mixin = function (mixin) {
-      this.options = mergeOptions(this.options, mixin);
-      return this
-    };
+  /* @flow */
+  function initUse(Vue) {
+      Vue.use = function (plugin) {
+          var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          if (installedPlugins.indexOf(plugin) > -1) {
+              return this;
+          }
+          // additional parameters
+          var args = toArray(arguments, 1);
+          args.unshift(this);
+          if (typeof plugin.install === 'function') {
+              plugin.install.apply(plugin, args);
+          }
+          else if (typeof plugin === 'function') {
+              plugin.apply(null, args);
+          }
+          installedPlugins.push(plugin);
+          return this;
+      };
   }
 
-  /*  */
-
-  function initExtend (Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    var cid = 1;
-
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-      extendOptions = extendOptions || {};
-      var Super = this;
-      var SuperId = Super.cid;
-      var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-      if (cachedCtors[SuperId]) {
-        return cachedCtors[SuperId]
-      }
-
-      var name = extendOptions.name || Super.options.name;
-      if (name) {
-        validateComponentName(name);
-      }
-
-      var Sub = function VueComponent (options) {
-        this._init(options);
+  /* @flow */
+  function initMixin$1(Vue) {
+      Vue.mixin = function (mixin) {
+          this.options = mergeOptions(this.options, mixin);
+          return this;
       };
-      Sub.prototype = Object.create(Super.prototype);
-      Sub.prototype.constructor = Sub;
-      Sub.cid = cid++;
-      Sub.options = mergeOptions(
-        Super.options,
-        extendOptions
-      );
-      Sub['super'] = Super;
-
-      // For props and computed properties, we define the proxy getters on
-      // the Vue instances at extension time, on the extended prototype. This
-      // avoids Object.defineProperty calls for each instance created.
-      if (Sub.options.props) {
-        initProps$1(Sub);
-      }
-      if (Sub.options.computed) {
-        initComputed$1(Sub);
-      }
-
-      // allow further extension/mixin/plugin usage
-      Sub.extend = Super.extend;
-      Sub.mixin = Super.mixin;
-      Sub.use = Super.use;
+  }
 
-      // create asset registers, so extended classes
-      // can have their private assets too.
-      ASSET_TYPES.forEach(function (type) {
-        Sub[type] = Super[type];
-      });
-      // enable recursive self-lookup
-      if (name) {
-        Sub.options.components[name] = Sub;
-      }
-
-      // keep a reference to the super options at extension time.
-      // later at instantiation we can check if Super's options have
-      // been updated.
-      Sub.superOptions = Super.options;
-      Sub.extendOptions = extendOptions;
-      Sub.sealedOptions = extend({}, Sub.options);
-
-      // cache constructor
-      cachedCtors[SuperId] = Sub;
-      return Sub
-    };
-  }
-
-  function initProps$1 (Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-      proxy(Comp.prototype, "_props", key);
-    }
-  }
-
-  function initComputed$1 (Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
-      defineComputed(Comp.prototype, key, computed[key]);
-    }
-  }
-
-  /*  */
-
-  function initAssetRegisters (Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach(function (type) {
-      Vue[type] = function (
-        id,
-        definition
-      ) {
-        if (!definition) {
-          return this.options[type + 's'][id]
-        } else {
-          /* istanbul ignore if */
-          if (type === 'component') {
-            validateComponentName(id);
+  /* @flow */
+  function initExtend(Vue) {
+      /**
+       * Each instance constructor, including Vue, has a unique
+       * cid. This enables us to create wrapped "child
+       * constructors" for prototypal inheritance and cache them.
+       */
+      Vue.cid = 0;
+      var cid = 1;
+      /**
+       * Class inheritance
+       */
+      Vue.extend = function (extendOptions) {
+          extendOptions = extendOptions || {};
+          var Super = this;
+          var SuperId = Super.cid;
+          var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          if (cachedCtors[SuperId]) {
+              return cachedCtors[SuperId];
           }
-          if (type === 'component' && isPlainObject(definition)) {
-            definition.name = definition.name || id;
-            definition = this.options._base.extend(definition);
+          var name = extendOptions.name || Super.options.name;
+          if (name) {
+              validateComponentName(name);
           }
-          if (type === 'directive' && typeof definition === 'function') {
-            definition = { bind: definition, update: definition };
+          var Sub = function VueComponent(options) {
+              this._init(options);
+          };
+          Sub.prototype = Object.create(Super.prototype);
+          Sub.prototype.constructor = Sub;
+          Sub.cid = cid++;
+          Sub.options = mergeOptions(Super.options, extendOptions);
+          Sub['super'] = Super;
+          // For props and computed properties, we define the proxy getters on
+          // the Vue instances at extension time, on the extended prototype. This
+          // avoids Object.defineProperty calls for each instance created.
+          if (Sub.options.props) {
+              initProps$1(Sub);
+          }
+          if (Sub.options.computed) {
+              initComputed$1(Sub);
+          }
+          // allow further extension/mixin/plugin usage
+          Sub.extend = Super.extend;
+          Sub.mixin = Super.mixin;
+          Sub.use = Super.use;
+          // create asset registers, so extended classes
+          // can have their private assets too.
+          ASSET_TYPES.forEach(function (type) {
+              Sub[type] = Super[type];
+          });
+          // enable recursive self-lookup
+          if (name) {
+              Sub.options.components[name] = Sub;
           }
-          this.options[type + 's'][id] = definition;
-          return definition
-        }
+          // keep a reference to the super options at extension time.
+          // later at instantiation we can check if Super's options have
+          // been updated.
+          Sub.superOptions = Super.options;
+          Sub.extendOptions = extendOptions;
+          Sub.sealedOptions = extend({}, Sub.options);
+          // cache constructor
+          cachedCtors[SuperId] = Sub;
+          return Sub;
       };
-    });
   }
-
-  /*  */
-
-
-
-  function getComponentName (opts) {
-    return opts && (opts.Ctor.options.name || opts.tag)
+  function initProps$1(Comp) {
+      var props = Comp.options.props;
+      for (var key in props) {
+          proxy(Comp.prototype, "_props", key);
+      }
+  }
+  function initComputed$1(Comp) {
+      var computed = Comp.options.computed;
+      for (var key in computed) {
+          defineComputed(Comp.prototype, key, computed[key]);
+      }
   }
 
-  function matches (pattern, name) {
-    if (Array.isArray(pattern)) {
-      return pattern.indexOf(name) > -1
-    } else if (typeof pattern === 'string') {
-      return pattern.split(',').indexOf(name) > -1
-    } else if (isRegExp(pattern)) {
-      return pattern.test(name)
-    }
-    /* istanbul ignore next */
-    return false
+  /* @flow */
+  function initAssetRegisters(Vue) {
+      /**
+       * Create asset registration methods.
+       */
+      ASSET_TYPES.forEach(function (type) {
+          // @ts-expect-error function is not exact same type
+          Vue[type] = function (id, definition) {
+              if (!definition) {
+                  return this.options[type + 's'][id];
+              }
+              else {
+                  /* istanbul ignore if */
+                  if (type === 'component') {
+                      validateComponentName(id);
+                  }
+                  if (type === 'component' && isPlainObject(definition)) {
+                      // @ts-expect-error
+                      definition.name = definition.name || id;
+                      definition = this.options._base.extend(definition);
+                  }
+                  if (type === 'directive' && typeof definition === 'function') {
+                      definition = { bind: definition, update: definition };
+                  }
+                  this.options[type + 's'][id] = definition;
+                  return definition;
+              }
+          };
+      });
   }
 
-  function pruneCache (keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-      var cachedNode = cache[key];
-      if (cachedNode) {
-        var name = getComponentName(cachedNode.componentOptions);
-        if (name && !filter(name)) {
-          pruneCacheEntry(cache, key, keys, _vnode);
-        }
+  // @ts-nocheck
+  function getComponentName(opts) {
+      return opts && (opts.Ctor.options.name || opts.tag);
+  }
+  function matches(pattern, name) {
+      if (Array.isArray(pattern)) {
+          return pattern.indexOf(name) > -1;
+      }
+      else if (typeof pattern === 'string') {
+          return pattern.split(',').indexOf(name) > -1;
+      }
+      else if (isRegExp(pattern)) {
+          return pattern.test(name);
+      }
+      /* istanbul ignore next */
+      return false;
+  }
+  function pruneCache(keepAliveInstance, filter) {
+      var cache = keepAliveInstance.cache;
+      var keys = keepAliveInstance.keys;
+      var _vnode = keepAliveInstance._vnode;
+      for (var key in cache) {
+          var cachedNode = cache[key];
+          if (cachedNode) {
+              var name = getComponentName(cachedNode.componentOptions);
+              if (name && !filter(name)) {
+                  pruneCacheEntry(cache, key, keys, _vnode);
+              }
+          }
       }
-    }
   }
-
-  function pruneCacheEntry (
-    cache,
-    key,
-    keys,
-    current
-  ) {
-    var cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-      cached$$1.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove(keys, key);
+  function pruneCacheEntry(cache, key, keys, current) {
+      var cached$$1 = cache[key];
+      if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+          cached$$1.componentInstance.$destroy();
+      }
+      cache[key] = null;
+      remove(keys, key);
   }
-
   var patternTypes = [String, RegExp, Array];
-
+  // TODO use defineComponent
   var KeepAlive = {
-    name: 'keep-alive',
-    abstract: true,
-
-    props: {
-      include: patternTypes,
-      exclude: patternTypes,
-      max: [String, Number]
-    },
-
-    created: function created () {
-      this.cache = Object.create(null);
-      this.keys = [];
-    },
-
-    destroyed: function destroyed () {
-      for (var key in this.cache) {
-        pruneCacheEntry(this.cache, key, this.keys);
-      }
-    },
-
-    mounted: function mounted () {
-      var this$1 = this;
-
-      this.$watch('include', function (val) {
-        pruneCache(this$1, function (name) { return matches(val, name); });
-      });
-      this.$watch('exclude', function (val) {
-        pruneCache(this$1, function (name) { return !matches(val, name); });
-      });
-    },
-
-    render: function render () {
-      var slot = this.$slots.default;
-      var vnode = getFirstComponentChild(slot);
-      var componentOptions = vnode && vnode.componentOptions;
-      if (componentOptions) {
-        // check pattern
-        var name = getComponentName(componentOptions);
-        var ref = this;
-        var include = ref.include;
-        var exclude = ref.exclude;
-        if (
-          // not included
-          (include && (!name || !matches(include, name))) ||
-          // excluded
-          (exclude && name && matches(exclude, name))
-        ) {
-          return vnode
-        }
-
-        var ref$1 = this;
-        var cache = ref$1.cache;
-        var keys = ref$1.keys;
-        var key = vnode.key == null
-          // same constructor may get registered as different local components
-          // so cid alone is not enough (#3269)
-          ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-          : vnode.key;
-        if (cache[key]) {
-          vnode.componentInstance = cache[key].componentInstance;
-          // make current key freshest
-          remove(keys, key);
-          keys.push(key);
-        } else {
-          cache[key] = vnode;
-          keys.push(key);
-          // prune oldest entry
-          if (this.max && keys.length > parseInt(this.max)) {
-            pruneCacheEntry(cache, keys[0], keys, this._vnode);
+      name: 'keep-alive',
+      abstract: true,
+      props: {
+          include: patternTypes,
+          exclude: patternTypes,
+          max: [String, Number],
+      },
+      created: function created() {
+          this.cache = Object.create(null);
+          this.keys = [];
+      },
+      destroyed: function destroyed() {
+          for (var key in this.cache) {
+              pruneCacheEntry(this.cache, key, this.keys);
           }
-        }
+      },
+      mounted: function mounted() {
+          var this$1 = this;
 
-        vnode.data.keepAlive = true;
-      }
-      return vnode || (slot && slot[0])
-    }
+          this.$watch('include', function (val) {
+              pruneCache(this$1, function (name) { return matches(val, name); });
+          });
+          this.$watch('exclude', function (val) {
+              pruneCache(this$1, function (name) { return !matches(val, name); });
+          });
+      },
+      render: function render() {
+          var slot = this.$slots.default;
+          var vnode = getFirstComponentChild(slot);
+          var componentOptions = vnode && vnode.componentOptions;
+          if (componentOptions) {
+              // check pattern
+              var name = getComponentName(componentOptions);
+              var ref = this;
+              var include = ref.include;
+              var exclude = ref.exclude;
+              if (
+              // not included
+              (include && (!name || !matches(include, name))) ||
+                  // excluded
+                  (exclude && name && matches(exclude, name))) {
+                  return vnode;
+              }
+              var ref$1 = this;
+              var cache = ref$1.cache;
+              var keys = ref$1.keys;
+              var key = vnode.key == null
+                  ? // same constructor may get registered as different local components
+                      // so cid alone is not enough (#3269)
+                      componentOptions.Ctor.cid +
+                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                  : vnode.key;
+              if (cache[key]) {
+                  vnode.componentInstance = cache[key].componentInstance;
+                  // make current key freshest
+                  remove(keys, key);
+                  keys.push(key);
+              }
+              else {
+                  cache[key] = vnode;
+                  keys.push(key);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+              }
+              vnode.data.keepAlive = true;
+          }
+          return vnode || (slot && slot[0]);
+      },
   };
 
   var builtInComponents = {
-    KeepAlive: KeepAlive
+      KeepAlive: KeepAlive,
   };
 
-  /*  */
-
-  function initGlobalAPI (Vue) {
-    // config
-    var configDef = {};
-    configDef.get = function () { return config; };
-    {
-      configDef.set = function () {
-        warn(
-          'Do not replace the Vue.config object, set individual fields instead.'
-        );
+  /* @flow */
+  function initGlobalAPI(Vue) {
+      // config
+      var configDef = {};
+      configDef.get = function () { return config; };
+      {
+          configDef.set = function () {
+              warn('Do not replace the Vue.config object, set individual fields instead.');
+          };
+      }
+      Object.defineProperty(Vue, 'config', configDef);
+      // exposed util methods.
+      // NOTE: these are not considered part of the public API - avoid relying on
+      // them unless you are aware of the risk.
+      Vue.util = {
+          warn: warn,
+          extend: extend,
+          mergeOptions: mergeOptions,
+          defineReactive: defineReactive$$1,
       };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-      warn: warn,
-      extend: extend,
-      mergeOptions: mergeOptions,
-      defineReactive: defineReactive$$1
-    };
-
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-
-    // 2.6 explicit observable API
-    Vue.observable = function (obj) {
-      observe(obj);
-      return obj
-    };
-
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
-      Vue.options[type + 's'] = Object.create(null);
-    });
-
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-
-    extend(Vue.options.components, builtInComponents);
-
-    initUse(Vue);
-    initMixin$1(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+      Vue.set = set;
+      Vue.delete = del;
+      Vue.nextTick = nextTick;
+      // 2.6 explicit observable API
+      Vue.observable = function (obj) {
+          observe(obj);
+          return obj;
+      };
+      Vue.options = Object.create(null);
+      ASSET_TYPES.forEach(function (type) {
+          Vue.options[type + 's'] = Object.create(null);
+      });
+      // this is used to identify the "base" constructor to extend all plain-object
+      // components with in Weex's multi-instance scenarios.
+      Vue.options._base = Vue;
+      extend(Vue.options.components, builtInComponents);
+      initUse(Vue);
+      initMixin$1(Vue);
+      initExtend(Vue);
+      initAssetRegisters(Vue);
   }
 
   initGlobalAPI(Vue);
-
   Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering
+      get: isServerRendering,
   });
-
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get () {
-      /* istanbul ignore next */
-      return this.$vnode && this.$vnode.ssrContext
-    }
+      get: function get() {
+          /* istanbul ignore next */
+          return this.$vnode && this.$vnode.ssrContext;
+      },
   });
-
   // expose FunctionalRenderContext for ssr runtime helper installation
   Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext
+      value: FunctionalRenderContext,
   });
-
   Vue.version = '2.6.12';
 
-  /*  */
-
+  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   var isReservedAttr = makeMap('style,class');
-
   // attributes that should be using props for binding
   var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
   };
-
   var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
   var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
   var convertEnumeratedValue = function (key, value) {
-    return isFalsyAttrValue(value) || value === 'false'
-      ? 'false'
-      // allow arbitrary string value for contenteditable
-      : key === 'contenteditable' && isValidContentEditableValue(value)
-        ? value
-        : 'true'
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
   };
-
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,translate,' +
-    'truespeed,typemustmatch,visible'
-  );
-
+  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
   var xlinkNS = 'http://www.w3.org/1999/xlink';
-
   var isXlink = function (name) {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
   };
-
   var getXlinkProp = function (name) {
-    return isXlink(name) ? name.slice(6, name.length) : ''
+      return isXlink(name) ? name.slice(6, name.length) : '';
   };
-
   var isFalsyAttrValue = function (val) {
-    return val == null || val === false
+      return val == null || val === false;
   };
 
-  /*  */
-
-  function genClassForVnode (vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-      childNode = childNode.componentInstance._vnode;
-      if (childNode && childNode.data) {
-        data = mergeClassData(childNode.data, data);
+  /* @flow */
+  function genClassForVnode(vnode) {
+      var data = vnode.data;
+      var parentNode = vnode;
+      var childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
       }
-    }
-    while (isDef(parentNode = parentNode.parent)) {
-      if (parentNode && parentNode.data) {
-        data = mergeClassData(data, parentNode.data);
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
       }
-    }
-    return renderClass(data.staticClass, data.class)
+      return renderClass(data.staticClass, data.class);
   }
-
-  function mergeClassData (child, parent) {
-    return {
-      staticClass: concat(child.staticClass, parent.staticClass),
-      class: isDef(child.class)
-        ? [child.class, parent.class]
-        : parent.class
-    }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
   }
-
-  function renderClass (
-    staticClass,
-    dynamicClass
-  ) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-      return concat(staticClass, stringifyClass(dynamicClass))
-    }
-    /* istanbul ignore next */
-    return ''
+  function renderClass(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
   }
-
-  function concat (a, b) {
-    return a ? b ? (a + ' ' + b) : a : (b || '')
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
   }
-
-  function stringifyClass (value) {
-    if (Array.isArray(value)) {
-      return stringifyArray(value)
-    }
-    if (isObject(value)) {
-      return stringifyObject(value)
-    }
-    if (typeof value === 'string') {
-      return value
-    }
-    /* istanbul ignore next */
-    return ''
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
   }
-
-  function stringifyArray (value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
-      if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-        if (res) { res += ' '; }
-        res += stringified;
+  function stringifyArray(value) {
+      var res = '';
+      var stringified;
+      for (var i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  { res += ' '; }
+              res += stringified;
+          }
       }
-    }
-    return res
+      return res;
   }
-
-  function stringifyObject (value) {
-    var res = '';
-    for (var key in value) {
-      if (value[key]) {
-        if (res) { res += ' '; }
-        res += key;
+  function stringifyObject(value) {
+      var res = '';
+      for (var key in value) {
+          if (value[key]) {
+              if (res)
+                  { res += ' '; }
+              res += key;
+          }
       }
-    }
-    return res
+      return res;
   }
 
-  /*  */
-
+  /* @flow */
   var namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML'
+      svg: 'http://www.w3.org/2000/svg',
+      math: 'http://www.w3.org/1998/Math/MathML',
   };
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-  );
-
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  );
-
+  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
   var isPreTag = function (tag) { return tag === 'pre'; };
-
   var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
+      return isHTMLTag(tag) || isSVG(tag);
   };
-
-  function getTagNamespace (tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
   }
-
   var unknownElementCache = Object.create(null);
-  function isUnknownElement (tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-      return true
-    }
-    if (isReservedTag(tag)) {
-      return false
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-      return unknownElementCache[tag]
-    }
-    var el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-      // http://stackoverflow.com/a/28210364/1070244
-      return (unknownElementCache[tag] = (
-        el.constructor === window.HTMLUnknownElement ||
-        el.constructor === window.HTMLElement
-      ))
-    } else {
-      return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-    }
+  function isUnknownElement(tag) {
+      /* istanbul ignore if */
+      if (!inBrowser) {
+          return true;
+      }
+      if (isReservedTag(tag)) {
+          return false;
+      }
+      tag = tag.toLowerCase();
+      /* istanbul ignore if */
+      if (unknownElementCache[tag] != null) {
+          return unknownElementCache[tag];
+      }
+      var el = document.createElement(tag);
+      if (tag.indexOf('-') > -1) {
+          // http://stackoverflow.com/a/28210364/1070244
+          return (unknownElementCache[tag] =
+              el.constructor === window.HTMLUnknownElement ||
+                  el.constructor === window.HTMLElement);
+      }
+      else {
+          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+      }
   }
-
   var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /*  */
-
+  /* @flow */
   /**
    * Query an element selector if it's not an element already.
    */
-  function query (el) {
-    if (typeof el === 'string') {
-      var selected = document.querySelector(el);
-      if (!selected) {
-        warn(
-          'Cannot find element: ' + el
-        );
-        return document.createElement('div')
+  function query(el) {
+      if (typeof el === 'string') {
+          var selected = document.querySelector(el);
+          if (!selected) {
+              warn('Cannot find element: ' + el);
+              return document.createElement('div');
+          }
+          return selected;
+      }
+      else {
+          return el;
       }
-      return selected
-    } else {
-      return el
-    }
   }
 
-  /*  */
-
-  function createElement$1 (tagName, vnode) {
-    var elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-      return elm
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-      elm.setAttribute('multiple', 'multiple');
-    }
-    return elm
+  /* @flow */
+  function createElement$1(tagName, vnode) {
+      var elm = document.createElement(tagName);
+      if (tagName !== 'select') {
+          return elm;
+      }
+      // false or null will remove the attribute but undefined will not
+      if (vnode.data &&
+          vnode.data.attrs &&
+          vnode.data.attrs.multiple !== undefined) {
+          elm.setAttribute('multiple', 'multiple');
+      }
+      return elm;
   }
-
-  function createElementNS (namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName)
+  function createElementNS(namespace, tagName) {
+      return document.createElementNS(namespaceMap[namespace], tagName);
   }
-
-  function createTextNode (text) {
-    return document.createTextNode(text)
+  function createTextNode(text) {
+      return document.createTextNode(text);
   }
-
-  function createComment (text) {
-    return document.createComment(text)
+  function createComment(text) {
+      return document.createComment(text);
   }
-
-  function insertBefore (parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
+  function insertBefore(parentNode, newNode, referenceNode) {
+      parentNode.insertBefore(newNode, referenceNode);
   }
-
-  function removeChild (node, child) {
-    node.removeChild(child);
+  function removeChild(node, child) {
+      node.removeChild(child);
   }
-
-  function appendChild (node, child) {
-    node.appendChild(child);
+  function appendChild(node, child) {
+      node.appendChild(child);
   }
-
-  function parentNode (node) {
-    return node.parentNode
+  function parentNode(node) {
+      return node.parentNode;
   }
-
-  function nextSibling (node) {
-    return node.nextSibling
+  function nextSibling(node) {
+      return node.nextSibling;
   }
-
-  function tagName (node) {
-    return node.tagName
+  function tagName(node) {
+      return node.tagName;
   }
-
-  function setTextContent (node, text) {
-    node.textContent = text;
+  function setTextContent(node, text) {
+      node.textContent = text;
   }
-
-  function setStyleScope (node, scopeId) {
-    node.setAttribute(scopeId, '');
+  function setStyleScope(node, scopeId) {
+      node.setAttribute(scopeId, '');
   }
 
   var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5747,48 +5033,53 @@
     setStyleScope: setStyleScope
   });
 
-  /*  */
-
+  /* @flow */
   var ref = {
-    create: function create (_, vnode) {
-      registerRef(vnode);
-    },
-    update: function update (oldVnode, vnode) {
-      if (oldVnode.data.ref !== vnode.data.ref) {
-        registerRef(oldVnode, true);
-        registerRef(vnode);
-      }
-    },
-    destroy: function destroy (vnode) {
-      registerRef(vnode, true);
-    }
+      create: function create(_, vnode) {
+          registerRef(vnode);
+      },
+      update: function update(oldVnode, vnode) {
+          if (oldVnode.data.ref !== vnode.data.ref) {
+              registerRef(oldVnode, true);
+              registerRef(vnode);
+          }
+      },
+      destroy: function destroy(vnode) {
+          registerRef(vnode, true);
+      },
   };
-
-  function registerRef (vnode, isRemoval) {
-    var key = vnode.data.ref;
-    if (!isDef(key)) { return }
-
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
-    if (isRemoval) {
-      if (Array.isArray(refs[key])) {
-        remove(refs[key], ref);
-      } else if (refs[key] === ref) {
-        refs[key] = undefined;
-      }
-    } else {
-      if (vnode.data.refInFor) {
-        if (!Array.isArray(refs[key])) {
-          refs[key] = [ref];
-        } else if (refs[key].indexOf(ref) < 0) {
-          // $flow-disable-line
-          refs[key].push(ref);
-        }
-      } else {
-        refs[key] = ref;
+  function registerRef(vnode, isRemoval) {
+      var key = vnode.data.ref;
+      if (!isDef(key))
+          { return; }
+      var vm = vnode.context;
+      var ref = vnode.componentInstance || vnode.elm;
+      var refs = vm.$refs;
+      if (isRemoval) {
+          if (Array.isArray(refs[key])) {
+              // @ts-expect-error invalid typings
+              remove(refs[key], ref);
+          }
+          else if (refs[key] === ref) {
+              refs[key] = undefined;
+          }
+      }
+      else {
+          // @ts-expect-error invalid typings
+          if (vnode.data.refInFor) {
+              if (!Array.isArray(refs[key])) {
+                  refs[key] = [ref];
+                  // @ts-expect-error invalid typings
+              }
+              else if (refs[key].indexOf(ref) < 0) {
+                  // @ts-expect-error invalid typings
+                  refs[key].push(ref);
+              }
+          }
+          else {
+              refs[key] = ref;
+          }
       }
-    }
   }
 
   /**
@@ -5802,1402 +5093,1297 @@
    * Not type-checking this because this file is perf-critical and the cost
    * of making flow understand it is not worth it.
    */
-
   var emptyNode = new VNode('', {}, []);
-
   var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-  function sameVnode (a, b) {
-    return (
-      a.key === b.key && (
-        (
-          a.tag === b.tag &&
-          a.isComment === b.isComment &&
-          isDef(a.data) === isDef(b.data) &&
-          sameInputType(a, b)
-        ) || (
-          isTrue(a.isAsyncPlaceholder) &&
-          a.asyncFactory === b.asyncFactory &&
-          isUndef(b.asyncFactory.error)
-        )
-      )
-    )
-  }
-
-  function sameInputType (a, b) {
-    if (a.tag !== 'input') { return true }
-    var i;
-    var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-    var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-    return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
-  }
-
-  function createKeyToOldIdx (children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-      key = children[i].key;
-      if (isDef(key)) { map[key] = i; }
-    }
-    return map
-  }
-
-  function createPatchFunction (backend) {
-    var i, j;
-    var cbs = {};
-
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
-
-    for (i = 0; i < hooks.length; ++i) {
-      cbs[hooks[i]] = [];
-      for (j = 0; j < modules.length; ++j) {
-        if (isDef(modules[j][hooks[i]])) {
-          cbs[hooks[i]].push(modules[j][hooks[i]]);
-        }
-      }
-    }
-
-    function emptyNodeAt (elm) {
-      return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-    }
-
-    function createRmCb (childElm, listeners) {
-      function remove$$1 () {
-        if (--remove$$1.listeners === 0) {
-          removeNode(childElm);
-        }
-      }
-      remove$$1.listeners = listeners;
-      return remove$$1
-    }
-
-    function removeNode (el) {
-      var parent = nodeOps.parentNode(el);
-      // element may have already been removed due to v-html / v-text
-      if (isDef(parent)) {
-        nodeOps.removeChild(parent, el);
-      }
-    }
-
-    function isUnknownElement$$1 (vnode, inVPre) {
-      return (
-        !inVPre &&
-        !vnode.ns &&
-        !(
-          config.ignoredElements.length &&
-          config.ignoredElements.some(function (ignore) {
-            return isRegExp(ignore)
-              ? ignore.test(vnode.tag)
-              : ignore === vnode.tag
-          })
-        ) &&
-        config.isUnknownElement(vnode.tag)
-      )
-    }
-
-    var creatingElmInVPre = 0;
-
-    function createElm (
-      vnode,
-      insertedVnodeQueue,
-      parentElm,
-      refElm,
-      nested,
-      ownerArray,
-      index
-    ) {
-      if (isDef(vnode.elm) && isDef(ownerArray)) {
-        // This vnode was used in a previous render!
-        // now it's used as a new node, overwriting its elm would cause
-        // potential patch errors down the road when it's used as an insertion
-        // reference node. Instead, we clone the node on-demand before creating
-        // associated DOM element for it.
-        vnode = ownerArray[index] = cloneVNode(vnode);
-      }
-
-      vnode.isRootInsert = !nested; // for transition enter check
-      if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-        return
+  function sameVnode(a, b) {
+      return (a.key === b.key &&
+          ((a.tag === b.tag &&
+              a.isComment === b.isComment &&
+              isDef(a.data) === isDef(b.data) &&
+              sameInputType(a, b)) ||
+              (isTrue(a.isAsyncPlaceholder) &&
+                  a.asyncFactory === b.asyncFactory &&
+                  isUndef(b.asyncFactory.error))));
+  }
+  function sameInputType(a, b) {
+      if (a.tag !== 'input')
+          { return true; }
+      var i;
+      var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+  }
+  function createKeyToOldIdx(children, beginIdx, endIdx) {
+      var i, key;
+      var map = {};
+      for (i = beginIdx; i <= endIdx; ++i) {
+          key = children[i].key;
+          if (isDef(key))
+              { map[key] = i; }
       }
-
-      var data = vnode.data;
-      var children = vnode.children;
-      var tag = vnode.tag;
-      if (isDef(tag)) {
-        {
-          if (data && data.pre) {
-            creatingElmInVPre++;
-          }
-          if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-            warn(
-              'Unknown custom element: <' + tag + '> - did you ' +
-              'register the component correctly? For recursive components, ' +
-              'make sure to provide the "name" option.',
-              vnode.context
-            );
-          }
-        }
-
-        vnode.elm = vnode.ns
-          ? nodeOps.createElementNS(vnode.ns, tag)
-          : nodeOps.createElement(tag, vnode);
-        setScope(vnode);
-
-        /* istanbul ignore if */
-        {
-          createChildren(vnode, children, insertedVnodeQueue);
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-          }
-          insert(parentElm, vnode.elm, refElm);
-        }
-
-        if (data && data.pre) {
-          creatingElmInVPre--;
-        }
-      } else if (isTrue(vnode.isComment)) {
-        vnode.elm = nodeOps.createComment(vnode.text);
-        insert(parentElm, vnode.elm, refElm);
-      } else {
-        vnode.elm = nodeOps.createTextNode(vnode.text);
-        insert(parentElm, vnode.elm, refElm);
-      }
-    }
-
-    function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-      var i = vnode.data;
-      if (isDef(i)) {
-        var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-        if (isDef(i = i.hook) && isDef(i = i.init)) {
-          i(vnode, false /* hydrating */);
-        }
-        // after calling the init hook, if the vnode is a child component
-        // it should've created a child instance and mounted it. the child
-        // component also has set the placeholder vnode's elm.
-        // in that case we can just return the element and be done.
-        if (isDef(vnode.componentInstance)) {
-          initComponent(vnode, insertedVnodeQueue);
-          insert(parentElm, vnode.elm, refElm);
-          if (isTrue(isReactivated)) {
-            reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+      return map;
+  }
+  function createPatchFunction(backend) {
+      var i, j;
+      var cbs = {};
+      var modules = backend.modules;
+      var nodeOps = backend.nodeOps;
+      for (i = 0; i < hooks.length; ++i) {
+          cbs[hooks[i]] = [];
+          for (j = 0; j < modules.length; ++j) {
+              if (isDef(modules[j][hooks[i]])) {
+                  cbs[hooks[i]].push(modules[j][hooks[i]]);
+              }
           }
-          return true
-        }
       }
-    }
-
-    function initComponent (vnode, insertedVnodeQueue) {
-      if (isDef(vnode.data.pendingInsert)) {
-        insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-        vnode.data.pendingInsert = null;
+      function emptyNodeAt(elm) {
+          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
       }
-      vnode.elm = vnode.componentInstance.$el;
-      if (isPatchable(vnode)) {
-        invokeCreateHooks(vnode, insertedVnodeQueue);
-        setScope(vnode);
-      } else {
-        // empty component root.
-        // skip all element-related modules except for ref (#3455)
-        registerRef(vnode);
-        // make sure to invoke the insert hook
-        insertedVnodeQueue.push(vnode);
+      function createRmCb(childElm, listeners) {
+          function remove$$1() {
+              if (--remove$$1.listeners === 0) {
+                  removeNode(childElm);
+              }
+          }
+          remove$$1.listeners = listeners;
+          return remove$$1;
+      }
+      function removeNode(el) {
+          var parent = nodeOps.parentNode(el);
+          // element may have already been removed due to v-html / v-text
+          if (isDef(parent)) {
+              nodeOps.removeChild(parent, el);
+          }
       }
-    }
-
-    function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-      var i;
-      // hack for #4339: a reactivated component with inner transition
-      // does not trigger because the inner node's created hooks are not called
-      // again. It's not ideal to involve module-specific logic in here but
-      // there doesn't seem to be a better way to do it.
-      var innerNode = vnode;
-      while (innerNode.componentInstance) {
-        innerNode = innerNode.componentInstance._vnode;
-        if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-          for (i = 0; i < cbs.activate.length; ++i) {
-            cbs.activate[i](emptyNode, innerNode);
-          }
-          insertedVnodeQueue.push(innerNode);
-          break
-        }
-      }
-      // unlike a newly created component,
-      // a reactivated keep-alive component doesn't insert itself
-      insert(parentElm, vnode.elm, refElm);
-    }
-
-    function insert (parent, elm, ref$$1) {
-      if (isDef(parent)) {
-        if (isDef(ref$$1)) {
-          if (nodeOps.parentNode(ref$$1) === parent) {
-            nodeOps.insertBefore(parent, elm, ref$$1);
-          }
-        } else {
-          nodeOps.appendChild(parent, elm);
-        }
-      }
-    }
-
-    function createChildren (vnode, children, insertedVnodeQueue) {
-      if (Array.isArray(children)) {
-        {
-          checkDuplicateKeys(children);
-        }
-        for (var i = 0; i < children.length; ++i) {
-          createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-        }
-      } else if (isPrimitive(vnode.text)) {
-        nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-      }
-    }
-
-    function isPatchable (vnode) {
-      while (vnode.componentInstance) {
-        vnode = vnode.componentInstance._vnode;
-      }
-      return isDef(vnode.tag)
-    }
-
-    function invokeCreateHooks (vnode, insertedVnodeQueue) {
-      for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-        cbs.create[i$1](emptyNode, vnode);
-      }
-      i = vnode.data.hook; // Reuse variable
-      if (isDef(i)) {
-        if (isDef(i.create)) { i.create(emptyNode, vnode); }
-        if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
-      }
-    }
-
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope (vnode) {
-      var i;
-      if (isDef(i = vnode.fnScopeId)) {
-        nodeOps.setStyleScope(vnode.elm, i);
-      } else {
-        var ancestor = vnode;
-        while (ancestor) {
-          if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-            nodeOps.setStyleScope(vnode.elm, i);
-          }
-          ancestor = ancestor.parent;
-        }
-      }
-      // for slot content they should also get the scopeId from the host instance.
-      if (isDef(i = activeInstance) &&
-        i !== vnode.context &&
-        i !== vnode.fnContext &&
-        isDef(i = i.$options._scopeId)
-      ) {
-        nodeOps.setStyleScope(vnode.elm, i);
-      }
-    }
-
-    function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-      for (; startIdx <= endIdx; ++startIdx) {
-        createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-      }
-    }
-
-    function invokeDestroyHook (vnode) {
-      var i, j;
-      var data = vnode.data;
-      if (isDef(data)) {
-        if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-        for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
-      }
-      if (isDef(i = vnode.children)) {
-        for (j = 0; j < vnode.children.length; ++j) {
-          invokeDestroyHook(vnode.children[j]);
-        }
-      }
-    }
-
-    function removeVnodes (vnodes, startIdx, endIdx) {
-      for (; startIdx <= endIdx; ++startIdx) {
-        var ch = vnodes[startIdx];
-        if (isDef(ch)) {
-          if (isDef(ch.tag)) {
-            removeAndInvokeRemoveHook(ch);
-            invokeDestroyHook(ch);
-          } else { // Text node
-            removeNode(ch.elm);
-          }
-        }
-      }
-    }
-
-    function removeAndInvokeRemoveHook (vnode, rm) {
-      if (isDef(rm) || isDef(vnode.data)) {
-        var i;
-        var listeners = cbs.remove.length + 1;
-        if (isDef(rm)) {
-          // we have a recursively passed down rm callback
-          // increase the listeners count
-          rm.listeners += listeners;
-        } else {
-          // directly removing
-          rm = createRmCb(vnode.elm, listeners);
-        }
-        // recursively invoke hooks on child component root node
-        if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-          removeAndInvokeRemoveHook(i, rm);
-        }
-        for (i = 0; i < cbs.remove.length; ++i) {
-          cbs.remove[i](vnode, rm);
-        }
-        if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-          i(vnode, rm);
-        } else {
-          rm();
-        }
-      } else {
-        removeNode(vnode.elm);
-      }
-    }
-
-    function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-      var oldStartIdx = 0;
-      var newStartIdx = 0;
-      var oldEndIdx = oldCh.length - 1;
-      var oldStartVnode = oldCh[0];
-      var oldEndVnode = oldCh[oldEndIdx];
-      var newEndIdx = newCh.length - 1;
-      var newStartVnode = newCh[0];
-      var newEndVnode = newCh[newEndIdx];
-      var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-      // removeOnly is a special flag used only by <transition-group>
-      // to ensure removed elements stay in correct relative positions
-      // during leaving transitions
-      var canMove = !removeOnly;
-
-      {
-        checkDuplicateKeys(newCh);
-      }
-
-      while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-        if (isUndef(oldStartVnode)) {
-          oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-        } else if (isUndef(oldEndVnode)) {
-          oldEndVnode = oldCh[--oldEndIdx];
-        } else if (sameVnode(oldStartVnode, newStartVnode)) {
-          patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-          oldStartVnode = oldCh[++oldStartIdx];
-          newStartVnode = newCh[++newStartIdx];
-        } else if (sameVnode(oldEndVnode, newEndVnode)) {
-          patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-          oldEndVnode = oldCh[--oldEndIdx];
-          newEndVnode = newCh[--newEndIdx];
-        } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-          patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-          canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-          oldStartVnode = oldCh[++oldStartIdx];
-          newEndVnode = newCh[--newEndIdx];
-        } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-          patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-          canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-          oldEndVnode = oldCh[--oldEndIdx];
-          newStartVnode = newCh[++newStartIdx];
-        } else {
-          if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-          idxInOld = isDef(newStartVnode.key)
-            ? oldKeyToIdx[newStartVnode.key]
-            : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-          if (isUndef(idxInOld)) { // New element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          } else {
-            vnodeToMove = oldCh[idxInOld];
-            if (sameVnode(vnodeToMove, newStartVnode)) {
-              patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-              oldCh[idxInOld] = undefined;
-              canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-            } else {
-              // same key but different element. treat as new element
-              createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-            }
-          }
-          newStartVnode = newCh[++newStartIdx];
-        }
-      }
-      if (oldStartIdx > oldEndIdx) {
-        refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-        addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-      } else if (newStartIdx > newEndIdx) {
-        removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-      }
-    }
-
-    function checkDuplicateKeys (children) {
-      var seenKeys = {};
-      for (var i = 0; i < children.length; i++) {
-        var vnode = children[i];
-        var key = vnode.key;
-        if (isDef(key)) {
-          if (seenKeys[key]) {
-            warn(
-              ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-              vnode.context
-            );
-          } else {
-            seenKeys[key] = true;
-          }
-        }
-      }
-    }
-
-    function findIdxInOld (node, oldCh, start, end) {
-      for (var i = start; i < end; i++) {
-        var c = oldCh[i];
-        if (isDef(c) && sameVnode(node, c)) { return i }
-      }
-    }
-
-    function patchVnode (
-      oldVnode,
-      vnode,
-      insertedVnodeQueue,
-      ownerArray,
-      index,
-      removeOnly
-    ) {
-      if (oldVnode === vnode) {
-        return
-      }
-
-      if (isDef(vnode.elm) && isDef(ownerArray)) {
-        // clone reused vnode
-        vnode = ownerArray[index] = cloneVNode(vnode);
-      }
-
-      var elm = vnode.elm = oldVnode.elm;
-
-      if (isTrue(oldVnode.isAsyncPlaceholder)) {
-        if (isDef(vnode.asyncFactory.resolved)) {
-          hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-        } else {
-          vnode.isAsyncPlaceholder = true;
-        }
-        return
-      }
-
-      // reuse element for static trees.
-      // note we only do this if the vnode is cloned -
-      // if the new node is not cloned it means the render functions have been
-      // reset by the hot-reload-api and we need to do a proper re-render.
-      if (isTrue(vnode.isStatic) &&
-        isTrue(oldVnode.isStatic) &&
-        vnode.key === oldVnode.key &&
-        (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-      ) {
-        vnode.componentInstance = oldVnode.componentInstance;
-        return
+      function isUnknownElement$$1(vnode, inVPre) {
+          return (!inVPre &&
+              !vnode.ns &&
+              !(config.ignoredElements.length &&
+                  config.ignoredElements.some(function (ignore) {
+                      return isRegExp(ignore)
+                          ? ignore.test(vnode.tag)
+                          : ignore === vnode.tag;
+                  })) &&
+              config.isUnknownElement(vnode.tag));
+      }
+      var creatingElmInVPre = 0;
+      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // This vnode was used in a previous render!
+              // now it's used as a new node, overwriting its elm would cause
+              // potential patch errors down the road when it's used as an insertion
+              // reference node. Instead, we clone the node on-demand before creating
+              // associated DOM element for it.
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          vnode.isRootInsert = !nested; // for transition enter check
+          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+              return;
+          }
+          var data = vnode.data;
+          var children = vnode.children;
+          var tag = vnode.tag;
+          if (isDef(tag)) {
+              {
+                  if (data && data.pre) {
+                      creatingElmInVPre++;
+                  }
+                  if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                      warn('Unknown custom element: <' +
+                          tag +
+                          '> - did you ' +
+                          'register the component correctly? For recursive components, ' +
+                          'make sure to provide the "name" option.', vnode.context);
+                  }
+              }
+              vnode.elm = vnode.ns
+                  ? nodeOps.createElementNS(vnode.ns, tag)
+                  : nodeOps.createElement(tag, vnode);
+              setScope(vnode);
+              /* istanbul ignore if */
+              {
+                  createChildren(vnode, children, insertedVnodeQueue);
+                  if (isDef(data)) {
+                      invokeCreateHooks(vnode, insertedVnodeQueue);
+                  }
+                  insert(parentElm, vnode.elm, refElm);
+              }
+              if (data && data.pre) {
+                  creatingElmInVPre--;
+              }
+          }
+          else if (isTrue(vnode.isComment)) {
+              vnode.elm = nodeOps.createComment(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+          else {
+              vnode.elm = nodeOps.createTextNode(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
       }
-
-      var i;
-      var data = vnode.data;
-      if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-        i(oldVnode, vnode);
+      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          var i = vnode.data;
+          if (isDef(i)) {
+              var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                  i(vnode, false /* hydrating */);
+              }
+              // after calling the init hook, if the vnode is a child component
+              // it should've created a child instance and mounted it. the child
+              // component also has set the placeholder vnode's elm.
+              // in that case we can just return the element and be done.
+              if (isDef(vnode.componentInstance)) {
+                  initComponent(vnode, insertedVnodeQueue);
+                  insert(parentElm, vnode.elm, refElm);
+                  if (isTrue(isReactivated)) {
+                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                  }
+                  return true;
+              }
+          }
       }
-
-      var oldCh = oldVnode.children;
-      var ch = vnode.children;
-      if (isDef(data) && isPatchable(vnode)) {
-        for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-        if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
+      function initComponent(vnode, insertedVnodeQueue) {
+          if (isDef(vnode.data.pendingInsert)) {
+              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+              vnode.data.pendingInsert = null;
+          }
+          vnode.elm = vnode.componentInstance.$el;
+          if (isPatchable(vnode)) {
+              invokeCreateHooks(vnode, insertedVnodeQueue);
+              setScope(vnode);
+          }
+          else {
+              // empty component root.
+              // skip all element-related modules except for ref (#3455)
+              registerRef(vnode);
+              // make sure to invoke the insert hook
+              insertedVnodeQueue.push(vnode);
+          }
+      }
+      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          var i;
+          // hack for #4339: a reactivated component with inner transition
+          // does not trigger because the inner node's created hooks are not called
+          // again. It's not ideal to involve module-specific logic in here but
+          // there doesn't seem to be a better way to do it.
+          var innerNode = vnode;
+          while (innerNode.componentInstance) {
+              innerNode = innerNode.componentInstance._vnode;
+              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                  for (i = 0; i < cbs.activate.length; ++i) {
+                      cbs.activate[i](emptyNode, innerNode);
+                  }
+                  insertedVnodeQueue.push(innerNode);
+                  break;
+              }
+          }
+          // unlike a newly created component,
+          // a reactivated keep-alive component doesn't insert itself
+          insert(parentElm, vnode.elm, refElm);
+      }
+      function insert(parent, elm, ref$$1) {
+          if (isDef(parent)) {
+              if (isDef(ref$$1)) {
+                  if (nodeOps.parentNode(ref$$1) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref$$1);
+                  }
+              }
+              else {
+                  nodeOps.appendChild(parent, elm);
+              }
+          }
+      }
+      function createChildren(vnode, children, insertedVnodeQueue) {
+          if (Array.isArray(children)) {
+              {
+                  checkDuplicateKeys(children);
+              }
+              for (var i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              }
+          }
+          else if (isPrimitive(vnode.text)) {
+              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+          }
+      }
+      function isPatchable(vnode) {
+          while (vnode.componentInstance) {
+              vnode = vnode.componentInstance._vnode;
+          }
+          return isDef(vnode.tag);
+      }
+      function invokeCreateHooks(vnode, insertedVnodeQueue) {
+          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+              cbs.create[i$1](emptyNode, vnode);
+          }
+          i = vnode.data.hook; // Reuse variable
+          if (isDef(i)) {
+              if (isDef(i.create))
+                  { i.create(emptyNode, vnode); }
+              if (isDef(i.insert))
+                  { insertedVnodeQueue.push(vnode); }
+          }
+      }
+      // set scope id attribute for scoped CSS.
+      // this is implemented as a special case to avoid the overhead
+      // of going through the normal attribute patching process.
+      function setScope(vnode) {
+          var i;
+          if (isDef((i = vnode.fnScopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+          else {
+              var ancestor = vnode;
+              while (ancestor) {
+                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                      nodeOps.setStyleScope(vnode.elm, i);
+                  }
+                  ancestor = ancestor.parent;
+              }
+          }
+          // for slot content they should also get the scopeId from the host instance.
+          if (isDef((i = activeInstance)) &&
+              i !== vnode.context &&
+              i !== vnode.fnContext &&
+              isDef((i = i.$options._scopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+      }
+      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+          }
+      }
+      function invokeDestroyHook(vnode) {
+          var i, j;
+          var data = vnode.data;
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                  { i(vnode); }
+              for (i = 0; i < cbs.destroy.length; ++i)
+                  { cbs.destroy[i](vnode); }
+          }
+          if (isDef((i = vnode.children))) {
+              for (j = 0; j < vnode.children.length; ++j) {
+                  invokeDestroyHook(vnode.children[j]);
+              }
+          }
       }
-      if (isUndef(vnode.text)) {
-        if (isDef(oldCh) && isDef(ch)) {
-          if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-        } else if (isDef(ch)) {
+      function removeVnodes(vnodes, startIdx, endIdx) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              var ch = vnodes[startIdx];
+              if (isDef(ch)) {
+                  if (isDef(ch.tag)) {
+                      removeAndInvokeRemoveHook(ch);
+                      invokeDestroyHook(ch);
+                  }
+                  else {
+                      // Text node
+                      removeNode(ch.elm);
+                  }
+              }
+          }
+      }
+      function removeAndInvokeRemoveHook(vnode, rm) {
+          if (isDef(rm) || isDef(vnode.data)) {
+              var i;
+              var listeners = cbs.remove.length + 1;
+              if (isDef(rm)) {
+                  // we have a recursively passed down rm callback
+                  // increase the listeners count
+                  rm.listeners += listeners;
+              }
+              else {
+                  // directly removing
+                  rm = createRmCb(vnode.elm, listeners);
+              }
+              // recursively invoke hooks on child component root node
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
+              }
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
+              }
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          }
+          else {
+              removeNode(vnode.elm);
+          }
+      }
+      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+          var oldStartIdx = 0;
+          var newStartIdx = 0;
+          var oldEndIdx = oldCh.length - 1;
+          var oldStartVnode = oldCh[0];
+          var oldEndVnode = oldCh[oldEndIdx];
+          var newEndIdx = newCh.length - 1;
+          var newStartVnode = newCh[0];
+          var newEndVnode = newCh[newEndIdx];
+          var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          // removeOnly is a special flag used only by <transition-group>
+          // to ensure removed elements stay in correct relative positions
+          // during leaving transitions
+          var canMove = !removeOnly;
           {
-            checkDuplicateKeys(ch);
-          }
-          if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-          addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-        } else if (isDef(oldCh)) {
-          removeVnodes(oldCh, 0, oldCh.length - 1);
-        } else if (isDef(oldVnode.text)) {
-          nodeOps.setTextContent(elm, '');
-        }
-      } else if (oldVnode.text !== vnode.text) {
-        nodeOps.setTextContent(elm, vnode.text);
-      }
-      if (isDef(data)) {
-        if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-      }
-    }
-
-    function invokeInsertHook (vnode, queue, initial) {
-      // delay insert hooks for component root nodes, invoke them after the
-      // element is really inserted
-      if (isTrue(initial) && isDef(vnode.parent)) {
-        vnode.parent.data.pendingInsert = queue;
-      } else {
-        for (var i = 0; i < queue.length; ++i) {
-          queue[i].data.hook.insert(queue[i]);
-        }
-      }
-    }
-
-    var hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-      var i;
-      var tag = vnode.tag;
-      var data = vnode.data;
-      var children = vnode.children;
-      inVPre = inVPre || (data && data.pre);
-      vnode.elm = elm;
-
-      if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-        vnode.isAsyncPlaceholder = true;
-        return true
+              checkDuplicateKeys(newCh);
+          }
+          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+              if (isUndef(oldStartVnode)) {
+                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+              }
+              else if (isUndef(oldEndVnode)) {
+                  oldEndVnode = oldCh[--oldEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newStartVnode)) {
+                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else if (sameVnode(oldEndVnode, newEndVnode)) {
+                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newEndVnode)) {
+                  // Vnode moved right
+                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldEndVnode, newStartVnode)) {
+                  // Vnode moved left
+                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else {
+                  if (isUndef(oldKeyToIdx))
+                      { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                  idxInOld = isDef(newStartVnode.key)
+                      ? oldKeyToIdx[newStartVnode.key]
+                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                  if (isUndef(idxInOld)) {
+                      // New element
+                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                  }
+                  else {
+                      vnodeToMove = oldCh[idxInOld];
+                      if (sameVnode(vnodeToMove, newStartVnode)) {
+                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                          oldCh[idxInOld] = undefined;
+                          canMove &&
+                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                      }
+                      else {
+                          // same key but different element. treat as new element
+                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                      }
+                  }
+                  newStartVnode = newCh[++newStartIdx];
+              }
+          }
+          if (oldStartIdx > oldEndIdx) {
+              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+          }
+          else if (newStartIdx > newEndIdx) {
+              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+          }
       }
-      // assert node match
-      {
-        if (!assertNodeMatch(elm, vnode, inVPre)) {
-          return false
-        }
-      }
-      if (isDef(data)) {
-        if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-        if (isDef(i = vnode.componentInstance)) {
-          // child component. it should have hydrated its own tree.
-          initComponent(vnode, insertedVnodeQueue);
-          return true
-        }
-      }
-      if (isDef(tag)) {
-        if (isDef(children)) {
-          // empty element, allow client to pick up and populate children
-          if (!elm.hasChildNodes()) {
-            createChildren(vnode, children, insertedVnodeQueue);
-          } else {
-            // v-html and domProps: innerHTML
-            if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-              if (i !== elm.innerHTML) {
-                /* istanbul ignore if */
-                if (typeof console !== 'undefined' &&
-                  !hydrationBailed
-                ) {
-                  hydrationBailed = true;
-                  console.warn('Parent: ', elm);
-                  console.warn('server innerHTML: ', i);
-                  console.warn('client innerHTML: ', elm.innerHTML);
-                }
-                return false
-              }
-            } else {
-              // iterate and compare children lists
-              var childrenMatch = true;
-              var childNode = elm.firstChild;
-              for (var i$1 = 0; i$1 < children.length; i$1++) {
-                if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                  childrenMatch = false;
-                  break
-                }
-                childNode = childNode.nextSibling;
-              }
-              // if childNode is not null, it means the actual childNodes list is
-              // longer than the virtual children list.
-              if (!childrenMatch || childNode) {
-                /* istanbul ignore if */
-                if (typeof console !== 'undefined' &&
-                  !hydrationBailed
-                ) {
-                  hydrationBailed = true;
-                  console.warn('Parent: ', elm);
-                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                }
-                return false
-              }
-            }
-          }
-        }
-        if (isDef(data)) {
-          var fullInvoke = false;
-          for (var key in data) {
-            if (!isRenderedModule(key)) {
-              fullInvoke = true;
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              break
-            }
-          }
-          if (!fullInvoke && data['class']) {
-            // ensure collecting deps for deep class bindings for future updates
-            traverse(data['class']);
-          }
-        }
-      } else if (elm.data !== vnode.text) {
-        elm.data = vnode.text;
-      }
-      return true
-    }
-
-    function assertNodeMatch (node, vnode, inVPre) {
-      if (isDef(vnode.tag)) {
-        return vnode.tag.indexOf('vue-component') === 0 || (
-          !isUnknownElement$$1(vnode, inVPre) &&
-          vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-        )
-      } else {
-        return node.nodeType === (vnode.isComment ? 8 : 3)
-      }
-    }
-
-    return function patch (oldVnode, vnode, hydrating, removeOnly) {
-      if (isUndef(vnode)) {
-        if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-        return
-      }
-
-      var isInitialPatch = false;
-      var insertedVnodeQueue = [];
-
-      if (isUndef(oldVnode)) {
-        // empty mount (likely as component), create new root element
-        isInitialPatch = true;
-        createElm(vnode, insertedVnodeQueue);
-      } else {
-        var isRealElement = isDef(oldVnode.nodeType);
-        if (!isRealElement && sameVnode(oldVnode, vnode)) {
-          // patch existing root node
-          patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-        } else {
-          if (isRealElement) {
-            // mounting to a real element
-            // check if this is server-rendered content and if we can perform
-            // a successful hydration.
-            if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-              oldVnode.removeAttribute(SSR_ATTR);
-              hydrating = true;
-            }
-            if (isTrue(hydrating)) {
-              if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                invokeInsertHook(vnode, insertedVnodeQueue, true);
-                return oldVnode
-              } else {
-                warn(
-                  'The client-side rendered virtual DOM tree is not matching ' +
-                  'server-rendered content. This is likely caused by incorrect ' +
-                  'HTML markup, for example nesting block-level elements inside ' +
-                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                  'full client-side render.'
-                );
-              }
-            }
-            // either not server-rendered, or hydration failed.
-            // create an empty node and replace it
-            oldVnode = emptyNodeAt(oldVnode);
-          }
-
-          // replacing existing element
-          var oldElm = oldVnode.elm;
-          var parentElm = nodeOps.parentNode(oldElm);
-
-          // create new node
-          createElm(
-            vnode,
-            insertedVnodeQueue,
-            // extremely rare edge case: do not insert if old element is in a
-            // leaving transition. Only happens when combining transition +
-            // keep-alive + HOCs. (#4590)
-            oldElm._leaveCb ? null : parentElm,
-            nodeOps.nextSibling(oldElm)
-          );
-
-          // update parent placeholder node element, recursively
-          if (isDef(vnode.parent)) {
-            var ancestor = vnode.parent;
-            var patchable = isPatchable(vnode);
-            while (ancestor) {
-              for (var i = 0; i < cbs.destroy.length; ++i) {
-                cbs.destroy[i](ancestor);
-              }
-              ancestor.elm = vnode.elm;
-              if (patchable) {
-                for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                  cbs.create[i$1](emptyNode, ancestor);
-                }
-                // #6513
-                // invoke insert hooks that may have been merged by create hooks.
-                // e.g. for directives that uses the "inserted" hook.
-                var insert = ancestor.data.hook.insert;
-                if (insert.merged) {
-                  // start at index 1 to avoid re-invoking component mounted hook
-                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                    insert.fns[i$2]();
+      function checkDuplicateKeys(children) {
+          var seenKeys = {};
+          for (var i = 0; i < children.length; i++) {
+              var vnode = children[i];
+              var key = vnode.key;
+              if (isDef(key)) {
+                  if (seenKeys[key]) {
+                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                  }
+                  else {
+                      seenKeys[key] = true;
                   }
-                }
-              } else {
-                registerRef(ancestor);
               }
-              ancestor = ancestor.parent;
-            }
           }
-
-          // destroy old node
-          if (isDef(parentElm)) {
-            removeVnodes([oldVnode], 0, 0);
-          } else if (isDef(oldVnode.tag)) {
-            invokeDestroyHook(oldVnode);
+      }
+      function findIdxInOld(node, oldCh, start, end) {
+          for (var i = start; i < end; i++) {
+              var c = oldCh[i];
+              if (isDef(c) && sameVnode(node, c))
+                  { return i; }
           }
-        }
       }
-
-      invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-      return vnode.elm
-    }
+      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+          if (oldVnode === vnode) {
+              return;
+          }
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // clone reused vnode
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          var elm = (vnode.elm = oldVnode.elm);
+          if (isTrue(oldVnode.isAsyncPlaceholder)) {
+              if (isDef(vnode.asyncFactory.resolved)) {
+                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+              }
+              else {
+                  vnode.isAsyncPlaceholder = true;
+              }
+              return;
+          }
+          // reuse element for static trees.
+          // note we only do this if the vnode is cloned -
+          // if the new node is not cloned it means the render functions have been
+          // reset by the hot-reload-api and we need to do a proper re-render.
+          if (isTrue(vnode.isStatic) &&
+              isTrue(oldVnode.isStatic) &&
+              vnode.key === oldVnode.key &&
+              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+              vnode.componentInstance = oldVnode.componentInstance;
+              return;
+          }
+          var i;
+          var data = vnode.data;
+          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+              i(oldVnode, vnode);
+          }
+          var oldCh = oldVnode.children;
+          var ch = vnode.children;
+          if (isDef(data) && isPatchable(vnode)) {
+              for (i = 0; i < cbs.update.length; ++i)
+                  { cbs.update[i](oldVnode, vnode); }
+              if (isDef((i = data.hook)) && isDef((i = i.update)))
+                  { i(oldVnode, vnode); }
+          }
+          if (isUndef(vnode.text)) {
+              if (isDef(oldCh) && isDef(ch)) {
+                  if (oldCh !== ch)
+                      { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+              }
+              else if (isDef(ch)) {
+                  {
+                      checkDuplicateKeys(ch);
+                  }
+                  if (isDef(oldVnode.text))
+                      { nodeOps.setTextContent(elm, ''); }
+                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+              }
+              else if (isDef(oldCh)) {
+                  removeVnodes(oldCh, 0, oldCh.length - 1);
+              }
+              else if (isDef(oldVnode.text)) {
+                  nodeOps.setTextContent(elm, '');
+              }
+          }
+          else if (oldVnode.text !== vnode.text) {
+              nodeOps.setTextContent(elm, vnode.text);
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                  { i(oldVnode, vnode); }
+          }
+      }
+      function invokeInsertHook(vnode, queue, initial) {
+          // delay insert hooks for component root nodes, invoke them after the
+          // element is really inserted
+          if (isTrue(initial) && isDef(vnode.parent)) {
+              vnode.parent.data.pendingInsert = queue;
+          }
+          else {
+              for (var i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
+              }
+          }
+      }
+      var hydrationBailed = false;
+      // list of modules that can skip create hook during hydration because they
+      // are already rendered on the client or has no need for initialization
+      // Note: style is excluded because it relies on initial clone for future
+      // deep updates (#7063).
+      var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      // Note: this is a browser-only function so we can assume elms are DOM nodes.
+      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+          var i;
+          var tag = vnode.tag;
+          var data = vnode.data;
+          var children = vnode.children;
+          inVPre = inVPre || (data && data.pre);
+          vnode.elm = elm;
+          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+              vnode.isAsyncPlaceholder = true;
+              return true;
+          }
+          // assert node match
+          {
+              if (!assertNodeMatch(elm, vnode, inVPre)) {
+                  return false;
+              }
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.init)))
+                  { i(vnode, true /* hydrating */); }
+              if (isDef((i = vnode.componentInstance))) {
+                  // child component. it should have hydrated its own tree.
+                  initComponent(vnode, insertedVnodeQueue);
+                  return true;
+              }
+          }
+          if (isDef(tag)) {
+              if (isDef(children)) {
+                  // empty element, allow client to pick up and populate children
+                  if (!elm.hasChildNodes()) {
+                      createChildren(vnode, children, insertedVnodeQueue);
+                  }
+                  else {
+                      // v-html and domProps: innerHTML
+                      if (isDef((i = data)) &&
+                          isDef((i = i.domProps)) &&
+                          isDef((i = i.innerHTML))) {
+                          if (i !== elm.innerHTML) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('server innerHTML: ', i);
+                                  console.warn('client innerHTML: ', elm.innerHTML);
+                              }
+                              return false;
+                          }
+                      }
+                      else {
+                          // iterate and compare children lists
+                          var childrenMatch = true;
+                          var childNode = elm.firstChild;
+                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                              if (!childNode ||
+                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  childrenMatch = false;
+                                  break;
+                              }
+                              childNode = childNode.nextSibling;
+                          }
+                          // if childNode is not null, it means the actual childNodes list is
+                          // longer than the virtual children list.
+                          if (!childrenMatch || childNode) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                              }
+                              return false;
+                          }
+                      }
+                  }
+              }
+              if (isDef(data)) {
+                  var fullInvoke = false;
+                  for (var key in data) {
+                      if (!isRenderedModule(key)) {
+                          fullInvoke = true;
+                          invokeCreateHooks(vnode, insertedVnodeQueue);
+                          break;
+                      }
+                  }
+                  if (!fullInvoke && data['class']) {
+                      // ensure collecting deps for deep class bindings for future updates
+                      traverse(data['class']);
+                  }
+              }
+          }
+          else if (elm.data !== vnode.text) {
+              elm.data = vnode.text;
+          }
+          return true;
+      }
+      function assertNodeMatch(node, vnode, inVPre) {
+          if (isDef(vnode.tag)) {
+              return (vnode.tag.indexOf('vue-component') === 0 ||
+                  (!isUnknownElement$$1(vnode, inVPre) &&
+                      vnode.tag.toLowerCase() ===
+                          (node.tagName && node.tagName.toLowerCase())));
+          }
+          else {
+              return node.nodeType === (vnode.isComment ? 8 : 3);
+          }
+      }
+      return function patch(oldVnode, vnode, hydrating, removeOnly) {
+          if (isUndef(vnode)) {
+              if (isDef(oldVnode))
+                  { invokeDestroyHook(oldVnode); }
+              return;
+          }
+          var isInitialPatch = false;
+          var insertedVnodeQueue = [];
+          if (isUndef(oldVnode)) {
+              // empty mount (likely as component), create new root element
+              isInitialPatch = true;
+              createElm(vnode, insertedVnodeQueue);
+          }
+          else {
+              var isRealElement = isDef(oldVnode.nodeType);
+              if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                  // patch existing root node
+                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+              }
+              else {
+                  if (isRealElement) {
+                      // mounting to a real element
+                      // check if this is server-rendered content and if we can perform
+                      // a successful hydration.
+                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                          oldVnode.removeAttribute(SSR_ATTR);
+                          hydrating = true;
+                      }
+                      if (isTrue(hydrating)) {
+                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                              invokeInsertHook(vnode, insertedVnodeQueue, true);
+                              return oldVnode;
+                          }
+                          else {
+                              warn('The client-side rendered virtual DOM tree is not matching ' +
+                                  'server-rendered content. This is likely caused by incorrect ' +
+                                  'HTML markup, for example nesting block-level elements inside ' +
+                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                  'full client-side render.');
+                          }
+                      }
+                      // either not server-rendered, or hydration failed.
+                      // create an empty node and replace it
+                      oldVnode = emptyNodeAt(oldVnode);
+                  }
+                  // replacing existing element
+                  var oldElm = oldVnode.elm;
+                  var parentElm = nodeOps.parentNode(oldElm);
+                  // create new node
+                  createElm(vnode, insertedVnodeQueue, 
+                  // extremely rare edge case: do not insert if old element is in a
+                  // leaving transition. Only happens when combining transition +
+                  // keep-alive + HOCs. (#4590)
+                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                  // update parent placeholder node element, recursively
+                  if (isDef(vnode.parent)) {
+                      var ancestor = vnode.parent;
+                      var patchable = isPatchable(vnode);
+                      while (ancestor) {
+                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
+                          }
+                          ancestor.elm = vnode.elm;
+                          if (patchable) {
+                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                  cbs.create[i$1](emptyNode, ancestor);
+                              }
+                              // #6513
+                              // invoke insert hooks that may have been merged by create hooks.
+                              // e.g. for directives that uses the "inserted" hook.
+                              var insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
+                                  // start at index 1 to avoid re-invoking component mounted hook
+                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                      insert.fns[i$2]();
+                                  }
+                              }
+                          }
+                          else {
+                              registerRef(ancestor);
+                          }
+                          ancestor = ancestor.parent;
+                      }
+                  }
+                  // destroy old node
+                  if (isDef(parentElm)) {
+                      removeVnodes([oldVnode], 0, 0);
+                  }
+                  else if (isDef(oldVnode.tag)) {
+                      invokeDestroyHook(oldVnode);
+                  }
+              }
+          }
+          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+          return vnode.elm;
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives (vnode) {
-      updateDirectives(vnode, emptyNode);
-    }
+      create: updateDirectives,
+      update: updateDirectives,
+      destroy: function unbindDirectives(vnode) {
+          // @ts-expect-error emptyNode is not VNodeWithData
+          updateDirectives(vnode, emptyNode);
+      },
   };
-
-  function updateDirectives (oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-      _update(oldVnode, vnode);
-    }
-  }
-
-  function _update (oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-
-    var key, oldDir, dir;
-    for (key in newDirs) {
-      oldDir = oldDirs[key];
-      dir = newDirs[key];
-      if (!oldDir) {
-        // new directive, bind
-        callHook$1(dir, 'bind', vnode, oldVnode);
-        if (dir.def && dir.def.inserted) {
-          dirsWithInsert.push(dir);
-        }
-      } else {
-        // existing directive, update
-        dir.oldValue = oldDir.value;
-        dir.oldArg = oldDir.arg;
-        callHook$1(dir, 'update', vnode, oldVnode);
-        if (dir.def && dir.def.componentUpdated) {
-          dirsWithPostpatch.push(dir);
-        }
-      }
-    }
-
-    if (dirsWithInsert.length) {
-      var callInsert = function () {
-        for (var i = 0; i < dirsWithInsert.length; i++) {
-          callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-        }
-      };
-      if (isCreate) {
-        mergeVNodeHook(vnode, 'insert', callInsert);
-      } else {
-        callInsert();
-      }
-    }
-
-    if (dirsWithPostpatch.length) {
-      mergeVNodeHook(vnode, 'postpatch', function () {
-        for (var i = 0; i < dirsWithPostpatch.length; i++) {
-          callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-        }
-      });
-    }
-
-    if (!isCreate) {
-      for (key in oldDirs) {
-        if (!newDirs[key]) {
-          // no longer present, unbind
-          callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-        }
+  function updateDirectives(oldVnode, vnode) {
+      if (oldVnode.data.directives || vnode.data.directives) {
+          _update(oldVnode, vnode);
+      }
+  }
+  function _update(oldVnode, vnode) {
+      var isCreate = oldVnode === emptyNode;
+      var isDestroy = vnode === emptyNode;
+      var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+      var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+      var dirsWithInsert = [];
+      var dirsWithPostpatch = [];
+      var key, oldDir, dir;
+      for (key in newDirs) {
+          oldDir = oldDirs[key];
+          dir = newDirs[key];
+          if (!oldDir) {
+              // new directive, bind
+              callHook$1(dir, 'bind', vnode, oldVnode);
+              if (dir.def && dir.def.inserted) {
+                  dirsWithInsert.push(dir);
+              }
+          }
+          else {
+              // existing directive, update
+              dir.oldValue = oldDir.value;
+              dir.oldArg = oldDir.arg;
+              callHook$1(dir, 'update', vnode, oldVnode);
+              if (dir.def && dir.def.componentUpdated) {
+                  dirsWithPostpatch.push(dir);
+              }
+          }
+      }
+      if (dirsWithInsert.length) {
+          var callInsert = function () {
+              for (var i = 0; i < dirsWithInsert.length; i++) {
+                  callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+              }
+          };
+          if (isCreate) {
+              mergeVNodeHook(vnode, 'insert', callInsert);
+          }
+          else {
+              callInsert();
+          }
+      }
+      if (dirsWithPostpatch.length) {
+          mergeVNodeHook(vnode, 'postpatch', function () {
+              for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                  callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+              }
+          });
+      }
+      if (!isCreate) {
+          for (key in oldDirs) {
+              if (!newDirs[key]) {
+                  // no longer present, unbind
+                  callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+              }
+          }
       }
-    }
   }
-
   var emptyModifiers = Object.create(null);
-
-  function normalizeDirectives$1 (
-    dirs,
-    vm
-  ) {
-    var res = Object.create(null);
-    if (!dirs) {
+  function normalizeDirectives$1(dirs, vm) {
+      var res = Object.create(null);
+      if (!dirs) {
+          // $flow-disable-line
+          return res;
+      }
+      var i, dir;
+      for (i = 0; i < dirs.length; i++) {
+          dir = dirs[i];
+          if (!dir.modifiers) {
+              // $flow-disable-line
+              dir.modifiers = emptyModifiers;
+          }
+          res[getRawDirName(dir)] = dir;
+          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+      }
       // $flow-disable-line
-      return res
-    }
-    var i, dir;
-    for (i = 0; i < dirs.length; i++) {
-      dir = dirs[i];
-      if (!dir.modifiers) {
-        // $flow-disable-line
-        dir.modifiers = emptyModifiers;
+      return res;
+  }
+  function getRawDirName(dir) {
+      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+  }
+  function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+      var fn = dir.def && dir.def[hook];
+      if (fn) {
+          try {
+              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+          }
+          catch (e) {
+              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+          }
       }
-      res[getRawDirName(dir)] = dir;
-      dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res
   }
 
-  function getRawDirName (dir) {
-    return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
-  }
+  var baseModules = [ref, directives];
 
-  function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
-    if (fn) {
-      try {
-        fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-      } catch (e) {
-        handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
-      }
-    }
-  }
-
-  var baseModules = [
-    ref,
-    directives
-  ];
-
-  /*  */
-
-  function updateAttrs (oldVnode, vnode) {
-    var opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-      return
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-      return
-    }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-      attrs = vnode.data.attrs = extend({}, attrs);
-    }
-
-    for (key in attrs) {
-      cur = attrs[key];
-      old = oldAttrs[key];
-      if (old !== cur) {
-        setAttr(elm, key, cur);
-      }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-      setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-      if (isUndef(attrs[key])) {
-        if (isXlink(key)) {
-          elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        } else if (!isEnumeratedAttr(key)) {
-          elm.removeAttribute(key);
-        }
-      }
-    }
-  }
-
-  function setAttr (el, key, value) {
-    if (el.tagName.indexOf('-') > -1) {
-      baseSetAttr(el, key, value);
-    } else if (isBooleanAttr(key)) {
-      // set attribute for blank value
-      // e.g. <option disabled>Select one</option>
-      if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-      } else {
-        // technically allowfullscreen is a boolean attribute for <iframe>,
-        // but Flash expects a value of "true" when used on <embed> tag
-        value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-          ? 'true'
-          : key;
-        el.setAttribute(key, value);
-      }
-    } else if (isEnumeratedAttr(key)) {
-      el.setAttribute(key, convertEnumeratedValue(key, value));
-    } else if (isXlink(key)) {
-      if (isFalsyAttrValue(value)) {
-        el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else {
-        el.setAttributeNS(xlinkNS, key, value);
-      }
-    } else {
-      baseSetAttr(el, key, value);
-    }
-  }
-
-  function baseSetAttr (el, key, value) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // #7138: IE10 & 11 fires input event when setting placeholder on
-      // <textarea>... block the first input event and remove the blocker
-      // immediately.
+  /* @flow */
+  function updateAttrs(oldVnode, vnode) {
+      var opts = vnode.componentOptions;
+      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+          return;
+      }
+      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+          return;
+      }
+      var key, cur, old;
+      var elm = vnode.elm;
+      var oldAttrs = oldVnode.data.attrs || {};
+      var attrs = vnode.data.attrs || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(attrs.__ob__)) {
+          attrs = vnode.data.attrs = extend({}, attrs);
+      }
+      for (key in attrs) {
+          cur = attrs[key];
+          old = oldAttrs[key];
+          if (old !== cur) {
+              setAttr(elm, key, cur, vnode.data.pre);
+          }
+      }
+      // #4391: in IE9, setting type can reset value for input[type=radio]
+      // #6666: IE/Edge forces progress value down to 1 before setting a max
       /* istanbul ignore if */
-      if (
-        isIE && !isIE9 &&
-        el.tagName === 'TEXTAREA' &&
-        key === 'placeholder' && value !== '' && !el.__ieph
-      ) {
-        var blocker = function (e) {
-          e.stopImmediatePropagation();
-          el.removeEventListener('input', blocker);
-        };
-        el.addEventListener('input', blocker);
-        // $flow-disable-line
-        el.__ieph = true; /* IE placeholder patched */
-      }
-      el.setAttribute(key, value);
-    }
+      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+          setAttr(elm, 'value', attrs.value);
+      }
+      for (key in oldAttrs) {
+          if (isUndef(attrs[key])) {
+              if (isXlink(key)) {
+                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+              }
+              else if (!isEnumeratedAttr(key)) {
+                  elm.removeAttribute(key);
+              }
+          }
+      }
+  }
+  function setAttr(el, key, value, isInPre) {
+      if (isInPre || el.tagName.indexOf('-') > -1) {
+          baseSetAttr(el, key, value);
+      }
+      else if (isBooleanAttr(key)) {
+          // set attribute for blank value
+          // e.g. <option disabled>Select one</option>
+          if (isFalsyAttrValue(value)) {
+              el.removeAttribute(key);
+          }
+          else {
+              // technically allowfullscreen is a boolean attribute for <iframe>,
+              // but Flash expects a value of "true" when used on <embed> tag
+              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+              el.setAttribute(key, value);
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          el.setAttribute(key, convertEnumeratedValue(key, value));
+      }
+      else if (isXlink(key)) {
+          if (isFalsyAttrValue(value)) {
+              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+          }
+          else {
+              el.setAttributeNS(xlinkNS, key, value);
+          }
+      }
+      else {
+          baseSetAttr(el, key, value);
+      }
+  }
+  function baseSetAttr(el, key, value) {
+      if (isFalsyAttrValue(value)) {
+          el.removeAttribute(key);
+      }
+      else {
+          // #7138: IE10 & 11 fires input event when setting placeholder on
+          // <textarea>... block the first input event and remove the blocker
+          // immediately.
+          /* istanbul ignore if */
+          if (isIE &&
+              !isIE9 &&
+              el.tagName === 'TEXTAREA' &&
+              key === 'placeholder' &&
+              value !== '' &&
+              !el.__ieph) {
+              var blocker = function (e) {
+                  e.stopImmediatePropagation();
+                  el.removeEventListener('input', blocker);
+              };
+              el.addEventListener('input', blocker);
+              // $flow-disable-line
+              el.__ieph = true; /* IE placeholder patched */
+          }
+          el.setAttribute(key, value);
+      }
   }
-
   var attrs = {
-    create: updateAttrs,
-    update: updateAttrs
+      create: updateAttrs,
+      update: updateAttrs,
   };
 
-  /*  */
-
-  function updateClass (oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-    if (
-      isUndef(data.staticClass) &&
-      isUndef(data.class) && (
-        isUndef(oldData) || (
-          isUndef(oldData.staticClass) &&
-          isUndef(oldData.class)
-        )
-      )
-    ) {
-      return
-    }
-
-    var cls = genClassForVnode(vnode);
-
-    // handle transition classes
-    var transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-      cls = concat(cls, stringifyClass(transitionClass));
-    }
-
-    // set the class
-    if (cls !== el._prevClass) {
-      el.setAttribute('class', cls);
-      el._prevClass = cls;
-    }
+  /* @flow */
+  function updateClass(oldVnode, vnode) {
+      var el = vnode.elm;
+      var data = vnode.data;
+      var oldData = oldVnode.data;
+      if (isUndef(data.staticClass) &&
+          isUndef(data.class) &&
+          (isUndef(oldData) ||
+              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+          return;
+      }
+      var cls = genClassForVnode(vnode);
+      // handle transition classes
+      var transitionClass = el._transitionClasses;
+      if (isDef(transitionClass)) {
+          cls = concat(cls, stringifyClass(transitionClass));
+      }
+      // set the class
+      if (cls !== el._prevClass) {
+          el.setAttribute('class', cls);
+          el._prevClass = cls;
+      }
   }
-
   var klass = {
-    create: updateClass,
-    update: updateClass
+      create: updateClass,
+      update: updateClass,
   };
 
-  /*  */
-
+  /* @flow */
   var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-  function parseFilters (exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
-
-    for (i = 0; i < exp.length; i++) {
-      prev = c;
-      c = exp.charCodeAt(i);
-      if (inSingle) {
-        if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-      } else if (inDouble) {
-        if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-      } else if (inTemplateString) {
-        if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-      } else if (inRegex) {
-        if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-      } else if (
-        c === 0x7C && // pipe
-        exp.charCodeAt(i + 1) !== 0x7C &&
-        exp.charCodeAt(i - 1) !== 0x7C &&
-        !curly && !square && !paren
-      ) {
-        if (expression === undefined) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1;
+  function parseFilters(exp) {
+      var inSingle = false;
+      var inDouble = false;
+      var inTemplateString = false;
+      var inRegex = false;
+      var curly = 0;
+      var square = 0;
+      var paren = 0;
+      var lastFilterIndex = 0;
+      var c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  { inSingle = false; }
+          }
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  { inDouble = false; }
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  { inTemplateString = false; }
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  { inRegex = false; }
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  var j = i - 1;
+                  var p = (void 0);
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          { break; }
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
+          }
+      }
+      if (expression === undefined) {
           expression = exp.slice(0, i).trim();
-        } else {
+      }
+      else if (lastFilterIndex !== 0) {
           pushFilter();
-        }
-      } else {
-        switch (c) {
-          case 0x22: inDouble = true; break         // "
-          case 0x27: inSingle = true; break         // '
-          case 0x60: inTemplateString = true; break // `
-          case 0x28: paren++; break                 // (
-          case 0x29: paren--; break                 // )
-          case 0x5B: square++; break                // [
-          case 0x5D: square--; break                // ]
-          case 0x7B: curly++; break                 // {
-          case 0x7D: curly--; break                 // }
-        }
-        if (c === 0x2f) { // /
-          var j = i - 1;
-          var p = (void 0);
-          // find first non-whitespace prev char
-          for (; j >= 0; j--) {
-            p = exp.charAt(j);
-            if (p !== ' ') { break }
-          }
-          if (!p || !validDivisionCharRE.test(p)) {
-            inRegex = true;
-          }
-        }
-      }
-    }
-
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
-    }
-
-    function pushFilter () {
-      (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-      lastFilterIndex = i + 1;
-    }
-
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i]);
-      }
-    }
-
-    return expression
-  }
-
-  function wrapFilter (exp, filter) {
-    var i = filter.indexOf('(');
-    if (i < 0) {
-      // _f: resolveFilter
-      return ("_f(\"" + filter + "\")(" + exp + ")")
-    } else {
-      var name = filter.slice(0, i);
-      var args = filter.slice(i + 1);
-      return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-    }
-  }
-
-  /*  */
-
-
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
+  }
+  function wrapFilter(exp, filter) {
+      var i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return ("_f(\"" + filter + "\")(" + exp + ")");
+      }
+      else {
+          var name = filter.slice(0, i);
+          var args = filter.slice(i + 1);
+          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+      }
+  }
 
+  /* @flow */
   /* eslint-disable no-unused-vars */
-  function baseWarn (msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+  function baseWarn(msg, range) {
+      console.error(("[Vue compiler]: " + msg));
   }
   /* eslint-enable no-unused-vars */
-
-  function pluckModuleFunction (
-    modules,
-    key
-  ) {
-    return modules
-      ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-      : []
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
   }
-
-  function addProp (el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      el.plain = false;
   }
-
-  function addAttr (el, name, value, range, dynamic) {
-    var attrs = dynamic
-      ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-      : (el.attrs || (el.attrs = []));
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addAttr(el, name, value, range, dynamic) {
+      var attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      el.plain = false;
   }
-
   // add a raw attr (use this in preTransforms)
-  function addRawAttr (el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-  }
-
-  function addDirective (
-    el,
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers,
-    range
-  ) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-      name: name,
-      rawName: rawName,
-      value: value,
-      arg: arg,
-      isDynamicArg: isDynamicArg,
-      modifiers: modifiers
-    }, range));
-    el.plain = false;
-  }
-
-  function prependModifierMarker (symbol, name, dynamic) {
-    return dynamic
-      ? ("_p(" + name + ",\"" + symbol + "\")")
-      : symbol + name // mark the event as captured
-  }
-
-  function addHandler (
-    el,
-    name,
-    value,
-    modifiers,
-    important,
-    warn,
-    range,
-    dynamic
-  ) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (
-      warn &&
-      modifiers.prevent && modifiers.passive
-    ) {
-      warn(
-        'passive and prevent can\'t be used together. ' +
-        'Passive handler can\'t prevent default event.',
-        range
-      );
-    }
-
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'contextmenu';
-        delete modifiers.right;
-      }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'mouseup';
-      }
-    }
-
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture;
-      name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-      delete modifiers.once;
-      name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive;
-      name = prependModifierMarker('&', name, dynamic);
-    }
-
-    var events;
-    if (modifiers.native) {
-      delete modifiers.native;
-      events = el.nativeEvents || (el.nativeEvents = {});
-    } else {
-      events = el.events || (el.events = {});
-    }
-
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers;
-    }
-
-    var handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-      important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    } else if (handlers) {
-      events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    } else {
-      events[name] = newHandler;
-    }
-
-    el.plain = false;
-  }
-
-  function getRawBindingAttr (
-    el,
-    name
-  ) {
-    return el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
-  }
-
-  function getBindingAttr (
-    el,
-    name,
-    getStatic
-  ) {
-    var dynamicValue =
-      getAndRemoveAttr(el, ':' + name) ||
-      getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-      return parseFilters(dynamicValue)
-    } else if (getStatic !== false) {
-      var staticValue = getAndRemoveAttr(el, name);
-      if (staticValue != null) {
-        return JSON.stringify(staticValue)
-      }
-    }
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name: name,
+          rawName: rawName,
+          value: value,
+          arg: arg,
+          isDynamicArg: isDynamicArg,
+          modifiers: modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      var events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      var handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
+  }
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
+  }
+  function getBindingAttr(el, name, getStatic) {
+      var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          var staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
   }
-
   // note: this only removes the attr from the Array (attrsList) so that it
   // doesn't get processed by processAttrs.
   // By default it does NOT remove it from the map (attrsMap) because the map is
   // needed during codegen.
-  function getAndRemoveAttr (
-    el,
-    name,
-    removeFromMap
-  ) {
-    var val;
-    if ((val = el.attrsMap[name]) != null) {
-      var list = el.attrsList;
-      for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i].name === name) {
-          list.splice(i, 1);
-          break
-        }
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      var val;
+      if ((val = el.attrsMap[name]) != null) {
+          var list = el.attrsList;
+          for (var i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
       }
-    }
-    if (removeFromMap) {
-      delete el.attrsMap[name];
-    }
-    return val
-  }
-
-  function getAndRemoveAttrByRegex (
-    el,
-    name
-  ) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      var attr = list[i];
-      if (name.test(attr.name)) {
-        list.splice(i, 1);
-        return attr
+      if (removeFromMap) {
+          delete el.attrsMap[name];
       }
-    }
+      return val;
   }
-
-  function rangeSetItem (
-    item,
-    range
-  ) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start;
+  function getAndRemoveAttrByRegex(el, name) {
+      var list = el.attrsList;
+      for (var i = 0, l = list.length; i < l; i++) {
+          var attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
       }
-      if (range.end != null) {
-        item.end = range.end;
+  }
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
       }
-    }
-    return item
+      return item;
   }
 
-  /*  */
-
+  /* @flow */
   /**
    * Cross-platform code generation for component v-model
    */
-  function genComponentModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
-    if (trim) {
-      valueExpression =
-        "(typeof " + baseValueExpression + " === 'string'" +
-        "? " + baseValueExpression + ".trim()" +
-        ": " + baseValueExpression + ")";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-    var assignment = genAssignmentCode(value, valueExpression);
-
-    el.model = {
-      value: ("(" + value + ")"),
-      expression: JSON.stringify(value),
-      callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-    };
+  function genComponentModel(el, value, modifiers) {
+      var ref = modifiers || {};
+      var number = ref.number;
+      var trim = ref.trim;
+      var baseValueExpression = '$$v';
+      var valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              "(typeof " + baseValueExpression + " === 'string'" +
+                  "? " + baseValueExpression + ".trim()" +
+                  ": " + baseValueExpression + ")";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: ("(" + value + ")"),
+          expression: JSON.stringify(value),
+          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+      };
   }
-
   /**
    * Cross-platform codegen helper for generating v-model value assignment code.
    */
-  function genAssignmentCode (
-    value,
-    assignment
-  ) {
-    var res = parseModel(value);
-    if (res.key === null) {
-      return (value + "=" + assignment)
-    } else {
-      return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-    }
+  function genAssignmentCode(value, assignment) {
+      var res = parseModel(value);
+      if (res.key === null) {
+          return (value + "=" + assignment);
+      }
+      else {
+          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+      }
   }
-
   /**
    * Parse a v-model expression into a base path and a final key segment.
    * Handles both dot-path and possible square brackets.
@@ -7212,2042 +6398,2134 @@
    * - test.xxx.a["asa"][test1[key]]
    *
    */
-
   var len, str, chr, index$1, expressionPos, expressionEndPos;
-
-
-
-  function parseModel (val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-      index$1 = val.lastIndexOf('.');
-      if (index$1 > -1) {
-        return {
-          exp: val.slice(0, index$1),
-          key: '"' + val.slice(index$1 + 1) + '"'
-        }
-      } else {
-        return {
-          exp: val,
-          key: null
-        }
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index$1 = val.lastIndexOf('.');
+          if (index$1 > -1) {
+              return {
+                  exp: val.slice(0, index$1),
+                  key: '"' + val.slice(index$1 + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
       }
-    }
-
-    str = val;
-    index$1 = expressionPos = expressionEndPos = 0;
-
-    while (!eof()) {
-      chr = next();
-      /* istanbul ignore if */
-      if (isStringStart(chr)) {
-        parseString(chr);
-      } else if (chr === 0x5B) {
-        parseBracket(chr);
+      str = val;
+      index$1 = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
       }
-    }
-
-    return {
-      exp: val.slice(0, expressionPos),
-      key: val.slice(expressionPos + 1, expressionEndPos)
-    }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
   }
-
-  function next () {
-    return str.charCodeAt(++index$1)
+  function next() {
+      return str.charCodeAt(++index$1);
   }
-
-  function eof () {
-    return index$1 >= len
+  function eof() {
+      return index$1 >= len;
   }
-
-  function isStringStart (chr) {
-    return chr === 0x22 || chr === 0x27
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
   }
-
-  function parseBracket (chr) {
-    var inBracket = 1;
-    expressionPos = index$1;
-    while (!eof()) {
-      chr = next();
-      if (isStringStart(chr)) {
-        parseString(chr);
-        continue
-      }
-      if (chr === 0x5B) { inBracket++; }
-      if (chr === 0x5D) { inBracket--; }
-      if (inBracket === 0) {
-        expressionEndPos = index$1;
-        break
+  function parseBracket(chr) {
+      var inBracket = 1;
+      expressionPos = index$1;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              { inBracket++; }
+          if (chr === 0x5d)
+              { inBracket--; }
+          if (inBracket === 0) {
+              expressionEndPos = index$1;
+              break;
+          }
       }
-    }
   }
-
-  function parseString (chr) {
-    var stringQuote = chr;
-    while (!eof()) {
-      chr = next();
-      if (chr === stringQuote) {
-        break
+  function parseString(chr) {
+      var stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   var warn$1;
-
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
   var CHECKBOX_RADIO_TOKEN = '__c';
-
-  function model (
-    el,
-    dir,
-    _warn
-  ) {
-    warn$1 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-
-    {
-      // inputs with type="file" are read only and setting the input's
-      // value will throw an error.
-      if (tag === 'input' && type === 'file') {
-        warn$1(
-          "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-          "File inputs are read only. Use a v-on:change listener instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-    }
-
-    if (el.component) {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    } else if (tag === 'select') {
-      genSelect(el, value, modifiers);
-    } else if (tag === 'input' && type === 'checkbox') {
-      genCheckboxModel(el, value, modifiers);
-    } else if (tag === 'input' && type === 'radio') {
-      genRadioModel(el, value, modifiers);
-    } else if (tag === 'input' || tag === 'textarea') {
-      genDefaultModel(el, value, modifiers);
-    } else if (!config.isReservedTag(tag)) {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    } else {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "v-model is not supported on this element type. " +
-        'If you are working with contenteditable, it\'s recommended to ' +
-        'wrap a library dedicated for that purpose inside a custom component.',
-        el.rawAttrsMap['v-model']
-      );
-    }
-
-    // ensure runtime directive metadata
-    return true
-  }
-
-  function genCheckboxModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked',
-      "Array.isArray(" + value + ")" +
-      "?_i(" + value + "," + valueBinding + ")>-1" + (
-        trueValueBinding === 'true'
-          ? (":(" + value + ")")
-          : (":_q(" + value + "," + trueValueBinding + ")")
-      )
-    );
-    addHandler(el, 'change',
-      "var $$a=" + value + "," +
+  function model(el, dir, _warn) {
+      warn$1 = _warn;
+      var value = dir.value;
+      var modifiers = dir.modifiers;
+      var tag = el.tag;
+      var type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn$1("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                  "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else if (!config.isReservedTag(tag)) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else {
+          warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+              "v-model is not supported on this element type. " +
+              "If you are working with contenteditable, it's recommended to " +
+              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', "Array.isArray(" + value + ")" +
+          "?_i(" + value + "," + valueBinding + ")>-1" +
+          (trueValueBinding === 'true'
+              ? (":(" + value + ")")
+              : (":_q(" + value + "," + trueValueBinding + ")")));
+      addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
           "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-      'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-            '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-      "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-      null, true
-    );
-  }
-
-  function genRadioModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-
-  function genSelect (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-      ".call($event.target.options,function(o){return o.selected})" +
-      ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-      "return " + (number ? '_n(val)' : 'val') + "})";
-
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-  }
-
-  function genDefaultModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var type = el.attrsMap.type;
-
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-      var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-      if (value$1 && !typeBinding) {
-        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-        warn$1(
-          binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-          'because the latter already expands to a value binding internally',
-          el.rawAttrsMap[binding]
-        );
-      }
-    }
-
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy
-      ? 'change'
-      : type === 'range'
-        ? RANGE_TOKEN
-        : 'input';
-
-    var valueExpression = '$event.target.value';
-    if (trim) {
-      valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-      code = "if($event.target.composing)return;" + code;
-    }
-
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()');
-    }
-  }
-
-  /*  */
+          'if(Array.isArray($$a)){' +
+          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+          '$$i=_i($$a,$$v);' +
+          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var selectedVal = "Array.prototype.filter" +
+          ".call($event.target.options,function(o){return o.selected})" +
+          ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+          "return " + (number ? '_n(val)' : 'val') + "})";
+      var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      var code = "var $$selectedVal = " + selectedVal + ";";
+      code = code + " " + (genAssignmentCode(value, assignment));
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      var type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value$1 && !typeBinding) {
+              var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn$1(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      var ref = modifiers || {};
+      var lazy = ref.lazy;
+      var number = ref.number;
+      var trim = ref.trim;
+      var needCompositionGuard = !lazy && type !== 'range';
+      var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      var valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = "$event.target.value.trim()";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = "if($event.target.composing)return;" + code;
+      }
+      addProp(el, 'value', ("(" + value + ")"));
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
+  }
 
+  /* @flow */
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
   // the whole point is ensuring the v-model callback gets called before
   // user-attached handlers.
-  function normalizeEvents (on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-      // IE input[type=range] only supports `change` event
-      var event = isIE ? 'change' : 'input';
-      on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-      delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-      on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-      delete on[CHECKBOX_RADIO_TOKEN];
-    }
+  function normalizeEvents(on) {
+      /* istanbul ignore if */
+      if (isDef(on[RANGE_TOKEN])) {
+          // IE input[type=range] only supports `change` event
+          var event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          delete on[RANGE_TOKEN];
+      }
+      // This was originally intended to fix #4521 but no longer necessary
+      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+      /* istanbul ignore if */
+      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+          delete on[CHECKBOX_RADIO_TOKEN];
+      }
   }
-
   var target$1;
-
-  function createOnceHandler$1 (event, handler, capture) {
-    var _target = target$1; // save current target element in closure
-    return function onceHandler () {
-      var res = handler.apply(null, arguments);
-      if (res !== null) {
-        remove$2(event, onceHandler, capture, _target);
-      }
-    }
+  function createOnceHandler$1(event, handler, capture) {
+      var _target = target$1; // save current target element in closure
+      return function onceHandler() {
+          var res = handler.apply(null, arguments);
+          if (res !== null) {
+              remove$2(event, onceHandler, capture, _target);
+          }
+      };
   }
-
   // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
   var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-  function add$1 (
-    name,
-    handler,
-    capture,
-    passive
-  ) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-      var attachedTimestamp = currentFlushTimestamp;
-      var original = handler;
-      handler = original._wrapper = function (e) {
-        if (
-          // no bubbling, should always fire.
-          // this is just a safety net in case event.timeStamp is unreliable in
-          // certain weird environments...
-          e.target === e.currentTarget ||
-          // event is fired after handler attachment
-          e.timeStamp >= attachedTimestamp ||
-          // bail for environments that have buggy event.timeStamp implementations
-          // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-          // #9681 QtWebEngine event.timeStamp is negative value
-          e.timeStamp <= 0 ||
-          // #9448 bail if event is fired in another document in a multi-page
-          // electron/nw.js app, since event.timeStamp will be using a different
-          // starting reference
-          e.target.ownerDocument !== document
-        ) {
-          return original.apply(this, arguments)
-        }
-      };
-    }
-    target$1.addEventListener(
-      name,
-      handler,
-      supportsPassive
-        ? { capture: capture, passive: passive }
-        : capture
-    );
-  }
-
-  function remove$2 (
-    name,
-    handler,
-    capture,
-    _target
-  ) {
-    (_target || target$1).removeEventListener(
-      name,
-      handler._wrapper || handler,
-      capture
-    );
-  }
-
-  function updateDOMListeners (oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-      return
-    }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+  function add$1(name, handler, capture, passive) {
+      // async edge case #6566: inner click event triggers patch, event handler
+      // attached to outer element during patch, and triggered again. This
+      // happens because browsers fire microtask ticks between event propagation.
+      // the solution is simple: we save the timestamp when a handler is attached,
+      // and the handler would only fire if the event passed to it was fired
+      // AFTER it was attached.
+      if (useMicrotaskFix) {
+          var attachedTimestamp = currentFlushTimestamp;
+          var original = handler;
+          //@ts-expect-error
+          handler = original._wrapper = function (e) {
+              if (
+              // no bubbling, should always fire.
+              // this is just a safety net in case event.timeStamp is unreliable in
+              // certain weird environments...
+              e.target === e.currentTarget ||
+                  // event is fired after handler attachment
+                  e.timeStamp >= attachedTimestamp ||
+                  // bail for environments that have buggy event.timeStamp implementations
+                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                  // #9681 QtWebEngine event.timeStamp is negative value
+                  e.timeStamp <= 0 ||
+                  // #9448 bail if event is fired in another document in a multi-page
+                  // electron/nw.js app, since event.timeStamp will be using a different
+                  // starting reference
+                  e.target.ownerDocument !== document) {
+                  return original.apply(this, arguments);
+              }
+          };
+      }
+      target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+  }
+  function remove$2(name, handler, capture, _target) {
+      (_target || target$1).removeEventListener(name, 
+      //@ts-expect-error
+      handler._wrapper || handler, capture);
+  }
+  function updateDOMListeners(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+          return;
+      }
+      var on = vnode.data.on || {};
+      var oldOn = oldVnode.data.on || {};
+      target$1 = vnode.elm;
+      normalizeEvents(on);
+      updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+      target$1 = undefined;
   }
-
   var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners
+      create: updateDOMListeners,
+      update: updateDOMListeners,
   };
 
-  /*  */
-
+  /* @flow */
   var svgContainer;
-
-  function updateDOMProps (oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-      return
-    }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-      props = vnode.data.domProps = extend({}, props);
-    }
-
-    for (key in oldProps) {
-      if (!(key in props)) {
-        elm[key] = '';
-      }
-    }
-
-    for (key in props) {
-      cur = props[key];
-      // ignore children if the node has textContent or innerHTML,
-      // as these will throw away existing DOM nodes and cause removal errors
-      // on subsequent patches (#3360)
-      if (key === 'textContent' || key === 'innerHTML') {
-        if (vnode.children) { vnode.children.length = 0; }
-        if (cur === oldProps[key]) { continue }
-        // #6601 work around Chrome version <= 55 bug where single textNode
-        // replaced by innerHTML/textContent retains its parentNode property
-        if (elm.childNodes.length === 1) {
-          elm.removeChild(elm.childNodes[0]);
-        }
-      }
-
-      if (key === 'value' && elm.tagName !== 'PROGRESS') {
-        // store value as _value as well since
-        // non-string values will be stringified
-        elm._value = cur;
-        // avoid resetting cursor position when value is the same
-        var strCur = isUndef(cur) ? '' : String(cur);
-        if (shouldUpdateValue(elm, strCur)) {
-          elm.value = strCur;
-        }
-      } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-        // IE doesn't support innerHTML for SVG elements
-        svgContainer = svgContainer || document.createElement('div');
-        svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-        var svg = svgContainer.firstChild;
-        while (elm.firstChild) {
-          elm.removeChild(elm.firstChild);
-        }
-        while (svg.firstChild) {
-          elm.appendChild(svg.firstChild);
-        }
-      } else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]
-      ) {
-        // some property updates can throw
-        // e.g. `value` on <progress> w/ non-finite value
-        try {
-          elm[key] = cur;
-        } catch (e) {}
-      }
-    }
-  }
-
-  // check platforms/web/util/attrs.js acceptValue
-
-
-  function shouldUpdateValue (elm, checkVal) {
-    return (!elm.composing && (
-      elm.tagName === 'OPTION' ||
-      isNotInFocusAndDirty(elm, checkVal) ||
-      isDirtyWithModifiers(elm, checkVal)
-    ))
-  }
-
-  function isNotInFocusAndDirty (elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    var notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try { notInFocus = document.activeElement !== elm; } catch (e) {}
-    return notInFocus && elm.value !== checkVal
-  }
-
-  function isDirtyWithModifiers (elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-      if (modifiers.number) {
-        return toNumber(value) !== toNumber(newVal)
-      }
-      if (modifiers.trim) {
-        return value.trim() !== newVal.trim()
-      }
-    }
-    return value !== newVal
+  function updateDOMProps(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+          return;
+      }
+      var key, cur;
+      var elm = vnode.elm;
+      var oldProps = oldVnode.data.domProps || {};
+      var props = vnode.data.domProps || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(props.__ob__)) {
+          props = vnode.data.domProps = extend({}, props);
+      }
+      for (key in oldProps) {
+          if (!(key in props)) {
+              elm[key] = '';
+          }
+      }
+      for (key in props) {
+          cur = props[key];
+          // ignore children if the node has textContent or innerHTML,
+          // as these will throw away existing DOM nodes and cause removal errors
+          // on subsequent patches (#3360)
+          if (key === 'textContent' || key === 'innerHTML') {
+              if (vnode.children)
+                  { vnode.children.length = 0; }
+              if (cur === oldProps[key])
+                  { continue; }
+              // #6601 work around Chrome version <= 55 bug where single textNode
+              // replaced by innerHTML/textContent retains its parentNode property
+              if (elm.childNodes.length === 1) {
+                  elm.removeChild(elm.childNodes[0]);
+              }
+          }
+          if (key === 'value' && elm.tagName !== 'PROGRESS') {
+              // store value as _value as well since
+              // non-string values will be stringified
+              elm._value = cur;
+              // avoid resetting cursor position when value is the same
+              var strCur = isUndef(cur) ? '' : String(cur);
+              if (shouldUpdateValue(elm, strCur)) {
+                  elm.value = strCur;
+              }
+          }
+          else if (key === 'innerHTML' &&
+              isSVG(elm.tagName) &&
+              isUndef(elm.innerHTML)) {
+              // IE doesn't support innerHTML for SVG elements
+              svgContainer = svgContainer || document.createElement('div');
+              svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+              var svg = svgContainer.firstChild;
+              while (elm.firstChild) {
+                  elm.removeChild(elm.firstChild);
+              }
+              while (svg.firstChild) {
+                  elm.appendChild(svg.firstChild);
+              }
+          }
+          else if (
+          // skip the update if old and new VDOM state is the same.
+          // `value` is handled separately because the DOM value may be temporarily
+          // out of sync with VDOM state due to focus, composition and modifiers.
+          // This  #4521 by skipping the unnecessary `checked` update.
+          cur !== oldProps[key]) {
+              // some property updates can throw
+              // e.g. `value` on <progress> w/ non-finite value
+              try {
+                  elm[key] = cur;
+              }
+              catch (e) { }
+          }
+      }
+  }
+  function shouldUpdateValue(elm, checkVal) {
+      return (
+      //@ts-expect-error
+      !elm.composing &&
+          (elm.tagName === 'OPTION' ||
+              isNotInFocusAndDirty(elm, checkVal) ||
+              isDirtyWithModifiers(elm, checkVal)));
+  }
+  function isNotInFocusAndDirty(elm, checkVal) {
+      // return true when textbox (.number and .trim) loses focus and its value is
+      // not equal to the updated value
+      var notInFocus = true;
+      // #6157
+      // work around IE bug when accessing document.activeElement in an iframe
+      try {
+          notInFocus = document.activeElement !== elm;
+      }
+      catch (e) { }
+      return notInFocus && elm.value !== checkVal;
+  }
+  function isDirtyWithModifiers(elm, newVal) {
+      var value = elm.value;
+      var modifiers = elm._vModifiers; // injected by v-model runtime
+      if (isDef(modifiers)) {
+          if (modifiers.number) {
+              return toNumber(value) !== toNumber(newVal);
+          }
+          if (modifiers.trim) {
+              return value.trim() !== newVal.trim();
+          }
+      }
+      return value !== newVal;
   }
-
   var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps
+      create: updateDOMProps,
+      update: updateDOMProps,
   };
 
-  /*  */
-
+  /* @flow */
   var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res
+      var res = {};
+      var listDelimiter = /;(?![^(]*\))/g;
+      var propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              var tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
   });
-
   // merge static and dynamic style data on the same vnode
-  function normalizeStyleData (data) {
-    var style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle
-      ? extend(data.staticStyle, style)
-      : style
+  function normalizeStyleData(data) {
+      var style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
   }
-
   // normalize possible array / string values into Object
-  function normalizeStyleBinding (bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-      return toObject(bindingStyle)
-    }
-    if (typeof bindingStyle === 'string') {
-      return parseStyleText(bindingStyle)
-    }
-    return bindingStyle
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
   }
-
   /**
    * parent component style should be after child's
    * so that parent component's style could override it
    */
-  function getStyle (vnode, checkChild) {
-    var res = {};
-    var styleData;
-
-    if (checkChild) {
-      var childNode = vnode;
-      while (childNode.componentInstance) {
-        childNode = childNode.componentInstance._vnode;
-        if (
-          childNode && childNode.data &&
-          (styleData = normalizeStyleData(childNode.data))
-        ) {
+  function getStyle(vnode, checkChild) {
+      var res = {};
+      var styleData;
+      if (checkChild) {
+          var childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
-        }
       }
-    }
-
-    if ((styleData = normalizeStyleData(vnode.data))) {
-      extend(res, styleData);
-    }
-
-    var parentNode = vnode;
-    while ((parentNode = parentNode.parent)) {
-      if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-        extend(res, styleData);
+      var parentNode = vnode;
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
       }
-    }
-    return res
+      return res;
   }
 
-  /*  */
-
+  /* @flow */
   var cssVarRE = /^--/;
   var importantRE = /\s*!important$/;
   var setProp = function (el, name, val) {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-      el.style.setProperty(name, val);
-    } else if (importantRE.test(val)) {
-      el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    } else {
-      var normalizedName = normalize(name);
-      if (Array.isArray(val)) {
-        // Support values array created by autoprefixer, e.g.
-        // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-        // Set them one by one, and the browser will only set those it can recognize
-        for (var i = 0, len = val.length; i < len; i++) {
-          el.style[normalizedName] = val[i];
-        }
-      } else {
-        el.style[normalizedName] = val;
-      }
-    }
+      /* istanbul ignore if */
+      if (cssVarRE.test(name)) {
+          el.style.setProperty(name, val);
+      }
+      else if (importantRE.test(val)) {
+          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+      }
+      else {
+          var normalizedName = normalize(name);
+          if (Array.isArray(val)) {
+              // Support values array created by autoprefixer, e.g.
+              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+              // Set them one by one, and the browser will only set those it can recognize
+              for (var i = 0, len = val.length; i < len; i++) {
+                  el.style[normalizedName] = val[i];
+              }
+          }
+          else {
+              el.style[normalizedName] = val;
+          }
+      }
   };
-
   var vendorNames = ['Webkit', 'Moz', 'ms'];
-
   var emptyStyle;
   var normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && (prop in emptyStyle)) {
-      return prop
-    }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-      var name = vendorNames[i] + capName;
-      if (name in emptyStyle) {
-        return name
-      }
-    }
+      emptyStyle = emptyStyle || document.createElement('div').style;
+      prop = camelize(prop);
+      if (prop !== 'filter' && prop in emptyStyle) {
+          return prop;
+      }
+      var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (var i = 0; i < vendorNames.length; i++) {
+          var name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
+          }
+      }
   });
-
-  function updateStyle (oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-
-    if (isUndef(data.staticStyle) && isUndef(data.style) &&
-      isUndef(oldData.staticStyle) && isUndef(oldData.style)
-    ) {
-      return
-    }
-
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-
-    var style = normalizeStyleBinding(vnode.data.style) || {};
-
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__)
-      ? extend({}, style)
-      : style;
-
-    var newStyle = getStyle(vnode, true);
-
-    for (name in oldStyle) {
-      if (isUndef(newStyle[name])) {
-        setProp(el, name, '');
+  function updateStyle(oldVnode, vnode) {
+      var data = vnode.data;
+      var oldData = oldVnode.data;
+      if (isUndef(data.staticStyle) &&
+          isUndef(data.style) &&
+          isUndef(oldData.staticStyle) &&
+          isUndef(oldData.style)) {
+          return;
+      }
+      var cur, name;
+      var el = vnode.elm;
+      var oldStaticStyle = oldData.staticStyle;
+      var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+      var oldStyle = oldStaticStyle || oldStyleBinding;
+      var style = normalizeStyleBinding(vnode.data.style) || {};
+      // store normalized style under a different key for next diff
+      // make sure to clone it if it's reactive, since the user likely wants
+      // to mutate it.
+      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+      var newStyle = getStyle(vnode, true);
+      for (name in oldStyle) {
+          if (isUndef(newStyle[name])) {
+              setProp(el, name, '');
+          }
       }
-    }
-    for (name in newStyle) {
-      cur = newStyle[name];
-      if (cur !== oldStyle[name]) {
-        // ie9 setting to null has no effect, must use empty string
-        setProp(el, name, cur == null ? '' : cur);
+      for (name in newStyle) {
+          cur = newStyle[name];
+          if (cur !== oldStyle[name]) {
+              // ie9 setting to null has no effect, must use empty string
+              setProp(el, name, cur == null ? '' : cur);
+          }
       }
-    }
   }
-
   var style = {
-    create: updateStyle,
-    update: updateStyle
+      create: updateStyle,
+      update: updateStyle,
   };
 
-  /*  */
-
+  /* @flow */
   var whitespaceRE = /\s+/;
-
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function addClass (el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-      return
-    }
-
-    /* istanbul ignore else */
-    if (el.classList) {
-      if (cls.indexOf(' ') > -1) {
-        cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-      } else {
-        el.classList.add(cls);
+  function addClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
       }
-    } else {
-      var cur = " " + (el.getAttribute('class') || '') + " ";
-      if (cur.indexOf(' ' + cls + ' ') < 0) {
-        el.setAttribute('class', (cur + cls).trim());
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+          }
+          else {
+              el.classList.add(cls);
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
       }
-    }
   }
-
   /**
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function removeClass (el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-      return
-    }
-
-    /* istanbul ignore else */
-    if (el.classList) {
-      if (cls.indexOf(' ') > -1) {
-        cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-      } else {
-        el.classList.remove(cls);
-      }
-      if (!el.classList.length) {
-        el.removeAttribute('class');
-      }
-    } else {
-      var cur = " " + (el.getAttribute('class') || '') + " ";
-      var tar = ' ' + cls + ' ';
-      while (cur.indexOf(tar) >= 0) {
-        cur = cur.replace(tar, ' ');
-      }
-      cur = cur.trim();
-      if (cur) {
-        el.setAttribute('class', cur);
-      } else {
-        el.removeAttribute('class');
-      }
-    }
-  }
-
-  /*  */
-
-  function resolveTransition (def$$1) {
-    if (!def$$1) {
-      return
-    }
-    /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
-      var res = {};
-      if (def$$1.css !== false) {
-        extend(res, autoCssTransition(def$$1.name || 'v'));
+  function removeClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          var tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
       }
-      extend(res, def$$1);
-      return res
-    } else if (typeof def$$1 === 'string') {
-      return autoCssTransition(def$$1)
-    }
   }
 
+  function resolveTransition(def$$1) {
+      if (!def$$1) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def$$1 === 'object') {
+          var res = {};
+          if (def$$1.css !== false) {
+              extend(res, autoCssTransition(def$$1.name || 'v'));
+          }
+          extend(res, def$$1);
+          return res;
+      }
+      else if (typeof def$$1 === 'string') {
+          return autoCssTransition(def$$1);
+      }
+  }
   var autoCssTransition = cached(function (name) {
-    return {
-      enterClass: (name + "-enter"),
-      enterToClass: (name + "-enter-to"),
-      enterActiveClass: (name + "-enter-active"),
-      leaveClass: (name + "-leave"),
-      leaveToClass: (name + "-leave-to"),
-      leaveActiveClass: (name + "-leave-active")
-    }
+      return {
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
+      };
   });
-
   var hasTransition = inBrowser && !isIE9;
   var TRANSITION = 'transition';
   var ANIMATION = 'animation';
-
   // Transition property/event sniffing
   var transitionProp = 'transition';
   var transitionEndEvent = 'transitionend';
   var animationProp = 'animation';
   var animationEndEvent = 'animationend';
   if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-      window.onwebkittransitionend !== undefined
-    ) {
-      transitionProp = 'WebkitTransition';
-      transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-      window.onwebkitanimationend !== undefined
-    ) {
-      animationProp = 'WebkitAnimation';
-      animationEndEvent = 'webkitAnimationEnd';
-    }
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          // @ts-expect-error
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          // @ts-expect-error
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
   }
-
   // binding to window is necessary to make hot reload work in IE in strict mode
   var raf = inBrowser
-    ? window.requestAnimationFrame
-      ? window.requestAnimationFrame.bind(window)
-      : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-
-  function nextFrame (fn) {
-    raf(function () {
-      raf(fn);
-    });
-  }
-
-  function addTransitionClass (el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-      transitionClasses.push(cls);
-      addClass(el, cls);
-    }
-  }
-
-  function removeTransitionClass (el, cls) {
-    if (el._transitionClasses) {
-      remove(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-  }
-
-  function whenTransitionEnds (
-    el,
-    expectedType,
-    cb
-  ) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type) { return cb() }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-      el.removeEventListener(event, onEnd);
-      cb();
-    };
-    var onEnd = function (e) {
-      if (e.target === el) {
-        if (++ended >= propCount) {
-          end();
-        }
-      }
-    };
-    setTimeout(function () {
-      if (ended < propCount) {
-        end();
-      }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ function (fn) { return fn(); };
+  function nextFrame(fn) {
+      raf(function () {
+          // @ts-expect-error
+          raf(fn);
+      });
+  }
+  function addTransitionClass(el, cls) {
+      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
+  }
+  function removeTransitionClass(el, cls) {
+      if (el._transitionClasses) {
+          remove(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
+  }
+  function whenTransitionEnds(el, expectedType, cb) {
+      var ref = getTransitionInfo(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
+      if (!type)
+          { return cb(); }
+      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var ended = 0;
+      var end = function () {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      var onEnd = function (e) {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(function () {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
   }
-
   var transformRE = /\b(transform|all)(,|$)/;
-
-  function getTransitionInfo (el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-      if (transitionTimeout > 0) {
-        type = TRANSITION;
-        timeout = transitionTimeout;
-        propCount = transitionDurations.length;
-      }
-    } else if (expectedType === ANIMATION) {
-      if (animationTimeout > 0) {
-        type = ANIMATION;
-        timeout = animationTimeout;
-        propCount = animationDurations.length;
-      }
-    } else {
-      timeout = Math.max(transitionTimeout, animationTimeout);
-      type = timeout > 0
-        ? transitionTimeout > animationTimeout
-          ? TRANSITION
-          : ANIMATION
-        : null;
-      propCount = type
-        ? type === TRANSITION
-          ? transitionDurations.length
-          : animationDurations.length
-        : 0;
-    }
-    var hasTransform =
-      type === TRANSITION &&
-      transformRE.test(styles[transitionProp + 'Property']);
-    return {
-      type: type,
-      timeout: timeout,
-      propCount: propCount,
-      hasTransform: hasTransform
-    }
-  }
-
-  function getTimeout (delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-      delays = delays.concat(delays);
-    }
-
-    return Math.max.apply(null, durations.map(function (d, i) {
-      return toMs(d) + toMs(delays[i])
-    }))
+  function getTransitionInfo(el, expectedType) {
+      var styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var type;
+      var timeout = 0;
+      var propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
+      }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type: type,
+          timeout: timeout,
+          propCount: propCount,
+          hasTransform: hasTransform,
+      };
+  }
+  function getTimeout(delays, durations) {
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map(function (d, i) {
+          return toMs(d) + toMs(delays[i]);
+      }));
   }
-
   // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
   // in a locale-dependent way, using a comma instead of a dot.
   // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
   // as a floor function) causing unexpected behaviors
-  function toMs (s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000
-  }
-
-  /*  */
-
-  function enter (vnode, toggleDisplay) {
-    var el = vnode.elm;
-
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-      el._leaveCb.cancelled = true;
-      el._leaveCb();
-    }
-
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-      return
-    }
-
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-      return
-    }
-
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-      context = transitionNode.context;
-      transitionNode = transitionNode.parent;
-    }
-
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-    if (isAppear && !appear && appear !== '') {
-      return
-    }
-
-    var startClass = isAppear && appearClass
-      ? appearClass
-      : enterClass;
-    var activeClass = isAppear && appearActiveClass
-      ? appearActiveClass
-      : enterActiveClass;
-    var toClass = isAppear && appearToClass
-      ? appearToClass
-      : enterToClass;
-
-    var beforeEnterHook = isAppear
-      ? (beforeAppear || beforeEnter)
-      : beforeEnter;
-    var enterHook = isAppear
-      ? (typeof appear === 'function' ? appear : enter)
-      : enter;
-    var afterEnterHook = isAppear
-      ? (afterAppear || afterEnter)
-      : afterEnter;
-    var enterCancelledHook = isAppear
-      ? (appearCancelled || enterCancelled)
-      : enterCancelled;
-
-    var explicitEnterDuration = toNumber(
-      isObject(duration)
-        ? duration.enter
-        : duration
-    );
-
-    if (explicitEnterDuration != null) {
-      checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-
-    var cb = el._enterCb = once(function () {
-      if (expectsCSS) {
-        removeTransitionClass(el, toClass);
-        removeTransitionClass(el, activeClass);
-      }
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, startClass);
-        }
-        enterCancelledHook && enterCancelledHook(el);
-      } else {
-        afterEnterHook && afterEnterHook(el);
-      }
-      el._enterCb = null;
-    });
-
-    if (!vnode.data.show) {
-      // remove pending leave element on enter by injecting an insert hook
-      mergeVNodeHook(vnode, 'insert', function () {
-        var parent = el.parentNode;
-        var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-        if (pendingNode &&
-          pendingNode.tag === vnode.tag &&
-          pendingNode.elm._leaveCb
-        ) {
-          pendingNode.elm._leaveCb();
-        }
-        enterHook && enterHook(el, cb);
-      });
-    }
-
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-      addTransitionClass(el, startClass);
-      addTransitionClass(el, activeClass);
-      nextFrame(function () {
-        removeTransitionClass(el, startClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, toClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitEnterDuration)) {
-              setTimeout(cb, explicitEnterDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-
-    if (vnode.data.show) {
-      toggleDisplay && toggleDisplay();
-      enterHook && enterHook(el, cb);
-    }
-
-    if (!expectsCSS && !userWantsControl) {
-      cb();
-    }
-  }
-
-  function leave (vnode, rm) {
-    var el = vnode.elm;
-
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-      el._enterCb.cancelled = true;
-      el._enterCb();
-    }
-
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-      return rm()
-    }
-
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-      return
-    }
-
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-
-    var explicitLeaveDuration = toNumber(
-      isObject(duration)
-        ? duration.leave
-        : duration
-    );
-
-    if (isDef(explicitLeaveDuration)) {
-      checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-
-    var cb = el._leaveCb = once(function () {
-      if (el.parentNode && el.parentNode._pending) {
-        el.parentNode._pending[vnode.key] = null;
+  function toMs(s) {
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+  }
+
+  /* @flow */
+  function enter(vnode, toggleDisplay) {
+      var el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
+      }
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      var context = activeInstance;
+      var transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      var startClass = isAppear && appearClass ? appearClass : enterClass;
+      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      var enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      var enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(enterHook);
+      var cb = (el._enterCb = once(function () {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', function () {
+              var parent = el.parentNode;
+              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
       }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
       if (expectsCSS) {
-        removeTransitionClass(el, leaveToClass);
-        removeTransitionClass(el, leaveActiveClass);
-      }
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, leaveClass);
-        }
-        leaveCancelled && leaveCancelled(el);
-      } else {
-        rm();
-        afterLeave && afterLeave(el);
-      }
-      el._leaveCb = null;
-    });
-
-    if (delayLeave) {
-      delayLeave(performLeave);
-    } else {
-      performLeave();
-    }
-
-    function performLeave () {
-      // the delayed leave may have already been cancelled
-      if (cb.cancelled) {
-        return
-      }
-      // record leaving element
-      if (!vnode.data.show && el.parentNode) {
-        (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
-      }
-      beforeLeave && beforeLeave(el);
-      if (expectsCSS) {
-        addTransitionClass(el, leaveClass);
-        addTransitionClass(el, leaveActiveClass);
-        nextFrame(function () {
-          removeTransitionClass(el, leaveClass);
-          if (!cb.cancelled) {
-            addTransitionClass(el, leaveToClass);
-            if (!userWantsControl) {
-              if (isValidDuration(explicitLeaveDuration)) {
-                setTimeout(cb, explicitLeaveDuration);
-              } else {
-                whenTransitionEnds(el, type, cb);
-              }
-            }
-          }
-        });
-      }
-      leave && leave(el, cb);
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(function () {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
       if (!expectsCSS && !userWantsControl) {
-        cb();
+          cb();
+      }
+  }
+  function leave(vnode, rm) {
+      var el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
+      }
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
+      }
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(leave);
+      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      var cb = (el._leaveCb = once(function () {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
+              }
+              leaveCancelled && leaveCancelled(el);
+          }
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
+      }
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(function () {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
       }
-    }
   }
-
   // only used in dev mode
-  function checkDuration (val, name, vnode) {
-    if (typeof val !== 'number') {
-      warn(
-        "<transition> explicit " + name + " duration is not a valid number - " +
-        "got " + (JSON.stringify(val)) + ".",
-        vnode.context
-      );
-    } else if (isNaN(val)) {
-      warn(
-        "<transition> explicit " + name + " duration is NaN - " +
-        'the duration expression might be incorrect.',
-        vnode.context
-      );
-    }
+  function checkDuration(val, name, vnode) {
+      if (typeof val !== 'number') {
+          warn("<transition> explicit " + name + " duration is not a valid number - " +
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn("<transition> explicit " + name + " duration is NaN - " +
+              'the duration expression might be incorrect.', vnode.context);
+      }
   }
-
-  function isValidDuration (val) {
-    return typeof val === 'number' && !isNaN(val)
+  function isValidDuration(val) {
+      return typeof val === 'number' && !isNaN(val);
   }
-
   /**
    * Normalize a transition hook's argument length. The hook may be:
    * - a merged hook (invoker) with the original in .fns
    * - a wrapped component method (check ._length)
    * - a plain function (.length)
    */
-  function getHookArgumentsLength (fn) {
-    if (isUndef(fn)) {
-      return false
-    }
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-      // invoker
-      return getHookArgumentsLength(
-        Array.isArray(invokerFns)
-          ? invokerFns[0]
-          : invokerFns
-      )
-    } else {
-      return (fn._length || fn.length) > 1
-    }
-  }
-
-  function _enter (_, vnode) {
-    if (vnode.data.show !== true) {
-      enter(vnode);
-    }
-  }
-
-  var transition = inBrowser ? {
-    create: _enter,
-    activate: _enter,
-    remove: function remove$$1 (vnode, rm) {
-      /* istanbul ignore else */
+  function getHookArgumentsLength(fn) {
+      if (isUndef(fn)) {
+          return false;
+      }
+      // @ts-expect-error
+      var invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
+  }
+  function _enter(_, vnode) {
       if (vnode.data.show !== true) {
-        leave(vnode, rm);
-      } else {
-        rm();
+          enter(vnode);
+      }
+  }
+  var transition = inBrowser
+      ? {
+          create: _enter,
+          activate: _enter,
+          remove: function remove$$1(vnode, rm) {
+              /* istanbul ignore else */
+              if (vnode.data.show !== true) {
+                  // @ts-expect-error
+                  leave(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          },
       }
-    }
-  } : {};
-
-  var platformModules = [
-    attrs,
-    klass,
-    events,
-    domProps,
-    style,
-    transition
-  ];
+      : {};
 
-  /*  */
+  var platformModules = [attrs, klass, events, domProps, style, transition];
 
+  /* @flow */
   // the directive module should be applied last, after all
   // built-in modules have been applied.
   var modules = platformModules.concat(baseModules);
-
   var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 
   /**
    * Not type checking this file because flow doesn't like attaching
    * properties to Elements.
    */
-
   /* istanbul ignore if */
   if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-      var el = document.activeElement;
-      if (el && el.vmodel) {
-        trigger(el, 'input');
-      }
-    });
+      // http://www.matts411.com/post/internet-explorer-9-oninput/
+      document.addEventListener('selectionchange', function () {
+          var el = document.activeElement;
+          // @ts-expect-error
+          if (el && el.vmodel) {
+              trigger(el, 'input');
+          }
+      });
   }
-
   var directive = {
-    inserted: function inserted (el, binding, vnode, oldVnode) {
-      if (vnode.tag === 'select') {
-        // #6903
-        if (oldVnode.elm && !oldVnode.elm._vOptions) {
-          mergeVNodeHook(vnode, 'postpatch', function () {
-            directive.componentUpdated(el, binding, vnode);
-          });
-        } else {
-          setSelected(el, binding, vnode.context);
-        }
-        el._vOptions = [].map.call(el.options, getValue);
-      } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-        el._vModifiers = binding.modifiers;
-        if (!binding.modifiers.lazy) {
-          el.addEventListener('compositionstart', onCompositionStart);
-          el.addEventListener('compositionend', onCompositionEnd);
-          // Safari < 10.2 & UIWebView doesn't fire compositionend when
-          // switching focus before confirming composition choice
-          // this also fixes the issue where some browsers e.g. iOS Chrome
-          // fires "change" instead of "input" on autocomplete.
-          el.addEventListener('change', onCompositionEnd);
-          /* istanbul ignore if */
-          if (isIE9) {
-            el.vmodel = true;
-          }
-        }
-      }
-    },
-
-    componentUpdated: function componentUpdated (el, binding, vnode) {
-      if (vnode.tag === 'select') {
-        setSelected(el, binding, vnode.context);
-        // in case the options rendered by v-for have changed,
-        // it's possible that the value is out-of-sync with the rendered options.
-        // detect such cases and filter out values that no longer has a matching
-        // option in the DOM.
-        var prevOptions = el._vOptions;
-        var curOptions = el._vOptions = [].map.call(el.options, getValue);
-        if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-          // trigger change event if
-          // no matching option found for at least one value
-          var needReset = el.multiple
-            ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-            : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-          if (needReset) {
-            trigger(el, 'change');
-          }
-        }
-      }
-    }
+      inserted: function inserted(el, binding, vnode, oldVnode) {
+          if (vnode.tag === 'select') {
+              // #6903
+              if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                  mergeVNodeHook(vnode, 'postpatch', function () {
+                      directive.componentUpdated(el, binding, vnode);
+                  });
+              }
+              else {
+                  setSelected(el, binding, vnode.context);
+              }
+              el._vOptions = [].map.call(el.options, getValue);
+          }
+          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+              el._vModifiers = binding.modifiers;
+              if (!binding.modifiers.lazy) {
+                  el.addEventListener('compositionstart', onCompositionStart);
+                  el.addEventListener('compositionend', onCompositionEnd);
+                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                  // switching focus before confirming composition choice
+                  // this also fixes the issue where some browsers e.g. iOS Chrome
+                  // fires "change" instead of "input" on autocomplete.
+                  el.addEventListener('change', onCompositionEnd);
+                  /* istanbul ignore if */
+                  if (isIE9) {
+                      el.vmodel = true;
+                  }
+              }
+          }
+      },
+      componentUpdated: function componentUpdated(el, binding, vnode) {
+          if (vnode.tag === 'select') {
+              setSelected(el, binding, vnode.context);
+              // in case the options rendered by v-for have changed,
+              // it's possible that the value is out-of-sync with the rendered options.
+              // detect such cases and filter out values that no longer has a matching
+              // option in the DOM.
+              var prevOptions = el._vOptions;
+              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                  // trigger change event if
+                  // no matching option found for at least one value
+                  var needReset = el.multiple
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                      : binding.value !== binding.oldValue &&
+                          hasNoMatchingOption(binding.value, curOptions);
+                  if (needReset) {
+                      trigger(el, 'change');
+                  }
+              }
+          }
+      },
   };
-
-  function setSelected (el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-      setTimeout(function () {
-        actuallySetSelected(el, binding, vm);
-      }, 0);
-    }
-  }
-
-  function actuallySetSelected (el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-      warn(
-        "<select multiple v-model=\"" + (binding.expression) + "\"> " +
-        "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
-        vm
-      );
-      return
-    }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
-      option = el.options[i];
-      if (isMultiple) {
-        selected = looseIndexOf(value, getValue(option)) > -1;
-        if (option.selected !== selected) {
-          option.selected = selected;
-        }
-      } else {
-        if (looseEqual(getValue(option), value)) {
-          if (el.selectedIndex !== i) {
-            el.selectedIndex = i;
+  function setSelected(el, binding, vm) {
+      actuallySetSelected(el, binding, vm);
+      /* istanbul ignore if */
+      if (isIE || isEdge) {
+          setTimeout(function () {
+              actuallySetSelected(el, binding, vm);
+          }, 0);
+      }
+  }
+  function actuallySetSelected(el, binding, vm) {
+      var value = binding.value;
+      var isMultiple = el.multiple;
+      if (isMultiple && !Array.isArray(value)) {
+          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                  "expects an Array value for its binding, but got " + (Object.prototype.toString
+                      .call(value)
+                      .slice(8, -1)), vm);
+          return;
+      }
+      var selected, option;
+      for (var i = 0, l = el.options.length; i < l; i++) {
+          option = el.options[i];
+          if (isMultiple) {
+              selected = looseIndexOf(value, getValue(option)) > -1;
+              if (option.selected !== selected) {
+                  option.selected = selected;
+              }
           }
-          return
-        }
+          else {
+              if (looseEqual(getValue(option), value)) {
+                  if (el.selectedIndex !== i) {
+                      el.selectedIndex = i;
+                  }
+                  return;
+              }
+          }
+      }
+      if (!isMultiple) {
+          el.selectedIndex = -1;
       }
-    }
-    if (!isMultiple) {
-      el.selectedIndex = -1;
-    }
   }
-
-  function hasNoMatchingOption (value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); })
+  function hasNoMatchingOption(value, options) {
+      return options.every(function (o) { return !looseEqual(o, value); });
   }
-
-  function getValue (option) {
-    return '_value' in option
-      ? option._value
-      : option.value
+  function getValue(option) {
+      return '_value' in option ? option._value : option.value;
   }
-
-  function onCompositionStart (e) {
-    e.target.composing = true;
+  function onCompositionStart(e) {
+      e.target.composing = true;
   }
-
-  function onCompositionEnd (e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing) { return }
-    e.target.composing = false;
-    trigger(e.target, 'input');
+  function onCompositionEnd(e) {
+      // prevent triggering an input event for no reason
+      if (!e.target.composing)
+          { return; }
+      e.target.composing = false;
+      trigger(e.target, 'input');
   }
-
-  function trigger (el, type) {
-    var e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+  function trigger(el, type) {
+      var e = document.createEvent('HTMLEvents');
+      e.initEvent(type, true, true);
+      el.dispatchEvent(e);
   }
 
-  /*  */
-
+  /* @flow */
   // recursively search for possible transition defined inside the component root
-  function locateNode (vnode) {
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-      ? locateNode(vnode.componentInstance._vnode)
-      : vnode
+  function locateNode(vnode) {
+      // @ts-expect-error
+      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+          ? locateNode(vnode.componentInstance._vnode)
+          : vnode;
   }
-
   var show = {
-    bind: function bind (el, ref, vnode) {
-      var value = ref.value;
-
-      vnode = locateNode(vnode);
-      var transition$$1 = vnode.data && vnode.data.transition;
-      var originalDisplay = el.__vOriginalDisplay =
-        el.style.display === 'none' ? '' : el.style.display;
-      if (value && transition$$1) {
-        vnode.data.show = true;
-        enter(vnode, function () {
-          el.style.display = originalDisplay;
-        });
-      } else {
-        el.style.display = value ? originalDisplay : 'none';
-      }
-    },
-
-    update: function update (el, ref, vnode) {
-      var value = ref.value;
-      var oldValue = ref.oldValue;
+      bind: function bind(el, ref, vnode) {
+          var value = ref.value;
+
+          vnode = locateNode(vnode);
+          var transition$$1 = vnode.data && vnode.data.transition;
+          var originalDisplay = (el.__vOriginalDisplay =
+              el.style.display === 'none' ? '' : el.style.display);
+          if (value && transition$$1) {
+              vnode.data.show = true;
+              enter(vnode, function () {
+                  el.style.display = originalDisplay;
+              });
+          }
+          else {
+              el.style.display = value ? originalDisplay : 'none';
+          }
+      },
+      update: function update(el, ref, vnode) {
+          var value = ref.value;
+          var oldValue = ref.oldValue;
 
-      /* istanbul ignore if */
-      if (!value === !oldValue) { return }
-      vnode = locateNode(vnode);
-      var transition$$1 = vnode.data && vnode.data.transition;
-      if (transition$$1) {
-        vnode.data.show = true;
-        if (value) {
-          enter(vnode, function () {
-            el.style.display = el.__vOriginalDisplay;
-          });
-        } else {
-          leave(vnode, function () {
-            el.style.display = 'none';
-          });
-        }
-      } else {
-        el.style.display = value ? el.__vOriginalDisplay : 'none';
-      }
-    },
-
-    unbind: function unbind (
-      el,
-      binding,
-      vnode,
-      oldVnode,
-      isDestroy
-    ) {
-      if (!isDestroy) {
-        el.style.display = el.__vOriginalDisplay;
-      }
-    }
+          /* istanbul ignore if */
+          if (!value === !oldValue)
+              { return; }
+          vnode = locateNode(vnode);
+          var transition$$1 = vnode.data && vnode.data.transition;
+          if (transition$$1) {
+              vnode.data.show = true;
+              if (value) {
+                  enter(vnode, function () {
+                      el.style.display = el.__vOriginalDisplay;
+                  });
+              }
+              else {
+                  leave(vnode, function () {
+                      el.style.display = 'none';
+                  });
+              }
+          }
+          else {
+              el.style.display = value ? el.__vOriginalDisplay : 'none';
+          }
+      },
+      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+          if (!isDestroy) {
+              el.style.display = el.__vOriginalDisplay;
+          }
+      },
   };
 
   var platformDirectives = {
-    model: directive,
-    show: show
+      model: directive,
+      show: show,
   };
 
-  /*  */
-
+  /* @flow */
   var transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object]
+      name: String,
+      appear: Boolean,
+      css: Boolean,
+      mode: String,
+      type: String,
+      enterClass: String,
+      leaveClass: String,
+      enterToClass: String,
+      leaveToClass: String,
+      enterActiveClass: String,
+      leaveActiveClass: String,
+      appearClass: String,
+      appearActiveClass: String,
+      appearToClass: String,
+      duration: [Number, String, Object],
   };
-
   // in case the child is also an abstract component, e.g. <keep-alive>
   // we want to recursively retrieve the real component to be rendered
-  function getRealChild (vnode) {
-    var compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-      return getRealChild(getFirstComponentChild(compOptions.children))
-    } else {
-      return vnode
-    }
-  }
-
-  function extractTransitionData (comp) {
-    var data = {};
-    var options = comp.$options;
-    // props
-    for (var key in options.propsData) {
-      data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-      data[camelize(key$1)] = listeners[key$1];
-    }
-    return data
-  }
-
-  function placeholder (h, rawChild) {
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-      return h('keep-alive', {
-        props: rawChild.componentOptions.propsData
-      })
-    }
+  function getRealChild(vnode) {
+      var compOptions = vnode && vnode.componentOptions;
+      if (compOptions && compOptions.Ctor.options.abstract) {
+          return getRealChild(getFirstComponentChild(compOptions.children));
+      }
+      else {
+          return vnode;
+      }
+  }
+  function extractTransitionData(comp) {
+      var data = {};
+      var options = comp.$options;
+      // props
+      for (var key in options.propsData) {
+          data[key] = comp[key];
+      }
+      // events.
+      // extract listeners and pass them directly to the transition methods
+      var listeners = options._parentListeners;
+      for (var key$1 in listeners) {
+          data[camelize(key$1)] = listeners[key$1];
+      }
+      return data;
+  }
+  function placeholder(h, rawChild) {
+      // @ts-expect-error
+      if (/\d-keep-alive$/.test(rawChild.tag)) {
+          return h('keep-alive', {
+              props: rawChild.componentOptions.propsData,
+          });
+      }
   }
-
-  function hasParentTransition (vnode) {
-    while ((vnode = vnode.parent)) {
-      if (vnode.data.transition) {
-        return true
+  function hasParentTransition(vnode) {
+      while ((vnode = vnode.parent)) {
+          if (vnode.data.transition) {
+              return true;
+          }
       }
-    }
   }
-
-  function isSameChild (child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag
+  function isSameChild(child, oldChild) {
+      return oldChild.key === child.key && oldChild.tag === child.tag;
   }
-
   var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
   var isVShowDirective = function (d) { return d.name === 'show'; };
-
   var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-
-    render: function render (h) {
-      var this$1 = this;
-
-      var children = this.$slots.default;
-      if (!children) {
-        return
-      }
-
-      // filter out text nodes (possible whitespaces)
-      children = children.filter(isNotTextNode);
-      /* istanbul ignore if */
-      if (!children.length) {
-        return
-      }
-
-      // warn multiple elements
-      if (children.length > 1) {
-        warn(
-          '<transition> can only be used on a single element. Use ' +
-          '<transition-group> for lists.',
-          this.$parent
-        );
-      }
-
-      var mode = this.mode;
-
-      // warn invalid mode
-      if (mode && mode !== 'in-out' && mode !== 'out-in'
-      ) {
-        warn(
-          'invalid <transition> mode: ' + mode,
-          this.$parent
-        );
-      }
-
-      var rawChild = children[0];
-
-      // if this is a component root node and the component's
-      // parent container node also has transition, skip.
-      if (hasParentTransition(this.$vnode)) {
-        return rawChild
-      }
-
-      // apply transition data to child
-      // use getRealChild() to ignore abstract components e.g. keep-alive
-      var child = getRealChild(rawChild);
-      /* istanbul ignore if */
-      if (!child) {
-        return rawChild
-      }
-
-      if (this._leaving) {
-        return placeholder(h, rawChild)
-      }
-
-      // ensure a key that is unique to the vnode type and to this transition
-      // component instance. This key will be used to remove pending leaving nodes
-      // during entering.
-      var id = "__transition-" + (this._uid) + "-";
-      child.key = child.key == null
-        ? child.isComment
-          ? id + 'comment'
-          : id + child.tag
-        : isPrimitive(child.key)
-          ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-          : child.key;
-
-      var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-      var oldRawChild = this._vnode;
-      var oldChild = getRealChild(oldRawChild);
-
-      // mark v-show
-      // so that the transition module can hand over the control to the directive
-      if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-        child.data.show = true;
-      }
-
-      if (
-        oldChild &&
-        oldChild.data &&
-        !isSameChild(child, oldChild) &&
-        !isAsyncPlaceholder(oldChild) &&
-        // #6687 component root is a comment node
-        !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-      ) {
-        // replace old child transition data with fresh one
-        // important for dynamic transitions!
-        var oldData = oldChild.data.transition = extend({}, data);
-        // handle transition mode
-        if (mode === 'out-in') {
-          // return placeholder node and queue update when leave finishes
-          this._leaving = true;
-          mergeVNodeHook(oldData, 'afterLeave', function () {
-            this$1._leaving = false;
-            this$1.$forceUpdate();
-          });
-          return placeholder(h, rawChild)
-        } else if (mode === 'in-out') {
-          if (isAsyncPlaceholder(child)) {
-            return oldRawChild
+      name: 'transition',
+      props: transitionProps,
+      abstract: true,
+      render: function render(h) {
+          var this$1 = this;
+
+          var children = this.$slots.default;
+          if (!children) {
+              return;
           }
-          var delayedLeave;
-          var performLeave = function () { delayedLeave(); };
-          mergeVNodeHook(data, 'afterEnter', performLeave);
-          mergeVNodeHook(data, 'enterCancelled', performLeave);
-          mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-        }
-      }
-
-      return rawChild
-    }
+          // filter out text nodes (possible whitespaces)
+          children = children.filter(isNotTextNode);
+          /* istanbul ignore if */
+          if (!children.length) {
+              return;
+          }
+          // warn multiple elements
+          if (children.length > 1) {
+              warn('<transition> can only be used on a single element. Use ' +
+                  '<transition-group> for lists.', this.$parent);
+          }
+          var mode = this.mode;
+          // warn invalid mode
+          if (mode &&
+              mode !== 'in-out' &&
+              mode !== 'out-in') {
+              warn('invalid <transition> mode: ' + mode, this.$parent);
+          }
+          var rawChild = children[0];
+          // if this is a component root node and the component's
+          // parent container node also has transition, skip.
+          if (hasParentTransition(this.$vnode)) {
+              return rawChild;
+          }
+          // apply transition data to child
+          // use getRealChild() to ignore abstract components e.g. keep-alive
+          var child = getRealChild(rawChild);
+          /* istanbul ignore if */
+          if (!child) {
+              return rawChild;
+          }
+          if (this._leaving) {
+              return placeholder(h, rawChild);
+          }
+          // ensure a key that is unique to the vnode type and to this transition
+          // component instance. This key will be used to remove pending leaving nodes
+          // during entering.
+          var id = "__transition-" + (this._uid) + "-";
+          child.key =
+              child.key == null
+                  ? child.isComment
+                      ? id + 'comment'
+                      : id + child.tag
+                  : isPrimitive(child.key)
+                      ? String(child.key).indexOf(id) === 0
+                          ? child.key
+                          : id + child.key
+                      : child.key;
+          var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          var oldRawChild = this._vnode;
+          var oldChild = getRealChild(oldRawChild);
+          // mark v-show
+          // so that the transition module can hand over the control to the directive
+          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+              child.data.show = true;
+          }
+          if (oldChild &&
+              oldChild.data &&
+              !isSameChild(child, oldChild) &&
+              !isAsyncPlaceholder(oldChild) &&
+              // #6687 component root is a comment node
+              !(oldChild.componentInstance &&
+                  oldChild.componentInstance._vnode.isComment)) {
+              // replace old child transition data with fresh one
+              // important for dynamic transitions!
+              var oldData = (oldChild.data.transition = extend({}, data));
+              // handle transition mode
+              if (mode === 'out-in') {
+                  // return placeholder node and queue update when leave finishes
+                  this._leaving = true;
+                  mergeVNodeHook(oldData, 'afterLeave', function () {
+                      this$1._leaving = false;
+                      this$1.$forceUpdate();
+                  });
+                  return placeholder(h, rawChild);
+              }
+              else if (mode === 'in-out') {
+                  if (isAsyncPlaceholder(child)) {
+                      return oldRawChild;
+                  }
+                  var delayedLeave;
+                  var performLeave = function () {
+                      delayedLeave();
+                  };
+                  mergeVNodeHook(data, 'afterEnter', performLeave);
+                  mergeVNodeHook(data, 'enterCancelled', performLeave);
+                  mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                      delayedLeave = leave;
+                  });
+              }
+          }
+          return rawChild;
+      },
   };
 
-  /*  */
-
+  // Provides transition support for list items.
   var props = extend({
-    tag: String,
-    moveClass: String
+      tag: String,
+      moveClass: String,
   }, transitionProps);
-
+  // @ts-ignore
   delete props.mode;
-
   var TransitionGroup = {
-    props: props,
-
-    beforeMount: function beforeMount () {
-      var this$1 = this;
-
-      var update = this._update;
-      this._update = function (vnode, hydrating) {
-        var restoreActiveInstance = setActiveInstance(this$1);
-        // force removing pass
-        this$1.__patch__(
-          this$1._vnode,
-          this$1.kept,
-          false, // hydrating
-          true // removeOnly (!important, avoids unnecessary moves)
-        );
-        this$1._vnode = this$1.kept;
-        restoreActiveInstance();
-        update.call(this$1, vnode, hydrating);
-      };
-    },
-
-    render: function render (h) {
-      var tag = this.tag || this.$vnode.data.tag || 'span';
-      var map = Object.create(null);
-      var prevChildren = this.prevChildren = this.children;
-      var rawChildren = this.$slots.default || [];
-      var children = this.children = [];
-      var transitionData = extractTransitionData(this);
-
-      for (var i = 0; i < rawChildren.length; i++) {
-        var c = rawChildren[i];
-        if (c.tag) {
-          if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-            children.push(c);
-            map[c.key] = c
-            ;(c.data || (c.data = {})).transition = transitionData;
-          } else {
-            var opts = c.componentOptions;
-            var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-            warn(("<transition-group> children must be keyed: <" + name + ">"));
-          }
-        }
-      }
-
-      if (prevChildren) {
-        var kept = [];
-        var removed = [];
-        for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-          var c$1 = prevChildren[i$1];
-          c$1.data.transition = transitionData;
-          c$1.data.pos = c$1.elm.getBoundingClientRect();
-          if (map[c$1.key]) {
-            kept.push(c$1);
-          } else {
-            removed.push(c$1);
-          }
-        }
-        this.kept = h(tag, null, kept);
-        this.removed = removed;
-      }
-
-      return h(tag, null, children)
-    },
-
-    updated: function updated () {
-      var children = this.prevChildren;
-      var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-      if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-        return
-      }
-
-      // we divide the work into three loops to avoid mixing DOM reads and writes
-      // in each iteration - which helps prevent layout thrashing.
-      children.forEach(callPendingCbs);
-      children.forEach(recordPosition);
-      children.forEach(applyTranslation);
-
-      // force reflow to put everything in position
-      // assign to this to avoid being removed in tree-shaking
-      // $flow-disable-line
-      this._reflow = document.body.offsetHeight;
-
-      children.forEach(function (c) {
-        if (c.data.moved) {
-          var el = c.elm;
-          var s = el.style;
-          addTransitionClass(el, moveClass);
-          s.transform = s.WebkitTransform = s.transitionDuration = '';
-          el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-            if (e && e.target !== el) {
-              return
-            }
-            if (!e || /transform$/.test(e.propertyName)) {
-              el.removeEventListener(transitionEndEvent, cb);
-              el._moveCb = null;
-              removeTransitionClass(el, moveClass);
-            }
+      props: props,
+      beforeMount: function beforeMount() {
+          var this$1 = this;
+
+          var update = this._update;
+          this._update = function (vnode, hydrating) {
+              var restoreActiveInstance = setActiveInstance(this$1);
+              // force removing pass
+              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              true // removeOnly (!important, avoids unnecessary moves)
+              );
+              this$1._vnode = this$1.kept;
+              restoreActiveInstance();
+              update.call(this$1, vnode, hydrating);
+          };
+      },
+      render: function render(h) {
+          var tag = this.tag || this.$vnode.data.tag || 'span';
+          var map = Object.create(null);
+          var prevChildren = (this.prevChildren = this.children);
+          var rawChildren = this.$slots.default || [];
+          var children = (this.children = []);
+          var transitionData = extractTransitionData(this);
+          for (var i = 0; i < rawChildren.length; i++) {
+              var c = rawChildren[i];
+              if (c.tag) {
+                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                      children.push(c);
+                      map[c.key] = c;
+                      (c.data || (c.data = {})).transition = transitionData;
+                  }
+                  else {
+                      var opts = c.componentOptions;
+                      var name = opts
+                          ? opts.Ctor.options.name || opts.tag || ''
+                          : c.tag;
+                      warn(("<transition-group> children must be keyed: <" + name + ">"));
+                  }
+              }
+          }
+          if (prevChildren) {
+              var kept = [];
+              var removed = [];
+              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                  var c$1 = prevChildren[i$1];
+                  c$1.data.transition = transitionData;
+                  // @ts-ignore
+                  c$1.data.pos = c$1.elm.getBoundingClientRect();
+                  // @ts-ignore
+                  if (map[c$1.key]) {
+                      kept.push(c$1);
+                  }
+                  else {
+                      removed.push(c$1);
+                  }
+              }
+              this.kept = h(tag, null, kept);
+              this.removed = removed;
+          }
+          return h(tag, null, children);
+      },
+      updated: function updated() {
+          var children = this.prevChildren;
+          var moveClass = this.moveClass || (this.name || 'v') + '-move';
+          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+              return;
+          }
+          // we divide the work into three loops to avoid mixing DOM reads and writes
+          // in each iteration - which helps prevent layout thrashing.
+          children.forEach(callPendingCbs);
+          children.forEach(recordPosition);
+          children.forEach(applyTranslation);
+          // force reflow to put everything in position
+          // assign to this to avoid being removed in tree-shaking
+          // $flow-disable-line
+          this._reflow = document.body.offsetHeight;
+          children.forEach(function (c) {
+              // @ts-ignore
+              if (c.data.moved) {
+                  var el = c.elm;
+                  var s = el.style;
+                  addTransitionClass(el, moveClass);
+                  s.transform = s.WebkitTransform = s.transitionDuration = '';
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
+                          return;
+                      }
+                      if (!e || /transform$/.test(e.propertyName)) {
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
+                      }
+                  }));
+              }
           });
-        }
-      });
-    },
-
-    methods: {
-      hasMove: function hasMove (el, moveClass) {
-        /* istanbul ignore if */
-        if (!hasTransition) {
-          return false
-        }
-        /* istanbul ignore if */
-        if (this._hasMove) {
-          return this._hasMove
-        }
-        // Detect whether an element with the move class applied has
-        // CSS transitions. Since the element may be inside an entering
-        // transition at this very moment, we make a clone of it and remove
-        // all other transition classes applied to ensure only the move class
-        // is applied.
-        var clone = el.cloneNode();
-        if (el._transitionClasses) {
-          el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
-        }
-        addClass(clone, moveClass);
-        clone.style.display = 'none';
-        this.$el.appendChild(clone);
-        var info = getTransitionInfo(clone);
-        this.$el.removeChild(clone);
-        return (this._hasMove = info.hasTransform)
-      }
-    }
+      },
+      methods: {
+          hasMove: function hasMove(el, moveClass) {
+              /* istanbul ignore if */
+              if (!hasTransition) {
+                  return false;
+              }
+              /* istanbul ignore if */
+              if (this._hasMove) {
+                  return this._hasMove;
+              }
+              // Detect whether an element with the move class applied has
+              // CSS transitions. Since the element may be inside an entering
+              // transition at this very moment, we make a clone of it and remove
+              // all other transition classes applied to ensure only the move class
+              // is applied.
+              var clone = el.cloneNode();
+              if (el._transitionClasses) {
+                  el._transitionClasses.forEach(function (cls) {
+                      removeClass(clone, cls);
+                  });
+              }
+              addClass(clone, moveClass);
+              clone.style.display = 'none';
+              this.$el.appendChild(clone);
+              var info = getTransitionInfo(clone);
+              this.$el.removeChild(clone);
+              return (this._hasMove = info.hasTransform);
+          },
+      },
   };
-
-  function callPendingCbs (c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-      c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-      c.elm._enterCb();
-    }
+  function callPendingCbs(c) {
+      /* istanbul ignore if */
+      //@ts-ignore
+      if (c.elm._moveCb) {
+          //@ts-ignore
+          c.elm._moveCb();
+      }
+      /* istanbul ignore if */
+      //@ts-ignore
+      if (c.elm._enterCb) {
+          //@ts-ignore
+          c.elm._enterCb();
+      }
   }
-
-  function recordPosition (c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
+  function recordPosition(c) {
+      //@ts-ignore
+      c.data.newPos = c.elm.getBoundingClientRect();
   }
-
-  function applyTranslation (c) {
-    var oldPos = c.data.pos;
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-      c.data.moved = true;
-      var s = c.elm.style;
-      s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-      s.transitionDuration = '0s';
-    }
+  function applyTranslation(c) {
+      //@ts-ignore
+      var oldPos = c.data.pos;
+      //@ts-ignore
+      var newPos = c.data.newPos;
+      var dx = oldPos.left - newPos.left;
+      var dy = oldPos.top - newPos.top;
+      if (dx || dy) {
+          //@ts-ignore
+          c.data.moved = true;
+          //@ts-ignore
+          var s = c.elm.style;
+          s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+          s.transitionDuration = '0s';
+      }
   }
 
   var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup
+      Transition: Transition,
+      TransitionGroup: TransitionGroup,
   };
 
-  /*  */
-
   // install platform specific utils
   Vue.config.mustUseProp = mustUseProp;
   Vue.config.isReservedTag = isReservedTag;
   Vue.config.isReservedAttr = isReservedAttr;
   Vue.config.getTagNamespace = getTagNamespace;
   Vue.config.isUnknownElement = isUnknownElement;
-
   // install platform runtime directives & components
   extend(Vue.options.directives, platformDirectives);
   extend(Vue.options.components, platformComponents);
-
   // install platform patch function
   Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
   // public mount method
-  Vue.prototype.$mount = function (
-    el,
-    hydrating
-  ) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating)
+  Vue.prototype.$mount = function (el, hydrating) {
+      el = el && inBrowser ? query(el) : undefined;
+      return mountComponent(this, el, hydrating);
   };
-
   // devtools global hook
   /* istanbul ignore next */
   if (inBrowser) {
-    setTimeout(function () {
-      if (config.devtools) {
-        if (devtools) {
-          devtools.emit('init', Vue);
-        } else {
-          console[console.info ? 'info' : 'log'](
-            'Download the Vue Devtools extension for a better development experience:\n' +
-            'https://github.com/vuejs/vue-devtools'
-          );
-        }
-      }
-      if (config.productionTip !== false &&
-        typeof console !== 'undefined'
-      ) {
-        console[console.info ? 'info' : 'log'](
-          "You are running Vue in development mode.\n" +
-          "Make sure to turn on production mode when deploying for production.\n" +
-          "See more tips at https://vuejs.org/guide/deployment.html"
-        );
-      }
-    }, 0);
+      setTimeout(function () {
+          if (config.devtools) {
+              if (devtools) {
+                  devtools.emit('init', Vue);
+              }
+              else {
+                  // @ts-expect-error
+                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                      'https://github.com/vuejs/vue-devtools');
+              }
+          }
+          if (config.productionTip !== false &&
+              typeof console !== 'undefined') {
+              // @ts-expect-error
+              console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                  "Make sure to turn on production mode when deploying for production.\n" +
+                  "See more tips at https://vuejs.org/guide/deployment.html");
+          }
+      }, 0);
   }
 
-  /*  */
-
+  /* @flow */
   var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
   var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+      var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
   });
-
-
-
-  function parseText (
-    text,
-    delimiters
-  ) {
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-      return
-    }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = tagRE.lastIndex = 0;
-    var match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-      index = match.index;
-      // push text token
-      if (index > lastIndex) {
-        rawTokens.push(tokenValue = text.slice(lastIndex, index));
-        tokens.push(JSON.stringify(tokenValue));
-      }
-      // tag token
-      var exp = parseFilters(match[1].trim());
-      tokens.push(("_s(" + exp + ")"));
-      rawTokens.push({ '@binding': exp });
-      lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      rawTokens.push(tokenValue = text.slice(lastIndex));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
-    }
-  }
-
-  /*  */
-
-  function transformNode (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-      var res = parseText(staticClass, options.delimiters);
-      if (res) {
-        warn(
-          "class=\"" + staticClass + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div class="{{ val }}">, use <div :class="val">.',
-          el.rawAttrsMap['class']
-        );
-      }
-    }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass);
-    }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-      el.classBinding = classBinding;
-    }
-  }
-
-  function genData (el) {
-    var data = '';
-    if (el.staticClass) {
-      data += "staticClass:" + (el.staticClass) + ",";
-    }
-    if (el.classBinding) {
-      data += "class:" + (el.classBinding) + ",";
-    }
-    return data
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      var tokens = [];
+      var rawTokens = [];
+      var lastIndex = (tagRE.lastIndex = 0);
+      var match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          var exp = parseFilters(match[1].trim());
+          tokens.push(("_s(" + exp + ")"));
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
   }
 
+  /* @flow */
+  function transformNode(el, options) {
+      var warn = options.warn || baseWarn;
+      var staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          var res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn("class=\"" + staticClass + "\": " +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
+      }
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass);
+      }
+      var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
+      }
+  }
+  function genData(el) {
+      var data = '';
+      if (el.staticClass) {
+          data += "staticClass:" + (el.staticClass) + ",";
+      }
+      if (el.classBinding) {
+          data += "class:" + (el.classBinding) + ",";
+      }
+      return data;
+  }
   var klass$1 = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData
+      staticKeys: ['staticClass'],
+      transformNode: transformNode,
+      genData: genData,
   };
 
-  /*  */
-
-  function transformNode$1 (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-      /* istanbul ignore if */
-      {
-        var res = parseText(staticStyle, options.delimiters);
-        if (res) {
-          warn(
-            "style=\"" + staticStyle + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div style="{{ val }}">, use <div :style="val">.',
-            el.rawAttrsMap['style']
-          );
-        }
+  /* @flow */
+  function transformNode$1(el, options) {
+      var warn = options.warn || baseWarn;
+      var staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              var res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn("style=\"" + staticStyle + "\": " +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
       }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-      el.styleBinding = styleBinding;
-    }
   }
-
-  function genData$1 (el) {
-    var data = '';
-    if (el.staticStyle) {
-      data += "staticStyle:" + (el.staticStyle) + ",";
-    }
-    if (el.styleBinding) {
-      data += "style:(" + (el.styleBinding) + "),";
-    }
-    return data
+  function genData$1(el) {
+      var data = '';
+      if (el.staticStyle) {
+          data += "staticStyle:" + (el.staticStyle) + ",";
+      }
+      if (el.styleBinding) {
+          data += "style:(" + (el.styleBinding) + "),";
+      }
+      return data;
   }
-
   var style$1 = {
-    staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
-    genData: genData$1
-  };
-
-  /*  */
-
-  var decoder;
-
-  var he = {
-    decode: function decode (html) {
-      decoder = decoder || document.createElement('div');
-      decoder.innerHTML = html;
-      return decoder.textContent
-    }
+      staticKeys: ['staticStyle'],
+      transformNode: transformNode$1,
+      genData: genData$1,
   };
 
-  /*  */
+  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+  (function(root) {
+
+  	// Detect free variables `exports`.
+  	var freeExports = typeof exports == 'object' && exports;
+
+  	// Detect free variable `module`.
+  	var freeModule = typeof module == 'object' && module &&
+  		module.exports == freeExports && module;
+
+  	// Detect free variable `global`, from Node.js or Browserified code,
+  	// and use it as `root`.
+  	var freeGlobal = typeof global == 'object' && global;
+  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+  		root = freeGlobal;
+  	}
+
+  	/*--------------------------------------------------------------------------*/
+
+  	// All astral symbols.
+  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  	// All ASCII symbols (not just printable ASCII) except those listed in the
+  	// first column of the overrides table.
+  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
+  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+  	// code points listed in the first column of the overrides table on
+  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+  	var regexEscape = /["&'<>`]/g;
+  	var escapeMap = {
+  		'"': '&quot;',
+  		'&': '&amp;',
+  		'\'': '&#x27;',
+  		'<': '&lt;',
+  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+  		// following is not strictly necessary unless it’s part of a tag or an
+  		// unquoted attribute value. We’re only escaping it to support those
+  		// situations, and for XML support.
+  		'>': '&gt;',
+  		// In Internet Explorer ≤ 8, the backtick character can be used
+  		// to break out of (un)quoted attribute values or HTML comments.
+  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
+  		// http://html5sec.org/#133.
+  		'`': '&#x60;'
+  	};
+
+  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var stringFromCharCode = String.fromCharCode;
+
+  	var object = {};
+  	var hasOwnProperty = object.hasOwnProperty;
+  	var has = function(object, propertyName) {
+  		return hasOwnProperty.call(object, propertyName);
+  	};
+
+  	var contains = function(array, value) {
+  		var index = -1;
+  		var length = array.length;
+  		while (++index < length) {
+  			if (array[index] == value) {
+  				return true;
+  			}
+  		}
+  		return false;
+  	};
+
+  	var merge = function(options, defaults) {
+  		if (!options) {
+  			return defaults;
+  		}
+  		var result = {};
+  		var key;
+  		for (key in defaults) {
+  			// A `hasOwnProperty` check is not needed here, since only recognized
+  			// option names are used anyway. Any others are ignored.
+  			result[key] = has(options, key) ? options[key] : defaults[key];
+  		}
+  		return result;
+  	};
+
+  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
+  	var codePointToSymbol = function(codePoint, strict) {
+  		var output = '';
+  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+  			// See issue #4:
+  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+  			// REPLACEMENT CHARACTER.”
+  			if (strict) {
+  				parseError('character reference outside the permissible Unicode range');
+  			}
+  			return '\uFFFD';
+  		}
+  		if (has(decodeMapNumeric, codePoint)) {
+  			if (strict) {
+  				parseError('disallowed character reference');
+  			}
+  			return decodeMapNumeric[codePoint];
+  		}
+  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+  			parseError('disallowed character reference');
+  		}
+  		if (codePoint > 0xFFFF) {
+  			codePoint -= 0x10000;
+  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+  			codePoint = 0xDC00 | codePoint & 0x3FF;
+  		}
+  		output += stringFromCharCode(codePoint);
+  		return output;
+  	};
+
+  	var hexEscape = function(codePoint) {
+  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+  	};
+
+  	var decEscape = function(codePoint) {
+  		return '&#' + codePoint + ';';
+  	};
+
+  	var parseError = function(message) {
+  		throw Error('Parse error: ' + message);
+  	};
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var encode = function(string, options) {
+  		options = merge(options, encode.options);
+  		var strict = options.strict;
+  		if (strict && regexInvalidRawCodePoint.test(string)) {
+  			parseError('forbidden code point');
+  		}
+  		var encodeEverything = options.encodeEverything;
+  		var useNamedReferences = options.useNamedReferences;
+  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
+  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+  		var escapeBmpSymbol = function(symbol) {
+  			return escapeCodePoint(symbol.charCodeAt(0));
+  		};
+
+  		if (encodeEverything) {
+  			// Encode ASCII symbols.
+  			string = string.replace(regexAsciiWhitelist, function(symbol) {
+  				// Use named references if requested & possible.
+  				if (useNamedReferences && has(encodeMap, symbol)) {
+  					return '&' + encodeMap[symbol] + ';';
+  				}
+  				return escapeBmpSymbol(symbol);
+  			});
+  			// Shorten a few escapes that represent two symbols, of which at least one
+  			// is within the ASCII range.
+  			if (useNamedReferences) {
+  				string = string
+  					.replace(/&gt;\u20D2/g, '&nvgt;')
+  					.replace(/&lt;\u20D2/g, '&nvlt;')
+  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
+  			}
+  			// Encode non-ASCII symbols.
+  			if (useNamedReferences) {
+  				// Encode non-ASCII symbols that can be replaced with a named reference.
+  				string = string.replace(regexEncodeNonAscii, function(string) {
+  					// Note: there is no need to check `has(encodeMap, string)` here.
+  					return '&' + encodeMap[string] + ';';
+  				});
+  			}
+  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+  		} else if (useNamedReferences) {
+  			// Apply named character references.
+  			// Encode `<>"'&` using named character references.
+  			if (!allowUnsafeSymbols) {
+  				string = string.replace(regexEscape, function(string) {
+  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+  				});
+  			}
+  			// Shorten escapes that represent two symbols, of which at least one is
+  			// `<>"'&`.
+  			string = string
+  				.replace(/&gt;\u20D2/g, '&nvgt;')
+  				.replace(/&lt;\u20D2/g, '&nvlt;');
+  			// Encode non-ASCII symbols that can be replaced with a named reference.
+  			string = string.replace(regexEncodeNonAscii, function(string) {
+  				// Note: there is no need to check `has(encodeMap, string)` here.
+  				return '&' + encodeMap[string] + ';';
+  			});
+  		} else if (!allowUnsafeSymbols) {
+  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+  			// using named character references.
+  			string = string.replace(regexEscape, escapeBmpSymbol);
+  		}
+  		return string
+  			// Encode astral symbols.
+  			.replace(regexAstralSymbols, function($0) {
+  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+  				var high = $0.charCodeAt(0);
+  				var low = $0.charCodeAt(1);
+  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+  				return escapeCodePoint(codePoint);
+  			})
+  			// Encode any remaining BMP symbols that are not printable ASCII symbols
+  			// using a hexadecimal escape.
+  			.replace(regexBmpWhitelist, escapeBmpSymbol);
+  	};
+  	// Expose default options (so they can be overridden globally).
+  	encode.options = {
+  		'allowUnsafeSymbols': false,
+  		'encodeEverything': false,
+  		'strict': false,
+  		'useNamedReferences': false,
+  		'decimal' : false
+  	};
+
+  	var decode = function(html, options) {
+  		options = merge(options, decode.options);
+  		var strict = options.strict;
+  		if (strict && regexInvalidEntity.test(html)) {
+  			parseError('malformed character reference');
+  		}
+  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+  			var codePoint;
+  			var semicolon;
+  			var decDigits;
+  			var hexDigits;
+  			var reference;
+  			var next;
+
+  			if ($1) {
+  				reference = $1;
+  				// Note: there is no need to check `has(decodeMap, reference)`.
+  				return decodeMap[reference];
+  			}
+
+  			if ($2) {
+  				// Decode named character references without trailing `;`, e.g. `&amp`.
+  				// This is only a parse error if it gets converted to `&`, or if it is
+  				// followed by `=` in an attribute context.
+  				reference = $2;
+  				next = $3;
+  				if (next && options.isAttributeValue) {
+  					if (strict && next == '=') {
+  						parseError('`&` did not start a character reference');
+  					}
+  					return $0;
+  				} else {
+  					if (strict) {
+  						parseError(
+  							'named character reference was not terminated by a semicolon'
+  						);
+  					}
+  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+  					return decodeMapLegacy[reference] + (next || '');
+  				}
+  			}
+
+  			if ($4) {
+  				// Decode decimal escapes, e.g. `&#119558;`.
+  				decDigits = $4;
+  				semicolon = $5;
+  				if (strict && !semicolon) {
+  					parseError('character reference was not terminated by a semicolon');
+  				}
+  				codePoint = parseInt(decDigits, 10);
+  				return codePointToSymbol(codePoint, strict);
+  			}
+
+  			if ($6) {
+  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+  				hexDigits = $6;
+  				semicolon = $7;
+  				if (strict && !semicolon) {
+  					parseError('character reference was not terminated by a semicolon');
+  				}
+  				codePoint = parseInt(hexDigits, 16);
+  				return codePointToSymbol(codePoint, strict);
+  			}
+
+  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+  			if (strict) {
+  				parseError(
+  					'named character reference was not terminated by a semicolon'
+  				);
+  			}
+  			return $0;
+  		});
+  	};
+  	// Expose default options (so they can be overridden globally).
+  	decode.options = {
+  		'isAttributeValue': false,
+  		'strict': false
+  	};
+
+  	var escape = function(string) {
+  		return string.replace(regexEscape, function($0) {
+  			// Note: there is no need to check `has(escapeMap, $0)` here.
+  			return escapeMap[$0];
+  		});
+  	};
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var he = {
+  		'version': '1.2.0',
+  		'encode': encode,
+  		'decode': decode,
+  		'escape': escape,
+  		'unescape': decode
+  	};
+
+  	// Some AMD build optimizers, like r.js, check for specific condition patterns
+  	// like the following:
+  	if (
+  		typeof define == 'function' &&
+  		typeof define.amd == 'object' &&
+  		define.amd
+  	) {
+  		define(function() {
+  			return he;
+  		});
+  	}	else if (freeExports && !freeExports.nodeType) {
+  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+  			freeModule.exports = he;
+  		} else { // in Narwhal or RingoJS v0.7.0-
+  			for (var key in he) {
+  				has(he, key) && (freeExports[key] = he[key]);
+  			}
+  		}
+  	} else { // in Rhino or a web browser
+  		root.he = he;
+  	}
+
+  }(undefined));
+
+  var he = /*#__PURE__*/Object.freeze({
 
-  var isUnaryTag = makeMap(
-    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr'
-  );
+  });
 
+  /* @flow */
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap(
-    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-  );
-
+  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap(
-    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track'
-  );
+  var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
 
   /**
    * Not type-checking this file because it's mostly vendor code.
    */
-
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
   var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -9257,309 +8535,287 @@
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
   var conditionalComment = /^<!\[/;
-
   // Special Elements (can contain anything)
   var isPlainTextElement = makeMap('script,style,textarea', true);
   var reCache = {};
-
   var decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'"
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
   };
   var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
   var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+  function decodeAttr(value, shouldDecodeNewlines) {
+      var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, function (match) { return decodingMap[match]; });
+  }
+  function parseHTML(html, options) {
+      var stack = [];
+      var expectHTML = options.expectHTML;
+      var isUnaryTag$$1 = options.isUnaryTag || no;
+      var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+      var index = 0;
+      var last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              var textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      var commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      var conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  var doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  var endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      var curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  var startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              var text = (void 0), rest = (void 0), next = (void 0);
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          { break; }
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
+              }
+          }
+          else {
+              var endTagLength = 0;
+              var stackedTag = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest$1.length;
+              html = rest$1;
+              parseEndTag(stackedTag, index - endTagLength, index);
+          }
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                      start: index + html.length,
+                  });
+              }
+              break;
+          }
+      }
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          var start = html.match(startTagOpen);
+          if (start) {
+              var match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              var end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
+      }
+      function handleStartTag(match) {
+          var tagName = match.tagName;
+          var unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+          var l = match.attrs.length;
+          var attrs = new Array(l);
+          for (var i = 0; i < l; i++) {
+              var args = match.attrs[i];
+              var value = args[3] || args[4] || args[5] || '';
+              var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
+          }
+      }
+      function parseEndTag(tagName, start, end) {
+          var pos, lowerCasedTagName;
+          if (start == null)
+              { start = index; }
+          if (end == null)
+              { end = index; }
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (var i = stack.length - 1; i >= pos; i--) {
+                  if (i > pos || !tagName &&
+                      options.warn) {
+                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
+          }
+      }
+  }
 
-  function decodeAttr (value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; })
-  }
-
-  function parseHTML (html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
-    while (html) {
-      last = html;
-      // Make sure we're not in a plaintext content element like script/style
-      if (!lastTag || !isPlainTextElement(lastTag)) {
-        var textEnd = html.indexOf('<');
-        if (textEnd === 0) {
-          // Comment:
-          if (comment.test(html)) {
-            var commentEnd = html.indexOf('-->');
-
-            if (commentEnd >= 0) {
-              if (options.shouldKeepComment) {
-                options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-              }
-              advance(commentEnd + 3);
-              continue
-            }
-          }
-
-          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (conditionalComment.test(html)) {
-            var conditionalEnd = html.indexOf(']>');
-
-            if (conditionalEnd >= 0) {
-              advance(conditionalEnd + 2);
-              continue
-            }
-          }
-
-          // Doctype:
-          var doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length);
-            continue
-          }
-
-          // End tag:
-          var endTagMatch = html.match(endTag);
-          if (endTagMatch) {
-            var curIndex = index;
-            advance(endTagMatch[0].length);
-            parseEndTag(endTagMatch[1], curIndex, index);
-            continue
-          }
-
-          // Start tag:
-          var startTagMatch = parseStartTag();
-          if (startTagMatch) {
-            handleStartTag(startTagMatch);
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1);
-            }
-            continue
-          }
-        }
-
-        var text = (void 0), rest = (void 0), next = (void 0);
-        if (textEnd >= 0) {
-          rest = html.slice(textEnd);
-          while (
-            !endTag.test(rest) &&
-            !startTagOpen.test(rest) &&
-            !comment.test(rest) &&
-            !conditionalComment.test(rest)
-          ) {
-            // < in plain text, be forgiving and treat it as text
-            next = rest.indexOf('<', 1);
-            if (next < 0) { break }
-            textEnd += next;
-            rest = html.slice(textEnd);
-          }
-          text = html.substring(0, textEnd);
-        }
-
-        if (textEnd < 0) {
-          text = html;
-        }
-
-        if (text) {
-          advance(text.length);
-        }
-
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index);
-        }
-      } else {
-        var endTagLength = 0;
-        var stackedTag = lastTag.toLowerCase();
-        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-        var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-          endTagLength = endTag.length;
-          if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-            text = text
-              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-          }
-          if (shouldIgnoreFirstNewline(stackedTag, text)) {
-            text = text.slice(1);
-          }
-          if (options.chars) {
-            options.chars(text);
-          }
-          return ''
-        });
-        index += html.length - rest$1.length;
-        html = rest$1;
-        parseEndTag(stackedTag, index - endTagLength, index);
-      }
-
-      if (html === last) {
-        options.chars && options.chars(html);
-        if (!stack.length && options.warn) {
-          options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-        }
-        break
-      }
-    }
-
-    // Clean up any remaining tags
-    parseEndTag();
-
-    function advance (n) {
-      index += n;
-      html = html.substring(n);
-    }
-
-    function parseStartTag () {
-      var start = html.match(startTagOpen);
-      if (start) {
-        var match = {
-          tagName: start[1],
-          attrs: [],
-          start: index
-        };
-        advance(start[0].length);
-        var end, attr;
-        while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-          attr.start = index;
-          advance(attr[0].length);
-          attr.end = index;
-          match.attrs.push(attr);
-        }
-        if (end) {
-          match.unarySlash = end[1];
-          advance(end[0].length);
-          match.end = index;
-          return match
-        }
-      }
-    }
-
-    function handleStartTag (match) {
-      var tagName = match.tagName;
-      var unarySlash = match.unarySlash;
-
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag);
-        }
-        if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-          parseEndTag(tagName);
-        }
-      }
-
-      var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-      var l = match.attrs.length;
-      var attrs = new Array(l);
-      for (var i = 0; i < l; i++) {
-        var args = match.attrs[i];
-        var value = args[3] || args[4] || args[5] || '';
-        var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-          ? options.shouldDecodeNewlinesForHref
-          : options.shouldDecodeNewlines;
-        attrs[i] = {
-          name: args[1],
-          value: decodeAttr(value, shouldDecodeNewlines)
-        };
-        if (options.outputSourceRange) {
-          attrs[i].start = args.start + args[0].match(/^\s*/).length;
-          attrs[i].end = args.end;
-        }
-      }
-
-      if (!unary) {
-        stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-        lastTag = tagName;
-      }
-
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end);
-      }
-    }
-
-    function parseEndTag (tagName, start, end) {
-      var pos, lowerCasedTagName;
-      if (start == null) { start = index; }
-      if (end == null) { end = index; }
-
-      // Find the closest opened tag of the same type
-      if (tagName) {
-        lowerCasedTagName = tagName.toLowerCase();
-        for (pos = stack.length - 1; pos >= 0; pos--) {
-          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-            break
-          }
-        }
-      } else {
-        // If no tag name is provided, clean shop
-        pos = 0;
-      }
-
-      if (pos >= 0) {
-        // Close all the open elements, up the stack
-        for (var i = stack.length - 1; i >= pos; i--) {
-          if (i > pos || !tagName &&
-            options.warn
-          ) {
-            options.warn(
-              ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-              { start: stack[i].start, end: stack[i].end }
-            );
-          }
-          if (options.end) {
-            options.end(stack[i].tag, start, end);
-          }
-        }
-
-        // Remove the open elements from the stack
-        stack.length = pos;
-        lastTag = pos && stack[pos - 1].tag;
-      } else if (lowerCasedTagName === 'br') {
-        if (options.start) {
-          options.start(tagName, [], true, start, end);
-        }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end);
-        }
-        if (options.end) {
-          options.end(tagName, start, end);
-        }
-      }
-    }
-  }
-
-  /*  */
-
+  /* @flow */
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
   var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
   var stripParensRE = /^\(|\)$/g;
   var dynamicArgRE = /^\[.*\]$/;
-
   var argRE = /:(.*)$/;
   var bindRE = /^:|^\.|^v-bind:/;
   var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
   var slotRE = /^v-slot(:|$)|^#/;
-
   var lineBreakRE = /[\r\n]/;
-  var whitespaceRE$1 = /\s+/g;
-
+  var whitespaceRE$1 = /[ \f\t\r\n]+/g;
   var invalidAttributeRE = /[\s"'<>\/=]/;
-
-  var decodeHTMLCached = cached(he.decode);
-
+  var decodeHTMLCached = cached(undefined);
   var emptySlotScopeToken = "_empty_";
-
   // configurable state
   var warn$2;
   var delimiters;
@@ -9570,1040 +8826,889 @@
   var platformMustUseProp;
   var platformGetTagNamespace;
   var maybeComponent;
-
-  function createASTElement (
-    tag,
-    attrs,
-    parent
-  ) {
-    return {
-      type: 1,
-      tag: tag,
-      attrsList: attrs,
-      attrsMap: makeAttrsMap(attrs),
-      rawAttrsMap: {},
-      parent: parent,
-      children: []
-    }
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag: tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent: parent,
+          children: [],
+      };
   }
-
   /**
    * Convert HTML string to AST.
    */
-  function parse (
-    template,
-    options
-  ) {
-    warn$2 = options.warn || baseWarn;
-
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-    delimiters = options.delimiters;
-
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
-
-    function warnOnce (msg, range) {
-      if (!warned) {
-        warned = true;
-        warn$2(msg, range);
-      }
-    }
-
-    function closeElement (element) {
-      trimEndingWhitespace(element);
-      if (!inVPre && !element.processed) {
-        element = processElement(element, options);
-      }
-      // tree management
-      if (!stack.length && element !== root) {
-        // allow root elements with v-if, v-else-if and v-else
-        if (root.if && (element.elseif || element.else)) {
-          {
-            checkRootConstraints(element);
+  function parse(template, options) {
+      warn$2 = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      var isReservedTag = options.isReservedTag || no;
+      maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      var stack = [];
+      var preserveWhitespace = options.preserveWhitespace !== false;
+      var whitespaceOption = options.whitespace;
+      var root;
+      var currentParent;
+      var inVPre = false;
+      var inPre = false;
+      var warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn$2(msg, range);
           }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          });
-        } else {
-          warnOnce(
-            "Component template should contain exactly one root element. " +
-            "If you are using v-if on multiple elements, " +
-            "use v-else-if to chain them instead.",
-            { start: element.start }
-          );
-        }
-      }
-      if (currentParent && !element.forbidden) {
-        if (element.elseif || element.else) {
-          processIfConditions(element, currentParent);
-        } else {
-          if (element.slotScope) {
-            // scoped slot
-            // keep it in the children list so that v-else(-if) conditions can
-            // find it as the prev node.
-            var name = element.slotTarget || '"default"'
-            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-          }
-          currentParent.children.push(element);
-          element.parent = currentParent;
-        }
-      }
-
-      // final children cleanup
-      // filter out scoped slots
-      element.children = element.children.filter(function (c) { return !(c).slotScope; });
-      // remove trailing whitespace node again
-      trimEndingWhitespace(element);
-
-      // check pre state
-      if (element.pre) {
-        inVPre = false;
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false;
-      }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options);
-      }
-    }
-
-    function trimEndingWhitespace (el) {
-      // remove trailing whitespace node
-      if (!inPre) {
-        var lastNode;
-        while (
-          (lastNode = el.children[el.children.length - 1]) &&
-          lastNode.type === 3 &&
-          lastNode.text === ' '
-        ) {
-          el.children.pop();
-        }
-      }
-    }
-
-    function checkRootConstraints (el) {
-      if (el.tag === 'slot' || el.tag === 'template') {
-        warnOnce(
-          "Cannot use <" + (el.tag) + "> as component root element because it may " +
-          'contain multiple nodes.',
-          { start: el.start }
-        );
-      }
-      if (el.attrsMap.hasOwnProperty('v-for')) {
-        warnOnce(
-          'Cannot use v-for on stateful component root element because ' +
-          'it renders multiple elements.',
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-
-    parseHTML(template, {
-      warn: warn$2,
-      expectHTML: options.expectHTML,
-      isUnaryTag: options.isUnaryTag,
-      canBeLeftOpenTag: options.canBeLeftOpenTag,
-      shouldDecodeNewlines: options.shouldDecodeNewlines,
-      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-      shouldKeepComment: options.comments,
-      outputSourceRange: options.outputSourceRange,
-      start: function start (tag, attrs, unary, start$1, end) {
-        // check namespace.
-        // inherit parent ns if there is one
-        var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-        // handle IE svg bug
-        /* istanbul ignore if */
-        if (isIE && ns === 'svg') {
-          attrs = guardIESVGBug(attrs);
-        }
-
-        var element = createASTElement(tag, attrs, currentParent);
-        if (ns) {
-          element.ns = ns;
-        }
-
-        {
-          if (options.outputSourceRange) {
-            element.start = start$1;
-            element.end = end;
-            element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-              cumulated[attr.name] = attr;
-              return cumulated
-            }, {});
-          }
-          attrs.forEach(function (attr) {
-            if (invalidAttributeRE.test(attr.name)) {
-              warn$2(
-                "Invalid dynamic argument expression: attribute names cannot contain " +
-                "spaces, quotes, <, >, / or =.",
-                {
-                  start: attr.start + attr.name.indexOf("["),
-                  end: attr.start + attr.name.length
-                }
-              );
-            }
-          });
-        }
-
-        if (isForbiddenTag(element) && !isServerRendering()) {
-          element.forbidden = true;
-          warn$2(
-            'Templates should only be responsible for mapping the state to the ' +
-            'UI. Avoid placing tags with side-effects in your templates, such as ' +
-            "<" + tag + ">" + ', as they will not be parsed.',
-            { start: element.start }
-          );
-        }
-
-        // apply pre-transforms
-        for (var i = 0; i < preTransforms.length; i++) {
-          element = preTransforms[i](element, options) || element;
-        }
-
-        if (!inVPre) {
-          processPre(element);
+      }
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce("Component template should contain exactly one root element. " +
+                      "If you are using v-if on multiple elements, " +
+                      "use v-else-if to chain them instead.", { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      var name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter(function (c) { return !c.slotScope; });
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
           if (element.pre) {
-            inVPre = true;
-          }
-        }
-        if (platformIsPreTag(element.tag)) {
-          inPre = true;
-        }
-        if (inVPre) {
-          processRawAttrs(element);
-        } else if (!element.processed) {
-          // structural directives
-          processFor(element);
-          processIf(element);
-          processOnce(element);
-        }
-
-        if (!root) {
-          root = element;
-          {
-            checkRootConstraints(root);
+              inVPre = false;
           }
-        }
-
-        if (!unary) {
-          currentParent = element;
-          stack.push(element);
-        } else {
-          closeElement(element);
-        }
-      },
-
-      end: function end (tag, start, end$1) {
-        var element = stack[stack.length - 1];
-        // pop stack
-        stack.length -= 1;
-        currentParent = stack[stack.length - 1];
-        if (options.outputSourceRange) {
-          element.end = end$1;
-        }
-        closeElement(element);
-      },
-
-      chars: function chars (text, start, end) {
-        if (!currentParent) {
-          {
-            if (text === template) {
-              warnOnce(
-                'Component template requires a root element, rather than just text.',
-                { start: start }
-              );
-            } else if ((text = text.trim())) {
-              warnOnce(
-                ("text \"" + text + "\" outside root element will be ignored."),
-                { start: start }
-              );
-            }
-          }
-          return
-        }
-        // IE textarea placeholder bug
-        /* istanbul ignore if */
-        if (isIE &&
-          currentParent.tag === 'textarea' &&
-          currentParent.attrsMap.placeholder === text
-        ) {
-          return
-        }
-        var children = currentParent.children;
-        if (inPre || text.trim()) {
-          text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-        } else if (!children.length) {
-          // remove the whitespace-only node right after an opening tag
-          text = '';
-        } else if (whitespaceOption) {
-          if (whitespaceOption === 'condense') {
-            // in condense mode, remove the whitespace node if it contains
-            // line break, otherwise condense to a single space
-            text = lineBreakRE.test(text) ? '' : ' ';
-          } else {
-            text = ' ';
-          }
-        } else {
-          text = preserveWhitespace ? ' ' : '';
-        }
-        if (text) {
-          if (!inPre && whitespaceOption === 'condense') {
-            // condense consecutive whitespaces into single space
-            text = text.replace(whitespaceRE$1, ' ');
-          }
-          var res;
-          var child;
-          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-            child = {
-              type: 2,
-              expression: res.expression,
-              tokens: res.tokens,
-              text: text
-            };
-          } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-            child = {
-              type: 3,
-              text: text
-            };
-          }
-          if (child) {
-            if (options.outputSourceRange) {
-              child.start = start;
-              child.end = end;
-            }
-            children.push(child);
-          }
-        }
-      },
-      comment: function comment (text, start, end) {
-        // adding anything as a sibling to the root node is forbidden
-        // comments should still be allowed, but ignored
-        if (currentParent) {
-          var child = {
-            type: 3,
-            text: text,
-            isComment: true
-          };
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          currentParent.children.push(child);
-        }
-      }
-    });
-    return root
-  }
-
-  function processPre (el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true;
-    }
-  }
-
-  function processRawAttrs (el) {
-    var list = el.attrsList;
-    var len = list.length;
-    if (len) {
-      var attrs = el.attrs = new Array(len);
-      for (var i = 0; i < len; i++) {
-        attrs[i] = {
-          name: list[i].name,
-          value: JSON.stringify(list[i].value)
-        };
-        if (list[i].start != null) {
-          attrs[i].start = list[i].start;
-          attrs[i].end = list[i].end;
-        }
-      }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true;
-    }
-  }
-
-  function processElement (
-    element,
-    options
-  ) {
-    processKey(element);
-
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain = (
-      !element.key &&
-      !element.scopedSlots &&
-      !element.attrsList.length
-    );
-
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element
-  }
-
-  function processKey (el) {
-    var exp = getBindingAttr(el, 'key');
-    if (exp) {
-      {
-        if (el.tag === 'template') {
-          warn$2(
-            "<template> cannot be keyed. Place the key on real elements instead.",
-            getRawBindingAttr(el, 'key')
-          );
-        }
-        if (el.for) {
-          var iterator = el.iterator2 || el.iterator1;
-          var parent = el.parent;
-          if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-            warn$2(
-              "Do not use v-for index as key on <transition-group> children, " +
-              "this is the same as not using keys.",
-              getRawBindingAttr(el, 'key'),
-              true /* tip */
-            );
-          }
-        }
-      }
-      el.key = exp;
-    }
-  }
-
-  function processRef (el) {
-    var ref = getBindingAttr(el, 'ref');
-    if (ref) {
-      el.ref = ref;
-      el.refInFor = checkInFor(el);
-    }
-  }
-
-  function processFor (el) {
-    var exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp);
-      if (res) {
-        extend(el, res);
-      } else {
-        warn$2(
-          ("Invalid v-for expression: " + exp),
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-  }
-
-
-
-  function parseFor (exp) {
-    var inMatch = exp.match(forAliasRE);
-    if (!inMatch) { return }
-    var res = {};
-    res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-      res.alias = alias.replace(forIteratorRE, '').trim();
-      res.iterator1 = iteratorMatch[1].trim();
-      if (iteratorMatch[2]) {
-        res.iterator2 = iteratorMatch[2].trim();
-      }
-    } else {
-      res.alias = alias;
-    }
-    return res
-  }
-
-  function processIf (el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-      el.if = exp;
-      addIfCondition(el, {
-        exp: exp,
-        block: el
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
+          }
+          // apply post-transforms
+          for (var i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
+          }
+      }
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              var lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
+          }
+      }
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                  'contain multiple nodes.', { start: el.start });
+          }
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
+          }
+      }
+      parseHTML(template, {
+          warn: warn$2,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start: function start(tag, attrs, unary, start$1, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              var element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start$1;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach(function (attr) {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn$2("Invalid dynamic argument expression: attribute names cannot contain " +
+                              "spaces, quotes, <, >, / or =.", {
+                              start: attr.start + attr.name.indexOf("["),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn$2('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          "<" + tag + ">" +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (var i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end: function end(tag, start, end$1) {
+              var element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end$1;
+              }
+              closeElement(element);
+          },
+          chars: function chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                              start: start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              var children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE$1, ' ');
+                  }
+                  var res;
+                  var child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text: text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text: text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment: function comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  var child = {
+                      type: 3,
+                      text: text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
       });
-    } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true;
+      return root;
+  }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
+  }
+  function processRawAttrs(el) {
+      var list = el.attrsList;
+      var len = list.length;
+      if (len) {
+          var attrs = (el.attrs = new Array(len));
+          for (var i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
       }
-      var elseif = getAndRemoveAttr(el, 'v-else-if');
-      if (elseif) {
-        el.elseif = elseif;
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (var i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      var exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  var iterator = el.iterator2 || el.iterator1;
+                  var parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn$2("Do not use v-for index as key on <transition-group> children, " +
+                          "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
       }
-    }
   }
-
-  function processIfConditions (el, parent) {
-    var prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-      addIfCondition(prev, {
-        exp: el.elseif,
-        block: el
-      });
-    } else {
-      warn$2(
-        "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-        "used on element <" + (el.tag) + "> without corresponding v-if.",
-        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-      );
-    }
-  }
-
-  function findPrevElement (children) {
-    var i = children.length;
-    while (i--) {
-      if (children[i].type === 1) {
-        return children[i]
-      } else {
-        if (children[i].text !== ' ') {
-          warn$2(
-            "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-            "will be ignored.",
-            children[i]
-          );
-        }
-        children.pop();
+  function processRef(el) {
+      var ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
       }
-    }
   }
-
-  function addIfCondition (el, condition) {
-    if (!el.ifConditions) {
-      el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
+  function processFor(el) {
+      var exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          var res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn$2(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+          }
+      }
   }
-
-  function processOnce (el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
-      el.once = true;
-    }
+  function parseFor(exp) {
+      var inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          { return; }
+      var res = {};
+      res.for = inMatch[2].trim();
+      var alias = inMatch[1].trim().replace(stripParensRE, '');
+      var iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
+          }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
+  }
+  function processIf(el) {
+      var exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          var elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
+      }
+  }
+  function processIfConditions(el, parent) {
+      var prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
+          });
+      }
+      else {
+          warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+      }
+  }
+  function findPrevElement(children) {
+      var i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn$2("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                      "will be ignored.", children[i]);
+              }
+              children.pop();
+          }
+      }
+  }
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
+  }
+  function processOnce(el) {
+      var once$$1 = getAndRemoveAttr(el, 'v-once');
+      if (once$$1 != null) {
+          el.once = true;
+      }
   }
-
   // handle content being passed to a component as slot,
   // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent (el) {
-    var slotScope;
-    if (el.tag === 'template') {
-      slotScope = getAndRemoveAttr(el, 'scope');
-      /* istanbul ignore if */
-      if (slotScope) {
-        warn$2(
-          "the \"scope\" attribute for scoped slots have been deprecated and " +
-          "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-          "can also be used on plain elements in addition to <template> to " +
-          "denote scoped slots.",
-          el.rawAttrsMap['scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-      /* istanbul ignore if */
-      if (el.attrsMap['v-for']) {
-        warn$2(
-          "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-          "(v-for takes higher priority). Use a wrapper <template> for the " +
-          "scoped slot to make it clearer.",
-          el.rawAttrsMap['slot-scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope;
-    }
-
-    // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-      el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-      // preserve slot as an attribute for native shadow DOM compat
-      // only for non-scoped slots.
-      if (el.tag !== 'template' && !el.slotScope) {
-        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-      }
-    }
-
-    // 2.6 v-slot syntax
-    {
+  function processSlotContent(el) {
+      var slotScope;
       if (el.tag === 'template') {
-        // v-slot on <template>
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding) {
-          {
-            if (el.slotTarget || el.slotScope) {
-              warn$2(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.parent && !maybeComponent(el.parent)) {
-              warn$2(
-                "<template v-slot> can only appear at the root level inside " +
-                "the receiving component",
-                el
-              );
-            }
-          }
-          var ref = getSlotName(slotBinding);
-          var name = ref.name;
-          var dynamic = ref.dynamic;
-          el.slotTarget = name;
-          el.slotTargetDynamic = dynamic;
-          el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-        }
-      } else {
-        // v-slot on component, denotes default slot
-        var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding$1) {
-          {
-            if (!maybeComponent(el)) {
-              warn$2(
-                "v-slot can only be used on components or <template>.",
-                slotBinding$1
-              );
-            }
-            if (el.slotScope || el.slotTarget) {
-              warn$2(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.scopedSlots) {
-              warn$2(
-                "To avoid scope ambiguity, the default slot should also use " +
-                "<template> syntax when there are other named slots.",
-                slotBinding$1
-              );
-            }
-          }
-          // add the component's children to its default slot
-          var slots = el.scopedSlots || (el.scopedSlots = {});
-          var ref$1 = getSlotName(slotBinding$1);
-          var name$1 = ref$1.name;
-          var dynamic$1 = ref$1.dynamic;
-          var slotContainer = slots[name$1] = createASTElement('template', [], el);
-          slotContainer.slotTarget = name$1;
-          slotContainer.slotTargetDynamic = dynamic$1;
-          slotContainer.children = el.children.filter(function (c) {
-            if (!c.slotScope) {
-              c.parent = slotContainer;
-              return true
-            }
-          });
-          slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-          // remove children as they are returned from scopedSlots now
-          el.children = [];
-          // mark el non-plain so data gets generated
-          el.plain = false;
-        }
-      }
-    }
-  }
-
-  function getSlotName (binding) {
-    var name = binding.name.replace(slotRE, '');
-    if (!name) {
-      if (binding.name[0] !== '#') {
-        name = 'default';
-      } else {
-        warn$2(
-          "v-slot shorthand syntax requires a slot name.",
-          binding
-        );
-      }
-    }
-    return dynamicArgRE.test(name)
-      // dynamic [name]
-      ? { name: name.slice(1, -1), dynamic: true }
-      // static name
-      : { name: ("\"" + name + "\""), dynamic: false }
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn$2("the \"scope\" attribute for scoped slots have been deprecated and " +
+                  "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                  "can also be used on plain elements in addition to <template> to " +
+                  "denote scoped slots.", el.rawAttrsMap['scope'], true);
+          }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn$2("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                  "(v-for takes higher priority). Use a wrapper <template> for the " +
+                  "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      var slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn$2("<template v-slot> can only appear at the root level inside " +
+                              "the receiving component", el);
+                      }
+                  }
+                  var ref = getSlotName(slotBinding);
+                  var name = ref.name;
+                  var dynamic = ref.dynamic;
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding$1) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn$2("v-slot can only be used on components or <template>.", slotBinding$1);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                      }
+                      if (el.scopedSlots) {
+                          warn$2("To avoid scope ambiguity, the default slot should also use " +
+                              "<template> syntax when there are other named slots.", slotBinding$1);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  var slots = el.scopedSlots || (el.scopedSlots = {});
+                  var ref$1 = getSlotName(slotBinding$1);
+                  var name$1 = ref$1.name;
+                  var dynamic$1 = ref$1.dynamic;
+                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name$1;
+                  slotContainer.slotTargetDynamic = dynamic$1;
+                  slotContainer.children = el.children.filter(function (c) {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
+          }
+      }
+  }
+  function getSlotName(binding) {
+      var name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn$2("v-slot shorthand syntax requires a slot name.", binding);
+          }
+      }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: ("\"" + name + "\""), dynamic: false };
   }
-
   // handle <slot/> outlets
-  function processSlotOutlet (el) {
-    if (el.tag === 'slot') {
-      el.slotName = getBindingAttr(el, 'name');
-      if (el.key) {
-        warn$2(
-          "`key` does not work on <slot> because slots are abstract outlets " +
-          "and can possibly expand into multiple elements. " +
-          "Use the key on a wrapping element instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-    }
-  }
-
-  function processComponent (el) {
-    var binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true;
-    }
-  }
-
-  function processAttrs (el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-      name = rawName = list[i].name;
-      value = list[i].value;
-      if (dirRE.test(name)) {
-        // mark element as dynamic
-        el.hasBindings = true;
-        // modifiers
-        modifiers = parseModifiers(name.replace(dirRE, ''));
-        // support .foo shorthand syntax for the .prop modifier
-        if (modifiers) {
-          name = name.replace(modifierRE, '');
-        }
-        if (bindRE.test(name)) { // v-bind
-          name = name.replace(bindRE, '');
-          value = parseFilters(value);
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          if (
-            value.trim().length === 0
-          ) {
-            warn$2(
-              ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-            );
-          }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name);
-              if (name === 'innerHtml') { name = 'innerHTML'; }
-            }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name);
-            }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, "$event");
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  ("update:" + (camelize(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$2,
-                  list[i]
-                );
-                if (hyphenate(name) !== camelize(name)) {
-                  addHandler(
-                    el,
-                    ("update:" + (hyphenate(name))),
-                    syncGen,
-                    null,
-                    false,
-                    warn$2,
-                    list[i]
-                  );
-                }
-              } else {
-                // handler w/ dynamic event name
-                addHandler(
-                  el,
-                  ("\"update:\"+(" + name + ")"),
-                  syncGen,
-                  null,
-                  false,
-                  warn$2,
-                  list[i],
-                  true // dynamic
-                );
-              }
-            }
-          }
-          if ((modifiers && modifiers.prop) || (
-            !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-          )) {
-            addProp(el, name, value, list[i], isDynamic);
-          } else {
-            addAttr(el, name, value, list[i], isDynamic);
-          }
-        } else if (onRE.test(name)) { // v-on
-          name = name.replace(onRE, '');
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
-        } else { // normal directives
-          name = name.replace(dirRE, '');
-          // parse arg
-          var argMatch = name.match(argRE);
-          var arg = argMatch && argMatch[1];
-          isDynamic = false;
-          if (arg) {
-            name = name.slice(0, -(arg.length + 1));
-            if (dynamicArgRE.test(arg)) {
-              arg = arg.slice(1, -1);
-              isDynamic = true;
-            }
-          }
-          addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-          if (name === 'model') {
-            checkForAliasModel(el, value);
-          }
-        }
-      } else {
-        // literal attribute
-        {
-          var res = parseText(value, delimiters);
-          if (res) {
-            warn$2(
-              name + "=\"" + value + "\": " +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div id="{{ val }}">, use <div :id="val">.',
-              list[i]
-            );
-          }
-        }
-        addAttr(el, name, JSON.stringify(value), list[i]);
-        // #6887 firefox doesn't update muted state if set via attribute
-        // even immediately after element creation
-        if (!el.component &&
-            name === 'muted' &&
-            platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-          addProp(el, name, 'true', list[i]);
-        }
-      }
-    }
-  }
-
-  function checkInFor (el) {
-    var parent = el;
-    while (parent) {
-      if (parent.for !== undefined) {
-        return true
-      }
-      parent = parent.parent;
-    }
-    return false
-  }
-
-  function parseModifiers (name) {
-    var match = name.match(modifierRE);
-    if (match) {
-      var ret = {};
-      match.forEach(function (m) { ret[m.slice(1)] = true; });
-      return ret
-    }
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn$2("`key` does not work on <slot> because slots are abstract outlets " +
+                  "and can possibly expand into multiple elements. " +
+                  "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+          }
+      }
   }
-
-  function makeAttrsMap (attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
-      if (
-        map[attrs[i].name] && !isIE && !isEdge
-      ) {
-        warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+  function processComponent(el) {
+      var binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
       }
-      map[attrs[i].name] = attrs[i].value;
-    }
-    return map
   }
-
+  function processAttrs(el) {
+      var list = el.attrsList;
+      var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn$2(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              { name = 'innerHTML'; }
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, "$event");
+                          if (!isDynamic) {
+                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$2, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$2, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$2, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  var argMatch = name.match(argRE);
+                  var arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
+              }
+          }
+          else {
+              // literal attribute
+              {
+                  var res = parseText(value, delimiters);
+                  if (res) {
+                      warn$2(name + "=\"" + value + "\": " +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
+          }
+      }
+  }
+  function checkInFor(el) {
+      var parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
+      }
+      return false;
+  }
+  function parseModifiers(name) {
+      var match = name.match(modifierRE);
+      if (match) {
+          var ret = {};
+          match.forEach(function (m) {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
+  }
+  function makeAttrsMap(attrs) {
+      var map = {};
+      for (var i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
+  }
   // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag (el) {
-    return el.tag === 'script' || el.tag === 'style'
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
   }
-
-  function isForbiddenTag (el) {
-    return (
-      el.tag === 'style' ||
-      (el.tag === 'script' && (
-        !el.attrsMap.type ||
-        el.attrsMap.type === 'text/javascript'
-      ))
-    )
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
   }
-
   var ieNSBug = /^xmlns:NS\d+/;
   var ieNSPrefix = /^NS\d+:/;
-
   /* istanbul ignore next */
-  function guardIESVGBug (attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (!ieNSBug.test(attr.name)) {
-        attr.name = attr.name.replace(ieNSPrefix, '');
-        res.push(attr);
-      }
-    }
-    return res
-  }
-
-  function checkForAliasModel (el, value) {
-    var _el = el;
-    while (_el) {
-      if (_el.for && _el.alias === value) {
-        warn$2(
-          "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-          "You are binding v-model directly to a v-for iteration alias. " +
-          "This will not be able to modify the v-for source array because " +
-          "writing to the alias is like modifying a function local variable. " +
-          "Consider using an array of objects and use v-model on an object property instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-      _el = _el.parent;
-    }
-  }
-
-  /*  */
-
-  function preTransformNode (el, options) {
-    if (el.tag === 'input') {
-      var map = el.attrsMap;
-      if (!map['v-model']) {
-        return
-      }
-
-      var typeBinding;
-      if (map[':type'] || map['v-bind:type']) {
-        typeBinding = getBindingAttr(el, 'type');
-      }
-      if (!map.type && !typeBinding && map['v-bind']) {
-        typeBinding = "(" + (map['v-bind']) + ").type";
-      }
-
-      if (typeBinding) {
-        var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-        var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-        // 1. checkbox
-        var branch0 = cloneASTElement(el);
-        // process for on the main node
-        processFor(branch0);
-        addRawAttr(branch0, 'type', 'checkbox');
-        processElement(branch0, options);
-        branch0.processed = true; // prevent it from double-processed
-        branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-        addIfCondition(branch0, {
-          exp: branch0.if,
-          block: branch0
-        });
-        // 2. add radio else-if condition
-        var branch1 = cloneASTElement(el);
-        getAndRemoveAttr(branch1, 'v-for', true);
-        addRawAttr(branch1, 'type', 'radio');
-        processElement(branch1, options);
-        addIfCondition(branch0, {
-          exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-          block: branch1
-        });
-        // 3. other
-        var branch2 = cloneASTElement(el);
-        getAndRemoveAttr(branch2, 'v-for', true);
-        addRawAttr(branch2, ':type', typeBinding);
-        processElement(branch2, options);
-        addIfCondition(branch0, {
-          exp: ifCondition,
-          block: branch2
-        });
-
-        if (hasElse) {
-          branch0.else = true;
-        } else if (elseIfCondition) {
-          branch0.elseif = elseIfCondition;
-        }
-
-        return branch0
-      }
-    }
-  }
-
-  function cloneASTElement (el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+  function guardIESVGBug(attrs) {
+      var res = [];
+      for (var i = 0; i < attrs.length; i++) {
+          var attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
+      }
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      var _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                  "You are binding v-model directly to a v-for iteration alias. " +
+                  "This will not be able to modify the v-for source array because " +
+                  "writing to the alias is like modifying a function local variable. " +
+                  "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
+      }
   }
 
+  /* @flow */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          var map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          var typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = "(" + (map['v-bind']) + ").type";
+          }
+          if (typeBinding) {
+              var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+              var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              var branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              var branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              var branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
+      }
+  }
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+  }
   var model$1 = {
-    preTransformNode: preTransformNode
+      preTransformNode: preTransformNode,
   };
 
-  var modules$1 = [
-    klass$1,
-    style$1,
-    model$1
-  ];
+  var modules$1 = [klass$1, style$1, model$1];
 
-  /*  */
-
-  function text (el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-    }
+  /* @flow */
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+      }
   }
 
-  /*  */
-
-  function html (el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-    }
+  /* @flow */
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+      }
   }
 
   var directives$1 = {
-    model: model,
-    text: text,
-    html: html
+      model: model,
+      text: text,
+      html: html,
   };
 
-  /*  */
-
+  /* @flow */
   var baseOptions = {
-    expectHTML: true,
-    modules: modules$1,
-    directives: directives$1,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    staticKeys: genStaticKeys(modules$1)
+      expectHTML: true,
+      modules: modules$1,
+      directives: directives$1,
+      isPreTag: isPreTag,
+      isUnaryTag: isUnaryTag,
+      mustUseProp: mustUseProp,
+      canBeLeftOpenTag: canBeLeftOpenTag,
+      isReservedTag: isReservedTag,
+      getTagNamespace: getTagNamespace,
+      // @ts-ignore
+      staticKeys: genStaticKeys(modules$1),
   };
 
-  /*  */
-
+  /* @flow */
   var isStaticKey;
   var isPlatformReservedTag;
-
   var genStaticKeysCached = cached(genStaticKeys$1);
-
   /**
    * Goal of the optimizer: walk the generated template AST tree
    * and detect sub-trees that are purely static, i.e. parts of
@@ -10615,1349 +9720,1183 @@
    *    create fresh nodes for them on each re-render;
    * 2. Completely skip them in the patching process.
    */
-  function optimize (root, options) {
-    if (!root) { return }
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic$1(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-  }
-
-  function genStaticKeys$1 (keys) {
-    return makeMap(
-      'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-      (keys ? ',' + keys : '')
-    )
-  }
-
-  function markStatic$1 (node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-      // do not make component slot content static. this avoids
-      // 1. components not able to mutate slot nodes
-      // 2. static slot content fails for hot-reloading
-      if (
-        !isPlatformReservedTag(node.tag) &&
-        node.tag !== 'slot' &&
-        node.attrsMap['inline-template'] == null
-      ) {
-        return
-      }
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        markStatic$1(child);
-        if (!child.static) {
-          node.static = false;
-        }
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          markStatic$1(block);
-          if (!block.static) {
-            node.static = false;
-          }
-        }
-      }
-    }
-  }
-
-  function markStaticRoots (node, isInFor) {
-    if (node.type === 1) {
-      if (node.static || node.once) {
-        node.staticInFor = isInFor;
-      }
-      // For a node to qualify as a static root, it should have children that
-      // are not just static text. Otherwise the cost of hoisting out will
-      // outweigh the benefits and it's better off to just always render it fresh.
-      if (node.static && node.children.length && !(
-        node.children.length === 1 &&
-        node.children[0].type === 3
-      )) {
-        node.staticRoot = true;
-        return
-      } else {
-        node.staticRoot = false;
-      }
-      if (node.children) {
-        for (var i = 0, l = node.children.length; i < l; i++) {
-          markStaticRoots(node.children[i], isInFor || !!node.for);
-        }
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          markStaticRoots(node.ifConditions[i$1].block, isInFor);
-        }
-      }
-    }
-  }
-
-  function isStatic (node) {
-    if (node.type === 2) { // expression
-      return false
-    }
-    if (node.type === 3) { // text
-      return true
-    }
-    return !!(node.pre || (
-      !node.hasBindings && // no dynamic bindings
-      !node.if && !node.for && // not v-if or v-for or v-else
-      !isBuiltInTag(node.tag) && // not a built-in
-      isPlatformReservedTag(node.tag) && // not a component
-      !isDirectChildOfTemplateFor(node) &&
-      Object.keys(node).every(isStaticKey)
-    ))
-  }
-
-  function isDirectChildOfTemplateFor (node) {
-    while (node.parent) {
-      node = node.parent;
-      if (node.tag !== 'template') {
-        return false
-      }
-      if (node.for) {
-        return true
-      }
-    }
-    return false
-  }
-
-  /*  */
+  function optimize(root, options) {
+      if (!root)
+          { return; }
+      isStaticKey = genStaticKeysCached(options.staticKeys || '');
+      isPlatformReservedTag = options.isReservedTag || no;
+      // first pass: mark all non-static nodes.
+      markStatic$1(root);
+      // second pass: mark static roots.
+      markStaticRoots(root, false);
+  }
+  function genStaticKeys$1(keys) {
+      return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+          (keys ? ',' + keys : ''));
+  }
+  function markStatic$1(node) {
+      node.static = isStatic(node);
+      if (node.type === 1) {
+          // do not make component slot content static. this avoids
+          // 1. components not able to mutate slot nodes
+          // 2. static slot content fails for hot-reloading
+          if (!isPlatformReservedTag(node.tag) &&
+              node.tag !== 'slot' &&
+              node.attrsMap['inline-template'] == null) {
+              return;
+          }
+          for (var i = 0, l = node.children.length; i < l; i++) {
+              var child = node.children[i];
+              markStatic$1(child);
+              if (!child.static) {
+                  node.static = false;
+              }
+          }
+          if (node.ifConditions) {
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
+                  markStatic$1(block);
+                  if (!block.static) {
+                      node.static = false;
+                  }
+              }
+          }
+      }
+  }
+  function markStaticRoots(node, isInFor) {
+      if (node.type === 1) {
+          if (node.static || node.once) {
+              node.staticInFor = isInFor;
+          }
+          // For a node to qualify as a static root, it should have children that
+          // are not just static text. Otherwise the cost of hoisting out will
+          // outweigh the benefits and it's better off to just always render it fresh.
+          if (node.static &&
+              node.children.length &&
+              !(node.children.length === 1 && node.children[0].type === 3)) {
+              node.staticRoot = true;
+              return;
+          }
+          else {
+              node.staticRoot = false;
+          }
+          if (node.children) {
+              for (var i = 0, l = node.children.length; i < l; i++) {
+                  markStaticRoots(node.children[i], isInFor || !!node.for);
+              }
+          }
+          if (node.ifConditions) {
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
+              }
+          }
+      }
+  }
+  function isStatic(node) {
+      if (node.type === 2) {
+          // expression
+          return false;
+      }
+      if (node.type === 3) {
+          // text
+          return true;
+      }
+      return !!(node.pre ||
+          (!node.hasBindings && // no dynamic bindings
+              !node.if &&
+              !node.for && // not v-if or v-for or v-else
+              !isBuiltInTag(node.tag) && // not a built-in
+              isPlatformReservedTag(node.tag) && // not a component
+              !isDirectChildOfTemplateFor(node) &&
+              Object.keys(node).every(isStaticKey)));
+  }
+  function isDirectChildOfTemplateFor(node) {
+      while (node.parent) {
+          node = node.parent;
+          if (node.tag !== 'template') {
+              return false;
+          }
+          if (node.for) {
+              return true;
+          }
+      }
+      return false;
+  }
 
+  /* @flow */
   var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
   // KeyboardEvent.keyCode aliases
   var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    'delete': [8, 46]
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
   };
-
   // KeyboardEvent.key aliases
   var keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    'delete': ['Backspace', 'Delete', 'Del']
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
   };
-
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
   var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
   var modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2")
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard("$event.target !== $event.currentTarget"),
+      ctrl: genGuard("!$event.ctrlKey"),
+      shift: genGuard("!$event.shiftKey"),
+      alt: genGuard("!$event.altKey"),
+      meta: genGuard("!$event.metaKey"),
+      left: genGuard("'button' in $event && $event.button !== 0"),
+      middle: genGuard("'button' in $event && $event.button !== 1"),
+      right: genGuard("'button' in $event && $event.button !== 2"),
   };
-
-  function genHandlers (
-    events,
-    isNative
-  ) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-      var handlerCode = genHandler(events[name]);
-      if (events[name] && events[name].dynamic) {
-        dynamicHandlers += name + "," + handlerCode + ",";
-      } else {
-        staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-      }
-    }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-    if (dynamicHandlers) {
-      return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-    } else {
-      return prefix + staticHandlers
-    }
-  }
-
-  function genHandler (handler) {
-    if (!handler) {
-      return 'function(){}'
-    }
-
-    if (Array.isArray(handler)) {
-      return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-    }
-
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-    if (!handler.modifiers) {
-      if (isMethodPath || isFunctionExpression) {
-        return handler.value
-      }
-      return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-    } else {
-      var code = '';
-      var genModifierCode = '';
-      var keys = [];
-      for (var key in handler.modifiers) {
-        if (modifierCode[key]) {
-          genModifierCode += modifierCode[key];
-          // left/right
-          if (keyCodes[key]) {
-            keys.push(key);
-          }
-        } else if (key === 'exact') {
-          var modifiers = (handler.modifiers);
-          genModifierCode += genGuard(
-            ['ctrl', 'shift', 'alt', 'meta']
-              .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-              .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-              .join('||')
-          );
-        } else {
-          keys.push(key);
-        }
+  function genHandlers(events, isNative) {
+      var prefix = isNative ? 'nativeOn:' : 'on:';
+      var staticHandlers = "";
+      var dynamicHandlers = "";
+      for (var name in events) {
+          var handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += name + "," + handlerCode + ",";
+          }
+          else {
+              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+          }
       }
-      if (keys.length) {
-        code += genKeyFilter(keys);
+      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      if (dynamicHandlers) {
+          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
       }
-      // Make sure modifiers like prevent and stop get executed after key filtering
-      if (genModifierCode) {
-        code += genModifierCode;
+      else {
+          return prefix + staticHandlers;
       }
-      var handlerCode = isMethodPath
-        ? ("return " + (handler.value) + "($event)")
-        : isFunctionExpression
-          ? ("return (" + (handler.value) + ")($event)")
-          : isFunctionInvocation
-            ? ("return " + (handler.value))
-            : handler.value;
-      return ("function($event){" + code + handlerCode + "}")
-    }
   }
-
-  function genKeyFilter (keys) {
-    return (
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+      }
+      var isMethodPath = simplePathRE.test(handler.value);
+      var isFunctionExpression = fnExpRE.test(handler.value);
+      var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+      }
+      else {
+          var code = '';
+          var genModifierCode = '';
+          var keys = [];
+          for (var key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  var modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          var handlerCode = isMethodPath
+              ? ("return " + (handler.value) + ".apply(null, arguments)")
+              : isFunctionExpression
+                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  : isFunctionInvocation
+                      ? ("return " + (handler.value))
+                      : handler.value;
+          return ("function($event){" + code + handlerCode + "}");
+      }
+  }
+  function genKeyFilter(keys) {
+      return (
       // make sure the key filters only apply to KeyboardEvents
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-      (keys.map(genFilterCode).join('&&')) + ")return null;"
-    )
+          (keys.map(genFilterCode).join('&&')) + ")return null;");
   }
-
-  function genFilterCode (key) {
-    var keyVal = parseInt(key, 10);
-    if (keyVal) {
-      return ("$event.keyCode!==" + keyVal)
-    }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return (
-      "_k($event.keyCode," +
-      (JSON.stringify(key)) + "," +
-      (JSON.stringify(keyCode)) + "," +
-      "$event.key," +
-      "" + (JSON.stringify(keyName)) +
-      ")"
-    )
+  function genFilterCode(key) {
+      var keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return ("$event.keyCode!==" + keyVal);
+      }
+      var keyCode = keyCodes[key];
+      var keyName = keyNames[key];
+      return ("_k($event.keyCode," +
+          (JSON.stringify(key)) + "," +
+          (JSON.stringify(keyCode)) + "," +
+          "$event.key," +
+          "" + (JSON.stringify(keyName)) +
+          ")");
   }
 
-  /*  */
-
-  function on (el, dir) {
-    if (dir.modifiers) {
-      warn("v-on without argument does not support modifiers.");
-    }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+  /* @flow */
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn("v-on without argument does not support modifiers.");
+      }
+      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
   }
 
-  /*  */
-
-  function bind$1 (el, dir) {
-    el.wrapData = function (code) {
-      return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-    };
+  /* @flow */
+  function bind$1(el, dir) {
+      el.wrapData = function (code) {
+          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var baseDirectives = {
-    on: on,
-    bind: bind$1,
-    cloak: noop
+      on: on,
+      bind: bind$1,
+      cloak: noop,
   };
 
-  /*  */
-
-
-
-
-
-  var CodegenState = function CodegenState (options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
+  /* @flow */
+  var CodegenState = function CodegenState(options) {
+      this.options = options;
+      this.warn = options.warn || baseWarn;
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+      this.directives = extend(extend({}, baseDirectives), options.directives);
+      var isReservedTag = options.isReservedTag || no;
+      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      this.onceId = 0;
+      this.staticRenderFns = [];
+      this.pre = false;
   };
-
-
-
-  function generate (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genElement (el, state) {
-    if (el.parent) {
-      el.pre = el.pre || el.parent.pre;
-    }
-
-    if (el.staticRoot && !el.staticProcessed) {
-      return genStatic(el, state)
-    } else if (el.once && !el.onceProcessed) {
-      return genOnce(el, state)
-    } else if (el.for && !el.forProcessed) {
-      return genFor(el, state)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-      return genChildren(el, state) || 'void 0'
-    } else if (el.tag === 'slot') {
-      return genSlot(el, state)
-    } else {
-      // component or element
-      var code;
-      if (el.component) {
-        code = genComponent(el.component, el, state);
-      } else {
-        var data;
-        if (!el.plain || (el.pre && state.maybeComponent(el))) {
-          data = genData$2(el, state);
-        }
-
-        var children = el.inlineTemplate ? null : genChildren(el, state, true);
-        code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+  function generate(ast, options) {
+      var state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      var code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: ("with(this){return " + code + "}"),
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
+      }
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
+      }
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
       }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code);
+      else {
+          // component or element
+          var code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              var data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData$2(el, state);
+              }
+              var children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+          }
+          // module transforms
+          for (var i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
       }
-      return code
-    }
   }
-
   // hoist static sub-trees out
-  function genStatic (el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
-    if (el.pre) {
-      state.pre = el.pre;
-    }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-    state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      var originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.pre = originalPreState;
+      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
   }
-
   // v-once
-  function genOnce (el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.staticInFor) {
-      var key = '';
-      var parent = el.parent;
-      while (parent) {
-        if (parent.for) {
-          key = parent.key;
-          break
-        }
-        parent = parent.parent;
-      }
-      if (!key) {
-        state.warn(
-          "v-once can only be used inside v-for that is keyed. ",
-          el.rawAttrsMap['v-once']
-        );
-        return genElement(el, state)
-      }
-      return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-    } else {
-      return genStatic(el, state)
-    }
-  }
-
-  function genIf (
-    el,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-  }
-
-  function genIfConditions (
-    conditions,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    if (!conditions.length) {
-      return altEmpty || '_e()'
-    }
-
-    var condition = conditions.shift();
-    if (condition.exp) {
-      return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-    } else {
-      return ("" + (genTernaryExp(condition.block)))
-    }
-
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp (el) {
-      return altGen
-        ? altGen(el, state)
-        : el.once
-          ? genOnce(el, state)
-          : genElement(el, state)
-    }
-  }
-
-  function genFor (
-    el,
-    state,
-    altGen,
-    altHelper
-  ) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-    if (state.maybeComponent(el) &&
-      el.tag !== 'slot' &&
-      el.tag !== 'template' &&
-      !el.key
-    ) {
-      state.warn(
-        "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-        "v-for should have explicit keys. " +
-        "See https://vuejs.org/guide/list.html#key for more info.",
-        el.rawAttrsMap['v-for'],
-        true /* tip */
-      );
-    }
-
-    el.forProcessed = true; // avoid recursion
-    return (altHelper || '_l') + "((" + exp + ")," +
-      "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
-      '})'
-  }
-
-  function genData$2 (el, state) {
-    var data = '{';
-
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
-    if (dirs) { data += dirs + ','; }
-
-    // key
-    if (el.key) {
-      data += "key:" + (el.key) + ",";
-    }
-    // ref
-    if (el.ref) {
-      data += "ref:" + (el.ref) + ",";
-    }
-    if (el.refInFor) {
-      data += "refInFor:true,";
-    }
-    // pre
-    if (el.pre) {
-      data += "pre:true,";
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-      data += "tag:\"" + (el.tag) + "\",";
-    }
-    // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
-      data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-      data += "attrs:" + (genProps(el.attrs)) + ",";
-    }
-    // DOM props
-    if (el.props) {
-      data += "domProps:" + (genProps(el.props)) + ",";
-    }
-    // event handlers
-    if (el.events) {
-      data += (genHandlers(el.events, false)) + ",";
-    }
-    if (el.nativeEvents) {
-      data += (genHandlers(el.nativeEvents, true)) + ",";
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-      data += "slot:" + (el.slotTarget) + ",";
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-      data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-    }
-    // component v-model
-    if (el.model) {
-      data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-      var inlineTemplate = genInlineTemplate(el, state);
-      if (inlineTemplate) {
-        data += inlineTemplate + ",";
-      }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-      data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data);
-    }
-    return data
-  }
-
-  function genDirectives (el, state) {
-    var dirs = el.directives;
-    if (!dirs) { return }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-      dir = dirs[i];
-      needRuntime = true;
-      var gen = state.directives[dir.name];
-      if (gen) {
-        // compile-time directive that manipulates AST.
-        // returns true if it also needs a runtime counterpart.
-        needRuntime = !!gen(el, dir, state.warn);
-      }
-      if (needRuntime) {
-        hasRuntime = true;
-        res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-      }
-    }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
-  }
-
-  function genInlineTemplate (el, state) {
-    var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
-      state.warn(
-        'Inline-template components must have exactly one child element.',
-        { start: el.start }
-      );
-    }
-    if (ast && ast.type === 1) {
-      var inlineRenderFns = generate(ast, state.options);
-      return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-    }
-  }
-
-  function genScopedSlots (
-    el,
-    slots,
-    state
-  ) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-      var slot = slots[key];
-      return (
-        slot.slotTargetDynamic ||
-        slot.if ||
-        slot.for ||
-        containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-      )
-    });
-
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    var needsKey = !!el.if;
-
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-      var parent = el.parent;
-      while (parent) {
-        if (
-          (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-          parent.for
-        ) {
-          needsForceUpdate = true;
-          break
-        }
-        if (parent.if) {
-          needsKey = true;
-        }
-        parent = parent.parent;
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.staticInFor) {
+          var key = '';
+          var parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      var condition = conditions.shift();
+      if (condition.exp) {
+          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+      }
+      else {
+          return ("" + (genTernaryExp(condition.block)));
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      var exp = el.for;
+      var alias = el.alias;
+      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+              "v-for should have explicit keys. " +
+              "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return ((altHelper || '_l') + "((" + exp + ")," +
+          "function(" + alias + iterator1 + iterator2 + "){" +
+          "return " + ((altGen || genElement)(el, state)) +
+          '})');
+  }
+  function genData$2(el, state) {
+      var data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      var dirs = genDirectives(el, state);
+      if (dirs)
+          { data += dirs + ','; }
+      // key
+      if (el.key) {
+          data += "key:" + (el.key) + ",";
+      }
+      // ref
+      if (el.ref) {
+          data += "ref:" + (el.ref) + ",";
+      }
+      if (el.refInFor) {
+          data += "refInFor:true,";
+      }
+      // pre
+      if (el.pre) {
+          data += "pre:true,";
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += "tag:\"" + (el.tag) + "\",";
+      }
+      // module data generation functions
+      for (var i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += "attrs:" + (genProps(el.attrs)) + ",";
+      }
+      // DOM props
+      if (el.props) {
+          data += "domProps:" + (genProps(el.props)) + ",";
+      }
+      // event handlers
+      if (el.events) {
+          data += (genHandlers(el.events, false)) + ",";
+      }
+      if (el.nativeEvents) {
+          data += (genHandlers(el.nativeEvents, true)) + ",";
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += "slot:" + (el.slotTarget) + ",";
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+      }
+      // component v-model
+      if (el.model) {
+          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          var inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += inlineTemplate + ",";
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      var dirs = el.directives;
+      if (!dirs)
+          { return; }
+      var res = 'directives:[';
+      var hasRuntime = false;
+      var i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          var gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
       }
-    }
-
-    var generatedSlots = Object.keys(slots)
-      .map(function (key) { return genScopedSlot(slots[key], state); })
-      .join(',');
-
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
   }
-
+  function genInlineTemplate(el, state) {
+      var ast = el.children[0];
+      if (el.children.length !== 1 || ast.type !== 1) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          var inlineRenderFns = generate(ast, state.options);
+          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+              .map(function (code) { return ("function(){" + code + "}"); })
+              .join(',')) + "]}");
+      }
+  }
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      var needsForceUpdate = el.for ||
+          Object.keys(slots).some(function (key) {
+              var slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      var needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          var parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
+      }
+      var generatedSlots = Object.keys(slots)
+          .map(function (key) { return genScopedSlot(slots[key], state); })
+          .join(',');
+      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+  }
   function hash(str) {
-    var hash = 5381;
-    var i = str.length;
-    while(i) {
-      hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0
+      var hash = 5381;
+      var i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
+      }
+      return hash >>> 0;
   }
-
-  function containsSlotChild (el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
-      }
-      return el.children.some(containsSlotChild)
-    }
-    return false
-  }
-
-  function genScopedSlot (
-    el,
-    state
-  ) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-      return genIf(el, state, genScopedSlot, "null")
-    }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
-    }
-    var slotScope = el.slotScope === emptySlotScopeToken
-      ? ""
-      : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-      "return " + (el.tag === 'template'
-        ? el.if && isLegacySyntax
-          ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-          : genChildren(el, state) || 'undefined'
-        : genElement(el, state)) + "}";
-    // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-  }
-
-  function genChildren (
-    el,
-    state,
-    checkSkip,
-    altGenElement,
-    altGenNode
-  ) {
-    var children = el.children;
-    if (children.length) {
-      var el$1 = children[0];
-      // optimize single v-for
-      if (children.length === 1 &&
-        el$1.for &&
-        el$1.tag !== 'template' &&
-        el$1.tag !== 'slot'
-      ) {
-        var normalizationType = checkSkip
-          ? state.maybeComponent(el$1) ? ",1" : ",0"
-          : "";
-        return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-      }
-      var normalizationType$1 = checkSkip
-        ? getNormalizationType(children, state.maybeComponent)
-        : 0;
-      var gen = altGenNode || genNode;
-      return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-    }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      var isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, "null");
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+      var fn = "function(" + slotScope + "){" +
+          "return " + (el.tag === 'template'
+              ? el.if && isLegacySyntax
+                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                  : genChildren(el, state) || 'undefined'
+              : genElement(el, state)) + "}";
+      // reverse proxy v-slot without scope on this.$slots
+      var reverseProxy = slotScope ? "" : ",proxy:true";
+      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      var children = el.children;
+      if (children.length) {
+          var el$1 = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el$1.for &&
+              el$1.tag !== 'template' &&
+              el$1.tag !== 'slot') {
+              var normalizationType = checkSkip
+                  ? state.maybeComponent(el$1)
+                      ? ",1"
+                      : ",0"
+                  : "";
+              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+          }
+          var normalizationType$1 = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          var gen = altGenNode || genNode;
+          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+      }
   }
-
   // determine the normalization needed for the children array.
   // 0: no normalization needed
   // 1: simple normalization needed (possible 1-level deep nested array)
   // 2: full normalization needed
-  function getNormalizationType (
-    children,
-    maybeComponent
-  ) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-      var el = children[i];
-      if (el.type !== 1) {
-        continue
-      }
-      if (needsNormalization(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-        res = 2;
-        break
-      }
-      if (maybeComponent(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-        res = 1;
-      }
-    }
-    return res
-  }
-
-  function needsNormalization (el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-  }
-
-  function genNode (node, state) {
-    if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
-    }
-  }
-
-  function genText (text) {
-    return ("_v(" + (text.type === 2
-      ? text.expression // no need for () because already wrapped in _s()
-      : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-  }
-
-  function genComment (comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")")
-  }
-
-  function genSlot (el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
-    var attrs = el.attrs || el.dynamicAttrs
-      ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-          // slot props are camelized
-          name: camelize(attr.name),
-          value: attr.value,
-          dynamic: attr.dynamic
-        }); }))
-      : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
-      res += ",null";
-    }
-    if (attrs) {
-      res += "," + attrs;
-    }
-    if (bind$$1) {
-      res += (attrs ? '' : ',null') + "," + bind$$1;
-    }
-    return res + ')'
+  function getNormalizationType(children, maybeComponent) {
+      var res = 0;
+      for (var i = 0; i < children.length; i++) {
+          var el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+              res = 1;
+          }
+      }
+      return res;
+  }
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+  }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
+  }
+  function genText(text) {
+      return ("_v(" + (text.type === 2
+          ? text.expression // no need for () because already wrapped in _s()
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+  }
+  function genComment(comment) {
+      return ("_e(" + (JSON.stringify(comment.text)) + ")");
+  }
+  function genSlot(el, state) {
+      var slotName = el.slotName || '"default"';
+      var children = genChildren(el, state);
+      var res = "_t(" + slotName + (children ? ("," + children) : '');
+      var attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic,
+          }); }))
+          : null;
+      var bind$$1 = el.attrsMap['v-bind'];
+      if ((attrs || bind$$1) && !children) {
+          res += ",null";
+      }
+      if (attrs) {
+          res += "," + attrs;
+      }
+      if (bind$$1) {
+          res += (attrs ? '' : ',null') + "," + bind$$1;
+      }
+      return res + ')';
   }
-
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent (
-    componentName,
-    el,
-    state
-  ) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-  }
-
-  function genProps (props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      var value = transformSpecialNewlines(prop.value);
-      if (prop.dynamic) {
-        dynamicProps += (prop.name) + "," + value + ",";
-      } else {
-        staticProps += "\"" + (prop.name) + "\":" + value + ",";
-      }
-    }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-    if (dynamicProps) {
-      return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-    } else {
-      return staticProps
-    }
+  function genComponent(componentName, el, state) {
+      var children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+  }
+  function genProps(props) {
+      var staticProps = "";
+      var dynamicProps = "";
+      for (var i = 0; i < props.length; i++) {
+          var prop = props[i];
+          var value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += (prop.name) + "," + value + ",";
+          }
+          else {
+              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+          }
+      }
+      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      if (dynamicProps) {
+          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+      }
+      else {
+          return staticProps;
+      }
   }
-
   // #3895, #4268
-  function transformSpecialNewlines (text) {
-    return text
-      .replace(/\u2028/g, '\\u2028')
-      .replace(/\u2029/g, '\\u2029')
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  /*  */
-
-
-
+  /* @flow */
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp('\\b' + (
-    'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-    'super,throw,while,yield,delete,export,import,return,switch,default,' +
-    'extends,finally,continue,debugger,function,arguments'
-  ).split(',').join('\\b|\\b') + '\\b');
-
+  var prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
   // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp('\\b' + (
-    'delete,typeof,void'
-  ).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+  var unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
   // strip strings in expressions
   var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
   // detect problematic expressions in a template
-  function detectErrors (ast, warn) {
-    if (ast) {
-      checkNode(ast, warn);
-    }
-  }
-
-  function checkNode (node, warn) {
-    if (node.type === 1) {
-      for (var name in node.attrsMap) {
-        if (dirRE.test(name)) {
-          var value = node.attrsMap[name];
-          if (value) {
-            var range = node.rawAttrsMap[name];
-            if (name === 'v-for') {
-              checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-            } else if (name === 'v-slot' || name[0] === '#') {
-              checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-            } else if (onRE.test(name)) {
-              checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-            } else {
-              checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-            }
-          }
-        }
-      }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn);
-        }
-      }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node);
-    }
-  }
-
-  function checkEvent (exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        "avoid using JavaScript unary operator as property name: " +
-        "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-        range
-      );
-    }
-    checkExpression(exp, text, warn, range);
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (var name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  var value = node.attrsMap[name];
+                  if (value) {
+                      var range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                      else {
+                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (var i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
+          }
+      }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
+      }
   }
-
-  function checkFor (node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  function checkEvent(exp, text, warn, range) {
+      var stripped = exp.replace(stripStringRE, '');
+      var keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn("avoid using JavaScript unary operator as property name: " +
+              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+      }
+      checkExpression(exp, text, warn, range);
   }
-
-  function checkIdentifier (
-    ident,
-    type,
-    text,
-    warn,
-    range
-  ) {
-    if (typeof ident === 'string') {
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(("var " + ident + "=_"));
+          }
+          catch (e) {
+              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+          }
+      }
+  }
+  function checkExpression(exp, text, warn, range) {
       try {
-        new Function(("var " + ident + "=_"));
-      } catch (e) {
-        warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-      }
-    }
-  }
-
-  function checkExpression (exp, text, warn, range) {
-    try {
-      new Function(("return " + exp));
-    } catch (e) {
-      var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-      if (keywordMatch) {
-        warn(
-          "avoid using JavaScript keyword as property name: " +
-          "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-          range
-        );
-      } else {
-        warn(
-          "invalid expression: " + (e.message) + " in\n\n" +
-          "    " + exp + "\n\n" +
-          "  Raw expression: " + (text.trim()) + "\n",
-          range
-        );
-      }
-    }
-  }
-
-  function checkFunctionParameterExpression (exp, text, warn, range) {
-    try {
-      new Function(exp, '');
-    } catch (e) {
-      warn(
-        "invalid function parameter expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
+          new Function(("return " + exp));
+      }
+      catch (e) {
+          var keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn("avoid using JavaScript keyword as property name: " +
+                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+          }
+          else {
+              warn("invalid expression: " + (e.message) + " in\n\n" +
+                  "    " + exp + "\n\n" +
+                  "  Raw expression: " + (text.trim()) + "\n", range);
+          }
+      }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+              "    " + exp + "\n\n" +
+              "  Raw expression: " + (text.trim()) + "\n", range);
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var range = 2;
-
-  function generateCodeFrame (
-    source,
-    start,
-    end
-  ) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
-      count += lines[i].length + 1;
-      if (count >= start) {
-        for (var j = i - range; j <= i + range || end > count; j++) {
-          if (j < 0 || j >= lines.length) { continue }
-          res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-          var lineLength = lines[j].length;
-          if (j === i) {
-            // push underline
-            var pad = start - (count - lineLength) + 1;
-            var length = end > count ? lineLength - pad : end - start;
-            res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-          } else if (j > i) {
-            if (end > count) {
-              var length$1 = Math.min(end - count, lineLength);
-              res.push("   |  " + repeat$1("^", length$1));
-            }
-            count += lineLength + 1;
-          }
-        }
-        break
-      }
-    }
-    return res.join('\n')
-  }
-
-  function repeat$1 (str, n) {
-    var result = '';
-    if (n > 0) {
-      while (true) { // eslint-disable-line
-        if (n & 1) { result += str; }
-        n >>>= 1;
-        if (n <= 0) { break }
-        str += str;
-      }
-    }
-    return result
-  }
-
-  /*  */
-
-
-
-  function createFunction (code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code });
-      return noop
-    }
-  }
-
-  function createCompileToFunctionFn (compile) {
-    var cache = Object.create(null);
-
-    return function compileToFunctions (
-      template,
-      options,
-      vm
-    ) {
-      options = extend({}, options);
-      var warn$$1 = options.warn || warn;
-      delete options.warn;
-
-      /* istanbul ignore if */
-      {
-        // detect possible CSP restriction
-        try {
-          new Function('return 1');
-        } catch (e) {
-          if (e.toString().match(/unsafe-eval|CSP/)) {
-            warn$$1(
-              'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-            );
-          }
-        }
-      }
-
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template;
-      if (cache[key]) {
-        return cache[key]
-      }
-
-      // compile
-      var compiled = compile(template, options);
-
-      // check compilation errors/tips
-      {
-        if (compiled.errors && compiled.errors.length) {
-          if (options.outputSourceRange) {
-            compiled.errors.forEach(function (e) {
-              warn$$1(
-                "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-                generateCodeFrame(template, e.start, e.end),
-                vm
-              );
-            });
-          } else {
-            warn$$1(
-              "Error compiling template:\n\n" + template + "\n\n" +
-              compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-              vm
-            );
+  function generateCodeFrame(source, start, end) {
+      if ( start === void 0 ) start = 0;
+      if ( end === void 0 ) end = source.length;
+
+      var lines = source.split(/\r?\n/);
+      var count = 0;
+      var res = [];
+      for (var i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (var j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      { continue; }
+                  res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                  var lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      var pad = start - (count - lineLength) + 1;
+                      var length = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          var length$1 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat$1("^", length$1));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
           }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-          } else {
-            compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+      }
+      return res.join('\n');
+  }
+  function repeat$1(str, n) {
+      var result = '';
+      if (n > 0) {
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  { result += str; }
+              n >>>= 1;
+              if (n <= 0)
+                  { break; }
+              str += str;
           }
-        }
       }
+      return result;
+  }
 
-      // turn code into functions
-      var res = {};
-      var fnGenErrors = [];
-      res.render = createFunction(compiled.render, fnGenErrors);
-      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-        return createFunction(code, fnGenErrors)
-      });
-
-      // check function generation errors.
-      // this should only happen if there is a bug in the compiler itself.
-      // mostly for codegen development use
-      /* istanbul ignore if */
-      {
-        if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-          warn$$1(
-            "Failed to generate render function:\n\n" +
-            fnGenErrors.map(function (ref) {
-              var err = ref.err;
-              var code = ref.code;
-
-              return ((err.toString()) + " in\n\n" + code + "\n");
-          }).join('\n'),
-            vm
-          );
-        }
-      }
-
-      return (cache[key] = res)
-    }
-  }
-
-  /*  */
-
-  function createCompilerCreator (baseCompile) {
-    return function createCompiler (baseOptions) {
-      function compile (
-        template,
-        options
-      ) {
-        var finalOptions = Object.create(baseOptions);
-        var errors = [];
-        var tips = [];
-
-        var warn = function (msg, range, tip) {
-          (tip ? tips : errors).push(msg);
-        };
-
-        if (options) {
-          if (options.outputSourceRange) {
-            // $flow-disable-line
-            var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-            warn = function (msg, range, tip) {
-              var data = { msg: msg };
-              if (range) {
-                if (range.start != null) {
-                  data.start = range.start + leadingSpaceLength;
-                }
-                if (range.end != null) {
-                  data.end = range.end + leadingSpaceLength;
-                }
-              }
-              (tip ? tips : errors).push(data);
-            };
-          }
-          // merge custom modules
-          if (options.modules) {
-            finalOptions.modules =
-              (baseOptions.modules || []).concat(options.modules);
-          }
-          // merge custom directives
-          if (options.directives) {
-            finalOptions.directives = extend(
-              Object.create(baseOptions.directives || null),
-              options.directives
-            );
-          }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key];
-            }
-          }
-        }
-
-        finalOptions.warn = warn;
-
-        var compiled = baseCompile(template.trim(), finalOptions);
-        {
-          detectErrors(compiled.ast, warn);
-        }
-        compiled.errors = errors;
-        compiled.tips = tips;
-        return compiled
+  /* @flow */
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
       }
-
-      return {
-        compile: compile,
-        compileToFunctions: createCompileToFunctionFn(compile)
+      catch (err) {
+          errors.push({ err: err, code: code });
+          return noop;
       }
-    }
+  }
+  function createCompileToFunctionFn(compile) {
+      var cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          var warn$$1 = options.warn || warn;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
+          }
+          // check cache
+          var key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
+          }
+          // compile
+          var compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach(function (e) {
+                          warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                  }
+                  else {
+                      compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                  }
+              }
+          }
+          // turn code into functions
+          var res = {};
+          var fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn$$1("Failed to generate render function:\n\n" +
+                      fnGenErrors
+                          .map(function (ref) {
+                              var err = ref.err;
+                              var code = ref.code;
+
+                              return ((err.toString()) + " in\n\n" + code + "\n");
+                  })
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
   }
 
-  /*  */
+  /* @flow */
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              var finalOptions = Object.create(baseOptions);
+              var errors = [];
+              var tips = [];
+              var warn = function (msg, range, tip) {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = function (msg, range, tip) {
+                          var data = { msg: msg };
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (var key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
+              }
+              finalOptions.warn = warn;
+              var compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
+          }
+          return {
+              compile: compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
+  }
 
+  /* @flow */
   // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
-  var createCompiler = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-      optimize(ast, options);
-    }
-    var code = generate(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
+  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      var ast = parse(template.trim(), options);
+      if (options.optimize !== false) {
+          optimize(ast, options);
+      }
+      var code = generate(ast, options);
+      return {
+          ast: ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
-  /*  */
-
+  /* @flow */
   var ref$1 = createCompiler(baseOptions);
   var compile = ref$1.compile;
   var compileToFunctions = ref$1.compileToFunctions;
 
-  /*  */
-
+  /* @flow */
   // check whether current browser encodes a char inside attribute values
   var div;
-  function getShouldDecode (href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
-    return div.innerHTML.indexOf('&#10;') > 0
+  function getShouldDecode(href) {
+      div = div || document.createElement('div');
+      div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+      return div.innerHTML.indexOf('&#10;') > 0;
   }
-
   // #3663: IE encodes newlines inside attribute values while other browsers don't
   var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
   // #6828: chrome encodes content in a[href]
-  var shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;
-
-  /*  */
+  var shouldDecodeNewlinesForHref = inBrowser
+      ? getShouldDecode(true)
+      : false;
 
+  /* @flow */
   var idToTemplate = cached(function (id) {
-    var el = query(id);
-    return el && el.innerHTML
+      var el = query(id);
+      return el && el.innerHTML;
   });
-
   var mount = Vue.prototype.$mount;
-  Vue.prototype.$mount = function (
-    el,
-    hydrating
-  ) {
-    el = el && query(el);
-
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-      warn(
-        "Do not mount Vue to <html> or <body> - mount to normal elements instead."
-      );
-      return this
-    }
-
-    var options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-      var template = options.template;
-      if (template) {
-        if (typeof template === 'string') {
-          if (template.charAt(0) === '#') {
-            template = idToTemplate(template);
-            /* istanbul ignore if */
-            if (!template) {
-              warn(
-                ("Template element not found or is empty: " + (options.template)),
-                this
-              );
-            }
+  Vue.prototype.$mount = function (el, hydrating) {
+      el = el && query(el);
+      /* istanbul ignore if */
+      if (el === document.body || el === document.documentElement) {
+          warn("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+          return this;
+      }
+      var options = this.$options;
+      // resolve template/el and convert to render function
+      if (!options.render) {
+          var template = options.template;
+          if (template) {
+              if (typeof template === 'string') {
+                  if (template.charAt(0) === '#') {
+                      template = idToTemplate(template);
+                      /* istanbul ignore if */
+                      if (!template) {
+                          warn(("Template element not found or is empty: " + (options.template)), this);
+                      }
+                  }
+              }
+              else if (template.nodeType) {
+                  template = template.innerHTML;
+              }
+              else {
+                  {
+                      warn('invalid template option:' + template, this);
+                  }
+                  return this;
+              }
           }
-        } else if (template.nodeType) {
-          template = template.innerHTML;
-        } else {
-          {
-            warn('invalid template option:' + template, this);
-          }
-          return this
-        }
-      } else if (el) {
-        template = getOuterHTML(el);
-      }
-      if (template) {
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-          mark('compile');
-        }
-
-        var ref = compileToFunctions(template, {
-          outputSourceRange: "development" !== 'production',
-          shouldDecodeNewlines: shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
-          delimiters: options.delimiters,
-          comments: options.comments
-        }, this);
-        var render = ref.render;
-        var staticRenderFns = ref.staticRenderFns;
-        options.render = render;
-        options.staticRenderFns = staticRenderFns;
-
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-          mark('compile end');
-          measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
-        }
-      }
-    }
-    return mount.call(this, el, hydrating)
+          else if (el) {
+              // @ts-expect-error
+              template = getOuterHTML(el);
+          }
+          if (template) {
+              /* istanbul ignore if */
+              if (config.performance && mark) {
+                  mark('compile');
+              }
+              var ref = compileToFunctions(template, {
+                  outputSourceRange: "development" !== 'production',
+                  shouldDecodeNewlines: shouldDecodeNewlines,
+                  shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                  delimiters: options.delimiters,
+                  comments: options.comments,
+              }, this);
+              var render = ref.render;
+              var staticRenderFns = ref.staticRenderFns;
+              options.render = render;
+              options.staticRenderFns = staticRenderFns;
+              /* istanbul ignore if */
+              if (config.performance && mark) {
+                  mark('compile end');
+                  measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+              }
+          }
+      }
+      return mount.call(this, el, hydrating);
   };
-
   /**
    * Get outerHTML of elements, taking care
    * of SVG elements in IE as well.
    */
-  function getOuterHTML (el) {
-    if (el.outerHTML) {
-      return el.outerHTML
-    } else {
-      var container = document.createElement('div');
-      container.appendChild(el.cloneNode(true));
-      return container.innerHTML
-    }
+  function getOuterHTML(el) {
+      if (el.outerHTML) {
+          return el.outerHTML;
+      }
+      else {
+          var container = document.createElement('div');
+          container.appendChild(el.cloneNode(true));
+          return container.innerHTML;
+      }
   }
-
   Vue.compile = compileToFunctions;
 
   return Vue;
diff --git a/dist/vue.min.js b/dist/vue.min.js
index 41094e008aa..e9fd8446ac2 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e=e||self).Vue=t()}(this,function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},E=function(e){return e};function N(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return N(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return N(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(N(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B,U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),J=z&&window.navigator.userAgent.toLowerCase(),q=J&&/msie|trident/.test(J),W=J&&J.indexOf("msie 9.0")>0,Z=J&&J.indexOf("edge/")>0,G=(J&&J.indexOf("android"),J&&/iphone|ipad|ipod|ios/.test(J)||"ios"===K),X=(J&&/chrome\/\d+/.test(J),J&&/phantomjs/.test(J),J&&J.match(/firefox\/(\d+)/)),Y={}.watch,Q=!1;if(z)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===B&&(B=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),B},ne=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(pe.prototype,de);var ve=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function he(e){return new pe(void 0,void 0,void 0,String(e))}function me(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=ye[e];R(ge,e,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var _e=Object.getOwnPropertyNames(ge),be=!0;function $e(e){be=e}var we=function(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(U?(t=ge,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ge,_e),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof we?n=e.__ob__:be&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new we(e)),t&&n&&n.vmCount++,n}function xe(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&Ce(t),o.notify())}})}}function ke(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(xe(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Ae(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}we.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)xe(e,t[n])},we.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Oe=F.optionMergeStrategies;function Se(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Se(r,i):ke(e,n,i));return e}function Te(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Se(r,i):i}:t?e?function(){return Se("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ee(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Oe.data=function(e,t,n){return n?Te(e,t,n):t&&"function"!=typeof t?e:Te(e,t)},I.forEach(function(e){Oe[e]=Ee}),M.forEach(function(e){Oe[e+"s"]=Ne}),Oe.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Oe.props=Oe.methods=Oe.inject=Oe.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Oe.provide=Te;var je=function(e,t){return void 0===t?e:t};function De(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=De(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=De(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Oe[r]||je;a[r]=i(e[r],t[r],n,r)}return a}function Le(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Me(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=be;$e(!0),Ce(a),$e(u)}return a}function Ie(e){var t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t,null,"config.errorHandler")}Ue(e,t,n)}function Ue(e,t,n){if(!z&&!V||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),G&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)He(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[he(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=he(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=he(f.text+u):""!==u&&s.push(he(u)):st(u)&&st(f)?s[l]=he(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c;if(Array.isArray(e)||"string"==typeof e)for(r=new Array(e.length),i=0,a=e.length;i<a;i++)r[i]=t(e[i],i);else if("number"==typeof e)for(r=new Array(e),i=0;i<e;i++)r[i]=t(i+1,i);else if(o(e))if(oe&&e[Symbol.iterator]){r=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)r.push(t(l.value,r.length)),l=u.next()}else for(s=Object.keys(e),r=new Array(s.length),i=0,a=s.length;i<a;i++)c=s[i],r[i]=t(e[c],c,i);return n(r)||(r=[]),r._isVList=!0,r}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return Le(this.$options,"filters",e)||E}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=N,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=he,e._e=ve,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Et(e,t,n,r,i){var o=me(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Nt(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){$e(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Me(d,v,n,t)}$e(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=ve();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Me(l,u,r||e);else n(i.attrs)&&Nt(c,i.attrs),n(i.props)&&Nt(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Et(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Et(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return ve();n(a)&&n(a.is)&&(i=a.is);if(!i)return ve();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=Le(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):ve()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(z&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};fn.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},fn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},fn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},fn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},fn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},fn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},fn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},fn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var o=function(o){i.push(o);var a=Me(o,t,n,e);xe(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);$e(!0)}(e,t.props),t.methods&&function(e,t){e.$options.props;for(var n in t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props,i=(e.$options.methods,n.length);for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=De(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=De(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=De($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;xe(t,"$attrs",o&&o.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach(function(n){xe(e,n,t[n])}),$e(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Ae,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate)try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=ve()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:De,defineReactive:xe},e.set=ke,e.delete=Ae,e.nextTick=Ye,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=De(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var En=p("style,class"),Nn=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&Nn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=Le(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a);for(o in(q||Z)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n){e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(q&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Er(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Nr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=q?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=z&&!W,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ei(e){Ti(function(){Ti(e)})}function Ni(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,E=O&&v?v:l,N=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!W,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,E),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),N&&N(i),F&&(Ni(i,S),Ni(i,T),Ei(function(){ji(i,S),R.cancelled||(Ni(i,E),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ni(i,u),Ni(i,p),Ei(function(){ji(i,u),w.cancelled||(Ni(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=me(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=me(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,z?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});W&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),W&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!N(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t,n),(q||Z)&&setTimeout(function(){Ji(e,t,n)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(N(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!N(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=e(t,null,u),this.removed=l}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ni(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=En,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!z)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=z?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&z?Yn(e):void 0,t)},z&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo,go={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},_o=function(e){return(yo=yo||document.createElement("div")).innerHTML=e,yo.textContent},bo=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),$o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),wo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Co=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ko="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ao="((?:"+ko+"\\:)?"+ko+")",Oo=new RegExp("^<"+Ao),So=/^\s*(\/?)>/,To=new RegExp("^<\\/"+Ao+"[^>]*>"),Eo=/^<!DOCTYPE [^>]+>/i,No=/^<!\--/,jo=/^<!\[/,Do=p("script,style,textarea",!0),Lo={},Mo={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Io=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Po=p("pre,textarea",!0),Ro=function(e,t){return e&&Po(e)&&"\n"===t[0]};function Ho(e,t){var n=t?Fo:Io;return e.replace(n,function(e){return Mo[e]})}var Bo,Uo,zo,Vo,Ko,Jo,qo,Wo,Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/\s+/g,sa=g(_o),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Bo=t.warn||Sr,Jo=t.isPreTag||T,qo=t.mustUseProp||T,Wo=t.getTagNamespace||T;t.isReservedTag;zo=Tr(t.modules,"transformNode"),Vo=Tr(t.modules,"preTransformNode"),Ko=Tr(t.modules,"postTransformNode"),Uo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Jo(e.tag)&&(c=!1);for(var f=0;f<Ko.length;f++)Ko[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&Do(r)){var u=0,l=r.toLowerCase(),f=Lo[l]||(Lo[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,function(e,n,r){return u=r.length,Do(l)||"noscript"===l||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ro(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(No.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(jo.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(Eo);if(m){C(m[0].length);continue}var y=e.match(To);if(y){var g=c;C(y[0].length),A(y[1],g,c);continue}var _=x();if(_){k(_),Ro(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(To.test($)||Oo.test($)||No.test($)||jo.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Oo);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(So))&&(r=e.match(xo)||e.match(Co));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&wo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Ho(v,h)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,u,e.start,e.end)}function A(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Bo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||Wo(e);q&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<Vo.length;h++)v=Vo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Jo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u,l,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):f.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(aa," ")),!s&&" "!==e&&(u=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Uo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Nr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var s=Pr(e,ia);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=va(s),l=u.name,f=u.dynamic,p=c[l]=ua("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=p,!0}),p.slotScope=s.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<zo.length;i++)e=zo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&qo(e.tag,e.attrsMap.type,r)?Er(e,r,o,u[t],c):Nr(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Nr(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&qo(e.tag,e.attrsMap.type,r)&&Er(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,go,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Ir(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+n+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",n),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Er(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Er(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:bo,mustUseProp:jn,canBeLeftOpenTag:$o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++){var s=t.ifConditions[o].block;e(s),s.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++)e(t.ifConditions[o].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ea={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Na=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Na("$event.target !== $event.currentTarget"),ctrl:Na("!$event.ctrlKey"),shift:Na("!$event.shiftKey"),alt:Na("!$event.altKey"),meta:Na("!$event.metaKey"),left:Na("'button' in $event && $event.button !== 0"),middle:Na("'button' in $event && $event.button !== 1"),right:Na("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(ja[s])o+=ja[s],Ta[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=Na(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+"($event)":n?"return ("+e.value+")($event)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Ea[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn;delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca),rs=(ns.compile,ns.compileToFunctions);function is(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var os=!!z&&is(!1),as=!!z&&is(!0),ss=g(function(e){var t=Yn(e);return t&&t.innerHTML}),cs=wn.prototype.$mount;return wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ss(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=rs(r,{outputSourceRange:!1,shouldDecodeNewlines:os,shouldDecodeNewlinesForHref:as,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return cs.call(this,e,t)},wn.compile=rs,wn});
\ No newline at end of file
+!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?module.exports=r():"function"==typeof define&&define.amd?define(r):(e=e||self).Vue=r()}(this,function(){"use strict";var e=Object.freeze({});function r(e){return null==e}function t(e){return null!=e}function n(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var i=Object.prototype.toString;function s(e){return"[object Object]"===i.call(e)}function c(e){var r=parseFloat(String(e));return r>=0&&Math.floor(r)===r&&isFinite(e)}function u(e){return t(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===i?JSON.stringify(e,null,2):String(e)}function p(e){var r=parseFloat(e);return isNaN(r)?e:r}function f(e,r){for(var t=Object.create(null),n=e.split(","),a=0;a<n.length;a++)t[n[a]]=!0;return r?function(e){return t[e.toLowerCase()]}:function(e){return t[e]}}var d=f("slot,component",!0),m=f("key,ref,slot,slot-scope,is");function h(e,r){if(e.length){var t=e.indexOf(r);if(t>-1)return e.splice(t,1)}}var v=Object.prototype.hasOwnProperty;function g(e,r){return v.call(e,r)}function b(e){var r=Object.create(null);return function(t){return r[t]||(r[t]=e(t))}}var y=/-(\w)/g,w=b(function(e){return e.replace(y,function(e,r){return r?r.toUpperCase():""})}),A=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),D=/\B([A-Z])/g,x=b(function(e){return e.replace(D,"-$1").toLowerCase()});var q=Function.prototype.bind?function(e,r){return e.bind(r)}:function(e,r){function t(t){var n=arguments.length;return n?n>1?e.apply(r,arguments):e.call(r,t):e.call(r)}return t._length=e.length,t};function k(e,r){r=r||0;for(var t=e.length-r,n=new Array(t);t--;)n[t]=e[t+r];return n}function E(e,r){for(var t in r)e[t]=r[t];return e}function _(e){for(var r={},t=0;t<e.length;t++)e[t]&&E(r,e[t]);return r}function C(e,r,t){}var S=function(e,r,t){return!1},L=function(e){return e};function T(e,r){if(e===r)return!0;var t=o(e),n=o(r);if(!t||!n)return!t&&!n&&String(e)===String(r);try{var a=Array.isArray(e),i=Array.isArray(r);if(a&&i)return e.length===r.length&&e.every(function(e,t){return T(e,r[t])});if(e instanceof Date&&r instanceof Date)return e.getTime()===r.getTime();if(a||i)return!1;var s=Object.keys(e),c=Object.keys(r);return s.length===c.length&&s.every(function(t){return T(e[t],r[t])})}catch(e){return!1}}function $(e,r){for(var t=0;t<e.length;t++)if(T(e[t],r))return t;return-1}function N(e){var r=!1;return function(){r||(r=!0,e.apply(this,arguments))}}var O="data-server-rendered",R=["component","directive","filter"],F=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],B={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:C,parsePlatformTagName:L,mustUseProp:S,async:!0,_lifecycleHooks:F},U=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function V(e,r,t,n){Object.defineProperty(e,r,{value:t,enumerable:!!n,writable:!0,configurable:!0})}var I=new RegExp("[^"+U.source+".$_\\d]");var j,P="__proto__"in{},H="undefined"!=typeof window,M="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,G=M&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),J=z&&/msie|trident/.test(z),K=z&&z.indexOf("msie 9.0")>0,Z=z&&z.indexOf("edge/")>0,Y=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===G),W=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Q={}.watch,X=!1;if(H)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){X=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var re=function(){return void 0===j&&(j=!H&&!M&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),j},te=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ne(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,oe="undefined"!=typeof Symbol&&ne(Symbol)&&"undefined"!=typeof Reflect&&ne(Reflect.ownKeys);ae="undefined"!=typeof Set&&ne(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ie=C,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),r=0,t=e.length;r<t;r++)e[r].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function pe(){ue.pop(),ce.target=ue[ue.length-1]}var fe=function(e,r,t,n,a,o,i,s){this.tag=e,this.data=r,this.children=t,this.text=n,this.elm=a,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=r&&r.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(fe.prototype,de);var me=function(e){void 0===e&&(e="");var r=new fe;return r.text=e,r.isComment=!0,r};function he(e){return new fe(void 0,void 0,void 0,String(e))}function ve(e){var r=new fe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return r.ns=e.ns,r.isStatic=e.isStatic,r.key=e.key,r.isComment=e.isComment,r.fnContext=e.fnContext,r.fnOptions=e.fnOptions,r.fnScopeId=e.fnScopeId,r.asyncMeta=e.asyncMeta,r.isCloned=!0,r}var ge=Array.prototype,be=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var r=ge[e];V(be,e,function(){for(var t=[],n=arguments.length;n--;)t[n]=arguments[n];var a,o=r.apply(this,t),i=this.__ob__;switch(e){case"push":case"unshift":a=t;break;case"splice":a=t.slice(2)}return a&&i.observeArray(a),i.dep.notify(),o})});var ye=Object.getOwnPropertyNames(be),we=!0;function Ae(e){we=e}var De=function(e){var r;this.value=e,this.dep=new ce,this.vmCount=0,V(e,"__ob__",this),Array.isArray(e)?(P?(r=be,e.__proto__=r):function(e,r,t){for(var n=0,a=t.length;n<a;n++){var o=t[n];V(e,o,r[o])}}(e,be,ye),this.observeArray(e)):this.walk(e)};function xe(e,r){var t;if(o(e)&&!(e instanceof fe))return g(e,"__ob__")&&e.__ob__ instanceof De?t=e.__ob__:we&&!re()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(t=new De(e)),r&&t&&t.vmCount++,t}function qe(e,r,t,n,a){var o=new ce,i=Object.getOwnPropertyDescriptor(e,r);if(!i||!1!==i.configurable){var s=i&&i.get,c=i&&i.set;s&&!c||2!==arguments.length||(t=e[r]);var u=!a&&xe(t);Object.defineProperty(e,r,{enumerable:!0,configurable:!0,get:function(){var r=s?s.call(e):t;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(r)&&function e(r){for(var t=void 0,n=0,a=r.length;n<a;n++)(t=r[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&e(t)}(r))),r},set:function(r){var n=s?s.call(e):t;r===n||r!=r&&n!=n||s&&!c||(c?c.call(e,r):t=r,u=!a&&xe(r),o.notify())}})}}function ke(e,r,t){if(Array.isArray(e)&&c(r))return e.length=Math.max(e.length,r),e.splice(r,1,t),t;if(r in e&&!(r in Object.prototype))return e[r]=t,t;var n=e.__ob__;return e._isVue||n&&n.vmCount?t:n?(qe(n.value,r,t),n.dep.notify(),t):(e[r]=t,t)}function Ee(e,r){if(Array.isArray(e)&&c(r))e.splice(r,1);else{var t=e.__ob__;e._isVue||t&&t.vmCount||g(e,r)&&(delete e[r],t&&t.dep.notify())}}De.prototype.walk=function(e){for(var r=Object.keys(e),t=0;t<r.length;t++)qe(e,r[t])},De.prototype.observeArray=function(e){for(var r=0,t=e.length;r<t;r++)xe(e[r])};var _e=B.optionMergeStrategies;function Ce(e,r){if(!r)return e;for(var t,n,a,o=oe?Reflect.ownKeys(r):Object.keys(r),i=0;i<o.length;i++)"__ob__"!==(t=o[i])&&(n=e[t],a=r[t],g(e,t)?n!==a&&s(n)&&s(a)&&Ce(n,a):ke(e,t,a));return e}function Se(e,r,t){return t?function(){var n="function"==typeof r?r.call(t,t):r,a="function"==typeof e?e.call(t,t):e;return n?Ce(n,a):a}:r?e?function(){return Ce("function"==typeof r?r.call(this,this):r,"function"==typeof e?e.call(this,this):e)}:r:e}function Le(e,r){var t=r?e?e.concat(r):Array.isArray(r)?r:[r]:e;return t?function(e){for(var r=[],t=0;t<e.length;t++)-1===r.indexOf(e[t])&&r.push(e[t]);return r}(t):t}function Te(e,r,t,n){var a=Object.create(e||null);return r?E(a,r):a}_e.data=function(e,r,t){return t?Se(e,r,t):r&&"function"!=typeof r?e:Se(e,r)},F.forEach(function(e){_e[e]=Le}),R.forEach(function(e){_e[e+"s"]=Te}),_e.watch=function(e,r,t,n){if(e===Q&&(e=void 0),r===Q&&(r=void 0),!r)return Object.create(e||null);if(!e)return r;var a={};for(var o in E(a,e),r){var i=a[o],s=r[o];i&&!Array.isArray(i)&&(i=[i]),a[o]=i?i.concat(s):Array.isArray(s)?s:[s]}return a},_e.props=_e.methods=_e.inject=_e.computed=function(e,r,t,n){if(!e)return r;var a=Object.create(null);return E(a,e),r&&E(a,r),a},_e.provide=Se;var $e=function(e,r){return void 0===r?e:r};function Ne(e,r,t){if("function"==typeof r&&(r=r.options),function(e,r){var t=e.props;if(t){var n,a,o={};if(Array.isArray(t))for(n=t.length;n--;)"string"==typeof(a=t[n])&&(o[w(a)]={type:null});else if(s(t))for(var i in t)a=t[i],o[w(i)]=s(a)?a:{type:a};e.props=o}}(r),function(e,r){var t=e.inject;if(t){var n=e.inject={};if(Array.isArray(t))for(var a=0;a<t.length;a++)n[t[a]]={from:t[a]};else if(s(t))for(var o in t){var i=t[o];n[o]=s(i)?E({from:o},i):{from:i}}}}(r),function(e){var r=e.directives;if(r)for(var t in r){var n=r[t];"function"==typeof n&&(r[t]={bind:n,update:n})}}(r),!r._base&&(r.extends&&(e=Ne(e,r.extends,t)),r.mixins))for(var n=0,a=r.mixins.length;n<a;n++)e=Ne(e,r.mixins[n],t);var o,i={};for(o in e)c(o);for(o in r)g(e,o)||c(o);function c(n){var a=_e[n]||$e;i[n]=a(e[n],r[n],t,n)}return i}function Oe(e,r,t,n){if("string"==typeof t){var a=e[r];if(g(a,t))return a[t];var o=w(t);if(g(a,o))return a[o];var i=A(o);return g(a,i)?a[i]:a[t]||a[o]||a[i]}}function Re(e,r,t,n){var a=r[e],o=!g(t,e),i=t[e],s=Ve(Boolean,a.type);if(s>-1)if(o&&!g(a,"default"))i=!1;else if(""===i||i===x(e)){var c=Ve(String,a.type);(c<0||s<c)&&(i=!0)}if(void 0===i){i=function(e,r,t){if(!g(r,"default"))return;var n=r.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[t]&&void 0!==e._props[t])return e._props[t];return"function"==typeof n&&"Function"!==Be(r.type)?n.call(e):n}(n,a,e);var u=we;Ae(!0),xe(i),Ae(u)}return i}var Fe=/^\s*function (\w+)/;function Be(e){var r=e&&e.toString().match(Fe);return r?r[1]:""}function Ue(e,r){return Be(e)===Be(r)}function Ve(e,r){if(!Array.isArray(r))return Ue(r,e)?0:-1;for(var t=0,n=r.length;t<n;t++)if(Ue(r[t],e))return t;return-1}function Ie(e,r,t){le();try{if(r)for(var n=r;n=n.$parent;){var a=n.$options.errorCaptured;if(a)for(var o=0;o<a.length;o++)try{if(!1===a[o].call(n,e,r,t))return}catch(e){Pe(e,n,"errorCaptured hook")}}Pe(e,r,t)}finally{pe()}}function je(e,r,t,n,a){var o;try{(o=t?e.apply(r,t):e.call(r))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Ie(e,n,a+" (Promise/async)")}),o._handled=!0)}catch(e){Ie(e,n,a)}return o}function Pe(e,r,t){if(B.errorHandler)try{return B.errorHandler.call(null,e,r,t)}catch(r){r!==e&&He(r,null,"config.errorHandler")}He(e,r,t)}function He(e,r,t){if(!H&&!M||"undefined"==typeof console)throw e;console.error(e)}var Me,Ge=!1,ze=[],Je=!1;function Ke(){Je=!1;var e=ze.slice(0);ze.length=0;for(var r=0;r<e.length;r++)e[r]()}if("undefined"!=typeof Promise&&ne(Promise)){var Ze=Promise.resolve();Me=function(){Ze.then(Ke),Y&&setTimeout(C)},Ge=!0}else if(J||"undefined"==typeof MutationObserver||!ne(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Me="undefined"!=typeof setImmediate&&ne(setImmediate)?function(){setImmediate(Ke)}:function(){setTimeout(Ke,0)};else{var Ye=1,We=new MutationObserver(Ke),Qe=document.createTextNode(String(Ye));We.observe(Qe,{characterData:!0}),Me=function(){Ye=(Ye+1)%2,Qe.data=String(Ye)},Ge=!0}function Xe(e,r){var t;if(ze.push(function(){if(e)try{e.call(r)}catch(e){Ie(e,r,"nextTick")}else t&&t(r)}),Je||(Je=!0,Me()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){t=e})}var er=new ae;function rr(e){!function e(r,t){var n,a;var i=Array.isArray(r);if(!i&&!o(r)||Object.isFrozen(r)||r instanceof fe)return;if(r.__ob__){var s=r.__ob__.dep.id;if(t.has(s))return;t.add(s)}if(i)for(n=r.length;n--;)e(r[n],t);else for(a=Object.keys(r),n=a.length;n--;)e(r[a[n]],t)}(e,er),er.clear()}var tr=b(function(e){var r="&"===e.charAt(0),t="~"===(e=r?e.slice(1):e).charAt(0),n="!"===(e=t?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:t,capture:n,passive:r}});function nr(e,r){function t(){var e=arguments,n=t.fns;if(!Array.isArray(n))return je(n,null,arguments,r,"v-on handler");for(var a=n.slice(),o=0;o<a.length;o++)je(a[o],null,e,r,"v-on handler")}return t.fns=e,t}function ar(e,t,a,o,i,s){var c,u,l,p;for(c in e)u=e[c],l=t[c],p=tr(c),r(u)||(r(l)?(r(u.fns)&&(u=e[c]=nr(u,s)),n(p.once)&&(u=e[c]=i(p.name,u,p.capture)),a(p.name,u,p.capture,p.passive,p.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)r(e[c])&&o((p=tr(c)).name,t[c],p.capture)}function or(e,a,o){var i;e instanceof fe&&(e=e.data.hook||(e.data.hook={}));var s=e[a];function c(){o.apply(this,arguments),h(i.fns,c)}r(s)?i=nr([c]):t(s.fns)&&n(s.merged)?(i=s).fns.push(c):i=nr([s,c]),i.merged=!0,e[a]=i}function ir(e,r,n,a,o){if(t(r)){if(g(r,n))return e[n]=r[n],o||delete r[n],!0;if(g(r,a))return e[n]=r[a],o||delete r[a],!0}return!1}function sr(e){return a(e)?[he(e)]:Array.isArray(e)?function e(o,i){var s=[];var c,u,l,p;for(c=0;c<o.length;c++)r(u=o[c])||"boolean"==typeof u||(l=s.length-1,p=s[l],Array.isArray(u)?u.length>0&&(cr((u=e(u,(i||"")+"_"+c))[0])&&cr(p)&&(s[l]=he(p.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?cr(p)?s[l]=he(p.text+u):""!==u&&s.push(he(u)):cr(u)&&cr(p)?s[l]=he(p.text+u.text):(n(o._isVList)&&t(u.tag)&&r(u.key)&&t(i)&&(u.key="__vlist"+i+"_"+c+"__"),s.push(u)));return s}(e):void 0}function cr(e){return t(e)&&t(e.text)&&!1===e.isComment}function ur(e,r){if(e){for(var t=Object.create(null),n=oe?Reflect.ownKeys(e):Object.keys(e),a=0;a<n.length;a++){var o=n[a];if("__ob__"!==o){for(var i=e[o].from,s=r;s;){if(s._provided&&g(s._provided,i)){t[o]=s._provided[i];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;t[o]="function"==typeof c?c.call(r):c}}}return t}}function lr(e,r){if(!e||!e.length)return{};for(var t={},n=0,a=e.length;n<a;n++){var o=e[n],i=o.data;if(i&&i.attrs&&i.attrs.slot&&delete i.attrs.slot,o.context!==r&&o.fnContext!==r||!i||null==i.slot)(t.default||(t.default=[])).push(o);else{var s=i.slot,c=t[s]||(t[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in t)t[u].every(pr)&&delete t[u];return t}function pr(e){return e.isComment&&!e.asyncFactory||" "===e.text}function fr(r,t,n){var a,o=Object.keys(t).length>0,i=r?!!r.$stable:!o,s=r&&r.$key;if(r){if(r._normalized)return r._normalized;if(i&&n&&n!==e&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in a={},r)r[c]&&"$"!==c[0]&&(a[c]=dr(t,c,r[c]))}else a={};for(var u in t)u in a||(a[u]=mr(t,u));return r&&Object.isExtensible(r)&&(r._normalized=a),V(a,"$stable",i),V(a,"$key",s),V(a,"$hasNormal",o),a}function dr(e,r,t){var n=function(){var e=arguments.length?t.apply(null,arguments):t({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:sr(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return t.proxy&&Object.defineProperty(e,r,{get:n,enumerable:!0,configurable:!0}),n}function mr(e,r){return function(){return e[r]}}function hr(e,r){var n,a,i,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,a=e.length;n<a;n++)c[n]=r(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=r(n+1,n);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(r(l.value,c.length)),l=u.next()}else for(i=Object.keys(e),c=new Array(i.length),n=0,a=i.length;n<a;n++)s=i[n],c[n]=r(e[s],s,n);return t(c)||(c=[]),c._isVList=!0,c}function vr(e,r,t,n){var a,o=this.$scopedSlots[e];o?(t=t||{},n&&(t=E(E({},n),t)),a=o(t)||r):a=this.$slots[e]||r;var i=t&&t.slot;return i?this.$createElement("template",{slot:i},a):a}function gr(e){return Oe(this.$options,"filters",e)||L}function br(e,r){return Array.isArray(e)?-1===e.indexOf(r):e!==r}function yr(e,r,t,n,a){var o=B.keyCodes[r]||t;return a&&n&&!B.keyCodes[r]?br(a,n):o?br(o,e):n?x(n)!==r:void 0}function wr(e,r,t,n,a){if(t)if(o(t)){var i;Array.isArray(t)&&(t=_(t));var s=function(o){if("class"===o||"style"===o||m(o))i=e;else{var s=e.attrs&&e.attrs.type;i=n||B.mustUseProp(r,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(o),u=x(o);c in i||u in i||(i[o]=t[o],a&&((e.on||(e.on={}))["update:"+o]=function(e){t[o]=e}))};for(var c in t)s(c)}else;return e}function Ar(e,r){var t=this._staticTrees||(this._staticTrees=[]),n=t[e];return n&&!r?n:(xr(n=t[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function Dr(e,r,t){return xr(e,"__once__"+r+(t?"_"+t:""),!0),e}function xr(e,r,t){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&qr(e[n],r+"_"+n,t);else qr(e,r,t)}function qr(e,r,t){e.isStatic=!0,e.key=r,e.isOnce=t}function kr(e,r){if(r)if(s(r)){var t=e.on=e.on?E({},e.on):{};for(var n in r){var a=t[n],o=r[n];t[n]=a?[].concat(a,o):o}}else;return e}function Er(e,r,t,n){r=r||{$stable:!t};for(var a=0;a<e.length;a++){var o=e[a];Array.isArray(o)?Er(o,r,t):o&&(o.proxy&&(o.fn.proxy=!0),r[o.key]=o.fn)}return n&&(r.$key=n),r}function _r(e,r){for(var t=0;t<r.length;t+=2){var n=r[t];"string"==typeof n&&n&&(e[r[t]]=r[t+1])}return e}function Cr(e,r){return"string"==typeof e?r+e:e}function Sr(e){e._o=Dr,e._n=p,e._s=l,e._l=hr,e._t=vr,e._q=T,e._i=$,e._m=Ar,e._f=gr,e._k=yr,e._b=wr,e._v=he,e._e=me,e._u=Er,e._g=kr,e._d=_r,e._p=Cr}function Lr(r,t,a,o,i){var s,c=this,u=i.options;g(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=n(u._compiled),p=!l;this.data=r,this.props=t,this.children=a,this.parent=o,this.listeners=r.on||e,this.injections=ur(u.inject,o),this.slots=function(){return c.$slots||fr(r.scopedSlots,c.$slots=lr(a,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return fr(r.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=fr(r.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,r,t,n){var a=Vr(s,e,r,t,n,p);return a&&!Array.isArray(a)&&(a.fnScopeId=u._scopeId,a.fnContext=o),a}:this._c=function(e,r,t,n){return Vr(s,e,r,t,n,p)}}function Tr(e,r,t,n,a){var o=ve(e);return o.fnContext=t,o.fnOptions=n,r.slot&&((o.data||(o.data={})).slot=r.slot),o}function $r(e,r){for(var t in r)e[w(t)]=r[t]}Sr(Lr.prototype);var Nr={init:function(e,r){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var n=e;Nr.prepatch(n,n)}else{(e.componentInstance=function(e,r){var n={_isComponent:!0,_parentVnode:e,parent:r},a=e.data.inlineTemplate;t(a)&&(n.render=a.render,n.staticRenderFns=a.staticRenderFns);return new e.componentOptions.Ctor(n)}(e,Zr)).$mount(r?e.elm:void 0,r)}},prepatch:function(r,t){var n=t.componentOptions;!function(r,t,n,a,o){var i=a.data.scopedSlots,s=r.$scopedSlots,c=!!(i&&!i.$stable||s!==e&&!s.$stable||i&&r.$scopedSlots.$key!==i.$key),u=!!(o||r.$options._renderChildren||c);r.$options._parentVnode=a,r.$vnode=a,r._vnode&&(r._vnode.parent=a);if(r.$options._renderChildren=o,r.$attrs=a.data.attrs||e,r.$listeners=n||e,t&&r.$options.props){Ae(!1);for(var l=r._props,p=r.$options._propKeys||[],f=0;f<p.length;f++){var d=p[f],m=r.$options.props;l[d]=Re(d,m,t,r)}Ae(!0),r.$options.propsData=t}n=n||e;var h=r.$options._parentListeners;r.$options._parentListeners=n,Kr(r,n,h),u&&(r.$slots=lr(o,a.context),r.$forceUpdate())}(t.componentInstance=r.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var r,t=e.context,n=e.componentInstance;n._isMounted||(n._isMounted=!0,Xr(n,"mounted")),e.data.keepAlive&&(t._isMounted?((r=n)._inactive=!1,rt.push(r)):Qr(n,!0))},destroy:function(e){var r=e.componentInstance;r._isDestroyed||(e.data.keepAlive?function e(r,t){if(t&&(r._directInactive=!0,Wr(r)))return;if(!r._inactive){r._inactive=!0;for(var n=0;n<r.$children.length;n++)e(r.$children[n]);Xr(r,"deactivated")}}(r,!0):r.$destroy())}},Or=Object.keys(Nr);function Rr(a,i,s,c,l){if(!r(a)){var p=s.$options._base;if(o(a)&&(a=p.extend(a)),"function"==typeof a){var f;if(r(a.cid)&&void 0===(a=function(e,a){if(n(e.error)&&t(e.errorComp))return e.errorComp;if(t(e.resolved))return e.resolved;var i=jr;i&&t(e.owners)&&-1===e.owners.indexOf(i)&&e.owners.push(i);if(n(e.loading)&&t(e.loadingComp))return e.loadingComp;if(i&&!t(e.owners)){var s=e.owners=[i],c=!0,l=null,p=null;i.$on("hook:destroyed",function(){return h(s,i)});var f=function(e){for(var r=0,t=s.length;r<t;r++)s[r].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==p&&(clearTimeout(p),p=null))},d=N(function(r){e.resolved=Pr(r,a),c?s.length=0:f(!0)}),m=N(function(r){t(e.errorComp)&&(e.error=!0,f(!0))}),v=e(d,m);return o(v)&&(u(v)?r(e.resolved)&&v.then(d,m):u(v.component)&&(v.component.then(d,m),t(v.error)&&(e.errorComp=Pr(v.error,a)),t(v.loading)&&(e.loadingComp=Pr(v.loading,a),0===v.delay?e.loading=!0:l=setTimeout(function(){l=null,r(e.resolved)&&r(e.error)&&(e.loading=!0,f(!1))},v.delay||200)),t(v.timeout)&&(p=setTimeout(function(){p=null,r(e.resolved)&&m(null)},v.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(f=a,p)))return function(e,r,t,n,a){var o=me();return o.asyncFactory=e,o.asyncMeta={data:r,context:t,children:n,tag:a},o}(f,i,s,c,l);i=i||{},At(a),t(i.model)&&function(e,r){var n=e.model&&e.model.prop||"value",a=e.model&&e.model.event||"input";(r.attrs||(r.attrs={}))[n]=r.model.value;var o=r.on||(r.on={}),i=o[a],s=r.model.callback;t(i)?(Array.isArray(i)?-1===i.indexOf(s):i!==s)&&(o[a]=[s].concat(i)):o[a]=s}(a.options,i);var d=function(e,n,a){var o=n.options.props;if(!r(o)){var i={},s=e.attrs,c=e.props;if(t(s)||t(c))for(var u in o){var l=x(u);ir(i,c,u,l,!0)||ir(i,s,u,l,!1)}return i}}(i,a);if(n(a.options.functional))return function(r,n,a,o,i){var s=r.options,c={},u=s.props;if(t(u))for(var l in u)c[l]=Re(l,u,n||e);else t(a.attrs)&&$r(c,a.attrs),t(a.props)&&$r(c,a.props);var p=new Lr(a,c,i,o,r),f=s.render.call(null,p._c,p);if(f instanceof fe)return Tr(f,a,p.parent,s);if(Array.isArray(f)){for(var d=sr(f)||[],m=new Array(d.length),h=0;h<d.length;h++)m[h]=Tr(d[h],a,p.parent,s);return m}}(a,d,i,s,c);var m=i.on;if(i.on=i.nativeOn,n(a.options.abstract)){var v=i.slot;i={},v&&(i.slot=v)}!function(e){for(var r=e.hook||(e.hook={}),t=0;t<Or.length;t++){var n=Or[t],a=r[n],o=Nr[n];a===o||a&&a._merged||(r[n]=a?Fr(o,a):o)}}(i);var g=a.options.name||l;return new fe("vue-component-"+a.cid+(g?"-"+g:""),i,void 0,void 0,void 0,s,{Ctor:a,propsData:d,listeners:m,tag:l,children:c},f)}}}function Fr(e,r){var t=function(t,n){e(t,n),r(t,n)};return t._merged=!0,t}var Br=1,Ur=2;function Vr(e,i,s,c,u,l){return(Array.isArray(s)||a(s))&&(u=c,c=s,s=void 0),n(l)&&(u=Ur),function(e,a,i,s,c){if(t(i)&&t(i.__ob__))return me();t(i)&&t(i.is)&&(a=i.is);if(!a)return me();Array.isArray(s)&&"function"==typeof s[0]&&((i=i||{}).scopedSlots={default:s[0]},s.length=0);c===Ur?s=sr(s):c===Br&&(s=function(e){for(var r=0;r<e.length;r++)if(Array.isArray(e[r]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof a){var p;l=e.$vnode&&e.$vnode.ns||B.getTagNamespace(a),u=B.isReservedTag(a)?new fe(B.parsePlatformTagName(a),i,s,void 0,void 0,e):i&&i.pre||!t(p=Oe(e.$options,"components",a))?new fe(a,i,s,void 0,void 0,e):Rr(p,i,e,s,a)}else u=Rr(a,i,e,s);return Array.isArray(u)?u:t(u)?(t(l)&&function e(a,o,i){a.ns=o;"foreignObject"===a.tag&&(o=void 0,i=!0);if(t(a.children))for(var s=0,c=a.children.length;s<c;s++){var u=a.children[s];t(u.tag)&&(r(u.ns)||n(i)&&"svg"!==u.tag)&&e(u,o,i)}}(u,l),t(i)&&function(e){o(e.style)&&rr(e.style);o(e.class)&&rr(e.class)}(i),u):me()}(e,i,s,c,u)}var Ir,jr=null;function Pr(e,r){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?r.extend(e):e}function Hr(e){return e.isComment&&e.asyncFactory}function Mr(e){if(Array.isArray(e))for(var r=0;r<e.length;r++){var n=e[r];if(t(n)&&(t(n.componentOptions)||Hr(n)))return n}}function Gr(e,r){Ir.$on(e,r)}function zr(e,r){Ir.$off(e,r)}function Jr(e,r){var t=Ir;return function n(){null!==r.apply(null,arguments)&&t.$off(e,n)}}function Kr(e,r,t){Ir=e,ar(r,t||{},Gr,zr,Jr,e),Ir=void 0}var Zr=null;function Yr(e){var r=Zr;return Zr=e,function(){Zr=r}}function Wr(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Qr(e,r){if(r){if(e._directInactive=!1,Wr(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var t=0;t<e.$children.length;t++)Qr(e.$children[t]);Xr(e,"activated")}}function Xr(e,r){le();var t=e.$options[r],n=r+" hook";if(t)for(var a=0,o=t.length;a<o;a++)je(t[a],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+r),pe()}var et=[],rt=[],tt={},nt=!1,at=!1,ot=0;var it=0,st=Date.now;if(H&&!J){var ct=window.performance;ct&&"function"==typeof ct.now&&st()>document.createEvent("Event").timeStamp&&(st=function(){return ct.now()})}function ut(){var e,r;for(it=st(),at=!0,et.sort(function(e,r){return e.id-r.id}),ot=0;ot<et.length;ot++)(e=et[ot]).before&&e.before(),r=e.id,tt[r]=null,e.run();var t=rt.slice(),n=et.slice();ot=et.length=rt.length=0,tt={},nt=at=!1,function(e){for(var r=0;r<e.length;r++)e[r]._inactive=!0,Qr(e[r],!0)}(t),function(e){var r=e.length;for(;r--;){var t=e[r],n=t.vm;n._watcher===t&&n._isMounted&&!n._isDestroyed&&Xr(n,"updated")}}(n),te&&B.devtools&&te.emit("flush")}var lt=0,pt=function(e,r,t,n,a){this.vm=e,a&&(e._watcher=this),e._watchers.push(this),n?(this.deep=!!n.deep,this.user=!!n.user,this.lazy=!!n.lazy,this.sync=!!n.sync,this.before=n.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=t,this.id=++lt,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ae,this.newDepIds=new ae,this.expression="","function"==typeof r?this.getter=r:(this.getter=function(e){if(!I.test(e)){var r=e.split(".");return function(e){for(var t=0;t<r.length;t++){if(!e)return;e=e[r[t]]}return e}}}(r),this.getter||(this.getter=C)),this.value=this.lazy?void 0:this.get()};pt.prototype.get=function(){var e;le(this);var r=this.vm;try{e=this.getter.call(r,r)}catch(e){if(!this.user)throw e;Ie(e,r,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rr(e),pe(),this.cleanupDeps()}return e},pt.prototype.addDep=function(e){var r=e.id;this.newDepIds.has(r)||(this.newDepIds.add(r),this.newDeps.push(e),this.depIds.has(r)||e.addSub(this))},pt.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var r=this.deps[e];this.newDepIds.has(r.id)||r.removeSub(this)}var t=this.depIds;this.depIds=this.newDepIds,this.newDepIds=t,this.newDepIds.clear(),t=this.deps,this.deps=this.newDeps,this.newDeps=t,this.newDeps.length=0},pt.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var r=e.id;if(null==tt[r]){if(tt[r]=!0,at){for(var t=et.length-1;t>ot&&et[t].id>e.id;)t--;et.splice(t+1,0,e)}else et.push(e);nt||(nt=!0,Xe(ut))}}(this)},pt.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var r=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,r)}catch(e){Ie(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,r)}}},pt.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},pt.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},pt.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var ft={enumerable:!0,configurable:!0,get:C,set:C};function dt(e,r,t){ft.get=function(){return this[r][t]},ft.set=function(e){this[r][t]=e},Object.defineProperty(e,t,ft)}function mt(e){e._watchers=[];var r=e.$options;r.props&&function(e,r){var t=e.$options.propsData||{},n=e._props={},a=e.$options._propKeys=[];e.$parent&&Ae(!1);var o=function(o){a.push(o);var i=Re(o,r,t,e);qe(n,o,i),o in e||dt(e,"_props",o)};for(var i in r)o(i);Ae(!0)}(e,r.props),r.methods&&function(e,r){e.$options.props;for(var t in r)e[t]="function"!=typeof r[t]?C:q(r[t],e)}(e,r.methods),r.data?function(e){var r=e.$options.data;s(r=e._data="function"==typeof r?function(e,r){le();try{return e.call(r,r)}catch(e){return Ie(e,r,"data()"),{}}finally{pe()}}(r,e):r||{})||(r={});var t=Object.keys(r),n=e.$options.props,a=(e.$options.methods,t.length);for(;a--;){var o=t[a];n&&g(n,o)||(i=void 0,36!==(i=(o+"").charCodeAt(0))&&95!==i&&dt(e,"_data",o))}var i;xe(r,!0)}(e):xe(e._data={},!0),r.computed&&function(e,r){var t=e._computedWatchers=Object.create(null),n=re();for(var a in r){var o=r[a],i="function"==typeof o?o:o.get;n||(t[a]=new pt(e,i||C,C,ht)),a in e||vt(e,a,o)}}(e,r.computed),r.watch&&r.watch!==Q&&function(e,r){for(var t in r){var n=r[t];if(Array.isArray(n))for(var a=0;a<n.length;a++)yt(e,t,n[a]);else yt(e,t,n)}}(e,r.watch)}var ht={lazy:!0};function vt(e,r,t){var n=!re();"function"==typeof t?(ft.get=n?gt(r):bt(t),ft.set=C):(ft.get=t.get?n&&!1!==t.cache?gt(r):bt(t.get):C,ft.set=t.set||C),Object.defineProperty(e,r,ft)}function gt(e){return function(){var r=this._computedWatchers&&this._computedWatchers[e];if(r)return r.dirty&&r.evaluate(),ce.target&&r.depend(),r.value}}function bt(e){return function(){return e.call(this,this)}}function yt(e,r,t,n){return s(t)&&(n=t,t=t.handler),"string"==typeof t&&(t=e[t]),e.$watch(r,t,n)}var wt=0;function At(e){var r=e.options;if(e.super){var t=At(e.super);if(t!==e.superOptions){e.superOptions=t;var n=function(e){var r,t=e.options,n=e.sealedOptions;for(var a in t)t[a]!==n[a]&&(r||(r={}),r[a]=t[a]);return r}(e);n&&E(e.extendOptions,n),(r=e.options=Ne(t,e.extendOptions)).name&&(r.components[r.name]=e)}}return r}function Dt(e){this._init(e)}function xt(e){e.cid=0;var r=1;e.extend=function(e){e=e||{};var t=this,n=t.cid,a=e._Ctor||(e._Ctor={});if(a[n])return a[n];var o=e.name||t.options.name,i=function(e){this._init(e)};return(i.prototype=Object.create(t.prototype)).constructor=i,i.cid=r++,i.options=Ne(t.options,e),i.super=t,i.options.props&&function(e){var r=e.options.props;for(var t in r)dt(e.prototype,"_props",t)}(i),i.options.computed&&function(e){var r=e.options.computed;for(var t in r)vt(e.prototype,t,r[t])}(i),i.extend=t.extend,i.mixin=t.mixin,i.use=t.use,R.forEach(function(e){i[e]=t[e]}),o&&(i.options.components[o]=i),i.superOptions=t.options,i.extendOptions=e,i.sealedOptions=E({},i.options),a[n]=i,i}}function qt(e){return e&&(e.Ctor.options.name||e.tag)}function kt(e,r){return Array.isArray(e)?e.indexOf(r)>-1:"string"==typeof e?e.split(",").indexOf(r)>-1:(t=e,"[object RegExp]"===i.call(t)&&e.test(r));var t}function Et(e,r){var t=e.cache,n=e.keys,a=e._vnode;for(var o in t){var i=t[o];if(i){var s=qt(i.componentOptions);s&&!r(s)&&_t(t,o,n,a)}}}function _t(e,r,t,n){var a=e[r];!a||n&&a.tag===n.tag||a.componentInstance.$destroy(),e[r]=null,h(t,r)}!function(r){r.prototype._init=function(r){var t=this;t._uid=wt++,t._isVue=!0,r&&r._isComponent?function(e,r){var t=e.$options=Object.create(e.constructor.options),n=r._parentVnode;t.parent=r.parent,t._parentVnode=n;var a=n.componentOptions;t.propsData=a.propsData,t._parentListeners=a.listeners,t._renderChildren=a.children,t._componentTag=a.tag,r.render&&(t.render=r.render,t.staticRenderFns=r.staticRenderFns)}(t,r):t.$options=Ne(At(t.constructor),r||{},t),t._renderProxy=t,t._self=t,function(e){var r=e.$options,t=r.parent;if(t&&!r.abstract){for(;t.$options.abstract&&t.$parent;)t=t.$parent;t.$children.push(e)}e.$parent=t,e.$root=t?t.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(t),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var r=e.$options._parentListeners;r&&Kr(e,r)}(t),function(r){r._vnode=null,r._staticTrees=null;var t=r.$options,n=r.$vnode=t._parentVnode,a=n&&n.context;r.$slots=lr(t._renderChildren,a),r.$scopedSlots=e,r._c=function(e,t,n,a){return Vr(r,e,t,n,a,!1)},r.$createElement=function(e,t,n,a){return Vr(r,e,t,n,a,!0)};var o=n&&n.data;qe(r,"$attrs",o&&o.attrs||e,null,!0),qe(r,"$listeners",t._parentListeners||e,null,!0)}(t),Xr(t,"beforeCreate"),function(e){var r=ur(e.$options.inject,e);r&&(Ae(!1),Object.keys(r).forEach(function(t){qe(e,t,r[t])}),Ae(!0))}(t),mt(t),function(e){var r=e.$options.provide;r&&(e._provided="function"==typeof r?r.call(e):r)}(t),Xr(t,"created"),t.$options.el&&t.$mount(t.$options.el)}}(Dt),function(e){var r={get:function(){return this._data}},t={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",r),Object.defineProperty(e.prototype,"$props",t),e.prototype.$set=ke,e.prototype.$delete=Ee,e.prototype.$watch=function(e,r,t){if(s(r))return yt(this,e,r,t);(t=t||{}).user=!0;var n=new pt(this,e,r,t);if(t.immediate){le();try{r.call(this,n.value)}catch(e){Ie(e,this,'callback for immediate watcher "'+n.expression+'"')}pe()}return function(){n.teardown()}}}(Dt),function(e){var r=/^hook:/;e.prototype.$on=function(e,t){var n=this;if(Array.isArray(e))for(var a=0,o=e.length;a<o;a++)n.$on(e[a],t);else(n._events[e]||(n._events[e]=[])).push(t),r.test(e)&&(n._hasHookEvent=!0);return n},e.prototype.$once=function(e,r){var t=this;function n(){t.$off(e,n),r.apply(t,arguments)}return n.fn=r,t.$on(e,n),t},e.prototype.$off=function(e,r){var t=this;if(!arguments.length)return t._events=Object.create(null),t;if(Array.isArray(e)){for(var n=0,a=e.length;n<a;n++)t.$off(e[n],r);return t}var o,i=t._events[e];if(!i)return t;if(!r)return t._events[e]=null,t;for(var s=i.length;s--;)if((o=i[s])===r||o.fn===r){i.splice(s,1);break}return t},e.prototype.$emit=function(e){var r=this._events[e];if(r){r=r.length>1?k(r):r;for(var t=k(arguments,1),n='event handler for "'+e+'"',a=0,o=r.length;a<o;a++)je(r[a],this,t,this,n)}return this}}(Dt),function(e){e.prototype._update=function(e,r){var t=this,n=t.$el,a=t._vnode,o=Yr(t);t._vnode=e,t.$el=a?t.__patch__(a,e):t.__patch__(t.$el,e,r,!1),o(),n&&(n.__vue__=null),t.$el&&(t.$el.__vue__=t),t.$vnode&&t.$parent&&t.$vnode===t.$parent._vnode&&(t.$parent.$el=t.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Xr(e,"beforeDestroy"),e._isBeingDestroyed=!0;var r=e.$parent;!r||r._isBeingDestroyed||e.$options.abstract||h(r.$children,e),e._watcher&&e._watcher.teardown();for(var t=e._watchers.length;t--;)e._watchers[t].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Xr(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(Dt),function(e){Sr(e.prototype),e.prototype.$nextTick=function(e){return Xe(e,this)},e.prototype._render=function(){var e,r=this,t=r.$options,n=t.render,a=t._parentVnode;a&&(r.$scopedSlots=fr(a.data.scopedSlots,r.$slots,r.$scopedSlots)),r.$vnode=a;try{jr=r,e=n.call(r._renderProxy,r.$createElement)}catch(t){Ie(t,r,"render"),e=r._vnode}finally{jr=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof fe||(e=me()),e.parent=a,e}}(Dt);var Ct=[String,RegExp,Array],St={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Ct,exclude:Ct,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)_t(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(r){Et(e,function(e){return kt(r,e)})}),this.$watch("exclude",function(r){Et(e,function(e){return!kt(r,e)})})},render:function(){var e=this.$slots.default,r=Mr(e),t=r&&r.componentOptions;if(t){var n=qt(t),a=this.include,o=this.exclude;if(a&&(!n||!kt(a,n))||o&&n&&kt(o,n))return r;var i=this.cache,s=this.keys,c=null==r.key?t.Ctor.cid+(t.tag?"::"+t.tag:""):r.key;i[c]?(r.componentInstance=i[c].componentInstance,h(s,c),s.push(c)):(i[c]=r,s.push(c),this.max&&s.length>parseInt(this.max)&&_t(i,s[0],s,this._vnode)),r.data.keepAlive=!0}return r||e&&e[0]}}};!function(e){var r={get:function(){return B}};Object.defineProperty(e,"config",r),e.util={warn:ie,extend:E,mergeOptions:Ne,defineReactive:qe},e.set=ke,e.delete=Ee,e.nextTick=Xe,e.observable=function(e){return xe(e),e},e.options=Object.create(null),R.forEach(function(r){e.options[r+"s"]=Object.create(null)}),e.options._base=e,E(e.options.components,St),function(e){e.use=function(e){var r=this._installedPlugins||(this._installedPlugins=[]);if(r.indexOf(e)>-1)return this;var t=k(arguments,1);return t.unshift(this),"function"==typeof e.install?e.install.apply(e,t):"function"==typeof e&&e.apply(null,t),r.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Ne(this.options,e),this}}(e),xt(e),function(e){R.forEach(function(r){e[r]=function(e,t){return t?("component"===r&&s(t)&&(t.name=t.name||e,t=this.options._base.extend(t)),"directive"===r&&"function"==typeof t&&(t={bind:t,update:t}),this.options[r+"s"][e]=t,t):this.options[r+"s"][e]}})}(e)}(Dt),Object.defineProperty(Dt.prototype,"$isServer",{get:re}),Object.defineProperty(Dt.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Dt,"FunctionalRenderContext",{value:Lr}),Dt.version="2.6.12";var Lt=f("style,class"),Tt=f("input,textarea,option,select,progress"),$t=function(e,r,t){return"value"===t&&Tt(e)&&"button"!==r||"selected"===t&&"option"===e||"checked"===t&&"input"===e||"muted"===t&&"video"===e},Nt=f("contenteditable,draggable,spellcheck"),Ot=f("events,caret,typing,plaintext-only"),Rt=function(e,r){return It(r)||"false"===r?"false":"contenteditable"===e&&Ot(r)?r:"true"},Ft=f("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Bt="http://www.w3.org/1999/xlink",Ut=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Vt=function(e){return Ut(e)?e.slice(6,e.length):""},It=function(e){return null==e||!1===e};function jt(e){for(var r=e.data,n=e,a=e;t(a.componentInstance);)(a=a.componentInstance._vnode)&&a.data&&(r=Pt(a.data,r));for(;t(n=n.parent);)n&&n.data&&(r=Pt(r,n.data));return function(e,r){if(t(e)||t(r))return Ht(e,Mt(r));return""}(r.staticClass,r.class)}function Pt(e,r){return{staticClass:Ht(e.staticClass,r.staticClass),class:t(e.class)?[e.class,r.class]:r.class}}function Ht(e,r){return e?r?e+" "+r:e:r||""}function Mt(e){return Array.isArray(e)?function(e){for(var r,n="",a=0,o=e.length;a<o;a++)t(r=Mt(e[a]))&&""!==r&&(n&&(n+=" "),n+=r);return n}(e):o(e)?function(e){var r="";for(var t in e)e[t]&&(r&&(r+=" "),r+=t);return r}(e):"string"==typeof e?e:""}var Gt={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zt=f("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Jt=f("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Kt=function(e){return zt(e)||Jt(e)};function Zt(e){return Jt(e)?"svg":"math"===e?"math":void 0}var Yt=Object.create(null);var Wt=f("text,number,password,search,email,tel,url");function Qt(e){if("string"==typeof e){var r=document.querySelector(e);return r||document.createElement("div")}return e}var Xt=Object.freeze({createElement:function(e,r){var t=document.createElement(e);return"select"!==e?t:(r.data&&r.data.attrs&&void 0!==r.data.attrs.multiple&&t.setAttribute("multiple","multiple"),t)},createElementNS:function(e,r){return document.createElementNS(Gt[e],r)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,r,t){e.insertBefore(r,t)},removeChild:function(e,r){e.removeChild(r)},appendChild:function(e,r){e.appendChild(r)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,r){e.textContent=r},setStyleScope:function(e,r){e.setAttribute(r,"")}}),en={create:function(e,r){rn(r)},update:function(e,r){e.data.ref!==r.data.ref&&(rn(e,!0),rn(r))},destroy:function(e){rn(e,!0)}};function rn(e,r){var n=e.data.ref;if(t(n)){var a=e.context,o=e.componentInstance||e.elm,i=a.$refs;r?Array.isArray(i[n])?h(i[n],o):i[n]===o&&(i[n]=void 0):e.data.refInFor?Array.isArray(i[n])?i[n].indexOf(o)<0&&i[n].push(o):i[n]=[o]:i[n]=o}}var tn=new fe("",{},[]),nn=["create","activate","update","remove","destroy"];function an(e,a){return e.key===a.key&&(e.tag===a.tag&&e.isComment===a.isComment&&t(e.data)===t(a.data)&&function(e,r){if("input"!==e.tag)return!0;var n,a=t(n=e.data)&&t(n=n.attrs)&&n.type,o=t(n=r.data)&&t(n=n.attrs)&&n.type;return a===o||Wt(a)&&Wt(o)}(e,a)||n(e.isAsyncPlaceholder)&&e.asyncFactory===a.asyncFactory&&r(a.asyncFactory.error))}function on(e,r,n){var a,o,i={};for(a=r;a<=n;++a)t(o=e[a].key)&&(i[o]=a);return i}var sn={create:cn,update:cn,destroy:function(e){cn(e,tn)}};function cn(e,r){(e.data.directives||r.data.directives)&&function(e,r){var t,n,a,o=e===tn,i=r===tn,s=ln(e.data.directives,e.context),c=ln(r.data.directives,r.context),u=[],l=[];for(t in c)n=s[t],a=c[t],n?(a.oldValue=n.value,a.oldArg=n.arg,fn(a,"update",r,e),a.def&&a.def.componentUpdated&&l.push(a)):(fn(a,"bind",r,e),a.def&&a.def.inserted&&u.push(a));if(u.length){var p=function(){for(var t=0;t<u.length;t++)fn(u[t],"inserted",r,e)};o?or(r,"insert",p):p()}l.length&&or(r,"postpatch",function(){for(var t=0;t<l.length;t++)fn(l[t],"componentUpdated",r,e)});if(!o)for(t in s)c[t]||fn(s[t],"unbind",e,e,i)}(e,r)}var un=Object.create(null);function ln(e,r){var t,n,a=Object.create(null);if(!e)return a;for(t=0;t<e.length;t++)(n=e[t]).modifiers||(n.modifiers=un),a[pn(n)]=n,n.def=Oe(r.$options,"directives",n.name);return a}function pn(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fn(e,r,t,n,a){var o=e.def&&e.def[r];if(o)try{o(t.elm,e,t,n,a)}catch(n){Ie(n,t.context,"directive "+e.name+" "+r+" hook")}}var dn=[en,sn];function mn(e,n){var a=n.componentOptions;if(!(t(a)&&!1===a.Ctor.options.inheritAttrs||r(e.data.attrs)&&r(n.data.attrs))){var o,i,s=n.elm,c=e.data.attrs||{},u=n.data.attrs||{};for(o in t(u.__ob__)&&(u=n.data.attrs=E({},u)),u)i=u[o],c[o]!==i&&hn(s,o,i,n.data.pre);for(o in(J||Z)&&u.value!==c.value&&hn(s,"value",u.value),c)r(u[o])&&(Ut(o)?s.removeAttributeNS(Bt,Vt(o)):Nt(o)||s.removeAttribute(o))}}function hn(e,r,t,n){n||e.tagName.indexOf("-")>-1?vn(e,r,t):Ft(r)?It(t)?e.removeAttribute(r):(t="allowfullscreen"===r&&"EMBED"===e.tagName?"true":r,e.setAttribute(r,t)):Nt(r)?e.setAttribute(r,Rt(r,t)):Ut(r)?It(t)?e.removeAttributeNS(Bt,Vt(r)):e.setAttributeNS(Bt,r,t):vn(e,r,t)}function vn(e,r,t){if(It(t))e.removeAttribute(r);else{if(J&&!K&&"TEXTAREA"===e.tagName&&"placeholder"===r&&""!==t&&!e.__ieph){var n=function(r){r.stopImmediatePropagation(),e.removeEventListener("input",n)};e.addEventListener("input",n),e.__ieph=!0}e.setAttribute(r,t)}}var gn={create:mn,update:mn};function bn(e,n){var a=n.elm,o=n.data,i=e.data;if(!(r(o.staticClass)&&r(o.class)&&(r(i)||r(i.staticClass)&&r(i.class)))){var s=jt(n),c=a._transitionClasses;t(c)&&(s=Ht(s,Mt(c))),s!==a._prevClass&&(a.setAttribute("class",s),a._prevClass=s)}}var yn,wn,An,Dn,xn,qn,kn={create:bn,update:bn},En=/[\w).+\-_$\]]/;function _n(e){var r,t,n,a,o,i=!1,s=!1,c=!1,u=!1,l=0,p=0,f=0,d=0;for(n=0;n<e.length;n++)if(t=r,r=e.charCodeAt(n),i)39===r&&92!==t&&(i=!1);else if(s)34===r&&92!==t&&(s=!1);else if(c)96===r&&92!==t&&(c=!1);else if(u)47===r&&92!==t&&(u=!1);else if(124!==r||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||p||f){switch(r){case 34:s=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:f++;break;case 41:f--;break;case 91:p++;break;case 93:p--;break;case 123:l++;break;case 125:l--}if(47===r){for(var m=n-1,h=void 0;m>=0&&" "===(h=e.charAt(m));m--);h&&En.test(h)||(u=!0)}}else void 0===a?(d=n+1,a=e.slice(0,n).trim()):v();function v(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===a?a=e.slice(0,n).trim():0!==d&&v(),o)for(n=0;n<o.length;n++)a=Cn(a,o[n]);return a}function Cn(e,r){var t=r.indexOf("(");if(t<0)return'_f("'+r+'")('+e+")";var n=r.slice(0,t),a=r.slice(t+1);return'_f("'+n+'")('+e+(")"!==a?","+a:a)}function Sn(e,r){console.error("[Vue compiler]: "+e)}function Ln(e,r){return e?e.map(function(e){return e[r]}).filter(function(e){return e}):[]}function Tn(e,r,t,n,a){(e.props||(e.props=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function $n(e,r,t,n,a){(a?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function Nn(e,r,t,n){e.attrsMap[r]=t,e.attrsList.push(In({name:r,value:t},n))}function On(e,r,t,n,a,o,i,s){(e.directives||(e.directives=[])).push(In({name:r,rawName:t,value:n,arg:a,isDynamicArg:o,modifiers:i},s)),e.plain=!1}function Rn(e,r,t){return t?"_p("+r+',"'+e+'")':e+r}function Fn(r,t,n,a,o,i,s,c){var u;(a=a||e).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete a.right):a.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),a.capture&&(delete a.capture,t=Rn("!",t,c)),a.once&&(delete a.once,t=Rn("~",t,c)),a.passive&&(delete a.passive,t=Rn("&",t,c)),a.native?(delete a.native,u=r.nativeEvents||(r.nativeEvents={})):u=r.events||(r.events={});var l=In({value:n.trim(),dynamic:c},s);a!==e&&(l.modifiers=a);var p=u[t];Array.isArray(p)?o?p.unshift(l):p.push(l):u[t]=p?o?[l,p]:[p,l]:l,r.plain=!1}function Bn(e,r,t){var n=Un(e,":"+r)||Un(e,"v-bind:"+r);if(null!=n)return _n(n);if(!1!==t){var a=Un(e,r);if(null!=a)return JSON.stringify(a)}}function Un(e,r,t){var n;if(null!=(n=e.attrsMap[r]))for(var a=e.attrsList,o=0,i=a.length;o<i;o++)if(a[o].name===r){a.splice(o,1);break}return t&&delete e.attrsMap[r],n}function Vn(e,r){for(var t=e.attrsList,n=0,a=t.length;n<a;n++){var o=t[n];if(r.test(o.name))return t.splice(n,1),o}}function In(e,r){return r&&(null!=r.start&&(e.start=r.start),null!=r.end&&(e.end=r.end)),e}function jn(e,r,t){var n=t||{},a=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),a&&(o="_n("+o+")");var i=Pn(r,o);e.model={value:"("+r+")",expression:JSON.stringify(r),callback:"function ($$v) {"+i+"}"}}function Pn(e,r){var t=function(e){if(e=e.trim(),yn=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<yn-1)return(Dn=e.lastIndexOf("."))>-1?{exp:e.slice(0,Dn),key:'"'+e.slice(Dn+1)+'"'}:{exp:e,key:null};wn=e,Dn=xn=qn=0;for(;!Mn();)Gn(An=Hn())?Jn(An):91===An&&zn(An);return{exp:e.slice(0,xn),key:e.slice(xn+1,qn)}}(e);return null===t.key?e+"="+r:"$set("+t.exp+", "+t.key+", "+r+")"}function Hn(){return wn.charCodeAt(++Dn)}function Mn(){return Dn>=yn}function Gn(e){return 34===e||39===e}function zn(e){var r=1;for(xn=Dn;!Mn();)if(Gn(e=Hn()))Jn(e);else if(91===e&&r++,93===e&&r--,0===r){qn=Dn;break}}function Jn(e){for(var r=e;!Mn()&&(e=Hn())!==r;);}var Kn,Zn="__r",Yn="__c";function Wn(e,r,t){var n=Kn;return function a(){null!==r.apply(null,arguments)&&ea(e,a,t,n)}}var Qn=Ge&&!(W&&Number(W[1])<=53);function Xn(e,r,t,n){if(Qn){var a=it,o=r;r=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=a||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Kn.addEventListener(e,r,X?{capture:t,passive:n}:t)}function ea(e,r,t,n){(n||Kn).removeEventListener(e,r._wrapper||r,t)}function ra(e,n){if(!r(e.data.on)||!r(n.data.on)){var a=n.data.on||{},o=e.data.on||{};Kn=n.elm,function(e){if(t(e[Zn])){var r=J?"change":"input";e[r]=[].concat(e[Zn],e[r]||[]),delete e[Zn]}t(e[Yn])&&(e.change=[].concat(e[Yn],e.change||[]),delete e[Yn])}(a),ar(a,o,Xn,ea,Wn,n.context),Kn=void 0}}var ta,na={create:ra,update:ra};function aa(e,n){if(!r(e.data.domProps)||!r(n.data.domProps)){var a,o,i=n.elm,s=e.data.domProps||{},c=n.data.domProps||{};for(a in t(c.__ob__)&&(c=n.data.domProps=E({},c)),s)a in c||(i[a]="");for(a in c){if(o=c[a],"textContent"===a||"innerHTML"===a){if(n.children&&(n.children.length=0),o===s[a])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===a&&"PROGRESS"!==i.tagName){i._value=o;var u=r(o)?"":String(o);oa(i,u)&&(i.value=u)}else if("innerHTML"===a&&Jt(i.tagName)&&r(i.innerHTML)){(ta=ta||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ta.firstChild;i.firstChild;)i.removeChild(i.firstChild);for(;l.firstChild;)i.appendChild(l.firstChild)}else if(o!==s[a])try{i[a]=o}catch(e){}}}}function oa(e,r){return!e.composing&&("OPTION"===e.tagName||function(e,r){var t=!0;try{t=document.activeElement!==e}catch(e){}return t&&e.value!==r}(e,r)||function(e,r){var n=e.value,a=e._vModifiers;if(t(a)){if(a.number)return p(n)!==p(r);if(a.trim)return n.trim()!==r.trim()}return n!==r}(e,r))}var ia={create:aa,update:aa},sa=b(function(e){var r={},t=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(t);n.length>1&&(r[n[0].trim()]=n[1].trim())}}),r});function ca(e){var r=ua(e.style);return e.staticStyle?E(e.staticStyle,r):r}function ua(e){return Array.isArray(e)?_(e):"string"==typeof e?sa(e):e}var la,pa=/^--/,fa=/\s*!important$/,da=function(e,r,t){if(pa.test(r))e.style.setProperty(r,t);else if(fa.test(t))e.style.setProperty(x(r),t.replace(fa,""),"important");else{var n=ha(r);if(Array.isArray(t))for(var a=0,o=t.length;a<o;a++)e.style[n]=t[a];else e.style[n]=t}},ma=["Webkit","Moz","ms"],ha=b(function(e){if(la=la||document.createElement("div").style,"filter"!==(e=w(e))&&e in la)return e;for(var r=e.charAt(0).toUpperCase()+e.slice(1),t=0;t<ma.length;t++){var n=ma[t]+r;if(n in la)return n}});function va(e,n){var a=n.data,o=e.data;if(!(r(a.staticStyle)&&r(a.style)&&r(o.staticStyle)&&r(o.style))){var i,s,c=n.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},p=u||l,f=ua(n.data.style)||{};n.data.normalizedStyle=t(f.__ob__)?E({},f):f;var d=function(e,r){var t,n={};if(r)for(var a=e;a.componentInstance;)(a=a.componentInstance._vnode)&&a.data&&(t=ca(a.data))&&E(n,t);(t=ca(e.data))&&E(n,t);for(var o=e;o=o.parent;)o.data&&(t=ca(o.data))&&E(n,t);return n}(n,!0);for(s in p)r(d[s])&&da(c,s,"");for(s in d)(i=d[s])!==p[s]&&da(c,s,null==i?"":i)}}var ga={create:va,update:va},ba=/\s+/;function ya(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.add(r)}):e.classList.add(r);else{var t=" "+(e.getAttribute("class")||"")+" ";t.indexOf(" "+r+" ")<0&&e.setAttribute("class",(t+r).trim())}}function wa(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.remove(r)}):e.classList.remove(r),e.classList.length||e.removeAttribute("class");else{for(var t=" "+(e.getAttribute("class")||"")+" ",n=" "+r+" ";t.indexOf(n)>=0;)t=t.replace(n," ");(t=t.trim())?e.setAttribute("class",t):e.removeAttribute("class")}}function Aa(e){if(e){if("object"==typeof e){var r={};return!1!==e.css&&E(r,Da(e.name||"v")),E(r,e),r}return"string"==typeof e?Da(e):void 0}}var Da=b(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),xa=H&&!K,qa="transition",ka="animation",Ea="transition",_a="transitionend",Ca="animation",Sa="animationend";xa&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ea="WebkitTransition",_a="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ca="WebkitAnimation",Sa="webkitAnimationEnd"));var La=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ta(e){La(function(){La(e)})}function $a(e,r){var t=e._transitionClasses||(e._transitionClasses=[]);t.indexOf(r)<0&&(t.push(r),ya(e,r))}function Na(e,r){e._transitionClasses&&h(e._transitionClasses,r),wa(e,r)}function Oa(e,r,t){var n=Fa(e,r),a=n.type,o=n.timeout,i=n.propCount;if(!a)return t();var s=a===qa?_a:Sa,c=0,u=function(){e.removeEventListener(s,l),t()},l=function(r){r.target===e&&++c>=i&&u()};setTimeout(function(){c<i&&u()},o+1),e.addEventListener(s,l)}var Ra=/\b(transform|all)(,|$)/;function Fa(e,r){var t,n=window.getComputedStyle(e),a=(n[Ea+"Delay"]||"").split(", "),o=(n[Ea+"Duration"]||"").split(", "),i=Ba(a,o),s=(n[Ca+"Delay"]||"").split(", "),c=(n[Ca+"Duration"]||"").split(", "),u=Ba(s,c),l=0,p=0;return r===qa?i>0&&(t=qa,l=i,p=o.length):r===ka?u>0&&(t=ka,l=u,p=c.length):p=(t=(l=Math.max(i,u))>0?i>u?qa:ka:null)?t===qa?o.length:c.length:0,{type:t,timeout:l,propCount:p,hasTransform:t===qa&&Ra.test(n[Ea+"Property"])}}function Ba(e,r){for(;e.length<r.length;)e=e.concat(e);return Math.max.apply(null,r.map(function(r,t){return Ua(r)+Ua(e[t])}))}function Ua(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Va(e,n){var a=e.elm;t(a._leaveCb)&&(a._leaveCb.cancelled=!0,a._leaveCb());var i=Aa(e.data.transition);if(!r(i)&&!t(a._enterCb)&&1===a.nodeType){for(var s=i.css,c=i.type,u=i.enterClass,l=i.enterToClass,f=i.enterActiveClass,d=i.appearClass,m=i.appearToClass,h=i.appearActiveClass,v=i.beforeEnter,g=i.enter,b=i.afterEnter,y=i.enterCancelled,w=i.beforeAppear,A=i.appear,D=i.afterAppear,x=i.appearCancelled,q=i.duration,k=Zr,E=Zr.$vnode;E&&E.parent;)k=E.context,E=E.parent;var _=!k._isMounted||!e.isRootInsert;if(!_||A||""===A){var C=_&&d?d:u,S=_&&h?h:f,L=_&&m?m:l,T=_&&w||v,$=_&&"function"==typeof A?A:g,O=_&&D||b,R=_&&x||y,F=p(o(q)?q.enter:q),B=!1!==s&&!K,U=Pa($),V=a._enterCb=N(function(){B&&(Na(a,L),Na(a,S)),V.cancelled?(B&&Na(a,C),R&&R(a)):O&&O(a),a._enterCb=null});e.data.show||or(e,"insert",function(){var r=a.parentNode,t=r&&r._pending&&r._pending[e.key];t&&t.tag===e.tag&&t.elm._leaveCb&&t.elm._leaveCb(),$&&$(a,V)}),T&&T(a),B&&($a(a,C),$a(a,S),Ta(function(){Na(a,C),V.cancelled||($a(a,L),U||(ja(F)?setTimeout(V,F):Oa(a,c,V)))})),e.data.show&&(n&&n(),$&&$(a,V)),B||U||V()}}}function Ia(e,n){var a=e.elm;t(a._enterCb)&&(a._enterCb.cancelled=!0,a._enterCb());var i=Aa(e.data.transition);if(r(i)||1!==a.nodeType)return n();if(!t(a._leaveCb)){var s=i.css,c=i.type,u=i.leaveClass,l=i.leaveToClass,f=i.leaveActiveClass,d=i.beforeLeave,m=i.leave,h=i.afterLeave,v=i.leaveCancelled,g=i.delayLeave,b=i.duration,y=!1!==s&&!K,w=Pa(m),A=p(o(b)?b.leave:b),D=a._leaveCb=N(function(){a.parentNode&&a.parentNode._pending&&(a.parentNode._pending[e.key]=null),y&&(Na(a,l),Na(a,f)),D.cancelled?(y&&Na(a,u),v&&v(a)):(n(),h&&h(a)),a._leaveCb=null});g?g(x):x()}function x(){D.cancelled||(!e.data.show&&a.parentNode&&((a.parentNode._pending||(a.parentNode._pending={}))[e.key]=e),d&&d(a),y&&($a(a,u),$a(a,f),Ta(function(){Na(a,u),D.cancelled||($a(a,l),w||(ja(A)?setTimeout(D,A):Oa(a,c,D)))})),m&&m(a,D),y||w||D())}}function ja(e){return"number"==typeof e&&!isNaN(e)}function Pa(e){if(r(e))return!1;var n=e.fns;return t(n)?Pa(Array.isArray(n)?n[0]:n):(e._length||e.length)>1}function Ha(e,r){!0!==r.data.show&&Va(r)}var Ma=function(e){var o,i,s={},c=e.modules,u=e.nodeOps;for(o=0;o<nn.length;++o)for(s[nn[o]]=[],i=0;i<c.length;++i)t(c[i][nn[o]])&&s[nn[o]].push(c[i][nn[o]]);function l(e){var r=u.parentNode(e);t(r)&&u.removeChild(r,e)}function p(e,r,a,o,i,c,l){if(t(e.elm)&&t(c)&&(e=c[l]=ve(e)),e.isRootInsert=!i,!function(e,r,a,o){var i=e.data;if(t(i)){var c=t(e.componentInstance)&&i.keepAlive;if(t(i=i.hook)&&t(i=i.init)&&i(e,!1),t(e.componentInstance))return d(e,r),m(a,e.elm,o),n(c)&&function(e,r,n,a){for(var o,i=e;i.componentInstance;)if(i=i.componentInstance._vnode,t(o=i.data)&&t(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](tn,i);r.push(i);break}m(n,e.elm,a)}(e,r,a,o),!0}}(e,r,a,o)){var p=e.data,f=e.children,v=e.tag;t(v)?(e.elm=e.ns?u.createElementNS(e.ns,v):u.createElement(v,e),b(e),h(e,f,r),t(p)&&g(e,r),m(a,e.elm,o)):n(e.isComment)?(e.elm=u.createComment(e.text),m(a,e.elm,o)):(e.elm=u.createTextNode(e.text),m(a,e.elm,o))}}function d(e,r){t(e.data.pendingInsert)&&(r.push.apply(r,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,v(e)?(g(e,r),b(e)):(rn(e),r.push(e))}function m(e,r,n){t(e)&&(t(n)?u.parentNode(n)===e&&u.insertBefore(e,r,n):u.appendChild(e,r))}function h(e,r,t){if(Array.isArray(r))for(var n=0;n<r.length;++n)p(r[n],t,e.elm,null,!0,r,n);else a(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function v(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return t(e.tag)}function g(e,r){for(var n=0;n<s.create.length;++n)s.create[n](tn,e);t(o=e.data.hook)&&(t(o.create)&&o.create(tn,e),t(o.insert)&&r.push(e))}function b(e){var r;if(t(r=e.fnScopeId))u.setStyleScope(e.elm,r);else for(var n=e;n;)t(r=n.context)&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r),n=n.parent;t(r=Zr)&&r!==e.context&&r!==e.fnContext&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r)}function y(e,r,t,n,a,o){for(;n<=a;++n)p(t[n],o,e,r,!1,t,n)}function w(e){var r,n,a=e.data;if(t(a))for(t(r=a.hook)&&t(r=r.destroy)&&r(e),r=0;r<s.destroy.length;++r)s.destroy[r](e);if(t(r=e.children))for(n=0;n<e.children.length;++n)w(e.children[n])}function A(e,r,n){for(;r<=n;++r){var a=e[r];t(a)&&(t(a.tag)?(D(a),w(a)):l(a.elm))}}function D(e,r){if(t(r)||t(e.data)){var n,a=s.remove.length+1;for(t(r)?r.listeners+=a:r=function(e,r){function t(){0==--t.listeners&&l(e)}return t.listeners=r,t}(e.elm,a),t(n=e.componentInstance)&&t(n=n._vnode)&&t(n.data)&&D(n,r),n=0;n<s.remove.length;++n)s.remove[n](e,r);t(n=e.data.hook)&&t(n=n.remove)?n(e,r):r()}else l(e.elm)}function x(e,r,n,a){for(var o=n;o<a;o++){var i=r[o];if(t(i)&&an(e,i))return o}}function q(e,a,o,i,c,l){if(e!==a){t(a.elm)&&t(i)&&(a=i[c]=ve(a));var f=a.elm=e.elm;if(n(e.isAsyncPlaceholder))t(a.asyncFactory.resolved)?_(e.elm,a,o):a.isAsyncPlaceholder=!0;else if(n(a.isStatic)&&n(e.isStatic)&&a.key===e.key&&(n(a.isCloned)||n(a.isOnce)))a.componentInstance=e.componentInstance;else{var d,m=a.data;t(m)&&t(d=m.hook)&&t(d=d.prepatch)&&d(e,a);var h=e.children,g=a.children;if(t(m)&&v(a)){for(d=0;d<s.update.length;++d)s.update[d](e,a);t(d=m.hook)&&t(d=d.update)&&d(e,a)}r(a.text)?t(h)&&t(g)?h!==g&&function(e,n,a,o,i){for(var s,c,l,f=0,d=0,m=n.length-1,h=n[0],v=n[m],g=a.length-1,b=a[0],w=a[g],D=!i;f<=m&&d<=g;)r(h)?h=n[++f]:r(v)?v=n[--m]:an(h,b)?(q(h,b,o,a,d),h=n[++f],b=a[++d]):an(v,w)?(q(v,w,o,a,g),v=n[--m],w=a[--g]):an(h,w)?(q(h,w,o,a,g),D&&u.insertBefore(e,h.elm,u.nextSibling(v.elm)),h=n[++f],w=a[--g]):an(v,b)?(q(v,b,o,a,d),D&&u.insertBefore(e,v.elm,h.elm),v=n[--m],b=a[++d]):(r(s)&&(s=on(n,f,m)),r(c=t(b.key)?s[b.key]:x(b,n,f,m))?p(b,o,e,h.elm,!1,a,d):an(l=n[c],b)?(q(l,b,o,a,d),n[c]=void 0,D&&u.insertBefore(e,l.elm,h.elm)):p(b,o,e,h.elm,!1,a,d),b=a[++d]);f>m?y(e,r(a[g+1])?null:a[g+1].elm,a,d,g,o):d>g&&A(n,f,m)}(f,h,g,o,l):t(g)?(t(e.text)&&u.setTextContent(f,""),y(f,null,g,0,g.length-1,o)):t(h)?A(h,0,h.length-1):t(e.text)&&u.setTextContent(f,""):e.text!==a.text&&u.setTextContent(f,a.text),t(m)&&t(d=m.hook)&&t(d=d.postpatch)&&d(e,a)}}}function k(e,r,a){if(n(a)&&t(e.parent))e.parent.data.pendingInsert=r;else for(var o=0;o<r.length;++o)r[o].data.hook.insert(r[o])}var E=f("attrs,class,staticClass,staticStyle,key");function _(e,r,a,o){var i,s=r.tag,c=r.data,u=r.children;if(o=o||c&&c.pre,r.elm=e,n(r.isComment)&&t(r.asyncFactory))return r.isAsyncPlaceholder=!0,!0;if(t(c)&&(t(i=c.hook)&&t(i=i.init)&&i(r,!0),t(i=r.componentInstance)))return d(r,a),!0;if(t(s)){if(t(u))if(e.hasChildNodes())if(t(i=c)&&t(i=i.domProps)&&t(i=i.innerHTML)){if(i!==e.innerHTML)return!1}else{for(var l=!0,p=e.firstChild,f=0;f<u.length;f++){if(!p||!_(p,u[f],a,o)){l=!1;break}p=p.nextSibling}if(!l||p)return!1}else h(r,u,a);if(t(c)){var m=!1;for(var v in c)if(!E(v)){m=!0,g(r,a);break}!m&&c.class&&rr(c.class)}}else e.data!==r.text&&(e.data=r.text);return!0}return function(e,a,o,i){if(!r(a)){var c,l=!1,f=[];if(r(e))l=!0,p(a,f);else{var d=t(e.nodeType);if(!d&&an(e,a))q(e,a,f,null,null,i);else{if(d){if(1===e.nodeType&&e.hasAttribute(O)&&(e.removeAttribute(O),o=!0),n(o)&&_(e,a,f))return k(a,f,!0),e;c=e,e=new fe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var m=e.elm,h=u.parentNode(m);if(p(a,f,m._leaveCb?null:h,u.nextSibling(m)),t(a.parent))for(var g=a.parent,b=v(a);g;){for(var y=0;y<s.destroy.length;++y)s.destroy[y](g);if(g.elm=a.elm,b){for(var D=0;D<s.create.length;++D)s.create[D](tn,g);var x=g.data.hook.insert;if(x.merged)for(var E=1;E<x.fns.length;E++)x.fns[E]()}else rn(g);g=g.parent}t(h)?A([e],0,0):t(e.tag)&&w(e)}}return k(a,f,l),a.elm}t(e)&&w(e)}}({nodeOps:Xt,modules:[gn,kn,na,ia,ga,H?{create:Ha,activate:Ha,remove:function(e,r){!0!==e.data.show?Ia(e,r):r()}}:{}].concat(dn)});K&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Qa(e,"input")});var Ga={inserted:function(e,r,t,n){"select"===t.tag?(n.elm&&!n.elm._vOptions?or(t,"postpatch",function(){Ga.componentUpdated(e,r,t)}):za(e,r,t.context),e._vOptions=[].map.call(e.options,Za)):("textarea"===t.tag||Wt(e.type))&&(e._vModifiers=r.modifiers,r.modifiers.lazy||(e.addEventListener("compositionstart",Ya),e.addEventListener("compositionend",Wa),e.addEventListener("change",Wa),K&&(e.vmodel=!0)))},componentUpdated:function(e,r,t){if("select"===t.tag){za(e,r,t.context);var n=e._vOptions,a=e._vOptions=[].map.call(e.options,Za);if(a.some(function(e,r){return!T(e,n[r])}))(e.multiple?r.value.some(function(e){return Ka(e,a)}):r.value!==r.oldValue&&Ka(r.value,a))&&Qa(e,"change")}}};function za(e,r,t){Ja(e,r,t),(J||Z)&&setTimeout(function(){Ja(e,r,t)},0)}function Ja(e,r,t){var n=r.value,a=e.multiple;if(!a||Array.isArray(n)){for(var o,i,s=0,c=e.options.length;s<c;s++)if(i=e.options[s],a)o=$(n,Za(i))>-1,i.selected!==o&&(i.selected=o);else if(T(Za(i),n))return void(e.selectedIndex!==s&&(e.selectedIndex=s));a||(e.selectedIndex=-1)}}function Ka(e,r){return r.every(function(r){return!T(r,e)})}function Za(e){return"_value"in e?e._value:e.value}function Ya(e){e.target.composing=!0}function Wa(e){e.target.composing&&(e.target.composing=!1,Qa(e.target,"input"))}function Qa(e,r){var t=document.createEvent("HTMLEvents");t.initEvent(r,!0,!0),e.dispatchEvent(t)}function Xa(e){return!e.componentInstance||e.data&&e.data.transition?e:Xa(e.componentInstance._vnode)}var eo={model:Ga,show:{bind:function(e,r,t){var n=r.value,a=(t=Xa(t)).data&&t.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;n&&a?(t.data.show=!0,Va(t,function(){e.style.display=o})):e.style.display=n?o:"none"},update:function(e,r,t){var n=r.value;!n!=!r.oldValue&&((t=Xa(t)).data&&t.data.transition?(t.data.show=!0,n?Va(t,function(){e.style.display=e.__vOriginalDisplay}):Ia(t,function(){e.style.display="none"})):e.style.display=n?e.__vOriginalDisplay:"none")},unbind:function(e,r,t,n,a){a||(e.style.display=e.__vOriginalDisplay)}}},ro={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var r=e&&e.componentOptions;return r&&r.Ctor.options.abstract?to(Mr(r.children)):e}function no(e){var r={},t=e.$options;for(var n in t.propsData)r[n]=e[n];var a=t._parentListeners;for(var o in a)r[w(o)]=a[o];return r}function ao(e,r){if(/\d-keep-alive$/.test(r.tag))return e("keep-alive",{props:r.componentOptions.propsData})}var oo=function(e){return e.tag||Hr(e)},io=function(e){return"show"===e.name},so={name:"transition",props:ro,abstract:!0,render:function(e){var r=this,t=this.$slots.default;if(t&&(t=t.filter(oo)).length){var n=this.mode,o=t[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var i=to(o);if(!i)return o;if(this._leaving)return ao(e,o);var s="__transition-"+this._uid+"-";i.key=null==i.key?i.isComment?s+"comment":s+i.tag:a(i.key)?0===String(i.key).indexOf(s)?i.key:s+i.key:i.key;var c=(i.data||(i.data={})).transition=no(this),u=this._vnode,l=to(u);if(i.data.directives&&i.data.directives.some(io)&&(i.data.show=!0),l&&l.data&&!function(e,r){return r.key===e.key&&r.tag===e.tag}(i,l)&&!Hr(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var p=l.data.transition=E({},c);if("out-in"===n)return this._leaving=!0,or(p,"afterLeave",function(){r._leaving=!1,r.$forceUpdate()}),ao(e,o);if("in-out"===n){if(Hr(i))return u;var f,d=function(){f()};or(c,"afterEnter",d),or(c,"enterCancelled",d),or(p,"delayLeave",function(e){f=e})}}return o}}},co=E({tag:String,moveClass:String},ro);function uo(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function lo(e){e.data.newPos=e.elm.getBoundingClientRect()}function po(e){var r=e.data.pos,t=e.data.newPos,n=r.left-t.left,a=r.top-t.top;if(n||a){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+n+"px,"+a+"px)",o.transitionDuration="0s"}}delete co.mode;var fo={Transition:so,TransitionGroup:{props:co,beforeMount:function(){var e=this,r=this._update;this._update=function(t,n){var a=Yr(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,a(),r.call(e,t,n)}},render:function(e){for(var r=this.tag||this.$vnode.data.tag||"span",t=Object.create(null),n=this.prevChildren=this.children,a=this.$slots.default||[],o=this.children=[],i=no(this),s=0;s<a.length;s++){var c=a[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),t[c.key]=c,(c.data||(c.data={})).transition=i)}if(n){for(var u=[],l=[],p=0;p<n.length;p++){var f=n[p];f.data.transition=i,f.data.pos=f.elm.getBoundingClientRect(),t[f.key]?u.push(f):l.push(f)}this.kept=e(r,null,u),this.removed=l}return e(r,null,o)},updated:function(){var e=this.prevChildren,r=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,r)&&(e.forEach(uo),e.forEach(lo),e.forEach(po),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var t=e.elm,n=t.style;$a(t,r),n.transform=n.WebkitTransform=n.transitionDuration="",t.addEventListener(_a,t._moveCb=function e(n){n&&n.target!==t||n&&!/transform$/.test(n.propertyName)||(t.removeEventListener(_a,e),t._moveCb=null,Na(t,r))})}}))},methods:{hasMove:function(e,r){if(!xa)return!1;if(this._hasMove)return this._hasMove;var t=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){wa(t,e)}),ya(t,r),t.style.display="none",this.$el.appendChild(t);var n=Fa(t);return this.$el.removeChild(t),this._hasMove=n.hasTransform}}}};Dt.config.mustUseProp=$t,Dt.config.isReservedTag=Kt,Dt.config.isReservedAttr=Lt,Dt.config.getTagNamespace=Zt,Dt.config.isUnknownElement=function(e){if(!H)return!0;if(Kt(e))return!1;if(e=e.toLowerCase(),null!=Yt[e])return Yt[e];var r=document.createElement(e);return e.indexOf("-")>-1?Yt[e]=r.constructor===window.HTMLUnknownElement||r.constructor===window.HTMLElement:Yt[e]=/HTMLUnknownElement/.test(r.toString())},E(Dt.options.directives,eo),E(Dt.options.components,fo),Dt.prototype.__patch__=H?Ma:C,Dt.prototype.$mount=function(e,r){return function(e,r,t){var n;return e.$el=r,e.$options.render||(e.$options.render=me),Xr(e,"beforeMount"),n=function(){e._update(e._render(),t)},new pt(e,n,C,{before:function(){e._isMounted&&!e._isDestroyed&&Xr(e,"beforeUpdate")}},!0),t=!1,null==e.$vnode&&(e._isMounted=!0,Xr(e,"mounted")),e}(this,e=e&&H?Qt(e):void 0,r)},H&&setTimeout(function(){B.devtools&&te&&te.emit("init",Dt)},0);var mo=/\{\{((?:.|\r?\n)+?)\}\}/g,ho=/[-.*+?^${}()|[\]\/\\]/g,vo=b(function(e){var r=e[0].replace(ho,"\\$&"),t=e[1].replace(ho,"\\$&");return new RegExp(r+"((?:.|\\n)+?)"+t,"g")});var go={staticKeys:["staticClass"],transformNode:function(e,r){r.warn;var t=Un(e,"class");t&&(e.staticClass=JSON.stringify(t));var n=Bn(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var r="";return e.staticClass&&(r+="staticClass:"+e.staticClass+","),e.classBinding&&(r+="class:"+e.classBinding+","),r}};var bo={staticKeys:["staticStyle"],transformNode:function(e,r){r.warn;var t=Un(e,"style");t&&(e.staticStyle=JSON.stringify(sa(t)));var n=Bn(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var r="";return e.staticStyle&&(r+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(r+="style:("+e.styleBinding+"),"),r}};!function(e){var r="object"==typeof exports&&exports,t="object"==typeof module&&module&&module.exports==r&&module,n="object"==typeof global&&global;n.global!==n&&n.window!==n||(e=n);var a=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,o=/[\x01-\x7F]/g,i=/[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,s=/<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g,c={"\xad":"shy","\u200c":"zwnj","\u200d":"zwj","\u200e":"lrm","\u2063":"ic","\u2062":"it","\u2061":"af","\u200f":"rlm","\u200b":"ZeroWidthSpace","\u2060":"NoBreak","\u0311":"DownBreve","\u20db":"tdot","\u20dc":"DotDot","\t":"Tab","\n":"NewLine","\u2008":"puncsp","\u205f":"MediumSpace","\u2009":"thinsp","\u200a":"hairsp","\u2004":"emsp13","\u2002":"ensp","\u2005":"emsp14","\u2003":"emsp","\u2007":"numsp","\xa0":"nbsp","\u205f\u200a":"ThickSpace","\u203e":"oline",_:"lowbar","\u2010":"dash","\u2013":"ndash","\u2014":"mdash","\u2015":"horbar",",":"comma",";":"semi","\u204f":"bsemi",":":"colon","\u2a74":"Colone","!":"excl","\xa1":"iexcl","?":"quest","\xbf":"iquest",".":"period","\u2025":"nldr","\u2026":"mldr","\xb7":"middot","'":"apos","\u2018":"lsquo","\u2019":"rsquo","\u201a":"sbquo","\u2039":"lsaquo","\u203a":"rsaquo",'"':"quot","\u201c":"ldquo","\u201d":"rdquo","\u201e":"bdquo","\xab":"laquo","\xbb":"raquo","(":"lpar",")":"rpar","[":"lsqb","]":"rsqb","{":"lcub","}":"rcub","\u2308":"lceil","\u2309":"rceil","\u230a":"lfloor","\u230b":"rfloor","\u2985":"lopar","\u2986":"ropar","\u298b":"lbrke","\u298c":"rbrke","\u298d":"lbrkslu","\u298e":"rbrksld","\u298f":"lbrksld","\u2990":"rbrkslu","\u2991":"langd","\u2992":"rangd","\u2993":"lparlt","\u2994":"rpargt","\u2995":"gtlPar","\u2996":"ltrPar","\u27e6":"lobrk","\u27e7":"robrk","\u27e8":"lang","\u27e9":"rang","\u27ea":"Lang","\u27eb":"Rang","\u27ec":"loang","\u27ed":"roang","\u2772":"lbbrk","\u2773":"rbbrk","\u2016":"Vert","\xa7":"sect","\xb6":"para","@":"commat","*":"ast","/":"sol",undefined:null,"&":"amp","#":"num","%":"percnt","\u2030":"permil","\u2031":"pertenk","\u2020":"dagger","\u2021":"Dagger","\u2022":"bull","\u2043":"hybull","\u2032":"prime","\u2033":"Prime","\u2034":"tprime","\u2057":"qprime","\u2035":"bprime","\u2041":"caret","`":"grave","\xb4":"acute","\u02dc":"tilde","^":"Hat","\xaf":"macr","\u02d8":"breve","\u02d9":"dot","\xa8":"die","\u02da":"ring","\u02dd":"dblac","\xb8":"cedil","\u02db":"ogon","\u02c6":"circ","\u02c7":"caron","\xb0":"deg","\xa9":"copy","\xae":"reg","\u2117":"copysr","\u2118":"wp","\u211e":"rx","\u2127":"mho","\u2129":"iiota","\u2190":"larr","\u219a":"nlarr","\u2192":"rarr","\u219b":"nrarr","\u2191":"uarr","\u2193":"darr","\u2194":"harr","\u21ae":"nharr","\u2195":"varr","\u2196":"nwarr","\u2197":"nearr","\u2198":"searr","\u2199":"swarr","\u219d":"rarrw","\u219d\u0338":"nrarrw","\u219e":"Larr","\u219f":"Uarr","\u21a0":"Rarr","\u21a1":"Darr","\u21a2":"larrtl","\u21a3":"rarrtl","\u21a4":"mapstoleft","\u21a5":"mapstoup","\u21a6":"map","\u21a7":"mapstodown","\u21a9":"larrhk","\u21aa":"rarrhk","\u21ab":"larrlp","\u21ac":"rarrlp","\u21ad":"harrw","\u21b0":"lsh","\u21b1":"rsh","\u21b2":"ldsh","\u21b3":"rdsh","\u21b5":"crarr","\u21b6":"cularr","\u21b7":"curarr","\u21ba":"olarr","\u21bb":"orarr","\u21bc":"lharu","\u21bd":"lhard","\u21be":"uharr","\u21bf":"uharl","\u21c0":"rharu","\u21c1":"rhard","\u21c2":"dharr","\u21c3":"dharl","\u21c4":"rlarr","\u21c5":"udarr","\u21c6":"lrarr","\u21c7":"llarr","\u21c8":"uuarr","\u21c9":"rrarr","\u21ca":"ddarr","\u21cb":"lrhar","\u21cc":"rlhar","\u21d0":"lArr","\u21cd":"nlArr","\u21d1":"uArr","\u21d2":"rArr","\u21cf":"nrArr","\u21d3":"dArr","\u21d4":"iff","\u21ce":"nhArr","\u21d5":"vArr","\u21d6":"nwArr","\u21d7":"neArr","\u21d8":"seArr","\u21d9":"swArr","\u21da":"lAarr","\u21db":"rAarr","\u21dd":"zigrarr","\u21e4":"larrb","\u21e5":"rarrb","\u21f5":"duarr","\u21fd":"loarr","\u21fe":"roarr","\u21ff":"hoarr","\u2200":"forall","\u2201":"comp","\u2202":"part","\u2202\u0338":"npart","\u2203":"exist","\u2204":"nexist","\u2205":"empty","\u2207":"Del","\u2208":"in","\u2209":"notin","\u220b":"ni","\u220c":"notni","\u03f6":"bepsi","\u220f":"prod","\u2210":"coprod","\u2211":"sum","+":"plus","\xb1":"pm","\xf7":"div","\xd7":"times","<":"lt","\u226e":"nlt","<\u20d2":"nvlt","=":"equals","\u2260":"ne","=\u20e5":"bne","\u2a75":"Equal",">":"gt","\u226f":"ngt",">\u20d2":"nvgt","\xac":"not","|":"vert","\xa6":"brvbar","\u2212":"minus","\u2213":"mp","\u2214":"plusdo","\u2044":"frasl","\u2216":"setmn","\u2217":"lowast","\u2218":"compfn","\u221a":"Sqrt","\u221d":"prop","\u221e":"infin","\u221f":"angrt","\u2220":"ang","\u2220\u20d2":"nang","\u2221":"angmsd","\u2222":"angsph","\u2223":"mid","\u2224":"nmid","\u2225":"par","\u2226":"npar","\u2227":"and","\u2228":"or","\u2229":"cap","\u2229\ufe00":"caps","\u222a":"cup","\u222a\ufe00":"cups","\u222b":"int","\u222c":"Int","\u222d":"tint","\u2a0c":"qint","\u222e":"oint","\u222f":"Conint","\u2230":"Cconint","\u2231":"cwint","\u2232":"cwconint","\u2233":"awconint","\u2234":"there4","\u2235":"becaus","\u2236":"ratio","\u2237":"Colon","\u2238":"minusd","\u223a":"mDDot","\u223b":"homtht","\u223c":"sim","\u2241":"nsim","\u223c\u20d2":"nvsim","\u223d":"bsim","\u223d\u0331":"race","\u223e":"ac","\u223e\u0333":"acE","\u223f":"acd","\u2240":"wr","\u2242":"esim","\u2242\u0338":"nesim","\u2243":"sime","\u2244":"nsime","\u2245":"cong","\u2247":"ncong","\u2246":"simne","\u2248":"ap","\u2249":"nap","\u224a":"ape","\u224b":"apid","\u224b\u0338":"napid","\u224c":"bcong","\u224d":"CupCap","\u226d":"NotCupCap","\u224d\u20d2":"nvap","\u224e":"bump","\u224e\u0338":"nbump","\u224f":"bumpe","\u224f\u0338":"nbumpe","\u2250":"doteq","\u2250\u0338":"nedot","\u2251":"eDot","\u2252":"efDot","\u2253":"erDot","\u2254":"colone","\u2255":"ecolon","\u2256":"ecir","\u2257":"cire","\u2259":"wedgeq","\u225a":"veeeq","\u225c":"trie","\u225f":"equest","\u2261":"equiv","\u2262":"nequiv","\u2261\u20e5":"bnequiv","\u2264":"le","\u2270":"nle","\u2264\u20d2":"nvle","\u2265":"ge","\u2271":"nge","\u2265\u20d2":"nvge","\u2266":"lE","\u2266\u0338":"nlE","\u2267":"gE","\u2267\u0338":"ngE","\u2268\ufe00":"lvnE","\u2268":"lnE","\u2269":"gnE","\u2269\ufe00":"gvnE","\u226a":"ll","\u226a\u0338":"nLtv","\u226a\u20d2":"nLt","\u226b":"gg","\u226b\u0338":"nGtv","\u226b\u20d2":"nGt","\u226c":"twixt","\u2272":"lsim","\u2274":"nlsim","\u2273":"gsim","\u2275":"ngsim","\u2276":"lg","\u2278":"ntlg","\u2277":"gl","\u2279":"ntgl","\u227a":"pr","\u2280":"npr","\u227b":"sc","\u2281":"nsc","\u227c":"prcue","\u22e0":"nprcue","\u227d":"sccue","\u22e1":"nsccue","\u227e":"prsim","\u227f":"scsim","\u227f\u0338":"NotSucceedsTilde","\u2282":"sub","\u2284":"nsub","\u2282\u20d2":"vnsub","\u2283":"sup","\u2285":"nsup","\u2283\u20d2":"vnsup","\u2286":"sube","\u2288":"nsube","\u2287":"supe","\u2289":"nsupe","\u228a\ufe00":"vsubne","\u228a":"subne","\u228b\ufe00":"vsupne","\u228b":"supne","\u228d":"cupdot","\u228e":"uplus","\u228f":"sqsub","\u228f\u0338":"NotSquareSubset","\u2290":"sqsup","\u2290\u0338":"NotSquareSuperset","\u2291":"sqsube","\u22e2":"nsqsube","\u2292":"sqsupe","\u22e3":"nsqsupe","\u2293":"sqcap","\u2293\ufe00":"sqcaps","\u2294":"sqcup","\u2294\ufe00":"sqcups","\u2295":"oplus","\u2296":"ominus","\u2297":"otimes","\u2298":"osol","\u2299":"odot","\u229a":"ocir","\u229b":"oast","\u229d":"odash","\u229e":"plusb","\u229f":"minusb","\u22a0":"timesb","\u22a1":"sdotb","\u22a2":"vdash","\u22ac":"nvdash","\u22a3":"dashv","\u22a4":"top","\u22a5":"bot","\u22a7":"models","\u22a8":"vDash","\u22ad":"nvDash","\u22a9":"Vdash","\u22ae":"nVdash","\u22aa":"Vvdash","\u22ab":"VDash","\u22af":"nVDash","\u22b0":"prurel","\u22b2":"vltri","\u22ea":"nltri","\u22b3":"vrtri","\u22eb":"nrtri","\u22b4":"ltrie","\u22ec":"nltrie","\u22b4\u20d2":"nvltrie","\u22b5":"rtrie","\u22ed":"nrtrie","\u22b5\u20d2":"nvrtrie","\u22b6":"origof","\u22b7":"imof","\u22b8":"mumap","\u22b9":"hercon","\u22ba":"intcal","\u22bb":"veebar","\u22bd":"barvee","\u22be":"angrtvb","\u22bf":"lrtri","\u22c0":"Wedge","\u22c1":"Vee","\u22c2":"xcap","\u22c3":"xcup","\u22c4":"diam","\u22c5":"sdot","\u22c6":"Star","\u22c7":"divonx","\u22c8":"bowtie","\u22c9":"ltimes","\u22ca":"rtimes","\u22cb":"lthree","\u22cc":"rthree","\u22cd":"bsime","\u22ce":"cuvee","\u22cf":"cuwed","\u22d0":"Sub","\u22d1":"Sup","\u22d2":"Cap","\u22d3":"Cup","\u22d4":"fork","\u22d5":"epar","\u22d6":"ltdot","\u22d7":"gtdot","\u22d8":"Ll","\u22d8\u0338":"nLl","\u22d9":"Gg","\u22d9\u0338":"nGg","\u22da\ufe00":"lesg","\u22da":"leg","\u22db":"gel","\u22db\ufe00":"gesl","\u22de":"cuepr","\u22df":"cuesc","\u22e6":"lnsim","\u22e7":"gnsim","\u22e8":"prnsim","\u22e9":"scnsim","\u22ee":"vellip","\u22ef":"ctdot","\u22f0":"utdot","\u22f1":"dtdot","\u22f2":"disin","\u22f3":"isinsv","\u22f4":"isins","\u22f5":"isindot","\u22f5\u0338":"notindot","\u22f6":"notinvc","\u22f7":"notinvb","\u22f9":"isinE","\u22f9\u0338":"notinE","\u22fa":"nisd","\u22fb":"xnis","\u22fc":"nis","\u22fd":"notnivc","\u22fe":"notnivb","\u2305":"barwed","\u2306":"Barwed","\u230c":"drcrop","\u230d":"dlcrop","\u230e":"urcrop","\u230f":"ulcrop","\u2310":"bnot","\u2312":"profline","\u2313":"profsurf","\u2315":"telrec","\u2316":"target","\u231c":"ulcorn","\u231d":"urcorn","\u231e":"dlcorn","\u231f":"drcorn","\u2322":"frown","\u2323":"smile","\u232d":"cylcty","\u232e":"profalar","\u2336":"topbot","\u233d":"ovbar","\u233f":"solbar","\u237c":"angzarr","\u23b0":"lmoust","\u23b1":"rmoust","\u23b4":"tbrk","\u23b5":"bbrk","\u23b6":"bbrktbrk","\u23dc":"OverParenthesis","\u23dd":"UnderParenthesis","\u23de":"OverBrace","\u23df":"UnderBrace","\u23e2":"trpezium","\u23e7":"elinters","\u2423":"blank","\u2500":"boxh","\u2502":"boxv","\u250c":"boxdr","\u2510":"boxdl","\u2514":"boxur","\u2518":"boxul","\u251c":"boxvr","\u2524":"boxvl","\u252c":"boxhd","\u2534":"boxhu","\u253c":"boxvh","\u2550":"boxH","\u2551":"boxV","\u2552":"boxdR","\u2553":"boxDr","\u2554":"boxDR","\u2555":"boxdL","\u2556":"boxDl","\u2557":"boxDL","\u2558":"boxuR","\u2559":"boxUr","\u255a":"boxUR","\u255b":"boxuL","\u255c":"boxUl","\u255d":"boxUL","\u255e":"boxvR","\u255f":"boxVr","\u2560":"boxVR","\u2561":"boxvL","\u2562":"boxVl","\u2563":"boxVL","\u2564":"boxHd","\u2565":"boxhD","\u2566":"boxHD","\u2567":"boxHu","\u2568":"boxhU","\u2569":"boxHU","\u256a":"boxvH","\u256b":"boxVh","\u256c":"boxVH","\u2580":"uhblk","\u2584":"lhblk","\u2588":"block","\u2591":"blk14","\u2592":"blk12","\u2593":"blk34","\u25a1":"squ","\u25aa":"squf","\u25ab":"EmptyVerySmallSquare","\u25ad":"rect","\u25ae":"marker","\u25b1":"fltns","\u25b3":"xutri","\u25b4":"utrif","\u25b5":"utri","\u25b8":"rtrif","\u25b9":"rtri","\u25bd":"xdtri","\u25be":"dtrif","\u25bf":"dtri","\u25c2":"ltrif","\u25c3":"ltri","\u25ca":"loz","\u25cb":"cir","\u25ec":"tridot","\u25ef":"xcirc","\u25f8":"ultri","\u25f9":"urtri","\u25fa":"lltri","\u25fb":"EmptySmallSquare","\u25fc":"FilledSmallSquare","\u2605":"starf","\u2606":"star","\u260e":"phone","\u2640":"female","\u2642":"male","\u2660":"spades","\u2663":"clubs","\u2665":"hearts","\u2666":"diams","\u266a":"sung","\u2713":"check","\u2717":"cross","\u2720":"malt","\u2736":"sext","\u2758":"VerticalSeparator","\u27c8":"bsolhsub","\u27c9":"suphsol","\u27f5":"xlarr","\u27f6":"xrarr","\u27f7":"xharr","\u27f8":"xlArr","\u27f9":"xrArr","\u27fa":"xhArr","\u27fc":"xmap","\u27ff":"dzigrarr","\u2902":"nvlArr","\u2903":"nvrArr","\u2904":"nvHarr","\u2905":"Map","\u290c":"lbarr","\u290d":"rbarr","\u290e":"lBarr","\u290f":"rBarr","\u2910":"RBarr","\u2911":"DDotrahd","\u2912":"UpArrowBar","\u2913":"DownArrowBar","\u2916":"Rarrtl","\u2919":"latail","\u291a":"ratail","\u291b":"lAtail","\u291c":"rAtail","\u291d":"larrfs","\u291e":"rarrfs","\u291f":"larrbfs","\u2920":"rarrbfs","\u2923":"nwarhk","\u2924":"nearhk","\u2925":"searhk","\u2926":"swarhk","\u2927":"nwnear","\u2928":"toea","\u2929":"tosa","\u292a":"swnwar","\u2933":"rarrc","\u2933\u0338":"nrarrc","\u2935":"cudarrr","\u2936":"ldca","\u2937":"rdca","\u2938":"cudarrl","\u2939":"larrpl","\u293c":"curarrm","\u293d":"cularrp","\u2945":"rarrpl","\u2948":"harrcir","\u2949":"Uarrocir","\u294a":"lurdshar","\u294b":"ldrushar","\u294e":"LeftRightVector","\u294f":"RightUpDownVector","\u2950":"DownLeftRightVector","\u2951":"LeftUpDownVector","\u2952":"LeftVectorBar","\u2953":"RightVectorBar","\u2954":"RightUpVectorBar","\u2955":"RightDownVectorBar","\u2956":"DownLeftVectorBar","\u2957":"DownRightVectorBar","\u2958":"LeftUpVectorBar","\u2959":"LeftDownVectorBar","\u295a":"LeftTeeVector","\u295b":"RightTeeVector","\u295c":"RightUpTeeVector","\u295d":"RightDownTeeVector","\u295e":"DownLeftTeeVector","\u295f":"DownRightTeeVector","\u2960":"LeftUpTeeVector","\u2961":"LeftDownTeeVector","\u2962":"lHar","\u2963":"uHar","\u2964":"rHar","\u2965":"dHar","\u2966":"luruhar","\u2967":"ldrdhar","\u2968":"ruluhar","\u2969":"rdldhar","\u296a":"lharul","\u296b":"llhard","\u296c":"rharul","\u296d":"lrhard","\u296e":"udhar","\u296f":"duhar","\u2970":"RoundImplies","\u2971":"erarr","\u2972":"simrarr","\u2973":"larrsim","\u2974":"rarrsim","\u2975":"rarrap","\u2976":"ltlarr","\u2978":"gtrarr","\u2979":"subrarr","\u297b":"suplarr","\u297c":"lfisht","\u297d":"rfisht","\u297e":"ufisht","\u297f":"dfisht","\u299a":"vzigzag","\u299c":"vangrt","\u299d":"angrtvbd","\u29a4":"ange","\u29a5":"range","\u29a6":"dwangle","\u29a7":"uwangle","\u29a8":"angmsdaa","\u29a9":"angmsdab","\u29aa":"angmsdac","\u29ab":"angmsdad","\u29ac":"angmsdae","\u29ad":"angmsdaf","\u29ae":"angmsdag","\u29af":"angmsdah","\u29b0":"bemptyv","\u29b1":"demptyv","\u29b2":"cemptyv","\u29b3":"raemptyv","\u29b4":"laemptyv","\u29b5":"ohbar","\u29b6":"omid","\u29b7":"opar","\u29b9":"operp","\u29bb":"olcross","\u29bc":"odsold","\u29be":"olcir","\u29bf":"ofcir","\u29c0":"olt","\u29c1":"ogt","\u29c2":"cirscir","\u29c3":"cirE","\u29c4":"solb","\u29c5":"bsolb","\u29c9":"boxbox","\u29cd":"trisb","\u29ce":"rtriltri","\u29cf":"LeftTriangleBar","\u29cf\u0338":"NotLeftTriangleBar","\u29d0":"RightTriangleBar","\u29d0\u0338":"NotRightTriangleBar","\u29dc":"iinfin","\u29dd":"infintie","\u29de":"nvinfin","\u29e3":"eparsl","\u29e4":"smeparsl","\u29e5":"eqvparsl","\u29eb":"lozf","\u29f4":"RuleDelayed","\u29f6":"dsol","\u2a00":"xodot","\u2a01":"xoplus","\u2a02":"xotime","\u2a04":"xuplus","\u2a06":"xsqcup","\u2a0d":"fpartint","\u2a10":"cirfnint","\u2a11":"awint","\u2a12":"rppolint","\u2a13":"scpolint","\u2a14":"npolint","\u2a15":"pointint","\u2a16":"quatint","\u2a17":"intlarhk","\u2a22":"pluscir","\u2a23":"plusacir","\u2a24":"simplus","\u2a25":"plusdu","\u2a26":"plussim","\u2a27":"plustwo","\u2a29":"mcomma","\u2a2a":"minusdu","\u2a2d":"loplus","\u2a2e":"roplus","\u2a2f":"Cross","\u2a30":"timesd","\u2a31":"timesbar","\u2a33":"smashp","\u2a34":"lotimes","\u2a35":"rotimes","\u2a36":"otimesas","\u2a37":"Otimes","\u2a38":"odiv","\u2a39":"triplus","\u2a3a":"triminus","\u2a3b":"tritime","\u2a3c":"iprod","\u2a3f":"amalg","\u2a40":"capdot","\u2a42":"ncup","\u2a43":"ncap","\u2a44":"capand","\u2a45":"cupor","\u2a46":"cupcap","\u2a47":"capcup","\u2a48":"cupbrcap","\u2a49":"capbrcup","\u2a4a":"cupcup","\u2a4b":"capcap","\u2a4c":"ccups","\u2a4d":"ccaps","\u2a50":"ccupssm","\u2a53":"And","\u2a54":"Or","\u2a55":"andand","\u2a56":"oror","\u2a57":"orslope","\u2a58":"andslope","\u2a5a":"andv","\u2a5b":"orv","\u2a5c":"andd","\u2a5d":"ord","\u2a5f":"wedbar","\u2a66":"sdote","\u2a6a":"simdot","\u2a6d":"congdot","\u2a6d\u0338":"ncongdot","\u2a6e":"easter","\u2a6f":"apacir","\u2a70":"apE","\u2a70\u0338":"napE","\u2a71":"eplus","\u2a72":"pluse","\u2a73":"Esim","\u2a77":"eDDot","\u2a78":"equivDD","\u2a79":"ltcir","\u2a7a":"gtcir","\u2a7b":"ltquest","\u2a7c":"gtquest","\u2a7d":"les","\u2a7d\u0338":"nles","\u2a7e":"ges","\u2a7e\u0338":"nges","\u2a7f":"lesdot","\u2a80":"gesdot","\u2a81":"lesdoto","\u2a82":"gesdoto","\u2a83":"lesdotor","\u2a84":"gesdotol","\u2a85":"lap","\u2a86":"gap","\u2a87":"lne","\u2a88":"gne","\u2a89":"lnap","\u2a8a":"gnap","\u2a8b":"lEg","\u2a8c":"gEl","\u2a8d":"lsime","\u2a8e":"gsime","\u2a8f":"lsimg","\u2a90":"gsiml","\u2a91":"lgE","\u2a92":"glE","\u2a93":"lesges","\u2a94":"gesles","\u2a95":"els","\u2a96":"egs","\u2a97":"elsdot","\u2a98":"egsdot","\u2a99":"el","\u2a9a":"eg","\u2a9d":"siml","\u2a9e":"simg","\u2a9f":"simlE","\u2aa0":"simgE","\u2aa1":"LessLess","\u2aa1\u0338":"NotNestedLessLess","\u2aa2":"GreaterGreater","\u2aa2\u0338":"NotNestedGreaterGreater","\u2aa4":"glj","\u2aa5":"gla","\u2aa6":"ltcc","\u2aa7":"gtcc","\u2aa8":"lescc","\u2aa9":"gescc","\u2aaa":"smt","\u2aab":"lat","\u2aac":"smte","\u2aac\ufe00":"smtes","\u2aad":"late","\u2aad\ufe00":"lates","\u2aae":"bumpE","\u2aaf":"pre","\u2aaf\u0338":"npre","\u2ab0":"sce","\u2ab0\u0338":"nsce","\u2ab3":"prE","\u2ab4":"scE","\u2ab5":"prnE","\u2ab6":"scnE","\u2ab7":"prap","\u2ab8":"scap","\u2ab9":"prnap","\u2aba":"scnap","\u2abb":"Pr","\u2abc":"Sc","\u2abd":"subdot","\u2abe":"supdot","\u2abf":"subplus","\u2ac0":"supplus","\u2ac1":"submult","\u2ac2":"supmult","\u2ac3":"subedot","\u2ac4":"supedot","\u2ac5":"subE","\u2ac5\u0338":"nsubE","\u2ac6":"supE","\u2ac6\u0338":"nsupE","\u2ac7":"subsim","\u2ac8":"supsim","\u2acb\ufe00":"vsubnE","\u2acb":"subnE","\u2acc\ufe00":"vsupnE","\u2acc":"supnE","\u2acf":"csub","\u2ad0":"csup","\u2ad1":"csube","\u2ad2":"csupe","\u2ad3":"subsup","\u2ad4":"supsub","\u2ad5":"subsub","\u2ad6":"supsup","\u2ad7":"suphsub","\u2ad8":"supdsub","\u2ad9":"forkv","\u2ada":"topfork","\u2adb":"mlcp","\u2ae4":"Dashv","\u2ae6":"Vdashl","\u2ae7":"Barv","\u2ae8":"vBar","\u2ae9":"vBarv","\u2aeb":"Vbar","\u2aec":"Not","\u2aed":"bNot","\u2aee":"rnmid","\u2aef":"cirmid","\u2af0":"midcir","\u2af1":"topcir","\u2af2":"nhpar","\u2af3":"parsim","\u2afd":"parsl","\u2afd\u20e5":"nparsl","\u266d":"flat","\u266e":"natur","\u266f":"sharp","\xa4":"curren","\xa2":"cent",$:"dollar","\xa3":"pound","\xa5":"yen","\u20ac":"euro","\xb9":"sup1","\xbd":"half","\u2153":"frac13","\xbc":"frac14","\u2155":"frac15","\u2159":"frac16","\u215b":"frac18","\xb2":"sup2","\u2154":"frac23","\u2156":"frac25","\xb3":"sup3","\xbe":"frac34","\u2157":"frac35","\u215c":"frac38","\u2158":"frac45","\u215a":"frac56","\u215d":"frac58","\u215e":"frac78","\ud835\udcb6":"ascr","\ud835\udd52":"aopf","\ud835\udd1e":"afr","\ud835\udd38":"Aopf","\ud835\udd04":"Afr","\ud835\udc9c":"Ascr","\xaa":"ordf","\xe1":"aacute","\xc1":"Aacute","\xe0":"agrave","\xc0":"Agrave","\u0103":"abreve","\u0102":"Abreve","\xe2":"acirc","\xc2":"Acirc","\xe5":"aring","\xc5":"angst","\xe4":"auml","\xc4":"Auml","\xe3":"atilde","\xc3":"Atilde","\u0105":"aogon","\u0104":"Aogon","\u0101":"amacr","\u0100":"Amacr","\xe6":"aelig","\xc6":"AElig","\ud835\udcb7":"bscr","\ud835\udd53":"bopf","\ud835\udd1f":"bfr","\ud835\udd39":"Bopf","\u212c":"Bscr","\ud835\udd05":"Bfr","\ud835\udd20":"cfr","\ud835\udcb8":"cscr","\ud835\udd54":"copf","\u212d":"Cfr","\ud835\udc9e":"Cscr","\u2102":"Copf","\u0107":"cacute","\u0106":"Cacute","\u0109":"ccirc","\u0108":"Ccirc","\u010d":"ccaron","\u010c":"Ccaron","\u010b":"cdot","\u010a":"Cdot","\xe7":"ccedil","\xc7":"Ccedil","\u2105":"incare","\ud835\udd21":"dfr","\u2146":"dd","\ud835\udd55":"dopf","\ud835\udcb9":"dscr","\ud835\udc9f":"Dscr","\ud835\udd07":"Dfr","\u2145":"DD","\ud835\udd3b":"Dopf","\u010f":"dcaron","\u010e":"Dcaron","\u0111":"dstrok","\u0110":"Dstrok","\xf0":"eth","\xd0":"ETH","\u2147":"ee","\u212f":"escr","\ud835\udd22":"efr","\ud835\udd56":"eopf","\u2130":"Escr","\ud835\udd08":"Efr","\ud835\udd3c":"Eopf","\xe9":"eacute","\xc9":"Eacute","\xe8":"egrave","\xc8":"Egrave","\xea":"ecirc","\xca":"Ecirc","\u011b":"ecaron","\u011a":"Ecaron","\xeb":"euml","\xcb":"Euml","\u0117":"edot","\u0116":"Edot","\u0119":"eogon","\u0118":"Eogon","\u0113":"emacr","\u0112":"Emacr","\ud835\udd23":"ffr","\ud835\udd57":"fopf","\ud835\udcbb":"fscr","\ud835\udd09":"Ffr","\ud835\udd3d":"Fopf","\u2131":"Fscr","\ufb00":"fflig","\ufb03":"ffilig","\ufb04":"ffllig","\ufb01":"filig",fj:"fjlig","\ufb02":"fllig","\u0192":"fnof","\u210a":"gscr","\ud835\udd58":"gopf","\ud835\udd24":"gfr","\ud835\udca2":"Gscr","\ud835\udd3e":"Gopf","\ud835\udd0a":"Gfr","\u01f5":"gacute","\u011f":"gbreve","\u011e":"Gbreve","\u011d":"gcirc","\u011c":"Gcirc","\u0121":"gdot","\u0120":"Gdot","\u0122":"Gcedil","\ud835\udd25":"hfr","\u210e":"planckh","\ud835\udcbd":"hscr","\ud835\udd59":"hopf","\u210b":"Hscr","\u210c":"Hfr","\u210d":"Hopf","\u0125":"hcirc","\u0124":"Hcirc","\u210f":"hbar","\u0127":"hstrok","\u0126":"Hstrok","\ud835\udd5a":"iopf","\ud835\udd26":"ifr","\ud835\udcbe":"iscr","\u2148":"ii","\ud835\udd40":"Iopf","\u2110":"Iscr","\u2111":"Im","\xed":"iacute","\xcd":"Iacute","\xec":"igrave","\xcc":"Igrave","\xee":"icirc","\xce":"Icirc","\xef":"iuml","\xcf":"Iuml","\u0129":"itilde","\u0128":"Itilde","\u0130":"Idot","\u012f":"iogon","\u012e":"Iogon","\u012b":"imacr","\u012a":"Imacr","\u0133":"ijlig","\u0132":"IJlig","\u0131":"imath","\ud835\udcbf":"jscr","\ud835\udd5b":"jopf","\ud835\udd27":"jfr","\ud835\udca5":"Jscr","\ud835\udd0d":"Jfr","\ud835\udd41":"Jopf","\u0135":"jcirc","\u0134":"Jcirc","\u0237":"jmath","\ud835\udd5c":"kopf","\ud835\udcc0":"kscr","\ud835\udd28":"kfr","\ud835\udca6":"Kscr","\ud835\udd42":"Kopf","\ud835\udd0e":"Kfr","\u0137":"kcedil","\u0136":"Kcedil","\ud835\udd29":"lfr","\ud835\udcc1":"lscr","\u2113":"ell","\ud835\udd5d":"lopf","\u2112":"Lscr","\ud835\udd0f":"Lfr","\ud835\udd43":"Lopf","\u013a":"lacute","\u0139":"Lacute","\u013e":"lcaron","\u013d":"Lcaron","\u013c":"lcedil","\u013b":"Lcedil","\u0142":"lstrok","\u0141":"Lstrok","\u0140":"lmidot","\u013f":"Lmidot","\ud835\udd2a":"mfr","\ud835\udd5e":"mopf","\ud835\udcc2":"mscr","\ud835\udd10":"Mfr","\ud835\udd44":"Mopf","\u2133":"Mscr","\ud835\udd2b":"nfr","\ud835\udd5f":"nopf","\ud835\udcc3":"nscr","\u2115":"Nopf","\ud835\udca9":"Nscr","\ud835\udd11":"Nfr","\u0144":"nacute","\u0143":"Nacute","\u0148":"ncaron","\u0147":"Ncaron","\xf1":"ntilde","\xd1":"Ntilde","\u0146":"ncedil","\u0145":"Ncedil","\u2116":"numero","\u014b":"eng","\u014a":"ENG","\ud835\udd60":"oopf","\ud835\udd2c":"ofr","\u2134":"oscr","\ud835\udcaa":"Oscr","\ud835\udd12":"Ofr","\ud835\udd46":"Oopf","\xba":"ordm","\xf3":"oacute","\xd3":"Oacute","\xf2":"ograve","\xd2":"Ograve","\xf4":"ocirc","\xd4":"Ocirc","\xf6":"ouml","\xd6":"Ouml","\u0151":"odblac","\u0150":"Odblac","\xf5":"otilde","\xd5":"Otilde","\xf8":"oslash","\xd8":"Oslash","\u014d":"omacr","\u014c":"Omacr","\u0153":"oelig","\u0152":"OElig","\ud835\udd2d":"pfr","\ud835\udcc5":"pscr","\ud835\udd61":"popf","\u2119":"Popf","\ud835\udd13":"Pfr","\ud835\udcab":"Pscr","\ud835\udd62":"qopf","\ud835\udd2e":"qfr","\ud835\udcc6":"qscr","\ud835\udcac":"Qscr","\ud835\udd14":"Qfr","\u211a":"Qopf","\u0138":"kgreen","\ud835\udd2f":"rfr","\ud835\udd63":"ropf","\ud835\udcc7":"rscr","\u211b":"Rscr","\u211c":"Re","\u211d":"Ropf","\u0155":"racute","\u0154":"Racute","\u0159":"rcaron","\u0158":"Rcaron","\u0157":"rcedil","\u0156":"Rcedil","\ud835\udd64":"sopf","\ud835\udcc8":"sscr","\ud835\udd30":"sfr","\ud835\udd4a":"Sopf","\ud835\udd16":"Sfr","\ud835\udcae":"Sscr","\u24c8":"oS","\u015b":"sacute","\u015a":"Sacute","\u015d":"scirc","\u015c":"Scirc","\u0161":"scaron","\u0160":"Scaron","\u015f":"scedil","\u015e":"Scedil","\xdf":"szlig","\ud835\udd31":"tfr","\ud835\udcc9":"tscr","\ud835\udd65":"topf","\ud835\udcaf":"Tscr","\ud835\udd17":"Tfr","\ud835\udd4b":"Topf","\u0165":"tcaron","\u0164":"Tcaron","\u0163":"tcedil","\u0162":"Tcedil","\u2122":"trade","\u0167":"tstrok","\u0166":"Tstrok","\ud835\udcca":"uscr","\ud835\udd66":"uopf","\ud835\udd32":"ufr","\ud835\udd4c":"Uopf","\ud835\udd18":"Ufr","\ud835\udcb0":"Uscr","\xfa":"uacute","\xda":"Uacute","\xf9":"ugrave","\xd9":"Ugrave","\u016d":"ubreve","\u016c":"Ubreve","\xfb":"ucirc","\xdb":"Ucirc","\u016f":"uring","\u016e":"Uring","\xfc":"uuml","\xdc":"Uuml","\u0171":"udblac","\u0170":"Udblac","\u0169":"utilde","\u0168":"Utilde","\u0173":"uogon","\u0172":"Uogon","\u016b":"umacr","\u016a":"Umacr","\ud835\udd33":"vfr","\ud835\udd67":"vopf","\ud835\udccb":"vscr","\ud835\udd19":"Vfr","\ud835\udd4d":"Vopf","\ud835\udcb1":"Vscr","\ud835\udd68":"wopf","\ud835\udccc":"wscr","\ud835\udd34":"wfr","\ud835\udcb2":"Wscr","\ud835\udd4e":"Wopf","\ud835\udd1a":"Wfr","\u0175":"wcirc","\u0174":"Wcirc","\ud835\udd35":"xfr","\ud835\udccd":"xscr","\ud835\udd69":"xopf","\ud835\udd4f":"Xopf","\ud835\udd1b":"Xfr","\ud835\udcb3":"Xscr","\ud835\udd36":"yfr","\ud835\udcce":"yscr","\ud835\udd6a":"yopf","\ud835\udcb4":"Yscr","\ud835\udd1c":"Yfr","\ud835\udd50":"Yopf","\xfd":"yacute","\xdd":"Yacute","\u0177":"ycirc","\u0176":"Ycirc","\xff":"yuml","\u0178":"Yuml","\ud835\udccf":"zscr","\ud835\udd37":"zfr","\ud835\udd6b":"zopf","\u2128":"Zfr","\u2124":"Zopf","\ud835\udcb5":"Zscr","\u017a":"zacute","\u0179":"Zacute","\u017e":"zcaron","\u017d":"Zcaron","\u017c":"zdot","\u017b":"Zdot","\u01b5":"imped","\xfe":"thorn","\xde":"THORN","\u0149":"napos","\u03b1":"alpha","\u0391":"Alpha","\u03b2":"beta","\u0392":"Beta","\u03b3":"gamma","\u0393":"Gamma","\u03b4":"delta","\u0394":"Delta","\u03b5":"epsi","\u03f5":"epsiv","\u0395":"Epsilon","\u03dd":"gammad","\u03dc":"Gammad","\u03b6":"zeta","\u0396":"Zeta","\u03b7":"eta","\u0397":"Eta","\u03b8":"theta","\u03d1":"thetav","\u0398":"Theta","\u03b9":"iota","\u0399":"Iota","\u03ba":"kappa","\u03f0":"kappav","\u039a":"Kappa","\u03bb":"lambda","\u039b":"Lambda","\u03bc":"mu","\xb5":"micro","\u039c":"Mu","\u03bd":"nu","\u039d":"Nu","\u03be":"xi","\u039e":"Xi","\u03bf":"omicron","\u039f":"Omicron","\u03c0":"pi","\u03d6":"piv","\u03a0":"Pi","\u03c1":"rho","\u03f1":"rhov","\u03a1":"Rho","\u03c3":"sigma","\u03a3":"Sigma","\u03c2":"sigmaf","\u03c4":"tau","\u03a4":"Tau","\u03c5":"upsi","\u03a5":"Upsilon","\u03d2":"Upsi","\u03c6":"phi","\u03d5":"phiv","\u03a6":"Phi","\u03c7":"chi","\u03a7":"Chi","\u03c8":"psi","\u03a8":"Psi","\u03c9":"omega","\u03a9":"ohm","\u0430":"acy","\u0410":"Acy","\u0431":"bcy","\u0411":"Bcy","\u0432":"vcy","\u0412":"Vcy","\u0433":"gcy","\u0413":"Gcy","\u0453":"gjcy","\u0403":"GJcy","\u0434":"dcy","\u0414":"Dcy","\u0452":"djcy","\u0402":"DJcy","\u0435":"iecy","\u0415":"IEcy","\u0451":"iocy","\u0401":"IOcy","\u0454":"jukcy","\u0404":"Jukcy","\u0436":"zhcy","\u0416":"ZHcy","\u0437":"zcy","\u0417":"Zcy","\u0455":"dscy","\u0405":"DScy","\u0438":"icy","\u0418":"Icy","\u0456":"iukcy","\u0406":"Iukcy","\u0457":"yicy","\u0407":"YIcy","\u0439":"jcy","\u0419":"Jcy","\u0458":"jsercy","\u0408":"Jsercy","\u043a":"kcy","\u041a":"Kcy","\u045c":"kjcy","\u040c":"KJcy","\u043b":"lcy","\u041b":"Lcy","\u0459":"ljcy","\u0409":"LJcy","\u043c":"mcy","\u041c":"Mcy","\u043d":"ncy","\u041d":"Ncy","\u045a":"njcy","\u040a":"NJcy","\u043e":"ocy","\u041e":"Ocy","\u043f":"pcy","\u041f":"Pcy","\u0440":"rcy","\u0420":"Rcy","\u0441":"scy","\u0421":"Scy","\u0442":"tcy","\u0422":"Tcy","\u045b":"tshcy","\u040b":"TSHcy","\u0443":"ucy","\u0423":"Ucy","\u045e":"ubrcy","\u040e":"Ubrcy","\u0444":"fcy","\u0424":"Fcy","\u0445":"khcy","\u0425":"KHcy","\u0446":"tscy","\u0426":"TScy","\u0447":"chcy","\u0427":"CHcy","\u045f":"dzcy","\u040f":"DZcy","\u0448":"shcy","\u0428":"SHcy","\u0449":"shchcy","\u0429":"SHCHcy","\u044a":"hardcy","\u042a":"HARDcy","\u044b":"ycy","\u042b":"Ycy","\u044c":"softcy","\u042c":"SOFTcy","\u044d":"ecy","\u042d":"Ecy","\u044e":"yucy","\u042e":"YUcy","\u044f":"yacy","\u042f":"YAcy","\u2135":"aleph","\u2136":"beth","\u2137":"gimel","\u2138":"daleth"},u=/["&'<>`]/g,l={'"':"&quot;","&":"&amp;","'":"&#x27;","<":"&lt;",">":"&gt;","`":"&#x60;"},p=/&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/,f=/[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/,d=/&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g,m={aacute:"\xe1",Aacute:"\xc1",abreve:"\u0103",Abreve:"\u0102",ac:"\u223e",acd:"\u223f",acE:"\u223e\u0333",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",acy:"\u0430",Acy:"\u0410",aelig:"\xe6",AElig:"\xc6",af:"\u2061",afr:"\ud835\udd1e",Afr:"\ud835\udd04",agrave:"\xe0",Agrave:"\xc0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",Alpha:"\u0391",amacr:"\u0101",Amacr:"\u0100",amalg:"\u2a3f",amp:"&",AMP:"&",and:"\u2227",And:"\u2a53",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",ange:"\u29a4",angle:"\u2220",angmsd:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angst:"\xc5",angzarr:"\u237c",aogon:"\u0105",Aogon:"\u0104",aopf:"\ud835\udd52",Aopf:"\ud835\udd38",ap:"\u2248",apacir:"\u2a6f",ape:"\u224a",apE:"\u2a70",apid:"\u224b",apos:"'",ApplyFunction:"\u2061",approx:"\u2248",approxeq:"\u224a",aring:"\xe5",Aring:"\xc5",ascr:"\ud835\udcb6",Ascr:"\ud835\udc9c",Assign:"\u2254",ast:"*",asymp:"\u2248",asympeq:"\u224d",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",awconint:"\u2233",awint:"\u2a11",backcong:"\u224c",backepsilon:"\u03f6",backprime:"\u2035",backsim:"\u223d",backsimeq:"\u22cd",Backslash:"\u2216",Barv:"\u2ae7",barvee:"\u22bd",barwed:"\u2305",Barwed:"\u2306",barwedge:"\u2305",bbrk:"\u23b5",bbrktbrk:"\u23b6",bcong:"\u224c",bcy:"\u0431",Bcy:"\u0411",bdquo:"\u201e",becaus:"\u2235",because:"\u2235",Because:"\u2235",bemptyv:"\u29b0",bepsi:"\u03f6",bernou:"\u212c",Bernoullis:"\u212c",beta:"\u03b2",Beta:"\u0392",beth:"\u2136",between:"\u226c",bfr:"\ud835\udd1f",Bfr:"\ud835\udd05",bigcap:"\u22c2",bigcirc:"\u25ef",bigcup:"\u22c3",bigodot:"\u2a00",bigoplus:"\u2a01",bigotimes:"\u2a02",bigsqcup:"\u2a06",bigstar:"\u2605",bigtriangledown:"\u25bd",bigtriangleup:"\u25b3",biguplus:"\u2a04",bigvee:"\u22c1",bigwedge:"\u22c0",bkarow:"\u290d",blacklozenge:"\u29eb",blacksquare:"\u25aa",blacktriangle:"\u25b4",blacktriangledown:"\u25be",blacktriangleleft:"\u25c2",blacktriangleright:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bNot:"\u2aed",bopf:"\ud835\udd53",Bopf:"\ud835\udd39",bot:"\u22a5",bottom:"\u22a5",bowtie:"\u22c8",boxbox:"\u29c9",boxdl:"\u2510",boxdL:"\u2555",boxDl:"\u2556",boxDL:"\u2557",boxdr:"\u250c",boxdR:"\u2552",boxDr:"\u2553",boxDR:"\u2554",boxh:"\u2500",boxH:"\u2550",boxhd:"\u252c",boxhD:"\u2565",boxHd:"\u2564",boxHD:"\u2566",boxhu:"\u2534",boxhU:"\u2568",boxHu:"\u2567",boxHU:"\u2569",boxminus:"\u229f",boxplus:"\u229e",boxtimes:"\u22a0",boxul:"\u2518",boxuL:"\u255b",boxUl:"\u255c",boxUL:"\u255d",boxur:"\u2514",boxuR:"\u2558",boxUr:"\u2559",boxUR:"\u255a",boxv:"\u2502",boxV:"\u2551",boxvh:"\u253c",boxvH:"\u256a",boxVh:"\u256b",boxVH:"\u256c",boxvl:"\u2524",boxvL:"\u2561",boxVl:"\u2562",boxVL:"\u2563",boxvr:"\u251c",boxvR:"\u255e",boxVr:"\u255f",boxVR:"\u2560",bprime:"\u2035",breve:"\u02d8",Breve:"\u02d8",brvbar:"\xa6",bscr:"\ud835\udcb7",Bscr:"\u212c",bsemi:"\u204f",bsim:"\u223d",bsime:"\u22cd",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bump:"\u224e",bumpe:"\u224f",bumpE:"\u2aae",bumpeq:"\u224f",Bumpeq:"\u224e",cacute:"\u0107",Cacute:"\u0106",cap:"\u2229",Cap:"\u22d2",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",CapitalDifferentialD:"\u2145",caps:"\u2229\ufe00",caret:"\u2041",caron:"\u02c7",Cayleys:"\u212d",ccaps:"\u2a4d",ccaron:"\u010d",Ccaron:"\u010c",ccedil:"\xe7",Ccedil:"\xc7",ccirc:"\u0109",Ccirc:"\u0108",Cconint:"\u2230",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",Cdot:"\u010a",cedil:"\xb8",Cedilla:"\xb8",cemptyv:"\u29b2",cent:"\xa2",centerdot:"\xb7",CenterDot:"\xb7",cfr:"\ud835\udd20",Cfr:"\u212d",chcy:"\u0447",CHcy:"\u0427",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",Chi:"\u03a7",cir:"\u25cb",circ:"\u02c6",circeq:"\u2257",circlearrowleft:"\u21ba",circlearrowright:"\u21bb",circledast:"\u229b",circledcirc:"\u229a",circleddash:"\u229d",CircleDot:"\u2299",circledR:"\xae",circledS:"\u24c8",CircleMinus:"\u2296",CirclePlus:"\u2295",CircleTimes:"\u2297",cire:"\u2257",cirE:"\u29c3",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",ClockwiseContourIntegral:"\u2232",CloseCurlyDoubleQuote:"\u201d",CloseCurlyQuote:"\u2019",clubs:"\u2663",clubsuit:"\u2663",colon:":",Colon:"\u2237",colone:"\u2254",Colone:"\u2a74",coloneq:"\u2254",comma:",",commat:"@",comp:"\u2201",compfn:"\u2218",complement:"\u2201",complexes:"\u2102",cong:"\u2245",congdot:"\u2a6d",Congruent:"\u2261",conint:"\u222e",Conint:"\u222f",ContourIntegral:"\u222e",copf:"\ud835\udd54",Copf:"\u2102",coprod:"\u2210",Coproduct:"\u2210",copy:"\xa9",COPY:"\xa9",copysr:"\u2117",CounterClockwiseContourIntegral:"\u2233",crarr:"\u21b5",cross:"\u2717",Cross:"\u2a2f",cscr:"\ud835\udcb8",Cscr:"\ud835\udc9e",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",cuesc:"\u22df",cularr:"\u21b6",cularrp:"\u293d",cup:"\u222a",Cup:"\u22d3",cupbrcap:"\u2a48",cupcap:"\u2a46",CupCap:"\u224d",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curarrm:"\u293c",curlyeqprec:"\u22de",curlyeqsucc:"\u22df",curlyvee:"\u22ce",curlywedge:"\u22cf",curren:"\xa4",curvearrowleft:"\u21b6",curvearrowright:"\u21b7",cuvee:"\u22ce",cuwed:"\u22cf",cwconint:"\u2232",cwint:"\u2231",cylcty:"\u232d",dagger:"\u2020",Dagger:"\u2021",daleth:"\u2138",darr:"\u2193",dArr:"\u21d3",Darr:"\u21a1",dash:"\u2010",dashv:"\u22a3",Dashv:"\u2ae4",dbkarow:"\u290f",dblac:"\u02dd",dcaron:"\u010f",Dcaron:"\u010e",dcy:"\u0434",Dcy:"\u0414",dd:"\u2146",DD:"\u2145",ddagger:"\u2021",ddarr:"\u21ca",DDotrahd:"\u2911",ddotseq:"\u2a77",deg:"\xb0",Del:"\u2207",delta:"\u03b4",Delta:"\u0394",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",Dfr:"\ud835\udd07",dHar:"\u2965",dharl:"\u21c3",dharr:"\u21c2",DiacriticalAcute:"\xb4",DiacriticalDot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",DiacriticalGrave:"`",DiacriticalTilde:"\u02dc",diam:"\u22c4",diamond:"\u22c4",Diamond:"\u22c4",diamondsuit:"\u2666",diams:"\u2666",die:"\xa8",DifferentialD:"\u2146",digamma:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",DJcy:"\u0402",dlcorn:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",Dopf:"\ud835\udd3b",dot:"\u02d9",Dot:"\xa8",DotDot:"\u20dc",doteq:"\u2250",doteqdot:"\u2251",DotEqual:"\u2250",dotminus:"\u2238",dotplus:"\u2214",dotsquare:"\u22a1",doublebarwedge:"\u2306",DoubleContourIntegral:"\u222f",DoubleDot:"\xa8",DoubleDownArrow:"\u21d3",DoubleLeftArrow:"\u21d0",DoubleLeftRightArrow:"\u21d4",DoubleLeftTee:"\u2ae4",DoubleLongLeftArrow:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",DoubleLongRightArrow:"\u27f9",DoubleRightArrow:"\u21d2",DoubleRightTee:"\u22a8",DoubleUpArrow:"\u21d1",DoubleUpDownArrow:"\u21d5",DoubleVerticalBar:"\u2225",downarrow:"\u2193",Downarrow:"\u21d3",DownArrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",DownBreve:"\u0311",downdownarrows:"\u21ca",downharpoonleft:"\u21c3",downharpoonright:"\u21c2",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",DownTeeArrow:"\u21a7",drbkarow:"\u2910",drcorn:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",Dscr:"\ud835\udc9f",dscy:"\u0455",DScy:"\u0405",dsol:"\u29f6",dstrok:"\u0111",Dstrok:"\u0110",dtdot:"\u22f1",dtri:"\u25bf",dtrif:"\u25be",duarr:"\u21f5",duhar:"\u296f",dwangle:"\u29a6",dzcy:"\u045f",DZcy:"\u040f",dzigrarr:"\u27ff",eacute:"\xe9",Eacute:"\xc9",easter:"\u2a6e",ecaron:"\u011b",Ecaron:"\u011a",ecir:"\u2256",ecirc:"\xea",Ecirc:"\xca",ecolon:"\u2255",ecy:"\u044d",Ecy:"\u042d",eDDot:"\u2a77",edot:"\u0117",eDot:"\u2251",Edot:"\u0116",ee:"\u2147",efDot:"\u2252",efr:"\ud835\udd22",Efr:"\ud835\udd08",eg:"\u2a9a",egrave:"\xe8",Egrave:"\xc8",egs:"\u2a96",egsdot:"\u2a98",el:"\u2a99",Element:"\u2208",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",Emacr:"\u0112",empty:"\u2205",emptyset:"\u2205",EmptySmallSquare:"\u25fb",emptyv:"\u2205",EmptyVerySmallSquare:"\u25ab",emsp:"\u2003",emsp13:"\u2004",emsp14:"\u2005",eng:"\u014b",ENG:"\u014a",ensp:"\u2002",eogon:"\u0119",Eogon:"\u0118",eopf:"\ud835\udd56",Eopf:"\ud835\udd3c",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",Epsilon:"\u0395",epsiv:"\u03f5",eqcirc:"\u2256",eqcolon:"\u2255",eqsim:"\u2242",eqslantgtr:"\u2a96",eqslantless:"\u2a95",Equal:"\u2a75",equals:"=",EqualTilde:"\u2242",equest:"\u225f",Equilibrium:"\u21cc",equiv:"\u2261",equivDD:"\u2a78",eqvparsl:"\u29e5",erarr:"\u2971",erDot:"\u2253",escr:"\u212f",Escr:"\u2130",esdot:"\u2250",esim:"\u2242",Esim:"\u2a73",eta:"\u03b7",Eta:"\u0397",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",euro:"\u20ac",excl:"!",exist:"\u2203",Exists:"\u2203",expectation:"\u2130",exponentiale:"\u2147",ExponentialE:"\u2147",fallingdotseq:"\u2252",fcy:"\u0444",Fcy:"\u0424",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",Ffr:"\ud835\udd09",filig:"\ufb01",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",Fopf:"\ud835\udd3d",forall:"\u2200",ForAll:"\u2200",fork:"\u22d4",forkv:"\u2ad9",Fouriertrf:"\u2131",fpartint:"\u2a0d",frac12:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",fscr:"\ud835\udcbb",Fscr:"\u2131",gacute:"\u01f5",gamma:"\u03b3",Gamma:"\u0393",gammad:"\u03dd",Gammad:"\u03dc",gap:"\u2a86",gbreve:"\u011f",Gbreve:"\u011e",Gcedil:"\u0122",gcirc:"\u011d",Gcirc:"\u011c",gcy:"\u0433",Gcy:"\u0413",gdot:"\u0121",Gdot:"\u0120",ge:"\u2265",gE:"\u2267",gel:"\u22db",gEl:"\u2a8c",geq:"\u2265",geqq:"\u2267",geqslant:"\u2a7e",ges:"\u2a7e",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",Gfr:"\ud835\udd0a",gg:"\u226b",Gg:"\u22d9",ggg:"\u22d9",gimel:"\u2137",gjcy:"\u0453",GJcy:"\u0403",gl:"\u2277",gla:"\u2aa5",glE:"\u2a92",glj:"\u2aa4",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gnE:"\u2269",gneq:"\u2a88",gneqq:"\u2269",gnsim:"\u22e7",gopf:"\ud835\udd58",Gopf:"\ud835\udd3e",grave:"`",GreaterEqual:"\u2265",GreaterEqualLess:"\u22db",GreaterFullEqual:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",GreaterSlantEqual:"\u2a7e",GreaterTilde:"\u2273",gscr:"\u210a",Gscr:"\ud835\udca2",gsim:"\u2273",gsime:"\u2a8e",gsiml:"\u2a90",gt:">",Gt:"\u226b",GT:">",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrapprox:"\u2a86",gtrarr:"\u2978",gtrdot:"\u22d7",gtreqless:"\u22db",gtreqqless:"\u2a8c",gtrless:"\u2277",gtrsim:"\u2273",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",Hacek:"\u02c7",hairsp:"\u200a",half:"\xbd",hamilt:"\u210b",hardcy:"\u044a",HARDcy:"\u042a",harr:"\u2194",hArr:"\u21d4",harrcir:"\u2948",harrw:"\u21ad",Hat:"^",hbar:"\u210f",hcirc:"\u0125",Hcirc:"\u0124",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",Hfr:"\u210c",HilbertSpace:"\u210b",hksearow:"\u2925",hkswarow:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",hookrightarrow:"\u21aa",hopf:"\ud835\udd59",Hopf:"\u210d",horbar:"\u2015",HorizontalLine:"\u2500",hscr:"\ud835\udcbd",Hscr:"\u210b",hslash:"\u210f",hstrok:"\u0127",Hstrok:"\u0126",HumpDownHump:"\u224e",HumpEqual:"\u224f",hybull:"\u2043",hyphen:"\u2010",iacute:"\xed",Iacute:"\xcd",ic:"\u2063",icirc:"\xee",Icirc:"\xce",icy:"\u0438",Icy:"\u0418",Idot:"\u0130",iecy:"\u0435",IEcy:"\u0415",iexcl:"\xa1",iff:"\u21d4",ifr:"\ud835\udd26",Ifr:"\u2111",igrave:"\xec",Igrave:"\xcc",ii:"\u2148",iiiint:"\u2a0c",iiint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",IJlig:"\u0132",Im:"\u2111",imacr:"\u012b",Imacr:"\u012a",image:"\u2111",ImaginaryI:"\u2148",imagline:"\u2110",imagpart:"\u2111",imath:"\u0131",imof:"\u22b7",imped:"\u01b5",Implies:"\u21d2",in:"\u2208",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",inodot:"\u0131",int:"\u222b",Int:"\u222c",intcal:"\u22ba",integers:"\u2124",Integral:"\u222b",intercal:"\u22ba",Intersection:"\u22c2",intlarhk:"\u2a17",intprod:"\u2a3c",InvisibleComma:"\u2063",InvisibleTimes:"\u2062",iocy:"\u0451",IOcy:"\u0401",iogon:"\u012f",Iogon:"\u012e",iopf:"\ud835\udd5a",Iopf:"\ud835\udd40",iota:"\u03b9",Iota:"\u0399",iprod:"\u2a3c",iquest:"\xbf",iscr:"\ud835\udcbe",Iscr:"\u2110",isin:"\u2208",isindot:"\u22f5",isinE:"\u22f9",isins:"\u22f4",isinsv:"\u22f3",isinv:"\u2208",it:"\u2062",itilde:"\u0129",Itilde:"\u0128",iukcy:"\u0456",Iukcy:"\u0406",iuml:"\xef",Iuml:"\xcf",jcirc:"\u0135",Jcirc:"\u0134",jcy:"\u0439",Jcy:"\u0419",jfr:"\ud835\udd27",Jfr:"\ud835\udd0d",jmath:"\u0237",jopf:"\ud835\udd5b",Jopf:"\ud835\udd41",jscr:"\ud835\udcbf",Jscr:"\ud835\udca5",jsercy:"\u0458",Jsercy:"\u0408",jukcy:"\u0454",Jukcy:"\u0404",kappa:"\u03ba",Kappa:"\u039a",kappav:"\u03f0",kcedil:"\u0137",Kcedil:"\u0136",kcy:"\u043a",Kcy:"\u041a",kfr:"\ud835\udd28",Kfr:"\ud835\udd0e",kgreen:"\u0138",khcy:"\u0445",KHcy:"\u0425",kjcy:"\u045c",KJcy:"\u040c",kopf:"\ud835\udd5c",Kopf:"\ud835\udd42",kscr:"\ud835\udcc0",Kscr:"\ud835\udca6",lAarr:"\u21da",lacute:"\u013a",Lacute:"\u0139",laemptyv:"\u29b4",lagran:"\u2112",lambda:"\u03bb",Lambda:"\u039b",lang:"\u27e8",Lang:"\u27ea",langd:"\u2991",langle:"\u27e8",lap:"\u2a85",Laplacetrf:"\u2112",laquo:"\xab",larr:"\u2190",lArr:"\u21d0",Larr:"\u219e",larrb:"\u21e4",larrbfs:"\u291f",larrfs:"\u291d",larrhk:"\u21a9",larrlp:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",lat:"\u2aab",latail:"\u2919",lAtail:"\u291b",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lBarr:"\u290e",lbbrk:"\u2772",lbrace:"{",lbrack:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",Lcaron:"\u013d",lcedil:"\u013c",Lcedil:"\u013b",lceil:"\u2308",lcub:"{",lcy:"\u043b",Lcy:"\u041b",ldca:"\u2936",ldquo:"\u201c",ldquor:"\u201e",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",lE:"\u2266",LeftAngleBracket:"\u27e8",leftarrow:"\u2190",Leftarrow:"\u21d0",LeftArrow:"\u2190",LeftArrowBar:"\u21e4",LeftArrowRightArrow:"\u21c6",leftarrowtail:"\u21a2",LeftCeiling:"\u2308",LeftDoubleBracket:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",leftharpoondown:"\u21bd",leftharpoonup:"\u21bc",leftleftarrows:"\u21c7",leftrightarrow:"\u2194",Leftrightarrow:"\u21d4",LeftRightArrow:"\u2194",leftrightarrows:"\u21c6",leftrightharpoons:"\u21cb",leftrightsquigarrow:"\u21ad",LeftRightVector:"\u294e",LeftTee:"\u22a3",LeftTeeArrow:"\u21a4",LeftTeeVector:"\u295a",leftthreetimes:"\u22cb",LeftTriangle:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",LeftVectorBar:"\u2952",leg:"\u22da",lEg:"\u2a8b",leq:"\u2264",leqq:"\u2266",leqslant:"\u2a7d",les:"\u2a7d",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessapprox:"\u2a85",lessdot:"\u22d6",lesseqgtr:"\u22da",lesseqqgtr:"\u2a8b",LessEqualGreater:"\u22da",LessFullEqual:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",LessLess:"\u2aa1",lesssim:"\u2272",LessSlantEqual:"\u2a7d",LessTilde:"\u2272",lfisht:"\u297c",lfloor:"\u230a",lfr:"\ud835\udd29",Lfr:"\ud835\udd0f",lg:"\u2276",lgE:"\u2a91",lHar:"\u2962",lhard:"\u21bd",lharu:"\u21bc",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",LJcy:"\u0409",ll:"\u226a",Ll:"\u22d8",llarr:"\u21c7",llcorner:"\u231e",Lleftarrow:"\u21da",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",Lmidot:"\u013f",lmoust:"\u23b0",lmoustache:"\u23b0",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lnE:"\u2268",lneq:"\u2a87",lneqq:"\u2268",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",lobrk:"\u27e6",longleftarrow:"\u27f5",Longleftarrow:"\u27f8",LongLeftArrow:"\u27f5",longleftrightarrow:"\u27f7",Longleftrightarrow:"\u27fa",LongLeftRightArrow:"\u27f7",longmapsto:"\u27fc",longrightarrow:"\u27f6",Longrightarrow:"\u27f9",LongRightArrow:"\u27f6",looparrowleft:"\u21ab",looparrowright:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",Lopf:"\ud835\udd43",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",lowbar:"_",LowerLeftArrow:"\u2199",LowerRightArrow:"\u2198",loz:"\u25ca",lozenge:"\u25ca",lozf:"\u29eb",lpar:"(",lparlt:"\u2993",lrarr:"\u21c6",lrcorner:"\u231f",lrhar:"\u21cb",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",Lscr:"\u2112",lsh:"\u21b0",Lsh:"\u21b0",lsim:"\u2272",lsime:"\u2a8d",lsimg:"\u2a8f",lsqb:"[",lsquo:"\u2018",lsquor:"\u201a",lstrok:"\u0142",Lstrok:"\u0141",lt:"<",Lt:"\u226a",LT:"<",ltcc:"\u2aa6",ltcir:"\u2a79",ltdot:"\u22d6",lthree:"\u22cb",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltri:"\u25c3",ltrie:"\u22b4",ltrif:"\u25c2",ltrPar:"\u2996",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",macr:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",map:"\u21a6",Map:"\u2905",mapsto:"\u21a6",mapstodown:"\u21a7",mapstoleft:"\u21a4",mapstoup:"\u21a5",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",Mcy:"\u041c",mdash:"\u2014",mDDot:"\u223a",measuredangle:"\u2221",MediumSpace:"\u205f",Mellintrf:"\u2133",mfr:"\ud835\udd2a",Mfr:"\ud835\udd10",mho:"\u2127",micro:"\xb5",mid:"\u2223",midast:"*",midcir:"\u2af0",middot:"\xb7",minus:"\u2212",minusb:"\u229f",minusd:"\u2238",minusdu:"\u2a2a",MinusPlus:"\u2213",mlcp:"\u2adb",mldr:"\u2026",mnplus:"\u2213",models:"\u22a7",mopf:"\ud835\udd5e",Mopf:"\ud835\udd44",mp:"\u2213",mscr:"\ud835\udcc2",Mscr:"\u2133",mstpos:"\u223e",mu:"\u03bc",Mu:"\u039c",multimap:"\u22b8",mumap:"\u22b8",nabla:"\u2207",nacute:"\u0144",Nacute:"\u0143",nang:"\u2220\u20d2",nap:"\u2249",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",napprox:"\u2249",natur:"\u266e",natural:"\u266e",naturals:"\u2115",nbsp:"\xa0",nbump:"\u224e\u0338",nbumpe:"\u224f\u0338",ncap:"\u2a43",ncaron:"\u0148",Ncaron:"\u0147",ncedil:"\u0146",Ncedil:"\u0145",ncong:"\u2247",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",Ncy:"\u041d",ndash:"\u2013",ne:"\u2260",nearhk:"\u2924",nearr:"\u2197",neArr:"\u21d7",nearrow:"\u2197",nedot:"\u2250\u0338",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",nequiv:"\u2262",nesear:"\u2928",nesim:"\u2242\u0338",NestedGreaterGreater:"\u226b",NestedLessLess:"\u226a",NewLine:"\n",nexist:"\u2204",nexists:"\u2204",nfr:"\ud835\udd2b",Nfr:"\ud835\udd11",nge:"\u2271",ngE:"\u2267\u0338",ngeq:"\u2271",ngeqq:"\u2267\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",nGg:"\u22d9\u0338",ngsim:"\u2275",ngt:"\u226f",nGt:"\u226b\u20d2",ngtr:"\u226f",nGtv:"\u226b\u0338",nharr:"\u21ae",nhArr:"\u21ce",nhpar:"\u2af2",ni:"\u220b",nis:"\u22fc",nisd:"\u22fa",niv:"\u220b",njcy:"\u045a",NJcy:"\u040a",nlarr:"\u219a",nlArr:"\u21cd",nldr:"\u2025",nle:"\u2270",nlE:"\u2266\u0338",nleftarrow:"\u219a",nLeftarrow:"\u21cd",nleftrightarrow:"\u21ae",nLeftrightarrow:"\u21ce",nleq:"\u2270",nleqq:"\u2266\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",nless:"\u226e",nLl:"\u22d8\u0338",nlsim:"\u2274",nlt:"\u226e",nLt:"\u226a\u20d2",nltri:"\u22ea",nltrie:"\u22ec",nLtv:"\u226a\u0338",nmid:"\u2224",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nopf:"\ud835\udd5f",Nopf:"\u2115",not:"\xac",Not:"\u2aec",NotCongruent:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",NotElement:"\u2209",NotEqual:"\u2260",NotEqualTilde:"\u2242\u0338",NotExists:"\u2204",NotGreater:"\u226f",NotGreaterEqual:"\u2271",NotGreaterFullEqual:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",NotGreaterLess:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",NotGreaterTilde:"\u2275",NotHumpDownHump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",notin:"\u2209",notindot:"\u22f5\u0338",notinE:"\u22f9\u0338",notinva:"\u2209",notinvb:"\u22f7",notinvc:"\u22f6",NotLeftTriangle:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",NotLess:"\u226e",NotLessEqual:"\u2270",NotLessGreater:"\u2278",NotLessLess:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",NotLessTilde:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",notni:"\u220c",notniva:"\u220c",notnivb:"\u22fe",notnivc:"\u22fd",NotPrecedes:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",NotReverseElement:"\u220c",NotRightTriangle:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",NotSubset:"\u2282\u20d2",NotSubsetEqual:"\u2288",NotSucceeds:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",NotSupersetEqual:"\u2289",NotTilde:"\u2241",NotTildeEqual:"\u2244",NotTildeFullEqual:"\u2247",NotTildeTilde:"\u2249",NotVerticalBar:"\u2224",npar:"\u2226",nparallel:"\u2226",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",npr:"\u2280",nprcue:"\u22e0",npre:"\u2aaf\u0338",nprec:"\u2280",npreceq:"\u2aaf\u0338",nrarr:"\u219b",nrArr:"\u21cf",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nrightarrow:"\u219b",nRightarrow:"\u21cf",nrtri:"\u22eb",nrtrie:"\u22ed",nsc:"\u2281",nsccue:"\u22e1",nsce:"\u2ab0\u0338",nscr:"\ud835\udcc3",Nscr:"\ud835\udca9",nshortmid:"\u2224",nshortparallel:"\u2226",nsim:"\u2241",nsime:"\u2244",nsimeq:"\u2244",nsmid:"\u2224",nspar:"\u2226",nsqsube:"\u22e2",nsqsupe:"\u22e3",nsub:"\u2284",nsube:"\u2288",nsubE:"\u2ac5\u0338",nsubset:"\u2282\u20d2",nsubseteq:"\u2288",nsubseteqq:"\u2ac5\u0338",nsucc:"\u2281",nsucceq:"\u2ab0\u0338",nsup:"\u2285",nsupe:"\u2289",nsupE:"\u2ac6\u0338",nsupset:"\u2283\u20d2",nsupseteq:"\u2289",nsupseteqq:"\u2ac6\u0338",ntgl:"\u2279",ntilde:"\xf1",Ntilde:"\xd1",ntlg:"\u2278",ntriangleleft:"\u22ea",ntrianglelefteq:"\u22ec",ntriangleright:"\u22eb",ntrianglerighteq:"\u22ed",nu:"\u03bd",Nu:"\u039d",num:"#",numero:"\u2116",numsp:"\u2007",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvDash:"\u22ad",nVdash:"\u22ae",nVDash:"\u22af",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvHarr:"\u2904",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwarhk:"\u2923",nwarr:"\u2196",nwArr:"\u21d6",nwarrow:"\u2196",nwnear:"\u2927",oacute:"\xf3",Oacute:"\xd3",oast:"\u229b",ocir:"\u229a",ocirc:"\xf4",Ocirc:"\xd4",ocy:"\u043e",Ocy:"\u041e",odash:"\u229d",odblac:"\u0151",Odblac:"\u0150",odiv:"\u2a38",odot:"\u2299",odsold:"\u29bc",oelig:"\u0153",OElig:"\u0152",ofcir:"\u29bf",ofr:"\ud835\udd2c",Ofr:"\ud835\udd12",ogon:"\u02db",ograve:"\xf2",Ograve:"\xd2",ogt:"\u29c1",ohbar:"\u29b5",ohm:"\u03a9",oint:"\u222e",olarr:"\u21ba",olcir:"\u29be",olcross:"\u29bb",oline:"\u203e",olt:"\u29c0",omacr:"\u014d",Omacr:"\u014c",omega:"\u03c9",Omega:"\u03a9",omicron:"\u03bf",Omicron:"\u039f",omid:"\u29b6",ominus:"\u2296",oopf:"\ud835\udd60",Oopf:"\ud835\udd46",opar:"\u29b7",OpenCurlyDoubleQuote:"\u201c",OpenCurlyQuote:"\u2018",operp:"\u29b9",oplus:"\u2295",or:"\u2228",Or:"\u2a54",orarr:"\u21bb",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oS:"\u24c8",oscr:"\u2134",Oscr:"\ud835\udcaa",oslash:"\xf8",Oslash:"\xd8",osol:"\u2298",otilde:"\xf5",Otilde:"\xd5",otimes:"\u2297",Otimes:"\u2a37",otimesas:"\u2a36",ouml:"\xf6",Ouml:"\xd6",ovbar:"\u233d",OverBar:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",OverParenthesis:"\u23dc",par:"\u2225",para:"\xb6",parallel:"\u2225",parsim:"\u2af3",parsl:"\u2afd",part:"\u2202",PartialD:"\u2202",pcy:"\u043f",Pcy:"\u041f",percnt:"%",period:".",permil:"\u2030",perp:"\u22a5",pertenk:"\u2031",pfr:"\ud835\udd2d",Pfr:"\ud835\udd13",phi:"\u03c6",Phi:"\u03a6",phiv:"\u03d5",phmmat:"\u2133",phone:"\u260e",pi:"\u03c0",Pi:"\u03a0",pitchfork:"\u22d4",piv:"\u03d6",planck:"\u210f",planckh:"\u210e",plankv:"\u210f",plus:"+",plusacir:"\u2a23",plusb:"\u229e",pluscir:"\u2a22",plusdo:"\u2214",plusdu:"\u2a25",pluse:"\u2a72",PlusMinus:"\xb1",plusmn:"\xb1",plussim:"\u2a26",plustwo:"\u2a27",pm:"\xb1",Poincareplane:"\u210c",pointint:"\u2a15",popf:"\ud835\udd61",Popf:"\u2119",pound:"\xa3",pr:"\u227a",Pr:"\u2abb",prap:"\u2ab7",prcue:"\u227c",pre:"\u2aaf",prE:"\u2ab3",prec:"\u227a",precapprox:"\u2ab7",preccurlyeq:"\u227c",Precedes:"\u227a",PrecedesEqual:"\u2aaf",PrecedesSlantEqual:"\u227c",PrecedesTilde:"\u227e",preceq:"\u2aaf",precnapprox:"\u2ab9",precneqq:"\u2ab5",precnsim:"\u22e8",precsim:"\u227e",prime:"\u2032",Prime:"\u2033",primes:"\u2119",prnap:"\u2ab9",prnE:"\u2ab5",prnsim:"\u22e8",prod:"\u220f",Product:"\u220f",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prop:"\u221d",Proportion:"\u2237",Proportional:"\u221d",propto:"\u221d",prsim:"\u227e",prurel:"\u22b0",pscr:"\ud835\udcc5",Pscr:"\ud835\udcab",psi:"\u03c8",Psi:"\u03a8",puncsp:"\u2008",qfr:"\ud835\udd2e",Qfr:"\ud835\udd14",qint:"\u2a0c",qopf:"\ud835\udd62",Qopf:"\u211a",qprime:"\u2057",qscr:"\ud835\udcc6",Qscr:"\ud835\udcac",quaternions:"\u210d",quatint:"\u2a16",quest:"?",questeq:"\u225f",quot:'"',QUOT:'"',rAarr:"\u21db",race:"\u223d\u0331",racute:"\u0155",Racute:"\u0154",radic:"\u221a",raemptyv:"\u29b3",rang:"\u27e9",Rang:"\u27eb",rangd:"\u2992",range:"\u29a5",rangle:"\u27e9",raquo:"\xbb",rarr:"\u2192",rArr:"\u21d2",Rarr:"\u21a0",rarrap:"\u2975",rarrb:"\u21e5",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrhk:"\u21aa",rarrlp:"\u21ac",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",Rarrtl:"\u2916",rarrw:"\u219d",ratail:"\u291a",rAtail:"\u291c",ratio:"\u2236",rationals:"\u211a",rbarr:"\u290d",rBarr:"\u290f",RBarr:"\u2910",rbbrk:"\u2773",rbrace:"}",rbrack:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",Rcaron:"\u0158",rcedil:"\u0157",Rcedil:"\u0156",rceil:"\u2309",rcub:"}",rcy:"\u0440",Rcy:"\u0420",rdca:"\u2937",rdldhar:"\u2969",rdquo:"\u201d",rdquor:"\u201d",rdsh:"\u21b3",Re:"\u211c",real:"\u211c",realine:"\u211b",realpart:"\u211c",reals:"\u211d",rect:"\u25ad",reg:"\xae",REG:"\xae",ReverseElement:"\u220b",ReverseEquilibrium:"\u21cb",ReverseUpEquilibrium:"\u296f",rfisht:"\u297d",rfloor:"\u230b",rfr:"\ud835\udd2f",Rfr:"\u211c",rHar:"\u2964",rhard:"\u21c1",rharu:"\u21c0",rharul:"\u296c",rho:"\u03c1",Rho:"\u03a1",rhov:"\u03f1",RightAngleBracket:"\u27e9",rightarrow:"\u2192",Rightarrow:"\u21d2",RightArrow:"\u2192",RightArrowBar:"\u21e5",RightArrowLeftArrow:"\u21c4",rightarrowtail:"\u21a3",RightCeiling:"\u2309",RightDoubleBracket:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rightharpoondown:"\u21c1",rightharpoonup:"\u21c0",rightleftarrows:"\u21c4",rightleftharpoons:"\u21cc",rightrightarrows:"\u21c9",rightsquigarrow:"\u219d",RightTee:"\u22a2",RightTeeArrow:"\u21a6",RightTeeVector:"\u295b",rightthreetimes:"\u22cc",RightTriangle:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",RightVectorBar:"\u2953",ring:"\u02da",risingdotseq:"\u2253",rlarr:"\u21c4",rlhar:"\u21cc",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",robrk:"\u27e7",ropar:"\u2986",ropf:"\ud835\udd63",Ropf:"\u211d",roplus:"\u2a2e",rotimes:"\u2a35",RoundImplies:"\u2970",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rrarr:"\u21c9",Rrightarrow:"\u21db",rsaquo:"\u203a",rscr:"\ud835\udcc7",Rscr:"\u211b",rsh:"\u21b1",Rsh:"\u21b1",rsqb:"]",rsquo:"\u2019",rsquor:"\u2019",rthree:"\u22cc",rtimes:"\u22ca",rtri:"\u25b9",rtrie:"\u22b5",rtrif:"\u25b8",rtriltri:"\u29ce",RuleDelayed:"\u29f4",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",Sacute:"\u015a",sbquo:"\u201a",sc:"\u227b",Sc:"\u2abc",scap:"\u2ab8",scaron:"\u0161",Scaron:"\u0160",sccue:"\u227d",sce:"\u2ab0",scE:"\u2ab4",scedil:"\u015f",Scedil:"\u015e",scirc:"\u015d",Scirc:"\u015c",scnap:"\u2aba",scnE:"\u2ab6",scnsim:"\u22e9",scpolint:"\u2a13",scsim:"\u227f",scy:"\u0441",Scy:"\u0421",sdot:"\u22c5",sdotb:"\u22a1",sdote:"\u2a66",searhk:"\u2925",searr:"\u2198",seArr:"\u21d8",searrow:"\u2198",sect:"\xa7",semi:";",seswar:"\u2929",setminus:"\u2216",setmn:"\u2216",sext:"\u2736",sfr:"\ud835\udd30",Sfr:"\ud835\udd16",sfrown:"\u2322",sharp:"\u266f",shchcy:"\u0449",SHCHcy:"\u0429",shcy:"\u0448",SHcy:"\u0428",ShortDownArrow:"\u2193",ShortLeftArrow:"\u2190",shortmid:"\u2223",shortparallel:"\u2225",ShortRightArrow:"\u2192",ShortUpArrow:"\u2191",shy:"\xad",sigma:"\u03c3",Sigma:"\u03a3",sigmaf:"\u03c2",sigmav:"\u03c2",sim:"\u223c",simdot:"\u2a6a",sime:"\u2243",simeq:"\u2243",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",slarr:"\u2190",SmallCircle:"\u2218",smallsetminus:"\u2216",smashp:"\u2a33",smeparsl:"\u29e4",smid:"\u2223",smile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",SOFTcy:"\u042c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",Sopf:"\ud835\udd4a",spades:"\u2660",spadesuit:"\u2660",spar:"\u2225",sqcap:"\u2293",sqcaps:"\u2293\ufe00",sqcup:"\u2294",sqcups:"\u2294\ufe00",Sqrt:"\u221a",sqsub:"\u228f",sqsube:"\u2291",sqsubset:"\u228f",sqsubseteq:"\u2291",sqsup:"\u2290",sqsupe:"\u2292",sqsupset:"\u2290",sqsupseteq:"\u2292",squ:"\u25a1",square:"\u25a1",Square:"\u25a1",SquareIntersection:"\u2293",SquareSubset:"\u228f",SquareSubsetEqual:"\u2291",SquareSuperset:"\u2290",SquareSupersetEqual:"\u2292",SquareUnion:"\u2294",squarf:"\u25aa",squf:"\u25aa",srarr:"\u2192",sscr:"\ud835\udcc8",Sscr:"\ud835\udcae",ssetmn:"\u2216",ssmile:"\u2323",sstarf:"\u22c6",star:"\u2606",Star:"\u22c6",starf:"\u2605",straightepsilon:"\u03f5",straightphi:"\u03d5",strns:"\xaf",sub:"\u2282",Sub:"\u22d0",subdot:"\u2abd",sube:"\u2286",subE:"\u2ac5",subedot:"\u2ac3",submult:"\u2ac1",subne:"\u228a",subnE:"\u2acb",subplus:"\u2abf",subrarr:"\u2979",subset:"\u2282",Subset:"\u22d0",subseteq:"\u2286",subseteqq:"\u2ac5",SubsetEqual:"\u2286",subsetneq:"\u228a",subsetneqq:"\u2acb",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",succ:"\u227b",succapprox:"\u2ab8",succcurlyeq:"\u227d",Succeeds:"\u227b",SucceedsEqual:"\u2ab0",SucceedsSlantEqual:"\u227d",SucceedsTilde:"\u227f",succeq:"\u2ab0",succnapprox:"\u2aba",succneqq:"\u2ab6",succnsim:"\u22e9",succsim:"\u227f",SuchThat:"\u220b",sum:"\u2211",Sum:"\u2211",sung:"\u266a",sup:"\u2283",Sup:"\u22d1",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supdot:"\u2abe",supdsub:"\u2ad8",supe:"\u2287",supE:"\u2ac6",supedot:"\u2ac4",Superset:"\u2283",SupersetEqual:"\u2287",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supne:"\u228b",supnE:"\u2acc",supplus:"\u2ac0",supset:"\u2283",Supset:"\u22d1",supseteq:"\u2287",supseteqq:"\u2ac6",supsetneq:"\u228b",supsetneqq:"\u2acc",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swarhk:"\u2926",swarr:"\u2199",swArr:"\u21d9",swarrow:"\u2199",swnwar:"\u292a",szlig:"\xdf",Tab:"\t",target:"\u2316",tau:"\u03c4",Tau:"\u03a4",tbrk:"\u23b4",tcaron:"\u0165",Tcaron:"\u0164",tcedil:"\u0163",Tcedil:"\u0162",tcy:"\u0442",Tcy:"\u0422",tdot:"\u20db",telrec:"\u2315",tfr:"\ud835\udd31",Tfr:"\ud835\udd17",there4:"\u2234",therefore:"\u2234",Therefore:"\u2234",theta:"\u03b8",Theta:"\u0398",thetasym:"\u03d1",thetav:"\u03d1",thickapprox:"\u2248",thicksim:"\u223c",ThickSpace:"\u205f\u200a",thinsp:"\u2009",ThinSpace:"\u2009",thkap:"\u2248",thksim:"\u223c",thorn:"\xfe",THORN:"\xde",tilde:"\u02dc",Tilde:"\u223c",TildeEqual:"\u2243",TildeFullEqual:"\u2245",TildeTilde:"\u2248",times:"\xd7",timesb:"\u22a0",timesbar:"\u2a31",timesd:"\u2a30",tint:"\u222d",toea:"\u2928",top:"\u22a4",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",Topf:"\ud835\udd4b",topfork:"\u2ada",tosa:"\u2929",tprime:"\u2034",trade:"\u2122",TRADE:"\u2122",triangle:"\u25b5",triangledown:"\u25bf",triangleleft:"\u25c3",trianglelefteq:"\u22b4",triangleq:"\u225c",triangleright:"\u25b9",trianglerighteq:"\u22b5",tridot:"\u25ec",trie:"\u225c",triminus:"\u2a3a",TripleDot:"\u20db",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",Tscr:"\ud835\udcaf",tscy:"\u0446",TScy:"\u0426",tshcy:"\u045b",TSHcy:"\u040b",tstrok:"\u0167",Tstrok:"\u0166",twixt:"\u226c",twoheadleftarrow:"\u219e",twoheadrightarrow:"\u21a0",uacute:"\xfa",Uacute:"\xda",uarr:"\u2191",uArr:"\u21d1",Uarr:"\u219f",Uarrocir:"\u2949",ubrcy:"\u045e",Ubrcy:"\u040e",ubreve:"\u016d",Ubreve:"\u016c",ucirc:"\xfb",Ucirc:"\xdb",ucy:"\u0443",Ucy:"\u0423",udarr:"\u21c5",udblac:"\u0171",Udblac:"\u0170",udhar:"\u296e",ufisht:"\u297e",ufr:"\ud835\udd32",Ufr:"\ud835\udd18",ugrave:"\xf9",Ugrave:"\xd9",uHar:"\u2963",uharl:"\u21bf",uharr:"\u21be",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",Umacr:"\u016a",uml:"\xa8",UnderBar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",UnionPlus:"\u228e",uogon:"\u0173",Uogon:"\u0172",uopf:"\ud835\udd66",Uopf:"\ud835\udd4c",uparrow:"\u2191",Uparrow:"\u21d1",UpArrow:"\u2191",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",updownarrow:"\u2195",Updownarrow:"\u21d5",UpDownArrow:"\u2195",UpEquilibrium:"\u296e",upharpoonleft:"\u21bf",upharpoonright:"\u21be",uplus:"\u228e",UpperLeftArrow:"\u2196",UpperRightArrow:"\u2197",upsi:"\u03c5",Upsi:"\u03d2",upsih:"\u03d2",upsilon:"\u03c5",Upsilon:"\u03a5",UpTee:"\u22a5",UpTeeArrow:"\u21a5",upuparrows:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",Uring:"\u016e",urtri:"\u25f9",uscr:"\ud835\udcca",Uscr:"\ud835\udcb0",utdot:"\u22f0",utilde:"\u0169",Utilde:"\u0168",utri:"\u25b5",utrif:"\u25b4",uuarr:"\u21c8",uuml:"\xfc",Uuml:"\xdc",uwangle:"\u29a7",vangrt:"\u299c",varepsilon:"\u03f5",varkappa:"\u03f0",varnothing:"\u2205",varphi:"\u03d5",varpi:"\u03d6",varpropto:"\u221d",varr:"\u2195",vArr:"\u21d5",varrho:"\u03f1",varsigma:"\u03c2",varsubsetneq:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vartheta:"\u03d1",vartriangleleft:"\u22b2",vartriangleright:"\u22b3",vBar:"\u2ae8",Vbar:"\u2aeb",vBarv:"\u2ae9",vcy:"\u0432",Vcy:"\u0412",vdash:"\u22a2",vDash:"\u22a8",Vdash:"\u22a9",VDash:"\u22ab",Vdashl:"\u2ae6",vee:"\u2228",Vee:"\u22c1",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",verbar:"|",Verbar:"\u2016",vert:"|",Vert:"\u2016",VerticalBar:"\u2223",VerticalLine:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",VeryThinSpace:"\u200a",vfr:"\ud835\udd33",Vfr:"\ud835\udd19",vltri:"\u22b2",vnsub:"\u2282\u20d2",vnsup:"\u2283\u20d2",vopf:"\ud835\udd67",Vopf:"\ud835\udd4d",vprop:"\u221d",vrtri:"\u22b3",vscr:"\ud835\udccb",Vscr:"\ud835\udcb1",vsubne:"\u228a\ufe00",vsubnE:"\u2acb\ufe00",vsupne:"\u228b\ufe00",vsupnE:"\u2acc\ufe00",Vvdash:"\u22aa",vzigzag:"\u299a",wcirc:"\u0175",Wcirc:"\u0174",wedbar:"\u2a5f",wedge:"\u2227",Wedge:"\u22c0",wedgeq:"\u2259",weierp:"\u2118",wfr:"\ud835\udd34",Wfr:"\ud835\udd1a",wopf:"\ud835\udd68",Wopf:"\ud835\udd4e",wp:"\u2118",wr:"\u2240",wreath:"\u2240",wscr:"\ud835\udccc",Wscr:"\ud835\udcb2",xcap:"\u22c2",xcirc:"\u25ef",xcup:"\u22c3",xdtri:"\u25bd",xfr:"\ud835\udd35",Xfr:"\ud835\udd1b",xharr:"\u27f7",xhArr:"\u27fa",xi:"\u03be",Xi:"\u039e",xlarr:"\u27f5",xlArr:"\u27f8",xmap:"\u27fc",xnis:"\u22fb",xodot:"\u2a00",xopf:"\ud835\udd69",Xopf:"\ud835\udd4f",xoplus:"\u2a01",xotime:"\u2a02",xrarr:"\u27f6",xrArr:"\u27f9",xscr:"\ud835\udccd",Xscr:"\ud835\udcb3",xsqcup:"\u2a06",xuplus:"\u2a04",xutri:"\u25b3",xvee:"\u22c1",xwedge:"\u22c0",yacute:"\xfd",Yacute:"\xdd",yacy:"\u044f",YAcy:"\u042f",ycirc:"\u0177",Ycirc:"\u0176",ycy:"\u044b",Ycy:"\u042b",yen:"\xa5",yfr:"\ud835\udd36",Yfr:"\ud835\udd1c",yicy:"\u0457",YIcy:"\u0407",yopf:"\ud835\udd6a",Yopf:"\ud835\udd50",yscr:"\ud835\udcce",Yscr:"\ud835\udcb4",yucy:"\u044e",YUcy:"\u042e",yuml:"\xff",Yuml:"\u0178",zacute:"\u017a",Zacute:"\u0179",zcaron:"\u017e",Zcaron:"\u017d",zcy:"\u0437",Zcy:"\u0417",zdot:"\u017c",Zdot:"\u017b",zeetrf:"\u2128",ZeroWidthSpace:"\u200b",zeta:"\u03b6",Zeta:"\u0396",zfr:"\ud835\udd37",Zfr:"\u2128",zhcy:"\u0436",ZHcy:"\u0416",zigrarr:"\u21dd",zopf:"\ud835\udd6b",Zopf:"\u2124",zscr:"\ud835\udccf",Zscr:"\ud835\udcb5",zwj:"\u200d",zwnj:"\u200c"},h={aacute:"\xe1",Aacute:"\xc1",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",aelig:"\xe6",AElig:"\xc6",agrave:"\xe0",Agrave:"\xc0",amp:"&",AMP:"&",aring:"\xe5",Aring:"\xc5",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",brvbar:"\xa6",ccedil:"\xe7",Ccedil:"\xc7",cedil:"\xb8",cent:"\xa2",copy:"\xa9",COPY:"\xa9",curren:"\xa4",deg:"\xb0",divide:"\xf7",eacute:"\xe9",Eacute:"\xc9",ecirc:"\xea",Ecirc:"\xca",egrave:"\xe8",Egrave:"\xc8",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",frac12:"\xbd",frac14:"\xbc",frac34:"\xbe",gt:">",GT:">",iacute:"\xed",Iacute:"\xcd",icirc:"\xee",Icirc:"\xce",iexcl:"\xa1",igrave:"\xec",Igrave:"\xcc",iquest:"\xbf",iuml:"\xef",Iuml:"\xcf",laquo:"\xab",lt:"<",LT:"<",macr:"\xaf",micro:"\xb5",middot:"\xb7",nbsp:"\xa0",not:"\xac",ntilde:"\xf1",Ntilde:"\xd1",oacute:"\xf3",Oacute:"\xd3",ocirc:"\xf4",Ocirc:"\xd4",ograve:"\xf2",Ograve:"\xd2",ordf:"\xaa",ordm:"\xba",oslash:"\xf8",Oslash:"\xd8",otilde:"\xf5",Otilde:"\xd5",ouml:"\xf6",Ouml:"\xd6",para:"\xb6",plusmn:"\xb1",pound:"\xa3",quot:'"',QUOT:'"',raquo:"\xbb",reg:"\xae",REG:"\xae",sect:"\xa7",shy:"\xad",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",szlig:"\xdf",thorn:"\xfe",THORN:"\xde",times:"\xd7",uacute:"\xfa",Uacute:"\xda",ucirc:"\xfb",Ucirc:"\xdb",ugrave:"\xf9",Ugrave:"\xd9",uml:"\xa8",uuml:"\xfc",Uuml:"\xdc",yacute:"\xfd",Yacute:"\xdd",yen:"\xa5",yuml:"\xff"},v={0:"\ufffd",128:"\u20ac",130:"\u201a",131:"\u0192",132:"\u201e",133:"\u2026",134:"\u2020",135:"\u2021",136:"\u02c6",137:"\u2030",138:"\u0160",139:"\u2039",140:"\u0152",142:"\u017d",145:"\u2018",146:"\u2019",147:"\u201c",148:"\u201d",149:"\u2022",150:"\u2013",151:"\u2014",152:"\u02dc",153:"\u2122",154:"\u0161",155:"\u203a",156:"\u0153",158:"\u017e",159:"\u0178"},g=[1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65e3,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111],b=String.fromCharCode,y={}.hasOwnProperty,w=function(e,r){return y.call(e,r)},A=function(e,r){if(!e)return r;var t,n={};for(t in r)n[t]=w(e,t)?e[t]:r[t];return n},D=function(e,r){var t="";return e>=55296&&e<=57343||e>1114111?(r&&k("character reference outside the permissible Unicode range"),"\ufffd"):w(v,e)?(r&&k("disallowed character reference"),v[e]):(r&&function(e,r){for(var t=-1,n=e.length;++t<n;)if(e[t]==r)return!0;return!1}(g,e)&&k("disallowed character reference"),e>65535&&(t+=b((e-=65536)>>>10&1023|55296),e=56320|1023&e),t+=b(e))},x=function(e){return"&#x"+e.toString(16).toUpperCase()+";"},q=function(e){return"&#"+e+";"},k=function(e){throw Error("Parse error: "+e)},E=function(e,r){(r=A(r,E.options)).strict&&f.test(e)&&k("forbidden code point");var t=r.encodeEverything,n=r.useNamedReferences,l=r.allowUnsafeSymbols,p=r.decimal?q:x,d=function(e){return p(e.charCodeAt(0))};return t?(e=e.replace(o,function(e){return n&&w(c,e)?"&"+c[e]+";":d(e)}),n&&(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;").replace(/&#x66;&#x6A;/g,"&fjlig;")),n&&(e=e.replace(s,function(e){return"&"+c[e]+";"}))):n?(l||(e=e.replace(u,function(e){return"&"+c[e]+";"})),e=(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;")).replace(s,function(e){return"&"+c[e]+";"})):l||(e=e.replace(u,d)),e.replace(a,function(e){var r=e.charCodeAt(0),t=e.charCodeAt(1);return p(1024*(r-55296)+t-56320+65536)}).replace(i,d)};E.options={allowUnsafeSymbols:!1,encodeEverything:!1,strict:!1,useNamedReferences:!1,decimal:!1};var _=function(e,r){var t=(r=A(r,_.options)).strict;return t&&p.test(e)&&k("malformed character reference"),e.replace(d,function(e,n,a,o,i,s,c,u,l){var p,f,d,v,g,b;return n?m[g=n]:a?(g=a,(b=o)&&r.isAttributeValue?(t&&"="==b&&k("`&` did not start a character reference"),e):(t&&k("named character reference was not terminated by a semicolon"),h[g]+(b||""))):i?(d=i,f=s,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(d,10),D(p,t)):c?(v=c,f=u,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(v,16),D(p,t)):(t&&k("named character reference was not terminated by a semicolon"),e)})};_.options={isAttributeValue:!1,strict:!1};var C={version:"1.2.0",encode:E,decode:_,escape:function(e){return e.replace(u,function(e){return l[e]})},unescape:_};if("function"==typeof define&&"object"==typeof define.amd&&define.amd)define(function(){return C});else if(r&&!r.nodeType)if(t)t.exports=C;else for(var S in C)w(C,S)&&(r[S]=C[S]);else e.he=C}(void 0);var yo=f("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),wo=f("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Ao=f("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Do=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,qo="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+U.source+"]*",ko="((?:"+qo+"\\:)?"+qo+")",Eo=new RegExp("^<"+ko),_o=/^\s*(\/?)>/,Co=new RegExp("^<\\/"+ko+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,Lo=/^<!\--/,To=/^<!\[/,$o=f("script,style,textarea",!0),No={},Oo={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ro=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Bo=f("pre,textarea",!0),Uo=function(e,r){return e&&Bo(e)&&"\n"===r[0]};function Vo(e,r){var t=r?Fo:Ro;return e.replace(t,function(e){return Oo[e]})}var Io,jo,Po,Ho,Mo,Go,zo,Jo,Ko=/^@|^v-on:/,Zo=/^v-|^@|^:|^#/,Yo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Wo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,Xo=/^\[.*\]$/,ei=/:(.*)$/,ri=/^:|^\.|^v-bind:/,ti=/\.[^.\]]+(?=[^\]]*$)/g,ni=/^v-slot(:|$)|^#/,ai=/[\r\n]/,oi=/[ \f\t\r\n]+/g,ii=b(void 0),si="_empty_";function ci(e,r,t){return{type:1,tag:e,attrsList:r,attrsMap:hi(r),rawAttrsMap:{},parent:t,children:[]}}function ui(e,r){Io=r.warn||Sn,Go=r.isPreTag||S,zo=r.mustUseProp||S,Jo=r.getTagNamespace||S;r.isReservedTag;Po=Ln(r.modules,"transformNode"),Ho=Ln(r.modules,"preTransformNode"),Mo=Ln(r.modules,"postTransformNode"),jo=r.delimiters;var t,n,a=[],o=!1!==r.preserveWhitespace,i=r.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=li(e,r)),a.length||e===t||t.if&&(e.elseif||e.else)&&fi(t,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)i=e,(u=function(e){var r=e.length;for(;r--;){if(1===e[r].type)return e[r];e.pop()}}(n.children))&&u.if&&fi(u,{exp:i.elseif,block:i});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var i,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Go(e.tag)&&(c=!1);for(var p=0;p<Mo.length;p++)Mo[p](e,r)}function l(e){if(!c)for(var r;(r=e.children[e.children.length-1])&&3===r.type&&" "===r.text;)e.children.pop()}return function(e,r){for(var t,n,a=[],o=r.expectHTML,i=r.isUnaryTag||S,s=r.canBeLeftOpenTag||S,c=0;e;){if(t=e,n&&$o(n)){var u=0,l=n.toLowerCase(),p=No[l]||(No[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),f=e.replace(p,function(e,t,n){return u=n.length,$o(l)||"noscript"===l||(t=t.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Uo(l,t)&&(t=t.slice(1)),r.chars&&r.chars(t),""});c+=e.length-f.length,e=f,E(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(Lo.test(e)){var m=e.indexOf("--\x3e");if(m>=0){r.shouldKeepComment&&r.comment(e.substring(4,m),c,c+m+3),x(m+3);continue}}if(To.test(e)){var h=e.indexOf("]>");if(h>=0){x(h+2);continue}}var v=e.match(So);if(v){x(v[0].length);continue}var g=e.match(Co);if(g){var b=c;x(g[0].length),E(g[1],b,c);continue}var y=q();if(y){k(y),Uo(y.tagName,e)&&x(1);continue}}var w=void 0,A=void 0,D=void 0;if(d>=0){for(A=e.slice(d);!(Co.test(A)||Eo.test(A)||Lo.test(A)||To.test(A)||(D=A.indexOf("<",1))<0);)d+=D,A=e.slice(d);w=e.substring(0,d)}d<0&&(w=e),w&&x(w.length),r.chars&&w&&r.chars(w,c-w.length,c)}if(e===t){r.chars&&r.chars(e);break}}function x(r){c+=r,e=e.substring(r)}function q(){var r=e.match(Eo);if(r){var t,n,a={tagName:r[1],attrs:[],start:c};for(x(r[0].length);!(t=e.match(_o))&&(n=e.match(xo)||e.match(Do));)n.start=c,x(n[0].length),n.end=c,a.attrs.push(n);if(t)return a.unarySlash=t[1],x(t[0].length),a.end=c,a}}function k(e){var t=e.tagName,c=e.unarySlash;o&&("p"===n&&Ao(t)&&E(n),s(t)&&n===t&&E(t));for(var u=i(t)||!!c,l=e.attrs.length,p=new Array(l),f=0;f<l;f++){var d=e.attrs[f],m=d[3]||d[4]||d[5]||"",h="a"===t&&"href"===d[1]?r.shouldDecodeNewlinesForHref:r.shouldDecodeNewlines;p[f]={name:d[1],value:Vo(m,h)}}u||(a.push({tag:t,lowerCasedTag:t.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=t),r.start&&r.start(t,p,u,e.start,e.end)}function E(e,t,o){var i,s;if(null==t&&(t=c),null==o&&(o=c),e)for(s=e.toLowerCase(),i=a.length-1;i>=0&&a[i].lowerCasedTag!==s;i--);else i=0;if(i>=0){for(var u=a.length-1;u>=i;u--)r.end&&r.end(a[u].tag,t,o);a.length=i,n=i&&a[i-1].tag}else"br"===s?r.start&&r.start(e,[],!0,t,o):"p"===s&&(r.start&&r.start(e,[],!1,t,o),r.end&&r.end(e,t,o))}E()}(e,{warn:Io,expectHTML:r.expectHTML,isUnaryTag:r.isUnaryTag,canBeLeftOpenTag:r.canBeLeftOpenTag,shouldDecodeNewlines:r.shouldDecodeNewlines,shouldDecodeNewlinesForHref:r.shouldDecodeNewlinesForHref,shouldKeepComment:r.comments,outputSourceRange:r.outputSourceRange,start:function(e,o,i,l,p){var f=n&&n.ns||Jo(e);J&&"svg"===f&&(o=function(e){for(var r=[],t=0;t<e.length;t++){var n=e[t];vi.test(n.name)||(n.name=n.name.replace(gi,""),r.push(n))}return r}(o));var d,m=ci(e,o,n);f&&(m.ns=f),"style"!==(d=m).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||re()||(m.forbidden=!0);for(var h=0;h<Ho.length;h++)m=Ho[h](m,r)||m;s||(!function(e){null!=Un(e,"v-pre")&&(e.pre=!0)}(m),m.pre&&(s=!0)),Go(m.tag)&&(c=!0),s?function(e){var r=e.attrsList,t=r.length;if(t)for(var n=e.attrs=new Array(t),a=0;a<t;a++)n[a]={name:r[a].name,value:JSON.stringify(r[a].value)},null!=r[a].start&&(n[a].start=r[a].start,n[a].end=r[a].end);else e.pre||(e.plain=!0)}(m):m.processed||(pi(m),function(e){var r=Un(e,"v-if");if(r)e.if=r,fi(e,{exp:r,block:e});else{null!=Un(e,"v-else")&&(e.else=!0);var t=Un(e,"v-else-if");t&&(e.elseif=t)}}(m),function(e){null!=Un(e,"v-once")&&(e.once=!0)}(m)),t||(t=m),i?u(m):(n=m,a.push(m))},end:function(e,r,t){var o=a[a.length-1];a.length-=1,n=a[a.length-1],u(o)},chars:function(e,r,t){if(n&&(!J||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var a,u,l,p=n.children;if(e=c||e.trim()?"script"===(a=n).tag||"style"===a.tag?e:ii(e):p.length?i?"condense"===i&&ai.test(e)?"":" ":o?" ":"":"")c||"condense"!==i||(e=e.replace(oi," ")),!s&&" "!==e&&(u=function(e,r){var t=r?vo(r):mo;if(t.test(e)){for(var n,a,o,i=[],s=[],c=t.lastIndex=0;n=t.exec(e);){(a=n.index)>c&&(s.push(o=e.slice(c,a)),i.push(JSON.stringify(o)));var u=_n(n[1].trim());i.push("_s("+u+")"),s.push({"@binding":u}),c=a+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),i.push(JSON.stringify(o))),{expression:i.join("+"),tokens:s}}}(e,jo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&p.length&&" "===p[p.length-1].text||(l={type:3,text:e}),l&&p.push(l)}},comment:function(e,r,t){if(n){var a={type:3,text:e,isComment:!0};n.children.push(a)}}}),t}function li(e,r){var t,n;(n=Bn(t=e,"key"))&&(t.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var r=Bn(e,"ref");r&&(e.ref=r,e.refInFor=function(e){var r=e;for(;r;){if(void 0!==r.for)return!0;r=r.parent}return!1}(e))}(e),function(e){var r;"template"===e.tag?(r=Un(e,"scope"),e.slotScope=r||Un(e,"slot-scope")):(r=Un(e,"slot-scope"))&&(e.slotScope=r);var t=Bn(e,"slot");t&&(e.slotTarget='""'===t?'"default"':t,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||$n(e,"slot",t,function(e,r){return e.rawAttrsMap[":"+r]||e.rawAttrsMap["v-bind:"+r]||e.rawAttrsMap[r]}(e,"slot")));if("template"===e.tag){var n=Vn(e,ni);if(n){var a=di(n),o=a.name,i=a.dynamic;e.slotTarget=o,e.slotTargetDynamic=i,e.slotScope=n.value||si}}else{var s=Vn(e,ni);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=di(s),l=u.name,p=u.dynamic,f=c[l]=ci("template",[],e);f.slotTarget=l,f.slotTargetDynamic=p,f.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=f,!0}),f.slotScope=s.value||si,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Bn(e,"name"))}(e),function(e){var r;(r=Bn(e,"is"))&&(e.component=r);null!=Un(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var a=0;a<Po.length;a++)e=Po[a](e,r)||e;return function(e){var r,t,n,a,o,i,s,c,u=e.attrsList;for(r=0,t=u.length;r<t;r++)if(n=a=u[r].name,o=u[r].value,Zo.test(n))if(e.hasBindings=!0,(i=mi(n.replace(Zo,"")))&&(n=n.replace(ti,"")),ri.test(n))n=n.replace(ri,""),o=_n(o),(c=Xo.test(n))&&(n=n.slice(1,-1)),i&&(i.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),i.camel&&!c&&(n=w(n)),i.sync&&(s=Pn(o,"$event"),c?Fn(e,'"update:"+('+n+")",s,null,!1,0,u[r],!0):(Fn(e,"update:"+w(n),s,null,!1,0,u[r]),x(n)!==w(n)&&Fn(e,"update:"+x(n),s,null,!1,0,u[r])))),i&&i.prop||!e.component&&zo(e.tag,e.attrsMap.type,n)?Tn(e,n,o,u[r],c):$n(e,n,o,u[r],c);else if(Ko.test(n))n=n.replace(Ko,""),(c=Xo.test(n))&&(n=n.slice(1,-1)),Fn(e,n,o,i,!1,0,u[r],c);else{var l=(n=n.replace(Zo,"")).match(ei),p=l&&l[1];c=!1,p&&(n=n.slice(0,-(p.length+1)),Xo.test(p)&&(p=p.slice(1,-1),c=!0)),On(e,n,a,o,p,c,i,u[r])}else $n(e,n,JSON.stringify(o),u[r]),!e.component&&"muted"===n&&zo(e.tag,e.attrsMap.type,n)&&Tn(e,n,"true",u[r])}(e),e}function pi(e){var r;if(r=Un(e,"v-for")){var t=function(e){var r=e.match(Yo);if(!r)return;var t={};t.for=r[2].trim();var n=r[1].trim().replace(Qo,""),a=n.match(Wo);a?(t.alias=n.replace(Wo,"").trim(),t.iterator1=a[1].trim(),a[2]&&(t.iterator2=a[2].trim())):t.alias=n;return t}(r);t&&E(e,t)}}function fi(e,r){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(r)}function di(e){var r=e.name.replace(ni,"");return r||"#"!==e.name[0]&&(r="default"),Xo.test(r)?{name:r.slice(1,-1),dynamic:!0}:{name:'"'+r+'"',dynamic:!1}}function mi(e){var r=e.match(ti);if(r){var t={};return r.forEach(function(e){t[e.slice(1)]=!0}),t}}function hi(e){for(var r={},t=0,n=e.length;t<n;t++)r[e[t].name]=e[t].value;return r}var vi=/^xmlns:NS\d+/,gi=/^NS\d+:/;function bi(e){return ci(e.tag,e.attrsList.slice(),e.parent)}var yi=[go,bo,{preTransformNode:function(e,r){if("input"===e.tag){var t,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(t=Bn(e,"type")),n.type||t||!n["v-bind"]||(t="("+n["v-bind"]+").type"),t){var a=Un(e,"v-if",!0),o=a?"&&("+a+")":"",i=null!=Un(e,"v-else",!0),s=Un(e,"v-else-if",!0),c=bi(e);pi(c),Nn(c,"type","checkbox"),li(c,r),c.processed=!0,c.if="("+t+")==='checkbox'"+o,fi(c,{exp:c.if,block:c});var u=bi(e);Un(u,"v-for",!0),Nn(u,"type","radio"),li(u,r),fi(c,{exp:"("+t+")==='radio'"+o,block:u});var l=bi(e);return Un(l,"v-for",!0),Nn(l,":type",t),li(l,r),fi(c,{exp:a,block:l}),i?c.else=!0:s&&(c.elseif=s),c}}}}];var wi,Ai,Di={expectHTML:!0,modules:yi,directives:{model:function(e,r,t){var n=r.value,a=r.modifiers,o=e.tag,i=e.attrsMap.type;if(e.component)return jn(e,n,a),!1;if("select"===o)!function(e,r,t){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(t&&t.number?"_n(val)":"val")+"});";n=n+" "+Pn(r,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Fn(e,"change",n,null,!0)}(e,n,a);else if("input"===o&&"checkbox"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null",o=Bn(e,"true-value")||"true",i=Bn(e,"false-value")||"false";Tn(e,"checked","Array.isArray("+r+")?_i("+r+","+a+")>-1"+("true"===o?":("+r+")":":_q("+r+","+o+")")),Fn(e,"change","var $$a="+r+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+i+");if(Array.isArray($$a)){var $$v="+(n?"_n("+a+")":a)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pn(r,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pn(r,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pn(r,"$$c")+"}",null,!0)}(e,n,a);else if("input"===o&&"radio"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null";Tn(e,"checked","_q("+r+","+(a=n?"_n("+a+")":a)+")"),Fn(e,"change",Pn(r,a),null,!0)}(e,n,a);else if("input"===o||"textarea"===o)!function(e,r,t){var n=e.attrsMap.type,a=t||{},o=a.lazy,i=a.number,s=a.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Zn:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),i&&(l="_n("+l+")");var p=Pn(r,l);c&&(p="if($event.target.composing)return;"+p),Tn(e,"value","("+r+")"),Fn(e,u,p,null,!0),(s||i)&&Fn(e,"blur","$forceUpdate()")}(e,n,a);else if(!B.isReservedTag(o))return jn(e,n,a),!1;return!0},text:function(e,r){r.value&&Tn(e,"textContent","_s("+r.value+")",r)},html:function(e,r){r.value&&Tn(e,"innerHTML","_s("+r.value+")",r)}},isPreTag:function(e){return"pre"===e},isUnaryTag:yo,mustUseProp:$t,canBeLeftOpenTag:wo,isReservedTag:Kt,getTagNamespace:Zt,staticKeys:function(e){return e.reduce(function(e,r){return e.concat(r.staticKeys||[])},[]).join(",")}(yi)},xi=b(function(e){return f("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function qi(e,r){e&&(wi=xi(r.staticKeys||""),Ai=r.isReservedTag||S,function e(r){r.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Ai(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(wi)))}(r);if(1===r.type){if(!Ai(r.tag)&&"slot"!==r.tag&&null==r.attrsMap["inline-template"])return;for(var t=0,n=r.children.length;t<n;t++){var a=r.children[t];e(a),a.static||(r.static=!1)}if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++){var s=r.ifConditions[o].block;e(s),s.static||(r.static=!1)}}}(e),function e(r,t){if(1===r.type){if((r.static||r.once)&&(r.staticInFor=t),r.static&&r.children.length&&(1!==r.children.length||3!==r.children[0].type))return void(r.staticRoot=!0);if(r.staticRoot=!1,r.children)for(var n=0,a=r.children.length;n<a;n++)e(r.children[n],t||!!r.for);if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++)e(r.ifConditions[o].block,t)}}(e,!1))}var ki=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ei=/\([^)]*?\);*$/,_i=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Si={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Li=function(e){return"if("+e+")return null;"},Ti={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Li("$event.target !== $event.currentTarget"),ctrl:Li("!$event.ctrlKey"),shift:Li("!$event.shiftKey"),alt:Li("!$event.altKey"),meta:Li("!$event.metaKey"),left:Li("'button' in $event && $event.button !== 0"),middle:Li("'button' in $event && $event.button !== 1"),right:Li("'button' in $event && $event.button !== 2")};function $i(e,r){var t=r?"nativeOn:":"on:",n="",a="";for(var o in e){var i=Ni(e[o]);e[o]&&e[o].dynamic?a+=o+","+i+",":n+='"'+o+'":'+i+","}return n="{"+n.slice(0,-1)+"}",a?t+"_d("+n+",["+a.slice(0,-1)+"])":t+n}function Ni(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Ni(e)}).join(",")+"]";var r=_i.test(e.value),t=ki.test(e.value),n=_i.test(e.value.replace(Ei,""));if(e.modifiers){var a="",o="",i=[];for(var s in e.modifiers)if(Ti[s])o+=Ti[s],Ci[s]&&i.push(s);else if("exact"===s){var c=e.modifiers;o+=Li(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else i.push(s);return i.length&&(a+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Oi).join("&&")+")return null;"}(i)),o&&(a+=o),"function($event){"+a+(r?"return "+e.value+".apply(null, arguments)":t?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return r||t?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function Oi(e){var r=parseInt(e,10);if(r)return"$event.keyCode!=="+r;var t=Ci[e],n=Si[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(t)+",$event.key,"+JSON.stringify(n)+")"}var Ri={on:function(e,r){e.wrapListeners=function(e){return"_g("+e+","+r.value+")"}},bind:function(e,r){e.wrapData=function(t){return"_b("+t+",'"+e.tag+"',"+r.value+","+(r.modifiers&&r.modifiers.prop?"true":"false")+(r.modifiers&&r.modifiers.sync?",true":"")+")"}},cloak:C},Fi=function(e){this.options=e,this.warn=e.warn||Sn,this.transforms=Ln(e.modules,"transformCode"),this.dataGenFns=Ln(e.modules,"genData"),this.directives=E(E({},Ri),e.directives);var r=e.isReservedTag||S;this.maybeComponent=function(e){return!!e.component||!r(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Bi(e,r){var t=new Fi(r);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ui(e,t):'_c("div")')+"}",staticRenderFns:t.staticRenderFns}}function Ui(e,r){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Vi(e,r);if(e.once&&!e.onceProcessed)return Ii(e,r);if(e.for&&!e.forProcessed)return Pi(e,r);if(e.if&&!e.ifProcessed)return ji(e,r);if("template"!==e.tag||e.slotTarget||r.pre){if("slot"===e.tag)return function(e,r){var t=e.slotName||'"default"',n=zi(e,r),a="_t("+t+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Zi((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,i=e.attrsMap["v-bind"];!o&&!i||n||(a+=",null");o&&(a+=","+o);i&&(a+=(o?"":",null")+","+i);return a+")"}(e,r);var t;if(e.component)t=function(e,r,t){var n=r.inlineTemplate?null:zi(r,t,!0);return"_c("+e+","+Hi(r,t)+(n?","+n:"")+")"}(e.component,e,r);else{var n;(!e.plain||e.pre&&r.maybeComponent(e))&&(n=Hi(e,r));var a=e.inlineTemplate?null:zi(e,r,!0);t="_c('"+e.tag+"'"+(n?","+n:"")+(a?","+a:"")+")"}for(var o=0;o<r.transforms.length;o++)t=r.transforms[o](e,t);return t}return zi(e,r)||"void 0"}function Vi(e,r){e.staticProcessed=!0;var t=r.pre;return e.pre&&(r.pre=e.pre),r.staticRenderFns.push("with(this){return "+Ui(e,r)+"}"),r.pre=t,"_m("+(r.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ii(e,r){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ji(e,r);if(e.staticInFor){for(var t="",n=e.parent;n;){if(n.for){t=n.key;break}n=n.parent}return t?"_o("+Ui(e,r)+","+r.onceId+++","+t+")":Ui(e,r)}return Vi(e,r)}function ji(e,r,t,n){return e.ifProcessed=!0,function e(r,t,n,a){if(!r.length)return a||"_e()";var o=r.shift();return o.exp?"("+o.exp+")?"+i(o.block)+":"+e(r,t,n,a):""+i(o.block);function i(e){return n?n(e,t):e.once?Ii(e,t):Ui(e,t)}}(e.ifConditions.slice(),r,t,n)}function Pi(e,r,t,n){var a=e.for,o=e.alias,i=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+a+"),function("+o+i+s+"){return "+(t||Ui)(e,r)+"})"}function Hi(e,r){var t="{",n=function(e,r){var t=e.directives;if(!t)return;var n,a,o,i,s="directives:[",c=!1;for(n=0,a=t.length;n<a;n++){o=t[n],i=!0;var u=r.directives[o.name];u&&(i=!!u(e,o,r.warn)),i&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,r);n&&(t+=n+","),e.key&&(t+="key:"+e.key+","),e.ref&&(t+="ref:"+e.ref+","),e.refInFor&&(t+="refInFor:true,"),e.pre&&(t+="pre:true,"),e.component&&(t+='tag:"'+e.tag+'",');for(var a=0;a<r.dataGenFns.length;a++)t+=r.dataGenFns[a](e);if(e.attrs&&(t+="attrs:"+Zi(e.attrs)+","),e.props&&(t+="domProps:"+Zi(e.props)+","),e.events&&(t+=$i(e.events,!1)+","),e.nativeEvents&&(t+=$i(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(t+="slot:"+e.slotTarget+","),e.scopedSlots&&(t+=function(e,r,t){var n=e.for||Object.keys(r).some(function(e){var t=r[e];return t.slotTargetDynamic||t.if||t.for||Mi(t)}),a=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==si||o.for){n=!0;break}o.if&&(a=!0),o=o.parent}var i=Object.keys(r).map(function(e){return Gi(r[e],t)}).join(",");return"scopedSlots:_u(["+i+"]"+(n?",null,true":"")+(!n&&a?",null,false,"+function(e){var r=5381,t=e.length;for(;t;)r=33*r^e.charCodeAt(--t);return r>>>0}(i):"")+")"}(e,e.scopedSlots,r)+","),e.model&&(t+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,r){var t=e.children[0];if(t&&1===t.type){var n=Bi(t,r.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,r);o&&(t+=o+",")}return t=t.replace(/,$/,"")+"}",e.dynamicAttrs&&(t="_b("+t+',"'+e.tag+'",'+Zi(e.dynamicAttrs)+")"),e.wrapData&&(t=e.wrapData(t)),e.wrapListeners&&(t=e.wrapListeners(t)),t}function Mi(e){return 1===e.type&&("slot"===e.tag||e.children.some(Mi))}function Gi(e,r){var t=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!t)return ji(e,r,Gi,"null");if(e.for&&!e.forProcessed)return Pi(e,r,Gi);var n=e.slotScope===si?"":String(e.slotScope),a="function("+n+"){return "+("template"===e.tag?e.if&&t?"("+e.if+")?"+(zi(e,r)||"undefined")+":undefined":zi(e,r)||"undefined":Ui(e,r))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+a+o+"}"}function zi(e,r,t,n,a){var o=e.children;if(o.length){var i=o[0];if(1===o.length&&i.for&&"template"!==i.tag&&"slot"!==i.tag){var s=t?r.maybeComponent(i)?",1":",0":"";return""+(n||Ui)(i,r)+s}var c=t?function(e,r){for(var t=0,n=0;n<e.length;n++){var a=e[n];if(1===a.type){if(Ji(a)||a.ifConditions&&a.ifConditions.some(function(e){return Ji(e.block)})){t=2;break}(r(a)||a.ifConditions&&a.ifConditions.some(function(e){return r(e.block)}))&&(t=1)}}return t}(o,r.maybeComponent):0,u=a||Ki;return"["+o.map(function(e){return u(e,r)}).join(",")+"]"+(c?","+c:"")}}function Ji(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Ki(e,r){return 1===e.type?Ui(e,r):3===e.type&&e.isComment?(n=e,"_e("+JSON.stringify(n.text)+")"):"_v("+(2===(t=e).type?t.expression:Yi(JSON.stringify(t.text)))+")";var t,n}function Zi(e){for(var r="",t="",n=0;n<e.length;n++){var a=e[n],o=Yi(a.value);a.dynamic?t+=a.name+","+o+",":r+='"'+a.name+'":'+o+","}return r="{"+r.slice(0,-1)+"}",t?"_d("+r+",["+t.slice(0,-1)+"])":r}function Yi(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Wi(e,r){try{return new Function(e)}catch(t){return r.push({err:t,code:e}),C}}function Qi(e){var r=Object.create(null);return function(t,n,a){(n=E({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+t:t;if(r[o])return r[o];var i=e(t,n),s={},c=[];return s.render=Wi(i.render,c),s.staticRenderFns=i.staticRenderFns.map(function(e){return Wi(e,c)}),r[o]=s}}var Xi,es,rs=(Xi=function(e,r){var t=ui(e.trim(),r);!1!==r.optimize&&qi(t,r);var n=Bi(t,r);return{ast:t,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function r(r,t){var n=Object.create(e),a=[],o=[];if(t)for(var i in t.modules&&(n.modules=(e.modules||[]).concat(t.modules)),t.directives&&(n.directives=E(Object.create(e.directives||null),t.directives)),t)"modules"!==i&&"directives"!==i&&(n[i]=t[i]);n.warn=function(e,r,t){(t?o:a).push(e)};var s=Xi(r.trim(),n);return s.errors=a,s.tips=o,s}return{compile:r,compileToFunctions:Qi(r)}})(Di),ts=(rs.compile,rs.compileToFunctions);function ns(e){return(es=es||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',es.innerHTML.indexOf("&#10;")>0}var as=!!H&&ns(!1),os=!!H&&ns(!0),is=b(function(e){var r=Qt(e);return r&&r.innerHTML}),ss=Dt.prototype.$mount;return Dt.prototype.$mount=function(e,r){if((e=e&&Qt(e))===document.body||e===document.documentElement)return this;var t=this.$options;if(!t.render){var n=t.template;if(n)if("string"==typeof n)"#"===n.charAt(0)&&(n=is(n));else{if(!n.nodeType)return this;n=n.innerHTML}else e&&(n=function(e){if(e.outerHTML)return e.outerHTML;var r=document.createElement("div");return r.appendChild(e.cloneNode(!0)),r.innerHTML}(e));if(n){var a=ts(n,{outputSourceRange:!1,shouldDecodeNewlines:as,shouldDecodeNewlinesForHref:os,delimiters:t.delimiters,comments:t.comments},this),o=a.render,i=a.staticRenderFns;t.render=o,t.staticRenderFns=i}}return ss.call(this,e,r)},Dt.compile=ts,Dt});
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index adc90e4dddb..f737ade77ae 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -1,193 +1,159 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
 'use strict';
 
-/*  */
-
+/* @flow */
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
-function isRegExp (v) {
-  return _toString.call(v) === '[object RegExp]'
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Capitalize a string.
  */
 var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -195,1104 +161,977 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
-function toArray (list, start) {
-  start = start || 0;
-  var i = list.length - start;
-  var ret = new Array(i);
-  while (i--) {
-    ret[i] = list[i + start];
-  }
-  return ret
+function toArray(list, start) {
+    start = start || 0;
+    var i = list.length - start;
+    var ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
 }
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
+function looseEqual(a, b) {
+    if (a === b)
+        { return true; }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every(function (e, i) {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every(function (key) {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (var i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            { return i; }
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
+function once(fn) {
+    var called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
 var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: "development" !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: "development" !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Check if a string starts with $ or _
  */
-function isReserved (str) {
-  var c = (str + '').charCodeAt(0);
-  return c === 0x24 || c === 0x5F
+function isReserved(str) {
+    var c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
 }
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
-
 /**
  * Parse simple path.
  */
 var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-function parsePath (path) {
-  if (bailRE.test(path)) {
-    return
-  }
-  var segments = path.split('.');
-  return function (obj) {
-    for (var i = 0; i < segments.length; i++) {
-      if (!obj) { return }
-      obj = obj[segments[i]];
-    }
-    return obj
-  }
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    var segments = path.split('.');
+    return function (obj) {
+        for (var i = 0; i < segments.length; i++) {
+            if (!obj)
+                { return; }
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 var isPhantomJS = UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
-
+// @ts-ignore
+var nativeWatch = {}.watch;
 var supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-        /* istanbul ignore next */
-        supportsPassive = true;
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/(function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function has (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function add (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function clear () {
+            this.set = Object.create(null);
+        };
 
-    return Set;
-  }());
+        return Set;
+    }());
 }
 
-/*  */
-
+/* @flow */
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace);
-    } else if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
+    };
+    var repeat = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
+                    .join('\n'));
+        }
+        else {
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+        }
+    };
 }
 
-/*  */
-
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
 };
-
 Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
+    this.subs.push(sub);
 };
-
 Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
+    remove(this.subs, sub);
 };
-
 Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
+    if (Dep.target) {
+        Dep.target.addDep(this);
+    }
 };
-
 Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (!config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (!config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
 };
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
-}
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
-}
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
+}
+
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
 };
 
 var prototypeAccessors = { child: { configurable: true } };
-
 // DEPRECATED: alias for componentInstance for backwards compat.
 /* istanbul ignore next */
 prototypeAccessors.child.get = function () {
-  return this.componentInstance
+    return this.componentInstance;
 };
 
 Object.defineProperties( VNode.prototype, prototypeAccessors );
-
 var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
+    if ( text === void 0 ) text = '';
 
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    var cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
+        }
+        else {
+            copyAugment(value, arrayMethods, arrayKeys);
+        }
+        this.observeArray(value);
+    }
+    else {
+        this.walk(value);
+    }
 };
-
 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive$$1(obj, keys[i]);
+    }
 };
-
 /**
  * Observe a list of Array items.
  */
 Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
 };
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Delete a property and trigger change if necessary.
  */
-function del (target, key) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1);
-    return
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    );
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key];
-  if (!ob) {
-    return
-  }
-  ob.dep.notify();
+function del(target, key) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    var ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1300,609 +1139,540 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && "development" !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (var key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    var props = options.props;
+    if (!props)
+        { return; }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (var key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn("Invalid value for option \"props\": expected an Array or an Object, " +
+            "but got " + (toRawType(props)) + ".", vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    var inject = options.inject;
+    if (!inject)
+        { return; }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (var i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (var key in inject) {
+            var val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+            "but got " + (toRawType(inject)) + ".", vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
+function normalizeDirectives(options) {
+    var dirs = options.directives;
+    if (dirs) {
+        for (var key in dirs) {
+            var def$$1 = dirs[key];
+            if (typeof def$$1 === 'function') {
+                dirs[key] = { bind: def$$1, update: def$$1 };
+            }
+        }
     }
-  }
 }
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            "but got " + (toRawType(value)) + ".", vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        var strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        { return assets[id]; }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        { return assets[camelizedId]; }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        { return assets[PascalCaseId]; }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+/* @flow */
+function validateProp(key, propOptions, propsData, vm) {
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            var stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        var prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        var t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid: valid,
+        expectedType: expectedType,
+    };
 }
-
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
+function getType(fn) {
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
 }
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
+function isSameType(a, b) {
+    return getType(a) === getType(b);
 }
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
     }
-  }
-  return -1
+    return -1;
 }
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  var expectedValue = styleValue(value, expectedType);
-  var receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += " with value " + expectedValue;
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + receivedValue + ".";
-  }
-  return message
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += " with value " + (styleValue(value, expectedType));
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += "with value " + (styleValue(value, receivedType)) + ".";
+    }
+    return message;
 }
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
+function styleValue(value, type) {
+    if (type === 'String') {
+        return ("\"" + value + "\"");
+    }
+    else if (type === 'Number') {
+        return ("" + (Number(value)));
+    }
+    else {
+        return ("" + value);
+    }
 }
-
-function isExplicable (value) {
-  var explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
+function isBoolean() {
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            var cur = vm;
+            while ((cur = cur.$parent)) {
+                var hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (var i = 0; i < hooks.length; i++) {
+                        try {
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                { return; }
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
             }
-          }
         }
-      }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
-}
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
 }
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    var res;
     try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler');
-      }
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
     }
-  }
-  logError(err, vm, info);
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
 }
-
-function logError (err, vm, info) {
-  {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/*  */
-
+/* @flow */
 var isUsingMicroTask = false;
-
 var callbacks = [];
 var pending = false;
-
-function flushCallbacks () {
-  pending = false;
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    pending = false;
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // Here we have async deferring wrappers using microtasks.
 // In 2.5 we used (macro) tasks (in combination with microtasks).
 // However, it has subtle problems when state is changed right before repaint
@@ -1915,7 +1685,6 @@ function flushCallbacks () {
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
 var timerFunc;
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1924,2299 +1693,2010 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  var p = Promise.resolve();
-  timerFunc = function () {
-    p.then(flushCallbacks);
-    // In problematic UIWebViews, Promise.then doesn't completely break, but
-    // it can get stuck in a weird state where callbacks are pushed into the
-    // microtask queue but the queue isn't being flushed, until the browser
-    // needs to do some other work, e.g. handle a timer. Therefore we can
-    // "force" the microtask queue to be flushed by adding an empty timer.
-    if (isIOS) { setTimeout(noop); }
-  };
-  isUsingMicroTask = true;
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-  timerFunc = function () {
-    counter = (counter + 1) % 2;
-    textNode.data = String(counter);
-  };
-  isUsingMicroTask = true;
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Technically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = function () {
-    setImmediate(flushCallbacks);
-  };
-} else {
-  // Fallback to setTimeout.
-  timerFunc = function () {
-    setTimeout(flushCallbacks, 0);
-  };
+    var p = Promise.resolve();
+    timerFunc = function () {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            { setTimeout(noop); }
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = function () {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = function () {
+        setImmediate(flushCallbacks);
+    };
 }
-
-function nextTick (cb, ctx) {
-  var _resolve;
-  callbacks.push(function () {
-    if (cb) {
-      try {
-        cb.call(ctx);
-      } catch (e) {
-        handleError(e, ctx, 'nextTick');
-      }
-    } else if (_resolve) {
-      _resolve(ctx);
-    }
-  });
-  if (!pending) {
-    pending = true;
-    timerFunc();
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(function (resolve) {
-      _resolve = resolve;
-    })
-  }
+else {
+    // Fallback to setTimeout.
+    timerFunc = function () {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    var _resolve;
+    callbacks.push(function () {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise(function (resolve) {
+            _resolve = resolve;
+        });
+    }
 }
 
-/*  */
+/* @flow */
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 var initProxy;
-
 {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var warnNonPresent = function (target, key) {
-    warn(
-      "Property or method \"" + key + "\" is not defined on the instance but " +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
-    );
-  };
-
-  var warnReservedPrefix = function (target, key) {
-    warn(
-      "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
     );
-  };
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
-
-  var hasHandler = {
-    has: function has (target, key) {
-      var has = key in target;
-      var isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-      if (!has && !isAllowed) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return has || !isAllowed
-    }
-  };
-
-  var getHandler = {
-    get: function get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return target[key]
-    }
-  };
-
-  initProxy = function initProxy (vm) {
+    var warnNonPresent = function (target, key) {
+        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    var warnReservedPrefix = function (target, key) {
+        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-      // determine which proxy handler to use
-      var options = vm.$options;
-      var handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler;
-      vm._renderProxy = new Proxy(vm, handlers);
-    } else {
-      vm._renderProxy = vm;
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
     }
-  };
+    var hasHandler = {
+        has: function has(target, key) {
+            var has = key in target;
+            var isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return has || !isAllowed;
+        },
+    };
+    var getHandler = {
+        get: function get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            var options = vm.$options;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-/*  */
-
+/* @flow */
 var seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    var i, keys;
+    var isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        var depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            { _traverse(val[i], seen); }
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            { _traverse(val[keys[i]], seen); }
+    }
 }
 
 var mark;
 var measure;
-
 {
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = function (tag) { return perf.mark(tag); };
-    measure = function (name, startTag, endTag) {
-      perf.measure(name, startTag, endTag);
-      perf.clearMarks(startTag);
-      perf.clearMarks(endTag);
-      // perf.clearMeasures(name)
-    };
-  }
+    var perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
+        measure = function (name, startTag, endTag) {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-/*  */
-
 var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+    var passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once$$1 ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name: name,
+        once: once$$1,
+        capture: capture,
+        passive: passive,
+    };
 });
-
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        var arguments$1 = arguments;
+
+        var fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+    var name, def$$1, cur, old, event;
+    for (name in on) {
+        def$$1 = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove$$1(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-/*  */
-
-function mergeVNodeHook (def, hookKey, hook) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {});
-  }
-  var invoker;
-  var oldHook = def[hookKey];
-
-  function wrappedHook () {
-    hook.apply(this, arguments);
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook);
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook]);
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook;
-      invoker.fns.push(wrappedHook);
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook]);
-    }
-  }
-
-  invoker.merged = true;
-  def[hookKey] = invoker;
+/* @flow */
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    var invoker;
+    var oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
+/* @flow */
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    var res = {};
+    var attrs = data.attrs;
+    var props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
+            {
+                var keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
 }
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-/*  */
-
+/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (var i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
-
-function initProvide (vm) {
-  var provide = vm.$options.provide;
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide;
-  }
-}
-
-function initInjections (vm) {
-  var result = resolveInject(vm.$options.inject, vm);
-  if (result) {
-    toggleObserving(false);
-    Object.keys(result).forEach(function (key) {
-      /* istanbul ignore else */
-      {
-        defineReactive$$1(vm, key, result[key], function () {
-          warn(
-            "Avoid mutating an injected value directly since the changes will be " +
-            "overwritten whenever the provided component re-renders. " +
-            "injection being mutated: \"" + key + "\"",
-            vm
-          );
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            { continue; }
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
+}
+
+/* @flow */
+function initProvide(vm) {
+    var provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    var result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach(function (key) {
+            /* istanbul ignore else */
+            {
+                defineReactive$$1(vm, key, result[key], function () {
+                    warn("Avoid mutating an injected value directly since the changes will be " +
+                        "overwritten whenever the provided component re-renders. " +
+                        "injection being mutated: \"" + key + "\"", vm);
+                });
+            }
         });
-      }
-    });
-    toggleObserving(true);
-  }
-}
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
-        }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else {
-          warn(("Injection \"" + key + "\" not found"), vm);
-        }
-      }
-    }
-    return result
-  }
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                { continue; }
+            var provideKey = inject[key].from;
+            var source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    var provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    // @ts-ignore
+                    warn(("Injection \"" + key + "\" not found"), vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/*  */
-
-
-
+/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+/* @flow */
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return function () { return slots[key]; };
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    var ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (!isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+/* @flow */
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn('v-bind without argument expects an Object or Array value', this);
         }
-      };
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            var hash;
+            var loop = function ( key ) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    var type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        var on = data.on || (data.on = {});
+                        on[("update:" + key)] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            };
 
-      for (var key in value) loop( key );
+            for (var key in value) loop( key );
+        }
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, ("__static__" + index), false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
-}
-
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
-    }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+function markOnce(tree, index, key) {
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (var i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
 }
-
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
+/* @flow */
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+/* @flow */
+function bindDynamicKeys(baseObj, values) {
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+/* @flow */
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+/* @flow */
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    var this$1 = this;
 
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
     }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        }
+        return this$1.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get: function get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = function (a, b, c, d) {
+            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
-
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (var key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            { mergeProps(props, data.attrs); }
+        if (isDef(data.props))
+            { mergeProps(props, data.props); }
+    }
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
     }
-    return res
-  }
 }
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
 }
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
+function mergeProps(to, from) {
+    for (var key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-/*  */
+/* @flow */
 
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init: function init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            var mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch: function prepatch(oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy: function destroy(vnode) {
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
+        }
+        return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
     }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        var slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
     }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent // activeInstance in lifecycle state
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
+    // @ts-expect-error
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    var options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+        }
     }
-  }
 }
-
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function mergeHook$1(f1, f2) {
+    var merged = function (a, b) {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
+function transformModel(options, data) {
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-/*  */
-
+/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (isDef(data) && isDef(data.nativeOn)) {
-        warn(
-          ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-          context
-        );
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      );
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === 'string') {
+        var Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            { applyNS(vnode, ns); }
+        if (isDef(data))
+            { registerDeepBindings(data); }
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
-}
-
-/*  */
-
-function initRender (vm) {
-  vm._vnode = null; // the root of the child tree
-  vm._staticTrees = null; // v-once cached trees
-  var options = vm.$options;
-  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-  var renderContext = parentVnode && parentVnode.context;
-  vm.$slots = resolveSlots(options._renderChildren, renderContext);
-  vm.$scopedSlots = emptyObject;
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  var parentData = parentVnode && parentVnode.data;
-
-  /* istanbul ignore else */
-  {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-    }, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-    }, true);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
+}
+
+/* @flow */
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    var parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        }, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        }, true);
+    }
 }
-
 var currentRenderingInstance = null;
-
-function renderMixin (Vue) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype);
-
-  Vue.prototype.$nextTick = function (fn) {
-    return nextTick(fn, this)
-  };
-
-  Vue.prototype._render = function () {
-    var vm = this;
-    var ref = vm.$options;
-    var render = ref.render;
-    var _parentVnode = ref._parentVnode;
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      );
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode;
-    // render self
-    var vnode;
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm;
-      vnode = render.call(vm._renderProxy, vm.$createElement);
-    } catch (e) {
-      handleError(e, vm, "render");
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (vm.$options.renderError) {
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        var vm = this;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        var vnode;
         try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-        } catch (e) {
-          handleError(e, vm, "renderError");
-          vnode = vm._vnode;
-        }
-      } else {
-        vnode = vm._vnode;
-      }
-    } finally {
-      currentRenderingInstance = null;
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0];
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        );
-      }
-      vnode = createEmptyVNode();
-    }
-    // set parent
-    vnode.parent = _parentVnode;
-    return vnode
-  };
-}
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
         }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
+        catch (e) {
+            handleError(e, vm, "render");
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, "renderError");
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
         }
-      }
-    };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+        finally {
+            currentRenderingInstance = null;
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                "timeout (" + (res.timeout) + "ms)"
-              );
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
             }
-          }, res.timeout);
+            vnode = createEmptyVNode();
         }
-      }
-    }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-/*  */
-
-function getFirstComponentChild (children) {
-  if (Array.isArray(children)) {
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
+/* @flow */
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
     }
-  }
+    return isObject(comp) ? base.extend(comp) : comp;
 }
-
-/*  */
-
-/*  */
-
-function initEvents (vm) {
-  vm._events = Object.create(null);
-  vm._hasHookEvent = false;
-  // init parent attached events
-  var listeners = vm.$options._parentListeners;
-  if (listeners) {
-    updateComponentListeners(vm, listeners);
-  }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    return node;
 }
-
-var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    var owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        var resolve = once(function (res) {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        var reject = once(function (reason) {
+            warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject("timeout (" + (res.timeout) + "ms)");
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function remove$1 (event, fn) {
-  target.$off(event, fn);
+/* @flow */
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
+/* @flow */
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+            var c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
     }
-  }
-}
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
 }
 
-function eventsMixin (Vue) {
-  var hookRE = /^hook:/;
-  Vue.prototype.$on = function (event, fn) {
-    var vm = this;
-    if (Array.isArray(event)) {
-      for (var i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn);
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn);
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true;
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$once = function (event, fn) {
-    var vm = this;
-    function on () {
-      vm.$off(event, on);
-      fn.apply(vm, arguments);
-    }
-    on.fn = fn;
-    vm.$on(event, on);
-    return vm
-  };
-
-  Vue.prototype.$off = function (event, fn) {
-    var vm = this;
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null);
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-        vm.$off(event[i$1], fn);
-      }
-      return vm
-    }
-    // specific event
-    var cbs = vm._events[event];
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null;
-      return vm
-    }
-    // specific handler
-    var cb;
-    var i = cbs.length;
-    while (i--) {
-      cb = cbs[i];
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1);
-        break
-      }
-    }
-    return vm
-  };
+/* @flow */
 
-  Vue.prototype.$emit = function (event) {
-    var vm = this;
-    {
-      var lowerCaseEvent = event.toLowerCase();
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-          "Note that HTML attributes are case-insensitive and you cannot use " +
-          "v-on to listen to camelCase events when using in-DOM templates. " +
-          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-        );
-      }
+/* @flow */
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    var listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
     }
-    var cbs = vm._events[event];
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-      var args = toArray(arguments, 1);
-      var info = "event handler for \"" + event + "\"";
-      for (var i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-      }
-    }
-    return vm
-  };
+}
+var target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    var _target = target;
+    return function onceHandler() {
+        var res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    target = undefined;
+}
+function eventsMixin(Vue) {
+    var hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        var vm = this;
+        if (Array.isArray(event)) {
+            for (var i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        var vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        var vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
+            }
+            return vm;
+        }
+        // specific event
+        var cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        var cb;
+        var i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        var vm = this;
+        {
+            var lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    "Note that HTML attributes are case-insensitive and you cannot use " +
+                    "v-on to listen to camelCase events when using in-DOM templates. " +
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+            }
+        }
+        var cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            var args = toArray(arguments, 1);
+            var info = "event handler for \"" + event + "\"";
+            for (var i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-/*  */
-
+/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
-
 function setActiveInstance(vm) {
-  var prevActiveInstance = activeInstance;
-  activeInstance = vm;
-  return function () {
-    activeInstance = prevActiveInstance;
-  }
+    var prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return function () {
+        activeInstance = prevActiveInstance;
+    };
 }
-
-function initLifecycle (vm) {
-  var options = vm.$options;
-
-  // locate first non-abstract parent
-  var parent = options.parent;
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
-    }
-    parent.$children.push(vm);
-  }
-
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
-
-  vm.$children = [];
-  vm.$refs = {};
-
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
+function initLifecycle(vm) {
+    var options = vm.$options;
+    // locate first non-abstract parent
+    var parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        var vm = this;
+        var prevEl = vm.$el;
+        var prevVnode = vm._vnode;
+        var restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        var vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        var vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook(vm, 'beforeDestroy');
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        var parent = vm.$parent;
+        // @ts-ignore
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        var i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook(vm, 'destroyed');
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            // @ts-expect-error null is not undefined
+            vm.$vnode.parent = null;
+        }
+    };
 }
-
-function lifecycleMixin (Vue) {
-  Vue.prototype._update = function (vnode, hydrating) {
-    var vm = this;
-    var prevEl = vm.$el;
-    var prevVnode = vm._vnode;
-    var restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
-    }
-    restoreActiveInstance();
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null;
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm;
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  };
-
-  Vue.prototype.$forceUpdate = function () {
-    var vm = this;
-    if (vm._watcher) {
-      vm._watcher.update();
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                vm.$options.el ||
+                el) {
+                warn('You are using the runtime-only build of Vue where the template ' +
+                    'compiler is not available. Either pre-compile the templates into ' +
+                    'render functions, or use the compiler-included build.', vm);
+            }
+            else {
+                warn('Failed to mount component: template or render function not defined.', vm);
+            }
+        }
     }
-  };
-
-  Vue.prototype.$destroy = function () {
-    var vm = this;
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy');
-    vm._isBeingDestroyed = true;
-    // remove self from parent
-    var parent = vm.$parent;
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
-    }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown();
-    }
-    var i = vm._watchers.length;
-    while (i--) {
-      vm._watchers[i].teardown();
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
-    }
-    // call the last hook...
-    vm._isDestroyed = true;
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
-    // fire destroyed hook
-    callHook(vm, 'destroyed');
-    // turn off all instance listeners.
-    vm.$off();
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null;
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null;
-    }
-  };
-}
-
-function mountComponent (
-  vm,
-  el,
-  hydrating
-) {
-  vm.$el = el;
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode;
+    callHook(vm, 'beforeMount');
+    var updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+        updateComponent = function () {
+            var name = vm._name;
+            var id = vm._uid;
+            var startTag = "vue-perf-start:" + id;
+            var endTag = "vue-perf-end:" + id;
+            mark(startTag);
+            var vnode = vm._render();
+            mark(endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = function () {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before: function before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook(vm, 'beforeUpdate');
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook(vm, 'mounted');
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
     {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        );
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        );
-      }
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
     }
-  }
-  callHook(vm, 'beforeMount');
-
-  var updateComponent;
-  /* istanbul ignore if */
-  if (config.performance && mark) {
-    updateComponent = function () {
-      var name = vm._name;
-      var id = vm._uid;
-      var startTag = "vue-perf-start:" + id;
-      var endTag = "vue-perf-end:" + id;
-
-      mark(startTag);
-      var vnode = vm._render();
-      mark(endTag);
-      measure(("vue " + name + " render"), startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(("vue " + name + " patch"), startTag, endTag);
-    };
-  } else {
-    updateComponent = function () {
-      vm._update(vm._render(), hydrating);
-    };
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before: function before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate');
-      }
-    }
-  }, true /* isRenderWatcher */);
-  hydrating = false;
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  }
-  return vm
-}
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-  {
-    isUpdatingChildComponent = true;
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+    {
+        isUpdatingChildComponent = false;
     }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-
-  {
-    isUpdatingChildComponent = false;
-  }
 }
-
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            { return true; }
+    }
+    return false;
 }
-
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (var i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'activated');
     }
-    callHook(vm, 'activated');
-  }
 }
-
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (var i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'deactivated');
     }
-    callHook(vm, 'deactivated');
-  }
 }
-
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-    }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
+    }
+    popTarget();
 }
 
-/*  */
-
+/* @flow */
 var MAX_UPDATE_COUNT = 100;
-
 var queue = [];
 var activatedChildren = [];
 var has = {};
@@ -4224,29 +3704,25 @@ var circular = {};
 var waiting = false;
 var flushing = false;
 var index = 0;
-
 /**
  * Reset the scheduler's state.
  */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0;
-  has = {};
-  {
-    circular = {};
-  }
-  waiting = flushing = false;
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+        circular = {};
+    }
+    waiting = flushing = false;
 }
-
 // Async edge case #6566 requires saving the timestamp when event listeners are
 // attached. However, calling performance.now() has a perf overhead especially
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
 var currentFlushTimestamp = 0;
-
 // Async edge case fix requires storing an event listener's attach timestamp.
 var getNow = Date.now;
-
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -4254,1467 +3730,1277 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = function () { return performance.now(); };
+    }
 }
-
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow();
-  flushing = true;
-  var watcher, id;
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort(function (a, b) { return a.id - b.id; });
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index];
-    if (watcher.before) {
-      watcher.before();
-    }
-    id = watcher.id;
-    has[id] = null;
-    watcher.run();
-    // in dev build, check and stop circular updates.
-    if (has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1;
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-              : "in a component render function."
-          ),
-          watcher.vm
-        );
-        break
-      }
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    var watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort(function (a, b) { return a.id - b.id; });
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        : "in a component render function."), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
     }
-  }
-
-  // keep copies of post queues before resetting state
-  var activatedQueue = activatedChildren.slice();
-  var updatedQueue = queue.slice();
-
-  resetSchedulerState();
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue);
-  callUpdatedHooks(updatedQueue);
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush');
-  }
 }
-
-function callUpdatedHooks (queue) {
-  var i = queue.length;
-  while (i--) {
-    var watcher = queue[i];
-    var vm = watcher.vm;
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated');
+function callUpdatedHooks(queue) {
+    var i = queue.length;
+    while (i--) {
+        var watcher = queue[i];
+        var vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook(vm, 'updated');
+        }
     }
-  }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-  activatedChildren.push(vm);
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
 }
-
-function callActivatedHooks (queue) {
-  for (var i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true;
-    activateChildComponent(queue[i], true /* true */);
-  }
+function callActivatedHooks(queue) {
+    for (var i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
 }
-
 /**
  * Push a watcher into the watcher queue.
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-function queueWatcher (watcher) {
-  var id = watcher.id;
-  if (has[id] == null) {
-    has[id] = true;
-    if (!flushing) {
-      queue.push(watcher);
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      var i = queue.length - 1;
-      while (i > index && queue[i].id > watcher.id) {
-        i--;
-      }
-      queue.splice(i + 1, 0, watcher);
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true;
-
-      if (!config.async) {
-        flushSchedulerQueue();
-        return
-      }
-      nextTick(flushSchedulerQueue);
+function queueWatcher(watcher) {
+    var id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            var i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (!config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
     }
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 var uid$2 = 0;
-
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher (
-  vm,
-  expOrFn,
-  cb,
-  options,
-  isRenderWatcher
-) {
-  this.vm = vm;
-  if (isRenderWatcher) {
-    vm._watcher = this;
-  }
-  vm._watchers.push(this);
-  // options
-  if (options) {
-    this.deep = !!options.deep;
-    this.user = !!options.user;
-    this.lazy = !!options.lazy;
-    this.sync = !!options.sync;
-    this.before = options.before;
-  } else {
-    this.deep = this.user = this.lazy = this.sync = false;
-  }
-  this.cb = cb;
-  this.id = ++uid$2; // uid for batching
-  this.active = true;
-  this.dirty = this.lazy; // for lazy watchers
-  this.deps = [];
-  this.newDeps = [];
-  this.depIds = new _Set();
-  this.newDepIds = new _Set();
-  this.expression = expOrFn.toString();
-  // parse expression for getter
-  if (typeof expOrFn === 'function') {
-    this.getter = expOrFn;
-  } else {
-    this.getter = parsePath(expOrFn);
-    if (!this.getter) {
-      this.getter = noop;
-      warn(
-        "Failed watching path: \"" + expOrFn + "\" " +
-        'Watcher only accepts simple dot-delimited paths. ' +
-        'For full control, use a function instead.',
-        vm
-      );
-    }
-  }
-  this.value = this.lazy
-    ? undefined
-    : this.get();
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$2; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        expOrFn.toString();
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            warn("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+        }
+    }
+    this.value = this.lazy ? undefined : this.get();
 };
-
 /**
  * Evaluate the getter, and re-collect dependencies.
  */
 Watcher.prototype.get = function get () {
-  pushTarget(this);
-  var value;
-  var vm = this.vm;
-  try {
-    value = this.getter.call(vm, vm);
-  } catch (e) {
-    if (this.user) {
-      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-    } else {
-      throw e
-    }
-  } finally {
-    // "touch" every property so they are all tracked as
-    // dependencies for deep watching
-    if (this.deep) {
-      traverse(value);
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
     }
-    popTarget();
-    this.cleanupDeps();
-  }
-  return value
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+        }
+        else {
+            throw e;
+        }
+    }
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
+        }
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
 };
-
 /**
  * Add a dependency to this directive.
  */
 Watcher.prototype.addDep = function addDep (dep) {
-  var id = dep.id;
-  if (!this.newDepIds.has(id)) {
-    this.newDepIds.add(id);
-    this.newDeps.push(dep);
-    if (!this.depIds.has(id)) {
-      dep.addSub(this);
-    }
-  }
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
 };
-
 /**
  * Clean up for dependency collection.
  */
 Watcher.prototype.cleanupDeps = function cleanupDeps () {
-  var i = this.deps.length;
-  while (i--) {
-    var dep = this.deps[i];
-    if (!this.newDepIds.has(dep.id)) {
-      dep.removeSub(this);
-    }
-  }
-  var tmp = this.depIds;
-  this.depIds = this.newDepIds;
-  this.newDepIds = tmp;
-  this.newDepIds.clear();
-  tmp = this.deps;
-  this.deps = this.newDeps;
-  this.newDeps = tmp;
-  this.newDeps.length = 0;
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
 };
-
 /**
  * Subscriber interface.
  * Will be called when a dependency changes.
  */
 Watcher.prototype.update = function update () {
-  /* istanbul ignore else */
-  if (this.lazy) {
-    this.dirty = true;
-  } else if (this.sync) {
-    this.run();
-  } else {
-    queueWatcher(this);
-  }
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
 };
-
 /**
  * Scheduler job interface.
  * Will be called by the scheduler.
  */
 Watcher.prototype.run = function run () {
-  if (this.active) {
-    var value = this.get();
-    if (
-      value !== this.value ||
-      // Deep watchers and watchers on Object/Arrays should fire even
-      // when the value is the same, because the value may
-      // have mutated.
-      isObject(value) ||
-      this.deep
-    ) {
-      // set new value
-      var oldValue = this.value;
-      this.value = value;
-      if (this.user) {
-        try {
-          this.cb.call(this.vm, value, oldValue);
-        } catch (e) {
-          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
+            if (this.user) {
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
+            }
+            else {
+                this.cb.call(this.vm, value, oldValue);
+            }
         }
-      } else {
-        this.cb.call(this.vm, value, oldValue);
-      }
     }
-  }
 };
-
 /**
  * Evaluate the value of the watcher.
  * This only gets called for lazy watchers.
  */
 Watcher.prototype.evaluate = function evaluate () {
-  this.value = this.get();
-  this.dirty = false;
+    this.value = this.get();
+    this.dirty = false;
 };
-
 /**
  * Depend on all deps collected by this watcher.
  */
 Watcher.prototype.depend = function depend () {
-  var i = this.deps.length;
-  while (i--) {
-    this.deps[i].depend();
-  }
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
 };
-
 /**
  * Remove self from all dependencies' subscriber list.
  */
 Watcher.prototype.teardown = function teardown () {
-  if (this.active) {
-    // remove self from vm's watcher list
-    // this is a somewhat expensive operation so we skip it
-    // if the vm is being destroyed.
-    if (!this.vm._isBeingDestroyed) {
-      remove(this.vm._watchers, this);
-    }
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].removeSub(this);
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove(this.vm._watchers, this);
+        }
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].removeSub(this);
+        }
+        this.active = false;
     }
-    this.active = false;
-  }
 };
 
-/*  */
-
+/* @flow */
 var sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
 };
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    var opts = vm.$options;
+    if (opts.props)
+        { initProps(vm, opts.props); }
+    if (opts.methods)
+        { initMethods(vm, opts.methods); }
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        { initComputed(vm, opts.computed); }
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps(vm, propsOptions) {
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    var loop = function ( key ) {
+        keys.push(key);
+        var value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        {
+            var hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+            }
+            defineReactive$$1(props, key, value, function () {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn("Avoid mutating a prop directly since the value will be " +
+                        "overwritten whenever the parent component re-renders. " +
+                        "Instead, use a data or computed property based on the prop's " +
+                        "value. Prop being mutated: \"" + key + "\"", vm);
+                }
+            });
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, "_props", key);
+        }
+    };
 
-function proxy (target, sourceKey, key) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  };
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function initState (vm) {
-  vm._watchers = [];
-  var opts = vm.$options;
-  if (opts.props) { initProps(vm, opts.props); }
-  if (opts.methods) { initMethods(vm, opts.methods); }
-  if (opts.data) {
-    initData(vm);
-  } else {
-    observe(vm._data = {}, true /* asRootData */);
-  }
-  if (opts.computed) { initComputed(vm, opts.computed); }
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
-  }
+    for (var key in propsOptions) loop( key );
+    toggleObserving(true);
 }
-
-function initProps (vm, propsOptions) {
-  var propsData = vm.$options.propsData || {};
-  var props = vm._props = {};
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  var keys = vm.$options._propKeys = [];
-  var isRoot = !vm.$parent;
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false);
-  }
-  var loop = function ( key ) {
-    keys.push(key);
-    var value = validateProp(key, propsOptions, propsData, vm);
-    /* istanbul ignore else */
-    {
-      var hyphenatedKey = hyphenate(key);
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-          vm
-        );
-      }
-      defineReactive$$1(props, key, value, function () {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            "Avoid mutating a prop directly since the value will be " +
-            "overwritten whenever the parent component re-renders. " +
-            "Instead, use a data or computed property based on the prop's " +
-            "value. Prop being mutated: \"" + key + "\"",
-            vm
-          );
-        }
-      });
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, "_props", key);
-    }
-  };
-
-  for (var key in propsOptions) loop( key );
-  toggleObserving(true);
+function initData(vm) {
+    var data = vm.$options.data;
+    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        warn('data functions should return an object:\n' +
+                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+    }
+    // proxy data on instance
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
+    while (i--) {
+        var key = keys[i];
+        {
+            if (methods && hasOwn(methods, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            warn("The data property \"" + key + "\" is already declared as a prop. " +
+                    "Use prop default value instead.", vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, "_data", key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
 }
-
-function initData (vm) {
-  var data = vm.$options.data;
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (!isPlainObject(data)) {
-    data = {};
-    warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    );
-  }
-  // proxy data on instance
-  var keys = Object.keys(data);
-  var props = vm.$options.props;
-  var methods = vm.$options.methods;
-  var i = keys.length;
-  while (i--) {
-    var key = keys[i];
-    {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a data property."),
-          vm
-        );
-      }
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
     }
-    if (props && hasOwn(props, key)) {
-      warn(
-        "The data property \"" + key + "\" is already declared as a prop. " +
-        "Use prop default value instead.",
-        vm
-      );
-    } else if (!isReserved(key)) {
-      proxy(vm, "_data", key);
+    catch (e) {
+        handleError(e, vm, "data()");
+        return {};
+    }
+    finally {
+        popTarget();
     }
-  }
-  // observe data
-  observe(data, true /* asRootData */);
-}
-
-function getData (data, vm) {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget();
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, "data()");
-    return {}
-  } finally {
-    popTarget();
-  }
 }
-
 var computedWatcherOptions = { lazy: true };
-
-function initComputed (vm, computed) {
-  // $flow-disable-line
-  var watchers = vm._computedWatchers = Object.create(null);
-  // computed properties are just getters during SSR
-  var isSSR = isServerRendering();
-
-  for (var key in computed) {
-    var userDef = computed[key];
-    var getter = typeof userDef === 'function' ? userDef : userDef.get;
-    if (getter == null) {
-      warn(
-        ("Getter is missing for computed property \"" + key + "\"."),
-        vm
-      );
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      );
+function initComputed(vm, computed) {
+    // $flow-disable-line
+    var watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+        var userDef = computed[key];
+        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+        if (getter == null) {
+            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else {
+            if (key in vm.$data) {
+                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+            }
+        }
     }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else {
-      if (key in vm.$data) {
-        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-      }
-    }
-  }
 }
-
-function defineComputed (
-  target,
-  key,
-  userDef
-) {
-  var shouldCache = !isServerRendering();
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
-  }
-  if (sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-        this
-      );
+function defineComputed(target, key, userDef) {
+    var shouldCache = !isServerRendering();
+    if (typeof userDef === 'function') {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        var watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
     };
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    var watcher = this._computedWatchers && this._computedWatchers[key];
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate();
-      }
-      if (Dep.target) {
-        watcher.depend();
-      }
-      return watcher.value
-    }
-  }
 }
-
 function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
 }
-
-function initMethods (vm, methods) {
-  var props = vm.$options.props;
-  for (var key in methods) {
-    {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-          "Did you reference the function correctly?",
-          vm
-        );
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a prop."),
-          vm
-        );
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-          "Avoid defining component methods that start with _ or $."
-        );
-      }
+function initMethods(vm, methods) {
+    var props = vm.$options.props;
+    for (var key in methods) {
+        {
+            if (typeof methods[key] !== 'function') {
+                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                    "Did you reference the function correctly?", vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                    "Avoid defining component methods that start with _ or $.");
+            }
+        }
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
     }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-  }
 }
-
-function initWatch (vm, watch) {
-  for (var key in watch) {
-    var handler = watch[key];
-    if (Array.isArray(handler)) {
-      for (var i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
-      }
-    } else {
-      createWatcher(vm, key, handler);
-    }
-  }
+function initWatch(vm, watch) {
+    for (var key in watch) {
+        var handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (var i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
 }
-
-function createWatcher (
-  vm,
-  expOrFn,
-  handler,
-  options
-) {
-  if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler];
-  }
-  return vm.$watch(expOrFn, handler, options)
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === 'string') {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
 }
-
-function stateMixin (Vue) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  var dataDef = {};
-  dataDef.get = function () { return this._data };
-  var propsDef = {};
-  propsDef.get = function () { return this._props };
-  {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      );
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    var dataDef = {};
+    dataDef.get = function () {
+        return this._data;
     };
-    propsDef.set = function () {
-      warn("$props is readonly.", this);
+    var propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    {
+        dataDef.set = function () {
+            warn('Avoid replacing instance root $data. ' +
+                'Use nested data properties instead.', this);
+        };
+        propsDef.set = function () {
+            warn("$props is readonly.", this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, '$data', dataDef);
+    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        var vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        var watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            pushTarget();
+            try {
+                cb.call(vm, watcher.value);
+            }
+            catch (error) {
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+            }
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
     };
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef);
-  Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
-
-  Vue.prototype.$watch = function (
-    expOrFn,
-    cb,
-    options
-  ) {
-    var vm = this;
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
-    }
-    options = options || {};
-    options.user = true;
-    var watcher = new Watcher(vm, expOrFn, cb, options);
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value);
-      } catch (error) {
-        handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-      }
-    }
-    return function unwatchFn () {
-      watcher.teardown();
-    }
-  };
 }
 
-/*  */
-
+/* @flow */
 var uid$3 = 0;
-
-function initMixin (Vue) {
-  Vue.prototype._init = function (options) {
-    var vm = this;
-    // a uid
-    vm._uid = uid$3++;
-
-    var startTag, endTag;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      startTag = "vue-perf-start:" + (vm._uid);
-      endTag = "vue-perf-end:" + (vm._uid);
-      mark(startTag);
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options);
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      );
-    }
-    /* istanbul ignore else */
-    {
-      initProxy(vm);
-    }
-    // expose real self
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook(vm, 'created');
-
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      vm._name = formatComponentName(vm, false);
-      mark(endTag);
-      measure(("vue " + (vm._name) + " init"), startTag, endTag);
+function initMixin(Vue) {
+    Vue.prototype._init = function (options) {
+        var vm = this;
+        // a uid
+        vm._uid = uid$3++;
+        var startTag, endTag;
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        {
+            initProxy(vm);
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook(vm, 'created');
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    // @ts-ignore
+    var opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    var parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    var vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    var options = Ctor.options;
+    if (Ctor.super) {
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            var modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
     }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el);
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                { modified = {}; }
+            modified[key] = latest[key];
+        }
     }
-  };
-}
-
-function initInternalComponent (vm, options) {
-  var opts = vm.$options = Object.create(vm.constructor.options);
-  // doing this because it's faster than dynamic enumeration.
-  var parentVnode = options._parentVnode;
-  opts.parent = options.parent;
-  opts._parentVnode = parentVnode;
-
-  var vnodeComponentOptions = parentVnode.componentOptions;
-  opts.propsData = vnodeComponentOptions.propsData;
-  opts._parentListeners = vnodeComponentOptions.listeners;
-  opts._renderChildren = vnodeComponentOptions.children;
-  opts._componentTag = vnodeComponentOptions.tag;
-
-  if (options.render) {
-    opts.render = options.render;
-    opts.staticRenderFns = options.staticRenderFns;
-  }
-}
-
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
+    return modified;
 }
 
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
-}
-
-function Vue (options) {
-  if (!(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword');
-  }
-  this._init(options);
+function Vue(options) {
+    if (!(this instanceof Vue)) {
+        warn('Vue is a constructor and should be called with the `new` keyword');
+    }
+    this._init(options);
 }
-
+//@ts-ignore
 initMixin(Vue);
+//@ts-ignore
 stateMixin(Vue);
+//@ts-ignore
 eventsMixin(Vue);
+//@ts-ignore
 lifecycleMixin(Vue);
+//@ts-ignore
 renderMixin(Vue);
 
-/*  */
-
-function initUse (Vue) {
-  Vue.use = function (plugin) {
-    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    var args = toArray(arguments, 1);
-    args.unshift(this);
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args);
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args);
-    }
-    installedPlugins.push(plugin);
-    return this
-  };
-}
-
-/*  */
-
-function initMixin$1 (Vue) {
-  Vue.mixin = function (mixin) {
-    this.options = mergeOptions(this.options, mixin);
-    return this
-  };
-}
-
-/*  */
-
-function initExtend (Vue) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0;
-  var cid = 1;
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions) {
-    extendOptions = extendOptions || {};
-    var Super = this;
-    var SuperId = Super.cid;
-    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
-    }
-
-    var name = extendOptions.name || Super.options.name;
-    if (name) {
-      validateComponentName(name);
-    }
-
-    var Sub = function VueComponent (options) {
-      this._init(options);
+/* @flow */
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        var args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
     };
-    Sub.prototype = Object.create(Super.prototype);
-    Sub.prototype.constructor = Sub;
-    Sub.cid = cid++;
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    );
-    Sub['super'] = Super;
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps$1(Sub);
-    }
-    if (Sub.options.computed) {
-      initComputed$1(Sub);
-    }
-
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend;
-    Sub.mixin = Super.mixin;
-    Sub.use = Super.use;
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type];
-    });
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub;
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options;
-    Sub.extendOptions = extendOptions;
-    Sub.sealedOptions = extend({}, Sub.options);
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub;
-    return Sub
-  };
-}
-
-function initProps$1 (Comp) {
-  var props = Comp.options.props;
-  for (var key in props) {
-    proxy(Comp.prototype, "_props", key);
-  }
 }
 
-function initComputed$1 (Comp) {
-  var computed = Comp.options.computed;
-  for (var key in computed) {
-    defineComputed(Comp.prototype, key, computed[key]);
-  }
+/* @flow */
+function initMixin$1(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-/*  */
-
-function initAssetRegisters (Vue) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(function (type) {
-    Vue[type] = function (
-      id,
-      definition
-    ) {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
-        /* istanbul ignore if */
-        if (type === 'component') {
-          validateComponentName(id);
+/* @flow */
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    var cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        var Super = this;
+        var SuperId = Super.cid;
+        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        var name = extendOptions.name || Super.options.name;
+        if (name) {
+            validateComponentName(name);
+        }
+        var Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps$1(Sub);
         }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id;
-          definition = this.options._base.extend(definition);
+        if (Sub.options.computed) {
+            initComputed$1(Sub);
         }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition };
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
         }
-        this.options[type + 's'][id] = definition;
-        return definition
-      }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
     };
-  });
 }
-
-/*  */
-
-
-
-function getComponentName (opts) {
-  return opts && (opts.Ctor.options.name || opts.tag)
+function initProps$1(Comp) {
+    var props = Comp.options.props;
+    for (var key in props) {
+        proxy(Comp.prototype, "_props", key);
+    }
 }
-
-function matches (pattern, name) {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
+function initComputed$1(Comp) {
+    var computed = Comp.options.computed;
+    for (var key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function pruneCache (keepAliveInstance, filter) {
-  var cache = keepAliveInstance.cache;
-  var keys = keepAliveInstance.keys;
-  var _vnode = keepAliveInstance._vnode;
-  for (var key in cache) {
-    var cachedNode = cache[key];
-    if (cachedNode) {
-      var name = getComponentName(cachedNode.componentOptions);
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
-      }
-    }
-  }
+/* @flow */
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach(function (type) {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-function pruneCacheEntry (
-  cache,
-  key,
-  keys,
-  current
-) {
-  var cached$$1 = cache[key];
-  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-    cached$$1.componentInstance.$destroy();
-  }
-  cache[key] = null;
-  remove(keys, key);
+// @ts-nocheck
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === 'string') {
+        return pattern.split(',').indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+        var cachedNode = cache[key];
+        if (cachedNode) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    var cached$$1 = cache[key];
+    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+        cached$$1.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove(keys, key);
 }
-
 var patternTypes = [String, RegExp, Array];
-
+// TODO use defineComponent
 var KeepAlive = {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created: function created () {
-    this.cache = Object.create(null);
-    this.keys = [];
-  },
-
-  destroyed: function destroyed () {
-    for (var key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
-    }
-  },
-
-  mounted: function mounted () {
-    var this$1 = this;
-
-    this.$watch('include', function (val) {
-      pruneCache(this$1, function (name) { return matches(val, name); });
-    });
-    this.$watch('exclude', function (val) {
-      pruneCache(this$1, function (name) { return !matches(val, name); });
-    });
-  },
-
-  render: function render () {
-    var slot = this.$slots.default;
-    var vnode = getFirstComponentChild(slot);
-    var componentOptions = vnode && vnode.componentOptions;
-    if (componentOptions) {
-      // check pattern
-      var name = getComponentName(componentOptions);
-      var ref = this;
-      var include = ref.include;
-      var exclude = ref.exclude;
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      var ref$1 = this;
-      var cache = ref$1.cache;
-      var keys = ref$1.keys;
-      var key = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-        : vnode.key;
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
-        // make current key freshest
-        remove(keys, key);
-        keys.push(key);
-      } else {
-        cache[key] = vnode;
-        keys.push(key);
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+    name: 'keep-alive',
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    created: function created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed: function destroyed() {
+        for (var key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
         }
-      }
+    },
+    mounted: function mounted() {
+        var this$1 = this;
 
-      vnode.data.keepAlive = true;
-    }
-    return vnode || (slot && slot[0])
-  }
+        this.$watch('include', function (val) {
+            pruneCache(this$1, function (name) { return matches(val, name); });
+        });
+        this.$watch('exclude', function (val) {
+            pruneCache(this$1, function (name) { return !matches(val, name); });
+        });
+    },
+    render: function render() {
+        var slot = this.$slots.default;
+        var vnode = getFirstComponentChild(slot);
+        var componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
+            var key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove(keys, key);
+                keys.push(key);
+            }
+            else {
+                cache[key] = vnode;
+                keys.push(key);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+            }
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
 var builtInComponents = {
-  KeepAlive: KeepAlive
+    KeepAlive: KeepAlive,
 };
 
-/*  */
-
-function initGlobalAPI (Vue) {
-  // config
-  var configDef = {};
-  configDef.get = function () { return config; };
-  {
-    configDef.set = function () {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      );
+/* @flow */
+function initGlobalAPI(Vue) {
+    // config
+    var configDef = {};
+    configDef.get = function () { return config; };
+    {
+        configDef.set = function () {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn,
+        extend: extend,
+        mergeOptions: mergeOptions,
+        defineReactive: defineReactive$$1,
     };
-  }
-  Object.defineProperty(Vue, 'config', configDef);
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn: warn,
-    extend: extend,
-    mergeOptions: mergeOptions,
-    defineReactive: defineReactive$$1
-  };
-
-  Vue.set = set;
-  Vue.delete = del;
-  Vue.nextTick = nextTick;
-
-  // 2.6 explicit observable API
-  Vue.observable = function (obj) {
-    observe(obj);
-    return obj
-  };
-
-  Vue.options = Object.create(null);
-  ASSET_TYPES.forEach(function (type) {
-    Vue.options[type + 's'] = Object.create(null);
-  });
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue;
-
-  extend(Vue.options.components, builtInComponents);
-
-  initUse(Vue);
-  initMixin$1(Vue);
-  initExtend(Vue);
-  initAssetRegisters(Vue);
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = function (obj) {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach(function (type) {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin$1(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
 initGlobalAPI(Vue);
-
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+    get: isServerRendering,
 });
-
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get: function get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
+    get: function get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
 });
-
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+    value: FunctionalRenderContext,
 });
-
 Vue.version = '2.6.12';
 
-/*  */
-
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
 var convertEnumeratedValue = function (key, value) {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
 var xlinkNS = 'http://www.w3.org/1999/xlink';
-
 var isXlink = function (name) {
-  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-
 var getXlinkProp = function (name) {
-  return isXlink(name) ? name.slice(6, name.length) : ''
+    return isXlink(name) ? name.slice(6, name.length) : '';
 };
-
 var isFalsyAttrValue = function (val) {
-  return val == null || val === false
+    return val == null || val === false;
 };
 
-/*  */
-
-function genClassForVnode (vnode) {
-  var data = vnode.data;
-  var parentNode = vnode;
-  var childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
-    }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
-    }
-  }
-  return renderClass(data.staticClass, data.class)
+/* @flow */
+function genClassForVnode(vnode) {
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
 }
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
 }
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
 }
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyArray (value) {
-  var res = '';
-  var stringified;
-  for (var i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) { res += ' '; }
-      res += stringified;
+function stringifyArray(value) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                { res += ' '; }
+            res += stringified;
+        }
     }
-  }
-  return res
+    return res;
 }
-
-function stringifyObject (value) {
-  var res = '';
-  for (var key in value) {
-    if (value[key]) {
-      if (res) { res += ' '; }
-      res += key;
+function stringifyObject(value) {
+    var res = '';
+    for (var key in value) {
+        if (value[key]) {
+            if (res)
+                { res += ' '; }
+            res += key;
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
 };
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 var unknownElementCache = Object.create(null);
-function isUnknownElement (tag) {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase();
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  var el = document.createElement(tag);
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    var el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
 }
-
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
-
+/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
-function query (el) {
-  if (typeof el === 'string') {
-    var selected = document.querySelector(el);
-    if (!selected) {
-      warn(
-        'Cannot find element: ' + el
-      );
-      return document.createElement('div')
-    }
-    return selected
-  } else {
-    return el
-  }
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-/*  */
-
-function createElement$1 (tagName, vnode) {
-  var elm = document.createElement(tagName);
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple');
-  }
-  return elm
+/* @flow */
+function createElement$1(tagName, vnode) {
+    var elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
 }
-
-function createElementNS (namespace, tagName) {
-  return document.createElementNS(namespaceMap[namespace], tagName)
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
 }
-
-function createTextNode (text) {
-  return document.createTextNode(text)
+function createTextNode(text) {
+    return document.createTextNode(text);
 }
-
-function createComment (text) {
-  return document.createComment(text)
+function createComment(text) {
+    return document.createComment(text);
 }
-
-function insertBefore (parentNode, newNode, referenceNode) {
-  parentNode.insertBefore(newNode, referenceNode);
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
 }
-
-function removeChild (node, child) {
-  node.removeChild(child);
+function removeChild(node, child) {
+    node.removeChild(child);
 }
-
-function appendChild (node, child) {
-  node.appendChild(child);
+function appendChild(node, child) {
+    node.appendChild(child);
 }
-
-function parentNode (node) {
-  return node.parentNode
+function parentNode(node) {
+    return node.parentNode;
 }
-
-function nextSibling (node) {
-  return node.nextSibling
+function nextSibling(node) {
+    return node.nextSibling;
 }
-
-function tagName (node) {
-  return node.tagName
+function tagName(node) {
+    return node.tagName;
 }
-
-function setTextContent (node, text) {
-  node.textContent = text;
+function setTextContent(node, text) {
+    node.textContent = text;
 }
-
-function setStyleScope (node, scopeId) {
-  node.setAttribute(scopeId, '');
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5732,48 +5018,53 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/*  */
-
+/* @flow */
 var ref = {
-  create: function create (_, vnode) {
-    registerRef(vnode);
-  },
-  update: function update (oldVnode, vnode) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
-    }
-  },
-  destroy: function destroy (vnode) {
-    registerRef(vnode, true);
-  }
+    create: function create(_, vnode) {
+        registerRef(vnode);
+    },
+    update: function update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy: function destroy(vnode) {
+        registerRef(vnode, true);
+    },
 };
-
-function registerRef (vnode, isRemoval) {
-  var key = vnode.data.ref;
-  if (!isDef(key)) { return }
-
-  var vm = vnode.context;
-  var ref = vnode.componentInstance || vnode.elm;
-  var refs = vm.$refs;
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref);
-    } else if (refs[key] === ref) {
-      refs[key] = undefined;
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref];
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref);
-      }
-    } else {
-      refs[key] = ref;
+function registerRef(vnode, isRemoval) {
+    var key = vnode.data.ref;
+    if (!isDef(key))
+        { return; }
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
+    if (isRemoval) {
+        if (Array.isArray(refs[key])) {
+            // @ts-expect-error invalid typings
+            remove(refs[key], ref);
+        }
+        else if (refs[key] === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error invalid typings
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(refs[key])) {
+                refs[key] = [ref];
+                // @ts-expect-error invalid typings
+            }
+            else if (refs[key].indexOf(ref) < 0) {
+                // @ts-expect-error invalid typings
+                refs[key].push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
     }
-  }
 }
 
 /**
@@ -5787,2637 +5078,2422 @@ function registerRef (vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-
 var emptyNode = new VNode('', {}, []);
-
 var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') { return true }
-  var i;
-  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        ((a.tag === b.tag &&
+            a.isComment === b.isComment &&
+            isDef(a.data) === isDef(b.data) &&
+            sameInputType(a, b)) ||
+            (isTrue(a.isAsyncPlaceholder) &&
+                a.asyncFactory === b.asyncFactory &&
+                isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        { return true; }
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  var i, key;
-  var map = {};
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key;
-    if (isDef(key)) { map[key] = i; }
-  }
-  return map
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    var i, key;
+    var map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            { map[key] = i; }
+    }
+    return map;
 }
-
-function createPatchFunction (backend) {
-  var i, j;
-  var cbs = {};
-
-  var modules = backend.modules;
-  var nodeOps = backend.nodeOps;
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = [];
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]]);
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove$$1 () {
-      if (--remove$$1.listeners === 0) {
-        removeNode(childElm);
-      }
-    }
-    remove$$1.listeners = listeners;
-    return remove$$1
-  }
-
-  function removeNode (el) {
-    var parent = nodeOps.parentNode(el);
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el);
+function createPatchFunction(backend) {
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
     }
-  }
-
-  function isUnknownElement$$1 (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(function (ignore) {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  var creatingElmInVPre = 0;
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode);
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
-
-    vnode.isRootInsert = !nested; // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
+    function createRmCb(childElm, listeners) {
+        function remove$$1() {
+            if (--remove$$1.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove$$1.listeners = listeners;
+        return remove$$1;
+    }
+    function removeNode(el) {
+        var parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
     }
-
-    var data = vnode.data;
-    var children = vnode.children;
-    var tag = vnode.tag;
-    if (isDef(tag)) {
-      {
-        if (data && data.pre) {
-          creatingElmInVPre++;
-        }
-        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          );
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode);
-      setScope(vnode);
-
-      /* istanbul ignore if */
-      {
-        createChildren(vnode, children, insertedVnodeQueue);
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue);
+    function isUnknownElement$$1(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some(function (ignore) {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    var creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        insert(parentElm, vnode.elm, refElm);
-      }
-
-      if (data && data.pre) {
-        creatingElmInVPre--;
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i = vnode.data;
-    if (isDef(i)) {
-      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */);
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue);
-        insert(parentElm, vnode.elm, refElm);
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        var data = vnode.data;
+        var children = vnode.children;
+        var tag = vnode.tag;
+        if (isDef(tag)) {
+            {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
         }
-        return true
-      }
     }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-      vnode.data.pendingInsert = null;
-    }
-    vnode.elm = vnode.componentInstance.$el;
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue);
-      setScope(vnode);
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode);
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode);
-    }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i;
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    var innerNode = vnode;
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode;
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode);
-        }
-        insertedVnodeQueue.push(innerNode);
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm);
-  }
-
-  function insert (parent, elm, ref$$1) {
-    if (isDef(parent)) {
-      if (isDef(ref$$1)) {
-        if (nodeOps.parentNode(ref$$1) === parent) {
-          nodeOps.insertBefore(parent, elm, ref$$1);
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i = vnode.data;
+        if (isDef(i)) {
+            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
         }
-      } else {
-        nodeOps.appendChild(parent, elm);
-      }
     }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      {
-        checkDuplicateKeys(children);
-      }
-      for (var i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode;
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
     }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-      cbs.create[i$1](emptyNode, vnode);
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        var innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref$$1) {
+        if (isDef(parent)) {
+            if (isDef(ref$$1)) {
+                if (nodeOps.parentNode(ref$$1) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref$$1);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
     }
-    i = vnode.data.hook; // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) { i.create(emptyNode, vnode); }
-      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            {
+                checkDuplicateKeys(children);
+            }
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
     }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    var i;
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    } else {
-      var ancestor = vnode;
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i);
-        }
-        ancestor = ancestor.parent;
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
     }
-  }
-
-  function invokeDestroyHook (vnode) {
-    var i, j;
-    var data = vnode.data;
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                { i.create(emptyNode, vnode); }
+            if (isDef(i.insert))
+                { insertedVnodeQueue.push(vnode); }
+        }
     }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j]);
-      }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        var i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            var ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
     }
-  }
-
-  function removeVnodes (vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      var ch = vnodes[startIdx];
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch);
-          invokeDestroyHook(ch);
-        } else { // Text node
-          removeNode(ch.elm);
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      var i;
-      var listeners = cbs.remove.length + 1;
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners;
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners);
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm);
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm);
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm);
-      } else {
-        rm();
-      }
-    } else {
-      removeNode(vnode.elm);
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    var oldStartIdx = 0;
-    var newStartIdx = 0;
-    var oldEndIdx = oldCh.length - 1;
-    var oldStartVnode = oldCh[0];
-    var oldEndVnode = oldCh[oldEndIdx];
-    var newEndIdx = newCh.length - 1;
-    var newStartVnode = newCh[0];
-    var newEndVnode = newCh[newEndIdx];
-    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    var canMove = !removeOnly;
-
-    {
-      checkDuplicateKeys(newCh);
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
     }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx];
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        oldStartVnode = oldCh[++oldStartIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-        oldStartVnode = oldCh[++oldStartIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-        } else {
-          vnodeToMove = oldCh[idxInOld];
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-            oldCh[idxInOld] = undefined;
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          }
-        }
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    var seenKeys = {};
-    for (var i = 0; i < children.length; i++) {
-      var vnode = children[i];
-      var key = vnode.key;
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-            vnode.context
-          );
-        } else {
-          seenKeys[key] = true;
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (var i = start; i < end; i++) {
-      var c = oldCh[i];
-      if (isDef(c) && sameVnode(node, c)) { return i }
+    function invokeDestroyHook(vnode) {
+        var i, j;
+        var data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                { i(vnode); }
+            for (i = 0; i < cbs.destroy.length; ++i)
+                { cbs.destroy[i](vnode); }
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
     }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            var ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
     }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode);
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            var i;
+            var listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
     }
-
-    var elm = vnode.elm = oldVnode.elm;
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-      } else {
-        vnode.isAsyncPlaceholder = true;
-      }
-      return
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        var oldStartIdx = 0;
+        var newStartIdx = 0;
+        var oldEndIdx = oldCh.length - 1;
+        var oldStartVnode = oldCh[0];
+        var oldEndVnode = oldCh[oldEndIdx];
+        var newEndIdx = newCh.length - 1;
+        var newStartVnode = newCh[0];
+        var newEndVnode = newCh[newEndIdx];
+        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        var canMove = !removeOnly;
+        {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
     }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance;
-      return
+    function checkDuplicateKeys(children) {
+        var seenKeys = {};
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
+            var key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
     }
-
-    var i;
-    var data = vnode.data;
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode);
+    function findIdxInOld(node, oldCh, start, end) {
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                { return i; }
+        }
     }
-
-    var oldCh = oldVnode.children;
-    var ch = vnode.children;
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
-    }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-      } else if (isDef(ch)) {
-        {
-          checkDuplicateKeys(ch);
-        }
-        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-      } else if (isDef(oldCh)) {
-        removeVnodes(oldCh, 0, oldCh.length - 1);
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '');
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text);
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue;
-    } else {
-      for (var i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i]);
-      }
-    }
-  }
-
-  var hydrationBailed = false;
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    var i;
-    var tag = vnode.tag;
-    var data = vnode.data;
-    var children = vnode.children;
-    inVPre = inVPre || (data && data.pre);
-    vnode.elm = elm;
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true;
-      return true
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        var elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        var i;
+        var data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        var oldCh = oldVnode.children;
+        var ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                { cbs.update[i](oldVnode, vnode); }
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                { i(oldVnode, vnode); }
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+            }
+            else if (isDef(ch)) {
+                {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    { nodeOps.setTextContent(elm, ''); }
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                { i(oldVnode, vnode); }
+        }
     }
-    // assert node match
-    {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue);
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue);
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('server innerHTML: ', i);
-                console.warn('client innerHTML: ', elm.innerHTML);
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            var childrenMatch = true;
-            var childNode = elm.firstChild;
-            for (var i$1 = 0; i$1 < children.length; i$1++) {
-              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false;
-                break
-              }
-              childNode = childNode.nextSibling;
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        var fullInvoke = false;
-        for (var key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true;
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            break
-          }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
         }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class']);
+        else {
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
         }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text;
     }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement$$1(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-      return
+    var hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        var i;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                { i(vnode, true /* hydrating */); }
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        var childrenMatch = true;
+                        var childNode = elm.firstChild;
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                var fullInvoke = false;
+                for (var key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement$$1(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
     }
-
-    var isInitialPatch = false;
-    var insertedVnodeQueue = [];
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true;
-      createElm(vnode, insertedVnodeQueue);
-    } else {
-      var isRealElement = isDef(oldVnode.nodeType);
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR);
-            hydrating = true;
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true);
-              return oldVnode
-            } else {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
-              );
-            }
-          }
-          // either not server-rendered, or hydration failed.
-          // create an empty node and replace it
-          oldVnode = emptyNodeAt(oldVnode);
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                { invokeDestroyHook(oldVnode); }
+            return;
         }
-
-        // replacing existing element
-        var oldElm = oldVnode.elm;
-        var parentElm = nodeOps.parentNode(oldElm);
-
-        // create new node
-        createElm(
-          vnode,
-          insertedVnodeQueue,
-          // extremely rare edge case: do not insert if old element is in a
-          // leaving transition. Only happens when combining transition +
-          // keep-alive + HOCs. (#4590)
-          oldElm._leaveCb ? null : parentElm,
-          nodeOps.nextSibling(oldElm)
-        );
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          var ancestor = vnode.parent;
-          var patchable = isPatchable(vnode);
-          while (ancestor) {
-            for (var i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor);
-            }
-            ancestor.elm = vnode.elm;
-            if (patchable) {
-              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                cbs.create[i$1](emptyNode, ancestor);
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              var insert = ancestor.data.hook.insert;
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                  insert.fns[i$2]();
+        var isInitialPatch = false;
+        var insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            var isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                var oldElm = oldVnode.elm;
+                var parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    var ancestor = vnode.parent;
+                    var patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
                 }
-              }
-            } else {
-              registerRef(ancestor);
             }
-            ancestor = ancestor.parent;
-          }
         }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes([oldVnode], 0, 0);
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode);
-        }
-      }
-    }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-    return vnode.elm
-  }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-/*  */
-
+/* @flow */
 var directives = {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode) {
-    updateDirectives(vnode, emptyNode);
-  }
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
 };
-
-function updateDirectives (oldVnode, vnode) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode);
-  }
-}
-
-function _update (oldVnode, vnode) {
-  var isCreate = oldVnode === emptyNode;
-  var isDestroy = vnode === emptyNode;
-  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-  var dirsWithInsert = [];
-  var dirsWithPostpatch = [];
-
-  var key, oldDir, dir;
-  for (key in newDirs) {
-    oldDir = oldDirs[key];
-    dir = newDirs[key];
-    if (!oldDir) {
-      // new directive, bind
-      callHook$1(dir, 'bind', vnode, oldVnode);
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir);
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value;
-      dir.oldArg = oldDir.arg;
-      callHook$1(dir, 'update', vnode, oldVnode);
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir);
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    var callInsert = function () {
-      for (var i = 0; i < dirsWithInsert.length; i++) {
-        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-      }
-    };
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert);
-    } else {
-      callInsert();
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook$1(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook$1(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
     }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', function () {
-      for (var i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-      }
-    });
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-      }
+    if (dirsWithInsert.length) {
+        var callInsert = function () {
+            for (var i = 0; i < dirsWithInsert.length; i++) {
+                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', function () {
+            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
     }
-  }
 }
-
 var emptyModifiers = Object.create(null);
-
-function normalizeDirectives$1 (
-  dirs,
-  vm
-) {
-  var res = Object.create(null);
-  if (!dirs) {
+function normalizeDirectives$1(dirs, vm) {
+    var res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    var i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
     // $flow-disable-line
-    return res
-  }
-  var i, dir;
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i];
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers;
-    }
-    res[getRawDirName(dir)] = dir;
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-  }
-  // $flow-disable-line
-  return res
+    return res;
 }
-
-function getRawDirName (dir) {
-  return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
+function getRawDirName(dir) {
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
 }
-
-function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-  var fn = dir.def && dir.def[hook];
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-    } catch (e) {
-      handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+    var fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+        }
     }
-  }
 }
 
-var baseModules = [
-  ref,
-  directives
-];
-
-/*  */
-
-function updateAttrs (oldVnode, vnode) {
-  var opts = vnode.componentOptions;
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  var key, cur, old;
-  var elm = vnode.elm;
-  var oldAttrs = oldVnode.data.attrs || {};
-  var attrs = vnode.data.attrs || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__)) {
-    attrs = vnode.data.attrs = extend({}, attrs);
-  }
+var baseModules = [ref, directives];
 
-  for (key in attrs) {
-    cur = attrs[key];
-    old = oldAttrs[key];
-    if (old !== cur) {
-      setAttr(elm, key, cur);
-    }
-  }
-  // #4391: in IE9, setting type can reset value for input[type=radio]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value);
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key);
-      }
-    }
-  }
+/* @flow */
+function updateAttrs(oldVnode, vnode) {
+    var opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
 }
-
-function setAttr (el, key, value) {
-  if (el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value);
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key;
-      el.setAttribute(key, value);
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value));
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-    } else {
-      el.setAttributeNS(xlinkNS, key, value);
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
     }
-  } else {
-    baseSetAttr(el, key, value);
-  }
 }
-
-function baseSetAttr (el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key);
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
-    /* istanbul ignore if */
-    if (
-      isIE && !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
-    ) {
-      var blocker = function (e) {
-        e.stopImmediatePropagation();
-        el.removeEventListener('input', blocker);
-      };
-      el.addEventListener('input', blocker);
-      // $flow-disable-line
-      el.__ieph = true; /* IE placeholder patched */
-    }
-    el.setAttribute(key, value);
-  }
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            var blocker = function (e) {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
 }
-
 var attrs = {
-  create: updateAttrs,
-  update: updateAttrs
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-/*  */
-
-function updateClass (oldVnode, vnode) {
-  var el = vnode.elm;
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
-  ) {
-    return
-  }
-
-  var cls = genClassForVnode(vnode);
-
-  // handle transition classes
-  var transitionClass = el._transitionClasses;
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass));
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls);
-    el._prevClass = cls;
-  }
+/* @flow */
+function updateClass(oldVnode, vnode) {
+    var el = vnode.elm;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    var cls = genClassForVnode(vnode);
+    // handle transition classes
+    var transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
 }
-
 var klass = {
-  create: updateClass,
-  update: updateClass
+    create: updateClass,
+    update: updateClass,
 };
 
-/*  */
+/* @flow */
 
-/*  */
+/* @flow */
 
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
 
-/*  */
-
+/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
 // user-attached handlers.
-function normalizeEvents (on) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    var event = isIE ? 'change' : 'input';
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-    delete on[RANGE_TOKEN];
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-    delete on[CHECKBOX_RADIO_TOKEN];
-  }
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
 }
-
 var target$1;
-
-function createOnceHandler$1 (event, handler, capture) {
-  var _target = target$1; // save current target element in closure
-  return function onceHandler () {
-    var res = handler.apply(null, arguments);
-    if (res !== null) {
-      remove$2(event, onceHandler, capture, _target);
-    }
-  }
+function createOnceHandler$1(event, handler, capture) {
+    var _target = target$1; // save current target element in closure
+    return function onceHandler() {
+        var res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove$2(event, onceHandler, capture, _target);
+        }
+    };
 }
-
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-function add$1 (
-  name,
-  handler,
-  capture,
-  passive
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    var attachedTimestamp = currentFlushTimestamp;
-    var original = handler;
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    };
-  }
-  target$1.addEventListener(
-    name,
-    handler,
-    supportsPassive
-      ? { capture: capture, passive: passive }
-      : capture
-  );
+function add$1(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
+        //@ts-expect-error
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-
-function remove$2 (
-  name,
-  handler,
-  capture,
-  _target
-) {
-  (_target || target$1).removeEventListener(
-    name,
-    handler._wrapper || handler,
-    capture
-  );
+function remove$2(name, handler, capture, _target) {
+    (_target || target$1).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
 }
-
-function updateDOMListeners (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  var on = vnode.data.on || {};
-  var oldOn = oldVnode.data.on || {};
-  target$1 = vnode.elm;
-  normalizeEvents(on);
-  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-  target$1 = undefined;
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target$1 = vnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+    target$1 = undefined;
 }
-
 var events = {
-  create: updateDOMListeners,
-  update: updateDOMListeners
+    create: updateDOMListeners,
+    update: updateDOMListeners,
 };
 
-/*  */
-
+/* @flow */
 var svgContainer;
-
-function updateDOMProps (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  var key, cur;
-  var elm = vnode.elm;
-  var oldProps = oldVnode.data.domProps || {};
-  var props = vnode.data.domProps || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
-    props = vnode.data.domProps = extend({}, props);
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      elm[key] = '';
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    var key, cur;
+    var elm = vnode.elm;
+    var oldProps = oldVnode.data.domProps || {};
+    var props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
     }
-  }
-
-  for (key in props) {
-    cur = props[key];
-    // ignore children if the node has textContent or innerHTML,
-    // as these will throw away existing DOM nodes and cause removal errors
-    // on subsequent patches (#3360)
-    if (key === 'textContent' || key === 'innerHTML') {
-      if (vnode.children) { vnode.children.length = 0; }
-      if (cur === oldProps[key]) { continue }
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0]);
-      }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                { vnode.children.length = 0; }
+            if (cur === oldProps[key])
+                { continue; }
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            var strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+            var svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
     }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // store value as _value as well since
-      // non-string values will be stringified
-      elm._value = cur;
-      // avoid resetting cursor position when value is the same
-      var strCur = isUndef(cur) ? '' : String(cur);
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur;
-      }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div');
-      svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-      var svg = svgContainer.firstChild;
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild);
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild);
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecessary `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur;
-      } catch (e) {}
-    }
-  }
-}
-
-// check platforms/web/util/attrs.js acceptValue
-
-
-function shouldUpdateValue (elm, checkVal) {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
-}
-
-function isNotInFocusAndDirty (elm, checkVal) {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  var notInFocus = true;
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm; } catch (e) {}
-  return notInFocus && elm.value !== checkVal
 }
-
-function isDirtyWithModifiers (elm, newVal) {
-  var value = elm.value;
-  var modifiers = elm._vModifiers; // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    var notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
     }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    var value = elm.value;
+    var modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
     }
-  }
-  return value !== newVal
+    return value !== newVal;
 }
-
 var domProps = {
-  create: updateDOMProps,
-  update: updateDOMProps
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-/*  */
-
+/* @flow */
 var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  var style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    var style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  var res = {};
-  var styleData;
-
-  if (checkChild) {
-    var childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    var res = {};
+    var styleData;
+    if (checkChild) {
+        var childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  var parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    var parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val);
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-  } else {
-    var normalizedName = normalize(name);
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (var i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i];
-      }
-    } else {
-      el.style[normalizedName] = val;
-    }
-  }
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        var normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (var i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
 };
-
 var vendorNames = ['Webkit', 'Moz', 'ms'];
-
 var emptyStyle;
 var normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style;
-  prop = camelize(prop);
-  if (prop !== 'filter' && (prop in emptyStyle)) {
-    return prop
-  }
-  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-  for (var i = 0; i < vendorNames.length; i++) {
-    var name = vendorNames[i] + capName;
-    if (name in emptyStyle) {
-      return name
-    }
-  }
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (var i = 0; i < vendorNames.length; i++) {
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
 });
-
-function updateStyle (oldVnode, vnode) {
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  var cur, name;
-  var el = vnode.elm;
-  var oldStaticStyle = oldData.staticStyle;
-  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  var oldStyle = oldStaticStyle || oldStyleBinding;
-
-  var style = normalizeStyleBinding(vnode.data.style) || {};
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style;
-
-  var newStyle = getStyle(vnode, true);
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      setProp(el, name, '');
+function updateStyle(oldVnode, vnode) {
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    var cur, name;
+    var el = vnode.elm;
+    var oldStaticStyle = oldData.staticStyle;
+    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    var oldStyle = oldStaticStyle || oldStyleBinding;
+    var style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    var newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
     }
-  }
-  for (name in newStyle) {
-    cur = newStyle[name];
-    if (cur !== oldStyle[name]) {
-      // ie9 setting to null has no effect, must use empty string
-      setProp(el, name, cur == null ? '' : cur);
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
     }
-  }
 }
-
 var style = {
-  create: updateStyle,
-  update: updateStyle
+    create: updateStyle,
+    update: updateStyle,
 };
 
-/*  */
-
+/* @flow */
 var whitespaceRE = /\s+/;
-
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-    } else {
-      el.classList.add(cls);
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+        }
+        else {
+            el.classList.add(cls);
+        }
     }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    if (cur.indexOf(' ' + cls + ' ') < 0) {
-      el.setAttribute('class', (cur + cls).trim());
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
     }
-  }
 }
-
 /**
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-    } else {
-      el.classList.remove(cls);
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class');
-    }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    var tar = ' ' + cls + ' ';
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ');
-    }
-    cur = cur.trim();
-    if (cur) {
-      el.setAttribute('class', cur);
-    } else {
-      el.removeAttribute('class');
-    }
-  }
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-/*  */
-
-function resolveTransition (def$$1) {
-  if (!def$$1) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def$$1 === 'object') {
-    var res = {};
-    if (def$$1.css !== false) {
-      extend(res, autoCssTransition(def$$1.name || 'v'));
+function resolveTransition(def$$1) {
+    if (!def$$1) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def$$1 === 'object') {
+        var res = {};
+        if (def$$1.css !== false) {
+            extend(res, autoCssTransition(def$$1.name || 'v'));
+        }
+        extend(res, def$$1);
+        return res;
+    }
+    else if (typeof def$$1 === 'string') {
+        return autoCssTransition(def$$1);
     }
-    extend(res, def$$1);
-    return res
-  } else if (typeof def$$1 === 'string') {
-    return autoCssTransition(def$$1)
-  }
 }
-
 var autoCssTransition = cached(function (name) {
-  return {
-    enterClass: (name + "-enter"),
-    enterToClass: (name + "-enter-to"),
-    enterActiveClass: (name + "-enter-active"),
-    leaveClass: (name + "-leave"),
-    leaveToClass: (name + "-leave-to"),
-    leaveActiveClass: (name + "-leave-active")
-  }
+    return {
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
+    };
 });
-
 var hasTransition = inBrowser && !isIE9;
 var TRANSITION = 'transition';
 var ANIMATION = 'animation';
-
 // Transition property/event sniffing
 var transitionProp = 'transition';
 var transitionEndEvent = 'transitionend';
 var animationProp = 'animation';
 var animationEndEvent = 'animationend';
 if (hasTransition) {
-  /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    transitionProp = 'WebkitTransition';
-    transitionEndEvent = 'webkitTransitionEnd';
-  }
-  if (window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    animationProp = 'WebkitAnimation';
-    animationEndEvent = 'webkitAnimationEnd';
-  }
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
 }
-
 // binding to window is necessary to make hot reload work in IE in strict mode
 var raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ function (fn) { return fn(); };
-
-function nextFrame (fn) {
-  raf(function () {
-    raf(fn);
-  });
-}
-
-function addTransitionClass (el, cls) {
-  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls);
-    addClass(el, cls);
-  }
-}
-
-function removeTransitionClass (el, cls) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls);
-  }
-  removeClass(el, cls);
-}
-
-function whenTransitionEnds (
-  el,
-  expectedType,
-  cb
-) {
-  var ref = getTransitionInfo(el, expectedType);
-  var type = ref.type;
-  var timeout = ref.timeout;
-  var propCount = ref.propCount;
-  if (!type) { return cb() }
-  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-  var ended = 0;
-  var end = function () {
-    el.removeEventListener(event, onEnd);
-    cb();
-  };
-  var onEnd = function (e) {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end();
-      }
-    }
-  };
-  setTimeout(function () {
-    if (ended < propCount) {
-      end();
-    }
-  }, timeout + 1);
-  el.addEventListener(event, onEnd);
-}
-
-var transformRE = /\b(transform|all)(,|$)/;
-
-function getTransitionInfo (el, expectedType) {
-  var styles = window.getComputedStyle(el);
-  // JSDOM may return undefined for transition properties
-  var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-  var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-  var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-  var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-  var animationTimeout = getTimeout(animationDelays, animationDurations);
-
-  var type;
-  var timeout = 0;
-  var propCount = 0;
-  /* istanbul ignore if */
-  if (expectedType === TRANSITION) {
-    if (transitionTimeout > 0) {
-      type = TRANSITION;
-      timeout = transitionTimeout;
-      propCount = transitionDurations.length;
-    }
-  } else if (expectedType === ANIMATION) {
-    if (animationTimeout > 0) {
-      type = ANIMATION;
-      timeout = animationTimeout;
-      propCount = animationDurations.length;
-    }
-  } else {
-    timeout = Math.max(transitionTimeout, animationTimeout);
-    type = timeout > 0
-      ? transitionTimeout > animationTimeout
-        ? TRANSITION
-        : ANIMATION
-      : null;
-    propCount = type
-      ? type === TRANSITION
-        ? transitionDurations.length
-        : animationDurations.length
-      : 0;
-  }
-  var hasTransform =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property']);
-  return {
-    type: type,
-    timeout: timeout,
-    propCount: propCount,
-    hasTransform: hasTransform
-  }
-}
-
-function getTimeout (delays, durations) {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
-  }
-
-  return Math.max.apply(null, durations.map(function (d, i) {
-    return toMs(d) + toMs(delays[i])
-  }))
-}
-
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs (s) {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
-}
-
-/*  */
-
-function enter (vnode, toggleDisplay) {
-  var el = vnode.elm;
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true;
-    el._leaveCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var enterClass = data.enterClass;
-  var enterToClass = data.enterToClass;
-  var enterActiveClass = data.enterActiveClass;
-  var appearClass = data.appearClass;
-  var appearToClass = data.appearToClass;
-  var appearActiveClass = data.appearActiveClass;
-  var beforeEnter = data.beforeEnter;
-  var enter = data.enter;
-  var afterEnter = data.afterEnter;
-  var enterCancelled = data.enterCancelled;
-  var beforeAppear = data.beforeAppear;
-  var appear = data.appear;
-  var afterAppear = data.afterAppear;
-  var appearCancelled = data.appearCancelled;
-  var duration = data.duration;
-
-  // activeInstance will always be the <transition> component managing this
-  // transition. One edge case to check is when the <transition> is placed
-  // as the root node of a child component. In that case we need to check
-  // <transition>'s parent for appear check.
-  var context = activeInstance;
-  var transitionNode = activeInstance.$vnode;
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context;
-    transitionNode = transitionNode.parent;
-  }
-
-  var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  var startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass;
-  var activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass;
-  var toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass;
-
-  var beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter;
-  var enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
-    : enter;
-  var afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter;
-  var enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
-    : enterCancelled;
-
-  var explicitEnterDuration = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
-  );
-
-  if (explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode);
-  }
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(enterHook);
-
-  var cb = el._enterCb = once(function () {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass);
-      removeTransitionClass(el, activeClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, startClass);
-      }
-      enterCancelledHook && enterCancelledHook(el);
-    } else {
-      afterEnterHook && afterEnterHook(el);
-    }
-    el._enterCb = null;
-  });
-
-  if (!vnode.data.show) {
-    // remove pending leave element on enter by injecting an insert hook
-    mergeVNodeHook(vnode, 'insert', function () {
-      var parent = el.parentNode;
-      var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-      if (pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb();
-      }
-      enterHook && enterHook(el, cb);
-    });
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el);
-  if (expectsCSS) {
-    addTransitionClass(el, startClass);
-    addTransitionClass(el, activeClass);
-    nextFrame(function () {
-      removeTransitionClass(el, startClass);
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass);
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration);
-          } else {
-            whenTransitionEnds(el, type, cb);
-          }
-        }
-      }
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
     });
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay();
-    enterHook && enterHook(el, cb);
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb();
-  }
 }
-
-function leave (vnode, rm) {
-  var el = vnode.elm;
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true;
-    el._enterCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var leaveClass = data.leaveClass;
-  var leaveToClass = data.leaveToClass;
-  var leaveActiveClass = data.leaveActiveClass;
-  var beforeLeave = data.beforeLeave;
-  var leave = data.leave;
-  var afterLeave = data.afterLeave;
-  var leaveCancelled = data.leaveCancelled;
-  var delayLeave = data.delayLeave;
-  var duration = data.duration;
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(leave);
-
-  var explicitLeaveDuration = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
-  );
-
-  if (isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode);
-  }
-
-  var cb = el._leaveCb = once(function () {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null;
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
     }
-    if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass);
-      removeTransitionClass(el, leaveActiveClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass);
-      }
-      leaveCancelled && leaveCancelled(el);
-    } else {
-      rm();
-      afterLeave && afterLeave(el);
-    }
-    el._leaveCb = null;
-  });
-
-  if (delayLeave) {
-    delayLeave(performLeave);
-  } else {
-    performLeave();
-  }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
 
-  function performLeave () {
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
+/* @flow */
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
     }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
     }
-    beforeLeave && beforeLeave(el);
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-      addTransitionClass(el, leaveClass);
-      addTransitionClass(el, leaveActiveClass);
-      nextFrame(function () {
-        removeTransitionClass(el, leaveClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-    leave && leave(el, cb);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
     if (!expectsCSS && !userWantsControl) {
-      cb();
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
     }
-  }
 }
-
 // only used in dev mode
-function checkDuration (val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      "<transition> explicit " + name + " duration is not a valid number - " +
-      "got " + (JSON.stringify(val)) + ".",
-      vnode.context
-    );
-  } else if (isNaN(val)) {
-    warn(
-      "<transition> explicit " + name + " duration is NaN - " +
-      'the duration expression might be incorrect.',
-      vnode.context
-    );
-  }
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn("<transition> explicit " + name + " duration is not a valid number - " +
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
 }
-
-function isValidDuration (val) {
-  return typeof val === 'number' && !isNaN(val)
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
 }
-
 /**
  * Normalize a transition hook's argument length. The hook may be:
  * - a merged hook (invoker) with the original in .fns
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength (fn) {
-  if (isUndef(fn)) {
-    return false
-  }
-  var invokerFns = fn.fns;
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
-    )
-  } else {
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter (_, vnode) {
-  if (vnode.data.show !== true) {
-    enter(vnode);
-  }
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
 }
-
-var transition = inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove: function remove$$1 (vnode, rm) {
-    /* istanbul ignore else */
+function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-      leave(vnode, rm);
-    } else {
-      rm();
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove: function remove$$1(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
     }
-  }
-} : {};
+    : {};
 
-var platformModules = [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-];
-
-/*  */
+var platformModules = [attrs, klass, events, domProps, style, transition];
 
+/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
-
 var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
  * properties to Elements.
  */
-
 /* istanbul ignore if */
 if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', function () {
-    var el = document.activeElement;
-    if (el && el.vmodel) {
-      trigger(el, 'input');
-    }
-  });
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', function () {
+        var el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
 }
-
 var directive = {
-  inserted: function inserted (el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-          directive.componentUpdated(el, binding, vnode);
-        });
-      } else {
-        setSelected(el, binding, vnode.context);
-      }
-      el._vOptions = [].map.call(el.options, getValue);
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers;
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart);
-        el.addEventListener('compositionend', onCompositionEnd);
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd);
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true;
+    inserted: function inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', function () {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
         }
-      }
-    }
-  },
-
-  componentUpdated: function componentUpdated (el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context);
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      var prevOptions = el._vOptions;
-      var curOptions = el._vOptions = [].map.call(el.options, getValue);
-      if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-        // trigger change event if
-        // no matching option found for at least one value
-        var needReset = el.multiple
-          ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-        if (needReset) {
-          trigger(el, 'change');
-        }
-      }
-    }
-  }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated: function componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                // trigger change event if
+                // no matching option found for at least one value
+                var needReset = el.multiple
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
 };
-
-function setSelected (el, binding, vm) {
-  actuallySetSelected(el, binding, vm);
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(function () {
-      actuallySetSelected(el, binding, vm);
-    }, 0);
-  }
-}
-
-function actuallySetSelected (el, binding, vm) {
-  var value = binding.value;
-  var isMultiple = el.multiple;
-  if (isMultiple && !Array.isArray(value)) {
-    warn(
-      "<select multiple v-model=\"" + (binding.expression) + "\"> " +
-      "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
-      vm
-    );
-    return
-  }
-  var selected, option;
-  for (var i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i];
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1;
-      if (option.selected !== selected) {
-        option.selected = selected;
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i;
-        }
-        return
-      }
-    }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1;
-  }
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(function () {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    var value = binding.value;
+    var isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)), vm);
+        return;
+    }
+    var selected, option;
+    for (var i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
 }
-
-function hasNoMatchingOption (value, options) {
-  return options.every(function (o) { return !looseEqual(o, value); })
+function hasNoMatchingOption(value, options) {
+    return options.every(function (o) { return !looseEqual(o, value); });
 }
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
 }
-
-function onCompositionStart (e) {
-  e.target.composing = true;
+function onCompositionStart(e) {
+    e.target.composing = true;
 }
-
-function onCompositionEnd (e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) { return }
-  e.target.composing = false;
-  trigger(e.target, 'input');
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        { return; }
+    e.target.composing = false;
+    trigger(e.target, 'input');
 }
-
-function trigger (el, type) {
-  var e = document.createEvent('HTMLEvents');
-  e.initEvent(type, true, true);
-  el.dispatchEvent(e);
+function trigger(el, type) {
+    var e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-/*  */
-
+/* @flow */
 // recursively search for possible transition defined inside the component root
-function locateNode (vnode) {
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
-    : vnode
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
 }
-
 var show = {
-  bind: function bind (el, ref, vnode) {
-    var value = ref.value;
-
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    var originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display;
-    if (value && transition$$1) {
-      vnode.data.show = true;
-      enter(vnode, function () {
-        el.style.display = originalDisplay;
-      });
-    } else {
-      el.style.display = value ? originalDisplay : 'none';
-    }
-  },
-
-  update: function update (el, ref, vnode) {
-    var value = ref.value;
-    var oldValue = ref.oldValue;
-
-    /* istanbul ignore if */
-    if (!value === !oldValue) { return }
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    if (transition$$1) {
-      vnode.data.show = true;
-      if (value) {
-        enter(vnode, function () {
-          el.style.display = el.__vOriginalDisplay;
-        });
-      } else {
-        leave(vnode, function () {
-          el.style.display = 'none';
-        });
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none';
-    }
-  },
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition$$1) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
 
-  unbind: function unbind (
-    el,
-    binding,
-    vnode,
-    oldVnode,
-    isDestroy
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay;
-    }
-  }
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            { return; }
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        if (transition$$1) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, function () {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
 var platformDirectives = {
-  model: directive,
-  show: show
+    model: directive,
+    show: show,
 };
 
-/*  */
-
+/* @flow */
 var transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
 };
-
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode) {
-  var compOptions = vnode && vnode.componentOptions;
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-function extractTransitionData (comp) {
-  var data = {};
-  var options = comp.$options;
-  // props
-  for (var key in options.propsData) {
-    data[key] = comp[key];
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  var listeners = options._parentListeners;
-  for (var key$1 in listeners) {
-    data[camelize(key$1)] = listeners[key$1];
-  }
-  return data
-}
-
-function placeholder (h, rawChild) {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
+function getRealChild(vnode) {
+    var compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    var data = {};
+    var options = comp.$options;
+    // props
+    for (var key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    var listeners = options._parentListeners;
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
 }
-
-function hasParentTransition (vnode) {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
     }
-  }
 }
-
-function isSameChild (child, oldChild) {
-  return oldChild.key === child.key && oldChild.tag === child.tag
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-
 var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
 var isVShowDirective = function (d) { return d.name === 'show'; };
-
 var Transition = {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render: function render (h) {
-    var this$1 = this;
-
-    var children = this.$slots.default;
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode);
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      );
-    }
-
-    var mode = this.mode;
-
-    // warn invalid mode
-    if (mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      );
-    }
-
-    var rawChild = children[0];
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    var child = getRealChild(rawChild);
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    var id = "__transition-" + (this._uid) + "-";
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key;
-
-    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-    var oldRawChild = this._vnode;
-    var oldChild = getRealChild(oldRawChild);
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true;
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      var oldData = oldChild.data.transition = extend({}, data);
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true;
-        mergeVNodeHook(oldData, 'afterLeave', function () {
-          this$1._leaving = false;
-          this$1.$forceUpdate();
-        });
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
-        }
-        var delayedLeave;
-        var performLeave = function () { delayedLeave(); };
-        mergeVNodeHook(data, 'afterEnter', performLeave);
-        mergeVNodeHook(data, 'enterCancelled', performLeave);
-        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-      }
-    }
-
-    return rawChild
-  }
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render: function render(h) {
+        var this$1 = this;
+
+        var children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        var mode = this.mode;
+        // warn invalid mode
+        if (mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        var rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        var child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        var id = "__transition-" + (this._uid) + "-";
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        var oldRawChild = this._vnode;
+        var oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            var oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', function () {
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                var delayedLeave;
+                var performLeave = function () {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-/*  */
-
+// Provides transition support for list items.
 var props = extend({
-  tag: String,
-  moveClass: String
+    tag: String,
+    moveClass: String,
 }, transitionProps);
-
+// @ts-ignore
 delete props.mode;
-
 var TransitionGroup = {
-  props: props,
-
-  beforeMount: function beforeMount () {
-    var this$1 = this;
-
-    var update = this._update;
-    this._update = function (vnode, hydrating) {
-      var restoreActiveInstance = setActiveInstance(this$1);
-      // force removing pass
-      this$1.__patch__(
-        this$1._vnode,
-        this$1.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      );
-      this$1._vnode = this$1.kept;
-      restoreActiveInstance();
-      update.call(this$1, vnode, hydrating);
-    };
-  },
-
-  render: function render (h) {
-    var tag = this.tag || this.$vnode.data.tag || 'span';
-    var map = Object.create(null);
-    var prevChildren = this.prevChildren = this.children;
-    var rawChildren = this.$slots.default || [];
-    var children = this.children = [];
-    var transitionData = extractTransitionData(this);
-
-    for (var i = 0; i < rawChildren.length; i++) {
-      var c = rawChildren[i];
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c);
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData;
-        } else {
-          var opts = c.componentOptions;
-          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-          warn(("<transition-group> children must be keyed: <" + name + ">"));
-        }
-      }
-    }
-
-    if (prevChildren) {
-      var kept = [];
-      var removed = [];
-      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-        var c$1 = prevChildren[i$1];
-        c$1.data.transition = transitionData;
-        c$1.data.pos = c$1.elm.getBoundingClientRect();
-        if (map[c$1.key]) {
-          kept.push(c$1);
-        } else {
-          removed.push(c$1);
-        }
-      }
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated: function updated () {
-    var children = this.prevChildren;
-    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs);
-    children.forEach(recordPosition);
-    children.forEach(applyTranslation);
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight;
-
-    children.forEach(function (c) {
-      if (c.data.moved) {
-        var el = c.elm;
-        var s = el.style;
-        addTransitionClass(el, moveClass);
-        s.transform = s.WebkitTransform = s.transitionDuration = '';
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb);
-            el._moveCb = null;
-            removeTransitionClass(el, moveClass);
-          }
+    props: props,
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
+        var update = this._update;
+        this._update = function (vnode, hydrating) {
+            var restoreActiveInstance = setActiveInstance(this$1);
+            // force removing pass
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this$1._vnode = this$1.kept;
+            restoreActiveInstance();
+            update.call(this$1, vnode, hydrating);
+        };
+    },
+    render: function render(h) {
+        var tag = this.tag || this.$vnode.data.tag || 'span';
+        var map = Object.create(null);
+        var prevChildren = (this.prevChildren = this.children);
+        var rawChildren = this.$slots.default || [];
+        var children = (this.children = []);
+        var transitionData = extractTransitionData(this);
+        for (var i = 0; i < rawChildren.length; i++) {
+            var c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else {
+                    var opts = c.componentOptions;
+                    var name = opts
+                        ? opts.Ctor.options.name || opts.tag || ''
+                        : c.tag;
+                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                }
+            }
+        }
+        if (prevChildren) {
+            var kept = [];
+            var removed = [];
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
+                // @ts-ignore
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                // @ts-ignore
+                if (map[c$1.key]) {
+                    kept.push(c$1);
+                }
+                else {
+                    removed.push(c$1);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated: function updated() {
+        var children = this.prevChildren;
+        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach(function (c) {
+            // @ts-ignore
+            if (c.data.moved) {
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
         });
-      }
-    });
-  },
-
-  methods: {
-    hasMove: function hasMove (el, moveClass) {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      var clone = el.cloneNode();
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
-      }
-      addClass(clone, moveClass);
-      clone.style.display = 'none';
-      this.$el.appendChild(clone);
-      var info = getTransitionInfo(clone);
-      this.$el.removeChild(clone);
-      return (this._hasMove = info.hasTransform)
-    }
-  }
+    },
+    methods: {
+        hasMove: function hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            var clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach(function (cls) {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = 'none';
+            this.$el.appendChild(clone);
+            var info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
 };
-
-function callPendingCbs (c) {
-  /* istanbul ignore if */
-  if (c.elm._moveCb) {
-    c.elm._moveCb();
-  }
-  /* istanbul ignore if */
-  if (c.elm._enterCb) {
-    c.elm._enterCb();
-  }
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._moveCb) {
+        //@ts-ignore
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._enterCb) {
+        //@ts-ignore
+        c.elm._enterCb();
+    }
 }
-
-function recordPosition (c) {
-  c.data.newPos = c.elm.getBoundingClientRect();
+function recordPosition(c) {
+    //@ts-ignore
+    c.data.newPos = c.elm.getBoundingClientRect();
 }
-
-function applyTranslation (c) {
-  var oldPos = c.data.pos;
-  var newPos = c.data.newPos;
-  var dx = oldPos.left - newPos.left;
-  var dy = oldPos.top - newPos.top;
-  if (dx || dy) {
-    c.data.moved = true;
-    var s = c.elm.style;
-    s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-    s.transitionDuration = '0s';
-  }
+function applyTranslation(c) {
+    //@ts-ignore
+    var oldPos = c.data.pos;
+    //@ts-ignore
+    var newPos = c.data.newPos;
+    var dx = oldPos.left - newPos.left;
+    var dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        //@ts-ignore
+        c.data.moved = true;
+        //@ts-ignore
+        var s = c.elm.style;
+        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+        s.transitionDuration = '0s';
+    }
 }
 
 var platformComponents = {
-  Transition: Transition,
-  TransitionGroup: TransitionGroup
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
 };
 
-/*  */
-
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp;
 Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
 Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
-
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
 extend(Vue.options.components, platformComponents);
-
 // install platform patch function
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
 // public mount method
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && inBrowser ? query(el) : undefined;
-  return mountComponent(this, el, hydrating)
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
 };
-
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-  setTimeout(function () {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue);
-      } else {
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
-        );
-      }
-    }
-    if (config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      console[console.info ? 'info' : 'log'](
-        "You are running Vue in development mode.\n" +
-        "Make sure to turn on production mode when deploying for production.\n" +
-        "See more tips at https://vuejs.org/guide/deployment.html"
-      );
-    }
-  }, 0);
+    setTimeout(function () {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                "Make sure to turn on production mode when deploying for production.\n" +
+                "See more tips at https://vuejs.org/guide/deployment.html");
+        }
+    }, 0);
 }
 
-/*  */
+/* @flow */
 
 module.exports = Vue;
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
index 2183ff42fc8..7a24ee33c65 100644
--- a/dist/vue.runtime.common.prod.js
+++ b/dist/vue.runtime.common.prod.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R,U="__proto__"in{},H="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=B&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0,X=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===V),G=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Z={}.watch,J=!1;if(H)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===R&&(R=!H&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),R},tt=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var pt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=ht[t];M(mt,t,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i})});var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(U?(e=mt,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var xt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&Ot(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?Ot(r,o):o}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}xt.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},P.forEach(function(t){xt[t]=St}),N.forEach(function(t){xt[t+"s"]=Et}),xt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},xt.provide=kt;var jt=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Tt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=xt[r]||jt;a[r]=o(t[r],e[r],n,r)}return a}function It(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Dt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Lt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Lt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}function Nt(t){var e=t&&t.toString().match(/^\s*function (\w+)/);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e,null,"config.errorHandler")}Ut(t,e,n)}function Ut(t,e,n){if(!H&&!B||"undefined"==typeof console)throw t;console.error(t)}var Ht,Bt=!1,Vt=[],zt=!1;function Wt(){zt=!1;var t=Vt.slice(0);Vt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Ht=function(){qt.then(Wt),X&&setTimeout(k)},Bt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ht="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Ht=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Bt=!0}function Zt(t,e){var n;if(Vt.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Ht()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function pe(t,e){var r,o,a,s,c;if(Array.isArray(t)||"string"==typeof t)for(r=new Array(t.length),o=0,a=t.length;o<a;o++)r[o]=e(t[o],o);else if("number"==typeof t)for(r=new Array(t),o=0;o<t;o++)r[o]=e(o+1,o);else if(i(t))if(rt&&t[Symbol.iterator]){r=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)r.push(e(l.value,r.length)),l=u.next()}else for(s=Object.keys(t),r=new Array(s.length),o=0,a=s.length;o<a;o++)c=s[o],r[o]=e(t[c],c,o);return n(r)||(r=[]),r._isVList=!0,r}function de(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return It(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?he(o,r):i?he(i,t):r?$(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?we(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ae(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=l,t._l=pe,t._t=de,t._q=j,t._i=T,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=pt,t._u=we,t._g=$e,t._d=Ae,t._p=xe}function ke(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Le(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Le(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ee(t,e){for(var n in e)t[_(n)]=e[n]}Oe(ke.prototype);var je={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;je.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Dt(d,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},Te=Object.keys(je);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I(function(e){t.resolved=Re(e,o),c?s.length=0:p(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,p(!0))}),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Dt(l,u,r||t);else n(o.attrs)&&Ee(c,o.attrs),n(o.props)&&Ee(c,o.props);var f=new ke(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Se(p,o,f.parent,s);if(Array.isArray(p)){for(var d=oe(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Se(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Te.length;n++){var r=Te[n],o=e[r],i=je[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Pe=2;function Le(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Pe),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return pt();n(a)&&n(a.is)&&(o=a.is);if(!o)return pt();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Pe?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=It(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):pt()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function He(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function Be(t,e){Me.$on(t,e)}function Ve(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},Be,Ve,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(H&&!W){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var cn=0,un=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};un.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},un.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},un.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},un.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},un.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},un.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},un.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},un.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var ln={enumerable:!0,configurable:!0,get:k,set:k};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function pn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Dt(i,e,n,t);$t(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(var n in e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||k,k,dn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var dn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=k):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):k,ln.set=n.set||k),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Tt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Tt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function $n(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function An(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=$n(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Le(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Le(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(function(n){$t(t,n,e[n])}),_t(!0))}(n),pn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate)try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=pt()),t.parent=o,t}}(bn);var On=[String,RegExp,Array],kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:On,exclude:On,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){An(t,function(t){return wn(e,t)})}),this.$watch("exclude",function(e){An(t,function(t){return!wn(e,t)})})},render:function(){var t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){var r=$n(n),o=this.include,i=this.exclude;if(o&&(!r||!wn(o,r))||i&&r&&wn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Zt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,kn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:ke}),bn.version="2.6.12";var Sn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=p("contenteditable,draggable,spellcheck"),Tn=p("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true"},Dn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Pn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Ln=function(t){return Pn(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Hn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Hn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Hn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Vn(t)||zn(t)};var qn=Object.create(null);var Kn=p("text,number,password,search,email,tel,url");var Xn=Object.freeze({createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=It(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a);for(i in(W||K)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Pn(i)?s.removeAttributeNS(Nn,Ln(i)):jn(i)||s.removeAttribute(i))}}function ur(t,e,n){t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):jn(e)?t.setAttribute(e,In(e,n)):Pn(e)?Mn(n)?t.removeAttributeNS(Nn,Ln(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function pr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Hn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var dr,vr={create:pr,update:pr},hr="__r",mr="__c";function yr(t,e,n){var r=dr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Bt&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}dr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||dr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};dr=r.elm,function(t){if(n(t[hr])){var e=W?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),dr=void 0}}var $r,wr={create:Cr,update:Cr};function Ar(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:Ar,update:Ar},kr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?O(t):"string"==typeof t?kr(t):t}var jr,Tr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(Tr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty($(e),n.replace(Ir,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Pr=y(function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in jr)return r}});function Lr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=Er(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Dr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Lr,update:Lr},Fr=/\s+/;function Rr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Hr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Vr=H&&!q,zr="transition",Wr="animation",qr="transition",Kr="transitionend",Xr="animation",Gr="animationend";Vr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(qr="WebkitTransition",Kr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Xr="WebkitAnimation",Gr="webkitAnimationEnd"));var Zr=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Jr(t){Zr(function(){Zr(t)})}function Qr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Rr(t,e))}function Yr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Ur(t,e)}function to(t,e,n){var r=no(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===zr?Kr:Gr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var eo=/\b(transform|all)(,|$)/;function no(t,e){var n,r=window.getComputedStyle(t),o=(r[qr+"Delay"]||"").split(", "),i=(r[qr+"Duration"]||"").split(", "),a=ro(o,i),s=(r[Xr+"Delay"]||"").split(", "),c=(r[Xr+"Duration"]||"").split(", "),u=ro(s,c),l=0,f=0;return e===zr?a>0&&(n=zr,l=a,f=i.length):e===Wr?u>0&&(n=Wr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?zr:Wr:null)?n===zr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===zr&&eo.test(r[qr+"Property"])}}function ro(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return oo(e)+oo(t[n])}))}function oo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function io(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Hr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=qe,O=qe.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=co(D),R=o._enterCb=I(function(){M&&(Yr(o,j),Yr(o,E)),R.cancelled?(M&&Yr(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Qr(o,S),Qr(o,E),Jr(function(){Yr(o,S),R.cancelled||(Qr(o,j),F||(so(L)?setTimeout(R,L):to(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function ao(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Hr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=co(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Yr(o,l),Yr(o,p)),$.cancelled?(_&&Yr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Qr(o,u),Qr(o,p),Jr(function(){Yr(o,u),$.cancelled||(Qr(o,l),b||(so(C)?setTimeout($,C):to(o,c,$)))})),v&&v(o,$),_||b||$())}}function so(t){return"number"==typeof t&&!isNaN(t)}function co(t){if(e(t))return!1;var r=t.fns;return n(r)?co(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function uo(t,e){!0!==e.data.show&&io(e)}var lo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:Yn(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):Yn(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):Yn(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=tr(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):Yn(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&Yn(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Jn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,wr,Or,Mr,H?{create:uo,activate:uo,remove:function(t,e){!0!==t.data.show?ao(t,e):e()}}:{}].concat(sr)});q&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&_o(t,"input")});var fo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){fo.componentUpdated(t,e,n)}):po(t,e,n.context),t._vOptions=[].map.call(t.options,mo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",yo),t.addEventListener("compositionend",go),t.addEventListener("change",go),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){po(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,mo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return ho(t,o)}):e.value!==e.oldValue&&ho(e.value,o))&&_o(t,"change")}}};function po(t,e,n){vo(t,e,n),(W||K)&&setTimeout(function(){vo(t,e,n)},0)}function vo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,mo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(mo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function ho(t,e){return e.every(function(e){return!j(e,t)})}function mo(t){return"_value"in t?t._value:t.value}function yo(t){t.target.composing=!0}function go(t){t.target.composing&&(t.target.composing=!1,_o(t.target,"input"))}function _o(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function bo(t){return!t.componentInstance||t.data&&t.data.transition?t:bo(t.componentInstance._vnode)}var Co={model:fo,show:{bind:function(t,e,n){var r=e.value,o=(n=bo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,io(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=bo(n)).data&&n.data.transition?(n.data.show=!0,r?io(n,function(){t.style.display=t.__vOriginalDisplay}):ao(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},$o={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function wo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?wo(He(e.children)):t}function Ao(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function xo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Oo=function(t){return t.tag||Ue(t)},ko=function(t){return"show"===t.name},So={name:"transition",props:$o,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Oo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=wo(i);if(!a)return i;if(this._leaving)return xo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ao(this),u=this._vnode,l=wo(u);if(a.data.directives&&a.data.directives.some(ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),xo(t,i);if("in-out"===r){if(Ue(a))return u;var p,d=function(){p()};ne(c,"afterEnter",d),ne(c,"enterCancelled",d),ne(f,"delayLeave",function(t){p=t})}}return i}}},Eo=x({tag:String,moveClass:String},$o);function jo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function To(t){t.data.newPos=t.elm.getBoundingClientRect()}function Io(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Eo.mode;var Do={Transition:So,TransitionGroup:{props:Eo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ao(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(jo),t.forEach(To),t.forEach(Io),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Qr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Kr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Kr,t),n._moveCb=null,Yr(n,e))})}}))},methods:{hasMove:function(t,e){if(!Vr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Ur(n,t)}),Rr(n,e),n.style.display="none",this.$el.appendChild(n);var r=no(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};bn.config.mustUseProp=function(t,e,n){return"value"===n&&En(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!H)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Co),x(bn.options.components,Do),bn.prototype.__patch__=H?lo:k,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&H?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},H&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",bn)},0),module.exports=bn;
\ No newline at end of file
+"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R,U="__proto__"in{},H="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=B&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0,X=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===V),G=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Z={}.watch,J=!1;if(H)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===R&&(R=!H&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),R},tt=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var pt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=ht[t];M(mt,t,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i})});var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(U?(e=mt,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var xt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&Ot(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?Ot(r,o):o}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}xt.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},P.forEach(function(t){xt[t]=St}),N.forEach(function(t){xt[t+"s"]=Et}),xt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},xt.provide=kt;var jt=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Tt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=xt[r]||jt;a[r]=o(t[r],e[r],n,r)}return a}function It(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Dt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Mt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Mt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Pt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Nt=/^\s*function (\w+)/;function Pt(t){var e=t&&t.toString().match(Nt);return e?e[1]:""}function Lt(t,e){return Pt(t)===Pt(e)}function Mt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Ft(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Ut(t,r,"errorCaptured hook")}}Ut(t,e,n)}finally{ut()}}function Rt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Ft(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Ft(t,r,o)}return i}function Ut(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e,null,"config.errorHandler")}Ht(t,e,n)}function Ht(t,e,n){if(!H&&!B||"undefined"==typeof console)throw t;console.error(t)}var Bt,Vt=!1,zt=[],Wt=!1;function qt(){Wt=!1;var t=zt.slice(0);zt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Kt=Promise.resolve();Bt=function(){Kt.then(qt),X&&setTimeout(k)},Vt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(qt)}:function(){setTimeout(qt,0)};else{var Xt=1,Gt=new MutationObserver(qt),Zt=document.createTextNode(String(Xt));Gt.observe(Zt,{characterData:!0}),Bt=function(){Xt=(Xt+1)%2,Zt.data=String(Xt)},Vt=!0}function Jt(t,e){var n;if(zt.push(function(){if(t)try{t.call(e)}catch(t){Ft(t,e,"nextTick")}else n&&n(e)}),Wt||(Wt=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Qt=new nt;function Yt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Qt),Qt.clear()}var te=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function ee(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Rt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Rt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ne(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=te(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=ee(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=te(c)).name,n[c],f.capture)}function re(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=ee([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=ee([s,c]),a.merged=!0,t[o]=a}function oe(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ie(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ae((u=t(u,(a||"")+"_"+c))[0])&&ae(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ae(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ae(u)&&ae(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ae(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function ce(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ue)&&delete n[u];return n}function ue(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=fe(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=pe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function fe(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ie(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function pe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ve(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function he(t){return It(this.$options,"filters",t)||E}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?me(o,r):i?me(i,t):r?$(r)!==e:void 0}function ge(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function _e(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(Ce(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function be(t,e,n){return Ce(t,"__once__"+e+(n?"_"+n:""),!0),t}function Ce(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&$e(t[r],e+"_"+r,n);else $e(t,e,n)}function $e(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function xe(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Oe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=be,t._n=f,t._s=l,t._l=de,t._t=ve,t._q=j,t._i=T,t._m=_e,t._f=he,t._k=ye,t._b=ge,t._v=dt,t._e=pt,t._u=Ae,t._g=we,t._d=xe,t._p=Oe}function Se(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=se(u.inject,i),this.slots=function(){return c.$slots||le(e.scopedSlots,c.$slots=ce(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Me(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Me(s,t,e,n,r,f)}}function Ee(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function je(t,e){for(var n in e)t[_(n)]=e[n]}ke(Se.prototype);var Te={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Te.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Dt(d,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,qe(e,r,h),u&&(e.$slots=ce(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Je(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Ye.push(e)):Ze(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Ge(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Je(e,"deactivated")}}(e,!0):e.$destroy())}},Ie=Object.keys(Te);function De(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Re;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I(function(e){t.resolved=Ue(e,o),c?s.length=0:p(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,p(!0))}),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=Ue(m.error,o)),n(m.loading)&&(t.loadingComp=Ue(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},bn(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);oe(a,c,u,l,!0)||oe(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Dt(l,u,r||t);else n(o.attrs)&&je(c,o.attrs),n(o.props)&&je(c,o.props);var f=new Se(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Ee(p,o,f.parent,s);if(Array.isArray(p)){for(var d=ie(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Ee(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Ie.length;n++){var r=Ie[n],o=e[r],i=Te[r];o===i||o&&o._merged||(e[r]=o?Ne(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function Ne(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Pe=1,Le=2;function Me(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return pt();n(a)&&n(a.is)&&(o=a.is);if(!o)return pt();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=ie(s):c===Pe&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=It(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):De(f,a,t,s,o)}else u=De(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Yt(t.style);i(t.class)&&Yt(t.class)}(a),u):pt()}(t,a,s,c,u)}var Fe,Re=null;function Ue(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function He(t){return t.isComment&&t.asyncFactory}function Be(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||He(r)))return r}}function Ve(t,e){Fe.$on(t,e)}function ze(t,e){Fe.$off(t,e)}function We(t,e){var n=Fe;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function qe(t,e,n){Fe=t,ne(e,n||{},Ve,ze,We,t),Fe=void 0}var Ke=null;function Xe(t){var e=Ke;return Ke=t,function(){Ke=e}}function Ge(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ze(t,e){if(e){if(t._directInactive=!1,Ge(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ze(t.$children[n]);Je(t,"activated")}}function Je(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Rt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Qe=[],Ye=[],tn={},en=!1,nn=!1,rn=0;var on=0,an=Date.now;if(H&&!W){var sn=window.performance;sn&&"function"==typeof sn.now&&an()>document.createEvent("Event").timeStamp&&(an=function(){return sn.now()})}function cn(){var t,e;for(on=an(),nn=!0,Qe.sort(function(t,e){return t.id-e.id}),rn=0;rn<Qe.length;rn++)(t=Qe[rn]).before&&t.before(),e=t.id,tn[e]=null,t.run();var n=Ye.slice(),r=Qe.slice();rn=Qe.length=Ye.length=0,tn={},en=nn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ze(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Je(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var un=0,ln=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};ln.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ft(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Yt(t),ut(),this.cleanupDeps()}return t},ln.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},ln.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},ln.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==tn[e]){if(tn[e]=!0,nn){for(var n=Qe.length-1;n>rn&&Qe[n].id>t.id;)n--;Qe.splice(n+1,0,t)}else Qe.push(t);en||(en=!0,Jt(cn))}}(this)},ln.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ft(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},ln.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},ln.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},ln.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var fn={enumerable:!0,configurable:!0,get:k,set:k};function pn(t,e,n){fn.get=function(){return this[e][n]},fn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,fn)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Dt(i,e,n,t);$t(r,i,a),i in t||pn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(var n in e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Ft(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&pn(t,"_data",i))}var a;Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new ln(t,a||k,k,vn)),o in t||hn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)gn(t,n,r[o]);else gn(t,n,r)}}(t,e.watch)}var vn={lazy:!0};function hn(t,e,n){var r=!Y();"function"==typeof n?(fn.get=r?mn(e):yn(n),fn.set=k):(fn.get=n.get?r&&!1!==n.cache?mn(e):yn(n.get):k,fn.set=n.set||k),Object.defineProperty(t,e,fn)}function mn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function yn(t){return function(){return t.call(this,this)}}function gn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var _n=0;function bn(t){var e=t.options;if(t.super){var n=bn(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Tt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function Cn(t){this._init(t)}function $n(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Tt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)pn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)hn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function xn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&On(n,i,r,o)}}}function On(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=_n++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(bn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&qe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=ce(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Me(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Me(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Je(n,"beforeCreate"),function(t){var e=se(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(function(n){$t(t,n,e[n])}),_t(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Je(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(Cn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return gn(this,t,e,n);(n=n||{}).user=!0;var r=new ln(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Ft(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(Cn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Rt(e[o],this,n,this,r)}return this}}(Cn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Xe(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Je(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Je(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(Cn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Jt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=le(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Re=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ft(n,e,"render"),t=e._vnode}finally{Re=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=pt()),t.parent=o,t}}(Cn);var kn=[String,RegExp,Array],Sn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)On(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){xn(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){xn(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Jt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,Sn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),$n(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(Cn),Object.defineProperty(Cn.prototype,"$isServer",{get:Y}),Object.defineProperty(Cn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Cn,"FunctionalRenderContext",{value:Se}),Cn.version="2.6.12";var En=p("style,class"),jn=p("input,textarea,option,select,progress"),Tn=p("contenteditable,draggable,spellcheck"),In=p("events,caret,typing,plaintext-only"),Dn=function(t,e){return Fn(e)||"false"===e?"false":"contenteditable"===t&&In(e)?e:"true"},Nn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Pn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Mn=function(t){return Ln(t)?t.slice(6,t.length):""},Fn=function(t){return null==t||!1===t};function Rn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Un(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Un(e,r.data));return function(t,e){if(n(t)||n(e))return Hn(t,Bn(e));return""}(e.staticClass,e.class)}function Un(t,e){return{staticClass:Hn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Hn(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Bn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Wn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),qn=function(t){return zn(t)||Wn(t)};var Kn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Vn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create:function(t,e){Jn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Jn(t,!0),Jn(e))},destroy:function(t){Jn(t,!0)}};function Jn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Qn=new lt("",{},[]),Yn=["create","activate","update","remove","destroy"];function tr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Xn(o)&&Xn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function er(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var nr={create:rr,update:rr,destroy:function(t){rr(t,Qn)}};function rr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Qn,a=e===Qn,s=ir(t.data.directives,t.context),c=ir(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,sr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(sr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)sr(u[n],"inserted",e,t)};i?re(e,"insert",f):f()}l.length&&re(e,"postpatch",function(){for(var n=0;n<l.length;n++)sr(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||sr(s[n],"unbind",t,t,a)}(t,e)}var or=Object.create(null);function ir(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=or),o[ar(r)]=r,r.def=It(e.$options,"directives",r.name);return o}function ar(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function sr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ft(r,n.context,"directive "+t.name+" "+e+" hook")}}var cr=[Zn,nr];function ur(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&lr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&lr(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Pn,Mn(i)):Tn(i)||s.removeAttribute(i))}}function lr(t,e,n,r){r||t.tagName.indexOf("-")>-1?fr(t,e,n):Nn(e)?Fn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,Dn(e,n)):Ln(e)?Fn(n)?t.removeAttributeNS(Pn,Mn(e)):t.setAttributeNS(Pn,e,n):fr(t,e,n)}function fr(t,e,n){if(Fn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var pr={create:ur,update:ur};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Rn(r),c=o._transitionClasses;n(c)&&(s=Hn(s,Bn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var vr,hr={create:dr,update:dr},mr="__r",yr="__c";function gr(t,e,n){var r=vr;return function o(){null!==e.apply(null,arguments)&&Cr(t,o,n,r)}}var _r=Vt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var o=on,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}vr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||vr).removeEventListener(t,e._wrapper||e,n)}function $r(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};vr=r.elm,function(t){if(n(t[mr])){var e=W?"change":"input";t[e]=[].concat(t[mr],t[e]||[]),delete t[mr]}n(t[yr])&&(t.change=[].concat(t[yr],t.change||[]),delete t[yr])}(o),ne(o,i,br,Cr,gr,r.context),vr=void 0}}var wr,Ar={create:$r,update:$r};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Wn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:xr,update:xr},Sr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?O(t):"string"==typeof t?Sr(t):t}var Tr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty($(e),n.replace(Dr,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Lr=y(function(t){if(Tr=Tr||document.createElement("div").style,"filter"!==(t=_(t))&&t in Tr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Tr)return r}});function Mr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=jr(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Nr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Br(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Vr(t.name||"v")),x(e,t),e}return"string"==typeof t?Vr(t):void 0}}var Vr=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),zr=H&&!q,Wr="transition",qr="animation",Kr="transition",Xr="transitionend",Gr="animation",Zr="animationend";zr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Kr="WebkitTransition",Xr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Gr="WebkitAnimation",Zr="webkitAnimationEnd"));var Jr=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Qr(t){Jr(function(){Jr(t)})}function Yr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Ur(t,e))}function to(t,e){t._transitionClasses&&v(t._transitionClasses,e),Hr(t,e)}function eo(t,e,n){var r=ro(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Wr?Xr:Zr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var no=/\b(transform|all)(,|$)/;function ro(t,e){var n,r=window.getComputedStyle(t),o=(r[Kr+"Delay"]||"").split(", "),i=(r[Kr+"Duration"]||"").split(", "),a=oo(o,i),s=(r[Gr+"Delay"]||"").split(", "),c=(r[Gr+"Duration"]||"").split(", "),u=oo(s,c),l=0,f=0;return e===Wr?a>0&&(n=Wr,l=a,f=i.length):e===qr?u>0&&(n=qr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Wr:qr:null)?n===Wr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Wr&&no.test(r[Kr+"Property"])}}function oo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return io(e)+io(t[n])}))}function io(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ao(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Br(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ke,O=Ke.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=uo(D),R=o._enterCb=I(function(){M&&(to(o,j),to(o,E)),R.cancelled?(M&&to(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||re(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Yr(o,S),Yr(o,E),Qr(function(){to(o,S),R.cancelled||(Yr(o,j),F||(co(L)?setTimeout(R,L):eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function so(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Br(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=uo(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(to(o,l),to(o,p)),$.cancelled?(_&&to(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Yr(o,u),Yr(o,p),Qr(function(){to(o,u),$.cancelled||(Yr(o,l),b||(co(C)?setTimeout($,C):eo(o,c,$)))})),v&&v(o,$),_||b||$())}}function co(t){return"number"==typeof t&&!isNaN(t)}function uo(t){if(e(t))return!1;var r=t.fns;return n(r)?uo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function lo(t,e){!0!==e.data.show&&ao(e)}var fo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Yn.length;++i)for(s[Yn[i]]=[],a=0;a<c.length;++a)n(c[a][Yn[i]])&&s[Yn[i]].push(c[a][Yn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Qn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Jn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Qn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Qn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&tr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:tr(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):tr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):tr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):tr(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=er(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):tr(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Yt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&tr(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Qn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Jn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Gn,modules:[pr,hr,Ar,kr,Fr,H?{create:lo,activate:lo,remove:function(t,e){!0!==t.data.show?so(t,e):e()}}:{}].concat(cr)});q&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&bo(t,"input")});var po={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?re(n,"postpatch",function(){po.componentUpdated(t,e,n)}):vo(t,e,n.context),t._vOptions=[].map.call(t.options,yo)):("textarea"===n.tag||Xn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",go),t.addEventListener("compositionend",_o),t.addEventListener("change",_o),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){vo(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,yo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return mo(t,o)}):e.value!==e.oldValue&&mo(e.value,o))&&bo(t,"change")}}};function vo(t,e,n){ho(t,e,n),(W||K)&&setTimeout(function(){ho(t,e,n)},0)}function ho(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,yo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(yo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function mo(t,e){return e.every(function(e){return!j(e,t)})}function yo(t){return"_value"in t?t._value:t.value}function go(t){t.target.composing=!0}function _o(t){t.target.composing&&(t.target.composing=!1,bo(t.target,"input"))}function bo(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Co(t){return!t.componentInstance||t.data&&t.data.transition?t:Co(t.componentInstance._vnode)}var $o={model:po,show:{bind:function(t,e,n){var r=e.value,o=(n=Co(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,ao(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=Co(n)).data&&n.data.transition?(n.data.show=!0,r?ao(n,function(){t.style.display=t.__vOriginalDisplay}):so(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},wo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ao(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ao(Be(e.children)):t}function xo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Oo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var ko=function(t){return t.tag||He(t)},So=function(t){return"show"===t.name},Eo={name:"transition",props:wo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(ko)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Ao(i);if(!a)return i;if(this._leaving)return Oo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=xo(this),u=this._vnode,l=Ao(u);if(a.data.directives&&a.data.directives.some(So)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!He(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,re(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Oo(t,i);if("in-out"===r){if(He(a))return u;var p,d=function(){p()};re(c,"afterEnter",d),re(c,"enterCancelled",d),re(f,"delayLeave",function(t){p=t})}}return i}}},jo=x({tag:String,moveClass:String},wo);function To(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Io(t){t.data.newPos=t.elm.getBoundingClientRect()}function Do(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete jo.mode;var No={Transition:Eo,TransitionGroup:{props:jo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Xe(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=xo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(To),t.forEach(Io),t.forEach(Do),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Yr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Xr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Xr,t),n._moveCb=null,to(n,e))})}}))},methods:{hasMove:function(t,e){if(!zr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Hr(n,t)}),Ur(n,e),n.style.display="none",this.$el.appendChild(n);var r=ro(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};Cn.config.mustUseProp=function(t,e,n){return"value"===n&&jn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},Cn.config.isReservedTag=qn,Cn.config.isReservedAttr=En,Cn.config.getTagNamespace=function(t){return Wn(t)?"svg":"math"===t?"math":void 0},Cn.config.isUnknownElement=function(t){if(!H)return!0;if(qn(t))return!1;if(t=t.toLowerCase(),null!=Kn[t])return Kn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Kn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Kn[t]=/HTMLUnknownElement/.test(e.toString())},x(Cn.options.directives,$o),x(Cn.options.components,No),Cn.prototype.__patch__=H?fo:k,Cn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),Je(t,"beforeMount"),r=function(){t._update(t._render(),n)},new ln(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Je(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Je(t,"mounted")),t}(this,t=t&&H?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},H&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",Cn)},0),module.exports=Cn;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index 67eadde7f5d..1b666367d91 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -1,191 +1,157 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-/*  */
-
+/* @flow */
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
-function isRegExp (v) {
-  return _toString.call(v) === '[object RegExp]'
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Capitalize a string.
  */
 var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -193,1106 +159,982 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
-function toArray (list, start) {
-  start = start || 0;
-  var i = list.length - start;
-  var ret = new Array(i);
-  while (i--) {
-    ret[i] = list[i + start];
-  }
-  return ret
+function toArray(list, start) {
+    start = start || 0;
+    var i = list.length - start;
+    var ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
 }
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
+function looseEqual(a, b) {
+    if (a === b)
+        { return true; }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every(function (e, i) {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every(function (key) {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (var i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            { return i; }
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
+function once(fn) {
+    var called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
 var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Check if a string starts with $ or _
  */
-function isReserved (str) {
-  var c = (str + '').charCodeAt(0);
-  return c === 0x24 || c === 0x5F
+function isReserved(str) {
+    var c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
 }
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
-
 /**
  * Parse simple path.
  */
 var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-function parsePath (path) {
-  if (bailRE.test(path)) {
-    return
-  }
-  var segments = path.split('.');
-  return function (obj) {
-    for (var i = 0; i < segments.length; i++) {
-      if (!obj) { return }
-      obj = obj[segments[i]];
-    }
-    return obj
-  }
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    var segments = path.split('.');
+    return function (obj) {
+        for (var i = 0; i < segments.length; i++) {
+            if (!obj)
+                { return; }
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 var isPhantomJS = UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
-
+// @ts-ignore
+var nativeWatch = {}.watch;
 var supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-        /* istanbul ignore next */
-        supportsPassive = true;
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/(function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function has (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function add (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function clear () {
+            this.set = Object.create(null);
+        };
 
-    return Set;
-  }());
+        return Set;
+    }());
 }
 
-/*  */
-
+/* @flow */
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace);
-    } else if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
+    };
+    var repeat = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
+                    .join('\n'));
+        }
+        else {
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+        }
+    };
 }
 
-/*  */
-
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
 };
-
 Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
+    this.subs.push(sub);
 };
-
 Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
+    remove(this.subs, sub);
 };
-
 Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
+    if (Dep.target) {
+        Dep.target.addDep(this);
+    }
 };
-
 Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
 };
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
-}
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
-}
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
+}
+
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
 };
 
 var prototypeAccessors = { child: { configurable: true } };
-
 // DEPRECATED: alias for componentInstance for backwards compat.
 /* istanbul ignore next */
 prototypeAccessors.child.get = function () {
-  return this.componentInstance
+    return this.componentInstance;
 };
 
 Object.defineProperties( VNode.prototype, prototypeAccessors );
-
 var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
+    if ( text === void 0 ) text = '';
 
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    var cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
+        }
+        else {
+            copyAugment(value, arrayMethods, arrayKeys);
+        }
+        this.observeArray(value);
+    }
+    else {
+        this.walk(value);
+    }
 };
-
 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive$$1(obj, keys[i]);
+    }
 };
-
 /**
  * Observe a list of Array items.
  */
 Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
 };
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Delete a property and trigger change if necessary.
  */
-function del (target, key) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1);
-    return
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    );
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key];
-  if (!ob) {
-    return
-  }
-  ob.dep.notify();
+function del(target, key) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    var ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
     }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1300,613 +1142,542 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (var key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else if (process.env.NODE_ENV !== 'production') {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    var props = options.props;
+    if (!props)
+        { return; }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (var key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("Invalid value for option \"props\": expected an Array or an Object, " +
+            "but got " + (toRawType(props)) + ".", vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    var inject = options.inject;
+    if (!inject)
+        { return; }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (var i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (var key in inject) {
+            var val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+            "but got " + (toRawType(inject)) + ".", vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
+function normalizeDirectives(options) {
+    var dirs = options.directives;
+    if (dirs) {
+        for (var key in dirs) {
+            var def$$1 = dirs[key];
+            if (typeof def$$1 === 'function') {
+                dirs[key] = { bind: def$$1, update: def$$1 };
+            }
+        }
     }
-  }
 }
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            "but got " + (toRawType(value)) + ".", vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        var strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    // skip validation for weex recycle-list child component props
-    !(false)
-  ) {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        { return assets[id]; }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        { return assets[camelizedId]; }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        { return assets[PascalCaseId]; }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+/* @flow */
+function validateProp(key, propOptions, propsData, vm) {
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            var stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        var prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        // skip validation for weex recycle-list child component props
+        !(false)) {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        var t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid: valid,
+        expectedType: expectedType,
+    };
 }
-
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
+function getType(fn) {
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
 }
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
+function isSameType(a, b) {
+    return getType(a) === getType(b);
 }
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
     }
-  }
-  return -1
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
 }
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  var expectedValue = styleValue(value, expectedType);
-  var receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += " with value " + expectedValue;
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + receivedValue + ".";
-  }
-  return message
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += " with value " + (styleValue(value, expectedType));
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += "with value " + (styleValue(value, receivedType)) + ".";
+    }
+    return message;
 }
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
+function styleValue(value, type) {
+    if (type === 'String') {
+        return ("\"" + value + "\"");
+    }
+    else if (type === 'Number') {
+        return ("" + (Number(value)));
+    }
+    else {
+        return ("" + value);
+    }
 }
-
-function isExplicable (value) {
-  var explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
+function isBoolean() {
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            var cur = vm;
+            while ((cur = cur.$parent)) {
+                var hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (var i = 0; i < hooks.length; i++) {
+                        try {
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                { return; }
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
             }
-          }
         }
-      }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
-}
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
 }
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    var res;
     try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler');
-      }
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
     }
-  }
-  logError(err, vm, info);
+    return res;
 }
-
-function logError (err, vm, info) {
-  if (process.env.NODE_ENV !== 'production') {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    if (process.env.NODE_ENV !== 'production') {
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/*  */
-
+/* @flow */
 var isUsingMicroTask = false;
-
 var callbacks = [];
 var pending = false;
-
-function flushCallbacks () {
-  pending = false;
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    pending = false;
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // Here we have async deferring wrappers using microtasks.
 // In 2.5 we used (macro) tasks (in combination with microtasks).
 // However, it has subtle problems when state is changed right before repaint
@@ -1919,7 +1690,6 @@ function flushCallbacks () {
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
 var timerFunc;
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1928,2307 +1698,2027 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  var p = Promise.resolve();
-  timerFunc = function () {
-    p.then(flushCallbacks);
-    // In problematic UIWebViews, Promise.then doesn't completely break, but
-    // it can get stuck in a weird state where callbacks are pushed into the
-    // microtask queue but the queue isn't being flushed, until the browser
-    // needs to do some other work, e.g. handle a timer. Therefore we can
-    // "force" the microtask queue to be flushed by adding an empty timer.
-    if (isIOS) { setTimeout(noop); }
-  };
-  isUsingMicroTask = true;
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-  timerFunc = function () {
-    counter = (counter + 1) % 2;
-    textNode.data = String(counter);
-  };
-  isUsingMicroTask = true;
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Technically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = function () {
-    setImmediate(flushCallbacks);
-  };
-} else {
-  // Fallback to setTimeout.
-  timerFunc = function () {
-    setTimeout(flushCallbacks, 0);
-  };
+    var p = Promise.resolve();
+    timerFunc = function () {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            { setTimeout(noop); }
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = function () {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = function () {
+        setImmediate(flushCallbacks);
+    };
 }
-
-function nextTick (cb, ctx) {
-  var _resolve;
-  callbacks.push(function () {
-    if (cb) {
-      try {
-        cb.call(ctx);
-      } catch (e) {
-        handleError(e, ctx, 'nextTick');
-      }
-    } else if (_resolve) {
-      _resolve(ctx);
-    }
-  });
-  if (!pending) {
-    pending = true;
-    timerFunc();
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(function (resolve) {
-      _resolve = resolve;
-    })
-  }
+else {
+    // Fallback to setTimeout.
+    timerFunc = function () {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    var _resolve;
+    callbacks.push(function () {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise(function (resolve) {
+            _resolve = resolve;
+        });
+    }
 }
 
-/*  */
+/* @flow */
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 var initProxy;
-
 if (process.env.NODE_ENV !== 'production') {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var warnNonPresent = function (target, key) {
-    warn(
-      "Property or method \"" + key + "\" is not defined on the instance but " +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
-    );
-  };
-
-  var warnReservedPrefix = function (target, key) {
-    warn(
-      "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
     );
-  };
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
-
-  var hasHandler = {
-    has: function has (target, key) {
-      var has = key in target;
-      var isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-      if (!has && !isAllowed) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return has || !isAllowed
-    }
-  };
-
-  var getHandler = {
-    get: function get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return target[key]
-    }
-  };
-
-  initProxy = function initProxy (vm) {
+    var warnNonPresent = function (target, key) {
+        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    var warnReservedPrefix = function (target, key) {
+        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-      // determine which proxy handler to use
-      var options = vm.$options;
-      var handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler;
-      vm._renderProxy = new Proxy(vm, handlers);
-    } else {
-      vm._renderProxy = vm;
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
     }
-  };
+    var hasHandler = {
+        has: function has(target, key) {
+            var has = key in target;
+            var isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return has || !isAllowed;
+        },
+    };
+    var getHandler = {
+        get: function get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    { warnReservedPrefix(target, key); }
+                else
+                    { warnNonPresent(target, key); }
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            var options = vm.$options;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-/*  */
-
+/* @flow */
 var seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    var i, keys;
+    var isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        var depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            { _traverse(val[i], seen); }
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            { _traverse(val[keys[i]], seen); }
+    }
 }
 
 var mark;
 var measure;
-
 if (process.env.NODE_ENV !== 'production') {
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = function (tag) { return perf.mark(tag); };
-    measure = function (name, startTag, endTag) {
-      perf.measure(name, startTag, endTag);
-      perf.clearMarks(startTag);
-      perf.clearMarks(endTag);
-      // perf.clearMeasures(name)
-    };
-  }
+    var perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
+        measure = function (name, startTag, endTag) {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-/*  */
-
 var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+    var passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once$$1 ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name: name,
+        once: once$$1,
+        capture: capture,
+        passive: passive,
+    };
 });
-
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        var arguments$1 = arguments;
+
+        var fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+    var name, def$$1, cur, old, event;
+    for (name in on) {
+        def$$1 = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove$$1(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-/*  */
-
-function mergeVNodeHook (def, hookKey, hook) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {});
-  }
-  var invoker;
-  var oldHook = def[hookKey];
-
-  function wrappedHook () {
-    hook.apply(this, arguments);
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook);
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook]);
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook;
-      invoker.fns.push(wrappedHook);
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook]);
-    }
-  }
-
-  invoker.merged = true;
-  def[hookKey] = invoker;
+/* @flow */
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    var invoker;
+    var oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      if (process.env.NODE_ENV !== 'production') {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
+/* @flow */
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    var res = {};
+    var attrs = data.attrs;
+    var props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
+            if (process.env.NODE_ENV !== 'production') {
+                var keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
 }
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-/*  */
-
+/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
-    }
-  }
-  return children
+function simpleNormalizeChildren(children) {
+    for (var i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
-
-function initProvide (vm) {
-  var provide = vm.$options.provide;
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide;
-  }
-}
-
-function initInjections (vm) {
-  var result = resolveInject(vm.$options.inject, vm);
-  if (result) {
-    toggleObserving(false);
-    Object.keys(result).forEach(function (key) {
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
-        defineReactive$$1(vm, key, result[key], function () {
-          warn(
-            "Avoid mutating an injected value directly since the changes will be " +
-            "overwritten whenever the provided component re-renders. " +
-            "injection being mutated: \"" + key + "\"",
-            vm
-          );
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            { continue; }
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
+}
+
+/* @flow */
+function initProvide(vm) {
+    var provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    var result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach(function (key) {
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production') {
+                defineReactive$$1(vm, key, result[key], function () {
+                    warn("Avoid mutating an injected value directly since the changes will be " +
+                        "overwritten whenever the provided component re-renders. " +
+                        "injection being mutated: \"" + key + "\"", vm);
+                });
+            }
+            else {
+                defineReactive$$1(vm, key, result[key]);
+            }
         });
-      } else {
-        defineReactive$$1(vm, key, result[key]);
-      }
-    });
-    toggleObserving(true);
-  }
-}
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
-        }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else if (process.env.NODE_ENV !== 'production') {
-          warn(("Injection \"" + key + "\" not found"), vm);
-        }
-      }
-    }
-    return result
-  }
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                { continue; }
+            var provideKey = inject[key].from;
+            var source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    var provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    // @ts-ignore
+                    warn(("Injection \"" + key + "\" not found"), vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/*  */
-
-
-
+/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+/* @flow */
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return function () { return slots[key]; };
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    var ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+/* @flow */
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-bind without argument expects an Object or Array value', this);
         }
-      };
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            var hash;
+            var loop = function ( key ) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    var type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        var on = data.on || (data.on = {});
+                        on[("update:" + key)] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            };
 
-      for (var key in value) loop( key );
+            for (var key in value) loop( key );
+        }
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, ("__static__" + index), false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
-}
-
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
-    }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+function markOnce(tree, index, key) {
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (var i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
 }
-
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
+/* @flow */
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+/* @flow */
+function bindDynamicKeys(baseObj, values) {
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (process.env.NODE_ENV !== 'production' &&
+            key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+/* @flow */
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+/* @flow */
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    var this$1 = this;
 
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
     }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        }
+        return this$1.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get: function get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = function (a, b, c, d) {
+            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
-
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (var key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            { mergeProps(props, data.attrs); }
+        if (isDef(data.props))
+            { mergeProps(props, data.props); }
+    }
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
     }
-    return res
-  }
 }
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    if (process.env.NODE_ENV !== 'production') {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
 }
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
+function mergeProps(to, from) {
+    for (var key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
-/*  */
+/* @flow */
 
+/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init: function init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            var mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch: function prepatch(oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy: function destroy(vnode) {
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    if (process.env.NODE_ENV !== 'production') {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        if (process.env.NODE_ENV !== 'production') {
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
+        }
+        return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
     }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        var slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
     }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent // activeInstance in lifecycle state
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
+    // @ts-expect-error
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    var options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+        }
     }
-  }
 }
-
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function mergeHook$1(f1, f2) {
+    var merged = function (a, b) {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
+function transformModel(options, data) {
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-/*  */
-
+/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (process.env.NODE_ENV !== 'production' &&
-    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {
-        warn(
-          ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-          context
-        );
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      );
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
 }
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (process.env.NODE_ENV !== 'production' &&
+        isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === 'string') {
+        var Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (process.env.NODE_ENV !== 'production' &&
+                isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            { applyNS(vnode, ns); }
+        if (isDef(data))
+            { registerDeepBindings(data); }
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
-}
-
-/*  */
-
-function initRender (vm) {
-  vm._vnode = null; // the root of the child tree
-  vm._staticTrees = null; // v-once cached trees
-  var options = vm.$options;
-  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-  var renderContext = parentVnode && parentVnode.context;
-  vm.$slots = resolveSlots(options._renderChildren, renderContext);
-  vm.$scopedSlots = emptyObject;
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  var parentData = parentVnode && parentVnode.data;
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-    }, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-    }, true);
-  } else {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
+}
+
+/* @flow */
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    var parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        }, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        }, true);
+    }
+    else {
+        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
+    }
 }
-
 var currentRenderingInstance = null;
-
-function renderMixin (Vue) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype);
-
-  Vue.prototype.$nextTick = function (fn) {
-    return nextTick(fn, this)
-  };
-
-  Vue.prototype._render = function () {
-    var vm = this;
-    var ref = vm.$options;
-    var render = ref.render;
-    var _parentVnode = ref._parentVnode;
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      );
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode;
-    // render self
-    var vnode;
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm;
-      vnode = render.call(vm._renderProxy, vm.$createElement);
-    } catch (e) {
-      handleError(e, vm, "render");
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        var vm = this;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        var vnode;
         try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-        } catch (e) {
-          handleError(e, vm, "renderError");
-          vnode = vm._vnode;
-        }
-      } else {
-        vnode = vm._vnode;
-      }
-    } finally {
-      currentRenderingInstance = null;
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0];
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        );
-      }
-      vnode = createEmptyVNode();
-    }
-    // set parent
-    vnode.parent = _parentVnode;
-    return vnode
-  };
-}
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
         }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
+        catch (e) {
+            handleError(e, vm, "render");
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, "renderError");
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
         }
-      }
-    };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+        finally {
+            currentRenderingInstance = null;
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                process.env.NODE_ENV !== 'production'
-                  ? ("timeout (" + (res.timeout) + "ms)")
-                  : null
-              );
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
             }
-          }, res.timeout);
+            vnode = createEmptyVNode();
         }
-      }
-    }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-/*  */
-
-function getFirstComponentChild (children) {
-  if (Array.isArray(children)) {
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
+/* @flow */
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
     }
-  }
+    return isObject(comp) ? base.extend(comp) : comp;
 }
-
-/*  */
-
-/*  */
-
-function initEvents (vm) {
-  vm._events = Object.create(null);
-  vm._hasHookEvent = false;
-  // init parent attached events
-  var listeners = vm.$options._parentListeners;
-  if (listeners) {
-    updateComponentListeners(vm, listeners);
-  }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    return node;
 }
-
-var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    var owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        var resolve = once(function (res) {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        var reject = once(function (reason) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(process.env.NODE_ENV !== 'production'
+                                ? ("timeout (" + (res.timeout) + "ms)")
+                                : null);
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function remove$1 (event, fn) {
-  target.$off(event, fn);
+/* @flow */
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
+/* @flow */
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+            var c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
     }
-  }
-}
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
 }
 
-function eventsMixin (Vue) {
-  var hookRE = /^hook:/;
-  Vue.prototype.$on = function (event, fn) {
-    var vm = this;
-    if (Array.isArray(event)) {
-      for (var i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn);
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn);
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true;
-      }
-    }
-    return vm
-  };
+/* @flow */
 
-  Vue.prototype.$once = function (event, fn) {
-    var vm = this;
-    function on () {
-      vm.$off(event, on);
-      fn.apply(vm, arguments);
-    }
-    on.fn = fn;
-    vm.$on(event, on);
-    return vm
-  };
-
-  Vue.prototype.$off = function (event, fn) {
-    var vm = this;
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null);
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-        vm.$off(event[i$1], fn);
-      }
-      return vm
-    }
-    // specific event
-    var cbs = vm._events[event];
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null;
-      return vm
-    }
-    // specific handler
-    var cb;
-    var i = cbs.length;
-    while (i--) {
-      cb = cbs[i];
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1);
-        break
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$emit = function (event) {
-    var vm = this;
-    if (process.env.NODE_ENV !== 'production') {
-      var lowerCaseEvent = event.toLowerCase();
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-          "Note that HTML attributes are case-insensitive and you cannot use " +
-          "v-on to listen to camelCase events when using in-DOM templates. " +
-          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-        );
-      }
-    }
-    var cbs = vm._events[event];
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-      var args = toArray(arguments, 1);
-      var info = "event handler for \"" + event + "\"";
-      for (var i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-      }
+/* @flow */
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    var listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
     }
-    return vm
-  };
+}
+var target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    var _target = target;
+    return function onceHandler() {
+        var res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    target = undefined;
+}
+function eventsMixin(Vue) {
+    var hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        var vm = this;
+        if (Array.isArray(event)) {
+            for (var i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        var vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        var vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
+            }
+            return vm;
+        }
+        // specific event
+        var cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        var cb;
+        var i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        var vm = this;
+        if (process.env.NODE_ENV !== 'production') {
+            var lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    "Note that HTML attributes are case-insensitive and you cannot use " +
+                    "v-on to listen to camelCase events when using in-DOM templates. " +
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+            }
+        }
+        var cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            var args = toArray(arguments, 1);
+            var info = "event handler for \"" + event + "\"";
+            for (var i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-/*  */
-
+/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
-
 function setActiveInstance(vm) {
-  var prevActiveInstance = activeInstance;
-  activeInstance = vm;
-  return function () {
-    activeInstance = prevActiveInstance;
-  }
+    var prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return function () {
+        activeInstance = prevActiveInstance;
+    };
 }
-
-function initLifecycle (vm) {
-  var options = vm.$options;
-
-  // locate first non-abstract parent
-  var parent = options.parent;
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
-    }
-    parent.$children.push(vm);
-  }
-
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
-
-  vm.$children = [];
-  vm.$refs = {};
-
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
+function initLifecycle(vm) {
+    var options = vm.$options;
+    // locate first non-abstract parent
+    var parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        var vm = this;
+        var prevEl = vm.$el;
+        var prevVnode = vm._vnode;
+        var restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        var vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        var vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook(vm, 'beforeDestroy');
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        var parent = vm.$parent;
+        // @ts-ignore
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        var i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook(vm, 'destroyed');
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            // @ts-expect-error null is not undefined
+            vm.$vnode.parent = null;
+        }
+    };
 }
-
-function lifecycleMixin (Vue) {
-  Vue.prototype._update = function (vnode, hydrating) {
-    var vm = this;
-    var prevEl = vm.$el;
-    var prevVnode = vm._vnode;
-    var restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
-    }
-    restoreActiveInstance();
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null;
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm;
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  };
-
-  Vue.prototype.$forceUpdate = function () {
-    var vm = this;
-    if (vm._watcher) {
-      vm._watcher.update();
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        if (process.env.NODE_ENV !== 'production') {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                vm.$options.el ||
+                el) {
+                warn('You are using the runtime-only build of Vue where the template ' +
+                    'compiler is not available. Either pre-compile the templates into ' +
+                    'render functions, or use the compiler-included build.', vm);
+            }
+            else {
+                warn('Failed to mount component: template or render function not defined.', vm);
+            }
+        }
     }
-  };
-
-  Vue.prototype.$destroy = function () {
-    var vm = this;
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy');
-    vm._isBeingDestroyed = true;
-    // remove self from parent
-    var parent = vm.$parent;
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
-    }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown();
-    }
-    var i = vm._watchers.length;
-    while (i--) {
-      vm._watchers[i].teardown();
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
-    }
-    // call the last hook...
-    vm._isDestroyed = true;
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
-    // fire destroyed hook
-    callHook(vm, 'destroyed');
-    // turn off all instance listeners.
-    vm.$off();
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null;
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null;
-    }
-  };
-}
-
-function mountComponent (
-  vm,
-  el,
-  hydrating
-) {
-  vm.$el = el;
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode;
+    callHook(vm, 'beforeMount');
+    var updateComponent;
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+        updateComponent = function () {
+            var name = vm._name;
+            var id = vm._uid;
+            var startTag = "vue-perf-start:" + id;
+            var endTag = "vue-perf-end:" + id;
+            mark(startTag);
+            var vnode = vm._render();
+            mark(endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = function () {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before: function before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook(vm, 'beforeUpdate');
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook(vm, 'mounted');
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
     if (process.env.NODE_ENV !== 'production') {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        );
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        );
-      }
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
     }
-  }
-  callHook(vm, 'beforeMount');
-
-  var updateComponent;
-  /* istanbul ignore if */
-  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-    updateComponent = function () {
-      var name = vm._name;
-      var id = vm._uid;
-      var startTag = "vue-perf-start:" + id;
-      var endTag = "vue-perf-end:" + id;
-
-      mark(startTag);
-      var vnode = vm._render();
-      mark(endTag);
-      measure(("vue " + name + " render"), startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(("vue " + name + " patch"), startTag, endTag);
-    };
-  } else {
-    updateComponent = function () {
-      vm._update(vm._render(), hydrating);
-    };
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before: function before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate');
-      }
-    }
-  }, true /* isRenderWatcher */);
-  hydrating = false;
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  }
-  return vm
-}
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = true;
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+    if (process.env.NODE_ENV !== 'production') {
+        isUpdatingChildComponent = false;
     }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = false;
-  }
 }
-
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            { return true; }
+    }
+    return false;
 }
-
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (var i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'activated');
     }
-    callHook(vm, 'activated');
-  }
 }
-
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (var i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'deactivated');
     }
-    callHook(vm, 'deactivated');
-  }
 }
-
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-    }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
+    }
+    popTarget();
 }
 
-/*  */
-
+/* @flow */
 var MAX_UPDATE_COUNT = 100;
-
 var queue = [];
 var activatedChildren = [];
 var has = {};
@@ -4236,29 +3726,25 @@ var circular = {};
 var waiting = false;
 var flushing = false;
 var index = 0;
-
 /**
  * Reset the scheduler's state.
  */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0;
-  has = {};
-  if (process.env.NODE_ENV !== 'production') {
-    circular = {};
-  }
-  waiting = flushing = false;
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    if (process.env.NODE_ENV !== 'production') {
+        circular = {};
+    }
+    waiting = flushing = false;
 }
-
 // Async edge case #6566 requires saving the timestamp when event listeners are
 // attached. However, calling performance.now() has a perf overhead especially
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
 var currentFlushTimestamp = 0;
-
 // Async edge case fix requires storing an event listener's attach timestamp.
 var getNow = Date.now;
-
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -4266,1475 +3752,1288 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = function () { return performance.now(); };
+    }
 }
-
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow();
-  flushing = true;
-  var watcher, id;
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort(function (a, b) { return a.id - b.id; });
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index];
-    if (watcher.before) {
-      watcher.before();
-    }
-    id = watcher.id;
-    has[id] = null;
-    watcher.run();
-    // in dev build, check and stop circular updates.
-    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1;
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-              : "in a component render function."
-          ),
-          watcher.vm
-        );
-        break
-      }
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    var watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort(function (a, b) { return a.id - b.id; });
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        : "in a component render function."), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
     }
-  }
-
-  // keep copies of post queues before resetting state
-  var activatedQueue = activatedChildren.slice();
-  var updatedQueue = queue.slice();
-
-  resetSchedulerState();
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue);
-  callUpdatedHooks(updatedQueue);
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush');
-  }
 }
-
-function callUpdatedHooks (queue) {
-  var i = queue.length;
-  while (i--) {
-    var watcher = queue[i];
-    var vm = watcher.vm;
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated');
+function callUpdatedHooks(queue) {
+    var i = queue.length;
+    while (i--) {
+        var watcher = queue[i];
+        var vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook(vm, 'updated');
+        }
     }
-  }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-  activatedChildren.push(vm);
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
 }
-
-function callActivatedHooks (queue) {
-  for (var i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true;
-    activateChildComponent(queue[i], true /* true */);
-  }
+function callActivatedHooks(queue) {
+    for (var i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
 }
-
 /**
  * Push a watcher into the watcher queue.
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-function queueWatcher (watcher) {
-  var id = watcher.id;
-  if (has[id] == null) {
-    has[id] = true;
-    if (!flushing) {
-      queue.push(watcher);
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      var i = queue.length - 1;
-      while (i > index && queue[i].id > watcher.id) {
-        i--;
-      }
-      queue.splice(i + 1, 0, watcher);
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true;
-
-      if (process.env.NODE_ENV !== 'production' && !config.async) {
-        flushSchedulerQueue();
-        return
-      }
-      nextTick(flushSchedulerQueue);
+function queueWatcher(watcher) {
+    var id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            var i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (process.env.NODE_ENV !== 'production' && !config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
     }
-  }
 }
 
-/*  */
-
-
-
+/* @flow */
 var uid$2 = 0;
-
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher (
-  vm,
-  expOrFn,
-  cb,
-  options,
-  isRenderWatcher
-) {
-  this.vm = vm;
-  if (isRenderWatcher) {
-    vm._watcher = this;
-  }
-  vm._watchers.push(this);
-  // options
-  if (options) {
-    this.deep = !!options.deep;
-    this.user = !!options.user;
-    this.lazy = !!options.lazy;
-    this.sync = !!options.sync;
-    this.before = options.before;
-  } else {
-    this.deep = this.user = this.lazy = this.sync = false;
-  }
-  this.cb = cb;
-  this.id = ++uid$2; // uid for batching
-  this.active = true;
-  this.dirty = this.lazy; // for lazy watchers
-  this.deps = [];
-  this.newDeps = [];
-  this.depIds = new _Set();
-  this.newDepIds = new _Set();
-  this.expression = process.env.NODE_ENV !== 'production'
-    ? expOrFn.toString()
-    : '';
-  // parse expression for getter
-  if (typeof expOrFn === 'function') {
-    this.getter = expOrFn;
-  } else {
-    this.getter = parsePath(expOrFn);
-    if (!this.getter) {
-      this.getter = noop;
-      process.env.NODE_ENV !== 'production' && warn(
-        "Failed watching path: \"" + expOrFn + "\" " +
-        'Watcher only accepts simple dot-delimited paths. ' +
-        'For full control, use a function instead.',
-        vm
-      );
-    }
-  }
-  this.value = this.lazy
-    ? undefined
-    : this.get();
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$2; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            process.env.NODE_ENV !== 'production' &&
+                warn("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+        }
+    }
+    this.value = this.lazy ? undefined : this.get();
 };
-
 /**
  * Evaluate the getter, and re-collect dependencies.
  */
 Watcher.prototype.get = function get () {
-  pushTarget(this);
-  var value;
-  var vm = this.vm;
-  try {
-    value = this.getter.call(vm, vm);
-  } catch (e) {
-    if (this.user) {
-      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-    } else {
-      throw e
-    }
-  } finally {
-    // "touch" every property so they are all tracked as
-    // dependencies for deep watching
-    if (this.deep) {
-      traverse(value);
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
     }
-    popTarget();
-    this.cleanupDeps();
-  }
-  return value
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+        }
+        else {
+            throw e;
+        }
+    }
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
+        }
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
 };
-
 /**
  * Add a dependency to this directive.
  */
 Watcher.prototype.addDep = function addDep (dep) {
-  var id = dep.id;
-  if (!this.newDepIds.has(id)) {
-    this.newDepIds.add(id);
-    this.newDeps.push(dep);
-    if (!this.depIds.has(id)) {
-      dep.addSub(this);
-    }
-  }
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
 };
-
 /**
  * Clean up for dependency collection.
  */
 Watcher.prototype.cleanupDeps = function cleanupDeps () {
-  var i = this.deps.length;
-  while (i--) {
-    var dep = this.deps[i];
-    if (!this.newDepIds.has(dep.id)) {
-      dep.removeSub(this);
-    }
-  }
-  var tmp = this.depIds;
-  this.depIds = this.newDepIds;
-  this.newDepIds = tmp;
-  this.newDepIds.clear();
-  tmp = this.deps;
-  this.deps = this.newDeps;
-  this.newDeps = tmp;
-  this.newDeps.length = 0;
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
 };
-
 /**
  * Subscriber interface.
  * Will be called when a dependency changes.
  */
 Watcher.prototype.update = function update () {
-  /* istanbul ignore else */
-  if (this.lazy) {
-    this.dirty = true;
-  } else if (this.sync) {
-    this.run();
-  } else {
-    queueWatcher(this);
-  }
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
 };
-
 /**
  * Scheduler job interface.
  * Will be called by the scheduler.
  */
 Watcher.prototype.run = function run () {
-  if (this.active) {
-    var value = this.get();
-    if (
-      value !== this.value ||
-      // Deep watchers and watchers on Object/Arrays should fire even
-      // when the value is the same, because the value may
-      // have mutated.
-      isObject(value) ||
-      this.deep
-    ) {
-      // set new value
-      var oldValue = this.value;
-      this.value = value;
-      if (this.user) {
-        try {
-          this.cb.call(this.vm, value, oldValue);
-        } catch (e) {
-          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
+            if (this.user) {
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
+            }
+            else {
+                this.cb.call(this.vm, value, oldValue);
+            }
         }
-      } else {
-        this.cb.call(this.vm, value, oldValue);
-      }
     }
-  }
 };
-
 /**
  * Evaluate the value of the watcher.
  * This only gets called for lazy watchers.
  */
 Watcher.prototype.evaluate = function evaluate () {
-  this.value = this.get();
-  this.dirty = false;
+    this.value = this.get();
+    this.dirty = false;
 };
-
 /**
  * Depend on all deps collected by this watcher.
  */
 Watcher.prototype.depend = function depend () {
-  var i = this.deps.length;
-  while (i--) {
-    this.deps[i].depend();
-  }
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
 };
-
 /**
  * Remove self from all dependencies' subscriber list.
  */
 Watcher.prototype.teardown = function teardown () {
-  if (this.active) {
-    // remove self from vm's watcher list
-    // this is a somewhat expensive operation so we skip it
-    // if the vm is being destroyed.
-    if (!this.vm._isBeingDestroyed) {
-      remove(this.vm._watchers, this);
-    }
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].removeSub(this);
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove(this.vm._watchers, this);
+        }
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].removeSub(this);
+        }
+        this.active = false;
     }
-    this.active = false;
-  }
 };
 
-/*  */
-
+/* @flow */
 var sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
 };
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    var opts = vm.$options;
+    if (opts.props)
+        { initProps(vm, opts.props); }
+    if (opts.methods)
+        { initMethods(vm, opts.methods); }
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        { initComputed(vm, opts.computed); }
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps(vm, propsOptions) {
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    var loop = function ( key ) {
+        keys.push(key);
+        var value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            var hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+            }
+            defineReactive$$1(props, key, value, function () {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn("Avoid mutating a prop directly since the value will be " +
+                        "overwritten whenever the parent component re-renders. " +
+                        "Instead, use a data or computed property based on the prop's " +
+                        "value. Prop being mutated: \"" + key + "\"", vm);
+                }
+            });
+        }
+        else {
+            defineReactive$$1(props, key, value);
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, "_props", key);
+        }
+    };
 
-function proxy (target, sourceKey, key) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  };
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function initState (vm) {
-  vm._watchers = [];
-  var opts = vm.$options;
-  if (opts.props) { initProps(vm, opts.props); }
-  if (opts.methods) { initMethods(vm, opts.methods); }
-  if (opts.data) {
-    initData(vm);
-  } else {
-    observe(vm._data = {}, true /* asRootData */);
-  }
-  if (opts.computed) { initComputed(vm, opts.computed); }
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
-  }
+    for (var key in propsOptions) loop( key );
+    toggleObserving(true);
 }
-
-function initProps (vm, propsOptions) {
-  var propsData = vm.$options.propsData || {};
-  var props = vm._props = {};
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  var keys = vm.$options._propKeys = [];
-  var isRoot = !vm.$parent;
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false);
-  }
-  var loop = function ( key ) {
-    keys.push(key);
-    var value = validateProp(key, propsOptions, propsData, vm);
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      var hyphenatedKey = hyphenate(key);
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-          vm
-        );
-      }
-      defineReactive$$1(props, key, value, function () {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            "Avoid mutating a prop directly since the value will be " +
-            "overwritten whenever the parent component re-renders. " +
-            "Instead, use a data or computed property based on the prop's " +
-            "value. Prop being mutated: \"" + key + "\"",
-            vm
-          );
-        }
-      });
-    } else {
-      defineReactive$$1(props, key, value);
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, "_props", key);
-    }
-  };
-
-  for (var key in propsOptions) loop( key );
-  toggleObserving(true);
+function initData(vm) {
+    var data = vm.$options.data;
+    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        process.env.NODE_ENV !== 'production' &&
+            warn('data functions should return an object:\n' +
+                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+    }
+    // proxy data on instance
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
+    while (i--) {
+        var key = keys[i];
+        if (process.env.NODE_ENV !== 'production') {
+            if (methods && hasOwn(methods, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("The data property \"" + key + "\" is already declared as a prop. " +
+                    "Use prop default value instead.", vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, "_data", key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
 }
-
-function initData (vm) {
-  var data = vm.$options.data;
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (!isPlainObject(data)) {
-    data = {};
-    process.env.NODE_ENV !== 'production' && warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    );
-  }
-  // proxy data on instance
-  var keys = Object.keys(data);
-  var props = vm.$options.props;
-  var methods = vm.$options.methods;
-  var i = keys.length;
-  while (i--) {
-    var key = keys[i];
-    if (process.env.NODE_ENV !== 'production') {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a data property."),
-          vm
-        );
-      }
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
     }
-    if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "The data property \"" + key + "\" is already declared as a prop. " +
-        "Use prop default value instead.",
-        vm
-      );
-    } else if (!isReserved(key)) {
-      proxy(vm, "_data", key);
+    catch (e) {
+        handleError(e, vm, "data()");
+        return {};
+    }
+    finally {
+        popTarget();
     }
-  }
-  // observe data
-  observe(data, true /* asRootData */);
-}
-
-function getData (data, vm) {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget();
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, "data()");
-    return {}
-  } finally {
-    popTarget();
-  }
 }
-
 var computedWatcherOptions = { lazy: true };
-
-function initComputed (vm, computed) {
-  // $flow-disable-line
-  var watchers = vm._computedWatchers = Object.create(null);
-  // computed properties are just getters during SSR
-  var isSSR = isServerRendering();
-
-  for (var key in computed) {
-    var userDef = computed[key];
-    var getter = typeof userDef === 'function' ? userDef : userDef.get;
-    if (process.env.NODE_ENV !== 'production' && getter == null) {
-      warn(
-        ("Getter is missing for computed property \"" + key + "\"."),
-        vm
-      );
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      );
+function initComputed(vm, computed) {
+    // $flow-disable-line
+    var watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+        var userDef = computed[key];
+        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== 'production' && getter == null) {
+            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            if (key in vm.$data) {
+                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+            }
+        }
     }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else if (process.env.NODE_ENV !== 'production') {
-      if (key in vm.$data) {
-        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-      }
-    }
-  }
 }
-
-function defineComputed (
-  target,
-  key,
-  userDef
-) {
-  var shouldCache = !isServerRendering();
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
-  }
-  if (process.env.NODE_ENV !== 'production' &&
-      sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-        this
-      );
+function defineComputed(target, key, userDef) {
+    var shouldCache = !isServerRendering();
+    if (typeof userDef === 'function') {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        var watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
     };
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    var watcher = this._computedWatchers && this._computedWatchers[key];
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate();
-      }
-      if (Dep.target) {
-        watcher.depend();
-      }
-      return watcher.value
-    }
-  }
 }
-
 function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
 }
-
-function initMethods (vm, methods) {
-  var props = vm.$options.props;
-  for (var key in methods) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-          "Did you reference the function correctly?",
-          vm
-        );
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a prop."),
-          vm
-        );
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-          "Avoid defining component methods that start with _ or $."
-        );
-      }
+function initMethods(vm, methods) {
+    var props = vm.$options.props;
+    for (var key in methods) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (typeof methods[key] !== 'function') {
+                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                    "Did you reference the function correctly?", vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                    "Avoid defining component methods that start with _ or $.");
+            }
+        }
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
     }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-  }
 }
-
-function initWatch (vm, watch) {
-  for (var key in watch) {
-    var handler = watch[key];
-    if (Array.isArray(handler)) {
-      for (var i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
-      }
-    } else {
-      createWatcher(vm, key, handler);
-    }
-  }
+function initWatch(vm, watch) {
+    for (var key in watch) {
+        var handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (var i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
 }
-
-function createWatcher (
-  vm,
-  expOrFn,
-  handler,
-  options
-) {
-  if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler];
-  }
-  return vm.$watch(expOrFn, handler, options)
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === 'string') {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
 }
-
-function stateMixin (Vue) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  var dataDef = {};
-  dataDef.get = function () { return this._data };
-  var propsDef = {};
-  propsDef.get = function () { return this._props };
-  if (process.env.NODE_ENV !== 'production') {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      );
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    var dataDef = {};
+    dataDef.get = function () {
+        return this._data;
     };
-    propsDef.set = function () {
-      warn("$props is readonly.", this);
+    var propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    if (process.env.NODE_ENV !== 'production') {
+        dataDef.set = function () {
+            warn('Avoid replacing instance root $data. ' +
+                'Use nested data properties instead.', this);
+        };
+        propsDef.set = function () {
+            warn("$props is readonly.", this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, '$data', dataDef);
+    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        var vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        var watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            pushTarget();
+            try {
+                cb.call(vm, watcher.value);
+            }
+            catch (error) {
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+            }
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
     };
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef);
-  Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
-
-  Vue.prototype.$watch = function (
-    expOrFn,
-    cb,
-    options
-  ) {
-    var vm = this;
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
-    }
-    options = options || {};
-    options.user = true;
-    var watcher = new Watcher(vm, expOrFn, cb, options);
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value);
-      } catch (error) {
-        handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-      }
-    }
-    return function unwatchFn () {
-      watcher.teardown();
-    }
-  };
 }
 
-/*  */
-
+/* @flow */
 var uid$3 = 0;
-
-function initMixin (Vue) {
-  Vue.prototype._init = function (options) {
-    var vm = this;
-    // a uid
-    vm._uid = uid$3++;
-
-    var startTag, endTag;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      startTag = "vue-perf-start:" + (vm._uid);
-      endTag = "vue-perf-end:" + (vm._uid);
-      mark(startTag);
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options);
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      );
-    }
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      initProxy(vm);
-    } else {
-      vm._renderProxy = vm;
-    }
-    // expose real self
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook(vm, 'created');
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      vm._name = formatComponentName(vm, false);
-      mark(endTag);
-      measure(("vue " + (vm._name) + " init"), startTag, endTag);
+function initMixin(Vue) {
+    Vue.prototype._init = function (options) {
+        var vm = this;
+        // a uid
+        vm._uid = uid$3++;
+        var startTag, endTag;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            initProxy(vm);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook(vm, 'created');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    // @ts-ignore
+    var opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    var parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    var vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    var options = Ctor.options;
+    if (Ctor.super) {
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            var modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
     }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el);
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                { modified = {}; }
+            modified[key] = latest[key];
+        }
     }
-  };
-}
-
-function initInternalComponent (vm, options) {
-  var opts = vm.$options = Object.create(vm.constructor.options);
-  // doing this because it's faster than dynamic enumeration.
-  var parentVnode = options._parentVnode;
-  opts.parent = options.parent;
-  opts._parentVnode = parentVnode;
-
-  var vnodeComponentOptions = parentVnode.componentOptions;
-  opts.propsData = vnodeComponentOptions.propsData;
-  opts._parentListeners = vnodeComponentOptions.listeners;
-  opts._renderChildren = vnodeComponentOptions.children;
-  opts._componentTag = vnodeComponentOptions.tag;
-
-  if (options.render) {
-    opts.render = options.render;
-    opts.staticRenderFns = options.staticRenderFns;
-  }
-}
-
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
+    return modified;
 }
 
-function Vue (options) {
-  if (process.env.NODE_ENV !== 'production' &&
-    !(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword');
-  }
-  this._init(options);
+function Vue(options) {
+    if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
+        warn('Vue is a constructor and should be called with the `new` keyword');
+    }
+    this._init(options);
 }
-
+//@ts-ignore
 initMixin(Vue);
+//@ts-ignore
 stateMixin(Vue);
+//@ts-ignore
 eventsMixin(Vue);
+//@ts-ignore
 lifecycleMixin(Vue);
+//@ts-ignore
 renderMixin(Vue);
 
-/*  */
-
-function initUse (Vue) {
-  Vue.use = function (plugin) {
-    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    var args = toArray(arguments, 1);
-    args.unshift(this);
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args);
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args);
-    }
-    installedPlugins.push(plugin);
-    return this
-  };
-}
-
-/*  */
-
-function initMixin$1 (Vue) {
-  Vue.mixin = function (mixin) {
-    this.options = mergeOptions(this.options, mixin);
-    return this
-  };
-}
-
-/*  */
-
-function initExtend (Vue) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0;
-  var cid = 1;
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions) {
-    extendOptions = extendOptions || {};
-    var Super = this;
-    var SuperId = Super.cid;
-    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
-    }
-
-    var name = extendOptions.name || Super.options.name;
-    if (process.env.NODE_ENV !== 'production' && name) {
-      validateComponentName(name);
-    }
-
-    var Sub = function VueComponent (options) {
-      this._init(options);
+/* @flow */
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        var args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
     };
-    Sub.prototype = Object.create(Super.prototype);
-    Sub.prototype.constructor = Sub;
-    Sub.cid = cid++;
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    );
-    Sub['super'] = Super;
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps$1(Sub);
-    }
-    if (Sub.options.computed) {
-      initComputed$1(Sub);
-    }
-
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend;
-    Sub.mixin = Super.mixin;
-    Sub.use = Super.use;
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type];
-    });
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub;
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options;
-    Sub.extendOptions = extendOptions;
-    Sub.sealedOptions = extend({}, Sub.options);
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub;
-    return Sub
-  };
-}
-
-function initProps$1 (Comp) {
-  var props = Comp.options.props;
-  for (var key in props) {
-    proxy(Comp.prototype, "_props", key);
-  }
 }
 
-function initComputed$1 (Comp) {
-  var computed = Comp.options.computed;
-  for (var key in computed) {
-    defineComputed(Comp.prototype, key, computed[key]);
-  }
+/* @flow */
+function initMixin$1(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-/*  */
-
-function initAssetRegisters (Vue) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(function (type) {
-    Vue[type] = function (
-      id,
-      definition
-    ) {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && type === 'component') {
-          validateComponentName(id);
+/* @flow */
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    var cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        var Super = this;
+        var SuperId = Super.cid;
+        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        var name = extendOptions.name || Super.options.name;
+        if (process.env.NODE_ENV !== 'production' && name) {
+            validateComponentName(name);
+        }
+        var Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps$1(Sub);
         }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id;
-          definition = this.options._base.extend(definition);
+        if (Sub.options.computed) {
+            initComputed$1(Sub);
         }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition };
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
         }
-        this.options[type + 's'][id] = definition;
-        return definition
-      }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
     };
-  });
 }
-
-/*  */
-
-
-
-function getComponentName (opts) {
-  return opts && (opts.Ctor.options.name || opts.tag)
+function initProps$1(Comp) {
+    var props = Comp.options.props;
+    for (var key in props) {
+        proxy(Comp.prototype, "_props", key);
+    }
 }
-
-function matches (pattern, name) {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
+function initComputed$1(Comp) {
+    var computed = Comp.options.computed;
+    for (var key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function pruneCache (keepAliveInstance, filter) {
-  var cache = keepAliveInstance.cache;
-  var keys = keepAliveInstance.keys;
-  var _vnode = keepAliveInstance._vnode;
-  for (var key in cache) {
-    var cachedNode = cache[key];
-    if (cachedNode) {
-      var name = getComponentName(cachedNode.componentOptions);
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
-      }
-    }
-  }
+/* @flow */
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach(function (type) {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (process.env.NODE_ENV !== 'production' && type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-function pruneCacheEntry (
-  cache,
-  key,
-  keys,
-  current
-) {
-  var cached$$1 = cache[key];
-  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-    cached$$1.componentInstance.$destroy();
-  }
-  cache[key] = null;
-  remove(keys, key);
+// @ts-nocheck
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === 'string') {
+        return pattern.split(',').indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+        var cachedNode = cache[key];
+        if (cachedNode) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    var cached$$1 = cache[key];
+    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+        cached$$1.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove(keys, key);
 }
-
 var patternTypes = [String, RegExp, Array];
-
+// TODO use defineComponent
 var KeepAlive = {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created: function created () {
-    this.cache = Object.create(null);
-    this.keys = [];
-  },
-
-  destroyed: function destroyed () {
-    for (var key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
-    }
-  },
-
-  mounted: function mounted () {
-    var this$1 = this;
-
-    this.$watch('include', function (val) {
-      pruneCache(this$1, function (name) { return matches(val, name); });
-    });
-    this.$watch('exclude', function (val) {
-      pruneCache(this$1, function (name) { return !matches(val, name); });
-    });
-  },
-
-  render: function render () {
-    var slot = this.$slots.default;
-    var vnode = getFirstComponentChild(slot);
-    var componentOptions = vnode && vnode.componentOptions;
-    if (componentOptions) {
-      // check pattern
-      var name = getComponentName(componentOptions);
-      var ref = this;
-      var include = ref.include;
-      var exclude = ref.exclude;
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      var ref$1 = this;
-      var cache = ref$1.cache;
-      var keys = ref$1.keys;
-      var key = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-        : vnode.key;
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
-        // make current key freshest
-        remove(keys, key);
-        keys.push(key);
-      } else {
-        cache[key] = vnode;
-        keys.push(key);
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+    name: 'keep-alive',
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    created: function created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed: function destroyed() {
+        for (var key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
         }
-      }
+    },
+    mounted: function mounted() {
+        var this$1 = this;
 
-      vnode.data.keepAlive = true;
-    }
-    return vnode || (slot && slot[0])
-  }
+        this.$watch('include', function (val) {
+            pruneCache(this$1, function (name) { return matches(val, name); });
+        });
+        this.$watch('exclude', function (val) {
+            pruneCache(this$1, function (name) { return !matches(val, name); });
+        });
+    },
+    render: function render() {
+        var slot = this.$slots.default;
+        var vnode = getFirstComponentChild(slot);
+        var componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
+            var key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove(keys, key);
+                keys.push(key);
+            }
+            else {
+                cache[key] = vnode;
+                keys.push(key);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+            }
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
 var builtInComponents = {
-  KeepAlive: KeepAlive
+    KeepAlive: KeepAlive,
 };
 
-/*  */
-
-function initGlobalAPI (Vue) {
-  // config
-  var configDef = {};
-  configDef.get = function () { return config; };
-  if (process.env.NODE_ENV !== 'production') {
-    configDef.set = function () {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      );
+/* @flow */
+function initGlobalAPI(Vue) {
+    // config
+    var configDef = {};
+    configDef.get = function () { return config; };
+    if (process.env.NODE_ENV !== 'production') {
+        configDef.set = function () {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn,
+        extend: extend,
+        mergeOptions: mergeOptions,
+        defineReactive: defineReactive$$1,
     };
-  }
-  Object.defineProperty(Vue, 'config', configDef);
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn: warn,
-    extend: extend,
-    mergeOptions: mergeOptions,
-    defineReactive: defineReactive$$1
-  };
-
-  Vue.set = set;
-  Vue.delete = del;
-  Vue.nextTick = nextTick;
-
-  // 2.6 explicit observable API
-  Vue.observable = function (obj) {
-    observe(obj);
-    return obj
-  };
-
-  Vue.options = Object.create(null);
-  ASSET_TYPES.forEach(function (type) {
-    Vue.options[type + 's'] = Object.create(null);
-  });
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue;
-
-  extend(Vue.options.components, builtInComponents);
-
-  initUse(Vue);
-  initMixin$1(Vue);
-  initExtend(Vue);
-  initAssetRegisters(Vue);
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = function (obj) {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach(function (type) {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin$1(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
 initGlobalAPI(Vue);
-
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+    get: isServerRendering,
 });
-
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get: function get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
+    get: function get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
 });
-
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+    value: FunctionalRenderContext,
 });
-
 Vue.version = '2.6.12';
 
-/*  */
-
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
 var convertEnumeratedValue = function (key, value) {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
 var xlinkNS = 'http://www.w3.org/1999/xlink';
-
 var isXlink = function (name) {
-  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-
 var getXlinkProp = function (name) {
-  return isXlink(name) ? name.slice(6, name.length) : ''
+    return isXlink(name) ? name.slice(6, name.length) : '';
 };
-
 var isFalsyAttrValue = function (val) {
-  return val == null || val === false
+    return val == null || val === false;
 };
 
-/*  */
-
-function genClassForVnode (vnode) {
-  var data = vnode.data;
-  var parentNode = vnode;
-  var childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
-    }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
-    }
-  }
-  return renderClass(data.staticClass, data.class)
+/* @flow */
+function genClassForVnode(vnode) {
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
 }
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
 }
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
 }
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyArray (value) {
-  var res = '';
-  var stringified;
-  for (var i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) { res += ' '; }
-      res += stringified;
+function stringifyArray(value) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                { res += ' '; }
+            res += stringified;
+        }
     }
-  }
-  return res
+    return res;
 }
-
-function stringifyObject (value) {
-  var res = '';
-  for (var key in value) {
-    if (value[key]) {
-      if (res) { res += ' '; }
-      res += key;
+function stringifyObject(value) {
+    var res = '';
+    for (var key in value) {
+        if (value[key]) {
+            if (res)
+                { res += ' '; }
+            res += key;
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var namespaceMap = {
-  svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML'
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
 };
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 var unknownElementCache = Object.create(null);
-function isUnknownElement (tag) {
-  /* istanbul ignore if */
-  if (!inBrowser) {
-    return true
-  }
-  if (isReservedTag(tag)) {
-    return false
-  }
-  tag = tag.toLowerCase();
-  /* istanbul ignore if */
-  if (unknownElementCache[tag] != null) {
-    return unknownElementCache[tag]
-  }
-  var el = document.createElement(tag);
-  if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
-    return (unknownElementCache[tag] = (
-      el.constructor === window.HTMLUnknownElement ||
-      el.constructor === window.HTMLElement
-    ))
-  } else {
-    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-  }
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    var el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
 }
-
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
-
+/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
-function query (el) {
-  if (typeof el === 'string') {
-    var selected = document.querySelector(el);
-    if (!selected) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'Cannot find element: ' + el
-      );
-      return document.createElement('div')
-    }
-    return selected
-  } else {
-    return el
-  }
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-/*  */
-
-function createElement$1 (tagName, vnode) {
-  var elm = document.createElement(tagName);
-  if (tagName !== 'select') {
-    return elm
-  }
-  // false or null will remove the attribute but undefined will not
-  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-    elm.setAttribute('multiple', 'multiple');
-  }
-  return elm
+/* @flow */
+function createElement$1(tagName, vnode) {
+    var elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
 }
-
-function createElementNS (namespace, tagName) {
-  return document.createElementNS(namespaceMap[namespace], tagName)
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
 }
-
-function createTextNode (text) {
-  return document.createTextNode(text)
+function createTextNode(text) {
+    return document.createTextNode(text);
 }
-
-function createComment (text) {
-  return document.createComment(text)
+function createComment(text) {
+    return document.createComment(text);
 }
-
-function insertBefore (parentNode, newNode, referenceNode) {
-  parentNode.insertBefore(newNode, referenceNode);
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
 }
-
-function removeChild (node, child) {
-  node.removeChild(child);
+function removeChild(node, child) {
+    node.removeChild(child);
 }
-
-function appendChild (node, child) {
-  node.appendChild(child);
+function appendChild(node, child) {
+    node.appendChild(child);
 }
-
-function parentNode (node) {
-  return node.parentNode
+function parentNode(node) {
+    return node.parentNode;
 }
-
-function nextSibling (node) {
-  return node.nextSibling
+function nextSibling(node) {
+    return node.nextSibling;
 }
-
-function tagName (node) {
-  return node.tagName
+function tagName(node) {
+    return node.tagName;
 }
-
-function setTextContent (node, text) {
-  node.textContent = text;
+function setTextContent(node, text) {
+    node.textContent = text;
 }
-
-function setStyleScope (node, scopeId) {
-  node.setAttribute(scopeId, '');
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5752,48 +5051,53 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/*  */
-
+/* @flow */
 var ref = {
-  create: function create (_, vnode) {
-    registerRef(vnode);
-  },
-  update: function update (oldVnode, vnode) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
-    }
-  },
-  destroy: function destroy (vnode) {
-    registerRef(vnode, true);
-  }
+    create: function create(_, vnode) {
+        registerRef(vnode);
+    },
+    update: function update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy: function destroy(vnode) {
+        registerRef(vnode, true);
+    },
 };
-
-function registerRef (vnode, isRemoval) {
-  var key = vnode.data.ref;
-  if (!isDef(key)) { return }
-
-  var vm = vnode.context;
-  var ref = vnode.componentInstance || vnode.elm;
-  var refs = vm.$refs;
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref);
-    } else if (refs[key] === ref) {
-      refs[key] = undefined;
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref];
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref);
-      }
-    } else {
-      refs[key] = ref;
+function registerRef(vnode, isRemoval) {
+    var key = vnode.data.ref;
+    if (!isDef(key))
+        { return; }
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
+    if (isRemoval) {
+        if (Array.isArray(refs[key])) {
+            // @ts-expect-error invalid typings
+            remove(refs[key], ref);
+        }
+        else if (refs[key] === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error invalid typings
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(refs[key])) {
+                refs[key] = [ref];
+                // @ts-expect-error invalid typings
+            }
+            else if (refs[key].indexOf(ref) < 0) {
+                // @ts-expect-error invalid typings
+                refs[key].push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
     }
-  }
 }
 
 /**
@@ -5807,2645 +5111,2429 @@ function registerRef (vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-
 var emptyNode = new VNode('', {}, []);
-
 var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') { return true }
-  var i;
-  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
-}
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  var i, key;
-  var map = {};
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key;
-    if (isDef(key)) { map[key] = i; }
-  }
-  return map
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        ((a.tag === b.tag &&
+            a.isComment === b.isComment &&
+            isDef(a.data) === isDef(b.data) &&
+            sameInputType(a, b)) ||
+            (isTrue(a.isAsyncPlaceholder) &&
+                a.asyncFactory === b.asyncFactory &&
+                isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        { return true; }
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
-
-function createPatchFunction (backend) {
-  var i, j;
-  var cbs = {};
-
-  var modules = backend.modules;
-  var nodeOps = backend.nodeOps;
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = [];
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]]);
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove$$1 () {
-      if (--remove$$1.listeners === 0) {
-        removeNode(childElm);
-      }
-    }
-    remove$$1.listeners = listeners;
-    return remove$$1
-  }
-
-  function removeNode (el) {
-    var parent = nodeOps.parentNode(el);
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el);
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    var i, key;
+    var map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            { map[key] = i; }
     }
-  }
-
-  function isUnknownElement$$1 (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(function (ignore) {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  var creatingElmInVPre = 0;
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode);
+    return map;
+}
+function createPatchFunction(backend) {
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
     }
-
-    vnode.isRootInsert = !nested; // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
-
-    var data = vnode.data;
-    var children = vnode.children;
-    var tag = vnode.tag;
-    if (isDef(tag)) {
-      if (process.env.NODE_ENV !== 'production') {
-        if (data && data.pre) {
-          creatingElmInVPre++;
-        }
-        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          );
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode);
-      setScope(vnode);
-
-      /* istanbul ignore if */
-      {
-        createChildren(vnode, children, insertedVnodeQueue);
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue);
+    function createRmCb(childElm, listeners) {
+        function remove$$1() {
+            if (--remove$$1.listeners === 0) {
+                removeNode(childElm);
+            }
         }
-        insert(parentElm, vnode.elm, refElm);
-      }
-
-      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-        creatingElmInVPre--;
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i = vnode.data;
-    if (isDef(i)) {
-      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */);
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue);
-        insert(parentElm, vnode.elm, refElm);
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+        remove$$1.listeners = listeners;
+        return remove$$1;
+    }
+    function removeNode(el) {
+        var parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
         }
-        return true
-      }
     }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-      vnode.data.pendingInsert = null;
-    }
-    vnode.elm = vnode.componentInstance.$el;
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue);
-      setScope(vnode);
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode);
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode);
-    }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i;
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    var innerNode = vnode;
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode;
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode);
-        }
-        insertedVnodeQueue.push(innerNode);
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm);
-  }
-
-  function insert (parent, elm, ref$$1) {
-    if (isDef(parent)) {
-      if (isDef(ref$$1)) {
-        if (nodeOps.parentNode(ref$$1) === parent) {
-          nodeOps.insertBefore(parent, elm, ref$$1);
+    function isUnknownElement$$1(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some(function (ignore) {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    var creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        var data = vnode.data;
+        var children = vnode.children;
+        var tag = vnode.tag;
+        if (isDef(tag)) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
         }
-      } else {
-        nodeOps.appendChild(parent, elm);
-      }
-    }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      if (process.env.NODE_ENV !== 'production') {
-        checkDuplicateKeys(children);
-      }
-      for (var i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode;
     }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-      cbs.create[i$1](emptyNode, vnode);
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i = vnode.data;
+        if (isDef(i)) {
+            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
     }
-    i = vnode.data.hook; // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) { i.create(emptyNode, vnode); }
-      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
     }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    var i;
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    } else {
-      var ancestor = vnode;
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i);
-        }
-        ancestor = ancestor.parent;
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        var innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
     }
-  }
-
-  function invokeDestroyHook (vnode) {
-    var i, j;
-    var data = vnode.data;
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
+    function insert(parent, elm, ref$$1) {
+        if (isDef(parent)) {
+            if (isDef(ref$$1)) {
+                if (nodeOps.parentNode(ref$$1) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref$$1);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
     }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j]);
-      }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            if (process.env.NODE_ENV !== 'production') {
+                checkDuplicateKeys(children);
+            }
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
     }
-  }
-
-  function removeVnodes (vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      var ch = vnodes[startIdx];
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch);
-          invokeDestroyHook(ch);
-        } else { // Text node
-          removeNode(ch.elm);
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      var i;
-      var listeners = cbs.remove.length + 1;
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners;
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners);
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm);
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm);
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm);
-      } else {
-        rm();
-      }
-    } else {
-      removeNode(vnode.elm);
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    var oldStartIdx = 0;
-    var newStartIdx = 0;
-    var oldEndIdx = oldCh.length - 1;
-    var oldStartVnode = oldCh[0];
-    var oldEndVnode = oldCh[oldEndIdx];
-    var newEndIdx = newCh.length - 1;
-    var newStartVnode = newCh[0];
-    var newEndVnode = newCh[newEndIdx];
-    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    var canMove = !removeOnly;
-
-    if (process.env.NODE_ENV !== 'production') {
-      checkDuplicateKeys(newCh);
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
     }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx];
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        oldStartVnode = oldCh[++oldStartIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-        oldStartVnode = oldCh[++oldStartIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-        } else {
-          vnodeToMove = oldCh[idxInOld];
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-            oldCh[idxInOld] = undefined;
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          }
-        }
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    var seenKeys = {};
-    for (var i = 0; i < children.length; i++) {
-      var vnode = children[i];
-      var key = vnode.key;
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-            vnode.context
-          );
-        } else {
-          seenKeys[key] = true;
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (var i = start; i < end; i++) {
-      var c = oldCh[i];
-      if (isDef(c) && sameVnode(node, c)) { return i }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                { i.create(emptyNode, vnode); }
+            if (isDef(i.insert))
+                { insertedVnodeQueue.push(vnode); }
+        }
     }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        var i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            var ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
     }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode);
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
     }
-
-    var elm = vnode.elm = oldVnode.elm;
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-      } else {
-        vnode.isAsyncPlaceholder = true;
-      }
-      return
+    function invokeDestroyHook(vnode) {
+        var i, j;
+        var data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                { i(vnode); }
+            for (i = 0; i < cbs.destroy.length; ++i)
+                { cbs.destroy[i](vnode); }
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
     }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance;
-      return
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            var ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
     }
-
-    var i;
-    var data = vnode.data;
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode);
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            var i;
+            var listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
     }
-
-    var oldCh = oldVnode.children;
-    var ch = vnode.children;
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
-    }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-      } else if (isDef(ch)) {
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        var oldStartIdx = 0;
+        var newStartIdx = 0;
+        var oldEndIdx = oldCh.length - 1;
+        var oldStartVnode = oldCh[0];
+        var oldEndVnode = oldCh[oldEndIdx];
+        var newEndIdx = newCh.length - 1;
+        var newStartVnode = newCh[0];
+        var newEndVnode = newCh[newEndIdx];
+        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        var canMove = !removeOnly;
         if (process.env.NODE_ENV !== 'production') {
-          checkDuplicateKeys(ch);
-        }
-        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-      } else if (isDef(oldCh)) {
-        removeVnodes(oldCh, 0, oldCh.length - 1);
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '');
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text);
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue;
-    } else {
-      for (var i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i]);
-      }
-    }
-  }
-
-  var hydrationBailed = false;
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    var i;
-    var tag = vnode.tag;
-    var data = vnode.data;
-    var children = vnode.children;
-    inVPre = inVPre || (data && data.pre);
-    vnode.elm = elm;
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true;
-      return true
-    }
-    // assert node match
-    if (process.env.NODE_ENV !== 'production') {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue);
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue);
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('server innerHTML: ', i);
-                console.warn('client innerHTML: ', elm.innerHTML);
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            var childrenMatch = true;
-            var childNode = elm.firstChild;
-            for (var i$1 = 0; i$1 < children.length; i$1++) {
-              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false;
-                break
-              }
-              childNode = childNode.nextSibling;
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        var fullInvoke = false;
-        for (var key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true;
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            break
-          }
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
         }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class']);
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
         }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text;
     }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement$$1(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-      return
+    function checkDuplicateKeys(children) {
+        var seenKeys = {};
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
+            var key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
     }
-
-    var isInitialPatch = false;
-    var insertedVnodeQueue = [];
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true;
-      createElm(vnode, insertedVnodeQueue);
-    } else {
-      var isRealElement = isDef(oldVnode.nodeType);
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR);
-            hydrating = true;
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true);
-              return oldVnode
-            } else if (process.env.NODE_ENV !== 'production') {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
-              );
-            }
-          }
-          // either not server-rendered, or hydration failed.
-          // create an empty node and replace it
-          oldVnode = emptyNodeAt(oldVnode);
+    function findIdxInOld(node, oldCh, start, end) {
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                { return i; }
         }
-
-        // replacing existing element
-        var oldElm = oldVnode.elm;
-        var parentElm = nodeOps.parentNode(oldElm);
-
-        // create new node
-        createElm(
-          vnode,
-          insertedVnodeQueue,
-          // extremely rare edge case: do not insert if old element is in a
-          // leaving transition. Only happens when combining transition +
-          // keep-alive + HOCs. (#4590)
-          oldElm._leaveCb ? null : parentElm,
-          nodeOps.nextSibling(oldElm)
-        );
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          var ancestor = vnode.parent;
-          var patchable = isPatchable(vnode);
-          while (ancestor) {
-            for (var i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor);
-            }
-            ancestor.elm = vnode.elm;
-            if (patchable) {
-              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                cbs.create[i$1](emptyNode, ancestor);
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              var insert = ancestor.data.hook.insert;
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                  insert.fns[i$2]();
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        var elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        var i;
+        var data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        var oldCh = oldVnode.children;
+        var ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                { cbs.update[i](oldVnode, vnode); }
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                { i(oldVnode, vnode); }
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+            }
+            else if (isDef(ch)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkDuplicateKeys(ch);
                 }
-              }
-            } else {
-              registerRef(ancestor);
+                if (isDef(oldVnode.text))
+                    { nodeOps.setTextContent(elm, ''); }
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
             }
-            ancestor = ancestor.parent;
-          }
         }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes([oldVnode], 0, 0);
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode);
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                { i(oldVnode, vnode); }
         }
-      }
     }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-    return vnode.elm
-  }
-}
-
-/*  */
-
-var directives = {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode) {
-    updateDirectives(vnode, emptyNode);
-  }
-};
-
-function updateDirectives (oldVnode, vnode) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode);
-  }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    var hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        var i;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        if (process.env.NODE_ENV !== 'production') {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                { i(vnode, true /* hydrating */); }
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        var childrenMatch = true;
+                        var childNode = elm.firstChild;
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                var fullInvoke = false;
+                for (var key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement$$1(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                { invokeDestroyHook(oldVnode); }
+            return;
+        }
+        var isInitialPatch = false;
+        var insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            var isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else if (process.env.NODE_ENV !== 'production') {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                var oldElm = oldVnode.elm;
+                var parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    var ancestor = vnode.parent;
+                    var patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-function _update (oldVnode, vnode) {
-  var isCreate = oldVnode === emptyNode;
-  var isDestroy = vnode === emptyNode;
-  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-  var dirsWithInsert = [];
-  var dirsWithPostpatch = [];
-
-  var key, oldDir, dir;
-  for (key in newDirs) {
-    oldDir = oldDirs[key];
-    dir = newDirs[key];
-    if (!oldDir) {
-      // new directive, bind
-      callHook$1(dir, 'bind', vnode, oldVnode);
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir);
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value;
-      dir.oldArg = oldDir.arg;
-      callHook$1(dir, 'update', vnode, oldVnode);
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir);
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    var callInsert = function () {
-      for (var i = 0; i < dirsWithInsert.length; i++) {
-        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-      }
-    };
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert);
-    } else {
-      callInsert();
+/* @flow */
+var directives = {
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
+};
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook$1(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook$1(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
     }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', function () {
-      for (var i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-      }
-    });
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-      }
+    if (dirsWithInsert.length) {
+        var callInsert = function () {
+            for (var i = 0; i < dirsWithInsert.length; i++) {
+                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', function () {
+            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
     }
-  }
 }
-
 var emptyModifiers = Object.create(null);
-
-function normalizeDirectives$1 (
-  dirs,
-  vm
-) {
-  var res = Object.create(null);
-  if (!dirs) {
+function normalizeDirectives$1(dirs, vm) {
+    var res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    var i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
     // $flow-disable-line
-    return res
-  }
-  var i, dir;
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i];
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers;
-    }
-    res[getRawDirName(dir)] = dir;
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-  }
-  // $flow-disable-line
-  return res
+    return res;
 }
-
-function getRawDirName (dir) {
-  return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
+function getRawDirName(dir) {
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
 }
-
-function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-  var fn = dir.def && dir.def[hook];
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-    } catch (e) {
-      handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+    var fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+        }
     }
-  }
 }
 
-var baseModules = [
-  ref,
-  directives
-];
-
-/*  */
+var baseModules = [ref, directives];
 
-function updateAttrs (oldVnode, vnode) {
-  var opts = vnode.componentOptions;
-  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-    return
-  }
-  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-    return
-  }
-  var key, cur, old;
-  var elm = vnode.elm;
-  var oldAttrs = oldVnode.data.attrs || {};
-  var attrs = vnode.data.attrs || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__)) {
-    attrs = vnode.data.attrs = extend({}, attrs);
-  }
-
-  for (key in attrs) {
-    cur = attrs[key];
-    old = oldAttrs[key];
-    if (old !== cur) {
-      setAttr(elm, key, cur);
-    }
-  }
-  // #4391: in IE9, setting type can reset value for input[type=radio]
-  // #6666: IE/Edge forces progress value down to 1 before setting a max
-  /* istanbul ignore if */
-  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-    setAttr(elm, 'value', attrs.value);
-  }
-  for (key in oldAttrs) {
-    if (isUndef(attrs[key])) {
-      if (isXlink(key)) {
-        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else if (!isEnumeratedAttr(key)) {
-        elm.removeAttribute(key);
-      }
-    }
-  }
+/* @flow */
+function updateAttrs(oldVnode, vnode) {
+    var opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
 }
-
-function setAttr (el, key, value) {
-  if (el.tagName.indexOf('-') > -1) {
-    baseSetAttr(el, key, value);
-  } else if (isBooleanAttr(key)) {
-    // set attribute for blank value
-    // e.g. <option disabled>Select one</option>
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // technically allowfullscreen is a boolean attribute for <iframe>,
-      // but Flash expects a value of "true" when used on <embed> tag
-      value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-        ? 'true'
-        : key;
-      el.setAttribute(key, value);
-    }
-  } else if (isEnumeratedAttr(key)) {
-    el.setAttribute(key, convertEnumeratedValue(key, value));
-  } else if (isXlink(key)) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-    } else {
-      el.setAttributeNS(xlinkNS, key, value);
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
     }
-  } else {
-    baseSetAttr(el, key, value);
-  }
 }
-
-function baseSetAttr (el, key, value) {
-  if (isFalsyAttrValue(value)) {
-    el.removeAttribute(key);
-  } else {
-    // #7138: IE10 & 11 fires input event when setting placeholder on
-    // <textarea>... block the first input event and remove the blocker
-    // immediately.
-    /* istanbul ignore if */
-    if (
-      isIE && !isIE9 &&
-      el.tagName === 'TEXTAREA' &&
-      key === 'placeholder' && value !== '' && !el.__ieph
-    ) {
-      var blocker = function (e) {
-        e.stopImmediatePropagation();
-        el.removeEventListener('input', blocker);
-      };
-      el.addEventListener('input', blocker);
-      // $flow-disable-line
-      el.__ieph = true; /* IE placeholder patched */
-    }
-    el.setAttribute(key, value);
-  }
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            var blocker = function (e) {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
 }
-
 var attrs = {
-  create: updateAttrs,
-  update: updateAttrs
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-/*  */
-
-function updateClass (oldVnode, vnode) {
-  var el = vnode.elm;
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-  if (
-    isUndef(data.staticClass) &&
-    isUndef(data.class) && (
-      isUndef(oldData) || (
-        isUndef(oldData.staticClass) &&
-        isUndef(oldData.class)
-      )
-    )
-  ) {
-    return
-  }
-
-  var cls = genClassForVnode(vnode);
-
-  // handle transition classes
-  var transitionClass = el._transitionClasses;
-  if (isDef(transitionClass)) {
-    cls = concat(cls, stringifyClass(transitionClass));
-  }
-
-  // set the class
-  if (cls !== el._prevClass) {
-    el.setAttribute('class', cls);
-    el._prevClass = cls;
-  }
+/* @flow */
+function updateClass(oldVnode, vnode) {
+    var el = vnode.elm;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    var cls = genClassForVnode(vnode);
+    // handle transition classes
+    var transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
 }
-
 var klass = {
-  create: updateClass,
-  update: updateClass
+    create: updateClass,
+    update: updateClass,
 };
 
-/*  */
-
-/*  */
+/* @flow */
 
-/*  */
+/* @flow */
 
-/*  */
+/* @flow */
 
+/* @flow */
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
 
-/*  */
-
+/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
 // user-attached handlers.
-function normalizeEvents (on) {
-  /* istanbul ignore if */
-  if (isDef(on[RANGE_TOKEN])) {
-    // IE input[type=range] only supports `change` event
-    var event = isIE ? 'change' : 'input';
-    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-    delete on[RANGE_TOKEN];
-  }
-  // This was originally intended to fix #4521 but no longer necessary
-  // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-  /* istanbul ignore if */
-  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-    delete on[CHECKBOX_RADIO_TOKEN];
-  }
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
 }
-
 var target$1;
-
-function createOnceHandler$1 (event, handler, capture) {
-  var _target = target$1; // save current target element in closure
-  return function onceHandler () {
-    var res = handler.apply(null, arguments);
-    if (res !== null) {
-      remove$2(event, onceHandler, capture, _target);
-    }
-  }
+function createOnceHandler$1(event, handler, capture) {
+    var _target = target$1; // save current target element in closure
+    return function onceHandler() {
+        var res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove$2(event, onceHandler, capture, _target);
+        }
+    };
 }
-
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-function add$1 (
-  name,
-  handler,
-  capture,
-  passive
-) {
-  // async edge case #6566: inner click event triggers patch, event handler
-  // attached to outer element during patch, and triggered again. This
-  // happens because browsers fire microtask ticks between event propagation.
-  // the solution is simple: we save the timestamp when a handler is attached,
-  // and the handler would only fire if the event passed to it was fired
-  // AFTER it was attached.
-  if (useMicrotaskFix) {
-    var attachedTimestamp = currentFlushTimestamp;
-    var original = handler;
-    handler = original._wrapper = function (e) {
-      if (
-        // no bubbling, should always fire.
-        // this is just a safety net in case event.timeStamp is unreliable in
-        // certain weird environments...
-        e.target === e.currentTarget ||
-        // event is fired after handler attachment
-        e.timeStamp >= attachedTimestamp ||
-        // bail for environments that have buggy event.timeStamp implementations
-        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-        // #9681 QtWebEngine event.timeStamp is negative value
-        e.timeStamp <= 0 ||
-        // #9448 bail if event is fired in another document in a multi-page
-        // electron/nw.js app, since event.timeStamp will be using a different
-        // starting reference
-        e.target.ownerDocument !== document
-      ) {
-        return original.apply(this, arguments)
-      }
-    };
-  }
-  target$1.addEventListener(
-    name,
-    handler,
-    supportsPassive
-      ? { capture: capture, passive: passive }
-      : capture
-  );
+function add$1(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
+        //@ts-expect-error
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-
-function remove$2 (
-  name,
-  handler,
-  capture,
-  _target
-) {
-  (_target || target$1).removeEventListener(
-    name,
-    handler._wrapper || handler,
-    capture
-  );
+function remove$2(name, handler, capture, _target) {
+    (_target || target$1).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
 }
-
-function updateDOMListeners (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-    return
-  }
-  var on = vnode.data.on || {};
-  var oldOn = oldVnode.data.on || {};
-  target$1 = vnode.elm;
-  normalizeEvents(on);
-  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-  target$1 = undefined;
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target$1 = vnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+    target$1 = undefined;
 }
-
 var events = {
-  create: updateDOMListeners,
-  update: updateDOMListeners
+    create: updateDOMListeners,
+    update: updateDOMListeners,
 };
 
-/*  */
-
+/* @flow */
 var svgContainer;
-
-function updateDOMProps (oldVnode, vnode) {
-  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-    return
-  }
-  var key, cur;
-  var elm = vnode.elm;
-  var oldProps = oldVnode.data.domProps || {};
-  var props = vnode.data.domProps || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
-    props = vnode.data.domProps = extend({}, props);
-  }
-
-  for (key in oldProps) {
-    if (!(key in props)) {
-      elm[key] = '';
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    var key, cur;
+    var elm = vnode.elm;
+    var oldProps = oldVnode.data.domProps || {};
+    var props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
     }
-  }
-
-  for (key in props) {
-    cur = props[key];
-    // ignore children if the node has textContent or innerHTML,
-    // as these will throw away existing DOM nodes and cause removal errors
-    // on subsequent patches (#3360)
-    if (key === 'textContent' || key === 'innerHTML') {
-      if (vnode.children) { vnode.children.length = 0; }
-      if (cur === oldProps[key]) { continue }
-      // #6601 work around Chrome version <= 55 bug where single textNode
-      // replaced by innerHTML/textContent retains its parentNode property
-      if (elm.childNodes.length === 1) {
-        elm.removeChild(elm.childNodes[0]);
-      }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                { vnode.children.length = 0; }
+            if (cur === oldProps[key])
+                { continue; }
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            var strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+            var svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
     }
-
-    if (key === 'value' && elm.tagName !== 'PROGRESS') {
-      // store value as _value as well since
-      // non-string values will be stringified
-      elm._value = cur;
-      // avoid resetting cursor position when value is the same
-      var strCur = isUndef(cur) ? '' : String(cur);
-      if (shouldUpdateValue(elm, strCur)) {
-        elm.value = strCur;
-      }
-    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-      // IE doesn't support innerHTML for SVG elements
-      svgContainer = svgContainer || document.createElement('div');
-      svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-      var svg = svgContainer.firstChild;
-      while (elm.firstChild) {
-        elm.removeChild(elm.firstChild);
-      }
-      while (svg.firstChild) {
-        elm.appendChild(svg.firstChild);
-      }
-    } else if (
-      // skip the update if old and new VDOM state is the same.
-      // `value` is handled separately because the DOM value may be temporarily
-      // out of sync with VDOM state due to focus, composition and modifiers.
-      // This  #4521 by skipping the unnecessary `checked` update.
-      cur !== oldProps[key]
-    ) {
-      // some property updates can throw
-      // e.g. `value` on <progress> w/ non-finite value
-      try {
-        elm[key] = cur;
-      } catch (e) {}
-    }
-  }
 }
-
-// check platforms/web/util/attrs.js acceptValue
-
-
-function shouldUpdateValue (elm, checkVal) {
-  return (!elm.composing && (
-    elm.tagName === 'OPTION' ||
-    isNotInFocusAndDirty(elm, checkVal) ||
-    isDirtyWithModifiers(elm, checkVal)
-  ))
-}
-
-function isNotInFocusAndDirty (elm, checkVal) {
-  // return true when textbox (.number and .trim) loses focus and its value is
-  // not equal to the updated value
-  var notInFocus = true;
-  // #6157
-  // work around IE bug when accessing document.activeElement in an iframe
-  try { notInFocus = document.activeElement !== elm; } catch (e) {}
-  return notInFocus && elm.value !== checkVal
-}
-
-function isDirtyWithModifiers (elm, newVal) {
-  var value = elm.value;
-  var modifiers = elm._vModifiers; // injected by v-model runtime
-  if (isDef(modifiers)) {
-    if (modifiers.number) {
-      return toNumber(value) !== toNumber(newVal)
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    var notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
     }
-    if (modifiers.trim) {
-      return value.trim() !== newVal.trim()
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    var value = elm.value;
+    var modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
     }
-  }
-  return value !== newVal
+    return value !== newVal;
 }
-
 var domProps = {
-  create: updateDOMProps,
-  update: updateDOMProps
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-/*  */
-
+/* @flow */
 var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  var style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    var style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  var res = {};
-  var styleData;
-
-  if (checkChild) {
-    var childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    var res = {};
+    var styleData;
+    if (checkChild) {
+        var childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  var parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    var parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
+/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
-  /* istanbul ignore if */
-  if (cssVarRE.test(name)) {
-    el.style.setProperty(name, val);
-  } else if (importantRE.test(val)) {
-    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-  } else {
-    var normalizedName = normalize(name);
-    if (Array.isArray(val)) {
-      // Support values array created by autoprefixer, e.g.
-      // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-      // Set them one by one, and the browser will only set those it can recognize
-      for (var i = 0, len = val.length; i < len; i++) {
-        el.style[normalizedName] = val[i];
-      }
-    } else {
-      el.style[normalizedName] = val;
-    }
-  }
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        var normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (var i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
 };
-
 var vendorNames = ['Webkit', 'Moz', 'ms'];
-
 var emptyStyle;
 var normalize = cached(function (prop) {
-  emptyStyle = emptyStyle || document.createElement('div').style;
-  prop = camelize(prop);
-  if (prop !== 'filter' && (prop in emptyStyle)) {
-    return prop
-  }
-  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-  for (var i = 0; i < vendorNames.length; i++) {
-    var name = vendorNames[i] + capName;
-    if (name in emptyStyle) {
-      return name
-    }
-  }
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (var i = 0; i < vendorNames.length; i++) {
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
 });
-
-function updateStyle (oldVnode, vnode) {
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-
-  if (isUndef(data.staticStyle) && isUndef(data.style) &&
-    isUndef(oldData.staticStyle) && isUndef(oldData.style)
-  ) {
-    return
-  }
-
-  var cur, name;
-  var el = vnode.elm;
-  var oldStaticStyle = oldData.staticStyle;
-  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-  // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-  var oldStyle = oldStaticStyle || oldStyleBinding;
-
-  var style = normalizeStyleBinding(vnode.data.style) || {};
-
-  // store normalized style under a different key for next diff
-  // make sure to clone it if it's reactive, since the user likely wants
-  // to mutate it.
-  vnode.data.normalizedStyle = isDef(style.__ob__)
-    ? extend({}, style)
-    : style;
-
-  var newStyle = getStyle(vnode, true);
-
-  for (name in oldStyle) {
-    if (isUndef(newStyle[name])) {
-      setProp(el, name, '');
+function updateStyle(oldVnode, vnode) {
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    var cur, name;
+    var el = vnode.elm;
+    var oldStaticStyle = oldData.staticStyle;
+    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    var oldStyle = oldStaticStyle || oldStyleBinding;
+    var style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    var newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
     }
-  }
-  for (name in newStyle) {
-    cur = newStyle[name];
-    if (cur !== oldStyle[name]) {
-      // ie9 setting to null has no effect, must use empty string
-      setProp(el, name, cur == null ? '' : cur);
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
     }
-  }
 }
-
 var style = {
-  create: updateStyle,
-  update: updateStyle
+    create: updateStyle,
+    update: updateStyle,
 };
 
-/*  */
-
+/* @flow */
 var whitespaceRE = /\s+/;
-
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-    } else {
-      el.classList.add(cls);
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+        }
+        else {
+            el.classList.add(cls);
+        }
     }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    if (cur.indexOf(' ' + cls + ' ') < 0) {
-      el.setAttribute('class', (cur + cls).trim());
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
     }
-  }
 }
-
 /**
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass (el, cls) {
-  /* istanbul ignore if */
-  if (!cls || !(cls = cls.trim())) {
-    return
-  }
-
-  /* istanbul ignore else */
-  if (el.classList) {
-    if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-    } else {
-      el.classList.remove(cls);
-    }
-    if (!el.classList.length) {
-      el.removeAttribute('class');
-    }
-  } else {
-    var cur = " " + (el.getAttribute('class') || '') + " ";
-    var tar = ' ' + cls + ' ';
-    while (cur.indexOf(tar) >= 0) {
-      cur = cur.replace(tar, ' ');
-    }
-    cur = cur.trim();
-    if (cur) {
-      el.setAttribute('class', cur);
-    } else {
-      el.removeAttribute('class');
-    }
-  }
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-/*  */
-
-function resolveTransition (def$$1) {
-  if (!def$$1) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def$$1 === 'object') {
-    var res = {};
-    if (def$$1.css !== false) {
-      extend(res, autoCssTransition(def$$1.name || 'v'));
+function resolveTransition(def$$1) {
+    if (!def$$1) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def$$1 === 'object') {
+        var res = {};
+        if (def$$1.css !== false) {
+            extend(res, autoCssTransition(def$$1.name || 'v'));
+        }
+        extend(res, def$$1);
+        return res;
+    }
+    else if (typeof def$$1 === 'string') {
+        return autoCssTransition(def$$1);
     }
-    extend(res, def$$1);
-    return res
-  } else if (typeof def$$1 === 'string') {
-    return autoCssTransition(def$$1)
-  }
 }
-
 var autoCssTransition = cached(function (name) {
-  return {
-    enterClass: (name + "-enter"),
-    enterToClass: (name + "-enter-to"),
-    enterActiveClass: (name + "-enter-active"),
-    leaveClass: (name + "-leave"),
-    leaveToClass: (name + "-leave-to"),
-    leaveActiveClass: (name + "-leave-active")
-  }
+    return {
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
+    };
 });
-
 var hasTransition = inBrowser && !isIE9;
 var TRANSITION = 'transition';
 var ANIMATION = 'animation';
-
 // Transition property/event sniffing
 var transitionProp = 'transition';
 var transitionEndEvent = 'transitionend';
 var animationProp = 'animation';
 var animationEndEvent = 'animationend';
 if (hasTransition) {
-  /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) {
-    transitionProp = 'WebkitTransition';
-    transitionEndEvent = 'webkitTransitionEnd';
-  }
-  if (window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) {
-    animationProp = 'WebkitAnimation';
-    animationEndEvent = 'webkitAnimationEnd';
-  }
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
 }
-
 // binding to window is necessary to make hot reload work in IE in strict mode
 var raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ function (fn) { return fn(); };
-
-function nextFrame (fn) {
-  raf(function () {
-    raf(fn);
-  });
-}
-
-function addTransitionClass (el, cls) {
-  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-  if (transitionClasses.indexOf(cls) < 0) {
-    transitionClasses.push(cls);
-    addClass(el, cls);
-  }
-}
-
-function removeTransitionClass (el, cls) {
-  if (el._transitionClasses) {
-    remove(el._transitionClasses, cls);
-  }
-  removeClass(el, cls);
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
 }
-
-function whenTransitionEnds (
-  el,
-  expectedType,
-  cb
-) {
-  var ref = getTransitionInfo(el, expectedType);
-  var type = ref.type;
-  var timeout = ref.timeout;
-  var propCount = ref.propCount;
-  if (!type) { return cb() }
-  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-  var ended = 0;
-  var end = function () {
-    el.removeEventListener(event, onEnd);
-    cb();
-  };
-  var onEnd = function (e) {
-    if (e.target === el) {
-      if (++ended >= propCount) {
-        end();
-      }
-    }
-  };
-  setTimeout(function () {
-    if (ended < propCount) {
-      end();
-    }
-  }, timeout + 1);
-  el.addEventListener(event, onEnd);
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
 }
-
 var transformRE = /\b(transform|all)(,|$)/;
-
-function getTransitionInfo (el, expectedType) {
-  var styles = window.getComputedStyle(el);
-  // JSDOM may return undefined for transition properties
-  var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-  var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-  var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-  var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-  var animationTimeout = getTimeout(animationDelays, animationDurations);
-
-  var type;
-  var timeout = 0;
-  var propCount = 0;
-  /* istanbul ignore if */
-  if (expectedType === TRANSITION) {
-    if (transitionTimeout > 0) {
-      type = TRANSITION;
-      timeout = transitionTimeout;
-      propCount = transitionDurations.length;
-    }
-  } else if (expectedType === ANIMATION) {
-    if (animationTimeout > 0) {
-      type = ANIMATION;
-      timeout = animationTimeout;
-      propCount = animationDurations.length;
-    }
-  } else {
-    timeout = Math.max(transitionTimeout, animationTimeout);
-    type = timeout > 0
-      ? transitionTimeout > animationTimeout
-        ? TRANSITION
-        : ANIMATION
-      : null;
-    propCount = type
-      ? type === TRANSITION
-        ? transitionDurations.length
-        : animationDurations.length
-      : 0;
-  }
-  var hasTransform =
-    type === TRANSITION &&
-    transformRE.test(styles[transitionProp + 'Property']);
-  return {
-    type: type,
-    timeout: timeout,
-    propCount: propCount,
-    hasTransform: hasTransform
-  }
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
 }
-
-function getTimeout (delays, durations) {
-  /* istanbul ignore next */
-  while (delays.length < durations.length) {
-    delays = delays.concat(delays);
-  }
-
-  return Math.max.apply(null, durations.map(function (d, i) {
-    return toMs(d) + toMs(delays[i])
-  }))
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
 }
-
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs (s) {
-  return Number(s.slice(0, -1).replace(',', '.')) * 1000
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-/*  */
-
-function enter (vnode, toggleDisplay) {
-  var el = vnode.elm;
-
-  // call leave callback now
-  if (isDef(el._leaveCb)) {
-    el._leaveCb.cancelled = true;
-    el._leaveCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data)) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._enterCb) || el.nodeType !== 1) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var enterClass = data.enterClass;
-  var enterToClass = data.enterToClass;
-  var enterActiveClass = data.enterActiveClass;
-  var appearClass = data.appearClass;
-  var appearToClass = data.appearToClass;
-  var appearActiveClass = data.appearActiveClass;
-  var beforeEnter = data.beforeEnter;
-  var enter = data.enter;
-  var afterEnter = data.afterEnter;
-  var enterCancelled = data.enterCancelled;
-  var beforeAppear = data.beforeAppear;
-  var appear = data.appear;
-  var afterAppear = data.afterAppear;
-  var appearCancelled = data.appearCancelled;
-  var duration = data.duration;
-
-  // activeInstance will always be the <transition> component managing this
-  // transition. One edge case to check is when the <transition> is placed
-  // as the root node of a child component. In that case we need to check
-  // <transition>'s parent for appear check.
-  var context = activeInstance;
-  var transitionNode = activeInstance.$vnode;
-  while (transitionNode && transitionNode.parent) {
-    context = transitionNode.context;
-    transitionNode = transitionNode.parent;
-  }
-
-  var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  var startClass = isAppear && appearClass
-    ? appearClass
-    : enterClass;
-  var activeClass = isAppear && appearActiveClass
-    ? appearActiveClass
-    : enterActiveClass;
-  var toClass = isAppear && appearToClass
-    ? appearToClass
-    : enterToClass;
-
-  var beforeEnterHook = isAppear
-    ? (beforeAppear || beforeEnter)
-    : beforeEnter;
-  var enterHook = isAppear
-    ? (typeof appear === 'function' ? appear : enter)
-    : enter;
-  var afterEnterHook = isAppear
-    ? (afterAppear || afterEnter)
-    : afterEnter;
-  var enterCancelledHook = isAppear
-    ? (appearCancelled || enterCancelled)
-    : enterCancelled;
-
-  var explicitEnterDuration = toNumber(
-    isObject(duration)
-      ? duration.enter
-      : duration
-  );
-
-  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-    checkDuration(explicitEnterDuration, 'enter', vnode);
-  }
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(enterHook);
-
-  var cb = el._enterCb = once(function () {
-    if (expectsCSS) {
-      removeTransitionClass(el, toClass);
-      removeTransitionClass(el, activeClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, startClass);
-      }
-      enterCancelledHook && enterCancelledHook(el);
-    } else {
-      afterEnterHook && afterEnterHook(el);
-    }
-    el._enterCb = null;
-  });
-
-  if (!vnode.data.show) {
-    // remove pending leave element on enter by injecting an insert hook
-    mergeVNodeHook(vnode, 'insert', function () {
-      var parent = el.parentNode;
-      var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-      if (pendingNode &&
-        pendingNode.tag === vnode.tag &&
-        pendingNode.elm._leaveCb
-      ) {
-        pendingNode.elm._leaveCb();
-      }
-      enterHook && enterHook(el, cb);
-    });
-  }
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el);
-  if (expectsCSS) {
-    addTransitionClass(el, startClass);
-    addTransitionClass(el, activeClass);
-    nextFrame(function () {
-      removeTransitionClass(el, startClass);
-      if (!cb.cancelled) {
-        addTransitionClass(el, toClass);
-        if (!userWantsControl) {
-          if (isValidDuration(explicitEnterDuration)) {
-            setTimeout(cb, explicitEnterDuration);
-          } else {
-            whenTransitionEnds(el, type, cb);
-          }
-        }
-      }
-    });
-  }
-
-  if (vnode.data.show) {
-    toggleDisplay && toggleDisplay();
-    enterHook && enterHook(el, cb);
-  }
-
-  if (!expectsCSS && !userWantsControl) {
-    cb();
-  }
-}
-
-function leave (vnode, rm) {
-  var el = vnode.elm;
-
-  // call enter callback now
-  if (isDef(el._enterCb)) {
-    el._enterCb.cancelled = true;
-    el._enterCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (isUndef(data) || el.nodeType !== 1) {
-    return rm()
-  }
-
-  /* istanbul ignore if */
-  if (isDef(el._leaveCb)) {
-    return
-  }
-
-  var css = data.css;
-  var type = data.type;
-  var leaveClass = data.leaveClass;
-  var leaveToClass = data.leaveToClass;
-  var leaveActiveClass = data.leaveActiveClass;
-  var beforeLeave = data.beforeLeave;
-  var leave = data.leave;
-  var afterLeave = data.afterLeave;
-  var leaveCancelled = data.leaveCancelled;
-  var delayLeave = data.delayLeave;
-  var duration = data.duration;
-
-  var expectsCSS = css !== false && !isIE9;
-  var userWantsControl = getHookArgumentsLength(leave);
-
-  var explicitLeaveDuration = toNumber(
-    isObject(duration)
-      ? duration.leave
-      : duration
-  );
-
-  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-    checkDuration(explicitLeaveDuration, 'leave', vnode);
-  }
-
-  var cb = el._leaveCb = once(function () {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null;
+/* @flow */
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
     }
-    if (expectsCSS) {
-      removeTransitionClass(el, leaveToClass);
-      removeTransitionClass(el, leaveActiveClass);
-    }
-    if (cb.cancelled) {
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveClass);
-      }
-      leaveCancelled && leaveCancelled(el);
-    } else {
-      rm();
-      afterLeave && afterLeave(el);
-    }
-    el._leaveCb = null;
-  });
-
-  if (delayLeave) {
-    delayLeave(performLeave);
-  } else {
-    performLeave();
-  }
-
-  function performLeave () {
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
     }
-    // record leaving element
-    if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
     }
-    beforeLeave && beforeLeave(el);
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-      addTransitionClass(el, leaveClass);
-      addTransitionClass(el, leaveActiveClass);
-      nextFrame(function () {
-        removeTransitionClass(el, leaveClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, leaveToClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitLeaveDuration)) {
-              setTimeout(cb, explicitLeaveDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-    leave && leave(el, cb);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
     if (!expectsCSS && !userWantsControl) {
-      cb();
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
     }
-  }
 }
-
 // only used in dev mode
-function checkDuration (val, name, vnode) {
-  if (typeof val !== 'number') {
-    warn(
-      "<transition> explicit " + name + " duration is not a valid number - " +
-      "got " + (JSON.stringify(val)) + ".",
-      vnode.context
-    );
-  } else if (isNaN(val)) {
-    warn(
-      "<transition> explicit " + name + " duration is NaN - " +
-      'the duration expression might be incorrect.',
-      vnode.context
-    );
-  }
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn("<transition> explicit " + name + " duration is not a valid number - " +
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
 }
-
-function isValidDuration (val) {
-  return typeof val === 'number' && !isNaN(val)
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
 }
-
 /**
  * Normalize a transition hook's argument length. The hook may be:
  * - a merged hook (invoker) with the original in .fns
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength (fn) {
-  if (isUndef(fn)) {
-    return false
-  }
-  var invokerFns = fn.fns;
-  if (isDef(invokerFns)) {
-    // invoker
-    return getHookArgumentsLength(
-      Array.isArray(invokerFns)
-        ? invokerFns[0]
-        : invokerFns
-    )
-  } else {
-    return (fn._length || fn.length) > 1
-  }
-}
-
-function _enter (_, vnode) {
-  if (vnode.data.show !== true) {
-    enter(vnode);
-  }
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
 }
-
-var transition = inBrowser ? {
-  create: _enter,
-  activate: _enter,
-  remove: function remove$$1 (vnode, rm) {
-    /* istanbul ignore else */
+function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-      leave(vnode, rm);
-    } else {
-      rm();
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove: function remove$$1(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
     }
-  }
-} : {};
+    : {};
 
-var platformModules = [
-  attrs,
-  klass,
-  events,
-  domProps,
-  style,
-  transition
-];
-
-/*  */
+var platformModules = [attrs, klass, events, domProps, style, transition];
 
+/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
-
 var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
  * properties to Elements.
  */
-
 /* istanbul ignore if */
 if (isIE9) {
-  // http://www.matts411.com/post/internet-explorer-9-oninput/
-  document.addEventListener('selectionchange', function () {
-    var el = document.activeElement;
-    if (el && el.vmodel) {
-      trigger(el, 'input');
-    }
-  });
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', function () {
+        var el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
 }
-
 var directive = {
-  inserted: function inserted (el, binding, vnode, oldVnode) {
-    if (vnode.tag === 'select') {
-      // #6903
-      if (oldVnode.elm && !oldVnode.elm._vOptions) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-          directive.componentUpdated(el, binding, vnode);
-        });
-      } else {
-        setSelected(el, binding, vnode.context);
-      }
-      el._vOptions = [].map.call(el.options, getValue);
-    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-      el._vModifiers = binding.modifiers;
-      if (!binding.modifiers.lazy) {
-        el.addEventListener('compositionstart', onCompositionStart);
-        el.addEventListener('compositionend', onCompositionEnd);
-        // Safari < 10.2 & UIWebView doesn't fire compositionend when
-        // switching focus before confirming composition choice
-        // this also fixes the issue where some browsers e.g. iOS Chrome
-        // fires "change" instead of "input" on autocomplete.
-        el.addEventListener('change', onCompositionEnd);
-        /* istanbul ignore if */
-        if (isIE9) {
-          el.vmodel = true;
+    inserted: function inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', function () {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
         }
-      }
-    }
-  },
-
-  componentUpdated: function componentUpdated (el, binding, vnode) {
-    if (vnode.tag === 'select') {
-      setSelected(el, binding, vnode.context);
-      // in case the options rendered by v-for have changed,
-      // it's possible that the value is out-of-sync with the rendered options.
-      // detect such cases and filter out values that no longer has a matching
-      // option in the DOM.
-      var prevOptions = el._vOptions;
-      var curOptions = el._vOptions = [].map.call(el.options, getValue);
-      if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-        // trigger change event if
-        // no matching option found for at least one value
-        var needReset = el.multiple
-          ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-        if (needReset) {
-          trigger(el, 'change');
-        }
-      }
-    }
-  }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated: function componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                // trigger change event if
+                // no matching option found for at least one value
+                var needReset = el.multiple
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
 };
-
-function setSelected (el, binding, vm) {
-  actuallySetSelected(el, binding, vm);
-  /* istanbul ignore if */
-  if (isIE || isEdge) {
-    setTimeout(function () {
-      actuallySetSelected(el, binding, vm);
-    }, 0);
-  }
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(function () {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
 }
-
-function actuallySetSelected (el, binding, vm) {
-  var value = binding.value;
-  var isMultiple = el.multiple;
-  if (isMultiple && !Array.isArray(value)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      "<select multiple v-model=\"" + (binding.expression) + "\"> " +
-      "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
-      vm
-    );
-    return
-  }
-  var selected, option;
-  for (var i = 0, l = el.options.length; i < l; i++) {
-    option = el.options[i];
-    if (isMultiple) {
-      selected = looseIndexOf(value, getValue(option)) > -1;
-      if (option.selected !== selected) {
-        option.selected = selected;
-      }
-    } else {
-      if (looseEqual(getValue(option), value)) {
-        if (el.selectedIndex !== i) {
-          el.selectedIndex = i;
-        }
-        return
-      }
-    }
-  }
-  if (!isMultiple) {
-    el.selectedIndex = -1;
-  }
+function actuallySetSelected(el, binding, vm) {
+    var value = binding.value;
+    var isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)), vm);
+        return;
+    }
+    var selected, option;
+    for (var i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
 }
-
-function hasNoMatchingOption (value, options) {
-  return options.every(function (o) { return !looseEqual(o, value); })
+function hasNoMatchingOption(value, options) {
+    return options.every(function (o) { return !looseEqual(o, value); });
 }
-
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
 }
-
-function onCompositionStart (e) {
-  e.target.composing = true;
+function onCompositionStart(e) {
+    e.target.composing = true;
 }
-
-function onCompositionEnd (e) {
-  // prevent triggering an input event for no reason
-  if (!e.target.composing) { return }
-  e.target.composing = false;
-  trigger(e.target, 'input');
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        { return; }
+    e.target.composing = false;
+    trigger(e.target, 'input');
 }
-
-function trigger (el, type) {
-  var e = document.createEvent('HTMLEvents');
-  e.initEvent(type, true, true);
-  el.dispatchEvent(e);
+function trigger(el, type) {
+    var e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-/*  */
-
+/* @flow */
 // recursively search for possible transition defined inside the component root
-function locateNode (vnode) {
-  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-    ? locateNode(vnode.componentInstance._vnode)
-    : vnode
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
 }
-
 var show = {
-  bind: function bind (el, ref, vnode) {
-    var value = ref.value;
-
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    var originalDisplay = el.__vOriginalDisplay =
-      el.style.display === 'none' ? '' : el.style.display;
-    if (value && transition$$1) {
-      vnode.data.show = true;
-      enter(vnode, function () {
-        el.style.display = originalDisplay;
-      });
-    } else {
-      el.style.display = value ? originalDisplay : 'none';
-    }
-  },
-
-  update: function update (el, ref, vnode) {
-    var value = ref.value;
-    var oldValue = ref.oldValue;
-
-    /* istanbul ignore if */
-    if (!value === !oldValue) { return }
-    vnode = locateNode(vnode);
-    var transition$$1 = vnode.data && vnode.data.transition;
-    if (transition$$1) {
-      vnode.data.show = true;
-      if (value) {
-        enter(vnode, function () {
-          el.style.display = el.__vOriginalDisplay;
-        });
-      } else {
-        leave(vnode, function () {
-          el.style.display = 'none';
-        });
-      }
-    } else {
-      el.style.display = value ? el.__vOriginalDisplay : 'none';
-    }
-  },
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition$$1) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
 
-  unbind: function unbind (
-    el,
-    binding,
-    vnode,
-    oldVnode,
-    isDestroy
-  ) {
-    if (!isDestroy) {
-      el.style.display = el.__vOriginalDisplay;
-    }
-  }
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            { return; }
+        vnode = locateNode(vnode);
+        var transition$$1 = vnode.data && vnode.data.transition;
+        if (transition$$1) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, function () {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
 var platformDirectives = {
-  model: directive,
-  show: show
+    model: directive,
+    show: show,
 };
 
-/*  */
-
+/* @flow */
 var transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
 };
-
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode) {
-  var compOptions = vnode && vnode.componentOptions;
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-function extractTransitionData (comp) {
-  var data = {};
-  var options = comp.$options;
-  // props
-  for (var key in options.propsData) {
-    data[key] = comp[key];
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  var listeners = options._parentListeners;
-  for (var key$1 in listeners) {
-    data[camelize(key$1)] = listeners[key$1];
-  }
-  return data
-}
-
-function placeholder (h, rawChild) {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
+function getRealChild(vnode) {
+    var compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    var data = {};
+    var options = comp.$options;
+    // props
+    for (var key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    var listeners = options._parentListeners;
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
 }
-
-function hasParentTransition (vnode) {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
     }
-  }
 }
-
-function isSameChild (child, oldChild) {
-  return oldChild.key === child.key && oldChild.tag === child.tag
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-
 var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
 var isVShowDirective = function (d) { return d.name === 'show'; };
-
 var Transition = {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render: function render (h) {
-    var this$1 = this;
-
-    var children = this.$slots.default;
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode);
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      );
-    }
-
-    var mode = this.mode;
-
-    // warn invalid mode
-    if (process.env.NODE_ENV !== 'production' &&
-      mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      );
-    }
-
-    var rawChild = children[0];
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    var child = getRealChild(rawChild);
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    var id = "__transition-" + (this._uid) + "-";
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key;
-
-    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-    var oldRawChild = this._vnode;
-    var oldChild = getRealChild(oldRawChild);
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true;
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      var oldData = oldChild.data.transition = extend({}, data);
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true;
-        mergeVNodeHook(oldData, 'afterLeave', function () {
-          this$1._leaving = false;
-          this$1.$forceUpdate();
-        });
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
-        }
-        var delayedLeave;
-        var performLeave = function () { delayedLeave(); };
-        mergeVNodeHook(data, 'afterEnter', performLeave);
-        mergeVNodeHook(data, 'enterCancelled', performLeave);
-        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-      }
-    }
-
-    return rawChild
-  }
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render: function render(h) {
+        var this$1 = this;
+
+        var children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        var mode = this.mode;
+        // warn invalid mode
+        if (process.env.NODE_ENV !== 'production' &&
+            mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        var rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        var child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        var id = "__transition-" + (this._uid) + "-";
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        var oldRawChild = this._vnode;
+        var oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            var oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', function () {
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                var delayedLeave;
+                var performLeave = function () {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-/*  */
-
+// Provides transition support for list items.
 var props = extend({
-  tag: String,
-  moveClass: String
+    tag: String,
+    moveClass: String,
 }, transitionProps);
-
+// @ts-ignore
 delete props.mode;
-
 var TransitionGroup = {
-  props: props,
-
-  beforeMount: function beforeMount () {
-    var this$1 = this;
-
-    var update = this._update;
-    this._update = function (vnode, hydrating) {
-      var restoreActiveInstance = setActiveInstance(this$1);
-      // force removing pass
-      this$1.__patch__(
-        this$1._vnode,
-        this$1.kept,
-        false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-      );
-      this$1._vnode = this$1.kept;
-      restoreActiveInstance();
-      update.call(this$1, vnode, hydrating);
-    };
-  },
-
-  render: function render (h) {
-    var tag = this.tag || this.$vnode.data.tag || 'span';
-    var map = Object.create(null);
-    var prevChildren = this.prevChildren = this.children;
-    var rawChildren = this.$slots.default || [];
-    var children = this.children = [];
-    var transitionData = extractTransitionData(this);
-
-    for (var i = 0; i < rawChildren.length; i++) {
-      var c = rawChildren[i];
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c);
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData;
-        } else if (process.env.NODE_ENV !== 'production') {
-          var opts = c.componentOptions;
-          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-          warn(("<transition-group> children must be keyed: <" + name + ">"));
-        }
-      }
-    }
-
-    if (prevChildren) {
-      var kept = [];
-      var removed = [];
-      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-        var c$1 = prevChildren[i$1];
-        c$1.data.transition = transitionData;
-        c$1.data.pos = c$1.elm.getBoundingClientRect();
-        if (map[c$1.key]) {
-          kept.push(c$1);
-        } else {
-          removed.push(c$1);
-        }
-      }
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
-    }
-
-    return h(tag, null, children)
-  },
-
-  updated: function updated () {
-    var children = this.prevChildren;
-    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
-    }
-
-    // we divide the work into three loops to avoid mixing DOM reads and writes
-    // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs);
-    children.forEach(recordPosition);
-    children.forEach(applyTranslation);
-
-    // force reflow to put everything in position
-    // assign to this to avoid being removed in tree-shaking
-    // $flow-disable-line
-    this._reflow = document.body.offsetHeight;
-
-    children.forEach(function (c) {
-      if (c.data.moved) {
-        var el = c.elm;
-        var s = el.style;
-        addTransitionClass(el, moveClass);
-        s.transform = s.WebkitTransform = s.transitionDuration = '';
-        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-          if (e && e.target !== el) {
-            return
-          }
-          if (!e || /transform$/.test(e.propertyName)) {
-            el.removeEventListener(transitionEndEvent, cb);
-            el._moveCb = null;
-            removeTransitionClass(el, moveClass);
-          }
+    props: props,
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
+        var update = this._update;
+        this._update = function (vnode, hydrating) {
+            var restoreActiveInstance = setActiveInstance(this$1);
+            // force removing pass
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this$1._vnode = this$1.kept;
+            restoreActiveInstance();
+            update.call(this$1, vnode, hydrating);
+        };
+    },
+    render: function render(h) {
+        var tag = this.tag || this.$vnode.data.tag || 'span';
+        var map = Object.create(null);
+        var prevChildren = (this.prevChildren = this.children);
+        var rawChildren = this.$slots.default || [];
+        var children = (this.children = []);
+        var transitionData = extractTransitionData(this);
+        for (var i = 0; i < rawChildren.length; i++) {
+            var c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    var opts = c.componentOptions;
+                    var name = opts
+                        ? opts.Ctor.options.name || opts.tag || ''
+                        : c.tag;
+                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                }
+            }
+        }
+        if (prevChildren) {
+            var kept = [];
+            var removed = [];
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
+                // @ts-ignore
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                // @ts-ignore
+                if (map[c$1.key]) {
+                    kept.push(c$1);
+                }
+                else {
+                    removed.push(c$1);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated: function updated() {
+        var children = this.prevChildren;
+        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach(function (c) {
+            // @ts-ignore
+            if (c.data.moved) {
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
         });
-      }
-    });
-  },
-
-  methods: {
-    hasMove: function hasMove (el, moveClass) {
-      /* istanbul ignore if */
-      if (!hasTransition) {
-        return false
-      }
-      /* istanbul ignore if */
-      if (this._hasMove) {
-        return this._hasMove
-      }
-      // Detect whether an element with the move class applied has
-      // CSS transitions. Since the element may be inside an entering
-      // transition at this very moment, we make a clone of it and remove
-      // all other transition classes applied to ensure only the move class
-      // is applied.
-      var clone = el.cloneNode();
-      if (el._transitionClasses) {
-        el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
-      }
-      addClass(clone, moveClass);
-      clone.style.display = 'none';
-      this.$el.appendChild(clone);
-      var info = getTransitionInfo(clone);
-      this.$el.removeChild(clone);
-      return (this._hasMove = info.hasTransform)
-    }
-  }
+    },
+    methods: {
+        hasMove: function hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            var clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach(function (cls) {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = 'none';
+            this.$el.appendChild(clone);
+            var info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
 };
-
-function callPendingCbs (c) {
-  /* istanbul ignore if */
-  if (c.elm._moveCb) {
-    c.elm._moveCb();
-  }
-  /* istanbul ignore if */
-  if (c.elm._enterCb) {
-    c.elm._enterCb();
-  }
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._moveCb) {
+        //@ts-ignore
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._enterCb) {
+        //@ts-ignore
+        c.elm._enterCb();
+    }
 }
-
-function recordPosition (c) {
-  c.data.newPos = c.elm.getBoundingClientRect();
+function recordPosition(c) {
+    //@ts-ignore
+    c.data.newPos = c.elm.getBoundingClientRect();
 }
-
-function applyTranslation (c) {
-  var oldPos = c.data.pos;
-  var newPos = c.data.newPos;
-  var dx = oldPos.left - newPos.left;
-  var dy = oldPos.top - newPos.top;
-  if (dx || dy) {
-    c.data.moved = true;
-    var s = c.elm.style;
-    s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-    s.transitionDuration = '0s';
-  }
+function applyTranslation(c) {
+    //@ts-ignore
+    var oldPos = c.data.pos;
+    //@ts-ignore
+    var newPos = c.data.newPos;
+    var dx = oldPos.left - newPos.left;
+    var dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        //@ts-ignore
+        c.data.moved = true;
+        //@ts-ignore
+        var s = c.elm.style;
+        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+        s.transitionDuration = '0s';
+    }
 }
 
 var platformComponents = {
-  Transition: Transition,
-  TransitionGroup: TransitionGroup
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
 };
 
-/*  */
-
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp;
 Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
 Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
-
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
 extend(Vue.options.components, platformComponents);
-
 // install platform patch function
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
 // public mount method
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  el = el && inBrowser ? query(el) : undefined;
-  return mountComponent(this, el, hydrating)
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
 };
-
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-  setTimeout(function () {
-    if (config.devtools) {
-      if (devtools) {
-        devtools.emit('init', Vue);
-      } else if (
-        process.env.NODE_ENV !== 'production' &&
-        process.env.NODE_ENV !== 'test'
-      ) {
-        console[console.info ? 'info' : 'log'](
-          'Download the Vue Devtools extension for a better development experience:\n' +
-          'https://github.com/vuejs/vue-devtools'
-        );
-      }
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-      process.env.NODE_ENV !== 'test' &&
-      config.productionTip !== false &&
-      typeof console !== 'undefined'
-    ) {
-      console[console.info ? 'info' : 'log'](
-        "You are running Vue in development mode.\n" +
-        "Make sure to turn on production mode when deploying for production.\n" +
-        "See more tips at https://vuejs.org/guide/deployment.html"
-      );
-    }
-  }, 0);
+    setTimeout(function () {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else if (process.env.NODE_ENV !== 'production' &&
+                process.env.NODE_ENV !== 'test') {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (process.env.NODE_ENV !== 'production' &&
+            process.env.NODE_ENV !== 'test' &&
+            config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                "Make sure to turn on production mode when deploying for production.\n" +
+                "See more tips at https://vuejs.org/guide/deployment.html");
+        }
+    }, 0);
 }
 
-/*  */
+/* @flow */
 
 export default Vue;
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index fa9c2fe22b7..6ac78dd7298 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
 (function (global, factory) {
@@ -9,189 +9,155 @@
   (global = global || self, global.Vue = factory());
 }(this, function () { 'use strict';
 
-  /*  */
-
+  /* @flow */
   var emptyObject = Object.freeze({});
-
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
-  function isUndef (v) {
-    return v === undefined || v === null
+  function isUndef(v) {
+      return v === undefined || v === null;
   }
-
-  function isDef (v) {
-    return v !== undefined && v !== null
+  function isDef(v) {
+      return v !== undefined && v !== null;
   }
-
-  function isTrue (v) {
-    return v === true
+  function isTrue(v) {
+      return v === true;
   }
-
-  function isFalse (v) {
-    return v === false
+  function isFalse(v) {
+      return v === false;
   }
-
   /**
    * Check if value is primitive.
    */
-  function isPrimitive (value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
   }
-
   /**
    * Quick object check - this is primarily used to tell
    * Objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
-  function isObject (obj) {
-    return obj !== null && typeof obj === 'object'
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
   }
-
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
   var _toString = Object.prototype.toString;
-
-  function toRawType (value) {
-    return _toString.call(value).slice(8, -1)
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
   }
-
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
-  function isPlainObject (obj) {
-    return _toString.call(obj) === '[object Object]'
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
   }
-
-  function isRegExp (v) {
-    return _toString.call(v) === '[object RegExp]'
+  function isRegExp(v) {
+      return _toString.call(v) === '[object RegExp]';
   }
-
   /**
    * Check if val is a valid array index.
    */
-  function isValidArrayIndex (val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
+  function isValidArrayIndex(val) {
+      var n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
-
-  function isPromise (val) {
-    return (
-      isDef(val) &&
-      typeof val.then === 'function' &&
-      typeof val.catch === 'function'
-    )
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
   }
-
   /**
    * Convert a value to a string that is actually rendered.
    */
-  function toString (val) {
-    return val == null
-      ? ''
-      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-        ? JSON.stringify(val, null, 2)
-        : String(val)
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
   }
-
   /**
    * Convert an input value to a number for persistence.
    * If the conversion fails, return original string.
    */
-  function toNumber (val) {
-    var n = parseFloat(val);
-    return isNaN(n) ? val : n
+  function toNumber(val) {
+      var n = parseFloat(val);
+      return isNaN(n) ? val : n;
   }
-
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
-  function makeMap (
-    str,
-    expectsLowerCase
-  ) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) { return map[val.toLowerCase()]; }
-      : function (val) { return map[val]; }
+  function makeMap(str, expectsLowerCase) {
+      var map = Object.create(null);
+      var list = str.split(',');
+      for (var i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
   }
-
   /**
    * Check if a tag is a built-in tag.
    */
   var isBuiltInTag = makeMap('slot,component', true);
-
   /**
    * Check if an attribute is a reserved attribute.
    */
   var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
   /**
    * Remove an item from an array.
    */
-  function remove (arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1)
+  function remove(arr, item) {
+      if (arr.length) {
+          var index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
       }
-    }
   }
-
   /**
    * Check whether an object has the property.
    */
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn (obj, key) {
-    return hasOwnProperty.call(obj, key)
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
   }
-
   /**
    * Create a cached version of a pure function.
    */
-  function cached (fn) {
-    var cache = Object.create(null);
-    return (function cachedFn (str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str))
-    })
+  function cached(fn) {
+      var cache = Object.create(null);
+      return function cachedFn(str) {
+          var hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
   }
-
   /**
    * Camelize a hyphen-delimited string.
    */
   var camelizeRE = /-(\w)/g;
   var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
   });
-
   /**
    * Capitalize a string.
    */
   var capitalize = cached(function (str) {
-    return str.charAt(0).toUpperCase() + str.slice(1)
+      return str.charAt(0).toUpperCase() + str.slice(1);
   });
-
   /**
    * Hyphenate a camelCase string.
    */
   var hyphenateRE = /\B([A-Z])/g;
   var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-
   /**
    * Simple bind polyfill for environments that do not support it,
    * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -199,1104 +165,977 @@
    * But removing it would mean breaking code that was able to run in
    * PhantomJS 1.x, so this must be kept for backward compatibility.
    */
-
   /* istanbul ignore next */
-  function polyfillBind (fn, ctx) {
-    function boundFn (a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx)
-    }
-
-    boundFn._length = fn.length;
-    return boundFn
-  }
-
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
-
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
-
+  function polyfillBind(fn, ctx) {
+      function boundFn(a) {
+          var l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
+  }
+  function nativeBind(fn, ctx) {
+      return fn.bind(ctx);
+  }
+  // @ts-expect-error bind cannot be `undefined`
+  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Convert an Array-like object to a real Array.
    */
-  function toArray (list, start) {
-    start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
-    while (i--) {
-      ret[i] = list[i + start];
-    }
-    return ret
+  function toArray(list, start) {
+      start = start || 0;
+      var i = list.length - start;
+      var ret = new Array(i);
+      while (i--) {
+          ret[i] = list[i + start];
+      }
+      return ret;
   }
-
   /**
    * Mix properties into target object.
    */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to
+  function extend(to, _from) {
+      for (var key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
   }
-
   /**
    * Merge an Array of Objects into a single Object.
    */
-  function toObject (arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-      if (arr[i]) {
-        extend(res, arr[i]);
+  function toObject(arr) {
+      var res = {};
+      for (var i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
       }
-    }
-    return res
+      return res;
   }
-
   /* eslint-disable no-unused-vars */
-
   /**
    * Perform no operation.
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop (a, b, c) {}
-
+  function noop(a, b, c) { }
   /**
    * Always return false.
    */
   var no = function (a, b, c) { return false; };
-
   /* eslint-enable no-unused-vars */
-
   /**
    * Return the same value.
    */
   var identity = function (_) { return _; };
-
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
-  function looseEqual (a, b) {
-    if (a === b) { return true }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-      try {
-        var isArrayA = Array.isArray(a);
-        var isArrayB = Array.isArray(b);
-        if (isArrayA && isArrayB) {
-          return a.length === b.length && a.every(function (e, i) {
-            return looseEqual(e, b[i])
-          })
-        } else if (a instanceof Date && b instanceof Date) {
-          return a.getTime() === b.getTime()
-        } else if (!isArrayA && !isArrayB) {
-          var keysA = Object.keys(a);
-          var keysB = Object.keys(b);
-          return keysA.length === keysB.length && keysA.every(function (key) {
-            return looseEqual(a[key], b[key])
-          })
-        } else {
-          /* istanbul ignore next */
-          return false
-        }
-      } catch (e) {
-        /* istanbul ignore next */
-        return false
-      }
-    } else if (!isObjectA && !isObjectB) {
-      return String(a) === String(b)
-    } else {
-      return false
-    }
+  function looseEqual(a, b) {
+      if (a === b)
+          { return true; }
+      var isObjectA = isObject(a);
+      var isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              var isArrayA = Array.isArray(a);
+              var isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every(function (e, i) {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  var keysA = Object.keys(a);
+                  var keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every(function (key) {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
   }
-
   /**
    * Return the first index at which a loosely equal value can be
    * found in the array (if value is a plain object, the array must
    * contain an object of the same shape), or -1 if it is not present.
    */
-  function looseIndexOf (arr, val) {
-    for (var i = 0; i < arr.length; i++) {
-      if (looseEqual(arr[i], val)) { return i }
-    }
-    return -1
+  function looseIndexOf(arr, val) {
+      for (var i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              { return i; }
+      }
+      return -1;
   }
-
   /**
    * Ensure a function is called only once.
    */
-  function once (fn) {
-    var called = false;
-    return function () {
-      if (!called) {
-        called = true;
-        fn.apply(this, arguments);
-      }
-    }
+  function once(fn) {
+      var called = false;
+      return function () {
+          if (!called) {
+              called = true;
+              fn.apply(this, arguments);
+          }
+      };
   }
 
   var SSR_ATTR = 'data-server-rendered';
-
-  var ASSET_TYPES = [
-    'component',
-    'directive',
-    'filter'
-  ];
-
+  var ASSET_TYPES = ['component', 'directive', 'filter'];
   var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
-  ];
-
-  /*  */
-
-
-
-  var config = ({
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  });
-
-  /*  */
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch' ];
+
+  /* @flow */
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
+  };
 
+  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
   var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
   /**
    * Check if a string starts with $ or _
    */
-  function isReserved (str) {
-    var c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5F
+  function isReserved(str) {
+      var c = (str + '').charCodeAt(0);
+      return c === 0x24 || c === 0x5f;
   }
-
   /**
    * Define a property.
    */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
   }
-
   /**
    * Parse simple path.
    */
   var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-  function parsePath (path) {
-    if (bailRE.test(path)) {
-      return
-    }
-    var segments = path.split('.');
-    return function (obj) {
-      for (var i = 0; i < segments.length; i++) {
-        if (!obj) { return }
-        obj = obj[segments[i]];
-      }
-      return obj
-    }
+  function parsePath(path) {
+      if (bailRE.test(path)) {
+          return;
+      }
+      var segments = path.split('.');
+      return function (obj) {
+          for (var i = 0; i < segments.length; i++) {
+              if (!obj)
+                  { return; }
+              obj = obj[segments[i]];
+          }
+          return obj;
+      };
   }
 
-  /*  */
-
+  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
-
   // Browser environment sniffing
   var inBrowser = typeof window !== 'undefined';
-  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
+  var inWeex = 
+  // @ts-ignore
+  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
   var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
   var isPhantomJS = UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
-
   // Firefox has a "watch" function on Object.prototype...
-  var nativeWatch = ({}).watch;
-
+  // @ts-ignore
+  var nativeWatch = {}.watch;
   var supportsPassive = false;
   if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, 'passive', ({
-        get: function get () {
-          /* istanbul ignore next */
-          supportsPassive = true;
-        }
-      })); // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts);
-    } catch (e) {}
+      try {
+          var opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get: function get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          // @ts-ignore
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
   }
-
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
   var _isServer;
   var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-      } else {
-        _isServer = false;
-      }
-    }
-    return _isServer
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
   };
-
   // detect devtools
+  // @ts-ignore TODO decalre this types
   var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
   /* istanbul ignore next */
-  function isNative (Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-
-  var hasSymbol =
-    typeof Symbol !== 'undefined' && isNative(Symbol) &&
-    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-  var _Set;
-  /* istanbul ignore if */ // $flow-disable-line
-  if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-      function Set () {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has (key) {
-        return this.set[key] === true
-      };
-      Set.prototype.add = function add (key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear () {
-        this.set = Object.create(null);
-      };
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  var hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  var _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = /*@__PURE__*/(function () {
+          function Set() {
+              this.set = Object.create(null);
+          }
+          Set.prototype.has = function has (key) {
+              return this.set[key] === true;
+          };
+          Set.prototype.add = function add (key) {
+              this.set[key] = true;
+          };
+          Set.prototype.clear = function clear () {
+              this.set = Object.create(null);
+          };
 
-      return Set;
-    }());
+          return Set;
+      }());
   }
 
-  /*  */
-
+  /* @flow */
   var warn = noop;
   var tip = noop;
-  var generateComponentTrace = (noop); // work around flow check
-  var formatComponentName = (noop);
-
+  var generateComponentTrace; // work around flow check
+  var formatComponentName;
   {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str
-      .replace(classifyRE, function (c) { return c.toUpperCase(); })
-      .replace(/[-_]/g, ''); };
-
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : '';
-
-      if (config.warnHandler) {
-        config.warnHandler.call(null, msg, vm, trace);
-      } else if (hasConsole && (!config.silent)) {
-        console.error(("[Vue warn]: " + msg + trace));
-      }
-    };
-
-    tip = function (msg, vm) {
-      if (hasConsole && (!config.silent)) {
-        console.warn("[Vue tip]: " + msg + (
-          vm ? generateComponentTrace(vm) : ''
-        ));
-      }
-    };
-
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options = typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-
-      return (
-        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-        (file && includeFile !== false ? (" at " + file) : '')
-      )
-    };
-
-    var repeat = function (str, n) {
-      var res = '';
-      while (n) {
-        if (n % 2 === 1) { res += str; }
-        if (n > 1) { str += str; }
-        n >>= 1;
-      }
-      return res
-    };
-
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
-          }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return '\n\nfound in\n\n' + tree
-          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-              : formatComponentName(vm))); })
-          .join('\n')
-      } else {
-        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-      }
-    };
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+      warn = function (msg, vm) {
+          var trace = vm ? generateComponentTrace(vm) : '';
+          if (config.warnHandler) {
+              config.warnHandler.call(null, msg, vm, trace);
+          }
+          else if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
+          }
+      };
+      tip = function (msg, vm) {
+          if (hasConsole && !config.silent) {
+              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = function (vm, includeFile) {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          var options = 
+          // @ts-ignore
+          typeof vm === 'function' && vm.cid != null
+              ? // @ts-ignore
+                  vm.options
+              : vm._isVue
+                  ? // @ts-ignore
+                      vm.$options || vm.constructor.options
+                  : vm;
+          var name = options.name || options._componentTag;
+          var file = options.__file;
+          if (!name && file) {
+              var match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
+      };
+      var repeat = function (str, n) {
+          var res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  { res += str; }
+              if (n > 1)
+                  { str += str; }
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = function (vm) {
+          // @ts-ignore
+          if (vm._isVue && vm.$parent) {
+              var tree = [];
+              var currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      var last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
+                      .join('\n'));
+          }
+          else {
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+          }
+      };
   }
 
-  /*  */
-
   var uid = 0;
-
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep () {
-    this.id = uid++;
-    this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid++;
+      this.subs = [];
   };
-
   Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
+      this.subs.push(sub);
   };
-
   Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
+      remove(this.subs, sub);
   };
-
   Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
+      if (Dep.target) {
+          Dep.target.addDep(this);
+      }
   };
-
   Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-      // subs aren't sorted in scheduler if not running async
-      // we need to sort them now to make sure they fire in correct
-      // order
-      subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      if (!config.async) {
+          // subs aren't sorted in scheduler if not running async
+          // we need to sort them now to make sure they fire in correct
+          // order
+          subs.sort(function (a, b) { return a.id - b.id; });
+      }
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
   };
-
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
   var targetStack = [];
-
-  function pushTarget (target) {
-    targetStack.push(target);
-    Dep.target = target;
-  }
-
-  function popTarget () {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  /*  */
-
-  var VNode = function VNode (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
+  }
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
+  }
+
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
   };
 
   var prototypeAccessors = { child: { configurable: true } };
-
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   prototypeAccessors.child.get = function () {
-    return this.componentInstance
+      return this.componentInstance;
   };
 
   Object.defineProperties( VNode.prototype, prototypeAccessors );
-
   var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
+      if ( text === void 0 ) text = '';
 
-    var node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node
+      var node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
   };
-
-  function createTextVNode (val) {
-    return new VNode(undefined, undefined, undefined, String(val))
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
   }
-
   // optimized shallow clone
   // used for static nodes and slot nodes because they may be reused across
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
-  function cloneVNode (vnode) {
-    var cloned = new VNode(
-      vnode.tag,
-      vnode.data,
+  function cloneVNode(vnode) {
+      var cloned = new VNode(
+      //@ts-expect-error void type not valid here
+      vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
-      vnode.children && vnode.children.slice(),
-      vnode.text,
-      vnode.elm,
-      vnode.context,
-      vnode.componentOptions,
-      vnode.asyncFactory
-    );
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
   }
 
   /*
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-
   var arrayProto = Array.prototype;
   var arrayMethods = Object.create(arrayProto);
-
   var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-  ];
-
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse' ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args;
-          break
-        case 'splice':
-          inserted = args.slice(2);
-          break
-      }
-      if (inserted) { ob.observeArray(inserted); }
-      // notify change
-      ob.dep.notify();
-      return result
-    });
+      // cache original method
+      var original = arrayProto[method];
+      def(arrayMethods, method, function mutator() {
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
+
+          var result = original.apply(this, args);
+          var ob = this.__ob__;
+          var inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              { ob.observeArray(inserted); }
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  /*  */
-
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
   var shouldObserve = true;
-
-  function toggleObserving (value) {
-    shouldObserve = value;
+  function toggleObserving(value) {
+      shouldObserve = value;
   }
-
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
+          }
+          else {
+              copyAugment(value, arrayMethods, arrayKeys);
+          }
+          this.observeArray(value);
+      }
+      else {
+          this.walk(value);
+      }
   };
-
   /**
    * Walk through all properties and convert them into
    * getter/setters. This method should only be called when
    * value type is Object.
    */
   Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
-    }
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive$$1(obj, keys[i]);
+      }
   };
-
   /**
    * Observe a list of Array items.
    */
   Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
   };
-
   // helpers
-
   /**
    * Augment a target Object or Array by intercepting
    * the prototype chain using __proto__
    */
-  function protoAugment (target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
   }
-
   /**
    * Augment a target Object or Array by defining
    * hidden properties.
    */
   /* istanbul ignore next */
-  function copyAugment (target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
+  function copyAugment(target, src, keys) {
+      for (var i = 0, l = keys.length; i < l; i++) {
+          var key = keys[i];
+          def(target, key, src[key]);
+      }
   }
-
   /**
    * Attempt to create an observer instance for a value,
    * returns the new observer if successfully observed,
    * or the existing observer if the value already has one.
    */
-  function observe (value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      var ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
   }
-
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1 (
-    obj,
-    key,
-    val,
-    customSetter,
-    shallow
-  ) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter () {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter (newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) { return }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      }
-    });
+  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+      var dep = new Dep();
+      var property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      var getter = property && property.get;
+      var setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      var childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              var value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              var value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  { return; }
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
   }
-
   /**
    * Set a property on an object. Adds the new property and
    * triggers change notification if the property doesn't
    * already exist.
    */
-  function set (target, key, val) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-        'at runtime - declare it upfront in the data option.'
-      );
-      return val
-    }
-    if (!ob) {
-      target[key] = val;
-      return val
-    }
-    defineReactive$$1(ob.value, key, val);
-    ob.dep.notify();
-    return val
+  function set(target, key, val) {
+      if (isUndef(target) || isPrimitive(target)) {
+          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      var ob = target.__ob__;
+      // @ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive$$1(ob.value, key, val);
+      ob.dep.notify();
+      return val;
   }
-
   /**
    * Delete a property and trigger change if necessary.
    */
-  function del (target, key) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.splice(key, 1);
-      return
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid deleting properties on a Vue instance or its root $data ' +
-        '- just set it to null.'
-      );
-      return
-    }
-    if (!hasOwn(target, key)) {
-      return
-    }
-    delete target[key];
-    if (!ob) {
-      return
-    }
-    ob.dep.notify();
+  function del(target, key) {
+      if (isUndef(target) || isPrimitive(target)) {
+          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.splice(key, 1);
+          return;
+      }
+      var ob = target.__ob__;
+      //@ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                  '- just set it to null.');
+          return;
+      }
+      if (!hasOwn(target, key)) {
+          return;
+      }
+      delete target[key];
+      if (!ob) {
+          return;
+      }
+      ob.dep.notify();
   }
-
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
-  function dependArray (value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
+  function dependArray(value) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
    */
   var strats = config.optionMergeStrategies;
-
   /**
    * Options with restrictions
    */
   {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          "option \"" + key + "\" can only be used during instance " +
-          'creation with the `new` keyword.'
-        );
-      }
-      return defaultStrat(parent, child)
-    };
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn("option \"" + key + "\" can only be used during instance " +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
   }
-
   /**
    * Helper that recursively merges two data objects together.
    */
-  function mergeData (to, from) {
-    if (!from) { return to }
-    var key, toVal, fromVal;
-
-    var keys = hasSymbol
-      ? Reflect.ownKeys(from)
-      : Object.keys(from);
-
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === '__ob__') { continue }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to
+  function mergeData(to, from) {
+      if (!from)
+          { return to; }
+      var key, toVal, fromVal;
+      var keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (var i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              { continue; }
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
   }
-
   /**
    * Data
    */
-  function mergeDataOrFn (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn () {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn () {
-        // instance merge
-        var instanceData = typeof childVal === 'function'
-          ? childVal.call(vm, vm)
-          : childVal;
-        var defaultData = typeof parentVal === 'function'
-          ? parentVal.call(vm, vm)
-          : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(
+              // @ts-ignore
+              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+              // @ts-ignore
+              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
       }
-    }
   }
-
-  strats.data = function (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn(
-          'The "data" option should be a function ' +
-          'that returns a per-instance value in component ' +
-          'definitions.',
-          vm
-        );
-
-        return parentVal
-      }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-
-    return mergeDataOrFn(parentVal, childVal, vm)
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
   };
-
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook (
-    parentVal,
-    childVal
-  ) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-          ? childVal
-          : [childVal]
-      : parentVal;
-    return res
-      ? dedupeHooks(res)
-      : res
+  function mergeHook(parentVal, childVal) {
+      var res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
   }
-
-  function dedupeHooks (hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
+  function dedupeHooks(hooks) {
+      var res = [];
+      for (var i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
       }
-    }
-    return res
+      return res;
   }
-
   LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+      strats[hook] = mergeHook;
   });
-
   /**
    * Assets
    *
@@ -1304,609 +1143,540 @@
    * a three-way merge between constructor options, instance
    * options and parent options.
    */
-  function mergeAssets (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal)
-    } else {
-      return res
-    }
+  function mergeAssets(parentVal, childVal, vm, key) {
+      var res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
   }
-
   ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
+      strats[type + 's'] = mergeAssets;
   });
-
   /**
    * Watchers.
    *
    * Watchers hashes should not overwrite one
    * another, so we merge them as arrays.
    */
-  strats.watch = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    // work around Firefox's Object.prototype.watch...
-    if (parentVal === nativeWatch) { parentVal = undefined; }
-    if (childVal === nativeWatch) { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal) { return Object.create(parentVal || null) }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child) ? child : [child];
-    }
-    return ret
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          { parentVal = undefined; }
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          { childVal = undefined; }
+      /* istanbul ignore if */
+      if (!childVal)
+          { return Object.create(parentVal || null); }
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = {};
+      extend(ret, parentVal);
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
   };
-
   /**
    * Other object hashes.
    */
-  strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== 'production') {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) { extend(ret, childVal); }
-    return ret
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          { extend(ret, childVal); }
+      return ret;
   };
   strats.provide = mergeDataOrFn;
-
   /**
    * Default strategy.
    */
   var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined
-      ? parentVal
-      : childVal
+      return childVal === undefined ? parentVal : childVal;
   };
-
   /**
    * Validate component names
    */
-  function checkComponents (options) {
-    for (var key in options.components) {
-      validateComponentName(key);
-    }
+  function checkComponents(options) {
+      for (var key in options.components) {
+          validateComponentName(key);
+      }
   }
-
-  function validateComponentName (name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-      warn(
-        'Invalid component name: "' + name + '". Component names ' +
-        'should conform to valid custom element name in html5 specification.'
-      );
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-      warn(
-        'Do not use built-in or reserved HTML elements as component ' +
-        'id: ' + name
-      );
-    }
+  function validateComponentName(name) {
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+          warn('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
   }
-
   /**
    * Ensure all props option syntax are normalized into the
    * Object-based format.
    */
-  function normalizeProps (options, vm) {
-    var props = options.props;
-    if (!props) { return }
-    var res = {};
-    var i, val, name;
-    if (Array.isArray(props)) {
-      i = props.length;
-      while (i--) {
-        val = props[i];
-        if (typeof val === 'string') {
-          name = camelize(val);
-          res[name] = { type: null };
-        } else {
-          warn('props must be strings when using array syntax.');
-        }
-      }
-    } else if (isPlainObject(props)) {
-      for (var key in props) {
-        val = props[key];
-        name = camelize(key);
-        res[name] = isPlainObject(val)
-          ? val
-          : { type: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"props\": expected an Array or an Object, " +
-        "but got " + (toRawType(props)) + ".",
-        vm
-      );
-    }
-    options.props = res;
+  function normalizeProps(options, vm) {
+      var props = options.props;
+      if (!props)
+          { return; }
+      var res = {};
+      var i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (var key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"props\": expected an Array or an Object, " +
+              "but got " + (toRawType(props)) + ".", vm);
+      }
+      options.props = res;
   }
-
   /**
    * Normalize all injections into Object-based format
    */
-  function normalizeInject (options, vm) {
-    var inject = options.inject;
-    if (!inject) { return }
-    var normalized = options.inject = {};
-    if (Array.isArray(inject)) {
-      for (var i = 0; i < inject.length; i++) {
-        normalized[inject[i]] = { from: inject[i] };
-      }
-    } else if (isPlainObject(inject)) {
-      for (var key in inject) {
-        var val = inject[key];
-        normalized[key] = isPlainObject(val)
-          ? extend({ from: key }, val)
-          : { from: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"inject\": expected an Array or an Object, " +
-        "but got " + (toRawType(inject)) + ".",
-        vm
-      );
-    }
+  function normalizeInject(options, vm) {
+      var inject = options.inject;
+      if (!inject)
+          { return; }
+      var normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (var i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (var key in inject) {
+              var val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+              "but got " + (toRawType(inject)) + ".", vm);
+      }
   }
-
   /**
    * Normalize raw function directives into object format.
    */
-  function normalizeDirectives (options) {
-    var dirs = options.directives;
-    if (dirs) {
-      for (var key in dirs) {
-        var def$$1 = dirs[key];
-        if (typeof def$$1 === 'function') {
-          dirs[key] = { bind: def$$1, update: def$$1 };
-        }
+  function normalizeDirectives(options) {
+      var dirs = options.directives;
+      if (dirs) {
+          for (var key in dirs) {
+              var def$$1 = dirs[key];
+              if (typeof def$$1 === 'function') {
+                  dirs[key] = { bind: def$$1, update: def$$1 };
+              }
+          }
       }
-    }
   }
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
-      );
-    }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn("Invalid value for option \"" + name + "\": expected an Object, " +
+              "but got " + (toRawType(value)) + ".", vm);
+      }
   }
-
   /**
    * Merge two option objects into a new one.
    * Core utility used in both instantiation and inheritance.
    */
-  function mergeOptions (
-    parent,
-    child,
-    vm
-  ) {
-    {
-      checkComponents(child);
-    }
-
-    if (typeof child === 'function') {
-      child = child.options;
-    }
-
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-      if (child.extends) {
-        parent = mergeOptions(parent, child.extends, vm);
-      }
-      if (child.mixins) {
-        for (var i = 0, l = child.mixins.length; i < l; i++) {
-          parent = mergeOptions(parent, child.mixins[i], vm);
-        }
-      }
-    }
-
-    var options = {};
-    var key;
-    for (key in parent) {
-      mergeField(key);
-    }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
-      }
-    }
-    function mergeField (key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (var i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      var options = {};
+      var key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          var strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
   }
-
   /**
    * Resolve an asset.
    * This function is used because child instances need access
    * to assets defined in its ancestor chain.
    */
-  function resolveAsset (
-    options,
-    type,
-    id,
-    warnMissing
-  ) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-      return
-    }
-    var assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id)) { return assets[id] }
-    var camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-    var PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-    // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-      warn(
-        'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-        options
-      );
-    }
-    return res
-  }
-
-  /*  */
-
-
-
-  function validateProp (
-    key,
-    propOptions,
-    propsData,
-    vm
-  ) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
-    // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-      if (absent && !hasOwn(prop, 'default')) {
-        value = false;
-      } else if (value === '' || value === hyphenate(key)) {
-        // only cast empty string / same name to boolean if
-        // boolean has higher priority
-        var stringIndex = getTypeIndex(String, prop.type);
-        if (stringIndex < 0 || booleanIndex < stringIndex) {
-          value = true;
-        }
-      }
-    }
-    // check default value
-    if (value === undefined) {
-      value = getPropDefaultValue(vm, prop, key);
-      // since the default value is a fresh copy,
-      // make sure to observe it.
-      var prevShouldObserve = shouldObserve;
-      toggleObserving(true);
-      observe(value);
-      toggleObserving(prevShouldObserve);
-    }
-    {
-      assertProp(prop, key, value, vm, absent);
-    }
-    return value
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      var assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          { return assets[id]; }
+      var camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          { return assets[camelizedId]; }
+      var PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          { return assets[PascalCaseId]; }
+      // fallback to prototype chain
+      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
+  }
+
+  /* @flow */
+  function validateProp(key, propOptions, propsData, vm) {
+      var prop = propOptions[key];
+      var absent = !hasOwn(propsData, key);
+      var value = propsData[key];
+      // boolean casting
+      var booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              var stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          var prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
   }
-
   /**
    * Get the default value of a prop.
    */
-  function getPropDefaultValue (vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-      return undefined
-    }
-    var def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-      warn(
-        'Invalid default value for prop "' + key + '": ' +
-        'Props with type Object/Array must use a factory function ' +
-        'to return the default value.',
-        vm
-      );
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm && vm.$options.propsData &&
-      vm.$options.propsData[key] === undefined &&
-      vm._props[key] !== undefined
-    ) {
-      return vm._props[key]
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-      ? def.call(vm)
-      : def
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      var def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
   }
-
   /**
    * Assert whether a prop is valid.
    */
-  function assertProp (
-    prop,
-    name,
-    value,
-    vm,
-    absent
-  ) {
-    if (prop.required && absent) {
-      warn(
-        'Missing required prop: "' + name + '"',
-        vm
-      );
-      return
-    }
-    if (value == null && !prop.required) {
-      return
-    }
-    var type = prop.type;
-    var valid = !type || type === true;
-    var expectedTypes = [];
-    if (type) {
-      if (!Array.isArray(type)) {
-        type = [type];
-      }
-      for (var i = 0; i < type.length && !valid; i++) {
-        var assertedType = assertType(value, type[i]);
-        expectedTypes.push(assertedType.expectedType || '');
-        valid = assertedType.valid;
-      }
-    }
-
-    if (!valid) {
-      warn(
-        getInvalidTypeMessage(name, value, expectedTypes),
-        vm
-      );
-      return
-    }
-    var validator = prop.validator;
-    if (validator) {
-      if (!validator(value)) {
-        warn(
-          'Invalid prop: custom validator check failed for prop "' + name + '".',
-          vm
-        );
-      }
-    }
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      var type = prop.type;
+      // @ts-ignore
+      var valid = !type || type === true;
+      var expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (var i = 0; i < type.length && !valid; i++) {
+              var assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+      if (!valid && haveExpectedTypes) {
+          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      var validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
   }
-
-  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-  function assertType (value, type) {
-    var valid;
-    var expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-      var t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      // for primitive wrapper objects
-      if (!valid && t === 'object') {
-        valid = value instanceof type;
-      }
-    } else if (expectedType === 'Object') {
-      valid = isPlainObject(value);
-    } else if (expectedType === 'Array') {
-      valid = Array.isArray(value);
-    } else {
-      valid = value instanceof type;
-    }
-    return {
-      valid: valid,
-      expectedType: expectedType
-    }
+  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      var valid;
+      var expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          var t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid: valid,
+          expectedType: expectedType,
+      };
   }
-
+  var functionTypeCheckRE = /^\s*function (\w+)/;
   /**
    * Use function string name to check built-in types,
    * because a simple equality check will fail when running
    * across different vms / iframes.
    */
-  function getType (fn) {
-    var match = fn && fn.toString().match(/^\s*function (\w+)/);
-    return match ? match[1] : ''
+  function getType(fn) {
+      var match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
   }
-
-  function isSameType (a, b) {
-    return getType(a) === getType(b)
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
   }
-
-  function getTypeIndex (type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-      return isSameType(expectedTypes, type) ? 0 : -1
-    }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
-      if (isSameType(expectedTypes[i], type)) {
-        return i
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (var i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
+          }
       }
-    }
-    return -1
+      return -1;
   }
-
-  function getInvalidTypeMessage (name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-      " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
-    var expectedValue = styleValue(value, expectedType);
-    var receivedValue = styleValue(value, receivedType);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        !isBoolean(expectedType, receivedType)) {
-      message += " with value " + expectedValue;
-    }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-      message += "with value " + receivedValue + ".";
-    }
-    return message
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
+      var expectedType = expectedTypes[0];
+      var receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += " with value " + (styleValue(value, expectedType));
+      }
+      message += ", got " + receivedType + " ";
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += "with value " + (styleValue(value, receivedType)) + ".";
+      }
+      return message;
   }
-
-  function styleValue (value, type) {
-    if (type === 'String') {
-      return ("\"" + value + "\"")
-    } else if (type === 'Number') {
-      return ("" + (Number(value)))
-    } else {
-      return ("" + value)
-    }
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return ("\"" + value + "\"");
+      }
+      else if (type === 'Number') {
+          return ("" + (Number(value)));
+      }
+      else {
+          return ("" + value);
+      }
   }
-
-  function isExplicable (value) {
-    var explicitTypes = ['string', 'number', 'boolean'];
-    return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
+  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
+  function isBoolean() {
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-  function isBoolean () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
+      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
-  /*  */
-
-  function handleError (err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-      if (vm) {
-        var cur = vm;
-        while ((cur = cur.$parent)) {
-          var hooks = cur.$options.errorCaptured;
-          if (hooks) {
-            for (var i = 0; i < hooks.length; i++) {
-              try {
-                var capture = hooks[i].call(cur, err, vm, info) === false;
-                if (capture) { return }
-              } catch (e) {
-                globalHandleError(e, cur, 'errorCaptured hook');
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              var cur = vm;
+              while ((cur = cur.$parent)) {
+                  var hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (var i = 0; i < hooks.length; i++) {
+                          try {
+                              var capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  { return; }
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
               }
-            }
           }
-        }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
       }
-      globalHandleError(err, vm, info);
-    } finally {
-      popTarget();
-    }
-  }
-
-  function invokeWithErrorHandling (
-    handler,
-    context,
-    args,
-    vm,
-    info
-  ) {
-    var res;
-    try {
-      res = args ? handler.apply(context, args) : handler.call(context);
-      if (res && !res._isVue && isPromise(res) && !res._handled) {
-        res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-        // issue #9511
-        // avoid catch triggering multiple times when nested calls
-        res._handled = true;
-      }
-    } catch (e) {
-      handleError(e, vm, info);
-    }
-    return res
   }
-
-  function globalHandleError (err, vm, info) {
-    if (config.errorHandler) {
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      var res;
       try {
-        return config.errorHandler.call(null, err, vm, info)
-      } catch (e) {
-        // if the user intentionally throws the original error in the handler,
-        // do not log it twice
-        if (e !== err) {
-          logError(e, null, 'config.errorHandler');
-        }
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
       }
-    }
-    logError(err, vm, info);
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
   }
-
-  function logError (err, vm, info) {
-    {
-      warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-      console.error(err);
-    } else {
-      throw err
-    }
+  function globalHandleError(err, vm, info) {
+      if (config.errorHandler) {
+          try {
+              return config.errorHandler.call(null, err, vm, info);
+          }
+          catch (e) {
+              // if the user intentionally throws the original error in the handler,
+              // do not log it twice
+              if (e !== err) {
+                  logError(e, null, 'config.errorHandler');
+              }
+          }
+      }
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var isUsingMicroTask = false;
-
   var callbacks = [];
   var pending = false;
-
-  function flushCallbacks () {
-    pending = false;
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
+  function flushCallbacks() {
+      pending = false;
+      var copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (var i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
   }
-
   // Here we have async deferring wrappers using microtasks.
   // In 2.5 we used (macro) tasks (in combination with microtasks).
   // However, it has subtle problems when state is changed right before repaint
@@ -1919,7 +1689,6 @@
   // sequential events (e.g. #4521, #6690, which have workarounds)
   // or even between bubbling of the same event (#6566).
   var timerFunc;
-
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -1928,2299 +1697,2010 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
-      p.then(flushCallbacks);
-      // In problematic UIWebViews, Promise.then doesn't completely break, but
-      // it can get stuck in a weird state where callbacks are pushed into the
-      // microtask queue but the queue isn't being flushed, until the browser
-      // needs to do some other work, e.g. handle a timer. Therefore we can
-      // "force" the microtask queue to be flushed by adding an empty timer.
-      if (isIOS) { setTimeout(noop); }
-    };
-    isUsingMicroTask = true;
-  } else if (!isIE && typeof MutationObserver !== 'undefined' && (
-    isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]'
-  )) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true
-    });
-    timerFunc = function () {
-      counter = (counter + 1) % 2;
-      textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = function () {
-      setImmediate(flushCallbacks);
-    };
-  } else {
-    // Fallback to setTimeout.
-    timerFunc = function () {
-      setTimeout(flushCallbacks, 0);
-    };
+      var p = Promise.resolve();
+      timerFunc = function () {
+          p.then(flushCallbacks);
+          // In problematic UIWebViews, Promise.then doesn't completely break, but
+          // it can get stuck in a weird state where callbacks are pushed into the
+          // microtask queue but the queue isn't being flushed, until the browser
+          // needs to do some other work, e.g. handle a timer. Therefore we can
+          // "force" the microtask queue to be flushed by adding an empty timer.
+          if (isIOS)
+              { setTimeout(noop); }
+      };
+      isUsingMicroTask = true;
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      var counter = 1;
+      var observer = new MutationObserver(flushCallbacks);
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+      timerFunc = function () {
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+      // Fallback to setImmediate.
+      // Technically it leverages the (macro) task queue,
+      // but it is still a better choice than setTimeout.
+      timerFunc = function () {
+          setImmediate(flushCallbacks);
+      };
   }
-
-  function nextTick (cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
-      if (cb) {
-        try {
-          cb.call(ctx);
-        } catch (e) {
-          handleError(e, ctx, 'nextTick');
-        }
-      } else if (_resolve) {
-        _resolve(ctx);
-      }
-    });
-    if (!pending) {
-      pending = true;
-      timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-      return new Promise(function (resolve) {
-        _resolve = resolve;
-      })
-    }
+  else {
+      // Fallback to setTimeout.
+      timerFunc = function () {
+          setTimeout(flushCallbacks, 0);
+      };
+  }
+  function nextTick(cb, ctx) {
+      var _resolve;
+      callbacks.push(function () {
+          if (cb) {
+              try {
+                  cb.call(ctx);
+              }
+              catch (e) {
+                  handleError(e, ctx, 'nextTick');
+              }
+          }
+          else if (_resolve) {
+              _resolve(ctx);
+          }
+      });
+      if (!pending) {
+          pending = true;
+          timerFunc();
+      }
+      // $flow-disable-line
+      if (!cb && typeof Promise !== 'undefined') {
+          return new Promise(function (resolve) {
+              _resolve = resolve;
+          });
+      }
   }
 
-  /*  */
+  /* @flow */
 
   /* not type checking this file because flow doesn't play well with Proxy */
-
   var initProxy;
-
   {
-    var allowedGlobals = makeMap(
-      'Infinity,undefined,NaN,isFinite,isNaN,' +
-      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-      'require' // for Webpack/Browserify
-    );
-
-    var warnNonPresent = function (target, key) {
-      warn(
-        "Property or method \"" + key + "\" is not defined on the instance but " +
-        'referenced during render. Make sure that this property is reactive, ' +
-        'either in the data option, or for class-based components, by ' +
-        'initializing the property. ' +
-        'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-        target
-      );
-    };
-
-    var warnReservedPrefix = function (target, key) {
-      warn(
-        "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-        'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-        'prevent conflicts with Vue internals. ' +
-        'See: https://vuejs.org/v2/api/#data',
-        target
+      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
       );
-    };
-
-    var hasProxy =
-      typeof Proxy !== 'undefined' && isNative(Proxy);
-
-    if (hasProxy) {
-      var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-      config.keyCodes = new Proxy(config.keyCodes, {
-        set: function set (target, key, value) {
-          if (isBuiltInModifier(key)) {
-            warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-            return false
-          } else {
-            target[key] = value;
-            return true
-          }
-        }
-      });
-    }
-
-    var hasHandler = {
-      has: function has (target, key) {
-        var has = key in target;
-        var isAllowed = allowedGlobals(key) ||
-          (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-        if (!has && !isAllowed) {
-          if (key in target.$data) { warnReservedPrefix(target, key); }
-          else { warnNonPresent(target, key); }
-        }
-        return has || !isAllowed
-      }
-    };
-
-    var getHandler = {
-      get: function get (target, key) {
-        if (typeof key === 'string' && !(key in target)) {
-          if (key in target.$data) { warnReservedPrefix(target, key); }
-          else { warnNonPresent(target, key); }
-        }
-        return target[key]
-      }
-    };
-
-    initProxy = function initProxy (vm) {
+      var warnNonPresent = function (target, key) {
+          warn("Property or method \"" + key + "\" is not defined on the instance but " +
+              'referenced during render. Make sure that this property is reactive, ' +
+              'either in the data option, or for class-based components, by ' +
+              'initializing the property. ' +
+              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+      };
+      var warnReservedPrefix = function (target, key) {
+          warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+              'prevent conflicts with Vue internals. ' +
+              'See: https://vuejs.org/v2/api/#data', target);
+      };
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
       if (hasProxy) {
-        // determine which proxy handler to use
-        var options = vm.$options;
-        var handlers = options.render && options.render._withStripped
-          ? getHandler
-          : hasHandler;
-        vm._renderProxy = new Proxy(vm, handlers);
-      } else {
-        vm._renderProxy = vm;
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
       }
-    };
+      var hasHandler = {
+          has: function has(target, key) {
+              var has = key in target;
+              var isAllowed = allowedGlobals(key) ||
+                  (typeof key === 'string' &&
+                      key.charAt(0) === '_' &&
+                      !(key in target.$data));
+              if (!has && !isAllowed) {
+                  if (key in target.$data)
+                      { warnReservedPrefix(target, key); }
+                  else
+                      { warnNonPresent(target, key); }
+              }
+              return has || !isAllowed;
+          },
+      };
+      var getHandler = {
+          get: function get(target, key) {
+              if (typeof key === 'string' && !(key in target)) {
+                  if (key in target.$data)
+                      { warnReservedPrefix(target, key); }
+                  else
+                      { warnNonPresent(target, key); }
+              }
+              return target[key];
+          },
+      };
+      initProxy = function initProxy(vm) {
+          if (hasProxy) {
+              // determine which proxy handler to use
+              var options = vm.$options;
+              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              vm._renderProxy = new Proxy(vm, handlers);
+          }
+          else {
+              vm._renderProxy = vm;
+          }
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var seenObjects = new _Set();
-
   /**
    * Recursively traverse an object to evoke all converted
    * getters, so that every nested property inside the object
    * is collected as a "deep" dependency.
    */
-  function traverse (val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-  }
-
-  function _traverse (val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-      return
-    }
-    if (val.__ob__) {
-      var depId = val.__ob__.dep.id;
-      if (seen.has(depId)) {
-        return
-      }
-      seen.add(depId);
-    }
-    if (isA) {
-      i = val.length;
-      while (i--) { _traverse(val[i], seen); }
-    } else {
-      keys = Object.keys(val);
-      i = keys.length;
-      while (i--) { _traverse(val[keys[i]], seen); }
-    }
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      var i, keys;
+      var isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          var depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              { _traverse(val[i], seen); }
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              { _traverse(val[keys[i]], seen); }
+      }
   }
 
   var mark;
   var measure;
-
   {
-    var perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (
-      perf &&
-      perf.mark &&
-      perf.measure &&
-      perf.clearMarks &&
-      perf.clearMeasures
-    ) {
-      mark = function (tag) { return perf.mark(tag); };
-      measure = function (name, startTag, endTag) {
-        perf.measure(name, startTag, endTag);
-        perf.clearMarks(startTag);
-        perf.clearMarks(endTag);
-        // perf.clearMeasures(name)
-      };
-    }
+      var perf = inBrowser && window.performance;
+      /* istanbul ignore if */
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = function (tag) { return perf.mark(tag); };
+          measure = function (name, startTag, endTag) {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+              // perf.clearMeasures(name)
+          };
+      }
   }
 
-  /*  */
-
   var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-      name: name,
-      once: once$$1,
-      capture: capture,
-      passive: passive
-    }
+      var passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once$$1 ? name.slice(1) : name;
+      var capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name: name,
+          once: once$$1,
+          capture: capture,
+          passive: passive,
+      };
   });
-
-  function createFnInvoker (fns, vm) {
-    function invoker () {
-      var arguments$1 = arguments;
-
-      var fns = invoker.fns;
-      if (Array.isArray(fns)) {
-        var cloned = fns.slice();
-        for (var i = 0; i < cloned.length; i++) {
-          invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-        }
-      } else {
-        // return handler return value for single handlers
-        return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-      }
-    }
-    invoker.fns = fns;
-    return invoker
-  }
-
-  function updateListeners (
-    on,
-    oldOn,
-    add,
-    remove$$1,
-    createOnceHandler,
-    vm
-  ) {
-    var name, def$$1, cur, old, event;
-    for (name in on) {
-      def$$1 = cur = on[name];
-      old = oldOn[name];
-      event = normalizeEvent(name);
-      if (isUndef(cur)) {
-        warn(
-          "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-          vm
-        );
-      } else if (isUndef(old)) {
-        if (isUndef(cur.fns)) {
-          cur = on[name] = createFnInvoker(cur, vm);
-        }
-        if (isTrue(event.once)) {
-          cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-        }
-        add(event.name, cur, event.capture, event.passive, event.params);
-      } else if (cur !== old) {
-        old.fns = cur;
-        on[name] = old;
-      }
-    }
-    for (name in oldOn) {
-      if (isUndef(on[name])) {
-        event = normalizeEvent(name);
-        remove$$1(event.name, oldOn[name], event.capture);
-      }
-    }
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          var arguments$1 = arguments;
+
+          var fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              var cloned = fns.slice();
+              for (var i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+      var name, def$$1, cur, old, event;
+      for (name in on) {
+          def$$1 = cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove$$1(event.name, oldOn[name], event.capture);
+          }
+      }
   }
 
-  /*  */
-
-  function mergeVNodeHook (def, hookKey, hook) {
-    if (def instanceof VNode) {
-      def = def.data.hook || (def.data.hook = {});
-    }
-    var invoker;
-    var oldHook = def[hookKey];
-
-    function wrappedHook () {
-      hook.apply(this, arguments);
-      // important: remove merged hook to ensure it's called only once
-      // and prevent memory leak
-      remove(invoker.fns, wrappedHook);
-    }
-
-    if (isUndef(oldHook)) {
-      // no existing hook
-      invoker = createFnInvoker([wrappedHook]);
-    } else {
-      /* istanbul ignore if */
-      if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-        // already a merged invoker
-        invoker = oldHook;
-        invoker.fns.push(wrappedHook);
-      } else {
-        // existing plain hook
-        invoker = createFnInvoker([oldHook, wrappedHook]);
-      }
-    }
-
-    invoker.merged = true;
-    def[hookKey] = invoker;
+  /* @flow */
+  function mergeVNodeHook(def, hookKey, hook) {
+      if (def instanceof VNode) {
+          def = def.data.hook || (def.data.hook = {});
+      }
+      var invoker;
+      var oldHook = def[hookKey];
+      function wrappedHook() {
+          hook.apply(this, arguments);
+          // important: remove merged hook to ensure it's called only once
+          // and prevent memory leak
+          remove(invoker.fns, wrappedHook);
+      }
+      if (isUndef(oldHook)) {
+          // no existing hook
+          invoker = createFnInvoker([wrappedHook]);
+      }
+      else {
+          /* istanbul ignore if */
+          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+              // already a merged invoker
+              invoker = oldHook;
+              invoker.fns.push(wrappedHook);
+          }
+          else {
+              // existing plain hook
+              invoker = createFnInvoker([oldHook, wrappedHook]);
+          }
+      }
+      invoker.merged = true;
+      def[hookKey] = invoker;
   }
 
-  /*  */
-
-  function extractPropsFromVNodeData (
-    data,
-    Ctor,
-    tag
-  ) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    var propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-      return
-    }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
-    if (isDef(attrs) || isDef(props)) {
-      for (var key in propOptions) {
-        var altKey = hyphenate(key);
-        {
-          var keyInLowerCase = key.toLowerCase();
-          if (
-            key !== keyInLowerCase &&
-            attrs && hasOwn(attrs, keyInLowerCase)
-          ) {
-            tip(
-              "Prop \"" + keyInLowerCase + "\" is passed to component " +
-              (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-              " \"" + key + "\". " +
-              "Note that HTML attributes are case-insensitive and camelCased " +
-              "props need to use their kebab-case equivalents when using in-DOM " +
-              "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-            );
-          }
-        }
-        checkProp(res, props, key, altKey, true) ||
-        checkProp(res, attrs, key, altKey, false);
-      }
-    }
-    return res
+  /* @flow */
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      var propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      var res = {};
+      var attrs = data.attrs;
+      var props = data.props;
+      if (isDef(attrs) || isDef(props)) {
+          for (var key in propOptions) {
+              var altKey = hyphenate(key);
+              {
+                  var keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                          (formatComponentName(
+                          // @ts-ignore
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
+                          "Note that HTML attributes are case-insensitive and camelCased " +
+                          "props need to use their kebab-case equivalents when using in-DOM " +
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
   }
-
-  function checkProp (
-    res,
-    hash,
-    key,
-    altKey,
-    preserve
-  ) {
-    if (isDef(hash)) {
-      if (hasOwn(hash, key)) {
-        res[key] = hash[key];
-        if (!preserve) {
-          delete hash[key];
-        }
-        return true
-      } else if (hasOwn(hash, altKey)) {
-        res[key] = hash[altKey];
-        if (!preserve) {
-          delete hash[altKey];
-        }
-        return true
-      }
-    }
-    return false
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
   }
 
-  /*  */
-
+  /* @flow */
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
   // For plain HTML markup, normalization can be completely skipped because the
   // generated render function is guaranteed to return Array<VNode>. There are
   // two cases where extra normalization is needed:
-
   // 1. When the children contains components - because a functional component
   // may return an Array instead of a single root. In this case, just a simple
   // normalization is needed - if any child is an Array, we flatten the whole
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
-  function simpleNormalizeChildren (children) {
-    for (var i = 0; i < children.length; i++) {
-      if (Array.isArray(children[i])) {
-        return Array.prototype.concat.apply([], children)
+  function simpleNormalizeChildren(children) {
+      for (var i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
       }
-    }
-    return children
+      return children;
   }
-
   // 2. When the children contains constructs that always generated nested Arrays,
   // e.g. <template>, <slot>, v-for, or when the children is provided by user
   // with hand-written render functions / JSX. In such cases a full normalization
   // is needed to cater to all possible types of children values.
-  function normalizeChildren (children) {
-    return isPrimitive(children)
-      ? [createTextVNode(children)]
-      : Array.isArray(children)
-        ? normalizeArrayChildren(children)
-        : undefined
-  }
-
-  function isTextNode (node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-  }
-
-  function normalizeArrayChildren (children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-      c = children[i];
-      if (isUndef(c) || typeof c === 'boolean') { continue }
-      lastIndex = res.length - 1;
-      last = res[lastIndex];
-      //  nested
-      if (Array.isArray(c)) {
-        if (c.length > 0) {
-          c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-          // merge adjacent text nodes
-          if (isTextNode(c[0]) && isTextNode(last)) {
-            res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-            c.shift();
-          }
-          res.push.apply(res, c);
-        }
-      } else if (isPrimitive(c)) {
-        if (isTextNode(last)) {
-          // merge adjacent text nodes
-          // this is necessary for SSR hydration because text nodes are
-          // essentially merged when rendered to HTML strings
-          res[lastIndex] = createTextVNode(last.text + c);
-        } else if (c !== '') {
-          // convert primitive to vnode
-          res.push(createTextVNode(c));
-        }
-      } else {
-        if (isTextNode(c) && isTextNode(last)) {
-          // merge adjacent text nodes
-          res[lastIndex] = createTextVNode(last.text + c.text);
-        } else {
-          // default key for nested array children (likely generated by v-for)
-          if (isTrue(children._isVList) &&
-            isDef(c.tag) &&
-            isUndef(c.key) &&
-            isDef(nestedIndex)) {
-            c.key = "__vlist" + nestedIndex + "_" + i + "__";
-          }
-          res.push(c);
-        }
-      }
-    }
-    return res
-  }
-
-  /*  */
-
-  function initProvide (vm) {
-    var provide = vm.$options.provide;
-    if (provide) {
-      vm._provided = typeof provide === 'function'
-        ? provide.call(vm)
-        : provide;
-    }
-  }
-
-  function initInjections (vm) {
-    var result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-      toggleObserving(false);
-      Object.keys(result).forEach(function (key) {
-        /* istanbul ignore else */
-        {
-          defineReactive$$1(vm, key, result[key], function () {
-            warn(
-              "Avoid mutating an injected value directly since the changes will be " +
-              "overwritten whenever the provided component re-renders. " +
-              "injection being mutated: \"" + key + "\"",
-              vm
-            );
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      var res = [];
+      var i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              { continue; }
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
+  }
+
+  /* @flow */
+  function initProvide(vm) {
+      var provide = vm.$options.provide;
+      if (provide) {
+          vm._provided =
+              typeof provide === 'function'
+                  ? // @ts-expect-error typing not correct
+                      provide.call(vm)
+                  : provide;
+      }
+  }
+  function initInjections(vm) {
+      var result = resolveInject(vm.$options.inject, vm);
+      if (result) {
+          toggleObserving(false);
+          Object.keys(result).forEach(function (key) {
+              /* istanbul ignore else */
+              {
+                  defineReactive$$1(vm, key, result[key], function () {
+                      warn("Avoid mutating an injected value directly since the changes will be " +
+                          "overwritten whenever the provided component re-renders. " +
+                          "injection being mutated: \"" + key + "\"", vm);
+                  });
+              }
           });
-        }
-      });
-      toggleObserving(true);
-    }
-  }
-
-  function resolveInject (inject, vm) {
-    if (inject) {
-      // inject is :any because flow is not smart enough to figure out cached
-      var result = Object.create(null);
-      var keys = hasSymbol
-        ? Reflect.ownKeys(inject)
-        : Object.keys(inject);
-
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        // #6574 in case the inject object is observed...
-        if (key === '__ob__') { continue }
-        var provideKey = inject[key].from;
-        var source = vm;
-        while (source) {
-          if (source._provided && hasOwn(source._provided, provideKey)) {
-            result[key] = source._provided[provideKey];
-            break
-          }
-          source = source.$parent;
-        }
-        if (!source) {
-          if ('default' in inject[key]) {
-            var provideDefault = inject[key].default;
-            result[key] = typeof provideDefault === 'function'
-              ? provideDefault.call(vm)
-              : provideDefault;
-          } else {
-            warn(("Injection \"" + key + "\" not found"), vm);
-          }
-        }
-      }
-      return result
-    }
+          toggleObserving(true);
+      }
+  }
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          var result = Object.create(null);
+          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (var i = 0; i < keys.length; i++) {
+              var key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  { continue; }
+              var provideKey = inject[key].from;
+              var source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      var provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      // @ts-ignore
+                      warn(("Injection \"" + key + "\" not found"), vm);
+                  }
+              }
+          }
+          return result;
+      }
   }
 
-  /*  */
-
-
-
+  /* @flow */
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
-  function resolveSlots (
-    children,
-    context
-  ) {
-    if (!children || !children.length) {
-      return {}
-    }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-      var child = children[i];
-      var data = child.data;
-      // remove slot attribute if the node is resolved as a Vue slot node
-      if (data && data.attrs && data.attrs.slot) {
-        delete data.attrs.slot;
-      }
-      // named slots should only be respected if the vnode was rendered in the
-      // same context.
-      if ((child.context === context || child.fnContext === context) &&
-        data && data.slot != null
-      ) {
-        var name = data.slot;
-        var slot = (slots[name] || (slots[name] = []));
-        if (child.tag === 'template') {
-          slot.push.apply(slot, child.children || []);
-        } else {
-          slot.push(child);
-        }
-      } else {
-        (slots.default || (slots.default = [])).push(child);
-      }
-    }
-    // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-      if (slots[name$1].every(isWhitespace)) {
-        delete slots[name$1];
-      }
-    }
-    return slots
-  }
-
-  function isWhitespace (node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' '
-  }
-
-  /*  */
-
-  function normalizeScopedSlots (
-    slots,
-    normalSlots,
-    prevSlots
-  ) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
-    if (!slots) {
-      res = {};
-    } else if (slots._normalized) {
-      // fast path 1: child component re-render only, parent did not change
-      return slots._normalized
-    } else if (
-      isStable &&
-      prevSlots &&
-      prevSlots !== emptyObject &&
-      key === prevSlots.$key &&
-      !hasNormalSlots &&
-      !prevSlots.$hasNormal
-    ) {
-      // fast path 2: stable scoped slots w/ no normal slots to proxy,
-      // only need to normalize once
-      return prevSlots
-    } else {
-      res = {};
-      for (var key$1 in slots) {
-        if (slots[key$1] && key$1[0] !== '$') {
-          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-        }
-      }
-    }
-    // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-      if (!(key$2 in res)) {
-        res[key$2] = proxyNormalSlot(normalSlots, key$2);
-      }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-      (slots)._normalized = res;
-    }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
-    return res
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      var slots = {};
+      for (var i = 0, l = children.length; i < l; i++) {
+          var child = children[i];
+          var data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  }
+
+  /* @flow */
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      var res;
+      var hasNormalSlots = Object.keys(normalSlots).length > 0;
+      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      var key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, '$stable', isStable);
+      def(res, '$key', key);
+      def(res, '$hasNormal', hasNormalSlots);
+      return res;
   }
-
   function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-      var res = arguments.length ? fn.apply(null, arguments) : fn({});
-      res = res && typeof res === 'object' && !Array.isArray(res)
-        ? [res] // single vnode
-        : normalizeChildren(res);
-      return res && (
-        res.length === 0 ||
-        (res.length === 1 && res[0].isComment) // #9658
-      ) ? undefined
-        : res
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-      Object.defineProperty(normalSlots, key, {
-        get: normalized,
-        enumerable: true,
-        configurable: true
-      });
-    }
-    return normalized
+      var normalized = function () {
+          var res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === 'object' && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
   }
-
   function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; }
+      return function () { return slots[key]; };
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering v-for lists.
    */
-  function renderList (
-    val,
-    render
-  ) {
-    var ret, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-      ret = new Array(val.length);
-      for (i = 0, l = val.length; i < l; i++) {
-        ret[i] = render(val[i], i);
-      }
-    } else if (typeof val === 'number') {
-      ret = new Array(val);
-      for (i = 0; i < val; i++) {
-        ret[i] = render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      if (hasSymbol && val[Symbol.iterator]) {
-        ret = [];
-        var iterator = val[Symbol.iterator]();
-        var result = iterator.next();
-        while (!result.done) {
-          ret.push(render(result.value, ret.length));
-          result = iterator.next();
-        }
-      } else {
-        keys = Object.keys(val);
-        ret = new Array(keys.length);
-        for (i = 0, l = keys.length; i < l; i++) {
-          key = keys[i];
-          ret[i] = render(val[key], key, i);
-        }
+  function renderList(val, render) {
+      var ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              var iterator = val[Symbol.iterator]();
+              var result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
       }
-    }
-    if (!isDef(ret)) {
-      ret = [];
-    }
-    (ret)._isVList = true;
-    return ret
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering <slot>
    */
-  function renderSlot (
-    name,
-    fallback,
-    props,
-    bindObject
-  ) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
-    if (scopedSlotFn) { // scoped slot
-      props = props || {};
-      if (bindObject) {
-        if (!isObject(bindObject)) {
-          warn(
-            'slot v-bind without argument expects an Object',
-            this
-          );
-        }
-        props = extend(extend({}, bindObject), props);
+  function renderSlot(name, fallback, props, bindObject) {
+      var scopedSlotFn = this.$scopedSlots[name];
+      var nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn('slot v-bind without argument expects an Object', this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes = scopedSlotFn(props) || fallback;
+      }
+      else {
+          nodes = this.$slots[name] || fallback;
+      }
+      var target = props && props.slot;
+      if (target) {
+          return this.$createElement('template', { slot: target }, nodes);
+      }
+      else {
+          return nodes;
       }
-      nodes = scopedSlotFn(props) || fallback;
-    } else {
-      nodes = this.$slots[name] || fallback;
-    }
-
-    var target = props && props.slot;
-    if (target) {
-      return this.$createElement('template', { slot: target }, nodes)
-    } else {
-      return nodes
-    }
   }
 
-  /*  */
-
   /**
    * Runtime helper for resolving filters
    */
-  function resolveFilter (id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /*  */
-
-  function isKeyNotMatch (expect, actual) {
-    if (Array.isArray(expect)) {
-      return expect.indexOf(actual) === -1
-    } else {
-      return expect !== actual
-    }
+  /* @flow */
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
   }
-
   /**
    * Runtime helper for checking keyCodes from config.
    * exposed as Vue.prototype._k
    * passing in eventKeyName as last argument separately for backwards compat
    */
-  function checkKeyCodes (
-    eventKeyCode,
-    key,
-    builtInKeyCode,
-    eventKeyName,
-    builtInKeyName
-  ) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-      return isKeyNotMatch(builtInKeyName, eventKeyName)
-    } else if (mappedKeyCode) {
-      return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-    } else if (eventKeyName) {
-      return hyphenate(eventKeyName) !== key
-    }
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
   }
 
-  /*  */
-
+  /* @flow */
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
-  function bindObjectProps (
-    data,
-    tag,
-    value,
-    asProp,
-    isSync
-  ) {
-    if (value) {
-      if (!isObject(value)) {
-        warn(
-          'v-bind without argument expects an Object or Array value',
-          this
-        );
-      } else {
-        if (Array.isArray(value)) {
-          value = toObject(value);
-        }
-        var hash;
-        var loop = function ( key ) {
-          if (
-            key === 'class' ||
-            key === 'style' ||
-            isReservedAttribute(key)
-          ) {
-            hash = data;
-          } else {
-            var type = data.attrs && data.attrs.type;
-            hash = asProp || config.mustUseProp(tag, type, key)
-              ? data.domProps || (data.domProps = {})
-              : data.attrs || (data.attrs = {});
-          }
-          var camelizedKey = camelize(key);
-          var hyphenatedKey = hyphenate(key);
-          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-            hash[key] = value[key];
-
-            if (isSync) {
-              var on = data.on || (data.on = {});
-              on[("update:" + key)] = function ($event) {
-                value[key] = $event;
-              };
-            }
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn('v-bind without argument expects an Object or Array value', this);
           }
-        };
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              var hash;
+              var loop = function ( key ) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      var type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  var camelizedKey = camelize(key);
+                  var hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          var on = data.on || (data.on = {});
+                          on[("update:" + key)] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              };
 
-        for (var key in value) loop( key );
+              for (var key in value) loop( key );
+          }
       }
-    }
-    return data
+      return data;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering static trees.
    */
-  function renderStatic (
-    index,
-    isInFor
-  ) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-      return tree
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(
-      this._renderProxy,
-      null,
-      this // for render fns generated for functional component templates
-    );
-    markStatic(tree, ("__static__" + index), false);
-    return tree
+  function renderStatic(index, isInFor) {
+      var cached = this._staticTrees || (this._staticTrees = []);
+      var tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, ("__static__" + index), false);
+      return tree;
   }
-
   /**
    * Runtime helper for v-once.
    * Effectively it means marking the node as static with a unique key.
    */
-  function markOnce (
-    tree,
-    index,
-    key
-  ) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-    return tree
-  }
-
-  function markStatic (
-    tree,
-    key,
-    isOnce
-  ) {
-    if (Array.isArray(tree)) {
-      for (var i = 0; i < tree.length; i++) {
-        if (tree[i] && typeof tree[i] !== 'string') {
-          markStaticNode(tree[i], (key + "_" + i), isOnce);
-        }
-      }
-    } else {
-      markStaticNode(tree, key, isOnce);
-    }
+  function markOnce(tree, index, key) {
+      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (var i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
   }
-
-  function markStaticNode (node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
-  /*  */
-
-  function bindObjectListeners (data, value) {
-    if (value) {
-      if (!isPlainObject(value)) {
-        warn(
-          'v-on without argument expects an Object value',
-          this
-        );
-      } else {
-        var on = data.on = data.on ? extend({}, data.on) : {};
-        for (var key in value) {
-          var existing = on[key];
-          var ours = value[key];
-          on[key] = existing ? [].concat(existing, ours) : ours;
-        }
-      }
-    }
-    return data
+  /* @flow */
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn('v-on without argument expects an Object value', this);
+          }
+          else {
+              var on = (data.on = data.on ? extend({}, data.on) : {});
+              for (var key in value) {
+                  var existing = on[key];
+                  var ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
+      }
+      return data;
   }
 
-  /*  */
-
-  function resolveScopedSlots (
-    fns, // see flow/vnode
-    res,
-    // the following are added in 2.6
-    hasDynamicKeys,
-    contentHashKey
-  ) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-      var slot = fns[i];
-      if (Array.isArray(slot)) {
-        resolveScopedSlots(slot, res, hasDynamicKeys);
-      } else if (slot) {
-        // marker for reverse proxying v-slot without scope on this.$slots
-        if (slot.proxy) {
-          slot.fn.proxy = true;
-        }
-        res[slot.key] = slot.fn;
-      }
-    }
-    if (contentHashKey) {
-      (res).$key = contentHashKey;
-    }
-    return res
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (var i = 0; i < fns.length; i++) {
+          var slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
-  /*  */
-
-  function bindDynamicKeys (baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-      var key = values[i];
-      if (typeof key === 'string' && key) {
-        baseObj[values[i]] = values[i + 1];
-      } else if (key !== '' && key !== null) {
-        // null is a special value for explicitly removing a binding
-        warn(
-          ("Invalid value for dynamic directive argument (expected string or null): " + key),
-          this
-        );
-      }
-    }
-    return baseObj
+  /* @flow */
+  function bindDynamicKeys(baseObj, values) {
+      for (var i = 0; i < values.length; i += 2) {
+          var key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+          }
+      }
+      return baseObj;
   }
-
   // helper to dynamically append modifier runtime markers to event names.
   // ensure only append when value is already string, otherwise it will be cast
   // to string and cause the type check to miss.
-  function prependModifier (value, symbol) {
-    return typeof value === 'string' ? symbol + value : value
-  }
-
-  /*  */
-
-  function installRenderHelpers (target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-  }
-
-  /*  */
-
-  function FunctionalRenderContext (
-    data,
-    props,
-    children,
-    parent,
-    Ctor
-  ) {
-    var this$1 = this;
-
-    var options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
-    if (hasOwn(parent, '_uid')) {
-      contextVm = Object.create(parent);
-      // $flow-disable-line
-      contextVm._original = parent;
-    } else {
-      // the context vm passed in is a functional context as well.
-      // in this case we want to make sure we are able to get a hold to the
-      // real context instance.
-      contextVm = parent;
-      // $flow-disable-line
-      parent = parent._original;
-    }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
-
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-      if (!this$1.$slots) {
-        normalizeScopedSlots(
-          data.scopedSlots,
-          this$1.$slots = resolveSlots(children, parent)
-        );
-      }
-      return this$1.$slots
-    };
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
+  }
+
+  /* @flow */
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
+  }
+
+  /* @flow */
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      var this$1 = this;
 
-    Object.defineProperty(this, 'scopedSlots', ({
-      enumerable: true,
-      get: function get () {
-        return normalizeScopedSlots(data.scopedSlots, this.slots())
+      var options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      var contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
       }
-    }));
-
-    // support for compiled functional template
-    if (isCompiled) {
-      // exposing $options for renderStatic()
-      this.$options = options;
-      // pre-resolve slots for renderSlot()
-      this.$slots = this.slots();
-      this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-
-    if (options._scopeId) {
-      this._c = function (a, b, c, d) {
-        var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-        if (vnode && !Array.isArray(vnode)) {
-          vnode.fnScopeId = options._scopeId;
-          vnode.fnContext = parent;
-        }
-        return vnode
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      var isCompiled = isTrue(options._compiled);
+      var needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = function () {
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          }
+          return this$1.$slots;
       };
-    } else {
-      this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-    }
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get: function get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = function (a, b, c, d) {
+              var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+      }
   }
-
   installRenderHelpers(FunctionalRenderContext.prototype);
-
-  function createFunctionalComponent (
-    Ctor,
-    propsData,
-    data,
-    contextVm,
-    children
-  ) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
-    if (isDef(propOptions)) {
-      for (var key in propOptions) {
-        props[key] = validateProp(key, propOptions, propsData || emptyObject);
-      }
-    } else {
-      if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-      if (isDef(data.props)) { mergeProps(props, data.props); }
-    }
-
-    var renderContext = new FunctionalRenderContext(
-      data,
-      props,
-      children,
-      contextVm,
-      Ctor
-    );
-
-    var vnode = options.render.call(null, renderContext._c, renderContext);
-
-    if (vnode instanceof VNode) {
-      return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-    } else if (Array.isArray(vnode)) {
-      var vnodes = normalizeChildren(vnode) || [];
-      var res = new Array(vnodes.length);
-      for (var i = 0; i < vnodes.length; i++) {
-        res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      var options = Ctor.options;
+      var props = {};
+      var propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (var key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              { mergeProps(props, data.attrs); }
+          if (isDef(data.props))
+              { mergeProps(props, data.props); }
+      }
+      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      var vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          var vnodes = normalizeChildren(vnode) || [];
+          var res = new Array(vnodes.length);
+          for (var i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
       }
-      return res
-    }
   }
-
-  function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    var clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-      (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-      (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      var clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
   }
-
-  function mergeProps (to, from) {
-    for (var key in from) {
-      to[camelize(key)] = from[key];
-    }
+  function mergeProps(to, from) {
+      for (var key in from) {
+          to[camelize(key)] = from[key];
+      }
   }
 
-  /*  */
+  /* @flow */
 
-  /*  */
-
-  /*  */
-
-  /*  */
+  /* @flow */
 
+  /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-    init: function init (vnode, hydrating) {
-      if (
-        vnode.componentInstance &&
-        !vnode.componentInstance._isDestroyed &&
-        vnode.data.keepAlive
-      ) {
-        // kept-alive components, treat as a patch
-        var mountedNode = vnode; // work around flow
-        componentVNodeHooks.prepatch(mountedNode, mountedNode);
-      } else {
-        var child = vnode.componentInstance = createComponentInstanceForVnode(
-          vnode,
-          activeInstance
-        );
-        child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-      }
-    },
-
-    prepatch: function prepatch (oldVnode, vnode) {
-      var options = vnode.componentOptions;
-      var child = vnode.componentInstance = oldVnode.componentInstance;
-      updateChildComponent(
-        child,
-        options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-      );
-    },
-
-    insert: function insert (vnode) {
-      var context = vnode.context;
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isMounted) {
-        componentInstance._isMounted = true;
-        callHook(componentInstance, 'mounted');
-      }
-      if (vnode.data.keepAlive) {
-        if (context._isMounted) {
-          // vue-router#1212
-          // During updates, a kept-alive component's child components may
-          // change, so directly walking the tree here may call activated hooks
-          // on incorrect children. Instead we push them into a queue which will
-          // be processed after the whole patch process ended.
-          queueActivatedComponent(componentInstance);
-        } else {
-          activateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    },
-
-    destroy: function destroy (vnode) {
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isDestroyed) {
-        if (!vnode.data.keepAlive) {
-          componentInstance.$destroy();
-        } else {
-          deactivateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    }
+      init: function init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              var mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch: function prepatch(oldVnode, vnode) {
+          var options = vnode.componentOptions;
+          var child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy: function destroy(vnode) {
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
   };
-
   var hooksToMerge = Object.keys(componentVNodeHooks);
-
-  function createComponent (
-    Ctor,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    if (isUndef(Ctor)) {
-      return
-    }
-
-    var baseCtor = context.$options._base;
-
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-      Ctor = baseCtor.extend(Ctor);
-    }
-
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-      {
-        warn(("Invalid Component definition: " + (String(Ctor))), context);
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      var baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn(("Invalid Component definition: " + (String(Ctor))), context);
+          }
+          return;
+      }
+      // async component
+      var asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
       }
-      return
-    }
-
-    // async component
-    var asyncFactory;
-    if (isUndef(Ctor.cid)) {
-      asyncFactory = Ctor;
-      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-      if (Ctor === undefined) {
-        // return a placeholder node for async component, which is rendered
-        // as a comment node but preserves all the raw information for the node.
-        // the information will be used for async server-rendering and hydration.
-        return createAsyncPlaceholder(
-          asyncFactory,
-          data,
-          context,
-          children,
-          tag
-        )
-      }
-    }
-
-    data = data || {};
-
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-      transformModel(Ctor.options, data);
-    }
-
-    // extract props
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-    // functional component
-    if (isTrue(Ctor.options.functional)) {
-      return createFunctionalComponent(Ctor, propsData, data, context, children)
-    }
-
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    var listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-
-    if (isTrue(Ctor.options.abstract)) {
-      // abstract components do not keep anything
-      // other than props & listeners & slot
-
-      // work around flow
-      var slot = data.slot;
-      data = {};
-      if (slot) {
-        data.slot = slot;
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      var listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          var slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
       }
-    }
-
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-
-    // return a placeholder vnode
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-      data, undefined, undefined, undefined, context,
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-      asyncFactory
-    );
-
-    return vnode
-  }
-
-  function createComponentInstanceForVnode (
-    vnode, // we know it's MountedComponentVNode but flow doesn't
-    parent // activeInstance in lifecycle state
-  ) {
-    var options = {
-      _isComponent: true,
-      _parentVnode: vnode,
-      parent: parent
-    };
-    // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-      options.render = inlineTemplate.render;
-      options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options)
-  }
-
-  function installComponentHooks (data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-      var key = hooksToMerge[i];
-      var existing = hooks[key];
-      var toMerge = componentVNodeHooks[key];
-      if (existing !== toMerge && !(existing && existing._merged)) {
-        hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      var name = Ctor.options.name || tag;
+      var vnode = new VNode(
+      // @ts-expect-error
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      var options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent: parent,
+      };
+      // check inline-template render functions
+      var inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      var hooks = data.hook || (data.hook = {});
+      for (var i = 0; i < hooksToMerge.length; i++) {
+          var key = hooksToMerge[i];
+          var existing = hooks[key];
+          var toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+          }
       }
-    }
   }
-
-  function mergeHook$1 (f1, f2) {
-    var merged = function (a, b) {
-      // flow complains about extra args which is why we use any
-      f1(a, b);
-      f2(a, b);
-    };
-    merged._merged = true;
-    return merged
+  function mergeHook$1(f1, f2) {
+      var merged = function (a, b) {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
   }
-
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
-  function transformModel (options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input'
-    ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
-    if (isDef(existing)) {
-      if (
-        Array.isArray(existing)
-          ? existing.indexOf(callback) === -1
-          : existing !== callback
-      ) {
-        on[event] = [callback].concat(existing);
-      }
-    } else {
-      on[event] = callback;
-    }
+  function transformModel(options, data) {
+      var prop = (options.model && options.model.prop) || 'value';
+      var event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      var on = data.on || (data.on = {});
+      var existing = on[event];
+      var callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
-
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType,
-    alwaysNormalize
-  ) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-      normalizationType = children;
-      children = data;
-      data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-      normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType)
-  }
-
-  function _createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType
-  ) {
-    if (isDef(data) && isDef((data).__ob__)) {
-      warn(
-        "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-        'Always create fresh vnode data objects in each render!',
-        context
-      );
-      return createEmptyVNode()
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-      tag = data.is;
-    }
-    if (!tag) {
-      // in case of component :is set to falsy value
-      return createEmptyVNode()
-    }
-    // warn against non-primitive key
-    if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-    ) {
-      {
-        warn(
-          'Avoid using non-primitive value as key, ' +
-          'use string/number value instead.',
-          context
-        );
-      }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) &&
-      typeof children[0] === 'function'
-    ) {
-      data = data || {};
-      data.scopedSlots = { default: children[0] };
-      children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-      children = normalizeChildren(children);
-    } else if (normalizationType === SIMPLE_NORMALIZE) {
-      children = simpleNormalizeChildren(children);
-    }
-    var vnode, ns;
-    if (typeof tag === 'string') {
-      var Ctor;
-      ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-      if (config.isReservedTag(tag)) {
-        // platform built-in elements
-        if (isDef(data) && isDef(data.nativeOn)) {
-          warn(
-            ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-            context
-          );
-        }
-        vnode = new VNode(
-          config.parsePlatformTagName(tag), data, children,
-          undefined, undefined, context
-        );
-      } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-        // component
-        vnode = createComponent(Ctor, data, context, children, tag);
-      } else {
-        // unknown or unlisted namespaced elements
-        // check at runtime because it may get assigned a namespace when its
-        // parent normalizes children
-        vnode = new VNode(
-          tag, data, children,
-          undefined, undefined, context
-        );
-      }
-    } else {
-      // direct component options / constructor
-      vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-      return vnode
-    } else if (isDef(vnode)) {
-      if (isDef(ns)) { applyNS(vnode, ns); }
-      if (isDef(data)) { registerDeepBindings(data); }
-      return vnode
-    } else {
-      return createEmptyVNode()
-    }
-  }
-
-  function applyNS (vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-      // use default namespace inside foreignObject
-      ns = undefined;
-      force = true;
-    }
-    if (isDef(vnode.children)) {
-      for (var i = 0, l = vnode.children.length; i < l; i++) {
-        var child = vnode.children[i];
-        if (isDef(child.tag) && (
-          isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-          applyNS(child, ns, force);
-        }
-      }
-    }
+  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      var vnode, ns;
+      if (typeof tag === 'string') {
+          var Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if (config.isReservedTag(tag)) {
+              // platform built-in elements
+              if (isDef(data) &&
+                  isDef(data.nativeOn) &&
+                  data.tag !== 'component') {
+                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+              }
+              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+          }
+          else if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              { applyNS(vnode, ns); }
+          if (isDef(data))
+              { registerDeepBindings(data); }
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (var i = 0, l = vnode.children.length; i < l; i++) {
+              var child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
   }
-
   // ref #5318
   // necessary to ensure parent re-render when deep bindings like :style and
   // :class are used on slot nodes
-  function registerDeepBindings (data) {
-    if (isObject(data.style)) {
-      traverse(data.style);
-    }
-    if (isObject(data.class)) {
-      traverse(data.class);
-    }
-  }
-
-  /*  */
-
-  function initRender (vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
-
-    /* istanbul ignore else */
-    {
-      defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-        !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-      }, true);
-      defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-        !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-      }, true);
-    }
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
+  }
+
+  /* @flow */
+  function initRender(vm) {
+      vm._vnode = null; // the root of the child tree
+      vm._staticTrees = null; // v-once cached trees
+      var options = vm.$options;
+      var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      var renderContext = parentVnode && parentVnode.context;
+      vm.$slots = resolveSlots(options._renderChildren, renderContext);
+      vm.$scopedSlots = emptyObject;
+      // bind the createElement fn to this instance
+      // so that we get proper render context inside it.
+      // args order: tag, data, children, normalizationType, alwaysNormalize
+      // internal version is used by render functions compiled from templates
+      // @ts-expect-error
+      vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+      // normalization is always applied for the public version, used in
+      // user-written render functions.
+      // @ts-expect-error
+      vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+      // $attrs & $listeners are exposed for easier HOC creation.
+      // they need to be reactive so that HOCs using them are always updated
+      var parentData = parentVnode && parentVnode.data;
+      /* istanbul ignore else */
+      {
+          defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+              !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+          }, true);
+          defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+              !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+          }, true);
+      }
   }
-
   var currentRenderingInstance = null;
-
-  function renderMixin (Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-
-    Vue.prototype.$nextTick = function (fn) {
-      return nextTick(fn, this)
-    };
-
-    Vue.prototype._render = function () {
-      var vm = this;
-      var ref = vm.$options;
-      var render = ref.render;
-      var _parentVnode = ref._parentVnode;
-
-      if (_parentVnode) {
-        vm.$scopedSlots = normalizeScopedSlots(
-          _parentVnode.data.scopedSlots,
-          vm.$slots,
-          vm.$scopedSlots
-        );
-      }
-
-      // set parent vnode. this allows render functions to have access
-      // to the data on the placeholder node.
-      vm.$vnode = _parentVnode;
-      // render self
-      var vnode;
-      try {
-        // There's no need to maintain a stack because all render fns are called
-        // separately from one another. Nested component's render fns are called
-        // when parent component is patched.
-        currentRenderingInstance = vm;
-        vnode = render.call(vm._renderProxy, vm.$createElement);
-      } catch (e) {
-        handleError(e, vm, "render");
-        // return error render result,
-        // or previous vnode to prevent render error causing blank component
-        /* istanbul ignore else */
-        if (vm.$options.renderError) {
+  function renderMixin(Vue) {
+      // install runtime convenience helpers
+      installRenderHelpers(Vue.prototype);
+      Vue.prototype.$nextTick = function (fn) {
+          return nextTick(fn, this);
+      };
+      Vue.prototype._render = function () {
+          var vm = this;
+          var ref = vm.$options;
+          var render = ref.render;
+          var _parentVnode = ref._parentVnode;
+          if (_parentVnode) {
+              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+          }
+          // set parent vnode. this allows render functions to have access
+          // to the data on the placeholder node.
+          vm.$vnode = _parentVnode;
+          // render self
+          var vnode;
           try {
-            vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-          } catch (e) {
-            handleError(e, vm, "renderError");
-            vnode = vm._vnode;
-          }
-        } else {
-          vnode = vm._vnode;
-        }
-      } finally {
-        currentRenderingInstance = null;
-      }
-      // if the returned array contains only a single node, allow it
-      if (Array.isArray(vnode) && vnode.length === 1) {
-        vnode = vnode[0];
-      }
-      // return empty vnode in case the render function errored out
-      if (!(vnode instanceof VNode)) {
-        if (Array.isArray(vnode)) {
-          warn(
-            'Multiple root nodes returned from render function. Render function ' +
-            'should return a single root node.',
-            vm
-          );
-        }
-        vnode = createEmptyVNode();
-      }
-      // set parent
-      vnode.parent = _parentVnode;
-      return vnode
-    };
-  }
-
-  /*  */
-
-  function ensureCtor (comp, base) {
-    if (
-      comp.__esModule ||
-      (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-    ) {
-      comp = comp.default;
-    }
-    return isObject(comp)
-      ? base.extend(comp)
-      : comp
-  }
-
-  function createAsyncPlaceholder (
-    factory,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    var node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-    return node
-  }
-
-  function resolveAsyncComponent (
-    factory,
-    baseCtor
-  ) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-      return factory.errorComp
-    }
-
-    if (isDef(factory.resolved)) {
-      return factory.resolved
-    }
-
-    var owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-      // already pending
-      factory.owners.push(owner);
-    }
-
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-      return factory.loadingComp
-    }
-
-    if (owner && !isDef(factory.owners)) {
-      var owners = factory.owners = [owner];
-      var sync = true;
-      var timerLoading = null;
-      var timerTimeout = null
-
-      ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-      var forceRender = function (renderCompleted) {
-        for (var i = 0, l = owners.length; i < l; i++) {
-          (owners[i]).$forceUpdate();
-        }
-
-        if (renderCompleted) {
-          owners.length = 0;
-          if (timerLoading !== null) {
-            clearTimeout(timerLoading);
-            timerLoading = null;
+              // There's no need to maintain a stack because all render fns are called
+              // separately from one another. Nested component's render fns are called
+              // when parent component is patched.
+              currentRenderingInstance = vm;
+              vnode = render.call(vm._renderProxy, vm.$createElement);
           }
-          if (timerTimeout !== null) {
-            clearTimeout(timerTimeout);
-            timerTimeout = null;
+          catch (e) {
+              handleError(e, vm, "render");
+              // return error render result,
+              // or previous vnode to prevent render error causing blank component
+              /* istanbul ignore else */
+              if (vm.$options.renderError) {
+                  try {
+                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                  }
+                  catch (e) {
+                      handleError(e, vm, "renderError");
+                      vnode = vm._vnode;
+                  }
+              }
+              else {
+                  vnode = vm._vnode;
+              }
           }
-        }
-      };
-
-      var resolve = once(function (res) {
-        // cache resolved
-        factory.resolved = ensureCtor(res, baseCtor);
-        // invoke callbacks only if this is not a synchronous resolve
-        // (async resolves are shimmed as synchronous during SSR)
-        if (!sync) {
-          forceRender(true);
-        } else {
-          owners.length = 0;
-        }
-      });
-
-      var reject = once(function (reason) {
-        warn(
-          "Failed to resolve async component: " + (String(factory)) +
-          (reason ? ("\nReason: " + reason) : '')
-        );
-        if (isDef(factory.errorComp)) {
-          factory.error = true;
-          forceRender(true);
-        }
-      });
-
-      var res = factory(resolve, reject);
-
-      if (isObject(res)) {
-        if (isPromise(res)) {
-          // () => Promise
-          if (isUndef(factory.resolved)) {
-            res.then(resolve, reject);
-          }
-        } else if (isPromise(res.component)) {
-          res.component.then(resolve, reject);
-
-          if (isDef(res.error)) {
-            factory.errorComp = ensureCtor(res.error, baseCtor);
+          finally {
+              currentRenderingInstance = null;
           }
-
-          if (isDef(res.loading)) {
-            factory.loadingComp = ensureCtor(res.loading, baseCtor);
-            if (res.delay === 0) {
-              factory.loading = true;
-            } else {
-              timerLoading = setTimeout(function () {
-                timerLoading = null;
-                if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                  factory.loading = true;
-                  forceRender(false);
-                }
-              }, res.delay || 200);
-            }
+          // if the returned array contains only a single node, allow it
+          if (Array.isArray(vnode) && vnode.length === 1) {
+              vnode = vnode[0];
           }
-
-          if (isDef(res.timeout)) {
-            timerTimeout = setTimeout(function () {
-              timerTimeout = null;
-              if (isUndef(factory.resolved)) {
-                reject(
-                  "timeout (" + (res.timeout) + "ms)"
-                );
+          // return empty vnode in case the render function errored out
+          if (!(vnode instanceof VNode)) {
+              if (Array.isArray(vnode)) {
+                  warn('Multiple root nodes returned from render function. Render function ' +
+                      'should return a single root node.', vm);
               }
-            }, res.timeout);
+              vnode = createEmptyVNode();
           }
-        }
-      }
-
-      sync = false;
-      // return in case resolved synchronously
-      return factory.loading
-        ? factory.loadingComp
-        : factory.resolved
-    }
-  }
-
-  /*  */
-
-  function isAsyncPlaceholder (node) {
-    return node.isComment && node.asyncFactory
+          // set parent
+          vnode.parent = _parentVnode;
+          return vnode;
+      };
   }
 
-  /*  */
-
-  function getFirstComponentChild (children) {
-    if (Array.isArray(children)) {
-      for (var i = 0; i < children.length; i++) {
-        var c = children[i];
-        if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-          return c
-        }
+  /* @flow */
+  function ensureCtor(comp, base) {
+      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+          comp = comp.default;
       }
-    }
+      return isObject(comp) ? base.extend(comp) : comp;
   }
-
-  /*  */
-
-  /*  */
-
-  function initEvents (vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    var listeners = vm.$options._parentListeners;
-    if (listeners) {
-      updateComponentListeners(vm, listeners);
-    }
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      var node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+      return node;
   }
-
-  var target;
-
-  function add (event, fn) {
-    target.$on(event, fn);
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      var owner = currentRenderingInstance;
+      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+          // already pending
+          factory.owners.push(owner);
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+      if (owner && !isDef(factory.owners)) {
+          var owners = (factory.owners = [owner]);
+          var sync = true;
+          var timerLoading = null;
+          var timerTimeout = null;
+          owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+          var forceRender = function (renderCompleted) {
+              for (var i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
+              }
+              if (renderCompleted) {
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
+                  }
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
+                  }
+              }
+          };
+          var resolve = once(function (res) {
+              // cache resolved
+              factory.resolved = ensureCtor(res, baseCtor);
+              // invoke callbacks only if this is not a synchronous resolve
+              // (async resolves are shimmed as synchronous during SSR)
+              if (!sync) {
+                  forceRender(true);
+              }
+              else {
+                  owners.length = 0;
+              }
+          });
+          var reject = once(function (reason) {
+              warn("Failed to resolve async component: " + (String(factory)) +
+                      (reason ? ("\nReason: " + reason) : ''));
+              if (isDef(factory.errorComp)) {
+                  factory.error = true;
+                  forceRender(true);
+              }
+          });
+          var res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
+                  // () => Promise
+                  if (isUndef(factory.resolved)) {
+                      res.then(resolve, reject);
+                  }
+              }
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
+                  }
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
+                          factory.loading = true;
+                      }
+                      else {
+                          // @ts-expect-error NodeJS timeout type
+                          timerLoading = setTimeout(function () {
+                              timerLoading = null;
+                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                  factory.loading = true;
+                                  forceRender(false);
+                              }
+                          }, res.delay || 200);
+                      }
+                  }
+                  if (isDef(res.timeout)) {
+                      // @ts-expect-error NodeJS timeout type
+                      timerTimeout = setTimeout(function () {
+                          timerTimeout = null;
+                          if (isUndef(factory.resolved)) {
+                              reject("timeout (" + (res.timeout) + "ms)");
+                          }
+                      }, res.timeout);
+                  }
+              }
+          }
+          sync = false;
+          // return in case resolved synchronously
+          return factory.loading ? factory.loadingComp : factory.resolved;
+      }
   }
 
-  function remove$1 (event, fn) {
-    target.$off(event, fn);
+  /* @flow */
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
   }
 
-  function createOnceHandler (event, fn) {
-    var _target = target;
-    return function onceHandler () {
-      var res = fn.apply(null, arguments);
-      if (res !== null) {
-        _target.$off(event, onceHandler);
+  /* @flow */
+  function getFirstComponentChild(children) {
+      if (Array.isArray(children)) {
+          for (var i = 0; i < children.length; i++) {
+              var c = children[i];
+              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                  return c;
+              }
+          }
       }
-    }
-  }
-
-  function updateComponentListeners (
-    vm,
-    listeners,
-    oldListeners
-  ) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
   }
 
-  function eventsMixin (Vue) {
-    var hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-      var vm = this;
-      if (Array.isArray(event)) {
-        for (var i = 0, l = event.length; i < l; i++) {
-          vm.$on(event[i], fn);
-        }
-      } else {
-        (vm._events[event] || (vm._events[event] = [])).push(fn);
-        // optimize hook:event cost by using a boolean flag marked at registration
-        // instead of a hash lookup
-        if (hookRE.test(event)) {
-          vm._hasHookEvent = true;
-        }
-      }
-      return vm
-    };
-
-    Vue.prototype.$once = function (event, fn) {
-      var vm = this;
-      function on () {
-        vm.$off(event, on);
-        fn.apply(vm, arguments);
-      }
-      on.fn = fn;
-      vm.$on(event, on);
-      return vm
-    };
-
-    Vue.prototype.$off = function (event, fn) {
-      var vm = this;
-      // all
-      if (!arguments.length) {
-        vm._events = Object.create(null);
-        return vm
-      }
-      // array of events
-      if (Array.isArray(event)) {
-        for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-          vm.$off(event[i$1], fn);
-        }
-        return vm
-      }
-      // specific event
-      var cbs = vm._events[event];
-      if (!cbs) {
-        return vm
-      }
-      if (!fn) {
-        vm._events[event] = null;
-        return vm
-      }
-      // specific handler
-      var cb;
-      var i = cbs.length;
-      while (i--) {
-        cb = cbs[i];
-        if (cb === fn || cb.fn === fn) {
-          cbs.splice(i, 1);
-          break
-        }
-      }
-      return vm
-    };
+  /* @flow */
 
-    Vue.prototype.$emit = function (event) {
-      var vm = this;
-      {
-        var lowerCaseEvent = event.toLowerCase();
-        if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-          tip(
-            "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-            (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-            "Note that HTML attributes are case-insensitive and you cannot use " +
-            "v-on to listen to camelCase events when using in-DOM templates. " +
-            "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-          );
-        }
+  /* @flow */
+  function initEvents(vm) {
+      vm._events = Object.create(null);
+      vm._hasHookEvent = false;
+      // init parent attached events
+      var listeners = vm.$options._parentListeners;
+      if (listeners) {
+          updateComponentListeners(vm, listeners);
       }
-      var cbs = vm._events[event];
-      if (cbs) {
-        cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-        var args = toArray(arguments, 1);
-        var info = "event handler for \"" + event + "\"";
-        for (var i = 0, l = cbs.length; i < l; i++) {
-          invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-        }
-      }
-      return vm
-    };
+  }
+  var target;
+  function add(event, fn) {
+      target.$on(event, fn);
+  }
+  function remove$1(event, fn) {
+      target.$off(event, fn);
+  }
+  function createOnceHandler(event, fn) {
+      var _target = target;
+      return function onceHandler() {
+          var res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
+  }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target = vm;
+      updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+      target = undefined;
+  }
+  function eventsMixin(Vue) {
+      var hookRE = /^hook:/;
+      Vue.prototype.$on = function (event, fn) {
+          var vm = this;
+          if (Array.isArray(event)) {
+              for (var i = 0, l = event.length; i < l; i++) {
+                  vm.$on(event[i], fn);
+              }
+          }
+          else {
+              (vm._events[event] || (vm._events[event] = [])).push(fn);
+              // optimize hook:event cost by using a boolean flag marked at registration
+              // instead of a hash lookup
+              if (hookRE.test(event)) {
+                  vm._hasHookEvent = true;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$once = function (event, fn) {
+          var vm = this;
+          function on() {
+              vm.$off(event, on);
+              fn.apply(vm, arguments);
+          }
+          on.fn = fn;
+          vm.$on(event, on);
+          return vm;
+      };
+      Vue.prototype.$off = function (event, fn) {
+          var vm = this;
+          // all
+          if (!arguments.length) {
+              vm._events = Object.create(null);
+              return vm;
+          }
+          // array of events
+          if (Array.isArray(event)) {
+              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                  vm.$off(event[i$1], fn);
+              }
+              return vm;
+          }
+          // specific event
+          var cbs = vm._events[event];
+          if (!cbs) {
+              return vm;
+          }
+          if (!fn) {
+              vm._events[event] = null;
+              return vm;
+          }
+          // specific handler
+          var cb;
+          var i = cbs.length;
+          while (i--) {
+              cb = cbs[i];
+              if (cb === fn || cb.fn === fn) {
+                  cbs.splice(i, 1);
+                  break;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$emit = function (event) {
+          var vm = this;
+          {
+              var lowerCaseEvent = event.toLowerCase();
+              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                  tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                      "Note that HTML attributes are case-insensitive and you cannot use " +
+                      "v-on to listen to camelCase events when using in-DOM templates. " +
+                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+              }
+          }
+          var cbs = vm._events[event];
+          if (cbs) {
+              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+              var args = toArray(arguments, 1);
+              var info = "event handler for \"" + event + "\"";
+              for (var i = 0, l = cbs.length; i < l; i++) {
+                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+              }
+          }
+          return vm;
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var activeInstance = null;
   var isUpdatingChildComponent = false;
-
   function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return function () {
-      activeInstance = prevActiveInstance;
-    }
+      var prevActiveInstance = activeInstance;
+      activeInstance = vm;
+      return function () {
+          activeInstance = prevActiveInstance;
+      };
   }
-
-  function initLifecycle (vm) {
-    var options = vm.$options;
-
-    // locate first non-abstract parent
-    var parent = options.parent;
-    if (parent && !options.abstract) {
-      while (parent.$options.abstract && parent.$parent) {
-        parent = parent.$parent;
-      }
-      parent.$children.push(vm);
-    }
-
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-
-    vm.$children = [];
-    vm.$refs = {};
-
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
+  function initLifecycle(vm) {
+      var options = vm.$options;
+      // locate first non-abstract parent
+      var parent = options.parent;
+      if (parent && !options.abstract) {
+          while (parent.$options.abstract && parent.$parent) {
+              parent = parent.$parent;
+          }
+          parent.$children.push(vm);
+      }
+      vm.$parent = parent;
+      vm.$root = parent ? parent.$root : vm;
+      vm.$children = [];
+      vm.$refs = {};
+      // @ts-ignore
+      vm._watcher = null;
+      vm._inactive = null;
+      vm._directInactive = false;
+      vm._isMounted = false;
+      vm._isDestroyed = false;
+      vm._isBeingDestroyed = false;
+  }
+  function lifecycleMixin(Vue) {
+      Vue.prototype._update = function (vnode, hydrating) {
+          var vm = this;
+          var prevEl = vm.$el;
+          var prevVnode = vm._vnode;
+          var restoreActiveInstance = setActiveInstance(vm);
+          vm._vnode = vnode;
+          // Vue.prototype.__patch__ is injected in entry points
+          // based on the rendering backend used.
+          if (!prevVnode) {
+              // initial render
+              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+          }
+          else {
+              // updates
+              vm.$el = vm.__patch__(prevVnode, vnode);
+          }
+          restoreActiveInstance();
+          // update __vue__ reference
+          if (prevEl) {
+              prevEl.__vue__ = null;
+          }
+          if (vm.$el) {
+              vm.$el.__vue__ = vm;
+          }
+          // if parent is an HOC, update its $el as well
+          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+              vm.$parent.$el = vm.$el;
+          }
+          // updated hook is called by the scheduler to ensure that children are
+          // updated in a parent's updated hook.
+      };
+      Vue.prototype.$forceUpdate = function () {
+          var vm = this;
+          if (vm._watcher) {
+              vm._watcher.update();
+          }
+      };
+      Vue.prototype.$destroy = function () {
+          var vm = this;
+          if (vm._isBeingDestroyed) {
+              return;
+          }
+          callHook(vm, 'beforeDestroy');
+          vm._isBeingDestroyed = true;
+          // remove self from parent
+          var parent = vm.$parent;
+          // @ts-ignore
+          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+              remove(parent.$children, vm);
+          }
+          // teardown watchers
+          if (vm._watcher) {
+              vm._watcher.teardown();
+          }
+          var i = vm._watchers.length;
+          while (i--) {
+              vm._watchers[i].teardown();
+          }
+          // remove reference from data ob
+          // frozen object may not have observer.
+          if (vm._data.__ob__) {
+              vm._data.__ob__.vmCount--;
+          }
+          // call the last hook...
+          vm._isDestroyed = true;
+          // invoke destroy hooks on current rendered tree
+          vm.__patch__(vm._vnode, null);
+          // fire destroyed hook
+          callHook(vm, 'destroyed');
+          // turn off all instance listeners.
+          vm.$off();
+          // remove __vue__ reference
+          if (vm.$el) {
+              vm.$el.__vue__ = null;
+          }
+          // release circular reference (#6759)
+          if (vm.$vnode) {
+              // @ts-expect-error null is not undefined
+              vm.$vnode.parent = null;
+          }
+      };
   }
-
-  function lifecycleMixin (Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-      var vm = this;
-      var prevEl = vm.$el;
-      var prevVnode = vm._vnode;
-      var restoreActiveInstance = setActiveInstance(vm);
-      vm._vnode = vnode;
-      // Vue.prototype.__patch__ is injected in entry points
-      // based on the rendering backend used.
-      if (!prevVnode) {
-        // initial render
-        vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-      } else {
-        // updates
-        vm.$el = vm.__patch__(prevVnode, vnode);
-      }
-      restoreActiveInstance();
-      // update __vue__ reference
-      if (prevEl) {
-        prevEl.__vue__ = null;
-      }
-      if (vm.$el) {
-        vm.$el.__vue__ = vm;
-      }
-      // if parent is an HOC, update its $el as well
-      if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-        vm.$parent.$el = vm.$el;
-      }
-      // updated hook is called by the scheduler to ensure that children are
-      // updated in a parent's updated hook.
-    };
-
-    Vue.prototype.$forceUpdate = function () {
-      var vm = this;
-      if (vm._watcher) {
-        vm._watcher.update();
+  function mountComponent(vm, el, hydrating) {
+      vm.$el = el;
+      if (!vm.$options.render) {
+          // @ts-expect-error invalid type
+          vm.$options.render = createEmptyVNode;
+          {
+              /* istanbul ignore if */
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                  vm.$options.el ||
+                  el) {
+                  warn('You are using the runtime-only build of Vue where the template ' +
+                      'compiler is not available. Either pre-compile the templates into ' +
+                      'render functions, or use the compiler-included build.', vm);
+              }
+              else {
+                  warn('Failed to mount component: template or render function not defined.', vm);
+              }
+          }
       }
-    };
-
-    Vue.prototype.$destroy = function () {
-      var vm = this;
-      if (vm._isBeingDestroyed) {
-        return
-      }
-      callHook(vm, 'beforeDestroy');
-      vm._isBeingDestroyed = true;
-      // remove self from parent
-      var parent = vm.$parent;
-      if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-        remove(parent.$children, vm);
-      }
-      // teardown watchers
-      if (vm._watcher) {
-        vm._watcher.teardown();
-      }
-      var i = vm._watchers.length;
-      while (i--) {
-        vm._watchers[i].teardown();
-      }
-      // remove reference from data ob
-      // frozen object may not have observer.
-      if (vm._data.__ob__) {
-        vm._data.__ob__.vmCount--;
-      }
-      // call the last hook...
-      vm._isDestroyed = true;
-      // invoke destroy hooks on current rendered tree
-      vm.__patch__(vm._vnode, null);
-      // fire destroyed hook
-      callHook(vm, 'destroyed');
-      // turn off all instance listeners.
-      vm.$off();
-      // remove __vue__ reference
-      if (vm.$el) {
-        vm.$el.__vue__ = null;
-      }
-      // release circular reference (#6759)
-      if (vm.$vnode) {
-        vm.$vnode.parent = null;
-      }
-    };
-  }
-
-  function mountComponent (
-    vm,
-    el,
-    hydrating
-  ) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-      vm.$options.render = createEmptyVNode;
+      callHook(vm, 'beforeMount');
+      var updateComponent;
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+          updateComponent = function () {
+              var name = vm._name;
+              var id = vm._uid;
+              var startTag = "vue-perf-start:" + id;
+              var endTag = "vue-perf-end:" + id;
+              mark(startTag);
+              var vnode = vm._render();
+              mark(endTag);
+              measure(("vue " + name + " render"), startTag, endTag);
+              mark(startTag);
+              vm._update(vnode, hydrating);
+              mark(endTag);
+              measure(("vue " + name + " patch"), startTag, endTag);
+          };
+      }
+      else {
+          updateComponent = function () {
+              vm._update(vm._render(), hydrating);
+          };
+      }
+      // we set this to vm._watcher inside the watcher's constructor
+      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+      // component's mounted hook), which relies on vm._watcher being already defined
+      new Watcher(vm, updateComponent, noop, {
+          before: function before() {
+              if (vm._isMounted && !vm._isDestroyed) {
+                  callHook(vm, 'beforeUpdate');
+              }
+          },
+      }, true /* isRenderWatcher */);
+      hydrating = false;
+      // manually mounted instance, call mounted on self
+      // mounted is called for render-created child components in its inserted hook
+      if (vm.$vnode == null) {
+          vm._isMounted = true;
+          callHook(vm, 'mounted');
+      }
+      return vm;
+  }
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
       {
-        /* istanbul ignore if */
-        if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-          vm.$options.el || el) {
-          warn(
-            'You are using the runtime-only build of Vue where the template ' +
-            'compiler is not available. Either pre-compile the templates into ' +
-            'render functions, or use the compiler-included build.',
-            vm
-          );
-        } else {
-          warn(
-            'Failed to mount component: template or render function not defined.',
-            vm
-          );
-        }
+          isUpdatingChildComponent = true;
+      }
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      var newScopedSlots = parentVnode.data.scopedSlots;
+      var oldScopedSlots = vm.$scopedSlots;
+      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      var needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      // @ts-ignore
+      vm.$options._parentVnode = parentVnode;
+      // @ts-ignore
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          // @ts-ignore
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      // @ts-ignore
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          var props = vm._props;
+          var propKeys = vm.$options._propKeys || [];
+          for (var i = 0; i < propKeys.length; i++) {
+              var key = propKeys[i];
+              var propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      var oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
       }
-    }
-    callHook(vm, 'beforeMount');
-
-    var updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      updateComponent = function () {
-        var name = vm._name;
-        var id = vm._uid;
-        var startTag = "vue-perf-start:" + id;
-        var endTag = "vue-perf-end:" + id;
-
-        mark(startTag);
-        var vnode = vm._render();
-        mark(endTag);
-        measure(("vue " + name + " render"), startTag, endTag);
-
-        mark(startTag);
-        vm._update(vnode, hydrating);
-        mark(endTag);
-        measure(("vue " + name + " patch"), startTag, endTag);
-      };
-    } else {
-      updateComponent = function () {
-        vm._update(vm._render(), hydrating);
-      };
-    }
-
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-      before: function before () {
-        if (vm._isMounted && !vm._isDestroyed) {
-          callHook(vm, 'beforeUpdate');
-        }
-      }
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-      vm._isMounted = true;
-      callHook(vm, 'mounted');
-    }
-    return vm
-  }
-
-  function updateChildComponent (
-    vm,
-    propsData,
-    listeners,
-    parentVnode,
-    renderChildren
-  ) {
-    {
-      isUpdatingChildComponent = true;
-    }
-
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!(
-      (newScopedSlots && !newScopedSlots.$stable) ||
-      (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-      (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-    );
-
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(
-      renderChildren ||               // has new static slots
-      vm.$options._renderChildren ||  // has old static slots
-      hasDynamicScopedSlot
-    );
-
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-    if (vm._vnode) { // update child tree's parent
-      vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-
-    // update props
-    if (propsData && vm.$options.props) {
-      toggleObserving(false);
-      var props = vm._props;
-      var propKeys = vm.$options._propKeys || [];
-      for (var i = 0; i < propKeys.length; i++) {
-        var key = propKeys[i];
-        var propOptions = vm.$options.props; // wtf flow?
-        props[key] = validateProp(key, propOptions, propsData, vm);
+      {
+          isUpdatingChildComponent = false;
       }
-      toggleObserving(true);
-      // keep a copy of raw propsData
-      vm.$options.propsData = propsData;
-    }
-
-    // update listeners
-    listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-      vm.$forceUpdate();
-    }
-
-    {
-      isUpdatingChildComponent = false;
-    }
   }
-
-  function isInInactiveTree (vm) {
-    while (vm && (vm = vm.$parent)) {
-      if (vm._inactive) { return true }
-    }
-    return false
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              { return true; }
+      }
+      return false;
   }
-
-  function activateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = false;
-      if (isInInactiveTree(vm)) {
-        return
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
       }
-    } else if (vm._directInactive) {
-      return
-    }
-    if (vm._inactive || vm._inactive === null) {
-      vm._inactive = false;
-      for (var i = 0; i < vm.$children.length; i++) {
-        activateChildComponent(vm.$children[i]);
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (var i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, 'activated');
       }
-      callHook(vm, 'activated');
-    }
   }
-
-  function deactivateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = true;
-      if (isInInactiveTree(vm)) {
-        return
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
       }
-    }
-    if (!vm._inactive) {
-      vm._inactive = true;
-      for (var i = 0; i < vm.$children.length; i++) {
-        deactivateChildComponent(vm.$children[i]);
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (var i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, 'deactivated');
       }
-      callHook(vm, 'deactivated');
-    }
   }
-
-  function callHook (vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
-    if (handlers) {
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-      }
-    }
-    if (vm._hasHookEvent) {
-      vm.$emit('hook:' + hook);
-    }
-    popTarget();
+  function callHook(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      var handlers = vm.$options[hook];
+      var info = hook + " hook";
+      if (handlers) {
+          for (var i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit('hook:' + hook);
+      }
+      popTarget();
   }
 
-  /*  */
-
+  /* @flow */
   var MAX_UPDATE_COUNT = 100;
-
   var queue = [];
   var activatedChildren = [];
   var has = {};
@@ -4228,29 +3708,25 @@
   var waiting = false;
   var flushing = false;
   var index = 0;
-
   /**
    * Reset the scheduler's state.
    */
-  function resetSchedulerState () {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-      circular = {};
-    }
-    waiting = flushing = false;
+  function resetSchedulerState() {
+      index = queue.length = activatedChildren.length = 0;
+      has = {};
+      {
+          circular = {};
+      }
+      waiting = flushing = false;
   }
-
   // Async edge case #6566 requires saving the timestamp when event listeners are
   // attached. However, calling performance.now() has a perf overhead especially
   // if the page has thousands of event listeners. Instead, we take a timestamp
   // every time the scheduler flushes and use that for all event listeners
   // attached during that flush.
   var currentFlushTimestamp = 0;
-
   // Async edge case fix requires storing an event listener's attach timestamp.
   var getNow = Date.now;
-
   // Determine what event timestamp the browser is using. Annoyingly, the
   // timestamp can either be hi-res (relative to page load) or low-res
   // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -4258,1467 +3734,1277 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (
-      performance &&
-      typeof performance.now === 'function' &&
-      getNow() > document.createEvent('Event').timeStamp
-    ) {
-      // if the event timestamp, although evaluated AFTER the Date.now(), is
-      // smaller than it, it means the event is using a hi-res timestamp,
-      // and we need to use the hi-res version for event listener timestamps as
-      // well.
-      getNow = function () { return performance.now(); };
-    }
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = function () { return performance.now(); };
+      }
   }
-
   /**
    * Flush both queues and run the watchers.
    */
-  function flushSchedulerQueue () {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    var watcher, id;
-
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
-
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-      watcher = queue[index];
-      if (watcher.before) {
-        watcher.before();
-      }
-      id = watcher.id;
-      has[id] = null;
-      watcher.run();
-      // in dev build, check and stop circular updates.
-      if (has[id] != null) {
-        circular[id] = (circular[id] || 0) + 1;
-        if (circular[id] > MAX_UPDATE_COUNT) {
-          warn(
-            'You may have an infinite update loop ' + (
-              watcher.user
-                ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                : "in a component render function."
-            ),
-            watcher.vm
-          );
-          break
-        }
+  function flushSchedulerQueue() {
+      currentFlushTimestamp = getNow();
+      flushing = true;
+      var watcher, id;
+      // Sort queue before flush.
+      // This ensures that:
+      // 1. Components are updated from parent to child. (because parent is always
+      //    created before the child)
+      // 2. A component's user watchers are run before its render watcher (because
+      //    user watchers are created before the render watcher)
+      // 3. If a component is destroyed during a parent component's watcher run,
+      //    its watchers can be skipped.
+      queue.sort(function (a, b) { return a.id - b.id; });
+      // do not cache length because more watchers might be pushed
+      // as we run existing watchers
+      for (index = 0; index < queue.length; index++) {
+          watcher = queue[index];
+          if (watcher.before) {
+              watcher.before();
+          }
+          id = watcher.id;
+          has[id] = null;
+          watcher.run();
+          // in dev build, check and stop circular updates.
+          if (has[id] != null) {
+              circular[id] = (circular[id] || 0) + 1;
+              if (circular[id] > MAX_UPDATE_COUNT) {
+                  warn('You may have an infinite update loop ' +
+                      (watcher.user
+                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                          : "in a component render function."), watcher.vm);
+                  break;
+              }
+          }
+      }
+      // keep copies of post queues before resetting state
+      var activatedQueue = activatedChildren.slice();
+      var updatedQueue = queue.slice();
+      resetSchedulerState();
+      // call component updated and activated hooks
+      callActivatedHooks(activatedQueue);
+      callUpdatedHooks(updatedQueue);
+      // devtool hook
+      /* istanbul ignore if */
+      if (devtools && config.devtools) {
+          devtools.emit('flush');
       }
-    }
-
-    // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
-
-    resetSchedulerState();
-
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-      devtools.emit('flush');
-    }
   }
-
-  function callUpdatedHooks (queue) {
-    var i = queue.length;
-    while (i--) {
-      var watcher = queue[i];
-      var vm = watcher.vm;
-      if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'updated');
+  function callUpdatedHooks(queue) {
+      var i = queue.length;
+      while (i--) {
+          var watcher = queue[i];
+          var vm = watcher.vm;
+          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+              callHook(vm, 'updated');
+          }
       }
-    }
   }
-
   /**
    * Queue a kept-alive component that was activated during patch.
    * The queue will be processed after the entire tree has been patched.
    */
-  function queueActivatedComponent (vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+      activatedChildren.push(vm);
   }
-
-  function callActivatedHooks (queue) {
-    for (var i = 0; i < queue.length; i++) {
-      queue[i]._inactive = true;
-      activateChildComponent(queue[i], true /* true */);
-    }
+  function callActivatedHooks(queue) {
+      for (var i = 0; i < queue.length; i++) {
+          queue[i]._inactive = true;
+          activateChildComponent(queue[i], true /* true */);
+      }
   }
-
   /**
    * Push a watcher into the watcher queue.
    * Jobs with duplicate IDs will be skipped unless it's
    * pushed when the queue is being flushed.
    */
-  function queueWatcher (watcher) {
-    var id = watcher.id;
-    if (has[id] == null) {
-      has[id] = true;
-      if (!flushing) {
-        queue.push(watcher);
-      } else {
-        // if already flushing, splice the watcher based on its id
-        // if already past its id, it will be run next immediately.
-        var i = queue.length - 1;
-        while (i > index && queue[i].id > watcher.id) {
-          i--;
-        }
-        queue.splice(i + 1, 0, watcher);
-      }
-      // queue the flush
-      if (!waiting) {
-        waiting = true;
-
-        if (!config.async) {
-          flushSchedulerQueue();
-          return
-        }
-        nextTick(flushSchedulerQueue);
+  function queueWatcher(watcher) {
+      var id = watcher.id;
+      if (has[id] == null) {
+          has[id] = true;
+          if (!flushing) {
+              queue.push(watcher);
+          }
+          else {
+              // if already flushing, splice the watcher based on its id
+              // if already past its id, it will be run next immediately.
+              var i = queue.length - 1;
+              while (i > index && queue[i].id > watcher.id) {
+                  i--;
+              }
+              queue.splice(i + 1, 0, watcher);
+          }
+          // queue the flush
+          if (!waiting) {
+              waiting = true;
+              if (!config.async) {
+                  flushSchedulerQueue();
+                  return;
+              }
+              nextTick(flushSchedulerQueue);
+          }
       }
-    }
   }
 
-  /*  */
-
-
-
+  /* @flow */
   var uid$2 = 0;
-
   /**
    * A watcher parses an expression, collects dependencies,
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = function Watcher (
-    vm,
-    expOrFn,
-    cb,
-    options,
-    isRenderWatcher
-  ) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-      vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-      this.deep = !!options.deep;
-      this.user = !!options.user;
-      this.lazy = !!options.lazy;
-      this.sync = !!options.sync;
-      this.before = options.before;
-    } else {
-      this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression = expOrFn.toString();
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-      this.getter = expOrFn;
-    } else {
-      this.getter = parsePath(expOrFn);
-      if (!this.getter) {
-        this.getter = noop;
-        warn(
-          "Failed watching path: \"" + expOrFn + "\" " +
-          'Watcher only accepts simple dot-delimited paths. ' +
-          'For full control, use a function instead.',
-          vm
-        );
-      }
-    }
-    this.value = this.lazy
-      ? undefined
-      : this.get();
+  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+      this.vm = vm;
+      if (isRenderWatcher) {
+          vm._watcher = this;
+      }
+      vm._watchers.push(this);
+      // options
+      if (options) {
+          this.deep = !!options.deep;
+          this.user = !!options.user;
+          this.lazy = !!options.lazy;
+          this.sync = !!options.sync;
+          this.before = options.before;
+      }
+      else {
+          this.deep = this.user = this.lazy = this.sync = false;
+      }
+      this.cb = cb;
+      this.id = ++uid$2; // uid for batching
+      this.active = true;
+      this.dirty = this.lazy; // for lazy watchers
+      this.deps = [];
+      this.newDeps = [];
+      this.depIds = new _Set();
+      this.newDepIds = new _Set();
+      this.expression =
+          expOrFn.toString();
+      // parse expression for getter
+      if (typeof expOrFn === 'function') {
+          this.getter = expOrFn;
+      }
+      else {
+          this.getter = parsePath(expOrFn);
+          if (!this.getter) {
+              this.getter = noop;
+              warn("Failed watching path: \"" + expOrFn + "\" " +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
+          }
+      }
+      this.value = this.lazy ? undefined : this.get();
   };
-
   /**
    * Evaluate the getter, and re-collect dependencies.
    */
   Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-      value = this.getter.call(vm, vm);
-    } catch (e) {
-      if (this.user) {
-        handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-      } else {
-        throw e
-      }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value);
+      pushTarget(this);
+      var value;
+      var vm = this.vm;
+      try {
+          value = this.getter.call(vm, vm);
       }
-      popTarget();
-      this.cleanupDeps();
-    }
-    return value
+      catch (e) {
+          if (this.user) {
+              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+          }
+          else {
+              throw e;
+          }
+      }
+      finally {
+          // "touch" every property so they are all tracked as
+          // dependencies for deep watching
+          if (this.deep) {
+              traverse(value);
+          }
+          popTarget();
+          this.cleanupDeps();
+      }
+      return value;
   };
-
   /**
    * Add a dependency to this directive.
    */
   Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id);
-      this.newDeps.push(dep);
-      if (!this.depIds.has(id)) {
-        dep.addSub(this);
-      }
-    }
+      var id = dep.id;
+      if (!this.newDepIds.has(id)) {
+          this.newDepIds.add(id);
+          this.newDeps.push(dep);
+          if (!this.depIds.has(id)) {
+              dep.addSub(this);
+          }
+      }
   };
-
   /**
    * Clean up for dependency collection.
    */
   Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-      var dep = this.deps[i];
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this);
-      }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
+      var i = this.deps.length;
+      while (i--) {
+          var dep = this.deps[i];
+          if (!this.newDepIds.has(dep.id)) {
+              dep.removeSub(this);
+          }
+      }
+      var tmp = this.depIds;
+      this.depIds = this.newDepIds;
+      this.newDepIds = tmp;
+      this.newDepIds.clear();
+      tmp = this.deps;
+      this.deps = this.newDeps;
+      this.newDeps = tmp;
+      this.newDeps.length = 0;
   };
-
   /**
    * Subscriber interface.
    * Will be called when a dependency changes.
    */
   Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-      this.dirty = true;
-    } else if (this.sync) {
-      this.run();
-    } else {
-      queueWatcher(this);
-    }
+      /* istanbul ignore else */
+      if (this.lazy) {
+          this.dirty = true;
+      }
+      else if (this.sync) {
+          this.run();
+      }
+      else {
+          queueWatcher(this);
+      }
   };
-
   /**
    * Scheduler job interface.
    * Will be called by the scheduler.
    */
   Watcher.prototype.run = function run () {
-    if (this.active) {
-      var value = this.get();
-      if (
-        value !== this.value ||
-        // Deep watchers and watchers on Object/Arrays should fire even
-        // when the value is the same, because the value may
-        // have mutated.
-        isObject(value) ||
-        this.deep
-      ) {
-        // set new value
-        var oldValue = this.value;
-        this.value = value;
-        if (this.user) {
-          try {
-            this.cb.call(this.vm, value, oldValue);
-          } catch (e) {
-            handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+      if (this.active) {
+          var value = this.get();
+          if (value !== this.value ||
+              // Deep watchers and watchers on Object/Arrays should fire even
+              // when the value is the same, because the value may
+              // have mutated.
+              isObject(value) ||
+              this.deep) {
+              // set new value
+              var oldValue = this.value;
+              this.value = value;
+              if (this.user) {
+                  try {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+                  catch (e) {
+                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  }
+              }
+              else {
+                  this.cb.call(this.vm, value, oldValue);
+              }
           }
-        } else {
-          this.cb.call(this.vm, value, oldValue);
-        }
       }
-    }
   };
-
   /**
    * Evaluate the value of the watcher.
    * This only gets called for lazy watchers.
    */
   Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
+      this.value = this.get();
+      this.dirty = false;
   };
-
   /**
    * Depend on all deps collected by this watcher.
    */
   Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].depend();
-    }
+      var i = this.deps.length;
+      while (i--) {
+          this.deps[i].depend();
+      }
   };
-
   /**
    * Remove self from all dependencies' subscriber list.
    */
   Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed.
-      if (!this.vm._isBeingDestroyed) {
-        remove(this.vm._watchers, this);
-      }
-      var i = this.deps.length;
-      while (i--) {
-        this.deps[i].removeSub(this);
+      if (this.active) {
+          // remove self from vm's watcher list
+          // this is a somewhat expensive operation so we skip it
+          // if the vm is being destroyed.
+          if (!this.vm._isBeingDestroyed) {
+              remove(this.vm._watchers, this);
+          }
+          var i = this.deps.length;
+          while (i--) {
+              this.deps[i].removeSub(this);
+          }
+          this.active = false;
       }
-      this.active = false;
-    }
   };
 
-  /*  */
-
+  /* @flow */
   var sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop
+      enumerable: true,
+      configurable: true,
+      get: noop,
+      set: noop,
   };
+  function proxy(target, sourceKey, key) {
+      sharedPropertyDefinition.get = function proxyGetter() {
+          return this[sourceKey][key];
+      };
+      sharedPropertyDefinition.set = function proxySetter(val) {
+          this[sourceKey][key] = val;
+      };
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function initState(vm) {
+      vm._watchers = [];
+      var opts = vm.$options;
+      if (opts.props)
+          { initProps(vm, opts.props); }
+      if (opts.methods)
+          { initMethods(vm, opts.methods); }
+      if (opts.data) {
+          initData(vm);
+      }
+      else {
+          observe((vm._data = {}), true /* asRootData */);
+      }
+      if (opts.computed)
+          { initComputed(vm, opts.computed); }
+      if (opts.watch && opts.watch !== nativeWatch) {
+          initWatch(vm, opts.watch);
+      }
+  }
+  function initProps(vm, propsOptions) {
+      var propsData = vm.$options.propsData || {};
+      var props = (vm._props = {});
+      // cache prop keys so that future props updates can iterate using Array
+      // instead of dynamic object key enumeration.
+      var keys = (vm.$options._propKeys = []);
+      var isRoot = !vm.$parent;
+      // root instance props should be converted
+      if (!isRoot) {
+          toggleObserving(false);
+      }
+      var loop = function ( key ) {
+          keys.push(key);
+          var value = validateProp(key, propsOptions, propsData, vm);
+          /* istanbul ignore else */
+          {
+              var hyphenatedKey = hyphenate(key);
+              if (isReservedAttribute(hyphenatedKey) ||
+                  config.isReservedAttr(hyphenatedKey)) {
+                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+              }
+              defineReactive$$1(props, key, value, function () {
+                  if (!isRoot && !isUpdatingChildComponent) {
+                      warn("Avoid mutating a prop directly since the value will be " +
+                          "overwritten whenever the parent component re-renders. " +
+                          "Instead, use a data or computed property based on the prop's " +
+                          "value. Prop being mutated: \"" + key + "\"", vm);
+                  }
+              });
+          }
+          // static props are already proxied on the component's prototype
+          // during Vue.extend(). We only need to proxy props defined at
+          // instantiation here.
+          if (!(key in vm)) {
+              proxy(vm, "_props", key);
+          }
+      };
 
-  function proxy (target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter () {
-      return this[sourceKey][key]
-    };
-    sharedPropertyDefinition.set = function proxySetter (val) {
-      this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-
-  function initState (vm) {
-    vm._watchers = [];
-    var opts = vm.$options;
-    if (opts.props) { initProps(vm, opts.props); }
-    if (opts.methods) { initMethods(vm, opts.methods); }
-    if (opts.data) {
-      initData(vm);
-    } else {
-      observe(vm._data = {}, true /* asRootData */);
-    }
-    if (opts.computed) { initComputed(vm, opts.computed); }
-    if (opts.watch && opts.watch !== nativeWatch) {
-      initWatch(vm, opts.watch);
-    }
+      for (var key in propsOptions) loop( key );
+      toggleObserving(true);
   }
-
-  function initProps (vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = vm._props = {};
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    var keys = vm.$options._propKeys = [];
-    var isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-      toggleObserving(false);
-    }
-    var loop = function ( key ) {
-      keys.push(key);
-      var value = validateProp(key, propsOptions, propsData, vm);
-      /* istanbul ignore else */
-      {
-        var hyphenatedKey = hyphenate(key);
-        if (isReservedAttribute(hyphenatedKey) ||
-            config.isReservedAttr(hyphenatedKey)) {
-          warn(
-            ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-            vm
-          );
-        }
-        defineReactive$$1(props, key, value, function () {
-          if (!isRoot && !isUpdatingChildComponent) {
-            warn(
-              "Avoid mutating a prop directly since the value will be " +
-              "overwritten whenever the parent component re-renders. " +
-              "Instead, use a data or computed property based on the prop's " +
-              "value. Prop being mutated: \"" + key + "\"",
-              vm
-            );
-          }
-        });
-      }
-      // static props are already proxied on the component's prototype
-      // during Vue.extend(). We only need to proxy props defined at
-      // instantiation here.
-      if (!(key in vm)) {
-        proxy(vm, "_props", key);
-      }
-    };
-
-    for (var key in propsOptions) loop( key );
-    toggleObserving(true);
+  function initData(vm) {
+      var data = vm.$options.data;
+      data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+      if (!isPlainObject(data)) {
+          data = {};
+          warn('data functions should return an object:\n' +
+                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+      }
+      // proxy data on instance
+      var keys = Object.keys(data);
+      var props = vm.$options.props;
+      var methods = vm.$options.methods;
+      var i = keys.length;
+      while (i--) {
+          var key = keys[i];
+          {
+              if (methods && hasOwn(methods, key)) {
+                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+              }
+          }
+          if (props && hasOwn(props, key)) {
+              warn("The data property \"" + key + "\" is already declared as a prop. " +
+                      "Use prop default value instead.", vm);
+          }
+          else if (!isReserved(key)) {
+              proxy(vm, "_data", key);
+          }
+      }
+      // observe data
+      observe(data, true /* asRootData */);
   }
-
-  function initData (vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function'
-      ? getData(data, vm)
-      : data || {};
-    if (!isPlainObject(data)) {
-      data = {};
-      warn(
-        'data functions should return an object:\n' +
-        'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-        vm
-      );
-    }
-    // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
-    while (i--) {
-      var key = keys[i];
-      {
-        if (methods && hasOwn(methods, key)) {
-          warn(
-            ("Method \"" + key + "\" has already been defined as a data property."),
-            vm
-          );
-        }
+  function getData(data, vm) {
+      // #7573 disable dep collection when invoking data getters
+      pushTarget();
+      try {
+          return data.call(vm, vm);
       }
-      if (props && hasOwn(props, key)) {
-        warn(
-          "The data property \"" + key + "\" is already declared as a prop. " +
-          "Use prop default value instead.",
-          vm
-        );
-      } else if (!isReserved(key)) {
-        proxy(vm, "_data", key);
+      catch (e) {
+          handleError(e, vm, "data()");
+          return {};
+      }
+      finally {
+          popTarget();
       }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-  }
-
-  function getData (data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-      return data.call(vm, vm)
-    } catch (e) {
-      handleError(e, vm, "data()");
-      return {}
-    } finally {
-      popTarget();
-    }
   }
-
   var computedWatcherOptions = { lazy: true };
-
-  function initComputed (vm, computed) {
-    // $flow-disable-line
-    var watchers = vm._computedWatchers = Object.create(null);
-    // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-
-    for (var key in computed) {
-      var userDef = computed[key];
-      var getter = typeof userDef === 'function' ? userDef : userDef.get;
-      if (getter == null) {
-        warn(
-          ("Getter is missing for computed property \"" + key + "\"."),
-          vm
-        );
-      }
-
-      if (!isSSR) {
-        // create internal watcher for the computed property.
-        watchers[key] = new Watcher(
-          vm,
-          getter || noop,
-          noop,
-          computedWatcherOptions
-        );
+  function initComputed(vm, computed) {
+      // $flow-disable-line
+      var watchers = (vm._computedWatchers = Object.create(null));
+      // computed properties are just getters during SSR
+      var isSSR = isServerRendering();
+      for (var key in computed) {
+          var userDef = computed[key];
+          var getter = typeof userDef === 'function' ? userDef : userDef.get;
+          if (getter == null) {
+              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+          }
+          if (!isSSR) {
+              // create internal watcher for the computed property.
+              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+          }
+          // component-defined computed properties are already defined on the
+          // component prototype. We only need to define computed properties defined
+          // at instantiation here.
+          if (!(key in vm)) {
+              defineComputed(vm, key, userDef);
+          }
+          else {
+              if (key in vm.$data) {
+                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+              }
+              else if (vm.$options.props && key in vm.$options.props) {
+                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+              }
+          }
       }
-
-      // component-defined computed properties are already defined on the
-      // component prototype. We only need to define computed properties defined
-      // at instantiation here.
-      if (!(key in vm)) {
-        defineComputed(vm, key, userDef);
-      } else {
-        if (key in vm.$data) {
-          warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-        } else if (vm.$options.props && key in vm.$options.props) {
-          warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-        }
-      }
-    }
   }
-
-  function defineComputed (
-    target,
-    key,
-    userDef
-  ) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
-      sharedPropertyDefinition.get = shouldCache
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef);
-      sharedPropertyDefinition.set = noop;
-    } else {
-      sharedPropertyDefinition.get = userDef.get
-        ? shouldCache && userDef.cache !== false
-          ? createComputedGetter(key)
-          : createGetterInvoker(userDef.get)
-        : noop;
-      sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-      sharedPropertyDefinition.set = function () {
-        warn(
-          ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-          this
-        );
+  function defineComputed(target, key, userDef) {
+      var shouldCache = !isServerRendering();
+      if (typeof userDef === 'function') {
+          sharedPropertyDefinition.get = shouldCache
+              ? createComputedGetter(key)
+              : createGetterInvoker(userDef);
+          sharedPropertyDefinition.set = noop;
+      }
+      else {
+          sharedPropertyDefinition.get = userDef.get
+              ? shouldCache && userDef.cache !== false
+                  ? createComputedGetter(key)
+                  : createGetterInvoker(userDef.get)
+              : noop;
+          sharedPropertyDefinition.set = userDef.set || noop;
+      }
+      if (sharedPropertyDefinition.set === noop) {
+          sharedPropertyDefinition.set = function () {
+              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+          };
+      }
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function createComputedGetter(key) {
+      return function computedGetter() {
+          var watcher = this._computedWatchers && this._computedWatchers[key];
+          if (watcher) {
+              if (watcher.dirty) {
+                  watcher.evaluate();
+              }
+              if (Dep.target) {
+                  watcher.depend();
+              }
+              return watcher.value;
+          }
       };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-
-  function createComputedGetter (key) {
-    return function computedGetter () {
-      var watcher = this._computedWatchers && this._computedWatchers[key];
-      if (watcher) {
-        if (watcher.dirty) {
-          watcher.evaluate();
-        }
-        if (Dep.target) {
-          watcher.depend();
-        }
-        return watcher.value
-      }
-    }
   }
-
   function createGetterInvoker(fn) {
-    return function computedGetter () {
-      return fn.call(this, this)
-    }
+      return function computedGetter() {
+          return fn.call(this, this);
+      };
   }
-
-  function initMethods (vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
-      {
-        if (typeof methods[key] !== 'function') {
-          warn(
-            "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-            "Did you reference the function correctly?",
-            vm
-          );
-        }
-        if (props && hasOwn(props, key)) {
-          warn(
-            ("Method \"" + key + "\" has already been defined as a prop."),
-            vm
-          );
-        }
-        if ((key in vm) && isReserved(key)) {
-          warn(
-            "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-            "Avoid defining component methods that start with _ or $."
-          );
-        }
+  function initMethods(vm, methods) {
+      var props = vm.$options.props;
+      for (var key in methods) {
+          {
+              if (typeof methods[key] !== 'function') {
+                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                      "Did you reference the function correctly?", vm);
+              }
+              if (props && hasOwn(props, key)) {
+                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+              }
+              if (key in vm && isReserved(key)) {
+                  warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                      "Avoid defining component methods that start with _ or $.");
+              }
+          }
+          vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
       }
-      vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-    }
   }
-
-  function initWatch (vm, watch) {
-    for (var key in watch) {
-      var handler = watch[key];
-      if (Array.isArray(handler)) {
-        for (var i = 0; i < handler.length; i++) {
-          createWatcher(vm, key, handler[i]);
-        }
-      } else {
-        createWatcher(vm, key, handler);
-      }
-    }
+  function initWatch(vm, watch) {
+      for (var key in watch) {
+          var handler = watch[key];
+          if (Array.isArray(handler)) {
+              for (var i = 0; i < handler.length; i++) {
+                  createWatcher(vm, key, handler[i]);
+              }
+          }
+          else {
+              createWatcher(vm, key, handler);
+          }
+      }
   }
-
-  function createWatcher (
-    vm,
-    expOrFn,
-    handler,
-    options
-  ) {
-    if (isPlainObject(handler)) {
-      options = handler;
-      handler = handler.handler;
-    }
-    if (typeof handler === 'string') {
-      handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options)
+  function createWatcher(vm, expOrFn, handler, options) {
+      if (isPlainObject(handler)) {
+          options = handler;
+          handler = handler.handler;
+      }
+      if (typeof handler === 'string') {
+          handler = vm[handler];
+      }
+      return vm.$watch(expOrFn, handler, options);
   }
-
-  function stateMixin (Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    var dataDef = {};
-    dataDef.get = function () { return this._data };
-    var propsDef = {};
-    propsDef.get = function () { return this._props };
-    {
-      dataDef.set = function () {
-        warn(
-          'Avoid replacing instance root $data. ' +
-          'Use nested data properties instead.',
-          this
-        );
+  function stateMixin(Vue) {
+      // flow somehow has problems with directly declared definition object
+      // when using Object.defineProperty, so we have to procedurally build up
+      // the object here.
+      var dataDef = {};
+      dataDef.get = function () {
+          return this._data;
       };
-      propsDef.set = function () {
-        warn("$props is readonly.", this);
+      var propsDef = {};
+      propsDef.get = function () {
+          return this._props;
+      };
+      {
+          dataDef.set = function () {
+              warn('Avoid replacing instance root $data. ' +
+                  'Use nested data properties instead.', this);
+          };
+          propsDef.set = function () {
+              warn("$props is readonly.", this);
+          };
+      }
+      Object.defineProperty(Vue.prototype, '$data', dataDef);
+      Object.defineProperty(Vue.prototype, '$props', propsDef);
+      Vue.prototype.$set = set;
+      Vue.prototype.$delete = del;
+      Vue.prototype.$watch = function (expOrFn, cb, options) {
+          var vm = this;
+          if (isPlainObject(cb)) {
+              return createWatcher(vm, expOrFn, cb, options);
+          }
+          options = options || {};
+          options.user = true;
+          var watcher = new Watcher(vm, expOrFn, cb, options);
+          if (options.immediate) {
+              pushTarget();
+              try {
+                  cb.call(vm, watcher.value);
+              }
+              catch (error) {
+                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+              }
+              popTarget();
+          }
+          return function unwatchFn() {
+              watcher.teardown();
+          };
       };
-    }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-
-    Vue.prototype.$watch = function (
-      expOrFn,
-      cb,
-      options
-    ) {
-      var vm = this;
-      if (isPlainObject(cb)) {
-        return createWatcher(vm, expOrFn, cb, options)
-      }
-      options = options || {};
-      options.user = true;
-      var watcher = new Watcher(vm, expOrFn, cb, options);
-      if (options.immediate) {
-        try {
-          cb.call(vm, watcher.value);
-        } catch (error) {
-          handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-        }
-      }
-      return function unwatchFn () {
-        watcher.teardown();
-      }
-    };
   }
 
-  /*  */
-
+  /* @flow */
   var uid$3 = 0;
-
-  function initMixin (Vue) {
-    Vue.prototype._init = function (options) {
-      var vm = this;
-      // a uid
-      vm._uid = uid$3++;
-
-      var startTag, endTag;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        startTag = "vue-perf-start:" + (vm._uid);
-        endTag = "vue-perf-end:" + (vm._uid);
-        mark(startTag);
-      }
-
-      // a flag to avoid this being observed
-      vm._isVue = true;
-      // merge options
-      if (options && options._isComponent) {
-        // optimize internal component instantiation
-        // since dynamic options merging is pretty slow, and none of the
-        // internal component options needs special treatment.
-        initInternalComponent(vm, options);
-      } else {
-        vm.$options = mergeOptions(
-          resolveConstructorOptions(vm.constructor),
-          options || {},
-          vm
-        );
-      }
-      /* istanbul ignore else */
-      {
-        initProxy(vm);
-      }
-      // expose real self
-      vm._self = vm;
-      initLifecycle(vm);
-      initEvents(vm);
-      initRender(vm);
-      callHook(vm, 'beforeCreate');
-      initInjections(vm); // resolve injections before data/props
-      initState(vm);
-      initProvide(vm); // resolve provide after data/props
-      callHook(vm, 'created');
-
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        vm._name = formatComponentName(vm, false);
-        mark(endTag);
-        measure(("vue " + (vm._name) + " init"), startTag, endTag);
+  function initMixin(Vue) {
+      Vue.prototype._init = function (options) {
+          var vm = this;
+          // a uid
+          vm._uid = uid$3++;
+          var startTag, endTag;
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              startTag = "vue-perf-start:" + (vm._uid);
+              endTag = "vue-perf-end:" + (vm._uid);
+              mark(startTag);
+          }
+          // a flag to avoid this being observed
+          vm._isVue = true;
+          // merge options
+          if (options && options._isComponent) {
+              // optimize internal component instantiation
+              // since dynamic options merging is pretty slow, and none of the
+              // internal component options needs special treatment.
+              initInternalComponent(vm, options);
+          }
+          else {
+              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+          }
+          /* istanbul ignore else */
+          {
+              initProxy(vm);
+          }
+          // expose real self
+          vm._self = vm;
+          initLifecycle(vm);
+          initEvents(vm);
+          initRender(vm);
+          callHook(vm, 'beforeCreate');
+          initInjections(vm); // resolve injections before data/props
+          initState(vm);
+          initProvide(vm); // resolve provide after data/props
+          callHook(vm, 'created');
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              vm._name = formatComponentName(vm, false);
+              mark(endTag);
+              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+          }
+          if (vm.$options.el) {
+              vm.$mount(vm.$options.el);
+          }
+      };
+  }
+  function initInternalComponent(vm, options) {
+      // @ts-ignore
+      var opts = (vm.$options = Object.create(vm.constructor.options));
+      // doing this because it's faster than dynamic enumeration.
+      var parentVnode = options._parentVnode;
+      opts.parent = options.parent;
+      opts._parentVnode = parentVnode;
+      var vnodeComponentOptions = parentVnode.componentOptions;
+      opts.propsData = vnodeComponentOptions.propsData;
+      opts._parentListeners = vnodeComponentOptions.listeners;
+      opts._renderChildren = vnodeComponentOptions.children;
+      opts._componentTag = vnodeComponentOptions.tag;
+      if (options.render) {
+          opts.render = options.render;
+          opts.staticRenderFns = options.staticRenderFns;
+      }
+  }
+  function resolveConstructorOptions(Ctor) {
+      var options = Ctor.options;
+      if (Ctor.super) {
+          var superOptions = resolveConstructorOptions(Ctor.super);
+          var cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              var modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
       }
-
-      if (vm.$options.el) {
-        vm.$mount(vm.$options.el);
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      var modified;
+      var latest = Ctor.options;
+      var sealed = Ctor.sealedOptions;
+      for (var key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  { modified = {}; }
+              modified[key] = latest[key];
+          }
       }
-    };
-  }
-
-  function initInternalComponent (vm, options) {
-    var opts = vm.$options = Object.create(vm.constructor.options);
-    // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-
-    var vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-
-    if (options.render) {
-      opts.render = options.render;
-      opts.staticRenderFns = options.staticRenderFns;
-    }
-  }
-
-  function resolveConstructorOptions (Ctor) {
-    var options = Ctor.options;
-    if (Ctor.super) {
-      var superOptions = resolveConstructorOptions(Ctor.super);
-      var cachedSuperOptions = Ctor.superOptions;
-      if (superOptions !== cachedSuperOptions) {
-        // super option changed,
-        // need to resolve new options.
-        Ctor.superOptions = superOptions;
-        // check if there are any late-modified/attached options (#4976)
-        var modifiedOptions = resolveModifiedOptions(Ctor);
-        // update base extend options
-        if (modifiedOptions) {
-          extend(Ctor.extendOptions, modifiedOptions);
-        }
-        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-        if (options.name) {
-          options.components[options.name] = Ctor;
-        }
-      }
-    }
-    return options
+      return modified;
   }
 
-  function resolveModifiedOptions (Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
-      if (latest[key] !== sealed[key]) {
-        if (!modified) { modified = {}; }
-        modified[key] = latest[key];
-      }
-    }
-    return modified
-  }
-
-  function Vue (options) {
-    if (!(this instanceof Vue)
-    ) {
-      warn('Vue is a constructor and should be called with the `new` keyword');
-    }
-    this._init(options);
+  function Vue(options) {
+      if (!(this instanceof Vue)) {
+          warn('Vue is a constructor and should be called with the `new` keyword');
+      }
+      this._init(options);
   }
-
+  //@ts-ignore
   initMixin(Vue);
+  //@ts-ignore
   stateMixin(Vue);
+  //@ts-ignore
   eventsMixin(Vue);
+  //@ts-ignore
   lifecycleMixin(Vue);
+  //@ts-ignore
   renderMixin(Vue);
 
-  /*  */
-
-  function initUse (Vue) {
-    Vue.use = function (plugin) {
-      var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-      if (installedPlugins.indexOf(plugin) > -1) {
-        return this
-      }
-
-      // additional parameters
-      var args = toArray(arguments, 1);
-      args.unshift(this);
-      if (typeof plugin.install === 'function') {
-        plugin.install.apply(plugin, args);
-      } else if (typeof plugin === 'function') {
-        plugin.apply(null, args);
-      }
-      installedPlugins.push(plugin);
-      return this
-    };
-  }
-
-  /*  */
-
-  function initMixin$1 (Vue) {
-    Vue.mixin = function (mixin) {
-      this.options = mergeOptions(this.options, mixin);
-      return this
-    };
-  }
-
-  /*  */
-
-  function initExtend (Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    var cid = 1;
-
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-      extendOptions = extendOptions || {};
-      var Super = this;
-      var SuperId = Super.cid;
-      var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-      if (cachedCtors[SuperId]) {
-        return cachedCtors[SuperId]
-      }
-
-      var name = extendOptions.name || Super.options.name;
-      if (name) {
-        validateComponentName(name);
-      }
-
-      var Sub = function VueComponent (options) {
-        this._init(options);
+  /* @flow */
+  function initUse(Vue) {
+      Vue.use = function (plugin) {
+          var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          if (installedPlugins.indexOf(plugin) > -1) {
+              return this;
+          }
+          // additional parameters
+          var args = toArray(arguments, 1);
+          args.unshift(this);
+          if (typeof plugin.install === 'function') {
+              plugin.install.apply(plugin, args);
+          }
+          else if (typeof plugin === 'function') {
+              plugin.apply(null, args);
+          }
+          installedPlugins.push(plugin);
+          return this;
       };
-      Sub.prototype = Object.create(Super.prototype);
-      Sub.prototype.constructor = Sub;
-      Sub.cid = cid++;
-      Sub.options = mergeOptions(
-        Super.options,
-        extendOptions
-      );
-      Sub['super'] = Super;
-
-      // For props and computed properties, we define the proxy getters on
-      // the Vue instances at extension time, on the extended prototype. This
-      // avoids Object.defineProperty calls for each instance created.
-      if (Sub.options.props) {
-        initProps$1(Sub);
-      }
-      if (Sub.options.computed) {
-        initComputed$1(Sub);
-      }
-
-      // allow further extension/mixin/plugin usage
-      Sub.extend = Super.extend;
-      Sub.mixin = Super.mixin;
-      Sub.use = Super.use;
-
-      // create asset registers, so extended classes
-      // can have their private assets too.
-      ASSET_TYPES.forEach(function (type) {
-        Sub[type] = Super[type];
-      });
-      // enable recursive self-lookup
-      if (name) {
-        Sub.options.components[name] = Sub;
-      }
-
-      // keep a reference to the super options at extension time.
-      // later at instantiation we can check if Super's options have
-      // been updated.
-      Sub.superOptions = Super.options;
-      Sub.extendOptions = extendOptions;
-      Sub.sealedOptions = extend({}, Sub.options);
-
-      // cache constructor
-      cachedCtors[SuperId] = Sub;
-      return Sub
-    };
-  }
-
-  function initProps$1 (Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-      proxy(Comp.prototype, "_props", key);
-    }
   }
 
-  function initComputed$1 (Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
-      defineComputed(Comp.prototype, key, computed[key]);
-    }
+  /* @flow */
+  function initMixin$1(Vue) {
+      Vue.mixin = function (mixin) {
+          this.options = mergeOptions(this.options, mixin);
+          return this;
+      };
   }
 
-  /*  */
-
-  function initAssetRegisters (Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach(function (type) {
-      Vue[type] = function (
-        id,
-        definition
-      ) {
-        if (!definition) {
-          return this.options[type + 's'][id]
-        } else {
-          /* istanbul ignore if */
-          if (type === 'component') {
-            validateComponentName(id);
+  /* @flow */
+  function initExtend(Vue) {
+      /**
+       * Each instance constructor, including Vue, has a unique
+       * cid. This enables us to create wrapped "child
+       * constructors" for prototypal inheritance and cache them.
+       */
+      Vue.cid = 0;
+      var cid = 1;
+      /**
+       * Class inheritance
+       */
+      Vue.extend = function (extendOptions) {
+          extendOptions = extendOptions || {};
+          var Super = this;
+          var SuperId = Super.cid;
+          var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          if (cachedCtors[SuperId]) {
+              return cachedCtors[SuperId];
+          }
+          var name = extendOptions.name || Super.options.name;
+          if (name) {
+              validateComponentName(name);
+          }
+          var Sub = function VueComponent(options) {
+              this._init(options);
+          };
+          Sub.prototype = Object.create(Super.prototype);
+          Sub.prototype.constructor = Sub;
+          Sub.cid = cid++;
+          Sub.options = mergeOptions(Super.options, extendOptions);
+          Sub['super'] = Super;
+          // For props and computed properties, we define the proxy getters on
+          // the Vue instances at extension time, on the extended prototype. This
+          // avoids Object.defineProperty calls for each instance created.
+          if (Sub.options.props) {
+              initProps$1(Sub);
           }
-          if (type === 'component' && isPlainObject(definition)) {
-            definition.name = definition.name || id;
-            definition = this.options._base.extend(definition);
+          if (Sub.options.computed) {
+              initComputed$1(Sub);
           }
-          if (type === 'directive' && typeof definition === 'function') {
-            definition = { bind: definition, update: definition };
+          // allow further extension/mixin/plugin usage
+          Sub.extend = Super.extend;
+          Sub.mixin = Super.mixin;
+          Sub.use = Super.use;
+          // create asset registers, so extended classes
+          // can have their private assets too.
+          ASSET_TYPES.forEach(function (type) {
+              Sub[type] = Super[type];
+          });
+          // enable recursive self-lookup
+          if (name) {
+              Sub.options.components[name] = Sub;
           }
-          this.options[type + 's'][id] = definition;
-          return definition
-        }
+          // keep a reference to the super options at extension time.
+          // later at instantiation we can check if Super's options have
+          // been updated.
+          Sub.superOptions = Super.options;
+          Sub.extendOptions = extendOptions;
+          Sub.sealedOptions = extend({}, Sub.options);
+          // cache constructor
+          cachedCtors[SuperId] = Sub;
+          return Sub;
       };
-    });
   }
-
-  /*  */
-
-
-
-  function getComponentName (opts) {
-    return opts && (opts.Ctor.options.name || opts.tag)
+  function initProps$1(Comp) {
+      var props = Comp.options.props;
+      for (var key in props) {
+          proxy(Comp.prototype, "_props", key);
+      }
   }
-
-  function matches (pattern, name) {
-    if (Array.isArray(pattern)) {
-      return pattern.indexOf(name) > -1
-    } else if (typeof pattern === 'string') {
-      return pattern.split(',').indexOf(name) > -1
-    } else if (isRegExp(pattern)) {
-      return pattern.test(name)
-    }
-    /* istanbul ignore next */
-    return false
+  function initComputed$1(Comp) {
+      var computed = Comp.options.computed;
+      for (var key in computed) {
+          defineComputed(Comp.prototype, key, computed[key]);
+      }
   }
 
-  function pruneCache (keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-      var cachedNode = cache[key];
-      if (cachedNode) {
-        var name = getComponentName(cachedNode.componentOptions);
-        if (name && !filter(name)) {
-          pruneCacheEntry(cache, key, keys, _vnode);
-        }
-      }
-    }
+  /* @flow */
+  function initAssetRegisters(Vue) {
+      /**
+       * Create asset registration methods.
+       */
+      ASSET_TYPES.forEach(function (type) {
+          // @ts-expect-error function is not exact same type
+          Vue[type] = function (id, definition) {
+              if (!definition) {
+                  return this.options[type + 's'][id];
+              }
+              else {
+                  /* istanbul ignore if */
+                  if (type === 'component') {
+                      validateComponentName(id);
+                  }
+                  if (type === 'component' && isPlainObject(definition)) {
+                      // @ts-expect-error
+                      definition.name = definition.name || id;
+                      definition = this.options._base.extend(definition);
+                  }
+                  if (type === 'directive' && typeof definition === 'function') {
+                      definition = { bind: definition, update: definition };
+                  }
+                  this.options[type + 's'][id] = definition;
+                  return definition;
+              }
+          };
+      });
   }
 
-  function pruneCacheEntry (
-    cache,
-    key,
-    keys,
-    current
-  ) {
-    var cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-      cached$$1.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove(keys, key);
+  // @ts-nocheck
+  function getComponentName(opts) {
+      return opts && (opts.Ctor.options.name || opts.tag);
+  }
+  function matches(pattern, name) {
+      if (Array.isArray(pattern)) {
+          return pattern.indexOf(name) > -1;
+      }
+      else if (typeof pattern === 'string') {
+          return pattern.split(',').indexOf(name) > -1;
+      }
+      else if (isRegExp(pattern)) {
+          return pattern.test(name);
+      }
+      /* istanbul ignore next */
+      return false;
+  }
+  function pruneCache(keepAliveInstance, filter) {
+      var cache = keepAliveInstance.cache;
+      var keys = keepAliveInstance.keys;
+      var _vnode = keepAliveInstance._vnode;
+      for (var key in cache) {
+          var cachedNode = cache[key];
+          if (cachedNode) {
+              var name = getComponentName(cachedNode.componentOptions);
+              if (name && !filter(name)) {
+                  pruneCacheEntry(cache, key, keys, _vnode);
+              }
+          }
+      }
+  }
+  function pruneCacheEntry(cache, key, keys, current) {
+      var cached$$1 = cache[key];
+      if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
+          cached$$1.componentInstance.$destroy();
+      }
+      cache[key] = null;
+      remove(keys, key);
   }
-
   var patternTypes = [String, RegExp, Array];
-
+  // TODO use defineComponent
   var KeepAlive = {
-    name: 'keep-alive',
-    abstract: true,
-
-    props: {
-      include: patternTypes,
-      exclude: patternTypes,
-      max: [String, Number]
-    },
-
-    created: function created () {
-      this.cache = Object.create(null);
-      this.keys = [];
-    },
-
-    destroyed: function destroyed () {
-      for (var key in this.cache) {
-        pruneCacheEntry(this.cache, key, this.keys);
-      }
-    },
-
-    mounted: function mounted () {
-      var this$1 = this;
-
-      this.$watch('include', function (val) {
-        pruneCache(this$1, function (name) { return matches(val, name); });
-      });
-      this.$watch('exclude', function (val) {
-        pruneCache(this$1, function (name) { return !matches(val, name); });
-      });
-    },
-
-    render: function render () {
-      var slot = this.$slots.default;
-      var vnode = getFirstComponentChild(slot);
-      var componentOptions = vnode && vnode.componentOptions;
-      if (componentOptions) {
-        // check pattern
-        var name = getComponentName(componentOptions);
-        var ref = this;
-        var include = ref.include;
-        var exclude = ref.exclude;
-        if (
-          // not included
-          (include && (!name || !matches(include, name))) ||
-          // excluded
-          (exclude && name && matches(exclude, name))
-        ) {
-          return vnode
-        }
-
-        var ref$1 = this;
-        var cache = ref$1.cache;
-        var keys = ref$1.keys;
-        var key = vnode.key == null
-          // same constructor may get registered as different local components
-          // so cid alone is not enough (#3269)
-          ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-          : vnode.key;
-        if (cache[key]) {
-          vnode.componentInstance = cache[key].componentInstance;
-          // make current key freshest
-          remove(keys, key);
-          keys.push(key);
-        } else {
-          cache[key] = vnode;
-          keys.push(key);
-          // prune oldest entry
-          if (this.max && keys.length > parseInt(this.max)) {
-            pruneCacheEntry(cache, keys[0], keys, this._vnode);
+      name: 'keep-alive',
+      abstract: true,
+      props: {
+          include: patternTypes,
+          exclude: patternTypes,
+          max: [String, Number],
+      },
+      created: function created() {
+          this.cache = Object.create(null);
+          this.keys = [];
+      },
+      destroyed: function destroyed() {
+          for (var key in this.cache) {
+              pruneCacheEntry(this.cache, key, this.keys);
           }
-        }
+      },
+      mounted: function mounted() {
+          var this$1 = this;
 
-        vnode.data.keepAlive = true;
-      }
-      return vnode || (slot && slot[0])
-    }
+          this.$watch('include', function (val) {
+              pruneCache(this$1, function (name) { return matches(val, name); });
+          });
+          this.$watch('exclude', function (val) {
+              pruneCache(this$1, function (name) { return !matches(val, name); });
+          });
+      },
+      render: function render() {
+          var slot = this.$slots.default;
+          var vnode = getFirstComponentChild(slot);
+          var componentOptions = vnode && vnode.componentOptions;
+          if (componentOptions) {
+              // check pattern
+              var name = getComponentName(componentOptions);
+              var ref = this;
+              var include = ref.include;
+              var exclude = ref.exclude;
+              if (
+              // not included
+              (include && (!name || !matches(include, name))) ||
+                  // excluded
+                  (exclude && name && matches(exclude, name))) {
+                  return vnode;
+              }
+              var ref$1 = this;
+              var cache = ref$1.cache;
+              var keys = ref$1.keys;
+              var key = vnode.key == null
+                  ? // same constructor may get registered as different local components
+                      // so cid alone is not enough (#3269)
+                      componentOptions.Ctor.cid +
+                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                  : vnode.key;
+              if (cache[key]) {
+                  vnode.componentInstance = cache[key].componentInstance;
+                  // make current key freshest
+                  remove(keys, key);
+                  keys.push(key);
+              }
+              else {
+                  cache[key] = vnode;
+                  keys.push(key);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+              }
+              vnode.data.keepAlive = true;
+          }
+          return vnode || (slot && slot[0]);
+      },
   };
 
   var builtInComponents = {
-    KeepAlive: KeepAlive
+      KeepAlive: KeepAlive,
   };
 
-  /*  */
-
-  function initGlobalAPI (Vue) {
-    // config
-    var configDef = {};
-    configDef.get = function () { return config; };
-    {
-      configDef.set = function () {
-        warn(
-          'Do not replace the Vue.config object, set individual fields instead.'
-        );
+  /* @flow */
+  function initGlobalAPI(Vue) {
+      // config
+      var configDef = {};
+      configDef.get = function () { return config; };
+      {
+          configDef.set = function () {
+              warn('Do not replace the Vue.config object, set individual fields instead.');
+          };
+      }
+      Object.defineProperty(Vue, 'config', configDef);
+      // exposed util methods.
+      // NOTE: these are not considered part of the public API - avoid relying on
+      // them unless you are aware of the risk.
+      Vue.util = {
+          warn: warn,
+          extend: extend,
+          mergeOptions: mergeOptions,
+          defineReactive: defineReactive$$1,
       };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-      warn: warn,
-      extend: extend,
-      mergeOptions: mergeOptions,
-      defineReactive: defineReactive$$1
-    };
-
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-
-    // 2.6 explicit observable API
-    Vue.observable = function (obj) {
-      observe(obj);
-      return obj
-    };
-
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
-      Vue.options[type + 's'] = Object.create(null);
-    });
-
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-
-    extend(Vue.options.components, builtInComponents);
-
-    initUse(Vue);
-    initMixin$1(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+      Vue.set = set;
+      Vue.delete = del;
+      Vue.nextTick = nextTick;
+      // 2.6 explicit observable API
+      Vue.observable = function (obj) {
+          observe(obj);
+          return obj;
+      };
+      Vue.options = Object.create(null);
+      ASSET_TYPES.forEach(function (type) {
+          Vue.options[type + 's'] = Object.create(null);
+      });
+      // this is used to identify the "base" constructor to extend all plain-object
+      // components with in Weex's multi-instance scenarios.
+      Vue.options._base = Vue;
+      extend(Vue.options.components, builtInComponents);
+      initUse(Vue);
+      initMixin$1(Vue);
+      initExtend(Vue);
+      initAssetRegisters(Vue);
   }
 
   initGlobalAPI(Vue);
-
   Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering
+      get: isServerRendering,
   });
-
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get () {
-      /* istanbul ignore next */
-      return this.$vnode && this.$vnode.ssrContext
-    }
+      get: function get() {
+          /* istanbul ignore next */
+          return this.$vnode && this.$vnode.ssrContext;
+      },
   });
-
   // expose FunctionalRenderContext for ssr runtime helper installation
   Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext
+      value: FunctionalRenderContext,
   });
-
   Vue.version = '2.6.12';
 
-  /*  */
-
+  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   var isReservedAttr = makeMap('style,class');
-
   // attributes that should be using props for binding
   var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
   };
-
   var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
   var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
   var convertEnumeratedValue = function (key, value) {
-    return isFalsyAttrValue(value) || value === 'false'
-      ? 'false'
-      // allow arbitrary string value for contenteditable
-      : key === 'contenteditable' && isValidContentEditableValue(value)
-        ? value
-        : 'true'
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
   };
-
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,translate,' +
-    'truespeed,typemustmatch,visible'
-  );
-
+  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
   var xlinkNS = 'http://www.w3.org/1999/xlink';
-
   var isXlink = function (name) {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
+      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
   };
-
   var getXlinkProp = function (name) {
-    return isXlink(name) ? name.slice(6, name.length) : ''
+      return isXlink(name) ? name.slice(6, name.length) : '';
   };
-
   var isFalsyAttrValue = function (val) {
-    return val == null || val === false
+      return val == null || val === false;
   };
 
-  /*  */
-
-  function genClassForVnode (vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-      childNode = childNode.componentInstance._vnode;
-      if (childNode && childNode.data) {
-        data = mergeClassData(childNode.data, data);
-      }
-    }
-    while (isDef(parentNode = parentNode.parent)) {
-      if (parentNode && parentNode.data) {
-        data = mergeClassData(data, parentNode.data);
-      }
-    }
-    return renderClass(data.staticClass, data.class)
+  /* @flow */
+  function genClassForVnode(vnode) {
+      var data = vnode.data;
+      var parentNode = vnode;
+      var childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass(data.staticClass, data.class);
   }
-
-  function mergeClassData (child, parent) {
-    return {
-      staticClass: concat(child.staticClass, parent.staticClass),
-      class: isDef(child.class)
-        ? [child.class, parent.class]
-        : parent.class
-    }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
   }
-
-  function renderClass (
-    staticClass,
-    dynamicClass
-  ) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-      return concat(staticClass, stringifyClass(dynamicClass))
-    }
-    /* istanbul ignore next */
-    return ''
+  function renderClass(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
   }
-
-  function concat (a, b) {
-    return a ? b ? (a + ' ' + b) : a : (b || '')
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
   }
-
-  function stringifyClass (value) {
-    if (Array.isArray(value)) {
-      return stringifyArray(value)
-    }
-    if (isObject(value)) {
-      return stringifyObject(value)
-    }
-    if (typeof value === 'string') {
-      return value
-    }
-    /* istanbul ignore next */
-    return ''
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
   }
-
-  function stringifyArray (value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
-      if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-        if (res) { res += ' '; }
-        res += stringified;
+  function stringifyArray(value) {
+      var res = '';
+      var stringified;
+      for (var i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  { res += ' '; }
+              res += stringified;
+          }
       }
-    }
-    return res
+      return res;
   }
-
-  function stringifyObject (value) {
-    var res = '';
-    for (var key in value) {
-      if (value[key]) {
-        if (res) { res += ' '; }
-        res += key;
+  function stringifyObject(value) {
+      var res = '';
+      for (var key in value) {
+          if (value[key]) {
+              if (res)
+                  { res += ' '; }
+              res += key;
+          }
       }
-    }
-    return res
+      return res;
   }
 
-  /*  */
-
+  /* @flow */
   var namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML'
+      svg: 'http://www.w3.org/2000/svg',
+      math: 'http://www.w3.org/1998/Math/MathML',
   };
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-  );
-
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  );
-
+  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
   var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
+      return isHTMLTag(tag) || isSVG(tag);
   };
-
-  function getTagNamespace (tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
   }
-
   var unknownElementCache = Object.create(null);
-  function isUnknownElement (tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-      return true
-    }
-    if (isReservedTag(tag)) {
-      return false
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-      return unknownElementCache[tag]
-    }
-    var el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-      // http://stackoverflow.com/a/28210364/1070244
-      return (unknownElementCache[tag] = (
-        el.constructor === window.HTMLUnknownElement ||
-        el.constructor === window.HTMLElement
-      ))
-    } else {
-      return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
-    }
+  function isUnknownElement(tag) {
+      /* istanbul ignore if */
+      if (!inBrowser) {
+          return true;
+      }
+      if (isReservedTag(tag)) {
+          return false;
+      }
+      tag = tag.toLowerCase();
+      /* istanbul ignore if */
+      if (unknownElementCache[tag] != null) {
+          return unknownElementCache[tag];
+      }
+      var el = document.createElement(tag);
+      if (tag.indexOf('-') > -1) {
+          // http://stackoverflow.com/a/28210364/1070244
+          return (unknownElementCache[tag] =
+              el.constructor === window.HTMLUnknownElement ||
+                  el.constructor === window.HTMLElement);
+      }
+      else {
+          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+      }
   }
-
   var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /*  */
-
+  /* @flow */
   /**
    * Query an element selector if it's not an element already.
    */
-  function query (el) {
-    if (typeof el === 'string') {
-      var selected = document.querySelector(el);
-      if (!selected) {
-        warn(
-          'Cannot find element: ' + el
-        );
-        return document.createElement('div')
-      }
-      return selected
-    } else {
-      return el
-    }
+  function query(el) {
+      if (typeof el === 'string') {
+          var selected = document.querySelector(el);
+          if (!selected) {
+              warn('Cannot find element: ' + el);
+              return document.createElement('div');
+          }
+          return selected;
+      }
+      else {
+          return el;
+      }
   }
 
-  /*  */
-
-  function createElement$1 (tagName, vnode) {
-    var elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-      return elm
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
-      elm.setAttribute('multiple', 'multiple');
-    }
-    return elm
+  /* @flow */
+  function createElement$1(tagName, vnode) {
+      var elm = document.createElement(tagName);
+      if (tagName !== 'select') {
+          return elm;
+      }
+      // false or null will remove the attribute but undefined will not
+      if (vnode.data &&
+          vnode.data.attrs &&
+          vnode.data.attrs.multiple !== undefined) {
+          elm.setAttribute('multiple', 'multiple');
+      }
+      return elm;
   }
-
-  function createElementNS (namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName)
+  function createElementNS(namespace, tagName) {
+      return document.createElementNS(namespaceMap[namespace], tagName);
   }
-
-  function createTextNode (text) {
-    return document.createTextNode(text)
+  function createTextNode(text) {
+      return document.createTextNode(text);
   }
-
-  function createComment (text) {
-    return document.createComment(text)
+  function createComment(text) {
+      return document.createComment(text);
   }
-
-  function insertBefore (parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
+  function insertBefore(parentNode, newNode, referenceNode) {
+      parentNode.insertBefore(newNode, referenceNode);
   }
-
-  function removeChild (node, child) {
-    node.removeChild(child);
+  function removeChild(node, child) {
+      node.removeChild(child);
   }
-
-  function appendChild (node, child) {
-    node.appendChild(child);
+  function appendChild(node, child) {
+      node.appendChild(child);
   }
-
-  function parentNode (node) {
-    return node.parentNode
+  function parentNode(node) {
+      return node.parentNode;
   }
-
-  function nextSibling (node) {
-    return node.nextSibling
+  function nextSibling(node) {
+      return node.nextSibling;
   }
-
-  function tagName (node) {
-    return node.tagName
+  function tagName(node) {
+      return node.tagName;
   }
-
-  function setTextContent (node, text) {
-    node.textContent = text;
+  function setTextContent(node, text) {
+      node.textContent = text;
   }
-
-  function setStyleScope (node, scopeId) {
-    node.setAttribute(scopeId, '');
+  function setStyleScope(node, scopeId) {
+      node.setAttribute(scopeId, '');
   }
 
   var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5736,48 +5022,53 @@
     setStyleScope: setStyleScope
   });
 
-  /*  */
-
+  /* @flow */
   var ref = {
-    create: function create (_, vnode) {
-      registerRef(vnode);
-    },
-    update: function update (oldVnode, vnode) {
-      if (oldVnode.data.ref !== vnode.data.ref) {
-        registerRef(oldVnode, true);
-        registerRef(vnode);
-      }
-    },
-    destroy: function destroy (vnode) {
-      registerRef(vnode, true);
-    }
+      create: function create(_, vnode) {
+          registerRef(vnode);
+      },
+      update: function update(oldVnode, vnode) {
+          if (oldVnode.data.ref !== vnode.data.ref) {
+              registerRef(oldVnode, true);
+              registerRef(vnode);
+          }
+      },
+      destroy: function destroy(vnode) {
+          registerRef(vnode, true);
+      },
   };
-
-  function registerRef (vnode, isRemoval) {
-    var key = vnode.data.ref;
-    if (!isDef(key)) { return }
-
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
-    if (isRemoval) {
-      if (Array.isArray(refs[key])) {
-        remove(refs[key], ref);
-      } else if (refs[key] === ref) {
-        refs[key] = undefined;
-      }
-    } else {
-      if (vnode.data.refInFor) {
-        if (!Array.isArray(refs[key])) {
-          refs[key] = [ref];
-        } else if (refs[key].indexOf(ref) < 0) {
-          // $flow-disable-line
-          refs[key].push(ref);
-        }
-      } else {
-        refs[key] = ref;
+  function registerRef(vnode, isRemoval) {
+      var key = vnode.data.ref;
+      if (!isDef(key))
+          { return; }
+      var vm = vnode.context;
+      var ref = vnode.componentInstance || vnode.elm;
+      var refs = vm.$refs;
+      if (isRemoval) {
+          if (Array.isArray(refs[key])) {
+              // @ts-expect-error invalid typings
+              remove(refs[key], ref);
+          }
+          else if (refs[key] === ref) {
+              refs[key] = undefined;
+          }
+      }
+      else {
+          // @ts-expect-error invalid typings
+          if (vnode.data.refInFor) {
+              if (!Array.isArray(refs[key])) {
+                  refs[key] = [ref];
+                  // @ts-expect-error invalid typings
+              }
+              else if (refs[key].indexOf(ref) < 0) {
+                  // @ts-expect-error invalid typings
+                  refs[key].push(ref);
+              }
+          }
+          else {
+              refs[key] = ref;
+          }
       }
-    }
   }
 
   /**
@@ -5791,2638 +5082,2423 @@
    * Not type-checking this because this file is perf-critical and the cost
    * of making flow understand it is not worth it.
    */
-
   var emptyNode = new VNode('', {}, []);
-
   var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-  function sameVnode (a, b) {
-    return (
-      a.key === b.key && (
-        (
-          a.tag === b.tag &&
-          a.isComment === b.isComment &&
-          isDef(a.data) === isDef(b.data) &&
-          sameInputType(a, b)
-        ) || (
-          isTrue(a.isAsyncPlaceholder) &&
-          a.asyncFactory === b.asyncFactory &&
-          isUndef(b.asyncFactory.error)
-        )
-      )
-    )
-  }
-
-  function sameInputType (a, b) {
-    if (a.tag !== 'input') { return true }
-    var i;
-    var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-    var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-    return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
+  function sameVnode(a, b) {
+      return (a.key === b.key &&
+          ((a.tag === b.tag &&
+              a.isComment === b.isComment &&
+              isDef(a.data) === isDef(b.data) &&
+              sameInputType(a, b)) ||
+              (isTrue(a.isAsyncPlaceholder) &&
+                  a.asyncFactory === b.asyncFactory &&
+                  isUndef(b.asyncFactory.error))));
+  }
+  function sameInputType(a, b) {
+      if (a.tag !== 'input')
+          { return true; }
+      var i;
+      var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
   }
-
-  function createKeyToOldIdx (children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-      key = children[i].key;
-      if (isDef(key)) { map[key] = i; }
-    }
-    return map
+  function createKeyToOldIdx(children, beginIdx, endIdx) {
+      var i, key;
+      var map = {};
+      for (i = beginIdx; i <= endIdx; ++i) {
+          key = children[i].key;
+          if (isDef(key))
+              { map[key] = i; }
+      }
+      return map;
   }
-
-  function createPatchFunction (backend) {
-    var i, j;
-    var cbs = {};
-
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
-
-    for (i = 0; i < hooks.length; ++i) {
-      cbs[hooks[i]] = [];
-      for (j = 0; j < modules.length; ++j) {
-        if (isDef(modules[j][hooks[i]])) {
-          cbs[hooks[i]].push(modules[j][hooks[i]]);
-        }
-      }
-    }
-
-    function emptyNodeAt (elm) {
-      return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-    }
-
-    function createRmCb (childElm, listeners) {
-      function remove$$1 () {
-        if (--remove$$1.listeners === 0) {
-          removeNode(childElm);
-        }
-      }
-      remove$$1.listeners = listeners;
-      return remove$$1
-    }
-
-    function removeNode (el) {
-      var parent = nodeOps.parentNode(el);
-      // element may have already been removed due to v-html / v-text
-      if (isDef(parent)) {
-        nodeOps.removeChild(parent, el);
+  function createPatchFunction(backend) {
+      var i, j;
+      var cbs = {};
+      var modules = backend.modules;
+      var nodeOps = backend.nodeOps;
+      for (i = 0; i < hooks.length; ++i) {
+          cbs[hooks[i]] = [];
+          for (j = 0; j < modules.length; ++j) {
+              if (isDef(modules[j][hooks[i]])) {
+                  cbs[hooks[i]].push(modules[j][hooks[i]]);
+              }
+          }
       }
-    }
-
-    function isUnknownElement$$1 (vnode, inVPre) {
-      return (
-        !inVPre &&
-        !vnode.ns &&
-        !(
-          config.ignoredElements.length &&
-          config.ignoredElements.some(function (ignore) {
-            return isRegExp(ignore)
-              ? ignore.test(vnode.tag)
-              : ignore === vnode.tag
-          })
-        ) &&
-        config.isUnknownElement(vnode.tag)
-      )
-    }
-
-    var creatingElmInVPre = 0;
-
-    function createElm (
-      vnode,
-      insertedVnodeQueue,
-      parentElm,
-      refElm,
-      nested,
-      ownerArray,
-      index
-    ) {
-      if (isDef(vnode.elm) && isDef(ownerArray)) {
-        // This vnode was used in a previous render!
-        // now it's used as a new node, overwriting its elm would cause
-        // potential patch errors down the road when it's used as an insertion
-        // reference node. Instead, we clone the node on-demand before creating
-        // associated DOM element for it.
-        vnode = ownerArray[index] = cloneVNode(vnode);
+      function emptyNodeAt(elm) {
+          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
       }
-
-      vnode.isRootInsert = !nested; // for transition enter check
-      if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-        return
+      function createRmCb(childElm, listeners) {
+          function remove$$1() {
+              if (--remove$$1.listeners === 0) {
+                  removeNode(childElm);
+              }
+          }
+          remove$$1.listeners = listeners;
+          return remove$$1;
+      }
+      function removeNode(el) {
+          var parent = nodeOps.parentNode(el);
+          // element may have already been removed due to v-html / v-text
+          if (isDef(parent)) {
+              nodeOps.removeChild(parent, el);
+          }
       }
-
-      var data = vnode.data;
-      var children = vnode.children;
-      var tag = vnode.tag;
-      if (isDef(tag)) {
-        {
-          if (data && data.pre) {
-            creatingElmInVPre++;
-          }
-          if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-            warn(
-              'Unknown custom element: <' + tag + '> - did you ' +
-              'register the component correctly? For recursive components, ' +
-              'make sure to provide the "name" option.',
-              vnode.context
-            );
-          }
-        }
-
-        vnode.elm = vnode.ns
-          ? nodeOps.createElementNS(vnode.ns, tag)
-          : nodeOps.createElement(tag, vnode);
-        setScope(vnode);
-
-        /* istanbul ignore if */
-        {
-          createChildren(vnode, children, insertedVnodeQueue);
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
+      function isUnknownElement$$1(vnode, inVPre) {
+          return (!inVPre &&
+              !vnode.ns &&
+              !(config.ignoredElements.length &&
+                  config.ignoredElements.some(function (ignore) {
+                      return isRegExp(ignore)
+                          ? ignore.test(vnode.tag)
+                          : ignore === vnode.tag;
+                  })) &&
+              config.isUnknownElement(vnode.tag));
+      }
+      var creatingElmInVPre = 0;
+      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // This vnode was used in a previous render!
+              // now it's used as a new node, overwriting its elm would cause
+              // potential patch errors down the road when it's used as an insertion
+              // reference node. Instead, we clone the node on-demand before creating
+              // associated DOM element for it.
+              vnode = ownerArray[index] = cloneVNode(vnode);
           }
-          insert(parentElm, vnode.elm, refElm);
-        }
-
-        if (data && data.pre) {
-          creatingElmInVPre--;
-        }
-      } else if (isTrue(vnode.isComment)) {
-        vnode.elm = nodeOps.createComment(vnode.text);
-        insert(parentElm, vnode.elm, refElm);
-      } else {
-        vnode.elm = nodeOps.createTextNode(vnode.text);
-        insert(parentElm, vnode.elm, refElm);
-      }
-    }
-
-    function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-      var i = vnode.data;
-      if (isDef(i)) {
-        var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-        if (isDef(i = i.hook) && isDef(i = i.init)) {
-          i(vnode, false /* hydrating */);
-        }
-        // after calling the init hook, if the vnode is a child component
-        // it should've created a child instance and mounted it. the child
-        // component also has set the placeholder vnode's elm.
-        // in that case we can just return the element and be done.
-        if (isDef(vnode.componentInstance)) {
-          initComponent(vnode, insertedVnodeQueue);
-          insert(parentElm, vnode.elm, refElm);
-          if (isTrue(isReactivated)) {
-            reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+          vnode.isRootInsert = !nested; // for transition enter check
+          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+              return;
+          }
+          var data = vnode.data;
+          var children = vnode.children;
+          var tag = vnode.tag;
+          if (isDef(tag)) {
+              {
+                  if (data && data.pre) {
+                      creatingElmInVPre++;
+                  }
+                  if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                      warn('Unknown custom element: <' +
+                          tag +
+                          '> - did you ' +
+                          'register the component correctly? For recursive components, ' +
+                          'make sure to provide the "name" option.', vnode.context);
+                  }
+              }
+              vnode.elm = vnode.ns
+                  ? nodeOps.createElementNS(vnode.ns, tag)
+                  : nodeOps.createElement(tag, vnode);
+              setScope(vnode);
+              /* istanbul ignore if */
+              {
+                  createChildren(vnode, children, insertedVnodeQueue);
+                  if (isDef(data)) {
+                      invokeCreateHooks(vnode, insertedVnodeQueue);
+                  }
+                  insert(parentElm, vnode.elm, refElm);
+              }
+              if (data && data.pre) {
+                  creatingElmInVPre--;
+              }
+          }
+          else if (isTrue(vnode.isComment)) {
+              vnode.elm = nodeOps.createComment(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+          else {
+              vnode.elm = nodeOps.createTextNode(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
           }
-          return true
-        }
       }
-    }
-
-    function initComponent (vnode, insertedVnodeQueue) {
-      if (isDef(vnode.data.pendingInsert)) {
-        insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-        vnode.data.pendingInsert = null;
-      }
-      vnode.elm = vnode.componentInstance.$el;
-      if (isPatchable(vnode)) {
-        invokeCreateHooks(vnode, insertedVnodeQueue);
-        setScope(vnode);
-      } else {
-        // empty component root.
-        // skip all element-related modules except for ref (#3455)
-        registerRef(vnode);
-        // make sure to invoke the insert hook
-        insertedVnodeQueue.push(vnode);
-      }
-    }
-
-    function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-      var i;
-      // hack for #4339: a reactivated component with inner transition
-      // does not trigger because the inner node's created hooks are not called
-      // again. It's not ideal to involve module-specific logic in here but
-      // there doesn't seem to be a better way to do it.
-      var innerNode = vnode;
-      while (innerNode.componentInstance) {
-        innerNode = innerNode.componentInstance._vnode;
-        if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-          for (i = 0; i < cbs.activate.length; ++i) {
-            cbs.activate[i](emptyNode, innerNode);
-          }
-          insertedVnodeQueue.push(innerNode);
-          break
-        }
-      }
-      // unlike a newly created component,
-      // a reactivated keep-alive component doesn't insert itself
-      insert(parentElm, vnode.elm, refElm);
-    }
-
-    function insert (parent, elm, ref$$1) {
-      if (isDef(parent)) {
-        if (isDef(ref$$1)) {
-          if (nodeOps.parentNode(ref$$1) === parent) {
-            nodeOps.insertBefore(parent, elm, ref$$1);
+      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          var i = vnode.data;
+          if (isDef(i)) {
+              var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                  i(vnode, false /* hydrating */);
+              }
+              // after calling the init hook, if the vnode is a child component
+              // it should've created a child instance and mounted it. the child
+              // component also has set the placeholder vnode's elm.
+              // in that case we can just return the element and be done.
+              if (isDef(vnode.componentInstance)) {
+                  initComponent(vnode, insertedVnodeQueue);
+                  insert(parentElm, vnode.elm, refElm);
+                  if (isTrue(isReactivated)) {
+                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                  }
+                  return true;
+              }
           }
-        } else {
-          nodeOps.appendChild(parent, elm);
-        }
       }
-    }
-
-    function createChildren (vnode, children, insertedVnodeQueue) {
-      if (Array.isArray(children)) {
-        {
-          checkDuplicateKeys(children);
-        }
-        for (var i = 0; i < children.length; ++i) {
-          createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-        }
-      } else if (isPrimitive(vnode.text)) {
-        nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-      }
-    }
-
-    function isPatchable (vnode) {
-      while (vnode.componentInstance) {
-        vnode = vnode.componentInstance._vnode;
+      function initComponent(vnode, insertedVnodeQueue) {
+          if (isDef(vnode.data.pendingInsert)) {
+              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+              vnode.data.pendingInsert = null;
+          }
+          vnode.elm = vnode.componentInstance.$el;
+          if (isPatchable(vnode)) {
+              invokeCreateHooks(vnode, insertedVnodeQueue);
+              setScope(vnode);
+          }
+          else {
+              // empty component root.
+              // skip all element-related modules except for ref (#3455)
+              registerRef(vnode);
+              // make sure to invoke the insert hook
+              insertedVnodeQueue.push(vnode);
+          }
       }
-      return isDef(vnode.tag)
-    }
-
-    function invokeCreateHooks (vnode, insertedVnodeQueue) {
-      for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-        cbs.create[i$1](emptyNode, vnode);
+      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          var i;
+          // hack for #4339: a reactivated component with inner transition
+          // does not trigger because the inner node's created hooks are not called
+          // again. It's not ideal to involve module-specific logic in here but
+          // there doesn't seem to be a better way to do it.
+          var innerNode = vnode;
+          while (innerNode.componentInstance) {
+              innerNode = innerNode.componentInstance._vnode;
+              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                  for (i = 0; i < cbs.activate.length; ++i) {
+                      cbs.activate[i](emptyNode, innerNode);
+                  }
+                  insertedVnodeQueue.push(innerNode);
+                  break;
+              }
+          }
+          // unlike a newly created component,
+          // a reactivated keep-alive component doesn't insert itself
+          insert(parentElm, vnode.elm, refElm);
+      }
+      function insert(parent, elm, ref$$1) {
+          if (isDef(parent)) {
+              if (isDef(ref$$1)) {
+                  if (nodeOps.parentNode(ref$$1) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref$$1);
+                  }
+              }
+              else {
+                  nodeOps.appendChild(parent, elm);
+              }
+          }
       }
-      i = vnode.data.hook; // Reuse variable
-      if (isDef(i)) {
-        if (isDef(i.create)) { i.create(emptyNode, vnode); }
-        if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
+      function createChildren(vnode, children, insertedVnodeQueue) {
+          if (Array.isArray(children)) {
+              {
+                  checkDuplicateKeys(children);
+              }
+              for (var i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              }
+          }
+          else if (isPrimitive(vnode.text)) {
+              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+          }
       }
-    }
-
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope (vnode) {
-      var i;
-      if (isDef(i = vnode.fnScopeId)) {
-        nodeOps.setStyleScope(vnode.elm, i);
-      } else {
-        var ancestor = vnode;
-        while (ancestor) {
-          if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-            nodeOps.setStyleScope(vnode.elm, i);
-          }
-          ancestor = ancestor.parent;
-        }
-      }
-      // for slot content they should also get the scopeId from the host instance.
-      if (isDef(i = activeInstance) &&
-        i !== vnode.context &&
-        i !== vnode.fnContext &&
-        isDef(i = i.$options._scopeId)
-      ) {
-        nodeOps.setStyleScope(vnode.elm, i);
-      }
-    }
-
-    function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-      for (; startIdx <= endIdx; ++startIdx) {
-        createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+      function isPatchable(vnode) {
+          while (vnode.componentInstance) {
+              vnode = vnode.componentInstance._vnode;
+          }
+          return isDef(vnode.tag);
       }
-    }
-
-    function invokeDestroyHook (vnode) {
-      var i, j;
-      var data = vnode.data;
-      if (isDef(data)) {
-        if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-        for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
+      function invokeCreateHooks(vnode, insertedVnodeQueue) {
+          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+              cbs.create[i$1](emptyNode, vnode);
+          }
+          i = vnode.data.hook; // Reuse variable
+          if (isDef(i)) {
+              if (isDef(i.create))
+                  { i.create(emptyNode, vnode); }
+              if (isDef(i.insert))
+                  { insertedVnodeQueue.push(vnode); }
+          }
       }
-      if (isDef(i = vnode.children)) {
-        for (j = 0; j < vnode.children.length; ++j) {
-          invokeDestroyHook(vnode.children[j]);
-        }
+      // set scope id attribute for scoped CSS.
+      // this is implemented as a special case to avoid the overhead
+      // of going through the normal attribute patching process.
+      function setScope(vnode) {
+          var i;
+          if (isDef((i = vnode.fnScopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+          else {
+              var ancestor = vnode;
+              while (ancestor) {
+                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                      nodeOps.setStyleScope(vnode.elm, i);
+                  }
+                  ancestor = ancestor.parent;
+              }
+          }
+          // for slot content they should also get the scopeId from the host instance.
+          if (isDef((i = activeInstance)) &&
+              i !== vnode.context &&
+              i !== vnode.fnContext &&
+              isDef((i = i.$options._scopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
       }
-    }
-
-    function removeVnodes (vnodes, startIdx, endIdx) {
-      for (; startIdx <= endIdx; ++startIdx) {
-        var ch = vnodes[startIdx];
-        if (isDef(ch)) {
-          if (isDef(ch.tag)) {
-            removeAndInvokeRemoveHook(ch);
-            invokeDestroyHook(ch);
-          } else { // Text node
-            removeNode(ch.elm);
-          }
-        }
-      }
-    }
-
-    function removeAndInvokeRemoveHook (vnode, rm) {
-      if (isDef(rm) || isDef(vnode.data)) {
-        var i;
-        var listeners = cbs.remove.length + 1;
-        if (isDef(rm)) {
-          // we have a recursively passed down rm callback
-          // increase the listeners count
-          rm.listeners += listeners;
-        } else {
-          // directly removing
-          rm = createRmCb(vnode.elm, listeners);
-        }
-        // recursively invoke hooks on child component root node
-        if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-          removeAndInvokeRemoveHook(i, rm);
-        }
-        for (i = 0; i < cbs.remove.length; ++i) {
-          cbs.remove[i](vnode, rm);
-        }
-        if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-          i(vnode, rm);
-        } else {
-          rm();
-        }
-      } else {
-        removeNode(vnode.elm);
-      }
-    }
-
-    function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-      var oldStartIdx = 0;
-      var newStartIdx = 0;
-      var oldEndIdx = oldCh.length - 1;
-      var oldStartVnode = oldCh[0];
-      var oldEndVnode = oldCh[oldEndIdx];
-      var newEndIdx = newCh.length - 1;
-      var newStartVnode = newCh[0];
-      var newEndVnode = newCh[newEndIdx];
-      var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-      // removeOnly is a special flag used only by <transition-group>
-      // to ensure removed elements stay in correct relative positions
-      // during leaving transitions
-      var canMove = !removeOnly;
-
-      {
-        checkDuplicateKeys(newCh);
+      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+          }
       }
-
-      while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-        if (isUndef(oldStartVnode)) {
-          oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-        } else if (isUndef(oldEndVnode)) {
-          oldEndVnode = oldCh[--oldEndIdx];
-        } else if (sameVnode(oldStartVnode, newStartVnode)) {
-          patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-          oldStartVnode = oldCh[++oldStartIdx];
-          newStartVnode = newCh[++newStartIdx];
-        } else if (sameVnode(oldEndVnode, newEndVnode)) {
-          patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-          oldEndVnode = oldCh[--oldEndIdx];
-          newEndVnode = newCh[--newEndIdx];
-        } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-          patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-          canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-          oldStartVnode = oldCh[++oldStartIdx];
-          newEndVnode = newCh[--newEndIdx];
-        } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-          patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-          canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-          oldEndVnode = oldCh[--oldEndIdx];
-          newStartVnode = newCh[++newStartIdx];
-        } else {
-          if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-          idxInOld = isDef(newStartVnode.key)
-            ? oldKeyToIdx[newStartVnode.key]
-            : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-          if (isUndef(idxInOld)) { // New element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          } else {
-            vnodeToMove = oldCh[idxInOld];
-            if (sameVnode(vnodeToMove, newStartVnode)) {
-              patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-              oldCh[idxInOld] = undefined;
-              canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-            } else {
-              // same key but different element. treat as new element
-              createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-            }
-          }
-          newStartVnode = newCh[++newStartIdx];
-        }
-      }
-      if (oldStartIdx > oldEndIdx) {
-        refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-        addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-      } else if (newStartIdx > newEndIdx) {
-        removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-      }
-    }
-
-    function checkDuplicateKeys (children) {
-      var seenKeys = {};
-      for (var i = 0; i < children.length; i++) {
-        var vnode = children[i];
-        var key = vnode.key;
-        if (isDef(key)) {
-          if (seenKeys[key]) {
-            warn(
-              ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-              vnode.context
-            );
-          } else {
-            seenKeys[key] = true;
-          }
-        }
-      }
-    }
-
-    function findIdxInOld (node, oldCh, start, end) {
-      for (var i = start; i < end; i++) {
-        var c = oldCh[i];
-        if (isDef(c) && sameVnode(node, c)) { return i }
+      function invokeDestroyHook(vnode) {
+          var i, j;
+          var data = vnode.data;
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                  { i(vnode); }
+              for (i = 0; i < cbs.destroy.length; ++i)
+                  { cbs.destroy[i](vnode); }
+          }
+          if (isDef((i = vnode.children))) {
+              for (j = 0; j < vnode.children.length; ++j) {
+                  invokeDestroyHook(vnode.children[j]);
+              }
+          }
       }
-    }
-
-    function patchVnode (
-      oldVnode,
-      vnode,
-      insertedVnodeQueue,
-      ownerArray,
-      index,
-      removeOnly
-    ) {
-      if (oldVnode === vnode) {
-        return
+      function removeVnodes(vnodes, startIdx, endIdx) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              var ch = vnodes[startIdx];
+              if (isDef(ch)) {
+                  if (isDef(ch.tag)) {
+                      removeAndInvokeRemoveHook(ch);
+                      invokeDestroyHook(ch);
+                  }
+                  else {
+                      // Text node
+                      removeNode(ch.elm);
+                  }
+              }
+          }
       }
-
-      if (isDef(vnode.elm) && isDef(ownerArray)) {
-        // clone reused vnode
-        vnode = ownerArray[index] = cloneVNode(vnode);
+      function removeAndInvokeRemoveHook(vnode, rm) {
+          if (isDef(rm) || isDef(vnode.data)) {
+              var i;
+              var listeners = cbs.remove.length + 1;
+              if (isDef(rm)) {
+                  // we have a recursively passed down rm callback
+                  // increase the listeners count
+                  rm.listeners += listeners;
+              }
+              else {
+                  // directly removing
+                  rm = createRmCb(vnode.elm, listeners);
+              }
+              // recursively invoke hooks on child component root node
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
+              }
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
+              }
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          }
+          else {
+              removeNode(vnode.elm);
+          }
       }
-
-      var elm = vnode.elm = oldVnode.elm;
-
-      if (isTrue(oldVnode.isAsyncPlaceholder)) {
-        if (isDef(vnode.asyncFactory.resolved)) {
-          hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-        } else {
-          vnode.isAsyncPlaceholder = true;
-        }
-        return
+      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+          var oldStartIdx = 0;
+          var newStartIdx = 0;
+          var oldEndIdx = oldCh.length - 1;
+          var oldStartVnode = oldCh[0];
+          var oldEndVnode = oldCh[oldEndIdx];
+          var newEndIdx = newCh.length - 1;
+          var newStartVnode = newCh[0];
+          var newEndVnode = newCh[newEndIdx];
+          var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          // removeOnly is a special flag used only by <transition-group>
+          // to ensure removed elements stay in correct relative positions
+          // during leaving transitions
+          var canMove = !removeOnly;
+          {
+              checkDuplicateKeys(newCh);
+          }
+          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+              if (isUndef(oldStartVnode)) {
+                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+              }
+              else if (isUndef(oldEndVnode)) {
+                  oldEndVnode = oldCh[--oldEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newStartVnode)) {
+                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else if (sameVnode(oldEndVnode, newEndVnode)) {
+                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newEndVnode)) {
+                  // Vnode moved right
+                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldEndVnode, newStartVnode)) {
+                  // Vnode moved left
+                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else {
+                  if (isUndef(oldKeyToIdx))
+                      { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                  idxInOld = isDef(newStartVnode.key)
+                      ? oldKeyToIdx[newStartVnode.key]
+                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                  if (isUndef(idxInOld)) {
+                      // New element
+                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                  }
+                  else {
+                      vnodeToMove = oldCh[idxInOld];
+                      if (sameVnode(vnodeToMove, newStartVnode)) {
+                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                          oldCh[idxInOld] = undefined;
+                          canMove &&
+                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                      }
+                      else {
+                          // same key but different element. treat as new element
+                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                      }
+                  }
+                  newStartVnode = newCh[++newStartIdx];
+              }
+          }
+          if (oldStartIdx > oldEndIdx) {
+              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+          }
+          else if (newStartIdx > newEndIdx) {
+              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+          }
       }
-
-      // reuse element for static trees.
-      // note we only do this if the vnode is cloned -
-      // if the new node is not cloned it means the render functions have been
-      // reset by the hot-reload-api and we need to do a proper re-render.
-      if (isTrue(vnode.isStatic) &&
-        isTrue(oldVnode.isStatic) &&
-        vnode.key === oldVnode.key &&
-        (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-      ) {
-        vnode.componentInstance = oldVnode.componentInstance;
-        return
+      function checkDuplicateKeys(children) {
+          var seenKeys = {};
+          for (var i = 0; i < children.length; i++) {
+              var vnode = children[i];
+              var key = vnode.key;
+              if (isDef(key)) {
+                  if (seenKeys[key]) {
+                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                  }
+                  else {
+                      seenKeys[key] = true;
+                  }
+              }
+          }
       }
-
-      var i;
-      var data = vnode.data;
-      if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-        i(oldVnode, vnode);
+      function findIdxInOld(node, oldCh, start, end) {
+          for (var i = start; i < end; i++) {
+              var c = oldCh[i];
+              if (isDef(c) && sameVnode(node, c))
+                  { return i; }
+          }
       }
-
-      var oldCh = oldVnode.children;
-      var ch = vnode.children;
-      if (isDef(data) && isPatchable(vnode)) {
-        for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-        if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
-      }
-      if (isUndef(vnode.text)) {
-        if (isDef(oldCh) && isDef(ch)) {
-          if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-        } else if (isDef(ch)) {
-          {
-            checkDuplicateKeys(ch);
-          }
-          if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-          addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-        } else if (isDef(oldCh)) {
-          removeVnodes(oldCh, 0, oldCh.length - 1);
-        } else if (isDef(oldVnode.text)) {
-          nodeOps.setTextContent(elm, '');
-        }
-      } else if (oldVnode.text !== vnode.text) {
-        nodeOps.setTextContent(elm, vnode.text);
-      }
-      if (isDef(data)) {
-        if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-      }
-    }
-
-    function invokeInsertHook (vnode, queue, initial) {
-      // delay insert hooks for component root nodes, invoke them after the
-      // element is really inserted
-      if (isTrue(initial) && isDef(vnode.parent)) {
-        vnode.parent.data.pendingInsert = queue;
-      } else {
-        for (var i = 0; i < queue.length; ++i) {
-          queue[i].data.hook.insert(queue[i]);
-        }
-      }
-    }
-
-    var hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-      var i;
-      var tag = vnode.tag;
-      var data = vnode.data;
-      var children = vnode.children;
-      inVPre = inVPre || (data && data.pre);
-      vnode.elm = elm;
-
-      if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-        vnode.isAsyncPlaceholder = true;
-        return true
+      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+          if (oldVnode === vnode) {
+              return;
+          }
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // clone reused vnode
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          var elm = (vnode.elm = oldVnode.elm);
+          if (isTrue(oldVnode.isAsyncPlaceholder)) {
+              if (isDef(vnode.asyncFactory.resolved)) {
+                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+              }
+              else {
+                  vnode.isAsyncPlaceholder = true;
+              }
+              return;
+          }
+          // reuse element for static trees.
+          // note we only do this if the vnode is cloned -
+          // if the new node is not cloned it means the render functions have been
+          // reset by the hot-reload-api and we need to do a proper re-render.
+          if (isTrue(vnode.isStatic) &&
+              isTrue(oldVnode.isStatic) &&
+              vnode.key === oldVnode.key &&
+              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+              vnode.componentInstance = oldVnode.componentInstance;
+              return;
+          }
+          var i;
+          var data = vnode.data;
+          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+              i(oldVnode, vnode);
+          }
+          var oldCh = oldVnode.children;
+          var ch = vnode.children;
+          if (isDef(data) && isPatchable(vnode)) {
+              for (i = 0; i < cbs.update.length; ++i)
+                  { cbs.update[i](oldVnode, vnode); }
+              if (isDef((i = data.hook)) && isDef((i = i.update)))
+                  { i(oldVnode, vnode); }
+          }
+          if (isUndef(vnode.text)) {
+              if (isDef(oldCh) && isDef(ch)) {
+                  if (oldCh !== ch)
+                      { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+              }
+              else if (isDef(ch)) {
+                  {
+                      checkDuplicateKeys(ch);
+                  }
+                  if (isDef(oldVnode.text))
+                      { nodeOps.setTextContent(elm, ''); }
+                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+              }
+              else if (isDef(oldCh)) {
+                  removeVnodes(oldCh, 0, oldCh.length - 1);
+              }
+              else if (isDef(oldVnode.text)) {
+                  nodeOps.setTextContent(elm, '');
+              }
+          }
+          else if (oldVnode.text !== vnode.text) {
+              nodeOps.setTextContent(elm, vnode.text);
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                  { i(oldVnode, vnode); }
+          }
       }
-      // assert node match
-      {
-        if (!assertNodeMatch(elm, vnode, inVPre)) {
-          return false
-        }
-      }
-      if (isDef(data)) {
-        if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-        if (isDef(i = vnode.componentInstance)) {
-          // child component. it should have hydrated its own tree.
-          initComponent(vnode, insertedVnodeQueue);
-          return true
-        }
-      }
-      if (isDef(tag)) {
-        if (isDef(children)) {
-          // empty element, allow client to pick up and populate children
-          if (!elm.hasChildNodes()) {
-            createChildren(vnode, children, insertedVnodeQueue);
-          } else {
-            // v-html and domProps: innerHTML
-            if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-              if (i !== elm.innerHTML) {
-                /* istanbul ignore if */
-                if (typeof console !== 'undefined' &&
-                  !hydrationBailed
-                ) {
-                  hydrationBailed = true;
-                  console.warn('Parent: ', elm);
-                  console.warn('server innerHTML: ', i);
-                  console.warn('client innerHTML: ', elm.innerHTML);
-                }
-                return false
-              }
-            } else {
-              // iterate and compare children lists
-              var childrenMatch = true;
-              var childNode = elm.firstChild;
-              for (var i$1 = 0; i$1 < children.length; i$1++) {
-                if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                  childrenMatch = false;
-                  break
-                }
-                childNode = childNode.nextSibling;
-              }
-              // if childNode is not null, it means the actual childNodes list is
-              // longer than the virtual children list.
-              if (!childrenMatch || childNode) {
-                /* istanbul ignore if */
-                if (typeof console !== 'undefined' &&
-                  !hydrationBailed
-                ) {
-                  hydrationBailed = true;
-                  console.warn('Parent: ', elm);
-                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                }
-                return false
-              }
-            }
-          }
-        }
-        if (isDef(data)) {
-          var fullInvoke = false;
-          for (var key in data) {
-            if (!isRenderedModule(key)) {
-              fullInvoke = true;
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              break
-            }
+      function invokeInsertHook(vnode, queue, initial) {
+          // delay insert hooks for component root nodes, invoke them after the
+          // element is really inserted
+          if (isTrue(initial) && isDef(vnode.parent)) {
+              vnode.parent.data.pendingInsert = queue;
           }
-          if (!fullInvoke && data['class']) {
-            // ensure collecting deps for deep class bindings for future updates
-            traverse(data['class']);
+          else {
+              for (var i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
+              }
           }
-        }
-      } else if (elm.data !== vnode.text) {
-        elm.data = vnode.text;
       }
-      return true
-    }
-
-    function assertNodeMatch (node, vnode, inVPre) {
-      if (isDef(vnode.tag)) {
-        return vnode.tag.indexOf('vue-component') === 0 || (
-          !isUnknownElement$$1(vnode, inVPre) &&
-          vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-        )
-      } else {
-        return node.nodeType === (vnode.isComment ? 8 : 3)
-      }
-    }
-
-    return function patch (oldVnode, vnode, hydrating, removeOnly) {
-      if (isUndef(vnode)) {
-        if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-        return
+      var hydrationBailed = false;
+      // list of modules that can skip create hook during hydration because they
+      // are already rendered on the client or has no need for initialization
+      // Note: style is excluded because it relies on initial clone for future
+      // deep updates (#7063).
+      var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      // Note: this is a browser-only function so we can assume elms are DOM nodes.
+      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+          var i;
+          var tag = vnode.tag;
+          var data = vnode.data;
+          var children = vnode.children;
+          inVPre = inVPre || (data && data.pre);
+          vnode.elm = elm;
+          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+              vnode.isAsyncPlaceholder = true;
+              return true;
+          }
+          // assert node match
+          {
+              if (!assertNodeMatch(elm, vnode, inVPre)) {
+                  return false;
+              }
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.init)))
+                  { i(vnode, true /* hydrating */); }
+              if (isDef((i = vnode.componentInstance))) {
+                  // child component. it should have hydrated its own tree.
+                  initComponent(vnode, insertedVnodeQueue);
+                  return true;
+              }
+          }
+          if (isDef(tag)) {
+              if (isDef(children)) {
+                  // empty element, allow client to pick up and populate children
+                  if (!elm.hasChildNodes()) {
+                      createChildren(vnode, children, insertedVnodeQueue);
+                  }
+                  else {
+                      // v-html and domProps: innerHTML
+                      if (isDef((i = data)) &&
+                          isDef((i = i.domProps)) &&
+                          isDef((i = i.innerHTML))) {
+                          if (i !== elm.innerHTML) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('server innerHTML: ', i);
+                                  console.warn('client innerHTML: ', elm.innerHTML);
+                              }
+                              return false;
+                          }
+                      }
+                      else {
+                          // iterate and compare children lists
+                          var childrenMatch = true;
+                          var childNode = elm.firstChild;
+                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                              if (!childNode ||
+                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  childrenMatch = false;
+                                  break;
+                              }
+                              childNode = childNode.nextSibling;
+                          }
+                          // if childNode is not null, it means the actual childNodes list is
+                          // longer than the virtual children list.
+                          if (!childrenMatch || childNode) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                              }
+                              return false;
+                          }
+                      }
+                  }
+              }
+              if (isDef(data)) {
+                  var fullInvoke = false;
+                  for (var key in data) {
+                      if (!isRenderedModule(key)) {
+                          fullInvoke = true;
+                          invokeCreateHooks(vnode, insertedVnodeQueue);
+                          break;
+                      }
+                  }
+                  if (!fullInvoke && data['class']) {
+                      // ensure collecting deps for deep class bindings for future updates
+                      traverse(data['class']);
+                  }
+              }
+          }
+          else if (elm.data !== vnode.text) {
+              elm.data = vnode.text;
+          }
+          return true;
+      }
+      function assertNodeMatch(node, vnode, inVPre) {
+          if (isDef(vnode.tag)) {
+              return (vnode.tag.indexOf('vue-component') === 0 ||
+                  (!isUnknownElement$$1(vnode, inVPre) &&
+                      vnode.tag.toLowerCase() ===
+                          (node.tagName && node.tagName.toLowerCase())));
+          }
+          else {
+              return node.nodeType === (vnode.isComment ? 8 : 3);
+          }
       }
-
-      var isInitialPatch = false;
-      var insertedVnodeQueue = [];
-
-      if (isUndef(oldVnode)) {
-        // empty mount (likely as component), create new root element
-        isInitialPatch = true;
-        createElm(vnode, insertedVnodeQueue);
-      } else {
-        var isRealElement = isDef(oldVnode.nodeType);
-        if (!isRealElement && sameVnode(oldVnode, vnode)) {
-          // patch existing root node
-          patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-        } else {
-          if (isRealElement) {
-            // mounting to a real element
-            // check if this is server-rendered content and if we can perform
-            // a successful hydration.
-            if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-              oldVnode.removeAttribute(SSR_ATTR);
-              hydrating = true;
-            }
-            if (isTrue(hydrating)) {
-              if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                invokeInsertHook(vnode, insertedVnodeQueue, true);
-                return oldVnode
-              } else {
-                warn(
-                  'The client-side rendered virtual DOM tree is not matching ' +
-                  'server-rendered content. This is likely caused by incorrect ' +
-                  'HTML markup, for example nesting block-level elements inside ' +
-                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                  'full client-side render.'
-                );
-              }
-            }
-            // either not server-rendered, or hydration failed.
-            // create an empty node and replace it
-            oldVnode = emptyNodeAt(oldVnode);
+      return function patch(oldVnode, vnode, hydrating, removeOnly) {
+          if (isUndef(vnode)) {
+              if (isDef(oldVnode))
+                  { invokeDestroyHook(oldVnode); }
+              return;
           }
-
-          // replacing existing element
-          var oldElm = oldVnode.elm;
-          var parentElm = nodeOps.parentNode(oldElm);
-
-          // create new node
-          createElm(
-            vnode,
-            insertedVnodeQueue,
-            // extremely rare edge case: do not insert if old element is in a
-            // leaving transition. Only happens when combining transition +
-            // keep-alive + HOCs. (#4590)
-            oldElm._leaveCb ? null : parentElm,
-            nodeOps.nextSibling(oldElm)
-          );
-
-          // update parent placeholder node element, recursively
-          if (isDef(vnode.parent)) {
-            var ancestor = vnode.parent;
-            var patchable = isPatchable(vnode);
-            while (ancestor) {
-              for (var i = 0; i < cbs.destroy.length; ++i) {
-                cbs.destroy[i](ancestor);
-              }
-              ancestor.elm = vnode.elm;
-              if (patchable) {
-                for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                  cbs.create[i$1](emptyNode, ancestor);
-                }
-                // #6513
-                // invoke insert hooks that may have been merged by create hooks.
-                // e.g. for directives that uses the "inserted" hook.
-                var insert = ancestor.data.hook.insert;
-                if (insert.merged) {
-                  // start at index 1 to avoid re-invoking component mounted hook
-                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                    insert.fns[i$2]();
+          var isInitialPatch = false;
+          var insertedVnodeQueue = [];
+          if (isUndef(oldVnode)) {
+              // empty mount (likely as component), create new root element
+              isInitialPatch = true;
+              createElm(vnode, insertedVnodeQueue);
+          }
+          else {
+              var isRealElement = isDef(oldVnode.nodeType);
+              if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                  // patch existing root node
+                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+              }
+              else {
+                  if (isRealElement) {
+                      // mounting to a real element
+                      // check if this is server-rendered content and if we can perform
+                      // a successful hydration.
+                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                          oldVnode.removeAttribute(SSR_ATTR);
+                          hydrating = true;
+                      }
+                      if (isTrue(hydrating)) {
+                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                              invokeInsertHook(vnode, insertedVnodeQueue, true);
+                              return oldVnode;
+                          }
+                          else {
+                              warn('The client-side rendered virtual DOM tree is not matching ' +
+                                  'server-rendered content. This is likely caused by incorrect ' +
+                                  'HTML markup, for example nesting block-level elements inside ' +
+                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                  'full client-side render.');
+                          }
+                      }
+                      // either not server-rendered, or hydration failed.
+                      // create an empty node and replace it
+                      oldVnode = emptyNodeAt(oldVnode);
+                  }
+                  // replacing existing element
+                  var oldElm = oldVnode.elm;
+                  var parentElm = nodeOps.parentNode(oldElm);
+                  // create new node
+                  createElm(vnode, insertedVnodeQueue, 
+                  // extremely rare edge case: do not insert if old element is in a
+                  // leaving transition. Only happens when combining transition +
+                  // keep-alive + HOCs. (#4590)
+                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                  // update parent placeholder node element, recursively
+                  if (isDef(vnode.parent)) {
+                      var ancestor = vnode.parent;
+                      var patchable = isPatchable(vnode);
+                      while (ancestor) {
+                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
+                          }
+                          ancestor.elm = vnode.elm;
+                          if (patchable) {
+                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                  cbs.create[i$1](emptyNode, ancestor);
+                              }
+                              // #6513
+                              // invoke insert hooks that may have been merged by create hooks.
+                              // e.g. for directives that uses the "inserted" hook.
+                              var insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
+                                  // start at index 1 to avoid re-invoking component mounted hook
+                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                      insert.fns[i$2]();
+                                  }
+                              }
+                          }
+                          else {
+                              registerRef(ancestor);
+                          }
+                          ancestor = ancestor.parent;
+                      }
+                  }
+                  // destroy old node
+                  if (isDef(parentElm)) {
+                      removeVnodes([oldVnode], 0, 0);
+                  }
+                  else if (isDef(oldVnode.tag)) {
+                      invokeDestroyHook(oldVnode);
                   }
-                }
-              } else {
-                registerRef(ancestor);
               }
-              ancestor = ancestor.parent;
-            }
           }
-
-          // destroy old node
-          if (isDef(parentElm)) {
-            removeVnodes([oldVnode], 0, 0);
-          } else if (isDef(oldVnode.tag)) {
-            invokeDestroyHook(oldVnode);
-          }
-        }
-      }
-
-      invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-      return vnode.elm
-    }
+          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+          return vnode.elm;
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives (vnode) {
-      updateDirectives(vnode, emptyNode);
-    }
+      create: updateDirectives,
+      update: updateDirectives,
+      destroy: function unbindDirectives(vnode) {
+          // @ts-expect-error emptyNode is not VNodeWithData
+          updateDirectives(vnode, emptyNode);
+      },
   };
-
-  function updateDirectives (oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-      _update(oldVnode, vnode);
-    }
-  }
-
-  function _update (oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-
-    var key, oldDir, dir;
-    for (key in newDirs) {
-      oldDir = oldDirs[key];
-      dir = newDirs[key];
-      if (!oldDir) {
-        // new directive, bind
-        callHook$1(dir, 'bind', vnode, oldVnode);
-        if (dir.def && dir.def.inserted) {
-          dirsWithInsert.push(dir);
-        }
-      } else {
-        // existing directive, update
-        dir.oldValue = oldDir.value;
-        dir.oldArg = oldDir.arg;
-        callHook$1(dir, 'update', vnode, oldVnode);
-        if (dir.def && dir.def.componentUpdated) {
-          dirsWithPostpatch.push(dir);
-        }
-      }
-    }
-
-    if (dirsWithInsert.length) {
-      var callInsert = function () {
-        for (var i = 0; i < dirsWithInsert.length; i++) {
-          callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-        }
-      };
-      if (isCreate) {
-        mergeVNodeHook(vnode, 'insert', callInsert);
-      } else {
-        callInsert();
+  function updateDirectives(oldVnode, vnode) {
+      if (oldVnode.data.directives || vnode.data.directives) {
+          _update(oldVnode, vnode);
+      }
+  }
+  function _update(oldVnode, vnode) {
+      var isCreate = oldVnode === emptyNode;
+      var isDestroy = vnode === emptyNode;
+      var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
+      var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+      var dirsWithInsert = [];
+      var dirsWithPostpatch = [];
+      var key, oldDir, dir;
+      for (key in newDirs) {
+          oldDir = oldDirs[key];
+          dir = newDirs[key];
+          if (!oldDir) {
+              // new directive, bind
+              callHook$1(dir, 'bind', vnode, oldVnode);
+              if (dir.def && dir.def.inserted) {
+                  dirsWithInsert.push(dir);
+              }
+          }
+          else {
+              // existing directive, update
+              dir.oldValue = oldDir.value;
+              dir.oldArg = oldDir.arg;
+              callHook$1(dir, 'update', vnode, oldVnode);
+              if (dir.def && dir.def.componentUpdated) {
+                  dirsWithPostpatch.push(dir);
+              }
+          }
       }
-    }
-
-    if (dirsWithPostpatch.length) {
-      mergeVNodeHook(vnode, 'postpatch', function () {
-        for (var i = 0; i < dirsWithPostpatch.length; i++) {
-          callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-        }
-      });
-    }
-
-    if (!isCreate) {
-      for (key in oldDirs) {
-        if (!newDirs[key]) {
-          // no longer present, unbind
-          callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-        }
+      if (dirsWithInsert.length) {
+          var callInsert = function () {
+              for (var i = 0; i < dirsWithInsert.length; i++) {
+                  callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+              }
+          };
+          if (isCreate) {
+              mergeVNodeHook(vnode, 'insert', callInsert);
+          }
+          else {
+              callInsert();
+          }
+      }
+      if (dirsWithPostpatch.length) {
+          mergeVNodeHook(vnode, 'postpatch', function () {
+              for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                  callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+              }
+          });
+      }
+      if (!isCreate) {
+          for (key in oldDirs) {
+              if (!newDirs[key]) {
+                  // no longer present, unbind
+                  callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+              }
+          }
       }
-    }
   }
-
   var emptyModifiers = Object.create(null);
-
-  function normalizeDirectives$1 (
-    dirs,
-    vm
-  ) {
-    var res = Object.create(null);
-    if (!dirs) {
+  function normalizeDirectives$1(dirs, vm) {
+      var res = Object.create(null);
+      if (!dirs) {
+          // $flow-disable-line
+          return res;
+      }
+      var i, dir;
+      for (i = 0; i < dirs.length; i++) {
+          dir = dirs[i];
+          if (!dir.modifiers) {
+              // $flow-disable-line
+              dir.modifiers = emptyModifiers;
+          }
+          res[getRawDirName(dir)] = dir;
+          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+      }
       // $flow-disable-line
-      return res
-    }
-    var i, dir;
-    for (i = 0; i < dirs.length; i++) {
-      dir = dirs[i];
-      if (!dir.modifiers) {
-        // $flow-disable-line
-        dir.modifiers = emptyModifiers;
-      }
-      res[getRawDirName(dir)] = dir;
-      dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res
+      return res;
   }
-
-  function getRawDirName (dir) {
-    return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
+  function getRawDirName(dir) {
+      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
   }
-
-  function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
-    if (fn) {
-      try {
-        fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-      } catch (e) {
-        handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+  function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+      var fn = dir.def && dir.def[hook];
+      if (fn) {
+          try {
+              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+          }
+          catch (e) {
+              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+          }
       }
-    }
   }
 
-  var baseModules = [
-    ref,
-    directives
-  ];
-
-  /*  */
-
-  function updateAttrs (oldVnode, vnode) {
-    var opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-      return
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-      return
-    }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-      attrs = vnode.data.attrs = extend({}, attrs);
-    }
+  var baseModules = [ref, directives];
 
-    for (key in attrs) {
-      cur = attrs[key];
-      old = oldAttrs[key];
-      if (old !== cur) {
-        setAttr(elm, key, cur);
-      }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-      setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-      if (isUndef(attrs[key])) {
-        if (isXlink(key)) {
-          elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        } else if (!isEnumeratedAttr(key)) {
-          elm.removeAttribute(key);
-        }
-      }
-    }
+  /* @flow */
+  function updateAttrs(oldVnode, vnode) {
+      var opts = vnode.componentOptions;
+      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+          return;
+      }
+      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+          return;
+      }
+      var key, cur, old;
+      var elm = vnode.elm;
+      var oldAttrs = oldVnode.data.attrs || {};
+      var attrs = vnode.data.attrs || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(attrs.__ob__)) {
+          attrs = vnode.data.attrs = extend({}, attrs);
+      }
+      for (key in attrs) {
+          cur = attrs[key];
+          old = oldAttrs[key];
+          if (old !== cur) {
+              setAttr(elm, key, cur, vnode.data.pre);
+          }
+      }
+      // #4391: in IE9, setting type can reset value for input[type=radio]
+      // #6666: IE/Edge forces progress value down to 1 before setting a max
+      /* istanbul ignore if */
+      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+          setAttr(elm, 'value', attrs.value);
+      }
+      for (key in oldAttrs) {
+          if (isUndef(attrs[key])) {
+              if (isXlink(key)) {
+                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+              }
+              else if (!isEnumeratedAttr(key)) {
+                  elm.removeAttribute(key);
+              }
+          }
+      }
   }
-
-  function setAttr (el, key, value) {
-    if (el.tagName.indexOf('-') > -1) {
-      baseSetAttr(el, key, value);
-    } else if (isBooleanAttr(key)) {
-      // set attribute for blank value
-      // e.g. <option disabled>Select one</option>
-      if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-      } else {
-        // technically allowfullscreen is a boolean attribute for <iframe>,
-        // but Flash expects a value of "true" when used on <embed> tag
-        value = key === 'allowfullscreen' && el.tagName === 'EMBED'
-          ? 'true'
-          : key;
-        el.setAttribute(key, value);
-      }
-    } else if (isEnumeratedAttr(key)) {
-      el.setAttribute(key, convertEnumeratedValue(key, value));
-    } else if (isXlink(key)) {
-      if (isFalsyAttrValue(value)) {
-        el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else {
-        el.setAttributeNS(xlinkNS, key, value);
+  function setAttr(el, key, value, isInPre) {
+      if (isInPre || el.tagName.indexOf('-') > -1) {
+          baseSetAttr(el, key, value);
+      }
+      else if (isBooleanAttr(key)) {
+          // set attribute for blank value
+          // e.g. <option disabled>Select one</option>
+          if (isFalsyAttrValue(value)) {
+              el.removeAttribute(key);
+          }
+          else {
+              // technically allowfullscreen is a boolean attribute for <iframe>,
+              // but Flash expects a value of "true" when used on <embed> tag
+              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+              el.setAttribute(key, value);
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          el.setAttribute(key, convertEnumeratedValue(key, value));
+      }
+      else if (isXlink(key)) {
+          if (isFalsyAttrValue(value)) {
+              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+          }
+          else {
+              el.setAttributeNS(xlinkNS, key, value);
+          }
+      }
+      else {
+          baseSetAttr(el, key, value);
       }
-    } else {
-      baseSetAttr(el, key, value);
-    }
   }
-
-  function baseSetAttr (el, key, value) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // #7138: IE10 & 11 fires input event when setting placeholder on
-      // <textarea>... block the first input event and remove the blocker
-      // immediately.
-      /* istanbul ignore if */
-      if (
-        isIE && !isIE9 &&
-        el.tagName === 'TEXTAREA' &&
-        key === 'placeholder' && value !== '' && !el.__ieph
-      ) {
-        var blocker = function (e) {
-          e.stopImmediatePropagation();
-          el.removeEventListener('input', blocker);
-        };
-        el.addEventListener('input', blocker);
-        // $flow-disable-line
-        el.__ieph = true; /* IE placeholder patched */
-      }
-      el.setAttribute(key, value);
-    }
+  function baseSetAttr(el, key, value) {
+      if (isFalsyAttrValue(value)) {
+          el.removeAttribute(key);
+      }
+      else {
+          // #7138: IE10 & 11 fires input event when setting placeholder on
+          // <textarea>... block the first input event and remove the blocker
+          // immediately.
+          /* istanbul ignore if */
+          if (isIE &&
+              !isIE9 &&
+              el.tagName === 'TEXTAREA' &&
+              key === 'placeholder' &&
+              value !== '' &&
+              !el.__ieph) {
+              var blocker = function (e) {
+                  e.stopImmediatePropagation();
+                  el.removeEventListener('input', blocker);
+              };
+              el.addEventListener('input', blocker);
+              // $flow-disable-line
+              el.__ieph = true; /* IE placeholder patched */
+          }
+          el.setAttribute(key, value);
+      }
   }
-
   var attrs = {
-    create: updateAttrs,
-    update: updateAttrs
+      create: updateAttrs,
+      update: updateAttrs,
   };
 
-  /*  */
-
-  function updateClass (oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-    if (
-      isUndef(data.staticClass) &&
-      isUndef(data.class) && (
-        isUndef(oldData) || (
-          isUndef(oldData.staticClass) &&
-          isUndef(oldData.class)
-        )
-      )
-    ) {
-      return
-    }
-
-    var cls = genClassForVnode(vnode);
-
-    // handle transition classes
-    var transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-      cls = concat(cls, stringifyClass(transitionClass));
-    }
-
-    // set the class
-    if (cls !== el._prevClass) {
-      el.setAttribute('class', cls);
-      el._prevClass = cls;
-    }
+  /* @flow */
+  function updateClass(oldVnode, vnode) {
+      var el = vnode.elm;
+      var data = vnode.data;
+      var oldData = oldVnode.data;
+      if (isUndef(data.staticClass) &&
+          isUndef(data.class) &&
+          (isUndef(oldData) ||
+              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+          return;
+      }
+      var cls = genClassForVnode(vnode);
+      // handle transition classes
+      var transitionClass = el._transitionClasses;
+      if (isDef(transitionClass)) {
+          cls = concat(cls, stringifyClass(transitionClass));
+      }
+      // set the class
+      if (cls !== el._prevClass) {
+          el.setAttribute('class', cls);
+          el._prevClass = cls;
+      }
   }
-
   var klass = {
-    create: updateClass,
-    update: updateClass
+      create: updateClass,
+      update: updateClass,
   };
 
-  /*  */
+  /* @flow */
 
-  /*  */
+  /* @flow */
 
-  /*  */
-
-  /*  */
+  /* @flow */
 
+  /* @flow */
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
   var CHECKBOX_RADIO_TOKEN = '__c';
 
-  /*  */
-
+  /* @flow */
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
   // the whole point is ensuring the v-model callback gets called before
   // user-attached handlers.
-  function normalizeEvents (on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-      // IE input[type=range] only supports `change` event
-      var event = isIE ? 'change' : 'input';
-      on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-      delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-      on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-      delete on[CHECKBOX_RADIO_TOKEN];
-    }
+  function normalizeEvents(on) {
+      /* istanbul ignore if */
+      if (isDef(on[RANGE_TOKEN])) {
+          // IE input[type=range] only supports `change` event
+          var event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          delete on[RANGE_TOKEN];
+      }
+      // This was originally intended to fix #4521 but no longer necessary
+      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+      /* istanbul ignore if */
+      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+          delete on[CHECKBOX_RADIO_TOKEN];
+      }
   }
-
   var target$1;
-
-  function createOnceHandler$1 (event, handler, capture) {
-    var _target = target$1; // save current target element in closure
-    return function onceHandler () {
-      var res = handler.apply(null, arguments);
-      if (res !== null) {
-        remove$2(event, onceHandler, capture, _target);
-      }
-    }
+  function createOnceHandler$1(event, handler, capture) {
+      var _target = target$1; // save current target element in closure
+      return function onceHandler() {
+          var res = handler.apply(null, arguments);
+          if (res !== null) {
+              remove$2(event, onceHandler, capture, _target);
+          }
+      };
   }
-
   // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
   var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-
-  function add$1 (
-    name,
-    handler,
-    capture,
-    passive
-  ) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-      var attachedTimestamp = currentFlushTimestamp;
-      var original = handler;
-      handler = original._wrapper = function (e) {
-        if (
-          // no bubbling, should always fire.
-          // this is just a safety net in case event.timeStamp is unreliable in
-          // certain weird environments...
-          e.target === e.currentTarget ||
-          // event is fired after handler attachment
-          e.timeStamp >= attachedTimestamp ||
-          // bail for environments that have buggy event.timeStamp implementations
-          // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-          // #9681 QtWebEngine event.timeStamp is negative value
-          e.timeStamp <= 0 ||
-          // #9448 bail if event is fired in another document in a multi-page
-          // electron/nw.js app, since event.timeStamp will be using a different
-          // starting reference
-          e.target.ownerDocument !== document
-        ) {
-          return original.apply(this, arguments)
-        }
-      };
-    }
-    target$1.addEventListener(
-      name,
-      handler,
-      supportsPassive
-        ? { capture: capture, passive: passive }
-        : capture
-    );
+  function add$1(name, handler, capture, passive) {
+      // async edge case #6566: inner click event triggers patch, event handler
+      // attached to outer element during patch, and triggered again. This
+      // happens because browsers fire microtask ticks between event propagation.
+      // the solution is simple: we save the timestamp when a handler is attached,
+      // and the handler would only fire if the event passed to it was fired
+      // AFTER it was attached.
+      if (useMicrotaskFix) {
+          var attachedTimestamp = currentFlushTimestamp;
+          var original = handler;
+          //@ts-expect-error
+          handler = original._wrapper = function (e) {
+              if (
+              // no bubbling, should always fire.
+              // this is just a safety net in case event.timeStamp is unreliable in
+              // certain weird environments...
+              e.target === e.currentTarget ||
+                  // event is fired after handler attachment
+                  e.timeStamp >= attachedTimestamp ||
+                  // bail for environments that have buggy event.timeStamp implementations
+                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                  // #9681 QtWebEngine event.timeStamp is negative value
+                  e.timeStamp <= 0 ||
+                  // #9448 bail if event is fired in another document in a multi-page
+                  // electron/nw.js app, since event.timeStamp will be using a different
+                  // starting reference
+                  e.target.ownerDocument !== document) {
+                  return original.apply(this, arguments);
+              }
+          };
+      }
+      target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
   }
-
-  function remove$2 (
-    name,
-    handler,
-    capture,
-    _target
-  ) {
-    (_target || target$1).removeEventListener(
-      name,
-      handler._wrapper || handler,
-      capture
-    );
+  function remove$2(name, handler, capture, _target) {
+      (_target || target$1).removeEventListener(name, 
+      //@ts-expect-error
+      handler._wrapper || handler, capture);
   }
-
-  function updateDOMListeners (oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-      return
-    }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+  function updateDOMListeners(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+          return;
+      }
+      var on = vnode.data.on || {};
+      var oldOn = oldVnode.data.on || {};
+      target$1 = vnode.elm;
+      normalizeEvents(on);
+      updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
+      target$1 = undefined;
   }
-
   var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners
+      create: updateDOMListeners,
+      update: updateDOMListeners,
   };
 
-  /*  */
-
+  /* @flow */
   var svgContainer;
-
-  function updateDOMProps (oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-      return
-    }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-      props = vnode.data.domProps = extend({}, props);
-    }
-
-    for (key in oldProps) {
-      if (!(key in props)) {
-        elm[key] = '';
+  function updateDOMProps(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+          return;
+      }
+      var key, cur;
+      var elm = vnode.elm;
+      var oldProps = oldVnode.data.domProps || {};
+      var props = vnode.data.domProps || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(props.__ob__)) {
+          props = vnode.data.domProps = extend({}, props);
+      }
+      for (key in oldProps) {
+          if (!(key in props)) {
+              elm[key] = '';
+          }
       }
-    }
-
-    for (key in props) {
-      cur = props[key];
-      // ignore children if the node has textContent or innerHTML,
-      // as these will throw away existing DOM nodes and cause removal errors
-      // on subsequent patches (#3360)
-      if (key === 'textContent' || key === 'innerHTML') {
-        if (vnode.children) { vnode.children.length = 0; }
-        if (cur === oldProps[key]) { continue }
-        // #6601 work around Chrome version <= 55 bug where single textNode
-        // replaced by innerHTML/textContent retains its parentNode property
-        if (elm.childNodes.length === 1) {
-          elm.removeChild(elm.childNodes[0]);
-        }
+      for (key in props) {
+          cur = props[key];
+          // ignore children if the node has textContent or innerHTML,
+          // as these will throw away existing DOM nodes and cause removal errors
+          // on subsequent patches (#3360)
+          if (key === 'textContent' || key === 'innerHTML') {
+              if (vnode.children)
+                  { vnode.children.length = 0; }
+              if (cur === oldProps[key])
+                  { continue; }
+              // #6601 work around Chrome version <= 55 bug where single textNode
+              // replaced by innerHTML/textContent retains its parentNode property
+              if (elm.childNodes.length === 1) {
+                  elm.removeChild(elm.childNodes[0]);
+              }
+          }
+          if (key === 'value' && elm.tagName !== 'PROGRESS') {
+              // store value as _value as well since
+              // non-string values will be stringified
+              elm._value = cur;
+              // avoid resetting cursor position when value is the same
+              var strCur = isUndef(cur) ? '' : String(cur);
+              if (shouldUpdateValue(elm, strCur)) {
+                  elm.value = strCur;
+              }
+          }
+          else if (key === 'innerHTML' &&
+              isSVG(elm.tagName) &&
+              isUndef(elm.innerHTML)) {
+              // IE doesn't support innerHTML for SVG elements
+              svgContainer = svgContainer || document.createElement('div');
+              svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+              var svg = svgContainer.firstChild;
+              while (elm.firstChild) {
+                  elm.removeChild(elm.firstChild);
+              }
+              while (svg.firstChild) {
+                  elm.appendChild(svg.firstChild);
+              }
+          }
+          else if (
+          // skip the update if old and new VDOM state is the same.
+          // `value` is handled separately because the DOM value may be temporarily
+          // out of sync with VDOM state due to focus, composition and modifiers.
+          // This  #4521 by skipping the unnecessary `checked` update.
+          cur !== oldProps[key]) {
+              // some property updates can throw
+              // e.g. `value` on <progress> w/ non-finite value
+              try {
+                  elm[key] = cur;
+              }
+              catch (e) { }
+          }
       }
-
-      if (key === 'value' && elm.tagName !== 'PROGRESS') {
-        // store value as _value as well since
-        // non-string values will be stringified
-        elm._value = cur;
-        // avoid resetting cursor position when value is the same
-        var strCur = isUndef(cur) ? '' : String(cur);
-        if (shouldUpdateValue(elm, strCur)) {
-          elm.value = strCur;
-        }
-      } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {
-        // IE doesn't support innerHTML for SVG elements
-        svgContainer = svgContainer || document.createElement('div');
-        svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-        var svg = svgContainer.firstChild;
-        while (elm.firstChild) {
-          elm.removeChild(elm.firstChild);
-        }
-        while (svg.firstChild) {
-          elm.appendChild(svg.firstChild);
-        }
-      } else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]
-      ) {
-        // some property updates can throw
-        // e.g. `value` on <progress> w/ non-finite value
-        try {
-          elm[key] = cur;
-        } catch (e) {}
-      }
-    }
-  }
-
-  // check platforms/web/util/attrs.js acceptValue
-
-
-  function shouldUpdateValue (elm, checkVal) {
-    return (!elm.composing && (
-      elm.tagName === 'OPTION' ||
-      isNotInFocusAndDirty(elm, checkVal) ||
-      isDirtyWithModifiers(elm, checkVal)
-    ))
-  }
-
-  function isNotInFocusAndDirty (elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    var notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try { notInFocus = document.activeElement !== elm; } catch (e) {}
-    return notInFocus && elm.value !== checkVal
   }
-
-  function isDirtyWithModifiers (elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-      if (modifiers.number) {
-        return toNumber(value) !== toNumber(newVal)
+  function shouldUpdateValue(elm, checkVal) {
+      return (
+      //@ts-expect-error
+      !elm.composing &&
+          (elm.tagName === 'OPTION' ||
+              isNotInFocusAndDirty(elm, checkVal) ||
+              isDirtyWithModifiers(elm, checkVal)));
+  }
+  function isNotInFocusAndDirty(elm, checkVal) {
+      // return true when textbox (.number and .trim) loses focus and its value is
+      // not equal to the updated value
+      var notInFocus = true;
+      // #6157
+      // work around IE bug when accessing document.activeElement in an iframe
+      try {
+          notInFocus = document.activeElement !== elm;
       }
-      if (modifiers.trim) {
-        return value.trim() !== newVal.trim()
+      catch (e) { }
+      return notInFocus && elm.value !== checkVal;
+  }
+  function isDirtyWithModifiers(elm, newVal) {
+      var value = elm.value;
+      var modifiers = elm._vModifiers; // injected by v-model runtime
+      if (isDef(modifiers)) {
+          if (modifiers.number) {
+              return toNumber(value) !== toNumber(newVal);
+          }
+          if (modifiers.trim) {
+              return value.trim() !== newVal.trim();
+          }
       }
-    }
-    return value !== newVal
+      return value !== newVal;
   }
-
   var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps
+      create: updateDOMProps,
+      update: updateDOMProps,
   };
 
-  /*  */
-
+  /* @flow */
   var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res
+      var res = {};
+      var listDelimiter = /;(?![^(]*\))/g;
+      var propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              var tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
   });
-
   // merge static and dynamic style data on the same vnode
-  function normalizeStyleData (data) {
-    var style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle
-      ? extend(data.staticStyle, style)
-      : style
+  function normalizeStyleData(data) {
+      var style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
   }
-
   // normalize possible array / string values into Object
-  function normalizeStyleBinding (bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-      return toObject(bindingStyle)
-    }
-    if (typeof bindingStyle === 'string') {
-      return parseStyleText(bindingStyle)
-    }
-    return bindingStyle
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
   }
-
   /**
    * parent component style should be after child's
    * so that parent component's style could override it
    */
-  function getStyle (vnode, checkChild) {
-    var res = {};
-    var styleData;
-
-    if (checkChild) {
-      var childNode = vnode;
-      while (childNode.componentInstance) {
-        childNode = childNode.componentInstance._vnode;
-        if (
-          childNode && childNode.data &&
-          (styleData = normalizeStyleData(childNode.data))
-        ) {
+  function getStyle(vnode, checkChild) {
+      var res = {};
+      var styleData;
+      if (checkChild) {
+          var childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
-        }
       }
-    }
-
-    if ((styleData = normalizeStyleData(vnode.data))) {
-      extend(res, styleData);
-    }
-
-    var parentNode = vnode;
-    while ((parentNode = parentNode.parent)) {
-      if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-        extend(res, styleData);
+      var parentNode = vnode;
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
       }
-    }
-    return res
+      return res;
   }
 
-  /*  */
-
+  /* @flow */
   var cssVarRE = /^--/;
   var importantRE = /\s*!important$/;
   var setProp = function (el, name, val) {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-      el.style.setProperty(name, val);
-    } else if (importantRE.test(val)) {
-      el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    } else {
-      var normalizedName = normalize(name);
-      if (Array.isArray(val)) {
-        // Support values array created by autoprefixer, e.g.
-        // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-        // Set them one by one, and the browser will only set those it can recognize
-        for (var i = 0, len = val.length; i < len; i++) {
-          el.style[normalizedName] = val[i];
-        }
-      } else {
-        el.style[normalizedName] = val;
-      }
-    }
+      /* istanbul ignore if */
+      if (cssVarRE.test(name)) {
+          el.style.setProperty(name, val);
+      }
+      else if (importantRE.test(val)) {
+          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+      }
+      else {
+          var normalizedName = normalize(name);
+          if (Array.isArray(val)) {
+              // Support values array created by autoprefixer, e.g.
+              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+              // Set them one by one, and the browser will only set those it can recognize
+              for (var i = 0, len = val.length; i < len; i++) {
+                  el.style[normalizedName] = val[i];
+              }
+          }
+          else {
+              el.style[normalizedName] = val;
+          }
+      }
   };
-
   var vendorNames = ['Webkit', 'Moz', 'ms'];
-
   var emptyStyle;
   var normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && (prop in emptyStyle)) {
-      return prop
-    }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-      var name = vendorNames[i] + capName;
-      if (name in emptyStyle) {
-        return name
-      }
-    }
+      emptyStyle = emptyStyle || document.createElement('div').style;
+      prop = camelize(prop);
+      if (prop !== 'filter' && prop in emptyStyle) {
+          return prop;
+      }
+      var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (var i = 0; i < vendorNames.length; i++) {
+          var name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
+          }
+      }
   });
-
-  function updateStyle (oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-
-    if (isUndef(data.staticStyle) && isUndef(data.style) &&
-      isUndef(oldData.staticStyle) && isUndef(oldData.style)
-    ) {
-      return
-    }
-
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-
-    var style = normalizeStyleBinding(vnode.data.style) || {};
-
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__)
-      ? extend({}, style)
-      : style;
-
-    var newStyle = getStyle(vnode, true);
-
-    for (name in oldStyle) {
-      if (isUndef(newStyle[name])) {
-        setProp(el, name, '');
+  function updateStyle(oldVnode, vnode) {
+      var data = vnode.data;
+      var oldData = oldVnode.data;
+      if (isUndef(data.staticStyle) &&
+          isUndef(data.style) &&
+          isUndef(oldData.staticStyle) &&
+          isUndef(oldData.style)) {
+          return;
+      }
+      var cur, name;
+      var el = vnode.elm;
+      var oldStaticStyle = oldData.staticStyle;
+      var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+      var oldStyle = oldStaticStyle || oldStyleBinding;
+      var style = normalizeStyleBinding(vnode.data.style) || {};
+      // store normalized style under a different key for next diff
+      // make sure to clone it if it's reactive, since the user likely wants
+      // to mutate it.
+      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+      var newStyle = getStyle(vnode, true);
+      for (name in oldStyle) {
+          if (isUndef(newStyle[name])) {
+              setProp(el, name, '');
+          }
       }
-    }
-    for (name in newStyle) {
-      cur = newStyle[name];
-      if (cur !== oldStyle[name]) {
-        // ie9 setting to null has no effect, must use empty string
-        setProp(el, name, cur == null ? '' : cur);
+      for (name in newStyle) {
+          cur = newStyle[name];
+          if (cur !== oldStyle[name]) {
+              // ie9 setting to null has no effect, must use empty string
+              setProp(el, name, cur == null ? '' : cur);
+          }
       }
-    }
   }
-
   var style = {
-    create: updateStyle,
-    update: updateStyle
+      create: updateStyle,
+      update: updateStyle,
   };
 
-  /*  */
-
+  /* @flow */
   var whitespaceRE = /\s+/;
-
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function addClass (el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-      return
-    }
-
-    /* istanbul ignore else */
-    if (el.classList) {
-      if (cls.indexOf(' ') > -1) {
-        cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-      } else {
-        el.classList.add(cls);
+  function addClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+          }
+          else {
+              el.classList.add(cls);
+          }
       }
-    } else {
-      var cur = " " + (el.getAttribute('class') || '') + " ";
-      if (cur.indexOf(' ' + cls + ' ') < 0) {
-        el.setAttribute('class', (cur + cls).trim());
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
       }
-    }
   }
-
   /**
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function removeClass (el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-      return
-    }
-
-    /* istanbul ignore else */
-    if (el.classList) {
-      if (cls.indexOf(' ') > -1) {
-        cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-      } else {
-        el.classList.remove(cls);
-      }
-      if (!el.classList.length) {
-        el.removeAttribute('class');
-      }
-    } else {
-      var cur = " " + (el.getAttribute('class') || '') + " ";
-      var tar = ' ' + cls + ' ';
-      while (cur.indexOf(tar) >= 0) {
-        cur = cur.replace(tar, ' ');
-      }
-      cur = cur.trim();
-      if (cur) {
-        el.setAttribute('class', cur);
-      } else {
-        el.removeAttribute('class');
-      }
-    }
+  function removeClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          var tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
+      }
   }
 
-  /*  */
-
-  function resolveTransition (def$$1) {
-    if (!def$$1) {
-      return
-    }
-    /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
-      var res = {};
-      if (def$$1.css !== false) {
-        extend(res, autoCssTransition(def$$1.name || 'v'));
+  function resolveTransition(def$$1) {
+      if (!def$$1) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def$$1 === 'object') {
+          var res = {};
+          if (def$$1.css !== false) {
+              extend(res, autoCssTransition(def$$1.name || 'v'));
+          }
+          extend(res, def$$1);
+          return res;
+      }
+      else if (typeof def$$1 === 'string') {
+          return autoCssTransition(def$$1);
       }
-      extend(res, def$$1);
-      return res
-    } else if (typeof def$$1 === 'string') {
-      return autoCssTransition(def$$1)
-    }
   }
-
   var autoCssTransition = cached(function (name) {
-    return {
-      enterClass: (name + "-enter"),
-      enterToClass: (name + "-enter-to"),
-      enterActiveClass: (name + "-enter-active"),
-      leaveClass: (name + "-leave"),
-      leaveToClass: (name + "-leave-to"),
-      leaveActiveClass: (name + "-leave-active")
-    }
+      return {
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
+      };
   });
-
   var hasTransition = inBrowser && !isIE9;
   var TRANSITION = 'transition';
   var ANIMATION = 'animation';
-
   // Transition property/event sniffing
   var transitionProp = 'transition';
   var transitionEndEvent = 'transitionend';
   var animationProp = 'animation';
   var animationEndEvent = 'animationend';
   if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-      window.onwebkittransitionend !== undefined
-    ) {
-      transitionProp = 'WebkitTransition';
-      transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-      window.onwebkitanimationend !== undefined
-    ) {
-      animationProp = 'WebkitAnimation';
-      animationEndEvent = 'webkitAnimationEnd';
-    }
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          // @ts-expect-error
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          // @ts-expect-error
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
   }
-
   // binding to window is necessary to make hot reload work in IE in strict mode
   var raf = inBrowser
-    ? window.requestAnimationFrame
-      ? window.requestAnimationFrame.bind(window)
-      : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-
-  function nextFrame (fn) {
-    raf(function () {
-      raf(fn);
-    });
-  }
-
-  function addTransitionClass (el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-      transitionClasses.push(cls);
-      addClass(el, cls);
-    }
-  }
-
-  function removeTransitionClass (el, cls) {
-    if (el._transitionClasses) {
-      remove(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-  }
-
-  function whenTransitionEnds (
-    el,
-    expectedType,
-    cb
-  ) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type) { return cb() }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-      el.removeEventListener(event, onEnd);
-      cb();
-    };
-    var onEnd = function (e) {
-      if (e.target === el) {
-        if (++ended >= propCount) {
-          end();
-        }
-      }
-    };
-    setTimeout(function () {
-      if (ended < propCount) {
-        end();
-      }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-  }
-
-  var transformRE = /\b(transform|all)(,|$)/;
-
-  function getTransitionInfo (el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-      if (transitionTimeout > 0) {
-        type = TRANSITION;
-        timeout = transitionTimeout;
-        propCount = transitionDurations.length;
-      }
-    } else if (expectedType === ANIMATION) {
-      if (animationTimeout > 0) {
-        type = ANIMATION;
-        timeout = animationTimeout;
-        propCount = animationDurations.length;
-      }
-    } else {
-      timeout = Math.max(transitionTimeout, animationTimeout);
-      type = timeout > 0
-        ? transitionTimeout > animationTimeout
-          ? TRANSITION
-          : ANIMATION
-        : null;
-      propCount = type
-        ? type === TRANSITION
-          ? transitionDurations.length
-          : animationDurations.length
-        : 0;
-    }
-    var hasTransform =
-      type === TRANSITION &&
-      transformRE.test(styles[transitionProp + 'Property']);
-    return {
-      type: type,
-      timeout: timeout,
-      propCount: propCount,
-      hasTransform: hasTransform
-    }
-  }
-
-  function getTimeout (delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-      delays = delays.concat(delays);
-    }
-
-    return Math.max.apply(null, durations.map(function (d, i) {
-      return toMs(d) + toMs(delays[i])
-    }))
-  }
-
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs (s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000
-  }
-
-  /*  */
-
-  function enter (vnode, toggleDisplay) {
-    var el = vnode.elm;
-
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-      el._leaveCb.cancelled = true;
-      el._leaveCb();
-    }
-
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-      return
-    }
-
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-      return
-    }
-
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-      context = transitionNode.context;
-      transitionNode = transitionNode.parent;
-    }
-
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-    if (isAppear && !appear && appear !== '') {
-      return
-    }
-
-    var startClass = isAppear && appearClass
-      ? appearClass
-      : enterClass;
-    var activeClass = isAppear && appearActiveClass
-      ? appearActiveClass
-      : enterActiveClass;
-    var toClass = isAppear && appearToClass
-      ? appearToClass
-      : enterToClass;
-
-    var beforeEnterHook = isAppear
-      ? (beforeAppear || beforeEnter)
-      : beforeEnter;
-    var enterHook = isAppear
-      ? (typeof appear === 'function' ? appear : enter)
-      : enter;
-    var afterEnterHook = isAppear
-      ? (afterAppear || afterEnter)
-      : afterEnter;
-    var enterCancelledHook = isAppear
-      ? (appearCancelled || enterCancelled)
-      : enterCancelled;
-
-    var explicitEnterDuration = toNumber(
-      isObject(duration)
-        ? duration.enter
-        : duration
-    );
-
-    if (explicitEnterDuration != null) {
-      checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-
-    var cb = el._enterCb = once(function () {
-      if (expectsCSS) {
-        removeTransitionClass(el, toClass);
-        removeTransitionClass(el, activeClass);
-      }
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, startClass);
-        }
-        enterCancelledHook && enterCancelledHook(el);
-      } else {
-        afterEnterHook && afterEnterHook(el);
-      }
-      el._enterCb = null;
-    });
-
-    if (!vnode.data.show) {
-      // remove pending leave element on enter by injecting an insert hook
-      mergeVNodeHook(vnode, 'insert', function () {
-        var parent = el.parentNode;
-        var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-        if (pendingNode &&
-          pendingNode.tag === vnode.tag &&
-          pendingNode.elm._leaveCb
-        ) {
-          pendingNode.elm._leaveCb();
-        }
-        enterHook && enterHook(el, cb);
-      });
-    }
-
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-      addTransitionClass(el, startClass);
-      addTransitionClass(el, activeClass);
-      nextFrame(function () {
-        removeTransitionClass(el, startClass);
-        if (!cb.cancelled) {
-          addTransitionClass(el, toClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitEnterDuration)) {
-              setTimeout(cb, explicitEnterDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ function (fn) { return fn(); };
+  function nextFrame(fn) {
+      raf(function () {
+          // @ts-expect-error
+          raf(fn);
       });
-    }
-
-    if (vnode.data.show) {
-      toggleDisplay && toggleDisplay();
-      enterHook && enterHook(el, cb);
-    }
-
-    if (!expectsCSS && !userWantsControl) {
-      cb();
-    }
   }
-
-  function leave (vnode, rm) {
-    var el = vnode.elm;
-
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-      el._enterCb.cancelled = true;
-      el._enterCb();
-    }
-
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-      return rm()
-    }
-
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-      return
-    }
-
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-
-    var explicitLeaveDuration = toNumber(
-      isObject(duration)
-        ? duration.leave
-        : duration
-    );
-
-    if (isDef(explicitLeaveDuration)) {
-      checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-
-    var cb = el._leaveCb = once(function () {
-      if (el.parentNode && el.parentNode._pending) {
-        el.parentNode._pending[vnode.key] = null;
+  function addTransitionClass(el, cls) {
+      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
+  }
+  function removeTransitionClass(el, cls) {
+      if (el._transitionClasses) {
+          remove(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
+  }
+  function whenTransitionEnds(el, expectedType, cb) {
+      var ref = getTransitionInfo(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
+      if (!type)
+          { return cb(); }
+      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var ended = 0;
+      var end = function () {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      var onEnd = function (e) {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(function () {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
+  }
+  var transformRE = /\b(transform|all)(,|$)/;
+  function getTransitionInfo(el, expectedType) {
+      var styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var type;
+      var timeout = 0;
+      var propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
       }
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveToClass);
-        removeTransitionClass(el, leaveActiveClass);
-      }
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, leaveClass);
-        }
-        leaveCancelled && leaveCancelled(el);
-      } else {
-        rm();
-        afterLeave && afterLeave(el);
-      }
-      el._leaveCb = null;
-    });
-
-    if (delayLeave) {
-      delayLeave(performLeave);
-    } else {
-      performLeave();
-    }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type: type,
+          timeout: timeout,
+          propCount: propCount,
+          hasTransform: hasTransform,
+      };
+  }
+  function getTimeout(delays, durations) {
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map(function (d, i) {
+          return toMs(d) + toMs(delays[i]);
+      }));
+  }
+  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+  // in a locale-dependent way, using a comma instead of a dot.
+  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+  // as a floor function) causing unexpected behaviors
+  function toMs(s) {
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+  }
 
-    function performLeave () {
-      // the delayed leave may have already been cancelled
-      if (cb.cancelled) {
-        return
+  /* @flow */
+  function enter(vnode, toggleDisplay) {
+      var el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
       }
-      // record leaving element
-      if (!vnode.data.show && el.parentNode) {
-        (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
       }
-      beforeLeave && beforeLeave(el);
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      var context = activeInstance;
+      var transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      var startClass = isAppear && appearClass ? appearClass : enterClass;
+      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      var enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      var enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(enterHook);
+      var cb = (el._enterCb = once(function () {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', function () {
+              var parent = el.parentNode;
+              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
+      }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
       if (expectsCSS) {
-        addTransitionClass(el, leaveClass);
-        addTransitionClass(el, leaveActiveClass);
-        nextFrame(function () {
-          removeTransitionClass(el, leaveClass);
-          if (!cb.cancelled) {
-            addTransitionClass(el, leaveToClass);
-            if (!userWantsControl) {
-              if (isValidDuration(explicitLeaveDuration)) {
-                setTimeout(cb, explicitLeaveDuration);
-              } else {
-                whenTransitionEnds(el, type, cb);
-              }
-            }
-          }
-        });
-      }
-      leave && leave(el, cb);
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(function () {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
       if (!expectsCSS && !userWantsControl) {
-        cb();
+          cb();
+      }
+  }
+  function leave(vnode, rm) {
+      var el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
+      }
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
+      }
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(leave);
+      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      var cb = (el._leaveCb = once(function () {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
+              }
+              leaveCancelled && leaveCancelled(el);
+          }
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
+      }
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(function () {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
       }
-    }
   }
-
   // only used in dev mode
-  function checkDuration (val, name, vnode) {
-    if (typeof val !== 'number') {
-      warn(
-        "<transition> explicit " + name + " duration is not a valid number - " +
-        "got " + (JSON.stringify(val)) + ".",
-        vnode.context
-      );
-    } else if (isNaN(val)) {
-      warn(
-        "<transition> explicit " + name + " duration is NaN - " +
-        'the duration expression might be incorrect.',
-        vnode.context
-      );
-    }
+  function checkDuration(val, name, vnode) {
+      if (typeof val !== 'number') {
+          warn("<transition> explicit " + name + " duration is not a valid number - " +
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn("<transition> explicit " + name + " duration is NaN - " +
+              'the duration expression might be incorrect.', vnode.context);
+      }
   }
-
-  function isValidDuration (val) {
-    return typeof val === 'number' && !isNaN(val)
+  function isValidDuration(val) {
+      return typeof val === 'number' && !isNaN(val);
   }
-
   /**
    * Normalize a transition hook's argument length. The hook may be:
    * - a merged hook (invoker) with the original in .fns
    * - a wrapped component method (check ._length)
    * - a plain function (.length)
    */
-  function getHookArgumentsLength (fn) {
-    if (isUndef(fn)) {
-      return false
-    }
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-      // invoker
-      return getHookArgumentsLength(
-        Array.isArray(invokerFns)
-          ? invokerFns[0]
-          : invokerFns
-      )
-    } else {
-      return (fn._length || fn.length) > 1
-    }
-  }
-
-  function _enter (_, vnode) {
-    if (vnode.data.show !== true) {
-      enter(vnode);
-    }
+  function getHookArgumentsLength(fn) {
+      if (isUndef(fn)) {
+          return false;
+      }
+      // @ts-expect-error
+      var invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
   }
-
-  var transition = inBrowser ? {
-    create: _enter,
-    activate: _enter,
-    remove: function remove$$1 (vnode, rm) {
-      /* istanbul ignore else */
+  function _enter(_, vnode) {
       if (vnode.data.show !== true) {
-        leave(vnode, rm);
-      } else {
-        rm();
+          enter(vnode);
+      }
+  }
+  var transition = inBrowser
+      ? {
+          create: _enter,
+          activate: _enter,
+          remove: function remove$$1(vnode, rm) {
+              /* istanbul ignore else */
+              if (vnode.data.show !== true) {
+                  // @ts-expect-error
+                  leave(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          },
       }
-    }
-  } : {};
+      : {};
 
-  var platformModules = [
-    attrs,
-    klass,
-    events,
-    domProps,
-    style,
-    transition
-  ];
-
-  /*  */
+  var platformModules = [attrs, klass, events, domProps, style, transition];
 
+  /* @flow */
   // the directive module should be applied last, after all
   // built-in modules have been applied.
   var modules = platformModules.concat(baseModules);
-
   var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 
   /**
    * Not type checking this file because flow doesn't like attaching
    * properties to Elements.
    */
-
   /* istanbul ignore if */
   if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-      var el = document.activeElement;
-      if (el && el.vmodel) {
-        trigger(el, 'input');
-      }
-    });
+      // http://www.matts411.com/post/internet-explorer-9-oninput/
+      document.addEventListener('selectionchange', function () {
+          var el = document.activeElement;
+          // @ts-expect-error
+          if (el && el.vmodel) {
+              trigger(el, 'input');
+          }
+      });
   }
-
   var directive = {
-    inserted: function inserted (el, binding, vnode, oldVnode) {
-      if (vnode.tag === 'select') {
-        // #6903
-        if (oldVnode.elm && !oldVnode.elm._vOptions) {
-          mergeVNodeHook(vnode, 'postpatch', function () {
-            directive.componentUpdated(el, binding, vnode);
-          });
-        } else {
-          setSelected(el, binding, vnode.context);
-        }
-        el._vOptions = [].map.call(el.options, getValue);
-      } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-        el._vModifiers = binding.modifiers;
-        if (!binding.modifiers.lazy) {
-          el.addEventListener('compositionstart', onCompositionStart);
-          el.addEventListener('compositionend', onCompositionEnd);
-          // Safari < 10.2 & UIWebView doesn't fire compositionend when
-          // switching focus before confirming composition choice
-          // this also fixes the issue where some browsers e.g. iOS Chrome
-          // fires "change" instead of "input" on autocomplete.
-          el.addEventListener('change', onCompositionEnd);
-          /* istanbul ignore if */
-          if (isIE9) {
-            el.vmodel = true;
+      inserted: function inserted(el, binding, vnode, oldVnode) {
+          if (vnode.tag === 'select') {
+              // #6903
+              if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                  mergeVNodeHook(vnode, 'postpatch', function () {
+                      directive.componentUpdated(el, binding, vnode);
+                  });
+              }
+              else {
+                  setSelected(el, binding, vnode.context);
+              }
+              el._vOptions = [].map.call(el.options, getValue);
           }
-        }
-      }
-    },
-
-    componentUpdated: function componentUpdated (el, binding, vnode) {
-      if (vnode.tag === 'select') {
-        setSelected(el, binding, vnode.context);
-        // in case the options rendered by v-for have changed,
-        // it's possible that the value is out-of-sync with the rendered options.
-        // detect such cases and filter out values that no longer has a matching
-        // option in the DOM.
-        var prevOptions = el._vOptions;
-        var curOptions = el._vOptions = [].map.call(el.options, getValue);
-        if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-          // trigger change event if
-          // no matching option found for at least one value
-          var needReset = el.multiple
-            ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-            : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);
-          if (needReset) {
-            trigger(el, 'change');
-          }
-        }
-      }
-    }
+          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+              el._vModifiers = binding.modifiers;
+              if (!binding.modifiers.lazy) {
+                  el.addEventListener('compositionstart', onCompositionStart);
+                  el.addEventListener('compositionend', onCompositionEnd);
+                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                  // switching focus before confirming composition choice
+                  // this also fixes the issue where some browsers e.g. iOS Chrome
+                  // fires "change" instead of "input" on autocomplete.
+                  el.addEventListener('change', onCompositionEnd);
+                  /* istanbul ignore if */
+                  if (isIE9) {
+                      el.vmodel = true;
+                  }
+              }
+          }
+      },
+      componentUpdated: function componentUpdated(el, binding, vnode) {
+          if (vnode.tag === 'select') {
+              setSelected(el, binding, vnode.context);
+              // in case the options rendered by v-for have changed,
+              // it's possible that the value is out-of-sync with the rendered options.
+              // detect such cases and filter out values that no longer has a matching
+              // option in the DOM.
+              var prevOptions = el._vOptions;
+              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                  // trigger change event if
+                  // no matching option found for at least one value
+                  var needReset = el.multiple
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                      : binding.value !== binding.oldValue &&
+                          hasNoMatchingOption(binding.value, curOptions);
+                  if (needReset) {
+                      trigger(el, 'change');
+                  }
+              }
+          }
+      },
   };
-
-  function setSelected (el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-      setTimeout(function () {
-        actuallySetSelected(el, binding, vm);
-      }, 0);
-    }
-  }
-
-  function actuallySetSelected (el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-      warn(
-        "<select multiple v-model=\"" + (binding.expression) + "\"> " +
-        "expects an Array value for its binding, but got " + (Object.prototype.toString.call(value).slice(8, -1)),
-        vm
-      );
-      return
-    }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
-      option = el.options[i];
-      if (isMultiple) {
-        selected = looseIndexOf(value, getValue(option)) > -1;
-        if (option.selected !== selected) {
-          option.selected = selected;
-        }
-      } else {
-        if (looseEqual(getValue(option), value)) {
-          if (el.selectedIndex !== i) {
-            el.selectedIndex = i;
-          }
-          return
-        }
-      }
-    }
-    if (!isMultiple) {
-      el.selectedIndex = -1;
-    }
+  function setSelected(el, binding, vm) {
+      actuallySetSelected(el, binding, vm);
+      /* istanbul ignore if */
+      if (isIE || isEdge) {
+          setTimeout(function () {
+              actuallySetSelected(el, binding, vm);
+          }, 0);
+      }
+  }
+  function actuallySetSelected(el, binding, vm) {
+      var value = binding.value;
+      var isMultiple = el.multiple;
+      if (isMultiple && !Array.isArray(value)) {
+          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                  "expects an Array value for its binding, but got " + (Object.prototype.toString
+                      .call(value)
+                      .slice(8, -1)), vm);
+          return;
+      }
+      var selected, option;
+      for (var i = 0, l = el.options.length; i < l; i++) {
+          option = el.options[i];
+          if (isMultiple) {
+              selected = looseIndexOf(value, getValue(option)) > -1;
+              if (option.selected !== selected) {
+                  option.selected = selected;
+              }
+          }
+          else {
+              if (looseEqual(getValue(option), value)) {
+                  if (el.selectedIndex !== i) {
+                      el.selectedIndex = i;
+                  }
+                  return;
+              }
+          }
+      }
+      if (!isMultiple) {
+          el.selectedIndex = -1;
+      }
   }
-
-  function hasNoMatchingOption (value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); })
+  function hasNoMatchingOption(value, options) {
+      return options.every(function (o) { return !looseEqual(o, value); });
   }
-
-  function getValue (option) {
-    return '_value' in option
-      ? option._value
-      : option.value
+  function getValue(option) {
+      return '_value' in option ? option._value : option.value;
   }
-
-  function onCompositionStart (e) {
-    e.target.composing = true;
+  function onCompositionStart(e) {
+      e.target.composing = true;
   }
-
-  function onCompositionEnd (e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing) { return }
-    e.target.composing = false;
-    trigger(e.target, 'input');
+  function onCompositionEnd(e) {
+      // prevent triggering an input event for no reason
+      if (!e.target.composing)
+          { return; }
+      e.target.composing = false;
+      trigger(e.target, 'input');
   }
-
-  function trigger (el, type) {
-    var e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+  function trigger(el, type) {
+      var e = document.createEvent('HTMLEvents');
+      e.initEvent(type, true, true);
+      el.dispatchEvent(e);
   }
 
-  /*  */
-
+  /* @flow */
   // recursively search for possible transition defined inside the component root
-  function locateNode (vnode) {
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-      ? locateNode(vnode.componentInstance._vnode)
-      : vnode
+  function locateNode(vnode) {
+      // @ts-expect-error
+      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+          ? locateNode(vnode.componentInstance._vnode)
+          : vnode;
   }
-
   var show = {
-    bind: function bind (el, ref, vnode) {
-      var value = ref.value;
-
-      vnode = locateNode(vnode);
-      var transition$$1 = vnode.data && vnode.data.transition;
-      var originalDisplay = el.__vOriginalDisplay =
-        el.style.display === 'none' ? '' : el.style.display;
-      if (value && transition$$1) {
-        vnode.data.show = true;
-        enter(vnode, function () {
-          el.style.display = originalDisplay;
-        });
-      } else {
-        el.style.display = value ? originalDisplay : 'none';
-      }
-    },
-
-    update: function update (el, ref, vnode) {
-      var value = ref.value;
-      var oldValue = ref.oldValue;
-
-      /* istanbul ignore if */
-      if (!value === !oldValue) { return }
-      vnode = locateNode(vnode);
-      var transition$$1 = vnode.data && vnode.data.transition;
-      if (transition$$1) {
-        vnode.data.show = true;
-        if (value) {
-          enter(vnode, function () {
-            el.style.display = el.__vOriginalDisplay;
-          });
-        } else {
-          leave(vnode, function () {
-            el.style.display = 'none';
-          });
-        }
-      } else {
-        el.style.display = value ? el.__vOriginalDisplay : 'none';
-      }
-    },
+      bind: function bind(el, ref, vnode) {
+          var value = ref.value;
+
+          vnode = locateNode(vnode);
+          var transition$$1 = vnode.data && vnode.data.transition;
+          var originalDisplay = (el.__vOriginalDisplay =
+              el.style.display === 'none' ? '' : el.style.display);
+          if (value && transition$$1) {
+              vnode.data.show = true;
+              enter(vnode, function () {
+                  el.style.display = originalDisplay;
+              });
+          }
+          else {
+              el.style.display = value ? originalDisplay : 'none';
+          }
+      },
+      update: function update(el, ref, vnode) {
+          var value = ref.value;
+          var oldValue = ref.oldValue;
 
-    unbind: function unbind (
-      el,
-      binding,
-      vnode,
-      oldVnode,
-      isDestroy
-    ) {
-      if (!isDestroy) {
-        el.style.display = el.__vOriginalDisplay;
-      }
-    }
+          /* istanbul ignore if */
+          if (!value === !oldValue)
+              { return; }
+          vnode = locateNode(vnode);
+          var transition$$1 = vnode.data && vnode.data.transition;
+          if (transition$$1) {
+              vnode.data.show = true;
+              if (value) {
+                  enter(vnode, function () {
+                      el.style.display = el.__vOriginalDisplay;
+                  });
+              }
+              else {
+                  leave(vnode, function () {
+                      el.style.display = 'none';
+                  });
+              }
+          }
+          else {
+              el.style.display = value ? el.__vOriginalDisplay : 'none';
+          }
+      },
+      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+          if (!isDestroy) {
+              el.style.display = el.__vOriginalDisplay;
+          }
+      },
   };
 
   var platformDirectives = {
-    model: directive,
-    show: show
+      model: directive,
+      show: show,
   };
 
-  /*  */
-
+  /* @flow */
   var transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object]
+      name: String,
+      appear: Boolean,
+      css: Boolean,
+      mode: String,
+      type: String,
+      enterClass: String,
+      leaveClass: String,
+      enterToClass: String,
+      leaveToClass: String,
+      enterActiveClass: String,
+      leaveActiveClass: String,
+      appearClass: String,
+      appearActiveClass: String,
+      appearToClass: String,
+      duration: [Number, String, Object],
   };
-
   // in case the child is also an abstract component, e.g. <keep-alive>
   // we want to recursively retrieve the real component to be rendered
-  function getRealChild (vnode) {
-    var compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-      return getRealChild(getFirstComponentChild(compOptions.children))
-    } else {
-      return vnode
-    }
-  }
-
-  function extractTransitionData (comp) {
-    var data = {};
-    var options = comp.$options;
-    // props
-    for (var key in options.propsData) {
-      data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-      data[camelize(key$1)] = listeners[key$1];
-    }
-    return data
-  }
-
-  function placeholder (h, rawChild) {
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-      return h('keep-alive', {
-        props: rawChild.componentOptions.propsData
-      })
-    }
+  function getRealChild(vnode) {
+      var compOptions = vnode && vnode.componentOptions;
+      if (compOptions && compOptions.Ctor.options.abstract) {
+          return getRealChild(getFirstComponentChild(compOptions.children));
+      }
+      else {
+          return vnode;
+      }
+  }
+  function extractTransitionData(comp) {
+      var data = {};
+      var options = comp.$options;
+      // props
+      for (var key in options.propsData) {
+          data[key] = comp[key];
+      }
+      // events.
+      // extract listeners and pass them directly to the transition methods
+      var listeners = options._parentListeners;
+      for (var key$1 in listeners) {
+          data[camelize(key$1)] = listeners[key$1];
+      }
+      return data;
+  }
+  function placeholder(h, rawChild) {
+      // @ts-expect-error
+      if (/\d-keep-alive$/.test(rawChild.tag)) {
+          return h('keep-alive', {
+              props: rawChild.componentOptions.propsData,
+          });
+      }
   }
-
-  function hasParentTransition (vnode) {
-    while ((vnode = vnode.parent)) {
-      if (vnode.data.transition) {
-        return true
+  function hasParentTransition(vnode) {
+      while ((vnode = vnode.parent)) {
+          if (vnode.data.transition) {
+              return true;
+          }
       }
-    }
   }
-
-  function isSameChild (child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag
+  function isSameChild(child, oldChild) {
+      return oldChild.key === child.key && oldChild.tag === child.tag;
   }
-
   var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
   var isVShowDirective = function (d) { return d.name === 'show'; };
-
   var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-
-    render: function render (h) {
-      var this$1 = this;
-
-      var children = this.$slots.default;
-      if (!children) {
-        return
-      }
-
-      // filter out text nodes (possible whitespaces)
-      children = children.filter(isNotTextNode);
-      /* istanbul ignore if */
-      if (!children.length) {
-        return
-      }
-
-      // warn multiple elements
-      if (children.length > 1) {
-        warn(
-          '<transition> can only be used on a single element. Use ' +
-          '<transition-group> for lists.',
-          this.$parent
-        );
-      }
-
-      var mode = this.mode;
-
-      // warn invalid mode
-      if (mode && mode !== 'in-out' && mode !== 'out-in'
-      ) {
-        warn(
-          'invalid <transition> mode: ' + mode,
-          this.$parent
-        );
-      }
-
-      var rawChild = children[0];
-
-      // if this is a component root node and the component's
-      // parent container node also has transition, skip.
-      if (hasParentTransition(this.$vnode)) {
-        return rawChild
-      }
-
-      // apply transition data to child
-      // use getRealChild() to ignore abstract components e.g. keep-alive
-      var child = getRealChild(rawChild);
-      /* istanbul ignore if */
-      if (!child) {
-        return rawChild
-      }
-
-      if (this._leaving) {
-        return placeholder(h, rawChild)
-      }
-
-      // ensure a key that is unique to the vnode type and to this transition
-      // component instance. This key will be used to remove pending leaving nodes
-      // during entering.
-      var id = "__transition-" + (this._uid) + "-";
-      child.key = child.key == null
-        ? child.isComment
-          ? id + 'comment'
-          : id + child.tag
-        : isPrimitive(child.key)
-          ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-          : child.key;
-
-      var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-      var oldRawChild = this._vnode;
-      var oldChild = getRealChild(oldRawChild);
-
-      // mark v-show
-      // so that the transition module can hand over the control to the directive
-      if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-        child.data.show = true;
-      }
-
-      if (
-        oldChild &&
-        oldChild.data &&
-        !isSameChild(child, oldChild) &&
-        !isAsyncPlaceholder(oldChild) &&
-        // #6687 component root is a comment node
-        !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-      ) {
-        // replace old child transition data with fresh one
-        // important for dynamic transitions!
-        var oldData = oldChild.data.transition = extend({}, data);
-        // handle transition mode
-        if (mode === 'out-in') {
-          // return placeholder node and queue update when leave finishes
-          this._leaving = true;
-          mergeVNodeHook(oldData, 'afterLeave', function () {
-            this$1._leaving = false;
-            this$1.$forceUpdate();
-          });
-          return placeholder(h, rawChild)
-        } else if (mode === 'in-out') {
-          if (isAsyncPlaceholder(child)) {
-            return oldRawChild
-          }
-          var delayedLeave;
-          var performLeave = function () { delayedLeave(); };
-          mergeVNodeHook(data, 'afterEnter', performLeave);
-          mergeVNodeHook(data, 'enterCancelled', performLeave);
-          mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-        }
-      }
-
-      return rawChild
-    }
+      name: 'transition',
+      props: transitionProps,
+      abstract: true,
+      render: function render(h) {
+          var this$1 = this;
+
+          var children = this.$slots.default;
+          if (!children) {
+              return;
+          }
+          // filter out text nodes (possible whitespaces)
+          children = children.filter(isNotTextNode);
+          /* istanbul ignore if */
+          if (!children.length) {
+              return;
+          }
+          // warn multiple elements
+          if (children.length > 1) {
+              warn('<transition> can only be used on a single element. Use ' +
+                  '<transition-group> for lists.', this.$parent);
+          }
+          var mode = this.mode;
+          // warn invalid mode
+          if (mode &&
+              mode !== 'in-out' &&
+              mode !== 'out-in') {
+              warn('invalid <transition> mode: ' + mode, this.$parent);
+          }
+          var rawChild = children[0];
+          // if this is a component root node and the component's
+          // parent container node also has transition, skip.
+          if (hasParentTransition(this.$vnode)) {
+              return rawChild;
+          }
+          // apply transition data to child
+          // use getRealChild() to ignore abstract components e.g. keep-alive
+          var child = getRealChild(rawChild);
+          /* istanbul ignore if */
+          if (!child) {
+              return rawChild;
+          }
+          if (this._leaving) {
+              return placeholder(h, rawChild);
+          }
+          // ensure a key that is unique to the vnode type and to this transition
+          // component instance. This key will be used to remove pending leaving nodes
+          // during entering.
+          var id = "__transition-" + (this._uid) + "-";
+          child.key =
+              child.key == null
+                  ? child.isComment
+                      ? id + 'comment'
+                      : id + child.tag
+                  : isPrimitive(child.key)
+                      ? String(child.key).indexOf(id) === 0
+                          ? child.key
+                          : id + child.key
+                      : child.key;
+          var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          var oldRawChild = this._vnode;
+          var oldChild = getRealChild(oldRawChild);
+          // mark v-show
+          // so that the transition module can hand over the control to the directive
+          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+              child.data.show = true;
+          }
+          if (oldChild &&
+              oldChild.data &&
+              !isSameChild(child, oldChild) &&
+              !isAsyncPlaceholder(oldChild) &&
+              // #6687 component root is a comment node
+              !(oldChild.componentInstance &&
+                  oldChild.componentInstance._vnode.isComment)) {
+              // replace old child transition data with fresh one
+              // important for dynamic transitions!
+              var oldData = (oldChild.data.transition = extend({}, data));
+              // handle transition mode
+              if (mode === 'out-in') {
+                  // return placeholder node and queue update when leave finishes
+                  this._leaving = true;
+                  mergeVNodeHook(oldData, 'afterLeave', function () {
+                      this$1._leaving = false;
+                      this$1.$forceUpdate();
+                  });
+                  return placeholder(h, rawChild);
+              }
+              else if (mode === 'in-out') {
+                  if (isAsyncPlaceholder(child)) {
+                      return oldRawChild;
+                  }
+                  var delayedLeave;
+                  var performLeave = function () {
+                      delayedLeave();
+                  };
+                  mergeVNodeHook(data, 'afterEnter', performLeave);
+                  mergeVNodeHook(data, 'enterCancelled', performLeave);
+                  mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                      delayedLeave = leave;
+                  });
+              }
+          }
+          return rawChild;
+      },
   };
 
-  /*  */
-
+  // Provides transition support for list items.
   var props = extend({
-    tag: String,
-    moveClass: String
+      tag: String,
+      moveClass: String,
   }, transitionProps);
-
+  // @ts-ignore
   delete props.mode;
-
   var TransitionGroup = {
-    props: props,
-
-    beforeMount: function beforeMount () {
-      var this$1 = this;
-
-      var update = this._update;
-      this._update = function (vnode, hydrating) {
-        var restoreActiveInstance = setActiveInstance(this$1);
-        // force removing pass
-        this$1.__patch__(
-          this$1._vnode,
-          this$1.kept,
-          false, // hydrating
-          true // removeOnly (!important, avoids unnecessary moves)
-        );
-        this$1._vnode = this$1.kept;
-        restoreActiveInstance();
-        update.call(this$1, vnode, hydrating);
-      };
-    },
-
-    render: function render (h) {
-      var tag = this.tag || this.$vnode.data.tag || 'span';
-      var map = Object.create(null);
-      var prevChildren = this.prevChildren = this.children;
-      var rawChildren = this.$slots.default || [];
-      var children = this.children = [];
-      var transitionData = extractTransitionData(this);
-
-      for (var i = 0; i < rawChildren.length; i++) {
-        var c = rawChildren[i];
-        if (c.tag) {
-          if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-            children.push(c);
-            map[c.key] = c
-            ;(c.data || (c.data = {})).transition = transitionData;
-          } else {
-            var opts = c.componentOptions;
-            var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;
-            warn(("<transition-group> children must be keyed: <" + name + ">"));
-          }
-        }
-      }
-
-      if (prevChildren) {
-        var kept = [];
-        var removed = [];
-        for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-          var c$1 = prevChildren[i$1];
-          c$1.data.transition = transitionData;
-          c$1.data.pos = c$1.elm.getBoundingClientRect();
-          if (map[c$1.key]) {
-            kept.push(c$1);
-          } else {
-            removed.push(c$1);
-          }
-        }
-        this.kept = h(tag, null, kept);
-        this.removed = removed;
-      }
-
-      return h(tag, null, children)
-    },
-
-    updated: function updated () {
-      var children = this.prevChildren;
-      var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-      if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-        return
-      }
-
-      // we divide the work into three loops to avoid mixing DOM reads and writes
-      // in each iteration - which helps prevent layout thrashing.
-      children.forEach(callPendingCbs);
-      children.forEach(recordPosition);
-      children.forEach(applyTranslation);
-
-      // force reflow to put everything in position
-      // assign to this to avoid being removed in tree-shaking
-      // $flow-disable-line
-      this._reflow = document.body.offsetHeight;
-
-      children.forEach(function (c) {
-        if (c.data.moved) {
-          var el = c.elm;
-          var s = el.style;
-          addTransitionClass(el, moveClass);
-          s.transform = s.WebkitTransform = s.transitionDuration = '';
-          el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {
-            if (e && e.target !== el) {
-              return
-            }
-            if (!e || /transform$/.test(e.propertyName)) {
-              el.removeEventListener(transitionEndEvent, cb);
-              el._moveCb = null;
-              removeTransitionClass(el, moveClass);
-            }
+      props: props,
+      beforeMount: function beforeMount() {
+          var this$1 = this;
+
+          var update = this._update;
+          this._update = function (vnode, hydrating) {
+              var restoreActiveInstance = setActiveInstance(this$1);
+              // force removing pass
+              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              true // removeOnly (!important, avoids unnecessary moves)
+              );
+              this$1._vnode = this$1.kept;
+              restoreActiveInstance();
+              update.call(this$1, vnode, hydrating);
+          };
+      },
+      render: function render(h) {
+          var tag = this.tag || this.$vnode.data.tag || 'span';
+          var map = Object.create(null);
+          var prevChildren = (this.prevChildren = this.children);
+          var rawChildren = this.$slots.default || [];
+          var children = (this.children = []);
+          var transitionData = extractTransitionData(this);
+          for (var i = 0; i < rawChildren.length; i++) {
+              var c = rawChildren[i];
+              if (c.tag) {
+                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                      children.push(c);
+                      map[c.key] = c;
+                      (c.data || (c.data = {})).transition = transitionData;
+                  }
+                  else {
+                      var opts = c.componentOptions;
+                      var name = opts
+                          ? opts.Ctor.options.name || opts.tag || ''
+                          : c.tag;
+                      warn(("<transition-group> children must be keyed: <" + name + ">"));
+                  }
+              }
+          }
+          if (prevChildren) {
+              var kept = [];
+              var removed = [];
+              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                  var c$1 = prevChildren[i$1];
+                  c$1.data.transition = transitionData;
+                  // @ts-ignore
+                  c$1.data.pos = c$1.elm.getBoundingClientRect();
+                  // @ts-ignore
+                  if (map[c$1.key]) {
+                      kept.push(c$1);
+                  }
+                  else {
+                      removed.push(c$1);
+                  }
+              }
+              this.kept = h(tag, null, kept);
+              this.removed = removed;
+          }
+          return h(tag, null, children);
+      },
+      updated: function updated() {
+          var children = this.prevChildren;
+          var moveClass = this.moveClass || (this.name || 'v') + '-move';
+          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+              return;
+          }
+          // we divide the work into three loops to avoid mixing DOM reads and writes
+          // in each iteration - which helps prevent layout thrashing.
+          children.forEach(callPendingCbs);
+          children.forEach(recordPosition);
+          children.forEach(applyTranslation);
+          // force reflow to put everything in position
+          // assign to this to avoid being removed in tree-shaking
+          // $flow-disable-line
+          this._reflow = document.body.offsetHeight;
+          children.forEach(function (c) {
+              // @ts-ignore
+              if (c.data.moved) {
+                  var el = c.elm;
+                  var s = el.style;
+                  addTransitionClass(el, moveClass);
+                  s.transform = s.WebkitTransform = s.transitionDuration = '';
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
+                          return;
+                      }
+                      if (!e || /transform$/.test(e.propertyName)) {
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
+                      }
+                  }));
+              }
           });
-        }
-      });
-    },
-
-    methods: {
-      hasMove: function hasMove (el, moveClass) {
-        /* istanbul ignore if */
-        if (!hasTransition) {
-          return false
-        }
-        /* istanbul ignore if */
-        if (this._hasMove) {
-          return this._hasMove
-        }
-        // Detect whether an element with the move class applied has
-        // CSS transitions. Since the element may be inside an entering
-        // transition at this very moment, we make a clone of it and remove
-        // all other transition classes applied to ensure only the move class
-        // is applied.
-        var clone = el.cloneNode();
-        if (el._transitionClasses) {
-          el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });
-        }
-        addClass(clone, moveClass);
-        clone.style.display = 'none';
-        this.$el.appendChild(clone);
-        var info = getTransitionInfo(clone);
-        this.$el.removeChild(clone);
-        return (this._hasMove = info.hasTransform)
-      }
-    }
+      },
+      methods: {
+          hasMove: function hasMove(el, moveClass) {
+              /* istanbul ignore if */
+              if (!hasTransition) {
+                  return false;
+              }
+              /* istanbul ignore if */
+              if (this._hasMove) {
+                  return this._hasMove;
+              }
+              // Detect whether an element with the move class applied has
+              // CSS transitions. Since the element may be inside an entering
+              // transition at this very moment, we make a clone of it and remove
+              // all other transition classes applied to ensure only the move class
+              // is applied.
+              var clone = el.cloneNode();
+              if (el._transitionClasses) {
+                  el._transitionClasses.forEach(function (cls) {
+                      removeClass(clone, cls);
+                  });
+              }
+              addClass(clone, moveClass);
+              clone.style.display = 'none';
+              this.$el.appendChild(clone);
+              var info = getTransitionInfo(clone);
+              this.$el.removeChild(clone);
+              return (this._hasMove = info.hasTransform);
+          },
+      },
   };
-
-  function callPendingCbs (c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-      c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-      c.elm._enterCb();
-    }
+  function callPendingCbs(c) {
+      /* istanbul ignore if */
+      //@ts-ignore
+      if (c.elm._moveCb) {
+          //@ts-ignore
+          c.elm._moveCb();
+      }
+      /* istanbul ignore if */
+      //@ts-ignore
+      if (c.elm._enterCb) {
+          //@ts-ignore
+          c.elm._enterCb();
+      }
   }
-
-  function recordPosition (c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
+  function recordPosition(c) {
+      //@ts-ignore
+      c.data.newPos = c.elm.getBoundingClientRect();
   }
-
-  function applyTranslation (c) {
-    var oldPos = c.data.pos;
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-      c.data.moved = true;
-      var s = c.elm.style;
-      s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-      s.transitionDuration = '0s';
-    }
+  function applyTranslation(c) {
+      //@ts-ignore
+      var oldPos = c.data.pos;
+      //@ts-ignore
+      var newPos = c.data.newPos;
+      var dx = oldPos.left - newPos.left;
+      var dy = oldPos.top - newPos.top;
+      if (dx || dy) {
+          //@ts-ignore
+          c.data.moved = true;
+          //@ts-ignore
+          var s = c.elm.style;
+          s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+          s.transitionDuration = '0s';
+      }
   }
 
   var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup
+      Transition: Transition,
+      TransitionGroup: TransitionGroup,
   };
 
-  /*  */
-
   // install platform specific utils
   Vue.config.mustUseProp = mustUseProp;
   Vue.config.isReservedTag = isReservedTag;
   Vue.config.isReservedAttr = isReservedAttr;
   Vue.config.getTagNamespace = getTagNamespace;
   Vue.config.isUnknownElement = isUnknownElement;
-
   // install platform runtime directives & components
   extend(Vue.options.directives, platformDirectives);
   extend(Vue.options.components, platformComponents);
-
   // install platform patch function
   Vue.prototype.__patch__ = inBrowser ? patch : noop;
-
   // public mount method
-  Vue.prototype.$mount = function (
-    el,
-    hydrating
-  ) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating)
+  Vue.prototype.$mount = function (el, hydrating) {
+      el = el && inBrowser ? query(el) : undefined;
+      return mountComponent(this, el, hydrating);
   };
-
   // devtools global hook
   /* istanbul ignore next */
   if (inBrowser) {
-    setTimeout(function () {
-      if (config.devtools) {
-        if (devtools) {
-          devtools.emit('init', Vue);
-        } else {
-          console[console.info ? 'info' : 'log'](
-            'Download the Vue Devtools extension for a better development experience:\n' +
-            'https://github.com/vuejs/vue-devtools'
-          );
-        }
-      }
-      if (config.productionTip !== false &&
-        typeof console !== 'undefined'
-      ) {
-        console[console.info ? 'info' : 'log'](
-          "You are running Vue in development mode.\n" +
-          "Make sure to turn on production mode when deploying for production.\n" +
-          "See more tips at https://vuejs.org/guide/deployment.html"
-        );
-      }
-    }, 0);
+      setTimeout(function () {
+          if (config.devtools) {
+              if (devtools) {
+                  devtools.emit('init', Vue);
+              }
+              else {
+                  // @ts-expect-error
+                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                      'https://github.com/vuejs/vue-devtools');
+              }
+          }
+          if (config.productionTip !== false &&
+              typeof console !== 'undefined') {
+              // @ts-expect-error
+              console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                  "Make sure to turn on production mode when deploying for production.\n" +
+                  "See more tips at https://vuejs.org/guide/deployment.html");
+          }
+      }, 0);
   }
 
-  /*  */
+  /* @flow */
 
   return Vue;
 
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
index d939ed2457e..557c86bb2f1 100644
--- a/dist/vue.runtime.min.js
+++ b/dist/vue.runtime.min.js
@@ -1,6 +1,6 @@
 /*!
  * Vue.js v2.6.12
- * (c) 2014-2020 Evan You
+ * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t=t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R,U="__proto__"in{},H="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0,X=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===B),G=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Z={}.watch,J=!1;if(H)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===R&&(R=!H&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),R},tt=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var dt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=ht[t];M(mt,t,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i})});var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(U?(e=mt,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var xt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&Ot(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?Ot(r,o):o}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}xt.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},P.forEach(function(t){xt[t]=St}),N.forEach(function(t){xt[t+"s"]=Et}),xt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},xt.provide=kt;var jt=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Tt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=xt[r]||jt;a[r]=o(t[r],e[r],n,r)}return a}function It(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Dt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Lt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Lt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}function Nt(t){var e=t&&t.toString().match(/^\s*function (\w+)/);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e,null,"config.errorHandler")}Ut(t,e,n)}function Ut(t,e,n){if(!H&&!V||"undefined"==typeof console)throw t;console.error(t)}var Ht,Vt=!1,Bt=[],zt=!1;function Wt(){zt=!1;var t=Bt.slice(0);Bt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Ht=function(){qt.then(Wt),X&&setTimeout(k)},Vt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ht="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Ht=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Vt=!0}function Zt(t,e){var n;if(Bt.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Ht()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[pt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=pt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=pt(f.text+u):""!==u&&s.push(pt(u)):ie(u)&&ie(f)?s[l]=pt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c;if(Array.isArray(t)||"string"==typeof t)for(r=new Array(t.length),o=0,a=t.length;o<a;o++)r[o]=e(t[o],o);else if("number"==typeof t)for(r=new Array(t),o=0;o<t;o++)r[o]=e(o+1,o);else if(i(t))if(rt&&t[Symbol.iterator]){r=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)r.push(e(l.value,r.length)),l=u.next()}else for(s=Object.keys(t),r=new Array(s.length),o=0,a=s.length;o<a;o++)c=s[o],r[o]=e(t[c],c,o);return n(r)||(r=[]),r._isVList=!0,r}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return It(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?he(o,r):i?he(i,t):r?$(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?we(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ae(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=j,t._i=T,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=pt,t._e=dt,t._u=we,t._g=$e,t._d=Ae,t._p=xe}function ke(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Le(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Le(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ee(t,e){for(var n in e)t[_(n)]=e[n]}Oe(ke.prototype);var je={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;je.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Dt(p,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},Te=Object.keys(je);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Dt(l,u,r||t);else n(o.attrs)&&Ee(c,o.attrs),n(o.props)&&Ee(c,o.props);var f=new ke(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Te.length;n++){var r=Te[n],o=e[r],i=je[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Pe=2;function Le(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Pe),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return dt();n(a)&&n(a.is)&&(o=a.is);if(!o)return dt();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Pe?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=It(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):dt()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function He(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function Ve(t,e){Me.$on(t,e)}function Be(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},Ve,Be,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(H&&!W){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var cn=0,un=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};un.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},un.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},un.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},un.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},un.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},un.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},un.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},un.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var ln={enumerable:!0,configurable:!0,get:k,set:k};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Dt(i,e,n,t);$t(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(var n in e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||k,k,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=k):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):k,ln.set=n.set||k),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Tt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Tt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function $n(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function An(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=$n(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Le(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Le(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(function(n){$t(t,n,e[n])}),_t(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate)try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=dt()),t.parent=o,t}}(bn);var On=[String,RegExp,Array],kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:On,exclude:On,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){An(t,function(t){return wn(e,t)})}),this.$watch("exclude",function(e){An(t,function(t){return!wn(e,t)})})},render:function(){var t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){var r=$n(n),o=this.include,i=this.exclude;if(o&&(!r||!wn(o,r))||i&&r&&wn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Zt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,kn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:ke}),bn.version="2.6.12";var Sn=d("style,class"),En=d("input,textarea,option,select,progress"),jn=d("contenteditable,draggable,spellcheck"),Tn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Pn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Ln=function(t){return Pn(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Hn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Hn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Hn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Bn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Bn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Vn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=It(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a);for(i in(W||K)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Pn(i)?s.removeAttributeNS(Nn,Ln(i)):jn(i)||s.removeAttribute(i))}}function ur(t,e,n){t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):jn(e)?t.setAttribute(e,In(e,n)):Pn(e)?Mn(n)?t.removeAttributeNS(Nn,Ln(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Hn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Vt&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=W?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var $r,wr={create:Cr,update:Cr};function Ar(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:Ar,update:Ar},kr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?O(t):"string"==typeof t?kr(t):t}var jr,Tr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(Tr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty($(e),n.replace(Ir,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Pr=y(function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in jr)return r}});function Lr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Er(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Lr,update:Lr},Fr=/\s+/;function Rr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Hr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Vr(t.name||"v")),x(e,t),e}return"string"==typeof t?Vr(t):void 0}}var Vr=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Br=H&&!q,zr="transition",Wr="animation",qr="transition",Kr="transitionend",Xr="animation",Gr="animationend";Br&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(qr="WebkitTransition",Kr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Xr="WebkitAnimation",Gr="webkitAnimationEnd"));var Zr=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Jr(t){Zr(function(){Zr(t)})}function Qr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Rr(t,e))}function Yr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Ur(t,e)}function to(t,e,n){var r=no(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===zr?Kr:Gr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var eo=/\b(transform|all)(,|$)/;function no(t,e){var n,r=window.getComputedStyle(t),o=(r[qr+"Delay"]||"").split(", "),i=(r[qr+"Duration"]||"").split(", "),a=ro(o,i),s=(r[Xr+"Delay"]||"").split(", "),c=(r[Xr+"Duration"]||"").split(", "),u=ro(s,c),l=0,f=0;return e===zr?a>0&&(n=zr,l=a,f=i.length):e===Wr?u>0&&(n=Wr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?zr:Wr:null)?n===zr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===zr&&eo.test(r[qr+"Property"])}}function ro(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return oo(e)+oo(t[n])}))}function oo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function io(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Hr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=qe,O=qe.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&p?p:u,E=k&&h?h:d,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=co(D),R=o._enterCb=I(function(){M&&(Yr(o,j),Yr(o,E)),R.cancelled?(M&&Yr(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Qr(o,S),Qr(o,E),Jr(function(){Yr(o,S),R.cancelled||(Qr(o,j),F||(so(L)?setTimeout(R,L):to(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function ao(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Hr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=co(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Yr(o,l),Yr(o,d)),$.cancelled?(_&&Yr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Qr(o,u),Qr(o,d),Jr(function(){Yr(o,u),$.cancelled||(Qr(o,l),b||(so(C)?setTimeout($,C):to(o,c,$)))})),v&&v(o,$),_||b||$())}}function so(t){return"number"==typeof t&&!isNaN(t)}function co(t){if(e(t))return!1;var r=t.fns;return n(r)?co(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function uo(t,e){!0!==e.data.show&&io(e)}var lo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?(A(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?(A(m,g,i,o,p),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:w(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?(A(l,g,i,o,p),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=d("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!k(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))A(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Jn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,wr,Or,Mr,H?{create:uo,activate:uo,remove:function(t,e){!0!==t.data.show?ao(t,e):e()}}:{}].concat(sr)});q&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&_o(t,"input")});var fo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){fo.componentUpdated(t,e,n)}):po(t,e,n.context),t._vOptions=[].map.call(t.options,mo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",yo),t.addEventListener("compositionend",go),t.addEventListener("change",go),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){po(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,mo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return ho(t,o)}):e.value!==e.oldValue&&ho(e.value,o))&&_o(t,"change")}}};function po(t,e,n){vo(t,e,n),(W||K)&&setTimeout(function(){vo(t,e,n)},0)}function vo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,mo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(mo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function ho(t,e){return e.every(function(e){return!j(e,t)})}function mo(t){return"_value"in t?t._value:t.value}function yo(t){t.target.composing=!0}function go(t){t.target.composing&&(t.target.composing=!1,_o(t.target,"input"))}function _o(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function bo(t){return!t.componentInstance||t.data&&t.data.transition?t:bo(t.componentInstance._vnode)}var Co={model:fo,show:{bind:function(t,e,n){var r=e.value,o=(n=bo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,io(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=bo(n)).data&&n.data.transition?(n.data.show=!0,r?io(n,function(){t.style.display=t.__vOriginalDisplay}):ao(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},$o={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function wo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?wo(He(e.children)):t}function Ao(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function xo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Oo=function(t){return t.tag||Ue(t)},ko=function(t){return"show"===t.name},So={name:"transition",props:$o,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Oo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=wo(i);if(!a)return i;if(this._leaving)return xo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ao(this),u=this._vnode,l=wo(u);if(a.data.directives&&a.data.directives.some(ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),xo(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Eo=x({tag:String,moveClass:String},$o);function jo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function To(t){t.data.newPos=t.elm.getBoundingClientRect()}function Io(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Eo.mode;var Do={Transition:So,TransitionGroup:{props:Eo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ao(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(jo),t.forEach(To),t.forEach(Io),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Qr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Kr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Kr,t),n._moveCb=null,Yr(n,e))})}}))},methods:{hasMove:function(t,e){if(!Br)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Ur(n,t)}),Rr(n,e),n.style.display="none",this.$el.appendChild(n);var r=no(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return bn.config.mustUseProp=function(t,e,n){return"value"===n&&En(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!H)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Co),x(bn.options.components,Do),bn.prototype.__patch__=H?lo:k,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&H?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},H&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",bn)},0),bn});
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t=t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R,U="__proto__"in{},H="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0,X=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===B),G=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Z={}.watch,J=!1;if(H)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===R&&(R=!H&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),R},tt=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var dt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=ht[t];M(mt,t,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i})});var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(U?(e=mt,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var xt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&Ot(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?Ot(r,o):o}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}xt.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},P.forEach(function(t){xt[t]=St}),N.forEach(function(t){xt[t+"s"]=Et}),xt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},xt.provide=kt;var jt=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Tt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=xt[r]||jt;a[r]=o(t[r],e[r],n,r)}return a}function It(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Dt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Mt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Mt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Pt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Nt=/^\s*function (\w+)/;function Pt(t){var e=t&&t.toString().match(Nt);return e?e[1]:""}function Lt(t,e){return Pt(t)===Pt(e)}function Mt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Ft(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Ut(t,r,"errorCaptured hook")}}Ut(t,e,n)}finally{ut()}}function Rt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Ft(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Ft(t,r,o)}return i}function Ut(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e,null,"config.errorHandler")}Ht(t,e,n)}function Ht(t,e,n){if(!H&&!V||"undefined"==typeof console)throw t;console.error(t)}var Vt,Bt=!1,zt=[],Wt=!1;function qt(){Wt=!1;var t=zt.slice(0);zt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Kt=Promise.resolve();Vt=function(){Kt.then(qt),X&&setTimeout(k)},Bt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(qt)}:function(){setTimeout(qt,0)};else{var Xt=1,Gt=new MutationObserver(qt),Zt=document.createTextNode(String(Xt));Gt.observe(Zt,{characterData:!0}),Vt=function(){Xt=(Xt+1)%2,Zt.data=String(Xt)},Bt=!0}function Jt(t,e){var n;if(zt.push(function(){if(t)try{t.call(e)}catch(t){Ft(t,e,"nextTick")}else n&&n(e)}),Wt||(Wt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Qt=new nt;function Yt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Qt),Qt.clear()}var te=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function ee(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Rt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Rt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ne(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=te(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=ee(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=te(c)).name,n[c],f.capture)}function re(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=ee([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=ee([s,c]),a.merged=!0,t[o]=a}function oe(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ie(t){return o(t)?[pt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ae((u=t(u,(a||"")+"_"+c))[0])&&ae(f)&&(s[l]=pt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ae(f)?s[l]=pt(f.text+u):""!==u&&s.push(pt(u)):ae(u)&&ae(f)?s[l]=pt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ae(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function ce(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ue)&&delete n[u];return n}function ue(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=fe(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=de(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function fe(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ie(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function de(t,e){return function(){return t[e]}}function pe(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ve(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function he(t){return It(this.$options,"filters",t)||E}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?me(o,r):i?me(i,t):r?$(r)!==e:void 0}function ge(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function _e(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(Ce(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function be(t,e,n){return Ce(t,"__once__"+e+(n?"_"+n:""),!0),t}function Ce(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&$e(t[r],e+"_"+r,n);else $e(t,e,n)}function $e(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function xe(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Oe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=be,t._n=f,t._s=l,t._l=pe,t._t=ve,t._q=j,t._i=T,t._m=_e,t._f=he,t._k=ye,t._b=ge,t._v=pt,t._e=dt,t._u=Ae,t._g=we,t._d=xe,t._p=Oe}function Se(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=se(u.inject,i),this.slots=function(){return c.$slots||le(e.scopedSlots,c.$slots=ce(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Me(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Me(s,t,e,n,r,f)}}function Ee(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function je(t,e){for(var n in e)t[_(n)]=e[n]}ke(Se.prototype);var Te={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Te.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Dt(p,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,qe(e,r,h),u&&(e.$slots=ce(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Je(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Ye.push(e)):Ze(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Ge(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Je(e,"deactivated")}}(e,!0):e.$destroy())}},Ie=Object.keys(Te);function De(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Re;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Ue(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Ue(m.error,o)),n(m.loading)&&(t.loadingComp=Ue(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},bn(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);oe(a,c,u,l,!0)||oe(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Dt(l,u,r||t);else n(o.attrs)&&je(c,o.attrs),n(o.props)&&je(c,o.props);var f=new Se(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Ee(d,o,f.parent,s);if(Array.isArray(d)){for(var p=ie(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Ee(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Ie.length;n++){var r=Ie[n],o=e[r],i=Te[r];o===i||o&&o._merged||(e[r]=o?Ne(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function Ne(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Pe=1,Le=2;function Me(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return dt();n(a)&&n(a.is)&&(o=a.is);if(!o)return dt();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=ie(s):c===Pe&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=It(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):De(f,a,t,s,o)}else u=De(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Yt(t.style);i(t.class)&&Yt(t.class)}(a),u):dt()}(t,a,s,c,u)}var Fe,Re=null;function Ue(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function He(t){return t.isComment&&t.asyncFactory}function Ve(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||He(r)))return r}}function Be(t,e){Fe.$on(t,e)}function ze(t,e){Fe.$off(t,e)}function We(t,e){var n=Fe;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function qe(t,e,n){Fe=t,ne(e,n||{},Be,ze,We,t),Fe=void 0}var Ke=null;function Xe(t){var e=Ke;return Ke=t,function(){Ke=e}}function Ge(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ze(t,e){if(e){if(t._directInactive=!1,Ge(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ze(t.$children[n]);Je(t,"activated")}}function Je(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Rt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Qe=[],Ye=[],tn={},en=!1,nn=!1,rn=0;var on=0,an=Date.now;if(H&&!W){var sn=window.performance;sn&&"function"==typeof sn.now&&an()>document.createEvent("Event").timeStamp&&(an=function(){return sn.now()})}function cn(){var t,e;for(on=an(),nn=!0,Qe.sort(function(t,e){return t.id-e.id}),rn=0;rn<Qe.length;rn++)(t=Qe[rn]).before&&t.before(),e=t.id,tn[e]=null,t.run();var n=Ye.slice(),r=Qe.slice();rn=Qe.length=Ye.length=0,tn={},en=nn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ze(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Je(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var un=0,ln=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};ln.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ft(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Yt(t),ut(),this.cleanupDeps()}return t},ln.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},ln.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},ln.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==tn[e]){if(tn[e]=!0,nn){for(var n=Qe.length-1;n>rn&&Qe[n].id>t.id;)n--;Qe.splice(n+1,0,t)}else Qe.push(t);en||(en=!0,Jt(cn))}}(this)},ln.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ft(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},ln.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},ln.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},ln.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var fn={enumerable:!0,configurable:!0,get:k,set:k};function dn(t,e,n){fn.get=function(){return this[e][n]},fn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,fn)}function pn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Dt(i,e,n,t);$t(r,i,a),i in t||dn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(var n in e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Ft(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&dn(t,"_data",i))}var a;Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new ln(t,a||k,k,vn)),o in t||hn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)gn(t,n,r[o]);else gn(t,n,r)}}(t,e.watch)}var vn={lazy:!0};function hn(t,e,n){var r=!Y();"function"==typeof n?(fn.get=r?mn(e):yn(n),fn.set=k):(fn.get=n.get?r&&!1!==n.cache?mn(e):yn(n.get):k,fn.set=n.set||k),Object.defineProperty(t,e,fn)}function mn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function yn(t){return function(){return t.call(this,this)}}function gn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var _n=0;function bn(t){var e=t.options;if(t.super){var n=bn(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Tt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function Cn(t){this._init(t)}function $n(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Tt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)dn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)hn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function xn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&On(n,i,r,o)}}}function On(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=_n++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(bn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&qe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=ce(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Me(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Me(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Je(n,"beforeCreate"),function(t){var e=se(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(function(n){$t(t,n,e[n])}),_t(!0))}(n),pn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Je(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(Cn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return gn(this,t,e,n);(n=n||{}).user=!0;var r=new ln(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Ft(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(Cn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Rt(e[o],this,n,this,r)}return this}}(Cn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Xe(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Je(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Je(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(Cn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Jt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=le(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Re=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ft(n,e,"render"),t=e._vnode}finally{Re=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=dt()),t.parent=o,t}}(Cn);var kn=[String,RegExp,Array],Sn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)On(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){xn(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){xn(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Ve(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Jt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,Sn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),$n(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(Cn),Object.defineProperty(Cn.prototype,"$isServer",{get:Y}),Object.defineProperty(Cn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Cn,"FunctionalRenderContext",{value:Se}),Cn.version="2.6.12";var En=d("style,class"),jn=d("input,textarea,option,select,progress"),Tn=d("contenteditable,draggable,spellcheck"),In=d("events,caret,typing,plaintext-only"),Dn=function(t,e){return Fn(e)||"false"===e?"false":"contenteditable"===t&&In(e)?e:"true"},Nn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Pn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Mn=function(t){return Ln(t)?t.slice(6,t.length):""},Fn=function(t){return null==t||!1===t};function Rn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Un(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Un(e,r.data));return function(t,e){if(n(t)||n(e))return Hn(t,Vn(e));return""}(e.staticClass,e.class)}function Un(t,e){return{staticClass:Hn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Hn(t,e){return t?e?t+" "+e:t:e||""}function Vn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Vn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Wn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),qn=function(t){return zn(t)||Wn(t)};var Kn=Object.create(null);var Xn=d("text,number,password,search,email,tel,url");var Gn=Object.freeze({createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create:function(t,e){Jn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Jn(t,!0),Jn(e))},destroy:function(t){Jn(t,!0)}};function Jn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Qn=new lt("",{},[]),Yn=["create","activate","update","remove","destroy"];function tr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Xn(o)&&Xn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function er(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var nr={create:rr,update:rr,destroy:function(t){rr(t,Qn)}};function rr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Qn,a=e===Qn,s=ir(t.data.directives,t.context),c=ir(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,sr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(sr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)sr(u[n],"inserted",e,t)};i?re(e,"insert",f):f()}l.length&&re(e,"postpatch",function(){for(var n=0;n<l.length;n++)sr(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||sr(s[n],"unbind",t,t,a)}(t,e)}var or=Object.create(null);function ir(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=or),o[ar(r)]=r,r.def=It(e.$options,"directives",r.name);return o}function ar(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function sr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ft(r,n.context,"directive "+t.name+" "+e+" hook")}}var cr=[Zn,nr];function ur(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&lr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&lr(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Pn,Mn(i)):Tn(i)||s.removeAttribute(i))}}function lr(t,e,n,r){r||t.tagName.indexOf("-")>-1?fr(t,e,n):Nn(e)?Fn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,Dn(e,n)):Ln(e)?Fn(n)?t.removeAttributeNS(Pn,Mn(e)):t.setAttributeNS(Pn,e,n):fr(t,e,n)}function fr(t,e,n){if(Fn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var dr={create:ur,update:ur};function pr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Rn(r),c=o._transitionClasses;n(c)&&(s=Hn(s,Vn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var vr,hr={create:pr,update:pr},mr="__r",yr="__c";function gr(t,e,n){var r=vr;return function o(){null!==e.apply(null,arguments)&&Cr(t,o,n,r)}}var _r=Bt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var o=on,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}vr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||vr).removeEventListener(t,e._wrapper||e,n)}function $r(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};vr=r.elm,function(t){if(n(t[mr])){var e=W?"change":"input";t[e]=[].concat(t[mr],t[e]||[]),delete t[mr]}n(t[yr])&&(t.change=[].concat(t[yr],t.change||[]),delete t[yr])}(o),ne(o,i,br,Cr,gr,r.context),vr=void 0}}var wr,Ar={create:$r,update:$r};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Wn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:xr,update:xr},Sr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?O(t):"string"==typeof t?Sr(t):t}var Tr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty($(e),n.replace(Dr,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Lr=y(function(t){if(Tr=Tr||document.createElement("div").style,"filter"!==(t=_(t))&&t in Tr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Tr)return r}});function Mr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=jr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Nr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Vr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),zr=H&&!q,Wr="transition",qr="animation",Kr="transition",Xr="transitionend",Gr="animation",Zr="animationend";zr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Kr="WebkitTransition",Xr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Gr="WebkitAnimation",Zr="webkitAnimationEnd"));var Jr=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Qr(t){Jr(function(){Jr(t)})}function Yr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Ur(t,e))}function to(t,e){t._transitionClasses&&v(t._transitionClasses,e),Hr(t,e)}function eo(t,e,n){var r=ro(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Wr?Xr:Zr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var no=/\b(transform|all)(,|$)/;function ro(t,e){var n,r=window.getComputedStyle(t),o=(r[Kr+"Delay"]||"").split(", "),i=(r[Kr+"Duration"]||"").split(", "),a=oo(o,i),s=(r[Gr+"Delay"]||"").split(", "),c=(r[Gr+"Duration"]||"").split(", "),u=oo(s,c),l=0,f=0;return e===Wr?a>0&&(n=Wr,l=a,f=i.length):e===qr?u>0&&(n=qr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Wr:qr:null)?n===Wr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Wr&&no.test(r[Kr+"Property"])}}function oo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return io(e)+io(t[n])}))}function io(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ao(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Vr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ke,O=Ke.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&p?p:u,E=k&&h?h:d,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=uo(D),R=o._enterCb=I(function(){M&&(to(o,j),to(o,E)),R.cancelled?(M&&to(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||re(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Yr(o,S),Yr(o,E),Qr(function(){to(o,S),R.cancelled||(Yr(o,j),F||(co(L)?setTimeout(R,L):eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function so(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Vr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=uo(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(to(o,l),to(o,d)),$.cancelled?(_&&to(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Yr(o,u),Yr(o,d),Qr(function(){to(o,u),$.cancelled||(Yr(o,l),b||(co(C)?setTimeout($,C):eo(o,c,$)))})),v&&v(o,$),_||b||$())}}function co(t){return"number"==typeof t&&!isNaN(t)}function uo(t){if(e(t))return!1;var r=t.fns;return n(r)?uo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function lo(t,e){!0!==e.data.show&&ao(e)}var fo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Yn.length;++i)for(s[Yn[i]]=[],a=0;a<c.length;++a)n(c[a][Yn[i]])&&s[Yn[i]].push(c[a][Yn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Qn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Jn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Qn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Qn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&tr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:tr(h,g)?(A(h,g,i,o,p),h=r[++d],g=o[++p]):tr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):tr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):tr(m,g)?(A(m,g,i,o,p),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=er(r,d,v)),e(c=n(g.key)?s[g.key]:w(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):tr(l=r[c],g)?(A(l,g,i,o,p),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=d("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!k(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Yt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&tr(t,o))A(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Qn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Jn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Gn,modules:[dr,hr,Ar,kr,Fr,H?{create:lo,activate:lo,remove:function(t,e){!0!==t.data.show?so(t,e):e()}}:{}].concat(cr)});q&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&bo(t,"input")});var po={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?re(n,"postpatch",function(){po.componentUpdated(t,e,n)}):vo(t,e,n.context),t._vOptions=[].map.call(t.options,yo)):("textarea"===n.tag||Xn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",go),t.addEventListener("compositionend",_o),t.addEventListener("change",_o),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){vo(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,yo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return mo(t,o)}):e.value!==e.oldValue&&mo(e.value,o))&&bo(t,"change")}}};function vo(t,e,n){ho(t,e,n),(W||K)&&setTimeout(function(){ho(t,e,n)},0)}function ho(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,yo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(yo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function mo(t,e){return e.every(function(e){return!j(e,t)})}function yo(t){return"_value"in t?t._value:t.value}function go(t){t.target.composing=!0}function _o(t){t.target.composing&&(t.target.composing=!1,bo(t.target,"input"))}function bo(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Co(t){return!t.componentInstance||t.data&&t.data.transition?t:Co(t.componentInstance._vnode)}var $o={model:po,show:{bind:function(t,e,n){var r=e.value,o=(n=Co(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,ao(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=Co(n)).data&&n.data.transition?(n.data.show=!0,r?ao(n,function(){t.style.display=t.__vOriginalDisplay}):so(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},wo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ao(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ao(Ve(e.children)):t}function xo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Oo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var ko=function(t){return t.tag||He(t)},So=function(t){return"show"===t.name},Eo={name:"transition",props:wo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(ko)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Ao(i);if(!a)return i;if(this._leaving)return Oo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=xo(this),u=this._vnode,l=Ao(u);if(a.data.directives&&a.data.directives.some(So)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!He(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,re(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Oo(t,i);if("in-out"===r){if(He(a))return u;var d,p=function(){d()};re(c,"afterEnter",p),re(c,"enterCancelled",p),re(f,"delayLeave",function(t){d=t})}}return i}}},jo=x({tag:String,moveClass:String},wo);function To(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Io(t){t.data.newPos=t.elm.getBoundingClientRect()}function Do(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete jo.mode;var No={Transition:Eo,TransitionGroup:{props:jo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Xe(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=xo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(To),t.forEach(Io),t.forEach(Do),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Yr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Xr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Xr,t),n._moveCb=null,to(n,e))})}}))},methods:{hasMove:function(t,e){if(!zr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Hr(n,t)}),Ur(n,e),n.style.display="none",this.$el.appendChild(n);var r=ro(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return Cn.config.mustUseProp=function(t,e,n){return"value"===n&&jn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},Cn.config.isReservedTag=qn,Cn.config.isReservedAttr=En,Cn.config.getTagNamespace=function(t){return Wn(t)?"svg":"math"===t?"math":void 0},Cn.config.isUnknownElement=function(t){if(!H)return!0;if(qn(t))return!1;if(t=t.toLowerCase(),null!=Kn[t])return Kn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Kn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Kn[t]=/HTMLUnknownElement/.test(e.toString())},x(Cn.options.directives,$o),x(Cn.options.components,No),Cn.prototype.__patch__=H?fo:k,Cn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),Je(t,"beforeMount"),r=function(){t._update(t._render(),n)},new ln(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Je(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Je(t,"mounted")),t}(this,t=t&&H?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},H&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",Cn)},0),Cn});
\ No newline at end of file
diff --git a/package.json b/package.json
index 62d894d5bdb..d26d0d2fdba 100644
--- a/package.json
+++ b/package.json
@@ -132,6 +132,7 @@
     "rollup-plugin-flow-no-whitespace": "^1.0.0",
     "rollup-plugin-node-resolve": "^4.0.0",
     "rollup-plugin-replace": "^2.0.0",
+    "rollup-plugin-typescript2": "^0.30.0",
     "selenium-server": "^2.53.1",
     "serialize-javascript": "^3.1.0",
     "shelljs": "^0.8.1",
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index a7e95e992eb..51863b4f052 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -4,185 +4,152 @@
   (global = global || self, global.renderVueComponentToString = factory());
 }(this, function () { 'use strict';
 
-  /*  */
-
+  /* @flow */
   var emptyObject = Object.freeze({});
-
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
-  function isUndef (v) {
-    return v === undefined || v === null
+  function isUndef(v) {
+      return v === undefined || v === null;
   }
-
-  function isDef (v) {
-    return v !== undefined && v !== null
+  function isDef(v) {
+      return v !== undefined && v !== null;
   }
-
-  function isTrue (v) {
-    return v === true
+  function isTrue(v) {
+      return v === true;
   }
-
-  function isFalse (v) {
-    return v === false
+  function isFalse(v) {
+      return v === false;
   }
-
   /**
    * Check if value is primitive.
    */
-  function isPrimitive (value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
   }
-
   /**
    * Quick object check - this is primarily used to tell
    * Objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
-  function isObject (obj) {
-    return obj !== null && typeof obj === 'object'
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
   }
-
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
   var _toString = Object.prototype.toString;
-
-  function toRawType (value) {
-    return _toString.call(value).slice(8, -1)
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
   }
-
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
-  function isPlainObject (obj) {
-    return _toString.call(obj) === '[object Object]'
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
   }
-
   /**
    * Check if val is a valid array index.
    */
-  function isValidArrayIndex (val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
+  function isValidArrayIndex(val) {
+      var n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
-
-  function isPromise (val) {
-    return (
-      isDef(val) &&
-      typeof val.then === 'function' &&
-      typeof val.catch === 'function'
-    )
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
   }
-
   /**
    * Convert a value to a string that is actually rendered.
    */
-  function toString (val) {
-    return val == null
-      ? ''
-      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-        ? JSON.stringify(val, null, 2)
-        : String(val)
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
   }
-
   /**
    * Convert an input value to a number for persistence.
    * If the conversion fails, return original string.
    */
-  function toNumber (val) {
-    var n = parseFloat(val);
-    return isNaN(n) ? val : n
+  function toNumber(val) {
+      var n = parseFloat(val);
+      return isNaN(n) ? val : n;
   }
-
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
-  function makeMap (
-    str,
-    expectsLowerCase
-  ) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) { return map[val.toLowerCase()]; }
-      : function (val) { return map[val]; }
+  function makeMap(str, expectsLowerCase) {
+      var map = Object.create(null);
+      var list = str.split(',');
+      for (var i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
   }
-
   /**
    * Check if a tag is a built-in tag.
    */
   var isBuiltInTag = makeMap('slot,component', true);
-
   /**
    * Check if an attribute is a reserved attribute.
    */
   var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
   /**
    * Remove an item from an array.
    */
-  function remove (arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1)
+  function remove(arr, item) {
+      if (arr.length) {
+          var index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
       }
-    }
   }
-
   /**
    * Check whether an object has the property.
    */
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn (obj, key) {
-    return hasOwnProperty.call(obj, key)
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
   }
-
   /**
    * Create a cached version of a pure function.
    */
-  function cached (fn) {
-    var cache = Object.create(null);
-    return (function cachedFn (str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str))
-    })
+  function cached(fn) {
+      var cache = Object.create(null);
+      return function cachedFn(str) {
+          var hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
   }
-
   /**
    * Camelize a hyphen-delimited string.
    */
   var camelizeRE = /-(\w)/g;
   var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
   });
-
   /**
    * Capitalize a string.
    */
   var capitalize = cached(function (str) {
-    return str.charAt(0).toUpperCase() + str.slice(1)
+      return str.charAt(0).toUpperCase() + str.slice(1);
   });
-
   /**
    * Hyphenate a camelCase string.
    */
   var hyphenateRE = /\B([A-Z])/g;
   var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-
   /**
    * Simple bind polyfill for environments that do not support it,
    * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -190,1267 +157,1120 @@
    * But removing it would mean breaking code that was able to run in
    * PhantomJS 1.x, so this must be kept for backward compatibility.
    */
-
   /* istanbul ignore next */
-  function polyfillBind (fn, ctx) {
-    function boundFn (a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx)
-    }
-
-    boundFn._length = fn.length;
-    return boundFn
-  }
-
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
-
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
-
+  function polyfillBind(fn, ctx) {
+      function boundFn(a) {
+          var l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
+  }
+  function nativeBind(fn, ctx) {
+      return fn.bind(ctx);
+  }
+  // @ts-expect-error bind cannot be `undefined`
+  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Mix properties into target object.
    */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to
+  function extend(to, _from) {
+      for (var key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
   }
-
   /**
    * Merge an Array of Objects into a single Object.
    */
-  function toObject (arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-      if (arr[i]) {
-        extend(res, arr[i]);
+  function toObject(arr) {
+      var res = {};
+      for (var i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
       }
-    }
-    return res
+      return res;
   }
-
   /* eslint-disable no-unused-vars */
-
   /**
    * Perform no operation.
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop (a, b, c) {}
-
+  function noop(a, b, c) { }
   /**
    * Always return false.
    */
   var no = function (a, b, c) { return false; };
-
   /* eslint-enable no-unused-vars */
-
   /**
    * Return the same value.
    */
   var identity = function (_) { return _; };
-
   /**
    * Generate a string containing static keys from compiler modules.
    */
-  function genStaticKeys (modules) {
-    return modules.reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, []).join(',')
+  function genStaticKeys(modules) {
+      return modules
+          .reduce(function (keys, m) {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
   }
-
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
-  function looseEqual (a, b) {
-    if (a === b) { return true }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-      try {
-        var isArrayA = Array.isArray(a);
-        var isArrayB = Array.isArray(b);
-        if (isArrayA && isArrayB) {
-          return a.length === b.length && a.every(function (e, i) {
-            return looseEqual(e, b[i])
-          })
-        } else if (a instanceof Date && b instanceof Date) {
-          return a.getTime() === b.getTime()
-        } else if (!isArrayA && !isArrayB) {
-          var keysA = Object.keys(a);
-          var keysB = Object.keys(b);
-          return keysA.length === keysB.length && keysA.every(function (key) {
-            return looseEqual(a[key], b[key])
-          })
-        } else {
-          /* istanbul ignore next */
-          return false
-        }
-      } catch (e) {
-        /* istanbul ignore next */
-        return false
-      }
-    } else if (!isObjectA && !isObjectB) {
-      return String(a) === String(b)
-    } else {
-      return false
-    }
+  function looseEqual(a, b) {
+      if (a === b)
+          { return true; }
+      var isObjectA = isObject(a);
+      var isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              var isArrayA = Array.isArray(a);
+              var isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every(function (e, i) {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  var keysA = Object.keys(a);
+                  var keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every(function (key) {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
   }
-
   /**
    * Return the first index at which a loosely equal value can be
    * found in the array (if value is a plain object, the array must
    * contain an object of the same shape), or -1 if it is not present.
    */
-  function looseIndexOf (arr, val) {
-    for (var i = 0; i < arr.length; i++) {
-      if (looseEqual(arr[i], val)) { return i }
-    }
-    return -1
+  function looseIndexOf(arr, val) {
+      for (var i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              { return i; }
+      }
+      return -1;
   }
-
   /**
    * Ensure a function is called only once.
    */
-  function once (fn) {
-    var called = false;
-    return function () {
-      if (!called) {
-        called = true;
-        fn.apply(this, arguments);
-      }
-    }
-  }
-
-  /*  */
-
-  var isAttr = makeMap(
-    'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap'
-  );
+  function once(fn) {
+      var called = false;
+      return function () {
+          if (!called) {
+              called = true;
+              fn.apply(this, arguments);
+          }
+      };
+  }
 
+  /* @flow */
+  var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap');
   var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
   var isSSRUnsafeAttr = function (name) {
-    return unsafeAttrCharRE.test(name)
+      return unsafeAttrCharRE.test(name);
   };
-
   /* istanbul ignore next */
   var isRenderableAttr = function (name) {
-    return (
-      isAttr(name) ||
-      name.indexOf('data-') === 0 ||
-      name.indexOf('aria-') === 0
-    )
+      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
   };
-
   var propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv'
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv',
   };
-
   var ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;'
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;',
   };
-
-  function escape (s) {
-    return s.replace(/[<>"&]/g, escapeChar)
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
   }
-
-  function escapeChar (a) {
-    return ESC[a] || a
+  function escapeChar(a) {
+      return ESC[a] || a;
   }
-
   var noUnitNumericStyleProps = {
-    "animation-iteration-count": true,
-    "border-image-outset": true,
-    "border-image-slice": true,
-    "border-image-width": true,
-    "box-flex": true,
-    "box-flex-group": true,
-    "box-ordinal-group": true,
-    "column-count": true,
-    "columns": true,
-    "flex": true,
-    "flex-grow": true,
-    "flex-positive": true,
-    "flex-shrink": true,
-    "flex-negative": true,
-    "flex-order": true,
-    "grid-row": true,
-    "grid-row-end": true,
-    "grid-row-span": true,
-    "grid-row-start": true,
-    "grid-column": true,
-    "grid-column-end": true,
-    "grid-column-span": true,
-    "grid-column-start": true,
-    "font-weight": true,
-    "line-clamp": true,
-    "line-height": true,
-    "opacity": true,
-    "order": true,
-    "orphans": true,
-    "tab-size": true,
-    "widows": true,
-    "z-index": true,
-    "zoom": true,
-    // SVG
-    "fill-opacity": true,
-    "flood-opacity": true,
-    "stop-opacity": true,
-    "stroke-dasharray": true,
-    "stroke-dashoffset": true,
-    "stroke-miterlimit": true,
-    "stroke-opacity": true,
-    "stroke-width": true
+      'animation-iteration-count': true,
+      'border-image-outset': true,
+      'border-image-slice': true,
+      'border-image-width': true,
+      'box-flex': true,
+      'box-flex-group': true,
+      'box-ordinal-group': true,
+      'column-count': true,
+      columns: true,
+      flex: true,
+      'flex-grow': true,
+      'flex-positive': true,
+      'flex-shrink': true,
+      'flex-negative': true,
+      'flex-order': true,
+      'grid-row': true,
+      'grid-row-end': true,
+      'grid-row-span': true,
+      'grid-row-start': true,
+      'grid-column': true,
+      'grid-column-end': true,
+      'grid-column-span': true,
+      'grid-column-start': true,
+      'font-weight': true,
+      'line-clamp': true,
+      'line-height': true,
+      opacity: true,
+      order: true,
+      orphans: true,
+      'tab-size': true,
+      widows: true,
+      'z-index': true,
+      zoom: true,
+      // SVG
+      'fill-opacity': true,
+      'flood-opacity': true,
+      'stop-opacity': true,
+      'stroke-dasharray': true,
+      'stroke-dashoffset': true,
+      'stroke-miterlimit': true,
+      'stroke-opacity': true,
+      'stroke-width': true,
   };
 
-  /*  */
-
+  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   var isReservedAttr = makeMap('style,class');
-
   // attributes that should be using props for binding
   var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
   };
-
   var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
   var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
   var convertEnumeratedValue = function (key, value) {
-    return isFalsyAttrValue(value) || value === 'false'
-      ? 'false'
-      // allow arbitrary string value for contenteditable
-      : key === 'contenteditable' && isValidContentEditableValue(value)
-        ? value
-        : 'true'
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
   };
-
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,translate,' +
-    'truespeed,typemustmatch,visible'
-  );
-
+  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
   var isFalsyAttrValue = function (val) {
-    return val == null || val === false
+      return val == null || val === false;
   };
 
-  /*  */
-
-  function renderAttrs (node) {
-    var attrs = node.data.attrs;
-    var res = '';
-
-    var opts = node.parent && node.parent.componentOptions;
-    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-      var parent = node.parent;
-      while (isDef(parent)) {
-        if (isDef(parent.data) && isDef(parent.data.attrs)) {
-          attrs = extend(extend({}, attrs), parent.data.attrs);
-        }
-        parent = parent.parent;
-      }
-    }
-
-    if (isUndef(attrs)) {
-      return res
-    }
-
-    for (var key in attrs) {
-      if (isSSRUnsafeAttr(key)) {
-        continue
-      }
-      if (key === 'style') {
-        // leave it to the style module
-        continue
-      }
-      res += renderAttr(key, attrs[key]);
-    }
-    return res
-  }
-
-  function renderAttr (key, value) {
-    if (isBooleanAttr(key)) {
-      if (!isFalsyAttrValue(value)) {
-        return (" " + key + "=\"" + key + "\"")
-      }
-    } else if (isEnumeratedAttr(key)) {
-      return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"")
-    } else if (!isFalsyAttrValue(value)) {
-      return (" " + key + "=\"" + (escape(String(value))) + "\"")
-    }
-    return ''
-  }
-
-  /*  */
-
-  var VNode = function VNode (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+  /* @flow */
+  function renderAttrs(node) {
+      var attrs = node.data.attrs;
+      var res = '';
+      var opts = node.parent && node.parent.componentOptions;
+      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+          var parent = node.parent;
+          while (isDef(parent)) {
+              // Stop fallthrough in case parent has inheritAttrs option set to false
+              if (parent.componentOptions &&
+                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                  break;
+              }
+              if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                  attrs = extend(extend({}, attrs), parent.data.attrs);
+              }
+              parent = parent.parent;
+          }
+      }
+      if (isUndef(attrs)) {
+          return res;
+      }
+      for (var key in attrs) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          if (key === 'style') {
+              // leave it to the style module
+              continue;
+          }
+          res += renderAttr(key, attrs[key]);
+      }
+      return res;
+  }
+  function renderAttr(key, value) {
+      if (isBooleanAttr(key)) {
+          if (!isFalsyAttrValue(value)) {
+              return (" " + key + "=\"" + key + "\"");
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"");
+      }
+      else if (!isFalsyAttrValue(value)) {
+          return (" " + key + "=\"" + (escape(String(value))) + "\"");
+      }
+      return '';
+  }
+
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
   };
 
   var prototypeAccessors = { child: { configurable: true } };
-
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   prototypeAccessors.child.get = function () {
-    return this.componentInstance
+      return this.componentInstance;
   };
 
   Object.defineProperties( VNode.prototype, prototypeAccessors );
-
   var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
+      if ( text === void 0 ) text = '';
 
-    var node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node
+      var node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
   };
-
-  function createTextVNode (val) {
-    return new VNode(undefined, undefined, undefined, String(val))
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
   }
-
   // optimized shallow clone
   // used for static nodes and slot nodes because they may be reused across
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
-  function cloneVNode (vnode) {
-    var cloned = new VNode(
-      vnode.tag,
-      vnode.data,
+  function cloneVNode(vnode) {
+      var cloned = new VNode(
+      //@ts-expect-error void type not valid here
+      vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
-      vnode.children && vnode.children.slice(),
-      vnode.text,
-      vnode.elm,
-      vnode.context,
-      vnode.componentOptions,
-      vnode.asyncFactory
-    );
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned
-  }
-
-  /*  */
-
-  function renderDOMProps (node) {
-    var props = node.data.domProps;
-    var res = '';
-
-    var parent = node.parent;
-    while (isDef(parent)) {
-      if (parent.data && parent.data.domProps) {
-        props = extend(extend({}, props), parent.data.domProps);
-      }
-      parent = parent.parent;
-    }
-
-    if (isUndef(props)) {
-      return res
-    }
-
-    var attrs = node.data.attrs;
-    for (var key in props) {
-      if (key === 'innerHTML') {
-        setText(node, props[key], true);
-      } else if (key === 'textContent') {
-        setText(node, props[key], false);
-      } else if (key === 'value' && node.tag === 'textarea') {
-        setText(node, props[key], false);
-      } else {
-        // $flow-disable-line (WTF?)
-        var attr = propsToAttrMap[key] || key.toLowerCase();
-        if (isRenderableAttr(attr) &&
-          // avoid rendering double-bound props/attrs twice
-          !(isDef(attrs) && isDef(attrs[attr]))
-        ) {
-          res += renderAttr(attr, props[key]);
-        }
-      }
-    }
-    return res
-  }
-
-  function setText (node, text, raw) {
-    var child = new VNode(undefined, undefined, undefined, text);
-    child.raw = raw;
-    node.children = [child];
-  }
-
-  /*  */
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
+  }
+
+  /* @flow */
+  function renderDOMProps(node) {
+      var props = node.data.domProps;
+      var res = '';
+      var parent = node.parent;
+      while (isDef(parent)) {
+          if (parent.data && parent.data.domProps) {
+              props = extend(extend({}, props), parent.data.domProps);
+          }
+          parent = parent.parent;
+      }
+      if (isUndef(props)) {
+          return res;
+      }
+      var attrs = node.data.attrs;
+      for (var key in props) {
+          if (key === 'innerHTML') {
+              setText(node, props[key], true);
+          }
+          else if (key === 'textContent') {
+              setText(node, props[key], false);
+          }
+          else if (key === 'value' && node.tag === 'textarea') {
+              setText(node, toString(props[key]), false);
+          }
+          else {
+              // $flow-disable-line (WTF?)
+              var attr = propsToAttrMap[key] || key.toLowerCase();
+              if (isRenderableAttr(attr) &&
+                  // avoid rendering double-bound props/attrs twice
+                  !(isDef(attrs) && isDef(attrs[attr]))) {
+                  res += renderAttr(attr, props[key]);
+              }
+          }
+      }
+      return res;
+  }
+  function setText(node, text, raw) {
+      var child = new VNode(undefined, undefined, undefined, text);
+      child.raw = raw;
+      node.children = [child];
+  }
 
+  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
   var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
   /**
    * Define a property.
    */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
   }
 
-  /*  */
-
+  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
-
   // Browser environment sniffing
   var inBrowser = typeof window !== 'undefined';
-  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
+  var inWeex = 
+  // @ts-ignore
+  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
   var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
   var isPhantomJS = UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
-
   // Firefox has a "watch" function on Object.prototype...
-  var nativeWatch = ({}).watch;
+  // @ts-ignore
+  var nativeWatch = {}.watch;
   if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, 'passive', ({
-        get: function get () {
-        }
-      })); // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts);
-    } catch (e) {}
+      try {
+          var opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get: function get() {
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          // @ts-ignore
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
   }
-
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
   var _isServer;
   var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-      } else {
-        _isServer = false;
-      }
-    }
-    return _isServer
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
   };
-
   // detect devtools
+  // @ts-ignore TODO decalre this types
   var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
   /* istanbul ignore next */
-  function isNative (Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-
-  var hasSymbol =
-    typeof Symbol !== 'undefined' && isNative(Symbol) &&
-    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-  var _Set;
-  /* istanbul ignore if */ // $flow-disable-line
-  if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-      function Set () {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has (key) {
-        return this.set[key] === true
-      };
-      Set.prototype.add = function add (key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear () {
-        this.set = Object.create(null);
-      };
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  var hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  var _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = /*@__PURE__*/(function () {
+          function Set() {
+              this.set = Object.create(null);
+          }
+          Set.prototype.has = function has (key) {
+              return this.set[key] === true;
+          };
+          Set.prototype.add = function add (key) {
+              this.set[key] = true;
+          };
+          Set.prototype.clear = function clear () {
+              this.set = Object.create(null);
+          };
 
-      return Set;
-    }());
+          return Set;
+      }());
   }
 
   var SSR_ATTR = 'data-server-rendered';
-
-  var ASSET_TYPES = [
-    'component',
-    'directive',
-    'filter'
-  ];
-
+  var ASSET_TYPES = ['component', 'directive', 'filter'];
   var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
-  ];
-
-  /*  */
-
-
-
-  var config = ({
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  });
-
-  /*  */
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch' ];
+
+  /* @flow */
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
+  };
 
+  /* @flow */
   var warn = noop;
   var tip = noop;
-  var generateComponentTrace = (noop); // work around flow check
-  var formatComponentName = (noop);
-
+  var generateComponentTrace; // work around flow check
+  var formatComponentName;
   {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str
-      .replace(classifyRE, function (c) { return c.toUpperCase(); })
-      .replace(/[-_]/g, ''); };
-
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : '';
-
-      if (hasConsole && (!config.silent)) {
-        console.error(("[Vue warn]: " + msg + trace));
-      }
-    };
-
-    tip = function (msg, vm) {
-      if (hasConsole && (!config.silent)) {
-        console.warn("[Vue tip]: " + msg + (
-          vm ? generateComponentTrace(vm) : ''
-        ));
-      }
-    };
-
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options = typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-
-      return (
-        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-        (file && includeFile !== false ? (" at " + file) : '')
-      )
-    };
-
-    var repeat = function (str, n) {
-      var res = '';
-      while (n) {
-        if (n % 2 === 1) { res += str; }
-        if (n > 1) { str += str; }
-        n >>= 1;
-      }
-      return res
-    };
-
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
-          }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return '\n\nfound in\n\n' + tree
-          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-              : formatComponentName(vm))); })
-          .join('\n')
-      } else {
-        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-      }
-    };
-  }
-
-  /*  */
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+      warn = function (msg, vm) {
+          var trace = vm ? generateComponentTrace(vm) : '';
+          if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
+          }
+      };
+      tip = function (msg, vm) {
+          if (hasConsole && !config.silent) {
+              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = function (vm, includeFile) {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          var options = 
+          // @ts-ignore
+          typeof vm === 'function' && vm.cid != null
+              ? // @ts-ignore
+                  vm.options
+              : vm._isVue
+                  ? // @ts-ignore
+                      vm.$options || vm.constructor.options
+                  : vm;
+          var name = options.name || options._componentTag;
+          var file = options.__file;
+          if (!name && file) {
+              var match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
+      };
+      var repeat = function (str, n) {
+          var res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  { res += str; }
+              if (n > 1)
+                  { str += str; }
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = function (vm) {
+          // @ts-ignore
+          if (vm._isVue && vm.$parent) {
+              var tree = [];
+              var currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      var last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
+                      .join('\n'));
+          }
+          else {
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+          }
+      };
+  }
 
   var uid = 0;
-
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep () {
-    this.id = uid++;
-    this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid++;
+      this.subs = [];
   };
-
   Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
+      this.subs.push(sub);
   };
-
   Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
+      remove(this.subs, sub);
   };
-
   Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
+      if (Dep.target) {
+          Dep.target.addDep(this);
+      }
   };
-
   Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
   };
-
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
   var targetStack = [];
-
-  function pushTarget (target) {
-    targetStack.push(target);
-    Dep.target = target;
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
   }
-
-  function popTarget () {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
   }
 
   /*
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-
   var arrayProto = Array.prototype;
   var arrayMethods = Object.create(arrayProto);
-
   var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-  ];
-
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse' ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args;
-          break
-        case 'splice':
-          inserted = args.slice(2);
-          break
-      }
-      if (inserted) { ob.observeArray(inserted); }
-      // notify change
-      ob.dep.notify();
-      return result
-    });
+      // cache original method
+      var original = arrayProto[method];
+      def(arrayMethods, method, function mutator() {
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
+
+          var result = original.apply(this, args);
+          var ob = this.__ob__;
+          var inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              { ob.observeArray(inserted); }
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  /*  */
-
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
   var shouldObserve = true;
-
-  function toggleObserving (value) {
-    shouldObserve = value;
+  function toggleObserving(value) {
+      shouldObserve = value;
   }
-
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
+          }
+          else {
+              copyAugment(value, arrayMethods, arrayKeys);
+          }
+          this.observeArray(value);
+      }
+      else {
+          this.walk(value);
+      }
   };
-
   /**
    * Walk through all properties and convert them into
    * getter/setters. This method should only be called when
    * value type is Object.
    */
   Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
-    }
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive$$1(obj, keys[i]);
+      }
   };
-
   /**
    * Observe a list of Array items.
    */
   Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
   };
-
   // helpers
-
   /**
    * Augment a target Object or Array by intercepting
    * the prototype chain using __proto__
    */
-  function protoAugment (target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
   }
-
   /**
    * Augment a target Object or Array by defining
    * hidden properties.
    */
   /* istanbul ignore next */
-  function copyAugment (target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
+  function copyAugment(target, src, keys) {
+      for (var i = 0, l = keys.length; i < l; i++) {
+          var key = keys[i];
+          def(target, key, src[key]);
+      }
   }
-
   /**
    * Attempt to create an observer instance for a value,
    * returns the new observer if successfully observed,
    * or the existing observer if the value already has one.
    */
-  function observe (value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      var ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
   }
-
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1 (
-    obj,
-    key,
-    val,
-    customSetter,
-    shallow
-  ) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter () {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter (newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) { return }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      }
-    });
+  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+      var dep = new Dep();
+      var property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      var getter = property && property.get;
+      var setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      var childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              var value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              var value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  { return; }
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
   }
-
   /**
    * Set a property on an object. Adds the new property and
    * triggers change notification if the property doesn't
    * already exist.
    */
-  function set (target, key, val) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-        'at runtime - declare it upfront in the data option.'
-      );
-      return val
-    }
-    if (!ob) {
-      target[key] = val;
-      return val
-    }
-    defineReactive$$1(ob.value, key, val);
-    ob.dep.notify();
-    return val
+  function set(target, key, val) {
+      if (isUndef(target) || isPrimitive(target)) {
+          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      var ob = target.__ob__;
+      // @ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive$$1(ob.value, key, val);
+      ob.dep.notify();
+      return val;
   }
-
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
-  function dependArray (value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
+  function dependArray(value) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
    */
   var strats = config.optionMergeStrategies;
-
   /**
    * Options with restrictions
    */
   {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          "option \"" + key + "\" can only be used during instance " +
-          'creation with the `new` keyword.'
-        );
-      }
-      return defaultStrat(parent, child)
-    };
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn("option \"" + key + "\" can only be used during instance " +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
   }
-
   /**
    * Helper that recursively merges two data objects together.
    */
-  function mergeData (to, from) {
-    if (!from) { return to }
-    var key, toVal, fromVal;
-
-    var keys = hasSymbol
-      ? Reflect.ownKeys(from)
-      : Object.keys(from);
-
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === '__ob__') { continue }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to
+  function mergeData(to, from) {
+      if (!from)
+          { return to; }
+      var key, toVal, fromVal;
+      var keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (var i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              { continue; }
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
   }
-
   /**
    * Data
    */
-  function mergeDataOrFn (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn () {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn () {
-        // instance merge
-        var instanceData = typeof childVal === 'function'
-          ? childVal.call(vm, vm)
-          : childVal;
-        var defaultData = typeof parentVal === 'function'
-          ? parentVal.call(vm, vm)
-          : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
-      }
-    }
-  }
-
-  strats.data = function (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn(
-          'The "data" option should be a function ' +
-          'that returns a per-instance value in component ' +
-          'definitions.',
-          vm
-        );
-
-        return parentVal
-      }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-
-    return mergeDataOrFn(parentVal, childVal, vm)
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(
+              // @ts-ignore
+              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+              // @ts-ignore
+              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
   };
-
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook (
-    parentVal,
-    childVal
-  ) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-          ? childVal
-          : [childVal]
-      : parentVal;
-    return res
-      ? dedupeHooks(res)
-      : res
-  }
-
-  function dedupeHooks (hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
-      }
-    }
-    return res
+  function mergeHook(parentVal, childVal) {
+      var res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      var res = [];
+      for (var i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
   }
-
   LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+      strats[hook] = mergeHook;
   });
-
   /**
    * Assets
    *
@@ -1458,594 +1278,525 @@
    * a three-way merge between constructor options, instance
    * options and parent options.
    */
-  function mergeAssets (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal)
-    } else {
-      return res
-    }
+  function mergeAssets(parentVal, childVal, vm, key) {
+      var res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
   }
-
   ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
+      strats[type + 's'] = mergeAssets;
   });
-
   /**
    * Watchers.
    *
    * Watchers hashes should not overwrite one
    * another, so we merge them as arrays.
    */
-  strats.watch = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    // work around Firefox's Object.prototype.watch...
-    if (parentVal === nativeWatch) { parentVal = undefined; }
-    if (childVal === nativeWatch) { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal) { return Object.create(parentVal || null) }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child) ? child : [child];
-    }
-    return ret
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          { parentVal = undefined; }
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          { childVal = undefined; }
+      /* istanbul ignore if */
+      if (!childVal)
+          { return Object.create(parentVal || null); }
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = {};
+      extend(ret, parentVal);
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
   };
-
   /**
    * Other object hashes.
    */
-  strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== 'production') {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) { extend(ret, childVal); }
-    return ret
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          { extend(ret, childVal); }
+      return ret;
   };
   strats.provide = mergeDataOrFn;
-
   /**
    * Default strategy.
    */
   var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined
-      ? parentVal
-      : childVal
+      return childVal === undefined ? parentVal : childVal;
   };
-
   /**
    * Validate component names
    */
-  function checkComponents (options) {
-    for (var key in options.components) {
-      validateComponentName(key);
-    }
+  function checkComponents(options) {
+      for (var key in options.components) {
+          validateComponentName(key);
+      }
   }
-
-  function validateComponentName (name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-      warn(
-        'Invalid component name: "' + name + '". Component names ' +
-        'should conform to valid custom element name in html5 specification.'
-      );
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-      warn(
-        'Do not use built-in or reserved HTML elements as component ' +
-        'id: ' + name
-      );
-    }
+  function validateComponentName(name) {
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+          warn('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
   }
-
   /**
    * Ensure all props option syntax are normalized into the
    * Object-based format.
    */
-  function normalizeProps (options, vm) {
-    var props = options.props;
-    if (!props) { return }
-    var res = {};
-    var i, val, name;
-    if (Array.isArray(props)) {
-      i = props.length;
-      while (i--) {
-        val = props[i];
-        if (typeof val === 'string') {
-          name = camelize(val);
-          res[name] = { type: null };
-        } else {
-          warn('props must be strings when using array syntax.');
-        }
-      }
-    } else if (isPlainObject(props)) {
-      for (var key in props) {
-        val = props[key];
-        name = camelize(key);
-        res[name] = isPlainObject(val)
-          ? val
-          : { type: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"props\": expected an Array or an Object, " +
-        "but got " + (toRawType(props)) + ".",
-        vm
-      );
-    }
-    options.props = res;
+  function normalizeProps(options, vm) {
+      var props = options.props;
+      if (!props)
+          { return; }
+      var res = {};
+      var i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (var key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"props\": expected an Array or an Object, " +
+              "but got " + (toRawType(props)) + ".", vm);
+      }
+      options.props = res;
   }
-
   /**
    * Normalize all injections into Object-based format
    */
-  function normalizeInject (options, vm) {
-    var inject = options.inject;
-    if (!inject) { return }
-    var normalized = options.inject = {};
-    if (Array.isArray(inject)) {
-      for (var i = 0; i < inject.length; i++) {
-        normalized[inject[i]] = { from: inject[i] };
-      }
-    } else if (isPlainObject(inject)) {
-      for (var key in inject) {
-        var val = inject[key];
-        normalized[key] = isPlainObject(val)
-          ? extend({ from: key }, val)
-          : { from: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"inject\": expected an Array or an Object, " +
-        "but got " + (toRawType(inject)) + ".",
-        vm
-      );
-    }
+  function normalizeInject(options, vm) {
+      var inject = options.inject;
+      if (!inject)
+          { return; }
+      var normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (var i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (var key in inject) {
+              var val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+              "but got " + (toRawType(inject)) + ".", vm);
+      }
   }
-
   /**
    * Normalize raw function directives into object format.
    */
-  function normalizeDirectives (options) {
-    var dirs = options.directives;
-    if (dirs) {
-      for (var key in dirs) {
-        var def$$1 = dirs[key];
-        if (typeof def$$1 === 'function') {
-          dirs[key] = { bind: def$$1, update: def$$1 };
-        }
-      }
-    }
-  }
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
-      );
-    }
+  function normalizeDirectives(options) {
+      var dirs = options.directives;
+      if (dirs) {
+          for (var key in dirs) {
+              var def$$1 = dirs[key];
+              if (typeof def$$1 === 'function') {
+                  dirs[key] = { bind: def$$1, update: def$$1 };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn("Invalid value for option \"" + name + "\": expected an Object, " +
+              "but got " + (toRawType(value)) + ".", vm);
+      }
   }
-
   /**
    * Merge two option objects into a new one.
    * Core utility used in both instantiation and inheritance.
    */
-  function mergeOptions (
-    parent,
-    child,
-    vm
-  ) {
-    {
-      checkComponents(child);
-    }
-
-    if (typeof child === 'function') {
-      child = child.options;
-    }
-
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-      if (child.extends) {
-        parent = mergeOptions(parent, child.extends, vm);
-      }
-      if (child.mixins) {
-        for (var i = 0, l = child.mixins.length; i < l; i++) {
-          parent = mergeOptions(parent, child.mixins[i], vm);
-        }
-      }
-    }
-
-    var options = {};
-    var key;
-    for (key in parent) {
-      mergeField(key);
-    }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
-      }
-    }
-    function mergeField (key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (var i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      var options = {};
+      var key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          var strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
   }
-
   /**
    * Resolve an asset.
    * This function is used because child instances need access
    * to assets defined in its ancestor chain.
    */
-  function resolveAsset (
-    options,
-    type,
-    id,
-    warnMissing
-  ) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-      return
-    }
-    var assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id)) { return assets[id] }
-    var camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-    var PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-    // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-      warn(
-        'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-        options
-      );
-    }
-    return res
-  }
-
-  /*  */
-
-
-
-  function validateProp (
-    key,
-    propOptions,
-    propsData,
-    vm
-  ) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
-    // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-      if (absent && !hasOwn(prop, 'default')) {
-        value = false;
-      } else if (value === '' || value === hyphenate(key)) {
-        // only cast empty string / same name to boolean if
-        // boolean has higher priority
-        var stringIndex = getTypeIndex(String, prop.type);
-        if (stringIndex < 0 || booleanIndex < stringIndex) {
-          value = true;
-        }
-      }
-    }
-    // check default value
-    if (value === undefined) {
-      value = getPropDefaultValue(vm, prop, key);
-      // since the default value is a fresh copy,
-      // make sure to observe it.
-      var prevShouldObserve = shouldObserve;
-      toggleObserving(true);
-      observe(value);
-      toggleObserving(prevShouldObserve);
-    }
-    {
-      assertProp(prop, key, value, vm, absent);
-    }
-    return value
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      var assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          { return assets[id]; }
+      var camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          { return assets[camelizedId]; }
+      var PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          { return assets[PascalCaseId]; }
+      // fallback to prototype chain
+      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
+  }
+
+  /* @flow */
+  function validateProp(key, propOptions, propsData, vm) {
+      var prop = propOptions[key];
+      var absent = !hasOwn(propsData, key);
+      var value = propsData[key];
+      // boolean casting
+      var booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              var stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          var prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
   }
-
   /**
    * Get the default value of a prop.
    */
-  function getPropDefaultValue (vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-      return undefined
-    }
-    var def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-      warn(
-        'Invalid default value for prop "' + key + '": ' +
-        'Props with type Object/Array must use a factory function ' +
-        'to return the default value.',
-        vm
-      );
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm && vm.$options.propsData &&
-      vm.$options.propsData[key] === undefined &&
-      vm._props[key] !== undefined
-    ) {
-      return vm._props[key]
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-      ? def.call(vm)
-      : def
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      var def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
   }
-
   /**
    * Assert whether a prop is valid.
    */
-  function assertProp (
-    prop,
-    name,
-    value,
-    vm,
-    absent
-  ) {
-    if (prop.required && absent) {
-      warn(
-        'Missing required prop: "' + name + '"',
-        vm
-      );
-      return
-    }
-    if (value == null && !prop.required) {
-      return
-    }
-    var type = prop.type;
-    var valid = !type || type === true;
-    var expectedTypes = [];
-    if (type) {
-      if (!Array.isArray(type)) {
-        type = [type];
-      }
-      for (var i = 0; i < type.length && !valid; i++) {
-        var assertedType = assertType(value, type[i]);
-        expectedTypes.push(assertedType.expectedType || '');
-        valid = assertedType.valid;
-      }
-    }
-
-    if (!valid) {
-      warn(
-        getInvalidTypeMessage(name, value, expectedTypes),
-        vm
-      );
-      return
-    }
-    var validator = prop.validator;
-    if (validator) {
-      if (!validator(value)) {
-        warn(
-          'Invalid prop: custom validator check failed for prop "' + name + '".',
-          vm
-        );
-      }
-    }
-  }
-
-  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-  function assertType (value, type) {
-    var valid;
-    var expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-      var t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      // for primitive wrapper objects
-      if (!valid && t === 'object') {
-        valid = value instanceof type;
-      }
-    } else if (expectedType === 'Object') {
-      valid = isPlainObject(value);
-    } else if (expectedType === 'Array') {
-      valid = Array.isArray(value);
-    } else {
-      valid = value instanceof type;
-    }
-    return {
-      valid: valid,
-      expectedType: expectedType
-    }
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      var type = prop.type;
+      // @ts-ignore
+      var valid = !type || type === true;
+      var expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (var i = 0; i < type.length && !valid; i++) {
+              var assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+      if (!valid && haveExpectedTypes) {
+          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      var validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
   }
-
+  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      var valid;
+      var expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          var t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid: valid,
+          expectedType: expectedType,
+      };
+  }
+  var functionTypeCheckRE = /^\s*function (\w+)/;
   /**
    * Use function string name to check built-in types,
    * because a simple equality check will fail when running
    * across different vms / iframes.
    */
-  function getType (fn) {
-    var match = fn && fn.toString().match(/^\s*function (\w+)/);
-    return match ? match[1] : ''
-  }
-
-  function isSameType (a, b) {
-    return getType(a) === getType(b)
-  }
-
-  function getTypeIndex (type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-      return isSameType(expectedTypes, type) ? 0 : -1
-    }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
-      if (isSameType(expectedTypes[i], type)) {
-        return i
-      }
-    }
-    return -1
-  }
-
-  function getInvalidTypeMessage (name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-      " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
-    var expectedValue = styleValue(value, expectedType);
-    var receivedValue = styleValue(value, receivedType);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        !isBoolean(expectedType, receivedType)) {
-      message += " with value " + expectedValue;
-    }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-      message += "with value " + receivedValue + ".";
-    }
-    return message
-  }
-
-  function styleValue (value, type) {
-    if (type === 'String') {
-      return ("\"" + value + "\"")
-    } else if (type === 'Number') {
-      return ("" + (Number(value)))
-    } else {
-      return ("" + value)
-    }
-  }
-
-  function isExplicable (value) {
-    var explicitTypes = ['string', 'number', 'boolean'];
-    return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
-  }
-
-  function isBoolean () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
-  }
-
-  /*  */
-
-  function handleError (err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-      if (vm) {
-        var cur = vm;
-        while ((cur = cur.$parent)) {
-          var hooks = cur.$options.errorCaptured;
-          if (hooks) {
-            for (var i = 0; i < hooks.length; i++) {
-              try {
-                var capture = hooks[i].call(cur, err, vm, info) === false;
-                if (capture) { return }
-              } catch (e) {
-                globalHandleError(e, cur, 'errorCaptured hook');
-              }
-            }
+  function getType(fn) {
+      var match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (var i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
           }
-        }
       }
-      globalHandleError(err, vm, info);
-    } finally {
-      popTarget();
-    }
+      return -1;
   }
-
-  function invokeWithErrorHandling (
-    handler,
-    context,
-    args,
-    vm,
-    info
-  ) {
-    var res;
-    try {
-      res = args ? handler.apply(context, args) : handler.call(context);
-      if (res && !res._isVue && isPromise(res) && !res._handled) {
-        res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-        // issue #9511
-        // avoid catch triggering multiple times when nested calls
-        res._handled = true;
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
+      var expectedType = expectedTypes[0];
+      var receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += " with value " + (styleValue(value, expectedType));
       }
-    } catch (e) {
-      handleError(e, vm, info);
-    }
-    return res
+      message += ", got " + receivedType + " ";
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += "with value " + (styleValue(value, receivedType)) + ".";
+      }
+      return message;
   }
-
-  function globalHandleError (err, vm, info) {
-    logError(err, vm, info);
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return ("\"" + value + "\"");
+      }
+      else if (type === 'Number') {
+          return ("" + (Number(value)));
+      }
+      else {
+          return ("" + value);
+      }
+  }
+  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
+  function isBoolean() {
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-  function logError (err, vm, info) {
-    {
-      warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-      console.error(err);
-    } else {
-      throw err
-    }
+      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
-  /*  */
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              var cur = vm;
+              while ((cur = cur.$parent)) {
+                  var hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (var i = 0; i < hooks.length; i++) {
+                          try {
+                              var capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  { return; }
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      var res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
+  }
 
+  /* @flow */
   var callbacks = [];
-
-  function flushCallbacks () {
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
+  function flushCallbacks() {
+      var copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (var i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
   }
-
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -2053,966 +1804,849 @@
   // completely stops working after triggering a few times... so, if native
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-    isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]'
-  )) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true
-    });
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-  /*  */
-
-  /*  */
-
-  function genClassForVnode (vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-      childNode = childNode.componentInstance._vnode;
-      if (childNode && childNode.data) {
-        data = mergeClassData(childNode.data, data);
-      }
-    }
-    while (isDef(parentNode = parentNode.parent)) {
-      if (parentNode && parentNode.data) {
-        data = mergeClassData(data, parentNode.data);
-      }
-    }
-    return renderClass(data.staticClass, data.class)
-  }
-
-  function mergeClassData (child, parent) {
-    return {
-      staticClass: concat(child.staticClass, parent.staticClass),
-      class: isDef(child.class)
-        ? [child.class, parent.class]
-        : parent.class
-    }
-  }
-
-  function renderClass (
-    staticClass,
-    dynamicClass
-  ) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-      return concat(staticClass, stringifyClass(dynamicClass))
-    }
-    /* istanbul ignore next */
-    return ''
-  }
-
-  function concat (a, b) {
-    return a ? b ? (a + ' ' + b) : a : (b || '')
-  }
-
-  function stringifyClass (value) {
-    if (Array.isArray(value)) {
-      return stringifyArray(value)
-    }
-    if (isObject(value)) {
-      return stringifyObject(value)
-    }
-    if (typeof value === 'string') {
-      return value
-    }
-    /* istanbul ignore next */
-    return ''
-  }
-
-  function stringifyArray (value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
-      if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-        if (res) { res += ' '; }
-        res += stringified;
-      }
-    }
-    return res
-  }
-
-  function stringifyObject (value) {
-    var res = '';
-    for (var key in value) {
-      if (value[key]) {
-        if (res) { res += ' '; }
-        res += key;
-      }
-    }
-    return res
-  }
-
-  /*  */
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-  );
+  if (typeof Promise !== 'undefined' && isNative(Promise)) ;
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      var counter = 1;
+      var observer = new MutationObserver(flushCallbacks);
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 
+  /* @flow */
+
+  /* @flow */
+  function genClassForVnode(vnode) {
+      var data = vnode.data;
+      var parentNode = vnode;
+      var childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass(data.staticClass, data.class);
+  }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
+  }
+  function renderClass(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
+  }
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function stringifyArray(value) {
+      var res = '';
+      var stringified;
+      for (var i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  { res += ' '; }
+              res += stringified;
+          }
+      }
+      return res;
+  }
+  function stringifyObject(value) {
+      var res = '';
+      for (var key in value) {
+          if (value[key]) {
+              if (res)
+                  { res += ' '; }
+              res += key;
+          }
+      }
+      return res;
+  }
+
+  /* @flow */
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  );
-
+  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
   var isPreTag = function (tag) { return tag === 'pre'; };
-
   var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
+      return isHTMLTag(tag) || isSVG(tag);
   };
-
-  function getTagNamespace (tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
   }
-
   var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /*  */
-
-  /*  */
+  /* @flow */
 
-  function renderClass$1 (node) {
-    var classList = genClassForVnode(node);
-    if (classList !== '') {
-      return (" class=\"" + (escape(classList)) + "\"")
-    }
+  /* @flow */
+  function renderClass$1(node) {
+      var classList = genClassForVnode(node);
+      if (classList !== '') {
+          return (" class=\"" + (escape(classList)) + "\"");
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res
+      var res = {};
+      var listDelimiter = /;(?![^(]*\))/g;
+      var propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              var tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
   });
-
   // merge static and dynamic style data on the same vnode
-  function normalizeStyleData (data) {
-    var style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle
-      ? extend(data.staticStyle, style)
-      : style
+  function normalizeStyleData(data) {
+      var style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
   }
-
   // normalize possible array / string values into Object
-  function normalizeStyleBinding (bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-      return toObject(bindingStyle)
-    }
-    if (typeof bindingStyle === 'string') {
-      return parseStyleText(bindingStyle)
-    }
-    return bindingStyle
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
   }
-
   /**
    * parent component style should be after child's
    * so that parent component's style could override it
    */
-  function getStyle (vnode, checkChild) {
-    var res = {};
-    var styleData;
-
-    if (checkChild) {
-      var childNode = vnode;
-      while (childNode.componentInstance) {
-        childNode = childNode.componentInstance._vnode;
-        if (
-          childNode && childNode.data &&
-          (styleData = normalizeStyleData(childNode.data))
-        ) {
+  function getStyle(vnode, checkChild) {
+      var res = {};
+      var styleData;
+      if (checkChild) {
+          var childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
-        }
       }
-    }
-
-    if ((styleData = normalizeStyleData(vnode.data))) {
-      extend(res, styleData);
-    }
-
-    var parentNode = vnode;
-    while ((parentNode = parentNode.parent)) {
-      if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-        extend(res, styleData);
+      var parentNode = vnode;
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
       }
-    }
-    return res
+      return res;
   }
 
-  /*  */
-
-  function genStyle (style) {
-    var styleText = '';
-    for (var key in style) {
-      var value = style[key];
-      var hyphenatedKey = hyphenate(key);
-      if (Array.isArray(value)) {
-        for (var i = 0, len = value.length; i < len; i++) {
-          styleText += normalizeValue(hyphenatedKey, value[i]);
-        }
-      } else {
-        styleText += normalizeValue(hyphenatedKey, value);
+  /* @flow */
+  function genStyle(style) {
+      var styleText = '';
+      for (var key in style) {
+          var value = style[key];
+          var hyphenatedKey = hyphenate(key);
+          if (Array.isArray(value)) {
+              for (var i = 0, len = value.length; i < len; i++) {
+                  styleText += normalizeValue(hyphenatedKey, value[i]);
+              }
+          }
+          else {
+              styleText += normalizeValue(hyphenatedKey, value);
+          }
       }
-    }
-    return styleText
+      return styleText;
   }
-
   function normalizeValue(key, value) {
-    if (
-      typeof value === 'string' ||
-      (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-      value === 0
-    ) {
-      return (key + ":" + value + ";")
-    } else {
-      // invalid values
-      return ""
-    }
+      if (typeof value === 'string' ||
+          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+          value === 0) {
+          return (key + ":" + value + ";");
+      }
+      else {
+          // invalid values
+          return "";
+      }
   }
-
-  function renderStyle (vnode) {
-    var styleText = genStyle(getStyle(vnode, false));
-    if (styleText !== '') {
-      return (" style=" + (JSON.stringify(escape(styleText))))
-    }
+  function renderStyle(vnode) {
+      var styleText = genStyle(getStyle(vnode, false));
+      if (styleText !== '') {
+          return (" style=" + (JSON.stringify(escape(styleText))));
+      }
   }
 
-  var modules = [
-    renderAttrs,
-    renderDOMProps,
-    renderClass$1,
-    renderStyle
-  ];
+  var modules = [renderAttrs, renderDOMProps, renderClass$1, renderStyle];
 
-  /*  */
-
-  function show (node, dir) {
-    if (!dir.value) {
-      var style = node.data.style || (node.data.style = {});
-      if (Array.isArray(style)) {
-        style.push({ display: 'none' });
-      } else {
-        style.display = 'none';
+  /* @flow */
+  function show(node, dir) {
+      if (!dir.value) {
+          var style = node.data.style || (node.data.style = {});
+          if (Array.isArray(style)) {
+              style.push({ display: 'none' });
+          }
+          else {
+              style.display = 'none';
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   // this is only applied for <select v-model> because it is the only edge case
   // that must be done at runtime instead of compile time.
-  function model (node, dir) {
-    if (!node.children) { return }
-    var value = dir.value;
-    var isMultiple = node.data.attrs && node.data.attrs.multiple;
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var option = node.children[i];
-      if (option.tag === 'option') {
-        if (isMultiple) {
-          var selected =
-            Array.isArray(value) &&
-            (looseIndexOf(value, getValue(option)) > -1);
-          if (selected) {
-            setSelected(option);
-          }
-        } else {
-          if (looseEqual(value, getValue(option))) {
-            setSelected(option);
-            return
+  function model(node, dir) {
+      if (!node.children)
+          { return; }
+      var value = dir.value;
+      var isMultiple = node.data.attrs && node.data.attrs.multiple;
+      for (var i = 0, l = node.children.length; i < l; i++) {
+          var option = node.children[i];
+          if (option.tag === 'option') {
+              if (isMultiple) {
+                  var selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                  if (selected) {
+                      setSelected(option);
+                  }
+              }
+              else {
+                  if (looseEqual(value, getValue(option))) {
+                      setSelected(option);
+                      return;
+                  }
+              }
           }
-        }
       }
-    }
   }
-
-  function getValue (option) {
-    var data = option.data || {};
-    return (
-      (data.attrs && data.attrs.value) ||
-      (data.domProps && data.domProps.value) ||
-      (option.children && option.children[0] && option.children[0].text)
-    )
+  function getValue(option) {
+      var data = option.data || {};
+      return ((data.attrs && data.attrs.value) ||
+          (data.domProps && data.domProps.value) ||
+          (option.children && option.children[0] && option.children[0].text));
   }
-
-  function setSelected (option) {
-    var data = option.data || (option.data = {});
-    var attrs = data.attrs || (data.attrs = {});
-    attrs.selected = '';
+  function setSelected(option) {
+      var data = option.data || (option.data = {});
+      var attrs = data.attrs || (data.attrs = {});
+      attrs.selected = '';
   }
 
   var directives = {
-    show: show,
-    model: model
+      show: show,
+      model: model,
   };
 
-  /*  */
-
-  var isUnaryTag = makeMap(
-    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr'
-  );
-
+  /* @flow */
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap(
-    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-  );
-
+  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap(
-    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track'
-  );
-
-  /*  */
+  var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
 
+  /* @flow */
   var MAX_STACK_DEPTH = 800;
   var noop$1 = function (_) { return _; };
-
   var defer = typeof process !== 'undefined' && process.nextTick
-    ? process.nextTick
-    : typeof Promise !== 'undefined'
-      ? function (fn) { return Promise.resolve().then(fn); }
-      : typeof setTimeout !== 'undefined'
-        ? setTimeout
-        : noop$1;
-
+      ? process.nextTick
+      : typeof Promise !== 'undefined'
+          ? function (fn) { return Promise.resolve().then(fn); }
+          : typeof setTimeout !== 'undefined'
+              ? setTimeout
+              : noop$1;
   if (defer === noop$1) {
-    throw new Error(
-      'Your JavaScript runtime does not support any asynchronous primitives ' +
-      'that are required by vue-server-renderer. Please use a polyfill for ' +
-      'either Promise or setTimeout.'
-    )
-  }
-
-  function createWriteFunction (
-    write,
-    onError
-  ) {
-    var stackDepth = 0;
-    var cachedWrite = function (text, next) {
-      if (text && cachedWrite.caching) {
-        cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-      }
-      var waitForNext = write(text, next);
-      if (waitForNext !== true) {
-        if (stackDepth >= MAX_STACK_DEPTH) {
-          defer(function () {
-            try { next(); } catch (e) {
-              onError(e);
-            }
-          });
-        } else {
-          stackDepth++;
-          next();
-          stackDepth--;
-        }
-      }
-    };
-    cachedWrite.caching = false;
-    cachedWrite.cacheBuffer = [];
-    cachedWrite.componentBuffer = [];
-    return cachedWrite
-  }
-
-  /*  */
-
-
-
-  var RenderContext = function RenderContext (options) {
-    this.userContext = options.userContext;
-    this.activeInstance = options.activeInstance;
-    this.renderStates = [];
-
-    this.write = options.write;
-    this.done = options.done;
-    this.renderNode = options.renderNode;
-
-    this.isUnaryTag = options.isUnaryTag;
-    this.modules = options.modules;
-    this.directives = options.directives;
-
-    var cache = options.cache;
-    if (cache && (!cache.get || !cache.set)) {
-      throw new Error('renderer cache must implement at least get & set.')
-    }
-    this.cache = cache;
-    this.get = cache && normalizeAsync(cache, 'get');
-    this.has = cache && normalizeAsync(cache, 'has');
-
-    this.next = this.next.bind(this);
+      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+          'that are required by vue-server-renderer. Please use a polyfill for ' +
+          'either Promise or setTimeout.');
+  }
+  function createWriteFunction(write, onError) {
+      var stackDepth = 0;
+      var cachedWrite = function (text, next) {
+          if (text && cachedWrite.caching) {
+              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+          }
+          var waitForNext = write(text, next);
+          if (waitForNext !== true) {
+              if (stackDepth >= MAX_STACK_DEPTH) {
+                  defer(function () {
+                      try {
+                          next();
+                      }
+                      catch (e) {
+                          onError(e);
+                      }
+                  });
+              }
+              else {
+                  stackDepth++;
+                  next();
+                  stackDepth--;
+              }
+          }
+      };
+      cachedWrite.caching = false;
+      cachedWrite.cacheBuffer = [];
+      cachedWrite.componentBuffer = [];
+      return cachedWrite;
+  }
+
+  /* @flow */
+  var RenderContext = function RenderContext(options) {
+      this.userContext = options.userContext;
+      this.activeInstance = options.activeInstance;
+      this.renderStates = [];
+      this.write = options.write;
+      this.done = options.done;
+      this.renderNode = options.renderNode;
+      this.isUnaryTag = options.isUnaryTag;
+      this.modules = options.modules;
+      this.directives = options.directives;
+      var cache = options.cache;
+      if (cache && (!cache.get || !cache.set)) {
+          throw new Error('renderer cache must implement at least get & set.');
+      }
+      this.cache = cache;
+      this.get = cache && normalizeAsync(cache, 'get');
+      this.has = cache && normalizeAsync(cache, 'has');
+      //@ts-expect-error
+      this.next = this.next.bind(this);
   };
-
+  //@ts-expect-error
   RenderContext.prototype.next = function next () {
-    // eslint-disable-next-line
-    while (true) {
-      var lastState = this.renderStates[this.renderStates.length - 1];
-      if (isUndef(lastState)) {
-        return this.done()
-      }
-      /* eslint-disable no-case-declarations */
-      switch (lastState.type) {
-        case 'Element':
-        case 'Fragment':
-          var children = lastState.children;
-        var total = lastState.total;
-          var rendered = lastState.rendered++;
-          if (rendered < total) {
-            return this.renderNode(children[rendered], false, this)
-          } else {
-            this.renderStates.pop();
-            if (lastState.type === 'Element') {
-              return this.write(lastState.endTag, this.next)
-            }
-          }
-          break
-        case 'Component':
-          this.renderStates.pop();
-          this.activeInstance = lastState.prevActive;
-          break
-        case 'ComponentWithCache':
-          this.renderStates.pop();
-          var buffer = lastState.buffer;
-        var bufferIndex = lastState.bufferIndex;
-        var componentBuffer = lastState.componentBuffer;
-        var key = lastState.key;
-          var result = {
-            html: buffer[bufferIndex],
-            components: componentBuffer[bufferIndex]
-          };
-          this.cache.set(key, result);
-          if (bufferIndex === 0) {
-            // this is a top-level cached component,
-            // exit caching mode.
-            this.write.caching = false;
-          } else {
-            // parent component is also being cached,
-            // merge self into parent's result
-            buffer[bufferIndex - 1] += result.html;
-            var prev = componentBuffer[bufferIndex - 1];
-            result.components.forEach(function (c) { return prev.add(c); });
-          }
-          buffer.length = bufferIndex;
-          componentBuffer.length = bufferIndex;
-          break
-      }
-    }
+      // eslint-disable-next-line
+      while (true) {
+          var lastState = this.renderStates[this.renderStates.length - 1];
+          if (isUndef(lastState)) {
+              return this.done();
+          }
+          /* eslint-disable no-case-declarations */
+          switch (lastState.type) {
+              case 'Element':
+              case 'Fragment':
+                  var children = lastState.children;
+              var total = lastState.total;
+                  var rendered = lastState.rendered++;
+                  if (rendered < total) {
+                      return this.renderNode(children[rendered], false, this);
+                  }
+                  else {
+                      this.renderStates.pop();
+                      if (lastState.type === 'Element') {
+                          return this.write(lastState.endTag, this.next);
+                      }
+                  }
+                  break;
+              case 'Component':
+                  this.renderStates.pop();
+                  this.activeInstance = lastState.prevActive;
+                  break;
+              case 'ComponentWithCache':
+                  this.renderStates.pop();
+                  var buffer = lastState.buffer;
+              var bufferIndex = lastState.bufferIndex;
+              var componentBuffer = lastState.componentBuffer;
+              var key = lastState.key;
+                  var result = {
+                      html: buffer[bufferIndex],
+                      components: componentBuffer[bufferIndex],
+                  };
+                  this.cache.set(key, result);
+                  if (bufferIndex === 0) {
+                      // this is a top-level cached component,
+                      // exit caching mode.
+                      //@ts-expect-error
+                      this.write.caching = false;
+                  }
+                  else {
+                      // parent component is also being cached,
+                      // merge self into parent's result
+                      buffer[bufferIndex - 1] += result.html;
+                      var prev = componentBuffer[bufferIndex - 1];
+                      result.components.forEach(function (c) { return prev.add(c); });
+                  }
+                  buffer.length = bufferIndex;
+                  componentBuffer.length = bufferIndex;
+                  break;
+          }
+      }
   };
-
-  function normalizeAsync (cache, method) {
-    var fn = cache[method];
-    if (isUndef(fn)) {
-      return
-    } else if (fn.length > 1) {
-      return function (key, cb) { return fn.call(cache, key, cb); }
-    } else {
-      return function (key, cb) { return cb(fn.call(cache, key)); }
-    }
+  function normalizeAsync(cache, method) {
+      var fn = cache[method];
+      if (isUndef(fn)) {
+          return;
+      }
+      else if (fn.length > 1) {
+          return function (key, cb) { return fn.call(cache, key, cb); };
+      }
+      else {
+          return function (key, cb) { return cb(fn.call(cache, key)); };
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-  function parseFilters (exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
-
-    for (i = 0; i < exp.length; i++) {
-      prev = c;
-      c = exp.charCodeAt(i);
-      if (inSingle) {
-        if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-      } else if (inDouble) {
-        if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-      } else if (inTemplateString) {
-        if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-      } else if (inRegex) {
-        if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-      } else if (
-        c === 0x7C && // pipe
-        exp.charCodeAt(i + 1) !== 0x7C &&
-        exp.charCodeAt(i - 1) !== 0x7C &&
-        !curly && !square && !paren
-      ) {
-        if (expression === undefined) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1;
+  function parseFilters(exp) {
+      var inSingle = false;
+      var inDouble = false;
+      var inTemplateString = false;
+      var inRegex = false;
+      var curly = 0;
+      var square = 0;
+      var paren = 0;
+      var lastFilterIndex = 0;
+      var c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  { inSingle = false; }
+          }
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  { inDouble = false; }
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  { inTemplateString = false; }
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  { inRegex = false; }
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  var j = i - 1;
+                  var p = (void 0);
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          { break; }
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
+          }
+      }
+      if (expression === undefined) {
           expression = exp.slice(0, i).trim();
-        } else {
+      }
+      else if (lastFilterIndex !== 0) {
           pushFilter();
-        }
-      } else {
-        switch (c) {
-          case 0x22: inDouble = true; break         // "
-          case 0x27: inSingle = true; break         // '
-          case 0x60: inTemplateString = true; break // `
-          case 0x28: paren++; break                 // (
-          case 0x29: paren--; break                 // )
-          case 0x5B: square++; break                // [
-          case 0x5D: square--; break                // ]
-          case 0x7B: curly++; break                 // {
-          case 0x7D: curly--; break                 // }
-        }
-        if (c === 0x2f) { // /
-          var j = i - 1;
-          var p = (void 0);
-          // find first non-whitespace prev char
-          for (; j >= 0; j--) {
-            p = exp.charAt(j);
-            if (p !== ' ') { break }
-          }
-          if (!p || !validDivisionCharRE.test(p)) {
-            inRegex = true;
-          }
-        }
-      }
-    }
-
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
-    }
-
-    function pushFilter () {
-      (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-      lastFilterIndex = i + 1;
-    }
-
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i]);
-      }
-    }
-
-    return expression
-  }
-
-  function wrapFilter (exp, filter) {
-    var i = filter.indexOf('(');
-    if (i < 0) {
-      // _f: resolveFilter
-      return ("_f(\"" + filter + "\")(" + exp + ")")
-    } else {
-      var name = filter.slice(0, i);
-      var args = filter.slice(i + 1);
-      return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-    }
-  }
-
-  /*  */
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
+  }
+  function wrapFilter(exp, filter) {
+      var i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return ("_f(\"" + filter + "\")(" + exp + ")");
+      }
+      else {
+          var name = filter.slice(0, i);
+          var args = filter.slice(i + 1);
+          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+      }
+  }
 
+  /* @flow */
   var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
   var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+      var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
   });
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      var tokens = [];
+      var rawTokens = [];
+      var lastIndex = (tagRE.lastIndex = 0);
+      var match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          var exp = parseFilters(match[1].trim());
+          tokens.push(("_s(" + exp + ")"));
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
+  }
 
-
-
-  function parseText (
-    text,
-    delimiters
-  ) {
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-      return
-    }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = tagRE.lastIndex = 0;
-    var match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-      index = match.index;
-      // push text token
-      if (index > lastIndex) {
-        rawTokens.push(tokenValue = text.slice(lastIndex, index));
-        tokens.push(JSON.stringify(tokenValue));
-      }
-      // tag token
-      var exp = parseFilters(match[1].trim());
-      tokens.push(("_s(" + exp + ")"));
-      rawTokens.push({ '@binding': exp });
-      lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      rawTokens.push(tokenValue = text.slice(lastIndex));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
-    }
-  }
-
-  /*  */
-
-
-
+  /* @flow */
   /* eslint-disable no-unused-vars */
-  function baseWarn (msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+  function baseWarn(msg, range) {
+      console.error(("[Vue compiler]: " + msg));
   }
   /* eslint-enable no-unused-vars */
-
-  function pluckModuleFunction (
-    modules,
-    key
-  ) {
-    return modules
-      ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-      : []
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
   }
-
-  function addProp (el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      el.plain = false;
   }
-
-  function addAttr (el, name, value, range, dynamic) {
-    var attrs = dynamic
-      ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-      : (el.attrs || (el.attrs = []));
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addAttr(el, name, value, range, dynamic) {
+      var attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      el.plain = false;
   }
-
   // add a raw attr (use this in preTransforms)
-  function addRawAttr (el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-  }
-
-  function addDirective (
-    el,
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers,
-    range
-  ) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-      name: name,
-      rawName: rawName,
-      value: value,
-      arg: arg,
-      isDynamicArg: isDynamicArg,
-      modifiers: modifiers
-    }, range));
-    el.plain = false;
-  }
-
-  function prependModifierMarker (symbol, name, dynamic) {
-    return dynamic
-      ? ("_p(" + name + ",\"" + symbol + "\")")
-      : symbol + name // mark the event as captured
-  }
-
-  function addHandler (
-    el,
-    name,
-    value,
-    modifiers,
-    important,
-    warn,
-    range,
-    dynamic
-  ) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (
-      warn &&
-      modifiers.prevent && modifiers.passive
-    ) {
-      warn(
-        'passive and prevent can\'t be used together. ' +
-        'Passive handler can\'t prevent default event.',
-        range
-      );
-    }
-
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'contextmenu';
-        delete modifiers.right;
-      }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'mouseup';
-      }
-    }
-
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture;
-      name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-      delete modifiers.once;
-      name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive;
-      name = prependModifierMarker('&', name, dynamic);
-    }
-
-    var events;
-    if (modifiers.native) {
-      delete modifiers.native;
-      events = el.nativeEvents || (el.nativeEvents = {});
-    } else {
-      events = el.events || (el.events = {});
-    }
-
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers;
-    }
-
-    var handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-      important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    } else if (handlers) {
-      events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    } else {
-      events[name] = newHandler;
-    }
-
-    el.plain = false;
-  }
-
-  function getRawBindingAttr (
-    el,
-    name
-  ) {
-    return el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
-  }
-
-  function getBindingAttr (
-    el,
-    name,
-    getStatic
-  ) {
-    var dynamicValue =
-      getAndRemoveAttr(el, ':' + name) ||
-      getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-      return parseFilters(dynamicValue)
-    } else if (getStatic !== false) {
-      var staticValue = getAndRemoveAttr(el, name);
-      if (staticValue != null) {
-        return JSON.stringify(staticValue)
-      }
-    }
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name: name,
+          rawName: rawName,
+          value: value,
+          arg: arg,
+          isDynamicArg: isDynamicArg,
+          modifiers: modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      var events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      var handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
+  }
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
+  }
+  function getBindingAttr(el, name, getStatic) {
+      var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          var staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
   }
-
   // note: this only removes the attr from the Array (attrsList) so that it
   // doesn't get processed by processAttrs.
   // By default it does NOT remove it from the map (attrsMap) because the map is
   // needed during codegen.
-  function getAndRemoveAttr (
-    el,
-    name,
-    removeFromMap
-  ) {
-    var val;
-    if ((val = el.attrsMap[name]) != null) {
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      var val;
+      if ((val = el.attrsMap[name]) != null) {
+          var list = el.attrsList;
+          for (var i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
+      }
+      if (removeFromMap) {
+          delete el.attrsMap[name];
+      }
+      return val;
+  }
+  function getAndRemoveAttrByRegex(el, name) {
       var list = el.attrsList;
       for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i].name === name) {
-          list.splice(i, 1);
-          break
-        }
-      }
-    }
-    if (removeFromMap) {
-      delete el.attrsMap[name];
-    }
-    return val
-  }
-
-  function getAndRemoveAttrByRegex (
-    el,
-    name
-  ) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      var attr = list[i];
-      if (name.test(attr.name)) {
-        list.splice(i, 1);
-        return attr
-      }
-    }
-  }
-
-  function rangeSetItem (
-    item,
-    range
-  ) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start;
-      }
-      if (range.end != null) {
-        item.end = range.end;
-      }
-    }
-    return item
-  }
-
-  /*  */
-
-  function transformNode (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-      var res = parseText(staticClass, options.delimiters);
-      if (res) {
-        warn(
-          "class=\"" + staticClass + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div class="{{ val }}">, use <div :class="val">.',
-          el.rawAttrsMap['class']
-        );
-      }
-    }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass);
-    }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-      el.classBinding = classBinding;
-    }
-  }
-
-  function genData (el) {
-    var data = '';
-    if (el.staticClass) {
-      data += "staticClass:" + (el.staticClass) + ",";
-    }
-    if (el.classBinding) {
-      data += "class:" + (el.classBinding) + ",";
-    }
-    return data
+          var attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
+      }
+  }
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
+      }
+      return item;
   }
 
+  /* @flow */
+  function transformNode(el, options) {
+      var warn = options.warn || baseWarn;
+      var staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          var res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn("class=\"" + staticClass + "\": " +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
+      }
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass);
+      }
+      var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
+      }
+  }
+  function genData(el) {
+      var data = '';
+      if (el.staticClass) {
+          data += "staticClass:" + (el.staticClass) + ",";
+      }
+      if (el.classBinding) {
+          data += "class:" + (el.classBinding) + ",";
+      }
+      return data;
+  }
   var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData
+      staticKeys: ['staticClass'],
+      transformNode: transformNode,
+      genData: genData,
   };
 
-  /*  */
-
-  function transformNode$1 (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-      /* istanbul ignore if */
-      {
-        var res = parseText(staticStyle, options.delimiters);
-        if (res) {
-          warn(
-            "style=\"" + staticStyle + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div style="{{ val }}">, use <div :style="val">.',
-            el.rawAttrsMap['style']
-          );
-        }
+  /* @flow */
+  function transformNode$1(el, options) {
+      var warn = options.warn || baseWarn;
+      var staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              var res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn("style=\"" + staticStyle + "\": " +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
       }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-      el.styleBinding = styleBinding;
-    }
   }
-
-  function genData$1 (el) {
-    var data = '';
-    if (el.staticStyle) {
-      data += "staticStyle:" + (el.staticStyle) + ",";
-    }
-    if (el.styleBinding) {
-      data += "style:(" + (el.styleBinding) + "),";
-    }
-    return data
+  function genData$1(el) {
+      var data = '';
+      if (el.staticStyle) {
+          data += "staticStyle:" + (el.staticStyle) + ",";
+      }
+      if (el.styleBinding) {
+          data += "style:(" + (el.styleBinding) + "),";
+      }
+      return data;
   }
-
   var style = {
-    staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
-    genData: genData$1
+      staticKeys: ['staticStyle'],
+      transformNode: transformNode$1,
+      genData: genData$1,
   };
 
   var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -3360,13 +2994,17 @@
   }(commonjsGlobal));
   });
 
+  var he$1 = /*#__PURE__*/Object.freeze({
+    default: he,
+    __moduleExports: he
+  });
+
   /**
    * Not type-checking this file because it's mostly vendor code.
    */
-
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
   var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -3376,334 +3014,309 @@
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
   var conditionalComment = /^<!\[/;
-
   // Special Elements (can contain anything)
   var isPlainTextElement = makeMap('script,style,textarea', true);
   var reCache = {};
-
   var decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'"
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
   };
   var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
   var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+  function decodeAttr(value, shouldDecodeNewlines) {
+      var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, function (match) { return decodingMap[match]; });
+  }
+  function parseHTML(html, options) {
+      var stack = [];
+      var expectHTML = options.expectHTML;
+      var isUnaryTag$$1 = options.isUnaryTag || no;
+      var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+      var index = 0;
+      var last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              var textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      var commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      var conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  var doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  var endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      var curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  var startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              var text = (void 0), rest = (void 0), next = (void 0);
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          { break; }
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
+              }
+          }
+          else {
+              var endTagLength = 0;
+              var stackedTag = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest$1.length;
+              html = rest$1;
+              parseEndTag(stackedTag, index - endTagLength, index);
+          }
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                      start: index + html.length,
+                  });
+              }
+              break;
+          }
+      }
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          var start = html.match(startTagOpen);
+          if (start) {
+              var match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              var end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
+      }
+      function handleStartTag(match) {
+          var tagName = match.tagName;
+          var unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+          var l = match.attrs.length;
+          var attrs = new Array(l);
+          for (var i = 0; i < l; i++) {
+              var args = match.attrs[i];
+              var value = args[3] || args[4] || args[5] || '';
+              var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
+          }
+      }
+      function parseEndTag(tagName, start, end) {
+          var pos, lowerCasedTagName;
+          if (start == null)
+              { start = index; }
+          if (end == null)
+              { end = index; }
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (var i = stack.length - 1; i >= pos; i--) {
+                  if (i > pos || !tagName &&
+                      options.warn) {
+                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
+          }
+      }
+  }
 
-  function decodeAttr (value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; })
-  }
-
-  function parseHTML (html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
-    while (html) {
-      last = html;
-      // Make sure we're not in a plaintext content element like script/style
-      if (!lastTag || !isPlainTextElement(lastTag)) {
-        var textEnd = html.indexOf('<');
-        if (textEnd === 0) {
-          // Comment:
-          if (comment.test(html)) {
-            var commentEnd = html.indexOf('-->');
-
-            if (commentEnd >= 0) {
-              if (options.shouldKeepComment) {
-                options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-              }
-              advance(commentEnd + 3);
-              continue
-            }
-          }
-
-          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (conditionalComment.test(html)) {
-            var conditionalEnd = html.indexOf(']>');
-
-            if (conditionalEnd >= 0) {
-              advance(conditionalEnd + 2);
-              continue
-            }
-          }
-
-          // Doctype:
-          var doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length);
-            continue
-          }
-
-          // End tag:
-          var endTagMatch = html.match(endTag);
-          if (endTagMatch) {
-            var curIndex = index;
-            advance(endTagMatch[0].length);
-            parseEndTag(endTagMatch[1], curIndex, index);
-            continue
-          }
-
-          // Start tag:
-          var startTagMatch = parseStartTag();
-          if (startTagMatch) {
-            handleStartTag(startTagMatch);
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1);
-            }
-            continue
-          }
-        }
-
-        var text = (void 0), rest = (void 0), next = (void 0);
-        if (textEnd >= 0) {
-          rest = html.slice(textEnd);
-          while (
-            !endTag.test(rest) &&
-            !startTagOpen.test(rest) &&
-            !comment.test(rest) &&
-            !conditionalComment.test(rest)
-          ) {
-            // < in plain text, be forgiving and treat it as text
-            next = rest.indexOf('<', 1);
-            if (next < 0) { break }
-            textEnd += next;
-            rest = html.slice(textEnd);
-          }
-          text = html.substring(0, textEnd);
-        }
-
-        if (textEnd < 0) {
-          text = html;
-        }
-
-        if (text) {
-          advance(text.length);
-        }
-
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index);
-        }
-      } else {
-        var endTagLength = 0;
-        var stackedTag = lastTag.toLowerCase();
-        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-        var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-          endTagLength = endTag.length;
-          if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-            text = text
-              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-          }
-          if (shouldIgnoreFirstNewline(stackedTag, text)) {
-            text = text.slice(1);
-          }
-          if (options.chars) {
-            options.chars(text);
-          }
-          return ''
-        });
-        index += html.length - rest$1.length;
-        html = rest$1;
-        parseEndTag(stackedTag, index - endTagLength, index);
-      }
-
-      if (html === last) {
-        options.chars && options.chars(html);
-        if (!stack.length && options.warn) {
-          options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-        }
-        break
-      }
-    }
-
-    // Clean up any remaining tags
-    parseEndTag();
-
-    function advance (n) {
-      index += n;
-      html = html.substring(n);
-    }
-
-    function parseStartTag () {
-      var start = html.match(startTagOpen);
-      if (start) {
-        var match = {
-          tagName: start[1],
-          attrs: [],
-          start: index
-        };
-        advance(start[0].length);
-        var end, attr;
-        while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-          attr.start = index;
-          advance(attr[0].length);
-          attr.end = index;
-          match.attrs.push(attr);
-        }
-        if (end) {
-          match.unarySlash = end[1];
-          advance(end[0].length);
-          match.end = index;
-          return match
-        }
-      }
-    }
-
-    function handleStartTag (match) {
-      var tagName = match.tagName;
-      var unarySlash = match.unarySlash;
-
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag);
-        }
-        if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-          parseEndTag(tagName);
-        }
-      }
-
-      var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-      var l = match.attrs.length;
-      var attrs = new Array(l);
-      for (var i = 0; i < l; i++) {
-        var args = match.attrs[i];
-        var value = args[3] || args[4] || args[5] || '';
-        var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-          ? options.shouldDecodeNewlinesForHref
-          : options.shouldDecodeNewlines;
-        attrs[i] = {
-          name: args[1],
-          value: decodeAttr(value, shouldDecodeNewlines)
-        };
-        if (options.outputSourceRange) {
-          attrs[i].start = args.start + args[0].match(/^\s*/).length;
-          attrs[i].end = args.end;
-        }
-      }
-
-      if (!unary) {
-        stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-        lastTag = tagName;
-      }
-
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end);
-      }
-    }
-
-    function parseEndTag (tagName, start, end) {
-      var pos, lowerCasedTagName;
-      if (start == null) { start = index; }
-      if (end == null) { end = index; }
-
-      // Find the closest opened tag of the same type
-      if (tagName) {
-        lowerCasedTagName = tagName.toLowerCase();
-        for (pos = stack.length - 1; pos >= 0; pos--) {
-          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-            break
-          }
-        }
-      } else {
-        // If no tag name is provided, clean shop
-        pos = 0;
-      }
-
-      if (pos >= 0) {
-        // Close all the open elements, up the stack
-        for (var i = stack.length - 1; i >= pos; i--) {
-          if (i > pos || !tagName &&
-            options.warn
-          ) {
-            options.warn(
-              ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-              { start: stack[i].start, end: stack[i].end }
-            );
-          }
-          if (options.end) {
-            options.end(stack[i].tag, start, end);
-          }
-        }
-
-        // Remove the open elements from the stack
-        stack.length = pos;
-        lastTag = pos && stack[pos - 1].tag;
-      } else if (lowerCasedTagName === 'br') {
-        if (options.start) {
-          options.start(tagName, [], true, start, end);
-        }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end);
-        }
-        if (options.end) {
-          options.end(tagName, start, end);
-        }
-      }
-    }
-  }
-
-  /*  */
-
+  /* @flow */
   /**
    * Cross-platform code generation for component v-model
    */
-  function genComponentModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
-    if (trim) {
-      valueExpression =
-        "(typeof " + baseValueExpression + " === 'string'" +
-        "? " + baseValueExpression + ".trim()" +
-        ": " + baseValueExpression + ")";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-    var assignment = genAssignmentCode(value, valueExpression);
-
-    el.model = {
-      value: ("(" + value + ")"),
-      expression: JSON.stringify(value),
-      callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-    };
+  function genComponentModel(el, value, modifiers) {
+      var ref = modifiers || {};
+      var number = ref.number;
+      var trim = ref.trim;
+      var baseValueExpression = '$$v';
+      var valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              "(typeof " + baseValueExpression + " === 'string'" +
+                  "? " + baseValueExpression + ".trim()" +
+                  ": " + baseValueExpression + ")";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: ("(" + value + ")"),
+          expression: JSON.stringify(value),
+          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+      };
   }
-
   /**
    * Cross-platform codegen helper for generating v-model value assignment code.
    */
-  function genAssignmentCode (
-    value,
-    assignment
-  ) {
-    var res = parseModel(value);
-    if (res.key === null) {
-      return (value + "=" + assignment)
-    } else {
-      return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-    }
+  function genAssignmentCode(value, assignment) {
+      var res = parseModel(value);
+      if (res.key === null) {
+          return (value + "=" + assignment);
+      }
+      else {
+          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+      }
   }
-
   /**
    * Parse a v-model expression into a base path and a final key segment.
    * Handles both dot-path and possible square brackets.
@@ -3718,115 +3331,98 @@
    * - test.xxx.a["asa"][test1[key]]
    *
    */
-
   var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-  function parseModel (val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-      index = val.lastIndexOf('.');
-      if (index > -1) {
-        return {
-          exp: val.slice(0, index),
-          key: '"' + val.slice(index + 1) + '"'
-        }
-      } else {
-        return {
-          exp: val,
-          key: null
-        }
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
+              return {
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
       }
-    }
-
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-
-    while (!eof()) {
-      chr = next();
-      /* istanbul ignore if */
-      if (isStringStart(chr)) {
-        parseString(chr);
-      } else if (chr === 0x5B) {
-        parseBracket(chr);
+      str = val;
+      index = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
       }
-    }
-
-    return {
-      exp: val.slice(0, expressionPos),
-      key: val.slice(expressionPos + 1, expressionEndPos)
-    }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
   }
-
-  function next () {
-    return str.charCodeAt(++index)
+  function next() {
+      return str.charCodeAt(++index);
   }
-
-  function eof () {
-    return index >= len
+  function eof() {
+      return index >= len;
   }
-
-  function isStringStart (chr) {
-    return chr === 0x22 || chr === 0x27
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
   }
-
-  function parseBracket (chr) {
-    var inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-      chr = next();
-      if (isStringStart(chr)) {
-        parseString(chr);
-        continue
-      }
-      if (chr === 0x5B) { inBracket++; }
-      if (chr === 0x5D) { inBracket--; }
-      if (inBracket === 0) {
-        expressionEndPos = index;
-        break
+  function parseBracket(chr) {
+      var inBracket = 1;
+      expressionPos = index;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              { inBracket++; }
+          if (chr === 0x5d)
+              { inBracket--; }
+          if (inBracket === 0) {
+              expressionEndPos = index;
+              break;
+          }
       }
-    }
   }
-
-  function parseString (chr) {
-    var stringQuote = chr;
-    while (!eof()) {
-      chr = next();
-      if (chr === stringQuote) {
-        break
+  function parseString(chr) {
+      var stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
   var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
   var stripParensRE = /^\(|\)$/g;
   var dynamicArgRE = /^\[.*\]$/;
-
   var argRE = /:(.*)$/;
   var bindRE = /^:|^\.|^v-bind:/;
   var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
   var slotRE = /^v-slot(:|$)|^#/;
-
   var lineBreakRE = /[\r\n]/;
-  var whitespaceRE = /\s+/g;
-
+  var whitespaceRE = /[ \f\t\r\n]+/g;
   var invalidAttributeRE = /[\s"'<>\/=]/;
-
-  var decodeHTMLCached = cached(he.decode);
-
+  var decodeHTMLCached = cached(undefined);
   var emptySlotScopeToken = "_empty_";
-
   // configurable state
   var warn$1;
   var delimiters;
@@ -3837,4158 +3433,3550 @@
   var platformMustUseProp;
   var platformGetTagNamespace;
   var maybeComponent;
-
-  function createASTElement (
-    tag,
-    attrs,
-    parent
-  ) {
-    return {
-      type: 1,
-      tag: tag,
-      attrsList: attrs,
-      attrsMap: makeAttrsMap(attrs),
-      rawAttrsMap: {},
-      parent: parent,
-      children: []
-    }
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag: tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent: parent,
+          children: [],
+      };
   }
-
   /**
    * Convert HTML string to AST.
    */
-  function parse (
-    template,
-    options
-  ) {
-    warn$1 = options.warn || baseWarn;
-
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-    delimiters = options.delimiters;
-
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
-
-    function warnOnce (msg, range) {
-      if (!warned) {
-        warned = true;
-        warn$1(msg, range);
-      }
-    }
-
-    function closeElement (element) {
-      trimEndingWhitespace(element);
-      if (!inVPre && !element.processed) {
-        element = processElement(element, options);
-      }
-      // tree management
-      if (!stack.length && element !== root) {
-        // allow root elements with v-if, v-else-if and v-else
-        if (root.if && (element.elseif || element.else)) {
-          {
-            checkRootConstraints(element);
+  function parse(template, options) {
+      warn$1 = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      var isReservedTag = options.isReservedTag || no;
+      maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      var stack = [];
+      var preserveWhitespace = options.preserveWhitespace !== false;
+      var whitespaceOption = options.whitespace;
+      var root;
+      var currentParent;
+      var inVPre = false;
+      var inPre = false;
+      var warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn$1(msg, range);
           }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          });
-        } else {
-          warnOnce(
-            "Component template should contain exactly one root element. " +
-            "If you are using v-if on multiple elements, " +
-            "use v-else-if to chain them instead.",
-            { start: element.start }
-          );
-        }
-      }
-      if (currentParent && !element.forbidden) {
-        if (element.elseif || element.else) {
-          processIfConditions(element, currentParent);
-        } else {
-          if (element.slotScope) {
-            // scoped slot
-            // keep it in the children list so that v-else(-if) conditions can
-            // find it as the prev node.
-            var name = element.slotTarget || '"default"'
-            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-          }
-          currentParent.children.push(element);
-          element.parent = currentParent;
-        }
-      }
-
-      // final children cleanup
-      // filter out scoped slots
-      element.children = element.children.filter(function (c) { return !(c).slotScope; });
-      // remove trailing whitespace node again
-      trimEndingWhitespace(element);
-
-      // check pre state
-      if (element.pre) {
-        inVPre = false;
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false;
-      }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options);
-      }
-    }
-
-    function trimEndingWhitespace (el) {
-      // remove trailing whitespace node
-      if (!inPre) {
-        var lastNode;
-        while (
-          (lastNode = el.children[el.children.length - 1]) &&
-          lastNode.type === 3 &&
-          lastNode.text === ' '
-        ) {
-          el.children.pop();
-        }
-      }
-    }
-
-    function checkRootConstraints (el) {
-      if (el.tag === 'slot' || el.tag === 'template') {
-        warnOnce(
-          "Cannot use <" + (el.tag) + "> as component root element because it may " +
-          'contain multiple nodes.',
-          { start: el.start }
-        );
-      }
-      if (el.attrsMap.hasOwnProperty('v-for')) {
-        warnOnce(
-          'Cannot use v-for on stateful component root element because ' +
-          'it renders multiple elements.',
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-
-    parseHTML(template, {
-      warn: warn$1,
-      expectHTML: options.expectHTML,
-      isUnaryTag: options.isUnaryTag,
-      canBeLeftOpenTag: options.canBeLeftOpenTag,
-      shouldDecodeNewlines: options.shouldDecodeNewlines,
-      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-      shouldKeepComment: options.comments,
-      outputSourceRange: options.outputSourceRange,
-      start: function start (tag, attrs, unary, start$1, end) {
-        // check namespace.
-        // inherit parent ns if there is one
-        var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-        // handle IE svg bug
-        /* istanbul ignore if */
-        if (isIE && ns === 'svg') {
-          attrs = guardIESVGBug(attrs);
-        }
-
-        var element = createASTElement(tag, attrs, currentParent);
-        if (ns) {
-          element.ns = ns;
-        }
-
-        {
-          if (options.outputSourceRange) {
-            element.start = start$1;
-            element.end = end;
-            element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-              cumulated[attr.name] = attr;
-              return cumulated
-            }, {});
-          }
-          attrs.forEach(function (attr) {
-            if (invalidAttributeRE.test(attr.name)) {
-              warn$1(
-                "Invalid dynamic argument expression: attribute names cannot contain " +
-                "spaces, quotes, <, >, / or =.",
-                {
-                  start: attr.start + attr.name.indexOf("["),
-                  end: attr.start + attr.name.length
-                }
-              );
-            }
-          });
-        }
-
-        if (isForbiddenTag(element) && !isServerRendering()) {
-          element.forbidden = true;
-          warn$1(
-            'Templates should only be responsible for mapping the state to the ' +
-            'UI. Avoid placing tags with side-effects in your templates, such as ' +
-            "<" + tag + ">" + ', as they will not be parsed.',
-            { start: element.start }
-          );
-        }
-
-        // apply pre-transforms
-        for (var i = 0; i < preTransforms.length; i++) {
-          element = preTransforms[i](element, options) || element;
-        }
-
-        if (!inVPre) {
-          processPre(element);
+      }
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce("Component template should contain exactly one root element. " +
+                      "If you are using v-if on multiple elements, " +
+                      "use v-else-if to chain them instead.", { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      var name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter(function (c) { return !c.slotScope; });
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
           if (element.pre) {
-            inVPre = true;
-          }
-        }
-        if (platformIsPreTag(element.tag)) {
-          inPre = true;
-        }
-        if (inVPre) {
-          processRawAttrs(element);
-        } else if (!element.processed) {
-          // structural directives
-          processFor(element);
-          processIf(element);
-          processOnce(element);
-        }
-
-        if (!root) {
-          root = element;
-          {
-            checkRootConstraints(root);
+              inVPre = false;
           }
-        }
-
-        if (!unary) {
-          currentParent = element;
-          stack.push(element);
-        } else {
-          closeElement(element);
-        }
-      },
-
-      end: function end (tag, start, end$1) {
-        var element = stack[stack.length - 1];
-        // pop stack
-        stack.length -= 1;
-        currentParent = stack[stack.length - 1];
-        if (options.outputSourceRange) {
-          element.end = end$1;
-        }
-        closeElement(element);
-      },
-
-      chars: function chars (text, start, end) {
-        if (!currentParent) {
-          {
-            if (text === template) {
-              warnOnce(
-                'Component template requires a root element, rather than just text.',
-                { start: start }
-              );
-            } else if ((text = text.trim())) {
-              warnOnce(
-                ("text \"" + text + "\" outside root element will be ignored."),
-                { start: start }
-              );
-            }
-          }
-          return
-        }
-        // IE textarea placeholder bug
-        /* istanbul ignore if */
-        if (isIE &&
-          currentParent.tag === 'textarea' &&
-          currentParent.attrsMap.placeholder === text
-        ) {
-          return
-        }
-        var children = currentParent.children;
-        if (inPre || text.trim()) {
-          text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-        } else if (!children.length) {
-          // remove the whitespace-only node right after an opening tag
-          text = '';
-        } else if (whitespaceOption) {
-          if (whitespaceOption === 'condense') {
-            // in condense mode, remove the whitespace node if it contains
-            // line break, otherwise condense to a single space
-            text = lineBreakRE.test(text) ? '' : ' ';
-          } else {
-            text = ' ';
-          }
-        } else {
-          text = preserveWhitespace ? ' ' : '';
-        }
-        if (text) {
-          if (!inPre && whitespaceOption === 'condense') {
-            // condense consecutive whitespaces into single space
-            text = text.replace(whitespaceRE, ' ');
-          }
-          var res;
-          var child;
-          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-            child = {
-              type: 2,
-              expression: res.expression,
-              tokens: res.tokens,
-              text: text
-            };
-          } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-            child = {
-              type: 3,
-              text: text
-            };
-          }
-          if (child) {
-            if (options.outputSourceRange) {
-              child.start = start;
-              child.end = end;
-            }
-            children.push(child);
-          }
-        }
-      },
-      comment: function comment (text, start, end) {
-        // adding anything as a sibling to the root node is forbidden
-        // comments should still be allowed, but ignored
-        if (currentParent) {
-          var child = {
-            type: 3,
-            text: text,
-            isComment: true
-          };
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          currentParent.children.push(child);
-        }
-      }
-    });
-    return root
-  }
-
-  function processPre (el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true;
-    }
-  }
-
-  function processRawAttrs (el) {
-    var list = el.attrsList;
-    var len = list.length;
-    if (len) {
-      var attrs = el.attrs = new Array(len);
-      for (var i = 0; i < len; i++) {
-        attrs[i] = {
-          name: list[i].name,
-          value: JSON.stringify(list[i].value)
-        };
-        if (list[i].start != null) {
-          attrs[i].start = list[i].start;
-          attrs[i].end = list[i].end;
-        }
-      }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true;
-    }
-  }
-
-  function processElement (
-    element,
-    options
-  ) {
-    processKey(element);
-
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain = (
-      !element.key &&
-      !element.scopedSlots &&
-      !element.attrsList.length
-    );
-
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element
-  }
-
-  function processKey (el) {
-    var exp = getBindingAttr(el, 'key');
-    if (exp) {
-      {
-        if (el.tag === 'template') {
-          warn$1(
-            "<template> cannot be keyed. Place the key on real elements instead.",
-            getRawBindingAttr(el, 'key')
-          );
-        }
-        if (el.for) {
-          var iterator = el.iterator2 || el.iterator1;
-          var parent = el.parent;
-          if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-            warn$1(
-              "Do not use v-for index as key on <transition-group> children, " +
-              "this is the same as not using keys.",
-              getRawBindingAttr(el, 'key'),
-              true /* tip */
-            );
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
+          }
+          // apply post-transforms
+          for (var i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
+          }
+      }
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              var lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
+          }
+      }
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                  'contain multiple nodes.', { start: el.start });
+          }
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
           }
-        }
       }
-      el.key = exp;
-    }
+      parseHTML(template, {
+          warn: warn$1,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start: function start(tag, attrs, unary, start$1, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              var element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start$1;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach(function (attr) {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
+                              "spaces, quotes, <, >, / or =.", {
+                              start: attr.start + attr.name.indexOf("["),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn$1('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          "<" + tag + ">" +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (var i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end: function end(tag, start, end$1) {
+              var element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end$1;
+              }
+              closeElement(element);
+          },
+          chars: function chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                              start: start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              var children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE, ' ');
+                  }
+                  var res;
+                  var child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text: text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text: text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment: function comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  var child = {
+                      type: 3,
+                      text: text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
+      });
+      return root;
   }
-
-  function processRef (el) {
-    var ref = getBindingAttr(el, 'ref');
-    if (ref) {
-      el.ref = ref;
-      el.refInFor = checkInFor(el);
-    }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
   }
-
-  function processFor (el) {
-    var exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp);
-      if (res) {
-        extend(el, res);
-      } else {
-        warn$1(
-          ("Invalid v-for expression: " + exp),
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-  }
-
-
-
-  function parseFor (exp) {
-    var inMatch = exp.match(forAliasRE);
-    if (!inMatch) { return }
-    var res = {};
-    res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-      res.alias = alias.replace(forIteratorRE, '').trim();
-      res.iterator1 = iteratorMatch[1].trim();
-      if (iteratorMatch[2]) {
-        res.iterator2 = iteratorMatch[2].trim();
-      }
-    } else {
-      res.alias = alias;
-    }
-    return res
-  }
-
-  function processIf (el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-      el.if = exp;
-      addIfCondition(el, {
-        exp: exp,
-        block: el
-      });
-    } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true;
+  function processRawAttrs(el) {
+      var list = el.attrsList;
+      var len = list.length;
+      if (len) {
+          var attrs = (el.attrs = new Array(len));
+          for (var i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
       }
-      var elseif = getAndRemoveAttr(el, 'v-else-if');
-      if (elseif) {
-        el.elseif = elseif;
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (var i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      var exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  var iterator = el.iterator2 || el.iterator1;
+                  var parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn$1("Do not use v-for index as key on <transition-group> children, " +
+                          "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
       }
-    }
   }
-
-  function processIfConditions (el, parent) {
-    var prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-      addIfCondition(prev, {
-        exp: el.elseif,
-        block: el
-      });
-    } else {
-      warn$1(
-        "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-        "used on element <" + (el.tag) + "> without corresponding v-if.",
-        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-      );
-    }
-  }
-
-  function findPrevElement (children) {
-    var i = children.length;
-    while (i--) {
-      if (children[i].type === 1) {
-        return children[i]
-      } else {
-        if (children[i].text !== ' ') {
-          warn$1(
-            "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-            "will be ignored.",
-            children[i]
-          );
-        }
-        children.pop();
+  function processRef(el) {
+      var ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
       }
-    }
   }
-
-  function addIfCondition (el, condition) {
-    if (!el.ifConditions) {
-      el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-  }
-
-  function processOnce (el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
-      el.once = true;
-    }
+  function processFor(el) {
+      var exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          var res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+          }
+      }
   }
-
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent (el) {
-    var slotScope;
-    if (el.tag === 'template') {
-      slotScope = getAndRemoveAttr(el, 'scope');
-      /* istanbul ignore if */
-      if (slotScope) {
-        warn$1(
-          "the \"scope\" attribute for scoped slots have been deprecated and " +
-          "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-          "can also be used on plain elements in addition to <template> to " +
-          "denote scoped slots.",
-          el.rawAttrsMap['scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-      /* istanbul ignore if */
-      if (el.attrsMap['v-for']) {
-        warn$1(
-          "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-          "(v-for takes higher priority). Use a wrapper <template> for the " +
-          "scoped slot to make it clearer.",
-          el.rawAttrsMap['slot-scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope;
-    }
-
-    // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-      el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-      // preserve slot as an attribute for native shadow DOM compat
-      // only for non-scoped slots.
-      if (el.tag !== 'template' && !el.slotScope) {
-        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-      }
-    }
-
-    // 2.6 v-slot syntax
-    {
-      if (el.tag === 'template') {
-        // v-slot on <template>
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding) {
-          {
-            if (el.slotTarget || el.slotScope) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.parent && !maybeComponent(el.parent)) {
-              warn$1(
-                "<template v-slot> can only appear at the root level inside " +
-                "the receiving component",
-                el
-              );
-            }
+  function parseFor(exp) {
+      var inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          { return; }
+      var res = {};
+      res.for = inMatch[2].trim();
+      var alias = inMatch[1].trim().replace(stripParensRE, '');
+      var iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
           }
-          var ref = getSlotName(slotBinding);
-          var name = ref.name;
-          var dynamic = ref.dynamic;
-          el.slotTarget = name;
-          el.slotTargetDynamic = dynamic;
-          el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-        }
-      } else {
-        // v-slot on component, denotes default slot
-        var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding$1) {
-          {
-            if (!maybeComponent(el)) {
-              warn$1(
-                "v-slot can only be used on components or <template>.",
-                slotBinding$1
-              );
-            }
-            if (el.slotScope || el.slotTarget) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.scopedSlots) {
-              warn$1(
-                "To avoid scope ambiguity, the default slot should also use " +
-                "<template> syntax when there are other named slots.",
-                slotBinding$1
-              );
-            }
-          }
-          // add the component's children to its default slot
-          var slots = el.scopedSlots || (el.scopedSlots = {});
-          var ref$1 = getSlotName(slotBinding$1);
-          var name$1 = ref$1.name;
-          var dynamic$1 = ref$1.dynamic;
-          var slotContainer = slots[name$1] = createASTElement('template', [], el);
-          slotContainer.slotTarget = name$1;
-          slotContainer.slotTargetDynamic = dynamic$1;
-          slotContainer.children = el.children.filter(function (c) {
-            if (!c.slotScope) {
-              c.parent = slotContainer;
-              return true
-            }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
+  }
+  function processIf(el) {
+      var exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          var elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
+      }
+  }
+  function processIfConditions(el, parent) {
+      var prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
           });
-          slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-          // remove children as they are returned from scopedSlots now
-          el.children = [];
-          // mark el non-plain so data gets generated
-          el.plain = false;
-        }
-      }
-    }
-  }
-
-  function getSlotName (binding) {
-    var name = binding.name.replace(slotRE, '');
-    if (!name) {
-      if (binding.name[0] !== '#') {
-        name = 'default';
-      } else {
-        warn$1(
-          "v-slot shorthand syntax requires a slot name.",
-          binding
-        );
-      }
-    }
-    return dynamicArgRE.test(name)
-      // dynamic [name]
-      ? { name: name.slice(1, -1), dynamic: true }
-      // static name
-      : { name: ("\"" + name + "\""), dynamic: false }
+      }
+      else {
+          warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+      }
+  }
+  function findPrevElement(children) {
+      var i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                      "will be ignored.", children[i]);
+              }
+              children.pop();
+          }
+      }
+  }
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
+  }
+  function processOnce(el) {
+      var once$$1 = getAndRemoveAttr(el, 'v-once');
+      if (once$$1 != null) {
+          el.once = true;
+      }
+  }
+  // handle content being passed to a component as slot,
+  // e.g. <template slot="xxx">, <div slot-scope="xxx">
+  function processSlotContent(el) {
+      var slotScope;
+      if (el.tag === 'template') {
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
+                  "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                  "can also be used on plain elements in addition to <template> to " +
+                  "denote scoped slots.", el.rawAttrsMap['scope'], true);
+          }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                  "(v-for takes higher priority). Use a wrapper <template> for the " +
+                  "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      var slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn$1("<template v-slot> can only appear at the root level inside " +
+                              "the receiving component", el);
+                      }
+                  }
+                  var ref = getSlotName(slotBinding);
+                  var name = ref.name;
+                  var dynamic = ref.dynamic;
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding$1) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                      }
+                      if (el.scopedSlots) {
+                          warn$1("To avoid scope ambiguity, the default slot should also use " +
+                              "<template> syntax when there are other named slots.", slotBinding$1);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  var slots = el.scopedSlots || (el.scopedSlots = {});
+                  var ref$1 = getSlotName(slotBinding$1);
+                  var name$1 = ref$1.name;
+                  var dynamic$1 = ref$1.dynamic;
+                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name$1;
+                  slotContainer.slotTargetDynamic = dynamic$1;
+                  slotContainer.children = el.children.filter(function (c) {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
+          }
+      }
+  }
+  function getSlotName(binding) {
+      var name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn$1("v-slot shorthand syntax requires a slot name.", binding);
+          }
+      }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: ("\"" + name + "\""), dynamic: false };
   }
-
   // handle <slot/> outlets
-  function processSlotOutlet (el) {
-    if (el.tag === 'slot') {
-      el.slotName = getBindingAttr(el, 'name');
-      if (el.key) {
-        warn$1(
-          "`key` does not work on <slot> because slots are abstract outlets " +
-          "and can possibly expand into multiple elements. " +
-          "Use the key on a wrapping element instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-    }
-  }
-
-  function processComponent (el) {
-    var binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true;
-    }
-  }
-
-  function processAttrs (el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-      name = rawName = list[i].name;
-      value = list[i].value;
-      if (dirRE.test(name)) {
-        // mark element as dynamic
-        el.hasBindings = true;
-        // modifiers
-        modifiers = parseModifiers(name.replace(dirRE, ''));
-        // support .foo shorthand syntax for the .prop modifier
-        if (modifiers) {
-          name = name.replace(modifierRE, '');
-        }
-        if (bindRE.test(name)) { // v-bind
-          name = name.replace(bindRE, '');
-          value = parseFilters(value);
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          if (
-            value.trim().length === 0
-          ) {
-            warn$1(
-              ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-            );
-          }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name);
-              if (name === 'innerHtml') { name = 'innerHTML'; }
-            }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name);
-            }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, "$event");
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  ("update:" + (camelize(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-                if (hyphenate(name) !== camelize(name)) {
-                  addHandler(
-                    el,
-                    ("update:" + (hyphenate(name))),
-                    syncGen,
-                    null,
-                    false,
-                    warn$1,
-                    list[i]
-                  );
-                }
-              } else {
-                // handler w/ dynamic event name
-                addHandler(
-                  el,
-                  ("\"update:\"+(" + name + ")"),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i],
-                  true // dynamic
-                );
-              }
-            }
-          }
-          if ((modifiers && modifiers.prop) || (
-            !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-          )) {
-            addProp(el, name, value, list[i], isDynamic);
-          } else {
-            addAttr(el, name, value, list[i], isDynamic);
-          }
-        } else if (onRE.test(name)) { // v-on
-          name = name.replace(onRE, '');
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-        } else { // normal directives
-          name = name.replace(dirRE, '');
-          // parse arg
-          var argMatch = name.match(argRE);
-          var arg = argMatch && argMatch[1];
-          isDynamic = false;
-          if (arg) {
-            name = name.slice(0, -(arg.length + 1));
-            if (dynamicArgRE.test(arg)) {
-              arg = arg.slice(1, -1);
-              isDynamic = true;
-            }
-          }
-          addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-          if (name === 'model') {
-            checkForAliasModel(el, value);
-          }
-        }
-      } else {
-        // literal attribute
-        {
-          var res = parseText(value, delimiters);
-          if (res) {
-            warn$1(
-              name + "=\"" + value + "\": " +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div id="{{ val }}">, use <div :id="val">.',
-              list[i]
-            );
-          }
-        }
-        addAttr(el, name, JSON.stringify(value), list[i]);
-        // #6887 firefox doesn't update muted state if set via attribute
-        // even immediately after element creation
-        if (!el.component &&
-            name === 'muted' &&
-            platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-          addProp(el, name, 'true', list[i]);
-        }
-      }
-    }
-  }
-
-  function checkInFor (el) {
-    var parent = el;
-    while (parent) {
-      if (parent.for !== undefined) {
-        return true
-      }
-      parent = parent.parent;
-    }
-    return false
-  }
-
-  function parseModifiers (name) {
-    var match = name.match(modifierRE);
-    if (match) {
-      var ret = {};
-      match.forEach(function (m) { ret[m.slice(1)] = true; });
-      return ret
-    }
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn$1("`key` does not work on <slot> because slots are abstract outlets " +
+                  "and can possibly expand into multiple elements. " +
+                  "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+          }
+      }
   }
-
-  function makeAttrsMap (attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
-      if (
-        map[attrs[i].name] && !isIE && !isEdge
-      ) {
-        warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+  function processComponent(el) {
+      var binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
       }
-      map[attrs[i].name] = attrs[i].value;
-    }
-    return map
   }
-
+  function processAttrs(el) {
+      var list = el.attrsList;
+      var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              { name = 'innerHTML'; }
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, "$event");
+                          if (!isDynamic) {
+                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  var argMatch = name.match(argRE);
+                  var arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
+              }
+          }
+          else {
+              // literal attribute
+              {
+                  var res = parseText(value, delimiters);
+                  if (res) {
+                      warn$1(name + "=\"" + value + "\": " +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
+          }
+      }
+  }
+  function checkInFor(el) {
+      var parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
+      }
+      return false;
+  }
+  function parseModifiers(name) {
+      var match = name.match(modifierRE);
+      if (match) {
+          var ret = {};
+          match.forEach(function (m) {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
+  }
+  function makeAttrsMap(attrs) {
+      var map = {};
+      for (var i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
+  }
   // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag (el) {
-    return el.tag === 'script' || el.tag === 'style'
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
   }
-
-  function isForbiddenTag (el) {
-    return (
-      el.tag === 'style' ||
-      (el.tag === 'script' && (
-        !el.attrsMap.type ||
-        el.attrsMap.type === 'text/javascript'
-      ))
-    )
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
   }
-
   var ieNSBug = /^xmlns:NS\d+/;
   var ieNSPrefix = /^NS\d+:/;
-
   /* istanbul ignore next */
-  function guardIESVGBug (attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (!ieNSBug.test(attr.name)) {
-        attr.name = attr.name.replace(ieNSPrefix, '');
-        res.push(attr);
-      }
-    }
-    return res
-  }
-
-  function checkForAliasModel (el, value) {
-    var _el = el;
-    while (_el) {
-      if (_el.for && _el.alias === value) {
-        warn$1(
-          "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-          "You are binding v-model directly to a v-for iteration alias. " +
-          "This will not be able to modify the v-for source array because " +
-          "writing to the alias is like modifying a function local variable. " +
-          "Consider using an array of objects and use v-model on an object property instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-      _el = _el.parent;
-    }
-  }
-
-  /*  */
-
-  function preTransformNode (el, options) {
-    if (el.tag === 'input') {
-      var map = el.attrsMap;
-      if (!map['v-model']) {
-        return
-      }
-
-      var typeBinding;
-      if (map[':type'] || map['v-bind:type']) {
-        typeBinding = getBindingAttr(el, 'type');
-      }
-      if (!map.type && !typeBinding && map['v-bind']) {
-        typeBinding = "(" + (map['v-bind']) + ").type";
-      }
-
-      if (typeBinding) {
-        var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-        var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-        // 1. checkbox
-        var branch0 = cloneASTElement(el);
-        // process for on the main node
-        processFor(branch0);
-        addRawAttr(branch0, 'type', 'checkbox');
-        processElement(branch0, options);
-        branch0.processed = true; // prevent it from double-processed
-        branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-        addIfCondition(branch0, {
-          exp: branch0.if,
-          block: branch0
-        });
-        // 2. add radio else-if condition
-        var branch1 = cloneASTElement(el);
-        getAndRemoveAttr(branch1, 'v-for', true);
-        addRawAttr(branch1, 'type', 'radio');
-        processElement(branch1, options);
-        addIfCondition(branch0, {
-          exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-          block: branch1
-        });
-        // 3. other
-        var branch2 = cloneASTElement(el);
-        getAndRemoveAttr(branch2, 'v-for', true);
-        addRawAttr(branch2, ':type', typeBinding);
-        processElement(branch2, options);
-        addIfCondition(branch0, {
-          exp: ifCondition,
-          block: branch2
-        });
-
-        if (hasElse) {
-          branch0.else = true;
-        } else if (elseIfCondition) {
-          branch0.elseif = elseIfCondition;
-        }
-
-        return branch0
-      }
-    }
-  }
-
-  function cloneASTElement (el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+  function guardIESVGBug(attrs) {
+      var res = [];
+      for (var i = 0; i < attrs.length; i++) {
+          var attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
+      }
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      var _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                  "You are binding v-model directly to a v-for iteration alias. " +
+                  "This will not be able to modify the v-for source array because " +
+                  "writing to the alias is like modifying a function local variable. " +
+                  "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
+      }
   }
 
+  /* @flow */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          var map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          var typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = "(" + (map['v-bind']) + ").type";
+          }
+          if (typeBinding) {
+              var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+              var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              var branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              var branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              var branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
+      }
+  }
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+  }
   var model$1 = {
-    preTransformNode: preTransformNode
+      preTransformNode: preTransformNode,
   };
 
-  var modules$1 = [
-    klass,
-    style,
-    model$1
-  ];
-
-  /*  */
+  var modules$1 = [klass, style, model$1];
 
+  /* @flow */
   var warn$2;
-
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
-
-  function model$2 (
-    el,
-    dir,
-    _warn
-  ) {
-    warn$2 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-
-    {
-      // inputs with type="file" are read only and setting the input's
-      // value will throw an error.
-      if (tag === 'input' && type === 'file') {
-        warn$2(
-          "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-          "File inputs are read only. Use a v-on:change listener instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-    }
-
-    if (el.component) {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    } else if (tag === 'select') {
-      genSelect(el, value, modifiers);
-    } else if (tag === 'input' && type === 'checkbox') {
-      genCheckboxModel(el, value, modifiers);
-    } else if (tag === 'input' && type === 'radio') {
-      genRadioModel(el, value, modifiers);
-    } else if (tag === 'input' || tag === 'textarea') {
-      genDefaultModel(el, value, modifiers);
-    } else {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    }
-
-    // ensure runtime directive metadata
-    return true
-  }
-
-  function genCheckboxModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked',
-      "Array.isArray(" + value + ")" +
-      "?_i(" + value + "," + valueBinding + ")>-1" + (
-        trueValueBinding === 'true'
-          ? (":(" + value + ")")
-          : (":_q(" + value + "," + trueValueBinding + ")")
-      )
-    );
-    addHandler(el, 'change',
-      "var $$a=" + value + "," +
+  function model$2(el, dir, _warn) {
+      warn$2 = _warn;
+      var value = dir.value;
+      var modifiers = dir.modifiers;
+      var tag = el.tag;
+      var type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                  "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', "Array.isArray(" + value + ")" +
+          "?_i(" + value + "," + valueBinding + ")>-1" +
+          (trueValueBinding === 'true'
+              ? (":(" + value + ")")
+              : (":_q(" + value + "," + trueValueBinding + ")")));
+      addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
           "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-      'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-            '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-      "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-      null, true
-    );
-  }
-
-  function genRadioModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-
-  function genSelect (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-      ".call($event.target.options,function(o){return o.selected})" +
-      ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-      "return " + (number ? '_n(val)' : 'val') + "})";
-
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-  }
-
-  function genDefaultModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var type = el.attrsMap.type;
-
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-      var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-      if (value$1 && !typeBinding) {
-        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-        warn$2(
-          binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-          'because the latter already expands to a value binding internally',
-          el.rawAttrsMap[binding]
-        );
-      }
-    }
-
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy
-      ? 'change'
-      : type === 'range'
-        ? RANGE_TOKEN
-        : 'input';
-
-    var valueExpression = '$event.target.value';
-    if (trim) {
-      valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-      code = "if($event.target.composing)return;" + code;
-    }
-
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()');
-    }
-  }
-
-  /*  */
-
-  function text (el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-    }
-  }
-
-  /*  */
-
-  function html (el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-    }
+          'if(Array.isArray($$a)){' +
+          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+          '$$i=_i($$a,$$v);' +
+          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var selectedVal = "Array.prototype.filter" +
+          ".call($event.target.options,function(o){return o.selected})" +
+          ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+          "return " + (number ? '_n(val)' : 'val') + "})";
+      var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      var code = "var $$selectedVal = " + selectedVal + ";";
+      code = code + " " + (genAssignmentCode(value, assignment));
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      var type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value$1 && !typeBinding) {
+              var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      var ref = modifiers || {};
+      var lazy = ref.lazy;
+      var number = ref.number;
+      var trim = ref.trim;
+      var needCompositionGuard = !lazy && type !== 'range';
+      var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      var valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = "$event.target.value.trim()";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = "if($event.target.composing)return;" + code;
+      }
+      addProp(el, 'value', ("(" + value + ")"));
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
+  }
+
+  /* @flow */
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+      }
+  }
+
+  /* @flow */
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+      }
   }
 
   var directives$1 = {
-    model: model$2,
-    text: text,
-    html: html
+      model: model$2,
+      text: text,
+      html: html,
   };
 
-  /*  */
-
+  /* @flow */
   var baseOptions = {
-    expectHTML: true,
-    modules: modules$1,
-    directives: directives$1,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    staticKeys: genStaticKeys(modules$1)
+      expectHTML: true,
+      modules: modules$1,
+      directives: directives$1,
+      isPreTag: isPreTag,
+      isUnaryTag: isUnaryTag,
+      mustUseProp: mustUseProp,
+      canBeLeftOpenTag: canBeLeftOpenTag,
+      isReservedTag: isReservedTag,
+      getTagNamespace: getTagNamespace,
+      // @ts-ignore
+      staticKeys: genStaticKeys(modules$1),
   };
 
-  /*  */
-
+  /* @flow */
   var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
   // KeyboardEvent.keyCode aliases
   var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    'delete': [8, 46]
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
   };
-
   // KeyboardEvent.key aliases
   var keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    'delete': ['Backspace', 'Delete', 'Del']
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
   };
-
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
   var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
   var modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2")
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard("$event.target !== $event.currentTarget"),
+      ctrl: genGuard("!$event.ctrlKey"),
+      shift: genGuard("!$event.shiftKey"),
+      alt: genGuard("!$event.altKey"),
+      meta: genGuard("!$event.metaKey"),
+      left: genGuard("'button' in $event && $event.button !== 0"),
+      middle: genGuard("'button' in $event && $event.button !== 1"),
+      right: genGuard("'button' in $event && $event.button !== 2"),
   };
-
-  function genHandlers (
-    events,
-    isNative
-  ) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-      var handlerCode = genHandler(events[name]);
-      if (events[name] && events[name].dynamic) {
-        dynamicHandlers += name + "," + handlerCode + ",";
-      } else {
-        staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-      }
-    }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-    if (dynamicHandlers) {
-      return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-    } else {
-      return prefix + staticHandlers
-    }
-  }
-
-  function genHandler (handler) {
-    if (!handler) {
-      return 'function(){}'
-    }
-
-    if (Array.isArray(handler)) {
-      return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-    }
-
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-    if (!handler.modifiers) {
-      if (isMethodPath || isFunctionExpression) {
-        return handler.value
-      }
-      return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-    } else {
-      var code = '';
-      var genModifierCode = '';
-      var keys = [];
-      for (var key in handler.modifiers) {
-        if (modifierCode[key]) {
-          genModifierCode += modifierCode[key];
-          // left/right
-          if (keyCodes[key]) {
-            keys.push(key);
-          }
-        } else if (key === 'exact') {
-          var modifiers = (handler.modifiers);
-          genModifierCode += genGuard(
-            ['ctrl', 'shift', 'alt', 'meta']
-              .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-              .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-              .join('||')
-          );
-        } else {
-          keys.push(key);
-        }
-      }
-      if (keys.length) {
-        code += genKeyFilter(keys);
-      }
-      // Make sure modifiers like prevent and stop get executed after key filtering
-      if (genModifierCode) {
-        code += genModifierCode;
-      }
-      var handlerCode = isMethodPath
-        ? ("return " + (handler.value) + "($event)")
-        : isFunctionExpression
-          ? ("return (" + (handler.value) + ")($event)")
-          : isFunctionInvocation
-            ? ("return " + (handler.value))
-            : handler.value;
-      return ("function($event){" + code + handlerCode + "}")
-    }
-  }
-
-  function genKeyFilter (keys) {
-    return (
+  function genHandlers(events, isNative) {
+      var prefix = isNative ? 'nativeOn:' : 'on:';
+      var staticHandlers = "";
+      var dynamicHandlers = "";
+      for (var name in events) {
+          var handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += name + "," + handlerCode + ",";
+          }
+          else {
+              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+          }
+      }
+      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      if (dynamicHandlers) {
+          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+      }
+      else {
+          return prefix + staticHandlers;
+      }
+  }
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+      }
+      var isMethodPath = simplePathRE.test(handler.value);
+      var isFunctionExpression = fnExpRE.test(handler.value);
+      var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+      }
+      else {
+          var code = '';
+          var genModifierCode = '';
+          var keys = [];
+          for (var key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  var modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          var handlerCode = isMethodPath
+              ? ("return " + (handler.value) + ".apply(null, arguments)")
+              : isFunctionExpression
+                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  : isFunctionInvocation
+                      ? ("return " + (handler.value))
+                      : handler.value;
+          return ("function($event){" + code + handlerCode + "}");
+      }
+  }
+  function genKeyFilter(keys) {
+      return (
       // make sure the key filters only apply to KeyboardEvents
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-      (keys.map(genFilterCode).join('&&')) + ")return null;"
-    )
+          (keys.map(genFilterCode).join('&&')) + ")return null;");
   }
-
-  function genFilterCode (key) {
-    var keyVal = parseInt(key, 10);
-    if (keyVal) {
-      return ("$event.keyCode!==" + keyVal)
-    }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return (
-      "_k($event.keyCode," +
-      (JSON.stringify(key)) + "," +
-      (JSON.stringify(keyCode)) + "," +
-      "$event.key," +
-      "" + (JSON.stringify(keyName)) +
-      ")"
-    )
+  function genFilterCode(key) {
+      var keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return ("$event.keyCode!==" + keyVal);
+      }
+      var keyCode = keyCodes[key];
+      var keyName = keyNames[key];
+      return ("_k($event.keyCode," +
+          (JSON.stringify(key)) + "," +
+          (JSON.stringify(keyCode)) + "," +
+          "$event.key," +
+          "" + (JSON.stringify(keyName)) +
+          ")");
   }
 
-  /*  */
-
-  function on (el, dir) {
-    if (dir.modifiers) {
-      warn("v-on without argument does not support modifiers.");
-    }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+  /* @flow */
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn("v-on without argument does not support modifiers.");
+      }
+      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
   }
 
-  /*  */
-
-  function bind$1 (el, dir) {
-    el.wrapData = function (code) {
-      return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-    };
+  /* @flow */
+  function bind$1(el, dir) {
+      el.wrapData = function (code) {
+          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var baseDirectives = {
-    on: on,
-    bind: bind$1,
-    cloak: noop
+      on: on,
+      bind: bind$1,
+      cloak: noop,
   };
 
-  /*  */
-
-
-
-
-
-  var CodegenState = function CodegenState (options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
+  /* @flow */
+  var CodegenState = function CodegenState(options) {
+      this.options = options;
+      this.warn = options.warn || baseWarn;
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+      this.directives = extend(extend({}, baseDirectives), options.directives);
+      var isReservedTag = options.isReservedTag || no;
+      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      this.onceId = 0;
+      this.staticRenderFns = [];
+      this.pre = false;
   };
-
-
-
-  function generate (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genElement (el, state) {
-    if (el.parent) {
-      el.pre = el.pre || el.parent.pre;
-    }
-
-    if (el.staticRoot && !el.staticProcessed) {
-      return genStatic(el, state)
-    } else if (el.once && !el.onceProcessed) {
-      return genOnce(el, state)
-    } else if (el.for && !el.forProcessed) {
-      return genFor(el, state)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-      return genChildren(el, state) || 'void 0'
-    } else if (el.tag === 'slot') {
-      return genSlot(el, state)
-    } else {
-      // component or element
-      var code;
-      if (el.component) {
-        code = genComponent(el.component, el, state);
-      } else {
-        var data;
-        if (!el.plain || (el.pre && state.maybeComponent(el))) {
-          data = genData$2(el, state);
-        }
-
-        var children = el.inlineTemplate ? null : genChildren(el, state, true);
-        code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+  function generate(ast, options) {
+      var state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      var code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: ("with(this){return " + code + "}"),
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
+      }
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
+      }
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
       }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code);
+      else {
+          // component or element
+          var code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              var data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData$2(el, state);
+              }
+              var children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+          }
+          // module transforms
+          for (var i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
       }
-      return code
-    }
   }
-
   // hoist static sub-trees out
-  function genStatic (el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
-    if (el.pre) {
-      state.pre = el.pre;
-    }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-    state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      var originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.pre = originalPreState;
+      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
   }
-
   // v-once
-  function genOnce (el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.staticInFor) {
-      var key = '';
-      var parent = el.parent;
-      while (parent) {
-        if (parent.for) {
-          key = parent.key;
-          break
-        }
-        parent = parent.parent;
-      }
-      if (!key) {
-        state.warn(
-          "v-once can only be used inside v-for that is keyed. ",
-          el.rawAttrsMap['v-once']
-        );
-        return genElement(el, state)
-      }
-      return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-    } else {
-      return genStatic(el, state)
-    }
-  }
-
-  function genIf (
-    el,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-  }
-
-  function genIfConditions (
-    conditions,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    if (!conditions.length) {
-      return altEmpty || '_e()'
-    }
-
-    var condition = conditions.shift();
-    if (condition.exp) {
-      return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-    } else {
-      return ("" + (genTernaryExp(condition.block)))
-    }
-
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp (el) {
-      return altGen
-        ? altGen(el, state)
-        : el.once
-          ? genOnce(el, state)
-          : genElement(el, state)
-    }
-  }
-
-  function genFor (
-    el,
-    state,
-    altGen,
-    altHelper
-  ) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-    if (state.maybeComponent(el) &&
-      el.tag !== 'slot' &&
-      el.tag !== 'template' &&
-      !el.key
-    ) {
-      state.warn(
-        "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-        "v-for should have explicit keys. " +
-        "See https://vuejs.org/guide/list.html#key for more info.",
-        el.rawAttrsMap['v-for'],
-        true /* tip */
-      );
-    }
-
-    el.forProcessed = true; // avoid recursion
-    return (altHelper || '_l') + "((" + exp + ")," +
-      "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
-      '})'
-  }
-
-  function genData$2 (el, state) {
-    var data = '{';
-
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
-    if (dirs) { data += dirs + ','; }
-
-    // key
-    if (el.key) {
-      data += "key:" + (el.key) + ",";
-    }
-    // ref
-    if (el.ref) {
-      data += "ref:" + (el.ref) + ",";
-    }
-    if (el.refInFor) {
-      data += "refInFor:true,";
-    }
-    // pre
-    if (el.pre) {
-      data += "pre:true,";
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-      data += "tag:\"" + (el.tag) + "\",";
-    }
-    // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
-      data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-      data += "attrs:" + (genProps(el.attrs)) + ",";
-    }
-    // DOM props
-    if (el.props) {
-      data += "domProps:" + (genProps(el.props)) + ",";
-    }
-    // event handlers
-    if (el.events) {
-      data += (genHandlers(el.events, false)) + ",";
-    }
-    if (el.nativeEvents) {
-      data += (genHandlers(el.nativeEvents, true)) + ",";
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-      data += "slot:" + (el.slotTarget) + ",";
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-      data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-    }
-    // component v-model
-    if (el.model) {
-      data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-      var inlineTemplate = genInlineTemplate(el, state);
-      if (inlineTemplate) {
-        data += inlineTemplate + ",";
-      }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-      data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data);
-    }
-    return data
-  }
-
-  function genDirectives (el, state) {
-    var dirs = el.directives;
-    if (!dirs) { return }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-      dir = dirs[i];
-      needRuntime = true;
-      var gen = state.directives[dir.name];
-      if (gen) {
-        // compile-time directive that manipulates AST.
-        // returns true if it also needs a runtime counterpart.
-        needRuntime = !!gen(el, dir, state.warn);
-      }
-      if (needRuntime) {
-        hasRuntime = true;
-        res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-      }
-    }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
-  }
-
-  function genInlineTemplate (el, state) {
-    var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
-      state.warn(
-        'Inline-template components must have exactly one child element.',
-        { start: el.start }
-      );
-    }
-    if (ast && ast.type === 1) {
-      var inlineRenderFns = generate(ast, state.options);
-      return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-    }
-  }
-
-  function genScopedSlots (
-    el,
-    slots,
-    state
-  ) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-      var slot = slots[key];
-      return (
-        slot.slotTargetDynamic ||
-        slot.if ||
-        slot.for ||
-        containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-      )
-    });
-
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    var needsKey = !!el.if;
-
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-      var parent = el.parent;
-      while (parent) {
-        if (
-          (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-          parent.for
-        ) {
-          needsForceUpdate = true;
-          break
-        }
-        if (parent.if) {
-          needsKey = true;
-        }
-        parent = parent.parent;
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.staticInFor) {
+          var key = '';
+          var parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      var condition = conditions.shift();
+      if (condition.exp) {
+          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+      }
+      else {
+          return ("" + (genTernaryExp(condition.block)));
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      var exp = el.for;
+      var alias = el.alias;
+      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+              "v-for should have explicit keys. " +
+              "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return ((altHelper || '_l') + "((" + exp + ")," +
+          "function(" + alias + iterator1 + iterator2 + "){" +
+          "return " + ((altGen || genElement)(el, state)) +
+          '})');
+  }
+  function genData$2(el, state) {
+      var data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      var dirs = genDirectives(el, state);
+      if (dirs)
+          { data += dirs + ','; }
+      // key
+      if (el.key) {
+          data += "key:" + (el.key) + ",";
+      }
+      // ref
+      if (el.ref) {
+          data += "ref:" + (el.ref) + ",";
+      }
+      if (el.refInFor) {
+          data += "refInFor:true,";
+      }
+      // pre
+      if (el.pre) {
+          data += "pre:true,";
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += "tag:\"" + (el.tag) + "\",";
+      }
+      // module data generation functions
+      for (var i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += "attrs:" + (genProps(el.attrs)) + ",";
+      }
+      // DOM props
+      if (el.props) {
+          data += "domProps:" + (genProps(el.props)) + ",";
+      }
+      // event handlers
+      if (el.events) {
+          data += (genHandlers(el.events, false)) + ",";
+      }
+      if (el.nativeEvents) {
+          data += (genHandlers(el.nativeEvents, true)) + ",";
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += "slot:" + (el.slotTarget) + ",";
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+      }
+      // component v-model
+      if (el.model) {
+          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          var inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += inlineTemplate + ",";
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      var dirs = el.directives;
+      if (!dirs)
+          { return; }
+      var res = 'directives:[';
+      var hasRuntime = false;
+      var i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          var gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
       }
-    }
-
-    var generatedSlots = Object.keys(slots)
-      .map(function (key) { return genScopedSlot(slots[key], state); })
-      .join(',');
-
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
   }
-
+  function genInlineTemplate(el, state) {
+      var ast = el.children[0];
+      if (el.children.length !== 1 || ast.type !== 1) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          var inlineRenderFns = generate(ast, state.options);
+          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+              .map(function (code) { return ("function(){" + code + "}"); })
+              .join(',')) + "]}");
+      }
+  }
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      var needsForceUpdate = el.for ||
+          Object.keys(slots).some(function (key) {
+              var slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      var needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          var parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
+      }
+      var generatedSlots = Object.keys(slots)
+          .map(function (key) { return genScopedSlot(slots[key], state); })
+          .join(',');
+      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+  }
   function hash(str) {
-    var hash = 5381;
-    var i = str.length;
-    while(i) {
-      hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0
+      var hash = 5381;
+      var i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
+      }
+      return hash >>> 0;
   }
-
-  function containsSlotChild (el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
-      }
-      return el.children.some(containsSlotChild)
-    }
-    return false
-  }
-
-  function genScopedSlot (
-    el,
-    state
-  ) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-      return genIf(el, state, genScopedSlot, "null")
-    }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
-    }
-    var slotScope = el.slotScope === emptySlotScopeToken
-      ? ""
-      : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-      "return " + (el.tag === 'template'
-        ? el.if && isLegacySyntax
-          ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-          : genChildren(el, state) || 'undefined'
-        : genElement(el, state)) + "}";
-    // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-  }
-
-  function genChildren (
-    el,
-    state,
-    checkSkip,
-    altGenElement,
-    altGenNode
-  ) {
-    var children = el.children;
-    if (children.length) {
-      var el$1 = children[0];
-      // optimize single v-for
-      if (children.length === 1 &&
-        el$1.for &&
-        el$1.tag !== 'template' &&
-        el$1.tag !== 'slot'
-      ) {
-        var normalizationType = checkSkip
-          ? state.maybeComponent(el$1) ? ",1" : ",0"
-          : "";
-        return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-      }
-      var normalizationType$1 = checkSkip
-        ? getNormalizationType(children, state.maybeComponent)
-        : 0;
-      var gen = altGenNode || genNode;
-      return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-    }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      var isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, "null");
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+      var fn = "function(" + slotScope + "){" +
+          "return " + (el.tag === 'template'
+              ? el.if && isLegacySyntax
+                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                  : genChildren(el, state) || 'undefined'
+              : genElement(el, state)) + "}";
+      // reverse proxy v-slot without scope on this.$slots
+      var reverseProxy = slotScope ? "" : ",proxy:true";
+      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      var children = el.children;
+      if (children.length) {
+          var el$1 = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el$1.for &&
+              el$1.tag !== 'template' &&
+              el$1.tag !== 'slot') {
+              var normalizationType = checkSkip
+                  ? state.maybeComponent(el$1)
+                      ? ",1"
+                      : ",0"
+                  : "";
+              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+          }
+          var normalizationType$1 = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          var gen = altGenNode || genNode;
+          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+      }
   }
-
   // determine the normalization needed for the children array.
   // 0: no normalization needed
   // 1: simple normalization needed (possible 1-level deep nested array)
   // 2: full normalization needed
-  function getNormalizationType (
-    children,
-    maybeComponent
-  ) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-      var el = children[i];
-      if (el.type !== 1) {
-        continue
-      }
-      if (needsNormalization(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-        res = 2;
-        break
-      }
-      if (maybeComponent(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-        res = 1;
-      }
-    }
-    return res
-  }
-
-  function needsNormalization (el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-  }
-
-  function genNode (node, state) {
-    if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
-    }
-  }
-
-  function genText (text) {
-    return ("_v(" + (text.type === 2
-      ? text.expression // no need for () because already wrapped in _s()
-      : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-  }
-
-  function genComment (comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")")
-  }
-
-  function genSlot (el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
-    var attrs = el.attrs || el.dynamicAttrs
-      ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-          // slot props are camelized
-          name: camelize(attr.name),
-          value: attr.value,
-          dynamic: attr.dynamic
-        }); }))
-      : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
-      res += ",null";
-    }
-    if (attrs) {
-      res += "," + attrs;
-    }
-    if (bind$$1) {
-      res += (attrs ? '' : ',null') + "," + bind$$1;
-    }
-    return res + ')'
+  function getNormalizationType(children, maybeComponent) {
+      var res = 0;
+      for (var i = 0; i < children.length; i++) {
+          var el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+              res = 1;
+          }
+      }
+      return res;
+  }
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+  }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
+  }
+  function genText(text) {
+      return ("_v(" + (text.type === 2
+          ? text.expression // no need for () because already wrapped in _s()
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+  }
+  function genComment(comment) {
+      return ("_e(" + (JSON.stringify(comment.text)) + ")");
+  }
+  function genSlot(el, state) {
+      var slotName = el.slotName || '"default"';
+      var children = genChildren(el, state);
+      var res = "_t(" + slotName + (children ? ("," + children) : '');
+      var attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic,
+          }); }))
+          : null;
+      var bind$$1 = el.attrsMap['v-bind'];
+      if ((attrs || bind$$1) && !children) {
+          res += ",null";
+      }
+      if (attrs) {
+          res += "," + attrs;
+      }
+      if (bind$$1) {
+          res += (attrs ? '' : ',null') + "," + bind$$1;
+      }
+      return res + ')';
   }
-
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent (
-    componentName,
-    el,
-    state
-  ) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-  }
-
-  function genProps (props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      var value = transformSpecialNewlines(prop.value);
-      if (prop.dynamic) {
-        dynamicProps += (prop.name) + "," + value + ",";
-      } else {
-        staticProps += "\"" + (prop.name) + "\":" + value + ",";
-      }
-    }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-    if (dynamicProps) {
-      return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-    } else {
-      return staticProps
-    }
+  function genComponent(componentName, el, state) {
+      var children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+  }
+  function genProps(props) {
+      var staticProps = "";
+      var dynamicProps = "";
+      for (var i = 0; i < props.length; i++) {
+          var prop = props[i];
+          var value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += (prop.name) + "," + value + ",";
+          }
+          else {
+              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+          }
+      }
+      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      if (dynamicProps) {
+          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+      }
+      else {
+          return staticProps;
+      }
   }
-
   // #3895, #4268
-  function transformSpecialNewlines (text) {
-    return text
-      .replace(/\u2028/g, '\\u2028')
-      .replace(/\u2029/g, '\\u2029')
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  /*  */
-
-
-
-
+  /* @flow */
   var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
   // let the model AST transform translate v-model into appropriate
   // props bindings
-  function applyModelTransform (el, state) {
-    if (el.directives) {
-      for (var i = 0; i < el.directives.length; i++) {
-        var dir = el.directives[i];
-        if (dir.name === 'model') {
-          state.directives.model(el, dir, state.warn);
-          // remove value for textarea as its converted to text
-          if (el.tag === 'textarea' && el.props) {
-            el.props = el.props.filter(function (p) { return p.name !== 'value'; });
-          }
-          break
-        }
-      }
-    }
-  }
-
-  function genAttrSegments (
-    attrs
-  ) {
-    return attrs.map(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      return genAttrSegment(name, value);
-    })
-  }
-
-  function genDOMPropSegments (
-    props,
-    attrs
-  ) {
-    var segments = [];
-    props.forEach(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      name = propsToAttrMap[name] || name.toLowerCase();
-      if (isRenderableAttr(name) &&
-        !(attrs && attrs.some(function (a) { return a.name === name; }))
-      ) {
-        segments.push(genAttrSegment(name, value));
-      }
-    });
-    return segments
-  }
-
-  function genAttrSegment (name, value) {
-    if (plainStringRE.test(value)) {
-      // force double quote
-      value = value.replace(/^'|'$/g, '"');
-      // force enumerated attr to "true"
-      if (isEnumeratedAttr(name) && value !== "\"false\"") {
-        value = "\"true\"";
+  function applyModelTransform(el, state) {
+      if (el.directives) {
+          for (var i = 0; i < el.directives.length; i++) {
+              var dir = el.directives[i];
+              if (dir.name === 'model') {
+                  state.directives.model(el, dir, state.warn);
+                  // remove value for textarea as its converted to text
+                  if (el.tag === 'textarea' && el.props) {
+                      el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+                  }
+                  break;
+              }
+          }
       }
-      return {
-        type: RAW,
-        value: isBooleanAttr(name)
-          ? (" " + name + "=\"" + name + "\"")
-          : value === '""'
-            ? (" " + name)
-            : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-      }
-    } else {
-      return {
-        type: EXPRESSION,
-        value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
-      }
-    }
-  }
-
-  function genClassSegments (
-    staticClass,
-    classBinding
-  ) {
-    if (staticClass && !classBinding) {
-      return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-      }]
-    }
-  }
-
-  function genStyleSegments (
-    staticStyle,
-    parsedStaticStyle,
-    styleBinding,
-    vShowExpression
-  ) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-      return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-            ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-            : 'null') + ")")
-      }]
-    }
-  }
-
-  /*  */
-
-  // optimizability constants
-  var optimizability = {
-    FALSE: 0,    // whole sub tree un-optimizable
-    FULL: 1,     // whole sub tree optimizable
-    SELF: 2,     // self optimizable but has some un-optimizable children
-    CHILDREN: 3, // self un-optimizable but have fully optimizable children
-    PARTIAL: 4   // self un-optimizable with some un-optimizable children
-  };
+  }
+  function genAttrSegments(attrs) {
+      return attrs.map(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
 
-  var isPlatformReservedTag;
+          return genAttrSegment(name, value);
+      });
+  }
+  function genDOMPropSegments(props, attrs) {
+      var segments = [];
+      props.forEach(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
 
-  function optimize (root, options) {
-    if (!root) { return }
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-  }
-
-  function walk (node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-      node.ssrOptimizability = optimizability.FALSE;
-      return
-    }
-    // root node or nodes with custom directives should always be a VNode
-    var selfUnoptimizable = isRoot || hasCustomDirective(node);
-    var check = function (child) {
-      if (child.ssrOptimizability !== optimizability.FULL) {
-        node.ssrOptimizability = selfUnoptimizable
-          ? optimizability.PARTIAL
-          : optimizability.SELF;
-      }
-    };
-    if (selfUnoptimizable) {
-      node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        walk(child);
-        check(child);
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          walk(block, isRoot);
-          check(block);
-        }
-      }
-      if (node.ssrOptimizability == null ||
-        (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-      ) {
-        node.ssrOptimizability = optimizability.FULL;
-      } else {
-        node.children = optimizeSiblings(node);
-      }
-    } else {
-      node.ssrOptimizability = optimizability.FULL;
-    }
-  }
-
-  function optimizeSiblings (el) {
-    var children = el.children;
-    var optimizedChildren = [];
-
-    var currentOptimizableGroup = [];
-    var pushGroup = function () {
-      if (currentOptimizableGroup.length) {
-        optimizedChildren.push({
-          type: 1,
-          parent: el,
-          tag: 'template',
-          attrsList: [],
-          attrsMap: {},
-          rawAttrsMap: {},
-          children: currentOptimizableGroup,
-          ssrOptimizability: optimizability.FULL
-        });
-      }
-      currentOptimizableGroup = [];
-    };
-
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.ssrOptimizability === optimizability.FULL) {
-        currentOptimizableGroup.push(c);
-      } else {
-        // wrap fully-optimizable adjacent siblings inside a template tag
-        // so that they can be optimized into a single ssrNode by codegen
-        pushGroup();
-        optimizedChildren.push(c);
-      }
-    }
-    pushGroup();
-    return optimizedChildren
-  }
-
-  function isUnOptimizableTree (node) {
-    if (node.type === 2 || node.type === 3) { // text or expression
-      return false
-    }
-    return (
-      isBuiltInTag(node.tag) || // built-in (slot, component)
-      !isPlatformReservedTag(node.tag) || // custom component
-      !!node.component || // "is" component
-      isSelectWithModel(node) // <select v-model> requires runtime inspection
-    )
+          name = propsToAttrMap[name] || name.toLowerCase();
+          if (isRenderableAttr(name) &&
+              !(attrs && attrs.some(function (a) { return a.name === name; }))) {
+              segments.push(genAttrSegment(name, value));
+          }
+      });
+      return segments;
+  }
+  function genAttrSegment(name, value) {
+      if (plainStringRE.test(value)) {
+          // force double quote
+          value = value.replace(/^'|'$/g, '"');
+          // force enumerated attr to "true"
+          if (isEnumeratedAttr(name) && value !== "\"false\"") {
+              value = "\"true\"";
+          }
+          return {
+              type: RAW,
+              value: isBooleanAttr(name)
+                  ? (" " + name + "=\"" + name + "\"")
+                  : value === '""'
+                      ? (" " + name)
+                      : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+          };
+      }
+      else {
+          return {
+              type: EXPRESSION,
+              value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+          };
+      }
+  }
+  function genClassSegments(staticClass, classBinding) {
+      if (staticClass && !classBinding) {
+          return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+              } ];
+      }
+  }
+  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+      if (staticStyle && !styleBinding && !vShowExpression) {
+          return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                      ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                      : 'null') + ")"),
+              } ];
+      }
   }
 
+  /* @flow */
+  // optimizability constants
+  var optimizability = {
+      FALSE: 0,
+      FULL: 1,
+      SELF: 2,
+      CHILDREN: 3,
+      PARTIAL: 4, // self un-optimizable with some un-optimizable children
+  };
+  var isPlatformReservedTag;
+  function optimize(root, options) {
+      if (!root)
+          { return; }
+      isPlatformReservedTag = options.isReservedTag || no;
+      walk(root, true);
+  }
+  function walk(node, isRoot) {
+      if (isUnOptimizableTree(node)) {
+          node.ssrOptimizability = optimizability.FALSE;
+          return;
+      }
+      // root node or nodes with custom directives should always be a VNode
+      var selfUnoptimizable = isRoot || hasCustomDirective(node);
+      var check = function (child) {
+          if (child.ssrOptimizability !== optimizability.FULL) {
+              node.ssrOptimizability = selfUnoptimizable
+                  ? optimizability.PARTIAL
+                  : optimizability.SELF;
+          }
+      };
+      if (selfUnoptimizable) {
+          node.ssrOptimizability = optimizability.CHILDREN;
+      }
+      if (node.type === 1) {
+          for (var i = 0, l = node.children.length; i < l; i++) {
+              var child = node.children[i];
+              walk(child);
+              check(child);
+          }
+          if (node.ifConditions) {
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
+                  walk(block, isRoot);
+                  check(block);
+              }
+          }
+          if (node.ssrOptimizability == null ||
+              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+              node.ssrOptimizability = optimizability.FULL;
+          }
+          else {
+              node.children = optimizeSiblings(node);
+          }
+      }
+      else {
+          node.ssrOptimizability = optimizability.FULL;
+      }
+  }
+  function optimizeSiblings(el) {
+      var children = el.children;
+      var optimizedChildren = [];
+      var currentOptimizableGroup = [];
+      var pushGroup = function () {
+          if (currentOptimizableGroup.length) {
+              optimizedChildren.push({
+                  type: 1,
+                  parent: el,
+                  tag: 'template',
+                  attrsList: [],
+                  attrsMap: {},
+                  rawAttrsMap: {},
+                  children: currentOptimizableGroup,
+                  ssrOptimizability: optimizability.FULL,
+              });
+          }
+          currentOptimizableGroup = [];
+      };
+      for (var i = 0; i < children.length; i++) {
+          var c = children[i];
+          if (c.ssrOptimizability === optimizability.FULL) {
+              currentOptimizableGroup.push(c);
+          }
+          else {
+              // wrap fully-optimizable adjacent siblings inside a template tag
+              // so that they can be optimized into a single ssrNode by codegen
+              pushGroup();
+              optimizedChildren.push(c);
+          }
+      }
+      pushGroup();
+      return optimizedChildren;
+  }
+  function isUnOptimizableTree(node) {
+      if (node.type === 2 || node.type === 3) {
+          // text or expression
+          return false;
+      }
+      return (isBuiltInTag(node.tag) || // built-in (slot, component)
+          !isPlatformReservedTag(node.tag) || // custom component
+          !!node.component || // "is" component
+          isSelectWithModel(node) // <select v-model> requires runtime inspection
+      );
+  }
   var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-  function hasCustomDirective (node) {
-    return (
-      node.type === 1 &&
-      node.directives &&
-      node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-    )
+  function hasCustomDirective(node) {
+      return (node.type === 1 &&
+          node.directives &&
+          node.directives.some(function (d) { return !isBuiltInDir(d.name); }));
   }
-
   // <select v-model> cannot be optimized because it requires a runtime check
   // to determine proper selected option
-  function isSelectWithModel (node) {
-    return (
-      node.type === 1 &&
-      node.tag === 'select' &&
-      node.directives != null &&
-      node.directives.some(function (d) { return d.name === 'model'; })
-    )
+  function isSelectWithModel(node) {
+      return (node.type === 1 &&
+          node.tag === 'select' &&
+          node.directives != null &&
+          node.directives.some(function (d) { return d.name === 'model'; }));
   }
 
-  /*  */
-
-
-
-
+  /* @flow */
   // segment types
   var RAW = 0;
   var INTERPOLATION = 1;
   var EXPRESSION = 2;
+  function generate$1(ast, options) {
+      var state = new CodegenState(options);
+      var code = ast ? genSSRElement(ast, state) : '_c("div")';
+      return {
+          render: ("with(this){return " + code + "}"),
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genSSRElement(el, state) {
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genSSRElement);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state, genSSRElement);
+      }
+      else if (el.tag === 'template' && !el.slotTarget) {
+          return el.ssrOptimizability === optimizability.FULL
+              ? genChildrenAsStringNode(el, state)
+              : genSSRChildren(el, state) || 'void 0';
+      }
+      switch (el.ssrOptimizability) {
+          case optimizability.FULL:
+              // stringify whole tree
+              return genStringElement(el, state);
+          case optimizability.SELF:
+              // stringify self and check children
+              return genStringElementWithChildren(el, state);
+          case optimizability.CHILDREN:
+              // generate self as VNode and stringify children
+              return genNormalElement(el, state, true);
+          case optimizability.PARTIAL:
+              // generate self as VNode and check children
+              return genNormalElement(el, state, false);
+          default:
+              // bail whole tree
+              return genElement(el, state);
+      }
+  }
+  function genNormalElement(el, state, stringifyChildren) {
+      var data = el.plain ? undefined : genData$2(el, state);
+      var children = stringifyChildren
+          ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+          : genSSRChildren(el, state, true);
+      return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+  }
+  function genSSRChildren(el, state, checkSkip) {
+      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+  }
+  function genSSRNode(el, state) {
+      return el.type === 1 ? genSSRElement(el, state) : genText(el);
+  }
+  function genChildrenAsStringNode(el, state) {
+      return el.children.length
+          ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+          : '';
+  }
+  function genStringElement(el, state) {
+      return ("_ssrNode(" + (elementToString(el, state)) + ")");
+  }
+  function genStringElementWithChildren(el, state) {
+      var children = genSSRChildren(el, state, true);
+      return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+  }
+  function elementToString(el, state) {
+      return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+  }
+  function elementToSegments(el, state) {
+      // v-for / v-if
+      if (el.for && !el.forProcessed) {
+          el.forProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genFor(el, state, elementToString, '_ssrList'),
+              } ];
+      }
+      else if (el.if && !el.ifProcessed) {
+          el.ifProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genIf(el, state, elementToString, '"<!---->"'),
+              } ];
+      }
+      else if (el.tag === 'template') {
+          return childrenToSegments(el, state);
+      }
+      var openSegments = elementToOpenTagSegments(el, state);
+      var childrenSegments = childrenToSegments(el, state);
+      var ref = state.options;
+      var isUnaryTag = ref.isUnaryTag;
+      var close = isUnaryTag && isUnaryTag(el.tag)
+          ? []
+          : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+      return openSegments.concat(childrenSegments, close);
+  }
+  function elementToOpenTagSegments(el, state) {
+      applyModelTransform(el, state);
+      var binding;
+      var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+      // attrs
+      if (el.attrs) {
+          segments.push.apply(segments, genAttrSegments(el.attrs));
+      }
+      // domProps
+      if (el.props) {
+          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+      }
+      // v-bind="object"
+      if ((binding = el.attrsMap['v-bind'])) {
+          segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+      }
+      // v-bind.prop="object"
+      if ((binding = el.attrsMap['v-bind.prop'])) {
+          segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+      }
+      // class
+      if (el.staticClass || el.classBinding) {
+          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+      }
+      // style & v-show
+      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+      }
+      // _scopedId
+      if (state.options.scopeId) {
+          segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+      }
+      segments.push({ type: RAW, value: ">" });
+      return segments;
+  }
+  function childrenToSegments(el, state) {
+      var binding;
+      if ((binding = el.attrsMap['v-html'])) {
+          return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+      }
+      if ((binding = el.attrsMap['v-text'])) {
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+      }
+      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+      }
+      return el.children ? nodesToSegments(el.children, state) : [];
+  }
+  function nodesToSegments(children, state) {
+      var segments = [];
+      for (var i = 0; i < children.length; i++) {
+          var c = children[i];
+          if (c.type === 1) {
+              segments.push.apply(segments, elementToSegments(c, state));
+          }
+          else if (c.type === 2) {
+              segments.push({ type: INTERPOLATION, value: c.expression });
+          }
+          else if (c.type === 3) {
+              var text = escape(c.text);
+              if (c.isComment) {
+                  text = '<!--' + text + '-->';
+              }
+              segments.push({ type: RAW, value: text });
+          }
+      }
+      return segments;
+  }
+  function flattenSegments(segments) {
+      var mergedSegments = [];
+      var textBuffer = '';
+      var pushBuffer = function () {
+          if (textBuffer) {
+              mergedSegments.push(JSON.stringify(textBuffer));
+              textBuffer = '';
+          }
+      };
+      for (var i = 0; i < segments.length; i++) {
+          var s = segments[i];
+          if (s.type === RAW) {
+              textBuffer += s.value;
+          }
+          else if (s.type === INTERPOLATION) {
+              pushBuffer();
+              mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+          }
+          else if (s.type === EXPRESSION) {
+              pushBuffer();
+              mergedSegments.push(("(" + (s.value) + ")"));
+          }
+      }
+      pushBuffer();
+      return mergedSegments.join('+');
+  }
 
-  function generate$1 (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genSSRElement (el, state) {
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genSSRElement)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state, genSSRElement)
-    } else if (el.tag === 'template' && !el.slotTarget) {
-      return el.ssrOptimizability === optimizability.FULL
-        ? genChildrenAsStringNode(el, state)
-        : genSSRChildren(el, state) || 'void 0'
-    }
-
-    switch (el.ssrOptimizability) {
-      case optimizability.FULL:
-        // stringify whole tree
-        return genStringElement(el, state)
-      case optimizability.SELF:
-        // stringify self and check children
-        return genStringElementWithChildren(el, state)
-      case optimizability.CHILDREN:
-        // generate self as VNode and stringify children
-        return genNormalElement(el, state, true)
-      case optimizability.PARTIAL:
-        // generate self as VNode and check children
-        return genNormalElement(el, state, false)
-      default:
-        // bail whole tree
-        return genElement(el, state)
-    }
-  }
-
-  function genNormalElement (el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData$2(el, state);
-    var children = stringifyChildren
-      ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-      : genSSRChildren(el, state, true);
-    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-  }
-
-  function genSSRChildren (el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-  }
-
-  function genSSRNode (el, state) {
-    return el.type === 1
-      ? genSSRElement(el, state)
-      : genText(el)
-  }
-
-  function genChildrenAsStringNode (el, state) {
-    return el.children.length
-      ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-      : ''
-  }
-
-  function genStringElement (el, state) {
-    return ("_ssrNode(" + (elementToString(el, state)) + ")")
-  }
-
-  function genStringElementWithChildren (el, state) {
-    var children = genSSRChildren(el, state, true);
-    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-  }
-
-  function elementToString (el, state) {
-    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-  }
-
-  function elementToSegments (el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-      el.forProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genFor(el, state, elementToString, '_ssrList')
-      }]
-    } else if (el.if && !el.ifProcessed) {
-      el.ifProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genIf(el, state, elementToString, '"<!---->"')
-      }]
-    } else if (el.tag === 'template') {
-      return childrenToSegments(el, state)
-    }
-
-    var openSegments = elementToOpenTagSegments(el, state);
-    var childrenSegments = childrenToSegments(el, state);
-    var ref = state.options;
-    var isUnaryTag = ref.isUnaryTag;
-    var close = (isUnaryTag && isUnaryTag(el.tag))
-      ? []
-      : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-    return openSegments.concat(childrenSegments, close)
-  }
-
-  function elementToOpenTagSegments (el, state) {
-    applyModelTransform(el, state);
-    var binding;
-    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-    // attrs
-    if (el.attrs) {
-      segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-      segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-      segments.push.apply(
-        segments,
-        genClassSegments(el.staticClass, el.classBinding)
-      );
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-      segments.push.apply(
-        segments,
-        genStyleSegments(
-          el.attrsMap.style,
-          el.staticStyle,
-          el.styleBinding,
-          el.attrsMap['v-show']
-        )
-      );
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-      segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-    }
-    segments.push({ type: RAW, value: ">" });
-    return segments
-  }
-
-  function childrenToSegments (el, state) {
-    var binding;
-    if ((binding = el.attrsMap['v-html'])) {
-      return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    return el.children
-      ? nodesToSegments(el.children, state)
-      : []
-  }
-
-  function nodesToSegments (
-    children,
-    state
-  ) {
-    var segments = [];
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.type === 1) {
-        segments.push.apply(segments, elementToSegments(c, state));
-      } else if (c.type === 2) {
-        segments.push({ type: INTERPOLATION, value: c.expression });
-      } else if (c.type === 3) {
-        var text = escape(c.text);
-        if (c.isComment) {
-          text = '<!--' + text + '-->';
-        }
-        segments.push({ type: RAW, value: text });
-      }
-    }
-    return segments
-  }
-
-  function flattenSegments (segments) {
-    var mergedSegments = [];
-    var textBuffer = '';
-
-    var pushBuffer = function () {
-      if (textBuffer) {
-        mergedSegments.push(JSON.stringify(textBuffer));
-        textBuffer = '';
-      }
-    };
-
-    for (var i = 0; i < segments.length; i++) {
-      var s = segments[i];
-      if (s.type === RAW) {
-        textBuffer += s.value;
-      } else if (s.type === INTERPOLATION) {
-        pushBuffer();
-        mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-      } else if (s.type === EXPRESSION) {
-        pushBuffer();
-        mergedSegments.push(("(" + (s.value) + ")"));
-      }
-    }
-    pushBuffer();
-
-    return mergedSegments.join('+')
-  }
-
-  /*  */
-
-
-
+  /* @flow */
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp('\\b' + (
-    'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-    'super,throw,while,yield,delete,export,import,return,switch,default,' +
-    'extends,finally,continue,debugger,function,arguments'
-  ).split(',').join('\\b|\\b') + '\\b');
-
+  var prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
   // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp('\\b' + (
-    'delete,typeof,void'
-  ).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+  var unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
   // strip strings in expressions
   var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
   // detect problematic expressions in a template
-  function detectErrors (ast, warn) {
-    if (ast) {
-      checkNode(ast, warn);
-    }
-  }
-
-  function checkNode (node, warn) {
-    if (node.type === 1) {
-      for (var name in node.attrsMap) {
-        if (dirRE.test(name)) {
-          var value = node.attrsMap[name];
-          if (value) {
-            var range = node.rawAttrsMap[name];
-            if (name === 'v-for') {
-              checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-            } else if (name === 'v-slot' || name[0] === '#') {
-              checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-            } else if (onRE.test(name)) {
-              checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-            } else {
-              checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-            }
-          }
-        }
-      }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn);
-        }
-      }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node);
-    }
-  }
-
-  function checkEvent (exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        "avoid using JavaScript unary operator as property name: " +
-        "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-        range
-      );
-    }
-    checkExpression(exp, text, warn, range);
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (var name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  var value = node.attrsMap[name];
+                  if (value) {
+                      var range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                      else {
+                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (var i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
+          }
+      }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
+      }
   }
-
-  function checkFor (node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  function checkEvent(exp, text, warn, range) {
+      var stripped = exp.replace(stripStringRE, '');
+      var keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn("avoid using JavaScript unary operator as property name: " +
+              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+      }
+      checkExpression(exp, text, warn, range);
   }
-
-  function checkIdentifier (
-    ident,
-    type,
-    text,
-    warn,
-    range
-  ) {
-    if (typeof ident === 'string') {
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(("var " + ident + "=_"));
+          }
+          catch (e) {
+              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+          }
+      }
+  }
+  function checkExpression(exp, text, warn, range) {
       try {
-        new Function(("var " + ident + "=_"));
-      } catch (e) {
-        warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-      }
-    }
-  }
-
-  function checkExpression (exp, text, warn, range) {
-    try {
-      new Function(("return " + exp));
-    } catch (e) {
-      var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-      if (keywordMatch) {
-        warn(
-          "avoid using JavaScript keyword as property name: " +
-          "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-          range
-        );
-      } else {
-        warn(
-          "invalid expression: " + (e.message) + " in\n\n" +
-          "    " + exp + "\n\n" +
-          "  Raw expression: " + (text.trim()) + "\n",
-          range
-        );
-      }
-    }
-  }
-
-  function checkFunctionParameterExpression (exp, text, warn, range) {
-    try {
-      new Function(exp, '');
-    } catch (e) {
-      warn(
-        "invalid function parameter expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
+          new Function(("return " + exp));
+      }
+      catch (e) {
+          var keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn("avoid using JavaScript keyword as property name: " +
+                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+          }
+          else {
+              warn("invalid expression: " + (e.message) + " in\n\n" +
+                  "    " + exp + "\n\n" +
+                  "  Raw expression: " + (text.trim()) + "\n", range);
+          }
+      }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+              "    " + exp + "\n\n" +
+              "  Raw expression: " + (text.trim()) + "\n", range);
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var range = 2;
-
-  function generateCodeFrame (
-    source,
-    start,
-    end
-  ) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
-      count += lines[i].length + 1;
-      if (count >= start) {
-        for (var j = i - range; j <= i + range || end > count; j++) {
-          if (j < 0 || j >= lines.length) { continue }
-          res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-          var lineLength = lines[j].length;
-          if (j === i) {
-            // push underline
-            var pad = start - (count - lineLength) + 1;
-            var length = end > count ? lineLength - pad : end - start;
-            res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-          } else if (j > i) {
-            if (end > count) {
-              var length$1 = Math.min(end - count, lineLength);
-              res.push("   |  " + repeat$1("^", length$1));
-            }
-            count += lineLength + 1;
-          }
-        }
-        break
-      }
-    }
-    return res.join('\n')
-  }
-
-  function repeat$1 (str, n) {
-    var result = '';
-    if (n > 0) {
-      while (true) { // eslint-disable-line
-        if (n & 1) { result += str; }
-        n >>>= 1;
-        if (n <= 0) { break }
-        str += str;
-      }
-    }
-    return result
-  }
-
-  /*  */
-
-
-
-  function createFunction (code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code });
-      return noop
-    }
-  }
-
-  function createCompileToFunctionFn (compile) {
-    var cache = Object.create(null);
-
-    return function compileToFunctions (
-      template,
-      options,
-      vm
-    ) {
-      options = extend({}, options);
-      var warn$$1 = options.warn || warn;
-      delete options.warn;
-
-      /* istanbul ignore if */
-      {
-        // detect possible CSP restriction
-        try {
-          new Function('return 1');
-        } catch (e) {
-          if (e.toString().match(/unsafe-eval|CSP/)) {
-            warn$$1(
-              'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-            );
-          }
-        }
-      }
-
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template;
-      if (cache[key]) {
-        return cache[key]
-      }
-
-      // compile
-      var compiled = compile(template, options);
-
-      // check compilation errors/tips
-      {
-        if (compiled.errors && compiled.errors.length) {
-          if (options.outputSourceRange) {
-            compiled.errors.forEach(function (e) {
-              warn$$1(
-                "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-                generateCodeFrame(template, e.start, e.end),
-                vm
-              );
-            });
-          } else {
-            warn$$1(
-              "Error compiling template:\n\n" + template + "\n\n" +
-              compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-              vm
-            );
+  function generateCodeFrame(source, start, end) {
+      if ( start === void 0 ) start = 0;
+      if ( end === void 0 ) end = source.length;
+
+      var lines = source.split(/\r?\n/);
+      var count = 0;
+      var res = [];
+      for (var i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (var j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      { continue; }
+                  res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                  var lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      var pad = start - (count - lineLength) + 1;
+                      var length = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          var length$1 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat$1("^", length$1));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
           }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-          } else {
-            compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+      }
+      return res.join('\n');
+  }
+  function repeat$1(str, n) {
+      var result = '';
+      if (n > 0) {
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  { result += str; }
+              n >>>= 1;
+              if (n <= 0)
+                  { break; }
+              str += str;
           }
-        }
       }
+      return result;
+  }
 
-      // turn code into functions
-      var res = {};
-      var fnGenErrors = [];
-      res.render = createFunction(compiled.render, fnGenErrors);
-      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-        return createFunction(code, fnGenErrors)
-      });
-
-      // check function generation errors.
-      // this should only happen if there is a bug in the compiler itself.
-      // mostly for codegen development use
-      /* istanbul ignore if */
-      {
-        if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-          warn$$1(
-            "Failed to generate render function:\n\n" +
-            fnGenErrors.map(function (ref) {
-              var err = ref.err;
-              var code = ref.code;
-
-              return ((err.toString()) + " in\n\n" + code + "\n");
-          }).join('\n'),
-            vm
-          );
-        }
-      }
-
-      return (cache[key] = res)
-    }
-  }
-
-  /*  */
-
-  function createCompilerCreator (baseCompile) {
-    return function createCompiler (baseOptions) {
-      function compile (
-        template,
-        options
-      ) {
-        var finalOptions = Object.create(baseOptions);
-        var errors = [];
-        var tips = [];
-
-        var warn = function (msg, range, tip) {
-          (tip ? tips : errors).push(msg);
-        };
-
-        if (options) {
-          if (options.outputSourceRange) {
-            // $flow-disable-line
-            var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-            warn = function (msg, range, tip) {
-              var data = { msg: msg };
-              if (range) {
-                if (range.start != null) {
-                  data.start = range.start + leadingSpaceLength;
-                }
-                if (range.end != null) {
-                  data.end = range.end + leadingSpaceLength;
-                }
-              }
-              (tip ? tips : errors).push(data);
-            };
-          }
-          // merge custom modules
-          if (options.modules) {
-            finalOptions.modules =
-              (baseOptions.modules || []).concat(options.modules);
-          }
-          // merge custom directives
-          if (options.directives) {
-            finalOptions.directives = extend(
-              Object.create(baseOptions.directives || null),
-              options.directives
-            );
-          }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key];
-            }
-          }
-        }
-
-        finalOptions.warn = warn;
-
-        var compiled = baseCompile(template.trim(), finalOptions);
-        {
-          detectErrors(compiled.ast, warn);
-        }
-        compiled.errors = errors;
-        compiled.tips = tips;
-        return compiled
+  /* @flow */
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
+      }
+      catch (err) {
+          errors.push({ err: err, code: code });
+          return noop;
       }
+  }
+  function createCompileToFunctionFn(compile) {
+      var cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          var warn$$1 = options.warn || warn;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
+          }
+          // check cache
+          var key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
+          }
+          // compile
+          var compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach(function (e) {
+                          warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                  }
+                  else {
+                      compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                  }
+              }
+          }
+          // turn code into functions
+          var res = {};
+          var fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn$$1("Failed to generate render function:\n\n" +
+                      fnGenErrors
+                          .map(function (ref) {
+                              var err = ref.err;
+                              var code = ref.code;
+
+                              return ((err.toString()) + " in\n\n" + code + "\n");
+                  })
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
+  }
+
+  /* @flow */
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              var finalOptions = Object.create(baseOptions);
+              var errors = [];
+              var tips = [];
+              var warn = function (msg, range, tip) {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = function (msg, range, tip) {
+                          var data = { msg: msg };
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (var key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
+              }
+              finalOptions.warn = warn;
+              var compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
+          }
+          return {
+              compile: compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
+  }
 
+  /* @flow */
+  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      var ast = parse(template.trim(), options);
+      optimize(ast, options);
+      var code = generate$1(ast, options);
       return {
-        compile: compile,
-        compileToFunctions: createCompileToFunctionFn(compile)
-      }
-    }
-  }
-
-  /*  */
-
-  var createCompiler = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    optimize(ast, options);
-    var code = generate$1(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
+          ast: ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
-  /*  */
-
+  /* @flow */
   var ref = createCompiler(baseOptions);
   var compile = ref.compile;
   var compileToFunctions = ref.compileToFunctions;
 
-  /*  */
-
+  /* @flow */
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
   // For plain HTML markup, normalization can be completely skipped because the
   // generated render function is guaranteed to return Array<VNode>. There are
   // two cases where extra normalization is needed:
-
   // 1. When the children contains components - because a functional component
   // may return an Array instead of a single root. In this case, just a simple
   // normalization is needed - if any child is an Array, we flatten the whole
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
-  function simpleNormalizeChildren (children) {
-    for (var i = 0; i < children.length; i++) {
-      if (Array.isArray(children[i])) {
-        return Array.prototype.concat.apply([], children)
+  function simpleNormalizeChildren(children) {
+      for (var i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
       }
-    }
-    return children
+      return children;
   }
-
   // 2. When the children contains constructs that always generated nested Arrays,
   // e.g. <template>, <slot>, v-for, or when the children is provided by user
   // with hand-written render functions / JSX. In such cases a full normalization
   // is needed to cater to all possible types of children values.
-  function normalizeChildren (children) {
-    return isPrimitive(children)
-      ? [createTextVNode(children)]
-      : Array.isArray(children)
-        ? normalizeArrayChildren(children)
-        : undefined
-  }
-
-  function isTextNode (node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-  }
-
-  function normalizeArrayChildren (children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-      c = children[i];
-      if (isUndef(c) || typeof c === 'boolean') { continue }
-      lastIndex = res.length - 1;
-      last = res[lastIndex];
-      //  nested
-      if (Array.isArray(c)) {
-        if (c.length > 0) {
-          c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-          // merge adjacent text nodes
-          if (isTextNode(c[0]) && isTextNode(last)) {
-            res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-            c.shift();
-          }
-          res.push.apply(res, c);
-        }
-      } else if (isPrimitive(c)) {
-        if (isTextNode(last)) {
-          // merge adjacent text nodes
-          // this is necessary for SSR hydration because text nodes are
-          // essentially merged when rendered to HTML strings
-          res[lastIndex] = createTextVNode(last.text + c);
-        } else if (c !== '') {
-          // convert primitive to vnode
-          res.push(createTextVNode(c));
-        }
-      } else {
-        if (isTextNode(c) && isTextNode(last)) {
-          // merge adjacent text nodes
-          res[lastIndex] = createTextVNode(last.text + c.text);
-        } else {
-          // default key for nested array children (likely generated by v-for)
-          if (isTrue(children._isVList) &&
-            isDef(c.tag) &&
-            isUndef(c.key) &&
-            isDef(nestedIndex)) {
-            c.key = "__vlist" + nestedIndex + "_" + i + "__";
-          }
-          res.push(c);
-        }
-      }
-    }
-    return res
-  }
-
-  /*  */
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      var res = [];
+      var i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              { continue; }
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
+  }
 
+  /* @flow */
   var ssrHelpers = {
-    _ssrEscape: escape,
-    _ssrNode: renderStringNode,
-    _ssrList: renderStringList,
-    _ssrAttr: renderAttr,
-    _ssrAttrs: renderAttrs$1,
-    _ssrDOMProps: renderDOMProps$1,
-    _ssrClass: renderSSRClass,
-    _ssrStyle: renderSSRStyle
+      _ssrEscape: escape,
+      _ssrNode: renderStringNode,
+      _ssrList: renderStringList,
+      _ssrAttr: renderAttr,
+      _ssrAttrs: renderAttrs$1,
+      _ssrDOMProps: renderDOMProps$1,
+      _ssrClass: renderSSRClass,
+      _ssrStyle: renderSSRStyle,
   };
-
-  function installSSRHelpers (vm) {
-    if (vm._ssrNode) {
-      return
-    }
-    var Vue = vm.constructor;
-    while (Vue.super) {
-      Vue = Vue.super;
-    }
-    extend(Vue.prototype, ssrHelpers);
-    if (Vue.FunctionalRenderContext) {
-      extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-    }
-  }
-
-  var StringNode = function StringNode (
-    open,
-    close,
-    children,
-    normalizationType
-  ) {
-    this.isString = true;
-    this.open = open;
-    this.close = close;
-    if (children) {
-      this.children = normalizationType === 1
-        ? simpleNormalizeChildren(children)
-        : normalizationType === 2
-          ? normalizeChildren(children)
-          : children;
-    } else {
-      this.children = void 0;
-    }
+  function installSSRHelpers(vm) {
+      if (vm._ssrNode) {
+          return;
+      }
+      var Vue = vm.constructor;
+      // @ts-expect-error
+      while (Vue.super) {
+          // @ts-expect-error
+          Vue = Vue.super;
+      }
+      extend(Vue.prototype, ssrHelpers);
+      // @ts-expect-error
+      if (Vue.FunctionalRenderContext) {
+          // @ts-expect-error
+          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+      }
+  }
+  var StringNode = function StringNode(open, close, children, normalizationType) {
+      this.isString = true;
+      this.open = open;
+      this.close = close;
+      if (children) {
+          this.children =
+              normalizationType === 1
+                  ? simpleNormalizeChildren(children)
+                  : normalizationType === 2
+                      ? normalizeChildren(children)
+                      : children;
+      }
+      else {
+          this.children = void 0;
+      }
   };
-
-  function renderStringNode (
-    open,
-    close,
-    children,
-    normalizationType
-  ) {
-    return new StringNode(open, close, children, normalizationType)
-  }
-
-  function renderStringList (
-    val,
-    render
-  ) {
-    var ret = '';
-    var i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-      for (i = 0, l = val.length; i < l; i++) {
-        ret += render(val[i], i);
-      }
-    } else if (typeof val === 'number') {
-      for (i = 0; i < val; i++) {
-        ret += render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      keys = Object.keys(val);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret += render(val[key], key, i);
-      }
-    }
-    return ret
-  }
-
-  function renderAttrs$1 (obj) {
-    var res = '';
-    for (var key in obj) {
-      if (isSSRUnsafeAttr(key)) {
-        continue
-      }
-      res += renderAttr(key, obj[key]);
-    }
-    return res
-  }
-
-  function renderDOMProps$1 (obj) {
-    var res = '';
-    for (var key in obj) {
-      var attr = propsToAttrMap[key] || key.toLowerCase();
-      if (isRenderableAttr(attr)) {
-        res += renderAttr(attr, obj[key]);
-      }
-    }
-    return res
-  }
-
-  function renderSSRClass (
-    staticClass,
-    dynamic
-  ) {
-    var res = renderClass(staticClass, dynamic);
-    return res === '' ? res : (" class=\"" + (escape(res)) + "\"")
-  }
-
-  function renderSSRStyle (
-    staticStyle,
-    dynamic,
-    extra
-  ) {
-    var style = {};
-    if (staticStyle) { extend(style, staticStyle); }
-    if (dynamic) { extend(style, normalizeStyleBinding(dynamic)); }
-    if (extra) { extend(style, extra); }
-    var res = genStyle(style);
-    return res === '' ? res : (" style=" + (JSON.stringify(escape(res))))
+  function renderStringNode(open, close, children, normalizationType) {
+      return new StringNode(open, close, children, normalizationType);
+  }
+  function renderStringList(val, render) {
+      var ret = '';
+      var i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          for (i = 0, l = val.length; i < l; i++) {
+              ret += render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          for (i = 0; i < val; i++) {
+              ret += render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          keys = Object.keys(val);
+          for (i = 0, l = keys.length; i < l; i++) {
+              key = keys[i];
+              ret += render(val[key], key, i);
+          }
+      }
+      return ret;
+  }
+  function renderAttrs$1(obj) {
+      var res = '';
+      for (var key in obj) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          res += renderAttr(key, obj[key]);
+      }
+      return res;
+  }
+  function renderDOMProps$1(obj) {
+      var res = '';
+      for (var key in obj) {
+          var attr = propsToAttrMap[key] || key.toLowerCase();
+          if (isRenderableAttr(attr)) {
+              res += renderAttr(attr, obj[key]);
+          }
+      }
+      return res;
+  }
+  function renderSSRClass(staticClass, dynamic) {
+      var res = renderClass(staticClass, dynamic);
+      return res === '' ? res : (" class=\"" + (escape(res)) + "\"");
+  }
+  function renderSSRStyle(staticStyle, dynamic, extra) {
+      var style = {};
+      if (staticStyle)
+          { extend(style, staticStyle); }
+      if (dynamic)
+          { extend(style, normalizeStyleBinding(dynamic)); }
+      if (extra)
+          { extend(style, extra); }
+      var res = genStyle(style);
+      return res === '' ? res : (" style=" + (JSON.stringify(escape(res))));
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
-
   {
-    var allowedGlobals = makeMap(
-      'Infinity,undefined,NaN,isFinite,isNaN,' +
-      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-      'require' // for Webpack/Browserify
-    );
-
-    var hasProxy =
-      typeof Proxy !== 'undefined' && isNative(Proxy);
-
-    if (hasProxy) {
-      var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-      config.keyCodes = new Proxy(config.keyCodes, {
-        set: function set (target, key, value) {
-          if (isBuiltInModifier(key)) {
-            warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-            return false
-          } else {
-            target[key] = value;
-            return true
-          }
-        }
-      });
-    }
+      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
+      );
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var seenObjects = new _Set();
-
   /**
    * Recursively traverse an object to evoke all converted
    * getters, so that every nested property inside the object
    * is collected as a "deep" dependency.
    */
-  function traverse (val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-  }
-
-  function _traverse (val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-      return
-    }
-    if (val.__ob__) {
-      var depId = val.__ob__.dep.id;
-      if (seen.has(depId)) {
-        return
-      }
-      seen.add(depId);
-    }
-    if (isA) {
-      i = val.length;
-      while (i--) { _traverse(val[i], seen); }
-    } else {
-      keys = Object.keys(val);
-      i = keys.length;
-      while (i--) { _traverse(val[keys[i]], seen); }
-    }
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      var i, keys;
+      var isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          var depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              { _traverse(val[i], seen); }
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              { _traverse(val[keys[i]], seen); }
+      }
   }
 
   {
-    var perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (
-      perf &&
-      perf.mark &&
-      perf.measure &&
-      perf.clearMarks &&
-      perf.clearMeasures
-    ) ;
+      var perf = inBrowser && window.performance;
+      /* istanbul ignore if */
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) ;
   }
 
-  /*  */
-
   var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-      name: name,
-      once: once$$1,
-      capture: capture,
-      passive: passive
-    }
+      var passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once$$1 ? name.slice(1) : name;
+      var capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name: name,
+          once: once$$1,
+          capture: capture,
+          passive: passive,
+      };
   });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          var arguments$1 = arguments;
+
+          var fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              var cloned = fns.slice();
+              for (var i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+      var name, def$$1, cur, old, event;
+      for (name in on) {
+          def$$1 = cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove$$1(event.name, oldOn[name], event.capture);
+          }
+      }
+  }
 
-  function createFnInvoker (fns, vm) {
-    function invoker () {
-      var arguments$1 = arguments;
-
-      var fns = invoker.fns;
-      if (Array.isArray(fns)) {
-        var cloned = fns.slice();
-        for (var i = 0; i < cloned.length; i++) {
-          invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-        }
-      } else {
-        // return handler return value for single handlers
-        return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-      }
-    }
-    invoker.fns = fns;
-    return invoker
-  }
-
-  function updateListeners (
-    on,
-    oldOn,
-    add,
-    remove$$1,
-    createOnceHandler,
-    vm
-  ) {
-    var name, def$$1, cur, old, event;
-    for (name in on) {
-      def$$1 = cur = on[name];
-      old = oldOn[name];
-      event = normalizeEvent(name);
-      if (isUndef(cur)) {
-        warn(
-          "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-          vm
-        );
-      } else if (isUndef(old)) {
-        if (isUndef(cur.fns)) {
-          cur = on[name] = createFnInvoker(cur, vm);
-        }
-        if (isTrue(event.once)) {
-          cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-        }
-        add(event.name, cur, event.capture, event.passive, event.params);
-      } else if (cur !== old) {
-        old.fns = cur;
-        on[name] = old;
-      }
-    }
-    for (name in oldOn) {
-      if (isUndef(on[name])) {
-        event = normalizeEvent(name);
-        remove$$1(event.name, oldOn[name], event.capture);
-      }
-    }
-  }
-
-  /*  */
-
-  /*  */
-
-  function extractPropsFromVNodeData (
-    data,
-    Ctor,
-    tag
-  ) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    var propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-      return
-    }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
-    if (isDef(attrs) || isDef(props)) {
-      for (var key in propOptions) {
-        var altKey = hyphenate(key);
-        {
-          var keyInLowerCase = key.toLowerCase();
-          if (
-            key !== keyInLowerCase &&
-            attrs && hasOwn(attrs, keyInLowerCase)
-          ) {
-            tip(
-              "Prop \"" + keyInLowerCase + "\" is passed to component " +
-              (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-              " \"" + key + "\". " +
-              "Note that HTML attributes are case-insensitive and camelCased " +
-              "props need to use their kebab-case equivalents when using in-DOM " +
-              "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-            );
-          }
-        }
-        checkProp(res, props, key, altKey, true) ||
-        checkProp(res, attrs, key, altKey, false);
-      }
-    }
-    return res
-  }
-
-  function checkProp (
-    res,
-    hash,
-    key,
-    altKey,
-    preserve
-  ) {
-    if (isDef(hash)) {
-      if (hasOwn(hash, key)) {
-        res[key] = hash[key];
-        if (!preserve) {
-          delete hash[key];
-        }
-        return true
-      } else if (hasOwn(hash, altKey)) {
-        res[key] = hash[altKey];
-        if (!preserve) {
-          delete hash[altKey];
-        }
-        return true
-      }
-    }
-    return false
-  }
-
-  /*  */
+  /* @flow */
+
+  /* @flow */
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      var propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      var res = {};
+      var attrs = data.attrs;
+      var props = data.props;
+      if (isDef(attrs) || isDef(props)) {
+          for (var key in propOptions) {
+              var altKey = hyphenate(key);
+              {
+                  var keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                          (formatComponentName(
+                          // @ts-ignore
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
+                          "Note that HTML attributes are case-insensitive and camelCased " +
+                          "props need to use their kebab-case equivalents when using in-DOM " +
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
+  }
 
+  /* @flow */
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
-
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType,
-    alwaysNormalize
-  ) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-      normalizationType = children;
-      children = data;
-      data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-      normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType)
-  }
-
-  function _createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType
-  ) {
-    if (isDef(data) && isDef((data).__ob__)) {
-      warn(
-        "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-        'Always create fresh vnode data objects in each render!',
-        context
-      );
-      return createEmptyVNode()
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-      tag = data.is;
-    }
-    if (!tag) {
-      // in case of component :is set to falsy value
-      return createEmptyVNode()
-    }
-    // warn against non-primitive key
-    if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-    ) {
-      {
-        warn(
-          'Avoid using non-primitive value as key, ' +
-          'use string/number value instead.',
-          context
-        );
-      }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) &&
-      typeof children[0] === 'function'
-    ) {
-      data = data || {};
-      data.scopedSlots = { default: children[0] };
-      children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-      children = normalizeChildren(children);
-    } else if (normalizationType === SIMPLE_NORMALIZE) {
-      children = simpleNormalizeChildren(children);
-    }
-    var vnode, ns;
-    if (typeof tag === 'string') {
-      var Ctor;
-      ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-      if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-        // component
-        vnode = createComponent(Ctor, data, context, children, tag);
-      } else {
-        // unknown or unlisted namespaced elements
-        // check at runtime because it may get assigned a namespace when its
-        // parent normalizes children
-        vnode = new VNode(
-          tag, data, children,
-          undefined, undefined, context
-        );
-      }
-    } else {
-      // direct component options / constructor
-      vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-      return vnode
-    } else if (isDef(vnode)) {
-      if (isDef(ns)) { applyNS(vnode, ns); }
-      if (isDef(data)) { registerDeepBindings(data); }
-      return vnode
-    } else {
-      return createEmptyVNode()
-    }
-  }
-
-  function applyNS (vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-      // use default namespace inside foreignObject
-      ns = undefined;
-      force = true;
-    }
-    if (isDef(vnode.children)) {
-      for (var i = 0, l = vnode.children.length; i < l; i++) {
-        var child = vnode.children[i];
-        if (isDef(child.tag) && (
-          isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-          applyNS(child, ns, force);
-        }
-      }
-    }
+  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      var vnode, ns;
+      if (typeof tag === 'string') {
+          var Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              { applyNS(vnode, ns); }
+          if (isDef(data))
+              { registerDeepBindings(data); }
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (var i = 0, l = vnode.children.length; i < l; i++) {
+              var child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
   }
-
   // ref #5318
   // necessary to ensure parent re-render when deep bindings like :style and
   // :class are used on slot nodes
-  function registerDeepBindings (data) {
-    if (isObject(data.style)) {
-      traverse(data.style);
-    }
-    if (isObject(data.class)) {
-      traverse(data.class);
-    }
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering v-for lists.
    */
-  function renderList (
-    val,
-    render
-  ) {
-    var ret, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-      ret = new Array(val.length);
-      for (i = 0, l = val.length; i < l; i++) {
-        ret[i] = render(val[i], i);
-      }
-    } else if (typeof val === 'number') {
-      ret = new Array(val);
-      for (i = 0; i < val; i++) {
-        ret[i] = render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      if (hasSymbol && val[Symbol.iterator]) {
-        ret = [];
-        var iterator = val[Symbol.iterator]();
-        var result = iterator.next();
-        while (!result.done) {
-          ret.push(render(result.value, ret.length));
-          result = iterator.next();
-        }
-      } else {
-        keys = Object.keys(val);
-        ret = new Array(keys.length);
-        for (i = 0, l = keys.length; i < l; i++) {
-          key = keys[i];
-          ret[i] = render(val[key], key, i);
-        }
+  function renderList(val, render) {
+      var ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              var iterator = val[Symbol.iterator]();
+              var result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
       }
-    }
-    if (!isDef(ret)) {
-      ret = [];
-    }
-    (ret)._isVList = true;
-    return ret
+      ret._isVList = true;
+      return ret;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering <slot>
    */
-  function renderSlot (
-    name,
-    fallback,
-    props,
-    bindObject
-  ) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
-    if (scopedSlotFn) { // scoped slot
-      props = props || {};
-      if (bindObject) {
-        if (!isObject(bindObject)) {
-          warn(
-            'slot v-bind without argument expects an Object',
-            this
-          );
-        }
-        props = extend(extend({}, bindObject), props);
+  function renderSlot(name, fallback, props, bindObject) {
+      var scopedSlotFn = this.$scopedSlots[name];
+      var nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn('slot v-bind without argument expects an Object', this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes = scopedSlotFn(props) || fallback;
+      }
+      else {
+          nodes = this.$slots[name] || fallback;
+      }
+      var target = props && props.slot;
+      if (target) {
+          return this.$createElement('template', { slot: target }, nodes);
+      }
+      else {
+          return nodes;
       }
-      nodes = scopedSlotFn(props) || fallback;
-    } else {
-      nodes = this.$slots[name] || fallback;
-    }
-
-    var target = props && props.slot;
-    if (target) {
-      return this.$createElement('template', { slot: target }, nodes)
-    } else {
-      return nodes
-    }
   }
 
-  /*  */
-
   /**
    * Runtime helper for resolving filters
    */
-  function resolveFilter (id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /*  */
-
-  function isKeyNotMatch (expect, actual) {
-    if (Array.isArray(expect)) {
-      return expect.indexOf(actual) === -1
-    } else {
-      return expect !== actual
-    }
+  /* @flow */
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
   }
-
   /**
    * Runtime helper for checking keyCodes from config.
    * exposed as Vue.prototype._k
    * passing in eventKeyName as last argument separately for backwards compat
    */
-  function checkKeyCodes (
-    eventKeyCode,
-    key,
-    builtInKeyCode,
-    eventKeyName,
-    builtInKeyName
-  ) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-      return isKeyNotMatch(builtInKeyName, eventKeyName)
-    } else if (mappedKeyCode) {
-      return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-    } else if (eventKeyName) {
-      return hyphenate(eventKeyName) !== key
-    }
-  }
-
-  /*  */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+  }
 
+  /* @flow */
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
-  function bindObjectProps (
-    data,
-    tag,
-    value,
-    asProp,
-    isSync
-  ) {
-    if (value) {
-      if (!isObject(value)) {
-        warn(
-          'v-bind without argument expects an Object or Array value',
-          this
-        );
-      } else {
-        if (Array.isArray(value)) {
-          value = toObject(value);
-        }
-        var hash;
-        var loop = function ( key ) {
-          if (
-            key === 'class' ||
-            key === 'style' ||
-            isReservedAttribute(key)
-          ) {
-            hash = data;
-          } else {
-            var type = data.attrs && data.attrs.type;
-            hash = asProp || config.mustUseProp(tag, type, key)
-              ? data.domProps || (data.domProps = {})
-              : data.attrs || (data.attrs = {});
-          }
-          var camelizedKey = camelize(key);
-          var hyphenatedKey = hyphenate(key);
-          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-            hash[key] = value[key];
-
-            if (isSync) {
-              var on = data.on || (data.on = {});
-              on[("update:" + key)] = function ($event) {
-                value[key] = $event;
-              };
-            }
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn('v-bind without argument expects an Object or Array value', this);
           }
-        };
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              var hash;
+              var loop = function ( key ) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      var type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  var camelizedKey = camelize(key);
+                  var hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          var on = data.on || (data.on = {});
+                          on[("update:" + key)] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              };
 
-        for (var key in value) loop( key );
+              for (var key in value) loop( key );
+          }
       }
-    }
-    return data
+      return data;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering static trees.
    */
-  function renderStatic (
-    index,
-    isInFor
-  ) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-      return tree
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(
-      this._renderProxy,
-      null,
-      this // for render fns generated for functional component templates
-    );
-    markStatic(tree, ("__static__" + index), false);
-    return tree
+  function renderStatic(index, isInFor) {
+      var cached = this._staticTrees || (this._staticTrees = []);
+      var tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, ("__static__" + index), false);
+      return tree;
   }
-
   /**
    * Runtime helper for v-once.
    * Effectively it means marking the node as static with a unique key.
    */
-  function markOnce (
-    tree,
-    index,
-    key
-  ) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-    return tree
+  function markOnce(tree, index, key) {
+      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (var i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
-  function markStatic (
-    tree,
-    key,
-    isOnce
-  ) {
-    if (Array.isArray(tree)) {
-      for (var i = 0; i < tree.length; i++) {
-        if (tree[i] && typeof tree[i] !== 'string') {
-          markStaticNode(tree[i], (key + "_" + i), isOnce);
-        }
+  /* @flow */
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn('v-on without argument expects an Object value', this);
+          }
+          else {
+              var on = (data.on = data.on ? extend({}, data.on) : {});
+              for (var key in value) {
+                  var existing = on[key];
+                  var ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
       }
-    } else {
-      markStaticNode(tree, key, isOnce);
-    }
+      return data;
   }
 
-  function markStaticNode (node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (var i = 0; i < fns.length; i++) {
+          var slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
-  /*  */
-
-  function bindObjectListeners (data, value) {
-    if (value) {
-      if (!isPlainObject(value)) {
-        warn(
-          'v-on without argument expects an Object value',
-          this
-        );
-      } else {
-        var on = data.on = data.on ? extend({}, data.on) : {};
-        for (var key in value) {
-          var existing = on[key];
-          var ours = value[key];
-          on[key] = existing ? [].concat(existing, ours) : ours;
-        }
-      }
-    }
-    return data
-  }
-
-  /*  */
-
-  function resolveScopedSlots (
-    fns, // see flow/vnode
-    res,
-    // the following are added in 2.6
-    hasDynamicKeys,
-    contentHashKey
-  ) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-      var slot = fns[i];
-      if (Array.isArray(slot)) {
-        resolveScopedSlots(slot, res, hasDynamicKeys);
-      } else if (slot) {
-        // marker for reverse proxying v-slot without scope on this.$slots
-        if (slot.proxy) {
-          slot.fn.proxy = true;
-        }
-        res[slot.key] = slot.fn;
-      }
-    }
-    if (contentHashKey) {
-      (res).$key = contentHashKey;
-    }
-    return res
-  }
-
-  /*  */
-
-  function bindDynamicKeys (baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-      var key = values[i];
-      if (typeof key === 'string' && key) {
-        baseObj[values[i]] = values[i + 1];
-      } else if (key !== '' && key !== null) {
-        // null is a special value for explicitly removing a binding
-        warn(
-          ("Invalid value for dynamic directive argument (expected string or null): " + key),
-          this
-        );
-      }
-    }
-    return baseObj
+  /* @flow */
+  function bindDynamicKeys(baseObj, values) {
+      for (var i = 0; i < values.length; i += 2) {
+          var key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+          }
+      }
+      return baseObj;
   }
-
   // helper to dynamically append modifier runtime markers to event names.
   // ensure only append when value is already string, otherwise it will be cast
   // to string and cause the type check to miss.
-  function prependModifier (value, symbol) {
-    return typeof value === 'string' ? symbol + value : value
-  }
-
-  /*  */
-
-  function installRenderHelpers (target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-  }
-
-  /*  */
-
-
-
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
+  }
+
+  /* @flow */
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
+  }
+
+  /* @flow */
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
-  function resolveSlots (
-    children,
-    context
-  ) {
-    if (!children || !children.length) {
-      return {}
-    }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-      var child = children[i];
-      var data = child.data;
-      // remove slot attribute if the node is resolved as a Vue slot node
-      if (data && data.attrs && data.attrs.slot) {
-        delete data.attrs.slot;
-      }
-      // named slots should only be respected if the vnode was rendered in the
-      // same context.
-      if ((child.context === context || child.fnContext === context) &&
-        data && data.slot != null
-      ) {
-        var name = data.slot;
-        var slot = (slots[name] || (slots[name] = []));
-        if (child.tag === 'template') {
-          slot.push.apply(slot, child.children || []);
-        } else {
-          slot.push(child);
-        }
-      } else {
-        (slots.default || (slots.default = [])).push(child);
-      }
-    }
-    // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-      if (slots[name$1].every(isWhitespace)) {
-        delete slots[name$1];
-      }
-    }
-    return slots
-  }
-
-  function isWhitespace (node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' '
-  }
-
-  /*  */
-
-  function normalizeScopedSlots (
-    slots,
-    normalSlots,
-    prevSlots
-  ) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
-    if (!slots) {
-      res = {};
-    } else if (slots._normalized) {
-      // fast path 1: child component re-render only, parent did not change
-      return slots._normalized
-    } else if (
-      isStable &&
-      prevSlots &&
-      prevSlots !== emptyObject &&
-      key === prevSlots.$key &&
-      !hasNormalSlots &&
-      !prevSlots.$hasNormal
-    ) {
-      // fast path 2: stable scoped slots w/ no normal slots to proxy,
-      // only need to normalize once
-      return prevSlots
-    } else {
-      res = {};
-      for (var key$1 in slots) {
-        if (slots[key$1] && key$1[0] !== '$') {
-          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-        }
-      }
-    }
-    // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-      if (!(key$2 in res)) {
-        res[key$2] = proxyNormalSlot(normalSlots, key$2);
-      }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-      (slots)._normalized = res;
-    }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
-    return res
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      var slots = {};
+      for (var i = 0, l = children.length; i < l; i++) {
+          var child = children[i];
+          var data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  }
+
+  /* @flow */
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      var res;
+      var hasNormalSlots = Object.keys(normalSlots).length > 0;
+      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      var key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, '$stable', isStable);
+      def(res, '$key', key);
+      def(res, '$hasNormal', hasNormalSlots);
+      return res;
   }
-
   function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-      var res = arguments.length ? fn.apply(null, arguments) : fn({});
-      res = res && typeof res === 'object' && !Array.isArray(res)
-        ? [res] // single vnode
-        : normalizeChildren(res);
-      return res && (
-        res.length === 0 ||
-        (res.length === 1 && res[0].isComment) // #9658
-      ) ? undefined
-        : res
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-      Object.defineProperty(normalSlots, key, {
-        get: normalized,
-        enumerable: true,
-        configurable: true
-      });
-    }
-    return normalized
+      var normalized = function () {
+          var res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === 'object' && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
   }
-
   function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; }
+      return function () { return slots[key]; };
   }
 
-  /*  */
-
+  /* @flow */
   var currentRenderingInstance = null;
 
-  /*  */
-
-  function ensureCtor (comp, base) {
-    if (
-      comp.__esModule ||
-      (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-    ) {
-      comp = comp.default;
-    }
-    return isObject(comp)
-      ? base.extend(comp)
-      : comp
-  }
-
-  function createAsyncPlaceholder (
-    factory,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    var node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-    return node
-  }
-
-  function resolveAsyncComponent (
-    factory,
-    baseCtor
-  ) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-      return factory.errorComp
-    }
-
-    if (isDef(factory.resolved)) {
-      return factory.resolved
-    }
-
-    var owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-      // already pending
-      factory.owners.push(owner);
-    }
-
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-      return factory.loadingComp
-    }
-
-    if (owner && !isDef(factory.owners)) {
-      var owners = factory.owners = [owner];
-      var sync = true;
-      var timerLoading = null;
-      var timerTimeout = null
-
-      ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-      var forceRender = function (renderCompleted) {
-        for (var i = 0, l = owners.length; i < l; i++) {
-          (owners[i]).$forceUpdate();
-        }
-
-        if (renderCompleted) {
-          owners.length = 0;
-          if (timerLoading !== null) {
-            clearTimeout(timerLoading);
-            timerLoading = null;
-          }
-          if (timerTimeout !== null) {
-            clearTimeout(timerTimeout);
-            timerTimeout = null;
-          }
-        }
-      };
-
-      var resolve = once(function (res) {
-        // cache resolved
-        factory.resolved = ensureCtor(res, baseCtor);
-        // invoke callbacks only if this is not a synchronous resolve
-        // (async resolves are shimmed as synchronous during SSR)
-        if (!sync) {
-          forceRender(true);
-        } else {
-          owners.length = 0;
-        }
-      });
-
-      var reject = once(function (reason) {
-        warn(
-          "Failed to resolve async component: " + (String(factory)) +
-          (reason ? ("\nReason: " + reason) : '')
-        );
-        if (isDef(factory.errorComp)) {
-          factory.error = true;
-          forceRender(true);
-        }
-      });
-
-      var res = factory(resolve, reject);
-
-      if (isObject(res)) {
-        if (isPromise(res)) {
-          // () => Promise
-          if (isUndef(factory.resolved)) {
-            res.then(resolve, reject);
-          }
-        } else if (isPromise(res.component)) {
-          res.component.then(resolve, reject);
-
-          if (isDef(res.error)) {
-            factory.errorComp = ensureCtor(res.error, baseCtor);
-          }
-
-          if (isDef(res.loading)) {
-            factory.loadingComp = ensureCtor(res.loading, baseCtor);
-            if (res.delay === 0) {
-              factory.loading = true;
-            } else {
-              timerLoading = setTimeout(function () {
-                timerLoading = null;
-                if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                  factory.loading = true;
-                  forceRender(false);
-                }
-              }, res.delay || 200);
-            }
-          }
-
-          if (isDef(res.timeout)) {
-            timerTimeout = setTimeout(function () {
-              timerTimeout = null;
-              if (isUndef(factory.resolved)) {
-                reject(
-                  "timeout (" + (res.timeout) + "ms)"
-                );
+  /* @flow */
+  function ensureCtor(comp, base) {
+      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+          comp = comp.default;
+      }
+      return isObject(comp) ? base.extend(comp) : comp;
+  }
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      var node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+      return node;
+  }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      var owner = currentRenderingInstance;
+      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+          // already pending
+          factory.owners.push(owner);
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+      if (owner && !isDef(factory.owners)) {
+          var owners = (factory.owners = [owner]);
+          var sync = true;
+          var timerLoading = null;
+          var timerTimeout = null;
+          owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+          var forceRender = function (renderCompleted) {
+              for (var i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
+              }
+              if (renderCompleted) {
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
+                  }
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
+                  }
+              }
+          };
+          var resolve = once(function (res) {
+              // cache resolved
+              factory.resolved = ensureCtor(res, baseCtor);
+              // invoke callbacks only if this is not a synchronous resolve
+              // (async resolves are shimmed as synchronous during SSR)
+              if (!sync) {
+                  forceRender(true);
+              }
+              else {
+                  owners.length = 0;
+              }
+          });
+          var reject = once(function (reason) {
+              warn("Failed to resolve async component: " + (String(factory)) +
+                      (reason ? ("\nReason: " + reason) : ''));
+              if (isDef(factory.errorComp)) {
+                  factory.error = true;
+                  forceRender(true);
+              }
+          });
+          var res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
+                  // () => Promise
+                  if (isUndef(factory.resolved)) {
+                      res.then(resolve, reject);
+                  }
+              }
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
+                  }
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
+                          factory.loading = true;
+                      }
+                      else {
+                          // @ts-expect-error NodeJS timeout type
+                          timerLoading = setTimeout(function () {
+                              timerLoading = null;
+                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                  factory.loading = true;
+                                  forceRender(false);
+                              }
+                          }, res.delay || 200);
+                      }
+                  }
+                  if (isDef(res.timeout)) {
+                      // @ts-expect-error NodeJS timeout type
+                      timerTimeout = setTimeout(function () {
+                          timerTimeout = null;
+                          if (isUndef(factory.resolved)) {
+                              reject("timeout (" + (res.timeout) + "ms)");
+                          }
+                      }, res.timeout);
+                  }
               }
-            }, res.timeout);
           }
-        }
+          sync = false;
+          // return in case resolved synchronously
+          return factory.loading ? factory.loadingComp : factory.resolved;
       }
-
-      sync = false;
-      // return in case resolved synchronously
-      return factory.loading
-        ? factory.loadingComp
-        : factory.resolved
-    }
   }
 
-  /*  */
-
-  /*  */
+  /* @flow */
 
-  /*  */
+  /* @flow */
 
-  /*  */
+  /* @flow */
 
+  /* @flow */
   var target;
-
-  function add (event, fn) {
-    target.$on(event, fn);
-  }
-
-  function remove$1 (event, fn) {
-    target.$off(event, fn);
-  }
-
-  function createOnceHandler (event, fn) {
-    var _target = target;
-    return function onceHandler () {
-      var res = fn.apply(null, arguments);
-      if (res !== null) {
-        _target.$off(event, onceHandler);
-      }
-    }
+  function add(event, fn) {
+      target.$on(event, fn);
+  }
+  function remove$1(event, fn) {
+      target.$off(event, fn);
+  }
+  function createOnceHandler(event, fn) {
+      var _target = target;
+      return function onceHandler() {
+          var res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
   }
-
-  function updateComponentListeners (
-    vm,
-    listeners,
-    oldListeners
-  ) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target = vm;
+      updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+      target = undefined;
   }
 
-  /*  */
-
+  /* @flow */
   var activeInstance = null;
-
-  function updateChildComponent (
-    vm,
-    propsData,
-    listeners,
-    parentVnode,
-    renderChildren
-  ) {
-
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!(
-      (newScopedSlots && !newScopedSlots.$stable) ||
-      (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-      (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-    );
-
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(
-      renderChildren ||               // has new static slots
-      vm.$options._renderChildren ||  // has old static slots
-      hasDynamicScopedSlot
-    );
-
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-    if (vm._vnode) { // update child tree's parent
-      vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-
-    // update props
-    if (propsData && vm.$options.props) {
-      toggleObserving(false);
-      var props = vm._props;
-      var propKeys = vm.$options._propKeys || [];
-      for (var i = 0; i < propKeys.length; i++) {
-        var key = propKeys[i];
-        var propOptions = vm.$options.props; // wtf flow?
-        props[key] = validateProp(key, propOptions, propsData, vm);
-      }
-      toggleObserving(true);
-      // keep a copy of raw propsData
-      vm.$options.propsData = propsData;
-    }
-
-    // update listeners
-    listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-      vm.$forceUpdate();
-    }
-  }
-
-  function isInInactiveTree (vm) {
-    while (vm && (vm = vm.$parent)) {
-      if (vm._inactive) { return true }
-    }
-    return false
-  }
-
-  function activateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = false;
-      if (isInInactiveTree(vm)) {
-        return
-      }
-    } else if (vm._directInactive) {
-      return
-    }
-    if (vm._inactive || vm._inactive === null) {
-      vm._inactive = false;
-      for (var i = 0; i < vm.$children.length; i++) {
-        activateChildComponent(vm.$children[i]);
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      var newScopedSlots = parentVnode.data.scopedSlots;
+      var oldScopedSlots = vm.$scopedSlots;
+      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      var needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      // @ts-ignore
+      vm.$options._parentVnode = parentVnode;
+      // @ts-ignore
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          // @ts-ignore
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      // @ts-ignore
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          var props = vm._props;
+          var propKeys = vm.$options._propKeys || [];
+          for (var i = 0; i < propKeys.length; i++) {
+              var key = propKeys[i];
+              var propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      var oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              { return true; }
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (var i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, 'activated');
       }
-      callHook(vm, 'activated');
-    }
   }
-
-  function deactivateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = true;
-      if (isInInactiveTree(vm)) {
-        return
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
       }
-    }
-    if (!vm._inactive) {
-      vm._inactive = true;
-      for (var i = 0; i < vm.$children.length; i++) {
-        deactivateChildComponent(vm.$children[i]);
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (var i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, 'deactivated');
       }
-      callHook(vm, 'deactivated');
-    }
   }
-
-  function callHook (vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
-    if (handlers) {
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+  function callHook(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      var handlers = vm.$options[hook];
+      var info = hook + " hook";
+      if (handlers) {
+          for (var i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit('hook:' + hook);
       }
-    }
-    if (vm._hasHookEvent) {
-      vm.$emit('hook:' + hook);
-    }
-    popTarget();
+      popTarget();
   }
 
-  /*  */
-
+  /* @flow */
   // Async edge case fix requires storing an event listener's attach timestamp.
   var getNow = Date.now;
-
   // Determine what event timestamp the browser is using. Annoyingly, the
   // timestamp can either be hi-res (relative to page load) or low-res
   // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -7996,962 +6984,857 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (
-      performance &&
-      typeof performance.now === 'function' &&
-      getNow() > document.createEvent('Event').timeStamp
-    ) {
-      // if the event timestamp, although evaluated AFTER the Date.now(), is
-      // smaller than it, it means the event is using a hi-res timestamp,
-      // and we need to use the hi-res version for event listener timestamps as
-      // well.
-      getNow = function () { return performance.now(); };
-    }
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = function () { return performance.now(); };
+      }
   }
-
   /**
    * Queue a kept-alive component that was activated during patch.
    * The queue will be processed after the entire tree has been patched.
    */
-  function queueActivatedComponent (vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
   }
 
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  function resolveInject (inject, vm) {
-    if (inject) {
-      // inject is :any because flow is not smart enough to figure out cached
-      var result = Object.create(null);
-      var keys = hasSymbol
-        ? Reflect.ownKeys(inject)
-        : Object.keys(inject);
-
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        // #6574 in case the inject object is observed...
-        if (key === '__ob__') { continue }
-        var provideKey = inject[key].from;
-        var source = vm;
-        while (source) {
-          if (source._provided && hasOwn(source._provided, provideKey)) {
-            result[key] = source._provided[provideKey];
-            break
-          }
-          source = source.$parent;
-        }
-        if (!source) {
-          if ('default' in inject[key]) {
-            var provideDefault = inject[key].default;
-            result[key] = typeof provideDefault === 'function'
-              ? provideDefault.call(vm)
-              : provideDefault;
-          } else {
-            warn(("Injection \"" + key + "\" not found"), vm);
-          }
-        }
-      }
-      return result
-    }
-  }
-
-  /*  */
-
-  function resolveConstructorOptions (Ctor) {
-    var options = Ctor.options;
-    if (Ctor.super) {
-      var superOptions = resolveConstructorOptions(Ctor.super);
-      var cachedSuperOptions = Ctor.superOptions;
-      if (superOptions !== cachedSuperOptions) {
-        // super option changed,
-        // need to resolve new options.
-        Ctor.superOptions = superOptions;
-        // check if there are any late-modified/attached options (#4976)
-        var modifiedOptions = resolveModifiedOptions(Ctor);
-        // update base extend options
-        if (modifiedOptions) {
-          extend(Ctor.extendOptions, modifiedOptions);
-        }
-        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-        if (options.name) {
-          options.components[options.name] = Ctor;
-        }
-      }
-    }
-    return options
-  }
-
-  function resolveModifiedOptions (Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
-      if (latest[key] !== sealed[key]) {
-        if (!modified) { modified = {}; }
-        modified[key] = latest[key];
-      }
-    }
-    return modified
-  }
-
-  /*  */
-
-  function FunctionalRenderContext (
-    data,
-    props,
-    children,
-    parent,
-    Ctor
-  ) {
-    var this$1 = this;
-
-    var options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
-    if (hasOwn(parent, '_uid')) {
-      contextVm = Object.create(parent);
-      // $flow-disable-line
-      contextVm._original = parent;
-    } else {
-      // the context vm passed in is a functional context as well.
-      // in this case we want to make sure we are able to get a hold to the
-      // real context instance.
-      contextVm = parent;
-      // $flow-disable-line
-      parent = parent._original;
-    }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
-
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-      if (!this$1.$slots) {
-        normalizeScopedSlots(
-          data.scopedSlots,
-          this$1.$slots = resolveSlots(children, parent)
-        );
-      }
-      return this$1.$slots
-    };
-
-    Object.defineProperty(this, 'scopedSlots', ({
-      enumerable: true,
-      get: function get () {
-        return normalizeScopedSlots(data.scopedSlots, this.slots())
-      }
-    }));
-
-    // support for compiled functional template
-    if (isCompiled) {
-      // exposing $options for renderStatic()
-      this.$options = options;
-      // pre-resolve slots for renderSlot()
-      this.$slots = this.slots();
-      this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-
-    if (options._scopeId) {
-      this._c = function (a, b, c, d) {
-        var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-        if (vnode && !Array.isArray(vnode)) {
-          vnode.fnScopeId = options._scopeId;
-          vnode.fnContext = parent;
-        }
-        return vnode
+  /* @flow */
+
+  /* @flow */
+
+  /* @flow */
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          var result = Object.create(null);
+          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (var i = 0; i < keys.length; i++) {
+              var key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  { continue; }
+              var provideKey = inject[key].from;
+              var source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      var provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      // @ts-ignore
+                      warn(("Injection \"" + key + "\" not found"), vm);
+                  }
+              }
+          }
+          return result;
+      }
+  }
+
+  /* @flow */
+  function resolveConstructorOptions(Ctor) {
+      var options = Ctor.options;
+      if (Ctor.super) {
+          var superOptions = resolveConstructorOptions(Ctor.super);
+          var cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              var modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      var modified;
+      var latest = Ctor.options;
+      var sealed = Ctor.sealedOptions;
+      for (var key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  { modified = {}; }
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
+  }
+
+  /* @flow */
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      var this$1 = this;
+
+      var options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      var contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      var isCompiled = isTrue(options._compiled);
+      var needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = function () {
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          }
+          return this$1.$slots;
       };
-    } else {
-      this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-    }
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get: function get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = function (a, b, c, d) {
+              var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+      }
   }
-
   installRenderHelpers(FunctionalRenderContext.prototype);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      var options = Ctor.options;
+      var props = {};
+      var propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (var key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              { mergeProps(props, data.attrs); }
+          if (isDef(data.props))
+              { mergeProps(props, data.props); }
+      }
+      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      var vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          var vnodes = normalizeChildren(vnode) || [];
+          var res = new Array(vnodes.length);
+          for (var i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      var clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (var key in from) {
+          to[camelize(key)] = from[key];
+      }
+  }
 
-  function createFunctionalComponent (
-    Ctor,
-    propsData,
-    data,
-    contextVm,
-    children
-  ) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
-    if (isDef(propOptions)) {
-      for (var key in propOptions) {
-        props[key] = validateProp(key, propOptions, propsData || emptyObject);
-      }
-    } else {
-      if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-      if (isDef(data.props)) { mergeProps(props, data.props); }
-    }
-
-    var renderContext = new FunctionalRenderContext(
-      data,
-      props,
-      children,
-      contextVm,
-      Ctor
-    );
-
-    var vnode = options.render.call(null, renderContext._c, renderContext);
-
-    if (vnode instanceof VNode) {
-      return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-    } else if (Array.isArray(vnode)) {
-      var vnodes = normalizeChildren(vnode) || [];
-      var res = new Array(vnodes.length);
-      for (var i = 0; i < vnodes.length; i++) {
-        res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-      }
-      return res
-    }
-  }
-
-  function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    var clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-      (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-      (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone
-  }
-
-  function mergeProps (to, from) {
-    for (var key in from) {
-      to[camelize(key)] = from[key];
-    }
-  }
-
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  /*  */
+  /* @flow */
 
+  /* @flow */
+
+  /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-    init: function init (vnode, hydrating) {
-      if (
-        vnode.componentInstance &&
-        !vnode.componentInstance._isDestroyed &&
-        vnode.data.keepAlive
-      ) {
-        // kept-alive components, treat as a patch
-        var mountedNode = vnode; // work around flow
-        componentVNodeHooks.prepatch(mountedNode, mountedNode);
-      } else {
-        var child = vnode.componentInstance = createComponentInstanceForVnode(
-          vnode,
-          activeInstance
-        );
-        child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-      }
-    },
-
-    prepatch: function prepatch (oldVnode, vnode) {
-      var options = vnode.componentOptions;
-      var child = vnode.componentInstance = oldVnode.componentInstance;
-      updateChildComponent(
-        child,
-        options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-      );
-    },
-
-    insert: function insert (vnode) {
-      var context = vnode.context;
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isMounted) {
-        componentInstance._isMounted = true;
-        callHook(componentInstance, 'mounted');
-      }
-      if (vnode.data.keepAlive) {
-        if (context._isMounted) {
-          // vue-router#1212
-          // During updates, a kept-alive component's child components may
-          // change, so directly walking the tree here may call activated hooks
-          // on incorrect children. Instead we push them into a queue which will
-          // be processed after the whole patch process ended.
-          queueActivatedComponent(componentInstance);
-        } else {
-          activateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    },
-
-    destroy: function destroy (vnode) {
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isDestroyed) {
-        if (!vnode.data.keepAlive) {
-          componentInstance.$destroy();
-        } else {
-          deactivateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    }
+      init: function init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              var mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch: function prepatch(oldVnode, vnode) {
+          var options = vnode.componentOptions;
+          var child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy: function destroy(vnode) {
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
   };
-
   var hooksToMerge = Object.keys(componentVNodeHooks);
-
-  function createComponent (
-    Ctor,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    if (isUndef(Ctor)) {
-      return
-    }
-
-    var baseCtor = context.$options._base;
-
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-      Ctor = baseCtor.extend(Ctor);
-    }
-
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-      {
-        warn(("Invalid Component definition: " + (String(Ctor))), context);
-      }
-      return
-    }
-
-    // async component
-    var asyncFactory;
-    if (isUndef(Ctor.cid)) {
-      asyncFactory = Ctor;
-      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-      if (Ctor === undefined) {
-        // return a placeholder node for async component, which is rendered
-        // as a comment node but preserves all the raw information for the node.
-        // the information will be used for async server-rendering and hydration.
-        return createAsyncPlaceholder(
-          asyncFactory,
-          data,
-          context,
-          children,
-          tag
-        )
-      }
-    }
-
-    data = data || {};
-
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-      transformModel(Ctor.options, data);
-    }
-
-    // extract props
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-    // functional component
-    if (isTrue(Ctor.options.functional)) {
-      return createFunctionalComponent(Ctor, propsData, data, context, children)
-    }
-
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    var listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-
-    if (isTrue(Ctor.options.abstract)) {
-      // abstract components do not keep anything
-      // other than props & listeners & slot
-
-      // work around flow
-      var slot = data.slot;
-      data = {};
-      if (slot) {
-        data.slot = slot;
-      }
-    }
-
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-
-    // return a placeholder vnode
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-      data, undefined, undefined, undefined, context,
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-      asyncFactory
-    );
-
-    return vnode
-  }
-
-  function createComponentInstanceForVnode (
-    vnode, // we know it's MountedComponentVNode but flow doesn't
-    parent // activeInstance in lifecycle state
-  ) {
-    var options = {
-      _isComponent: true,
-      _parentVnode: vnode,
-      parent: parent
-    };
-    // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-      options.render = inlineTemplate.render;
-      options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options)
-  }
-
-  function installComponentHooks (data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-      var key = hooksToMerge[i];
-      var existing = hooks[key];
-      var toMerge = componentVNodeHooks[key];
-      if (existing !== toMerge && !(existing && existing._merged)) {
-        hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-      }
-    }
-  }
-
-  function mergeHook$1 (f1, f2) {
-    var merged = function (a, b) {
-      // flow complains about extra args which is why we use any
-      f1(a, b);
-      f2(a, b);
-    };
-    merged._merged = true;
-    return merged
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      var baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn(("Invalid Component definition: " + (String(Ctor))), context);
+          }
+          return;
+      }
+      // async component
+      var asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      var listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          var slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      var name = Ctor.options.name || tag;
+      var vnode = new VNode(
+      // @ts-expect-error
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      var options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent: parent,
+      };
+      // check inline-template render functions
+      var inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      var hooks = data.hook || (data.hook = {});
+      for (var i = 0; i < hooksToMerge.length; i++) {
+          var key = hooksToMerge[i];
+          var existing = hooks[key];
+          var toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook$1(f1, f2) {
+      var merged = function (a, b) {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
   }
-
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
-  function transformModel (options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input'
-    ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
-    if (isDef(existing)) {
-      if (
-        Array.isArray(existing)
-          ? existing.indexOf(callback) === -1
-          : existing !== callback
-      ) {
-        on[event] = [callback].concat(existing);
-      }
-    } else {
-      on[event] = callback;
-    }
-  }
-
-  /*  */
+  function transformModel(options, data) {
+      var prop = (options.model && options.model.prop) || 'value';
+      var event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      var on = data.on || (data.on = {});
+      var existing = on[event];
+      var callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
+  }
 
+  /* @flow */
   var warned = Object.create(null);
   var warnOnce = function (msg) {
-    if (!warned[msg]) {
-      warned[msg] = true;
-      // eslint-disable-next-line no-console
-      console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
-    }
+      if (!warned[msg]) {
+          warned[msg] = true;
+          // eslint-disable-next-line no-console
+          console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
+      }
   };
-
   var onCompilationError = function (err, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"))
+      var trace = vm ? generateComponentTrace(vm) : '';
+      throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"));
   };
-
   var normalizeRender = function (vm) {
-    var ref = vm.$options;
-    var render = ref.render;
-    var template = ref.template;
-    var _scopeId = ref._scopeId;
-    if (isUndef(render)) {
-      if (template) {
-        var compiled = compileToFunctions(template, {
-          scopeId: _scopeId,
-          warn: onCompilationError
-        }, vm);
-
-        vm.$options.render = compiled.render;
-        vm.$options.staticRenderFns = compiled.staticRenderFns;
-      } else {
-        throw new Error(
-          ("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'))
-        )
-      }
-    }
+      var ref = vm.$options;
+      var render = ref.render;
+      var template = ref.template;
+      var _scopeId = ref._scopeId;
+      if (isUndef(render)) {
+          if (template) {
+              var compiled = compileToFunctions(template, {
+                  scopeId: _scopeId,
+                  warn: onCompilationError,
+              }, vm);
+              vm.$options.render = compiled.render;
+              vm.$options.staticRenderFns = compiled.staticRenderFns;
+          }
+          else {
+              throw new Error(("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous')));
+          }
+      }
   };
-
-  function waitForServerPrefetch (vm, resolve, reject) {
-    var handlers = vm.$options.serverPrefetch;
-    if (isDef(handlers)) {
-      if (!Array.isArray(handlers)) { handlers = [handlers]; }
-      try {
-        var promises = [];
-        for (var i = 0, j = handlers.length; i < j; i++) {
-          var result = handlers[i].call(vm, vm);
-          if (result && typeof result.then === 'function') {
-            promises.push(result);
-          }
-        }
-        Promise.all(promises).then(resolve).catch(reject);
-        return
-      } catch (e) {
-        reject(e);
-      }
-    }
-    resolve();
-  }
-
-  function renderNode (node, isRoot, context) {
-    if (node.isString) {
-      renderStringNode$1(node, context);
-    } else if (isDef(node.componentOptions)) {
-      renderComponent(node, isRoot, context);
-    } else if (isDef(node.tag)) {
-      renderElement(node, isRoot, context);
-    } else if (isTrue(node.isComment)) {
-      if (isDef(node.asyncFactory)) {
-        // async component
-        renderAsyncComponent(node, isRoot, context);
-      } else {
-        context.write(("<!--" + (node.text) + "-->"), context.next);
-      }
-    } else {
-      context.write(
-        node.raw ? node.text : escape(String(node.text)),
-        context.next
-      );
-    }
-  }
-
-  function registerComponentForCache (options, write) {
-    // exposed by vue-loader, need to call this if cache hit because
-    // component lifecycle hooks will not be called.
-    var register = options._ssrRegister;
-    if (write.caching && isDef(register)) {
-      write.componentBuffer[write.componentBuffer.length - 1].add(register);
-    }
-    return register
-  }
-
-  function renderComponent (node, isRoot, context) {
-    var write = context.write;
-    var next = context.next;
-    var userContext = context.userContext;
-
-    // check cache hit
-    var Ctor = node.componentOptions.Ctor;
-    var getKey = Ctor.options.serverCacheKey;
-    var name = Ctor.options.name;
-    var cache = context.cache;
-    var registerComponent = registerComponentForCache(Ctor.options, write);
-
-    if (isDef(getKey) && isDef(cache) && isDef(name)) {
-      var rawKey = getKey(node.componentOptions.propsData);
-      if (rawKey === false) {
-        renderComponentInner(node, isRoot, context);
-        return
-      }
-      var key = name + '::' + rawKey;
-      var has = context.has;
-      var get = context.get;
-      if (isDef(has)) {
-        has(key, function (hit) {
-          if (hit === true && isDef(get)) {
-            get(key, function (res) {
-              if (isDef(registerComponent)) {
-                registerComponent(userContext);
-              }
-              res.components.forEach(function (register) { return register(userContext); });
-              write(res.html, next);
-            });
-          } else {
-            renderComponentWithCache(node, isRoot, key, context);
-          }
-        });
-      } else if (isDef(get)) {
-        get(key, function (res) {
-          if (isDef(res)) {
-            if (isDef(registerComponent)) {
-              registerComponent(userContext);
-            }
-            res.components.forEach(function (register) { return register(userContext); });
-            write(res.html, next);
-          } else {
-            renderComponentWithCache(node, isRoot, key, context);
-          }
-        });
-      }
-    } else {
-      if (isDef(getKey) && isUndef(cache)) {
-        warnOnce(
-          "[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
-          'but no cache was provided to the renderer.'
-        );
-      }
-      if (isDef(getKey) && isUndef(name)) {
-        warnOnce(
-          "[vue-server-renderer] Components that implement \"serverCacheKey\" " +
-          "must also define a unique \"name\" option."
-        );
+  function waitForServerPrefetch(vm, resolve, reject) {
+      var handlers = vm.$options.serverPrefetch;
+      if (isDef(handlers)) {
+          if (!Array.isArray(handlers))
+              { handlers = [handlers]; }
+          try {
+              var promises = [];
+              for (var i = 0, j = handlers.length; i < j; i++) {
+                  var result = handlers[i].call(vm, vm);
+                  if (result && typeof result.then === 'function') {
+                      promises.push(result);
+                  }
+              }
+              Promise.all(promises).then(resolve).catch(reject);
+              return;
+          }
+          catch (e) {
+              reject(e);
+          }
       }
-      renderComponentInner(node, isRoot, context);
-    }
-  }
-
-  function renderComponentWithCache (node, isRoot, key, context) {
-    var write = context.write;
-    write.caching = true;
-    var buffer = write.cacheBuffer;
-    var bufferIndex = buffer.push('') - 1;
-    var componentBuffer = write.componentBuffer;
-    componentBuffer.push(new Set());
-    context.renderStates.push({
-      type: 'ComponentWithCache',
-      key: key,
-      buffer: buffer,
-      bufferIndex: bufferIndex,
-      componentBuffer: componentBuffer
-    });
-    renderComponentInner(node, isRoot, context);
-  }
-
-  function renderComponentInner (node, isRoot, context) {
-    var prevActive = context.activeInstance;
-    // expose userContext on vnode
-    node.ssrContext = context.userContext;
-    var child = context.activeInstance = createComponentInstanceForVnode(
-      node,
-      context.activeInstance
-    );
-    normalizeRender(child);
-
-    var resolve = function () {
-      var childNode = child._render();
-      childNode.parent = node;
+      resolve();
+  }
+  function renderNode(node, isRoot, context) {
+      if (node.isString) {
+          renderStringNode$1(node, context);
+      }
+      else if (isDef(node.componentOptions)) {
+          renderComponent(node, isRoot, context);
+      }
+      else if (isDef(node.tag)) {
+          renderElement(node, isRoot, context);
+      }
+      else if (isTrue(node.isComment)) {
+          if (isDef(node.asyncFactory)) {
+              // async component
+              renderAsyncComponent(node, isRoot, context);
+          }
+          else {
+              context.write(("<!--" + (node.text) + "-->"), context.next);
+          }
+      }
+      else {
+          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+      }
+  }
+  function registerComponentForCache(options, write) {
+      // exposed by vue-loader, need to call this if cache hit because
+      // component lifecycle hooks will not be called.
+      var register = options._ssrRegister;
+      if (write.caching && isDef(register)) {
+          write.componentBuffer[write.componentBuffer.length - 1].add(register);
+      }
+      return register;
+  }
+  function renderComponent(node, isRoot, context) {
+      var write = context.write;
+      var next = context.next;
+      var userContext = context.userContext;
+      // check cache hit
+      var Ctor = node.componentOptions.Ctor;
+      var getKey = Ctor.options.serverCacheKey;
+      var name = Ctor.options.name;
+      var cache = context.cache;
+      var registerComponent = registerComponentForCache(Ctor.options, write);
+      if (isDef(getKey) && isDef(cache) && isDef(name)) {
+          var rawKey = getKey(node.componentOptions.propsData);
+          if (rawKey === false) {
+              renderComponentInner(node, isRoot, context);
+              return;
+          }
+          var key = name + '::' + rawKey;
+          var has = context.has;
+          var get = context.get;
+          if (isDef(has)) {
+              has(key, function (hit) {
+                  if (hit === true && isDef(get)) {
+                      get(key, function (res) {
+                          if (isDef(registerComponent)) {
+                              registerComponent(userContext);
+                          }
+                          res.components.forEach(function (register) { return register(userContext); });
+                          write(res.html, next);
+                      });
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+          else if (isDef(get)) {
+              get(key, function (res) {
+                  if (isDef(res)) {
+                      if (isDef(registerComponent)) {
+                          registerComponent(userContext);
+                      }
+                      res.components.forEach(function (register) { return register(userContext); });
+                      write(res.html, next);
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+      }
+      else {
+          if (isDef(getKey) && isUndef(cache)) {
+              warnOnce("[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
+                  'but no cache was provided to the renderer.');
+          }
+          if (isDef(getKey) && isUndef(name)) {
+              warnOnce("[vue-server-renderer] Components that implement \"serverCacheKey\" " +
+                  "must also define a unique \"name\" option.");
+          }
+          renderComponentInner(node, isRoot, context);
+      }
+  }
+  function renderComponentWithCache(node, isRoot, key, context) {
+      var write = context.write;
+      write.caching = true;
+      var buffer = write.cacheBuffer;
+      var bufferIndex = buffer.push('') - 1;
+      var componentBuffer = write.componentBuffer;
+      componentBuffer.push(new Set());
       context.renderStates.push({
-        type: 'Component',
-        prevActive: prevActive
+          type: 'ComponentWithCache',
+          key: key,
+          buffer: buffer,
+          bufferIndex: bufferIndex,
+          componentBuffer: componentBuffer,
       });
-      renderNode(childNode, isRoot, context);
-    };
-
-    var reject = context.done;
-
-    waitForServerPrefetch(child, resolve, reject);
+      renderComponentInner(node, isRoot, context);
   }
-
-  function renderAsyncComponent (node, isRoot, context) {
-    var factory = node.asyncFactory;
-
-    var resolve = function (comp) {
-      if (comp.__esModule && comp.default) {
-        comp = comp.default;
-      }
-      var ref = node.asyncMeta;
-      var data = ref.data;
-      var children = ref.children;
-      var tag = ref.tag;
-      var nodeContext = node.asyncMeta.context;
-      var resolvedNode = createComponent(
-        comp,
-        data,
-        nodeContext,
-        children,
-        tag
-      );
-      if (resolvedNode) {
-        if (resolvedNode.componentOptions) {
-          // normal component
-          renderComponent(resolvedNode, isRoot, context);
-        } else if (!Array.isArray(resolvedNode)) {
-          // single return node from functional component
-          renderNode(resolvedNode, isRoot, context);
-        } else {
-          // multiple return nodes from functional component
+  function renderComponentInner(node, isRoot, context) {
+      var prevActive = context.activeInstance;
+      // expose userContext on vnode
+      node.ssrContext = context.userContext;
+      var child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+      normalizeRender(child);
+      var resolve = function () {
+          var childNode = child._render();
+          childNode.parent = node;
           context.renderStates.push({
-            type: 'Fragment',
-            children: resolvedNode,
-            rendered: 0,
-            total: resolvedNode.length
+              type: 'Component',
+              prevActive: prevActive,
           });
-          context.next();
-        }
-      } else {
-        // invalid component, but this does not throw on the client
-        // so render empty comment node
-        context.write("<!---->", context.next);
-      }
-    };
-
-    if (factory.resolved) {
-      resolve(factory.resolved);
-      return
-    }
-
-    var reject = context.done;
-    var res;
-    try {
-      res = factory(resolve, reject);
-    } catch (e) {
-      reject(e);
-    }
-    if (res) {
-      if (typeof res.then === 'function') {
-        res.then(resolve, reject).catch(reject);
-      } else {
-        // new syntax in 2.3
-        var comp = res.component;
-        if (comp && typeof comp.then === 'function') {
-          comp.then(resolve, reject).catch(reject);
-        }
-      }
-    }
-  }
-
-  function renderStringNode$1 (el, context) {
-    var write = context.write;
-    var next = context.next;
-    if (isUndef(el.children) || el.children.length === 0) {
-      write(el.open + (el.close || ''), next);
-    } else {
-      var children = el.children;
-      context.renderStates.push({
-        type: 'Element',
-        children: children,
-        rendered: 0,
-        total: children.length,
-        endTag: el.close
-      });
-      write(el.open, next);
-    }
-  }
-
-  function renderElement (el, isRoot, context) {
-    var write = context.write;
-    var next = context.next;
-
-    if (isTrue(isRoot)) {
-      if (!el.data) { el.data = {}; }
-      if (!el.data.attrs) { el.data.attrs = {}; }
-      el.data.attrs[SSR_ATTR] = 'true';
-    }
-
-    if (el.fnOptions) {
-      registerComponentForCache(el.fnOptions, write);
-    }
-
-    var startTag = renderStartingTag(el, context);
-    var endTag = "</" + (el.tag) + ">";
-    if (context.isUnaryTag(el.tag)) {
-      write(startTag, next);
-    } else if (isUndef(el.children) || el.children.length === 0) {
-      write(startTag + endTag, next);
-    } else {
-      var children = el.children;
-      context.renderStates.push({
-        type: 'Element',
-        children: children,
-        rendered: 0,
-        total: children.length,
-        endTag: endTag
-      });
-      write(startTag, next);
-    }
+          renderNode(childNode, isRoot, context);
+      };
+      var reject = context.done;
+      waitForServerPrefetch(child, resolve, reject);
+  }
+  function renderAsyncComponent(node, isRoot, context) {
+      var factory = node.asyncFactory;
+      var resolve = function (comp) {
+          if (comp.__esModule && comp.default) {
+              comp = comp.default;
+          }
+          var ref = node.asyncMeta;
+          var data = ref.data;
+          var children = ref.children;
+          var tag = ref.tag;
+          var nodeContext = node.asyncMeta.context;
+          var resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+          if (resolvedNode) {
+              if (resolvedNode.componentOptions) {
+                  // normal component
+                  renderComponent(resolvedNode, isRoot, context);
+              }
+              else if (!Array.isArray(resolvedNode)) {
+                  // single return node from functional component
+                  renderNode(resolvedNode, isRoot, context);
+              }
+              else {
+                  // multiple return nodes from functional component
+                  context.renderStates.push({
+                      type: 'Fragment',
+                      children: resolvedNode,
+                      rendered: 0,
+                      total: resolvedNode.length,
+                  });
+                  context.next();
+              }
+          }
+          else {
+              // invalid component, but this does not throw on the client
+              // so render empty comment node
+              context.write("<!---->", context.next);
+          }
+      };
+      if (factory.resolved) {
+          resolve(factory.resolved);
+          return;
+      }
+      var reject = context.done;
+      var res;
+      try {
+          res = factory(resolve, reject);
+      }
+      catch (e) {
+          reject(e);
+      }
+      if (res) {
+          if (typeof res.then === 'function') {
+              res.then(resolve, reject).catch(reject);
+          }
+          else {
+              // new syntax in 2.3
+              var comp = res.component;
+              if (comp && typeof comp.then === 'function') {
+                  comp.then(resolve, reject).catch(reject);
+              }
+          }
+      }
   }
-
-  function hasAncestorData (node) {
-    var parentNode = node.parent;
-    return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
+  function renderStringNode$1(el, context) {
+      var write = context.write;
+      var next = context.next;
+      if (isUndef(el.children) || el.children.length === 0) {
+          write(el.open + (el.close || ''), next);
+      }
+      else {
+          var children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children: children,
+              rendered: 0,
+              total: children.length,
+              endTag: el.close,
+          });
+          write(el.open, next);
+      }
   }
-
-  function getVShowDirectiveInfo (node) {
-    var dir;
-    var tmp;
-
-    while (isDef(node)) {
-      if (node.data && node.data.directives) {
-        tmp = node.data.directives.find(function (dir) { return dir.name === 'show'; });
-        if (tmp) {
-          dir = tmp;
-        }
+  function renderElement(el, isRoot, context) {
+      var write = context.write;
+      var next = context.next;
+      if (isTrue(isRoot)) {
+          if (!el.data)
+              { el.data = {}; }
+          if (!el.data.attrs)
+              { el.data.attrs = {}; }
+          el.data.attrs[SSR_ATTR] = 'true';
+      }
+      if (el.fnOptions) {
+          registerComponentForCache(el.fnOptions, write);
+      }
+      var startTag = renderStartingTag(el, context);
+      var endTag = "</" + (el.tag) + ">";
+      if (context.isUnaryTag(el.tag)) {
+          write(startTag, next);
+      }
+      else if (isUndef(el.children) || el.children.length === 0) {
+          write(startTag + endTag, next);
+      }
+      else {
+          var children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children: children,
+              rendered: 0,
+              total: children.length,
+              endTag: endTag,
+          });
+          write(startTag, next);
       }
-      node = node.parent;
-    }
-    return dir
   }
-
-  function renderStartingTag (node, context) {
-    var markup = "<" + (node.tag);
-    var directives = context.directives;
-    var modules = context.modules;
-
-    // construct synthetic data for module processing
-    // because modules like style also produce code by parent VNode data
-    if (isUndef(node.data) && hasAncestorData(node)) {
-      node.data = {};
-    }
-    if (isDef(node.data)) {
-      // check directives
-      var dirs = node.data.directives;
-      if (dirs) {
-        for (var i = 0; i < dirs.length; i++) {
-          var name = dirs[i].name;
-          if (name !== 'show') {
-            var dirRenderer = resolveAsset(context, 'directives', name);
-            if (dirRenderer) {
-              // directives mutate the node's data
-              // which then gets rendered by modules
-              dirRenderer(node, dirs[i]);
-            }
-          }
-        }
-      }
-
-      // v-show directive needs to be merged from parent to child
-      var vshowDirectiveInfo = getVShowDirectiveInfo(node);
-      if (vshowDirectiveInfo) {
-        directives.show(node, vshowDirectiveInfo);
-      }
-
-      // apply other modules
-      for (var i$1 = 0; i$1 < modules.length; i$1++) {
-        var res = modules[i$1](node);
-        if (res) {
-          markup += res;
-        }
-      }
-    }
-    // attach scoped CSS ID
-    var scopeId;
-    var activeInstance = context.activeInstance;
-    if (isDef(activeInstance) &&
-      activeInstance !== node.context &&
-      isDef(scopeId = activeInstance.$options._scopeId)
-    ) {
-      markup += " " + ((scopeId));
-    }
-    if (isDef(node.fnScopeId)) {
-      markup += " " + (node.fnScopeId);
-    } else {
+  function hasAncestorData(node) {
+      var parentNode = node.parent;
+      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+  }
+  function getVShowDirectiveInfo(node) {
+      var dir;
+      var tmp;
       while (isDef(node)) {
-        if (isDef(scopeId = node.context.$options._scopeId)) {
+          if (node.data && node.data.directives) {
+              tmp = node.data.directives.find(function (dir) { return dir.name === 'show'; });
+              if (tmp) {
+                  dir = tmp;
+              }
+          }
+          node = node.parent;
+      }
+      //@ts-expect-error
+      return dir;
+  }
+  function renderStartingTag(node, context) {
+      var markup = "<" + (node.tag);
+      var directives = context.directives;
+      var modules = context.modules;
+      // construct synthetic data for module processing
+      // because modules like style also produce code by parent VNode data
+      if (isUndef(node.data) && hasAncestorData(node)) {
+          node.data = {};
+      }
+      if (isDef(node.data)) {
+          // check directives
+          var dirs = node.data.directives;
+          if (dirs) {
+              for (var i = 0; i < dirs.length; i++) {
+                  var name = dirs[i].name;
+                  if (name !== 'show') {
+                      var dirRenderer = resolveAsset(context, 'directives', name);
+                      if (dirRenderer) {
+                          // directives mutate the node's data
+                          // which then gets rendered by modules
+                          dirRenderer(node, dirs[i]);
+                      }
+                  }
+              }
+          }
+          // v-show directive needs to be merged from parent to child
+          var vshowDirectiveInfo = getVShowDirectiveInfo(node);
+          if (vshowDirectiveInfo) {
+              directives.show(node, vshowDirectiveInfo);
+          }
+          // apply other modules
+          for (var i$1 = 0; i$1 < modules.length; i$1++) {
+              var res = modules[i$1](node);
+              if (res) {
+                  markup += res;
+              }
+          }
+      }
+      // attach scoped CSS ID
+      var scopeId;
+      var activeInstance = context.activeInstance;
+      if (isDef(activeInstance) &&
+          activeInstance !== node.context &&
+          isDef((scopeId = activeInstance.$options._scopeId))) {
           markup += " " + scopeId;
-        }
-        node = node.parent;
-      }
-    }
-    return markup + '>'
-  }
-
-  function createRenderFunction (
-    modules,
-    directives,
-    isUnaryTag,
-    cache
-  ) {
-    return function render (
-      component,
-      write,
-      userContext,
-      done
-    ) {
-      warned = Object.create(null);
-      var context = new RenderContext({
-        activeInstance: component,
-        userContext: userContext,
-        write: write, done: done, renderNode: renderNode,
-        isUnaryTag: isUnaryTag, modules: modules, directives: directives,
-        cache: cache
-      });
-      installSSRHelpers(component);
-      normalizeRender(component);
-
-      var resolve = function () {
-        renderNode(component._render(), true, context);
+      }
+      if (isDef(node.fnScopeId)) {
+          markup += " " + (node.fnScopeId);
+      }
+      else {
+          while (isDef(node)) {
+              //@ts-expect-error
+              if (isDef((scopeId = node.context.$options._scopeId))) {
+                  markup += " " + scopeId;
+              }
+              node = node.parent;
+          }
+      }
+      return markup + '>';
+  }
+  function createRenderFunction(modules, directives, isUnaryTag, cache) {
+      return function render(component, write, userContext, done) {
+          warned = Object.create(null);
+          var context = new RenderContext({
+              activeInstance: component,
+              userContext: userContext,
+              write: write,
+              done: done,
+              renderNode: renderNode,
+              isUnaryTag: isUnaryTag,
+              modules: modules,
+              directives: directives,
+              cache: cache,
+          });
+          installSSRHelpers(component);
+          normalizeRender(component);
+          var resolve = function () {
+              renderNode(component._render(), true, context);
+          };
+          waitForServerPrefetch(component, resolve, done);
       };
-      waitForServerPrefetch(component, resolve, done);
-    }
   }
 
-  /*  */
-
-
-  function createBasicRenderer (ref) {
-    if ( ref === void 0 ) ref = {};
-    var modules = ref.modules; if ( modules === void 0 ) modules = [];
-    var directives = ref.directives; if ( directives === void 0 ) directives = {};
-    var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = (function () { return false; });
-    var cache = ref.cache;
-
-    var render = createRenderFunction(modules, directives, isUnaryTag, cache);
+  /* @flow */
+  function createBasicRenderer(ref) {
+      if ( ref === void 0 ) ref = {};
+      var modules = ref.modules; if ( modules === void 0 ) modules = [];
+      var directives = ref.directives; if ( directives === void 0 ) directives = {};
+      var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = function () { return false; };
+      var cache = ref.cache;
 
-    return function renderToString (
-      component,
-      context,
-      done
-    ) {
-      if (typeof context === 'function') {
-        done = context;
-        context = {};
-      }
-      var result = '';
-      var write = createWriteFunction(function (text) {
-        result += text;
-        return false
-      }, done);
-      try {
-        render(component, write, context, function () {
-          done(null, result);
-        });
-      } catch (e) {
-        done(e);
-      }
-    }
+      var render = createRenderFunction(modules, directives, isUnaryTag, cache);
+      return function renderToString(component, context, done) {
+          if (typeof context === 'function') {
+              done = context;
+              context = {};
+          }
+          var result = '';
+          var write = createWriteFunction(function (text) {
+              result += text;
+              return false;
+          }, done);
+          try {
+              //@ts-expect-error
+              render(component, write, context, function () {
+                  done(null, result);
+              });
+          }
+          catch (e) {
+              done(e);
+          }
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var entryServerBasicRenderer = createBasicRenderer({
-    modules: modules,
-    directives: directives,
-    isUnaryTag: isUnaryTag,
-    canBeLeftOpenTag: canBeLeftOpenTag
+      // @ts-expect-error
+      modules: modules,
+      directives: directives,
+      isUnaryTag: isUnaryTag,
+      canBeLeftOpenTag: canBeLeftOpenTag,
   });
 
   return entryServerBasicRenderer;
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index fb4caf51154..8f3479b24b0 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -2,189 +2,155 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var he = _interopDefault(require('he'));
-
-/*  */
+var stream = require('stream');
+var he = require('he');
 
+/* @flow */
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Capitalize a string.
  */
 var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -192,1267 +158,1120 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys(modules) {
+    return modules
+        .reduce(function (keys, m) {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
+function looseEqual(a, b) {
+    if (a === b)
+        { return true; }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every(function (e, i) {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every(function (key) {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
     }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (var i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            { return i; }
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
-}
-
-/*  */
-
-var isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-  'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-  'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-  'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-  'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-  'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-  'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-  'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-  'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-  'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-  'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-  'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-  'target,title,usemap,value,width,wrap'
-);
+function once(fn) {
+    var called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
+}
 
+/* @flow */
+var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
 var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
 var isSSRUnsafeAttr = function (name) {
-  return unsafeAttrCharRE.test(name)
+    return unsafeAttrCharRE.test(name);
 };
-
 /* istanbul ignore next */
 var isRenderableAttr = function (name) {
-  return (
-    isAttr(name) ||
-    name.indexOf('data-') === 0 ||
-    name.indexOf('aria-') === 0
-  )
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
 };
-
 var propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
 };
-
 var ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
 };
-
-function escape (s) {
-  return s.replace(/[<>"&]/g, escapeChar)
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
 }
-
-function escapeChar (a) {
-  return ESC[a] || a
+function escapeChar(a) {
+    return ESC[a] || a;
 }
-
 var noUnitNumericStyleProps = {
-  "animation-iteration-count": true,
-  "border-image-outset": true,
-  "border-image-slice": true,
-  "border-image-width": true,
-  "box-flex": true,
-  "box-flex-group": true,
-  "box-ordinal-group": true,
-  "column-count": true,
-  "columns": true,
-  "flex": true,
-  "flex-grow": true,
-  "flex-positive": true,
-  "flex-shrink": true,
-  "flex-negative": true,
-  "flex-order": true,
-  "grid-row": true,
-  "grid-row-end": true,
-  "grid-row-span": true,
-  "grid-row-start": true,
-  "grid-column": true,
-  "grid-column-end": true,
-  "grid-column-span": true,
-  "grid-column-start": true,
-  "font-weight": true,
-  "line-clamp": true,
-  "line-height": true,
-  "opacity": true,
-  "order": true,
-  "orphans": true,
-  "tab-size": true,
-  "widows": true,
-  "z-index": true,
-  "zoom": true,
-  // SVG
-  "fill-opacity": true,
-  "flood-opacity": true,
-  "stop-opacity": true,
-  "stroke-dasharray": true,
-  "stroke-dashoffset": true,
-  "stroke-miterlimit": true,
-  "stroke-opacity": true,
-  "stroke-width": true
+    'animation-iteration-count': true,
+    'border-image-outset': true,
+    'border-image-slice': true,
+    'border-image-width': true,
+    'box-flex': true,
+    'box-flex-group': true,
+    'box-ordinal-group': true,
+    'column-count': true,
+    columns: true,
+    flex: true,
+    'flex-grow': true,
+    'flex-positive': true,
+    'flex-shrink': true,
+    'flex-negative': true,
+    'flex-order': true,
+    'grid-row': true,
+    'grid-row-end': true,
+    'grid-row-span': true,
+    'grid-row-start': true,
+    'grid-column': true,
+    'grid-column-end': true,
+    'grid-column-span': true,
+    'grid-column-start': true,
+    'font-weight': true,
+    'line-clamp': true,
+    'line-height': true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    'tab-size': true,
+    widows: true,
+    'z-index': true,
+    zoom: true,
+    // SVG
+    'fill-opacity': true,
+    'flood-opacity': true,
+    'stop-opacity': true,
+    'stroke-dasharray': true,
+    'stroke-dashoffset': true,
+    'stroke-miterlimit': true,
+    'stroke-opacity': true,
+    'stroke-width': true,
 };
 
-/*  */
-
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
 var convertEnumeratedValue = function (key, value) {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
 var isFalsyAttrValue = function (val) {
-  return val == null || val === false
+    return val == null || val === false;
 };
 
-/*  */
-
-function renderAttrs (node) {
-  var attrs = node.data.attrs;
-  var res = '';
-
-  var opts = node.parent && node.parent.componentOptions;
-  if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-    var parent = node.parent;
-    while (isDef(parent)) {
-      if (isDef(parent.data) && isDef(parent.data.attrs)) {
-        attrs = extend(extend({}, attrs), parent.data.attrs);
-      }
-      parent = parent.parent;
-    }
-  }
-
-  if (isUndef(attrs)) {
-    return res
-  }
-
-  for (var key in attrs) {
-    if (isSSRUnsafeAttr(key)) {
-      continue
-    }
-    if (key === 'style') {
-      // leave it to the style module
-      continue
-    }
-    res += renderAttr(key, attrs[key]);
-  }
-  return res
-}
-
-function renderAttr (key, value) {
-  if (isBooleanAttr(key)) {
-    if (!isFalsyAttrValue(value)) {
-      return (" " + key + "=\"" + key + "\"")
-    }
-  } else if (isEnumeratedAttr(key)) {
-    return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"")
-  } else if (!isFalsyAttrValue(value)) {
-    return (" " + key + "=\"" + (escape(String(value))) + "\"")
-  }
-  return ''
-}
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
+/* @flow */
+function renderAttrs(node) {
+    var attrs = node.data.attrs;
+    var res = '';
+    var opts = node.parent && node.parent.componentOptions;
+    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+        var parent = node.parent;
+        while (isDef(parent)) {
+            // Stop fallthrough in case parent has inheritAttrs option set to false
+            if (parent.componentOptions &&
+                parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                break;
+            }
+            if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                attrs = extend(extend({}, attrs), parent.data.attrs);
+            }
+            parent = parent.parent;
+        }
+    }
+    if (isUndef(attrs)) {
+        return res;
+    }
+    for (var key in attrs) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        if (key === 'style') {
+            // leave it to the style module
+            continue;
+        }
+        res += renderAttr(key, attrs[key]);
+    }
+    return res;
+}
+function renderAttr(key, value) {
+    if (isBooleanAttr(key)) {
+        if (!isFalsyAttrValue(value)) {
+            return (" " + key + "=\"" + key + "\"");
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"");
+    }
+    else if (!isFalsyAttrValue(value)) {
+        return (" " + key + "=\"" + (escape(String(value))) + "\"");
+    }
+    return '';
+}
+
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
 };
 
 var prototypeAccessors = { child: { configurable: true } };
-
 // DEPRECATED: alias for componentInstance for backwards compat.
 /* istanbul ignore next */
 prototypeAccessors.child.get = function () {
-  return this.componentInstance
+    return this.componentInstance;
 };
 
 Object.defineProperties( VNode.prototype, prototypeAccessors );
-
 var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
+    if ( text === void 0 ) text = '';
 
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    var cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
-}
-
-/*  */
-
-function renderDOMProps (node) {
-  var props = node.data.domProps;
-  var res = '';
-
-  var parent = node.parent;
-  while (isDef(parent)) {
-    if (parent.data && parent.data.domProps) {
-      props = extend(extend({}, props), parent.data.domProps);
-    }
-    parent = parent.parent;
-  }
-
-  if (isUndef(props)) {
-    return res
-  }
-
-  var attrs = node.data.attrs;
-  for (var key in props) {
-    if (key === 'innerHTML') {
-      setText(node, props[key], true);
-    } else if (key === 'textContent') {
-      setText(node, props[key], false);
-    } else if (key === 'value' && node.tag === 'textarea') {
-      setText(node, props[key], false);
-    } else {
-      // $flow-disable-line (WTF?)
-      var attr = propsToAttrMap[key] || key.toLowerCase();
-      if (isRenderableAttr(attr) &&
-        // avoid rendering double-bound props/attrs twice
-        !(isDef(attrs) && isDef(attrs[attr]))
-      ) {
-        res += renderAttr(attr, props[key]);
-      }
-    }
-  }
-  return res
-}
-
-function setText (node, text, raw) {
-  var child = new VNode(undefined, undefined, undefined, text);
-  child.raw = raw;
-  node.children = [child];
-}
-
-/*  */
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
+}
+
+/* @flow */
+function renderDOMProps(node) {
+    var props = node.data.domProps;
+    var res = '';
+    var parent = node.parent;
+    while (isDef(parent)) {
+        if (parent.data && parent.data.domProps) {
+            props = extend(extend({}, props), parent.data.domProps);
+        }
+        parent = parent.parent;
+    }
+    if (isUndef(props)) {
+        return res;
+    }
+    var attrs = node.data.attrs;
+    for (var key in props) {
+        if (key === 'innerHTML') {
+            setText(node, props[key], true);
+        }
+        else if (key === 'textContent') {
+            setText(node, props[key], false);
+        }
+        else if (key === 'value' && node.tag === 'textarea') {
+            setText(node, toString(props[key]), false);
+        }
+        else {
+            // $flow-disable-line (WTF?)
+            var attr = propsToAttrMap[key] || key.toLowerCase();
+            if (isRenderableAttr(attr) &&
+                // avoid rendering double-bound props/attrs twice
+                !(isDef(attrs) && isDef(attrs[attr]))) {
+                res += renderAttr(attr, props[key]);
+            }
+        }
+    }
+    return res;
+}
+function setText(node, text, raw) {
+    var child = new VNode(undefined, undefined, undefined, text);
+    child.raw = raw;
+    node.children = [child];
+}
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 var isPhantomJS = UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// @ts-ignore
+var nativeWatch = {}.watch;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function get() {
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/(function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function has (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function add (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function clear () {
+            this.set = Object.create(null);
+        };
 
-    return Set;
-  }());
+        return Set;
+    }());
 }
 
 var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: "development" !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: "development" !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
-}
-
-/*  */
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
+    };
+    var repeat = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
+                    .join('\n'));
+        }
+        else {
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+        }
+    };
+}
 
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
 };
-
 Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
+    this.subs.push(sub);
 };
-
 Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
+    remove(this.subs, sub);
 };
-
 Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
+    if (Dep.target) {
+        Dep.target.addDep(this);
+    }
 };
-
 Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
 };
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
 }
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
+        }
+        else {
+            copyAugment(value, arrayMethods, arrayKeys);
+        }
+        this.observeArray(value);
+    }
+    else {
+        this.walk(value);
+    }
 };
-
 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive$$1(obj, keys[i]);
+    }
 };
-
 /**
  * Observe a list of Array items.
  */
 Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
 };
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (isUndef(target) || isPrimitive(target)) {
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
-}
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
-    }
-  }
-  return res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach(function (hook) {
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1460,594 +1279,525 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && "development" !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (var key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    var props = options.props;
+    if (!props)
+        { return; }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (var key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn("Invalid value for option \"props\": expected an Array or an Object, " +
+            "but got " + (toRawType(props)) + ".", vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    var inject = options.inject;
+    if (!inject)
+        { return; }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (var i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (var key in inject) {
+            var val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+            "but got " + (toRawType(inject)) + ".", vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
-    }
-  }
-}
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function normalizeDirectives(options) {
+    var dirs = options.directives;
+    if (dirs) {
+        for (var key in dirs) {
+            var def$$1 = dirs[key];
+            if (typeof def$$1 === 'function') {
+                dirs[key] = { bind: def$$1, update: def$$1 };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            "but got " + (toRawType(value)) + ".", vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        var strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        { return assets[id]; }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        { return assets[camelizedId]; }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        { return assets[PascalCaseId]; }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+/* @flow */
+function validateProp(key, propOptions, propsData, vm) {
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            var stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        var prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
-}
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        var t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid: valid,
+        expectedType: expectedType,
+    };
+}
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
-}
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
-}
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
-    }
-  }
-  return -1
-}
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  var expectedValue = styleValue(value, expectedType);
-  var receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += " with value " + expectedValue;
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + receivedValue + ".";
-  }
-  return message
-}
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
-}
-
-function isExplicable (value) {
-  var explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
-}
-
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
-}
-
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
-            }
-          }
+function getType(fn) {
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
         }
-      }
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
+    return -1;
 }
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += " with value " + (styleValue(value, expectedType));
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += "with value " + (styleValue(value, receivedType)) + ".";
     }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
+    return message;
 }
-
-function globalHandleError (err, vm, info) {
-  logError(err, vm, info);
+function styleValue(value, type) {
+    if (type === 'String') {
+        return ("\"" + value + "\"");
+    }
+    else if (type === 'Number') {
+        return ("" + (Number(value)));
+    }
+    else {
+        return ("" + value);
+    }
 }
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+}
+function isBoolean() {
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-function logError (err, vm, info) {
-  {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
-/*  */
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            var cur = vm;
+            while ((cur = cur.$parent)) {
+                var hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (var i = 0; i < hooks.length; i++) {
+                        try {
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                { return; }
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    var res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
+}
 
+/* @flow */
 var callbacks = [];
-
-function flushCallbacks () {
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -2055,1068 +1805,937 @@ function flushCallbacks () {
 // completely stops working after triggering a few times... so, if native
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/*  */
-
-/*  */
-
-function genClassForVnode (vnode) {
-  var data = vnode.data;
-  var parentNode = vnode;
-  var childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
-    }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
-    }
-  }
-  return renderClass(data.staticClass, data.class)
-}
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
-}
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
-}
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
-}
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
-}
-
-function stringifyArray (value) {
-  var res = '';
-  var stringified;
-  for (var i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) { res += ' '; }
-      res += stringified;
-    }
-  }
-  return res
-}
-
-function stringifyObject (value) {
-  var res = '';
-  for (var key in value) {
-    if (value[key]) {
-      if (res) { res += ' '; }
-      res += key;
-    }
-  }
-  return res
-}
-
-/*  */
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
+if (typeof Promise !== 'undefined' && isNative(Promise)) ;
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+
+/* @flow */
 
+/* @flow */
+function genClassForVnode(vnode) {
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                { res += ' '; }
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    var res = '';
+    for (var key in value) {
+        if (value[key]) {
+            if (res)
+                { res += ' '; }
+            res += key;
+        }
+    }
+    return res;
+}
+
+/* @flow */
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isPreTag = function (tag) { return tag === 'pre'; };
-
 var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
+/* @flow */
 
-/*  */
-
-function renderClass$1 (node) {
-  var classList = genClassForVnode(node);
-  if (classList !== '') {
-    return (" class=\"" + (escape(classList)) + "\"")
-  }
+/* @flow */
+function renderClass$1(node) {
+    var classList = genClassForVnode(node);
+    if (classList !== '') {
+        return (" class=\"" + (escape(classList)) + "\"");
+    }
 }
 
-/*  */
-
+/* @flow */
 var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  var style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    var style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  var res = {};
-  var styleData;
-
-  if (checkChild) {
-    var childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    var res = {};
+    var styleData;
+    if (checkChild) {
+        var childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  var parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    var parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
-function genStyle (style) {
-  var styleText = '';
-  for (var key in style) {
-    var value = style[key];
-    var hyphenatedKey = hyphenate(key);
-    if (Array.isArray(value)) {
-      for (var i = 0, len = value.length; i < len; i++) {
-        styleText += normalizeValue(hyphenatedKey, value[i]);
-      }
-    } else {
-      styleText += normalizeValue(hyphenatedKey, value);
+/* @flow */
+function genStyle(style) {
+    var styleText = '';
+    for (var key in style) {
+        var value = style[key];
+        var hyphenatedKey = hyphenate(key);
+        if (Array.isArray(value)) {
+            for (var i = 0, len = value.length; i < len; i++) {
+                styleText += normalizeValue(hyphenatedKey, value[i]);
+            }
+        }
+        else {
+            styleText += normalizeValue(hyphenatedKey, value);
+        }
     }
-  }
-  return styleText
+    return styleText;
 }
-
 function normalizeValue(key, value) {
-  if (
-    typeof value === 'string' ||
-    (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-    value === 0
-  ) {
-    return (key + ":" + value + ";")
-  } else {
-    // invalid values
-    return ""
-  }
+    if (typeof value === 'string' ||
+        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+        value === 0) {
+        return (key + ":" + value + ";");
+    }
+    else {
+        // invalid values
+        return "";
+    }
 }
-
-function renderStyle (vnode) {
-  var styleText = genStyle(getStyle(vnode, false));
-  if (styleText !== '') {
-    return (" style=" + (JSON.stringify(escape(styleText))))
-  }
+function renderStyle(vnode) {
+    var styleText = genStyle(getStyle(vnode, false));
+    if (styleText !== '') {
+        return (" style=" + (JSON.stringify(escape(styleText))));
+    }
 }
 
-var modules = [
-  renderAttrs,
-  renderDOMProps,
-  renderClass$1,
-  renderStyle
-];
-
-/*  */
+var modules = [renderAttrs, renderDOMProps, renderClass$1, renderStyle];
 
-function show (node, dir) {
-  if (!dir.value) {
-    var style = node.data.style || (node.data.style = {});
-    if (Array.isArray(style)) {
-      style.push({ display: 'none' });
-    } else {
-      style.display = 'none';
+/* @flow */
+function show(node, dir) {
+    if (!dir.value) {
+        var style = node.data.style || (node.data.style = {});
+        if (Array.isArray(style)) {
+            style.push({ display: 'none' });
+        }
+        else {
+            style.display = 'none';
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
-function model (node, dir) {
-  if (!node.children) { return }
-  var value = dir.value;
-  var isMultiple = node.data.attrs && node.data.attrs.multiple;
-  for (var i = 0, l = node.children.length; i < l; i++) {
-    var option = node.children[i];
-    if (option.tag === 'option') {
-      if (isMultiple) {
-        var selected =
-          Array.isArray(value) &&
-          (looseIndexOf(value, getValue(option)) > -1);
-        if (selected) {
-          setSelected(option);
-        }
-      } else {
-        if (looseEqual(value, getValue(option))) {
-          setSelected(option);
-          return
+function model(node, dir) {
+    if (!node.children)
+        { return; }
+    var value = dir.value;
+    var isMultiple = node.data.attrs && node.data.attrs.multiple;
+    for (var i = 0, l = node.children.length; i < l; i++) {
+        var option = node.children[i];
+        if (option.tag === 'option') {
+            if (isMultiple) {
+                var selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                if (selected) {
+                    setSelected(option);
+                }
+            }
+            else {
+                if (looseEqual(value, getValue(option))) {
+                    setSelected(option);
+                    return;
+                }
+            }
         }
-      }
     }
-  }
 }
-
-function getValue (option) {
-  var data = option.data || {};
-  return (
-    (data.attrs && data.attrs.value) ||
-    (data.domProps && data.domProps.value) ||
-    (option.children && option.children[0] && option.children[0].text)
-  )
+function getValue(option) {
+    var data = option.data || {};
+    return ((data.attrs && data.attrs.value) ||
+        (data.domProps && data.domProps.value) ||
+        (option.children && option.children[0] && option.children[0].text));
 }
-
-function setSelected (option) {
-  var data = option.data || (option.data = {});
-  var attrs = data.attrs || (data.attrs = {});
-  attrs.selected = '';
+function setSelected(option) {
+    var data = option.data || (option.data = {});
+    var attrs = data.attrs || (data.attrs = {});
+    attrs.selected = '';
 }
 
 var baseDirectives = {
-  show: show,
-  model: model
+    show: show,
+    model: model,
 };
 
-/*  */
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
-
+/* @flow */
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
-
-/*  */
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
+/* @flow */
 var MAX_STACK_DEPTH = 800;
 var noop$1 = function (_) { return _; };
-
 var defer = typeof process !== 'undefined' && process.nextTick
-  ? process.nextTick
-  : typeof Promise !== 'undefined'
-    ? function (fn) { return Promise.resolve().then(fn); }
-    : typeof setTimeout !== 'undefined'
-      ? setTimeout
-      : noop$1;
-
+    ? process.nextTick
+    : typeof Promise !== 'undefined'
+        ? function (fn) { return Promise.resolve().then(fn); }
+        : typeof setTimeout !== 'undefined'
+            ? setTimeout
+            : noop$1;
 if (defer === noop$1) {
-  throw new Error(
-    'Your JavaScript runtime does not support any asynchronous primitives ' +
-    'that are required by vue-server-renderer. Please use a polyfill for ' +
-    'either Promise or setTimeout.'
-  )
-}
-
-function createWriteFunction (
-  write,
-  onError
-) {
-  var stackDepth = 0;
-  var cachedWrite = function (text, next) {
-    if (text && cachedWrite.caching) {
-      cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-    }
-    var waitForNext = write(text, next);
-    if (waitForNext !== true) {
-      if (stackDepth >= MAX_STACK_DEPTH) {
-        defer(function () {
-          try { next(); } catch (e) {
-            onError(e);
-          }
+    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+        'that are required by vue-server-renderer. Please use a polyfill for ' +
+        'either Promise or setTimeout.');
+}
+function createWriteFunction(write, onError) {
+    var stackDepth = 0;
+    var cachedWrite = function (text, next) {
+        if (text && cachedWrite.caching) {
+            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+        }
+        var waitForNext = write(text, next);
+        if (waitForNext !== true) {
+            if (stackDepth >= MAX_STACK_DEPTH) {
+                defer(function () {
+                    try {
+                        next();
+                    }
+                    catch (e) {
+                        onError(e);
+                    }
+                });
+            }
+            else {
+                stackDepth++;
+                next();
+                stackDepth--;
+            }
+        }
+    };
+    cachedWrite.caching = false;
+    cachedWrite.cacheBuffer = [];
+    cachedWrite.componentBuffer = [];
+    return cachedWrite;
+}
+
+/* @flow */
+var RenderStream = /*@__PURE__*/(function (Readable) {
+    function RenderStream(render) {
+        var this$1 = this;
+
+        Readable.call(this);
+        this.buffer = '';
+        //@ts-expect-error
+        this.render = render;
+        this.expectedSize = 0;
+        this.write = createWriteFunction(function (text, next) {
+            var n = this$1.expectedSize;
+            this$1.buffer += text;
+            if (this$1.buffer.length >= n) {
+                this$1.next = next;
+                this$1.pushBySize(n);
+                return true; // we will decide when to call next
+            }
+            return false;
+        }, function (err) {
+            this$1.emit('error', err);
         });
-      } else {
-        stackDepth++;
-        next();
-        stackDepth--;
-      }
+        this.end = function () {
+            this$1.emit('beforeEnd');
+            // the rendering is finished; we should push out the last of the buffer.
+            this$1.done = true;
+            this$1.push(this$1.buffer);
+        };
     }
-  };
-  cachedWrite.caching = false;
-  cachedWrite.cacheBuffer = [];
-  cachedWrite.componentBuffer = [];
-  return cachedWrite
-}
-
-/*  */
-
-/**
- * Original RenderStream implementation by Sasha Aickin (@aickin)
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Modified by Evan You (@yyx990803)
- */
-
-var stream = require('stream');
 
-var RenderStream = /*@__PURE__*/(function (superclass) {
-  function RenderStream (render) {
-    var this$1 = this;
-
-    superclass.call(this);
-    this.buffer = '';
-    this.render = render;
-    this.expectedSize = 0;
-
-    this.write = createWriteFunction(function (text, next) {
-      var n = this$1.expectedSize;
-      this$1.buffer += text;
-      if (this$1.buffer.length >= n) {
-        this$1.next = next;
-        this$1.pushBySize(n);
-        return true // we will decide when to call next
-      }
-      return false
-    }, function (err) {
-      this$1.emit('error', err);
-    });
-
-    this.end = function () {
-      this$1.emit('beforeEnd');
-      // the rendering is finished; we should push out the last of the buffer.
-      this$1.done = true;
-      this$1.push(this$1.buffer);
+    if ( Readable ) RenderStream.__proto__ = Readable;
+    RenderStream.prototype = Object.create( Readable && Readable.prototype );
+    RenderStream.prototype.constructor = RenderStream;
+    RenderStream.prototype.pushBySize = function pushBySize (n) {
+        var bufferToPush = this.buffer.substring(0, n);
+        this.buffer = this.buffer.substring(n);
+        this.push(bufferToPush);
+    };
+    RenderStream.prototype.tryRender = function tryRender () {
+        try {
+            this.render(this.write, this.end);
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    };
+    RenderStream.prototype.tryNext = function tryNext () {
+        try {
+            this.next();
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    };
+    RenderStream.prototype._read = function _read (n) {
+        this.expectedSize = n;
+        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
+        // which means we will need to go through multiple read calls to drain it
+        // down to < n.
+        if (isTrue(this.done)) {
+            this.push(null);
+            return;
+        }
+        if (this.buffer.length >= n) {
+            this.pushBySize(n);
+            return;
+        }
+        if (isUndef(this.next)) {
+            // start the rendering chain.
+            this.tryRender();
+        }
+        else {
+            // continue with the rendering.
+            this.tryNext();
+        }
     };
-  }
-
-  if ( superclass ) RenderStream.__proto__ = superclass;
-  RenderStream.prototype = Object.create( superclass && superclass.prototype );
-  RenderStream.prototype.constructor = RenderStream;
-
-  RenderStream.prototype.pushBySize = function pushBySize (n) {
-    var bufferToPush = this.buffer.substring(0, n);
-    this.buffer = this.buffer.substring(n);
-    this.push(bufferToPush);
-  };
-
-  RenderStream.prototype.tryRender = function tryRender () {
-    try {
-      this.render(this.write, this.end);
-    } catch (e) {
-      this.emit('error', e);
-    }
-  };
 
-  RenderStream.prototype.tryNext = function tryNext () {
-    try {
-      this.next();
-    } catch (e) {
-      this.emit('error', e);
-    }
-  };
-
-  RenderStream.prototype._read = function _read (n) {
-    this.expectedSize = n;
-    // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-    // which means we will need to go through multiple read calls to drain it
-    // down to < n.
-    if (isTrue(this.done)) {
-      this.push(null);
-      return
-    }
-    if (this.buffer.length >= n) {
-      this.pushBySize(n);
-      return
-    }
-    if (isUndef(this.next)) {
-      // start the rendering chain.
-      this.tryRender();
-    } else {
-      // continue with the rendering.
-      this.tryNext();
-    }
-  };
-
-  return RenderStream;
+    return RenderStream;
 }(stream.Readable));
 
-/*  */
-
-
-
-var RenderContext = function RenderContext (options) {
-  this.userContext = options.userContext;
-  this.activeInstance = options.activeInstance;
-  this.renderStates = [];
-
-  this.write = options.write;
-  this.done = options.done;
-  this.renderNode = options.renderNode;
-
-  this.isUnaryTag = options.isUnaryTag;
-  this.modules = options.modules;
-  this.directives = options.directives;
-
-  var cache = options.cache;
-  if (cache && (!cache.get || !cache.set)) {
-    throw new Error('renderer cache must implement at least get & set.')
-  }
-  this.cache = cache;
-  this.get = cache && normalizeAsync(cache, 'get');
-  this.has = cache && normalizeAsync(cache, 'has');
-
-  this.next = this.next.bind(this);
+/* @flow */
+var RenderContext = function RenderContext(options) {
+    this.userContext = options.userContext;
+    this.activeInstance = options.activeInstance;
+    this.renderStates = [];
+    this.write = options.write;
+    this.done = options.done;
+    this.renderNode = options.renderNode;
+    this.isUnaryTag = options.isUnaryTag;
+    this.modules = options.modules;
+    this.directives = options.directives;
+    var cache = options.cache;
+    if (cache && (!cache.get || !cache.set)) {
+        throw new Error('renderer cache must implement at least get & set.');
+    }
+    this.cache = cache;
+    this.get = cache && normalizeAsync(cache, 'get');
+    this.has = cache && normalizeAsync(cache, 'has');
+    //@ts-expect-error
+    this.next = this.next.bind(this);
 };
-
+//@ts-expect-error
 RenderContext.prototype.next = function next () {
-  // eslint-disable-next-line
-  while (true) {
-    var lastState = this.renderStates[this.renderStates.length - 1];
-    if (isUndef(lastState)) {
-      return this.done()
-    }
-    /* eslint-disable no-case-declarations */
-    switch (lastState.type) {
-      case 'Element':
-      case 'Fragment':
-        var children = lastState.children;
-      var total = lastState.total;
-        var rendered = lastState.rendered++;
-        if (rendered < total) {
-          return this.renderNode(children[rendered], false, this)
-        } else {
-          this.renderStates.pop();
-          if (lastState.type === 'Element') {
-            return this.write(lastState.endTag, this.next)
-          }
-        }
-        break
-      case 'Component':
-        this.renderStates.pop();
-        this.activeInstance = lastState.prevActive;
-        break
-      case 'ComponentWithCache':
-        this.renderStates.pop();
-        var buffer = lastState.buffer;
-      var bufferIndex = lastState.bufferIndex;
-      var componentBuffer = lastState.componentBuffer;
-      var key = lastState.key;
-        var result = {
-          html: buffer[bufferIndex],
-          components: componentBuffer[bufferIndex]
-        };
-        this.cache.set(key, result);
-        if (bufferIndex === 0) {
-          // this is a top-level cached component,
-          // exit caching mode.
-          this.write.caching = false;
-        } else {
-          // parent component is also being cached,
-          // merge self into parent's result
-          buffer[bufferIndex - 1] += result.html;
-          var prev = componentBuffer[bufferIndex - 1];
-          result.components.forEach(function (c) { return prev.add(c); });
-        }
-        buffer.length = bufferIndex;
-        componentBuffer.length = bufferIndex;
-        break
-    }
-  }
-};
-
-function normalizeAsync (cache, method) {
-  var fn = cache[method];
-  if (isUndef(fn)) {
-    return
-  } else if (fn.length > 1) {
-    return function (key, cb) { return fn.call(cache, key, cb); }
-  } else {
-    return function (key, cb) { return cb(fn.call(cache, key)); }
-  }
+    // eslint-disable-next-line
+    while (true) {
+        var lastState = this.renderStates[this.renderStates.length - 1];
+        if (isUndef(lastState)) {
+            return this.done();
+        }
+        /* eslint-disable no-case-declarations */
+        switch (lastState.type) {
+            case 'Element':
+            case 'Fragment':
+                var children = lastState.children;
+            var total = lastState.total;
+                var rendered = lastState.rendered++;
+                if (rendered < total) {
+                    return this.renderNode(children[rendered], false, this);
+                }
+                else {
+                    this.renderStates.pop();
+                    if (lastState.type === 'Element') {
+                        return this.write(lastState.endTag, this.next);
+                    }
+                }
+                break;
+            case 'Component':
+                this.renderStates.pop();
+                this.activeInstance = lastState.prevActive;
+                break;
+            case 'ComponentWithCache':
+                this.renderStates.pop();
+                var buffer = lastState.buffer;
+            var bufferIndex = lastState.bufferIndex;
+            var componentBuffer = lastState.componentBuffer;
+            var key = lastState.key;
+                var result = {
+                    html: buffer[bufferIndex],
+                    components: componentBuffer[bufferIndex],
+                };
+                this.cache.set(key, result);
+                if (bufferIndex === 0) {
+                    // this is a top-level cached component,
+                    // exit caching mode.
+                    //@ts-expect-error
+                    this.write.caching = false;
+                }
+                else {
+                    // parent component is also being cached,
+                    // merge self into parent's result
+                    buffer[bufferIndex - 1] += result.html;
+                    var prev = componentBuffer[bufferIndex - 1];
+                    result.components.forEach(function (c) { return prev.add(c); });
+                }
+                buffer.length = bufferIndex;
+                componentBuffer.length = bufferIndex;
+                break;
+        }
+    }
+};
+function normalizeAsync(cache, method) {
+    var fn = cache[method];
+    if (isUndef(fn)) {
+        return;
+    }
+    else if (fn.length > 1) {
+        return function (key, cb) { return fn.call(cache, key, cb); };
+    }
+    else {
+        return function (key, cb) { return cb(fn.call(cache, key)); };
+    }
 }
 
-/*  */
-
+/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function parseFilters(exp) {
+    var inSingle = false;
+    var inDouble = false;
+    var inTemplateString = false;
+    var inRegex = false;
+    var curly = 0;
+    var square = 0;
+    var paren = 0;
+    var lastFilterIndex = 0;
+    var c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                { inSingle = false; }
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                { inDouble = false; }
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                { inTemplateString = false; }
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                { inRegex = false; }
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                var j = i - 1;
+                var p = (void 0);
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        { break; }
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
-    }
-  }
-
-  return expression
-}
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
-}
-
-/*  */
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    var i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return ("_f(\"" + filter + "\")(" + exp + ")");
+    }
+    else {
+        var name = filter.slice(0, i);
+        var args = filter.slice(i + 1);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+    }
+}
 
+/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
 var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    var tokens = [];
+    var rawTokens = [];
+    var lastIndex = (tagRE.lastIndex = 0);
+    var match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        var exp = parseFilters(match[1].trim());
+        tokens.push(("_s(" + exp + ")"));
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
+}
 
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
-
-/*  */
-
-
-
+/* @flow */
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    var attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
-}
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-}
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    var events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    var handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        var staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
+function getAndRemoveAttr(el, name, removeFromMap) {
+    var val;
+    if ((val = el.attrsMap[name]) != null) {
+        var list = el.attrsList;
+        for (var i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
     var list = el.attrsList;
     for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
-    }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
-    }
-  }
-}
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
-    }
-    if (range.end != null) {
-      item.end = range.end;
-    }
-  }
-  return item
-}
-
-/*  */
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  if (staticClass) {
-    var res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        "class=\"" + staticClass + "\": " +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
-}
-
-function genData (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
+        var attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
+/* @flow */
+function transformNode(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        var res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn("class=\"" + staticClass + "\": " +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass);
+    }
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData(el) {
+    var data = '';
+    if (el.staticClass) {
+        data += "staticClass:" + (el.staticClass) + ",";
+    }
+    if (el.classBinding) {
+        data += "class:" + (el.classBinding) + ",";
+    }
+    return data;
+}
 var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData
+    staticKeys: ['staticClass'],
+    transformNode: transformNode,
+    genData: genData,
 };
 
-/*  */
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    {
-      var res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          "style=\"" + staticStyle + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
+/* @flow */
+function transformNode$1(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            var res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn("style=\"" + staticStyle + "\": " +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
     }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
 }
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:(" + (el.styleBinding) + "),";
-  }
-  return data
+function genData$1(el) {
+    var data = '';
+    if (el.staticStyle) {
+        data += "staticStyle:" + (el.staticStyle) + ",";
+    }
+    if (el.styleBinding) {
+        data += "style:(" + (el.styleBinding) + "),";
+    }
+    return data;
 }
-
 var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode$1,
+    genData: genData$1,
 };
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
 var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -3126,334 +2745,309 @@ var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
 var conditionalComment = /^<!\[/;
-
 // Special Elements (can contain anything)
 var isPlainTextElement = makeMap('script,style,textarea', true);
 var reCache = {};
-
 var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
 var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
 var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+function decodeAttr(value, shouldDecodeNewlines) {
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, function (match) { return decodingMap[match]; });
+}
+function parseHTML(html, options) {
+    var stack = [];
+    var expectHTML = options.expectHTML;
+    var isUnaryTag$$1 = options.isUnaryTag || no;
+    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var index = 0;
+    var last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            var textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    var commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    var conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                var doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                var endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    var curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                var startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            var text = (void 0), rest = (void 0), next = (void 0);
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        { break; }
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        var start = html.match(startTagOpen);
+        if (start) {
+            var match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            var end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        var tagName = match.tagName;
+        var unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var l = match.attrs.length;
+        var attrs = new Array(l);
+        for (var i = 0; i < l; i++) {
+            var args = match.attrs[i];
+            var value = args[3] || args[4] || args[5] || '';
+            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        var pos, lowerCasedTagName;
+        if (start == null)
+            { start = index; }
+        if (end == null)
+            { end = index; }
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (var i = stack.length - 1; i >= pos; i--) {
+                if (i > pos || !tagName &&
+                    options.warn) {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
+}
 
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-            }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
-        }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
-        }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
-        }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (!stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
-    }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
-    }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
-    }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (i > pos || !tagName &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
-}
-
-/*  */
-
+/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
+    var baseValueExpression = '$$v';
+    var valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            "(typeof " + baseValueExpression + " === 'string'" +
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: ("(" + value + ")"),
+        expression: JSON.stringify(value),
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    var res = parseModel(value);
+    if (res.key === null) {
+        return (value + "=" + assignment);
+    }
+    else {
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -3468,115 +3062,98 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
 var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.');
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  str = val;
-  index = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index)
+function next() {
+    return str.charCodeAt(++index);
 }
-
-function eof () {
-  return index >= len
+function eof() {
+    return index >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index;
-      break
+function parseBracket(chr) {
+    var inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            { inBracket++; }
+        if (chr === 0x5d)
+            { inBracket--; }
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
     }
-  }
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    var stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
 var stripParensRE = /^\(|\)$/g;
 var dynamicArgRE = /^\[.*\]$/;
-
 var argRE = /:(.*)$/;
 var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
 var slotRE = /^v-slot(:|$)|^#/;
-
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /\s+/g;
-
+var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-
 var decodeHTMLCached = cached(he.decode);
-
 var emptySlotScopeToken = "_empty_";
-
 // configurable state
 var warn$1;
 var delimiters;
@@ -3587,4158 +3164,3550 @@ var platformIsPreTag;
 var platformMustUseProp;
 var platformGetTagNamespace;
 var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag: tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent: parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$1 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$1(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    var isReservedTag = options.isReservedTag || no;
+    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    var stack = [];
+    var preserveWhitespace = options.preserveWhitespace !== false;
+    var whitespaceOption = options.whitespace;
+    var root;
+    var currentParent;
+    var inVPre = false;
+    var inPre = false;
+    var warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
-    }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
-    }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
-    }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$1,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$1(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        warn$1(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce("Component template should contain exactly one root element. " +
+                    "If you are using v-if on multiple elements, " +
+                    "use v-else-if to chain them instead.", { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
         if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        {
-          checkRootConstraints(root);
+            inVPre = false;
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
-        {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
-        }
-        currentParent.children.push(child);
-      }
-    }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    {
-      if (el.tag === 'template') {
-        warn$1(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$1(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (var i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
         }
-      }
-    }
-    el.key = exp;
-  }
-}
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
-}
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else {
-      warn$1(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-}
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
-}
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
-    }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
     }
-  }
-}
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else {
-    warn$1(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
-}
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (children[i].text !== ' ') {
-        warn$1(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            var lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
     }
-  }
-}
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
-}
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
-}
-
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (slotScope) {
-      warn$1(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (el.attrsMap['v-for']) {
-      warn$1(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
-    if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        {
-          if (el.slotTarget || el.slotScope) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$1(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                'contain multiple nodes.', { start: el.start });
         }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start: function start(tag, attrs, unary, start$1, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            var element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start$1;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach(function (attr) {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
+                            "spaces, quotes, <, >, / or =.", {
+                            start: attr.start + attr.name.indexOf("["),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        "<" + tag + ">" +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (var i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end: function end(tag, start, end$1) {
+            var element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end$1;
+            }
+            closeElement(element);
+        },
+        chars: function chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                            start: start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            var children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                var res;
+                var child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text: text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text: text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment: function comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                var child = {
+                    type: 3,
+                    text: text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    var list = el.attrsList;
+    var len = list.length;
+    if (len) {
+        var attrs = (el.attrs = new Array(len));
+        for (var i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (var i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    var exp = getBindingAttr(el, 'key');
+    if (exp) {
         {
-          if (!maybeComponent(el)) {
-            warn$1(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$1(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
+            if (el.tag === 'template') {
+                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                var iterator = el.iterator2 || el.iterator1;
+                var parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1("Do not use v-for index as key on <transition-group> children, " +
+                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    var ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    var exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        var res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    var inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        { return; }
+    var res = {};
+    res.for = inMatch[2].trim();
+    var alias = inMatch[1].trim().replace(stripParensRE, '');
+    var iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    var exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
         });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
-    }
-  }
-}
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else {
-      warn$1(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    var prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    var i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                    "will be ignored.", children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    var once$$1 = getAndRemoveAttr(el, 'v-once');
+    if (once$$1 != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    var slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
+                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                "can also be used on plain elements in addition to <template> to " +
+                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                "(v-for takes higher priority). Use a wrapper <template> for the " +
+                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    var slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1("<template v-slot> can only appear at the root level inside " +
+                            "the receiving component", el);
+                    }
+                }
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding$1);
+                    }
+                }
+                // add the component's children to its default slot
+                var slots = el.scopedSlots || (el.scopedSlots = {});
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    var name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn$1("v-slot shorthand syntax requires a slot name.", binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: ("\"" + name + "\""), dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (el.key) {
-      warn$1(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
-}
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
-}
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          value.trim().length === 0
-        ) {
-          warn$1(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i],
-                true // dynamic
-              );
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn$1(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
-}
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent;
-  }
-  return false
-}
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
+                "and can possibly expand into multiple elements. " +
+                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+function processComponent(el) {
+    var binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
     }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
 }
-
+function processAttrs(el) {
+    var list = el.attrsList;
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            { name = 'innerHTML'; }
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, "$event");
+                        if (!isDynamic) {
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                var argMatch = name.match(argRE);
+                var arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                var res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(name + "=\"" + value + "\": " +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    var parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    var match = name.match(modifierRE);
+    if (match) {
+        var ret = {};
+        match.forEach(function (m) {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    var map = {};
+    for (var i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
 var ieNSBug = /^xmlns:NS\d+/;
 var ieNSPrefix = /^NS\d+:/;
-
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap;
-    if (!map['v-model']) {
-      return
-    }
-
-    var typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
-    }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = "(" + (map['v-bind']) + ").type";
-    }
-
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      var branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      var branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
-    }
-  }
-}
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function guardIESVGBug(attrs) {
+    var res = [];
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    var _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                "You are binding v-model directly to a v-for iteration alias. " +
+                "This will not be able to modify the v-for source array because " +
+                "writing to the alias is like modifying a function local variable. " +
+                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
+/* @flow */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        var map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        var typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = "(" + (map['v-bind']) + ").type";
+        }
+        if (typeBinding) {
+            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            var branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            var branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            var branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
 var model$1 = {
-  preTransformNode: preTransformNode
+    preTransformNode: preTransformNode,
 };
 
-var modules$1 = [
-  klass,
-  style,
-  model$1
-];
-
-/*  */
+var modules$1 = [klass, style, model$1];
 
+/* @flow */
 var warn$2;
-
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
-
-function model$2 (
-  el,
-  dir,
-  _warn
-) {
-  warn$2 = _warn;
-  var value = dir.value;
-  var modifiers = dir.modifiers;
-  var tag = el.tag;
-  var type = el.attrsMap.type;
-
-  {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$2(
-        "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-        "File inputs are read only. Use a v-on:change listener instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    "Array.isArray(" + value + ")" +
-    "?_i(" + value + "," + valueBinding + ")>-1" + (
-      trueValueBinding === 'true'
-        ? (":(" + value + ")")
-        : (":_q(" + value + "," + trueValueBinding + ")")
-    )
-  );
-  addHandler(el, 'change',
-    "var $$a=" + value + "," +
+function model$2(el, dir, _warn) {
+    warn$2 = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
+        (trueValueBinding === 'true'
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
+    addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
         "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-    'if(Array.isArray($$a)){' +
-      "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-      "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-      "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-    "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-  addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var selectedVal = "Array.prototype.filter" +
-    ".call($event.target.options,function(o){return o.selected})" +
-    ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-    "return " + (number ? '_n(val)' : 'val') + "})";
-
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  var code = "var $$selectedVal = " + selectedVal + ";";
-  code = code + " " + (genAssignmentCode(value, assignment));
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  {
-    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value$1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$2(
-        binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var number = ref.number;
-  var trim = ref.trim;
-  var needCompositionGuard = !lazy && type !== 'range';
-  var event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  var valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = "$event.target.value.trim()";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = "if($event.target.composing)return;" + code;
-  }
-
-  addProp(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
-}
-
-/*  */
-
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-  }
-}
-
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-  }
+        'if(Array.isArray($$a)){' +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        '$$i=_i($$a,$$v);' +
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        "return " + (number ? '_n(val)' : 'val') + "})";
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + (genAssignmentCode(value, assignment));
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value$1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', ("(" + value + ")"));
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
+
+/* @flow */
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+    }
+}
+
+/* @flow */
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
 var directives = {
-  model: model$2,
-  text: text,
-  html: html
+    model: model$2,
+    text: text,
+    html: html,
 };
 
-/*  */
-
+/* @flow */
 var baseOptions = {
-  expectHTML: true,
-  modules: modules$1,
-  directives: directives,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys(modules$1)
+    expectHTML: true,
+    modules: modules$1,
+    directives: directives,
+    isPreTag: isPreTag,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
+    // @ts-ignore
+    staticKeys: genStaticKeys(modules$1),
 };
 
-/*  */
-
+/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
 // KeyboardEvent.keyCode aliases
 var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
 var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
 var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
 var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard("$event.target !== $event.currentTarget"),
+    ctrl: genGuard("!$event.ctrlKey"),
+    shift: genGuard("!$event.shiftKey"),
+    alt: genGuard("!$event.altKey"),
+    meta: genGuard("!$event.metaKey"),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2"),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
-}
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys);
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
-    }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + "($event)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ")($event)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    return ("function($event){" + code + handlerCode + "}")
-  }
-}
-
-function genKeyFilter (keys) {
-  return (
+function genHandlers(events, isNative) {
+    var prefix = isNative ? 'nativeOn:' : 'on:';
+    var staticHandlers = "";
+    var dynamicHandlers = "";
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
+        }
+        else {
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+        }
+    }
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    if (dynamicHandlers) {
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+    }
+    var isMethodPath = simplePathRE.test(handler.value);
+    var isFunctionExpression = fnExpRE.test(handler.value);
+    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+    }
+    else {
+        var code = '';
+        var genModifierCode = '';
+        var keys = [];
+        for (var key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                var modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        var handlerCode = isMethodPath
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            : isFunctionExpression
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                : isFunctionInvocation
+                    ? ("return " + (handler.value))
+                    : handler.value;
+        return ("function($event){" + code + handlerCode + "}");
+    }
+}
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    var keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return ("$event.keyCode!==" + keyVal);
+    }
+    var keyCode = keyCodes[key];
+    var keyName = keyNames[key];
+    return ("_k($event.keyCode," +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
+        "$event.key," +
+        "" + (JSON.stringify(keyName)) +
+        ")");
 }
 
-/*  */
-
-function on (el, dir) {
-  if (dir.modifiers) {
-    warn("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+/* @flow */
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn("v-on without argument does not support modifiers.");
+    }
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+/* @flow */
+function bind$1(el, dir) {
+    el.wrapData = function (code) {
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+    };
 }
 
-/*  */
-
+/* @flow */
 var baseDirectives$1 = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
+    on: on,
+    bind: bind$1,
+    cloak: noop,
 };
 
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives$1), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
+/* @flow */
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives$1), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
 };
-
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function generate(ast, options) {
+    var state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    var code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: ("with(this){return " + code + "}"),
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        var code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            var data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData$2(el, state);
+            }
+            var children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+        }
+        // module transforms
+        for (var i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    var originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.pre = originalPreState;
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData$2 (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (el.children.length !== 1 || ast.type !== 1) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        var key = '';
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    var condition = conditions.shift();
+    if (condition.exp) {
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+    }
+    else {
+        return ("" + (genTernaryExp(condition.block)));
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    var exp = el.for;
+    var alias = el.alias;
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+            "v-for should have explicit keys. " +
+            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return ((altHelper || '_l') + "((" + exp + ")," +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
+        '})');
+}
+function genData$2(el, state) {
+    var data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    var dirs = genDirectives(el, state);
+    if (dirs)
+        { data += dirs + ','; }
+    // key
+    if (el.key) {
+        data += "key:" + (el.key) + ",";
+    }
+    // ref
+    if (el.ref) {
+        data += "ref:" + (el.ref) + ",";
+    }
+    if (el.refInFor) {
+        data += "refInFor:true,";
+    }
+    // pre
+    if (el.pre) {
+        data += "pre:true,";
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += "tag:\"" + (el.tag) + "\",";
+    }
+    // module data generation functions
+    for (var i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += "attrs:" + (genProps(el.attrs)) + ",";
+    }
+    // DOM props
+    if (el.props) {
+        data += "domProps:" + (genProps(el.props)) + ",";
+    }
+    // event handlers
+    if (el.events) {
+        data += (genHandlers(el.events, false)) + ",";
+    }
+    if (el.nativeEvents) {
+        data += (genHandlers(el.nativeEvents, true)) + ",";
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += "slot:" + (el.slotTarget) + ",";
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+    }
+    // component v-model
+    if (el.model) {
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        var inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += inlineTemplate + ",";
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    var dirs = el.directives;
+    if (!dirs)
+        { return; }
+    var res = 'directives:[';
+    var hasRuntime = false;
+    var i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        var gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
     }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
 }
-
+function genInlineTemplate(el, state) {
+    var ast = el.children[0];
+    if (el.children.length !== 1 || ast.type !== 1) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        var inlineRenderFns = generate(ast, state.options);
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    var needsForceUpdate = el.for ||
+        Object.keys(slots).some(function (key) {
+            var slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    var needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    var generatedSlots = Object.keys(slots)
+        .map(function (key) { return genScopedSlot(slots[key], state); })
+        .join(',');
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+}
 function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
+    var hash = 5381;
+    var i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
 }
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-}
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    var isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, "null");
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+    var fn = "function(" + slotScope + "){" +
+        "return " + (el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)) + "}";
+    // reverse proxy v-slot without scope on this.$slots
+    var reverseProxy = slotScope ? "" : ",proxy:true";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    var children = el.children;
+    if (children.length) {
+        var el$1 = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
+                    ? ",1"
+                    : ",0"
+                : "";
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+        }
+        var normalizationType$1 = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
-}
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-}
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
-}
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? ("," + children) : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function getNormalizationType(children, maybeComponent) {
+    var res = 0;
+    for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return ("_v(" + (text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+}
+function genComment(comment) {
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+}
+function genSlot(el, state) {
+    var slotName = el.slotName || '"default"';
+    var children = genChildren(el, state);
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+        }); }))
+        : null;
+    var bind$$1 = el.attrsMap['v-bind'];
+    if ((attrs || bind$$1) && !children) {
+        res += ",null";
+    }
+    if (attrs) {
+        res += "," + attrs;
+    }
+    if (bind$$1) {
+        res += (attrs ? '' : ',null') + "," + bind$$1;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    var children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+}
+function genProps(props) {
+    var staticProps = "";
+    var dynamicProps = "";
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        var value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += (prop.name) + "," + value + ",";
+        }
+        else {
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+        }
+    }
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    if (dynamicProps) {
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
+/* @flow */
+var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+// let the model AST transform translate v-model into appropriate
+// props bindings
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (var i = 0; i < el.directives.length; i++) {
+            var dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+                }
+                break;
+            }
+        }
+    }
+}
+function genAttrSegments(attrs) {
+    return attrs.map(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
 
-var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+        return genAttrSegment(name, value);
+    });
+}
+function genDOMPropSegments(props, attrs) {
+    var segments = [];
+    props.forEach(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
 
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform (el, state) {
-  if (el.directives) {
-    for (var i = 0; i < el.directives.length; i++) {
-      var dir = el.directives[i];
-      if (dir.name === 'model') {
-        state.directives.model(el, dir, state.warn);
-        // remove value for textarea as its converted to text
-        if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(function (p) { return p.name !== 'value'; });
-        }
-        break
-      }
-    }
-  }
-}
-
-function genAttrSegments (
-  attrs
-) {
-  return attrs.map(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    return genAttrSegment(name, value);
-  })
-}
-
-function genDOMPropSegments (
-  props,
-  attrs
-) {
-  var segments = [];
-  props.forEach(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    name = propsToAttrMap[name] || name.toLowerCase();
-    if (isRenderableAttr(name) &&
-      !(attrs && attrs.some(function (a) { return a.name === name; }))
-    ) {
-      segments.push(genAttrSegment(name, value));
-    }
-  });
-  return segments
-}
-
-function genAttrSegment (name, value) {
-  if (plainStringRE.test(value)) {
-    // force double quote
-    value = value.replace(/^'|'$/g, '"');
-    // force enumerated attr to "true"
-    if (isEnumeratedAttr(name) && value !== "\"false\"") {
-      value = "\"true\"";
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some(function (a) { return a.name === name; }))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== "\"false\"") {
+            value = "\"true\"";
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? (" " + name + "=\"" + name + "\"")
+                : value === '""'
+                    ? (" " + name)
+                    : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+        };
     }
-    return {
-      type: RAW,
-      value: isBooleanAttr(name)
-        ? (" " + name + "=\"" + name + "\"")
-        : value === '""'
-          ? (" " + name)
-          : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-    }
-  } else {
-    return {
-      type: EXPRESSION,
-      value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
-    }
-  }
-}
-
-function genClassSegments (
-  staticClass,
-  classBinding
-) {
-  if (staticClass && !classBinding) {
-    return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-    }]
-  }
-}
-
-function genStyleSegments (
-  staticStyle,
-  parsedStaticStyle,
-  styleBinding,
-  vShowExpression
-) {
-  if (staticStyle && !styleBinding && !vShowExpression) {
-    return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-          ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-          : 'null') + ")")
-    }]
-  }
-}
-
-/*  */
+    else {
+        return {
+            type: EXPRESSION,
+            value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+        };
+    }
+}
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+            } ];
+    }
+}
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                    ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                    : 'null') + ")"),
+            } ];
+    }
+}
 
+/* @flow */
 // optimizability constants
 var optimizability = {
-  FALSE: 0,    // whole sub tree un-optimizable
-  FULL: 1,     // whole sub tree optimizable
-  SELF: 2,     // self optimizable but has some un-optimizable children
-  CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4   // self un-optimizable with some un-optimizable children
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
 };
-
 var isPlatformReservedTag;
-
-function optimize (root, options) {
-  if (!root) { return }
-  isPlatformReservedTag = options.isReservedTag || no;
-  walk(root, true);
-}
-
-function walk (node, isRoot) {
-  if (isUnOptimizableTree(node)) {
-    node.ssrOptimizability = optimizability.FALSE;
-    return
-  }
-  // root node or nodes with custom directives should always be a VNode
-  var selfUnoptimizable = isRoot || hasCustomDirective(node);
-  var check = function (child) {
-    if (child.ssrOptimizability !== optimizability.FULL) {
-      node.ssrOptimizability = selfUnoptimizable
-        ? optimizability.PARTIAL
-        : optimizability.SELF;
-    }
-  };
-  if (selfUnoptimizable) {
-    node.ssrOptimizability = optimizability.CHILDREN;
-  }
-  if (node.type === 1) {
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      walk(child);
-      check(child);
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        walk(block, isRoot);
-        check(block);
-      }
-    }
-    if (node.ssrOptimizability == null ||
-      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-    ) {
-      node.ssrOptimizability = optimizability.FULL;
-    } else {
-      node.children = optimizeSiblings(node);
-    }
-  } else {
-    node.ssrOptimizability = optimizability.FULL;
-  }
-}
-
-function optimizeSiblings (el) {
-  var children = el.children;
-  var optimizedChildren = [];
-
-  var currentOptimizableGroup = [];
-  var pushGroup = function () {
-    if (currentOptimizableGroup.length) {
-      optimizedChildren.push({
-        type: 1,
-        parent: el,
-        tag: 'template',
-        attrsList: [],
-        attrsMap: {},
-        rawAttrsMap: {},
-        children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
-      });
-    }
-    currentOptimizableGroup = [];
-  };
-
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.ssrOptimizability === optimizability.FULL) {
-      currentOptimizableGroup.push(c);
-    } else {
-      // wrap fully-optimizable adjacent siblings inside a template tag
-      // so that they can be optimized into a single ssrNode by codegen
-      pushGroup();
-      optimizedChildren.push(c);
-    }
-  }
-  pushGroup();
-  return optimizedChildren
-}
-
-function isUnOptimizableTree (node) {
-  if (node.type === 2 || node.type === 3) { // text or expression
-    return false
-  }
-  return (
-    isBuiltInTag(node.tag) || // built-in (slot, component)
-    !isPlatformReservedTag(node.tag) || // custom component
-    !!node.component || // "is" component
-    isSelectWithModel(node) // <select v-model> requires runtime inspection
-  )
+function optimize(root, options) {
+    if (!root)
+        { return; }
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    var selfUnoptimizable = isRoot || hasCustomDirective(node);
+    var check = function (child) {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
+    }
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    var children = el.children;
+    var optimizedChildren = [];
+    var currentOptimizableGroup = [];
+    var pushGroup = function () {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (var i = 0; i < children.length; i++) {
+        var c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
+}
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
 }
-
 var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-function hasCustomDirective (node) {
-  return (
-    node.type === 1 &&
-    node.directives &&
-    node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-  )
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some(function (d) { return !isBuiltInDir(d.name); }));
 }
-
 // <select v-model> cannot be optimized because it requires a runtime check
 // to determine proper selected option
-function isSelectWithModel (node) {
-  return (
-    node.type === 1 &&
-    node.tag === 'select' &&
-    node.directives != null &&
-    node.directives.some(function (d) { return d.name === 'model'; })
-  )
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some(function (d) { return d.name === 'model'; }));
 }
 
-/*  */
-
-
-
-
+/* @flow */
 // segment types
 var RAW = 0;
 var INTERPOLATION = 1;
 var EXPRESSION = 2;
+function generate$1(ast, options) {
+    var state = new CodegenState(options);
+    var code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: ("with(this){return " + code + "}"),
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    var data = el.plain ? undefined : genData$2(el, state);
+    var children = stringifyChildren
+        ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+        : genSSRChildren(el, state, true);
+    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+        : '';
+}
+function genStringElement(el, state) {
+    return ("_ssrNode(" + (elementToString(el, state)) + ")");
+}
+function genStringElementWithChildren(el, state) {
+    var children = genSSRChildren(el, state, true);
+    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+}
+function elementToString(el, state) {
+    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            } ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            } ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    var openSegments = elementToOpenTagSegments(el, state);
+    var childrenSegments = childrenToSegments(el, state);
+    var ref = state.options;
+    var isUnaryTag = ref.isUnaryTag;
+    var close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    var binding;
+    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+    }
+    segments.push({ type: RAW, value: ">" });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    var binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    var segments = [];
+    for (var i = 0; i < children.length; i++) {
+        var c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            var text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
+}
+function flattenSegments(segments) {
+    var mergedSegments = [];
+    var textBuffer = '';
+    var pushBuffer = function () {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (var i = 0; i < segments.length; i++) {
+        var s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(("(" + (s.value) + ")"));
+        }
+    }
+    pushBuffer();
+    return mergedSegments.join('+');
+}
 
-function generate$1 (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genSSRElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genSSRElement (el, state) {
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genSSRElement)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state, genSSRElement)
-  } else if (el.tag === 'template' && !el.slotTarget) {
-    return el.ssrOptimizability === optimizability.FULL
-      ? genChildrenAsStringNode(el, state)
-      : genSSRChildren(el, state) || 'void 0'
-  }
-
-  switch (el.ssrOptimizability) {
-    case optimizability.FULL:
-      // stringify whole tree
-      return genStringElement(el, state)
-    case optimizability.SELF:
-      // stringify self and check children
-      return genStringElementWithChildren(el, state)
-    case optimizability.CHILDREN:
-      // generate self as VNode and stringify children
-      return genNormalElement(el, state, true)
-    case optimizability.PARTIAL:
-      // generate self as VNode and check children
-      return genNormalElement(el, state, false)
-    default:
-      // bail whole tree
-      return genElement(el, state)
-  }
-}
-
-function genNormalElement (el, state, stringifyChildren) {
-  var data = el.plain ? undefined : genData$2(el, state);
-  var children = stringifyChildren
-    ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-    : genSSRChildren(el, state, true);
-  return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-}
-
-function genSSRChildren (el, state, checkSkip) {
-  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-}
-
-function genSSRNode (el, state) {
-  return el.type === 1
-    ? genSSRElement(el, state)
-    : genText(el)
-}
-
-function genChildrenAsStringNode (el, state) {
-  return el.children.length
-    ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-    : ''
-}
-
-function genStringElement (el, state) {
-  return ("_ssrNode(" + (elementToString(el, state)) + ")")
-}
-
-function genStringElementWithChildren (el, state) {
-  var children = genSSRChildren(el, state, true);
-  return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-}
-
-function elementToString (el, state) {
-  return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-}
-
-function elementToSegments (el, state) {
-  // v-for / v-if
-  if (el.for && !el.forProcessed) {
-    el.forProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genFor(el, state, elementToString, '_ssrList')
-    }]
-  } else if (el.if && !el.ifProcessed) {
-    el.ifProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genIf(el, state, elementToString, '"<!---->"')
-    }]
-  } else if (el.tag === 'template') {
-    return childrenToSegments(el, state)
-  }
-
-  var openSegments = elementToOpenTagSegments(el, state);
-  var childrenSegments = childrenToSegments(el, state);
-  var ref = state.options;
-  var isUnaryTag = ref.isUnaryTag;
-  var close = (isUnaryTag && isUnaryTag(el.tag))
-    ? []
-    : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-  return openSegments.concat(childrenSegments, close)
-}
-
-function elementToOpenTagSegments (el, state) {
-  applyModelTransform(el, state);
-  var binding;
-  var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-  // attrs
-  if (el.attrs) {
-    segments.push.apply(segments, genAttrSegments(el.attrs));
-  }
-  // domProps
-  if (el.props) {
-    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-  }
-  // v-bind="object"
-  if ((binding = el.attrsMap['v-bind'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-  }
-  // v-bind.prop="object"
-  if ((binding = el.attrsMap['v-bind.prop'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-  }
-  // class
-  if (el.staticClass || el.classBinding) {
-    segments.push.apply(
-      segments,
-      genClassSegments(el.staticClass, el.classBinding)
-    );
-  }
-  // style & v-show
-  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-    segments.push.apply(
-      segments,
-      genStyleSegments(
-        el.attrsMap.style,
-        el.staticStyle,
-        el.styleBinding,
-        el.attrsMap['v-show']
-      )
-    );
-  }
-  // _scopedId
-  if (state.options.scopeId) {
-    segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-  }
-  segments.push({ type: RAW, value: ">" });
-  return segments
-}
-
-function childrenToSegments (el, state) {
-  var binding;
-  if ((binding = el.attrsMap['v-html'])) {
-    return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-  }
-  if ((binding = el.attrsMap['v-text'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  return el.children
-    ? nodesToSegments(el.children, state)
-    : []
-}
-
-function nodesToSegments (
-  children,
-  state
-) {
-  var segments = [];
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.type === 1) {
-      segments.push.apply(segments, elementToSegments(c, state));
-    } else if (c.type === 2) {
-      segments.push({ type: INTERPOLATION, value: c.expression });
-    } else if (c.type === 3) {
-      var text = escape(c.text);
-      if (c.isComment) {
-        text = '<!--' + text + '-->';
-      }
-      segments.push({ type: RAW, value: text });
-    }
-  }
-  return segments
-}
-
-function flattenSegments (segments) {
-  var mergedSegments = [];
-  var textBuffer = '';
-
-  var pushBuffer = function () {
-    if (textBuffer) {
-      mergedSegments.push(JSON.stringify(textBuffer));
-      textBuffer = '';
-    }
-  };
-
-  for (var i = 0; i < segments.length; i++) {
-    var s = segments[i];
-    if (s.type === RAW) {
-      textBuffer += s.value;
-    } else if (s.type === INTERPOLATION) {
-      pushBuffer();
-      mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-    } else if (s.type === EXPRESSION) {
-      pushBuffer();
-      mergedSegments.push(("(" + (s.value) + ")"));
-    }
-  }
-  pushBuffer();
-
-  return mergedSegments.join('+')
-}
-
-/*  */
-
-
-
+/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+var prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+var unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
 var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
-}
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
-}
-
-function checkEvent (exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
+                if (value) {
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else {
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (var i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkEvent(exp, text, warn, range) {
+    var stripped = exp.replace(stripStringRE, '');
+    var keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn("avoid using JavaScript unary operator as property name: " +
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(("var " + ident + "=_"));
+        }
+        catch (e) {
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-    }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
+        new Function(("return " + exp));
+    }
+    catch (e) {
+        var keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn("avoid using JavaScript keyword as property name: " +
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+        }
+        else {
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
+    }
 }
 
-/*  */
-
+/* @flow */
 var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
-    }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
+function generateCodeFrame(source, start, end) {
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
+    var lines = source.split(/\r?\n/);
+    var count = 0;
+    var res = [];
+    for (var i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (var j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    { continue; }
+                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                var lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    var pad = start - (count - lineLength) + 1;
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat$1("^", length$1));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
         }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+    }
+    return res.join('\n');
+}
+function repeat$1(str, n) {
+    var result = '';
+    if (n > 0) {
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                { result += str; }
+            n >>>= 1;
+            if (n <= 0)
+                { break; }
+            str += str;
         }
-      }
     }
+    return result;
+}
 
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
-            }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
+/* @flow */
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err: err, code: code });
+        return noop;
     }
+}
+function createCompileToFunctionFn(compile) {
+    var cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        var warn$$1 = options.warn || warn;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        var key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        var compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach(function (e) {
+                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                }
+                else {
+                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                }
+            }
+        }
+        // turn code into functions
+        var res = {};
+        var fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn$$1("Failed to generate render function:\n\n" +
+                    fnGenErrors
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
+}
+
+/* @flow */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            var finalOptions = Object.create(baseOptions);
+            var errors = [];
+            var tips = [];
+            var warn = function (msg, range, tip) {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = function (msg, range, tip) {
+                        var data = { msg: msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (var key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            var compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile: compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
+/* @flow */
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
+    optimize(ast, options);
+    var code = generate$1(ast, options);
     return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
-}
-
-/*  */
-
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  optimize(ast, options);
-  var code = generate$1(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+        ast: ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
+/* @flow */
 var ref = createCompiler(baseOptions);
 var compile = ref.compile;
 var compileToFunctions = ref.compileToFunctions;
 
-/*  */
-
+/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (var i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            { continue; }
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
+}
 
+/* @flow */
 var ssrHelpers = {
-  _ssrEscape: escape,
-  _ssrNode: renderStringNode,
-  _ssrList: renderStringList,
-  _ssrAttr: renderAttr,
-  _ssrAttrs: renderAttrs$1,
-  _ssrDOMProps: renderDOMProps$1,
-  _ssrClass: renderSSRClass,
-  _ssrStyle: renderSSRStyle
+    _ssrEscape: escape,
+    _ssrNode: renderStringNode,
+    _ssrList: renderStringList,
+    _ssrAttr: renderAttr,
+    _ssrAttrs: renderAttrs$1,
+    _ssrDOMProps: renderDOMProps$1,
+    _ssrClass: renderSSRClass,
+    _ssrStyle: renderSSRStyle,
 };
-
-function installSSRHelpers (vm) {
-  if (vm._ssrNode) {
-    return
-  }
-  var Vue = vm.constructor;
-  while (Vue.super) {
-    Vue = Vue.super;
-  }
-  extend(Vue.prototype, ssrHelpers);
-  if (Vue.FunctionalRenderContext) {
-    extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-  }
-}
-
-var StringNode = function StringNode (
-  open,
-  close,
-  children,
-  normalizationType
-) {
-  this.isString = true;
-  this.open = open;
-  this.close = close;
-  if (children) {
-    this.children = normalizationType === 1
-      ? simpleNormalizeChildren(children)
-      : normalizationType === 2
-        ? normalizeChildren(children)
-        : children;
-  } else {
-    this.children = void 0;
-  }
+function installSSRHelpers(vm) {
+    if (vm._ssrNode) {
+        return;
+    }
+    var Vue = vm.constructor;
+    // @ts-expect-error
+    while (Vue.super) {
+        // @ts-expect-error
+        Vue = Vue.super;
+    }
+    extend(Vue.prototype, ssrHelpers);
+    // @ts-expect-error
+    if (Vue.FunctionalRenderContext) {
+        // @ts-expect-error
+        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+    }
+}
+var StringNode = function StringNode(open, close, children, normalizationType) {
+    this.isString = true;
+    this.open = open;
+    this.close = close;
+    if (children) {
+        this.children =
+            normalizationType === 1
+                ? simpleNormalizeChildren(children)
+                : normalizationType === 2
+                    ? normalizeChildren(children)
+                    : children;
+    }
+    else {
+        this.children = void 0;
+    }
 };
-
-function renderStringNode (
-  open,
-  close,
-  children,
-  normalizationType
-) {
-  return new StringNode(open, close, children, normalizationType)
-}
-
-function renderStringList (
-  val,
-  render
-) {
-  var ret = '';
-  var i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    for (i = 0, l = val.length; i < l; i++) {
-      ret += render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    for (i = 0; i < val; i++) {
-      ret += render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    keys = Object.keys(val);
-    for (i = 0, l = keys.length; i < l; i++) {
-      key = keys[i];
-      ret += render(val[key], key, i);
-    }
-  }
-  return ret
-}
-
-function renderAttrs$1 (obj) {
-  var res = '';
-  for (var key in obj) {
-    if (isSSRUnsafeAttr(key)) {
-      continue
-    }
-    res += renderAttr(key, obj[key]);
-  }
-  return res
-}
-
-function renderDOMProps$1 (obj) {
-  var res = '';
-  for (var key in obj) {
-    var attr = propsToAttrMap[key] || key.toLowerCase();
-    if (isRenderableAttr(attr)) {
-      res += renderAttr(attr, obj[key]);
-    }
-  }
-  return res
-}
-
-function renderSSRClass (
-  staticClass,
-  dynamic
-) {
-  var res = renderClass(staticClass, dynamic);
-  return res === '' ? res : (" class=\"" + (escape(res)) + "\"")
-}
-
-function renderSSRStyle (
-  staticStyle,
-  dynamic,
-  extra
-) {
-  var style = {};
-  if (staticStyle) { extend(style, staticStyle); }
-  if (dynamic) { extend(style, normalizeStyleBinding(dynamic)); }
-  if (extra) { extend(style, extra); }
-  var res = genStyle(style);
-  return res === '' ? res : (" style=" + (JSON.stringify(escape(res))))
+function renderStringNode(open, close, children, normalizationType) {
+    return new StringNode(open, close, children, normalizationType);
+}
+function renderStringList(val, render) {
+    var ret = '';
+    var i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        for (i = 0, l = val.length; i < l; i++) {
+            ret += render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        for (i = 0; i < val; i++) {
+            ret += render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        keys = Object.keys(val);
+        for (i = 0, l = keys.length; i < l; i++) {
+            key = keys[i];
+            ret += render(val[key], key, i);
+        }
+    }
+    return ret;
+}
+function renderAttrs$1(obj) {
+    var res = '';
+    for (var key in obj) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        res += renderAttr(key, obj[key]);
+    }
+    return res;
+}
+function renderDOMProps$1(obj) {
+    var res = '';
+    for (var key in obj) {
+        var attr = propsToAttrMap[key] || key.toLowerCase();
+        if (isRenderableAttr(attr)) {
+            res += renderAttr(attr, obj[key]);
+        }
+    }
+    return res;
+}
+function renderSSRClass(staticClass, dynamic) {
+    var res = renderClass(staticClass, dynamic);
+    return res === '' ? res : (" class=\"" + (escape(res)) + "\"");
+}
+function renderSSRStyle(staticStyle, dynamic, extra) {
+    var style = {};
+    if (staticStyle)
+        { extend(style, staticStyle); }
+    if (dynamic)
+        { extend(style, normalizeStyleBinding(dynamic)); }
+    if (extra)
+        { extend(style, extra); }
+    var res = genStyle(style);
+    return res === '' ? res : (" style=" + (JSON.stringify(escape(res))));
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
 }
 
-/*  */
-
+/* @flow */
 var seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    var i, keys;
+    var isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        var depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            { _traverse(val[i], seen); }
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            { _traverse(val[keys[i]], seen); }
+    }
 }
 
 {
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) ;
+    var perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) ;
 }
 
-/*  */
-
 var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+    var passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once$$1 ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name: name,
+        once: once$$1,
+        capture: capture,
+        passive: passive,
+    };
 });
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        var arguments$1 = arguments;
+
+        var fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
+    var name, def$$1, cur, old, event;
+    for (name in on) {
+        def$$1 = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove$$1(event.name, oldOn[name], event.capture);
+        }
+    }
+}
 
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
-}
-
-/*  */
-
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
-}
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
+/* @flow */
 
+/* @flow */
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    var res = {};
+    var attrs = data.attrs;
+    var props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
+            {
+                var keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === 'string') {
+        var Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            { applyNS(vnode, ns); }
+        if (isDef(data))
+            { registerDeepBindings(data); }
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    var ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (!isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+/* @flow */
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
-}
-
-/*  */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+}
 
+/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn('v-bind without argument expects an Object or Array value', this);
         }
-      };
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            var hash;
+            var loop = function ( key ) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    var type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        var on = data.on || (data.on = {});
+                        on[("update:" + key)] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            };
 
-      for (var key in value) loop( key );
+            for (var key in value) loop( key );
+        }
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, ("__static__" + index), false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
+function markOnce(tree, index, key) {
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (var i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
+/* @flow */
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
     }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+    return data;
 }
 
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
-}
-
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
-}
-
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+/* @flow */
+function bindDynamicKeys(baseObj, values) {
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-
-
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+/* @flow */
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+/* @flow */
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return function () { return slots[key]; };
 }
 
-/*  */
-
+/* @flow */
 var currentRenderingInstance = null;
 
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
-        }
-      }
-    };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
-        }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
-        }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                "timeout (" + (res.timeout) + "ms)"
-              );
+/* @flow */
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
+}
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    var owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        var resolve = once(function (res) {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        var reject = once(function (reason) {
+            warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject("timeout (" + (res.timeout) + "ms)");
+                        }
+                    }, res.timeout);
+                }
             }
-          }, res.timeout);
         }
-      }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
     }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
 }
 
-/*  */
+/* @flow */
 
-/*  */
+/* @flow */
 
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
 var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
-}
-
-function remove$1 (event, fn) {
-  target.$off(event, fn);
-}
-
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
-    }
-  }
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    var _target = target;
+    return function onceHandler() {
+        var res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
 }
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    target = undefined;
 }
 
-/*  */
-
+/* @flow */
 var activeInstance = null;
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
-    }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-}
-
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
-}
-
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            { return true; }
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (var i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'activated');
     }
-    callHook(vm, 'activated');
-  }
 }
-
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (var i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, 'deactivated');
     }
-    callHook(vm, 'deactivated');
-  }
 }
-
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
     }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
+    popTarget();
 }
 
-/*  */
-
+/* @flow */
 // Async edge case fix requires storing an event listener's attach timestamp.
 var getNow = Date.now;
-
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -7746,1871 +6715,1680 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = function () { return performance.now(); };
+    }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
 }
 
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
+
+/* @flow */
+
+/* @flow */
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                { continue; }
+            var provideKey = inject[key].from;
+            var source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    var provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    // @ts-ignore
+                    warn(("Injection \"" + key + "\" not found"), vm);
+                }
+            }
+        }
+        return result;
+    }
+}
+
+/* @flow */
+function resolveConstructorOptions(Ctor) {
+    var options = Ctor.options;
+    if (Ctor.super) {
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            var modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                { modified = {}; }
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
+}
 
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
+/* @flow */
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    var this$1 = this;
 
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
-        }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else {
-          warn(("Injection \"" + key + "\" not found"), vm);
-        }
-      }
-    }
-    return result
-  }
-}
-
-/*  */
-
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
-    }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        }
+        return this$1.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get: function get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = function (a, b, c, d) {
+            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (var key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            { mergeProps(props, data.attrs); }
+        if (isDef(data.props))
+            { mergeProps(props, data.props); }
+    }
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (var key in from) {
+        to[camelize(key)] = from[key];
+    }
+}
+
+/* @flow */
 
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-    }
-    return res
-  }
-}
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
-}
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
-}
-
-/*  */
-
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init: function init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            var mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch: function prepatch(oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy: function destroy(vnode) {
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
-    }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
-    }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent // activeInstance in lifecycle state
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-    }
-  }
-}
-
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
+        }
+        return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        var slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
+    // @ts-expect-error
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    var options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook$1(f1, f2) {
+    var merged = function (a, b) {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
-}
-
-/*  */
+function transformModel(options, data) {
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
+}
 
+/* @flow */
 var warned = Object.create(null);
 var warnOnce = function (msg) {
-  if (!warned[msg]) {
-    warned[msg] = true;
-    // eslint-disable-next-line no-console
-    console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
-  }
+    if (!warned[msg]) {
+        warned[msg] = true;
+        // eslint-disable-next-line no-console
+        console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
+    }
 };
-
 var onCompilationError = function (err, vm) {
-  var trace = vm ? generateComponentTrace(vm) : '';
-  throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"))
+    var trace = vm ? generateComponentTrace(vm) : '';
+    throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"));
 };
-
 var normalizeRender = function (vm) {
-  var ref = vm.$options;
-  var render = ref.render;
-  var template = ref.template;
-  var _scopeId = ref._scopeId;
-  if (isUndef(render)) {
-    if (template) {
-      var compiled = compileToFunctions(template, {
-        scopeId: _scopeId,
-        warn: onCompilationError
-      }, vm);
-
-      vm.$options.render = compiled.render;
-      vm.$options.staticRenderFns = compiled.staticRenderFns;
-    } else {
-      throw new Error(
-        ("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'))
-      )
-    }
-  }
+    var ref = vm.$options;
+    var render = ref.render;
+    var template = ref.template;
+    var _scopeId = ref._scopeId;
+    if (isUndef(render)) {
+        if (template) {
+            var compiled = compileToFunctions(template, {
+                scopeId: _scopeId,
+                warn: onCompilationError,
+            }, vm);
+            vm.$options.render = compiled.render;
+            vm.$options.staticRenderFns = compiled.staticRenderFns;
+        }
+        else {
+            throw new Error(("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous')));
+        }
+    }
 };
-
-function waitForServerPrefetch (vm, resolve, reject) {
-  var handlers = vm.$options.serverPrefetch;
-  if (isDef(handlers)) {
-    if (!Array.isArray(handlers)) { handlers = [handlers]; }
-    try {
-      var promises = [];
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        var result = handlers[i].call(vm, vm);
-        if (result && typeof result.then === 'function') {
-          promises.push(result);
-        }
-      }
-      Promise.all(promises).then(resolve).catch(reject);
-      return
-    } catch (e) {
-      reject(e);
-    }
-  }
-  resolve();
-}
-
-function renderNode (node, isRoot, context) {
-  if (node.isString) {
-    renderStringNode$1(node, context);
-  } else if (isDef(node.componentOptions)) {
-    renderComponent(node, isRoot, context);
-  } else if (isDef(node.tag)) {
-    renderElement(node, isRoot, context);
-  } else if (isTrue(node.isComment)) {
-    if (isDef(node.asyncFactory)) {
-      // async component
-      renderAsyncComponent(node, isRoot, context);
-    } else {
-      context.write(("<!--" + (node.text) + "-->"), context.next);
-    }
-  } else {
-    context.write(
-      node.raw ? node.text : escape(String(node.text)),
-      context.next
-    );
-  }
-}
-
-function registerComponentForCache (options, write) {
-  // exposed by vue-loader, need to call this if cache hit because
-  // component lifecycle hooks will not be called.
-  var register = options._ssrRegister;
-  if (write.caching && isDef(register)) {
-    write.componentBuffer[write.componentBuffer.length - 1].add(register);
-  }
-  return register
-}
-
-function renderComponent (node, isRoot, context) {
-  var write = context.write;
-  var next = context.next;
-  var userContext = context.userContext;
-
-  // check cache hit
-  var Ctor = node.componentOptions.Ctor;
-  var getKey = Ctor.options.serverCacheKey;
-  var name = Ctor.options.name;
-  var cache = context.cache;
-  var registerComponent = registerComponentForCache(Ctor.options, write);
-
-  if (isDef(getKey) && isDef(cache) && isDef(name)) {
-    var rawKey = getKey(node.componentOptions.propsData);
-    if (rawKey === false) {
-      renderComponentInner(node, isRoot, context);
-      return
-    }
-    var key = name + '::' + rawKey;
-    var has = context.has;
-    var get = context.get;
-    if (isDef(has)) {
-      has(key, function (hit) {
-        if (hit === true && isDef(get)) {
-          get(key, function (res) {
-            if (isDef(registerComponent)) {
-              registerComponent(userContext);
-            }
-            res.components.forEach(function (register) { return register(userContext); });
-            write(res.html, next);
-          });
-        } else {
-          renderComponentWithCache(node, isRoot, key, context);
-        }
-      });
-    } else if (isDef(get)) {
-      get(key, function (res) {
-        if (isDef(res)) {
-          if (isDef(registerComponent)) {
-            registerComponent(userContext);
-          }
-          res.components.forEach(function (register) { return register(userContext); });
-          write(res.html, next);
-        } else {
-          renderComponentWithCache(node, isRoot, key, context);
-        }
-      });
-    }
-  } else {
-    if (isDef(getKey) && isUndef(cache)) {
-      warnOnce(
-        "[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
-        'but no cache was provided to the renderer.'
-      );
-    }
-    if (isDef(getKey) && isUndef(name)) {
-      warnOnce(
-        "[vue-server-renderer] Components that implement \"serverCacheKey\" " +
-        "must also define a unique \"name\" option."
-      );
+function waitForServerPrefetch(vm, resolve, reject) {
+    var handlers = vm.$options.serverPrefetch;
+    if (isDef(handlers)) {
+        if (!Array.isArray(handlers))
+            { handlers = [handlers]; }
+        try {
+            var promises = [];
+            for (var i = 0, j = handlers.length; i < j; i++) {
+                var result = handlers[i].call(vm, vm);
+                if (result && typeof result.then === 'function') {
+                    promises.push(result);
+                }
+            }
+            Promise.all(promises).then(resolve).catch(reject);
+            return;
+        }
+        catch (e) {
+            reject(e);
+        }
     }
-    renderComponentInner(node, isRoot, context);
-  }
-}
-
-function renderComponentWithCache (node, isRoot, key, context) {
-  var write = context.write;
-  write.caching = true;
-  var buffer = write.cacheBuffer;
-  var bufferIndex = buffer.push('') - 1;
-  var componentBuffer = write.componentBuffer;
-  componentBuffer.push(new Set());
-  context.renderStates.push({
-    type: 'ComponentWithCache',
-    key: key,
-    buffer: buffer,
-    bufferIndex: bufferIndex,
-    componentBuffer: componentBuffer
-  });
-  renderComponentInner(node, isRoot, context);
-}
-
-function renderComponentInner (node, isRoot, context) {
-  var prevActive = context.activeInstance;
-  // expose userContext on vnode
-  node.ssrContext = context.userContext;
-  var child = context.activeInstance = createComponentInstanceForVnode(
-    node,
-    context.activeInstance
-  );
-  normalizeRender(child);
-
-  var resolve = function () {
-    var childNode = child._render();
-    childNode.parent = node;
+    resolve();
+}
+function renderNode(node, isRoot, context) {
+    if (node.isString) {
+        renderStringNode$1(node, context);
+    }
+    else if (isDef(node.componentOptions)) {
+        renderComponent(node, isRoot, context);
+    }
+    else if (isDef(node.tag)) {
+        renderElement(node, isRoot, context);
+    }
+    else if (isTrue(node.isComment)) {
+        if (isDef(node.asyncFactory)) {
+            // async component
+            renderAsyncComponent(node, isRoot, context);
+        }
+        else {
+            context.write(("<!--" + (node.text) + "-->"), context.next);
+        }
+    }
+    else {
+        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+    }
+}
+function registerComponentForCache(options, write) {
+    // exposed by vue-loader, need to call this if cache hit because
+    // component lifecycle hooks will not be called.
+    var register = options._ssrRegister;
+    if (write.caching && isDef(register)) {
+        write.componentBuffer[write.componentBuffer.length - 1].add(register);
+    }
+    return register;
+}
+function renderComponent(node, isRoot, context) {
+    var write = context.write;
+    var next = context.next;
+    var userContext = context.userContext;
+    // check cache hit
+    var Ctor = node.componentOptions.Ctor;
+    var getKey = Ctor.options.serverCacheKey;
+    var name = Ctor.options.name;
+    var cache = context.cache;
+    var registerComponent = registerComponentForCache(Ctor.options, write);
+    if (isDef(getKey) && isDef(cache) && isDef(name)) {
+        var rawKey = getKey(node.componentOptions.propsData);
+        if (rawKey === false) {
+            renderComponentInner(node, isRoot, context);
+            return;
+        }
+        var key = name + '::' + rawKey;
+        var has = context.has;
+        var get = context.get;
+        if (isDef(has)) {
+            has(key, function (hit) {
+                if (hit === true && isDef(get)) {
+                    get(key, function (res) {
+                        if (isDef(registerComponent)) {
+                            registerComponent(userContext);
+                        }
+                        res.components.forEach(function (register) { return register(userContext); });
+                        write(res.html, next);
+                    });
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+        else if (isDef(get)) {
+            get(key, function (res) {
+                if (isDef(res)) {
+                    if (isDef(registerComponent)) {
+                        registerComponent(userContext);
+                    }
+                    res.components.forEach(function (register) { return register(userContext); });
+                    write(res.html, next);
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+    }
+    else {
+        if (isDef(getKey) && isUndef(cache)) {
+            warnOnce("[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
+                'but no cache was provided to the renderer.');
+        }
+        if (isDef(getKey) && isUndef(name)) {
+            warnOnce("[vue-server-renderer] Components that implement \"serverCacheKey\" " +
+                "must also define a unique \"name\" option.");
+        }
+        renderComponentInner(node, isRoot, context);
+    }
+}
+function renderComponentWithCache(node, isRoot, key, context) {
+    var write = context.write;
+    write.caching = true;
+    var buffer = write.cacheBuffer;
+    var bufferIndex = buffer.push('') - 1;
+    var componentBuffer = write.componentBuffer;
+    componentBuffer.push(new Set());
     context.renderStates.push({
-      type: 'Component',
-      prevActive: prevActive
+        type: 'ComponentWithCache',
+        key: key,
+        buffer: buffer,
+        bufferIndex: bufferIndex,
+        componentBuffer: componentBuffer,
     });
-    renderNode(childNode, isRoot, context);
-  };
-
-  var reject = context.done;
-
-  waitForServerPrefetch(child, resolve, reject);
+    renderComponentInner(node, isRoot, context);
 }
-
-function renderAsyncComponent (node, isRoot, context) {
-  var factory = node.asyncFactory;
-
-  var resolve = function (comp) {
-    if (comp.__esModule && comp.default) {
-      comp = comp.default;
+function renderComponentInner(node, isRoot, context) {
+    var prevActive = context.activeInstance;
+    // expose userContext on vnode
+    node.ssrContext = context.userContext;
+    var child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+    normalizeRender(child);
+    var resolve = function () {
+        var childNode = child._render();
+        childNode.parent = node;
+        context.renderStates.push({
+            type: 'Component',
+            prevActive: prevActive,
+        });
+        renderNode(childNode, isRoot, context);
+    };
+    var reject = context.done;
+    waitForServerPrefetch(child, resolve, reject);
+}
+function renderAsyncComponent(node, isRoot, context) {
+    var factory = node.asyncFactory;
+    var resolve = function (comp) {
+        if (comp.__esModule && comp.default) {
+            comp = comp.default;
+        }
+        var ref = node.asyncMeta;
+        var data = ref.data;
+        var children = ref.children;
+        var tag = ref.tag;
+        var nodeContext = node.asyncMeta.context;
+        var resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+        if (resolvedNode) {
+            if (resolvedNode.componentOptions) {
+                // normal component
+                renderComponent(resolvedNode, isRoot, context);
+            }
+            else if (!Array.isArray(resolvedNode)) {
+                // single return node from functional component
+                renderNode(resolvedNode, isRoot, context);
+            }
+            else {
+                // multiple return nodes from functional component
+                context.renderStates.push({
+                    type: 'Fragment',
+                    children: resolvedNode,
+                    rendered: 0,
+                    total: resolvedNode.length,
+                });
+                context.next();
+            }
+        }
+        else {
+            // invalid component, but this does not throw on the client
+            // so render empty comment node
+            context.write("<!---->", context.next);
+        }
+    };
+    if (factory.resolved) {
+        resolve(factory.resolved);
+        return;
+    }
+    var reject = context.done;
+    var res;
+    try {
+        res = factory(resolve, reject);
+    }
+    catch (e) {
+        reject(e);
+    }
+    if (res) {
+        if (typeof res.then === 'function') {
+            res.then(resolve, reject).catch(reject);
+        }
+        else {
+            // new syntax in 2.3
+            var comp = res.component;
+            if (comp && typeof comp.then === 'function') {
+                comp.then(resolve, reject).catch(reject);
+            }
+        }
+    }
+}
+function renderStringNode$1(el, context) {
+    var write = context.write;
+    var next = context.next;
+    if (isUndef(el.children) || el.children.length === 0) {
+        write(el.open + (el.close || ''), next);
+    }
+    else {
+        var children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children: children,
+            rendered: 0,
+            total: children.length,
+            endTag: el.close,
+        });
+        write(el.open, next);
+    }
+}
+function renderElement(el, isRoot, context) {
+    var write = context.write;
+    var next = context.next;
+    if (isTrue(isRoot)) {
+        if (!el.data)
+            { el.data = {}; }
+        if (!el.data.attrs)
+            { el.data.attrs = {}; }
+        el.data.attrs[SSR_ATTR] = 'true';
+    }
+    if (el.fnOptions) {
+        registerComponentForCache(el.fnOptions, write);
+    }
+    var startTag = renderStartingTag(el, context);
+    var endTag = "</" + (el.tag) + ">";
+    if (context.isUnaryTag(el.tag)) {
+        write(startTag, next);
+    }
+    else if (isUndef(el.children) || el.children.length === 0) {
+        write(startTag + endTag, next);
     }
-    var ref = node.asyncMeta;
-    var data = ref.data;
-    var children = ref.children;
-    var tag = ref.tag;
-    var nodeContext = node.asyncMeta.context;
-    var resolvedNode = createComponent(
-      comp,
-      data,
-      nodeContext,
-      children,
-      tag
-    );
-    if (resolvedNode) {
-      if (resolvedNode.componentOptions) {
-        // normal component
-        renderComponent(resolvedNode, isRoot, context);
-      } else if (!Array.isArray(resolvedNode)) {
-        // single return node from functional component
-        renderNode(resolvedNode, isRoot, context);
-      } else {
-        // multiple return nodes from functional component
+    else {
+        var children = el.children;
         context.renderStates.push({
-          type: 'Fragment',
-          children: resolvedNode,
-          rendered: 0,
-          total: resolvedNode.length
+            type: 'Element',
+            children: children,
+            rendered: 0,
+            total: children.length,
+            endTag: endTag,
         });
-        context.next();
-      }
-    } else {
-      // invalid component, but this does not throw on the client
-      // so render empty comment node
-      context.write("<!---->", context.next);
-    }
-  };
-
-  if (factory.resolved) {
-    resolve(factory.resolved);
-    return
-  }
-
-  var reject = context.done;
-  var res;
-  try {
-    res = factory(resolve, reject);
-  } catch (e) {
-    reject(e);
-  }
-  if (res) {
-    if (typeof res.then === 'function') {
-      res.then(resolve, reject).catch(reject);
-    } else {
-      // new syntax in 2.3
-      var comp = res.component;
-      if (comp && typeof comp.then === 'function') {
-        comp.then(resolve, reject).catch(reject);
-      }
-    }
-  }
-}
-
-function renderStringNode$1 (el, context) {
-  var write = context.write;
-  var next = context.next;
-  if (isUndef(el.children) || el.children.length === 0) {
-    write(el.open + (el.close || ''), next);
-  } else {
-    var children = el.children;
-    context.renderStates.push({
-      type: 'Element',
-      children: children,
-      rendered: 0,
-      total: children.length,
-      endTag: el.close
-    });
-    write(el.open, next);
-  }
-}
-
-function renderElement (el, isRoot, context) {
-  var write = context.write;
-  var next = context.next;
-
-  if (isTrue(isRoot)) {
-    if (!el.data) { el.data = {}; }
-    if (!el.data.attrs) { el.data.attrs = {}; }
-    el.data.attrs[SSR_ATTR] = 'true';
-  }
-
-  if (el.fnOptions) {
-    registerComponentForCache(el.fnOptions, write);
-  }
-
-  var startTag = renderStartingTag(el, context);
-  var endTag = "</" + (el.tag) + ">";
-  if (context.isUnaryTag(el.tag)) {
-    write(startTag, next);
-  } else if (isUndef(el.children) || el.children.length === 0) {
-    write(startTag + endTag, next);
-  } else {
-    var children = el.children;
-    context.renderStates.push({
-      type: 'Element',
-      children: children,
-      rendered: 0,
-      total: children.length,
-      endTag: endTag
-    });
-    write(startTag, next);
-  }
-}
-
-function hasAncestorData (node) {
-  var parentNode = node.parent;
-  return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
-}
-
-function getVShowDirectiveInfo (node) {
-  var dir;
-  var tmp;
-
-  while (isDef(node)) {
-    if (node.data && node.data.directives) {
-      tmp = node.data.directives.find(function (dir) { return dir.name === 'show'; });
-      if (tmp) {
-        dir = tmp;
-      }
+        write(startTag, next);
     }
-    node = node.parent;
-  }
-  return dir
 }
-
-function renderStartingTag (node, context) {
-  var markup = "<" + (node.tag);
-  var directives = context.directives;
-  var modules = context.modules;
-
-  // construct synthetic data for module processing
-  // because modules like style also produce code by parent VNode data
-  if (isUndef(node.data) && hasAncestorData(node)) {
-    node.data = {};
-  }
-  if (isDef(node.data)) {
-    // check directives
-    var dirs = node.data.directives;
-    if (dirs) {
-      for (var i = 0; i < dirs.length; i++) {
-        var name = dirs[i].name;
-        if (name !== 'show') {
-          var dirRenderer = resolveAsset(context, 'directives', name);
-          if (dirRenderer) {
-            // directives mutate the node's data
-            // which then gets rendered by modules
-            dirRenderer(node, dirs[i]);
-          }
-        }
-      }
-    }
-
-    // v-show directive needs to be merged from parent to child
-    var vshowDirectiveInfo = getVShowDirectiveInfo(node);
-    if (vshowDirectiveInfo) {
-      directives.show(node, vshowDirectiveInfo);
-    }
-
-    // apply other modules
-    for (var i$1 = 0; i$1 < modules.length; i$1++) {
-      var res = modules[i$1](node);
-      if (res) {
-        markup += res;
-      }
-    }
-  }
-  // attach scoped CSS ID
-  var scopeId;
-  var activeInstance = context.activeInstance;
-  if (isDef(activeInstance) &&
-    activeInstance !== node.context &&
-    isDef(scopeId = activeInstance.$options._scopeId)
-  ) {
-    markup += " " + ((scopeId));
-  }
-  if (isDef(node.fnScopeId)) {
-    markup += " " + (node.fnScopeId);
-  } else {
+function hasAncestorData(node) {
+    var parentNode = node.parent;
+    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+}
+function getVShowDirectiveInfo(node) {
+    var dir;
+    var tmp;
     while (isDef(node)) {
-      if (isDef(scopeId = node.context.$options._scopeId)) {
+        if (node.data && node.data.directives) {
+            tmp = node.data.directives.find(function (dir) { return dir.name === 'show'; });
+            if (tmp) {
+                dir = tmp;
+            }
+        }
+        node = node.parent;
+    }
+    //@ts-expect-error
+    return dir;
+}
+function renderStartingTag(node, context) {
+    var markup = "<" + (node.tag);
+    var directives = context.directives;
+    var modules = context.modules;
+    // construct synthetic data for module processing
+    // because modules like style also produce code by parent VNode data
+    if (isUndef(node.data) && hasAncestorData(node)) {
+        node.data = {};
+    }
+    if (isDef(node.data)) {
+        // check directives
+        var dirs = node.data.directives;
+        if (dirs) {
+            for (var i = 0; i < dirs.length; i++) {
+                var name = dirs[i].name;
+                if (name !== 'show') {
+                    var dirRenderer = resolveAsset(context, 'directives', name);
+                    if (dirRenderer) {
+                        // directives mutate the node's data
+                        // which then gets rendered by modules
+                        dirRenderer(node, dirs[i]);
+                    }
+                }
+            }
+        }
+        // v-show directive needs to be merged from parent to child
+        var vshowDirectiveInfo = getVShowDirectiveInfo(node);
+        if (vshowDirectiveInfo) {
+            directives.show(node, vshowDirectiveInfo);
+        }
+        // apply other modules
+        for (var i$1 = 0; i$1 < modules.length; i$1++) {
+            var res = modules[i$1](node);
+            if (res) {
+                markup += res;
+            }
+        }
+    }
+    // attach scoped CSS ID
+    var scopeId;
+    var activeInstance = context.activeInstance;
+    if (isDef(activeInstance) &&
+        activeInstance !== node.context &&
+        isDef((scopeId = activeInstance.$options._scopeId))) {
         markup += " " + scopeId;
-      }
-      node = node.parent;
-    }
-  }
-  return markup + '>'
-}
-
-function createRenderFunction (
-  modules,
-  directives,
-  isUnaryTag,
-  cache
-) {
-  return function render (
-    component,
-    write,
-    userContext,
-    done
-  ) {
-    warned = Object.create(null);
-    var context = new RenderContext({
-      activeInstance: component,
-      userContext: userContext,
-      write: write, done: done, renderNode: renderNode,
-      isUnaryTag: isUnaryTag, modules: modules, directives: directives,
-      cache: cache
-    });
-    installSSRHelpers(component);
-    normalizeRender(component);
-
-    var resolve = function () {
-      renderNode(component._render(), true, context);
+    }
+    if (isDef(node.fnScopeId)) {
+        markup += " " + (node.fnScopeId);
+    }
+    else {
+        while (isDef(node)) {
+            //@ts-expect-error
+            if (isDef((scopeId = node.context.$options._scopeId))) {
+                markup += " " + scopeId;
+            }
+            node = node.parent;
+        }
+    }
+    return markup + '>';
+}
+function createRenderFunction(modules, directives, isUnaryTag, cache) {
+    return function render(component, write, userContext, done) {
+        warned = Object.create(null);
+        var context = new RenderContext({
+            activeInstance: component,
+            userContext: userContext,
+            write: write,
+            done: done,
+            renderNode: renderNode,
+            isUnaryTag: isUnaryTag,
+            modules: modules,
+            directives: directives,
+            cache: cache,
+        });
+        installSSRHelpers(component);
+        normalizeRender(component);
+        var resolve = function () {
+            renderNode(component._render(), true, context);
+        };
+        waitForServerPrefetch(component, resolve, done);
     };
-    waitForServerPrefetch(component, resolve, done);
-  }
 }
 
-/*  */
-
+/* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
-
 var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
-
-function createPromiseCallback () {
-  var resolve, reject;
-  var promise = new Promise(function (_resolve, _reject) {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  var cb = function (err, res) {
-    if (err) { return reject(err) }
-    resolve(res || '');
-  };
-  return { promise: promise, cb: cb }
+function createPromiseCallback() {
+    var resolve, reject;
+    var promise = new Promise(function (_resolve, _reject) {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    var cb = function (err, res) {
+        if (err)
+            { return reject(err); }
+        resolve(res || '');
+    };
+    return { promise: promise, cb: cb };
 }
 
-/*  */
-
-var Transform = require('stream').Transform;
-
-
-
+/* @flow */
 var TemplateStream = /*@__PURE__*/(function (Transform) {
-  function TemplateStream (
-    renderer,
-    template,
-    context
-  ) {
-    Transform.call(this);
-    this.started = false;
-    this.renderer = renderer;
-    this.template = template;
-    this.context = context || {};
-    this.inject = renderer.inject;
-  }
-
-  if ( Transform ) TemplateStream.__proto__ = Transform;
-  TemplateStream.prototype = Object.create( Transform && Transform.prototype );
-  TemplateStream.prototype.constructor = TemplateStream;
-
-  TemplateStream.prototype._transform = function _transform (data, encoding, done) {
-    if (!this.started) {
-      this.emit('beforeStart');
-      this.start();
-    }
-    this.push(data);
-    done();
-  };
-
-  TemplateStream.prototype.start = function start () {
-    this.started = true;
-    this.push(this.template.head(this.context));
-
-    if (this.inject) {
-      // inline server-rendered head meta information
-      if (this.context.head) {
-        this.push(this.context.head);
-      }
-
-      // inline preload/prefetch directives for initial/async chunks
-      var links = this.renderer.renderResourceHints(this.context);
-      if (links) {
-        this.push(links);
-      }
-
-      // CSS files and inline server-rendered CSS collected by vue-style-loader
-      var styles = this.renderer.renderStyles(this.context);
-      if (styles) {
-        this.push(styles);
-      }
-    }
-
-    this.push(this.template.neck(this.context));
-  };
-
-  TemplateStream.prototype._flush = function _flush (done) {
-    this.emit('beforeEnd');
-
-    if (this.inject) {
-      // inline initial store state
-      var state = this.renderer.renderState(this.context);
-      if (state) {
-        this.push(state);
-      }
-
-      // embed scripts needed
-      var scripts = this.renderer.renderScripts(this.context);
-      if (scripts) {
-        this.push(scripts);
-      }
-    }
-
-    this.push(this.template.tail(this.context));
-    done();
-  };
-
-  return TemplateStream;
-}(Transform));
+    function TemplateStream(renderer, template, context) {
+        Transform.call(this);
+        this.started = false;
+        this.renderer = renderer;
+        this.template = template;
+        this.context = context || {};
+        this.inject = renderer.inject;
+    }
+
+    if ( Transform ) TemplateStream.__proto__ = Transform;
+    TemplateStream.prototype = Object.create( Transform && Transform.prototype );
+    TemplateStream.prototype.constructor = TemplateStream;
+    TemplateStream.prototype._transform = function _transform (data, encoding, done) {
+        if (!this.started) {
+            this.emit('beforeStart');
+            this.start();
+        }
+        this.push(data);
+        done();
+    };
+    TemplateStream.prototype.start = function start () {
+        this.started = true;
+        this.push(this.template.head(this.context));
+        if (this.inject) {
+            // inline server-rendered head meta information
+            if (this.context.head) {
+                this.push(this.context.head);
+            }
+            // inline preload/prefetch directives for initial/async chunks
+            var links = this.renderer.renderResourceHints(this.context);
+            if (links) {
+                this.push(links);
+            }
+            // CSS files and inline server-rendered CSS collected by vue-style-loader
+            var styles = this.renderer.renderStyles(this.context);
+            if (styles) {
+                this.push(styles);
+            }
+        }
+        this.push(this.template.neck(this.context));
+    };
+    TemplateStream.prototype._flush = function _flush (done) {
+        this.emit('beforeEnd');
+        if (this.inject) {
+            // inline initial store state
+            var state = this.renderer.renderState(this.context);
+            if (state) {
+                this.push(state);
+            }
+            // embed scripts needed
+            var scripts = this.renderer.renderScripts(this.context);
+            if (scripts) {
+                this.push(scripts);
+            }
+        }
+        this.push(this.template.tail(this.context));
+        done();
+    };
 
-/*  */
+    return TemplateStream;
+}(stream.Transform));
 
+/* @flow */
 var compile$1 = require('lodash.template');
 var compileOptions = {
-  escape: /{{([^{][\s\S]+?[^}])}}/g,
-  interpolate: /{{{([\s\S]+?)}}}/g
+    escape: /{{([^{][\s\S]+?[^}])}}/g,
+    interpolate: /{{{([\s\S]+?)}}}/g,
 };
+function parseTemplate(template, contentPlaceholder) {
+    if ( contentPlaceholder === void 0 ) contentPlaceholder = '<!--vue-ssr-outlet-->';
 
-
-
-function parseTemplate (
-  template,
-  contentPlaceholder
-) {
-  if ( contentPlaceholder === void 0 ) contentPlaceholder = '<!--vue-ssr-outlet-->';
-
-  if (typeof template === 'object') {
-    return template
-  }
-
-  var i = template.indexOf('</head>');
-  var j = template.indexOf(contentPlaceholder);
-
-  if (j < 0) {
-    throw new Error("Content placeholder not found in template.")
-  }
-
-  if (i < 0) {
-    i = template.indexOf('<body>');
-    if (i < 0) {
-      i = j;
+    if (typeof template === 'object') {
+        return template;
     }
-  }
-
-  return {
-    head: compile$1(template.slice(0, i), compileOptions),
-    neck: compile$1(template.slice(i, j), compileOptions),
-    tail: compile$1(template.slice(j + contentPlaceholder.length), compileOptions)
-  }
-}
-
-/*  */
-
-/**
- * Creates a mapper that maps components used during a server-side render
- * to async chunk files in the client-side build, so that we can inline them
- * directly in the rendered HTML to avoid waterfall requests.
- */
-
-
-
-
-
-function createMapper (
-  clientManifest
-) {
-  var map = createMap(clientManifest);
-  // map server-side moduleIds to client-side files
-  return function mapper (moduleIds) {
-    var res = new Set();
-    for (var i = 0; i < moduleIds.length; i++) {
-      var mapped = map.get(moduleIds[i]);
-      if (mapped) {
-        for (var j = 0; j < mapped.length; j++) {
-          res.add(mapped[j]);
+    var i = template.indexOf('</head>');
+    var j = template.indexOf(contentPlaceholder);
+    if (j < 0) {
+        throw new Error("Content placeholder not found in template.");
+    }
+    if (i < 0) {
+        i = template.indexOf('<body>');
+        if (i < 0) {
+            i = j;
         }
-      }
     }
-    return Array.from(res)
-  }
+    return {
+        head: compile$1(template.slice(0, i), compileOptions),
+        neck: compile$1(template.slice(i, j), compileOptions),
+        tail: compile$1(template.slice(j + contentPlaceholder.length), compileOptions),
+    };
 }
 
-function createMap (clientManifest) {
-  var map = new Map();
-  Object.keys(clientManifest.modules).forEach(function (id) {
-    map.set(id, mapIdToFile(id, clientManifest));
-  });
-  return map
+/* @flow */
+function createMapper(clientManifest) {
+    var map = createMap(clientManifest);
+    // map server-side moduleIds to client-side files
+    return function mapper(moduleIds) {
+        var res = new Set();
+        for (var i = 0; i < moduleIds.length; i++) {
+            var mapped = map.get(moduleIds[i]);
+            if (mapped) {
+                for (var j = 0; j < mapped.length; j++) {
+                    res.add(mapped[j]);
+                }
+            }
+        }
+        return Array.from(res);
+    };
 }
-
-function mapIdToFile (id, clientManifest) {
-  var files = [];
-  var fileIndices = clientManifest.modules[id];
-  if (fileIndices) {
-    fileIndices.forEach(function (index) {
-      var file = clientManifest.all[index];
-      // only include async files or non-js, non-css assets
-      if (clientManifest.async.indexOf(file) > -1 || !(/\.(js|css)($|\?)/.test(file))) {
-        files.push(file);
-      }
+function createMap(clientManifest) {
+    var map = new Map();
+    Object.keys(clientManifest.modules).forEach(function (id) {
+        map.set(id, mapIdToFile(id, clientManifest));
     });
-  }
-  return files
+    return map;
+}
+function mapIdToFile(id, clientManifest) {
+    var files = [];
+    var fileIndices = clientManifest.modules[id];
+    if (fileIndices) {
+        fileIndices.forEach(function (index) {
+            var file = clientManifest.all[index];
+            // only include async files or non-js, non-css assets
+            if (file &&
+                (clientManifest.async.indexOf(file) > -1 ||
+                    !/\.(js|css)($|\?)/.test(file))) {
+                files.push(file);
+            }
+        });
+    }
+    return files;
 }
 
-/*  */
-
+/* @flow */
 var path = require('path');
 var serialize = require('serialize-javascript');
-
-
-
-
-
-
-
-
-
-var TemplateRenderer = function TemplateRenderer (options) {
-  this.options = options;
-  this.inject = options.inject !== false;
-  // if no template option is provided, the renderer is created
-  // as a utility object for rendering assets like preload links and scripts.
-    
-  var template = options.template;
-  this.parsedTemplate = template
-    ? typeof template === 'string'
-      ? parseTemplate(template)
-      : template
-    : null;
-
-  // function used to serialize initial state JSON
-  this.serialize = options.serializer || (function (state) {
-    return serialize(state, { isJSON: true })
-  });
-
-  // extra functionality with client manifest
-  if (options.clientManifest) {
-    var clientManifest = this.clientManifest = options.clientManifest;
-    // ensure publicPath ends with /
-    this.publicPath = clientManifest.publicPath === ''
-      ? ''
-      : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-    // preload/prefetch directives
-    this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-    this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-    // initial async chunk mapping
-    this.mapFiles = createMapper(clientManifest);
-  }
+var TemplateRenderer = function TemplateRenderer(options) {
+    this.options = options;
+    this.inject = options.inject !== false;
+    // if no template option is provided, the renderer is created
+    // as a utility object for rendering assets like preload links and scripts.
+    var template = options.template;
+    this.parsedTemplate = template
+        ? typeof template === 'string'
+            ? parseTemplate(template)
+            : template
+        : null;
+    // function used to serialize initial state JSON
+    this.serialize =
+        options.serializer ||
+            (function (state) {
+                return serialize(state, { isJSON: true });
+            });
+    // extra functionality with client manifest
+    if (options.clientManifest) {
+        var clientManifest = (this.clientManifest = options.clientManifest);
+        // ensure publicPath ends with /
+        this.publicPath =
+            clientManifest.publicPath === ''
+                ? ''
+                : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
+        // preload/prefetch directives
+        this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
+        this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
+        // initial async chunk mapping
+        this.mapFiles = createMapper(clientManifest);
+    }
 };
-
 TemplateRenderer.prototype.bindRenderFns = function bindRenderFns (context) {
-  var renderer = this
-  ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
-    context[("render" + type)] = renderer[("render" + type)].bind(renderer, context);
-  });
-  // also expose getPreloadFiles, useful for HTTP/2 push
-  context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
+    var renderer = this;
+    ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
+        context[("render" + type)] = renderer[("render" + type)].bind(renderer, context);
+    });
+    // also expose getPreloadFiles, useful for HTTP/2 push
+    context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
 };
-
 // render synchronously given rendered app content and render context
 TemplateRenderer.prototype.render = function render (content, context) {
-  var template = this.parsedTemplate;
-  if (!template) {
-    throw new Error('render cannot be called without a template.')
-  }
-  context = context || {};
-
-  if (typeof template === 'function') {
-    return template(content, context)
-  }
-
-  if (this.inject) {
-    return (
-      template.head(context) +
-      (context.head || '') +
-      this.renderResourceHints(context) +
-      this.renderStyles(context) +
-      template.neck(context) +
-      content +
-      this.renderState(context) +
-      this.renderScripts(context) +
-      template.tail(context)
-    )
-  } else {
-    return (
-      template.head(context) +
-      template.neck(context) +
-      content +
-      template.tail(context)
-    )
-  }
+    var template = this.parsedTemplate;
+    if (!template) {
+        throw new Error('render cannot be called without a template.');
+    }
+    context = context || {};
+    if (typeof template === 'function') {
+        return template(content, context);
+    }
+    if (this.inject) {
+        return (template.head(context) +
+            (context.head || '') +
+            this.renderResourceHints(context) +
+            this.renderStyles(context) +
+            template.neck(context) +
+            content +
+            this.renderState(context) +
+            this.renderScripts(context) +
+            template.tail(context));
+    }
+    else {
+        return (template.head(context) +
+            template.neck(context) +
+            content +
+            template.tail(context));
+    }
 };
-
 TemplateRenderer.prototype.renderStyles = function renderStyles (context) {
-    var this$1 = this;
+        var this$1 = this;
 
-  var initial = this.preloadFiles || [];
-  var async = this.getUsedAsyncFiles(context) || [];
-  var cssFiles = initial.concat(async).filter(function (ref) {
-      var file = ref.file;
+    var initial = this.preloadFiles || [];
+    var async = this.getUsedAsyncFiles(context) || [];
+    var cssFiles = initial.concat(async).filter(function (ref) {
+            var file = ref.file;
 
-      return isCSS(file);
-    });
-  return (
+            return isCSS(file);
+        });
+    return (
     // render links for css files
     (cssFiles.length
-      ? cssFiles.map(function (ref) {
-          var file = ref.file;
-
-          return ("<link rel=\"stylesheet\" href=\"" + (this$1.publicPath) + file + "\">");
-    }).join('')
-      : '') +
-    // context.styles is a getter exposed by vue-style-loader which contains
-    // the inline component styles collected during SSR
-    (context.styles || '')
-  )
-};
+        ? cssFiles
+            .map(function (ref) {
+                    var file = ref.file;
 
+                    return ("<link rel=\"stylesheet\" href=\"" + (this$1.publicPath) + file + "\">");
+        })
+            .join('')
+        : '') +
+        // context.styles is a getter exposed by vue-style-loader which contains
+        // the inline component styles collected during SSR
+        (context.styles || ''));
+};
 TemplateRenderer.prototype.renderResourceHints = function renderResourceHints (context) {
-  return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context)
+    return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
 };
-
 TemplateRenderer.prototype.getPreloadFiles = function getPreloadFiles (context) {
-  var usedAsyncFiles = this.getUsedAsyncFiles(context);
-  if (this.preloadFiles || usedAsyncFiles) {
-    return (this.preloadFiles || []).concat(usedAsyncFiles || [])
-  } else {
-    return []
-  }
+    var usedAsyncFiles = this.getUsedAsyncFiles(context);
+    if (this.preloadFiles || usedAsyncFiles) {
+        return (this.preloadFiles || []).concat(usedAsyncFiles || []);
+    }
+    else {
+        return [];
+    }
 };
-
 TemplateRenderer.prototype.renderPreloadLinks = function renderPreloadLinks (context) {
-    var this$1 = this;
-
-  var files = this.getPreloadFiles(context);
-  var shouldPreload = this.options.shouldPreload;
-  if (files.length) {
-    return files.map(function (ref) {
-        var file = ref.file;
-        var extension = ref.extension;
-        var fileWithoutQuery = ref.fileWithoutQuery;
-        var asType = ref.asType;
-
-      var extra = '';
-      // by default, we only preload scripts or css
-      if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-        return ''
-      }
-      // user wants to explicitly control what to preload
-      if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-        return ''
-      }
-      if (asType === 'font') {
-        extra = " type=\"font/" + extension + "\" crossorigin";
-      }
-      return ("<link rel=\"preload\" href=\"" + (this$1.publicPath) + file + "\"" + (asType !== '' ? (" as=\"" + asType + "\"") : '') + extra + ">")
-    }).join('')
-  } else {
-    return ''
-  }
+        var this$1 = this;
+
+    var files = this.getPreloadFiles(context);
+    var shouldPreload = this.options.shouldPreload;
+    if (files.length) {
+        return files
+            .map(function (ref) {
+                var file = ref.file;
+                var extension = ref.extension;
+                var fileWithoutQuery = ref.fileWithoutQuery;
+                var asType = ref.asType;
+
+            var extra = '';
+            // by default, we only preload scripts or css
+            if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+                return '';
+            }
+            // user wants to explicitly control what to preload
+            if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+                return '';
+            }
+            if (asType === 'font') {
+                extra = " type=\"font/" + extension + "\" crossorigin";
+            }
+            return ("<link rel=\"preload\" href=\"" + (this$1.publicPath) + file + "\"" + (asType !== '' ? (" as=\"" + asType + "\"") : '') + extra + ">");
+        })
+            .join('');
+    }
+    else {
+        return '';
+    }
 };
-
 TemplateRenderer.prototype.renderPrefetchLinks = function renderPrefetchLinks (context) {
-    var this$1 = this;
+        var this$1 = this;
 
-  var shouldPrefetch = this.options.shouldPrefetch;
-  if (this.prefetchFiles) {
-    var usedAsyncFiles = this.getUsedAsyncFiles(context);
-    var alreadyRendered = function (file) {
-      return usedAsyncFiles && usedAsyncFiles.some(function (f) { return f.file === file; })
-    };
-    return this.prefetchFiles.map(function (ref) {
-        var file = ref.file;
-        var fileWithoutQuery = ref.fileWithoutQuery;
-        var asType = ref.asType;
-
-      if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-        return ''
-      }
-      if (alreadyRendered(file)) {
-        return ''
-      }
-      return ("<link rel=\"prefetch\" href=\"" + (this$1.publicPath) + file + "\">")
-    }).join('')
-  } else {
-    return ''
-  }
+    var shouldPrefetch = this.options.shouldPrefetch;
+    if (this.prefetchFiles) {
+        var usedAsyncFiles = this.getUsedAsyncFiles(context);
+        var alreadyRendered = function (file) {
+            return usedAsyncFiles && usedAsyncFiles.some(function (f) { return f.file === file; });
+        };
+        return this.prefetchFiles
+            .map(function (ref) {
+                var file = ref.file;
+                var fileWithoutQuery = ref.fileWithoutQuery;
+                var asType = ref.asType;
+
+            if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+                return '';
+            }
+            if (alreadyRendered(file)) {
+                return '';
+            }
+            return ("<link rel=\"prefetch\" href=\"" + (this$1.publicPath) + file + "\">");
+        })
+            .join('');
+    }
+    else {
+        return '';
+    }
 };
-
 TemplateRenderer.prototype.renderState = function renderState (context, options) {
-  var ref = options || {};
-    var contextKey = ref.contextKey; if ( contextKey === void 0 ) contextKey = 'state';
-    var windowKey = ref.windowKey; if ( windowKey === void 0 ) windowKey = '__INITIAL_STATE__';
-  var state = this.serialize(context[contextKey]);
-  var autoRemove = '';
-  var nonceAttr = context.nonce ? (" nonce=\"" + (context.nonce) + "\"") : '';
-  return context[contextKey]
-    ? ("<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>")
-    : ''
+    var ref = options || {};
+        var contextKey = ref.contextKey; if ( contextKey === void 0 ) contextKey = 'state';
+        var windowKey = ref.windowKey; if ( windowKey === void 0 ) windowKey = '__INITIAL_STATE__';
+    var state = this.serialize(context[contextKey]);
+    var autoRemove = '';
+    var nonceAttr = context.nonce ? (" nonce=\"" + (context.nonce) + "\"") : '';
+    return context[contextKey]
+        ? ("<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>")
+        : '';
 };
-
 TemplateRenderer.prototype.renderScripts = function renderScripts (context) {
-    var this$1 = this;
+        var this$1 = this;
 
-  if (this.clientManifest) {
-    var initial = this.preloadFiles.filter(function (ref) {
-        var file = ref.file;
-
-        return isJS(file);
-      });
-    var async = (this.getUsedAsyncFiles(context) || []).filter(function (ref) {
-        var file = ref.file;
-
-        return isJS(file);
-      });
-    var needed = [initial[0]].concat(async, initial.slice(1));
-    return needed.map(function (ref) {
-        var file = ref.file;
-
-      return ("<script src=\"" + (this$1.publicPath) + file + "\" defer></script>")
-    }).join('')
-  } else {
-    return ''
-  }
-};
+    if (this.clientManifest) {
+        var initial = this.preloadFiles.filter(function (ref) {
+                var file = ref.file;
+
+                return isJS(file);
+            });
+        var async = (this.getUsedAsyncFiles(context) || []).filter(function (ref) {
+                var file = ref.file;
+
+                return isJS(file);
+            });
+        var needed = [initial[0]].concat(async, initial.slice(1));
+        return needed
+            .map(function (ref) {
+                var file = ref.file;
 
+            return ("<script src=\"" + (this$1.publicPath) + file + "\" defer></script>");
+        })
+            .join('');
+    }
+    else {
+        return '';
+    }
+};
 TemplateRenderer.prototype.getUsedAsyncFiles = function getUsedAsyncFiles (context) {
-  if (!context._mappedFiles && context._registeredComponents && this.mapFiles) {
-    var registered = Array.from(context._registeredComponents);
-    context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-  }
-  return context._mappedFiles
+    if (!context._mappedFiles &&
+        context._registeredComponents &&
+        this.mapFiles) {
+        var registered = Array.from(context._registeredComponents);
+        context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
+    }
+    return context._mappedFiles;
 };
-
 // create a transform stream
 TemplateRenderer.prototype.createStream = function createStream (context) {
-  if (!this.parsedTemplate) {
-    throw new Error('createStream cannot be called without a template.')
-  }
-  return new TemplateStream(this, this.parsedTemplate, context || {})
+    if (!this.parsedTemplate) {
+        throw new Error('createStream cannot be called without a template.');
+    }
+    //@ts-expect-error
+    return new TemplateStream(this, this.parsedTemplate, context || {});
 };
+function normalizeFile(file) {
+    var withoutQuery = file.replace(/\?.*/, '');
+    var extension = path.extname(withoutQuery).slice(1);
+    return {
+        file: file,
+        extension: extension,
+        fileWithoutQuery: withoutQuery,
+        asType: getPreloadType(extension),
+    };
+}
+function getPreloadType(ext) {
+    if (ext === 'js') {
+        return 'script';
+    }
+    else if (ext === 'css') {
+        return 'style';
+    }
+    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
+        return 'image';
+    }
+    else if (/woff2?|ttf|otf|eot/.test(ext)) {
+        return 'font';
+    }
+    else {
+        // not exhausting all possibilities here, but above covers common cases
+        return '';
+    }
+}
+
+/* @flow */
+function createRenderer(ref) {
+    if ( ref === void 0 ) ref = {};
+    var modules = ref.modules; if ( modules === void 0 ) modules = [];
+    var directives = ref.directives; if ( directives === void 0 ) directives = {};
+    var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = function () { return false; };
+    var template = ref.template;
+    var inject = ref.inject;
+    var cache = ref.cache;
+    var shouldPreload = ref.shouldPreload;
+    var shouldPrefetch = ref.shouldPrefetch;
+    var clientManifest = ref.clientManifest;
+    var serializer = ref.serializer;
+
+    var render = createRenderFunction(modules, directives, isUnaryTag, cache);
+    var templateRenderer = new TemplateRenderer({
+        template: template,
+        inject: inject,
+        // @ts-expect-error
+        shouldPreload: shouldPreload,
+        // @ts-expect-error
+        shouldPrefetch: shouldPrefetch,
+        clientManifest: clientManifest,
+        serializer: serializer,
+    });
+    return {
+        renderToString: function renderToString(component, context, cb) {
+            var assign;
 
-function normalizeFile (file) {
-  var withoutQuery = file.replace(/\?.*/, '');
-  var extension = path.extname(withoutQuery).slice(1);
-  return {
-    file: file,
-    extension: extension,
-    fileWithoutQuery: withoutQuery,
-    asType: getPreloadType(extension)
-  }
-}
-
-function getPreloadType (ext) {
-  if (ext === 'js') {
-    return 'script'
-  } else if (ext === 'css') {
-    return 'style'
-  } else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
-    return 'image'
-  } else if (/woff2?|ttf|otf|eot/.test(ext)) {
-    return 'font'
-  } else {
-    // not exhausting all possibilities here, but above covers common cases
-    return ''
-  }
-}
-
-/*  */
-
-
-
-
-
-
-
-
-function createRenderer (ref) {
-  if ( ref === void 0 ) ref = {};
-  var modules = ref.modules; if ( modules === void 0 ) modules = [];
-  var directives = ref.directives; if ( directives === void 0 ) directives = {};
-  var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = (function () { return false; });
-  var template = ref.template;
-  var inject = ref.inject;
-  var cache = ref.cache;
-  var shouldPreload = ref.shouldPreload;
-  var shouldPrefetch = ref.shouldPrefetch;
-  var clientManifest = ref.clientManifest;
-  var serializer = ref.serializer;
-
-  var render = createRenderFunction(modules, directives, isUnaryTag, cache);
-  var templateRenderer = new TemplateRenderer({
-    template: template,
-    inject: inject,
-    shouldPreload: shouldPreload,
-    shouldPrefetch: shouldPrefetch,
-    clientManifest: clientManifest,
-    serializer: serializer
-  });
-
-  return {
-    renderToString: function renderToString (
-      component,
-      context,
-      cb
-    ) {
-      var assign;
-
-      if (typeof context === 'function') {
-        cb = context;
-        context = {};
-      }
-      if (context) {
-        templateRenderer.bindRenderFns(context);
-      }
-
-      // no callback, return Promise
-      var promise;
-      if (!cb) {
-        ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
-      }
-
-      var result = '';
-      var write = createWriteFunction(function (text) {
-        result += text;
-        return false
-      }, cb);
-      try {
-        render(component, write, context, function (err) {
-          if (err) {
-            return cb(err)
-          }
-          if (context && context.rendered) {
-            context.rendered(context);
-          }
-          if (template) {
+            if (typeof context === 'function') {
+                cb = context;
+                context = {};
+            }
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            // no callback, return Promise
+            var promise;
+            if (!cb) {
+                ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
+            }
+            var result = '';
+            var write = createWriteFunction(function (text) {
+                result += text;
+                return false;
+            }, cb);
             try {
-              var res = templateRenderer.render(result, context);
-              if (typeof res !== 'string') {
-                // function template returning promise
-                res
-                  .then(function (html) { return cb(null, html); })
-                  .catch(cb);
-              } else {
-                cb(null, res);
-              }
-            } catch (e) {
-              cb(e);
-            }
-          } else {
-            cb(null, result);
-          }
-        });
-      } catch (e) {
-        cb(e);
-      }
-
-      return promise
-    },
-
-    renderToStream: function renderToStream (
-      component,
-      context
-    ) {
-      if (context) {
-        templateRenderer.bindRenderFns(context);
-      }
-      var renderStream = new RenderStream(function (write, done) {
-        render(component, write, context, done);
-      });
-      if (!template) {
-        if (context && context.rendered) {
-          var rendered = context.rendered;
-          renderStream.once('beforeEnd', function () {
-            rendered(context);
-          });
-        }
-        return renderStream
-      } else if (typeof template === 'function') {
-        throw new Error("function template is only supported in renderToString.")
-      } else {
-        var templateStream = templateRenderer.createStream(context);
-        renderStream.on('error', function (err) {
-          templateStream.emit('error', err);
-        });
-        renderStream.pipe(templateStream);
-        if (context && context.rendered) {
-          var rendered$1 = context.rendered;
-          renderStream.once('beforeEnd', function () {
-            rendered$1(context);
-          });
-        }
-        return templateStream
-      }
-    }
-  }
+                // @ts-expect-error TODO improve
+                render(component, write, context, function (err) {
+                    if (err) {
+                        return cb(err);
+                    }
+                    if (context && context.rendered) {
+                        context.rendered(context);
+                    }
+                    if (template) {
+                        try {
+                            var res = templateRenderer.render(result, context);
+                            if (typeof res !== 'string') {
+                                // function template returning promise
+                                res.then(function (html) { return cb(null, html); }).catch(cb);
+                            }
+                            else {
+                                cb(null, res);
+                            }
+                        }
+                        catch (e) {
+                            cb(e);
+                        }
+                    }
+                    else {
+                        cb(null, result);
+                    }
+                });
+            }
+            catch (e) {
+                cb(e);
+            }
+            return promise;
+        },
+        renderToStream: function renderToStream(component, context) {
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            var renderStream = new RenderStream(function (write, done) {
+                // @ts-expect-error
+                render(component, write, context, done);
+            });
+            if (!template) {
+                // @ts-expect-error
+                if (context && context.rendered) {
+                    // @ts-expect-error
+                    var rendered = context.rendered;
+                    renderStream.once('beforeEnd', function () {
+                        rendered(context);
+                    });
+                }
+                return renderStream;
+            }
+            else if (typeof template === 'function') {
+                throw new Error("function template is only supported in renderToString.");
+            }
+            else {
+                var templateStream = templateRenderer.createStream(context);
+                renderStream.on('error', function (err) {
+                    templateStream.emit('error', err);
+                });
+                renderStream.pipe(templateStream);
+                //@ts-expect-error
+                if (context && context.rendered) {
+                    //@ts-expect-error
+                    var rendered$1 = context.rendered;
+                    renderStream.once('beforeEnd', function () {
+                        rendered$1(context);
+                    });
+                }
+                return templateStream;
+            }
+        },
+    };
 }
 
 var vm = require('vm');
 var path$1 = require('path');
 var resolve = require('resolve');
 var NativeModule = require('module');
-
-function createSandbox (context) {
-  var sandbox = {
-    Buffer: Buffer,
-    console: console,
-    process: process,
-    setTimeout: setTimeout,
-    setInterval: setInterval,
-    setImmediate: setImmediate,
-    clearTimeout: clearTimeout,
-    clearInterval: clearInterval,
-    clearImmediate: clearImmediate,
-    __VUE_SSR_CONTEXT__: context
-  };
-  sandbox.global = sandbox;
-  return sandbox
-}
-
-function compileModule (files, basedir, runInNewContext) {
-  var compiledScripts = {};
-  var resolvedModules = {};
-
-  function getCompiledScript (filename) {
-    if (compiledScripts[filename]) {
-      return compiledScripts[filename]
-    }
-    var code = files[filename];
-    var wrapper = NativeModule.wrap(code);
-    var script = new vm.Script(wrapper, {
-      filename: filename,
-      displayErrors: true
-    });
-    compiledScripts[filename] = script;
-    return script
-  }
-
-  function evaluateModule (filename, sandbox, evaluatedFiles) {
-    if ( evaluatedFiles === void 0 ) evaluatedFiles = {};
-
-    if (evaluatedFiles[filename]) {
-      return evaluatedFiles[filename]
-    }
-
-    var script = getCompiledScript(filename);
-    var compiledWrapper = runInNewContext === false
-      ? script.runInThisContext()
-      : script.runInNewContext(sandbox);
-    var m = { exports: {}};
-    var r = function (file) {
-      file = path$1.posix.join('.', file);
-      if (files[file]) {
-        return evaluateModule(file, sandbox, evaluatedFiles)
-      } else if (basedir) {
-        return require(
-          resolvedModules[file] ||
-          (resolvedModules[file] = resolve.sync(file, { basedir: basedir }))
-        )
-      } else {
-        return require(file)
-      }
+function createSandbox(context) {
+    var sandbox = {
+        Buffer: Buffer,
+        console: console,
+        process: process,
+        setTimeout: setTimeout,
+        setInterval: setInterval,
+        setImmediate: setImmediate,
+        clearTimeout: clearTimeout,
+        clearInterval: clearInterval,
+        clearImmediate: clearImmediate,
+        __VUE_SSR_CONTEXT__: context,
     };
-    compiledWrapper.call(m.exports, m.exports, r, m);
+    // @ts-expect-error
+    sandbox.global = sandbox;
+    return sandbox;
+}
+function compileModule(files, basedir, runInNewContext) {
+    var compiledScripts = {};
+    var resolvedModules = {};
+    function getCompiledScript(filename) {
+        if (compiledScripts[filename]) {
+            return compiledScripts[filename];
+        }
+        var code = files[filename];
+        var wrapper = NativeModule.wrap(code);
+        var script = new vm.Script(wrapper, {
+            filename: filename,
+            displayErrors: true,
+        });
+        compiledScripts[filename] = script;
+        return script;
+    }
+    function evaluateModule(filename, sandbox, evaluatedFiles) {
+        if ( evaluatedFiles === void 0 ) evaluatedFiles = {};
 
-    var res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-      ? m.exports.default
-      : m.exports;
-    evaluatedFiles[filename] = res;
-    return res
-  }
-  return evaluateModule
+        if (evaluatedFiles[filename]) {
+            return evaluatedFiles[filename];
+        }
+        var script = getCompiledScript(filename);
+        var compiledWrapper = runInNewContext === false
+            ? script.runInThisContext()
+            : script.runInNewContext(sandbox);
+        var m = { exports: {} };
+        var r = function (file) {
+            file = path$1.posix.join('.', file);
+            if (files[file]) {
+                return evaluateModule(file, sandbox, evaluatedFiles);
+            }
+            else if (basedir) {
+                return require(resolvedModules[file] ||
+                    (resolvedModules[file] = resolve.sync(file, { basedir: basedir })));
+            }
+            else {
+                return require(file);
+            }
+        };
+        compiledWrapper.call(m.exports, m.exports, r, m);
+        var res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
+            ? // @ts-expect-error
+                m.exports.default
+            : m.exports;
+        evaluatedFiles[filename] = res;
+        return res;
+    }
+    return evaluateModule;
+}
+function deepClone(val) {
+    if (isPlainObject(val)) {
+        var res = {};
+        for (var key in val) {
+            res[key] = deepClone(val[key]);
+        }
+        return res;
+    }
+    else if (Array.isArray(val)) {
+        return val.slice();
+    }
+    else {
+        return val;
+    }
 }
+function createBundleRunner(entry, files, basedir, runInNewContext) {
+    var evaluate = compileModule(files, basedir, runInNewContext);
+    if (runInNewContext !== false && runInNewContext !== 'once') {
+        // new context mode: creates a fresh context and re-evaluate the bundle
+        // on each render. Ensures entire application state is fresh for each
+        // render, but incurs extra evaluation cost.
+        return function (userContext) {
+            if ( userContext === void 0 ) userContext = {};
 
-function deepClone (val) {
-  if (isPlainObject(val)) {
-    var res = {};
-    for (var key in val) {
-      res[key] = deepClone(val[key]);
-    }
-    return res
-  } else if (Array.isArray(val)) {
-    return val.slice()
-  } else {
-    return val
-  }
-}
-
-function createBundleRunner (entry, files, basedir, runInNewContext) {
-  var evaluate = compileModule(files, basedir, runInNewContext);
-  if (runInNewContext !== false && runInNewContext !== 'once') {
-    // new context mode: creates a fresh context and re-evaluate the bundle
-    // on each render. Ensures entire application state is fresh for each
-    // render, but incurs extra evaluation cost.
-    return function (userContext) {
-      if ( userContext === void 0 ) userContext = {};
-
-      return new Promise(function (resolve) {
-      userContext._registeredComponents = new Set();
-      var res = evaluate(entry, createSandbox(userContext));
-      resolve(typeof res === 'function' ? res(userContext) : res);
-    });
+            return new Promise(function (resolve) {
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            var res = evaluate(entry, createSandbox(userContext));
+            resolve(typeof res === 'function' ? res(userContext) : res);
+        });
+        };
     }
-  } else {
-    // direct mode: instead of re-evaluating the whole bundle on
-    // each render, it simply calls the exported function. This avoids the
-    // module evaluation costs but requires the source code to be structured
-    // slightly differently.
-    var runner; // lazy creation so that errors can be caught by user
-    var initialContext;
-    return function (userContext) {
-      if ( userContext === void 0 ) userContext = {};
-
-      return new Promise(function (resolve) {
-      if (!runner) {
-        var sandbox = runInNewContext === 'once'
-          ? createSandbox()
-          : global;
-        // the initial context is only used for collecting possible non-component
-        // styles injected by vue-style-loader.
-        initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
-        runner = evaluate(entry, sandbox);
-        // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-        // to prevent cross-request pollution.
-        delete sandbox.__VUE_SSR_CONTEXT__;
-        if (typeof runner !== 'function') {
-          throw new Error(
-            'bundle export should be a function when using ' +
-            '{ runInNewContext: false }.'
-          )
-        }
-      }
-      userContext._registeredComponents = new Set();
-
-      // vue-style-loader styles imported outside of component lifecycle hooks
-      if (initialContext._styles) {
-        userContext._styles = deepClone(initialContext._styles);
-        // #6353 ensure "styles" is exposed even if no styles are injected
-        // in component lifecycles.
-        // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-        var renderStyles = initialContext._renderStyles;
-        if (renderStyles) {
-          Object.defineProperty(userContext, 'styles', {
-            enumerable: true,
-            get: function get () {
-              return renderStyles(userContext._styles)
+    else {
+        // direct mode: instead of re-evaluating the whole bundle on
+        // each render, it simply calls the exported function. This avoids the
+        // module evaluation costs but requires the source code to be structured
+        // slightly differently.
+        var runner; // lazy creation so that errors can be caught by user
+        var initialContext;
+        return function (userContext) {
+            if ( userContext === void 0 ) userContext = {};
+
+            return new Promise(function (resolve) {
+            if (!runner) {
+                var sandbox = runInNewContext === 'once' ? createSandbox() : global;
+                // the initial context is only used for collecting possible non-component
+                // styles injected by vue-style-loader.
+                // @ts-expect-error
+                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
+                runner = evaluate(entry, sandbox);
+                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+                // to prevent cross-request pollution.
+                // @ts-expect-error
+                delete sandbox.__VUE_SSR_CONTEXT__;
+                if (typeof runner !== 'function') {
+                    throw new Error('bundle export should be a function when using ' +
+                        '{ runInNewContext: false }.');
+                }
             }
-          });
-        }
-      }
-
-      resolve(runner(userContext));
-    });
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            // vue-style-loader styles imported outside of component lifecycle hooks
+            if (initialContext._styles) {
+                // @ts-expect-error
+                userContext._styles = deepClone(initialContext._styles);
+                // #6353 ensure "styles" is exposed even if no styles are injected
+                // in component lifecycles.
+                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+                var renderStyles = initialContext._renderStyles;
+                if (renderStyles) {
+                    Object.defineProperty(userContext, 'styles', {
+                        enumerable: true,
+                        get: function get() {
+                            // @ts-expect-error
+                            return renderStyles(userContext._styles);
+                        },
+                    });
+                }
+            }
+            resolve(runner(userContext));
+        });
+        };
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 var SourceMapConsumer = require('source-map').SourceMapConsumer;
-
 var filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
-
-function createSourceMapConsumers (rawMaps) {
-  var maps = {};
-  Object.keys(rawMaps).forEach(function (file) {
-    maps[file] = new SourceMapConsumer(rawMaps[file]);
-  });
-  return maps
-}
-
-function rewriteErrorTrace (e, mapConsumers) {
-  if (e && typeof e.stack === 'string') {
-    e.stack = e.stack.split('\n').map(function (line) {
-      return rewriteTraceLine(line, mapConsumers)
-    }).join('\n');
-  }
-}
-
-function rewriteTraceLine (trace, mapConsumers) {
-  var m = trace.match(filenameRE);
-  var map = m && mapConsumers[m[1]];
-  if (m != null && map) {
-    var originalPosition = map.originalPositionFor({
-      line: Number(m[2]),
-      column: Number(m[3])
+function createSourceMapConsumers(rawMaps) {
+    var maps = {};
+    Object.keys(rawMaps).forEach(function (file) {
+        maps[file] = new SourceMapConsumer(rawMaps[file]);
     });
-    if (originalPosition.source != null) {
-      var source = originalPosition.source;
-      var line = originalPosition.line;
-      var column = originalPosition.column;
-      var mappedPosition = "(" + (source.replace(/^webpack:\/\/\//, '')) + ":" + (String(line)) + ":" + (String(column)) + ")";
-      return trace.replace(filenameRE, mappedPosition)
-    } else {
-      return trace
+    return maps;
+}
+function rewriteErrorTrace(e, mapConsumers) {
+    if (e && typeof e.stack === 'string') {
+        e.stack = e.stack
+            .split('\n')
+            .map(function (line) {
+            return rewriteTraceLine(line, mapConsumers);
+        })
+            .join('\n');
+    }
+}
+function rewriteTraceLine(trace, mapConsumers) {
+    var m = trace.match(filenameRE);
+    var map = m && mapConsumers[m[1]];
+    if (m != null && map) {
+        var originalPosition = map.originalPositionFor({
+            line: Number(m[2]),
+            column: Number(m[3]),
+        });
+        if (originalPosition.source != null) {
+            var source = originalPosition.source;
+            var line = originalPosition.line;
+            var column = originalPosition.column;
+            var mappedPosition = "(" + (source.replace(/^webpack:\/\/\//, '')) + ":" + (String(line)) + ":" + (String(column)) + ")";
+            return trace.replace(filenameRE, mappedPosition);
+        }
+        else {
+            return trace;
+        }
+    }
+    else {
+        return trace;
     }
-  } else {
-    return trace
-  }
 }
 
-/*  */
-
+/* @flow */
 var fs = require('fs');
 var path$2 = require('path');
 var PassThrough = require('stream').PassThrough;
-
-var INVALID_MSG =
-  'Invalid server-rendering bundle format. Should be a string ' +
-  'or a bundle Object of type:\n\n' +
-"{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";
-
-// The render bundle can either be a string (single bundled file)
-// or a bundle manifest object generated by vue-ssr-webpack-plugin.
-
-
-function createBundleRendererCreator (
-  createRenderer
-) {
-  return function createBundleRenderer (
-    bundle,
-    rendererOptions
-  ) {
-    if ( rendererOptions === void 0 ) rendererOptions = {};
-
-    var files, entry, maps;
-    var basedir = rendererOptions.basedir;
-
-    // load bundle if given filepath
-    if (
-      typeof bundle === 'string' &&
-      /\.js(on)?$/.test(bundle) &&
-      path$2.isAbsolute(bundle)
-    ) {
-      if (fs.existsSync(bundle)) {
-        var isJSON = /\.json$/.test(bundle);
-        basedir = basedir || path$2.dirname(bundle);
-        bundle = fs.readFileSync(bundle, 'utf-8');
-        if (isJSON) {
-          try {
-            bundle = JSON.parse(bundle);
-          } catch (e) {
-            throw new Error(("Invalid JSON bundle file: " + bundle))
-          }
-        }
-      } else {
-        throw new Error(("Cannot locate bundle file: " + bundle))
-      }
-    }
-
-    if (typeof bundle === 'object') {
-      entry = bundle.entry;
-      files = bundle.files;
-      basedir = basedir || bundle.basedir;
-      maps = createSourceMapConsumers(bundle.maps);
-      if (typeof entry !== 'string' || typeof files !== 'object') {
-        throw new Error(INVALID_MSG)
-      }
-    } else if (typeof bundle === 'string') {
-      entry = '__vue_ssr_bundle__';
-      files = { '__vue_ssr_bundle__': bundle };
-      maps = {};
-    } else {
-      throw new Error(INVALID_MSG)
-    }
-
-    var renderer = createRenderer(rendererOptions);
-
-    var run = createBundleRunner(
-      entry,
-      files,
-      basedir,
-      rendererOptions.runInNewContext
-    );
-
-    return {
-      renderToString: function (context, cb) {
-        var assign;
-
-        if (typeof context === 'function') {
-          cb = context;
-          context = {};
-        }
-
-        var promise;
-        if (!cb) {
-          ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
+var INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
+    'or a bundle Object of type:\n\n' +
+    "{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";
+function createBundleRendererCreator(createRenderer) {
+    return function createBundleRenderer(bundle, rendererOptions) {
+        if ( rendererOptions === void 0 ) rendererOptions = {};
+
+        var files, entry, maps;
+        var basedir = rendererOptions.basedir;
+        // load bundle if given filepath
+        if (typeof bundle === 'string' &&
+            /\.js(on)?$/.test(bundle) &&
+            path$2.isAbsolute(bundle)) {
+            if (fs.existsSync(bundle)) {
+                var isJSON = /\.json$/.test(bundle);
+                basedir = basedir || path$2.dirname(bundle);
+                bundle = fs.readFileSync(bundle, 'utf-8');
+                if (isJSON) {
+                    try {
+                        // @ts-expect-error
+                        bundle = JSON.parse(bundle);
+                    }
+                    catch (e) {
+                        throw new Error(("Invalid JSON bundle file: " + bundle));
+                    }
+                }
+            }
+            else {
+                throw new Error(("Cannot locate bundle file: " + bundle));
+            }
         }
-
-        run(context).catch(function (err) {
-          rewriteErrorTrace(err, maps);
-          cb(err);
-        }).then(function (app) {
-          if (app) {
-            renderer.renderToString(app, context, function (err, res) {
-              rewriteErrorTrace(err, maps);
-              cb(err, res);
-            });
-          }
-        });
-
-        return promise
-      },
-
-      renderToStream: function (context) {
-        var res = new PassThrough();
-        run(context).catch(function (err) {
-          rewriteErrorTrace(err, maps);
-          // avoid emitting synchronously before user can
-          // attach error listener
-          process.nextTick(function () {
-            res.emit('error', err);
-          });
-        }).then(function (app) {
-          if (app) {
-            var renderStream = renderer.renderToStream(app, context);
-
-            renderStream.on('error', function (err) {
-              rewriteErrorTrace(err, maps);
-              res.emit('error', err);
-            });
-
-            // relay HTMLStream special events
-            if (rendererOptions && rendererOptions.template) {
-              renderStream.on('beforeStart', function () {
-                res.emit('beforeStart');
-              });
-              renderStream.on('beforeEnd', function () {
-                res.emit('beforeEnd');
-              });
+        if (typeof bundle === 'object') {
+            entry = bundle.entry;
+            files = bundle.files;
+            basedir = basedir || bundle.basedir;
+            maps = createSourceMapConsumers(bundle.maps);
+            if (typeof entry !== 'string' || typeof files !== 'object') {
+                throw new Error(INVALID_MSG);
             }
-
-            renderStream.pipe(res);
-          }
-        });
-
-        return res
-      }
-    }
-  }
+        }
+        else if (typeof bundle === 'string') {
+            entry = '__vue_ssr_bundle__';
+            files = { __vue_ssr_bundle__: bundle };
+            maps = {};
+        }
+        else {
+            throw new Error(INVALID_MSG);
+        }
+        var renderer = createRenderer(rendererOptions);
+        var run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
+        return {
+            renderToString: function (context, cb) {
+                var assign;
+
+                if (typeof context === 'function') {
+                    cb = context;
+                    context = {};
+                }
+                var promise;
+                if (!cb) {
+                    ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
+                }
+                run(context)
+                    .catch(function (err) {
+                    rewriteErrorTrace(err, maps);
+                    cb(err);
+                })
+                    .then(function (app) {
+                    if (app) {
+                        //@ts-expect-error
+                        renderer.renderToString(app, context, function (err, res) {
+                            rewriteErrorTrace(err, maps);
+                            cb(err, res);
+                        });
+                    }
+                });
+                return promise;
+            },
+            renderToStream: function (context) {
+                var res = new PassThrough();
+                run(context)
+                    .catch(function (err) {
+                    rewriteErrorTrace(err, maps);
+                    // avoid emitting synchronously before user can
+                    // attach error listener
+                    process.nextTick(function () {
+                        res.emit('error', err);
+                    });
+                })
+                    .then(function (app) {
+                    if (app) {
+                        //@ts-expect-error
+                        var renderStream = renderer.renderToStream(app, context);
+                        renderStream.on('error', function (err) {
+                            rewriteErrorTrace(err, maps);
+                            res.emit('error', err);
+                        });
+                        // relay HTMLStream special events
+                        if (rendererOptions && rendererOptions.template) {
+                            renderStream.on('beforeStart', function () {
+                                res.emit('beforeStart');
+                            });
+                            renderStream.on('beforeEnd', function () {
+                                res.emit('beforeEnd');
+                            });
+                        }
+                        renderStream.pipe(res);
+                    }
+                });
+                return res;
+            },
+        };
+    };
 }
 
-/*  */
-
+/* @flow */
 process.env.VUE_ENV = 'server';
-
-function createRenderer$1 (options) {
-  if ( options === void 0 ) options = {};
-
-  return createRenderer(extend(extend({}, options), {
-    isUnaryTag: isUnaryTag,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    modules: modules,
-    // user can provide server-side implementations for custom directives
-    // when creating the renderer.
-    directives: extend(baseDirectives, options.directives)
-  }))
+function createRenderer$1(options) {
+    if ( options === void 0 ) options = {};
+
+    return createRenderer(extend(extend({}, options), {
+        isUnaryTag: isUnaryTag,
+        canBeLeftOpenTag: canBeLeftOpenTag,
+        modules: modules,
+        // user can provide server-side implementations for custom directives
+        // when creating the renderer.
+        directives: extend(baseDirectives, options.directives),
+    }));
 }
-
 var createBundleRenderer = createBundleRendererCreator(createRenderer$1);
 
 exports.createRenderer = createRenderer$1;
diff --git a/packages/vue-server-renderer/build.prod.js b/packages/vue-server-renderer/build.prod.js
index 36c5aa30b08..e14d8fd57a1 100644
--- a/packages/vue-server-renderer/build.prod.js
+++ b/packages/vue-server-renderer/build.prod.js
@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,t=(e=require("he"))&&"object"==typeof e&&"default"in e?e.default:e,r=Object.freeze({});function n(e){return null==e}function i(e){return null!=e}function o(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function s(e){return null!==e&&"object"==typeof e}var c=Object.prototype.toString;function u(e){return"[object Object]"===c.call(e)}function l(e){return i(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function f(e){return null==e?"":Array.isArray(e)||u(e)&&e.toString===c?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)return e.splice(r,1)}}var y=Object.prototype.hasOwnProperty;function g(e,t){return y.call(e,t)}function b(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var _=/-(\w)/g,w=b(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),x=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),S=/\B([A-Z])/g,$=b(function(e){return e.replace(S,"-$1").toLowerCase()});Function.prototype.bind;function A(e,t){for(var r in t)e[r]=t[r];return e}function O(e){for(var t={},r=0;r<e.length;r++)e[r]&&A(t,e[r]);return t}function k(e,t,r){}var C=function(e,t,r){return!1},T=function(e){return e};function F(e,t){if(e===t)return!0;var r=s(e),n=s(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return F(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),c=Object.keys(t);return a.length===c.length&&a.every(function(r){return F(e[r],t[r])})}catch(e){return!1}}function j(e,t){for(var r=0;r<e.length;r++)if(F(e[r],t))return r;return-1}function P(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var E=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),N=/[>/="'\u0009\u000a\u000c\u0020]/,L=function(e){return N.test(e)},I=function(e){return E(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},M={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},R={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function D(e){return e.replace(/[<>"&]/g,U)}function U(e){return R[e]||e}var z={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},B=d("input,textarea,option,select,progress"),q=d("contenteditable,draggable,spellcheck"),J=d("events,caret,typing,plaintext-only"),H=function(e,t){return V(t)||"false"===t?"false":"contenteditable"===e&&J(t)?t:"true"},K=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,translate,truespeed,typemustmatch,visible"),V=function(e){return null==e||!1===e};function W(e,t){if(K(e)){if(!V(t))return" "+e+'="'+e+'"'}else{if(q(e))return" "+e+'="'+D(H(e,t))+'"';if(!V(t))return" "+e+'="'+D(String(t))+'"'}return""}var Z=function(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},X={child:{configurable:!0}};X.child.get=function(){return this.componentInstance},Object.defineProperties(Z.prototype,X);var G=function(e){void 0===e&&(e="");var t=new Z;return t.text=e,t.isComment=!0,t};function Q(e){return new Z(void 0,void 0,void 0,String(e))}function Y(e,t,r){var n=new Z(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ee(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var te,re="__proto__"in{},ne="undefined"!=typeof window,ie="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,oe=ie&&WXEnvironment.platform.toLowerCase(),ae=ne&&window.navigator.userAgent.toLowerCase(),se=ae&&/msie|trident/.test(ae),ce=(ae&&ae.indexOf("msie 9.0"),ae&&ae.indexOf("edge/")>0),ue=(ae&&ae.indexOf("android"),ae&&/iphone|ipad|ipod|ios/.test(ae),ae&&/chrome\/\d+/.test(ae),ae&&/phantomjs/.test(ae),ae&&ae.match(/firefox\/(\d+)/),{}.watch);if(ne)try{var le={};Object.defineProperty(le,"passive",{get:function(){}}),window.addEventListener("test-passive",null,le)}catch(e){}var fe=function(){return void 0===te&&(te=!ne&&!ie&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),te};ne&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function pe(e){return"function"==typeof e&&/native code/.test(e.toString())}var de,ve="undefined"!=typeof Symbol&&pe(Symbol)&&"undefined"!=typeof Reflect&&pe(Reflect.ownKeys);de="undefined"!=typeof Set&&pe(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var he="data-server-rendered",me=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],ye={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:C,isReservedAttr:C,isUnknownElement:C,getTagNamespace:k,parsePlatformTagName:T,mustUseProp:C,async:!0,_lifecycleHooks:me},ge=k,be=0,_e=function(){this.id=be++,this.subs=[]};_e.prototype.addSub=function(e){this.subs.push(e)},_e.prototype.removeSub=function(e){m(this.subs,e)},_e.prototype.depend=function(){_e.target&&_e.target.addDep(this)},_e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},_e.target=null;var we=[];function xe(e){we.push(e),_e.target=e}function Se(){we.pop(),_e.target=we[we.length-1]}var $e=Array.prototype,Ae=Object.create($e);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=$e[e];ee(Ae,e,function(){for(var r=[],n=arguments.length;n--;)r[n]=arguments[n];var i,o=t.apply(this,r),a=this.__ob__;switch(e){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var Oe=Object.getOwnPropertyNames(Ae),ke=!0;function Ce(e){ke=e}var Te=function(e){var t;this.value=e,this.dep=new _e,this.vmCount=0,ee(e,"__ob__",this),Array.isArray(e)?(re?(t=Ae,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ee(e,o,t[o])}}(e,Ae,Oe),this.observeArray(e)):this.walk(e)};function Fe(e,t){var r;if(s(e)&&!(e instanceof Z))return g(e,"__ob__")&&e.__ob__ instanceof Te?r=e.__ob__:ke&&!fe()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Te(e)),t&&r&&r.vmCount++,r}function je(e,t,r,n,i){var o=new _e,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&Fe(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return _e.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&Fe(t),o.notify())}})}}function Pe(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(je(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}Te.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)je(e,t[r])},Te.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)Fe(e[t])};var Ee=ye.optionMergeStrategies;function Ne(e,t){if(!t)return e;for(var r,n,i,o=ve?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],g(e,r)?n!==i&&u(n)&&u(i)&&Ne(n,i):Pe(e,r,i));return e}function Le(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ne(n,i):i}:t?e?function(){return Ne("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ie(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Me(e,t,r,n){var i=Object.create(e||null);return t?A(i,t):i}Ee.data=function(e,t,r){return r?Le(e,t,r):t&&"function"!=typeof t?e:Le(e,t)},me.forEach(function(e){Ee[e]=Ie}),["component","directive","filter"].forEach(function(e){Ee[e+"s"]=Me}),Ee.watch=function(e,t,r,n){if(e===ue&&(e=void 0),t===ue&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ee.props=Ee.methods=Ee.inject=Ee.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ee.provide=Le;var Re=function(e,t){return void 0===t?e:t};function De(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[w(i)]={type:null});else if(u(r))for(var a in r)i=r[a],o[w(a)]=u(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(u(r))for(var o in r){var a=r[o];n[o]=u(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=De(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=De(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)g(e,o)||s(o);function s(n){var i=Ee[n]||Re;a[n]=i(e[n],t[n],r,n)}return a}function Ue(e,t,r,n){if("string"==typeof r){var i=e[t];if(g(i,r))return i[r];var o=w(r);if(g(i,o))return i[o];var a=x(o);return g(i,a)?i[a]:i[r]||i[o]||i[a]}}function ze(e,t,r,n){var i=t[e],o=!g(r,e),a=r[e],s=Je(Boolean,i.type);if(s>-1)if(o&&!g(i,"default"))a=!1;else if(""===a||a===$(e)){var c=Je(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!g(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Be(t.type)?n.call(e):n}(n,i,e);var u=ke;Ce(!0),Fe(a),Ce(u)}return a}function Be(e){var t=e&&e.toString().match(/^\s*function (\w+)/);return t?t[1]:""}function qe(e,t){return Be(e)===Be(t)}function Je(e,t){if(!Array.isArray(t))return qe(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(qe(t[r],e))return r;return-1}function He(e,t,r){xe();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){Ve(e,n,"errorCaptured hook")}}Ve(e,t,r)}finally{Se()}}function Ke(e,t,r,n,i){var o;try{(o=r?e.apply(t,r):e.call(t))&&!o._isVue&&l(o)&&!o._handled&&(o.catch(function(e){return He(e,n,i+" (Promise/async)")}),o._handled=!0)}catch(e){He(e,n,i)}return o}function Ve(e,t,r){!function(e,t,r){if(!ne&&!ie||"undefined"==typeof console)throw e;console.error(e)}(e)}var We=[];if("undefined"!=typeof Promise&&pe(Promise));else if(se||"undefined"==typeof MutationObserver||!pe(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&pe(setImmediate);else{var Ze=new MutationObserver(function(){var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}),Xe=document.createTextNode(String(1));Ze.observe(Xe,{characterData:!0})}function Ge(e,t){return{staticClass:Ye(e.staticClass,t.staticClass),class:i(e.class)?[e.class,t.class]:t.class}}function Qe(e,t){return i(e)||i(t)?Ye(e,et(t)):""}function Ye(e,t){return e?t?e+" "+t:e:t||""}function et(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,o=e.length;n<o;n++)i(t=et(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):s(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var tt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),rt=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var nt=b(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function it(e){var t=ot(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ot(e){return Array.isArray(e)?O(e):"string"==typeof e?nt(e):e}function at(e){var t="";for(var r in e){var n=e[r],i=$(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=st(i,n[o]);else t+=st(i,n)}return t}function st(e,t){return"string"==typeof t||"number"==typeof t&&z[e]||0===t?e+":"+t+";":""}var ct=[function(e){var t=e.data.attrs,r="",o=e.parent&&e.parent.componentOptions;if(n(o)||!1!==o.Ctor.options.inheritAttrs)for(var a=e.parent;i(a);)i(a.data)&&i(a.data.attrs)&&(t=A(A({},t),a.data.attrs)),a=a.parent;if(n(t))return r;for(var s in t)L(s)||"style"!==s&&(r+=W(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",o=e.parent;i(o);)o.data&&o.data.domProps&&(t=A(A({},t),o.data.domProps)),o=o.parent;if(n(t))return r;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)Y(e,t[s],!0);else if("textContent"===s)Y(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)Y(e,t[s],!1);else{var c=M[s]||s.toLowerCase();!I(c)||i(a)&&i(a[c])||(r+=W(c,t[s]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;i(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Ge(n.data,t));for(;i(r=r.parent);)r&&r.data&&(t=Ge(t,r.data));return Qe(t.staticClass,t.class)}(e);if(""!==t)return' class="'+D(t)+'"'},function(e){var t=at(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=it(i.data))&&A(n,r);(r=it(e.data))&&A(n,r);for(var o=e;o=o.parent;)o.data&&(r=it(o.data))&&A(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(D(t))}];function ut(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function lt(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var ft={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&j(r,ut(a))>-1&&lt(a);else if(F(r,ut(a)))return void lt(a)}}},pt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),dt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),vt=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ht=800,mt=function(e){return e},yt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:mt;if(yt===mt)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function gt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=ht?yt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var bt=function(e){function t(t){var r=this;e.call(this),this.buffer="",this.render=t,this.expectedSize=0,this.write=gt(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),this.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)}}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,o(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):n(this.next)?this.tryRender():this.tryNext()},t}(require("stream").Readable),_t=function(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&wt(t,"get"),this.has=t&&wt(t,"has"),this.next=this.next.bind(this)};function wt(e,t){var r=e[t];return n(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}_t.prototype.next=function(){for(;;){var e=this.renderStates[this.renderStates.length-1];if(n(e))return this.done();switch(e.type){case"Element":case"Fragment":var t=e.children,r=e.total,i=e.rendered++;if(i<r)return this.renderNode(t[i],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();var o=e.buffer,a=e.bufferIndex,s=e.componentBuffer,c=e.key,u={html:o[a],components:s[a]};if(this.cache.set(c,u),0===a)this.write.caching=!1;else{o[a-1]+=u.html;var l=s[a-1];u.components.forEach(function(e){return l.add(e)})}o.length=a,s.length=a}}};var xt=/[\w).+\-_$\]]/;function St(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&xt.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=$t(i,o[n]);return i}function $t(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var At=/\{\{((?:.|\r?\n)+?)\}\}/g,Ot=/[-.*+?^${}()|[\]\/\\]/g,kt=b(function(e){var t=e[0].replace(Ot,"\\$&"),r=e[1].replace(Ot,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function Ct(e,t){console.error("[Vue compiler]: "+e)}function Tt(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Ft(e,t,r,n,i){(e.props||(e.props=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function jt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function Pt(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Dt({name:t,value:r},n))}function Et(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Dt({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Nt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Lt(e,t,n,i,o,a,s,c){var u;(i=i||r).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Nt("!",t,c)),i.once&&(delete i.once,t=Nt("~",t,c)),i.passive&&(delete i.passive,t=Nt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Dt({value:n.trim(),dynamic:c},s);i!==r&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function It(e,t,r){var n=Mt(e,":"+t)||Mt(e,"v-bind:"+t);if(null!=n)return St(n);if(!1!==r){var i=Mt(e,t);if(null!=i)return JSON.stringify(i)}}function Mt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Rt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Dt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var Ut={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Mt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=It(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var zt,Bt,qt,Jt,Ht,Kt,Vt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Mt(e,"style");r&&(e.staticStyle=JSON.stringify(nt(r)));var n=It(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Wt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Zt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Xt="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Gt="((?:"+Xt+"\\:)?"+Xt+")",Qt=new RegExp("^<"+Gt),Yt=/^\s*(\/?)>/,er=new RegExp("^<\\/"+Gt+"[^>]*>"),tr=/^<!DOCTYPE [^>]+>/i,rr=/^<!\--/,nr=/^<!\[/,ir=d("script,style,textarea",!0),or={},ar={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},sr=/&(?:lt|gt|quot|amp|#39);/g,cr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,ur=d("pre,textarea",!0),lr=function(e,t){return e&&ur(e)&&"\n"===t[0]};function fr(e,t){var r=t?cr:sr;return e.replace(r,function(e){return ar[e]})}function pr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=dr(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function dr(e,t){var r=function(e){if(e=e.trim(),zt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<zt-1)return(Jt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Jt),key:'"'+e.slice(Jt+1)+'"'}:{exp:e,key:null};Bt=e,Jt=Ht=Kt=0;for(;!hr();)mr(qt=vr())?gr(qt):91===qt&&yr(qt);return{exp:e.slice(0,Ht),key:e.slice(Ht+1,Kt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function vr(){return Bt.charCodeAt(++Jt)}function hr(){return Jt>=zt}function mr(e){return 34===e||39===e}function yr(e){var t=1;for(Ht=Jt;!hr();)if(mr(e=vr()))gr(e);else if(91===e&&t++,93===e&&t--,0===t){Kt=Jt;break}}function gr(e){for(var t=e;!hr()&&(e=vr())!==t;);}var br,_r,wr,xr,Sr,$r,Ar,Or,kr=/^@|^v-on:/,Cr=/^v-|^@|^:|^#/,Tr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,jr=/^\(|\)$/g,Pr=/^\[.*\]$/,Er=/:(.*)$/,Nr=/^:|^\.|^v-bind:/,Lr=/\.[^.\]]+(?=[^\]]*$)/g,Ir=/^v-slot(:|$)|^#/,Mr=/[\r\n]/,Rr=/\s+/g,Dr=b(t.decode),Ur="_empty_";function zr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Wr(t),rawAttrsMap:{},parent:r,children:[]}}function Br(e,t){br=t.warn||Ct,$r=t.isPreTag||C,Ar=t.mustUseProp||C,Or=t.getTagNamespace||C;t.isReservedTag;wr=Tt(t.modules,"transformNode"),xr=Tt(t.modules,"preTransformNode"),Sr=Tt(t.modules,"postTransformNode"),_r=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=qr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Hr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Hr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),$r(e.tag)&&(c=!1);for(var f=0;f<Sr.length;f++)Sr[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||C,s=t.canBeLeftOpenTag||C,c=0;e;){if(r=e,n&&ir(n)){var u=0,l=n.toLowerCase(),f=or[l]||(or[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,function(e,r,n){return u=n.length,ir(l)||"noscript"===l||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),lr(l,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-p.length,e=p,O(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(rr.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),S(v+3);continue}}if(nr.test(e)){var h=e.indexOf("]>");if(h>=0){S(h+2);continue}}var m=e.match(tr);if(m){S(m[0].length);continue}var y=e.match(er);if(y){var g=c;S(y[0].length),O(y[1],g,c);continue}var b=$();if(b){A(b),lr(b.tagName,e)&&S(1);continue}}var _=void 0,w=void 0,x=void 0;if(d>=0){for(w=e.slice(d);!(er.test(w)||Qt.test(w)||rr.test(w)||nr.test(w)||(x=w.indexOf("<",1))<0);)d+=x,w=e.slice(d);_=e.substring(0,d)}d<0&&(_=e),_&&S(_.length),t.chars&&_&&t.chars(_,c-_.length,c)}if(e===r){t.chars&&t.chars(e);break}}function S(t){c+=t,e=e.substring(t)}function $(){var t=e.match(Qt);if(t){var r,n,i={tagName:t[1],attrs:[],start:c};for(S(t[0].length);!(r=e.match(Yt))&&(n=e.match(Zt)||e.match(Wt));)n.start=c,S(n[0].length),n.end=c,i.attrs.push(n);if(r)return i.unarySlash=r[1],S(r[0].length),i.end=c,i}}function A(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&vt(r)&&O(n),s(r)&&n===r&&O(r));for(var u=a(r)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===r&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:fr(v,h)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:f,start:e.start,end:e.end}),n=r),t.start&&t.start(r,f,u,e.start,e.end)}function O(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}O()}(e,{warn:br,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||Or(e);se&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Zr.test(n.name)||(n.name=n.name.replace(Xr,""),t.push(n))}return t}(o));var d,v=zr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||fe()||(v.forbidden=!0);for(var h=0;h<xr.length;h++)v=xr[h](v,t)||v;s||(!function(e){null!=Mt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),$r(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Jr(v),function(e){var t=Mt(e,"v-if");if(t)e.if=t,Hr(e,{exp:t,block:e});else{null!=Mt(e,"v-else")&&(e.else=!0);var r=Mt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Mt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!se||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u,l,f=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Dr(e):f.length?a?"condense"===a&&Mr.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(Rr," ")),!s&&" "!==e&&(u=function(e,t){var r=t?kt(t):At;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=St(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,_r))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function qr(e,t){var r,n;(n=It(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=It(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Mt(e,"scope"),e.slotScope=t||Mt(e,"slot-scope")):(t=Mt(e,"slot-scope"))&&(e.slotScope=t);var r=It(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||jt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Rt(e,Ir);if(n){var i=Kr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Ur}}else{var s=Rt(e,Ir);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=Kr(s),l=u.name,f=u.dynamic,p=c[l]=zr("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=p,!0}),p.slotScope=s.value||Ur,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=It(e,"name"))}(e),function(e){var t;(t=It(e,"is"))&&(e.component=t);null!=Mt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<wr.length;i++)e=wr[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Cr.test(n))if(e.hasBindings=!0,(a=Vr(n.replace(Cr,"")))&&(n=n.replace(Lr,"")),Nr.test(n))n=n.replace(Nr,""),o=St(o),(c=Pr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),a.camel&&!c&&(n=w(n)),a.sync&&(s=dr(o,"$event"),c?Lt(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Lt(e,"update:"+w(n),s,null,!1,0,u[t]),$(n)!==w(n)&&Lt(e,"update:"+$(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Ar(e.tag,e.attrsMap.type,n)?Ft(e,n,o,u[t],c):jt(e,n,o,u[t],c);else if(kr.test(n))n=n.replace(kr,""),(c=Pr.test(n))&&(n=n.slice(1,-1)),Lt(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Cr,"")).match(Er),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Pr.test(f)&&(f=f.slice(1,-1),c=!0)),Et(e,n,i,o,f,c,a,u[t])}else jt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&Ar(e.tag,e.attrsMap.type,n)&&Ft(e,n,"true",u[t])}(e),e}function Jr(e){var t;if(t=Mt(e,"v-for")){var r=function(e){var t=e.match(Tr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(jr,""),i=n.match(Fr);i?(r.alias=n.replace(Fr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&A(e,r)}}function Hr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Kr(e){var t=e.name.replace(Ir,"");return t||"#"!==e.name[0]&&(t="default"),Pr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Vr(e){var t=e.match(Lr);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function Wr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Zr=/^xmlns:NS\d+/,Xr=/^NS\d+:/;function Gr(e){return zr(e.tag,e.attrsList.slice(),e.parent)}var Qr=[Ut,Vt,{preTransformNode:function(e,t){if("input"===e.tag){var r,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(r=It(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Mt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Mt(e,"v-else",!0),s=Mt(e,"v-else-if",!0),c=Gr(e);Jr(c),Pt(c,"type","checkbox"),qr(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,Hr(c,{exp:c.if,block:c});var u=Gr(e);Mt(u,"v-for",!0),Pt(u,"type","radio"),qr(u,t),Hr(c,{exp:"("+r+")==='radio'"+o,block:u});var l=Gr(e);return Mt(l,"v-for",!0),Pt(l,":type",r),qr(l,t),Hr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],Yr="__r";var en={expectHTML:!0,modules:Qr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return pr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+dr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lt(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null",o=It(e,"true-value")||"true",a=It(e,"false-value")||"false";Ft(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Lt(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+dr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+dr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+dr(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null";Ft(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Lt(e,"change",dr(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return pr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Yr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=dr(t,l);c&&(f="if($event.target.composing)return;"+f),Ft(e,"value","("+t+")"),Lt(e,u,f,null,!0),(s||a)&&Lt(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&Ft(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Ft(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:pt,mustUseProp:function(e,t,r){return"value"===r&&B(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:dt,isReservedTag:function(e){return tt(e)||rt(e)},getTagNamespace:function(e){return rt(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Qr)},tn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,rn=/\([^)]*?\);*$/,nn=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,on={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},an={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},sn=function(e){return"if("+e+")return null;"},cn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:sn("$event.target !== $event.currentTarget"),ctrl:sn("!$event.ctrlKey"),shift:sn("!$event.shiftKey"),alt:sn("!$event.altKey"),meta:sn("!$event.metaKey"),left:sn("'button' in $event && $event.button !== 0"),middle:sn("'button' in $event && $event.button !== 1"),right:sn("'button' in $event && $event.button !== 2")};function un(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=ln(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function ln(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return ln(e)}).join(",")+"]";var t=nn.test(e.value),r=tn.test(e.value),n=nn.test(e.value.replace(rn,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(cn[s])o+=cn[s],on[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=sn(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(fn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+"($event)":r?"return ("+e.value+")($event)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function fn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=on[e],n=an[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var pn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:k},dn=function(e){this.options=e,this.warn=e.warn||Ct,this.transforms=Tt(e.modules,"transformCode"),this.dataGenFns=Tt(e.modules,"genData"),this.directives=A(A({},pn),e.directives);var t=e.isReservedTag||C;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function vn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return hn(e,t);if(e.once&&!e.onceProcessed)return mn(e,t);if(e.for&&!e.forProcessed)return gn(e,t);if(e.if&&!e.ifProcessed)return yn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=xn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?On((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:xn(t,r,!0);return"_c("+e+","+bn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=bn(e,t));var i=e.inlineTemplate?null:xn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return xn(e,t)||"void 0"}function hn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+vn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function mn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return yn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+vn(e,t)+","+t.onceId+++","+r+")":vn(e,t)}return hn(e,t)}function yn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?mn(e,r):vn(e,r)}}(e.ifConditions.slice(),t,r,n)}function gn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||vn)(e,t)+"})"}function bn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+On(e.attrs)+","),e.props&&(r+="domProps:"+On(e.props)+","),e.events&&(r+=un(e.events,!1)+","),e.nativeEvents&&(r+=un(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||_n(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Ur||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return wn(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?vn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+On(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function _n(e){return 1===e.type&&("slot"===e.tag||e.children.some(_n))}function wn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return yn(e,t,wn,"null");if(e.for&&!e.forProcessed)return gn(e,t,wn);var n=e.slotScope===Ur?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(xn(e,t)||"undefined")+":undefined":xn(e,t)||"undefined":vn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function xn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||vn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(Sn(i)||i.ifConditions&&i.ifConditions.some(function(e){return Sn(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||$n;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Sn(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function $n(e,t){return 1===e.type?vn(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):An(e);var r}function An(e){return"_v("+(2===e.type?e.expression:kn(JSON.stringify(e.text)))+")"}function On(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=kn(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function kn(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Cn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function Tn(e,t){return Cn.test(t)?(t=t.replace(/^'|'$/g,'"'),q(e)&&'"false"'!==t&&(t='"true"'),{type:Nn,value:K(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:In,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var Fn,jn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Pn(e,t){e&&(Fn=t.isReservedTag||C,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!Fn(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=jn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!En(e.name)})}(t);var i=function(e){e.ssrOptimizability!==jn.FULL&&(t.ssrOptimizability=n?jn.PARTIAL:jn.SELF)};n&&(t.ssrOptimizability=jn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var c=1,u=t.ifConditions.length;c<u;c++){var l=t.ifConditions[c].block;e(l,r),i(l)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=jn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:jn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===jn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=jn.FULL}(e,!0))}var En=d("text,html,show,on,bind,model,pre,cloak,once");var Nn=0,Ln=1,In=2;function Mn(e,t){if(e.for&&!e.forProcessed)return gn(e,t,Mn);if(e.if&&!e.ifProcessed)return yn(e,t,Mn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===jn.FULL?zn(e,t):Dn(e,t)||"void 0";switch(e.ssrOptimizability){case jn.FULL:return function(e,t){return"_ssrNode("+Bn(e,t)+")"}(e,t);case jn.SELF:return function(e,t){var r=Dn(e,t,!0);return"_ssrNode("+Kn(Jn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case jn.CHILDREN:return Rn(e,t,!0);case jn.PARTIAL:return Rn(e,t,!1);default:return vn(e,t)}}function Rn(e,t,r){var n=e.plain?void 0:bn(e,t),i=r?"["+zn(e,t)+"]":Dn(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Dn(e,t,r){return xn(e,t,r,Mn,Un)}function Un(e,t){return 1===e.type?Mn(e,t):An(e)}function zn(e,t){return e.children.length?"_ssrNode("+Kn(Hn(e,t))+")":""}function Bn(e,t){return"("+Kn(qn(e,t))+")"}function qn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:In,value:gn(e,t,Bn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:In,value:yn(e,t,Bn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Hn(e,t);var r=Jn(e,t),n=Hn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:Nn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Jn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:Nn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return Tn(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=M[n]||n.toLowerCase(),!I(n)||t&&t.some(function(e){return e.name===n})||r.push(Tn(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:In,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:In,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:Nn,value:' class="'+JSON.parse(n)+'"'}]:[{type:In,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:In,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:Nn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:Nn,value:" "+t.options.scopeId}),u.push({type:Nn,value:">"}),u}function Hn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:In,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Ln,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Ln,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,qn(i,t));else if(2===i.type)r.push({type:Ln,value:i.expression});else if(3===i.type){var o=D(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:Nn,value:o})}}return r}(e.children,t):[]}function Kn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===Nn?r+=o.value:o.type===Ln?(n(),t.push("_ssrEscape("+o.value+")")):o.type===In&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Vn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),k}}function Wn(e){var t=Object.create(null);return function(r,n,i){(n=A({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Vn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Vn(e,c)}),t[o]=s}}var Zn,Xn=(Zn=function(e,t){var r=Br(e.trim(),t);Pn(r,t);var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?Mn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=A(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=Zn(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Wn(t)}})(en),Gn=(Xn.compile,Xn.compileToFunctions);function Qn(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Yn(e){return a(e)?[Q(e)]:Array.isArray(e)?function e(t,r){var s=[];var c,u,l,f;for(c=0;c<t.length;c++)n(u=t[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ei((u=e(u,(r||"")+"_"+c))[0])&&ei(f)&&(s[l]=Q(f.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?ei(f)?s[l]=Q(f.text+u):""!==u&&s.push(Q(u)):ei(u)&&ei(f)?s[l]=Q(f.text+u.text):(o(t._isVList)&&i(u.tag)&&n(u.key)&&i(r)&&(u.key="__vlist"+r+"_"+c+"__"),s.push(u)));return s}(e):void 0}function ei(e){return i(e)&&i(e.text)&&!1===e.isComment}var ti={_ssrEscape:D,_ssrNode:function(e,t,r,n){return new ri(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(s(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:W,_ssrAttrs:function(e){var t="";for(var r in e)L(r)||(t+=W(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=M[r]||r.toLowerCase();I(n)&&(t+=W(n,e[r]))}return t},_ssrClass:function(e,t){var r=Qe(e,t);return""===r?r:' class="'+D(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&A(n,e);t&&A(n,ot(t));r&&A(n,r);var i=at(n);return""===i?i:" style="+JSON.stringify(D(i))}};var ri=function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?Qn(r):2===n?Yn(r):r:void 0};var ni=new de;function ii(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!s(t)||Object.isFrozen(t)||t instanceof Z)return;if(t.__ob__){var a=t.__ob__.dep.id;if(r.has(a))return;r.add(a)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,ni),ni.clear()}var oi=b(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function ai(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return Ke(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)Ke(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function si(e,t,r,n,o){if(i(t)){if(g(t,r))return e[r]=t[r],o||delete t[r],!0;if(g(t,n))return e[r]=t[n],o||delete t[n],!0}return!1}var ci=1,ui=2;function li(e,t,r,c,u,l){return(Array.isArray(r)||a(r))&&(u=c,c=r,r=void 0),o(l)&&(u=ui),function(e,t,r,a,c){if(i(r)&&i(r.__ob__))return G();i(r)&&i(r.is)&&(t=r.is);if(!t)return G();Array.isArray(a)&&"function"==typeof a[0]&&((r=r||{}).scopedSlots={default:a[0]},a.length=0);c===ui?a=Yn(a):c===ci&&(a=Qn(a));var u,l;if("string"==typeof t){var f;l=e.$vnode&&e.$vnode.ns||ye.getTagNamespace(t),u=r&&r.pre||!i(f=Ue(e.$options,"components",t))?new Z(t,r,a,void 0,void 0,e):Ki(f,r,e,a,t)}else u=Ki(t,r,e,a);return Array.isArray(u)?u:i(u)?(i(l)&&function e(t,r,a){t.ns=r;"foreignObject"===t.tag&&(r=void 0,a=!0);if(i(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];i(u.tag)&&(n(u.ns)||o(a)&&"svg"!==u.tag)&&e(u,r,a)}}(u,l),i(r)&&function(e){s(e.style)&&ii(e.style);s(e.class)&&ii(e.class)}(r),u):G()}(e,t,r,c,u)}function fi(e,t){var r,n,o,a,c;if(Array.isArray(e)||"string"==typeof e)for(r=new Array(e.length),n=0,o=e.length;n<o;n++)r[n]=t(e[n],n);else if("number"==typeof e)for(r=new Array(e),n=0;n<e;n++)r[n]=t(n+1,n);else if(s(e))if(ve&&e[Symbol.iterator]){r=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)r.push(t(l.value,r.length)),l=u.next()}else for(a=Object.keys(e),r=new Array(a.length),n=0,o=a.length;n<o;n++)c=a[n],r[n]=t(e[c],c,n);return i(r)||(r=[]),r._isVList=!0,r}function pi(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=A(A({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function di(e){return Ue(this.$options,"filters",e)||T}function vi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function hi(e,t,r,n,i){var o=ye.keyCodes[t]||r;return i&&n&&!ye.keyCodes[t]?vi(i,n):o?vi(o,e):n?$(n)!==t:void 0}function mi(e,t,r,n,i){if(r)if(s(r)){var o;Array.isArray(r)&&(r=O(r));var a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||ye.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(a),u=$(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var c in r)a(c)}else;return e}function yi(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(bi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function gi(e,t,r){return bi(e,"__once__"+t+(r?"_"+r:""),!0),e}function bi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&_i(e[n],t+"_"+n,r);else _i(e,t,r)}function _i(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function wi(e,t){if(t)if(u(t)){var r=e.on=e.on?A({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function xi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?xi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function Si(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function $i(e,t){return"string"==typeof e?t+e:e}function Ai(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Oi)&&delete r[u];return r}function Oi(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ki(e,t,n){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&n&&n!==r&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Ci(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Ti(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ee(i,"$stable",a),ee(i,"$key",s),ee(i,"$hasNormal",o),i}function Ci(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Yn(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Ti(e,t){return function(){return e[t]}}var Fi,ji=null;function Pi(e,t){return(e.__esModule||ve&&"Module"===e[Symbol.toStringTag])&&(e=e.default),s(e)?t.extend(e):e}function Ei(e,t){Fi.$on(e,t)}function Ni(e,t){Fi.$off(e,t)}function Li(e,t){var r=Fi;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ii(e,t,r){Fi=e,function(e,t,r,i,a,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=oi(c),n(u)||(n(l)?(n(u.fns)&&(u=e[c]=ai(u,s)),o(f.once)&&(u=e[c]=a(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)n(e[c])&&i((f=oi(c)).name,t[c],f.capture)}(t,r||{},Ei,Ni,Li,e),Fi=void 0}function Mi(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Ri(e,t){xe();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)Ke(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),Se()}var Di=Date.now;if(ne&&!se){var Ui=window.performance;Ui&&"function"==typeof Ui.now&&Di()>document.createEvent("Event").timeStamp&&(Di=function(){return Ui.now()})}function zi(e,t,n,i,a){var s,c=this,u=a.options;g(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=o(u._compiled),f=!l;this.data=e,this.props=t,this.children=n,this.parent=i,this.listeners=e.on||r,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=ve?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&g(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||ki(e.scopedSlots,c.$slots=Ai(n,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ki(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ki(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=li(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return li(s,e,t,r,n,f)}}function Bi(e,t,r,n,i){var o=function(e){var t=new Z(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function qi(e,t){for(var r in t)e[w(r)]=t[r]}!function(e){e._o=gi,e._n=p,e._s=f,e._l=fi,e._t=pi,e._q=F,e._i=j,e._m=yi,e._f=di,e._k=hi,e._b=mi,e._v=Q,e._e=G,e._u=xi,e._g=wi,e._d=Si,e._p=$i}(zi.prototype);var Ji={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ji.prepatch(r,r)}else{(e.componentInstance=Vi(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var n=t.componentOptions;!function(e,t,n,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==r&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||r,e.$listeners=n||r,t&&e.$options.props){Ce(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=ze(d,v,t,e)}Ce(!0),e.$options.propsData=t}n=n||r;var h=e.$options._parentListeners;e.$options._parentListeners=n,Ii(e,n,h),u&&(e.$slots=Ai(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Ri(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,Mi(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Ri(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,Mi(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Ri(t,"deactivated")}}(t,!0):t.$destroy())}},Hi=Object.keys(Ji);function Ki(e,t,a,c,u){if(!n(e)){var f=a.$options._base;if(s(e)&&(e=f.extend(e)),"function"==typeof e){var p;if(n(e.cid)&&void 0===(e=function(e,t){if(o(e.error)&&i(e.errorComp))return e.errorComp;if(i(e.resolved))return e.resolved;var r=ji;if(r&&i(e.owners)&&-1===e.owners.indexOf(r)&&e.owners.push(r),o(e.loading)&&i(e.loadingComp))return e.loadingComp;if(r&&!i(e.owners)){var a=e.owners=[r],c=!0,u=null,f=null;r.$on("hook:destroyed",function(){return m(a,r)});var p=function(e){for(var t=0,r=a.length;t<r;t++)a[t].$forceUpdate();e&&(a.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=P(function(r){e.resolved=Pi(r,t),c?a.length=0:p(!0)}),v=P(function(t){i(e.errorComp)&&(e.error=!0,p(!0))}),h=e(d,v);return s(h)&&(l(h)?n(e.resolved)&&h.then(d,v):l(h.component)&&(h.component.then(d,v),i(h.error)&&(e.errorComp=Pi(h.error,t)),i(h.loading)&&(e.loadingComp=Pi(h.loading,t),0===h.delay?e.loading=!0:u=setTimeout(function(){u=null,n(e.resolved)&&n(e.error)&&(e.loading=!0,p(!1))},h.delay||200)),i(h.timeout)&&(f=setTimeout(function(){f=null,n(e.resolved)&&v(null)},h.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=e,f)))return function(e,t,r,n,i){var o=G();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(p,t,a,c,u);t=t||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&A(t.extendOptions,i),(r=t.options=De(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),i(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[n],s=t.model.callback;i(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[n]=[s].concat(a)):o[n]=s}(e.options,t);var d=function(e,t,r){var o=t.options.props;if(!n(o)){var a={},s=e.attrs,c=e.props;if(i(s)||i(c))for(var u in o){var l=$(u);si(a,c,u,l,!0)||si(a,s,u,l,!1)}return a}}(t,e);if(o(e.options.functional))return function(e,t,n,o,a){var s=e.options,c={},u=s.props;if(i(u))for(var l in u)c[l]=ze(l,u,t||r);else i(n.attrs)&&qi(c,n.attrs),i(n.props)&&qi(c,n.props);var f=new zi(n,c,a,o,e),p=s.render.call(null,f._c,f);if(p instanceof Z)return Bi(p,n,f.parent,s);if(Array.isArray(p)){for(var d=Yn(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Bi(d[h],n,f.parent,s);return v}}(e,d,t,a,c);var v=t.on;if(t.on=t.nativeOn,o(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Hi.length;r++){var n=Hi[r],i=t[n],o=Ji[n];i===o||i&&i._merged||(t[n]=i?Wi(o,i):o)}}(t);var y=e.options.name||u;return new Z("vue-component-"+e.cid+(y?"-"+y:""),t,void 0,void 0,void 0,a,{Ctor:e,propsData:d,listeners:v,tag:u,children:c},p)}}}function Vi(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return i(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function Wi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var Zi=Object.create(null),Xi=function(e){Zi[e]||(Zi[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},Gi=function(e,t){var r=t?ge(t):"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},Qi=function(e){var t=e.$options,r=t.render,i=t.template,o=t._scopeId;if(n(r)){if(!i)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=Gn(i,{scopeId:o,warn:Gi},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function Yi(e,t,r){var n=e.$options.serverPrefetch;if(i(n)){Array.isArray(n)||(n=[n]);try{for(var o=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&o.push(c)}return void Promise.all(o).then(t).catch(r)}catch(e){r(e)}}t()}function eo(e,t,r){e.isString?function(e,t){var r=t.write,i=t.next;if(n(e.children)||0===e.children.length)r(e.open+(e.close||""),i);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,i)}}(e,r):i(e.componentOptions)?ro(e,t,r):i(e.tag)?function(e,t,r){var a=r.write,s=r.next;o(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[he]="true");e.fnOptions&&to(e.fnOptions,a);var c=function(e,t){var r,o="<"+e.tag,a=t.directives,s=t.modules;n(e.data)&&function e(t){var r=t.parent;return i(r)&&(i(r.data)||e(r))}(e)&&(e.data={});if(i(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=Ue(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;i(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var d=0;d<s.length;d++){var v=s[d](e);v&&(o+=v)}}var h=t.activeInstance;i(h)&&h!==e.context&&i(r=h.$options._scopeId)&&(o+=" "+r);if(i(e.fnScopeId))o+=" "+e.fnScopeId;else for(;i(e);)i(r=e.context.$options._scopeId)&&(o+=" "+r),e=e.parent;return o+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))a(c,s);else if(n(e.children)||0===e.children.length)a(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),a(c,s)}}(e,t,r):o(e.isComment)?i(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=Ki(n,o,c,a,s);u?u.componentOptions?ro(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):eo(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:D(String(e.text)),r.next)}function to(e,t){var r=e._ssrRegister;return t.caching&&i(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function ro(e,t,r){var o=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=to(c.options,o);if(i(u)&&i(f)&&i(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void io(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;i(h)?h(v,function(n){!0===n&&i(m)?m(v,function(e){i(p)&&p(s),e.components.forEach(function(e){return e(s)}),o(e.html,a)}):no(e,t,v,r)}):i(m)&&m(v,function(n){i(n)?(i(p)&&p(s),n.components.forEach(function(e){return e(s)}),o(n.html,a)):no(e,t,v,r)})}else i(u)&&n(f)&&Xi("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),i(u)&&n(l)&&Xi('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),io(e,t,r)}function no(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),io(e,t,n)}function io(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Vi(e,r.activeInstance);Qi(i);var o=r.done;Yi(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),eo(o,t,r)},o)}function oo(e,t,r,n){return function(i,o,a,s){Zi=Object.create(null);var c=new _t({activeInstance:i,userContext:a,write:o,done:s,renderNode:eo,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;A(t.prototype,ti),t.FunctionalRenderContext&&A(t.FunctionalRenderContext.prototype,ti)}}(i),Qi(i);Yi(i,function(){eo(i._render(),!0,c)},s)}}var ao=function(e){return/\.js(\?[^.]+)?$/.test(e)};function so(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var co=function(e){function t(t,r,n){e.call(this),this.started=!1,this.renderer=t,this.template=r,this.context=n||{},this.inject=t.inject}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(require("stream").Transform),uo=require("lodash.template"),lo={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function fo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var po=require("path"),vo=require("serialize-javascript"),ho=function(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:uo(e.slice(0,r),lo),neck:uo(e.slice(r,n),lo),tail:uo(e.slice(n+t.length),lo)}}(t):t:null,this.serialize=e.serializer||function(e){return vo(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(mo),this.prefetchFiles=(r.async||[]).map(mo),this.mapFiles=fo(r)}};function mo(e){var t=e.replace(/\?.*/,""),r=po.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:yo(r)}}function yo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}ho.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},ho.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},ho.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},ho.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},ho.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},ho.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},ho.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},ho.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey;void 0===n&&(n="state");var i=r.windowKey;void 0===i&&(i="__INITIAL_STATE__");var o=this.serialize(e[n]),a=e.nonce?' nonce="'+e.nonce+'"':"";return e[n]?"<script"+a+">window."+i+"="+o+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},ho.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return ao(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return ao(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},ho.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(mo)}return e._mappedFiles},ho.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new co(this,this.parsedTemplate,e||{})};var go=require("vm"),bo=require("path"),_o=require("resolve"),wo=require("module");function xo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function So(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=wo.wrap(r),o=new go.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=bo.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=_o.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function $o(e,t,r,n){var i,o,a=So(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,xo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?xo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(u(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))})}}var Ao=require("source-map").SourceMapConsumer,Oo=/\(([^)]+\.js):(\d+):(\d+)\)$/;function ko(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(Oo),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(Oo,c)}return e}return e}(e,t)}).join("\n"))}var Co=require("fs"),To=require("path"),Fo=require("stream").PassThrough,jo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Po(e){return void 0===e&&(e={}),function(e){void 0===e&&(e={});var t=e.modules;void 0===t&&(t=[]);var r=e.directives;void 0===r&&(r={});var n=e.isUnaryTag;void 0===n&&(n=function(){return!1});var i=e.template,o=e.inject,a=e.cache,s=e.shouldPreload,c=e.shouldPrefetch,u=e.clientManifest,l=e.serializer,f=oo(t,r,n,a),p=new ho({template:i,inject:o,shouldPreload:s,shouldPrefetch:c,clientManifest:u,serializer:l});return{renderToString:function(e,t,r){var n,o;"function"==typeof t&&(r=t,t={}),t&&p.bindRenderFns(t),r||(o=(n=so()).promise,r=n.cb);var a="",s=gt(function(e){return a+=e,!1},r);try{f(e,s,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),i)try{var n=p.render(a,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,a)})}catch(e){r(e)}return o},renderToStream:function(e,t){t&&p.bindRenderFns(t);var r=new bt(function(r,n){f(e,r,t,n)});if(i){if("function"==typeof i)throw new Error("function template is only supported in renderToString.");var n=p.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return n}if(t&&t.rendered){var a=t.rendered;r.once("beforeEnd",function(){a(t)})}return r}}}(A(A({},e),{isUnaryTag:pt,canBeLeftOpenTag:dt,modules:ct,directives:A(ft,e.directives)}))}process.env.VUE_ENV="server";var Eo=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&To.isAbsolute(t)){if(!Co.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||To.dirname(t),t=Co.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new Ao(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(jo)}else{if("string"!=typeof t)throw new Error(jo);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=$o(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=so()).promise,t=r.cb),u(e).catch(function(e){ko(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){ko(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new Fo;return u(e).catch(function(e){ko(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){ko(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(Po);exports.createRenderer=Po,exports.createBundleRenderer=Eo;
\ No newline at end of file
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream"),t=require("he"),r=Object.freeze({});function n(e){return null==e}function i(e){return null!=e}function o(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function s(e){return null!==e&&"object"==typeof e}var c=Object.prototype.toString;function u(e){return"[object Object]"===c.call(e)}function l(e){return i(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function f(e){return null==e?"":Array.isArray(e)||u(e)&&e.toString===c?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)return e.splice(r,1)}}var y=Object.prototype.hasOwnProperty;function g(e,t){return y.call(e,t)}function b(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var _=/-(\w)/g,w=b(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),x=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),S=/\B([A-Z])/g,$=b(function(e){return e.replace(S,"-$1").toLowerCase()});Function.prototype.bind;function A(e,t){for(var r in t)e[r]=t[r];return e}function O(e){for(var t={},r=0;r<e.length;r++)e[r]&&A(t,e[r]);return t}function k(e,t,r){}var C=function(e,t,r){return!1},T=function(e){return e};function F(e,t){if(e===t)return!0;var r=s(e),n=s(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return F(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),c=Object.keys(t);return a.length===c.length&&a.every(function(r){return F(e[r],t[r])})}catch(e){return!1}}function j(e,t){for(var r=0;r<e.length;r++)if(F(e[r],t))return r;return-1}function P(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var E=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),N=/[>/="'\u0009\u000a\u000c\u0020]/,L=function(e){return N.test(e)},I=function(e){return E(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},M={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},R={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function D(e){return e.replace(/[<>"&]/g,U)}function U(e){return R[e]||e}var z={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},B=d("input,textarea,option,select,progress"),q=d("contenteditable,draggable,spellcheck"),J=d("events,caret,typing,plaintext-only"),H=function(e,t){return V(t)||"false"===t?"false":"contenteditable"===e&&J(t)?t:"true"},K=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),V=function(e){return null==e||!1===e};function W(e,t){if(K(e)){if(!V(t))return" "+e+'="'+e+'"'}else{if(q(e))return" "+e+'="'+D(H(e,t))+'"';if(!V(t))return" "+e+'="'+D(String(t))+'"'}return""}var Z=function(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},X={child:{configurable:!0}};X.child.get=function(){return this.componentInstance},Object.defineProperties(Z.prototype,X);var G=function(e){void 0===e&&(e="");var t=new Z;return t.text=e,t.isComment=!0,t};function Q(e){return new Z(void 0,void 0,void 0,String(e))}function Y(e,t,r){var n=new Z(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ee(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var te,re="__proto__"in{},ne="undefined"!=typeof window,ie="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,oe=ie&&WXEnvironment.platform.toLowerCase(),ae=ne&&window.navigator.userAgent.toLowerCase(),se=ae&&/msie|trident/.test(ae),ce=(ae&&ae.indexOf("msie 9.0"),ae&&ae.indexOf("edge/")>0),ue=(ae&&ae.indexOf("android"),ae&&/iphone|ipad|ipod|ios/.test(ae),ae&&/chrome\/\d+/.test(ae),ae&&/phantomjs/.test(ae),ae&&ae.match(/firefox\/(\d+)/),{}.watch);if(ne)try{var le={};Object.defineProperty(le,"passive",{get:function(){}}),window.addEventListener("test-passive",null,le)}catch(e){}var fe=function(){return void 0===te&&(te=!ne&&!ie&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),te};ne&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function pe(e){return"function"==typeof e&&/native code/.test(e.toString())}var de,ve="undefined"!=typeof Symbol&&pe(Symbol)&&"undefined"!=typeof Reflect&&pe(Reflect.ownKeys);de="undefined"!=typeof Set&&pe(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var he="data-server-rendered",me=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],ye={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:C,isReservedAttr:C,isUnknownElement:C,getTagNamespace:k,parsePlatformTagName:T,mustUseProp:C,async:!0,_lifecycleHooks:me},ge=0,be=function(){this.id=ge++,this.subs=[]};be.prototype.addSub=function(e){this.subs.push(e)},be.prototype.removeSub=function(e){m(this.subs,e)},be.prototype.depend=function(){be.target&&be.target.addDep(this)},be.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},be.target=null;var _e=[];function we(e){_e.push(e),be.target=e}function xe(){_e.pop(),be.target=_e[_e.length-1]}var Se=Array.prototype,$e=Object.create(Se);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=Se[e];ee($e,e,function(){for(var r=[],n=arguments.length;n--;)r[n]=arguments[n];var i,o=t.apply(this,r),a=this.__ob__;switch(e){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var Ae=Object.getOwnPropertyNames($e),Oe=!0;function ke(e){Oe=e}var Ce=function(e){var t;this.value=e,this.dep=new be,this.vmCount=0,ee(e,"__ob__",this),Array.isArray(e)?(re?(t=$e,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ee(e,o,t[o])}}(e,$e,Ae),this.observeArray(e)):this.walk(e)};function Te(e,t){var r;if(s(e)&&!(e instanceof Z))return g(e,"__ob__")&&e.__ob__ instanceof Ce?r=e.__ob__:Oe&&!fe()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Ce(e)),t&&r&&r.vmCount++,r}function Fe(e,t,r,n,i){var o=new be,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&Te(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return be.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&Te(t),o.notify())}})}}function je(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Fe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}Ce.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Fe(e,t[r])},Ce.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)Te(e[t])};var Pe=ye.optionMergeStrategies;function Ee(e,t){if(!t)return e;for(var r,n,i,o=ve?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],g(e,r)?n!==i&&u(n)&&u(i)&&Ee(n,i):je(e,r,i));return e}function Ne(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ee(n,i):i}:t?e?function(){return Ee("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Le(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Ie(e,t,r,n){var i=Object.create(e||null);return t?A(i,t):i}Pe.data=function(e,t,r){return r?Ne(e,t,r):t&&"function"!=typeof t?e:Ne(e,t)},me.forEach(function(e){Pe[e]=Le}),["component","directive","filter"].forEach(function(e){Pe[e+"s"]=Ie}),Pe.watch=function(e,t,r,n){if(e===ue&&(e=void 0),t===ue&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Pe.props=Pe.methods=Pe.inject=Pe.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Pe.provide=Ne;var Me=function(e,t){return void 0===t?e:t};function Re(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[w(i)]={type:null});else if(u(r))for(var a in r)i=r[a],o[w(a)]=u(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(u(r))for(var o in r){var a=r[o];n[o]=u(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=Re(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=Re(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)g(e,o)||s(o);function s(n){var i=Pe[n]||Me;a[n]=i(e[n],t[n],r,n)}return a}function De(e,t,r,n){if("string"==typeof r){var i=e[t];if(g(i,r))return i[r];var o=w(r);if(g(i,o))return i[o];var a=x(o);return g(i,a)?i[a]:i[r]||i[o]||i[a]}}function Ue(e,t,r,n){var i=t[e],o=!g(r,e),a=r[e],s=Je(Boolean,i.type);if(s>-1)if(o&&!g(i,"default"))a=!1;else if(""===a||a===$(e)){var c=Je(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!g(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Be(t.type)?n.call(e):n}(n,i,e);var u=Oe;ke(!0),Te(a),ke(u)}return a}var ze=/^\s*function (\w+)/;function Be(e){var t=e&&e.toString().match(ze);return t?t[1]:""}function qe(e,t){return Be(e)===Be(t)}function Je(e,t){if(!Array.isArray(t))return qe(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(qe(t[r],e))return r;return-1}function He(e,t,r){we();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){Ve(e,n,"errorCaptured hook")}}Ve(e,t,r)}finally{xe()}}function Ke(e,t,r,n,i){var o;try{(o=r?e.apply(t,r):e.call(t))&&!o._isVue&&l(o)&&!o._handled&&(o.catch(function(e){return He(e,n,i+" (Promise/async)")}),o._handled=!0)}catch(e){He(e,n,i)}return o}function Ve(e,t,r){!function(e,t,r){if(!ne&&!ie||"undefined"==typeof console)throw e;console.error(e)}(e)}var We=[];if("undefined"!=typeof Promise&&pe(Promise));else if(se||"undefined"==typeof MutationObserver||!pe(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&pe(setImmediate);else{var Ze=new MutationObserver(function(){var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}),Xe=document.createTextNode(String(1));Ze.observe(Xe,{characterData:!0})}function Ge(e,t){return{staticClass:Ye(e.staticClass,t.staticClass),class:i(e.class)?[e.class,t.class]:t.class}}function Qe(e,t){return i(e)||i(t)?Ye(e,et(t)):""}function Ye(e,t){return e?t?e+" "+t:e:t||""}function et(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,o=e.length;n<o;n++)i(t=et(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):s(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var tt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),rt=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var nt=b(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function it(e){var t=ot(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ot(e){return Array.isArray(e)?O(e):"string"==typeof e?nt(e):e}function at(e){var t="";for(var r in e){var n=e[r],i=$(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=st(i,n[o]);else t+=st(i,n)}return t}function st(e,t){return"string"==typeof t||"number"==typeof t&&z[e]||0===t?e+":"+t+";":""}var ct=[function(e){var t=e.data.attrs,r="",o=e.parent&&e.parent.componentOptions;if(n(o)||!1!==o.Ctor.options.inheritAttrs)for(var a=e.parent;i(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)i(a.data)&&i(a.data.attrs)&&(t=A(A({},t),a.data.attrs)),a=a.parent;if(n(t))return r;for(var s in t)L(s)||"style"!==s&&(r+=W(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",o=e.parent;i(o);)o.data&&o.data.domProps&&(t=A(A({},t),o.data.domProps)),o=o.parent;if(n(t))return r;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)Y(e,t[s],!0);else if("textContent"===s)Y(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)Y(e,f(t[s]),!1);else{var c=M[s]||s.toLowerCase();!I(c)||i(a)&&i(a[c])||(r+=W(c,t[s]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;i(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Ge(n.data,t));for(;i(r=r.parent);)r&&r.data&&(t=Ge(t,r.data));return Qe(t.staticClass,t.class)}(e);if(""!==t)return' class="'+D(t)+'"'},function(e){var t=at(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=it(i.data))&&A(n,r);(r=it(e.data))&&A(n,r);for(var o=e;o=o.parent;)o.data&&(r=it(o.data))&&A(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(D(t))}];function ut(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function lt(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var ft={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&j(r,ut(a))>-1&&lt(a);else if(F(r,ut(a)))return void lt(a)}}},pt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),dt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),vt=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ht=800,mt=function(e){return e},yt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:mt;if(yt===mt)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function gt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=ht?yt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var bt=function(e){function t(t){var r=this;e.call(this),this.buffer="",this.render=t,this.expectedSize=0,this.write=gt(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),this.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)}}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,o(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):n(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),_t=function(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&wt(t,"get"),this.has=t&&wt(t,"has"),this.next=this.next.bind(this)};function wt(e,t){var r=e[t];return n(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}_t.prototype.next=function(){for(;;){var e=this.renderStates[this.renderStates.length-1];if(n(e))return this.done();switch(e.type){case"Element":case"Fragment":var t=e.children,r=e.total,i=e.rendered++;if(i<r)return this.renderNode(t[i],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();var o=e.buffer,a=e.bufferIndex,s=e.componentBuffer,c=e.key,u={html:o[a],components:s[a]};if(this.cache.set(c,u),0===a)this.write.caching=!1;else{o[a-1]+=u.html;var l=s[a-1];u.components.forEach(function(e){return l.add(e)})}o.length=a,s.length=a}}};var xt=/[\w).+\-_$\]]/;function St(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&xt.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=$t(i,o[n]);return i}function $t(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var At=/\{\{((?:.|\r?\n)+?)\}\}/g,Ot=/[-.*+?^${}()|[\]\/\\]/g,kt=b(function(e){var t=e[0].replace(Ot,"\\$&"),r=e[1].replace(Ot,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function Ct(e,t){console.error("[Vue compiler]: "+e)}function Tt(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Ft(e,t,r,n,i){(e.props||(e.props=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function jt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function Pt(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Dt({name:t,value:r},n))}function Et(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Dt({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Nt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Lt(e,t,n,i,o,a,s,c){var u;(i=i||r).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Nt("!",t,c)),i.once&&(delete i.once,t=Nt("~",t,c)),i.passive&&(delete i.passive,t=Nt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Dt({value:n.trim(),dynamic:c},s);i!==r&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function It(e,t,r){var n=Mt(e,":"+t)||Mt(e,"v-bind:"+t);if(null!=n)return St(n);if(!1!==r){var i=Mt(e,t);if(null!=i)return JSON.stringify(i)}}function Mt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Rt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Dt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var Ut={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Mt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=It(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var zt,Bt,qt,Jt,Ht,Kt,Vt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Mt(e,"style");r&&(e.staticStyle=JSON.stringify(nt(r)));var n=It(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Wt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Zt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Xt="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Gt="((?:"+Xt+"\\:)?"+Xt+")",Qt=new RegExp("^<"+Gt),Yt=/^\s*(\/?)>/,er=new RegExp("^<\\/"+Gt+"[^>]*>"),tr=/^<!DOCTYPE [^>]+>/i,rr=/^<!\--/,nr=/^<!\[/,ir=d("script,style,textarea",!0),or={},ar={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},sr=/&(?:lt|gt|quot|amp|#39);/g,cr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,ur=d("pre,textarea",!0),lr=function(e,t){return e&&ur(e)&&"\n"===t[0]};function fr(e,t){var r=t?cr:sr;return e.replace(r,function(e){return ar[e]})}function pr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=dr(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function dr(e,t){var r=function(e){if(e=e.trim(),zt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<zt-1)return(Jt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Jt),key:'"'+e.slice(Jt+1)+'"'}:{exp:e,key:null};Bt=e,Jt=Ht=Kt=0;for(;!hr();)mr(qt=vr())?gr(qt):91===qt&&yr(qt);return{exp:e.slice(0,Ht),key:e.slice(Ht+1,Kt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function vr(){return Bt.charCodeAt(++Jt)}function hr(){return Jt>=zt}function mr(e){return 34===e||39===e}function yr(e){var t=1;for(Ht=Jt;!hr();)if(mr(e=vr()))gr(e);else if(91===e&&t++,93===e&&t--,0===t){Kt=Jt;break}}function gr(e){for(var t=e;!hr()&&(e=vr())!==t;);}var br,_r,wr,xr,Sr,$r,Ar,Or,kr=/^@|^v-on:/,Cr=/^v-|^@|^:|^#/,Tr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,jr=/^\(|\)$/g,Pr=/^\[.*\]$/,Er=/:(.*)$/,Nr=/^:|^\.|^v-bind:/,Lr=/\.[^.\]]+(?=[^\]]*$)/g,Ir=/^v-slot(:|$)|^#/,Mr=/[\r\n]/,Rr=/[ \f\t\r\n]+/g,Dr=b(t.decode),Ur="_empty_";function zr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Wr(t),rawAttrsMap:{},parent:r,children:[]}}function Br(e,t){br=t.warn||Ct,$r=t.isPreTag||C,Ar=t.mustUseProp||C,Or=t.getTagNamespace||C;t.isReservedTag;wr=Tt(t.modules,"transformNode"),xr=Tt(t.modules,"preTransformNode"),Sr=Tt(t.modules,"postTransformNode"),_r=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=qr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Hr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Hr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),$r(e.tag)&&(c=!1);for(var f=0;f<Sr.length;f++)Sr[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||C,s=t.canBeLeftOpenTag||C,c=0;e;){if(r=e,n&&ir(n)){var u=0,l=n.toLowerCase(),f=or[l]||(or[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,function(e,r,n){return u=n.length,ir(l)||"noscript"===l||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),lr(l,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-p.length,e=p,O(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(rr.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),S(v+3);continue}}if(nr.test(e)){var h=e.indexOf("]>");if(h>=0){S(h+2);continue}}var m=e.match(tr);if(m){S(m[0].length);continue}var y=e.match(er);if(y){var g=c;S(y[0].length),O(y[1],g,c);continue}var b=$();if(b){A(b),lr(b.tagName,e)&&S(1);continue}}var _=void 0,w=void 0,x=void 0;if(d>=0){for(w=e.slice(d);!(er.test(w)||Qt.test(w)||rr.test(w)||nr.test(w)||(x=w.indexOf("<",1))<0);)d+=x,w=e.slice(d);_=e.substring(0,d)}d<0&&(_=e),_&&S(_.length),t.chars&&_&&t.chars(_,c-_.length,c)}if(e===r){t.chars&&t.chars(e);break}}function S(t){c+=t,e=e.substring(t)}function $(){var t=e.match(Qt);if(t){var r,n,i={tagName:t[1],attrs:[],start:c};for(S(t[0].length);!(r=e.match(Yt))&&(n=e.match(Zt)||e.match(Wt));)n.start=c,S(n[0].length),n.end=c,i.attrs.push(n);if(r)return i.unarySlash=r[1],S(r[0].length),i.end=c,i}}function A(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&vt(r)&&O(n),s(r)&&n===r&&O(r));for(var u=a(r)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===r&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:fr(v,h)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:f,start:e.start,end:e.end}),n=r),t.start&&t.start(r,f,u,e.start,e.end)}function O(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}O()}(e,{warn:br,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||Or(e);se&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Zr.test(n.name)||(n.name=n.name.replace(Xr,""),t.push(n))}return t}(o));var d,v=zr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||fe()||(v.forbidden=!0);for(var h=0;h<xr.length;h++)v=xr[h](v,t)||v;s||(!function(e){null!=Mt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),$r(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Jr(v),function(e){var t=Mt(e,"v-if");if(t)e.if=t,Hr(e,{exp:t,block:e});else{null!=Mt(e,"v-else")&&(e.else=!0);var r=Mt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Mt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!se||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u,l,f=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Dr(e):f.length?a?"condense"===a&&Mr.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(Rr," ")),!s&&" "!==e&&(u=function(e,t){var r=t?kt(t):At;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=St(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,_r))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function qr(e,t){var r,n;(n=It(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=It(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Mt(e,"scope"),e.slotScope=t||Mt(e,"slot-scope")):(t=Mt(e,"slot-scope"))&&(e.slotScope=t);var r=It(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||jt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Rt(e,Ir);if(n){var i=Kr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Ur}}else{var s=Rt(e,Ir);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=Kr(s),l=u.name,f=u.dynamic,p=c[l]=zr("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=p,!0}),p.slotScope=s.value||Ur,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=It(e,"name"))}(e),function(e){var t;(t=It(e,"is"))&&(e.component=t);null!=Mt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<wr.length;i++)e=wr[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Cr.test(n))if(e.hasBindings=!0,(a=Vr(n.replace(Cr,"")))&&(n=n.replace(Lr,"")),Nr.test(n))n=n.replace(Nr,""),o=St(o),(c=Pr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),a.camel&&!c&&(n=w(n)),a.sync&&(s=dr(o,"$event"),c?Lt(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Lt(e,"update:"+w(n),s,null,!1,0,u[t]),$(n)!==w(n)&&Lt(e,"update:"+$(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Ar(e.tag,e.attrsMap.type,n)?Ft(e,n,o,u[t],c):jt(e,n,o,u[t],c);else if(kr.test(n))n=n.replace(kr,""),(c=Pr.test(n))&&(n=n.slice(1,-1)),Lt(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Cr,"")).match(Er),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Pr.test(f)&&(f=f.slice(1,-1),c=!0)),Et(e,n,i,o,f,c,a,u[t])}else jt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&Ar(e.tag,e.attrsMap.type,n)&&Ft(e,n,"true",u[t])}(e),e}function Jr(e){var t;if(t=Mt(e,"v-for")){var r=function(e){var t=e.match(Tr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(jr,""),i=n.match(Fr);i?(r.alias=n.replace(Fr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&A(e,r)}}function Hr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Kr(e){var t=e.name.replace(Ir,"");return t||"#"!==e.name[0]&&(t="default"),Pr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Vr(e){var t=e.match(Lr);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function Wr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Zr=/^xmlns:NS\d+/,Xr=/^NS\d+:/;function Gr(e){return zr(e.tag,e.attrsList.slice(),e.parent)}var Qr=[Ut,Vt,{preTransformNode:function(e,t){if("input"===e.tag){var r,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(r=It(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Mt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Mt(e,"v-else",!0),s=Mt(e,"v-else-if",!0),c=Gr(e);Jr(c),Pt(c,"type","checkbox"),qr(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,Hr(c,{exp:c.if,block:c});var u=Gr(e);Mt(u,"v-for",!0),Pt(u,"type","radio"),qr(u,t),Hr(c,{exp:"("+r+")==='radio'"+o,block:u});var l=Gr(e);return Mt(l,"v-for",!0),Pt(l,":type",r),qr(l,t),Hr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],Yr="__r";var en={expectHTML:!0,modules:Qr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return pr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+dr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lt(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null",o=It(e,"true-value")||"true",a=It(e,"false-value")||"false";Ft(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Lt(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+dr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+dr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+dr(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null";Ft(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Lt(e,"change",dr(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return pr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Yr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=dr(t,l);c&&(f="if($event.target.composing)return;"+f),Ft(e,"value","("+t+")"),Lt(e,u,f,null,!0),(s||a)&&Lt(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&Ft(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Ft(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:pt,mustUseProp:function(e,t,r){return"value"===r&&B(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:dt,isReservedTag:function(e){return tt(e)||rt(e)},getTagNamespace:function(e){return rt(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Qr)},tn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,rn=/\([^)]*?\);*$/,nn=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,on={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},an={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},sn=function(e){return"if("+e+")return null;"},cn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:sn("$event.target !== $event.currentTarget"),ctrl:sn("!$event.ctrlKey"),shift:sn("!$event.shiftKey"),alt:sn("!$event.altKey"),meta:sn("!$event.metaKey"),left:sn("'button' in $event && $event.button !== 0"),middle:sn("'button' in $event && $event.button !== 1"),right:sn("'button' in $event && $event.button !== 2")};function un(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=ln(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function ln(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return ln(e)}).join(",")+"]";var t=nn.test(e.value),r=tn.test(e.value),n=nn.test(e.value.replace(rn,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(cn[s])o+=cn[s],on[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=sn(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(fn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function fn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=on[e],n=an[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var pn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:k},dn=function(e){this.options=e,this.warn=e.warn||Ct,this.transforms=Tt(e.modules,"transformCode"),this.dataGenFns=Tt(e.modules,"genData"),this.directives=A(A({},pn),e.directives);var t=e.isReservedTag||C;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function vn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return hn(e,t);if(e.once&&!e.onceProcessed)return mn(e,t);if(e.for&&!e.forProcessed)return gn(e,t);if(e.if&&!e.ifProcessed)return yn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=xn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?On((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:xn(t,r,!0);return"_c("+e+","+bn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=bn(e,t));var i=e.inlineTemplate?null:xn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return xn(e,t)||"void 0"}function hn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+vn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function mn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return yn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+vn(e,t)+","+t.onceId+++","+r+")":vn(e,t)}return hn(e,t)}function yn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?mn(e,r):vn(e,r)}}(e.ifConditions.slice(),t,r,n)}function gn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||vn)(e,t)+"})"}function bn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+On(e.attrs)+","),e.props&&(r+="domProps:"+On(e.props)+","),e.events&&(r+=un(e.events,!1)+","),e.nativeEvents&&(r+=un(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||_n(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Ur||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return wn(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":vn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+On(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function _n(e){return 1===e.type&&("slot"===e.tag||e.children.some(_n))}function wn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return yn(e,t,wn,"null");if(e.for&&!e.forProcessed)return gn(e,t,wn);var n=e.slotScope===Ur?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(xn(e,t)||"undefined")+":undefined":xn(e,t)||"undefined":vn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function xn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||vn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(Sn(i)||i.ifConditions&&i.ifConditions.some(function(e){return Sn(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||$n;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Sn(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function $n(e,t){return 1===e.type?vn(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):An(e);var r}function An(e){return"_v("+(2===e.type?e.expression:kn(JSON.stringify(e.text)))+")"}function On(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=kn(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function kn(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Cn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function Tn(e,t){return Cn.test(t)?(t=t.replace(/^'|'$/g,'"'),q(e)&&'"false"'!==t&&(t='"true"'),{type:Nn,value:K(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:In,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var Fn,jn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Pn(e,t){e&&(Fn=t.isReservedTag||C,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!Fn(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=jn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!En(e.name)})}(t);var i=function(e){e.ssrOptimizability!==jn.FULL&&(t.ssrOptimizability=n?jn.PARTIAL:jn.SELF)};n&&(t.ssrOptimizability=jn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var c=1,u=t.ifConditions.length;c<u;c++){var l=t.ifConditions[c].block;e(l,r),i(l)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=jn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:jn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===jn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=jn.FULL}(e,!0))}var En=d("text,html,show,on,bind,model,pre,cloak,once");var Nn=0,Ln=1,In=2;function Mn(e,t){if(e.for&&!e.forProcessed)return gn(e,t,Mn);if(e.if&&!e.ifProcessed)return yn(e,t,Mn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===jn.FULL?zn(e,t):Dn(e,t)||"void 0";switch(e.ssrOptimizability){case jn.FULL:return function(e,t){return"_ssrNode("+Bn(e,t)+")"}(e,t);case jn.SELF:return function(e,t){var r=Dn(e,t,!0);return"_ssrNode("+Kn(Jn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case jn.CHILDREN:return Rn(e,t,!0);case jn.PARTIAL:return Rn(e,t,!1);default:return vn(e,t)}}function Rn(e,t,r){var n=e.plain?void 0:bn(e,t),i=r?"["+zn(e,t)+"]":Dn(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Dn(e,t,r){return xn(e,t,r,Mn,Un)}function Un(e,t){return 1===e.type?Mn(e,t):An(e)}function zn(e,t){return e.children.length?"_ssrNode("+Kn(Hn(e,t))+")":""}function Bn(e,t){return"("+Kn(qn(e,t))+")"}function qn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:In,value:gn(e,t,Bn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:In,value:yn(e,t,Bn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Hn(e,t);var r=Jn(e,t),n=Hn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:Nn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Jn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:Nn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return Tn(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=M[n]||n.toLowerCase(),!I(n)||t&&t.some(function(e){return e.name===n})||r.push(Tn(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:In,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:In,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:Nn,value:' class="'+JSON.parse(n)+'"'}]:[{type:In,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:In,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:Nn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:Nn,value:" "+t.options.scopeId}),u.push({type:Nn,value:">"}),u}function Hn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:In,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Ln,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Ln,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,qn(i,t));else if(2===i.type)r.push({type:Ln,value:i.expression});else if(3===i.type){var o=D(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:Nn,value:o})}}return r}(e.children,t):[]}function Kn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===Nn?r+=o.value:o.type===Ln?(n(),t.push("_ssrEscape("+o.value+")")):o.type===In&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Vn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),k}}function Wn(e){var t=Object.create(null);return function(r,n,i){(n=A({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Vn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Vn(e,c)}),t[o]=s}}var Zn,Xn=(Zn=function(e,t){var r=Br(e.trim(),t);Pn(r,t);var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?Mn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=A(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=Zn(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Wn(t)}})(en),Gn=(Xn.compile,Xn.compileToFunctions);function Qn(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Yn(e){return a(e)?[Q(e)]:Array.isArray(e)?function e(t,r){var s=[];var c,u,l,f;for(c=0;c<t.length;c++)n(u=t[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ei((u=e(u,(r||"")+"_"+c))[0])&&ei(f)&&(s[l]=Q(f.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?ei(f)?s[l]=Q(f.text+u):""!==u&&s.push(Q(u)):ei(u)&&ei(f)?s[l]=Q(f.text+u.text):(o(t._isVList)&&i(u.tag)&&n(u.key)&&i(r)&&(u.key="__vlist"+r+"_"+c+"__"),s.push(u)));return s}(e):void 0}function ei(e){return i(e)&&i(e.text)&&!1===e.isComment}var ti={_ssrEscape:D,_ssrNode:function(e,t,r,n){return new ri(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(s(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:W,_ssrAttrs:function(e){var t="";for(var r in e)L(r)||(t+=W(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=M[r]||r.toLowerCase();I(n)&&(t+=W(n,e[r]))}return t},_ssrClass:function(e,t){var r=Qe(e,t);return""===r?r:' class="'+D(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&A(n,e);t&&A(n,ot(t));r&&A(n,r);var i=at(n);return""===i?i:" style="+JSON.stringify(D(i))}};var ri=function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?Qn(r):2===n?Yn(r):r:void 0};var ni=new de;function ii(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!s(t)||Object.isFrozen(t)||t instanceof Z)return;if(t.__ob__){var a=t.__ob__.dep.id;if(r.has(a))return;r.add(a)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,ni),ni.clear()}var oi=b(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function ai(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return Ke(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)Ke(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function si(e,t,r,n,o){if(i(t)){if(g(t,r))return e[r]=t[r],o||delete t[r],!0;if(g(t,n))return e[r]=t[n],o||delete t[n],!0}return!1}var ci=1,ui=2;function li(e,t,r,c,u,l){return(Array.isArray(r)||a(r))&&(u=c,c=r,r=void 0),o(l)&&(u=ui),function(e,t,r,a,c){if(i(r)&&i(r.__ob__))return G();i(r)&&i(r.is)&&(t=r.is);if(!t)return G();Array.isArray(a)&&"function"==typeof a[0]&&((r=r||{}).scopedSlots={default:a[0]},a.length=0);c===ui?a=Yn(a):c===ci&&(a=Qn(a));var u,l;if("string"==typeof t){var f;l=e.$vnode&&e.$vnode.ns||ye.getTagNamespace(t),u=r&&r.pre||!i(f=De(e.$options,"components",t))?new Z(t,r,a,void 0,void 0,e):Ki(f,r,e,a,t)}else u=Ki(t,r,e,a);return Array.isArray(u)?u:i(u)?(i(l)&&function e(t,r,a){t.ns=r;"foreignObject"===t.tag&&(r=void 0,a=!0);if(i(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];i(u.tag)&&(n(u.ns)||o(a)&&"svg"!==u.tag)&&e(u,r,a)}}(u,l),i(r)&&function(e){s(e.style)&&ii(e.style);s(e.class)&&ii(e.class)}(r),u):G()}(e,t,r,c,u)}function fi(e,t){var r,n,o,a,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,n=e.length;r<n;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(s(e))if(ve&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,n=o.length;r<n;r++)a=o[r],c[r]=t(e[a],a,r);return i(c)||(c=[]),c._isVList=!0,c}function pi(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=A(A({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function di(e){return De(this.$options,"filters",e)||T}function vi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function hi(e,t,r,n,i){var o=ye.keyCodes[t]||r;return i&&n&&!ye.keyCodes[t]?vi(i,n):o?vi(o,e):n?$(n)!==t:void 0}function mi(e,t,r,n,i){if(r)if(s(r)){var o;Array.isArray(r)&&(r=O(r));var a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||ye.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(a),u=$(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var c in r)a(c)}else;return e}function yi(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(bi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function gi(e,t,r){return bi(e,"__once__"+t+(r?"_"+r:""),!0),e}function bi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&_i(e[n],t+"_"+n,r);else _i(e,t,r)}function _i(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function wi(e,t){if(t)if(u(t)){var r=e.on=e.on?A({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function xi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?xi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function Si(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function $i(e,t){return"string"==typeof e?t+e:e}function Ai(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Oi)&&delete r[u];return r}function Oi(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ki(e,t,n){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&n&&n!==r&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Ci(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Ti(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ee(i,"$stable",a),ee(i,"$key",s),ee(i,"$hasNormal",o),i}function Ci(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Yn(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Ti(e,t){return function(){return e[t]}}var Fi,ji=null;function Pi(e,t){return(e.__esModule||ve&&"Module"===e[Symbol.toStringTag])&&(e=e.default),s(e)?t.extend(e):e}function Ei(e,t){Fi.$on(e,t)}function Ni(e,t){Fi.$off(e,t)}function Li(e,t){var r=Fi;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ii(e,t,r){Fi=e,function(e,t,r,i,a,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=oi(c),n(u)||(n(l)?(n(u.fns)&&(u=e[c]=ai(u,s)),o(f.once)&&(u=e[c]=a(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)n(e[c])&&i((f=oi(c)).name,t[c],f.capture)}(t,r||{},Ei,Ni,Li,e),Fi=void 0}function Mi(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Ri(e,t){we();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)Ke(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),xe()}var Di=Date.now;if(ne&&!se){var Ui=window.performance;Ui&&"function"==typeof Ui.now&&Di()>document.createEvent("Event").timeStamp&&(Di=function(){return Ui.now()})}function zi(e,t,n,i,a){var s,c=this,u=a.options;g(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=o(u._compiled),f=!l;this.data=e,this.props=t,this.children=n,this.parent=i,this.listeners=e.on||r,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=ve?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&g(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||ki(e.scopedSlots,c.$slots=Ai(n,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ki(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ki(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=li(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return li(s,e,t,r,n,f)}}function Bi(e,t,r,n,i){var o=function(e){var t=new Z(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function qi(e,t){for(var r in t)e[w(r)]=t[r]}!function(e){e._o=gi,e._n=p,e._s=f,e._l=fi,e._t=pi,e._q=F,e._i=j,e._m=yi,e._f=di,e._k=hi,e._b=mi,e._v=Q,e._e=G,e._u=xi,e._g=wi,e._d=Si,e._p=$i}(zi.prototype);var Ji={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ji.prepatch(r,r)}else{(e.componentInstance=Vi(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var n=t.componentOptions;!function(e,t,n,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==r&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||r,e.$listeners=n||r,t&&e.$options.props){ke(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Ue(d,v,t,e)}ke(!0),e.$options.propsData=t}n=n||r;var h=e.$options._parentListeners;e.$options._parentListeners=n,Ii(e,n,h),u&&(e.$slots=Ai(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Ri(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,Mi(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Ri(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,Mi(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Ri(t,"deactivated")}}(t,!0):t.$destroy())}},Hi=Object.keys(Ji);function Ki(e,t,a,c,u){if(!n(e)){var f=a.$options._base;if(s(e)&&(e=f.extend(e)),"function"==typeof e){var p;if(n(e.cid)&&void 0===(e=function(e,t){if(o(e.error)&&i(e.errorComp))return e.errorComp;if(i(e.resolved))return e.resolved;var r=ji;if(r&&i(e.owners)&&-1===e.owners.indexOf(r)&&e.owners.push(r),o(e.loading)&&i(e.loadingComp))return e.loadingComp;if(r&&!i(e.owners)){var a=e.owners=[r],c=!0,u=null,f=null;r.$on("hook:destroyed",function(){return m(a,r)});var p=function(e){for(var t=0,r=a.length;t<r;t++)a[t].$forceUpdate();e&&(a.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=P(function(r){e.resolved=Pi(r,t),c?a.length=0:p(!0)}),v=P(function(t){i(e.errorComp)&&(e.error=!0,p(!0))}),h=e(d,v);return s(h)&&(l(h)?n(e.resolved)&&h.then(d,v):l(h.component)&&(h.component.then(d,v),i(h.error)&&(e.errorComp=Pi(h.error,t)),i(h.loading)&&(e.loadingComp=Pi(h.loading,t),0===h.delay?e.loading=!0:u=setTimeout(function(){u=null,n(e.resolved)&&n(e.error)&&(e.loading=!0,p(!1))},h.delay||200)),i(h.timeout)&&(f=setTimeout(function(){f=null,n(e.resolved)&&v(null)},h.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=e,f)))return function(e,t,r,n,i){var o=G();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(p,t,a,c,u);t=t||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&A(t.extendOptions,i),(r=t.options=Re(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),i(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[n],s=t.model.callback;i(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[n]=[s].concat(a)):o[n]=s}(e.options,t);var d=function(e,t,r){var o=t.options.props;if(!n(o)){var a={},s=e.attrs,c=e.props;if(i(s)||i(c))for(var u in o){var l=$(u);si(a,c,u,l,!0)||si(a,s,u,l,!1)}return a}}(t,e);if(o(e.options.functional))return function(e,t,n,o,a){var s=e.options,c={},u=s.props;if(i(u))for(var l in u)c[l]=Ue(l,u,t||r);else i(n.attrs)&&qi(c,n.attrs),i(n.props)&&qi(c,n.props);var f=new zi(n,c,a,o,e),p=s.render.call(null,f._c,f);if(p instanceof Z)return Bi(p,n,f.parent,s);if(Array.isArray(p)){for(var d=Yn(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Bi(d[h],n,f.parent,s);return v}}(e,d,t,a,c);var v=t.on;if(t.on=t.nativeOn,o(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Hi.length;r++){var n=Hi[r],i=t[n],o=Ji[n];i===o||i&&i._merged||(t[n]=i?Wi(o,i):o)}}(t);var y=e.options.name||u;return new Z("vue-component-"+e.cid+(y?"-"+y:""),t,void 0,void 0,void 0,a,{Ctor:e,propsData:d,listeners:v,tag:u,children:c},p)}}}function Vi(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return i(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function Wi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var Zi=Object.create(null),Xi=function(e){Zi[e]||(Zi[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},Gi=function(e,t){var r=t?(void 0)(t):"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},Qi=function(e){var t=e.$options,r=t.render,i=t.template,o=t._scopeId;if(n(r)){if(!i)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=Gn(i,{scopeId:o,warn:Gi},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function Yi(e,t,r){var n=e.$options.serverPrefetch;if(i(n)){Array.isArray(n)||(n=[n]);try{for(var o=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&o.push(c)}return void Promise.all(o).then(t).catch(r)}catch(e){r(e)}}t()}function eo(e,t,r){e.isString?function(e,t){var r=t.write,i=t.next;if(n(e.children)||0===e.children.length)r(e.open+(e.close||""),i);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,i)}}(e,r):i(e.componentOptions)?ro(e,t,r):i(e.tag)?function(e,t,r){var a=r.write,s=r.next;o(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[he]="true");e.fnOptions&&to(e.fnOptions,a);var c=function(e,t){var r,o="<"+e.tag,a=t.directives,s=t.modules;n(e.data)&&function e(t){var r=t.parent;return i(r)&&(i(r.data)||e(r))}(e)&&(e.data={});if(i(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=De(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;i(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var d=0;d<s.length;d++){var v=s[d](e);v&&(o+=v)}}var h=t.activeInstance;i(h)&&h!==e.context&&i(r=h.$options._scopeId)&&(o+=" "+r);if(i(e.fnScopeId))o+=" "+e.fnScopeId;else for(;i(e);)i(r=e.context.$options._scopeId)&&(o+=" "+r),e=e.parent;return o+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))a(c,s);else if(n(e.children)||0===e.children.length)a(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),a(c,s)}}(e,t,r):o(e.isComment)?i(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=Ki(n,o,c,a,s);u?u.componentOptions?ro(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):eo(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:D(String(e.text)),r.next)}function to(e,t){var r=e._ssrRegister;return t.caching&&i(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function ro(e,t,r){var o=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=to(c.options,o);if(i(u)&&i(f)&&i(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void io(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;i(h)?h(v,function(n){!0===n&&i(m)?m(v,function(e){i(p)&&p(s),e.components.forEach(function(e){return e(s)}),o(e.html,a)}):no(e,t,v,r)}):i(m)&&m(v,function(n){i(n)?(i(p)&&p(s),n.components.forEach(function(e){return e(s)}),o(n.html,a)):no(e,t,v,r)})}else i(u)&&n(f)&&Xi("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),i(u)&&n(l)&&Xi('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),io(e,t,r)}function no(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),io(e,t,n)}function io(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Vi(e,r.activeInstance);Qi(i);var o=r.done;Yi(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),eo(o,t,r)},o)}function oo(e,t,r,n){return function(i,o,a,s){Zi=Object.create(null);var c=new _t({activeInstance:i,userContext:a,write:o,done:s,renderNode:eo,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;A(t.prototype,ti),t.FunctionalRenderContext&&A(t.FunctionalRenderContext.prototype,ti)}}(i),Qi(i);Yi(i,function(){eo(i._render(),!0,c)},s)}}var ao=function(e){return/\.js(\?[^.]+)?$/.test(e)};function so(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var co=function(e){function t(t,r,n){e.call(this),this.started=!1,this.renderer=t,this.template=r,this.context=n||{},this.inject=t.inject}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),uo=require("lodash.template"),lo={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function fo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var po=require("path"),vo=require("serialize-javascript"),ho=function(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:uo(e.slice(0,r),lo),neck:uo(e.slice(r,n),lo),tail:uo(e.slice(n+t.length),lo)}}(t):t:null,this.serialize=e.serializer||function(e){return vo(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(mo),this.prefetchFiles=(r.async||[]).map(mo),this.mapFiles=fo(r)}};function mo(e){var t=e.replace(/\?.*/,""),r=po.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:yo(r)}}function yo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}ho.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},ho.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},ho.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},ho.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},ho.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},ho.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},ho.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},ho.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey;void 0===n&&(n="state");var i=r.windowKey;void 0===i&&(i="__INITIAL_STATE__");var o=this.serialize(e[n]),a=e.nonce?' nonce="'+e.nonce+'"':"";return e[n]?"<script"+a+">window."+i+"="+o+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},ho.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return ao(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return ao(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},ho.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(mo)}return e._mappedFiles},ho.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new co(this,this.parsedTemplate,e||{})};var go=require("vm"),bo=require("path"),_o=require("resolve"),wo=require("module");function xo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function So(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=wo.wrap(r),o=new go.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=bo.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=_o.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function $o(e,t,r,n){var i,o,a=So(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,xo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?xo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(u(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))})}}var Ao=require("source-map").SourceMapConsumer,Oo=/\(([^)]+\.js):(\d+):(\d+)\)$/;function ko(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(Oo),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(Oo,c)}return e}return e}(e,t)}).join("\n"))}var Co=require("fs"),To=require("path"),Fo=require("stream").PassThrough,jo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Po(e){return void 0===e&&(e={}),function(e){void 0===e&&(e={});var t=e.modules;void 0===t&&(t=[]);var r=e.directives;void 0===r&&(r={});var n=e.isUnaryTag;void 0===n&&(n=function(){return!1});var i=e.template,o=e.inject,a=e.cache,s=e.shouldPreload,c=e.shouldPrefetch,u=e.clientManifest,l=e.serializer,f=oo(t,r,n,a),p=new ho({template:i,inject:o,shouldPreload:s,shouldPrefetch:c,clientManifest:u,serializer:l});return{renderToString:function(e,t,r){var n,o;"function"==typeof t&&(r=t,t={}),t&&p.bindRenderFns(t),r||(o=(n=so()).promise,r=n.cb);var a="",s=gt(function(e){return a+=e,!1},r);try{f(e,s,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),i)try{var n=p.render(a,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,a)})}catch(e){r(e)}return o},renderToStream:function(e,t){t&&p.bindRenderFns(t);var r=new bt(function(r,n){f(e,r,t,n)});if(i){if("function"==typeof i)throw new Error("function template is only supported in renderToString.");var n=p.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return n}if(t&&t.rendered){var a=t.rendered;r.once("beforeEnd",function(){a(t)})}return r}}}(A(A({},e),{isUnaryTag:pt,canBeLeftOpenTag:dt,modules:ct,directives:A(ft,e.directives)}))}process.env.VUE_ENV="server";var Eo=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&To.isAbsolute(t)){if(!Co.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||To.dirname(t),t=Co.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new Ao(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(jo)}else{if("string"!=typeof t)throw new Error(jo);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=$o(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=so()).promise,t=r.cb),u(e).catch(function(e){ko(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){ko(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new Fo;return u(e).catch(function(e){ko(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){ko(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(Po);exports.createRenderer=Po,exports.createBundleRenderer=Eo;
\ No newline at end of file
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 15cdcbd3ad4..3a17291425d 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -1,94 +1,86 @@
 'use strict';
 
-/*  */
-
+/* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
-
 var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
 
 var ref = require('chalk');
 var red = ref.red;
 var yellow = ref.yellow;
-
 var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); };
-var tip = exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); };
-
+var warn = (exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); });
+var tip = (exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); });
 var onEmit = function (compiler, name, hook) {
-  if (compiler.hooks) {
-    // Webpack >= 4.0.0
-    compiler.hooks.emit.tapAsync(name, hook);
-  } else {
-    // Webpack < 4.0.0
-    compiler.plugin('emit', hook);
-  }
+    if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
 };
 
 var hash = require('hash-sum');
 var uniq = require('lodash.uniq');
+var VueSSRClientPlugin = function VueSSRClientPlugin(options) {
+    if ( options === void 0 ) options = {};
 
-var VueSSRClientPlugin = function VueSSRClientPlugin (options) {
-  if ( options === void 0 ) options = {};
-
-  this.options = Object.assign({
-    filename: 'vue-ssr-client-manifest.json'
-  }, options);
+    //@ts-expect-error
+    this.options = Object.assign({
+        filename: 'vue-ssr-client-manifest.json',
+    }, options);
 };
-
 VueSSRClientPlugin.prototype.apply = function apply (compiler) {
-    var this$1 = this;
-
-  onEmit(compiler, 'vue-client-plugin', function (compilation, cb) {
-    var stats = compilation.getStats().toJson();
-
-    var allFiles = uniq(stats.assets
-      .map(function (a) { return a.name; }));
-
-    var initialFiles = uniq(Object.keys(stats.entrypoints)
-      .map(function (name) { return stats.entrypoints[name].assets; })
-      .reduce(function (assets, all) { return all.concat(assets); }, [])
-      .filter(function (file) { return isJS(file) || isCSS(file); }));
-
-    var asyncFiles = allFiles
-      .filter(function (file) { return isJS(file) || isCSS(file); })
-      .filter(function (file) { return initialFiles.indexOf(file) < 0; });
-
-    var manifest = {
-      publicPath: stats.publicPath,
-      all: allFiles,
-      initial: initialFiles,
-      async: asyncFiles,
-      modules: { /* [identifier: string]: Array<index: number> */ }
-    };
-
-    var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
-    var fileToIndex = function (file) { return manifest.all.indexOf(file); };
-    stats.modules.forEach(function (m) {
-      // ignore modules duplicated in multiple chunks
-      if (m.chunks.length === 1) {
-        var cid = m.chunks[0];
-        var chunk = stats.chunks.find(function (c) { return c.id === cid; });
-        if (!chunk || !chunk.files) {
-          return
-        }
-        var id = m.identifier.replace(/\s\w+$/, ''); // remove appended hash
-        var files = manifest.modules[hash(id)] = chunk.files.map(fileToIndex);
-        // find all asset modules associated with the same chunk
-        assetModules.forEach(function (m) {
-          if (m.chunks.some(function (id) { return id === cid; })) {
-            files.push.apply(files, m.assets.map(fileToIndex));
-          }
+        var this$1 = this;
+
+    onEmit(compiler, 'vue-client-plugin', function (compilation, cb) {
+        var stats = compilation.getStats().toJson();
+        var allFiles = uniq(stats.assets.map(function (a) { return a.name; }));
+        var initialFiles = uniq(Object.keys(stats.entrypoints)
+            .map(function (name) { return stats.entrypoints[name].assets; })
+            .reduce(function (assets, all) { return all.concat(assets); }, [])
+            .filter(function (file) { return isJS(file) || isCSS(file); }));
+        var asyncFiles = allFiles
+            .filter(function (file) { return isJS(file) || isCSS(file); })
+            .filter(function (file) { return initialFiles.indexOf(file) < 0; });
+        var manifest = {
+            publicPath: stats.publicPath,
+            all: allFiles,
+            initial: initialFiles,
+            async: asyncFiles,
+            modules: {
+            /* [identifier: string]: Array<index: number> */
+            },
+        };
+        var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
+        var fileToIndex = function (file) { return manifest.all.indexOf(file); };
+        stats.modules.forEach(function (m) {
+            // ignore modules duplicated in multiple chunks
+            if (m.chunks.length === 1) {
+                var cid = m.chunks[0];
+                var chunk = stats.chunks.find(function (c) { return c.id === cid; });
+                if (!chunk || !chunk.files) {
+                    return;
+                }
+                var id = m.identifier.replace(/\s\w+$/, ''); // remove appended hash
+                var files = (manifest.modules[hash(id)] = chunk.files.map(fileToIndex));
+                // find all asset modules associated with the same chunk
+                assetModules.forEach(function (m) {
+                    if (m.chunks.some(function (id) { return id === cid; })) {
+                        files.push.apply(files, m.assets.map(fileToIndex));
+                    }
+                });
+            }
         });
-      }
+        var json = JSON.stringify(manifest, null, 2);
+        //@ts-expect-error
+        compilation.assets[this$1.options.filename] = {
+            source: function () { return json; },
+            size: function () { return json.length; },
+        };
+        cb();
     });
-
-    var json = JSON.stringify(manifest, null, 2);
-    compilation.assets[this$1.options.filename] = {
-      source: function () { return json; },
-      size: function () { return json.length; }
-    };
-    cb();
-  });
 };
 
 module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index 54ba2b3ab0a..866b41a87d4 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -1,109 +1,91 @@
 'use strict';
 
-/*  */
-
+/* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 
 var ref = require('chalk');
 var red = ref.red;
 var yellow = ref.yellow;
-
 var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); };
-var tip = exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); };
-
+var warn = (exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); });
+var tip = (exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); });
 var validate = function (compiler) {
-  if (compiler.options.target !== 'node') {
-    warn('webpack config `target` should be "node".');
-  }
-
-  if (compiler.options.output && compiler.options.output.libraryTarget !== 'commonjs2') {
-    warn('webpack config `output.libraryTarget` should be "commonjs2".');
-  }
-
-  if (!compiler.options.externals) {
-    tip(
-      'It is recommended to externalize dependencies in the server build for ' +
-      'better build performance.'
-    );
-  }
+    if (compiler.options.target !== 'node') {
+        warn('webpack config `target` should be "node".');
+    }
+    if (compiler.options.output &&
+        compiler.options.output.libraryTarget !== 'commonjs2') {
+        warn('webpack config `output.libraryTarget` should be "commonjs2".');
+    }
+    if (!compiler.options.externals) {
+        tip('It is recommended to externalize dependencies in the server build for ' +
+            'better build performance.');
+    }
 };
-
 var onEmit = function (compiler, name, hook) {
-  if (compiler.hooks) {
-    // Webpack >= 4.0.0
-    compiler.hooks.emit.tapAsync(name, hook);
-  } else {
-    // Webpack < 4.0.0
-    compiler.plugin('emit', hook);
-  }
+    if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
 };
 
-var VueSSRServerPlugin = function VueSSRServerPlugin (options) {
-  if ( options === void 0 ) options = {};
+var VueSSRServerPlugin = function VueSSRServerPlugin(options) {
+    if ( options === void 0 ) options = {};
 
-  this.options = Object.assign({
-    filename: 'vue-ssr-server-bundle.json'
-  }, options);
+    //@ts-expect-error
+    this.options = Object.assign({
+        filename: 'vue-ssr-server-bundle.json',
+    }, options);
 };
-
 VueSSRServerPlugin.prototype.apply = function apply (compiler) {
-    var this$1 = this;
-
-  validate(compiler);
-
-  onEmit(compiler, 'vue-server-plugin', function (compilation, cb) {
-    var stats = compilation.getStats().toJson();
-    var entryName = Object.keys(stats.entrypoints)[0];
-    var entryInfo = stats.entrypoints[entryName];
-
-    if (!entryInfo) {
-      // #5553
-      return cb()
-    }
-
-    var entryAssets = entryInfo.assets.filter(isJS);
-
-    if (entryAssets.length > 1) {
-      throw new Error(
-        "Server-side bundle should have one single entry file. " +
-        "Avoid using CommonsChunkPlugin in the server config."
-      )
-    }
-
-    var entry = entryAssets[0];
-    if (!entry || typeof entry !== 'string') {
-      throw new Error(
-        ("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?")
-      )
-    }
-
-    var bundle = {
-      entry: entry,
-      files: {},
-      maps: {}
-    };
-
-    stats.assets.forEach(function (asset) {
-      if (isJS(asset.name)) {
-        bundle.files[asset.name] = compilation.assets[asset.name].source();
-      } else if (asset.name.match(/\.js\.map$/)) {
-        bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source());
-      }
-      // do not emit anything else for server
-      delete compilation.assets[asset.name];
+        var this$1 = this;
+
+    validate(compiler);
+    onEmit(compiler, 'vue-server-plugin', function (compilation, cb) {
+        var stats = compilation.getStats().toJson();
+        var entryName = Object.keys(stats.entrypoints)[0];
+        var entryInfo = stats.entrypoints[entryName];
+        if (!entryInfo) {
+            // #5553
+            return cb();
+        }
+        var entryAssets = entryInfo.assets.filter(isJS);
+        if (entryAssets.length > 1) {
+            throw new Error("Server-side bundle should have one single entry file. " +
+                "Avoid using CommonsChunkPlugin in the server config.");
+        }
+        var entry = entryAssets[0];
+        if (!entry || typeof entry !== 'string') {
+            throw new Error(("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?"));
+        }
+        var bundle = {
+            entry: entry,
+            files: {},
+            maps: {},
+        };
+        stats.assets.forEach(function (asset) {
+            if (isJS(asset.name)) {
+                bundle.files[asset.name] = compilation.assets[asset.name].source();
+            }
+            else if (asset.name.match(/\.js\.map$/)) {
+                bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source());
+            }
+            // do not emit anything else for server
+            delete compilation.assets[asset.name];
+        });
+        var json = JSON.stringify(bundle, null, 2);
+        //@ts-expect-error
+        var filename = this$1.options.filename;
+        compilation.assets[filename] = {
+            source: function () { return json; },
+            size: function () { return json.length; },
+        };
+        cb();
     });
-
-    var json = JSON.stringify(bundle, null, 2);
-    var filename = this$1.options.filename;
-
-    compilation.assets[filename] = {
-      source: function () { return json; },
-      size: function () { return json.length; }
-    };
-
-    cb();
-  });
 };
 
 module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index c2907a17769..c73b00097e6 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -50,138 +50,114 @@
     return i
   }
 
-  /*  */
-
+  /* @flow */
   var emptyObject = Object.freeze({});
-
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
-  function isUndef (v) {
-    return v === undefined || v === null
+  function isUndef(v) {
+      return v === undefined || v === null;
   }
-
   /**
    * Check if value is primitive.
    */
-  function isPrimitive (value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
   }
-
   /**
    * Quick object check - this is primarily used to tell
    * Objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
-  function isObject (obj) {
-    return obj !== null && typeof obj === 'object'
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
   }
-
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
   var _toString = Object.prototype.toString;
-
-  function toRawType (value) {
-    return _toString.call(value).slice(8, -1)
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
   }
-
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
-  function isPlainObject (obj) {
-    return _toString.call(obj) === '[object Object]'
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
   }
-
   /**
    * Check if val is a valid array index.
    */
-  function isValidArrayIndex (val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
+  function isValidArrayIndex(val) {
+      var n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
-
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
-  function makeMap (
-    str,
-    expectsLowerCase
-  ) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) { return map[val.toLowerCase()]; }
-      : function (val) { return map[val]; }
+  function makeMap(str, expectsLowerCase) {
+      var map = Object.create(null);
+      var list = str.split(',');
+      for (var i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
   }
-
   /**
    * Check if a tag is a built-in tag.
    */
   var isBuiltInTag = makeMap('slot,component', true);
-
   /**
    * Check if an attribute is a reserved attribute.
    */
   var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
   /**
    * Remove an item from an array.
    */
-  function remove (arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1)
+  function remove(arr, item) {
+      if (arr.length) {
+          var index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
       }
-    }
   }
-
   /**
    * Check whether an object has the property.
    */
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn (obj, key) {
-    return hasOwnProperty.call(obj, key)
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
   }
-
   /**
    * Create a cached version of a pure function.
    */
-  function cached (fn) {
-    var cache = Object.create(null);
-    return (function cachedFn (str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str))
-    })
+  function cached(fn) {
+      var cache = Object.create(null);
+      return function cachedFn(str) {
+          var hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
   }
-
   /**
    * Camelize a hyphen-delimited string.
    */
   var camelizeRE = /-(\w)/g;
   var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
   });
-
   /**
    * Hyphenate a camelCase string.
    */
   var hyphenateRE = /\B([A-Z])/g;
   var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-
   /**
    * Simple bind polyfill for environments that do not support it,
    * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -189,121 +165,99 @@
    * But removing it would mean breaking code that was able to run in
    * PhantomJS 1.x, so this must be kept for backward compatibility.
    */
-
   /* istanbul ignore next */
-  function polyfillBind (fn, ctx) {
-    function boundFn (a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx)
-    }
-
-    boundFn._length = fn.length;
-    return boundFn
-  }
-
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
-
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
-
+  function polyfillBind(fn, ctx) {
+      function boundFn(a) {
+          var l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
+  }
+  function nativeBind(fn, ctx) {
+      return fn.bind(ctx);
+  }
+  // @ts-expect-error bind cannot be `undefined`
+  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Mix properties into target object.
    */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to
+  function extend(to, _from) {
+      for (var key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
   }
-
   /* eslint-disable no-unused-vars */
-
   /**
    * Perform no operation.
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop (a, b, c) {}
-
+  function noop(a, b, c) { }
   /**
    * Always return false.
    */
   var no = function (a, b, c) { return false; };
-
   /* eslint-enable no-unused-vars */
-
   /**
    * Return the same value.
    */
   var identity = function (_) { return _; };
-
   /**
    * Generate a string containing static keys from compiler modules.
    */
-  function genStaticKeys (modules) {
-    return modules.reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, []).join(',')
+  function genStaticKeys(modules) {
+      return modules
+          .reduce(function (keys, m) {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
   }
 
-  /*  */
-
-  var isUnaryTag = makeMap(
-    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr'
-  );
-
+  /* @flow */
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap(
-    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-  );
-
+  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap(
-    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track'
-  );
-
-  /*  */
+  var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
 
+  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
   var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
   /**
    * Define a property.
    */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
   }
 
   /**
    * Not type-checking this file because it's mostly vendor code.
    */
-
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
   var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -313,801 +267,724 @@
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
   var conditionalComment = /^<!\[/;
-
   // Special Elements (can contain anything)
   var isPlainTextElement = makeMap('script,style,textarea', true);
   var reCache = {};
-
   var decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'"
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
   };
   var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
   var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-  function decodeAttr (value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; })
-  }
-
-  function parseHTML (html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
-    while (html) {
-      last = html;
-      // Make sure we're not in a plaintext content element like script/style
-      if (!lastTag || !isPlainTextElement(lastTag)) {
-        var textEnd = html.indexOf('<');
-        if (textEnd === 0) {
-          // Comment:
-          if (comment.test(html)) {
-            var commentEnd = html.indexOf('-->');
-
-            if (commentEnd >= 0) {
-              if (options.shouldKeepComment) {
-                options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+  function decodeAttr(value, shouldDecodeNewlines) {
+      var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, function (match) { return decodingMap[match]; });
+  }
+  function parseHTML(html, options) {
+      var stack = [];
+      var expectHTML = options.expectHTML;
+      var isUnaryTag$$1 = options.isUnaryTag || no;
+      var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+      var index = 0;
+      var last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              var textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      var commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      var conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  var doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  var endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      var curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  var startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              var text = (void 0), rest = (void 0), next = (void 0);
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          { break; }
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
               }
-              advance(commentEnd + 3);
-              continue
-            }
-          }
-
-          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (conditionalComment.test(html)) {
-            var conditionalEnd = html.indexOf(']>');
-
-            if (conditionalEnd >= 0) {
-              advance(conditionalEnd + 2);
-              continue
-            }
-          }
-
-          // Doctype:
-          var doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length);
-            continue
           }
-
-          // End tag:
-          var endTagMatch = html.match(endTag);
-          if (endTagMatch) {
-            var curIndex = index;
-            advance(endTagMatch[0].length);
-            parseEndTag(endTagMatch[1], curIndex, index);
-            continue
+          else {
+              var endTagLength = 0;
+              var stackedTag = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest$1.length;
+              html = rest$1;
+              parseEndTag(stackedTag, index - endTagLength, index);
           }
-
-          // Start tag:
-          var startTagMatch = parseStartTag();
-          if (startTagMatch) {
-            handleStartTag(startTagMatch);
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1);
-            }
-            continue
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                      start: index + html.length,
+                  });
+              }
+              break;
           }
-        }
-
-        var text = (void 0), rest = (void 0), next = (void 0);
-        if (textEnd >= 0) {
-          rest = html.slice(textEnd);
-          while (
-            !endTag.test(rest) &&
-            !startTagOpen.test(rest) &&
-            !comment.test(rest) &&
-            !conditionalComment.test(rest)
-          ) {
-            // < in plain text, be forgiving and treat it as text
-            next = rest.indexOf('<', 1);
-            if (next < 0) { break }
-            textEnd += next;
-            rest = html.slice(textEnd);
-          }
-          text = html.substring(0, textEnd);
-        }
-
-        if (textEnd < 0) {
-          text = html;
-        }
-
-        if (text) {
-          advance(text.length);
-        }
-
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index);
-        }
-      } else {
-        var endTagLength = 0;
-        var stackedTag = lastTag.toLowerCase();
-        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-        var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-          endTagLength = endTag.length;
-          if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-            text = text
-              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-          }
-          if (shouldIgnoreFirstNewline(stackedTag, text)) {
-            text = text.slice(1);
-          }
-          if (options.chars) {
-            options.chars(text);
-          }
-          return ''
-        });
-        index += html.length - rest$1.length;
-        html = rest$1;
-        parseEndTag(stackedTag, index - endTagLength, index);
-      }
-
-      if (html === last) {
-        options.chars && options.chars(html);
-        if (!stack.length && options.warn) {
-          options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-        }
-        break
-      }
-    }
-
-    // Clean up any remaining tags
-    parseEndTag();
-
-    function advance (n) {
-      index += n;
-      html = html.substring(n);
-    }
-
-    function parseStartTag () {
-      var start = html.match(startTagOpen);
-      if (start) {
-        var match = {
-          tagName: start[1],
-          attrs: [],
-          start: index
-        };
-        advance(start[0].length);
-        var end, attr;
-        while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-          attr.start = index;
-          advance(attr[0].length);
-          attr.end = index;
-          match.attrs.push(attr);
-        }
-        if (end) {
-          match.unarySlash = end[1];
-          advance(end[0].length);
-          match.end = index;
-          return match
-        }
-      }
-    }
-
-    function handleStartTag (match) {
-      var tagName = match.tagName;
-      var unarySlash = match.unarySlash;
-
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag);
-        }
-        if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-          parseEndTag(tagName);
-        }
-      }
-
-      var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-      var l = match.attrs.length;
-      var attrs = new Array(l);
-      for (var i = 0; i < l; i++) {
-        var args = match.attrs[i];
-        var value = args[3] || args[4] || args[5] || '';
-        var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-          ? options.shouldDecodeNewlinesForHref
-          : options.shouldDecodeNewlines;
-        attrs[i] = {
-          name: args[1],
-          value: decodeAttr(value, shouldDecodeNewlines)
-        };
-        if (options.outputSourceRange) {
-          attrs[i].start = args.start + args[0].match(/^\s*/).length;
-          attrs[i].end = args.end;
-        }
-      }
-
-      if (!unary) {
-        stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-        lastTag = tagName;
       }
-
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end);
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          var start = html.match(startTagOpen);
+          if (start) {
+              var match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              var end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
       }
-    }
-
-    function parseEndTag (tagName, start, end) {
-      var pos, lowerCasedTagName;
-      if (start == null) { start = index; }
-      if (end == null) { end = index; }
-
-      // Find the closest opened tag of the same type
-      if (tagName) {
-        lowerCasedTagName = tagName.toLowerCase();
-        for (pos = stack.length - 1; pos >= 0; pos--) {
-          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-            break
+      function handleStartTag(match) {
+          var tagName = match.tagName;
+          var unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+          var l = match.attrs.length;
+          var attrs = new Array(l);
+          for (var i = 0; i < l; i++) {
+              var args = match.attrs[i];
+              var value = args[3] || args[4] || args[5] || '';
+              var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
           }
-        }
-      } else {
-        // If no tag name is provided, clean shop
-        pos = 0;
       }
-
-      if (pos >= 0) {
-        // Close all the open elements, up the stack
-        for (var i = stack.length - 1; i >= pos; i--) {
-          if (i > pos || !tagName &&
-            options.warn
-          ) {
-            options.warn(
-              ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-              { start: stack[i].start, end: stack[i].end }
-            );
-          }
-          if (options.end) {
-            options.end(stack[i].tag, start, end);
+      function parseEndTag(tagName, start, end) {
+          var pos, lowerCasedTagName;
+          if (start == null)
+              { start = index; }
+          if (end == null)
+              { end = index; }
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (var i = stack.length - 1; i >= pos; i--) {
+                  if (i > pos || !tagName &&
+                      options.warn) {
+                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
           }
-        }
-
-        // Remove the open elements from the stack
-        stack.length = pos;
-        lastTag = pos && stack[pos - 1].tag;
-      } else if (lowerCasedTagName === 'br') {
-        if (options.start) {
-          options.start(tagName, [], true, start, end);
-        }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end);
-        }
-        if (options.end) {
-          options.end(tagName, start, end);
-        }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   var splitRE$1 = /\r?\n/g;
   var replaceRE = /./g;
   var isSpecialTag = makeMap('script,style,template', true);
-
   /**
    * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
    */
-  function parseComponent (
-    content,
-    options
-  ) {
-    if ( options === void 0 ) options = {};
-
-    var sfc = {
-      template: null,
-      script: null,
-      styles: [],
-      customBlocks: [],
-      errors: []
-    };
-    var depth = 0;
-    var currentBlock = null;
-
-    var warn = function (msg) {
-      sfc.errors.push(msg);
-    };
-
-    if (options.outputSourceRange) {
-      warn = function (msg, range) {
-        var data = { msg: msg };
-        if (range.start != null) {
-          data.start = range.start;
-        }
-        if (range.end != null) {
-          data.end = range.end;
-        }
-        sfc.errors.push(data);
+  function parseComponent(content, options) {
+      if ( options === void 0 ) options = {};
+
+      var sfc = {
+          template: null,
+          script: null,
+          styles: [],
+          customBlocks: [],
+          errors: [],
       };
-    }
-
-    function start (
-      tag,
-      attrs,
-      unary,
-      start,
-      end
-    ) {
-      if (depth === 0) {
-        currentBlock = {
-          type: tag,
-          content: '',
-          start: end,
-          attrs: attrs.reduce(function (cumulated, ref) {
-            var name = ref.name;
-            var value = ref.value;
-
-            cumulated[name] = value || true;
-            return cumulated
-          }, {})
-        };
-        if (isSpecialTag(tag)) {
-          checkAttrs(currentBlock, attrs);
-          if (tag === 'style') {
-            sfc.styles.push(currentBlock);
-          } else {
-            sfc[tag] = currentBlock;
-          }
-        } else { // custom blocks
-          sfc.customBlocks.push(currentBlock);
-        }
+      var depth = 0;
+      var currentBlock = null;
+      var warn = function (msg) {
+          sfc.errors.push(msg);
+      };
+      if (options.outputSourceRange) {
+          warn = function (msg, range) {
+              var data = { msg: msg };
+              if (range.start != null) {
+                  data.start = range.start;
+              }
+              if (range.end != null) {
+                  data.end = range.end;
+              }
+              sfc.errors.push(data);
+          };
       }
-      if (!unary) {
-        depth++;
+      function start(tag, attrs, unary, start, end) {
+          if (depth === 0) {
+              currentBlock = {
+                  type: tag,
+                  content: '',
+                  start: end,
+                  attrs: attrs.reduce(function (cumulated, ref) {
+                      var name = ref.name;
+                      var value = ref.value;
+
+                      cumulated[name] = value || true;
+                      return cumulated;
+                  }, {}),
+              };
+              if (isSpecialTag(tag)) {
+                  checkAttrs(currentBlock, attrs);
+                  if (tag === 'style') {
+                      sfc.styles.push(currentBlock);
+                  }
+                  else {
+                      sfc[tag] = currentBlock;
+                  }
+              }
+              else {
+                  // custom blocks
+                  sfc.customBlocks.push(currentBlock);
+              }
+          }
+          if (!unary) {
+              depth++;
+          }
       }
-    }
-
-    function checkAttrs (block, attrs) {
-      for (var i = 0; i < attrs.length; i++) {
-        var attr = attrs[i];
-        if (attr.name === 'lang') {
-          block.lang = attr.value;
-        }
-        if (attr.name === 'scoped') {
-          block.scoped = true;
-        }
-        if (attr.name === 'module') {
-          block.module = attr.value || true;
-        }
-        if (attr.name === 'src') {
-          block.src = attr.value;
-        }
+      function checkAttrs(block, attrs) {
+          for (var i = 0; i < attrs.length; i++) {
+              var attr = attrs[i];
+              if (attr.name === 'lang') {
+                  block.lang = attr.value;
+              }
+              if (attr.name === 'scoped') {
+                  block.scoped = true;
+              }
+              if (attr.name === 'module') {
+                  block.module = attr.value || true;
+              }
+              if (attr.name === 'src') {
+                  block.src = attr.value;
+              }
+          }
       }
-    }
-
-    function end (tag, start) {
-      if (depth === 1 && currentBlock) {
-        currentBlock.end = start;
-        var text = content.slice(currentBlock.start, currentBlock.end);
-        if (options.deindent !== false) {
-          text = deIndent(text);
-        }
-        // pad content so that linters and pre-processors can output correct
-        // line numbers in errors and warnings
-        if (currentBlock.type !== 'template' && options.pad) {
-          text = padContent(currentBlock, options.pad) + text;
-        }
-        currentBlock.content = text;
-        currentBlock = null;
+      function end(tag, start) {
+          if (depth === 1 && currentBlock) {
+              currentBlock.end = start;
+              var text = content.slice(currentBlock.start, currentBlock.end);
+              if (options.deindent !== false) {
+                  //@ts-expect-error
+                  text = deIndent(text);
+              }
+              // pad content so that linters and pre-processors can output correct
+              // line numbers in errors and warnings
+              if (currentBlock.type !== 'template' && options.pad) {
+                  text = padContent(currentBlock, options.pad) + text;
+              }
+              currentBlock.content = text;
+              currentBlock = null;
+          }
+          depth--;
       }
-      depth--;
-    }
-
-    function padContent (block, pad) {
-      if (pad === 'space') {
-        return content.slice(0, block.start).replace(replaceRE, ' ')
-      } else {
-        var offset = content.slice(0, block.start).split(splitRE$1).length;
-        var padChar = block.type === 'script' && !block.lang
-          ? '//\n'
-          : '\n';
-        return Array(offset).join(padChar)
+      function padContent(block, pad) {
+          if (pad === 'space') {
+              return content.slice(0, block.start).replace(replaceRE, ' ');
+          }
+          else {
+              var offset = content.slice(0, block.start).split(splitRE$1).length;
+              var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+              return Array(offset).join(padChar);
+          }
       }
-    }
-
-    parseHTML(content, {
-      warn: warn,
-      start: start,
-      end: end,
-      outputSourceRange: options.outputSourceRange
-    });
-
-    return sfc
+      parseHTML(content, {
+          warn: warn,
+          start: start,
+          end: end,
+          outputSourceRange: options.outputSourceRange,
+      });
+      return sfc;
   }
 
-  /*  */
-
+  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
-
   // Browser environment sniffing
   var inBrowser = typeof window !== 'undefined';
-  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
+  var inWeex = 
+  // @ts-ignore
+  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  // @ts-ignore
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
   var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
   var isPhantomJS = UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
-
   // Firefox has a "watch" function on Object.prototype...
-  var nativeWatch = ({}).watch;
+  // @ts-ignore
+  var nativeWatch = {}.watch;
   if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, 'passive', ({
-        get: function get () {
-        }
-      })); // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts);
-    } catch (e) {}
+      try {
+          var opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get: function get() {
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          // @ts-ignore
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
   }
-
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
   var _isServer;
   var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-      } else {
-        _isServer = false;
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
       }
-    }
-    return _isServer
+      return _isServer;
   };
-
   // detect devtools
+  // @ts-ignore TODO decalre this types
   var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
   /* istanbul ignore next */
-  function isNative (Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-
-  var hasSymbol =
-    typeof Symbol !== 'undefined' && isNative(Symbol) &&
-    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-  var _Set;
-  /* istanbul ignore if */ // $flow-disable-line
-  if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-      function Set () {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has (key) {
-        return this.set[key] === true
-      };
-      Set.prototype.add = function add (key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear () {
-        this.set = Object.create(null);
-      };
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  var hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  var _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = /*@__PURE__*/(function () {
+          function Set() {
+              this.set = Object.create(null);
+          }
+          Set.prototype.has = function has (key) {
+              return this.set[key] === true;
+          };
+          Set.prototype.add = function add (key) {
+              this.set[key] = true;
+          };
+          Set.prototype.clear = function clear () {
+              this.set = Object.create(null);
+          };
 
-      return Set;
-    }());
+          return Set;
+      }());
   }
 
-  var ASSET_TYPES = [
-    'component',
-    'directive',
-    'filter'
-  ];
-
+  var ASSET_TYPES = ['component', 'directive', 'filter'];
   var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
-  ];
-
-  /*  */
-
-
-
-  var config = ({
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  });
-
-  /*  */
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch' ];
+
+  /* @flow */
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
+  };
 
+  /* @flow */
   var warn = noop;
   var tip = noop;
-  var generateComponentTrace = (noop); // work around flow check
-  var formatComponentName = (noop);
-
+  var generateComponentTrace; // work around flow check
+  var formatComponentName;
   {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str
-      .replace(classifyRE, function (c) { return c.toUpperCase(); })
-      .replace(/[-_]/g, ''); };
-
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : '';
-
-      if (hasConsole && (!config.silent)) {
-        console.error(("[Vue warn]: " + msg + trace));
-      }
-    };
-
-    tip = function (msg, vm) {
-      if (hasConsole && (!config.silent)) {
-        console.warn("[Vue tip]: " + msg + (
-          vm ? generateComponentTrace(vm) : ''
-        ));
-      }
-    };
-
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options = typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-
-      return (
-        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-        (file && includeFile !== false ? (" at " + file) : '')
-      )
-    };
-
-    var repeat = function (str, n) {
-      var res = '';
-      while (n) {
-        if (n % 2 === 1) { res += str; }
-        if (n > 1) { str += str; }
-        n >>= 1;
-      }
-      return res
-    };
-
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+      warn = function (msg, vm) {
+          var trace = vm ? generateComponentTrace(vm) : '';
+          if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
           }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return '\n\nfound in\n\n' + tree
-          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-              : formatComponentName(vm))); })
-          .join('\n')
-      } else {
-        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-      }
-    };
+      };
+      tip = function (msg, vm) {
+          if (hasConsole && !config.silent) {
+              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = function (vm, includeFile) {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          var options = 
+          // @ts-ignore
+          typeof vm === 'function' && vm.cid != null
+              ? // @ts-ignore
+                  vm.options
+              : vm._isVue
+                  ? // @ts-ignore
+                      vm.$options || vm.constructor.options
+                  : vm;
+          var name = options.name || options._componentTag;
+          var file = options.__file;
+          if (!name && file) {
+              var match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
+      };
+      var repeat = function (str, n) {
+          var res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  { res += str; }
+              if (n > 1)
+                  { str += str; }
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = function (vm) {
+          // @ts-ignore
+          if (vm._isVue && vm.$parent) {
+              var tree = [];
+              var currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      var last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
+                      .join('\n'));
+          }
+          else {
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+          }
+      };
   }
 
-  /*  */
-
   var uid = 0;
-
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep () {
-    this.id = uid++;
-    this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid++;
+      this.subs = [];
   };
-
   Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
+      this.subs.push(sub);
   };
-
   Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
+      remove(this.subs, sub);
   };
-
   Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
+      if (Dep.target) {
+          Dep.target.addDep(this);
+      }
   };
-
   Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
   };
-
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
 
-  /*  */
-
-  var VNode = function VNode (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
   };
 
   var prototypeAccessors = { child: { configurable: true } };
-
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   prototypeAccessors.child.get = function () {
-    return this.componentInstance
+      return this.componentInstance;
   };
 
   Object.defineProperties( VNode.prototype, prototypeAccessors );
@@ -1116,422 +993,367 @@
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-
   var arrayProto = Array.prototype;
   var arrayMethods = Object.create(arrayProto);
-
   var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-  ];
-
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse' ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args;
-          break
-        case 'splice':
-          inserted = args.slice(2);
-          break
-      }
-      if (inserted) { ob.observeArray(inserted); }
-      // notify change
-      ob.dep.notify();
-      return result
-    });
+      // cache original method
+      var original = arrayProto[method];
+      def(arrayMethods, method, function mutator() {
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
+
+          var result = original.apply(this, args);
+          var ob = this.__ob__;
+          var inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              { ob.observeArray(inserted); }
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  /*  */
-
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
   var shouldObserve = true;
-
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
+          }
+          else {
+              copyAugment(value, arrayMethods, arrayKeys);
+          }
+          this.observeArray(value);
+      }
+      else {
+          this.walk(value);
+      }
   };
-
   /**
    * Walk through all properties and convert them into
    * getter/setters. This method should only be called when
    * value type is Object.
    */
   Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
-    }
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive$$1(obj, keys[i]);
+      }
   };
-
   /**
    * Observe a list of Array items.
    */
   Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
   };
-
   // helpers
-
   /**
    * Augment a target Object or Array by intercepting
    * the prototype chain using __proto__
    */
-  function protoAugment (target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
   }
-
   /**
    * Augment a target Object or Array by defining
    * hidden properties.
    */
   /* istanbul ignore next */
-  function copyAugment (target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
+  function copyAugment(target, src, keys) {
+      for (var i = 0, l = keys.length; i < l; i++) {
+          var key = keys[i];
+          def(target, key, src[key]);
+      }
   }
-
   /**
    * Attempt to create an observer instance for a value,
    * returns the new observer if successfully observed,
    * or the existing observer if the value already has one.
    */
-  function observe (value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      var ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
   }
-
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1 (
-    obj,
-    key,
-    val,
-    customSetter,
-    shallow
-  ) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter () {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter (newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) { return }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      }
-    });
+  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+      var dep = new Dep();
+      var property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      var getter = property && property.get;
+      var setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      var childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              var value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              var value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  { return; }
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
   }
-
   /**
    * Set a property on an object. Adds the new property and
    * triggers change notification if the property doesn't
    * already exist.
    */
-  function set (target, key, val) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-        'at runtime - declare it upfront in the data option.'
-      );
-      return val
-    }
-    if (!ob) {
-      target[key] = val;
-      return val
-    }
-    defineReactive$$1(ob.value, key, val);
-    ob.dep.notify();
-    return val
+  function set(target, key, val) {
+      if (isUndef(target) || isPrimitive(target)) {
+          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      var ob = target.__ob__;
+      // @ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive$$1(ob.value, key, val);
+      ob.dep.notify();
+      return val;
   }
-
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
-  function dependArray (value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
+  function dependArray(value) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
    */
   var strats = config.optionMergeStrategies;
-
   /**
    * Options with restrictions
    */
   {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          "option \"" + key + "\" can only be used during instance " +
-          'creation with the `new` keyword.'
-        );
-      }
-      return defaultStrat(parent, child)
-    };
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn("option \"" + key + "\" can only be used during instance " +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
   }
-
   /**
    * Helper that recursively merges two data objects together.
    */
-  function mergeData (to, from) {
-    if (!from) { return to }
-    var key, toVal, fromVal;
-
-    var keys = hasSymbol
-      ? Reflect.ownKeys(from)
-      : Object.keys(from);
-
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === '__ob__') { continue }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
+  function mergeData(to, from) {
+      if (!from)
+          { return to; }
+      var key, toVal, fromVal;
+      var keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (var i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              { continue; }
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
       }
-    }
-    return to
+      return to;
   }
-
   /**
    * Data
    */
-  function mergeDataOrFn (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn () {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn () {
-        // instance merge
-        var instanceData = typeof childVal === 'function'
-          ? childVal.call(vm, vm)
-          : childVal;
-        var defaultData = typeof parentVal === 'function'
-          ? parentVal.call(vm, vm)
-          : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(
+              // @ts-ignore
+              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+              // @ts-ignore
+              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
       }
-    }
   }
-
-  strats.data = function (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn(
-          'The "data" option should be a function ' +
-          'that returns a per-instance value in component ' +
-          'definitions.',
-          vm
-        );
-
-        return parentVal
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
       }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-
-    return mergeDataOrFn(parentVal, childVal, vm)
+      return mergeDataOrFn(parentVal, childVal, vm);
   };
-
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook (
-    parentVal,
-    childVal
-  ) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-          ? childVal
-          : [childVal]
-      : parentVal;
-    return res
-      ? dedupeHooks(res)
-      : res
+  function mergeHook(parentVal, childVal) {
+      var res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
   }
-
-  function dedupeHooks (hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
+  function dedupeHooks(hooks) {
+      var res = [];
+      for (var i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
       }
-    }
-    return res
+      return res;
   }
-
   LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+      strats[hook] = mergeHook;
   });
-
   /**
    * Assets
    *
@@ -1539,119 +1361,97 @@
    * a three-way merge between constructor options, instance
    * options and parent options.
    */
-  function mergeAssets (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal)
-    } else {
-      return res
-    }
+  function mergeAssets(parentVal, childVal, vm, key) {
+      var res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
   }
-
   ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
+      strats[type + 's'] = mergeAssets;
   });
-
   /**
    * Watchers.
    *
    * Watchers hashes should not overwrite one
    * another, so we merge them as arrays.
    */
-  strats.watch = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    // work around Firefox's Object.prototype.watch...
-    if (parentVal === nativeWatch) { parentVal = undefined; }
-    if (childVal === nativeWatch) { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal) { return Object.create(parentVal || null) }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child) ? child : [child];
-    }
-    return ret
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          { parentVal = undefined; }
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          { childVal = undefined; }
+      /* istanbul ignore if */
+      if (!childVal)
+          { return Object.create(parentVal || null); }
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = {};
+      extend(ret, parentVal);
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
   };
-
   /**
    * Other object hashes.
    */
-  strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== 'production') {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) { extend(ret, childVal); }
-    return ret
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          { extend(ret, childVal); }
+      return ret;
   };
   strats.provide = mergeDataOrFn;
-
   /**
    * Default strategy.
    */
   var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined
-      ? parentVal
-      : childVal
+      return childVal === undefined ? parentVal : childVal;
   };
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
-      );
-    }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn("Invalid value for option \"" + name + "\": expected an Object, " +
+              "but got " + (toRawType(value)) + ".", vm);
+      }
   }
 
-  /*  */
-
-  /*  */
-
-  /*  */
+  /* @flow */
 
+  /* @flow */
   var callbacks = [];
-
-  function flushCallbacks () {
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
+  function flushCallbacks() {
+      var copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (var i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
   }
-
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -1659,578 +1459,501 @@
   // completely stops working after triggering a few times... so, if native
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-    isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]'
-  )) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true
-    });
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-  /*  */
+  if (typeof Promise !== 'undefined' && isNative(Promise)) ;
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      var counter = 1;
+      var observer = new MutationObserver(flushCallbacks);
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 
-  /*  */
+  /* @flow */
 
+  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   var isReservedAttr = makeMap('style,class');
-
   // attributes that should be using props for binding
   var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
   };
-
   var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
   var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,translate,' +
-    'truespeed,typemustmatch,visible'
-  );
-
-  /*  */
-
-  /*  */
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-  );
-
+  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+
+  /* @flow */
+
+  /* @flow */
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  );
-
+  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
   var isPreTag = function (tag) { return tag === 'pre'; };
-
   var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
+      return isHTMLTag(tag) || isSVG(tag);
   };
-
-  function getTagNamespace (tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
   }
-
   var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /*  */
-
-  /*  */
+  /* @flow */
 
+  /* @flow */
   var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-  function parseFilters (exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
-
-    for (i = 0; i < exp.length; i++) {
-      prev = c;
-      c = exp.charCodeAt(i);
-      if (inSingle) {
-        if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-      } else if (inDouble) {
-        if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-      } else if (inTemplateString) {
-        if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-      } else if (inRegex) {
-        if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-      } else if (
-        c === 0x7C && // pipe
-        exp.charCodeAt(i + 1) !== 0x7C &&
-        exp.charCodeAt(i - 1) !== 0x7C &&
-        !curly && !square && !paren
-      ) {
-        if (expression === undefined) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1;
-          expression = exp.slice(0, i).trim();
-        } else {
-          pushFilter();
-        }
-      } else {
-        switch (c) {
-          case 0x22: inDouble = true; break         // "
-          case 0x27: inSingle = true; break         // '
-          case 0x60: inTemplateString = true; break // `
-          case 0x28: paren++; break                 // (
-          case 0x29: paren--; break                 // )
-          case 0x5B: square++; break                // [
-          case 0x5D: square--; break                // ]
-          case 0x7B: curly++; break                 // {
-          case 0x7D: curly--; break                 // }
-        }
-        if (c === 0x2f) { // /
-          var j = i - 1;
-          var p = (void 0);
-          // find first non-whitespace prev char
-          for (; j >= 0; j--) {
-            p = exp.charAt(j);
-            if (p !== ' ') { break }
+  function parseFilters(exp) {
+      var inSingle = false;
+      var inDouble = false;
+      var inTemplateString = false;
+      var inRegex = false;
+      var curly = 0;
+      var square = 0;
+      var paren = 0;
+      var lastFilterIndex = 0;
+      var c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  { inSingle = false; }
           }
-          if (!p || !validDivisionCharRE.test(p)) {
-            inRegex = true;
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  { inDouble = false; }
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  { inTemplateString = false; }
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  { inRegex = false; }
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  var j = i - 1;
+                  var p = (void 0);
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          { break; }
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
           }
-        }
       }
-    }
-
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
-    }
-
-    function pushFilter () {
-      (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-      lastFilterIndex = i + 1;
-    }
-
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i]);
+      if (expression === undefined) {
+          expression = exp.slice(0, i).trim();
       }
-    }
-
-    return expression
+      else if (lastFilterIndex !== 0) {
+          pushFilter();
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
   }
-
-  function wrapFilter (exp, filter) {
-    var i = filter.indexOf('(');
-    if (i < 0) {
-      // _f: resolveFilter
-      return ("_f(\"" + filter + "\")(" + exp + ")")
-    } else {
-      var name = filter.slice(0, i);
-      var args = filter.slice(i + 1);
-      return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-    }
+  function wrapFilter(exp, filter) {
+      var i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return ("_f(\"" + filter + "\")(" + exp + ")");
+      }
+      else {
+          var name = filter.slice(0, i);
+          var args = filter.slice(i + 1);
+          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
   var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+      var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
   });
-
-
-
-  function parseText (
-    text,
-    delimiters
-  ) {
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-      return
-    }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = tagRE.lastIndex = 0;
-    var match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-      index = match.index;
-      // push text token
-      if (index > lastIndex) {
-        rawTokens.push(tokenValue = text.slice(lastIndex, index));
-        tokens.push(JSON.stringify(tokenValue));
-      }
-      // tag token
-      var exp = parseFilters(match[1].trim());
-      tokens.push(("_s(" + exp + ")"));
-      rawTokens.push({ '@binding': exp });
-      lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      rawTokens.push(tokenValue = text.slice(lastIndex));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
-    }
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      var tokens = [];
+      var rawTokens = [];
+      var lastIndex = (tagRE.lastIndex = 0);
+      var match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          var exp = parseFilters(match[1].trim());
+          tokens.push(("_s(" + exp + ")"));
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
   }
 
-  /*  */
-
-
-
+  /* @flow */
   /* eslint-disable no-unused-vars */
-  function baseWarn (msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+  function baseWarn(msg, range) {
+      console.error(("[Vue compiler]: " + msg));
   }
   /* eslint-enable no-unused-vars */
-
-  function pluckModuleFunction (
-    modules,
-    key
-  ) {
-    return modules
-      ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-      : []
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
   }
-
-  function addProp (el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      el.plain = false;
   }
-
-  function addAttr (el, name, value, range, dynamic) {
-    var attrs = dynamic
-      ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-      : (el.attrs || (el.attrs = []));
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addAttr(el, name, value, range, dynamic) {
+      var attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      el.plain = false;
   }
-
   // add a raw attr (use this in preTransforms)
-  function addRawAttr (el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name: name,
+          rawName: rawName,
+          value: value,
+          arg: arg,
+          isDynamicArg: isDynamicArg,
+          modifiers: modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      var events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      var handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
   }
-
-  function addDirective (
-    el,
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers,
-    range
-  ) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-      name: name,
-      rawName: rawName,
-      value: value,
-      arg: arg,
-      isDynamicArg: isDynamicArg,
-      modifiers: modifiers
-    }, range));
-    el.plain = false;
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
   }
-
-  function prependModifierMarker (symbol, name, dynamic) {
-    return dynamic
-      ? ("_p(" + name + ",\"" + symbol + "\")")
-      : symbol + name // mark the event as captured
+  function getBindingAttr(el, name, getStatic) {
+      var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          var staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
   }
-
-  function addHandler (
-    el,
-    name,
-    value,
-    modifiers,
-    important,
-    warn,
-    range,
-    dynamic
-  ) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (
-      warn &&
-      modifiers.prevent && modifiers.passive
-    ) {
-      warn(
-        'passive and prevent can\'t be used together. ' +
-        'Passive handler can\'t prevent default event.',
-        range
-      );
-    }
-
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'contextmenu';
-        delete modifiers.right;
-      }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'mouseup';
+  // note: this only removes the attr from the Array (attrsList) so that it
+  // doesn't get processed by processAttrs.
+  // By default it does NOT remove it from the map (attrsMap) because the map is
+  // needed during codegen.
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      var val;
+      if ((val = el.attrsMap[name]) != null) {
+          var list = el.attrsList;
+          for (var i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
       }
-    }
-
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture;
-      name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-      delete modifiers.once;
-      name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive;
-      name = prependModifierMarker('&', name, dynamic);
-    }
-
-    var events;
-    if (modifiers.native) {
-      delete modifiers.native;
-      events = el.nativeEvents || (el.nativeEvents = {});
-    } else {
-      events = el.events || (el.events = {});
-    }
-
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers;
-    }
-
-    var handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-      important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    } else if (handlers) {
-      events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    } else {
-      events[name] = newHandler;
-    }
-
-    el.plain = false;
-  }
-
-  function getRawBindingAttr (
-    el,
-    name
-  ) {
-    return el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
-  }
-
-  function getBindingAttr (
-    el,
-    name,
-    getStatic
-  ) {
-    var dynamicValue =
-      getAndRemoveAttr(el, ':' + name) ||
-      getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-      return parseFilters(dynamicValue)
-    } else if (getStatic !== false) {
-      var staticValue = getAndRemoveAttr(el, name);
-      if (staticValue != null) {
-        return JSON.stringify(staticValue)
+      if (removeFromMap) {
+          delete el.attrsMap[name];
       }
-    }
+      return val;
   }
-
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr (
-    el,
-    name,
-    removeFromMap
-  ) {
-    var val;
-    if ((val = el.attrsMap[name]) != null) {
+  function getAndRemoveAttrByRegex(el, name) {
       var list = el.attrsList;
       for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i].name === name) {
-          list.splice(i, 1);
-          break
-        }
+          var attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
       }
-    }
-    if (removeFromMap) {
-      delete el.attrsMap[name];
-    }
-    return val
   }
-
-  function getAndRemoveAttrByRegex (
-    el,
-    name
-  ) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      var attr = list[i];
-      if (name.test(attr.name)) {
-        list.splice(i, 1);
-        return attr
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
       }
-    }
+      return item;
   }
 
-  function rangeSetItem (
-    item,
-    range
-  ) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start;
+  /* @flow */
+  function transformNode(el, options) {
+      var warn = options.warn || baseWarn;
+      var staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          var res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn("class=\"" + staticClass + "\": " +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
       }
-      if (range.end != null) {
-        item.end = range.end;
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass);
       }
-    }
-    return item
-  }
-
-  /*  */
-
-  function transformNode (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-      var res = parseText(staticClass, options.delimiters);
-      if (res) {
-        warn(
-          "class=\"" + staticClass + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div class="{{ val }}">, use <div :class="val">.',
-          el.rawAttrsMap['class']
-        );
+      var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
       }
-    }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass);
-    }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-      el.classBinding = classBinding;
-    }
   }
-
-  function genData (el) {
-    var data = '';
-    if (el.staticClass) {
-      data += "staticClass:" + (el.staticClass) + ",";
-    }
-    if (el.classBinding) {
-      data += "class:" + (el.classBinding) + ",";
-    }
-    return data
+  function genData(el) {
+      var data = '';
+      if (el.staticClass) {
+          data += "staticClass:" + (el.staticClass) + ",";
+      }
+      if (el.classBinding) {
+          data += "class:" + (el.classBinding) + ",";
+      }
+      return data;
   }
-
   var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData
+      staticKeys: ['staticClass'],
+      transformNode: transformNode,
+      genData: genData,
   };
 
-  /*  */
-
+  /* @flow */
   var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res
+      var res = {};
+      var listDelimiter = /;(?![^(]*\))/g;
+      var propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              var tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
   });
 
-  /*  */
-
-  function transformNode$1 (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-      /* istanbul ignore if */
-      {
-        var res = parseText(staticStyle, options.delimiters);
-        if (res) {
-          warn(
-            "style=\"" + staticStyle + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div style="{{ val }}">, use <div :style="val">.',
-            el.rawAttrsMap['style']
-          );
-        }
+  /* @flow */
+  function transformNode$1(el, options) {
+      var warn = options.warn || baseWarn;
+      var staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              var res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn("style=\"" + staticStyle + "\": " +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
       }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-      el.styleBinding = styleBinding;
-    }
   }
-
-  function genData$1 (el) {
-    var data = '';
-    if (el.staticStyle) {
-      data += "staticStyle:" + (el.staticStyle) + ",";
-    }
-    if (el.styleBinding) {
-      data += "style:(" + (el.styleBinding) + "),";
-    }
-    return data
+  function genData$1(el) {
+      var data = '';
+      if (el.staticStyle) {
+          data += "staticStyle:" + (el.staticStyle) + ",";
+      }
+      if (el.styleBinding) {
+          data += "style:(" + (el.styleBinding) + "),";
+      }
+      return data;
   }
-
   var style = {
-    staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
-    genData: genData$1
+      staticKeys: ['staticStyle'],
+      transformNode: transformNode$1,
+      genData: genData$1,
   };
 
   var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -2578,55 +2301,49 @@
   }(commonjsGlobal));
   });
 
-  /*  */
+  var he$1 = /*#__PURE__*/Object.freeze({
+    default: he,
+    __moduleExports: he
+  });
 
+  /* @flow */
   /**
    * Cross-platform code generation for component v-model
    */
-  function genComponentModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
-    if (trim) {
-      valueExpression =
-        "(typeof " + baseValueExpression + " === 'string'" +
-        "? " + baseValueExpression + ".trim()" +
-        ": " + baseValueExpression + ")";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-    var assignment = genAssignmentCode(value, valueExpression);
-
-    el.model = {
-      value: ("(" + value + ")"),
-      expression: JSON.stringify(value),
-      callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-    };
+  function genComponentModel(el, value, modifiers) {
+      var ref = modifiers || {};
+      var number = ref.number;
+      var trim = ref.trim;
+      var baseValueExpression = '$$v';
+      var valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              "(typeof " + baseValueExpression + " === 'string'" +
+                  "? " + baseValueExpression + ".trim()" +
+                  ": " + baseValueExpression + ")";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: ("(" + value + ")"),
+          expression: JSON.stringify(value),
+          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+      };
   }
-
   /**
    * Cross-platform codegen helper for generating v-model value assignment code.
    */
-  function genAssignmentCode (
-    value,
-    assignment
-  ) {
-    var res = parseModel(value);
-    if (res.key === null) {
-      return (value + "=" + assignment)
-    } else {
-      return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-    }
+  function genAssignmentCode(value, assignment) {
+      var res = parseModel(value);
+      if (res.key === null) {
+          return (value + "=" + assignment);
+      }
+      else {
+          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+      }
   }
-
   /**
    * Parse a v-model expression into a base path and a final key segment.
    * Handles both dot-path and possible square brackets.
@@ -2641,115 +2358,98 @@
    * - test.xxx.a["asa"][test1[key]]
    *
    */
-
   var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-  function parseModel (val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-      index = val.lastIndexOf('.');
-      if (index > -1) {
-        return {
-          exp: val.slice(0, index),
-          key: '"' + val.slice(index + 1) + '"'
-        }
-      } else {
-        return {
-          exp: val,
-          key: null
-        }
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
+              return {
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
       }
-    }
-
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-
-    while (!eof()) {
-      chr = next();
-      /* istanbul ignore if */
-      if (isStringStart(chr)) {
-        parseString(chr);
-      } else if (chr === 0x5B) {
-        parseBracket(chr);
+      str = val;
+      index = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
       }
-    }
-
-    return {
-      exp: val.slice(0, expressionPos),
-      key: val.slice(expressionPos + 1, expressionEndPos)
-    }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
   }
-
-  function next () {
-    return str.charCodeAt(++index)
+  function next() {
+      return str.charCodeAt(++index);
   }
-
-  function eof () {
-    return index >= len
+  function eof() {
+      return index >= len;
   }
-
-  function isStringStart (chr) {
-    return chr === 0x22 || chr === 0x27
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
   }
-
-  function parseBracket (chr) {
-    var inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-      chr = next();
-      if (isStringStart(chr)) {
-        parseString(chr);
-        continue
-      }
-      if (chr === 0x5B) { inBracket++; }
-      if (chr === 0x5D) { inBracket--; }
-      if (inBracket === 0) {
-        expressionEndPos = index;
-        break
+  function parseBracket(chr) {
+      var inBracket = 1;
+      expressionPos = index;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              { inBracket++; }
+          if (chr === 0x5d)
+              { inBracket--; }
+          if (inBracket === 0) {
+              expressionEndPos = index;
+              break;
+          }
       }
-    }
   }
-
-  function parseString (chr) {
-    var stringQuote = chr;
-    while (!eof()) {
-      chr = next();
-      if (chr === stringQuote) {
-        break
+  function parseString(chr) {
+      var stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
       }
-    }
   }
 
-  /*  */
-
+  /* @flow */
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
   var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
   var stripParensRE = /^\(|\)$/g;
   var dynamicArgRE = /^\[.*\]$/;
-
   var argRE = /:(.*)$/;
   var bindRE = /^:|^\.|^v-bind:/;
   var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
   var slotRE = /^v-slot(:|$)|^#/;
-
   var lineBreakRE = /[\r\n]/;
-  var whitespaceRE = /\s+/g;
-
+  var whitespaceRE = /[ \f\t\r\n]+/g;
   var invalidAttributeRE = /[\s"'<>\/=]/;
-
-  var decodeHTMLCached = cached(he.decode);
-
+  var decodeHTMLCached = cached(undefined);
   var emptySlotScopeToken = "_empty_";
-
   // configurable state
   var warn$1;
   var delimiters;
@@ -2760,1206 +2460,1014 @@
   var platformMustUseProp;
   var platformGetTagNamespace;
   var maybeComponent;
-
-  function createASTElement (
-    tag,
-    attrs,
-    parent
-  ) {
-    return {
-      type: 1,
-      tag: tag,
-      attrsList: attrs,
-      attrsMap: makeAttrsMap(attrs),
-      rawAttrsMap: {},
-      parent: parent,
-      children: []
-    }
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag: tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent: parent,
+          children: [],
+      };
   }
-
   /**
    * Convert HTML string to AST.
    */
-  function parse (
-    template,
-    options
-  ) {
-    warn$1 = options.warn || baseWarn;
-
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-    delimiters = options.delimiters;
-
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
-
-    function warnOnce (msg, range) {
-      if (!warned) {
-        warned = true;
-        warn$1(msg, range);
-      }
-    }
-
-    function closeElement (element) {
-      trimEndingWhitespace(element);
-      if (!inVPre && !element.processed) {
-        element = processElement(element, options);
-      }
-      // tree management
-      if (!stack.length && element !== root) {
-        // allow root elements with v-if, v-else-if and v-else
-        if (root.if && (element.elseif || element.else)) {
-          {
-            checkRootConstraints(element);
+  function parse(template, options) {
+      warn$1 = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      var isReservedTag = options.isReservedTag || no;
+      maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      var stack = [];
+      var preserveWhitespace = options.preserveWhitespace !== false;
+      var whitespaceOption = options.whitespace;
+      var root;
+      var currentParent;
+      var inVPre = false;
+      var inPre = false;
+      var warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn$1(msg, range);
           }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          });
-        } else {
-          warnOnce(
-            "Component template should contain exactly one root element. " +
-            "If you are using v-if on multiple elements, " +
-            "use v-else-if to chain them instead.",
-            { start: element.start }
-          );
-        }
-      }
-      if (currentParent && !element.forbidden) {
-        if (element.elseif || element.else) {
-          processIfConditions(element, currentParent);
-        } else {
-          if (element.slotScope) {
-            // scoped slot
-            // keep it in the children list so that v-else(-if) conditions can
-            // find it as the prev node.
-            var name = element.slotTarget || '"default"'
-            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-          }
-          currentParent.children.push(element);
-          element.parent = currentParent;
-        }
-      }
-
-      // final children cleanup
-      // filter out scoped slots
-      element.children = element.children.filter(function (c) { return !(c).slotScope; });
-      // remove trailing whitespace node again
-      trimEndingWhitespace(element);
-
-      // check pre state
-      if (element.pre) {
-        inVPre = false;
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false;
-      }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options);
-      }
-    }
-
-    function trimEndingWhitespace (el) {
-      // remove trailing whitespace node
-      if (!inPre) {
-        var lastNode;
-        while (
-          (lastNode = el.children[el.children.length - 1]) &&
-          lastNode.type === 3 &&
-          lastNode.text === ' '
-        ) {
-          el.children.pop();
-        }
-      }
-    }
-
-    function checkRootConstraints (el) {
-      if (el.tag === 'slot' || el.tag === 'template') {
-        warnOnce(
-          "Cannot use <" + (el.tag) + "> as component root element because it may " +
-          'contain multiple nodes.',
-          { start: el.start }
-        );
-      }
-      if (el.attrsMap.hasOwnProperty('v-for')) {
-        warnOnce(
-          'Cannot use v-for on stateful component root element because ' +
-          'it renders multiple elements.',
-          el.rawAttrsMap['v-for']
-        );
       }
-    }
-
-    parseHTML(template, {
-      warn: warn$1,
-      expectHTML: options.expectHTML,
-      isUnaryTag: options.isUnaryTag,
-      canBeLeftOpenTag: options.canBeLeftOpenTag,
-      shouldDecodeNewlines: options.shouldDecodeNewlines,
-      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-      shouldKeepComment: options.comments,
-      outputSourceRange: options.outputSourceRange,
-      start: function start (tag, attrs, unary, start$1, end) {
-        // check namespace.
-        // inherit parent ns if there is one
-        var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-        // handle IE svg bug
-        /* istanbul ignore if */
-        if (isIE && ns === 'svg') {
-          attrs = guardIESVGBug(attrs);
-        }
-
-        var element = createASTElement(tag, attrs, currentParent);
-        if (ns) {
-          element.ns = ns;
-        }
-
-        {
-          if (options.outputSourceRange) {
-            element.start = start$1;
-            element.end = end;
-            element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-              cumulated[attr.name] = attr;
-              return cumulated
-            }, {});
-          }
-          attrs.forEach(function (attr) {
-            if (invalidAttributeRE.test(attr.name)) {
-              warn$1(
-                "Invalid dynamic argument expression: attribute names cannot contain " +
-                "spaces, quotes, <, >, / or =.",
-                {
-                  start: attr.start + attr.name.indexOf("["),
-                  end: attr.start + attr.name.length
-                }
-              );
-            }
-          });
-        }
-
-        if (isForbiddenTag(element) && !isServerRendering()) {
-          element.forbidden = true;
-          warn$1(
-            'Templates should only be responsible for mapping the state to the ' +
-            'UI. Avoid placing tags with side-effects in your templates, such as ' +
-            "<" + tag + ">" + ', as they will not be parsed.',
-            { start: element.start }
-          );
-        }
-
-        // apply pre-transforms
-        for (var i = 0; i < preTransforms.length; i++) {
-          element = preTransforms[i](element, options) || element;
-        }
-
-        if (!inVPre) {
-          processPre(element);
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce("Component template should contain exactly one root element. " +
+                      "If you are using v-if on multiple elements, " +
+                      "use v-else-if to chain them instead.", { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      var name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter(function (c) { return !c.slotScope; });
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
           if (element.pre) {
-            inVPre = true;
+              inVPre = false;
           }
-        }
-        if (platformIsPreTag(element.tag)) {
-          inPre = true;
-        }
-        if (inVPre) {
-          processRawAttrs(element);
-        } else if (!element.processed) {
-          // structural directives
-          processFor(element);
-          processIf(element);
-          processOnce(element);
-        }
-
-        if (!root) {
-          root = element;
-          {
-            checkRootConstraints(root);
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
           }
-        }
-
-        if (!unary) {
-          currentParent = element;
-          stack.push(element);
-        } else {
-          closeElement(element);
-        }
-      },
-
-      end: function end (tag, start, end$1) {
-        var element = stack[stack.length - 1];
-        // pop stack
-        stack.length -= 1;
-        currentParent = stack[stack.length - 1];
-        if (options.outputSourceRange) {
-          element.end = end$1;
-        }
-        closeElement(element);
-      },
-
-      chars: function chars (text, start, end) {
-        if (!currentParent) {
-          {
-            if (text === template) {
-              warnOnce(
-                'Component template requires a root element, rather than just text.',
-                { start: start }
-              );
-            } else if ((text = text.trim())) {
-              warnOnce(
-                ("text \"" + text + "\" outside root element will be ignored."),
-                { start: start }
-              );
-            }
+          // apply post-transforms
+          for (var i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
           }
-          return
-        }
-        // IE textarea placeholder bug
-        /* istanbul ignore if */
-        if (isIE &&
-          currentParent.tag === 'textarea' &&
-          currentParent.attrsMap.placeholder === text
-        ) {
-          return
-        }
-        var children = currentParent.children;
-        if (inPre || text.trim()) {
-          text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-        } else if (!children.length) {
-          // remove the whitespace-only node right after an opening tag
-          text = '';
-        } else if (whitespaceOption) {
-          if (whitespaceOption === 'condense') {
-            // in condense mode, remove the whitespace node if it contains
-            // line break, otherwise condense to a single space
-            text = lineBreakRE.test(text) ? '' : ' ';
-          } else {
-            text = ' ';
+      }
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              var lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
           }
-        } else {
-          text = preserveWhitespace ? ' ' : '';
-        }
-        if (text) {
-          if (!inPre && whitespaceOption === 'condense') {
-            // condense consecutive whitespaces into single space
-            text = text.replace(whitespaceRE, ' ');
-          }
-          var res;
-          var child;
-          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-            child = {
-              type: 2,
-              expression: res.expression,
-              tokens: res.tokens,
-              text: text
-            };
-          } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-            child = {
-              type: 3,
-              text: text
-            };
-          }
-          if (child) {
-            if (options.outputSourceRange) {
-              child.start = start;
-              child.end = end;
-            }
-            children.push(child);
+      }
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                  'contain multiple nodes.', { start: el.start });
           }
-        }
-      },
-      comment: function comment (text, start, end) {
-        // adding anything as a sibling to the root node is forbidden
-        // comments should still be allowed, but ignored
-        if (currentParent) {
-          var child = {
-            type: 3,
-            text: text,
-            isComment: true
-          };
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
           }
-          currentParent.children.push(child);
-        }
       }
-    });
-    return root
+      parseHTML(template, {
+          warn: warn$1,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start: function start(tag, attrs, unary, start$1, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              var element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start$1;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach(function (attr) {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
+                              "spaces, quotes, <, >, / or =.", {
+                              start: attr.start + attr.name.indexOf("["),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn$1('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          "<" + tag + ">" +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (var i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end: function end(tag, start, end$1) {
+              var element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end$1;
+              }
+              closeElement(element);
+          },
+          chars: function chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                              start: start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              var children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE, ' ');
+                  }
+                  var res;
+                  var child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text: text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text: text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment: function comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  var child = {
+                      type: 3,
+                      text: text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
+      });
+      return root;
   }
-
-  function processPre (el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true;
-    }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
   }
-
-  function processRawAttrs (el) {
-    var list = el.attrsList;
-    var len = list.length;
-    if (len) {
-      var attrs = el.attrs = new Array(len);
-      for (var i = 0; i < len; i++) {
-        attrs[i] = {
-          name: list[i].name,
-          value: JSON.stringify(list[i].value)
-        };
-        if (list[i].start != null) {
-          attrs[i].start = list[i].start;
-          attrs[i].end = list[i].end;
-        }
+  function processRawAttrs(el) {
+      var list = el.attrsList;
+      var len = list.length;
+      if (len) {
+          var attrs = (el.attrs = new Array(len));
+          for (var i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
+      }
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (var i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      var exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  var iterator = el.iterator2 || el.iterator1;
+                  var parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn$1("Do not use v-for index as key on <transition-group> children, " +
+                          "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
       }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true;
-    }
   }
-
-  function processElement (
-    element,
-    options
-  ) {
-    processKey(element);
-
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain = (
-      !element.key &&
-      !element.scopedSlots &&
-      !element.attrsList.length
-    );
-
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element
+  function processRef(el) {
+      var ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
+      }
   }
-
-  function processKey (el) {
-    var exp = getBindingAttr(el, 'key');
-    if (exp) {
-      {
-        if (el.tag === 'template') {
-          warn$1(
-            "<template> cannot be keyed. Place the key on real elements instead.",
-            getRawBindingAttr(el, 'key')
-          );
-        }
-        if (el.for) {
-          var iterator = el.iterator2 || el.iterator1;
-          var parent = el.parent;
-          if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-            warn$1(
-              "Do not use v-for index as key on <transition-group> children, " +
-              "this is the same as not using keys.",
-              getRawBindingAttr(el, 'key'),
-              true /* tip */
-            );
+  function processFor(el) {
+      var exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          var res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
           }
-        }
       }
-      el.key = exp;
-    }
   }
-
-  function processRef (el) {
-    var ref = getBindingAttr(el, 'ref');
-    if (ref) {
-      el.ref = ref;
-      el.refInFor = checkInFor(el);
-    }
+  function parseFor(exp) {
+      var inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          { return; }
+      var res = {};
+      res.for = inMatch[2].trim();
+      var alias = inMatch[1].trim().replace(stripParensRE, '');
+      var iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
+          }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
   }
-
-  function processFor (el) {
-    var exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp);
-      if (res) {
-        extend(el, res);
-      } else {
-        warn$1(
-          ("Invalid v-for expression: " + exp),
-          el.rawAttrsMap['v-for']
-        );
+  function processIf(el) {
+      var exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          var elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
       }
-    }
   }
-
-
-
-  function parseFor (exp) {
-    var inMatch = exp.match(forAliasRE);
-    if (!inMatch) { return }
-    var res = {};
-    res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-      res.alias = alias.replace(forIteratorRE, '').trim();
-      res.iterator1 = iteratorMatch[1].trim();
-      if (iteratorMatch[2]) {
-        res.iterator2 = iteratorMatch[2].trim();
-      }
-    } else {
-      res.alias = alias;
-    }
-    return res
-  }
-
-  function processIf (el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-      el.if = exp;
-      addIfCondition(el, {
-        exp: exp,
-        block: el
-      });
-    } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true;
+  function processIfConditions(el, parent) {
+      var prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
+          });
       }
-      var elseif = getAndRemoveAttr(el, 'v-else-if');
-      if (elseif) {
-        el.elseif = elseif;
+      else {
+          warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
-    }
-  }
-
-  function processIfConditions (el, parent) {
-    var prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-      addIfCondition(prev, {
-        exp: el.elseif,
-        block: el
-      });
-    } else {
-      warn$1(
-        "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-        "used on element <" + (el.tag) + "> without corresponding v-if.",
-        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-      );
-    }
   }
-
-  function findPrevElement (children) {
-    var i = children.length;
-    while (i--) {
-      if (children[i].type === 1) {
-        return children[i]
-      } else {
-        if (children[i].text !== ' ') {
-          warn$1(
-            "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-            "will be ignored.",
-            children[i]
-          );
-        }
-        children.pop();
+  function findPrevElement(children) {
+      var i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                      "will be ignored.", children[i]);
+              }
+              children.pop();
+          }
       }
-    }
   }
-
-  function addIfCondition (el, condition) {
-    if (!el.ifConditions) {
-      el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
   }
-
-  function processOnce (el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
-      el.once = true;
-    }
+  function processOnce(el) {
+      var once$$1 = getAndRemoveAttr(el, 'v-once');
+      if (once$$1 != null) {
+          el.once = true;
+      }
   }
-
   // handle content being passed to a component as slot,
   // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent (el) {
-    var slotScope;
-    if (el.tag === 'template') {
-      slotScope = getAndRemoveAttr(el, 'scope');
-      /* istanbul ignore if */
-      if (slotScope) {
-        warn$1(
-          "the \"scope\" attribute for scoped slots have been deprecated and " +
-          "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-          "can also be used on plain elements in addition to <template> to " +
-          "denote scoped slots.",
-          el.rawAttrsMap['scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-      /* istanbul ignore if */
-      if (el.attrsMap['v-for']) {
-        warn$1(
-          "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-          "(v-for takes higher priority). Use a wrapper <template> for the " +
-          "scoped slot to make it clearer.",
-          el.rawAttrsMap['slot-scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope;
-    }
-
-    // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-      el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-      // preserve slot as an attribute for native shadow DOM compat
-      // only for non-scoped slots.
-      if (el.tag !== 'template' && !el.slotScope) {
-        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-      }
-    }
-
-    // 2.6 v-slot syntax
-    {
+  function processSlotContent(el) {
+      var slotScope;
       if (el.tag === 'template') {
-        // v-slot on <template>
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding) {
-          {
-            if (el.slotTarget || el.slotScope) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.parent && !maybeComponent(el.parent)) {
-              warn$1(
-                "<template v-slot> can only appear at the root level inside " +
-                "the receiving component",
-                el
-              );
-            }
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
+                  "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                  "can also be used on plain elements in addition to <template> to " +
+                  "denote scoped slots.", el.rawAttrsMap['scope'], true);
           }
-          var ref = getSlotName(slotBinding);
-          var name = ref.name;
-          var dynamic = ref.dynamic;
-          el.slotTarget = name;
-          el.slotTargetDynamic = dynamic;
-          el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-        }
-      } else {
-        // v-slot on component, denotes default slot
-        var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding$1) {
-          {
-            if (!maybeComponent(el)) {
-              warn$1(
-                "v-slot can only be used on components or <template>.",
-                slotBinding$1
-              );
-            }
-            if (el.slotScope || el.slotTarget) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.scopedSlots) {
-              warn$1(
-                "To avoid scope ambiguity, the default slot should also use " +
-                "<template> syntax when there are other named slots.",
-                slotBinding$1
-              );
-            }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                  "(v-for takes higher priority). Use a wrapper <template> for the " +
+                  "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      var slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn$1("<template v-slot> can only appear at the root level inside " +
+                              "the receiving component", el);
+                      }
+                  }
+                  var ref = getSlotName(slotBinding);
+                  var name = ref.name;
+                  var dynamic = ref.dynamic;
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding$1) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                      }
+                      if (el.scopedSlots) {
+                          warn$1("To avoid scope ambiguity, the default slot should also use " +
+                              "<template> syntax when there are other named slots.", slotBinding$1);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  var slots = el.scopedSlots || (el.scopedSlots = {});
+                  var ref$1 = getSlotName(slotBinding$1);
+                  var name$1 = ref$1.name;
+                  var dynamic$1 = ref$1.dynamic;
+                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name$1;
+                  slotContainer.slotTargetDynamic = dynamic$1;
+                  slotContainer.children = el.children.filter(function (c) {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
           }
-          // add the component's children to its default slot
-          var slots = el.scopedSlots || (el.scopedSlots = {});
-          var ref$1 = getSlotName(slotBinding$1);
-          var name$1 = ref$1.name;
-          var dynamic$1 = ref$1.dynamic;
-          var slotContainer = slots[name$1] = createASTElement('template', [], el);
-          slotContainer.slotTarget = name$1;
-          slotContainer.slotTargetDynamic = dynamic$1;
-          slotContainer.children = el.children.filter(function (c) {
-            if (!c.slotScope) {
-              c.parent = slotContainer;
-              return true
-            }
-          });
-          slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-          // remove children as they are returned from scopedSlots now
-          el.children = [];
-          // mark el non-plain so data gets generated
-          el.plain = false;
-        }
       }
-    }
   }
-
-  function getSlotName (binding) {
-    var name = binding.name.replace(slotRE, '');
-    if (!name) {
-      if (binding.name[0] !== '#') {
-        name = 'default';
-      } else {
-        warn$1(
-          "v-slot shorthand syntax requires a slot name.",
-          binding
-        );
+  function getSlotName(binding) {
+      var name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn$1("v-slot shorthand syntax requires a slot name.", binding);
+          }
       }
-    }
-    return dynamicArgRE.test(name)
-      // dynamic [name]
-      ? { name: name.slice(1, -1), dynamic: true }
-      // static name
-      : { name: ("\"" + name + "\""), dynamic: false }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: ("\"" + name + "\""), dynamic: false };
   }
-
   // handle <slot/> outlets
-  function processSlotOutlet (el) {
-    if (el.tag === 'slot') {
-      el.slotName = getBindingAttr(el, 'name');
-      if (el.key) {
-        warn$1(
-          "`key` does not work on <slot> because slots are abstract outlets " +
-          "and can possibly expand into multiple elements. " +
-          "Use the key on a wrapping element instead.",
-          getRawBindingAttr(el, 'key')
-        );
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn$1("`key` does not work on <slot> because slots are abstract outlets " +
+                  "and can possibly expand into multiple elements. " +
+                  "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+          }
       }
-    }
   }
-
-  function processComponent (el) {
-    var binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true;
-    }
+  function processComponent(el) {
+      var binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
+      }
   }
-
-  function processAttrs (el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-      name = rawName = list[i].name;
-      value = list[i].value;
-      if (dirRE.test(name)) {
-        // mark element as dynamic
-        el.hasBindings = true;
-        // modifiers
-        modifiers = parseModifiers(name.replace(dirRE, ''));
-        // support .foo shorthand syntax for the .prop modifier
-        if (modifiers) {
-          name = name.replace(modifierRE, '');
-        }
-        if (bindRE.test(name)) { // v-bind
-          name = name.replace(bindRE, '');
-          value = parseFilters(value);
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          if (
-            value.trim().length === 0
-          ) {
-            warn$1(
-              ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-            );
-          }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name);
-              if (name === 'innerHtml') { name = 'innerHTML'; }
-            }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name);
-            }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, "$event");
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  ("update:" + (camelize(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-                if (hyphenate(name) !== camelize(name)) {
-                  addHandler(
-                    el,
-                    ("update:" + (hyphenate(name))),
-                    syncGen,
-                    null,
-                    false,
-                    warn$1,
-                    list[i]
-                  );
-                }
-              } else {
-                // handler w/ dynamic event name
-                addHandler(
-                  el,
-                  ("\"update:\"+(" + name + ")"),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i],
-                  true // dynamic
-                );
+  function processAttrs(el) {
+      var list = el.attrsList;
+      var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              { name = 'innerHTML'; }
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, "$event");
+                          if (!isDynamic) {
+                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  var argMatch = name.match(argRE);
+                  var arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
               }
-            }
-          }
-          if ((modifiers && modifiers.prop) || (
-            !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-          )) {
-            addProp(el, name, value, list[i], isDynamic);
-          } else {
-            addAttr(el, name, value, list[i], isDynamic);
-          }
-        } else if (onRE.test(name)) { // v-on
-          name = name.replace(onRE, '');
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-        } else { // normal directives
-          name = name.replace(dirRE, '');
-          // parse arg
-          var argMatch = name.match(argRE);
-          var arg = argMatch && argMatch[1];
-          isDynamic = false;
-          if (arg) {
-            name = name.slice(0, -(arg.length + 1));
-            if (dynamicArgRE.test(arg)) {
-              arg = arg.slice(1, -1);
-              isDynamic = true;
-            }
-          }
-          addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-          if (name === 'model') {
-            checkForAliasModel(el, value);
           }
-        }
-      } else {
-        // literal attribute
-        {
-          var res = parseText(value, delimiters);
-          if (res) {
-            warn$1(
-              name + "=\"" + value + "\": " +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div id="{{ val }}">, use <div :id="val">.',
-              list[i]
-            );
+          else {
+              // literal attribute
+              {
+                  var res = parseText(value, delimiters);
+                  if (res) {
+                      warn$1(name + "=\"" + value + "\": " +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
           }
-        }
-        addAttr(el, name, JSON.stringify(value), list[i]);
-        // #6887 firefox doesn't update muted state if set via attribute
-        // even immediately after element creation
-        if (!el.component &&
-            name === 'muted' &&
-            platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-          addProp(el, name, 'true', list[i]);
-        }
       }
-    }
   }
-
-  function checkInFor (el) {
-    var parent = el;
-    while (parent) {
-      if (parent.for !== undefined) {
-        return true
+  function checkInFor(el) {
+      var parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
       }
-      parent = parent.parent;
-    }
-    return false
+      return false;
   }
-
-  function parseModifiers (name) {
-    var match = name.match(modifierRE);
-    if (match) {
-      var ret = {};
-      match.forEach(function (m) { ret[m.slice(1)] = true; });
-      return ret
-    }
+  function parseModifiers(name) {
+      var match = name.match(modifierRE);
+      if (match) {
+          var ret = {};
+          match.forEach(function (m) {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
   }
-
-  function makeAttrsMap (attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
-      if (
-        map[attrs[i].name] && !isIE && !isEdge
-      ) {
-        warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-      }
-      map[attrs[i].name] = attrs[i].value;
-    }
-    return map
+  function makeAttrsMap(attrs) {
+      var map = {};
+      for (var i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
   }
-
   // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag (el) {
-    return el.tag === 'script' || el.tag === 'style'
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
   }
-
-  function isForbiddenTag (el) {
-    return (
-      el.tag === 'style' ||
-      (el.tag === 'script' && (
-        !el.attrsMap.type ||
-        el.attrsMap.type === 'text/javascript'
-      ))
-    )
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
   }
-
   var ieNSBug = /^xmlns:NS\d+/;
   var ieNSPrefix = /^NS\d+:/;
-
   /* istanbul ignore next */
-  function guardIESVGBug (attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (!ieNSBug.test(attr.name)) {
-        attr.name = attr.name.replace(ieNSPrefix, '');
-        res.push(attr);
-      }
-    }
-    return res
-  }
-
-  function checkForAliasModel (el, value) {
-    var _el = el;
-    while (_el) {
-      if (_el.for && _el.alias === value) {
-        warn$1(
-          "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-          "You are binding v-model directly to a v-for iteration alias. " +
-          "This will not be able to modify the v-for source array because " +
-          "writing to the alias is like modifying a function local variable. " +
-          "Consider using an array of objects and use v-model on an object property instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-      _el = _el.parent;
-    }
-  }
-
-  /*  */
-
-  function preTransformNode (el, options) {
-    if (el.tag === 'input') {
-      var map = el.attrsMap;
-      if (!map['v-model']) {
-        return
-      }
-
-      var typeBinding;
-      if (map[':type'] || map['v-bind:type']) {
-        typeBinding = getBindingAttr(el, 'type');
+  function guardIESVGBug(attrs) {
+      var res = [];
+      for (var i = 0; i < attrs.length; i++) {
+          var attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
       }
-      if (!map.type && !typeBinding && map['v-bind']) {
-        typeBinding = "(" + (map['v-bind']) + ").type";
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      var _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                  "You are binding v-model directly to a v-for iteration alias. " +
+                  "This will not be able to modify the v-for source array because " +
+                  "writing to the alias is like modifying a function local variable. " +
+                  "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
       }
+  }
 
-      if (typeBinding) {
-        var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-        var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-        // 1. checkbox
-        var branch0 = cloneASTElement(el);
-        // process for on the main node
-        processFor(branch0);
-        addRawAttr(branch0, 'type', 'checkbox');
-        processElement(branch0, options);
-        branch0.processed = true; // prevent it from double-processed
-        branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-        addIfCondition(branch0, {
-          exp: branch0.if,
-          block: branch0
-        });
-        // 2. add radio else-if condition
-        var branch1 = cloneASTElement(el);
-        getAndRemoveAttr(branch1, 'v-for', true);
-        addRawAttr(branch1, 'type', 'radio');
-        processElement(branch1, options);
-        addIfCondition(branch0, {
-          exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-          block: branch1
-        });
-        // 3. other
-        var branch2 = cloneASTElement(el);
-        getAndRemoveAttr(branch2, 'v-for', true);
-        addRawAttr(branch2, ':type', typeBinding);
-        processElement(branch2, options);
-        addIfCondition(branch0, {
-          exp: ifCondition,
-          block: branch2
-        });
-
-        if (hasElse) {
-          branch0.else = true;
-        } else if (elseIfCondition) {
-          branch0.elseif = elseIfCondition;
-        }
-
-        return branch0
+  /* @flow */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          var map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          var typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = "(" + (map['v-bind']) + ").type";
+          }
+          if (typeBinding) {
+              var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+              var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              var branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              var branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              var branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
       }
-    }
   }
-
-  function cloneASTElement (el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
   }
-
   var model = {
-    preTransformNode: preTransformNode
+      preTransformNode: preTransformNode,
   };
 
-  var modules = [
-    klass,
-    style,
-    model
-  ];
-
-  /*  */
+  var modules = [klass, style, model];
 
+  /* @flow */
   var warn$2;
-
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
-
-  function model$1 (
-    el,
-    dir,
-    _warn
-  ) {
-    warn$2 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-
-    {
-      // inputs with type="file" are read only and setting the input's
-      // value will throw an error.
-      if (tag === 'input' && type === 'file') {
-        warn$2(
-          "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-          "File inputs are read only. Use a v-on:change listener instead.",
-          el.rawAttrsMap['v-model']
-        );
+  function model$1(el, dir, _warn) {
+      warn$2 = _warn;
+      var value = dir.value;
+      var modifiers = dir.modifiers;
+      var tag = el.tag;
+      var type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                  "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+          }
       }
-    }
-
-    if (el.component) {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    } else if (tag === 'select') {
-      genSelect(el, value, modifiers);
-    } else if (tag === 'input' && type === 'checkbox') {
-      genCheckboxModel(el, value, modifiers);
-    } else if (tag === 'input' && type === 'radio') {
-      genRadioModel(el, value, modifiers);
-    } else if (tag === 'input' || tag === 'textarea') {
-      genDefaultModel(el, value, modifiers);
-    } else {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    }
-
-    // ensure runtime directive metadata
-    return true
-  }
-
-  function genCheckboxModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked',
-      "Array.isArray(" + value + ")" +
-      "?_i(" + value + "," + valueBinding + ")>-1" + (
-        trueValueBinding === 'true'
-          ? (":(" + value + ")")
-          : (":_q(" + value + "," + trueValueBinding + ")")
-      )
-    );
-    addHandler(el, 'change',
-      "var $$a=" + value + "," +
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else if (!config.isReservedTag(tag)) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else {
+          warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+              "v-model is not supported on this element type. " +
+              "If you are working with contenteditable, it's recommended to " +
+              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', "Array.isArray(" + value + ")" +
+          "?_i(" + value + "," + valueBinding + ")>-1" +
+          (trueValueBinding === 'true'
+              ? (":(" + value + ")")
+              : (":_q(" + value + "," + trueValueBinding + ")")));
+      addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
           "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-      'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-            '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-      "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-      null, true
-    );
-  }
-
-  function genRadioModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-
-  function genSelect (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-      ".call($event.target.options,function(o){return o.selected})" +
-      ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-      "return " + (number ? '_n(val)' : 'val') + "})";
-
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-  }
-
-  function genDefaultModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var type = el.attrsMap.type;
-
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-      var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-      if (value$1 && !typeBinding) {
-        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-        warn$2(
-          binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-          'because the latter already expands to a value binding internally',
-          el.rawAttrsMap[binding]
-        );
+          'if(Array.isArray($$a)){' +
+          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+          '$$i=_i($$a,$$v);' +
+          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var selectedVal = "Array.prototype.filter" +
+          ".call($event.target.options,function(o){return o.selected})" +
+          ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+          "return " + (number ? '_n(val)' : 'val') + "})";
+      var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      var code = "var $$selectedVal = " + selectedVal + ";";
+      code = code + " " + (genAssignmentCode(value, assignment));
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      var type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value$1 && !typeBinding) {
+              var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      var ref = modifiers || {};
+      var lazy = ref.lazy;
+      var number = ref.number;
+      var trim = ref.trim;
+      var needCompositionGuard = !lazy && type !== 'range';
+      var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      var valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = "$event.target.value.trim()";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = "if($event.target.composing)return;" + code;
+      }
+      addProp(el, 'value', ("(" + value + ")"));
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
       }
-    }
-
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy
-      ? 'change'
-      : type === 'range'
-        ? RANGE_TOKEN
-        : 'input';
-
-    var valueExpression = '$event.target.value';
-    if (trim) {
-      valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-      code = "if($event.target.composing)return;" + code;
-    }
-
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()');
-    }
   }
 
-  /*  */
-
-  function text (el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-    }
+  /* @flow */
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+      }
   }
 
-  /*  */
-
-  function html (el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-    }
+  /* @flow */
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+      }
   }
 
   var directives = {
-    model: model$1,
-    text: text,
-    html: html
+      model: model$1,
+      text: text,
+      html: html,
   };
 
-  /*  */
-
+  /* @flow */
   var baseOptions = {
-    expectHTML: true,
-    modules: modules,
-    directives: directives,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    staticKeys: genStaticKeys(modules)
+      expectHTML: true,
+      modules: modules,
+      directives: directives,
+      isPreTag: isPreTag,
+      isUnaryTag: isUnaryTag,
+      mustUseProp: mustUseProp,
+      canBeLeftOpenTag: canBeLeftOpenTag,
+      isReservedTag: isReservedTag,
+      getTagNamespace: getTagNamespace,
+      // @ts-ignore
+      staticKeys: genStaticKeys(modules),
   };
 
-  /*  */
-
+  /* @flow */
   var isStaticKey;
   var isPlatformReservedTag;
-
   var genStaticKeysCached = cached(genStaticKeys$1);
-
   /**
    * Goal of the optimizer: walk the generated template AST tree
    * and detect sub-trees that are purely static, i.e. parts of
@@ -3971,1786 +3479,1549 @@
    *    create fresh nodes for them on each re-render;
    * 2. Completely skip them in the patching process.
    */
-  function optimize (root, options) {
-    if (!root) { return }
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-  }
-
-  function genStaticKeys$1 (keys) {
-    return makeMap(
-      'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-      (keys ? ',' + keys : '')
-    )
-  }
-
-  function markStatic (node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-      // do not make component slot content static. this avoids
-      // 1. components not able to mutate slot nodes
-      // 2. static slot content fails for hot-reloading
-      if (
-        !isPlatformReservedTag(node.tag) &&
-        node.tag !== 'slot' &&
-        node.attrsMap['inline-template'] == null
-      ) {
-        return
-      }
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        markStatic(child);
-        if (!child.static) {
-          node.static = false;
-        }
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          markStatic(block);
-          if (!block.static) {
-            node.static = false;
+  function optimize(root, options) {
+      if (!root)
+          { return; }
+      isStaticKey = genStaticKeysCached(options.staticKeys || '');
+      isPlatformReservedTag = options.isReservedTag || no;
+      // first pass: mark all non-static nodes.
+      markStatic(root);
+      // second pass: mark static roots.
+      markStaticRoots(root, false);
+  }
+  function genStaticKeys$1(keys) {
+      return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+          (keys ? ',' + keys : ''));
+  }
+  function markStatic(node) {
+      node.static = isStatic(node);
+      if (node.type === 1) {
+          // do not make component slot content static. this avoids
+          // 1. components not able to mutate slot nodes
+          // 2. static slot content fails for hot-reloading
+          if (!isPlatformReservedTag(node.tag) &&
+              node.tag !== 'slot' &&
+              node.attrsMap['inline-template'] == null) {
+              return;
+          }
+          for (var i = 0, l = node.children.length; i < l; i++) {
+              var child = node.children[i];
+              markStatic(child);
+              if (!child.static) {
+                  node.static = false;
+              }
+          }
+          if (node.ifConditions) {
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
+                  markStatic(block);
+                  if (!block.static) {
+                      node.static = false;
+                  }
+              }
           }
-        }
       }
-    }
   }
-
-  function markStaticRoots (node, isInFor) {
-    if (node.type === 1) {
-      if (node.static || node.once) {
-        node.staticInFor = isInFor;
-      }
-      // For a node to qualify as a static root, it should have children that
-      // are not just static text. Otherwise the cost of hoisting out will
-      // outweigh the benefits and it's better off to just always render it fresh.
-      if (node.static && node.children.length && !(
-        node.children.length === 1 &&
-        node.children[0].type === 3
-      )) {
-        node.staticRoot = true;
-        return
-      } else {
-        node.staticRoot = false;
-      }
-      if (node.children) {
-        for (var i = 0, l = node.children.length; i < l; i++) {
-          markStaticRoots(node.children[i], isInFor || !!node.for);
-        }
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          markStaticRoots(node.ifConditions[i$1].block, isInFor);
-        }
+  function markStaticRoots(node, isInFor) {
+      if (node.type === 1) {
+          if (node.static || node.once) {
+              node.staticInFor = isInFor;
+          }
+          // For a node to qualify as a static root, it should have children that
+          // are not just static text. Otherwise the cost of hoisting out will
+          // outweigh the benefits and it's better off to just always render it fresh.
+          if (node.static &&
+              node.children.length &&
+              !(node.children.length === 1 && node.children[0].type === 3)) {
+              node.staticRoot = true;
+              return;
+          }
+          else {
+              node.staticRoot = false;
+          }
+          if (node.children) {
+              for (var i = 0, l = node.children.length; i < l; i++) {
+                  markStaticRoots(node.children[i], isInFor || !!node.for);
+              }
+          }
+          if (node.ifConditions) {
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
+              }
+          }
       }
-    }
-  }
-
-  function isStatic (node) {
-    if (node.type === 2) { // expression
-      return false
-    }
-    if (node.type === 3) { // text
-      return true
-    }
-    return !!(node.pre || (
-      !node.hasBindings && // no dynamic bindings
-      !node.if && !node.for && // not v-if or v-for or v-else
-      !isBuiltInTag(node.tag) && // not a built-in
-      isPlatformReservedTag(node.tag) && // not a component
-      !isDirectChildOfTemplateFor(node) &&
-      Object.keys(node).every(isStaticKey)
-    ))
   }
-
-  function isDirectChildOfTemplateFor (node) {
-    while (node.parent) {
-      node = node.parent;
-      if (node.tag !== 'template') {
-        return false
-      }
-      if (node.for) {
-        return true
+  function isStatic(node) {
+      if (node.type === 2) {
+          // expression
+          return false;
+      }
+      if (node.type === 3) {
+          // text
+          return true;
+      }
+      return !!(node.pre ||
+          (!node.hasBindings && // no dynamic bindings
+              !node.if &&
+              !node.for && // not v-if or v-for or v-else
+              !isBuiltInTag(node.tag) && // not a built-in
+              isPlatformReservedTag(node.tag) && // not a component
+              !isDirectChildOfTemplateFor(node) &&
+              Object.keys(node).every(isStaticKey)));
+  }
+  function isDirectChildOfTemplateFor(node) {
+      while (node.parent) {
+          node = node.parent;
+          if (node.tag !== 'template') {
+              return false;
+          }
+          if (node.for) {
+              return true;
+          }
       }
-    }
-    return false
+      return false;
   }
 
-  /*  */
-
+  /* @flow */
   var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
   // KeyboardEvent.keyCode aliases
   var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    'delete': [8, 46]
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
   };
-
   // KeyboardEvent.key aliases
   var keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    'delete': ['Backspace', 'Delete', 'Del']
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
   };
-
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
   var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
   var modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2")
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard("$event.target !== $event.currentTarget"),
+      ctrl: genGuard("!$event.ctrlKey"),
+      shift: genGuard("!$event.shiftKey"),
+      alt: genGuard("!$event.altKey"),
+      meta: genGuard("!$event.metaKey"),
+      left: genGuard("'button' in $event && $event.button !== 0"),
+      middle: genGuard("'button' in $event && $event.button !== 1"),
+      right: genGuard("'button' in $event && $event.button !== 2"),
   };
-
-  function genHandlers (
-    events,
-    isNative
-  ) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-      var handlerCode = genHandler(events[name]);
-      if (events[name] && events[name].dynamic) {
-        dynamicHandlers += name + "," + handlerCode + ",";
-      } else {
-        staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+  function genHandlers(events, isNative) {
+      var prefix = isNative ? 'nativeOn:' : 'on:';
+      var staticHandlers = "";
+      var dynamicHandlers = "";
+      for (var name in events) {
+          var handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += name + "," + handlerCode + ",";
+          }
+          else {
+              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+          }
+      }
+      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      if (dynamicHandlers) {
+          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+      }
+      else {
+          return prefix + staticHandlers;
       }
-    }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-    if (dynamicHandlers) {
-      return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-    } else {
-      return prefix + staticHandlers
-    }
   }
-
-  function genHandler (handler) {
-    if (!handler) {
-      return 'function(){}'
-    }
-
-    if (Array.isArray(handler)) {
-      return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-    }
-
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-    if (!handler.modifiers) {
-      if (isMethodPath || isFunctionExpression) {
-        return handler.value
-      }
-      return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-    } else {
-      var code = '';
-      var genModifierCode = '';
-      var keys = [];
-      for (var key in handler.modifiers) {
-        if (modifierCode[key]) {
-          genModifierCode += modifierCode[key];
-          // left/right
-          if (keyCodes[key]) {
-            keys.push(key);
-          }
-        } else if (key === 'exact') {
-          var modifiers = (handler.modifiers);
-          genModifierCode += genGuard(
-            ['ctrl', 'shift', 'alt', 'meta']
-              .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-              .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-              .join('||')
-          );
-        } else {
-          keys.push(key);
-        }
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+      }
+      var isMethodPath = simplePathRE.test(handler.value);
+      var isFunctionExpression = fnExpRE.test(handler.value);
+      var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+      }
+      else {
+          var code = '';
+          var genModifierCode = '';
+          var keys = [];
+          for (var key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  var modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          var handlerCode = isMethodPath
+              ? ("return " + (handler.value) + ".apply(null, arguments)")
+              : isFunctionExpression
+                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  : isFunctionInvocation
+                      ? ("return " + (handler.value))
+                      : handler.value;
+          return ("function($event){" + code + handlerCode + "}");
       }
-      if (keys.length) {
-        code += genKeyFilter(keys);
-      }
-      // Make sure modifiers like prevent and stop get executed after key filtering
-      if (genModifierCode) {
-        code += genModifierCode;
-      }
-      var handlerCode = isMethodPath
-        ? ("return " + (handler.value) + "($event)")
-        : isFunctionExpression
-          ? ("return (" + (handler.value) + ")($event)")
-          : isFunctionInvocation
-            ? ("return " + (handler.value))
-            : handler.value;
-      return ("function($event){" + code + handlerCode + "}")
-    }
   }
-
-  function genKeyFilter (keys) {
-    return (
+  function genKeyFilter(keys) {
+      return (
       // make sure the key filters only apply to KeyboardEvents
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-      (keys.map(genFilterCode).join('&&')) + ")return null;"
-    )
+          (keys.map(genFilterCode).join('&&')) + ")return null;");
   }
-
-  function genFilterCode (key) {
-    var keyVal = parseInt(key, 10);
-    if (keyVal) {
-      return ("$event.keyCode!==" + keyVal)
-    }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return (
-      "_k($event.keyCode," +
-      (JSON.stringify(key)) + "," +
-      (JSON.stringify(keyCode)) + "," +
-      "$event.key," +
-      "" + (JSON.stringify(keyName)) +
-      ")"
-    )
+  function genFilterCode(key) {
+      var keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return ("$event.keyCode!==" + keyVal);
+      }
+      var keyCode = keyCodes[key];
+      var keyName = keyNames[key];
+      return ("_k($event.keyCode," +
+          (JSON.stringify(key)) + "," +
+          (JSON.stringify(keyCode)) + "," +
+          "$event.key," +
+          "" + (JSON.stringify(keyName)) +
+          ")");
   }
 
-  /*  */
-
-  function on (el, dir) {
-    if (dir.modifiers) {
-      warn("v-on without argument does not support modifiers.");
-    }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+  /* @flow */
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn("v-on without argument does not support modifiers.");
+      }
+      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
   }
 
-  /*  */
-
-  function bind$1 (el, dir) {
-    el.wrapData = function (code) {
-      return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-    };
+  /* @flow */
+  function bind$1(el, dir) {
+      el.wrapData = function (code) {
+          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+      };
   }
 
-  /*  */
-
+  /* @flow */
   var baseDirectives = {
-    on: on,
-    bind: bind$1,
-    cloak: noop
+      on: on,
+      bind: bind$1,
+      cloak: noop,
   };
 
-  /*  */
-
-
-
-
-
-  var CodegenState = function CodegenState (options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
+  /* @flow */
+  var CodegenState = function CodegenState(options) {
+      this.options = options;
+      this.warn = options.warn || baseWarn;
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+      this.directives = extend(extend({}, baseDirectives), options.directives);
+      var isReservedTag = options.isReservedTag || no;
+      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      this.onceId = 0;
+      this.staticRenderFns = [];
+      this.pre = false;
   };
-
-
-
-  function generate (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
+  function generate(ast, options) {
+      var state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      var code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: ("with(this){return " + code + "}"),
+          staticRenderFns: state.staticRenderFns,
+      };
   }
-
-  function genElement (el, state) {
-    if (el.parent) {
-      el.pre = el.pre || el.parent.pre;
-    }
-
-    if (el.staticRoot && !el.staticProcessed) {
-      return genStatic(el, state)
-    } else if (el.once && !el.onceProcessed) {
-      return genOnce(el, state)
-    } else if (el.for && !el.forProcessed) {
-      return genFor(el, state)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-      return genChildren(el, state) || 'void 0'
-    } else if (el.tag === 'slot') {
-      return genSlot(el, state)
-    } else {
-      // component or element
-      var code;
-      if (el.component) {
-        code = genComponent(el.component, el, state);
-      } else {
-        var data;
-        if (!el.plain || (el.pre && state.maybeComponent(el))) {
-          data = genData$2(el, state);
-        }
-
-        var children = el.inlineTemplate ? null : genChildren(el, state, true);
-        code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
       }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code);
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
+      }
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
+      }
+      else {
+          // component or element
+          var code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              var data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData$2(el, state);
+              }
+              var children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+          }
+          // module transforms
+          for (var i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
       }
-      return code
-    }
   }
-
   // hoist static sub-trees out
-  function genStatic (el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
-    if (el.pre) {
-      state.pre = el.pre;
-    }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-    state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      var originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.pre = originalPreState;
+      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
   }
-
   // v-once
-  function genOnce (el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.staticInFor) {
-      var key = '';
-      var parent = el.parent;
-      while (parent) {
-        if (parent.for) {
-          key = parent.key;
-          break
-        }
-        parent = parent.parent;
-      }
-      if (!key) {
-        state.warn(
-          "v-once can only be used inside v-for that is keyed. ",
-          el.rawAttrsMap['v-once']
-        );
-        return genElement(el, state)
-      }
-      return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-    } else {
-      return genStatic(el, state)
-    }
-  }
-
-  function genIf (
-    el,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-  }
-
-  function genIfConditions (
-    conditions,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    if (!conditions.length) {
-      return altEmpty || '_e()'
-    }
-
-    var condition = conditions.shift();
-    if (condition.exp) {
-      return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-    } else {
-      return ("" + (genTernaryExp(condition.block)))
-    }
-
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp (el) {
-      return altGen
-        ? altGen(el, state)
-        : el.once
-          ? genOnce(el, state)
-          : genElement(el, state)
-    }
-  }
-
-  function genFor (
-    el,
-    state,
-    altGen,
-    altHelper
-  ) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-    if (state.maybeComponent(el) &&
-      el.tag !== 'slot' &&
-      el.tag !== 'template' &&
-      !el.key
-    ) {
-      state.warn(
-        "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-        "v-for should have explicit keys. " +
-        "See https://vuejs.org/guide/list.html#key for more info.",
-        el.rawAttrsMap['v-for'],
-        true /* tip */
-      );
-    }
-
-    el.forProcessed = true; // avoid recursion
-    return (altHelper || '_l') + "((" + exp + ")," +
-      "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
-      '})'
-  }
-
-  function genData$2 (el, state) {
-    var data = '{';
-
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
-    if (dirs) { data += dirs + ','; }
-
-    // key
-    if (el.key) {
-      data += "key:" + (el.key) + ",";
-    }
-    // ref
-    if (el.ref) {
-      data += "ref:" + (el.ref) + ",";
-    }
-    if (el.refInFor) {
-      data += "refInFor:true,";
-    }
-    // pre
-    if (el.pre) {
-      data += "pre:true,";
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-      data += "tag:\"" + (el.tag) + "\",";
-    }
-    // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
-      data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-      data += "attrs:" + (genProps(el.attrs)) + ",";
-    }
-    // DOM props
-    if (el.props) {
-      data += "domProps:" + (genProps(el.props)) + ",";
-    }
-    // event handlers
-    if (el.events) {
-      data += (genHandlers(el.events, false)) + ",";
-    }
-    if (el.nativeEvents) {
-      data += (genHandlers(el.nativeEvents, true)) + ",";
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-      data += "slot:" + (el.slotTarget) + ",";
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-      data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-    }
-    // component v-model
-    if (el.model) {
-      data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-      var inlineTemplate = genInlineTemplate(el, state);
-      if (inlineTemplate) {
-        data += inlineTemplate + ",";
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
       }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-      data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data);
-    }
-    return data
-  }
-
-  function genDirectives (el, state) {
-    var dirs = el.directives;
-    if (!dirs) { return }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-      dir = dirs[i];
-      needRuntime = true;
-      var gen = state.directives[dir.name];
-      if (gen) {
-        // compile-time directive that manipulates AST.
-        // returns true if it also needs a runtime counterpart.
-        needRuntime = !!gen(el, dir, state.warn);
-      }
-      if (needRuntime) {
-        hasRuntime = true;
-        res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+      else if (el.staticInFor) {
+          var key = '';
+          var parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      var condition = conditions.shift();
+      if (condition.exp) {
+          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+      }
+      else {
+          return ("" + (genTernaryExp(condition.block)));
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      var exp = el.for;
+      var alias = el.alias;
+      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+              "v-for should have explicit keys. " +
+              "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return ((altHelper || '_l') + "((" + exp + ")," +
+          "function(" + alias + iterator1 + iterator2 + "){" +
+          "return " + ((altGen || genElement)(el, state)) +
+          '})');
+  }
+  function genData$2(el, state) {
+      var data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      var dirs = genDirectives(el, state);
+      if (dirs)
+          { data += dirs + ','; }
+      // key
+      if (el.key) {
+          data += "key:" + (el.key) + ",";
+      }
+      // ref
+      if (el.ref) {
+          data += "ref:" + (el.ref) + ",";
+      }
+      if (el.refInFor) {
+          data += "refInFor:true,";
+      }
+      // pre
+      if (el.pre) {
+          data += "pre:true,";
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += "tag:\"" + (el.tag) + "\",";
+      }
+      // module data generation functions
+      for (var i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += "attrs:" + (genProps(el.attrs)) + ",";
+      }
+      // DOM props
+      if (el.props) {
+          data += "domProps:" + (genProps(el.props)) + ",";
+      }
+      // event handlers
+      if (el.events) {
+          data += (genHandlers(el.events, false)) + ",";
+      }
+      if (el.nativeEvents) {
+          data += (genHandlers(el.nativeEvents, true)) + ",";
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += "slot:" + (el.slotTarget) + ",";
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+      }
+      // component v-model
+      if (el.model) {
+          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          var inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += inlineTemplate + ",";
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      var dirs = el.directives;
+      if (!dirs)
+          { return; }
+      var res = 'directives:[';
+      var hasRuntime = false;
+      var i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          var gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
       }
-    }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
   }
-
-  function genInlineTemplate (el, state) {
-    var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
-      state.warn(
-        'Inline-template components must have exactly one child element.',
-        { start: el.start }
-      );
-    }
-    if (ast && ast.type === 1) {
-      var inlineRenderFns = generate(ast, state.options);
-      return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-    }
+  function genInlineTemplate(el, state) {
+      var ast = el.children[0];
+      if (el.children.length !== 1 || ast.type !== 1) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          var inlineRenderFns = generate(ast, state.options);
+          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+              .map(function (code) { return ("function(){" + code + "}"); })
+              .join(',')) + "]}");
+      }
   }
-
-  function genScopedSlots (
-    el,
-    slots,
-    state
-  ) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-      var slot = slots[key];
-      return (
-        slot.slotTargetDynamic ||
-        slot.if ||
-        slot.for ||
-        containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-      )
-    });
-
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    var needsKey = !!el.if;
-
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-      var parent = el.parent;
-      while (parent) {
-        if (
-          (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-          parent.for
-        ) {
-          needsForceUpdate = true;
-          break
-        }
-        if (parent.if) {
-          needsKey = true;
-        }
-        parent = parent.parent;
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      var needsForceUpdate = el.for ||
+          Object.keys(slots).some(function (key) {
+              var slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      var needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          var parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
       }
-    }
-
-    var generatedSlots = Object.keys(slots)
-      .map(function (key) { return genScopedSlot(slots[key], state); })
-      .join(',');
-
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
+      var generatedSlots = Object.keys(slots)
+          .map(function (key) { return genScopedSlot(slots[key], state); })
+          .join(',');
+      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
   }
-
   function hash(str) {
-    var hash = 5381;
-    var i = str.length;
-    while(i) {
-      hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0
-  }
-
-  function containsSlotChild (el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
+      var hash = 5381;
+      var i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
       }
-      return el.children.some(containsSlotChild)
-    }
-    return false
+      return hash >>> 0;
   }
-
-  function genScopedSlot (
-    el,
-    state
-  ) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-      return genIf(el, state, genScopedSlot, "null")
-    }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
-    }
-    var slotScope = el.slotScope === emptySlotScopeToken
-      ? ""
-      : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-      "return " + (el.tag === 'template'
-        ? el.if && isLegacySyntax
-          ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-          : genChildren(el, state) || 'undefined'
-        : genElement(el, state)) + "}";
-    // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-  }
-
-  function genChildren (
-    el,
-    state,
-    checkSkip,
-    altGenElement,
-    altGenNode
-  ) {
-    var children = el.children;
-    if (children.length) {
-      var el$1 = children[0];
-      // optimize single v-for
-      if (children.length === 1 &&
-        el$1.for &&
-        el$1.tag !== 'template' &&
-        el$1.tag !== 'slot'
-      ) {
-        var normalizationType = checkSkip
-          ? state.maybeComponent(el$1) ? ",1" : ",0"
-          : "";
-        return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-      }
-      var normalizationType$1 = checkSkip
-        ? getNormalizationType(children, state.maybeComponent)
-        : 0;
-      var gen = altGenNode || genNode;
-      return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-    }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      var isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, "null");
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+      var fn = "function(" + slotScope + "){" +
+          "return " + (el.tag === 'template'
+              ? el.if && isLegacySyntax
+                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                  : genChildren(el, state) || 'undefined'
+              : genElement(el, state)) + "}";
+      // reverse proxy v-slot without scope on this.$slots
+      var reverseProxy = slotScope ? "" : ",proxy:true";
+      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      var children = el.children;
+      if (children.length) {
+          var el$1 = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el$1.for &&
+              el$1.tag !== 'template' &&
+              el$1.tag !== 'slot') {
+              var normalizationType = checkSkip
+                  ? state.maybeComponent(el$1)
+                      ? ",1"
+                      : ",0"
+                  : "";
+              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+          }
+          var normalizationType$1 = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          var gen = altGenNode || genNode;
+          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+      }
   }
-
   // determine the normalization needed for the children array.
   // 0: no normalization needed
   // 1: simple normalization needed (possible 1-level deep nested array)
   // 2: full normalization needed
-  function getNormalizationType (
-    children,
-    maybeComponent
-  ) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-      var el = children[i];
-      if (el.type !== 1) {
-        continue
-      }
-      if (needsNormalization(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-        res = 2;
-        break
-      }
-      if (maybeComponent(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-        res = 1;
+  function getNormalizationType(children, maybeComponent) {
+      var res = 0;
+      for (var i = 0; i < children.length; i++) {
+          var el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+              res = 1;
+          }
       }
-    }
-    return res
+      return res;
   }
-
-  function needsNormalization (el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
   }
-
-  function genNode (node, state) {
-    if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
-    }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
   }
-
-  function genText (text) {
-    return ("_v(" + (text.type === 2
-      ? text.expression // no need for () because already wrapped in _s()
-      : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
+  function genText(text) {
+      return ("_v(" + (text.type === 2
+          ? text.expression // no need for () because already wrapped in _s()
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
   }
-
-  function genComment (comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")")
+  function genComment(comment) {
+      return ("_e(" + (JSON.stringify(comment.text)) + ")");
   }
-
-  function genSlot (el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
-    var attrs = el.attrs || el.dynamicAttrs
-      ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-          // slot props are camelized
-          name: camelize(attr.name),
-          value: attr.value,
-          dynamic: attr.dynamic
-        }); }))
-      : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
-      res += ",null";
-    }
-    if (attrs) {
-      res += "," + attrs;
-    }
-    if (bind$$1) {
-      res += (attrs ? '' : ',null') + "," + bind$$1;
-    }
-    return res + ')'
+  function genSlot(el, state) {
+      var slotName = el.slotName || '"default"';
+      var children = genChildren(el, state);
+      var res = "_t(" + slotName + (children ? ("," + children) : '');
+      var attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic,
+          }); }))
+          : null;
+      var bind$$1 = el.attrsMap['v-bind'];
+      if ((attrs || bind$$1) && !children) {
+          res += ",null";
+      }
+      if (attrs) {
+          res += "," + attrs;
+      }
+      if (bind$$1) {
+          res += (attrs ? '' : ',null') + "," + bind$$1;
+      }
+      return res + ')';
   }
-
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent (
-    componentName,
-    el,
-    state
-  ) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-  }
-
-  function genProps (props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      var value = transformSpecialNewlines(prop.value);
-      if (prop.dynamic) {
-        dynamicProps += (prop.name) + "," + value + ",";
-      } else {
-        staticProps += "\"" + (prop.name) + "\":" + value + ",";
+  function genComponent(componentName, el, state) {
+      var children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+  }
+  function genProps(props) {
+      var staticProps = "";
+      var dynamicProps = "";
+      for (var i = 0; i < props.length; i++) {
+          var prop = props[i];
+          var value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += (prop.name) + "," + value + ",";
+          }
+          else {
+              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+          }
+      }
+      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      if (dynamicProps) {
+          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+      }
+      else {
+          return staticProps;
       }
-    }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-    if (dynamicProps) {
-      return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-    } else {
-      return staticProps
-    }
   }
-
   // #3895, #4268
-  function transformSpecialNewlines (text) {
-    return text
-      .replace(/\u2028/g, '\\u2028')
-      .replace(/\u2029/g, '\\u2029')
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  /*  */
-
-
-
+  /* @flow */
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp('\\b' + (
-    'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-    'super,throw,while,yield,delete,export,import,return,switch,default,' +
-    'extends,finally,continue,debugger,function,arguments'
-  ).split(',').join('\\b|\\b') + '\\b');
-
+  var prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
   // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp('\\b' + (
-    'delete,typeof,void'
-  ).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+  var unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
   // strip strings in expressions
   var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
   // detect problematic expressions in a template
-  function detectErrors (ast, warn) {
-    if (ast) {
-      checkNode(ast, warn);
-    }
-  }
-
-  function checkNode (node, warn) {
-    if (node.type === 1) {
-      for (var name in node.attrsMap) {
-        if (dirRE.test(name)) {
-          var value = node.attrsMap[name];
-          if (value) {
-            var range = node.rawAttrsMap[name];
-            if (name === 'v-for') {
-              checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-            } else if (name === 'v-slot' || name[0] === '#') {
-              checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-            } else if (onRE.test(name)) {
-              checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-            } else {
-              checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-            }
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (var name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  var value = node.attrsMap[name];
+                  if (value) {
+                      var range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                      else {
+                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (var i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
           }
-        }
       }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn);
-        }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
       }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node);
-    }
   }
-
-  function checkEvent (exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        "avoid using JavaScript unary operator as property name: " +
-        "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-        range
-      );
-    }
-    checkExpression(exp, text, warn, range);
+  function checkEvent(exp, text, warn, range) {
+      var stripped = exp.replace(stripStringRE, '');
+      var keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn("avoid using JavaScript unary operator as property name: " +
+              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+      }
+      checkExpression(exp, text, warn, range);
   }
-
-  function checkFor (node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
   }
-
-  function checkIdentifier (
-    ident,
-    type,
-    text,
-    warn,
-    range
-  ) {
-    if (typeof ident === 'string') {
-      try {
-        new Function(("var " + ident + "=_"));
-      } catch (e) {
-        warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(("var " + ident + "=_"));
+          }
+          catch (e) {
+              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+          }
       }
-    }
   }
-
-  function checkExpression (exp, text, warn, range) {
-    try {
-      new Function(("return " + exp));
-    } catch (e) {
-      var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-      if (keywordMatch) {
-        warn(
-          "avoid using JavaScript keyword as property name: " +
-          "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-          range
-        );
-      } else {
-        warn(
-          "invalid expression: " + (e.message) + " in\n\n" +
-          "    " + exp + "\n\n" +
-          "  Raw expression: " + (text.trim()) + "\n",
-          range
-        );
+  function checkExpression(exp, text, warn, range) {
+      try {
+          new Function(("return " + exp));
+      }
+      catch (e) {
+          var keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn("avoid using JavaScript keyword as property name: " +
+                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+          }
+          else {
+              warn("invalid expression: " + (e.message) + " in\n\n" +
+                  "    " + exp + "\n\n" +
+                  "  Raw expression: " + (text.trim()) + "\n", range);
+          }
       }
-    }
   }
-
-  function checkFunctionParameterExpression (exp, text, warn, range) {
-    try {
-      new Function(exp, '');
-    } catch (e) {
-      warn(
-        "invalid function parameter expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+              "    " + exp + "\n\n" +
+              "  Raw expression: " + (text.trim()) + "\n", range);
+      }
   }
 
-  /*  */
-
+  /* @flow */
   var range = 2;
-
-  function generateCodeFrame (
-    source,
-    start,
-    end
-  ) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
-      count += lines[i].length + 1;
-      if (count >= start) {
-        for (var j = i - range; j <= i + range || end > count; j++) {
-          if (j < 0 || j >= lines.length) { continue }
-          res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-          var lineLength = lines[j].length;
-          if (j === i) {
-            // push underline
-            var pad = start - (count - lineLength) + 1;
-            var length = end > count ? lineLength - pad : end - start;
-            res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-          } else if (j > i) {
-            if (end > count) {
-              var length$1 = Math.min(end - count, lineLength);
-              res.push("   |  " + repeat$1("^", length$1));
-            }
-            count += lineLength + 1;
+  function generateCodeFrame(source, start, end) {
+      if ( start === void 0 ) start = 0;
+      if ( end === void 0 ) end = source.length;
+
+      var lines = source.split(/\r?\n/);
+      var count = 0;
+      var res = [];
+      for (var i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (var j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      { continue; }
+                  res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                  var lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      var pad = start - (count - lineLength) + 1;
+                      var length = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          var length$1 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat$1("^", length$1));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
           }
-        }
-        break
       }
-    }
-    return res.join('\n')
-  }
-
-  function repeat$1 (str, n) {
-    var result = '';
-    if (n > 0) {
-      while (true) { // eslint-disable-line
-        if (n & 1) { result += str; }
-        n >>>= 1;
-        if (n <= 0) { break }
-        str += str;
+      return res.join('\n');
+  }
+  function repeat$1(str, n) {
+      var result = '';
+      if (n > 0) {
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  { result += str; }
+              n >>>= 1;
+              if (n <= 0)
+                  { break; }
+              str += str;
+          }
       }
-    }
-    return result
+      return result;
   }
 
-  /*  */
-
-
-
-  function createFunction (code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code });
-      return noop
-    }
-  }
-
-  function createCompileToFunctionFn (compile) {
-    var cache = Object.create(null);
-
-    return function compileToFunctions (
-      template,
-      options,
-      vm
-    ) {
-      options = extend({}, options);
-      var warn$$1 = options.warn || warn;
-      delete options.warn;
-
-      /* istanbul ignore if */
-      {
-        // detect possible CSP restriction
-        try {
-          new Function('return 1');
-        } catch (e) {
-          if (e.toString().match(/unsafe-eval|CSP/)) {
-            warn$$1(
-              'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-            );
-          }
-        }
+  /* @flow */
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
       }
-
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template;
-      if (cache[key]) {
-        return cache[key]
+      catch (err) {
+          errors.push({ err: err, code: code });
+          return noop;
       }
-
-      // compile
-      var compiled = compile(template, options);
-
-      // check compilation errors/tips
-      {
-        if (compiled.errors && compiled.errors.length) {
-          if (options.outputSourceRange) {
-            compiled.errors.forEach(function (e) {
-              warn$$1(
-                "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-                generateCodeFrame(template, e.start, e.end),
-                vm
-              );
-            });
-          } else {
-            warn$$1(
-              "Error compiling template:\n\n" + template + "\n\n" +
-              compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-              vm
-            );
+  }
+  function createCompileToFunctionFn(compile) {
+      var cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          var warn$$1 = options.warn || warn;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
           }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-          } else {
-            compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+          // check cache
+          var key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
           }
-        }
-      }
-
-      // turn code into functions
-      var res = {};
-      var fnGenErrors = [];
-      res.render = createFunction(compiled.render, fnGenErrors);
-      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-        return createFunction(code, fnGenErrors)
-      });
-
-      // check function generation errors.
-      // this should only happen if there is a bug in the compiler itself.
-      // mostly for codegen development use
-      /* istanbul ignore if */
-      {
-        if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-          warn$$1(
-            "Failed to generate render function:\n\n" +
-            fnGenErrors.map(function (ref) {
-              var err = ref.err;
-              var code = ref.code;
-
-              return ((err.toString()) + " in\n\n" + code + "\n");
-          }).join('\n'),
-            vm
-          );
-        }
-      }
-
-      return (cache[key] = res)
-    }
+          // compile
+          var compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach(function (e) {
+                          warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                  }
+                  else {
+                      compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                  }
+              }
+          }
+          // turn code into functions
+          var res = {};
+          var fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn$$1("Failed to generate render function:\n\n" +
+                      fnGenErrors
+                          .map(function (ref) {
+                              var err = ref.err;
+                              var code = ref.code;
+
+                              return ((err.toString()) + " in\n\n" + code + "\n");
+                  })
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
   }
 
-  /*  */
-
-  function createCompilerCreator (baseCompile) {
-    return function createCompiler (baseOptions) {
-      function compile (
-        template,
-        options
-      ) {
-        var finalOptions = Object.create(baseOptions);
-        var errors = [];
-        var tips = [];
-
-        var warn = function (msg, range, tip) {
-          (tip ? tips : errors).push(msg);
-        };
-
-        if (options) {
-          if (options.outputSourceRange) {
-            // $flow-disable-line
-            var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-            warn = function (msg, range, tip) {
-              var data = { msg: msg };
-              if (range) {
-                if (range.start != null) {
-                  data.start = range.start + leadingSpaceLength;
-                }
-                if (range.end != null) {
-                  data.end = range.end + leadingSpaceLength;
-                }
+  /* @flow */
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              var finalOptions = Object.create(baseOptions);
+              var errors = [];
+              var tips = [];
+              var warn = function (msg, range, tip) {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = function (msg, range, tip) {
+                          var data = { msg: msg };
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (var key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
               }
-              (tip ? tips : errors).push(data);
-            };
-          }
-          // merge custom modules
-          if (options.modules) {
-            finalOptions.modules =
-              (baseOptions.modules || []).concat(options.modules);
-          }
-          // merge custom directives
-          if (options.directives) {
-            finalOptions.directives = extend(
-              Object.create(baseOptions.directives || null),
-              options.directives
-            );
-          }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key];
-            }
+              finalOptions.warn = warn;
+              var compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
           }
-        }
-
-        finalOptions.warn = warn;
-
-        var compiled = baseCompile(template.trim(), finalOptions);
-        {
-          detectErrors(compiled.ast, warn);
-        }
-        compiled.errors = errors;
-        compiled.tips = tips;
-        return compiled
-      }
-
-      return {
-        compile: compile,
-        compileToFunctions: createCompileToFunctionFn(compile)
-      }
-    }
+          return {
+              compile: compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
   }
 
-  /*  */
-
+  /* @flow */
   // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
-  var createCompiler = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-      optimize(ast, options);
-    }
-    var code = generate(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
+  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      var ast = parse(template.trim(), options);
+      if (options.optimize !== false) {
+          optimize(ast, options);
+      }
+      var code = generate(ast, options);
+      return {
+          ast: ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
-  /*  */
-
+  /* @flow */
   var ref = createCompiler(baseOptions);
   var compile = ref.compile;
   var compileToFunctions = ref.compileToFunctions;
 
-  /*  */
-
-  var isAttr = makeMap(
-    'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap'
-  );
-
+  /* @flow */
+  var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap');
   /* istanbul ignore next */
   var isRenderableAttr = function (name) {
-    return (
-      isAttr(name) ||
-      name.indexOf('data-') === 0 ||
-      name.indexOf('aria-') === 0
-    )
+      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
   };
-
   var propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv'
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv',
   };
-
   var ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;'
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;',
   };
-
-  function escape (s) {
-    return s.replace(/[<>"&]/g, escapeChar)
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
   }
-
-  function escapeChar (a) {
-    return ESC[a] || a
+  function escapeChar(a) {
+      return ESC[a] || a;
   }
 
-  /*  */
-
-
-
-
+  /* @flow */
   var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
   // let the model AST transform translate v-model into appropriate
   // props bindings
-  function applyModelTransform (el, state) {
-    if (el.directives) {
-      for (var i = 0; i < el.directives.length; i++) {
-        var dir = el.directives[i];
-        if (dir.name === 'model') {
-          state.directives.model(el, dir, state.warn);
-          // remove value for textarea as its converted to text
-          if (el.tag === 'textarea' && el.props) {
-            el.props = el.props.filter(function (p) { return p.name !== 'value'; });
-          }
-          break
-        }
+  function applyModelTransform(el, state) {
+      if (el.directives) {
+          for (var i = 0; i < el.directives.length; i++) {
+              var dir = el.directives[i];
+              if (dir.name === 'model') {
+                  state.directives.model(el, dir, state.warn);
+                  // remove value for textarea as its converted to text
+                  if (el.tag === 'textarea' && el.props) {
+                      el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+                  }
+                  break;
+              }
+          }
       }
-    }
   }
+  function genAttrSegments(attrs) {
+      return attrs.map(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
 
-  function genAttrSegments (
-    attrs
-  ) {
-    return attrs.map(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      return genAttrSegment(name, value);
-    })
+          return genAttrSegment(name, value);
+      });
   }
+  function genDOMPropSegments(props, attrs) {
+      var segments = [];
+      props.forEach(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
 
-  function genDOMPropSegments (
-    props,
-    attrs
-  ) {
-    var segments = [];
-    props.forEach(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      name = propsToAttrMap[name] || name.toLowerCase();
-      if (isRenderableAttr(name) &&
-        !(attrs && attrs.some(function (a) { return a.name === name; }))
-      ) {
-        segments.push(genAttrSegment(name, value));
+          name = propsToAttrMap[name] || name.toLowerCase();
+          if (isRenderableAttr(name) &&
+              !(attrs && attrs.some(function (a) { return a.name === name; }))) {
+              segments.push(genAttrSegment(name, value));
+          }
+      });
+      return segments;
+  }
+  function genAttrSegment(name, value) {
+      if (plainStringRE.test(value)) {
+          // force double quote
+          value = value.replace(/^'|'$/g, '"');
+          // force enumerated attr to "true"
+          if (isEnumeratedAttr(name) && value !== "\"false\"") {
+              value = "\"true\"";
+          }
+          return {
+              type: RAW,
+              value: isBooleanAttr(name)
+                  ? (" " + name + "=\"" + name + "\"")
+                  : value === '""'
+                      ? (" " + name)
+                      : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+          };
+      }
+      else {
+          return {
+              type: EXPRESSION,
+              value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+          };
       }
-    });
-    return segments
   }
-
-  function genAttrSegment (name, value) {
-    if (plainStringRE.test(value)) {
-      // force double quote
-      value = value.replace(/^'|'$/g, '"');
-      // force enumerated attr to "true"
-      if (isEnumeratedAttr(name) && value !== "\"false\"") {
-        value = "\"true\"";
+  function genClassSegments(staticClass, classBinding) {
+      if (staticClass && !classBinding) {
+          return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
       }
-      return {
-        type: RAW,
-        value: isBooleanAttr(name)
-          ? (" " + name + "=\"" + name + "\"")
-          : value === '""'
-            ? (" " + name)
-            : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-      }
-    } else {
-      return {
-        type: EXPRESSION,
-        value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+              } ];
       }
-    }
-  }
-
-  function genClassSegments (
-    staticClass,
-    classBinding
-  ) {
-    if (staticClass && !classBinding) {
-      return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-      }]
-    }
   }
-
-  function genStyleSegments (
-    staticStyle,
-    parsedStaticStyle,
-    styleBinding,
-    vShowExpression
-  ) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-      return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-            ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-            : 'null') + ")")
-      }]
-    }
+  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+      if (staticStyle && !styleBinding && !vShowExpression) {
+          return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                      ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                      : 'null') + ")"),
+              } ];
+      }
   }
 
-  /*  */
-
+  /* @flow */
   // optimizability constants
   var optimizability = {
-    FALSE: 0,    // whole sub tree un-optimizable
-    FULL: 1,     // whole sub tree optimizable
-    SELF: 2,     // self optimizable but has some un-optimizable children
-    CHILDREN: 3, // self un-optimizable but have fully optimizable children
-    PARTIAL: 4   // self un-optimizable with some un-optimizable children
+      FALSE: 0,
+      FULL: 1,
+      SELF: 2,
+      CHILDREN: 3,
+      PARTIAL: 4, // self un-optimizable with some un-optimizable children
   };
-
   var isPlatformReservedTag$1;
-
-  function optimize$1 (root, options) {
-    if (!root) { return }
-    isPlatformReservedTag$1 = options.isReservedTag || no;
-    walk(root, true);
-  }
-
-  function walk (node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-      node.ssrOptimizability = optimizability.FALSE;
-      return
-    }
-    // root node or nodes with custom directives should always be a VNode
-    var selfUnoptimizable = isRoot || hasCustomDirective(node);
-    var check = function (child) {
-      if (child.ssrOptimizability !== optimizability.FULL) {
-        node.ssrOptimizability = selfUnoptimizable
-          ? optimizability.PARTIAL
-          : optimizability.SELF;
-      }
-    };
-    if (selfUnoptimizable) {
-      node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        walk(child);
-        check(child);
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          walk(block, isRoot);
-          check(block);
-        }
+  function optimize$1(root, options) {
+      if (!root)
+          { return; }
+      isPlatformReservedTag$1 = options.isReservedTag || no;
+      walk(root, true);
+  }
+  function walk(node, isRoot) {
+      if (isUnOptimizableTree(node)) {
+          node.ssrOptimizability = optimizability.FALSE;
+          return;
+      }
+      // root node or nodes with custom directives should always be a VNode
+      var selfUnoptimizable = isRoot || hasCustomDirective(node);
+      var check = function (child) {
+          if (child.ssrOptimizability !== optimizability.FULL) {
+              node.ssrOptimizability = selfUnoptimizable
+                  ? optimizability.PARTIAL
+                  : optimizability.SELF;
+          }
+      };
+      if (selfUnoptimizable) {
+          node.ssrOptimizability = optimizability.CHILDREN;
+      }
+      if (node.type === 1) {
+          for (var i = 0, l = node.children.length; i < l; i++) {
+              var child = node.children[i];
+              walk(child);
+              check(child);
+          }
+          if (node.ifConditions) {
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
+                  walk(block, isRoot);
+                  check(block);
+              }
+          }
+          if (node.ssrOptimizability == null ||
+              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+              node.ssrOptimizability = optimizability.FULL;
+          }
+          else {
+              node.children = optimizeSiblings(node);
+          }
       }
-      if (node.ssrOptimizability == null ||
-        (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-      ) {
-        node.ssrOptimizability = optimizability.FULL;
-      } else {
-        node.children = optimizeSiblings(node);
+      else {
+          node.ssrOptimizability = optimizability.FULL;
+      }
+  }
+  function optimizeSiblings(el) {
+      var children = el.children;
+      var optimizedChildren = [];
+      var currentOptimizableGroup = [];
+      var pushGroup = function () {
+          if (currentOptimizableGroup.length) {
+              optimizedChildren.push({
+                  type: 1,
+                  parent: el,
+                  tag: 'template',
+                  attrsList: [],
+                  attrsMap: {},
+                  rawAttrsMap: {},
+                  children: currentOptimizableGroup,
+                  ssrOptimizability: optimizability.FULL,
+              });
+          }
+          currentOptimizableGroup = [];
+      };
+      for (var i = 0; i < children.length; i++) {
+          var c = children[i];
+          if (c.ssrOptimizability === optimizability.FULL) {
+              currentOptimizableGroup.push(c);
+          }
+          else {
+              // wrap fully-optimizable adjacent siblings inside a template tag
+              // so that they can be optimized into a single ssrNode by codegen
+              pushGroup();
+              optimizedChildren.push(c);
+          }
       }
-    } else {
-      node.ssrOptimizability = optimizability.FULL;
-    }
+      pushGroup();
+      return optimizedChildren;
   }
-
-  function optimizeSiblings (el) {
-    var children = el.children;
-    var optimizedChildren = [];
-
-    var currentOptimizableGroup = [];
-    var pushGroup = function () {
-      if (currentOptimizableGroup.length) {
-        optimizedChildren.push({
-          type: 1,
-          parent: el,
-          tag: 'template',
-          attrsList: [],
-          attrsMap: {},
-          rawAttrsMap: {},
-          children: currentOptimizableGroup,
-          ssrOptimizability: optimizability.FULL
-        });
+  function isUnOptimizableTree(node) {
+      if (node.type === 2 || node.type === 3) {
+          // text or expression
+          return false;
       }
-      currentOptimizableGroup = [];
-    };
-
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.ssrOptimizability === optimizability.FULL) {
-        currentOptimizableGroup.push(c);
-      } else {
-        // wrap fully-optimizable adjacent siblings inside a template tag
-        // so that they can be optimized into a single ssrNode by codegen
-        pushGroup();
-        optimizedChildren.push(c);
-      }
-    }
-    pushGroup();
-    return optimizedChildren
-  }
-
-  function isUnOptimizableTree (node) {
-    if (node.type === 2 || node.type === 3) { // text or expression
-      return false
-    }
-    return (
-      isBuiltInTag(node.tag) || // built-in (slot, component)
-      !isPlatformReservedTag$1(node.tag) || // custom component
-      !!node.component || // "is" component
-      isSelectWithModel(node) // <select v-model> requires runtime inspection
-    )
+      return (isBuiltInTag(node.tag) || // built-in (slot, component)
+          !isPlatformReservedTag$1(node.tag) || // custom component
+          !!node.component || // "is" component
+          isSelectWithModel(node) // <select v-model> requires runtime inspection
+      );
   }
-
   var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-  function hasCustomDirective (node) {
-    return (
-      node.type === 1 &&
-      node.directives &&
-      node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-    )
+  function hasCustomDirective(node) {
+      return (node.type === 1 &&
+          node.directives &&
+          node.directives.some(function (d) { return !isBuiltInDir(d.name); }));
   }
-
   // <select v-model> cannot be optimized because it requires a runtime check
   // to determine proper selected option
-  function isSelectWithModel (node) {
-    return (
-      node.type === 1 &&
-      node.tag === 'select' &&
-      node.directives != null &&
-      node.directives.some(function (d) { return d.name === 'model'; })
-    )
+  function isSelectWithModel(node) {
+      return (node.type === 1 &&
+          node.tag === 'select' &&
+          node.directives != null &&
+          node.directives.some(function (d) { return d.name === 'model'; }));
   }
 
-  /*  */
-
-
-
-
+  /* @flow */
   // segment types
   var RAW = 0;
   var INTERPOLATION = 1;
   var EXPRESSION = 2;
-
-  function generate$1 (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genSSRElement (el, state) {
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genSSRElement)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state, genSSRElement)
-    } else if (el.tag === 'template' && !el.slotTarget) {
-      return el.ssrOptimizability === optimizability.FULL
-        ? genChildrenAsStringNode(el, state)
-        : genSSRChildren(el, state) || 'void 0'
-    }
-
-    switch (el.ssrOptimizability) {
-      case optimizability.FULL:
-        // stringify whole tree
-        return genStringElement(el, state)
-      case optimizability.SELF:
-        // stringify self and check children
-        return genStringElementWithChildren(el, state)
-      case optimizability.CHILDREN:
-        // generate self as VNode and stringify children
-        return genNormalElement(el, state, true)
-      case optimizability.PARTIAL:
-        // generate self as VNode and check children
-        return genNormalElement(el, state, false)
-      default:
-        // bail whole tree
-        return genElement(el, state)
-    }
-  }
-
-  function genNormalElement (el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData$2(el, state);
-    var children = stringifyChildren
-      ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-      : genSSRChildren(el, state, true);
-    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-  }
-
-  function genSSRChildren (el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-  }
-
-  function genSSRNode (el, state) {
-    return el.type === 1
-      ? genSSRElement(el, state)
-      : genText(el)
-  }
-
-  function genChildrenAsStringNode (el, state) {
-    return el.children.length
-      ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-      : ''
-  }
-
-  function genStringElement (el, state) {
-    return ("_ssrNode(" + (elementToString(el, state)) + ")")
-  }
-
-  function genStringElementWithChildren (el, state) {
-    var children = genSSRChildren(el, state, true);
-    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-  }
-
-  function elementToString (el, state) {
-    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-  }
-
-  function elementToSegments (el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-      el.forProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genFor(el, state, elementToString, '_ssrList')
-      }]
-    } else if (el.if && !el.ifProcessed) {
-      el.ifProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genIf(el, state, elementToString, '"<!---->"')
-      }]
-    } else if (el.tag === 'template') {
-      return childrenToSegments(el, state)
-    }
-
-    var openSegments = elementToOpenTagSegments(el, state);
-    var childrenSegments = childrenToSegments(el, state);
-    var ref = state.options;
-    var isUnaryTag = ref.isUnaryTag;
-    var close = (isUnaryTag && isUnaryTag(el.tag))
-      ? []
-      : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-    return openSegments.concat(childrenSegments, close)
-  }
-
-  function elementToOpenTagSegments (el, state) {
-    applyModelTransform(el, state);
-    var binding;
-    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-    // attrs
-    if (el.attrs) {
-      segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-      segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-      segments.push.apply(
-        segments,
-        genClassSegments(el.staticClass, el.classBinding)
-      );
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-      segments.push.apply(
-        segments,
-        genStyleSegments(
-          el.attrsMap.style,
-          el.staticStyle,
-          el.styleBinding,
-          el.attrsMap['v-show']
-        )
-      );
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-      segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-    }
-    segments.push({ type: RAW, value: ">" });
-    return segments
-  }
-
-  function childrenToSegments (el, state) {
-    var binding;
-    if ((binding = el.attrsMap['v-html'])) {
-      return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    return el.children
-      ? nodesToSegments(el.children, state)
-      : []
+  function generate$1(ast, options) {
+      var state = new CodegenState(options);
+      var code = ast ? genSSRElement(ast, state) : '_c("div")';
+      return {
+          render: ("with(this){return " + code + "}"),
+          staticRenderFns: state.staticRenderFns,
+      };
   }
-
-  function nodesToSegments (
-    children,
-    state
-  ) {
-    var segments = [];
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.type === 1) {
-        segments.push.apply(segments, elementToSegments(c, state));
-      } else if (c.type === 2) {
-        segments.push({ type: INTERPOLATION, value: c.expression });
-      } else if (c.type === 3) {
-        var text = escape(c.text);
-        if (c.isComment) {
-          text = '<!--' + text + '-->';
-        }
-        segments.push({ type: RAW, value: text });
+  function genSSRElement(el, state) {
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genSSRElement);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state, genSSRElement);
+      }
+      else if (el.tag === 'template' && !el.slotTarget) {
+          return el.ssrOptimizability === optimizability.FULL
+              ? genChildrenAsStringNode(el, state)
+              : genSSRChildren(el, state) || 'void 0';
+      }
+      switch (el.ssrOptimizability) {
+          case optimizability.FULL:
+              // stringify whole tree
+              return genStringElement(el, state);
+          case optimizability.SELF:
+              // stringify self and check children
+              return genStringElementWithChildren(el, state);
+          case optimizability.CHILDREN:
+              // generate self as VNode and stringify children
+              return genNormalElement(el, state, true);
+          case optimizability.PARTIAL:
+              // generate self as VNode and check children
+              return genNormalElement(el, state, false);
+          default:
+              // bail whole tree
+              return genElement(el, state);
+      }
+  }
+  function genNormalElement(el, state, stringifyChildren) {
+      var data = el.plain ? undefined : genData$2(el, state);
+      var children = stringifyChildren
+          ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+          : genSSRChildren(el, state, true);
+      return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+  }
+  function genSSRChildren(el, state, checkSkip) {
+      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+  }
+  function genSSRNode(el, state) {
+      return el.type === 1 ? genSSRElement(el, state) : genText(el);
+  }
+  function genChildrenAsStringNode(el, state) {
+      return el.children.length
+          ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+          : '';
+  }
+  function genStringElement(el, state) {
+      return ("_ssrNode(" + (elementToString(el, state)) + ")");
+  }
+  function genStringElementWithChildren(el, state) {
+      var children = genSSRChildren(el, state, true);
+      return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+  }
+  function elementToString(el, state) {
+      return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+  }
+  function elementToSegments(el, state) {
+      // v-for / v-if
+      if (el.for && !el.forProcessed) {
+          el.forProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genFor(el, state, elementToString, '_ssrList'),
+              } ];
+      }
+      else if (el.if && !el.ifProcessed) {
+          el.ifProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genIf(el, state, elementToString, '"<!---->"'),
+              } ];
+      }
+      else if (el.tag === 'template') {
+          return childrenToSegments(el, state);
+      }
+      var openSegments = elementToOpenTagSegments(el, state);
+      var childrenSegments = childrenToSegments(el, state);
+      var ref = state.options;
+      var isUnaryTag = ref.isUnaryTag;
+      var close = isUnaryTag && isUnaryTag(el.tag)
+          ? []
+          : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+      return openSegments.concat(childrenSegments, close);
+  }
+  function elementToOpenTagSegments(el, state) {
+      applyModelTransform(el, state);
+      var binding;
+      var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+      // attrs
+      if (el.attrs) {
+          segments.push.apply(segments, genAttrSegments(el.attrs));
+      }
+      // domProps
+      if (el.props) {
+          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+      }
+      // v-bind="object"
+      if ((binding = el.attrsMap['v-bind'])) {
+          segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+      }
+      // v-bind.prop="object"
+      if ((binding = el.attrsMap['v-bind.prop'])) {
+          segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+      }
+      // class
+      if (el.staticClass || el.classBinding) {
+          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+      }
+      // style & v-show
+      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+      }
+      // _scopedId
+      if (state.options.scopeId) {
+          segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+      }
+      segments.push({ type: RAW, value: ">" });
+      return segments;
+  }
+  function childrenToSegments(el, state) {
+      var binding;
+      if ((binding = el.attrsMap['v-html'])) {
+          return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+      }
+      if ((binding = el.attrsMap['v-text'])) {
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+      }
+      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+      }
+      return el.children ? nodesToSegments(el.children, state) : [];
+  }
+  function nodesToSegments(children, state) {
+      var segments = [];
+      for (var i = 0; i < children.length; i++) {
+          var c = children[i];
+          if (c.type === 1) {
+              segments.push.apply(segments, elementToSegments(c, state));
+          }
+          else if (c.type === 2) {
+              segments.push({ type: INTERPOLATION, value: c.expression });
+          }
+          else if (c.type === 3) {
+              var text = escape(c.text);
+              if (c.isComment) {
+                  text = '<!--' + text + '-->';
+              }
+              segments.push({ type: RAW, value: text });
+          }
       }
-    }
-    return segments
+      return segments;
   }
-
-  function flattenSegments (segments) {
-    var mergedSegments = [];
-    var textBuffer = '';
-
-    var pushBuffer = function () {
-      if (textBuffer) {
-        mergedSegments.push(JSON.stringify(textBuffer));
-        textBuffer = '';
-      }
-    };
-
-    for (var i = 0; i < segments.length; i++) {
-      var s = segments[i];
-      if (s.type === RAW) {
-        textBuffer += s.value;
-      } else if (s.type === INTERPOLATION) {
-        pushBuffer();
-        mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-      } else if (s.type === EXPRESSION) {
-        pushBuffer();
-        mergedSegments.push(("(" + (s.value) + ")"));
+  function flattenSegments(segments) {
+      var mergedSegments = [];
+      var textBuffer = '';
+      var pushBuffer = function () {
+          if (textBuffer) {
+              mergedSegments.push(JSON.stringify(textBuffer));
+              textBuffer = '';
+          }
+      };
+      for (var i = 0; i < segments.length; i++) {
+          var s = segments[i];
+          if (s.type === RAW) {
+              textBuffer += s.value;
+          }
+          else if (s.type === INTERPOLATION) {
+              pushBuffer();
+              mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+          }
+          else if (s.type === EXPRESSION) {
+              pushBuffer();
+              mergedSegments.push(("(" + (s.value) + ")"));
+          }
       }
-    }
-    pushBuffer();
-
-    return mergedSegments.join('+')
+      pushBuffer();
+      return mergedSegments.join('+');
   }
 
-  /*  */
-
-  var createCompiler$1 = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    optimize$1(ast, options);
-    var code = generate$1(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
+  /* @flow */
+  var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+      var ast = parse(template.trim(), options);
+      optimize$1(ast, options);
+      var code = generate$1(ast, options);
+      return {
+          ast: ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
-  /*  */
-
+  /* @flow */
   var ref$1 = createCompiler$1(baseOptions);
   var compile$1 = ref$1.compile;
   var compileToFunctions$1 = ref$1.compileToFunctions;
 
-  /*  */
+  /* @flow */
 
   exports.parseComponent = parseComponent;
   exports.compile = compile;
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index e76e16c823b..ea282103df3 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -5,140 +5,116 @@ Object.defineProperty(exports, '__esModule', { value: true });
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
 var deindent = _interopDefault(require('de-indent'));
-var he = _interopDefault(require('he'));
-
-/*  */
+var he = require('he');
 
+/* @flow */
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -146,121 +122,99 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys(modules) {
+    return modules
+        .reduce(function (keys, m) {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
 
-/*  */
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
-
+/* @flow */
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
-
-/*  */
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
+/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
 var startTagOpen = new RegExp(("^<" + qnameCapture));
@@ -270,808 +224,732 @@ var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
 var conditionalComment = /^<!\[/;
-
 // Special Elements (can contain anything)
 var isPlainTextElement = makeMap('script,style,textarea', true);
 var reCache = {};
-
 var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
 var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
 var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+function decodeAttr(value, shouldDecodeNewlines) {
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, function (match) { return decodingMap[match]; });
+}
+function parseHTML(html, options) {
+    var stack = [];
+    var expectHTML = options.expectHTML;
+    var isUnaryTag$$1 = options.isUnaryTag || no;
+    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var index = 0;
+    var last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            var textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    var commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    var conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                var doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                var endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    var curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                var startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            var text = (void 0), rest = (void 0), next = (void 0);
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        { break; }
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
             }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
         }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
+        else {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                    start: index + html.length,
+                });
+            }
+            break;
         }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
     }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        var start = html.match(startTagOpen);
+        if (start) {
+            var match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            var end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
     }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
+    function handleStartTag(match) {
+        var tagName = match.tagName;
+        var unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var l = match.attrs.length;
+        var attrs = new Array(l);
+        for (var i = 0; i < l; i++) {
+            var args = match.attrs[i];
+            var value = args[3] || args[4] || args[5] || '';
+            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
     }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
+    function parseEndTag(tagName, start, end) {
+        var pos, lowerCasedTagName;
+        if (start == null)
+            { start = index; }
+        if (end == null)
+            { end = index; }
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (var i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
     }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
 }
 
-/*  */
-
+/* @flow */
 var splitRE = /\r?\n/g;
 var replaceRE = /./g;
 var isSpecialTag = makeMap('script,style,template', true);
-
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
-function parseComponent (
-  content,
-  options
-) {
-  if ( options === void 0 ) options = {};
-
-  var sfc = {
-    template: null,
-    script: null,
-    styles: [],
-    customBlocks: [],
-    errors: []
-  };
-  var depth = 0;
-  var currentBlock = null;
-
-  var warn = function (msg) {
-    sfc.errors.push(msg);
-  };
-
-  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-    warn = function (msg, range) {
-      var data = { msg: msg };
-      if (range.start != null) {
-        data.start = range.start;
-      }
-      if (range.end != null) {
-        data.end = range.end;
-      }
-      sfc.errors.push(data);
+function parseComponent(content, options) {
+    if ( options === void 0 ) options = {};
+
+    var sfc = {
+        template: null,
+        script: null,
+        styles: [],
+        customBlocks: [],
+        errors: [],
     };
-  }
-
-  function start (
-    tag,
-    attrs,
-    unary,
-    start,
-    end
-  ) {
-    if (depth === 0) {
-      currentBlock = {
-        type: tag,
-        content: '',
-        start: end,
-        attrs: attrs.reduce(function (cumulated, ref) {
-          var name = ref.name;
-          var value = ref.value;
-
-          cumulated[name] = value || true;
-          return cumulated
-        }, {})
-      };
-      if (isSpecialTag(tag)) {
-        checkAttrs(currentBlock, attrs);
-        if (tag === 'style') {
-          sfc.styles.push(currentBlock);
-        } else {
-          sfc[tag] = currentBlock;
-        }
-      } else { // custom blocks
-        sfc.customBlocks.push(currentBlock);
-      }
-    }
-    if (!unary) {
-      depth++;
-    }
-  }
-
-  function checkAttrs (block, attrs) {
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (attr.name === 'lang') {
-        block.lang = attr.value;
-      }
-      if (attr.name === 'scoped') {
-        block.scoped = true;
-      }
-      if (attr.name === 'module') {
-        block.module = attr.value || true;
-      }
-      if (attr.name === 'src') {
-        block.src = attr.value;
-      }
-    }
-  }
-
-  function end (tag, start) {
-    if (depth === 1 && currentBlock) {
-      currentBlock.end = start;
-      var text = content.slice(currentBlock.start, currentBlock.end);
-      if (options.deindent !== false) {
-        text = deindent(text);
-      }
-      // pad content so that linters and pre-processors can output correct
-      // line numbers in errors and warnings
-      if (currentBlock.type !== 'template' && options.pad) {
-        text = padContent(currentBlock, options.pad) + text;
-      }
-      currentBlock.content = text;
-      currentBlock = null;
-    }
-    depth--;
-  }
-
-  function padContent (block, pad) {
-    if (pad === 'space') {
-      return content.slice(0, block.start).replace(replaceRE, ' ')
-    } else {
-      var offset = content.slice(0, block.start).split(splitRE).length;
-      var padChar = block.type === 'script' && !block.lang
-        ? '//\n'
-        : '\n';
-      return Array(offset).join(padChar)
-    }
-  }
-
-  parseHTML(content, {
-    warn: warn,
-    start: start,
-    end: end,
-    outputSourceRange: options.outputSourceRange
-  });
-
-  return sfc
+    var depth = 0;
+    var currentBlock = null;
+    var warn = function (msg) {
+        sfc.errors.push(msg);
+    };
+    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        warn = function (msg, range) {
+            var data = { msg: msg };
+            if (range.start != null) {
+                data.start = range.start;
+            }
+            if (range.end != null) {
+                data.end = range.end;
+            }
+            sfc.errors.push(data);
+        };
+    }
+    function start(tag, attrs, unary, start, end) {
+        if (depth === 0) {
+            currentBlock = {
+                type: tag,
+                content: '',
+                start: end,
+                attrs: attrs.reduce(function (cumulated, ref) {
+                    var name = ref.name;
+                    var value = ref.value;
+
+                    cumulated[name] = value || true;
+                    return cumulated;
+                }, {}),
+            };
+            if (isSpecialTag(tag)) {
+                checkAttrs(currentBlock, attrs);
+                if (tag === 'style') {
+                    sfc.styles.push(currentBlock);
+                }
+                else {
+                    sfc[tag] = currentBlock;
+                }
+            }
+            else {
+                // custom blocks
+                sfc.customBlocks.push(currentBlock);
+            }
+        }
+        if (!unary) {
+            depth++;
+        }
+    }
+    function checkAttrs(block, attrs) {
+        for (var i = 0; i < attrs.length; i++) {
+            var attr = attrs[i];
+            if (attr.name === 'lang') {
+                block.lang = attr.value;
+            }
+            if (attr.name === 'scoped') {
+                block.scoped = true;
+            }
+            if (attr.name === 'module') {
+                block.module = attr.value || true;
+            }
+            if (attr.name === 'src') {
+                block.src = attr.value;
+            }
+        }
+    }
+    function end(tag, start) {
+        if (depth === 1 && currentBlock) {
+            currentBlock.end = start;
+            var text = content.slice(currentBlock.start, currentBlock.end);
+            if (options.deindent !== false) {
+                //@ts-expect-error
+                text = deindent(text);
+            }
+            // pad content so that linters and pre-processors can output correct
+            // line numbers in errors and warnings
+            if (currentBlock.type !== 'template' && options.pad) {
+                text = padContent(currentBlock, options.pad) + text;
+            }
+            currentBlock.content = text;
+            currentBlock = null;
+        }
+        depth--;
+    }
+    function padContent(block, pad) {
+        if (pad === 'space') {
+            return content.slice(0, block.start).replace(replaceRE, ' ');
+        }
+        else {
+            var offset = content.slice(0, block.start).split(splitRE).length;
+            var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+            return Array(offset).join(padChar);
+        }
+    }
+    parseHTML(content, {
+        warn: warn,
+        start: start,
+        end: end,
+        outputSourceRange: options.outputSourceRange,
+    });
+    return sfc;
 }
 
-/*  */
-
+/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
+var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
 var isPhantomJS = UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
-
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// @ts-ignore
+var nativeWatch = {}.watch;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function get() {
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/(function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function has (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function add (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function clear () {
+            this.set = Object.create(null);
+        };
 
-    return Set;
-  }());
+        return Set;
+    }());
 }
 
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+/* @flow */
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+/* @flow */
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
+    };
+    var repeat = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
+                    .join('\n'));
+        }
+        else {
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+        }
+    };
 }
 
-/*  */
-
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
 };
-
 Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
+    this.subs.push(sub);
 };
-
 Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
+    remove(this.subs, sub);
 };
-
 Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
+    if (Dep.target) {
+        Dep.target.addDep(this);
+    }
 };
-
 Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
 };
-
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
 };
 
 var prototypeAccessors = { child: { configurable: true } };
-
 // DEPRECATED: alias for componentInstance for backwards compat.
 /* istanbul ignore next */
 prototypeAccessors.child.get = function () {
-  return this.componentInstance
+    return this.componentInstance;
 };
 
 Object.defineProperties( VNode.prototype, prototypeAccessors );
@@ -1080,423 +958,370 @@ Object.defineProperties( VNode.prototype, prototypeAccessors );
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
+
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
+        }
+        else {
+            copyAugment(value, arrayMethods, arrayKeys);
+        }
+        this.observeArray(value);
+    }
+    else {
+        this.walk(value);
+    }
 };
-
 /**
  * Walk through all properties and convert them into
  * getter/setters. This method should only be called when
  * value type is Object.
  */
 Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive$$1(obj, keys[i]);
+    }
 };
-
 /**
  * Observe a list of Array items.
  */
 Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
 };
-
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
-}
-
+function defineReactive$$1(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive$$1(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
     }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1504,119 +1329,97 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            "but got " + (toRawType(value)) + ".", vm);
+    }
 }
 
-/*  */
-
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
 var callbacks = [];
-
-function flushCallbacks () {
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1624,629 +1427,542 @@ function flushCallbacks () {
 // completely stops working after triggering a few times... so, if native
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/*  */
+if (typeof Promise !== 'undefined' && isNative(Promise)) ;
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 
-/*  */
+/* @flow */
 
+/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
-
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
 var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,translate,' +
-  'truespeed,typemustmatch,visible'
-);
-
-/*  */
-
-/*  */
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+
+/* @flow */
+
+/* @flow */
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isPreTag = function (tag) { return tag === 'pre'; };
-
 var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
-
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/*  */
-
-/*  */
+/* @flow */
 
+/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function parseFilters(exp) {
+    var inSingle = false;
+    var inDouble = false;
+    var inTemplateString = false;
+    var inRegex = false;
+    var curly = 0;
+    var square = 0;
+    var paren = 0;
+    var lastFilterIndex = 0;
+    var c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                { inSingle = false; }
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                { inDouble = false; }
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                { inTemplateString = false; }
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                { inRegex = false; }
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                var j = i - 1;
+                var p = (void 0);
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        { break; }
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
     }
-  }
-
-  return expression
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
 }
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
+function wrapFilter(exp, filter) {
+    var i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return ("_f(\"" + filter + "\")(" + exp + ")");
+    }
+    else {
+        var name = filter.slice(0, i);
+        var args = filter.slice(i + 1);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+    }
 }
 
-/*  */
-
+/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
 var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    var tokens = [];
+    var rawTokens = [];
+    var lastIndex = (tagRE.lastIndex = 0);
+    var match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        var exp = parseFilters(match[1].trim());
+        tokens.push(("_s(" + exp + ")"));
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/*  */
-
-
-
+/* @flow */
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    var attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    var events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    var handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
 }
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
 }
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function getBindingAttr(el, name, getStatic) {
+    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        var staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
+function getAndRemoveAttr(el, name, removeFromMap) {
+    var val;
+    if ((val = el.attrsMap[name]) != null) {
+        var list = el.attrsList;
+        for (var i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
     var list = el.attrsList;
     for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
+        var attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
 }
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
-    }
-  }
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
+/* @flow */
+function transformNode(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticClass = getAndRemoveAttr(el, 'class');
+    if (process.env.NODE_ENV !== 'production' && staticClass) {
+        var res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn("class=\"" + staticClass + "\": " +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
     }
-    if (range.end != null) {
-      item.end = range.end;
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass);
+    }
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
     }
-  }
-  return item
-}
-
-/*  */
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  if (process.env.NODE_ENV !== 'production' && staticClass) {
-    var res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        "class=\"" + staticClass + "\": " +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
 }
-
-function genData (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
+function genData(el) {
+    var data = '';
+    if (el.staticClass) {
+        data += "staticClass:" + (el.staticClass) + ",";
+    }
+    if (el.classBinding) {
+        data += "class:" + (el.classBinding) + ",";
+    }
+    return data;
 }
-
 var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData
+    staticKeys: ['staticClass'],
+    transformNode: transformNode,
+    genData: genData,
 };
 
-/*  */
-
+/* @flow */
 var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            var tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
 
-/*  */
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      var res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          "style=\"" + staticStyle + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
-    }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
+/* @flow */
+function transformNode$1(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            var res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn("style=\"" + staticStyle + "\": " +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
 }
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:(" + (el.styleBinding) + "),";
-  }
-  return data
+function genData$1(el) {
+    var data = '';
+    if (el.staticStyle) {
+        data += "staticStyle:" + (el.staticStyle) + ",";
+    }
+    if (el.styleBinding) {
+        data += "style:(" + (el.styleBinding) + "),";
+    }
+    return data;
 }
-
 var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode$1,
+    genData: genData$1,
 };
 
-/*  */
-
+/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
+    var baseValueExpression = '$$v';
+    var valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            "(typeof " + baseValueExpression + " === 'string'" +
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: ("(" + value + ")"),
+        expression: JSON.stringify(value),
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    var res = parseModel(value);
+    if (res.key === null) {
+        return (value + "=" + assignment);
+    }
+    else {
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -2261,115 +1977,98 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
 var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.');
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-
-  str = val;
-  index = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index)
+function next() {
+    return str.charCodeAt(++index);
 }
-
-function eof () {
-  return index >= len
+function eof() {
+    return index >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index;
-      break
-    }
-  }
+function parseBracket(chr) {
+    var inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            { inBracket++; }
+        if (chr === 0x5d)
+            { inBracket--; }
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    var stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
+/* @flow */
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
 var stripParensRE = /^\(|\)$/g;
 var dynamicArgRE = /^\[.*\]$/;
-
 var argRE = /:(.*)$/;
 var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
 var slotRE = /^v-slot(:|$)|^#/;
-
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /\s+/g;
-
+var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-
 var decodeHTMLCached = cached(he.decode);
-
 var emptySlotScopeToken = "_empty_";
-
 // configurable state
 var warn$1;
 var delimiters;
@@ -2380,1216 +2079,1019 @@ var platformIsPreTag;
 var platformMustUseProp;
 var platformGetTagNamespace;
 var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag: tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent: parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$1 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$1(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    var isReservedTag = options.isReservedTag || no;
+    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    var stack = [];
+    var preserveWhitespace = options.preserveWhitespace !== false;
+    var whitespaceOption = options.whitespace;
+    var root;
+    var currentParent;
+    var inVPre = false;
+    var inPre = false;
+    var warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
     }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce("Component template should contain exactly one root element. " +
+                    "If you are using v-if on multiple elements, " +
+                    "use v-else-if to chain them instead.", { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (var i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
     }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            var lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
     }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$1,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$1(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        process.env.NODE_ENV !== 'production' && warn$1(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
-        if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root);
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+                'contain multiple nodes.', { start: el.start });
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
         }
-        currentParent.children.push(child);
-      }
     }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start: function start(tag, attrs, unary, start$1, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            var element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start$1;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach(function (attr) {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
+                            "spaces, quotes, <, >, / or =.", {
+                            start: attr.start + attr.name.indexOf("["),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        "<" + tag + ">" +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (var i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end: function end(tag, start, end$1) {
+            var element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end$1;
+            }
+            closeElement(element);
+        },
+        chars: function chars(text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                            start: start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            var children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                var res;
+                var child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text: text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text: text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment: function comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                var child = {
+                    type: 3,
+                    text: text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
 }
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
 }
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn$1(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$1(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
+function processRawAttrs(el) {
+    var list = el.attrsList;
+    var len = list.length;
+    if (len) {
+        var attrs = (el.attrs = new Array(len));
+        for (var i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
         }
-      }
     }
-    el.key = exp;
-  }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (var i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    var exp = getBindingAttr(el, 'key');
+    if (exp) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (el.tag === 'template') {
+                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                var iterator = el.iterator2 || el.iterator1;
+                var parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1("Do not use v-for index as key on <transition-group> children, " +
+                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
 }
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
+function processRef(el) {
+    var ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
 }
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$1(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
+function processFor(el) {
+    var exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        var res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+        }
+    }
 }
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
+function parseFor(exp) {
+    var inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        { return; }
+    var res = {};
+    res.for = inMatch[2].trim();
+    var alias = inMatch[1].trim().replace(stripParensRE, '');
+    var iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
 }
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+function processIf(el) {
+    var exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
     }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$1(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
+function processIfConditions(el, parent) {
+    var prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
 }
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn$1(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
-    }
-  }
+function findPrevElement(children) {
+    var i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                    "will be ignored.", children[i]);
+            }
+            children.pop();
+        }
+    }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
 }
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function processOnce(el) {
+    var once$$1 = getAndRemoveAttr(el, 'v-once');
+    if (once$$1 != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn$1(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn$1(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    var slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$1(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
+                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                "can also be used on plain elements in addition to <template> to " +
+                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+                "(v-for takes higher priority). Use a wrapper <template> for the " +
+                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    var slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1("<template v-slot> can only appear at the root level inside " +
+                            "the receiving component", el);
+                    }
+                }
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding$1);
+                    }
+                }
+                // add the component's children to its default slot
+                var slots = el.scopedSlots || (el.scopedSlots = {});
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
         }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn$1(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$1(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
     }
-  }
 }
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$1(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+function getSlotName(binding) {
+    var name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1("v-slot shorthand syntax requires a slot name.", binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: ("\"" + name + "\""), dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn$1(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
+                "and can possibly expand into multiple elements. " +
+                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
+function processComponent(el) {
+    var binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
 }
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn$1(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i],
-                true // dynamic
-              );
+function processAttrs(el) {
+    var list = el.attrsList;
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
             }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn$1(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            { name = 'innerHTML'; }
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, "$event");
+                        if (!isDynamic) {
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                var argMatch = name.match(argRE);
+                var arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                var res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(name + "=\"" + value + "\": " +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
 }
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
+function checkInFor(el) {
+    var parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
     }
-    parent = parent.parent;
-  }
-  return false
+    return false;
 }
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function parseModifiers(name) {
+    var match = name.match(modifierRE);
+    if (match) {
+        var ret = {};
+        match.forEach(function (m) {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-    }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
+function makeAttrsMap(attrs) {
+    var map = {};
+    for (var i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
 }
-
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
 var ieNSBug = /^xmlns:NS\d+/;
 var ieNSPrefix = /^NS\d+:/;
-
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap;
-    if (!map['v-model']) {
-      return
-    }
-
-    var typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
+function guardIESVGBug(attrs) {
+    var res = [];
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
     }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = "(" + (map['v-bind']) + ").type";
+    return res;
+}
+function checkForAliasModel(el, value) {
+    var _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+                "You are binding v-model directly to a v-for iteration alias. " +
+                "This will not be able to modify the v-for source array because " +
+                "writing to the alias is like modifying a function local variable. " +
+                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
     }
+}
 
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      var branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      var branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
+/* @flow */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        var map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        var typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = "(" + (map['v-bind']) + ").type";
+        }
+        if (typeBinding) {
+            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            var branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            var branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            var branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
     }
-  }
 }
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-
 var model = {
-  preTransformNode: preTransformNode
+    preTransformNode: preTransformNode,
 };
 
-var modules = [
-  klass,
-  style,
-  model
-];
-
-/*  */
+var modules = [klass, style, model];
 
+/* @flow */
 var warn$2;
-
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
-
-function model$1 (
-  el,
-  dir,
-  _warn
-) {
-  warn$2 = _warn;
-  var value = dir.value;
-  var modifiers = dir.modifiers;
-  var tag = el.tag;
-  var type = el.attrsMap.type;
-
-  if (process.env.NODE_ENV !== 'production') {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$2(
-        "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-        "File inputs are read only. Use a v-on:change listener instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else if (!config.isReservedTag(tag)) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$2(
-      "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-      "v-model is not supported on this element type. " +
-      'If you are working with contenteditable, it\'s recommended to ' +
-      'wrap a library dedicated for that purpose inside a custom component.',
-      el.rawAttrsMap['v-model']
-    );
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    "Array.isArray(" + value + ")" +
-    "?_i(" + value + "," + valueBinding + ")>-1" + (
-      trueValueBinding === 'true'
-        ? (":(" + value + ")")
-        : (":_q(" + value + "," + trueValueBinding + ")")
-    )
-  );
-  addHandler(el, 'change',
-    "var $$a=" + value + "," +
+function model$1(el, dir, _warn) {
+    warn$2 = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
+        (trueValueBinding === 'true'
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
+    addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
         "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-    'if(Array.isArray($$a)){' +
-      "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-      "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-      "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-    "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-  addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var selectedVal = "Array.prototype.filter" +
-    ".call($event.target.options,function(o){return o.selected})" +
-    ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-    "return " + (number ? '_n(val)' : 'val') + "})";
-
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  var code = "var $$selectedVal = " + selectedVal + ";";
-  code = code + " " + (genAssignmentCode(value, assignment));
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  if (process.env.NODE_ENV !== 'production') {
-    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value$1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$2(
-        binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var number = ref.number;
-  var trim = ref.trim;
-  var needCompositionGuard = !lazy && type !== 'range';
-  var event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  var valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = "$event.target.value.trim()";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = "if($event.target.composing)return;" + code;
-  }
-
-  addProp(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
+        'if(Array.isArray($$a)){' +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        '$$i=_i($$a,$$v);' +
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        "return " + (number ? '_n(val)' : 'val') + "})";
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + (genAssignmentCode(value, assignment));
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value$1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', ("(" + value + ")"));
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-/*  */
-
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-  }
+/* @flow */
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-  }
+/* @flow */
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+    }
 }
 
 var directives = {
-  model: model$1,
-  text: text,
-  html: html
+    model: model$1,
+    text: text,
+    html: html,
 };
 
-/*  */
-
+/* @flow */
 var baseOptions = {
-  expectHTML: true,
-  modules: modules,
-  directives: directives,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys(modules)
+    expectHTML: true,
+    modules: modules,
+    directives: directives,
+    isPreTag: isPreTag,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
+    // @ts-ignore
+    staticKeys: genStaticKeys(modules),
 };
 
-/*  */
-
+/* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
-
 var genStaticKeysCached = cached(genStaticKeys$1);
-
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -3601,1789 +3103,1553 @@ var genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize (root, options) {
-  if (!root) { return }
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      markStatic(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        markStatic(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        markStaticRoots(node.ifConditions[i$1].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
+function optimize(root, options) {
+    if (!root)
+        { return; }
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys$1(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
 }
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (var i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            }
+        }
     }
-    if (node.for) {
-      return true
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
     }
-  }
-  return false
+    return false;
 }
 
-/*  */
-
+/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
 // KeyboardEvent.keyCode aliases
 var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
 var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
 var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
 var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard("$event.target !== $event.currentTarget"),
+    ctrl: genGuard("!$event.ctrlKey"),
+    shift: genGuard("!$event.shiftKey"),
+    alt: genGuard("!$event.altKey"),
+    meta: genGuard("!$event.metaKey"),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2"),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
+function genHandlers(events, isNative) {
+    var prefix = isNative ? 'nativeOn:' : 'on:';
+    var staticHandlers = "";
+    var dynamicHandlers = "";
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
+        }
+        else {
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+        }
+    }
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    if (dynamicHandlers) {
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+    }
+    else {
+        return prefix + staticHandlers;
+    }
 }
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys);
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
-    }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + "($event)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ")($event)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    return ("function($event){" + code + handlerCode + "}")
-  }
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+    }
+    var isMethodPath = simplePathRE.test(handler.value);
+    var isFunctionExpression = fnExpRE.test(handler.value);
+    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+    }
+    else {
+        var code = '';
+        var genModifierCode = '';
+        var keys = [];
+        for (var key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                var modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        var handlerCode = isMethodPath
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            : isFunctionExpression
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                : isFunctionInvocation
+                    ? ("return " + (handler.value))
+                    : handler.value;
+        return ("function($event){" + code + handlerCode + "}");
+    }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    var keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return ("$event.keyCode!==" + keyVal);
+    }
+    var keyCode = keyCodes[key];
+    var keyName = keyNames[key];
+    return ("_k($event.keyCode," +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
+        "$event.key," +
+        "" + (JSON.stringify(keyName)) +
+        ")");
 }
 
-/*  */
-
-function on (el, dir) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+/* @flow */
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn("v-on without argument does not support modifiers.");
+    }
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+/* @flow */
+function bind$1(el, dir) {
+    el.wrapData = function (code) {
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+    };
 }
 
-/*  */
-
+/* @flow */
 var baseDirectives = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
+    on: on,
+    bind: bind$1,
+    cloak: noop,
 };
 
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
+/* @flow */
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
 };
-
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
+function generate(ast, options) {
+    var state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    var code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: ("with(this){return " + code + "}"),
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        var code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            var data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData$2(el, state);
+            }
+            var children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+        }
+        // module transforms
+        for (var i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    var originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.pre = originalPreState;
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData$2 (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
-    }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        var key = '';
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    var condition = conditions.shift();
+    if (condition.exp) {
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+    }
+    else {
+        return ("" + (genTernaryExp(condition.block)));
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    var exp = el.for;
+    var alias = el.alias;
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+            "v-for should have explicit keys. " +
+            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return ((altHelper || '_l') + "((" + exp + ")," +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
+        '})');
+}
+function genData$2(el, state) {
+    var data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    var dirs = genDirectives(el, state);
+    if (dirs)
+        { data += dirs + ','; }
+    // key
+    if (el.key) {
+        data += "key:" + (el.key) + ",";
+    }
+    // ref
+    if (el.ref) {
+        data += "ref:" + (el.ref) + ",";
+    }
+    if (el.refInFor) {
+        data += "refInFor:true,";
+    }
+    // pre
+    if (el.pre) {
+        data += "pre:true,";
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += "tag:\"" + (el.tag) + "\",";
+    }
+    // module data generation functions
+    for (var i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += "attrs:" + (genProps(el.attrs)) + ",";
+    }
+    // DOM props
+    if (el.props) {
+        data += "domProps:" + (genProps(el.props)) + ",";
+    }
+    // event handlers
+    if (el.events) {
+        data += (genHandlers(el.events, false)) + ",";
+    }
+    if (el.nativeEvents) {
+        data += (genHandlers(el.nativeEvents, true)) + ",";
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += "slot:" + (el.slotTarget) + ",";
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+    }
+    // component v-model
+    if (el.model) {
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        var inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += inlineTemplate + ",";
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    var dirs = el.directives;
+    if (!dirs)
+        { return; }
+    var res = 'directives:[';
+    var hasRuntime = false;
+    var i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        var gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
 }
-
-function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
+function genInlineTemplate(el, state) {
+    var ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        var inlineRenderFns = generate(ast, state.options);
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
+    }
 }
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    var needsForceUpdate = el.for ||
+        Object.keys(slots).some(function (key) {
+            var slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    var needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
     }
-    return el.children.some(containsSlotChild)
-  }
-  return false
+    var generatedSlots = Object.keys(slots)
+        .map(function (key) { return genScopedSlot(slots[key], state); })
+        .join(',');
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
 }
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
+function hash(str) {
+    var hash = 5381;
+    var i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
 }
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    var isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, "null");
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+    var fn = "function(" + slotScope + "){" +
+        "return " + (el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)) + "}";
+    // reverse proxy v-slot without scope on this.$slots
+    var reverseProxy = slotScope ? "" : ",proxy:true";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    var children = el.children;
+    if (children.length) {
+        var el$1 = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
+                    ? ",1"
+                    : ",0"
+                : "";
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+        }
+        var normalizationType$1 = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
+function getNormalizationType(children, maybeComponent) {
+    var res = 0;
+    for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            res = 1;
+        }
+    }
+    return res;
 }
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
 }
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
 }
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
+function genText(text) {
+    return ("_v(" + (text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
 }
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
+function genComment(comment) {
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
 }
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? ("," + children) : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function genSlot(el, state) {
+    var slotName = el.slotName || '"default"';
+    var children = genChildren(el, state);
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+        }); }))
+        : null;
+    var bind$$1 = el.attrsMap['v-bind'];
+    if ((attrs || bind$$1) && !children) {
+        res += ",null";
+    }
+    if (attrs) {
+        res += "," + attrs;
+    }
+    if (bind$$1) {
+        res += (attrs ? '' : ',null') + "," + bind$$1;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    var children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+}
+function genProps(props) {
+    var staticProps = "";
+    var dynamicProps = "";
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        var value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += (prop.name) + "," + value + ",";
+        }
+        else {
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+        }
+    }
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    if (dynamicProps) {
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
+/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+var prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+var unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
 var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
+                if (value) {
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                    else {
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (var i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
+function checkEvent(exp, text, warn, range) {
+    var stripped = exp.replace(stripStringRE, '');
+    var keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn("avoid using JavaScript unary operator as property name: " +
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkEvent (exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(("var " + ident + "=_"));
+        }
+        catch (e) {
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        }
+    }
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        new Function(("return " + exp));
+    }
+    catch (e) {
+        var keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn("avoid using JavaScript keyword as property name: " +
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+        }
+        else {
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
+        }
     }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
 }
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
+    }
 }
 
-/*  */
-
+/* @flow */
 var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
+function generateCodeFrame(source, start, end) {
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
+    var lines = source.split(/\r?\n/);
+    var count = 0;
+    var res = [];
+    for (var i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (var j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    { continue; }
+                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                var lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    var pad = start - (count - lineLength) + 1;
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat$1("^", length$1));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
     }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
+    return res.join('\n');
+}
+function repeat$1(str, n) {
+    var result = '';
+    if (n > 0) {
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                { result += str; }
+            n >>>= 1;
+            if (n <= 0)
+                { break; }
+            str += str;
+        }
     }
+    return result;
+}
 
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-        }
-      }
+/* @flow */
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
+    catch (err) {
+        errors.push({ err: err, code: code });
+        return noop;
     }
-
-    return (cache[key] = res)
-  }
 }
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
+function createCompileToFunctionFn(compile) {
+    var cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        var warn$$1 = options.warn || warn;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
             }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
-    }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        var key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        var compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach(function (e) {
+                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                }
+                else {
+                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                }
+            }
+        }
+        // turn code into functions
+        var res = {};
+        var fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn$$1("Failed to generate render function:\n\n" +
+                    fnGenErrors
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+/* @flow */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            var finalOptions = Object.create(baseOptions);
+            var errors = [];
+            var tips = [];
+            var warn = function (msg, range, tip) {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = function (msg, range, tip) {
+                        var data = { msg: msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (var key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            var compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile: compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
+/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  var code = generate(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    var code = generate(ast, options);
+    return {
+        ast: ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
+/* @flow */
 var ref = createCompiler(baseOptions);
 var compile = ref.compile;
 var compileToFunctions = ref.compileToFunctions;
 
-/*  */
-
-var isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-  'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-  'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-  'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-  'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-  'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-  'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-  'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-  'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-  'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-  'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-  'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-  'target,title,usemap,value,width,wrap'
-);
-
+/* @flow */
+var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
 /* istanbul ignore next */
 var isRenderableAttr = function (name) {
-  return (
-    isAttr(name) ||
-    name.indexOf('data-') === 0 ||
-    name.indexOf('aria-') === 0
-  )
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
 };
-
 var propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
 };
-
 var ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
 };
-
-function escape (s) {
-  return s.replace(/[<>"&]/g, escapeChar)
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
 }
-
-function escapeChar (a) {
-  return ESC[a] || a
+function escapeChar(a) {
+    return ESC[a] || a;
 }
 
-/*  */
-
-
-
-
+/* @flow */
 var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
 // let the model AST transform translate v-model into appropriate
 // props bindings
-function applyModelTransform (el, state) {
-  if (el.directives) {
-    for (var i = 0; i < el.directives.length; i++) {
-      var dir = el.directives[i];
-      if (dir.name === 'model') {
-        state.directives.model(el, dir, state.warn);
-        // remove value for textarea as its converted to text
-        if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (var i = 0; i < el.directives.length; i++) {
+            var dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+                }
+                break;
+            }
         }
-        break
-      }
     }
-  }
 }
+function genAttrSegments(attrs) {
+    return attrs.map(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
 
-function genAttrSegments (
-  attrs
-) {
-  return attrs.map(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    return genAttrSegment(name, value);
-  })
+        return genAttrSegment(name, value);
+    });
 }
+function genDOMPropSegments(props, attrs) {
+    var segments = [];
+    props.forEach(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
 
-function genDOMPropSegments (
-  props,
-  attrs
-) {
-  var segments = [];
-  props.forEach(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    name = propsToAttrMap[name] || name.toLowerCase();
-    if (isRenderableAttr(name) &&
-      !(attrs && attrs.some(function (a) { return a.name === name; }))
-    ) {
-      segments.push(genAttrSegment(name, value));
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some(function (a) { return a.name === name; }))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== "\"false\"") {
+            value = "\"true\"";
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? (" " + name + "=\"" + name + "\"")
+                : value === '""'
+                    ? (" " + name)
+                    : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+        };
     }
-  });
-  return segments
 }
-
-function genAttrSegment (name, value) {
-  if (plainStringRE.test(value)) {
-    // force double quote
-    value = value.replace(/^'|'$/g, '"');
-    // force enumerated attr to "true"
-    if (isEnumeratedAttr(name) && value !== "\"false\"") {
-      value = "\"true\"";
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
     }
-    return {
-      type: RAW,
-      value: isBooleanAttr(name)
-        ? (" " + name + "=\"" + name + "\"")
-        : value === '""'
-          ? (" " + name)
-          : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-    }
-  } else {
-    return {
-      type: EXPRESSION,
-      value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+            } ];
     }
-  }
-}
-
-function genClassSegments (
-  staticClass,
-  classBinding
-) {
-  if (staticClass && !classBinding) {
-    return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-    }]
-  }
 }
-
-function genStyleSegments (
-  staticStyle,
-  parsedStaticStyle,
-  styleBinding,
-  vShowExpression
-) {
-  if (staticStyle && !styleBinding && !vShowExpression) {
-    return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-          ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-          : 'null') + ")")
-    }]
-  }
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                    ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                    : 'null') + ")"),
+            } ];
+    }
 }
 
-/*  */
-
+/* @flow */
 // optimizability constants
 var optimizability = {
-  FALSE: 0,    // whole sub tree un-optimizable
-  FULL: 1,     // whole sub tree optimizable
-  SELF: 2,     // self optimizable but has some un-optimizable children
-  CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4   // self un-optimizable with some un-optimizable children
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
 };
-
 var isPlatformReservedTag$1;
-
-function optimize$1 (root, options) {
-  if (!root) { return }
-  isPlatformReservedTag$1 = options.isReservedTag || no;
-  walk(root, true);
-}
-
-function walk (node, isRoot) {
-  if (isUnOptimizableTree(node)) {
-    node.ssrOptimizability = optimizability.FALSE;
-    return
-  }
-  // root node or nodes with custom directives should always be a VNode
-  var selfUnoptimizable = isRoot || hasCustomDirective(node);
-  var check = function (child) {
-    if (child.ssrOptimizability !== optimizability.FULL) {
-      node.ssrOptimizability = selfUnoptimizable
-        ? optimizability.PARTIAL
-        : optimizability.SELF;
-    }
-  };
-  if (selfUnoptimizable) {
-    node.ssrOptimizability = optimizability.CHILDREN;
-  }
-  if (node.type === 1) {
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      walk(child);
-      check(child);
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        walk(block, isRoot);
-        check(block);
-      }
-    }
-    if (node.ssrOptimizability == null ||
-      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-    ) {
-      node.ssrOptimizability = optimizability.FULL;
-    } else {
-      node.children = optimizeSiblings(node);
-    }
-  } else {
-    node.ssrOptimizability = optimizability.FULL;
-  }
-}
-
-function optimizeSiblings (el) {
-  var children = el.children;
-  var optimizedChildren = [];
-
-  var currentOptimizableGroup = [];
-  var pushGroup = function () {
-    if (currentOptimizableGroup.length) {
-      optimizedChildren.push({
-        type: 1,
-        parent: el,
-        tag: 'template',
-        attrsList: [],
-        attrsMap: {},
-        rawAttrsMap: {},
-        children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
-      });
+function optimize$1(root, options) {
+    if (!root)
+        { return; }
+    isPlatformReservedTag$1 = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    var selfUnoptimizable = isRoot || hasCustomDirective(node);
+    var check = function (child) {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
     }
-    currentOptimizableGroup = [];
-  };
-
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.ssrOptimizability === optimizability.FULL) {
-      currentOptimizableGroup.push(c);
-    } else {
-      // wrap fully-optimizable adjacent siblings inside a template tag
-      // so that they can be optimized into a single ssrNode by codegen
-      pushGroup();
-      optimizedChildren.push(c);
-    }
-  }
-  pushGroup();
-  return optimizedChildren
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    var children = el.children;
+    var optimizedChildren = [];
+    var currentOptimizableGroup = [];
+    var pushGroup = function () {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (var i = 0; i < children.length; i++) {
+        var c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
 }
-
-function isUnOptimizableTree (node) {
-  if (node.type === 2 || node.type === 3) { // text or expression
-    return false
-  }
-  return (
-    isBuiltInTag(node.tag) || // built-in (slot, component)
-    !isPlatformReservedTag$1(node.tag) || // custom component
-    !!node.component || // "is" component
-    isSelectWithModel(node) // <select v-model> requires runtime inspection
-  )
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag$1(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
 }
-
 var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-function hasCustomDirective (node) {
-  return (
-    node.type === 1 &&
-    node.directives &&
-    node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-  )
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some(function (d) { return !isBuiltInDir(d.name); }));
 }
-
 // <select v-model> cannot be optimized because it requires a runtime check
 // to determine proper selected option
-function isSelectWithModel (node) {
-  return (
-    node.type === 1 &&
-    node.tag === 'select' &&
-    node.directives != null &&
-    node.directives.some(function (d) { return d.name === 'model'; })
-  )
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some(function (d) { return d.name === 'model'; }));
 }
 
-/*  */
-
-
-
-
+/* @flow */
 // segment types
 var RAW = 0;
 var INTERPOLATION = 1;
 var EXPRESSION = 2;
-
-function generate$1 (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genSSRElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genSSRElement (el, state) {
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genSSRElement)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state, genSSRElement)
-  } else if (el.tag === 'template' && !el.slotTarget) {
-    return el.ssrOptimizability === optimizability.FULL
-      ? genChildrenAsStringNode(el, state)
-      : genSSRChildren(el, state) || 'void 0'
-  }
-
-  switch (el.ssrOptimizability) {
-    case optimizability.FULL:
-      // stringify whole tree
-      return genStringElement(el, state)
-    case optimizability.SELF:
-      // stringify self and check children
-      return genStringElementWithChildren(el, state)
-    case optimizability.CHILDREN:
-      // generate self as VNode and stringify children
-      return genNormalElement(el, state, true)
-    case optimizability.PARTIAL:
-      // generate self as VNode and check children
-      return genNormalElement(el, state, false)
-    default:
-      // bail whole tree
-      return genElement(el, state)
-  }
-}
-
-function genNormalElement (el, state, stringifyChildren) {
-  var data = el.plain ? undefined : genData$2(el, state);
-  var children = stringifyChildren
-    ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-    : genSSRChildren(el, state, true);
-  return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-}
-
-function genSSRChildren (el, state, checkSkip) {
-  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-}
-
-function genSSRNode (el, state) {
-  return el.type === 1
-    ? genSSRElement(el, state)
-    : genText(el)
-}
-
-function genChildrenAsStringNode (el, state) {
-  return el.children.length
-    ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-    : ''
-}
-
-function genStringElement (el, state) {
-  return ("_ssrNode(" + (elementToString(el, state)) + ")")
-}
-
-function genStringElementWithChildren (el, state) {
-  var children = genSSRChildren(el, state, true);
-  return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-}
-
-function elementToString (el, state) {
-  return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-}
-
-function elementToSegments (el, state) {
-  // v-for / v-if
-  if (el.for && !el.forProcessed) {
-    el.forProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genFor(el, state, elementToString, '_ssrList')
-    }]
-  } else if (el.if && !el.ifProcessed) {
-    el.ifProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genIf(el, state, elementToString, '"<!---->"')
-    }]
-  } else if (el.tag === 'template') {
-    return childrenToSegments(el, state)
-  }
-
-  var openSegments = elementToOpenTagSegments(el, state);
-  var childrenSegments = childrenToSegments(el, state);
-  var ref = state.options;
-  var isUnaryTag = ref.isUnaryTag;
-  var close = (isUnaryTag && isUnaryTag(el.tag))
-    ? []
-    : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-  return openSegments.concat(childrenSegments, close)
-}
-
-function elementToOpenTagSegments (el, state) {
-  applyModelTransform(el, state);
-  var binding;
-  var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-  // attrs
-  if (el.attrs) {
-    segments.push.apply(segments, genAttrSegments(el.attrs));
-  }
-  // domProps
-  if (el.props) {
-    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-  }
-  // v-bind="object"
-  if ((binding = el.attrsMap['v-bind'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-  }
-  // v-bind.prop="object"
-  if ((binding = el.attrsMap['v-bind.prop'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-  }
-  // class
-  if (el.staticClass || el.classBinding) {
-    segments.push.apply(
-      segments,
-      genClassSegments(el.staticClass, el.classBinding)
-    );
-  }
-  // style & v-show
-  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-    segments.push.apply(
-      segments,
-      genStyleSegments(
-        el.attrsMap.style,
-        el.staticStyle,
-        el.styleBinding,
-        el.attrsMap['v-show']
-      )
-    );
-  }
-  // _scopedId
-  if (state.options.scopeId) {
-    segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-  }
-  segments.push({ type: RAW, value: ">" });
-  return segments
-}
-
-function childrenToSegments (el, state) {
-  var binding;
-  if ((binding = el.attrsMap['v-html'])) {
-    return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-  }
-  if ((binding = el.attrsMap['v-text'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  return el.children
-    ? nodesToSegments(el.children, state)
-    : []
+function generate$1(ast, options) {
+    var state = new CodegenState(options);
+    var code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: ("with(this){return " + code + "}"),
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function nodesToSegments (
-  children,
-  state
-) {
-  var segments = [];
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.type === 1) {
-      segments.push.apply(segments, elementToSegments(c, state));
-    } else if (c.type === 2) {
-      segments.push({ type: INTERPOLATION, value: c.expression });
-    } else if (c.type === 3) {
-      var text = escape(c.text);
-      if (c.isComment) {
-        text = '<!--' + text + '-->';
-      }
-      segments.push({ type: RAW, value: text });
-    }
-  }
-  return segments
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    var data = el.plain ? undefined : genData$2(el, state);
+    var children = stringifyChildren
+        ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+        : genSSRChildren(el, state, true);
+    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+        : '';
+}
+function genStringElement(el, state) {
+    return ("_ssrNode(" + (elementToString(el, state)) + ")");
+}
+function genStringElementWithChildren(el, state) {
+    var children = genSSRChildren(el, state, true);
+    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+}
+function elementToString(el, state) {
+    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            } ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            } ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    var openSegments = elementToOpenTagSegments(el, state);
+    var childrenSegments = childrenToSegments(el, state);
+    var ref = state.options;
+    var isUnaryTag = ref.isUnaryTag;
+    var close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    var binding;
+    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+    }
+    segments.push({ type: RAW, value: ">" });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    var binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    var segments = [];
+    for (var i = 0; i < children.length; i++) {
+        var c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            var text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
 }
-
-function flattenSegments (segments) {
-  var mergedSegments = [];
-  var textBuffer = '';
-
-  var pushBuffer = function () {
-    if (textBuffer) {
-      mergedSegments.push(JSON.stringify(textBuffer));
-      textBuffer = '';
+function flattenSegments(segments) {
+    var mergedSegments = [];
+    var textBuffer = '';
+    var pushBuffer = function () {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (var i = 0; i < segments.length; i++) {
+        var s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(("(" + (s.value) + ")"));
+        }
     }
-  };
-
-  for (var i = 0; i < segments.length; i++) {
-    var s = segments[i];
-    if (s.type === RAW) {
-      textBuffer += s.value;
-    } else if (s.type === INTERPOLATION) {
-      pushBuffer();
-      mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-    } else if (s.type === EXPRESSION) {
-      pushBuffer();
-      mergedSegments.push(("(" + (s.value) + ")"));
-    }
-  }
-  pushBuffer();
-
-  return mergedSegments.join('+')
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-/*  */
-
-var createCompiler$1 = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  optimize$1(ast, options);
-  var code = generate$1(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+/* @flow */
+var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
+    optimize$1(ast, options);
+    var code = generate$1(ast, options);
+    return {
+        ast: ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
+/* @flow */
 var ref$1 = createCompiler$1(baseOptions);
 var compile$1 = ref$1.compile;
 var compileToFunctions$1 = ref$1.compileToFunctions;
 
-/*  */
+/* @flow */
 
 exports.parseComponent = parseComponent;
 exports.compile = compile;
diff --git a/scripts/config.js b/scripts/config.js
index 1294a6534fa..0e47accdc2e 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -4,7 +4,8 @@ const alias = require('rollup-plugin-alias')
 const cjs = require('rollup-plugin-commonjs')
 const replace = require('rollup-plugin-replace')
 const node = require('rollup-plugin-node-resolve')
-const flow = require('rollup-plugin-flow-no-whitespace')
+const ts = require('rollup-plugin-typescript2')
+
 const version = process.env.VERSION || require('../package.json').version
 const weexVersion = process.env.WEEX_VERSION || require('../packages/weex-vue-framework/package.json').version
 const featureFlags = require('./feature-flags')
@@ -38,14 +39,14 @@ const resolve = p => {
 const builds = {
   // Runtime only (CommonJS). Used by bundlers e.g. Webpack & Browserify
   'web-runtime-cjs-dev': {
-    entry: resolve('web/entry-runtime.js'),
+    entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.common.dev.js'),
     format: 'cjs',
     env: 'development',
     banner
   },
   'web-runtime-cjs-prod': {
-    entry: resolve('web/entry-runtime.js'),
+    entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.common.prod.js'),
     format: 'cjs',
     env: 'production',
@@ -53,7 +54,7 @@ const builds = {
   },
   // Runtime+compiler CommonJS build (CommonJS)
   'web-full-cjs-dev': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.common.dev.js'),
     format: 'cjs',
     env: 'development',
@@ -61,7 +62,7 @@ const builds = {
     banner
   },
   'web-full-cjs-prod': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.common.prod.js'),
     format: 'cjs',
     env: 'production',
@@ -70,14 +71,14 @@ const builds = {
   },
   // Runtime only ES modules build (for bundlers)
   'web-runtime-esm': {
-    entry: resolve('web/entry-runtime.js'),
+    entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.esm.js'),
     format: 'es',
     banner
   },
   // Runtime+compiler ES modules build (for bundlers)
   'web-full-esm': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.esm.js'),
     format: 'es',
     alias: { he: './entity-decoder' },
@@ -85,7 +86,7 @@ const builds = {
   },
   // Runtime+compiler ES modules build (for direct import in browser)
   'web-full-esm-browser-dev': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.esm.browser.js'),
     format: 'es',
     transpile: false,
@@ -95,7 +96,7 @@ const builds = {
   },
   // Runtime+compiler ES modules build (for direct import in browser)
   'web-full-esm-browser-prod': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.esm.browser.min.js'),
     format: 'es',
     transpile: false,
@@ -105,7 +106,7 @@ const builds = {
   },
   // runtime-only build (Browser)
   'web-runtime-dev': {
-    entry: resolve('web/entry-runtime.js'),
+    entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.js'),
     format: 'umd',
     env: 'development',
@@ -113,7 +114,7 @@ const builds = {
   },
   // runtime-only production build (Browser)
   'web-runtime-prod': {
-    entry: resolve('web/entry-runtime.js'),
+    entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.min.js'),
     format: 'umd',
     env: 'production',
@@ -121,7 +122,7 @@ const builds = {
   },
   // Runtime+compiler development build (Browser)
   'web-full-dev': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.js'),
     format: 'umd',
     env: 'development',
@@ -130,7 +131,7 @@ const builds = {
   },
   // Runtime+compiler production build  (Browser)
   'web-full-prod': {
-    entry: resolve('web/entry-runtime-with-compiler.js'),
+    entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.min.js'),
     format: 'umd',
     env: 'production',
@@ -139,14 +140,14 @@ const builds = {
   },
   // Web compiler (CommonJS).
   'web-compiler': {
-    entry: resolve('web/entry-compiler.js'),
+    entry: resolve('web/entry-compiler.ts'),
     dest: resolve('packages/vue-template-compiler/build.js'),
     format: 'cjs',
     external: Object.keys(require('../packages/vue-template-compiler/package.json').dependencies)
   },
   // Web compiler (UMD for in-browser use).
   'web-compiler-browser': {
-    entry: resolve('web/entry-compiler.js'),
+    entry: resolve('web/entry-compiler.ts'),
     dest: resolve('packages/vue-template-compiler/browser.js'),
     format: 'umd',
     env: 'development',
@@ -155,21 +156,21 @@ const builds = {
   },
   // Web server renderer (CommonJS).
   'web-server-renderer-dev': {
-    entry: resolve('web/entry-server-renderer.js'),
+    entry: resolve('web/entry-server-renderer.ts'),
     dest: resolve('packages/vue-server-renderer/build.dev.js'),
     format: 'cjs',
     env: 'development',
     external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
   },
   'web-server-renderer-prod': {
-    entry: resolve('web/entry-server-renderer.js'),
+    entry: resolve('web/entry-server-renderer.ts'),
     dest: resolve('packages/vue-server-renderer/build.prod.js'),
     format: 'cjs',
     env: 'production',
     external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
   },
   'web-server-renderer-basic': {
-    entry: resolve('web/entry-server-basic-renderer.js'),
+    entry: resolve('web/entry-server-basic-renderer.ts'),
     dest: resolve('packages/vue-server-renderer/basic.js'),
     format: 'umd',
     env: 'development',
@@ -177,13 +178,13 @@ const builds = {
     plugins: [node(), cjs()]
   },
   'web-server-renderer-webpack-server-plugin': {
-    entry: resolve('server/webpack-plugin/server.js'),
+    entry: resolve('server/webpack-plugin/server.ts'),
     dest: resolve('packages/vue-server-renderer/server-plugin.js'),
     format: 'cjs',
     external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
   },
   'web-server-renderer-webpack-client-plugin': {
-    entry: resolve('server/webpack-plugin/client.js'),
+    entry: resolve('server/webpack-plugin/client.ts'),
     dest: resolve('packages/vue-server-renderer/client-plugin.js'),
     format: 'cjs',
     external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
@@ -191,7 +192,7 @@ const builds = {
   // Weex runtime factory
   'weex-factory': {
     weex: true,
-    entry: resolve('weex/entry-runtime-factory.js'),
+    entry: resolve('weex/entry-runtime-factory.ts'),
     dest: resolve('packages/weex-vue-framework/factory.js'),
     format: 'cjs',
     plugins: [weexFactoryPlugin]
@@ -199,14 +200,14 @@ const builds = {
   // Weex runtime framework (CommonJS).
   'weex-framework': {
     weex: true,
-    entry: resolve('weex/entry-framework.js'),
+    entry: resolve('weex/entry-framework.ts'),
     dest: resolve('packages/weex-vue-framework/index.js'),
     format: 'cjs'
   },
   // Weex compiler (CommonJS). Used by Weex's Webpack loader.
   'weex-compiler': {
     weex: true,
-    entry: resolve('weex/entry-compiler.js'),
+    entry: resolve('weex/entry-compiler.ts'),
     dest: resolve('packages/weex-template-compiler/build.js'),
     format: 'cjs',
     external: Object.keys(require('../packages/weex-template-compiler/package.json').dependencies)
@@ -215,11 +216,25 @@ const builds = {
 
 function genConfig (name) {
   const opts = builds[name]
+
+  // console.log('__dir', __dirname)
   const config = {
     input: opts.entry,
     external: opts.external,
     plugins: [
-      flow(),
+      // flow(),
+      ts({
+        tsconfig: path.resolve(__dirname, '../', 'tsconfig.json'),
+        cacheRoot: path.resolve(__dirname, '../','node_modules/.rts2_cache'),
+        tsconfigOverride: {
+          // compilerOptions: {
+          //   sourceMap: output.sourcemap,
+          //   declaration: shouldEmitDeclarations,
+          //   declarationMap: shouldEmitDeclarations
+          // },
+          exclude: ['tests', 'test-dts']
+        }
+      }),
       alias(Object.assign({}, aliases, opts.alias))
     ].concat(opts.plugins || []),
     output: {
diff --git a/src/compiler/codegen/events.ts b/src/compiler/codegen/events.ts
index 8e4a747d3fc..47f66a59823 100644
--- a/src/compiler/codegen/events.ts
+++ b/src/compiler/codegen/events.ts
@@ -1,7 +1,5 @@
 /* @flow */
 
-import { __WEEX__ } from 'typescript/weex'
-
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
 const fnInvokeRE = /\([^)]*?\);*$/
 const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index 6bc381c0f39..7a54f043b4f 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -1,6 +1,6 @@
 /* @flow */
 
-import he from 'he'
+import * as he from 'he'
 import { parseHTML } from './html-parser'
 import { parseText } from './text-parser'
 import { parseFilters } from './filter-parser'
diff --git a/src/core/config.ts b/src/core/config.ts
index c3924c4107e..f615dac15e8 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -18,12 +18,12 @@ export type Config = {
   keyCodes: { [key: string]: number | Array<number> }
 
   // platform
-  isReservedTag: (x?: string) => boolean
-  isReservedAttr: (x?: string) => boolean
+  isReservedTag: (x: string) => boolean | undefined
+  isReservedAttr: (x: string) => true | undefined
   parsePlatformTagName: (x: string) => string
-  isUnknownElement: (x?: string) => boolean
-  getTagNamespace: (x?: string) => string | void
-  mustUseProp: (tag: string, type?: string, name?: string) => boolean
+  isUnknownElement: (x: string) => boolean
+  getTagNamespace: (x: string) => string | undefined
+  mustUseProp: (tag: string, type?: string | null, name?: string) => boolean
 
   // private
   async: boolean
diff --git a/src/core/index.ts b/src/core/index.ts
index ac6e38e914b..b50240e4a81 100644
--- a/src/core/index.ts
+++ b/src/core/index.ts
@@ -1,4 +1,3 @@
-//@ts-nocheck
 import Vue from './instance/index'
 import { initGlobalAPI } from './global-api/index'
 import { isServerRendering } from 'core/util/env'
diff --git a/src/core/instance/index.ts b/src/core/instance/index.ts
index 1d15d1cfb39..1b8e8fa8c53 100644
--- a/src/core/instance/index.ts
+++ b/src/core/instance/index.ts
@@ -1,10 +1,11 @@
-//@ts-nocheck
+
 import { initMixin } from './init'
 import { stateMixin } from './state'
 import { renderMixin } from './render'
 import { eventsMixin } from './events'
 import { lifecycleMixin } from './lifecycle'
 import { warn } from '../util/index'
+import { GlobalAPI } from 'typescript/global-api'
 
 function Vue(options) {
   if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
@@ -13,10 +14,15 @@ function Vue(options) {
   this._init(options)
 }
 
+//@ts-ignore
 initMixin(Vue)
+//@ts-ignore
 stateMixin(Vue)
+//@ts-ignore
 eventsMixin(Vue)
+//@ts-ignore
 lifecycleMixin(Vue)
+//@ts-ignore
 renderMixin(Vue)
 
-export default Vue
+export default Vue as unknown as GlobalAPI
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index ea4d84c9b8e..486c8e3c33e 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -120,15 +120,13 @@ export function lifecycleMixin(Vue: Component) {
     }
     // remove reference from data ob
     // frozen object may not have observer.
-    //@ts-expect-error internal usage
     if (vm._data.__ob__) {
-      //@ts-expect-error internal usage
       vm._data.__ob__.vmCount--
     }
     // call the last hook...
     vm._isDestroyed = true
     // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null)
+    vm.__patch__(vm._vnode!, null)
     // fire destroyed hook
     callHook(vm, 'destroyed')
     // turn off all instance listeners.
@@ -147,7 +145,7 @@ export function lifecycleMixin(Vue: Component) {
 
 export function mountComponent(
   vm: Component,
-  el: Element | null,
+  el: Element | null | undefined,
   hydrating?: boolean
 ): Component {
   vm.$el = el
diff --git a/src/core/instance/proxy.ts b/src/core/instance/proxy.ts
index f6bd109ff93..33bc30a0312 100644
--- a/src/core/instance/proxy.ts
+++ b/src/core/instance/proxy.ts
@@ -41,7 +41,7 @@ if (process.env.NODE_ENV !== 'production') {
       'stop,prevent,self,ctrl,shift,alt,meta,exact'
     )
     config.keyCodes = new Proxy(config.keyCodes, {
-      set(target, key, value) {
+      set(target, key: string, value) {
         if (isBuiltInModifier(key)) {
           warn(
             `Avoid overwriting built-in modifier in config.keyCodes: .${key}`
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 5166a9d9595..0416ebb62f5 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -15,22 +15,25 @@ import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
 import VNode, { createEmptyVNode } from '../vdom/vnode'
 
 import { isUpdatingChildComponent } from './lifecycle'
+import { Component } from 'typescript/component'
 
 export function initRender(vm: Component) {
   vm._vnode = null // the root of the child tree
   vm._staticTrees = null // v-once cached trees
   const options = vm.$options
-  const parentVnode = (vm.$vnode = options._parentVnode) // the placeholder node in parent tree
-  const renderContext = parentVnode && parentVnode.context
+  const parentVnode = (vm.$vnode = options._parentVnode!) // the placeholder node in parent tree
+  const renderContext  = parentVnode && parentVnode.context as Component
   vm.$slots = resolveSlots(options._renderChildren, renderContext)
   vm.$scopedSlots = emptyObject
   // bind the createElement fn to this instance
   // so that we get proper render context inside it.
   // args order: tag, data, children, normalizationType, alwaysNormalize
   // internal version is used by render functions compiled from templates
+  // @ts-expect-error
   vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false)
   // normalization is always applied for the public version, used in
   // user-written render functions.
+  // @ts-expect-error
   vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true)
 
   // $attrs & $listeners are exposed for easier HOC creation.
@@ -82,7 +85,7 @@ export function setCurrentRenderingInstance(vm: Component) {
   currentRenderingInstance = vm
 }
 
-export function renderMixin(Vue: Class<Component>) {
+export function renderMixin(Vue: Component) {
   // install runtime convenience helpers
   installRenderHelpers(Vue.prototype)
 
@@ -96,7 +99,7 @@ export function renderMixin(Vue: Class<Component>) {
 
     if (_parentVnode) {
       vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
+        _parentVnode.data!.scopedSlots,
         vm.$slots,
         vm.$scopedSlots
       )
@@ -104,7 +107,7 @@ export function renderMixin(Vue: Class<Component>) {
 
     // set parent vnode. this allows render functions to have access
     // to the data on the placeholder node.
-    vm.$vnode = _parentVnode
+    vm.$vnode = _parentVnode!
     // render self
     let vnode
     try {
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 65398900a72..5a9b35b655d 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -27,6 +27,7 @@ import {
   isServerRendering,
   isReservedAttribute,
 } from '../util/index'
+import { Component } from 'typescript/component'
 
 const sharedPropertyDefinition = {
   enumerable: true,
@@ -66,7 +67,7 @@ function initProps(vm: Component, propsOptions: Object) {
   const props = (vm._props = {})
   // cache prop keys so that future props updates can iterate using Array
   // instead of dynamic object key enumeration.
-  const keys = (vm.$options._propKeys = [])
+  const keys: string[] = (vm.$options._propKeys = [])
   const isRoot = !vm.$parent
   // root instance props should be converted
   if (!isRoot) {
@@ -112,7 +113,7 @@ function initProps(vm: Component, propsOptions: Object) {
 }
 
 function initData(vm: Component) {
-  let data = vm.$options.data
+  let data: any = vm.$options.data
   data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {}
   if (!isPlainObject(data)) {
     data = {}
@@ -206,7 +207,7 @@ function initComputed(vm: Component, computed: Object) {
 export function defineComputed(
   target: any,
   key: string,
-  userDef: Object | Function
+  userDef: Record<string, any> | Function
 ) {
   const shouldCache = !isServerRendering()
   if (typeof userDef === 'function') {
@@ -313,15 +314,15 @@ function createWatcher(
   return vm.$watch(expOrFn, handler, options)
 }
 
-export function stateMixin(Vue: Class<Component>) {
+export function stateMixin(Vue: Component) {
   // flow somehow has problems with directly declared definition object
   // when using Object.defineProperty, so we have to procedurally build up
   // the object here.
-  const dataDef = {}
+  const dataDef:any = {}
   dataDef.get = function () {
     return this._data
   }
-  const propsDef = {}
+  const propsDef: any = {}
   propsDef.get = function () {
     return this._props
   }
@@ -346,7 +347,7 @@ export function stateMixin(Vue: Class<Component>) {
   Vue.prototype.$watch = function (
     expOrFn: string | Function,
     cb: any,
-    options?: Object
+    options?: Record<string,any>
   ): Function {
     const vm: Component = this
     if (isPlainObject(cb)) {
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index d97e6644c9e..f02f7d45762 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -134,7 +134,7 @@ export function defineReactive(
   obj: object,
   key: string,
   val?: any,
-  customSetter?: Function,
+  customSetter?: Function | null,
   shallow?: boolean
 ) {
   const dep = new Dep()
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index 17757c216cc..645c87224ec 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -11,7 +11,6 @@ import {
   isPlainObject,
 } from 'shared/util'
 import { Component } from 'typescript/component'
-import { __WEEX__ } from 'typescript/weex'
 
 type PropOptions = {
   type: Function | Array<Function> | null
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 6ef3a07df22..336423abcab 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -31,7 +31,6 @@ import {
   VNodeWithData,
 } from 'typescript/vnode'
 import { Component } from 'typescript/component'
-import { __WEEX__ } from 'typescript/weex'
 import { InternalComponentOptions } from 'typescript/options'
 
 // inline hooks to be invoked on component VNodes during patch
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index d78c685ac57..493dd0c3aa6 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -18,7 +18,6 @@ import {
 import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
 import { Component } from 'typescript/component'
 import { VNodeData } from 'typescript/vnode'
-import { __WEEX__ } from 'typescript/weex'
 
 const SIMPLE_NORMALIZE = 1
 const ALWAYS_NORMALIZE = 2
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index bb552ed3d3c..7ed667ce817 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -161,9 +161,7 @@ function cloneAndMarkFunctionalResult(
   clone.fnContext = contextVm
   clone.fnOptions = options
   if (process.env.NODE_ENV !== 'production') {
-    ;(clone.devtoolsMeta =
-      // @ts-expect-error
-      clone.devtoolsMeta || {}).renderContext = renderContext
+    ;(clone.devtoolsMeta = clone.devtoolsMeta || {} as any).renderContext = renderContext
   }
   if (data.slot) {
     ;(clone.data || (clone.data = {})).slot = data.slot
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index 5b755f3652f..eb513a7e058 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -1,7 +1,6 @@
 import { warn, invokeWithErrorHandling } from 'core/util/index'
 import { cached, isUndef, isTrue, isPlainObject } from 'shared/util'
 import { Component } from 'typescript/component'
-import { __WEEX__ } from 'typescript/weex'
 
 const normalizeEvent = cached((name: string): {
   name: string
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index 6064153c783..cb9c7eb9127 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -27,7 +27,6 @@ import {
   isRegExp,
   isPrimitive,
 } from '../util/index'
-import { __WEEX__ } from 'typescript/weex'
 
 export const emptyNode = new VNode('', {}, [])
 
diff --git a/src/global.d.ts b/src/global.d.ts
new file mode 100644
index 00000000000..b148c97c0bd
--- /dev/null
+++ b/src/global.d.ts
@@ -0,0 +1,22 @@
+declare const __WEEX__: boolean;
+declare type WeexEnvironment = {
+  platform: string; // could be "Web", "iOS", "Android"
+  weexVersion: string; // the version of WeexSDK
+
+  osName: string; // could be "iOS", "Android" or others
+  osVersion: string;
+  appName: string; // mobile app name or browser name
+  appVersion: string;
+
+  // information about current running device
+  deviceModel: string; // phone device model
+  deviceWidth: number;
+  deviceHeight: number;
+  scale: number;
+
+  // only available on the web
+  userAgent?: string;
+  dpr?: number;
+  rem?: number;
+};
+declare var WXEnvironment: WeexEnvironment;
diff --git a/src/platforms/web/compiler/modules/model.ts b/src/platforms/web/compiler/modules/model.ts
index 15ba74cc857..b1b17994747 100644
--- a/src/platforms/web/compiler/modules/model.ts
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -66,7 +66,7 @@ function preTransformNode(el: ASTElement, options: CompilerOptions) {
       addRawAttr(branch2, ':type', typeBinding)
       processElement(branch2, options)
       addIfCondition(branch0, {
-        exp: ifCondition,
+        exp: ifCondition!,
         block: branch2,
       })
 
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index 0b40274d697..c7d233c6183 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -106,7 +106,6 @@ function getOuterHTML(el: Element): string {
   }
 }
 
-// @ts-expect-error
 Vue.compile = compileToFunctions
 
 export default Vue
diff --git a/src/platforms/web/runtime/index.ts b/src/platforms/web/runtime/index.ts
index 06e74cf1b55..32468341473 100644
--- a/src/platforms/web/runtime/index.ts
+++ b/src/platforms/web/runtime/index.ts
@@ -1,5 +1,3 @@
-//@ts-nocheck
-
 import Vue from 'core/index'
 import config from 'core/config'
 import { extend, noop } from 'shared/util'
@@ -18,6 +16,7 @@ import {
 import { patch } from './patch'
 import platformDirectives from './directives/index'
 import platformComponents from './components/index'
+import { Component } from 'typescript/component'
 
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp
@@ -53,6 +52,7 @@ if (inBrowser) {
         process.env.NODE_ENV !== 'production' &&
         process.env.NODE_ENV !== 'test'
       ) {
+        // @ts-expect-error
         console[console.info ? 'info' : 'log'](
           'Download the Vue Devtools extension for a better development experience:\n' +
             'https://github.com/vuejs/vue-devtools'
@@ -65,6 +65,7 @@ if (inBrowser) {
       config.productionTip !== false &&
       typeof console !== 'undefined'
     ) {
+      // @ts-expect-error
       console[console.info ? 'info' : 'log'](
         `You are running Vue in development mode.\n` +
           `Make sure to turn on production mode when deploying for production.\n` +
diff --git a/src/platforms/web/runtime/modules/style.ts b/src/platforms/web/runtime/modules/style.ts
index 1e70ac852a1..8424fe19da3 100644
--- a/src/platforms/web/runtime/modules/style.ts
+++ b/src/platforms/web/runtime/modules/style.ts
@@ -82,7 +82,6 @@ function updateStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   // store normalized style under a different key for next diff
   // make sure to clone it if it's reactive, since the user likely wants
   // to mutate it.
-  //@ts-expect-error
   vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style
 
   const newStyle = getStyle(vnode, true)
diff --git a/src/platforms/web/server/directives/model.ts b/src/platforms/web/server/directives/model.ts
index 705e502f7a4..e5144b9b209 100644
--- a/src/platforms/web/server/directives/model.ts
+++ b/src/platforms/web/server/directives/model.ts
@@ -1,6 +1,7 @@
 /* @flow */
 
 import { looseEqual, looseIndexOf } from 'shared/util'
+import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
diff --git a/src/platforms/web/server/modules/attrs.ts b/src/platforms/web/server/modules/attrs.ts
index ead95fe63a4..cf0082ef7fc 100644
--- a/src/platforms/web/server/modules/attrs.ts
+++ b/src/platforms/web/server/modules/attrs.ts
@@ -12,6 +12,7 @@ import {
 } from 'web/util/attrs'
 
 import { isSSRUnsafeAttr } from 'web/server/util'
+import { VNodeWithData } from 'typescript/vnode'
 
 export default function renderAttrs(node: VNodeWithData): string {
   let attrs = node.data.attrs
diff --git a/src/platforms/web/server/modules/dom-props.ts b/src/platforms/web/server/modules/dom-props.ts
index f165245cfaf..bf481861b3d 100644
--- a/src/platforms/web/server/modules/dom-props.ts
+++ b/src/platforms/web/server/modules/dom-props.ts
@@ -4,6 +4,7 @@ import VNode from 'core/vdom/vnode'
 import { renderAttr } from './attrs'
 import { isDef, isUndef, extend, toString } from 'shared/util'
 import { propsToAttrMap, isRenderableAttr } from '../util'
+import { VNodeWithData } from 'typescript/vnode'
 
 export default function renderDOMProps(node: VNodeWithData): string {
   let props = node.data.domProps
diff --git a/src/platforms/web/util/attrs.ts b/src/platforms/web/util/attrs.ts
index cfde37699f1..49aa22abdac 100644
--- a/src/platforms/web/util/attrs.ts
+++ b/src/platforms/web/util/attrs.ts
@@ -10,8 +10,8 @@ export const isReservedAttr = makeMap('style,class')
 const acceptValue = makeMap('input,textarea,option,select,progress')
 export const mustUseProp = (
   tag: string,
-  type: string | null,
-  attr: string
+  type?: string | null,
+  attr?: string
 ): boolean => {
   return (
     (attr === 'value' && acceptValue(tag) && type !== 'button') ||
diff --git a/tsconfig.json b/tsconfig.json
index 3c4378bb070..1f4d22f282d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -17,7 +17,7 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": ["jest", "puppeteer", "node"],
+    "types": ["node"],
     "rootDir": ".",
     "paths": {
       "compiler/*": ["src/compiler/*"],
@@ -32,11 +32,14 @@
     }
   },
   "include": [
-    "typescript",
     "src",
     // "packages/runtime-dom/types/jsx.d.ts",
     // "packages/*/__tests__",
-    "test-dts"
+    "test-dts",
+
+
+    "typescript",
+    // "src/global.d.ts"
   ],
 
   "exclude": ["flow"]
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index f1fb9955c45..db14beeda20 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -7,27 +7,27 @@ import { ScopedSlotsData, VNodeChildren, VNodeData } from "./vnode";
 declare class Component {
   // constructor information
   static cid: number;
-  static options: Object;
+  static options: Record<string, any>;
   // extend
-  static extend: (options: Object) => Function;
-  static superOptions: Object;
-  static extendOptions: Object;
-  static sealedOptions: Object;
+  static extend: (options: Record<string, any>) => Function;
+  static superOptions: Record<string, any>;
+  static extendOptions: Record<string, any>;
+  static sealedOptions: Record<string, any>;
   static super: Component;
   // assets
   static directive: (
     id: string,
-    def?: Function | Object
-  ) => Function | Object | void;
-  static component: (id: string, def?: Component | Object) => Component;
+    def?: Function | Record<string, any>
+  ) => Function | Record<string, any> | void;
+  static component: (id: string, def?: Component | Record<string, any>) => Component;
   static filter: (id: string, def?: Function) => Function | void;
   // functional context constructor
   static FunctionalRenderContext: Function;
 
   // public properties
   $el: any; // so that we can attach __vue__ to it
-  $data: Object;
-  $props: Object;
+  $data: Record<string, any>;
+  $props: Record<string, any>;
   $options: ComponentOptions;
   $parent: Component | undefined;
   $root: Component;
@@ -46,12 +46,12 @@ declare class Component {
   $mount: (el?: Element | string, hydrating?: boolean) => Component;
   $forceUpdate: () => void;
   $destroy: () => void;
-  $set: <T>(target: Object | Array<T>, key: string | number, val: T) => T;
-  $delete: <T>(target: Object | Array<T>, key: string | number) => void;
+  $set: <T>(target: Record<string, any> | Array<T>, key: string | number, val: T) => T;
+  $delete: <T>(target: Record<string, any> | Array<T>, key: string | number) => void;
   $watch: (
     expOrFn: string | Function,
     cb: Function,
-    options?: Object
+    options?: Record<string, any>
   ) => Function;
   $on: (event: string | Array<string>, fn: Function) => Component;
   $once: (event: string, fn: Function) => Component;
@@ -60,7 +60,7 @@ declare class Component {
   $nextTick: (fn: Function) => void | Promise<any>;
   $createElement: (
     tag?: string | Component,
-    data?: Object,
+    data?: Record<string, any>,
     children?: VNodeChildren
   ) => VNode;
 
@@ -74,18 +74,18 @@ declare class Component {
   _watcher: Watcher;
   _watchers: Array<Watcher>;
   _computedWatchers: { [key: string]: Watcher };
-  _data: Object;
-  _props: Object;
+  _data: Record<string, any>;
+  _props: Record<string, any>;
   _events: Record<string, any>;
   _inactive: boolean | null;
   _directInactive: boolean;
   _isMounted: boolean;
   _isDestroyed: boolean;
   _isBeingDestroyed: boolean;
-  _vnode?: VNode; // self root node
-  _staticTrees?: Array<VNode>; // v-once cached trees
+  _vnode?: VNode | null; // self root node
+  _staticTrees?: Array<VNode> | null; // v-once cached trees
   _hasHookEvent: boolean;
-  _provided?: Object;
+  _provided?: Record<string, any>;
   // _virtualComponents?: { [key: string]: Component };
 
   // private methods
@@ -145,7 +145,7 @@ declare class Component {
   _t: (
     name: string,
     fallback?: Array<VNode>,
-    props?: Object
+    props?: Record<string, any>
   ) => Array<VNode> | null;
   // apply v-bind object
   _b: (
@@ -167,7 +167,7 @@ declare class Component {
   // resolve scoped slots
   _u: (
     scopedSlots: ScopedSlotsData,
-    res?: Object
+    res?: Record<string, any>
   ) => { [key: string]: Function };
 
   // SSR specific
diff --git a/typescript/global-api.d.ts b/typescript/global-api.d.ts
index 1a34774f155..d484c8a99c0 100644
--- a/typescript/global-api.d.ts
+++ b/typescript/global-api.d.ts
@@ -2,6 +2,7 @@ import { Config } from "../src/core/config";
 import { Component } from "./component";
 
 declare interface GlobalAPI {
+  (options: any): void;
   cid: number;
   options: Record<string, any>;
   config: Config;
diff --git a/typescript/weex.d.ts b/typescript/weex.d.ts
index ea138db3587..0427fadc589 100644
--- a/typescript/weex.d.ts
+++ b/typescript/weex.d.ts
@@ -2,7 +2,7 @@ import { Component } from "./component";
 import { GlobalAPI } from "./global-api";
 
 // global flag to be compiled away
-declare var __WEEX__: boolean;
+declare const __WEEX__: boolean;
 
 // global object in Weex
 declare var WXEnvironment: WeexEnvironment;
diff --git a/yarn.lock b/yarn.lock
index f03c1e11303..01f06e9145f 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -658,6 +658,14 @@
     log-update "^2.3.0"
     strip-ansi "^3.0.1"
 
+"@rollup/pluginutils@^4.1.0":
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.1.0.tgz#0dcc61c780e39257554feb7f77207dceca13c838"
+  integrity sha512-TrBhfJkFxA+ER+ew2U2/fHbebhLT/l/2pRk0hfj9KusXUuRXd2v0R58AfaZK9VXDQ4TogOSEmICVrQAA3zFnHQ==
+  dependencies:
+    estree-walker "^2.0.1"
+    picomatch "^2.2.2"
+
 "@samverschueren/stream-to-observable@^0.3.0":
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz#ecdf48d532c58ea477acfcab80348424f8d0662f"
@@ -3048,6 +3056,11 @@ estree-walker@^0.5.2:
   resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.5.2.tgz#d3850be7529c9580d815600b53126515e146dd39"
   integrity sha512-XpCnW/AE10ws/kDAs37cngSkvgIR8aN3G0MS85m7dUpuK2EREo9VJ00uvw6Dg/hXEpfsE1I1TvJOJr+Z+TL+ig==
 
+estree-walker@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
+  integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
+
 esutils@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b"
@@ -3366,6 +3379,15 @@ find-cache-dir@^2.0.0:
     make-dir "^1.0.0"
     pkg-dir "^3.0.0"
 
+find-cache-dir@^3.3.1:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.1.tgz#89b33fad4a4670daa94f855f7fbe31d6d84fe880"
+  integrity sha512-t2GDMt3oGC/v+BMwzmllWDuJF/xcDtE5j/fCGbqDD7OLuJkj0cfh1YSA5VKPvwMeLFLNDBkwOKZ2X85jGLVftQ==
+  dependencies:
+    commondir "^1.0.1"
+    make-dir "^3.0.2"
+    pkg-dir "^4.1.0"
+
 find-node-modules@1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/find-node-modules/-/find-node-modules-1.0.4.tgz#b6deb3cccb699c87037677bcede2c5f5862b2550"
@@ -3406,6 +3428,14 @@ find-up@^3.0.0:
   dependencies:
     locate-path "^3.0.0"
 
+find-up@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
+  integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
+  dependencies:
+    locate-path "^5.0.0"
+    path-exists "^4.0.0"
+
 findup-sync@0.4.2:
   version "0.4.2"
   resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-0.4.2.tgz#a8117d0f73124f5a4546839579fe52d7129fb5e5"
@@ -3510,6 +3540,15 @@ fs-exists-sync@^0.1.0:
   resolved "https://registry.yarnpkg.com/fs-exists-sync/-/fs-exists-sync-0.1.0.tgz#982d6893af918e72d08dec9e8673ff2b5a8d6add"
   integrity sha1-mC1ok6+RjnLQjeyehnP/K1qNat0=
 
+fs-extra@8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0"
+  integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
+  dependencies:
+    graceful-fs "^4.2.0"
+    jsonfile "^4.0.0"
+    universalify "^0.1.0"
+
 fs-extra@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-1.0.0.tgz#cd3ce5f7e7cb6145883fcae3191e9877f8587950"
@@ -3795,6 +3834,11 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.15.tgz#ffb703e1066e8a0eeaa4c8b80ba9253eeefbfb00"
   integrity sha512-6uHUhOPEBgQ24HM+r6b/QwWfZq+yiFcipKFrOFiBEnWdy5sdzYoi+pJeQaPI5qOLRFqWmAXUPQNsielzdLoecA==
 
+graceful-fs@^4.2.0:
+  version "4.2.6"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
+  integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
+
 "graceful-readlink@>= 1.0.0":
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
@@ -4276,6 +4320,13 @@ is-ci@^1.0.10:
   dependencies:
     ci-info "^1.5.0"
 
+is-core-module@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
+  integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
+  dependencies:
+    has "^1.0.3"
+
 is-data-descriptor@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
@@ -4749,6 +4800,13 @@ jsonfile@^2.1.0:
   optionalDependencies:
     graceful-fs "^4.1.6"
 
+jsonfile@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
+  integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
 jsonparse@^1.2.0:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
@@ -5068,6 +5126,13 @@ locate-path@^3.0.0:
     p-locate "^3.0.0"
     path-exists "^3.0.0"
 
+locate-path@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
+  integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
+  dependencies:
+    p-locate "^4.1.0"
+
 lodash._arraycopy@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/lodash._arraycopy/-/lodash._arraycopy-3.0.0.tgz#76e7b7c1f1fb92547374878a562ed06a3e50f6e1"
@@ -5352,6 +5417,13 @@ make-dir@^1.0.0:
   dependencies:
     pify "^3.0.0"
 
+make-dir@^3.0.2:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
+  integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
+  dependencies:
+    semver "^6.0.0"
+
 map-cache@^0.2.2:
   version "0.2.2"
   resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
@@ -6098,6 +6170,13 @@ p-limit@^2.0.0:
   dependencies:
     p-try "^2.0.0"
 
+p-limit@^2.2.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
+  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
+  dependencies:
+    p-try "^2.0.0"
+
 p-locate@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
@@ -6112,6 +6191,13 @@ p-locate@^3.0.0:
   dependencies:
     p-limit "^2.0.0"
 
+p-locate@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
+  integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
+  dependencies:
+    p-limit "^2.2.0"
+
 p-map@^1.1.1:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/p-map/-/p-map-1.2.0.tgz#e4e94f311eabbc8633a1e79908165fca26241b6b"
@@ -6278,6 +6364,11 @@ path-exists@^3.0.0:
   resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
   integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=
 
+path-exists@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
+  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
+
 path-is-absolute@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
@@ -6350,6 +6441,11 @@ phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
     request-progress "^2.0.1"
     which "^1.2.10"
 
+picomatch@^2.2.2:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
+  integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
+
 pify@^2.0.0, pify@^2.3.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
@@ -6393,6 +6489,13 @@ pkg-dir@^3.0.0:
   dependencies:
     find-up "^3.0.0"
 
+pkg-dir@^4.1.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
+  integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
+  dependencies:
+    find-up "^4.0.0"
+
 please-upgrade-node@^3.0.2:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/please-upgrade-node/-/please-upgrade-node-3.1.1.tgz#ed320051dfcc5024fae696712c8288993595e8ac"
@@ -6943,6 +7046,14 @@ resolve@1.1.x:
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b"
   integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=
 
+resolve@1.20.0:
+  version "1.20.0"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
+  integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
+  dependencies:
+    is-core-module "^2.2.0"
+    path-parse "^1.0.6"
+
 resolve@^1.1.6, resolve@^1.3.2, resolve@^1.3.3, resolve@^1.8.1:
   version "1.9.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.9.0.tgz#a14c6fdfa8f92a7df1d996cb7105fa744658ea06"
@@ -7047,6 +7158,17 @@ rollup-plugin-replace@^2.0.0:
     minimatch "^3.0.2"
     rollup-pluginutils "^2.0.1"
 
+rollup-plugin-typescript2@^0.30.0:
+  version "0.30.0"
+  resolved "https://registry.yarnpkg.com/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.30.0.tgz#1cc99ac2309bf4b9d0a3ebdbc2002aecd56083d3"
+  integrity sha512-NUFszIQyhgDdhRS9ya/VEmsnpTe+GERDMmFo0Y+kf8ds51Xy57nPNGglJY+W6x1vcouA7Au7nsTgsLFj2I0PxQ==
+  dependencies:
+    "@rollup/pluginutils" "^4.1.0"
+    find-cache-dir "^3.3.1"
+    fs-extra "8.1.0"
+    resolve "1.20.0"
+    tslib "2.1.0"
+
 rollup-pluginutils@^1.5.2:
   version "1.5.2"
   resolved "https://registry.yarnpkg.com/rollup-pluginutils/-/rollup-pluginutils-1.5.2.tgz#1e156e778f94b7255bfa1b3d0178be8f5c552408"
@@ -7185,6 +7307,11 @@ semver-compare@^1.0.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.6.0.tgz#7e74256fbaa49c75aa7c7a205cc22799cac80004"
   integrity sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==
 
+semver@^6.0.0:
+  version "6.3.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
+  integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
+
 semver@~5.0.1:
   version "5.0.3"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.0.3.tgz#77466de589cd5d3c95f138aa78bc569a3cb5d27a"
@@ -7941,6 +8068,11 @@ trim-right@^1.0.1:
   resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003"
   integrity sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=
 
+tslib@2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
+  integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
+
 tslib@^1.9.0:
   version "1.9.3"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286"
@@ -8057,6 +8189,11 @@ unique-slug@^2.0.0:
   dependencies:
     imurmurhash "^0.1.4"
 
+universalify@^0.1.0:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
+  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
+
 unpipe@1.0.0, unpipe@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"

From 63f9077de4f2930eede3d46eb50f520ae0c1cfaa Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Sat, 3 Apr 2021 17:29:42 +0100
Subject: [PATCH 003/317] import as types

---
 src/compiler/to-function.ts                                 | 2 +-
 src/core/components/keep-alive.ts                           | 2 +-
 src/core/config.ts                                          | 2 +-
 src/core/global-api/assets.ts                               | 2 +-
 src/core/global-api/extend.ts                               | 4 ++--
 src/core/global-api/index.ts                                | 2 +-
 src/core/global-api/mixin.ts                                | 2 +-
 src/core/global-api/use.ts                                  | 2 +-
 src/core/instance/events.ts                                 | 2 +-
 src/core/instance/index.ts                                  | 2 +-
 src/core/instance/init.ts                                   | 4 ++--
 src/core/instance/inject.ts                                 | 2 +-
 src/core/instance/lifecycle.ts                              | 4 ++--
 src/core/instance/render-helpers/bind-object-listeners.ts   | 2 +-
 src/core/instance/render-helpers/bind-object-props.ts       | 2 +-
 src/core/instance/render-helpers/resolve-scoped-slots.ts    | 2 +-
 src/core/instance/render-helpers/resolve-slots.ts           | 2 +-
 src/core/instance/render.ts                                 | 2 +-
 src/core/instance/state.ts                                  | 2 +-
 src/core/observer/scheduler.ts                              | 2 +-
 src/core/observer/watcher.ts                                | 2 +-
 src/core/util/debug.ts                                      | 2 +-
 src/core/util/options.ts                                    | 4 ++--
 src/core/util/props.ts                                      | 2 +-
 src/core/vdom/create-component.ts                           | 6 +++---
 src/core/vdom/create-element.ts                             | 4 ++--
 src/core/vdom/create-functional-component.ts                | 4 ++--
 src/core/vdom/helpers/extract-props.ts                      | 4 ++--
 src/core/vdom/helpers/resolve-async-component.ts            | 4 ++--
 src/core/vdom/helpers/update-listeners.ts                   | 2 +-
 src/core/vdom/modules/directives.ts                         | 4 ++--
 src/core/vdom/modules/ref.ts                                | 2 +-
 src/core/vdom/vnode.ts                                      | 6 +++---
 src/platforms/web/entry-runtime-with-compiler.ts            | 6 +++---
 src/platforms/web/runtime/components/transition.ts          | 2 +-
 src/platforms/web/runtime/directives/show.ts                | 2 +-
 src/platforms/web/runtime/index.ts                          | 2 +-
 src/platforms/web/runtime/modules/attrs.ts                  | 2 +-
 src/platforms/web/runtime/modules/class.ts                  | 2 +-
 src/platforms/web/runtime/modules/dom-props.ts              | 2 +-
 src/platforms/web/runtime/modules/events.ts                 | 2 +-
 src/platforms/web/runtime/modules/style.ts                  | 2 +-
 src/platforms/web/runtime/modules/transition.ts             | 2 +-
 src/platforms/web/server/directives/model.ts                | 2 +-
 src/platforms/web/server/directives/show.ts                 | 2 +-
 src/platforms/web/server/modules/attrs.ts                   | 2 +-
 src/platforms/web/server/modules/class.ts                   | 2 +-
 src/platforms/web/server/modules/dom-props.ts               | 2 +-
 src/platforms/web/server/modules/style.ts                   | 2 +-
 src/platforms/web/util/class.ts                             | 2 +-
 src/platforms/web/util/style.ts                             | 2 +-
 src/platforms/weex/compiler/index.ts                        | 2 +-
 .../weex/compiler/modules/recycle-list/component.ts         | 2 +-
 src/platforms/weex/compiler/modules/recycle-list/index.ts   | 2 +-
 .../weex/compiler/modules/recycle-list/recycle-list.ts      | 2 +-
 src/platforms/weex/compiler/modules/recycle-list/v-for.ts   | 2 +-
 src/platforms/weex/compiler/modules/recycle-list/v-if.ts    | 2 +-
 src/platforms/weex/compiler/modules/style.ts                | 2 +-
 src/platforms/weex/entry-framework.ts                       | 2 +-
 src/platforms/weex/runtime/modules/attrs.ts                 | 2 +-
 src/platforms/weex/runtime/modules/class.ts                 | 4 ++--
 src/platforms/weex/runtime/modules/events.ts                | 2 +-
 src/platforms/weex/runtime/modules/style.ts                 | 1 +
 src/platforms/weex/runtime/node-ops.ts                      | 2 +-
 .../weex/runtime/recycle-list/render-component-template.ts  | 2 +-
 .../weex/runtime/recycle-list/virtual-component.ts          | 4 ++--
 src/platforms/weex/util/index.ts                            | 2 +-
 src/server/create-basic-renderer.ts                         | 2 +-
 src/server/create-renderer.ts                               | 2 +-
 src/server/optimizing-compiler/runtime-helpers.ts           | 2 +-
 src/server/render.ts                                        | 4 ++--
 71 files changed, 89 insertions(+), 88 deletions(-)

diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index d14f45fbf03..6a434fbccf2 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -3,7 +3,7 @@
 import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
 import { generateCodeFrame } from './codeframe'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 type CompiledFunctionResult = {
   render: Function
diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index 6af29e4afac..a5b08bd7b47 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -3,7 +3,7 @@
 import { isRegExp, remove } from 'shared/util'
 import { getFirstComponentChild } from 'core/vdom/helpers/index'
 import VNode from 'core/vdom/vnode'
-import { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
+import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
 
 type VNodeCache = { [key: string]: VNode | null }
 
diff --git a/src/core/config.ts b/src/core/config.ts
index f615dac15e8..893f62228df 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -3,7 +3,7 @@
 import { no, noop, identity } from 'shared/util'
 
 import { LIFECYCLE_HOOKS } from 'shared/constants'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export type Config = {
   // user
diff --git a/src/core/global-api/assets.ts b/src/core/global-api/assets.ts
index 93cc7fc29d1..cdfe18fc6bc 100644
--- a/src/core/global-api/assets.ts
+++ b/src/core/global-api/assets.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { ASSET_TYPES } from 'shared/constants'
-import { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'typescript/global-api'
 import { isPlainObject, validateComponentName } from '../util/index'
 
 export function initAssetRegisters(Vue: GlobalAPI) {
diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index 0cb8b4b5091..546ae0b0659 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -1,8 +1,8 @@
 /* @flow */
 
 import { ASSET_TYPES } from 'shared/constants'
-import { Component } from 'typescript/component'
-import { GlobalAPI } from 'typescript/global-api'
+import type { Component } from 'typescript/component'
+import type { GlobalAPI } from 'typescript/global-api'
 import { defineComputed, proxy } from '../instance/state'
 import { extend, mergeOptions, validateComponentName } from '../util/index'
 
diff --git a/src/core/global-api/index.ts b/src/core/global-api/index.ts
index 071f76d8f2c..74c2dce8cd1 100644
--- a/src/core/global-api/index.ts
+++ b/src/core/global-api/index.ts
@@ -17,7 +17,7 @@ import {
   mergeOptions,
   defineReactive,
 } from '../util/index'
-import { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'typescript/global-api'
 
 export function initGlobalAPI(Vue: GlobalAPI) {
   // config
diff --git a/src/core/global-api/mixin.ts b/src/core/global-api/mixin.ts
index 9d78e2cd3c4..9947a5b22ee 100644
--- a/src/core/global-api/mixin.ts
+++ b/src/core/global-api/mixin.ts
@@ -1,6 +1,6 @@
 /* @flow */
 
-import { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'typescript/global-api'
 import { mergeOptions } from '../util/index'
 
 export function initMixin(Vue: GlobalAPI) {
diff --git a/src/core/global-api/use.ts b/src/core/global-api/use.ts
index bdc37b08972..ea5b1e91571 100644
--- a/src/core/global-api/use.ts
+++ b/src/core/global-api/use.ts
@@ -1,6 +1,6 @@
 /* @flow */
 
-import { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'typescript/global-api'
 import { toArray } from '../util/index'
 
 export function initUse(Vue: GlobalAPI) {
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index 413e1cf3da9..f8d301cc663 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -1,6 +1,6 @@
 /* @flow */
 
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 import {
   tip,
   toArray,
diff --git a/src/core/instance/index.ts b/src/core/instance/index.ts
index 1b8e8fa8c53..b17d6955011 100644
--- a/src/core/instance/index.ts
+++ b/src/core/instance/index.ts
@@ -5,7 +5,7 @@ import { renderMixin } from './render'
 import { eventsMixin } from './events'
 import { lifecycleMixin } from './lifecycle'
 import { warn } from '../util/index'
-import { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'typescript/global-api'
 
 function Vue(options) {
   if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index addccccc633..298370fe703 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -9,8 +9,8 @@ import { mark, measure } from '../util/perf'
 import { initLifecycle, callHook } from './lifecycle'
 import { initProvide, initInjections } from './inject'
 import { extend, mergeOptions, formatComponentName } from '../util/index'
-import { Component } from 'typescript/component'
-import { InternalComponentOptions } from 'typescript/options'
+import type { Component } from 'typescript/component'
+import type { InternalComponentOptions } from 'typescript/options'
 
 let uid = 0
 
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 2ffb3baec4d..d61a99b8f26 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -3,7 +3,7 @@
 import { hasOwn } from 'shared/util'
 import { warn, hasSymbol } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export function initProvide(vm: Component) {
   const provide = vm.$options.provide
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 486c8e3c33e..bcd6d65b2f8 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -17,8 +17,8 @@ import {
   validateProp,
   invokeWithErrorHandling,
 } from '../util/index'
-import { Component } from 'typescript/component'
-import { MountedComponentVNode } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
+import type { MountedComponentVNode } from 'typescript/vnode'
 
 export let activeInstance: any = null
 export let isUpdatingChildComponent: boolean = false
diff --git a/src/core/instance/render-helpers/bind-object-listeners.ts b/src/core/instance/render-helpers/bind-object-listeners.ts
index 5b839ae3bfe..858fe233d78 100644
--- a/src/core/instance/render-helpers/bind-object-listeners.ts
+++ b/src/core/instance/render-helpers/bind-object-listeners.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { warn, extend, isPlainObject } from 'core/util/index'
-import { VNodeData } from 'typescript/vnode'
+import type { VNodeData } from 'typescript/vnode'
 
 export function bindObjectListeners(data: any, value: any): VNodeData {
   if (value) {
diff --git a/src/core/instance/render-helpers/bind-object-props.ts b/src/core/instance/render-helpers/bind-object-props.ts
index 74cec42640b..c5f24c43fd6 100644
--- a/src/core/instance/render-helpers/bind-object-props.ts
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -10,7 +10,7 @@ import {
   camelize,
   hyphenate,
 } from 'core/util/index'
-import { VNodeData } from 'typescript/vnode'
+import type { VNodeData } from 'typescript/vnode'
 
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
diff --git a/src/core/instance/render-helpers/resolve-scoped-slots.ts b/src/core/instance/render-helpers/resolve-scoped-slots.ts
index 5caac1bcee6..c5bd2903316 100644
--- a/src/core/instance/render-helpers/resolve-scoped-slots.ts
+++ b/src/core/instance/render-helpers/resolve-scoped-slots.ts
@@ -1,4 +1,4 @@
-import { ScopedSlotsData } from 'typescript/vnode'
+import type { ScopedSlotsData } from 'typescript/vnode'
 
 export function resolveScopedSlots(
   fns: ScopedSlotsData,
diff --git a/src/core/instance/render-helpers/resolve-slots.ts b/src/core/instance/render-helpers/resolve-slots.ts
index e8b9e527104..d6a780272bc 100644
--- a/src/core/instance/render-helpers/resolve-slots.ts
+++ b/src/core/instance/render-helpers/resolve-slots.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import type VNode from 'core/vdom/vnode'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 0416ebb62f5..c16c6c60f13 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -15,7 +15,7 @@ import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
 import VNode, { createEmptyVNode } from '../vdom/vnode'
 
 import { isUpdatingChildComponent } from './lifecycle'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export function initRender(vm: Component) {
   vm._vnode = null // the root of the child tree
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 5a9b35b655d..d337b1a084b 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -27,7 +27,7 @@ import {
   isServerRendering,
   isReservedAttribute,
 } from '../util/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 const sharedPropertyDefinition = {
   enumerable: true,
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index ea2aec33eed..42a84d0fdcc 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -5,7 +5,7 @@ import config from '../config'
 import { callHook, activateChildComponent } from '../instance/lifecycle'
 
 import { warn, nextTick, devtools, inBrowser, isIE } from '../util/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export const MAX_UPDATE_COUNT = 100
 
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index a336ff044cf..df929201332 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -15,7 +15,7 @@ import { queueWatcher } from './scheduler'
 import Dep, { pushTarget, popTarget } from './dep'
 
 import type { SimpleSet } from '../util/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 let uid = 0
 
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index 43756d0ec27..ddbea7befe1 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -2,7 +2,7 @@
 
 import config from '../config'
 import { noop } from 'shared/util'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export let warn = noop
 export let tip = noop
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index f8fce1776dc..c01a8ce21ae 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -17,8 +17,8 @@ import {
   isBuiltInTag,
   isPlainObject,
 } from 'shared/util'
-import { Component } from 'typescript/component'
-import { ComponentOptions } from 'typescript/options'
+import type { Component } from 'typescript/component'
+import type { ComponentOptions } from 'typescript/options'
 
 /**
  * Option overwriting strategies are functions that handle
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index 645c87224ec..d7030ec2939 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -10,7 +10,7 @@ import {
   capitalize,
   isPlainObject,
 } from 'shared/util'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 type PropOptions = {
   type: Function | Array<Function> | null
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 336423abcab..c6e0172c31d 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -25,13 +25,13 @@ import {
   isRecyclableComponent,
   renderRecyclableComponentTemplate,
 } from 'weex/runtime/recycle-list/render-component-template'
-import {
+import type {
   MountedComponentVNode,
   VNodeData,
   VNodeWithData,
 } from 'typescript/vnode'
-import { Component } from 'typescript/component'
-import { InternalComponentOptions } from 'typescript/options'
+import type { Component } from 'typescript/component'
+import type { InternalComponentOptions } from 'typescript/options'
 
 // inline hooks to be invoked on component VNodes during patch
 const componentVNodeHooks = {
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index 493dd0c3aa6..e87ef802617 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -16,8 +16,8 @@ import {
 } from '../util/index'
 
 import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
-import { Component } from 'typescript/component'
-import { VNodeData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
+import type { VNodeData } from 'typescript/vnode'
 
 const SIMPLE_NORMALIZE = 1
 const ALWAYS_NORMALIZE = 2
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index 7ed667ce817..3e1fa3ced88 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -16,8 +16,8 @@ import {
   emptyObject,
   validateProp,
 } from '../util/index'
-import { Component } from 'typescript/component'
-import { VNodeData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
+import type { VNodeData } from 'typescript/vnode'
 
 export function FunctionalRenderContext(
   data: VNodeData,
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index 3bde2e81a89..a0507782c0c 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -8,8 +8,8 @@ import {
   hyphenate,
   formatComponentName,
 } from 'core/util/index'
-import { Component } from 'typescript/component'
-import { VNodeData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
+import type { VNodeData } from 'typescript/vnode'
 
 export function extractPropsFromVNodeData(
   data: VNodeData,
diff --git a/src/core/vdom/helpers/resolve-async-component.ts b/src/core/vdom/helpers/resolve-async-component.ts
index 38bcb687ac9..532425ca594 100644
--- a/src/core/vdom/helpers/resolve-async-component.ts
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -14,8 +14,8 @@ import {
 
 import VNode, { createEmptyVNode } from 'core/vdom/vnode'
 import { currentRenderingInstance } from 'core/instance/render'
-import { VNodeData } from 'typescript/vnode'
-import { Component } from 'typescript/component'
+import type { VNodeData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
 
 function ensureCtor(comp: any, base) {
   if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index eb513a7e058..ce84e18bab3 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -1,6 +1,6 @@
 import { warn, invokeWithErrorHandling } from 'core/util/index'
 import { cached, isUndef, isTrue, isPlainObject } from 'shared/util'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 const normalizeEvent = cached((name: string): {
   name: string
diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 097a241e323..9b89aa5cba1 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -3,8 +3,8 @@
 import { emptyNode } from 'core/vdom/patch'
 import { resolveAsset, handleError } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
-import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
-import { Component } from 'typescript/component'
+import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
 
 export default {
   create: updateDirectives,
diff --git a/src/core/vdom/modules/ref.ts b/src/core/vdom/modules/ref.ts
index 91a54a71d34..74cf22635bc 100644
--- a/src/core/vdom/modules/ref.ts
+++ b/src/core/vdom/modules/ref.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { remove, isDef } from 'shared/util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 export default {
   create(_: any, vnode: VNodeWithData) {
diff --git a/src/core/vdom/vnode.ts b/src/core/vdom/vnode.ts
index ef867750ded..a8e5ce8f3f4 100644
--- a/src/core/vdom/vnode.ts
+++ b/src/core/vdom/vnode.ts
@@ -1,6 +1,6 @@
-import { Component } from 'typescript/component'
-import { ComponentOptions } from 'typescript/options'
-import { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
+import type { ComponentOptions } from 'typescript/options'
+import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
 
 export default class VNode {
   tag: string | void
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index c7d233c6183..846e92877ef 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -1,5 +1,4 @@
 /* @flow */
-
 import config from 'core/config'
 import { warn, cached } from 'core/util/index'
 import { mark, measure } from 'core/util/perf'
@@ -11,7 +10,8 @@ import {
   shouldDecodeNewlines,
   shouldDecodeNewlinesForHref,
 } from './util/compat'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
+import type { GlobalAPI } from 'typescript/global-api'
 
 const idToTemplate = cached((id) => {
   const el = query(id)
@@ -108,4 +108,4 @@ function getOuterHTML(el: Element): string {
 
 Vue.compile = compileToFunctions
 
-export default Vue
+export default Vue as GlobalAPI
diff --git a/src/platforms/web/runtime/components/transition.ts b/src/platforms/web/runtime/components/transition.ts
index 381c146114e..12d299a1987 100644
--- a/src/platforms/web/runtime/components/transition.ts
+++ b/src/platforms/web/runtime/components/transition.ts
@@ -11,7 +11,7 @@ import {
   getFirstComponentChild,
 } from 'core/vdom/helpers/index'
 import VNode from 'core/vdom/vnode'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export const transitionProps = {
   name: String,
diff --git a/src/platforms/web/runtime/directives/show.ts b/src/platforms/web/runtime/directives/show.ts
index 182832c298b..1a9991ab118 100644
--- a/src/platforms/web/runtime/directives/show.ts
+++ b/src/platforms/web/runtime/directives/show.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import VNode from 'core/vdom/vnode'
-import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 import { enter, leave } from '../modules/transition'
 
 // recursively search for possible transition defined inside the component root
diff --git a/src/platforms/web/runtime/index.ts b/src/platforms/web/runtime/index.ts
index 32468341473..f1fda1e99f6 100644
--- a/src/platforms/web/runtime/index.ts
+++ b/src/platforms/web/runtime/index.ts
@@ -16,7 +16,7 @@ import {
 import { patch } from './patch'
 import platformDirectives from './directives/index'
 import platformComponents from './components/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp
diff --git a/src/platforms/web/runtime/modules/attrs.ts b/src/platforms/web/runtime/modules/attrs.ts
index dc1221e6b5d..42e6d8e12e3 100644
--- a/src/platforms/web/runtime/modules/attrs.ts
+++ b/src/platforms/web/runtime/modules/attrs.ts
@@ -3,7 +3,7 @@
 import { isIE, isIE9, isEdge } from 'core/util/env'
 
 import { extend, isDef, isUndef } from 'shared/util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 import {
   isXlink,
diff --git a/src/platforms/web/runtime/modules/class.ts b/src/platforms/web/runtime/modules/class.ts
index f1e0e70b559..6046f9b4751 100644
--- a/src/platforms/web/runtime/modules/class.ts
+++ b/src/platforms/web/runtime/modules/class.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { isDef, isUndef } from 'shared/util'
-import { VNodeData } from 'typescript/vnode'
+import type { VNodeData } from 'typescript/vnode'
 
 import { concat, stringifyClass, genClassForVnode } from 'web/util/index'
 
diff --git a/src/platforms/web/runtime/modules/dom-props.ts b/src/platforms/web/runtime/modules/dom-props.ts
index 799fdf7cf87..aa080c6b5df 100644
--- a/src/platforms/web/runtime/modules/dom-props.ts
+++ b/src/platforms/web/runtime/modules/dom-props.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { isDef, isUndef, extend, toNumber } from 'shared/util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 import { isSVG } from 'web/util/index'
 
 let svgContainer
diff --git a/src/platforms/web/runtime/modules/events.ts b/src/platforms/web/runtime/modules/events.ts
index 8c531aec710..fd9923aa2d1 100644
--- a/src/platforms/web/runtime/modules/events.ts
+++ b/src/platforms/web/runtime/modules/events.ts
@@ -8,7 +8,7 @@ import {
   CHECKBOX_RADIO_TOKEN,
 } from 'web/compiler/directives/model'
 import { currentFlushTimestamp } from 'core/observer/scheduler'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
diff --git a/src/platforms/web/runtime/modules/style.ts b/src/platforms/web/runtime/modules/style.ts
index 8424fe19da3..45d042d341f 100644
--- a/src/platforms/web/runtime/modules/style.ts
+++ b/src/platforms/web/runtime/modules/style.ts
@@ -9,7 +9,7 @@ import {
   isUndef,
   hyphenate,
 } from 'shared/util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 const cssVarRE = /^--/
 const importantRE = /\s*!important$/
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index 3552f767f5b..21e33b7a54a 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -13,7 +13,7 @@ import {
   addTransitionClass,
   removeTransitionClass,
 } from '../transition-util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 import VNode from 'core/vdom/vnode'
 
 export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
diff --git a/src/platforms/web/server/directives/model.ts b/src/platforms/web/server/directives/model.ts
index e5144b9b209..7ba5600182d 100644
--- a/src/platforms/web/server/directives/model.ts
+++ b/src/platforms/web/server/directives/model.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { looseEqual, looseIndexOf } from 'shared/util'
-import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
diff --git a/src/platforms/web/server/directives/show.ts b/src/platforms/web/server/directives/show.ts
index 5676348342e..ed1a7a4a2cf 100644
--- a/src/platforms/web/server/directives/show.ts
+++ b/src/platforms/web/server/directives/show.ts
@@ -1,6 +1,6 @@
 /* @flow */
 
-import { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 
 export default function show(node: VNodeWithData, dir: VNodeDirective) {
   if (!dir.value) {
diff --git a/src/platforms/web/server/modules/attrs.ts b/src/platforms/web/server/modules/attrs.ts
index cf0082ef7fc..18b2938b7d4 100644
--- a/src/platforms/web/server/modules/attrs.ts
+++ b/src/platforms/web/server/modules/attrs.ts
@@ -12,7 +12,7 @@ import {
 } from 'web/util/attrs'
 
 import { isSSRUnsafeAttr } from 'web/server/util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 export default function renderAttrs(node: VNodeWithData): string {
   let attrs = node.data.attrs
diff --git a/src/platforms/web/server/modules/class.ts b/src/platforms/web/server/modules/class.ts
index 7dc5d39fa05..1db7206b4cc 100644
--- a/src/platforms/web/server/modules/class.ts
+++ b/src/platforms/web/server/modules/class.ts
@@ -2,7 +2,7 @@
 
 import { escape } from '../util'
 import { genClassForVnode } from 'web/util/index'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 export default function renderClass(node: VNodeWithData): string | undefined {
   const classList = genClassForVnode(node)
diff --git a/src/platforms/web/server/modules/dom-props.ts b/src/platforms/web/server/modules/dom-props.ts
index bf481861b3d..1676c8949f4 100644
--- a/src/platforms/web/server/modules/dom-props.ts
+++ b/src/platforms/web/server/modules/dom-props.ts
@@ -4,7 +4,7 @@ import VNode from 'core/vdom/vnode'
 import { renderAttr } from './attrs'
 import { isDef, isUndef, extend, toString } from 'shared/util'
 import { propsToAttrMap, isRenderableAttr } from '../util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 export default function renderDOMProps(node: VNodeWithData): string {
   let props = node.data.domProps
diff --git a/src/platforms/web/server/modules/style.ts b/src/platforms/web/server/modules/style.ts
index 5e7bbbd6694..0e14124d0c7 100644
--- a/src/platforms/web/server/modules/style.ts
+++ b/src/platforms/web/server/modules/style.ts
@@ -3,7 +3,7 @@
 import { escape, noUnitNumericStyleProps } from '../util'
 import { hyphenate } from 'shared/util'
 import { getStyle } from 'web/util/style'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 export function genStyle(style: Object): string {
   let styleText = ''
diff --git a/src/platforms/web/util/class.ts b/src/platforms/web/util/class.ts
index 2f42a993990..a2fafe91383 100644
--- a/src/platforms/web/util/class.ts
+++ b/src/platforms/web/util/class.ts
@@ -2,7 +2,7 @@
 
 import VNode from 'core/vdom/vnode'
 import { isDef, isObject } from 'shared/util'
-import { VNodeData, VNodeWithData } from 'typescript/vnode'
+import type { VNodeData, VNodeWithData } from 'typescript/vnode'
 
 export function genClassForVnode(vnode: VNodeWithData): string {
   let data = vnode.data
diff --git a/src/platforms/web/util/style.ts b/src/platforms/web/util/style.ts
index b90c47650bf..df2306771f2 100644
--- a/src/platforms/web/util/style.ts
+++ b/src/platforms/web/util/style.ts
@@ -2,7 +2,7 @@
 
 import VNode from 'core/vdom/vnode'
 import { cached, extend, toObject } from 'shared/util'
-import { VNodeData, VNodeWithData } from 'typescript/vnode'
+import type { VNodeData, VNodeWithData } from 'typescript/vnode'
 
 export const parseStyleText = cached(function (cssText) {
   const res = {}
diff --git a/src/platforms/weex/compiler/index.ts b/src/platforms/weex/compiler/index.ts
index 4b7ec5bc811..31ecfaa14b0 100644
--- a/src/platforms/weex/compiler/index.ts
+++ b/src/platforms/weex/compiler/index.ts
@@ -13,7 +13,7 @@ import {
   canBeLeftOpenTag,
   getTagNamespace,
 } from '../util/element'
-import { WeexCompiledResult, WeexCompilerOptions } from 'typescript/weex'
+import type { WeexCompiledResult, WeexCompilerOptions } from 'typescript/weex'
 
 export const baseOptions: WeexCompilerOptions = {
   modules,
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component.ts b/src/platforms/weex/compiler/modules/recycle-list/component.ts
index 1d03c8fde13..f167cf0e1ce 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/component.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/component.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { addAttr } from 'compiler/helpers'
-import { WeexCompilerOptions } from 'typescript/weex'
+import type { WeexCompilerOptions } from 'typescript/weex'
 import { RECYCLE_LIST_MARKER } from 'weex/util/index'
 
 // mark components as inside recycle-list so that we know we need to invoke
diff --git a/src/platforms/weex/compiler/modules/recycle-list/index.ts b/src/platforms/weex/compiler/modules/recycle-list/index.ts
index 02096c0264b..9b2ee5bde0b 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/index.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/index.ts
@@ -9,7 +9,7 @@ import { preTransformVIf } from './v-if'
 import { preTransformVFor } from './v-for'
 import { postTransformVOn } from './v-on'
 import { preTransformVOnce } from './v-once'
-import { WeexCompilerOptions } from 'typescript/weex'
+import type { WeexCompilerOptions } from 'typescript/weex'
 
 let currentRecycleList: null | ASTElement = null
 
diff --git a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
index f9270403a6f..bc3893ace3f 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
@@ -2,7 +2,7 @@
 
 import { parseFor } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-import { WeexCompilerOptions } from 'typescript/weex'
+import type { WeexCompilerOptions } from 'typescript/weex'
 
 /**
  * Map the following syntax to corresponding attrs:
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-for.ts b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
index e6e29f3a084..5a99827fa91 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
@@ -2,7 +2,7 @@
 
 import { parseFor } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-import { WeexCompilerOptions } from 'typescript/weex'
+import type { WeexCompilerOptions } from 'typescript/weex'
 
 export function preTransformVFor(el: ASTElement, options: WeexCompilerOptions) {
   const exp = getAndRemoveAttr(el, 'v-for')
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
index 2fd85de2562..df29bc02099 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
@@ -2,7 +2,7 @@
 
 import { addIfCondition } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-import { WeexCompilerOptions } from 'typescript/weex'
+import type { WeexCompilerOptions } from 'typescript/weex'
 
 function hasConditionDirective(el: ASTElement): boolean {
   for (const attr in el.attrsMap) {
diff --git a/src/platforms/weex/compiler/modules/style.ts b/src/platforms/weex/compiler/modules/style.ts
index 51b3e16e478..90914e3f6cd 100644
--- a/src/platforms/weex/compiler/modules/style.ts
+++ b/src/platforms/weex/compiler/modules/style.ts
@@ -14,7 +14,7 @@ const normalize = cached(camelize)
 function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
   const staticStyle = getAndRemoveAttr(el, 'style')
-  const { dynamic, styleResult } = parseStaticStyle(staticStyle, options)
+  const { dynamic, styleResult } = parseStaticStyle(staticStyle!, options)
   if (process.env.NODE_ENV !== 'production' && dynamic) {
     warn(
       `style="${String(staticStyle)}": ` +
diff --git a/src/platforms/weex/entry-framework.ts b/src/platforms/weex/entry-framework.ts
index b3c1b094abe..2c8ba3606ec 100644
--- a/src/platforms/weex/entry-framework.ts
+++ b/src/platforms/weex/entry-framework.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { GlobalAPI } from 'typescript/global-api'
-import {
+import type {
   Weex,
   WeexInstanceContext,
   WeexInstanceOption,
diff --git a/src/platforms/weex/runtime/modules/attrs.ts b/src/platforms/weex/runtime/modules/attrs.ts
index dd437154593..7d3b3b6b217 100644
--- a/src/platforms/weex/runtime/modules/attrs.ts
+++ b/src/platforms/weex/runtime/modules/attrs.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { extend } from 'shared/util'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   if (!oldVnode.data.attrs && !vnode.data.attrs) {
diff --git a/src/platforms/weex/runtime/modules/class.ts b/src/platforms/weex/runtime/modules/class.ts
index a5020939446..80dbac8f1a9 100644
--- a/src/platforms/weex/runtime/modules/class.ts
+++ b/src/platforms/weex/runtime/modules/class.ts
@@ -1,8 +1,8 @@
 /* @flow */
 
 import { extend, isObject } from 'shared/util'
-import { Component } from 'typescript/component'
-import { VNodeData, VNodeWithData } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
+import type { VNodeData, VNodeWithData } from 'typescript/vnode'
 
 function updateClass(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   const el = vnode.elm
diff --git a/src/platforms/weex/runtime/modules/events.ts b/src/platforms/weex/runtime/modules/events.ts
index 53340b44034..1bc1a874568 100644
--- a/src/platforms/weex/runtime/modules/events.ts
+++ b/src/platforms/weex/runtime/modules/events.ts
@@ -1,7 +1,7 @@
 /* @flow */
 
 import { updateListeners } from 'core/vdom/helpers/update-listeners'
-import { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'typescript/vnode'
 
 let target: any
 
diff --git a/src/platforms/weex/runtime/modules/style.ts b/src/platforms/weex/runtime/modules/style.ts
index 7d982c65c68..6abcf6fe8d5 100644
--- a/src/platforms/weex/runtime/modules/style.ts
+++ b/src/platforms/weex/runtime/modules/style.ts
@@ -1,6 +1,7 @@
 /* @flow */
 
 import { extend, cached, camelize } from 'shared/util'
+import type { VNodeWithData } from 'typescript/vnode'
 
 const normalize = cached(camelize)
 
diff --git a/src/platforms/weex/runtime/node-ops.ts b/src/platforms/weex/runtime/node-ops.ts
index ca6cccc32fc..e7ad4d50c90 100644
--- a/src/platforms/weex/runtime/node-ops.ts
+++ b/src/platforms/weex/runtime/node-ops.ts
@@ -1,7 +1,7 @@
 /* @flow */
 declare var document: WeexDocument
 
-import { WeexDocument, WeexElement } from 'typescript/weex'
+import type { WeexDocument, WeexElement } from 'typescript/weex'
 import TextNode from 'weex/runtime/text-node'
 
 export const namespaceMap = {}
diff --git a/src/platforms/weex/runtime/recycle-list/render-component-template.ts b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
index 114ef0ecd86..1a7f222e930 100644
--- a/src/platforms/weex/runtime/recycle-list/render-component-template.ts
+++ b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
@@ -5,7 +5,7 @@ import { handleError } from 'core/util/error'
 import { RECYCLE_LIST_MARKER } from 'weex/util/index'
 import { createComponentInstanceForVnode } from 'core/vdom/create-component'
 import { resolveVirtualComponent } from './virtual-component'
-import { MountedComponentVNode, VNodeWithData } from 'typescript/vnode'
+import type { MountedComponentVNode, VNodeWithData } from 'typescript/vnode'
 import VNode from 'core/vdom/vnode'
 
 export function isRecyclableComponent(vnode: VNodeWithData | VNode): boolean {
diff --git a/src/platforms/weex/runtime/recycle-list/virtual-component.ts b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
index fde0d22e55c..a56d520d063 100644
--- a/src/platforms/weex/runtime/recycle-list/virtual-component.ts
+++ b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
@@ -15,9 +15,9 @@ import {
   resolveConstructorOptions,
 } from 'core/instance/init'
 import { registerComponentHook, updateComponentData } from '../../util/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 import VNode from 'core/vdom/vnode'
-import { MountedComponentVNode } from 'typescript/vnode'
+import type { MountedComponentVNode } from 'typescript/vnode'
 
 let uid = 0
 
diff --git a/src/platforms/weex/util/index.ts b/src/platforms/weex/util/index.ts
index 3c0d531e081..7f233115c3f 100644
--- a/src/platforms/weex/util/index.ts
+++ b/src/platforms/weex/util/index.ts
@@ -2,7 +2,7 @@
 declare var document: WeexDocument
 
 import { warn } from 'core/util/index'
-import { WeexDocument } from 'typescript/weex'
+import type { WeexDocument } from 'typescript/weex'
 
 export const RECYCLE_LIST_MARKER = '@inRecycleList'
 
diff --git a/src/server/create-basic-renderer.ts b/src/server/create-basic-renderer.ts
index e5f12bde60c..47867777ff5 100644
--- a/src/server/create-basic-renderer.ts
+++ b/src/server/create-basic-renderer.ts
@@ -3,7 +3,7 @@
 import { createWriteFunction } from './write'
 import { createRenderFunction } from './render'
 import type { RenderOptions } from './create-renderer'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 export function createBasicRenderer({
   modules = [],
diff --git a/src/server/create-renderer.ts b/src/server/create-renderer.ts
index a716553ba51..57480a26ea0 100644
--- a/src/server/create-renderer.ts
+++ b/src/server/create-renderer.ts
@@ -6,7 +6,7 @@ import { createRenderFunction } from './render'
 import { createPromiseCallback } from './util'
 import TemplateRenderer from './template-renderer/index'
 import type { ClientManifest } from './template-renderer/index'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 import VNode from 'core/vdom/vnode'
 import { Readable } from 'stream'
 
diff --git a/src/server/optimizing-compiler/runtime-helpers.ts b/src/server/optimizing-compiler/runtime-helpers.ts
index 56a25b16aaf..91d3e55a68a 100644
--- a/src/server/optimizing-compiler/runtime-helpers.ts
+++ b/src/server/optimizing-compiler/runtime-helpers.ts
@@ -13,7 +13,7 @@ import {
 } from 'core/vdom/helpers/normalize-children'
 
 import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
-import { Component } from 'typescript/component'
+import type { Component } from 'typescript/component'
 
 const ssrHelpers = {
   _ssrEscape: escape,
diff --git a/src/server/render.ts b/src/server/render.ts
index 2ebe6f1bf74..f5e3e0fd0bf 100644
--- a/src/server/render.ts
+++ b/src/server/render.ts
@@ -15,8 +15,8 @@ import {
   createComponentInstanceForVnode,
 } from 'core/vdom/create-component'
 import VNode from 'core/vdom/vnode'
-import { VNodeDirective } from 'typescript/vnode'
-import { Component } from 'typescript/component'
+import type { VNodeDirective } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
 
 let warned = Object.create(null)
 const warnOnce = (msg) => {

From 9c70fc0ec3ad78449e118dd3e33e0c8dbaabbb42 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Sat, 3 Apr 2021 17:32:18 +0100
Subject: [PATCH 004/317] fix unit tests

---
 package.json                   |   3 +
 test/unit/global.d.ts          |   3 +
 test/unit/karma.base.config.js |  14 ++-
 tsconfig.json                  |  11 +--
 yarn.lock                      | 153 ++++++++++++++++++++++++++++++++-
 5 files changed, 174 insertions(+), 10 deletions(-)
 create mode 100644 test/unit/global.d.ts

diff --git a/package.json b/package.json
index d26d0d2fdba..b145e0a8ca2 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,8 @@
     "@babel/plugin-transform-flow-strip-types": "^7.0.0",
     "@babel/preset-env": "^7.0.0",
     "@babel/register": "^7.0.0",
+    "@types/jasmine": "^3.6.9",
+    "@types/mocha": "^8.2.2",
     "@types/node": "^12.12.0",
     "@types/webpack": "^4.4.22",
     "acorn": "^5.2.1",
@@ -137,6 +139,7 @@
     "serialize-javascript": "^3.1.0",
     "shelljs": "^0.8.1",
     "terser": "^3.10.2",
+    "ts-loader": "^8.1.0",
     "typescript": "^4.2.2",
     "webpack": "~4.28.4",
     "weex-js-runtime": "^0.23.6",
diff --git a/test/unit/global.d.ts b/test/unit/global.d.ts
new file mode 100644
index 00000000000..6d72e300690
--- /dev/null
+++ b/test/unit/global.d.ts
@@ -0,0 +1,3 @@
+declare function waitForUpdate(
+  cb: Function
+): any;
diff --git a/test/unit/karma.base.config.js b/test/unit/karma.base.config.js
index 700ad6c093c..228ca8e28d7 100644
--- a/test/unit/karma.base.config.js
+++ b/test/unit/karma.base.config.js
@@ -4,18 +4,24 @@ const webpack = require('webpack')
 
 const webpackConfig = {
   mode: 'development',
-  resolve: {
-    alias: alias
-  },
   module: {
     rules: [
       {
         test: /\.js$/,
         loader: 'babel-loader',
         exclude: /node_modules/
-      }
+      },
+      {
+        test: /\.tsx?$/,
+        exclude: /node_modules/,
+        loader: 'ts-loader',
+      },
     ]
   },
+  resolve: {
+    alias: alias,
+    extensions: ['.tsx', '.ts', '.js'],
+  },
   plugins: [
     new webpack.DefinePlugin({
       __WEEX__: false,
diff --git a/tsconfig.json b/tsconfig.json
index 1f4d22f282d..2c3ba8a5313 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,7 +2,7 @@
   "compilerOptions": {
     "baseUrl": ".",
     "outDir": "dist",
-    "sourceMap": false,
+    "sourceMap": true,
     "target": "esnext",
     "module": "esnext",
     "moduleResolution": "node",
@@ -17,18 +17,19 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": ["node"],
+    "types": ["node", "jasmine"],
     "rootDir": ".",
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
-      "platforms/*": ["src/platforms/*"],
       "server/*": ["src/server/*"],
       "sfc/*": ["src/sfc/*"],
       "shared/*": ["src/shared/*"],
 
       "web/*": ["src/platforms/web/*"],
-      "weex/*": ["src/platforms/weex/*"]
+      "weex/*": ["src/platforms/weex/*"],
+
+      "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
   "include": [
@@ -37,8 +38,8 @@
     // "packages/*/__tests__",
     "test-dts",
 
-
     "typescript",
+    "test"
     // "src/global.d.ts"
   ],
 
diff --git a/yarn.lock b/yarn.lock
index 01f06e9145f..2727fea70ae 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -683,6 +683,16 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
   integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
 
+"@types/jasmine@^3.6.9":
+  version "3.6.9"
+  resolved "https://registry.yarnpkg.com/@types/jasmine/-/jasmine-3.6.9.tgz#8785870f87839b7d91b45d7b226380f28dee5d9f"
+  integrity sha512-B53NIwMj/AO0O+xfSWLYmKB0Mo6TYxfv2Mk8/c1T2w/e38t55iaPR6p7pHXTTtqfTmevPK3i8T1YweYFTZlxDw==
+
+"@types/mocha@^8.2.2":
+  version "8.2.2"
+  resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-8.2.2.tgz#91daa226eb8c2ff261e6a8cbf8c7304641e095e0"
+  integrity sha512-Lwh0lzzqT5Pqh6z61P3c3P5nm6fzQK/MMHl9UKeneAeInVflBSz1O2EkX6gM6xfJd7FBXBY5purtLx7fUiZ7Hw==
+
 "@types/node@*":
   version "10.12.18"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-10.12.18.tgz#1d3ca764718915584fcd9f6344621b7672665c67"
@@ -1009,6 +1019,13 @@ ansi-styles@^3.2.0, ansi-styles@^3.2.1:
   dependencies:
     color-convert "^1.9.0"
 
+ansi-styles@^4.1.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+  dependencies:
+    color-convert "^2.0.1"
+
 any-observable@^0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/any-observable/-/any-observable-0.3.0.tgz#af933475e5806a67d0d7df090dd5e8bef65d119b"
@@ -1524,6 +1541,13 @@ braces@^2.3.0, braces@^2.3.1:
     split-string "^3.0.2"
     to-regex "^3.0.1"
 
+braces@^3.0.1:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
+  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
+  dependencies:
+    fill-range "^7.0.1"
+
 brorand@^1.0.1, brorand@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
@@ -1788,6 +1812,14 @@ chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4
     escape-string-regexp "^1.0.5"
     supports-color "^5.3.0"
 
+chalk@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
+  integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
+  dependencies:
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
 chardet@^0.4.0:
   version "0.4.2"
   resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
@@ -1937,11 +1969,23 @@ color-convert@^1.9.0:
   dependencies:
     color-name "1.1.3"
 
+color-convert@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+  dependencies:
+    color-name "~1.1.4"
+
 color-name@1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
   integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
 
+color-name@~1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
+  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
+
 colors@^1.1.0:
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.3.tgz#39e005d546afe01e01f9c4ca8fa50f686a01205d"
@@ -2756,6 +2800,11 @@ emojis-list@^2.0.0:
   resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-2.1.0.tgz#4daa4d9db00f9819880c79fa457ae5b09a1fd389"
   integrity sha1-TapNnbAPmBmIDHn6RXrlsJof04k=
 
+emojis-list@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
+  integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
+
 encodeurl@~1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
@@ -2815,6 +2864,15 @@ engine.io@~3.2.0:
     engine.io-parser "~2.1.0"
     ws "~3.3.1"
 
+enhanced-resolve@^4.0.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec"
+  integrity sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==
+  dependencies:
+    graceful-fs "^4.1.2"
+    memory-fs "^0.5.0"
+    tapable "^1.0.0"
+
 enhanced-resolve@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.1.0.tgz#41c7e0bfdfe74ac1ffe1e57ad6a5c6c9f3742a7f"
@@ -3348,6 +3406,13 @@ fill-range@^4.0.0:
     repeat-string "^1.6.1"
     to-regex-range "^2.1.0"
 
+fill-range@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
+  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
+  dependencies:
+    to-regex-range "^5.0.1"
+
 finalhandler@1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.1.0.tgz#ce0b6855b45853e791b2fcc680046d88253dd7f5"
@@ -3903,6 +3968,11 @@ has-flag@^3.0.0:
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
   integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
 
+has-flag@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
+  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
+
 has-symbols@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.0.tgz#ba1a8f1af2a0fc39650f5c850367704122063b44"
@@ -4472,6 +4542,11 @@ is-number@^4.0.0:
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
   integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
 
+is-number@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
+  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
+
 is-obj@^1.0.0, is-obj@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
@@ -4793,6 +4868,13 @@ json5@^2.1.0:
   dependencies:
     minimist "^1.2.0"
 
+json5@^2.1.2:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
+  integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==
+  dependencies:
+    minimist "^1.2.5"
+
 jsonfile@^2.1.0:
   version "2.4.0"
   resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-2.4.0.tgz#3736a2b428b87bbda0cc83b53fa3d633a35c2ae8"
@@ -5110,6 +5192,15 @@ loader-utils@^1.0.2, loader-utils@^1.1.0:
     emojis-list "^2.0.0"
     json5 "^1.0.1"
 
+loader-utils@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.0.tgz#e4cace5b816d425a166b5f097e10cd12b36064b0"
+  integrity sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==
+  dependencies:
+    big.js "^5.2.2"
+    emojis-list "^3.0.0"
+    json5 "^2.1.2"
+
 locate-path@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
@@ -5391,6 +5482,13 @@ lru-cache@^5.1.1:
   dependencies:
     yallist "^3.0.2"
 
+lru-cache@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
+  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
+  dependencies:
+    yallist "^4.0.0"
+
 lru-cache@~2.6.5:
   version "2.6.5"
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-2.6.5.tgz#e56d6354148ede8d7707b58d143220fd08df0fd5"
@@ -5480,6 +5578,14 @@ memory-fs@^0.4.0, memory-fs@~0.4.1:
     errno "^0.1.3"
     readable-stream "^2.0.1"
 
+memory-fs@^0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
+  integrity sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==
+  dependencies:
+    errno "^0.1.3"
+    readable-stream "^2.0.1"
+
 meow@^3.3.0:
   version "3.7.0"
   resolved "https://registry.yarnpkg.com/meow/-/meow-3.7.0.tgz#72cb668b425228290abbfa856892587308a801fb"
@@ -5554,6 +5660,14 @@ micromatch@^3.1.10, micromatch@^3.1.4, micromatch@^3.1.8:
     snapdragon "^0.8.1"
     to-regex "^3.0.2"
 
+micromatch@^4.0.0:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.2.tgz#4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259"
+  integrity sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==
+  dependencies:
+    braces "^3.0.1"
+    picomatch "^2.0.5"
+
 miller-rabin@^4.0.0:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
@@ -6441,7 +6555,7 @@ phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
     request-progress "^2.0.1"
     which "^1.2.10"
 
-picomatch@^2.2.2:
+picomatch@^2.0.5, picomatch@^2.2.2:
   version "2.2.2"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
   integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
@@ -7312,6 +7426,13 @@ semver@^6.0.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
+semver@^7.3.4:
+  version "7.3.5"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
+  integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
+  dependencies:
+    lru-cache "^6.0.0"
+
 semver@~5.0.1:
   version "5.0.3"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.0.3.tgz#77466de589cd5d3c95f138aa78bc569a3cb5d27a"
@@ -7860,6 +7981,13 @@ supports-color@^5.3.0:
   dependencies:
     has-flag "^3.0.0"
 
+supports-color@^7.1.0:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
+  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
+  dependencies:
+    has-flag "^4.0.0"
+
 symbol-observable@^1.1.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.2.0.tgz#c22688aed4eab3cdc2dfeacbb561660560a00804"
@@ -8030,6 +8158,13 @@ to-regex-range@^2.1.0:
     is-number "^3.0.0"
     repeat-string "^1.6.1"
 
+to-regex-range@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
+  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
+  dependencies:
+    is-number "^7.0.0"
+
 to-regex@^3.0.1, to-regex@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
@@ -8068,6 +8203,17 @@ trim-right@^1.0.1:
   resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003"
   integrity sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=
 
+ts-loader@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-8.1.0.tgz#d6292487df279c7cc79b6d3b70bb9d31682b693e"
+  integrity sha512-YiQipGGAFj2zBfqLhp28yUvPP9jUGqHxRzrGYuc82Z2wM27YIHbElXiaZDc93c3x0mz4zvBmS6q/DgExpdj37A==
+  dependencies:
+    chalk "^4.1.0"
+    enhanced-resolve "^4.0.0"
+    loader-utils "^2.0.0"
+    micromatch "^4.0.0"
+    semver "^7.3.4"
+
 tslib@2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
@@ -8523,6 +8669,11 @@ yallist@^3.0.0, yallist@^3.0.2:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.0.3.tgz#b4b049e314be545e3ce802236d6cd22cd91c3de9"
   integrity sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A==
 
+yallist@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
+  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
+
 yauzl@2.4.1:
   version "2.4.1"
   resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.4.1.tgz#9528f442dab1b2284e58b4379bb194e22e0c4005"

From 79f9e15f42194a0129a49b5eeb20c0da151bb3ef Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Sat, 3 Apr 2021 17:53:04 +0100
Subject: [PATCH 005/317] ignore folder

---
 tsconfig.json | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/tsconfig.json b/tsconfig.json
index 2c3ba8a5313..55173de3e70 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -32,16 +32,7 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": [
-    "src",
-    // "packages/runtime-dom/types/jsx.d.ts",
-    // "packages/*/__tests__",
-    "test-dts",
+  "include": ["src", "test-dts", "typescript", "test"],
 
-    "typescript",
-    "test"
-    // "src/global.d.ts"
-  ],
-
-  "exclude": ["flow"]
+  "exclude": ["flow", "node_modules", "packages"]
 }

From cb0d18bfa1ea69a9ae01a025400de85b2e233efb Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 6 Apr 2021 17:04:48 +0100
Subject: [PATCH 006/317] bump rollup deps

---
 dist/vue.common.dev.js                        | 2721 +++++-----
 dist/vue.common.prod.js                       |    2 +-
 dist/vue.esm.browser.js                       | 4631 ++++++++---------
 dist/vue.esm.browser.min.js                   |    2 +-
 dist/vue.esm.js                               | 2726 +++++-----
 dist/vue.js                                   | 2727 +++++-----
 dist/vue.min.js                               |    2 +-
 dist/vue.runtime.common.dev.js                | 1529 +++---
 dist/vue.runtime.common.prod.js               |    2 +-
 dist/vue.runtime.esm.js                       | 1538 +++---
 dist/vue.runtime.js                           | 1535 +++---
 dist/vue.runtime.min.js                       |    2 +-
 package.json                                  |   15 +-
 packages/vue-server-renderer/basic.js         | 2085 +++-----
 packages/vue-server-renderer/build.dev.js     | 2424 ++++-----
 packages/vue-server-renderer/build.prod.js    |    2 +-
 packages/vue-server-renderer/client-plugin.js |  123 +-
 packages/vue-server-renderer/server-plugin.js |  111 +-
 packages/vue-template-compiler/browser.js     | 1489 ++----
 packages/vue-template-compiler/build.js       | 1138 ++--
 scripts/config.js                             |   21 +-
 src/compiler/parser/index.ts                  |    5 +-
 tsconfig.json                                 |    5 +-
 yarn.lock                                     |  355 +-
 24 files changed, 11344 insertions(+), 13846 deletions(-)

diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index d2b34780db6..ee880f933a0 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -109,7 +109,7 @@ var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove(arr, item) {
+function remove$2(arr, item) {
     if (arr.length) {
         var index = arr.indexOf(item);
         if (index > -1) {
@@ -178,7 +178,7 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
+var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
@@ -231,7 +231,7 @@ var identity = function (_) { return _; };
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys(modules) {
+function genStaticKeys$1(modules) {
     return modules
         .reduce(function (keys, m) {
         return keys.concat(m.staticKeys || []);
@@ -433,7 +433,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -464,10 +464,10 @@ var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
 var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
@@ -477,7 +477,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get: function () {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -523,44 +523,45 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
+    _Set = /** @class */ (function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function has (key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function add (key) {
+        Set.prototype.add = function (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function clear () {
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
         };
-
         return Set;
     }());
 }
 
 /* @flow */
-var warn = noop;
+var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn = function (msg, vm) {
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+        else if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole && !config.silent) {
+        if (hasConsole_1 && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -583,10 +584,10 @@ var formatComponentName;
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    var repeat = function (str, n) {
+    var repeat_1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -620,50 +621,55 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
 
-var uid = 0;
+var uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
-    }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$2(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -678,43 +684,45 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
+    if (text === void 0) { text = ''; }
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -768,9 +776,12 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
+        var arguments$1 = arguments;
 
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -806,43 +817,46 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
     }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive$$1(obj, keys[i]);
-    }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
-    }
-};
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -892,7 +906,7 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
+function defineReactive(obj, key, val, customSetter, shallow) {
     var dep = new Dep();
     var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -951,8 +965,8 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
  * already exist.
  */
 function set(target, key, val) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -966,7 +980,7 @@ function set(target, key, val) {
     var ob = target.__ob__;
     // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
         return val;
     }
@@ -974,7 +988,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -982,8 +996,8 @@ function set(target, key, val) {
  * Delete a property and trigger change if necessary.
  */
 function del(target, key) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -992,7 +1006,7 @@ function del(target, key) {
     var ob = target.__ob__;
     //@ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid deleting properties on a Vue instance or its root $data ' +
+        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                 '- just set it to null.');
         return;
     }
@@ -1010,7 +1024,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1032,7 +1046,7 @@ var strats = config.optionMergeStrategies;
 {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
+            warn$2("option \"" + key + "\" can only be used during instance " +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1108,7 +1122,7 @@ function mergeDataOrFn(parentVal, childVal, vm) {
 strats.data = function (parentVal, childVal, vm) {
     if (!vm) {
         if (childVal && typeof childVal !== 'function') {
-            warn('The "data" option should be a function ' +
+            warn$2('The "data" option should be a function ' +
                     'that returns a per-instance value in component ' +
                     'definitions.', vm);
             return parentVal;
@@ -1120,7 +1134,7 @@ strats.data = function (parentVal, childVal, vm) {
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(parentVal, childVal) {
+function mergeHook$1(parentVal, childVal) {
     var res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
@@ -1140,7 +1154,7 @@ function dedupeHooks(hooks) {
     return res;
 }
 LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+    strats[hook] = mergeHook$1;
 });
 /**
  * Assets
@@ -1186,14 +1200,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key$1] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1231,14 +1245,14 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-        warn('Invalid component name: "' +
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+        warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
             'should conform to valid custom element name in html5 specification.');
     }
     if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
             'id: ' +
             name);
     }
@@ -1262,7 +1276,7 @@ function normalizeProps(options, vm) {
                 res[name] = { type: null };
             }
             else {
-                warn('props must be strings when using array syntax.');
+                warn$2('props must be strings when using array syntax.');
             }
         }
     }
@@ -1274,8 +1288,8 @@ function normalizeProps(options, vm) {
         }
     }
     else {
-        warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
+            ("but got " + toRawType(props) + "."), vm);
     }
     options.props = res;
 }
@@ -1301,28 +1315,28 @@ function normalizeInject(options, vm) {
         }
     }
     else {
-        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
+            ("but got " + toRawType(inject) + "."), vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives(options) {
+function normalizeDirectives$1(options) {
     var dirs = options.directives;
     if (dirs) {
         for (var key in dirs) {
-            var def$$1 = dirs[key];
-            if (typeof def$$1 === 'function') {
-                dirs[key] = { bind: def$$1, update: def$$1 };
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
             }
         }
     }
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 /**
@@ -1339,7 +1353,7 @@ function mergeOptions(parent, child, vm) {
     }
     normalizeProps(child, vm);
     normalizeInject(child, vm);
-    normalizeDirectives(child);
+    normalizeDirectives$1(child);
     // Apply extends and mixins on the child options,
     // but only if it is a raw options object that isn't
     // the result of another mergeOptions call.
@@ -1393,7 +1407,7 @@ function resolveAsset(options, type, id, warnMissing) {
     // fallback to prototype chain
     var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
     return res;
 }
@@ -1444,7 +1458,7 @@ function getPropDefaultValue(vm, prop, key) {
     var def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (isObject(def)) {
-        warn('Invalid default value for prop "' +
+        warn$2('Invalid default value for prop "' +
             key +
             '": ' +
             'Props with type Object/Array must use a factory function ' +
@@ -1469,7 +1483,7 @@ function getPropDefaultValue(vm, prop, key) {
  */
 function assertProp(prop, name, value, vm, absent) {
     if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
+        warn$2('Missing required prop: "' + name + '"', vm);
         return;
     }
     if (value == null && !prop.required) {
@@ -1491,13 +1505,13 @@ function assertProp(prop, name, value, vm, absent) {
     }
     var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
     if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
     var validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
@@ -1524,7 +1538,7 @@ function assertType(value, type, vm) {
             valid = value instanceof type;
         }
         catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
             valid = false;
         }
     }
@@ -1559,7 +1573,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1567,24 +1581,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += " with value " + styleValue(value, expectedType);
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += "with value " + styleValue(value, receivedType) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return "\"" + value + "\"";
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return "" + Number(value);
     }
     else {
-        return ("" + value);
+        return "" + value;
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1592,9 +1606,12 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
+    var arguments$1 = arguments;
 
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments$1[_i];
+    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1660,7 +1677,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1703,9 +1720,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
+    var p_1 = Promise.resolve();
     timerFunc = function () {
-        p.then(flushCallbacks);
+        p_1.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1724,15 +1741,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
+    var counter_1 = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
     timerFunc = function () {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
+        counter_1 = (counter_1 + 1) % 2;
+        textNode_1.data = String(counter_1);
     };
     isUsingMicroTask = true;
 }
@@ -1777,23 +1794,21 @@ function nextTick(cb, ctx) {
     }
 }
 
-/* @flow */
-
 var mark;
 var measure;
 {
-    var perf = inBrowser && window.performance;
+    var perf_1 = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) {
+        mark = function (tag) { return perf_1.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
+            perf_1.measure(name, startTag, endTag);
+            perf_1.clearMarks(startTag);
+            perf_1.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1802,31 +1817,31 @@ var measure;
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
-        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+    var warnNonPresent_1 = function (target, key) {
+        warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
-        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    var warnReservedPrefix_1 = function (target, key) {
+        warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                     return false;
                 }
                 else {
@@ -1836,38 +1851,38 @@ var initProxy;
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
+    var hasHandler_1 = {
+        has: function (target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+            var isAllowed = allowedGlobals_1(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    var getHandler_1 = {
+        get: function (target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy) {
+        if (hasProxy_1) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1918,13 +1933,13 @@ function _traverse(val, seen) {
 var normalizeEvent = cached(function (name) {
     var passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
     var capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
         name: name,
-        once: once$$1,
+        once: once,
         capture: capture,
         passive: passive,
     };
@@ -1948,14 +1963,14 @@ function createFnInvoker(fns, vm) {
     invoker.fns = fns;
     return invoker;
 }
-function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-    var name, def$$1, cur, old, event;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, cur, old, event;
     for (name in on) {
-        def$$1 = cur = on[name];
+        cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+            warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1974,7 +1989,7 @@ function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
     for (name in oldOn) {
         if (isUndef(on[name])) {
             event = normalizeEvent(name);
-            remove$$1(event.name, oldOn[name], event.capture);
+            remove(event.name, oldOn[name], event.capture);
         }
     }
 }
@@ -1990,7 +2005,7 @@ function mergeVNodeHook(def, hookKey, hook) {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
         // and prevent memory leak
-        remove(invoker.fns, wrappedHook);
+        remove$2(invoker.fns, wrappedHook);
     }
     if (isUndef(oldHook)) {
         // no existing hook
@@ -2022,8 +2037,7 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    var attrs = data.attrs, props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2033,11 +2047,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2112,7 +2126,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2171,10 +2185,10 @@ function initInjections(vm) {
         Object.keys(result).forEach(function (key) {
             /* istanbul ignore else */
             {
-                defineReactive$$1(vm, key, result[key], function () {
-                    warn("Avoid mutating an injected value directly since the changes will be " +
+                defineReactive(vm, key, result[key], function () {
+                    warn$2("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                        ("injection being mutated: \"" + key + "\""), vm);
                 });
             }
         });
@@ -2211,7 +2225,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn$2("Injection \"" + key + "\" not found", vm);
                 }
             }
         }
@@ -2240,8 +2254,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2254,9 +2268,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
         }
     }
     return slots;
@@ -2290,16 +2304,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2393,7 +2407,7 @@ function renderSlot(name, fallback, props, bindObject) {
         props = props || {};
         if (bindObject) {
             if (!isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
+                warn$2('slot v-bind without argument expects an Object', this);
             }
             props = extend(extend({}, bindObject), props);
         }
@@ -2452,14 +2466,14 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
 function bindObjectProps(data, tag, value, asProp, isSync) {
     if (value) {
         if (!isObject(value)) {
-            warn('v-bind without argument expects an Object or Array value', this);
+            warn$2('v-bind without argument expects an Object or Array value', this);
         }
         else {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            var hash = void 0;
+            var _loop_1 = function (key) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2476,14 +2490,15 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        on["update:" + key] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-
-            for (var key in value) loop( key );
+            for (var key in value) {
+                _loop_1(key);
+            }
         }
     }
     return data;
@@ -2503,7 +2518,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic$1(tree, "__static__" + index, false);
     return tree;
 }
 /**
@@ -2511,14 +2526,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
     return tree;
 }
-function markStatic(tree, key, isOnce) {
+function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], key + "_" + i, isOnce);
             }
         }
     }
@@ -2536,7 +2551,7 @@ function markStaticNode(node, key, isOnce) {
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
-            warn('v-on without argument expects an Object value', this);
+            warn$2('v-on without argument expects an Object value', this);
         }
         else {
             var on = (data.on = data.on ? extend({}, data.on) : {});
@@ -2585,7 +2600,7 @@ function bindDynamicKeys(baseObj, values) {
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
         }
     }
     return baseObj;
@@ -2620,8 +2635,7 @@ function installRenderHelpers(target) {
 
 /* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
+    var _this = this;
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2648,14 +2662,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return _this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get: function () {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2669,7 +2683,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     }
     if (options._scopeId) {
         this._c = function (a, b, c, d) {
-            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2678,7 +2692,9 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+        this._c = function (a, b, c, d) {
+            return createElement$1(contextVm, a, b, c, d, needNormalization);
+        };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2732,14 +2748,10 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+    init: function (vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2752,7 +2764,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
+    prepatch: function (oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2761,12 +2773,11 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
+            callHook$1(componentInstance, 'mounted');
         }
         if (vnode.data.keepAlive) {
             if (context._isMounted) {
@@ -2782,7 +2793,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2808,7 +2819,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn$2("Invalid Component definition: " + String(Ctor), context);
         }
         return;
     }
@@ -2866,7 +2877,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2897,11 +2908,11 @@ function installComponentHooks(data) {
         var toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
     }
 }
-function mergeHook$1(f1, f2) {
+function mergeHook(f1, f2) {
     var merged = function (a, b) {
         // flow complains about extra args which is why we use any
         f1(a, b);
@@ -2936,7 +2947,7 @@ var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
     if (Array.isArray(data) || isPrimitive(data)) {
         normalizationType = children;
         children = data;
@@ -2949,7 +2960,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2966,7 +2977,7 @@ function _createElement(context, tag, data, children, normalizationType) {
         !isPrimitive(data.key)) {
         // @ts-expect-error
         {
-            warn('Avoid using non-primitive value as key, ' +
+            warn$2('Avoid using non-primitive value as key, ' +
                 'use string/number value instead.', context);
         }
     }
@@ -2984,14 +2995,14 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        var Ctor = void 0;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3068,21 +3079,21 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
     var parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
         }, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
         }, true);
     }
 }
@@ -3095,9 +3106,7 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3122,8 +3131,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e) {
-                    handleError(e, vm, "renderError");
+                catch (e$1) {
+                    handleError(e$1, vm, "renderError");
                     vnode = vm._vnode;
                 }
             }
@@ -3141,7 +3150,7 @@ function renderMixin(Vue) {
         // return empty vnode in case the render function errored out
         if (!(vnode instanceof VNode)) {
             if (Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
+                warn$2('Multiple root nodes returned from render function. Render function ' +
                     'should return a single root node.', vm);
             }
             vnode = createEmptyVNode();
@@ -3181,24 +3190,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
+        var owners_1 = (factory.owners = [owner]);
+        var sync_1 = true;
+        var timerLoading_1 = null;
+        var timerTimeout_1 = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+        var forceRender_1 = function (renderCompleted) {
+            for (var i = 0, l = owners_1.length; i < l; i++) {
+                owners_1[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
+                owners_1.length = 0;
+                if (timerLoading_1 !== null) {
+                    clearTimeout(timerLoading_1);
+                    timerLoading_1 = null;
                 }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
+                if (timerTimeout_1 !== null) {
+                    clearTimeout(timerTimeout_1);
+                    timerTimeout_1 = null;
                 }
             }
         };
@@ -3207,62 +3216,63 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
+            if (!sync_1) {
+                forceRender_1(true);
             }
             else {
-                owners.length = 0;
+                owners_1.length = 0;
             }
         });
-        var reject = once(function (reason) {
-            warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+        var reject_1 = once(function (reason) {
+            warn$2("Failed to resolve async component: " + String(factory) +
+                    (reason ? "\nReason: " + reason : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender(true);
+                forceRender_1(true);
             }
         });
-        var res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
+        var res_1 = factory(resolve, reject_1);
+        if (isObject(res_1)) {
+            if (isPromise(res_1)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
+                    res_1.then(resolve, reject_1);
                 }
             }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
+            else if (isPromise(res_1.component)) {
+                res_1.component.then(resolve, reject_1);
+                if (isDef(res_1.error)) {
+                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
                 }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
+                if (isDef(res_1.loading)) {
+                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                    if (res_1.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
-                            timerLoading = null;
+                        timerLoading_1 = setTimeout(function () {
+                            timerLoading_1 = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender(false);
+                                forceRender_1(false);
                             }
-                        }, res.delay || 200);
+                        }, res_1.delay || 200);
                     }
                 }
-                if (isDef(res.timeout)) {
+                if (isDef(res_1.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
-                        timerTimeout = null;
+                    timerTimeout_1 = setTimeout(function () {
+                        timerTimeout_1 = null;
                         if (isUndef(factory.resolved)) {
-                            reject("timeout (" + (res.timeout) + "ms)");
+                            reject_1("timeout (" + res_1.timeout + "ms)"
+                                );
                         }
-                    }, res.timeout);
+                    }, res_1.timeout);
                 }
             }
         }
-        sync = false;
+        sync_1 = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3286,8 +3296,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
-
 /* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
@@ -3298,15 +3306,15 @@ function initEvents(vm) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target;
-function add(event, fn) {
-    target.$on(event, fn);
+var target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
 }
 function remove$1(event, fn) {
-    target.$off(event, fn);
+    target$1.$off(event, fn);
 }
-function createOnceHandler(event, fn) {
-    var _target = target;
+function createOnceHandler$1(event, fn) {
+    var _target = target$1;
     return function onceHandler() {
         var res = fn.apply(null, arguments);
         if (res !== null) {
@@ -3315,9 +3323,9 @@ function createOnceHandler(event, fn) {
     };
 }
 function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
 }
 function eventsMixin(Vue) {
     var hookRE = /^hook:/;
@@ -3357,8 +3365,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                vm.$off(event[i_1], fn);
             }
             return vm;
         }
@@ -3389,10 +3397,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
             }
         }
         var cbs = vm._events[event];
@@ -3483,13 +3491,13 @@ function lifecycleMixin(Vue) {
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook(vm, 'beforeDestroy');
+        callHook$1(vm, 'beforeDestroy');
         vm._isBeingDestroyed = true;
         // remove self from parent
         var parent = vm.$parent;
         // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove(parent.$children, vm);
+            remove$2(parent.$children, vm);
         }
         // teardown watchers
         if (vm._watcher) {
@@ -3509,7 +3517,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook(vm, 'destroyed');
+        callHook$1(vm, 'destroyed');
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3533,16 +3541,16 @@ function mountComponent(vm, el, hydrating) {
             if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
                 vm.$options.el ||
                 el) {
-                warn('You are using the runtime-only build of Vue where the template ' +
+                warn$2('You are using the runtime-only build of Vue where the template ' +
                     'compiler is not available. Either pre-compile the templates into ' +
                     'render functions, or use the compiler-included build.', vm);
             }
             else {
-                warn('Failed to mount component: template or render function not defined.', vm);
+                warn$2('Failed to mount component: template or render function not defined.', vm);
             }
         }
     }
-    callHook(vm, 'beforeMount');
+    callHook$1(vm, 'beforeMount');
     var updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
@@ -3554,11 +3562,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure("vue " + name + " render", startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure("vue " + name + " patch", startTag, endTag);
         };
     }
     else {
@@ -3570,9 +3578,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before: function () {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook(vm, 'beforeUpdate');
+                callHook$1(vm, 'beforeUpdate');
             }
         },
     }, true /* isRenderWatcher */);
@@ -3581,7 +3589,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook(vm, 'mounted');
+        callHook$1(vm, 'mounted');
     }
     return vm;
 }
@@ -3671,7 +3679,7 @@ function activateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'activated');
+        callHook$1(vm, 'activated');
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3686,10 +3694,10 @@ function deactivateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'deactivated');
+        callHook$1(vm, 'deactivated');
     }
 }
-function callHook(vm, hook) {
+function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
     var handlers = vm.$options[hook];
@@ -3713,12 +3721,12 @@ var has = {};
 var circular = {};
 var waiting = false;
 var flushing = false;
-var index = 0;
+var index$1 = 0;
 /**
  * Reset the scheduler's state.
  */
 function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
+    index$1 = queue.length = activatedChildren.length = 0;
     has = {};
     {
         circular = {};
@@ -3740,15 +3748,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = function () { return performance_1.now(); };
     }
 }
 /**
@@ -3769,8 +3777,8 @@ function flushSchedulerQueue() {
     queue.sort(function (a, b) { return a.id - b.id; });
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
+    for (index$1 = 0; index$1 < queue.length; index$1++) {
+        watcher = queue[index$1];
         if (watcher.before) {
             watcher.before();
         }
@@ -3781,9 +3789,9 @@ function flushSchedulerQueue() {
         if (has[id] != null) {
             circular[id] = (circular[id] || 0) + 1;
             if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
+                warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        ? "in watcher with expression \"" + watcher.expression + "\""
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3808,7 +3816,7 @@ function callUpdatedHooks(queue) {
         var watcher = queue[i];
         var vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook(vm, 'updated');
+            callHook$1(vm, 'updated');
         }
     }
 }
@@ -3844,7 +3852,7 @@ function queueWatcher(watcher) {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
             var i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
+            while (i > index$1 && queue[i].id > watcher.id) {
                 i--;
             }
             queue.splice(i + 1, 0, watcher);
@@ -3862,197 +3870,200 @@ function queueWatcher(watcher) {
 }
 
 /* @flow */
-var uid$2 = 0;
+var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        expOrFn.toString();
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            warn("Failed watching path: \"" + expOrFn + "\" " +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-        }
-    }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+var Watcher = /** @class */ (function () {
+    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
         }
         else {
-            throw e;
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression =
+            expOrFn.toString() ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                        'Watcher only accepts simple dot-delimited paths. ' +
+                        'For full control, use a function instead.', vm);
+            }
         }
-        popTarget();
-        this.cleanupDeps();
+        this.value = this.lazy ? undefined : this.get();
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    Watcher.prototype.get = function () {
+        pushTarget(this);
+        var value;
+        var vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-    }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
-    }
-    else {
-        queueWatcher(this);
-    }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
+        catch (e) {
             if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                }
+                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
             }
             else {
-                this.cb.call(this.vm, value, oldValue);
+                throw e;
             }
         }
-    }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
-    }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove(this.vm._watchers, this);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    };
+    /**
+     * Add a dependency to this directive.
+     */
+    Watcher.prototype.addDep = function (dep) {
+        var id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
         }
+    };
+    /**
+     * Clean up for dependency collection.
+     */
+    Watcher.prototype.cleanupDeps = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            var dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        var tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    };
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    Watcher.prototype.update = function () {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
         }
-        this.active = false;
-    }
-};
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    };
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    Watcher.prototype.run = function () {
+        if (this.active) {
+            var value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                var oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    try {
+                        this.cb.call(this.vm, value, oldValue);
+                    }
+                    catch (e) {
+                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                    }
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    };
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    Watcher.prototype.evaluate = function () {
+        this.value = this.get();
+        this.dirty = false;
+    };
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    Watcher.prototype.depend = function () {
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    };
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    Watcher.prototype.teardown = function () {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            var i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    };
+    return Watcher;
+}());
 
 /* @flow */
 var sharedPropertyDefinition = {
@@ -4074,7 +4085,7 @@ function initState(vm) {
     vm._watchers = [];
     var opts = vm.$options;
     if (opts.props)
-        { initProps(vm, opts.props); }
+        { initProps$1(vm, opts.props); }
     if (opts.methods)
         { initMethods(vm, opts.methods); }
     if (opts.data) {
@@ -4084,12 +4095,12 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed(vm, opts.computed); }
+        { initComputed$1(vm, opts.computed); }
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
-function initProps(vm, propsOptions) {
+function initProps$1(vm, propsOptions) {
     var propsData = vm.$options.propsData || {};
     var props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
@@ -4100,7 +4111,7 @@ function initProps(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    var _loop_1 = function (key) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4108,14 +4119,14 @@ function initProps(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
             }
-            defineReactive$$1(props, key, value, function () {
+            defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn("Avoid mutating a prop directly since the value will be " +
+                    warn$2("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                        ("value. Prop being mutated: \"" + key + "\""), vm);
                 }
             });
         }
@@ -4126,8 +4137,9 @@ function initProps(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-
-    for (var key in propsOptions) loop( key );
+    for (var key in propsOptions) {
+        _loop_1(key);
+    }
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4135,7 +4147,7 @@ function initData(vm) {
     data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        warn('data functions should return an object:\n' +
+        warn$2('data functions should return an object:\n' +
                 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
     }
     // proxy data on instance
@@ -4147,11 +4159,11 @@ function initData(vm) {
         var key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            warn("The data property \"" + key + "\" is already declared as a prop. " +
+            warn$2("The data property \"" + key + "\" is already declared as a prop. " +
                     "Use prop default value instead.", vm);
         }
         else if (!isReserved(key)) {
@@ -4176,7 +4188,7 @@ function getData(data, vm) {
     }
 }
 var computedWatcherOptions = { lazy: true };
-function initComputed(vm, computed) {
+function initComputed$1(vm, computed) {
     // $flow-disable-line
     var watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
@@ -4185,7 +4197,7 @@ function initComputed(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (getter == null) {
-            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+            warn$2("Getter is missing for computed property \"" + key + "\".", vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4199,10 +4211,10 @@ function initComputed(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
             }
         }
     }
@@ -4225,7 +4237,7 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4254,18 +4266,18 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         {
             if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
             }
             if (key in vm && isReserved(key)) {
-                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
                     "Avoid defining component methods that start with _ or $.");
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
@@ -4305,11 +4317,11 @@ function stateMixin(Vue) {
     };
     {
         dataDef.set = function () {
-            warn('Avoid replacing instance root $data. ' +
+            warn$2('Avoid replacing instance root $data. ' +
                 'Use nested data properties instead.', this);
         };
         propsDef.set = function () {
-            warn("$props is readonly.", this);
+            warn$2("$props is readonly.", this);
         };
     }
     Object.defineProperty(Vue.prototype, '$data', dataDef);
@@ -4330,7 +4342,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
             }
             popTarget();
         }
@@ -4341,17 +4353,17 @@ function stateMixin(Vue) {
 }
 
 /* @flow */
-var uid$3 = 0;
-function initMixin(Vue) {
+var uid = 0;
+function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
         var vm = this;
         // a uid
-        vm._uid = uid$3++;
+        vm._uid = uid++;
         var startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = "vue-perf-start:" + vm._uid;
+            endTag = "vue-perf-end:" + vm._uid;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4375,16 +4387,16 @@ function initMixin(Vue) {
         initLifecycle(vm);
         initEvents(vm);
         initRender(vm);
-        callHook(vm, 'beforeCreate');
+        callHook$1(vm, 'beforeCreate');
         initInjections(vm); // resolve injections before data/props
         initState(vm);
         initProvide(vm); // resolve provide after data/props
-        callHook(vm, 'created');
+        callHook$1(vm, 'created');
         /* istanbul ignore if */
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure("vue " + vm._name + " init", startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4447,12 +4459,12 @@ function resolveModifiedOptions(Ctor) {
 
 function Vue(options) {
     if (!(this instanceof Vue)) {
-        warn('Vue is a constructor and should be called with the `new` keyword');
+        warn$2('Vue is a constructor and should be called with the `new` keyword');
     }
     this._init(options);
 }
 //@ts-ignore
-initMixin(Vue);
+initMixin$1(Vue);
 //@ts-ignore
 stateMixin(Vue);
 //@ts-ignore
@@ -4484,7 +4496,7 @@ function initUse(Vue) {
 }
 
 /* @flow */
-function initMixin$1(Vue) {
+function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
         return this;
@@ -4527,10 +4539,10 @@ function initExtend(Vue) {
         // the Vue instances at extension time, on the extended prototype. This
         // avoids Object.defineProperty calls for each instance created.
         if (Sub.options.props) {
-            initProps$1(Sub);
+            initProps(Sub);
         }
         if (Sub.options.computed) {
-            initComputed$1(Sub);
+            initComputed(Sub);
         }
         // allow further extension/mixin/plugin usage
         Sub.extend = Super.extend;
@@ -4556,13 +4568,13 @@ function initExtend(Vue) {
         return Sub;
     };
 }
-function initProps$1(Comp) {
+function initProps(Comp) {
     var props = Comp.options.props;
     for (var key in props) {
         proxy(Comp.prototype, "_props", key);
     }
 }
-function initComputed$1(Comp) {
+function initComputed(Comp) {
     var computed = Comp.options.computed;
     for (var key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
@@ -4618,26 +4630,24 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
-            if (name && !filter(name)) {
+            var name_1 = getComponentName(cachedNode.componentOptions);
+            if (name_1 && !filter(name_1)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-        cached$$1.componentInstance.$destroy();
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+        cached.componentInstance.$destroy();
     }
     cache[key] = null;
-    remove(keys, key);
+    remove$2(keys, key);
 }
 var patternTypes = [String, RegExp, Array];
 // TODO use defineComponent
@@ -4649,55 +4659,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    created: function () {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
+    destroyed: function () {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
+    mounted: function () {
+        var _this = this;
         this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+            pruneCache(_this, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+            pruneCache(_this, function (name) { return !matches(val, name); });
         });
     },
-    render: function render() {
+    render: function () {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            var name_2 = getComponentName(componentOptions);
+            var _a = this, include = _a.include, exclude = _a.exclude;
             if (
             // not included
-            (include && (!name || !matches(include, name))) ||
+            (include && (!name_2 || !matches(include, name_2))) ||
                 // excluded
-                (exclude && name && matches(exclude, name))) {
+                (exclude && name_2 && matches(exclude, name_2))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
+            var _b = this, cache = _b.cache, keys = _b.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? "::" + componentOptions.tag : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
                 // make current key freshest
-                remove(keys, key);
+                remove$2(keys, key);
                 keys.push(key);
             }
             else {
@@ -4725,7 +4730,7 @@ function initGlobalAPI(Vue) {
     configDef.get = function () { return config; };
     {
         configDef.set = function () {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
+            warn$2('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
     Object.defineProperty(Vue, 'config', configDef);
@@ -4733,10 +4738,10 @@ function initGlobalAPI(Vue) {
     // NOTE: these are not considered part of the public API - avoid relying on
     // them unless you are aware of the risk.
     Vue.util = {
-        warn: warn,
+        warn: warn$2,
         extend: extend,
         mergeOptions: mergeOptions,
-        defineReactive: defineReactive$$1,
+        defineReactive: defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
@@ -4755,7 +4760,7 @@ function initGlobalAPI(Vue) {
     Vue.options._base = Vue;
     extend(Vue.options.components, builtInComponents);
     initUse(Vue);
-    initMixin$1(Vue);
+    initMixin(Vue);
     initExtend(Vue);
     initAssetRegisters(Vue);
 }
@@ -4765,7 +4770,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get: function () {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4956,7 +4961,7 @@ function query(el) {
     if (typeof el === 'string') {
         var selected = document.querySelector(el);
         if (!selected) {
-            warn('Cannot find element: ' + el);
+            warn$2('Cannot find element: ' + el);
             return document.createElement('div');
         }
         return selected;
@@ -4967,7 +4972,7 @@ function query(el) {
 }
 
 /* @flow */
-function createElement$1(tagName, vnode) {
+function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
@@ -5015,7 +5020,8 @@ function setStyleScope(node, scopeId) {
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
-  createElement: createElement$1,
+  __proto__: null,
+  createElement: createElement,
   createElementNS: createElementNS,
   createTextNode: createTextNode,
   createComment: createComment,
@@ -5031,16 +5037,16 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 
 /* @flow */
 var ref = {
-    create: function create(_, vnode) {
+    create: function (_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update: function (oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5054,7 +5060,7 @@ function registerRef(vnode, isRemoval) {
     if (isRemoval) {
         if (Array.isArray(refs[key])) {
             // @ts-expect-error invalid typings
-            remove(refs[key], ref);
+            remove$2(refs[key], ref);
         }
         else if (refs[key] === ref) {
             refs[key] = undefined;
@@ -5122,8 +5128,7 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    var modules = backend.modules, nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5136,13 +5141,13 @@ function createPatchFunction(backend) {
         return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
     function createRmCb(childElm, listeners) {
-        function remove$$1() {
-            if (--remove$$1.listeners === 0) {
+        function remove() {
+            if (--remove.listeners === 0) {
                 removeNode(childElm);
             }
         }
-        remove$$1.listeners = listeners;
-        return remove$$1;
+        remove.listeners = listeners;
+        return remove;
     }
     function removeNode(el) {
         var parent = nodeOps.parentNode(el);
@@ -5151,7 +5156,7 @@ function createPatchFunction(backend) {
             nodeOps.removeChild(parent, el);
         }
     }
-    function isUnknownElement$$1(vnode, inVPre) {
+    function isUnknownElement(vnode, inVPre) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
@@ -5184,8 +5189,8 @@ function createPatchFunction(backend) {
                 if (data && data.pre) {
                     creatingElmInVPre++;
                 }
-                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn$2('Unknown custom element: <' +
                         tag +
                         '> - did you ' +
                         'register the component correctly? For recursive components, ' +
@@ -5277,11 +5282,11 @@ function createPatchFunction(backend) {
         // a reactivated keep-alive component doesn't insert itself
         insert(parentElm, vnode.elm, refElm);
     }
-    function insert(parent, elm, ref$$1) {
+    function insert(parent, elm, ref) {
         if (isDef(parent)) {
-            if (isDef(ref$$1)) {
-                if (nodeOps.parentNode(ref$$1) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref$$1);
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
                 }
             }
             else {
@@ -5294,8 +5299,8 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5309,8 +5314,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+            cbs.create[i_2](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5382,7 +5387,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
+            var i_3;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5394,16 +5399,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
+            if (isDef((i_3 = vnode.componentInstance)) &&
+                isDef((i_3 = i_3._vnode)) &&
+                isDef(i_3.data)) {
+                removeAndInvokeRemoveHook(i_3, rm);
             }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
+            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                cbs.remove[i_3](vnode, rm);
             }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
+            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                i_3(vnode, rm);
             }
             else {
                 rm();
@@ -5499,12 +5504,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
+        for (var i_4 = 0; i_4 < children.length; i_4++) {
+            var vnode = children[i_4];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5513,10 +5518,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (var i_5 = start; i_5 < end; i_5++) {
+            var c = oldCh[i_5];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                { return i_5; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5596,8 +5601,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
+            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                queue[i_6].data.hook.insert(queue[i_6]);
             }
         }
     }
@@ -5610,9 +5615,7 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        var tag = vnode.tag, data = vnode.data, children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5661,9 +5664,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        for (var i_7 = 0; i_7 < children.length; i_7++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5707,7 +5710,7 @@ function createPatchFunction(backend) {
     function assertNodeMatch(node, vnode, inVPre) {
         if (isDef(vnode.tag)) {
             return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement$$1(vnode, inVPre) &&
+                (!isUnknownElement(vnode, inVPre) &&
                     vnode.tag.toLowerCase() ===
                         (node.tagName && node.tagName.toLowerCase())));
         }
@@ -5749,7 +5752,7 @@ function createPatchFunction(backend) {
                             return oldVnode;
                         }
                         else {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
                                 'server-rendered content. This is likely caused by incorrect ' +
                                 'HTML markup, for example nesting block-level elements inside ' +
                                 '<p>, or missing <tbody>. Bailing hydration and performing ' +
@@ -5774,22 +5777,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
+                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                            cbs.destroy[i_8](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                cbs.create[i_9](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
+                            var insert_1 = ancestor.data.hook.insert;
+                            if (insert_1.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                    insert_1.fns[i_10]();
                                 }
                             }
                         }
@@ -5814,7 +5817,7 @@ function createPatchFunction(backend) {
 }
 
 /* @flow */
-var directives = {
+var directives$1 = {
     create: updateDirectives,
     update: updateDirectives,
     destroy: function unbindDirectives(vnode) {
@@ -5830,8 +5833,8 @@ function updateDirectives(oldVnode, vnode) {
 function _update(oldVnode, vnode) {
     var isCreate = oldVnode === emptyNode;
     var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
     var dirsWithInsert = [];
     var dirsWithPostpatch = [];
     var key, oldDir, dir;
@@ -5840,7 +5843,7 @@ function _update(oldVnode, vnode) {
         dir = newDirs[key];
         if (!oldDir) {
             // new directive, bind
-            callHook$1(dir, 'bind', vnode, oldVnode);
+            callHook(dir, 'bind', vnode, oldVnode);
             if (dir.def && dir.def.inserted) {
                 dirsWithInsert.push(dir);
             }
@@ -5849,7 +5852,7 @@ function _update(oldVnode, vnode) {
             // existing directive, update
             dir.oldValue = oldDir.value;
             dir.oldArg = oldDir.arg;
-            callHook$1(dir, 'update', vnode, oldVnode);
+            callHook(dir, 'update', vnode, oldVnode);
             if (dir.def && dir.def.componentUpdated) {
                 dirsWithPostpatch.push(dir);
             }
@@ -5858,7 +5861,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithInsert.length) {
         var callInsert = function () {
             for (var i = 0; i < dirsWithInsert.length; i++) {
-                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
         if (isCreate) {
@@ -5871,7 +5874,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithPostpatch.length) {
         mergeVNodeHook(vnode, 'postpatch', function () {
             for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
     }
@@ -5879,13 +5882,13 @@ function _update(oldVnode, vnode) {
         for (key in oldDirs) {
             if (!newDirs[key]) {
                 // no longer present, unbind
-                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
             }
         }
     }
 }
 var emptyModifiers = Object.create(null);
-function normalizeDirectives$1(dirs, vm) {
+function normalizeDirectives(dirs, vm) {
     var res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
@@ -5905,21 +5908,21 @@ function normalizeDirectives$1(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
 }
-function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
         }
     }
 }
 
-var baseModules = [ref, directives];
+var baseModules = [ref, directives$1];
 
 /* @flow */
 function updateAttrs(oldVnode, vnode) {
@@ -6009,11 +6012,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            var blocker_1 = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
+                el.removeEventListener('input', blocker_1);
             };
-            el.addEventListener('input', blocker);
+            el.addEventListener('input', blocker_1);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6048,7 +6051,7 @@ function updateClass(oldVnode, vnode) {
         el._prevClass = cls;
     }
 }
-var klass = {
+var klass$1 = {
     create: updateClass,
     update: updateClass,
 };
@@ -6132,7 +6135,9 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p = (void 0);
+                var p 
+                // find first non-whitespace prev char
+                = void 0;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -6166,19 +6171,19 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return ("_f(\"" + filter + "\")(" + exp + ")");
+        return "_f(\"" + filter + "\")(" + exp + ")";
     }
     else {
-        var name = filter.slice(0, i);
+        var name_1 = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
     }
 }
 
 /* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+    console.error("[Vue compiler]: " + msg);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -6212,7 +6217,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6347,25 +6352,23 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                "? " + baseValueExpression + ".trim()" +
-                ": " + baseValueExpression + ")";
+                ("? " + baseValueExpression + ".trim()") +
+                (": " + baseValueExpression + ")");
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: ("(" + value + ")"),
+        value: "(" + value + ")",
         expression: JSON.stringify(value),
-        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
     };
 }
 /**
@@ -6374,10 +6377,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return (value + "=" + assignment);
+        return value + "=" + assignment;
     }
     else {
-        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
     }
 }
 /**
@@ -6394,18 +6397,18 @@ function genAssignmentCode(value, assignment) {
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-var len, str, chr, index$1, expressionPos, expressionEndPos;
+var len, str, chr, index, expressionPos, expressionEndPos;
 function parseModel(val) {
     // Fix https://github.com/vuejs/vue/pull/7730
     // allow v-model="obj.val " (trailing whitespace)
     val = val.trim();
     len = val.length;
     if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index$1 = val.lastIndexOf('.');
-        if (index$1 > -1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
             return {
-                exp: val.slice(0, index$1),
-                key: '"' + val.slice(index$1 + 1) + '"',
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
             };
         }
         else {
@@ -6416,7 +6419,7 @@ function parseModel(val) {
         }
     }
     str = val;
-    index$1 = expressionPos = expressionEndPos = 0;
+    index = expressionPos = expressionEndPos = 0;
     while (!eof()) {
         chr = next();
         /* istanbul ignore if */
@@ -6433,17 +6436,17 @@ function parseModel(val) {
     };
 }
 function next() {
-    return str.charCodeAt(++index$1);
+    return str.charCodeAt(++index);
 }
 function eof() {
-    return index$1 >= len;
+    return index >= len;
 }
 function isStringStart(chr) {
     return chr === 0x22 || chr === 0x27;
 }
 function parseBracket(chr) {
     var inBracket = 1;
-    expressionPos = index$1;
+    expressionPos = index;
     while (!eof()) {
         chr = next();
         if (isStringStart(chr)) {
@@ -6455,7 +6458,7 @@ function parseBracket(chr) {
         if (chr === 0x5d)
             { inBracket--; }
         if (inBracket === 0) {
-            expressionEndPos = index$1;
+            expressionEndPos = index;
             break;
         }
     }
@@ -6476,7 +6479,7 @@ var warn$1;
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-function model(el, dir, _warn) {
+function model$1(el, dir, _warn) {
     warn$1 = _warn;
     var value = dir.value;
     var modifiers = dir.modifiers;
@@ -6486,7 +6489,7 @@ function model(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn$1("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -6513,7 +6516,7 @@ function model(el, dir, _warn) {
         return false;
     }
     else {
-        warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+        warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
             "v-model is not supported on this element type. " +
             "If you are working with contenteditable, it's recommended to " +
             'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
@@ -6527,25 +6530,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        "?_i(" + value + "," + valueBinding + ")>-1" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
         (trueValueBinding === 'true'
-            ? (":(" + value + ")")
-            : (":_q(" + value + "," + trueValueBinding + ")")));
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
         'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
         '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -6553,10 +6556,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        "return " + (number ? '_n(val)' : 'val') + "})";
+        ("return " + (number ? '_n(val)' : 'val') + "})");
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
+    code = code + " " + genAssignmentCode(value, assignment);
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -6564,18 +6567,15 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     {
-        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value$1 && !typeBinding) {
+        if (value_1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+            warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -6589,7 +6589,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', ("(" + value + ")"));
+    addProp(el, 'value', "(" + value + ")");
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -6605,8 +6605,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        var event_1 = isIE ? 'change' : 'input';
+        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6617,13 +6617,13 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target$1;
-function createOnceHandler$1(event, handler, capture) {
-    var _target = target$1; // save current target element in closure
+var target;
+function createOnceHandler(event, handler, capture) {
+    var _target = target; // save current target element in closure
     return function onceHandler() {
         var res = handler.apply(null, arguments);
         if (res !== null) {
-            remove$2(event, onceHandler, capture, _target);
+            remove(event, onceHandler, capture, _target);
         }
     };
 }
@@ -6631,7 +6631,7 @@ function createOnceHandler$1(event, handler, capture) {
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add$1(name, handler, capture, passive) {
+function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
     // happens because browsers fire microtask ticks between event propagation.
@@ -6639,17 +6639,17 @@ function add$1(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
+        var attachedTimestamp_1 = currentFlushTimestamp;
+        var original_1 = handler;
         //@ts-expect-error
-        handler = original._wrapper = function (e) {
+        handler = original_1._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
+                e.timeStamp >= attachedTimestamp_1 ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6658,14 +6658,14 @@ function add$1(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
+                return original_1.apply(this, arguments);
             }
         };
     }
-    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-function remove$2(name, handler, capture, _target) {
-    (_target || target$1).removeEventListener(name, 
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
     //@ts-expect-error
     handler._wrapper || handler, capture);
 }
@@ -6675,10 +6675,10 @@ function updateDOMListeners(oldVnode, vnode) {
     }
     var on = vnode.data.on || {};
     var oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
+    target = vnode.elm;
     normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
 }
 var events = {
     create: updateDOMListeners,
@@ -6893,9 +6893,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
+        var name_1 = vendorNames[i] + capName;
+        if (name_1 in emptyStyle) {
+            return name_1;
         }
     }
 });
@@ -6933,13 +6933,13 @@ function updateStyle(oldVnode, vnode) {
         }
     }
 }
-var style = {
+var style$1 = {
     create: updateStyle,
     update: updateStyle,
 };
 
 /* @flow */
-var whitespaceRE = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6952,7 +6952,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6977,7 +6977,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -7002,31 +7002,31 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def$$1) {
-    if (!def$$1) {
+function resolveTransition(def) {
+    if (!def) {
         return;
     }
     /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
+    if (typeof def === 'object') {
         var res = {};
-        if (def$$1.css !== false) {
-            extend(res, autoCssTransition(def$$1.name || 'v'));
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
         }
-        extend(res, def$$1);
+        extend(res, def);
         return res;
     }
-    else if (typeof def$$1 === 'string') {
-        return autoCssTransition(def$$1);
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
     }
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -7073,15 +7073,12 @@ function addTransitionClass(el, cls) {
 }
 function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
-        remove(el._transitionClasses, cls);
+        remove$2(el._transitionClasses, cls);
     }
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7187,23 +7184,7 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7311,17 +7292,7 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7394,11 +7365,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
     }
     else if (isNaN(val)) {
-        warn("<transition> explicit " + name + " duration is NaN - " +
+        warn$2("<transition> explicit " + name + " duration is NaN - " +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7435,7 +7406,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove$$1(vnode, rm) {
+        remove: function (vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7448,13 +7419,13 @@ var transition = inBrowser
     }
     : {};
 
-var platformModules = [attrs, klass, events, domProps, style, transition];
+var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
 /* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+var modules$1 = platformModules.concat(baseModules);
+var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -7472,7 +7443,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+    inserted: function (el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -7502,22 +7473,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated: function (el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            var prevOptions_1 = el._vOptions;
+            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
+                        hasNoMatchingOption(binding.value, curOptions_1);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7538,8 +7509,8 @@ function actuallySetSelected(el, binding, vm) {
     var value = binding.value;
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+        warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
+                ("expects an Array value for its binding, but got " + Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7597,14 +7568,13 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
+        var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition$$1) {
+        if (value && transition) {
             vnode.data.show = true;
             enter(vnode, function () {
                 el.style.display = originalDisplay;
@@ -7614,16 +7584,14 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
-        if (transition$$1) {
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
             vnode.data.show = true;
             if (value) {
                 enter(vnode, function () {
@@ -7640,7 +7608,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7691,8 +7659,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    for (var key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7720,9 +7688,8 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
+    render: function (h) {
+        var _this = this;
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -7735,7 +7702,7 @@ var Transition = {
         }
         // warn multiple elements
         if (children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
+            warn$2('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
         var mode = this.mode;
@@ -7743,7 +7710,7 @@ var Transition = {
         if (mode &&
             mode !== 'in-out' &&
             mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
+            warn$2('invalid <transition> mode: ' + mode, this.$parent);
         }
         var rawChild = children[0];
         // if this is a component root node and the component's
@@ -7764,7 +7731,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        var id = "__transition-" + this._uid + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7798,8 +7765,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                    _this._leaving = false;
+                    _this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7807,14 +7774,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
+                var delayedLeave_1;
                 var performLeave = function () {
-                    delayedLeave();
+                    delayedLeave_1();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave = leave;
+                    delayedLeave_1 = leave;
                 });
             }
         }
@@ -7831,22 +7798,21 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
+    beforeMount: function () {
+        var _this = this;
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+            var restoreActiveInstance = setActiveInstance(_this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            _this._vnode = _this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(_this, vnode, hydrating);
         };
     },
-    render: function render(h) {
+    render: function (h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -7863,27 +7829,27 @@ var TransitionGroup = {
                 }
                 else {
                     var opts = c.componentOptions;
-                    var name = opts
+                    var name_1 = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
+            for (var i = 0; i < prevChildren.length; i++) {
+                var c = prevChildren[i];
+                c.data.transition = transitionData;
                 // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                c.data.pos = c.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7891,7 +7857,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
+    updated: function () {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7909,25 +7875,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
-                addTransitionClass(el, moveClass);
+                var el_1 = c.elm;
+                var s = el_1.style;
+                addTransitionClass(el_1, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
+                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                    if (e && e.target !== el_1) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
+                        el_1.removeEventListener(transitionEndEvent, cb);
+                        el_1._moveCb = null;
+                        removeTransitionClass(el_1, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove: function (el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -8063,7 +8029,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push(("_s(" + exp + ")"));
+        tokens.push("_s(" + exp + ")");
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8078,7 +8044,7 @@ function parseText(text, delimiters) {
 }
 
 /* @flow */
-function transformNode(el, options) {
+function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
     if (staticClass) {
@@ -8098,24 +8064,24 @@ function transformNode(el, options) {
         el.classBinding = classBinding;
     }
 }
-function genData(el) {
+function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + (el.staticClass) + ",";
+        data += "staticClass:" + el.staticClass + ",";
     }
     if (el.classBinding) {
-        data += "class:" + (el.classBinding) + ",";
+        data += "class:" + el.classBinding + ",";
     }
     return data;
 }
-var klass$1 = {
+var klass = {
     staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData,
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
 /* @flow */
-function transformNode$1(el, options) {
+function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
@@ -8139,369 +8105,19 @@ function transformNode$1(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + (el.staticStyle) + ",";
+        data += "staticStyle:" + el.staticStyle + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + (el.styleBinding) + "),";
+        data += "style:(" + el.styleBinding + "),";
     }
     return data;
 }
-var style$1 = {
+var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
+    transformNode: transformNode,
     genData: genData$1,
 };
 
-/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-(function(root) {
-
-	// Detect free variables `exports`.
-	var freeExports = typeof exports == 'object' && exports;
-
-	// Detect free variable `module`.
-	var freeModule = typeof module == 'object' && module &&
-		module.exports == freeExports && module;
-
-	// Detect free variable `global`, from Node.js or Browserified code,
-	// and use it as `root`.
-	var freeGlobal = typeof global == 'object' && global;
-	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-		root = freeGlobal;
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	// All astral symbols.
-	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-	// All ASCII symbols (not just printable ASCII) except those listed in the
-	// first column of the overrides table.
-	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-	// code points listed in the first column of the overrides table on
-	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-	var regexEscape = /["&'<>`]/g;
-	var escapeMap = {
-		'"': '&quot;',
-		'&': '&amp;',
-		'\'': '&#x27;',
-		'<': '&lt;',
-		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-		// following is not strictly necessary unless it’s part of a tag or an
-		// unquoted attribute value. We’re only escaping it to support those
-		// situations, and for XML support.
-		'>': '&gt;',
-		// In Internet Explorer ≤ 8, the backtick character can be used
-		// to break out of (un)quoted attribute values or HTML comments.
-		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-		// http://html5sec.org/#133.
-		'`': '&#x60;'
-	};
-
-	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-	/*--------------------------------------------------------------------------*/
-
-	var stringFromCharCode = String.fromCharCode;
-
-	var object = {};
-	var hasOwnProperty = object.hasOwnProperty;
-	var has = function(object, propertyName) {
-		return hasOwnProperty.call(object, propertyName);
-	};
-
-	var contains = function(array, value) {
-		var index = -1;
-		var length = array.length;
-		while (++index < length) {
-			if (array[index] == value) {
-				return true;
-			}
-		}
-		return false;
-	};
-
-	var merge = function(options, defaults) {
-		if (!options) {
-			return defaults;
-		}
-		var result = {};
-		var key;
-		for (key in defaults) {
-			// A `hasOwnProperty` check is not needed here, since only recognized
-			// option names are used anyway. Any others are ignored.
-			result[key] = has(options, key) ? options[key] : defaults[key];
-		}
-		return result;
-	};
-
-	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-	var codePointToSymbol = function(codePoint, strict) {
-		var output = '';
-		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-			// See issue #4:
-			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-			// REPLACEMENT CHARACTER.”
-			if (strict) {
-				parseError('character reference outside the permissible Unicode range');
-			}
-			return '\uFFFD';
-		}
-		if (has(decodeMapNumeric, codePoint)) {
-			if (strict) {
-				parseError('disallowed character reference');
-			}
-			return decodeMapNumeric[codePoint];
-		}
-		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-			parseError('disallowed character reference');
-		}
-		if (codePoint > 0xFFFF) {
-			codePoint -= 0x10000;
-			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-			codePoint = 0xDC00 | codePoint & 0x3FF;
-		}
-		output += stringFromCharCode(codePoint);
-		return output;
-	};
-
-	var hexEscape = function(codePoint) {
-		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-	};
-
-	var decEscape = function(codePoint) {
-		return '&#' + codePoint + ';';
-	};
-
-	var parseError = function(message) {
-		throw Error('Parse error: ' + message);
-	};
-
-	/*--------------------------------------------------------------------------*/
-
-	var encode = function(string, options) {
-		options = merge(options, encode.options);
-		var strict = options.strict;
-		if (strict && regexInvalidRawCodePoint.test(string)) {
-			parseError('forbidden code point');
-		}
-		var encodeEverything = options.encodeEverything;
-		var useNamedReferences = options.useNamedReferences;
-		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-		var escapeBmpSymbol = function(symbol) {
-			return escapeCodePoint(symbol.charCodeAt(0));
-		};
-
-		if (encodeEverything) {
-			// Encode ASCII symbols.
-			string = string.replace(regexAsciiWhitelist, function(symbol) {
-				// Use named references if requested & possible.
-				if (useNamedReferences && has(encodeMap, symbol)) {
-					return '&' + encodeMap[symbol] + ';';
-				}
-				return escapeBmpSymbol(symbol);
-			});
-			// Shorten a few escapes that represent two symbols, of which at least one
-			// is within the ASCII range.
-			if (useNamedReferences) {
-				string = string
-					.replace(/&gt;\u20D2/g, '&nvgt;')
-					.replace(/&lt;\u20D2/g, '&nvlt;')
-					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-			}
-			// Encode non-ASCII symbols.
-			if (useNamedReferences) {
-				// Encode non-ASCII symbols that can be replaced with a named reference.
-				string = string.replace(regexEncodeNonAscii, function(string) {
-					// Note: there is no need to check `has(encodeMap, string)` here.
-					return '&' + encodeMap[string] + ';';
-				});
-			}
-			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-		} else if (useNamedReferences) {
-			// Apply named character references.
-			// Encode `<>"'&` using named character references.
-			if (!allowUnsafeSymbols) {
-				string = string.replace(regexEscape, function(string) {
-					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-				});
-			}
-			// Shorten escapes that represent two symbols, of which at least one is
-			// `<>"'&`.
-			string = string
-				.replace(/&gt;\u20D2/g, '&nvgt;')
-				.replace(/&lt;\u20D2/g, '&nvlt;');
-			// Encode non-ASCII symbols that can be replaced with a named reference.
-			string = string.replace(regexEncodeNonAscii, function(string) {
-				// Note: there is no need to check `has(encodeMap, string)` here.
-				return '&' + encodeMap[string] + ';';
-			});
-		} else if (!allowUnsafeSymbols) {
-			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-			// using named character references.
-			string = string.replace(regexEscape, escapeBmpSymbol);
-		}
-		return string
-			// Encode astral symbols.
-			.replace(regexAstralSymbols, function($0) {
-				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-				var high = $0.charCodeAt(0);
-				var low = $0.charCodeAt(1);
-				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-				return escapeCodePoint(codePoint);
-			})
-			// Encode any remaining BMP symbols that are not printable ASCII symbols
-			// using a hexadecimal escape.
-			.replace(regexBmpWhitelist, escapeBmpSymbol);
-	};
-	// Expose default options (so they can be overridden globally).
-	encode.options = {
-		'allowUnsafeSymbols': false,
-		'encodeEverything': false,
-		'strict': false,
-		'useNamedReferences': false,
-		'decimal' : false
-	};
-
-	var decode = function(html, options) {
-		options = merge(options, decode.options);
-		var strict = options.strict;
-		if (strict && regexInvalidEntity.test(html)) {
-			parseError('malformed character reference');
-		}
-		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-			var codePoint;
-			var semicolon;
-			var decDigits;
-			var hexDigits;
-			var reference;
-			var next;
-
-			if ($1) {
-				reference = $1;
-				// Note: there is no need to check `has(decodeMap, reference)`.
-				return decodeMap[reference];
-			}
-
-			if ($2) {
-				// Decode named character references without trailing `;`, e.g. `&amp`.
-				// This is only a parse error if it gets converted to `&`, or if it is
-				// followed by `=` in an attribute context.
-				reference = $2;
-				next = $3;
-				if (next && options.isAttributeValue) {
-					if (strict && next == '=') {
-						parseError('`&` did not start a character reference');
-					}
-					return $0;
-				} else {
-					if (strict) {
-						parseError(
-							'named character reference was not terminated by a semicolon'
-						);
-					}
-					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-					return decodeMapLegacy[reference] + (next || '');
-				}
-			}
-
-			if ($4) {
-				// Decode decimal escapes, e.g. `&#119558;`.
-				decDigits = $4;
-				semicolon = $5;
-				if (strict && !semicolon) {
-					parseError('character reference was not terminated by a semicolon');
-				}
-				codePoint = parseInt(decDigits, 10);
-				return codePointToSymbol(codePoint, strict);
-			}
-
-			if ($6) {
-				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-				hexDigits = $6;
-				semicolon = $7;
-				if (strict && !semicolon) {
-					parseError('character reference was not terminated by a semicolon');
-				}
-				codePoint = parseInt(hexDigits, 16);
-				return codePointToSymbol(codePoint, strict);
-			}
-
-			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-			if (strict) {
-				parseError(
-					'named character reference was not terminated by a semicolon'
-				);
-			}
-			return $0;
-		});
-	};
-	// Expose default options (so they can be overridden globally).
-	decode.options = {
-		'isAttributeValue': false,
-		'strict': false
-	};
-
-	var escape = function(string) {
-		return string.replace(regexEscape, function($0) {
-			// Note: there is no need to check `has(escapeMap, $0)` here.
-			return escapeMap[$0];
-		});
-	};
-
-	/*--------------------------------------------------------------------------*/
-
-	var he = {
-		'version': '1.2.0',
-		'encode': encode,
-		'decode': decode,
-		'escape': escape,
-		'unescape': decode
-	};
-
-	// Some AMD build optimizers, like r.js, check for specific condition patterns
-	// like the following:
-	if (
-		typeof define == 'function' &&
-		typeof define.amd == 'object' &&
-		define.amd
-	) {
-		define(function() {
-			return he;
-		});
-	}	else if (freeExports && !freeExports.nodeType) {
-		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-			freeModule.exports = he;
-		} else { // in Narwhal or RingoJS v0.7.0-
-			for (var key in he) {
-				has(he, key) && (freeExports[key] = he[key]);
-			}
-		}
-	} else { // in Rhino or a web browser
-		root.he = he;
-	}
-
-}(undefined));
-
-var he = /*#__PURE__*/Object.freeze({
-
-});
-
 /* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
@@ -8522,11 +8138,11 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
+var startTagOpen = new RegExp("^<" + qnameCapture);
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -8547,7 +8163,9 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+};
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -8555,11 +8173,11 @@ function decodeAttr(value, shouldDecodeNewlines) {
 function parseHTML(html, options) {
     var stack = [];
     var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var isUnaryTag = options.isUnaryTag || no;
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    while (html) {
+    var _loop_1 = function () {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -8573,7 +8191,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        continue;
+                        return "continue";
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -8581,14 +8199,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        continue;
+                        return "continue";
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    continue;
+                    return "continue";
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -8596,7 +8214,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
+                    return "continue";
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -8605,10 +8223,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    continue;
+                    return "continue";
                 }
             }
-            var text = (void 0), rest = (void 0), next = (void 0);
+            var text = void 0, rest = void 0, next = void 0;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8635,18 +8253,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength = 0;
-            var stackedTag = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+            var endTagLength_1 = 0;
+            var stackedTag_1 = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag_1] ||
+                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+            var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength_1 = endTag.length;
+                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -8654,20 +8272,25 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest$1.length;
-            html = rest$1;
-            parseEndTag(stackedTag, index - endTagLength, index);
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag_1, index - endTagLength_1, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                     start: index + html.length,
                 });
             }
-            break;
+            return "break";
         }
+    };
+    while (html) {
+        var state_1 = _loop_1();
+        if (state_1 === "break")
+            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -8684,7 +8307,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end, attr;
+            var end = void 0, attr = void 0;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8707,11 +8330,11 @@ function parseHTML(html, options) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
             }
-            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var unary = isUnaryTag(tagName) || !!unarySlash;
         var l = match.attrs.length;
         var attrs = new Array(l);
         for (var i = 0; i < l; i++) {
@@ -8765,9 +8388,9 @@ function parseHTML(html, options) {
         if (pos >= 0) {
             // Close all the open elements, up the stack
             for (var i = stack.length - 1; i >= pos; i--) {
-                if (i > pos || !tagName &&
+                if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8797,6 +8420,7 @@ function parseHTML(html, options) {
 }
 
 /* @flow */
+var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8808,12 +8432,12 @@ var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
 var slotRE = /^v-slot(:|$)|^#/;
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE$1 = /[ \f\t\r\n]+/g;
+var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(undefined);
+var decodeHTMLCached = cached(he.decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
-var warn$2;
+var warn;
 var delimiters;
 var transforms;
 var preTransforms;
@@ -8837,7 +8461,7 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn$2 = options.warn || baseWarn;
+    warn = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
@@ -8858,7 +8482,7 @@ function parse(template, options) {
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn$2(msg, range);
+            warn(msg, range);
         }
     }
     function closeElement(element) {
@@ -8893,8 +8517,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                    var name_1 = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -8920,7 +8544,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode;
+            var lastNode = void 0;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8930,7 +8554,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8939,7 +8563,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn$2,
+        warn: warn,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8947,7 +8571,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function start(tag, attrs, unary, start$1, end) {
+        start: function (tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -8962,7 +8586,7 @@ function parse(template, options) {
             }
             {
                 if (options.outputSourceRange) {
-                    element.start = start$1;
+                    element.start = start;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -8971,7 +8595,7 @@ function parse(template, options) {
                 }
                 attrs.forEach(function (attr) {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$2("Invalid dynamic argument expression: attribute names cannot contain " +
+                        warn("Invalid dynamic argument expression: attribute names cannot contain " +
                             "spaces, quotes, <, >, / or =.", {
                             start: attr.start + attr.name.indexOf("["),
                             end: attr.start + attr.name.length,
@@ -8981,9 +8605,9 @@ function parse(template, options) {
             }
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
-                warn$2('Templates should only be responsible for mapping the state to the ' +
+                warn('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        "<" + tag + ">" +
+                        ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -9022,24 +8646,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function end(tag, start, end$1) {
+        end: function (tag, start, end) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (options.outputSourceRange) {
-                element.end = end$1;
+                element.end = end;
             }
             closeElement(element);
         },
-        chars: function chars(text, start, end) {
+        chars: function (text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                             start: start,
                         });
                     }
@@ -9077,10 +8701,10 @@ function parse(template, options) {
             if (text) {
                 if (!inPre && whitespaceOption === 'condense') {
                     // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE$1, ' ');
+                    text = text.replace(whitespaceRE, ' ');
                 }
-                var res;
-                var child;
+                var res = void 0;
+                var child = void 0;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -9106,7 +8730,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function comment(text, start, end) {
+        comment: function (text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -9172,16 +8796,16 @@ function processKey(el) {
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent = el.parent;
+                var parent_1 = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$2("Do not use v-for index as key on <transition-group> children, " +
+                    parent_1 &&
+                    parent_1.tag === 'transition-group') {
+                    warn("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
@@ -9204,7 +8828,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn$2(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+            warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -9256,8 +8880,8 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+        warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -9268,7 +8892,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn$2("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -9282,8 +8906,8 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
+    var once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
         el.once = true;
     }
 }
@@ -9295,7 +8919,7 @@ function processSlotContent(el) {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn$2("the \"scope\" attribute for scoped slots have been deprecated and " +
+            warn("the \"scope\" attribute for scoped slots have been deprecated and " +
                 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                 "can also be used on plain elements in addition to <template> to " +
                 "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -9305,7 +8929,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$2("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+            warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -9330,52 +8954,48 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$2("<template v-slot> can only appear at the root level inside " +
+                        warn("<template v-slot> can only appear at the root level inside " +
                             "the receiving component", el);
                     }
                 }
-                var ref = getSlotName(slotBinding);
-                var name = ref.name;
-                var dynamic = ref.dynamic;
-                el.slotTarget = name;
+                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                el.slotTarget = name_2;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding$1) {
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$2("v-slot can only be used on components or <template>.", slotBinding$1);
+                        warn("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
-                        warn$2("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding$1);
+                        warn("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var ref$1 = getSlotName(slotBinding$1);
-                var name$1 = ref$1.name;
-                var dynamic$1 = ref$1.dynamic;
-                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name$1;
-                slotContainer.slotTargetDynamic = dynamic$1;
-                slotContainer.children = el.children.filter(function (c) {
+                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                slotContainer_1.slotTarget = name_3;
+                slotContainer_1.slotTargetDynamic = dynamic;
+                slotContainer_1.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer;
+                        c.parent = slotContainer_1;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -9391,21 +9011,21 @@ function getSlotName(binding) {
             name = 'default';
         }
         else {
-            warn$2("v-slot shorthand syntax requires a slot name.", binding);
+            warn("v-slot shorthand syntax requires a slot name.", binding);
         }
     }
     return dynamicArgRE.test(name)
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: ("\"" + name + "\""), dynamic: false };
+            { name: "\"" + name + "\"", dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn$2("`key` does not work on <slot> because slots are abstract outlets " +
+            warn("`key` does not work on <slot> because slots are abstract outlets " +
                 "and can possibly expand into multiple elements. " +
                 "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
         }
@@ -9444,7 +9064,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$2(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                    warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9458,14 +9078,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$2, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$2, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$2, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
                             );
                         }
                     }
@@ -9485,7 +9105,7 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
             }
             else {
                 // normal directives
@@ -9512,7 +9132,7 @@ function processAttrs(el) {
             {
                 var res = parseText(value, delimiters);
                 if (res) {
-                    warn$2(name + "=\"" + value + "\": " +
+                    warn(name + "=\"" + value + "\": " +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9542,11 +9162,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret = {};
+        var ret_1 = {};
         match.forEach(function (m) {
-            ret[m.slice(1)] = true;
+            ret_1[m.slice(1)] = true;
         });
-        return ret;
+        return ret_1;
     }
 }
 function makeAttrsMap(attrs) {
@@ -9555,7 +9175,7 @@ function makeAttrsMap(attrs) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9588,7 +9208,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            warn("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9605,16 +9225,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding;
+        var typeBinding = void 0;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + (map['v-bind']) + ").type";
+            typeBinding = "(" + map['v-bind'] + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -9660,28 +9280,28 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model$1 = {
+var model = {
     preTransformNode: preTransformNode,
 };
 
-var modules$1 = [klass$1, style$1, model$1];
+var modules = [klass, style, model];
 
 /* @flow */
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
 /* @flow */
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
     }
 }
 
-var directives$1 = {
-    model: model,
+var directives = {
+    model: model$1,
     text: text,
     html: html,
 };
@@ -9689,8 +9309,8 @@ var directives$1 = {
 /* @flow */
 var baseOptions = {
     expectHTML: true,
-    modules: modules$1,
-    directives: directives$1,
+    modules: modules,
+    directives: directives,
     isPreTag: isPreTag,
     isUnaryTag: isUnaryTag,
     mustUseProp: mustUseProp,
@@ -9698,13 +9318,13 @@ var baseOptions = {
     isReservedTag: isReservedTag,
     getTagNamespace: getTagNamespace,
     // @ts-ignore
-    staticKeys: genStaticKeys(modules$1),
+    staticKeys: genStaticKeys$1(modules),
 };
 
 /* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
-var genStaticKeysCached = cached(genStaticKeys$1);
+var genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -9722,15 +9342,15 @@ function optimize(root, options) {
     isStaticKey = genStaticKeysCached(options.staticKeys || '');
     isPlatformReservedTag = options.isReservedTag || no;
     // first pass: mark all non-static nodes.
-    markStatic$1(root);
+    markStatic(root);
     // second pass: mark static roots.
     markStaticRoots(root, false);
 }
-function genStaticKeys$1(keys) {
+function genStaticKeys(keys) {
     return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
         (keys ? ',' + keys : ''));
 }
-function markStatic$1(node) {
+function markStatic(node) {
     node.static = isStatic(node);
     if (node.type === 1) {
         // do not make component slot content static. this avoids
@@ -9743,15 +9363,15 @@ function markStatic$1(node) {
         }
         for (var i = 0, l = node.children.length; i < l; i++) {
             var child = node.children[i];
-            markStatic$1(child);
+            markStatic(child);
             if (!child.static) {
                 node.static = false;
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
-                markStatic$1(block);
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
+                markStatic(block);
                 if (!block.static) {
                     node.static = false;
                 }
@@ -9782,8 +9402,8 @@ function markStaticRoots(node, isInFor) {
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
     }
@@ -9854,7 +9474,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -9871,19 +9491,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name in events) {
-        var handlerCode = genHandler(events[name]);
+    for (var name_1 in events) {
+        var handlerCode = genHandler(events[name_1]);
         //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += name + "," + handlerCode + ",";
+        if (events[name_1] && events[name_1].dynamic) {
+            dynamicHandlers += name_1 + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
     if (dynamicHandlers) {
-        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
     }
     else {
         return prefix + staticHandlers;
@@ -9894,7 +9514,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -9903,13 +9523,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        for (var key in handler.modifiers) {
+        var _loop_1 = function (key) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -9918,15 +9538,18 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers = handler.modifiers;
+                var modifiers_1 = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
+        };
+        for (var key in handler.modifiers) {
+            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -9936,13 +9559,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            ? "return " + handler.value + ".apply(null, arguments)"
             : isFunctionExpression
-                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                ? "return (" + handler.value + ").apply(null, arguments)"
                 : isFunctionInvocation
-                    ? ("return " + (handler.value))
+                    ? "return " + handler.value
                     : handler.value;
-        return ("function($event){" + code + handlerCode + "}");
+        return "function($event){" + code + handlerCode + "}";
     }
 }
 function genKeyFilter(keys) {
@@ -9951,59 +9574,64 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&')) + ")return null;");
+        (keys.map(genFilterCode).join('&&') + ")return null;"));
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return ("$event.keyCode!==" + keyVal);
+        return "$event.keyCode!==" + keyVal;
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key)) + "," +
-        (JSON.stringify(keyCode)) + "," +
+        (JSON.stringify(key) + ",") +
+        (JSON.stringify(keyCode) + ",") +
         "$event.key," +
-        "" + (JSON.stringify(keyName)) +
+        ("" + JSON.stringify(keyName)) +
         ")");
 }
 
 /* @flow */
 function on(el, dir) {
     if (dir.modifiers) {
-        warn("v-on without argument does not support modifiers.");
+        warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
 /* @flow */
-function bind$1(el, dir) {
+function bind(el, dir) {
     el.wrapData = function (code) {
-        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
 /* @flow */
 var baseDirectives = {
     on: on,
-    bind: bind$1,
+    bind: bind,
     cloak: noop,
 };
 
 /* @flow */
-var CodegenState = function CodegenState(options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-};
+var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        var isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = function (el) {
+            return !!el.component || !isReservedTag(el.tag);
+        };
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+    return CodegenState;
+}());
 function generate(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
@@ -10013,7 +9641,7 @@ function generate(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -10041,17 +9669,19 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code;
+        var code = void 0;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data;
+            var data = void 0;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData$2(el, state);
+                data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+            ) + (children ? "," + children : '' // children
+            ) + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -10070,9 +9700,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
     state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
 }
 // v-once
 function genOnce(el, state) {
@@ -10082,19 +9712,19 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
+        var parent_1 = el.parent;
+        while (parent_1) {
+            if (parent_1.for) {
+                key = parent_1.key;
                 break;
             }
-            parent = parent.parent;
+            parent_1 = parent_1.parent;
         }
         if (!key) {
             state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
     }
     else {
         return genStatic(el, state);
@@ -10110,10 +9740,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
     }
     else {
-        return ("" + (genTernaryExp(condition.block)));
+        return "" + genTernaryExp(condition.block);
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -10127,23 +9757,23 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
+        ("function(" + alias + iterator1 + iterator2 + "){") +
+        ("return " + (altGen || genElement)(el, state)) +
         '})');
 }
-function genData$2(el, state) {
+function genData(el, state) {
     var data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
@@ -10152,11 +9782,11 @@ function genData$2(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + (el.key) + ",";
+        data += "key:" + el.key + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + (el.ref) + ",";
+        data += "ref:" + el.ref + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -10167,7 +9797,7 @@ function genData$2(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + (el.tag) + "\",";
+        data += "tag:\"" + el.tag + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -10175,31 +9805,31 @@ function genData$2(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + (genProps(el.attrs)) + ",";
+        data += "attrs:" + genProps(el.attrs) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + (genProps(el.props)) + ",";
+        data += "domProps:" + genProps(el.props) + ",";
     }
     // event handlers
     if (el.events) {
-        data += (genHandlers(el.events, false)) + ",";
+        data += genHandlers(el.events, false) + ",";
     }
     if (el.nativeEvents) {
-        data += (genHandlers(el.nativeEvents, true)) + ",";
+        data += genHandlers(el.nativeEvents, true) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + (el.slotTarget) + ",";
+        data += "slot:" + el.slotTarget + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+        data += genScopedSlots(el, el.scopedSlots, state) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -10213,7 +9843,7 @@ function genData$2(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -10243,9 +9873,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -10254,14 +9884,14 @@ function genDirectives(el, state) {
 }
 function genInlineTemplate(el, state) {
     var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
+    if ((el.children.length !== 1 || ast.type !== 1)) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
         var inlineRenderFns = generate(ast, state.options);
-        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-            .map(function (code) { return ("function(){" + code + "}"); })
-            .join(',')) + "]}");
+        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+            .map(function (code) { return "function(){" + code + "}"; })
+            .join(',') + "]}";
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -10286,23 +9916,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
+        var parent_2 = el.parent;
+        while (parent_2) {
+            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                parent_2.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent.if) {
+            if (parent_2.if) {
                 needsKey = true;
             }
-            parent = parent.parent;
+            parent_2 = parent_2.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
 }
 function hash(str) {
     var hash = 5381;
@@ -10331,36 +9961,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        "return " + (el.tag === 'template'
+        ("return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}";
+            : genElement(el, state)) + "}");
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el$1 = children[0];
+        var el_1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el$1.for &&
-            el$1.tag !== 'template' &&
-            el$1.tag !== 'slot') {
-            var normalizationType = checkSkip
-                ? state.maybeComponent(el$1)
+            el_1.for &&
+            el_1.tag !== 'template' &&
+            el_1.tag !== 'slot') {
+            var normalizationType_1 = checkSkip
+                ? state.maybeComponent(el_1)
                     ? ",1"
                     : ",0"
                 : "";
-            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
         }
-        var normalizationType$1 = checkSkip
+        var normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen = altGenNode || genNode;
-        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+        var gen_1 = altGenNode || genNode;
+        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
     }
 }
 // determine the normalization needed for the children array.
@@ -10402,17 +10032,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return ("_v(" + (text.type === 2
+    return "_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
 }
 function genComment(comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+    return "_e(" + JSON.stringify(comment.text) + ")";
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var res = "_t(" + slotName + (children ? "," + children : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -10421,22 +10051,22 @@ function genSlot(el, state) {
             dynamic: attr.dynamic,
         }); }))
         : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
+    var bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
         res += ",null";
     }
     if (attrs) {
         res += "," + attrs;
     }
-    if (bind$$1) {
-        res += (attrs ? '' : ',null') + "," + bind$$1;
+    if (bind) {
+        res += (attrs ? '' : ',null') + "," + bind;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
 }
 function genProps(props) {
     var staticProps = "";
@@ -10445,15 +10075,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += (prop.name) + "," + value + ",";
+            dynamicProps += prop.name + "," + value + ",";
         }
         else {
-            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+            staticProps += "\"" + prop.name + "\":" + value + ",";
         }
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    staticProps = "{" + staticProps.slice(0, -1) + "}";
     if (dynamicProps) {
-        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
     }
     else {
         return staticProps;
@@ -10488,22 +10118,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                var value = node.attrsMap[name];
+        for (var name_1 in node.attrsMap) {
+            if (dirRE.test(name_1)) {
+                var value = node.attrsMap[name_1];
                 if (value) {
-                    var range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    var range = node.rawAttrsMap[name_1];
+                    if (name_1 === 'v-for') {
+                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
                     }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (onRE.test(name_1)) {
+                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                     else {
-                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                 }
             }
@@ -10523,7 +10153,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10536,16 +10166,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(("var " + ident + "=_"));
+            new Function("var " + ident + "=_");
         }
         catch (e) {
-            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(("return " + exp));
+        new Function("return " + exp);
     }
     catch (e) {
         var keywordMatch = exp
@@ -10553,12 +10183,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
         }
         else {
-            warn("invalid expression: " + (e.message) + " in\n\n" +
-                "    " + exp + "\n\n" +
-                "  Raw expression: " + (text.trim()) + "\n", range);
+            warn("invalid expression: " + e.message + " in\n\n" +
+                ("    " + exp + "\n\n") +
+                ("  Raw expression: " + text.trim() + "\n"), range);
         }
     }
 }
@@ -10567,18 +10197,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-            "    " + exp + "\n\n" +
-            "  Raw expression: " + (text.trim()) + "\n", range);
+        warn("invalid function parameter expression: " + e.message + " in\n\n" +
+            ("    " + exp + "\n\n") +
+            ("  Raw expression: " + text.trim() + "\n"), range);
     }
 }
 
 /* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
+    if (start === void 0) { start = 0; }
+    if (end === void 0) { end = source.length; }
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -10588,18 +10217,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                    var length_1 = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length$1 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat$1("^", length$1));
+                        var length_2 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length_2));
                     }
                     count += lineLength + 1;
                 }
@@ -10609,7 +10238,7 @@ function generateCodeFrame(source, start, end) {
     }
     return res.join('\n');
 }
-function repeat$1(str, n) {
+function repeat(str, n) {
     var result = '';
     if (n > 0) {
         while (true) {
@@ -10639,7 +10268,7 @@ function createCompileToFunctionFn(compile) {
     var cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn$$1 = options.warn || warn;
+        var warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         {
@@ -10649,7 +10278,7 @@ function createCompileToFunctionFn(compile) {
             }
             catch (e) {
                 if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
                         'environment with Content Security Policy that prohibits unsafe-eval. ' +
                         'The template compiler cannot work in this environment. Consider ' +
                         'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -10671,13 +10300,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                    warn("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -10703,14 +10332,12 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn$$1("Failed to generate render function:\n\n" +
+                warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (ref) {
-                            var err = ref.err;
-                            var code = ref.code;
-
-                            return ((err.toString()) + " in\n\n" + code + "\n");
-                })
+                        .map(function (_a) {
+                        var err = _a.err, code = _a.code;
+                        return err.toString() + " in\n\n" + code + "\n";
+                    })
                         .join('\n'), vm);
             }
         }
@@ -10731,15 +10358,15 @@ function createCompilerCreator(baseCompile) {
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
+                                data.start = range.start + leadingSpaceLength_1;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
+                                data.end = range.end + leadingSpaceLength_1;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -10794,9 +10421,7 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
 });
 
 /* @flow */
-var ref$1 = createCompiler(baseOptions);
-var compile = ref$1.compile;
-var compileToFunctions = ref$1.compileToFunctions;
+var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
 /* @flow */
 // check whether current browser encodes a char inside attribute values
@@ -10823,7 +10448,7 @@ Vue.prototype.$mount = function (el, hydrating) {
     el = el && query(el);
     /* istanbul ignore if */
     if (el === document.body || el === document.documentElement) {
-        warn("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+        warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
         return this;
     }
     var options = this.$options;
@@ -10836,7 +10461,7 @@ Vue.prototype.$mount = function (el, hydrating) {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (!template) {
-                        warn(("Template element not found or is empty: " + (options.template)), this);
+                        warn$2("Template element not found or is empty: " + options.template, this);
                     }
                 }
             }
@@ -10845,7 +10470,7 @@ Vue.prototype.$mount = function (el, hydrating) {
             }
             else {
                 {
-                    warn('invalid template option:' + template, this);
+                    warn$2('invalid template option:' + template, this);
                 }
                 return this;
             }
@@ -10859,21 +10484,19 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (config.performance && mark) {
                 mark('compile');
             }
-            var ref = compileToFunctions(template, {
+            var _a = compileToFunctions(template, {
                 outputSourceRange: "development" !== 'production',
                 shouldDecodeNewlines: shouldDecodeNewlines,
                 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
-            }, this);
-            var render = ref.render;
-            var staticRenderFns = ref.staticRenderFns;
+            }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (config.performance && mark) {
                 mark('compile end');
-                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+                measure("vue " + this._name + " compile", 'compile', 'compile end');
             }
         }
     }
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
index 7673ab64786..7dd3bc1ea9d 100644
--- a/dist/vue.common.prod.js
+++ b/dist/vue.common.prod.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var e=Object.freeze({});function r(e){return null==e}function t(e){return null!=e}function n(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var i=Object.prototype.toString;function s(e){return"[object Object]"===i.call(e)}function c(e){var r=parseFloat(String(e));return r>=0&&Math.floor(r)===r&&isFinite(e)}function u(e){return t(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===i?JSON.stringify(e,null,2):String(e)}function p(e){var r=parseFloat(e);return isNaN(r)?e:r}function f(e,r){for(var t=Object.create(null),n=e.split(","),a=0;a<n.length;a++)t[n[a]]=!0;return r?function(e){return t[e.toLowerCase()]}:function(e){return t[e]}}var d=f("slot,component",!0),m=f("key,ref,slot,slot-scope,is");function h(e,r){if(e.length){var t=e.indexOf(r);if(t>-1)return e.splice(t,1)}}var v=Object.prototype.hasOwnProperty;function g(e,r){return v.call(e,r)}function b(e){var r=Object.create(null);return function(t){return r[t]||(r[t]=e(t))}}var y=/-(\w)/g,w=b(function(e){return e.replace(y,function(e,r){return r?r.toUpperCase():""})}),A=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),D=/\B([A-Z])/g,x=b(function(e){return e.replace(D,"-$1").toLowerCase()});var q=Function.prototype.bind?function(e,r){return e.bind(r)}:function(e,r){function t(t){var n=arguments.length;return n?n>1?e.apply(r,arguments):e.call(r,t):e.call(r)}return t._length=e.length,t};function k(e,r){r=r||0;for(var t=e.length-r,n=new Array(t);t--;)n[t]=e[t+r];return n}function E(e,r){for(var t in r)e[t]=r[t];return e}function _(e){for(var r={},t=0;t<e.length;t++)e[t]&&E(r,e[t]);return r}function C(e,r,t){}var S=function(e,r,t){return!1},L=function(e){return e};function T(e,r){if(e===r)return!0;var t=o(e),n=o(r);if(!t||!n)return!t&&!n&&String(e)===String(r);try{var a=Array.isArray(e),i=Array.isArray(r);if(a&&i)return e.length===r.length&&e.every(function(e,t){return T(e,r[t])});if(e instanceof Date&&r instanceof Date)return e.getTime()===r.getTime();if(a||i)return!1;var s=Object.keys(e),c=Object.keys(r);return s.length===c.length&&s.every(function(t){return T(e[t],r[t])})}catch(e){return!1}}function $(e,r){for(var t=0;t<e.length;t++)if(T(e[t],r))return t;return-1}function N(e){var r=!1;return function(){r||(r=!0,e.apply(this,arguments))}}var O="data-server-rendered",R=["component","directive","filter"],F=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],B={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:C,parsePlatformTagName:L,mustUseProp:S,async:!0,_lifecycleHooks:F},U=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function V(e,r,t,n){Object.defineProperty(e,r,{value:t,enumerable:!!n,writable:!0,configurable:!0})}var I=new RegExp("[^"+U.source+".$_\\d]");var j,P="__proto__"in{},H="undefined"!=typeof window,M="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,G=M&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),J=z&&/msie|trident/.test(z),K=z&&z.indexOf("msie 9.0")>0,Z=z&&z.indexOf("edge/")>0,Y=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===G),W=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Q={}.watch,X=!1;if(H)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){X=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var re=function(){return void 0===j&&(j=!H&&!M&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),j},te=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ne(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,oe="undefined"!=typeof Symbol&&ne(Symbol)&&"undefined"!=typeof Reflect&&ne(Reflect.ownKeys);ae="undefined"!=typeof Set&&ne(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ie=C,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),r=0,t=e.length;r<t;r++)e[r].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function pe(){ue.pop(),ce.target=ue[ue.length-1]}var fe=function(e,r,t,n,a,o,i,s){this.tag=e,this.data=r,this.children=t,this.text=n,this.elm=a,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=r&&r.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(fe.prototype,de);var me=function(e){void 0===e&&(e="");var r=new fe;return r.text=e,r.isComment=!0,r};function he(e){return new fe(void 0,void 0,void 0,String(e))}function ve(e){var r=new fe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return r.ns=e.ns,r.isStatic=e.isStatic,r.key=e.key,r.isComment=e.isComment,r.fnContext=e.fnContext,r.fnOptions=e.fnOptions,r.fnScopeId=e.fnScopeId,r.asyncMeta=e.asyncMeta,r.isCloned=!0,r}var ge=Array.prototype,be=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var r=ge[e];V(be,e,function(){for(var t=[],n=arguments.length;n--;)t[n]=arguments[n];var a,o=r.apply(this,t),i=this.__ob__;switch(e){case"push":case"unshift":a=t;break;case"splice":a=t.slice(2)}return a&&i.observeArray(a),i.dep.notify(),o})});var ye=Object.getOwnPropertyNames(be),we=!0;function Ae(e){we=e}var De=function(e){var r;this.value=e,this.dep=new ce,this.vmCount=0,V(e,"__ob__",this),Array.isArray(e)?(P?(r=be,e.__proto__=r):function(e,r,t){for(var n=0,a=t.length;n<a;n++){var o=t[n];V(e,o,r[o])}}(e,be,ye),this.observeArray(e)):this.walk(e)};function xe(e,r){var t;if(o(e)&&!(e instanceof fe))return g(e,"__ob__")&&e.__ob__ instanceof De?t=e.__ob__:we&&!re()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(t=new De(e)),r&&t&&t.vmCount++,t}function qe(e,r,t,n,a){var o=new ce,i=Object.getOwnPropertyDescriptor(e,r);if(!i||!1!==i.configurable){var s=i&&i.get,c=i&&i.set;s&&!c||2!==arguments.length||(t=e[r]);var u=!a&&xe(t);Object.defineProperty(e,r,{enumerable:!0,configurable:!0,get:function(){var r=s?s.call(e):t;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(r)&&function e(r){for(var t=void 0,n=0,a=r.length;n<a;n++)(t=r[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&e(t)}(r))),r},set:function(r){var n=s?s.call(e):t;r===n||r!=r&&n!=n||s&&!c||(c?c.call(e,r):t=r,u=!a&&xe(r),o.notify())}})}}function ke(e,r,t){if(Array.isArray(e)&&c(r))return e.length=Math.max(e.length,r),e.splice(r,1,t),t;if(r in e&&!(r in Object.prototype))return e[r]=t,t;var n=e.__ob__;return e._isVue||n&&n.vmCount?t:n?(qe(n.value,r,t),n.dep.notify(),t):(e[r]=t,t)}function Ee(e,r){if(Array.isArray(e)&&c(r))e.splice(r,1);else{var t=e.__ob__;e._isVue||t&&t.vmCount||g(e,r)&&(delete e[r],t&&t.dep.notify())}}De.prototype.walk=function(e){for(var r=Object.keys(e),t=0;t<r.length;t++)qe(e,r[t])},De.prototype.observeArray=function(e){for(var r=0,t=e.length;r<t;r++)xe(e[r])};var _e=B.optionMergeStrategies;function Ce(e,r){if(!r)return e;for(var t,n,a,o=oe?Reflect.ownKeys(r):Object.keys(r),i=0;i<o.length;i++)"__ob__"!==(t=o[i])&&(n=e[t],a=r[t],g(e,t)?n!==a&&s(n)&&s(a)&&Ce(n,a):ke(e,t,a));return e}function Se(e,r,t){return t?function(){var n="function"==typeof r?r.call(t,t):r,a="function"==typeof e?e.call(t,t):e;return n?Ce(n,a):a}:r?e?function(){return Ce("function"==typeof r?r.call(this,this):r,"function"==typeof e?e.call(this,this):e)}:r:e}function Le(e,r){var t=r?e?e.concat(r):Array.isArray(r)?r:[r]:e;return t?function(e){for(var r=[],t=0;t<e.length;t++)-1===r.indexOf(e[t])&&r.push(e[t]);return r}(t):t}function Te(e,r,t,n){var a=Object.create(e||null);return r?E(a,r):a}_e.data=function(e,r,t){return t?Se(e,r,t):r&&"function"!=typeof r?e:Se(e,r)},F.forEach(function(e){_e[e]=Le}),R.forEach(function(e){_e[e+"s"]=Te}),_e.watch=function(e,r,t,n){if(e===Q&&(e=void 0),r===Q&&(r=void 0),!r)return Object.create(e||null);if(!e)return r;var a={};for(var o in E(a,e),r){var i=a[o],s=r[o];i&&!Array.isArray(i)&&(i=[i]),a[o]=i?i.concat(s):Array.isArray(s)?s:[s]}return a},_e.props=_e.methods=_e.inject=_e.computed=function(e,r,t,n){if(!e)return r;var a=Object.create(null);return E(a,e),r&&E(a,r),a},_e.provide=Se;var $e=function(e,r){return void 0===r?e:r};function Ne(e,r,t){if("function"==typeof r&&(r=r.options),function(e,r){var t=e.props;if(t){var n,a,o={};if(Array.isArray(t))for(n=t.length;n--;)"string"==typeof(a=t[n])&&(o[w(a)]={type:null});else if(s(t))for(var i in t)a=t[i],o[w(i)]=s(a)?a:{type:a};e.props=o}}(r),function(e,r){var t=e.inject;if(t){var n=e.inject={};if(Array.isArray(t))for(var a=0;a<t.length;a++)n[t[a]]={from:t[a]};else if(s(t))for(var o in t){var i=t[o];n[o]=s(i)?E({from:o},i):{from:i}}}}(r),function(e){var r=e.directives;if(r)for(var t in r){var n=r[t];"function"==typeof n&&(r[t]={bind:n,update:n})}}(r),!r._base&&(r.extends&&(e=Ne(e,r.extends,t)),r.mixins))for(var n=0,a=r.mixins.length;n<a;n++)e=Ne(e,r.mixins[n],t);var o,i={};for(o in e)c(o);for(o in r)g(e,o)||c(o);function c(n){var a=_e[n]||$e;i[n]=a(e[n],r[n],t,n)}return i}function Oe(e,r,t,n){if("string"==typeof t){var a=e[r];if(g(a,t))return a[t];var o=w(t);if(g(a,o))return a[o];var i=A(o);return g(a,i)?a[i]:a[t]||a[o]||a[i]}}function Re(e,r,t,n){var a=r[e],o=!g(t,e),i=t[e],s=Ve(Boolean,a.type);if(s>-1)if(o&&!g(a,"default"))i=!1;else if(""===i||i===x(e)){var c=Ve(String,a.type);(c<0||s<c)&&(i=!0)}if(void 0===i){i=function(e,r,t){if(!g(r,"default"))return;var n=r.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[t]&&void 0!==e._props[t])return e._props[t];return"function"==typeof n&&"Function"!==Be(r.type)?n.call(e):n}(n,a,e);var u=we;Ae(!0),xe(i),Ae(u)}return i}var Fe=/^\s*function (\w+)/;function Be(e){var r=e&&e.toString().match(Fe);return r?r[1]:""}function Ue(e,r){return Be(e)===Be(r)}function Ve(e,r){if(!Array.isArray(r))return Ue(r,e)?0:-1;for(var t=0,n=r.length;t<n;t++)if(Ue(r[t],e))return t;return-1}function Ie(e,r,t){le();try{if(r)for(var n=r;n=n.$parent;){var a=n.$options.errorCaptured;if(a)for(var o=0;o<a.length;o++)try{if(!1===a[o].call(n,e,r,t))return}catch(e){Pe(e,n,"errorCaptured hook")}}Pe(e,r,t)}finally{pe()}}function je(e,r,t,n,a){var o;try{(o=t?e.apply(r,t):e.call(r))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Ie(e,n,a+" (Promise/async)")}),o._handled=!0)}catch(e){Ie(e,n,a)}return o}function Pe(e,r,t){if(B.errorHandler)try{return B.errorHandler.call(null,e,r,t)}catch(r){r!==e&&He(r,null,"config.errorHandler")}He(e,r,t)}function He(e,r,t){if(!H&&!M||"undefined"==typeof console)throw e;console.error(e)}var Me,Ge=!1,ze=[],Je=!1;function Ke(){Je=!1;var e=ze.slice(0);ze.length=0;for(var r=0;r<e.length;r++)e[r]()}if("undefined"!=typeof Promise&&ne(Promise)){var Ze=Promise.resolve();Me=function(){Ze.then(Ke),Y&&setTimeout(C)},Ge=!0}else if(J||"undefined"==typeof MutationObserver||!ne(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Me="undefined"!=typeof setImmediate&&ne(setImmediate)?function(){setImmediate(Ke)}:function(){setTimeout(Ke,0)};else{var Ye=1,We=new MutationObserver(Ke),Qe=document.createTextNode(String(Ye));We.observe(Qe,{characterData:!0}),Me=function(){Ye=(Ye+1)%2,Qe.data=String(Ye)},Ge=!0}function Xe(e,r){var t;if(ze.push(function(){if(e)try{e.call(r)}catch(e){Ie(e,r,"nextTick")}else t&&t(r)}),Je||(Je=!0,Me()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){t=e})}var er=new ae;function rr(e){!function e(r,t){var n,a;var i=Array.isArray(r);if(!i&&!o(r)||Object.isFrozen(r)||r instanceof fe)return;if(r.__ob__){var s=r.__ob__.dep.id;if(t.has(s))return;t.add(s)}if(i)for(n=r.length;n--;)e(r[n],t);else for(a=Object.keys(r),n=a.length;n--;)e(r[a[n]],t)}(e,er),er.clear()}var tr=b(function(e){var r="&"===e.charAt(0),t="~"===(e=r?e.slice(1):e).charAt(0),n="!"===(e=t?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:t,capture:n,passive:r}});function nr(e,r){function t(){var e=arguments,n=t.fns;if(!Array.isArray(n))return je(n,null,arguments,r,"v-on handler");for(var a=n.slice(),o=0;o<a.length;o++)je(a[o],null,e,r,"v-on handler")}return t.fns=e,t}function ar(e,t,a,o,i,s){var c,u,l,p;for(c in e)u=e[c],l=t[c],p=tr(c),r(u)||(r(l)?(r(u.fns)&&(u=e[c]=nr(u,s)),n(p.once)&&(u=e[c]=i(p.name,u,p.capture)),a(p.name,u,p.capture,p.passive,p.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)r(e[c])&&o((p=tr(c)).name,t[c],p.capture)}function or(e,a,o){var i;e instanceof fe&&(e=e.data.hook||(e.data.hook={}));var s=e[a];function c(){o.apply(this,arguments),h(i.fns,c)}r(s)?i=nr([c]):t(s.fns)&&n(s.merged)?(i=s).fns.push(c):i=nr([s,c]),i.merged=!0,e[a]=i}function ir(e,r,n,a,o){if(t(r)){if(g(r,n))return e[n]=r[n],o||delete r[n],!0;if(g(r,a))return e[n]=r[a],o||delete r[a],!0}return!1}function sr(e){return a(e)?[he(e)]:Array.isArray(e)?function e(o,i){var s=[];var c,u,l,p;for(c=0;c<o.length;c++)r(u=o[c])||"boolean"==typeof u||(l=s.length-1,p=s[l],Array.isArray(u)?u.length>0&&(cr((u=e(u,(i||"")+"_"+c))[0])&&cr(p)&&(s[l]=he(p.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?cr(p)?s[l]=he(p.text+u):""!==u&&s.push(he(u)):cr(u)&&cr(p)?s[l]=he(p.text+u.text):(n(o._isVList)&&t(u.tag)&&r(u.key)&&t(i)&&(u.key="__vlist"+i+"_"+c+"__"),s.push(u)));return s}(e):void 0}function cr(e){return t(e)&&t(e.text)&&!1===e.isComment}function ur(e,r){if(e){for(var t=Object.create(null),n=oe?Reflect.ownKeys(e):Object.keys(e),a=0;a<n.length;a++){var o=n[a];if("__ob__"!==o){for(var i=e[o].from,s=r;s;){if(s._provided&&g(s._provided,i)){t[o]=s._provided[i];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;t[o]="function"==typeof c?c.call(r):c}}}return t}}function lr(e,r){if(!e||!e.length)return{};for(var t={},n=0,a=e.length;n<a;n++){var o=e[n],i=o.data;if(i&&i.attrs&&i.attrs.slot&&delete i.attrs.slot,o.context!==r&&o.fnContext!==r||!i||null==i.slot)(t.default||(t.default=[])).push(o);else{var s=i.slot,c=t[s]||(t[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in t)t[u].every(pr)&&delete t[u];return t}function pr(e){return e.isComment&&!e.asyncFactory||" "===e.text}function fr(r,t,n){var a,o=Object.keys(t).length>0,i=r?!!r.$stable:!o,s=r&&r.$key;if(r){if(r._normalized)return r._normalized;if(i&&n&&n!==e&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in a={},r)r[c]&&"$"!==c[0]&&(a[c]=dr(t,c,r[c]))}else a={};for(var u in t)u in a||(a[u]=mr(t,u));return r&&Object.isExtensible(r)&&(r._normalized=a),V(a,"$stable",i),V(a,"$key",s),V(a,"$hasNormal",o),a}function dr(e,r,t){var n=function(){var e=arguments.length?t.apply(null,arguments):t({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:sr(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return t.proxy&&Object.defineProperty(e,r,{get:n,enumerable:!0,configurable:!0}),n}function mr(e,r){return function(){return e[r]}}function hr(e,r){var n,a,i,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,a=e.length;n<a;n++)c[n]=r(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=r(n+1,n);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(r(l.value,c.length)),l=u.next()}else for(i=Object.keys(e),c=new Array(i.length),n=0,a=i.length;n<a;n++)s=i[n],c[n]=r(e[s],s,n);return t(c)||(c=[]),c._isVList=!0,c}function vr(e,r,t,n){var a,o=this.$scopedSlots[e];o?(t=t||{},n&&(t=E(E({},n),t)),a=o(t)||r):a=this.$slots[e]||r;var i=t&&t.slot;return i?this.$createElement("template",{slot:i},a):a}function gr(e){return Oe(this.$options,"filters",e)||L}function br(e,r){return Array.isArray(e)?-1===e.indexOf(r):e!==r}function yr(e,r,t,n,a){var o=B.keyCodes[r]||t;return a&&n&&!B.keyCodes[r]?br(a,n):o?br(o,e):n?x(n)!==r:void 0}function wr(e,r,t,n,a){if(t)if(o(t)){var i;Array.isArray(t)&&(t=_(t));var s=function(o){if("class"===o||"style"===o||m(o))i=e;else{var s=e.attrs&&e.attrs.type;i=n||B.mustUseProp(r,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(o),u=x(o);c in i||u in i||(i[o]=t[o],a&&((e.on||(e.on={}))["update:"+o]=function(e){t[o]=e}))};for(var c in t)s(c)}else;return e}function Ar(e,r){var t=this._staticTrees||(this._staticTrees=[]),n=t[e];return n&&!r?n:(xr(n=t[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function Dr(e,r,t){return xr(e,"__once__"+r+(t?"_"+t:""),!0),e}function xr(e,r,t){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&qr(e[n],r+"_"+n,t);else qr(e,r,t)}function qr(e,r,t){e.isStatic=!0,e.key=r,e.isOnce=t}function kr(e,r){if(r)if(s(r)){var t=e.on=e.on?E({},e.on):{};for(var n in r){var a=t[n],o=r[n];t[n]=a?[].concat(a,o):o}}else;return e}function Er(e,r,t,n){r=r||{$stable:!t};for(var a=0;a<e.length;a++){var o=e[a];Array.isArray(o)?Er(o,r,t):o&&(o.proxy&&(o.fn.proxy=!0),r[o.key]=o.fn)}return n&&(r.$key=n),r}function _r(e,r){for(var t=0;t<r.length;t+=2){var n=r[t];"string"==typeof n&&n&&(e[r[t]]=r[t+1])}return e}function Cr(e,r){return"string"==typeof e?r+e:e}function Sr(e){e._o=Dr,e._n=p,e._s=l,e._l=hr,e._t=vr,e._q=T,e._i=$,e._m=Ar,e._f=gr,e._k=yr,e._b=wr,e._v=he,e._e=me,e._u=Er,e._g=kr,e._d=_r,e._p=Cr}function Lr(r,t,a,o,i){var s,c=this,u=i.options;g(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=n(u._compiled),p=!l;this.data=r,this.props=t,this.children=a,this.parent=o,this.listeners=r.on||e,this.injections=ur(u.inject,o),this.slots=function(){return c.$slots||fr(r.scopedSlots,c.$slots=lr(a,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return fr(r.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=fr(r.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,r,t,n){var a=Vr(s,e,r,t,n,p);return a&&!Array.isArray(a)&&(a.fnScopeId=u._scopeId,a.fnContext=o),a}:this._c=function(e,r,t,n){return Vr(s,e,r,t,n,p)}}function Tr(e,r,t,n,a){var o=ve(e);return o.fnContext=t,o.fnOptions=n,r.slot&&((o.data||(o.data={})).slot=r.slot),o}function $r(e,r){for(var t in r)e[w(t)]=r[t]}Sr(Lr.prototype);var Nr={init:function(e,r){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var n=e;Nr.prepatch(n,n)}else{(e.componentInstance=function(e,r){var n={_isComponent:!0,_parentVnode:e,parent:r},a=e.data.inlineTemplate;t(a)&&(n.render=a.render,n.staticRenderFns=a.staticRenderFns);return new e.componentOptions.Ctor(n)}(e,Zr)).$mount(r?e.elm:void 0,r)}},prepatch:function(r,t){var n=t.componentOptions;!function(r,t,n,a,o){var i=a.data.scopedSlots,s=r.$scopedSlots,c=!!(i&&!i.$stable||s!==e&&!s.$stable||i&&r.$scopedSlots.$key!==i.$key),u=!!(o||r.$options._renderChildren||c);r.$options._parentVnode=a,r.$vnode=a,r._vnode&&(r._vnode.parent=a);if(r.$options._renderChildren=o,r.$attrs=a.data.attrs||e,r.$listeners=n||e,t&&r.$options.props){Ae(!1);for(var l=r._props,p=r.$options._propKeys||[],f=0;f<p.length;f++){var d=p[f],m=r.$options.props;l[d]=Re(d,m,t,r)}Ae(!0),r.$options.propsData=t}n=n||e;var h=r.$options._parentListeners;r.$options._parentListeners=n,Kr(r,n,h),u&&(r.$slots=lr(o,a.context),r.$forceUpdate())}(t.componentInstance=r.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var r,t=e.context,n=e.componentInstance;n._isMounted||(n._isMounted=!0,Xr(n,"mounted")),e.data.keepAlive&&(t._isMounted?((r=n)._inactive=!1,rt.push(r)):Qr(n,!0))},destroy:function(e){var r=e.componentInstance;r._isDestroyed||(e.data.keepAlive?function e(r,t){if(t&&(r._directInactive=!0,Wr(r)))return;if(!r._inactive){r._inactive=!0;for(var n=0;n<r.$children.length;n++)e(r.$children[n]);Xr(r,"deactivated")}}(r,!0):r.$destroy())}},Or=Object.keys(Nr);function Rr(a,i,s,c,l){if(!r(a)){var p=s.$options._base;if(o(a)&&(a=p.extend(a)),"function"==typeof a){var f;if(r(a.cid)&&void 0===(a=function(e,a){if(n(e.error)&&t(e.errorComp))return e.errorComp;if(t(e.resolved))return e.resolved;var i=jr;i&&t(e.owners)&&-1===e.owners.indexOf(i)&&e.owners.push(i);if(n(e.loading)&&t(e.loadingComp))return e.loadingComp;if(i&&!t(e.owners)){var s=e.owners=[i],c=!0,l=null,p=null;i.$on("hook:destroyed",function(){return h(s,i)});var f=function(e){for(var r=0,t=s.length;r<t;r++)s[r].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==p&&(clearTimeout(p),p=null))},d=N(function(r){e.resolved=Pr(r,a),c?s.length=0:f(!0)}),m=N(function(r){t(e.errorComp)&&(e.error=!0,f(!0))}),v=e(d,m);return o(v)&&(u(v)?r(e.resolved)&&v.then(d,m):u(v.component)&&(v.component.then(d,m),t(v.error)&&(e.errorComp=Pr(v.error,a)),t(v.loading)&&(e.loadingComp=Pr(v.loading,a),0===v.delay?e.loading=!0:l=setTimeout(function(){l=null,r(e.resolved)&&r(e.error)&&(e.loading=!0,f(!1))},v.delay||200)),t(v.timeout)&&(p=setTimeout(function(){p=null,r(e.resolved)&&m(null)},v.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(f=a,p)))return function(e,r,t,n,a){var o=me();return o.asyncFactory=e,o.asyncMeta={data:r,context:t,children:n,tag:a},o}(f,i,s,c,l);i=i||{},At(a),t(i.model)&&function(e,r){var n=e.model&&e.model.prop||"value",a=e.model&&e.model.event||"input";(r.attrs||(r.attrs={}))[n]=r.model.value;var o=r.on||(r.on={}),i=o[a],s=r.model.callback;t(i)?(Array.isArray(i)?-1===i.indexOf(s):i!==s)&&(o[a]=[s].concat(i)):o[a]=s}(a.options,i);var d=function(e,n,a){var o=n.options.props;if(!r(o)){var i={},s=e.attrs,c=e.props;if(t(s)||t(c))for(var u in o){var l=x(u);ir(i,c,u,l,!0)||ir(i,s,u,l,!1)}return i}}(i,a);if(n(a.options.functional))return function(r,n,a,o,i){var s=r.options,c={},u=s.props;if(t(u))for(var l in u)c[l]=Re(l,u,n||e);else t(a.attrs)&&$r(c,a.attrs),t(a.props)&&$r(c,a.props);var p=new Lr(a,c,i,o,r),f=s.render.call(null,p._c,p);if(f instanceof fe)return Tr(f,a,p.parent,s);if(Array.isArray(f)){for(var d=sr(f)||[],m=new Array(d.length),h=0;h<d.length;h++)m[h]=Tr(d[h],a,p.parent,s);return m}}(a,d,i,s,c);var m=i.on;if(i.on=i.nativeOn,n(a.options.abstract)){var v=i.slot;i={},v&&(i.slot=v)}!function(e){for(var r=e.hook||(e.hook={}),t=0;t<Or.length;t++){var n=Or[t],a=r[n],o=Nr[n];a===o||a&&a._merged||(r[n]=a?Fr(o,a):o)}}(i);var g=a.options.name||l;return new fe("vue-component-"+a.cid+(g?"-"+g:""),i,void 0,void 0,void 0,s,{Ctor:a,propsData:d,listeners:m,tag:l,children:c},f)}}}function Fr(e,r){var t=function(t,n){e(t,n),r(t,n)};return t._merged=!0,t}var Br=1,Ur=2;function Vr(e,i,s,c,u,l){return(Array.isArray(s)||a(s))&&(u=c,c=s,s=void 0),n(l)&&(u=Ur),function(e,a,i,s,c){if(t(i)&&t(i.__ob__))return me();t(i)&&t(i.is)&&(a=i.is);if(!a)return me();Array.isArray(s)&&"function"==typeof s[0]&&((i=i||{}).scopedSlots={default:s[0]},s.length=0);c===Ur?s=sr(s):c===Br&&(s=function(e){for(var r=0;r<e.length;r++)if(Array.isArray(e[r]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof a){var p;l=e.$vnode&&e.$vnode.ns||B.getTagNamespace(a),u=B.isReservedTag(a)?new fe(B.parsePlatformTagName(a),i,s,void 0,void 0,e):i&&i.pre||!t(p=Oe(e.$options,"components",a))?new fe(a,i,s,void 0,void 0,e):Rr(p,i,e,s,a)}else u=Rr(a,i,e,s);return Array.isArray(u)?u:t(u)?(t(l)&&function e(a,o,i){a.ns=o;"foreignObject"===a.tag&&(o=void 0,i=!0);if(t(a.children))for(var s=0,c=a.children.length;s<c;s++){var u=a.children[s];t(u.tag)&&(r(u.ns)||n(i)&&"svg"!==u.tag)&&e(u,o,i)}}(u,l),t(i)&&function(e){o(e.style)&&rr(e.style);o(e.class)&&rr(e.class)}(i),u):me()}(e,i,s,c,u)}var Ir,jr=null;function Pr(e,r){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?r.extend(e):e}function Hr(e){return e.isComment&&e.asyncFactory}function Mr(e){if(Array.isArray(e))for(var r=0;r<e.length;r++){var n=e[r];if(t(n)&&(t(n.componentOptions)||Hr(n)))return n}}function Gr(e,r){Ir.$on(e,r)}function zr(e,r){Ir.$off(e,r)}function Jr(e,r){var t=Ir;return function n(){null!==r.apply(null,arguments)&&t.$off(e,n)}}function Kr(e,r,t){Ir=e,ar(r,t||{},Gr,zr,Jr,e),Ir=void 0}var Zr=null;function Yr(e){var r=Zr;return Zr=e,function(){Zr=r}}function Wr(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Qr(e,r){if(r){if(e._directInactive=!1,Wr(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var t=0;t<e.$children.length;t++)Qr(e.$children[t]);Xr(e,"activated")}}function Xr(e,r){le();var t=e.$options[r],n=r+" hook";if(t)for(var a=0,o=t.length;a<o;a++)je(t[a],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+r),pe()}var et=[],rt=[],tt={},nt=!1,at=!1,ot=0;var it=0,st=Date.now;if(H&&!J){var ct=window.performance;ct&&"function"==typeof ct.now&&st()>document.createEvent("Event").timeStamp&&(st=function(){return ct.now()})}function ut(){var e,r;for(it=st(),at=!0,et.sort(function(e,r){return e.id-r.id}),ot=0;ot<et.length;ot++)(e=et[ot]).before&&e.before(),r=e.id,tt[r]=null,e.run();var t=rt.slice(),n=et.slice();ot=et.length=rt.length=0,tt={},nt=at=!1,function(e){for(var r=0;r<e.length;r++)e[r]._inactive=!0,Qr(e[r],!0)}(t),function(e){var r=e.length;for(;r--;){var t=e[r],n=t.vm;n._watcher===t&&n._isMounted&&!n._isDestroyed&&Xr(n,"updated")}}(n),te&&B.devtools&&te.emit("flush")}var lt=0,pt=function(e,r,t,n,a){this.vm=e,a&&(e._watcher=this),e._watchers.push(this),n?(this.deep=!!n.deep,this.user=!!n.user,this.lazy=!!n.lazy,this.sync=!!n.sync,this.before=n.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=t,this.id=++lt,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ae,this.newDepIds=new ae,this.expression="","function"==typeof r?this.getter=r:(this.getter=function(e){if(!I.test(e)){var r=e.split(".");return function(e){for(var t=0;t<r.length;t++){if(!e)return;e=e[r[t]]}return e}}}(r),this.getter||(this.getter=C)),this.value=this.lazy?void 0:this.get()};pt.prototype.get=function(){var e;le(this);var r=this.vm;try{e=this.getter.call(r,r)}catch(e){if(!this.user)throw e;Ie(e,r,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rr(e),pe(),this.cleanupDeps()}return e},pt.prototype.addDep=function(e){var r=e.id;this.newDepIds.has(r)||(this.newDepIds.add(r),this.newDeps.push(e),this.depIds.has(r)||e.addSub(this))},pt.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var r=this.deps[e];this.newDepIds.has(r.id)||r.removeSub(this)}var t=this.depIds;this.depIds=this.newDepIds,this.newDepIds=t,this.newDepIds.clear(),t=this.deps,this.deps=this.newDeps,this.newDeps=t,this.newDeps.length=0},pt.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var r=e.id;if(null==tt[r]){if(tt[r]=!0,at){for(var t=et.length-1;t>ot&&et[t].id>e.id;)t--;et.splice(t+1,0,e)}else et.push(e);nt||(nt=!0,Xe(ut))}}(this)},pt.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var r=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,r)}catch(e){Ie(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,r)}}},pt.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},pt.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},pt.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var ft={enumerable:!0,configurable:!0,get:C,set:C};function dt(e,r,t){ft.get=function(){return this[r][t]},ft.set=function(e){this[r][t]=e},Object.defineProperty(e,t,ft)}function mt(e){e._watchers=[];var r=e.$options;r.props&&function(e,r){var t=e.$options.propsData||{},n=e._props={},a=e.$options._propKeys=[];e.$parent&&Ae(!1);var o=function(o){a.push(o);var i=Re(o,r,t,e);qe(n,o,i),o in e||dt(e,"_props",o)};for(var i in r)o(i);Ae(!0)}(e,r.props),r.methods&&function(e,r){e.$options.props;for(var t in r)e[t]="function"!=typeof r[t]?C:q(r[t],e)}(e,r.methods),r.data?function(e){var r=e.$options.data;s(r=e._data="function"==typeof r?function(e,r){le();try{return e.call(r,r)}catch(e){return Ie(e,r,"data()"),{}}finally{pe()}}(r,e):r||{})||(r={});var t=Object.keys(r),n=e.$options.props,a=(e.$options.methods,t.length);for(;a--;){var o=t[a];n&&g(n,o)||(i=void 0,36!==(i=(o+"").charCodeAt(0))&&95!==i&&dt(e,"_data",o))}var i;xe(r,!0)}(e):xe(e._data={},!0),r.computed&&function(e,r){var t=e._computedWatchers=Object.create(null),n=re();for(var a in r){var o=r[a],i="function"==typeof o?o:o.get;n||(t[a]=new pt(e,i||C,C,ht)),a in e||vt(e,a,o)}}(e,r.computed),r.watch&&r.watch!==Q&&function(e,r){for(var t in r){var n=r[t];if(Array.isArray(n))for(var a=0;a<n.length;a++)yt(e,t,n[a]);else yt(e,t,n)}}(e,r.watch)}var ht={lazy:!0};function vt(e,r,t){var n=!re();"function"==typeof t?(ft.get=n?gt(r):bt(t),ft.set=C):(ft.get=t.get?n&&!1!==t.cache?gt(r):bt(t.get):C,ft.set=t.set||C),Object.defineProperty(e,r,ft)}function gt(e){return function(){var r=this._computedWatchers&&this._computedWatchers[e];if(r)return r.dirty&&r.evaluate(),ce.target&&r.depend(),r.value}}function bt(e){return function(){return e.call(this,this)}}function yt(e,r,t,n){return s(t)&&(n=t,t=t.handler),"string"==typeof t&&(t=e[t]),e.$watch(r,t,n)}var wt=0;function At(e){var r=e.options;if(e.super){var t=At(e.super);if(t!==e.superOptions){e.superOptions=t;var n=function(e){var r,t=e.options,n=e.sealedOptions;for(var a in t)t[a]!==n[a]&&(r||(r={}),r[a]=t[a]);return r}(e);n&&E(e.extendOptions,n),(r=e.options=Ne(t,e.extendOptions)).name&&(r.components[r.name]=e)}}return r}function Dt(e){this._init(e)}function xt(e){e.cid=0;var r=1;e.extend=function(e){e=e||{};var t=this,n=t.cid,a=e._Ctor||(e._Ctor={});if(a[n])return a[n];var o=e.name||t.options.name,i=function(e){this._init(e)};return(i.prototype=Object.create(t.prototype)).constructor=i,i.cid=r++,i.options=Ne(t.options,e),i.super=t,i.options.props&&function(e){var r=e.options.props;for(var t in r)dt(e.prototype,"_props",t)}(i),i.options.computed&&function(e){var r=e.options.computed;for(var t in r)vt(e.prototype,t,r[t])}(i),i.extend=t.extend,i.mixin=t.mixin,i.use=t.use,R.forEach(function(e){i[e]=t[e]}),o&&(i.options.components[o]=i),i.superOptions=t.options,i.extendOptions=e,i.sealedOptions=E({},i.options),a[n]=i,i}}function qt(e){return e&&(e.Ctor.options.name||e.tag)}function kt(e,r){return Array.isArray(e)?e.indexOf(r)>-1:"string"==typeof e?e.split(",").indexOf(r)>-1:(t=e,"[object RegExp]"===i.call(t)&&e.test(r));var t}function Et(e,r){var t=e.cache,n=e.keys,a=e._vnode;for(var o in t){var i=t[o];if(i){var s=qt(i.componentOptions);s&&!r(s)&&_t(t,o,n,a)}}}function _t(e,r,t,n){var a=e[r];!a||n&&a.tag===n.tag||a.componentInstance.$destroy(),e[r]=null,h(t,r)}!function(r){r.prototype._init=function(r){var t=this;t._uid=wt++,t._isVue=!0,r&&r._isComponent?function(e,r){var t=e.$options=Object.create(e.constructor.options),n=r._parentVnode;t.parent=r.parent,t._parentVnode=n;var a=n.componentOptions;t.propsData=a.propsData,t._parentListeners=a.listeners,t._renderChildren=a.children,t._componentTag=a.tag,r.render&&(t.render=r.render,t.staticRenderFns=r.staticRenderFns)}(t,r):t.$options=Ne(At(t.constructor),r||{},t),t._renderProxy=t,t._self=t,function(e){var r=e.$options,t=r.parent;if(t&&!r.abstract){for(;t.$options.abstract&&t.$parent;)t=t.$parent;t.$children.push(e)}e.$parent=t,e.$root=t?t.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(t),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var r=e.$options._parentListeners;r&&Kr(e,r)}(t),function(r){r._vnode=null,r._staticTrees=null;var t=r.$options,n=r.$vnode=t._parentVnode,a=n&&n.context;r.$slots=lr(t._renderChildren,a),r.$scopedSlots=e,r._c=function(e,t,n,a){return Vr(r,e,t,n,a,!1)},r.$createElement=function(e,t,n,a){return Vr(r,e,t,n,a,!0)};var o=n&&n.data;qe(r,"$attrs",o&&o.attrs||e,null,!0),qe(r,"$listeners",t._parentListeners||e,null,!0)}(t),Xr(t,"beforeCreate"),function(e){var r=ur(e.$options.inject,e);r&&(Ae(!1),Object.keys(r).forEach(function(t){qe(e,t,r[t])}),Ae(!0))}(t),mt(t),function(e){var r=e.$options.provide;r&&(e._provided="function"==typeof r?r.call(e):r)}(t),Xr(t,"created"),t.$options.el&&t.$mount(t.$options.el)}}(Dt),function(e){var r={get:function(){return this._data}},t={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",r),Object.defineProperty(e.prototype,"$props",t),e.prototype.$set=ke,e.prototype.$delete=Ee,e.prototype.$watch=function(e,r,t){if(s(r))return yt(this,e,r,t);(t=t||{}).user=!0;var n=new pt(this,e,r,t);if(t.immediate){le();try{r.call(this,n.value)}catch(e){Ie(e,this,'callback for immediate watcher "'+n.expression+'"')}pe()}return function(){n.teardown()}}}(Dt),function(e){var r=/^hook:/;e.prototype.$on=function(e,t){var n=this;if(Array.isArray(e))for(var a=0,o=e.length;a<o;a++)n.$on(e[a],t);else(n._events[e]||(n._events[e]=[])).push(t),r.test(e)&&(n._hasHookEvent=!0);return n},e.prototype.$once=function(e,r){var t=this;function n(){t.$off(e,n),r.apply(t,arguments)}return n.fn=r,t.$on(e,n),t},e.prototype.$off=function(e,r){var t=this;if(!arguments.length)return t._events=Object.create(null),t;if(Array.isArray(e)){for(var n=0,a=e.length;n<a;n++)t.$off(e[n],r);return t}var o,i=t._events[e];if(!i)return t;if(!r)return t._events[e]=null,t;for(var s=i.length;s--;)if((o=i[s])===r||o.fn===r){i.splice(s,1);break}return t},e.prototype.$emit=function(e){var r=this._events[e];if(r){r=r.length>1?k(r):r;for(var t=k(arguments,1),n='event handler for "'+e+'"',a=0,o=r.length;a<o;a++)je(r[a],this,t,this,n)}return this}}(Dt),function(e){e.prototype._update=function(e,r){var t=this,n=t.$el,a=t._vnode,o=Yr(t);t._vnode=e,t.$el=a?t.__patch__(a,e):t.__patch__(t.$el,e,r,!1),o(),n&&(n.__vue__=null),t.$el&&(t.$el.__vue__=t),t.$vnode&&t.$parent&&t.$vnode===t.$parent._vnode&&(t.$parent.$el=t.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Xr(e,"beforeDestroy"),e._isBeingDestroyed=!0;var r=e.$parent;!r||r._isBeingDestroyed||e.$options.abstract||h(r.$children,e),e._watcher&&e._watcher.teardown();for(var t=e._watchers.length;t--;)e._watchers[t].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Xr(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(Dt),function(e){Sr(e.prototype),e.prototype.$nextTick=function(e){return Xe(e,this)},e.prototype._render=function(){var e,r=this,t=r.$options,n=t.render,a=t._parentVnode;a&&(r.$scopedSlots=fr(a.data.scopedSlots,r.$slots,r.$scopedSlots)),r.$vnode=a;try{jr=r,e=n.call(r._renderProxy,r.$createElement)}catch(t){Ie(t,r,"render"),e=r._vnode}finally{jr=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof fe||(e=me()),e.parent=a,e}}(Dt);var Ct=[String,RegExp,Array],St={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Ct,exclude:Ct,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)_t(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(r){Et(e,function(e){return kt(r,e)})}),this.$watch("exclude",function(r){Et(e,function(e){return!kt(r,e)})})},render:function(){var e=this.$slots.default,r=Mr(e),t=r&&r.componentOptions;if(t){var n=qt(t),a=this.include,o=this.exclude;if(a&&(!n||!kt(a,n))||o&&n&&kt(o,n))return r;var i=this.cache,s=this.keys,c=null==r.key?t.Ctor.cid+(t.tag?"::"+t.tag:""):r.key;i[c]?(r.componentInstance=i[c].componentInstance,h(s,c),s.push(c)):(i[c]=r,s.push(c),this.max&&s.length>parseInt(this.max)&&_t(i,s[0],s,this._vnode)),r.data.keepAlive=!0}return r||e&&e[0]}}};!function(e){var r={get:function(){return B}};Object.defineProperty(e,"config",r),e.util={warn:ie,extend:E,mergeOptions:Ne,defineReactive:qe},e.set=ke,e.delete=Ee,e.nextTick=Xe,e.observable=function(e){return xe(e),e},e.options=Object.create(null),R.forEach(function(r){e.options[r+"s"]=Object.create(null)}),e.options._base=e,E(e.options.components,St),function(e){e.use=function(e){var r=this._installedPlugins||(this._installedPlugins=[]);if(r.indexOf(e)>-1)return this;var t=k(arguments,1);return t.unshift(this),"function"==typeof e.install?e.install.apply(e,t):"function"==typeof e&&e.apply(null,t),r.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Ne(this.options,e),this}}(e),xt(e),function(e){R.forEach(function(r){e[r]=function(e,t){return t?("component"===r&&s(t)&&(t.name=t.name||e,t=this.options._base.extend(t)),"directive"===r&&"function"==typeof t&&(t={bind:t,update:t}),this.options[r+"s"][e]=t,t):this.options[r+"s"][e]}})}(e)}(Dt),Object.defineProperty(Dt.prototype,"$isServer",{get:re}),Object.defineProperty(Dt.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Dt,"FunctionalRenderContext",{value:Lr}),Dt.version="2.6.12";var Lt=f("style,class"),Tt=f("input,textarea,option,select,progress"),$t=function(e,r,t){return"value"===t&&Tt(e)&&"button"!==r||"selected"===t&&"option"===e||"checked"===t&&"input"===e||"muted"===t&&"video"===e},Nt=f("contenteditable,draggable,spellcheck"),Ot=f("events,caret,typing,plaintext-only"),Rt=function(e,r){return It(r)||"false"===r?"false":"contenteditable"===e&&Ot(r)?r:"true"},Ft=f("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Bt="http://www.w3.org/1999/xlink",Ut=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Vt=function(e){return Ut(e)?e.slice(6,e.length):""},It=function(e){return null==e||!1===e};function jt(e){for(var r=e.data,n=e,a=e;t(a.componentInstance);)(a=a.componentInstance._vnode)&&a.data&&(r=Pt(a.data,r));for(;t(n=n.parent);)n&&n.data&&(r=Pt(r,n.data));return function(e,r){if(t(e)||t(r))return Ht(e,Mt(r));return""}(r.staticClass,r.class)}function Pt(e,r){return{staticClass:Ht(e.staticClass,r.staticClass),class:t(e.class)?[e.class,r.class]:r.class}}function Ht(e,r){return e?r?e+" "+r:e:r||""}function Mt(e){return Array.isArray(e)?function(e){for(var r,n="",a=0,o=e.length;a<o;a++)t(r=Mt(e[a]))&&""!==r&&(n&&(n+=" "),n+=r);return n}(e):o(e)?function(e){var r="";for(var t in e)e[t]&&(r&&(r+=" "),r+=t);return r}(e):"string"==typeof e?e:""}var Gt={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zt=f("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Jt=f("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Kt=function(e){return zt(e)||Jt(e)};function Zt(e){return Jt(e)?"svg":"math"===e?"math":void 0}var Yt=Object.create(null);var Wt=f("text,number,password,search,email,tel,url");function Qt(e){if("string"==typeof e){var r=document.querySelector(e);return r||document.createElement("div")}return e}var Xt=Object.freeze({createElement:function(e,r){var t=document.createElement(e);return"select"!==e?t:(r.data&&r.data.attrs&&void 0!==r.data.attrs.multiple&&t.setAttribute("multiple","multiple"),t)},createElementNS:function(e,r){return document.createElementNS(Gt[e],r)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,r,t){e.insertBefore(r,t)},removeChild:function(e,r){e.removeChild(r)},appendChild:function(e,r){e.appendChild(r)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,r){e.textContent=r},setStyleScope:function(e,r){e.setAttribute(r,"")}}),en={create:function(e,r){rn(r)},update:function(e,r){e.data.ref!==r.data.ref&&(rn(e,!0),rn(r))},destroy:function(e){rn(e,!0)}};function rn(e,r){var n=e.data.ref;if(t(n)){var a=e.context,o=e.componentInstance||e.elm,i=a.$refs;r?Array.isArray(i[n])?h(i[n],o):i[n]===o&&(i[n]=void 0):e.data.refInFor?Array.isArray(i[n])?i[n].indexOf(o)<0&&i[n].push(o):i[n]=[o]:i[n]=o}}var tn=new fe("",{},[]),nn=["create","activate","update","remove","destroy"];function an(e,a){return e.key===a.key&&(e.tag===a.tag&&e.isComment===a.isComment&&t(e.data)===t(a.data)&&function(e,r){if("input"!==e.tag)return!0;var n,a=t(n=e.data)&&t(n=n.attrs)&&n.type,o=t(n=r.data)&&t(n=n.attrs)&&n.type;return a===o||Wt(a)&&Wt(o)}(e,a)||n(e.isAsyncPlaceholder)&&e.asyncFactory===a.asyncFactory&&r(a.asyncFactory.error))}function on(e,r,n){var a,o,i={};for(a=r;a<=n;++a)t(o=e[a].key)&&(i[o]=a);return i}var sn={create:cn,update:cn,destroy:function(e){cn(e,tn)}};function cn(e,r){(e.data.directives||r.data.directives)&&function(e,r){var t,n,a,o=e===tn,i=r===tn,s=ln(e.data.directives,e.context),c=ln(r.data.directives,r.context),u=[],l=[];for(t in c)n=s[t],a=c[t],n?(a.oldValue=n.value,a.oldArg=n.arg,fn(a,"update",r,e),a.def&&a.def.componentUpdated&&l.push(a)):(fn(a,"bind",r,e),a.def&&a.def.inserted&&u.push(a));if(u.length){var p=function(){for(var t=0;t<u.length;t++)fn(u[t],"inserted",r,e)};o?or(r,"insert",p):p()}l.length&&or(r,"postpatch",function(){for(var t=0;t<l.length;t++)fn(l[t],"componentUpdated",r,e)});if(!o)for(t in s)c[t]||fn(s[t],"unbind",e,e,i)}(e,r)}var un=Object.create(null);function ln(e,r){var t,n,a=Object.create(null);if(!e)return a;for(t=0;t<e.length;t++)(n=e[t]).modifiers||(n.modifiers=un),a[pn(n)]=n,n.def=Oe(r.$options,"directives",n.name);return a}function pn(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fn(e,r,t,n,a){var o=e.def&&e.def[r];if(o)try{o(t.elm,e,t,n,a)}catch(n){Ie(n,t.context,"directive "+e.name+" "+r+" hook")}}var dn=[en,sn];function mn(e,n){var a=n.componentOptions;if(!(t(a)&&!1===a.Ctor.options.inheritAttrs||r(e.data.attrs)&&r(n.data.attrs))){var o,i,s=n.elm,c=e.data.attrs||{},u=n.data.attrs||{};for(o in t(u.__ob__)&&(u=n.data.attrs=E({},u)),u)i=u[o],c[o]!==i&&hn(s,o,i,n.data.pre);for(o in(J||Z)&&u.value!==c.value&&hn(s,"value",u.value),c)r(u[o])&&(Ut(o)?s.removeAttributeNS(Bt,Vt(o)):Nt(o)||s.removeAttribute(o))}}function hn(e,r,t,n){n||e.tagName.indexOf("-")>-1?vn(e,r,t):Ft(r)?It(t)?e.removeAttribute(r):(t="allowfullscreen"===r&&"EMBED"===e.tagName?"true":r,e.setAttribute(r,t)):Nt(r)?e.setAttribute(r,Rt(r,t)):Ut(r)?It(t)?e.removeAttributeNS(Bt,Vt(r)):e.setAttributeNS(Bt,r,t):vn(e,r,t)}function vn(e,r,t){if(It(t))e.removeAttribute(r);else{if(J&&!K&&"TEXTAREA"===e.tagName&&"placeholder"===r&&""!==t&&!e.__ieph){var n=function(r){r.stopImmediatePropagation(),e.removeEventListener("input",n)};e.addEventListener("input",n),e.__ieph=!0}e.setAttribute(r,t)}}var gn={create:mn,update:mn};function bn(e,n){var a=n.elm,o=n.data,i=e.data;if(!(r(o.staticClass)&&r(o.class)&&(r(i)||r(i.staticClass)&&r(i.class)))){var s=jt(n),c=a._transitionClasses;t(c)&&(s=Ht(s,Mt(c))),s!==a._prevClass&&(a.setAttribute("class",s),a._prevClass=s)}}var yn,wn,An,Dn,xn,qn,kn={create:bn,update:bn},En=/[\w).+\-_$\]]/;function _n(e){var r,t,n,a,o,i=!1,s=!1,c=!1,u=!1,l=0,p=0,f=0,d=0;for(n=0;n<e.length;n++)if(t=r,r=e.charCodeAt(n),i)39===r&&92!==t&&(i=!1);else if(s)34===r&&92!==t&&(s=!1);else if(c)96===r&&92!==t&&(c=!1);else if(u)47===r&&92!==t&&(u=!1);else if(124!==r||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||p||f){switch(r){case 34:s=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:f++;break;case 41:f--;break;case 91:p++;break;case 93:p--;break;case 123:l++;break;case 125:l--}if(47===r){for(var m=n-1,h=void 0;m>=0&&" "===(h=e.charAt(m));m--);h&&En.test(h)||(u=!0)}}else void 0===a?(d=n+1,a=e.slice(0,n).trim()):v();function v(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===a?a=e.slice(0,n).trim():0!==d&&v(),o)for(n=0;n<o.length;n++)a=Cn(a,o[n]);return a}function Cn(e,r){var t=r.indexOf("(");if(t<0)return'_f("'+r+'")('+e+")";var n=r.slice(0,t),a=r.slice(t+1);return'_f("'+n+'")('+e+(")"!==a?","+a:a)}function Sn(e,r){console.error("[Vue compiler]: "+e)}function Ln(e,r){return e?e.map(function(e){return e[r]}).filter(function(e){return e}):[]}function Tn(e,r,t,n,a){(e.props||(e.props=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function $n(e,r,t,n,a){(a?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function Nn(e,r,t,n){e.attrsMap[r]=t,e.attrsList.push(In({name:r,value:t},n))}function On(e,r,t,n,a,o,i,s){(e.directives||(e.directives=[])).push(In({name:r,rawName:t,value:n,arg:a,isDynamicArg:o,modifiers:i},s)),e.plain=!1}function Rn(e,r,t){return t?"_p("+r+',"'+e+'")':e+r}function Fn(r,t,n,a,o,i,s,c){var u;(a=a||e).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete a.right):a.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),a.capture&&(delete a.capture,t=Rn("!",t,c)),a.once&&(delete a.once,t=Rn("~",t,c)),a.passive&&(delete a.passive,t=Rn("&",t,c)),a.native?(delete a.native,u=r.nativeEvents||(r.nativeEvents={})):u=r.events||(r.events={});var l=In({value:n.trim(),dynamic:c},s);a!==e&&(l.modifiers=a);var p=u[t];Array.isArray(p)?o?p.unshift(l):p.push(l):u[t]=p?o?[l,p]:[p,l]:l,r.plain=!1}function Bn(e,r,t){var n=Un(e,":"+r)||Un(e,"v-bind:"+r);if(null!=n)return _n(n);if(!1!==t){var a=Un(e,r);if(null!=a)return JSON.stringify(a)}}function Un(e,r,t){var n;if(null!=(n=e.attrsMap[r]))for(var a=e.attrsList,o=0,i=a.length;o<i;o++)if(a[o].name===r){a.splice(o,1);break}return t&&delete e.attrsMap[r],n}function Vn(e,r){for(var t=e.attrsList,n=0,a=t.length;n<a;n++){var o=t[n];if(r.test(o.name))return t.splice(n,1),o}}function In(e,r){return r&&(null!=r.start&&(e.start=r.start),null!=r.end&&(e.end=r.end)),e}function jn(e,r,t){var n=t||{},a=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),a&&(o="_n("+o+")");var i=Pn(r,o);e.model={value:"("+r+")",expression:JSON.stringify(r),callback:"function ($$v) {"+i+"}"}}function Pn(e,r){var t=function(e){if(e=e.trim(),yn=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<yn-1)return(Dn=e.lastIndexOf("."))>-1?{exp:e.slice(0,Dn),key:'"'+e.slice(Dn+1)+'"'}:{exp:e,key:null};wn=e,Dn=xn=qn=0;for(;!Mn();)Gn(An=Hn())?Jn(An):91===An&&zn(An);return{exp:e.slice(0,xn),key:e.slice(xn+1,qn)}}(e);return null===t.key?e+"="+r:"$set("+t.exp+", "+t.key+", "+r+")"}function Hn(){return wn.charCodeAt(++Dn)}function Mn(){return Dn>=yn}function Gn(e){return 34===e||39===e}function zn(e){var r=1;for(xn=Dn;!Mn();)if(Gn(e=Hn()))Jn(e);else if(91===e&&r++,93===e&&r--,0===r){qn=Dn;break}}function Jn(e){for(var r=e;!Mn()&&(e=Hn())!==r;);}var Kn,Zn="__r",Yn="__c";function Wn(e,r,t){var n=Kn;return function a(){null!==r.apply(null,arguments)&&ea(e,a,t,n)}}var Qn=Ge&&!(W&&Number(W[1])<=53);function Xn(e,r,t,n){if(Qn){var a=it,o=r;r=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=a||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Kn.addEventListener(e,r,X?{capture:t,passive:n}:t)}function ea(e,r,t,n){(n||Kn).removeEventListener(e,r._wrapper||r,t)}function ra(e,n){if(!r(e.data.on)||!r(n.data.on)){var a=n.data.on||{},o=e.data.on||{};Kn=n.elm,function(e){if(t(e[Zn])){var r=J?"change":"input";e[r]=[].concat(e[Zn],e[r]||[]),delete e[Zn]}t(e[Yn])&&(e.change=[].concat(e[Yn],e.change||[]),delete e[Yn])}(a),ar(a,o,Xn,ea,Wn,n.context),Kn=void 0}}var ta,na={create:ra,update:ra};function aa(e,n){if(!r(e.data.domProps)||!r(n.data.domProps)){var a,o,i=n.elm,s=e.data.domProps||{},c=n.data.domProps||{};for(a in t(c.__ob__)&&(c=n.data.domProps=E({},c)),s)a in c||(i[a]="");for(a in c){if(o=c[a],"textContent"===a||"innerHTML"===a){if(n.children&&(n.children.length=0),o===s[a])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===a&&"PROGRESS"!==i.tagName){i._value=o;var u=r(o)?"":String(o);oa(i,u)&&(i.value=u)}else if("innerHTML"===a&&Jt(i.tagName)&&r(i.innerHTML)){(ta=ta||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ta.firstChild;i.firstChild;)i.removeChild(i.firstChild);for(;l.firstChild;)i.appendChild(l.firstChild)}else if(o!==s[a])try{i[a]=o}catch(e){}}}}function oa(e,r){return!e.composing&&("OPTION"===e.tagName||function(e,r){var t=!0;try{t=document.activeElement!==e}catch(e){}return t&&e.value!==r}(e,r)||function(e,r){var n=e.value,a=e._vModifiers;if(t(a)){if(a.number)return p(n)!==p(r);if(a.trim)return n.trim()!==r.trim()}return n!==r}(e,r))}var ia={create:aa,update:aa},sa=b(function(e){var r={},t=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(t);n.length>1&&(r[n[0].trim()]=n[1].trim())}}),r});function ca(e){var r=ua(e.style);return e.staticStyle?E(e.staticStyle,r):r}function ua(e){return Array.isArray(e)?_(e):"string"==typeof e?sa(e):e}var la,pa=/^--/,fa=/\s*!important$/,da=function(e,r,t){if(pa.test(r))e.style.setProperty(r,t);else if(fa.test(t))e.style.setProperty(x(r),t.replace(fa,""),"important");else{var n=ha(r);if(Array.isArray(t))for(var a=0,o=t.length;a<o;a++)e.style[n]=t[a];else e.style[n]=t}},ma=["Webkit","Moz","ms"],ha=b(function(e){if(la=la||document.createElement("div").style,"filter"!==(e=w(e))&&e in la)return e;for(var r=e.charAt(0).toUpperCase()+e.slice(1),t=0;t<ma.length;t++){var n=ma[t]+r;if(n in la)return n}});function va(e,n){var a=n.data,o=e.data;if(!(r(a.staticStyle)&&r(a.style)&&r(o.staticStyle)&&r(o.style))){var i,s,c=n.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},p=u||l,f=ua(n.data.style)||{};n.data.normalizedStyle=t(f.__ob__)?E({},f):f;var d=function(e,r){var t,n={};if(r)for(var a=e;a.componentInstance;)(a=a.componentInstance._vnode)&&a.data&&(t=ca(a.data))&&E(n,t);(t=ca(e.data))&&E(n,t);for(var o=e;o=o.parent;)o.data&&(t=ca(o.data))&&E(n,t);return n}(n,!0);for(s in p)r(d[s])&&da(c,s,"");for(s in d)(i=d[s])!==p[s]&&da(c,s,null==i?"":i)}}var ga={create:va,update:va},ba=/\s+/;function ya(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.add(r)}):e.classList.add(r);else{var t=" "+(e.getAttribute("class")||"")+" ";t.indexOf(" "+r+" ")<0&&e.setAttribute("class",(t+r).trim())}}function wa(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.remove(r)}):e.classList.remove(r),e.classList.length||e.removeAttribute("class");else{for(var t=" "+(e.getAttribute("class")||"")+" ",n=" "+r+" ";t.indexOf(n)>=0;)t=t.replace(n," ");(t=t.trim())?e.setAttribute("class",t):e.removeAttribute("class")}}function Aa(e){if(e){if("object"==typeof e){var r={};return!1!==e.css&&E(r,Da(e.name||"v")),E(r,e),r}return"string"==typeof e?Da(e):void 0}}var Da=b(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),xa=H&&!K,qa="transition",ka="animation",Ea="transition",_a="transitionend",Ca="animation",Sa="animationend";xa&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ea="WebkitTransition",_a="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ca="WebkitAnimation",Sa="webkitAnimationEnd"));var La=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ta(e){La(function(){La(e)})}function $a(e,r){var t=e._transitionClasses||(e._transitionClasses=[]);t.indexOf(r)<0&&(t.push(r),ya(e,r))}function Na(e,r){e._transitionClasses&&h(e._transitionClasses,r),wa(e,r)}function Oa(e,r,t){var n=Fa(e,r),a=n.type,o=n.timeout,i=n.propCount;if(!a)return t();var s=a===qa?_a:Sa,c=0,u=function(){e.removeEventListener(s,l),t()},l=function(r){r.target===e&&++c>=i&&u()};setTimeout(function(){c<i&&u()},o+1),e.addEventListener(s,l)}var Ra=/\b(transform|all)(,|$)/;function Fa(e,r){var t,n=window.getComputedStyle(e),a=(n[Ea+"Delay"]||"").split(", "),o=(n[Ea+"Duration"]||"").split(", "),i=Ba(a,o),s=(n[Ca+"Delay"]||"").split(", "),c=(n[Ca+"Duration"]||"").split(", "),u=Ba(s,c),l=0,p=0;return r===qa?i>0&&(t=qa,l=i,p=o.length):r===ka?u>0&&(t=ka,l=u,p=c.length):p=(t=(l=Math.max(i,u))>0?i>u?qa:ka:null)?t===qa?o.length:c.length:0,{type:t,timeout:l,propCount:p,hasTransform:t===qa&&Ra.test(n[Ea+"Property"])}}function Ba(e,r){for(;e.length<r.length;)e=e.concat(e);return Math.max.apply(null,r.map(function(r,t){return Ua(r)+Ua(e[t])}))}function Ua(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Va(e,n){var a=e.elm;t(a._leaveCb)&&(a._leaveCb.cancelled=!0,a._leaveCb());var i=Aa(e.data.transition);if(!r(i)&&!t(a._enterCb)&&1===a.nodeType){for(var s=i.css,c=i.type,u=i.enterClass,l=i.enterToClass,f=i.enterActiveClass,d=i.appearClass,m=i.appearToClass,h=i.appearActiveClass,v=i.beforeEnter,g=i.enter,b=i.afterEnter,y=i.enterCancelled,w=i.beforeAppear,A=i.appear,D=i.afterAppear,x=i.appearCancelled,q=i.duration,k=Zr,E=Zr.$vnode;E&&E.parent;)k=E.context,E=E.parent;var _=!k._isMounted||!e.isRootInsert;if(!_||A||""===A){var C=_&&d?d:u,S=_&&h?h:f,L=_&&m?m:l,T=_&&w||v,$=_&&"function"==typeof A?A:g,O=_&&D||b,R=_&&x||y,F=p(o(q)?q.enter:q),B=!1!==s&&!K,U=Pa($),V=a._enterCb=N(function(){B&&(Na(a,L),Na(a,S)),V.cancelled?(B&&Na(a,C),R&&R(a)):O&&O(a),a._enterCb=null});e.data.show||or(e,"insert",function(){var r=a.parentNode,t=r&&r._pending&&r._pending[e.key];t&&t.tag===e.tag&&t.elm._leaveCb&&t.elm._leaveCb(),$&&$(a,V)}),T&&T(a),B&&($a(a,C),$a(a,S),Ta(function(){Na(a,C),V.cancelled||($a(a,L),U||(ja(F)?setTimeout(V,F):Oa(a,c,V)))})),e.data.show&&(n&&n(),$&&$(a,V)),B||U||V()}}}function Ia(e,n){var a=e.elm;t(a._enterCb)&&(a._enterCb.cancelled=!0,a._enterCb());var i=Aa(e.data.transition);if(r(i)||1!==a.nodeType)return n();if(!t(a._leaveCb)){var s=i.css,c=i.type,u=i.leaveClass,l=i.leaveToClass,f=i.leaveActiveClass,d=i.beforeLeave,m=i.leave,h=i.afterLeave,v=i.leaveCancelled,g=i.delayLeave,b=i.duration,y=!1!==s&&!K,w=Pa(m),A=p(o(b)?b.leave:b),D=a._leaveCb=N(function(){a.parentNode&&a.parentNode._pending&&(a.parentNode._pending[e.key]=null),y&&(Na(a,l),Na(a,f)),D.cancelled?(y&&Na(a,u),v&&v(a)):(n(),h&&h(a)),a._leaveCb=null});g?g(x):x()}function x(){D.cancelled||(!e.data.show&&a.parentNode&&((a.parentNode._pending||(a.parentNode._pending={}))[e.key]=e),d&&d(a),y&&($a(a,u),$a(a,f),Ta(function(){Na(a,u),D.cancelled||($a(a,l),w||(ja(A)?setTimeout(D,A):Oa(a,c,D)))})),m&&m(a,D),y||w||D())}}function ja(e){return"number"==typeof e&&!isNaN(e)}function Pa(e){if(r(e))return!1;var n=e.fns;return t(n)?Pa(Array.isArray(n)?n[0]:n):(e._length||e.length)>1}function Ha(e,r){!0!==r.data.show&&Va(r)}var Ma=function(e){var o,i,s={},c=e.modules,u=e.nodeOps;for(o=0;o<nn.length;++o)for(s[nn[o]]=[],i=0;i<c.length;++i)t(c[i][nn[o]])&&s[nn[o]].push(c[i][nn[o]]);function l(e){var r=u.parentNode(e);t(r)&&u.removeChild(r,e)}function p(e,r,a,o,i,c,l){if(t(e.elm)&&t(c)&&(e=c[l]=ve(e)),e.isRootInsert=!i,!function(e,r,a,o){var i=e.data;if(t(i)){var c=t(e.componentInstance)&&i.keepAlive;if(t(i=i.hook)&&t(i=i.init)&&i(e,!1),t(e.componentInstance))return d(e,r),m(a,e.elm,o),n(c)&&function(e,r,n,a){for(var o,i=e;i.componentInstance;)if(i=i.componentInstance._vnode,t(o=i.data)&&t(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](tn,i);r.push(i);break}m(n,e.elm,a)}(e,r,a,o),!0}}(e,r,a,o)){var p=e.data,f=e.children,v=e.tag;t(v)?(e.elm=e.ns?u.createElementNS(e.ns,v):u.createElement(v,e),b(e),h(e,f,r),t(p)&&g(e,r),m(a,e.elm,o)):n(e.isComment)?(e.elm=u.createComment(e.text),m(a,e.elm,o)):(e.elm=u.createTextNode(e.text),m(a,e.elm,o))}}function d(e,r){t(e.data.pendingInsert)&&(r.push.apply(r,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,v(e)?(g(e,r),b(e)):(rn(e),r.push(e))}function m(e,r,n){t(e)&&(t(n)?u.parentNode(n)===e&&u.insertBefore(e,r,n):u.appendChild(e,r))}function h(e,r,t){if(Array.isArray(r))for(var n=0;n<r.length;++n)p(r[n],t,e.elm,null,!0,r,n);else a(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function v(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return t(e.tag)}function g(e,r){for(var n=0;n<s.create.length;++n)s.create[n](tn,e);t(o=e.data.hook)&&(t(o.create)&&o.create(tn,e),t(o.insert)&&r.push(e))}function b(e){var r;if(t(r=e.fnScopeId))u.setStyleScope(e.elm,r);else for(var n=e;n;)t(r=n.context)&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r),n=n.parent;t(r=Zr)&&r!==e.context&&r!==e.fnContext&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r)}function y(e,r,t,n,a,o){for(;n<=a;++n)p(t[n],o,e,r,!1,t,n)}function w(e){var r,n,a=e.data;if(t(a))for(t(r=a.hook)&&t(r=r.destroy)&&r(e),r=0;r<s.destroy.length;++r)s.destroy[r](e);if(t(r=e.children))for(n=0;n<e.children.length;++n)w(e.children[n])}function A(e,r,n){for(;r<=n;++r){var a=e[r];t(a)&&(t(a.tag)?(D(a),w(a)):l(a.elm))}}function D(e,r){if(t(r)||t(e.data)){var n,a=s.remove.length+1;for(t(r)?r.listeners+=a:r=function(e,r){function t(){0==--t.listeners&&l(e)}return t.listeners=r,t}(e.elm,a),t(n=e.componentInstance)&&t(n=n._vnode)&&t(n.data)&&D(n,r),n=0;n<s.remove.length;++n)s.remove[n](e,r);t(n=e.data.hook)&&t(n=n.remove)?n(e,r):r()}else l(e.elm)}function x(e,r,n,a){for(var o=n;o<a;o++){var i=r[o];if(t(i)&&an(e,i))return o}}function q(e,a,o,i,c,l){if(e!==a){t(a.elm)&&t(i)&&(a=i[c]=ve(a));var f=a.elm=e.elm;if(n(e.isAsyncPlaceholder))t(a.asyncFactory.resolved)?_(e.elm,a,o):a.isAsyncPlaceholder=!0;else if(n(a.isStatic)&&n(e.isStatic)&&a.key===e.key&&(n(a.isCloned)||n(a.isOnce)))a.componentInstance=e.componentInstance;else{var d,m=a.data;t(m)&&t(d=m.hook)&&t(d=d.prepatch)&&d(e,a);var h=e.children,g=a.children;if(t(m)&&v(a)){for(d=0;d<s.update.length;++d)s.update[d](e,a);t(d=m.hook)&&t(d=d.update)&&d(e,a)}r(a.text)?t(h)&&t(g)?h!==g&&function(e,n,a,o,i){for(var s,c,l,f=0,d=0,m=n.length-1,h=n[0],v=n[m],g=a.length-1,b=a[0],w=a[g],D=!i;f<=m&&d<=g;)r(h)?h=n[++f]:r(v)?v=n[--m]:an(h,b)?(q(h,b,o,a,d),h=n[++f],b=a[++d]):an(v,w)?(q(v,w,o,a,g),v=n[--m],w=a[--g]):an(h,w)?(q(h,w,o,a,g),D&&u.insertBefore(e,h.elm,u.nextSibling(v.elm)),h=n[++f],w=a[--g]):an(v,b)?(q(v,b,o,a,d),D&&u.insertBefore(e,v.elm,h.elm),v=n[--m],b=a[++d]):(r(s)&&(s=on(n,f,m)),r(c=t(b.key)?s[b.key]:x(b,n,f,m))?p(b,o,e,h.elm,!1,a,d):an(l=n[c],b)?(q(l,b,o,a,d),n[c]=void 0,D&&u.insertBefore(e,l.elm,h.elm)):p(b,o,e,h.elm,!1,a,d),b=a[++d]);f>m?y(e,r(a[g+1])?null:a[g+1].elm,a,d,g,o):d>g&&A(n,f,m)}(f,h,g,o,l):t(g)?(t(e.text)&&u.setTextContent(f,""),y(f,null,g,0,g.length-1,o)):t(h)?A(h,0,h.length-1):t(e.text)&&u.setTextContent(f,""):e.text!==a.text&&u.setTextContent(f,a.text),t(m)&&t(d=m.hook)&&t(d=d.postpatch)&&d(e,a)}}}function k(e,r,a){if(n(a)&&t(e.parent))e.parent.data.pendingInsert=r;else for(var o=0;o<r.length;++o)r[o].data.hook.insert(r[o])}var E=f("attrs,class,staticClass,staticStyle,key");function _(e,r,a,o){var i,s=r.tag,c=r.data,u=r.children;if(o=o||c&&c.pre,r.elm=e,n(r.isComment)&&t(r.asyncFactory))return r.isAsyncPlaceholder=!0,!0;if(t(c)&&(t(i=c.hook)&&t(i=i.init)&&i(r,!0),t(i=r.componentInstance)))return d(r,a),!0;if(t(s)){if(t(u))if(e.hasChildNodes())if(t(i=c)&&t(i=i.domProps)&&t(i=i.innerHTML)){if(i!==e.innerHTML)return!1}else{for(var l=!0,p=e.firstChild,f=0;f<u.length;f++){if(!p||!_(p,u[f],a,o)){l=!1;break}p=p.nextSibling}if(!l||p)return!1}else h(r,u,a);if(t(c)){var m=!1;for(var v in c)if(!E(v)){m=!0,g(r,a);break}!m&&c.class&&rr(c.class)}}else e.data!==r.text&&(e.data=r.text);return!0}return function(e,a,o,i){if(!r(a)){var c,l=!1,f=[];if(r(e))l=!0,p(a,f);else{var d=t(e.nodeType);if(!d&&an(e,a))q(e,a,f,null,null,i);else{if(d){if(1===e.nodeType&&e.hasAttribute(O)&&(e.removeAttribute(O),o=!0),n(o)&&_(e,a,f))return k(a,f,!0),e;c=e,e=new fe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var m=e.elm,h=u.parentNode(m);if(p(a,f,m._leaveCb?null:h,u.nextSibling(m)),t(a.parent))for(var g=a.parent,b=v(a);g;){for(var y=0;y<s.destroy.length;++y)s.destroy[y](g);if(g.elm=a.elm,b){for(var D=0;D<s.create.length;++D)s.create[D](tn,g);var x=g.data.hook.insert;if(x.merged)for(var E=1;E<x.fns.length;E++)x.fns[E]()}else rn(g);g=g.parent}t(h)?A([e],0,0):t(e.tag)&&w(e)}}return k(a,f,l),a.elm}t(e)&&w(e)}}({nodeOps:Xt,modules:[gn,kn,na,ia,ga,H?{create:Ha,activate:Ha,remove:function(e,r){!0!==e.data.show?Ia(e,r):r()}}:{}].concat(dn)});K&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Qa(e,"input")});var Ga={inserted:function(e,r,t,n){"select"===t.tag?(n.elm&&!n.elm._vOptions?or(t,"postpatch",function(){Ga.componentUpdated(e,r,t)}):za(e,r,t.context),e._vOptions=[].map.call(e.options,Za)):("textarea"===t.tag||Wt(e.type))&&(e._vModifiers=r.modifiers,r.modifiers.lazy||(e.addEventListener("compositionstart",Ya),e.addEventListener("compositionend",Wa),e.addEventListener("change",Wa),K&&(e.vmodel=!0)))},componentUpdated:function(e,r,t){if("select"===t.tag){za(e,r,t.context);var n=e._vOptions,a=e._vOptions=[].map.call(e.options,Za);if(a.some(function(e,r){return!T(e,n[r])}))(e.multiple?r.value.some(function(e){return Ka(e,a)}):r.value!==r.oldValue&&Ka(r.value,a))&&Qa(e,"change")}}};function za(e,r,t){Ja(e,r,t),(J||Z)&&setTimeout(function(){Ja(e,r,t)},0)}function Ja(e,r,t){var n=r.value,a=e.multiple;if(!a||Array.isArray(n)){for(var o,i,s=0,c=e.options.length;s<c;s++)if(i=e.options[s],a)o=$(n,Za(i))>-1,i.selected!==o&&(i.selected=o);else if(T(Za(i),n))return void(e.selectedIndex!==s&&(e.selectedIndex=s));a||(e.selectedIndex=-1)}}function Ka(e,r){return r.every(function(r){return!T(r,e)})}function Za(e){return"_value"in e?e._value:e.value}function Ya(e){e.target.composing=!0}function Wa(e){e.target.composing&&(e.target.composing=!1,Qa(e.target,"input"))}function Qa(e,r){var t=document.createEvent("HTMLEvents");t.initEvent(r,!0,!0),e.dispatchEvent(t)}function Xa(e){return!e.componentInstance||e.data&&e.data.transition?e:Xa(e.componentInstance._vnode)}var eo={model:Ga,show:{bind:function(e,r,t){var n=r.value,a=(t=Xa(t)).data&&t.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;n&&a?(t.data.show=!0,Va(t,function(){e.style.display=o})):e.style.display=n?o:"none"},update:function(e,r,t){var n=r.value;!n!=!r.oldValue&&((t=Xa(t)).data&&t.data.transition?(t.data.show=!0,n?Va(t,function(){e.style.display=e.__vOriginalDisplay}):Ia(t,function(){e.style.display="none"})):e.style.display=n?e.__vOriginalDisplay:"none")},unbind:function(e,r,t,n,a){a||(e.style.display=e.__vOriginalDisplay)}}},ro={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var r=e&&e.componentOptions;return r&&r.Ctor.options.abstract?to(Mr(r.children)):e}function no(e){var r={},t=e.$options;for(var n in t.propsData)r[n]=e[n];var a=t._parentListeners;for(var o in a)r[w(o)]=a[o];return r}function ao(e,r){if(/\d-keep-alive$/.test(r.tag))return e("keep-alive",{props:r.componentOptions.propsData})}var oo=function(e){return e.tag||Hr(e)},io=function(e){return"show"===e.name},so={name:"transition",props:ro,abstract:!0,render:function(e){var r=this,t=this.$slots.default;if(t&&(t=t.filter(oo)).length){var n=this.mode,o=t[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var i=to(o);if(!i)return o;if(this._leaving)return ao(e,o);var s="__transition-"+this._uid+"-";i.key=null==i.key?i.isComment?s+"comment":s+i.tag:a(i.key)?0===String(i.key).indexOf(s)?i.key:s+i.key:i.key;var c=(i.data||(i.data={})).transition=no(this),u=this._vnode,l=to(u);if(i.data.directives&&i.data.directives.some(io)&&(i.data.show=!0),l&&l.data&&!function(e,r){return r.key===e.key&&r.tag===e.tag}(i,l)&&!Hr(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var p=l.data.transition=E({},c);if("out-in"===n)return this._leaving=!0,or(p,"afterLeave",function(){r._leaving=!1,r.$forceUpdate()}),ao(e,o);if("in-out"===n){if(Hr(i))return u;var f,d=function(){f()};or(c,"afterEnter",d),or(c,"enterCancelled",d),or(p,"delayLeave",function(e){f=e})}}return o}}},co=E({tag:String,moveClass:String},ro);function uo(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function lo(e){e.data.newPos=e.elm.getBoundingClientRect()}function po(e){var r=e.data.pos,t=e.data.newPos,n=r.left-t.left,a=r.top-t.top;if(n||a){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+n+"px,"+a+"px)",o.transitionDuration="0s"}}delete co.mode;var fo={Transition:so,TransitionGroup:{props:co,beforeMount:function(){var e=this,r=this._update;this._update=function(t,n){var a=Yr(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,a(),r.call(e,t,n)}},render:function(e){for(var r=this.tag||this.$vnode.data.tag||"span",t=Object.create(null),n=this.prevChildren=this.children,a=this.$slots.default||[],o=this.children=[],i=no(this),s=0;s<a.length;s++){var c=a[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),t[c.key]=c,(c.data||(c.data={})).transition=i)}if(n){for(var u=[],l=[],p=0;p<n.length;p++){var f=n[p];f.data.transition=i,f.data.pos=f.elm.getBoundingClientRect(),t[f.key]?u.push(f):l.push(f)}this.kept=e(r,null,u),this.removed=l}return e(r,null,o)},updated:function(){var e=this.prevChildren,r=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,r)&&(e.forEach(uo),e.forEach(lo),e.forEach(po),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var t=e.elm,n=t.style;$a(t,r),n.transform=n.WebkitTransform=n.transitionDuration="",t.addEventListener(_a,t._moveCb=function e(n){n&&n.target!==t||n&&!/transform$/.test(n.propertyName)||(t.removeEventListener(_a,e),t._moveCb=null,Na(t,r))})}}))},methods:{hasMove:function(e,r){if(!xa)return!1;if(this._hasMove)return this._hasMove;var t=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){wa(t,e)}),ya(t,r),t.style.display="none",this.$el.appendChild(t);var n=Fa(t);return this.$el.removeChild(t),this._hasMove=n.hasTransform}}}};Dt.config.mustUseProp=$t,Dt.config.isReservedTag=Kt,Dt.config.isReservedAttr=Lt,Dt.config.getTagNamespace=Zt,Dt.config.isUnknownElement=function(e){if(!H)return!0;if(Kt(e))return!1;if(e=e.toLowerCase(),null!=Yt[e])return Yt[e];var r=document.createElement(e);return e.indexOf("-")>-1?Yt[e]=r.constructor===window.HTMLUnknownElement||r.constructor===window.HTMLElement:Yt[e]=/HTMLUnknownElement/.test(r.toString())},E(Dt.options.directives,eo),E(Dt.options.components,fo),Dt.prototype.__patch__=H?Ma:C,Dt.prototype.$mount=function(e,r){return function(e,r,t){var n;return e.$el=r,e.$options.render||(e.$options.render=me),Xr(e,"beforeMount"),n=function(){e._update(e._render(),t)},new pt(e,n,C,{before:function(){e._isMounted&&!e._isDestroyed&&Xr(e,"beforeUpdate")}},!0),t=!1,null==e.$vnode&&(e._isMounted=!0,Xr(e,"mounted")),e}(this,e=e&&H?Qt(e):void 0,r)},H&&setTimeout(function(){B.devtools&&te&&te.emit("init",Dt)},0);var mo=/\{\{((?:.|\r?\n)+?)\}\}/g,ho=/[-.*+?^${}()|[\]\/\\]/g,vo=b(function(e){var r=e[0].replace(ho,"\\$&"),t=e[1].replace(ho,"\\$&");return new RegExp(r+"((?:.|\\n)+?)"+t,"g")});var go={staticKeys:["staticClass"],transformNode:function(e,r){r.warn;var t=Un(e,"class");t&&(e.staticClass=JSON.stringify(t));var n=Bn(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var r="";return e.staticClass&&(r+="staticClass:"+e.staticClass+","),e.classBinding&&(r+="class:"+e.classBinding+","),r}};var bo={staticKeys:["staticStyle"],transformNode:function(e,r){r.warn;var t=Un(e,"style");t&&(e.staticStyle=JSON.stringify(sa(t)));var n=Bn(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var r="";return e.staticStyle&&(r+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(r+="style:("+e.styleBinding+"),"),r}};!function(e){var r="object"==typeof exports&&exports,t="object"==typeof module&&module&&module.exports==r&&module,n="object"==typeof global&&global;n.global!==n&&n.window!==n||(e=n);var a=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,o=/[\x01-\x7F]/g,i=/[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,s=/<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g,c={"\xad":"shy","\u200c":"zwnj","\u200d":"zwj","\u200e":"lrm","\u2063":"ic","\u2062":"it","\u2061":"af","\u200f":"rlm","\u200b":"ZeroWidthSpace","\u2060":"NoBreak","\u0311":"DownBreve","\u20db":"tdot","\u20dc":"DotDot","\t":"Tab","\n":"NewLine","\u2008":"puncsp","\u205f":"MediumSpace","\u2009":"thinsp","\u200a":"hairsp","\u2004":"emsp13","\u2002":"ensp","\u2005":"emsp14","\u2003":"emsp","\u2007":"numsp","\xa0":"nbsp","\u205f\u200a":"ThickSpace","\u203e":"oline",_:"lowbar","\u2010":"dash","\u2013":"ndash","\u2014":"mdash","\u2015":"horbar",",":"comma",";":"semi","\u204f":"bsemi",":":"colon","\u2a74":"Colone","!":"excl","\xa1":"iexcl","?":"quest","\xbf":"iquest",".":"period","\u2025":"nldr","\u2026":"mldr","\xb7":"middot","'":"apos","\u2018":"lsquo","\u2019":"rsquo","\u201a":"sbquo","\u2039":"lsaquo","\u203a":"rsaquo",'"':"quot","\u201c":"ldquo","\u201d":"rdquo","\u201e":"bdquo","\xab":"laquo","\xbb":"raquo","(":"lpar",")":"rpar","[":"lsqb","]":"rsqb","{":"lcub","}":"rcub","\u2308":"lceil","\u2309":"rceil","\u230a":"lfloor","\u230b":"rfloor","\u2985":"lopar","\u2986":"ropar","\u298b":"lbrke","\u298c":"rbrke","\u298d":"lbrkslu","\u298e":"rbrksld","\u298f":"lbrksld","\u2990":"rbrkslu","\u2991":"langd","\u2992":"rangd","\u2993":"lparlt","\u2994":"rpargt","\u2995":"gtlPar","\u2996":"ltrPar","\u27e6":"lobrk","\u27e7":"robrk","\u27e8":"lang","\u27e9":"rang","\u27ea":"Lang","\u27eb":"Rang","\u27ec":"loang","\u27ed":"roang","\u2772":"lbbrk","\u2773":"rbbrk","\u2016":"Vert","\xa7":"sect","\xb6":"para","@":"commat","*":"ast","/":"sol",undefined:null,"&":"amp","#":"num","%":"percnt","\u2030":"permil","\u2031":"pertenk","\u2020":"dagger","\u2021":"Dagger","\u2022":"bull","\u2043":"hybull","\u2032":"prime","\u2033":"Prime","\u2034":"tprime","\u2057":"qprime","\u2035":"bprime","\u2041":"caret","`":"grave","\xb4":"acute","\u02dc":"tilde","^":"Hat","\xaf":"macr","\u02d8":"breve","\u02d9":"dot","\xa8":"die","\u02da":"ring","\u02dd":"dblac","\xb8":"cedil","\u02db":"ogon","\u02c6":"circ","\u02c7":"caron","\xb0":"deg","\xa9":"copy","\xae":"reg","\u2117":"copysr","\u2118":"wp","\u211e":"rx","\u2127":"mho","\u2129":"iiota","\u2190":"larr","\u219a":"nlarr","\u2192":"rarr","\u219b":"nrarr","\u2191":"uarr","\u2193":"darr","\u2194":"harr","\u21ae":"nharr","\u2195":"varr","\u2196":"nwarr","\u2197":"nearr","\u2198":"searr","\u2199":"swarr","\u219d":"rarrw","\u219d\u0338":"nrarrw","\u219e":"Larr","\u219f":"Uarr","\u21a0":"Rarr","\u21a1":"Darr","\u21a2":"larrtl","\u21a3":"rarrtl","\u21a4":"mapstoleft","\u21a5":"mapstoup","\u21a6":"map","\u21a7":"mapstodown","\u21a9":"larrhk","\u21aa":"rarrhk","\u21ab":"larrlp","\u21ac":"rarrlp","\u21ad":"harrw","\u21b0":"lsh","\u21b1":"rsh","\u21b2":"ldsh","\u21b3":"rdsh","\u21b5":"crarr","\u21b6":"cularr","\u21b7":"curarr","\u21ba":"olarr","\u21bb":"orarr","\u21bc":"lharu","\u21bd":"lhard","\u21be":"uharr","\u21bf":"uharl","\u21c0":"rharu","\u21c1":"rhard","\u21c2":"dharr","\u21c3":"dharl","\u21c4":"rlarr","\u21c5":"udarr","\u21c6":"lrarr","\u21c7":"llarr","\u21c8":"uuarr","\u21c9":"rrarr","\u21ca":"ddarr","\u21cb":"lrhar","\u21cc":"rlhar","\u21d0":"lArr","\u21cd":"nlArr","\u21d1":"uArr","\u21d2":"rArr","\u21cf":"nrArr","\u21d3":"dArr","\u21d4":"iff","\u21ce":"nhArr","\u21d5":"vArr","\u21d6":"nwArr","\u21d7":"neArr","\u21d8":"seArr","\u21d9":"swArr","\u21da":"lAarr","\u21db":"rAarr","\u21dd":"zigrarr","\u21e4":"larrb","\u21e5":"rarrb","\u21f5":"duarr","\u21fd":"loarr","\u21fe":"roarr","\u21ff":"hoarr","\u2200":"forall","\u2201":"comp","\u2202":"part","\u2202\u0338":"npart","\u2203":"exist","\u2204":"nexist","\u2205":"empty","\u2207":"Del","\u2208":"in","\u2209":"notin","\u220b":"ni","\u220c":"notni","\u03f6":"bepsi","\u220f":"prod","\u2210":"coprod","\u2211":"sum","+":"plus","\xb1":"pm","\xf7":"div","\xd7":"times","<":"lt","\u226e":"nlt","<\u20d2":"nvlt","=":"equals","\u2260":"ne","=\u20e5":"bne","\u2a75":"Equal",">":"gt","\u226f":"ngt",">\u20d2":"nvgt","\xac":"not","|":"vert","\xa6":"brvbar","\u2212":"minus","\u2213":"mp","\u2214":"plusdo","\u2044":"frasl","\u2216":"setmn","\u2217":"lowast","\u2218":"compfn","\u221a":"Sqrt","\u221d":"prop","\u221e":"infin","\u221f":"angrt","\u2220":"ang","\u2220\u20d2":"nang","\u2221":"angmsd","\u2222":"angsph","\u2223":"mid","\u2224":"nmid","\u2225":"par","\u2226":"npar","\u2227":"and","\u2228":"or","\u2229":"cap","\u2229\ufe00":"caps","\u222a":"cup","\u222a\ufe00":"cups","\u222b":"int","\u222c":"Int","\u222d":"tint","\u2a0c":"qint","\u222e":"oint","\u222f":"Conint","\u2230":"Cconint","\u2231":"cwint","\u2232":"cwconint","\u2233":"awconint","\u2234":"there4","\u2235":"becaus","\u2236":"ratio","\u2237":"Colon","\u2238":"minusd","\u223a":"mDDot","\u223b":"homtht","\u223c":"sim","\u2241":"nsim","\u223c\u20d2":"nvsim","\u223d":"bsim","\u223d\u0331":"race","\u223e":"ac","\u223e\u0333":"acE","\u223f":"acd","\u2240":"wr","\u2242":"esim","\u2242\u0338":"nesim","\u2243":"sime","\u2244":"nsime","\u2245":"cong","\u2247":"ncong","\u2246":"simne","\u2248":"ap","\u2249":"nap","\u224a":"ape","\u224b":"apid","\u224b\u0338":"napid","\u224c":"bcong","\u224d":"CupCap","\u226d":"NotCupCap","\u224d\u20d2":"nvap","\u224e":"bump","\u224e\u0338":"nbump","\u224f":"bumpe","\u224f\u0338":"nbumpe","\u2250":"doteq","\u2250\u0338":"nedot","\u2251":"eDot","\u2252":"efDot","\u2253":"erDot","\u2254":"colone","\u2255":"ecolon","\u2256":"ecir","\u2257":"cire","\u2259":"wedgeq","\u225a":"veeeq","\u225c":"trie","\u225f":"equest","\u2261":"equiv","\u2262":"nequiv","\u2261\u20e5":"bnequiv","\u2264":"le","\u2270":"nle","\u2264\u20d2":"nvle","\u2265":"ge","\u2271":"nge","\u2265\u20d2":"nvge","\u2266":"lE","\u2266\u0338":"nlE","\u2267":"gE","\u2267\u0338":"ngE","\u2268\ufe00":"lvnE","\u2268":"lnE","\u2269":"gnE","\u2269\ufe00":"gvnE","\u226a":"ll","\u226a\u0338":"nLtv","\u226a\u20d2":"nLt","\u226b":"gg","\u226b\u0338":"nGtv","\u226b\u20d2":"nGt","\u226c":"twixt","\u2272":"lsim","\u2274":"nlsim","\u2273":"gsim","\u2275":"ngsim","\u2276":"lg","\u2278":"ntlg","\u2277":"gl","\u2279":"ntgl","\u227a":"pr","\u2280":"npr","\u227b":"sc","\u2281":"nsc","\u227c":"prcue","\u22e0":"nprcue","\u227d":"sccue","\u22e1":"nsccue","\u227e":"prsim","\u227f":"scsim","\u227f\u0338":"NotSucceedsTilde","\u2282":"sub","\u2284":"nsub","\u2282\u20d2":"vnsub","\u2283":"sup","\u2285":"nsup","\u2283\u20d2":"vnsup","\u2286":"sube","\u2288":"nsube","\u2287":"supe","\u2289":"nsupe","\u228a\ufe00":"vsubne","\u228a":"subne","\u228b\ufe00":"vsupne","\u228b":"supne","\u228d":"cupdot","\u228e":"uplus","\u228f":"sqsub","\u228f\u0338":"NotSquareSubset","\u2290":"sqsup","\u2290\u0338":"NotSquareSuperset","\u2291":"sqsube","\u22e2":"nsqsube","\u2292":"sqsupe","\u22e3":"nsqsupe","\u2293":"sqcap","\u2293\ufe00":"sqcaps","\u2294":"sqcup","\u2294\ufe00":"sqcups","\u2295":"oplus","\u2296":"ominus","\u2297":"otimes","\u2298":"osol","\u2299":"odot","\u229a":"ocir","\u229b":"oast","\u229d":"odash","\u229e":"plusb","\u229f":"minusb","\u22a0":"timesb","\u22a1":"sdotb","\u22a2":"vdash","\u22ac":"nvdash","\u22a3":"dashv","\u22a4":"top","\u22a5":"bot","\u22a7":"models","\u22a8":"vDash","\u22ad":"nvDash","\u22a9":"Vdash","\u22ae":"nVdash","\u22aa":"Vvdash","\u22ab":"VDash","\u22af":"nVDash","\u22b0":"prurel","\u22b2":"vltri","\u22ea":"nltri","\u22b3":"vrtri","\u22eb":"nrtri","\u22b4":"ltrie","\u22ec":"nltrie","\u22b4\u20d2":"nvltrie","\u22b5":"rtrie","\u22ed":"nrtrie","\u22b5\u20d2":"nvrtrie","\u22b6":"origof","\u22b7":"imof","\u22b8":"mumap","\u22b9":"hercon","\u22ba":"intcal","\u22bb":"veebar","\u22bd":"barvee","\u22be":"angrtvb","\u22bf":"lrtri","\u22c0":"Wedge","\u22c1":"Vee","\u22c2":"xcap","\u22c3":"xcup","\u22c4":"diam","\u22c5":"sdot","\u22c6":"Star","\u22c7":"divonx","\u22c8":"bowtie","\u22c9":"ltimes","\u22ca":"rtimes","\u22cb":"lthree","\u22cc":"rthree","\u22cd":"bsime","\u22ce":"cuvee","\u22cf":"cuwed","\u22d0":"Sub","\u22d1":"Sup","\u22d2":"Cap","\u22d3":"Cup","\u22d4":"fork","\u22d5":"epar","\u22d6":"ltdot","\u22d7":"gtdot","\u22d8":"Ll","\u22d8\u0338":"nLl","\u22d9":"Gg","\u22d9\u0338":"nGg","\u22da\ufe00":"lesg","\u22da":"leg","\u22db":"gel","\u22db\ufe00":"gesl","\u22de":"cuepr","\u22df":"cuesc","\u22e6":"lnsim","\u22e7":"gnsim","\u22e8":"prnsim","\u22e9":"scnsim","\u22ee":"vellip","\u22ef":"ctdot","\u22f0":"utdot","\u22f1":"dtdot","\u22f2":"disin","\u22f3":"isinsv","\u22f4":"isins","\u22f5":"isindot","\u22f5\u0338":"notindot","\u22f6":"notinvc","\u22f7":"notinvb","\u22f9":"isinE","\u22f9\u0338":"notinE","\u22fa":"nisd","\u22fb":"xnis","\u22fc":"nis","\u22fd":"notnivc","\u22fe":"notnivb","\u2305":"barwed","\u2306":"Barwed","\u230c":"drcrop","\u230d":"dlcrop","\u230e":"urcrop","\u230f":"ulcrop","\u2310":"bnot","\u2312":"profline","\u2313":"profsurf","\u2315":"telrec","\u2316":"target","\u231c":"ulcorn","\u231d":"urcorn","\u231e":"dlcorn","\u231f":"drcorn","\u2322":"frown","\u2323":"smile","\u232d":"cylcty","\u232e":"profalar","\u2336":"topbot","\u233d":"ovbar","\u233f":"solbar","\u237c":"angzarr","\u23b0":"lmoust","\u23b1":"rmoust","\u23b4":"tbrk","\u23b5":"bbrk","\u23b6":"bbrktbrk","\u23dc":"OverParenthesis","\u23dd":"UnderParenthesis","\u23de":"OverBrace","\u23df":"UnderBrace","\u23e2":"trpezium","\u23e7":"elinters","\u2423":"blank","\u2500":"boxh","\u2502":"boxv","\u250c":"boxdr","\u2510":"boxdl","\u2514":"boxur","\u2518":"boxul","\u251c":"boxvr","\u2524":"boxvl","\u252c":"boxhd","\u2534":"boxhu","\u253c":"boxvh","\u2550":"boxH","\u2551":"boxV","\u2552":"boxdR","\u2553":"boxDr","\u2554":"boxDR","\u2555":"boxdL","\u2556":"boxDl","\u2557":"boxDL","\u2558":"boxuR","\u2559":"boxUr","\u255a":"boxUR","\u255b":"boxuL","\u255c":"boxUl","\u255d":"boxUL","\u255e":"boxvR","\u255f":"boxVr","\u2560":"boxVR","\u2561":"boxvL","\u2562":"boxVl","\u2563":"boxVL","\u2564":"boxHd","\u2565":"boxhD","\u2566":"boxHD","\u2567":"boxHu","\u2568":"boxhU","\u2569":"boxHU","\u256a":"boxvH","\u256b":"boxVh","\u256c":"boxVH","\u2580":"uhblk","\u2584":"lhblk","\u2588":"block","\u2591":"blk14","\u2592":"blk12","\u2593":"blk34","\u25a1":"squ","\u25aa":"squf","\u25ab":"EmptyVerySmallSquare","\u25ad":"rect","\u25ae":"marker","\u25b1":"fltns","\u25b3":"xutri","\u25b4":"utrif","\u25b5":"utri","\u25b8":"rtrif","\u25b9":"rtri","\u25bd":"xdtri","\u25be":"dtrif","\u25bf":"dtri","\u25c2":"ltrif","\u25c3":"ltri","\u25ca":"loz","\u25cb":"cir","\u25ec":"tridot","\u25ef":"xcirc","\u25f8":"ultri","\u25f9":"urtri","\u25fa":"lltri","\u25fb":"EmptySmallSquare","\u25fc":"FilledSmallSquare","\u2605":"starf","\u2606":"star","\u260e":"phone","\u2640":"female","\u2642":"male","\u2660":"spades","\u2663":"clubs","\u2665":"hearts","\u2666":"diams","\u266a":"sung","\u2713":"check","\u2717":"cross","\u2720":"malt","\u2736":"sext","\u2758":"VerticalSeparator","\u27c8":"bsolhsub","\u27c9":"suphsol","\u27f5":"xlarr","\u27f6":"xrarr","\u27f7":"xharr","\u27f8":"xlArr","\u27f9":"xrArr","\u27fa":"xhArr","\u27fc":"xmap","\u27ff":"dzigrarr","\u2902":"nvlArr","\u2903":"nvrArr","\u2904":"nvHarr","\u2905":"Map","\u290c":"lbarr","\u290d":"rbarr","\u290e":"lBarr","\u290f":"rBarr","\u2910":"RBarr","\u2911":"DDotrahd","\u2912":"UpArrowBar","\u2913":"DownArrowBar","\u2916":"Rarrtl","\u2919":"latail","\u291a":"ratail","\u291b":"lAtail","\u291c":"rAtail","\u291d":"larrfs","\u291e":"rarrfs","\u291f":"larrbfs","\u2920":"rarrbfs","\u2923":"nwarhk","\u2924":"nearhk","\u2925":"searhk","\u2926":"swarhk","\u2927":"nwnear","\u2928":"toea","\u2929":"tosa","\u292a":"swnwar","\u2933":"rarrc","\u2933\u0338":"nrarrc","\u2935":"cudarrr","\u2936":"ldca","\u2937":"rdca","\u2938":"cudarrl","\u2939":"larrpl","\u293c":"curarrm","\u293d":"cularrp","\u2945":"rarrpl","\u2948":"harrcir","\u2949":"Uarrocir","\u294a":"lurdshar","\u294b":"ldrushar","\u294e":"LeftRightVector","\u294f":"RightUpDownVector","\u2950":"DownLeftRightVector","\u2951":"LeftUpDownVector","\u2952":"LeftVectorBar","\u2953":"RightVectorBar","\u2954":"RightUpVectorBar","\u2955":"RightDownVectorBar","\u2956":"DownLeftVectorBar","\u2957":"DownRightVectorBar","\u2958":"LeftUpVectorBar","\u2959":"LeftDownVectorBar","\u295a":"LeftTeeVector","\u295b":"RightTeeVector","\u295c":"RightUpTeeVector","\u295d":"RightDownTeeVector","\u295e":"DownLeftTeeVector","\u295f":"DownRightTeeVector","\u2960":"LeftUpTeeVector","\u2961":"LeftDownTeeVector","\u2962":"lHar","\u2963":"uHar","\u2964":"rHar","\u2965":"dHar","\u2966":"luruhar","\u2967":"ldrdhar","\u2968":"ruluhar","\u2969":"rdldhar","\u296a":"lharul","\u296b":"llhard","\u296c":"rharul","\u296d":"lrhard","\u296e":"udhar","\u296f":"duhar","\u2970":"RoundImplies","\u2971":"erarr","\u2972":"simrarr","\u2973":"larrsim","\u2974":"rarrsim","\u2975":"rarrap","\u2976":"ltlarr","\u2978":"gtrarr","\u2979":"subrarr","\u297b":"suplarr","\u297c":"lfisht","\u297d":"rfisht","\u297e":"ufisht","\u297f":"dfisht","\u299a":"vzigzag","\u299c":"vangrt","\u299d":"angrtvbd","\u29a4":"ange","\u29a5":"range","\u29a6":"dwangle","\u29a7":"uwangle","\u29a8":"angmsdaa","\u29a9":"angmsdab","\u29aa":"angmsdac","\u29ab":"angmsdad","\u29ac":"angmsdae","\u29ad":"angmsdaf","\u29ae":"angmsdag","\u29af":"angmsdah","\u29b0":"bemptyv","\u29b1":"demptyv","\u29b2":"cemptyv","\u29b3":"raemptyv","\u29b4":"laemptyv","\u29b5":"ohbar","\u29b6":"omid","\u29b7":"opar","\u29b9":"operp","\u29bb":"olcross","\u29bc":"odsold","\u29be":"olcir","\u29bf":"ofcir","\u29c0":"olt","\u29c1":"ogt","\u29c2":"cirscir","\u29c3":"cirE","\u29c4":"solb","\u29c5":"bsolb","\u29c9":"boxbox","\u29cd":"trisb","\u29ce":"rtriltri","\u29cf":"LeftTriangleBar","\u29cf\u0338":"NotLeftTriangleBar","\u29d0":"RightTriangleBar","\u29d0\u0338":"NotRightTriangleBar","\u29dc":"iinfin","\u29dd":"infintie","\u29de":"nvinfin","\u29e3":"eparsl","\u29e4":"smeparsl","\u29e5":"eqvparsl","\u29eb":"lozf","\u29f4":"RuleDelayed","\u29f6":"dsol","\u2a00":"xodot","\u2a01":"xoplus","\u2a02":"xotime","\u2a04":"xuplus","\u2a06":"xsqcup","\u2a0d":"fpartint","\u2a10":"cirfnint","\u2a11":"awint","\u2a12":"rppolint","\u2a13":"scpolint","\u2a14":"npolint","\u2a15":"pointint","\u2a16":"quatint","\u2a17":"intlarhk","\u2a22":"pluscir","\u2a23":"plusacir","\u2a24":"simplus","\u2a25":"plusdu","\u2a26":"plussim","\u2a27":"plustwo","\u2a29":"mcomma","\u2a2a":"minusdu","\u2a2d":"loplus","\u2a2e":"roplus","\u2a2f":"Cross","\u2a30":"timesd","\u2a31":"timesbar","\u2a33":"smashp","\u2a34":"lotimes","\u2a35":"rotimes","\u2a36":"otimesas","\u2a37":"Otimes","\u2a38":"odiv","\u2a39":"triplus","\u2a3a":"triminus","\u2a3b":"tritime","\u2a3c":"iprod","\u2a3f":"amalg","\u2a40":"capdot","\u2a42":"ncup","\u2a43":"ncap","\u2a44":"capand","\u2a45":"cupor","\u2a46":"cupcap","\u2a47":"capcup","\u2a48":"cupbrcap","\u2a49":"capbrcup","\u2a4a":"cupcup","\u2a4b":"capcap","\u2a4c":"ccups","\u2a4d":"ccaps","\u2a50":"ccupssm","\u2a53":"And","\u2a54":"Or","\u2a55":"andand","\u2a56":"oror","\u2a57":"orslope","\u2a58":"andslope","\u2a5a":"andv","\u2a5b":"orv","\u2a5c":"andd","\u2a5d":"ord","\u2a5f":"wedbar","\u2a66":"sdote","\u2a6a":"simdot","\u2a6d":"congdot","\u2a6d\u0338":"ncongdot","\u2a6e":"easter","\u2a6f":"apacir","\u2a70":"apE","\u2a70\u0338":"napE","\u2a71":"eplus","\u2a72":"pluse","\u2a73":"Esim","\u2a77":"eDDot","\u2a78":"equivDD","\u2a79":"ltcir","\u2a7a":"gtcir","\u2a7b":"ltquest","\u2a7c":"gtquest","\u2a7d":"les","\u2a7d\u0338":"nles","\u2a7e":"ges","\u2a7e\u0338":"nges","\u2a7f":"lesdot","\u2a80":"gesdot","\u2a81":"lesdoto","\u2a82":"gesdoto","\u2a83":"lesdotor","\u2a84":"gesdotol","\u2a85":"lap","\u2a86":"gap","\u2a87":"lne","\u2a88":"gne","\u2a89":"lnap","\u2a8a":"gnap","\u2a8b":"lEg","\u2a8c":"gEl","\u2a8d":"lsime","\u2a8e":"gsime","\u2a8f":"lsimg","\u2a90":"gsiml","\u2a91":"lgE","\u2a92":"glE","\u2a93":"lesges","\u2a94":"gesles","\u2a95":"els","\u2a96":"egs","\u2a97":"elsdot","\u2a98":"egsdot","\u2a99":"el","\u2a9a":"eg","\u2a9d":"siml","\u2a9e":"simg","\u2a9f":"simlE","\u2aa0":"simgE","\u2aa1":"LessLess","\u2aa1\u0338":"NotNestedLessLess","\u2aa2":"GreaterGreater","\u2aa2\u0338":"NotNestedGreaterGreater","\u2aa4":"glj","\u2aa5":"gla","\u2aa6":"ltcc","\u2aa7":"gtcc","\u2aa8":"lescc","\u2aa9":"gescc","\u2aaa":"smt","\u2aab":"lat","\u2aac":"smte","\u2aac\ufe00":"smtes","\u2aad":"late","\u2aad\ufe00":"lates","\u2aae":"bumpE","\u2aaf":"pre","\u2aaf\u0338":"npre","\u2ab0":"sce","\u2ab0\u0338":"nsce","\u2ab3":"prE","\u2ab4":"scE","\u2ab5":"prnE","\u2ab6":"scnE","\u2ab7":"prap","\u2ab8":"scap","\u2ab9":"prnap","\u2aba":"scnap","\u2abb":"Pr","\u2abc":"Sc","\u2abd":"subdot","\u2abe":"supdot","\u2abf":"subplus","\u2ac0":"supplus","\u2ac1":"submult","\u2ac2":"supmult","\u2ac3":"subedot","\u2ac4":"supedot","\u2ac5":"subE","\u2ac5\u0338":"nsubE","\u2ac6":"supE","\u2ac6\u0338":"nsupE","\u2ac7":"subsim","\u2ac8":"supsim","\u2acb\ufe00":"vsubnE","\u2acb":"subnE","\u2acc\ufe00":"vsupnE","\u2acc":"supnE","\u2acf":"csub","\u2ad0":"csup","\u2ad1":"csube","\u2ad2":"csupe","\u2ad3":"subsup","\u2ad4":"supsub","\u2ad5":"subsub","\u2ad6":"supsup","\u2ad7":"suphsub","\u2ad8":"supdsub","\u2ad9":"forkv","\u2ada":"topfork","\u2adb":"mlcp","\u2ae4":"Dashv","\u2ae6":"Vdashl","\u2ae7":"Barv","\u2ae8":"vBar","\u2ae9":"vBarv","\u2aeb":"Vbar","\u2aec":"Not","\u2aed":"bNot","\u2aee":"rnmid","\u2aef":"cirmid","\u2af0":"midcir","\u2af1":"topcir","\u2af2":"nhpar","\u2af3":"parsim","\u2afd":"parsl","\u2afd\u20e5":"nparsl","\u266d":"flat","\u266e":"natur","\u266f":"sharp","\xa4":"curren","\xa2":"cent",$:"dollar","\xa3":"pound","\xa5":"yen","\u20ac":"euro","\xb9":"sup1","\xbd":"half","\u2153":"frac13","\xbc":"frac14","\u2155":"frac15","\u2159":"frac16","\u215b":"frac18","\xb2":"sup2","\u2154":"frac23","\u2156":"frac25","\xb3":"sup3","\xbe":"frac34","\u2157":"frac35","\u215c":"frac38","\u2158":"frac45","\u215a":"frac56","\u215d":"frac58","\u215e":"frac78","\ud835\udcb6":"ascr","\ud835\udd52":"aopf","\ud835\udd1e":"afr","\ud835\udd38":"Aopf","\ud835\udd04":"Afr","\ud835\udc9c":"Ascr","\xaa":"ordf","\xe1":"aacute","\xc1":"Aacute","\xe0":"agrave","\xc0":"Agrave","\u0103":"abreve","\u0102":"Abreve","\xe2":"acirc","\xc2":"Acirc","\xe5":"aring","\xc5":"angst","\xe4":"auml","\xc4":"Auml","\xe3":"atilde","\xc3":"Atilde","\u0105":"aogon","\u0104":"Aogon","\u0101":"amacr","\u0100":"Amacr","\xe6":"aelig","\xc6":"AElig","\ud835\udcb7":"bscr","\ud835\udd53":"bopf","\ud835\udd1f":"bfr","\ud835\udd39":"Bopf","\u212c":"Bscr","\ud835\udd05":"Bfr","\ud835\udd20":"cfr","\ud835\udcb8":"cscr","\ud835\udd54":"copf","\u212d":"Cfr","\ud835\udc9e":"Cscr","\u2102":"Copf","\u0107":"cacute","\u0106":"Cacute","\u0109":"ccirc","\u0108":"Ccirc","\u010d":"ccaron","\u010c":"Ccaron","\u010b":"cdot","\u010a":"Cdot","\xe7":"ccedil","\xc7":"Ccedil","\u2105":"incare","\ud835\udd21":"dfr","\u2146":"dd","\ud835\udd55":"dopf","\ud835\udcb9":"dscr","\ud835\udc9f":"Dscr","\ud835\udd07":"Dfr","\u2145":"DD","\ud835\udd3b":"Dopf","\u010f":"dcaron","\u010e":"Dcaron","\u0111":"dstrok","\u0110":"Dstrok","\xf0":"eth","\xd0":"ETH","\u2147":"ee","\u212f":"escr","\ud835\udd22":"efr","\ud835\udd56":"eopf","\u2130":"Escr","\ud835\udd08":"Efr","\ud835\udd3c":"Eopf","\xe9":"eacute","\xc9":"Eacute","\xe8":"egrave","\xc8":"Egrave","\xea":"ecirc","\xca":"Ecirc","\u011b":"ecaron","\u011a":"Ecaron","\xeb":"euml","\xcb":"Euml","\u0117":"edot","\u0116":"Edot","\u0119":"eogon","\u0118":"Eogon","\u0113":"emacr","\u0112":"Emacr","\ud835\udd23":"ffr","\ud835\udd57":"fopf","\ud835\udcbb":"fscr","\ud835\udd09":"Ffr","\ud835\udd3d":"Fopf","\u2131":"Fscr","\ufb00":"fflig","\ufb03":"ffilig","\ufb04":"ffllig","\ufb01":"filig",fj:"fjlig","\ufb02":"fllig","\u0192":"fnof","\u210a":"gscr","\ud835\udd58":"gopf","\ud835\udd24":"gfr","\ud835\udca2":"Gscr","\ud835\udd3e":"Gopf","\ud835\udd0a":"Gfr","\u01f5":"gacute","\u011f":"gbreve","\u011e":"Gbreve","\u011d":"gcirc","\u011c":"Gcirc","\u0121":"gdot","\u0120":"Gdot","\u0122":"Gcedil","\ud835\udd25":"hfr","\u210e":"planckh","\ud835\udcbd":"hscr","\ud835\udd59":"hopf","\u210b":"Hscr","\u210c":"Hfr","\u210d":"Hopf","\u0125":"hcirc","\u0124":"Hcirc","\u210f":"hbar","\u0127":"hstrok","\u0126":"Hstrok","\ud835\udd5a":"iopf","\ud835\udd26":"ifr","\ud835\udcbe":"iscr","\u2148":"ii","\ud835\udd40":"Iopf","\u2110":"Iscr","\u2111":"Im","\xed":"iacute","\xcd":"Iacute","\xec":"igrave","\xcc":"Igrave","\xee":"icirc","\xce":"Icirc","\xef":"iuml","\xcf":"Iuml","\u0129":"itilde","\u0128":"Itilde","\u0130":"Idot","\u012f":"iogon","\u012e":"Iogon","\u012b":"imacr","\u012a":"Imacr","\u0133":"ijlig","\u0132":"IJlig","\u0131":"imath","\ud835\udcbf":"jscr","\ud835\udd5b":"jopf","\ud835\udd27":"jfr","\ud835\udca5":"Jscr","\ud835\udd0d":"Jfr","\ud835\udd41":"Jopf","\u0135":"jcirc","\u0134":"Jcirc","\u0237":"jmath","\ud835\udd5c":"kopf","\ud835\udcc0":"kscr","\ud835\udd28":"kfr","\ud835\udca6":"Kscr","\ud835\udd42":"Kopf","\ud835\udd0e":"Kfr","\u0137":"kcedil","\u0136":"Kcedil","\ud835\udd29":"lfr","\ud835\udcc1":"lscr","\u2113":"ell","\ud835\udd5d":"lopf","\u2112":"Lscr","\ud835\udd0f":"Lfr","\ud835\udd43":"Lopf","\u013a":"lacute","\u0139":"Lacute","\u013e":"lcaron","\u013d":"Lcaron","\u013c":"lcedil","\u013b":"Lcedil","\u0142":"lstrok","\u0141":"Lstrok","\u0140":"lmidot","\u013f":"Lmidot","\ud835\udd2a":"mfr","\ud835\udd5e":"mopf","\ud835\udcc2":"mscr","\ud835\udd10":"Mfr","\ud835\udd44":"Mopf","\u2133":"Mscr","\ud835\udd2b":"nfr","\ud835\udd5f":"nopf","\ud835\udcc3":"nscr","\u2115":"Nopf","\ud835\udca9":"Nscr","\ud835\udd11":"Nfr","\u0144":"nacute","\u0143":"Nacute","\u0148":"ncaron","\u0147":"Ncaron","\xf1":"ntilde","\xd1":"Ntilde","\u0146":"ncedil","\u0145":"Ncedil","\u2116":"numero","\u014b":"eng","\u014a":"ENG","\ud835\udd60":"oopf","\ud835\udd2c":"ofr","\u2134":"oscr","\ud835\udcaa":"Oscr","\ud835\udd12":"Ofr","\ud835\udd46":"Oopf","\xba":"ordm","\xf3":"oacute","\xd3":"Oacute","\xf2":"ograve","\xd2":"Ograve","\xf4":"ocirc","\xd4":"Ocirc","\xf6":"ouml","\xd6":"Ouml","\u0151":"odblac","\u0150":"Odblac","\xf5":"otilde","\xd5":"Otilde","\xf8":"oslash","\xd8":"Oslash","\u014d":"omacr","\u014c":"Omacr","\u0153":"oelig","\u0152":"OElig","\ud835\udd2d":"pfr","\ud835\udcc5":"pscr","\ud835\udd61":"popf","\u2119":"Popf","\ud835\udd13":"Pfr","\ud835\udcab":"Pscr","\ud835\udd62":"qopf","\ud835\udd2e":"qfr","\ud835\udcc6":"qscr","\ud835\udcac":"Qscr","\ud835\udd14":"Qfr","\u211a":"Qopf","\u0138":"kgreen","\ud835\udd2f":"rfr","\ud835\udd63":"ropf","\ud835\udcc7":"rscr","\u211b":"Rscr","\u211c":"Re","\u211d":"Ropf","\u0155":"racute","\u0154":"Racute","\u0159":"rcaron","\u0158":"Rcaron","\u0157":"rcedil","\u0156":"Rcedil","\ud835\udd64":"sopf","\ud835\udcc8":"sscr","\ud835\udd30":"sfr","\ud835\udd4a":"Sopf","\ud835\udd16":"Sfr","\ud835\udcae":"Sscr","\u24c8":"oS","\u015b":"sacute","\u015a":"Sacute","\u015d":"scirc","\u015c":"Scirc","\u0161":"scaron","\u0160":"Scaron","\u015f":"scedil","\u015e":"Scedil","\xdf":"szlig","\ud835\udd31":"tfr","\ud835\udcc9":"tscr","\ud835\udd65":"topf","\ud835\udcaf":"Tscr","\ud835\udd17":"Tfr","\ud835\udd4b":"Topf","\u0165":"tcaron","\u0164":"Tcaron","\u0163":"tcedil","\u0162":"Tcedil","\u2122":"trade","\u0167":"tstrok","\u0166":"Tstrok","\ud835\udcca":"uscr","\ud835\udd66":"uopf","\ud835\udd32":"ufr","\ud835\udd4c":"Uopf","\ud835\udd18":"Ufr","\ud835\udcb0":"Uscr","\xfa":"uacute","\xda":"Uacute","\xf9":"ugrave","\xd9":"Ugrave","\u016d":"ubreve","\u016c":"Ubreve","\xfb":"ucirc","\xdb":"Ucirc","\u016f":"uring","\u016e":"Uring","\xfc":"uuml","\xdc":"Uuml","\u0171":"udblac","\u0170":"Udblac","\u0169":"utilde","\u0168":"Utilde","\u0173":"uogon","\u0172":"Uogon","\u016b":"umacr","\u016a":"Umacr","\ud835\udd33":"vfr","\ud835\udd67":"vopf","\ud835\udccb":"vscr","\ud835\udd19":"Vfr","\ud835\udd4d":"Vopf","\ud835\udcb1":"Vscr","\ud835\udd68":"wopf","\ud835\udccc":"wscr","\ud835\udd34":"wfr","\ud835\udcb2":"Wscr","\ud835\udd4e":"Wopf","\ud835\udd1a":"Wfr","\u0175":"wcirc","\u0174":"Wcirc","\ud835\udd35":"xfr","\ud835\udccd":"xscr","\ud835\udd69":"xopf","\ud835\udd4f":"Xopf","\ud835\udd1b":"Xfr","\ud835\udcb3":"Xscr","\ud835\udd36":"yfr","\ud835\udcce":"yscr","\ud835\udd6a":"yopf","\ud835\udcb4":"Yscr","\ud835\udd1c":"Yfr","\ud835\udd50":"Yopf","\xfd":"yacute","\xdd":"Yacute","\u0177":"ycirc","\u0176":"Ycirc","\xff":"yuml","\u0178":"Yuml","\ud835\udccf":"zscr","\ud835\udd37":"zfr","\ud835\udd6b":"zopf","\u2128":"Zfr","\u2124":"Zopf","\ud835\udcb5":"Zscr","\u017a":"zacute","\u0179":"Zacute","\u017e":"zcaron","\u017d":"Zcaron","\u017c":"zdot","\u017b":"Zdot","\u01b5":"imped","\xfe":"thorn","\xde":"THORN","\u0149":"napos","\u03b1":"alpha","\u0391":"Alpha","\u03b2":"beta","\u0392":"Beta","\u03b3":"gamma","\u0393":"Gamma","\u03b4":"delta","\u0394":"Delta","\u03b5":"epsi","\u03f5":"epsiv","\u0395":"Epsilon","\u03dd":"gammad","\u03dc":"Gammad","\u03b6":"zeta","\u0396":"Zeta","\u03b7":"eta","\u0397":"Eta","\u03b8":"theta","\u03d1":"thetav","\u0398":"Theta","\u03b9":"iota","\u0399":"Iota","\u03ba":"kappa","\u03f0":"kappav","\u039a":"Kappa","\u03bb":"lambda","\u039b":"Lambda","\u03bc":"mu","\xb5":"micro","\u039c":"Mu","\u03bd":"nu","\u039d":"Nu","\u03be":"xi","\u039e":"Xi","\u03bf":"omicron","\u039f":"Omicron","\u03c0":"pi","\u03d6":"piv","\u03a0":"Pi","\u03c1":"rho","\u03f1":"rhov","\u03a1":"Rho","\u03c3":"sigma","\u03a3":"Sigma","\u03c2":"sigmaf","\u03c4":"tau","\u03a4":"Tau","\u03c5":"upsi","\u03a5":"Upsilon","\u03d2":"Upsi","\u03c6":"phi","\u03d5":"phiv","\u03a6":"Phi","\u03c7":"chi","\u03a7":"Chi","\u03c8":"psi","\u03a8":"Psi","\u03c9":"omega","\u03a9":"ohm","\u0430":"acy","\u0410":"Acy","\u0431":"bcy","\u0411":"Bcy","\u0432":"vcy","\u0412":"Vcy","\u0433":"gcy","\u0413":"Gcy","\u0453":"gjcy","\u0403":"GJcy","\u0434":"dcy","\u0414":"Dcy","\u0452":"djcy","\u0402":"DJcy","\u0435":"iecy","\u0415":"IEcy","\u0451":"iocy","\u0401":"IOcy","\u0454":"jukcy","\u0404":"Jukcy","\u0436":"zhcy","\u0416":"ZHcy","\u0437":"zcy","\u0417":"Zcy","\u0455":"dscy","\u0405":"DScy","\u0438":"icy","\u0418":"Icy","\u0456":"iukcy","\u0406":"Iukcy","\u0457":"yicy","\u0407":"YIcy","\u0439":"jcy","\u0419":"Jcy","\u0458":"jsercy","\u0408":"Jsercy","\u043a":"kcy","\u041a":"Kcy","\u045c":"kjcy","\u040c":"KJcy","\u043b":"lcy","\u041b":"Lcy","\u0459":"ljcy","\u0409":"LJcy","\u043c":"mcy","\u041c":"Mcy","\u043d":"ncy","\u041d":"Ncy","\u045a":"njcy","\u040a":"NJcy","\u043e":"ocy","\u041e":"Ocy","\u043f":"pcy","\u041f":"Pcy","\u0440":"rcy","\u0420":"Rcy","\u0441":"scy","\u0421":"Scy","\u0442":"tcy","\u0422":"Tcy","\u045b":"tshcy","\u040b":"TSHcy","\u0443":"ucy","\u0423":"Ucy","\u045e":"ubrcy","\u040e":"Ubrcy","\u0444":"fcy","\u0424":"Fcy","\u0445":"khcy","\u0425":"KHcy","\u0446":"tscy","\u0426":"TScy","\u0447":"chcy","\u0427":"CHcy","\u045f":"dzcy","\u040f":"DZcy","\u0448":"shcy","\u0428":"SHcy","\u0449":"shchcy","\u0429":"SHCHcy","\u044a":"hardcy","\u042a":"HARDcy","\u044b":"ycy","\u042b":"Ycy","\u044c":"softcy","\u042c":"SOFTcy","\u044d":"ecy","\u042d":"Ecy","\u044e":"yucy","\u042e":"YUcy","\u044f":"yacy","\u042f":"YAcy","\u2135":"aleph","\u2136":"beth","\u2137":"gimel","\u2138":"daleth"},u=/["&'<>`]/g,l={'"':"&quot;","&":"&amp;","'":"&#x27;","<":"&lt;",">":"&gt;","`":"&#x60;"},p=/&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/,f=/[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/,d=/&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g,m={aacute:"\xe1",Aacute:"\xc1",abreve:"\u0103",Abreve:"\u0102",ac:"\u223e",acd:"\u223f",acE:"\u223e\u0333",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",acy:"\u0430",Acy:"\u0410",aelig:"\xe6",AElig:"\xc6",af:"\u2061",afr:"\ud835\udd1e",Afr:"\ud835\udd04",agrave:"\xe0",Agrave:"\xc0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",Alpha:"\u0391",amacr:"\u0101",Amacr:"\u0100",amalg:"\u2a3f",amp:"&",AMP:"&",and:"\u2227",And:"\u2a53",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",ange:"\u29a4",angle:"\u2220",angmsd:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angst:"\xc5",angzarr:"\u237c",aogon:"\u0105",Aogon:"\u0104",aopf:"\ud835\udd52",Aopf:"\ud835\udd38",ap:"\u2248",apacir:"\u2a6f",ape:"\u224a",apE:"\u2a70",apid:"\u224b",apos:"'",ApplyFunction:"\u2061",approx:"\u2248",approxeq:"\u224a",aring:"\xe5",Aring:"\xc5",ascr:"\ud835\udcb6",Ascr:"\ud835\udc9c",Assign:"\u2254",ast:"*",asymp:"\u2248",asympeq:"\u224d",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",awconint:"\u2233",awint:"\u2a11",backcong:"\u224c",backepsilon:"\u03f6",backprime:"\u2035",backsim:"\u223d",backsimeq:"\u22cd",Backslash:"\u2216",Barv:"\u2ae7",barvee:"\u22bd",barwed:"\u2305",Barwed:"\u2306",barwedge:"\u2305",bbrk:"\u23b5",bbrktbrk:"\u23b6",bcong:"\u224c",bcy:"\u0431",Bcy:"\u0411",bdquo:"\u201e",becaus:"\u2235",because:"\u2235",Because:"\u2235",bemptyv:"\u29b0",bepsi:"\u03f6",bernou:"\u212c",Bernoullis:"\u212c",beta:"\u03b2",Beta:"\u0392",beth:"\u2136",between:"\u226c",bfr:"\ud835\udd1f",Bfr:"\ud835\udd05",bigcap:"\u22c2",bigcirc:"\u25ef",bigcup:"\u22c3",bigodot:"\u2a00",bigoplus:"\u2a01",bigotimes:"\u2a02",bigsqcup:"\u2a06",bigstar:"\u2605",bigtriangledown:"\u25bd",bigtriangleup:"\u25b3",biguplus:"\u2a04",bigvee:"\u22c1",bigwedge:"\u22c0",bkarow:"\u290d",blacklozenge:"\u29eb",blacksquare:"\u25aa",blacktriangle:"\u25b4",blacktriangledown:"\u25be",blacktriangleleft:"\u25c2",blacktriangleright:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bNot:"\u2aed",bopf:"\ud835\udd53",Bopf:"\ud835\udd39",bot:"\u22a5",bottom:"\u22a5",bowtie:"\u22c8",boxbox:"\u29c9",boxdl:"\u2510",boxdL:"\u2555",boxDl:"\u2556",boxDL:"\u2557",boxdr:"\u250c",boxdR:"\u2552",boxDr:"\u2553",boxDR:"\u2554",boxh:"\u2500",boxH:"\u2550",boxhd:"\u252c",boxhD:"\u2565",boxHd:"\u2564",boxHD:"\u2566",boxhu:"\u2534",boxhU:"\u2568",boxHu:"\u2567",boxHU:"\u2569",boxminus:"\u229f",boxplus:"\u229e",boxtimes:"\u22a0",boxul:"\u2518",boxuL:"\u255b",boxUl:"\u255c",boxUL:"\u255d",boxur:"\u2514",boxuR:"\u2558",boxUr:"\u2559",boxUR:"\u255a",boxv:"\u2502",boxV:"\u2551",boxvh:"\u253c",boxvH:"\u256a",boxVh:"\u256b",boxVH:"\u256c",boxvl:"\u2524",boxvL:"\u2561",boxVl:"\u2562",boxVL:"\u2563",boxvr:"\u251c",boxvR:"\u255e",boxVr:"\u255f",boxVR:"\u2560",bprime:"\u2035",breve:"\u02d8",Breve:"\u02d8",brvbar:"\xa6",bscr:"\ud835\udcb7",Bscr:"\u212c",bsemi:"\u204f",bsim:"\u223d",bsime:"\u22cd",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bump:"\u224e",bumpe:"\u224f",bumpE:"\u2aae",bumpeq:"\u224f",Bumpeq:"\u224e",cacute:"\u0107",Cacute:"\u0106",cap:"\u2229",Cap:"\u22d2",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",CapitalDifferentialD:"\u2145",caps:"\u2229\ufe00",caret:"\u2041",caron:"\u02c7",Cayleys:"\u212d",ccaps:"\u2a4d",ccaron:"\u010d",Ccaron:"\u010c",ccedil:"\xe7",Ccedil:"\xc7",ccirc:"\u0109",Ccirc:"\u0108",Cconint:"\u2230",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",Cdot:"\u010a",cedil:"\xb8",Cedilla:"\xb8",cemptyv:"\u29b2",cent:"\xa2",centerdot:"\xb7",CenterDot:"\xb7",cfr:"\ud835\udd20",Cfr:"\u212d",chcy:"\u0447",CHcy:"\u0427",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",Chi:"\u03a7",cir:"\u25cb",circ:"\u02c6",circeq:"\u2257",circlearrowleft:"\u21ba",circlearrowright:"\u21bb",circledast:"\u229b",circledcirc:"\u229a",circleddash:"\u229d",CircleDot:"\u2299",circledR:"\xae",circledS:"\u24c8",CircleMinus:"\u2296",CirclePlus:"\u2295",CircleTimes:"\u2297",cire:"\u2257",cirE:"\u29c3",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",ClockwiseContourIntegral:"\u2232",CloseCurlyDoubleQuote:"\u201d",CloseCurlyQuote:"\u2019",clubs:"\u2663",clubsuit:"\u2663",colon:":",Colon:"\u2237",colone:"\u2254",Colone:"\u2a74",coloneq:"\u2254",comma:",",commat:"@",comp:"\u2201",compfn:"\u2218",complement:"\u2201",complexes:"\u2102",cong:"\u2245",congdot:"\u2a6d",Congruent:"\u2261",conint:"\u222e",Conint:"\u222f",ContourIntegral:"\u222e",copf:"\ud835\udd54",Copf:"\u2102",coprod:"\u2210",Coproduct:"\u2210",copy:"\xa9",COPY:"\xa9",copysr:"\u2117",CounterClockwiseContourIntegral:"\u2233",crarr:"\u21b5",cross:"\u2717",Cross:"\u2a2f",cscr:"\ud835\udcb8",Cscr:"\ud835\udc9e",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",cuesc:"\u22df",cularr:"\u21b6",cularrp:"\u293d",cup:"\u222a",Cup:"\u22d3",cupbrcap:"\u2a48",cupcap:"\u2a46",CupCap:"\u224d",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curarrm:"\u293c",curlyeqprec:"\u22de",curlyeqsucc:"\u22df",curlyvee:"\u22ce",curlywedge:"\u22cf",curren:"\xa4",curvearrowleft:"\u21b6",curvearrowright:"\u21b7",cuvee:"\u22ce",cuwed:"\u22cf",cwconint:"\u2232",cwint:"\u2231",cylcty:"\u232d",dagger:"\u2020",Dagger:"\u2021",daleth:"\u2138",darr:"\u2193",dArr:"\u21d3",Darr:"\u21a1",dash:"\u2010",dashv:"\u22a3",Dashv:"\u2ae4",dbkarow:"\u290f",dblac:"\u02dd",dcaron:"\u010f",Dcaron:"\u010e",dcy:"\u0434",Dcy:"\u0414",dd:"\u2146",DD:"\u2145",ddagger:"\u2021",ddarr:"\u21ca",DDotrahd:"\u2911",ddotseq:"\u2a77",deg:"\xb0",Del:"\u2207",delta:"\u03b4",Delta:"\u0394",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",Dfr:"\ud835\udd07",dHar:"\u2965",dharl:"\u21c3",dharr:"\u21c2",DiacriticalAcute:"\xb4",DiacriticalDot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",DiacriticalGrave:"`",DiacriticalTilde:"\u02dc",diam:"\u22c4",diamond:"\u22c4",Diamond:"\u22c4",diamondsuit:"\u2666",diams:"\u2666",die:"\xa8",DifferentialD:"\u2146",digamma:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",DJcy:"\u0402",dlcorn:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",Dopf:"\ud835\udd3b",dot:"\u02d9",Dot:"\xa8",DotDot:"\u20dc",doteq:"\u2250",doteqdot:"\u2251",DotEqual:"\u2250",dotminus:"\u2238",dotplus:"\u2214",dotsquare:"\u22a1",doublebarwedge:"\u2306",DoubleContourIntegral:"\u222f",DoubleDot:"\xa8",DoubleDownArrow:"\u21d3",DoubleLeftArrow:"\u21d0",DoubleLeftRightArrow:"\u21d4",DoubleLeftTee:"\u2ae4",DoubleLongLeftArrow:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",DoubleLongRightArrow:"\u27f9",DoubleRightArrow:"\u21d2",DoubleRightTee:"\u22a8",DoubleUpArrow:"\u21d1",DoubleUpDownArrow:"\u21d5",DoubleVerticalBar:"\u2225",downarrow:"\u2193",Downarrow:"\u21d3",DownArrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",DownBreve:"\u0311",downdownarrows:"\u21ca",downharpoonleft:"\u21c3",downharpoonright:"\u21c2",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",DownTeeArrow:"\u21a7",drbkarow:"\u2910",drcorn:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",Dscr:"\ud835\udc9f",dscy:"\u0455",DScy:"\u0405",dsol:"\u29f6",dstrok:"\u0111",Dstrok:"\u0110",dtdot:"\u22f1",dtri:"\u25bf",dtrif:"\u25be",duarr:"\u21f5",duhar:"\u296f",dwangle:"\u29a6",dzcy:"\u045f",DZcy:"\u040f",dzigrarr:"\u27ff",eacute:"\xe9",Eacute:"\xc9",easter:"\u2a6e",ecaron:"\u011b",Ecaron:"\u011a",ecir:"\u2256",ecirc:"\xea",Ecirc:"\xca",ecolon:"\u2255",ecy:"\u044d",Ecy:"\u042d",eDDot:"\u2a77",edot:"\u0117",eDot:"\u2251",Edot:"\u0116",ee:"\u2147",efDot:"\u2252",efr:"\ud835\udd22",Efr:"\ud835\udd08",eg:"\u2a9a",egrave:"\xe8",Egrave:"\xc8",egs:"\u2a96",egsdot:"\u2a98",el:"\u2a99",Element:"\u2208",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",Emacr:"\u0112",empty:"\u2205",emptyset:"\u2205",EmptySmallSquare:"\u25fb",emptyv:"\u2205",EmptyVerySmallSquare:"\u25ab",emsp:"\u2003",emsp13:"\u2004",emsp14:"\u2005",eng:"\u014b",ENG:"\u014a",ensp:"\u2002",eogon:"\u0119",Eogon:"\u0118",eopf:"\ud835\udd56",Eopf:"\ud835\udd3c",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",Epsilon:"\u0395",epsiv:"\u03f5",eqcirc:"\u2256",eqcolon:"\u2255",eqsim:"\u2242",eqslantgtr:"\u2a96",eqslantless:"\u2a95",Equal:"\u2a75",equals:"=",EqualTilde:"\u2242",equest:"\u225f",Equilibrium:"\u21cc",equiv:"\u2261",equivDD:"\u2a78",eqvparsl:"\u29e5",erarr:"\u2971",erDot:"\u2253",escr:"\u212f",Escr:"\u2130",esdot:"\u2250",esim:"\u2242",Esim:"\u2a73",eta:"\u03b7",Eta:"\u0397",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",euro:"\u20ac",excl:"!",exist:"\u2203",Exists:"\u2203",expectation:"\u2130",exponentiale:"\u2147",ExponentialE:"\u2147",fallingdotseq:"\u2252",fcy:"\u0444",Fcy:"\u0424",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",Ffr:"\ud835\udd09",filig:"\ufb01",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",Fopf:"\ud835\udd3d",forall:"\u2200",ForAll:"\u2200",fork:"\u22d4",forkv:"\u2ad9",Fouriertrf:"\u2131",fpartint:"\u2a0d",frac12:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",fscr:"\ud835\udcbb",Fscr:"\u2131",gacute:"\u01f5",gamma:"\u03b3",Gamma:"\u0393",gammad:"\u03dd",Gammad:"\u03dc",gap:"\u2a86",gbreve:"\u011f",Gbreve:"\u011e",Gcedil:"\u0122",gcirc:"\u011d",Gcirc:"\u011c",gcy:"\u0433",Gcy:"\u0413",gdot:"\u0121",Gdot:"\u0120",ge:"\u2265",gE:"\u2267",gel:"\u22db",gEl:"\u2a8c",geq:"\u2265",geqq:"\u2267",geqslant:"\u2a7e",ges:"\u2a7e",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",Gfr:"\ud835\udd0a",gg:"\u226b",Gg:"\u22d9",ggg:"\u22d9",gimel:"\u2137",gjcy:"\u0453",GJcy:"\u0403",gl:"\u2277",gla:"\u2aa5",glE:"\u2a92",glj:"\u2aa4",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gnE:"\u2269",gneq:"\u2a88",gneqq:"\u2269",gnsim:"\u22e7",gopf:"\ud835\udd58",Gopf:"\ud835\udd3e",grave:"`",GreaterEqual:"\u2265",GreaterEqualLess:"\u22db",GreaterFullEqual:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",GreaterSlantEqual:"\u2a7e",GreaterTilde:"\u2273",gscr:"\u210a",Gscr:"\ud835\udca2",gsim:"\u2273",gsime:"\u2a8e",gsiml:"\u2a90",gt:">",Gt:"\u226b",GT:">",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrapprox:"\u2a86",gtrarr:"\u2978",gtrdot:"\u22d7",gtreqless:"\u22db",gtreqqless:"\u2a8c",gtrless:"\u2277",gtrsim:"\u2273",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",Hacek:"\u02c7",hairsp:"\u200a",half:"\xbd",hamilt:"\u210b",hardcy:"\u044a",HARDcy:"\u042a",harr:"\u2194",hArr:"\u21d4",harrcir:"\u2948",harrw:"\u21ad",Hat:"^",hbar:"\u210f",hcirc:"\u0125",Hcirc:"\u0124",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",Hfr:"\u210c",HilbertSpace:"\u210b",hksearow:"\u2925",hkswarow:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",hookrightarrow:"\u21aa",hopf:"\ud835\udd59",Hopf:"\u210d",horbar:"\u2015",HorizontalLine:"\u2500",hscr:"\ud835\udcbd",Hscr:"\u210b",hslash:"\u210f",hstrok:"\u0127",Hstrok:"\u0126",HumpDownHump:"\u224e",HumpEqual:"\u224f",hybull:"\u2043",hyphen:"\u2010",iacute:"\xed",Iacute:"\xcd",ic:"\u2063",icirc:"\xee",Icirc:"\xce",icy:"\u0438",Icy:"\u0418",Idot:"\u0130",iecy:"\u0435",IEcy:"\u0415",iexcl:"\xa1",iff:"\u21d4",ifr:"\ud835\udd26",Ifr:"\u2111",igrave:"\xec",Igrave:"\xcc",ii:"\u2148",iiiint:"\u2a0c",iiint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",IJlig:"\u0132",Im:"\u2111",imacr:"\u012b",Imacr:"\u012a",image:"\u2111",ImaginaryI:"\u2148",imagline:"\u2110",imagpart:"\u2111",imath:"\u0131",imof:"\u22b7",imped:"\u01b5",Implies:"\u21d2",in:"\u2208",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",inodot:"\u0131",int:"\u222b",Int:"\u222c",intcal:"\u22ba",integers:"\u2124",Integral:"\u222b",intercal:"\u22ba",Intersection:"\u22c2",intlarhk:"\u2a17",intprod:"\u2a3c",InvisibleComma:"\u2063",InvisibleTimes:"\u2062",iocy:"\u0451",IOcy:"\u0401",iogon:"\u012f",Iogon:"\u012e",iopf:"\ud835\udd5a",Iopf:"\ud835\udd40",iota:"\u03b9",Iota:"\u0399",iprod:"\u2a3c",iquest:"\xbf",iscr:"\ud835\udcbe",Iscr:"\u2110",isin:"\u2208",isindot:"\u22f5",isinE:"\u22f9",isins:"\u22f4",isinsv:"\u22f3",isinv:"\u2208",it:"\u2062",itilde:"\u0129",Itilde:"\u0128",iukcy:"\u0456",Iukcy:"\u0406",iuml:"\xef",Iuml:"\xcf",jcirc:"\u0135",Jcirc:"\u0134",jcy:"\u0439",Jcy:"\u0419",jfr:"\ud835\udd27",Jfr:"\ud835\udd0d",jmath:"\u0237",jopf:"\ud835\udd5b",Jopf:"\ud835\udd41",jscr:"\ud835\udcbf",Jscr:"\ud835\udca5",jsercy:"\u0458",Jsercy:"\u0408",jukcy:"\u0454",Jukcy:"\u0404",kappa:"\u03ba",Kappa:"\u039a",kappav:"\u03f0",kcedil:"\u0137",Kcedil:"\u0136",kcy:"\u043a",Kcy:"\u041a",kfr:"\ud835\udd28",Kfr:"\ud835\udd0e",kgreen:"\u0138",khcy:"\u0445",KHcy:"\u0425",kjcy:"\u045c",KJcy:"\u040c",kopf:"\ud835\udd5c",Kopf:"\ud835\udd42",kscr:"\ud835\udcc0",Kscr:"\ud835\udca6",lAarr:"\u21da",lacute:"\u013a",Lacute:"\u0139",laemptyv:"\u29b4",lagran:"\u2112",lambda:"\u03bb",Lambda:"\u039b",lang:"\u27e8",Lang:"\u27ea",langd:"\u2991",langle:"\u27e8",lap:"\u2a85",Laplacetrf:"\u2112",laquo:"\xab",larr:"\u2190",lArr:"\u21d0",Larr:"\u219e",larrb:"\u21e4",larrbfs:"\u291f",larrfs:"\u291d",larrhk:"\u21a9",larrlp:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",lat:"\u2aab",latail:"\u2919",lAtail:"\u291b",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lBarr:"\u290e",lbbrk:"\u2772",lbrace:"{",lbrack:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",Lcaron:"\u013d",lcedil:"\u013c",Lcedil:"\u013b",lceil:"\u2308",lcub:"{",lcy:"\u043b",Lcy:"\u041b",ldca:"\u2936",ldquo:"\u201c",ldquor:"\u201e",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",lE:"\u2266",LeftAngleBracket:"\u27e8",leftarrow:"\u2190",Leftarrow:"\u21d0",LeftArrow:"\u2190",LeftArrowBar:"\u21e4",LeftArrowRightArrow:"\u21c6",leftarrowtail:"\u21a2",LeftCeiling:"\u2308",LeftDoubleBracket:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",leftharpoondown:"\u21bd",leftharpoonup:"\u21bc",leftleftarrows:"\u21c7",leftrightarrow:"\u2194",Leftrightarrow:"\u21d4",LeftRightArrow:"\u2194",leftrightarrows:"\u21c6",leftrightharpoons:"\u21cb",leftrightsquigarrow:"\u21ad",LeftRightVector:"\u294e",LeftTee:"\u22a3",LeftTeeArrow:"\u21a4",LeftTeeVector:"\u295a",leftthreetimes:"\u22cb",LeftTriangle:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",LeftVectorBar:"\u2952",leg:"\u22da",lEg:"\u2a8b",leq:"\u2264",leqq:"\u2266",leqslant:"\u2a7d",les:"\u2a7d",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessapprox:"\u2a85",lessdot:"\u22d6",lesseqgtr:"\u22da",lesseqqgtr:"\u2a8b",LessEqualGreater:"\u22da",LessFullEqual:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",LessLess:"\u2aa1",lesssim:"\u2272",LessSlantEqual:"\u2a7d",LessTilde:"\u2272",lfisht:"\u297c",lfloor:"\u230a",lfr:"\ud835\udd29",Lfr:"\ud835\udd0f",lg:"\u2276",lgE:"\u2a91",lHar:"\u2962",lhard:"\u21bd",lharu:"\u21bc",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",LJcy:"\u0409",ll:"\u226a",Ll:"\u22d8",llarr:"\u21c7",llcorner:"\u231e",Lleftarrow:"\u21da",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",Lmidot:"\u013f",lmoust:"\u23b0",lmoustache:"\u23b0",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lnE:"\u2268",lneq:"\u2a87",lneqq:"\u2268",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",lobrk:"\u27e6",longleftarrow:"\u27f5",Longleftarrow:"\u27f8",LongLeftArrow:"\u27f5",longleftrightarrow:"\u27f7",Longleftrightarrow:"\u27fa",LongLeftRightArrow:"\u27f7",longmapsto:"\u27fc",longrightarrow:"\u27f6",Longrightarrow:"\u27f9",LongRightArrow:"\u27f6",looparrowleft:"\u21ab",looparrowright:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",Lopf:"\ud835\udd43",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",lowbar:"_",LowerLeftArrow:"\u2199",LowerRightArrow:"\u2198",loz:"\u25ca",lozenge:"\u25ca",lozf:"\u29eb",lpar:"(",lparlt:"\u2993",lrarr:"\u21c6",lrcorner:"\u231f",lrhar:"\u21cb",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",Lscr:"\u2112",lsh:"\u21b0",Lsh:"\u21b0",lsim:"\u2272",lsime:"\u2a8d",lsimg:"\u2a8f",lsqb:"[",lsquo:"\u2018",lsquor:"\u201a",lstrok:"\u0142",Lstrok:"\u0141",lt:"<",Lt:"\u226a",LT:"<",ltcc:"\u2aa6",ltcir:"\u2a79",ltdot:"\u22d6",lthree:"\u22cb",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltri:"\u25c3",ltrie:"\u22b4",ltrif:"\u25c2",ltrPar:"\u2996",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",macr:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",map:"\u21a6",Map:"\u2905",mapsto:"\u21a6",mapstodown:"\u21a7",mapstoleft:"\u21a4",mapstoup:"\u21a5",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",Mcy:"\u041c",mdash:"\u2014",mDDot:"\u223a",measuredangle:"\u2221",MediumSpace:"\u205f",Mellintrf:"\u2133",mfr:"\ud835\udd2a",Mfr:"\ud835\udd10",mho:"\u2127",micro:"\xb5",mid:"\u2223",midast:"*",midcir:"\u2af0",middot:"\xb7",minus:"\u2212",minusb:"\u229f",minusd:"\u2238",minusdu:"\u2a2a",MinusPlus:"\u2213",mlcp:"\u2adb",mldr:"\u2026",mnplus:"\u2213",models:"\u22a7",mopf:"\ud835\udd5e",Mopf:"\ud835\udd44",mp:"\u2213",mscr:"\ud835\udcc2",Mscr:"\u2133",mstpos:"\u223e",mu:"\u03bc",Mu:"\u039c",multimap:"\u22b8",mumap:"\u22b8",nabla:"\u2207",nacute:"\u0144",Nacute:"\u0143",nang:"\u2220\u20d2",nap:"\u2249",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",napprox:"\u2249",natur:"\u266e",natural:"\u266e",naturals:"\u2115",nbsp:"\xa0",nbump:"\u224e\u0338",nbumpe:"\u224f\u0338",ncap:"\u2a43",ncaron:"\u0148",Ncaron:"\u0147",ncedil:"\u0146",Ncedil:"\u0145",ncong:"\u2247",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",Ncy:"\u041d",ndash:"\u2013",ne:"\u2260",nearhk:"\u2924",nearr:"\u2197",neArr:"\u21d7",nearrow:"\u2197",nedot:"\u2250\u0338",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",nequiv:"\u2262",nesear:"\u2928",nesim:"\u2242\u0338",NestedGreaterGreater:"\u226b",NestedLessLess:"\u226a",NewLine:"\n",nexist:"\u2204",nexists:"\u2204",nfr:"\ud835\udd2b",Nfr:"\ud835\udd11",nge:"\u2271",ngE:"\u2267\u0338",ngeq:"\u2271",ngeqq:"\u2267\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",nGg:"\u22d9\u0338",ngsim:"\u2275",ngt:"\u226f",nGt:"\u226b\u20d2",ngtr:"\u226f",nGtv:"\u226b\u0338",nharr:"\u21ae",nhArr:"\u21ce",nhpar:"\u2af2",ni:"\u220b",nis:"\u22fc",nisd:"\u22fa",niv:"\u220b",njcy:"\u045a",NJcy:"\u040a",nlarr:"\u219a",nlArr:"\u21cd",nldr:"\u2025",nle:"\u2270",nlE:"\u2266\u0338",nleftarrow:"\u219a",nLeftarrow:"\u21cd",nleftrightarrow:"\u21ae",nLeftrightarrow:"\u21ce",nleq:"\u2270",nleqq:"\u2266\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",nless:"\u226e",nLl:"\u22d8\u0338",nlsim:"\u2274",nlt:"\u226e",nLt:"\u226a\u20d2",nltri:"\u22ea",nltrie:"\u22ec",nLtv:"\u226a\u0338",nmid:"\u2224",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nopf:"\ud835\udd5f",Nopf:"\u2115",not:"\xac",Not:"\u2aec",NotCongruent:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",NotElement:"\u2209",NotEqual:"\u2260",NotEqualTilde:"\u2242\u0338",NotExists:"\u2204",NotGreater:"\u226f",NotGreaterEqual:"\u2271",NotGreaterFullEqual:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",NotGreaterLess:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",NotGreaterTilde:"\u2275",NotHumpDownHump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",notin:"\u2209",notindot:"\u22f5\u0338",notinE:"\u22f9\u0338",notinva:"\u2209",notinvb:"\u22f7",notinvc:"\u22f6",NotLeftTriangle:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",NotLess:"\u226e",NotLessEqual:"\u2270",NotLessGreater:"\u2278",NotLessLess:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",NotLessTilde:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",notni:"\u220c",notniva:"\u220c",notnivb:"\u22fe",notnivc:"\u22fd",NotPrecedes:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",NotReverseElement:"\u220c",NotRightTriangle:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",NotSubset:"\u2282\u20d2",NotSubsetEqual:"\u2288",NotSucceeds:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",NotSupersetEqual:"\u2289",NotTilde:"\u2241",NotTildeEqual:"\u2244",NotTildeFullEqual:"\u2247",NotTildeTilde:"\u2249",NotVerticalBar:"\u2224",npar:"\u2226",nparallel:"\u2226",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",npr:"\u2280",nprcue:"\u22e0",npre:"\u2aaf\u0338",nprec:"\u2280",npreceq:"\u2aaf\u0338",nrarr:"\u219b",nrArr:"\u21cf",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nrightarrow:"\u219b",nRightarrow:"\u21cf",nrtri:"\u22eb",nrtrie:"\u22ed",nsc:"\u2281",nsccue:"\u22e1",nsce:"\u2ab0\u0338",nscr:"\ud835\udcc3",Nscr:"\ud835\udca9",nshortmid:"\u2224",nshortparallel:"\u2226",nsim:"\u2241",nsime:"\u2244",nsimeq:"\u2244",nsmid:"\u2224",nspar:"\u2226",nsqsube:"\u22e2",nsqsupe:"\u22e3",nsub:"\u2284",nsube:"\u2288",nsubE:"\u2ac5\u0338",nsubset:"\u2282\u20d2",nsubseteq:"\u2288",nsubseteqq:"\u2ac5\u0338",nsucc:"\u2281",nsucceq:"\u2ab0\u0338",nsup:"\u2285",nsupe:"\u2289",nsupE:"\u2ac6\u0338",nsupset:"\u2283\u20d2",nsupseteq:"\u2289",nsupseteqq:"\u2ac6\u0338",ntgl:"\u2279",ntilde:"\xf1",Ntilde:"\xd1",ntlg:"\u2278",ntriangleleft:"\u22ea",ntrianglelefteq:"\u22ec",ntriangleright:"\u22eb",ntrianglerighteq:"\u22ed",nu:"\u03bd",Nu:"\u039d",num:"#",numero:"\u2116",numsp:"\u2007",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvDash:"\u22ad",nVdash:"\u22ae",nVDash:"\u22af",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvHarr:"\u2904",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwarhk:"\u2923",nwarr:"\u2196",nwArr:"\u21d6",nwarrow:"\u2196",nwnear:"\u2927",oacute:"\xf3",Oacute:"\xd3",oast:"\u229b",ocir:"\u229a",ocirc:"\xf4",Ocirc:"\xd4",ocy:"\u043e",Ocy:"\u041e",odash:"\u229d",odblac:"\u0151",Odblac:"\u0150",odiv:"\u2a38",odot:"\u2299",odsold:"\u29bc",oelig:"\u0153",OElig:"\u0152",ofcir:"\u29bf",ofr:"\ud835\udd2c",Ofr:"\ud835\udd12",ogon:"\u02db",ograve:"\xf2",Ograve:"\xd2",ogt:"\u29c1",ohbar:"\u29b5",ohm:"\u03a9",oint:"\u222e",olarr:"\u21ba",olcir:"\u29be",olcross:"\u29bb",oline:"\u203e",olt:"\u29c0",omacr:"\u014d",Omacr:"\u014c",omega:"\u03c9",Omega:"\u03a9",omicron:"\u03bf",Omicron:"\u039f",omid:"\u29b6",ominus:"\u2296",oopf:"\ud835\udd60",Oopf:"\ud835\udd46",opar:"\u29b7",OpenCurlyDoubleQuote:"\u201c",OpenCurlyQuote:"\u2018",operp:"\u29b9",oplus:"\u2295",or:"\u2228",Or:"\u2a54",orarr:"\u21bb",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oS:"\u24c8",oscr:"\u2134",Oscr:"\ud835\udcaa",oslash:"\xf8",Oslash:"\xd8",osol:"\u2298",otilde:"\xf5",Otilde:"\xd5",otimes:"\u2297",Otimes:"\u2a37",otimesas:"\u2a36",ouml:"\xf6",Ouml:"\xd6",ovbar:"\u233d",OverBar:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",OverParenthesis:"\u23dc",par:"\u2225",para:"\xb6",parallel:"\u2225",parsim:"\u2af3",parsl:"\u2afd",part:"\u2202",PartialD:"\u2202",pcy:"\u043f",Pcy:"\u041f",percnt:"%",period:".",permil:"\u2030",perp:"\u22a5",pertenk:"\u2031",pfr:"\ud835\udd2d",Pfr:"\ud835\udd13",phi:"\u03c6",Phi:"\u03a6",phiv:"\u03d5",phmmat:"\u2133",phone:"\u260e",pi:"\u03c0",Pi:"\u03a0",pitchfork:"\u22d4",piv:"\u03d6",planck:"\u210f",planckh:"\u210e",plankv:"\u210f",plus:"+",plusacir:"\u2a23",plusb:"\u229e",pluscir:"\u2a22",plusdo:"\u2214",plusdu:"\u2a25",pluse:"\u2a72",PlusMinus:"\xb1",plusmn:"\xb1",plussim:"\u2a26",plustwo:"\u2a27",pm:"\xb1",Poincareplane:"\u210c",pointint:"\u2a15",popf:"\ud835\udd61",Popf:"\u2119",pound:"\xa3",pr:"\u227a",Pr:"\u2abb",prap:"\u2ab7",prcue:"\u227c",pre:"\u2aaf",prE:"\u2ab3",prec:"\u227a",precapprox:"\u2ab7",preccurlyeq:"\u227c",Precedes:"\u227a",PrecedesEqual:"\u2aaf",PrecedesSlantEqual:"\u227c",PrecedesTilde:"\u227e",preceq:"\u2aaf",precnapprox:"\u2ab9",precneqq:"\u2ab5",precnsim:"\u22e8",precsim:"\u227e",prime:"\u2032",Prime:"\u2033",primes:"\u2119",prnap:"\u2ab9",prnE:"\u2ab5",prnsim:"\u22e8",prod:"\u220f",Product:"\u220f",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prop:"\u221d",Proportion:"\u2237",Proportional:"\u221d",propto:"\u221d",prsim:"\u227e",prurel:"\u22b0",pscr:"\ud835\udcc5",Pscr:"\ud835\udcab",psi:"\u03c8",Psi:"\u03a8",puncsp:"\u2008",qfr:"\ud835\udd2e",Qfr:"\ud835\udd14",qint:"\u2a0c",qopf:"\ud835\udd62",Qopf:"\u211a",qprime:"\u2057",qscr:"\ud835\udcc6",Qscr:"\ud835\udcac",quaternions:"\u210d",quatint:"\u2a16",quest:"?",questeq:"\u225f",quot:'"',QUOT:'"',rAarr:"\u21db",race:"\u223d\u0331",racute:"\u0155",Racute:"\u0154",radic:"\u221a",raemptyv:"\u29b3",rang:"\u27e9",Rang:"\u27eb",rangd:"\u2992",range:"\u29a5",rangle:"\u27e9",raquo:"\xbb",rarr:"\u2192",rArr:"\u21d2",Rarr:"\u21a0",rarrap:"\u2975",rarrb:"\u21e5",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrhk:"\u21aa",rarrlp:"\u21ac",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",Rarrtl:"\u2916",rarrw:"\u219d",ratail:"\u291a",rAtail:"\u291c",ratio:"\u2236",rationals:"\u211a",rbarr:"\u290d",rBarr:"\u290f",RBarr:"\u2910",rbbrk:"\u2773",rbrace:"}",rbrack:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",Rcaron:"\u0158",rcedil:"\u0157",Rcedil:"\u0156",rceil:"\u2309",rcub:"}",rcy:"\u0440",Rcy:"\u0420",rdca:"\u2937",rdldhar:"\u2969",rdquo:"\u201d",rdquor:"\u201d",rdsh:"\u21b3",Re:"\u211c",real:"\u211c",realine:"\u211b",realpart:"\u211c",reals:"\u211d",rect:"\u25ad",reg:"\xae",REG:"\xae",ReverseElement:"\u220b",ReverseEquilibrium:"\u21cb",ReverseUpEquilibrium:"\u296f",rfisht:"\u297d",rfloor:"\u230b",rfr:"\ud835\udd2f",Rfr:"\u211c",rHar:"\u2964",rhard:"\u21c1",rharu:"\u21c0",rharul:"\u296c",rho:"\u03c1",Rho:"\u03a1",rhov:"\u03f1",RightAngleBracket:"\u27e9",rightarrow:"\u2192",Rightarrow:"\u21d2",RightArrow:"\u2192",RightArrowBar:"\u21e5",RightArrowLeftArrow:"\u21c4",rightarrowtail:"\u21a3",RightCeiling:"\u2309",RightDoubleBracket:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rightharpoondown:"\u21c1",rightharpoonup:"\u21c0",rightleftarrows:"\u21c4",rightleftharpoons:"\u21cc",rightrightarrows:"\u21c9",rightsquigarrow:"\u219d",RightTee:"\u22a2",RightTeeArrow:"\u21a6",RightTeeVector:"\u295b",rightthreetimes:"\u22cc",RightTriangle:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",RightVectorBar:"\u2953",ring:"\u02da",risingdotseq:"\u2253",rlarr:"\u21c4",rlhar:"\u21cc",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",robrk:"\u27e7",ropar:"\u2986",ropf:"\ud835\udd63",Ropf:"\u211d",roplus:"\u2a2e",rotimes:"\u2a35",RoundImplies:"\u2970",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rrarr:"\u21c9",Rrightarrow:"\u21db",rsaquo:"\u203a",rscr:"\ud835\udcc7",Rscr:"\u211b",rsh:"\u21b1",Rsh:"\u21b1",rsqb:"]",rsquo:"\u2019",rsquor:"\u2019",rthree:"\u22cc",rtimes:"\u22ca",rtri:"\u25b9",rtrie:"\u22b5",rtrif:"\u25b8",rtriltri:"\u29ce",RuleDelayed:"\u29f4",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",Sacute:"\u015a",sbquo:"\u201a",sc:"\u227b",Sc:"\u2abc",scap:"\u2ab8",scaron:"\u0161",Scaron:"\u0160",sccue:"\u227d",sce:"\u2ab0",scE:"\u2ab4",scedil:"\u015f",Scedil:"\u015e",scirc:"\u015d",Scirc:"\u015c",scnap:"\u2aba",scnE:"\u2ab6",scnsim:"\u22e9",scpolint:"\u2a13",scsim:"\u227f",scy:"\u0441",Scy:"\u0421",sdot:"\u22c5",sdotb:"\u22a1",sdote:"\u2a66",searhk:"\u2925",searr:"\u2198",seArr:"\u21d8",searrow:"\u2198",sect:"\xa7",semi:";",seswar:"\u2929",setminus:"\u2216",setmn:"\u2216",sext:"\u2736",sfr:"\ud835\udd30",Sfr:"\ud835\udd16",sfrown:"\u2322",sharp:"\u266f",shchcy:"\u0449",SHCHcy:"\u0429",shcy:"\u0448",SHcy:"\u0428",ShortDownArrow:"\u2193",ShortLeftArrow:"\u2190",shortmid:"\u2223",shortparallel:"\u2225",ShortRightArrow:"\u2192",ShortUpArrow:"\u2191",shy:"\xad",sigma:"\u03c3",Sigma:"\u03a3",sigmaf:"\u03c2",sigmav:"\u03c2",sim:"\u223c",simdot:"\u2a6a",sime:"\u2243",simeq:"\u2243",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",slarr:"\u2190",SmallCircle:"\u2218",smallsetminus:"\u2216",smashp:"\u2a33",smeparsl:"\u29e4",smid:"\u2223",smile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",SOFTcy:"\u042c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",Sopf:"\ud835\udd4a",spades:"\u2660",spadesuit:"\u2660",spar:"\u2225",sqcap:"\u2293",sqcaps:"\u2293\ufe00",sqcup:"\u2294",sqcups:"\u2294\ufe00",Sqrt:"\u221a",sqsub:"\u228f",sqsube:"\u2291",sqsubset:"\u228f",sqsubseteq:"\u2291",sqsup:"\u2290",sqsupe:"\u2292",sqsupset:"\u2290",sqsupseteq:"\u2292",squ:"\u25a1",square:"\u25a1",Square:"\u25a1",SquareIntersection:"\u2293",SquareSubset:"\u228f",SquareSubsetEqual:"\u2291",SquareSuperset:"\u2290",SquareSupersetEqual:"\u2292",SquareUnion:"\u2294",squarf:"\u25aa",squf:"\u25aa",srarr:"\u2192",sscr:"\ud835\udcc8",Sscr:"\ud835\udcae",ssetmn:"\u2216",ssmile:"\u2323",sstarf:"\u22c6",star:"\u2606",Star:"\u22c6",starf:"\u2605",straightepsilon:"\u03f5",straightphi:"\u03d5",strns:"\xaf",sub:"\u2282",Sub:"\u22d0",subdot:"\u2abd",sube:"\u2286",subE:"\u2ac5",subedot:"\u2ac3",submult:"\u2ac1",subne:"\u228a",subnE:"\u2acb",subplus:"\u2abf",subrarr:"\u2979",subset:"\u2282",Subset:"\u22d0",subseteq:"\u2286",subseteqq:"\u2ac5",SubsetEqual:"\u2286",subsetneq:"\u228a",subsetneqq:"\u2acb",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",succ:"\u227b",succapprox:"\u2ab8",succcurlyeq:"\u227d",Succeeds:"\u227b",SucceedsEqual:"\u2ab0",SucceedsSlantEqual:"\u227d",SucceedsTilde:"\u227f",succeq:"\u2ab0",succnapprox:"\u2aba",succneqq:"\u2ab6",succnsim:"\u22e9",succsim:"\u227f",SuchThat:"\u220b",sum:"\u2211",Sum:"\u2211",sung:"\u266a",sup:"\u2283",Sup:"\u22d1",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supdot:"\u2abe",supdsub:"\u2ad8",supe:"\u2287",supE:"\u2ac6",supedot:"\u2ac4",Superset:"\u2283",SupersetEqual:"\u2287",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supne:"\u228b",supnE:"\u2acc",supplus:"\u2ac0",supset:"\u2283",Supset:"\u22d1",supseteq:"\u2287",supseteqq:"\u2ac6",supsetneq:"\u228b",supsetneqq:"\u2acc",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swarhk:"\u2926",swarr:"\u2199",swArr:"\u21d9",swarrow:"\u2199",swnwar:"\u292a",szlig:"\xdf",Tab:"\t",target:"\u2316",tau:"\u03c4",Tau:"\u03a4",tbrk:"\u23b4",tcaron:"\u0165",Tcaron:"\u0164",tcedil:"\u0163",Tcedil:"\u0162",tcy:"\u0442",Tcy:"\u0422",tdot:"\u20db",telrec:"\u2315",tfr:"\ud835\udd31",Tfr:"\ud835\udd17",there4:"\u2234",therefore:"\u2234",Therefore:"\u2234",theta:"\u03b8",Theta:"\u0398",thetasym:"\u03d1",thetav:"\u03d1",thickapprox:"\u2248",thicksim:"\u223c",ThickSpace:"\u205f\u200a",thinsp:"\u2009",ThinSpace:"\u2009",thkap:"\u2248",thksim:"\u223c",thorn:"\xfe",THORN:"\xde",tilde:"\u02dc",Tilde:"\u223c",TildeEqual:"\u2243",TildeFullEqual:"\u2245",TildeTilde:"\u2248",times:"\xd7",timesb:"\u22a0",timesbar:"\u2a31",timesd:"\u2a30",tint:"\u222d",toea:"\u2928",top:"\u22a4",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",Topf:"\ud835\udd4b",topfork:"\u2ada",tosa:"\u2929",tprime:"\u2034",trade:"\u2122",TRADE:"\u2122",triangle:"\u25b5",triangledown:"\u25bf",triangleleft:"\u25c3",trianglelefteq:"\u22b4",triangleq:"\u225c",triangleright:"\u25b9",trianglerighteq:"\u22b5",tridot:"\u25ec",trie:"\u225c",triminus:"\u2a3a",TripleDot:"\u20db",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",Tscr:"\ud835\udcaf",tscy:"\u0446",TScy:"\u0426",tshcy:"\u045b",TSHcy:"\u040b",tstrok:"\u0167",Tstrok:"\u0166",twixt:"\u226c",twoheadleftarrow:"\u219e",twoheadrightarrow:"\u21a0",uacute:"\xfa",Uacute:"\xda",uarr:"\u2191",uArr:"\u21d1",Uarr:"\u219f",Uarrocir:"\u2949",ubrcy:"\u045e",Ubrcy:"\u040e",ubreve:"\u016d",Ubreve:"\u016c",ucirc:"\xfb",Ucirc:"\xdb",ucy:"\u0443",Ucy:"\u0423",udarr:"\u21c5",udblac:"\u0171",Udblac:"\u0170",udhar:"\u296e",ufisht:"\u297e",ufr:"\ud835\udd32",Ufr:"\ud835\udd18",ugrave:"\xf9",Ugrave:"\xd9",uHar:"\u2963",uharl:"\u21bf",uharr:"\u21be",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",Umacr:"\u016a",uml:"\xa8",UnderBar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",UnionPlus:"\u228e",uogon:"\u0173",Uogon:"\u0172",uopf:"\ud835\udd66",Uopf:"\ud835\udd4c",uparrow:"\u2191",Uparrow:"\u21d1",UpArrow:"\u2191",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",updownarrow:"\u2195",Updownarrow:"\u21d5",UpDownArrow:"\u2195",UpEquilibrium:"\u296e",upharpoonleft:"\u21bf",upharpoonright:"\u21be",uplus:"\u228e",UpperLeftArrow:"\u2196",UpperRightArrow:"\u2197",upsi:"\u03c5",Upsi:"\u03d2",upsih:"\u03d2",upsilon:"\u03c5",Upsilon:"\u03a5",UpTee:"\u22a5",UpTeeArrow:"\u21a5",upuparrows:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",Uring:"\u016e",urtri:"\u25f9",uscr:"\ud835\udcca",Uscr:"\ud835\udcb0",utdot:"\u22f0",utilde:"\u0169",Utilde:"\u0168",utri:"\u25b5",utrif:"\u25b4",uuarr:"\u21c8",uuml:"\xfc",Uuml:"\xdc",uwangle:"\u29a7",vangrt:"\u299c",varepsilon:"\u03f5",varkappa:"\u03f0",varnothing:"\u2205",varphi:"\u03d5",varpi:"\u03d6",varpropto:"\u221d",varr:"\u2195",vArr:"\u21d5",varrho:"\u03f1",varsigma:"\u03c2",varsubsetneq:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vartheta:"\u03d1",vartriangleleft:"\u22b2",vartriangleright:"\u22b3",vBar:"\u2ae8",Vbar:"\u2aeb",vBarv:"\u2ae9",vcy:"\u0432",Vcy:"\u0412",vdash:"\u22a2",vDash:"\u22a8",Vdash:"\u22a9",VDash:"\u22ab",Vdashl:"\u2ae6",vee:"\u2228",Vee:"\u22c1",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",verbar:"|",Verbar:"\u2016",vert:"|",Vert:"\u2016",VerticalBar:"\u2223",VerticalLine:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",VeryThinSpace:"\u200a",vfr:"\ud835\udd33",Vfr:"\ud835\udd19",vltri:"\u22b2",vnsub:"\u2282\u20d2",vnsup:"\u2283\u20d2",vopf:"\ud835\udd67",Vopf:"\ud835\udd4d",vprop:"\u221d",vrtri:"\u22b3",vscr:"\ud835\udccb",Vscr:"\ud835\udcb1",vsubne:"\u228a\ufe00",vsubnE:"\u2acb\ufe00",vsupne:"\u228b\ufe00",vsupnE:"\u2acc\ufe00",Vvdash:"\u22aa",vzigzag:"\u299a",wcirc:"\u0175",Wcirc:"\u0174",wedbar:"\u2a5f",wedge:"\u2227",Wedge:"\u22c0",wedgeq:"\u2259",weierp:"\u2118",wfr:"\ud835\udd34",Wfr:"\ud835\udd1a",wopf:"\ud835\udd68",Wopf:"\ud835\udd4e",wp:"\u2118",wr:"\u2240",wreath:"\u2240",wscr:"\ud835\udccc",Wscr:"\ud835\udcb2",xcap:"\u22c2",xcirc:"\u25ef",xcup:"\u22c3",xdtri:"\u25bd",xfr:"\ud835\udd35",Xfr:"\ud835\udd1b",xharr:"\u27f7",xhArr:"\u27fa",xi:"\u03be",Xi:"\u039e",xlarr:"\u27f5",xlArr:"\u27f8",xmap:"\u27fc",xnis:"\u22fb",xodot:"\u2a00",xopf:"\ud835\udd69",Xopf:"\ud835\udd4f",xoplus:"\u2a01",xotime:"\u2a02",xrarr:"\u27f6",xrArr:"\u27f9",xscr:"\ud835\udccd",Xscr:"\ud835\udcb3",xsqcup:"\u2a06",xuplus:"\u2a04",xutri:"\u25b3",xvee:"\u22c1",xwedge:"\u22c0",yacute:"\xfd",Yacute:"\xdd",yacy:"\u044f",YAcy:"\u042f",ycirc:"\u0177",Ycirc:"\u0176",ycy:"\u044b",Ycy:"\u042b",yen:"\xa5",yfr:"\ud835\udd36",Yfr:"\ud835\udd1c",yicy:"\u0457",YIcy:"\u0407",yopf:"\ud835\udd6a",Yopf:"\ud835\udd50",yscr:"\ud835\udcce",Yscr:"\ud835\udcb4",yucy:"\u044e",YUcy:"\u042e",yuml:"\xff",Yuml:"\u0178",zacute:"\u017a",Zacute:"\u0179",zcaron:"\u017e",Zcaron:"\u017d",zcy:"\u0437",Zcy:"\u0417",zdot:"\u017c",Zdot:"\u017b",zeetrf:"\u2128",ZeroWidthSpace:"\u200b",zeta:"\u03b6",Zeta:"\u0396",zfr:"\ud835\udd37",Zfr:"\u2128",zhcy:"\u0436",ZHcy:"\u0416",zigrarr:"\u21dd",zopf:"\ud835\udd6b",Zopf:"\u2124",zscr:"\ud835\udccf",Zscr:"\ud835\udcb5",zwj:"\u200d",zwnj:"\u200c"},h={aacute:"\xe1",Aacute:"\xc1",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",aelig:"\xe6",AElig:"\xc6",agrave:"\xe0",Agrave:"\xc0",amp:"&",AMP:"&",aring:"\xe5",Aring:"\xc5",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",brvbar:"\xa6",ccedil:"\xe7",Ccedil:"\xc7",cedil:"\xb8",cent:"\xa2",copy:"\xa9",COPY:"\xa9",curren:"\xa4",deg:"\xb0",divide:"\xf7",eacute:"\xe9",Eacute:"\xc9",ecirc:"\xea",Ecirc:"\xca",egrave:"\xe8",Egrave:"\xc8",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",frac12:"\xbd",frac14:"\xbc",frac34:"\xbe",gt:">",GT:">",iacute:"\xed",Iacute:"\xcd",icirc:"\xee",Icirc:"\xce",iexcl:"\xa1",igrave:"\xec",Igrave:"\xcc",iquest:"\xbf",iuml:"\xef",Iuml:"\xcf",laquo:"\xab",lt:"<",LT:"<",macr:"\xaf",micro:"\xb5",middot:"\xb7",nbsp:"\xa0",not:"\xac",ntilde:"\xf1",Ntilde:"\xd1",oacute:"\xf3",Oacute:"\xd3",ocirc:"\xf4",Ocirc:"\xd4",ograve:"\xf2",Ograve:"\xd2",ordf:"\xaa",ordm:"\xba",oslash:"\xf8",Oslash:"\xd8",otilde:"\xf5",Otilde:"\xd5",ouml:"\xf6",Ouml:"\xd6",para:"\xb6",plusmn:"\xb1",pound:"\xa3",quot:'"',QUOT:'"',raquo:"\xbb",reg:"\xae",REG:"\xae",sect:"\xa7",shy:"\xad",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",szlig:"\xdf",thorn:"\xfe",THORN:"\xde",times:"\xd7",uacute:"\xfa",Uacute:"\xda",ucirc:"\xfb",Ucirc:"\xdb",ugrave:"\xf9",Ugrave:"\xd9",uml:"\xa8",uuml:"\xfc",Uuml:"\xdc",yacute:"\xfd",Yacute:"\xdd",yen:"\xa5",yuml:"\xff"},v={0:"\ufffd",128:"\u20ac",130:"\u201a",131:"\u0192",132:"\u201e",133:"\u2026",134:"\u2020",135:"\u2021",136:"\u02c6",137:"\u2030",138:"\u0160",139:"\u2039",140:"\u0152",142:"\u017d",145:"\u2018",146:"\u2019",147:"\u201c",148:"\u201d",149:"\u2022",150:"\u2013",151:"\u2014",152:"\u02dc",153:"\u2122",154:"\u0161",155:"\u203a",156:"\u0153",158:"\u017e",159:"\u0178"},g=[1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65e3,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111],b=String.fromCharCode,y={}.hasOwnProperty,w=function(e,r){return y.call(e,r)},A=function(e,r){if(!e)return r;var t,n={};for(t in r)n[t]=w(e,t)?e[t]:r[t];return n},D=function(e,r){var t="";return e>=55296&&e<=57343||e>1114111?(r&&k("character reference outside the permissible Unicode range"),"\ufffd"):w(v,e)?(r&&k("disallowed character reference"),v[e]):(r&&function(e,r){for(var t=-1,n=e.length;++t<n;)if(e[t]==r)return!0;return!1}(g,e)&&k("disallowed character reference"),e>65535&&(t+=b((e-=65536)>>>10&1023|55296),e=56320|1023&e),t+=b(e))},x=function(e){return"&#x"+e.toString(16).toUpperCase()+";"},q=function(e){return"&#"+e+";"},k=function(e){throw Error("Parse error: "+e)},E=function(e,r){(r=A(r,E.options)).strict&&f.test(e)&&k("forbidden code point");var t=r.encodeEverything,n=r.useNamedReferences,l=r.allowUnsafeSymbols,p=r.decimal?q:x,d=function(e){return p(e.charCodeAt(0))};return t?(e=e.replace(o,function(e){return n&&w(c,e)?"&"+c[e]+";":d(e)}),n&&(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;").replace(/&#x66;&#x6A;/g,"&fjlig;")),n&&(e=e.replace(s,function(e){return"&"+c[e]+";"}))):n?(l||(e=e.replace(u,function(e){return"&"+c[e]+";"})),e=(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;")).replace(s,function(e){return"&"+c[e]+";"})):l||(e=e.replace(u,d)),e.replace(a,function(e){var r=e.charCodeAt(0),t=e.charCodeAt(1);return p(1024*(r-55296)+t-56320+65536)}).replace(i,d)};E.options={allowUnsafeSymbols:!1,encodeEverything:!1,strict:!1,useNamedReferences:!1,decimal:!1};var _=function(e,r){var t=(r=A(r,_.options)).strict;return t&&p.test(e)&&k("malformed character reference"),e.replace(d,function(e,n,a,o,i,s,c,u,l){var p,f,d,v,g,b;return n?m[g=n]:a?(g=a,(b=o)&&r.isAttributeValue?(t&&"="==b&&k("`&` did not start a character reference"),e):(t&&k("named character reference was not terminated by a semicolon"),h[g]+(b||""))):i?(d=i,f=s,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(d,10),D(p,t)):c?(v=c,f=u,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(v,16),D(p,t)):(t&&k("named character reference was not terminated by a semicolon"),e)})};_.options={isAttributeValue:!1,strict:!1};var C={version:"1.2.0",encode:E,decode:_,escape:function(e){return e.replace(u,function(e){return l[e]})},unescape:_};if("function"==typeof define&&"object"==typeof define.amd&&define.amd)define(function(){return C});else if(r&&!r.nodeType)if(t)t.exports=C;else for(var S in C)w(C,S)&&(r[S]=C[S]);else e.he=C}(void 0);var yo=f("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),wo=f("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Ao=f("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Do=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,qo="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+U.source+"]*",ko="((?:"+qo+"\\:)?"+qo+")",Eo=new RegExp("^<"+ko),_o=/^\s*(\/?)>/,Co=new RegExp("^<\\/"+ko+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,Lo=/^<!\--/,To=/^<!\[/,$o=f("script,style,textarea",!0),No={},Oo={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ro=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Bo=f("pre,textarea",!0),Uo=function(e,r){return e&&Bo(e)&&"\n"===r[0]};function Vo(e,r){var t=r?Fo:Ro;return e.replace(t,function(e){return Oo[e]})}var Io,jo,Po,Ho,Mo,Go,zo,Jo,Ko=/^@|^v-on:/,Zo=/^v-|^@|^:|^#/,Yo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Wo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,Xo=/^\[.*\]$/,ei=/:(.*)$/,ri=/^:|^\.|^v-bind:/,ti=/\.[^.\]]+(?=[^\]]*$)/g,ni=/^v-slot(:|$)|^#/,ai=/[\r\n]/,oi=/[ \f\t\r\n]+/g,ii=b(void 0),si="_empty_";function ci(e,r,t){return{type:1,tag:e,attrsList:r,attrsMap:hi(r),rawAttrsMap:{},parent:t,children:[]}}function ui(e,r){Io=r.warn||Sn,Go=r.isPreTag||S,zo=r.mustUseProp||S,Jo=r.getTagNamespace||S;r.isReservedTag;Po=Ln(r.modules,"transformNode"),Ho=Ln(r.modules,"preTransformNode"),Mo=Ln(r.modules,"postTransformNode"),jo=r.delimiters;var t,n,a=[],o=!1!==r.preserveWhitespace,i=r.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=li(e,r)),a.length||e===t||t.if&&(e.elseif||e.else)&&fi(t,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)i=e,(u=function(e){var r=e.length;for(;r--;){if(1===e[r].type)return e[r];e.pop()}}(n.children))&&u.if&&fi(u,{exp:i.elseif,block:i});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var i,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Go(e.tag)&&(c=!1);for(var p=0;p<Mo.length;p++)Mo[p](e,r)}function l(e){if(!c)for(var r;(r=e.children[e.children.length-1])&&3===r.type&&" "===r.text;)e.children.pop()}return function(e,r){for(var t,n,a=[],o=r.expectHTML,i=r.isUnaryTag||S,s=r.canBeLeftOpenTag||S,c=0;e;){if(t=e,n&&$o(n)){var u=0,l=n.toLowerCase(),p=No[l]||(No[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),f=e.replace(p,function(e,t,n){return u=n.length,$o(l)||"noscript"===l||(t=t.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Uo(l,t)&&(t=t.slice(1)),r.chars&&r.chars(t),""});c+=e.length-f.length,e=f,E(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(Lo.test(e)){var m=e.indexOf("--\x3e");if(m>=0){r.shouldKeepComment&&r.comment(e.substring(4,m),c,c+m+3),x(m+3);continue}}if(To.test(e)){var h=e.indexOf("]>");if(h>=0){x(h+2);continue}}var v=e.match(So);if(v){x(v[0].length);continue}var g=e.match(Co);if(g){var b=c;x(g[0].length),E(g[1],b,c);continue}var y=q();if(y){k(y),Uo(y.tagName,e)&&x(1);continue}}var w=void 0,A=void 0,D=void 0;if(d>=0){for(A=e.slice(d);!(Co.test(A)||Eo.test(A)||Lo.test(A)||To.test(A)||(D=A.indexOf("<",1))<0);)d+=D,A=e.slice(d);w=e.substring(0,d)}d<0&&(w=e),w&&x(w.length),r.chars&&w&&r.chars(w,c-w.length,c)}if(e===t){r.chars&&r.chars(e);break}}function x(r){c+=r,e=e.substring(r)}function q(){var r=e.match(Eo);if(r){var t,n,a={tagName:r[1],attrs:[],start:c};for(x(r[0].length);!(t=e.match(_o))&&(n=e.match(xo)||e.match(Do));)n.start=c,x(n[0].length),n.end=c,a.attrs.push(n);if(t)return a.unarySlash=t[1],x(t[0].length),a.end=c,a}}function k(e){var t=e.tagName,c=e.unarySlash;o&&("p"===n&&Ao(t)&&E(n),s(t)&&n===t&&E(t));for(var u=i(t)||!!c,l=e.attrs.length,p=new Array(l),f=0;f<l;f++){var d=e.attrs[f],m=d[3]||d[4]||d[5]||"",h="a"===t&&"href"===d[1]?r.shouldDecodeNewlinesForHref:r.shouldDecodeNewlines;p[f]={name:d[1],value:Vo(m,h)}}u||(a.push({tag:t,lowerCasedTag:t.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=t),r.start&&r.start(t,p,u,e.start,e.end)}function E(e,t,o){var i,s;if(null==t&&(t=c),null==o&&(o=c),e)for(s=e.toLowerCase(),i=a.length-1;i>=0&&a[i].lowerCasedTag!==s;i--);else i=0;if(i>=0){for(var u=a.length-1;u>=i;u--)r.end&&r.end(a[u].tag,t,o);a.length=i,n=i&&a[i-1].tag}else"br"===s?r.start&&r.start(e,[],!0,t,o):"p"===s&&(r.start&&r.start(e,[],!1,t,o),r.end&&r.end(e,t,o))}E()}(e,{warn:Io,expectHTML:r.expectHTML,isUnaryTag:r.isUnaryTag,canBeLeftOpenTag:r.canBeLeftOpenTag,shouldDecodeNewlines:r.shouldDecodeNewlines,shouldDecodeNewlinesForHref:r.shouldDecodeNewlinesForHref,shouldKeepComment:r.comments,outputSourceRange:r.outputSourceRange,start:function(e,o,i,l,p){var f=n&&n.ns||Jo(e);J&&"svg"===f&&(o=function(e){for(var r=[],t=0;t<e.length;t++){var n=e[t];vi.test(n.name)||(n.name=n.name.replace(gi,""),r.push(n))}return r}(o));var d,m=ci(e,o,n);f&&(m.ns=f),"style"!==(d=m).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||re()||(m.forbidden=!0);for(var h=0;h<Ho.length;h++)m=Ho[h](m,r)||m;s||(!function(e){null!=Un(e,"v-pre")&&(e.pre=!0)}(m),m.pre&&(s=!0)),Go(m.tag)&&(c=!0),s?function(e){var r=e.attrsList,t=r.length;if(t)for(var n=e.attrs=new Array(t),a=0;a<t;a++)n[a]={name:r[a].name,value:JSON.stringify(r[a].value)},null!=r[a].start&&(n[a].start=r[a].start,n[a].end=r[a].end);else e.pre||(e.plain=!0)}(m):m.processed||(pi(m),function(e){var r=Un(e,"v-if");if(r)e.if=r,fi(e,{exp:r,block:e});else{null!=Un(e,"v-else")&&(e.else=!0);var t=Un(e,"v-else-if");t&&(e.elseif=t)}}(m),function(e){null!=Un(e,"v-once")&&(e.once=!0)}(m)),t||(t=m),i?u(m):(n=m,a.push(m))},end:function(e,r,t){var o=a[a.length-1];a.length-=1,n=a[a.length-1],u(o)},chars:function(e,r,t){if(n&&(!J||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var a,u,l,p=n.children;if(e=c||e.trim()?"script"===(a=n).tag||"style"===a.tag?e:ii(e):p.length?i?"condense"===i&&ai.test(e)?"":" ":o?" ":"":"")c||"condense"!==i||(e=e.replace(oi," ")),!s&&" "!==e&&(u=function(e,r){var t=r?vo(r):mo;if(t.test(e)){for(var n,a,o,i=[],s=[],c=t.lastIndex=0;n=t.exec(e);){(a=n.index)>c&&(s.push(o=e.slice(c,a)),i.push(JSON.stringify(o)));var u=_n(n[1].trim());i.push("_s("+u+")"),s.push({"@binding":u}),c=a+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),i.push(JSON.stringify(o))),{expression:i.join("+"),tokens:s}}}(e,jo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&p.length&&" "===p[p.length-1].text||(l={type:3,text:e}),l&&p.push(l)}},comment:function(e,r,t){if(n){var a={type:3,text:e,isComment:!0};n.children.push(a)}}}),t}function li(e,r){var t,n;(n=Bn(t=e,"key"))&&(t.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var r=Bn(e,"ref");r&&(e.ref=r,e.refInFor=function(e){var r=e;for(;r;){if(void 0!==r.for)return!0;r=r.parent}return!1}(e))}(e),function(e){var r;"template"===e.tag?(r=Un(e,"scope"),e.slotScope=r||Un(e,"slot-scope")):(r=Un(e,"slot-scope"))&&(e.slotScope=r);var t=Bn(e,"slot");t&&(e.slotTarget='""'===t?'"default"':t,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||$n(e,"slot",t,function(e,r){return e.rawAttrsMap[":"+r]||e.rawAttrsMap["v-bind:"+r]||e.rawAttrsMap[r]}(e,"slot")));if("template"===e.tag){var n=Vn(e,ni);if(n){var a=di(n),o=a.name,i=a.dynamic;e.slotTarget=o,e.slotTargetDynamic=i,e.slotScope=n.value||si}}else{var s=Vn(e,ni);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=di(s),l=u.name,p=u.dynamic,f=c[l]=ci("template",[],e);f.slotTarget=l,f.slotTargetDynamic=p,f.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=f,!0}),f.slotScope=s.value||si,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Bn(e,"name"))}(e),function(e){var r;(r=Bn(e,"is"))&&(e.component=r);null!=Un(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var a=0;a<Po.length;a++)e=Po[a](e,r)||e;return function(e){var r,t,n,a,o,i,s,c,u=e.attrsList;for(r=0,t=u.length;r<t;r++)if(n=a=u[r].name,o=u[r].value,Zo.test(n))if(e.hasBindings=!0,(i=mi(n.replace(Zo,"")))&&(n=n.replace(ti,"")),ri.test(n))n=n.replace(ri,""),o=_n(o),(c=Xo.test(n))&&(n=n.slice(1,-1)),i&&(i.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),i.camel&&!c&&(n=w(n)),i.sync&&(s=Pn(o,"$event"),c?Fn(e,'"update:"+('+n+")",s,null,!1,0,u[r],!0):(Fn(e,"update:"+w(n),s,null,!1,0,u[r]),x(n)!==w(n)&&Fn(e,"update:"+x(n),s,null,!1,0,u[r])))),i&&i.prop||!e.component&&zo(e.tag,e.attrsMap.type,n)?Tn(e,n,o,u[r],c):$n(e,n,o,u[r],c);else if(Ko.test(n))n=n.replace(Ko,""),(c=Xo.test(n))&&(n=n.slice(1,-1)),Fn(e,n,o,i,!1,0,u[r],c);else{var l=(n=n.replace(Zo,"")).match(ei),p=l&&l[1];c=!1,p&&(n=n.slice(0,-(p.length+1)),Xo.test(p)&&(p=p.slice(1,-1),c=!0)),On(e,n,a,o,p,c,i,u[r])}else $n(e,n,JSON.stringify(o),u[r]),!e.component&&"muted"===n&&zo(e.tag,e.attrsMap.type,n)&&Tn(e,n,"true",u[r])}(e),e}function pi(e){var r;if(r=Un(e,"v-for")){var t=function(e){var r=e.match(Yo);if(!r)return;var t={};t.for=r[2].trim();var n=r[1].trim().replace(Qo,""),a=n.match(Wo);a?(t.alias=n.replace(Wo,"").trim(),t.iterator1=a[1].trim(),a[2]&&(t.iterator2=a[2].trim())):t.alias=n;return t}(r);t&&E(e,t)}}function fi(e,r){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(r)}function di(e){var r=e.name.replace(ni,"");return r||"#"!==e.name[0]&&(r="default"),Xo.test(r)?{name:r.slice(1,-1),dynamic:!0}:{name:'"'+r+'"',dynamic:!1}}function mi(e){var r=e.match(ti);if(r){var t={};return r.forEach(function(e){t[e.slice(1)]=!0}),t}}function hi(e){for(var r={},t=0,n=e.length;t<n;t++)r[e[t].name]=e[t].value;return r}var vi=/^xmlns:NS\d+/,gi=/^NS\d+:/;function bi(e){return ci(e.tag,e.attrsList.slice(),e.parent)}var yi=[go,bo,{preTransformNode:function(e,r){if("input"===e.tag){var t,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(t=Bn(e,"type")),n.type||t||!n["v-bind"]||(t="("+n["v-bind"]+").type"),t){var a=Un(e,"v-if",!0),o=a?"&&("+a+")":"",i=null!=Un(e,"v-else",!0),s=Un(e,"v-else-if",!0),c=bi(e);pi(c),Nn(c,"type","checkbox"),li(c,r),c.processed=!0,c.if="("+t+")==='checkbox'"+o,fi(c,{exp:c.if,block:c});var u=bi(e);Un(u,"v-for",!0),Nn(u,"type","radio"),li(u,r),fi(c,{exp:"("+t+")==='radio'"+o,block:u});var l=bi(e);return Un(l,"v-for",!0),Nn(l,":type",t),li(l,r),fi(c,{exp:a,block:l}),i?c.else=!0:s&&(c.elseif=s),c}}}}];var wi,Ai,Di={expectHTML:!0,modules:yi,directives:{model:function(e,r,t){var n=r.value,a=r.modifiers,o=e.tag,i=e.attrsMap.type;if(e.component)return jn(e,n,a),!1;if("select"===o)!function(e,r,t){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(t&&t.number?"_n(val)":"val")+"});";n=n+" "+Pn(r,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Fn(e,"change",n,null,!0)}(e,n,a);else if("input"===o&&"checkbox"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null",o=Bn(e,"true-value")||"true",i=Bn(e,"false-value")||"false";Tn(e,"checked","Array.isArray("+r+")?_i("+r+","+a+")>-1"+("true"===o?":("+r+")":":_q("+r+","+o+")")),Fn(e,"change","var $$a="+r+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+i+");if(Array.isArray($$a)){var $$v="+(n?"_n("+a+")":a)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pn(r,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pn(r,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pn(r,"$$c")+"}",null,!0)}(e,n,a);else if("input"===o&&"radio"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null";Tn(e,"checked","_q("+r+","+(a=n?"_n("+a+")":a)+")"),Fn(e,"change",Pn(r,a),null,!0)}(e,n,a);else if("input"===o||"textarea"===o)!function(e,r,t){var n=e.attrsMap.type,a=t||{},o=a.lazy,i=a.number,s=a.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Zn:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),i&&(l="_n("+l+")");var p=Pn(r,l);c&&(p="if($event.target.composing)return;"+p),Tn(e,"value","("+r+")"),Fn(e,u,p,null,!0),(s||i)&&Fn(e,"blur","$forceUpdate()")}(e,n,a);else if(!B.isReservedTag(o))return jn(e,n,a),!1;return!0},text:function(e,r){r.value&&Tn(e,"textContent","_s("+r.value+")",r)},html:function(e,r){r.value&&Tn(e,"innerHTML","_s("+r.value+")",r)}},isPreTag:function(e){return"pre"===e},isUnaryTag:yo,mustUseProp:$t,canBeLeftOpenTag:wo,isReservedTag:Kt,getTagNamespace:Zt,staticKeys:function(e){return e.reduce(function(e,r){return e.concat(r.staticKeys||[])},[]).join(",")}(yi)},xi=b(function(e){return f("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function qi(e,r){e&&(wi=xi(r.staticKeys||""),Ai=r.isReservedTag||S,function e(r){r.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Ai(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(wi)))}(r);if(1===r.type){if(!Ai(r.tag)&&"slot"!==r.tag&&null==r.attrsMap["inline-template"])return;for(var t=0,n=r.children.length;t<n;t++){var a=r.children[t];e(a),a.static||(r.static=!1)}if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++){var s=r.ifConditions[o].block;e(s),s.static||(r.static=!1)}}}(e),function e(r,t){if(1===r.type){if((r.static||r.once)&&(r.staticInFor=t),r.static&&r.children.length&&(1!==r.children.length||3!==r.children[0].type))return void(r.staticRoot=!0);if(r.staticRoot=!1,r.children)for(var n=0,a=r.children.length;n<a;n++)e(r.children[n],t||!!r.for);if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++)e(r.ifConditions[o].block,t)}}(e,!1))}var ki=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ei=/\([^)]*?\);*$/,_i=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Si={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Li=function(e){return"if("+e+")return null;"},Ti={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Li("$event.target !== $event.currentTarget"),ctrl:Li("!$event.ctrlKey"),shift:Li("!$event.shiftKey"),alt:Li("!$event.altKey"),meta:Li("!$event.metaKey"),left:Li("'button' in $event && $event.button !== 0"),middle:Li("'button' in $event && $event.button !== 1"),right:Li("'button' in $event && $event.button !== 2")};function $i(e,r){var t=r?"nativeOn:":"on:",n="",a="";for(var o in e){var i=Ni(e[o]);e[o]&&e[o].dynamic?a+=o+","+i+",":n+='"'+o+'":'+i+","}return n="{"+n.slice(0,-1)+"}",a?t+"_d("+n+",["+a.slice(0,-1)+"])":t+n}function Ni(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Ni(e)}).join(",")+"]";var r=_i.test(e.value),t=ki.test(e.value),n=_i.test(e.value.replace(Ei,""));if(e.modifiers){var a="",o="",i=[];for(var s in e.modifiers)if(Ti[s])o+=Ti[s],Ci[s]&&i.push(s);else if("exact"===s){var c=e.modifiers;o+=Li(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else i.push(s);return i.length&&(a+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Oi).join("&&")+")return null;"}(i)),o&&(a+=o),"function($event){"+a+(r?"return "+e.value+".apply(null, arguments)":t?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return r||t?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function Oi(e){var r=parseInt(e,10);if(r)return"$event.keyCode!=="+r;var t=Ci[e],n=Si[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(t)+",$event.key,"+JSON.stringify(n)+")"}var Ri={on:function(e,r){e.wrapListeners=function(e){return"_g("+e+","+r.value+")"}},bind:function(e,r){e.wrapData=function(t){return"_b("+t+",'"+e.tag+"',"+r.value+","+(r.modifiers&&r.modifiers.prop?"true":"false")+(r.modifiers&&r.modifiers.sync?",true":"")+")"}},cloak:C},Fi=function(e){this.options=e,this.warn=e.warn||Sn,this.transforms=Ln(e.modules,"transformCode"),this.dataGenFns=Ln(e.modules,"genData"),this.directives=E(E({},Ri),e.directives);var r=e.isReservedTag||S;this.maybeComponent=function(e){return!!e.component||!r(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Bi(e,r){var t=new Fi(r);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ui(e,t):'_c("div")')+"}",staticRenderFns:t.staticRenderFns}}function Ui(e,r){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Vi(e,r);if(e.once&&!e.onceProcessed)return Ii(e,r);if(e.for&&!e.forProcessed)return Pi(e,r);if(e.if&&!e.ifProcessed)return ji(e,r);if("template"!==e.tag||e.slotTarget||r.pre){if("slot"===e.tag)return function(e,r){var t=e.slotName||'"default"',n=zi(e,r),a="_t("+t+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Zi((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,i=e.attrsMap["v-bind"];!o&&!i||n||(a+=",null");o&&(a+=","+o);i&&(a+=(o?"":",null")+","+i);return a+")"}(e,r);var t;if(e.component)t=function(e,r,t){var n=r.inlineTemplate?null:zi(r,t,!0);return"_c("+e+","+Hi(r,t)+(n?","+n:"")+")"}(e.component,e,r);else{var n;(!e.plain||e.pre&&r.maybeComponent(e))&&(n=Hi(e,r));var a=e.inlineTemplate?null:zi(e,r,!0);t="_c('"+e.tag+"'"+(n?","+n:"")+(a?","+a:"")+")"}for(var o=0;o<r.transforms.length;o++)t=r.transforms[o](e,t);return t}return zi(e,r)||"void 0"}function Vi(e,r){e.staticProcessed=!0;var t=r.pre;return e.pre&&(r.pre=e.pre),r.staticRenderFns.push("with(this){return "+Ui(e,r)+"}"),r.pre=t,"_m("+(r.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ii(e,r){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ji(e,r);if(e.staticInFor){for(var t="",n=e.parent;n;){if(n.for){t=n.key;break}n=n.parent}return t?"_o("+Ui(e,r)+","+r.onceId+++","+t+")":Ui(e,r)}return Vi(e,r)}function ji(e,r,t,n){return e.ifProcessed=!0,function e(r,t,n,a){if(!r.length)return a||"_e()";var o=r.shift();return o.exp?"("+o.exp+")?"+i(o.block)+":"+e(r,t,n,a):""+i(o.block);function i(e){return n?n(e,t):e.once?Ii(e,t):Ui(e,t)}}(e.ifConditions.slice(),r,t,n)}function Pi(e,r,t,n){var a=e.for,o=e.alias,i=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+a+"),function("+o+i+s+"){return "+(t||Ui)(e,r)+"})"}function Hi(e,r){var t="{",n=function(e,r){var t=e.directives;if(!t)return;var n,a,o,i,s="directives:[",c=!1;for(n=0,a=t.length;n<a;n++){o=t[n],i=!0;var u=r.directives[o.name];u&&(i=!!u(e,o,r.warn)),i&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,r);n&&(t+=n+","),e.key&&(t+="key:"+e.key+","),e.ref&&(t+="ref:"+e.ref+","),e.refInFor&&(t+="refInFor:true,"),e.pre&&(t+="pre:true,"),e.component&&(t+='tag:"'+e.tag+'",');for(var a=0;a<r.dataGenFns.length;a++)t+=r.dataGenFns[a](e);if(e.attrs&&(t+="attrs:"+Zi(e.attrs)+","),e.props&&(t+="domProps:"+Zi(e.props)+","),e.events&&(t+=$i(e.events,!1)+","),e.nativeEvents&&(t+=$i(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(t+="slot:"+e.slotTarget+","),e.scopedSlots&&(t+=function(e,r,t){var n=e.for||Object.keys(r).some(function(e){var t=r[e];return t.slotTargetDynamic||t.if||t.for||Mi(t)}),a=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==si||o.for){n=!0;break}o.if&&(a=!0),o=o.parent}var i=Object.keys(r).map(function(e){return Gi(r[e],t)}).join(",");return"scopedSlots:_u(["+i+"]"+(n?",null,true":"")+(!n&&a?",null,false,"+function(e){var r=5381,t=e.length;for(;t;)r=33*r^e.charCodeAt(--t);return r>>>0}(i):"")+")"}(e,e.scopedSlots,r)+","),e.model&&(t+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,r){var t=e.children[0];if(t&&1===t.type){var n=Bi(t,r.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,r);o&&(t+=o+",")}return t=t.replace(/,$/,"")+"}",e.dynamicAttrs&&(t="_b("+t+',"'+e.tag+'",'+Zi(e.dynamicAttrs)+")"),e.wrapData&&(t=e.wrapData(t)),e.wrapListeners&&(t=e.wrapListeners(t)),t}function Mi(e){return 1===e.type&&("slot"===e.tag||e.children.some(Mi))}function Gi(e,r){var t=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!t)return ji(e,r,Gi,"null");if(e.for&&!e.forProcessed)return Pi(e,r,Gi);var n=e.slotScope===si?"":String(e.slotScope),a="function("+n+"){return "+("template"===e.tag?e.if&&t?"("+e.if+")?"+(zi(e,r)||"undefined")+":undefined":zi(e,r)||"undefined":Ui(e,r))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+a+o+"}"}function zi(e,r,t,n,a){var o=e.children;if(o.length){var i=o[0];if(1===o.length&&i.for&&"template"!==i.tag&&"slot"!==i.tag){var s=t?r.maybeComponent(i)?",1":",0":"";return""+(n||Ui)(i,r)+s}var c=t?function(e,r){for(var t=0,n=0;n<e.length;n++){var a=e[n];if(1===a.type){if(Ji(a)||a.ifConditions&&a.ifConditions.some(function(e){return Ji(e.block)})){t=2;break}(r(a)||a.ifConditions&&a.ifConditions.some(function(e){return r(e.block)}))&&(t=1)}}return t}(o,r.maybeComponent):0,u=a||Ki;return"["+o.map(function(e){return u(e,r)}).join(",")+"]"+(c?","+c:"")}}function Ji(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Ki(e,r){return 1===e.type?Ui(e,r):3===e.type&&e.isComment?(n=e,"_e("+JSON.stringify(n.text)+")"):"_v("+(2===(t=e).type?t.expression:Yi(JSON.stringify(t.text)))+")";var t,n}function Zi(e){for(var r="",t="",n=0;n<e.length;n++){var a=e[n],o=Yi(a.value);a.dynamic?t+=a.name+","+o+",":r+='"'+a.name+'":'+o+","}return r="{"+r.slice(0,-1)+"}",t?"_d("+r+",["+t.slice(0,-1)+"])":r}function Yi(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Wi(e,r){try{return new Function(e)}catch(t){return r.push({err:t,code:e}),C}}function Qi(e){var r=Object.create(null);return function(t,n,a){(n=E({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+t:t;if(r[o])return r[o];var i=e(t,n),s={},c=[];return s.render=Wi(i.render,c),s.staticRenderFns=i.staticRenderFns.map(function(e){return Wi(e,c)}),r[o]=s}}var Xi,es,rs=(Xi=function(e,r){var t=ui(e.trim(),r);!1!==r.optimize&&qi(t,r);var n=Bi(t,r);return{ast:t,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function r(r,t){var n=Object.create(e),a=[],o=[];if(t)for(var i in t.modules&&(n.modules=(e.modules||[]).concat(t.modules)),t.directives&&(n.directives=E(Object.create(e.directives||null),t.directives)),t)"modules"!==i&&"directives"!==i&&(n[i]=t[i]);n.warn=function(e,r,t){(t?o:a).push(e)};var s=Xi(r.trim(),n);return s.errors=a,s.tips=o,s}return{compile:r,compileToFunctions:Qi(r)}})(Di),ts=(rs.compile,rs.compileToFunctions);function ns(e){return(es=es||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',es.innerHTML.indexOf("&#10;")>0}var as=!!H&&ns(!1),os=!!H&&ns(!0),is=b(function(e){var r=Qt(e);return r&&r.innerHTML}),ss=Dt.prototype.$mount;Dt.prototype.$mount=function(e,r){if((e=e&&Qt(e))===document.body||e===document.documentElement)return this;var t=this.$options;if(!t.render){var n=t.template;if(n)if("string"==typeof n)"#"===n.charAt(0)&&(n=is(n));else{if(!n.nodeType)return this;n=n.innerHTML}else e&&(n=function(e){if(e.outerHTML)return e.outerHTML;var r=document.createElement("div");return r.appendChild(e.cloneNode(!0)),r.innerHTML}(e));if(n){var a=ts(n,{outputSourceRange:!1,shouldDecodeNewlines:as,shouldDecodeNewlinesForHref:os,delimiters:t.delimiters,comments:t.comments},this),o=a.render,i=a.staticRenderFns;t.render=o,t.staticRenderFns=i}}return ss.call(this,e,r)},Dt.compile=ts,module.exports=Dt;
\ No newline at end of file
+"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(){function e(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var o,a=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":o=r;break;case"splice":o=r.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&we(t),o.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function je(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=je(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Ae[r]||Ee;a[r]=i(e[r],t[r],n,r)}return a}function De(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Le(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=_e;be(!0),we(a),be(u)}return a}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),Z&&setTimeout(S)},Ve=!0}else if(J||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)He(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=ve(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=ve(f.text+u):""!==u&&s.push(ve(u)):st(u)&&st(f)?s[l]=ve(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return De(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=E,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var o=he(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Le(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=de();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Le(l,u,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return de();n(a)&&n(a.is)&&(i=a.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f=void 0;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=De(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):de()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(U&&!J){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var o=function(o){i.push(o);var a=Le(o,t,n,e);Ce(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=je(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=je(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=je($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;Ce(t,"$attrs",o&&o.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){le();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:je,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=je(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=De(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(J||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(J&&!q&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=J?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=U&&!q,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ni(e){Ti(function(){Ti(e)})}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,N=O&&v?v:l,E=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!q,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,N),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),E&&E(i),F&&(Ei(i,S),Ei(i,T),Ni(function(){ji(i,S),R.cancelled||(Ei(i,N),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ni(function(){ji(i,u),w.cancelled||(Ei(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=he(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,U?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});q&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),q&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t),(J||W)&&setTimeout(function(){Ji(e,t)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(E(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!E(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){(l=i[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(o.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=e(t,null,c),this.removed=u}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!U)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=U?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?Yn(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},go=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),_o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,No=/^<!\[/,Eo=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,function(e){return Do[e]})}function Ro(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,u=function(){if(n=e,r&&Eo(r)){var u=0,p=r.toLowerCase(),d=jo[p]||(jo[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return u=r.length,Eo(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(To.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(No.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(So);if(y)return l(y[0].length),"continue";var g=e.match(Oo);if(g){var _=c;return l(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(ko);if(t){var n={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Ao))&&(i=e.match(wo)||e.match($o));)i.start=c,l(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&f(r),s(n)&&r===n&&f(n));for(var u=a(n)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:Po(h,m)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,u,e.start,e.end)}(b),Fo(b.tagName,e)&&l(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Oo.test(w)||ko.test(w)||To.test(w)||No.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&l($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}f()}var Ho,Bo,Uo,zo,Vo,Ko,Jo,qo,Wo=require("he"),Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/[ \f\t\r\n]+/g,sa=g(Wo.decode),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Ho=t.warn||Sr,Ko=t.isPreTag||T,Jo=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Uo=Tr(t.modules,"transformNode"),zo=Tr(t.modules,"preTransformNode"),Vo=Tr(t.modules,"postTransformNode"),Bo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ko(e.tag)&&(c=!1);for(var f=0;f<Vo.length;f++)Vo[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return Ro(e,{warn:Ho,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<zo.length;h++)v=zo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ko(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):u.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(aa," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Bo))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var r=Pr(e,ia);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=va(r),u=c.name,a=c.dynamic,l=s[u]=ua("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=r.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Uo.length;i++)e=Uo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Jo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):Er(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Er(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Jo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,yo,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=Ir(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+r+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",r),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Nr(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:go,mustUseProp:jn,canBeLeftOpenTag:_o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var o=t.ifConditions[n].block;e(o),o.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Na={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(ja[t])o+=ja[t],Ta[t]&&a.push(t);else if("exact"===t){var n=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Na[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(){return function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g(function(e){var t=Yn(e);return t&&t.innerHTML}),ss=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},wn.compile=ns,module.exports=wn;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index e19afcbb49d..79d3da366cd 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -4,7 +4,7 @@
  * Released under the MIT License.
  */
 /* @flow */
-const emptyObject = Object.freeze({});
+var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 function isUndef(v) {
@@ -40,7 +40,7 @@ function isObject(obj) {
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-const _toString = Object.prototype.toString;
+var _toString = Object.prototype.toString;
 function toRawType(value) {
     return _toString.call(value).slice(8, -1);
 }
@@ -58,7 +58,7 @@ function isRegExp(v) {
  * Check if val is a valid array index.
  */
 function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
+    var n = parseFloat(String(val));
     return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
 function isPromise(val) {
@@ -81,7 +81,7 @@ function toString(val) {
  * If the conversion fails, return original string.
  */
 function toNumber(val) {
-    const n = parseFloat(val);
+    var n = parseFloat(val);
     return isNaN(n) ? val : n;
 }
 /**
@@ -89,27 +89,27 @@ function toNumber(val) {
  * is in that map.
  */
 function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
         map[list[i]] = true;
     }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
 /**
  * Check if a tag is a built-in tag.
  */
-const isBuiltInTag = makeMap('slot,component', true);
+var isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove(arr, item) {
+function remove$2(arr, item) {
     if (arr.length) {
-        const index = arr.indexOf(item);
+        var index = arr.indexOf(item);
         if (index > -1) {
             return arr.splice(index, 1);
         }
@@ -118,7 +118,7 @@ function remove(arr, item) {
 /**
  * Check whether an object has the property.
  */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
 }
@@ -126,30 +126,30 @@ function hasOwn(obj, key) {
  * Create a cached version of a pure function.
  */
 function cached(fn) {
-    const cache = Object.create(null);
+    var cache = Object.create(null);
     return function cachedFn(str) {
-        const hit = cache[str];
+        var hit = cache[str];
         return hit || (cache[str] = fn(str));
     };
 }
 /**
  * Camelize a hyphen-delimited string.
  */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+var camelizeRE = /-(\w)/g;
+var camelize = cached(function (str) {
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
 /**
  * Capitalize a string.
  */
-const capitalize = cached((str) => {
+var capitalize = cached(function (str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
  * Hyphenate a camelCase string.
  */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cached(function (str) {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
 /**
@@ -162,7 +162,7 @@ const hyphenate = cached((str) => {
 /* istanbul ignore next */
 function polyfillBind(fn, ctx) {
     function boundFn(a) {
-        const l = arguments.length;
+        var l = arguments.length;
         return l
             ? l > 1
                 ? fn.apply(ctx, arguments)
@@ -176,14 +176,14 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-const bind = Function.prototype.bind ? nativeBind : polyfillBind;
+var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
 function toArray(list, start) {
     start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
+    var i = list.length - start;
+    var ret = new Array(i);
     while (i--) {
         ret[i] = list[i + start];
     }
@@ -193,7 +193,7 @@ function toArray(list, start) {
  * Mix properties into target object.
  */
 function extend(to, _from) {
-    for (const key in _from) {
+    for (var key in _from) {
         to[key] = _from[key];
     }
     return to;
@@ -202,8 +202,8 @@ function extend(to, _from) {
  * Merge an Array of Objects into a single Object.
  */
 function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
         if (arr[i]) {
             extend(res, arr[i]);
         }
@@ -220,18 +220,18 @@ function noop(a, b, c) { }
 /**
  * Always return false.
  */
-const no = (a, b, c) => false;
+var no = function (a, b, c) { return false; };
 /* eslint-enable no-unused-vars */
 /**
  * Return the same value.
  */
-const identity = (_) => _;
+var identity = function (_) { return _; };
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys(modules) {
+function genStaticKeys$1(modules) {
     return modules
-        .reduce((keys, m) => {
+        .reduce(function (keys, m) {
         return keys.concat(m.staticKeys || []);
     }, [])
         .join(',');
@@ -243,15 +243,15 @@ function genStaticKeys(modules) {
 function looseEqual(a, b) {
     if (a === b)
         return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
     if (isObjectA && isObjectB) {
         try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
             if (isArrayA && isArrayB) {
                 return (a.length === b.length &&
-                    a.every((e, i) => {
+                    a.every(function (e, i) {
                         return looseEqual(e, b[i]);
                     }));
             }
@@ -259,10 +259,10 @@ function looseEqual(a, b) {
                 return a.getTime() === b.getTime();
             }
             else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
                 return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
+                    keysA.every(function (key) {
                         return looseEqual(a[key], b[key]);
                     }));
             }
@@ -289,7 +289,7 @@ function looseEqual(a, b) {
  * contain an object of the same shape), or -1 if it is not present.
  */
 function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
+    for (var i = 0; i < arr.length; i++) {
         if (looseEqual(arr[i], val))
             return i;
     }
@@ -299,7 +299,7 @@ function looseIndexOf(arr, val) {
  * Ensure a function is called only once.
  */
 function once(fn) {
-    let called = false;
+    var called = false;
     return function () {
         if (!called) {
             called = true;
@@ -308,9 +308,9 @@ function once(fn) {
     };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
+var SSR_ATTR = 'data-server-rendered';
+var ASSET_TYPES = ['component', 'directive', 'filter'];
+var LIFECYCLE_HOOKS = [
     'beforeCreate',
     'created',
     'beforeMount',
@@ -410,12 +410,12 @@ var config = {
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Check if a string starts with $ or _
  */
 function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
+    var c = (str + '').charCodeAt(0);
     return c === 0x24 || c === 0x5f;
 }
 /**
@@ -432,14 +432,14 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
     }
-    const segments = path.split('.');
+    var segments = path.split('.');
     return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
+        for (var i = 0; i < segments.length; i++) {
             if (!obj)
                 return;
             obj = obj[segments[i]];
@@ -450,33 +450,33 @@ function parsePath(path) {
 
 /* @flow */
 // can we use __proto__?
-const hasProto = '__proto__' in {};
+var hasProto = '__proto__' in {};
 // Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
+var inBrowser = typeof window !== 'undefined';
 // @ts-ignore
-const inWeex = 
+var inWeex = 
 // @ts-ignore
 typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
 // @ts-ignore
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-const isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-const isPhantomJS = UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
+var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+var UA = inBrowser && window.navigator.userAgent.toLowerCase();
+var isIE = UA && /msie|trident/.test(UA);
+var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+var isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+var isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
-const nativeWatch = {}.watch;
-let supportsPassive = false;
+var nativeWatch = {}.watch;
+var supportsPassive = false;
 if (inBrowser) {
     try {
-        const opts = {};
+        var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get() {
+            get: function () {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -488,8 +488,8 @@ if (inBrowser) {
 }
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
+var _isServer;
+var isServerRendering = function () {
     if (_isServer === undefined) {
         /* istanbul ignore if */
         if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -506,66 +506,69 @@ const isServerRendering = () => {
 };
 // detect devtools
 // @ts-ignore TODO decalre this types
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
 }
-const hasSymbol = typeof Symbol !== 'undefined' &&
+var hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
+var _Set; // $flow-disable-line
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
     // use native Set when available.
     _Set = Set;
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        constructor() {
+    _Set = /** @class */ (function () {
+        function Set() {
             this.set = Object.create(null);
         }
-        has(key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
-        }
-        add(key) {
+        };
+        Set.prototype.add = function (key) {
             this.set[key] = true;
-        }
-        clear() {
+        };
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
-        }
-    };
+        };
+        return Set;
+    }());
 }
 
 /* @flow */
-let warn = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
+var warn$2 = noop;
+var tip = noop;
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn$2 = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
+        else if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+    tip = function (msg, vm) {
+        if (hasConsole_1 && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
-    formatComponentName = (vm, includeFile) => {
+    formatComponentName = function (vm, includeFile) {
         if (vm.$root === vm) {
             return '<Root>';
         }
-        const options = 
+        var options = 
         // @ts-ignore
         typeof vm === 'function' && vm.cid != null
             ? // @ts-ignore
@@ -574,17 +577,17 @@ let formatComponentName;
                 ? // @ts-ignore
                     vm.$options || vm.constructor.options
                 : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
         if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
+            var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    const repeat = (str, n) => {
-        let res = '';
+    var repeat_1 = function (str, n) {
+        var res = '';
         while (n) {
             if (n % 2 === 1)
                 res += str;
@@ -594,14 +597,14 @@ let formatComponentName;
         }
         return res;
     };
-    generateComponentTrace = (vm) => {
+    generateComponentTrace = function (vm) {
         // @ts-ignore
         if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
+            var tree = [];
+            var currentRecursiveSequence = 0;
             while (vm) {
                 if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
+                    var last = tree[tree.length - 1];
                     if (last.constructor === vm.constructor) {
                         currentRecursiveSequence++;
                         vm = vm.$parent;
@@ -617,57 +620,60 @@ let formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
 
-let uid = 0;
+var uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-class Dep {
-    constructor() {
-        this.id = uid++;
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid$2++;
         this.subs = [];
     }
-    addSub(sub) {
+    Dep.prototype.addSub = function (sub) {
         this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove(this.subs, sub);
-    }
-    depend() {
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$2(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
         if (Dep.target) {
             Dep.target.addDep(this);
         }
-    }
-    notify() {
+    };
+    Dep.prototype.notify = function () {
         // stabilize the subscriber list first
-        const subs = this.subs.slice();
+        var subs = this.subs.slice();
         if (!config.async) {
             // subs aren't sorted in scheduler if not running async
             // we need to sort them now to make sure they fire in correct
             // order
-            subs.sort((a, b) => a.id - b.id);
+            subs.sort(function (a, b) { return a.id - b.id; });
         }
-        for (let i = 0, l = subs.length; i < l; i++) {
+        for (var i = 0, l = subs.length; i < l; i++) {
             subs[i].update();
         }
-    }
-}
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-const targetStack = [];
+var targetStack = [];
 function pushTarget(target) {
     targetStack.push(target);
     Dep.target = target;
@@ -677,8 +683,8 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-class VNode {
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
         this.tag = tag;
         this.data = data;
         this.children = children;
@@ -703,14 +709,20 @@ class VNode {
         this.asyncMeta = undefined;
         this.isAsyncPlaceholder = false;
     }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = '') => {
-    const node = new VNode();
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
+var createEmptyVNode = function (text) {
+    if (text === void 0) { text = ''; }
+    var node = new VNode();
     node.text = text;
     node.isComment = true;
     return node;
@@ -723,7 +735,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    const cloned = new VNode(
+    var cloned = new VNode(
     //@ts-expect-error void type not valid here
     vnode.tag, vnode.data, 
     // #7975
@@ -746,9 +758,9 @@ function cloneVNode(vnode) {
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
+var arrayProto = Array.prototype;
+var arrayMethods = Object.create(arrayProto);
+var methodsToPatch = [
     'push',
     'pop',
     'shift',
@@ -762,11 +774,15 @@ const methodsToPatch = [
  */
 methodsToPatch.forEach(function (method) {
     // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
         switch (method) {
             case 'push':
             case 'unshift':
@@ -784,12 +800,12 @@ methodsToPatch.forEach(function (method) {
     });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-let shouldObserve = true;
+var shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
@@ -799,8 +815,8 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-class Observer {
-    constructor(value) {
+var Observer = /** @class */ (function () {
+    function Observer(value) {
         this.value = value;
         this.dep = new Dep();
         this.vmCount = 0;
@@ -823,21 +839,22 @@ class Observer {
      * getter/setters. This method should only be called when
      * value type is Object.
      */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive$$1(obj, keys[i]);
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
         }
-    }
+    };
     /**
      * Observe a list of Array items.
      */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
             observe(items[i]);
         }
-    }
-}
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -854,8 +871,8 @@ function protoAugment(target, src) {
  */
 /* istanbul ignore next */
 function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
         def(target, key, src[key]);
     }
 }
@@ -868,7 +885,7 @@ function observe(value, asRootData) {
     if (!isObject(value) || value instanceof VNode) {
         return;
     }
-    let ob;
+    var ob;
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
@@ -887,24 +904,24 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
+function defineReactive(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
         return;
     }
     // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
+    var getter = property && property.get;
+    var setter = property && property.set;
     if ((!getter || setter) && arguments.length === 2) {
         val = obj[key];
     }
-    let childOb = !shallow && observe(val);
+    var childOb = !shallow && observe(val);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
         get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
+            var value = getter ? getter.call(obj) : val;
             if (Dep.target) {
                 dep.depend();
                 if (childOb) {
@@ -917,7 +934,7 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
             return value;
         },
         set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
+            var value = getter ? getter.call(obj) : val;
             /* eslint-disable no-self-compare */
             if (newVal === value || (newVal !== newVal && value !== value)) {
                 return;
@@ -946,8 +963,8 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
  * already exist.
  */
 function set(target, key, val) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -958,10 +975,10 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    const ob = target.__ob__;
+    var ob = target.__ob__;
     // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
         return val;
     }
@@ -969,7 +986,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -977,17 +994,17 @@ function set(target, key, val) {
  * Delete a property and trigger change if necessary.
  */
 function del(target, key) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
         return;
     }
-    const ob = target.__ob__;
+    var ob = target.__ob__;
     //@ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid deleting properties on a Vue instance or its root $data ' +
+        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                 '- just set it to null.');
         return;
     }
@@ -1005,7 +1022,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1020,14 +1037,14 @@ function dependArray(value) {
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-const strats = config.optionMergeStrategies;
+var strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn(`option "${key}" can only be used during instance ` +
+            warn$2("option \"" + key + "\" can only be used during instance " +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1039,11 +1056,11 @@ const strats = config.optionMergeStrategies;
 function mergeData(to, from) {
     if (!from)
         return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
+    var key, toVal, fromVal;
+    var keys = hasSymbol
         ? Reflect.ownKeys(from)
         : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
+    for (var i = 0; i < keys.length; i++) {
         key = keys[i];
         // in case the object is already observed...
         if (key === '__ob__')
@@ -1089,8 +1106,8 @@ function mergeDataOrFn(parentVal, childVal, vm) {
     else {
         return function mergedInstanceDataFn() {
             // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
             if (instanceData) {
                 return mergeData(instanceData, defaultData);
             }
@@ -1103,7 +1120,7 @@ function mergeDataOrFn(parentVal, childVal, vm) {
 strats.data = function (parentVal, childVal, vm) {
     if (!vm) {
         if (childVal && typeof childVal !== 'function') {
-            warn('The "data" option should be a function ' +
+            warn$2('The "data" option should be a function ' +
                     'that returns a per-instance value in component ' +
                     'definitions.', vm);
             return parentVal;
@@ -1115,8 +1132,8 @@ strats.data = function (parentVal, childVal, vm) {
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(parentVal, childVal) {
-    const res = childVal
+function mergeHook$1(parentVal, childVal) {
+    var res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : Array.isArray(childVal)
@@ -1126,16 +1143,16 @@ function mergeHook(parentVal, childVal) {
     return res ? dedupeHooks(res) : res;
 }
 function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
         if (res.indexOf(hooks[i]) === -1) {
             res.push(hooks[i]);
         }
     }
     return res;
 }
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook;
+LIFECYCLE_HOOKS.forEach(function (hook) {
+    strats[hook] = mergeHook$1;
 });
 /**
  * Assets
@@ -1145,7 +1162,7 @@ LIFECYCLE_HOOKS.forEach((hook) => {
  * options and parent options.
  */
 function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
+    var res = Object.create(parentVal || null);
     if (childVal) {
         assertObjectType(key, childVal, vm);
         return extend(res, childVal);
@@ -1179,16 +1196,16 @@ strats.watch = function (parentVal, childVal, vm, key) {
     }
     if (!parentVal)
         return childVal;
-    const ret = {};
+    var ret = {};
     extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1204,7 +1221,7 @@ strats.props = strats.methods = strats.inject = strats.computed = function (pare
     }
     if (!parentVal)
         return childVal;
-    const ret = Object.create(null);
+    var ret = Object.create(null);
     extend(ret, parentVal);
     if (childVal)
         extend(ret, childVal);
@@ -1214,26 +1231,26 @@ strats.provide = mergeDataOrFn;
 /**
  * Default strategy.
  */
-const defaultStrat = function (parentVal, childVal) {
+var defaultStrat = function (parentVal, childVal) {
     return childVal === undefined ? parentVal : childVal;
 };
 /**
  * Validate component names
  */
 function checkComponents(options) {
-    for (const key in options.components) {
+    for (var key in options.components) {
         validateComponentName(key);
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn('Invalid component name: "' +
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+        warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
             'should conform to valid custom element name in html5 specification.');
     }
     if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
             'id: ' +
             name);
     }
@@ -1243,11 +1260,11 @@ function validateComponentName(name) {
  * Object-based format.
  */
 function normalizeProps(options, vm) {
-    const props = options.props;
+    var props = options.props;
     if (!props)
         return;
-    const res = {};
-    let i, val, name;
+    var res = {};
+    var i, val, name;
     if (Array.isArray(props)) {
         i = props.length;
         while (i--) {
@@ -1257,20 +1274,20 @@ function normalizeProps(options, vm) {
                 res[name] = { type: null };
             }
             else {
-                warn('props must be strings when using array syntax.');
+                warn$2('props must be strings when using array syntax.');
             }
         }
     }
     else if (isPlainObject(props)) {
-        for (const key in props) {
+        for (var key in props) {
             val = props[key];
             name = camelize(key);
             res[name] = isPlainObject(val) ? val : { type: val };
         }
     }
     else {
-        warn(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
+        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
+            ("but got " + toRawType(props) + "."), vm);
     }
     options.props = res;
 }
@@ -1278,46 +1295,46 @@ function normalizeProps(options, vm) {
  * Normalize all injections into Object-based format
  */
 function normalizeInject(options, vm) {
-    const inject = options.inject;
+    var inject = options.inject;
     if (!inject)
         return;
-    const normalized = (options.inject = {});
+    var normalized = (options.inject = {});
     if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
+        for (var i = 0; i < inject.length; i++) {
             normalized[inject[i]] = { from: inject[i] };
         }
     }
     else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
+        for (var key in inject) {
+            var val = inject[key];
             normalized[key] = isPlainObject(val)
                 ? extend({ from: key }, val)
                 : { from: val };
         }
     }
     else {
-        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
+        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
+            ("but got " + toRawType(inject) + "."), vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives(options) {
-    const dirs = options.directives;
+function normalizeDirectives$1(options) {
+    var dirs = options.directives;
     if (dirs) {
-        for (const key in dirs) {
-            const def$$1 = dirs[key];
-            if (typeof def$$1 === 'function') {
-                dirs[key] = { bind: def$$1, update: def$$1 };
+        for (var key in dirs) {
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
             }
         }
     }
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
+        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 /**
@@ -1334,7 +1351,7 @@ function mergeOptions(parent, child, vm) {
     }
     normalizeProps(child, vm);
     normalizeInject(child, vm);
-    normalizeDirectives(child);
+    normalizeDirectives$1(child);
     // Apply extends and mixins on the child options,
     // but only if it is a raw options object that isn't
     // the result of another mergeOptions call.
@@ -1344,13 +1361,13 @@ function mergeOptions(parent, child, vm) {
             parent = mergeOptions(parent, child.extends, vm);
         }
         if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
                 parent = mergeOptions(parent, child.mixins[i], vm);
             }
         }
     }
-    const options = {};
-    let key;
+    var options = {};
+    var key;
     for (key in parent) {
         mergeField(key);
     }
@@ -1360,7 +1377,7 @@ function mergeOptions(parent, child, vm) {
         }
     }
     function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
+        var strat = strats[key] || defaultStrat;
         options[key] = strat(parent[key], child[key], vm, key);
     }
     return options;
@@ -1375,31 +1392,31 @@ function resolveAsset(options, type, id, warnMissing) {
     if (typeof id !== 'string') {
         return;
     }
-    const assets = options[type];
+    var assets = options[type];
     // check local registration variations first
     if (hasOwn(assets, id))
         return assets[id];
-    const camelizedId = camelize(id);
+    var camelizedId = camelize(id);
     if (hasOwn(assets, camelizedId))
         return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
+    var PascalCaseId = capitalize(camelizedId);
     if (hasOwn(assets, PascalCaseId))
         return assets[PascalCaseId];
     // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
     return res;
 }
 
 /* @flow */
 function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
     // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
     if (booleanIndex > -1) {
         if (absent && !hasOwn(prop, 'default')) {
             value = false;
@@ -1407,7 +1424,7 @@ function validateProp(key, propOptions, propsData, vm) {
         else if (value === '' || value === hyphenate(key)) {
             // only cast empty string / same name to boolean if
             // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
+            var stringIndex = getTypeIndex(String, prop.type);
             if (stringIndex < 0 || booleanIndex < stringIndex) {
                 value = true;
             }
@@ -1418,7 +1435,7 @@ function validateProp(key, propOptions, propsData, vm) {
         value = getPropDefaultValue(vm, prop, key);
         // since the default value is a fresh copy,
         // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
+        var prevShouldObserve = shouldObserve;
         toggleObserving(true);
         observe(value);
         toggleObserving(prevShouldObserve);
@@ -1436,10 +1453,10 @@ function getPropDefaultValue(vm, prop, key) {
     if (!hasOwn(prop, 'default')) {
         return undefined;
     }
-    const def = prop.default;
+    var def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (isObject(def)) {
-        warn('Invalid default value for prop "' +
+        warn$2('Invalid default value for prop "' +
             key +
             '": ' +
             'Props with type Object/Array must use a factory function ' +
@@ -1464,44 +1481,44 @@ function getPropDefaultValue(vm, prop, key) {
  */
 function assertProp(prop, name, value, vm, absent) {
     if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
+        warn$2('Missing required prop: "' + name + '"', vm);
         return;
     }
     if (value == null && !prop.required) {
         return;
     }
-    let type = prop.type;
+    var type = prop.type;
     // @ts-ignore
-    let valid = !type || type === true;
-    const expectedTypes = [];
+    var valid = !type || type === true;
+    var expectedTypes = [];
     if (type) {
         if (!Array.isArray(type)) {
             type = [type];
         }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
             expectedTypes.push(assertedType.expectedType || '');
             valid = assertedType.valid;
         }
     }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
     if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
-    const validator = prop.validator;
+    var validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
 function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
+    var valid;
+    var expectedType = getType(type);
     if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
+        var t = typeof value;
         valid = t === expectedType.toLowerCase();
         // for primitive wrapper objects
         if (!valid && t === 'object') {
@@ -1519,23 +1536,23 @@ function assertType(value, type, vm) {
             valid = value instanceof type;
         }
         catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
             valid = false;
         }
     }
     return {
-        valid,
-        expectedType,
+        valid: valid,
+        expectedType: expectedType,
     };
 }
-const functionTypeCheckRE = /^\s*function (\w+)/;
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
 function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
+    var match = fn && fn.toString().match(functionTypeCheckRE);
     return match ? match[1] : '';
 }
 function isSameType(a, b) {
@@ -1545,7 +1562,7 @@ function getTypeIndex(type, expectedTypes) {
     if (!Array.isArray(expectedTypes)) {
         return isSameType(expectedTypes, type) ? 0 : -1;
     }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
         if (isSameType(expectedTypes[i], type)) {
             return i;
         }
@@ -1553,41 +1570,45 @@ function getTypeIndex(type, expectedTypes) {
     return -1;
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
     // check if we need to specify expected value
     if (expectedTypes.length === 1 &&
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
+        message += " with value " + styleValue(value, expectedType);
     }
-    message += `, got ${receivedType} `;
+    message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
+        message += "with value " + styleValue(value, receivedType) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return `"${value}"`;
+        return "\"" + value + "\"";
     }
     else if (type === 'Number') {
-        return `${Number(value)}`;
+        return "" + Number(value);
     }
     else {
-        return `${value}`;
+        return "" + value;
     }
 }
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
 function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function isBoolean() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
 function handleError(err, vm, info) {
@@ -1596,13 +1617,13 @@ function handleError(err, vm, info) {
     pushTarget();
     try {
         if (vm) {
-            let cur = vm;
+            var cur = vm;
             while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
+                var hooks = cur.$options.errorCaptured;
                 if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
+                    for (var i = 0; i < hooks.length; i++) {
                         try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
                             if (capture)
                                 return;
                         }
@@ -1620,11 +1641,11 @@ function handleError(err, vm, info) {
     }
 }
 function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
+    var res;
     try {
         res = args ? handler.apply(context, args) : handler.call(context);
         if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
             // issue #9511
             // avoid catch triggering multiple times when nested calls
             res._handled = true;
@@ -1652,7 +1673,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn(`Error in ${info}: "${err.toString()}"`, vm);
+        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1664,14 +1685,14 @@ function logError(err, vm, info) {
 }
 
 /* @flow */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
+var isUsingMicroTask = false;
+var callbacks = [];
+var pending = false;
 function flushCallbacks() {
     pending = false;
-    const copies = callbacks.slice(0);
+    var copies = callbacks.slice(0);
     callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
+    for (var i = 0; i < copies.length; i++) {
         copies[i]();
     }
 }
@@ -1686,7 +1707,7 @@ function flushCallbacks() {
 // where microtasks have too high a priority and fire in between supposedly
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
-let timerFunc;
+var timerFunc;
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1695,9 +1716,9 @@ let timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
+    var p_1 = Promise.resolve();
+    timerFunc = function () {
+        p_1.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1716,15 +1737,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var counter_1 = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
+    timerFunc = function () {
+        counter_1 = (counter_1 + 1) % 2;
+        textNode_1.data = String(counter_1);
     };
     isUsingMicroTask = true;
 }
@@ -1732,19 +1753,19 @@ else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
     // Fallback to setImmediate.
     // Technically it leverages the (macro) task queue,
     // but it is still a better choice than setTimeout.
-    timerFunc = () => {
+    timerFunc = function () {
         setImmediate(flushCallbacks);
     };
 }
 else {
     // Fallback to setTimeout.
-    timerFunc = () => {
+    timerFunc = function () {
         setTimeout(flushCallbacks, 0);
     };
 }
 function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
+    var _resolve;
+    callbacks.push(function () {
         if (cb) {
             try {
                 cb.call(ctx);
@@ -1763,62 +1784,60 @@ function nextTick(cb, ctx) {
     }
     // $flow-disable-line
     if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
+        return new Promise(function (resolve) {
             _resolve = resolve;
         });
     }
 }
 
-/* @flow */
-
-let mark;
-let measure;
+var mark;
+var measure;
 {
-    const perf = inBrowser && window.performance;
+    var perf_1 = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) {
+        mark = function (tag) { return perf_1.mark(tag); };
+        measure = function (name, startTag, endTag) {
+            perf_1.measure(name, startTag, endTag);
+            perf_1.clearMarks(startTag);
+            perf_1.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
+var initProxy;
 {
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    const warnNonPresent = (target, key) => {
-        warn(`Property or method "${key}" is not defined on the instance but ` +
+    var warnNonPresent_1 = function (target, key) {
+        warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    const warnReservedPrefix = (target, key) => {
-        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
+    var warnReservedPrefix_1 = function (target, key) {
+        warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                     return false;
                 }
                 else {
@@ -1828,38 +1847,38 @@ let initProxy;
             },
         });
     }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
+    var hasHandler_1 = {
+        has: function (target, key) {
+            var has = key in target;
+            var isAllowed = allowedGlobals_1(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    warnReservedPrefix(target, key);
+                    warnReservedPrefix_1(target, key);
                 else
-                    warnNonPresent(target, key);
+                    warnNonPresent_1(target, key);
             }
             return has || !isAllowed;
         },
     };
-    const getHandler = {
-        get(target, key) {
+    var getHandler_1 = {
+        get: function (target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    warnReservedPrefix(target, key);
+                    warnReservedPrefix_1(target, key);
                 else
-                    warnNonPresent(target, key);
+                    warnNonPresent_1(target, key);
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy) {
+        if (hasProxy_1) {
             // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            var options = vm.$options;
+            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1869,7 +1888,7 @@ let initProxy;
 }
 
 /* @flow */
-const seenObjects = new _Set();
+var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
@@ -1880,15 +1899,15 @@ function traverse(val) {
     seenObjects.clear();
 }
 function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
+    var i, keys;
+    var isA = Array.isArray(val);
     if ((!isA && !isObject(val)) ||
         Object.isFrozen(val) ||
         val instanceof VNode) {
         return;
     }
     if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
+        var depId = val.__ob__.dep.id;
         if (seen.has(depId)) {
             return;
         }
@@ -1907,45 +1926,45 @@ function _traverse(val, seen) {
     }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
+var normalizeEvent = cached(function (name) {
+    var passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    const once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
-        name,
-        once: once$$1,
-        capture,
-        passive,
+        name: name,
+        once: once,
+        capture: capture,
+        passive: passive,
     };
 });
 function createFnInvoker(fns, vm) {
     function invoker() {
-        const fns = invoker.fns;
+        var fns = invoker.fns;
         if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, "v-on handler");
             }
         }
         else {
             // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
         }
     }
     invoker.fns = fns;
     return invoker;
 }
-function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-    let name, def$$1, cur, old, event;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, cur, old, event;
     for (name in on) {
-        def$$1 = cur = on[name];
+        cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+            warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1964,7 +1983,7 @@ function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
     for (name in oldOn) {
         if (isUndef(on[name])) {
             event = normalizeEvent(name);
-            remove$$1(event.name, oldOn[name], event.capture);
+            remove(event.name, oldOn[name], event.capture);
         }
     }
 }
@@ -1974,13 +1993,13 @@ function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
     }
-    let invoker;
-    const oldHook = def[hookKey];
+    var invoker;
+    var oldHook = def[hookKey];
     function wrappedHook() {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
         // and prevent memory leak
-        remove(invoker.fns, wrappedHook);
+        remove$2(invoker.fns, wrappedHook);
     }
     if (isUndef(oldHook)) {
         // no existing hook
@@ -2007,26 +2026,26 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
     // component itself.
-    const propOptions = Ctor.options.props;
+    var propOptions = Ctor.options.props;
     if (isUndef(propOptions)) {
         return;
     }
-    const res = {};
-    const { attrs, props } = data;
+    var res = {};
+    var attrs = data.attrs, props = data.props;
     if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
             {
-                const keyInLowerCase = key.toLowerCase();
+                var keyInLowerCase = key.toLowerCase();
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2068,7 +2087,7 @@ function checkProp(res, hash, key, altKey, preserve) {
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
 function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
+    for (var i = 0; i < children.length; i++) {
         if (Array.isArray(children[i])) {
             return Array.prototype.concat.apply([], children);
         }
@@ -2090,8 +2109,8 @@ function isTextNode(node) {
     return isDef(node) && isDef(node.text) && isFalse(node.isComment);
 }
 function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
+    var res = [];
+    var i, c, lastIndex, last;
     for (i = 0; i < children.length; i++) {
         c = children[i];
         if (isUndef(c) || typeof c === 'boolean')
@@ -2101,7 +2120,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2133,7 +2152,7 @@ function normalizeArrayChildren(children, nestedIndex) {
                     isDef(c.tag) &&
                     isUndef(c.key) &&
                     isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
                 }
                 res.push(c);
             }
@@ -2144,7 +2163,7 @@ function normalizeArrayChildren(children, nestedIndex) {
 
 /* @flow */
 function initProvide(vm) {
-    const provide = vm.$options.provide;
+    var provide = vm.$options.provide;
     if (provide) {
         vm._provided =
             typeof provide === 'function'
@@ -2154,16 +2173,16 @@ function initProvide(vm) {
     }
 }
 function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
+    var result = resolveInject(vm.$options.inject, vm);
     if (result) {
         toggleObserving(false);
-        Object.keys(result).forEach((key) => {
+        Object.keys(result).forEach(function (key) {
             /* istanbul ignore else */
             {
-                defineReactive$$1(vm, key, result[key], () => {
-                    warn(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
+                defineReactive(vm, key, result[key], function () {
+                    warn$2("Avoid mutating an injected value directly since the changes will be " +
+                        "overwritten whenever the provided component re-renders. " +
+                        ("injection being mutated: \"" + key + "\""), vm);
                 });
             }
         });
@@ -2173,15 +2192,15 @@ function initInjections(vm) {
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
             // #6574 in case the inject object is observed...
             if (key === '__ob__')
                 continue;
-            const provideKey = inject[key].from;
-            let source = vm;
+            var provideKey = inject[key].from;
+            var source = vm;
             while (source) {
                 if (source._provided && hasOwn(source._provided, provideKey)) {
                     result[key] = source._provided[provideKey];
@@ -2192,7 +2211,7 @@ function resolveInject(inject, vm) {
             }
             if (!source) {
                 if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
+                    var provideDefault = inject[key].default;
                     result[key] =
                         typeof provideDefault === 'function'
                             ? provideDefault.call(vm)
@@ -2200,7 +2219,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn(`Injection "${key}" not found`, vm);
+                    warn$2("Injection \"" + key + "\" not found", vm);
                 }
             }
         }
@@ -2216,10 +2235,10 @@ function resolveSlots(children, context) {
     if (!children || !children.length) {
         return {};
     }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
         // remove slot attribute if the node is resolved as a Vue slot node
         if (data && data.attrs && data.attrs.slot) {
             delete data.attrs.slot;
@@ -2229,8 +2248,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2243,9 +2262,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
         }
     }
     return slots;
@@ -2256,10 +2275,10 @@ function isWhitespace(node) {
 
 /* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
     if (!slots) {
         res = {};
     }
@@ -2279,16 +2298,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== '$') {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2302,8 +2321,8 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
             res && typeof res === 'object' && !Array.isArray(res)
                 ? [res] // single vnode
@@ -2325,14 +2344,14 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     return normalized;
 }
 function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+    return function () { return slots[key]; };
 }
 
 /**
  * Runtime helper for rendering v-for lists.
  */
 function renderList(val, render) {
-    let ret = null, i, l, keys, key;
+    var ret = null, i, l, keys, key;
     if (Array.isArray(val) || typeof val === 'string') {
         ret = new Array(val.length);
         for (i = 0, l = val.length; i < l; i++) {
@@ -2348,8 +2367,8 @@ function renderList(val, render) {
     else if (isObject(val)) {
         if (hasSymbol && val[Symbol.iterator]) {
             ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
             while (!result.done) {
                 ret.push(render(result.value, ret.length));
                 result = iterator.next();
@@ -2375,14 +2394,14 @@ function renderList(val, render) {
  * Runtime helper for rendering <slot>
  */
 function renderSlot(name, fallback, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
     if (scopedSlotFn) {
         // scoped slot
         props = props || {};
         if (bindObject) {
             if (!isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
+                warn$2('slot v-bind without argument expects an Object', this);
             }
             props = extend(extend({}, bindObject), props);
         }
@@ -2391,7 +2410,7 @@ function renderSlot(name, fallback, props, bindObject) {
     else {
         nodes = this.$slots[name] || fallback;
     }
-    const target = props && props.slot;
+    var target = props && props.slot;
     if (target) {
         return this.$createElement('template', { slot: target }, nodes);
     }
@@ -2422,7 +2441,7 @@ function isKeyNotMatch(expect, actual) {
  * passing in eventKeyName as last argument separately for backwards compat
  */
 function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
     if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
         return isKeyNotMatch(builtInKeyName, eventKeyName);
     }
@@ -2441,35 +2460,38 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
 function bindObjectProps(data, tag, value, asProp, isSync) {
     if (value) {
         if (!isObject(value)) {
-            warn('v-bind without argument expects an Object or Array value', this);
+            warn$2('v-bind without argument expects an Object or Array value', this);
         }
         else {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            let hash;
-            for (const key in value) {
+            var hash = void 0;
+            var _loop_1 = function (key) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
                 else {
-                    const type = data.attrs && data.attrs.type;
+                    var type = data.attrs && data.attrs.type;
                     hash =
                         asProp || config.mustUseProp(tag, type, key)
                             ? data.domProps || (data.domProps = {})
                             : data.attrs || (data.attrs = {});
                 }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
                 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                     hash[key] = value[key];
                     if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
+                        var on = data.on || (data.on = {});
+                        on["update:" + key] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
+            };
+            for (var key in value) {
+                _loop_1(key);
             }
         }
     }
@@ -2480,8 +2502,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
  * Runtime helper for rendering static trees.
  */
 function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
     // if has already-rendered static tree and not inside v-for,
     // we can reuse the same tree.
     if (tree && !isInFor) {
@@ -2490,7 +2512,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, `__static__${index}`, false);
+    markStatic$1(tree, "__static__" + index, false);
     return tree;
 }
 /**
@@ -2498,14 +2520,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
     return tree;
 }
-function markStatic(tree, key, isOnce) {
+function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
+        for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+                markStaticNode(tree[i], key + "_" + i, isOnce);
             }
         }
     }
@@ -2523,13 +2545,13 @@ function markStaticNode(node, key, isOnce) {
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
-            warn('v-on without argument expects an Object value', this);
+            warn$2('v-on without argument expects an Object value', this);
         }
         else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
                 on[key] = existing ? [].concat(existing, ours) : ours;
             }
         }
@@ -2541,8 +2563,8 @@ function resolveScopedSlots(fns, res,
 // the following are added in 2.6
 hasDynamicKeys, contentHashKey) {
     res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
         if (Array.isArray(slot)) {
             resolveScopedSlots(slot, res, hasDynamicKeys);
         }
@@ -2564,15 +2586,15 @@ hasDynamicKeys, contentHashKey) {
 
 /* @flow */
 function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
         if (typeof key === 'string' && key) {
             baseObj[values[i]] = values[i + 1];
         }
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
         }
     }
     return baseObj;
@@ -2607,10 +2629,11 @@ function installRenderHelpers(target) {
 
 /* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
+    var _this = this;
+    var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
+    var contextVm;
     if (hasOwn(parent, '_uid')) {
         contextVm = Object.create(parent);
         // $flow-disable-line
@@ -2624,23 +2647,23 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         // $flow-disable-line
         parent = parent._original;
     }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
     this.data = data;
     this.props = props;
     this.children = children;
     this.parent = parent;
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+    this.slots = function () {
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
         }
-        return this.$slots;
+        return _this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get() {
+        get: function () {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2653,8 +2676,8 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
     }
     if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+        this._c = function (a, b, c, d) {
+            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2663,16 +2686,18 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+        this._c = function (a, b, c, d) {
+            return createElement$1(contextVm, a, b, c, d, needNormalization);
+        };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
 function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
     if (isDef(propOptions)) {
-        for (const key in propOptions) {
+        for (var key in propOptions) {
             props[key] = validateProp(key, propOptions, propsData || emptyObject);
         }
     }
@@ -2682,15 +2707,15 @@ function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
         if (isDef(data.props))
             mergeProps(props, data.props);
     }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
     if (vnode instanceof VNode) {
         return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
     }
     else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
             res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
         }
         return res;
@@ -2700,7 +2725,7 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     // #7817 clone node before setting fnContext, otherwise if the node is reused
     // (e.g. it was from a cached normal slot) the fnContext causes named slots
     // that should not be matched to match.
-    const clone = cloneVNode(vnode);
+    var clone = cloneVNode(vnode);
     clone.fnContext = contextVm;
     clone.fnOptions = options;
     {
@@ -2712,45 +2737,41 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     return clone;
 }
 function mergeProps(to, from) {
-    for (const key in from) {
+    for (var key in from) {
         to[camelize(key)] = from[key];
     }
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
+var componentVNodeHooks = {
+    init: function (vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
             // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
+            var mountedNode = vnode; // work around flow
             componentVNodeHooks.prepatch(mountedNode, mountedNode);
         }
         else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
+    prepatch: function (oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
         options.listeners, // updated listeners
         vnode, // new parent vnode
         options.children // new children
         );
     },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
+            callHook$1(componentInstance, 'mounted');
         }
         if (vnode.data.keepAlive) {
             if (context._isMounted) {
@@ -2766,8 +2787,8 @@ const componentVNodeHooks = {
             }
         }
     },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
+    destroy: function (vnode) {
+        var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
                 componentInstance.$destroy();
@@ -2778,12 +2799,12 @@ const componentVNodeHooks = {
         }
     },
 };
-const hooksToMerge = Object.keys(componentVNodeHooks);
+var hooksToMerge = Object.keys(componentVNodeHooks);
 function createComponent(Ctor, data, context, children, tag) {
     if (isUndef(Ctor)) {
         return;
     }
-    const baseCtor = context.$options._base;
+    var baseCtor = context.$options._base;
     // plain options object: turn it into a constructor
     if (isObject(Ctor)) {
         Ctor = baseCtor.extend(Ctor);
@@ -2792,12 +2813,12 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn(`Invalid Component definition: ${String(Ctor)}`, context);
+            warn$2("Invalid Component definition: " + String(Ctor), context);
         }
         return;
     }
     // async component
-    let asyncFactory;
+    var asyncFactory;
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
@@ -2820,7 +2841,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract props
     // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
     // functional component
     // @ts-expect-error
     if (isTrue(Ctor.options.functional)) {
@@ -2828,7 +2849,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract listeners, since these needs to be treated as
     // child component listeners instead of DOM listeners
-    const listeners = data.on;
+    var listeners = data.on;
     // replace with listeners with .native modifier
     // so it gets processed during parent component patch.
     data.on = data.nativeOn;
@@ -2837,7 +2858,7 @@ function createComponent(Ctor, data, context, children, tag) {
         // abstract components do not keep anything
         // other than props & listeners & slot
         // work around flow
-        const slot = data.slot;
+        var slot = data.slot;
         data = {};
         if (slot) {
             data.slot = slot;
@@ -2847,12 +2868,12 @@ function createComponent(Ctor, data, context, children, tag) {
     installComponentHooks(data);
     // return a placeholder vnode
     // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
     // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
 }
 function createComponentInstanceForVnode(
@@ -2860,13 +2881,13 @@ function createComponentInstanceForVnode(
 vnode, 
 // activeInstance in lifecycle state
 parent) {
-    const options = {
+    var options = {
         _isComponent: true,
         _parentVnode: vnode,
-        parent,
+        parent: parent,
     };
     // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
+    var inlineTemplate = vnode.data.inlineTemplate;
     if (isDef(inlineTemplate)) {
         options.render = inlineTemplate.render;
         options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2874,19 +2895,19 @@ parent) {
     return new vnode.componentOptions.Ctor(options);
 }
 function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
     }
 }
-function mergeHook$1(f1, f2) {
-    const merged = (a, b) => {
+function mergeHook(f1, f2) {
+    var merged = function (a, b) {
         // flow complains about extra args which is why we use any
         f1(a, b);
         f2(a, b);
@@ -2897,12 +2918,12 @@ function mergeHook$1(f1, f2) {
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
 function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
     (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
     if (isDef(existing)) {
         if (Array.isArray(existing)
             ? existing.indexOf(callback) === -1
@@ -2916,11 +2937,11 @@ function transformModel(options, data) {
 }
 
 /* @flow */
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
+var SIMPLE_NORMALIZE = 1;
+var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
     if (Array.isArray(data) || isPrimitive(data)) {
         normalizationType = children;
         children = data;
@@ -2933,7 +2954,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2950,7 +2971,7 @@ function _createElement(context, tag, data, children, normalizationType) {
         !isPrimitive(data.key)) {
         // @ts-expect-error
         {
-            warn('Avoid using non-primitive value as key, ' +
+            warn$2('Avoid using non-primitive value as key, ' +
                 'use string/number value instead.', context);
         }
     }
@@ -2966,16 +2987,16 @@ function _createElement(context, tag, data, children, normalizationType) {
     else if (normalizationType === SIMPLE_NORMALIZE) {
         children = simpleNormalizeChildren(children);
     }
-    let vnode, ns;
+    var vnode, ns;
     if (typeof tag === 'string') {
-        let Ctor;
+        var Ctor = void 0;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+                warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3017,8 +3038,8 @@ function applyNS(vnode, ns, force) {
         force = true;
     }
     if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
             if (isDef(child.tag) &&
                 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                 applyNS(child, ns, force);
@@ -3042,9 +3063,9 @@ function registerDeepBindings(data) {
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
     vm.$slots = resolveSlots(options._renderChildren, renderContext);
     vm.$scopedSlots = emptyObject;
     // bind the createElement fn to this instance
@@ -3052,25 +3073,25 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement(vm, a, b, c, d, false);
+    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement(vm, a, b, c, d, true);
+    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
+    var parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
         }, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
         }, true);
     }
 }
-let currentRenderingInstance = null;
+var currentRenderingInstance = null;
 function renderMixin(Vue) {
     // install runtime convenience helpers
     installRenderHelpers(Vue.prototype);
@@ -3078,8 +3099,8 @@ function renderMixin(Vue) {
         return nextTick(fn, this);
     };
     Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
+        var vm = this;
+        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3087,7 +3108,7 @@ function renderMixin(Vue) {
         // to the data on the placeholder node.
         vm.$vnode = _parentVnode;
         // render self
-        let vnode;
+        var vnode;
         try {
             // There's no need to maintain a stack because all render fns are called
             // separately from one another. Nested component's render fns are called
@@ -3096,7 +3117,7 @@ function renderMixin(Vue) {
             vnode = render.call(vm._renderProxy, vm.$createElement);
         }
         catch (e) {
-            handleError(e, vm, `render`);
+            handleError(e, vm, "render");
             // return error render result,
             // or previous vnode to prevent render error causing blank component
             /* istanbul ignore else */
@@ -3105,7 +3126,7 @@ function renderMixin(Vue) {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
                 catch (e) {
-                    handleError(e, vm, `renderError`);
+                    handleError(e, vm, "renderError");
                     vnode = vm._vnode;
                 }
             }
@@ -3123,7 +3144,7 @@ function renderMixin(Vue) {
         // return empty vnode in case the render function errored out
         if (!(vnode instanceof VNode)) {
             if (Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
+                warn$2('Multiple root nodes returned from render function. Render function ' +
                     'should return a single root node.', vm);
             }
             vnode = createEmptyVNode();
@@ -3142,9 +3163,9 @@ function ensureCtor(comp, base) {
     return isObject(comp) ? base.extend(comp) : comp;
 }
 function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
+    var node = createEmptyVNode();
     node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
     return node;
 }
 function resolveAsyncComponent(factory, baseCtor) {
@@ -3154,7 +3175,7 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    const owner = currentRenderingInstance;
+    var owner = currentRenderingInstance;
     if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
         // already pending
         factory.owners.push(owner);
@@ -3163,88 +3184,89 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
+        var owners_1 = (factory.owners = [owner]);
+        var sync_1 = true;
+        var timerLoading_1 = null;
+        var timerTimeout_1 = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+        var forceRender_1 = function (renderCompleted) {
+            for (var i = 0, l = owners_1.length; i < l; i++) {
+                owners_1[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
+                owners_1.length = 0;
+                if (timerLoading_1 !== null) {
+                    clearTimeout(timerLoading_1);
+                    timerLoading_1 = null;
                 }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
+                if (timerTimeout_1 !== null) {
+                    clearTimeout(timerTimeout_1);
+                    timerTimeout_1 = null;
                 }
             }
         };
-        const resolve = once((res) => {
+        var resolve = once(function (res) {
             // cache resolved
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
+            if (!sync_1) {
+                forceRender_1(true);
             }
             else {
-                owners.length = 0;
+                owners_1.length = 0;
             }
         });
-        const reject = once((reason) => {
-            warn(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
+        var reject_1 = once(function (reason) {
+            warn$2("Failed to resolve async component: " + String(factory) +
+                    (reason ? "\nReason: " + reason : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender(true);
+                forceRender_1(true);
             }
         });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
+        var res_1 = factory(resolve, reject_1);
+        if (isObject(res_1)) {
+            if (isPromise(res_1)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
+                    res_1.then(resolve, reject_1);
                 }
             }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
+            else if (isPromise(res_1.component)) {
+                res_1.component.then(resolve, reject_1);
+                if (isDef(res_1.error)) {
+                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
                 }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
+                if (isDef(res_1.loading)) {
+                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                    if (res_1.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
+                        timerLoading_1 = setTimeout(function () {
+                            timerLoading_1 = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender(false);
+                                forceRender_1(false);
                             }
-                        }, res.delay || 200);
+                        }, res_1.delay || 200);
                     }
                 }
-                if (isDef(res.timeout)) {
+                if (isDef(res_1.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
+                    timerTimeout_1 = setTimeout(function () {
+                        timerTimeout_1 = null;
                         if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`);
+                            reject_1("timeout (" + res_1.timeout + "ms)"
+                                );
                         }
-                    }, res.timeout);
+                    }, res_1.timeout);
                 }
             }
         }
-        sync = false;
+        sync_1 = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3259,8 +3281,8 @@ function isAsyncPlaceholder(node) {
 /* @flow */
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
+        for (var i = 0; i < children.length; i++) {
+            var c = children[i];
             if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                 return c;
             }
@@ -3268,45 +3290,43 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
-
 /* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
     // init parent attached events
-    const listeners = vm.$options._parentListeners;
+    var listeners = vm.$options._parentListeners;
     if (listeners) {
         updateComponentListeners(vm, listeners);
     }
 }
-let target;
-function add(event, fn) {
-    target.$on(event, fn);
+var target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
 }
 function remove$1(event, fn) {
-    target.$off(event, fn);
+    target$1.$off(event, fn);
 }
-function createOnceHandler(event, fn) {
-    const _target = target;
+function createOnceHandler$1(event, fn) {
+    var _target = target$1;
     return function onceHandler() {
-        const res = fn.apply(null, arguments);
+        var res = fn.apply(null, arguments);
         if (res !== null) {
             _target.$off(event, onceHandler);
         }
     };
 }
 function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
 }
 function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
+    var hookRE = /^hook:/;
     Vue.prototype.$on = function (event, fn) {
-        const vm = this;
+        var vm = this;
         if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
+            for (var i = 0, l = event.length; i < l; i++) {
                 vm.$on(event[i], fn);
             }
         }
@@ -3321,7 +3341,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$once = function (event, fn) {
-        const vm = this;
+        var vm = this;
         function on() {
             vm.$off(event, on);
             fn.apply(vm, arguments);
@@ -3331,7 +3351,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$off = function (event, fn) {
-        const vm = this;
+        var vm = this;
         // all
         if (!arguments.length) {
             vm._events = Object.create(null);
@@ -3339,13 +3359,13 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
+            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                vm.$off(event[i_1], fn);
             }
             return vm;
         }
         // specific event
-        const cbs = vm._events[event];
+        var cbs = vm._events[event];
         if (!cbs) {
             return vm;
         }
@@ -3354,8 +3374,8 @@ function eventsMixin(Vue) {
             return vm;
         }
         // specific handler
-        let cb;
-        let i = cbs.length;
+        var cb;
+        var i = cbs.length;
         while (i--) {
             cb = cbs[i];
             if (cb === fn || cb.fn === fn) {
@@ -3366,23 +3386,23 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$emit = function (event) {
-        const vm = this;
+        var vm = this;
         {
-            const lowerCaseEvent = event.toLowerCase();
+            var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                    "Note that HTML attributes are case-insensitive and you cannot use " +
+                    "v-on to listen to camelCase events when using in-DOM templates. " +
+                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
             }
         }
-        let cbs = vm._events[event];
+        var cbs = vm._events[event];
         if (cbs) {
             cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
+            var args = toArray(arguments, 1);
+            var info = "event handler for \"" + event + "\"";
+            for (var i = 0, l = cbs.length; i < l; i++) {
                 invokeWithErrorHandling(cbs[i], vm, args, vm, info);
             }
         }
@@ -3391,19 +3411,19 @@ function eventsMixin(Vue) {
 }
 
 /* @flow */
-let activeInstance = null;
-let isUpdatingChildComponent = false;
+var activeInstance = null;
+var isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
+    var prevActiveInstance = activeInstance;
     activeInstance = vm;
-    return () => {
+    return function () {
         activeInstance = prevActiveInstance;
     };
 }
 function initLifecycle(vm) {
-    const options = vm.$options;
+    var options = vm.$options;
     // locate first non-abstract parent
-    let parent = options.parent;
+    var parent = options.parent;
     if (parent && !options.abstract) {
         while (parent.$options.abstract && parent.$parent) {
             parent = parent.$parent;
@@ -3424,10 +3444,10 @@ function initLifecycle(vm) {
 }
 function lifecycleMixin(Vue) {
     Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
+        var vm = this;
+        var prevEl = vm.$el;
+        var prevVnode = vm._vnode;
+        var restoreActiveInstance = setActiveInstance(vm);
         vm._vnode = vnode;
         // Vue.prototype.__patch__ is injected in entry points
         // based on the rendering backend used.
@@ -3455,29 +3475,29 @@ function lifecycleMixin(Vue) {
         // updated in a parent's updated hook.
     };
     Vue.prototype.$forceUpdate = function () {
-        const vm = this;
+        var vm = this;
         if (vm._watcher) {
             vm._watcher.update();
         }
     };
     Vue.prototype.$destroy = function () {
-        const vm = this;
+        var vm = this;
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook(vm, 'beforeDestroy');
+        callHook$1(vm, 'beforeDestroy');
         vm._isBeingDestroyed = true;
         // remove self from parent
-        const parent = vm.$parent;
+        var parent = vm.$parent;
         // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove(parent.$children, vm);
+            remove$2(parent.$children, vm);
         }
         // teardown watchers
         if (vm._watcher) {
             vm._watcher.teardown();
         }
-        let i = vm._watchers.length;
+        var i = vm._watchers.length;
         while (i--) {
             vm._watchers[i].teardown();
         }
@@ -3491,7 +3511,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook(vm, 'destroyed');
+        callHook$1(vm, 'destroyed');
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3515,36 +3535,36 @@ function mountComponent(vm, el, hydrating) {
             if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
                 vm.$options.el ||
                 el) {
-                warn('You are using the runtime-only build of Vue where the template ' +
+                warn$2('You are using the runtime-only build of Vue where the template ' +
                     'compiler is not available. Either pre-compile the templates into ' +
                     'render functions, or use the compiler-included build.', vm);
             }
             else {
-                warn('Failed to mount component: template or render function not defined.', vm);
+                warn$2('Failed to mount component: template or render function not defined.', vm);
             }
         }
     }
-    callHook(vm, 'beforeMount');
-    let updateComponent;
+    callHook$1(vm, 'beforeMount');
+    var updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
+        updateComponent = function () {
+            var name = vm._name;
+            var id = vm._uid;
+            var startTag = "vue-perf-start:" + id;
+            var endTag = "vue-perf-end:" + id;
             mark(startTag);
-            const vnode = vm._render();
+            var vnode = vm._render();
             mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
+            measure("vue " + name + " render", startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
+            measure("vue " + name + " patch", startTag, endTag);
         };
     }
     else {
-        updateComponent = () => {
+        updateComponent = function () {
             vm._update(vm._render(), hydrating);
         };
     }
@@ -3552,9 +3572,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before() {
+        before: function () {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook(vm, 'beforeUpdate');
+                callHook$1(vm, 'beforeUpdate');
             }
         },
     }, true /* isRenderWatcher */);
@@ -3563,7 +3583,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook(vm, 'mounted');
+        callHook$1(vm, 'mounted');
     }
     return vm;
 }
@@ -3576,15 +3596,15 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // check if there are dynamic scopedSlots (hand-written or compiled but with
     // dynamic slot names). Static scoped slots compiled from template has the
     // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
         (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
+    var needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
     // @ts-ignore
@@ -3606,11 +3626,11 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // update props
     if (propsData && vm.$options.props) {
         toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
             props[key] = validateProp(key, propOptions, propsData, vm);
         }
         toggleObserving(true);
@@ -3619,7 +3639,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     }
     // update listeners
     listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
+    var oldListeners = vm.$options._parentListeners;
     vm.$options._parentListeners = listeners;
     updateComponentListeners(vm, listeners, oldListeners);
     // resolve slots + force update if has children
@@ -3650,10 +3670,10 @@ function activateChildComponent(vm, direct) {
     }
     if (vm._inactive || vm._inactive === null) {
         vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
+        for (var i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'activated');
+        callHook$1(vm, 'activated');
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3665,19 +3685,19 @@ function deactivateChildComponent(vm, direct) {
     }
     if (!vm._inactive) {
         vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
+        for (var i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'deactivated');
+        callHook$1(vm, 'deactivated');
     }
 }
-function callHook(vm, hook) {
+function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
     if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
             invokeWithErrorHandling(handlers[i], vm, null, vm, info);
         }
     }
@@ -3688,19 +3708,19 @@ function callHook(vm, hook) {
 }
 
 /* @flow */
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index = 0;
+var MAX_UPDATE_COUNT = 100;
+var queue = [];
+var activatedChildren = [];
+var has = {};
+var circular = {};
+var waiting = false;
+var flushing = false;
+var index$1 = 0;
 /**
  * Reset the scheduler's state.
  */
 function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
+    index$1 = queue.length = activatedChildren.length = 0;
     has = {};
     {
         circular = {};
@@ -3712,9 +3732,9 @@ function resetSchedulerState() {
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
-let currentFlushTimestamp = 0;
+var currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
+var getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3722,15 +3742,15 @@ let getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = () => performance.now();
+        getNow = function () { return performance_1.now(); };
     }
 }
 /**
@@ -3739,7 +3759,7 @@ if (inBrowser && !isIE) {
 function flushSchedulerQueue() {
     currentFlushTimestamp = getNow();
     flushing = true;
-    let watcher, id;
+    var watcher, id;
     // Sort queue before flush.
     // This ensures that:
     // 1. Components are updated from parent to child. (because parent is always
@@ -3748,11 +3768,11 @@ function flushSchedulerQueue() {
     //    user watchers are created before the render watcher)
     // 3. If a component is destroyed during a parent component's watcher run,
     //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
+    queue.sort(function (a, b) { return a.id - b.id; });
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
+    for (index$1 = 0; index$1 < queue.length; index$1++) {
+        watcher = queue[index$1];
         if (watcher.before) {
             watcher.before();
         }
@@ -3763,17 +3783,17 @@ function flushSchedulerQueue() {
         if (has[id] != null) {
             circular[id] = (circular[id] || 0) + 1;
             if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
+                warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
+                        ? "in watcher with expression \"" + watcher.expression + "\""
+                        : "in a component render function."), watcher.vm);
                 break;
             }
         }
     }
     // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
     resetSchedulerState();
     // call component updated and activated hooks
     callActivatedHooks(activatedQueue);
@@ -3785,12 +3805,12 @@ function flushSchedulerQueue() {
     }
 }
 function callUpdatedHooks(queue) {
-    let i = queue.length;
+    var i = queue.length;
     while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
+        var watcher = queue[i];
+        var vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook(vm, 'updated');
+            callHook$1(vm, 'updated');
         }
     }
 }
@@ -3805,7 +3825,7 @@ function queueActivatedComponent(vm) {
     activatedChildren.push(vm);
 }
 function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
+    for (var i = 0; i < queue.length; i++) {
         queue[i]._inactive = true;
         activateChildComponent(queue[i], true /* true */);
     }
@@ -3816,7 +3836,7 @@ function callActivatedHooks(queue) {
  * pushed when the queue is being flushed.
  */
 function queueWatcher(watcher) {
-    const id = watcher.id;
+    var id = watcher.id;
     if (has[id] == null) {
         has[id] = true;
         if (!flushing) {
@@ -3825,8 +3845,8 @@ function queueWatcher(watcher) {
         else {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
+            var i = queue.length - 1;
+            while (i > index$1 && queue[i].id > watcher.id) {
                 i--;
             }
             queue.splice(i + 1, 0, watcher);
@@ -3844,14 +3864,14 @@ function queueWatcher(watcher) {
 }
 
 /* @flow */
-let uid$2 = 0;
+var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-class Watcher {
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+var Watcher = /** @class */ (function () {
+    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
         this.vm = vm;
         if (isRenderWatcher) {
             vm._watcher = this;
@@ -3869,7 +3889,7 @@ class Watcher {
             this.deep = this.user = this.lazy = this.sync = false;
         }
         this.cb = cb;
-        this.id = ++uid$2; // uid for batching
+        this.id = ++uid$1; // uid for batching
         this.active = true;
         this.dirty = this.lazy; // for lazy watchers
         this.deps = [];
@@ -3877,7 +3897,7 @@ class Watcher {
         this.depIds = new _Set();
         this.newDepIds = new _Set();
         this.expression =
-            expOrFn.toString();
+            expOrFn.toString() ;
         // parse expression for getter
         if (typeof expOrFn === 'function') {
             this.getter = expOrFn;
@@ -3886,7 +3906,7 @@ class Watcher {
             this.getter = parsePath(expOrFn);
             if (!this.getter) {
                 this.getter = noop;
-                warn(`Failed watching path: "${expOrFn}" ` +
+                warn$2("Failed watching path: \"" + expOrFn + "\" " +
                         'Watcher only accepts simple dot-delimited paths. ' +
                         'For full control, use a function instead.', vm);
             }
@@ -3896,16 +3916,16 @@ class Watcher {
     /**
      * Evaluate the getter, and re-collect dependencies.
      */
-    get() {
+    Watcher.prototype.get = function () {
         pushTarget(this);
-        let value;
-        const vm = this.vm;
+        var value;
+        var vm = this.vm;
         try {
             value = this.getter.call(vm, vm);
         }
         catch (e) {
             if (this.user) {
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
+                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
             }
             else {
                 throw e;
@@ -3921,12 +3941,12 @@ class Watcher {
             this.cleanupDeps();
         }
         return value;
-    }
+    };
     /**
      * Add a dependency to this directive.
      */
-    addDep(dep) {
-        const id = dep.id;
+    Watcher.prototype.addDep = function (dep) {
+        var id = dep.id;
         if (!this.newDepIds.has(id)) {
             this.newDepIds.add(id);
             this.newDeps.push(dep);
@@ -3934,19 +3954,19 @@ class Watcher {
                 dep.addSub(this);
             }
         }
-    }
+    };
     /**
      * Clean up for dependency collection.
      */
-    cleanupDeps() {
-        let i = this.deps.length;
+    Watcher.prototype.cleanupDeps = function () {
+        var i = this.deps.length;
         while (i--) {
-            const dep = this.deps[i];
+            var dep = this.deps[i];
             if (!this.newDepIds.has(dep.id)) {
                 dep.removeSub(this);
             }
         }
-        let tmp = this.depIds;
+        var tmp = this.depIds;
         this.depIds = this.newDepIds;
         this.newDepIds = tmp;
         this.newDepIds.clear();
@@ -3954,12 +3974,12 @@ class Watcher {
         this.deps = this.newDeps;
         this.newDeps = tmp;
         this.newDeps.length = 0;
-    }
+    };
     /**
      * Subscriber interface.
      * Will be called when a dependency changes.
      */
-    update() {
+    Watcher.prototype.update = function () {
         /* istanbul ignore else */
         if (this.lazy) {
             this.dirty = true;
@@ -3970,14 +3990,14 @@ class Watcher {
         else {
             queueWatcher(this);
         }
-    }
+    };
     /**
      * Scheduler job interface.
      * Will be called by the scheduler.
      */
-    run() {
+    Watcher.prototype.run = function () {
         if (this.active) {
-            const value = this.get();
+            var value = this.get();
             if (value !== this.value ||
                 // Deep watchers and watchers on Object/Arrays should fire even
                 // when the value is the same, because the value may
@@ -3985,14 +4005,14 @@ class Watcher {
                 isObject(value) ||
                 this.deep) {
                 // set new value
-                const oldValue = this.value;
+                var oldValue = this.value;
                 this.value = value;
                 if (this.user) {
                     try {
                         this.cb.call(this.vm, value, oldValue);
                     }
                     catch (e) {
-                        handleError(e, this.vm, `callback for watcher "${this.expression}"`);
+                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
                     }
                 }
                 else {
@@ -4000,46 +4020,47 @@ class Watcher {
                 }
             }
         }
-    }
+    };
     /**
      * Evaluate the value of the watcher.
      * This only gets called for lazy watchers.
      */
-    evaluate() {
+    Watcher.prototype.evaluate = function () {
         this.value = this.get();
         this.dirty = false;
-    }
+    };
     /**
      * Depend on all deps collected by this watcher.
      */
-    depend() {
-        let i = this.deps.length;
+    Watcher.prototype.depend = function () {
+        var i = this.deps.length;
         while (i--) {
             this.deps[i].depend();
         }
-    }
+    };
     /**
      * Remove self from all dependencies' subscriber list.
      */
-    teardown() {
+    Watcher.prototype.teardown = function () {
         if (this.active) {
             // remove self from vm's watcher list
             // this is a somewhat expensive operation so we skip it
             // if the vm is being destroyed.
             if (!this.vm._isBeingDestroyed) {
-                remove(this.vm._watchers, this);
+                remove$2(this.vm._watchers, this);
             }
-            let i = this.deps.length;
+            var i = this.deps.length;
             while (i--) {
                 this.deps[i].removeSub(this);
             }
             this.active = false;
         }
-    }
-}
+    };
+    return Watcher;
+}());
 
 /* @flow */
-const sharedPropertyDefinition = {
+var sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
     get: noop,
@@ -4056,9 +4077,9 @@ function proxy(target, sourceKey, key) {
 }
 function initState(vm) {
     vm._watchers = [];
-    const opts = vm.$options;
+    var opts = vm.$options;
     if (opts.props)
-        initProps(vm, opts.props);
+        initProps$1(vm, opts.props);
     if (opts.methods)
         initMethods(vm, opts.methods);
     if (opts.data) {
@@ -4068,38 +4089,38 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        initComputed(vm, opts.computed);
+        initComputed$1(vm, opts.computed);
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
-function initProps(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
+function initProps$1(vm, propsOptions) {
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
     // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
     // root instance props should be converted
     if (!isRoot) {
         toggleObserving(false);
     }
-    for (const key in propsOptions) {
+    var _loop_1 = function (key) {
         keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
+        var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
         {
-            const hyphenatedKey = hyphenate(key);
+            var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+                warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
             }
-            defineReactive$$1(props, key, value, () => {
+            defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
+                    warn$2("Avoid mutating a prop directly since the value will be " +
+                        "overwritten whenever the parent component re-renders. " +
+                        "Instead, use a data or computed property based on the prop's " +
+                        ("value. Prop being mutated: \"" + key + "\""), vm);
                 }
             });
         }
@@ -4107,37 +4128,40 @@ function initProps(vm, propsOptions) {
         // during Vue.extend(). We only need to proxy props defined at
         // instantiation here.
         if (!(key in vm)) {
-            proxy(vm, `_props`, key);
+            proxy(vm, "_props", key);
         }
+    };
+    for (var key in propsOptions) {
+        _loop_1(key);
     }
     toggleObserving(true);
 }
 function initData(vm) {
-    let data = vm.$options.data;
+    var data = vm.$options.data;
     data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        warn('data functions should return an object:\n' +
+        warn$2('data functions should return an object:\n' +
                 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
     }
     // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
     while (i--) {
-        const key = keys[i];
+        var key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn(`Method "${key}" has already been defined as a data property.`, vm);
+                warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            warn(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
+            warn$2("The data property \"" + key + "\" is already declared as a prop. " +
+                    "Use prop default value instead.", vm);
         }
         else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
+            proxy(vm, "_data", key);
         }
     }
     // observe data
@@ -4150,24 +4174,24 @@ function getData(data, vm) {
         return data.call(vm, vm);
     }
     catch (e) {
-        handleError(e, vm, `data()`);
+        handleError(e, vm, "data()");
         return {};
     }
     finally {
         popTarget();
     }
 }
-const computedWatcherOptions = { lazy: true };
-function initComputed(vm, computed) {
+var computedWatcherOptions = { lazy: true };
+function initComputed$1(vm, computed) {
     // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
+    var watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === 'function' ? userDef : userDef.get;
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+        var userDef = computed[key];
+        var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (getter == null) {
-            warn(`Getter is missing for computed property "${key}".`, vm);
+            warn$2("Getter is missing for computed property \"" + key + "\".", vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4181,16 +4205,16 @@ function initComputed(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn(`The computed property "${key}" is already defined in data.`, vm);
+                warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(`The computed property "${key}" is already defined as a prop.`, vm);
+                warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
             }
         }
     }
 }
 function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
+    var shouldCache = !isServerRendering();
     if (typeof userDef === 'function') {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
@@ -4207,14 +4231,14 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
+            warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
 }
 function createComputedGetter(key) {
     return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
+        var watcher = this._computedWatchers && this._computedWatchers[key];
         if (watcher) {
             if (watcher.dirty) {
                 watcher.evaluate();
@@ -4232,29 +4256,29 @@ function createGetterInvoker(fn) {
     };
 }
 function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
+    var props = vm.$options.props;
+    for (var key in methods) {
         {
             if (typeof methods[key] !== 'function') {
-                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
+                warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                    "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(`Method "${key}" has already been defined as a prop.`, vm);
+                warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
             }
             if (key in vm && isReserved(key)) {
-                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
+                warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                    "Avoid defining component methods that start with _ or $.");
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
+    for (var key in watch) {
+        var handler = watch[key];
         if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
+            for (var i = 0; i < handler.length; i++) {
                 createWatcher(vm, key, handler[i]);
             }
         }
@@ -4277,21 +4301,21 @@ function stateMixin(Vue) {
     // flow somehow has problems with directly declared definition object
     // when using Object.defineProperty, so we have to procedurally build up
     // the object here.
-    const dataDef = {};
+    var dataDef = {};
     dataDef.get = function () {
         return this._data;
     };
-    const propsDef = {};
+    var propsDef = {};
     propsDef.get = function () {
         return this._props;
     };
     {
         dataDef.set = function () {
-            warn('Avoid replacing instance root $data. ' +
+            warn$2('Avoid replacing instance root $data. ' +
                 'Use nested data properties instead.', this);
         };
         propsDef.set = function () {
-            warn(`$props is readonly.`, this);
+            warn$2("$props is readonly.", this);
         };
     }
     Object.defineProperty(Vue.prototype, '$data', dataDef);
@@ -4299,20 +4323,20 @@ function stateMixin(Vue) {
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
+        var vm = this;
         if (isPlainObject(cb)) {
             return createWatcher(vm, expOrFn, cb, options);
         }
         options = options || {};
         options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
+        var watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
             pushTarget();
             try {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`);
+                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
             }
             popTarget();
         }
@@ -4323,17 +4347,17 @@ function stateMixin(Vue) {
 }
 
 /* @flow */
-let uid$3 = 0;
-function initMixin(Vue) {
+var uid = 0;
+function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
-        const vm = this;
+        var vm = this;
         // a uid
-        vm._uid = uid$3++;
-        let startTag, endTag;
+        vm._uid = uid++;
+        var startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
+            startTag = "vue-perf-start:" + vm._uid;
+            endTag = "vue-perf-end:" + vm._uid;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4357,16 +4381,16 @@ function initMixin(Vue) {
         initLifecycle(vm);
         initEvents(vm);
         initRender(vm);
-        callHook(vm, 'beforeCreate');
+        callHook$1(vm, 'beforeCreate');
         initInjections(vm); // resolve injections before data/props
         initState(vm);
         initProvide(vm); // resolve provide after data/props
-        callHook(vm, 'created');
+        callHook$1(vm, 'created');
         /* istanbul ignore if */
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
+            measure("vue " + vm._name + " init", startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4375,12 +4399,12 @@ function initMixin(Vue) {
 }
 function initInternalComponent(vm, options) {
     // @ts-ignore
-    const opts = (vm.$options = Object.create(vm.constructor.options));
+    var opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
+    var parentVnode = options._parentVnode;
     opts.parent = options.parent;
     opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
+    var vnodeComponentOptions = parentVnode.componentOptions;
     opts.propsData = vnodeComponentOptions.propsData;
     opts._parentListeners = vnodeComponentOptions.listeners;
     opts._renderChildren = vnodeComponentOptions.children;
@@ -4391,16 +4415,16 @@ function initInternalComponent(vm, options) {
     }
 }
 function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
+    var options = Ctor.options;
     if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
         if (superOptions !== cachedSuperOptions) {
             // super option changed,
             // need to resolve new options.
             Ctor.superOptions = superOptions;
             // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
+            var modifiedOptions = resolveModifiedOptions(Ctor);
             // update base extend options
             if (modifiedOptions) {
                 extend(Ctor.extendOptions, modifiedOptions);
@@ -4414,10 +4438,10 @@ function resolveConstructorOptions(Ctor) {
     return options;
 }
 function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
         if (latest[key] !== sealed[key]) {
             if (!modified)
                 modified = {};
@@ -4429,12 +4453,12 @@ function resolveModifiedOptions(Ctor) {
 
 function Vue(options) {
     if (!(this instanceof Vue)) {
-        warn('Vue is a constructor and should be called with the `new` keyword');
+        warn$2('Vue is a constructor and should be called with the `new` keyword');
     }
     this._init(options);
 }
 //@ts-ignore
-initMixin(Vue);
+initMixin$1(Vue);
 //@ts-ignore
 stateMixin(Vue);
 //@ts-ignore
@@ -4447,12 +4471,12 @@ renderMixin(Vue);
 /* @flow */
 function initUse(Vue) {
     Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
         if (installedPlugins.indexOf(plugin) > -1) {
             return this;
         }
         // additional parameters
-        const args = toArray(arguments, 1);
+        var args = toArray(arguments, 1);
         args.unshift(this);
         if (typeof plugin.install === 'function') {
             plugin.install.apply(plugin, args);
@@ -4466,7 +4490,7 @@ function initUse(Vue) {
 }
 
 /* @flow */
-function initMixin$1(Vue) {
+function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
         return this;
@@ -4481,23 +4505,23 @@ function initExtend(Vue) {
      * constructors" for prototypal inheritance and cache them.
      */
     Vue.cid = 0;
-    let cid = 1;
+    var cid = 1;
     /**
      * Class inheritance
      */
     Vue.extend = function (extendOptions) {
         extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        var Super = this;
+        var SuperId = Super.cid;
+        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
         if (cachedCtors[SuperId]) {
             return cachedCtors[SuperId];
         }
-        const name = extendOptions.name || Super.options.name;
+        var name = extendOptions.name || Super.options.name;
         if (name) {
             validateComponentName(name);
         }
-        const Sub = function VueComponent(options) {
+        var Sub = function VueComponent(options) {
             this._init(options);
         };
         Sub.prototype = Object.create(Super.prototype);
@@ -4509,10 +4533,10 @@ function initExtend(Vue) {
         // the Vue instances at extension time, on the extended prototype. This
         // avoids Object.defineProperty calls for each instance created.
         if (Sub.options.props) {
-            initProps$1(Sub);
+            initProps(Sub);
         }
         if (Sub.options.computed) {
-            initComputed$1(Sub);
+            initComputed(Sub);
         }
         // allow further extension/mixin/plugin usage
         Sub.extend = Super.extend;
@@ -4538,15 +4562,15 @@ function initExtend(Vue) {
         return Sub;
     };
 }
-function initProps$1(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
+function initProps(Comp) {
+    var props = Comp.options.props;
+    for (var key in props) {
+        proxy(Comp.prototype, "_props", key);
     }
 }
-function initComputed$1(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
+function initComputed(Comp) {
+    var computed = Comp.options.computed;
+    for (var key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
     }
 }
@@ -4556,7 +4580,7 @@ function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
      */
-    ASSET_TYPES.forEach((type) => {
+    ASSET_TYPES.forEach(function (type) {
         // @ts-expect-error function is not exact same type
         Vue[type] = function (id, definition) {
             if (!definition) {
@@ -4600,26 +4624,26 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const cachedNode = cache[key];
+    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+        var cachedNode = cache[key];
         if (cachedNode) {
-            const name = getComponentName(cachedNode.componentOptions);
-            if (name && !filter(name)) {
+            var name_1 = getComponentName(cachedNode.componentOptions);
+            if (name_1 && !filter(name_1)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    const cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-        cached$$1.componentInstance.$destroy();
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+        cached.componentInstance.$destroy();
     }
     cache[key] = null;
-    remove(keys, key);
+    remove$2(keys, key);
 }
-const patternTypes = [String, RegExp, Array];
+var patternTypes = [String, RegExp, Array];
 // TODO use defineComponent
 var KeepAlive = {
     name: 'keep-alive',
@@ -4629,49 +4653,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created() {
+    created: function () {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed() {
-        for (const key in this.cache) {
+    destroyed: function () {
+        for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted() {
-        this.$watch('include', (val) => {
-            pruneCache(this, (name) => matches(val, name));
+    mounted: function () {
+        var _this = this;
+        this.$watch('include', function (val) {
+            pruneCache(_this, function (name) { return matches(val, name); });
         });
-        this.$watch('exclude', (val) => {
-            pruneCache(this, (name) => !matches(val, name));
+        this.$watch('exclude', function (val) {
+            pruneCache(_this, function (name) { return !matches(val, name); });
         });
     },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
+    render: function () {
+        var slot = this.$slots.default;
+        var vnode = getFirstComponentChild(slot);
+        var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
+            var name_2 = getComponentName(componentOptions);
+            var _a = this, include = _a.include, exclude = _a.exclude;
             if (
             // not included
-            (include && (!name || !matches(include, name))) ||
+            (include && (!name_2 || !matches(include, name_2))) ||
                 // excluded
-                (exclude && name && matches(exclude, name))) {
+                (exclude && name_2 && matches(exclude, name_2))) {
                 return vnode;
             }
-            const { cache, keys } = this;
-            const key = vnode.key == null
+            var _b = this, cache = _b.cache, keys = _b.keys;
+            var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : '')
+                        (componentOptions.tag ? "::" + componentOptions.tag : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
                 // make current key freshest
-                remove(keys, key);
+                remove$2(keys, key);
                 keys.push(key);
             }
             else {
@@ -4689,17 +4714,17 @@ var KeepAlive = {
 };
 
 var builtInComponents = {
-    KeepAlive,
+    KeepAlive: KeepAlive,
 };
 
 /* @flow */
 function initGlobalAPI(Vue) {
     // config
-    const configDef = {};
-    configDef.get = () => config;
+    var configDef = {};
+    configDef.get = function () { return config; };
     {
-        configDef.set = () => {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
+        configDef.set = function () {
+            warn$2('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
     Object.defineProperty(Vue, 'config', configDef);
@@ -4707,21 +4732,21 @@ function initGlobalAPI(Vue) {
     // NOTE: these are not considered part of the public API - avoid relying on
     // them unless you are aware of the risk.
     Vue.util = {
-        warn,
-        extend,
-        mergeOptions,
-        defineReactive: defineReactive$$1,
+        warn: warn$2,
+        extend: extend,
+        mergeOptions: mergeOptions,
+        defineReactive: defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
     Vue.nextTick = nextTick;
     // 2.6 explicit observable API
-    Vue.observable = (obj) => {
+    Vue.observable = function (obj) {
         observe(obj);
         return obj;
     };
     Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
+    ASSET_TYPES.forEach(function (type) {
         Vue.options[type + 's'] = Object.create(null);
     });
     // this is used to identify the "base" constructor to extend all plain-object
@@ -4729,7 +4754,7 @@ function initGlobalAPI(Vue) {
     Vue.options._base = Vue;
     extend(Vue.options.components, builtInComponents);
     initUse(Vue);
-    initMixin$1(Vue);
+    initMixin(Vue);
     initExtend(Vue);
     initAssetRegisters(Vue);
 }
@@ -4739,7 +4764,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
+    get: function () {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4753,18 +4778,18 @@ Vue.version = '2.6.12';
 /* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
-const isReservedAttr = makeMap('style,class');
+var isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
+var acceptValue = makeMap('input,textarea,option,select,progress');
+var mustUseProp = function (tag, type, attr) {
     return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
+var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+var convertEnumeratedValue = function (key, value) {
     return isFalsyAttrValue(value) || value === 'false'
         ? 'false'
         : // allow arbitrary string value for contenteditable
@@ -4772,28 +4797,28 @@ const convertEnumeratedValue = (key, value) => {
                 ? value
                 : 'true';
 };
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
+var xlinkNS = 'http://www.w3.org/1999/xlink';
+var isXlink = function (name) {
     return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-const getXlinkProp = (name) => {
+var getXlinkProp = function (name) {
     return isXlink(name) ? name.slice(6, name.length) : '';
 };
-const isFalsyAttrValue = (val) => {
+var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
 /* @flow */
 function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
     while (isDef(childNode.componentInstance)) {
         childNode = childNode.componentInstance._vnode;
         if (childNode && childNode.data) {
@@ -4837,9 +4862,9 @@ function stringifyClass(value) {
     return '';
 }
 function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
+    var res = '';
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
         if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
             if (res)
                 res += ' ';
@@ -4849,8 +4874,8 @@ function stringifyArray(value) {
     return res;
 }
 function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
+    var res = '';
+    for (var key in value) {
         if (value[key]) {
             if (res)
                 res += ' ';
@@ -4861,11 +4886,11 @@ function stringifyObject(value) {
 }
 
 /* @flow */
-const namespaceMap = {
+var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4878,11 +4903,11 @@ const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
+var isPreTag = function (tag) { return tag === 'pre'; };
+var isReservedTag = function (tag) {
     return isHTMLTag(tag) || isSVG(tag);
 };
 function getTagNamespace(tag) {
@@ -4895,7 +4920,7 @@ function getTagNamespace(tag) {
         return 'math';
     }
 }
-const unknownElementCache = Object.create(null);
+var unknownElementCache = Object.create(null);
 function isUnknownElement(tag) {
     /* istanbul ignore if */
     if (!inBrowser) {
@@ -4909,7 +4934,7 @@ function isUnknownElement(tag) {
     if (unknownElementCache[tag] != null) {
         return unknownElementCache[tag];
     }
-    const el = document.createElement(tag);
+    var el = document.createElement(tag);
     if (tag.indexOf('-') > -1) {
         // http://stackoverflow.com/a/28210364/1070244
         return (unknownElementCache[tag] =
@@ -4920,7 +4945,7 @@ function isUnknownElement(tag) {
         return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
     }
 }
-const isTextInputType = makeMap('text,number,password,search,email,tel,url');
+var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /* @flow */
 /**
@@ -4928,9 +4953,9 @@ const isTextInputType = makeMap('text,number,password,search,email,tel,url');
  */
 function query(el) {
     if (typeof el === 'string') {
-        const selected = document.querySelector(el);
+        var selected = document.querySelector(el);
         if (!selected) {
-            warn('Cannot find element: ' + el);
+            warn$2('Cannot find element: ' + el);
             return document.createElement('div');
         }
         return selected;
@@ -4941,8 +4966,8 @@ function query(el) {
 }
 
 /* @flow */
-function createElement$1(tagName, vnode) {
-    const elm = document.createElement(tagName);
+function createElement(tagName, vnode) {
+    var elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
     }
@@ -4989,7 +5014,8 @@ function setStyleScope(node, scopeId) {
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
-  createElement: createElement$1,
+  __proto__: null,
+  createElement: createElement,
   createElementNS: createElementNS,
   createTextNode: createTextNode,
   createComment: createComment,
@@ -5005,30 +5031,30 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 
 /* @flow */
 var ref = {
-    create(_, vnode) {
+    create: function (_, vnode) {
         registerRef(vnode);
     },
-    update(oldVnode, vnode) {
+    update: function (oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy(vnode) {
+    destroy: function (vnode) {
         registerRef(vnode, true);
     },
 };
 function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
+    var key = vnode.data.ref;
     if (!isDef(key))
         return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
     if (isRemoval) {
         if (Array.isArray(refs[key])) {
             // @ts-expect-error invalid typings
-            remove(refs[key], ref);
+            remove$2(refs[key], ref);
         }
         else if (refs[key] === ref) {
             refs[key] = undefined;
@@ -5063,8 +5089,8 @@ function registerRef(vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+var emptyNode = new VNode('', {}, []);
+var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
         ((a.tag === b.tag &&
@@ -5078,14 +5104,14 @@ function sameVnode(a, b) {
 function sameInputType(a, b) {
     if (a.tag !== 'input')
         return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
     return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
 function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
+    var i, key;
+    var map = {};
     for (i = beginIdx; i <= endIdx; ++i) {
         key = children[i].key;
         if (isDef(key))
@@ -5094,9 +5120,9 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
     return map;
 }
 function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules, nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5109,33 +5135,33 @@ function createPatchFunction(backend) {
         return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
     function createRmCb(childElm, listeners) {
-        function remove$$1() {
-            if (--remove$$1.listeners === 0) {
+        function remove() {
+            if (--remove.listeners === 0) {
                 removeNode(childElm);
             }
         }
-        remove$$1.listeners = listeners;
-        return remove$$1;
+        remove.listeners = listeners;
+        return remove;
     }
     function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
+        var parent = nodeOps.parentNode(el);
         // element may have already been removed due to v-html / v-text
         if (isDef(parent)) {
             nodeOps.removeChild(parent, el);
         }
     }
-    function isUnknownElement$$1(vnode, inVPre) {
+    function isUnknownElement(vnode, inVPre) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
+                config.ignoredElements.some(function (ignore) {
                     return isRegExp(ignore)
                         ? ignore.test(vnode.tag)
                         : ignore === vnode.tag;
                 })) &&
             config.isUnknownElement(vnode.tag));
     }
-    let creatingElmInVPre = 0;
+    var creatingElmInVPre = 0;
     function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
         if (isDef(vnode.elm) && isDef(ownerArray)) {
             // This vnode was used in a previous render!
@@ -5149,16 +5175,16 @@ function createPatchFunction(backend) {
         if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
             return;
         }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
+        var tag = vnode.tag;
         if (isDef(tag)) {
             {
                 if (data && data.pre) {
                     creatingElmInVPre++;
                 }
-                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn$2('Unknown custom element: <' +
                         tag +
                         '> - did you ' +
                         'register the component correctly? For recursive components, ' +
@@ -5191,9 +5217,9 @@ function createPatchFunction(backend) {
         }
     }
     function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
+        var i = vnode.data;
         if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
             if (isDef((i = i.hook)) && isDef((i = i.init))) {
                 i(vnode, false /* hydrating */);
             }
@@ -5230,12 +5256,12 @@ function createPatchFunction(backend) {
         }
     }
     function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
+        var i;
         // hack for #4339: a reactivated component with inner transition
         // does not trigger because the inner node's created hooks are not called
         // again. It's not ideal to involve module-specific logic in here but
         // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
+        var innerNode = vnode;
         while (innerNode.componentInstance) {
             innerNode = innerNode.componentInstance._vnode;
             if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5250,11 +5276,11 @@ function createPatchFunction(backend) {
         // a reactivated keep-alive component doesn't insert itself
         insert(parentElm, vnode.elm, refElm);
     }
-    function insert(parent, elm, ref$$1) {
+    function insert(parent, elm, ref) {
         if (isDef(parent)) {
-            if (isDef(ref$$1)) {
-                if (nodeOps.parentNode(ref$$1) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref$$1);
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
                 }
             }
             else {
@@ -5267,8 +5293,8 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5282,8 +5308,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
+        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+            cbs.create[i_2](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5297,12 +5323,12 @@ function createPatchFunction(backend) {
     // this is implemented as a special case to avoid the overhead
     // of going through the normal attribute patching process.
     function setScope(vnode) {
-        let i;
+        var i;
         if (isDef((i = vnode.fnScopeId))) {
             nodeOps.setStyleScope(vnode.elm, i);
         }
         else {
-            let ancestor = vnode;
+            var ancestor = vnode;
             while (ancestor) {
                 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                     nodeOps.setStyleScope(vnode.elm, i);
@@ -5324,8 +5350,8 @@ function createPatchFunction(backend) {
         }
     }
     function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
+        var i, j;
+        var data = vnode.data;
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.destroy)))
                 i(vnode);
@@ -5340,7 +5366,7 @@ function createPatchFunction(backend) {
     }
     function removeVnodes(vnodes, startIdx, endIdx) {
         for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
+            var ch = vnodes[startIdx];
             if (isDef(ch)) {
                 if (isDef(ch.tag)) {
                     removeAndInvokeRemoveHook(ch);
@@ -5355,8 +5381,8 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
+            var i_3;
+            var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
                 // increase the listeners count
@@ -5367,16 +5393,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
+            if (isDef((i_3 = vnode.componentInstance)) &&
+                isDef((i_3 = i_3._vnode)) &&
+                isDef(i_3.data)) {
+                removeAndInvokeRemoveHook(i_3, rm);
             }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
+            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                cbs.remove[i_3](vnode, rm);
             }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
+            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                i_3(vnode, rm);
             }
             else {
                 rm();
@@ -5387,19 +5413,19 @@ function createPatchFunction(backend) {
         }
     }
     function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        var oldStartIdx = 0;
+        var newStartIdx = 0;
+        var oldEndIdx = oldCh.length - 1;
+        var oldStartVnode = oldCh[0];
+        var oldEndVnode = oldCh[oldEndIdx];
+        var newEndIdx = newCh.length - 1;
+        var newStartVnode = newCh[0];
+        var newEndVnode = newCh[newEndIdx];
+        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
         // removeOnly is a special flag used only by <transition-group>
         // to ensure removed elements stay in correct relative positions
         // during leaving transitions
-        const canMove = !removeOnly;
+        var canMove = !removeOnly;
         {
             checkDuplicateKeys(newCh);
         }
@@ -5471,13 +5497,13 @@ function createPatchFunction(backend) {
         }
     }
     function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
+        var seenKeys = {};
+        for (var i_4 = 0; i_4 < children.length; i_4++) {
+            var vnode = children[i_4];
+            var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                    warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5486,10 +5512,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
+        for (var i_5 = start; i_5 < end; i_5++) {
+            var c = oldCh[i_5];
             if (isDef(c) && sameVnode(node, c))
-                return i;
+                return i_5;
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5500,7 +5526,7 @@ function createPatchFunction(backend) {
             // clone reused vnode
             vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        const elm = (vnode.elm = oldVnode.elm);
+        var elm = (vnode.elm = oldVnode.elm);
         if (isTrue(oldVnode.isAsyncPlaceholder)) {
             if (isDef(vnode.asyncFactory.resolved)) {
                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5521,13 +5547,13 @@ function createPatchFunction(backend) {
             vnode.componentInstance = oldVnode.componentInstance;
             return;
         }
-        let i;
-        const data = vnode.data;
+        var i;
+        var data = vnode.data;
         if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
             i(oldVnode, vnode);
         }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
+        var oldCh = oldVnode.children;
+        var ch = vnode.children;
         if (isDef(data) && isPatchable(vnode)) {
             for (i = 0; i < cbs.update.length; ++i)
                 cbs.update[i](oldVnode, vnode);
@@ -5569,21 +5595,21 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
+            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                queue[i_6].data.hook.insert(queue[i_6]);
             }
         }
     }
-    let hydrationBailed = false;
+    var hydrationBailed = false;
     // list of modules that can skip create hook during hydration because they
     // are already rendered on the client or has no need for initialization
     // Note: style is excluded because it relies on initial clone for future
     // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
+        var i;
+        var tag = vnode.tag, data = vnode.data, children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5630,11 +5656,11 @@ function createPatchFunction(backend) {
                     }
                     else {
                         // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
+                        var childrenMatch = true;
+                        var childNode = elm.firstChild;
+                        for (var i_7 = 0; i_7 < children.length; i_7++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5656,8 +5682,8 @@ function createPatchFunction(backend) {
                 }
             }
             if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
+                var fullInvoke = false;
+                for (var key in data) {
                     if (!isRenderedModule(key)) {
                         fullInvoke = true;
                         invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5678,7 +5704,7 @@ function createPatchFunction(backend) {
     function assertNodeMatch(node, vnode, inVPre) {
         if (isDef(vnode.tag)) {
             return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement$$1(vnode, inVPre) &&
+                (!isUnknownElement(vnode, inVPre) &&
                     vnode.tag.toLowerCase() ===
                         (node.tagName && node.tagName.toLowerCase())));
         }
@@ -5692,15 +5718,15 @@ function createPatchFunction(backend) {
                 invokeDestroyHook(oldVnode);
             return;
         }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
+        var isInitialPatch = false;
+        var insertedVnodeQueue = [];
         if (isUndef(oldVnode)) {
             // empty mount (likely as component), create new root element
             isInitialPatch = true;
             createElm(vnode, insertedVnodeQueue);
         }
         else {
-            const isRealElement = isDef(oldVnode.nodeType);
+            var isRealElement = isDef(oldVnode.nodeType);
             if (!isRealElement && sameVnode(oldVnode, vnode)) {
                 // patch existing root node
                 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5720,7 +5746,7 @@ function createPatchFunction(backend) {
                             return oldVnode;
                         }
                         else {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
                                 'server-rendered content. This is likely caused by incorrect ' +
                                 'HTML markup, for example nesting block-level elements inside ' +
                                 '<p>, or missing <tbody>. Bailing hydration and performing ' +
@@ -5732,8 +5758,8 @@ function createPatchFunction(backend) {
                     oldVnode = emptyNodeAt(oldVnode);
                 }
                 // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
+                var oldElm = oldVnode.elm;
+                var parentElm = nodeOps.parentNode(oldElm);
                 // create new node
                 createElm(vnode, insertedVnodeQueue, 
                 // extremely rare edge case: do not insert if old element is in a
@@ -5742,25 +5768,25 @@ function createPatchFunction(backend) {
                 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                 // update parent placeholder node element, recursively
                 if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
+                    var ancestor = vnode.parent;
+                    var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
+                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                            cbs.destroy[i_8](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
+                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                cbs.create[i_9](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
+                            var insert_1 = ancestor.data.hook.insert;
+                            if (insert_1.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
+                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                    insert_1.fns[i_10]();
                                 }
                             }
                         }
@@ -5785,7 +5811,7 @@ function createPatchFunction(backend) {
 }
 
 /* @flow */
-var directives = {
+var directives$1 = {
     create: updateDirectives,
     update: updateDirectives,
     destroy: function unbindDirectives(vnode) {
@@ -5799,19 +5825,19 @@ function updateDirectives(oldVnode, vnode) {
     }
 }
 function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
     for (key in newDirs) {
         oldDir = oldDirs[key];
         dir = newDirs[key];
         if (!oldDir) {
             // new directive, bind
-            callHook$1(dir, 'bind', vnode, oldVnode);
+            callHook(dir, 'bind', vnode, oldVnode);
             if (dir.def && dir.def.inserted) {
                 dirsWithInsert.push(dir);
             }
@@ -5820,16 +5846,16 @@ function _update(oldVnode, vnode) {
             // existing directive, update
             dir.oldValue = oldDir.value;
             dir.oldArg = oldDir.arg;
-            callHook$1(dir, 'update', vnode, oldVnode);
+            callHook(dir, 'update', vnode, oldVnode);
             if (dir.def && dir.def.componentUpdated) {
                 dirsWithPostpatch.push(dir);
             }
         }
     }
     if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+        var callInsert = function () {
+            for (var i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
         if (isCreate) {
@@ -5840,9 +5866,9 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+        mergeVNodeHook(vnode, 'postpatch', function () {
+            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
     }
@@ -5850,19 +5876,19 @@ function _update(oldVnode, vnode) {
         for (key in oldDirs) {
             if (!newDirs[key]) {
                 // no longer present, unbind
-                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
             }
         }
     }
 }
-const emptyModifiers = Object.create(null);
-function normalizeDirectives$1(dirs, vm) {
-    const res = Object.create(null);
+var emptyModifiers = Object.create(null);
+function normalizeDirectives(dirs, vm) {
+    var res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
         return res;
     }
-    let i, dir;
+    var i, dir;
     for (i = 0; i < dirs.length; i++) {
         dir = dirs[i];
         if (!dir.modifiers) {
@@ -5876,35 +5902,35 @@ function normalizeDirectives$1(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
 }
-function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    var fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
         }
     }
 }
 
-var baseModules = [ref, directives];
+var baseModules = [ref, directives$1];
 
 /* @flow */
 function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
+    var opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
         return;
     }
     if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
         return;
     }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(attrs.__ob__)) {
         attrs = vnode.data.attrs = extend({}, attrs);
@@ -5980,11 +6006,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            const blocker = (e) => {
+            var blocker_1 = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
+                el.removeEventListener('input', blocker_1);
             };
-            el.addEventListener('input', blocker);
+            el.addEventListener('input', blocker_1);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -5998,18 +6024,18 @@ var attrs = {
 
 /* @flow */
 function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
+    var el = vnode.elm;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
     if (isUndef(data.staticClass) &&
         isUndef(data.class) &&
         (isUndef(oldData) ||
             (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
         return;
     }
-    let cls = genClassForVnode(vnode);
+    var cls = genClassForVnode(vnode);
     // handle transition classes
-    const transitionClass = el._transitionClasses;
+    var transitionClass = el._transitionClasses;
     if (isDef(transitionClass)) {
         cls = concat(cls, stringifyClass(transitionClass));
     }
@@ -6019,23 +6045,23 @@ function updateClass(oldVnode, vnode) {
         el._prevClass = cls;
     }
 }
-var klass = {
+var klass$1 = {
     create: updateClass,
     update: updateClass,
 };
 
 /* @flow */
-const validDivisionCharRE = /[\w).+\-_$\]]/;
+var validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
+    var inSingle = false;
+    var inDouble = false;
+    var inTemplateString = false;
+    var inRegex = false;
+    var curly = 0;
+    var square = 0;
+    var paren = 0;
+    var lastFilterIndex = 0;
+    var c, prev, i, expression, filters;
     for (i = 0; i < exp.length; i++) {
         prev = c;
         c = exp.charCodeAt(i);
@@ -6102,8 +6128,10 @@ function parseFilters(exp) {
             }
             if (c === 0x2f) {
                 // /
-                let j = i - 1;
-                let p;
+                var j = i - 1;
+                var p 
+                // find first non-whitespace prev char
+                = void 0;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -6134,56 +6162,56 @@ function parseFilters(exp) {
     return expression;
 }
 function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
+    var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
+        return "_f(\"" + filter + "\")(" + exp + ")";
     }
     else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+        var name_1 = filter.slice(0, i);
+        var args = filter.slice(i + 1);
+        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
     }
 }
 
 /* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
+    console.error("[Vue compiler]: " + msg);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
 }
 function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
     el.plain = false;
 }
 function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
+    var attrs = dynamic
         ? el.dynamicAttrs || (el.dynamicAttrs = [])
         : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
     el.plain = false;
 }
 // add a raw attr (use this in preTransforms)
 function addRawAttr(el, name, value, range) {
     el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
 }
 function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
     (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers,
     }, range));
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6200,7 +6228,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     // the only target envs that have right/middle clicks.
     if (modifiers.right) {
         if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
+            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
         }
         else if (name === 'click') {
             name = 'contextmenu';
@@ -6209,7 +6237,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     }
     else if (modifiers.middle) {
         if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
+            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
         }
         else if (name === 'click') {
             name = 'mouseup';
@@ -6229,7 +6257,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
         delete modifiers.passive;
         name = prependModifierMarker('&', name, dynamic);
     }
-    let events;
+    var events;
     if (modifiers.native) {
         delete modifiers.native;
         events = el.nativeEvents || (el.nativeEvents = {});
@@ -6237,11 +6265,11 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     else {
         events = el.events || (el.events = {});
     }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
     if (modifiers !== emptyObject) {
         newHandler.modifiers = modifiers;
     }
-    const handlers = events[name];
+    var handlers = events[name];
     /* istanbul ignore if */
     if (Array.isArray(handlers)) {
         important ? handlers.unshift(newHandler) : handlers.push(newHandler);
@@ -6260,12 +6288,12 @@ function getRawBindingAttr(el, name) {
         el.rawAttrsMap[name]);
 }
 function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
     if (dynamicValue != null) {
         return parseFilters(dynamicValue);
     }
     else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
+        var staticValue = getAndRemoveAttr(el, name);
         if (staticValue != null) {
             return JSON.stringify(staticValue);
         }
@@ -6276,10 +6304,10 @@ function getBindingAttr(el, name, getStatic) {
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
 function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
+    var val;
     if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
+        var list = el.attrsList;
+        for (var i = 0, l = list.length; i < l; i++) {
             if (list[i].name === name) {
                 list.splice(i, 1);
                 break;
@@ -6292,9 +6320,9 @@ function getAndRemoveAttr(el, name, removeFromMap) {
     return val;
 }
 function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
+    var list = el.attrsList;
+    for (var i = 0, l = list.length; i < l; i++) {
+        var attr = list[i];
         if (name.test(attr.name)) {
             list.splice(i, 1);
             return attr;
@@ -6318,35 +6346,35 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
+    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+    var baseValueExpression = '$$v';
+    var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
+            "(typeof " + baseValueExpression + " === 'string'" +
+                ("? " + baseValueExpression + ".trim()") +
+                (": " + baseValueExpression + ")");
     }
     if (number) {
-        valueExpression = `_n(${valueExpression})`;
+        valueExpression = "_n(" + valueExpression + ")";
     }
-    const assignment = genAssignmentCode(value, valueExpression);
+    var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: `(${value})`,
+        value: "(" + value + ")",
         expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
+        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
     };
 }
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
 function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
+    var res = parseModel(value);
     if (res.key === null) {
-        return `${value}=${assignment}`;
+        return value + "=" + assignment;
     }
     else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
     }
 }
 /**
@@ -6363,18 +6391,18 @@ function genAssignmentCode(value, assignment) {
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-let len, str, chr, index$1, expressionPos, expressionEndPos;
+var len, str, chr, index, expressionPos, expressionEndPos;
 function parseModel(val) {
     // Fix https://github.com/vuejs/vue/pull/7730
     // allow v-model="obj.val " (trailing whitespace)
     val = val.trim();
     len = val.length;
     if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index$1 = val.lastIndexOf('.');
-        if (index$1 > -1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
             return {
-                exp: val.slice(0, index$1),
-                key: '"' + val.slice(index$1 + 1) + '"',
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
             };
         }
         else {
@@ -6385,7 +6413,7 @@ function parseModel(val) {
         }
     }
     str = val;
-    index$1 = expressionPos = expressionEndPos = 0;
+    index = expressionPos = expressionEndPos = 0;
     while (!eof()) {
         chr = next();
         /* istanbul ignore if */
@@ -6402,17 +6430,17 @@ function parseModel(val) {
     };
 }
 function next() {
-    return str.charCodeAt(++index$1);
+    return str.charCodeAt(++index);
 }
 function eof() {
-    return index$1 >= len;
+    return index >= len;
 }
 function isStringStart(chr) {
     return chr === 0x22 || chr === 0x27;
 }
 function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index$1;
+    var inBracket = 1;
+    expressionPos = index;
     while (!eof()) {
         chr = next();
         if (isStringStart(chr)) {
@@ -6424,13 +6452,13 @@ function parseBracket(chr) {
         if (chr === 0x5d)
             inBracket--;
         if (inBracket === 0) {
-            expressionEndPos = index$1;
+            expressionEndPos = index;
             break;
         }
     }
 }
 function parseString(chr) {
-    const stringQuote = chr;
+    var stringQuote = chr;
     while (!eof()) {
         chr = next();
         if (chr === stringQuote) {
@@ -6440,23 +6468,23 @@ function parseString(chr) {
 }
 
 /* @flow */
-let warn$1;
+var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model(el, dir, _warn) {
+var RANGE_TOKEN = '__r';
+var CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
     warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
     {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+            warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
     if (el.component) {
@@ -6482,8 +6510,8 @@ function model(el, dir, _warn) {
         return false;
     }
     else {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
+        warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
             "If you are working with contenteditable, it's recommended to " +
             'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
     }
@@ -6491,71 +6519,71 @@ function model(el, dir, _warn) {
     return true;
 }
 function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
         (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
+    addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
         'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
         '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
 }
 function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        ("return " + (number ? '_n(val)' : 'val') + "})");
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + genAssignmentCode(value, assignment);
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
+    var type = el.attrsMap.type;
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value_1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
     if (trim) {
-        valueExpression = `$event.target.value.trim()`;
+        valueExpression = "$event.target.value.trim()";
     }
     if (number) {
-        valueExpression = `_n(${valueExpression})`;
+        valueExpression = "_n(" + valueExpression + ")";
     }
-    let code = genAssignmentCode(value, valueExpression);
+    var code = genAssignmentCode(value, valueExpression);
     if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
+        code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', `(${value})`);
+    addProp(el, 'value', "(" + value + ")");
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -6571,8 +6599,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        var event_1 = isIE ? 'change' : 'input';
+        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6583,21 +6611,21 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-let target$1;
-function createOnceHandler$1(event, handler, capture) {
-    const _target = target$1; // save current target element in closure
+var target;
+function createOnceHandler(event, handler, capture) {
+    var _target = target; // save current target element in closure
     return function onceHandler() {
-        const res = handler.apply(null, arguments);
+        var res = handler.apply(null, arguments);
         if (res !== null) {
-            remove$2(event, onceHandler, capture, _target);
+            remove(event, onceHandler, capture, _target);
         }
     };
 }
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add$1(name, handler, capture, passive) {
+var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
     // happens because browsers fire microtask ticks between event propagation.
@@ -6605,17 +6633,17 @@ function add$1(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
+        var attachedTimestamp_1 = currentFlushTimestamp;
+        var original_1 = handler;
         //@ts-expect-error
-        handler = original._wrapper = function (e) {
+        handler = original_1._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
+                e.timeStamp >= attachedTimestamp_1 ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6624,14 +6652,14 @@ function add$1(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
+                return original_1.apply(this, arguments);
             }
         };
     }
-    target$1.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-function remove$2(name, handler, capture, _target) {
-    (_target || target$1).removeEventListener(name, 
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
     //@ts-expect-error
     handler._wrapper || handler, capture);
 }
@@ -6639,12 +6667,12 @@ function updateDOMListeners(oldVnode, vnode) {
     if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
         return;
     }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target = vnode.elm;
     normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
 }
 var events = {
     create: updateDOMListeners,
@@ -6652,15 +6680,15 @@ var events = {
 };
 
 /* @flow */
-let svgContainer;
+var svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
         return;
     }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
+    var key, cur;
+    var elm = vnode.elm;
+    var oldProps = oldVnode.data.domProps || {};
+    var props = vnode.data.domProps || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(props.__ob__)) {
         props = vnode.data.domProps = extend({}, props);
@@ -6691,7 +6719,7 @@ function updateDOMProps(oldVnode, vnode) {
             // non-string values will be stringified
             elm._value = cur;
             // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
+            var strCur = isUndef(cur) ? '' : String(cur);
             if (shouldUpdateValue(elm, strCur)) {
                 elm.value = strCur;
             }
@@ -6701,8 +6729,8 @@ function updateDOMProps(oldVnode, vnode) {
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
+            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+            var svg = svgContainer.firstChild;
             while (elm.firstChild) {
                 elm.removeChild(elm.firstChild);
             }
@@ -6736,7 +6764,7 @@ function shouldUpdateValue(elm, checkVal) {
 function isNotInFocusAndDirty(elm, checkVal) {
     // return true when textbox (.number and .trim) loses focus and its value is
     // not equal to the updated value
-    let notInFocus = true;
+    var notInFocus = true;
     // #6157
     // work around IE bug when accessing document.activeElement in an iframe
     try {
@@ -6746,8 +6774,8 @@ function isNotInFocusAndDirty(elm, checkVal) {
     return notInFocus && elm.value !== checkVal;
 }
 function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
+    var value = elm.value;
+    var modifiers = elm._vModifiers; // injected by v-model runtime
     if (isDef(modifiers)) {
         if (modifiers.number) {
             return toNumber(value) !== toNumber(newVal);
@@ -6764,13 +6792,13 @@ var domProps = {
 };
 
 /* @flow */
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
+var parseStyleText = cached(function (cssText) {
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
     cssText.split(listDelimiter).forEach(function (item) {
         if (item) {
-            const tmp = item.split(propertyDelimiter);
+            var tmp = item.split(propertyDelimiter);
             tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
         }
     });
@@ -6778,7 +6806,7 @@ const parseStyleText = cached(function (cssText) {
 });
 // merge static and dynamic style data on the same vnode
 function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
+    var style = normalizeStyleBinding(data.style);
     // static style is pre-processed into an object during compilation
     // and is always a fresh object, so it's safe to merge into it
     return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6798,10 +6826,10 @@ function normalizeStyleBinding(bindingStyle) {
  * so that parent component's style could override it
  */
 function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
+    var res = {};
+    var styleData;
     if (checkChild) {
-        let childNode = vnode;
+        var childNode = vnode;
         while (childNode.componentInstance) {
             childNode = childNode.componentInstance._vnode;
             if (childNode &&
@@ -6814,7 +6842,7 @@ function getStyle(vnode, checkChild) {
     if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
     }
-    let parentNode = vnode;
+    var parentNode = vnode;
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6824,9 +6852,9 @@ function getStyle(vnode, checkChild) {
 }
 
 /* @flow */
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
+var cssVarRE = /^--/;
+var importantRE = /\s*!important$/;
+var setProp = function (el, name, val) {
     /* istanbul ignore if */
     if (cssVarRE.test(name)) {
         el.style.setProperty(name, val);
@@ -6835,12 +6863,12 @@ const setProp = (el, name, val) => {
         el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
     }
     else {
-        const normalizedName = normalize(name);
+        var normalizedName = normalize(name);
         if (Array.isArray(val)) {
             // Support values array created by autoprefixer, e.g.
             // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
             // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
+            for (var i = 0, len = val.length; i < len; i++) {
                 el.style[normalizedName] = val[i];
             }
         }
@@ -6849,43 +6877,43 @@ const setProp = (el, name, val) => {
         }
     }
 };
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
+var vendorNames = ['Webkit', 'Moz', 'ms'];
+var emptyStyle;
+var normalize = cached(function (prop) {
     emptyStyle = emptyStyle || document.createElement('div').style;
     prop = camelize(prop);
     if (prop !== 'filter' && prop in emptyStyle) {
         return prop;
     }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
+    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (var i = 0; i < vendorNames.length; i++) {
+        var name_1 = vendorNames[i] + capName;
+        if (name_1 in emptyStyle) {
+            return name_1;
         }
     }
 });
 function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
     if (isUndef(data.staticStyle) &&
         isUndef(data.style) &&
         isUndef(oldData.staticStyle) &&
         isUndef(oldData.style)) {
         return;
     }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    var cur, name;
+    var el = vnode.elm;
+    var oldStaticStyle = oldData.staticStyle;
+    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
     // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
+    var oldStyle = oldStaticStyle || oldStyleBinding;
+    var style = normalizeStyleBinding(vnode.data.style) || {};
     // store normalized style under a different key for next diff
     // make sure to clone it if it's reactive, since the user likely wants
     // to mutate it.
     vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
+    var newStyle = getStyle(vnode, true);
     for (name in oldStyle) {
         if (isUndef(newStyle[name])) {
             setProp(el, name, '');
@@ -6899,13 +6927,13 @@ function updateStyle(oldVnode, vnode) {
         }
     }
 }
-var style = {
+var style$1 = {
     create: updateStyle,
     update: updateStyle,
 };
 
 /* @flow */
-const whitespaceRE = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6918,14 +6946,14 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
+        var cur = " " + (el.getAttribute('class') || '') + " ";
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -6943,7 +6971,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6953,8 +6981,8 @@ function removeClass(el, cls) {
         }
     }
     else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -6968,41 +6996,41 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def$$1) {
-    if (!def$$1) {
+function resolveTransition(def) {
+    if (!def) {
         return;
     }
     /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
-        const res = {};
-        if (def$$1.css !== false) {
-            extend(res, autoCssTransition(def$$1.name || 'v'));
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
         }
-        extend(res, def$$1);
+        extend(res, def);
         return res;
     }
-    else if (typeof def$$1 === 'string') {
-        return autoCssTransition(def$$1);
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
     }
 }
-const autoCssTransition = cached((name) => {
+var autoCssTransition = cached(function (name) {
     return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
     };
 });
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
 // Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
@@ -7019,19 +7047,19 @@ if (hasTransition) {
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
+var raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
+    : /* istanbul ignore next */ function (fn) { return fn(); };
 function nextFrame(fn) {
-    raf(() => {
+    raf(function () {
         // @ts-expect-error
         raf(fn);
     });
 }
 function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass(el, cls);
@@ -7039,47 +7067,47 @@ function addTransitionClass(el, cls) {
 }
 function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
-        remove(el._transitionClasses, cls);
+        remove$2(el._transitionClasses, cls);
     }
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    const onEnd = (e) => {
+    var onEnd = function (e) {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(() => {
+    setTimeout(function () {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-const transformRE = /\b(transform|all)(,|$)/;
+var transformRE = /\b(transform|all)(,|$)/;
 function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
+    var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
@@ -7109,12 +7137,12 @@ function getTransitionInfo(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
     };
 }
 function getTimeout(delays, durations) {
@@ -7122,7 +7150,7 @@ function getTimeout(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map((d, i) => {
+    return Math.max.apply(null, durations.map(function (d, i) {
         return toMs(d) + toMs(delays[i]);
     }));
 }
@@ -7136,13 +7164,13 @@ function toMs(s) {
 
 /* @flow */
 function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
+    var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    const data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7150,41 +7178,41 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
         checkDuration(explicitEnterDuration, 'enter', vnode);
     }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
             removeTransitionClass(el, toClass);
             removeTransitionClass(el, activeClass);
@@ -7203,9 +7231,9 @@ function enter(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -7219,7 +7247,7 @@ function enter(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass(el, startClass);
         addTransitionClass(el, activeClass);
-        nextFrame(() => {
+        nextFrame(function () {
             removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -7244,13 +7272,13 @@ function enter(vnode, toggleDisplay) {
     }
 }
 function leave(vnode, rm) {
-    const el = vnode.elm;
+    var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    const data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7258,14 +7286,14 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
         checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
-    const cb = (el._leaveCb = once(() => {
+    var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -7306,7 +7334,7 @@ function leave(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass(el, leaveClass);
             addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
+            nextFrame(function () {
                 removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -7331,11 +7359,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
+        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
     }
     else if (isNaN(val)) {
-        warn(`<transition> explicit ${name} duration is NaN - ` +
+        warn$2("<transition> explicit " + name + " duration is NaN - " +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7353,7 +7381,7 @@ function getHookArgumentsLength(fn) {
         return false;
     }
     // @ts-expect-error
-    const invokerFns = fn.fns;
+    var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -7372,7 +7400,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove(vnode, rm) {
+        remove: function (vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7385,13 +7413,13 @@ var transition = inBrowser
     }
     : {};
 
-var platformModules = [attrs, klass, events, domProps, style, transition];
+var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
 /* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-const modules = platformModules.concat(baseModules);
-const patch = createPatchFunction({ nodeOps, modules });
+var modules$1 = platformModules.concat(baseModules);
+var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -7400,20 +7428,20 @@ const patch = createPatchFunction({ nodeOps, modules });
 /* istanbul ignore if */
 if (isIE9) {
     // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
+    document.addEventListener('selectionchange', function () {
+        var el = document.activeElement;
         // @ts-expect-error
         if (el && el.vmodel) {
             trigger(el, 'input');
         }
     });
 }
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
+var directive = {
+    inserted: function (el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
+                mergeVNodeHook(vnode, 'postpatch', function () {
                     directive.componentUpdated(el, binding, vnode);
                 });
             }
@@ -7439,22 +7467,22 @@ const directive = {
             }
         }
     },
-    componentUpdated(el, binding, vnode) {
+    componentUpdated: function (el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+            var prevOptions_1 = el._vOptions;
+            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                var needReset = el.multiple
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
+                        hasNoMatchingOption(binding.value, curOptions_1);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7466,23 +7494,23 @@ function setSelected(el, binding, vm) {
     actuallySetSelected(el, binding, vm);
     /* istanbul ignore if */
     if (isIE || isEdge) {
-        setTimeout(() => {
+        setTimeout(function () {
             actuallySetSelected(el, binding, vm);
         }, 0);
     }
 }
 function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
+    var value = binding.value;
+    var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
+        warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
+                ("expects an Array value for its binding, but got " + Object.prototype.toString
                     .call(value)
-                    .slice(8, -1)}`, vm);
+                    .slice(8, -1)), vm);
         return;
     }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
+    var selected, option;
+    for (var i = 0, l = el.options.length; i < l; i++) {
         option = el.options[i];
         if (isMultiple) {
             selected = looseIndexOf(value, getValue(option)) > -1;
@@ -7504,7 +7532,7 @@ function actuallySetSelected(el, binding, vm) {
     }
 }
 function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
+    return options.every(function (o) { return !looseEqual(o, value); });
 }
 function getValue(option) {
     return '_value' in option ? option._value : option.value;
@@ -7520,7 +7548,7 @@ function onCompositionEnd(e) {
     trigger(e.target, 'input');
 }
 function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
+    var e = document.createEvent('HTMLEvents');
     e.initEvent(type, true, true);
     el.dispatchEvent(e);
 }
@@ -7534,14 +7562,15 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind(el, { value }, vnode) {
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
         vnode = locateNode(vnode);
-        const transition$$1 = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
+        var transition = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition$$1) {
+        if (value && transition) {
             vnode.data.show = true;
-            enter(vnode, () => {
+            enter(vnode, function () {
                 el.style.display = originalDisplay;
             });
         }
@@ -7549,21 +7578,22 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update(el, { value, oldValue }, vnode) {
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
         /* istanbul ignore if */
         if (!value === !oldValue)
             return;
         vnode = locateNode(vnode);
-        const transition$$1 = vnode.data && vnode.data.transition;
-        if (transition$$1) {
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
             vnode.data.show = true;
             if (value) {
-                enter(vnode, () => {
+                enter(vnode, function () {
                     el.style.display = el.__vOriginalDisplay;
                 });
             }
             else {
-                leave(vnode, () => {
+                leave(vnode, function () {
                     el.style.display = 'none';
                 });
             }
@@ -7572,7 +7602,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7581,11 +7611,11 @@ var show = {
 
 var platformDirectives = {
     model: directive,
-    show,
+    show: show,
 };
 
 /* @flow */
-const transitionProps = {
+var transitionProps = {
     name: String,
     appear: Boolean,
     css: Boolean,
@@ -7605,7 +7635,7 @@ const transitionProps = {
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
 function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
+    var compOptions = vnode && vnode.componentOptions;
     if (compOptions && compOptions.Ctor.options.abstract) {
         return getRealChild(getFirstComponentChild(compOptions.children));
     }
@@ -7614,16 +7644,16 @@ function getRealChild(vnode) {
     }
 }
 function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
+    var data = {};
+    var options = comp.$options;
     // props
-    for (const key in options.propsData) {
+    for (var key in options.propsData) {
         data[key] = comp[key];
     }
     // events.
     // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
+    var listeners = options._parentListeners;
+    for (var key in listeners) {
         data[camelize(key)] = listeners[key];
     }
     return data;
@@ -7646,14 +7676,15 @@ function hasParentTransition(vnode) {
 function isSameChild(child, oldChild) {
     return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
+var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
+var isVShowDirective = function (d) { return d.name === 'show'; };
 var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render(h) {
-        let children = this.$slots.default;
+    render: function (h) {
+        var _this = this;
+        var children = this.$slots.default;
         if (!children) {
             return;
         }
@@ -7665,17 +7696,17 @@ var Transition = {
         }
         // warn multiple elements
         if (children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
+            warn$2('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
-        const mode = this.mode;
+        var mode = this.mode;
         // warn invalid mode
         if (mode &&
             mode !== 'in-out' &&
             mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
+            warn$2('invalid <transition> mode: ' + mode, this.$parent);
         }
-        const rawChild = children[0];
+        var rawChild = children[0];
         // if this is a component root node and the component's
         // parent container node also has transition, skip.
         if (hasParentTransition(this.$vnode)) {
@@ -7683,7 +7714,7 @@ var Transition = {
         }
         // apply transition data to child
         // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
+        var child = getRealChild(rawChild);
         /* istanbul ignore if */
         if (!child) {
             return rawChild;
@@ -7694,7 +7725,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        const id = `__transition-${this._uid}-`;
+        var id = "__transition-" + this._uid + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7705,9 +7736,9 @@ var Transition = {
                         ? child.key
                         : id + child.key
                     : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
+        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        var oldRawChild = this._vnode;
+        var oldChild = getRealChild(oldRawChild);
         // mark v-show
         // so that the transition module can hand over the control to the directive
         if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7722,14 +7753,14 @@ var Transition = {
                 oldChild.componentInstance._vnode.isComment)) {
             // replace old child transition data with fresh one
             // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
+            var oldData = (oldChild.data.transition = extend({}, data));
             // handle transition mode
             if (mode === 'out-in') {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
+                mergeVNodeHook(oldData, 'afterLeave', function () {
+                    _this._leaving = false;
+                    _this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7737,14 +7768,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
+                var delayedLeave_1;
+                var performLeave = function () {
+                    delayedLeave_1();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
+                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                    delayedLeave_1 = leave;
                 });
             }
         }
@@ -7753,36 +7784,37 @@ var Transition = {
 };
 
 // Provides transition support for list items.
-const props = extend({
+var props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
 // @ts-ignore
 delete props.mode;
 var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
+    props: props,
+    beforeMount: function () {
+        var _this = this;
+        var update = this._update;
+        this._update = function (vnode, hydrating) {
+            var restoreActiveInstance = setActiveInstance(_this);
             // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
+            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this._vnode = this.kept;
+            _this._vnode = _this.kept;
             restoreActiveInstance();
-            update.call(this, vnode, hydrating);
+            update.call(_this, vnode, hydrating);
         };
     },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || 'span';
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
+    render: function (h) {
+        var tag = this.tag || this.$vnode.data.tag || 'span';
+        var map = Object.create(null);
+        var prevChildren = (this.prevChildren = this.children);
+        var rawChildren = this.$slots.default || [];
+        var children = (this.children = []);
+        var transitionData = extractTransitionData(this);
+        for (var i = 0; i < rawChildren.length; i++) {
+            var c = rawChildren[i];
             if (c.tag) {
                 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
                     children.push(c);
@@ -7790,19 +7822,19 @@ var TransitionGroup = {
                     (c.data || (c.data = {})).transition = transitionData;
                 }
                 else {
-                    const opts = c.componentOptions;
-                    const name = opts
+                    var opts = c.componentOptions;
+                    var name_1 = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn(`<transition-group> children must be keyed: <${name}>`);
+                    warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
                 }
             }
         }
         if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
+            var kept = [];
+            var removed = [];
+            for (var i = 0; i < prevChildren.length; i++) {
+                var c = prevChildren[i];
                 c.data.transition = transitionData;
                 // @ts-ignore
                 c.data.pos = c.elm.getBoundingClientRect();
@@ -7819,9 +7851,9 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || 'v') + '-move';
+    updated: function () {
+        var children = this.prevChildren;
+        var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -7834,28 +7866,28 @@ var TransitionGroup = {
         // assign to this to avoid being removed in tree-shaking
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
+        children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
+                var el_1 = c.elm;
+                var s = el_1.style;
+                addTransitionClass(el_1, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
+                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                    if (e && e.target !== el_1) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
+                        el_1.removeEventListener(transitionEndEvent, cb);
+                        el_1._moveCb = null;
+                        removeTransitionClass(el_1, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove(el, moveClass) {
+        hasMove: function (el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -7869,16 +7901,16 @@ var TransitionGroup = {
             // transition at this very moment, we make a clone of it and remove
             // all other transition classes applied to ensure only the move class
             // is applied.
-            const clone = el.cloneNode();
+            var clone = el.cloneNode();
             if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
+                el._transitionClasses.forEach(function (cls) {
                     removeClass(clone, cls);
                 });
             }
             addClass(clone, moveClass);
             clone.style.display = 'none';
             this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
+            var info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
             return (this._hasMove = info.hasTransform);
         },
@@ -7904,24 +7936,24 @@ function recordPosition(c) {
 }
 function applyTranslation(c) {
     //@ts-ignore
-    const oldPos = c.data.pos;
+    var oldPos = c.data.pos;
     //@ts-ignore
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
+    var newPos = c.data.newPos;
+    var dx = oldPos.left - newPos.left;
+    var dy = oldPos.top - newPos.top;
     if (dx || dy) {
         //@ts-ignore
         c.data.moved = true;
         //@ts-ignore
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        var s = c.elm.style;
+        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
         s.transitionDuration = '0s';
     }
 }
 
 var platformComponents = {
-    Transition,
-    TransitionGroup,
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
 };
 
 // install platform specific utils
@@ -7943,7 +7975,7 @@ Vue.prototype.$mount = function (el, hydrating) {
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-    setTimeout(() => {
+    setTimeout(function () {
         if (config.devtools) {
             if (devtools) {
                 devtools.emit('init', Vue);
@@ -7957,31 +7989,31 @@ if (inBrowser) {
         if (config.productionTip !== false &&
             typeof console !== 'undefined') {
             // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
+            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                "Make sure to turn on production mode when deploying for production.\n" +
+                "See more tips at https://vuejs.org/guide/deployment.html");
         }
     }, 0);
 }
 
 /* @flow */
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+var buildRegex = cached(function (delimiters) {
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
     return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
 function parseText(text, delimiters) {
     //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
     if (!tagRE.test(text)) {
         return;
     }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
+    var tokens = [];
+    var rawTokens = [];
+    var lastIndex = (tagRE.lastIndex = 0);
+    var match, index, tokenValue;
     while ((match = tagRE.exec(text))) {
         index = match.index;
         // push text token
@@ -7990,8 +8022,8 @@ function parseText(text, delimiters) {
             tokens.push(JSON.stringify(tokenValue));
         }
         // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
+        var exp = parseFilters(match[1].trim());
+        tokens.push("_s(" + exp + ")");
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8006,13 +8038,13 @@ function parseText(text, delimiters) {
 }
 
 /* @flow */
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
+function transformNode$1(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticClass = getAndRemoveAttr(el, 'class');
     if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
+        var res = parseText(staticClass, options.delimiters);
         if (res) {
-            warn(`class="${staticClass}": ` +
+            warn("class=\"" + staticClass + "\": " +
                 'Interpolation inside attributes has been removed. ' +
                 'Use v-bind or the colon shorthand instead. For example, ' +
                 'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
@@ -8021,37 +8053,37 @@ function transformNode(el, options) {
     if (staticClass) {
         el.staticClass = JSON.stringify(staticClass);
     }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
     if (classBinding) {
         el.classBinding = classBinding;
     }
 }
-function genData(el) {
-    let data = '';
+function genData$2(el) {
+    var data = '';
     if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
+        data += "staticClass:" + el.staticClass + ",";
     }
     if (el.classBinding) {
-        data += `class:${el.classBinding},`;
+        data += "class:" + el.classBinding + ",";
     }
     return data;
 }
-var klass$1 = {
+var klass = {
     staticKeys: ['staticClass'],
-    transformNode,
-    genData,
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
 /* @flow */
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
+function transformNode(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
         /* istanbul ignore if */
         {
-            const res = parseText(staticStyle, options.delimiters);
+            var res = parseText(staticStyle, options.delimiters);
             if (res) {
-                warn(`style="${staticStyle}": ` +
+                warn("style=\"" + staticStyle + "\": " +
                     'Interpolation inside attributes has been removed. ' +
                     'Use v-bind or the colon shorthand instead. For example, ' +
                     'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
@@ -8059,386 +8091,36 @@ function transformNode$1(el, options) {
         }
         el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
     }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
     if (styleBinding) {
         el.styleBinding = styleBinding;
     }
 }
 function genData$1(el) {
-    let data = '';
+    var data = '';
     if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
+        data += "staticStyle:" + el.staticStyle + ",";
     }
     if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
+        data += "style:(" + el.styleBinding + "),";
     }
     return data;
 }
-var style$1 = {
+var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
+    transformNode: transformNode,
     genData: genData$1,
 };
 
-/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-(function(root) {
-
-	// Detect free variables `exports`.
-	var freeExports = typeof exports == 'object' && exports;
-
-	// Detect free variable `module`.
-	var freeModule = typeof module == 'object' && module &&
-		module.exports == freeExports && module;
-
-	// Detect free variable `global`, from Node.js or Browserified code,
-	// and use it as `root`.
-	var freeGlobal = typeof global == 'object' && global;
-	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-		root = freeGlobal;
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	// All astral symbols.
-	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-	// All ASCII symbols (not just printable ASCII) except those listed in the
-	// first column of the overrides table.
-	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-	// code points listed in the first column of the overrides table on
-	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-	var regexEscape = /["&'<>`]/g;
-	var escapeMap = {
-		'"': '&quot;',
-		'&': '&amp;',
-		'\'': '&#x27;',
-		'<': '&lt;',
-		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-		// following is not strictly necessary unless it’s part of a tag or an
-		// unquoted attribute value. We’re only escaping it to support those
-		// situations, and for XML support.
-		'>': '&gt;',
-		// In Internet Explorer ≤ 8, the backtick character can be used
-		// to break out of (un)quoted attribute values or HTML comments.
-		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-		// http://html5sec.org/#133.
-		'`': '&#x60;'
-	};
-
-	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-	/*--------------------------------------------------------------------------*/
-
-	var stringFromCharCode = String.fromCharCode;
-
-	var object = {};
-	var hasOwnProperty = object.hasOwnProperty;
-	var has = function(object, propertyName) {
-		return hasOwnProperty.call(object, propertyName);
-	};
-
-	var contains = function(array, value) {
-		var index = -1;
-		var length = array.length;
-		while (++index < length) {
-			if (array[index] == value) {
-				return true;
-			}
-		}
-		return false;
-	};
-
-	var merge = function(options, defaults) {
-		if (!options) {
-			return defaults;
-		}
-		var result = {};
-		var key;
-		for (key in defaults) {
-			// A `hasOwnProperty` check is not needed here, since only recognized
-			// option names are used anyway. Any others are ignored.
-			result[key] = has(options, key) ? options[key] : defaults[key];
-		}
-		return result;
-	};
-
-	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-	var codePointToSymbol = function(codePoint, strict) {
-		var output = '';
-		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-			// See issue #4:
-			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-			// REPLACEMENT CHARACTER.”
-			if (strict) {
-				parseError('character reference outside the permissible Unicode range');
-			}
-			return '\uFFFD';
-		}
-		if (has(decodeMapNumeric, codePoint)) {
-			if (strict) {
-				parseError('disallowed character reference');
-			}
-			return decodeMapNumeric[codePoint];
-		}
-		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-			parseError('disallowed character reference');
-		}
-		if (codePoint > 0xFFFF) {
-			codePoint -= 0x10000;
-			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-			codePoint = 0xDC00 | codePoint & 0x3FF;
-		}
-		output += stringFromCharCode(codePoint);
-		return output;
-	};
-
-	var hexEscape = function(codePoint) {
-		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-	};
-
-	var decEscape = function(codePoint) {
-		return '&#' + codePoint + ';';
-	};
-
-	var parseError = function(message) {
-		throw Error('Parse error: ' + message);
-	};
-
-	/*--------------------------------------------------------------------------*/
-
-	var encode = function(string, options) {
-		options = merge(options, encode.options);
-		var strict = options.strict;
-		if (strict && regexInvalidRawCodePoint.test(string)) {
-			parseError('forbidden code point');
-		}
-		var encodeEverything = options.encodeEverything;
-		var useNamedReferences = options.useNamedReferences;
-		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-		var escapeBmpSymbol = function(symbol) {
-			return escapeCodePoint(symbol.charCodeAt(0));
-		};
-
-		if (encodeEverything) {
-			// Encode ASCII symbols.
-			string = string.replace(regexAsciiWhitelist, function(symbol) {
-				// Use named references if requested & possible.
-				if (useNamedReferences && has(encodeMap, symbol)) {
-					return '&' + encodeMap[symbol] + ';';
-				}
-				return escapeBmpSymbol(symbol);
-			});
-			// Shorten a few escapes that represent two symbols, of which at least one
-			// is within the ASCII range.
-			if (useNamedReferences) {
-				string = string
-					.replace(/&gt;\u20D2/g, '&nvgt;')
-					.replace(/&lt;\u20D2/g, '&nvlt;')
-					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-			}
-			// Encode non-ASCII symbols.
-			if (useNamedReferences) {
-				// Encode non-ASCII symbols that can be replaced with a named reference.
-				string = string.replace(regexEncodeNonAscii, function(string) {
-					// Note: there is no need to check `has(encodeMap, string)` here.
-					return '&' + encodeMap[string] + ';';
-				});
-			}
-			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-		} else if (useNamedReferences) {
-			// Apply named character references.
-			// Encode `<>"'&` using named character references.
-			if (!allowUnsafeSymbols) {
-				string = string.replace(regexEscape, function(string) {
-					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-				});
-			}
-			// Shorten escapes that represent two symbols, of which at least one is
-			// `<>"'&`.
-			string = string
-				.replace(/&gt;\u20D2/g, '&nvgt;')
-				.replace(/&lt;\u20D2/g, '&nvlt;');
-			// Encode non-ASCII symbols that can be replaced with a named reference.
-			string = string.replace(regexEncodeNonAscii, function(string) {
-				// Note: there is no need to check `has(encodeMap, string)` here.
-				return '&' + encodeMap[string] + ';';
-			});
-		} else if (!allowUnsafeSymbols) {
-			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-			// using named character references.
-			string = string.replace(regexEscape, escapeBmpSymbol);
-		}
-		return string
-			// Encode astral symbols.
-			.replace(regexAstralSymbols, function($0) {
-				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-				var high = $0.charCodeAt(0);
-				var low = $0.charCodeAt(1);
-				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-				return escapeCodePoint(codePoint);
-			})
-			// Encode any remaining BMP symbols that are not printable ASCII symbols
-			// using a hexadecimal escape.
-			.replace(regexBmpWhitelist, escapeBmpSymbol);
-	};
-	// Expose default options (so they can be overridden globally).
-	encode.options = {
-		'allowUnsafeSymbols': false,
-		'encodeEverything': false,
-		'strict': false,
-		'useNamedReferences': false,
-		'decimal' : false
-	};
-
-	var decode = function(html, options) {
-		options = merge(options, decode.options);
-		var strict = options.strict;
-		if (strict && regexInvalidEntity.test(html)) {
-			parseError('malformed character reference');
-		}
-		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-			var codePoint;
-			var semicolon;
-			var decDigits;
-			var hexDigits;
-			var reference;
-			var next;
-
-			if ($1) {
-				reference = $1;
-				// Note: there is no need to check `has(decodeMap, reference)`.
-				return decodeMap[reference];
-			}
-
-			if ($2) {
-				// Decode named character references without trailing `;`, e.g. `&amp`.
-				// This is only a parse error if it gets converted to `&`, or if it is
-				// followed by `=` in an attribute context.
-				reference = $2;
-				next = $3;
-				if (next && options.isAttributeValue) {
-					if (strict && next == '=') {
-						parseError('`&` did not start a character reference');
-					}
-					return $0;
-				} else {
-					if (strict) {
-						parseError(
-							'named character reference was not terminated by a semicolon'
-						);
-					}
-					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-					return decodeMapLegacy[reference] + (next || '');
-				}
-			}
-
-			if ($4) {
-				// Decode decimal escapes, e.g. `&#119558;`.
-				decDigits = $4;
-				semicolon = $5;
-				if (strict && !semicolon) {
-					parseError('character reference was not terminated by a semicolon');
-				}
-				codePoint = parseInt(decDigits, 10);
-				return codePointToSymbol(codePoint, strict);
-			}
-
-			if ($6) {
-				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-				hexDigits = $6;
-				semicolon = $7;
-				if (strict && !semicolon) {
-					parseError('character reference was not terminated by a semicolon');
-				}
-				codePoint = parseInt(hexDigits, 16);
-				return codePointToSymbol(codePoint, strict);
-			}
-
-			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-			if (strict) {
-				parseError(
-					'named character reference was not terminated by a semicolon'
-				);
-			}
-			return $0;
-		});
-	};
-	// Expose default options (so they can be overridden globally).
-	decode.options = {
-		'isAttributeValue': false,
-		'strict': false
-	};
-
-	var escape = function(string) {
-		return string.replace(regexEscape, function($0) {
-			// Note: there is no need to check `has(escapeMap, $0)` here.
-			return escapeMap[$0];
-		});
-	};
-
-	/*--------------------------------------------------------------------------*/
-
-	var he = {
-		'version': '1.2.0',
-		'encode': encode,
-		'decode': decode,
-		'escape': escape,
-		'unescape': decode
-	};
-
-	// Some AMD build optimizers, like r.js, check for specific condition patterns
-	// like the following:
-	if (
-		typeof define == 'function' &&
-		typeof define.amd == 'object' &&
-		define.amd
-	) {
-		define(function() {
-			return he;
-		});
-	}	else if (freeExports && !freeExports.nodeType) {
-		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-			freeModule.exports = he;
-		} else { // in Narwhal or RingoJS v0.7.0-
-			for (var key in he) {
-				has(he, key) && (freeExports[key] = he[key]);
-			}
-		}
-	} else { // in Rhino or a web browser
-		root.he = he;
-	}
-
-}(undefined));
-
-var he = /*#__PURE__*/Object.freeze({
-
-});
-
 /* @flow */
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
     'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -8448,21 +8130,21 @@ const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,cap
  * Not type-checking this file because it's mostly vendor code.
  */
 // Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
+var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
+var startTagOpen = new RegExp("^<" + qnameCapture);
+var startTagClose = /^\s*(\/?)>/;
+var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
+var comment = /^<!\--/;
+var conditionalComment = /^<!\[/;
 // Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
+var isPlainTextElement = makeMap('script,style,textarea', true);
+var reCache = {};
+var decodingMap = {
     '&lt;': '<',
     '&gt;': '>',
     '&quot;': '"',
@@ -8471,72 +8153,74 @@ const decodingMap = {
     '&#9;': '\t',
     '&#39;': "'",
 };
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+var isIgnoreNewlineTag = makeMap('pre,textarea', true);
+var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+};
 function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, function (match) { return decodingMap[match]; });
 }
 function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag$$1 = options.isUnaryTag || no;
-    const canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
+    var stack = [];
+    var expectHTML = options.expectHTML;
+    var isUnaryTag = options.isUnaryTag || no;
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    var index = 0;
+    var last, lastTag;
+    var _loop_1 = function () {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
+            var textEnd = html.indexOf('<');
             if (textEnd === 0) {
                 // Comment:
                 if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
+                    var commentEnd = html.indexOf('-->');
                     if (commentEnd >= 0) {
                         if (options.shouldKeepComment) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        continue;
+                        return "continue";
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
                 if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
+                    var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        continue;
+                        return "continue";
                     }
                 }
                 // Doctype:
-                const doctypeMatch = html.match(doctype);
+                var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    continue;
+                    return "continue";
                 }
                 // End tag:
-                const endTagMatch = html.match(endTag);
+                var endTagMatch = html.match(endTag);
                 if (endTagMatch) {
-                    const curIndex = index;
+                    var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
+                    return "continue";
                 }
                 // Start tag:
-                const startTagMatch = parseStartTag();
+                var startTagMatch = parseStartTag();
                 if (startTagMatch) {
                     handleStartTag(startTagMatch);
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    continue;
+                    return "continue";
                 }
             }
-            let text, rest, next;
+            var text = void 0, rest = void 0, next = void 0;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8563,18 +8247,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+            var endTagLength_1 = 0;
+            var stackedTag_1 = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag_1] ||
+                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+            var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength_1 = endTag.length;
+                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -8584,18 +8268,23 @@ function parseHTML(html, options) {
             });
             index += html.length - rest.length;
             html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
+            parseEndTag(stackedTag_1, index - endTagLength_1, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                     start: index + html.length,
                 });
             }
-            break;
+            return "break";
         }
+    };
+    while (html) {
+        var state_1 = _loop_1();
+        if (state_1 === "break")
+            break;
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -8604,15 +8293,15 @@ function parseHTML(html, options) {
         html = html.substring(n);
     }
     function parseStartTag() {
-        const start = html.match(startTagOpen);
+        var start = html.match(startTagOpen);
         if (start) {
-            const match = {
+            var match = {
                 tagName: start[1],
                 attrs: [],
                 start: index,
             };
             advance(start[0].length);
-            let end, attr;
+            var end = void 0, attr = void 0;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8629,23 +8318,23 @@ function parseHTML(html, options) {
         }
     }
     function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
+        var tagName = match.tagName;
+        var unarySlash = match.unarySlash;
         if (expectHTML) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
             }
-            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                 parseEndTag(tagName);
             }
         }
-        const unary = isUnaryTag$$1(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+        var unary = isUnaryTag(tagName) || !!unarySlash;
+        var l = match.attrs.length;
+        var attrs = new Array(l);
+        for (var i = 0; i < l; i++) {
+            var args = match.attrs[i];
+            var value = args[3] || args[4] || args[5] || '';
+            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
                 ? options.shouldDecodeNewlinesForHref
                 : options.shouldDecodeNewlines;
             attrs[i] = {
@@ -8672,7 +8361,7 @@ function parseHTML(html, options) {
         }
     }
     function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
+        var pos, lowerCasedTagName;
         if (start == null)
             start = index;
         if (end == null)
@@ -8692,10 +8381,10 @@ function parseHTML(html, options) {
         }
         if (pos >= 0) {
             // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if (i > pos || !tagName &&
+            for (var i = stack.length - 1; i >= pos; i--) {
+                if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8725,39 +8414,40 @@ function parseHTML(html, options) {
 }
 
 /* @flow */
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE$1 = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(undefined);
-const emptySlotScopeToken = `_empty_`;
+var he = require('he');
+var onRE = /^@|^v-on:/;
+var dirRE = /^v-|^@|^:|^#/;
+var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+var stripParensRE = /^\(|\)$/g;
+var dynamicArgRE = /^\[.*\]$/;
+var argRE = /:(.*)$/;
+var bindRE = /^:|^\.|^v-bind:/;
+var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+var slotRE = /^v-slot(:|$)|^#/;
+var lineBreakRE = /[\r\n]/;
+var whitespaceRE = /[ \f\t\r\n]+/g;
+var invalidAttributeRE = /[\s"'<>\/=]/;
+var decodeHTMLCached = cached(he.decode);
+var emptySlotScopeToken = "_empty_";
 // configurable state
-let warn$2;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
+var warn;
+var delimiters;
+var transforms;
+var preTransforms;
+var postTransforms;
+var platformIsPreTag;
+var platformMustUseProp;
+var platformGetTagNamespace;
+var maybeComponent;
 function createASTElement(tag, attrs, parent) {
     return {
         type: 1,
-        tag,
+        tag: tag,
         attrsList: attrs,
         attrsMap: makeAttrsMap(attrs),
         rawAttrsMap: {},
-        parent,
+        parent: parent,
         children: [],
     };
 }
@@ -8765,28 +8455,28 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn$2 = options.warn || baseWarn;
+    warn = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+    var isReservedTag = options.isReservedTag || no;
+    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
     delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
+    var stack = [];
+    var preserveWhitespace = options.preserveWhitespace !== false;
+    var whitespaceOption = options.whitespace;
+    var root;
+    var currentParent;
+    var inVPre = false;
+    var inPre = false;
+    var warned = false;
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn$2(msg, range);
+            warn(msg, range);
         }
     }
     function closeElement(element) {
@@ -8807,9 +8497,9 @@ function parse(template, options) {
                 });
             }
             else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
+                warnOnce("Component template should contain exactly one root element. " +
+                    "If you are using v-if on multiple elements, " +
+                    "use v-else-if to chain them instead.", { start: element.start });
             }
         }
         if (currentParent && !element.forbidden) {
@@ -8821,8 +8511,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                    var name_1 = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -8830,7 +8520,7 @@ function parse(template, options) {
         }
         // final children cleanup
         // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
+        element.children = element.children.filter(function (c) { return !c.slotScope; });
         // remove trailing whitespace node again
         trimEndingWhitespace(element);
         // check pre state
@@ -8841,14 +8531,14 @@ function parse(template, options) {
             inPre = false;
         }
         // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
+        for (var i = 0; i < postTransforms.length; i++) {
             postTransforms[i](element, options);
         }
     }
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            let lastNode;
+            var lastNode = void 0;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8858,7 +8548,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8867,7 +8557,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn$2,
+        warn: warn,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8875,16 +8565,16 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
+        start: function (tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
             // handle IE svg bug
             /* istanbul ignore if */
             if (isIE && ns === 'svg') {
                 attrs = guardIESVGBug(attrs);
             }
-            let element = createASTElement(tag, attrs, currentParent);
+            var element = createASTElement(tag, attrs, currentParent);
             if (ns) {
                 element.ns = ns;
             }
@@ -8892,16 +8582,16 @@ function parse(template, options) {
                 if (options.outputSourceRange) {
                     element.start = start;
                     element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
                         return cumulated;
                     }, {});
                 }
-                attrs.forEach((attr) => {
+                attrs.forEach(function (attr) {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$2(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
+                        warn("Invalid dynamic argument expression: attribute names cannot contain " +
+                            "spaces, quotes, <, >, / or =.", {
+                            start: attr.start + attr.name.indexOf("["),
                             end: attr.start + attr.name.length,
                         });
                     }
@@ -8909,13 +8599,13 @@ function parse(template, options) {
             }
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
-                warn$2('Templates should only be responsible for mapping the state to the ' +
+                warn('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
+                        ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
+            for (var i = 0; i < preTransforms.length; i++) {
                 element = preTransforms[i](element, options) || element;
             }
             if (!inVPre) {
@@ -8950,8 +8640,8 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
+        end: function (tag, start, end) {
+            var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
@@ -8960,15 +8650,15 @@ function parse(template, options) {
             }
             closeElement(element);
         },
-        chars(text, start, end) {
+        chars: function (text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
+                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                            start: start,
                         });
                     }
                 }
@@ -8981,7 +8671,7 @@ function parse(template, options) {
                 currentParent.attrsMap.placeholder === text) {
                 return;
             }
-            const children = currentParent.children;
+            var children = currentParent.children;
             if (inPre || text.trim()) {
                 text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
             }
@@ -9005,16 +8695,16 @@ function parse(template, options) {
             if (text) {
                 if (!inPre && whitespaceOption === 'condense') {
                     // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE$1, ' ');
+                    text = text.replace(whitespaceRE, ' ');
                 }
-                let res;
-                let child;
+                var res = void 0;
+                var child = void 0;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
                         expression: res.expression,
                         tokens: res.tokens,
-                        text,
+                        text: text,
                     };
                 }
                 else if (text !== ' ' ||
@@ -9022,7 +8712,7 @@ function parse(template, options) {
                     children[children.length - 1].text !== ' ') {
                     child = {
                         type: 3,
-                        text,
+                        text: text,
                     };
                 }
                 if (child) {
@@ -9034,13 +8724,13 @@ function parse(template, options) {
                 }
             }
         },
-        comment(text, start, end) {
+        comment: function (text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
-                const child = {
+                var child = {
                     type: 3,
-                    text,
+                    text: text,
                     isComment: true,
                 };
                 if (options.outputSourceRange) {
@@ -9059,11 +8749,11 @@ function processPre(el) {
     }
 }
 function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
+    var list = el.attrsList;
+    var len = list.length;
     if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
+        var attrs = (el.attrs = new Array(len));
+        for (var i = 0; i < len; i++) {
             attrs[i] = {
                 name: list[i].name,
                 value: JSON.stringify(list[i].value),
@@ -9089,28 +8779,28 @@ function processElement(element, options) {
     processSlotContent(element);
     processSlotOutlet(element);
     processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
+    for (var i = 0; i < transforms.length; i++) {
         element = transforms[i](element, options) || element;
     }
     processAttrs(element);
     return element;
 }
 function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
+    var exp = getBindingAttr(el, 'key');
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn$2(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+                warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
+                var iterator = el.iterator2 || el.iterator1;
+                var parent_1 = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$2(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                    parent_1 &&
+                    parent_1.tag === 'transition-group') {
+                    warn("Do not use v-for index as key on <transition-group> children, " +
+                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
         }
@@ -9118,32 +8808,32 @@ function processKey(el) {
     }
 }
 function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
+    var ref = getBindingAttr(el, 'ref');
     if (ref) {
         el.ref = ref;
         el.refInFor = checkInFor(el);
     }
 }
 function processFor(el) {
-    let exp;
+    var exp;
     if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
+        var res = parseFor(exp);
         if (res) {
             extend(el, res);
         }
         else {
-            warn$2(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+            warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
 function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
+    var inMatch = exp.match(forAliasRE);
     if (!inMatch)
         return;
-    const res = {};
+    var res = {};
     res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
+    var alias = inMatch[1].trim().replace(stripParensRE, '');
+    var iteratorMatch = alias.match(forIteratorRE);
     if (iteratorMatch) {
         res.alias = alias.replace(forIteratorRE, '').trim();
         res.iterator1 = iteratorMatch[1].trim();
@@ -9157,7 +8847,7 @@ function parseFor(exp) {
     return res;
 }
 function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
+    var exp = getAndRemoveAttr(el, 'v-if');
     if (exp) {
         el.if = exp;
         addIfCondition(el, {
@@ -9169,14 +8859,14 @@ function processIf(el) {
         if (getAndRemoveAttr(el, 'v-else') != null) {
             el.else = true;
         }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        var elseif = getAndRemoveAttr(el, 'v-else-if');
         if (elseif) {
             el.elseif = elseif;
         }
     }
 }
 function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
+    var prev = findPrevElement(parent.children);
     if (prev && prev.if) {
         addIfCondition(prev, {
             exp: el.elseif,
@@ -9184,20 +8874,20 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn$2(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+        warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
-    let i = children.length;
+    var i = children.length;
     while (i--) {
         if (children[i].type === 1) {
             return children[i];
         }
         else {
             if (children[i].text !== ' ') {
-                warn$2(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
+                warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                    "will be ignored.", children[i]);
             }
             children.pop();
         }
@@ -9210,37 +8900,37 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    const once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
+    var once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
         el.once = true;
     }
 }
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
 function processSlotContent(el) {
-    let slotScope;
+    var slotScope;
     if (el.tag === 'template') {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn$2(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+            warn("the \"scope\" attribute for scoped slots have been deprecated and " +
+                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                "can also be used on plain elements in addition to <template> to " +
+                "denote scoped slots.", el.rawAttrsMap['scope'], true);
         }
         el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
     }
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$2(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+            warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+                "(v-for takes higher priority). Use a wrapper <template> for the " +
+                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
         el.slotScope = slotScope;
     }
     // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
+    var slotTarget = getBindingAttr(el, 'slot');
     if (slotTarget) {
         el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
         el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
@@ -9254,52 +8944,52 @@ function processSlotContent(el) {
     {
         if (el.tag === 'template') {
             // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn$2(`Unexpected mixed usage of different slot syntaxes.`, el);
+                        warn("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$2(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
+                        warn("<template v-slot> can only appear at the root level inside " +
+                            "the receiving component", el);
                     }
                 }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
+                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                el.slotTarget = name_2;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
             if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$2(`v-slot can only be used on components or <template>.`, slotBinding);
+                        warn("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$2(`Unexpected mixed usage of different slot syntaxes.`, el);
+                        warn("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
-                        warn$2(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
+                        warn("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
                 // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
+                var slots = el.scopedSlots || (el.scopedSlots = {});
+                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                slotContainer_1.slotTarget = name_3;
+                slotContainer_1.slotTargetDynamic = dynamic;
+                slotContainer_1.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer;
+                        c.parent = slotContainer_1;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -9309,34 +8999,34 @@ function processSlotContent(el) {
     }
 }
 function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
+    var name = binding.name.replace(slotRE, '');
     if (!name) {
         if (binding.name[0] !== '#') {
             name = 'default';
         }
         else {
-            warn$2(`v-slot shorthand syntax requires a slot name.`, binding);
+            warn("v-slot shorthand syntax requires a slot name.", binding);
         }
     }
     return dynamicArgRE.test(name)
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: `"${name}"`, dynamic: false };
+            { name: "\"" + name + "\"", dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn$2(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+            warn("`key` does not work on <slot> because slots are abstract outlets " +
+                "and can possibly expand into multiple elements. " +
+                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
         }
     }
 }
 function processComponent(el) {
-    let binding;
+    var binding;
     if ((binding = getBindingAttr(el, 'is'))) {
         el.component = binding;
     }
@@ -9345,8 +9035,8 @@ function processComponent(el) {
     }
 }
 function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    var list = el.attrsList;
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
     for (i = 0, l = list.length; i < l; i++) {
         name = rawName = list[i].name;
         value = list[i].value;
@@ -9368,7 +9058,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$2(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                    warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9380,16 +9070,16 @@ function processAttrs(el) {
                         name = camelize(name);
                     }
                     if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
+                        syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$2, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$2, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$2, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
                             );
                         }
                     }
@@ -9409,14 +9099,14 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
             }
             else {
                 // normal directives
                 name = name.replace(dirRE, '');
                 // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
+                var argMatch = name.match(argRE);
+                var arg = argMatch && argMatch[1];
                 isDynamic = false;
                 if (arg) {
                     name = name.slice(0, -(arg.length + 1));
@@ -9434,9 +9124,9 @@ function processAttrs(el) {
         else {
             // literal attribute
             {
-                const res = parseText(value, delimiters);
+                var res = parseText(value, delimiters);
                 if (res) {
-                    warn$2(`${name}="${value}": ` +
+                    warn(name + "=\"" + value + "\": " +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9454,7 +9144,7 @@ function processAttrs(el) {
     }
 }
 function checkInFor(el) {
-    let parent = el;
+    var parent = el;
     while (parent) {
         if (parent.for !== undefined) {
             return true;
@@ -9464,22 +9154,22 @@ function checkInFor(el) {
     return false;
 }
 function parseModifiers(name) {
-    const match = name.match(modifierRE);
+    var match = name.match(modifierRE);
     if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
+        var ret_1 = {};
+        match.forEach(function (m) {
+            ret_1[m.slice(1)] = true;
         });
-        return ret;
+        return ret_1;
     }
 }
 function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
+    var map = {};
+    for (var i = 0, l = attrs.length; i < l; i++) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9494,13 +9184,13 @@ function isForbiddenTag(el) {
         (el.tag === 'script' &&
             (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
+var ieNSBug = /^xmlns:NS\d+/;
+var ieNSPrefix = /^NS\d+:/;
 /* istanbul ignore next */
 function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
+    var res = [];
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
         if (!ieNSBug.test(attr.name)) {
             attr.name = attr.name.replace(ieNSPrefix, '');
             res.push(attr);
@@ -9509,14 +9199,14 @@ function guardIESVGBug(attrs) {
     return res;
 }
 function checkForAliasModel(el, value) {
-    let _el = el;
+    var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$2(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+            warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+                "You are binding v-model directly to a v-for iteration alias. " +
+                "This will not be able to modify the v-for source array because " +
+                "writing to the alias is like modifying a function local variable. " +
+                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
         }
         _el = _el.parent;
     }
@@ -9525,45 +9215,45 @@ function checkForAliasModel(el, value) {
 /* @flow */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
-        const map = el.attrsMap;
+        var map = el.attrsMap;
         if (!map['v-model']) {
             return;
         }
-        let typeBinding;
+        var typeBinding = void 0;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
+            typeBinding = "(" + map['v-bind'] + ").type";
         }
         if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
-            const branch0 = cloneASTElement(el);
+            var branch0 = cloneASTElement(el);
             // process for on the main node
             processFor(branch0);
             addRawAttr(branch0, 'type', 'checkbox');
             processElement(branch0, options);
             branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
             addIfCondition(branch0, {
                 exp: branch0.if,
                 block: branch0,
             });
             // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
+            var branch1 = cloneASTElement(el);
             getAndRemoveAttr(branch1, 'v-for', true);
             addRawAttr(branch1, 'type', 'radio');
             processElement(branch1, options);
             addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
                 block: branch1,
             });
             // 3. other
-            const branch2 = cloneASTElement(el);
+            var branch2 = cloneASTElement(el);
             getAndRemoveAttr(branch2, 'v-for', true);
             addRawAttr(branch2, ':type', typeBinding);
             processElement(branch2, options);
@@ -9584,51 +9274,51 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model$1 = {
-    preTransformNode,
+var model = {
+    preTransformNode: preTransformNode,
 };
 
-var modules$1 = [klass$1, style$1, model$1];
+var modules = [klass, style, model];
 
 /* @flow */
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
 /* @flow */
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
     }
 }
 
-var directives$1 = {
-    model,
-    text,
-    html,
+var directives = {
+    model: model$1,
+    text: text,
+    html: html,
 };
 
 /* @flow */
-const baseOptions = {
+var baseOptions = {
     expectHTML: true,
-    modules: modules$1,
-    directives: directives$1,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
+    modules: modules,
+    directives: directives,
+    isPreTag: isPreTag,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
     // @ts-ignore
-    staticKeys: genStaticKeys(modules$1),
+    staticKeys: genStaticKeys$1(modules),
 };
 
 /* @flow */
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys$1);
+var isStaticKey;
+var isPlatformReservedTag;
+var genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -9646,15 +9336,15 @@ function optimize(root, options) {
     isStaticKey = genStaticKeysCached(options.staticKeys || '');
     isPlatformReservedTag = options.isReservedTag || no;
     // first pass: mark all non-static nodes.
-    markStatic$1(root);
+    markStatic(root);
     // second pass: mark static roots.
     markStaticRoots(root, false);
 }
-function genStaticKeys$1(keys) {
+function genStaticKeys(keys) {
     return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
         (keys ? ',' + keys : ''));
 }
-function markStatic$1(node) {
+function markStatic(node) {
     node.static = isStatic(node);
     if (node.type === 1) {
         // do not make component slot content static. this avoids
@@ -9665,17 +9355,17 @@ function markStatic$1(node) {
             node.attrsMap['inline-template'] == null) {
             return;
         }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic$1(child);
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            markStatic(child);
             if (!child.static) {
                 node.static = false;
             }
         }
         if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic$1(block);
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
+                markStatic(block);
                 if (!block.static) {
                     node.static = false;
                 }
@@ -9701,12 +9391,12 @@ function markStaticRoots(node, isInFor) {
             node.staticRoot = false;
         }
         if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
+            for (var i = 0, l = node.children.length; i < l; i++) {
                 markStaticRoots(node.children[i], isInFor || !!node.for);
             }
         }
         if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
                 markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
@@ -9744,11 +9434,11 @@ function isDirectChildOfTemplateFor(node) {
 }
 
 /* @flow */
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+var fnInvokeRE = /\([^)]*?\);*$/;
+var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
 // KeyboardEvent.keyCode aliases
-const keyCodes = {
+var keyCodes = {
     esc: 27,
     tab: 9,
     enter: 13,
@@ -9760,7 +9450,7 @@ const keyCodes = {
     delete: [8, 46],
 };
 // KeyboardEvent.key aliases
-const keyNames = {
+var keyNames = {
     // #7880: IE11 and Edge use `Esc` for Escape key name.
     esc: ['Esc', 'Escape'],
     tab: 'Tab',
@@ -9778,36 +9468,36 @@ const keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
+var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
+    self: genGuard("$event.target !== $event.currentTarget"),
+    ctrl: genGuard("!$event.ctrlKey"),
+    shift: genGuard("!$event.shiftKey"),
+    alt: genGuard("!$event.altKey"),
+    meta: genGuard("!$event.metaKey"),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2"),
 };
 function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
+    var prefix = isNative ? 'nativeOn:' : 'on:';
+    var staticHandlers = "";
+    var dynamicHandlers = "";
+    for (var name_1 in events) {
+        var handlerCode = genHandler(events[name_1]);
         //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
+        if (events[name_1] && events[name_1].dynamic) {
+            dynamicHandlers += name_1 + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += `"${name}":${handlerCode},`;
+            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
     if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
     }
     else {
         return prefix + staticHandlers;
@@ -9818,22 +9508,22 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
     }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    var isMethodPath = simplePathRE.test(handler.value);
+    var isFunctionExpression = fnExpRE.test(handler.value);
+    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
     if (!handler.modifiers) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
     }
     else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
+        var code = '';
+        var genModifierCode = '';
+        var keys = [];
+        var _loop_1 = function (key) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -9842,15 +9532,18 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                const modifiers = handler.modifiers;
+                var modifiers_1 = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
+        };
+        for (var key in handler.modifiers) {
+            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -9859,14 +9552,14 @@ function genHandler(handler) {
         if (genModifierCode) {
             code += genModifierCode;
         }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
+        var handlerCode = isMethodPath
+            ? "return " + handler.value + ".apply(null, arguments)"
             : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
+                ? "return (" + handler.value + ").apply(null, arguments)"
                 : isFunctionInvocation
-                    ? `return ${handler.value}`
+                    ? "return " + handler.value
                     : handler.value;
-        return `function($event){${code}${handlerCode}}`;
+        return "function($event){" + code + handlerCode + "}";
     }
 }
 function genKeyFilter(keys) {
@@ -9874,72 +9567,75 @@ function genKeyFilter(keys) {
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
+    "if(!$event.type.indexOf('key')&&" +
+        (keys.map(genFilterCode).join('&&') + ")return null;"));
 }
 function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
+    var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
+        return "$event.keyCode!==" + keyVal;
     }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+    var keyCode = keyCodes[key];
+    var keyName = keyNames[key];
+    return ("_k($event.keyCode," +
+        (JSON.stringify(key) + ",") +
+        (JSON.stringify(keyCode) + ",") +
+        "$event.key," +
+        ("" + JSON.stringify(keyName)) +
+        ")");
 }
 
 /* @flow */
 function on(el, dir) {
     if (dir.modifiers) {
-        warn(`v-on without argument does not support modifiers.`);
+        warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
 /* @flow */
-function bind$1(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+function bind(el, dir) {
+    el.wrapData = function (code) {
+        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
 /* @flow */
 var baseDirectives = {
-    on,
-    bind: bind$1,
+    on: on,
+    bind: bind,
     cloak: noop,
 };
 
 /* @flow */
-class CodegenState {
-    constructor(options) {
+var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
         this.options = options;
         this.warn = options.warn || baseWarn;
         //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
         this.transforms = pluckModuleFunction(options.modules, 'transformCode');
         this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
         this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        var isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = function (el) {
+            return !!el.component || !isReservedTag(el.tag);
+        };
         this.onceId = 0;
         this.staticRenderFns = [];
         this.pre = false;
     }
-}
+    return CodegenState;
+}());
 function generate(ast, options) {
-    const state = new CodegenState(options);
+    var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
+    var code = ast
         ? ast.tag === 'script'
             ? 'null'
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: `with(this){return ${code}}`,
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -9967,22 +9663,22 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        let code;
+        var code = void 0;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            let data;
+            var data = void 0;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData$2(el, state);
+                data = genData(el, state);
             }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
+            var children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+            ) + (children ? "," + children : '' // children
+            ) + ")";
         }
         // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
+        for (var i = 0; i < state.transforms.length; i++) {
             code = state.transforms[i](el, code);
         }
         return code;
@@ -9994,13 +9690,13 @@ function genStatic(el, state) {
     // Some elements (templates) need to behave differently inside of a v-pre
     // node.  All pre nodes are static roots, so we can use this as a location to
     // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
+    var originalPreState = state.pre;
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
     state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
 }
 // v-once
 function genOnce(el, state) {
@@ -10009,20 +9705,20 @@ function genOnce(el, state) {
         return genIf(el, state);
     }
     else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
+        var key = '';
+        var parent_1 = el.parent;
+        while (parent_1) {
+            if (parent_1.for) {
+                key = parent_1.key;
                 break;
             }
-            parent = parent.parent;
+            parent_1 = parent_1.parent;
         }
         if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
     }
     else {
         return genStatic(el, state);
@@ -10036,12 +9732,12 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     if (!conditions.length) {
         return altEmpty || '_e()';
     }
-    const condition = conditions.shift();
+    var condition = conditions.shift();
     if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
     }
     else {
-        return `${genTernaryExp(condition.block)}`;
+        return "" + genTernaryExp(condition.block);
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -10053,87 +9749,87 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
 }
 function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    var exp = el.for;
+    var alias = el.alias;
+    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+            "v-for should have explicit keys. " +
+            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
+    return ((altHelper || '_l') + "((" + exp + ")," +
+        ("function(" + alias + iterator1 + iterator2 + "){") +
+        ("return " + (altGen || genElement)(el, state)) +
         '})');
 }
-function genData$2(el, state) {
-    let data = '{';
+function genData(el, state) {
+    var data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
+    var dirs = genDirectives(el, state);
     if (dirs)
         data += dirs + ',';
     // key
     if (el.key) {
-        data += `key:${el.key},`;
+        data += "key:" + el.key + ",";
     }
     // ref
     if (el.ref) {
-        data += `ref:${el.ref},`;
+        data += "ref:" + el.ref + ",";
     }
     if (el.refInFor) {
-        data += `refInFor:true,`;
+        data += "refInFor:true,";
     }
     // pre
     if (el.pre) {
-        data += `pre:true,`;
+        data += "pre:true,";
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += `tag:"${el.tag}",`;
+        data += "tag:\"" + el.tag + "\",";
     }
     // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
+    for (var i = 0; i < state.dataGenFns.length; i++) {
         data += state.dataGenFns[i](el);
     }
     // attributes
     if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
+        data += "attrs:" + genProps(el.attrs) + ",";
     }
     // DOM props
     if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
+        data += "domProps:" + genProps(el.props) + ",";
     }
     // event handlers
     if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
+        data += genHandlers(el.events, false) + ",";
     }
     if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
+        data += genHandlers(el.nativeEvents, true) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
+        data += "slot:" + el.slotTarget + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+        data += genScopedSlots(el, el.scopedSlots, state) + ",";
     }
     // component v-model
     if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
+        var inlineTemplate = genInlineTemplate(el, state);
         if (inlineTemplate) {
-            data += `${inlineTemplate},`;
+            data += inlineTemplate + ",";
         }
     }
     data = data.replace(/,$/, '') + '}';
@@ -10141,7 +9837,7 @@ function genData$2(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -10154,16 +9850,16 @@ function genData$2(el, state) {
     return data;
 }
 function genDirectives(el, state) {
-    const dirs = el.directives;
+    var dirs = el.directives;
     if (!dirs)
         return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
+    var res = 'directives:[';
+    var hasRuntime = false;
+    var i, l, dir, needRuntime;
     for (i = 0, l = dirs.length; i < l; i++) {
         dir = dirs[i];
         needRuntime = true;
-        const gen = state.directives[dir.name];
+        var gen = state.directives[dir.name];
         if (gen) {
             // compile-time directive that manipulates AST.
             // returns true if it also needs a runtime counterpart.
@@ -10171,9 +9867,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -10181,15 +9877,15 @@ function genDirectives(el, state) {
     }
 }
 function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
+    var ast = el.children[0];
+    if ((el.children.length !== 1 || ast.type !== 1)) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
+        var inlineRenderFns = generate(ast, state.options);
+        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+            .map(function (code) { return "function(){" + code + "}"; })
+            .join(',') + "]}";
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -10197,9 +9893,9 @@ function genScopedSlots(el, slots, state) {
     // components with only scoped slots to skip forced updates from parent.
     // but in some cases we have to bail-out of this optimization
     // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
+    var needsForceUpdate = el.for ||
+        Object.keys(slots).some(function (key) {
+            var slot = slots[key];
             return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
             );
         });
@@ -10207,34 +9903,34 @@ function genScopedSlots(el, slots, state) {
     // it's possible for the same component to be reused but with different
     // compiled slot content. To avoid that, we generate a unique key based on
     // the generated code of all the slot contents.
-    let needsKey = !!el.if;
+    var needsKey = !!el.if;
     // OR when it is inside another scoped slot or v-for (the reactivity may be
     // disconnected due to the intermediate scope variable)
     // #9438, #9506
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
+        var parent_2 = el.parent;
+        while (parent_2) {
+            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                parent_2.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent.if) {
+            if (parent_2.if) {
                 needsKey = true;
             }
-            parent = parent.parent;
+            parent_2 = parent_2.parent;
         }
     }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
+    var generatedSlots = Object.keys(slots)
+        .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
 }
 function hash(str) {
-    let hash = 5381;
-    let i = str.length;
+    var hash = 5381;
+    var i = str.length;
     while (i) {
         hash = (hash * 33) ^ str.charCodeAt(--i);
     }
@@ -10250,45 +9946,45 @@ function containsSlotChild(el) {
     return false;
 }
 function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
+    var isLegacySyntax = el.attrsMap['slot-scope'];
     if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
+        return genIf(el, state, genScopedSlot, "null");
     }
     if (el.for && !el.forProcessed) {
         return genFor(el, state, genScopedSlot);
     }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
+    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+    var fn = "function(" + slotScope + "){" +
+        ("return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
+            : genElement(el, state)) + "}");
     // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+    var reverseProxy = slotScope ? "" : ",proxy:true";
+    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
+    var children = el.children;
     if (children.length) {
-        const el = children[0];
+        var el_1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
+            el_1.for &&
+            el_1.tag !== 'template' &&
+            el_1.tag !== 'slot') {
+            var normalizationType_1 = checkSkip
+                ? state.maybeComponent(el_1)
+                    ? ",1"
+                    : ",0"
+                : "";
+            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+        }
+        var normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+        var gen_1 = altGenNode || genNode;
+        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
     }
 }
 // determine the normalization needed for the children array.
@@ -10296,20 +9992,20 @@ function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
 function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
+    var res = 0;
+    for (var i = 0; i < children.length; i++) {
+        var el = children[i];
         if (el.type !== 1) {
             continue;
         }
         if (needsNormalization(el) ||
             (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
             res = 2;
             break;
         }
         if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
             res = 1;
         }
     }
@@ -10330,58 +10026,58 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return `_v(${text.type === 2
+    return "_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
 }
 function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
+    return "_e(" + JSON.stringify(comment.text) + ")";
 }
 function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,${children}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
+    var slotName = el.slotName || '"default"';
+    var children = genChildren(el, state);
+    var res = "_t(" + slotName + (children ? "," + children : '');
+    var attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
             name: camelize(attr.name),
             value: attr.value,
             dynamic: attr.dynamic,
-        })))
+        }); }))
         : null;
-    const bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
-        res += `,null`;
+    var bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += ",null";
     }
     if (attrs) {
-        res += `,${attrs}`;
+        res += "," + attrs;
     }
-    if (bind$$1) {
-        res += `${attrs ? '' : ',null'},${bind$$1}`;
+    if (bind) {
+        res += (attrs ? '' : ',null') + "," + bind;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData$2(el, state)}${children ? `,${children}` : ''})`;
+    var children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
 }
 function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
+    var staticProps = "";
+    var dynamicProps = "";
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
+            dynamicProps += prop.name + "," + value + ",";
         }
         else {
-            staticProps += `"${prop.name}":${value},`;
+            staticProps += "\"" + prop.name + "\":" + value + ",";
         }
     }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
+    staticProps = "{" + staticProps.slice(0, -1) + "}";
     if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
     }
     else {
         return staticProps;
@@ -10395,7 +10091,7 @@ function transformSpecialNewlines(text) {
 /* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
+var prohibitedKeywordRE = new RegExp('\\b' +
     ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
         'super,throw,while,yield,delete,export,import,return,switch,default,' +
         'extends,finally,continue,debugger,function,arguments')
@@ -10403,11 +10099,11 @@ const prohibitedKeywordRE = new RegExp('\\b' +
         .join('\\b|\\b') +
     '\\b');
 // these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
+var unaryOperatorsRE = new RegExp('\\b' +
     'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
     '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
 // detect problematic expressions in a template
 function detectErrors(ast, warn) {
     if (ast) {
@@ -10416,28 +10112,28 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
+        for (var name_1 in node.attrsMap) {
+            if (dirRE.test(name_1)) {
+                var value = node.attrsMap[name_1];
                 if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
+                    var range = node.rawAttrsMap[name_1];
+                    if (name_1 === 'v-for') {
+                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
                     }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    else if (onRE.test(name_1)) {
+                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                     else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
+                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                 }
             }
         }
         if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
+            for (var i = 0; i < node.children.length; i++) {
                 checkNode(node.children[i], warn);
             }
         }
@@ -10447,11 +10143,11 @@ function checkNode(node, warn) {
     }
 }
 function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
+    var stripped = exp.replace(stripStringRE, '');
+    var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+        warn("avoid using JavaScript unary operator as property name: " +
+            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10464,29 +10160,29 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(`var ${ident}=_`);
+            new Function("var " + ident + "=_");
         }
         catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(`return ${exp}`);
+        new Function("return " + exp);
     }
     catch (e) {
-        const keywordMatch = exp
+        var keywordMatch = exp
             .replace(stripStringRE, '')
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+            warn("avoid using JavaScript keyword as property name: " +
+                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
         }
         else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
+            warn("invalid expression: " + e.message + " in\n\n" +
+                ("    " + exp + "\n\n") +
+                ("  Raw expression: " + text.trim() + "\n"), range);
         }
     }
 }
@@ -10495,36 +10191,38 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
+        warn("invalid function parameter expression: " + e.message + " in\n\n" +
+            ("    " + exp + "\n\n") +
+            ("  Raw expression: " + text.trim() + "\n"), range);
     }
 }
 
 /* @flow */
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
+var range = 2;
+function generateCodeFrame(source, start, end) {
+    if (start === void 0) { start = 0; }
+    if (end === void 0) { end = source.length; }
+    var lines = source.split(/\r?\n/);
+    var count = 0;
+    var res = [];
+    for (var i = 0; i < lines.length; i++) {
         count += lines[i].length + 1;
         if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
+            for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
+                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                    var pad = start - (count - lineLength) + 1;
+                    var length_1 = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
+                        var length_2 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length_2));
                     }
                     count += lineLength + 1;
                 }
@@ -10535,7 +10233,7 @@ function generateCodeFrame(source, start = 0, end = source.length) {
     return res.join('\n');
 }
 function repeat(str, n) {
-    let result = '';
+    var result = '';
     if (n > 0) {
         while (true) {
             // eslint-disable-line
@@ -10556,15 +10254,15 @@ function createFunction(code, errors) {
         return new Function(code);
     }
     catch (err) {
-        errors.push({ err, code });
+        errors.push({ err: err, code: code });
         return noop;
     }
 }
 function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
+    var cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        const warn$$1 = options.warn || warn;
+        var warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         {
@@ -10574,7 +10272,7 @@ function createCompileToFunctionFn(compile) {
             }
             catch (e) {
                 if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
                         'environment with Content Security Policy that prohibits unsafe-eval. ' +
                         'The template compiler cannot work in this environment. Consider ' +
                         'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -10583,43 +10281,43 @@ function createCompileToFunctionFn(compile) {
             }
         }
         // check cache
-        const key = options.delimiters
+        var key = options.delimiters
             ? String(options.delimiters) + template
             : template;
         if (cache[key]) {
             return cache[key];
         }
         // compile
-        const compiled = compile(template, options);
+        var compiled = compile(template, options);
         // check compilation errors/tips
         {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn$$1(`Error compiling template:\n\n${e.msg}\n\n` +
+                    compiled.errors.forEach(function (e) {
+                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn$$1(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                    warn("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                         '\n', vm);
                 }
             }
             if (compiled.tips && compiled.tips.length) {
                 if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
                 }
                 else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
+                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
                 }
             }
         }
         // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
+        var res = {};
+        var fnGenErrors = [];
         res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
             return createFunction(code, fnGenErrors);
         });
         // check function generation errors.
@@ -10628,9 +10326,12 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn$$1(`Failed to generate render function:\n\n` +
+                warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .map(function (_a) {
+                        var err = _a.err, code = _a.code;
+                        return err.toString() + " in\n\n" + code + "\n";
+                    })
                         .join('\n'), vm);
             }
         }
@@ -10642,24 +10343,24 @@ function createCompileToFunctionFn(compile) {
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
+            var finalOptions = Object.create(baseOptions);
+            var errors = [];
+            var tips = [];
+            var warn = function (msg, range, tip) {
                 (tip ? tips : errors).push(msg);
             };
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
+                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                    warn = function (msg, range, tip) {
+                        var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
+                                data.start = range.start + leadingSpaceLength_1;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
+                                data.end = range.end + leadingSpaceLength_1;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -10674,14 +10375,14 @@ function createCompilerCreator(baseCompile) {
                     finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
                 }
                 // copy other options
-                for (const key in options) {
+                for (var key in options) {
                     if (key !== 'modules' && key !== 'directives') {
                         finalOptions[key] = options[key];
                     }
                 }
             }
             finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
+            var compiled = baseCompile(template.trim(), finalOptions);
             {
                 detectErrors(compiled.ast, warn);
             }
@@ -10690,7 +10391,7 @@ function createCompilerCreator(baseCompile) {
             return compiled;
         }
         return {
-            compile,
+            compile: compile,
             compileToFunctions: createCompileToFunctionFn(compile),
         };
     };
@@ -10700,61 +10401,61 @@ function createCompilerCreator(baseCompile) {
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
     if (options.optimize !== false) {
         optimize(ast, options);
     }
-    const code = generate(ast, options);
+    var code = generate(ast, options);
     return {
-        ast,
+        ast: ast,
         render: code.render,
         staticRenderFns: code.staticRenderFns,
     };
 });
 
 /* @flow */
-const { compile, compileToFunctions } = createCompiler(baseOptions);
+var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
 /* @flow */
 // check whether current browser encodes a char inside attribute values
-let div;
+var div;
 function getShouldDecode(href) {
     div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
+    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
     return div.innerHTML.indexOf('&#10;') > 0;
 }
 // #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
+var shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
 /* @flow */
-const idToTemplate = cached((id) => {
-    const el = query(id);
+var idToTemplate = cached(function (id) {
+    var el = query(id);
     return el && el.innerHTML;
 });
-const mount = Vue.prototype.$mount;
+var mount = Vue.prototype.$mount;
 Vue.prototype.$mount = function (el, hydrating) {
     el = el && query(el);
     /* istanbul ignore if */
     if (el === document.body || el === document.documentElement) {
-        warn(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
+        warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
         return this;
     }
-    const options = this.$options;
+    var options = this.$options;
     // resolve template/el and convert to render function
     if (!options.render) {
-        let template = options.template;
+        var template = options.template;
         if (template) {
             if (typeof template === 'string') {
                 if (template.charAt(0) === '#') {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (!template) {
-                        warn(`Template element not found or is empty: ${options.template}`, this);
+                        warn$2("Template element not found or is empty: " + options.template, this);
                     }
                 }
             }
@@ -10763,7 +10464,7 @@ Vue.prototype.$mount = function (el, hydrating) {
             }
             else {
                 {
-                    warn('invalid template option:' + template, this);
+                    warn$2('invalid template option:' + template, this);
                 }
                 return this;
             }
@@ -10777,19 +10478,19 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (config.performance && mark) {
                 mark('compile');
             }
-            const { render, staticRenderFns } = compileToFunctions(template, {
+            var _a = compileToFunctions(template, {
                 outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
+                shouldDecodeNewlines: shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
-            }, this);
+            }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (config.performance && mark) {
                 mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
+                measure("vue " + this._name + " compile", 'compile', 'compile end');
             }
         }
     }
@@ -10804,7 +10505,7 @@ function getOuterHTML(el) {
         return el.outerHTML;
     }
     else {
-        const container = document.createElement('div');
+        var container = document.createElement('div');
         container.appendChild(el.cloneNode(true));
         return container.innerHTML;
     }
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
index 9a6af5e0c30..4f800369322 100644
--- a/dist/vue.esm.browser.min.js
+++ b/dist/vue.esm.browser.min.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-const e=Object.freeze({});function t(e){return null==e}function r(e){return null!=e}function n(e){return!0===e}function o(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function s(e){return null!==e&&"object"==typeof e}const a=Object.prototype.toString;function i(e){return"[object Object]"===a.call(e)}function c(e){const t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return r(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||i(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function p(e){const t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){const r=Object.create(null),n=e.split(",");for(let e=0;e<n.length;e++)r[n[e]]=!0;return t?e=>r[e.toLowerCase()]:e=>r[e]}const f=d("slot,component",!0),m=d("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){const r=e.indexOf(t);if(r>-1)return e.splice(r,1)}}const g=Object.prototype.hasOwnProperty;function b(e,t){return g.call(e,t)}function y(e){const t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}const v=/-(\w)/g,w=y(e=>e.replace(v,(e,t)=>t?t.toUpperCase():"")),A=y(e=>e.charAt(0).toUpperCase()+e.slice(1)),D=/\B([A-Z])/g,x=y(e=>e.replace(D,"-$1").toLowerCase());const q=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function r(r){const n=arguments.length;return n?n>1?e.apply(t,arguments):e.call(t,r):e.call(t)}return r._length=e.length,r};function $(e,t){t=t||0;let r=e.length-t;const n=new Array(r);for(;r--;)n[r]=e[r+t];return n}function k(e,t){for(const r in t)e[r]=t[r];return e}function E(e){const t={};for(let r=0;r<e.length;r++)e[r]&&k(t,e[r]);return t}function _(e,t,r){}const C=(e,t,r)=>!1,S=e=>e;function L(e,t){if(e===t)return!0;const r=s(e),n=s(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{const r=Array.isArray(e),n=Array.isArray(t);if(r&&n)return e.length===t.length&&e.every((e,r)=>L(e,t[r]));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(r||n)return!1;{const r=Object.keys(e),n=Object.keys(t);return r.length===n.length&&r.every(r=>L(e[r],t[r]))}}catch(e){return!1}}function T(e,t){for(let r=0;r<e.length;r++)if(L(e[r],t))return r;return-1}function N(e){let t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}const O="data-server-rendered",R=["component","directive","filter"],F=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var B={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:C,isReservedAttr:C,isUnknownElement:C,getTagNamespace:_,parsePlatformTagName:S,mustUseProp:C,async:!0,_lifecycleHooks:F};const U=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function V(e){const t=(e+"").charCodeAt(0);return 36===t||95===t}function I(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}const j=new RegExp(`[^${U.source}.$_\\d]`);const P="__proto__"in{},H="undefined"!=typeof window,M="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,G=M&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),J=z&&/msie|trident/.test(z),K=z&&z.indexOf("msie 9.0")>0,Z=z&&z.indexOf("edge/")>0,Y=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===G),W=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Q={}.watch;let X,ee=!1;if(H)try{const e={};Object.defineProperty(e,"passive",{get(){ee=!0}}),window.addEventListener("test-passive",null,e)}catch(e){}const te=()=>(void 0===X&&(X=!H&&!M&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X),re=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ne(e){return"function"==typeof e&&/native code/.test(e.toString())}const oe="undefined"!=typeof Symbol&&ne(Symbol)&&"undefined"!=typeof Reflect&&ne(Reflect.ownKeys);let se;se="undefined"!=typeof Set&&ne(Set)?Set:class{constructor(){this.set=Object.create(null)}has(e){return!0===this.set[e]}add(e){this.set[e]=!0}clear(){this.set=Object.create(null)}};let ae=_,ie=0;class ce{constructor(){this.id=ie++,this.subs=[]}addSub(e){this.subs.push(e)}removeSub(e){h(this.subs,e)}depend(){ce.target&&ce.target.addDep(this)}notify(){const e=this.subs.slice();for(let t=0,r=e.length;t<r;t++)e[t].update()}}ce.target=null;const le=[];function ue(e){le.push(e),ce.target=e}function pe(){le.pop(),ce.target=le[le.length-1]}class de{constructor(e,t,r,n,o,s,a,i){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=o,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=i,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const fe=(e="")=>{const t=new de;return t.text=e,t.isComment=!0,t};function me(e){return new de(void 0,void 0,void 0,String(e))}function he(e){const t=new de(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}const ge=Array.prototype,be=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){const t=ge[e];I(be,e,function(...r){const n=t.apply(this,r),o=this.__ob__;let s;switch(e){case"push":case"unshift":s=r;break;case"splice":s=r.slice(2)}return s&&o.observeArray(s),o.dep.notify(),n})});const ye=Object.getOwnPropertyNames(be);let ve=!0;function we(e){ve=e}class Ae{constructor(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,I(e,"__ob__",this),Array.isArray(e)?(P?(t=be,e.__proto__=t):function(e,t,r){for(let n=0,o=r.length;n<o;n++){const o=r[n];I(e,o,t[o])}}(e,be,ye),this.observeArray(e)):this.walk(e)}walk(e){const t=Object.keys(e);for(let r=0;r<t.length;r++)xe(e,t[r])}observeArray(e){for(let t=0,r=e.length;t<r;t++)De(e[t])}}function De(e,t){if(!s(e)||e instanceof de)return;let r;return b(e,"__ob__")&&e.__ob__ instanceof Ae?r=e.__ob__:ve&&!te()&&(Array.isArray(e)||i(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Ae(e)),t&&r&&r.vmCount++,r}function xe(e,t,r,n,o){const s=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(a&&!1===a.configurable)return;const i=a&&a.get,c=a&&a.set;i&&!c||2!==arguments.length||(r=e[t]);let l=!o&&De(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){const t=i?i.call(e):r;return ce.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(let r,n=0,o=t.length;n<o;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){const n=i?i.call(e):r;t===n||t!=t&&n!=n||i&&!c||(c?c.call(e,t):r=t,l=!o&&De(t),s.notify())}})}function qe(e,t,r){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;const n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(xe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}function $e(e,t){if(Array.isArray(e)&&c(t))return void e.splice(t,1);const r=e.__ob__;e._isVue||r&&r.vmCount||b(e,t)&&(delete e[t],r&&r.dep.notify())}const ke=B.optionMergeStrategies;function Ee(e,t){if(!t)return e;let r,n,o;const s=oe?Reflect.ownKeys(t):Object.keys(t);for(let a=0;a<s.length;a++)"__ob__"!==(r=s[a])&&(n=e[r],o=t[r],b(e,r)?n!==o&&i(n)&&i(o)&&Ee(n,o):qe(e,r,o));return e}function _e(e,t,r){return r?function(){const n="function"==typeof t?t.call(r,r):t,o="function"==typeof e?e.call(r,r):e;return n?Ee(n,o):o}:t?e?function(){return Ee("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ce(e,t){const r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){const t=[];for(let r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Se(e,t,r,n){const o=Object.create(e||null);return t?k(o,t):o}ke.data=function(e,t,r){return r?_e(e,t,r):t&&"function"!=typeof t?e:_e(e,t)},F.forEach(e=>{ke[e]=Ce}),R.forEach(function(e){ke[e+"s"]=Se}),ke.watch=function(e,t,r,n){if(e===Q&&(e=void 0),t===Q&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;const o={};k(o,e);for(const e in t){let r=o[e];const n=t[e];r&&!Array.isArray(r)&&(r=[r]),o[e]=r?r.concat(n):Array.isArray(n)?n:[n]}return o},ke.props=ke.methods=ke.inject=ke.computed=function(e,t,r,n){if(!e)return t;const o=Object.create(null);return k(o,e),t&&k(o,t),o},ke.provide=_e;const Le=function(e,t){return void 0===t?e:t};function Te(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){const r=e.props;if(!r)return;const n={};let o,s,a;if(Array.isArray(r))for(o=r.length;o--;)"string"==typeof(s=r[o])&&(n[a=w(s)]={type:null});else if(i(r))for(const e in r)s=r[e],n[a=w(e)]=i(s)?s:{type:s};e.props=n}(t),function(e,t){const r=e.inject;if(!r)return;const n=e.inject={};if(Array.isArray(r))for(let e=0;e<r.length;e++)n[r[e]]={from:r[e]};else if(i(r))for(const e in r){const t=r[e];n[e]=i(t)?k({from:e},t):{from:t}}}(t),function(e){const t=e.directives;if(t)for(const e in t){const r=t[e];"function"==typeof r&&(t[e]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Te(e,t.extends,r)),t.mixins))for(let n=0,o=t.mixins.length;n<o;n++)e=Te(e,t.mixins[n],r);const n={};let o;for(o in e)s(o);for(o in t)b(e,o)||s(o);function s(o){const s=ke[o]||Le;n[o]=s(e[o],t[o],r,o)}return n}function Ne(e,t,r,n){if("string"!=typeof r)return;const o=e[t];if(b(o,r))return o[r];const s=w(r);if(b(o,s))return o[s];const a=A(s);return b(o,a)?o[a]:o[r]||o[s]||o[a]}function Oe(e,t,r,n){const o=t[e],s=!b(r,e);let a=r[e];const i=Ue(Boolean,o.type);if(i>-1)if(s&&!b(o,"default"))a=!1;else if(""===a||a===x(e)){const e=Ue(String,o.type);(e<0||i<e)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!b(t,"default"))return;const n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Fe(t.type)?n.call(e):n}(n,o,e);const t=ve;we(!0),De(a),we(t)}return a}const Re=/^\s*function (\w+)/;function Fe(e){const t=e&&e.toString().match(Re);return t?t[1]:""}function Be(e,t){return Fe(e)===Fe(t)}function Ue(e,t){if(!Array.isArray(t))return Be(t,e)?0:-1;for(let r=0,n=t.length;r<n;r++)if(Be(t[r],e))return r;return-1}function Ve(e,t,r){ue();try{if(t){let n=t;for(;n=n.$parent;){const o=n.$options.errorCaptured;if(o)for(let s=0;s<o.length;s++)try{if(!1===o[s].call(n,e,t,r))return}catch(e){je(e,n,"errorCaptured hook")}}}je(e,t,r)}finally{pe()}}function Ie(e,t,r,n,o){let s;try{(s=r?e.apply(t,r):e.call(t))&&!s._isVue&&l(s)&&!s._handled&&(s.catch(e=>Ve(e,n,o+" (Promise/async)")),s._handled=!0)}catch(e){Ve(e,n,o)}return s}function je(e,t,r){if(B.errorHandler)try{return B.errorHandler.call(null,e,t,r)}catch(t){t!==e&&Pe(t,null,"config.errorHandler")}Pe(e,t,r)}function Pe(e,t,r){if(!H&&!M||"undefined"==typeof console)throw e;console.error(e)}let He=!1;const Me=[];let Ge,ze=!1;function Je(){ze=!1;const e=Me.slice(0);Me.length=0;for(let t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&ne(Promise)){const e=Promise.resolve();Ge=(()=>{e.then(Je),Y&&setTimeout(_)}),He=!0}else if(J||"undefined"==typeof MutationObserver||!ne(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ge="undefined"!=typeof setImmediate&&ne(setImmediate)?()=>{setImmediate(Je)}:()=>{setTimeout(Je,0)};else{let e=1;const t=new MutationObserver(Je),r=document.createTextNode(String(e));t.observe(r,{characterData:!0}),Ge=(()=>{e=(e+1)%2,r.data=String(e)}),He=!0}function Ke(e,t){let r;if(Me.push(()=>{if(e)try{e.call(t)}catch(e){Ve(e,t,"nextTick")}else r&&r(t)}),ze||(ze=!0,Ge()),!e&&"undefined"!=typeof Promise)return new Promise(e=>{r=e})}const Ze=new se;function Ye(e){!function e(t,r){let n,o;const a=Array.isArray(t);if(!a&&!s(t)||Object.isFrozen(t)||t instanceof de)return;if(t.__ob__){const e=t.__ob__.dep.id;if(r.has(e))return;r.add(e)}if(a)for(n=t.length;n--;)e(t[n],r);else for(o=Object.keys(t),n=o.length;n--;)e(t[o[n]],r)}(e,Ze),Ze.clear()}const We=y(e=>{const t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function Qe(e,t){function r(){const e=r.fns;if(!Array.isArray(e))return Ie(e,null,arguments,t,"v-on handler");{const r=e.slice();for(let e=0;e<r.length;e++)Ie(r[e],null,arguments,t,"v-on handler")}}return r.fns=e,r}function Xe(e,r,o,s,a,i){let c,l,u,p,d;for(c in e)l=u=e[c],p=r[c],d=We(c),t(u)||(t(p)?(t(u.fns)&&(u=e[c]=Qe(u,i)),n(d.once)&&(u=e[c]=a(d.name,u,d.capture)),o(d.name,u,d.capture,d.passive,d.params)):u!==p&&(p.fns=u,e[c]=p));for(c in r)t(e[c])&&s((d=We(c)).name,r[c],d.capture)}function et(e,o,s){let a;e instanceof de&&(e=e.data.hook||(e.data.hook={}));const i=e[o];function c(){s.apply(this,arguments),h(a.fns,c)}t(i)?a=Qe([c]):r(i.fns)&&n(i.merged)?(a=i).fns.push(c):a=Qe([i,c]),a.merged=!0,e[o]=a}function tt(e,t,n,o,s){if(r(t)){if(b(t,n))return e[n]=t[n],s||delete t[n],!0;if(b(t,o))return e[n]=t[o],s||delete t[o],!0}return!1}function rt(e){return o(e)?[me(e)]:Array.isArray(e)?function e(s,a){const i=[];let c,l,u,p;for(c=0;c<s.length;c++)t(l=s[c])||"boolean"==typeof l||(u=i.length-1,p=i[u],Array.isArray(l)?l.length>0&&(nt((l=e(l,`${a||""}_${c}`))[0])&&nt(p)&&(i[u]=me(p.text+l[0].text),l.shift()),i.push.apply(i,l)):o(l)?nt(p)?i[u]=me(p.text+l):""!==l&&i.push(me(l)):nt(l)&&nt(p)?i[u]=me(p.text+l.text):(n(s._isVList)&&r(l.tag)&&t(l.key)&&r(a)&&(l.key=`__vlist${a}_${c}__`),i.push(l)));return i}(e):void 0}function nt(e){return r(e)&&r(e.text)&&!1===e.isComment}function ot(e,t){if(e){const r=Object.create(null),n=oe?Reflect.ownKeys(e):Object.keys(e);for(let o=0;o<n.length;o++){const s=n[o];if("__ob__"===s)continue;const a=e[s].from;let i=t;for(;i;){if(i._provided&&b(i._provided,a)){r[s]=i._provided[a];break}i=i.$parent}if(!i&&"default"in e[s]){const n=e[s].default;r[s]="function"==typeof n?n.call(t):n}}return r}}function st(e,t){if(!e||!e.length)return{};const r={};for(let n=0,o=e.length;n<o;n++){const o=e[n],s=o.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,o.context!==t&&o.fnContext!==t||!s||null==s.slot)(r.default||(r.default=[])).push(o);else{const e=s.slot,t=r[e]||(r[e]=[]);"template"===o.tag?t.push.apply(t,o.children||[]):t.push(o)}}for(const e in r)r[e].every(at)&&delete r[e];return r}function at(e){return e.isComment&&!e.asyncFactory||" "===e.text}function it(t,r,n){let o;const s=Object.keys(r).length>0,a=t?!!t.$stable:!s,i=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&n&&n!==e&&i===n.$key&&!s&&!n.$hasNormal)return n;o={};for(const e in t)t[e]&&"$"!==e[0]&&(o[e]=ct(r,e,t[e]))}else o={};for(const e in r)e in o||(o[e]=lt(r,e));return t&&Object.isExtensible(t)&&(t._normalized=o),I(o,"$stable",a),I(o,"$key",i),I(o,"$hasNormal",s),o}function ct(e,t,r){const n=function(){let e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:rt(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function lt(e,t){return()=>e[t]}function ut(e,t){let n,o,a,i,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,o=e.length;n<o;n++)c[n]=t(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=t(n+1,n);else if(s(e))if(oe&&e[Symbol.iterator]){c=[];const r=e[Symbol.iterator]();let n=r.next();for(;!n.done;)c.push(t(n.value,c.length)),n=r.next()}else for(a=Object.keys(e),c=new Array(a.length),n=0,o=a.length;n<o;n++)i=a[n],c[n]=t(e[i],i,n);return r(c)||(c=[]),c._isVList=!0,c}function pt(e,t,r,n){const o=this.$scopedSlots[e];let s;o?(r=r||{},n&&(r=k(k({},n),r)),s=o(r)||t):s=this.$slots[e]||t;const a=r&&r.slot;return a?this.$createElement("template",{slot:a},s):s}function dt(e){return Ne(this.$options,"filters",e)||S}function ft(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function mt(e,t,r,n,o){const s=B.keyCodes[t]||r;return o&&n&&!B.keyCodes[t]?ft(o,n):s?ft(s,e):n?x(n)!==t:void 0}function ht(e,t,r,n,o){if(r)if(s(r)){let s;Array.isArray(r)&&(r=E(r));for(const a in r){if("class"===a||"style"===a||m(a))s=e;else{const r=e.attrs&&e.attrs.type;s=n||B.mustUseProp(t,r,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}const i=w(a),c=x(a);if(!(i in s||c in s)&&(s[a]=r[a],o)){(e.on||(e.on={}))[`update:${a}`]=function(e){r[a]=e}}}}else;return e}function gt(e,t){const r=this._staticTrees||(this._staticTrees=[]);let n=r[e];return n&&!t?n:(yt(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),`__static__${e}`,!1),n)}function bt(e,t,r){return yt(e,`__once__${t}${r?`_${r}`:""}`,!0),e}function yt(e,t,r){if(Array.isArray(e))for(let n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&vt(e[n],`${t}_${n}`,r);else vt(e,t,r)}function vt(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function wt(e,t){if(t)if(i(t)){const r=e.on=e.on?k({},e.on):{};for(const e in t){const n=r[e],o=t[e];r[e]=n?[].concat(n,o):o}}else;return e}function At(e,t,r,n){t=t||{$stable:!r};for(let n=0;n<e.length;n++){const o=e[n];Array.isArray(o)?At(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function Dt(e,t){for(let r=0;r<t.length;r+=2){const n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function xt(e,t){return"string"==typeof e?t+e:e}function qt(e){e._o=bt,e._n=p,e._s=u,e._l=ut,e._t=pt,e._q=L,e._i=T,e._m=gt,e._f=dt,e._k=mt,e._b=ht,e._v=me,e._e=fe,e._u=At,e._g=wt,e._d=Dt,e._p=xt}function $t(t,r,o,s,a){const i=a.options;let c;b(s,"_uid")?(c=Object.create(s))._original=s:(c=s,s=s._original);const l=n(i._compiled),u=!l;this.data=t,this.props=r,this.children=o,this.parent=s,this.listeners=t.on||e,this.injections=ot(i.inject,s),this.slots=(()=>(this.$slots||it(t.scopedSlots,this.$slots=st(o,s)),this.$slots)),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return it(t.scopedSlots,this.slots())}}),l&&(this.$options=i,this.$slots=this.slots(),this.$scopedSlots=it(t.scopedSlots,this.$slots)),i._scopeId?this._c=((e,t,r,n)=>{const o=Ot(c,e,t,r,n,u);return o&&!Array.isArray(o)&&(o.fnScopeId=i._scopeId,o.fnContext=s),o}):this._c=((e,t,r,n)=>Ot(c,e,t,r,n,u))}function kt(e,t,r,n,o){const s=he(e);return s.fnContext=r,s.fnOptions=n,t.slot&&((s.data||(s.data={})).slot=t.slot),s}function Et(e,t){for(const r in t)e[w(r)]=t[r]}qt($t.prototype);const _t={init(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){const t=e;_t.prepatch(t,t)}else{(e.componentInstance=function(e,t){const n={_isComponent:!0,_parentVnode:e,parent:t},o=e.data.inlineTemplate;r(o)&&(n.render=o.render,n.staticRenderFns=o.staticRenderFns);return new e.componentOptions.Ctor(n)}(e,Mt)).$mount(t?e.elm:void 0,t)}},prepatch(t,r){const n=r.componentOptions;!function(t,r,n,o,s){const a=o.data.scopedSlots,i=t.$scopedSlots,c=!!(a&&!a.$stable||i!==e&&!i.$stable||a&&t.$scopedSlots.$key!==a.$key),l=!!(s||t.$options._renderChildren||c);t.$options._parentVnode=o,t.$vnode=o,t._vnode&&(t._vnode.parent=o);if(t.$options._renderChildren=s,t.$attrs=o.data.attrs||e,t.$listeners=n||e,r&&t.$options.props){we(!1);const e=t._props,n=t.$options._propKeys||[];for(let o=0;o<n.length;o++){const s=n[o],a=t.$options.props;e[s]=Oe(s,a,r,t)}we(!0),t.$options.propsData=r}n=n||e;const u=t.$options._parentListeners;t.$options._parentListeners=n,Ht(t,n,u),l&&(t.$slots=st(s,o.context),t.$forceUpdate())}(r.componentInstance=t.componentInstance,n.propsData,n.listeners,r,n.children)},insert(e){const{context:t,componentInstance:r}=e;var n;r._isMounted||(r._isMounted=!0,Kt(r,"mounted")),e.data.keepAlive&&(t._isMounted?((n=r)._inactive=!1,Yt.push(n)):Jt(r,!0))},destroy(e){const{componentInstance:t}=e;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(r&&(t._directInactive=!0,zt(t)))return;if(!t._inactive){t._inactive=!0;for(let r=0;r<t.$children.length;r++)e(t.$children[r]);Kt(t,"deactivated")}}(t,!0):t.$destroy())}},Ct=Object.keys(_t);function St(o,a,i,c,u){if(t(o))return;const p=i.$options._base;if(s(o)&&(o=p.extend(o)),"function"!=typeof o)return;let d;if(t(o.cid)&&void 0===(o=function(e,o){if(n(e.error)&&r(e.errorComp))return e.errorComp;if(r(e.resolved))return e.resolved;const a=Ft;a&&r(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(n(e.loading)&&r(e.loadingComp))return e.loadingComp;if(a&&!r(e.owners)){const n=e.owners=[a];let i=!0,c=null,u=null;a.$on("hook:destroyed",()=>h(n,a));const p=e=>{for(let e=0,t=n.length;e<t;e++)n[e].$forceUpdate();e&&(n.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=N(t=>{e.resolved=Bt(t,o),i?n.length=0:p(!0)}),f=N(t=>{r(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,f);return s(m)&&(l(m)?t(e.resolved)&&m.then(d,f):l(m.component)&&(m.component.then(d,f),r(m.error)&&(e.errorComp=Bt(m.error,o)),r(m.loading)&&(e.loadingComp=Bt(m.loading,o),0===m.delay?e.loading=!0:c=setTimeout(()=>{c=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),r(m.timeout)&&(u=setTimeout(()=>{u=null,t(e.resolved)&&f(null)},m.timeout)))),i=!1,e.loading?e.loadingComp:e.resolved}}(d=o,p)))return function(e,t,r,n,o){const s=fe();return s.asyncFactory=e,s.asyncMeta={data:t,context:r,children:n,tag:o},s}(d,a,i,c,u);a=a||{},hr(o),r(a.model)&&function(e,t){const n=e.model&&e.model.prop||"value",o=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[n]=t.model.value;const s=t.on||(t.on={}),a=s[o],i=t.model.callback;r(a)?(Array.isArray(a)?-1===a.indexOf(i):a!==i)&&(s[o]=[i].concat(a)):s[o]=i}(o.options,a);const f=function(e,n,o){const s=n.options.props;if(t(s))return;const a={},{attrs:i,props:c}=e;if(r(i)||r(c))for(const e in s){const t=x(e);tt(a,c,e,t,!0)||tt(a,i,e,t,!1)}return a}(a,o);if(n(o.options.functional))return function(t,n,o,s,a){const i=t.options,c={},l=i.props;if(r(l))for(const t in l)c[t]=Oe(t,l,n||e);else r(o.attrs)&&Et(c,o.attrs),r(o.props)&&Et(c,o.props);const u=new $t(o,c,a,s,t),p=i.render.call(null,u._c,u);if(p instanceof de)return kt(p,o,u.parent,i);if(Array.isArray(p)){const e=rt(p)||[],t=new Array(e.length);for(let r=0;r<e.length;r++)t[r]=kt(e[r],o,u.parent,i);return t}}(o,f,a,i,c);const m=a.on;if(a.on=a.nativeOn,n(o.options.abstract)){const e=a.slot;a={},e&&(a.slot=e)}!function(e){const t=e.hook||(e.hook={});for(let e=0;e<Ct.length;e++){const r=Ct[e],n=t[r],o=_t[r];n===o||n&&n._merged||(t[r]=n?Lt(o,n):o)}}(a);const g=o.options.name||u;return new de(`vue-component-${o.cid}${g?`-${g}`:""}`,a,void 0,void 0,void 0,i,{Ctor:o,propsData:f,listeners:m,tag:u,children:c},d)}function Lt(e,t){const r=(r,n)=>{e(r,n),t(r,n)};return r._merged=!0,r}const Tt=1,Nt=2;function Ot(e,a,i,c,l,u){return(Array.isArray(i)||o(i))&&(l=c,c=i,i=void 0),n(u)&&(l=Nt),function(e,o,a,i,c){if(r(a)&&r(a.__ob__))return fe();r(a)&&r(a.is)&&(o=a.is);if(!o)return fe();Array.isArray(i)&&"function"==typeof i[0]&&((a=a||{}).scopedSlots={default:i[0]},i.length=0);c===Nt?i=rt(i):c===Tt&&(i=function(e){for(let t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));let l,u;if("string"==typeof o){let t;u=e.$vnode&&e.$vnode.ns||B.getTagNamespace(o),l=B.isReservedTag(o)?new de(B.parsePlatformTagName(o),a,i,void 0,void 0,e):a&&a.pre||!r(t=Ne(e.$options,"components",o))?new de(o,a,i,void 0,void 0,e):St(t,a,e,i,o)}else l=St(o,a,e,i);return Array.isArray(l)?l:r(l)?(r(u)&&function e(o,s,a){o.ns=s;"foreignObject"===o.tag&&(s=void 0,a=!0);if(r(o.children))for(let i=0,c=o.children.length;i<c;i++){const c=o.children[i];r(c.tag)&&(t(c.ns)||n(a)&&"svg"!==c.tag)&&e(c,s,a)}}(l,u),r(a)&&function(e){s(e.style)&&Ye(e.style);s(e.class)&&Ye(e.class)}(a),l):fe()}(e,a,i,c,l)}let Rt,Ft=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),s(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function Vt(e){if(Array.isArray(e))for(let t=0;t<e.length;t++){const n=e[t];if(r(n)&&(r(n.componentOptions)||Ut(n)))return n}}function It(e,t){Rt.$on(e,t)}function jt(e,t){Rt.$off(e,t)}function Pt(e,t){const r=Rt;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ht(e,t,r){Rt=e,Xe(t,r||{},It,jt,Pt,e),Rt=void 0}let Mt=null;function Gt(e){const t=Mt;return Mt=e,()=>{Mt=t}}function zt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Jt(e,t){if(t){if(e._directInactive=!1,zt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(let t=0;t<e.$children.length;t++)Jt(e.$children[t]);Kt(e,"activated")}}function Kt(e,t){ue();const r=e.$options[t],n=`${t} hook`;if(r)for(let t=0,o=r.length;t<o;t++)Ie(r[t],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),pe()}const Zt=[],Yt=[];let Wt={},Qt=!1,Xt=!1,er=0;let tr=0,rr=Date.now;if(H&&!J){const e=window.performance;e&&"function"==typeof e.now&&rr()>document.createEvent("Event").timeStamp&&(rr=(()=>e.now()))}function nr(){let e,t;for(tr=rr(),Xt=!0,Zt.sort((e,t)=>e.id-t.id),er=0;er<Zt.length;er++)(e=Zt[er]).before&&e.before(),t=e.id,Wt[t]=null,e.run();const r=Yt.slice(),n=Zt.slice();er=Zt.length=Yt.length=0,Wt={},Qt=Xt=!1,function(e){for(let t=0;t<e.length;t++)e[t]._inactive=!0,Jt(e[t],!0)}(r),function(e){let t=e.length;for(;t--;){const r=e[t],n=r.vm;n._watcher===r&&n._isMounted&&!n._isDestroyed&&Kt(n,"updated")}}(n),re&&B.devtools&&re.emit("flush")}let or=0;class sr{constructor(e,t,r,n,o){this.vm=e,o&&(e._watcher=this),e._watchers.push(this),n?(this.deep=!!n.deep,this.user=!!n.user,this.lazy=!!n.lazy,this.sync=!!n.sync,this.before=n.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=r,this.id=++or,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new se,this.newDepIds=new se,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(j.test(e))return;const t=e.split(".");return function(e){for(let r=0;r<t.length;r++){if(!e)return;e=e[t[r]]}return e}}(t),this.getter||(this.getter=_)),this.value=this.lazy?void 0:this.get()}get(){let e;ue(this);const t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Ve(e,t,`getter for watcher "${this.expression}"`)}finally{this.deep&&Ye(e),pe(),this.cleanupDeps()}return e}addDep(e){const t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))}cleanupDeps(){let e=this.deps.length;for(;e--;){const t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}let t=this.depIds;this.depIds=this.newDepIds,this.newDepIds=t,this.newDepIds.clear(),t=this.deps,this.deps=this.newDeps,this.newDeps=t,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){const t=e.id;if(null==Wt[t]){if(Wt[t]=!0,Xt){let t=Zt.length-1;for(;t>er&&Zt[t].id>e.id;)t--;Zt.splice(t+1,0,e)}else Zt.push(e);Qt||(Qt=!0,Ke(nr))}}(this)}run(){if(this.active){const e=this.get();if(e!==this.value||s(e)||this.deep){const t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Ve(e,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,e,t)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let e=this.deps.length;for(;e--;)this.deps[e].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);let e=this.deps.length;for(;e--;)this.deps[e].removeSub(this);this.active=!1}}}const ar={enumerable:!0,configurable:!0,get:_,set:_};function ir(e,t,r){ar.get=function(){return this[t][r]},ar.set=function(e){this[t][r]=e},Object.defineProperty(e,r,ar)}function cr(e){e._watchers=[];const t=e.$options;t.props&&function(e,t){const r=e.$options.propsData||{},n=e._props={},o=e.$options._propKeys=[];e.$parent&&we(!1);for(const s in t){o.push(s);const a=Oe(s,t,r,e);xe(n,s,a),s in e||ir(e,"_props",s)}we(!0)}(e,t.props),t.methods&&function(e,t){e.$options.props;for(const r in t)e[r]="function"!=typeof t[r]?_:q(t[r],e)}(e,t.methods),t.data?function(e){let t=e.$options.data;i(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Ve(e,t,"data()"),{}}finally{pe()}}(t,e):t||{})||(t={});const r=Object.keys(t),n=e.$options.props;e.$options.methods;let o=r.length;for(;o--;){const t=r[o];n&&b(n,t)||V(t)||ir(e,"_data",t)}De(t,!0)}(e):De(e._data={},!0),t.computed&&function(e,t){const r=e._computedWatchers=Object.create(null),n=te();for(const o in t){const s=t[o],a="function"==typeof s?s:s.get;n||(r[o]=new sr(e,a||_,_,lr)),o in e||ur(e,o,s)}}(e,t.computed),t.watch&&t.watch!==Q&&function(e,t){for(const r in t){const n=t[r];if(Array.isArray(n))for(let t=0;t<n.length;t++)fr(e,r,n[t]);else fr(e,r,n)}}(e,t.watch)}const lr={lazy:!0};function ur(e,t,r){const n=!te();"function"==typeof r?(ar.get=n?pr(t):dr(r),ar.set=_):(ar.get=r.get?n&&!1!==r.cache?pr(t):dr(r.get):_,ar.set=r.set||_),Object.defineProperty(e,t,ar)}function pr(e){return function(){const t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function dr(e){return function(){return e.call(this,this)}}function fr(e,t,r,n){return i(r)&&(n=r,r=r.handler),"string"==typeof r&&(r=e[r]),e.$watch(t,r,n)}let mr=0;function hr(e){let t=e.options;if(e.super){const r=hr(e.super);if(r!==e.superOptions){e.superOptions=r;const n=function(e){let t;const r=e.options,n=e.sealedOptions;for(const e in r)r[e]!==n[e]&&(t||(t={}),t[e]=r[e]);return t}(e);n&&k(e.extendOptions,n),(t=e.options=Te(r,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function gr(e){this._init(e)}function br(e){e.cid=0;let t=1;e.extend=function(e){e=e||{};const r=this,n=r.cid,o=e._Ctor||(e._Ctor={});if(o[n])return o[n];const s=e.name||r.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(r.prototype)).constructor=a,a.cid=t++,a.options=Te(r.options,e),a.super=r,a.options.props&&function(e){const t=e.options.props;for(const r in t)ir(e.prototype,"_props",r)}(a),a.options.computed&&function(e){const t=e.options.computed;for(const r in t)ur(e.prototype,r,t[r])}(a),a.extend=r.extend,a.mixin=r.mixin,a.use=r.use,R.forEach(function(e){a[e]=r[e]}),s&&(a.options.components[s]=a),a.superOptions=r.options,a.extendOptions=e,a.sealedOptions=k({},a.options),o[n]=a,a}}function yr(e){return e&&(e.Ctor.options.name||e.tag)}function vr(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(r=e,"[object RegExp]"===a.call(r)&&e.test(t));var r}function wr(e,t){const{cache:r,keys:n,_vnode:o}=e;for(const e in r){const s=r[e];if(s){const a=yr(s.componentOptions);a&&!t(a)&&Ar(r,e,n,o)}}}function Ar(e,t,r,n){const o=e[t];!o||n&&o.tag===n.tag||o.componentInstance.$destroy(),e[t]=null,h(r,t)}!function(t){t.prototype._init=function(t){const r=this;r._uid=mr++,r._isVue=!0,t&&t._isComponent?function(e,t){const r=e.$options=Object.create(e.constructor.options),n=t._parentVnode;r.parent=t.parent,r._parentVnode=n;const o=n.componentOptions;r.propsData=o.propsData,r._parentListeners=o.listeners,r._renderChildren=o.children,r._componentTag=o.tag,t.render&&(r.render=t.render,r.staticRenderFns=t.staticRenderFns)}(r,t):r.$options=Te(hr(r.constructor),t||{},r),r._renderProxy=r,r._self=r,function(e){const t=e.$options;let r=t.parent;if(r&&!t.abstract){for(;r.$options.abstract&&r.$parent;)r=r.$parent;r.$children.push(e)}e.$parent=r,e.$root=r?r.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(r),function(e){e._events=Object.create(null),e._hasHookEvent=!1;const t=e.$options._parentListeners;t&&Ht(e,t)}(r),function(t){t._vnode=null,t._staticTrees=null;const r=t.$options,n=t.$vnode=r._parentVnode,o=n&&n.context;t.$slots=st(r._renderChildren,o),t.$scopedSlots=e,t._c=((e,r,n,o)=>Ot(t,e,r,n,o,!1)),t.$createElement=((e,r,n,o)=>Ot(t,e,r,n,o,!0));const s=n&&n.data;xe(t,"$attrs",s&&s.attrs||e,null,!0),xe(t,"$listeners",r._parentListeners||e,null,!0)}(r),Kt(r,"beforeCreate"),function(e){const t=ot(e.$options.inject,e);t&&(we(!1),Object.keys(t).forEach(r=>{xe(e,r,t[r])}),we(!0))}(r),cr(r),function(e){const t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(r),Kt(r,"created"),r.$options.el&&r.$mount(r.$options.el)}}(gr),function(e){const t={get:function(){return this._data}},r={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",r),e.prototype.$set=qe,e.prototype.$delete=$e,e.prototype.$watch=function(e,t,r){const n=this;if(i(t))return fr(n,e,t,r);(r=r||{}).user=!0;const o=new sr(n,e,t,r);if(r.immediate){ue();try{t.call(n,o.value)}catch(e){Ve(e,n,`callback for immediate watcher "${o.expression}"`)}pe()}return function(){o.teardown()}}}(gr),function(e){const t=/^hook:/;e.prototype.$on=function(e,r){const n=this;if(Array.isArray(e))for(let t=0,o=e.length;t<o;t++)n.$on(e[t],r);else(n._events[e]||(n._events[e]=[])).push(r),t.test(e)&&(n._hasHookEvent=!0);return n},e.prototype.$once=function(e,t){const r=this;function n(){r.$off(e,n),t.apply(r,arguments)}return n.fn=t,r.$on(e,n),r},e.prototype.$off=function(e,t){const r=this;if(!arguments.length)return r._events=Object.create(null),r;if(Array.isArray(e)){for(let n=0,o=e.length;n<o;n++)r.$off(e[n],t);return r}const n=r._events[e];if(!n)return r;if(!t)return r._events[e]=null,r;let o,s=n.length;for(;s--;)if((o=n[s])===t||o.fn===t){n.splice(s,1);break}return r},e.prototype.$emit=function(e){const t=this;let r=t._events[e];if(r){r=r.length>1?$(r):r;const n=$(arguments,1),o=`event handler for "${e}"`;for(let e=0,s=r.length;e<s;e++)Ie(r[e],t,n,t,o)}return t}}(gr),function(e){e.prototype._update=function(e,t){const r=this,n=r.$el,o=r._vnode,s=Gt(r);r._vnode=e,r.$el=o?r.__patch__(o,e):r.__patch__(r.$el,e,t,!1),s(),n&&(n.__vue__=null),r.$el&&(r.$el.__vue__=r),r.$vnode&&r.$parent&&r.$vnode===r.$parent._vnode&&(r.$parent.$el=r.$el)},e.prototype.$forceUpdate=function(){const e=this;e._watcher&&e._watcher.update()},e.prototype.$destroy=function(){const e=this;if(e._isBeingDestroyed)return;Kt(e,"beforeDestroy"),e._isBeingDestroyed=!0;const t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();let r=e._watchers.length;for(;r--;)e._watchers[r].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Kt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}(gr),function(e){qt(e.prototype),e.prototype.$nextTick=function(e){return Ke(e,this)},e.prototype._render=function(){const e=this,{render:t,_parentVnode:r}=e.$options;let n;r&&(e.$scopedSlots=it(r.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=r;try{Ft=e,n=t.call(e._renderProxy,e.$createElement)}catch(t){Ve(t,e,"render"),n=e._vnode}finally{Ft=null}return Array.isArray(n)&&1===n.length&&(n=n[0]),n instanceof de||(n=fe()),n.parent=r,n}}(gr);const Dr=[String,RegExp,Array];var xr={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Dr,exclude:Dr,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const e in this.cache)Ar(this.cache,e,this.keys)},mounted(){this.$watch("include",e=>{wr(this,t=>vr(e,t))}),this.$watch("exclude",e=>{wr(this,t=>!vr(e,t))})},render(){const e=this.$slots.default,t=Vt(e),r=t&&t.componentOptions;if(r){const e=yr(r),{include:n,exclude:o}=this;if(n&&(!e||!vr(n,e))||o&&e&&vr(o,e))return t;const{cache:s,keys:a}=this,i=null==t.key?r.Ctor.cid+(r.tag?`::${r.tag}`:""):t.key;s[i]?(t.componentInstance=s[i].componentInstance,h(a,i),a.push(i)):(s[i]=t,a.push(i),this.max&&a.length>parseInt(this.max)&&Ar(s,a[0],a,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){const t={get:()=>B};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:k,mergeOptions:Te,defineReactive:xe},e.set=qe,e.delete=$e,e.nextTick=Ke,e.observable=(e=>(De(e),e)),e.options=Object.create(null),R.forEach(t=>{e.options[t+"s"]=Object.create(null)}),e.options._base=e,k(e.options.components,xr),function(e){e.use=function(e){const t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;const r=$(arguments,1);return r.unshift(this),"function"==typeof e.install?e.install.apply(e,r):"function"==typeof e&&e.apply(null,r),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Te(this.options,e),this}}(e),br(e),function(e){R.forEach(t=>{e[t]=function(e,r){return r?("component"===t&&i(r)&&(r.name=r.name||e,r=this.options._base.extend(r)),"directive"===t&&"function"==typeof r&&(r={bind:r,update:r}),this.options[t+"s"][e]=r,r):this.options[t+"s"][e]}})}(e)}(gr),Object.defineProperty(gr.prototype,"$isServer",{get:te}),Object.defineProperty(gr.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(gr,"FunctionalRenderContext",{value:$t}),gr.version="2.6.12";const qr=d("style,class"),$r=d("input,textarea,option,select,progress"),kr=(e,t,r)=>"value"===r&&$r(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e,Er=d("contenteditable,draggable,spellcheck"),_r=d("events,caret,typing,plaintext-only"),Cr=(e,t)=>Or(t)||"false"===t?"false":"contenteditable"===e&&_r(t)?t:"true",Sr=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Lr="http://www.w3.org/1999/xlink",Tr=e=>":"===e.charAt(5)&&"xlink"===e.slice(0,5),Nr=e=>Tr(e)?e.slice(6,e.length):"",Or=e=>null==e||!1===e;function Rr(e){let t=e.data,n=e,o=e;for(;r(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(t=Fr(o.data,t));for(;r(n=n.parent);)n&&n.data&&(t=Fr(t,n.data));return function(e,t){if(r(e)||r(t))return Br(e,Ur(t));return""}(t.staticClass,t.class)}function Fr(e,t){return{staticClass:Br(e.staticClass,t.staticClass),class:r(e.class)?[e.class,t.class]:t.class}}function Br(e,t){return e?t?e+" "+t:e:t||""}function Ur(e){return Array.isArray(e)?function(e){let t,n="";for(let o=0,s=e.length;o<s;o++)r(t=Ur(e[o]))&&""!==t&&(n&&(n+=" "),n+=t);return n}(e):s(e)?function(e){let t="";for(const r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}const Vr={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Ir=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),jr=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Pr=e=>Ir(e)||jr(e);function Hr(e){return jr(e)?"svg":"math"===e?"math":void 0}const Mr=Object.create(null);const Gr=d("text,number,password,search,email,tel,url");function zr(e){if("string"==typeof e){const t=document.querySelector(e);return t||document.createElement("div")}return e}var Jr=Object.freeze({createElement:function(e,t){const r=document.createElement(e);return"select"!==e?r:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&r.setAttribute("multiple","multiple"),r)},createElementNS:function(e,t){return document.createElementNS(Vr[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,r){e.insertBefore(t,r)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Kr={create(e,t){Zr(t)},update(e,t){e.data.ref!==t.data.ref&&(Zr(e,!0),Zr(t))},destroy(e){Zr(e,!0)}};function Zr(e,t){const n=e.data.ref;if(!r(n))return;const o=e.context,s=e.componentInstance||e.elm,a=o.$refs;t?Array.isArray(a[n])?h(a[n],s):a[n]===s&&(a[n]=void 0):e.data.refInFor?Array.isArray(a[n])?a[n].indexOf(s)<0&&a[n].push(s):a[n]=[s]:a[n]=s}const Yr=new de("",{},[]),Wr=["create","activate","update","remove","destroy"];function Qr(e,o){return e.key===o.key&&(e.tag===o.tag&&e.isComment===o.isComment&&r(e.data)===r(o.data)&&function(e,t){if("input"!==e.tag)return!0;let n;const o=r(n=e.data)&&r(n=n.attrs)&&n.type,s=r(n=t.data)&&r(n=n.attrs)&&n.type;return o===s||Gr(o)&&Gr(s)}(e,o)||n(e.isAsyncPlaceholder)&&e.asyncFactory===o.asyncFactory&&t(o.asyncFactory.error))}function Xr(e,t,n){let o,s;const a={};for(o=t;o<=n;++o)r(s=e[o].key)&&(a[s]=o);return a}var en={create:tn,update:tn,destroy:function(e){tn(e,Yr)}};function tn(e,t){(e.data.directives||t.data.directives)&&function(e,t){const r=e===Yr,n=t===Yr,o=nn(e.data.directives,e.context),s=nn(t.data.directives,t.context),a=[],i=[];let c,l,u;for(c in s)l=o[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,sn(u,"update",t,e),u.def&&u.def.componentUpdated&&i.push(u)):(sn(u,"bind",t,e),u.def&&u.def.inserted&&a.push(u));if(a.length){const n=()=>{for(let r=0;r<a.length;r++)sn(a[r],"inserted",t,e)};r?et(t,"insert",n):n()}i.length&&et(t,"postpatch",()=>{for(let r=0;r<i.length;r++)sn(i[r],"componentUpdated",t,e)});if(!r)for(c in o)s[c]||sn(o[c],"unbind",e,e,n)}(e,t)}const rn=Object.create(null);function nn(e,t){const r=Object.create(null);if(!e)return r;let n,o;for(n=0;n<e.length;n++)(o=e[n]).modifiers||(o.modifiers=rn),r[on(o)]=o,o.def=Ne(t.$options,"directives",o.name);return r}function on(e){return e.rawName||`${e.name}.${Object.keys(e.modifiers||{}).join(".")}`}function sn(e,t,r,n,o){const s=e.def&&e.def[t];if(s)try{s(r.elm,e,r,n,o)}catch(n){Ve(n,r.context,`directive ${e.name} ${t} hook`)}}var an=[Kr,en];function cn(e,n){const o=n.componentOptions;if(r(o)&&!1===o.Ctor.options.inheritAttrs)return;if(t(e.data.attrs)&&t(n.data.attrs))return;let s,a,i;const c=n.elm,l=e.data.attrs||{};let u=n.data.attrs||{};for(s in r(u.__ob__)&&(u=n.data.attrs=k({},u)),u)a=u[s],(i=l[s])!==a&&ln(c,s,a,n.data.pre);for(s in(J||Z)&&u.value!==l.value&&ln(c,"value",u.value),l)t(u[s])&&(Tr(s)?c.removeAttributeNS(Lr,Nr(s)):Er(s)||c.removeAttribute(s))}function ln(e,t,r,n){n||e.tagName.indexOf("-")>-1?un(e,t,r):Sr(t)?Or(r)?e.removeAttribute(t):(r="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,r)):Er(t)?e.setAttribute(t,Cr(t,r)):Tr(t)?Or(r)?e.removeAttributeNS(Lr,Nr(t)):e.setAttributeNS(Lr,t,r):un(e,t,r)}function un(e,t,r){if(Or(r))e.removeAttribute(t);else{if(J&&!K&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==r&&!e.__ieph){const t=r=>{r.stopImmediatePropagation(),e.removeEventListener("input",t)};e.addEventListener("input",t),e.__ieph=!0}e.setAttribute(t,r)}}var pn={create:cn,update:cn};function dn(e,n){const o=n.elm,s=n.data,a=e.data;if(t(s.staticClass)&&t(s.class)&&(t(a)||t(a.staticClass)&&t(a.class)))return;let i=Rr(n);const c=o._transitionClasses;r(c)&&(i=Br(i,Ur(c))),i!==o._prevClass&&(o.setAttribute("class",i),o._prevClass=i)}var fn={create:dn,update:dn};const mn=/[\w).+\-_$\]]/;function hn(e){let t,r,n,o,s,a=!1,i=!1,c=!1,l=!1,u=0,p=0,d=0,f=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(i)34===t&&92!==r&&(i=!1);else if(c)96===t&&92!==r&&(c=!1);else if(l)47===t&&92!==r&&(l=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||u||p||d){switch(t){case 34:i=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:p++;break;case 93:p--;break;case 123:u++;break;case 125:u--}if(47===t){let t,r=n-1;for(;r>=0&&" "===(t=e.charAt(r));r--);t&&mn.test(t)||(l=!0)}}else void 0===o?(f=n+1,o=e.slice(0,n).trim()):m();function m(){(s||(s=[])).push(e.slice(f,n).trim()),f=n+1}if(void 0===o?o=e.slice(0,n).trim():0!==f&&m(),s)for(n=0;n<s.length;n++)o=gn(o,s[n]);return o}function gn(e,t){const r=t.indexOf("(");if(r<0)return`_f("${t}")(${e})`;{const n=t.slice(0,r),o=t.slice(r+1);return`_f("${n}")(${e}${")"!==o?","+o:o}`}}function bn(e,t){console.error(`[Vue compiler]: ${e}`)}function yn(e,t){return e?e.map(e=>e[t]).filter(e=>e):[]}function vn(e,t,r,n,o){(e.props||(e.props=[])).push(_n({name:t,value:r,dynamic:o},n)),e.plain=!1}function wn(e,t,r,n,o){(o?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(_n({name:t,value:r,dynamic:o},n)),e.plain=!1}function An(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(_n({name:t,value:r},n))}function Dn(e,t,r,n,o,s,a,i){(e.directives||(e.directives=[])).push(_n({name:t,rawName:r,value:n,arg:o,isDynamicArg:s,modifiers:a},i)),e.plain=!1}function xn(e,t,r){return r?`_p(${t},"${e}")`:e+t}function qn(t,r,n,o,s,a,i,c){let l;(o=o||e).right?c?r=`(${r})==='click'?'contextmenu':(${r})`:"click"===r&&(r="contextmenu",delete o.right):o.middle&&(c?r=`(${r})==='click'?'mouseup':(${r})`:"click"===r&&(r="mouseup")),o.capture&&(delete o.capture,r=xn("!",r,c)),o.once&&(delete o.once,r=xn("~",r,c)),o.passive&&(delete o.passive,r=xn("&",r,c)),o.native?(delete o.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});const u=_n({value:n.trim(),dynamic:c},i);o!==e&&(u.modifiers=o);const p=l[r];Array.isArray(p)?s?p.unshift(u):p.push(u):l[r]=p?s?[u,p]:[p,u]:u,t.plain=!1}function $n(e,t,r){const n=kn(e,":"+t)||kn(e,"v-bind:"+t);if(null!=n)return hn(n);if(!1!==r){const r=kn(e,t);if(null!=r)return JSON.stringify(r)}}function kn(e,t,r){let n;if(null!=(n=e.attrsMap[t])){const r=e.attrsList;for(let e=0,n=r.length;e<n;e++)if(r[e].name===t){r.splice(e,1);break}}return r&&delete e.attrsMap[t],n}function En(e,t){const r=e.attrsList;for(let e=0,n=r.length;e<n;e++){const n=r[e];if(t.test(n.name))return r.splice(e,1),n}}function _n(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Cn(e,t,r){const{number:n,trim:o}=r||{};let s="$$v";o&&(s="(typeof $$v === 'string'? $$v.trim(): $$v)"),n&&(s=`_n(${s})`);const a=Sn(t,s);e.model={value:`(${t})`,expression:JSON.stringify(t),callback:`function ($$v) {${a}}`}}function Sn(e,t){const r=function(e){if(e=e.trim(),Ln=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Ln-1)return(On=e.lastIndexOf("."))>-1?{exp:e.slice(0,On),key:'"'+e.slice(On+1)+'"'}:{exp:e,key:null};Tn=e,On=Rn=Fn=0;for(;!Un();)Vn(Nn=Bn())?jn(Nn):91===Nn&&In(Nn);return{exp:e.slice(0,Rn),key:e.slice(Rn+1,Fn)}}(e);return null===r.key?`${e}=${t}`:`$set(${r.exp}, ${r.key}, ${t})`}let Ln,Tn,Nn,On,Rn,Fn;function Bn(){return Tn.charCodeAt(++On)}function Un(){return On>=Ln}function Vn(e){return 34===e||39===e}function In(e){let t=1;for(Rn=On;!Un();)if(Vn(e=Bn()))jn(e);else if(91===e&&t++,93===e&&t--,0===t){Fn=On;break}}function jn(e){const t=e;for(;!Un()&&(e=Bn())!==t;);}const Pn="__r",Hn="__c";let Mn;function Gn(e,t,r){const n=Mn;return function o(){null!==t.apply(null,arguments)&&Kn(e,o,r,n)}}const zn=He&&!(W&&Number(W[1])<=53);function Jn(e,t,r,n){if(zn){const e=tr,r=t;t=r._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=e||t.timeStamp<=0||t.target.ownerDocument!==document)return r.apply(this,arguments)}}Mn.addEventListener(e,t,ee?{capture:r,passive:n}:r)}function Kn(e,t,r,n){(n||Mn).removeEventListener(e,t._wrapper||t,r)}function Zn(e,n){if(t(e.data.on)&&t(n.data.on))return;const o=n.data.on||{},s=e.data.on||{};Mn=n.elm,function(e){if(r(e[Pn])){const t=J?"change":"input";e[t]=[].concat(e[Pn],e[t]||[]),delete e[Pn]}r(e[Hn])&&(e.change=[].concat(e[Hn],e.change||[]),delete e[Hn])}(o),Xe(o,s,Jn,Kn,Gn,n.context),Mn=void 0}var Yn={create:Zn,update:Zn};let Wn;function Qn(e,n){if(t(e.data.domProps)&&t(n.data.domProps))return;let o,s;const a=n.elm,i=e.data.domProps||{};let c=n.data.domProps||{};for(o in r(c.__ob__)&&(c=n.data.domProps=k({},c)),i)o in c||(a[o]="");for(o in c){if(s=c[o],"textContent"===o||"innerHTML"===o){if(n.children&&(n.children.length=0),s===i[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=s;const e=t(s)?"":String(s);Xn(a,e)&&(a.value=e)}else if("innerHTML"===o&&jr(a.tagName)&&t(a.innerHTML)){(Wn=Wn||document.createElement("div")).innerHTML=`<svg>${s}</svg>`;const e=Wn.firstChild;for(;a.firstChild;)a.removeChild(a.firstChild);for(;e.firstChild;)a.appendChild(e.firstChild)}else if(s!==i[o])try{a[o]=s}catch(e){}}}function Xn(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){let r=!0;try{r=document.activeElement!==e}catch(e){}return r&&e.value!==t}(e,t)||function(e,t){const n=e.value,o=e._vModifiers;if(r(o)){if(o.number)return p(n)!==p(t);if(o.trim)return n.trim()!==t.trim()}return n!==t}(e,t))}var eo={create:Qn,update:Qn};const to=y(function(e){const t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){const n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function ro(e){const t=no(e.style);return e.staticStyle?k(e.staticStyle,t):t}function no(e){return Array.isArray(e)?E(e):"string"==typeof e?to(e):e}const oo=/^--/,so=/\s*!important$/,ao=(e,t,r)=>{if(oo.test(t))e.style.setProperty(t,r);else if(so.test(r))e.style.setProperty(x(t),r.replace(so,""),"important");else{const n=lo(t);if(Array.isArray(r))for(let t=0,o=r.length;t<o;t++)e.style[n]=r[t];else e.style[n]=r}},io=["Webkit","Moz","ms"];let co;const lo=y(function(e){if(co=co||document.createElement("div").style,"filter"!==(e=w(e))&&e in co)return e;const t=e.charAt(0).toUpperCase()+e.slice(1);for(let e=0;e<io.length;e++){const r=io[e]+t;if(r in co)return r}});function uo(e,n){const o=n.data,s=e.data;if(t(o.staticStyle)&&t(o.style)&&t(s.staticStyle)&&t(s.style))return;let a,i;const c=n.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},p=l||u,d=no(n.data.style)||{};n.data.normalizedStyle=r(d.__ob__)?k({},d):d;const f=function(e,t){const r={};let n;if(t){let t=e;for(;t.componentInstance;)(t=t.componentInstance._vnode)&&t.data&&(n=ro(t.data))&&k(r,n)}(n=ro(e.data))&&k(r,n);let o=e;for(;o=o.parent;)o.data&&(n=ro(o.data))&&k(r,n);return r}(n,!0);for(i in p)t(f[i])&&ao(c,i,"");for(i in f)(a=f[i])!==p[i]&&ao(c,i,null==a?"":a)}var po={create:uo,update:uo};const fo=/\s+/;function mo(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(fo).forEach(t=>e.classList.add(t)):e.classList.add(t);else{const r=` ${e.getAttribute("class")||""} `;r.indexOf(" "+t+" ")<0&&e.setAttribute("class",(r+t).trim())}}function ho(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(fo).forEach(t=>e.classList.remove(t)):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{let r=` ${e.getAttribute("class")||""} `;const n=" "+t+" ";for(;r.indexOf(n)>=0;)r=r.replace(n," ");(r=r.trim())?e.setAttribute("class",r):e.removeAttribute("class")}}function go(e){if(e){if("object"==typeof e){const t={};return!1!==e.css&&k(t,bo(e.name||"v")),k(t,e),t}return"string"==typeof e?bo(e):void 0}}const bo=y(e=>({enterClass:`${e}-enter`,enterToClass:`${e}-enter-to`,enterActiveClass:`${e}-enter-active`,leaveClass:`${e}-leave`,leaveToClass:`${e}-leave-to`,leaveActiveClass:`${e}-leave-active`})),yo=H&&!K,vo="transition",wo="animation";let Ao="transition",Do="transitionend",xo="animation",qo="animationend";yo&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ao="WebkitTransition",Do="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(xo="WebkitAnimation",qo="webkitAnimationEnd"));const $o=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:e=>e();function ko(e){$o(()=>{$o(e)})}function Eo(e,t){const r=e._transitionClasses||(e._transitionClasses=[]);r.indexOf(t)<0&&(r.push(t),mo(e,t))}function _o(e,t){e._transitionClasses&&h(e._transitionClasses,t),ho(e,t)}function Co(e,t,r){const{type:n,timeout:o,propCount:s}=Lo(e,t);if(!n)return r();const a=n===vo?Do:qo;let i=0;const c=()=>{e.removeEventListener(a,l),r()},l=t=>{t.target===e&&++i>=s&&c()};setTimeout(()=>{i<s&&c()},o+1),e.addEventListener(a,l)}const So=/\b(transform|all)(,|$)/;function Lo(e,t){const r=window.getComputedStyle(e),n=(r[Ao+"Delay"]||"").split(", "),o=(r[Ao+"Duration"]||"").split(", "),s=To(n,o),a=(r[xo+"Delay"]||"").split(", "),i=(r[xo+"Duration"]||"").split(", "),c=To(a,i);let l,u=0,p=0;return t===vo?s>0&&(l=vo,u=s,p=o.length):t===wo?c>0&&(l=wo,u=c,p=i.length):p=(l=(u=Math.max(s,c))>0?s>c?vo:wo:null)?l===vo?o.length:i.length:0,{type:l,timeout:u,propCount:p,hasTransform:l===vo&&So.test(r[Ao+"Property"])}}function To(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((t,r)=>No(t)+No(e[r])))}function No(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Oo(e,n){const o=e.elm;r(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());const a=go(e.data.transition);if(t(a))return;if(r(o._enterCb)||1!==o.nodeType)return;const{css:i,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:f,appearToClass:m,appearActiveClass:h,beforeEnter:g,enter:b,afterEnter:y,enterCancelled:v,beforeAppear:w,appear:A,afterAppear:D,appearCancelled:x,duration:q}=a;let $=Mt,k=Mt.$vnode;for(;k&&k.parent;)$=k.context,k=k.parent;const E=!$._isMounted||!e.isRootInsert;if(E&&!A&&""!==A)return;const _=E&&f?f:l,C=E&&h?h:d,S=E&&m?m:u,L=E&&w||g,T=E&&"function"==typeof A?A:b,O=E&&D||y,R=E&&x||v,F=p(s(q)?q.enter:q),B=!1!==i&&!K,U=Bo(T),V=o._enterCb=N(()=>{B&&(_o(o,S),_o(o,C)),V.cancelled?(B&&_o(o,_),R&&R(o)):O&&O(o),o._enterCb=null});e.data.show||et(e,"insert",()=>{const t=o.parentNode,r=t&&t._pending&&t._pending[e.key];r&&r.tag===e.tag&&r.elm._leaveCb&&r.elm._leaveCb(),T&&T(o,V)}),L&&L(o),B&&(Eo(o,_),Eo(o,C),ko(()=>{_o(o,_),V.cancelled||(Eo(o,S),U||(Fo(F)?setTimeout(V,F):Co(o,c,V)))})),e.data.show&&(n&&n(),T&&T(o,V)),B||U||V()}function Ro(e,n){const o=e.elm;r(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());const a=go(e.data.transition);if(t(a)||1!==o.nodeType)return n();if(r(o._leaveCb))return;const{css:i,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:f,leave:m,afterLeave:h,leaveCancelled:g,delayLeave:b,duration:y}=a,v=!1!==i&&!K,w=Bo(m),A=p(s(y)?y.leave:y),D=o._leaveCb=N(()=>{o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[e.key]=null),v&&(_o(o,u),_o(o,d)),D.cancelled?(v&&_o(o,l),g&&g(o)):(n(),h&&h(o)),o._leaveCb=null});function x(){D.cancelled||(!e.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[e.key]=e),f&&f(o),v&&(Eo(o,l),Eo(o,d),ko(()=>{_o(o,l),D.cancelled||(Eo(o,u),w||(Fo(A)?setTimeout(D,A):Co(o,c,D)))})),m&&m(o,D),v||w||D())}b?b(x):x()}function Fo(e){return"number"==typeof e&&!isNaN(e)}function Bo(e){if(t(e))return!1;const n=e.fns;return r(n)?Bo(Array.isArray(n)?n[0]:n):(e._length||e.length)>1}function Uo(e,t){!0!==t.data.show&&Oo(t)}const Vo=function(e){let s,a;const i={},{modules:c,nodeOps:l}=e;for(s=0;s<Wr.length;++s)for(i[Wr[s]]=[],a=0;a<c.length;++a)r(c[a][Wr[s]])&&i[Wr[s]].push(c[a][Wr[s]]);function u(e){const t=l.parentNode(e);r(t)&&l.removeChild(t,e)}function p(e,t,o,s,a,c,u){if(r(e.elm)&&r(c)&&(e=c[u]=he(e)),e.isRootInsert=!a,function(e,t,o,s){let a=e.data;if(r(a)){const c=r(e.componentInstance)&&a.keepAlive;if(r(a=a.hook)&&r(a=a.init)&&a(e,!1),r(e.componentInstance))return f(e,t),m(o,e.elm,s),n(c)&&function(e,t,n,o){let s,a=e;for(;a.componentInstance;)if(a=a.componentInstance._vnode,r(s=a.data)&&r(s=s.transition)){for(s=0;s<i.activate.length;++s)i.activate[s](Yr,a);t.push(a);break}m(n,e.elm,o)}(e,t,o,s),!0}}(e,t,o,s))return;const p=e.data,d=e.children,g=e.tag;r(g)?(e.elm=e.ns?l.createElementNS(e.ns,g):l.createElement(g,e),y(e),h(e,d,t),r(p)&&b(e,t),m(o,e.elm,s)):n(e.isComment)?(e.elm=l.createComment(e.text),m(o,e.elm,s)):(e.elm=l.createTextNode(e.text),m(o,e.elm,s))}function f(e,t){r(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,g(e)?(b(e,t),y(e)):(Zr(e),t.push(e))}function m(e,t,n){r(e)&&(r(n)?l.parentNode(n)===e&&l.insertBefore(e,t,n):l.appendChild(e,t))}function h(e,t,r){if(Array.isArray(t))for(let n=0;n<t.length;++n)p(t[n],r,e.elm,null,!0,t,n);else o(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function g(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return r(e.tag)}function b(e,t){for(let t=0;t<i.create.length;++t)i.create[t](Yr,e);r(s=e.data.hook)&&(r(s.create)&&s.create(Yr,e),r(s.insert)&&t.push(e))}function y(e){let t;if(r(t=e.fnScopeId))l.setStyleScope(e.elm,t);else{let n=e;for(;n;)r(t=n.context)&&r(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),n=n.parent}r(t=Mt)&&t!==e.context&&t!==e.fnContext&&r(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function v(e,t,r,n,o,s){for(;n<=o;++n)p(r[n],s,e,t,!1,r,n)}function w(e){let t,n;const o=e.data;if(r(o))for(r(t=o.hook)&&r(t=t.destroy)&&t(e),t=0;t<i.destroy.length;++t)i.destroy[t](e);if(r(t=e.children))for(n=0;n<e.children.length;++n)w(e.children[n])}function A(e,t,n){for(;t<=n;++t){const n=e[t];r(n)&&(r(n.tag)?(D(n),w(n)):u(n.elm))}}function D(e,t){if(r(t)||r(e.data)){let n;const o=i.remove.length+1;for(r(t)?t.listeners+=o:t=function(e,t){function r(){0==--r.listeners&&u(e)}return r.listeners=t,r}(e.elm,o),r(n=e.componentInstance)&&r(n=n._vnode)&&r(n.data)&&D(n,t),n=0;n<i.remove.length;++n)i.remove[n](e,t);r(n=e.data.hook)&&r(n=n.remove)?n(e,t):t()}else u(e.elm)}function x(e,t,n,o){for(let s=n;s<o;s++){const n=t[s];if(r(n)&&Qr(e,n))return s}}function q(e,o,s,a,c,u){if(e===o)return;r(o.elm)&&r(a)&&(o=a[c]=he(o));const d=o.elm=e.elm;if(n(e.isAsyncPlaceholder))return void(r(o.asyncFactory.resolved)?E(e.elm,o,s):o.isAsyncPlaceholder=!0);if(n(o.isStatic)&&n(e.isStatic)&&o.key===e.key&&(n(o.isCloned)||n(o.isOnce)))return void(o.componentInstance=e.componentInstance);let f;const m=o.data;r(m)&&r(f=m.hook)&&r(f=f.prepatch)&&f(e,o);const h=e.children,b=o.children;if(r(m)&&g(o)){for(f=0;f<i.update.length;++f)i.update[f](e,o);r(f=m.hook)&&r(f=f.update)&&f(e,o)}t(o.text)?r(h)&&r(b)?h!==b&&function(e,n,o,s,a){let i,c,u,d,f=0,m=0,h=n.length-1,g=n[0],b=n[h],y=o.length-1,w=o[0],D=o[y];const $=!a;for(;f<=h&&m<=y;)t(g)?g=n[++f]:t(b)?b=n[--h]:Qr(g,w)?(q(g,w,s,o,m),g=n[++f],w=o[++m]):Qr(b,D)?(q(b,D,s,o,y),b=n[--h],D=o[--y]):Qr(g,D)?(q(g,D,s,o,y),$&&l.insertBefore(e,g.elm,l.nextSibling(b.elm)),g=n[++f],D=o[--y]):Qr(b,w)?(q(b,w,s,o,m),$&&l.insertBefore(e,b.elm,g.elm),b=n[--h],w=o[++m]):(t(i)&&(i=Xr(n,f,h)),t(c=r(w.key)?i[w.key]:x(w,n,f,h))?p(w,s,e,g.elm,!1,o,m):Qr(u=n[c],w)?(q(u,w,s,o,m),n[c]=void 0,$&&l.insertBefore(e,u.elm,g.elm)):p(w,s,e,g.elm,!1,o,m),w=o[++m]);f>h?v(e,d=t(o[y+1])?null:o[y+1].elm,o,m,y,s):m>y&&A(n,f,h)}(d,h,b,s,u):r(b)?(r(e.text)&&l.setTextContent(d,""),v(d,null,b,0,b.length-1,s)):r(h)?A(h,0,h.length-1):r(e.text)&&l.setTextContent(d,""):e.text!==o.text&&l.setTextContent(d,o.text),r(m)&&r(f=m.hook)&&r(f=f.postpatch)&&f(e,o)}function $(e,t,o){if(n(o)&&r(e.parent))e.parent.data.pendingInsert=t;else for(let e=0;e<t.length;++e)t[e].data.hook.insert(t[e])}const k=d("attrs,class,staticClass,staticStyle,key");function E(e,t,o,s){let a;const{tag:i,data:c,children:l}=t;if(s=s||c&&c.pre,t.elm=e,n(t.isComment)&&r(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(r(c)&&(r(a=c.hook)&&r(a=a.init)&&a(t,!0),r(a=t.componentInstance)))return f(t,o),!0;if(r(i)){if(r(l))if(e.hasChildNodes())if(r(a=c)&&r(a=a.domProps)&&r(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{let t=!0,r=e.firstChild;for(let e=0;e<l.length;e++){if(!r||!E(r,l[e],o,s)){t=!1;break}r=r.nextSibling}if(!t||r)return!1}else h(t,l,o);if(r(c)){let e=!1;for(const r in c)if(!k(r)){e=!0,b(t,o);break}!e&&c.class&&Ye(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,o,s,a){if(t(o))return void(r(e)&&w(e));let c=!1;const u=[];if(t(e))c=!0,p(o,u);else{const t=r(e.nodeType);if(!t&&Qr(e,o))q(e,o,u,null,null,a);else{if(t){if(1===e.nodeType&&e.hasAttribute(O)&&(e.removeAttribute(O),s=!0),n(s)&&E(e,o,u))return $(o,u,!0),e;d=e,e=new de(l.tagName(d).toLowerCase(),{},[],void 0,d)}const a=e.elm,c=l.parentNode(a);if(p(o,u,a._leaveCb?null:c,l.nextSibling(a)),r(o.parent)){let e=o.parent;const t=g(o);for(;e;){for(let t=0;t<i.destroy.length;++t)i.destroy[t](e);if(e.elm=o.elm,t){for(let t=0;t<i.create.length;++t)i.create[t](Yr,e);const t=e.data.hook.insert;if(t.merged)for(let e=1;e<t.fns.length;e++)t.fns[e]()}else Zr(e);e=e.parent}}r(c)?A([e],0,0):r(e.tag)&&w(e)}}var d;return $(o,u,c),o.elm}}({nodeOps:Jr,modules:[pn,fn,Yn,eo,po,H?{create:Uo,activate:Uo,remove(e,t){!0!==e.data.show?Ro(e,t):t()}}:{}].concat(an)});K&&document.addEventListener("selectionchange",()=>{const e=document.activeElement;e&&e.vmodel&&Jo(e,"input")});const Io={inserted(e,t,r,n){"select"===r.tag?(n.elm&&!n.elm._vOptions?et(r,"postpatch",()=>{Io.componentUpdated(e,t,r)}):jo(e,t,r.context),e._vOptions=[].map.call(e.options,Mo)):("textarea"===r.tag||Gr(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Go),e.addEventListener("compositionend",zo),e.addEventListener("change",zo),K&&(e.vmodel=!0)))},componentUpdated(e,t,r){if("select"===r.tag){jo(e,t,r.context);const n=e._vOptions,o=e._vOptions=[].map.call(e.options,Mo);if(o.some((e,t)=>!L(e,n[t]))){(e.multiple?t.value.some(e=>Ho(e,o)):t.value!==t.oldValue&&Ho(t.value,o))&&Jo(e,"change")}}}};function jo(e,t,r){Po(e,t,r),(J||Z)&&setTimeout(()=>{Po(e,t,r)},0)}function Po(e,t,r){const n=t.value,o=e.multiple;if(o&&!Array.isArray(n))return;let s,a;for(let t=0,r=e.options.length;t<r;t++)if(a=e.options[t],o)s=T(n,Mo(a))>-1,a.selected!==s&&(a.selected=s);else if(L(Mo(a),n))return void(e.selectedIndex!==t&&(e.selectedIndex=t));o||(e.selectedIndex=-1)}function Ho(e,t){return t.every(t=>!L(t,e))}function Mo(e){return"_value"in e?e._value:e.value}function Go(e){e.target.composing=!0}function zo(e){e.target.composing&&(e.target.composing=!1,Jo(e.target,"input"))}function Jo(e,t){const r=document.createEvent("HTMLEvents");r.initEvent(t,!0,!0),e.dispatchEvent(r)}function Ko(e){return!e.componentInstance||e.data&&e.data.transition?e:Ko(e.componentInstance._vnode)}var Zo={model:Io,show:{bind(e,{value:t},r){const n=(r=Ko(r)).data&&r.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;t&&n?(r.data.show=!0,Oo(r,()=>{e.style.display=o})):e.style.display=t?o:"none"},update(e,{value:t,oldValue:r},n){if(!t==!r)return;(n=Ko(n)).data&&n.data.transition?(n.data.show=!0,t?Oo(n,()=>{e.style.display=e.__vOriginalDisplay}):Ro(n,()=>{e.style.display="none"})):e.style.display=t?e.__vOriginalDisplay:"none"},unbind(e,t,r,n,o){o||(e.style.display=e.__vOriginalDisplay)}}};const Yo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Wo(e){const t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?Wo(Vt(t.children)):e}function Qo(e){const t={},r=e.$options;for(const n in r.propsData)t[n]=e[n];const n=r._parentListeners;for(const e in n)t[w(e)]=n[e];return t}function Xo(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}const es=e=>e.tag||Ut(e),ts=e=>"show"===e.name;var rs={name:"transition",props:Yo,abstract:!0,render(e){let t=this.$slots.default;if(!t)return;if(!(t=t.filter(es)).length)return;const r=this.mode,n=t[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return n;const s=Wo(n);if(!s)return n;if(this._leaving)return Xo(e,n);const a=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?a+"comment":a+s.tag:o(s.key)?0===String(s.key).indexOf(a)?s.key:a+s.key:s.key;const i=(s.data||(s.data={})).transition=Qo(this),c=this._vnode,l=Wo(c);if(s.data.directives&&s.data.directives.some(ts)&&(s.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(s,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const t=l.data.transition=k({},i);if("out-in"===r)return this._leaving=!0,et(t,"afterLeave",()=>{this._leaving=!1,this.$forceUpdate()}),Xo(e,n);if("in-out"===r){if(Ut(s))return c;let e;const r=()=>{e()};et(i,"afterEnter",r),et(i,"enterCancelled",r),et(t,"delayLeave",t=>{e=t})}}return n}};const ns=k({tag:String,moveClass:String},Yo);function os(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function ss(e){e.data.newPos=e.elm.getBoundingClientRect()}function as(e){const t=e.data.pos,r=e.data.newPos,n=t.left-r.left,o=t.top-r.top;if(n||o){e.data.moved=!0;const t=e.elm.style;t.transform=t.WebkitTransform=`translate(${n}px,${o}px)`,t.transitionDuration="0s"}}delete ns.mode;var is={Transition:rs,TransitionGroup:{props:ns,beforeMount(){const e=this._update;this._update=((t,r)=>{const n=Gt(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,n(),e.call(this,t,r)})},render(e){const t=this.tag||this.$vnode.data.tag||"span",r=Object.create(null),n=this.prevChildren=this.children,o=this.$slots.default||[],s=this.children=[],a=Qo(this);for(let e=0;e<o.length;e++){const t=o[e];t.tag&&null!=t.key&&0!==String(t.key).indexOf("__vlist")&&(s.push(t),r[t.key]=t,(t.data||(t.data={})).transition=a)}if(n){const o=[],s=[];for(let e=0;e<n.length;e++){const t=n[e];t.data.transition=a,t.data.pos=t.elm.getBoundingClientRect(),r[t.key]?o.push(t):s.push(t)}this.kept=e(t,null,o),this.removed=s}return e(t,null,s)},updated(){const e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(os),e.forEach(ss),e.forEach(as),this._reflow=document.body.offsetHeight,e.forEach(e=>{if(e.data.moved){const r=e.elm,n=r.style;Eo(r,t),n.transform=n.WebkitTransform=n.transitionDuration="",r.addEventListener(Do,r._moveCb=function e(n){n&&n.target!==r||n&&!/transform$/.test(n.propertyName)||(r.removeEventListener(Do,e),r._moveCb=null,_o(r,t))})}}))},methods:{hasMove(e,t){if(!yo)return!1;if(this._hasMove)return this._hasMove;const r=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(e=>{ho(r,e)}),mo(r,t),r.style.display="none",this.$el.appendChild(r);const n=Lo(r);return this.$el.removeChild(r),this._hasMove=n.hasTransform}}}};gr.config.mustUseProp=kr,gr.config.isReservedTag=Pr,gr.config.isReservedAttr=qr,gr.config.getTagNamespace=Hr,gr.config.isUnknownElement=function(e){if(!H)return!0;if(Pr(e))return!1;if(e=e.toLowerCase(),null!=Mr[e])return Mr[e];const t=document.createElement(e);return e.indexOf("-")>-1?Mr[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Mr[e]=/HTMLUnknownElement/.test(t.toString())},k(gr.options.directives,Zo),k(gr.options.components,is),gr.prototype.__patch__=H?Vo:_,gr.prototype.$mount=function(e,t){return function(e,t,r){let n;return e.$el=t,e.$options.render||(e.$options.render=fe),Kt(e,"beforeMount"),n=(()=>{e._update(e._render(),r)}),new sr(e,n,_,{before(){e._isMounted&&!e._isDestroyed&&Kt(e,"beforeUpdate")}},!0),r=!1,null==e.$vnode&&(e._isMounted=!0,Kt(e,"mounted")),e}(this,e=e&&H?zr(e):void 0,t)},H&&setTimeout(()=>{B.devtools&&re&&re.emit("init",gr)},0);const cs=/\{\{((?:.|\r?\n)+?)\}\}/g,ls=/[-.*+?^${}()|[\]\/\\]/g,us=y(e=>{const t=e[0].replace(ls,"\\$&"),r=e[1].replace(ls,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});var ps={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;const r=kn(e,"class");r&&(e.staticClass=JSON.stringify(r));const n=$n(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){let t="";return e.staticClass&&(t+=`staticClass:${e.staticClass},`),e.classBinding&&(t+=`class:${e.classBinding},`),t}};var ds={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;const r=kn(e,"style");r&&(e.staticStyle=JSON.stringify(to(r)));const n=$n(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){let t="";return e.staticStyle&&(t+=`staticStyle:${e.staticStyle},`),e.styleBinding&&(t+=`style:(${e.styleBinding}),`),t}};!function(e){var t="object"==typeof exports&&exports,r="object"==typeof module&&module&&module.exports==t&&module,n="object"==typeof global&&global;n.global!==n&&n.window!==n||(e=n);var o=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,s=/[\x01-\x7F]/g,a=/[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,i=/<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g,c={"\xad":"shy","\u200c":"zwnj","\u200d":"zwj","\u200e":"lrm","\u2063":"ic","\u2062":"it","\u2061":"af","\u200f":"rlm","\u200b":"ZeroWidthSpace","\u2060":"NoBreak","\u0311":"DownBreve","\u20db":"tdot","\u20dc":"DotDot","\t":"Tab","\n":"NewLine","\u2008":"puncsp","\u205f":"MediumSpace","\u2009":"thinsp","\u200a":"hairsp","\u2004":"emsp13","\u2002":"ensp","\u2005":"emsp14","\u2003":"emsp","\u2007":"numsp","\xa0":"nbsp","\u205f\u200a":"ThickSpace","\u203e":"oline",_:"lowbar","\u2010":"dash","\u2013":"ndash","\u2014":"mdash","\u2015":"horbar",",":"comma",";":"semi","\u204f":"bsemi",":":"colon","\u2a74":"Colone","!":"excl","\xa1":"iexcl","?":"quest","\xbf":"iquest",".":"period","\u2025":"nldr","\u2026":"mldr","\xb7":"middot","'":"apos","\u2018":"lsquo","\u2019":"rsquo","\u201a":"sbquo","\u2039":"lsaquo","\u203a":"rsaquo",'"':"quot","\u201c":"ldquo","\u201d":"rdquo","\u201e":"bdquo","\xab":"laquo","\xbb":"raquo","(":"lpar",")":"rpar","[":"lsqb","]":"rsqb","{":"lcub","}":"rcub","\u2308":"lceil","\u2309":"rceil","\u230a":"lfloor","\u230b":"rfloor","\u2985":"lopar","\u2986":"ropar","\u298b":"lbrke","\u298c":"rbrke","\u298d":"lbrkslu","\u298e":"rbrksld","\u298f":"lbrksld","\u2990":"rbrkslu","\u2991":"langd","\u2992":"rangd","\u2993":"lparlt","\u2994":"rpargt","\u2995":"gtlPar","\u2996":"ltrPar","\u27e6":"lobrk","\u27e7":"robrk","\u27e8":"lang","\u27e9":"rang","\u27ea":"Lang","\u27eb":"Rang","\u27ec":"loang","\u27ed":"roang","\u2772":"lbbrk","\u2773":"rbbrk","\u2016":"Vert","\xa7":"sect","\xb6":"para","@":"commat","*":"ast","/":"sol",undefined:null,"&":"amp","#":"num","%":"percnt","\u2030":"permil","\u2031":"pertenk","\u2020":"dagger","\u2021":"Dagger","\u2022":"bull","\u2043":"hybull","\u2032":"prime","\u2033":"Prime","\u2034":"tprime","\u2057":"qprime","\u2035":"bprime","\u2041":"caret","`":"grave","\xb4":"acute","\u02dc":"tilde","^":"Hat","\xaf":"macr","\u02d8":"breve","\u02d9":"dot","\xa8":"die","\u02da":"ring","\u02dd":"dblac","\xb8":"cedil","\u02db":"ogon","\u02c6":"circ","\u02c7":"caron","\xb0":"deg","\xa9":"copy","\xae":"reg","\u2117":"copysr","\u2118":"wp","\u211e":"rx","\u2127":"mho","\u2129":"iiota","\u2190":"larr","\u219a":"nlarr","\u2192":"rarr","\u219b":"nrarr","\u2191":"uarr","\u2193":"darr","\u2194":"harr","\u21ae":"nharr","\u2195":"varr","\u2196":"nwarr","\u2197":"nearr","\u2198":"searr","\u2199":"swarr","\u219d":"rarrw","\u219d\u0338":"nrarrw","\u219e":"Larr","\u219f":"Uarr","\u21a0":"Rarr","\u21a1":"Darr","\u21a2":"larrtl","\u21a3":"rarrtl","\u21a4":"mapstoleft","\u21a5":"mapstoup","\u21a6":"map","\u21a7":"mapstodown","\u21a9":"larrhk","\u21aa":"rarrhk","\u21ab":"larrlp","\u21ac":"rarrlp","\u21ad":"harrw","\u21b0":"lsh","\u21b1":"rsh","\u21b2":"ldsh","\u21b3":"rdsh","\u21b5":"crarr","\u21b6":"cularr","\u21b7":"curarr","\u21ba":"olarr","\u21bb":"orarr","\u21bc":"lharu","\u21bd":"lhard","\u21be":"uharr","\u21bf":"uharl","\u21c0":"rharu","\u21c1":"rhard","\u21c2":"dharr","\u21c3":"dharl","\u21c4":"rlarr","\u21c5":"udarr","\u21c6":"lrarr","\u21c7":"llarr","\u21c8":"uuarr","\u21c9":"rrarr","\u21ca":"ddarr","\u21cb":"lrhar","\u21cc":"rlhar","\u21d0":"lArr","\u21cd":"nlArr","\u21d1":"uArr","\u21d2":"rArr","\u21cf":"nrArr","\u21d3":"dArr","\u21d4":"iff","\u21ce":"nhArr","\u21d5":"vArr","\u21d6":"nwArr","\u21d7":"neArr","\u21d8":"seArr","\u21d9":"swArr","\u21da":"lAarr","\u21db":"rAarr","\u21dd":"zigrarr","\u21e4":"larrb","\u21e5":"rarrb","\u21f5":"duarr","\u21fd":"loarr","\u21fe":"roarr","\u21ff":"hoarr","\u2200":"forall","\u2201":"comp","\u2202":"part","\u2202\u0338":"npart","\u2203":"exist","\u2204":"nexist","\u2205":"empty","\u2207":"Del","\u2208":"in","\u2209":"notin","\u220b":"ni","\u220c":"notni","\u03f6":"bepsi","\u220f":"prod","\u2210":"coprod","\u2211":"sum","+":"plus","\xb1":"pm","\xf7":"div","\xd7":"times","<":"lt","\u226e":"nlt","<\u20d2":"nvlt","=":"equals","\u2260":"ne","=\u20e5":"bne","\u2a75":"Equal",">":"gt","\u226f":"ngt",">\u20d2":"nvgt","\xac":"not","|":"vert","\xa6":"brvbar","\u2212":"minus","\u2213":"mp","\u2214":"plusdo","\u2044":"frasl","\u2216":"setmn","\u2217":"lowast","\u2218":"compfn","\u221a":"Sqrt","\u221d":"prop","\u221e":"infin","\u221f":"angrt","\u2220":"ang","\u2220\u20d2":"nang","\u2221":"angmsd","\u2222":"angsph","\u2223":"mid","\u2224":"nmid","\u2225":"par","\u2226":"npar","\u2227":"and","\u2228":"or","\u2229":"cap","\u2229\ufe00":"caps","\u222a":"cup","\u222a\ufe00":"cups","\u222b":"int","\u222c":"Int","\u222d":"tint","\u2a0c":"qint","\u222e":"oint","\u222f":"Conint","\u2230":"Cconint","\u2231":"cwint","\u2232":"cwconint","\u2233":"awconint","\u2234":"there4","\u2235":"becaus","\u2236":"ratio","\u2237":"Colon","\u2238":"minusd","\u223a":"mDDot","\u223b":"homtht","\u223c":"sim","\u2241":"nsim","\u223c\u20d2":"nvsim","\u223d":"bsim","\u223d\u0331":"race","\u223e":"ac","\u223e\u0333":"acE","\u223f":"acd","\u2240":"wr","\u2242":"esim","\u2242\u0338":"nesim","\u2243":"sime","\u2244":"nsime","\u2245":"cong","\u2247":"ncong","\u2246":"simne","\u2248":"ap","\u2249":"nap","\u224a":"ape","\u224b":"apid","\u224b\u0338":"napid","\u224c":"bcong","\u224d":"CupCap","\u226d":"NotCupCap","\u224d\u20d2":"nvap","\u224e":"bump","\u224e\u0338":"nbump","\u224f":"bumpe","\u224f\u0338":"nbumpe","\u2250":"doteq","\u2250\u0338":"nedot","\u2251":"eDot","\u2252":"efDot","\u2253":"erDot","\u2254":"colone","\u2255":"ecolon","\u2256":"ecir","\u2257":"cire","\u2259":"wedgeq","\u225a":"veeeq","\u225c":"trie","\u225f":"equest","\u2261":"equiv","\u2262":"nequiv","\u2261\u20e5":"bnequiv","\u2264":"le","\u2270":"nle","\u2264\u20d2":"nvle","\u2265":"ge","\u2271":"nge","\u2265\u20d2":"nvge","\u2266":"lE","\u2266\u0338":"nlE","\u2267":"gE","\u2267\u0338":"ngE","\u2268\ufe00":"lvnE","\u2268":"lnE","\u2269":"gnE","\u2269\ufe00":"gvnE","\u226a":"ll","\u226a\u0338":"nLtv","\u226a\u20d2":"nLt","\u226b":"gg","\u226b\u0338":"nGtv","\u226b\u20d2":"nGt","\u226c":"twixt","\u2272":"lsim","\u2274":"nlsim","\u2273":"gsim","\u2275":"ngsim","\u2276":"lg","\u2278":"ntlg","\u2277":"gl","\u2279":"ntgl","\u227a":"pr","\u2280":"npr","\u227b":"sc","\u2281":"nsc","\u227c":"prcue","\u22e0":"nprcue","\u227d":"sccue","\u22e1":"nsccue","\u227e":"prsim","\u227f":"scsim","\u227f\u0338":"NotSucceedsTilde","\u2282":"sub","\u2284":"nsub","\u2282\u20d2":"vnsub","\u2283":"sup","\u2285":"nsup","\u2283\u20d2":"vnsup","\u2286":"sube","\u2288":"nsube","\u2287":"supe","\u2289":"nsupe","\u228a\ufe00":"vsubne","\u228a":"subne","\u228b\ufe00":"vsupne","\u228b":"supne","\u228d":"cupdot","\u228e":"uplus","\u228f":"sqsub","\u228f\u0338":"NotSquareSubset","\u2290":"sqsup","\u2290\u0338":"NotSquareSuperset","\u2291":"sqsube","\u22e2":"nsqsube","\u2292":"sqsupe","\u22e3":"nsqsupe","\u2293":"sqcap","\u2293\ufe00":"sqcaps","\u2294":"sqcup","\u2294\ufe00":"sqcups","\u2295":"oplus","\u2296":"ominus","\u2297":"otimes","\u2298":"osol","\u2299":"odot","\u229a":"ocir","\u229b":"oast","\u229d":"odash","\u229e":"plusb","\u229f":"minusb","\u22a0":"timesb","\u22a1":"sdotb","\u22a2":"vdash","\u22ac":"nvdash","\u22a3":"dashv","\u22a4":"top","\u22a5":"bot","\u22a7":"models","\u22a8":"vDash","\u22ad":"nvDash","\u22a9":"Vdash","\u22ae":"nVdash","\u22aa":"Vvdash","\u22ab":"VDash","\u22af":"nVDash","\u22b0":"prurel","\u22b2":"vltri","\u22ea":"nltri","\u22b3":"vrtri","\u22eb":"nrtri","\u22b4":"ltrie","\u22ec":"nltrie","\u22b4\u20d2":"nvltrie","\u22b5":"rtrie","\u22ed":"nrtrie","\u22b5\u20d2":"nvrtrie","\u22b6":"origof","\u22b7":"imof","\u22b8":"mumap","\u22b9":"hercon","\u22ba":"intcal","\u22bb":"veebar","\u22bd":"barvee","\u22be":"angrtvb","\u22bf":"lrtri","\u22c0":"Wedge","\u22c1":"Vee","\u22c2":"xcap","\u22c3":"xcup","\u22c4":"diam","\u22c5":"sdot","\u22c6":"Star","\u22c7":"divonx","\u22c8":"bowtie","\u22c9":"ltimes","\u22ca":"rtimes","\u22cb":"lthree","\u22cc":"rthree","\u22cd":"bsime","\u22ce":"cuvee","\u22cf":"cuwed","\u22d0":"Sub","\u22d1":"Sup","\u22d2":"Cap","\u22d3":"Cup","\u22d4":"fork","\u22d5":"epar","\u22d6":"ltdot","\u22d7":"gtdot","\u22d8":"Ll","\u22d8\u0338":"nLl","\u22d9":"Gg","\u22d9\u0338":"nGg","\u22da\ufe00":"lesg","\u22da":"leg","\u22db":"gel","\u22db\ufe00":"gesl","\u22de":"cuepr","\u22df":"cuesc","\u22e6":"lnsim","\u22e7":"gnsim","\u22e8":"prnsim","\u22e9":"scnsim","\u22ee":"vellip","\u22ef":"ctdot","\u22f0":"utdot","\u22f1":"dtdot","\u22f2":"disin","\u22f3":"isinsv","\u22f4":"isins","\u22f5":"isindot","\u22f5\u0338":"notindot","\u22f6":"notinvc","\u22f7":"notinvb","\u22f9":"isinE","\u22f9\u0338":"notinE","\u22fa":"nisd","\u22fb":"xnis","\u22fc":"nis","\u22fd":"notnivc","\u22fe":"notnivb","\u2305":"barwed","\u2306":"Barwed","\u230c":"drcrop","\u230d":"dlcrop","\u230e":"urcrop","\u230f":"ulcrop","\u2310":"bnot","\u2312":"profline","\u2313":"profsurf","\u2315":"telrec","\u2316":"target","\u231c":"ulcorn","\u231d":"urcorn","\u231e":"dlcorn","\u231f":"drcorn","\u2322":"frown","\u2323":"smile","\u232d":"cylcty","\u232e":"profalar","\u2336":"topbot","\u233d":"ovbar","\u233f":"solbar","\u237c":"angzarr","\u23b0":"lmoust","\u23b1":"rmoust","\u23b4":"tbrk","\u23b5":"bbrk","\u23b6":"bbrktbrk","\u23dc":"OverParenthesis","\u23dd":"UnderParenthesis","\u23de":"OverBrace","\u23df":"UnderBrace","\u23e2":"trpezium","\u23e7":"elinters","\u2423":"blank","\u2500":"boxh","\u2502":"boxv","\u250c":"boxdr","\u2510":"boxdl","\u2514":"boxur","\u2518":"boxul","\u251c":"boxvr","\u2524":"boxvl","\u252c":"boxhd","\u2534":"boxhu","\u253c":"boxvh","\u2550":"boxH","\u2551":"boxV","\u2552":"boxdR","\u2553":"boxDr","\u2554":"boxDR","\u2555":"boxdL","\u2556":"boxDl","\u2557":"boxDL","\u2558":"boxuR","\u2559":"boxUr","\u255a":"boxUR","\u255b":"boxuL","\u255c":"boxUl","\u255d":"boxUL","\u255e":"boxvR","\u255f":"boxVr","\u2560":"boxVR","\u2561":"boxvL","\u2562":"boxVl","\u2563":"boxVL","\u2564":"boxHd","\u2565":"boxhD","\u2566":"boxHD","\u2567":"boxHu","\u2568":"boxhU","\u2569":"boxHU","\u256a":"boxvH","\u256b":"boxVh","\u256c":"boxVH","\u2580":"uhblk","\u2584":"lhblk","\u2588":"block","\u2591":"blk14","\u2592":"blk12","\u2593":"blk34","\u25a1":"squ","\u25aa":"squf","\u25ab":"EmptyVerySmallSquare","\u25ad":"rect","\u25ae":"marker","\u25b1":"fltns","\u25b3":"xutri","\u25b4":"utrif","\u25b5":"utri","\u25b8":"rtrif","\u25b9":"rtri","\u25bd":"xdtri","\u25be":"dtrif","\u25bf":"dtri","\u25c2":"ltrif","\u25c3":"ltri","\u25ca":"loz","\u25cb":"cir","\u25ec":"tridot","\u25ef":"xcirc","\u25f8":"ultri","\u25f9":"urtri","\u25fa":"lltri","\u25fb":"EmptySmallSquare","\u25fc":"FilledSmallSquare","\u2605":"starf","\u2606":"star","\u260e":"phone","\u2640":"female","\u2642":"male","\u2660":"spades","\u2663":"clubs","\u2665":"hearts","\u2666":"diams","\u266a":"sung","\u2713":"check","\u2717":"cross","\u2720":"malt","\u2736":"sext","\u2758":"VerticalSeparator","\u27c8":"bsolhsub","\u27c9":"suphsol","\u27f5":"xlarr","\u27f6":"xrarr","\u27f7":"xharr","\u27f8":"xlArr","\u27f9":"xrArr","\u27fa":"xhArr","\u27fc":"xmap","\u27ff":"dzigrarr","\u2902":"nvlArr","\u2903":"nvrArr","\u2904":"nvHarr","\u2905":"Map","\u290c":"lbarr","\u290d":"rbarr","\u290e":"lBarr","\u290f":"rBarr","\u2910":"RBarr","\u2911":"DDotrahd","\u2912":"UpArrowBar","\u2913":"DownArrowBar","\u2916":"Rarrtl","\u2919":"latail","\u291a":"ratail","\u291b":"lAtail","\u291c":"rAtail","\u291d":"larrfs","\u291e":"rarrfs","\u291f":"larrbfs","\u2920":"rarrbfs","\u2923":"nwarhk","\u2924":"nearhk","\u2925":"searhk","\u2926":"swarhk","\u2927":"nwnear","\u2928":"toea","\u2929":"tosa","\u292a":"swnwar","\u2933":"rarrc","\u2933\u0338":"nrarrc","\u2935":"cudarrr","\u2936":"ldca","\u2937":"rdca","\u2938":"cudarrl","\u2939":"larrpl","\u293c":"curarrm","\u293d":"cularrp","\u2945":"rarrpl","\u2948":"harrcir","\u2949":"Uarrocir","\u294a":"lurdshar","\u294b":"ldrushar","\u294e":"LeftRightVector","\u294f":"RightUpDownVector","\u2950":"DownLeftRightVector","\u2951":"LeftUpDownVector","\u2952":"LeftVectorBar","\u2953":"RightVectorBar","\u2954":"RightUpVectorBar","\u2955":"RightDownVectorBar","\u2956":"DownLeftVectorBar","\u2957":"DownRightVectorBar","\u2958":"LeftUpVectorBar","\u2959":"LeftDownVectorBar","\u295a":"LeftTeeVector","\u295b":"RightTeeVector","\u295c":"RightUpTeeVector","\u295d":"RightDownTeeVector","\u295e":"DownLeftTeeVector","\u295f":"DownRightTeeVector","\u2960":"LeftUpTeeVector","\u2961":"LeftDownTeeVector","\u2962":"lHar","\u2963":"uHar","\u2964":"rHar","\u2965":"dHar","\u2966":"luruhar","\u2967":"ldrdhar","\u2968":"ruluhar","\u2969":"rdldhar","\u296a":"lharul","\u296b":"llhard","\u296c":"rharul","\u296d":"lrhard","\u296e":"udhar","\u296f":"duhar","\u2970":"RoundImplies","\u2971":"erarr","\u2972":"simrarr","\u2973":"larrsim","\u2974":"rarrsim","\u2975":"rarrap","\u2976":"ltlarr","\u2978":"gtrarr","\u2979":"subrarr","\u297b":"suplarr","\u297c":"lfisht","\u297d":"rfisht","\u297e":"ufisht","\u297f":"dfisht","\u299a":"vzigzag","\u299c":"vangrt","\u299d":"angrtvbd","\u29a4":"ange","\u29a5":"range","\u29a6":"dwangle","\u29a7":"uwangle","\u29a8":"angmsdaa","\u29a9":"angmsdab","\u29aa":"angmsdac","\u29ab":"angmsdad","\u29ac":"angmsdae","\u29ad":"angmsdaf","\u29ae":"angmsdag","\u29af":"angmsdah","\u29b0":"bemptyv","\u29b1":"demptyv","\u29b2":"cemptyv","\u29b3":"raemptyv","\u29b4":"laemptyv","\u29b5":"ohbar","\u29b6":"omid","\u29b7":"opar","\u29b9":"operp","\u29bb":"olcross","\u29bc":"odsold","\u29be":"olcir","\u29bf":"ofcir","\u29c0":"olt","\u29c1":"ogt","\u29c2":"cirscir","\u29c3":"cirE","\u29c4":"solb","\u29c5":"bsolb","\u29c9":"boxbox","\u29cd":"trisb","\u29ce":"rtriltri","\u29cf":"LeftTriangleBar","\u29cf\u0338":"NotLeftTriangleBar","\u29d0":"RightTriangleBar","\u29d0\u0338":"NotRightTriangleBar","\u29dc":"iinfin","\u29dd":"infintie","\u29de":"nvinfin","\u29e3":"eparsl","\u29e4":"smeparsl","\u29e5":"eqvparsl","\u29eb":"lozf","\u29f4":"RuleDelayed","\u29f6":"dsol","\u2a00":"xodot","\u2a01":"xoplus","\u2a02":"xotime","\u2a04":"xuplus","\u2a06":"xsqcup","\u2a0d":"fpartint","\u2a10":"cirfnint","\u2a11":"awint","\u2a12":"rppolint","\u2a13":"scpolint","\u2a14":"npolint","\u2a15":"pointint","\u2a16":"quatint","\u2a17":"intlarhk","\u2a22":"pluscir","\u2a23":"plusacir","\u2a24":"simplus","\u2a25":"plusdu","\u2a26":"plussim","\u2a27":"plustwo","\u2a29":"mcomma","\u2a2a":"minusdu","\u2a2d":"loplus","\u2a2e":"roplus","\u2a2f":"Cross","\u2a30":"timesd","\u2a31":"timesbar","\u2a33":"smashp","\u2a34":"lotimes","\u2a35":"rotimes","\u2a36":"otimesas","\u2a37":"Otimes","\u2a38":"odiv","\u2a39":"triplus","\u2a3a":"triminus","\u2a3b":"tritime","\u2a3c":"iprod","\u2a3f":"amalg","\u2a40":"capdot","\u2a42":"ncup","\u2a43":"ncap","\u2a44":"capand","\u2a45":"cupor","\u2a46":"cupcap","\u2a47":"capcup","\u2a48":"cupbrcap","\u2a49":"capbrcup","\u2a4a":"cupcup","\u2a4b":"capcap","\u2a4c":"ccups","\u2a4d":"ccaps","\u2a50":"ccupssm","\u2a53":"And","\u2a54":"Or","\u2a55":"andand","\u2a56":"oror","\u2a57":"orslope","\u2a58":"andslope","\u2a5a":"andv","\u2a5b":"orv","\u2a5c":"andd","\u2a5d":"ord","\u2a5f":"wedbar","\u2a66":"sdote","\u2a6a":"simdot","\u2a6d":"congdot","\u2a6d\u0338":"ncongdot","\u2a6e":"easter","\u2a6f":"apacir","\u2a70":"apE","\u2a70\u0338":"napE","\u2a71":"eplus","\u2a72":"pluse","\u2a73":"Esim","\u2a77":"eDDot","\u2a78":"equivDD","\u2a79":"ltcir","\u2a7a":"gtcir","\u2a7b":"ltquest","\u2a7c":"gtquest","\u2a7d":"les","\u2a7d\u0338":"nles","\u2a7e":"ges","\u2a7e\u0338":"nges","\u2a7f":"lesdot","\u2a80":"gesdot","\u2a81":"lesdoto","\u2a82":"gesdoto","\u2a83":"lesdotor","\u2a84":"gesdotol","\u2a85":"lap","\u2a86":"gap","\u2a87":"lne","\u2a88":"gne","\u2a89":"lnap","\u2a8a":"gnap","\u2a8b":"lEg","\u2a8c":"gEl","\u2a8d":"lsime","\u2a8e":"gsime","\u2a8f":"lsimg","\u2a90":"gsiml","\u2a91":"lgE","\u2a92":"glE","\u2a93":"lesges","\u2a94":"gesles","\u2a95":"els","\u2a96":"egs","\u2a97":"elsdot","\u2a98":"egsdot","\u2a99":"el","\u2a9a":"eg","\u2a9d":"siml","\u2a9e":"simg","\u2a9f":"simlE","\u2aa0":"simgE","\u2aa1":"LessLess","\u2aa1\u0338":"NotNestedLessLess","\u2aa2":"GreaterGreater","\u2aa2\u0338":"NotNestedGreaterGreater","\u2aa4":"glj","\u2aa5":"gla","\u2aa6":"ltcc","\u2aa7":"gtcc","\u2aa8":"lescc","\u2aa9":"gescc","\u2aaa":"smt","\u2aab":"lat","\u2aac":"smte","\u2aac\ufe00":"smtes","\u2aad":"late","\u2aad\ufe00":"lates","\u2aae":"bumpE","\u2aaf":"pre","\u2aaf\u0338":"npre","\u2ab0":"sce","\u2ab0\u0338":"nsce","\u2ab3":"prE","\u2ab4":"scE","\u2ab5":"prnE","\u2ab6":"scnE","\u2ab7":"prap","\u2ab8":"scap","\u2ab9":"prnap","\u2aba":"scnap","\u2abb":"Pr","\u2abc":"Sc","\u2abd":"subdot","\u2abe":"supdot","\u2abf":"subplus","\u2ac0":"supplus","\u2ac1":"submult","\u2ac2":"supmult","\u2ac3":"subedot","\u2ac4":"supedot","\u2ac5":"subE","\u2ac5\u0338":"nsubE","\u2ac6":"supE","\u2ac6\u0338":"nsupE","\u2ac7":"subsim","\u2ac8":"supsim","\u2acb\ufe00":"vsubnE","\u2acb":"subnE","\u2acc\ufe00":"vsupnE","\u2acc":"supnE","\u2acf":"csub","\u2ad0":"csup","\u2ad1":"csube","\u2ad2":"csupe","\u2ad3":"subsup","\u2ad4":"supsub","\u2ad5":"subsub","\u2ad6":"supsup","\u2ad7":"suphsub","\u2ad8":"supdsub","\u2ad9":"forkv","\u2ada":"topfork","\u2adb":"mlcp","\u2ae4":"Dashv","\u2ae6":"Vdashl","\u2ae7":"Barv","\u2ae8":"vBar","\u2ae9":"vBarv","\u2aeb":"Vbar","\u2aec":"Not","\u2aed":"bNot","\u2aee":"rnmid","\u2aef":"cirmid","\u2af0":"midcir","\u2af1":"topcir","\u2af2":"nhpar","\u2af3":"parsim","\u2afd":"parsl","\u2afd\u20e5":"nparsl","\u266d":"flat","\u266e":"natur","\u266f":"sharp","\xa4":"curren","\xa2":"cent",$:"dollar","\xa3":"pound","\xa5":"yen","\u20ac":"euro","\xb9":"sup1","\xbd":"half","\u2153":"frac13","\xbc":"frac14","\u2155":"frac15","\u2159":"frac16","\u215b":"frac18","\xb2":"sup2","\u2154":"frac23","\u2156":"frac25","\xb3":"sup3","\xbe":"frac34","\u2157":"frac35","\u215c":"frac38","\u2158":"frac45","\u215a":"frac56","\u215d":"frac58","\u215e":"frac78","\ud835\udcb6":"ascr","\ud835\udd52":"aopf","\ud835\udd1e":"afr","\ud835\udd38":"Aopf","\ud835\udd04":"Afr","\ud835\udc9c":"Ascr","\xaa":"ordf","\xe1":"aacute","\xc1":"Aacute","\xe0":"agrave","\xc0":"Agrave","\u0103":"abreve","\u0102":"Abreve","\xe2":"acirc","\xc2":"Acirc","\xe5":"aring","\xc5":"angst","\xe4":"auml","\xc4":"Auml","\xe3":"atilde","\xc3":"Atilde","\u0105":"aogon","\u0104":"Aogon","\u0101":"amacr","\u0100":"Amacr","\xe6":"aelig","\xc6":"AElig","\ud835\udcb7":"bscr","\ud835\udd53":"bopf","\ud835\udd1f":"bfr","\ud835\udd39":"Bopf","\u212c":"Bscr","\ud835\udd05":"Bfr","\ud835\udd20":"cfr","\ud835\udcb8":"cscr","\ud835\udd54":"copf","\u212d":"Cfr","\ud835\udc9e":"Cscr","\u2102":"Copf","\u0107":"cacute","\u0106":"Cacute","\u0109":"ccirc","\u0108":"Ccirc","\u010d":"ccaron","\u010c":"Ccaron","\u010b":"cdot","\u010a":"Cdot","\xe7":"ccedil","\xc7":"Ccedil","\u2105":"incare","\ud835\udd21":"dfr","\u2146":"dd","\ud835\udd55":"dopf","\ud835\udcb9":"dscr","\ud835\udc9f":"Dscr","\ud835\udd07":"Dfr","\u2145":"DD","\ud835\udd3b":"Dopf","\u010f":"dcaron","\u010e":"Dcaron","\u0111":"dstrok","\u0110":"Dstrok","\xf0":"eth","\xd0":"ETH","\u2147":"ee","\u212f":"escr","\ud835\udd22":"efr","\ud835\udd56":"eopf","\u2130":"Escr","\ud835\udd08":"Efr","\ud835\udd3c":"Eopf","\xe9":"eacute","\xc9":"Eacute","\xe8":"egrave","\xc8":"Egrave","\xea":"ecirc","\xca":"Ecirc","\u011b":"ecaron","\u011a":"Ecaron","\xeb":"euml","\xcb":"Euml","\u0117":"edot","\u0116":"Edot","\u0119":"eogon","\u0118":"Eogon","\u0113":"emacr","\u0112":"Emacr","\ud835\udd23":"ffr","\ud835\udd57":"fopf","\ud835\udcbb":"fscr","\ud835\udd09":"Ffr","\ud835\udd3d":"Fopf","\u2131":"Fscr","\ufb00":"fflig","\ufb03":"ffilig","\ufb04":"ffllig","\ufb01":"filig",fj:"fjlig","\ufb02":"fllig","\u0192":"fnof","\u210a":"gscr","\ud835\udd58":"gopf","\ud835\udd24":"gfr","\ud835\udca2":"Gscr","\ud835\udd3e":"Gopf","\ud835\udd0a":"Gfr","\u01f5":"gacute","\u011f":"gbreve","\u011e":"Gbreve","\u011d":"gcirc","\u011c":"Gcirc","\u0121":"gdot","\u0120":"Gdot","\u0122":"Gcedil","\ud835\udd25":"hfr","\u210e":"planckh","\ud835\udcbd":"hscr","\ud835\udd59":"hopf","\u210b":"Hscr","\u210c":"Hfr","\u210d":"Hopf","\u0125":"hcirc","\u0124":"Hcirc","\u210f":"hbar","\u0127":"hstrok","\u0126":"Hstrok","\ud835\udd5a":"iopf","\ud835\udd26":"ifr","\ud835\udcbe":"iscr","\u2148":"ii","\ud835\udd40":"Iopf","\u2110":"Iscr","\u2111":"Im","\xed":"iacute","\xcd":"Iacute","\xec":"igrave","\xcc":"Igrave","\xee":"icirc","\xce":"Icirc","\xef":"iuml","\xcf":"Iuml","\u0129":"itilde","\u0128":"Itilde","\u0130":"Idot","\u012f":"iogon","\u012e":"Iogon","\u012b":"imacr","\u012a":"Imacr","\u0133":"ijlig","\u0132":"IJlig","\u0131":"imath","\ud835\udcbf":"jscr","\ud835\udd5b":"jopf","\ud835\udd27":"jfr","\ud835\udca5":"Jscr","\ud835\udd0d":"Jfr","\ud835\udd41":"Jopf","\u0135":"jcirc","\u0134":"Jcirc","\u0237":"jmath","\ud835\udd5c":"kopf","\ud835\udcc0":"kscr","\ud835\udd28":"kfr","\ud835\udca6":"Kscr","\ud835\udd42":"Kopf","\ud835\udd0e":"Kfr","\u0137":"kcedil","\u0136":"Kcedil","\ud835\udd29":"lfr","\ud835\udcc1":"lscr","\u2113":"ell","\ud835\udd5d":"lopf","\u2112":"Lscr","\ud835\udd0f":"Lfr","\ud835\udd43":"Lopf","\u013a":"lacute","\u0139":"Lacute","\u013e":"lcaron","\u013d":"Lcaron","\u013c":"lcedil","\u013b":"Lcedil","\u0142":"lstrok","\u0141":"Lstrok","\u0140":"lmidot","\u013f":"Lmidot","\ud835\udd2a":"mfr","\ud835\udd5e":"mopf","\ud835\udcc2":"mscr","\ud835\udd10":"Mfr","\ud835\udd44":"Mopf","\u2133":"Mscr","\ud835\udd2b":"nfr","\ud835\udd5f":"nopf","\ud835\udcc3":"nscr","\u2115":"Nopf","\ud835\udca9":"Nscr","\ud835\udd11":"Nfr","\u0144":"nacute","\u0143":"Nacute","\u0148":"ncaron","\u0147":"Ncaron","\xf1":"ntilde","\xd1":"Ntilde","\u0146":"ncedil","\u0145":"Ncedil","\u2116":"numero","\u014b":"eng","\u014a":"ENG","\ud835\udd60":"oopf","\ud835\udd2c":"ofr","\u2134":"oscr","\ud835\udcaa":"Oscr","\ud835\udd12":"Ofr","\ud835\udd46":"Oopf","\xba":"ordm","\xf3":"oacute","\xd3":"Oacute","\xf2":"ograve","\xd2":"Ograve","\xf4":"ocirc","\xd4":"Ocirc","\xf6":"ouml","\xd6":"Ouml","\u0151":"odblac","\u0150":"Odblac","\xf5":"otilde","\xd5":"Otilde","\xf8":"oslash","\xd8":"Oslash","\u014d":"omacr","\u014c":"Omacr","\u0153":"oelig","\u0152":"OElig","\ud835\udd2d":"pfr","\ud835\udcc5":"pscr","\ud835\udd61":"popf","\u2119":"Popf","\ud835\udd13":"Pfr","\ud835\udcab":"Pscr","\ud835\udd62":"qopf","\ud835\udd2e":"qfr","\ud835\udcc6":"qscr","\ud835\udcac":"Qscr","\ud835\udd14":"Qfr","\u211a":"Qopf","\u0138":"kgreen","\ud835\udd2f":"rfr","\ud835\udd63":"ropf","\ud835\udcc7":"rscr","\u211b":"Rscr","\u211c":"Re","\u211d":"Ropf","\u0155":"racute","\u0154":"Racute","\u0159":"rcaron","\u0158":"Rcaron","\u0157":"rcedil","\u0156":"Rcedil","\ud835\udd64":"sopf","\ud835\udcc8":"sscr","\ud835\udd30":"sfr","\ud835\udd4a":"Sopf","\ud835\udd16":"Sfr","\ud835\udcae":"Sscr","\u24c8":"oS","\u015b":"sacute","\u015a":"Sacute","\u015d":"scirc","\u015c":"Scirc","\u0161":"scaron","\u0160":"Scaron","\u015f":"scedil","\u015e":"Scedil","\xdf":"szlig","\ud835\udd31":"tfr","\ud835\udcc9":"tscr","\ud835\udd65":"topf","\ud835\udcaf":"Tscr","\ud835\udd17":"Tfr","\ud835\udd4b":"Topf","\u0165":"tcaron","\u0164":"Tcaron","\u0163":"tcedil","\u0162":"Tcedil","\u2122":"trade","\u0167":"tstrok","\u0166":"Tstrok","\ud835\udcca":"uscr","\ud835\udd66":"uopf","\ud835\udd32":"ufr","\ud835\udd4c":"Uopf","\ud835\udd18":"Ufr","\ud835\udcb0":"Uscr","\xfa":"uacute","\xda":"Uacute","\xf9":"ugrave","\xd9":"Ugrave","\u016d":"ubreve","\u016c":"Ubreve","\xfb":"ucirc","\xdb":"Ucirc","\u016f":"uring","\u016e":"Uring","\xfc":"uuml","\xdc":"Uuml","\u0171":"udblac","\u0170":"Udblac","\u0169":"utilde","\u0168":"Utilde","\u0173":"uogon","\u0172":"Uogon","\u016b":"umacr","\u016a":"Umacr","\ud835\udd33":"vfr","\ud835\udd67":"vopf","\ud835\udccb":"vscr","\ud835\udd19":"Vfr","\ud835\udd4d":"Vopf","\ud835\udcb1":"Vscr","\ud835\udd68":"wopf","\ud835\udccc":"wscr","\ud835\udd34":"wfr","\ud835\udcb2":"Wscr","\ud835\udd4e":"Wopf","\ud835\udd1a":"Wfr","\u0175":"wcirc","\u0174":"Wcirc","\ud835\udd35":"xfr","\ud835\udccd":"xscr","\ud835\udd69":"xopf","\ud835\udd4f":"Xopf","\ud835\udd1b":"Xfr","\ud835\udcb3":"Xscr","\ud835\udd36":"yfr","\ud835\udcce":"yscr","\ud835\udd6a":"yopf","\ud835\udcb4":"Yscr","\ud835\udd1c":"Yfr","\ud835\udd50":"Yopf","\xfd":"yacute","\xdd":"Yacute","\u0177":"ycirc","\u0176":"Ycirc","\xff":"yuml","\u0178":"Yuml","\ud835\udccf":"zscr","\ud835\udd37":"zfr","\ud835\udd6b":"zopf","\u2128":"Zfr","\u2124":"Zopf","\ud835\udcb5":"Zscr","\u017a":"zacute","\u0179":"Zacute","\u017e":"zcaron","\u017d":"Zcaron","\u017c":"zdot","\u017b":"Zdot","\u01b5":"imped","\xfe":"thorn","\xde":"THORN","\u0149":"napos","\u03b1":"alpha","\u0391":"Alpha","\u03b2":"beta","\u0392":"Beta","\u03b3":"gamma","\u0393":"Gamma","\u03b4":"delta","\u0394":"Delta","\u03b5":"epsi","\u03f5":"epsiv","\u0395":"Epsilon","\u03dd":"gammad","\u03dc":"Gammad","\u03b6":"zeta","\u0396":"Zeta","\u03b7":"eta","\u0397":"Eta","\u03b8":"theta","\u03d1":"thetav","\u0398":"Theta","\u03b9":"iota","\u0399":"Iota","\u03ba":"kappa","\u03f0":"kappav","\u039a":"Kappa","\u03bb":"lambda","\u039b":"Lambda","\u03bc":"mu","\xb5":"micro","\u039c":"Mu","\u03bd":"nu","\u039d":"Nu","\u03be":"xi","\u039e":"Xi","\u03bf":"omicron","\u039f":"Omicron","\u03c0":"pi","\u03d6":"piv","\u03a0":"Pi","\u03c1":"rho","\u03f1":"rhov","\u03a1":"Rho","\u03c3":"sigma","\u03a3":"Sigma","\u03c2":"sigmaf","\u03c4":"tau","\u03a4":"Tau","\u03c5":"upsi","\u03a5":"Upsilon","\u03d2":"Upsi","\u03c6":"phi","\u03d5":"phiv","\u03a6":"Phi","\u03c7":"chi","\u03a7":"Chi","\u03c8":"psi","\u03a8":"Psi","\u03c9":"omega","\u03a9":"ohm","\u0430":"acy","\u0410":"Acy","\u0431":"bcy","\u0411":"Bcy","\u0432":"vcy","\u0412":"Vcy","\u0433":"gcy","\u0413":"Gcy","\u0453":"gjcy","\u0403":"GJcy","\u0434":"dcy","\u0414":"Dcy","\u0452":"djcy","\u0402":"DJcy","\u0435":"iecy","\u0415":"IEcy","\u0451":"iocy","\u0401":"IOcy","\u0454":"jukcy","\u0404":"Jukcy","\u0436":"zhcy","\u0416":"ZHcy","\u0437":"zcy","\u0417":"Zcy","\u0455":"dscy","\u0405":"DScy","\u0438":"icy","\u0418":"Icy","\u0456":"iukcy","\u0406":"Iukcy","\u0457":"yicy","\u0407":"YIcy","\u0439":"jcy","\u0419":"Jcy","\u0458":"jsercy","\u0408":"Jsercy","\u043a":"kcy","\u041a":"Kcy","\u045c":"kjcy","\u040c":"KJcy","\u043b":"lcy","\u041b":"Lcy","\u0459":"ljcy","\u0409":"LJcy","\u043c":"mcy","\u041c":"Mcy","\u043d":"ncy","\u041d":"Ncy","\u045a":"njcy","\u040a":"NJcy","\u043e":"ocy","\u041e":"Ocy","\u043f":"pcy","\u041f":"Pcy","\u0440":"rcy","\u0420":"Rcy","\u0441":"scy","\u0421":"Scy","\u0442":"tcy","\u0422":"Tcy","\u045b":"tshcy","\u040b":"TSHcy","\u0443":"ucy","\u0423":"Ucy","\u045e":"ubrcy","\u040e":"Ubrcy","\u0444":"fcy","\u0424":"Fcy","\u0445":"khcy","\u0425":"KHcy","\u0446":"tscy","\u0426":"TScy","\u0447":"chcy","\u0427":"CHcy","\u045f":"dzcy","\u040f":"DZcy","\u0448":"shcy","\u0428":"SHcy","\u0449":"shchcy","\u0429":"SHCHcy","\u044a":"hardcy","\u042a":"HARDcy","\u044b":"ycy","\u042b":"Ycy","\u044c":"softcy","\u042c":"SOFTcy","\u044d":"ecy","\u042d":"Ecy","\u044e":"yucy","\u042e":"YUcy","\u044f":"yacy","\u042f":"YAcy","\u2135":"aleph","\u2136":"beth","\u2137":"gimel","\u2138":"daleth"},l=/["&'<>`]/g,u={'"':"&quot;","&":"&amp;","'":"&#x27;","<":"&lt;",">":"&gt;","`":"&#x60;"},p=/&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/,d=/[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/,f=/&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g,m={aacute:"\xe1",Aacute:"\xc1",abreve:"\u0103",Abreve:"\u0102",ac:"\u223e",acd:"\u223f",acE:"\u223e\u0333",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",acy:"\u0430",Acy:"\u0410",aelig:"\xe6",AElig:"\xc6",af:"\u2061",afr:"\ud835\udd1e",Afr:"\ud835\udd04",agrave:"\xe0",Agrave:"\xc0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",Alpha:"\u0391",amacr:"\u0101",Amacr:"\u0100",amalg:"\u2a3f",amp:"&",AMP:"&",and:"\u2227",And:"\u2a53",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",ange:"\u29a4",angle:"\u2220",angmsd:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angst:"\xc5",angzarr:"\u237c",aogon:"\u0105",Aogon:"\u0104",aopf:"\ud835\udd52",Aopf:"\ud835\udd38",ap:"\u2248",apacir:"\u2a6f",ape:"\u224a",apE:"\u2a70",apid:"\u224b",apos:"'",ApplyFunction:"\u2061",approx:"\u2248",approxeq:"\u224a",aring:"\xe5",Aring:"\xc5",ascr:"\ud835\udcb6",Ascr:"\ud835\udc9c",Assign:"\u2254",ast:"*",asymp:"\u2248",asympeq:"\u224d",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",awconint:"\u2233",awint:"\u2a11",backcong:"\u224c",backepsilon:"\u03f6",backprime:"\u2035",backsim:"\u223d",backsimeq:"\u22cd",Backslash:"\u2216",Barv:"\u2ae7",barvee:"\u22bd",barwed:"\u2305",Barwed:"\u2306",barwedge:"\u2305",bbrk:"\u23b5",bbrktbrk:"\u23b6",bcong:"\u224c",bcy:"\u0431",Bcy:"\u0411",bdquo:"\u201e",becaus:"\u2235",because:"\u2235",Because:"\u2235",bemptyv:"\u29b0",bepsi:"\u03f6",bernou:"\u212c",Bernoullis:"\u212c",beta:"\u03b2",Beta:"\u0392",beth:"\u2136",between:"\u226c",bfr:"\ud835\udd1f",Bfr:"\ud835\udd05",bigcap:"\u22c2",bigcirc:"\u25ef",bigcup:"\u22c3",bigodot:"\u2a00",bigoplus:"\u2a01",bigotimes:"\u2a02",bigsqcup:"\u2a06",bigstar:"\u2605",bigtriangledown:"\u25bd",bigtriangleup:"\u25b3",biguplus:"\u2a04",bigvee:"\u22c1",bigwedge:"\u22c0",bkarow:"\u290d",blacklozenge:"\u29eb",blacksquare:"\u25aa",blacktriangle:"\u25b4",blacktriangledown:"\u25be",blacktriangleleft:"\u25c2",blacktriangleright:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bNot:"\u2aed",bopf:"\ud835\udd53",Bopf:"\ud835\udd39",bot:"\u22a5",bottom:"\u22a5",bowtie:"\u22c8",boxbox:"\u29c9",boxdl:"\u2510",boxdL:"\u2555",boxDl:"\u2556",boxDL:"\u2557",boxdr:"\u250c",boxdR:"\u2552",boxDr:"\u2553",boxDR:"\u2554",boxh:"\u2500",boxH:"\u2550",boxhd:"\u252c",boxhD:"\u2565",boxHd:"\u2564",boxHD:"\u2566",boxhu:"\u2534",boxhU:"\u2568",boxHu:"\u2567",boxHU:"\u2569",boxminus:"\u229f",boxplus:"\u229e",boxtimes:"\u22a0",boxul:"\u2518",boxuL:"\u255b",boxUl:"\u255c",boxUL:"\u255d",boxur:"\u2514",boxuR:"\u2558",boxUr:"\u2559",boxUR:"\u255a",boxv:"\u2502",boxV:"\u2551",boxvh:"\u253c",boxvH:"\u256a",boxVh:"\u256b",boxVH:"\u256c",boxvl:"\u2524",boxvL:"\u2561",boxVl:"\u2562",boxVL:"\u2563",boxvr:"\u251c",boxvR:"\u255e",boxVr:"\u255f",boxVR:"\u2560",bprime:"\u2035",breve:"\u02d8",Breve:"\u02d8",brvbar:"\xa6",bscr:"\ud835\udcb7",Bscr:"\u212c",bsemi:"\u204f",bsim:"\u223d",bsime:"\u22cd",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bump:"\u224e",bumpe:"\u224f",bumpE:"\u2aae",bumpeq:"\u224f",Bumpeq:"\u224e",cacute:"\u0107",Cacute:"\u0106",cap:"\u2229",Cap:"\u22d2",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",CapitalDifferentialD:"\u2145",caps:"\u2229\ufe00",caret:"\u2041",caron:"\u02c7",Cayleys:"\u212d",ccaps:"\u2a4d",ccaron:"\u010d",Ccaron:"\u010c",ccedil:"\xe7",Ccedil:"\xc7",ccirc:"\u0109",Ccirc:"\u0108",Cconint:"\u2230",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",Cdot:"\u010a",cedil:"\xb8",Cedilla:"\xb8",cemptyv:"\u29b2",cent:"\xa2",centerdot:"\xb7",CenterDot:"\xb7",cfr:"\ud835\udd20",Cfr:"\u212d",chcy:"\u0447",CHcy:"\u0427",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",Chi:"\u03a7",cir:"\u25cb",circ:"\u02c6",circeq:"\u2257",circlearrowleft:"\u21ba",circlearrowright:"\u21bb",circledast:"\u229b",circledcirc:"\u229a",circleddash:"\u229d",CircleDot:"\u2299",circledR:"\xae",circledS:"\u24c8",CircleMinus:"\u2296",CirclePlus:"\u2295",CircleTimes:"\u2297",cire:"\u2257",cirE:"\u29c3",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",ClockwiseContourIntegral:"\u2232",CloseCurlyDoubleQuote:"\u201d",CloseCurlyQuote:"\u2019",clubs:"\u2663",clubsuit:"\u2663",colon:":",Colon:"\u2237",colone:"\u2254",Colone:"\u2a74",coloneq:"\u2254",comma:",",commat:"@",comp:"\u2201",compfn:"\u2218",complement:"\u2201",complexes:"\u2102",cong:"\u2245",congdot:"\u2a6d",Congruent:"\u2261",conint:"\u222e",Conint:"\u222f",ContourIntegral:"\u222e",copf:"\ud835\udd54",Copf:"\u2102",coprod:"\u2210",Coproduct:"\u2210",copy:"\xa9",COPY:"\xa9",copysr:"\u2117",CounterClockwiseContourIntegral:"\u2233",crarr:"\u21b5",cross:"\u2717",Cross:"\u2a2f",cscr:"\ud835\udcb8",Cscr:"\ud835\udc9e",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",cuesc:"\u22df",cularr:"\u21b6",cularrp:"\u293d",cup:"\u222a",Cup:"\u22d3",cupbrcap:"\u2a48",cupcap:"\u2a46",CupCap:"\u224d",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curarrm:"\u293c",curlyeqprec:"\u22de",curlyeqsucc:"\u22df",curlyvee:"\u22ce",curlywedge:"\u22cf",curren:"\xa4",curvearrowleft:"\u21b6",curvearrowright:"\u21b7",cuvee:"\u22ce",cuwed:"\u22cf",cwconint:"\u2232",cwint:"\u2231",cylcty:"\u232d",dagger:"\u2020",Dagger:"\u2021",daleth:"\u2138",darr:"\u2193",dArr:"\u21d3",Darr:"\u21a1",dash:"\u2010",dashv:"\u22a3",Dashv:"\u2ae4",dbkarow:"\u290f",dblac:"\u02dd",dcaron:"\u010f",Dcaron:"\u010e",dcy:"\u0434",Dcy:"\u0414",dd:"\u2146",DD:"\u2145",ddagger:"\u2021",ddarr:"\u21ca",DDotrahd:"\u2911",ddotseq:"\u2a77",deg:"\xb0",Del:"\u2207",delta:"\u03b4",Delta:"\u0394",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",Dfr:"\ud835\udd07",dHar:"\u2965",dharl:"\u21c3",dharr:"\u21c2",DiacriticalAcute:"\xb4",DiacriticalDot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",DiacriticalGrave:"`",DiacriticalTilde:"\u02dc",diam:"\u22c4",diamond:"\u22c4",Diamond:"\u22c4",diamondsuit:"\u2666",diams:"\u2666",die:"\xa8",DifferentialD:"\u2146",digamma:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",DJcy:"\u0402",dlcorn:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",Dopf:"\ud835\udd3b",dot:"\u02d9",Dot:"\xa8",DotDot:"\u20dc",doteq:"\u2250",doteqdot:"\u2251",DotEqual:"\u2250",dotminus:"\u2238",dotplus:"\u2214",dotsquare:"\u22a1",doublebarwedge:"\u2306",DoubleContourIntegral:"\u222f",DoubleDot:"\xa8",DoubleDownArrow:"\u21d3",DoubleLeftArrow:"\u21d0",DoubleLeftRightArrow:"\u21d4",DoubleLeftTee:"\u2ae4",DoubleLongLeftArrow:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",DoubleLongRightArrow:"\u27f9",DoubleRightArrow:"\u21d2",DoubleRightTee:"\u22a8",DoubleUpArrow:"\u21d1",DoubleUpDownArrow:"\u21d5",DoubleVerticalBar:"\u2225",downarrow:"\u2193",Downarrow:"\u21d3",DownArrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",DownBreve:"\u0311",downdownarrows:"\u21ca",downharpoonleft:"\u21c3",downharpoonright:"\u21c2",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",DownTeeArrow:"\u21a7",drbkarow:"\u2910",drcorn:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",Dscr:"\ud835\udc9f",dscy:"\u0455",DScy:"\u0405",dsol:"\u29f6",dstrok:"\u0111",Dstrok:"\u0110",dtdot:"\u22f1",dtri:"\u25bf",dtrif:"\u25be",duarr:"\u21f5",duhar:"\u296f",dwangle:"\u29a6",dzcy:"\u045f",DZcy:"\u040f",dzigrarr:"\u27ff",eacute:"\xe9",Eacute:"\xc9",easter:"\u2a6e",ecaron:"\u011b",Ecaron:"\u011a",ecir:"\u2256",ecirc:"\xea",Ecirc:"\xca",ecolon:"\u2255",ecy:"\u044d",Ecy:"\u042d",eDDot:"\u2a77",edot:"\u0117",eDot:"\u2251",Edot:"\u0116",ee:"\u2147",efDot:"\u2252",efr:"\ud835\udd22",Efr:"\ud835\udd08",eg:"\u2a9a",egrave:"\xe8",Egrave:"\xc8",egs:"\u2a96",egsdot:"\u2a98",el:"\u2a99",Element:"\u2208",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",Emacr:"\u0112",empty:"\u2205",emptyset:"\u2205",EmptySmallSquare:"\u25fb",emptyv:"\u2205",EmptyVerySmallSquare:"\u25ab",emsp:"\u2003",emsp13:"\u2004",emsp14:"\u2005",eng:"\u014b",ENG:"\u014a",ensp:"\u2002",eogon:"\u0119",Eogon:"\u0118",eopf:"\ud835\udd56",Eopf:"\ud835\udd3c",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",Epsilon:"\u0395",epsiv:"\u03f5",eqcirc:"\u2256",eqcolon:"\u2255",eqsim:"\u2242",eqslantgtr:"\u2a96",eqslantless:"\u2a95",Equal:"\u2a75",equals:"=",EqualTilde:"\u2242",equest:"\u225f",Equilibrium:"\u21cc",equiv:"\u2261",equivDD:"\u2a78",eqvparsl:"\u29e5",erarr:"\u2971",erDot:"\u2253",escr:"\u212f",Escr:"\u2130",esdot:"\u2250",esim:"\u2242",Esim:"\u2a73",eta:"\u03b7",Eta:"\u0397",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",euro:"\u20ac",excl:"!",exist:"\u2203",Exists:"\u2203",expectation:"\u2130",exponentiale:"\u2147",ExponentialE:"\u2147",fallingdotseq:"\u2252",fcy:"\u0444",Fcy:"\u0424",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",Ffr:"\ud835\udd09",filig:"\ufb01",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",Fopf:"\ud835\udd3d",forall:"\u2200",ForAll:"\u2200",fork:"\u22d4",forkv:"\u2ad9",Fouriertrf:"\u2131",fpartint:"\u2a0d",frac12:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",fscr:"\ud835\udcbb",Fscr:"\u2131",gacute:"\u01f5",gamma:"\u03b3",Gamma:"\u0393",gammad:"\u03dd",Gammad:"\u03dc",gap:"\u2a86",gbreve:"\u011f",Gbreve:"\u011e",Gcedil:"\u0122",gcirc:"\u011d",Gcirc:"\u011c",gcy:"\u0433",Gcy:"\u0413",gdot:"\u0121",Gdot:"\u0120",ge:"\u2265",gE:"\u2267",gel:"\u22db",gEl:"\u2a8c",geq:"\u2265",geqq:"\u2267",geqslant:"\u2a7e",ges:"\u2a7e",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",Gfr:"\ud835\udd0a",gg:"\u226b",Gg:"\u22d9",ggg:"\u22d9",gimel:"\u2137",gjcy:"\u0453",GJcy:"\u0403",gl:"\u2277",gla:"\u2aa5",glE:"\u2a92",glj:"\u2aa4",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gnE:"\u2269",gneq:"\u2a88",gneqq:"\u2269",gnsim:"\u22e7",gopf:"\ud835\udd58",Gopf:"\ud835\udd3e",grave:"`",GreaterEqual:"\u2265",GreaterEqualLess:"\u22db",GreaterFullEqual:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",GreaterSlantEqual:"\u2a7e",GreaterTilde:"\u2273",gscr:"\u210a",Gscr:"\ud835\udca2",gsim:"\u2273",gsime:"\u2a8e",gsiml:"\u2a90",gt:">",Gt:"\u226b",GT:">",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrapprox:"\u2a86",gtrarr:"\u2978",gtrdot:"\u22d7",gtreqless:"\u22db",gtreqqless:"\u2a8c",gtrless:"\u2277",gtrsim:"\u2273",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",Hacek:"\u02c7",hairsp:"\u200a",half:"\xbd",hamilt:"\u210b",hardcy:"\u044a",HARDcy:"\u042a",harr:"\u2194",hArr:"\u21d4",harrcir:"\u2948",harrw:"\u21ad",Hat:"^",hbar:"\u210f",hcirc:"\u0125",Hcirc:"\u0124",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",Hfr:"\u210c",HilbertSpace:"\u210b",hksearow:"\u2925",hkswarow:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",hookrightarrow:"\u21aa",hopf:"\ud835\udd59",Hopf:"\u210d",horbar:"\u2015",HorizontalLine:"\u2500",hscr:"\ud835\udcbd",Hscr:"\u210b",hslash:"\u210f",hstrok:"\u0127",Hstrok:"\u0126",HumpDownHump:"\u224e",HumpEqual:"\u224f",hybull:"\u2043",hyphen:"\u2010",iacute:"\xed",Iacute:"\xcd",ic:"\u2063",icirc:"\xee",Icirc:"\xce",icy:"\u0438",Icy:"\u0418",Idot:"\u0130",iecy:"\u0435",IEcy:"\u0415",iexcl:"\xa1",iff:"\u21d4",ifr:"\ud835\udd26",Ifr:"\u2111",igrave:"\xec",Igrave:"\xcc",ii:"\u2148",iiiint:"\u2a0c",iiint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",IJlig:"\u0132",Im:"\u2111",imacr:"\u012b",Imacr:"\u012a",image:"\u2111",ImaginaryI:"\u2148",imagline:"\u2110",imagpart:"\u2111",imath:"\u0131",imof:"\u22b7",imped:"\u01b5",Implies:"\u21d2",in:"\u2208",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",inodot:"\u0131",int:"\u222b",Int:"\u222c",intcal:"\u22ba",integers:"\u2124",Integral:"\u222b",intercal:"\u22ba",Intersection:"\u22c2",intlarhk:"\u2a17",intprod:"\u2a3c",InvisibleComma:"\u2063",InvisibleTimes:"\u2062",iocy:"\u0451",IOcy:"\u0401",iogon:"\u012f",Iogon:"\u012e",iopf:"\ud835\udd5a",Iopf:"\ud835\udd40",iota:"\u03b9",Iota:"\u0399",iprod:"\u2a3c",iquest:"\xbf",iscr:"\ud835\udcbe",Iscr:"\u2110",isin:"\u2208",isindot:"\u22f5",isinE:"\u22f9",isins:"\u22f4",isinsv:"\u22f3",isinv:"\u2208",it:"\u2062",itilde:"\u0129",Itilde:"\u0128",iukcy:"\u0456",Iukcy:"\u0406",iuml:"\xef",Iuml:"\xcf",jcirc:"\u0135",Jcirc:"\u0134",jcy:"\u0439",Jcy:"\u0419",jfr:"\ud835\udd27",Jfr:"\ud835\udd0d",jmath:"\u0237",jopf:"\ud835\udd5b",Jopf:"\ud835\udd41",jscr:"\ud835\udcbf",Jscr:"\ud835\udca5",jsercy:"\u0458",Jsercy:"\u0408",jukcy:"\u0454",Jukcy:"\u0404",kappa:"\u03ba",Kappa:"\u039a",kappav:"\u03f0",kcedil:"\u0137",Kcedil:"\u0136",kcy:"\u043a",Kcy:"\u041a",kfr:"\ud835\udd28",Kfr:"\ud835\udd0e",kgreen:"\u0138",khcy:"\u0445",KHcy:"\u0425",kjcy:"\u045c",KJcy:"\u040c",kopf:"\ud835\udd5c",Kopf:"\ud835\udd42",kscr:"\ud835\udcc0",Kscr:"\ud835\udca6",lAarr:"\u21da",lacute:"\u013a",Lacute:"\u0139",laemptyv:"\u29b4",lagran:"\u2112",lambda:"\u03bb",Lambda:"\u039b",lang:"\u27e8",Lang:"\u27ea",langd:"\u2991",langle:"\u27e8",lap:"\u2a85",Laplacetrf:"\u2112",laquo:"\xab",larr:"\u2190",lArr:"\u21d0",Larr:"\u219e",larrb:"\u21e4",larrbfs:"\u291f",larrfs:"\u291d",larrhk:"\u21a9",larrlp:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",lat:"\u2aab",latail:"\u2919",lAtail:"\u291b",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lBarr:"\u290e",lbbrk:"\u2772",lbrace:"{",lbrack:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",Lcaron:"\u013d",lcedil:"\u013c",Lcedil:"\u013b",lceil:"\u2308",lcub:"{",lcy:"\u043b",Lcy:"\u041b",ldca:"\u2936",ldquo:"\u201c",ldquor:"\u201e",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",lE:"\u2266",LeftAngleBracket:"\u27e8",leftarrow:"\u2190",Leftarrow:"\u21d0",LeftArrow:"\u2190",LeftArrowBar:"\u21e4",LeftArrowRightArrow:"\u21c6",leftarrowtail:"\u21a2",LeftCeiling:"\u2308",LeftDoubleBracket:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",leftharpoondown:"\u21bd",leftharpoonup:"\u21bc",leftleftarrows:"\u21c7",leftrightarrow:"\u2194",Leftrightarrow:"\u21d4",LeftRightArrow:"\u2194",leftrightarrows:"\u21c6",leftrightharpoons:"\u21cb",leftrightsquigarrow:"\u21ad",LeftRightVector:"\u294e",LeftTee:"\u22a3",LeftTeeArrow:"\u21a4",LeftTeeVector:"\u295a",leftthreetimes:"\u22cb",LeftTriangle:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",LeftVectorBar:"\u2952",leg:"\u22da",lEg:"\u2a8b",leq:"\u2264",leqq:"\u2266",leqslant:"\u2a7d",les:"\u2a7d",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessapprox:"\u2a85",lessdot:"\u22d6",lesseqgtr:"\u22da",lesseqqgtr:"\u2a8b",LessEqualGreater:"\u22da",LessFullEqual:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",LessLess:"\u2aa1",lesssim:"\u2272",LessSlantEqual:"\u2a7d",LessTilde:"\u2272",lfisht:"\u297c",lfloor:"\u230a",lfr:"\ud835\udd29",Lfr:"\ud835\udd0f",lg:"\u2276",lgE:"\u2a91",lHar:"\u2962",lhard:"\u21bd",lharu:"\u21bc",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",LJcy:"\u0409",ll:"\u226a",Ll:"\u22d8",llarr:"\u21c7",llcorner:"\u231e",Lleftarrow:"\u21da",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",Lmidot:"\u013f",lmoust:"\u23b0",lmoustache:"\u23b0",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lnE:"\u2268",lneq:"\u2a87",lneqq:"\u2268",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",lobrk:"\u27e6",longleftarrow:"\u27f5",Longleftarrow:"\u27f8",LongLeftArrow:"\u27f5",longleftrightarrow:"\u27f7",Longleftrightarrow:"\u27fa",LongLeftRightArrow:"\u27f7",longmapsto:"\u27fc",longrightarrow:"\u27f6",Longrightarrow:"\u27f9",LongRightArrow:"\u27f6",looparrowleft:"\u21ab",looparrowright:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",Lopf:"\ud835\udd43",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",lowbar:"_",LowerLeftArrow:"\u2199",LowerRightArrow:"\u2198",loz:"\u25ca",lozenge:"\u25ca",lozf:"\u29eb",lpar:"(",lparlt:"\u2993",lrarr:"\u21c6",lrcorner:"\u231f",lrhar:"\u21cb",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",Lscr:"\u2112",lsh:"\u21b0",Lsh:"\u21b0",lsim:"\u2272",lsime:"\u2a8d",lsimg:"\u2a8f",lsqb:"[",lsquo:"\u2018",lsquor:"\u201a",lstrok:"\u0142",Lstrok:"\u0141",lt:"<",Lt:"\u226a",LT:"<",ltcc:"\u2aa6",ltcir:"\u2a79",ltdot:"\u22d6",lthree:"\u22cb",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltri:"\u25c3",ltrie:"\u22b4",ltrif:"\u25c2",ltrPar:"\u2996",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",macr:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",map:"\u21a6",Map:"\u2905",mapsto:"\u21a6",mapstodown:"\u21a7",mapstoleft:"\u21a4",mapstoup:"\u21a5",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",Mcy:"\u041c",mdash:"\u2014",mDDot:"\u223a",measuredangle:"\u2221",MediumSpace:"\u205f",Mellintrf:"\u2133",mfr:"\ud835\udd2a",Mfr:"\ud835\udd10",mho:"\u2127",micro:"\xb5",mid:"\u2223",midast:"*",midcir:"\u2af0",middot:"\xb7",minus:"\u2212",minusb:"\u229f",minusd:"\u2238",minusdu:"\u2a2a",MinusPlus:"\u2213",mlcp:"\u2adb",mldr:"\u2026",mnplus:"\u2213",models:"\u22a7",mopf:"\ud835\udd5e",Mopf:"\ud835\udd44",mp:"\u2213",mscr:"\ud835\udcc2",Mscr:"\u2133",mstpos:"\u223e",mu:"\u03bc",Mu:"\u039c",multimap:"\u22b8",mumap:"\u22b8",nabla:"\u2207",nacute:"\u0144",Nacute:"\u0143",nang:"\u2220\u20d2",nap:"\u2249",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",napprox:"\u2249",natur:"\u266e",natural:"\u266e",naturals:"\u2115",nbsp:"\xa0",nbump:"\u224e\u0338",nbumpe:"\u224f\u0338",ncap:"\u2a43",ncaron:"\u0148",Ncaron:"\u0147",ncedil:"\u0146",Ncedil:"\u0145",ncong:"\u2247",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",Ncy:"\u041d",ndash:"\u2013",ne:"\u2260",nearhk:"\u2924",nearr:"\u2197",neArr:"\u21d7",nearrow:"\u2197",nedot:"\u2250\u0338",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",nequiv:"\u2262",nesear:"\u2928",nesim:"\u2242\u0338",NestedGreaterGreater:"\u226b",NestedLessLess:"\u226a",NewLine:"\n",nexist:"\u2204",nexists:"\u2204",nfr:"\ud835\udd2b",Nfr:"\ud835\udd11",nge:"\u2271",ngE:"\u2267\u0338",ngeq:"\u2271",ngeqq:"\u2267\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",nGg:"\u22d9\u0338",ngsim:"\u2275",ngt:"\u226f",nGt:"\u226b\u20d2",ngtr:"\u226f",nGtv:"\u226b\u0338",nharr:"\u21ae",nhArr:"\u21ce",nhpar:"\u2af2",ni:"\u220b",nis:"\u22fc",nisd:"\u22fa",niv:"\u220b",njcy:"\u045a",NJcy:"\u040a",nlarr:"\u219a",nlArr:"\u21cd",nldr:"\u2025",nle:"\u2270",nlE:"\u2266\u0338",nleftarrow:"\u219a",nLeftarrow:"\u21cd",nleftrightarrow:"\u21ae",nLeftrightarrow:"\u21ce",nleq:"\u2270",nleqq:"\u2266\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",nless:"\u226e",nLl:"\u22d8\u0338",nlsim:"\u2274",nlt:"\u226e",nLt:"\u226a\u20d2",nltri:"\u22ea",nltrie:"\u22ec",nLtv:"\u226a\u0338",nmid:"\u2224",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nopf:"\ud835\udd5f",Nopf:"\u2115",not:"\xac",Not:"\u2aec",NotCongruent:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",NotElement:"\u2209",NotEqual:"\u2260",NotEqualTilde:"\u2242\u0338",NotExists:"\u2204",NotGreater:"\u226f",NotGreaterEqual:"\u2271",NotGreaterFullEqual:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",NotGreaterLess:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",NotGreaterTilde:"\u2275",NotHumpDownHump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",notin:"\u2209",notindot:"\u22f5\u0338",notinE:"\u22f9\u0338",notinva:"\u2209",notinvb:"\u22f7",notinvc:"\u22f6",NotLeftTriangle:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",NotLess:"\u226e",NotLessEqual:"\u2270",NotLessGreater:"\u2278",NotLessLess:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",NotLessTilde:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",notni:"\u220c",notniva:"\u220c",notnivb:"\u22fe",notnivc:"\u22fd",NotPrecedes:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",NotReverseElement:"\u220c",NotRightTriangle:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",NotSubset:"\u2282\u20d2",NotSubsetEqual:"\u2288",NotSucceeds:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",NotSupersetEqual:"\u2289",NotTilde:"\u2241",NotTildeEqual:"\u2244",NotTildeFullEqual:"\u2247",NotTildeTilde:"\u2249",NotVerticalBar:"\u2224",npar:"\u2226",nparallel:"\u2226",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",npr:"\u2280",nprcue:"\u22e0",npre:"\u2aaf\u0338",nprec:"\u2280",npreceq:"\u2aaf\u0338",nrarr:"\u219b",nrArr:"\u21cf",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nrightarrow:"\u219b",nRightarrow:"\u21cf",nrtri:"\u22eb",nrtrie:"\u22ed",nsc:"\u2281",nsccue:"\u22e1",nsce:"\u2ab0\u0338",nscr:"\ud835\udcc3",Nscr:"\ud835\udca9",nshortmid:"\u2224",nshortparallel:"\u2226",nsim:"\u2241",nsime:"\u2244",nsimeq:"\u2244",nsmid:"\u2224",nspar:"\u2226",nsqsube:"\u22e2",nsqsupe:"\u22e3",nsub:"\u2284",nsube:"\u2288",nsubE:"\u2ac5\u0338",nsubset:"\u2282\u20d2",nsubseteq:"\u2288",nsubseteqq:"\u2ac5\u0338",nsucc:"\u2281",nsucceq:"\u2ab0\u0338",nsup:"\u2285",nsupe:"\u2289",nsupE:"\u2ac6\u0338",nsupset:"\u2283\u20d2",nsupseteq:"\u2289",nsupseteqq:"\u2ac6\u0338",ntgl:"\u2279",ntilde:"\xf1",Ntilde:"\xd1",ntlg:"\u2278",ntriangleleft:"\u22ea",ntrianglelefteq:"\u22ec",ntriangleright:"\u22eb",ntrianglerighteq:"\u22ed",nu:"\u03bd",Nu:"\u039d",num:"#",numero:"\u2116",numsp:"\u2007",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvDash:"\u22ad",nVdash:"\u22ae",nVDash:"\u22af",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvHarr:"\u2904",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwarhk:"\u2923",nwarr:"\u2196",nwArr:"\u21d6",nwarrow:"\u2196",nwnear:"\u2927",oacute:"\xf3",Oacute:"\xd3",oast:"\u229b",ocir:"\u229a",ocirc:"\xf4",Ocirc:"\xd4",ocy:"\u043e",Ocy:"\u041e",odash:"\u229d",odblac:"\u0151",Odblac:"\u0150",odiv:"\u2a38",odot:"\u2299",odsold:"\u29bc",oelig:"\u0153",OElig:"\u0152",ofcir:"\u29bf",ofr:"\ud835\udd2c",Ofr:"\ud835\udd12",ogon:"\u02db",ograve:"\xf2",Ograve:"\xd2",ogt:"\u29c1",ohbar:"\u29b5",ohm:"\u03a9",oint:"\u222e",olarr:"\u21ba",olcir:"\u29be",olcross:"\u29bb",oline:"\u203e",olt:"\u29c0",omacr:"\u014d",Omacr:"\u014c",omega:"\u03c9",Omega:"\u03a9",omicron:"\u03bf",Omicron:"\u039f",omid:"\u29b6",ominus:"\u2296",oopf:"\ud835\udd60",Oopf:"\ud835\udd46",opar:"\u29b7",OpenCurlyDoubleQuote:"\u201c",OpenCurlyQuote:"\u2018",operp:"\u29b9",oplus:"\u2295",or:"\u2228",Or:"\u2a54",orarr:"\u21bb",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oS:"\u24c8",oscr:"\u2134",Oscr:"\ud835\udcaa",oslash:"\xf8",Oslash:"\xd8",osol:"\u2298",otilde:"\xf5",Otilde:"\xd5",otimes:"\u2297",Otimes:"\u2a37",otimesas:"\u2a36",ouml:"\xf6",Ouml:"\xd6",ovbar:"\u233d",OverBar:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",OverParenthesis:"\u23dc",par:"\u2225",para:"\xb6",parallel:"\u2225",parsim:"\u2af3",parsl:"\u2afd",part:"\u2202",PartialD:"\u2202",pcy:"\u043f",Pcy:"\u041f",percnt:"%",period:".",permil:"\u2030",perp:"\u22a5",pertenk:"\u2031",pfr:"\ud835\udd2d",Pfr:"\ud835\udd13",phi:"\u03c6",Phi:"\u03a6",phiv:"\u03d5",phmmat:"\u2133",phone:"\u260e",pi:"\u03c0",Pi:"\u03a0",pitchfork:"\u22d4",piv:"\u03d6",planck:"\u210f",planckh:"\u210e",plankv:"\u210f",plus:"+",plusacir:"\u2a23",plusb:"\u229e",pluscir:"\u2a22",plusdo:"\u2214",plusdu:"\u2a25",pluse:"\u2a72",PlusMinus:"\xb1",plusmn:"\xb1",plussim:"\u2a26",plustwo:"\u2a27",pm:"\xb1",Poincareplane:"\u210c",pointint:"\u2a15",popf:"\ud835\udd61",Popf:"\u2119",pound:"\xa3",pr:"\u227a",Pr:"\u2abb",prap:"\u2ab7",prcue:"\u227c",pre:"\u2aaf",prE:"\u2ab3",prec:"\u227a",precapprox:"\u2ab7",preccurlyeq:"\u227c",Precedes:"\u227a",PrecedesEqual:"\u2aaf",PrecedesSlantEqual:"\u227c",PrecedesTilde:"\u227e",preceq:"\u2aaf",precnapprox:"\u2ab9",precneqq:"\u2ab5",precnsim:"\u22e8",precsim:"\u227e",prime:"\u2032",Prime:"\u2033",primes:"\u2119",prnap:"\u2ab9",prnE:"\u2ab5",prnsim:"\u22e8",prod:"\u220f",Product:"\u220f",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prop:"\u221d",Proportion:"\u2237",Proportional:"\u221d",propto:"\u221d",prsim:"\u227e",prurel:"\u22b0",pscr:"\ud835\udcc5",Pscr:"\ud835\udcab",psi:"\u03c8",Psi:"\u03a8",puncsp:"\u2008",qfr:"\ud835\udd2e",Qfr:"\ud835\udd14",qint:"\u2a0c",qopf:"\ud835\udd62",Qopf:"\u211a",qprime:"\u2057",qscr:"\ud835\udcc6",Qscr:"\ud835\udcac",quaternions:"\u210d",quatint:"\u2a16",quest:"?",questeq:"\u225f",quot:'"',QUOT:'"',rAarr:"\u21db",race:"\u223d\u0331",racute:"\u0155",Racute:"\u0154",radic:"\u221a",raemptyv:"\u29b3",rang:"\u27e9",Rang:"\u27eb",rangd:"\u2992",range:"\u29a5",rangle:"\u27e9",raquo:"\xbb",rarr:"\u2192",rArr:"\u21d2",Rarr:"\u21a0",rarrap:"\u2975",rarrb:"\u21e5",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrhk:"\u21aa",rarrlp:"\u21ac",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",Rarrtl:"\u2916",rarrw:"\u219d",ratail:"\u291a",rAtail:"\u291c",ratio:"\u2236",rationals:"\u211a",rbarr:"\u290d",rBarr:"\u290f",RBarr:"\u2910",rbbrk:"\u2773",rbrace:"}",rbrack:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",Rcaron:"\u0158",rcedil:"\u0157",Rcedil:"\u0156",rceil:"\u2309",rcub:"}",rcy:"\u0440",Rcy:"\u0420",rdca:"\u2937",rdldhar:"\u2969",rdquo:"\u201d",rdquor:"\u201d",rdsh:"\u21b3",Re:"\u211c",real:"\u211c",realine:"\u211b",realpart:"\u211c",reals:"\u211d",rect:"\u25ad",reg:"\xae",REG:"\xae",ReverseElement:"\u220b",ReverseEquilibrium:"\u21cb",ReverseUpEquilibrium:"\u296f",rfisht:"\u297d",rfloor:"\u230b",rfr:"\ud835\udd2f",Rfr:"\u211c",rHar:"\u2964",rhard:"\u21c1",rharu:"\u21c0",rharul:"\u296c",rho:"\u03c1",Rho:"\u03a1",rhov:"\u03f1",RightAngleBracket:"\u27e9",rightarrow:"\u2192",Rightarrow:"\u21d2",RightArrow:"\u2192",RightArrowBar:"\u21e5",RightArrowLeftArrow:"\u21c4",rightarrowtail:"\u21a3",RightCeiling:"\u2309",RightDoubleBracket:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rightharpoondown:"\u21c1",rightharpoonup:"\u21c0",rightleftarrows:"\u21c4",rightleftharpoons:"\u21cc",rightrightarrows:"\u21c9",rightsquigarrow:"\u219d",RightTee:"\u22a2",RightTeeArrow:"\u21a6",RightTeeVector:"\u295b",rightthreetimes:"\u22cc",RightTriangle:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",RightVectorBar:"\u2953",ring:"\u02da",risingdotseq:"\u2253",rlarr:"\u21c4",rlhar:"\u21cc",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",robrk:"\u27e7",ropar:"\u2986",ropf:"\ud835\udd63",Ropf:"\u211d",roplus:"\u2a2e",rotimes:"\u2a35",RoundImplies:"\u2970",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rrarr:"\u21c9",Rrightarrow:"\u21db",rsaquo:"\u203a",rscr:"\ud835\udcc7",Rscr:"\u211b",rsh:"\u21b1",Rsh:"\u21b1",rsqb:"]",rsquo:"\u2019",rsquor:"\u2019",rthree:"\u22cc",rtimes:"\u22ca",rtri:"\u25b9",rtrie:"\u22b5",rtrif:"\u25b8",rtriltri:"\u29ce",RuleDelayed:"\u29f4",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",Sacute:"\u015a",sbquo:"\u201a",sc:"\u227b",Sc:"\u2abc",scap:"\u2ab8",scaron:"\u0161",Scaron:"\u0160",sccue:"\u227d",sce:"\u2ab0",scE:"\u2ab4",scedil:"\u015f",Scedil:"\u015e",scirc:"\u015d",Scirc:"\u015c",scnap:"\u2aba",scnE:"\u2ab6",scnsim:"\u22e9",scpolint:"\u2a13",scsim:"\u227f",scy:"\u0441",Scy:"\u0421",sdot:"\u22c5",sdotb:"\u22a1",sdote:"\u2a66",searhk:"\u2925",searr:"\u2198",seArr:"\u21d8",searrow:"\u2198",sect:"\xa7",semi:";",seswar:"\u2929",setminus:"\u2216",setmn:"\u2216",sext:"\u2736",sfr:"\ud835\udd30",Sfr:"\ud835\udd16",sfrown:"\u2322",sharp:"\u266f",shchcy:"\u0449",SHCHcy:"\u0429",shcy:"\u0448",SHcy:"\u0428",ShortDownArrow:"\u2193",ShortLeftArrow:"\u2190",shortmid:"\u2223",shortparallel:"\u2225",ShortRightArrow:"\u2192",ShortUpArrow:"\u2191",shy:"\xad",sigma:"\u03c3",Sigma:"\u03a3",sigmaf:"\u03c2",sigmav:"\u03c2",sim:"\u223c",simdot:"\u2a6a",sime:"\u2243",simeq:"\u2243",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",slarr:"\u2190",SmallCircle:"\u2218",smallsetminus:"\u2216",smashp:"\u2a33",smeparsl:"\u29e4",smid:"\u2223",smile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",SOFTcy:"\u042c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",Sopf:"\ud835\udd4a",spades:"\u2660",spadesuit:"\u2660",spar:"\u2225",sqcap:"\u2293",sqcaps:"\u2293\ufe00",sqcup:"\u2294",sqcups:"\u2294\ufe00",Sqrt:"\u221a",sqsub:"\u228f",sqsube:"\u2291",sqsubset:"\u228f",sqsubseteq:"\u2291",sqsup:"\u2290",sqsupe:"\u2292",sqsupset:"\u2290",sqsupseteq:"\u2292",squ:"\u25a1",square:"\u25a1",Square:"\u25a1",SquareIntersection:"\u2293",SquareSubset:"\u228f",SquareSubsetEqual:"\u2291",SquareSuperset:"\u2290",SquareSupersetEqual:"\u2292",SquareUnion:"\u2294",squarf:"\u25aa",squf:"\u25aa",srarr:"\u2192",sscr:"\ud835\udcc8",Sscr:"\ud835\udcae",ssetmn:"\u2216",ssmile:"\u2323",sstarf:"\u22c6",star:"\u2606",Star:"\u22c6",starf:"\u2605",straightepsilon:"\u03f5",straightphi:"\u03d5",strns:"\xaf",sub:"\u2282",Sub:"\u22d0",subdot:"\u2abd",sube:"\u2286",subE:"\u2ac5",subedot:"\u2ac3",submult:"\u2ac1",subne:"\u228a",subnE:"\u2acb",subplus:"\u2abf",subrarr:"\u2979",subset:"\u2282",Subset:"\u22d0",subseteq:"\u2286",subseteqq:"\u2ac5",SubsetEqual:"\u2286",subsetneq:"\u228a",subsetneqq:"\u2acb",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",succ:"\u227b",succapprox:"\u2ab8",succcurlyeq:"\u227d",Succeeds:"\u227b",SucceedsEqual:"\u2ab0",SucceedsSlantEqual:"\u227d",SucceedsTilde:"\u227f",succeq:"\u2ab0",succnapprox:"\u2aba",succneqq:"\u2ab6",succnsim:"\u22e9",succsim:"\u227f",SuchThat:"\u220b",sum:"\u2211",Sum:"\u2211",sung:"\u266a",sup:"\u2283",Sup:"\u22d1",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supdot:"\u2abe",supdsub:"\u2ad8",supe:"\u2287",supE:"\u2ac6",supedot:"\u2ac4",Superset:"\u2283",SupersetEqual:"\u2287",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supne:"\u228b",supnE:"\u2acc",supplus:"\u2ac0",supset:"\u2283",Supset:"\u22d1",supseteq:"\u2287",supseteqq:"\u2ac6",supsetneq:"\u228b",supsetneqq:"\u2acc",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swarhk:"\u2926",swarr:"\u2199",swArr:"\u21d9",swarrow:"\u2199",swnwar:"\u292a",szlig:"\xdf",Tab:"\t",target:"\u2316",tau:"\u03c4",Tau:"\u03a4",tbrk:"\u23b4",tcaron:"\u0165",Tcaron:"\u0164",tcedil:"\u0163",Tcedil:"\u0162",tcy:"\u0442",Tcy:"\u0422",tdot:"\u20db",telrec:"\u2315",tfr:"\ud835\udd31",Tfr:"\ud835\udd17",there4:"\u2234",therefore:"\u2234",Therefore:"\u2234",theta:"\u03b8",Theta:"\u0398",thetasym:"\u03d1",thetav:"\u03d1",thickapprox:"\u2248",thicksim:"\u223c",ThickSpace:"\u205f\u200a",thinsp:"\u2009",ThinSpace:"\u2009",thkap:"\u2248",thksim:"\u223c",thorn:"\xfe",THORN:"\xde",tilde:"\u02dc",Tilde:"\u223c",TildeEqual:"\u2243",TildeFullEqual:"\u2245",TildeTilde:"\u2248",times:"\xd7",timesb:"\u22a0",timesbar:"\u2a31",timesd:"\u2a30",tint:"\u222d",toea:"\u2928",top:"\u22a4",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",Topf:"\ud835\udd4b",topfork:"\u2ada",tosa:"\u2929",tprime:"\u2034",trade:"\u2122",TRADE:"\u2122",triangle:"\u25b5",triangledown:"\u25bf",triangleleft:"\u25c3",trianglelefteq:"\u22b4",triangleq:"\u225c",triangleright:"\u25b9",trianglerighteq:"\u22b5",tridot:"\u25ec",trie:"\u225c",triminus:"\u2a3a",TripleDot:"\u20db",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",Tscr:"\ud835\udcaf",tscy:"\u0446",TScy:"\u0426",tshcy:"\u045b",TSHcy:"\u040b",tstrok:"\u0167",Tstrok:"\u0166",twixt:"\u226c",twoheadleftarrow:"\u219e",twoheadrightarrow:"\u21a0",uacute:"\xfa",Uacute:"\xda",uarr:"\u2191",uArr:"\u21d1",Uarr:"\u219f",Uarrocir:"\u2949",ubrcy:"\u045e",Ubrcy:"\u040e",ubreve:"\u016d",Ubreve:"\u016c",ucirc:"\xfb",Ucirc:"\xdb",ucy:"\u0443",Ucy:"\u0423",udarr:"\u21c5",udblac:"\u0171",Udblac:"\u0170",udhar:"\u296e",ufisht:"\u297e",ufr:"\ud835\udd32",Ufr:"\ud835\udd18",ugrave:"\xf9",Ugrave:"\xd9",uHar:"\u2963",uharl:"\u21bf",uharr:"\u21be",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",Umacr:"\u016a",uml:"\xa8",UnderBar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",UnionPlus:"\u228e",uogon:"\u0173",Uogon:"\u0172",uopf:"\ud835\udd66",Uopf:"\ud835\udd4c",uparrow:"\u2191",Uparrow:"\u21d1",UpArrow:"\u2191",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",updownarrow:"\u2195",Updownarrow:"\u21d5",UpDownArrow:"\u2195",UpEquilibrium:"\u296e",upharpoonleft:"\u21bf",upharpoonright:"\u21be",uplus:"\u228e",UpperLeftArrow:"\u2196",UpperRightArrow:"\u2197",upsi:"\u03c5",Upsi:"\u03d2",upsih:"\u03d2",upsilon:"\u03c5",Upsilon:"\u03a5",UpTee:"\u22a5",UpTeeArrow:"\u21a5",upuparrows:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",Uring:"\u016e",urtri:"\u25f9",uscr:"\ud835\udcca",Uscr:"\ud835\udcb0",utdot:"\u22f0",utilde:"\u0169",Utilde:"\u0168",utri:"\u25b5",utrif:"\u25b4",uuarr:"\u21c8",uuml:"\xfc",Uuml:"\xdc",uwangle:"\u29a7",vangrt:"\u299c",varepsilon:"\u03f5",varkappa:"\u03f0",varnothing:"\u2205",varphi:"\u03d5",varpi:"\u03d6",varpropto:"\u221d",varr:"\u2195",vArr:"\u21d5",varrho:"\u03f1",varsigma:"\u03c2",varsubsetneq:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vartheta:"\u03d1",vartriangleleft:"\u22b2",vartriangleright:"\u22b3",vBar:"\u2ae8",Vbar:"\u2aeb",vBarv:"\u2ae9",vcy:"\u0432",Vcy:"\u0412",vdash:"\u22a2",vDash:"\u22a8",Vdash:"\u22a9",VDash:"\u22ab",Vdashl:"\u2ae6",vee:"\u2228",Vee:"\u22c1",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",verbar:"|",Verbar:"\u2016",vert:"|",Vert:"\u2016",VerticalBar:"\u2223",VerticalLine:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",VeryThinSpace:"\u200a",vfr:"\ud835\udd33",Vfr:"\ud835\udd19",vltri:"\u22b2",vnsub:"\u2282\u20d2",vnsup:"\u2283\u20d2",vopf:"\ud835\udd67",Vopf:"\ud835\udd4d",vprop:"\u221d",vrtri:"\u22b3",vscr:"\ud835\udccb",Vscr:"\ud835\udcb1",vsubne:"\u228a\ufe00",vsubnE:"\u2acb\ufe00",vsupne:"\u228b\ufe00",vsupnE:"\u2acc\ufe00",Vvdash:"\u22aa",vzigzag:"\u299a",wcirc:"\u0175",Wcirc:"\u0174",wedbar:"\u2a5f",wedge:"\u2227",Wedge:"\u22c0",wedgeq:"\u2259",weierp:"\u2118",wfr:"\ud835\udd34",Wfr:"\ud835\udd1a",wopf:"\ud835\udd68",Wopf:"\ud835\udd4e",wp:"\u2118",wr:"\u2240",wreath:"\u2240",wscr:"\ud835\udccc",Wscr:"\ud835\udcb2",xcap:"\u22c2",xcirc:"\u25ef",xcup:"\u22c3",xdtri:"\u25bd",xfr:"\ud835\udd35",Xfr:"\ud835\udd1b",xharr:"\u27f7",xhArr:"\u27fa",xi:"\u03be",Xi:"\u039e",xlarr:"\u27f5",xlArr:"\u27f8",xmap:"\u27fc",xnis:"\u22fb",xodot:"\u2a00",xopf:"\ud835\udd69",Xopf:"\ud835\udd4f",xoplus:"\u2a01",xotime:"\u2a02",xrarr:"\u27f6",xrArr:"\u27f9",xscr:"\ud835\udccd",Xscr:"\ud835\udcb3",xsqcup:"\u2a06",xuplus:"\u2a04",xutri:"\u25b3",xvee:"\u22c1",xwedge:"\u22c0",yacute:"\xfd",Yacute:"\xdd",yacy:"\u044f",YAcy:"\u042f",ycirc:"\u0177",Ycirc:"\u0176",ycy:"\u044b",Ycy:"\u042b",yen:"\xa5",yfr:"\ud835\udd36",Yfr:"\ud835\udd1c",yicy:"\u0457",YIcy:"\u0407",yopf:"\ud835\udd6a",Yopf:"\ud835\udd50",yscr:"\ud835\udcce",Yscr:"\ud835\udcb4",yucy:"\u044e",YUcy:"\u042e",yuml:"\xff",Yuml:"\u0178",zacute:"\u017a",Zacute:"\u0179",zcaron:"\u017e",Zcaron:"\u017d",zcy:"\u0437",Zcy:"\u0417",zdot:"\u017c",Zdot:"\u017b",zeetrf:"\u2128",ZeroWidthSpace:"\u200b",zeta:"\u03b6",Zeta:"\u0396",zfr:"\ud835\udd37",Zfr:"\u2128",zhcy:"\u0436",ZHcy:"\u0416",zigrarr:"\u21dd",zopf:"\ud835\udd6b",Zopf:"\u2124",zscr:"\ud835\udccf",Zscr:"\ud835\udcb5",zwj:"\u200d",zwnj:"\u200c"},h={aacute:"\xe1",Aacute:"\xc1",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",aelig:"\xe6",AElig:"\xc6",agrave:"\xe0",Agrave:"\xc0",amp:"&",AMP:"&",aring:"\xe5",Aring:"\xc5",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",brvbar:"\xa6",ccedil:"\xe7",Ccedil:"\xc7",cedil:"\xb8",cent:"\xa2",copy:"\xa9",COPY:"\xa9",curren:"\xa4",deg:"\xb0",divide:"\xf7",eacute:"\xe9",Eacute:"\xc9",ecirc:"\xea",Ecirc:"\xca",egrave:"\xe8",Egrave:"\xc8",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",frac12:"\xbd",frac14:"\xbc",frac34:"\xbe",gt:">",GT:">",iacute:"\xed",Iacute:"\xcd",icirc:"\xee",Icirc:"\xce",iexcl:"\xa1",igrave:"\xec",Igrave:"\xcc",iquest:"\xbf",iuml:"\xef",Iuml:"\xcf",laquo:"\xab",lt:"<",LT:"<",macr:"\xaf",micro:"\xb5",middot:"\xb7",nbsp:"\xa0",not:"\xac",ntilde:"\xf1",Ntilde:"\xd1",oacute:"\xf3",Oacute:"\xd3",ocirc:"\xf4",Ocirc:"\xd4",ograve:"\xf2",Ograve:"\xd2",ordf:"\xaa",ordm:"\xba",oslash:"\xf8",Oslash:"\xd8",otilde:"\xf5",Otilde:"\xd5",ouml:"\xf6",Ouml:"\xd6",para:"\xb6",plusmn:"\xb1",pound:"\xa3",quot:'"',QUOT:'"',raquo:"\xbb",reg:"\xae",REG:"\xae",sect:"\xa7",shy:"\xad",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",szlig:"\xdf",thorn:"\xfe",THORN:"\xde",times:"\xd7",uacute:"\xfa",Uacute:"\xda",ucirc:"\xfb",Ucirc:"\xdb",ugrave:"\xf9",Ugrave:"\xd9",uml:"\xa8",uuml:"\xfc",Uuml:"\xdc",yacute:"\xfd",Yacute:"\xdd",yen:"\xa5",yuml:"\xff"},g={0:"\ufffd",128:"\u20ac",130:"\u201a",131:"\u0192",132:"\u201e",133:"\u2026",134:"\u2020",135:"\u2021",136:"\u02c6",137:"\u2030",138:"\u0160",139:"\u2039",140:"\u0152",142:"\u017d",145:"\u2018",146:"\u2019",147:"\u201c",148:"\u201d",149:"\u2022",150:"\u2013",151:"\u2014",152:"\u02dc",153:"\u2122",154:"\u0161",155:"\u203a",156:"\u0153",158:"\u017e",159:"\u0178"},b=[1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65e3,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111],y=String.fromCharCode,v={}.hasOwnProperty,w=function(e,t){return v.call(e,t)},A=function(e,t){if(!e)return t;var r,n={};for(r in t)n[r]=w(e,r)?e[r]:t[r];return n},D=function(e,t){var r="";return e>=55296&&e<=57343||e>1114111?(t&&$("character reference outside the permissible Unicode range"),"\ufffd"):w(g,e)?(t&&$("disallowed character reference"),g[e]):(t&&function(e,t){for(var r=-1,n=e.length;++r<n;)if(e[r]==t)return!0;return!1}(b,e)&&$("disallowed character reference"),e>65535&&(r+=y((e-=65536)>>>10&1023|55296),e=56320|1023&e),r+=y(e))},x=function(e){return"&#x"+e.toString(16).toUpperCase()+";"},q=function(e){return"&#"+e+";"},$=function(e){throw Error("Parse error: "+e)},k=function(e,t){(t=A(t,k.options)).strict&&d.test(e)&&$("forbidden code point");var r=t.encodeEverything,n=t.useNamedReferences,u=t.allowUnsafeSymbols,p=t.decimal?q:x,f=function(e){return p(e.charCodeAt(0))};return r?(e=e.replace(s,function(e){return n&&w(c,e)?"&"+c[e]+";":f(e)}),n&&(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;").replace(/&#x66;&#x6A;/g,"&fjlig;")),n&&(e=e.replace(i,function(e){return"&"+c[e]+";"}))):n?(u||(e=e.replace(l,function(e){return"&"+c[e]+";"})),e=(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;")).replace(i,function(e){return"&"+c[e]+";"})):u||(e=e.replace(l,f)),e.replace(o,function(e){var t=e.charCodeAt(0),r=e.charCodeAt(1);return p(1024*(t-55296)+r-56320+65536)}).replace(a,f)};k.options={allowUnsafeSymbols:!1,encodeEverything:!1,strict:!1,useNamedReferences:!1,decimal:!1};var E=function(e,t){var r=(t=A(t,E.options)).strict;return r&&p.test(e)&&$("malformed character reference"),e.replace(f,function(e,n,o,s,a,i,c,l,u){var p,d,f,g,b,y;return n?m[b=n]:o?(b=o,(y=s)&&t.isAttributeValue?(r&&"="==y&&$("`&` did not start a character reference"),e):(r&&$("named character reference was not terminated by a semicolon"),h[b]+(y||""))):a?(f=a,d=i,r&&!d&&$("character reference was not terminated by a semicolon"),p=parseInt(f,10),D(p,r)):c?(g=c,d=l,r&&!d&&$("character reference was not terminated by a semicolon"),p=parseInt(g,16),D(p,r)):(r&&$("named character reference was not terminated by a semicolon"),e)})};E.options={isAttributeValue:!1,strict:!1};var _={version:"1.2.0",encode:k,decode:E,escape:function(e){return e.replace(l,function(e){return u[e]})},unescape:E};if("function"==typeof define&&"object"==typeof define.amd&&define.amd)define(function(){return _});else if(t&&!t.nodeType)if(r)r.exports=_;else for(var C in _)w(_,C)&&(t[C]=_[C]);else e.he=_}(void 0);const fs=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),ms=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),hs=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),gs=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,bs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ys=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${U.source}]*`,vs=`((?:${ys}\\:)?${ys})`,ws=new RegExp(`^<${vs}`),As=/^\s*(\/?)>/,Ds=new RegExp(`^<\\/${vs}[^>]*>`),xs=/^<!DOCTYPE [^>]+>/i,qs=/^<!\--/,$s=/^<!\[/,ks=d("script,style,textarea",!0),Es={},_s={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Cs=/&(?:lt|gt|quot|amp|#39);/g,Ss=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ls=d("pre,textarea",!0),Ts=(e,t)=>e&&Ls(e)&&"\n"===t[0];function Ns(e,t){const r=t?Ss:Cs;return e.replace(r,e=>_s[e])}const Os=/^@|^v-on:/,Rs=/^v-|^@|^:|^#/,Fs=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Bs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Us=/^\(|\)$/g,Vs=/^\[.*\]$/,Is=/:(.*)$/,js=/^:|^\.|^v-bind:/,Ps=/\.[^.\]]+(?=[^\]]*$)/g,Hs=/^v-slot(:|$)|^#/,Ms=/[\r\n]/,Gs=/[ \f\t\r\n]+/g,zs=y(void 0),Js="_empty_";let Ks,Zs,Ys,Ws,Qs,Xs,ea,ta;function ra(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:la(t),rawAttrsMap:{},parent:r,children:[]}}function na(e,t){Ks=t.warn||bn,Xs=t.isPreTag||C,ea=t.mustUseProp||C,ta=t.getTagNamespace||C;t.isReservedTag;Ys=yn(t.modules,"transformNode"),Ws=yn(t.modules,"preTransformNode"),Qs=yn(t.modules,"postTransformNode"),Zs=t.delimiters;const r=[],n=!1!==t.preserveWhitespace,o=t.whitespace;let s,a,i=!1,c=!1;function l(e){if(u(e),i||e.processed||(e=oa(e,t)),r.length||e===s||s.if&&(e.elseif||e.else)&&aa(s,{exp:e.elseif,block:e}),a&&!e.forbidden)if(e.elseif||e.else)!function(e,t){const r=function(e){let t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(t.children);r&&r.if&&aa(r,{exp:e.elseif,block:e})}(e,a);else{if(e.slotScope){const t=e.slotTarget||'"default"';(a.scopedSlots||(a.scopedSlots={}))[t]=e}a.children.push(e),e.parent=a}e.children=e.children.filter(e=>!e.slotScope),u(e),e.pre&&(i=!1),Xs(e.tag)&&(c=!1);for(let r=0;r<Qs.length;r++)Qs[r](e,t)}function u(e){if(!c){let t;for(;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}}return function(e,t){const r=[],n=t.expectHTML,o=t.isUnaryTag||C,s=t.canBeLeftOpenTag||C;let a,i,c=0;for(;e;){if(a=e,i&&ks(i)){let r=0;const n=i.toLowerCase(),o=Es[n]||(Es[n]=new RegExp("([\\s\\S]*?)(</"+n+"[^>]*>)","i")),s=e.replace(o,function(e,o,s){return r=s.length,ks(n)||"noscript"===n||(o=o.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ts(n,o)&&(o=o.slice(1)),t.chars&&t.chars(o),""});c+=e.length-s.length,e=s,d(n,c-r,c)}else{let r,n,o,s=e.indexOf("<");if(0===s){if(qs.test(e)){const r=e.indexOf("--\x3e");if(r>=0){t.shouldKeepComment&&t.comment(e.substring(4,r),c,c+r+3),l(r+3);continue}}if($s.test(e)){const t=e.indexOf("]>");if(t>=0){l(t+2);continue}}const r=e.match(xs);if(r){l(r[0].length);continue}const n=e.match(Ds);if(n){const e=c;l(n[0].length),d(n[1],e,c);continue}const o=u();if(o){p(o),Ts(o.tagName,e)&&l(1);continue}}if(s>=0){for(n=e.slice(s);!(Ds.test(n)||ws.test(n)||qs.test(n)||$s.test(n)||(o=n.indexOf("<",1))<0);)s+=o,n=e.slice(s);r=e.substring(0,s)}s<0&&(r=e),r&&l(r.length),t.chars&&r&&t.chars(r,c-r.length,c)}if(e===a){t.chars&&t.chars(e);break}}function l(t){c+=t,e=e.substring(t)}function u(){const t=e.match(ws);if(t){const r={tagName:t[1],attrs:[],start:c};let n,o;for(l(t[0].length);!(n=e.match(As))&&(o=e.match(bs)||e.match(gs));)o.start=c,l(o[0].length),o.end=c,r.attrs.push(o);if(n)return r.unarySlash=n[1],l(n[0].length),r.end=c,r}}function p(e){const a=e.tagName,c=e.unarySlash;n&&("p"===i&&hs(a)&&d(i),s(a)&&i===a&&d(a));const l=o(a)||!!c,u=e.attrs.length,p=new Array(u);for(let r=0;r<u;r++){const n=e.attrs[r],o=n[3]||n[4]||n[5]||"",s="a"===a&&"href"===n[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[r]={name:n[1],value:Ns(o,s)}}l||(r.push({tag:a,lowerCasedTag:a.toLowerCase(),attrs:p,start:e.start,end:e.end}),i=a),t.start&&t.start(a,p,l,e.start,e.end)}function d(e,n,o){let s,a;if(null==n&&(n=c),null==o&&(o=c),e)for(a=e.toLowerCase(),s=r.length-1;s>=0&&r[s].lowerCasedTag!==a;s--);else s=0;if(s>=0){for(let e=r.length-1;e>=s;e--)t.end&&t.end(r[e].tag,n,o);r.length=s,i=s&&r[s-1].tag}else"br"===a?t.start&&t.start(e,[],!0,n,o):"p"===a&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}d()}(e,{warn:Ks,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start(e,n,o,u,p){const d=a&&a.ns||ta(e);J&&"svg"===d&&(n=function(e){const t=[];for(let r=0;r<e.length;r++){const n=e[r];ua.test(n.name)||(n.name=n.name.replace(pa,""),t.push(n))}return t}(n));let f=ra(e,n,a);var m;d&&(f.ns=d),"style"!==(m=f).tag&&("script"!==m.tag||m.attrsMap.type&&"text/javascript"!==m.attrsMap.type)||te()||(f.forbidden=!0);for(let e=0;e<Ws.length;e++)f=Ws[e](f,t)||f;i||(!function(e){null!=kn(e,"v-pre")&&(e.pre=!0)}(f),f.pre&&(i=!0)),Xs(f.tag)&&(c=!0),i?function(e){const t=e.attrsList,r=t.length;if(r){const n=e.attrs=new Array(r);for(let e=0;e<r;e++)n[e]={name:t[e].name,value:JSON.stringify(t[e].value)},null!=t[e].start&&(n[e].start=t[e].start,n[e].end=t[e].end)}else e.pre||(e.plain=!0)}(f):f.processed||(sa(f),function(e){const t=kn(e,"v-if");if(t)e.if=t,aa(e,{exp:t,block:e});else{null!=kn(e,"v-else")&&(e.else=!0);const t=kn(e,"v-else-if");t&&(e.elseif=t)}}(f),function(e){null!=kn(e,"v-once")&&(e.once=!0)}(f)),s||(s=f),o?l(f):(a=f,r.push(f))},end(e,t,n){const o=r[r.length-1];r.length-=1,a=r[r.length-1],l(o)},chars(e,t,r){if(!a)return;if(J&&"textarea"===a.tag&&a.attrsMap.placeholder===e)return;const s=a.children;var l;if(e=c||e.trim()?"script"===(l=a).tag||"style"===l.tag?e:zs(e):s.length?o?"condense"===o&&Ms.test(e)?"":" ":n?" ":"":""){let t,r;c||"condense"!==o||(e=e.replace(Gs," ")),!i&&" "!==e&&(t=function(e,t){const r=t?us(t):cs;if(!r.test(e))return;const n=[],o=[];let s,a,i,c=r.lastIndex=0;for(;s=r.exec(e);){(a=s.index)>c&&(o.push(i=e.slice(c,a)),n.push(JSON.stringify(i)));const t=hn(s[1].trim());n.push(`_s(${t})`),o.push({"@binding":t}),c=a+s[0].length}return c<e.length&&(o.push(i=e.slice(c)),n.push(JSON.stringify(i))),{expression:n.join("+"),tokens:o}}(e,Zs))?r={type:2,expression:t.expression,tokens:t.tokens,text:e}:" "===e&&s.length&&" "===s[s.length-1].text||(r={type:3,text:e}),r&&s.push(r)}},comment(e,t,r){if(a){const t={type:3,text:e,isComment:!0};a.children.push(t)}}}),s}function oa(e,t){var r;!function(e){const t=$n(e,"key");t&&(e.key=t)}(e),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){const t=$n(e,"ref");t&&(e.ref=t,e.refInFor=function(e){let t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){let t;"template"===e.tag?(t=kn(e,"scope"),e.slotScope=t||kn(e,"slot-scope")):(t=kn(e,"slot-scope"))&&(e.slotScope=t);const r=$n(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||wn(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){const t=En(e,Hs);if(t){const{name:r,dynamic:n}=ia(t);e.slotTarget=r,e.slotTargetDynamic=n,e.slotScope=t.value||Js}}else{const t=En(e,Hs);if(t){const r=e.scopedSlots||(e.scopedSlots={}),{name:n,dynamic:o}=ia(t),s=r[n]=ra("template",[],e);s.slotTarget=n,s.slotTargetDynamic=o,s.children=e.children.filter(e=>{if(!e.slotScope)return e.parent=s,!0}),s.slotScope=t.value||Js,e.children=[],e.plain=!1}}}(e),"slot"===(r=e).tag&&(r.slotName=$n(r,"name")),function(e){let t;(t=$n(e,"is"))&&(e.component=t);null!=kn(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(let r=0;r<Ys.length;r++)e=Ys[r](e,t)||e;return function(e){const t=e.attrsList;let r,n,o,s,a,i,c,l;for(r=0,n=t.length;r<n;r++)if(o=s=t[r].name,a=t[r].value,Rs.test(o))if(e.hasBindings=!0,(i=ca(o.replace(Rs,"")))&&(o=o.replace(Ps,"")),js.test(o))o=o.replace(js,""),a=hn(a),(l=Vs.test(o))&&(o=o.slice(1,-1)),i&&(i.prop&&!l&&"innerHtml"===(o=w(o))&&(o="innerHTML"),i.camel&&!l&&(o=w(o)),i.sync&&(c=Sn(a,"$event"),l?qn(e,`"update:"+(${o})`,c,null,!1,0,t[r],!0):(qn(e,`update:${w(o)}`,c,null,!1,0,t[r]),x(o)!==w(o)&&qn(e,`update:${x(o)}`,c,null,!1,0,t[r])))),i&&i.prop||!e.component&&ea(e.tag,e.attrsMap.type,o)?vn(e,o,a,t[r],l):wn(e,o,a,t[r],l);else if(Os.test(o))o=o.replace(Os,""),(l=Vs.test(o))&&(o=o.slice(1,-1)),qn(e,o,a,i,!1,0,t[r],l);else{const n=(o=o.replace(Rs,"")).match(Is);let c=n&&n[1];l=!1,c&&(o=o.slice(0,-(c.length+1)),Vs.test(c)&&(c=c.slice(1,-1),l=!0)),Dn(e,o,s,a,c,l,i,t[r])}else wn(e,o,JSON.stringify(a),t[r]),!e.component&&"muted"===o&&ea(e.tag,e.attrsMap.type,o)&&vn(e,o,"true",t[r])}(e),e}function sa(e){let t;if(t=kn(e,"v-for")){const r=function(e){const t=e.match(Fs);if(!t)return;const r={};r.for=t[2].trim();const n=t[1].trim().replace(Us,""),o=n.match(Bs);o?(r.alias=n.replace(Bs,"").trim(),r.iterator1=o[1].trim(),o[2]&&(r.iterator2=o[2].trim())):r.alias=n;return r}(t);r&&k(e,r)}}function aa(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function ia(e){let t=e.name.replace(Hs,"");return t||"#"!==e.name[0]&&(t="default"),Vs.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:`"${t}"`,dynamic:!1}}function ca(e){const t=e.match(Ps);if(t){const e={};return t.forEach(t=>{e[t.slice(1)]=!0}),e}}function la(e){const t={};for(let r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}const ua=/^xmlns:NS\d+/,pa=/^NS\d+:/;function da(e){return ra(e.tag,e.attrsList.slice(),e.parent)}var fa=[ps,ds,{preTransformNode:function(e,t){if("input"===e.tag){const r=e.attrsMap;if(!r["v-model"])return;let n;if((r[":type"]||r["v-bind:type"])&&(n=$n(e,"type")),r.type||n||!r["v-bind"]||(n=`(${r["v-bind"]}).type`),n){const r=kn(e,"v-if",!0),o=r?`&&(${r})`:"",s=null!=kn(e,"v-else",!0),a=kn(e,"v-else-if",!0),i=da(e);sa(i),An(i,"type","checkbox"),oa(i,t),i.processed=!0,i.if=`(${n})==='checkbox'`+o,aa(i,{exp:i.if,block:i});const c=da(e);kn(c,"v-for",!0),An(c,"type","radio"),oa(c,t),aa(i,{exp:`(${n})==='radio'`+o,block:c});const l=da(e);return kn(l,"v-for",!0),An(l,":type",n),oa(l,t),aa(i,{exp:r,block:l}),s?i.else=!0:a&&(i.elseif=a),i}}}}];const ma={expectHTML:!0,modules:fa,directives:{model:function(e,t,r){const n=t.value,o=t.modifiers,s=e.tag,a=e.attrsMap.type;if(e.component)return Cn(e,n,o),!1;if("select"===s)!function(e,t,r){let n=`var $$selectedVal = ${'Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;'+`return ${r&&r.number?"_n(val)":"val"}})`};`;n=`${n} ${Sn(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,qn(e,"change",n,null,!0)}(e,n,o);else if("input"===s&&"checkbox"===a)!function(e,t,r){const n=r&&r.number,o=$n(e,"value")||"null",s=$n(e,"true-value")||"true",a=$n(e,"false-value")||"false";vn(e,"checked",`Array.isArray(${t})`+`?_i(${t},${o})>-1`+("true"===s?`:(${t})`:`:_q(${t},${s})`)),qn(e,"change",`var $$a=${t},`+"$$el=$event.target,"+`$$c=$$el.checked?(${s}):(${a});`+"if(Array.isArray($$a)){"+`var $$v=${n?"_n("+o+")":o},`+"$$i=_i($$a,$$v);"+`if($$el.checked){$$i<0&&(${Sn(t,"$$a.concat([$$v])")})}`+`else{$$i>-1&&(${Sn(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}`+`}else{${Sn(t,"$$c")}}`,null,!0)}(e,n,o);else if("input"===s&&"radio"===a)!function(e,t,r){const n=r&&r.number;let o=$n(e,"value")||"null";vn(e,"checked",`_q(${t},${o=n?`_n(${o})`:o})`),qn(e,"change",Sn(t,o),null,!0)}(e,n,o);else if("input"===s||"textarea"===s)!function(e,t,r){const n=e.attrsMap.type,{lazy:o,number:s,trim:a}=r||{},i=!o&&"range"!==n,c=o?"change":"range"===n?Pn:"input";let l="$event.target.value";a&&(l="$event.target.value.trim()"),s&&(l=`_n(${l})`);let u=Sn(t,l);i&&(u=`if($event.target.composing)return;${u}`),vn(e,"value",`(${t})`),qn(e,c,u,null,!0),(a||s)&&qn(e,"blur","$forceUpdate()")}(e,n,o);else if(!B.isReservedTag(s))return Cn(e,n,o),!1;return!0},text:function(e,t){t.value&&vn(e,"textContent",`_s(${t.value})`,t)},html:function(e,t){t.value&&vn(e,"innerHTML",`_s(${t.value})`,t)}},isPreTag:e=>"pre"===e,isUnaryTag:fs,mustUseProp:kr,canBeLeftOpenTag:ms,isReservedTag:Pr,getTagNamespace:Hr,staticKeys:function(e){return e.reduce((e,t)=>e.concat(t.staticKeys||[]),[]).join(",")}(fa)};let ha,ga;const ba=y(function(e){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ya(e,t){e&&(ha=ba(t.staticKeys||""),ga=t.isReservedTag||C,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||f(e.tag)||!ga(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(ha)))}(t);if(1===t.type){if(!ga(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let r=0,n=t.children.length;r<n;r++){const n=t.children[r];e(n),n.static||(t.static=!1)}if(t.ifConditions)for(let r=1,n=t.ifConditions.length;r<n;r++){const n=t.ifConditions[r].block;e(n),n.static||(t.static=!1)}}}(e),function e(t,r){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=r),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)e(t.children[n],r||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)e(t.ifConditions[n].block,r)}}(e,!1))}const va=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,wa=/\([^)]*?\);*$/,Aa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Da={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xa={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},qa=e=>`if(${e})return null;`,$a={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:qa("$event.target !== $event.currentTarget"),ctrl:qa("!$event.ctrlKey"),shift:qa("!$event.shiftKey"),alt:qa("!$event.altKey"),meta:qa("!$event.metaKey"),left:qa("'button' in $event && $event.button !== 0"),middle:qa("'button' in $event && $event.button !== 1"),right:qa("'button' in $event && $event.button !== 2")};function ka(e,t){const r=t?"nativeOn:":"on:";let n="",o="";for(const t in e){const r=Ea(e[t]);e[t]&&e[t].dynamic?o+=`${t},${r},`:n+=`"${t}":${r},`}return n=`{${n.slice(0,-1)}}`,o?r+`_d(${n},[${o.slice(0,-1)}])`:r+n}function Ea(e){if(!e)return"function(){}";if(Array.isArray(e))return`[${e.map(e=>Ea(e)).join(",")}]`;const t=Aa.test(e.value),r=va.test(e.value),n=Aa.test(e.value.replace(wa,""));if(e.modifiers){let o="",s="";const a=[];for(const t in e.modifiers)if($a[t])s+=$a[t],Da[t]&&a.push(t);else if("exact"===t){const t=e.modifiers;s+=qa(["ctrl","shift","alt","meta"].filter(e=>!t[e]).map(e=>`$event.${e}Key`).join("||"))}else a.push(t);return a.length&&(o+=function(e){return"if(!$event.type.indexOf('key')&&"+`${e.map(_a).join("&&")})return null;`}(a)),s&&(o+=s),`function($event){${o}${t?`return ${e.value}.apply(null, arguments)`:r?`return (${e.value}).apply(null, arguments)`:n?`return ${e.value}`:e.value}}`}return t||r?e.value:`function($event){${n?`return ${e.value}`:e.value}}`}function _a(e){const t=parseInt(e,10);if(t)return`$event.keyCode!==${t}`;const r=Da[e],n=xa[e];return"_k($event.keyCode,"+`${JSON.stringify(e)},`+`${JSON.stringify(r)},`+"$event.key,"+`${JSON.stringify(n)}`+")"}var Ca={on:function(e,t){e.wrapListeners=(e=>`_g(${e},${t.value})`)},bind:function(e,t){e.wrapData=(r=>`_b(${r},'${e.tag}',${t.value},${t.modifiers&&t.modifiers.prop?"true":"false"}${t.modifiers&&t.modifiers.sync?",true":""})`)},cloak:_};class Sa{constructor(e){this.options=e,this.warn=e.warn||bn,this.transforms=yn(e.modules,"transformCode"),this.dataGenFns=yn(e.modules,"genData"),this.directives=k(k({},Ca),e.directives);const t=e.isReservedTag||C;this.maybeComponent=(e=>!!e.component||!t(e.tag)),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function La(e,t){const r=new Sa(t);return{render:`with(this){return ${e?"script"===e.tag?"null":Ta(e,r):'_c("div")'}}`,staticRenderFns:r.staticRenderFns}}function Ta(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Na(e,t);if(e.once&&!e.onceProcessed)return Oa(e,t);if(e.for&&!e.forProcessed)return Fa(e,t);if(e.if&&!e.ifProcessed)return Ra(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){const r=e.slotName||'"default"',n=Ia(e,t);let o=`_t(${r}${n?`,${n}`:""}`;const s=e.attrs||e.dynamicAttrs?Ha((e.attrs||[]).concat(e.dynamicAttrs||[]).map(e=>({name:w(e.name),value:e.value,dynamic:e.dynamic}))):null,a=e.attrsMap["v-bind"];!s&&!a||n||(o+=",null");s&&(o+=`,${s}`);a&&(o+=`${s?"":",null"},${a}`);return o+")"}(e,t);{let r;if(e.component)r=function(e,t,r){const n=t.inlineTemplate?null:Ia(t,r,!0);return`_c(${e},${Ba(t,r)}${n?`,${n}`:""})`}(e.component,e,t);else{let n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=Ba(e,t));const o=e.inlineTemplate?null:Ia(e,t,!0);r=`_c('${e.tag}'${n?`,${n}`:""}${o?`,${o}`:""})`}for(let n=0;n<t.transforms.length;n++)r=t.transforms[n](e,r);return r}}return Ia(e,t)||"void 0"}function Na(e,t){e.staticProcessed=!0;const r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push(`with(this){return ${Ta(e,t)}}`),t.pre=r,`_m(${t.staticRenderFns.length-1}${e.staticInFor?",true":""})`}function Oa(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ra(e,t);if(e.staticInFor){let r="",n=e.parent;for(;n;){if(n.for){r=n.key;break}n=n.parent}return r?`_o(${Ta(e,t)},${t.onceId++},${r})`:Ta(e,t)}return Na(e,t)}function Ra(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,o){if(!t.length)return o||"_e()";const s=t.shift();return s.exp?`(${s.exp})?${a(s.block)}:${e(t,r,n,o)}`:`${a(s.block)}`;function a(e){return n?n(e,r):e.once?Oa(e,r):Ta(e,r)}}(e.ifConditions.slice(),t,r,n)}function Fa(e,t,r,n){const o=e.for,s=e.alias,a=e.iterator1?`,${e.iterator1}`:"",i=e.iterator2?`,${e.iterator2}`:"";return e.forProcessed=!0,`${n||"_l"}((${o}),`+`function(${s}${a}${i}){`+`return ${(r||Ta)(e,t)}`+"})"}function Ba(e,t){let r="{";const n=function(e,t){const r=e.directives;if(!r)return;let n,o,s,a,i="directives:[",c=!1;for(n=0,o=r.length;n<o;n++){s=r[n],a=!0;const o=t.directives[s.name];o&&(a=!!o(e,s,t.warn)),a&&(c=!0,i+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return i.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+=`key:${e.key},`),e.ref&&(r+=`ref:${e.ref},`),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+=`tag:"${e.tag}",`);for(let n=0;n<t.dataGenFns.length;n++)r+=t.dataGenFns[n](e);if(e.attrs&&(r+=`attrs:${Ha(e.attrs)},`),e.props&&(r+=`domProps:${Ha(e.props)},`),e.events&&(r+=`${ka(e.events,!1)},`),e.nativeEvents&&(r+=`${ka(e.nativeEvents,!0)},`),e.slotTarget&&!e.slotScope&&(r+=`slot:${e.slotTarget},`),e.scopedSlots&&(r+=`${function(e,t,r){let n=e.for||Object.keys(t).some(e=>{const r=t[e];return r.slotTargetDynamic||r.if||r.for||Ua(r)}),o=!!e.if;if(!n){let t=e.parent;for(;t;){if(t.slotScope&&t.slotScope!==Js||t.for){n=!0;break}t.if&&(o=!0),t=t.parent}}const s=Object.keys(t).map(e=>Va(t[e],r)).join(",");return`scopedSlots:_u([${s}]${n?",null,true":""}${!n&&o?`,null,false,${function(e){let t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(s)}`:""})`}(e,e.scopedSlots,t)},`),e.model&&(r+=`model:{value:${e.model.value},callback:${e.model.callback},expression:${e.model.expression}},`),e.inlineTemplate){const n=function(e,t){const r=e.children[0];if(r&&1===r.type){const e=La(r,t.options);return`inlineTemplate:{render:function(){${e.render}},staticRenderFns:[${e.staticRenderFns.map(e=>`function(){${e}}`).join(",")}]}`}}(e,t);n&&(r+=`${n},`)}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r=`_b(${r},"${e.tag}",${Ha(e.dynamicAttrs)})`),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function Ua(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ua))}function Va(e,t){const r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return Ra(e,t,Va,"null");if(e.for&&!e.forProcessed)return Fa(e,t,Va);const n=e.slotScope===Js?"":String(e.slotScope),o=`function(${n}){`+`return ${"template"===e.tag?e.if&&r?`(${e.if})?${Ia(e,t)||"undefined"}:undefined`:Ia(e,t)||"undefined":Ta(e,t)}}`,s=n?"":",proxy:true";return`{key:${e.slotTarget||'"default"'},fn:${o}${s}}`}function Ia(e,t,r,n,o){const s=e.children;if(s.length){const e=s[0];if(1===s.length&&e.for&&"template"!==e.tag&&"slot"!==e.tag){const o=r?t.maybeComponent(e)?",1":",0":"";return`${(n||Ta)(e,t)}${o}`}const a=r?function(e,t){let r=0;for(let n=0;n<e.length;n++){const o=e[n];if(1===o.type){if(ja(o)||o.ifConditions&&o.ifConditions.some(e=>ja(e.block))){r=2;break}(t(o)||o.ifConditions&&o.ifConditions.some(e=>t(e.block)))&&(r=1)}}return r}(s,t.maybeComponent):0,i=o||Pa;return`[${s.map(e=>i(e,t)).join(",")}]${a?`,${a}`:""}`}}function ja(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Pa(e,t){return 1===e.type?Ta(e,t):3===e.type&&e.isComment?(n=e,`_e(${JSON.stringify(n.text)})`):`_v(${2===(r=e).type?r.expression:Ma(JSON.stringify(r.text))})`;var r,n}function Ha(e){let t="",r="";for(let n=0;n<e.length;n++){const o=e[n],s=Ma(o.value);o.dynamic?r+=`${o.name},${s},`:t+=`"${o.name}":${s},`}return t=`{${t.slice(0,-1)}}`,r?`_d(${t},[${r.slice(0,-1)}])`:t}function Ma(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Ga(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),_}}function za(e){const t=Object.create(null);return function(r,n,o){(n=k({},n)).warn;delete n.warn;const s=n.delimiters?String(n.delimiters)+r:r;if(t[s])return t[s];const a=e(r,n),i={},c=[];return i.render=Ga(a.render,c),i.staticRenderFns=a.staticRenderFns.map(e=>Ga(e,c)),t[s]=i}}const Ja=(Ka=function(e,t){const r=na(e.trim(),t);!1!==t.optimize&&ya(r,t);const n=La(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){const n=Object.create(e),o=[],s=[];if(r){r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=k(Object.create(e.directives||null),r.directives));for(const e in r)"modules"!==e&&"directives"!==e&&(n[e]=r[e])}n.warn=((e,t,r)=>{(r?s:o).push(e)});const a=Ka(t.trim(),n);return a.errors=o,a.tips=s,a}return{compile:t,compileToFunctions:za(t)}});var Ka;const{compile:Za,compileToFunctions:Ya}=Ja(ma);let Wa;function Qa(e){return(Wa=Wa||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',Wa.innerHTML.indexOf("&#10;")>0}const Xa=!!H&&Qa(!1),ei=!!H&&Qa(!0),ti=y(e=>{const t=zr(e);return t&&t.innerHTML}),ri=gr.prototype.$mount;gr.prototype.$mount=function(e,t){if((e=e&&zr(e))===document.body||e===document.documentElement)return this;const r=this.$options;if(!r.render){let t=r.template;if(t)if("string"==typeof t)"#"===t.charAt(0)&&(t=ti(t));else{if(!t.nodeType)return this;t=t.innerHTML}else e&&(t=function(e){if(e.outerHTML)return e.outerHTML;{const t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}}(e));if(t){const{render:e,staticRenderFns:n}=Ya(t,{outputSourceRange:!1,shouldDecodeNewlines:Xa,shouldDecodeNewlinesForHref:ei,delimiters:r.delimiters,comments:r.comments},this);r.render=e,r.staticRenderFns=n}}return ri.call(this,e,t)},gr.compile=Ya;export default gr;
\ No newline at end of file
+var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(){function e(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=[],r=0;r<arguments.length;r++)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&we(t),o.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function je(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=je(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Ae[r]||Ee;a[r]=i(e[r],t[r],n,r)}return a}function De(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Le(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=_e;be(!0),we(a),be(u)}return a}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),Z&&setTimeout(S)},Ve=!0}else if(J||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=n.fns;if(!Array.isArray(e))return He(e,null,arguments,t,"v-on handler");for(var r=e.slice(),i=0;i<r.length;i++)He(r[i],null,arguments,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=ve(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=ve(f.text+u):""!==u&&s.push(ve(u)):st(u)&&st(f)?s[l]=ve(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return De(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=E,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var o=he(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Le(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=de();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Le(l,u,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return de();n(a)&&n(a.is)&&(i=a.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f=void 0;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=De(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):de()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(U&&!J){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var o=function(o){i.push(o);var a=Le(o,t,n,e);Ce(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=je(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=je(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=je($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;Ce(t,"$attrs",o&&o.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){le();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:je,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=je(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=De(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(J||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(J&&!q&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=J?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=U&&!q,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ni(e){Ti(function(){Ti(e)})}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,N=O&&v?v:l,E=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!q,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,N),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),E&&E(i),F&&(Ei(i,S),Ei(i,T),Ni(function(){ji(i,S),R.cancelled||(Ei(i,N),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ni(function(){ji(i,u),w.cancelled||(Ei(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=he(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,U?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});q&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),q&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t),(J||W)&&setTimeout(function(){Ji(e,t)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(E(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!E(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){(l=i[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(o.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=e(t,null,c),this.removed=u}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!U)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=U?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?Yn(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},go=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),_o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,No=/^<!\[/,Eo=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,function(e){return Do[e]})}function Ro(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,u=function(){if(n=e,r&&Eo(r)){var u=0,p=r.toLowerCase(),d=jo[p]||(jo[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return u=r.length,Eo(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(To.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(No.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(So);if(y)return l(y[0].length),"continue";var g=e.match(Oo);if(g){var _=c;return l(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(ko);if(t){var n={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Ao))&&(i=e.match(wo)||e.match($o));)i.start=c,l(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&f(r),s(n)&&r===n&&f(n));for(var u=a(n)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:Po(h,m)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,u,e.start,e.end)}(b),Fo(b.tagName,e)&&l(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Oo.test(w)||ko.test(w)||To.test(w)||No.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&l($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}f()}var Ho,Bo,Uo,zo,Vo,Ko,Jo,qo,Wo=require("he"),Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/[ \f\t\r\n]+/g,sa=g(Wo.decode),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Ho=t.warn||Sr,Ko=t.isPreTag||T,Jo=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Uo=Tr(t.modules,"transformNode"),zo=Tr(t.modules,"preTransformNode"),Vo=Tr(t.modules,"postTransformNode"),Bo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ko(e.tag)&&(c=!1);for(var f=0;f<Vo.length;f++)Vo[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return Ro(e,{warn:Ho,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<zo.length;h++)v=zo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ko(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):u.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(aa," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Bo))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var r=Pr(e,ia);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=va(r),u=c.name,a=c.dynamic,l=s[u]=ua("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=r.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Uo.length;i++)e=Uo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Jo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):Er(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Er(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Jo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,yo,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=Ir(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+r+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",r),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Nr(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:go,mustUseProp:jn,canBeLeftOpenTag:_o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var o=t.ifConditions[n].block;e(o),o.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Na={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(ja[t])o+=ja[t],Ta[t]&&a.push(t);else if("exact"===t){var n=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Na[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(){return function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g(function(e){var t=Yn(e);return t&&t.innerHTML}),ss=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},wn.compile=ns;export default wn;
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index acbc5a0be94..2c7f13f1038 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -107,7 +107,7 @@ var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove(arr, item) {
+function remove$2(arr, item) {
     if (arr.length) {
         var index = arr.indexOf(item);
         if (index > -1) {
@@ -176,7 +176,7 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
+var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
@@ -229,7 +229,7 @@ var identity = function (_) { return _; };
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys(modules) {
+function genStaticKeys$1(modules) {
     return modules
         .reduce(function (keys, m) {
         return keys.concat(m.staticKeys || []);
@@ -431,7 +431,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -462,10 +462,10 @@ var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
 var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
@@ -475,7 +475,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get: function () {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -521,44 +521,45 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
+    _Set = /** @class */ (function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function has (key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function add (key) {
+        Set.prototype.add = function (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function clear () {
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
         };
-
         return Set;
     }());
 }
 
 /* @flow */
-var warn = noop;
+var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn = function (msg, vm) {
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+        else if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole && !config.silent) {
+        if (hasConsole_1 && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -581,10 +582,10 @@ if (process.env.NODE_ENV !== 'production') {
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    var repeat = function (str, n) {
+    var repeat_1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -618,50 +619,55 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
 
-var uid = 0;
+var uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
-    }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$2(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -676,43 +682,45 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
+    if (text === void 0) { text = ''; }
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -766,9 +774,12 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
+        var arguments$1 = arguments;
 
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -804,43 +815,46 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
     }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive$$1(obj, keys[i]);
-    }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
-    }
-};
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -890,7 +904,7 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
+function defineReactive(obj, key, val, customSetter, shallow) {
     var dep = new Dep();
     var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -951,7 +965,7 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -966,7 +980,7 @@ function set(target, key, val) {
     // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
-            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
         return val;
     }
@@ -974,7 +988,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -984,7 +998,7 @@ function set(target, key, val) {
 function del(target, key) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+        warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -994,7 +1008,7 @@ function del(target, key) {
     //@ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
-            warn('Avoid deleting properties on a Vue instance or its root $data ' +
+            warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                 '- just set it to null.');
         return;
     }
@@ -1012,7 +1026,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1034,7 +1048,7 @@ var strats = config.optionMergeStrategies;
 if (process.env.NODE_ENV !== 'production') {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
+            warn$2("option \"" + key + "\" can only be used during instance " +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1111,7 +1125,7 @@ strats.data = function (parentVal, childVal, vm) {
     if (!vm) {
         if (childVal && typeof childVal !== 'function') {
             process.env.NODE_ENV !== 'production' &&
-                warn('The "data" option should be a function ' +
+                warn$2('The "data" option should be a function ' +
                     'that returns a per-instance value in component ' +
                     'definitions.', vm);
             return parentVal;
@@ -1123,7 +1137,7 @@ strats.data = function (parentVal, childVal, vm) {
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(parentVal, childVal) {
+function mergeHook$1(parentVal, childVal) {
     var res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
@@ -1143,7 +1157,7 @@ function dedupeHooks(hooks) {
     return res;
 }
 LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+    strats[hook] = mergeHook$1;
 });
 /**
  * Assets
@@ -1189,14 +1203,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key$1] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1234,14 +1248,14 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-        warn('Invalid component name: "' +
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+        warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
             'should conform to valid custom element name in html5 specification.');
     }
     if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
             'id: ' +
             name);
     }
@@ -1265,7 +1279,7 @@ function normalizeProps(options, vm) {
                 res[name] = { type: null };
             }
             else if (process.env.NODE_ENV !== 'production') {
-                warn('props must be strings when using array syntax.');
+                warn$2('props must be strings when using array syntax.');
             }
         }
     }
@@ -1277,8 +1291,8 @@ function normalizeProps(options, vm) {
         }
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
+            ("but got " + toRawType(props) + "."), vm);
     }
     options.props = res;
 }
@@ -1304,28 +1318,28 @@ function normalizeInject(options, vm) {
         }
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
+            ("but got " + toRawType(inject) + "."), vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives(options) {
+function normalizeDirectives$1(options) {
     var dirs = options.directives;
     if (dirs) {
         for (var key in dirs) {
-            var def$$1 = dirs[key];
-            if (typeof def$$1 === 'function') {
-                dirs[key] = { bind: def$$1, update: def$$1 };
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
             }
         }
     }
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 /**
@@ -1342,7 +1356,7 @@ function mergeOptions(parent, child, vm) {
     }
     normalizeProps(child, vm);
     normalizeInject(child, vm);
-    normalizeDirectives(child);
+    normalizeDirectives$1(child);
     // Apply extends and mixins on the child options,
     // but only if it is a raw options object that isn't
     // the result of another mergeOptions call.
@@ -1396,7 +1410,7 @@ function resolveAsset(options, type, id, warnMissing) {
     // fallback to prototype chain
     var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
     return res;
 }
@@ -1433,7 +1447,7 @@ function validateProp(key, propOptions, propsData, vm) {
     }
     if (process.env.NODE_ENV !== 'production' &&
         // skip validation for weex recycle-list child component props
-        !(false)) {
+        !(false  )) {
         assertProp(prop, key, value, vm, absent);
     }
     return value;
@@ -1449,7 +1463,7 @@ function getPropDefaultValue(vm, prop, key) {
     var def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-        warn('Invalid default value for prop "' +
+        warn$2('Invalid default value for prop "' +
             key +
             '": ' +
             'Props with type Object/Array must use a factory function ' +
@@ -1474,7 +1488,7 @@ function getPropDefaultValue(vm, prop, key) {
  */
 function assertProp(prop, name, value, vm, absent) {
     if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
+        warn$2('Missing required prop: "' + name + '"', vm);
         return;
     }
     if (value == null && !prop.required) {
@@ -1496,13 +1510,13 @@ function assertProp(prop, name, value, vm, absent) {
     }
     var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
     if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
     var validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
@@ -1529,7 +1543,7 @@ function assertType(value, type, vm) {
             valid = value instanceof type;
         }
         catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
             valid = false;
         }
     }
@@ -1564,7 +1578,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1572,24 +1586,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += " with value " + styleValue(value, expectedType);
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += "with value " + styleValue(value, receivedType) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return "\"" + value + "\"";
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return "" + Number(value);
     }
     else {
-        return ("" + value);
+        return "" + value;
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1597,9 +1611,12 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
+    var arguments$1 = arguments;
 
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments$1[_i];
+    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1665,7 +1682,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     if (process.env.NODE_ENV !== 'production') {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1708,9 +1725,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
+    var p_1 = Promise.resolve();
     timerFunc = function () {
-        p.then(flushCallbacks);
+        p_1.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1729,15 +1746,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
+    var counter_1 = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
     timerFunc = function () {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
+        counter_1 = (counter_1 + 1) % 2;
+        textNode_1.data = String(counter_1);
     };
     isUsingMicroTask = true;
 }
@@ -1782,23 +1799,21 @@ function nextTick(cb, ctx) {
     }
 }
 
-/* @flow */
-
 var mark;
 var measure;
 if (process.env.NODE_ENV !== 'production') {
-    var perf = inBrowser && window.performance;
+    var perf_1 = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) {
+        mark = function (tag) { return perf_1.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
+            perf_1.measure(name, startTag, endTag);
+            perf_1.clearMarks(startTag);
+            perf_1.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1807,31 +1822,31 @@ if (process.env.NODE_ENV !== 'production') {
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
-        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+    var warnNonPresent_1 = function (target, key) {
+        warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
-        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    var warnReservedPrefix_1 = function (target, key) {
+        warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                     return false;
                 }
                 else {
@@ -1841,38 +1856,38 @@ if (process.env.NODE_ENV !== 'production') {
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
+    var hasHandler_1 = {
+        has: function (target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+            var isAllowed = allowedGlobals_1(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    var getHandler_1 = {
+        get: function (target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy) {
+        if (hasProxy_1) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1923,13 +1938,13 @@ function _traverse(val, seen) {
 var normalizeEvent = cached(function (name) {
     var passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
     var capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
         name: name,
-        once: once$$1,
+        once: once,
         capture: capture,
         passive: passive,
     };
@@ -1953,15 +1968,15 @@ function createFnInvoker(fns, vm) {
     invoker.fns = fns;
     return invoker;
 }
-function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-    var name, def$$1, cur, old, event;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, cur, old, event;
     for (name in on) {
-        def$$1 = cur = on[name];
+        cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+                warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1980,7 +1995,7 @@ function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
     for (name in oldOn) {
         if (isUndef(on[name])) {
             event = normalizeEvent(name);
-            remove$$1(event.name, oldOn[name], event.capture);
+            remove(event.name, oldOn[name], event.capture);
         }
     }
 }
@@ -1996,7 +2011,7 @@ function mergeVNodeHook(def, hookKey, hook) {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
         // and prevent memory leak
-        remove(invoker.fns, wrappedHook);
+        remove$2(invoker.fns, wrappedHook);
     }
     if (isUndef(oldHook)) {
         // no existing hook
@@ -2028,8 +2043,7 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    var attrs = data.attrs, props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2039,11 +2053,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2118,7 +2132,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2177,14 +2191,14 @@ function initInjections(vm) {
         Object.keys(result).forEach(function (key) {
             /* istanbul ignore else */
             if (process.env.NODE_ENV !== 'production') {
-                defineReactive$$1(vm, key, result[key], function () {
-                    warn("Avoid mutating an injected value directly since the changes will be " +
+                defineReactive(vm, key, result[key], function () {
+                    warn$2("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                        ("injection being mutated: \"" + key + "\""), vm);
                 });
             }
             else {
-                defineReactive$$1(vm, key, result[key]);
+                defineReactive(vm, key, result[key]);
             }
         });
         toggleObserving(true);
@@ -2220,7 +2234,7 @@ function resolveInject(inject, vm) {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn$2("Injection \"" + key + "\" not found", vm);
                 }
             }
         }
@@ -2249,8 +2263,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2263,9 +2277,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
         }
     }
     return slots;
@@ -2299,16 +2313,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2402,7 +2416,7 @@ function renderSlot(name, fallback, props, bindObject) {
         props = props || {};
         if (bindObject) {
             if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
+                warn$2('slot v-bind without argument expects an Object', this);
             }
             props = extend(extend({}, bindObject), props);
         }
@@ -2462,14 +2476,14 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
     if (value) {
         if (!isObject(value)) {
             process.env.NODE_ENV !== 'production' &&
-                warn('v-bind without argument expects an Object or Array value', this);
+                warn$2('v-bind without argument expects an Object or Array value', this);
         }
         else {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            var hash = void 0;
+            var _loop_1 = function (key) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2486,14 +2500,15 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        on["update:" + key] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-
-            for (var key in value) loop( key );
+            for (var key in value) {
+                _loop_1(key);
+            }
         }
     }
     return data;
@@ -2513,7 +2528,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic$1(tree, "__static__" + index, false);
     return tree;
 }
 /**
@@ -2521,14 +2536,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
     return tree;
 }
-function markStatic(tree, key, isOnce) {
+function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], key + "_" + i, isOnce);
             }
         }
     }
@@ -2547,7 +2562,7 @@ function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
             process.env.NODE_ENV !== 'production' &&
-                warn('v-on without argument expects an Object value', this);
+                warn$2('v-on without argument expects an Object value', this);
         }
         else {
             var on = (data.on = data.on ? extend({}, data.on) : {});
@@ -2597,7 +2612,7 @@ function bindDynamicKeys(baseObj, values) {
             key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
         }
     }
     return baseObj;
@@ -2632,8 +2647,7 @@ function installRenderHelpers(target) {
 
 /* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
+    var _this = this;
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2660,14 +2674,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return _this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get: function () {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2681,7 +2695,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     }
     if (options._scopeId) {
         this._c = function (a, b, c, d) {
-            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2690,7 +2704,9 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+        this._c = function (a, b, c, d) {
+            return createElement$1(contextVm, a, b, c, d, needNormalization);
+        };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2744,14 +2760,10 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+    init: function (vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2764,7 +2776,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
+    prepatch: function (oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2773,12 +2785,11 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
+            callHook$1(componentInstance, 'mounted');
         }
         if (vnode.data.keepAlive) {
             if (context._isMounted) {
@@ -2794,7 +2805,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2820,7 +2831,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         if (process.env.NODE_ENV !== 'production') {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn$2("Invalid Component definition: " + String(Ctor), context);
         }
         return;
     }
@@ -2878,7 +2889,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2909,11 +2920,11 @@ function installComponentHooks(data) {
         var toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
     }
 }
-function mergeHook$1(f1, f2) {
+function mergeHook(f1, f2) {
     var merged = function (a, b) {
         // flow complains about extra args which is why we use any
         f1(a, b);
@@ -2948,7 +2959,7 @@ var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
     if (Array.isArray(data) || isPrimitive(data)) {
         normalizationType = children;
         children = data;
@@ -2962,7 +2973,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+            warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2980,7 +2991,7 @@ function _createElement(context, tag, data, children, normalizationType) {
         !isPrimitive(data.key)) {
         // @ts-expect-error
         {
-            warn('Avoid using non-primitive value as key, ' +
+            warn$2('Avoid using non-primitive value as key, ' +
                 'use string/number value instead.', context);
         }
     }
@@ -2998,7 +3009,7 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        var Ctor = void 0;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
@@ -3006,7 +3017,7 @@ function _createElement(context, tag, data, children, normalizationType) {
                 isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3083,26 +3094,26 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
     var parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     if (process.env.NODE_ENV !== 'production') {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
         }, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
         }, true);
     }
     else {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
     }
 }
 var currentRenderingInstance = null;
@@ -3114,9 +3125,7 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3141,8 +3150,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e) {
-                    handleError(e, vm, "renderError");
+                catch (e$1) {
+                    handleError(e$1, vm, "renderError");
                     vnode = vm._vnode;
                 }
             }
@@ -3160,7 +3169,7 @@ function renderMixin(Vue) {
         // return empty vnode in case the render function errored out
         if (!(vnode instanceof VNode)) {
             if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
+                warn$2('Multiple root nodes returned from render function. Render function ' +
                     'should return a single root node.', vm);
             }
             vnode = createEmptyVNode();
@@ -3200,24 +3209,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
+        var owners_1 = (factory.owners = [owner]);
+        var sync_1 = true;
+        var timerLoading_1 = null;
+        var timerTimeout_1 = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+        var forceRender_1 = function (renderCompleted) {
+            for (var i = 0, l = owners_1.length; i < l; i++) {
+                owners_1[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
+                owners_1.length = 0;
+                if (timerLoading_1 !== null) {
+                    clearTimeout(timerLoading_1);
+                    timerLoading_1 = null;
                 }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
+                if (timerTimeout_1 !== null) {
+                    clearTimeout(timerTimeout_1);
+                    timerTimeout_1 = null;
                 }
             }
         };
@@ -3226,65 +3235,65 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
+            if (!sync_1) {
+                forceRender_1(true);
             }
             else {
-                owners.length = 0;
+                owners_1.length = 0;
             }
         });
-        var reject = once(function (reason) {
+        var reject_1 = once(function (reason) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+                warn$2("Failed to resolve async component: " + String(factory) +
+                    (reason ? "\nReason: " + reason : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender(true);
+                forceRender_1(true);
             }
         });
-        var res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
+        var res_1 = factory(resolve, reject_1);
+        if (isObject(res_1)) {
+            if (isPromise(res_1)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
+                    res_1.then(resolve, reject_1);
                 }
             }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
+            else if (isPromise(res_1.component)) {
+                res_1.component.then(resolve, reject_1);
+                if (isDef(res_1.error)) {
+                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
                 }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
+                if (isDef(res_1.loading)) {
+                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                    if (res_1.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
-                            timerLoading = null;
+                        timerLoading_1 = setTimeout(function () {
+                            timerLoading_1 = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender(false);
+                                forceRender_1(false);
                             }
-                        }, res.delay || 200);
+                        }, res_1.delay || 200);
                     }
                 }
-                if (isDef(res.timeout)) {
+                if (isDef(res_1.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
-                        timerTimeout = null;
+                    timerTimeout_1 = setTimeout(function () {
+                        timerTimeout_1 = null;
                         if (isUndef(factory.resolved)) {
-                            reject(process.env.NODE_ENV !== 'production'
-                                ? ("timeout (" + (res.timeout) + "ms)")
+                            reject_1(process.env.NODE_ENV !== 'production'
+                                ? "timeout (" + res_1.timeout + "ms)"
                                 : null);
                         }
-                    }, res.timeout);
+                    }, res_1.timeout);
                 }
             }
         }
-        sync = false;
+        sync_1 = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3308,8 +3317,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
-
 /* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
@@ -3320,15 +3327,15 @@ function initEvents(vm) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target;
-function add(event, fn) {
-    target.$on(event, fn);
+var target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
 }
 function remove$1(event, fn) {
-    target.$off(event, fn);
+    target$1.$off(event, fn);
 }
-function createOnceHandler(event, fn) {
-    var _target = target;
+function createOnceHandler$1(event, fn) {
+    var _target = target$1;
     return function onceHandler() {
         var res = fn.apply(null, arguments);
         if (res !== null) {
@@ -3337,9 +3344,9 @@ function createOnceHandler(event, fn) {
     };
 }
 function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
 }
 function eventsMixin(Vue) {
     var hookRE = /^hook:/;
@@ -3379,8 +3386,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                vm.$off(event[i_1], fn);
             }
             return vm;
         }
@@ -3411,10 +3418,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
             }
         }
         var cbs = vm._events[event];
@@ -3505,13 +3512,13 @@ function lifecycleMixin(Vue) {
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook(vm, 'beforeDestroy');
+        callHook$1(vm, 'beforeDestroy');
         vm._isBeingDestroyed = true;
         // remove self from parent
         var parent = vm.$parent;
         // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove(parent.$children, vm);
+            remove$2(parent.$children, vm);
         }
         // teardown watchers
         if (vm._watcher) {
@@ -3531,7 +3538,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook(vm, 'destroyed');
+        callHook$1(vm, 'destroyed');
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3555,16 +3562,16 @@ function mountComponent(vm, el, hydrating) {
             if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
                 vm.$options.el ||
                 el) {
-                warn('You are using the runtime-only build of Vue where the template ' +
+                warn$2('You are using the runtime-only build of Vue where the template ' +
                     'compiler is not available. Either pre-compile the templates into ' +
                     'render functions, or use the compiler-included build.', vm);
             }
             else {
-                warn('Failed to mount component: template or render function not defined.', vm);
+                warn$2('Failed to mount component: template or render function not defined.', vm);
             }
         }
     }
-    callHook(vm, 'beforeMount');
+    callHook$1(vm, 'beforeMount');
     var updateComponent;
     /* istanbul ignore if */
     if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
@@ -3576,11 +3583,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure("vue " + name + " render", startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure("vue " + name + " patch", startTag, endTag);
         };
     }
     else {
@@ -3592,9 +3599,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before: function () {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook(vm, 'beforeUpdate');
+                callHook$1(vm, 'beforeUpdate');
             }
         },
     }, true /* isRenderWatcher */);
@@ -3603,7 +3610,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook(vm, 'mounted');
+        callHook$1(vm, 'mounted');
     }
     return vm;
 }
@@ -3693,7 +3700,7 @@ function activateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'activated');
+        callHook$1(vm, 'activated');
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3708,10 +3715,10 @@ function deactivateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'deactivated');
+        callHook$1(vm, 'deactivated');
     }
 }
-function callHook(vm, hook) {
+function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
     var handlers = vm.$options[hook];
@@ -3735,12 +3742,12 @@ var has = {};
 var circular = {};
 var waiting = false;
 var flushing = false;
-var index = 0;
+var index$1 = 0;
 /**
  * Reset the scheduler's state.
  */
 function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
+    index$1 = queue.length = activatedChildren.length = 0;
     has = {};
     if (process.env.NODE_ENV !== 'production') {
         circular = {};
@@ -3762,15 +3769,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = function () { return performance_1.now(); };
     }
 }
 /**
@@ -3791,8 +3798,8 @@ function flushSchedulerQueue() {
     queue.sort(function (a, b) { return a.id - b.id; });
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
+    for (index$1 = 0; index$1 < queue.length; index$1++) {
+        watcher = queue[index$1];
         if (watcher.before) {
             watcher.before();
         }
@@ -3803,9 +3810,9 @@ function flushSchedulerQueue() {
         if (process.env.NODE_ENV !== 'production' && has[id] != null) {
             circular[id] = (circular[id] || 0) + 1;
             if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
+                warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        ? "in watcher with expression \"" + watcher.expression + "\""
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3830,7 +3837,7 @@ function callUpdatedHooks(queue) {
         var watcher = queue[i];
         var vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook(vm, 'updated');
+            callHook$1(vm, 'updated');
         }
     }
 }
@@ -3866,7 +3873,7 @@ function queueWatcher(watcher) {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
             var i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
+            while (i > index$1 && queue[i].id > watcher.id) {
                 i--;
             }
             queue.splice(i + 1, 0, watcher);
@@ -3884,198 +3891,201 @@ function queueWatcher(watcher) {
 }
 
 /* @flow */
-var uid$2 = 0;
+var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            process.env.NODE_ENV !== 'production' &&
-                warn("Failed watching path: \"" + expOrFn + "\" " +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-        }
-    }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+var Watcher = /** @class */ (function () {
+    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
         }
         else {
-            throw e;
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression =
+            process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                        'Watcher only accepts simple dot-delimited paths. ' +
+                        'For full control, use a function instead.', vm);
+            }
         }
-        popTarget();
-        this.cleanupDeps();
+        this.value = this.lazy ? undefined : this.get();
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    Watcher.prototype.get = function () {
+        pushTarget(this);
+        var value;
+        var vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-    }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
-    }
-    else {
-        queueWatcher(this);
-    }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
+        catch (e) {
             if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                }
+                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
             }
             else {
-                this.cb.call(this.vm, value, oldValue);
+                throw e;
             }
         }
-    }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
-    }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove(this.vm._watchers, this);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    };
+    /**
+     * Add a dependency to this directive.
+     */
+    Watcher.prototype.addDep = function (dep) {
+        var id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
         }
+    };
+    /**
+     * Clean up for dependency collection.
+     */
+    Watcher.prototype.cleanupDeps = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            var dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        var tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    };
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    Watcher.prototype.update = function () {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
         }
-        this.active = false;
-    }
-};
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    };
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    Watcher.prototype.run = function () {
+        if (this.active) {
+            var value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                var oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    try {
+                        this.cb.call(this.vm, value, oldValue);
+                    }
+                    catch (e) {
+                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                    }
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    };
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    Watcher.prototype.evaluate = function () {
+        this.value = this.get();
+        this.dirty = false;
+    };
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    Watcher.prototype.depend = function () {
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    };
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    Watcher.prototype.teardown = function () {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            var i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    };
+    return Watcher;
+}());
 
 /* @flow */
 var sharedPropertyDefinition = {
@@ -4097,7 +4107,7 @@ function initState(vm) {
     vm._watchers = [];
     var opts = vm.$options;
     if (opts.props)
-        { initProps(vm, opts.props); }
+        { initProps$1(vm, opts.props); }
     if (opts.methods)
         { initMethods(vm, opts.methods); }
     if (opts.data) {
@@ -4107,12 +4117,12 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed(vm, opts.computed); }
+        { initComputed$1(vm, opts.computed); }
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
-function initProps(vm, propsOptions) {
+function initProps$1(vm, propsOptions) {
     var propsData = vm.$options.propsData || {};
     var props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
@@ -4123,7 +4133,7 @@ function initProps(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    var _loop_1 = function (key) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4131,19 +4141,19 @@ function initProps(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
             }
-            defineReactive$$1(props, key, value, function () {
+            defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn("Avoid mutating a prop directly since the value will be " +
+                    warn$2("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                        ("value. Prop being mutated: \"" + key + "\""), vm);
                 }
             });
         }
         else {
-            defineReactive$$1(props, key, value);
+            defineReactive(props, key, value);
         }
         // static props are already proxied on the component's prototype
         // during Vue.extend(). We only need to proxy props defined at
@@ -4152,8 +4162,9 @@ function initProps(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-
-    for (var key in propsOptions) loop( key );
+    for (var key in propsOptions) {
+        _loop_1(key);
+    }
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4162,7 +4173,7 @@ function initData(vm) {
     if (!isPlainObject(data)) {
         data = {};
         process.env.NODE_ENV !== 'production' &&
-            warn('data functions should return an object:\n' +
+            warn$2('data functions should return an object:\n' +
                 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
     }
     // proxy data on instance
@@ -4174,12 +4185,12 @@ function initData(vm) {
         var key = keys[i];
         if (process.env.NODE_ENV !== 'production') {
             if (methods && hasOwn(methods, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
             }
         }
         if (props && hasOwn(props, key)) {
             process.env.NODE_ENV !== 'production' &&
-                warn("The data property \"" + key + "\" is already declared as a prop. " +
+                warn$2("The data property \"" + key + "\" is already declared as a prop. " +
                     "Use prop default value instead.", vm);
         }
         else if (!isReserved(key)) {
@@ -4204,7 +4215,7 @@ function getData(data, vm) {
     }
 }
 var computedWatcherOptions = { lazy: true };
-function initComputed(vm, computed) {
+function initComputed$1(vm, computed) {
     // $flow-disable-line
     var watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
@@ -4213,7 +4224,7 @@ function initComputed(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+            warn$2("Getter is missing for computed property \"" + key + "\".", vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4227,10 +4238,10 @@ function initComputed(vm, computed) {
         }
         else if (process.env.NODE_ENV !== 'production') {
             if (key in vm.$data) {
-                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
             }
         }
     }
@@ -4254,7 +4265,7 @@ function defineComputed(target, key, userDef) {
     if (process.env.NODE_ENV !== 'production' &&
         sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4283,18 +4294,18 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         if (process.env.NODE_ENV !== 'production') {
             if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
             }
             if (key in vm && isReserved(key)) {
-                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
                     "Avoid defining component methods that start with _ or $.");
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
@@ -4334,11 +4345,11 @@ function stateMixin(Vue) {
     };
     if (process.env.NODE_ENV !== 'production') {
         dataDef.set = function () {
-            warn('Avoid replacing instance root $data. ' +
+            warn$2('Avoid replacing instance root $data. ' +
                 'Use nested data properties instead.', this);
         };
         propsDef.set = function () {
-            warn("$props is readonly.", this);
+            warn$2("$props is readonly.", this);
         };
     }
     Object.defineProperty(Vue.prototype, '$data', dataDef);
@@ -4359,7 +4370,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
             }
             popTarget();
         }
@@ -4370,17 +4381,17 @@ function stateMixin(Vue) {
 }
 
 /* @flow */
-var uid$3 = 0;
-function initMixin(Vue) {
+var uid = 0;
+function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
         var vm = this;
         // a uid
-        vm._uid = uid$3++;
+        vm._uid = uid++;
         var startTag, endTag;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = "vue-perf-start:" + vm._uid;
+            endTag = "vue-perf-end:" + vm._uid;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4407,16 +4418,16 @@ function initMixin(Vue) {
         initLifecycle(vm);
         initEvents(vm);
         initRender(vm);
-        callHook(vm, 'beforeCreate');
+        callHook$1(vm, 'beforeCreate');
         initInjections(vm); // resolve injections before data/props
         initState(vm);
         initProvide(vm); // resolve provide after data/props
-        callHook(vm, 'created');
+        callHook$1(vm, 'created');
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure("vue " + vm._name + " init", startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4479,12 +4490,12 @@ function resolveModifiedOptions(Ctor) {
 
 function Vue(options) {
     if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
-        warn('Vue is a constructor and should be called with the `new` keyword');
+        warn$2('Vue is a constructor and should be called with the `new` keyword');
     }
     this._init(options);
 }
 //@ts-ignore
-initMixin(Vue);
+initMixin$1(Vue);
 //@ts-ignore
 stateMixin(Vue);
 //@ts-ignore
@@ -4516,7 +4527,7 @@ function initUse(Vue) {
 }
 
 /* @flow */
-function initMixin$1(Vue) {
+function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
         return this;
@@ -4559,10 +4570,10 @@ function initExtend(Vue) {
         // the Vue instances at extension time, on the extended prototype. This
         // avoids Object.defineProperty calls for each instance created.
         if (Sub.options.props) {
-            initProps$1(Sub);
+            initProps(Sub);
         }
         if (Sub.options.computed) {
-            initComputed$1(Sub);
+            initComputed(Sub);
         }
         // allow further extension/mixin/plugin usage
         Sub.extend = Super.extend;
@@ -4588,13 +4599,13 @@ function initExtend(Vue) {
         return Sub;
     };
 }
-function initProps$1(Comp) {
+function initProps(Comp) {
     var props = Comp.options.props;
     for (var key in props) {
         proxy(Comp.prototype, "_props", key);
     }
 }
-function initComputed$1(Comp) {
+function initComputed(Comp) {
     var computed = Comp.options.computed;
     for (var key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
@@ -4650,26 +4661,24 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
-            if (name && !filter(name)) {
+            var name_1 = getComponentName(cachedNode.componentOptions);
+            if (name_1 && !filter(name_1)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-        cached$$1.componentInstance.$destroy();
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+        cached.componentInstance.$destroy();
     }
     cache[key] = null;
-    remove(keys, key);
+    remove$2(keys, key);
 }
 var patternTypes = [String, RegExp, Array];
 // TODO use defineComponent
@@ -4681,55 +4690,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    created: function () {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
+    destroyed: function () {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
+    mounted: function () {
+        var _this = this;
         this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+            pruneCache(_this, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+            pruneCache(_this, function (name) { return !matches(val, name); });
         });
     },
-    render: function render() {
+    render: function () {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            var name_2 = getComponentName(componentOptions);
+            var _a = this, include = _a.include, exclude = _a.exclude;
             if (
             // not included
-            (include && (!name || !matches(include, name))) ||
+            (include && (!name_2 || !matches(include, name_2))) ||
                 // excluded
-                (exclude && name && matches(exclude, name))) {
+                (exclude && name_2 && matches(exclude, name_2))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
+            var _b = this, cache = _b.cache, keys = _b.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? "::" + componentOptions.tag : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
                 // make current key freshest
-                remove(keys, key);
+                remove$2(keys, key);
                 keys.push(key);
             }
             else {
@@ -4757,7 +4761,7 @@ function initGlobalAPI(Vue) {
     configDef.get = function () { return config; };
     if (process.env.NODE_ENV !== 'production') {
         configDef.set = function () {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
+            warn$2('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
     Object.defineProperty(Vue, 'config', configDef);
@@ -4765,10 +4769,10 @@ function initGlobalAPI(Vue) {
     // NOTE: these are not considered part of the public API - avoid relying on
     // them unless you are aware of the risk.
     Vue.util = {
-        warn: warn,
+        warn: warn$2,
         extend: extend,
         mergeOptions: mergeOptions,
-        defineReactive: defineReactive$$1,
+        defineReactive: defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
@@ -4787,7 +4791,7 @@ function initGlobalAPI(Vue) {
     Vue.options._base = Vue;
     extend(Vue.options.components, builtInComponents);
     initUse(Vue);
-    initMixin$1(Vue);
+    initMixin(Vue);
     initExtend(Vue);
     initAssetRegisters(Vue);
 }
@@ -4797,7 +4801,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get: function () {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4989,7 +4993,7 @@ function query(el) {
         var selected = document.querySelector(el);
         if (!selected) {
             process.env.NODE_ENV !== 'production' &&
-                warn('Cannot find element: ' + el);
+                warn$2('Cannot find element: ' + el);
             return document.createElement('div');
         }
         return selected;
@@ -5000,7 +5004,7 @@ function query(el) {
 }
 
 /* @flow */
-function createElement$1(tagName, vnode) {
+function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
@@ -5048,7 +5052,8 @@ function setStyleScope(node, scopeId) {
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
-  createElement: createElement$1,
+  __proto__: null,
+  createElement: createElement,
   createElementNS: createElementNS,
   createTextNode: createTextNode,
   createComment: createComment,
@@ -5064,16 +5069,16 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 
 /* @flow */
 var ref = {
-    create: function create(_, vnode) {
+    create: function (_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update: function (oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5087,7 +5092,7 @@ function registerRef(vnode, isRemoval) {
     if (isRemoval) {
         if (Array.isArray(refs[key])) {
             // @ts-expect-error invalid typings
-            remove(refs[key], ref);
+            remove$2(refs[key], ref);
         }
         else if (refs[key] === ref) {
             refs[key] = undefined;
@@ -5155,8 +5160,7 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    var modules = backend.modules, nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5169,13 +5173,13 @@ function createPatchFunction(backend) {
         return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
     function createRmCb(childElm, listeners) {
-        function remove$$1() {
-            if (--remove$$1.listeners === 0) {
+        function remove() {
+            if (--remove.listeners === 0) {
                 removeNode(childElm);
             }
         }
-        remove$$1.listeners = listeners;
-        return remove$$1;
+        remove.listeners = listeners;
+        return remove;
     }
     function removeNode(el) {
         var parent = nodeOps.parentNode(el);
@@ -5184,7 +5188,7 @@ function createPatchFunction(backend) {
             nodeOps.removeChild(parent, el);
         }
     }
-    function isUnknownElement$$1(vnode, inVPre) {
+    function isUnknownElement(vnode, inVPre) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
@@ -5217,8 +5221,8 @@ function createPatchFunction(backend) {
                 if (data && data.pre) {
                     creatingElmInVPre++;
                 }
-                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn$2('Unknown custom element: <' +
                         tag +
                         '> - did you ' +
                         'register the component correctly? For recursive components, ' +
@@ -5310,11 +5314,11 @@ function createPatchFunction(backend) {
         // a reactivated keep-alive component doesn't insert itself
         insert(parentElm, vnode.elm, refElm);
     }
-    function insert(parent, elm, ref$$1) {
+    function insert(parent, elm, ref) {
         if (isDef(parent)) {
-            if (isDef(ref$$1)) {
-                if (nodeOps.parentNode(ref$$1) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref$$1);
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
                 }
             }
             else {
@@ -5327,8 +5331,8 @@ function createPatchFunction(backend) {
             if (process.env.NODE_ENV !== 'production') {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5342,8 +5346,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+            cbs.create[i_2](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5415,7 +5419,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
+            var i_3;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5427,16 +5431,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
+            if (isDef((i_3 = vnode.componentInstance)) &&
+                isDef((i_3 = i_3._vnode)) &&
+                isDef(i_3.data)) {
+                removeAndInvokeRemoveHook(i_3, rm);
             }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
+            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                cbs.remove[i_3](vnode, rm);
             }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
+            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                i_3(vnode, rm);
             }
             else {
                 rm();
@@ -5532,12 +5536,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
+        for (var i_4 = 0; i_4 < children.length; i_4++) {
+            var vnode = children[i_4];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5546,10 +5550,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (var i_5 = start; i_5 < end; i_5++) {
+            var c = oldCh[i_5];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                { return i_5; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5629,8 +5633,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
+            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                queue[i_6].data.hook.insert(queue[i_6]);
             }
         }
     }
@@ -5643,9 +5647,7 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        var tag = vnode.tag, data = vnode.data, children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5695,9 +5697,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        for (var i_7 = 0; i_7 < children.length; i_7++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5742,7 +5744,7 @@ function createPatchFunction(backend) {
     function assertNodeMatch(node, vnode, inVPre) {
         if (isDef(vnode.tag)) {
             return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement$$1(vnode, inVPre) &&
+                (!isUnknownElement(vnode, inVPre) &&
                     vnode.tag.toLowerCase() ===
                         (node.tagName && node.tagName.toLowerCase())));
         }
@@ -5784,7 +5786,7 @@ function createPatchFunction(backend) {
                             return oldVnode;
                         }
                         else if (process.env.NODE_ENV !== 'production') {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
                                 'server-rendered content. This is likely caused by incorrect ' +
                                 'HTML markup, for example nesting block-level elements inside ' +
                                 '<p>, or missing <tbody>. Bailing hydration and performing ' +
@@ -5809,22 +5811,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
+                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                            cbs.destroy[i_8](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                cbs.create[i_9](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
+                            var insert_1 = ancestor.data.hook.insert;
+                            if (insert_1.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                    insert_1.fns[i_10]();
                                 }
                             }
                         }
@@ -5849,7 +5851,7 @@ function createPatchFunction(backend) {
 }
 
 /* @flow */
-var directives = {
+var directives$1 = {
     create: updateDirectives,
     update: updateDirectives,
     destroy: function unbindDirectives(vnode) {
@@ -5865,8 +5867,8 @@ function updateDirectives(oldVnode, vnode) {
 function _update(oldVnode, vnode) {
     var isCreate = oldVnode === emptyNode;
     var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
     var dirsWithInsert = [];
     var dirsWithPostpatch = [];
     var key, oldDir, dir;
@@ -5875,7 +5877,7 @@ function _update(oldVnode, vnode) {
         dir = newDirs[key];
         if (!oldDir) {
             // new directive, bind
-            callHook$1(dir, 'bind', vnode, oldVnode);
+            callHook(dir, 'bind', vnode, oldVnode);
             if (dir.def && dir.def.inserted) {
                 dirsWithInsert.push(dir);
             }
@@ -5884,7 +5886,7 @@ function _update(oldVnode, vnode) {
             // existing directive, update
             dir.oldValue = oldDir.value;
             dir.oldArg = oldDir.arg;
-            callHook$1(dir, 'update', vnode, oldVnode);
+            callHook(dir, 'update', vnode, oldVnode);
             if (dir.def && dir.def.componentUpdated) {
                 dirsWithPostpatch.push(dir);
             }
@@ -5893,7 +5895,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithInsert.length) {
         var callInsert = function () {
             for (var i = 0; i < dirsWithInsert.length; i++) {
-                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
         if (isCreate) {
@@ -5906,7 +5908,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithPostpatch.length) {
         mergeVNodeHook(vnode, 'postpatch', function () {
             for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
     }
@@ -5914,13 +5916,13 @@ function _update(oldVnode, vnode) {
         for (key in oldDirs) {
             if (!newDirs[key]) {
                 // no longer present, unbind
-                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
             }
         }
     }
 }
 var emptyModifiers = Object.create(null);
-function normalizeDirectives$1(dirs, vm) {
+function normalizeDirectives(dirs, vm) {
     var res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
@@ -5940,21 +5942,21 @@ function normalizeDirectives$1(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
 }
-function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
         }
     }
 }
 
-var baseModules = [ref, directives];
+var baseModules = [ref, directives$1];
 
 /* @flow */
 function updateAttrs(oldVnode, vnode) {
@@ -6044,11 +6046,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            var blocker_1 = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
+                el.removeEventListener('input', blocker_1);
             };
-            el.addEventListener('input', blocker);
+            el.addEventListener('input', blocker_1);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6083,7 +6085,7 @@ function updateClass(oldVnode, vnode) {
         el._prevClass = cls;
     }
 }
-var klass = {
+var klass$1 = {
     create: updateClass,
     update: updateClass,
 };
@@ -6167,7 +6169,9 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p = (void 0);
+                var p 
+                // find first non-whitespace prev char
+                = void 0;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -6201,19 +6205,19 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return ("_f(\"" + filter + "\")(" + exp + ")");
+        return "_f(\"" + filter + "\")(" + exp + ")";
     }
     else {
-        var name = filter.slice(0, i);
+        var name_1 = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
     }
 }
 
 /* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+    console.error("[Vue compiler]: " + msg);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -6247,7 +6251,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6383,25 +6387,23 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                "? " + baseValueExpression + ".trim()" +
-                ": " + baseValueExpression + ")";
+                ("? " + baseValueExpression + ".trim()") +
+                (": " + baseValueExpression + ")");
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: ("(" + value + ")"),
+        value: "(" + value + ")",
         expression: JSON.stringify(value),
-        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
     };
 }
 /**
@@ -6410,10 +6412,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return (value + "=" + assignment);
+        return value + "=" + assignment;
     }
     else {
-        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
     }
 }
 /**
@@ -6430,18 +6432,18 @@ function genAssignmentCode(value, assignment) {
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-var len, str, chr, index$1, expressionPos, expressionEndPos;
+var len, str, chr, index, expressionPos, expressionEndPos;
 function parseModel(val) {
     // Fix https://github.com/vuejs/vue/pull/7730
     // allow v-model="obj.val " (trailing whitespace)
     val = val.trim();
     len = val.length;
     if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index$1 = val.lastIndexOf('.');
-        if (index$1 > -1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
             return {
-                exp: val.slice(0, index$1),
-                key: '"' + val.slice(index$1 + 1) + '"',
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
             };
         }
         else {
@@ -6452,7 +6454,7 @@ function parseModel(val) {
         }
     }
     str = val;
-    index$1 = expressionPos = expressionEndPos = 0;
+    index = expressionPos = expressionEndPos = 0;
     while (!eof()) {
         chr = next();
         /* istanbul ignore if */
@@ -6469,17 +6471,17 @@ function parseModel(val) {
     };
 }
 function next() {
-    return str.charCodeAt(++index$1);
+    return str.charCodeAt(++index);
 }
 function eof() {
-    return index$1 >= len;
+    return index >= len;
 }
 function isStringStart(chr) {
     return chr === 0x22 || chr === 0x27;
 }
 function parseBracket(chr) {
     var inBracket = 1;
-    expressionPos = index$1;
+    expressionPos = index;
     while (!eof()) {
         chr = next();
         if (isStringStart(chr)) {
@@ -6491,7 +6493,7 @@ function parseBracket(chr) {
         if (chr === 0x5d)
             { inBracket--; }
         if (inBracket === 0) {
-            expressionEndPos = index$1;
+            expressionEndPos = index;
             break;
         }
     }
@@ -6512,7 +6514,7 @@ var warn$1;
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-function model(el, dir, _warn) {
+function model$1(el, dir, _warn) {
     warn$1 = _warn;
     var value = dir.value;
     var modifiers = dir.modifiers;
@@ -6522,7 +6524,7 @@ function model(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn$1("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -6549,7 +6551,7 @@ function model(el, dir, _warn) {
         return false;
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+        warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
             "v-model is not supported on this element type. " +
             "If you are working with contenteditable, it's recommended to " +
             'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
@@ -6563,25 +6565,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        "?_i(" + value + "," + valueBinding + ")>-1" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
         (trueValueBinding === 'true'
-            ? (":(" + value + ")")
-            : (":_q(" + value + "," + trueValueBinding + ")")));
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
         'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
         '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -6589,10 +6591,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        "return " + (number ? '_n(val)' : 'val') + "})";
+        ("return " + (number ? '_n(val)' : 'val') + "})");
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
+    code = code + " " + genAssignmentCode(value, assignment);
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -6600,18 +6602,15 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     if (process.env.NODE_ENV !== 'production') {
-        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value$1 && !typeBinding) {
+        if (value_1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+            warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -6625,7 +6624,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', ("(" + value + ")"));
+    addProp(el, 'value', "(" + value + ")");
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -6641,8 +6640,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        var event_1 = isIE ? 'change' : 'input';
+        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6653,13 +6652,13 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target$1;
-function createOnceHandler$1(event, handler, capture) {
-    var _target = target$1; // save current target element in closure
+var target;
+function createOnceHandler(event, handler, capture) {
+    var _target = target; // save current target element in closure
     return function onceHandler() {
         var res = handler.apply(null, arguments);
         if (res !== null) {
-            remove$2(event, onceHandler, capture, _target);
+            remove(event, onceHandler, capture, _target);
         }
     };
 }
@@ -6667,7 +6666,7 @@ function createOnceHandler$1(event, handler, capture) {
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add$1(name, handler, capture, passive) {
+function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
     // happens because browsers fire microtask ticks between event propagation.
@@ -6675,17 +6674,17 @@ function add$1(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
+        var attachedTimestamp_1 = currentFlushTimestamp;
+        var original_1 = handler;
         //@ts-expect-error
-        handler = original._wrapper = function (e) {
+        handler = original_1._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
+                e.timeStamp >= attachedTimestamp_1 ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6694,14 +6693,14 @@ function add$1(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
+                return original_1.apply(this, arguments);
             }
         };
     }
-    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-function remove$2(name, handler, capture, _target) {
-    (_target || target$1).removeEventListener(name, 
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
     //@ts-expect-error
     handler._wrapper || handler, capture);
 }
@@ -6711,10 +6710,10 @@ function updateDOMListeners(oldVnode, vnode) {
     }
     var on = vnode.data.on || {};
     var oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
+    target = vnode.elm;
     normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
 }
 var events = {
     create: updateDOMListeners,
@@ -6929,9 +6928,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
+        var name_1 = vendorNames[i] + capName;
+        if (name_1 in emptyStyle) {
+            return name_1;
         }
     }
 });
@@ -6969,13 +6968,13 @@ function updateStyle(oldVnode, vnode) {
         }
     }
 }
-var style = {
+var style$1 = {
     create: updateStyle,
     update: updateStyle,
 };
 
 /* @flow */
-var whitespaceRE = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6988,7 +6987,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -7013,7 +7012,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -7038,31 +7037,31 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def$$1) {
-    if (!def$$1) {
+function resolveTransition(def) {
+    if (!def) {
         return;
     }
     /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
+    if (typeof def === 'object') {
         var res = {};
-        if (def$$1.css !== false) {
-            extend(res, autoCssTransition(def$$1.name || 'v'));
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
         }
-        extend(res, def$$1);
+        extend(res, def);
         return res;
     }
-    else if (typeof def$$1 === 'string') {
-        return autoCssTransition(def$$1);
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
     }
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -7109,15 +7108,12 @@ function addTransitionClass(el, cls) {
 }
 function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
-        remove(el._transitionClasses, cls);
+        remove$2(el._transitionClasses, cls);
     }
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7223,23 +7219,7 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7347,17 +7327,7 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7430,11 +7400,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
     }
     else if (isNaN(val)) {
-        warn("<transition> explicit " + name + " duration is NaN - " +
+        warn$2("<transition> explicit " + name + " duration is NaN - " +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7471,7 +7441,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove$$1(vnode, rm) {
+        remove: function (vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7484,13 +7454,13 @@ var transition = inBrowser
     }
     : {};
 
-var platformModules = [attrs, klass, events, domProps, style, transition];
+var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
 /* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+var modules$1 = platformModules.concat(baseModules);
+var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -7508,7 +7478,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+    inserted: function (el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -7538,22 +7508,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated: function (el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            var prevOptions_1 = el._vOptions;
+            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
+                        hasNoMatchingOption(binding.value, curOptions_1);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7575,8 +7545,8 @@ function actuallySetSelected(el, binding, vm) {
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+            warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
+                ("expects an Array value for its binding, but got " + Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7634,14 +7604,13 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
+        var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition$$1) {
+        if (value && transition) {
             vnode.data.show = true;
             enter(vnode, function () {
                 el.style.display = originalDisplay;
@@ -7651,16 +7620,14 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
-        if (transition$$1) {
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
             vnode.data.show = true;
             if (value) {
                 enter(vnode, function () {
@@ -7677,7 +7644,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7728,8 +7695,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    for (var key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7757,9 +7724,8 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
+    render: function (h) {
+        var _this = this;
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -7772,7 +7738,7 @@ var Transition = {
         }
         // warn multiple elements
         if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
+            warn$2('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
         var mode = this.mode;
@@ -7781,7 +7747,7 @@ var Transition = {
             mode &&
             mode !== 'in-out' &&
             mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
+            warn$2('invalid <transition> mode: ' + mode, this.$parent);
         }
         var rawChild = children[0];
         // if this is a component root node and the component's
@@ -7802,7 +7768,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        var id = "__transition-" + this._uid + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7836,8 +7802,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                    _this._leaving = false;
+                    _this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7845,14 +7811,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
+                var delayedLeave_1;
                 var performLeave = function () {
-                    delayedLeave();
+                    delayedLeave_1();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave = leave;
+                    delayedLeave_1 = leave;
                 });
             }
         }
@@ -7869,22 +7835,21 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
+    beforeMount: function () {
+        var _this = this;
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+            var restoreActiveInstance = setActiveInstance(_this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            _this._vnode = _this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(_this, vnode, hydrating);
         };
     },
-    render: function render(h) {
+    render: function (h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -7901,27 +7866,27 @@ var TransitionGroup = {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     var opts = c.componentOptions;
-                    var name = opts
+                    var name_1 = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
+            for (var i = 0; i < prevChildren.length; i++) {
+                var c = prevChildren[i];
+                c.data.transition = transitionData;
                 // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                c.data.pos = c.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7929,7 +7894,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
+    updated: function () {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7947,25 +7912,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
-                addTransitionClass(el, moveClass);
+                var el_1 = c.elm;
+                var s = el_1.style;
+                addTransitionClass(el_1, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
+                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                    if (e && e.target !== el_1) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
+                        el_1.removeEventListener(transitionEndEvent, cb);
+                        el_1._moveCb = null;
+                        removeTransitionClass(el_1, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove: function (el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -8104,7 +8069,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push(("_s(" + exp + ")"));
+        tokens.push("_s(" + exp + ")");
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8119,7 +8084,7 @@ function parseText(text, delimiters) {
 }
 
 /* @flow */
-function transformNode(el, options) {
+function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
     if (process.env.NODE_ENV !== 'production' && staticClass) {
@@ -8139,24 +8104,24 @@ function transformNode(el, options) {
         el.classBinding = classBinding;
     }
 }
-function genData(el) {
+function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + (el.staticClass) + ",";
+        data += "staticClass:" + el.staticClass + ",";
     }
     if (el.classBinding) {
-        data += "class:" + (el.classBinding) + ",";
+        data += "class:" + el.classBinding + ",";
     }
     return data;
 }
-var klass$1 = {
+var klass = {
     staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData,
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
 /* @flow */
-function transformNode$1(el, options) {
+function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
@@ -8180,369 +8145,19 @@ function transformNode$1(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + (el.staticStyle) + ",";
+        data += "staticStyle:" + el.staticStyle + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + (el.styleBinding) + "),";
+        data += "style:(" + el.styleBinding + "),";
     }
     return data;
 }
-var style$1 = {
+var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
+    transformNode: transformNode,
     genData: genData$1,
 };
 
-/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-(function(root) {
-
-	// Detect free variables `exports`.
-	var freeExports = typeof exports == 'object' && exports;
-
-	// Detect free variable `module`.
-	var freeModule = typeof module == 'object' && module &&
-		module.exports == freeExports && module;
-
-	// Detect free variable `global`, from Node.js or Browserified code,
-	// and use it as `root`.
-	var freeGlobal = typeof global == 'object' && global;
-	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-		root = freeGlobal;
-	}
-
-	/*--------------------------------------------------------------------------*/
-
-	// All astral symbols.
-	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-	// All ASCII symbols (not just printable ASCII) except those listed in the
-	// first column of the overrides table.
-	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-	// code points listed in the first column of the overrides table on
-	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-	var regexEscape = /["&'<>`]/g;
-	var escapeMap = {
-		'"': '&quot;',
-		'&': '&amp;',
-		'\'': '&#x27;',
-		'<': '&lt;',
-		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-		// following is not strictly necessary unless it’s part of a tag or an
-		// unquoted attribute value. We’re only escaping it to support those
-		// situations, and for XML support.
-		'>': '&gt;',
-		// In Internet Explorer ≤ 8, the backtick character can be used
-		// to break out of (un)quoted attribute values or HTML comments.
-		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-		// http://html5sec.org/#133.
-		'`': '&#x60;'
-	};
-
-	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-	/*--------------------------------------------------------------------------*/
-
-	var stringFromCharCode = String.fromCharCode;
-
-	var object = {};
-	var hasOwnProperty = object.hasOwnProperty;
-	var has = function(object, propertyName) {
-		return hasOwnProperty.call(object, propertyName);
-	};
-
-	var contains = function(array, value) {
-		var index = -1;
-		var length = array.length;
-		while (++index < length) {
-			if (array[index] == value) {
-				return true;
-			}
-		}
-		return false;
-	};
-
-	var merge = function(options, defaults) {
-		if (!options) {
-			return defaults;
-		}
-		var result = {};
-		var key;
-		for (key in defaults) {
-			// A `hasOwnProperty` check is not needed here, since only recognized
-			// option names are used anyway. Any others are ignored.
-			result[key] = has(options, key) ? options[key] : defaults[key];
-		}
-		return result;
-	};
-
-	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-	var codePointToSymbol = function(codePoint, strict) {
-		var output = '';
-		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-			// See issue #4:
-			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-			// REPLACEMENT CHARACTER.”
-			if (strict) {
-				parseError('character reference outside the permissible Unicode range');
-			}
-			return '\uFFFD';
-		}
-		if (has(decodeMapNumeric, codePoint)) {
-			if (strict) {
-				parseError('disallowed character reference');
-			}
-			return decodeMapNumeric[codePoint];
-		}
-		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-			parseError('disallowed character reference');
-		}
-		if (codePoint > 0xFFFF) {
-			codePoint -= 0x10000;
-			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-			codePoint = 0xDC00 | codePoint & 0x3FF;
-		}
-		output += stringFromCharCode(codePoint);
-		return output;
-	};
-
-	var hexEscape = function(codePoint) {
-		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-	};
-
-	var decEscape = function(codePoint) {
-		return '&#' + codePoint + ';';
-	};
-
-	var parseError = function(message) {
-		throw Error('Parse error: ' + message);
-	};
-
-	/*--------------------------------------------------------------------------*/
-
-	var encode = function(string, options) {
-		options = merge(options, encode.options);
-		var strict = options.strict;
-		if (strict && regexInvalidRawCodePoint.test(string)) {
-			parseError('forbidden code point');
-		}
-		var encodeEverything = options.encodeEverything;
-		var useNamedReferences = options.useNamedReferences;
-		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-		var escapeBmpSymbol = function(symbol) {
-			return escapeCodePoint(symbol.charCodeAt(0));
-		};
-
-		if (encodeEverything) {
-			// Encode ASCII symbols.
-			string = string.replace(regexAsciiWhitelist, function(symbol) {
-				// Use named references if requested & possible.
-				if (useNamedReferences && has(encodeMap, symbol)) {
-					return '&' + encodeMap[symbol] + ';';
-				}
-				return escapeBmpSymbol(symbol);
-			});
-			// Shorten a few escapes that represent two symbols, of which at least one
-			// is within the ASCII range.
-			if (useNamedReferences) {
-				string = string
-					.replace(/&gt;\u20D2/g, '&nvgt;')
-					.replace(/&lt;\u20D2/g, '&nvlt;')
-					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-			}
-			// Encode non-ASCII symbols.
-			if (useNamedReferences) {
-				// Encode non-ASCII symbols that can be replaced with a named reference.
-				string = string.replace(regexEncodeNonAscii, function(string) {
-					// Note: there is no need to check `has(encodeMap, string)` here.
-					return '&' + encodeMap[string] + ';';
-				});
-			}
-			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-		} else if (useNamedReferences) {
-			// Apply named character references.
-			// Encode `<>"'&` using named character references.
-			if (!allowUnsafeSymbols) {
-				string = string.replace(regexEscape, function(string) {
-					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-				});
-			}
-			// Shorten escapes that represent two symbols, of which at least one is
-			// `<>"'&`.
-			string = string
-				.replace(/&gt;\u20D2/g, '&nvgt;')
-				.replace(/&lt;\u20D2/g, '&nvlt;');
-			// Encode non-ASCII symbols that can be replaced with a named reference.
-			string = string.replace(regexEncodeNonAscii, function(string) {
-				// Note: there is no need to check `has(encodeMap, string)` here.
-				return '&' + encodeMap[string] + ';';
-			});
-		} else if (!allowUnsafeSymbols) {
-			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-			// using named character references.
-			string = string.replace(regexEscape, escapeBmpSymbol);
-		}
-		return string
-			// Encode astral symbols.
-			.replace(regexAstralSymbols, function($0) {
-				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-				var high = $0.charCodeAt(0);
-				var low = $0.charCodeAt(1);
-				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-				return escapeCodePoint(codePoint);
-			})
-			// Encode any remaining BMP symbols that are not printable ASCII symbols
-			// using a hexadecimal escape.
-			.replace(regexBmpWhitelist, escapeBmpSymbol);
-	};
-	// Expose default options (so they can be overridden globally).
-	encode.options = {
-		'allowUnsafeSymbols': false,
-		'encodeEverything': false,
-		'strict': false,
-		'useNamedReferences': false,
-		'decimal' : false
-	};
-
-	var decode = function(html, options) {
-		options = merge(options, decode.options);
-		var strict = options.strict;
-		if (strict && regexInvalidEntity.test(html)) {
-			parseError('malformed character reference');
-		}
-		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-			var codePoint;
-			var semicolon;
-			var decDigits;
-			var hexDigits;
-			var reference;
-			var next;
-
-			if ($1) {
-				reference = $1;
-				// Note: there is no need to check `has(decodeMap, reference)`.
-				return decodeMap[reference];
-			}
-
-			if ($2) {
-				// Decode named character references without trailing `;`, e.g. `&amp`.
-				// This is only a parse error if it gets converted to `&`, or if it is
-				// followed by `=` in an attribute context.
-				reference = $2;
-				next = $3;
-				if (next && options.isAttributeValue) {
-					if (strict && next == '=') {
-						parseError('`&` did not start a character reference');
-					}
-					return $0;
-				} else {
-					if (strict) {
-						parseError(
-							'named character reference was not terminated by a semicolon'
-						);
-					}
-					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-					return decodeMapLegacy[reference] + (next || '');
-				}
-			}
-
-			if ($4) {
-				// Decode decimal escapes, e.g. `&#119558;`.
-				decDigits = $4;
-				semicolon = $5;
-				if (strict && !semicolon) {
-					parseError('character reference was not terminated by a semicolon');
-				}
-				codePoint = parseInt(decDigits, 10);
-				return codePointToSymbol(codePoint, strict);
-			}
-
-			if ($6) {
-				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-				hexDigits = $6;
-				semicolon = $7;
-				if (strict && !semicolon) {
-					parseError('character reference was not terminated by a semicolon');
-				}
-				codePoint = parseInt(hexDigits, 16);
-				return codePointToSymbol(codePoint, strict);
-			}
-
-			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-			if (strict) {
-				parseError(
-					'named character reference was not terminated by a semicolon'
-				);
-			}
-			return $0;
-		});
-	};
-	// Expose default options (so they can be overridden globally).
-	decode.options = {
-		'isAttributeValue': false,
-		'strict': false
-	};
-
-	var escape = function(string) {
-		return string.replace(regexEscape, function($0) {
-			// Note: there is no need to check `has(escapeMap, $0)` here.
-			return escapeMap[$0];
-		});
-	};
-
-	/*--------------------------------------------------------------------------*/
-
-	var he = {
-		'version': '1.2.0',
-		'encode': encode,
-		'decode': decode,
-		'escape': escape,
-		'unescape': decode
-	};
-
-	// Some AMD build optimizers, like r.js, check for specific condition patterns
-	// like the following:
-	if (
-		typeof define == 'function' &&
-		typeof define.amd == 'object' &&
-		define.amd
-	) {
-		define(function() {
-			return he;
-		});
-	}	else if (freeExports && !freeExports.nodeType) {
-		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-			freeModule.exports = he;
-		} else { // in Narwhal or RingoJS v0.7.0-
-			for (var key in he) {
-				has(he, key) && (freeExports[key] = he[key]);
-			}
-		}
-	} else { // in Rhino or a web browser
-		root.he = he;
-	}
-
-}(undefined));
-
-var he = /*#__PURE__*/Object.freeze({
-
-});
-
 /* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
@@ -8563,11 +8178,11 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
+var startTagOpen = new RegExp("^<" + qnameCapture);
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -8588,7 +8203,9 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+};
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -8596,11 +8213,11 @@ function decodeAttr(value, shouldDecodeNewlines) {
 function parseHTML(html, options) {
     var stack = [];
     var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var isUnaryTag = options.isUnaryTag || no;
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    while (html) {
+    var _loop_1 = function () {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -8614,7 +8231,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        continue;
+                        return "continue";
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -8622,14 +8239,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        continue;
+                        return "continue";
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    continue;
+                    return "continue";
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -8637,7 +8254,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
+                    return "continue";
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -8646,10 +8263,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    continue;
+                    return "continue";
                 }
             }
-            var text = (void 0), rest = (void 0), next = (void 0);
+            var text = void 0, rest = void 0, next = void 0;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8676,18 +8293,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength = 0;
-            var stackedTag = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+            var endTagLength_1 = 0;
+            var stackedTag_1 = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag_1] ||
+                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+            var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength_1 = endTag.length;
+                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -8695,21 +8312,26 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest$1.length;
-            html = rest$1;
-            parseEndTag(stackedTag, index - endTagLength, index);
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag_1, index - endTagLength_1, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (process.env.NODE_ENV !== 'production' &&
                 !stack.length &&
                 options.warn) {
-                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                     start: index + html.length,
                 });
             }
-            break;
+            return "break";
         }
+    };
+    while (html) {
+        var state_1 = _loop_1();
+        if (state_1 === "break")
+            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -8726,7 +8348,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end, attr;
+            var end = void 0, attr = void 0;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8749,11 +8371,11 @@ function parseHTML(html, options) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
             }
-            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var unary = isUnaryTag(tagName) || !!unarySlash;
         var l = match.attrs.length;
         var attrs = new Array(l);
         for (var i = 0; i < l; i++) {
@@ -8810,7 +8432,7 @@ function parseHTML(html, options) {
                 if (process.env.NODE_ENV !== 'production' &&
                     (i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8840,6 +8462,7 @@ function parseHTML(html, options) {
 }
 
 /* @flow */
+var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8851,12 +8474,12 @@ var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
 var slotRE = /^v-slot(:|$)|^#/;
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE$1 = /[ \f\t\r\n]+/g;
+var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(undefined);
+var decodeHTMLCached = cached(he.decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
-var warn$2;
+var warn;
 var delimiters;
 var transforms;
 var preTransforms;
@@ -8880,7 +8503,7 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn$2 = options.warn || baseWarn;
+    warn = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
@@ -8901,7 +8524,7 @@ function parse(template, options) {
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn$2(msg, range);
+            warn(msg, range);
         }
     }
     function closeElement(element) {
@@ -8936,8 +8559,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                    var name_1 = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -8963,7 +8586,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode;
+            var lastNode = void 0;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8973,7 +8596,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8982,7 +8605,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn$2,
+        warn: warn,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8990,7 +8613,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function start(tag, attrs, unary, start$1, end) {
+        start: function (tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -9005,7 +8628,7 @@ function parse(template, options) {
             }
             if (process.env.NODE_ENV !== 'production') {
                 if (options.outputSourceRange) {
-                    element.start = start$1;
+                    element.start = start;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -9014,7 +8637,7 @@ function parse(template, options) {
                 }
                 attrs.forEach(function (attr) {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$2("Invalid dynamic argument expression: attribute names cannot contain " +
+                        warn("Invalid dynamic argument expression: attribute names cannot contain " +
                             "spaces, quotes, <, >, / or =.", {
                             start: attr.start + attr.name.indexOf("["),
                             end: attr.start + attr.name.length,
@@ -9025,9 +8648,9 @@ function parse(template, options) {
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
                 process.env.NODE_ENV !== 'production' &&
-                    warn$2('Templates should only be responsible for mapping the state to the ' +
+                    warn('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        "<" + tag + ">" +
+                        ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -9066,24 +8689,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function end(tag, start, end$1) {
+        end: function (tag, start, end) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end$1;
+                element.end = end;
             }
             closeElement(element);
         },
-        chars: function chars(text, start, end) {
+        chars: function (text, start, end) {
             if (!currentParent) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                             start: start,
                         });
                     }
@@ -9121,10 +8744,10 @@ function parse(template, options) {
             if (text) {
                 if (!inPre && whitespaceOption === 'condense') {
                     // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE$1, ' ');
+                    text = text.replace(whitespaceRE, ' ');
                 }
-                var res;
-                var child;
+                var res = void 0;
+                var child = void 0;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -9151,7 +8774,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function comment(text, start, end) {
+        comment: function (text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -9218,16 +8841,16 @@ function processKey(el) {
     if (exp) {
         if (process.env.NODE_ENV !== 'production') {
             if (el.tag === 'template') {
-                warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent = el.parent;
+                var parent_1 = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$2("Do not use v-for index as key on <transition-group> children, " +
+                    parent_1 &&
+                    parent_1.tag === 'transition-group') {
+                    warn("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
@@ -9250,7 +8873,7 @@ function processFor(el) {
             extend(el, res);
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$2(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+            warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -9302,8 +8925,8 @@ function processIfConditions(el, parent) {
         });
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+        warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -9314,7 +8937,7 @@ function findPrevElement(children) {
         }
         else {
             if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$2("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -9328,8 +8951,8 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
+    var once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
         el.once = true;
     }
 }
@@ -9341,7 +8964,7 @@ function processSlotContent(el) {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn$2("the \"scope\" attribute for scoped slots have been deprecated and " +
+            warn("the \"scope\" attribute for scoped slots have been deprecated and " +
                 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                 "can also be used on plain elements in addition to <template> to " +
                 "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -9351,7 +8974,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$2("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+            warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -9376,52 +8999,48 @@ function processSlotContent(el) {
             if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (el.slotTarget || el.slotScope) {
-                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$2("<template v-slot> can only appear at the root level inside " +
+                        warn("<template v-slot> can only appear at the root level inside " +
                             "the receiving component", el);
                     }
                 }
-                var ref = getSlotName(slotBinding);
-                var name = ref.name;
-                var dynamic = ref.dynamic;
-                el.slotTarget = name;
+                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                el.slotTarget = name_2;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding$1) {
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (!maybeComponent(el)) {
-                        warn$2("v-slot can only be used on components or <template>.", slotBinding$1);
+                        warn("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
-                        warn$2("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding$1);
+                        warn("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var ref$1 = getSlotName(slotBinding$1);
-                var name$1 = ref$1.name;
-                var dynamic$1 = ref$1.dynamic;
-                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name$1;
-                slotContainer.slotTargetDynamic = dynamic$1;
-                slotContainer.children = el.children.filter(function (c) {
+                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                slotContainer_1.slotTarget = name_3;
+                slotContainer_1.slotTargetDynamic = dynamic;
+                slotContainer_1.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer;
+                        c.parent = slotContainer_1;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -9437,21 +9056,21 @@ function getSlotName(binding) {
             name = 'default';
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$2("v-slot shorthand syntax requires a slot name.", binding);
+            warn("v-slot shorthand syntax requires a slot name.", binding);
         }
     }
     return dynamicArgRE.test(name)
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: ("\"" + name + "\""), dynamic: false };
+            { name: "\"" + name + "\"", dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn$2("`key` does not work on <slot> because slots are abstract outlets " +
+            warn("`key` does not work on <slot> because slots are abstract outlets " +
                 "and can possibly expand into multiple elements. " +
                 "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
         }
@@ -9491,7 +9110,7 @@ function processAttrs(el) {
                 }
                 if (process.env.NODE_ENV !== 'production' &&
                     value.trim().length === 0) {
-                    warn$2(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                    warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9505,14 +9124,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$2, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$2, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$2, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
                             );
                         }
                     }
@@ -9532,7 +9151,7 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
             }
             else {
                 // normal directives
@@ -9559,7 +9178,7 @@ function processAttrs(el) {
             if (process.env.NODE_ENV !== 'production') {
                 var res = parseText(value, delimiters);
                 if (res) {
-                    warn$2(name + "=\"" + value + "\": " +
+                    warn(name + "=\"" + value + "\": " +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9589,11 +9208,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret = {};
+        var ret_1 = {};
         match.forEach(function (m) {
-            ret[m.slice(1)] = true;
+            ret_1[m.slice(1)] = true;
         });
-        return ret;
+        return ret_1;
     }
 }
 function makeAttrsMap(attrs) {
@@ -9603,7 +9222,7 @@ function makeAttrsMap(attrs) {
             map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9636,7 +9255,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            warn("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9653,16 +9272,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding;
+        var typeBinding = void 0;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + (map['v-bind']) + ").type";
+            typeBinding = "(" + map['v-bind'] + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -9708,28 +9327,28 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model$1 = {
+var model = {
     preTransformNode: preTransformNode,
 };
 
-var modules$1 = [klass$1, style$1, model$1];
+var modules = [klass, style, model];
 
 /* @flow */
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
 /* @flow */
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
     }
 }
 
-var directives$1 = {
-    model: model,
+var directives = {
+    model: model$1,
     text: text,
     html: html,
 };
@@ -9737,8 +9356,8 @@ var directives$1 = {
 /* @flow */
 var baseOptions = {
     expectHTML: true,
-    modules: modules$1,
-    directives: directives$1,
+    modules: modules,
+    directives: directives,
     isPreTag: isPreTag,
     isUnaryTag: isUnaryTag,
     mustUseProp: mustUseProp,
@@ -9746,13 +9365,13 @@ var baseOptions = {
     isReservedTag: isReservedTag,
     getTagNamespace: getTagNamespace,
     // @ts-ignore
-    staticKeys: genStaticKeys(modules$1),
+    staticKeys: genStaticKeys$1(modules),
 };
 
 /* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
-var genStaticKeysCached = cached(genStaticKeys$1);
+var genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -9770,15 +9389,15 @@ function optimize(root, options) {
     isStaticKey = genStaticKeysCached(options.staticKeys || '');
     isPlatformReservedTag = options.isReservedTag || no;
     // first pass: mark all non-static nodes.
-    markStatic$1(root);
+    markStatic(root);
     // second pass: mark static roots.
     markStaticRoots(root, false);
 }
-function genStaticKeys$1(keys) {
+function genStaticKeys(keys) {
     return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
         (keys ? ',' + keys : ''));
 }
-function markStatic$1(node) {
+function markStatic(node) {
     node.static = isStatic(node);
     if (node.type === 1) {
         // do not make component slot content static. this avoids
@@ -9791,15 +9410,15 @@ function markStatic$1(node) {
         }
         for (var i = 0, l = node.children.length; i < l; i++) {
             var child = node.children[i];
-            markStatic$1(child);
+            markStatic(child);
             if (!child.static) {
                 node.static = false;
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
-                markStatic$1(block);
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
+                markStatic(block);
                 if (!block.static) {
                     node.static = false;
                 }
@@ -9830,8 +9449,8 @@ function markStaticRoots(node, isInFor) {
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
     }
@@ -9902,7 +9521,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -9919,19 +9538,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name in events) {
-        var handlerCode = genHandler(events[name]);
+    for (var name_1 in events) {
+        var handlerCode = genHandler(events[name_1]);
         //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += name + "," + handlerCode + ",";
+        if (events[name_1] && events[name_1].dynamic) {
+            dynamicHandlers += name_1 + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
     if (dynamicHandlers) {
-        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
     }
     else {
         return prefix + staticHandlers;
@@ -9942,7 +9561,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -9951,13 +9570,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        for (var key in handler.modifiers) {
+        var _loop_1 = function (key) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -9966,15 +9585,18 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers = handler.modifiers;
+                var modifiers_1 = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
+        };
+        for (var key in handler.modifiers) {
+            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -9984,13 +9606,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            ? "return " + handler.value + ".apply(null, arguments)"
             : isFunctionExpression
-                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                ? "return (" + handler.value + ").apply(null, arguments)"
                 : isFunctionInvocation
-                    ? ("return " + (handler.value))
+                    ? "return " + handler.value
                     : handler.value;
-        return ("function($event){" + code + handlerCode + "}");
+        return "function($event){" + code + handlerCode + "}";
     }
 }
 function genKeyFilter(keys) {
@@ -9999,59 +9621,64 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&')) + ")return null;");
+        (keys.map(genFilterCode).join('&&') + ")return null;"));
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return ("$event.keyCode!==" + keyVal);
+        return "$event.keyCode!==" + keyVal;
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key)) + "," +
-        (JSON.stringify(keyCode)) + "," +
+        (JSON.stringify(key) + ",") +
+        (JSON.stringify(keyCode) + ",") +
         "$event.key," +
-        "" + (JSON.stringify(keyName)) +
+        ("" + JSON.stringify(keyName)) +
         ")");
 }
 
 /* @flow */
 function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn("v-on without argument does not support modifiers.");
+        warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
 /* @flow */
-function bind$1(el, dir) {
+function bind(el, dir) {
     el.wrapData = function (code) {
-        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
 /* @flow */
 var baseDirectives = {
     on: on,
-    bind: bind$1,
+    bind: bind,
     cloak: noop,
 };
 
 /* @flow */
-var CodegenState = function CodegenState(options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-};
+var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        var isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = function (el) {
+            return !!el.component || !isReservedTag(el.tag);
+        };
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+    return CodegenState;
+}());
 function generate(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
@@ -10061,7 +9688,7 @@ function generate(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -10089,17 +9716,19 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code;
+        var code = void 0;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data;
+            var data = void 0;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData$2(el, state);
+                data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+            ) + (children ? "," + children : '' // children
+            ) + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -10118,9 +9747,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
     state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
 }
 // v-once
 function genOnce(el, state) {
@@ -10130,20 +9759,20 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
+        var parent_1 = el.parent;
+        while (parent_1) {
+            if (parent_1.for) {
+                key = parent_1.key;
                 break;
             }
-            parent = parent.parent;
+            parent_1 = parent_1.parent;
         }
         if (!key) {
             process.env.NODE_ENV !== 'production' &&
                 state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
     }
     else {
         return genStatic(el, state);
@@ -10159,10 +9788,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
     }
     else {
-        return ("" + (genTernaryExp(condition.block)));
+        return "" + genTernaryExp(condition.block);
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -10176,24 +9805,24 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
     if (process.env.NODE_ENV !== 'production' &&
         state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
+        ("function(" + alias + iterator1 + iterator2 + "){") +
+        ("return " + (altGen || genElement)(el, state)) +
         '})');
 }
-function genData$2(el, state) {
+function genData(el, state) {
     var data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
@@ -10202,11 +9831,11 @@ function genData$2(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + (el.key) + ",";
+        data += "key:" + el.key + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + (el.ref) + ",";
+        data += "ref:" + el.ref + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -10217,7 +9846,7 @@ function genData$2(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + (el.tag) + "\",";
+        data += "tag:\"" + el.tag + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -10225,31 +9854,31 @@ function genData$2(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + (genProps(el.attrs)) + ",";
+        data += "attrs:" + genProps(el.attrs) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + (genProps(el.props)) + ",";
+        data += "domProps:" + genProps(el.props) + ",";
     }
     // event handlers
     if (el.events) {
-        data += (genHandlers(el.events, false)) + ",";
+        data += genHandlers(el.events, false) + ",";
     }
     if (el.nativeEvents) {
-        data += (genHandlers(el.nativeEvents, true)) + ",";
+        data += genHandlers(el.nativeEvents, true) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + (el.slotTarget) + ",";
+        data += "slot:" + el.slotTarget + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+        data += genScopedSlots(el, el.scopedSlots, state) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -10263,7 +9892,7 @@ function genData$2(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -10293,9 +9922,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -10310,9 +9939,9 @@ function genInlineTemplate(el, state) {
     }
     if (ast && ast.type === 1) {
         var inlineRenderFns = generate(ast, state.options);
-        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-            .map(function (code) { return ("function(){" + code + "}"); })
-            .join(',')) + "]}");
+        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+            .map(function (code) { return "function(){" + code + "}"; })
+            .join(',') + "]}";
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -10337,23 +9966,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
+        var parent_2 = el.parent;
+        while (parent_2) {
+            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                parent_2.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent.if) {
+            if (parent_2.if) {
                 needsKey = true;
             }
-            parent = parent.parent;
+            parent_2 = parent_2.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
 }
 function hash(str) {
     var hash = 5381;
@@ -10382,36 +10011,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        "return " + (el.tag === 'template'
+        ("return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}";
+            : genElement(el, state)) + "}");
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el$1 = children[0];
+        var el_1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el$1.for &&
-            el$1.tag !== 'template' &&
-            el$1.tag !== 'slot') {
-            var normalizationType = checkSkip
-                ? state.maybeComponent(el$1)
+            el_1.for &&
+            el_1.tag !== 'template' &&
+            el_1.tag !== 'slot') {
+            var normalizationType_1 = checkSkip
+                ? state.maybeComponent(el_1)
                     ? ",1"
                     : ",0"
                 : "";
-            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
         }
-        var normalizationType$1 = checkSkip
+        var normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen = altGenNode || genNode;
-        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+        var gen_1 = altGenNode || genNode;
+        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
     }
 }
 // determine the normalization needed for the children array.
@@ -10453,17 +10082,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return ("_v(" + (text.type === 2
+    return "_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
 }
 function genComment(comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+    return "_e(" + JSON.stringify(comment.text) + ")";
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var res = "_t(" + slotName + (children ? "," + children : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -10472,22 +10101,22 @@ function genSlot(el, state) {
             dynamic: attr.dynamic,
         }); }))
         : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
+    var bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
         res += ",null";
     }
     if (attrs) {
         res += "," + attrs;
     }
-    if (bind$$1) {
-        res += (attrs ? '' : ',null') + "," + bind$$1;
+    if (bind) {
+        res += (attrs ? '' : ',null') + "," + bind;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
 }
 function genProps(props) {
     var staticProps = "";
@@ -10496,15 +10125,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += (prop.name) + "," + value + ",";
+            dynamicProps += prop.name + "," + value + ",";
         }
         else {
-            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+            staticProps += "\"" + prop.name + "\":" + value + ",";
         }
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    staticProps = "{" + staticProps.slice(0, -1) + "}";
     if (dynamicProps) {
-        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
     }
     else {
         return staticProps;
@@ -10539,22 +10168,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                var value = node.attrsMap[name];
+        for (var name_1 in node.attrsMap) {
+            if (dirRE.test(name_1)) {
+                var value = node.attrsMap[name_1];
                 if (value) {
-                    var range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    var range = node.rawAttrsMap[name_1];
+                    if (name_1 === 'v-for') {
+                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
                     }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (onRE.test(name_1)) {
+                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                     else {
-                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                 }
             }
@@ -10574,7 +10203,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10587,16 +10216,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(("var " + ident + "=_"));
+            new Function("var " + ident + "=_");
         }
         catch (e) {
-            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(("return " + exp));
+        new Function("return " + exp);
     }
     catch (e) {
         var keywordMatch = exp
@@ -10604,12 +10233,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
         }
         else {
-            warn("invalid expression: " + (e.message) + " in\n\n" +
-                "    " + exp + "\n\n" +
-                "  Raw expression: " + (text.trim()) + "\n", range);
+            warn("invalid expression: " + e.message + " in\n\n" +
+                ("    " + exp + "\n\n") +
+                ("  Raw expression: " + text.trim() + "\n"), range);
         }
     }
 }
@@ -10618,18 +10247,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-            "    " + exp + "\n\n" +
-            "  Raw expression: " + (text.trim()) + "\n", range);
+        warn("invalid function parameter expression: " + e.message + " in\n\n" +
+            ("    " + exp + "\n\n") +
+            ("  Raw expression: " + text.trim() + "\n"), range);
     }
 }
 
 /* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
+    if (start === void 0) { start = 0; }
+    if (end === void 0) { end = source.length; }
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -10639,18 +10267,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                    var length_1 = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length$1 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat$1("^", length$1));
+                        var length_2 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length_2));
                     }
                     count += lineLength + 1;
                 }
@@ -10660,7 +10288,7 @@ function generateCodeFrame(source, start, end) {
     }
     return res.join('\n');
 }
-function repeat$1(str, n) {
+function repeat(str, n) {
     var result = '';
     if (n > 0) {
         while (true) {
@@ -10690,7 +10318,7 @@ function createCompileToFunctionFn(compile) {
     var cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn$$1 = options.warn || warn;
+        var warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
@@ -10700,7 +10328,7 @@ function createCompileToFunctionFn(compile) {
             }
             catch (e) {
                 if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
                         'environment with Content Security Policy that prohibits unsafe-eval. ' +
                         'The template compiler cannot work in this environment. Consider ' +
                         'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -10722,13 +10350,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                    warn("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -10754,14 +10382,12 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn$$1("Failed to generate render function:\n\n" +
+                warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (ref) {
-                            var err = ref.err;
-                            var code = ref.code;
-
-                            return ((err.toString()) + " in\n\n" + code + "\n");
-                })
+                        .map(function (_a) {
+                        var err = _a.err, code = _a.code;
+                        return err.toString() + " in\n\n" + code + "\n";
+                    })
                         .join('\n'), vm);
             }
         }
@@ -10783,15 +10409,15 @@ function createCompilerCreator(baseCompile) {
                 if (process.env.NODE_ENV !== 'production' &&
                     options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
+                                data.start = range.start + leadingSpaceLength_1;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
+                                data.end = range.end + leadingSpaceLength_1;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -10846,9 +10472,7 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
 });
 
 /* @flow */
-var ref$1 = createCompiler(baseOptions);
-var compile = ref$1.compile;
-var compileToFunctions = ref$1.compileToFunctions;
+var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
 /* @flow */
 // check whether current browser encodes a char inside attribute values
@@ -10876,7 +10500,7 @@ Vue.prototype.$mount = function (el, hydrating) {
     /* istanbul ignore if */
     if (el === document.body || el === document.documentElement) {
         process.env.NODE_ENV !== 'production' &&
-            warn("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+            warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
         return this;
     }
     var options = this.$options;
@@ -10889,7 +10513,7 @@ Vue.prototype.$mount = function (el, hydrating) {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (process.env.NODE_ENV !== 'production' && !template) {
-                        warn(("Template element not found or is empty: " + (options.template)), this);
+                        warn$2("Template element not found or is empty: " + options.template, this);
                     }
                 }
             }
@@ -10898,7 +10522,7 @@ Vue.prototype.$mount = function (el, hydrating) {
             }
             else {
                 if (process.env.NODE_ENV !== 'production') {
-                    warn('invalid template option:' + template, this);
+                    warn$2('invalid template option:' + template, this);
                 }
                 return this;
             }
@@ -10912,21 +10536,19 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
                 mark('compile');
             }
-            var ref = compileToFunctions(template, {
+            var _a = compileToFunctions(template, {
                 outputSourceRange: process.env.NODE_ENV !== 'production',
                 shouldDecodeNewlines: shouldDecodeNewlines,
                 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
-            }, this);
-            var render = ref.render;
-            var staticRenderFns = ref.staticRenderFns;
+            }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
                 mark('compile end');
-                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+                measure("vue " + this._name + " compile", 'compile', 'compile end');
             }
         }
     }
diff --git a/dist/vue.js b/dist/vue.js
index a5cba7a2552..2eb5cf4e43e 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -6,8 +6,8 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
-  (global = global || self, global.Vue = factory());
-}(this, function () { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
+}(this, (function () { 'use strict';
 
   /* @flow */
   var emptyObject = Object.freeze({});
@@ -113,7 +113,7 @@
   /**
    * Remove an item from an array.
    */
-  function remove(arr, item) {
+  function remove$2(arr, item) {
       if (arr.length) {
           var index = arr.indexOf(item);
           if (index > -1) {
@@ -182,7 +182,7 @@
       return fn.bind(ctx);
   }
   // @ts-expect-error bind cannot be `undefined`
-  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
+  var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Convert an Array-like object to a real Array.
    */
@@ -235,7 +235,7 @@
   /**
    * Generate a string containing static keys from compiler modules.
    */
-  function genStaticKeys(modules) {
+  function genStaticKeys$1(modules) {
       return modules
           .reduce(function (keys, m) {
           return keys.concat(m.staticKeys || []);
@@ -437,7 +437,7 @@
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+  var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
   function parsePath(path) {
       if (bailRE.test(path)) {
           return;
@@ -468,10 +468,10 @@
   var isIE = UA && /msie|trident/.test(UA);
   var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
   var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-  var isPhantomJS = UA && /phantomjs/.test(UA);
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
   // @ts-ignore
@@ -481,7 +481,7 @@
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function get() {
+              get: function () {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
@@ -527,44 +527,45 @@
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
+      _Set = /** @class */ (function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function has (key) {
+          Set.prototype.has = function (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function add (key) {
+          Set.prototype.add = function (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function clear () {
+          Set.prototype.clear = function () {
               this.set = Object.create(null);
           };
-
           return Set;
       }());
   }
 
   /* @flow */
-  var warn = noop;
+  var warn$2 = noop;
   var tip = noop;
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-      warn = function (msg, vm) {
+      var hasConsole_1 = typeof console !== 'undefined';
+      var classifyRE_1 = /(?:^|[-_])(\w)/g;
+      var classify_1 = function (str) {
+          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+      };
+      warn$2 = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
           if (config.warnHandler) {
               config.warnHandler.call(null, msg, vm, trace);
           }
-          else if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
+          else if (hasConsole_1 && !config.silent) {
+              console.error("[Vue warn]: " + msg + trace);
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole && !config.silent) {
+          if (hasConsole_1 && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -587,10 +588,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
+          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+              (file && includeFile !== false ? " at " + file : ''));
       };
-      var repeat = function (str, n) {
+      var repeat_1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -624,50 +625,55 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
+                      .map(function (vm, i) {
+                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                          : formatComponentName(vm));
+                  })
                       .join('\n'));
           }
           else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+              return "\n\n(found in " + formatComponentName(vm) + ")";
           }
       };
   }
 
-  var uid = 0;
+  var uid$2 = 0;
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep() {
-      this.id = uid++;
-      this.subs = [];
-  };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
-  };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove(this.subs, sub);
-  };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
-      }
-  };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      if (!config.async) {
-          // subs aren't sorted in scheduler if not running async
-          // we need to sort them now to make sure they fire in correct
-          // order
-          subs.sort(function (a, b) { return a.id - b.id; });
-      }
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
+  var Dep = /** @class */ (function () {
+      function Dep() {
+          this.id = uid$2++;
+          this.subs = [];
       }
-  };
+      Dep.prototype.addSub = function (sub) {
+          this.subs.push(sub);
+      };
+      Dep.prototype.removeSub = function (sub) {
+          remove$2(this.subs, sub);
+      };
+      Dep.prototype.depend = function () {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      };
+      Dep.prototype.notify = function () {
+          // stabilize the subscriber list first
+          var subs = this.subs.slice();
+          if (!config.async) {
+              // subs aren't sorted in scheduler if not running async
+              // we need to sort them now to make sure they fire in correct
+              // order
+              subs.sort(function (a, b) { return a.id - b.id; });
+          }
+          for (var i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      };
+      return Dep;
+  }());
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
@@ -682,43 +688,45 @@
       Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-      return this.componentInstance;
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
+  var VNode = /** @class */ (function () {
+      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      Object.defineProperty(VNode.prototype, "child", {
+          // DEPRECATED: alias for componentInstance for backwards compat.
+          /* istanbul ignore next */
+          get: function () {
+              return this.componentInstance;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return VNode;
+  }());
   var createEmptyVNode = function (text) {
-      if ( text === void 0 ) text = '';
-
+      if (text === void 0) { text = ''; }
       var node = new VNode();
       node.text = text;
       node.isComment = true;
@@ -772,9 +780,12 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
+          var arguments$1 = arguments;
 
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments$1[_i];
+          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -810,43 +821,46 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
+  var Observer = /** @class */ (function () {
+      function Observer(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
           }
           else {
-              copyAugment(value, arrayMethods, arrayKeys);
+              this.walk(value);
           }
-          this.observeArray(value);
-      }
-      else {
-          this.walk(value);
       }
-  };
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive$$1(obj, keys[i]);
-      }
-  };
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
-      }
-  };
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      Observer.prototype.walk = function (obj) {
+          var keys = Object.keys(obj);
+          for (var i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      };
+      /**
+       * Observe a list of Array items.
+       */
+      Observer.prototype.observeArray = function (items) {
+          for (var i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      };
+      return Observer;
+  }());
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -896,7 +910,7 @@
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+  function defineReactive(obj, key, val, customSetter, shallow) {
       var dep = new Dep();
       var property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
@@ -955,8 +969,8 @@
    * already exist.
    */
   function set(target, key, val) {
-      if (isUndef(target) || isPrimitive(target)) {
-          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -970,7 +984,7 @@
       var ob = target.__ob__;
       // @ts-ignore
       if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                   'at runtime - declare it upfront in the data option.');
           return val;
       }
@@ -978,7 +992,7 @@
           target[key] = val;
           return val;
       }
-      defineReactive$$1(ob.value, key, val);
+      defineReactive(ob.value, key, val);
       ob.dep.notify();
       return val;
   }
@@ -986,8 +1000,8 @@
    * Delete a property and trigger change if necessary.
    */
   function del(target, key) {
-      if (isUndef(target) || isPrimitive(target)) {
-          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.splice(key, 1);
@@ -996,7 +1010,7 @@
       var ob = target.__ob__;
       //@ts-ignore
       if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid deleting properties on a Vue instance or its root $data ' +
+          warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                   '- just set it to null.');
           return;
       }
@@ -1014,7 +1028,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1036,7 +1050,7 @@
   {
       strats.el = strats.propsData = function (parent, child, vm, key) {
           if (!vm) {
-              warn("option \"" + key + "\" can only be used during instance " +
+              warn$2("option \"" + key + "\" can only be used during instance " +
                   'creation with the `new` keyword.');
           }
           return defaultStrat(parent, child);
@@ -1112,7 +1126,7 @@
   strats.data = function (parentVal, childVal, vm) {
       if (!vm) {
           if (childVal && typeof childVal !== 'function') {
-              warn('The "data" option should be a function ' +
+              warn$2('The "data" option should be a function ' +
                       'that returns a per-instance value in component ' +
                       'definitions.', vm);
               return parentVal;
@@ -1124,7 +1138,7 @@
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook(parentVal, childVal) {
+  function mergeHook$1(parentVal, childVal) {
       var res = childVal
           ? parentVal
               ? parentVal.concat(childVal)
@@ -1144,7 +1158,7 @@
       return res;
   }
   LIFECYCLE_HOOKS.forEach(function (hook) {
-      strats[hook] = mergeHook;
+      strats[hook] = mergeHook$1;
   });
   /**
    * Assets
@@ -1190,14 +1204,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key$1] = parent
-              ? parent.concat(child)
+      for (var key_1 in childVal) {
+          var parent_1 = ret[key_1];
+          var child = childVal[key_1];
+          if (parent_1 && !Array.isArray(parent_1)) {
+              parent_1 = [parent_1];
+          }
+          ret[key_1] = parent_1
+              ? parent_1.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1235,14 +1249,14 @@
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-          warn('Invalid component name: "' +
+      if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+          warn$2('Invalid component name: "' +
               name +
               '". Component names ' +
               'should conform to valid custom element name in html5 specification.');
       }
       if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn('Do not use built-in or reserved HTML elements as component ' +
+          warn$2('Do not use built-in or reserved HTML elements as component ' +
               'id: ' +
               name);
       }
@@ -1266,7 +1280,7 @@
                   res[name] = { type: null };
               }
               else {
-                  warn('props must be strings when using array syntax.');
+                  warn$2('props must be strings when using array syntax.');
               }
           }
       }
@@ -1278,8 +1292,8 @@
           }
       }
       else {
-          warn("Invalid value for option \"props\": expected an Array or an Object, " +
-              "but got " + (toRawType(props)) + ".", vm);
+          warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
+              ("but got " + toRawType(props) + "."), vm);
       }
       options.props = res;
   }
@@ -1305,28 +1319,28 @@
           }
       }
       else {
-          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-              "but got " + (toRawType(inject)) + ".", vm);
+          warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
+              ("but got " + toRawType(inject) + "."), vm);
       }
   }
   /**
    * Normalize raw function directives into object format.
    */
-  function normalizeDirectives(options) {
+  function normalizeDirectives$1(options) {
       var dirs = options.directives;
       if (dirs) {
           for (var key in dirs) {
-              var def$$1 = dirs[key];
-              if (typeof def$$1 === 'function') {
-                  dirs[key] = { bind: def$$1, update: def$$1 };
+              var def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
               }
           }
       }
   }
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
-          warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
+          warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+              ("but got " + toRawType(value) + "."), vm);
       }
   }
   /**
@@ -1343,7 +1357,7 @@
       }
       normalizeProps(child, vm);
       normalizeInject(child, vm);
-      normalizeDirectives(child);
+      normalizeDirectives$1(child);
       // Apply extends and mixins on the child options,
       // but only if it is a raw options object that isn't
       // the result of another mergeOptions call.
@@ -1397,7 +1411,7 @@
       // fallback to prototype chain
       var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
       if (warnMissing && !res) {
-          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
       }
       return res;
   }
@@ -1448,7 +1462,7 @@
       var def = prop.default;
       // warn against non-factory defaults for Object & Array
       if (isObject(def)) {
-          warn('Invalid default value for prop "' +
+          warn$2('Invalid default value for prop "' +
               key +
               '": ' +
               'Props with type Object/Array must use a factory function ' +
@@ -1473,7 +1487,7 @@
    */
   function assertProp(prop, name, value, vm, absent) {
       if (prop.required && absent) {
-          warn('Missing required prop: "' + name + '"', vm);
+          warn$2('Missing required prop: "' + name + '"', vm);
           return;
       }
       if (value == null && !prop.required) {
@@ -1495,13 +1509,13 @@
       }
       var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
       if (!valid && haveExpectedTypes) {
-          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
           return;
       }
       var validator = prop.validator;
       if (validator) {
           if (!validator(value)) {
-              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
           }
       }
   }
@@ -1528,7 +1542,7 @@
               valid = value instanceof type;
           }
           catch (e) {
-              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
               valid = false;
           }
       }
@@ -1563,7 +1577,7 @@
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
       var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          " Expected " + (expectedTypes.map(capitalize).join(', '));
+          (" Expected " + expectedTypes.map(capitalize).join(', '));
       var expectedType = expectedTypes[0];
       var receivedType = toRawType(value);
       // check if we need to specify expected value
@@ -1571,24 +1585,24 @@
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + (styleValue(value, expectedType));
+          message += " with value " + styleValue(value, expectedType);
       }
       message += ", got " + receivedType + " ";
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + (styleValue(value, receivedType)) + ".";
+          message += "with value " + styleValue(value, receivedType) + ".";
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return ("\"" + value + "\"");
+          return "\"" + value + "\"";
       }
       else if (type === 'Number') {
-          return ("" + (Number(value)));
+          return "" + Number(value);
       }
       else {
-          return ("" + value);
+          return "" + value;
       }
   }
   var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1596,9 +1610,12 @@
       return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
+      var arguments$1 = arguments;
 
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments$1[_i];
+      }
       return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
@@ -1664,7 +1681,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+          warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1707,9 +1724,9 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p = Promise.resolve();
+      var p_1 = Promise.resolve();
       timerFunc = function () {
-          p.then(flushCallbacks);
+          p_1.then(flushCallbacks);
           // In problematic UIWebViews, Promise.then doesn't completely break, but
           // it can get stuck in a weird state where callbacks are pushed into the
           // microtask queue but the queue isn't being flushed, until the browser
@@ -1728,15 +1745,15 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
+      var counter_1 = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
+      var textNode_1 = document.createTextNode(String(counter_1));
+      observer.observe(textNode_1, {
           characterData: true,
       });
       timerFunc = function () {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
+          counter_1 = (counter_1 + 1) % 2;
+          textNode_1.data = String(counter_1);
       };
       isUsingMicroTask = true;
   }
@@ -1781,23 +1798,21 @@
       }
   }
 
-  /* @flow */
-
   var mark;
   var measure;
   {
-      var perf = inBrowser && window.performance;
+      var perf_1 = inBrowser && window.performance;
       /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = function (tag) { return perf.mark(tag); };
+      if (perf_1 &&
+          perf_1.mark &&
+          perf_1.measure &&
+          perf_1.clearMarks &&
+          perf_1.clearMeasures) {
+          mark = function (tag) { return perf_1.mark(tag); };
           measure = function (name, startTag, endTag) {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
+              perf_1.measure(name, startTag, endTag);
+              perf_1.clearMarks(startTag);
+              perf_1.clearMarks(endTag);
               // perf.clearMeasures(name)
           };
       }
@@ -1806,31 +1821,31 @@
   /* not type checking this file because flow doesn't play well with Proxy */
   var initProxy;
   {
-      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var warnNonPresent = function (target, key) {
-          warn("Property or method \"" + key + "\" is not defined on the instance but " +
+      var warnNonPresent_1 = function (target, key) {
+          warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
               'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
-      var warnReservedPrefix = function (target, key) {
-          warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+      var warnReservedPrefix_1 = function (target, key) {
+          warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
               'See: https://vuejs.org/v2/api/#data', target);
       };
-      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+      var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy_1) {
+          var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+              set: function (target, key, value) {
+                  if (isBuiltInModifier_1(key)) {
+                      warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                       return false;
                   }
                   else {
@@ -1840,38 +1855,38 @@
               },
           });
       }
-      var hasHandler = {
-          has: function has(target, key) {
+      var hasHandler_1 = {
+          has: function (target, key) {
               var has = key in target;
-              var isAllowed = allowedGlobals(key) ||
+              var isAllowed = allowedGlobals_1(key) ||
                   (typeof key === 'string' &&
                       key.charAt(0) === '_' &&
                       !(key in target.$data));
               if (!has && !isAllowed) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      { warnReservedPrefix_1(target, key); }
                   else
-                      { warnNonPresent(target, key); }
+                      { warnNonPresent_1(target, key); }
               }
               return has || !isAllowed;
           },
       };
-      var getHandler = {
-          get: function get(target, key) {
+      var getHandler_1 = {
+          get: function (target, key) {
               if (typeof key === 'string' && !(key in target)) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      { warnReservedPrefix_1(target, key); }
                   else
-                      { warnNonPresent(target, key); }
+                      { warnNonPresent_1(target, key); }
               }
               return target[key];
           },
       };
       initProxy = function initProxy(vm) {
-          if (hasProxy) {
+          if (hasProxy_1) {
               // determine which proxy handler to use
               var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
               vm._renderProxy = new Proxy(vm, handlers);
           }
           else {
@@ -1922,13 +1937,13 @@
   var normalizeEvent = cached(function (name) {
       var passive = name.charAt(0) === '&';
       name = passive ? name.slice(1) : name;
-      var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once$$1 ? name.slice(1) : name;
+      var once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
       var capture = name.charAt(0) === '!';
       name = capture ? name.slice(1) : name;
       return {
           name: name,
-          once: once$$1,
+          once: once,
           capture: capture,
           passive: passive,
       };
@@ -1952,14 +1967,14 @@
       invoker.fns = fns;
       return invoker;
   }
-  function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-      var name, def$$1, cur, old, event;
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      var name, cur, old, event;
       for (name in on) {
-          def$$1 = cur = on[name];
+          cur = on[name];
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+              warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -1978,7 +1993,7 @@
       for (name in oldOn) {
           if (isUndef(on[name])) {
               event = normalizeEvent(name);
-              remove$$1(event.name, oldOn[name], event.capture);
+              remove(event.name, oldOn[name], event.capture);
           }
       }
   }
@@ -1994,7 +2009,7 @@
           hook.apply(this, arguments);
           // important: remove merged hook to ensure it's called only once
           // and prevent memory leak
-          remove(invoker.fns, wrappedHook);
+          remove$2(invoker.fns, wrappedHook);
       }
       if (isUndef(oldHook)) {
           // no existing hook
@@ -2026,8 +2041,7 @@
           return;
       }
       var res = {};
-      var attrs = data.attrs;
-      var props = data.props;
+      var attrs = data.attrs, props = data.props;
       if (isDef(attrs) || isDef(props)) {
           for (var key in propOptions) {
               var altKey = hyphenate(key);
@@ -2037,11 +2051,11 @@
                       tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                           (formatComponentName(
                           // @ts-ignore
-                          tag || Ctor)) + ", but the declared prop name is" +
-                          " \"" + key + "\". " +
+                          tag || Ctor) + ", but the declared prop name is") +
+                          (" \"" + key + "\". ") +
                           "Note that HTML attributes are case-insensitive and camelCased " +
                           "props need to use their kebab-case equivalents when using in-DOM " +
-                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                          ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -2116,7 +2130,7 @@
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2175,10 +2189,10 @@
           Object.keys(result).forEach(function (key) {
               /* istanbul ignore else */
               {
-                  defineReactive$$1(vm, key, result[key], function () {
-                      warn("Avoid mutating an injected value directly since the changes will be " +
+                  defineReactive(vm, key, result[key], function () {
+                      warn$2("Avoid mutating an injected value directly since the changes will be " +
                           "overwritten whenever the provided component re-renders. " +
-                          "injection being mutated: \"" + key + "\"", vm);
+                          ("injection being mutated: \"" + key + "\""), vm);
                   });
               }
           });
@@ -2215,7 +2229,7 @@
                   }
                   else {
                       // @ts-ignore
-                      warn(("Injection \"" + key + "\" not found"), vm);
+                      warn$2("Injection \"" + key + "\" not found", vm);
                   }
               }
           }
@@ -2244,8 +2258,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name = data.slot;
-              var slot = slots[name] || (slots[name] = []);
+              var name_1 = data.slot;
+              var slot = slots[name_1] || (slots[name_1] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -2258,9 +2272,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name$1 in slots) {
-          if (slots[name$1].every(isWhitespace)) {
-              delete slots[name$1];
+      for (var name_2 in slots) {
+          if (slots[name_2].every(isWhitespace)) {
+              delete slots[name_2];
           }
       }
       return slots;
@@ -2294,16 +2308,16 @@
       }
       else {
           res = {};
-          for (var key$1 in slots) {
-              if (slots[key$1] && key$1[0] !== '$') {
-                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+          for (var key_1 in slots) {
+              if (slots[key_1] && key_1[0] !== '$') {
+                  res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key$2 in normalSlots) {
-          if (!(key$2 in res)) {
-              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+      for (var key_2 in normalSlots) {
+          if (!(key_2 in res)) {
+              res[key_2] = proxyNormalSlot(normalSlots, key_2);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2397,7 +2411,7 @@
           props = props || {};
           if (bindObject) {
               if (!isObject(bindObject)) {
-                  warn('slot v-bind without argument expects an Object', this);
+                  warn$2('slot v-bind without argument expects an Object', this);
               }
               props = extend(extend({}, bindObject), props);
           }
@@ -2456,14 +2470,14 @@
   function bindObjectProps(data, tag, value, asProp, isSync) {
       if (value) {
           if (!isObject(value)) {
-              warn('v-bind without argument expects an Object or Array value', this);
+              warn$2('v-bind without argument expects an Object or Array value', this);
           }
           else {
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash;
-              var loop = function ( key ) {
+              var hash = void 0;
+              var _loop_1 = function (key) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
@@ -2480,14 +2494,15 @@
                       hash[key] = value[key];
                       if (isSync) {
                           var on = data.on || (data.on = {});
-                          on[("update:" + key)] = function ($event) {
+                          on["update:" + key] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
               };
-
-              for (var key in value) loop( key );
+              for (var key in value) {
+                  _loop_1(key);
+              }
           }
       }
       return data;
@@ -2507,7 +2522,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic(tree, ("__static__" + index), false);
+      markStatic$1(tree, "__static__" + index, false);
       return tree;
   }
   /**
@@ -2515,14 +2530,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
       return tree;
   }
-  function markStatic(tree, key, isOnce) {
+  function markStatic$1(tree, key, isOnce) {
       if (Array.isArray(tree)) {
           for (var i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+                  markStaticNode(tree[i], key + "_" + i, isOnce);
               }
           }
       }
@@ -2540,7 +2555,7 @@
   function bindObjectListeners(data, value) {
       if (value) {
           if (!isPlainObject(value)) {
-              warn('v-on without argument expects an Object value', this);
+              warn$2('v-on without argument expects an Object value', this);
           }
           else {
               var on = (data.on = data.on ? extend({}, data.on) : {});
@@ -2589,7 +2604,7 @@
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+              warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
           }
       }
       return baseObj;
@@ -2624,8 +2639,7 @@
 
   /* @flow */
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var this$1 = this;
-
+      var _this = this;
       var options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
@@ -2652,14 +2666,14 @@
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
       this.slots = function () {
-          if (!this$1.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          if (!_this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
           }
-          return this$1.$slots;
+          return _this.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function get() {
+          get: function () {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -2673,7 +2687,7 @@
       }
       if (options._scopeId) {
           this._c = function (a, b, c, d) {
-              var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
               if (vnode && !Array.isArray(vnode)) {
                   vnode.fnScopeId = options._scopeId;
                   vnode.fnContext = parent;
@@ -2682,7 +2696,9 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+          this._c = function (a, b, c, d) {
+              return createElement$1(contextVm, a, b, c, d, needNormalization);
+          };
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2736,14 +2752,10 @@
       }
   }
 
-  /* @flow */
-
-  /* @flow */
-
   /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function init(vnode, hydrating) {
+      init: function (vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
@@ -2756,7 +2768,7 @@
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function prepatch(oldVnode, vnode) {
+      prepatch: function (oldVnode, vnode) {
           var options = vnode.componentOptions;
           var child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
@@ -2765,12 +2777,11 @@
           options.children // new children
           );
       },
-      insert: function insert(vnode) {
-          var context = vnode.context;
-          var componentInstance = vnode.componentInstance;
+      insert: function (vnode) {
+          var context = vnode.context, componentInstance = vnode.componentInstance;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
-              callHook(componentInstance, 'mounted');
+              callHook$1(componentInstance, 'mounted');
           }
           if (vnode.data.keepAlive) {
               if (context._isMounted) {
@@ -2786,7 +2797,7 @@
               }
           }
       },
-      destroy: function destroy(vnode) {
+      destroy: function (vnode) {
           var componentInstance = vnode.componentInstance;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
@@ -2812,7 +2823,7 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn(("Invalid Component definition: " + (String(Ctor))), context);
+              warn$2("Invalid Component definition: " + String(Ctor), context);
           }
           return;
       }
@@ -2870,7 +2881,7 @@
       var name = Ctor.options.name || tag;
       var vnode = new VNode(
       // @ts-expect-error
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
       // @ts-expect-error
       { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
       return vnode;
@@ -2901,11 +2912,11 @@
           var toMerge = componentVNodeHooks[key];
           // @ts-expect-error
           if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
           }
       }
   }
-  function mergeHook$1(f1, f2) {
+  function mergeHook(f1, f2) {
       var merged = function (a, b) {
           // flow complains about extra args which is why we use any
           f1(a, b);
@@ -2940,7 +2951,7 @@
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
       if (Array.isArray(data) || isPrimitive(data)) {
           normalizationType = children;
           children = data;
@@ -2953,7 +2964,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -2970,7 +2981,7 @@
           !isPrimitive(data.key)) {
           // @ts-expect-error
           {
-              warn('Avoid using non-primitive value as key, ' +
+              warn$2('Avoid using non-primitive value as key, ' +
                   'use string/number value instead.', context);
           }
       }
@@ -2988,14 +2999,14 @@
       }
       var vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor;
+          var Ctor = void 0;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if (config.isReservedTag(tag)) {
               // platform built-in elements
               if (isDef(data) &&
                   isDef(data.nativeOn) &&
                   data.tag !== 'component') {
-                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                  warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
               }
               vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
           }
@@ -3072,21 +3083,21 @@
       // args order: tag, data, children, normalizationType, alwaysNormalize
       // internal version is used by render functions compiled from templates
       // @ts-expect-error
-      vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+      vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
       // normalization is always applied for the public version, used in
       // user-written render functions.
       // @ts-expect-error
-      vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+      vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
       // $attrs & $listeners are exposed for easier HOC creation.
       // they need to be reactive so that HOCs using them are always updated
       var parentData = parentVnode && parentVnode.data;
       /* istanbul ignore else */
       {
-          defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-              !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+              !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
           }, true);
-          defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-              !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
+              !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
           }, true);
       }
   }
@@ -3099,9 +3110,7 @@
       };
       Vue.prototype._render = function () {
           var vm = this;
-          var ref = vm.$options;
-          var render = ref.render;
-          var _parentVnode = ref._parentVnode;
+          var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
           if (_parentVnode) {
               vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
@@ -3126,8 +3135,8 @@
                   try {
                       vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                   }
-                  catch (e) {
-                      handleError(e, vm, "renderError");
+                  catch (e$1) {
+                      handleError(e$1, vm, "renderError");
                       vnode = vm._vnode;
                   }
               }
@@ -3145,7 +3154,7 @@
           // return empty vnode in case the render function errored out
           if (!(vnode instanceof VNode)) {
               if (Array.isArray(vnode)) {
-                  warn('Multiple root nodes returned from render function. Render function ' +
+                  warn$2('Multiple root nodes returned from render function. Render function ' +
                       'should return a single root node.', vm);
               }
               vnode = createEmptyVNode();
@@ -3185,24 +3194,24 @@
           return factory.loadingComp;
       }
       if (owner && !isDef(factory.owners)) {
-          var owners = (factory.owners = [owner]);
-          var sync = true;
-          var timerLoading = null;
-          var timerTimeout = null;
-          owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-          var forceRender = function (renderCompleted) {
-              for (var i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
+          var owners_1 = (factory.owners = [owner]);
+          var sync_1 = true;
+          var timerLoading_1 = null;
+          var timerTimeout_1 = null;
+          owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+          var forceRender_1 = function (renderCompleted) {
+              for (var i = 0, l = owners_1.length; i < l; i++) {
+                  owners_1[i].$forceUpdate();
               }
               if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
+                  owners_1.length = 0;
+                  if (timerLoading_1 !== null) {
+                      clearTimeout(timerLoading_1);
+                      timerLoading_1 = null;
                   }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
+                  if (timerTimeout_1 !== null) {
+                      clearTimeout(timerTimeout_1);
+                      timerTimeout_1 = null;
                   }
               }
           };
@@ -3211,62 +3220,63 @@
               factory.resolved = ensureCtor(res, baseCtor);
               // invoke callbacks only if this is not a synchronous resolve
               // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
+              if (!sync_1) {
+                  forceRender_1(true);
               }
               else {
-                  owners.length = 0;
+                  owners_1.length = 0;
               }
           });
-          var reject = once(function (reason) {
-              warn("Failed to resolve async component: " + (String(factory)) +
-                      (reason ? ("\nReason: " + reason) : ''));
+          var reject_1 = once(function (reason) {
+              warn$2("Failed to resolve async component: " + String(factory) +
+                      (reason ? "\nReason: " + reason : ''));
               if (isDef(factory.errorComp)) {
                   factory.error = true;
-                  forceRender(true);
+                  forceRender_1(true);
               }
           });
-          var res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
+          var res_1 = factory(resolve, reject_1);
+          if (isObject(res_1)) {
+              if (isPromise(res_1)) {
                   // () => Promise
                   if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
+                      res_1.then(resolve, reject_1);
                   }
               }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
+              else if (isPromise(res_1.component)) {
+                  res_1.component.then(resolve, reject_1);
+                  if (isDef(res_1.error)) {
+                      factory.errorComp = ensureCtor(res_1.error, baseCtor);
                   }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
+                  if (isDef(res_1.loading)) {
+                      factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                      if (res_1.delay === 0) {
                           factory.loading = true;
                       }
                       else {
                           // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(function () {
-                              timerLoading = null;
+                          timerLoading_1 = setTimeout(function () {
+                              timerLoading_1 = null;
                               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                   factory.loading = true;
-                                  forceRender(false);
+                                  forceRender_1(false);
                               }
-                          }, res.delay || 200);
+                          }, res_1.delay || 200);
                       }
                   }
-                  if (isDef(res.timeout)) {
+                  if (isDef(res_1.timeout)) {
                       // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(function () {
-                          timerTimeout = null;
+                      timerTimeout_1 = setTimeout(function () {
+                          timerTimeout_1 = null;
                           if (isUndef(factory.resolved)) {
-                              reject("timeout (" + (res.timeout) + "ms)");
+                              reject_1("timeout (" + res_1.timeout + "ms)"
+                                  );
                           }
-                      }, res.timeout);
+                      }, res_1.timeout);
                   }
               }
           }
-          sync = false;
+          sync_1 = false;
           // return in case resolved synchronously
           return factory.loading ? factory.loadingComp : factory.resolved;
       }
@@ -3290,8 +3300,6 @@
       }
   }
 
-  /* @flow */
-
   /* @flow */
   function initEvents(vm) {
       vm._events = Object.create(null);
@@ -3302,15 +3310,15 @@
           updateComponentListeners(vm, listeners);
       }
   }
-  var target;
-  function add(event, fn) {
-      target.$on(event, fn);
+  var target$1;
+  function add$1(event, fn) {
+      target$1.$on(event, fn);
   }
   function remove$1(event, fn) {
-      target.$off(event, fn);
+      target$1.$off(event, fn);
   }
-  function createOnceHandler(event, fn) {
-      var _target = target;
+  function createOnceHandler$1(event, fn) {
+      var _target = target$1;
       return function onceHandler() {
           var res = fn.apply(null, arguments);
           if (res !== null) {
@@ -3319,9 +3327,9 @@
       };
   }
   function updateComponentListeners(vm, listeners, oldListeners) {
-      target = vm;
-      updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-      target = undefined;
+      target$1 = vm;
+      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+      target$1 = undefined;
   }
   function eventsMixin(Vue) {
       var hookRE = /^hook:/;
@@ -3361,8 +3369,8 @@
           }
           // array of events
           if (Array.isArray(event)) {
-              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                  vm.$off(event[i$1], fn);
+              for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                  vm.$off(event[i_1], fn);
               }
               return vm;
           }
@@ -3393,10 +3401,10 @@
               var lowerCaseEvent = event.toLowerCase();
               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                   tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                      (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
                       "Note that HTML attributes are case-insensitive and you cannot use " +
                       "v-on to listen to camelCase events when using in-DOM templates. " +
-                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                      ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
               }
           }
           var cbs = vm._events[event];
@@ -3487,13 +3495,13 @@
           if (vm._isBeingDestroyed) {
               return;
           }
-          callHook(vm, 'beforeDestroy');
+          callHook$1(vm, 'beforeDestroy');
           vm._isBeingDestroyed = true;
           // remove self from parent
           var parent = vm.$parent;
           // @ts-ignore
           if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove(parent.$children, vm);
+              remove$2(parent.$children, vm);
           }
           // teardown watchers
           if (vm._watcher) {
@@ -3513,7 +3521,7 @@
           // invoke destroy hooks on current rendered tree
           vm.__patch__(vm._vnode, null);
           // fire destroyed hook
-          callHook(vm, 'destroyed');
+          callHook$1(vm, 'destroyed');
           // turn off all instance listeners.
           vm.$off();
           // remove __vue__ reference
@@ -3537,16 +3545,16 @@
               if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
                   vm.$options.el ||
                   el) {
-                  warn('You are using the runtime-only build of Vue where the template ' +
+                  warn$2('You are using the runtime-only build of Vue where the template ' +
                       'compiler is not available. Either pre-compile the templates into ' +
                       'render functions, or use the compiler-included build.', vm);
               }
               else {
-                  warn('Failed to mount component: template or render function not defined.', vm);
+                  warn$2('Failed to mount component: template or render function not defined.', vm);
               }
           }
       }
-      callHook(vm, 'beforeMount');
+      callHook$1(vm, 'beforeMount');
       var updateComponent;
       /* istanbul ignore if */
       if (config.performance && mark) {
@@ -3558,11 +3566,11 @@
               mark(startTag);
               var vnode = vm._render();
               mark(endTag);
-              measure(("vue " + name + " render"), startTag, endTag);
+              measure("vue " + name + " render", startTag, endTag);
               mark(startTag);
               vm._update(vnode, hydrating);
               mark(endTag);
-              measure(("vue " + name + " patch"), startTag, endTag);
+              measure("vue " + name + " patch", startTag, endTag);
           };
       }
       else {
@@ -3574,9 +3582,9 @@
       // since the watcher's initial patch may call $forceUpdate (e.g. inside child
       // component's mounted hook), which relies on vm._watcher being already defined
       new Watcher(vm, updateComponent, noop, {
-          before: function before() {
+          before: function () {
               if (vm._isMounted && !vm._isDestroyed) {
-                  callHook(vm, 'beforeUpdate');
+                  callHook$1(vm, 'beforeUpdate');
               }
           },
       }, true /* isRenderWatcher */);
@@ -3585,7 +3593,7 @@
       // mounted is called for render-created child components in its inserted hook
       if (vm.$vnode == null) {
           vm._isMounted = true;
-          callHook(vm, 'mounted');
+          callHook$1(vm, 'mounted');
       }
       return vm;
   }
@@ -3675,7 +3683,7 @@
           for (var i = 0; i < vm.$children.length; i++) {
               activateChildComponent(vm.$children[i]);
           }
-          callHook(vm, 'activated');
+          callHook$1(vm, 'activated');
       }
   }
   function deactivateChildComponent(vm, direct) {
@@ -3690,10 +3698,10 @@
           for (var i = 0; i < vm.$children.length; i++) {
               deactivateChildComponent(vm.$children[i]);
           }
-          callHook(vm, 'deactivated');
+          callHook$1(vm, 'deactivated');
       }
   }
-  function callHook(vm, hook) {
+  function callHook$1(vm, hook) {
       // #7573 disable dep collection when invoking lifecycle hooks
       pushTarget();
       var handlers = vm.$options[hook];
@@ -3717,12 +3725,12 @@
   var circular = {};
   var waiting = false;
   var flushing = false;
-  var index = 0;
+  var index$1 = 0;
   /**
    * Reset the scheduler's state.
    */
   function resetSchedulerState() {
-      index = queue.length = activatedChildren.length = 0;
+      index$1 = queue.length = activatedChildren.length = 0;
       has = {};
       {
           circular = {};
@@ -3744,15 +3752,15 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
+      var performance_1 = window.performance;
+      if (performance_1 &&
+          typeof performance_1.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
           // if the event timestamp, although evaluated AFTER the Date.now(), is
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance.now(); };
+          getNow = function () { return performance_1.now(); };
       }
   }
   /**
@@ -3773,8 +3781,8 @@
       queue.sort(function (a, b) { return a.id - b.id; });
       // do not cache length because more watchers might be pushed
       // as we run existing watchers
-      for (index = 0; index < queue.length; index++) {
-          watcher = queue[index];
+      for (index$1 = 0; index$1 < queue.length; index$1++) {
+          watcher = queue[index$1];
           if (watcher.before) {
               watcher.before();
           }
@@ -3785,9 +3793,9 @@
           if (has[id] != null) {
               circular[id] = (circular[id] || 0) + 1;
               if (circular[id] > MAX_UPDATE_COUNT) {
-                  warn('You may have an infinite update loop ' +
+                  warn$2('You may have an infinite update loop ' +
                       (watcher.user
-                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                          ? "in watcher with expression \"" + watcher.expression + "\""
                           : "in a component render function."), watcher.vm);
                   break;
               }
@@ -3812,7 +3820,7 @@
           var watcher = queue[i];
           var vm = watcher.vm;
           if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook(vm, 'updated');
+              callHook$1(vm, 'updated');
           }
       }
   }
@@ -3848,7 +3856,7 @@
               // if already flushing, splice the watcher based on its id
               // if already past its id, it will be run next immediately.
               var i = queue.length - 1;
-              while (i > index && queue[i].id > watcher.id) {
+              while (i > index$1 && queue[i].id > watcher.id) {
                   i--;
               }
               queue.splice(i + 1, 0, watcher);
@@ -3866,197 +3874,200 @@
   }
 
   /* @flow */
-  var uid$2 = 0;
+  var uid$1 = 0;
   /**
    * A watcher parses an expression, collects dependencies,
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-      this.vm = vm;
-      if (isRenderWatcher) {
-          vm._watcher = this;
-      }
-      vm._watchers.push(this);
-      // options
-      if (options) {
-          this.deep = !!options.deep;
-          this.user = !!options.user;
-          this.lazy = !!options.lazy;
-          this.sync = !!options.sync;
-          this.before = options.before;
-      }
-      else {
-          this.deep = this.user = this.lazy = this.sync = false;
-      }
-      this.cb = cb;
-      this.id = ++uid$2; // uid for batching
-      this.active = true;
-      this.dirty = this.lazy; // for lazy watchers
-      this.deps = [];
-      this.newDeps = [];
-      this.depIds = new _Set();
-      this.newDepIds = new _Set();
-      this.expression =
-          expOrFn.toString();
-      // parse expression for getter
-      if (typeof expOrFn === 'function') {
-          this.getter = expOrFn;
-      }
-      else {
-          this.getter = parsePath(expOrFn);
-          if (!this.getter) {
-              this.getter = noop;
-              warn("Failed watching path: \"" + expOrFn + "\" " +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
-          }
-      }
-      this.value = this.lazy ? undefined : this.get();
-  };
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  Watcher.prototype.get = function get () {
-      pushTarget(this);
-      var value;
-      var vm = this.vm;
-      try {
-          value = this.getter.call(vm, vm);
-      }
-      catch (e) {
-          if (this.user) {
-              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+  var Watcher = /** @class */ (function () {
+      function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+          this.vm = vm;
+          if (isRenderWatcher) {
+              vm._watcher = this;
+          }
+          vm._watchers.push(this);
+          // options
+          if (options) {
+              this.deep = !!options.deep;
+              this.user = !!options.user;
+              this.lazy = !!options.lazy;
+              this.sync = !!options.sync;
+              this.before = options.before;
           }
           else {
-              throw e;
+              this.deep = this.user = this.lazy = this.sync = false;
+          }
+          this.cb = cb;
+          this.id = ++uid$1; // uid for batching
+          this.active = true;
+          this.dirty = this.lazy; // for lazy watchers
+          this.deps = [];
+          this.newDeps = [];
+          this.depIds = new _Set();
+          this.newDepIds = new _Set();
+          this.expression =
+              expOrFn.toString() ;
+          // parse expression for getter
+          if (typeof expOrFn === 'function') {
+              this.getter = expOrFn;
           }
-      }
-      finally {
-          // "touch" every property so they are all tracked as
-          // dependencies for deep watching
-          if (this.deep) {
-              traverse(value);
+          else {
+              this.getter = parsePath(expOrFn);
+              if (!this.getter) {
+                  this.getter = noop;
+                  warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                          'Watcher only accepts simple dot-delimited paths. ' +
+                          'For full control, use a function instead.', vm);
+              }
           }
-          popTarget();
-          this.cleanupDeps();
+          this.value = this.lazy ? undefined : this.get();
       }
-      return value;
-  };
-  /**
-   * Add a dependency to this directive.
-   */
-  Watcher.prototype.addDep = function addDep (dep) {
-      var id = dep.id;
-      if (!this.newDepIds.has(id)) {
-          this.newDepIds.add(id);
-          this.newDeps.push(dep);
-          if (!this.depIds.has(id)) {
-              dep.addSub(this);
+      /**
+       * Evaluate the getter, and re-collect dependencies.
+       */
+      Watcher.prototype.get = function () {
+          pushTarget(this);
+          var value;
+          var vm = this.vm;
+          try {
+              value = this.getter.call(vm, vm);
           }
-      }
-  };
-  /**
-   * Clean up for dependency collection.
-   */
-  Watcher.prototype.cleanupDeps = function cleanupDeps () {
-      var i = this.deps.length;
-      while (i--) {
-          var dep = this.deps[i];
-          if (!this.newDepIds.has(dep.id)) {
-              dep.removeSub(this);
-          }
-      }
-      var tmp = this.depIds;
-      this.depIds = this.newDepIds;
-      this.newDepIds = tmp;
-      this.newDepIds.clear();
-      tmp = this.deps;
-      this.deps = this.newDeps;
-      this.newDeps = tmp;
-      this.newDeps.length = 0;
-  };
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  Watcher.prototype.update = function update () {
-      /* istanbul ignore else */
-      if (this.lazy) {
-          this.dirty = true;
-      }
-      else if (this.sync) {
-          this.run();
-      }
-      else {
-          queueWatcher(this);
-      }
-  };
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  Watcher.prototype.run = function run () {
-      if (this.active) {
-          var value = this.get();
-          if (value !== this.value ||
-              // Deep watchers and watchers on Object/Arrays should fire even
-              // when the value is the same, because the value may
-              // have mutated.
-              isObject(value) ||
-              this.deep) {
-              // set new value
-              var oldValue = this.value;
-              this.value = value;
+          catch (e) {
               if (this.user) {
-                  try {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-                  catch (e) {
-                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                  }
+                  handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
               }
               else {
-                  this.cb.call(this.vm, value, oldValue);
+                  throw e;
               }
           }
-      }
-  };
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  Watcher.prototype.evaluate = function evaluate () {
-      this.value = this.get();
-      this.dirty = false;
-  };
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  Watcher.prototype.depend = function depend () {
-      var i = this.deps.length;
-      while (i--) {
-          this.deps[i].depend();
-      }
-  };
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  Watcher.prototype.teardown = function teardown () {
-      if (this.active) {
-          // remove self from vm's watcher list
-          // this is a somewhat expensive operation so we skip it
-          // if the vm is being destroyed.
-          if (!this.vm._isBeingDestroyed) {
-              remove(this.vm._watchers, this);
+          finally {
+              // "touch" every property so they are all tracked as
+              // dependencies for deep watching
+              if (this.deep) {
+                  traverse(value);
+              }
+              popTarget();
+              this.cleanupDeps();
+          }
+          return value;
+      };
+      /**
+       * Add a dependency to this directive.
+       */
+      Watcher.prototype.addDep = function (dep) {
+          var id = dep.id;
+          if (!this.newDepIds.has(id)) {
+              this.newDepIds.add(id);
+              this.newDeps.push(dep);
+              if (!this.depIds.has(id)) {
+                  dep.addSub(this);
+              }
           }
+      };
+      /**
+       * Clean up for dependency collection.
+       */
+      Watcher.prototype.cleanupDeps = function () {
           var i = this.deps.length;
           while (i--) {
-              this.deps[i].removeSub(this);
+              var dep = this.deps[i];
+              if (!this.newDepIds.has(dep.id)) {
+                  dep.removeSub(this);
+              }
+          }
+          var tmp = this.depIds;
+          this.depIds = this.newDepIds;
+          this.newDepIds = tmp;
+          this.newDepIds.clear();
+          tmp = this.deps;
+          this.deps = this.newDeps;
+          this.newDeps = tmp;
+          this.newDeps.length = 0;
+      };
+      /**
+       * Subscriber interface.
+       * Will be called when a dependency changes.
+       */
+      Watcher.prototype.update = function () {
+          /* istanbul ignore else */
+          if (this.lazy) {
+              this.dirty = true;
           }
-          this.active = false;
-      }
-  };
+          else if (this.sync) {
+              this.run();
+          }
+          else {
+              queueWatcher(this);
+          }
+      };
+      /**
+       * Scheduler job interface.
+       * Will be called by the scheduler.
+       */
+      Watcher.prototype.run = function () {
+          if (this.active) {
+              var value = this.get();
+              if (value !== this.value ||
+                  // Deep watchers and watchers on Object/Arrays should fire even
+                  // when the value is the same, because the value may
+                  // have mutated.
+                  isObject(value) ||
+                  this.deep) {
+                  // set new value
+                  var oldValue = this.value;
+                  this.value = value;
+                  if (this.user) {
+                      try {
+                          this.cb.call(this.vm, value, oldValue);
+                      }
+                      catch (e) {
+                          handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                      }
+                  }
+                  else {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+              }
+          }
+      };
+      /**
+       * Evaluate the value of the watcher.
+       * This only gets called for lazy watchers.
+       */
+      Watcher.prototype.evaluate = function () {
+          this.value = this.get();
+          this.dirty = false;
+      };
+      /**
+       * Depend on all deps collected by this watcher.
+       */
+      Watcher.prototype.depend = function () {
+          var i = this.deps.length;
+          while (i--) {
+              this.deps[i].depend();
+          }
+      };
+      /**
+       * Remove self from all dependencies' subscriber list.
+       */
+      Watcher.prototype.teardown = function () {
+          if (this.active) {
+              // remove self from vm's watcher list
+              // this is a somewhat expensive operation so we skip it
+              // if the vm is being destroyed.
+              if (!this.vm._isBeingDestroyed) {
+                  remove$2(this.vm._watchers, this);
+              }
+              var i = this.deps.length;
+              while (i--) {
+                  this.deps[i].removeSub(this);
+              }
+              this.active = false;
+          }
+      };
+      return Watcher;
+  }());
 
   /* @flow */
   var sharedPropertyDefinition = {
@@ -4078,7 +4089,7 @@
       vm._watchers = [];
       var opts = vm.$options;
       if (opts.props)
-          { initProps(vm, opts.props); }
+          { initProps$1(vm, opts.props); }
       if (opts.methods)
           { initMethods(vm, opts.methods); }
       if (opts.data) {
@@ -4088,12 +4099,12 @@
           observe((vm._data = {}), true /* asRootData */);
       }
       if (opts.computed)
-          { initComputed(vm, opts.computed); }
+          { initComputed$1(vm, opts.computed); }
       if (opts.watch && opts.watch !== nativeWatch) {
           initWatch(vm, opts.watch);
       }
   }
-  function initProps(vm, propsOptions) {
+  function initProps$1(vm, propsOptions) {
       var propsData = vm.$options.propsData || {};
       var props = (vm._props = {});
       // cache prop keys so that future props updates can iterate using Array
@@ -4104,7 +4115,7 @@
       if (!isRoot) {
           toggleObserving(false);
       }
-      var loop = function ( key ) {
+      var _loop_1 = function (key) {
           keys.push(key);
           var value = validateProp(key, propsOptions, propsData, vm);
           /* istanbul ignore else */
@@ -4112,14 +4123,14 @@
               var hyphenatedKey = hyphenate(key);
               if (isReservedAttribute(hyphenatedKey) ||
                   config.isReservedAttr(hyphenatedKey)) {
-                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                  warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
               }
-              defineReactive$$1(props, key, value, function () {
+              defineReactive(props, key, value, function () {
                   if (!isRoot && !isUpdatingChildComponent) {
-                      warn("Avoid mutating a prop directly since the value will be " +
+                      warn$2("Avoid mutating a prop directly since the value will be " +
                           "overwritten whenever the parent component re-renders. " +
                           "Instead, use a data or computed property based on the prop's " +
-                          "value. Prop being mutated: \"" + key + "\"", vm);
+                          ("value. Prop being mutated: \"" + key + "\""), vm);
                   }
               });
           }
@@ -4130,8 +4141,9 @@
               proxy(vm, "_props", key);
           }
       };
-
-      for (var key in propsOptions) loop( key );
+      for (var key in propsOptions) {
+          _loop_1(key);
+      }
       toggleObserving(true);
   }
   function initData(vm) {
@@ -4139,7 +4151,7 @@
       data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
       if (!isPlainObject(data)) {
           data = {};
-          warn('data functions should return an object:\n' +
+          warn$2('data functions should return an object:\n' +
                   'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
       }
       // proxy data on instance
@@ -4151,11 +4163,11 @@
           var key = keys[i];
           {
               if (methods && hasOwn(methods, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                  warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
               }
           }
           if (props && hasOwn(props, key)) {
-              warn("The data property \"" + key + "\" is already declared as a prop. " +
+              warn$2("The data property \"" + key + "\" is already declared as a prop. " +
                       "Use prop default value instead.", vm);
           }
           else if (!isReserved(key)) {
@@ -4180,7 +4192,7 @@
       }
   }
   var computedWatcherOptions = { lazy: true };
-  function initComputed(vm, computed) {
+  function initComputed$1(vm, computed) {
       // $flow-disable-line
       var watchers = (vm._computedWatchers = Object.create(null));
       // computed properties are just getters during SSR
@@ -4189,7 +4201,7 @@
           var userDef = computed[key];
           var getter = typeof userDef === 'function' ? userDef : userDef.get;
           if (getter == null) {
-              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+              warn$2("Getter is missing for computed property \"" + key + "\".", vm);
           }
           if (!isSSR) {
               // create internal watcher for the computed property.
@@ -4203,10 +4215,10 @@
           }
           else {
               if (key in vm.$data) {
-                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                  warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
               }
               else if (vm.$options.props && key in vm.$options.props) {
-                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                  warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
               }
           }
       }
@@ -4229,7 +4241,7 @@
       }
       if (sharedPropertyDefinition.set === noop) {
           sharedPropertyDefinition.set = function () {
-              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+              warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
           };
       }
       Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4258,18 +4270,18 @@
       for (var key in methods) {
           {
               if (typeof methods[key] !== 'function') {
-                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                  warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
                       "Did you reference the function correctly?", vm);
               }
               if (props && hasOwn(props, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                  warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
               }
               if (key in vm && isReserved(key)) {
-                  warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                  warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
                       "Avoid defining component methods that start with _ or $.");
               }
           }
-          vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+          vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
       }
   }
   function initWatch(vm, watch) {
@@ -4309,11 +4321,11 @@
       };
       {
           dataDef.set = function () {
-              warn('Avoid replacing instance root $data. ' +
+              warn$2('Avoid replacing instance root $data. ' +
                   'Use nested data properties instead.', this);
           };
           propsDef.set = function () {
-              warn("$props is readonly.", this);
+              warn$2("$props is readonly.", this);
           };
       }
       Object.defineProperty(Vue.prototype, '$data', dataDef);
@@ -4334,7 +4346,7 @@
                   cb.call(vm, watcher.value);
               }
               catch (error) {
-                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+                  handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
               }
               popTarget();
           }
@@ -4345,17 +4357,17 @@
   }
 
   /* @flow */
-  var uid$3 = 0;
-  function initMixin(Vue) {
+  var uid = 0;
+  function initMixin$1(Vue) {
       Vue.prototype._init = function (options) {
           var vm = this;
           // a uid
-          vm._uid = uid$3++;
+          vm._uid = uid++;
           var startTag, endTag;
           /* istanbul ignore if */
           if (config.performance && mark) {
-              startTag = "vue-perf-start:" + (vm._uid);
-              endTag = "vue-perf-end:" + (vm._uid);
+              startTag = "vue-perf-start:" + vm._uid;
+              endTag = "vue-perf-end:" + vm._uid;
               mark(startTag);
           }
           // a flag to avoid this being observed
@@ -4379,16 +4391,16 @@
           initLifecycle(vm);
           initEvents(vm);
           initRender(vm);
-          callHook(vm, 'beforeCreate');
+          callHook$1(vm, 'beforeCreate');
           initInjections(vm); // resolve injections before data/props
           initState(vm);
           initProvide(vm); // resolve provide after data/props
-          callHook(vm, 'created');
+          callHook$1(vm, 'created');
           /* istanbul ignore if */
           if (config.performance && mark) {
               vm._name = formatComponentName(vm, false);
               mark(endTag);
-              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+              measure("vue " + vm._name + " init", startTag, endTag);
           }
           if (vm.$options.el) {
               vm.$mount(vm.$options.el);
@@ -4451,12 +4463,12 @@
 
   function Vue(options) {
       if (!(this instanceof Vue)) {
-          warn('Vue is a constructor and should be called with the `new` keyword');
+          warn$2('Vue is a constructor and should be called with the `new` keyword');
       }
       this._init(options);
   }
   //@ts-ignore
-  initMixin(Vue);
+  initMixin$1(Vue);
   //@ts-ignore
   stateMixin(Vue);
   //@ts-ignore
@@ -4488,7 +4500,7 @@
   }
 
   /* @flow */
-  function initMixin$1(Vue) {
+  function initMixin(Vue) {
       Vue.mixin = function (mixin) {
           this.options = mergeOptions(this.options, mixin);
           return this;
@@ -4531,10 +4543,10 @@
           // the Vue instances at extension time, on the extended prototype. This
           // avoids Object.defineProperty calls for each instance created.
           if (Sub.options.props) {
-              initProps$1(Sub);
+              initProps(Sub);
           }
           if (Sub.options.computed) {
-              initComputed$1(Sub);
+              initComputed(Sub);
           }
           // allow further extension/mixin/plugin usage
           Sub.extend = Super.extend;
@@ -4560,13 +4572,13 @@
           return Sub;
       };
   }
-  function initProps$1(Comp) {
+  function initProps(Comp) {
       var props = Comp.options.props;
       for (var key in props) {
           proxy(Comp.prototype, "_props", key);
       }
   }
-  function initComputed$1(Comp) {
+  function initComputed(Comp) {
       var computed = Comp.options.computed;
       for (var key in computed) {
           defineComputed(Comp.prototype, key, computed[key]);
@@ -4622,26 +4634,24 @@
       return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache;
-      var keys = keepAliveInstance.keys;
-      var _vnode = keepAliveInstance._vnode;
+      var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
       for (var key in cache) {
           var cachedNode = cache[key];
           if (cachedNode) {
-              var name = getComponentName(cachedNode.componentOptions);
-              if (name && !filter(name)) {
+              var name_1 = getComponentName(cachedNode.componentOptions);
+              if (name_1 && !filter(name_1)) {
                   pruneCacheEntry(cache, key, keys, _vnode);
               }
           }
       }
   }
   function pruneCacheEntry(cache, key, keys, current) {
-      var cached$$1 = cache[key];
-      if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-          cached$$1.componentInstance.$destroy();
+      var cached = cache[key];
+      if (cached && (!current || cached.tag !== current.tag)) {
+          cached.componentInstance.$destroy();
       }
       cache[key] = null;
-      remove(keys, key);
+      remove$2(keys, key);
   }
   var patternTypes = [String, RegExp, Array];
   // TODO use defineComponent
@@ -4653,55 +4663,50 @@
           exclude: patternTypes,
           max: [String, Number],
       },
-      created: function created() {
+      created: function () {
           this.cache = Object.create(null);
           this.keys = [];
       },
-      destroyed: function destroyed() {
+      destroyed: function () {
           for (var key in this.cache) {
               pruneCacheEntry(this.cache, key, this.keys);
           }
       },
-      mounted: function mounted() {
-          var this$1 = this;
-
+      mounted: function () {
+          var _this = this;
           this.$watch('include', function (val) {
-              pruneCache(this$1, function (name) { return matches(val, name); });
+              pruneCache(_this, function (name) { return matches(val, name); });
           });
           this.$watch('exclude', function (val) {
-              pruneCache(this$1, function (name) { return !matches(val, name); });
+              pruneCache(_this, function (name) { return !matches(val, name); });
           });
       },
-      render: function render() {
+      render: function () {
           var slot = this.$slots.default;
           var vnode = getFirstComponentChild(slot);
           var componentOptions = vnode && vnode.componentOptions;
           if (componentOptions) {
               // check pattern
-              var name = getComponentName(componentOptions);
-              var ref = this;
-              var include = ref.include;
-              var exclude = ref.exclude;
+              var name_2 = getComponentName(componentOptions);
+              var _a = this, include = _a.include, exclude = _a.exclude;
               if (
               // not included
-              (include && (!name || !matches(include, name))) ||
+              (include && (!name_2 || !matches(include, name_2))) ||
                   // excluded
-                  (exclude && name && matches(exclude, name))) {
+                  (exclude && name_2 && matches(exclude, name_2))) {
                   return vnode;
               }
-              var ref$1 = this;
-              var cache = ref$1.cache;
-              var keys = ref$1.keys;
+              var _b = this, cache = _b.cache, keys = _b.keys;
               var key = vnode.key == null
                   ? // same constructor may get registered as different local components
                       // so cid alone is not enough (#3269)
                       componentOptions.Ctor.cid +
-                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                          (componentOptions.tag ? "::" + componentOptions.tag : '')
                   : vnode.key;
               if (cache[key]) {
                   vnode.componentInstance = cache[key].componentInstance;
                   // make current key freshest
-                  remove(keys, key);
+                  remove$2(keys, key);
                   keys.push(key);
               }
               else {
@@ -4729,7 +4734,7 @@
       configDef.get = function () { return config; };
       {
           configDef.set = function () {
-              warn('Do not replace the Vue.config object, set individual fields instead.');
+              warn$2('Do not replace the Vue.config object, set individual fields instead.');
           };
       }
       Object.defineProperty(Vue, 'config', configDef);
@@ -4737,10 +4742,10 @@
       // NOTE: these are not considered part of the public API - avoid relying on
       // them unless you are aware of the risk.
       Vue.util = {
-          warn: warn,
+          warn: warn$2,
           extend: extend,
           mergeOptions: mergeOptions,
-          defineReactive: defineReactive$$1,
+          defineReactive: defineReactive,
       };
       Vue.set = set;
       Vue.delete = del;
@@ -4759,7 +4764,7 @@
       Vue.options._base = Vue;
       extend(Vue.options.components, builtInComponents);
       initUse(Vue);
-      initMixin$1(Vue);
+      initMixin(Vue);
       initExtend(Vue);
       initAssetRegisters(Vue);
   }
@@ -4769,7 +4774,7 @@
       get: isServerRendering,
   });
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function get() {
+      get: function () {
           /* istanbul ignore next */
           return this.$vnode && this.$vnode.ssrContext;
       },
@@ -4960,7 +4965,7 @@
       if (typeof el === 'string') {
           var selected = document.querySelector(el);
           if (!selected) {
-              warn('Cannot find element: ' + el);
+              warn$2('Cannot find element: ' + el);
               return document.createElement('div');
           }
           return selected;
@@ -4971,7 +4976,7 @@
   }
 
   /* @flow */
-  function createElement$1(tagName, vnode) {
+  function createElement(tagName, vnode) {
       var elm = document.createElement(tagName);
       if (tagName !== 'select') {
           return elm;
@@ -5019,7 +5024,8 @@
   }
 
   var nodeOps = /*#__PURE__*/Object.freeze({
-    createElement: createElement$1,
+    __proto__: null,
+    createElement: createElement,
     createElementNS: createElementNS,
     createTextNode: createTextNode,
     createComment: createComment,
@@ -5035,16 +5041,16 @@
 
   /* @flow */
   var ref = {
-      create: function create(_, vnode) {
+      create: function (_, vnode) {
           registerRef(vnode);
       },
-      update: function update(oldVnode, vnode) {
+      update: function (oldVnode, vnode) {
           if (oldVnode.data.ref !== vnode.data.ref) {
               registerRef(oldVnode, true);
               registerRef(vnode);
           }
       },
-      destroy: function destroy(vnode) {
+      destroy: function (vnode) {
           registerRef(vnode, true);
       },
   };
@@ -5058,7 +5064,7 @@
       if (isRemoval) {
           if (Array.isArray(refs[key])) {
               // @ts-expect-error invalid typings
-              remove(refs[key], ref);
+              remove$2(refs[key], ref);
           }
           else if (refs[key] === ref) {
               refs[key] = undefined;
@@ -5126,8 +5132,7 @@
   function createPatchFunction(backend) {
       var i, j;
       var cbs = {};
-      var modules = backend.modules;
-      var nodeOps = backend.nodeOps;
+      var modules = backend.modules, nodeOps = backend.nodeOps;
       for (i = 0; i < hooks.length; ++i) {
           cbs[hooks[i]] = [];
           for (j = 0; j < modules.length; ++j) {
@@ -5140,13 +5145,13 @@
           return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
       }
       function createRmCb(childElm, listeners) {
-          function remove$$1() {
-              if (--remove$$1.listeners === 0) {
+          function remove() {
+              if (--remove.listeners === 0) {
                   removeNode(childElm);
               }
           }
-          remove$$1.listeners = listeners;
-          return remove$$1;
+          remove.listeners = listeners;
+          return remove;
       }
       function removeNode(el) {
           var parent = nodeOps.parentNode(el);
@@ -5155,7 +5160,7 @@
               nodeOps.removeChild(parent, el);
           }
       }
-      function isUnknownElement$$1(vnode, inVPre) {
+      function isUnknownElement(vnode, inVPre) {
           return (!inVPre &&
               !vnode.ns &&
               !(config.ignoredElements.length &&
@@ -5188,8 +5193,8 @@
                   if (data && data.pre) {
                       creatingElmInVPre++;
                   }
-                  if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-                      warn('Unknown custom element: <' +
+                  if (isUnknownElement(vnode, creatingElmInVPre)) {
+                      warn$2('Unknown custom element: <' +
                           tag +
                           '> - did you ' +
                           'register the component correctly? For recursive components, ' +
@@ -5281,11 +5286,11 @@
           // a reactivated keep-alive component doesn't insert itself
           insert(parentElm, vnode.elm, refElm);
       }
-      function insert(parent, elm, ref$$1) {
+      function insert(parent, elm, ref) {
           if (isDef(parent)) {
-              if (isDef(ref$$1)) {
-                  if (nodeOps.parentNode(ref$$1) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref$$1);
+              if (isDef(ref)) {
+                  if (nodeOps.parentNode(ref) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref);
                   }
               }
               else {
@@ -5298,8 +5303,8 @@
               {
                   checkDuplicateKeys(children);
               }
-              for (var i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                  createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
               }
           }
           else if (isPrimitive(vnode.text)) {
@@ -5313,8 +5318,8 @@
           return isDef(vnode.tag);
       }
       function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-              cbs.create[i$1](emptyNode, vnode);
+          for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+              cbs.create[i_2](emptyNode, vnode);
           }
           i = vnode.data.hook; // Reuse variable
           if (isDef(i)) {
@@ -5386,7 +5391,7 @@
       }
       function removeAndInvokeRemoveHook(vnode, rm) {
           if (isDef(rm) || isDef(vnode.data)) {
-              var i;
+              var i_3;
               var listeners = cbs.remove.length + 1;
               if (isDef(rm)) {
                   // we have a recursively passed down rm callback
@@ -5398,16 +5403,16 @@
                   rm = createRmCb(vnode.elm, listeners);
               }
               // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
+              if (isDef((i_3 = vnode.componentInstance)) &&
+                  isDef((i_3 = i_3._vnode)) &&
+                  isDef(i_3.data)) {
+                  removeAndInvokeRemoveHook(i_3, rm);
               }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
+              for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                  cbs.remove[i_3](vnode, rm);
               }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
+              if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                  i_3(vnode, rm);
               }
               else {
                   rm();
@@ -5503,12 +5508,12 @@
       }
       function checkDuplicateKeys(children) {
           var seenKeys = {};
-          for (var i = 0; i < children.length; i++) {
-              var vnode = children[i];
+          for (var i_4 = 0; i_4 < children.length; i_4++) {
+              var vnode = children[i_4];
               var key = vnode.key;
               if (isDef(key)) {
                   if (seenKeys[key]) {
-                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                      warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                   }
                   else {
                       seenKeys[key] = true;
@@ -5517,10 +5522,10 @@
           }
       }
       function findIdxInOld(node, oldCh, start, end) {
-          for (var i = start; i < end; i++) {
-              var c = oldCh[i];
+          for (var i_5 = start; i_5 < end; i_5++) {
+              var c = oldCh[i_5];
               if (isDef(c) && sameVnode(node, c))
-                  { return i; }
+                  { return i_5; }
           }
       }
       function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5600,8 +5605,8 @@
               vnode.parent.data.pendingInsert = queue;
           }
           else {
-              for (var i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
+              for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                  queue[i_6].data.hook.insert(queue[i_6]);
               }
           }
       }
@@ -5614,9 +5619,7 @@
       // Note: this is a browser-only function so we can assume elms are DOM nodes.
       function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
           var i;
-          var tag = vnode.tag;
-          var data = vnode.data;
-          var children = vnode.children;
+          var tag = vnode.tag, data = vnode.data, children = vnode.children;
           inVPre = inVPre || (data && data.pre);
           vnode.elm = elm;
           if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5665,9 +5668,9 @@
                           // iterate and compare children lists
                           var childrenMatch = true;
                           var childNode = elm.firstChild;
-                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                          for (var i_7 = 0; i_7 < children.length; i_7++) {
                               if (!childNode ||
-                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                   childrenMatch = false;
                                   break;
                               }
@@ -5711,7 +5714,7 @@
       function assertNodeMatch(node, vnode, inVPre) {
           if (isDef(vnode.tag)) {
               return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement$$1(vnode, inVPre) &&
+                  (!isUnknownElement(vnode, inVPre) &&
                       vnode.tag.toLowerCase() ===
                           (node.tagName && node.tagName.toLowerCase())));
           }
@@ -5753,7 +5756,7 @@
                               return oldVnode;
                           }
                           else {
-                              warn('The client-side rendered virtual DOM tree is not matching ' +
+                              warn$2('The client-side rendered virtual DOM tree is not matching ' +
                                   'server-rendered content. This is likely caused by incorrect ' +
                                   'HTML markup, for example nesting block-level elements inside ' +
                                   '<p>, or missing <tbody>. Bailing hydration and performing ' +
@@ -5778,22 +5781,22 @@
                       var ancestor = vnode.parent;
                       var patchable = isPatchable(vnode);
                       while (ancestor) {
-                          for (var i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
+                          for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                              cbs.destroy[i_8](ancestor);
                           }
                           ancestor.elm = vnode.elm;
                           if (patchable) {
-                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                  cbs.create[i$1](emptyNode, ancestor);
+                              for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                  cbs.create[i_9](emptyNode, ancestor);
                               }
                               // #6513
                               // invoke insert hooks that may have been merged by create hooks.
                               // e.g. for directives that uses the "inserted" hook.
-                              var insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
+                              var insert_1 = ancestor.data.hook.insert;
+                              if (insert_1.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                      insert.fns[i$2]();
+                                  for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                      insert_1.fns[i_10]();
                                   }
                               }
                           }
@@ -5818,7 +5821,7 @@
   }
 
   /* @flow */
-  var directives = {
+  var directives$1 = {
       create: updateDirectives,
       update: updateDirectives,
       destroy: function unbindDirectives(vnode) {
@@ -5834,8 +5837,8 @@
   function _update(oldVnode, vnode) {
       var isCreate = oldVnode === emptyNode;
       var isDestroy = vnode === emptyNode;
-      var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-      var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+      var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
       var dirsWithInsert = [];
       var dirsWithPostpatch = [];
       var key, oldDir, dir;
@@ -5844,7 +5847,7 @@
           dir = newDirs[key];
           if (!oldDir) {
               // new directive, bind
-              callHook$1(dir, 'bind', vnode, oldVnode);
+              callHook(dir, 'bind', vnode, oldVnode);
               if (dir.def && dir.def.inserted) {
                   dirsWithInsert.push(dir);
               }
@@ -5853,7 +5856,7 @@
               // existing directive, update
               dir.oldValue = oldDir.value;
               dir.oldArg = oldDir.arg;
-              callHook$1(dir, 'update', vnode, oldVnode);
+              callHook(dir, 'update', vnode, oldVnode);
               if (dir.def && dir.def.componentUpdated) {
                   dirsWithPostpatch.push(dir);
               }
@@ -5862,7 +5865,7 @@
       if (dirsWithInsert.length) {
           var callInsert = function () {
               for (var i = 0; i < dirsWithInsert.length; i++) {
-                  callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
               }
           };
           if (isCreate) {
@@ -5875,7 +5878,7 @@
       if (dirsWithPostpatch.length) {
           mergeVNodeHook(vnode, 'postpatch', function () {
               for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
               }
           });
       }
@@ -5883,13 +5886,13 @@
           for (key in oldDirs) {
               if (!newDirs[key]) {
                   // no longer present, unbind
-                  callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
               }
           }
       }
   }
   var emptyModifiers = Object.create(null);
-  function normalizeDirectives$1(dirs, vm) {
+  function normalizeDirectives(dirs, vm) {
       var res = Object.create(null);
       if (!dirs) {
           // $flow-disable-line
@@ -5909,21 +5912,21 @@
       return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+      return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
   }
-  function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
       var fn = dir.def && dir.def[hook];
       if (fn) {
           try {
               fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
           }
           catch (e) {
-              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+              handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
           }
       }
   }
 
-  var baseModules = [ref, directives];
+  var baseModules = [ref, directives$1];
 
   /* @flow */
   function updateAttrs(oldVnode, vnode) {
@@ -6013,11 +6016,11 @@
               key === 'placeholder' &&
               value !== '' &&
               !el.__ieph) {
-              var blocker = function (e) {
+              var blocker_1 = function (e) {
                   e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
+                  el.removeEventListener('input', blocker_1);
               };
-              el.addEventListener('input', blocker);
+              el.addEventListener('input', blocker_1);
               // $flow-disable-line
               el.__ieph = true; /* IE placeholder patched */
           }
@@ -6052,7 +6055,7 @@
           el._prevClass = cls;
       }
   }
-  var klass = {
+  var klass$1 = {
       create: updateClass,
       update: updateClass,
   };
@@ -6136,7 +6139,9 @@
               if (c === 0x2f) {
                   // /
                   var j = i - 1;
-                  var p = (void 0);
+                  var p 
+                  // find first non-whitespace prev char
+                  = void 0;
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
@@ -6170,19 +6175,19 @@
       var i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return ("_f(\"" + filter + "\")(" + exp + ")");
+          return "_f(\"" + filter + "\")(" + exp + ")";
       }
       else {
-          var name = filter.slice(0, i);
+          var name_1 = filter.slice(0, i);
           var args = filter.slice(i + 1);
-          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+          return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
       }
   }
 
   /* @flow */
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error(("[Vue compiler]: " + msg));
+      console.error("[Vue compiler]: " + msg);
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
@@ -6216,7 +6221,7 @@
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+      return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -6351,25 +6356,23 @@
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var ref = modifiers || {};
-      var number = ref.number;
-      var trim = ref.trim;
+      var _a = modifiers || {}, number = _a.number, trim = _a.trim;
       var baseValueExpression = '$$v';
       var valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
               "(typeof " + baseValueExpression + " === 'string'" +
-                  "? " + baseValueExpression + ".trim()" +
-                  ": " + baseValueExpression + ")";
+                  ("? " + baseValueExpression + ".trim()") +
+                  (": " + baseValueExpression + ")");
       }
       if (number) {
           valueExpression = "_n(" + valueExpression + ")";
       }
       var assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: ("(" + value + ")"),
+          value: "(" + value + ")",
           expression: JSON.stringify(value),
-          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+          callback: "function (" + baseValueExpression + ") {" + assignment + "}",
       };
   }
   /**
@@ -6378,10 +6381,10 @@
   function genAssignmentCode(value, assignment) {
       var res = parseModel(value);
       if (res.key === null) {
-          return (value + "=" + assignment);
+          return value + "=" + assignment;
       }
       else {
-          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+          return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
       }
   }
   /**
@@ -6398,18 +6401,18 @@
    * - test.xxx.a["asa"][test1[key]]
    *
    */
-  var len, str, chr, index$1, expressionPos, expressionEndPos;
+  var len, str, chr, index, expressionPos, expressionEndPos;
   function parseModel(val) {
       // Fix https://github.com/vuejs/vue/pull/7730
       // allow v-model="obj.val " (trailing whitespace)
       val = val.trim();
       len = val.length;
       if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-          index$1 = val.lastIndexOf('.');
-          if (index$1 > -1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
               return {
-                  exp: val.slice(0, index$1),
-                  key: '"' + val.slice(index$1 + 1) + '"',
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
               };
           }
           else {
@@ -6420,7 +6423,7 @@
           }
       }
       str = val;
-      index$1 = expressionPos = expressionEndPos = 0;
+      index = expressionPos = expressionEndPos = 0;
       while (!eof()) {
           chr = next();
           /* istanbul ignore if */
@@ -6437,17 +6440,17 @@
       };
   }
   function next() {
-      return str.charCodeAt(++index$1);
+      return str.charCodeAt(++index);
   }
   function eof() {
-      return index$1 >= len;
+      return index >= len;
   }
   function isStringStart(chr) {
       return chr === 0x22 || chr === 0x27;
   }
   function parseBracket(chr) {
       var inBracket = 1;
-      expressionPos = index$1;
+      expressionPos = index;
       while (!eof()) {
           chr = next();
           if (isStringStart(chr)) {
@@ -6459,7 +6462,7 @@
           if (chr === 0x5d)
               { inBracket--; }
           if (inBracket === 0) {
-              expressionEndPos = index$1;
+              expressionEndPos = index;
               break;
           }
       }
@@ -6480,7 +6483,7 @@
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
   var CHECKBOX_RADIO_TOKEN = '__c';
-  function model(el, dir, _warn) {
+  function model$1(el, dir, _warn) {
       warn$1 = _warn;
       var value = dir.value;
       var modifiers = dir.modifiers;
@@ -6490,7 +6493,7 @@
           // inputs with type="file" are read only and setting the input's
           // value will throw an error.
           if (tag === 'input' && type === 'file') {
-              warn$1("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+              warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                   "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
           }
       }
@@ -6517,7 +6520,7 @@
           return false;
       }
       else {
-          warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+          warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
               "v-model is not supported on this element type. " +
               "If you are working with contenteditable, it's recommended to " +
               'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
@@ -6531,25 +6534,25 @@
       var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
       var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
       addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          "?_i(" + value + "," + valueBinding + ")>-1" +
+          ("?_i(" + value + "," + valueBinding + ")>-1") +
           (trueValueBinding === 'true'
-              ? (":(" + value + ")")
-              : (":_q(" + value + "," + trueValueBinding + ")")));
+              ? ":(" + value + ")"
+              : ":_q(" + value + "," + trueValueBinding + ")"));
       addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
-          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
           'if(Array.isArray($$a)){' +
-          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
           '$$i=_i($$a,$$v);' +
-          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
   }
   function genRadioModel(el, value, modifiers) {
       var number = modifiers && modifiers.number;
       var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
       addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
   }
   function genSelect(el, value, modifiers) {
@@ -6557,10 +6560,10 @@
       var selectedVal = "Array.prototype.filter" +
           ".call($event.target.options,function(o){return o.selected})" +
           ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          "return " + (number ? '_n(val)' : 'val') + "})";
+          ("return " + (number ? '_n(val)' : 'val') + "})");
       var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
       var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + (genAssignmentCode(value, assignment));
+      code = code + " " + genAssignmentCode(value, assignment);
       addHandler(el, 'change', code, null, true);
   }
   function genDefaultModel(el, value, modifiers) {
@@ -6568,18 +6571,15 @@
       // warn if v-bind:value conflicts with v-model
       // except for inputs with v-bind:type
       {
-          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
           var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value$1 && !typeBinding) {
+          if (value_1 && !typeBinding) {
               var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn$1(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+              warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                   'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
           }
       }
-      var ref = modifiers || {};
-      var lazy = ref.lazy;
-      var number = ref.number;
-      var trim = ref.trim;
+      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
       var needCompositionGuard = !lazy && type !== 'range';
       var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
       var valueExpression = '$event.target.value';
@@ -6593,7 +6593,7 @@
       if (needCompositionGuard) {
           code = "if($event.target.composing)return;" + code;
       }
-      addProp(el, 'value', ("(" + value + ")"));
+      addProp(el, 'value', "(" + value + ")");
       addHandler(el, event, code, null, true);
       if (trim || number) {
           addHandler(el, 'blur', '$forceUpdate()');
@@ -6609,8 +6609,8 @@
       /* istanbul ignore if */
       if (isDef(on[RANGE_TOKEN])) {
           // IE input[type=range] only supports `change` event
-          var event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          var event_1 = isIE ? 'change' : 'input';
+          on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
           delete on[RANGE_TOKEN];
       }
       // This was originally intended to fix #4521 but no longer necessary
@@ -6621,13 +6621,13 @@
           delete on[CHECKBOX_RADIO_TOKEN];
       }
   }
-  var target$1;
-  function createOnceHandler$1(event, handler, capture) {
-      var _target = target$1; // save current target element in closure
+  var target;
+  function createOnceHandler(event, handler, capture) {
+      var _target = target; // save current target element in closure
       return function onceHandler() {
           var res = handler.apply(null, arguments);
           if (res !== null) {
-              remove$2(event, onceHandler, capture, _target);
+              remove(event, onceHandler, capture, _target);
           }
       };
   }
@@ -6635,7 +6635,7 @@
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
   var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-  function add$1(name, handler, capture, passive) {
+  function add(name, handler, capture, passive) {
       // async edge case #6566: inner click event triggers patch, event handler
       // attached to outer element during patch, and triggered again. This
       // happens because browsers fire microtask ticks between event propagation.
@@ -6643,17 +6643,17 @@
       // and the handler would only fire if the event passed to it was fired
       // AFTER it was attached.
       if (useMicrotaskFix) {
-          var attachedTimestamp = currentFlushTimestamp;
-          var original = handler;
+          var attachedTimestamp_1 = currentFlushTimestamp;
+          var original_1 = handler;
           //@ts-expect-error
-          handler = original._wrapper = function (e) {
+          handler = original_1._wrapper = function (e) {
               if (
               // no bubbling, should always fire.
               // this is just a safety net in case event.timeStamp is unreliable in
               // certain weird environments...
               e.target === e.currentTarget ||
                   // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
+                  e.timeStamp >= attachedTimestamp_1 ||
                   // bail for environments that have buggy event.timeStamp implementations
                   // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                   // #9681 QtWebEngine event.timeStamp is negative value
@@ -6662,14 +6662,14 @@
                   // electron/nw.js app, since event.timeStamp will be using a different
                   // starting reference
                   e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
+                  return original_1.apply(this, arguments);
               }
           };
       }
-      target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+      target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
   }
-  function remove$2(name, handler, capture, _target) {
-      (_target || target$1).removeEventListener(name, 
+  function remove(name, handler, capture, _target) {
+      (_target || target).removeEventListener(name, 
       //@ts-expect-error
       handler._wrapper || handler, capture);
   }
@@ -6679,10 +6679,10 @@
       }
       var on = vnode.data.on || {};
       var oldOn = oldVnode.data.on || {};
-      target$1 = vnode.elm;
+      target = vnode.elm;
       normalizeEvents(on);
-      updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-      target$1 = undefined;
+      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+      target = undefined;
   }
   var events = {
       create: updateDOMListeners,
@@ -6897,9 +6897,9 @@
       }
       var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
       for (var i = 0; i < vendorNames.length; i++) {
-          var name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
+          var name_1 = vendorNames[i] + capName;
+          if (name_1 in emptyStyle) {
+              return name_1;
           }
       }
   });
@@ -6937,13 +6937,13 @@
           }
       }
   }
-  var style = {
+  var style$1 = {
       create: updateStyle,
       update: updateStyle,
   };
 
   /* @flow */
-  var whitespaceRE = /\s+/;
+  var whitespaceRE$1 = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
@@ -6956,7 +6956,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
           }
           else {
               el.classList.add(cls);
@@ -6981,7 +6981,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
           }
           else {
               el.classList.remove(cls);
@@ -7006,31 +7006,31 @@
       }
   }
 
-  function resolveTransition(def$$1) {
-      if (!def$$1) {
+  function resolveTransition(def) {
+      if (!def) {
           return;
       }
       /* istanbul ignore else */
-      if (typeof def$$1 === 'object') {
+      if (typeof def === 'object') {
           var res = {};
-          if (def$$1.css !== false) {
-              extend(res, autoCssTransition(def$$1.name || 'v'));
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
           }
-          extend(res, def$$1);
+          extend(res, def);
           return res;
       }
-      else if (typeof def$$1 === 'string') {
-          return autoCssTransition(def$$1);
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
       }
   }
   var autoCssTransition = cached(function (name) {
       return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
+          enterClass: name + "-enter",
+          enterToClass: name + "-enter-to",
+          enterActiveClass: name + "-enter-active",
+          leaveClass: name + "-leave",
+          leaveToClass: name + "-leave-to",
+          leaveActiveClass: name + "-leave-active",
       };
   });
   var hasTransition = inBrowser && !isIE9;
@@ -7077,15 +7077,12 @@
   }
   function removeTransitionClass(el, cls) {
       if (el._transitionClasses) {
-          remove(el._transitionClasses, cls);
+          remove$2(el._transitionClasses, cls);
       }
       removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var ref = getTransitionInfo(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
+      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
       if (!type)
           { return cb(); }
       var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7191,23 +7188,7 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
+      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
@@ -7315,17 +7296,7 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
+      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
       var userWantsControl = getHookArgumentsLength(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7398,11 +7369,11 @@
   // only used in dev mode
   function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
-          warn("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
+          warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+              ("got " + JSON.stringify(val) + "."), vnode.context);
       }
       else if (isNaN(val)) {
-          warn("<transition> explicit " + name + " duration is NaN - " +
+          warn$2("<transition> explicit " + name + " duration is NaN - " +
               'the duration expression might be incorrect.', vnode.context);
       }
   }
@@ -7439,7 +7410,7 @@
       ? {
           create: _enter,
           activate: _enter,
-          remove: function remove$$1(vnode, rm) {
+          remove: function (vnode, rm) {
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
@@ -7452,13 +7423,13 @@
       }
       : {};
 
-  var platformModules = [attrs, klass, events, domProps, style, transition];
+  var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
   /* @flow */
   // the directive module should be applied last, after all
   // built-in modules have been applied.
-  var modules = platformModules.concat(baseModules);
-  var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+  var modules$1 = platformModules.concat(baseModules);
+  var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 
   /**
    * Not type checking this file because flow doesn't like attaching
@@ -7476,7 +7447,7 @@
       });
   }
   var directive = {
-      inserted: function inserted(el, binding, vnode, oldVnode) {
+      inserted: function (el, binding, vnode, oldVnode) {
           if (vnode.tag === 'select') {
               // #6903
               if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -7506,22 +7477,22 @@
               }
           }
       },
-      componentUpdated: function componentUpdated(el, binding, vnode) {
+      componentUpdated: function (el, binding, vnode) {
           if (vnode.tag === 'select') {
               setSelected(el, binding, vnode.context);
               // in case the options rendered by v-for have changed,
               // it's possible that the value is out-of-sync with the rendered options.
               // detect such cases and filter out values that no longer has a matching
               // option in the DOM.
-              var prevOptions = el._vOptions;
-              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+              var prevOptions_1 = el._vOptions;
+              var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                   // trigger change event if
                   // no matching option found for at least one value
                   var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                       : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
+                          hasNoMatchingOption(binding.value, curOptions_1);
                   if (needReset) {
                       trigger(el, 'change');
                   }
@@ -7542,8 +7513,8 @@
       var value = binding.value;
       var isMultiple = el.multiple;
       if (isMultiple && !Array.isArray(value)) {
-          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                  "expects an Array value for its binding, but got " + (Object.prototype.toString
+          warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
+                  ("expects an Array value for its binding, but got " + Object.prototype.toString
                       .call(value)
                       .slice(8, -1)), vm);
           return;
@@ -7601,14 +7572,13 @@
           : vnode;
   }
   var show = {
-      bind: function bind(el, ref, vnode) {
-          var value = ref.value;
-
+      bind: function (el, _a, vnode) {
+          var value = _a.value;
           vnode = locateNode(vnode);
-          var transition$$1 = vnode.data && vnode.data.transition;
+          var transition = vnode.data && vnode.data.transition;
           var originalDisplay = (el.__vOriginalDisplay =
               el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition$$1) {
+          if (value && transition) {
               vnode.data.show = true;
               enter(vnode, function () {
                   el.style.display = originalDisplay;
@@ -7618,16 +7588,14 @@
               el.style.display = value ? originalDisplay : 'none';
           }
       },
-      update: function update(el, ref, vnode) {
-          var value = ref.value;
-          var oldValue = ref.oldValue;
-
+      update: function (el, _a, vnode) {
+          var value = _a.value, oldValue = _a.oldValue;
           /* istanbul ignore if */
           if (!value === !oldValue)
               { return; }
           vnode = locateNode(vnode);
-          var transition$$1 = vnode.data && vnode.data.transition;
-          if (transition$$1) {
+          var transition = vnode.data && vnode.data.transition;
+          if (transition) {
               vnode.data.show = true;
               if (value) {
                   enter(vnode, function () {
@@ -7644,7 +7612,7 @@
               el.style.display = value ? el.__vOriginalDisplay : 'none';
           }
       },
-      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+      unbind: function (el, binding, vnode, oldVnode, isDestroy) {
           if (!isDestroy) {
               el.style.display = el.__vOriginalDisplay;
           }
@@ -7695,8 +7663,8 @@
       // events.
       // extract listeners and pass them directly to the transition methods
       var listeners = options._parentListeners;
-      for (var key$1 in listeners) {
-          data[camelize(key$1)] = listeners[key$1];
+      for (var key in listeners) {
+          data[camelize(key)] = listeners[key];
       }
       return data;
   }
@@ -7724,9 +7692,8 @@
       name: 'transition',
       props: transitionProps,
       abstract: true,
-      render: function render(h) {
-          var this$1 = this;
-
+      render: function (h) {
+          var _this = this;
           var children = this.$slots.default;
           if (!children) {
               return;
@@ -7739,7 +7706,7 @@
           }
           // warn multiple elements
           if (children.length > 1) {
-              warn('<transition> can only be used on a single element. Use ' +
+              warn$2('<transition> can only be used on a single element. Use ' +
                   '<transition-group> for lists.', this.$parent);
           }
           var mode = this.mode;
@@ -7747,7 +7714,7 @@
           if (mode &&
               mode !== 'in-out' &&
               mode !== 'out-in') {
-              warn('invalid <transition> mode: ' + mode, this.$parent);
+              warn$2('invalid <transition> mode: ' + mode, this.$parent);
           }
           var rawChild = children[0];
           // if this is a component root node and the component's
@@ -7768,7 +7735,7 @@
           // ensure a key that is unique to the vnode type and to this transition
           // component instance. This key will be used to remove pending leaving nodes
           // during entering.
-          var id = "__transition-" + (this._uid) + "-";
+          var id = "__transition-" + this._uid + "-";
           child.key =
               child.key == null
                   ? child.isComment
@@ -7802,8 +7769,8 @@
                   // return placeholder node and queue update when leave finishes
                   this._leaving = true;
                   mergeVNodeHook(oldData, 'afterLeave', function () {
-                      this$1._leaving = false;
-                      this$1.$forceUpdate();
+                      _this._leaving = false;
+                      _this.$forceUpdate();
                   });
                   return placeholder(h, rawChild);
               }
@@ -7811,14 +7778,14 @@
                   if (isAsyncPlaceholder(child)) {
                       return oldRawChild;
                   }
-                  var delayedLeave;
+                  var delayedLeave_1;
                   var performLeave = function () {
-                      delayedLeave();
+                      delayedLeave_1();
                   };
                   mergeVNodeHook(data, 'afterEnter', performLeave);
                   mergeVNodeHook(data, 'enterCancelled', performLeave);
                   mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                      delayedLeave = leave;
+                      delayedLeave_1 = leave;
                   });
               }
           }
@@ -7835,22 +7802,21 @@
   delete props.mode;
   var TransitionGroup = {
       props: props,
-      beforeMount: function beforeMount() {
-          var this$1 = this;
-
+      beforeMount: function () {
+          var _this = this;
           var update = this._update;
           this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(this$1);
+              var restoreActiveInstance = setActiveInstance(_this);
               // force removing pass
-              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              _this.__patch__(_this._vnode, _this.kept, false, // hydrating
               true // removeOnly (!important, avoids unnecessary moves)
               );
-              this$1._vnode = this$1.kept;
+              _this._vnode = _this.kept;
               restoreActiveInstance();
-              update.call(this$1, vnode, hydrating);
+              update.call(_this, vnode, hydrating);
           };
       },
-      render: function render(h) {
+      render: function (h) {
           var tag = this.tag || this.$vnode.data.tag || 'span';
           var map = Object.create(null);
           var prevChildren = (this.prevChildren = this.children);
@@ -7867,27 +7833,27 @@
                   }
                   else {
                       var opts = c.componentOptions;
-                      var name = opts
+                      var name_1 = opts
                           ? opts.Ctor.options.name || opts.tag || ''
                           : c.tag;
-                      warn(("<transition-group> children must be keyed: <" + name + ">"));
+                      warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
                   }
               }
           }
           if (prevChildren) {
               var kept = [];
               var removed = [];
-              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                  var c$1 = prevChildren[i$1];
-                  c$1.data.transition = transitionData;
+              for (var i = 0; i < prevChildren.length; i++) {
+                  var c = prevChildren[i];
+                  c.data.transition = transitionData;
                   // @ts-ignore
-                  c$1.data.pos = c$1.elm.getBoundingClientRect();
+                  c.data.pos = c.elm.getBoundingClientRect();
                   // @ts-ignore
-                  if (map[c$1.key]) {
-                      kept.push(c$1);
+                  if (map[c.key]) {
+                      kept.push(c);
                   }
                   else {
-                      removed.push(c$1);
+                      removed.push(c);
                   }
               }
               this.kept = h(tag, null, kept);
@@ -7895,7 +7861,7 @@
           }
           return h(tag, null, children);
       },
-      updated: function updated() {
+      updated: function () {
           var children = this.prevChildren;
           var moveClass = this.moveClass || (this.name || 'v') + '-move';
           if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7913,25 +7879,25 @@
           children.forEach(function (c) {
               // @ts-ignore
               if (c.data.moved) {
-                  var el = c.elm;
-                  var s = el.style;
-                  addTransitionClass(el, moveClass);
+                  var el_1 = c.elm;
+                  var s = el_1.style;
+                  addTransitionClass(el_1, moveClass);
                   s.transform = s.WebkitTransform = s.transitionDuration = '';
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
+                  el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                      if (e && e.target !== el_1) {
                           return;
                       }
                       if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
+                          el_1.removeEventListener(transitionEndEvent, cb);
+                          el_1._moveCb = null;
+                          removeTransitionClass(el_1, moveClass);
                       }
                   }));
               }
           });
       },
       methods: {
-          hasMove: function hasMove(el, moveClass) {
+          hasMove: function (el, moveClass) {
               /* istanbul ignore if */
               if (!hasTransition) {
                   return false;
@@ -8067,7 +8033,7 @@
           }
           // tag token
           var exp = parseFilters(match[1].trim());
-          tokens.push(("_s(" + exp + ")"));
+          tokens.push("_s(" + exp + ")");
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -8082,7 +8048,7 @@
   }
 
   /* @flow */
-  function transformNode(el, options) {
+  function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
       if (staticClass) {
@@ -8102,24 +8068,24 @@
           el.classBinding = classBinding;
       }
   }
-  function genData(el) {
+  function genData$2(el) {
       var data = '';
       if (el.staticClass) {
-          data += "staticClass:" + (el.staticClass) + ",";
+          data += "staticClass:" + el.staticClass + ",";
       }
       if (el.classBinding) {
-          data += "class:" + (el.classBinding) + ",";
+          data += "class:" + el.classBinding + ",";
       }
       return data;
   }
-  var klass$1 = {
+  var klass = {
       staticKeys: ['staticClass'],
-      transformNode: transformNode,
-      genData: genData,
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
   /* @flow */
-  function transformNode$1(el, options) {
+  function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
       if (staticStyle) {
@@ -8143,369 +8109,19 @@
   function genData$1(el) {
       var data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + (el.staticStyle) + ",";
+          data += "staticStyle:" + el.staticStyle + ",";
       }
       if (el.styleBinding) {
-          data += "style:(" + (el.styleBinding) + "),";
+          data += "style:(" + el.styleBinding + "),";
       }
       return data;
   }
-  var style$1 = {
+  var style = {
       staticKeys: ['staticStyle'],
-      transformNode: transformNode$1,
+      transformNode: transformNode,
       genData: genData$1,
   };
 
-  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-  (function(root) {
-
-  	// Detect free variables `exports`.
-  	var freeExports = typeof exports == 'object' && exports;
-
-  	// Detect free variable `module`.
-  	var freeModule = typeof module == 'object' && module &&
-  		module.exports == freeExports && module;
-
-  	// Detect free variable `global`, from Node.js or Browserified code,
-  	// and use it as `root`.
-  	var freeGlobal = typeof global == 'object' && global;
-  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-  		root = freeGlobal;
-  	}
-
-  	/*--------------------------------------------------------------------------*/
-
-  	// All astral symbols.
-  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  	// All ASCII symbols (not just printable ASCII) except those listed in the
-  	// first column of the overrides table.
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-  	// code points listed in the first column of the overrides table on
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-  	var regexEscape = /["&'<>`]/g;
-  	var escapeMap = {
-  		'"': '&quot;',
-  		'&': '&amp;',
-  		'\'': '&#x27;',
-  		'<': '&lt;',
-  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-  		// following is not strictly necessary unless it’s part of a tag or an
-  		// unquoted attribute value. We’re only escaping it to support those
-  		// situations, and for XML support.
-  		'>': '&gt;',
-  		// In Internet Explorer ≤ 8, the backtick character can be used
-  		// to break out of (un)quoted attribute values or HTML comments.
-  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-  		// http://html5sec.org/#133.
-  		'`': '&#x60;'
-  	};
-
-  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var stringFromCharCode = String.fromCharCode;
-
-  	var object = {};
-  	var hasOwnProperty = object.hasOwnProperty;
-  	var has = function(object, propertyName) {
-  		return hasOwnProperty.call(object, propertyName);
-  	};
-
-  	var contains = function(array, value) {
-  		var index = -1;
-  		var length = array.length;
-  		while (++index < length) {
-  			if (array[index] == value) {
-  				return true;
-  			}
-  		}
-  		return false;
-  	};
-
-  	var merge = function(options, defaults) {
-  		if (!options) {
-  			return defaults;
-  		}
-  		var result = {};
-  		var key;
-  		for (key in defaults) {
-  			// A `hasOwnProperty` check is not needed here, since only recognized
-  			// option names are used anyway. Any others are ignored.
-  			result[key] = has(options, key) ? options[key] : defaults[key];
-  		}
-  		return result;
-  	};
-
-  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-  	var codePointToSymbol = function(codePoint, strict) {
-  		var output = '';
-  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-  			// See issue #4:
-  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-  			// REPLACEMENT CHARACTER.”
-  			if (strict) {
-  				parseError('character reference outside the permissible Unicode range');
-  			}
-  			return '\uFFFD';
-  		}
-  		if (has(decodeMapNumeric, codePoint)) {
-  			if (strict) {
-  				parseError('disallowed character reference');
-  			}
-  			return decodeMapNumeric[codePoint];
-  		}
-  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-  			parseError('disallowed character reference');
-  		}
-  		if (codePoint > 0xFFFF) {
-  			codePoint -= 0x10000;
-  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-  			codePoint = 0xDC00 | codePoint & 0x3FF;
-  		}
-  		output += stringFromCharCode(codePoint);
-  		return output;
-  	};
-
-  	var hexEscape = function(codePoint) {
-  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-  	};
-
-  	var decEscape = function(codePoint) {
-  		return '&#' + codePoint + ';';
-  	};
-
-  	var parseError = function(message) {
-  		throw Error('Parse error: ' + message);
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var encode = function(string, options) {
-  		options = merge(options, encode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidRawCodePoint.test(string)) {
-  			parseError('forbidden code point');
-  		}
-  		var encodeEverything = options.encodeEverything;
-  		var useNamedReferences = options.useNamedReferences;
-  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-  		var escapeBmpSymbol = function(symbol) {
-  			return escapeCodePoint(symbol.charCodeAt(0));
-  		};
-
-  		if (encodeEverything) {
-  			// Encode ASCII symbols.
-  			string = string.replace(regexAsciiWhitelist, function(symbol) {
-  				// Use named references if requested & possible.
-  				if (useNamedReferences && has(encodeMap, symbol)) {
-  					return '&' + encodeMap[symbol] + ';';
-  				}
-  				return escapeBmpSymbol(symbol);
-  			});
-  			// Shorten a few escapes that represent two symbols, of which at least one
-  			// is within the ASCII range.
-  			if (useNamedReferences) {
-  				string = string
-  					.replace(/&gt;\u20D2/g, '&nvgt;')
-  					.replace(/&lt;\u20D2/g, '&nvlt;')
-  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-  			}
-  			// Encode non-ASCII symbols.
-  			if (useNamedReferences) {
-  				// Encode non-ASCII symbols that can be replaced with a named reference.
-  				string = string.replace(regexEncodeNonAscii, function(string) {
-  					// Note: there is no need to check `has(encodeMap, string)` here.
-  					return '&' + encodeMap[string] + ';';
-  				});
-  			}
-  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-  		} else if (useNamedReferences) {
-  			// Apply named character references.
-  			// Encode `<>"'&` using named character references.
-  			if (!allowUnsafeSymbols) {
-  				string = string.replace(regexEscape, function(string) {
-  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-  				});
-  			}
-  			// Shorten escapes that represent two symbols, of which at least one is
-  			// `<>"'&`.
-  			string = string
-  				.replace(/&gt;\u20D2/g, '&nvgt;')
-  				.replace(/&lt;\u20D2/g, '&nvlt;');
-  			// Encode non-ASCII symbols that can be replaced with a named reference.
-  			string = string.replace(regexEncodeNonAscii, function(string) {
-  				// Note: there is no need to check `has(encodeMap, string)` here.
-  				return '&' + encodeMap[string] + ';';
-  			});
-  		} else if (!allowUnsafeSymbols) {
-  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-  			// using named character references.
-  			string = string.replace(regexEscape, escapeBmpSymbol);
-  		}
-  		return string
-  			// Encode astral symbols.
-  			.replace(regexAstralSymbols, function($0) {
-  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-  				var high = $0.charCodeAt(0);
-  				var low = $0.charCodeAt(1);
-  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-  				return escapeCodePoint(codePoint);
-  			})
-  			// Encode any remaining BMP symbols that are not printable ASCII symbols
-  			// using a hexadecimal escape.
-  			.replace(regexBmpWhitelist, escapeBmpSymbol);
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	encode.options = {
-  		'allowUnsafeSymbols': false,
-  		'encodeEverything': false,
-  		'strict': false,
-  		'useNamedReferences': false,
-  		'decimal' : false
-  	};
-
-  	var decode = function(html, options) {
-  		options = merge(options, decode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidEntity.test(html)) {
-  			parseError('malformed character reference');
-  		}
-  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  			var codePoint;
-  			var semicolon;
-  			var decDigits;
-  			var hexDigits;
-  			var reference;
-  			var next;
-
-  			if ($1) {
-  				reference = $1;
-  				// Note: there is no need to check `has(decodeMap, reference)`.
-  				return decodeMap[reference];
-  			}
-
-  			if ($2) {
-  				// Decode named character references without trailing `;`, e.g. `&amp`.
-  				// This is only a parse error if it gets converted to `&`, or if it is
-  				// followed by `=` in an attribute context.
-  				reference = $2;
-  				next = $3;
-  				if (next && options.isAttributeValue) {
-  					if (strict && next == '=') {
-  						parseError('`&` did not start a character reference');
-  					}
-  					return $0;
-  				} else {
-  					if (strict) {
-  						parseError(
-  							'named character reference was not terminated by a semicolon'
-  						);
-  					}
-  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-  					return decodeMapLegacy[reference] + (next || '');
-  				}
-  			}
-
-  			if ($4) {
-  				// Decode decimal escapes, e.g. `&#119558;`.
-  				decDigits = $4;
-  				semicolon = $5;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(decDigits, 10);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			if ($6) {
-  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-  				hexDigits = $6;
-  				semicolon = $7;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(hexDigits, 16);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-  			if (strict) {
-  				parseError(
-  					'named character reference was not terminated by a semicolon'
-  				);
-  			}
-  			return $0;
-  		});
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	decode.options = {
-  		'isAttributeValue': false,
-  		'strict': false
-  	};
-
-  	var escape = function(string) {
-  		return string.replace(regexEscape, function($0) {
-  			// Note: there is no need to check `has(escapeMap, $0)` here.
-  			return escapeMap[$0];
-  		});
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var he = {
-  		'version': '1.2.0',
-  		'encode': encode,
-  		'decode': decode,
-  		'escape': escape,
-  		'unescape': decode
-  	};
-
-  	// Some AMD build optimizers, like r.js, check for specific condition patterns
-  	// like the following:
-  	if (
-  		typeof define == 'function' &&
-  		typeof define.amd == 'object' &&
-  		define.amd
-  	) {
-  		define(function() {
-  			return he;
-  		});
-  	}	else if (freeExports && !freeExports.nodeType) {
-  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-  			freeModule.exports = he;
-  		} else { // in Narwhal or RingoJS v0.7.0-
-  			for (var key in he) {
-  				has(he, key) && (freeExports[key] = he[key]);
-  			}
-  		}
-  	} else { // in Rhino or a web browser
-  		root.he = he;
-  	}
-
-  }(undefined));
-
-  var he = /*#__PURE__*/Object.freeze({
-
-  });
-
   /* @flow */
   var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
@@ -8526,11 +8142,11 @@
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp(("^<" + qnameCapture));
+  var startTagOpen = new RegExp("^<" + qnameCapture);
   var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+  var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
   var doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
@@ -8551,7 +8167,9 @@
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+  var shouldIgnoreFirstNewline = function (tag, html) {
+      return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  };
   function decodeAttr(value, shouldDecodeNewlines) {
       var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
       return value.replace(re, function (match) { return decodingMap[match]; });
@@ -8559,11 +8177,11 @@
   function parseHTML(html, options) {
       var stack = [];
       var expectHTML = options.expectHTML;
-      var isUnaryTag$$1 = options.isUnaryTag || no;
-      var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+      var isUnaryTag = options.isUnaryTag || no;
+      var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
       var index = 0;
       var last, lastTag;
-      while (html) {
+      var _loop_1 = function () {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -8577,7 +8195,7 @@
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                           }
                           advance(commentEnd + 3);
-                          continue;
+                          return "continue";
                       }
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -8585,14 +8203,14 @@
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
-                          continue;
+                          return "continue";
                       }
                   }
                   // Doctype:
                   var doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
-                      continue;
+                      return "continue";
                   }
                   // End tag:
                   var endTagMatch = html.match(endTag);
@@ -8600,7 +8218,7 @@
                       var curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
+                      return "continue";
                   }
                   // Start tag:
                   var startTagMatch = parseStartTag();
@@ -8609,10 +8227,10 @@
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                           advance(1);
                       }
-                      continue;
+                      return "continue";
                   }
               }
-              var text = (void 0), rest = (void 0), next = (void 0);
+              var text = void 0, rest = void 0, next = void 0;
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -8639,18 +8257,18 @@
               }
           }
           else {
-              var endTagLength = 0;
-              var stackedTag = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+              var endTagLength_1 = 0;
+              var stackedTag_1 = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag_1] ||
+                  (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+              var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength_1 = endTag.length;
+                  if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                       text = text
                           .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                           .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                   }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                  if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                       text = text.slice(1);
                   }
                   if (options.chars) {
@@ -8658,20 +8276,25 @@
                   }
                   return '';
               });
-              index += html.length - rest$1.length;
-              html = rest$1;
-              parseEndTag(stackedTag, index - endTagLength, index);
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag_1, index - endTagLength_1, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                  options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                       start: index + html.length,
                   });
               }
-              break;
+              return "break";
           }
+      };
+      while (html) {
+          var state_1 = _loop_1();
+          if (state_1 === "break")
+              { break; }
       }
       // Clean up any remaining tags
       parseEndTag();
@@ -8688,7 +8311,7 @@
                   start: index,
               };
               advance(start[0].length);
-              var end, attr;
+              var end = void 0, attr = void 0;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -8711,11 +8334,11 @@
               if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                   parseEndTag(lastTag);
               }
-              if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                   parseEndTag(tagName);
               }
           }
-          var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+          var unary = isUnaryTag(tagName) || !!unarySlash;
           var l = match.attrs.length;
           var attrs = new Array(l);
           for (var i = 0; i < l; i++) {
@@ -8769,9 +8392,9 @@
           if (pos >= 0) {
               // Close all the open elements, up the stack
               for (var i = stack.length - 1; i >= pos; i--) {
-                  if (i > pos || !tagName &&
+                  if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                      options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -8801,6 +8424,7 @@
   }
 
   /* @flow */
+  var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8812,12 +8436,12 @@
   var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
   var slotRE = /^v-slot(:|$)|^#/;
   var lineBreakRE = /[\r\n]/;
-  var whitespaceRE$1 = /[ \f\t\r\n]+/g;
+  var whitespaceRE = /[ \f\t\r\n]+/g;
   var invalidAttributeRE = /[\s"'<>\/=]/;
-  var decodeHTMLCached = cached(undefined);
+  var decodeHTMLCached = cached(he.decode);
   var emptySlotScopeToken = "_empty_";
   // configurable state
-  var warn$2;
+  var warn;
   var delimiters;
   var transforms;
   var preTransforms;
@@ -8841,7 +8465,7 @@
    * Convert HTML string to AST.
    */
   function parse(template, options) {
-      warn$2 = options.warn || baseWarn;
+      warn = options.warn || baseWarn;
       platformIsPreTag = options.isPreTag || no;
       platformMustUseProp = options.mustUseProp || no;
       platformGetTagNamespace = options.getTagNamespace || no;
@@ -8862,7 +8486,7 @@
       function warnOnce(msg, range) {
           if (!warned) {
               warned = true;
-              warn$2(msg, range);
+              warn(msg, range);
           }
       }
       function closeElement(element) {
@@ -8897,8 +8521,8 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                      var name_1 = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                   }
                   currentParent.children.push(element);
                   element.parent = currentParent;
@@ -8924,7 +8548,7 @@
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode;
+              var lastNode = void 0;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -8934,7 +8558,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+              warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8943,7 +8567,7 @@
           }
       }
       parseHTML(template, {
-          warn: warn$2,
+          warn: warn,
           expectHTML: options.expectHTML,
           isUnaryTag: options.isUnaryTag,
           canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8951,7 +8575,7 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function start(tag, attrs, unary, start$1, end) {
+          start: function (tag, attrs, unary, start, end) {
               // check namespace.
               // inherit parent ns if there is one
               var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -8966,7 +8590,7 @@
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start$1;
+                      element.start = start;
                       element.end = end;
                       element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                           cumulated[attr.name] = attr;
@@ -8975,7 +8599,7 @@
                   }
                   attrs.forEach(function (attr) {
                       if (invalidAttributeRE.test(attr.name)) {
-                          warn$2("Invalid dynamic argument expression: attribute names cannot contain " +
+                          warn("Invalid dynamic argument expression: attribute names cannot contain " +
                               "spaces, quotes, <, >, / or =.", {
                               start: attr.start + attr.name.indexOf("["),
                               end: attr.start + attr.name.length,
@@ -8985,9 +8609,9 @@
               }
               if (isForbiddenTag(element) && !isServerRendering()) {
                   element.forbidden = true;
-                  warn$2('Templates should only be responsible for mapping the state to the ' +
+                  warn('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          "<" + tag + ">" +
+                          ("<" + tag + ">") +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
@@ -9026,24 +8650,24 @@
                   closeElement(element);
               }
           },
-          end: function end(tag, start, end$1) {
+          end: function (tag, start, end) {
               var element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end$1;
+                  element.end = end;
               }
               closeElement(element);
           },
-          chars: function chars(text, start, end) {
+          chars: function (text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
                           warnOnce('Component template requires a root element, rather than just text.', { start: start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                          warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                               start: start,
                           });
                       }
@@ -9081,10 +8705,10 @@
               if (text) {
                   if (!inPre && whitespaceOption === 'condense') {
                       // condense consecutive whitespaces into single space
-                      text = text.replace(whitespaceRE$1, ' ');
+                      text = text.replace(whitespaceRE, ' ');
                   }
-                  var res;
-                  var child;
+                  var res = void 0;
+                  var child = void 0;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
@@ -9110,7 +8734,7 @@
                   }
               }
           },
-          comment: function comment(text, start, end) {
+          comment: function (text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
@@ -9176,16 +8800,16 @@
       if (exp) {
           {
               if (el.tag === 'template') {
-                  warn$2("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                  warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
-                  var parent = el.parent;
+                  var parent_1 = el.parent;
                   if (iterator &&
                       iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
-                      warn$2("Do not use v-for index as key on <transition-group> children, " +
+                      parent_1 &&
+                      parent_1.tag === 'transition-group') {
+                      warn("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
               }
@@ -9208,7 +8832,7 @@
               extend(el, res);
           }
           else {
-              warn$2(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+              warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -9260,8 +8884,8 @@
           });
       }
       else {
-          warn$2("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+          warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+              ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
@@ -9272,7 +8896,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$2("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                  warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -9286,8 +8910,8 @@
       el.ifConditions.push(condition);
   }
   function processOnce(el) {
-      var once$$1 = getAndRemoveAttr(el, 'v-once');
-      if (once$$1 != null) {
+      var once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
           el.once = true;
       }
   }
@@ -9299,7 +8923,7 @@
           slotScope = getAndRemoveAttr(el, 'scope');
           /* istanbul ignore if */
           if (slotScope) {
-              warn$2("the \"scope\" attribute for scoped slots have been deprecated and " +
+              warn("the \"scope\" attribute for scoped slots have been deprecated and " +
                   "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                   "can also be used on plain elements in addition to <template> to " +
                   "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -9309,7 +8933,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$2("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+              warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -9334,52 +8958,48 @@
               if (slotBinding) {
                   {
                       if (el.slotTarget || el.slotScope) {
-                          warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                          warn("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.parent && !maybeComponent(el.parent)) {
-                          warn$2("<template v-slot> can only appear at the root level inside " +
+                          warn("<template v-slot> can only appear at the root level inside " +
                               "the receiving component", el);
                       }
                   }
-                  var ref = getSlotName(slotBinding);
-                  var name = ref.name;
-                  var dynamic = ref.dynamic;
-                  el.slotTarget = name;
+                  var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                  el.slotTarget = name_2;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
               }
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding$1) {
+              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$2("v-slot can only be used on components or <template>.", slotBinding$1);
+                          warn("v-slot can only be used on components or <template>.", slotBinding);
                       }
                       if (el.slotScope || el.slotTarget) {
-                          warn$2("Unexpected mixed usage of different slot syntaxes.", el);
+                          warn("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
-                          warn$2("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding$1);
+                          warn("To avoid scope ambiguity, the default slot should also use " +
+                              "<template> syntax when there are other named slots.", slotBinding);
                       }
                   }
                   // add the component's children to its default slot
                   var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var ref$1 = getSlotName(slotBinding$1);
-                  var name$1 = ref$1.name;
-                  var dynamic$1 = ref$1.dynamic;
-                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name$1;
-                  slotContainer.slotTargetDynamic = dynamic$1;
-                  slotContainer.children = el.children.filter(function (c) {
+                  var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                  var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                  slotContainer_1.slotTarget = name_3;
+                  slotContainer_1.slotTargetDynamic = dynamic;
+                  slotContainer_1.children = el.children.filter(function (c) {
                       if (!c.slotScope) {
-                          c.parent = slotContainer;
+                          c.parent = slotContainer_1;
                           return true;
                       }
                   });
-                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -9395,21 +9015,21 @@
               name = 'default';
           }
           else {
-              warn$2("v-slot shorthand syntax requires a slot name.", binding);
+              warn("v-slot shorthand syntax requires a slot name.", binding);
           }
       }
       return dynamicArgRE.test(name)
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: ("\"" + name + "\""), dynamic: false };
+              { name: "\"" + name + "\"", dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
       if (el.tag === 'slot') {
           el.slotName = getBindingAttr(el, 'name');
           if (el.key) {
-              warn$2("`key` does not work on <slot> because slots are abstract outlets " +
+              warn("`key` does not work on <slot> because slots are abstract outlets " +
                   "and can possibly expand into multiple elements. " +
                   "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
           }
@@ -9448,7 +9068,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$2(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                      warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -9462,14 +9082,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$2, list[i]);
+                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$2, list[i]);
+                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$2, list[i], true // dynamic
+                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
                               );
                           }
                       }
@@ -9489,7 +9109,7 @@
                   if (isDynamic) {
                       name = name.slice(1, -1);
                   }
-                  addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);
+                  addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
               }
               else {
                   // normal directives
@@ -9516,7 +9136,7 @@
               {
                   var res = parseText(value, delimiters);
                   if (res) {
-                      warn$2(name + "=\"" + value + "\": " +
+                      warn(name + "=\"" + value + "\": " +
                           'Interpolation inside attributes has been removed. ' +
                           'Use v-bind or the colon shorthand instead. For example, ' +
                           'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9546,11 +9166,11 @@
   function parseModifiers(name) {
       var match = name.match(modifierRE);
       if (match) {
-          var ret = {};
+          var ret_1 = {};
           match.forEach(function (m) {
-              ret[m.slice(1)] = true;
+              ret_1[m.slice(1)] = true;
           });
-          return ret;
+          return ret_1;
       }
   }
   function makeAttrsMap(attrs) {
@@ -9559,7 +9179,7 @@
           if (map[attrs[i].name] &&
               !isIE &&
               !isEdge) {
-              warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);
+              warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
           }
           map[attrs[i].name] = attrs[i].value;
       }
@@ -9592,7 +9212,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+              warn("<" + el.tag + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -9609,16 +9229,16 @@
           if (!map['v-model']) {
               return;
           }
-          var typeBinding;
+          var typeBinding = void 0;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + (map['v-bind']) + ").type";
+              typeBinding = "(" + map['v-bind'] + ").type";
           }
           if (typeBinding) {
               var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+              var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
               var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
               var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
@@ -9664,28 +9284,28 @@
   function cloneASTElement(el) {
       return createASTElement(el.tag, el.attrsList.slice(), el.parent);
   }
-  var model$1 = {
+  var model = {
       preTransformNode: preTransformNode,
   };
 
-  var modules$1 = [klass$1, style$1, model$1];
+  var modules = [klass, style, model];
 
   /* @flow */
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
   /* @flow */
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
       }
   }
 
-  var directives$1 = {
-      model: model,
+  var directives = {
+      model: model$1,
       text: text,
       html: html,
   };
@@ -9693,8 +9313,8 @@
   /* @flow */
   var baseOptions = {
       expectHTML: true,
-      modules: modules$1,
-      directives: directives$1,
+      modules: modules,
+      directives: directives,
       isPreTag: isPreTag,
       isUnaryTag: isUnaryTag,
       mustUseProp: mustUseProp,
@@ -9702,13 +9322,13 @@
       isReservedTag: isReservedTag,
       getTagNamespace: getTagNamespace,
       // @ts-ignore
-      staticKeys: genStaticKeys(modules$1),
+      staticKeys: genStaticKeys$1(modules),
   };
 
   /* @flow */
   var isStaticKey;
   var isPlatformReservedTag;
-  var genStaticKeysCached = cached(genStaticKeys$1);
+  var genStaticKeysCached = cached(genStaticKeys);
   /**
    * Goal of the optimizer: walk the generated template AST tree
    * and detect sub-trees that are purely static, i.e. parts of
@@ -9726,15 +9346,15 @@
       isStaticKey = genStaticKeysCached(options.staticKeys || '');
       isPlatformReservedTag = options.isReservedTag || no;
       // first pass: mark all non-static nodes.
-      markStatic$1(root);
+      markStatic(root);
       // second pass: mark static roots.
       markStaticRoots(root, false);
   }
-  function genStaticKeys$1(keys) {
+  function genStaticKeys(keys) {
       return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
           (keys ? ',' + keys : ''));
   }
-  function markStatic$1(node) {
+  function markStatic(node) {
       node.static = isStatic(node);
       if (node.type === 1) {
           // do not make component slot content static. this avoids
@@ -9747,15 +9367,15 @@
           }
           for (var i = 0, l = node.children.length; i < l; i++) {
               var child = node.children[i];
-              markStatic$1(child);
+              markStatic(child);
               if (!child.static) {
                   node.static = false;
               }
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  var block = node.ifConditions[i$1].block;
-                  markStatic$1(block);
+              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                  var block = node.ifConditions[i].block;
+                  markStatic(block);
                   if (!block.static) {
                       node.static = false;
                   }
@@ -9786,8 +9406,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
+              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                  markStaticRoots(node.ifConditions[i].block, isInFor);
               }
           }
       }
@@ -9858,7 +9478,7 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+  var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
   var modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
@@ -9875,19 +9495,19 @@
       var prefix = isNative ? 'nativeOn:' : 'on:';
       var staticHandlers = "";
       var dynamicHandlers = "";
-      for (var name in events) {
-          var handlerCode = genHandler(events[name]);
+      for (var name_1 in events) {
+          var handlerCode = genHandler(events[name_1]);
           //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += name + "," + handlerCode + ",";
+          if (events[name_1] && events[name_1].dynamic) {
+              dynamicHandlers += name_1 + "," + handlerCode + ",";
           }
           else {
-              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+              staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
           }
       }
-      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
       if (dynamicHandlers) {
-          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+          return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
       }
       else {
           return prefix + staticHandlers;
@@ -9898,7 +9518,7 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+          return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
       }
       var isMethodPath = simplePathRE.test(handler.value);
       var isFunctionExpression = fnExpRE.test(handler.value);
@@ -9907,13 +9527,13 @@
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+          return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
       }
       else {
           var code = '';
           var genModifierCode = '';
           var keys = [];
-          for (var key in handler.modifiers) {
+          var _loop_1 = function (key) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -9922,15 +9542,18 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers = handler.modifiers;
+                  var modifiers_1 = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                      .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                       .join('||'));
               }
               else {
                   keys.push(key);
               }
+          };
+          for (var key in handler.modifiers) {
+              _loop_1(key);
           }
           if (keys.length) {
               code += genKeyFilter(keys);
@@ -9940,13 +9563,13 @@
               code += genModifierCode;
           }
           var handlerCode = isMethodPath
-              ? ("return " + (handler.value) + ".apply(null, arguments)")
+              ? "return " + handler.value + ".apply(null, arguments)"
               : isFunctionExpression
-                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  ? "return (" + handler.value + ").apply(null, arguments)"
                   : isFunctionInvocation
-                      ? ("return " + (handler.value))
+                      ? "return " + handler.value
                       : handler.value;
-          return ("function($event){" + code + handlerCode + "}");
+          return "function($event){" + code + handlerCode + "}";
       }
   }
   function genKeyFilter(keys) {
@@ -9955,59 +9578,64 @@
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&')) + ")return null;");
+          (keys.map(genFilterCode).join('&&') + ")return null;"));
   }
   function genFilterCode(key) {
       var keyVal = parseInt(key, 10);
       if (keyVal) {
-          return ("$event.keyCode!==" + keyVal);
+          return "$event.keyCode!==" + keyVal;
       }
       var keyCode = keyCodes[key];
       var keyName = keyNames[key];
       return ("_k($event.keyCode," +
-          (JSON.stringify(key)) + "," +
-          (JSON.stringify(keyCode)) + "," +
+          (JSON.stringify(key) + ",") +
+          (JSON.stringify(keyCode) + ",") +
           "$event.key," +
-          "" + (JSON.stringify(keyName)) +
+          ("" + JSON.stringify(keyName)) +
           ")");
   }
 
   /* @flow */
   function on(el, dir) {
       if (dir.modifiers) {
-          warn("v-on without argument does not support modifiers.");
+          warn$2("v-on without argument does not support modifiers.");
       }
-      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+      el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
   /* @flow */
-  function bind$1(el, dir) {
+  function bind(el, dir) {
       el.wrapData = function (code) {
-          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+          return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
   /* @flow */
   var baseDirectives = {
       on: on,
-      bind: bind$1,
+      bind: bind,
       cloak: noop,
   };
 
   /* @flow */
-  var CodegenState = function CodegenState(options) {
-      this.options = options;
-      this.warn = options.warn || baseWarn;
-      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-      this.directives = extend(extend({}, baseDirectives), options.directives);
-      var isReservedTag = options.isReservedTag || no;
-      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-      this.onceId = 0;
-      this.staticRenderFns = [];
-      this.pre = false;
-  };
+  var CodegenState = /** @class */ (function () {
+      function CodegenState(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          var isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = function (el) {
+              return !!el.component || !isReservedTag(el.tag);
+          };
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+      return CodegenState;
+  }());
   function generate(ast, options) {
       var state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
@@ -10017,7 +9645,7 @@
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: ("with(this){return " + code + "}"),
+          render: "with(this){return " + code + "}",
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -10045,17 +9673,19 @@
       }
       else {
           // component or element
-          var code;
+          var code = void 0;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data;
+              var data = void 0;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData$2(el, state);
+                  data = genData(el, state);
               }
               var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+              code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+              ) + (children ? "," + children : '' // children
+              ) + ")";
           }
           // module transforms
           for (var i = 0; i < state.transforms.length; i++) {
@@ -10074,9 +9704,9 @@
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
       state.pre = originalPreState;
-      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+      return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
   }
   // v-once
   function genOnce(el, state) {
@@ -10086,19 +9716,19 @@
       }
       else if (el.staticInFor) {
           var key = '';
-          var parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
+          var parent_1 = el.parent;
+          while (parent_1) {
+              if (parent_1.for) {
+                  key = parent_1.key;
                   break;
               }
-              parent = parent.parent;
+              parent_1 = parent_1.parent;
           }
           if (!key) {
               state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+          return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
       }
       else {
           return genStatic(el, state);
@@ -10114,10 +9744,10 @@
       }
       var condition = conditions.shift();
       if (condition.exp) {
-          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+          return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
       }
       else {
-          return ("" + (genTernaryExp(condition.block)));
+          return "" + genTernaryExp(condition.block);
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -10131,23 +9761,23 @@
   function genFor(el, state, altGen, altHelper) {
       var exp = el.for;
       var alias = el.alias;
-      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+      var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+          state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
               "v-for should have explicit keys. " +
               "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ((altHelper || '_l') + "((" + exp + ")," +
-          "function(" + alias + iterator1 + iterator2 + "){" +
-          "return " + ((altGen || genElement)(el, state)) +
+          ("function(" + alias + iterator1 + iterator2 + "){") +
+          ("return " + (altGen || genElement)(el, state)) +
           '})');
   }
-  function genData$2(el, state) {
+  function genData(el, state) {
       var data = '{';
       // directives first.
       // directives may mutate the el's other properties before they are generated.
@@ -10156,11 +9786,11 @@
           { data += dirs + ','; }
       // key
       if (el.key) {
-          data += "key:" + (el.key) + ",";
+          data += "key:" + el.key + ",";
       }
       // ref
       if (el.ref) {
-          data += "ref:" + (el.ref) + ",";
+          data += "ref:" + el.ref + ",";
       }
       if (el.refInFor) {
           data += "refInFor:true,";
@@ -10171,7 +9801,7 @@
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + (el.tag) + "\",";
+          data += "tag:\"" + el.tag + "\",";
       }
       // module data generation functions
       for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -10179,31 +9809,31 @@
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + (genProps(el.attrs)) + ",";
+          data += "attrs:" + genProps(el.attrs) + ",";
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + (genProps(el.props)) + ",";
+          data += "domProps:" + genProps(el.props) + ",";
       }
       // event handlers
       if (el.events) {
-          data += (genHandlers(el.events, false)) + ",";
+          data += genHandlers(el.events, false) + ",";
       }
       if (el.nativeEvents) {
-          data += (genHandlers(el.nativeEvents, true)) + ",";
+          data += genHandlers(el.nativeEvents, true) + ",";
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + (el.slotTarget) + ",";
+          data += "slot:" + el.slotTarget + ",";
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+          data += genScopedSlots(el, el.scopedSlots, state) + ",";
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+          data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
       }
       // inline-template
       if (el.inlineTemplate) {
@@ -10217,7 +9847,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+          data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -10247,9 +9877,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+              res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                  ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                  : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
           }
       }
       if (hasRuntime) {
@@ -10258,14 +9888,14 @@
   }
   function genInlineTemplate(el, state) {
       var ast = el.children[0];
-      if (el.children.length !== 1 || ast.type !== 1) {
+      if ((el.children.length !== 1 || ast.type !== 1)) {
           state.warn('Inline-template components must have exactly one child element.', { start: el.start });
       }
       if (ast && ast.type === 1) {
           var inlineRenderFns = generate(ast, state.options);
-          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-              .map(function (code) { return ("function(){" + code + "}"); })
-              .join(',')) + "]}");
+          return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+              .map(function (code) { return "function(){" + code + "}"; })
+              .join(',') + "]}";
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -10290,23 +9920,23 @@
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
+          var parent_2 = el.parent;
+          while (parent_2) {
+              if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                  parent_2.for) {
                   needsForceUpdate = true;
                   break;
               }
-              if (parent.if) {
+              if (parent_2.if) {
                   needsKey = true;
               }
-              parent = parent.parent;
+              parent_2 = parent_2.parent;
           }
       }
       var generatedSlots = Object.keys(slots)
           .map(function (key) { return genScopedSlot(slots[key], state); })
           .join(',');
-      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+      return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
   }
   function hash(str) {
       var hash = 5381;
@@ -10335,36 +9965,36 @@
       }
       var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
       var fn = "function(" + slotScope + "){" +
-          "return " + (el.tag === 'template'
+          ("return " + (el.tag === 'template'
               ? el.if && isLegacySyntax
-                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                  ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                   : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}";
+              : genElement(el, state)) + "}");
       // reverse proxy v-slot without scope on this.$slots
       var reverseProxy = slotScope ? "" : ",proxy:true";
-      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+      return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
       var children = el.children;
       if (children.length) {
-          var el$1 = children[0];
+          var el_1 = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el$1.for &&
-              el$1.tag !== 'template' &&
-              el$1.tag !== 'slot') {
-              var normalizationType = checkSkip
-                  ? state.maybeComponent(el$1)
+              el_1.for &&
+              el_1.tag !== 'template' &&
+              el_1.tag !== 'slot') {
+              var normalizationType_1 = checkSkip
+                  ? state.maybeComponent(el_1)
                       ? ",1"
                       : ",0"
                   : "";
-              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+              return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
           }
-          var normalizationType$1 = checkSkip
+          var normalizationType = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen = altGenNode || genNode;
-          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+          var gen_1 = altGenNode || genNode;
+          return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
       }
   }
   // determine the normalization needed for the children array.
@@ -10406,17 +10036,17 @@
       }
   }
   function genText(text) {
-      return ("_v(" + (text.type === 2
+      return "_v(" + (text.type === 2
           ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
   }
   function genComment(comment) {
-      return ("_e(" + (JSON.stringify(comment.text)) + ")");
+      return "_e(" + JSON.stringify(comment.text) + ")";
   }
   function genSlot(el, state) {
       var slotName = el.slotName || '"default"';
       var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? ("," + children) : '');
+      var res = "_t(" + slotName + (children ? "," + children : '');
       var attrs = el.attrs || el.dynamicAttrs
           ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
               // slot props are camelized
@@ -10425,22 +10055,22 @@
               dynamic: attr.dynamic,
           }); }))
           : null;
-      var bind$$1 = el.attrsMap['v-bind'];
-      if ((attrs || bind$$1) && !children) {
+      var bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
           res += ",null";
       }
       if (attrs) {
           res += "," + attrs;
       }
-      if (bind$$1) {
-          res += (attrs ? '' : ',null') + "," + bind$$1;
+      if (bind) {
+          res += (attrs ? '' : ',null') + "," + bind;
       }
       return res + ')';
   }
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
       var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+      return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
   }
   function genProps(props) {
       var staticProps = "";
@@ -10449,15 +10079,15 @@
           var prop = props[i];
           var value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += (prop.name) + "," + value + ",";
+              dynamicProps += prop.name + "," + value + ",";
           }
           else {
-              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+              staticProps += "\"" + prop.name + "\":" + value + ",";
           }
       }
-      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      staticProps = "{" + staticProps.slice(0, -1) + "}";
       if (dynamicProps) {
-          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+          return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
       }
       else {
           return staticProps;
@@ -10492,22 +10122,22 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  var value = node.attrsMap[name];
+          for (var name_1 in node.attrsMap) {
+              if (dirRE.test(name_1)) {
+                  var value = node.attrsMap[name_1];
                   if (value) {
-                      var range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                      var range = node.rawAttrsMap[name_1];
+                      if (name_1 === 'v-for') {
+                          checkFor(node, "v-for=\"" + value + "\"", warn, range);
                       }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                          checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                      else if (onRE.test(name_1)) {
+                          checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
                       else {
-                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                          checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
                   }
               }
@@ -10527,7 +10157,7 @@
       var keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
           warn("avoid using JavaScript unary operator as property name: " +
-              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+              ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -10540,16 +10170,16 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function(("var " + ident + "=_"));
+              new Function("var " + ident + "=_");
           }
           catch (e) {
-              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+              warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function(("return " + exp));
+          new Function("return " + exp);
       }
       catch (e) {
           var keywordMatch = exp
@@ -10557,12 +10187,12 @@
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
               warn("avoid using JavaScript keyword as property name: " +
-                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                  ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
           }
           else {
-              warn("invalid expression: " + (e.message) + " in\n\n" +
-                  "    " + exp + "\n\n" +
-                  "  Raw expression: " + (text.trim()) + "\n", range);
+              warn("invalid expression: " + e.message + " in\n\n" +
+                  ("    " + exp + "\n\n") +
+                  ("  Raw expression: " + text.trim() + "\n"), range);
           }
       }
   }
@@ -10571,18 +10201,17 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-              "    " + exp + "\n\n" +
-              "  Raw expression: " + (text.trim()) + "\n", range);
+          warn("invalid function parameter expression: " + e.message + " in\n\n" +
+              ("    " + exp + "\n\n") +
+              ("  Raw expression: " + text.trim() + "\n"), range);
       }
   }
 
   /* @flow */
   var range = 2;
   function generateCodeFrame(source, start, end) {
-      if ( start === void 0 ) start = 0;
-      if ( end === void 0 ) end = source.length;
-
+      if (start === void 0) { start = 0; }
+      if (end === void 0) { end = source.length; }
       var lines = source.split(/\r?\n/);
       var count = 0;
       var res = [];
@@ -10592,18 +10221,18 @@
               for (var j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
                       { continue; }
-                  res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                  res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                   var lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
                       var pad = start - (count - lineLength) + 1;
-                      var length = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                      var length_1 = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length$1 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat$1("^", length$1));
+                          var length_2 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat("^", length_2));
                       }
                       count += lineLength + 1;
                   }
@@ -10613,7 +10242,7 @@
       }
       return res.join('\n');
   }
-  function repeat$1(str, n) {
+  function repeat(str, n) {
       var result = '';
       if (n > 0) {
           while (true) {
@@ -10643,7 +10272,7 @@
       var cache = Object.create(null);
       return function compileToFunctions(template, options, vm) {
           options = extend({}, options);
-          var warn$$1 = options.warn || warn;
+          var warn = options.warn || warn$2;
           delete options.warn;
           /* istanbul ignore if */
           {
@@ -10653,7 +10282,7 @@
               }
               catch (e) {
                   if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
                           'environment with Content Security Policy that prohibits unsafe-eval. ' +
                           'The template compiler cannot work in this environment. Consider ' +
                           'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -10675,13 +10304,13 @@
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
                       compiled.errors.forEach(function (e) {
-                          warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                          warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
-                      warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                      warn("Error compiling template:\n\n" + template + "\n\n" +
+                          compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                           '\n', vm);
                   }
               }
@@ -10707,14 +10336,12 @@
           /* istanbul ignore if */
           {
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn$$1("Failed to generate render function:\n\n" +
+                  warn("Failed to generate render function:\n\n" +
                       fnGenErrors
-                          .map(function (ref) {
-                              var err = ref.err;
-                              var code = ref.code;
-
-                              return ((err.toString()) + " in\n\n" + code + "\n");
-                  })
+                          .map(function (_a) {
+                          var err = _a.err, code = _a.code;
+                          return err.toString() + " in\n\n" + code + "\n";
+                      })
                           .join('\n'), vm);
               }
           }
@@ -10735,15 +10362,15 @@
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                       warn = function (msg, range, tip) {
                           var data = { msg: msg };
                           if (range) {
                               if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
+                                  data.start = range.start + leadingSpaceLength_1;
                               }
                               if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
+                                  data.end = range.end + leadingSpaceLength_1;
                               }
                           }
                           (tip ? tips : errors).push(data);
@@ -10798,9 +10425,7 @@
   });
 
   /* @flow */
-  var ref$1 = createCompiler(baseOptions);
-  var compile = ref$1.compile;
-  var compileToFunctions = ref$1.compileToFunctions;
+  var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
   /* @flow */
   // check whether current browser encodes a char inside attribute values
@@ -10827,7 +10452,7 @@
       el = el && query(el);
       /* istanbul ignore if */
       if (el === document.body || el === document.documentElement) {
-          warn("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+          warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
           return this;
       }
       var options = this.$options;
@@ -10840,7 +10465,7 @@
                       template = idToTemplate(template);
                       /* istanbul ignore if */
                       if (!template) {
-                          warn(("Template element not found or is empty: " + (options.template)), this);
+                          warn$2("Template element not found or is empty: " + options.template, this);
                       }
                   }
               }
@@ -10849,7 +10474,7 @@
               }
               else {
                   {
-                      warn('invalid template option:' + template, this);
+                      warn$2('invalid template option:' + template, this);
                   }
                   return this;
               }
@@ -10863,21 +10488,19 @@
               if (config.performance && mark) {
                   mark('compile');
               }
-              var ref = compileToFunctions(template, {
+              var _a = compileToFunctions(template, {
                   outputSourceRange: "development" !== 'production',
                   shouldDecodeNewlines: shouldDecodeNewlines,
                   shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                   delimiters: options.delimiters,
                   comments: options.comments,
-              }, this);
-              var render = ref.render;
-              var staticRenderFns = ref.staticRenderFns;
+              }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
               options.render = render;
               options.staticRenderFns = staticRenderFns;
               /* istanbul ignore if */
               if (config.performance && mark) {
                   mark('compile end');
-                  measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+                  measure("vue " + this._name + " compile", 'compile', 'compile end');
               }
           }
       }
@@ -10901,4 +10524,4 @@
 
   return Vue;
 
-}));
+})));
diff --git a/dist/vue.min.js b/dist/vue.min.js
index e9fd8446ac2..d6f19e63635 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(e,r){"object"==typeof exports&&"undefined"!=typeof module?module.exports=r():"function"==typeof define&&define.amd?define(r):(e=e||self).Vue=r()}(this,function(){"use strict";var e=Object.freeze({});function r(e){return null==e}function t(e){return null!=e}function n(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var i=Object.prototype.toString;function s(e){return"[object Object]"===i.call(e)}function c(e){var r=parseFloat(String(e));return r>=0&&Math.floor(r)===r&&isFinite(e)}function u(e){return t(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===i?JSON.stringify(e,null,2):String(e)}function p(e){var r=parseFloat(e);return isNaN(r)?e:r}function f(e,r){for(var t=Object.create(null),n=e.split(","),a=0;a<n.length;a++)t[n[a]]=!0;return r?function(e){return t[e.toLowerCase()]}:function(e){return t[e]}}var d=f("slot,component",!0),m=f("key,ref,slot,slot-scope,is");function h(e,r){if(e.length){var t=e.indexOf(r);if(t>-1)return e.splice(t,1)}}var v=Object.prototype.hasOwnProperty;function g(e,r){return v.call(e,r)}function b(e){var r=Object.create(null);return function(t){return r[t]||(r[t]=e(t))}}var y=/-(\w)/g,w=b(function(e){return e.replace(y,function(e,r){return r?r.toUpperCase():""})}),A=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),D=/\B([A-Z])/g,x=b(function(e){return e.replace(D,"-$1").toLowerCase()});var q=Function.prototype.bind?function(e,r){return e.bind(r)}:function(e,r){function t(t){var n=arguments.length;return n?n>1?e.apply(r,arguments):e.call(r,t):e.call(r)}return t._length=e.length,t};function k(e,r){r=r||0;for(var t=e.length-r,n=new Array(t);t--;)n[t]=e[t+r];return n}function E(e,r){for(var t in r)e[t]=r[t];return e}function _(e){for(var r={},t=0;t<e.length;t++)e[t]&&E(r,e[t]);return r}function C(e,r,t){}var S=function(e,r,t){return!1},L=function(e){return e};function T(e,r){if(e===r)return!0;var t=o(e),n=o(r);if(!t||!n)return!t&&!n&&String(e)===String(r);try{var a=Array.isArray(e),i=Array.isArray(r);if(a&&i)return e.length===r.length&&e.every(function(e,t){return T(e,r[t])});if(e instanceof Date&&r instanceof Date)return e.getTime()===r.getTime();if(a||i)return!1;var s=Object.keys(e),c=Object.keys(r);return s.length===c.length&&s.every(function(t){return T(e[t],r[t])})}catch(e){return!1}}function $(e,r){for(var t=0;t<e.length;t++)if(T(e[t],r))return t;return-1}function N(e){var r=!1;return function(){r||(r=!0,e.apply(this,arguments))}}var O="data-server-rendered",R=["component","directive","filter"],F=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],B={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:C,parsePlatformTagName:L,mustUseProp:S,async:!0,_lifecycleHooks:F},U=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function V(e,r,t,n){Object.defineProperty(e,r,{value:t,enumerable:!!n,writable:!0,configurable:!0})}var I=new RegExp("[^"+U.source+".$_\\d]");var j,P="__proto__"in{},H="undefined"!=typeof window,M="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,G=M&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),J=z&&/msie|trident/.test(z),K=z&&z.indexOf("msie 9.0")>0,Z=z&&z.indexOf("edge/")>0,Y=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===G),W=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Q={}.watch,X=!1;if(H)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){X=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var re=function(){return void 0===j&&(j=!H&&!M&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),j},te=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ne(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,oe="undefined"!=typeof Symbol&&ne(Symbol)&&"undefined"!=typeof Reflect&&ne(Reflect.ownKeys);ae="undefined"!=typeof Set&&ne(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ie=C,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),r=0,t=e.length;r<t;r++)e[r].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function pe(){ue.pop(),ce.target=ue[ue.length-1]}var fe=function(e,r,t,n,a,o,i,s){this.tag=e,this.data=r,this.children=t,this.text=n,this.elm=a,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=r&&r.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(fe.prototype,de);var me=function(e){void 0===e&&(e="");var r=new fe;return r.text=e,r.isComment=!0,r};function he(e){return new fe(void 0,void 0,void 0,String(e))}function ve(e){var r=new fe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return r.ns=e.ns,r.isStatic=e.isStatic,r.key=e.key,r.isComment=e.isComment,r.fnContext=e.fnContext,r.fnOptions=e.fnOptions,r.fnScopeId=e.fnScopeId,r.asyncMeta=e.asyncMeta,r.isCloned=!0,r}var ge=Array.prototype,be=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var r=ge[e];V(be,e,function(){for(var t=[],n=arguments.length;n--;)t[n]=arguments[n];var a,o=r.apply(this,t),i=this.__ob__;switch(e){case"push":case"unshift":a=t;break;case"splice":a=t.slice(2)}return a&&i.observeArray(a),i.dep.notify(),o})});var ye=Object.getOwnPropertyNames(be),we=!0;function Ae(e){we=e}var De=function(e){var r;this.value=e,this.dep=new ce,this.vmCount=0,V(e,"__ob__",this),Array.isArray(e)?(P?(r=be,e.__proto__=r):function(e,r,t){for(var n=0,a=t.length;n<a;n++){var o=t[n];V(e,o,r[o])}}(e,be,ye),this.observeArray(e)):this.walk(e)};function xe(e,r){var t;if(o(e)&&!(e instanceof fe))return g(e,"__ob__")&&e.__ob__ instanceof De?t=e.__ob__:we&&!re()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(t=new De(e)),r&&t&&t.vmCount++,t}function qe(e,r,t,n,a){var o=new ce,i=Object.getOwnPropertyDescriptor(e,r);if(!i||!1!==i.configurable){var s=i&&i.get,c=i&&i.set;s&&!c||2!==arguments.length||(t=e[r]);var u=!a&&xe(t);Object.defineProperty(e,r,{enumerable:!0,configurable:!0,get:function(){var r=s?s.call(e):t;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(r)&&function e(r){for(var t=void 0,n=0,a=r.length;n<a;n++)(t=r[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&e(t)}(r))),r},set:function(r){var n=s?s.call(e):t;r===n||r!=r&&n!=n||s&&!c||(c?c.call(e,r):t=r,u=!a&&xe(r),o.notify())}})}}function ke(e,r,t){if(Array.isArray(e)&&c(r))return e.length=Math.max(e.length,r),e.splice(r,1,t),t;if(r in e&&!(r in Object.prototype))return e[r]=t,t;var n=e.__ob__;return e._isVue||n&&n.vmCount?t:n?(qe(n.value,r,t),n.dep.notify(),t):(e[r]=t,t)}function Ee(e,r){if(Array.isArray(e)&&c(r))e.splice(r,1);else{var t=e.__ob__;e._isVue||t&&t.vmCount||g(e,r)&&(delete e[r],t&&t.dep.notify())}}De.prototype.walk=function(e){for(var r=Object.keys(e),t=0;t<r.length;t++)qe(e,r[t])},De.prototype.observeArray=function(e){for(var r=0,t=e.length;r<t;r++)xe(e[r])};var _e=B.optionMergeStrategies;function Ce(e,r){if(!r)return e;for(var t,n,a,o=oe?Reflect.ownKeys(r):Object.keys(r),i=0;i<o.length;i++)"__ob__"!==(t=o[i])&&(n=e[t],a=r[t],g(e,t)?n!==a&&s(n)&&s(a)&&Ce(n,a):ke(e,t,a));return e}function Se(e,r,t){return t?function(){var n="function"==typeof r?r.call(t,t):r,a="function"==typeof e?e.call(t,t):e;return n?Ce(n,a):a}:r?e?function(){return Ce("function"==typeof r?r.call(this,this):r,"function"==typeof e?e.call(this,this):e)}:r:e}function Le(e,r){var t=r?e?e.concat(r):Array.isArray(r)?r:[r]:e;return t?function(e){for(var r=[],t=0;t<e.length;t++)-1===r.indexOf(e[t])&&r.push(e[t]);return r}(t):t}function Te(e,r,t,n){var a=Object.create(e||null);return r?E(a,r):a}_e.data=function(e,r,t){return t?Se(e,r,t):r&&"function"!=typeof r?e:Se(e,r)},F.forEach(function(e){_e[e]=Le}),R.forEach(function(e){_e[e+"s"]=Te}),_e.watch=function(e,r,t,n){if(e===Q&&(e=void 0),r===Q&&(r=void 0),!r)return Object.create(e||null);if(!e)return r;var a={};for(var o in E(a,e),r){var i=a[o],s=r[o];i&&!Array.isArray(i)&&(i=[i]),a[o]=i?i.concat(s):Array.isArray(s)?s:[s]}return a},_e.props=_e.methods=_e.inject=_e.computed=function(e,r,t,n){if(!e)return r;var a=Object.create(null);return E(a,e),r&&E(a,r),a},_e.provide=Se;var $e=function(e,r){return void 0===r?e:r};function Ne(e,r,t){if("function"==typeof r&&(r=r.options),function(e,r){var t=e.props;if(t){var n,a,o={};if(Array.isArray(t))for(n=t.length;n--;)"string"==typeof(a=t[n])&&(o[w(a)]={type:null});else if(s(t))for(var i in t)a=t[i],o[w(i)]=s(a)?a:{type:a};e.props=o}}(r),function(e,r){var t=e.inject;if(t){var n=e.inject={};if(Array.isArray(t))for(var a=0;a<t.length;a++)n[t[a]]={from:t[a]};else if(s(t))for(var o in t){var i=t[o];n[o]=s(i)?E({from:o},i):{from:i}}}}(r),function(e){var r=e.directives;if(r)for(var t in r){var n=r[t];"function"==typeof n&&(r[t]={bind:n,update:n})}}(r),!r._base&&(r.extends&&(e=Ne(e,r.extends,t)),r.mixins))for(var n=0,a=r.mixins.length;n<a;n++)e=Ne(e,r.mixins[n],t);var o,i={};for(o in e)c(o);for(o in r)g(e,o)||c(o);function c(n){var a=_e[n]||$e;i[n]=a(e[n],r[n],t,n)}return i}function Oe(e,r,t,n){if("string"==typeof t){var a=e[r];if(g(a,t))return a[t];var o=w(t);if(g(a,o))return a[o];var i=A(o);return g(a,i)?a[i]:a[t]||a[o]||a[i]}}function Re(e,r,t,n){var a=r[e],o=!g(t,e),i=t[e],s=Ve(Boolean,a.type);if(s>-1)if(o&&!g(a,"default"))i=!1;else if(""===i||i===x(e)){var c=Ve(String,a.type);(c<0||s<c)&&(i=!0)}if(void 0===i){i=function(e,r,t){if(!g(r,"default"))return;var n=r.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[t]&&void 0!==e._props[t])return e._props[t];return"function"==typeof n&&"Function"!==Be(r.type)?n.call(e):n}(n,a,e);var u=we;Ae(!0),xe(i),Ae(u)}return i}var Fe=/^\s*function (\w+)/;function Be(e){var r=e&&e.toString().match(Fe);return r?r[1]:""}function Ue(e,r){return Be(e)===Be(r)}function Ve(e,r){if(!Array.isArray(r))return Ue(r,e)?0:-1;for(var t=0,n=r.length;t<n;t++)if(Ue(r[t],e))return t;return-1}function Ie(e,r,t){le();try{if(r)for(var n=r;n=n.$parent;){var a=n.$options.errorCaptured;if(a)for(var o=0;o<a.length;o++)try{if(!1===a[o].call(n,e,r,t))return}catch(e){Pe(e,n,"errorCaptured hook")}}Pe(e,r,t)}finally{pe()}}function je(e,r,t,n,a){var o;try{(o=t?e.apply(r,t):e.call(r))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Ie(e,n,a+" (Promise/async)")}),o._handled=!0)}catch(e){Ie(e,n,a)}return o}function Pe(e,r,t){if(B.errorHandler)try{return B.errorHandler.call(null,e,r,t)}catch(r){r!==e&&He(r,null,"config.errorHandler")}He(e,r,t)}function He(e,r,t){if(!H&&!M||"undefined"==typeof console)throw e;console.error(e)}var Me,Ge=!1,ze=[],Je=!1;function Ke(){Je=!1;var e=ze.slice(0);ze.length=0;for(var r=0;r<e.length;r++)e[r]()}if("undefined"!=typeof Promise&&ne(Promise)){var Ze=Promise.resolve();Me=function(){Ze.then(Ke),Y&&setTimeout(C)},Ge=!0}else if(J||"undefined"==typeof MutationObserver||!ne(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Me="undefined"!=typeof setImmediate&&ne(setImmediate)?function(){setImmediate(Ke)}:function(){setTimeout(Ke,0)};else{var Ye=1,We=new MutationObserver(Ke),Qe=document.createTextNode(String(Ye));We.observe(Qe,{characterData:!0}),Me=function(){Ye=(Ye+1)%2,Qe.data=String(Ye)},Ge=!0}function Xe(e,r){var t;if(ze.push(function(){if(e)try{e.call(r)}catch(e){Ie(e,r,"nextTick")}else t&&t(r)}),Je||(Je=!0,Me()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){t=e})}var er=new ae;function rr(e){!function e(r,t){var n,a;var i=Array.isArray(r);if(!i&&!o(r)||Object.isFrozen(r)||r instanceof fe)return;if(r.__ob__){var s=r.__ob__.dep.id;if(t.has(s))return;t.add(s)}if(i)for(n=r.length;n--;)e(r[n],t);else for(a=Object.keys(r),n=a.length;n--;)e(r[a[n]],t)}(e,er),er.clear()}var tr=b(function(e){var r="&"===e.charAt(0),t="~"===(e=r?e.slice(1):e).charAt(0),n="!"===(e=t?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:t,capture:n,passive:r}});function nr(e,r){function t(){var e=arguments,n=t.fns;if(!Array.isArray(n))return je(n,null,arguments,r,"v-on handler");for(var a=n.slice(),o=0;o<a.length;o++)je(a[o],null,e,r,"v-on handler")}return t.fns=e,t}function ar(e,t,a,o,i,s){var c,u,l,p;for(c in e)u=e[c],l=t[c],p=tr(c),r(u)||(r(l)?(r(u.fns)&&(u=e[c]=nr(u,s)),n(p.once)&&(u=e[c]=i(p.name,u,p.capture)),a(p.name,u,p.capture,p.passive,p.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)r(e[c])&&o((p=tr(c)).name,t[c],p.capture)}function or(e,a,o){var i;e instanceof fe&&(e=e.data.hook||(e.data.hook={}));var s=e[a];function c(){o.apply(this,arguments),h(i.fns,c)}r(s)?i=nr([c]):t(s.fns)&&n(s.merged)?(i=s).fns.push(c):i=nr([s,c]),i.merged=!0,e[a]=i}function ir(e,r,n,a,o){if(t(r)){if(g(r,n))return e[n]=r[n],o||delete r[n],!0;if(g(r,a))return e[n]=r[a],o||delete r[a],!0}return!1}function sr(e){return a(e)?[he(e)]:Array.isArray(e)?function e(o,i){var s=[];var c,u,l,p;for(c=0;c<o.length;c++)r(u=o[c])||"boolean"==typeof u||(l=s.length-1,p=s[l],Array.isArray(u)?u.length>0&&(cr((u=e(u,(i||"")+"_"+c))[0])&&cr(p)&&(s[l]=he(p.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?cr(p)?s[l]=he(p.text+u):""!==u&&s.push(he(u)):cr(u)&&cr(p)?s[l]=he(p.text+u.text):(n(o._isVList)&&t(u.tag)&&r(u.key)&&t(i)&&(u.key="__vlist"+i+"_"+c+"__"),s.push(u)));return s}(e):void 0}function cr(e){return t(e)&&t(e.text)&&!1===e.isComment}function ur(e,r){if(e){for(var t=Object.create(null),n=oe?Reflect.ownKeys(e):Object.keys(e),a=0;a<n.length;a++){var o=n[a];if("__ob__"!==o){for(var i=e[o].from,s=r;s;){if(s._provided&&g(s._provided,i)){t[o]=s._provided[i];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;t[o]="function"==typeof c?c.call(r):c}}}return t}}function lr(e,r){if(!e||!e.length)return{};for(var t={},n=0,a=e.length;n<a;n++){var o=e[n],i=o.data;if(i&&i.attrs&&i.attrs.slot&&delete i.attrs.slot,o.context!==r&&o.fnContext!==r||!i||null==i.slot)(t.default||(t.default=[])).push(o);else{var s=i.slot,c=t[s]||(t[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in t)t[u].every(pr)&&delete t[u];return t}function pr(e){return e.isComment&&!e.asyncFactory||" "===e.text}function fr(r,t,n){var a,o=Object.keys(t).length>0,i=r?!!r.$stable:!o,s=r&&r.$key;if(r){if(r._normalized)return r._normalized;if(i&&n&&n!==e&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in a={},r)r[c]&&"$"!==c[0]&&(a[c]=dr(t,c,r[c]))}else a={};for(var u in t)u in a||(a[u]=mr(t,u));return r&&Object.isExtensible(r)&&(r._normalized=a),V(a,"$stable",i),V(a,"$key",s),V(a,"$hasNormal",o),a}function dr(e,r,t){var n=function(){var e=arguments.length?t.apply(null,arguments):t({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:sr(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return t.proxy&&Object.defineProperty(e,r,{get:n,enumerable:!0,configurable:!0}),n}function mr(e,r){return function(){return e[r]}}function hr(e,r){var n,a,i,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,a=e.length;n<a;n++)c[n]=r(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=r(n+1,n);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(r(l.value,c.length)),l=u.next()}else for(i=Object.keys(e),c=new Array(i.length),n=0,a=i.length;n<a;n++)s=i[n],c[n]=r(e[s],s,n);return t(c)||(c=[]),c._isVList=!0,c}function vr(e,r,t,n){var a,o=this.$scopedSlots[e];o?(t=t||{},n&&(t=E(E({},n),t)),a=o(t)||r):a=this.$slots[e]||r;var i=t&&t.slot;return i?this.$createElement("template",{slot:i},a):a}function gr(e){return Oe(this.$options,"filters",e)||L}function br(e,r){return Array.isArray(e)?-1===e.indexOf(r):e!==r}function yr(e,r,t,n,a){var o=B.keyCodes[r]||t;return a&&n&&!B.keyCodes[r]?br(a,n):o?br(o,e):n?x(n)!==r:void 0}function wr(e,r,t,n,a){if(t)if(o(t)){var i;Array.isArray(t)&&(t=_(t));var s=function(o){if("class"===o||"style"===o||m(o))i=e;else{var s=e.attrs&&e.attrs.type;i=n||B.mustUseProp(r,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(o),u=x(o);c in i||u in i||(i[o]=t[o],a&&((e.on||(e.on={}))["update:"+o]=function(e){t[o]=e}))};for(var c in t)s(c)}else;return e}function Ar(e,r){var t=this._staticTrees||(this._staticTrees=[]),n=t[e];return n&&!r?n:(xr(n=t[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function Dr(e,r,t){return xr(e,"__once__"+r+(t?"_"+t:""),!0),e}function xr(e,r,t){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&qr(e[n],r+"_"+n,t);else qr(e,r,t)}function qr(e,r,t){e.isStatic=!0,e.key=r,e.isOnce=t}function kr(e,r){if(r)if(s(r)){var t=e.on=e.on?E({},e.on):{};for(var n in r){var a=t[n],o=r[n];t[n]=a?[].concat(a,o):o}}else;return e}function Er(e,r,t,n){r=r||{$stable:!t};for(var a=0;a<e.length;a++){var o=e[a];Array.isArray(o)?Er(o,r,t):o&&(o.proxy&&(o.fn.proxy=!0),r[o.key]=o.fn)}return n&&(r.$key=n),r}function _r(e,r){for(var t=0;t<r.length;t+=2){var n=r[t];"string"==typeof n&&n&&(e[r[t]]=r[t+1])}return e}function Cr(e,r){return"string"==typeof e?r+e:e}function Sr(e){e._o=Dr,e._n=p,e._s=l,e._l=hr,e._t=vr,e._q=T,e._i=$,e._m=Ar,e._f=gr,e._k=yr,e._b=wr,e._v=he,e._e=me,e._u=Er,e._g=kr,e._d=_r,e._p=Cr}function Lr(r,t,a,o,i){var s,c=this,u=i.options;g(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=n(u._compiled),p=!l;this.data=r,this.props=t,this.children=a,this.parent=o,this.listeners=r.on||e,this.injections=ur(u.inject,o),this.slots=function(){return c.$slots||fr(r.scopedSlots,c.$slots=lr(a,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return fr(r.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=fr(r.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,r,t,n){var a=Vr(s,e,r,t,n,p);return a&&!Array.isArray(a)&&(a.fnScopeId=u._scopeId,a.fnContext=o),a}:this._c=function(e,r,t,n){return Vr(s,e,r,t,n,p)}}function Tr(e,r,t,n,a){var o=ve(e);return o.fnContext=t,o.fnOptions=n,r.slot&&((o.data||(o.data={})).slot=r.slot),o}function $r(e,r){for(var t in r)e[w(t)]=r[t]}Sr(Lr.prototype);var Nr={init:function(e,r){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var n=e;Nr.prepatch(n,n)}else{(e.componentInstance=function(e,r){var n={_isComponent:!0,_parentVnode:e,parent:r},a=e.data.inlineTemplate;t(a)&&(n.render=a.render,n.staticRenderFns=a.staticRenderFns);return new e.componentOptions.Ctor(n)}(e,Zr)).$mount(r?e.elm:void 0,r)}},prepatch:function(r,t){var n=t.componentOptions;!function(r,t,n,a,o){var i=a.data.scopedSlots,s=r.$scopedSlots,c=!!(i&&!i.$stable||s!==e&&!s.$stable||i&&r.$scopedSlots.$key!==i.$key),u=!!(o||r.$options._renderChildren||c);r.$options._parentVnode=a,r.$vnode=a,r._vnode&&(r._vnode.parent=a);if(r.$options._renderChildren=o,r.$attrs=a.data.attrs||e,r.$listeners=n||e,t&&r.$options.props){Ae(!1);for(var l=r._props,p=r.$options._propKeys||[],f=0;f<p.length;f++){var d=p[f],m=r.$options.props;l[d]=Re(d,m,t,r)}Ae(!0),r.$options.propsData=t}n=n||e;var h=r.$options._parentListeners;r.$options._parentListeners=n,Kr(r,n,h),u&&(r.$slots=lr(o,a.context),r.$forceUpdate())}(t.componentInstance=r.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var r,t=e.context,n=e.componentInstance;n._isMounted||(n._isMounted=!0,Xr(n,"mounted")),e.data.keepAlive&&(t._isMounted?((r=n)._inactive=!1,rt.push(r)):Qr(n,!0))},destroy:function(e){var r=e.componentInstance;r._isDestroyed||(e.data.keepAlive?function e(r,t){if(t&&(r._directInactive=!0,Wr(r)))return;if(!r._inactive){r._inactive=!0;for(var n=0;n<r.$children.length;n++)e(r.$children[n]);Xr(r,"deactivated")}}(r,!0):r.$destroy())}},Or=Object.keys(Nr);function Rr(a,i,s,c,l){if(!r(a)){var p=s.$options._base;if(o(a)&&(a=p.extend(a)),"function"==typeof a){var f;if(r(a.cid)&&void 0===(a=function(e,a){if(n(e.error)&&t(e.errorComp))return e.errorComp;if(t(e.resolved))return e.resolved;var i=jr;i&&t(e.owners)&&-1===e.owners.indexOf(i)&&e.owners.push(i);if(n(e.loading)&&t(e.loadingComp))return e.loadingComp;if(i&&!t(e.owners)){var s=e.owners=[i],c=!0,l=null,p=null;i.$on("hook:destroyed",function(){return h(s,i)});var f=function(e){for(var r=0,t=s.length;r<t;r++)s[r].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==p&&(clearTimeout(p),p=null))},d=N(function(r){e.resolved=Pr(r,a),c?s.length=0:f(!0)}),m=N(function(r){t(e.errorComp)&&(e.error=!0,f(!0))}),v=e(d,m);return o(v)&&(u(v)?r(e.resolved)&&v.then(d,m):u(v.component)&&(v.component.then(d,m),t(v.error)&&(e.errorComp=Pr(v.error,a)),t(v.loading)&&(e.loadingComp=Pr(v.loading,a),0===v.delay?e.loading=!0:l=setTimeout(function(){l=null,r(e.resolved)&&r(e.error)&&(e.loading=!0,f(!1))},v.delay||200)),t(v.timeout)&&(p=setTimeout(function(){p=null,r(e.resolved)&&m(null)},v.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(f=a,p)))return function(e,r,t,n,a){var o=me();return o.asyncFactory=e,o.asyncMeta={data:r,context:t,children:n,tag:a},o}(f,i,s,c,l);i=i||{},At(a),t(i.model)&&function(e,r){var n=e.model&&e.model.prop||"value",a=e.model&&e.model.event||"input";(r.attrs||(r.attrs={}))[n]=r.model.value;var o=r.on||(r.on={}),i=o[a],s=r.model.callback;t(i)?(Array.isArray(i)?-1===i.indexOf(s):i!==s)&&(o[a]=[s].concat(i)):o[a]=s}(a.options,i);var d=function(e,n,a){var o=n.options.props;if(!r(o)){var i={},s=e.attrs,c=e.props;if(t(s)||t(c))for(var u in o){var l=x(u);ir(i,c,u,l,!0)||ir(i,s,u,l,!1)}return i}}(i,a);if(n(a.options.functional))return function(r,n,a,o,i){var s=r.options,c={},u=s.props;if(t(u))for(var l in u)c[l]=Re(l,u,n||e);else t(a.attrs)&&$r(c,a.attrs),t(a.props)&&$r(c,a.props);var p=new Lr(a,c,i,o,r),f=s.render.call(null,p._c,p);if(f instanceof fe)return Tr(f,a,p.parent,s);if(Array.isArray(f)){for(var d=sr(f)||[],m=new Array(d.length),h=0;h<d.length;h++)m[h]=Tr(d[h],a,p.parent,s);return m}}(a,d,i,s,c);var m=i.on;if(i.on=i.nativeOn,n(a.options.abstract)){var v=i.slot;i={},v&&(i.slot=v)}!function(e){for(var r=e.hook||(e.hook={}),t=0;t<Or.length;t++){var n=Or[t],a=r[n],o=Nr[n];a===o||a&&a._merged||(r[n]=a?Fr(o,a):o)}}(i);var g=a.options.name||l;return new fe("vue-component-"+a.cid+(g?"-"+g:""),i,void 0,void 0,void 0,s,{Ctor:a,propsData:d,listeners:m,tag:l,children:c},f)}}}function Fr(e,r){var t=function(t,n){e(t,n),r(t,n)};return t._merged=!0,t}var Br=1,Ur=2;function Vr(e,i,s,c,u,l){return(Array.isArray(s)||a(s))&&(u=c,c=s,s=void 0),n(l)&&(u=Ur),function(e,a,i,s,c){if(t(i)&&t(i.__ob__))return me();t(i)&&t(i.is)&&(a=i.is);if(!a)return me();Array.isArray(s)&&"function"==typeof s[0]&&((i=i||{}).scopedSlots={default:s[0]},s.length=0);c===Ur?s=sr(s):c===Br&&(s=function(e){for(var r=0;r<e.length;r++)if(Array.isArray(e[r]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof a){var p;l=e.$vnode&&e.$vnode.ns||B.getTagNamespace(a),u=B.isReservedTag(a)?new fe(B.parsePlatformTagName(a),i,s,void 0,void 0,e):i&&i.pre||!t(p=Oe(e.$options,"components",a))?new fe(a,i,s,void 0,void 0,e):Rr(p,i,e,s,a)}else u=Rr(a,i,e,s);return Array.isArray(u)?u:t(u)?(t(l)&&function e(a,o,i){a.ns=o;"foreignObject"===a.tag&&(o=void 0,i=!0);if(t(a.children))for(var s=0,c=a.children.length;s<c;s++){var u=a.children[s];t(u.tag)&&(r(u.ns)||n(i)&&"svg"!==u.tag)&&e(u,o,i)}}(u,l),t(i)&&function(e){o(e.style)&&rr(e.style);o(e.class)&&rr(e.class)}(i),u):me()}(e,i,s,c,u)}var Ir,jr=null;function Pr(e,r){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?r.extend(e):e}function Hr(e){return e.isComment&&e.asyncFactory}function Mr(e){if(Array.isArray(e))for(var r=0;r<e.length;r++){var n=e[r];if(t(n)&&(t(n.componentOptions)||Hr(n)))return n}}function Gr(e,r){Ir.$on(e,r)}function zr(e,r){Ir.$off(e,r)}function Jr(e,r){var t=Ir;return function n(){null!==r.apply(null,arguments)&&t.$off(e,n)}}function Kr(e,r,t){Ir=e,ar(r,t||{},Gr,zr,Jr,e),Ir=void 0}var Zr=null;function Yr(e){var r=Zr;return Zr=e,function(){Zr=r}}function Wr(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Qr(e,r){if(r){if(e._directInactive=!1,Wr(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var t=0;t<e.$children.length;t++)Qr(e.$children[t]);Xr(e,"activated")}}function Xr(e,r){le();var t=e.$options[r],n=r+" hook";if(t)for(var a=0,o=t.length;a<o;a++)je(t[a],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+r),pe()}var et=[],rt=[],tt={},nt=!1,at=!1,ot=0;var it=0,st=Date.now;if(H&&!J){var ct=window.performance;ct&&"function"==typeof ct.now&&st()>document.createEvent("Event").timeStamp&&(st=function(){return ct.now()})}function ut(){var e,r;for(it=st(),at=!0,et.sort(function(e,r){return e.id-r.id}),ot=0;ot<et.length;ot++)(e=et[ot]).before&&e.before(),r=e.id,tt[r]=null,e.run();var t=rt.slice(),n=et.slice();ot=et.length=rt.length=0,tt={},nt=at=!1,function(e){for(var r=0;r<e.length;r++)e[r]._inactive=!0,Qr(e[r],!0)}(t),function(e){var r=e.length;for(;r--;){var t=e[r],n=t.vm;n._watcher===t&&n._isMounted&&!n._isDestroyed&&Xr(n,"updated")}}(n),te&&B.devtools&&te.emit("flush")}var lt=0,pt=function(e,r,t,n,a){this.vm=e,a&&(e._watcher=this),e._watchers.push(this),n?(this.deep=!!n.deep,this.user=!!n.user,this.lazy=!!n.lazy,this.sync=!!n.sync,this.before=n.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=t,this.id=++lt,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ae,this.newDepIds=new ae,this.expression="","function"==typeof r?this.getter=r:(this.getter=function(e){if(!I.test(e)){var r=e.split(".");return function(e){for(var t=0;t<r.length;t++){if(!e)return;e=e[r[t]]}return e}}}(r),this.getter||(this.getter=C)),this.value=this.lazy?void 0:this.get()};pt.prototype.get=function(){var e;le(this);var r=this.vm;try{e=this.getter.call(r,r)}catch(e){if(!this.user)throw e;Ie(e,r,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rr(e),pe(),this.cleanupDeps()}return e},pt.prototype.addDep=function(e){var r=e.id;this.newDepIds.has(r)||(this.newDepIds.add(r),this.newDeps.push(e),this.depIds.has(r)||e.addSub(this))},pt.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var r=this.deps[e];this.newDepIds.has(r.id)||r.removeSub(this)}var t=this.depIds;this.depIds=this.newDepIds,this.newDepIds=t,this.newDepIds.clear(),t=this.deps,this.deps=this.newDeps,this.newDeps=t,this.newDeps.length=0},pt.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var r=e.id;if(null==tt[r]){if(tt[r]=!0,at){for(var t=et.length-1;t>ot&&et[t].id>e.id;)t--;et.splice(t+1,0,e)}else et.push(e);nt||(nt=!0,Xe(ut))}}(this)},pt.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var r=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,r)}catch(e){Ie(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,r)}}},pt.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},pt.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},pt.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var ft={enumerable:!0,configurable:!0,get:C,set:C};function dt(e,r,t){ft.get=function(){return this[r][t]},ft.set=function(e){this[r][t]=e},Object.defineProperty(e,t,ft)}function mt(e){e._watchers=[];var r=e.$options;r.props&&function(e,r){var t=e.$options.propsData||{},n=e._props={},a=e.$options._propKeys=[];e.$parent&&Ae(!1);var o=function(o){a.push(o);var i=Re(o,r,t,e);qe(n,o,i),o in e||dt(e,"_props",o)};for(var i in r)o(i);Ae(!0)}(e,r.props),r.methods&&function(e,r){e.$options.props;for(var t in r)e[t]="function"!=typeof r[t]?C:q(r[t],e)}(e,r.methods),r.data?function(e){var r=e.$options.data;s(r=e._data="function"==typeof r?function(e,r){le();try{return e.call(r,r)}catch(e){return Ie(e,r,"data()"),{}}finally{pe()}}(r,e):r||{})||(r={});var t=Object.keys(r),n=e.$options.props,a=(e.$options.methods,t.length);for(;a--;){var o=t[a];n&&g(n,o)||(i=void 0,36!==(i=(o+"").charCodeAt(0))&&95!==i&&dt(e,"_data",o))}var i;xe(r,!0)}(e):xe(e._data={},!0),r.computed&&function(e,r){var t=e._computedWatchers=Object.create(null),n=re();for(var a in r){var o=r[a],i="function"==typeof o?o:o.get;n||(t[a]=new pt(e,i||C,C,ht)),a in e||vt(e,a,o)}}(e,r.computed),r.watch&&r.watch!==Q&&function(e,r){for(var t in r){var n=r[t];if(Array.isArray(n))for(var a=0;a<n.length;a++)yt(e,t,n[a]);else yt(e,t,n)}}(e,r.watch)}var ht={lazy:!0};function vt(e,r,t){var n=!re();"function"==typeof t?(ft.get=n?gt(r):bt(t),ft.set=C):(ft.get=t.get?n&&!1!==t.cache?gt(r):bt(t.get):C,ft.set=t.set||C),Object.defineProperty(e,r,ft)}function gt(e){return function(){var r=this._computedWatchers&&this._computedWatchers[e];if(r)return r.dirty&&r.evaluate(),ce.target&&r.depend(),r.value}}function bt(e){return function(){return e.call(this,this)}}function yt(e,r,t,n){return s(t)&&(n=t,t=t.handler),"string"==typeof t&&(t=e[t]),e.$watch(r,t,n)}var wt=0;function At(e){var r=e.options;if(e.super){var t=At(e.super);if(t!==e.superOptions){e.superOptions=t;var n=function(e){var r,t=e.options,n=e.sealedOptions;for(var a in t)t[a]!==n[a]&&(r||(r={}),r[a]=t[a]);return r}(e);n&&E(e.extendOptions,n),(r=e.options=Ne(t,e.extendOptions)).name&&(r.components[r.name]=e)}}return r}function Dt(e){this._init(e)}function xt(e){e.cid=0;var r=1;e.extend=function(e){e=e||{};var t=this,n=t.cid,a=e._Ctor||(e._Ctor={});if(a[n])return a[n];var o=e.name||t.options.name,i=function(e){this._init(e)};return(i.prototype=Object.create(t.prototype)).constructor=i,i.cid=r++,i.options=Ne(t.options,e),i.super=t,i.options.props&&function(e){var r=e.options.props;for(var t in r)dt(e.prototype,"_props",t)}(i),i.options.computed&&function(e){var r=e.options.computed;for(var t in r)vt(e.prototype,t,r[t])}(i),i.extend=t.extend,i.mixin=t.mixin,i.use=t.use,R.forEach(function(e){i[e]=t[e]}),o&&(i.options.components[o]=i),i.superOptions=t.options,i.extendOptions=e,i.sealedOptions=E({},i.options),a[n]=i,i}}function qt(e){return e&&(e.Ctor.options.name||e.tag)}function kt(e,r){return Array.isArray(e)?e.indexOf(r)>-1:"string"==typeof e?e.split(",").indexOf(r)>-1:(t=e,"[object RegExp]"===i.call(t)&&e.test(r));var t}function Et(e,r){var t=e.cache,n=e.keys,a=e._vnode;for(var o in t){var i=t[o];if(i){var s=qt(i.componentOptions);s&&!r(s)&&_t(t,o,n,a)}}}function _t(e,r,t,n){var a=e[r];!a||n&&a.tag===n.tag||a.componentInstance.$destroy(),e[r]=null,h(t,r)}!function(r){r.prototype._init=function(r){var t=this;t._uid=wt++,t._isVue=!0,r&&r._isComponent?function(e,r){var t=e.$options=Object.create(e.constructor.options),n=r._parentVnode;t.parent=r.parent,t._parentVnode=n;var a=n.componentOptions;t.propsData=a.propsData,t._parentListeners=a.listeners,t._renderChildren=a.children,t._componentTag=a.tag,r.render&&(t.render=r.render,t.staticRenderFns=r.staticRenderFns)}(t,r):t.$options=Ne(At(t.constructor),r||{},t),t._renderProxy=t,t._self=t,function(e){var r=e.$options,t=r.parent;if(t&&!r.abstract){for(;t.$options.abstract&&t.$parent;)t=t.$parent;t.$children.push(e)}e.$parent=t,e.$root=t?t.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(t),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var r=e.$options._parentListeners;r&&Kr(e,r)}(t),function(r){r._vnode=null,r._staticTrees=null;var t=r.$options,n=r.$vnode=t._parentVnode,a=n&&n.context;r.$slots=lr(t._renderChildren,a),r.$scopedSlots=e,r._c=function(e,t,n,a){return Vr(r,e,t,n,a,!1)},r.$createElement=function(e,t,n,a){return Vr(r,e,t,n,a,!0)};var o=n&&n.data;qe(r,"$attrs",o&&o.attrs||e,null,!0),qe(r,"$listeners",t._parentListeners||e,null,!0)}(t),Xr(t,"beforeCreate"),function(e){var r=ur(e.$options.inject,e);r&&(Ae(!1),Object.keys(r).forEach(function(t){qe(e,t,r[t])}),Ae(!0))}(t),mt(t),function(e){var r=e.$options.provide;r&&(e._provided="function"==typeof r?r.call(e):r)}(t),Xr(t,"created"),t.$options.el&&t.$mount(t.$options.el)}}(Dt),function(e){var r={get:function(){return this._data}},t={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",r),Object.defineProperty(e.prototype,"$props",t),e.prototype.$set=ke,e.prototype.$delete=Ee,e.prototype.$watch=function(e,r,t){if(s(r))return yt(this,e,r,t);(t=t||{}).user=!0;var n=new pt(this,e,r,t);if(t.immediate){le();try{r.call(this,n.value)}catch(e){Ie(e,this,'callback for immediate watcher "'+n.expression+'"')}pe()}return function(){n.teardown()}}}(Dt),function(e){var r=/^hook:/;e.prototype.$on=function(e,t){var n=this;if(Array.isArray(e))for(var a=0,o=e.length;a<o;a++)n.$on(e[a],t);else(n._events[e]||(n._events[e]=[])).push(t),r.test(e)&&(n._hasHookEvent=!0);return n},e.prototype.$once=function(e,r){var t=this;function n(){t.$off(e,n),r.apply(t,arguments)}return n.fn=r,t.$on(e,n),t},e.prototype.$off=function(e,r){var t=this;if(!arguments.length)return t._events=Object.create(null),t;if(Array.isArray(e)){for(var n=0,a=e.length;n<a;n++)t.$off(e[n],r);return t}var o,i=t._events[e];if(!i)return t;if(!r)return t._events[e]=null,t;for(var s=i.length;s--;)if((o=i[s])===r||o.fn===r){i.splice(s,1);break}return t},e.prototype.$emit=function(e){var r=this._events[e];if(r){r=r.length>1?k(r):r;for(var t=k(arguments,1),n='event handler for "'+e+'"',a=0,o=r.length;a<o;a++)je(r[a],this,t,this,n)}return this}}(Dt),function(e){e.prototype._update=function(e,r){var t=this,n=t.$el,a=t._vnode,o=Yr(t);t._vnode=e,t.$el=a?t.__patch__(a,e):t.__patch__(t.$el,e,r,!1),o(),n&&(n.__vue__=null),t.$el&&(t.$el.__vue__=t),t.$vnode&&t.$parent&&t.$vnode===t.$parent._vnode&&(t.$parent.$el=t.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Xr(e,"beforeDestroy"),e._isBeingDestroyed=!0;var r=e.$parent;!r||r._isBeingDestroyed||e.$options.abstract||h(r.$children,e),e._watcher&&e._watcher.teardown();for(var t=e._watchers.length;t--;)e._watchers[t].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Xr(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(Dt),function(e){Sr(e.prototype),e.prototype.$nextTick=function(e){return Xe(e,this)},e.prototype._render=function(){var e,r=this,t=r.$options,n=t.render,a=t._parentVnode;a&&(r.$scopedSlots=fr(a.data.scopedSlots,r.$slots,r.$scopedSlots)),r.$vnode=a;try{jr=r,e=n.call(r._renderProxy,r.$createElement)}catch(t){Ie(t,r,"render"),e=r._vnode}finally{jr=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof fe||(e=me()),e.parent=a,e}}(Dt);var Ct=[String,RegExp,Array],St={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Ct,exclude:Ct,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)_t(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(r){Et(e,function(e){return kt(r,e)})}),this.$watch("exclude",function(r){Et(e,function(e){return!kt(r,e)})})},render:function(){var e=this.$slots.default,r=Mr(e),t=r&&r.componentOptions;if(t){var n=qt(t),a=this.include,o=this.exclude;if(a&&(!n||!kt(a,n))||o&&n&&kt(o,n))return r;var i=this.cache,s=this.keys,c=null==r.key?t.Ctor.cid+(t.tag?"::"+t.tag:""):r.key;i[c]?(r.componentInstance=i[c].componentInstance,h(s,c),s.push(c)):(i[c]=r,s.push(c),this.max&&s.length>parseInt(this.max)&&_t(i,s[0],s,this._vnode)),r.data.keepAlive=!0}return r||e&&e[0]}}};!function(e){var r={get:function(){return B}};Object.defineProperty(e,"config",r),e.util={warn:ie,extend:E,mergeOptions:Ne,defineReactive:qe},e.set=ke,e.delete=Ee,e.nextTick=Xe,e.observable=function(e){return xe(e),e},e.options=Object.create(null),R.forEach(function(r){e.options[r+"s"]=Object.create(null)}),e.options._base=e,E(e.options.components,St),function(e){e.use=function(e){var r=this._installedPlugins||(this._installedPlugins=[]);if(r.indexOf(e)>-1)return this;var t=k(arguments,1);return t.unshift(this),"function"==typeof e.install?e.install.apply(e,t):"function"==typeof e&&e.apply(null,t),r.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Ne(this.options,e),this}}(e),xt(e),function(e){R.forEach(function(r){e[r]=function(e,t){return t?("component"===r&&s(t)&&(t.name=t.name||e,t=this.options._base.extend(t)),"directive"===r&&"function"==typeof t&&(t={bind:t,update:t}),this.options[r+"s"][e]=t,t):this.options[r+"s"][e]}})}(e)}(Dt),Object.defineProperty(Dt.prototype,"$isServer",{get:re}),Object.defineProperty(Dt.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Dt,"FunctionalRenderContext",{value:Lr}),Dt.version="2.6.12";var Lt=f("style,class"),Tt=f("input,textarea,option,select,progress"),$t=function(e,r,t){return"value"===t&&Tt(e)&&"button"!==r||"selected"===t&&"option"===e||"checked"===t&&"input"===e||"muted"===t&&"video"===e},Nt=f("contenteditable,draggable,spellcheck"),Ot=f("events,caret,typing,plaintext-only"),Rt=function(e,r){return It(r)||"false"===r?"false":"contenteditable"===e&&Ot(r)?r:"true"},Ft=f("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Bt="http://www.w3.org/1999/xlink",Ut=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Vt=function(e){return Ut(e)?e.slice(6,e.length):""},It=function(e){return null==e||!1===e};function jt(e){for(var r=e.data,n=e,a=e;t(a.componentInstance);)(a=a.componentInstance._vnode)&&a.data&&(r=Pt(a.data,r));for(;t(n=n.parent);)n&&n.data&&(r=Pt(r,n.data));return function(e,r){if(t(e)||t(r))return Ht(e,Mt(r));return""}(r.staticClass,r.class)}function Pt(e,r){return{staticClass:Ht(e.staticClass,r.staticClass),class:t(e.class)?[e.class,r.class]:r.class}}function Ht(e,r){return e?r?e+" "+r:e:r||""}function Mt(e){return Array.isArray(e)?function(e){for(var r,n="",a=0,o=e.length;a<o;a++)t(r=Mt(e[a]))&&""!==r&&(n&&(n+=" "),n+=r);return n}(e):o(e)?function(e){var r="";for(var t in e)e[t]&&(r&&(r+=" "),r+=t);return r}(e):"string"==typeof e?e:""}var Gt={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zt=f("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Jt=f("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Kt=function(e){return zt(e)||Jt(e)};function Zt(e){return Jt(e)?"svg":"math"===e?"math":void 0}var Yt=Object.create(null);var Wt=f("text,number,password,search,email,tel,url");function Qt(e){if("string"==typeof e){var r=document.querySelector(e);return r||document.createElement("div")}return e}var Xt=Object.freeze({createElement:function(e,r){var t=document.createElement(e);return"select"!==e?t:(r.data&&r.data.attrs&&void 0!==r.data.attrs.multiple&&t.setAttribute("multiple","multiple"),t)},createElementNS:function(e,r){return document.createElementNS(Gt[e],r)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,r,t){e.insertBefore(r,t)},removeChild:function(e,r){e.removeChild(r)},appendChild:function(e,r){e.appendChild(r)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,r){e.textContent=r},setStyleScope:function(e,r){e.setAttribute(r,"")}}),en={create:function(e,r){rn(r)},update:function(e,r){e.data.ref!==r.data.ref&&(rn(e,!0),rn(r))},destroy:function(e){rn(e,!0)}};function rn(e,r){var n=e.data.ref;if(t(n)){var a=e.context,o=e.componentInstance||e.elm,i=a.$refs;r?Array.isArray(i[n])?h(i[n],o):i[n]===o&&(i[n]=void 0):e.data.refInFor?Array.isArray(i[n])?i[n].indexOf(o)<0&&i[n].push(o):i[n]=[o]:i[n]=o}}var tn=new fe("",{},[]),nn=["create","activate","update","remove","destroy"];function an(e,a){return e.key===a.key&&(e.tag===a.tag&&e.isComment===a.isComment&&t(e.data)===t(a.data)&&function(e,r){if("input"!==e.tag)return!0;var n,a=t(n=e.data)&&t(n=n.attrs)&&n.type,o=t(n=r.data)&&t(n=n.attrs)&&n.type;return a===o||Wt(a)&&Wt(o)}(e,a)||n(e.isAsyncPlaceholder)&&e.asyncFactory===a.asyncFactory&&r(a.asyncFactory.error))}function on(e,r,n){var a,o,i={};for(a=r;a<=n;++a)t(o=e[a].key)&&(i[o]=a);return i}var sn={create:cn,update:cn,destroy:function(e){cn(e,tn)}};function cn(e,r){(e.data.directives||r.data.directives)&&function(e,r){var t,n,a,o=e===tn,i=r===tn,s=ln(e.data.directives,e.context),c=ln(r.data.directives,r.context),u=[],l=[];for(t in c)n=s[t],a=c[t],n?(a.oldValue=n.value,a.oldArg=n.arg,fn(a,"update",r,e),a.def&&a.def.componentUpdated&&l.push(a)):(fn(a,"bind",r,e),a.def&&a.def.inserted&&u.push(a));if(u.length){var p=function(){for(var t=0;t<u.length;t++)fn(u[t],"inserted",r,e)};o?or(r,"insert",p):p()}l.length&&or(r,"postpatch",function(){for(var t=0;t<l.length;t++)fn(l[t],"componentUpdated",r,e)});if(!o)for(t in s)c[t]||fn(s[t],"unbind",e,e,i)}(e,r)}var un=Object.create(null);function ln(e,r){var t,n,a=Object.create(null);if(!e)return a;for(t=0;t<e.length;t++)(n=e[t]).modifiers||(n.modifiers=un),a[pn(n)]=n,n.def=Oe(r.$options,"directives",n.name);return a}function pn(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fn(e,r,t,n,a){var o=e.def&&e.def[r];if(o)try{o(t.elm,e,t,n,a)}catch(n){Ie(n,t.context,"directive "+e.name+" "+r+" hook")}}var dn=[en,sn];function mn(e,n){var a=n.componentOptions;if(!(t(a)&&!1===a.Ctor.options.inheritAttrs||r(e.data.attrs)&&r(n.data.attrs))){var o,i,s=n.elm,c=e.data.attrs||{},u=n.data.attrs||{};for(o in t(u.__ob__)&&(u=n.data.attrs=E({},u)),u)i=u[o],c[o]!==i&&hn(s,o,i,n.data.pre);for(o in(J||Z)&&u.value!==c.value&&hn(s,"value",u.value),c)r(u[o])&&(Ut(o)?s.removeAttributeNS(Bt,Vt(o)):Nt(o)||s.removeAttribute(o))}}function hn(e,r,t,n){n||e.tagName.indexOf("-")>-1?vn(e,r,t):Ft(r)?It(t)?e.removeAttribute(r):(t="allowfullscreen"===r&&"EMBED"===e.tagName?"true":r,e.setAttribute(r,t)):Nt(r)?e.setAttribute(r,Rt(r,t)):Ut(r)?It(t)?e.removeAttributeNS(Bt,Vt(r)):e.setAttributeNS(Bt,r,t):vn(e,r,t)}function vn(e,r,t){if(It(t))e.removeAttribute(r);else{if(J&&!K&&"TEXTAREA"===e.tagName&&"placeholder"===r&&""!==t&&!e.__ieph){var n=function(r){r.stopImmediatePropagation(),e.removeEventListener("input",n)};e.addEventListener("input",n),e.__ieph=!0}e.setAttribute(r,t)}}var gn={create:mn,update:mn};function bn(e,n){var a=n.elm,o=n.data,i=e.data;if(!(r(o.staticClass)&&r(o.class)&&(r(i)||r(i.staticClass)&&r(i.class)))){var s=jt(n),c=a._transitionClasses;t(c)&&(s=Ht(s,Mt(c))),s!==a._prevClass&&(a.setAttribute("class",s),a._prevClass=s)}}var yn,wn,An,Dn,xn,qn,kn={create:bn,update:bn},En=/[\w).+\-_$\]]/;function _n(e){var r,t,n,a,o,i=!1,s=!1,c=!1,u=!1,l=0,p=0,f=0,d=0;for(n=0;n<e.length;n++)if(t=r,r=e.charCodeAt(n),i)39===r&&92!==t&&(i=!1);else if(s)34===r&&92!==t&&(s=!1);else if(c)96===r&&92!==t&&(c=!1);else if(u)47===r&&92!==t&&(u=!1);else if(124!==r||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||p||f){switch(r){case 34:s=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:f++;break;case 41:f--;break;case 91:p++;break;case 93:p--;break;case 123:l++;break;case 125:l--}if(47===r){for(var m=n-1,h=void 0;m>=0&&" "===(h=e.charAt(m));m--);h&&En.test(h)||(u=!0)}}else void 0===a?(d=n+1,a=e.slice(0,n).trim()):v();function v(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===a?a=e.slice(0,n).trim():0!==d&&v(),o)for(n=0;n<o.length;n++)a=Cn(a,o[n]);return a}function Cn(e,r){var t=r.indexOf("(");if(t<0)return'_f("'+r+'")('+e+")";var n=r.slice(0,t),a=r.slice(t+1);return'_f("'+n+'")('+e+(")"!==a?","+a:a)}function Sn(e,r){console.error("[Vue compiler]: "+e)}function Ln(e,r){return e?e.map(function(e){return e[r]}).filter(function(e){return e}):[]}function Tn(e,r,t,n,a){(e.props||(e.props=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function $n(e,r,t,n,a){(a?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(In({name:r,value:t,dynamic:a},n)),e.plain=!1}function Nn(e,r,t,n){e.attrsMap[r]=t,e.attrsList.push(In({name:r,value:t},n))}function On(e,r,t,n,a,o,i,s){(e.directives||(e.directives=[])).push(In({name:r,rawName:t,value:n,arg:a,isDynamicArg:o,modifiers:i},s)),e.plain=!1}function Rn(e,r,t){return t?"_p("+r+',"'+e+'")':e+r}function Fn(r,t,n,a,o,i,s,c){var u;(a=a||e).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete a.right):a.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),a.capture&&(delete a.capture,t=Rn("!",t,c)),a.once&&(delete a.once,t=Rn("~",t,c)),a.passive&&(delete a.passive,t=Rn("&",t,c)),a.native?(delete a.native,u=r.nativeEvents||(r.nativeEvents={})):u=r.events||(r.events={});var l=In({value:n.trim(),dynamic:c},s);a!==e&&(l.modifiers=a);var p=u[t];Array.isArray(p)?o?p.unshift(l):p.push(l):u[t]=p?o?[l,p]:[p,l]:l,r.plain=!1}function Bn(e,r,t){var n=Un(e,":"+r)||Un(e,"v-bind:"+r);if(null!=n)return _n(n);if(!1!==t){var a=Un(e,r);if(null!=a)return JSON.stringify(a)}}function Un(e,r,t){var n;if(null!=(n=e.attrsMap[r]))for(var a=e.attrsList,o=0,i=a.length;o<i;o++)if(a[o].name===r){a.splice(o,1);break}return t&&delete e.attrsMap[r],n}function Vn(e,r){for(var t=e.attrsList,n=0,a=t.length;n<a;n++){var o=t[n];if(r.test(o.name))return t.splice(n,1),o}}function In(e,r){return r&&(null!=r.start&&(e.start=r.start),null!=r.end&&(e.end=r.end)),e}function jn(e,r,t){var n=t||{},a=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),a&&(o="_n("+o+")");var i=Pn(r,o);e.model={value:"("+r+")",expression:JSON.stringify(r),callback:"function ($$v) {"+i+"}"}}function Pn(e,r){var t=function(e){if(e=e.trim(),yn=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<yn-1)return(Dn=e.lastIndexOf("."))>-1?{exp:e.slice(0,Dn),key:'"'+e.slice(Dn+1)+'"'}:{exp:e,key:null};wn=e,Dn=xn=qn=0;for(;!Mn();)Gn(An=Hn())?Jn(An):91===An&&zn(An);return{exp:e.slice(0,xn),key:e.slice(xn+1,qn)}}(e);return null===t.key?e+"="+r:"$set("+t.exp+", "+t.key+", "+r+")"}function Hn(){return wn.charCodeAt(++Dn)}function Mn(){return Dn>=yn}function Gn(e){return 34===e||39===e}function zn(e){var r=1;for(xn=Dn;!Mn();)if(Gn(e=Hn()))Jn(e);else if(91===e&&r++,93===e&&r--,0===r){qn=Dn;break}}function Jn(e){for(var r=e;!Mn()&&(e=Hn())!==r;);}var Kn,Zn="__r",Yn="__c";function Wn(e,r,t){var n=Kn;return function a(){null!==r.apply(null,arguments)&&ea(e,a,t,n)}}var Qn=Ge&&!(W&&Number(W[1])<=53);function Xn(e,r,t,n){if(Qn){var a=it,o=r;r=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=a||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Kn.addEventListener(e,r,X?{capture:t,passive:n}:t)}function ea(e,r,t,n){(n||Kn).removeEventListener(e,r._wrapper||r,t)}function ra(e,n){if(!r(e.data.on)||!r(n.data.on)){var a=n.data.on||{},o=e.data.on||{};Kn=n.elm,function(e){if(t(e[Zn])){var r=J?"change":"input";e[r]=[].concat(e[Zn],e[r]||[]),delete e[Zn]}t(e[Yn])&&(e.change=[].concat(e[Yn],e.change||[]),delete e[Yn])}(a),ar(a,o,Xn,ea,Wn,n.context),Kn=void 0}}var ta,na={create:ra,update:ra};function aa(e,n){if(!r(e.data.domProps)||!r(n.data.domProps)){var a,o,i=n.elm,s=e.data.domProps||{},c=n.data.domProps||{};for(a in t(c.__ob__)&&(c=n.data.domProps=E({},c)),s)a in c||(i[a]="");for(a in c){if(o=c[a],"textContent"===a||"innerHTML"===a){if(n.children&&(n.children.length=0),o===s[a])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===a&&"PROGRESS"!==i.tagName){i._value=o;var u=r(o)?"":String(o);oa(i,u)&&(i.value=u)}else if("innerHTML"===a&&Jt(i.tagName)&&r(i.innerHTML)){(ta=ta||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ta.firstChild;i.firstChild;)i.removeChild(i.firstChild);for(;l.firstChild;)i.appendChild(l.firstChild)}else if(o!==s[a])try{i[a]=o}catch(e){}}}}function oa(e,r){return!e.composing&&("OPTION"===e.tagName||function(e,r){var t=!0;try{t=document.activeElement!==e}catch(e){}return t&&e.value!==r}(e,r)||function(e,r){var n=e.value,a=e._vModifiers;if(t(a)){if(a.number)return p(n)!==p(r);if(a.trim)return n.trim()!==r.trim()}return n!==r}(e,r))}var ia={create:aa,update:aa},sa=b(function(e){var r={},t=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(t);n.length>1&&(r[n[0].trim()]=n[1].trim())}}),r});function ca(e){var r=ua(e.style);return e.staticStyle?E(e.staticStyle,r):r}function ua(e){return Array.isArray(e)?_(e):"string"==typeof e?sa(e):e}var la,pa=/^--/,fa=/\s*!important$/,da=function(e,r,t){if(pa.test(r))e.style.setProperty(r,t);else if(fa.test(t))e.style.setProperty(x(r),t.replace(fa,""),"important");else{var n=ha(r);if(Array.isArray(t))for(var a=0,o=t.length;a<o;a++)e.style[n]=t[a];else e.style[n]=t}},ma=["Webkit","Moz","ms"],ha=b(function(e){if(la=la||document.createElement("div").style,"filter"!==(e=w(e))&&e in la)return e;for(var r=e.charAt(0).toUpperCase()+e.slice(1),t=0;t<ma.length;t++){var n=ma[t]+r;if(n in la)return n}});function va(e,n){var a=n.data,o=e.data;if(!(r(a.staticStyle)&&r(a.style)&&r(o.staticStyle)&&r(o.style))){var i,s,c=n.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},p=u||l,f=ua(n.data.style)||{};n.data.normalizedStyle=t(f.__ob__)?E({},f):f;var d=function(e,r){var t,n={};if(r)for(var a=e;a.componentInstance;)(a=a.componentInstance._vnode)&&a.data&&(t=ca(a.data))&&E(n,t);(t=ca(e.data))&&E(n,t);for(var o=e;o=o.parent;)o.data&&(t=ca(o.data))&&E(n,t);return n}(n,!0);for(s in p)r(d[s])&&da(c,s,"");for(s in d)(i=d[s])!==p[s]&&da(c,s,null==i?"":i)}}var ga={create:va,update:va},ba=/\s+/;function ya(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.add(r)}):e.classList.add(r);else{var t=" "+(e.getAttribute("class")||"")+" ";t.indexOf(" "+r+" ")<0&&e.setAttribute("class",(t+r).trim())}}function wa(e,r){if(r&&(r=r.trim()))if(e.classList)r.indexOf(" ")>-1?r.split(ba).forEach(function(r){return e.classList.remove(r)}):e.classList.remove(r),e.classList.length||e.removeAttribute("class");else{for(var t=" "+(e.getAttribute("class")||"")+" ",n=" "+r+" ";t.indexOf(n)>=0;)t=t.replace(n," ");(t=t.trim())?e.setAttribute("class",t):e.removeAttribute("class")}}function Aa(e){if(e){if("object"==typeof e){var r={};return!1!==e.css&&E(r,Da(e.name||"v")),E(r,e),r}return"string"==typeof e?Da(e):void 0}}var Da=b(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),xa=H&&!K,qa="transition",ka="animation",Ea="transition",_a="transitionend",Ca="animation",Sa="animationend";xa&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ea="WebkitTransition",_a="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ca="WebkitAnimation",Sa="webkitAnimationEnd"));var La=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ta(e){La(function(){La(e)})}function $a(e,r){var t=e._transitionClasses||(e._transitionClasses=[]);t.indexOf(r)<0&&(t.push(r),ya(e,r))}function Na(e,r){e._transitionClasses&&h(e._transitionClasses,r),wa(e,r)}function Oa(e,r,t){var n=Fa(e,r),a=n.type,o=n.timeout,i=n.propCount;if(!a)return t();var s=a===qa?_a:Sa,c=0,u=function(){e.removeEventListener(s,l),t()},l=function(r){r.target===e&&++c>=i&&u()};setTimeout(function(){c<i&&u()},o+1),e.addEventListener(s,l)}var Ra=/\b(transform|all)(,|$)/;function Fa(e,r){var t,n=window.getComputedStyle(e),a=(n[Ea+"Delay"]||"").split(", "),o=(n[Ea+"Duration"]||"").split(", "),i=Ba(a,o),s=(n[Ca+"Delay"]||"").split(", "),c=(n[Ca+"Duration"]||"").split(", "),u=Ba(s,c),l=0,p=0;return r===qa?i>0&&(t=qa,l=i,p=o.length):r===ka?u>0&&(t=ka,l=u,p=c.length):p=(t=(l=Math.max(i,u))>0?i>u?qa:ka:null)?t===qa?o.length:c.length:0,{type:t,timeout:l,propCount:p,hasTransform:t===qa&&Ra.test(n[Ea+"Property"])}}function Ba(e,r){for(;e.length<r.length;)e=e.concat(e);return Math.max.apply(null,r.map(function(r,t){return Ua(r)+Ua(e[t])}))}function Ua(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Va(e,n){var a=e.elm;t(a._leaveCb)&&(a._leaveCb.cancelled=!0,a._leaveCb());var i=Aa(e.data.transition);if(!r(i)&&!t(a._enterCb)&&1===a.nodeType){for(var s=i.css,c=i.type,u=i.enterClass,l=i.enterToClass,f=i.enterActiveClass,d=i.appearClass,m=i.appearToClass,h=i.appearActiveClass,v=i.beforeEnter,g=i.enter,b=i.afterEnter,y=i.enterCancelled,w=i.beforeAppear,A=i.appear,D=i.afterAppear,x=i.appearCancelled,q=i.duration,k=Zr,E=Zr.$vnode;E&&E.parent;)k=E.context,E=E.parent;var _=!k._isMounted||!e.isRootInsert;if(!_||A||""===A){var C=_&&d?d:u,S=_&&h?h:f,L=_&&m?m:l,T=_&&w||v,$=_&&"function"==typeof A?A:g,O=_&&D||b,R=_&&x||y,F=p(o(q)?q.enter:q),B=!1!==s&&!K,U=Pa($),V=a._enterCb=N(function(){B&&(Na(a,L),Na(a,S)),V.cancelled?(B&&Na(a,C),R&&R(a)):O&&O(a),a._enterCb=null});e.data.show||or(e,"insert",function(){var r=a.parentNode,t=r&&r._pending&&r._pending[e.key];t&&t.tag===e.tag&&t.elm._leaveCb&&t.elm._leaveCb(),$&&$(a,V)}),T&&T(a),B&&($a(a,C),$a(a,S),Ta(function(){Na(a,C),V.cancelled||($a(a,L),U||(ja(F)?setTimeout(V,F):Oa(a,c,V)))})),e.data.show&&(n&&n(),$&&$(a,V)),B||U||V()}}}function Ia(e,n){var a=e.elm;t(a._enterCb)&&(a._enterCb.cancelled=!0,a._enterCb());var i=Aa(e.data.transition);if(r(i)||1!==a.nodeType)return n();if(!t(a._leaveCb)){var s=i.css,c=i.type,u=i.leaveClass,l=i.leaveToClass,f=i.leaveActiveClass,d=i.beforeLeave,m=i.leave,h=i.afterLeave,v=i.leaveCancelled,g=i.delayLeave,b=i.duration,y=!1!==s&&!K,w=Pa(m),A=p(o(b)?b.leave:b),D=a._leaveCb=N(function(){a.parentNode&&a.parentNode._pending&&(a.parentNode._pending[e.key]=null),y&&(Na(a,l),Na(a,f)),D.cancelled?(y&&Na(a,u),v&&v(a)):(n(),h&&h(a)),a._leaveCb=null});g?g(x):x()}function x(){D.cancelled||(!e.data.show&&a.parentNode&&((a.parentNode._pending||(a.parentNode._pending={}))[e.key]=e),d&&d(a),y&&($a(a,u),$a(a,f),Ta(function(){Na(a,u),D.cancelled||($a(a,l),w||(ja(A)?setTimeout(D,A):Oa(a,c,D)))})),m&&m(a,D),y||w||D())}}function ja(e){return"number"==typeof e&&!isNaN(e)}function Pa(e){if(r(e))return!1;var n=e.fns;return t(n)?Pa(Array.isArray(n)?n[0]:n):(e._length||e.length)>1}function Ha(e,r){!0!==r.data.show&&Va(r)}var Ma=function(e){var o,i,s={},c=e.modules,u=e.nodeOps;for(o=0;o<nn.length;++o)for(s[nn[o]]=[],i=0;i<c.length;++i)t(c[i][nn[o]])&&s[nn[o]].push(c[i][nn[o]]);function l(e){var r=u.parentNode(e);t(r)&&u.removeChild(r,e)}function p(e,r,a,o,i,c,l){if(t(e.elm)&&t(c)&&(e=c[l]=ve(e)),e.isRootInsert=!i,!function(e,r,a,o){var i=e.data;if(t(i)){var c=t(e.componentInstance)&&i.keepAlive;if(t(i=i.hook)&&t(i=i.init)&&i(e,!1),t(e.componentInstance))return d(e,r),m(a,e.elm,o),n(c)&&function(e,r,n,a){for(var o,i=e;i.componentInstance;)if(i=i.componentInstance._vnode,t(o=i.data)&&t(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](tn,i);r.push(i);break}m(n,e.elm,a)}(e,r,a,o),!0}}(e,r,a,o)){var p=e.data,f=e.children,v=e.tag;t(v)?(e.elm=e.ns?u.createElementNS(e.ns,v):u.createElement(v,e),b(e),h(e,f,r),t(p)&&g(e,r),m(a,e.elm,o)):n(e.isComment)?(e.elm=u.createComment(e.text),m(a,e.elm,o)):(e.elm=u.createTextNode(e.text),m(a,e.elm,o))}}function d(e,r){t(e.data.pendingInsert)&&(r.push.apply(r,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,v(e)?(g(e,r),b(e)):(rn(e),r.push(e))}function m(e,r,n){t(e)&&(t(n)?u.parentNode(n)===e&&u.insertBefore(e,r,n):u.appendChild(e,r))}function h(e,r,t){if(Array.isArray(r))for(var n=0;n<r.length;++n)p(r[n],t,e.elm,null,!0,r,n);else a(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function v(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return t(e.tag)}function g(e,r){for(var n=0;n<s.create.length;++n)s.create[n](tn,e);t(o=e.data.hook)&&(t(o.create)&&o.create(tn,e),t(o.insert)&&r.push(e))}function b(e){var r;if(t(r=e.fnScopeId))u.setStyleScope(e.elm,r);else for(var n=e;n;)t(r=n.context)&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r),n=n.parent;t(r=Zr)&&r!==e.context&&r!==e.fnContext&&t(r=r.$options._scopeId)&&u.setStyleScope(e.elm,r)}function y(e,r,t,n,a,o){for(;n<=a;++n)p(t[n],o,e,r,!1,t,n)}function w(e){var r,n,a=e.data;if(t(a))for(t(r=a.hook)&&t(r=r.destroy)&&r(e),r=0;r<s.destroy.length;++r)s.destroy[r](e);if(t(r=e.children))for(n=0;n<e.children.length;++n)w(e.children[n])}function A(e,r,n){for(;r<=n;++r){var a=e[r];t(a)&&(t(a.tag)?(D(a),w(a)):l(a.elm))}}function D(e,r){if(t(r)||t(e.data)){var n,a=s.remove.length+1;for(t(r)?r.listeners+=a:r=function(e,r){function t(){0==--t.listeners&&l(e)}return t.listeners=r,t}(e.elm,a),t(n=e.componentInstance)&&t(n=n._vnode)&&t(n.data)&&D(n,r),n=0;n<s.remove.length;++n)s.remove[n](e,r);t(n=e.data.hook)&&t(n=n.remove)?n(e,r):r()}else l(e.elm)}function x(e,r,n,a){for(var o=n;o<a;o++){var i=r[o];if(t(i)&&an(e,i))return o}}function q(e,a,o,i,c,l){if(e!==a){t(a.elm)&&t(i)&&(a=i[c]=ve(a));var f=a.elm=e.elm;if(n(e.isAsyncPlaceholder))t(a.asyncFactory.resolved)?_(e.elm,a,o):a.isAsyncPlaceholder=!0;else if(n(a.isStatic)&&n(e.isStatic)&&a.key===e.key&&(n(a.isCloned)||n(a.isOnce)))a.componentInstance=e.componentInstance;else{var d,m=a.data;t(m)&&t(d=m.hook)&&t(d=d.prepatch)&&d(e,a);var h=e.children,g=a.children;if(t(m)&&v(a)){for(d=0;d<s.update.length;++d)s.update[d](e,a);t(d=m.hook)&&t(d=d.update)&&d(e,a)}r(a.text)?t(h)&&t(g)?h!==g&&function(e,n,a,o,i){for(var s,c,l,f=0,d=0,m=n.length-1,h=n[0],v=n[m],g=a.length-1,b=a[0],w=a[g],D=!i;f<=m&&d<=g;)r(h)?h=n[++f]:r(v)?v=n[--m]:an(h,b)?(q(h,b,o,a,d),h=n[++f],b=a[++d]):an(v,w)?(q(v,w,o,a,g),v=n[--m],w=a[--g]):an(h,w)?(q(h,w,o,a,g),D&&u.insertBefore(e,h.elm,u.nextSibling(v.elm)),h=n[++f],w=a[--g]):an(v,b)?(q(v,b,o,a,d),D&&u.insertBefore(e,v.elm,h.elm),v=n[--m],b=a[++d]):(r(s)&&(s=on(n,f,m)),r(c=t(b.key)?s[b.key]:x(b,n,f,m))?p(b,o,e,h.elm,!1,a,d):an(l=n[c],b)?(q(l,b,o,a,d),n[c]=void 0,D&&u.insertBefore(e,l.elm,h.elm)):p(b,o,e,h.elm,!1,a,d),b=a[++d]);f>m?y(e,r(a[g+1])?null:a[g+1].elm,a,d,g,o):d>g&&A(n,f,m)}(f,h,g,o,l):t(g)?(t(e.text)&&u.setTextContent(f,""),y(f,null,g,0,g.length-1,o)):t(h)?A(h,0,h.length-1):t(e.text)&&u.setTextContent(f,""):e.text!==a.text&&u.setTextContent(f,a.text),t(m)&&t(d=m.hook)&&t(d=d.postpatch)&&d(e,a)}}}function k(e,r,a){if(n(a)&&t(e.parent))e.parent.data.pendingInsert=r;else for(var o=0;o<r.length;++o)r[o].data.hook.insert(r[o])}var E=f("attrs,class,staticClass,staticStyle,key");function _(e,r,a,o){var i,s=r.tag,c=r.data,u=r.children;if(o=o||c&&c.pre,r.elm=e,n(r.isComment)&&t(r.asyncFactory))return r.isAsyncPlaceholder=!0,!0;if(t(c)&&(t(i=c.hook)&&t(i=i.init)&&i(r,!0),t(i=r.componentInstance)))return d(r,a),!0;if(t(s)){if(t(u))if(e.hasChildNodes())if(t(i=c)&&t(i=i.domProps)&&t(i=i.innerHTML)){if(i!==e.innerHTML)return!1}else{for(var l=!0,p=e.firstChild,f=0;f<u.length;f++){if(!p||!_(p,u[f],a,o)){l=!1;break}p=p.nextSibling}if(!l||p)return!1}else h(r,u,a);if(t(c)){var m=!1;for(var v in c)if(!E(v)){m=!0,g(r,a);break}!m&&c.class&&rr(c.class)}}else e.data!==r.text&&(e.data=r.text);return!0}return function(e,a,o,i){if(!r(a)){var c,l=!1,f=[];if(r(e))l=!0,p(a,f);else{var d=t(e.nodeType);if(!d&&an(e,a))q(e,a,f,null,null,i);else{if(d){if(1===e.nodeType&&e.hasAttribute(O)&&(e.removeAttribute(O),o=!0),n(o)&&_(e,a,f))return k(a,f,!0),e;c=e,e=new fe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var m=e.elm,h=u.parentNode(m);if(p(a,f,m._leaveCb?null:h,u.nextSibling(m)),t(a.parent))for(var g=a.parent,b=v(a);g;){for(var y=0;y<s.destroy.length;++y)s.destroy[y](g);if(g.elm=a.elm,b){for(var D=0;D<s.create.length;++D)s.create[D](tn,g);var x=g.data.hook.insert;if(x.merged)for(var E=1;E<x.fns.length;E++)x.fns[E]()}else rn(g);g=g.parent}t(h)?A([e],0,0):t(e.tag)&&w(e)}}return k(a,f,l),a.elm}t(e)&&w(e)}}({nodeOps:Xt,modules:[gn,kn,na,ia,ga,H?{create:Ha,activate:Ha,remove:function(e,r){!0!==e.data.show?Ia(e,r):r()}}:{}].concat(dn)});K&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Qa(e,"input")});var Ga={inserted:function(e,r,t,n){"select"===t.tag?(n.elm&&!n.elm._vOptions?or(t,"postpatch",function(){Ga.componentUpdated(e,r,t)}):za(e,r,t.context),e._vOptions=[].map.call(e.options,Za)):("textarea"===t.tag||Wt(e.type))&&(e._vModifiers=r.modifiers,r.modifiers.lazy||(e.addEventListener("compositionstart",Ya),e.addEventListener("compositionend",Wa),e.addEventListener("change",Wa),K&&(e.vmodel=!0)))},componentUpdated:function(e,r,t){if("select"===t.tag){za(e,r,t.context);var n=e._vOptions,a=e._vOptions=[].map.call(e.options,Za);if(a.some(function(e,r){return!T(e,n[r])}))(e.multiple?r.value.some(function(e){return Ka(e,a)}):r.value!==r.oldValue&&Ka(r.value,a))&&Qa(e,"change")}}};function za(e,r,t){Ja(e,r,t),(J||Z)&&setTimeout(function(){Ja(e,r,t)},0)}function Ja(e,r,t){var n=r.value,a=e.multiple;if(!a||Array.isArray(n)){for(var o,i,s=0,c=e.options.length;s<c;s++)if(i=e.options[s],a)o=$(n,Za(i))>-1,i.selected!==o&&(i.selected=o);else if(T(Za(i),n))return void(e.selectedIndex!==s&&(e.selectedIndex=s));a||(e.selectedIndex=-1)}}function Ka(e,r){return r.every(function(r){return!T(r,e)})}function Za(e){return"_value"in e?e._value:e.value}function Ya(e){e.target.composing=!0}function Wa(e){e.target.composing&&(e.target.composing=!1,Qa(e.target,"input"))}function Qa(e,r){var t=document.createEvent("HTMLEvents");t.initEvent(r,!0,!0),e.dispatchEvent(t)}function Xa(e){return!e.componentInstance||e.data&&e.data.transition?e:Xa(e.componentInstance._vnode)}var eo={model:Ga,show:{bind:function(e,r,t){var n=r.value,a=(t=Xa(t)).data&&t.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;n&&a?(t.data.show=!0,Va(t,function(){e.style.display=o})):e.style.display=n?o:"none"},update:function(e,r,t){var n=r.value;!n!=!r.oldValue&&((t=Xa(t)).data&&t.data.transition?(t.data.show=!0,n?Va(t,function(){e.style.display=e.__vOriginalDisplay}):Ia(t,function(){e.style.display="none"})):e.style.display=n?e.__vOriginalDisplay:"none")},unbind:function(e,r,t,n,a){a||(e.style.display=e.__vOriginalDisplay)}}},ro={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var r=e&&e.componentOptions;return r&&r.Ctor.options.abstract?to(Mr(r.children)):e}function no(e){var r={},t=e.$options;for(var n in t.propsData)r[n]=e[n];var a=t._parentListeners;for(var o in a)r[w(o)]=a[o];return r}function ao(e,r){if(/\d-keep-alive$/.test(r.tag))return e("keep-alive",{props:r.componentOptions.propsData})}var oo=function(e){return e.tag||Hr(e)},io=function(e){return"show"===e.name},so={name:"transition",props:ro,abstract:!0,render:function(e){var r=this,t=this.$slots.default;if(t&&(t=t.filter(oo)).length){var n=this.mode,o=t[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var i=to(o);if(!i)return o;if(this._leaving)return ao(e,o);var s="__transition-"+this._uid+"-";i.key=null==i.key?i.isComment?s+"comment":s+i.tag:a(i.key)?0===String(i.key).indexOf(s)?i.key:s+i.key:i.key;var c=(i.data||(i.data={})).transition=no(this),u=this._vnode,l=to(u);if(i.data.directives&&i.data.directives.some(io)&&(i.data.show=!0),l&&l.data&&!function(e,r){return r.key===e.key&&r.tag===e.tag}(i,l)&&!Hr(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var p=l.data.transition=E({},c);if("out-in"===n)return this._leaving=!0,or(p,"afterLeave",function(){r._leaving=!1,r.$forceUpdate()}),ao(e,o);if("in-out"===n){if(Hr(i))return u;var f,d=function(){f()};or(c,"afterEnter",d),or(c,"enterCancelled",d),or(p,"delayLeave",function(e){f=e})}}return o}}},co=E({tag:String,moveClass:String},ro);function uo(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function lo(e){e.data.newPos=e.elm.getBoundingClientRect()}function po(e){var r=e.data.pos,t=e.data.newPos,n=r.left-t.left,a=r.top-t.top;if(n||a){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+n+"px,"+a+"px)",o.transitionDuration="0s"}}delete co.mode;var fo={Transition:so,TransitionGroup:{props:co,beforeMount:function(){var e=this,r=this._update;this._update=function(t,n){var a=Yr(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,a(),r.call(e,t,n)}},render:function(e){for(var r=this.tag||this.$vnode.data.tag||"span",t=Object.create(null),n=this.prevChildren=this.children,a=this.$slots.default||[],o=this.children=[],i=no(this),s=0;s<a.length;s++){var c=a[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),t[c.key]=c,(c.data||(c.data={})).transition=i)}if(n){for(var u=[],l=[],p=0;p<n.length;p++){var f=n[p];f.data.transition=i,f.data.pos=f.elm.getBoundingClientRect(),t[f.key]?u.push(f):l.push(f)}this.kept=e(r,null,u),this.removed=l}return e(r,null,o)},updated:function(){var e=this.prevChildren,r=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,r)&&(e.forEach(uo),e.forEach(lo),e.forEach(po),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var t=e.elm,n=t.style;$a(t,r),n.transform=n.WebkitTransform=n.transitionDuration="",t.addEventListener(_a,t._moveCb=function e(n){n&&n.target!==t||n&&!/transform$/.test(n.propertyName)||(t.removeEventListener(_a,e),t._moveCb=null,Na(t,r))})}}))},methods:{hasMove:function(e,r){if(!xa)return!1;if(this._hasMove)return this._hasMove;var t=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){wa(t,e)}),ya(t,r),t.style.display="none",this.$el.appendChild(t);var n=Fa(t);return this.$el.removeChild(t),this._hasMove=n.hasTransform}}}};Dt.config.mustUseProp=$t,Dt.config.isReservedTag=Kt,Dt.config.isReservedAttr=Lt,Dt.config.getTagNamespace=Zt,Dt.config.isUnknownElement=function(e){if(!H)return!0;if(Kt(e))return!1;if(e=e.toLowerCase(),null!=Yt[e])return Yt[e];var r=document.createElement(e);return e.indexOf("-")>-1?Yt[e]=r.constructor===window.HTMLUnknownElement||r.constructor===window.HTMLElement:Yt[e]=/HTMLUnknownElement/.test(r.toString())},E(Dt.options.directives,eo),E(Dt.options.components,fo),Dt.prototype.__patch__=H?Ma:C,Dt.prototype.$mount=function(e,r){return function(e,r,t){var n;return e.$el=r,e.$options.render||(e.$options.render=me),Xr(e,"beforeMount"),n=function(){e._update(e._render(),t)},new pt(e,n,C,{before:function(){e._isMounted&&!e._isDestroyed&&Xr(e,"beforeUpdate")}},!0),t=!1,null==e.$vnode&&(e._isMounted=!0,Xr(e,"mounted")),e}(this,e=e&&H?Qt(e):void 0,r)},H&&setTimeout(function(){B.devtools&&te&&te.emit("init",Dt)},0);var mo=/\{\{((?:.|\r?\n)+?)\}\}/g,ho=/[-.*+?^${}()|[\]\/\\]/g,vo=b(function(e){var r=e[0].replace(ho,"\\$&"),t=e[1].replace(ho,"\\$&");return new RegExp(r+"((?:.|\\n)+?)"+t,"g")});var go={staticKeys:["staticClass"],transformNode:function(e,r){r.warn;var t=Un(e,"class");t&&(e.staticClass=JSON.stringify(t));var n=Bn(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var r="";return e.staticClass&&(r+="staticClass:"+e.staticClass+","),e.classBinding&&(r+="class:"+e.classBinding+","),r}};var bo={staticKeys:["staticStyle"],transformNode:function(e,r){r.warn;var t=Un(e,"style");t&&(e.staticStyle=JSON.stringify(sa(t)));var n=Bn(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var r="";return e.staticStyle&&(r+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(r+="style:("+e.styleBinding+"),"),r}};!function(e){var r="object"==typeof exports&&exports,t="object"==typeof module&&module&&module.exports==r&&module,n="object"==typeof global&&global;n.global!==n&&n.window!==n||(e=n);var a=/[\uD800-\uDBFF][\uDC00-\uDFFF]/g,o=/[\x01-\x7F]/g,i=/[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,s=/<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g,c={"\xad":"shy","\u200c":"zwnj","\u200d":"zwj","\u200e":"lrm","\u2063":"ic","\u2062":"it","\u2061":"af","\u200f":"rlm","\u200b":"ZeroWidthSpace","\u2060":"NoBreak","\u0311":"DownBreve","\u20db":"tdot","\u20dc":"DotDot","\t":"Tab","\n":"NewLine","\u2008":"puncsp","\u205f":"MediumSpace","\u2009":"thinsp","\u200a":"hairsp","\u2004":"emsp13","\u2002":"ensp","\u2005":"emsp14","\u2003":"emsp","\u2007":"numsp","\xa0":"nbsp","\u205f\u200a":"ThickSpace","\u203e":"oline",_:"lowbar","\u2010":"dash","\u2013":"ndash","\u2014":"mdash","\u2015":"horbar",",":"comma",";":"semi","\u204f":"bsemi",":":"colon","\u2a74":"Colone","!":"excl","\xa1":"iexcl","?":"quest","\xbf":"iquest",".":"period","\u2025":"nldr","\u2026":"mldr","\xb7":"middot","'":"apos","\u2018":"lsquo","\u2019":"rsquo","\u201a":"sbquo","\u2039":"lsaquo","\u203a":"rsaquo",'"':"quot","\u201c":"ldquo","\u201d":"rdquo","\u201e":"bdquo","\xab":"laquo","\xbb":"raquo","(":"lpar",")":"rpar","[":"lsqb","]":"rsqb","{":"lcub","}":"rcub","\u2308":"lceil","\u2309":"rceil","\u230a":"lfloor","\u230b":"rfloor","\u2985":"lopar","\u2986":"ropar","\u298b":"lbrke","\u298c":"rbrke","\u298d":"lbrkslu","\u298e":"rbrksld","\u298f":"lbrksld","\u2990":"rbrkslu","\u2991":"langd","\u2992":"rangd","\u2993":"lparlt","\u2994":"rpargt","\u2995":"gtlPar","\u2996":"ltrPar","\u27e6":"lobrk","\u27e7":"robrk","\u27e8":"lang","\u27e9":"rang","\u27ea":"Lang","\u27eb":"Rang","\u27ec":"loang","\u27ed":"roang","\u2772":"lbbrk","\u2773":"rbbrk","\u2016":"Vert","\xa7":"sect","\xb6":"para","@":"commat","*":"ast","/":"sol",undefined:null,"&":"amp","#":"num","%":"percnt","\u2030":"permil","\u2031":"pertenk","\u2020":"dagger","\u2021":"Dagger","\u2022":"bull","\u2043":"hybull","\u2032":"prime","\u2033":"Prime","\u2034":"tprime","\u2057":"qprime","\u2035":"bprime","\u2041":"caret","`":"grave","\xb4":"acute","\u02dc":"tilde","^":"Hat","\xaf":"macr","\u02d8":"breve","\u02d9":"dot","\xa8":"die","\u02da":"ring","\u02dd":"dblac","\xb8":"cedil","\u02db":"ogon","\u02c6":"circ","\u02c7":"caron","\xb0":"deg","\xa9":"copy","\xae":"reg","\u2117":"copysr","\u2118":"wp","\u211e":"rx","\u2127":"mho","\u2129":"iiota","\u2190":"larr","\u219a":"nlarr","\u2192":"rarr","\u219b":"nrarr","\u2191":"uarr","\u2193":"darr","\u2194":"harr","\u21ae":"nharr","\u2195":"varr","\u2196":"nwarr","\u2197":"nearr","\u2198":"searr","\u2199":"swarr","\u219d":"rarrw","\u219d\u0338":"nrarrw","\u219e":"Larr","\u219f":"Uarr","\u21a0":"Rarr","\u21a1":"Darr","\u21a2":"larrtl","\u21a3":"rarrtl","\u21a4":"mapstoleft","\u21a5":"mapstoup","\u21a6":"map","\u21a7":"mapstodown","\u21a9":"larrhk","\u21aa":"rarrhk","\u21ab":"larrlp","\u21ac":"rarrlp","\u21ad":"harrw","\u21b0":"lsh","\u21b1":"rsh","\u21b2":"ldsh","\u21b3":"rdsh","\u21b5":"crarr","\u21b6":"cularr","\u21b7":"curarr","\u21ba":"olarr","\u21bb":"orarr","\u21bc":"lharu","\u21bd":"lhard","\u21be":"uharr","\u21bf":"uharl","\u21c0":"rharu","\u21c1":"rhard","\u21c2":"dharr","\u21c3":"dharl","\u21c4":"rlarr","\u21c5":"udarr","\u21c6":"lrarr","\u21c7":"llarr","\u21c8":"uuarr","\u21c9":"rrarr","\u21ca":"ddarr","\u21cb":"lrhar","\u21cc":"rlhar","\u21d0":"lArr","\u21cd":"nlArr","\u21d1":"uArr","\u21d2":"rArr","\u21cf":"nrArr","\u21d3":"dArr","\u21d4":"iff","\u21ce":"nhArr","\u21d5":"vArr","\u21d6":"nwArr","\u21d7":"neArr","\u21d8":"seArr","\u21d9":"swArr","\u21da":"lAarr","\u21db":"rAarr","\u21dd":"zigrarr","\u21e4":"larrb","\u21e5":"rarrb","\u21f5":"duarr","\u21fd":"loarr","\u21fe":"roarr","\u21ff":"hoarr","\u2200":"forall","\u2201":"comp","\u2202":"part","\u2202\u0338":"npart","\u2203":"exist","\u2204":"nexist","\u2205":"empty","\u2207":"Del","\u2208":"in","\u2209":"notin","\u220b":"ni","\u220c":"notni","\u03f6":"bepsi","\u220f":"prod","\u2210":"coprod","\u2211":"sum","+":"plus","\xb1":"pm","\xf7":"div","\xd7":"times","<":"lt","\u226e":"nlt","<\u20d2":"nvlt","=":"equals","\u2260":"ne","=\u20e5":"bne","\u2a75":"Equal",">":"gt","\u226f":"ngt",">\u20d2":"nvgt","\xac":"not","|":"vert","\xa6":"brvbar","\u2212":"minus","\u2213":"mp","\u2214":"plusdo","\u2044":"frasl","\u2216":"setmn","\u2217":"lowast","\u2218":"compfn","\u221a":"Sqrt","\u221d":"prop","\u221e":"infin","\u221f":"angrt","\u2220":"ang","\u2220\u20d2":"nang","\u2221":"angmsd","\u2222":"angsph","\u2223":"mid","\u2224":"nmid","\u2225":"par","\u2226":"npar","\u2227":"and","\u2228":"or","\u2229":"cap","\u2229\ufe00":"caps","\u222a":"cup","\u222a\ufe00":"cups","\u222b":"int","\u222c":"Int","\u222d":"tint","\u2a0c":"qint","\u222e":"oint","\u222f":"Conint","\u2230":"Cconint","\u2231":"cwint","\u2232":"cwconint","\u2233":"awconint","\u2234":"there4","\u2235":"becaus","\u2236":"ratio","\u2237":"Colon","\u2238":"minusd","\u223a":"mDDot","\u223b":"homtht","\u223c":"sim","\u2241":"nsim","\u223c\u20d2":"nvsim","\u223d":"bsim","\u223d\u0331":"race","\u223e":"ac","\u223e\u0333":"acE","\u223f":"acd","\u2240":"wr","\u2242":"esim","\u2242\u0338":"nesim","\u2243":"sime","\u2244":"nsime","\u2245":"cong","\u2247":"ncong","\u2246":"simne","\u2248":"ap","\u2249":"nap","\u224a":"ape","\u224b":"apid","\u224b\u0338":"napid","\u224c":"bcong","\u224d":"CupCap","\u226d":"NotCupCap","\u224d\u20d2":"nvap","\u224e":"bump","\u224e\u0338":"nbump","\u224f":"bumpe","\u224f\u0338":"nbumpe","\u2250":"doteq","\u2250\u0338":"nedot","\u2251":"eDot","\u2252":"efDot","\u2253":"erDot","\u2254":"colone","\u2255":"ecolon","\u2256":"ecir","\u2257":"cire","\u2259":"wedgeq","\u225a":"veeeq","\u225c":"trie","\u225f":"equest","\u2261":"equiv","\u2262":"nequiv","\u2261\u20e5":"bnequiv","\u2264":"le","\u2270":"nle","\u2264\u20d2":"nvle","\u2265":"ge","\u2271":"nge","\u2265\u20d2":"nvge","\u2266":"lE","\u2266\u0338":"nlE","\u2267":"gE","\u2267\u0338":"ngE","\u2268\ufe00":"lvnE","\u2268":"lnE","\u2269":"gnE","\u2269\ufe00":"gvnE","\u226a":"ll","\u226a\u0338":"nLtv","\u226a\u20d2":"nLt","\u226b":"gg","\u226b\u0338":"nGtv","\u226b\u20d2":"nGt","\u226c":"twixt","\u2272":"lsim","\u2274":"nlsim","\u2273":"gsim","\u2275":"ngsim","\u2276":"lg","\u2278":"ntlg","\u2277":"gl","\u2279":"ntgl","\u227a":"pr","\u2280":"npr","\u227b":"sc","\u2281":"nsc","\u227c":"prcue","\u22e0":"nprcue","\u227d":"sccue","\u22e1":"nsccue","\u227e":"prsim","\u227f":"scsim","\u227f\u0338":"NotSucceedsTilde","\u2282":"sub","\u2284":"nsub","\u2282\u20d2":"vnsub","\u2283":"sup","\u2285":"nsup","\u2283\u20d2":"vnsup","\u2286":"sube","\u2288":"nsube","\u2287":"supe","\u2289":"nsupe","\u228a\ufe00":"vsubne","\u228a":"subne","\u228b\ufe00":"vsupne","\u228b":"supne","\u228d":"cupdot","\u228e":"uplus","\u228f":"sqsub","\u228f\u0338":"NotSquareSubset","\u2290":"sqsup","\u2290\u0338":"NotSquareSuperset","\u2291":"sqsube","\u22e2":"nsqsube","\u2292":"sqsupe","\u22e3":"nsqsupe","\u2293":"sqcap","\u2293\ufe00":"sqcaps","\u2294":"sqcup","\u2294\ufe00":"sqcups","\u2295":"oplus","\u2296":"ominus","\u2297":"otimes","\u2298":"osol","\u2299":"odot","\u229a":"ocir","\u229b":"oast","\u229d":"odash","\u229e":"plusb","\u229f":"minusb","\u22a0":"timesb","\u22a1":"sdotb","\u22a2":"vdash","\u22ac":"nvdash","\u22a3":"dashv","\u22a4":"top","\u22a5":"bot","\u22a7":"models","\u22a8":"vDash","\u22ad":"nvDash","\u22a9":"Vdash","\u22ae":"nVdash","\u22aa":"Vvdash","\u22ab":"VDash","\u22af":"nVDash","\u22b0":"prurel","\u22b2":"vltri","\u22ea":"nltri","\u22b3":"vrtri","\u22eb":"nrtri","\u22b4":"ltrie","\u22ec":"nltrie","\u22b4\u20d2":"nvltrie","\u22b5":"rtrie","\u22ed":"nrtrie","\u22b5\u20d2":"nvrtrie","\u22b6":"origof","\u22b7":"imof","\u22b8":"mumap","\u22b9":"hercon","\u22ba":"intcal","\u22bb":"veebar","\u22bd":"barvee","\u22be":"angrtvb","\u22bf":"lrtri","\u22c0":"Wedge","\u22c1":"Vee","\u22c2":"xcap","\u22c3":"xcup","\u22c4":"diam","\u22c5":"sdot","\u22c6":"Star","\u22c7":"divonx","\u22c8":"bowtie","\u22c9":"ltimes","\u22ca":"rtimes","\u22cb":"lthree","\u22cc":"rthree","\u22cd":"bsime","\u22ce":"cuvee","\u22cf":"cuwed","\u22d0":"Sub","\u22d1":"Sup","\u22d2":"Cap","\u22d3":"Cup","\u22d4":"fork","\u22d5":"epar","\u22d6":"ltdot","\u22d7":"gtdot","\u22d8":"Ll","\u22d8\u0338":"nLl","\u22d9":"Gg","\u22d9\u0338":"nGg","\u22da\ufe00":"lesg","\u22da":"leg","\u22db":"gel","\u22db\ufe00":"gesl","\u22de":"cuepr","\u22df":"cuesc","\u22e6":"lnsim","\u22e7":"gnsim","\u22e8":"prnsim","\u22e9":"scnsim","\u22ee":"vellip","\u22ef":"ctdot","\u22f0":"utdot","\u22f1":"dtdot","\u22f2":"disin","\u22f3":"isinsv","\u22f4":"isins","\u22f5":"isindot","\u22f5\u0338":"notindot","\u22f6":"notinvc","\u22f7":"notinvb","\u22f9":"isinE","\u22f9\u0338":"notinE","\u22fa":"nisd","\u22fb":"xnis","\u22fc":"nis","\u22fd":"notnivc","\u22fe":"notnivb","\u2305":"barwed","\u2306":"Barwed","\u230c":"drcrop","\u230d":"dlcrop","\u230e":"urcrop","\u230f":"ulcrop","\u2310":"bnot","\u2312":"profline","\u2313":"profsurf","\u2315":"telrec","\u2316":"target","\u231c":"ulcorn","\u231d":"urcorn","\u231e":"dlcorn","\u231f":"drcorn","\u2322":"frown","\u2323":"smile","\u232d":"cylcty","\u232e":"profalar","\u2336":"topbot","\u233d":"ovbar","\u233f":"solbar","\u237c":"angzarr","\u23b0":"lmoust","\u23b1":"rmoust","\u23b4":"tbrk","\u23b5":"bbrk","\u23b6":"bbrktbrk","\u23dc":"OverParenthesis","\u23dd":"UnderParenthesis","\u23de":"OverBrace","\u23df":"UnderBrace","\u23e2":"trpezium","\u23e7":"elinters","\u2423":"blank","\u2500":"boxh","\u2502":"boxv","\u250c":"boxdr","\u2510":"boxdl","\u2514":"boxur","\u2518":"boxul","\u251c":"boxvr","\u2524":"boxvl","\u252c":"boxhd","\u2534":"boxhu","\u253c":"boxvh","\u2550":"boxH","\u2551":"boxV","\u2552":"boxdR","\u2553":"boxDr","\u2554":"boxDR","\u2555":"boxdL","\u2556":"boxDl","\u2557":"boxDL","\u2558":"boxuR","\u2559":"boxUr","\u255a":"boxUR","\u255b":"boxuL","\u255c":"boxUl","\u255d":"boxUL","\u255e":"boxvR","\u255f":"boxVr","\u2560":"boxVR","\u2561":"boxvL","\u2562":"boxVl","\u2563":"boxVL","\u2564":"boxHd","\u2565":"boxhD","\u2566":"boxHD","\u2567":"boxHu","\u2568":"boxhU","\u2569":"boxHU","\u256a":"boxvH","\u256b":"boxVh","\u256c":"boxVH","\u2580":"uhblk","\u2584":"lhblk","\u2588":"block","\u2591":"blk14","\u2592":"blk12","\u2593":"blk34","\u25a1":"squ","\u25aa":"squf","\u25ab":"EmptyVerySmallSquare","\u25ad":"rect","\u25ae":"marker","\u25b1":"fltns","\u25b3":"xutri","\u25b4":"utrif","\u25b5":"utri","\u25b8":"rtrif","\u25b9":"rtri","\u25bd":"xdtri","\u25be":"dtrif","\u25bf":"dtri","\u25c2":"ltrif","\u25c3":"ltri","\u25ca":"loz","\u25cb":"cir","\u25ec":"tridot","\u25ef":"xcirc","\u25f8":"ultri","\u25f9":"urtri","\u25fa":"lltri","\u25fb":"EmptySmallSquare","\u25fc":"FilledSmallSquare","\u2605":"starf","\u2606":"star","\u260e":"phone","\u2640":"female","\u2642":"male","\u2660":"spades","\u2663":"clubs","\u2665":"hearts","\u2666":"diams","\u266a":"sung","\u2713":"check","\u2717":"cross","\u2720":"malt","\u2736":"sext","\u2758":"VerticalSeparator","\u27c8":"bsolhsub","\u27c9":"suphsol","\u27f5":"xlarr","\u27f6":"xrarr","\u27f7":"xharr","\u27f8":"xlArr","\u27f9":"xrArr","\u27fa":"xhArr","\u27fc":"xmap","\u27ff":"dzigrarr","\u2902":"nvlArr","\u2903":"nvrArr","\u2904":"nvHarr","\u2905":"Map","\u290c":"lbarr","\u290d":"rbarr","\u290e":"lBarr","\u290f":"rBarr","\u2910":"RBarr","\u2911":"DDotrahd","\u2912":"UpArrowBar","\u2913":"DownArrowBar","\u2916":"Rarrtl","\u2919":"latail","\u291a":"ratail","\u291b":"lAtail","\u291c":"rAtail","\u291d":"larrfs","\u291e":"rarrfs","\u291f":"larrbfs","\u2920":"rarrbfs","\u2923":"nwarhk","\u2924":"nearhk","\u2925":"searhk","\u2926":"swarhk","\u2927":"nwnear","\u2928":"toea","\u2929":"tosa","\u292a":"swnwar","\u2933":"rarrc","\u2933\u0338":"nrarrc","\u2935":"cudarrr","\u2936":"ldca","\u2937":"rdca","\u2938":"cudarrl","\u2939":"larrpl","\u293c":"curarrm","\u293d":"cularrp","\u2945":"rarrpl","\u2948":"harrcir","\u2949":"Uarrocir","\u294a":"lurdshar","\u294b":"ldrushar","\u294e":"LeftRightVector","\u294f":"RightUpDownVector","\u2950":"DownLeftRightVector","\u2951":"LeftUpDownVector","\u2952":"LeftVectorBar","\u2953":"RightVectorBar","\u2954":"RightUpVectorBar","\u2955":"RightDownVectorBar","\u2956":"DownLeftVectorBar","\u2957":"DownRightVectorBar","\u2958":"LeftUpVectorBar","\u2959":"LeftDownVectorBar","\u295a":"LeftTeeVector","\u295b":"RightTeeVector","\u295c":"RightUpTeeVector","\u295d":"RightDownTeeVector","\u295e":"DownLeftTeeVector","\u295f":"DownRightTeeVector","\u2960":"LeftUpTeeVector","\u2961":"LeftDownTeeVector","\u2962":"lHar","\u2963":"uHar","\u2964":"rHar","\u2965":"dHar","\u2966":"luruhar","\u2967":"ldrdhar","\u2968":"ruluhar","\u2969":"rdldhar","\u296a":"lharul","\u296b":"llhard","\u296c":"rharul","\u296d":"lrhard","\u296e":"udhar","\u296f":"duhar","\u2970":"RoundImplies","\u2971":"erarr","\u2972":"simrarr","\u2973":"larrsim","\u2974":"rarrsim","\u2975":"rarrap","\u2976":"ltlarr","\u2978":"gtrarr","\u2979":"subrarr","\u297b":"suplarr","\u297c":"lfisht","\u297d":"rfisht","\u297e":"ufisht","\u297f":"dfisht","\u299a":"vzigzag","\u299c":"vangrt","\u299d":"angrtvbd","\u29a4":"ange","\u29a5":"range","\u29a6":"dwangle","\u29a7":"uwangle","\u29a8":"angmsdaa","\u29a9":"angmsdab","\u29aa":"angmsdac","\u29ab":"angmsdad","\u29ac":"angmsdae","\u29ad":"angmsdaf","\u29ae":"angmsdag","\u29af":"angmsdah","\u29b0":"bemptyv","\u29b1":"demptyv","\u29b2":"cemptyv","\u29b3":"raemptyv","\u29b4":"laemptyv","\u29b5":"ohbar","\u29b6":"omid","\u29b7":"opar","\u29b9":"operp","\u29bb":"olcross","\u29bc":"odsold","\u29be":"olcir","\u29bf":"ofcir","\u29c0":"olt","\u29c1":"ogt","\u29c2":"cirscir","\u29c3":"cirE","\u29c4":"solb","\u29c5":"bsolb","\u29c9":"boxbox","\u29cd":"trisb","\u29ce":"rtriltri","\u29cf":"LeftTriangleBar","\u29cf\u0338":"NotLeftTriangleBar","\u29d0":"RightTriangleBar","\u29d0\u0338":"NotRightTriangleBar","\u29dc":"iinfin","\u29dd":"infintie","\u29de":"nvinfin","\u29e3":"eparsl","\u29e4":"smeparsl","\u29e5":"eqvparsl","\u29eb":"lozf","\u29f4":"RuleDelayed","\u29f6":"dsol","\u2a00":"xodot","\u2a01":"xoplus","\u2a02":"xotime","\u2a04":"xuplus","\u2a06":"xsqcup","\u2a0d":"fpartint","\u2a10":"cirfnint","\u2a11":"awint","\u2a12":"rppolint","\u2a13":"scpolint","\u2a14":"npolint","\u2a15":"pointint","\u2a16":"quatint","\u2a17":"intlarhk","\u2a22":"pluscir","\u2a23":"plusacir","\u2a24":"simplus","\u2a25":"plusdu","\u2a26":"plussim","\u2a27":"plustwo","\u2a29":"mcomma","\u2a2a":"minusdu","\u2a2d":"loplus","\u2a2e":"roplus","\u2a2f":"Cross","\u2a30":"timesd","\u2a31":"timesbar","\u2a33":"smashp","\u2a34":"lotimes","\u2a35":"rotimes","\u2a36":"otimesas","\u2a37":"Otimes","\u2a38":"odiv","\u2a39":"triplus","\u2a3a":"triminus","\u2a3b":"tritime","\u2a3c":"iprod","\u2a3f":"amalg","\u2a40":"capdot","\u2a42":"ncup","\u2a43":"ncap","\u2a44":"capand","\u2a45":"cupor","\u2a46":"cupcap","\u2a47":"capcup","\u2a48":"cupbrcap","\u2a49":"capbrcup","\u2a4a":"cupcup","\u2a4b":"capcap","\u2a4c":"ccups","\u2a4d":"ccaps","\u2a50":"ccupssm","\u2a53":"And","\u2a54":"Or","\u2a55":"andand","\u2a56":"oror","\u2a57":"orslope","\u2a58":"andslope","\u2a5a":"andv","\u2a5b":"orv","\u2a5c":"andd","\u2a5d":"ord","\u2a5f":"wedbar","\u2a66":"sdote","\u2a6a":"simdot","\u2a6d":"congdot","\u2a6d\u0338":"ncongdot","\u2a6e":"easter","\u2a6f":"apacir","\u2a70":"apE","\u2a70\u0338":"napE","\u2a71":"eplus","\u2a72":"pluse","\u2a73":"Esim","\u2a77":"eDDot","\u2a78":"equivDD","\u2a79":"ltcir","\u2a7a":"gtcir","\u2a7b":"ltquest","\u2a7c":"gtquest","\u2a7d":"les","\u2a7d\u0338":"nles","\u2a7e":"ges","\u2a7e\u0338":"nges","\u2a7f":"lesdot","\u2a80":"gesdot","\u2a81":"lesdoto","\u2a82":"gesdoto","\u2a83":"lesdotor","\u2a84":"gesdotol","\u2a85":"lap","\u2a86":"gap","\u2a87":"lne","\u2a88":"gne","\u2a89":"lnap","\u2a8a":"gnap","\u2a8b":"lEg","\u2a8c":"gEl","\u2a8d":"lsime","\u2a8e":"gsime","\u2a8f":"lsimg","\u2a90":"gsiml","\u2a91":"lgE","\u2a92":"glE","\u2a93":"lesges","\u2a94":"gesles","\u2a95":"els","\u2a96":"egs","\u2a97":"elsdot","\u2a98":"egsdot","\u2a99":"el","\u2a9a":"eg","\u2a9d":"siml","\u2a9e":"simg","\u2a9f":"simlE","\u2aa0":"simgE","\u2aa1":"LessLess","\u2aa1\u0338":"NotNestedLessLess","\u2aa2":"GreaterGreater","\u2aa2\u0338":"NotNestedGreaterGreater","\u2aa4":"glj","\u2aa5":"gla","\u2aa6":"ltcc","\u2aa7":"gtcc","\u2aa8":"lescc","\u2aa9":"gescc","\u2aaa":"smt","\u2aab":"lat","\u2aac":"smte","\u2aac\ufe00":"smtes","\u2aad":"late","\u2aad\ufe00":"lates","\u2aae":"bumpE","\u2aaf":"pre","\u2aaf\u0338":"npre","\u2ab0":"sce","\u2ab0\u0338":"nsce","\u2ab3":"prE","\u2ab4":"scE","\u2ab5":"prnE","\u2ab6":"scnE","\u2ab7":"prap","\u2ab8":"scap","\u2ab9":"prnap","\u2aba":"scnap","\u2abb":"Pr","\u2abc":"Sc","\u2abd":"subdot","\u2abe":"supdot","\u2abf":"subplus","\u2ac0":"supplus","\u2ac1":"submult","\u2ac2":"supmult","\u2ac3":"subedot","\u2ac4":"supedot","\u2ac5":"subE","\u2ac5\u0338":"nsubE","\u2ac6":"supE","\u2ac6\u0338":"nsupE","\u2ac7":"subsim","\u2ac8":"supsim","\u2acb\ufe00":"vsubnE","\u2acb":"subnE","\u2acc\ufe00":"vsupnE","\u2acc":"supnE","\u2acf":"csub","\u2ad0":"csup","\u2ad1":"csube","\u2ad2":"csupe","\u2ad3":"subsup","\u2ad4":"supsub","\u2ad5":"subsub","\u2ad6":"supsup","\u2ad7":"suphsub","\u2ad8":"supdsub","\u2ad9":"forkv","\u2ada":"topfork","\u2adb":"mlcp","\u2ae4":"Dashv","\u2ae6":"Vdashl","\u2ae7":"Barv","\u2ae8":"vBar","\u2ae9":"vBarv","\u2aeb":"Vbar","\u2aec":"Not","\u2aed":"bNot","\u2aee":"rnmid","\u2aef":"cirmid","\u2af0":"midcir","\u2af1":"topcir","\u2af2":"nhpar","\u2af3":"parsim","\u2afd":"parsl","\u2afd\u20e5":"nparsl","\u266d":"flat","\u266e":"natur","\u266f":"sharp","\xa4":"curren","\xa2":"cent",$:"dollar","\xa3":"pound","\xa5":"yen","\u20ac":"euro","\xb9":"sup1","\xbd":"half","\u2153":"frac13","\xbc":"frac14","\u2155":"frac15","\u2159":"frac16","\u215b":"frac18","\xb2":"sup2","\u2154":"frac23","\u2156":"frac25","\xb3":"sup3","\xbe":"frac34","\u2157":"frac35","\u215c":"frac38","\u2158":"frac45","\u215a":"frac56","\u215d":"frac58","\u215e":"frac78","\ud835\udcb6":"ascr","\ud835\udd52":"aopf","\ud835\udd1e":"afr","\ud835\udd38":"Aopf","\ud835\udd04":"Afr","\ud835\udc9c":"Ascr","\xaa":"ordf","\xe1":"aacute","\xc1":"Aacute","\xe0":"agrave","\xc0":"Agrave","\u0103":"abreve","\u0102":"Abreve","\xe2":"acirc","\xc2":"Acirc","\xe5":"aring","\xc5":"angst","\xe4":"auml","\xc4":"Auml","\xe3":"atilde","\xc3":"Atilde","\u0105":"aogon","\u0104":"Aogon","\u0101":"amacr","\u0100":"Amacr","\xe6":"aelig","\xc6":"AElig","\ud835\udcb7":"bscr","\ud835\udd53":"bopf","\ud835\udd1f":"bfr","\ud835\udd39":"Bopf","\u212c":"Bscr","\ud835\udd05":"Bfr","\ud835\udd20":"cfr","\ud835\udcb8":"cscr","\ud835\udd54":"copf","\u212d":"Cfr","\ud835\udc9e":"Cscr","\u2102":"Copf","\u0107":"cacute","\u0106":"Cacute","\u0109":"ccirc","\u0108":"Ccirc","\u010d":"ccaron","\u010c":"Ccaron","\u010b":"cdot","\u010a":"Cdot","\xe7":"ccedil","\xc7":"Ccedil","\u2105":"incare","\ud835\udd21":"dfr","\u2146":"dd","\ud835\udd55":"dopf","\ud835\udcb9":"dscr","\ud835\udc9f":"Dscr","\ud835\udd07":"Dfr","\u2145":"DD","\ud835\udd3b":"Dopf","\u010f":"dcaron","\u010e":"Dcaron","\u0111":"dstrok","\u0110":"Dstrok","\xf0":"eth","\xd0":"ETH","\u2147":"ee","\u212f":"escr","\ud835\udd22":"efr","\ud835\udd56":"eopf","\u2130":"Escr","\ud835\udd08":"Efr","\ud835\udd3c":"Eopf","\xe9":"eacute","\xc9":"Eacute","\xe8":"egrave","\xc8":"Egrave","\xea":"ecirc","\xca":"Ecirc","\u011b":"ecaron","\u011a":"Ecaron","\xeb":"euml","\xcb":"Euml","\u0117":"edot","\u0116":"Edot","\u0119":"eogon","\u0118":"Eogon","\u0113":"emacr","\u0112":"Emacr","\ud835\udd23":"ffr","\ud835\udd57":"fopf","\ud835\udcbb":"fscr","\ud835\udd09":"Ffr","\ud835\udd3d":"Fopf","\u2131":"Fscr","\ufb00":"fflig","\ufb03":"ffilig","\ufb04":"ffllig","\ufb01":"filig",fj:"fjlig","\ufb02":"fllig","\u0192":"fnof","\u210a":"gscr","\ud835\udd58":"gopf","\ud835\udd24":"gfr","\ud835\udca2":"Gscr","\ud835\udd3e":"Gopf","\ud835\udd0a":"Gfr","\u01f5":"gacute","\u011f":"gbreve","\u011e":"Gbreve","\u011d":"gcirc","\u011c":"Gcirc","\u0121":"gdot","\u0120":"Gdot","\u0122":"Gcedil","\ud835\udd25":"hfr","\u210e":"planckh","\ud835\udcbd":"hscr","\ud835\udd59":"hopf","\u210b":"Hscr","\u210c":"Hfr","\u210d":"Hopf","\u0125":"hcirc","\u0124":"Hcirc","\u210f":"hbar","\u0127":"hstrok","\u0126":"Hstrok","\ud835\udd5a":"iopf","\ud835\udd26":"ifr","\ud835\udcbe":"iscr","\u2148":"ii","\ud835\udd40":"Iopf","\u2110":"Iscr","\u2111":"Im","\xed":"iacute","\xcd":"Iacute","\xec":"igrave","\xcc":"Igrave","\xee":"icirc","\xce":"Icirc","\xef":"iuml","\xcf":"Iuml","\u0129":"itilde","\u0128":"Itilde","\u0130":"Idot","\u012f":"iogon","\u012e":"Iogon","\u012b":"imacr","\u012a":"Imacr","\u0133":"ijlig","\u0132":"IJlig","\u0131":"imath","\ud835\udcbf":"jscr","\ud835\udd5b":"jopf","\ud835\udd27":"jfr","\ud835\udca5":"Jscr","\ud835\udd0d":"Jfr","\ud835\udd41":"Jopf","\u0135":"jcirc","\u0134":"Jcirc","\u0237":"jmath","\ud835\udd5c":"kopf","\ud835\udcc0":"kscr","\ud835\udd28":"kfr","\ud835\udca6":"Kscr","\ud835\udd42":"Kopf","\ud835\udd0e":"Kfr","\u0137":"kcedil","\u0136":"Kcedil","\ud835\udd29":"lfr","\ud835\udcc1":"lscr","\u2113":"ell","\ud835\udd5d":"lopf","\u2112":"Lscr","\ud835\udd0f":"Lfr","\ud835\udd43":"Lopf","\u013a":"lacute","\u0139":"Lacute","\u013e":"lcaron","\u013d":"Lcaron","\u013c":"lcedil","\u013b":"Lcedil","\u0142":"lstrok","\u0141":"Lstrok","\u0140":"lmidot","\u013f":"Lmidot","\ud835\udd2a":"mfr","\ud835\udd5e":"mopf","\ud835\udcc2":"mscr","\ud835\udd10":"Mfr","\ud835\udd44":"Mopf","\u2133":"Mscr","\ud835\udd2b":"nfr","\ud835\udd5f":"nopf","\ud835\udcc3":"nscr","\u2115":"Nopf","\ud835\udca9":"Nscr","\ud835\udd11":"Nfr","\u0144":"nacute","\u0143":"Nacute","\u0148":"ncaron","\u0147":"Ncaron","\xf1":"ntilde","\xd1":"Ntilde","\u0146":"ncedil","\u0145":"Ncedil","\u2116":"numero","\u014b":"eng","\u014a":"ENG","\ud835\udd60":"oopf","\ud835\udd2c":"ofr","\u2134":"oscr","\ud835\udcaa":"Oscr","\ud835\udd12":"Ofr","\ud835\udd46":"Oopf","\xba":"ordm","\xf3":"oacute","\xd3":"Oacute","\xf2":"ograve","\xd2":"Ograve","\xf4":"ocirc","\xd4":"Ocirc","\xf6":"ouml","\xd6":"Ouml","\u0151":"odblac","\u0150":"Odblac","\xf5":"otilde","\xd5":"Otilde","\xf8":"oslash","\xd8":"Oslash","\u014d":"omacr","\u014c":"Omacr","\u0153":"oelig","\u0152":"OElig","\ud835\udd2d":"pfr","\ud835\udcc5":"pscr","\ud835\udd61":"popf","\u2119":"Popf","\ud835\udd13":"Pfr","\ud835\udcab":"Pscr","\ud835\udd62":"qopf","\ud835\udd2e":"qfr","\ud835\udcc6":"qscr","\ud835\udcac":"Qscr","\ud835\udd14":"Qfr","\u211a":"Qopf","\u0138":"kgreen","\ud835\udd2f":"rfr","\ud835\udd63":"ropf","\ud835\udcc7":"rscr","\u211b":"Rscr","\u211c":"Re","\u211d":"Ropf","\u0155":"racute","\u0154":"Racute","\u0159":"rcaron","\u0158":"Rcaron","\u0157":"rcedil","\u0156":"Rcedil","\ud835\udd64":"sopf","\ud835\udcc8":"sscr","\ud835\udd30":"sfr","\ud835\udd4a":"Sopf","\ud835\udd16":"Sfr","\ud835\udcae":"Sscr","\u24c8":"oS","\u015b":"sacute","\u015a":"Sacute","\u015d":"scirc","\u015c":"Scirc","\u0161":"scaron","\u0160":"Scaron","\u015f":"scedil","\u015e":"Scedil","\xdf":"szlig","\ud835\udd31":"tfr","\ud835\udcc9":"tscr","\ud835\udd65":"topf","\ud835\udcaf":"Tscr","\ud835\udd17":"Tfr","\ud835\udd4b":"Topf","\u0165":"tcaron","\u0164":"Tcaron","\u0163":"tcedil","\u0162":"Tcedil","\u2122":"trade","\u0167":"tstrok","\u0166":"Tstrok","\ud835\udcca":"uscr","\ud835\udd66":"uopf","\ud835\udd32":"ufr","\ud835\udd4c":"Uopf","\ud835\udd18":"Ufr","\ud835\udcb0":"Uscr","\xfa":"uacute","\xda":"Uacute","\xf9":"ugrave","\xd9":"Ugrave","\u016d":"ubreve","\u016c":"Ubreve","\xfb":"ucirc","\xdb":"Ucirc","\u016f":"uring","\u016e":"Uring","\xfc":"uuml","\xdc":"Uuml","\u0171":"udblac","\u0170":"Udblac","\u0169":"utilde","\u0168":"Utilde","\u0173":"uogon","\u0172":"Uogon","\u016b":"umacr","\u016a":"Umacr","\ud835\udd33":"vfr","\ud835\udd67":"vopf","\ud835\udccb":"vscr","\ud835\udd19":"Vfr","\ud835\udd4d":"Vopf","\ud835\udcb1":"Vscr","\ud835\udd68":"wopf","\ud835\udccc":"wscr","\ud835\udd34":"wfr","\ud835\udcb2":"Wscr","\ud835\udd4e":"Wopf","\ud835\udd1a":"Wfr","\u0175":"wcirc","\u0174":"Wcirc","\ud835\udd35":"xfr","\ud835\udccd":"xscr","\ud835\udd69":"xopf","\ud835\udd4f":"Xopf","\ud835\udd1b":"Xfr","\ud835\udcb3":"Xscr","\ud835\udd36":"yfr","\ud835\udcce":"yscr","\ud835\udd6a":"yopf","\ud835\udcb4":"Yscr","\ud835\udd1c":"Yfr","\ud835\udd50":"Yopf","\xfd":"yacute","\xdd":"Yacute","\u0177":"ycirc","\u0176":"Ycirc","\xff":"yuml","\u0178":"Yuml","\ud835\udccf":"zscr","\ud835\udd37":"zfr","\ud835\udd6b":"zopf","\u2128":"Zfr","\u2124":"Zopf","\ud835\udcb5":"Zscr","\u017a":"zacute","\u0179":"Zacute","\u017e":"zcaron","\u017d":"Zcaron","\u017c":"zdot","\u017b":"Zdot","\u01b5":"imped","\xfe":"thorn","\xde":"THORN","\u0149":"napos","\u03b1":"alpha","\u0391":"Alpha","\u03b2":"beta","\u0392":"Beta","\u03b3":"gamma","\u0393":"Gamma","\u03b4":"delta","\u0394":"Delta","\u03b5":"epsi","\u03f5":"epsiv","\u0395":"Epsilon","\u03dd":"gammad","\u03dc":"Gammad","\u03b6":"zeta","\u0396":"Zeta","\u03b7":"eta","\u0397":"Eta","\u03b8":"theta","\u03d1":"thetav","\u0398":"Theta","\u03b9":"iota","\u0399":"Iota","\u03ba":"kappa","\u03f0":"kappav","\u039a":"Kappa","\u03bb":"lambda","\u039b":"Lambda","\u03bc":"mu","\xb5":"micro","\u039c":"Mu","\u03bd":"nu","\u039d":"Nu","\u03be":"xi","\u039e":"Xi","\u03bf":"omicron","\u039f":"Omicron","\u03c0":"pi","\u03d6":"piv","\u03a0":"Pi","\u03c1":"rho","\u03f1":"rhov","\u03a1":"Rho","\u03c3":"sigma","\u03a3":"Sigma","\u03c2":"sigmaf","\u03c4":"tau","\u03a4":"Tau","\u03c5":"upsi","\u03a5":"Upsilon","\u03d2":"Upsi","\u03c6":"phi","\u03d5":"phiv","\u03a6":"Phi","\u03c7":"chi","\u03a7":"Chi","\u03c8":"psi","\u03a8":"Psi","\u03c9":"omega","\u03a9":"ohm","\u0430":"acy","\u0410":"Acy","\u0431":"bcy","\u0411":"Bcy","\u0432":"vcy","\u0412":"Vcy","\u0433":"gcy","\u0413":"Gcy","\u0453":"gjcy","\u0403":"GJcy","\u0434":"dcy","\u0414":"Dcy","\u0452":"djcy","\u0402":"DJcy","\u0435":"iecy","\u0415":"IEcy","\u0451":"iocy","\u0401":"IOcy","\u0454":"jukcy","\u0404":"Jukcy","\u0436":"zhcy","\u0416":"ZHcy","\u0437":"zcy","\u0417":"Zcy","\u0455":"dscy","\u0405":"DScy","\u0438":"icy","\u0418":"Icy","\u0456":"iukcy","\u0406":"Iukcy","\u0457":"yicy","\u0407":"YIcy","\u0439":"jcy","\u0419":"Jcy","\u0458":"jsercy","\u0408":"Jsercy","\u043a":"kcy","\u041a":"Kcy","\u045c":"kjcy","\u040c":"KJcy","\u043b":"lcy","\u041b":"Lcy","\u0459":"ljcy","\u0409":"LJcy","\u043c":"mcy","\u041c":"Mcy","\u043d":"ncy","\u041d":"Ncy","\u045a":"njcy","\u040a":"NJcy","\u043e":"ocy","\u041e":"Ocy","\u043f":"pcy","\u041f":"Pcy","\u0440":"rcy","\u0420":"Rcy","\u0441":"scy","\u0421":"Scy","\u0442":"tcy","\u0422":"Tcy","\u045b":"tshcy","\u040b":"TSHcy","\u0443":"ucy","\u0423":"Ucy","\u045e":"ubrcy","\u040e":"Ubrcy","\u0444":"fcy","\u0424":"Fcy","\u0445":"khcy","\u0425":"KHcy","\u0446":"tscy","\u0426":"TScy","\u0447":"chcy","\u0427":"CHcy","\u045f":"dzcy","\u040f":"DZcy","\u0448":"shcy","\u0428":"SHcy","\u0449":"shchcy","\u0429":"SHCHcy","\u044a":"hardcy","\u042a":"HARDcy","\u044b":"ycy","\u042b":"Ycy","\u044c":"softcy","\u042c":"SOFTcy","\u044d":"ecy","\u042d":"Ecy","\u044e":"yucy","\u042e":"YUcy","\u044f":"yacy","\u042f":"YAcy","\u2135":"aleph","\u2136":"beth","\u2137":"gimel","\u2138":"daleth"},u=/["&'<>`]/g,l={'"':"&quot;","&":"&amp;","'":"&#x27;","<":"&lt;",">":"&gt;","`":"&#x60;"},p=/&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/,f=/[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/,d=/&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g,m={aacute:"\xe1",Aacute:"\xc1",abreve:"\u0103",Abreve:"\u0102",ac:"\u223e",acd:"\u223f",acE:"\u223e\u0333",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",acy:"\u0430",Acy:"\u0410",aelig:"\xe6",AElig:"\xc6",af:"\u2061",afr:"\ud835\udd1e",Afr:"\ud835\udd04",agrave:"\xe0",Agrave:"\xc0",alefsym:"\u2135",aleph:"\u2135",alpha:"\u03b1",Alpha:"\u0391",amacr:"\u0101",Amacr:"\u0100",amalg:"\u2a3f",amp:"&",AMP:"&",and:"\u2227",And:"\u2a53",andand:"\u2a55",andd:"\u2a5c",andslope:"\u2a58",andv:"\u2a5a",ang:"\u2220",ange:"\u29a4",angle:"\u2220",angmsd:"\u2221",angmsdaa:"\u29a8",angmsdab:"\u29a9",angmsdac:"\u29aa",angmsdad:"\u29ab",angmsdae:"\u29ac",angmsdaf:"\u29ad",angmsdag:"\u29ae",angmsdah:"\u29af",angrt:"\u221f",angrtvb:"\u22be",angrtvbd:"\u299d",angsph:"\u2222",angst:"\xc5",angzarr:"\u237c",aogon:"\u0105",Aogon:"\u0104",aopf:"\ud835\udd52",Aopf:"\ud835\udd38",ap:"\u2248",apacir:"\u2a6f",ape:"\u224a",apE:"\u2a70",apid:"\u224b",apos:"'",ApplyFunction:"\u2061",approx:"\u2248",approxeq:"\u224a",aring:"\xe5",Aring:"\xc5",ascr:"\ud835\udcb6",Ascr:"\ud835\udc9c",Assign:"\u2254",ast:"*",asymp:"\u2248",asympeq:"\u224d",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",awconint:"\u2233",awint:"\u2a11",backcong:"\u224c",backepsilon:"\u03f6",backprime:"\u2035",backsim:"\u223d",backsimeq:"\u22cd",Backslash:"\u2216",Barv:"\u2ae7",barvee:"\u22bd",barwed:"\u2305",Barwed:"\u2306",barwedge:"\u2305",bbrk:"\u23b5",bbrktbrk:"\u23b6",bcong:"\u224c",bcy:"\u0431",Bcy:"\u0411",bdquo:"\u201e",becaus:"\u2235",because:"\u2235",Because:"\u2235",bemptyv:"\u29b0",bepsi:"\u03f6",bernou:"\u212c",Bernoullis:"\u212c",beta:"\u03b2",Beta:"\u0392",beth:"\u2136",between:"\u226c",bfr:"\ud835\udd1f",Bfr:"\ud835\udd05",bigcap:"\u22c2",bigcirc:"\u25ef",bigcup:"\u22c3",bigodot:"\u2a00",bigoplus:"\u2a01",bigotimes:"\u2a02",bigsqcup:"\u2a06",bigstar:"\u2605",bigtriangledown:"\u25bd",bigtriangleup:"\u25b3",biguplus:"\u2a04",bigvee:"\u22c1",bigwedge:"\u22c0",bkarow:"\u290d",blacklozenge:"\u29eb",blacksquare:"\u25aa",blacktriangle:"\u25b4",blacktriangledown:"\u25be",blacktriangleleft:"\u25c2",blacktriangleright:"\u25b8",blank:"\u2423",blk12:"\u2592",blk14:"\u2591",blk34:"\u2593",block:"\u2588",bne:"=\u20e5",bnequiv:"\u2261\u20e5",bnot:"\u2310",bNot:"\u2aed",bopf:"\ud835\udd53",Bopf:"\ud835\udd39",bot:"\u22a5",bottom:"\u22a5",bowtie:"\u22c8",boxbox:"\u29c9",boxdl:"\u2510",boxdL:"\u2555",boxDl:"\u2556",boxDL:"\u2557",boxdr:"\u250c",boxdR:"\u2552",boxDr:"\u2553",boxDR:"\u2554",boxh:"\u2500",boxH:"\u2550",boxhd:"\u252c",boxhD:"\u2565",boxHd:"\u2564",boxHD:"\u2566",boxhu:"\u2534",boxhU:"\u2568",boxHu:"\u2567",boxHU:"\u2569",boxminus:"\u229f",boxplus:"\u229e",boxtimes:"\u22a0",boxul:"\u2518",boxuL:"\u255b",boxUl:"\u255c",boxUL:"\u255d",boxur:"\u2514",boxuR:"\u2558",boxUr:"\u2559",boxUR:"\u255a",boxv:"\u2502",boxV:"\u2551",boxvh:"\u253c",boxvH:"\u256a",boxVh:"\u256b",boxVH:"\u256c",boxvl:"\u2524",boxvL:"\u2561",boxVl:"\u2562",boxVL:"\u2563",boxvr:"\u251c",boxvR:"\u255e",boxVr:"\u255f",boxVR:"\u2560",bprime:"\u2035",breve:"\u02d8",Breve:"\u02d8",brvbar:"\xa6",bscr:"\ud835\udcb7",Bscr:"\u212c",bsemi:"\u204f",bsim:"\u223d",bsime:"\u22cd",bsol:"\\",bsolb:"\u29c5",bsolhsub:"\u27c8",bull:"\u2022",bullet:"\u2022",bump:"\u224e",bumpe:"\u224f",bumpE:"\u2aae",bumpeq:"\u224f",Bumpeq:"\u224e",cacute:"\u0107",Cacute:"\u0106",cap:"\u2229",Cap:"\u22d2",capand:"\u2a44",capbrcup:"\u2a49",capcap:"\u2a4b",capcup:"\u2a47",capdot:"\u2a40",CapitalDifferentialD:"\u2145",caps:"\u2229\ufe00",caret:"\u2041",caron:"\u02c7",Cayleys:"\u212d",ccaps:"\u2a4d",ccaron:"\u010d",Ccaron:"\u010c",ccedil:"\xe7",Ccedil:"\xc7",ccirc:"\u0109",Ccirc:"\u0108",Cconint:"\u2230",ccups:"\u2a4c",ccupssm:"\u2a50",cdot:"\u010b",Cdot:"\u010a",cedil:"\xb8",Cedilla:"\xb8",cemptyv:"\u29b2",cent:"\xa2",centerdot:"\xb7",CenterDot:"\xb7",cfr:"\ud835\udd20",Cfr:"\u212d",chcy:"\u0447",CHcy:"\u0427",check:"\u2713",checkmark:"\u2713",chi:"\u03c7",Chi:"\u03a7",cir:"\u25cb",circ:"\u02c6",circeq:"\u2257",circlearrowleft:"\u21ba",circlearrowright:"\u21bb",circledast:"\u229b",circledcirc:"\u229a",circleddash:"\u229d",CircleDot:"\u2299",circledR:"\xae",circledS:"\u24c8",CircleMinus:"\u2296",CirclePlus:"\u2295",CircleTimes:"\u2297",cire:"\u2257",cirE:"\u29c3",cirfnint:"\u2a10",cirmid:"\u2aef",cirscir:"\u29c2",ClockwiseContourIntegral:"\u2232",CloseCurlyDoubleQuote:"\u201d",CloseCurlyQuote:"\u2019",clubs:"\u2663",clubsuit:"\u2663",colon:":",Colon:"\u2237",colone:"\u2254",Colone:"\u2a74",coloneq:"\u2254",comma:",",commat:"@",comp:"\u2201",compfn:"\u2218",complement:"\u2201",complexes:"\u2102",cong:"\u2245",congdot:"\u2a6d",Congruent:"\u2261",conint:"\u222e",Conint:"\u222f",ContourIntegral:"\u222e",copf:"\ud835\udd54",Copf:"\u2102",coprod:"\u2210",Coproduct:"\u2210",copy:"\xa9",COPY:"\xa9",copysr:"\u2117",CounterClockwiseContourIntegral:"\u2233",crarr:"\u21b5",cross:"\u2717",Cross:"\u2a2f",cscr:"\ud835\udcb8",Cscr:"\ud835\udc9e",csub:"\u2acf",csube:"\u2ad1",csup:"\u2ad0",csupe:"\u2ad2",ctdot:"\u22ef",cudarrl:"\u2938",cudarrr:"\u2935",cuepr:"\u22de",cuesc:"\u22df",cularr:"\u21b6",cularrp:"\u293d",cup:"\u222a",Cup:"\u22d3",cupbrcap:"\u2a48",cupcap:"\u2a46",CupCap:"\u224d",cupcup:"\u2a4a",cupdot:"\u228d",cupor:"\u2a45",cups:"\u222a\ufe00",curarr:"\u21b7",curarrm:"\u293c",curlyeqprec:"\u22de",curlyeqsucc:"\u22df",curlyvee:"\u22ce",curlywedge:"\u22cf",curren:"\xa4",curvearrowleft:"\u21b6",curvearrowright:"\u21b7",cuvee:"\u22ce",cuwed:"\u22cf",cwconint:"\u2232",cwint:"\u2231",cylcty:"\u232d",dagger:"\u2020",Dagger:"\u2021",daleth:"\u2138",darr:"\u2193",dArr:"\u21d3",Darr:"\u21a1",dash:"\u2010",dashv:"\u22a3",Dashv:"\u2ae4",dbkarow:"\u290f",dblac:"\u02dd",dcaron:"\u010f",Dcaron:"\u010e",dcy:"\u0434",Dcy:"\u0414",dd:"\u2146",DD:"\u2145",ddagger:"\u2021",ddarr:"\u21ca",DDotrahd:"\u2911",ddotseq:"\u2a77",deg:"\xb0",Del:"\u2207",delta:"\u03b4",Delta:"\u0394",demptyv:"\u29b1",dfisht:"\u297f",dfr:"\ud835\udd21",Dfr:"\ud835\udd07",dHar:"\u2965",dharl:"\u21c3",dharr:"\u21c2",DiacriticalAcute:"\xb4",DiacriticalDot:"\u02d9",DiacriticalDoubleAcute:"\u02dd",DiacriticalGrave:"`",DiacriticalTilde:"\u02dc",diam:"\u22c4",diamond:"\u22c4",Diamond:"\u22c4",diamondsuit:"\u2666",diams:"\u2666",die:"\xa8",DifferentialD:"\u2146",digamma:"\u03dd",disin:"\u22f2",div:"\xf7",divide:"\xf7",divideontimes:"\u22c7",divonx:"\u22c7",djcy:"\u0452",DJcy:"\u0402",dlcorn:"\u231e",dlcrop:"\u230d",dollar:"$",dopf:"\ud835\udd55",Dopf:"\ud835\udd3b",dot:"\u02d9",Dot:"\xa8",DotDot:"\u20dc",doteq:"\u2250",doteqdot:"\u2251",DotEqual:"\u2250",dotminus:"\u2238",dotplus:"\u2214",dotsquare:"\u22a1",doublebarwedge:"\u2306",DoubleContourIntegral:"\u222f",DoubleDot:"\xa8",DoubleDownArrow:"\u21d3",DoubleLeftArrow:"\u21d0",DoubleLeftRightArrow:"\u21d4",DoubleLeftTee:"\u2ae4",DoubleLongLeftArrow:"\u27f8",DoubleLongLeftRightArrow:"\u27fa",DoubleLongRightArrow:"\u27f9",DoubleRightArrow:"\u21d2",DoubleRightTee:"\u22a8",DoubleUpArrow:"\u21d1",DoubleUpDownArrow:"\u21d5",DoubleVerticalBar:"\u2225",downarrow:"\u2193",Downarrow:"\u21d3",DownArrow:"\u2193",DownArrowBar:"\u2913",DownArrowUpArrow:"\u21f5",DownBreve:"\u0311",downdownarrows:"\u21ca",downharpoonleft:"\u21c3",downharpoonright:"\u21c2",DownLeftRightVector:"\u2950",DownLeftTeeVector:"\u295e",DownLeftVector:"\u21bd",DownLeftVectorBar:"\u2956",DownRightTeeVector:"\u295f",DownRightVector:"\u21c1",DownRightVectorBar:"\u2957",DownTee:"\u22a4",DownTeeArrow:"\u21a7",drbkarow:"\u2910",drcorn:"\u231f",drcrop:"\u230c",dscr:"\ud835\udcb9",Dscr:"\ud835\udc9f",dscy:"\u0455",DScy:"\u0405",dsol:"\u29f6",dstrok:"\u0111",Dstrok:"\u0110",dtdot:"\u22f1",dtri:"\u25bf",dtrif:"\u25be",duarr:"\u21f5",duhar:"\u296f",dwangle:"\u29a6",dzcy:"\u045f",DZcy:"\u040f",dzigrarr:"\u27ff",eacute:"\xe9",Eacute:"\xc9",easter:"\u2a6e",ecaron:"\u011b",Ecaron:"\u011a",ecir:"\u2256",ecirc:"\xea",Ecirc:"\xca",ecolon:"\u2255",ecy:"\u044d",Ecy:"\u042d",eDDot:"\u2a77",edot:"\u0117",eDot:"\u2251",Edot:"\u0116",ee:"\u2147",efDot:"\u2252",efr:"\ud835\udd22",Efr:"\ud835\udd08",eg:"\u2a9a",egrave:"\xe8",Egrave:"\xc8",egs:"\u2a96",egsdot:"\u2a98",el:"\u2a99",Element:"\u2208",elinters:"\u23e7",ell:"\u2113",els:"\u2a95",elsdot:"\u2a97",emacr:"\u0113",Emacr:"\u0112",empty:"\u2205",emptyset:"\u2205",EmptySmallSquare:"\u25fb",emptyv:"\u2205",EmptyVerySmallSquare:"\u25ab",emsp:"\u2003",emsp13:"\u2004",emsp14:"\u2005",eng:"\u014b",ENG:"\u014a",ensp:"\u2002",eogon:"\u0119",Eogon:"\u0118",eopf:"\ud835\udd56",Eopf:"\ud835\udd3c",epar:"\u22d5",eparsl:"\u29e3",eplus:"\u2a71",epsi:"\u03b5",epsilon:"\u03b5",Epsilon:"\u0395",epsiv:"\u03f5",eqcirc:"\u2256",eqcolon:"\u2255",eqsim:"\u2242",eqslantgtr:"\u2a96",eqslantless:"\u2a95",Equal:"\u2a75",equals:"=",EqualTilde:"\u2242",equest:"\u225f",Equilibrium:"\u21cc",equiv:"\u2261",equivDD:"\u2a78",eqvparsl:"\u29e5",erarr:"\u2971",erDot:"\u2253",escr:"\u212f",Escr:"\u2130",esdot:"\u2250",esim:"\u2242",Esim:"\u2a73",eta:"\u03b7",Eta:"\u0397",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",euro:"\u20ac",excl:"!",exist:"\u2203",Exists:"\u2203",expectation:"\u2130",exponentiale:"\u2147",ExponentialE:"\u2147",fallingdotseq:"\u2252",fcy:"\u0444",Fcy:"\u0424",female:"\u2640",ffilig:"\ufb03",fflig:"\ufb00",ffllig:"\ufb04",ffr:"\ud835\udd23",Ffr:"\ud835\udd09",filig:"\ufb01",FilledSmallSquare:"\u25fc",FilledVerySmallSquare:"\u25aa",fjlig:"fj",flat:"\u266d",fllig:"\ufb02",fltns:"\u25b1",fnof:"\u0192",fopf:"\ud835\udd57",Fopf:"\ud835\udd3d",forall:"\u2200",ForAll:"\u2200",fork:"\u22d4",forkv:"\u2ad9",Fouriertrf:"\u2131",fpartint:"\u2a0d",frac12:"\xbd",frac13:"\u2153",frac14:"\xbc",frac15:"\u2155",frac16:"\u2159",frac18:"\u215b",frac23:"\u2154",frac25:"\u2156",frac34:"\xbe",frac35:"\u2157",frac38:"\u215c",frac45:"\u2158",frac56:"\u215a",frac58:"\u215d",frac78:"\u215e",frasl:"\u2044",frown:"\u2322",fscr:"\ud835\udcbb",Fscr:"\u2131",gacute:"\u01f5",gamma:"\u03b3",Gamma:"\u0393",gammad:"\u03dd",Gammad:"\u03dc",gap:"\u2a86",gbreve:"\u011f",Gbreve:"\u011e",Gcedil:"\u0122",gcirc:"\u011d",Gcirc:"\u011c",gcy:"\u0433",Gcy:"\u0413",gdot:"\u0121",Gdot:"\u0120",ge:"\u2265",gE:"\u2267",gel:"\u22db",gEl:"\u2a8c",geq:"\u2265",geqq:"\u2267",geqslant:"\u2a7e",ges:"\u2a7e",gescc:"\u2aa9",gesdot:"\u2a80",gesdoto:"\u2a82",gesdotol:"\u2a84",gesl:"\u22db\ufe00",gesles:"\u2a94",gfr:"\ud835\udd24",Gfr:"\ud835\udd0a",gg:"\u226b",Gg:"\u22d9",ggg:"\u22d9",gimel:"\u2137",gjcy:"\u0453",GJcy:"\u0403",gl:"\u2277",gla:"\u2aa5",glE:"\u2a92",glj:"\u2aa4",gnap:"\u2a8a",gnapprox:"\u2a8a",gne:"\u2a88",gnE:"\u2269",gneq:"\u2a88",gneqq:"\u2269",gnsim:"\u22e7",gopf:"\ud835\udd58",Gopf:"\ud835\udd3e",grave:"`",GreaterEqual:"\u2265",GreaterEqualLess:"\u22db",GreaterFullEqual:"\u2267",GreaterGreater:"\u2aa2",GreaterLess:"\u2277",GreaterSlantEqual:"\u2a7e",GreaterTilde:"\u2273",gscr:"\u210a",Gscr:"\ud835\udca2",gsim:"\u2273",gsime:"\u2a8e",gsiml:"\u2a90",gt:">",Gt:"\u226b",GT:">",gtcc:"\u2aa7",gtcir:"\u2a7a",gtdot:"\u22d7",gtlPar:"\u2995",gtquest:"\u2a7c",gtrapprox:"\u2a86",gtrarr:"\u2978",gtrdot:"\u22d7",gtreqless:"\u22db",gtreqqless:"\u2a8c",gtrless:"\u2277",gtrsim:"\u2273",gvertneqq:"\u2269\ufe00",gvnE:"\u2269\ufe00",Hacek:"\u02c7",hairsp:"\u200a",half:"\xbd",hamilt:"\u210b",hardcy:"\u044a",HARDcy:"\u042a",harr:"\u2194",hArr:"\u21d4",harrcir:"\u2948",harrw:"\u21ad",Hat:"^",hbar:"\u210f",hcirc:"\u0125",Hcirc:"\u0124",hearts:"\u2665",heartsuit:"\u2665",hellip:"\u2026",hercon:"\u22b9",hfr:"\ud835\udd25",Hfr:"\u210c",HilbertSpace:"\u210b",hksearow:"\u2925",hkswarow:"\u2926",hoarr:"\u21ff",homtht:"\u223b",hookleftarrow:"\u21a9",hookrightarrow:"\u21aa",hopf:"\ud835\udd59",Hopf:"\u210d",horbar:"\u2015",HorizontalLine:"\u2500",hscr:"\ud835\udcbd",Hscr:"\u210b",hslash:"\u210f",hstrok:"\u0127",Hstrok:"\u0126",HumpDownHump:"\u224e",HumpEqual:"\u224f",hybull:"\u2043",hyphen:"\u2010",iacute:"\xed",Iacute:"\xcd",ic:"\u2063",icirc:"\xee",Icirc:"\xce",icy:"\u0438",Icy:"\u0418",Idot:"\u0130",iecy:"\u0435",IEcy:"\u0415",iexcl:"\xa1",iff:"\u21d4",ifr:"\ud835\udd26",Ifr:"\u2111",igrave:"\xec",Igrave:"\xcc",ii:"\u2148",iiiint:"\u2a0c",iiint:"\u222d",iinfin:"\u29dc",iiota:"\u2129",ijlig:"\u0133",IJlig:"\u0132",Im:"\u2111",imacr:"\u012b",Imacr:"\u012a",image:"\u2111",ImaginaryI:"\u2148",imagline:"\u2110",imagpart:"\u2111",imath:"\u0131",imof:"\u22b7",imped:"\u01b5",Implies:"\u21d2",in:"\u2208",incare:"\u2105",infin:"\u221e",infintie:"\u29dd",inodot:"\u0131",int:"\u222b",Int:"\u222c",intcal:"\u22ba",integers:"\u2124",Integral:"\u222b",intercal:"\u22ba",Intersection:"\u22c2",intlarhk:"\u2a17",intprod:"\u2a3c",InvisibleComma:"\u2063",InvisibleTimes:"\u2062",iocy:"\u0451",IOcy:"\u0401",iogon:"\u012f",Iogon:"\u012e",iopf:"\ud835\udd5a",Iopf:"\ud835\udd40",iota:"\u03b9",Iota:"\u0399",iprod:"\u2a3c",iquest:"\xbf",iscr:"\ud835\udcbe",Iscr:"\u2110",isin:"\u2208",isindot:"\u22f5",isinE:"\u22f9",isins:"\u22f4",isinsv:"\u22f3",isinv:"\u2208",it:"\u2062",itilde:"\u0129",Itilde:"\u0128",iukcy:"\u0456",Iukcy:"\u0406",iuml:"\xef",Iuml:"\xcf",jcirc:"\u0135",Jcirc:"\u0134",jcy:"\u0439",Jcy:"\u0419",jfr:"\ud835\udd27",Jfr:"\ud835\udd0d",jmath:"\u0237",jopf:"\ud835\udd5b",Jopf:"\ud835\udd41",jscr:"\ud835\udcbf",Jscr:"\ud835\udca5",jsercy:"\u0458",Jsercy:"\u0408",jukcy:"\u0454",Jukcy:"\u0404",kappa:"\u03ba",Kappa:"\u039a",kappav:"\u03f0",kcedil:"\u0137",Kcedil:"\u0136",kcy:"\u043a",Kcy:"\u041a",kfr:"\ud835\udd28",Kfr:"\ud835\udd0e",kgreen:"\u0138",khcy:"\u0445",KHcy:"\u0425",kjcy:"\u045c",KJcy:"\u040c",kopf:"\ud835\udd5c",Kopf:"\ud835\udd42",kscr:"\ud835\udcc0",Kscr:"\ud835\udca6",lAarr:"\u21da",lacute:"\u013a",Lacute:"\u0139",laemptyv:"\u29b4",lagran:"\u2112",lambda:"\u03bb",Lambda:"\u039b",lang:"\u27e8",Lang:"\u27ea",langd:"\u2991",langle:"\u27e8",lap:"\u2a85",Laplacetrf:"\u2112",laquo:"\xab",larr:"\u2190",lArr:"\u21d0",Larr:"\u219e",larrb:"\u21e4",larrbfs:"\u291f",larrfs:"\u291d",larrhk:"\u21a9",larrlp:"\u21ab",larrpl:"\u2939",larrsim:"\u2973",larrtl:"\u21a2",lat:"\u2aab",latail:"\u2919",lAtail:"\u291b",late:"\u2aad",lates:"\u2aad\ufe00",lbarr:"\u290c",lBarr:"\u290e",lbbrk:"\u2772",lbrace:"{",lbrack:"[",lbrke:"\u298b",lbrksld:"\u298f",lbrkslu:"\u298d",lcaron:"\u013e",Lcaron:"\u013d",lcedil:"\u013c",Lcedil:"\u013b",lceil:"\u2308",lcub:"{",lcy:"\u043b",Lcy:"\u041b",ldca:"\u2936",ldquo:"\u201c",ldquor:"\u201e",ldrdhar:"\u2967",ldrushar:"\u294b",ldsh:"\u21b2",le:"\u2264",lE:"\u2266",LeftAngleBracket:"\u27e8",leftarrow:"\u2190",Leftarrow:"\u21d0",LeftArrow:"\u2190",LeftArrowBar:"\u21e4",LeftArrowRightArrow:"\u21c6",leftarrowtail:"\u21a2",LeftCeiling:"\u2308",LeftDoubleBracket:"\u27e6",LeftDownTeeVector:"\u2961",LeftDownVector:"\u21c3",LeftDownVectorBar:"\u2959",LeftFloor:"\u230a",leftharpoondown:"\u21bd",leftharpoonup:"\u21bc",leftleftarrows:"\u21c7",leftrightarrow:"\u2194",Leftrightarrow:"\u21d4",LeftRightArrow:"\u2194",leftrightarrows:"\u21c6",leftrightharpoons:"\u21cb",leftrightsquigarrow:"\u21ad",LeftRightVector:"\u294e",LeftTee:"\u22a3",LeftTeeArrow:"\u21a4",LeftTeeVector:"\u295a",leftthreetimes:"\u22cb",LeftTriangle:"\u22b2",LeftTriangleBar:"\u29cf",LeftTriangleEqual:"\u22b4",LeftUpDownVector:"\u2951",LeftUpTeeVector:"\u2960",LeftUpVector:"\u21bf",LeftUpVectorBar:"\u2958",LeftVector:"\u21bc",LeftVectorBar:"\u2952",leg:"\u22da",lEg:"\u2a8b",leq:"\u2264",leqq:"\u2266",leqslant:"\u2a7d",les:"\u2a7d",lescc:"\u2aa8",lesdot:"\u2a7f",lesdoto:"\u2a81",lesdotor:"\u2a83",lesg:"\u22da\ufe00",lesges:"\u2a93",lessapprox:"\u2a85",lessdot:"\u22d6",lesseqgtr:"\u22da",lesseqqgtr:"\u2a8b",LessEqualGreater:"\u22da",LessFullEqual:"\u2266",LessGreater:"\u2276",lessgtr:"\u2276",LessLess:"\u2aa1",lesssim:"\u2272",LessSlantEqual:"\u2a7d",LessTilde:"\u2272",lfisht:"\u297c",lfloor:"\u230a",lfr:"\ud835\udd29",Lfr:"\ud835\udd0f",lg:"\u2276",lgE:"\u2a91",lHar:"\u2962",lhard:"\u21bd",lharu:"\u21bc",lharul:"\u296a",lhblk:"\u2584",ljcy:"\u0459",LJcy:"\u0409",ll:"\u226a",Ll:"\u22d8",llarr:"\u21c7",llcorner:"\u231e",Lleftarrow:"\u21da",llhard:"\u296b",lltri:"\u25fa",lmidot:"\u0140",Lmidot:"\u013f",lmoust:"\u23b0",lmoustache:"\u23b0",lnap:"\u2a89",lnapprox:"\u2a89",lne:"\u2a87",lnE:"\u2268",lneq:"\u2a87",lneqq:"\u2268",lnsim:"\u22e6",loang:"\u27ec",loarr:"\u21fd",lobrk:"\u27e6",longleftarrow:"\u27f5",Longleftarrow:"\u27f8",LongLeftArrow:"\u27f5",longleftrightarrow:"\u27f7",Longleftrightarrow:"\u27fa",LongLeftRightArrow:"\u27f7",longmapsto:"\u27fc",longrightarrow:"\u27f6",Longrightarrow:"\u27f9",LongRightArrow:"\u27f6",looparrowleft:"\u21ab",looparrowright:"\u21ac",lopar:"\u2985",lopf:"\ud835\udd5d",Lopf:"\ud835\udd43",loplus:"\u2a2d",lotimes:"\u2a34",lowast:"\u2217",lowbar:"_",LowerLeftArrow:"\u2199",LowerRightArrow:"\u2198",loz:"\u25ca",lozenge:"\u25ca",lozf:"\u29eb",lpar:"(",lparlt:"\u2993",lrarr:"\u21c6",lrcorner:"\u231f",lrhar:"\u21cb",lrhard:"\u296d",lrm:"\u200e",lrtri:"\u22bf",lsaquo:"\u2039",lscr:"\ud835\udcc1",Lscr:"\u2112",lsh:"\u21b0",Lsh:"\u21b0",lsim:"\u2272",lsime:"\u2a8d",lsimg:"\u2a8f",lsqb:"[",lsquo:"\u2018",lsquor:"\u201a",lstrok:"\u0142",Lstrok:"\u0141",lt:"<",Lt:"\u226a",LT:"<",ltcc:"\u2aa6",ltcir:"\u2a79",ltdot:"\u22d6",lthree:"\u22cb",ltimes:"\u22c9",ltlarr:"\u2976",ltquest:"\u2a7b",ltri:"\u25c3",ltrie:"\u22b4",ltrif:"\u25c2",ltrPar:"\u2996",lurdshar:"\u294a",luruhar:"\u2966",lvertneqq:"\u2268\ufe00",lvnE:"\u2268\ufe00",macr:"\xaf",male:"\u2642",malt:"\u2720",maltese:"\u2720",map:"\u21a6",Map:"\u2905",mapsto:"\u21a6",mapstodown:"\u21a7",mapstoleft:"\u21a4",mapstoup:"\u21a5",marker:"\u25ae",mcomma:"\u2a29",mcy:"\u043c",Mcy:"\u041c",mdash:"\u2014",mDDot:"\u223a",measuredangle:"\u2221",MediumSpace:"\u205f",Mellintrf:"\u2133",mfr:"\ud835\udd2a",Mfr:"\ud835\udd10",mho:"\u2127",micro:"\xb5",mid:"\u2223",midast:"*",midcir:"\u2af0",middot:"\xb7",minus:"\u2212",minusb:"\u229f",minusd:"\u2238",minusdu:"\u2a2a",MinusPlus:"\u2213",mlcp:"\u2adb",mldr:"\u2026",mnplus:"\u2213",models:"\u22a7",mopf:"\ud835\udd5e",Mopf:"\ud835\udd44",mp:"\u2213",mscr:"\ud835\udcc2",Mscr:"\u2133",mstpos:"\u223e",mu:"\u03bc",Mu:"\u039c",multimap:"\u22b8",mumap:"\u22b8",nabla:"\u2207",nacute:"\u0144",Nacute:"\u0143",nang:"\u2220\u20d2",nap:"\u2249",napE:"\u2a70\u0338",napid:"\u224b\u0338",napos:"\u0149",napprox:"\u2249",natur:"\u266e",natural:"\u266e",naturals:"\u2115",nbsp:"\xa0",nbump:"\u224e\u0338",nbumpe:"\u224f\u0338",ncap:"\u2a43",ncaron:"\u0148",Ncaron:"\u0147",ncedil:"\u0146",Ncedil:"\u0145",ncong:"\u2247",ncongdot:"\u2a6d\u0338",ncup:"\u2a42",ncy:"\u043d",Ncy:"\u041d",ndash:"\u2013",ne:"\u2260",nearhk:"\u2924",nearr:"\u2197",neArr:"\u21d7",nearrow:"\u2197",nedot:"\u2250\u0338",NegativeMediumSpace:"\u200b",NegativeThickSpace:"\u200b",NegativeThinSpace:"\u200b",NegativeVeryThinSpace:"\u200b",nequiv:"\u2262",nesear:"\u2928",nesim:"\u2242\u0338",NestedGreaterGreater:"\u226b",NestedLessLess:"\u226a",NewLine:"\n",nexist:"\u2204",nexists:"\u2204",nfr:"\ud835\udd2b",Nfr:"\ud835\udd11",nge:"\u2271",ngE:"\u2267\u0338",ngeq:"\u2271",ngeqq:"\u2267\u0338",ngeqslant:"\u2a7e\u0338",nges:"\u2a7e\u0338",nGg:"\u22d9\u0338",ngsim:"\u2275",ngt:"\u226f",nGt:"\u226b\u20d2",ngtr:"\u226f",nGtv:"\u226b\u0338",nharr:"\u21ae",nhArr:"\u21ce",nhpar:"\u2af2",ni:"\u220b",nis:"\u22fc",nisd:"\u22fa",niv:"\u220b",njcy:"\u045a",NJcy:"\u040a",nlarr:"\u219a",nlArr:"\u21cd",nldr:"\u2025",nle:"\u2270",nlE:"\u2266\u0338",nleftarrow:"\u219a",nLeftarrow:"\u21cd",nleftrightarrow:"\u21ae",nLeftrightarrow:"\u21ce",nleq:"\u2270",nleqq:"\u2266\u0338",nleqslant:"\u2a7d\u0338",nles:"\u2a7d\u0338",nless:"\u226e",nLl:"\u22d8\u0338",nlsim:"\u2274",nlt:"\u226e",nLt:"\u226a\u20d2",nltri:"\u22ea",nltrie:"\u22ec",nLtv:"\u226a\u0338",nmid:"\u2224",NoBreak:"\u2060",NonBreakingSpace:"\xa0",nopf:"\ud835\udd5f",Nopf:"\u2115",not:"\xac",Not:"\u2aec",NotCongruent:"\u2262",NotCupCap:"\u226d",NotDoubleVerticalBar:"\u2226",NotElement:"\u2209",NotEqual:"\u2260",NotEqualTilde:"\u2242\u0338",NotExists:"\u2204",NotGreater:"\u226f",NotGreaterEqual:"\u2271",NotGreaterFullEqual:"\u2267\u0338",NotGreaterGreater:"\u226b\u0338",NotGreaterLess:"\u2279",NotGreaterSlantEqual:"\u2a7e\u0338",NotGreaterTilde:"\u2275",NotHumpDownHump:"\u224e\u0338",NotHumpEqual:"\u224f\u0338",notin:"\u2209",notindot:"\u22f5\u0338",notinE:"\u22f9\u0338",notinva:"\u2209",notinvb:"\u22f7",notinvc:"\u22f6",NotLeftTriangle:"\u22ea",NotLeftTriangleBar:"\u29cf\u0338",NotLeftTriangleEqual:"\u22ec",NotLess:"\u226e",NotLessEqual:"\u2270",NotLessGreater:"\u2278",NotLessLess:"\u226a\u0338",NotLessSlantEqual:"\u2a7d\u0338",NotLessTilde:"\u2274",NotNestedGreaterGreater:"\u2aa2\u0338",NotNestedLessLess:"\u2aa1\u0338",notni:"\u220c",notniva:"\u220c",notnivb:"\u22fe",notnivc:"\u22fd",NotPrecedes:"\u2280",NotPrecedesEqual:"\u2aaf\u0338",NotPrecedesSlantEqual:"\u22e0",NotReverseElement:"\u220c",NotRightTriangle:"\u22eb",NotRightTriangleBar:"\u29d0\u0338",NotRightTriangleEqual:"\u22ed",NotSquareSubset:"\u228f\u0338",NotSquareSubsetEqual:"\u22e2",NotSquareSuperset:"\u2290\u0338",NotSquareSupersetEqual:"\u22e3",NotSubset:"\u2282\u20d2",NotSubsetEqual:"\u2288",NotSucceeds:"\u2281",NotSucceedsEqual:"\u2ab0\u0338",NotSucceedsSlantEqual:"\u22e1",NotSucceedsTilde:"\u227f\u0338",NotSuperset:"\u2283\u20d2",NotSupersetEqual:"\u2289",NotTilde:"\u2241",NotTildeEqual:"\u2244",NotTildeFullEqual:"\u2247",NotTildeTilde:"\u2249",NotVerticalBar:"\u2224",npar:"\u2226",nparallel:"\u2226",nparsl:"\u2afd\u20e5",npart:"\u2202\u0338",npolint:"\u2a14",npr:"\u2280",nprcue:"\u22e0",npre:"\u2aaf\u0338",nprec:"\u2280",npreceq:"\u2aaf\u0338",nrarr:"\u219b",nrArr:"\u21cf",nrarrc:"\u2933\u0338",nrarrw:"\u219d\u0338",nrightarrow:"\u219b",nRightarrow:"\u21cf",nrtri:"\u22eb",nrtrie:"\u22ed",nsc:"\u2281",nsccue:"\u22e1",nsce:"\u2ab0\u0338",nscr:"\ud835\udcc3",Nscr:"\ud835\udca9",nshortmid:"\u2224",nshortparallel:"\u2226",nsim:"\u2241",nsime:"\u2244",nsimeq:"\u2244",nsmid:"\u2224",nspar:"\u2226",nsqsube:"\u22e2",nsqsupe:"\u22e3",nsub:"\u2284",nsube:"\u2288",nsubE:"\u2ac5\u0338",nsubset:"\u2282\u20d2",nsubseteq:"\u2288",nsubseteqq:"\u2ac5\u0338",nsucc:"\u2281",nsucceq:"\u2ab0\u0338",nsup:"\u2285",nsupe:"\u2289",nsupE:"\u2ac6\u0338",nsupset:"\u2283\u20d2",nsupseteq:"\u2289",nsupseteqq:"\u2ac6\u0338",ntgl:"\u2279",ntilde:"\xf1",Ntilde:"\xd1",ntlg:"\u2278",ntriangleleft:"\u22ea",ntrianglelefteq:"\u22ec",ntriangleright:"\u22eb",ntrianglerighteq:"\u22ed",nu:"\u03bd",Nu:"\u039d",num:"#",numero:"\u2116",numsp:"\u2007",nvap:"\u224d\u20d2",nvdash:"\u22ac",nvDash:"\u22ad",nVdash:"\u22ae",nVDash:"\u22af",nvge:"\u2265\u20d2",nvgt:">\u20d2",nvHarr:"\u2904",nvinfin:"\u29de",nvlArr:"\u2902",nvle:"\u2264\u20d2",nvlt:"<\u20d2",nvltrie:"\u22b4\u20d2",nvrArr:"\u2903",nvrtrie:"\u22b5\u20d2",nvsim:"\u223c\u20d2",nwarhk:"\u2923",nwarr:"\u2196",nwArr:"\u21d6",nwarrow:"\u2196",nwnear:"\u2927",oacute:"\xf3",Oacute:"\xd3",oast:"\u229b",ocir:"\u229a",ocirc:"\xf4",Ocirc:"\xd4",ocy:"\u043e",Ocy:"\u041e",odash:"\u229d",odblac:"\u0151",Odblac:"\u0150",odiv:"\u2a38",odot:"\u2299",odsold:"\u29bc",oelig:"\u0153",OElig:"\u0152",ofcir:"\u29bf",ofr:"\ud835\udd2c",Ofr:"\ud835\udd12",ogon:"\u02db",ograve:"\xf2",Ograve:"\xd2",ogt:"\u29c1",ohbar:"\u29b5",ohm:"\u03a9",oint:"\u222e",olarr:"\u21ba",olcir:"\u29be",olcross:"\u29bb",oline:"\u203e",olt:"\u29c0",omacr:"\u014d",Omacr:"\u014c",omega:"\u03c9",Omega:"\u03a9",omicron:"\u03bf",Omicron:"\u039f",omid:"\u29b6",ominus:"\u2296",oopf:"\ud835\udd60",Oopf:"\ud835\udd46",opar:"\u29b7",OpenCurlyDoubleQuote:"\u201c",OpenCurlyQuote:"\u2018",operp:"\u29b9",oplus:"\u2295",or:"\u2228",Or:"\u2a54",orarr:"\u21bb",ord:"\u2a5d",order:"\u2134",orderof:"\u2134",ordf:"\xaa",ordm:"\xba",origof:"\u22b6",oror:"\u2a56",orslope:"\u2a57",orv:"\u2a5b",oS:"\u24c8",oscr:"\u2134",Oscr:"\ud835\udcaa",oslash:"\xf8",Oslash:"\xd8",osol:"\u2298",otilde:"\xf5",Otilde:"\xd5",otimes:"\u2297",Otimes:"\u2a37",otimesas:"\u2a36",ouml:"\xf6",Ouml:"\xd6",ovbar:"\u233d",OverBar:"\u203e",OverBrace:"\u23de",OverBracket:"\u23b4",OverParenthesis:"\u23dc",par:"\u2225",para:"\xb6",parallel:"\u2225",parsim:"\u2af3",parsl:"\u2afd",part:"\u2202",PartialD:"\u2202",pcy:"\u043f",Pcy:"\u041f",percnt:"%",period:".",permil:"\u2030",perp:"\u22a5",pertenk:"\u2031",pfr:"\ud835\udd2d",Pfr:"\ud835\udd13",phi:"\u03c6",Phi:"\u03a6",phiv:"\u03d5",phmmat:"\u2133",phone:"\u260e",pi:"\u03c0",Pi:"\u03a0",pitchfork:"\u22d4",piv:"\u03d6",planck:"\u210f",planckh:"\u210e",plankv:"\u210f",plus:"+",plusacir:"\u2a23",plusb:"\u229e",pluscir:"\u2a22",plusdo:"\u2214",plusdu:"\u2a25",pluse:"\u2a72",PlusMinus:"\xb1",plusmn:"\xb1",plussim:"\u2a26",plustwo:"\u2a27",pm:"\xb1",Poincareplane:"\u210c",pointint:"\u2a15",popf:"\ud835\udd61",Popf:"\u2119",pound:"\xa3",pr:"\u227a",Pr:"\u2abb",prap:"\u2ab7",prcue:"\u227c",pre:"\u2aaf",prE:"\u2ab3",prec:"\u227a",precapprox:"\u2ab7",preccurlyeq:"\u227c",Precedes:"\u227a",PrecedesEqual:"\u2aaf",PrecedesSlantEqual:"\u227c",PrecedesTilde:"\u227e",preceq:"\u2aaf",precnapprox:"\u2ab9",precneqq:"\u2ab5",precnsim:"\u22e8",precsim:"\u227e",prime:"\u2032",Prime:"\u2033",primes:"\u2119",prnap:"\u2ab9",prnE:"\u2ab5",prnsim:"\u22e8",prod:"\u220f",Product:"\u220f",profalar:"\u232e",profline:"\u2312",profsurf:"\u2313",prop:"\u221d",Proportion:"\u2237",Proportional:"\u221d",propto:"\u221d",prsim:"\u227e",prurel:"\u22b0",pscr:"\ud835\udcc5",Pscr:"\ud835\udcab",psi:"\u03c8",Psi:"\u03a8",puncsp:"\u2008",qfr:"\ud835\udd2e",Qfr:"\ud835\udd14",qint:"\u2a0c",qopf:"\ud835\udd62",Qopf:"\u211a",qprime:"\u2057",qscr:"\ud835\udcc6",Qscr:"\ud835\udcac",quaternions:"\u210d",quatint:"\u2a16",quest:"?",questeq:"\u225f",quot:'"',QUOT:'"',rAarr:"\u21db",race:"\u223d\u0331",racute:"\u0155",Racute:"\u0154",radic:"\u221a",raemptyv:"\u29b3",rang:"\u27e9",Rang:"\u27eb",rangd:"\u2992",range:"\u29a5",rangle:"\u27e9",raquo:"\xbb",rarr:"\u2192",rArr:"\u21d2",Rarr:"\u21a0",rarrap:"\u2975",rarrb:"\u21e5",rarrbfs:"\u2920",rarrc:"\u2933",rarrfs:"\u291e",rarrhk:"\u21aa",rarrlp:"\u21ac",rarrpl:"\u2945",rarrsim:"\u2974",rarrtl:"\u21a3",Rarrtl:"\u2916",rarrw:"\u219d",ratail:"\u291a",rAtail:"\u291c",ratio:"\u2236",rationals:"\u211a",rbarr:"\u290d",rBarr:"\u290f",RBarr:"\u2910",rbbrk:"\u2773",rbrace:"}",rbrack:"]",rbrke:"\u298c",rbrksld:"\u298e",rbrkslu:"\u2990",rcaron:"\u0159",Rcaron:"\u0158",rcedil:"\u0157",Rcedil:"\u0156",rceil:"\u2309",rcub:"}",rcy:"\u0440",Rcy:"\u0420",rdca:"\u2937",rdldhar:"\u2969",rdquo:"\u201d",rdquor:"\u201d",rdsh:"\u21b3",Re:"\u211c",real:"\u211c",realine:"\u211b",realpart:"\u211c",reals:"\u211d",rect:"\u25ad",reg:"\xae",REG:"\xae",ReverseElement:"\u220b",ReverseEquilibrium:"\u21cb",ReverseUpEquilibrium:"\u296f",rfisht:"\u297d",rfloor:"\u230b",rfr:"\ud835\udd2f",Rfr:"\u211c",rHar:"\u2964",rhard:"\u21c1",rharu:"\u21c0",rharul:"\u296c",rho:"\u03c1",Rho:"\u03a1",rhov:"\u03f1",RightAngleBracket:"\u27e9",rightarrow:"\u2192",Rightarrow:"\u21d2",RightArrow:"\u2192",RightArrowBar:"\u21e5",RightArrowLeftArrow:"\u21c4",rightarrowtail:"\u21a3",RightCeiling:"\u2309",RightDoubleBracket:"\u27e7",RightDownTeeVector:"\u295d",RightDownVector:"\u21c2",RightDownVectorBar:"\u2955",RightFloor:"\u230b",rightharpoondown:"\u21c1",rightharpoonup:"\u21c0",rightleftarrows:"\u21c4",rightleftharpoons:"\u21cc",rightrightarrows:"\u21c9",rightsquigarrow:"\u219d",RightTee:"\u22a2",RightTeeArrow:"\u21a6",RightTeeVector:"\u295b",rightthreetimes:"\u22cc",RightTriangle:"\u22b3",RightTriangleBar:"\u29d0",RightTriangleEqual:"\u22b5",RightUpDownVector:"\u294f",RightUpTeeVector:"\u295c",RightUpVector:"\u21be",RightUpVectorBar:"\u2954",RightVector:"\u21c0",RightVectorBar:"\u2953",ring:"\u02da",risingdotseq:"\u2253",rlarr:"\u21c4",rlhar:"\u21cc",rlm:"\u200f",rmoust:"\u23b1",rmoustache:"\u23b1",rnmid:"\u2aee",roang:"\u27ed",roarr:"\u21fe",robrk:"\u27e7",ropar:"\u2986",ropf:"\ud835\udd63",Ropf:"\u211d",roplus:"\u2a2e",rotimes:"\u2a35",RoundImplies:"\u2970",rpar:")",rpargt:"\u2994",rppolint:"\u2a12",rrarr:"\u21c9",Rrightarrow:"\u21db",rsaquo:"\u203a",rscr:"\ud835\udcc7",Rscr:"\u211b",rsh:"\u21b1",Rsh:"\u21b1",rsqb:"]",rsquo:"\u2019",rsquor:"\u2019",rthree:"\u22cc",rtimes:"\u22ca",rtri:"\u25b9",rtrie:"\u22b5",rtrif:"\u25b8",rtriltri:"\u29ce",RuleDelayed:"\u29f4",ruluhar:"\u2968",rx:"\u211e",sacute:"\u015b",Sacute:"\u015a",sbquo:"\u201a",sc:"\u227b",Sc:"\u2abc",scap:"\u2ab8",scaron:"\u0161",Scaron:"\u0160",sccue:"\u227d",sce:"\u2ab0",scE:"\u2ab4",scedil:"\u015f",Scedil:"\u015e",scirc:"\u015d",Scirc:"\u015c",scnap:"\u2aba",scnE:"\u2ab6",scnsim:"\u22e9",scpolint:"\u2a13",scsim:"\u227f",scy:"\u0441",Scy:"\u0421",sdot:"\u22c5",sdotb:"\u22a1",sdote:"\u2a66",searhk:"\u2925",searr:"\u2198",seArr:"\u21d8",searrow:"\u2198",sect:"\xa7",semi:";",seswar:"\u2929",setminus:"\u2216",setmn:"\u2216",sext:"\u2736",sfr:"\ud835\udd30",Sfr:"\ud835\udd16",sfrown:"\u2322",sharp:"\u266f",shchcy:"\u0449",SHCHcy:"\u0429",shcy:"\u0448",SHcy:"\u0428",ShortDownArrow:"\u2193",ShortLeftArrow:"\u2190",shortmid:"\u2223",shortparallel:"\u2225",ShortRightArrow:"\u2192",ShortUpArrow:"\u2191",shy:"\xad",sigma:"\u03c3",Sigma:"\u03a3",sigmaf:"\u03c2",sigmav:"\u03c2",sim:"\u223c",simdot:"\u2a6a",sime:"\u2243",simeq:"\u2243",simg:"\u2a9e",simgE:"\u2aa0",siml:"\u2a9d",simlE:"\u2a9f",simne:"\u2246",simplus:"\u2a24",simrarr:"\u2972",slarr:"\u2190",SmallCircle:"\u2218",smallsetminus:"\u2216",smashp:"\u2a33",smeparsl:"\u29e4",smid:"\u2223",smile:"\u2323",smt:"\u2aaa",smte:"\u2aac",smtes:"\u2aac\ufe00",softcy:"\u044c",SOFTcy:"\u042c",sol:"/",solb:"\u29c4",solbar:"\u233f",sopf:"\ud835\udd64",Sopf:"\ud835\udd4a",spades:"\u2660",spadesuit:"\u2660",spar:"\u2225",sqcap:"\u2293",sqcaps:"\u2293\ufe00",sqcup:"\u2294",sqcups:"\u2294\ufe00",Sqrt:"\u221a",sqsub:"\u228f",sqsube:"\u2291",sqsubset:"\u228f",sqsubseteq:"\u2291",sqsup:"\u2290",sqsupe:"\u2292",sqsupset:"\u2290",sqsupseteq:"\u2292",squ:"\u25a1",square:"\u25a1",Square:"\u25a1",SquareIntersection:"\u2293",SquareSubset:"\u228f",SquareSubsetEqual:"\u2291",SquareSuperset:"\u2290",SquareSupersetEqual:"\u2292",SquareUnion:"\u2294",squarf:"\u25aa",squf:"\u25aa",srarr:"\u2192",sscr:"\ud835\udcc8",Sscr:"\ud835\udcae",ssetmn:"\u2216",ssmile:"\u2323",sstarf:"\u22c6",star:"\u2606",Star:"\u22c6",starf:"\u2605",straightepsilon:"\u03f5",straightphi:"\u03d5",strns:"\xaf",sub:"\u2282",Sub:"\u22d0",subdot:"\u2abd",sube:"\u2286",subE:"\u2ac5",subedot:"\u2ac3",submult:"\u2ac1",subne:"\u228a",subnE:"\u2acb",subplus:"\u2abf",subrarr:"\u2979",subset:"\u2282",Subset:"\u22d0",subseteq:"\u2286",subseteqq:"\u2ac5",SubsetEqual:"\u2286",subsetneq:"\u228a",subsetneqq:"\u2acb",subsim:"\u2ac7",subsub:"\u2ad5",subsup:"\u2ad3",succ:"\u227b",succapprox:"\u2ab8",succcurlyeq:"\u227d",Succeeds:"\u227b",SucceedsEqual:"\u2ab0",SucceedsSlantEqual:"\u227d",SucceedsTilde:"\u227f",succeq:"\u2ab0",succnapprox:"\u2aba",succneqq:"\u2ab6",succnsim:"\u22e9",succsim:"\u227f",SuchThat:"\u220b",sum:"\u2211",Sum:"\u2211",sung:"\u266a",sup:"\u2283",Sup:"\u22d1",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",supdot:"\u2abe",supdsub:"\u2ad8",supe:"\u2287",supE:"\u2ac6",supedot:"\u2ac4",Superset:"\u2283",SupersetEqual:"\u2287",suphsol:"\u27c9",suphsub:"\u2ad7",suplarr:"\u297b",supmult:"\u2ac2",supne:"\u228b",supnE:"\u2acc",supplus:"\u2ac0",supset:"\u2283",Supset:"\u22d1",supseteq:"\u2287",supseteqq:"\u2ac6",supsetneq:"\u228b",supsetneqq:"\u2acc",supsim:"\u2ac8",supsub:"\u2ad4",supsup:"\u2ad6",swarhk:"\u2926",swarr:"\u2199",swArr:"\u21d9",swarrow:"\u2199",swnwar:"\u292a",szlig:"\xdf",Tab:"\t",target:"\u2316",tau:"\u03c4",Tau:"\u03a4",tbrk:"\u23b4",tcaron:"\u0165",Tcaron:"\u0164",tcedil:"\u0163",Tcedil:"\u0162",tcy:"\u0442",Tcy:"\u0422",tdot:"\u20db",telrec:"\u2315",tfr:"\ud835\udd31",Tfr:"\ud835\udd17",there4:"\u2234",therefore:"\u2234",Therefore:"\u2234",theta:"\u03b8",Theta:"\u0398",thetasym:"\u03d1",thetav:"\u03d1",thickapprox:"\u2248",thicksim:"\u223c",ThickSpace:"\u205f\u200a",thinsp:"\u2009",ThinSpace:"\u2009",thkap:"\u2248",thksim:"\u223c",thorn:"\xfe",THORN:"\xde",tilde:"\u02dc",Tilde:"\u223c",TildeEqual:"\u2243",TildeFullEqual:"\u2245",TildeTilde:"\u2248",times:"\xd7",timesb:"\u22a0",timesbar:"\u2a31",timesd:"\u2a30",tint:"\u222d",toea:"\u2928",top:"\u22a4",topbot:"\u2336",topcir:"\u2af1",topf:"\ud835\udd65",Topf:"\ud835\udd4b",topfork:"\u2ada",tosa:"\u2929",tprime:"\u2034",trade:"\u2122",TRADE:"\u2122",triangle:"\u25b5",triangledown:"\u25bf",triangleleft:"\u25c3",trianglelefteq:"\u22b4",triangleq:"\u225c",triangleright:"\u25b9",trianglerighteq:"\u22b5",tridot:"\u25ec",trie:"\u225c",triminus:"\u2a3a",TripleDot:"\u20db",triplus:"\u2a39",trisb:"\u29cd",tritime:"\u2a3b",trpezium:"\u23e2",tscr:"\ud835\udcc9",Tscr:"\ud835\udcaf",tscy:"\u0446",TScy:"\u0426",tshcy:"\u045b",TSHcy:"\u040b",tstrok:"\u0167",Tstrok:"\u0166",twixt:"\u226c",twoheadleftarrow:"\u219e",twoheadrightarrow:"\u21a0",uacute:"\xfa",Uacute:"\xda",uarr:"\u2191",uArr:"\u21d1",Uarr:"\u219f",Uarrocir:"\u2949",ubrcy:"\u045e",Ubrcy:"\u040e",ubreve:"\u016d",Ubreve:"\u016c",ucirc:"\xfb",Ucirc:"\xdb",ucy:"\u0443",Ucy:"\u0423",udarr:"\u21c5",udblac:"\u0171",Udblac:"\u0170",udhar:"\u296e",ufisht:"\u297e",ufr:"\ud835\udd32",Ufr:"\ud835\udd18",ugrave:"\xf9",Ugrave:"\xd9",uHar:"\u2963",uharl:"\u21bf",uharr:"\u21be",uhblk:"\u2580",ulcorn:"\u231c",ulcorner:"\u231c",ulcrop:"\u230f",ultri:"\u25f8",umacr:"\u016b",Umacr:"\u016a",uml:"\xa8",UnderBar:"_",UnderBrace:"\u23df",UnderBracket:"\u23b5",UnderParenthesis:"\u23dd",Union:"\u22c3",UnionPlus:"\u228e",uogon:"\u0173",Uogon:"\u0172",uopf:"\ud835\udd66",Uopf:"\ud835\udd4c",uparrow:"\u2191",Uparrow:"\u21d1",UpArrow:"\u2191",UpArrowBar:"\u2912",UpArrowDownArrow:"\u21c5",updownarrow:"\u2195",Updownarrow:"\u21d5",UpDownArrow:"\u2195",UpEquilibrium:"\u296e",upharpoonleft:"\u21bf",upharpoonright:"\u21be",uplus:"\u228e",UpperLeftArrow:"\u2196",UpperRightArrow:"\u2197",upsi:"\u03c5",Upsi:"\u03d2",upsih:"\u03d2",upsilon:"\u03c5",Upsilon:"\u03a5",UpTee:"\u22a5",UpTeeArrow:"\u21a5",upuparrows:"\u21c8",urcorn:"\u231d",urcorner:"\u231d",urcrop:"\u230e",uring:"\u016f",Uring:"\u016e",urtri:"\u25f9",uscr:"\ud835\udcca",Uscr:"\ud835\udcb0",utdot:"\u22f0",utilde:"\u0169",Utilde:"\u0168",utri:"\u25b5",utrif:"\u25b4",uuarr:"\u21c8",uuml:"\xfc",Uuml:"\xdc",uwangle:"\u29a7",vangrt:"\u299c",varepsilon:"\u03f5",varkappa:"\u03f0",varnothing:"\u2205",varphi:"\u03d5",varpi:"\u03d6",varpropto:"\u221d",varr:"\u2195",vArr:"\u21d5",varrho:"\u03f1",varsigma:"\u03c2",varsubsetneq:"\u228a\ufe00",varsubsetneqq:"\u2acb\ufe00",varsupsetneq:"\u228b\ufe00",varsupsetneqq:"\u2acc\ufe00",vartheta:"\u03d1",vartriangleleft:"\u22b2",vartriangleright:"\u22b3",vBar:"\u2ae8",Vbar:"\u2aeb",vBarv:"\u2ae9",vcy:"\u0432",Vcy:"\u0412",vdash:"\u22a2",vDash:"\u22a8",Vdash:"\u22a9",VDash:"\u22ab",Vdashl:"\u2ae6",vee:"\u2228",Vee:"\u22c1",veebar:"\u22bb",veeeq:"\u225a",vellip:"\u22ee",verbar:"|",Verbar:"\u2016",vert:"|",Vert:"\u2016",VerticalBar:"\u2223",VerticalLine:"|",VerticalSeparator:"\u2758",VerticalTilde:"\u2240",VeryThinSpace:"\u200a",vfr:"\ud835\udd33",Vfr:"\ud835\udd19",vltri:"\u22b2",vnsub:"\u2282\u20d2",vnsup:"\u2283\u20d2",vopf:"\ud835\udd67",Vopf:"\ud835\udd4d",vprop:"\u221d",vrtri:"\u22b3",vscr:"\ud835\udccb",Vscr:"\ud835\udcb1",vsubne:"\u228a\ufe00",vsubnE:"\u2acb\ufe00",vsupne:"\u228b\ufe00",vsupnE:"\u2acc\ufe00",Vvdash:"\u22aa",vzigzag:"\u299a",wcirc:"\u0175",Wcirc:"\u0174",wedbar:"\u2a5f",wedge:"\u2227",Wedge:"\u22c0",wedgeq:"\u2259",weierp:"\u2118",wfr:"\ud835\udd34",Wfr:"\ud835\udd1a",wopf:"\ud835\udd68",Wopf:"\ud835\udd4e",wp:"\u2118",wr:"\u2240",wreath:"\u2240",wscr:"\ud835\udccc",Wscr:"\ud835\udcb2",xcap:"\u22c2",xcirc:"\u25ef",xcup:"\u22c3",xdtri:"\u25bd",xfr:"\ud835\udd35",Xfr:"\ud835\udd1b",xharr:"\u27f7",xhArr:"\u27fa",xi:"\u03be",Xi:"\u039e",xlarr:"\u27f5",xlArr:"\u27f8",xmap:"\u27fc",xnis:"\u22fb",xodot:"\u2a00",xopf:"\ud835\udd69",Xopf:"\ud835\udd4f",xoplus:"\u2a01",xotime:"\u2a02",xrarr:"\u27f6",xrArr:"\u27f9",xscr:"\ud835\udccd",Xscr:"\ud835\udcb3",xsqcup:"\u2a06",xuplus:"\u2a04",xutri:"\u25b3",xvee:"\u22c1",xwedge:"\u22c0",yacute:"\xfd",Yacute:"\xdd",yacy:"\u044f",YAcy:"\u042f",ycirc:"\u0177",Ycirc:"\u0176",ycy:"\u044b",Ycy:"\u042b",yen:"\xa5",yfr:"\ud835\udd36",Yfr:"\ud835\udd1c",yicy:"\u0457",YIcy:"\u0407",yopf:"\ud835\udd6a",Yopf:"\ud835\udd50",yscr:"\ud835\udcce",Yscr:"\ud835\udcb4",yucy:"\u044e",YUcy:"\u042e",yuml:"\xff",Yuml:"\u0178",zacute:"\u017a",Zacute:"\u0179",zcaron:"\u017e",Zcaron:"\u017d",zcy:"\u0437",Zcy:"\u0417",zdot:"\u017c",Zdot:"\u017b",zeetrf:"\u2128",ZeroWidthSpace:"\u200b",zeta:"\u03b6",Zeta:"\u0396",zfr:"\ud835\udd37",Zfr:"\u2128",zhcy:"\u0436",ZHcy:"\u0416",zigrarr:"\u21dd",zopf:"\ud835\udd6b",Zopf:"\u2124",zscr:"\ud835\udccf",Zscr:"\ud835\udcb5",zwj:"\u200d",zwnj:"\u200c"},h={aacute:"\xe1",Aacute:"\xc1",acirc:"\xe2",Acirc:"\xc2",acute:"\xb4",aelig:"\xe6",AElig:"\xc6",agrave:"\xe0",Agrave:"\xc0",amp:"&",AMP:"&",aring:"\xe5",Aring:"\xc5",atilde:"\xe3",Atilde:"\xc3",auml:"\xe4",Auml:"\xc4",brvbar:"\xa6",ccedil:"\xe7",Ccedil:"\xc7",cedil:"\xb8",cent:"\xa2",copy:"\xa9",COPY:"\xa9",curren:"\xa4",deg:"\xb0",divide:"\xf7",eacute:"\xe9",Eacute:"\xc9",ecirc:"\xea",Ecirc:"\xca",egrave:"\xe8",Egrave:"\xc8",eth:"\xf0",ETH:"\xd0",euml:"\xeb",Euml:"\xcb",frac12:"\xbd",frac14:"\xbc",frac34:"\xbe",gt:">",GT:">",iacute:"\xed",Iacute:"\xcd",icirc:"\xee",Icirc:"\xce",iexcl:"\xa1",igrave:"\xec",Igrave:"\xcc",iquest:"\xbf",iuml:"\xef",Iuml:"\xcf",laquo:"\xab",lt:"<",LT:"<",macr:"\xaf",micro:"\xb5",middot:"\xb7",nbsp:"\xa0",not:"\xac",ntilde:"\xf1",Ntilde:"\xd1",oacute:"\xf3",Oacute:"\xd3",ocirc:"\xf4",Ocirc:"\xd4",ograve:"\xf2",Ograve:"\xd2",ordf:"\xaa",ordm:"\xba",oslash:"\xf8",Oslash:"\xd8",otilde:"\xf5",Otilde:"\xd5",ouml:"\xf6",Ouml:"\xd6",para:"\xb6",plusmn:"\xb1",pound:"\xa3",quot:'"',QUOT:'"',raquo:"\xbb",reg:"\xae",REG:"\xae",sect:"\xa7",shy:"\xad",sup1:"\xb9",sup2:"\xb2",sup3:"\xb3",szlig:"\xdf",thorn:"\xfe",THORN:"\xde",times:"\xd7",uacute:"\xfa",Uacute:"\xda",ucirc:"\xfb",Ucirc:"\xdb",ugrave:"\xf9",Ugrave:"\xd9",uml:"\xa8",uuml:"\xfc",Uuml:"\xdc",yacute:"\xfd",Yacute:"\xdd",yen:"\xa5",yuml:"\xff"},v={0:"\ufffd",128:"\u20ac",130:"\u201a",131:"\u0192",132:"\u201e",133:"\u2026",134:"\u2020",135:"\u2021",136:"\u02c6",137:"\u2030",138:"\u0160",139:"\u2039",140:"\u0152",142:"\u017d",145:"\u2018",146:"\u2019",147:"\u201c",148:"\u201d",149:"\u2022",150:"\u2013",151:"\u2014",152:"\u02dc",153:"\u2122",154:"\u0161",155:"\u203a",156:"\u0153",158:"\u017e",159:"\u0178"},g=[1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65e3,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111],b=String.fromCharCode,y={}.hasOwnProperty,w=function(e,r){return y.call(e,r)},A=function(e,r){if(!e)return r;var t,n={};for(t in r)n[t]=w(e,t)?e[t]:r[t];return n},D=function(e,r){var t="";return e>=55296&&e<=57343||e>1114111?(r&&k("character reference outside the permissible Unicode range"),"\ufffd"):w(v,e)?(r&&k("disallowed character reference"),v[e]):(r&&function(e,r){for(var t=-1,n=e.length;++t<n;)if(e[t]==r)return!0;return!1}(g,e)&&k("disallowed character reference"),e>65535&&(t+=b((e-=65536)>>>10&1023|55296),e=56320|1023&e),t+=b(e))},x=function(e){return"&#x"+e.toString(16).toUpperCase()+";"},q=function(e){return"&#"+e+";"},k=function(e){throw Error("Parse error: "+e)},E=function(e,r){(r=A(r,E.options)).strict&&f.test(e)&&k("forbidden code point");var t=r.encodeEverything,n=r.useNamedReferences,l=r.allowUnsafeSymbols,p=r.decimal?q:x,d=function(e){return p(e.charCodeAt(0))};return t?(e=e.replace(o,function(e){return n&&w(c,e)?"&"+c[e]+";":d(e)}),n&&(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;").replace(/&#x66;&#x6A;/g,"&fjlig;")),n&&(e=e.replace(s,function(e){return"&"+c[e]+";"}))):n?(l||(e=e.replace(u,function(e){return"&"+c[e]+";"})),e=(e=e.replace(/&gt;\u20D2/g,"&nvgt;").replace(/&lt;\u20D2/g,"&nvlt;")).replace(s,function(e){return"&"+c[e]+";"})):l||(e=e.replace(u,d)),e.replace(a,function(e){var r=e.charCodeAt(0),t=e.charCodeAt(1);return p(1024*(r-55296)+t-56320+65536)}).replace(i,d)};E.options={allowUnsafeSymbols:!1,encodeEverything:!1,strict:!1,useNamedReferences:!1,decimal:!1};var _=function(e,r){var t=(r=A(r,_.options)).strict;return t&&p.test(e)&&k("malformed character reference"),e.replace(d,function(e,n,a,o,i,s,c,u,l){var p,f,d,v,g,b;return n?m[g=n]:a?(g=a,(b=o)&&r.isAttributeValue?(t&&"="==b&&k("`&` did not start a character reference"),e):(t&&k("named character reference was not terminated by a semicolon"),h[g]+(b||""))):i?(d=i,f=s,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(d,10),D(p,t)):c?(v=c,f=u,t&&!f&&k("character reference was not terminated by a semicolon"),p=parseInt(v,16),D(p,t)):(t&&k("named character reference was not terminated by a semicolon"),e)})};_.options={isAttributeValue:!1,strict:!1};var C={version:"1.2.0",encode:E,decode:_,escape:function(e){return e.replace(u,function(e){return l[e]})},unescape:_};if("function"==typeof define&&"object"==typeof define.amd&&define.amd)define(function(){return C});else if(r&&!r.nodeType)if(t)t.exports=C;else for(var S in C)w(C,S)&&(r[S]=C[S]);else e.he=C}(void 0);var yo=f("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),wo=f("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Ao=f("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Do=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,xo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,qo="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+U.source+"]*",ko="((?:"+qo+"\\:)?"+qo+")",Eo=new RegExp("^<"+ko),_o=/^\s*(\/?)>/,Co=new RegExp("^<\\/"+ko+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,Lo=/^<!\--/,To=/^<!\[/,$o=f("script,style,textarea",!0),No={},Oo={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ro=/&(?:lt|gt|quot|amp|#39);/g,Fo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Bo=f("pre,textarea",!0),Uo=function(e,r){return e&&Bo(e)&&"\n"===r[0]};function Vo(e,r){var t=r?Fo:Ro;return e.replace(t,function(e){return Oo[e]})}var Io,jo,Po,Ho,Mo,Go,zo,Jo,Ko=/^@|^v-on:/,Zo=/^v-|^@|^:|^#/,Yo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Wo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,Xo=/^\[.*\]$/,ei=/:(.*)$/,ri=/^:|^\.|^v-bind:/,ti=/\.[^.\]]+(?=[^\]]*$)/g,ni=/^v-slot(:|$)|^#/,ai=/[\r\n]/,oi=/[ \f\t\r\n]+/g,ii=b(void 0),si="_empty_";function ci(e,r,t){return{type:1,tag:e,attrsList:r,attrsMap:hi(r),rawAttrsMap:{},parent:t,children:[]}}function ui(e,r){Io=r.warn||Sn,Go=r.isPreTag||S,zo=r.mustUseProp||S,Jo=r.getTagNamespace||S;r.isReservedTag;Po=Ln(r.modules,"transformNode"),Ho=Ln(r.modules,"preTransformNode"),Mo=Ln(r.modules,"postTransformNode"),jo=r.delimiters;var t,n,a=[],o=!1!==r.preserveWhitespace,i=r.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=li(e,r)),a.length||e===t||t.if&&(e.elseif||e.else)&&fi(t,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)i=e,(u=function(e){var r=e.length;for(;r--;){if(1===e[r].type)return e[r];e.pop()}}(n.children))&&u.if&&fi(u,{exp:i.elseif,block:i});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var i,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Go(e.tag)&&(c=!1);for(var p=0;p<Mo.length;p++)Mo[p](e,r)}function l(e){if(!c)for(var r;(r=e.children[e.children.length-1])&&3===r.type&&" "===r.text;)e.children.pop()}return function(e,r){for(var t,n,a=[],o=r.expectHTML,i=r.isUnaryTag||S,s=r.canBeLeftOpenTag||S,c=0;e;){if(t=e,n&&$o(n)){var u=0,l=n.toLowerCase(),p=No[l]||(No[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),f=e.replace(p,function(e,t,n){return u=n.length,$o(l)||"noscript"===l||(t=t.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Uo(l,t)&&(t=t.slice(1)),r.chars&&r.chars(t),""});c+=e.length-f.length,e=f,E(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(Lo.test(e)){var m=e.indexOf("--\x3e");if(m>=0){r.shouldKeepComment&&r.comment(e.substring(4,m),c,c+m+3),x(m+3);continue}}if(To.test(e)){var h=e.indexOf("]>");if(h>=0){x(h+2);continue}}var v=e.match(So);if(v){x(v[0].length);continue}var g=e.match(Co);if(g){var b=c;x(g[0].length),E(g[1],b,c);continue}var y=q();if(y){k(y),Uo(y.tagName,e)&&x(1);continue}}var w=void 0,A=void 0,D=void 0;if(d>=0){for(A=e.slice(d);!(Co.test(A)||Eo.test(A)||Lo.test(A)||To.test(A)||(D=A.indexOf("<",1))<0);)d+=D,A=e.slice(d);w=e.substring(0,d)}d<0&&(w=e),w&&x(w.length),r.chars&&w&&r.chars(w,c-w.length,c)}if(e===t){r.chars&&r.chars(e);break}}function x(r){c+=r,e=e.substring(r)}function q(){var r=e.match(Eo);if(r){var t,n,a={tagName:r[1],attrs:[],start:c};for(x(r[0].length);!(t=e.match(_o))&&(n=e.match(xo)||e.match(Do));)n.start=c,x(n[0].length),n.end=c,a.attrs.push(n);if(t)return a.unarySlash=t[1],x(t[0].length),a.end=c,a}}function k(e){var t=e.tagName,c=e.unarySlash;o&&("p"===n&&Ao(t)&&E(n),s(t)&&n===t&&E(t));for(var u=i(t)||!!c,l=e.attrs.length,p=new Array(l),f=0;f<l;f++){var d=e.attrs[f],m=d[3]||d[4]||d[5]||"",h="a"===t&&"href"===d[1]?r.shouldDecodeNewlinesForHref:r.shouldDecodeNewlines;p[f]={name:d[1],value:Vo(m,h)}}u||(a.push({tag:t,lowerCasedTag:t.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=t),r.start&&r.start(t,p,u,e.start,e.end)}function E(e,t,o){var i,s;if(null==t&&(t=c),null==o&&(o=c),e)for(s=e.toLowerCase(),i=a.length-1;i>=0&&a[i].lowerCasedTag!==s;i--);else i=0;if(i>=0){for(var u=a.length-1;u>=i;u--)r.end&&r.end(a[u].tag,t,o);a.length=i,n=i&&a[i-1].tag}else"br"===s?r.start&&r.start(e,[],!0,t,o):"p"===s&&(r.start&&r.start(e,[],!1,t,o),r.end&&r.end(e,t,o))}E()}(e,{warn:Io,expectHTML:r.expectHTML,isUnaryTag:r.isUnaryTag,canBeLeftOpenTag:r.canBeLeftOpenTag,shouldDecodeNewlines:r.shouldDecodeNewlines,shouldDecodeNewlinesForHref:r.shouldDecodeNewlinesForHref,shouldKeepComment:r.comments,outputSourceRange:r.outputSourceRange,start:function(e,o,i,l,p){var f=n&&n.ns||Jo(e);J&&"svg"===f&&(o=function(e){for(var r=[],t=0;t<e.length;t++){var n=e[t];vi.test(n.name)||(n.name=n.name.replace(gi,""),r.push(n))}return r}(o));var d,m=ci(e,o,n);f&&(m.ns=f),"style"!==(d=m).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||re()||(m.forbidden=!0);for(var h=0;h<Ho.length;h++)m=Ho[h](m,r)||m;s||(!function(e){null!=Un(e,"v-pre")&&(e.pre=!0)}(m),m.pre&&(s=!0)),Go(m.tag)&&(c=!0),s?function(e){var r=e.attrsList,t=r.length;if(t)for(var n=e.attrs=new Array(t),a=0;a<t;a++)n[a]={name:r[a].name,value:JSON.stringify(r[a].value)},null!=r[a].start&&(n[a].start=r[a].start,n[a].end=r[a].end);else e.pre||(e.plain=!0)}(m):m.processed||(pi(m),function(e){var r=Un(e,"v-if");if(r)e.if=r,fi(e,{exp:r,block:e});else{null!=Un(e,"v-else")&&(e.else=!0);var t=Un(e,"v-else-if");t&&(e.elseif=t)}}(m),function(e){null!=Un(e,"v-once")&&(e.once=!0)}(m)),t||(t=m),i?u(m):(n=m,a.push(m))},end:function(e,r,t){var o=a[a.length-1];a.length-=1,n=a[a.length-1],u(o)},chars:function(e,r,t){if(n&&(!J||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var a,u,l,p=n.children;if(e=c||e.trim()?"script"===(a=n).tag||"style"===a.tag?e:ii(e):p.length?i?"condense"===i&&ai.test(e)?"":" ":o?" ":"":"")c||"condense"!==i||(e=e.replace(oi," ")),!s&&" "!==e&&(u=function(e,r){var t=r?vo(r):mo;if(t.test(e)){for(var n,a,o,i=[],s=[],c=t.lastIndex=0;n=t.exec(e);){(a=n.index)>c&&(s.push(o=e.slice(c,a)),i.push(JSON.stringify(o)));var u=_n(n[1].trim());i.push("_s("+u+")"),s.push({"@binding":u}),c=a+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),i.push(JSON.stringify(o))),{expression:i.join("+"),tokens:s}}}(e,jo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&p.length&&" "===p[p.length-1].text||(l={type:3,text:e}),l&&p.push(l)}},comment:function(e,r,t){if(n){var a={type:3,text:e,isComment:!0};n.children.push(a)}}}),t}function li(e,r){var t,n;(n=Bn(t=e,"key"))&&(t.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var r=Bn(e,"ref");r&&(e.ref=r,e.refInFor=function(e){var r=e;for(;r;){if(void 0!==r.for)return!0;r=r.parent}return!1}(e))}(e),function(e){var r;"template"===e.tag?(r=Un(e,"scope"),e.slotScope=r||Un(e,"slot-scope")):(r=Un(e,"slot-scope"))&&(e.slotScope=r);var t=Bn(e,"slot");t&&(e.slotTarget='""'===t?'"default"':t,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||$n(e,"slot",t,function(e,r){return e.rawAttrsMap[":"+r]||e.rawAttrsMap["v-bind:"+r]||e.rawAttrsMap[r]}(e,"slot")));if("template"===e.tag){var n=Vn(e,ni);if(n){var a=di(n),o=a.name,i=a.dynamic;e.slotTarget=o,e.slotTargetDynamic=i,e.slotScope=n.value||si}}else{var s=Vn(e,ni);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=di(s),l=u.name,p=u.dynamic,f=c[l]=ci("template",[],e);f.slotTarget=l,f.slotTargetDynamic=p,f.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=f,!0}),f.slotScope=s.value||si,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Bn(e,"name"))}(e),function(e){var r;(r=Bn(e,"is"))&&(e.component=r);null!=Un(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var a=0;a<Po.length;a++)e=Po[a](e,r)||e;return function(e){var r,t,n,a,o,i,s,c,u=e.attrsList;for(r=0,t=u.length;r<t;r++)if(n=a=u[r].name,o=u[r].value,Zo.test(n))if(e.hasBindings=!0,(i=mi(n.replace(Zo,"")))&&(n=n.replace(ti,"")),ri.test(n))n=n.replace(ri,""),o=_n(o),(c=Xo.test(n))&&(n=n.slice(1,-1)),i&&(i.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),i.camel&&!c&&(n=w(n)),i.sync&&(s=Pn(o,"$event"),c?Fn(e,'"update:"+('+n+")",s,null,!1,0,u[r],!0):(Fn(e,"update:"+w(n),s,null,!1,0,u[r]),x(n)!==w(n)&&Fn(e,"update:"+x(n),s,null,!1,0,u[r])))),i&&i.prop||!e.component&&zo(e.tag,e.attrsMap.type,n)?Tn(e,n,o,u[r],c):$n(e,n,o,u[r],c);else if(Ko.test(n))n=n.replace(Ko,""),(c=Xo.test(n))&&(n=n.slice(1,-1)),Fn(e,n,o,i,!1,0,u[r],c);else{var l=(n=n.replace(Zo,"")).match(ei),p=l&&l[1];c=!1,p&&(n=n.slice(0,-(p.length+1)),Xo.test(p)&&(p=p.slice(1,-1),c=!0)),On(e,n,a,o,p,c,i,u[r])}else $n(e,n,JSON.stringify(o),u[r]),!e.component&&"muted"===n&&zo(e.tag,e.attrsMap.type,n)&&Tn(e,n,"true",u[r])}(e),e}function pi(e){var r;if(r=Un(e,"v-for")){var t=function(e){var r=e.match(Yo);if(!r)return;var t={};t.for=r[2].trim();var n=r[1].trim().replace(Qo,""),a=n.match(Wo);a?(t.alias=n.replace(Wo,"").trim(),t.iterator1=a[1].trim(),a[2]&&(t.iterator2=a[2].trim())):t.alias=n;return t}(r);t&&E(e,t)}}function fi(e,r){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(r)}function di(e){var r=e.name.replace(ni,"");return r||"#"!==e.name[0]&&(r="default"),Xo.test(r)?{name:r.slice(1,-1),dynamic:!0}:{name:'"'+r+'"',dynamic:!1}}function mi(e){var r=e.match(ti);if(r){var t={};return r.forEach(function(e){t[e.slice(1)]=!0}),t}}function hi(e){for(var r={},t=0,n=e.length;t<n;t++)r[e[t].name]=e[t].value;return r}var vi=/^xmlns:NS\d+/,gi=/^NS\d+:/;function bi(e){return ci(e.tag,e.attrsList.slice(),e.parent)}var yi=[go,bo,{preTransformNode:function(e,r){if("input"===e.tag){var t,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(t=Bn(e,"type")),n.type||t||!n["v-bind"]||(t="("+n["v-bind"]+").type"),t){var a=Un(e,"v-if",!0),o=a?"&&("+a+")":"",i=null!=Un(e,"v-else",!0),s=Un(e,"v-else-if",!0),c=bi(e);pi(c),Nn(c,"type","checkbox"),li(c,r),c.processed=!0,c.if="("+t+")==='checkbox'"+o,fi(c,{exp:c.if,block:c});var u=bi(e);Un(u,"v-for",!0),Nn(u,"type","radio"),li(u,r),fi(c,{exp:"("+t+")==='radio'"+o,block:u});var l=bi(e);return Un(l,"v-for",!0),Nn(l,":type",t),li(l,r),fi(c,{exp:a,block:l}),i?c.else=!0:s&&(c.elseif=s),c}}}}];var wi,Ai,Di={expectHTML:!0,modules:yi,directives:{model:function(e,r,t){var n=r.value,a=r.modifiers,o=e.tag,i=e.attrsMap.type;if(e.component)return jn(e,n,a),!1;if("select"===o)!function(e,r,t){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(t&&t.number?"_n(val)":"val")+"});";n=n+" "+Pn(r,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Fn(e,"change",n,null,!0)}(e,n,a);else if("input"===o&&"checkbox"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null",o=Bn(e,"true-value")||"true",i=Bn(e,"false-value")||"false";Tn(e,"checked","Array.isArray("+r+")?_i("+r+","+a+")>-1"+("true"===o?":("+r+")":":_q("+r+","+o+")")),Fn(e,"change","var $$a="+r+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+i+");if(Array.isArray($$a)){var $$v="+(n?"_n("+a+")":a)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pn(r,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pn(r,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pn(r,"$$c")+"}",null,!0)}(e,n,a);else if("input"===o&&"radio"===i)!function(e,r,t){var n=t&&t.number,a=Bn(e,"value")||"null";Tn(e,"checked","_q("+r+","+(a=n?"_n("+a+")":a)+")"),Fn(e,"change",Pn(r,a),null,!0)}(e,n,a);else if("input"===o||"textarea"===o)!function(e,r,t){var n=e.attrsMap.type,a=t||{},o=a.lazy,i=a.number,s=a.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Zn:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),i&&(l="_n("+l+")");var p=Pn(r,l);c&&(p="if($event.target.composing)return;"+p),Tn(e,"value","("+r+")"),Fn(e,u,p,null,!0),(s||i)&&Fn(e,"blur","$forceUpdate()")}(e,n,a);else if(!B.isReservedTag(o))return jn(e,n,a),!1;return!0},text:function(e,r){r.value&&Tn(e,"textContent","_s("+r.value+")",r)},html:function(e,r){r.value&&Tn(e,"innerHTML","_s("+r.value+")",r)}},isPreTag:function(e){return"pre"===e},isUnaryTag:yo,mustUseProp:$t,canBeLeftOpenTag:wo,isReservedTag:Kt,getTagNamespace:Zt,staticKeys:function(e){return e.reduce(function(e,r){return e.concat(r.staticKeys||[])},[]).join(",")}(yi)},xi=b(function(e){return f("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function qi(e,r){e&&(wi=xi(r.staticKeys||""),Ai=r.isReservedTag||S,function e(r){r.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Ai(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(wi)))}(r);if(1===r.type){if(!Ai(r.tag)&&"slot"!==r.tag&&null==r.attrsMap["inline-template"])return;for(var t=0,n=r.children.length;t<n;t++){var a=r.children[t];e(a),a.static||(r.static=!1)}if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++){var s=r.ifConditions[o].block;e(s),s.static||(r.static=!1)}}}(e),function e(r,t){if(1===r.type){if((r.static||r.once)&&(r.staticInFor=t),r.static&&r.children.length&&(1!==r.children.length||3!==r.children[0].type))return void(r.staticRoot=!0);if(r.staticRoot=!1,r.children)for(var n=0,a=r.children.length;n<a;n++)e(r.children[n],t||!!r.for);if(r.ifConditions)for(var o=1,i=r.ifConditions.length;o<i;o++)e(r.ifConditions[o].block,t)}}(e,!1))}var ki=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ei=/\([^)]*?\);*$/,_i=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Si={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Li=function(e){return"if("+e+")return null;"},Ti={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Li("$event.target !== $event.currentTarget"),ctrl:Li("!$event.ctrlKey"),shift:Li("!$event.shiftKey"),alt:Li("!$event.altKey"),meta:Li("!$event.metaKey"),left:Li("'button' in $event && $event.button !== 0"),middle:Li("'button' in $event && $event.button !== 1"),right:Li("'button' in $event && $event.button !== 2")};function $i(e,r){var t=r?"nativeOn:":"on:",n="",a="";for(var o in e){var i=Ni(e[o]);e[o]&&e[o].dynamic?a+=o+","+i+",":n+='"'+o+'":'+i+","}return n="{"+n.slice(0,-1)+"}",a?t+"_d("+n+",["+a.slice(0,-1)+"])":t+n}function Ni(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Ni(e)}).join(",")+"]";var r=_i.test(e.value),t=ki.test(e.value),n=_i.test(e.value.replace(Ei,""));if(e.modifiers){var a="",o="",i=[];for(var s in e.modifiers)if(Ti[s])o+=Ti[s],Ci[s]&&i.push(s);else if("exact"===s){var c=e.modifiers;o+=Li(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else i.push(s);return i.length&&(a+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Oi).join("&&")+")return null;"}(i)),o&&(a+=o),"function($event){"+a+(r?"return "+e.value+".apply(null, arguments)":t?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return r||t?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function Oi(e){var r=parseInt(e,10);if(r)return"$event.keyCode!=="+r;var t=Ci[e],n=Si[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(t)+",$event.key,"+JSON.stringify(n)+")"}var Ri={on:function(e,r){e.wrapListeners=function(e){return"_g("+e+","+r.value+")"}},bind:function(e,r){e.wrapData=function(t){return"_b("+t+",'"+e.tag+"',"+r.value+","+(r.modifiers&&r.modifiers.prop?"true":"false")+(r.modifiers&&r.modifiers.sync?",true":"")+")"}},cloak:C},Fi=function(e){this.options=e,this.warn=e.warn||Sn,this.transforms=Ln(e.modules,"transformCode"),this.dataGenFns=Ln(e.modules,"genData"),this.directives=E(E({},Ri),e.directives);var r=e.isReservedTag||S;this.maybeComponent=function(e){return!!e.component||!r(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Bi(e,r){var t=new Fi(r);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ui(e,t):'_c("div")')+"}",staticRenderFns:t.staticRenderFns}}function Ui(e,r){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Vi(e,r);if(e.once&&!e.onceProcessed)return Ii(e,r);if(e.for&&!e.forProcessed)return Pi(e,r);if(e.if&&!e.ifProcessed)return ji(e,r);if("template"!==e.tag||e.slotTarget||r.pre){if("slot"===e.tag)return function(e,r){var t=e.slotName||'"default"',n=zi(e,r),a="_t("+t+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Zi((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,i=e.attrsMap["v-bind"];!o&&!i||n||(a+=",null");o&&(a+=","+o);i&&(a+=(o?"":",null")+","+i);return a+")"}(e,r);var t;if(e.component)t=function(e,r,t){var n=r.inlineTemplate?null:zi(r,t,!0);return"_c("+e+","+Hi(r,t)+(n?","+n:"")+")"}(e.component,e,r);else{var n;(!e.plain||e.pre&&r.maybeComponent(e))&&(n=Hi(e,r));var a=e.inlineTemplate?null:zi(e,r,!0);t="_c('"+e.tag+"'"+(n?","+n:"")+(a?","+a:"")+")"}for(var o=0;o<r.transforms.length;o++)t=r.transforms[o](e,t);return t}return zi(e,r)||"void 0"}function Vi(e,r){e.staticProcessed=!0;var t=r.pre;return e.pre&&(r.pre=e.pre),r.staticRenderFns.push("with(this){return "+Ui(e,r)+"}"),r.pre=t,"_m("+(r.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ii(e,r){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ji(e,r);if(e.staticInFor){for(var t="",n=e.parent;n;){if(n.for){t=n.key;break}n=n.parent}return t?"_o("+Ui(e,r)+","+r.onceId+++","+t+")":Ui(e,r)}return Vi(e,r)}function ji(e,r,t,n){return e.ifProcessed=!0,function e(r,t,n,a){if(!r.length)return a||"_e()";var o=r.shift();return o.exp?"("+o.exp+")?"+i(o.block)+":"+e(r,t,n,a):""+i(o.block);function i(e){return n?n(e,t):e.once?Ii(e,t):Ui(e,t)}}(e.ifConditions.slice(),r,t,n)}function Pi(e,r,t,n){var a=e.for,o=e.alias,i=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+a+"),function("+o+i+s+"){return "+(t||Ui)(e,r)+"})"}function Hi(e,r){var t="{",n=function(e,r){var t=e.directives;if(!t)return;var n,a,o,i,s="directives:[",c=!1;for(n=0,a=t.length;n<a;n++){o=t[n],i=!0;var u=r.directives[o.name];u&&(i=!!u(e,o,r.warn)),i&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,r);n&&(t+=n+","),e.key&&(t+="key:"+e.key+","),e.ref&&(t+="ref:"+e.ref+","),e.refInFor&&(t+="refInFor:true,"),e.pre&&(t+="pre:true,"),e.component&&(t+='tag:"'+e.tag+'",');for(var a=0;a<r.dataGenFns.length;a++)t+=r.dataGenFns[a](e);if(e.attrs&&(t+="attrs:"+Zi(e.attrs)+","),e.props&&(t+="domProps:"+Zi(e.props)+","),e.events&&(t+=$i(e.events,!1)+","),e.nativeEvents&&(t+=$i(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(t+="slot:"+e.slotTarget+","),e.scopedSlots&&(t+=function(e,r,t){var n=e.for||Object.keys(r).some(function(e){var t=r[e];return t.slotTargetDynamic||t.if||t.for||Mi(t)}),a=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==si||o.for){n=!0;break}o.if&&(a=!0),o=o.parent}var i=Object.keys(r).map(function(e){return Gi(r[e],t)}).join(",");return"scopedSlots:_u(["+i+"]"+(n?",null,true":"")+(!n&&a?",null,false,"+function(e){var r=5381,t=e.length;for(;t;)r=33*r^e.charCodeAt(--t);return r>>>0}(i):"")+")"}(e,e.scopedSlots,r)+","),e.model&&(t+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,r){var t=e.children[0];if(t&&1===t.type){var n=Bi(t,r.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,r);o&&(t+=o+",")}return t=t.replace(/,$/,"")+"}",e.dynamicAttrs&&(t="_b("+t+',"'+e.tag+'",'+Zi(e.dynamicAttrs)+")"),e.wrapData&&(t=e.wrapData(t)),e.wrapListeners&&(t=e.wrapListeners(t)),t}function Mi(e){return 1===e.type&&("slot"===e.tag||e.children.some(Mi))}function Gi(e,r){var t=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!t)return ji(e,r,Gi,"null");if(e.for&&!e.forProcessed)return Pi(e,r,Gi);var n=e.slotScope===si?"":String(e.slotScope),a="function("+n+"){return "+("template"===e.tag?e.if&&t?"("+e.if+")?"+(zi(e,r)||"undefined")+":undefined":zi(e,r)||"undefined":Ui(e,r))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+a+o+"}"}function zi(e,r,t,n,a){var o=e.children;if(o.length){var i=o[0];if(1===o.length&&i.for&&"template"!==i.tag&&"slot"!==i.tag){var s=t?r.maybeComponent(i)?",1":",0":"";return""+(n||Ui)(i,r)+s}var c=t?function(e,r){for(var t=0,n=0;n<e.length;n++){var a=e[n];if(1===a.type){if(Ji(a)||a.ifConditions&&a.ifConditions.some(function(e){return Ji(e.block)})){t=2;break}(r(a)||a.ifConditions&&a.ifConditions.some(function(e){return r(e.block)}))&&(t=1)}}return t}(o,r.maybeComponent):0,u=a||Ki;return"["+o.map(function(e){return u(e,r)}).join(",")+"]"+(c?","+c:"")}}function Ji(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Ki(e,r){return 1===e.type?Ui(e,r):3===e.type&&e.isComment?(n=e,"_e("+JSON.stringify(n.text)+")"):"_v("+(2===(t=e).type?t.expression:Yi(JSON.stringify(t.text)))+")";var t,n}function Zi(e){for(var r="",t="",n=0;n<e.length;n++){var a=e[n],o=Yi(a.value);a.dynamic?t+=a.name+","+o+",":r+='"'+a.name+'":'+o+","}return r="{"+r.slice(0,-1)+"}",t?"_d("+r+",["+t.slice(0,-1)+"])":r}function Yi(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Wi(e,r){try{return new Function(e)}catch(t){return r.push({err:t,code:e}),C}}function Qi(e){var r=Object.create(null);return function(t,n,a){(n=E({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+t:t;if(r[o])return r[o];var i=e(t,n),s={},c=[];return s.render=Wi(i.render,c),s.staticRenderFns=i.staticRenderFns.map(function(e){return Wi(e,c)}),r[o]=s}}var Xi,es,rs=(Xi=function(e,r){var t=ui(e.trim(),r);!1!==r.optimize&&qi(t,r);var n=Bi(t,r);return{ast:t,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function r(r,t){var n=Object.create(e),a=[],o=[];if(t)for(var i in t.modules&&(n.modules=(e.modules||[]).concat(t.modules)),t.directives&&(n.directives=E(Object.create(e.directives||null),t.directives)),t)"modules"!==i&&"directives"!==i&&(n[i]=t[i]);n.warn=function(e,r,t){(t?o:a).push(e)};var s=Xi(r.trim(),n);return s.errors=a,s.tips=o,s}return{compile:r,compileToFunctions:Qi(r)}})(Di),ts=(rs.compile,rs.compileToFunctions);function ns(e){return(es=es||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',es.innerHTML.indexOf("&#10;")>0}var as=!!H&&ns(!1),os=!!H&&ns(!0),is=b(function(e){var r=Qt(e);return r&&r.innerHTML}),ss=Dt.prototype.$mount;return Dt.prototype.$mount=function(e,r){if((e=e&&Qt(e))===document.body||e===document.documentElement)return this;var t=this.$options;if(!t.render){var n=t.template;if(n)if("string"==typeof n)"#"===n.charAt(0)&&(n=is(n));else{if(!n.nodeType)return this;n=n.innerHTML}else e&&(n=function(e){if(e.outerHTML)return e.outerHTML;var r=document.createElement("div");return r.appendChild(e.cloneNode(!0)),r.innerHTML}(e));if(n){var a=ts(n,{outputSourceRange:!1,shouldDecodeNewlines:as,shouldDecodeNewlinesForHref:os,delimiters:t.delimiters,comments:t.comments},this),o=a.render,i=a.staticRenderFns;t.render=o,t.staticRenderFns=i}}return ss.call(this,e,r)},Dt.compile=ts,Dt});
\ No newline at end of file
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(){function e(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var o,a=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":o=r;break;case"splice":o=r.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&we(t),o.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function je(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=je(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Ae[r]||Ee;a[r]=i(e[r],t[r],n,r)}return a}function De(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Le(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=_e;be(!0),we(a),be(u)}return a}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),Z&&setTimeout(S)},Ve=!0}else if(J||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)He(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=ve(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=ve(f.text+u):""!==u&&s.push(ve(u)):st(u)&&st(f)?s[l]=ve(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return De(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=E,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var o=he(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Le(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=de();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Le(l,u,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return de();n(a)&&n(a.is)&&(i=a.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f=void 0;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=De(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):de()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(U&&!J){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var o=function(o){i.push(o);var a=Le(o,t,n,e);Ce(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=je(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=je(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=je($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;Ce(t,"$attrs",o&&o.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){le();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:je,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=je(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=De(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(J||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(J&&!q&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=J?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=U&&!q,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ni(e){Ti(function(){Ti(e)})}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,N=O&&v?v:l,E=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!q,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,N),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),E&&E(i),F&&(Ei(i,S),Ei(i,T),Ni(function(){ji(i,S),R.cancelled||(Ei(i,N),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ni(function(){ji(i,u),w.cancelled||(Ei(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=he(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,U?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});q&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),q&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t),(J||W)&&setTimeout(function(){Ji(e,t)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(E(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!E(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){(l=i[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(o.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=e(t,null,c),this.removed=u}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!U)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=U?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?Yn(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},go=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),_o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,No=/^<!\[/,Eo=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,function(e){return Do[e]})}function Ro(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,u=function(){if(n=e,r&&Eo(r)){var u=0,p=r.toLowerCase(),d=jo[p]||(jo[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return u=r.length,Eo(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(To.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(No.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(So);if(y)return l(y[0].length),"continue";var g=e.match(Oo);if(g){var _=c;return l(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(ko);if(t){var n={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Ao))&&(i=e.match(wo)||e.match($o));)i.start=c,l(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&f(r),s(n)&&r===n&&f(n));for(var u=a(n)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:Po(h,m)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,u,e.start,e.end)}(b),Fo(b.tagName,e)&&l(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Oo.test(w)||ko.test(w)||To.test(w)||No.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&l($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}f()}var Ho,Bo,Uo,zo,Vo,Ko,Jo,qo,Wo=require("he"),Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/[ \f\t\r\n]+/g,sa=g(Wo.decode),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Ho=t.warn||Sr,Ko=t.isPreTag||T,Jo=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Uo=Tr(t.modules,"transformNode"),zo=Tr(t.modules,"preTransformNode"),Vo=Tr(t.modules,"postTransformNode"),Bo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ko(e.tag)&&(c=!1);for(var f=0;f<Vo.length;f++)Vo[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return Ro(e,{warn:Ho,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<zo.length;h++)v=zo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ko(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):u.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(aa," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Bo))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var r=Pr(e,ia);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=va(r),u=c.name,a=c.dynamic,l=s[u]=ua("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=r.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Uo.length;i++)e=Uo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Jo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):Er(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Er(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Jo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,yo,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=Ir(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+r+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",r),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Nr(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:go,mustUseProp:jn,canBeLeftOpenTag:_o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var o=t.ifConditions[n].block;e(o),o.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Na={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(ja[t])o+=ja[t],Ta[t]&&a.push(t);else if("exact"===t){var n=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Na[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(){return function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g(function(e){var t=Yn(e);return t&&t.innerHTML}),ss=wn.prototype.$mount;return wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},wn.compile=ns,wn});
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index f737ade77ae..dd020e74184 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -109,7 +109,7 @@ var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove(arr, item) {
+function remove$2(arr, item) {
     if (arr.length) {
         var index = arr.indexOf(item);
         if (index > -1) {
@@ -423,7 +423,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -454,10 +454,10 @@ var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
 var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
@@ -467,7 +467,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get: function () {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -513,20 +513,19 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
+    _Set = /** @class */ (function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function has (key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function add (key) {
+        Set.prototype.add = function (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function clear () {
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
         };
-
         return Set;
     }());
 }
@@ -537,20 +536,22 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
     warn = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+        else if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole && !config.silent) {
+        if (hasConsole_1 && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -573,10 +574,10 @@ var formatComponentName;
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    var repeat = function (str, n) {
+    var repeat_1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -610,50 +611,55 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
 
-var uid = 0;
+var uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
-    }
-};
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$2(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -668,43 +674,45 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
+    if (text === void 0) { text = ''; }
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -758,9 +766,12 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
+        var arguments$1 = arguments;
 
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -796,43 +807,46 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
-    }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive$$1(obj, keys[i]);
     }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
-    }
-};
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -882,7 +896,7 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
+function defineReactive(obj, key, val, customSetter, shallow) {
     var dep = new Dep();
     var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -941,8 +955,8 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
  * already exist.
  */
 function set(target, key, val) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -964,7 +978,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -972,8 +986,8 @@ function set(target, key, val) {
  * Delete a property and trigger change if necessary.
  */
 function del(target, key) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -1000,7 +1014,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1110,7 +1124,7 @@ strats.data = function (parentVal, childVal, vm) {
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(parentVal, childVal) {
+function mergeHook$1(parentVal, childVal) {
     var res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
@@ -1130,7 +1144,7 @@ function dedupeHooks(hooks) {
     return res;
 }
 LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+    strats[hook] = mergeHook$1;
 });
 /**
  * Assets
@@ -1176,14 +1190,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key$1] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1221,7 +1235,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
         warn('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1265,7 +1279,7 @@ function normalizeProps(options, vm) {
     }
     else {
         warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+            ("but got " + toRawType(props) + "."), vm);
     }
     options.props = res;
 }
@@ -1292,19 +1306,19 @@ function normalizeInject(options, vm) {
     }
     else {
         warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+            ("but got " + toRawType(inject) + "."), vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives(options) {
+function normalizeDirectives$1(options) {
     var dirs = options.directives;
     if (dirs) {
         for (var key in dirs) {
-            var def$$1 = dirs[key];
-            if (typeof def$$1 === 'function') {
-                dirs[key] = { bind: def$$1, update: def$$1 };
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
             }
         }
     }
@@ -1312,7 +1326,7 @@ function normalizeDirectives(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 /**
@@ -1329,7 +1343,7 @@ function mergeOptions(parent, child, vm) {
     }
     normalizeProps(child, vm);
     normalizeInject(child, vm);
-    normalizeDirectives(child);
+    normalizeDirectives$1(child);
     // Apply extends and mixins on the child options,
     // but only if it is a raw options object that isn't
     // the result of another mergeOptions call.
@@ -1549,7 +1563,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1557,24 +1571,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += " with value " + styleValue(value, expectedType);
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += "with value " + styleValue(value, receivedType) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return "\"" + value + "\"";
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return "" + Number(value);
     }
     else {
-        return ("" + value);
+        return "" + value;
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1582,9 +1596,12 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
+    var arguments$1 = arguments;
 
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments$1[_i];
+    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1650,7 +1667,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1693,9 +1710,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
+    var p_1 = Promise.resolve();
     timerFunc = function () {
-        p.then(flushCallbacks);
+        p_1.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1714,15 +1731,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
+    var counter_1 = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
     timerFunc = function () {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
+        counter_1 = (counter_1 + 1) % 2;
+        textNode_1.data = String(counter_1);
     };
     isUsingMicroTask = true;
 }
@@ -1767,36 +1784,34 @@ function nextTick(cb, ctx) {
     }
 }
 
-/* @flow */
-
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
+    var warnNonPresent_1 = function (target, key) {
         warn("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
+    var warnReservedPrefix_1 = function (target, key) {
         warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                     return false;
                 }
                 else {
@@ -1806,38 +1821,38 @@ var initProxy;
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
+    var hasHandler_1 = {
+        has: function (target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+            var isAllowed = allowedGlobals_1(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    var getHandler_1 = {
+        get: function (target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy) {
+        if (hasProxy_1) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1888,18 +1903,18 @@ function _traverse(val, seen) {
 var mark;
 var measure;
 {
-    var perf = inBrowser && window.performance;
+    var perf_1 = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) {
+        mark = function (tag) { return perf_1.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
+            perf_1.measure(name, startTag, endTag);
+            perf_1.clearMarks(startTag);
+            perf_1.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1908,13 +1923,13 @@ var measure;
 var normalizeEvent = cached(function (name) {
     var passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
     var capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
         name: name,
-        once: once$$1,
+        once: once,
         capture: capture,
         passive: passive,
     };
@@ -1938,14 +1953,14 @@ function createFnInvoker(fns, vm) {
     invoker.fns = fns;
     return invoker;
 }
-function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-    var name, def$$1, cur, old, event;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, cur, old, event;
     for (name in on) {
-        def$$1 = cur = on[name];
+        cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+            warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1964,7 +1979,7 @@ function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
     for (name in oldOn) {
         if (isUndef(on[name])) {
             event = normalizeEvent(name);
-            remove$$1(event.name, oldOn[name], event.capture);
+            remove(event.name, oldOn[name], event.capture);
         }
     }
 }
@@ -1980,7 +1995,7 @@ function mergeVNodeHook(def, hookKey, hook) {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
         // and prevent memory leak
-        remove(invoker.fns, wrappedHook);
+        remove$2(invoker.fns, wrappedHook);
     }
     if (isUndef(oldHook)) {
         // no existing hook
@@ -2012,8 +2027,7 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    var attrs = data.attrs, props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2023,11 +2037,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2102,7 +2116,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2161,10 +2175,10 @@ function initInjections(vm) {
         Object.keys(result).forEach(function (key) {
             /* istanbul ignore else */
             {
-                defineReactive$$1(vm, key, result[key], function () {
+                defineReactive(vm, key, result[key], function () {
                     warn("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                        ("injection being mutated: \"" + key + "\""), vm);
                 });
             }
         });
@@ -2201,7 +2215,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn("Injection \"" + key + "\" not found", vm);
                 }
             }
         }
@@ -2230,8 +2244,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2244,9 +2258,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
         }
     }
     return slots;
@@ -2280,16 +2294,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2448,8 +2462,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            var hash = void 0;
+            var _loop_1 = function (key) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2466,14 +2480,15 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        on["update:" + key] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-
-            for (var key in value) loop( key );
+            for (var key in value) {
+                _loop_1(key);
+            }
         }
     }
     return data;
@@ -2493,7 +2508,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic(tree, "__static__" + index, false);
     return tree;
 }
 /**
@@ -2501,14 +2516,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], key + "_" + i, isOnce);
             }
         }
     }
@@ -2575,7 +2590,7 @@ function bindDynamicKeys(baseObj, values) {
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
         }
     }
     return baseObj;
@@ -2610,8 +2625,7 @@ function installRenderHelpers(target) {
 
 /* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
+    var _this = this;
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2638,14 +2652,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return _this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get: function () {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2659,7 +2673,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     }
     if (options._scopeId) {
         this._c = function (a, b, c, d) {
-            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2668,7 +2682,9 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+        this._c = function (a, b, c, d) {
+            return createElement$1(contextVm, a, b, c, d, needNormalization);
+        };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2722,14 +2738,10 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+    init: function (vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2742,7 +2754,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
+    prepatch: function (oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2751,12 +2763,11 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
+            callHook$1(componentInstance, 'mounted');
         }
         if (vnode.data.keepAlive) {
             if (context._isMounted) {
@@ -2772,7 +2783,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2798,7 +2809,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn("Invalid Component definition: " + String(Ctor), context);
         }
         return;
     }
@@ -2856,7 +2867,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2887,11 +2898,11 @@ function installComponentHooks(data) {
         var toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
     }
 }
-function mergeHook$1(f1, f2) {
+function mergeHook(f1, f2) {
     var merged = function (a, b) {
         // flow complains about extra args which is why we use any
         f1(a, b);
@@ -2926,7 +2937,7 @@ var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
     if (Array.isArray(data) || isPrimitive(data)) {
         normalizationType = children;
         children = data;
@@ -2939,7 +2950,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2974,14 +2985,14 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        var Ctor = void 0;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3058,20 +3069,20 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
     var parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
             !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
         }, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
             !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
         }, true);
     }
@@ -3085,9 +3096,7 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3112,8 +3121,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e) {
-                    handleError(e, vm, "renderError");
+                catch (e$1) {
+                    handleError(e$1, vm, "renderError");
                     vnode = vm._vnode;
                 }
             }
@@ -3171,24 +3180,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
+        var owners_1 = (factory.owners = [owner]);
+        var sync_1 = true;
+        var timerLoading_1 = null;
+        var timerTimeout_1 = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+        var forceRender_1 = function (renderCompleted) {
+            for (var i = 0, l = owners_1.length; i < l; i++) {
+                owners_1[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
+                owners_1.length = 0;
+                if (timerLoading_1 !== null) {
+                    clearTimeout(timerLoading_1);
+                    timerLoading_1 = null;
                 }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
+                if (timerTimeout_1 !== null) {
+                    clearTimeout(timerTimeout_1);
+                    timerTimeout_1 = null;
                 }
             }
         };
@@ -3197,62 +3206,63 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
+            if (!sync_1) {
+                forceRender_1(true);
             }
             else {
-                owners.length = 0;
+                owners_1.length = 0;
             }
         });
-        var reject = once(function (reason) {
-            warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+        var reject_1 = once(function (reason) {
+            warn("Failed to resolve async component: " + String(factory) +
+                    (reason ? "\nReason: " + reason : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender(true);
+                forceRender_1(true);
             }
         });
-        var res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
+        var res_1 = factory(resolve, reject_1);
+        if (isObject(res_1)) {
+            if (isPromise(res_1)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
+                    res_1.then(resolve, reject_1);
                 }
             }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
+            else if (isPromise(res_1.component)) {
+                res_1.component.then(resolve, reject_1);
+                if (isDef(res_1.error)) {
+                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
                 }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
+                if (isDef(res_1.loading)) {
+                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                    if (res_1.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
-                            timerLoading = null;
+                        timerLoading_1 = setTimeout(function () {
+                            timerLoading_1 = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender(false);
+                                forceRender_1(false);
                             }
-                        }, res.delay || 200);
+                        }, res_1.delay || 200);
                     }
                 }
-                if (isDef(res.timeout)) {
+                if (isDef(res_1.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
-                        timerTimeout = null;
+                    timerTimeout_1 = setTimeout(function () {
+                        timerTimeout_1 = null;
                         if (isUndef(factory.resolved)) {
-                            reject("timeout (" + (res.timeout) + "ms)");
+                            reject_1("timeout (" + res_1.timeout + "ms)"
+                                );
                         }
-                    }, res.timeout);
+                    }, res_1.timeout);
                 }
             }
         }
-        sync = false;
+        sync_1 = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3276,8 +3286,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
-
 /* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
@@ -3288,15 +3296,15 @@ function initEvents(vm) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target;
-function add(event, fn) {
-    target.$on(event, fn);
+var target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
 }
 function remove$1(event, fn) {
-    target.$off(event, fn);
+    target$1.$off(event, fn);
 }
-function createOnceHandler(event, fn) {
-    var _target = target;
+function createOnceHandler$1(event, fn) {
+    var _target = target$1;
     return function onceHandler() {
         var res = fn.apply(null, arguments);
         if (res !== null) {
@@ -3305,9 +3313,9 @@ function createOnceHandler(event, fn) {
     };
 }
 function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
 }
 function eventsMixin(Vue) {
     var hookRE = /^hook:/;
@@ -3347,8 +3355,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                vm.$off(event[i_1], fn);
             }
             return vm;
         }
@@ -3379,10 +3387,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
             }
         }
         var cbs = vm._events[event];
@@ -3473,13 +3481,13 @@ function lifecycleMixin(Vue) {
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook(vm, 'beforeDestroy');
+        callHook$1(vm, 'beforeDestroy');
         vm._isBeingDestroyed = true;
         // remove self from parent
         var parent = vm.$parent;
         // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove(parent.$children, vm);
+            remove$2(parent.$children, vm);
         }
         // teardown watchers
         if (vm._watcher) {
@@ -3499,7 +3507,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook(vm, 'destroyed');
+        callHook$1(vm, 'destroyed');
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3532,7 +3540,7 @@ function mountComponent(vm, el, hydrating) {
             }
         }
     }
-    callHook(vm, 'beforeMount');
+    callHook$1(vm, 'beforeMount');
     var updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
@@ -3544,11 +3552,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure("vue " + name + " render", startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure("vue " + name + " patch", startTag, endTag);
         };
     }
     else {
@@ -3560,9 +3568,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before: function () {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook(vm, 'beforeUpdate');
+                callHook$1(vm, 'beforeUpdate');
             }
         },
     }, true /* isRenderWatcher */);
@@ -3571,7 +3579,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook(vm, 'mounted');
+        callHook$1(vm, 'mounted');
     }
     return vm;
 }
@@ -3661,7 +3669,7 @@ function activateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'activated');
+        callHook$1(vm, 'activated');
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3676,10 +3684,10 @@ function deactivateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'deactivated');
+        callHook$1(vm, 'deactivated');
     }
 }
-function callHook(vm, hook) {
+function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
     var handlers = vm.$options[hook];
@@ -3730,15 +3738,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = function () { return performance_1.now(); };
     }
 }
 /**
@@ -3773,7 +3781,7 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        ? "in watcher with expression \"" + watcher.expression + "\""
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3798,7 +3806,7 @@ function callUpdatedHooks(queue) {
         var watcher = queue[i];
         var vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook(vm, 'updated');
+            callHook$1(vm, 'updated');
         }
     }
 }
@@ -3852,197 +3860,200 @@ function queueWatcher(watcher) {
 }
 
 /* @flow */
-var uid$2 = 0;
+var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        expOrFn.toString();
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            warn("Failed watching path: \"" + expOrFn + "\" " +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
+var Watcher = /** @class */ (function () {
+    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
         }
-    }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression =
+            expOrFn.toString() ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
         }
         else {
-            throw e;
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn("Failed watching path: \"" + expOrFn + "\" " +
+                        'Watcher only accepts simple dot-delimited paths. ' +
+                        'For full control, use a function instead.', vm);
+            }
         }
+        this.value = this.lazy ? undefined : this.get();
     }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
-        }
-        popTarget();
-        this.cleanupDeps();
-    }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    Watcher.prototype.get = function () {
+        pushTarget(this);
+        var value;
+        var vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-    }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
-    }
-    else {
-        queueWatcher(this);
-    }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
+        catch (e) {
             if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                }
+                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
             }
             else {
-                this.cb.call(this.vm, value, oldValue);
+                throw e;
             }
         }
-    }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
-    }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove(this.vm._watchers, this);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
         }
+        return value;
+    };
+    /**
+     * Add a dependency to this directive.
+     */
+    Watcher.prototype.addDep = function (dep) {
+        var id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    };
+    /**
+     * Clean up for dependency collection.
+     */
+    Watcher.prototype.cleanupDeps = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            var dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        var tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    };
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    Watcher.prototype.update = function () {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
         }
-        this.active = false;
-    }
-};
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    };
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    Watcher.prototype.run = function () {
+        if (this.active) {
+            var value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                var oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    try {
+                        this.cb.call(this.vm, value, oldValue);
+                    }
+                    catch (e) {
+                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                    }
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    };
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    Watcher.prototype.evaluate = function () {
+        this.value = this.get();
+        this.dirty = false;
+    };
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    Watcher.prototype.depend = function () {
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    };
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    Watcher.prototype.teardown = function () {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            var i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    };
+    return Watcher;
+}());
 
 /* @flow */
 var sharedPropertyDefinition = {
@@ -4064,7 +4075,7 @@ function initState(vm) {
     vm._watchers = [];
     var opts = vm.$options;
     if (opts.props)
-        { initProps(vm, opts.props); }
+        { initProps$1(vm, opts.props); }
     if (opts.methods)
         { initMethods(vm, opts.methods); }
     if (opts.data) {
@@ -4074,12 +4085,12 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed(vm, opts.computed); }
+        { initComputed$1(vm, opts.computed); }
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
-function initProps(vm, propsOptions) {
+function initProps$1(vm, propsOptions) {
     var propsData = vm.$options.propsData || {};
     var props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
@@ -4090,7 +4101,7 @@ function initProps(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    var _loop_1 = function (key) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4098,14 +4109,14 @@ function initProps(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
             }
-            defineReactive$$1(props, key, value, function () {
+            defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
                     warn("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                        ("value. Prop being mutated: \"" + key + "\""), vm);
                 }
             });
         }
@@ -4116,8 +4127,9 @@ function initProps(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-
-    for (var key in propsOptions) loop( key );
+    for (var key in propsOptions) {
+        _loop_1(key);
+    }
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4137,7 +4149,7 @@ function initData(vm) {
         var key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn("Method \"" + key + "\" has already been defined as a data property.", vm);
             }
         }
         if (props && hasOwn(props, key)) {
@@ -4166,7 +4178,7 @@ function getData(data, vm) {
     }
 }
 var computedWatcherOptions = { lazy: true };
-function initComputed(vm, computed) {
+function initComputed$1(vm, computed) {
     // $flow-disable-line
     var watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
@@ -4175,7 +4187,7 @@ function initComputed(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (getter == null) {
-            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+            warn("Getter is missing for computed property \"" + key + "\".", vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4189,10 +4201,10 @@ function initComputed(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn("The computed property \"" + key + "\" is already defined in data.", vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
             }
         }
     }
@@ -4215,7 +4227,7 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4244,11 +4256,11 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         {
             if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn("Method \"" + key + "\" has already been defined as a prop.", vm);
             }
             if (key in vm && isReserved(key)) {
                 warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4320,7 +4332,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
             }
             popTarget();
         }
@@ -4331,17 +4343,17 @@ function stateMixin(Vue) {
 }
 
 /* @flow */
-var uid$3 = 0;
-function initMixin(Vue) {
+var uid = 0;
+function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
         var vm = this;
         // a uid
-        vm._uid = uid$3++;
+        vm._uid = uid++;
         var startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = "vue-perf-start:" + vm._uid;
+            endTag = "vue-perf-end:" + vm._uid;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4365,16 +4377,16 @@ function initMixin(Vue) {
         initLifecycle(vm);
         initEvents(vm);
         initRender(vm);
-        callHook(vm, 'beforeCreate');
+        callHook$1(vm, 'beforeCreate');
         initInjections(vm); // resolve injections before data/props
         initState(vm);
         initProvide(vm); // resolve provide after data/props
-        callHook(vm, 'created');
+        callHook$1(vm, 'created');
         /* istanbul ignore if */
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure("vue " + vm._name + " init", startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4442,7 +4454,7 @@ function Vue(options) {
     this._init(options);
 }
 //@ts-ignore
-initMixin(Vue);
+initMixin$1(Vue);
 //@ts-ignore
 stateMixin(Vue);
 //@ts-ignore
@@ -4474,7 +4486,7 @@ function initUse(Vue) {
 }
 
 /* @flow */
-function initMixin$1(Vue) {
+function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
         return this;
@@ -4517,10 +4529,10 @@ function initExtend(Vue) {
         // the Vue instances at extension time, on the extended prototype. This
         // avoids Object.defineProperty calls for each instance created.
         if (Sub.options.props) {
-            initProps$1(Sub);
+            initProps(Sub);
         }
         if (Sub.options.computed) {
-            initComputed$1(Sub);
+            initComputed(Sub);
         }
         // allow further extension/mixin/plugin usage
         Sub.extend = Super.extend;
@@ -4546,13 +4558,13 @@ function initExtend(Vue) {
         return Sub;
     };
 }
-function initProps$1(Comp) {
+function initProps(Comp) {
     var props = Comp.options.props;
     for (var key in props) {
         proxy(Comp.prototype, "_props", key);
     }
 }
-function initComputed$1(Comp) {
+function initComputed(Comp) {
     var computed = Comp.options.computed;
     for (var key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
@@ -4608,26 +4620,24 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
-            if (name && !filter(name)) {
+            var name_1 = getComponentName(cachedNode.componentOptions);
+            if (name_1 && !filter(name_1)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-        cached$$1.componentInstance.$destroy();
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+        cached.componentInstance.$destroy();
     }
     cache[key] = null;
-    remove(keys, key);
+    remove$2(keys, key);
 }
 var patternTypes = [String, RegExp, Array];
 // TODO use defineComponent
@@ -4639,55 +4649,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    created: function () {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
+    destroyed: function () {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
+    mounted: function () {
+        var _this = this;
         this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+            pruneCache(_this, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+            pruneCache(_this, function (name) { return !matches(val, name); });
         });
     },
-    render: function render() {
+    render: function () {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            var name_2 = getComponentName(componentOptions);
+            var _a = this, include = _a.include, exclude = _a.exclude;
             if (
             // not included
-            (include && (!name || !matches(include, name))) ||
+            (include && (!name_2 || !matches(include, name_2))) ||
                 // excluded
-                (exclude && name && matches(exclude, name))) {
+                (exclude && name_2 && matches(exclude, name_2))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
+            var _b = this, cache = _b.cache, keys = _b.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? "::" + componentOptions.tag : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
                 // make current key freshest
-                remove(keys, key);
+                remove$2(keys, key);
                 keys.push(key);
             }
             else {
@@ -4726,7 +4731,7 @@ function initGlobalAPI(Vue) {
         warn: warn,
         extend: extend,
         mergeOptions: mergeOptions,
-        defineReactive: defineReactive$$1,
+        defineReactive: defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
@@ -4745,7 +4750,7 @@ function initGlobalAPI(Vue) {
     Vue.options._base = Vue;
     extend(Vue.options.components, builtInComponents);
     initUse(Vue);
-    initMixin$1(Vue);
+    initMixin(Vue);
     initExtend(Vue);
     initAssetRegisters(Vue);
 }
@@ -4755,7 +4760,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get: function () {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4956,7 +4961,7 @@ function query(el) {
 }
 
 /* @flow */
-function createElement$1(tagName, vnode) {
+function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
@@ -5004,7 +5009,8 @@ function setStyleScope(node, scopeId) {
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
-  createElement: createElement$1,
+  __proto__: null,
+  createElement: createElement,
   createElementNS: createElementNS,
   createTextNode: createTextNode,
   createComment: createComment,
@@ -5020,16 +5026,16 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 
 /* @flow */
 var ref = {
-    create: function create(_, vnode) {
+    create: function (_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update: function (oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5043,7 +5049,7 @@ function registerRef(vnode, isRemoval) {
     if (isRemoval) {
         if (Array.isArray(refs[key])) {
             // @ts-expect-error invalid typings
-            remove(refs[key], ref);
+            remove$2(refs[key], ref);
         }
         else if (refs[key] === ref) {
             refs[key] = undefined;
@@ -5111,8 +5117,7 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    var modules = backend.modules, nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5125,13 +5130,13 @@ function createPatchFunction(backend) {
         return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
     function createRmCb(childElm, listeners) {
-        function remove$$1() {
-            if (--remove$$1.listeners === 0) {
+        function remove() {
+            if (--remove.listeners === 0) {
                 removeNode(childElm);
             }
         }
-        remove$$1.listeners = listeners;
-        return remove$$1;
+        remove.listeners = listeners;
+        return remove;
     }
     function removeNode(el) {
         var parent = nodeOps.parentNode(el);
@@ -5140,7 +5145,7 @@ function createPatchFunction(backend) {
             nodeOps.removeChild(parent, el);
         }
     }
-    function isUnknownElement$$1(vnode, inVPre) {
+    function isUnknownElement(vnode, inVPre) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
@@ -5173,7 +5178,7 @@ function createPatchFunction(backend) {
                 if (data && data.pre) {
                     creatingElmInVPre++;
                 }
-                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
                     warn('Unknown custom element: <' +
                         tag +
                         '> - did you ' +
@@ -5266,11 +5271,11 @@ function createPatchFunction(backend) {
         // a reactivated keep-alive component doesn't insert itself
         insert(parentElm, vnode.elm, refElm);
     }
-    function insert(parent, elm, ref$$1) {
+    function insert(parent, elm, ref) {
         if (isDef(parent)) {
-            if (isDef(ref$$1)) {
-                if (nodeOps.parentNode(ref$$1) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref$$1);
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
                 }
             }
             else {
@@ -5283,8 +5288,8 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5298,8 +5303,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+            cbs.create[i_2](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5371,7 +5376,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
+            var i_3;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5383,16 +5388,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
+            if (isDef((i_3 = vnode.componentInstance)) &&
+                isDef((i_3 = i_3._vnode)) &&
+                isDef(i_3.data)) {
+                removeAndInvokeRemoveHook(i_3, rm);
             }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
+            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                cbs.remove[i_3](vnode, rm);
             }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
+            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                i_3(vnode, rm);
             }
             else {
                 rm();
@@ -5488,12 +5493,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
+        for (var i_4 = 0; i_4 < children.length; i_4++) {
+            var vnode = children[i_4];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5502,10 +5507,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (var i_5 = start; i_5 < end; i_5++) {
+            var c = oldCh[i_5];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                { return i_5; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5585,8 +5590,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
+            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                queue[i_6].data.hook.insert(queue[i_6]);
             }
         }
     }
@@ -5599,9 +5604,7 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        var tag = vnode.tag, data = vnode.data, children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5650,9 +5653,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        for (var i_7 = 0; i_7 < children.length; i_7++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5696,7 +5699,7 @@ function createPatchFunction(backend) {
     function assertNodeMatch(node, vnode, inVPre) {
         if (isDef(vnode.tag)) {
             return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement$$1(vnode, inVPre) &&
+                (!isUnknownElement(vnode, inVPre) &&
                     vnode.tag.toLowerCase() ===
                         (node.tagName && node.tagName.toLowerCase())));
         }
@@ -5763,22 +5766,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
+                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                            cbs.destroy[i_8](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                cbs.create[i_9](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
+                            var insert_1 = ancestor.data.hook.insert;
+                            if (insert_1.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                    insert_1.fns[i_10]();
                                 }
                             }
                         }
@@ -5819,8 +5822,8 @@ function updateDirectives(oldVnode, vnode) {
 function _update(oldVnode, vnode) {
     var isCreate = oldVnode === emptyNode;
     var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
     var dirsWithInsert = [];
     var dirsWithPostpatch = [];
     var key, oldDir, dir;
@@ -5829,7 +5832,7 @@ function _update(oldVnode, vnode) {
         dir = newDirs[key];
         if (!oldDir) {
             // new directive, bind
-            callHook$1(dir, 'bind', vnode, oldVnode);
+            callHook(dir, 'bind', vnode, oldVnode);
             if (dir.def && dir.def.inserted) {
                 dirsWithInsert.push(dir);
             }
@@ -5838,7 +5841,7 @@ function _update(oldVnode, vnode) {
             // existing directive, update
             dir.oldValue = oldDir.value;
             dir.oldArg = oldDir.arg;
-            callHook$1(dir, 'update', vnode, oldVnode);
+            callHook(dir, 'update', vnode, oldVnode);
             if (dir.def && dir.def.componentUpdated) {
                 dirsWithPostpatch.push(dir);
             }
@@ -5847,7 +5850,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithInsert.length) {
         var callInsert = function () {
             for (var i = 0; i < dirsWithInsert.length; i++) {
-                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
         if (isCreate) {
@@ -5860,7 +5863,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithPostpatch.length) {
         mergeVNodeHook(vnode, 'postpatch', function () {
             for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
     }
@@ -5868,13 +5871,13 @@ function _update(oldVnode, vnode) {
         for (key in oldDirs) {
             if (!newDirs[key]) {
                 // no longer present, unbind
-                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
             }
         }
     }
 }
 var emptyModifiers = Object.create(null);
-function normalizeDirectives$1(dirs, vm) {
+function normalizeDirectives(dirs, vm) {
     var res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
@@ -5894,16 +5897,16 @@ function normalizeDirectives$1(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
 }
-function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
         }
     }
 }
@@ -5998,11 +6001,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            var blocker_1 = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
+                el.removeEventListener('input', blocker_1);
             };
-            el.addEventListener('input', blocker);
+            el.addEventListener('input', blocker_1);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6042,12 +6045,6 @@ var klass = {
     update: updateClass,
 };
 
-/* @flow */
-
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -6063,8 +6060,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        var event_1 = isIE ? 'change' : 'input';
+        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6075,13 +6072,13 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target$1;
-function createOnceHandler$1(event, handler, capture) {
-    var _target = target$1; // save current target element in closure
+var target;
+function createOnceHandler(event, handler, capture) {
+    var _target = target; // save current target element in closure
     return function onceHandler() {
         var res = handler.apply(null, arguments);
         if (res !== null) {
-            remove$2(event, onceHandler, capture, _target);
+            remove(event, onceHandler, capture, _target);
         }
     };
 }
@@ -6089,7 +6086,7 @@ function createOnceHandler$1(event, handler, capture) {
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add$1(name, handler, capture, passive) {
+function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
     // happens because browsers fire microtask ticks between event propagation.
@@ -6097,17 +6094,17 @@ function add$1(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
+        var attachedTimestamp_1 = currentFlushTimestamp;
+        var original_1 = handler;
         //@ts-expect-error
-        handler = original._wrapper = function (e) {
+        handler = original_1._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
+                e.timeStamp >= attachedTimestamp_1 ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6116,14 +6113,14 @@ function add$1(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
+                return original_1.apply(this, arguments);
             }
         };
     }
-    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-function remove$2(name, handler, capture, _target) {
-    (_target || target$1).removeEventListener(name, 
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
     //@ts-expect-error
     handler._wrapper || handler, capture);
 }
@@ -6133,10 +6130,10 @@ function updateDOMListeners(oldVnode, vnode) {
     }
     var on = vnode.data.on || {};
     var oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
+    target = vnode.elm;
     normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
 }
 var events = {
     create: updateDOMListeners,
@@ -6351,9 +6348,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
+        var name_1 = vendorNames[i] + capName;
+        if (name_1 in emptyStyle) {
+            return name_1;
         }
     }
 });
@@ -6460,31 +6457,31 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def$$1) {
-    if (!def$$1) {
+function resolveTransition(def) {
+    if (!def) {
         return;
     }
     /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
+    if (typeof def === 'object') {
         var res = {};
-        if (def$$1.css !== false) {
-            extend(res, autoCssTransition(def$$1.name || 'v'));
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
         }
-        extend(res, def$$1);
+        extend(res, def);
         return res;
     }
-    else if (typeof def$$1 === 'string') {
-        return autoCssTransition(def$$1);
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
     }
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -6531,15 +6528,12 @@ function addTransitionClass(el, cls) {
 }
 function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
-        remove(el._transitionClasses, cls);
+        remove$2(el._transitionClasses, cls);
     }
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -6645,23 +6639,7 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -6769,17 +6747,7 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -6853,7 +6821,7 @@ function leave(vnode, rm) {
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+            ("got " + JSON.stringify(val) + "."), vnode.context);
     }
     else if (isNaN(val)) {
         warn("<transition> explicit " + name + " duration is NaN - " +
@@ -6893,7 +6861,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove$$1(vnode, rm) {
+        remove: function (vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -6930,7 +6898,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+    inserted: function (el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -6960,22 +6928,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated: function (el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            var prevOptions_1 = el._vOptions;
+            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
+                        hasNoMatchingOption(binding.value, curOptions_1);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -6996,8 +6964,8 @@ function actuallySetSelected(el, binding, vm) {
     var value = binding.value;
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+        warn("<select multiple v-model=\"" + binding.expression + "\"> " +
+                ("expects an Array value for its binding, but got " + Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7055,14 +7023,13 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
+        var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition$$1) {
+        if (value && transition) {
             vnode.data.show = true;
             enter(vnode, function () {
                 el.style.display = originalDisplay;
@@ -7072,16 +7039,14 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
-        if (transition$$1) {
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
             vnode.data.show = true;
             if (value) {
                 enter(vnode, function () {
@@ -7098,7 +7063,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7149,8 +7114,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    for (var key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7178,9 +7143,8 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
+    render: function (h) {
+        var _this = this;
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -7222,7 +7186,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        var id = "__transition-" + this._uid + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7256,8 +7220,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                    _this._leaving = false;
+                    _this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7265,14 +7229,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
+                var delayedLeave_1;
                 var performLeave = function () {
-                    delayedLeave();
+                    delayedLeave_1();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave = leave;
+                    delayedLeave_1 = leave;
                 });
             }
         }
@@ -7289,22 +7253,21 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
+    beforeMount: function () {
+        var _this = this;
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+            var restoreActiveInstance = setActiveInstance(_this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            _this._vnode = _this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(_this, vnode, hydrating);
         };
     },
-    render: function render(h) {
+    render: function (h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -7321,27 +7284,27 @@ var TransitionGroup = {
                 }
                 else {
                     var opts = c.componentOptions;
-                    var name = opts
+                    var name_1 = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn("<transition-group> children must be keyed: <" + name_1 + ">");
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
+            for (var i = 0; i < prevChildren.length; i++) {
+                var c = prevChildren[i];
+                c.data.transition = transitionData;
                 // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                c.data.pos = c.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7349,7 +7312,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
+    updated: function () {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7367,25 +7330,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
-                addTransitionClass(el, moveClass);
+                var el_1 = c.elm;
+                var s = el_1.style;
+                addTransitionClass(el_1, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
+                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                    if (e && e.target !== el_1) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
+                        el_1.removeEventListener(transitionEndEvent, cb);
+                        el_1._moveCb = null;
+                        removeTransitionClass(el_1, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove: function (el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
index 7a24ee33c65..0adec3a8753 100644
--- a/dist/vue.runtime.common.prod.js
+++ b/dist/vue.runtime.common.prod.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R,U="__proto__"in{},H="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=B&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0,X=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===V),G=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Z={}.watch,J=!1;if(H)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===R&&(R=!H&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),R},tt=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var pt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=ht[t];M(mt,t,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i})});var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(U?(e=mt,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var xt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&Ot(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?Ot(r,o):o}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}xt.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},P.forEach(function(t){xt[t]=St}),N.forEach(function(t){xt[t+"s"]=Et}),xt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},xt.provide=kt;var jt=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Tt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=xt[r]||jt;a[r]=o(t[r],e[r],n,r)}return a}function It(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Dt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Mt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Mt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Pt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Nt=/^\s*function (\w+)/;function Pt(t){var e=t&&t.toString().match(Nt);return e?e[1]:""}function Lt(t,e){return Pt(t)===Pt(e)}function Mt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Ft(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Ut(t,r,"errorCaptured hook")}}Ut(t,e,n)}finally{ut()}}function Rt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Ft(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Ft(t,r,o)}return i}function Ut(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e,null,"config.errorHandler")}Ht(t,e,n)}function Ht(t,e,n){if(!H&&!B||"undefined"==typeof console)throw t;console.error(t)}var Bt,Vt=!1,zt=[],Wt=!1;function qt(){Wt=!1;var t=zt.slice(0);zt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Kt=Promise.resolve();Bt=function(){Kt.then(qt),X&&setTimeout(k)},Vt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(qt)}:function(){setTimeout(qt,0)};else{var Xt=1,Gt=new MutationObserver(qt),Zt=document.createTextNode(String(Xt));Gt.observe(Zt,{characterData:!0}),Bt=function(){Xt=(Xt+1)%2,Zt.data=String(Xt)},Vt=!0}function Jt(t,e){var n;if(zt.push(function(){if(t)try{t.call(e)}catch(t){Ft(t,e,"nextTick")}else n&&n(e)}),Wt||(Wt=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Qt=new nt;function Yt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Qt),Qt.clear()}var te=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function ee(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Rt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Rt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ne(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=te(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=ee(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=te(c)).name,n[c],f.capture)}function re(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=ee([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=ee([s,c]),a.merged=!0,t[o]=a}function oe(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ie(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ae((u=t(u,(a||"")+"_"+c))[0])&&ae(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ae(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ae(u)&&ae(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ae(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function ce(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ue)&&delete n[u];return n}function ue(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=fe(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=pe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function fe(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ie(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function pe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ve(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function he(t){return It(this.$options,"filters",t)||E}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?me(o,r):i?me(i,t):r?$(r)!==e:void 0}function ge(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function _e(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(Ce(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function be(t,e,n){return Ce(t,"__once__"+e+(n?"_"+n:""),!0),t}function Ce(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&$e(t[r],e+"_"+r,n);else $e(t,e,n)}function $e(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function xe(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Oe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=be,t._n=f,t._s=l,t._l=de,t._t=ve,t._q=j,t._i=T,t._m=_e,t._f=he,t._k=ye,t._b=ge,t._v=dt,t._e=pt,t._u=Ae,t._g=we,t._d=xe,t._p=Oe}function Se(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=se(u.inject,i),this.slots=function(){return c.$slots||le(e.scopedSlots,c.$slots=ce(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Me(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Me(s,t,e,n,r,f)}}function Ee(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function je(t,e){for(var n in e)t[_(n)]=e[n]}ke(Se.prototype);var Te={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Te.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Dt(d,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,qe(e,r,h),u&&(e.$slots=ce(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Je(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Ye.push(e)):Ze(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Ge(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Je(e,"deactivated")}}(e,!0):e.$destroy())}},Ie=Object.keys(Te);function De(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Re;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I(function(e){t.resolved=Ue(e,o),c?s.length=0:p(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,p(!0))}),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=Ue(m.error,o)),n(m.loading)&&(t.loadingComp=Ue(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},bn(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);oe(a,c,u,l,!0)||oe(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Dt(l,u,r||t);else n(o.attrs)&&je(c,o.attrs),n(o.props)&&je(c,o.props);var f=new Se(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Ee(p,o,f.parent,s);if(Array.isArray(p)){for(var d=ie(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Ee(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Ie.length;n++){var r=Ie[n],o=e[r],i=Te[r];o===i||o&&o._merged||(e[r]=o?Ne(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function Ne(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Pe=1,Le=2;function Me(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return pt();n(a)&&n(a.is)&&(o=a.is);if(!o)return pt();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=ie(s):c===Pe&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=It(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):De(f,a,t,s,o)}else u=De(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Yt(t.style);i(t.class)&&Yt(t.class)}(a),u):pt()}(t,a,s,c,u)}var Fe,Re=null;function Ue(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function He(t){return t.isComment&&t.asyncFactory}function Be(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||He(r)))return r}}function Ve(t,e){Fe.$on(t,e)}function ze(t,e){Fe.$off(t,e)}function We(t,e){var n=Fe;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function qe(t,e,n){Fe=t,ne(e,n||{},Ve,ze,We,t),Fe=void 0}var Ke=null;function Xe(t){var e=Ke;return Ke=t,function(){Ke=e}}function Ge(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ze(t,e){if(e){if(t._directInactive=!1,Ge(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ze(t.$children[n]);Je(t,"activated")}}function Je(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Rt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Qe=[],Ye=[],tn={},en=!1,nn=!1,rn=0;var on=0,an=Date.now;if(H&&!W){var sn=window.performance;sn&&"function"==typeof sn.now&&an()>document.createEvent("Event").timeStamp&&(an=function(){return sn.now()})}function cn(){var t,e;for(on=an(),nn=!0,Qe.sort(function(t,e){return t.id-e.id}),rn=0;rn<Qe.length;rn++)(t=Qe[rn]).before&&t.before(),e=t.id,tn[e]=null,t.run();var n=Ye.slice(),r=Qe.slice();rn=Qe.length=Ye.length=0,tn={},en=nn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ze(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Je(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var un=0,ln=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};ln.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ft(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Yt(t),ut(),this.cleanupDeps()}return t},ln.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},ln.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},ln.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==tn[e]){if(tn[e]=!0,nn){for(var n=Qe.length-1;n>rn&&Qe[n].id>t.id;)n--;Qe.splice(n+1,0,t)}else Qe.push(t);en||(en=!0,Jt(cn))}}(this)},ln.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ft(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},ln.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},ln.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},ln.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var fn={enumerable:!0,configurable:!0,get:k,set:k};function pn(t,e,n){fn.get=function(){return this[e][n]},fn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,fn)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Dt(i,e,n,t);$t(r,i,a),i in t||pn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(var n in e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Ft(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&pn(t,"_data",i))}var a;Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new ln(t,a||k,k,vn)),o in t||hn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)gn(t,n,r[o]);else gn(t,n,r)}}(t,e.watch)}var vn={lazy:!0};function hn(t,e,n){var r=!Y();"function"==typeof n?(fn.get=r?mn(e):yn(n),fn.set=k):(fn.get=n.get?r&&!1!==n.cache?mn(e):yn(n.get):k,fn.set=n.set||k),Object.defineProperty(t,e,fn)}function mn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function yn(t){return function(){return t.call(this,this)}}function gn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var _n=0;function bn(t){var e=t.options;if(t.super){var n=bn(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Tt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function Cn(t){this._init(t)}function $n(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Tt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)pn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)hn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function xn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&On(n,i,r,o)}}}function On(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=_n++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(bn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&qe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=ce(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Me(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Me(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Je(n,"beforeCreate"),function(t){var e=se(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(function(n){$t(t,n,e[n])}),_t(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Je(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(Cn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return gn(this,t,e,n);(n=n||{}).user=!0;var r=new ln(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Ft(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(Cn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Rt(e[o],this,n,this,r)}return this}}(Cn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Xe(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Je(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Je(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(Cn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Jt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=le(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Re=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ft(n,e,"render"),t=e._vnode}finally{Re=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=pt()),t.parent=o,t}}(Cn);var kn=[String,RegExp,Array],Sn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)On(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){xn(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){xn(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Jt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,Sn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),$n(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(Cn),Object.defineProperty(Cn.prototype,"$isServer",{get:Y}),Object.defineProperty(Cn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Cn,"FunctionalRenderContext",{value:Se}),Cn.version="2.6.12";var En=p("style,class"),jn=p("input,textarea,option,select,progress"),Tn=p("contenteditable,draggable,spellcheck"),In=p("events,caret,typing,plaintext-only"),Dn=function(t,e){return Fn(e)||"false"===e?"false":"contenteditable"===t&&In(e)?e:"true"},Nn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Pn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Mn=function(t){return Ln(t)?t.slice(6,t.length):""},Fn=function(t){return null==t||!1===t};function Rn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Un(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Un(e,r.data));return function(t,e){if(n(t)||n(e))return Hn(t,Bn(e));return""}(e.staticClass,e.class)}function Un(t,e){return{staticClass:Hn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Hn(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Bn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Wn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),qn=function(t){return zn(t)||Wn(t)};var Kn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Vn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create:function(t,e){Jn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Jn(t,!0),Jn(e))},destroy:function(t){Jn(t,!0)}};function Jn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Qn=new lt("",{},[]),Yn=["create","activate","update","remove","destroy"];function tr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Xn(o)&&Xn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function er(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var nr={create:rr,update:rr,destroy:function(t){rr(t,Qn)}};function rr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Qn,a=e===Qn,s=ir(t.data.directives,t.context),c=ir(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,sr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(sr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)sr(u[n],"inserted",e,t)};i?re(e,"insert",f):f()}l.length&&re(e,"postpatch",function(){for(var n=0;n<l.length;n++)sr(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||sr(s[n],"unbind",t,t,a)}(t,e)}var or=Object.create(null);function ir(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=or),o[ar(r)]=r,r.def=It(e.$options,"directives",r.name);return o}function ar(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function sr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ft(r,n.context,"directive "+t.name+" "+e+" hook")}}var cr=[Zn,nr];function ur(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&lr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&lr(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Pn,Mn(i)):Tn(i)||s.removeAttribute(i))}}function lr(t,e,n,r){r||t.tagName.indexOf("-")>-1?fr(t,e,n):Nn(e)?Fn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,Dn(e,n)):Ln(e)?Fn(n)?t.removeAttributeNS(Pn,Mn(e)):t.setAttributeNS(Pn,e,n):fr(t,e,n)}function fr(t,e,n){if(Fn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var pr={create:ur,update:ur};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Rn(r),c=o._transitionClasses;n(c)&&(s=Hn(s,Bn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var vr,hr={create:dr,update:dr},mr="__r",yr="__c";function gr(t,e,n){var r=vr;return function o(){null!==e.apply(null,arguments)&&Cr(t,o,n,r)}}var _r=Vt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var o=on,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}vr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||vr).removeEventListener(t,e._wrapper||e,n)}function $r(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};vr=r.elm,function(t){if(n(t[mr])){var e=W?"change":"input";t[e]=[].concat(t[mr],t[e]||[]),delete t[mr]}n(t[yr])&&(t.change=[].concat(t[yr],t.change||[]),delete t[yr])}(o),ne(o,i,br,Cr,gr,r.context),vr=void 0}}var wr,Ar={create:$r,update:$r};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Wn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:xr,update:xr},Sr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?O(t):"string"==typeof t?Sr(t):t}var Tr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty($(e),n.replace(Dr,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Lr=y(function(t){if(Tr=Tr||document.createElement("div").style,"filter"!==(t=_(t))&&t in Tr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Tr)return r}});function Mr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=jr(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Nr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Br(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Vr(t.name||"v")),x(e,t),e}return"string"==typeof t?Vr(t):void 0}}var Vr=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),zr=H&&!q,Wr="transition",qr="animation",Kr="transition",Xr="transitionend",Gr="animation",Zr="animationend";zr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Kr="WebkitTransition",Xr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Gr="WebkitAnimation",Zr="webkitAnimationEnd"));var Jr=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Qr(t){Jr(function(){Jr(t)})}function Yr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Ur(t,e))}function to(t,e){t._transitionClasses&&v(t._transitionClasses,e),Hr(t,e)}function eo(t,e,n){var r=ro(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Wr?Xr:Zr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var no=/\b(transform|all)(,|$)/;function ro(t,e){var n,r=window.getComputedStyle(t),o=(r[Kr+"Delay"]||"").split(", "),i=(r[Kr+"Duration"]||"").split(", "),a=oo(o,i),s=(r[Gr+"Delay"]||"").split(", "),c=(r[Gr+"Duration"]||"").split(", "),u=oo(s,c),l=0,f=0;return e===Wr?a>0&&(n=Wr,l=a,f=i.length):e===qr?u>0&&(n=qr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Wr:qr:null)?n===Wr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Wr&&no.test(r[Kr+"Property"])}}function oo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return io(e)+io(t[n])}))}function io(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ao(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Br(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ke,O=Ke.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=uo(D),R=o._enterCb=I(function(){M&&(to(o,j),to(o,E)),R.cancelled?(M&&to(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||re(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Yr(o,S),Yr(o,E),Qr(function(){to(o,S),R.cancelled||(Yr(o,j),F||(co(L)?setTimeout(R,L):eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function so(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Br(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=uo(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(to(o,l),to(o,p)),$.cancelled?(_&&to(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Yr(o,u),Yr(o,p),Qr(function(){to(o,u),$.cancelled||(Yr(o,l),b||(co(C)?setTimeout($,C):eo(o,c,$)))})),v&&v(o,$),_||b||$())}}function co(t){return"number"==typeof t&&!isNaN(t)}function uo(t){if(e(t))return!1;var r=t.fns;return n(r)?uo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function lo(t,e){!0!==e.data.show&&ao(e)}var fo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Yn.length;++i)for(s[Yn[i]]=[],a=0;a<c.length;++a)n(c[a][Yn[i]])&&s[Yn[i]].push(c[a][Yn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Qn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Jn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Qn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Qn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&tr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:tr(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):tr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):tr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):tr(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=er(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):tr(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Yt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&tr(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Qn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Jn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Gn,modules:[pr,hr,Ar,kr,Fr,H?{create:lo,activate:lo,remove:function(t,e){!0!==t.data.show?so(t,e):e()}}:{}].concat(cr)});q&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&bo(t,"input")});var po={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?re(n,"postpatch",function(){po.componentUpdated(t,e,n)}):vo(t,e,n.context),t._vOptions=[].map.call(t.options,yo)):("textarea"===n.tag||Xn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",go),t.addEventListener("compositionend",_o),t.addEventListener("change",_o),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){vo(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,yo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return mo(t,o)}):e.value!==e.oldValue&&mo(e.value,o))&&bo(t,"change")}}};function vo(t,e,n){ho(t,e,n),(W||K)&&setTimeout(function(){ho(t,e,n)},0)}function ho(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,yo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(yo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function mo(t,e){return e.every(function(e){return!j(e,t)})}function yo(t){return"_value"in t?t._value:t.value}function go(t){t.target.composing=!0}function _o(t){t.target.composing&&(t.target.composing=!1,bo(t.target,"input"))}function bo(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Co(t){return!t.componentInstance||t.data&&t.data.transition?t:Co(t.componentInstance._vnode)}var $o={model:po,show:{bind:function(t,e,n){var r=e.value,o=(n=Co(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,ao(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=Co(n)).data&&n.data.transition?(n.data.show=!0,r?ao(n,function(){t.style.display=t.__vOriginalDisplay}):so(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},wo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ao(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ao(Be(e.children)):t}function xo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Oo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var ko=function(t){return t.tag||He(t)},So=function(t){return"show"===t.name},Eo={name:"transition",props:wo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(ko)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Ao(i);if(!a)return i;if(this._leaving)return Oo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=xo(this),u=this._vnode,l=Ao(u);if(a.data.directives&&a.data.directives.some(So)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!He(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,re(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Oo(t,i);if("in-out"===r){if(He(a))return u;var p,d=function(){p()};re(c,"afterEnter",d),re(c,"enterCancelled",d),re(f,"delayLeave",function(t){p=t})}}return i}}},jo=x({tag:String,moveClass:String},wo);function To(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Io(t){t.data.newPos=t.elm.getBoundingClientRect()}function Do(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete jo.mode;var No={Transition:Eo,TransitionGroup:{props:jo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Xe(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=xo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(To),t.forEach(Io),t.forEach(Do),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Yr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Xr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Xr,t),n._moveCb=null,to(n,e))})}}))},methods:{hasMove:function(t,e){if(!zr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Hr(n,t)}),Ur(n,e),n.style.display="none",this.$el.appendChild(n);var r=ro(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};Cn.config.mustUseProp=function(t,e,n){return"value"===n&&jn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},Cn.config.isReservedTag=qn,Cn.config.isReservedAttr=En,Cn.config.getTagNamespace=function(t){return Wn(t)?"svg":"math"===t?"math":void 0},Cn.config.isUnknownElement=function(t){if(!H)return!0;if(qn(t))return!1;if(t=t.toLowerCase(),null!=Kn[t])return Kn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Kn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Kn[t]=/HTMLUnknownElement/.test(e.toString())},x(Cn.options.directives,$o),x(Cn.options.components,No),Cn.prototype.__patch__=H?fo:k,Cn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),Je(t,"beforeMount"),r=function(){t._update(t._render(),n)},new ln(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Je(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Je(t,"mounted")),t}(this,t=t&&H?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},H&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",Cn)},0),module.exports=Cn;
\ No newline at end of file
+"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function dt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function wt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var At=L.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):$t(t,n,o));return t}function Ot(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function kt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}At.data=function(t,e,n){return n?Ot(t,e,n):e&&"function"!=typeof e?t:Ot(t,e)},P.forEach(function(t){At[t]=kt}),N.forEach(function(t){At[t+"s"]=St}),At.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},At.props=At.methods=At.inject=At.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},At.provide=Ot;var Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=jt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=At[r]||Et;a[r]=o(t[r],e[r],n,r)}return a}function Tt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Lt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Lt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Bt,Ht=!1,Vt=[],zt=!1;function Wt(){zt=!1;var t=Vt.slice(0);Vt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Bt=function(){qt.then(Wt),K&&setTimeout(k)},Ht=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Bt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Ht=!0}function Zt(t,e){var n;if(Vt.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[pt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=pt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=pt(f.text+u):""!==u&&s.push(pt(u)):ie(u)&&ie(f)?s[l]=pt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function pe(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function de(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return Tt(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?he(o,r):i?he(i,t):r?$(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?we(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ae(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=l,t._l=pe,t._t=de,t._q=j,t._i=T,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=pt,t._e=ft,t._u=we,t._g=$e,t._d=Ae,t._p=xe}function ke(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Le(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Le(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=dt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ee(t,e){for(var n in e)t[_(n)]=e[n]}Oe(ke.prototype);var je={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;je.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=It(d,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},Te=Object.keys(je);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I(function(e){t.resolved=Re(e,o),c?s.length=0:p(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,p(!0))}),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Ee(c,o.attrs),n(o.props)&&Ee(c,o.props);var f=new ke(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Se(p,o,f.parent,s);if(Array.isArray(p)){for(var d=oe(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Se(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Te.length;n++){var r=Te[n],o=e[r],i=je[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Pe=2;function Le(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Pe),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Pe?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=Tt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Be(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function He(t,e){Me.$on(t,e)}function Ve(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},He,Ve,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:k,set:k};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function pn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||k,k,dn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var dn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=k):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):k,ln.set=n.set||k),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=jt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=jt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function $n(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function An(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=$n(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Le(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Le(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),pn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=wt,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var On=[String,RegExp,Array],kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:On,exclude:On,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){An(t,function(t){return wn(e,t)})}),this.$watch("exclude",function(e){An(t,function(t){return!wn(e,t)})})},render:function(){var t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){var r=$n(n),o=this.include,i=this.exclude;if(o&&(!r||!wn(o,r))||i&&r&&wn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:jt,defineReactive:Ct},t.set=$t,t.delete=wt,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,kn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:ke}),bn.version="2.6.12";var Sn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=p("contenteditable,draggable,spellcheck"),Tn=p("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true"},Dn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Pn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Ln=function(t){return Pn(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Bn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Bn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Vn(t)||zn(t)};var qn=Object.create(null);var Kn=p("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=Tt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Pn(i)?s.removeAttributeNS(Nn,Ln(i)):jn(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):jn(e)?t.setAttribute(e,In(e,n)):Pn(e)?Mn(n)?t.removeAttributeNS(Nn,Ln(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function pr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Bn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var dr,vr={create:pr,update:pr},hr="__r",mr="__c";function yr(t,e,n){var r=dr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Ht&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}dr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||dr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};dr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),dr=void 0}}var $r,wr={create:Cr,update:Cr};function Ar(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:Ar,update:Ar},kr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?O(t):"string"==typeof t?kr(t):t}var jr,Tr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(Tr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty($(e),n.replace(Ir,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Pr=y(function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in jr)return r}});function Lr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=Er(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Dr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Lr,update:Lr},Fr=/\s+/;function Rr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Br(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Hr(t.name||"v")),x(e,t),e}return"string"==typeof t?Hr(t):void 0}}var Hr=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Vr=U&&!W,zr="transition",Wr="animation",qr="transition",Kr="transitionend",Xr="animation",Gr="animationend";Vr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(qr="WebkitTransition",Kr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Xr="WebkitAnimation",Gr="webkitAnimationEnd"));var Zr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Jr(t){Zr(function(){Zr(t)})}function Qr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Rr(t,e))}function Yr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Ur(t,e)}function to(t,e,n){var r=no(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===zr?Kr:Gr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var eo=/\b(transform|all)(,|$)/;function no(t,e){var n,r=window.getComputedStyle(t),o=(r[qr+"Delay"]||"").split(", "),i=(r[qr+"Duration"]||"").split(", "),a=ro(o,i),s=(r[Xr+"Delay"]||"").split(", "),c=(r[Xr+"Duration"]||"").split(", "),u=ro(s,c),l=0,f=0;return e===zr?a>0&&(n=zr,l=a,f=i.length):e===Wr?u>0&&(n=Wr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?zr:Wr:null)?n===zr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===zr&&eo.test(r[qr+"Property"])}}function ro(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return oo(e)+oo(t[n])}))}function oo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function io(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Br(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=qe,O=qe.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!W,F=co(D),R=o._enterCb=I(function(){M&&(Yr(o,j),Yr(o,E)),R.cancelled?(M&&Yr(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Qr(o,S),Qr(o,E),Jr(function(){Yr(o,S),R.cancelled||(Qr(o,j),F||(so(L)?setTimeout(R,L):to(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function ao(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Br(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=co(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Yr(o,l),Yr(o,p)),$.cancelled?(_&&Yr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Qr(o,u),Qr(o,p),Jr(function(){Yr(o,u),$.cancelled||(Qr(o,l),b||(so(C)?setTimeout($,C):to(o,c,$)))})),v&&v(o,$),_||b||$())}}function so(t){return"number"==typeof t&&!isNaN(t)}function co(t){if(e(t))return!1;var r=t.fns;return n(r)?co(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function uo(t,e){!0!==e.data.show&&io(e)}var lo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=dt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=dt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:Yn(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):Yn(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):Yn(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=tr(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):Yn(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&Yn(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Jn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,wr,Or,Mr,U?{create:uo,activate:uo,remove:function(t,e){!0!==t.data.show?ao(t,e):e()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&_o(t,"input")});var fo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){fo.componentUpdated(t,e,n)}):po(t,e,n.context),t._vOptions=[].map.call(t.options,mo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",yo),t.addEventListener("compositionend",go),t.addEventListener("change",go),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){po(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,mo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return ho(t,o)}):e.value!==e.oldValue&&ho(e.value,o))&&_o(t,"change")}}};function po(t,e,n){vo(t,e),(z||q)&&setTimeout(function(){vo(t,e)},0)}function vo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,mo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(mo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function ho(t,e){return e.every(function(e){return!j(e,t)})}function mo(t){return"_value"in t?t._value:t.value}function yo(t){t.target.composing=!0}function go(t){t.target.composing&&(t.target.composing=!1,_o(t.target,"input"))}function _o(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function bo(t){return!t.componentInstance||t.data&&t.data.transition?t:bo(t.componentInstance._vnode)}var Co={model:fo,show:{bind:function(t,e,n){var r=e.value,o=(n=bo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,io(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=bo(n)).data&&n.data.transition?(n.data.show=!0,r?io(n,function(){t.style.display=t.__vOriginalDisplay}):ao(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},$o={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function wo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?wo(Be(e.children)):t}function Ao(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function xo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Oo=function(t){return t.tag||Ue(t)},ko=function(t){return"show"===t.name},So={name:"transition",props:$o,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Oo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=wo(i);if(!a)return i;if(this._leaving)return xo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ao(this),u=this._vnode,l=wo(u);if(a.data.directives&&a.data.directives.some(ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),xo(t,i);if("in-out"===r){if(Ue(a))return u;var p,d=function(){p()};ne(c,"afterEnter",d),ne(c,"enterCancelled",d),ne(f,"delayLeave",function(t){p=t})}}return i}}},Eo=x({tag:String,moveClass:String},$o);function jo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function To(t){t.data.newPos=t.elm.getBoundingClientRect()}function Io(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Eo.mode;var Do={Transition:So,TransitionGroup:{props:Eo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ao(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(jo),t.forEach(To),t.forEach(Io),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Qr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Kr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Kr,t),n._moveCb=null,Yr(n,e))})}}))},methods:{hasMove:function(t,e){if(!Vr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Ur(n,t)}),Rr(n,e),n.style.display="none",this.$el.appendChild(n);var r=no(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};bn.config.mustUseProp=function(t,e,n){return"value"===n&&En(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Co),x(bn.options.components,Do),bn.prototype.__patch__=U?lo:k,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",bn)},0),module.exports=bn;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index 1b666367d91..4ca266587b6 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -107,7 +107,7 @@ var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove(arr, item) {
+function remove$2(arr, item) {
     if (arr.length) {
         var index = arr.indexOf(item);
         if (index > -1) {
@@ -421,7 +421,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -452,10 +452,10 @@ var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
 var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
 var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
 var isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
@@ -465,7 +465,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get: function () {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -511,20 +511,19 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
+    _Set = /** @class */ (function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function has (key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function add (key) {
+        Set.prototype.add = function (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function clear () {
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
         };
-
         return Set;
     }());
 }
@@ -535,20 +534,22 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
     warn = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+        else if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole && !config.silent) {
+        if (hasConsole_1 && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -571,10 +572,10 @@ if (process.env.NODE_ENV !== 'production') {
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    var repeat = function (str, n) {
+    var repeat_1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -608,50 +609,55 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
 
-var uid = 0;
+var uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
-    }
-};
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$2(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -666,43 +672,45 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
+    if (text === void 0) { text = ''; }
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -756,9 +764,12 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
+        var arguments$1 = arguments;
 
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -794,43 +805,46 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
-    }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive$$1(obj, keys[i]);
     }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
-    }
-};
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -880,7 +894,7 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
+function defineReactive(obj, key, val, customSetter, shallow) {
     var dep = new Dep();
     var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -941,7 +955,7 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -964,7 +978,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -974,7 +988,7 @@ function set(target, key, val) {
 function del(target, key) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+        warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -1002,7 +1016,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1113,7 +1127,7 @@ strats.data = function (parentVal, childVal, vm) {
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(parentVal, childVal) {
+function mergeHook$1(parentVal, childVal) {
     var res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
@@ -1133,7 +1147,7 @@ function dedupeHooks(hooks) {
     return res;
 }
 LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+    strats[hook] = mergeHook$1;
 });
 /**
  * Assets
@@ -1179,14 +1193,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key$1] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1224,7 +1238,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
         warn('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1268,7 +1282,7 @@ function normalizeProps(options, vm) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+            ("but got " + toRawType(props) + "."), vm);
     }
     options.props = res;
 }
@@ -1295,19 +1309,19 @@ function normalizeInject(options, vm) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+            ("but got " + toRawType(inject) + "."), vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives(options) {
+function normalizeDirectives$1(options) {
     var dirs = options.directives;
     if (dirs) {
         for (var key in dirs) {
-            var def$$1 = dirs[key];
-            if (typeof def$$1 === 'function') {
-                dirs[key] = { bind: def$$1, update: def$$1 };
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
             }
         }
     }
@@ -1315,7 +1329,7 @@ function normalizeDirectives(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 /**
@@ -1332,7 +1346,7 @@ function mergeOptions(parent, child, vm) {
     }
     normalizeProps(child, vm);
     normalizeInject(child, vm);
-    normalizeDirectives(child);
+    normalizeDirectives$1(child);
     // Apply extends and mixins on the child options,
     // but only if it is a raw options object that isn't
     // the result of another mergeOptions call.
@@ -1423,7 +1437,7 @@ function validateProp(key, propOptions, propsData, vm) {
     }
     if (process.env.NODE_ENV !== 'production' &&
         // skip validation for weex recycle-list child component props
-        !(false)) {
+        !(false  )) {
         assertProp(prop, key, value, vm, absent);
     }
     return value;
@@ -1554,7 +1568,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1562,24 +1576,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += " with value " + styleValue(value, expectedType);
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += "with value " + styleValue(value, receivedType) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return "\"" + value + "\"";
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return "" + Number(value);
     }
     else {
-        return ("" + value);
+        return "" + value;
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1587,9 +1601,12 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
+    var arguments$1 = arguments;
 
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments$1[_i];
+    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1655,7 +1672,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     if (process.env.NODE_ENV !== 'production') {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1698,9 +1715,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
+    var p_1 = Promise.resolve();
     timerFunc = function () {
-        p.then(flushCallbacks);
+        p_1.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1719,15 +1736,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
+    var counter_1 = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
     timerFunc = function () {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
+        counter_1 = (counter_1 + 1) % 2;
+        textNode_1.data = String(counter_1);
     };
     isUsingMicroTask = true;
 }
@@ -1772,36 +1789,34 @@ function nextTick(cb, ctx) {
     }
 }
 
-/* @flow */
-
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
+    var warnNonPresent_1 = function (target, key) {
         warn("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
+    var warnReservedPrefix_1 = function (target, key) {
         warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                     return false;
                 }
                 else {
@@ -1811,38 +1826,38 @@ if (process.env.NODE_ENV !== 'production') {
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
+    var hasHandler_1 = {
+        has: function (target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+            var isAllowed = allowedGlobals_1(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    var getHandler_1 = {
+        get: function (target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    { warnReservedPrefix_1(target, key); }
                 else
-                    { warnNonPresent(target, key); }
+                    { warnNonPresent_1(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy) {
+        if (hasProxy_1) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1893,18 +1908,18 @@ function _traverse(val, seen) {
 var mark;
 var measure;
 if (process.env.NODE_ENV !== 'production') {
-    var perf = inBrowser && window.performance;
+    var perf_1 = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) {
+        mark = function (tag) { return perf_1.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
+            perf_1.measure(name, startTag, endTag);
+            perf_1.clearMarks(startTag);
+            perf_1.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1913,13 +1928,13 @@ if (process.env.NODE_ENV !== 'production') {
 var normalizeEvent = cached(function (name) {
     var passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
     var capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
         name: name,
-        once: once$$1,
+        once: once,
         capture: capture,
         passive: passive,
     };
@@ -1943,15 +1958,15 @@ function createFnInvoker(fns, vm) {
     invoker.fns = fns;
     return invoker;
 }
-function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-    var name, def$$1, cur, old, event;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, cur, old, event;
     for (name in on) {
-        def$$1 = cur = on[name];
+        cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+                warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1970,7 +1985,7 @@ function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
     for (name in oldOn) {
         if (isUndef(on[name])) {
             event = normalizeEvent(name);
-            remove$$1(event.name, oldOn[name], event.capture);
+            remove(event.name, oldOn[name], event.capture);
         }
     }
 }
@@ -1986,7 +2001,7 @@ function mergeVNodeHook(def, hookKey, hook) {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
         // and prevent memory leak
-        remove(invoker.fns, wrappedHook);
+        remove$2(invoker.fns, wrappedHook);
     }
     if (isUndef(oldHook)) {
         // no existing hook
@@ -2018,8 +2033,7 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    var attrs = data.attrs, props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2029,11 +2043,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2108,7 +2122,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2167,14 +2181,14 @@ function initInjections(vm) {
         Object.keys(result).forEach(function (key) {
             /* istanbul ignore else */
             if (process.env.NODE_ENV !== 'production') {
-                defineReactive$$1(vm, key, result[key], function () {
+                defineReactive(vm, key, result[key], function () {
                     warn("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                        ("injection being mutated: \"" + key + "\""), vm);
                 });
             }
             else {
-                defineReactive$$1(vm, key, result[key]);
+                defineReactive(vm, key, result[key]);
             }
         });
         toggleObserving(true);
@@ -2210,7 +2224,7 @@ function resolveInject(inject, vm) {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn("Injection \"" + key + "\" not found", vm);
                 }
             }
         }
@@ -2239,8 +2253,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2253,9 +2267,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
         }
     }
     return slots;
@@ -2289,16 +2303,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2458,8 +2472,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            var hash = void 0;
+            var _loop_1 = function (key) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2476,14 +2490,15 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        on["update:" + key] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-
-            for (var key in value) loop( key );
+            for (var key in value) {
+                _loop_1(key);
+            }
         }
     }
     return data;
@@ -2503,7 +2518,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic(tree, "__static__" + index, false);
     return tree;
 }
 /**
@@ -2511,14 +2526,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], key + "_" + i, isOnce);
             }
         }
     }
@@ -2587,7 +2602,7 @@ function bindDynamicKeys(baseObj, values) {
             key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
         }
     }
     return baseObj;
@@ -2622,8 +2637,7 @@ function installRenderHelpers(target) {
 
 /* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
+    var _this = this;
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2650,14 +2664,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return _this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get: function () {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2671,7 +2685,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     }
     if (options._scopeId) {
         this._c = function (a, b, c, d) {
-            var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2680,7 +2694,9 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+        this._c = function (a, b, c, d) {
+            return createElement$1(contextVm, a, b, c, d, needNormalization);
+        };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2734,14 +2750,10 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+    init: function (vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2754,7 +2766,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
+    prepatch: function (oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2763,12 +2775,11 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
+            callHook$1(componentInstance, 'mounted');
         }
         if (vnode.data.keepAlive) {
             if (context._isMounted) {
@@ -2784,7 +2795,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2810,7 +2821,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         if (process.env.NODE_ENV !== 'production') {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn("Invalid Component definition: " + String(Ctor), context);
         }
         return;
     }
@@ -2868,7 +2879,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2899,11 +2910,11 @@ function installComponentHooks(data) {
         var toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
     }
 }
-function mergeHook$1(f1, f2) {
+function mergeHook(f1, f2) {
     var merged = function (a, b) {
         // flow complains about extra args which is why we use any
         f1(a, b);
@@ -2938,7 +2949,7 @@ var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
     if (Array.isArray(data) || isPrimitive(data)) {
         normalizationType = children;
         children = data;
@@ -2952,7 +2963,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+            warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2988,7 +2999,7 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        var Ctor = void 0;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
@@ -2996,7 +3007,7 @@ function _createElement(context, tag, data, children, normalizationType) {
                 isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3073,26 +3084,26 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
     var parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     if (process.env.NODE_ENV !== 'production') {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
             !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
         }, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
             !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
         }, true);
     }
     else {
-        defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
     }
 }
 var currentRenderingInstance = null;
@@ -3104,9 +3115,7 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3131,8 +3140,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e) {
-                    handleError(e, vm, "renderError");
+                catch (e$1) {
+                    handleError(e$1, vm, "renderError");
                     vnode = vm._vnode;
                 }
             }
@@ -3190,24 +3199,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
+        var owners_1 = (factory.owners = [owner]);
+        var sync_1 = true;
+        var timerLoading_1 = null;
+        var timerTimeout_1 = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+        var forceRender_1 = function (renderCompleted) {
+            for (var i = 0, l = owners_1.length; i < l; i++) {
+                owners_1[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
+                owners_1.length = 0;
+                if (timerLoading_1 !== null) {
+                    clearTimeout(timerLoading_1);
+                    timerLoading_1 = null;
                 }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
+                if (timerTimeout_1 !== null) {
+                    clearTimeout(timerTimeout_1);
+                    timerTimeout_1 = null;
                 }
             }
         };
@@ -3216,65 +3225,65 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
+            if (!sync_1) {
+                forceRender_1(true);
             }
             else {
-                owners.length = 0;
+                owners_1.length = 0;
             }
         });
-        var reject = once(function (reason) {
+        var reject_1 = once(function (reason) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+                warn("Failed to resolve async component: " + String(factory) +
+                    (reason ? "\nReason: " + reason : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender(true);
+                forceRender_1(true);
             }
         });
-        var res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
+        var res_1 = factory(resolve, reject_1);
+        if (isObject(res_1)) {
+            if (isPromise(res_1)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
+                    res_1.then(resolve, reject_1);
                 }
             }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
+            else if (isPromise(res_1.component)) {
+                res_1.component.then(resolve, reject_1);
+                if (isDef(res_1.error)) {
+                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
                 }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
+                if (isDef(res_1.loading)) {
+                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                    if (res_1.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
-                            timerLoading = null;
+                        timerLoading_1 = setTimeout(function () {
+                            timerLoading_1 = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender(false);
+                                forceRender_1(false);
                             }
-                        }, res.delay || 200);
+                        }, res_1.delay || 200);
                     }
                 }
-                if (isDef(res.timeout)) {
+                if (isDef(res_1.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
-                        timerTimeout = null;
+                    timerTimeout_1 = setTimeout(function () {
+                        timerTimeout_1 = null;
                         if (isUndef(factory.resolved)) {
-                            reject(process.env.NODE_ENV !== 'production'
-                                ? ("timeout (" + (res.timeout) + "ms)")
+                            reject_1(process.env.NODE_ENV !== 'production'
+                                ? "timeout (" + res_1.timeout + "ms)"
                                 : null);
                         }
-                    }, res.timeout);
+                    }, res_1.timeout);
                 }
             }
         }
-        sync = false;
+        sync_1 = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3298,8 +3307,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
-
 /* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
@@ -3310,15 +3317,15 @@ function initEvents(vm) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target;
-function add(event, fn) {
-    target.$on(event, fn);
+var target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
 }
 function remove$1(event, fn) {
-    target.$off(event, fn);
+    target$1.$off(event, fn);
 }
-function createOnceHandler(event, fn) {
-    var _target = target;
+function createOnceHandler$1(event, fn) {
+    var _target = target$1;
     return function onceHandler() {
         var res = fn.apply(null, arguments);
         if (res !== null) {
@@ -3327,9 +3334,9 @@ function createOnceHandler(event, fn) {
     };
 }
 function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
 }
 function eventsMixin(Vue) {
     var hookRE = /^hook:/;
@@ -3369,8 +3376,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                vm.$off(event[i_1], fn);
             }
             return vm;
         }
@@ -3401,10 +3408,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
             }
         }
         var cbs = vm._events[event];
@@ -3495,13 +3502,13 @@ function lifecycleMixin(Vue) {
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook(vm, 'beforeDestroy');
+        callHook$1(vm, 'beforeDestroy');
         vm._isBeingDestroyed = true;
         // remove self from parent
         var parent = vm.$parent;
         // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove(parent.$children, vm);
+            remove$2(parent.$children, vm);
         }
         // teardown watchers
         if (vm._watcher) {
@@ -3521,7 +3528,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook(vm, 'destroyed');
+        callHook$1(vm, 'destroyed');
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3554,7 +3561,7 @@ function mountComponent(vm, el, hydrating) {
             }
         }
     }
-    callHook(vm, 'beforeMount');
+    callHook$1(vm, 'beforeMount');
     var updateComponent;
     /* istanbul ignore if */
     if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
@@ -3566,11 +3573,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure("vue " + name + " render", startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure("vue " + name + " patch", startTag, endTag);
         };
     }
     else {
@@ -3582,9 +3589,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before: function () {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook(vm, 'beforeUpdate');
+                callHook$1(vm, 'beforeUpdate');
             }
         },
     }, true /* isRenderWatcher */);
@@ -3593,7 +3600,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook(vm, 'mounted');
+        callHook$1(vm, 'mounted');
     }
     return vm;
 }
@@ -3683,7 +3690,7 @@ function activateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'activated');
+        callHook$1(vm, 'activated');
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3698,10 +3705,10 @@ function deactivateChildComponent(vm, direct) {
         for (var i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook(vm, 'deactivated');
+        callHook$1(vm, 'deactivated');
     }
 }
-function callHook(vm, hook) {
+function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
     var handlers = vm.$options[hook];
@@ -3752,15 +3759,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = function () { return performance_1.now(); };
     }
 }
 /**
@@ -3795,7 +3802,7 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                        ? "in watcher with expression \"" + watcher.expression + "\""
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3820,7 +3827,7 @@ function callUpdatedHooks(queue) {
         var watcher = queue[i];
         var vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook(vm, 'updated');
+            callHook$1(vm, 'updated');
         }
     }
 }
@@ -3874,198 +3881,201 @@ function queueWatcher(watcher) {
 }
 
 /* @flow */
-var uid$2 = 0;
+var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$2; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            process.env.NODE_ENV !== 'production' &&
-                warn("Failed watching path: \"" + expOrFn + "\" " +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-        }
-    }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+var Watcher = /** @class */ (function () {
+    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
         }
         else {
-            throw e;
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression =
+            process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' &&
+                    warn("Failed watching path: \"" + expOrFn + "\" " +
+                        'Watcher only accepts simple dot-delimited paths. ' +
+                        'For full control, use a function instead.', vm);
+            }
         }
-        popTarget();
-        this.cleanupDeps();
+        this.value = this.lazy ? undefined : this.get();
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    Watcher.prototype.get = function () {
+        pushTarget(this);
+        var value;
+        var vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-    }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
-    }
-    else {
-        queueWatcher(this);
-    }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
+        catch (e) {
             if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                }
+                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
             }
             else {
-                this.cb.call(this.vm, value, oldValue);
+                throw e;
             }
         }
-    }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
-    }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove(this.vm._watchers, this);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
         }
+        return value;
+    };
+    /**
+     * Add a dependency to this directive.
+     */
+    Watcher.prototype.addDep = function (dep) {
+        var id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    };
+    /**
+     * Clean up for dependency collection.
+     */
+    Watcher.prototype.cleanupDeps = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            var dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        var tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    };
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    Watcher.prototype.update = function () {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
         }
-        this.active = false;
-    }
-};
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    };
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    Watcher.prototype.run = function () {
+        if (this.active) {
+            var value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                var oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    try {
+                        this.cb.call(this.vm, value, oldValue);
+                    }
+                    catch (e) {
+                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                    }
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    };
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    Watcher.prototype.evaluate = function () {
+        this.value = this.get();
+        this.dirty = false;
+    };
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    Watcher.prototype.depend = function () {
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    };
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    Watcher.prototype.teardown = function () {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            var i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    };
+    return Watcher;
+}());
 
 /* @flow */
 var sharedPropertyDefinition = {
@@ -4087,7 +4097,7 @@ function initState(vm) {
     vm._watchers = [];
     var opts = vm.$options;
     if (opts.props)
-        { initProps(vm, opts.props); }
+        { initProps$1(vm, opts.props); }
     if (opts.methods)
         { initMethods(vm, opts.methods); }
     if (opts.data) {
@@ -4097,12 +4107,12 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed(vm, opts.computed); }
+        { initComputed$1(vm, opts.computed); }
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
-function initProps(vm, propsOptions) {
+function initProps$1(vm, propsOptions) {
     var propsData = vm.$options.propsData || {};
     var props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
@@ -4113,7 +4123,7 @@ function initProps(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    var _loop_1 = function (key) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4121,19 +4131,19 @@ function initProps(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
             }
-            defineReactive$$1(props, key, value, function () {
+            defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
                     warn("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                        ("value. Prop being mutated: \"" + key + "\""), vm);
                 }
             });
         }
         else {
-            defineReactive$$1(props, key, value);
+            defineReactive(props, key, value);
         }
         // static props are already proxied on the component's prototype
         // during Vue.extend(). We only need to proxy props defined at
@@ -4142,8 +4152,9 @@ function initProps(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-
-    for (var key in propsOptions) loop( key );
+    for (var key in propsOptions) {
+        _loop_1(key);
+    }
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4164,7 +4175,7 @@ function initData(vm) {
         var key = keys[i];
         if (process.env.NODE_ENV !== 'production') {
             if (methods && hasOwn(methods, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn("Method \"" + key + "\" has already been defined as a data property.", vm);
             }
         }
         if (props && hasOwn(props, key)) {
@@ -4194,7 +4205,7 @@ function getData(data, vm) {
     }
 }
 var computedWatcherOptions = { lazy: true };
-function initComputed(vm, computed) {
+function initComputed$1(vm, computed) {
     // $flow-disable-line
     var watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
@@ -4203,7 +4214,7 @@ function initComputed(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+            warn("Getter is missing for computed property \"" + key + "\".", vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4217,10 +4228,10 @@ function initComputed(vm, computed) {
         }
         else if (process.env.NODE_ENV !== 'production') {
             if (key in vm.$data) {
-                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn("The computed property \"" + key + "\" is already defined in data.", vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
             }
         }
     }
@@ -4244,7 +4255,7 @@ function defineComputed(target, key, userDef) {
     if (process.env.NODE_ENV !== 'production' &&
         sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4273,11 +4284,11 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         if (process.env.NODE_ENV !== 'production') {
             if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn("Method \"" + key + "\" has already been defined as a prop.", vm);
             }
             if (key in vm && isReserved(key)) {
                 warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4349,7 +4360,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
             }
             popTarget();
         }
@@ -4360,17 +4371,17 @@ function stateMixin(Vue) {
 }
 
 /* @flow */
-var uid$3 = 0;
-function initMixin(Vue) {
+var uid = 0;
+function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
         var vm = this;
         // a uid
-        vm._uid = uid$3++;
+        vm._uid = uid++;
         var startTag, endTag;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = "vue-perf-start:" + vm._uid;
+            endTag = "vue-perf-end:" + vm._uid;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4397,16 +4408,16 @@ function initMixin(Vue) {
         initLifecycle(vm);
         initEvents(vm);
         initRender(vm);
-        callHook(vm, 'beforeCreate');
+        callHook$1(vm, 'beforeCreate');
         initInjections(vm); // resolve injections before data/props
         initState(vm);
         initProvide(vm); // resolve provide after data/props
-        callHook(vm, 'created');
+        callHook$1(vm, 'created');
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure("vue " + vm._name + " init", startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4474,7 +4485,7 @@ function Vue(options) {
     this._init(options);
 }
 //@ts-ignore
-initMixin(Vue);
+initMixin$1(Vue);
 //@ts-ignore
 stateMixin(Vue);
 //@ts-ignore
@@ -4506,7 +4517,7 @@ function initUse(Vue) {
 }
 
 /* @flow */
-function initMixin$1(Vue) {
+function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
         return this;
@@ -4549,10 +4560,10 @@ function initExtend(Vue) {
         // the Vue instances at extension time, on the extended prototype. This
         // avoids Object.defineProperty calls for each instance created.
         if (Sub.options.props) {
-            initProps$1(Sub);
+            initProps(Sub);
         }
         if (Sub.options.computed) {
-            initComputed$1(Sub);
+            initComputed(Sub);
         }
         // allow further extension/mixin/plugin usage
         Sub.extend = Super.extend;
@@ -4578,13 +4589,13 @@ function initExtend(Vue) {
         return Sub;
     };
 }
-function initProps$1(Comp) {
+function initProps(Comp) {
     var props = Comp.options.props;
     for (var key in props) {
         proxy(Comp.prototype, "_props", key);
     }
 }
-function initComputed$1(Comp) {
+function initComputed(Comp) {
     var computed = Comp.options.computed;
     for (var key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
@@ -4640,26 +4651,24 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
-            if (name && !filter(name)) {
+            var name_1 = getComponentName(cachedNode.componentOptions);
+            if (name_1 && !filter(name_1)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached$$1 = cache[key];
-    if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-        cached$$1.componentInstance.$destroy();
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+        cached.componentInstance.$destroy();
     }
     cache[key] = null;
-    remove(keys, key);
+    remove$2(keys, key);
 }
 var patternTypes = [String, RegExp, Array];
 // TODO use defineComponent
@@ -4671,55 +4680,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    created: function () {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
+    destroyed: function () {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
+    mounted: function () {
+        var _this = this;
         this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+            pruneCache(_this, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+            pruneCache(_this, function (name) { return !matches(val, name); });
         });
     },
-    render: function render() {
+    render: function () {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            var name_2 = getComponentName(componentOptions);
+            var _a = this, include = _a.include, exclude = _a.exclude;
             if (
             // not included
-            (include && (!name || !matches(include, name))) ||
+            (include && (!name_2 || !matches(include, name_2))) ||
                 // excluded
-                (exclude && name && matches(exclude, name))) {
+                (exclude && name_2 && matches(exclude, name_2))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
+            var _b = this, cache = _b.cache, keys = _b.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? "::" + componentOptions.tag : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
                 // make current key freshest
-                remove(keys, key);
+                remove$2(keys, key);
                 keys.push(key);
             }
             else {
@@ -4758,7 +4762,7 @@ function initGlobalAPI(Vue) {
         warn: warn,
         extend: extend,
         mergeOptions: mergeOptions,
-        defineReactive: defineReactive$$1,
+        defineReactive: defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
@@ -4777,7 +4781,7 @@ function initGlobalAPI(Vue) {
     Vue.options._base = Vue;
     extend(Vue.options.components, builtInComponents);
     initUse(Vue);
-    initMixin$1(Vue);
+    initMixin(Vue);
     initExtend(Vue);
     initAssetRegisters(Vue);
 }
@@ -4787,7 +4791,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get: function () {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4989,7 +4993,7 @@ function query(el) {
 }
 
 /* @flow */
-function createElement$1(tagName, vnode) {
+function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
@@ -5037,7 +5041,8 @@ function setStyleScope(node, scopeId) {
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
-  createElement: createElement$1,
+  __proto__: null,
+  createElement: createElement,
   createElementNS: createElementNS,
   createTextNode: createTextNode,
   createComment: createComment,
@@ -5053,16 +5058,16 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 
 /* @flow */
 var ref = {
-    create: function create(_, vnode) {
+    create: function (_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update: function (oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5076,7 +5081,7 @@ function registerRef(vnode, isRemoval) {
     if (isRemoval) {
         if (Array.isArray(refs[key])) {
             // @ts-expect-error invalid typings
-            remove(refs[key], ref);
+            remove$2(refs[key], ref);
         }
         else if (refs[key] === ref) {
             refs[key] = undefined;
@@ -5144,8 +5149,7 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    var modules = backend.modules, nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5158,13 +5162,13 @@ function createPatchFunction(backend) {
         return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
     function createRmCb(childElm, listeners) {
-        function remove$$1() {
-            if (--remove$$1.listeners === 0) {
+        function remove() {
+            if (--remove.listeners === 0) {
                 removeNode(childElm);
             }
         }
-        remove$$1.listeners = listeners;
-        return remove$$1;
+        remove.listeners = listeners;
+        return remove;
     }
     function removeNode(el) {
         var parent = nodeOps.parentNode(el);
@@ -5173,7 +5177,7 @@ function createPatchFunction(backend) {
             nodeOps.removeChild(parent, el);
         }
     }
-    function isUnknownElement$$1(vnode, inVPre) {
+    function isUnknownElement(vnode, inVPre) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
@@ -5206,7 +5210,7 @@ function createPatchFunction(backend) {
                 if (data && data.pre) {
                     creatingElmInVPre++;
                 }
-                if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
                     warn('Unknown custom element: <' +
                         tag +
                         '> - did you ' +
@@ -5299,11 +5303,11 @@ function createPatchFunction(backend) {
         // a reactivated keep-alive component doesn't insert itself
         insert(parentElm, vnode.elm, refElm);
     }
-    function insert(parent, elm, ref$$1) {
+    function insert(parent, elm, ref) {
         if (isDef(parent)) {
-            if (isDef(ref$$1)) {
-                if (nodeOps.parentNode(ref$$1) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref$$1);
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
                 }
             }
             else {
@@ -5316,8 +5320,8 @@ function createPatchFunction(backend) {
             if (process.env.NODE_ENV !== 'production') {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5331,8 +5335,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+            cbs.create[i_2](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5404,7 +5408,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
+            var i_3;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5416,16 +5420,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
+            if (isDef((i_3 = vnode.componentInstance)) &&
+                isDef((i_3 = i_3._vnode)) &&
+                isDef(i_3.data)) {
+                removeAndInvokeRemoveHook(i_3, rm);
             }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
+            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                cbs.remove[i_3](vnode, rm);
             }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
+            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                i_3(vnode, rm);
             }
             else {
                 rm();
@@ -5521,12 +5525,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
+        for (var i_4 = 0; i_4 < children.length; i_4++) {
+            var vnode = children[i_4];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5535,10 +5539,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (var i_5 = start; i_5 < end; i_5++) {
+            var c = oldCh[i_5];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                { return i_5; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5618,8 +5622,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
+            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                queue[i_6].data.hook.insert(queue[i_6]);
             }
         }
     }
@@ -5632,9 +5636,7 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        var tag = vnode.tag, data = vnode.data, children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5684,9 +5686,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        for (var i_7 = 0; i_7 < children.length; i_7++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5731,7 +5733,7 @@ function createPatchFunction(backend) {
     function assertNodeMatch(node, vnode, inVPre) {
         if (isDef(vnode.tag)) {
             return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement$$1(vnode, inVPre) &&
+                (!isUnknownElement(vnode, inVPre) &&
                     vnode.tag.toLowerCase() ===
                         (node.tagName && node.tagName.toLowerCase())));
         }
@@ -5798,22 +5800,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
+                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                            cbs.destroy[i_8](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                cbs.create[i_9](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
+                            var insert_1 = ancestor.data.hook.insert;
+                            if (insert_1.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                    insert_1.fns[i_10]();
                                 }
                             }
                         }
@@ -5854,8 +5856,8 @@ function updateDirectives(oldVnode, vnode) {
 function _update(oldVnode, vnode) {
     var isCreate = oldVnode === emptyNode;
     var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
     var dirsWithInsert = [];
     var dirsWithPostpatch = [];
     var key, oldDir, dir;
@@ -5864,7 +5866,7 @@ function _update(oldVnode, vnode) {
         dir = newDirs[key];
         if (!oldDir) {
             // new directive, bind
-            callHook$1(dir, 'bind', vnode, oldVnode);
+            callHook(dir, 'bind', vnode, oldVnode);
             if (dir.def && dir.def.inserted) {
                 dirsWithInsert.push(dir);
             }
@@ -5873,7 +5875,7 @@ function _update(oldVnode, vnode) {
             // existing directive, update
             dir.oldValue = oldDir.value;
             dir.oldArg = oldDir.arg;
-            callHook$1(dir, 'update', vnode, oldVnode);
+            callHook(dir, 'update', vnode, oldVnode);
             if (dir.def && dir.def.componentUpdated) {
                 dirsWithPostpatch.push(dir);
             }
@@ -5882,7 +5884,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithInsert.length) {
         var callInsert = function () {
             for (var i = 0; i < dirsWithInsert.length; i++) {
-                callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
         if (isCreate) {
@@ -5895,7 +5897,7 @@ function _update(oldVnode, vnode) {
     if (dirsWithPostpatch.length) {
         mergeVNodeHook(vnode, 'postpatch', function () {
             for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
     }
@@ -5903,13 +5905,13 @@ function _update(oldVnode, vnode) {
         for (key in oldDirs) {
             if (!newDirs[key]) {
                 // no longer present, unbind
-                callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
             }
         }
     }
 }
 var emptyModifiers = Object.create(null);
-function normalizeDirectives$1(dirs, vm) {
+function normalizeDirectives(dirs, vm) {
     var res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
@@ -5929,16 +5931,16 @@ function normalizeDirectives$1(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
 }
-function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
         }
     }
 }
@@ -6033,11 +6035,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            var blocker_1 = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
+                el.removeEventListener('input', blocker_1);
             };
-            el.addEventListener('input', blocker);
+            el.addEventListener('input', blocker_1);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6077,12 +6079,6 @@ var klass = {
     update: updateClass,
 };
 
-/* @flow */
-
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -6098,8 +6094,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        var event_1 = isIE ? 'change' : 'input';
+        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6110,13 +6106,13 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target$1;
-function createOnceHandler$1(event, handler, capture) {
-    var _target = target$1; // save current target element in closure
+var target;
+function createOnceHandler(event, handler, capture) {
+    var _target = target; // save current target element in closure
     return function onceHandler() {
         var res = handler.apply(null, arguments);
         if (res !== null) {
-            remove$2(event, onceHandler, capture, _target);
+            remove(event, onceHandler, capture, _target);
         }
     };
 }
@@ -6124,7 +6120,7 @@ function createOnceHandler$1(event, handler, capture) {
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
 var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add$1(name, handler, capture, passive) {
+function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
     // happens because browsers fire microtask ticks between event propagation.
@@ -6132,17 +6128,17 @@ function add$1(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
+        var attachedTimestamp_1 = currentFlushTimestamp;
+        var original_1 = handler;
         //@ts-expect-error
-        handler = original._wrapper = function (e) {
+        handler = original_1._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
+                e.timeStamp >= attachedTimestamp_1 ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6151,14 +6147,14 @@ function add$1(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
+                return original_1.apply(this, arguments);
             }
         };
     }
-    target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
 }
-function remove$2(name, handler, capture, _target) {
-    (_target || target$1).removeEventListener(name, 
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
     //@ts-expect-error
     handler._wrapper || handler, capture);
 }
@@ -6168,10 +6164,10 @@ function updateDOMListeners(oldVnode, vnode) {
     }
     var on = vnode.data.on || {};
     var oldOn = oldVnode.data.on || {};
-    target$1 = vnode.elm;
+    target = vnode.elm;
     normalizeEvents(on);
-    updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-    target$1 = undefined;
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
 }
 var events = {
     create: updateDOMListeners,
@@ -6386,9 +6382,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
+        var name_1 = vendorNames[i] + capName;
+        if (name_1 in emptyStyle) {
+            return name_1;
         }
     }
 });
@@ -6495,31 +6491,31 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def$$1) {
-    if (!def$$1) {
+function resolveTransition(def) {
+    if (!def) {
         return;
     }
     /* istanbul ignore else */
-    if (typeof def$$1 === 'object') {
+    if (typeof def === 'object') {
         var res = {};
-        if (def$$1.css !== false) {
-            extend(res, autoCssTransition(def$$1.name || 'v'));
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
         }
-        extend(res, def$$1);
+        extend(res, def);
         return res;
     }
-    else if (typeof def$$1 === 'string') {
-        return autoCssTransition(def$$1);
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
     }
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -6566,15 +6562,12 @@ function addTransitionClass(el, cls) {
 }
 function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
-        remove(el._transitionClasses, cls);
+        remove$2(el._transitionClasses, cls);
     }
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -6680,23 +6673,7 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -6804,17 +6781,7 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -6888,7 +6855,7 @@ function leave(vnode, rm) {
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+            ("got " + JSON.stringify(val) + "."), vnode.context);
     }
     else if (isNaN(val)) {
         warn("<transition> explicit " + name + " duration is NaN - " +
@@ -6928,7 +6895,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove$$1(vnode, rm) {
+        remove: function (vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -6965,7 +6932,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+    inserted: function (el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -6995,22 +6962,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated: function (el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            var prevOptions_1 = el._vOptions;
+            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
+                        hasNoMatchingOption(binding.value, curOptions_1);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7032,8 +6999,8 @@ function actuallySetSelected(el, binding, vm) {
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+            warn("<select multiple v-model=\"" + binding.expression + "\"> " +
+                ("expects an Array value for its binding, but got " + Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7091,14 +7058,13 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
+        var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition$$1) {
+        if (value && transition) {
             vnode.data.show = true;
             enter(vnode, function () {
                 el.style.display = originalDisplay;
@@ -7108,16 +7074,14 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
         vnode = locateNode(vnode);
-        var transition$$1 = vnode.data && vnode.data.transition;
-        if (transition$$1) {
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
             vnode.data.show = true;
             if (value) {
                 enter(vnode, function () {
@@ -7134,7 +7098,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7185,8 +7149,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    for (var key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7214,9 +7178,8 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
+    render: function (h) {
+        var _this = this;
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -7259,7 +7222,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        var id = "__transition-" + this._uid + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7293,8 +7256,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                    _this._leaving = false;
+                    _this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7302,14 +7265,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
+                var delayedLeave_1;
                 var performLeave = function () {
-                    delayedLeave();
+                    delayedLeave_1();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave = leave;
+                    delayedLeave_1 = leave;
                 });
             }
         }
@@ -7326,22 +7289,21 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
+    beforeMount: function () {
+        var _this = this;
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+            var restoreActiveInstance = setActiveInstance(_this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            _this._vnode = _this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(_this, vnode, hydrating);
         };
     },
-    render: function render(h) {
+    render: function (h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -7358,27 +7320,27 @@ var TransitionGroup = {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     var opts = c.componentOptions;
-                    var name = opts
+                    var name_1 = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn("<transition-group> children must be keyed: <" + name_1 + ">");
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
+            for (var i = 0; i < prevChildren.length; i++) {
+                var c = prevChildren[i];
+                c.data.transition = transitionData;
                 // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
+                c.data.pos = c.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7386,7 +7348,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
+    updated: function () {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7404,25 +7366,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
-                addTransitionClass(el, moveClass);
+                var el_1 = c.elm;
+                var s = el_1.style;
+                addTransitionClass(el_1, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
+                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                    if (e && e.target !== el_1) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
+                        el_1.removeEventListener(transitionEndEvent, cb);
+                        el_1._moveCb = null;
+                        removeTransitionClass(el_1, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove: function (el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 6ac78dd7298..050daa627f1 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -6,8 +6,8 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
-  (global = global || self, global.Vue = factory());
-}(this, function () { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
+}(this, (function () { 'use strict';
 
   /* @flow */
   var emptyObject = Object.freeze({});
@@ -113,7 +113,7 @@
   /**
    * Remove an item from an array.
    */
-  function remove(arr, item) {
+  function remove$2(arr, item) {
       if (arr.length) {
           var index = arr.indexOf(item);
           if (index > -1) {
@@ -427,7 +427,7 @@
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+  var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
   function parsePath(path) {
       if (bailRE.test(path)) {
           return;
@@ -458,10 +458,10 @@
   var isIE = UA && /msie|trident/.test(UA);
   var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
   var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-  var isPhantomJS = UA && /phantomjs/.test(UA);
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
   // @ts-ignore
@@ -471,7 +471,7 @@
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function get() {
+              get: function () {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
@@ -517,20 +517,19 @@
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
+      _Set = /** @class */ (function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function has (key) {
+          Set.prototype.has = function (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function add (key) {
+          Set.prototype.add = function (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function clear () {
+          Set.prototype.clear = function () {
               this.set = Object.create(null);
           };
-
           return Set;
       }());
   }
@@ -541,20 +540,22 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+      var hasConsole_1 = typeof console !== 'undefined';
+      var classifyRE_1 = /(?:^|[-_])(\w)/g;
+      var classify_1 = function (str) {
+          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+      };
       warn = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
           if (config.warnHandler) {
               config.warnHandler.call(null, msg, vm, trace);
           }
-          else if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
+          else if (hasConsole_1 && !config.silent) {
+              console.error("[Vue warn]: " + msg + trace);
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole && !config.silent) {
+          if (hasConsole_1 && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -577,10 +578,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
+          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+              (file && includeFile !== false ? " at " + file : ''));
       };
-      var repeat = function (str, n) {
+      var repeat_1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -614,50 +615,55 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
+                      .map(function (vm, i) {
+                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                          : formatComponentName(vm));
+                  })
                       .join('\n'));
           }
           else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+              return "\n\n(found in " + formatComponentName(vm) + ")";
           }
       };
   }
 
-  var uid = 0;
+  var uid$2 = 0;
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep() {
-      this.id = uid++;
-      this.subs = [];
-  };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
-  };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove(this.subs, sub);
-  };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
+  var Dep = /** @class */ (function () {
+      function Dep() {
+          this.id = uid$2++;
+          this.subs = [];
       }
-  };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      if (!config.async) {
-          // subs aren't sorted in scheduler if not running async
-          // we need to sort them now to make sure they fire in correct
-          // order
-          subs.sort(function (a, b) { return a.id - b.id; });
-      }
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
-      }
-  };
+      Dep.prototype.addSub = function (sub) {
+          this.subs.push(sub);
+      };
+      Dep.prototype.removeSub = function (sub) {
+          remove$2(this.subs, sub);
+      };
+      Dep.prototype.depend = function () {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      };
+      Dep.prototype.notify = function () {
+          // stabilize the subscriber list first
+          var subs = this.subs.slice();
+          if (!config.async) {
+              // subs aren't sorted in scheduler if not running async
+              // we need to sort them now to make sure they fire in correct
+              // order
+              subs.sort(function (a, b) { return a.id - b.id; });
+          }
+          for (var i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      };
+      return Dep;
+  }());
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
@@ -672,43 +678,45 @@
       Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-      return this.componentInstance;
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
+  var VNode = /** @class */ (function () {
+      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      Object.defineProperty(VNode.prototype, "child", {
+          // DEPRECATED: alias for componentInstance for backwards compat.
+          /* istanbul ignore next */
+          get: function () {
+              return this.componentInstance;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return VNode;
+  }());
   var createEmptyVNode = function (text) {
-      if ( text === void 0 ) text = '';
-
+      if (text === void 0) { text = ''; }
       var node = new VNode();
       node.text = text;
       node.isComment = true;
@@ -762,9 +770,12 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
+          var arguments$1 = arguments;
 
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments$1[_i];
+          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -800,43 +811,46 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
+  var Observer = /** @class */ (function () {
+      function Observer(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
           }
           else {
-              copyAugment(value, arrayMethods, arrayKeys);
+              this.walk(value);
           }
-          this.observeArray(value);
-      }
-      else {
-          this.walk(value);
-      }
-  };
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive$$1(obj, keys[i]);
       }
-  };
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
-      }
-  };
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      Observer.prototype.walk = function (obj) {
+          var keys = Object.keys(obj);
+          for (var i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      };
+      /**
+       * Observe a list of Array items.
+       */
+      Observer.prototype.observeArray = function (items) {
+          for (var i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      };
+      return Observer;
+  }());
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -886,7 +900,7 @@
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+  function defineReactive(obj, key, val, customSetter, shallow) {
       var dep = new Dep();
       var property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
@@ -945,8 +959,8 @@
    * already exist.
    */
   function set(target, key, val) {
-      if (isUndef(target) || isPrimitive(target)) {
-          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -968,7 +982,7 @@
           target[key] = val;
           return val;
       }
-      defineReactive$$1(ob.value, key, val);
+      defineReactive(ob.value, key, val);
       ob.dep.notify();
       return val;
   }
@@ -976,8 +990,8 @@
    * Delete a property and trigger change if necessary.
    */
   function del(target, key) {
-      if (isUndef(target) || isPrimitive(target)) {
-          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.splice(key, 1);
@@ -1004,7 +1018,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1114,7 +1128,7 @@
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook(parentVal, childVal) {
+  function mergeHook$1(parentVal, childVal) {
       var res = childVal
           ? parentVal
               ? parentVal.concat(childVal)
@@ -1134,7 +1148,7 @@
       return res;
   }
   LIFECYCLE_HOOKS.forEach(function (hook) {
-      strats[hook] = mergeHook;
+      strats[hook] = mergeHook$1;
   });
   /**
    * Assets
@@ -1180,14 +1194,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key$1] = parent
-              ? parent.concat(child)
+      for (var key_1 in childVal) {
+          var parent_1 = ret[key_1];
+          var child = childVal[key_1];
+          if (parent_1 && !Array.isArray(parent_1)) {
+              parent_1 = [parent_1];
+          }
+          ret[key_1] = parent_1
+              ? parent_1.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1225,7 +1239,7 @@
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+      if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
           warn('Invalid component name: "' +
               name +
               '". Component names ' +
@@ -1269,7 +1283,7 @@
       }
       else {
           warn("Invalid value for option \"props\": expected an Array or an Object, " +
-              "but got " + (toRawType(props)) + ".", vm);
+              ("but got " + toRawType(props) + "."), vm);
       }
       options.props = res;
   }
@@ -1296,19 +1310,19 @@
       }
       else {
           warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-              "but got " + (toRawType(inject)) + ".", vm);
+              ("but got " + toRawType(inject) + "."), vm);
       }
   }
   /**
    * Normalize raw function directives into object format.
    */
-  function normalizeDirectives(options) {
+  function normalizeDirectives$1(options) {
       var dirs = options.directives;
       if (dirs) {
           for (var key in dirs) {
-              var def$$1 = dirs[key];
-              if (typeof def$$1 === 'function') {
-                  dirs[key] = { bind: def$$1, update: def$$1 };
+              var def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
               }
           }
       }
@@ -1316,7 +1330,7 @@
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
           warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
+              ("but got " + toRawType(value) + "."), vm);
       }
   }
   /**
@@ -1333,7 +1347,7 @@
       }
       normalizeProps(child, vm);
       normalizeInject(child, vm);
-      normalizeDirectives(child);
+      normalizeDirectives$1(child);
       // Apply extends and mixins on the child options,
       // but only if it is a raw options object that isn't
       // the result of another mergeOptions call.
@@ -1553,7 +1567,7 @@
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
       var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          " Expected " + (expectedTypes.map(capitalize).join(', '));
+          (" Expected " + expectedTypes.map(capitalize).join(', '));
       var expectedType = expectedTypes[0];
       var receivedType = toRawType(value);
       // check if we need to specify expected value
@@ -1561,24 +1575,24 @@
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + (styleValue(value, expectedType));
+          message += " with value " + styleValue(value, expectedType);
       }
       message += ", got " + receivedType + " ";
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + (styleValue(value, receivedType)) + ".";
+          message += "with value " + styleValue(value, receivedType) + ".";
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return ("\"" + value + "\"");
+          return "\"" + value + "\"";
       }
       else if (type === 'Number') {
-          return ("" + (Number(value)));
+          return "" + Number(value);
       }
       else {
-          return ("" + value);
+          return "" + value;
       }
   }
   var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1586,9 +1600,12 @@
       return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
+      var arguments$1 = arguments;
 
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments$1[_i];
+      }
       return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
@@ -1654,7 +1671,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+          warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1697,9 +1714,9 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p = Promise.resolve();
+      var p_1 = Promise.resolve();
       timerFunc = function () {
-          p.then(flushCallbacks);
+          p_1.then(flushCallbacks);
           // In problematic UIWebViews, Promise.then doesn't completely break, but
           // it can get stuck in a weird state where callbacks are pushed into the
           // microtask queue but the queue isn't being flushed, until the browser
@@ -1718,15 +1735,15 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
+      var counter_1 = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
+      var textNode_1 = document.createTextNode(String(counter_1));
+      observer.observe(textNode_1, {
           characterData: true,
       });
       timerFunc = function () {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
+          counter_1 = (counter_1 + 1) % 2;
+          textNode_1.data = String(counter_1);
       };
       isUsingMicroTask = true;
   }
@@ -1771,36 +1788,34 @@
       }
   }
 
-  /* @flow */
-
   /* not type checking this file because flow doesn't play well with Proxy */
   var initProxy;
   {
-      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var warnNonPresent = function (target, key) {
+      var warnNonPresent_1 = function (target, key) {
           warn("Property or method \"" + key + "\" is not defined on the instance but " +
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
               'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
-      var warnReservedPrefix = function (target, key) {
+      var warnReservedPrefix_1 = function (target, key) {
           warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
               'See: https://vuejs.org/v2/api/#data', target);
       };
-      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+      var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy_1) {
+          var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+              set: function (target, key, value) {
+                  if (isBuiltInModifier_1(key)) {
+                      warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                       return false;
                   }
                   else {
@@ -1810,38 +1825,38 @@
               },
           });
       }
-      var hasHandler = {
-          has: function has(target, key) {
+      var hasHandler_1 = {
+          has: function (target, key) {
               var has = key in target;
-              var isAllowed = allowedGlobals(key) ||
+              var isAllowed = allowedGlobals_1(key) ||
                   (typeof key === 'string' &&
                       key.charAt(0) === '_' &&
                       !(key in target.$data));
               if (!has && !isAllowed) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      { warnReservedPrefix_1(target, key); }
                   else
-                      { warnNonPresent(target, key); }
+                      { warnNonPresent_1(target, key); }
               }
               return has || !isAllowed;
           },
       };
-      var getHandler = {
-          get: function get(target, key) {
+      var getHandler_1 = {
+          get: function (target, key) {
               if (typeof key === 'string' && !(key in target)) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      { warnReservedPrefix_1(target, key); }
                   else
-                      { warnNonPresent(target, key); }
+                      { warnNonPresent_1(target, key); }
               }
               return target[key];
           },
       };
       initProxy = function initProxy(vm) {
-          if (hasProxy) {
+          if (hasProxy_1) {
               // determine which proxy handler to use
               var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
               vm._renderProxy = new Proxy(vm, handlers);
           }
           else {
@@ -1892,18 +1907,18 @@
   var mark;
   var measure;
   {
-      var perf = inBrowser && window.performance;
+      var perf_1 = inBrowser && window.performance;
       /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = function (tag) { return perf.mark(tag); };
+      if (perf_1 &&
+          perf_1.mark &&
+          perf_1.measure &&
+          perf_1.clearMarks &&
+          perf_1.clearMeasures) {
+          mark = function (tag) { return perf_1.mark(tag); };
           measure = function (name, startTag, endTag) {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
+              perf_1.measure(name, startTag, endTag);
+              perf_1.clearMarks(startTag);
+              perf_1.clearMarks(endTag);
               // perf.clearMeasures(name)
           };
       }
@@ -1912,13 +1927,13 @@
   var normalizeEvent = cached(function (name) {
       var passive = name.charAt(0) === '&';
       name = passive ? name.slice(1) : name;
-      var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once$$1 ? name.slice(1) : name;
+      var once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
       var capture = name.charAt(0) === '!';
       name = capture ? name.slice(1) : name;
       return {
           name: name,
-          once: once$$1,
+          once: once,
           capture: capture,
           passive: passive,
       };
@@ -1942,14 +1957,14 @@
       invoker.fns = fns;
       return invoker;
   }
-  function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-      var name, def$$1, cur, old, event;
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      var name, cur, old, event;
       for (name in on) {
-          def$$1 = cur = on[name];
+          cur = on[name];
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+              warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -1968,7 +1983,7 @@
       for (name in oldOn) {
           if (isUndef(on[name])) {
               event = normalizeEvent(name);
-              remove$$1(event.name, oldOn[name], event.capture);
+              remove(event.name, oldOn[name], event.capture);
           }
       }
   }
@@ -1984,7 +1999,7 @@
           hook.apply(this, arguments);
           // important: remove merged hook to ensure it's called only once
           // and prevent memory leak
-          remove(invoker.fns, wrappedHook);
+          remove$2(invoker.fns, wrappedHook);
       }
       if (isUndef(oldHook)) {
           // no existing hook
@@ -2016,8 +2031,7 @@
           return;
       }
       var res = {};
-      var attrs = data.attrs;
-      var props = data.props;
+      var attrs = data.attrs, props = data.props;
       if (isDef(attrs) || isDef(props)) {
           for (var key in propOptions) {
               var altKey = hyphenate(key);
@@ -2027,11 +2041,11 @@
                       tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                           (formatComponentName(
                           // @ts-ignore
-                          tag || Ctor)) + ", but the declared prop name is" +
-                          " \"" + key + "\". " +
+                          tag || Ctor) + ", but the declared prop name is") +
+                          (" \"" + key + "\". ") +
                           "Note that HTML attributes are case-insensitive and camelCased " +
                           "props need to use their kebab-case equivalents when using in-DOM " +
-                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                          ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -2106,7 +2120,7 @@
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2165,10 +2179,10 @@
           Object.keys(result).forEach(function (key) {
               /* istanbul ignore else */
               {
-                  defineReactive$$1(vm, key, result[key], function () {
+                  defineReactive(vm, key, result[key], function () {
                       warn("Avoid mutating an injected value directly since the changes will be " +
                           "overwritten whenever the provided component re-renders. " +
-                          "injection being mutated: \"" + key + "\"", vm);
+                          ("injection being mutated: \"" + key + "\""), vm);
                   });
               }
           });
@@ -2205,7 +2219,7 @@
                   }
                   else {
                       // @ts-ignore
-                      warn(("Injection \"" + key + "\" not found"), vm);
+                      warn("Injection \"" + key + "\" not found", vm);
                   }
               }
           }
@@ -2234,8 +2248,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name = data.slot;
-              var slot = slots[name] || (slots[name] = []);
+              var name_1 = data.slot;
+              var slot = slots[name_1] || (slots[name_1] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -2248,9 +2262,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name$1 in slots) {
-          if (slots[name$1].every(isWhitespace)) {
-              delete slots[name$1];
+      for (var name_2 in slots) {
+          if (slots[name_2].every(isWhitespace)) {
+              delete slots[name_2];
           }
       }
       return slots;
@@ -2284,16 +2298,16 @@
       }
       else {
           res = {};
-          for (var key$1 in slots) {
-              if (slots[key$1] && key$1[0] !== '$') {
-                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+          for (var key_1 in slots) {
+              if (slots[key_1] && key_1[0] !== '$') {
+                  res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key$2 in normalSlots) {
-          if (!(key$2 in res)) {
-              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+      for (var key_2 in normalSlots) {
+          if (!(key_2 in res)) {
+              res[key_2] = proxyNormalSlot(normalSlots, key_2);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2452,8 +2466,8 @@
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash;
-              var loop = function ( key ) {
+              var hash = void 0;
+              var _loop_1 = function (key) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
@@ -2470,14 +2484,15 @@
                       hash[key] = value[key];
                       if (isSync) {
                           var on = data.on || (data.on = {});
-                          on[("update:" + key)] = function ($event) {
+                          on["update:" + key] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
               };
-
-              for (var key in value) loop( key );
+              for (var key in value) {
+                  _loop_1(key);
+              }
           }
       }
       return data;
@@ -2497,7 +2512,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic(tree, ("__static__" + index), false);
+      markStatic(tree, "__static__" + index, false);
       return tree;
   }
   /**
@@ -2505,14 +2520,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
       return tree;
   }
   function markStatic(tree, key, isOnce) {
       if (Array.isArray(tree)) {
           for (var i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+                  markStaticNode(tree[i], key + "_" + i, isOnce);
               }
           }
       }
@@ -2579,7 +2594,7 @@
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+              warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
           }
       }
       return baseObj;
@@ -2614,8 +2629,7 @@
 
   /* @flow */
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var this$1 = this;
-
+      var _this = this;
       var options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
@@ -2642,14 +2656,14 @@
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
       this.slots = function () {
-          if (!this$1.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          if (!_this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
           }
-          return this$1.$slots;
+          return _this.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function get() {
+          get: function () {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -2663,7 +2677,7 @@
       }
       if (options._scopeId) {
           this._c = function (a, b, c, d) {
-              var vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
               if (vnode && !Array.isArray(vnode)) {
                   vnode.fnScopeId = options._scopeId;
                   vnode.fnContext = parent;
@@ -2672,7 +2686,9 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+          this._c = function (a, b, c, d) {
+              return createElement$1(contextVm, a, b, c, d, needNormalization);
+          };
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2726,14 +2742,10 @@
       }
   }
 
-  /* @flow */
-
-  /* @flow */
-
   /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function init(vnode, hydrating) {
+      init: function (vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
@@ -2746,7 +2758,7 @@
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function prepatch(oldVnode, vnode) {
+      prepatch: function (oldVnode, vnode) {
           var options = vnode.componentOptions;
           var child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
@@ -2755,12 +2767,11 @@
           options.children // new children
           );
       },
-      insert: function insert(vnode) {
-          var context = vnode.context;
-          var componentInstance = vnode.componentInstance;
+      insert: function (vnode) {
+          var context = vnode.context, componentInstance = vnode.componentInstance;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
-              callHook(componentInstance, 'mounted');
+              callHook$1(componentInstance, 'mounted');
           }
           if (vnode.data.keepAlive) {
               if (context._isMounted) {
@@ -2776,7 +2787,7 @@
               }
           }
       },
-      destroy: function destroy(vnode) {
+      destroy: function (vnode) {
           var componentInstance = vnode.componentInstance;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
@@ -2802,7 +2813,7 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn(("Invalid Component definition: " + (String(Ctor))), context);
+              warn("Invalid Component definition: " + String(Ctor), context);
           }
           return;
       }
@@ -2860,7 +2871,7 @@
       var name = Ctor.options.name || tag;
       var vnode = new VNode(
       // @ts-expect-error
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
       // @ts-expect-error
       { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
       return vnode;
@@ -2891,11 +2902,11 @@
           var toMerge = componentVNodeHooks[key];
           // @ts-expect-error
           if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
           }
       }
   }
-  function mergeHook$1(f1, f2) {
+  function mergeHook(f1, f2) {
       var merged = function (a, b) {
           // flow complains about extra args which is why we use any
           f1(a, b);
@@ -2930,7 +2941,7 @@
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
       if (Array.isArray(data) || isPrimitive(data)) {
           normalizationType = children;
           children = data;
@@ -2943,7 +2954,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -2978,14 +2989,14 @@
       }
       var vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor;
+          var Ctor = void 0;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if (config.isReservedTag(tag)) {
               // platform built-in elements
               if (isDef(data) &&
                   isDef(data.nativeOn) &&
                   data.tag !== 'component') {
-                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                  warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
               }
               vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
           }
@@ -3062,20 +3073,20 @@
       // args order: tag, data, children, normalizationType, alwaysNormalize
       // internal version is used by render functions compiled from templates
       // @ts-expect-error
-      vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
+      vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
       // normalization is always applied for the public version, used in
       // user-written render functions.
       // @ts-expect-error
-      vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
+      vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
       // $attrs & $listeners are exposed for easier HOC creation.
       // they need to be reactive so that HOCs using them are always updated
       var parentData = parentVnode && parentVnode.data;
       /* istanbul ignore else */
       {
-          defineReactive$$1(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
               !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
           }, true);
-          defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
               !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
           }, true);
       }
@@ -3089,9 +3100,7 @@
       };
       Vue.prototype._render = function () {
           var vm = this;
-          var ref = vm.$options;
-          var render = ref.render;
-          var _parentVnode = ref._parentVnode;
+          var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
           if (_parentVnode) {
               vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
@@ -3116,8 +3125,8 @@
                   try {
                       vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                   }
-                  catch (e) {
-                      handleError(e, vm, "renderError");
+                  catch (e$1) {
+                      handleError(e$1, vm, "renderError");
                       vnode = vm._vnode;
                   }
               }
@@ -3175,24 +3184,24 @@
           return factory.loadingComp;
       }
       if (owner && !isDef(factory.owners)) {
-          var owners = (factory.owners = [owner]);
-          var sync = true;
-          var timerLoading = null;
-          var timerTimeout = null;
-          owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-          var forceRender = function (renderCompleted) {
-              for (var i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
+          var owners_1 = (factory.owners = [owner]);
+          var sync_1 = true;
+          var timerLoading_1 = null;
+          var timerTimeout_1 = null;
+          owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+          var forceRender_1 = function (renderCompleted) {
+              for (var i = 0, l = owners_1.length; i < l; i++) {
+                  owners_1[i].$forceUpdate();
               }
               if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
+                  owners_1.length = 0;
+                  if (timerLoading_1 !== null) {
+                      clearTimeout(timerLoading_1);
+                      timerLoading_1 = null;
                   }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
+                  if (timerTimeout_1 !== null) {
+                      clearTimeout(timerTimeout_1);
+                      timerTimeout_1 = null;
                   }
               }
           };
@@ -3201,62 +3210,63 @@
               factory.resolved = ensureCtor(res, baseCtor);
               // invoke callbacks only if this is not a synchronous resolve
               // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
+              if (!sync_1) {
+                  forceRender_1(true);
               }
               else {
-                  owners.length = 0;
+                  owners_1.length = 0;
               }
           });
-          var reject = once(function (reason) {
-              warn("Failed to resolve async component: " + (String(factory)) +
-                      (reason ? ("\nReason: " + reason) : ''));
+          var reject_1 = once(function (reason) {
+              warn("Failed to resolve async component: " + String(factory) +
+                      (reason ? "\nReason: " + reason : ''));
               if (isDef(factory.errorComp)) {
                   factory.error = true;
-                  forceRender(true);
+                  forceRender_1(true);
               }
           });
-          var res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
+          var res_1 = factory(resolve, reject_1);
+          if (isObject(res_1)) {
+              if (isPromise(res_1)) {
                   // () => Promise
                   if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
+                      res_1.then(resolve, reject_1);
                   }
               }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
+              else if (isPromise(res_1.component)) {
+                  res_1.component.then(resolve, reject_1);
+                  if (isDef(res_1.error)) {
+                      factory.errorComp = ensureCtor(res_1.error, baseCtor);
                   }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
+                  if (isDef(res_1.loading)) {
+                      factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                      if (res_1.delay === 0) {
                           factory.loading = true;
                       }
                       else {
                           // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(function () {
-                              timerLoading = null;
+                          timerLoading_1 = setTimeout(function () {
+                              timerLoading_1 = null;
                               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                   factory.loading = true;
-                                  forceRender(false);
+                                  forceRender_1(false);
                               }
-                          }, res.delay || 200);
+                          }, res_1.delay || 200);
                       }
                   }
-                  if (isDef(res.timeout)) {
+                  if (isDef(res_1.timeout)) {
                       // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(function () {
-                          timerTimeout = null;
+                      timerTimeout_1 = setTimeout(function () {
+                          timerTimeout_1 = null;
                           if (isUndef(factory.resolved)) {
-                              reject("timeout (" + (res.timeout) + "ms)");
+                              reject_1("timeout (" + res_1.timeout + "ms)"
+                                  );
                           }
-                      }, res.timeout);
+                      }, res_1.timeout);
                   }
               }
           }
-          sync = false;
+          sync_1 = false;
           // return in case resolved synchronously
           return factory.loading ? factory.loadingComp : factory.resolved;
       }
@@ -3280,8 +3290,6 @@
       }
   }
 
-  /* @flow */
-
   /* @flow */
   function initEvents(vm) {
       vm._events = Object.create(null);
@@ -3292,15 +3300,15 @@
           updateComponentListeners(vm, listeners);
       }
   }
-  var target;
-  function add(event, fn) {
-      target.$on(event, fn);
+  var target$1;
+  function add$1(event, fn) {
+      target$1.$on(event, fn);
   }
   function remove$1(event, fn) {
-      target.$off(event, fn);
+      target$1.$off(event, fn);
   }
-  function createOnceHandler(event, fn) {
-      var _target = target;
+  function createOnceHandler$1(event, fn) {
+      var _target = target$1;
       return function onceHandler() {
           var res = fn.apply(null, arguments);
           if (res !== null) {
@@ -3309,9 +3317,9 @@
       };
   }
   function updateComponentListeners(vm, listeners, oldListeners) {
-      target = vm;
-      updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-      target = undefined;
+      target$1 = vm;
+      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+      target$1 = undefined;
   }
   function eventsMixin(Vue) {
       var hookRE = /^hook:/;
@@ -3351,8 +3359,8 @@
           }
           // array of events
           if (Array.isArray(event)) {
-              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                  vm.$off(event[i$1], fn);
+              for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                  vm.$off(event[i_1], fn);
               }
               return vm;
           }
@@ -3383,10 +3391,10 @@
               var lowerCaseEvent = event.toLowerCase();
               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                   tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                      (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
                       "Note that HTML attributes are case-insensitive and you cannot use " +
                       "v-on to listen to camelCase events when using in-DOM templates. " +
-                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                      ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
               }
           }
           var cbs = vm._events[event];
@@ -3477,13 +3485,13 @@
           if (vm._isBeingDestroyed) {
               return;
           }
-          callHook(vm, 'beforeDestroy');
+          callHook$1(vm, 'beforeDestroy');
           vm._isBeingDestroyed = true;
           // remove self from parent
           var parent = vm.$parent;
           // @ts-ignore
           if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove(parent.$children, vm);
+              remove$2(parent.$children, vm);
           }
           // teardown watchers
           if (vm._watcher) {
@@ -3503,7 +3511,7 @@
           // invoke destroy hooks on current rendered tree
           vm.__patch__(vm._vnode, null);
           // fire destroyed hook
-          callHook(vm, 'destroyed');
+          callHook$1(vm, 'destroyed');
           // turn off all instance listeners.
           vm.$off();
           // remove __vue__ reference
@@ -3536,7 +3544,7 @@
               }
           }
       }
-      callHook(vm, 'beforeMount');
+      callHook$1(vm, 'beforeMount');
       var updateComponent;
       /* istanbul ignore if */
       if (config.performance && mark) {
@@ -3548,11 +3556,11 @@
               mark(startTag);
               var vnode = vm._render();
               mark(endTag);
-              measure(("vue " + name + " render"), startTag, endTag);
+              measure("vue " + name + " render", startTag, endTag);
               mark(startTag);
               vm._update(vnode, hydrating);
               mark(endTag);
-              measure(("vue " + name + " patch"), startTag, endTag);
+              measure("vue " + name + " patch", startTag, endTag);
           };
       }
       else {
@@ -3564,9 +3572,9 @@
       // since the watcher's initial patch may call $forceUpdate (e.g. inside child
       // component's mounted hook), which relies on vm._watcher being already defined
       new Watcher(vm, updateComponent, noop, {
-          before: function before() {
+          before: function () {
               if (vm._isMounted && !vm._isDestroyed) {
-                  callHook(vm, 'beforeUpdate');
+                  callHook$1(vm, 'beforeUpdate');
               }
           },
       }, true /* isRenderWatcher */);
@@ -3575,7 +3583,7 @@
       // mounted is called for render-created child components in its inserted hook
       if (vm.$vnode == null) {
           vm._isMounted = true;
-          callHook(vm, 'mounted');
+          callHook$1(vm, 'mounted');
       }
       return vm;
   }
@@ -3665,7 +3673,7 @@
           for (var i = 0; i < vm.$children.length; i++) {
               activateChildComponent(vm.$children[i]);
           }
-          callHook(vm, 'activated');
+          callHook$1(vm, 'activated');
       }
   }
   function deactivateChildComponent(vm, direct) {
@@ -3680,10 +3688,10 @@
           for (var i = 0; i < vm.$children.length; i++) {
               deactivateChildComponent(vm.$children[i]);
           }
-          callHook(vm, 'deactivated');
+          callHook$1(vm, 'deactivated');
       }
   }
-  function callHook(vm, hook) {
+  function callHook$1(vm, hook) {
       // #7573 disable dep collection when invoking lifecycle hooks
       pushTarget();
       var handlers = vm.$options[hook];
@@ -3734,15 +3742,15 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
+      var performance_1 = window.performance;
+      if (performance_1 &&
+          typeof performance_1.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
           // if the event timestamp, although evaluated AFTER the Date.now(), is
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance.now(); };
+          getNow = function () { return performance_1.now(); };
       }
   }
   /**
@@ -3777,7 +3785,7 @@
               if (circular[id] > MAX_UPDATE_COUNT) {
                   warn('You may have an infinite update loop ' +
                       (watcher.user
-                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                          ? "in watcher with expression \"" + watcher.expression + "\""
                           : "in a component render function."), watcher.vm);
                   break;
               }
@@ -3802,7 +3810,7 @@
           var watcher = queue[i];
           var vm = watcher.vm;
           if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook(vm, 'updated');
+              callHook$1(vm, 'updated');
           }
       }
   }
@@ -3856,197 +3864,200 @@
   }
 
   /* @flow */
-  var uid$2 = 0;
+  var uid$1 = 0;
   /**
    * A watcher parses an expression, collects dependencies,
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-      this.vm = vm;
-      if (isRenderWatcher) {
-          vm._watcher = this;
-      }
-      vm._watchers.push(this);
-      // options
-      if (options) {
-          this.deep = !!options.deep;
-          this.user = !!options.user;
-          this.lazy = !!options.lazy;
-          this.sync = !!options.sync;
-          this.before = options.before;
-      }
-      else {
-          this.deep = this.user = this.lazy = this.sync = false;
-      }
-      this.cb = cb;
-      this.id = ++uid$2; // uid for batching
-      this.active = true;
-      this.dirty = this.lazy; // for lazy watchers
-      this.deps = [];
-      this.newDeps = [];
-      this.depIds = new _Set();
-      this.newDepIds = new _Set();
-      this.expression =
-          expOrFn.toString();
-      // parse expression for getter
-      if (typeof expOrFn === 'function') {
-          this.getter = expOrFn;
-      }
-      else {
-          this.getter = parsePath(expOrFn);
-          if (!this.getter) {
-              this.getter = noop;
-              warn("Failed watching path: \"" + expOrFn + "\" " +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
+  var Watcher = /** @class */ (function () {
+      function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+          this.vm = vm;
+          if (isRenderWatcher) {
+              vm._watcher = this;
+          }
+          vm._watchers.push(this);
+          // options
+          if (options) {
+              this.deep = !!options.deep;
+              this.user = !!options.user;
+              this.lazy = !!options.lazy;
+              this.sync = !!options.sync;
+              this.before = options.before;
           }
-      }
-      this.value = this.lazy ? undefined : this.get();
-  };
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  Watcher.prototype.get = function get () {
-      pushTarget(this);
-      var value;
-      var vm = this.vm;
-      try {
-          value = this.getter.call(vm, vm);
-      }
-      catch (e) {
-          if (this.user) {
-              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+          else {
+              this.deep = this.user = this.lazy = this.sync = false;
+          }
+          this.cb = cb;
+          this.id = ++uid$1; // uid for batching
+          this.active = true;
+          this.dirty = this.lazy; // for lazy watchers
+          this.deps = [];
+          this.newDeps = [];
+          this.depIds = new _Set();
+          this.newDepIds = new _Set();
+          this.expression =
+              expOrFn.toString() ;
+          // parse expression for getter
+          if (typeof expOrFn === 'function') {
+              this.getter = expOrFn;
           }
           else {
-              throw e;
+              this.getter = parsePath(expOrFn);
+              if (!this.getter) {
+                  this.getter = noop;
+                  warn("Failed watching path: \"" + expOrFn + "\" " +
+                          'Watcher only accepts simple dot-delimited paths. ' +
+                          'For full control, use a function instead.', vm);
+              }
           }
+          this.value = this.lazy ? undefined : this.get();
       }
-      finally {
-          // "touch" every property so they are all tracked as
-          // dependencies for deep watching
-          if (this.deep) {
-              traverse(value);
-          }
-          popTarget();
-          this.cleanupDeps();
-      }
-      return value;
-  };
-  /**
-   * Add a dependency to this directive.
-   */
-  Watcher.prototype.addDep = function addDep (dep) {
-      var id = dep.id;
-      if (!this.newDepIds.has(id)) {
-          this.newDepIds.add(id);
-          this.newDeps.push(dep);
-          if (!this.depIds.has(id)) {
-              dep.addSub(this);
+      /**
+       * Evaluate the getter, and re-collect dependencies.
+       */
+      Watcher.prototype.get = function () {
+          pushTarget(this);
+          var value;
+          var vm = this.vm;
+          try {
+              value = this.getter.call(vm, vm);
           }
-      }
-  };
-  /**
-   * Clean up for dependency collection.
-   */
-  Watcher.prototype.cleanupDeps = function cleanupDeps () {
-      var i = this.deps.length;
-      while (i--) {
-          var dep = this.deps[i];
-          if (!this.newDepIds.has(dep.id)) {
-              dep.removeSub(this);
-          }
-      }
-      var tmp = this.depIds;
-      this.depIds = this.newDepIds;
-      this.newDepIds = tmp;
-      this.newDepIds.clear();
-      tmp = this.deps;
-      this.deps = this.newDeps;
-      this.newDeps = tmp;
-      this.newDeps.length = 0;
-  };
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  Watcher.prototype.update = function update () {
-      /* istanbul ignore else */
-      if (this.lazy) {
-          this.dirty = true;
-      }
-      else if (this.sync) {
-          this.run();
-      }
-      else {
-          queueWatcher(this);
-      }
-  };
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  Watcher.prototype.run = function run () {
-      if (this.active) {
-          var value = this.get();
-          if (value !== this.value ||
-              // Deep watchers and watchers on Object/Arrays should fire even
-              // when the value is the same, because the value may
-              // have mutated.
-              isObject(value) ||
-              this.deep) {
-              // set new value
-              var oldValue = this.value;
-              this.value = value;
+          catch (e) {
               if (this.user) {
-                  try {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-                  catch (e) {
-                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                  }
+                  handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
               }
               else {
-                  this.cb.call(this.vm, value, oldValue);
+                  throw e;
               }
           }
-      }
-  };
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  Watcher.prototype.evaluate = function evaluate () {
-      this.value = this.get();
-      this.dirty = false;
-  };
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  Watcher.prototype.depend = function depend () {
-      var i = this.deps.length;
-      while (i--) {
-          this.deps[i].depend();
-      }
-  };
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  Watcher.prototype.teardown = function teardown () {
-      if (this.active) {
-          // remove self from vm's watcher list
-          // this is a somewhat expensive operation so we skip it
-          // if the vm is being destroyed.
-          if (!this.vm._isBeingDestroyed) {
-              remove(this.vm._watchers, this);
+          finally {
+              // "touch" every property so they are all tracked as
+              // dependencies for deep watching
+              if (this.deep) {
+                  traverse(value);
+              }
+              popTarget();
+              this.cleanupDeps();
           }
+          return value;
+      };
+      /**
+       * Add a dependency to this directive.
+       */
+      Watcher.prototype.addDep = function (dep) {
+          var id = dep.id;
+          if (!this.newDepIds.has(id)) {
+              this.newDepIds.add(id);
+              this.newDeps.push(dep);
+              if (!this.depIds.has(id)) {
+                  dep.addSub(this);
+              }
+          }
+      };
+      /**
+       * Clean up for dependency collection.
+       */
+      Watcher.prototype.cleanupDeps = function () {
           var i = this.deps.length;
           while (i--) {
-              this.deps[i].removeSub(this);
+              var dep = this.deps[i];
+              if (!this.newDepIds.has(dep.id)) {
+                  dep.removeSub(this);
+              }
+          }
+          var tmp = this.depIds;
+          this.depIds = this.newDepIds;
+          this.newDepIds = tmp;
+          this.newDepIds.clear();
+          tmp = this.deps;
+          this.deps = this.newDeps;
+          this.newDeps = tmp;
+          this.newDeps.length = 0;
+      };
+      /**
+       * Subscriber interface.
+       * Will be called when a dependency changes.
+       */
+      Watcher.prototype.update = function () {
+          /* istanbul ignore else */
+          if (this.lazy) {
+              this.dirty = true;
           }
-          this.active = false;
-      }
-  };
+          else if (this.sync) {
+              this.run();
+          }
+          else {
+              queueWatcher(this);
+          }
+      };
+      /**
+       * Scheduler job interface.
+       * Will be called by the scheduler.
+       */
+      Watcher.prototype.run = function () {
+          if (this.active) {
+              var value = this.get();
+              if (value !== this.value ||
+                  // Deep watchers and watchers on Object/Arrays should fire even
+                  // when the value is the same, because the value may
+                  // have mutated.
+                  isObject(value) ||
+                  this.deep) {
+                  // set new value
+                  var oldValue = this.value;
+                  this.value = value;
+                  if (this.user) {
+                      try {
+                          this.cb.call(this.vm, value, oldValue);
+                      }
+                      catch (e) {
+                          handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                      }
+                  }
+                  else {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+              }
+          }
+      };
+      /**
+       * Evaluate the value of the watcher.
+       * This only gets called for lazy watchers.
+       */
+      Watcher.prototype.evaluate = function () {
+          this.value = this.get();
+          this.dirty = false;
+      };
+      /**
+       * Depend on all deps collected by this watcher.
+       */
+      Watcher.prototype.depend = function () {
+          var i = this.deps.length;
+          while (i--) {
+              this.deps[i].depend();
+          }
+      };
+      /**
+       * Remove self from all dependencies' subscriber list.
+       */
+      Watcher.prototype.teardown = function () {
+          if (this.active) {
+              // remove self from vm's watcher list
+              // this is a somewhat expensive operation so we skip it
+              // if the vm is being destroyed.
+              if (!this.vm._isBeingDestroyed) {
+                  remove$2(this.vm._watchers, this);
+              }
+              var i = this.deps.length;
+              while (i--) {
+                  this.deps[i].removeSub(this);
+              }
+              this.active = false;
+          }
+      };
+      return Watcher;
+  }());
 
   /* @flow */
   var sharedPropertyDefinition = {
@@ -4068,7 +4079,7 @@
       vm._watchers = [];
       var opts = vm.$options;
       if (opts.props)
-          { initProps(vm, opts.props); }
+          { initProps$1(vm, opts.props); }
       if (opts.methods)
           { initMethods(vm, opts.methods); }
       if (opts.data) {
@@ -4078,12 +4089,12 @@
           observe((vm._data = {}), true /* asRootData */);
       }
       if (opts.computed)
-          { initComputed(vm, opts.computed); }
+          { initComputed$1(vm, opts.computed); }
       if (opts.watch && opts.watch !== nativeWatch) {
           initWatch(vm, opts.watch);
       }
   }
-  function initProps(vm, propsOptions) {
+  function initProps$1(vm, propsOptions) {
       var propsData = vm.$options.propsData || {};
       var props = (vm._props = {});
       // cache prop keys so that future props updates can iterate using Array
@@ -4094,7 +4105,7 @@
       if (!isRoot) {
           toggleObserving(false);
       }
-      var loop = function ( key ) {
+      var _loop_1 = function (key) {
           keys.push(key);
           var value = validateProp(key, propsOptions, propsData, vm);
           /* istanbul ignore else */
@@ -4102,14 +4113,14 @@
               var hyphenatedKey = hyphenate(key);
               if (isReservedAttribute(hyphenatedKey) ||
                   config.isReservedAttr(hyphenatedKey)) {
-                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                  warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
               }
-              defineReactive$$1(props, key, value, function () {
+              defineReactive(props, key, value, function () {
                   if (!isRoot && !isUpdatingChildComponent) {
                       warn("Avoid mutating a prop directly since the value will be " +
                           "overwritten whenever the parent component re-renders. " +
                           "Instead, use a data or computed property based on the prop's " +
-                          "value. Prop being mutated: \"" + key + "\"", vm);
+                          ("value. Prop being mutated: \"" + key + "\""), vm);
                   }
               });
           }
@@ -4120,8 +4131,9 @@
               proxy(vm, "_props", key);
           }
       };
-
-      for (var key in propsOptions) loop( key );
+      for (var key in propsOptions) {
+          _loop_1(key);
+      }
       toggleObserving(true);
   }
   function initData(vm) {
@@ -4141,7 +4153,7 @@
           var key = keys[i];
           {
               if (methods && hasOwn(methods, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                  warn("Method \"" + key + "\" has already been defined as a data property.", vm);
               }
           }
           if (props && hasOwn(props, key)) {
@@ -4170,7 +4182,7 @@
       }
   }
   var computedWatcherOptions = { lazy: true };
-  function initComputed(vm, computed) {
+  function initComputed$1(vm, computed) {
       // $flow-disable-line
       var watchers = (vm._computedWatchers = Object.create(null));
       // computed properties are just getters during SSR
@@ -4179,7 +4191,7 @@
           var userDef = computed[key];
           var getter = typeof userDef === 'function' ? userDef : userDef.get;
           if (getter == null) {
-              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+              warn("Getter is missing for computed property \"" + key + "\".", vm);
           }
           if (!isSSR) {
               // create internal watcher for the computed property.
@@ -4193,10 +4205,10 @@
           }
           else {
               if (key in vm.$data) {
-                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                  warn("The computed property \"" + key + "\" is already defined in data.", vm);
               }
               else if (vm.$options.props && key in vm.$options.props) {
-                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                  warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
               }
           }
       }
@@ -4219,7 +4231,7 @@
       }
       if (sharedPropertyDefinition.set === noop) {
           sharedPropertyDefinition.set = function () {
-              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+              warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
           };
       }
       Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4248,11 +4260,11 @@
       for (var key in methods) {
           {
               if (typeof methods[key] !== 'function') {
-                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                  warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
                       "Did you reference the function correctly?", vm);
               }
               if (props && hasOwn(props, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                  warn("Method \"" + key + "\" has already been defined as a prop.", vm);
               }
               if (key in vm && isReserved(key)) {
                   warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4324,7 +4336,7 @@
                   cb.call(vm, watcher.value);
               }
               catch (error) {
-                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+                  handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
               }
               popTarget();
           }
@@ -4335,17 +4347,17 @@
   }
 
   /* @flow */
-  var uid$3 = 0;
-  function initMixin(Vue) {
+  var uid = 0;
+  function initMixin$1(Vue) {
       Vue.prototype._init = function (options) {
           var vm = this;
           // a uid
-          vm._uid = uid$3++;
+          vm._uid = uid++;
           var startTag, endTag;
           /* istanbul ignore if */
           if (config.performance && mark) {
-              startTag = "vue-perf-start:" + (vm._uid);
-              endTag = "vue-perf-end:" + (vm._uid);
+              startTag = "vue-perf-start:" + vm._uid;
+              endTag = "vue-perf-end:" + vm._uid;
               mark(startTag);
           }
           // a flag to avoid this being observed
@@ -4369,16 +4381,16 @@
           initLifecycle(vm);
           initEvents(vm);
           initRender(vm);
-          callHook(vm, 'beforeCreate');
+          callHook$1(vm, 'beforeCreate');
           initInjections(vm); // resolve injections before data/props
           initState(vm);
           initProvide(vm); // resolve provide after data/props
-          callHook(vm, 'created');
+          callHook$1(vm, 'created');
           /* istanbul ignore if */
           if (config.performance && mark) {
               vm._name = formatComponentName(vm, false);
               mark(endTag);
-              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+              measure("vue " + vm._name + " init", startTag, endTag);
           }
           if (vm.$options.el) {
               vm.$mount(vm.$options.el);
@@ -4446,7 +4458,7 @@
       this._init(options);
   }
   //@ts-ignore
-  initMixin(Vue);
+  initMixin$1(Vue);
   //@ts-ignore
   stateMixin(Vue);
   //@ts-ignore
@@ -4478,7 +4490,7 @@
   }
 
   /* @flow */
-  function initMixin$1(Vue) {
+  function initMixin(Vue) {
       Vue.mixin = function (mixin) {
           this.options = mergeOptions(this.options, mixin);
           return this;
@@ -4521,10 +4533,10 @@
           // the Vue instances at extension time, on the extended prototype. This
           // avoids Object.defineProperty calls for each instance created.
           if (Sub.options.props) {
-              initProps$1(Sub);
+              initProps(Sub);
           }
           if (Sub.options.computed) {
-              initComputed$1(Sub);
+              initComputed(Sub);
           }
           // allow further extension/mixin/plugin usage
           Sub.extend = Super.extend;
@@ -4550,13 +4562,13 @@
           return Sub;
       };
   }
-  function initProps$1(Comp) {
+  function initProps(Comp) {
       var props = Comp.options.props;
       for (var key in props) {
           proxy(Comp.prototype, "_props", key);
       }
   }
-  function initComputed$1(Comp) {
+  function initComputed(Comp) {
       var computed = Comp.options.computed;
       for (var key in computed) {
           defineComputed(Comp.prototype, key, computed[key]);
@@ -4612,26 +4624,24 @@
       return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache;
-      var keys = keepAliveInstance.keys;
-      var _vnode = keepAliveInstance._vnode;
+      var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
       for (var key in cache) {
           var cachedNode = cache[key];
           if (cachedNode) {
-              var name = getComponentName(cachedNode.componentOptions);
-              if (name && !filter(name)) {
+              var name_1 = getComponentName(cachedNode.componentOptions);
+              if (name_1 && !filter(name_1)) {
                   pruneCacheEntry(cache, key, keys, _vnode);
               }
           }
       }
   }
   function pruneCacheEntry(cache, key, keys, current) {
-      var cached$$1 = cache[key];
-      if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-          cached$$1.componentInstance.$destroy();
+      var cached = cache[key];
+      if (cached && (!current || cached.tag !== current.tag)) {
+          cached.componentInstance.$destroy();
       }
       cache[key] = null;
-      remove(keys, key);
+      remove$2(keys, key);
   }
   var patternTypes = [String, RegExp, Array];
   // TODO use defineComponent
@@ -4643,55 +4653,50 @@
           exclude: patternTypes,
           max: [String, Number],
       },
-      created: function created() {
+      created: function () {
           this.cache = Object.create(null);
           this.keys = [];
       },
-      destroyed: function destroyed() {
+      destroyed: function () {
           for (var key in this.cache) {
               pruneCacheEntry(this.cache, key, this.keys);
           }
       },
-      mounted: function mounted() {
-          var this$1 = this;
-
+      mounted: function () {
+          var _this = this;
           this.$watch('include', function (val) {
-              pruneCache(this$1, function (name) { return matches(val, name); });
+              pruneCache(_this, function (name) { return matches(val, name); });
           });
           this.$watch('exclude', function (val) {
-              pruneCache(this$1, function (name) { return !matches(val, name); });
+              pruneCache(_this, function (name) { return !matches(val, name); });
           });
       },
-      render: function render() {
+      render: function () {
           var slot = this.$slots.default;
           var vnode = getFirstComponentChild(slot);
           var componentOptions = vnode && vnode.componentOptions;
           if (componentOptions) {
               // check pattern
-              var name = getComponentName(componentOptions);
-              var ref = this;
-              var include = ref.include;
-              var exclude = ref.exclude;
+              var name_2 = getComponentName(componentOptions);
+              var _a = this, include = _a.include, exclude = _a.exclude;
               if (
               // not included
-              (include && (!name || !matches(include, name))) ||
+              (include && (!name_2 || !matches(include, name_2))) ||
                   // excluded
-                  (exclude && name && matches(exclude, name))) {
+                  (exclude && name_2 && matches(exclude, name_2))) {
                   return vnode;
               }
-              var ref$1 = this;
-              var cache = ref$1.cache;
-              var keys = ref$1.keys;
+              var _b = this, cache = _b.cache, keys = _b.keys;
               var key = vnode.key == null
                   ? // same constructor may get registered as different local components
                       // so cid alone is not enough (#3269)
                       componentOptions.Ctor.cid +
-                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                          (componentOptions.tag ? "::" + componentOptions.tag : '')
                   : vnode.key;
               if (cache[key]) {
                   vnode.componentInstance = cache[key].componentInstance;
                   // make current key freshest
-                  remove(keys, key);
+                  remove$2(keys, key);
                   keys.push(key);
               }
               else {
@@ -4730,7 +4735,7 @@
           warn: warn,
           extend: extend,
           mergeOptions: mergeOptions,
-          defineReactive: defineReactive$$1,
+          defineReactive: defineReactive,
       };
       Vue.set = set;
       Vue.delete = del;
@@ -4749,7 +4754,7 @@
       Vue.options._base = Vue;
       extend(Vue.options.components, builtInComponents);
       initUse(Vue);
-      initMixin$1(Vue);
+      initMixin(Vue);
       initExtend(Vue);
       initAssetRegisters(Vue);
   }
@@ -4759,7 +4764,7 @@
       get: isServerRendering,
   });
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function get() {
+      get: function () {
           /* istanbul ignore next */
           return this.$vnode && this.$vnode.ssrContext;
       },
@@ -4960,7 +4965,7 @@
   }
 
   /* @flow */
-  function createElement$1(tagName, vnode) {
+  function createElement(tagName, vnode) {
       var elm = document.createElement(tagName);
       if (tagName !== 'select') {
           return elm;
@@ -5008,7 +5013,8 @@
   }
 
   var nodeOps = /*#__PURE__*/Object.freeze({
-    createElement: createElement$1,
+    __proto__: null,
+    createElement: createElement,
     createElementNS: createElementNS,
     createTextNode: createTextNode,
     createComment: createComment,
@@ -5024,16 +5030,16 @@
 
   /* @flow */
   var ref = {
-      create: function create(_, vnode) {
+      create: function (_, vnode) {
           registerRef(vnode);
       },
-      update: function update(oldVnode, vnode) {
+      update: function (oldVnode, vnode) {
           if (oldVnode.data.ref !== vnode.data.ref) {
               registerRef(oldVnode, true);
               registerRef(vnode);
           }
       },
-      destroy: function destroy(vnode) {
+      destroy: function (vnode) {
           registerRef(vnode, true);
       },
   };
@@ -5047,7 +5053,7 @@
       if (isRemoval) {
           if (Array.isArray(refs[key])) {
               // @ts-expect-error invalid typings
-              remove(refs[key], ref);
+              remove$2(refs[key], ref);
           }
           else if (refs[key] === ref) {
               refs[key] = undefined;
@@ -5115,8 +5121,7 @@
   function createPatchFunction(backend) {
       var i, j;
       var cbs = {};
-      var modules = backend.modules;
-      var nodeOps = backend.nodeOps;
+      var modules = backend.modules, nodeOps = backend.nodeOps;
       for (i = 0; i < hooks.length; ++i) {
           cbs[hooks[i]] = [];
           for (j = 0; j < modules.length; ++j) {
@@ -5129,13 +5134,13 @@
           return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
       }
       function createRmCb(childElm, listeners) {
-          function remove$$1() {
-              if (--remove$$1.listeners === 0) {
+          function remove() {
+              if (--remove.listeners === 0) {
                   removeNode(childElm);
               }
           }
-          remove$$1.listeners = listeners;
-          return remove$$1;
+          remove.listeners = listeners;
+          return remove;
       }
       function removeNode(el) {
           var parent = nodeOps.parentNode(el);
@@ -5144,7 +5149,7 @@
               nodeOps.removeChild(parent, el);
           }
       }
-      function isUnknownElement$$1(vnode, inVPre) {
+      function isUnknownElement(vnode, inVPre) {
           return (!inVPre &&
               !vnode.ns &&
               !(config.ignoredElements.length &&
@@ -5177,7 +5182,7 @@
                   if (data && data.pre) {
                       creatingElmInVPre++;
                   }
-                  if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
+                  if (isUnknownElement(vnode, creatingElmInVPre)) {
                       warn('Unknown custom element: <' +
                           tag +
                           '> - did you ' +
@@ -5270,11 +5275,11 @@
           // a reactivated keep-alive component doesn't insert itself
           insert(parentElm, vnode.elm, refElm);
       }
-      function insert(parent, elm, ref$$1) {
+      function insert(parent, elm, ref) {
           if (isDef(parent)) {
-              if (isDef(ref$$1)) {
-                  if (nodeOps.parentNode(ref$$1) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref$$1);
+              if (isDef(ref)) {
+                  if (nodeOps.parentNode(ref) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref);
                   }
               }
               else {
@@ -5287,8 +5292,8 @@
               {
                   checkDuplicateKeys(children);
               }
-              for (var i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                  createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
               }
           }
           else if (isPrimitive(vnode.text)) {
@@ -5302,8 +5307,8 @@
           return isDef(vnode.tag);
       }
       function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-              cbs.create[i$1](emptyNode, vnode);
+          for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+              cbs.create[i_2](emptyNode, vnode);
           }
           i = vnode.data.hook; // Reuse variable
           if (isDef(i)) {
@@ -5375,7 +5380,7 @@
       }
       function removeAndInvokeRemoveHook(vnode, rm) {
           if (isDef(rm) || isDef(vnode.data)) {
-              var i;
+              var i_3;
               var listeners = cbs.remove.length + 1;
               if (isDef(rm)) {
                   // we have a recursively passed down rm callback
@@ -5387,16 +5392,16 @@
                   rm = createRmCb(vnode.elm, listeners);
               }
               // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
+              if (isDef((i_3 = vnode.componentInstance)) &&
+                  isDef((i_3 = i_3._vnode)) &&
+                  isDef(i_3.data)) {
+                  removeAndInvokeRemoveHook(i_3, rm);
               }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
+              for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                  cbs.remove[i_3](vnode, rm);
               }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
+              if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                  i_3(vnode, rm);
               }
               else {
                   rm();
@@ -5492,12 +5497,12 @@
       }
       function checkDuplicateKeys(children) {
           var seenKeys = {};
-          for (var i = 0; i < children.length; i++) {
-              var vnode = children[i];
+          for (var i_4 = 0; i_4 < children.length; i_4++) {
+              var vnode = children[i_4];
               var key = vnode.key;
               if (isDef(key)) {
                   if (seenKeys[key]) {
-                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                      warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
                   }
                   else {
                       seenKeys[key] = true;
@@ -5506,10 +5511,10 @@
           }
       }
       function findIdxInOld(node, oldCh, start, end) {
-          for (var i = start; i < end; i++) {
-              var c = oldCh[i];
+          for (var i_5 = start; i_5 < end; i_5++) {
+              var c = oldCh[i_5];
               if (isDef(c) && sameVnode(node, c))
-                  { return i; }
+                  { return i_5; }
           }
       }
       function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5589,8 +5594,8 @@
               vnode.parent.data.pendingInsert = queue;
           }
           else {
-              for (var i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
+              for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                  queue[i_6].data.hook.insert(queue[i_6]);
               }
           }
       }
@@ -5603,9 +5608,7 @@
       // Note: this is a browser-only function so we can assume elms are DOM nodes.
       function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
           var i;
-          var tag = vnode.tag;
-          var data = vnode.data;
-          var children = vnode.children;
+          var tag = vnode.tag, data = vnode.data, children = vnode.children;
           inVPre = inVPre || (data && data.pre);
           vnode.elm = elm;
           if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5654,9 +5657,9 @@
                           // iterate and compare children lists
                           var childrenMatch = true;
                           var childNode = elm.firstChild;
-                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                          for (var i_7 = 0; i_7 < children.length; i_7++) {
                               if (!childNode ||
-                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
                                   childrenMatch = false;
                                   break;
                               }
@@ -5700,7 +5703,7 @@
       function assertNodeMatch(node, vnode, inVPre) {
           if (isDef(vnode.tag)) {
               return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement$$1(vnode, inVPre) &&
+                  (!isUnknownElement(vnode, inVPre) &&
                       vnode.tag.toLowerCase() ===
                           (node.tagName && node.tagName.toLowerCase())));
           }
@@ -5767,22 +5770,22 @@
                       var ancestor = vnode.parent;
                       var patchable = isPatchable(vnode);
                       while (ancestor) {
-                          for (var i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
+                          for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                              cbs.destroy[i_8](ancestor);
                           }
                           ancestor.elm = vnode.elm;
                           if (patchable) {
-                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                  cbs.create[i$1](emptyNode, ancestor);
+                              for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                  cbs.create[i_9](emptyNode, ancestor);
                               }
                               // #6513
                               // invoke insert hooks that may have been merged by create hooks.
                               // e.g. for directives that uses the "inserted" hook.
-                              var insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
+                              var insert_1 = ancestor.data.hook.insert;
+                              if (insert_1.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                      insert.fns[i$2]();
+                                  for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                      insert_1.fns[i_10]();
                                   }
                               }
                           }
@@ -5823,8 +5826,8 @@
   function _update(oldVnode, vnode) {
       var isCreate = oldVnode === emptyNode;
       var isDestroy = vnode === emptyNode;
-      var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-      var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
+      var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
       var dirsWithInsert = [];
       var dirsWithPostpatch = [];
       var key, oldDir, dir;
@@ -5833,7 +5836,7 @@
           dir = newDirs[key];
           if (!oldDir) {
               // new directive, bind
-              callHook$1(dir, 'bind', vnode, oldVnode);
+              callHook(dir, 'bind', vnode, oldVnode);
               if (dir.def && dir.def.inserted) {
                   dirsWithInsert.push(dir);
               }
@@ -5842,7 +5845,7 @@
               // existing directive, update
               dir.oldValue = oldDir.value;
               dir.oldArg = oldDir.arg;
-              callHook$1(dir, 'update', vnode, oldVnode);
+              callHook(dir, 'update', vnode, oldVnode);
               if (dir.def && dir.def.componentUpdated) {
                   dirsWithPostpatch.push(dir);
               }
@@ -5851,7 +5854,7 @@
       if (dirsWithInsert.length) {
           var callInsert = function () {
               for (var i = 0; i < dirsWithInsert.length; i++) {
-                  callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
               }
           };
           if (isCreate) {
@@ -5864,7 +5867,7 @@
       if (dirsWithPostpatch.length) {
           mergeVNodeHook(vnode, 'postpatch', function () {
               for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
               }
           });
       }
@@ -5872,13 +5875,13 @@
           for (key in oldDirs) {
               if (!newDirs[key]) {
                   // no longer present, unbind
-                  callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
               }
           }
       }
   }
   var emptyModifiers = Object.create(null);
-  function normalizeDirectives$1(dirs, vm) {
+  function normalizeDirectives(dirs, vm) {
       var res = Object.create(null);
       if (!dirs) {
           // $flow-disable-line
@@ -5898,16 +5901,16 @@
       return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+      return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
   }
-  function callHook$1(dir, hook, vnode, oldVnode, isDestroy) {
+  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
       var fn = dir.def && dir.def[hook];
       if (fn) {
           try {
               fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
           }
           catch (e) {
-              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+              handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
           }
       }
   }
@@ -6002,11 +6005,11 @@
               key === 'placeholder' &&
               value !== '' &&
               !el.__ieph) {
-              var blocker = function (e) {
+              var blocker_1 = function (e) {
                   e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
+                  el.removeEventListener('input', blocker_1);
               };
-              el.addEventListener('input', blocker);
+              el.addEventListener('input', blocker_1);
               // $flow-disable-line
               el.__ieph = true; /* IE placeholder patched */
           }
@@ -6046,12 +6049,6 @@
       update: updateClass,
   };
 
-  /* @flow */
-
-  /* @flow */
-
-  /* @flow */
-
   /* @flow */
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
@@ -6067,8 +6064,8 @@
       /* istanbul ignore if */
       if (isDef(on[RANGE_TOKEN])) {
           // IE input[type=range] only supports `change` event
-          var event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          var event_1 = isIE ? 'change' : 'input';
+          on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
           delete on[RANGE_TOKEN];
       }
       // This was originally intended to fix #4521 but no longer necessary
@@ -6079,13 +6076,13 @@
           delete on[CHECKBOX_RADIO_TOKEN];
       }
   }
-  var target$1;
-  function createOnceHandler$1(event, handler, capture) {
-      var _target = target$1; // save current target element in closure
+  var target;
+  function createOnceHandler(event, handler, capture) {
+      var _target = target; // save current target element in closure
       return function onceHandler() {
           var res = handler.apply(null, arguments);
           if (res !== null) {
-              remove$2(event, onceHandler, capture, _target);
+              remove(event, onceHandler, capture, _target);
           }
       };
   }
@@ -6093,7 +6090,7 @@
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
   var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-  function add$1(name, handler, capture, passive) {
+  function add(name, handler, capture, passive) {
       // async edge case #6566: inner click event triggers patch, event handler
       // attached to outer element during patch, and triggered again. This
       // happens because browsers fire microtask ticks between event propagation.
@@ -6101,17 +6098,17 @@
       // and the handler would only fire if the event passed to it was fired
       // AFTER it was attached.
       if (useMicrotaskFix) {
-          var attachedTimestamp = currentFlushTimestamp;
-          var original = handler;
+          var attachedTimestamp_1 = currentFlushTimestamp;
+          var original_1 = handler;
           //@ts-expect-error
-          handler = original._wrapper = function (e) {
+          handler = original_1._wrapper = function (e) {
               if (
               // no bubbling, should always fire.
               // this is just a safety net in case event.timeStamp is unreliable in
               // certain weird environments...
               e.target === e.currentTarget ||
                   // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
+                  e.timeStamp >= attachedTimestamp_1 ||
                   // bail for environments that have buggy event.timeStamp implementations
                   // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                   // #9681 QtWebEngine event.timeStamp is negative value
@@ -6120,14 +6117,14 @@
                   // electron/nw.js app, since event.timeStamp will be using a different
                   // starting reference
                   e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
+                  return original_1.apply(this, arguments);
               }
           };
       }
-      target$1.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+      target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
   }
-  function remove$2(name, handler, capture, _target) {
-      (_target || target$1).removeEventListener(name, 
+  function remove(name, handler, capture, _target) {
+      (_target || target).removeEventListener(name, 
       //@ts-expect-error
       handler._wrapper || handler, capture);
   }
@@ -6137,10 +6134,10 @@
       }
       var on = vnode.data.on || {};
       var oldOn = oldVnode.data.on || {};
-      target$1 = vnode.elm;
+      target = vnode.elm;
       normalizeEvents(on);
-      updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-      target$1 = undefined;
+      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+      target = undefined;
   }
   var events = {
       create: updateDOMListeners,
@@ -6355,9 +6352,9 @@
       }
       var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
       for (var i = 0; i < vendorNames.length; i++) {
-          var name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
+          var name_1 = vendorNames[i] + capName;
+          if (name_1 in emptyStyle) {
+              return name_1;
           }
       }
   });
@@ -6464,31 +6461,31 @@
       }
   }
 
-  function resolveTransition(def$$1) {
-      if (!def$$1) {
+  function resolveTransition(def) {
+      if (!def) {
           return;
       }
       /* istanbul ignore else */
-      if (typeof def$$1 === 'object') {
+      if (typeof def === 'object') {
           var res = {};
-          if (def$$1.css !== false) {
-              extend(res, autoCssTransition(def$$1.name || 'v'));
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
           }
-          extend(res, def$$1);
+          extend(res, def);
           return res;
       }
-      else if (typeof def$$1 === 'string') {
-          return autoCssTransition(def$$1);
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
       }
   }
   var autoCssTransition = cached(function (name) {
       return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
+          enterClass: name + "-enter",
+          enterToClass: name + "-enter-to",
+          enterActiveClass: name + "-enter-active",
+          leaveClass: name + "-leave",
+          leaveToClass: name + "-leave-to",
+          leaveActiveClass: name + "-leave-active",
       };
   });
   var hasTransition = inBrowser && !isIE9;
@@ -6535,15 +6532,12 @@
   }
   function removeTransitionClass(el, cls) {
       if (el._transitionClasses) {
-          remove(el._transitionClasses, cls);
+          remove$2(el._transitionClasses, cls);
       }
       removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var ref = getTransitionInfo(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
+      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
       if (!type)
           { return cb(); }
       var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -6649,23 +6643,7 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
+      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
@@ -6773,17 +6751,7 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
+      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
       var userWantsControl = getHookArgumentsLength(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -6857,7 +6825,7 @@
   function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
           warn("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
+              ("got " + JSON.stringify(val) + "."), vnode.context);
       }
       else if (isNaN(val)) {
           warn("<transition> explicit " + name + " duration is NaN - " +
@@ -6897,7 +6865,7 @@
       ? {
           create: _enter,
           activate: _enter,
-          remove: function remove$$1(vnode, rm) {
+          remove: function (vnode, rm) {
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
@@ -6934,7 +6902,7 @@
       });
   }
   var directive = {
-      inserted: function inserted(el, binding, vnode, oldVnode) {
+      inserted: function (el, binding, vnode, oldVnode) {
           if (vnode.tag === 'select') {
               // #6903
               if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -6964,22 +6932,22 @@
               }
           }
       },
-      componentUpdated: function componentUpdated(el, binding, vnode) {
+      componentUpdated: function (el, binding, vnode) {
           if (vnode.tag === 'select') {
               setSelected(el, binding, vnode.context);
               // in case the options rendered by v-for have changed,
               // it's possible that the value is out-of-sync with the rendered options.
               // detect such cases and filter out values that no longer has a matching
               // option in the DOM.
-              var prevOptions = el._vOptions;
-              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+              var prevOptions_1 = el._vOptions;
+              var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
                   // trigger change event if
                   // no matching option found for at least one value
                   var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
                       : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
+                          hasNoMatchingOption(binding.value, curOptions_1);
                   if (needReset) {
                       trigger(el, 'change');
                   }
@@ -7000,8 +6968,8 @@
       var value = binding.value;
       var isMultiple = el.multiple;
       if (isMultiple && !Array.isArray(value)) {
-          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                  "expects an Array value for its binding, but got " + (Object.prototype.toString
+          warn("<select multiple v-model=\"" + binding.expression + "\"> " +
+                  ("expects an Array value for its binding, but got " + Object.prototype.toString
                       .call(value)
                       .slice(8, -1)), vm);
           return;
@@ -7059,14 +7027,13 @@
           : vnode;
   }
   var show = {
-      bind: function bind(el, ref, vnode) {
-          var value = ref.value;
-
+      bind: function (el, _a, vnode) {
+          var value = _a.value;
           vnode = locateNode(vnode);
-          var transition$$1 = vnode.data && vnode.data.transition;
+          var transition = vnode.data && vnode.data.transition;
           var originalDisplay = (el.__vOriginalDisplay =
               el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition$$1) {
+          if (value && transition) {
               vnode.data.show = true;
               enter(vnode, function () {
                   el.style.display = originalDisplay;
@@ -7076,16 +7043,14 @@
               el.style.display = value ? originalDisplay : 'none';
           }
       },
-      update: function update(el, ref, vnode) {
-          var value = ref.value;
-          var oldValue = ref.oldValue;
-
+      update: function (el, _a, vnode) {
+          var value = _a.value, oldValue = _a.oldValue;
           /* istanbul ignore if */
           if (!value === !oldValue)
               { return; }
           vnode = locateNode(vnode);
-          var transition$$1 = vnode.data && vnode.data.transition;
-          if (transition$$1) {
+          var transition = vnode.data && vnode.data.transition;
+          if (transition) {
               vnode.data.show = true;
               if (value) {
                   enter(vnode, function () {
@@ -7102,7 +7067,7 @@
               el.style.display = value ? el.__vOriginalDisplay : 'none';
           }
       },
-      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+      unbind: function (el, binding, vnode, oldVnode, isDestroy) {
           if (!isDestroy) {
               el.style.display = el.__vOriginalDisplay;
           }
@@ -7153,8 +7118,8 @@
       // events.
       // extract listeners and pass them directly to the transition methods
       var listeners = options._parentListeners;
-      for (var key$1 in listeners) {
-          data[camelize(key$1)] = listeners[key$1];
+      for (var key in listeners) {
+          data[camelize(key)] = listeners[key];
       }
       return data;
   }
@@ -7182,9 +7147,8 @@
       name: 'transition',
       props: transitionProps,
       abstract: true,
-      render: function render(h) {
-          var this$1 = this;
-
+      render: function (h) {
+          var _this = this;
           var children = this.$slots.default;
           if (!children) {
               return;
@@ -7226,7 +7190,7 @@
           // ensure a key that is unique to the vnode type and to this transition
           // component instance. This key will be used to remove pending leaving nodes
           // during entering.
-          var id = "__transition-" + (this._uid) + "-";
+          var id = "__transition-" + this._uid + "-";
           child.key =
               child.key == null
                   ? child.isComment
@@ -7260,8 +7224,8 @@
                   // return placeholder node and queue update when leave finishes
                   this._leaving = true;
                   mergeVNodeHook(oldData, 'afterLeave', function () {
-                      this$1._leaving = false;
-                      this$1.$forceUpdate();
+                      _this._leaving = false;
+                      _this.$forceUpdate();
                   });
                   return placeholder(h, rawChild);
               }
@@ -7269,14 +7233,14 @@
                   if (isAsyncPlaceholder(child)) {
                       return oldRawChild;
                   }
-                  var delayedLeave;
+                  var delayedLeave_1;
                   var performLeave = function () {
-                      delayedLeave();
+                      delayedLeave_1();
                   };
                   mergeVNodeHook(data, 'afterEnter', performLeave);
                   mergeVNodeHook(data, 'enterCancelled', performLeave);
                   mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                      delayedLeave = leave;
+                      delayedLeave_1 = leave;
                   });
               }
           }
@@ -7293,22 +7257,21 @@
   delete props.mode;
   var TransitionGroup = {
       props: props,
-      beforeMount: function beforeMount() {
-          var this$1 = this;
-
+      beforeMount: function () {
+          var _this = this;
           var update = this._update;
           this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(this$1);
+              var restoreActiveInstance = setActiveInstance(_this);
               // force removing pass
-              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              _this.__patch__(_this._vnode, _this.kept, false, // hydrating
               true // removeOnly (!important, avoids unnecessary moves)
               );
-              this$1._vnode = this$1.kept;
+              _this._vnode = _this.kept;
               restoreActiveInstance();
-              update.call(this$1, vnode, hydrating);
+              update.call(_this, vnode, hydrating);
           };
       },
-      render: function render(h) {
+      render: function (h) {
           var tag = this.tag || this.$vnode.data.tag || 'span';
           var map = Object.create(null);
           var prevChildren = (this.prevChildren = this.children);
@@ -7325,27 +7288,27 @@
                   }
                   else {
                       var opts = c.componentOptions;
-                      var name = opts
+                      var name_1 = opts
                           ? opts.Ctor.options.name || opts.tag || ''
                           : c.tag;
-                      warn(("<transition-group> children must be keyed: <" + name + ">"));
+                      warn("<transition-group> children must be keyed: <" + name_1 + ">");
                   }
               }
           }
           if (prevChildren) {
               var kept = [];
               var removed = [];
-              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                  var c$1 = prevChildren[i$1];
-                  c$1.data.transition = transitionData;
+              for (var i = 0; i < prevChildren.length; i++) {
+                  var c = prevChildren[i];
+                  c.data.transition = transitionData;
                   // @ts-ignore
-                  c$1.data.pos = c$1.elm.getBoundingClientRect();
+                  c.data.pos = c.elm.getBoundingClientRect();
                   // @ts-ignore
-                  if (map[c$1.key]) {
-                      kept.push(c$1);
+                  if (map[c.key]) {
+                      kept.push(c);
                   }
                   else {
-                      removed.push(c$1);
+                      removed.push(c);
                   }
               }
               this.kept = h(tag, null, kept);
@@ -7353,7 +7316,7 @@
           }
           return h(tag, null, children);
       },
-      updated: function updated() {
+      updated: function () {
           var children = this.prevChildren;
           var moveClass = this.moveClass || (this.name || 'v') + '-move';
           if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7371,25 +7334,25 @@
           children.forEach(function (c) {
               // @ts-ignore
               if (c.data.moved) {
-                  var el = c.elm;
-                  var s = el.style;
-                  addTransitionClass(el, moveClass);
+                  var el_1 = c.elm;
+                  var s = el_1.style;
+                  addTransitionClass(el_1, moveClass);
                   s.transform = s.WebkitTransform = s.transitionDuration = '';
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
+                  el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
+                      if (e && e.target !== el_1) {
                           return;
                       }
                       if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
+                          el_1.removeEventListener(transitionEndEvent, cb);
+                          el_1._moveCb = null;
+                          removeTransitionClass(el_1, moveClass);
                       }
                   }));
               }
           });
       },
       methods: {
-          hasMove: function hasMove(el, moveClass) {
+          hasMove: function (el, moveClass) {
               /* istanbul ignore if */
               if (!hasTransition) {
                   return false;
@@ -7502,4 +7465,4 @@
 
   return Vue;
 
-}));
+})));
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
index 557c86bb2f1..9b4bf801bbf 100644
--- a/dist/vue.runtime.min.js
+++ b/dist/vue.runtime.min.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t=t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R,U="__proto__"in{},H="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),z=H&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0,X=(z&&z.indexOf("android"),z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===B),G=(z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z),z&&z.match(/firefox\/(\d+)/)),Z={}.watch,J=!1;if(H)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===R&&(R=!H&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),R},tt=H&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var dt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=ht[t];M(mt,t,function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i})});var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(U?(e=mt,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var xt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&Ot(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?Ot(r,o):o}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}xt.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},P.forEach(function(t){xt[t]=St}),N.forEach(function(t){xt[t+"s"]=Et}),xt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},xt.provide=kt;var jt=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Tt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=xt[r]||jt;a[r]=o(t[r],e[r],n,r)}return a}function It(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Dt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Mt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Mt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Pt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Nt=/^\s*function (\w+)/;function Pt(t){var e=t&&t.toString().match(Nt);return e?e[1]:""}function Lt(t,e){return Pt(t)===Pt(e)}function Mt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Ft(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Ut(t,r,"errorCaptured hook")}}Ut(t,e,n)}finally{ut()}}function Rt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Ft(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Ft(t,r,o)}return i}function Ut(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e,null,"config.errorHandler")}Ht(t,e,n)}function Ht(t,e,n){if(!H&&!V||"undefined"==typeof console)throw t;console.error(t)}var Vt,Bt=!1,zt=[],Wt=!1;function qt(){Wt=!1;var t=zt.slice(0);zt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Kt=Promise.resolve();Vt=function(){Kt.then(qt),X&&setTimeout(k)},Bt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(qt)}:function(){setTimeout(qt,0)};else{var Xt=1,Gt=new MutationObserver(qt),Zt=document.createTextNode(String(Xt));Gt.observe(Zt,{characterData:!0}),Vt=function(){Xt=(Xt+1)%2,Zt.data=String(Xt)},Bt=!0}function Jt(t,e){var n;if(zt.push(function(){if(t)try{t.call(e)}catch(t){Ft(t,e,"nextTick")}else n&&n(e)}),Wt||(Wt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Qt=new nt;function Yt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Qt),Qt.clear()}var te=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function ee(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Rt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Rt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ne(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=te(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=ee(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=te(c)).name,n[c],f.capture)}function re(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=ee([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=ee([s,c]),a.merged=!0,t[o]=a}function oe(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ie(t){return o(t)?[pt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ae((u=t(u,(a||"")+"_"+c))[0])&&ae(f)&&(s[l]=pt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ae(f)?s[l]=pt(f.text+u):""!==u&&s.push(pt(u)):ae(u)&&ae(f)?s[l]=pt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ae(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function ce(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ue)&&delete n[u];return n}function ue(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=fe(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=de(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function fe(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ie(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function de(t,e){return function(){return t[e]}}function pe(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ve(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function he(t){return It(this.$options,"filters",t)||E}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?me(o,r):i?me(i,t):r?$(r)!==e:void 0}function ge(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function _e(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(Ce(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function be(t,e,n){return Ce(t,"__once__"+e+(n?"_"+n:""),!0),t}function Ce(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&$e(t[r],e+"_"+r,n);else $e(t,e,n)}function $e(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function xe(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Oe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=be,t._n=f,t._s=l,t._l=pe,t._t=ve,t._q=j,t._i=T,t._m=_e,t._f=he,t._k=ye,t._b=ge,t._v=pt,t._e=dt,t._u=Ae,t._g=we,t._d=xe,t._p=Oe}function Se(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=se(u.inject,i),this.slots=function(){return c.$slots||le(e.scopedSlots,c.$slots=ce(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Me(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Me(s,t,e,n,r,f)}}function Ee(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function je(t,e){for(var n in e)t[_(n)]=e[n]}ke(Se.prototype);var Te={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Te.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Dt(p,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,qe(e,r,h),u&&(e.$slots=ce(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Je(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Ye.push(e)):Ze(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Ge(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Je(e,"deactivated")}}(e,!0):e.$destroy())}},Ie=Object.keys(Te);function De(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Re;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Ue(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Ue(m.error,o)),n(m.loading)&&(t.loadingComp=Ue(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},bn(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);oe(a,c,u,l,!0)||oe(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Dt(l,u,r||t);else n(o.attrs)&&je(c,o.attrs),n(o.props)&&je(c,o.props);var f=new Se(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Ee(d,o,f.parent,s);if(Array.isArray(d)){for(var p=ie(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Ee(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Ie.length;n++){var r=Ie[n],o=e[r],i=Te[r];o===i||o&&o._merged||(e[r]=o?Ne(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function Ne(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Pe=1,Le=2;function Me(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return dt();n(a)&&n(a.is)&&(o=a.is);if(!o)return dt();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=ie(s):c===Pe&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=It(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):De(f,a,t,s,o)}else u=De(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Yt(t.style);i(t.class)&&Yt(t.class)}(a),u):dt()}(t,a,s,c,u)}var Fe,Re=null;function Ue(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function He(t){return t.isComment&&t.asyncFactory}function Ve(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||He(r)))return r}}function Be(t,e){Fe.$on(t,e)}function ze(t,e){Fe.$off(t,e)}function We(t,e){var n=Fe;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function qe(t,e,n){Fe=t,ne(e,n||{},Be,ze,We,t),Fe=void 0}var Ke=null;function Xe(t){var e=Ke;return Ke=t,function(){Ke=e}}function Ge(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ze(t,e){if(e){if(t._directInactive=!1,Ge(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ze(t.$children[n]);Je(t,"activated")}}function Je(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Rt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Qe=[],Ye=[],tn={},en=!1,nn=!1,rn=0;var on=0,an=Date.now;if(H&&!W){var sn=window.performance;sn&&"function"==typeof sn.now&&an()>document.createEvent("Event").timeStamp&&(an=function(){return sn.now()})}function cn(){var t,e;for(on=an(),nn=!0,Qe.sort(function(t,e){return t.id-e.id}),rn=0;rn<Qe.length;rn++)(t=Qe[rn]).before&&t.before(),e=t.id,tn[e]=null,t.run();var n=Ye.slice(),r=Qe.slice();rn=Qe.length=Ye.length=0,tn={},en=nn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ze(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Je(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var un=0,ln=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};ln.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ft(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Yt(t),ut(),this.cleanupDeps()}return t},ln.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},ln.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},ln.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==tn[e]){if(tn[e]=!0,nn){for(var n=Qe.length-1;n>rn&&Qe[n].id>t.id;)n--;Qe.splice(n+1,0,t)}else Qe.push(t);en||(en=!0,Jt(cn))}}(this)},ln.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ft(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},ln.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},ln.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},ln.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var fn={enumerable:!0,configurable:!0,get:k,set:k};function dn(t,e,n){fn.get=function(){return this[e][n]},fn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,fn)}function pn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Dt(i,e,n,t);$t(r,i,a),i in t||dn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(var n in e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Ft(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props,o=(t.$options.methods,n.length);for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&dn(t,"_data",i))}var a;Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new ln(t,a||k,k,vn)),o in t||hn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)gn(t,n,r[o]);else gn(t,n,r)}}(t,e.watch)}var vn={lazy:!0};function hn(t,e,n){var r=!Y();"function"==typeof n?(fn.get=r?mn(e):yn(n),fn.set=k):(fn.get=n.get?r&&!1!==n.cache?mn(e):yn(n.get):k,fn.set=n.set||k),Object.defineProperty(t,e,fn)}function mn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function yn(t){return function(){return t.call(this,this)}}function gn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var _n=0;function bn(t){var e=t.options;if(t.super){var n=bn(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Tt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function Cn(t){this._init(t)}function $n(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Tt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)dn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)hn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function xn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&On(n,i,r,o)}}}function On(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=_n++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(bn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&qe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=ce(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Me(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Me(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Je(n,"beforeCreate"),function(t){var e=se(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach(function(n){$t(t,n,e[n])}),_t(!0))}(n),pn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Je(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(Cn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return gn(this,t,e,n);(n=n||{}).user=!0;var r=new ln(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Ft(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(Cn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Rt(e[o],this,n,this,r)}return this}}(Cn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Xe(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Je(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Je(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(Cn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Jt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=le(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Re=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ft(n,e,"render"),t=e._vnode}finally{Re=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=dt()),t.parent=o,t}}(Cn);var kn=[String,RegExp,Array],Sn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)On(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){xn(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){xn(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Ve(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Jt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,Sn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),$n(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(Cn),Object.defineProperty(Cn.prototype,"$isServer",{get:Y}),Object.defineProperty(Cn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(Cn,"FunctionalRenderContext",{value:Se}),Cn.version="2.6.12";var En=d("style,class"),jn=d("input,textarea,option,select,progress"),Tn=d("contenteditable,draggable,spellcheck"),In=d("events,caret,typing,plaintext-only"),Dn=function(t,e){return Fn(e)||"false"===e?"false":"contenteditable"===t&&In(e)?e:"true"},Nn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Pn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Mn=function(t){return Ln(t)?t.slice(6,t.length):""},Fn=function(t){return null==t||!1===t};function Rn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Un(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Un(e,r.data));return function(t,e){if(n(t)||n(e))return Hn(t,Vn(e));return""}(e.staticClass,e.class)}function Un(t,e){return{staticClass:Hn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Hn(t,e){return t?e?t+" "+e:t:e||""}function Vn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Vn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},zn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Wn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),qn=function(t){return zn(t)||Wn(t)};var Kn=Object.create(null);var Xn=d("text,number,password,search,email,tel,url");var Gn=Object.freeze({createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create:function(t,e){Jn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Jn(t,!0),Jn(e))},destroy:function(t){Jn(t,!0)}};function Jn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Qn=new lt("",{},[]),Yn=["create","activate","update","remove","destroy"];function tr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Xn(o)&&Xn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function er(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var nr={create:rr,update:rr,destroy:function(t){rr(t,Qn)}};function rr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Qn,a=e===Qn,s=ir(t.data.directives,t.context),c=ir(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,sr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(sr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)sr(u[n],"inserted",e,t)};i?re(e,"insert",f):f()}l.length&&re(e,"postpatch",function(){for(var n=0;n<l.length;n++)sr(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||sr(s[n],"unbind",t,t,a)}(t,e)}var or=Object.create(null);function ir(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=or),o[ar(r)]=r,r.def=It(e.$options,"directives",r.name);return o}function ar(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function sr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ft(r,n.context,"directive "+t.name+" "+e+" hook")}}var cr=[Zn,nr];function ur(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&lr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&lr(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Pn,Mn(i)):Tn(i)||s.removeAttribute(i))}}function lr(t,e,n,r){r||t.tagName.indexOf("-")>-1?fr(t,e,n):Nn(e)?Fn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,Dn(e,n)):Ln(e)?Fn(n)?t.removeAttributeNS(Pn,Mn(e)):t.setAttributeNS(Pn,e,n):fr(t,e,n)}function fr(t,e,n){if(Fn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var dr={create:ur,update:ur};function pr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Rn(r),c=o._transitionClasses;n(c)&&(s=Hn(s,Vn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var vr,hr={create:pr,update:pr},mr="__r",yr="__c";function gr(t,e,n){var r=vr;return function o(){null!==e.apply(null,arguments)&&Cr(t,o,n,r)}}var _r=Bt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var o=on,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}vr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||vr).removeEventListener(t,e._wrapper||e,n)}function $r(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};vr=r.elm,function(t){if(n(t[mr])){var e=W?"change":"input";t[e]=[].concat(t[mr],t[e]||[]),delete t[mr]}n(t[yr])&&(t.change=[].concat(t[yr],t.change||[]),delete t[yr])}(o),ne(o,i,br,Cr,gr,r.context),vr=void 0}}var wr,Ar={create:$r,update:$r};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Wn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:xr,update:xr},Sr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?O(t):"string"==typeof t?Sr(t):t}var Tr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty($(e),n.replace(Dr,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Lr=y(function(t){if(Tr=Tr||document.createElement("div").style,"filter"!==(t=_(t))&&t in Tr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Tr)return r}});function Mr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=jr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Nr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Vr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),zr=H&&!q,Wr="transition",qr="animation",Kr="transition",Xr="transitionend",Gr="animation",Zr="animationend";zr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Kr="WebkitTransition",Xr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Gr="WebkitAnimation",Zr="webkitAnimationEnd"));var Jr=H?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Qr(t){Jr(function(){Jr(t)})}function Yr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Ur(t,e))}function to(t,e){t._transitionClasses&&v(t._transitionClasses,e),Hr(t,e)}function eo(t,e,n){var r=ro(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Wr?Xr:Zr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var no=/\b(transform|all)(,|$)/;function ro(t,e){var n,r=window.getComputedStyle(t),o=(r[Kr+"Delay"]||"").split(", "),i=(r[Kr+"Duration"]||"").split(", "),a=oo(o,i),s=(r[Gr+"Delay"]||"").split(", "),c=(r[Gr+"Duration"]||"").split(", "),u=oo(s,c),l=0,f=0;return e===Wr?a>0&&(n=Wr,l=a,f=i.length):e===qr?u>0&&(n=qr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Wr:qr:null)?n===Wr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Wr&&no.test(r[Kr+"Property"])}}function oo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return io(e)+io(t[n])}))}function io(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ao(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Vr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ke,O=Ke.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&p?p:u,E=k&&h?h:d,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=uo(D),R=o._enterCb=I(function(){M&&(to(o,j),to(o,E)),R.cancelled?(M&&to(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||re(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Yr(o,S),Yr(o,E),Qr(function(){to(o,S),R.cancelled||(Yr(o,j),F||(co(L)?setTimeout(R,L):eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function so(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Vr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=uo(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(to(o,l),to(o,d)),$.cancelled?(_&&to(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Yr(o,u),Yr(o,d),Qr(function(){to(o,u),$.cancelled||(Yr(o,l),b||(co(C)?setTimeout($,C):eo(o,c,$)))})),v&&v(o,$),_||b||$())}}function co(t){return"number"==typeof t&&!isNaN(t)}function uo(t){if(e(t))return!1;var r=t.fns;return n(r)?uo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function lo(t,e){!0!==e.data.show&&ao(e)}var fo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Yn.length;++i)for(s[Yn[i]]=[],a=0;a<c.length;++a)n(c[a][Yn[i]])&&s[Yn[i]].push(c[a][Yn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Qn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Jn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Qn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Qn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&tr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:tr(h,g)?(A(h,g,i,o,p),h=r[++d],g=o[++p]):tr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):tr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):tr(m,g)?(A(m,g,i,o,p),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=er(r,d,v)),e(c=n(g.key)?s[g.key]:w(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):tr(l=r[c],g)?(A(l,g,i,o,p),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=d("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!k(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Yt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&tr(t,o))A(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Qn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Jn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Gn,modules:[dr,hr,Ar,kr,Fr,H?{create:lo,activate:lo,remove:function(t,e){!0!==t.data.show?so(t,e):e()}}:{}].concat(cr)});q&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&bo(t,"input")});var po={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?re(n,"postpatch",function(){po.componentUpdated(t,e,n)}):vo(t,e,n.context),t._vOptions=[].map.call(t.options,yo)):("textarea"===n.tag||Xn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",go),t.addEventListener("compositionend",_o),t.addEventListener("change",_o),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){vo(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,yo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return mo(t,o)}):e.value!==e.oldValue&&mo(e.value,o))&&bo(t,"change")}}};function vo(t,e,n){ho(t,e,n),(W||K)&&setTimeout(function(){ho(t,e,n)},0)}function ho(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,yo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(yo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function mo(t,e){return e.every(function(e){return!j(e,t)})}function yo(t){return"_value"in t?t._value:t.value}function go(t){t.target.composing=!0}function _o(t){t.target.composing&&(t.target.composing=!1,bo(t.target,"input"))}function bo(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Co(t){return!t.componentInstance||t.data&&t.data.transition?t:Co(t.componentInstance._vnode)}var $o={model:po,show:{bind:function(t,e,n){var r=e.value,o=(n=Co(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,ao(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=Co(n)).data&&n.data.transition?(n.data.show=!0,r?ao(n,function(){t.style.display=t.__vOriginalDisplay}):so(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},wo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ao(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ao(Ve(e.children)):t}function xo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Oo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var ko=function(t){return t.tag||He(t)},So=function(t){return"show"===t.name},Eo={name:"transition",props:wo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(ko)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Ao(i);if(!a)return i;if(this._leaving)return Oo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=xo(this),u=this._vnode,l=Ao(u);if(a.data.directives&&a.data.directives.some(So)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!He(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,re(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Oo(t,i);if("in-out"===r){if(He(a))return u;var d,p=function(){d()};re(c,"afterEnter",p),re(c,"enterCancelled",p),re(f,"delayLeave",function(t){d=t})}}return i}}},jo=x({tag:String,moveClass:String},wo);function To(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Io(t){t.data.newPos=t.elm.getBoundingClientRect()}function Do(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete jo.mode;var No={Transition:Eo,TransitionGroup:{props:jo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Xe(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=xo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(To),t.forEach(Io),t.forEach(Do),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Yr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Xr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Xr,t),n._moveCb=null,to(n,e))})}}))},methods:{hasMove:function(t,e){if(!zr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Hr(n,t)}),Ur(n,e),n.style.display="none",this.$el.appendChild(n);var r=ro(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return Cn.config.mustUseProp=function(t,e,n){return"value"===n&&jn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},Cn.config.isReservedTag=qn,Cn.config.isReservedAttr=En,Cn.config.getTagNamespace=function(t){return Wn(t)?"svg":"math"===t?"math":void 0},Cn.config.isUnknownElement=function(t){if(!H)return!0;if(qn(t))return!1;if(t=t.toLowerCase(),null!=Kn[t])return Kn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Kn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Kn[t]=/HTMLUnknownElement/.test(e.toString())},x(Cn.options.directives,$o),x(Cn.options.components,No),Cn.prototype.__patch__=H?fo:k,Cn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),Je(t,"beforeMount"),r=function(){t._update(t._render(),n)},new ln(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Je(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Je(t,"mounted")),t}(this,t=t&&H?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},H&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",Cn)},0),Cn});
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),H=U&&window.navigator.userAgent.toLowerCase(),z=H&&/msie|trident/.test(H),W=H&&H.indexOf("msie 9.0")>0,q=H&&H.indexOf("edge/")>0;H&&H.indexOf("android");var K=H&&/iphone|ipad|ipod|ios/.test(H)||"ios"===B;H&&/chrome\/\d+/.test(H),H&&/phantomjs/.test(H);var X,G=H&&H.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function pt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function wt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var At=L.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):$t(t,n,o));return t}function Ot(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function kt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}At.data=function(t,e,n){return n?Ot(t,e,n):e&&"function"!=typeof e?t:Ot(t,e)},P.forEach(function(t){At[t]=kt}),N.forEach(function(t){At[t+"s"]=St}),At.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},At.props=At.methods=At.inject=At.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},At.provide=Ot;var Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=jt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=At[r]||Et;a[r]=o(t[r],e[r],n,r)}return a}function Tt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Lt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Lt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!V||"undefined"==typeof console)throw t;console.error(t)}var Vt,Bt=!1,Ht=[],zt=!1;function Wt(){zt=!1;var t=Ht.slice(0);Ht.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Vt=function(){qt.then(Wt),K&&setTimeout(k)},Bt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Vt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Bt=!0}function Zt(t,e){var n;if(Ht.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return Tt(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?he(o,r):i?he(i,t):r?$(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?we(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ae(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=j,t._i=T,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=ft,t._u=we,t._g=$e,t._d=Ae,t._p=xe}function ke(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Le(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Le(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=pt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ee(t,e){for(var n in e)t[_(n)]=e[n]}Oe(ke.prototype);var je={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;je.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=It(p,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},Te=Object.keys(je);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Ee(c,o.attrs),n(o.props)&&Ee(c,o.props);var f=new ke(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Te.length;n++){var r=Te[n],o=e[r],i=je[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Pe=2;function Le(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Pe),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Pe?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=Tt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Ve(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function Be(t,e){Me.$on(t,e)}function He(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},Be,He,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:k,set:k};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||k,k,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=k):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):k,ln.set=n.set||k),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=jt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=jt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function $n(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function An(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=$n(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Le(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Le(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=wt,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var On=[String,RegExp,Array],kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:On,exclude:On,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){An(t,function(t){return wn(e,t)})}),this.$watch("exclude",function(e){An(t,function(t){return!wn(e,t)})})},render:function(){var t=this.$slots.default,e=Ve(t),n=e&&e.componentOptions;if(n){var r=$n(n),o=this.include,i=this.exclude;if(o&&(!r||!wn(o,r))||i&&r&&wn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:jt,defineReactive:Ct},t.set=$t,t.delete=wt,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,kn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:ke}),bn.version="2.6.12";var Sn=d("style,class"),En=d("input,textarea,option,select,progress"),jn=d("contenteditable,draggable,spellcheck"),Tn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Pn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Ln=function(t){return Pn(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Vn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Vn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Vn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Hn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Hn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=Tt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Pn(i)?s.removeAttributeNS(Nn,Ln(i)):jn(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):jn(e)?t.setAttribute(e,In(e,n)):Pn(e)?Mn(n)?t.removeAttributeNS(Nn,Ln(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Vn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Bt&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var $r,wr={create:Cr,update:Cr};function Ar(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:Ar,update:Ar},kr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?O(t):"string"==typeof t?kr(t):t}var jr,Tr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(Tr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty($(e),n.replace(Ir,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Pr=y(function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in jr)return r}});function Lr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Er(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Lr,update:Lr},Fr=/\s+/;function Rr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Vr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Hr=U&&!W,zr="transition",Wr="animation",qr="transition",Kr="transitionend",Xr="animation",Gr="animationend";Hr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(qr="WebkitTransition",Kr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Xr="WebkitAnimation",Gr="webkitAnimationEnd"));var Zr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Jr(t){Zr(function(){Zr(t)})}function Qr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Rr(t,e))}function Yr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Ur(t,e)}function to(t,e,n){var r=no(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===zr?Kr:Gr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var eo=/\b(transform|all)(,|$)/;function no(t,e){var n,r=window.getComputedStyle(t),o=(r[qr+"Delay"]||"").split(", "),i=(r[qr+"Duration"]||"").split(", "),a=ro(o,i),s=(r[Xr+"Delay"]||"").split(", "),c=(r[Xr+"Duration"]||"").split(", "),u=ro(s,c),l=0,f=0;return e===zr?a>0&&(n=zr,l=a,f=i.length):e===Wr?u>0&&(n=Wr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?zr:Wr:null)?n===zr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===zr&&eo.test(r[qr+"Property"])}}function ro(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return oo(e)+oo(t[n])}))}function oo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function io(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Vr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=qe,O=qe.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&p?p:u,E=k&&h?h:d,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!W,F=co(D),R=o._enterCb=I(function(){M&&(Yr(o,j),Yr(o,E)),R.cancelled?(M&&Yr(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Qr(o,S),Qr(o,E),Jr(function(){Yr(o,S),R.cancelled||(Qr(o,j),F||(so(L)?setTimeout(R,L):to(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function ao(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Vr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=co(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Yr(o,l),Yr(o,d)),$.cancelled?(_&&Yr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Qr(o,u),Qr(o,d),Jr(function(){Yr(o,u),$.cancelled||(Qr(o,l),b||(so(C)?setTimeout($,C):to(o,c,$)))})),v&&v(o,$),_||b||$())}}function so(t){return"number"==typeof t&&!isNaN(t)}function co(t){if(e(t))return!1;var r=t.fns;return n(r)?co(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function uo(t,e){!0!==e.data.show&&io(e)}var lo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=pt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=pt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?(A(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?(A(m,g,i,o,p),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:w(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?(A(l,g,i,o,p),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=d("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!k(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))A(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Jn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,wr,Or,Mr,U?{create:uo,activate:uo,remove:function(t,e){!0!==t.data.show?ao(t,e):e()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&_o(t,"input")});var fo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){fo.componentUpdated(t,e,n)}):po(t,e,n.context),t._vOptions=[].map.call(t.options,mo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",yo),t.addEventListener("compositionend",go),t.addEventListener("change",go),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){po(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,mo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return ho(t,o)}):e.value!==e.oldValue&&ho(e.value,o))&&_o(t,"change")}}};function po(t,e,n){vo(t,e),(z||q)&&setTimeout(function(){vo(t,e)},0)}function vo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,mo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(mo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function ho(t,e){return e.every(function(e){return!j(e,t)})}function mo(t){return"_value"in t?t._value:t.value}function yo(t){t.target.composing=!0}function go(t){t.target.composing&&(t.target.composing=!1,_o(t.target,"input"))}function _o(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function bo(t){return!t.componentInstance||t.data&&t.data.transition?t:bo(t.componentInstance._vnode)}var Co={model:fo,show:{bind:function(t,e,n){var r=e.value,o=(n=bo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,io(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=bo(n)).data&&n.data.transition?(n.data.show=!0,r?io(n,function(){t.style.display=t.__vOriginalDisplay}):ao(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},$o={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function wo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?wo(Ve(e.children)):t}function Ao(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function xo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Oo=function(t){return t.tag||Ue(t)},ko=function(t){return"show"===t.name},So={name:"transition",props:$o,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Oo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=wo(i);if(!a)return i;if(this._leaving)return xo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ao(this),u=this._vnode,l=wo(u);if(a.data.directives&&a.data.directives.some(ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),xo(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Eo=x({tag:String,moveClass:String},$o);function jo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function To(t){t.data.newPos=t.elm.getBoundingClientRect()}function Io(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Eo.mode;var Do={Transition:So,TransitionGroup:{props:Eo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ao(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(jo),t.forEach(To),t.forEach(Io),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Qr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Kr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Kr,t),n._moveCb=null,Yr(n,e))})}}))},methods:{hasMove:function(t,e){if(!Hr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Ur(n,t)}),Rr(n,e),n.style.display="none",this.$el.appendChild(n);var r=no(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return bn.config.mustUseProp=function(t,e,n){return"value"===n&&En(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Co),x(bn.options.components,Do),bn.prototype.__patch__=U?lo:k,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",bn)},0),bn});
\ No newline at end of file
diff --git a/package.json b/package.json
index b145e0a8ca2..61fe0e1fd30 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,12 @@
     "@babel/plugin-transform-flow-strip-types": "^7.0.0",
     "@babel/preset-env": "^7.0.0",
     "@babel/register": "^7.0.0",
+    "@rollup/plugin-alias": "^3.1.2",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-buble": "^0.21.3",
+    "@rollup/plugin-commonjs": "^18.0.0",
+    "@rollup/plugin-node-resolve": "^11.2.1",
+    "@rollup/plugin-replace": "^2.4.2",
     "@types/jasmine": "^3.6.9",
     "@types/mocha": "^8.2.2",
     "@types/node": "^12.12.0",
@@ -127,19 +133,14 @@
     "phantomjs-prebuilt": "^2.1.14",
     "puppeteer": "^1.11.0",
     "resolve": "^1.3.3",
-    "rollup": "^1.0.0",
-    "rollup-plugin-alias": "^1.3.1",
-    "rollup-plugin-buble": "^0.19.6",
-    "rollup-plugin-commonjs": "^9.2.0",
-    "rollup-plugin-flow-no-whitespace": "^1.0.0",
-    "rollup-plugin-node-resolve": "^4.0.0",
-    "rollup-plugin-replace": "^2.0.0",
+    "rollup": "^2.44.0",
     "rollup-plugin-typescript2": "^0.30.0",
     "selenium-server": "^2.53.1",
     "serialize-javascript": "^3.1.0",
     "shelljs": "^0.8.1",
     "terser": "^3.10.2",
     "ts-loader": "^8.1.0",
+    "tslib": "^2.2.0",
     "typescript": "^4.2.2",
     "webpack": "~4.28.4",
     "weex-js-runtime": "^0.23.6",
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 51863b4f052..979fd652b07 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -1,8 +1,8 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
-  (global = global || self, global.renderVueComponentToString = factory());
-}(this, function () { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.renderVueComponentToString = factory());
+}(this, (function () { 'use strict';
 
   /* @flow */
   var emptyObject = Object.freeze({});
@@ -105,7 +105,7 @@
   /**
    * Remove an item from an array.
    */
-  function remove(arr, item) {
+  function remove$1(arr, item) {
       if (arr.length) {
           var index = arr.indexOf(item);
           if (index > -1) {
@@ -150,31 +150,6 @@
   var hyphenate = cached(function (str) {
       return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-  /* istanbul ignore next */
-  function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          var l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
-  }
-  function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
-  }
-  // @ts-expect-error bind cannot be `undefined`
-  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Mix properties into target object.
    */
@@ -202,7 +177,7 @@
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop(a, b, c) { }
+  function noop$1(a, b, c) { }
   /**
    * Always return false.
    */
@@ -281,18 +256,6 @@
       }
       return -1;
   }
-  /**
-   * Ensure a function is called only once.
-   */
-  function once(fn) {
-      var called = false;
-      return function () {
-          if (!called) {
-              called = true;
-              fn.apply(this, arguments);
-          }
-      };
-  }
 
   /* @flow */
   var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
@@ -382,7 +345,7 @@
   /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap('style,class');
+  makeMap('style,class');
   // attributes that should be using props for binding
   var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
@@ -412,22 +375,22 @@
   };
 
   /* @flow */
-  function renderAttrs(node) {
+  function renderAttrs$1(node) {
       var attrs = node.data.attrs;
       var res = '';
       var opts = node.parent && node.parent.componentOptions;
       if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-          var parent = node.parent;
-          while (isDef(parent)) {
+          var parent_1 = node.parent;
+          while (isDef(parent_1)) {
               // Stop fallthrough in case parent has inheritAttrs option set to false
-              if (parent.componentOptions &&
-                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
+              if (parent_1.componentOptions &&
+                  parent_1.componentOptions.Ctor.options.inheritAttrs === false) {
                   break;
               }
-              if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                  attrs = extend(extend({}, attrs), parent.data.attrs);
+              if (isDef(parent_1.data) && isDef(parent_1.data.attrs)) {
+                  attrs = extend(extend({}, attrs), parent_1.data.attrs);
               }
-              parent = parent.parent;
+              parent_1 = parent_1.parent;
           }
       }
       if (isUndef(attrs)) {
@@ -448,55 +411,57 @@
   function renderAttr(key, value) {
       if (isBooleanAttr(key)) {
           if (!isFalsyAttrValue(value)) {
-              return (" " + key + "=\"" + key + "\"");
+              return " " + key + "=\"" + key + "\"";
           }
       }
       else if (isEnumeratedAttr(key)) {
-          return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"");
+          return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
       }
       else if (!isFalsyAttrValue(value)) {
-          return (" " + key + "=\"" + (escape(String(value))) + "\"");
+          return " " + key + "=\"" + escape(String(value)) + "\"";
       }
       return '';
   }
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-      return this.componentInstance;
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
+  var VNode = /** @class */ (function () {
+      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      Object.defineProperty(VNode.prototype, "child", {
+          // DEPRECATED: alias for componentInstance for backwards compat.
+          /* istanbul ignore next */
+          get: function () {
+              return this.componentInstance;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return VNode;
+  }());
   var createEmptyVNode = function (text) {
-      if ( text === void 0 ) text = '';
-
+      if (text === void 0) { text = ''; }
       var node = new VNode();
       node.text = text;
       node.isComment = true;
@@ -530,7 +495,7 @@
   }
 
   /* @flow */
-  function renderDOMProps(node) {
+  function renderDOMProps$1(node) {
       var props = node.data.domProps;
       var res = '';
       var parent = node.parent;
@@ -604,21 +569,24 @@
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-  var isPhantomJS = UA && /phantomjs/.test(UA);
-  var isFF = UA && UA.match(/firefox\/(\d+)/);
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
   // @ts-ignore
   var nativeWatch = {}.watch;
+  var supportsPassive = false;
   if (inBrowser) {
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function get() {
+              get: function () {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
               },
           }); // https://github.com/facebook/flow/issues/285
           // @ts-ignore
@@ -644,9 +612,6 @@
       }
       return _isServer;
   };
-  // detect devtools
-  // @ts-ignore TODO decalre this types
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
   /* istanbul ignore next */
   function isNative(Ctor) {
       return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
@@ -662,20 +627,19 @@
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
+      _Set = /** @class */ (function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function has (key) {
+          Set.prototype.has = function (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function add (key) {
+          Set.prototype.add = function (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function clear () {
+          Set.prototype.clear = function () {
               this.set = Object.create(null);
           };
-
           return Set;
       }());
   }
@@ -754,7 +718,7 @@
       /**
        * Get the namespace of an element
        */
-      getTagNamespace: noop,
+      getTagNamespace: noop$1,
       /**
        * Parse the real tag name for the specific platform.
        */
@@ -776,22 +740,24 @@
   };
 
   /* @flow */
-  var warn = noop;
-  var tip = noop;
+  var warn$2 = noop$1;
+  var tip = noop$1;
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-      warn = function (msg, vm) {
+      var hasConsole_1 = typeof console !== 'undefined';
+      var classifyRE_1 = /(?:^|[-_])(\w)/g;
+      var classify_1 = function (str) {
+          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+      };
+      warn$2 = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
+          if (hasConsole_1 && !config.silent) {
+              console.error("[Vue warn]: " + msg + trace);
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole && !config.silent) {
+          if (hasConsole_1 && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -814,10 +780,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
+          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+              (file && includeFile !== false ? " at " + file : ''));
       };
-      var repeat = function (str, n) {
+      var repeat_1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -851,13 +817,15 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
+                      .map(function (vm, i) {
+                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                          : formatComponentName(vm));
+                  })
                       .join('\n'));
           }
           else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+              return "\n\n(found in " + formatComponentName(vm) + ")";
           }
       };
   }
@@ -867,28 +835,31 @@
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep() {
-      this.id = uid++;
-      this.subs = [];
-  };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
-  };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove(this.subs, sub);
-  };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
-      }
-  };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
+  var Dep = /** @class */ (function () {
+      function Dep() {
+          this.id = uid++;
+          this.subs = [];
       }
-  };
+      Dep.prototype.addSub = function (sub) {
+          this.subs.push(sub);
+      };
+      Dep.prototype.removeSub = function (sub) {
+          remove$1(this.subs, sub);
+      };
+      Dep.prototype.depend = function () {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      };
+      Dep.prototype.notify = function () {
+          // stabilize the subscriber list first
+          var subs = this.subs.slice();
+          for (var i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      };
+      return Dep;
+  }());
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
@@ -924,9 +895,12 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
+          var arguments$1 = arguments;
 
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments$1[_i];
+          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -962,43 +936,46 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
+  var Observer = /** @class */ (function () {
+      function Observer(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
           }
           else {
-              copyAugment(value, arrayMethods, arrayKeys);
+              this.walk(value);
           }
-          this.observeArray(value);
-      }
-      else {
-          this.walk(value);
       }
-  };
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive$$1(obj, keys[i]);
-      }
-  };
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
-      }
-  };
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      Observer.prototype.walk = function (obj) {
+          var keys = Object.keys(obj);
+          for (var i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      };
+      /**
+       * Observe a list of Array items.
+       */
+      Observer.prototype.observeArray = function (items) {
+          for (var i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      };
+      return Observer;
+  }());
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -1048,7 +1025,7 @@
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+  function defineReactive(obj, key, val, customSetter, shallow) {
       var dep = new Dep();
       var property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
@@ -1107,8 +1084,8 @@
    * already exist.
    */
   function set(target, key, val) {
-      if (isUndef(target) || isPrimitive(target)) {
-          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -1122,7 +1099,7 @@
       var ob = target.__ob__;
       // @ts-ignore
       if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                   'at runtime - declare it upfront in the data option.');
           return val;
       }
@@ -1130,7 +1107,7 @@
           target[key] = val;
           return val;
       }
-      defineReactive$$1(ob.value, key, val);
+      defineReactive(ob.value, key, val);
       ob.dep.notify();
       return val;
   }
@@ -1139,7 +1116,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1161,7 +1138,7 @@
   {
       strats.el = strats.propsData = function (parent, child, vm, key) {
           if (!vm) {
-              warn("option \"" + key + "\" can only be used during instance " +
+              warn$2("option \"" + key + "\" can only be used during instance " +
                   'creation with the `new` keyword.');
           }
           return defaultStrat(parent, child);
@@ -1237,7 +1214,7 @@
   strats.data = function (parentVal, childVal, vm) {
       if (!vm) {
           if (childVal && typeof childVal !== 'function') {
-              warn('The "data" option should be a function ' +
+              warn$2('The "data" option should be a function ' +
                       'that returns a per-instance value in component ' +
                       'definitions.', vm);
               return parentVal;
@@ -1249,7 +1226,7 @@
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook(parentVal, childVal) {
+  function mergeHook$1(parentVal, childVal) {
       var res = childVal
           ? parentVal
               ? parentVal.concat(childVal)
@@ -1269,7 +1246,7 @@
       return res;
   }
   LIFECYCLE_HOOKS.forEach(function (hook) {
-      strats[hook] = mergeHook;
+      strats[hook] = mergeHook$1;
   });
   /**
    * Assets
@@ -1315,14 +1292,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key$1] = parent
-              ? parent.concat(child)
+      for (var key_1 in childVal) {
+          var parent_1 = ret[key_1];
+          var child = childVal[key_1];
+          if (parent_1 && !Array.isArray(parent_1)) {
+              parent_1 = [parent_1];
+          }
+          ret[key_1] = parent_1
+              ? parent_1.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1360,14 +1337,14 @@
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-          warn('Invalid component name: "' +
+      if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+          warn$2('Invalid component name: "' +
               name +
               '". Component names ' +
               'should conform to valid custom element name in html5 specification.');
       }
       if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn('Do not use built-in or reserved HTML elements as component ' +
+          warn$2('Do not use built-in or reserved HTML elements as component ' +
               'id: ' +
               name);
       }
@@ -1391,7 +1368,7 @@
                   res[name] = { type: null };
               }
               else {
-                  warn('props must be strings when using array syntax.');
+                  warn$2('props must be strings when using array syntax.');
               }
           }
       }
@@ -1403,8 +1380,8 @@
           }
       }
       else {
-          warn("Invalid value for option \"props\": expected an Array or an Object, " +
-              "but got " + (toRawType(props)) + ".", vm);
+          warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
+              ("but got " + toRawType(props) + "."), vm);
       }
       options.props = res;
   }
@@ -1430,8 +1407,8 @@
           }
       }
       else {
-          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-              "but got " + (toRawType(inject)) + ".", vm);
+          warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
+              ("but got " + toRawType(inject) + "."), vm);
       }
   }
   /**
@@ -1441,17 +1418,17 @@
       var dirs = options.directives;
       if (dirs) {
           for (var key in dirs) {
-              var def$$1 = dirs[key];
-              if (typeof def$$1 === 'function') {
-                  dirs[key] = { bind: def$$1, update: def$$1 };
+              var def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
               }
           }
       }
   }
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
-          warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
+          warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+              ("but got " + toRawType(value) + "."), vm);
       }
   }
   /**
@@ -1522,7 +1499,7 @@
       // fallback to prototype chain
       var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
       if (warnMissing && !res) {
-          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
       }
       return res;
   }
@@ -1573,7 +1550,7 @@
       var def = prop.default;
       // warn against non-factory defaults for Object & Array
       if (isObject(def)) {
-          warn('Invalid default value for prop "' +
+          warn$2('Invalid default value for prop "' +
               key +
               '": ' +
               'Props with type Object/Array must use a factory function ' +
@@ -1598,7 +1575,7 @@
    */
   function assertProp(prop, name, value, vm, absent) {
       if (prop.required && absent) {
-          warn('Missing required prop: "' + name + '"', vm);
+          warn$2('Missing required prop: "' + name + '"', vm);
           return;
       }
       if (value == null && !prop.required) {
@@ -1620,13 +1597,13 @@
       }
       var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
       if (!valid && haveExpectedTypes) {
-          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
           return;
       }
       var validator = prop.validator;
       if (validator) {
           if (!validator(value)) {
-              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
           }
       }
   }
@@ -1653,7 +1630,7 @@
               valid = value instanceof type;
           }
           catch (e) {
-              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
               valid = false;
           }
       }
@@ -1688,7 +1665,7 @@
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
       var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          " Expected " + (expectedTypes.map(capitalize).join(', '));
+          (" Expected " + expectedTypes.map(capitalize).join(', '));
       var expectedType = expectedTypes[0];
       var receivedType = toRawType(value);
       // check if we need to specify expected value
@@ -1696,24 +1673,24 @@
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + (styleValue(value, expectedType));
+          message += " with value " + styleValue(value, expectedType);
       }
       message += ", got " + receivedType + " ";
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + (styleValue(value, receivedType)) + ".";
+          message += "with value " + styleValue(value, receivedType) + ".";
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return ("\"" + value + "\"");
+          return "\"" + value + "\"";
       }
       else if (type === 'Number') {
-          return ("" + (Number(value)));
+          return "" + Number(value);
       }
       else {
-          return ("" + value);
+          return "" + value;
       }
   }
   var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1721,9 +1698,12 @@
       return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
+      var arguments$1 = arguments;
 
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+          args[_i] = arguments$1[_i];
+      }
       return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
@@ -1777,7 +1757,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+          warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1813,16 +1793,15 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
+      var counter_1 = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
+      var textNode_1 = document.createTextNode(String(counter_1));
+      observer.observe(textNode_1, {
           characterData: true,
       });
   }
   else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-  /* @flow */
+  else ;
 
   /* @flow */
   function genClassForVnode(vnode) {
@@ -1840,7 +1819,7 @@
               data = mergeClassData(data, parentNode.data);
           }
       }
-      return renderClass(data.staticClass, data.class);
+      return renderClass$1(data.staticClass, data.class);
   }
   function mergeClassData(child, parent) {
       return {
@@ -1848,7 +1827,7 @@
           class: isDef(child.class) ? [child.class, parent.class] : parent.class,
       };
   }
-  function renderClass(staticClass, dynamicClass) {
+  function renderClass$1(staticClass, dynamicClass) {
       if (isDef(staticClass) || isDef(dynamicClass)) {
           return concat(staticClass, stringifyClass(dynamicClass));
       }
@@ -1926,15 +1905,13 @@
           return 'math';
       }
   }
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-  /* @flow */
+  makeMap('text,number,password,search,email,tel,url');
 
   /* @flow */
-  function renderClass$1(node) {
+  function renderClass(node) {
       var classList = genClassForVnode(node);
       if (classList !== '') {
-          return (" class=\"" + (escape(classList)) + "\"");
+          return " class=\"" + escape(classList) + "\"";
       }
   }
 
@@ -2019,7 +1996,7 @@
       if (typeof value === 'string' ||
           (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
           value === 0) {
-          return (key + ":" + value + ";");
+          return key + ":" + value + ";";
       }
       else {
           // invalid values
@@ -2029,11 +2006,11 @@
   function renderStyle(vnode) {
       var styleText = genStyle(getStyle(vnode, false));
       if (styleText !== '') {
-          return (" style=" + (JSON.stringify(escape(styleText))));
+          return " style=" + JSON.stringify(escape(styleText));
       }
   }
 
-  var modules = [renderAttrs, renderDOMProps, renderClass$1, renderStyle];
+  var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
   /* @flow */
   function show(node, dir) {
@@ -2051,7 +2028,7 @@
   /* @flow */
   // this is only applied for <select v-model> because it is the only edge case
   // that must be done at runtime instead of compile time.
-  function model(node, dir) {
+  function model$2(node, dir) {
       if (!node.children)
           { return; }
       var value = dir.value;
@@ -2086,9 +2063,9 @@
       attrs.selected = '';
   }
 
-  var directives = {
+  var directives$1 = {
       show: show,
-      model: model,
+      model: model$2,
   };
 
   /* @flow */
@@ -2107,15 +2084,15 @@
 
   /* @flow */
   var MAX_STACK_DEPTH = 800;
-  var noop$1 = function (_) { return _; };
+  var noop = function (_) { return _; };
   var defer = typeof process !== 'undefined' && process.nextTick
       ? process.nextTick
       : typeof Promise !== 'undefined'
           ? function (fn) { return Promise.resolve().then(fn); }
           : typeof setTimeout !== 'undefined'
               ? setTimeout
-              : noop$1;
-  if (defer === noop$1) {
+              : noop;
+  if (defer === noop) {
       throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
           'that are required by vue-server-renderer. Please use a polyfill for ' +
           'either Promise or setTimeout.');
@@ -2152,85 +2129,90 @@
   }
 
   /* @flow */
-  var RenderContext = function RenderContext(options) {
-      this.userContext = options.userContext;
-      this.activeInstance = options.activeInstance;
-      this.renderStates = [];
-      this.write = options.write;
-      this.done = options.done;
-      this.renderNode = options.renderNode;
-      this.isUnaryTag = options.isUnaryTag;
-      this.modules = options.modules;
-      this.directives = options.directives;
-      var cache = options.cache;
-      if (cache && (!cache.get || !cache.set)) {
-          throw new Error('renderer cache must implement at least get & set.');
-      }
-      this.cache = cache;
-      this.get = cache && normalizeAsync(cache, 'get');
-      this.has = cache && normalizeAsync(cache, 'has');
+  var RenderContext = /** @class */ (function () {
+      function RenderContext(options) {
+          this.userContext = options.userContext;
+          this.activeInstance = options.activeInstance;
+          this.renderStates = [];
+          this.write = options.write;
+          this.done = options.done;
+          this.renderNode = options.renderNode;
+          this.isUnaryTag = options.isUnaryTag;
+          this.modules = options.modules;
+          this.directives = options.directives;
+          var cache = options.cache;
+          if (cache && (!cache.get || !cache.set)) {
+              throw new Error('renderer cache must implement at least get & set.');
+          }
+          this.cache = cache;
+          this.get = cache && normalizeAsync(cache, 'get');
+          this.has = cache && normalizeAsync(cache, 'has');
+          //@ts-expect-error
+          this.next = this.next.bind(this);
+      }
       //@ts-expect-error
-      this.next = this.next.bind(this);
-  };
-  //@ts-expect-error
-  RenderContext.prototype.next = function next () {
-      // eslint-disable-next-line
-      while (true) {
-          var lastState = this.renderStates[this.renderStates.length - 1];
-          if (isUndef(lastState)) {
-              return this.done();
-          }
-          /* eslint-disable no-case-declarations */
-          switch (lastState.type) {
-              case 'Element':
-              case 'Fragment':
-                  var children = lastState.children;
-              var total = lastState.total;
-                  var rendered = lastState.rendered++;
-                  if (rendered < total) {
-                      return this.renderNode(children[rendered], false, this);
-                  }
-                  else {
-                      this.renderStates.pop();
-                      if (lastState.type === 'Element') {
-                          return this.write(lastState.endTag, this.next);
+      RenderContext.prototype.next = function () {
+          var _loop_1 = function () {
+              var lastState = this_1.renderStates[this_1.renderStates.length - 1];
+              if (isUndef(lastState)) {
+                  return { value: this_1.done() };
+              }
+              /* eslint-disable no-case-declarations */
+              switch (lastState.type) {
+                  case 'Element':
+                  case 'Fragment':
+                      var children = lastState.children, total = lastState.total;
+                      var rendered = lastState.rendered++;
+                      if (rendered < total) {
+                          return { value: this_1.renderNode(children[rendered], false, this_1) };
                       }
-                  }
-                  break;
-              case 'Component':
-                  this.renderStates.pop();
-                  this.activeInstance = lastState.prevActive;
-                  break;
-              case 'ComponentWithCache':
-                  this.renderStates.pop();
-                  var buffer = lastState.buffer;
-              var bufferIndex = lastState.bufferIndex;
-              var componentBuffer = lastState.componentBuffer;
-              var key = lastState.key;
-                  var result = {
-                      html: buffer[bufferIndex],
-                      components: componentBuffer[bufferIndex],
-                  };
-                  this.cache.set(key, result);
-                  if (bufferIndex === 0) {
-                      // this is a top-level cached component,
-                      // exit caching mode.
-                      //@ts-expect-error
-                      this.write.caching = false;
-                  }
-                  else {
-                      // parent component is also being cached,
-                      // merge self into parent's result
-                      buffer[bufferIndex - 1] += result.html;
-                      var prev = componentBuffer[bufferIndex - 1];
-                      result.components.forEach(function (c) { return prev.add(c); });
-                  }
-                  buffer.length = bufferIndex;
-                  componentBuffer.length = bufferIndex;
-                  break;
+                      else {
+                          this_1.renderStates.pop();
+                          if (lastState.type === 'Element') {
+                              return { value: this_1.write(lastState.endTag, this_1.next) };
+                          }
+                      }
+                      break;
+                  case 'Component':
+                      this_1.renderStates.pop();
+                      this_1.activeInstance = lastState.prevActive;
+                      break;
+                  case 'ComponentWithCache':
+                      this_1.renderStates.pop();
+                      var buffer = lastState.buffer, bufferIndex = lastState.bufferIndex, componentBuffer = lastState.componentBuffer, key = lastState.key;
+                      var result = {
+                          html: buffer[bufferIndex],
+                          components: componentBuffer[bufferIndex],
+                      };
+                      this_1.cache.set(key, result);
+                      if (bufferIndex === 0) {
+                          // this is a top-level cached component,
+                          // exit caching mode.
+                          //@ts-expect-error
+                          this_1.write.caching = false;
+                      }
+                      else {
+                          // parent component is also being cached,
+                          // merge self into parent's result
+                          buffer[bufferIndex - 1] += result.html;
+                          var prev_1 = componentBuffer[bufferIndex - 1];
+                          result.components.forEach(function (c) { return prev_1.add(c); });
+                      }
+                      buffer.length = bufferIndex;
+                      componentBuffer.length = bufferIndex;
+                      break;
+              }
+          };
+          var this_1 = this;
+          // eslint-disable-next-line
+          while (true) {
+              var state_1 = _loop_1();
+              if (typeof state_1 === "object")
+                  { return state_1.value; }
           }
-      }
-  };
+      };
+      return RenderContext;
+  }());
   function normalizeAsync(cache, method) {
       var fn = cache[method];
       if (isUndef(fn)) {
@@ -2323,7 +2305,9 @@
               if (c === 0x2f) {
                   // /
                   var j = i - 1;
-                  var p = (void 0);
+                  var p 
+                  // find first non-whitespace prev char
+                  = void 0;
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
@@ -2357,12 +2341,12 @@
       var i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return ("_f(\"" + filter + "\")(" + exp + ")");
+          return "_f(\"" + filter + "\")(" + exp + ")";
       }
       else {
-          var name = filter.slice(0, i);
+          var name_1 = filter.slice(0, i);
           var args = filter.slice(i + 1);
-          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+          return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
       }
   }
 
@@ -2393,7 +2377,7 @@
           }
           // tag token
           var exp = parseFilters(match[1].trim());
-          tokens.push(("_s(" + exp + ")"));
+          tokens.push("_s(" + exp + ")");
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -2410,7 +2394,7 @@
   /* @flow */
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error(("[Vue compiler]: " + msg));
+      console.error("[Vue compiler]: " + msg);
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
@@ -2444,7 +2428,7 @@
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+      return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -2575,7 +2559,7 @@
   }
 
   /* @flow */
-  function transformNode(el, options) {
+  function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
       if (staticClass) {
@@ -2595,24 +2579,24 @@
           el.classBinding = classBinding;
       }
   }
-  function genData(el) {
+  function genData$2(el) {
       var data = '';
       if (el.staticClass) {
-          data += "staticClass:" + (el.staticClass) + ",";
+          data += "staticClass:" + el.staticClass + ",";
       }
       if (el.classBinding) {
-          data += "class:" + (el.classBinding) + ",";
+          data += "class:" + el.classBinding + ",";
       }
       return data;
   }
   var klass = {
       staticKeys: ['staticClass'],
-      transformNode: transformNode,
-      genData: genData,
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
   /* @flow */
-  function transformNode$1(el, options) {
+  function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
       if (staticStyle) {
@@ -2636,380 +2620,30 @@
   function genData$1(el) {
       var data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + (el.staticStyle) + ",";
+          data += "staticStyle:" + el.staticStyle + ",";
       }
       if (el.styleBinding) {
-          data += "style:(" + (el.styleBinding) + "),";
+          data += "style:(" + el.styleBinding + "),";
       }
       return data;
   }
   var style = {
       staticKeys: ['staticStyle'],
-      transformNode: transformNode$1,
+      transformNode: transformNode,
       genData: genData$1,
   };
 
-  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  function createCommonjsModule(fn, module) {
-  	return module = { exports: {} }, fn(module, module.exports), module.exports;
-  }
-
-  var he = createCommonjsModule(function (module, exports) {
-  (function(root) {
-
-  	// Detect free variables `exports`.
-  	var freeExports = exports;
-
-  	// Detect free variable `module`.
-  	var freeModule = module &&
-  		module.exports == freeExports && module;
-
-  	// Detect free variable `global`, from Node.js or Browserified code,
-  	// and use it as `root`.
-  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-  		root = freeGlobal;
-  	}
-
-  	/*--------------------------------------------------------------------------*/
-
-  	// All astral symbols.
-  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  	// All ASCII symbols (not just printable ASCII) except those listed in the
-  	// first column of the overrides table.
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-  	// code points listed in the first column of the overrides table on
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-  	var regexEscape = /["&'<>`]/g;
-  	var escapeMap = {
-  		'"': '&quot;',
-  		'&': '&amp;',
-  		'\'': '&#x27;',
-  		'<': '&lt;',
-  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-  		// following is not strictly necessary unless it’s part of a tag or an
-  		// unquoted attribute value. We’re only escaping it to support those
-  		// situations, and for XML support.
-  		'>': '&gt;',
-  		// In Internet Explorer ≤ 8, the backtick character can be used
-  		// to break out of (un)quoted attribute values or HTML comments.
-  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-  		// http://html5sec.org/#133.
-  		'`': '&#x60;'
-  	};
-
-  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var stringFromCharCode = String.fromCharCode;
-
-  	var object = {};
-  	var hasOwnProperty = object.hasOwnProperty;
-  	var has = function(object, propertyName) {
-  		return hasOwnProperty.call(object, propertyName);
-  	};
-
-  	var contains = function(array, value) {
-  		var index = -1;
-  		var length = array.length;
-  		while (++index < length) {
-  			if (array[index] == value) {
-  				return true;
-  			}
-  		}
-  		return false;
-  	};
-
-  	var merge = function(options, defaults) {
-  		if (!options) {
-  			return defaults;
-  		}
-  		var result = {};
-  		var key;
-  		for (key in defaults) {
-  			// A `hasOwnProperty` check is not needed here, since only recognized
-  			// option names are used anyway. Any others are ignored.
-  			result[key] = has(options, key) ? options[key] : defaults[key];
-  		}
-  		return result;
-  	};
-
-  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-  	var codePointToSymbol = function(codePoint, strict) {
-  		var output = '';
-  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-  			// See issue #4:
-  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-  			// REPLACEMENT CHARACTER.”
-  			if (strict) {
-  				parseError('character reference outside the permissible Unicode range');
-  			}
-  			return '\uFFFD';
-  		}
-  		if (has(decodeMapNumeric, codePoint)) {
-  			if (strict) {
-  				parseError('disallowed character reference');
-  			}
-  			return decodeMapNumeric[codePoint];
-  		}
-  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-  			parseError('disallowed character reference');
-  		}
-  		if (codePoint > 0xFFFF) {
-  			codePoint -= 0x10000;
-  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-  			codePoint = 0xDC00 | codePoint & 0x3FF;
-  		}
-  		output += stringFromCharCode(codePoint);
-  		return output;
-  	};
-
-  	var hexEscape = function(codePoint) {
-  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-  	};
-
-  	var decEscape = function(codePoint) {
-  		return '&#' + codePoint + ';';
-  	};
-
-  	var parseError = function(message) {
-  		throw Error('Parse error: ' + message);
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var encode = function(string, options) {
-  		options = merge(options, encode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidRawCodePoint.test(string)) {
-  			parseError('forbidden code point');
-  		}
-  		var encodeEverything = options.encodeEverything;
-  		var useNamedReferences = options.useNamedReferences;
-  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-  		var escapeBmpSymbol = function(symbol) {
-  			return escapeCodePoint(symbol.charCodeAt(0));
-  		};
-
-  		if (encodeEverything) {
-  			// Encode ASCII symbols.
-  			string = string.replace(regexAsciiWhitelist, function(symbol) {
-  				// Use named references if requested & possible.
-  				if (useNamedReferences && has(encodeMap, symbol)) {
-  					return '&' + encodeMap[symbol] + ';';
-  				}
-  				return escapeBmpSymbol(symbol);
-  			});
-  			// Shorten a few escapes that represent two symbols, of which at least one
-  			// is within the ASCII range.
-  			if (useNamedReferences) {
-  				string = string
-  					.replace(/&gt;\u20D2/g, '&nvgt;')
-  					.replace(/&lt;\u20D2/g, '&nvlt;')
-  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-  			}
-  			// Encode non-ASCII symbols.
-  			if (useNamedReferences) {
-  				// Encode non-ASCII symbols that can be replaced with a named reference.
-  				string = string.replace(regexEncodeNonAscii, function(string) {
-  					// Note: there is no need to check `has(encodeMap, string)` here.
-  					return '&' + encodeMap[string] + ';';
-  				});
-  			}
-  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-  		} else if (useNamedReferences) {
-  			// Apply named character references.
-  			// Encode `<>"'&` using named character references.
-  			if (!allowUnsafeSymbols) {
-  				string = string.replace(regexEscape, function(string) {
-  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-  				});
-  			}
-  			// Shorten escapes that represent two symbols, of which at least one is
-  			// `<>"'&`.
-  			string = string
-  				.replace(/&gt;\u20D2/g, '&nvgt;')
-  				.replace(/&lt;\u20D2/g, '&nvlt;');
-  			// Encode non-ASCII symbols that can be replaced with a named reference.
-  			string = string.replace(regexEncodeNonAscii, function(string) {
-  				// Note: there is no need to check `has(encodeMap, string)` here.
-  				return '&' + encodeMap[string] + ';';
-  			});
-  		} else if (!allowUnsafeSymbols) {
-  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-  			// using named character references.
-  			string = string.replace(regexEscape, escapeBmpSymbol);
-  		}
-  		return string
-  			// Encode astral symbols.
-  			.replace(regexAstralSymbols, function($0) {
-  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-  				var high = $0.charCodeAt(0);
-  				var low = $0.charCodeAt(1);
-  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-  				return escapeCodePoint(codePoint);
-  			})
-  			// Encode any remaining BMP symbols that are not printable ASCII symbols
-  			// using a hexadecimal escape.
-  			.replace(regexBmpWhitelist, escapeBmpSymbol);
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	encode.options = {
-  		'allowUnsafeSymbols': false,
-  		'encodeEverything': false,
-  		'strict': false,
-  		'useNamedReferences': false,
-  		'decimal' : false
-  	};
-
-  	var decode = function(html, options) {
-  		options = merge(options, decode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidEntity.test(html)) {
-  			parseError('malformed character reference');
-  		}
-  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  			var codePoint;
-  			var semicolon;
-  			var decDigits;
-  			var hexDigits;
-  			var reference;
-  			var next;
-
-  			if ($1) {
-  				reference = $1;
-  				// Note: there is no need to check `has(decodeMap, reference)`.
-  				return decodeMap[reference];
-  			}
-
-  			if ($2) {
-  				// Decode named character references without trailing `;`, e.g. `&amp`.
-  				// This is only a parse error if it gets converted to `&`, or if it is
-  				// followed by `=` in an attribute context.
-  				reference = $2;
-  				next = $3;
-  				if (next && options.isAttributeValue) {
-  					if (strict && next == '=') {
-  						parseError('`&` did not start a character reference');
-  					}
-  					return $0;
-  				} else {
-  					if (strict) {
-  						parseError(
-  							'named character reference was not terminated by a semicolon'
-  						);
-  					}
-  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-  					return decodeMapLegacy[reference] + (next || '');
-  				}
-  			}
-
-  			if ($4) {
-  				// Decode decimal escapes, e.g. `&#119558;`.
-  				decDigits = $4;
-  				semicolon = $5;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(decDigits, 10);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			if ($6) {
-  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-  				hexDigits = $6;
-  				semicolon = $7;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(hexDigits, 16);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-  			if (strict) {
-  				parseError(
-  					'named character reference was not terminated by a semicolon'
-  				);
-  			}
-  			return $0;
-  		});
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	decode.options = {
-  		'isAttributeValue': false,
-  		'strict': false
-  	};
-
-  	var escape = function(string) {
-  		return string.replace(regexEscape, function($0) {
-  			// Note: there is no need to check `has(escapeMap, $0)` here.
-  			return escapeMap[$0];
-  		});
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var he = {
-  		'version': '1.2.0',
-  		'encode': encode,
-  		'decode': decode,
-  		'escape': escape,
-  		'unescape': decode
-  	};
-
-  	// Some AMD build optimizers, like r.js, check for specific condition patterns
-  	// like the following:
-  	if (freeExports && !freeExports.nodeType) {
-  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-  			freeModule.exports = he;
-  		} else { // in Narwhal or RingoJS v0.7.0-
-  			for (var key in he) {
-  				has(he, key) && (freeExports[key] = he[key]);
-  			}
-  		}
-  	} else { // in Rhino or a web browser
-  		root.he = he;
-  	}
-
-  }(commonjsGlobal));
-  });
-
-  var he$1 = /*#__PURE__*/Object.freeze({
-    default: he,
-    __moduleExports: he
-  });
-
   /**
    * Not type-checking this file because it's mostly vendor code.
    */
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp(("^<" + qnameCapture));
+  var startTagOpen = new RegExp("^<" + qnameCapture);
   var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+  var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
   var doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
@@ -3030,7 +2664,9 @@
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+  var shouldIgnoreFirstNewline = function (tag, html) {
+      return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  };
   function decodeAttr(value, shouldDecodeNewlines) {
       var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
       return value.replace(re, function (match) { return decodingMap[match]; });
@@ -3038,11 +2674,11 @@
   function parseHTML(html, options) {
       var stack = [];
       var expectHTML = options.expectHTML;
-      var isUnaryTag$$1 = options.isUnaryTag || no;
-      var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+      var isUnaryTag = options.isUnaryTag || no;
+      var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
       var index = 0;
       var last, lastTag;
-      while (html) {
+      var _loop_1 = function () {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -3056,7 +2692,7 @@
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                           }
                           advance(commentEnd + 3);
-                          continue;
+                          return "continue";
                       }
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -3064,14 +2700,14 @@
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
-                          continue;
+                          return "continue";
                       }
                   }
                   // Doctype:
                   var doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
-                      continue;
+                      return "continue";
                   }
                   // End tag:
                   var endTagMatch = html.match(endTag);
@@ -3079,7 +2715,7 @@
                       var curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
+                      return "continue";
                   }
                   // Start tag:
                   var startTagMatch = parseStartTag();
@@ -3088,10 +2724,10 @@
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                           advance(1);
                       }
-                      continue;
+                      return "continue";
                   }
               }
-              var text = (void 0), rest = (void 0), next = (void 0);
+              var text = void 0, rest = void 0, next = void 0;
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -3118,18 +2754,18 @@
               }
           }
           else {
-              var endTagLength = 0;
-              var stackedTag = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+              var endTagLength_1 = 0;
+              var stackedTag_1 = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag_1] ||
+                  (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+              var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength_1 = endTag.length;
+                  if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                       text = text
                           .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                           .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                   }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                  if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                       text = text.slice(1);
                   }
                   if (options.chars) {
@@ -3137,20 +2773,25 @@
                   }
                   return '';
               });
-              index += html.length - rest$1.length;
-              html = rest$1;
-              parseEndTag(stackedTag, index - endTagLength, index);
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag_1, index - endTagLength_1, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                  options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                       start: index + html.length,
                   });
               }
-              break;
+              return "break";
           }
+      };
+      while (html) {
+          var state_1 = _loop_1();
+          if (state_1 === "break")
+              { break; }
       }
       // Clean up any remaining tags
       parseEndTag();
@@ -3167,7 +2808,7 @@
                   start: index,
               };
               advance(start[0].length);
-              var end, attr;
+              var end = void 0, attr = void 0;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -3190,11 +2831,11 @@
               if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                   parseEndTag(lastTag);
               }
-              if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                   parseEndTag(tagName);
               }
           }
-          var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+          var unary = isUnaryTag(tagName) || !!unarySlash;
           var l = match.attrs.length;
           var attrs = new Array(l);
           for (var i = 0; i < l; i++) {
@@ -3248,9 +2889,9 @@
           if (pos >= 0) {
               // Close all the open elements, up the stack
               for (var i = stack.length - 1; i >= pos; i--) {
-                  if (i > pos || !tagName &&
+                  if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                      options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -3284,25 +2925,23 @@
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var ref = modifiers || {};
-      var number = ref.number;
-      var trim = ref.trim;
+      var _a = modifiers || {}, number = _a.number, trim = _a.trim;
       var baseValueExpression = '$$v';
       var valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
               "(typeof " + baseValueExpression + " === 'string'" +
-                  "? " + baseValueExpression + ".trim()" +
-                  ": " + baseValueExpression + ")";
+                  ("? " + baseValueExpression + ".trim()") +
+                  (": " + baseValueExpression + ")");
       }
       if (number) {
           valueExpression = "_n(" + valueExpression + ")";
       }
       var assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: ("(" + value + ")"),
+          value: "(" + value + ")",
           expression: JSON.stringify(value),
-          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+          callback: "function (" + baseValueExpression + ") {" + assignment + "}",
       };
   }
   /**
@@ -3311,10 +2950,10 @@
   function genAssignmentCode(value, assignment) {
       var res = parseModel(value);
       if (res.key === null) {
-          return (value + "=" + assignment);
+          return value + "=" + assignment;
       }
       else {
-          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+          return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
       }
   }
   /**
@@ -3408,6 +3047,7 @@
   }
 
   /* @flow */
+  var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -3421,7 +3061,7 @@
   var lineBreakRE = /[\r\n]/;
   var whitespaceRE = /[ \f\t\r\n]+/g;
   var invalidAttributeRE = /[\s"'<>\/=]/;
-  var decodeHTMLCached = cached(undefined);
+  var decodeHTMLCached = cached(he.decode);
   var emptySlotScopeToken = "_empty_";
   // configurable state
   var warn$1;
@@ -3504,8 +3144,8 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                      var name_1 = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                   }
                   currentParent.children.push(element);
                   element.parent = currentParent;
@@ -3531,7 +3171,7 @@
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode;
+              var lastNode = void 0;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -3541,7 +3181,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+              warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -3558,7 +3198,7 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function start(tag, attrs, unary, start$1, end) {
+          start: function (tag, attrs, unary, start, end) {
               // check namespace.
               // inherit parent ns if there is one
               var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -3573,7 +3213,7 @@
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start$1;
+                      element.start = start;
                       element.end = end;
                       element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                           cumulated[attr.name] = attr;
@@ -3594,7 +3234,7 @@
                   element.forbidden = true;
                   warn$1('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          "<" + tag + ">" +
+                          ("<" + tag + ">") +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
@@ -3633,24 +3273,24 @@
                   closeElement(element);
               }
           },
-          end: function end(tag, start, end$1) {
+          end: function (tag, start, end) {
               var element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end$1;
+                  element.end = end;
               }
               closeElement(element);
           },
-          chars: function chars(text, start, end) {
+          chars: function (text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
                           warnOnce('Component template requires a root element, rather than just text.', { start: start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                          warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                               start: start,
                           });
                       }
@@ -3690,8 +3330,8 @@
                       // condense consecutive whitespaces into single space
                       text = text.replace(whitespaceRE, ' ');
                   }
-                  var res;
-                  var child;
+                  var res = void 0;
+                  var child = void 0;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
@@ -3717,7 +3357,7 @@
                   }
               }
           },
-          comment: function comment(text, start, end) {
+          comment: function (text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
@@ -3787,11 +3427,11 @@
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
-                  var parent = el.parent;
+                  var parent_1 = el.parent;
                   if (iterator &&
                       iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
+                      parent_1 &&
+                      parent_1.tag === 'transition-group') {
                       warn$1("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
@@ -3815,7 +3455,7 @@
               extend(el, res);
           }
           else {
-              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+              warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -3868,7 +3508,7 @@
       }
       else {
           warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+              ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
@@ -3879,7 +3519,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                  warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -3893,8 +3533,8 @@
       el.ifConditions.push(condition);
   }
   function processOnce(el) {
-      var once$$1 = getAndRemoveAttr(el, 'v-once');
-      if (once$$1 != null) {
+      var once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
           el.once = true;
       }
   }
@@ -3916,7 +3556,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -3948,45 +3588,41 @@
                               "the receiving component", el);
                       }
                   }
-                  var ref = getSlotName(slotBinding);
-                  var name = ref.name;
-                  var dynamic = ref.dynamic;
-                  el.slotTarget = name;
+                  var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                  el.slotTarget = name_2;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
               }
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding$1) {
+              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding);
                       }
                       if (el.slotScope || el.slotTarget) {
                           warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
                           warn$1("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding$1);
+                              "<template> syntax when there are other named slots.", slotBinding);
                       }
                   }
                   // add the component's children to its default slot
                   var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var ref$1 = getSlotName(slotBinding$1);
-                  var name$1 = ref$1.name;
-                  var dynamic$1 = ref$1.dynamic;
-                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name$1;
-                  slotContainer.slotTargetDynamic = dynamic$1;
-                  slotContainer.children = el.children.filter(function (c) {
+                  var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                  var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                  slotContainer_1.slotTarget = name_3;
+                  slotContainer_1.slotTargetDynamic = dynamic;
+                  slotContainer_1.children = el.children.filter(function (c) {
                       if (!c.slotScope) {
-                          c.parent = slotContainer;
+                          c.parent = slotContainer_1;
                           return true;
                       }
                   });
-                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -4009,7 +3645,7 @@
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: ("\"" + name + "\""), dynamic: false };
+              { name: "\"" + name + "\"", dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
@@ -4055,7 +3691,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                      warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -4069,14 +3705,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                               );
                           }
                       }
@@ -4153,11 +3789,11 @@
   function parseModifiers(name) {
       var match = name.match(modifierRE);
       if (match) {
-          var ret = {};
+          var ret_1 = {};
           match.forEach(function (m) {
-              ret[m.slice(1)] = true;
+              ret_1[m.slice(1)] = true;
           });
-          return ret;
+          return ret_1;
       }
   }
   function makeAttrsMap(attrs) {
@@ -4199,7 +3835,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+              warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -4216,16 +3852,16 @@
           if (!map['v-model']) {
               return;
           }
-          var typeBinding;
+          var typeBinding = void 0;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + (map['v-bind']) + ").type";
+              typeBinding = "(" + map['v-bind'] + ").type";
           }
           if (typeBinding) {
               var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+              var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
               var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
               var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
@@ -4275,15 +3911,15 @@
       preTransformNode: preTransformNode,
   };
 
-  var modules$1 = [klass, style, model$1];
+  var modules = [klass, style, model$1];
 
   /* @flow */
-  var warn$2;
+  var warn;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
-  function model$2(el, dir, _warn) {
-      warn$2 = _warn;
+  function model(el, dir, _warn) {
+      warn = _warn;
       var value = dir.value;
       var modifiers = dir.modifiers;
       var tag = el.tag;
@@ -4292,7 +3928,7 @@
           // inputs with type="file" are read only and setting the input's
           // value will throw an error.
           if (tag === 'input' && type === 'file') {
-              warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+              warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                   "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
           }
       }
@@ -4327,25 +3963,25 @@
       var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
       var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
       addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          "?_i(" + value + "," + valueBinding + ")>-1" +
+          ("?_i(" + value + "," + valueBinding + ")>-1") +
           (trueValueBinding === 'true'
-              ? (":(" + value + ")")
-              : (":_q(" + value + "," + trueValueBinding + ")")));
+              ? ":(" + value + ")"
+              : ":_q(" + value + "," + trueValueBinding + ")"));
       addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
-          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
           'if(Array.isArray($$a)){' +
-          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
           '$$i=_i($$a,$$v);' +
-          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
   }
   function genRadioModel(el, value, modifiers) {
       var number = modifiers && modifiers.number;
       var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
       addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
   }
   function genSelect(el, value, modifiers) {
@@ -4353,10 +3989,10 @@
       var selectedVal = "Array.prototype.filter" +
           ".call($event.target.options,function(o){return o.selected})" +
           ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          "return " + (number ? '_n(val)' : 'val') + "})";
+          ("return " + (number ? '_n(val)' : 'val') + "})");
       var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
       var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + (genAssignmentCode(value, assignment));
+      code = code + " " + genAssignmentCode(value, assignment);
       addHandler(el, 'change', code, null, true);
   }
   function genDefaultModel(el, value, modifiers) {
@@ -4364,18 +4000,15 @@
       // warn if v-bind:value conflicts with v-model
       // except for inputs with v-bind:type
       {
-          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
           var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value$1 && !typeBinding) {
+          if (value_1 && !typeBinding) {
               var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+              warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                   'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
           }
       }
-      var ref = modifiers || {};
-      var lazy = ref.lazy;
-      var number = ref.number;
-      var trim = ref.trim;
+      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
       var needCompositionGuard = !lazy && type !== 'range';
       var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
       var valueExpression = '$event.target.value';
@@ -4389,7 +4022,7 @@
       if (needCompositionGuard) {
           code = "if($event.target.composing)return;" + code;
       }
-      addProp(el, 'value', ("(" + value + ")"));
+      addProp(el, 'value', "(" + value + ")");
       addHandler(el, event, code, null, true);
       if (trim || number) {
           addHandler(el, 'blur', '$forceUpdate()');
@@ -4399,19 +4032,19 @@
   /* @flow */
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
   /* @flow */
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
       }
   }
 
-  var directives$1 = {
-      model: model$2,
+  var directives = {
+      model: model,
       text: text,
       html: html,
   };
@@ -4419,8 +4052,8 @@
   /* @flow */
   var baseOptions = {
       expectHTML: true,
-      modules: modules$1,
-      directives: directives$1,
+      modules: modules,
+      directives: directives,
       isPreTag: isPreTag,
       isUnaryTag: isUnaryTag,
       mustUseProp: mustUseProp,
@@ -4428,7 +4061,7 @@
       isReservedTag: isReservedTag,
       getTagNamespace: getTagNamespace,
       // @ts-ignore
-      staticKeys: genStaticKeys(modules$1),
+      staticKeys: genStaticKeys(modules),
   };
 
   /* @flow */
@@ -4466,7 +4099,7 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+  var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
   var modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
@@ -4483,19 +4116,19 @@
       var prefix = isNative ? 'nativeOn:' : 'on:';
       var staticHandlers = "";
       var dynamicHandlers = "";
-      for (var name in events) {
-          var handlerCode = genHandler(events[name]);
+      for (var name_1 in events) {
+          var handlerCode = genHandler(events[name_1]);
           //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += name + "," + handlerCode + ",";
+          if (events[name_1] && events[name_1].dynamic) {
+              dynamicHandlers += name_1 + "," + handlerCode + ",";
           }
           else {
-              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+              staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
           }
       }
-      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
       if (dynamicHandlers) {
-          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+          return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
       }
       else {
           return prefix + staticHandlers;
@@ -4506,7 +4139,7 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+          return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
       }
       var isMethodPath = simplePathRE.test(handler.value);
       var isFunctionExpression = fnExpRE.test(handler.value);
@@ -4515,13 +4148,13 @@
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+          return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
       }
       else {
           var code = '';
           var genModifierCode = '';
           var keys = [];
-          for (var key in handler.modifiers) {
+          var _loop_1 = function (key) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -4530,15 +4163,18 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers = handler.modifiers;
+                  var modifiers_1 = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                      .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                       .join('||'));
               }
               else {
                   keys.push(key);
               }
+          };
+          for (var key in handler.modifiers) {
+              _loop_1(key);
           }
           if (keys.length) {
               code += genKeyFilter(keys);
@@ -4548,13 +4184,13 @@
               code += genModifierCode;
           }
           var handlerCode = isMethodPath
-              ? ("return " + (handler.value) + ".apply(null, arguments)")
+              ? "return " + handler.value + ".apply(null, arguments)"
               : isFunctionExpression
-                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  ? "return (" + handler.value + ").apply(null, arguments)"
                   : isFunctionInvocation
-                      ? ("return " + (handler.value))
+                      ? "return " + handler.value
                       : handler.value;
-          return ("function($event){" + code + handlerCode + "}");
+          return "function($event){" + code + handlerCode + "}";
       }
   }
   function genKeyFilter(keys) {
@@ -4563,60 +4199,65 @@
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&')) + ")return null;");
+          (keys.map(genFilterCode).join('&&') + ")return null;"));
   }
   function genFilterCode(key) {
       var keyVal = parseInt(key, 10);
       if (keyVal) {
-          return ("$event.keyCode!==" + keyVal);
+          return "$event.keyCode!==" + keyVal;
       }
       var keyCode = keyCodes[key];
       var keyName = keyNames[key];
       return ("_k($event.keyCode," +
-          (JSON.stringify(key)) + "," +
-          (JSON.stringify(keyCode)) + "," +
+          (JSON.stringify(key) + ",") +
+          (JSON.stringify(keyCode) + ",") +
           "$event.key," +
-          "" + (JSON.stringify(keyName)) +
+          ("" + JSON.stringify(keyName)) +
           ")");
   }
 
   /* @flow */
   function on(el, dir) {
       if (dir.modifiers) {
-          warn("v-on without argument does not support modifiers.");
+          warn$2("v-on without argument does not support modifiers.");
       }
-      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+      el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
   /* @flow */
-  function bind$1(el, dir) {
+  function bind(el, dir) {
       el.wrapData = function (code) {
-          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+          return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
   /* @flow */
   var baseDirectives = {
       on: on,
-      bind: bind$1,
-      cloak: noop,
+      bind: bind,
+      cloak: noop$1,
   };
 
   /* @flow */
-  var CodegenState = function CodegenState(options) {
-      this.options = options;
-      this.warn = options.warn || baseWarn;
-      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-      this.directives = extend(extend({}, baseDirectives), options.directives);
-      var isReservedTag = options.isReservedTag || no;
-      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-      this.onceId = 0;
-      this.staticRenderFns = [];
-      this.pre = false;
-  };
-  function generate(ast, options) {
+  var CodegenState = /** @class */ (function () {
+      function CodegenState(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          var isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = function (el) {
+              return !!el.component || !isReservedTag(el.tag);
+          };
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+      return CodegenState;
+  }());
+  function generate$1(ast, options) {
       var state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
       var code = ast
@@ -4625,7 +4266,7 @@
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: ("with(this){return " + code + "}"),
+          render: "with(this){return " + code + "}",
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -4653,17 +4294,19 @@
       }
       else {
           // component or element
-          var code;
+          var code = void 0;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data;
+              var data = void 0;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData$2(el, state);
+                  data = genData(el, state);
               }
               var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+              code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+              ) + (children ? "," + children : '' // children
+              ) + ")";
           }
           // module transforms
           for (var i = 0; i < state.transforms.length; i++) {
@@ -4682,9 +4325,9 @@
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
       state.pre = originalPreState;
-      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+      return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
   }
   // v-once
   function genOnce(el, state) {
@@ -4694,19 +4337,19 @@
       }
       else if (el.staticInFor) {
           var key = '';
-          var parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
+          var parent_1 = el.parent;
+          while (parent_1) {
+              if (parent_1.for) {
+                  key = parent_1.key;
                   break;
               }
-              parent = parent.parent;
+              parent_1 = parent_1.parent;
           }
           if (!key) {
               state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+          return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
       }
       else {
           return genStatic(el, state);
@@ -4722,10 +4365,10 @@
       }
       var condition = conditions.shift();
       if (condition.exp) {
-          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+          return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
       }
       else {
-          return ("" + (genTernaryExp(condition.block)));
+          return "" + genTernaryExp(condition.block);
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -4739,23 +4382,23 @@
   function genFor(el, state, altGen, altHelper) {
       var exp = el.for;
       var alias = el.alias;
-      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+      var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+          state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
               "v-for should have explicit keys. " +
               "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ((altHelper || '_l') + "((" + exp + ")," +
-          "function(" + alias + iterator1 + iterator2 + "){" +
-          "return " + ((altGen || genElement)(el, state)) +
+          ("function(" + alias + iterator1 + iterator2 + "){") +
+          ("return " + (altGen || genElement)(el, state)) +
           '})');
   }
-  function genData$2(el, state) {
+  function genData(el, state) {
       var data = '{';
       // directives first.
       // directives may mutate the el's other properties before they are generated.
@@ -4764,11 +4407,11 @@
           { data += dirs + ','; }
       // key
       if (el.key) {
-          data += "key:" + (el.key) + ",";
+          data += "key:" + el.key + ",";
       }
       // ref
       if (el.ref) {
-          data += "ref:" + (el.ref) + ",";
+          data += "ref:" + el.ref + ",";
       }
       if (el.refInFor) {
           data += "refInFor:true,";
@@ -4779,7 +4422,7 @@
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + (el.tag) + "\",";
+          data += "tag:\"" + el.tag + "\",";
       }
       // module data generation functions
       for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -4787,31 +4430,31 @@
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + (genProps(el.attrs)) + ",";
+          data += "attrs:" + genProps(el.attrs) + ",";
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + (genProps(el.props)) + ",";
+          data += "domProps:" + genProps(el.props) + ",";
       }
       // event handlers
       if (el.events) {
-          data += (genHandlers(el.events, false)) + ",";
+          data += genHandlers(el.events, false) + ",";
       }
       if (el.nativeEvents) {
-          data += (genHandlers(el.nativeEvents, true)) + ",";
+          data += genHandlers(el.nativeEvents, true) + ",";
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + (el.slotTarget) + ",";
+          data += "slot:" + el.slotTarget + ",";
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+          data += genScopedSlots(el, el.scopedSlots, state) + ",";
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+          data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
       }
       // inline-template
       if (el.inlineTemplate) {
@@ -4825,7 +4468,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+          data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -4855,9 +4498,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+              res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                  ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                  : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
           }
       }
       if (hasRuntime) {
@@ -4866,14 +4509,14 @@
   }
   function genInlineTemplate(el, state) {
       var ast = el.children[0];
-      if (el.children.length !== 1 || ast.type !== 1) {
+      if ((el.children.length !== 1 || ast.type !== 1)) {
           state.warn('Inline-template components must have exactly one child element.', { start: el.start });
       }
       if (ast && ast.type === 1) {
-          var inlineRenderFns = generate(ast, state.options);
-          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-              .map(function (code) { return ("function(){" + code + "}"); })
-              .join(',')) + "]}");
+          var inlineRenderFns = generate$1(ast, state.options);
+          return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+              .map(function (code) { return "function(){" + code + "}"; })
+              .join(',') + "]}";
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -4898,23 +4541,23 @@
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
+          var parent_2 = el.parent;
+          while (parent_2) {
+              if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                  parent_2.for) {
                   needsForceUpdate = true;
                   break;
               }
-              if (parent.if) {
+              if (parent_2.if) {
                   needsKey = true;
               }
-              parent = parent.parent;
+              parent_2 = parent_2.parent;
           }
       }
       var generatedSlots = Object.keys(slots)
           .map(function (key) { return genScopedSlot(slots[key], state); })
           .join(',');
-      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+      return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
   }
   function hash(str) {
       var hash = 5381;
@@ -4943,36 +4586,36 @@
       }
       var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
       var fn = "function(" + slotScope + "){" +
-          "return " + (el.tag === 'template'
+          ("return " + (el.tag === 'template'
               ? el.if && isLegacySyntax
-                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                  ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                   : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}";
+              : genElement(el, state)) + "}");
       // reverse proxy v-slot without scope on this.$slots
       var reverseProxy = slotScope ? "" : ",proxy:true";
-      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+      return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
       var children = el.children;
       if (children.length) {
-          var el$1 = children[0];
+          var el_1 = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el$1.for &&
-              el$1.tag !== 'template' &&
-              el$1.tag !== 'slot') {
-              var normalizationType = checkSkip
-                  ? state.maybeComponent(el$1)
+              el_1.for &&
+              el_1.tag !== 'template' &&
+              el_1.tag !== 'slot') {
+              var normalizationType_1 = checkSkip
+                  ? state.maybeComponent(el_1)
                       ? ",1"
                       : ",0"
                   : "";
-              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+              return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
           }
-          var normalizationType$1 = checkSkip
+          var normalizationType = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen = altGenNode || genNode;
-          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+          var gen_1 = altGenNode || genNode;
+          return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
       }
   }
   // determine the normalization needed for the children array.
@@ -5014,17 +4657,17 @@
       }
   }
   function genText(text) {
-      return ("_v(" + (text.type === 2
+      return "_v(" + (text.type === 2
           ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
   }
   function genComment(comment) {
-      return ("_e(" + (JSON.stringify(comment.text)) + ")");
+      return "_e(" + JSON.stringify(comment.text) + ")";
   }
   function genSlot(el, state) {
       var slotName = el.slotName || '"default"';
       var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? ("," + children) : '');
+      var res = "_t(" + slotName + (children ? "," + children : '');
       var attrs = el.attrs || el.dynamicAttrs
           ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
               // slot props are camelized
@@ -5033,22 +4676,22 @@
               dynamic: attr.dynamic,
           }); }))
           : null;
-      var bind$$1 = el.attrsMap['v-bind'];
-      if ((attrs || bind$$1) && !children) {
+      var bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
           res += ",null";
       }
       if (attrs) {
           res += "," + attrs;
       }
-      if (bind$$1) {
-          res += (attrs ? '' : ',null') + "," + bind$$1;
+      if (bind) {
+          res += (attrs ? '' : ',null') + "," + bind;
       }
       return res + ')';
   }
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
       var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+      return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
   }
   function genProps(props) {
       var staticProps = "";
@@ -5057,15 +4700,15 @@
           var prop = props[i];
           var value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += (prop.name) + "," + value + ",";
+              dynamicProps += prop.name + "," + value + ",";
           }
           else {
-              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+              staticProps += "\"" + prop.name + "\":" + value + ",";
           }
       }
-      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      staticProps = "{" + staticProps.slice(0, -1) + "}";
       if (dynamicProps) {
-          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+          return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
       }
       else {
           return staticProps;
@@ -5096,19 +4739,15 @@
       }
   }
   function genAttrSegments(attrs) {
-      return attrs.map(function (ref) {
-          var name = ref.name;
-          var value = ref.value;
-
+      return attrs.map(function (_a) {
+          var name = _a.name, value = _a.value;
           return genAttrSegment(name, value);
       });
   }
   function genDOMPropSegments(props, attrs) {
       var segments = [];
-      props.forEach(function (ref) {
-          var name = ref.name;
-          var value = ref.value;
-
+      props.forEach(function (_a) {
+          var name = _a.name, value = _a.value;
           name = propsToAttrMap[name] || name.toLowerCase();
           if (isRenderableAttr(name) &&
               !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -5128,42 +4767,42 @@
           return {
               type: RAW,
               value: isBooleanAttr(name)
-                  ? (" " + name + "=\"" + name + "\"")
+                  ? " " + name + "=\"" + name + "\""
                   : value === '""'
-                      ? (" " + name)
-                      : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+                      ? " " + name
+                      : " " + name + "=\"" + JSON.parse(value) + "\"",
           };
       }
       else {
           return {
               type: EXPRESSION,
-              value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+              value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
           };
       }
   }
   function genClassSegments(staticClass, classBinding) {
       if (staticClass && !classBinding) {
-          return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
+          return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+                  value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
               } ];
       }
   }
   function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
       if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+          return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                      ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-                      : 'null') + ")"),
+                  value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                      ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
+                      : 'null') + ")",
               } ];
       }
   }
@@ -5208,8 +4847,8 @@
               check(child);
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  var block = node.ifConditions[i$1].block;
+              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                  var block = node.ifConditions[i].block;
                   walk(block, isRoot);
                   check(block);
               }
@@ -5291,11 +4930,11 @@
   var RAW = 0;
   var INTERPOLATION = 1;
   var EXPRESSION = 2;
-  function generate$1(ast, options) {
+  function generate(ast, options) {
       var state = new CodegenState(options);
       var code = ast ? genSSRElement(ast, state) : '_c("div")';
       return {
-          render: ("with(this){return " + code + "}"),
+          render: "with(this){return " + code + "}",
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -5330,11 +4969,11 @@
       }
   }
   function genNormalElement(el, state, stringifyChildren) {
-      var data = el.plain ? undefined : genData$2(el, state);
+      var data = el.plain ? undefined : genData(el, state);
       var children = stringifyChildren
-          ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+          ? "[" + genChildrenAsStringNode(el, state) + "]"
           : genSSRChildren(el, state, true);
-      return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+      return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
   }
   function genSSRChildren(el, state, checkSkip) {
       return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -5344,18 +4983,18 @@
   }
   function genChildrenAsStringNode(el, state) {
       return el.children.length
-          ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+          ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
           : '';
   }
   function genStringElement(el, state) {
-      return ("_ssrNode(" + (elementToString(el, state)) + ")");
+      return "_ssrNode(" + elementToString(el, state) + ")";
   }
   function genStringElementWithChildren(el, state) {
       var children = genSSRChildren(el, state, true);
-      return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+      return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
   }
   function elementToString(el, state) {
-      return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+      return "(" + flattenSegments(elementToSegments(el, state)) + ")";
   }
   function elementToSegments(el, state) {
       // v-for / v-if
@@ -5380,17 +5019,16 @@
       }
       var openSegments = elementToOpenTagSegments(el, state);
       var childrenSegments = childrenToSegments(el, state);
-      var ref = state.options;
-      var isUnaryTag = ref.isUnaryTag;
+      var isUnaryTag = state.options.isUnaryTag;
       var close = isUnaryTag && isUnaryTag(el.tag)
           ? []
-          : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+          : [{ type: RAW, value: "</" + el.tag + ">" }];
       return openSegments.concat(childrenSegments, close);
   }
   function elementToOpenTagSegments(el, state) {
       applyModelTransform(el, state);
       var binding;
-      var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+      var segments = [{ type: RAW, value: "<" + el.tag }];
       // attrs
       if (el.attrs) {
           segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -5401,11 +5039,11 @@
       }
       // v-bind="object"
       if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+          segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
       }
       // v-bind.prop="object"
       if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+          segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
       }
       // class
       if (el.staticClass || el.classBinding) {
@@ -5417,7 +5055,7 @@
       }
       // _scopedId
       if (state.options.scopeId) {
-          segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+          segments.push({ type: RAW, value: " " + state.options.scopeId });
       }
       segments.push({ type: RAW, value: ">" });
       return segments;
@@ -5425,13 +5063,13 @@
   function childrenToSegments(el, state) {
       var binding;
       if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+          return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
       }
       if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
       }
       if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
       }
       return el.children ? nodesToSegments(el.children, state) : [];
   }
@@ -5471,11 +5109,11 @@
           }
           else if (s.type === INTERPOLATION) {
               pushBuffer();
-              mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+              mergedSegments.push("_ssrEscape(" + s.value + ")");
           }
           else if (s.type === EXPRESSION) {
               pushBuffer();
-              mergedSegments.push(("(" + (s.value) + ")"));
+              mergedSegments.push("(" + s.value + ")");
           }
       }
       pushBuffer();
@@ -5506,22 +5144,22 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  var value = node.attrsMap[name];
+          for (var name_1 in node.attrsMap) {
+              if (dirRE.test(name_1)) {
+                  var value = node.attrsMap[name_1];
                   if (value) {
-                      var range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                      var range = node.rawAttrsMap[name_1];
+                      if (name_1 === 'v-for') {
+                          checkFor(node, "v-for=\"" + value + "\"", warn, range);
                       }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                          checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                      else if (onRE.test(name_1)) {
+                          checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
                       else {
-                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                          checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
                   }
               }
@@ -5541,7 +5179,7 @@
       var keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
           warn("avoid using JavaScript unary operator as property name: " +
-              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+              ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -5554,16 +5192,16 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function(("var " + ident + "=_"));
+              new Function("var " + ident + "=_");
           }
           catch (e) {
-              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+              warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function(("return " + exp));
+          new Function("return " + exp);
       }
       catch (e) {
           var keywordMatch = exp
@@ -5571,12 +5209,12 @@
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
               warn("avoid using JavaScript keyword as property name: " +
-                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                  ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
           }
           else {
-              warn("invalid expression: " + (e.message) + " in\n\n" +
-                  "    " + exp + "\n\n" +
-                  "  Raw expression: " + (text.trim()) + "\n", range);
+              warn("invalid expression: " + e.message + " in\n\n" +
+                  ("    " + exp + "\n\n") +
+                  ("  Raw expression: " + text.trim() + "\n"), range);
           }
       }
   }
@@ -5585,18 +5223,17 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-              "    " + exp + "\n\n" +
-              "  Raw expression: " + (text.trim()) + "\n", range);
+          warn("invalid function parameter expression: " + e.message + " in\n\n" +
+              ("    " + exp + "\n\n") +
+              ("  Raw expression: " + text.trim() + "\n"), range);
       }
   }
 
   /* @flow */
   var range = 2;
   function generateCodeFrame(source, start, end) {
-      if ( start === void 0 ) start = 0;
-      if ( end === void 0 ) end = source.length;
-
+      if (start === void 0) { start = 0; }
+      if (end === void 0) { end = source.length; }
       var lines = source.split(/\r?\n/);
       var count = 0;
       var res = [];
@@ -5606,18 +5243,18 @@
               for (var j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
                       { continue; }
-                  res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                  res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                   var lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
                       var pad = start - (count - lineLength) + 1;
-                      var length = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                      var length_1 = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length$1 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat$1("^", length$1));
+                          var length_2 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat("^", length_2));
                       }
                       count += lineLength + 1;
                   }
@@ -5627,7 +5264,7 @@
       }
       return res.join('\n');
   }
-  function repeat$1(str, n) {
+  function repeat(str, n) {
       var result = '';
       if (n > 0) {
           while (true) {
@@ -5650,14 +5287,14 @@
       }
       catch (err) {
           errors.push({ err: err, code: code });
-          return noop;
+          return noop$1;
       }
   }
   function createCompileToFunctionFn(compile) {
       var cache = Object.create(null);
       return function compileToFunctions(template, options, vm) {
           options = extend({}, options);
-          var warn$$1 = options.warn || warn;
+          var warn = options.warn || warn$2;
           delete options.warn;
           /* istanbul ignore if */
           {
@@ -5667,7 +5304,7 @@
               }
               catch (e) {
                   if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
                           'environment with Content Security Policy that prohibits unsafe-eval. ' +
                           'The template compiler cannot work in this environment. Consider ' +
                           'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -5689,13 +5326,13 @@
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
                       compiled.errors.forEach(function (e) {
-                          warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                          warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
-                      warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                      warn("Error compiling template:\n\n" + template + "\n\n" +
+                          compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                           '\n', vm);
                   }
               }
@@ -5721,14 +5358,12 @@
           /* istanbul ignore if */
           {
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn$$1("Failed to generate render function:\n\n" +
+                  warn("Failed to generate render function:\n\n" +
                       fnGenErrors
-                          .map(function (ref) {
-                              var err = ref.err;
-                              var code = ref.code;
-
-                              return ((err.toString()) + " in\n\n" + code + "\n");
-                  })
+                          .map(function (_a) {
+                          var err = _a.err, code = _a.code;
+                          return err.toString() + " in\n\n" + code + "\n";
+                      })
                           .join('\n'), vm);
               }
           }
@@ -5749,15 +5384,15 @@
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                       warn = function (msg, range, tip) {
                           var data = { msg: msg };
                           if (range) {
                               if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
+                                  data.start = range.start + leadingSpaceLength_1;
                               }
                               if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
+                                  data.end = range.end + leadingSpaceLength_1;
                               }
                           }
                           (tip ? tips : errors).push(data);
@@ -5798,7 +5433,7 @@
   var createCompiler = createCompilerCreator(function baseCompile(template, options) {
       var ast = parse(template.trim(), options);
       optimize(ast, options);
-      var code = generate$1(ast, options);
+      var code = generate(ast, options);
       return {
           ast: ast,
           render: code.render,
@@ -5807,9 +5442,7 @@
   });
 
   /* @flow */
-  var ref = createCompiler(baseOptions);
-  var compile = ref.compile;
-  var compileToFunctions = ref.compileToFunctions;
+  var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
   /* @flow */
   // The template compiler attempts to minimize the need for normalization by
@@ -5857,7 +5490,7 @@
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -5901,11 +5534,11 @@
   /* @flow */
   var ssrHelpers = {
       _ssrEscape: escape,
-      _ssrNode: renderStringNode,
+      _ssrNode: renderStringNode$1,
       _ssrList: renderStringList,
       _ssrAttr: renderAttr,
-      _ssrAttrs: renderAttrs$1,
-      _ssrDOMProps: renderDOMProps$1,
+      _ssrAttrs: renderAttrs,
+      _ssrDOMProps: renderDOMProps,
       _ssrClass: renderSSRClass,
       _ssrStyle: renderSSRStyle,
   };
@@ -5926,23 +5559,26 @@
           extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
       }
   }
-  var StringNode = function StringNode(open, close, children, normalizationType) {
-      this.isString = true;
-      this.open = open;
-      this.close = close;
-      if (children) {
-          this.children =
-              normalizationType === 1
-                  ? simpleNormalizeChildren(children)
-                  : normalizationType === 2
-                      ? normalizeChildren(children)
-                      : children;
-      }
-      else {
-          this.children = void 0;
+  var StringNode = /** @class */ (function () {
+      function StringNode(open, close, children, normalizationType) {
+          this.isString = true;
+          this.open = open;
+          this.close = close;
+          if (children) {
+              this.children =
+                  normalizationType === 1
+                      ? simpleNormalizeChildren(children)
+                      : normalizationType === 2
+                          ? normalizeChildren(children)
+                          : children;
+          }
+          else {
+              this.children = void 0;
+          }
       }
-  };
-  function renderStringNode(open, close, children, normalizationType) {
+      return StringNode;
+  }());
+  function renderStringNode$1(open, close, children, normalizationType) {
       return new StringNode(open, close, children, normalizationType);
   }
   function renderStringList(val, render) {
@@ -5967,7 +5603,7 @@
       }
       return ret;
   }
-  function renderAttrs$1(obj) {
+  function renderAttrs(obj) {
       var res = '';
       for (var key in obj) {
           if (isSSRUnsafeAttr(key)) {
@@ -5977,7 +5613,7 @@
       }
       return res;
   }
-  function renderDOMProps$1(obj) {
+  function renderDOMProps(obj) {
       var res = '';
       for (var key in obj) {
           var attr = propsToAttrMap[key] || key.toLowerCase();
@@ -5988,8 +5624,8 @@
       return res;
   }
   function renderSSRClass(staticClass, dynamic) {
-      var res = renderClass(staticClass, dynamic);
-      return res === '' ? res : (" class=\"" + (escape(res)) + "\"");
+      var res = renderClass$1(staticClass, dynamic);
+      return res === '' ? res : " class=\"" + escape(res) + "\"";
   }
   function renderSSRStyle(staticStyle, dynamic, extra) {
       var style = {};
@@ -6000,23 +5636,23 @@
       if (extra)
           { extend(style, extra); }
       var res = genStyle(style);
-      return res === '' ? res : (" style=" + (JSON.stringify(escape(res))));
+      return res === '' ? res : " style=" + JSON.stringify(escape(res));
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
   {
-      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+      var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy_1) {
+          var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+              set: function (target, key, value) {
+                  if (isBuiltInModifier_1(key)) {
+                      warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                       return false;
                   }
                   else {
@@ -6068,25 +5704,25 @@
   }
 
   {
-      var perf = inBrowser && window.performance;
+      var perf_1 = inBrowser && window.performance;
       /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) ;
+      if (perf_1 &&
+          perf_1.mark &&
+          perf_1.measure &&
+          perf_1.clearMarks &&
+          perf_1.clearMeasures) ;
   }
 
   var normalizeEvent = cached(function (name) {
       var passive = name.charAt(0) === '&';
       name = passive ? name.slice(1) : name;
-      var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once$$1 ? name.slice(1) : name;
+      var once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
       var capture = name.charAt(0) === '!';
       name = capture ? name.slice(1) : name;
       return {
           name: name,
-          once: once$$1,
+          once: once,
           capture: capture,
           passive: passive,
       };
@@ -6110,14 +5746,14 @@
       invoker.fns = fns;
       return invoker;
   }
-  function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-      var name, def$$1, cur, old, event;
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      var name, cur, old, event;
       for (name in on) {
-          def$$1 = cur = on[name];
+          cur = on[name];
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+              warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -6136,13 +5772,11 @@
       for (name in oldOn) {
           if (isUndef(on[name])) {
               event = normalizeEvent(name);
-              remove$$1(event.name, oldOn[name], event.capture);
+              remove(event.name, oldOn[name], event.capture);
           }
       }
   }
 
-  /* @flow */
-
   /* @flow */
   function extractPropsFromVNodeData(data, Ctor, tag) {
       // we are only extracting raw values here.
@@ -6153,8 +5787,7 @@
           return;
       }
       var res = {};
-      var attrs = data.attrs;
-      var props = data.props;
+      var attrs = data.attrs, props = data.props;
       if (isDef(attrs) || isDef(props)) {
           for (var key in propOptions) {
               var altKey = hyphenate(key);
@@ -6164,11 +5797,11 @@
                       tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                           (formatComponentName(
                           // @ts-ignore
-                          tag || Ctor)) + ", but the declared prop name is" +
-                          " \"" + key + "\". " +
+                          tag || Ctor) + ", but the declared prop name is") +
+                          (" \"" + key + "\". ") +
                           "Note that HTML attributes are case-insensitive and camelCased " +
                           "props need to use their kebab-case equivalents when using in-DOM " +
-                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                          ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -6215,7 +5848,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -6232,7 +5865,7 @@
           !isPrimitive(data.key)) {
           // @ts-expect-error
           {
-              warn('Avoid using non-primitive value as key, ' +
+              warn$2('Avoid using non-primitive value as key, ' +
                   'use string/number value instead.', context);
           }
       }
@@ -6250,7 +5883,7 @@
       }
       var vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor;
+          var Ctor = void 0;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if ((!data || !data.pre) &&
               isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
@@ -6365,7 +5998,7 @@
           props = props || {};
           if (bindObject) {
               if (!isObject(bindObject)) {
-                  warn('slot v-bind without argument expects an Object', this);
+                  warn$2('slot v-bind without argument expects an Object', this);
               }
               props = extend(extend({}, bindObject), props);
           }
@@ -6424,14 +6057,14 @@
   function bindObjectProps(data, tag, value, asProp, isSync) {
       if (value) {
           if (!isObject(value)) {
-              warn('v-bind without argument expects an Object or Array value', this);
+              warn$2('v-bind without argument expects an Object or Array value', this);
           }
           else {
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash;
-              var loop = function ( key ) {
+              var hash = void 0;
+              var _loop_1 = function (key) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
@@ -6448,14 +6081,15 @@
                       hash[key] = value[key];
                       if (isSync) {
                           var on = data.on || (data.on = {});
-                          on[("update:" + key)] = function ($event) {
+                          on["update:" + key] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
               };
-
-              for (var key in value) loop( key );
+              for (var key in value) {
+                  _loop_1(key);
+              }
           }
       }
       return data;
@@ -6475,7 +6109,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic(tree, ("__static__" + index), false);
+      markStatic(tree, "__static__" + index, false);
       return tree;
   }
   /**
@@ -6483,14 +6117,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
       return tree;
   }
   function markStatic(tree, key, isOnce) {
       if (Array.isArray(tree)) {
           for (var i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+                  markStaticNode(tree[i], key + "_" + i, isOnce);
               }
           }
       }
@@ -6508,7 +6142,7 @@
   function bindObjectListeners(data, value) {
       if (value) {
           if (!isPlainObject(value)) {
-              warn('v-on without argument expects an Object value', this);
+              warn$2('v-on without argument expects an Object value', this);
           }
           else {
               var on = (data.on = data.on ? extend({}, data.on) : {});
@@ -6557,7 +6191,7 @@
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+              warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
           }
       }
       return baseObj;
@@ -6611,8 +6245,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name = data.slot;
-              var slot = slots[name] || (slots[name] = []);
+              var name_1 = data.slot;
+              var slot = slots[name_1] || (slots[name_1] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -6625,9 +6259,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name$1 in slots) {
-          if (slots[name$1].every(isWhitespace)) {
-              delete slots[name$1];
+      for (var name_2 in slots) {
+          if (slots[name_2].every(isWhitespace)) {
+              delete slots[name_2];
           }
       }
       return slots;
@@ -6661,16 +6295,16 @@
       }
       else {
           res = {};
-          for (var key$1 in slots) {
-              if (slots[key$1] && key$1[0] !== '$') {
-                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+          for (var key_1 in slots) {
+              if (slots[key_1] && key_1[0] !== '$') {
+                  res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key$2 in normalSlots) {
-          if (!(key$2 in res)) {
-              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+      for (var key_2 in normalSlots) {
+          if (!(key_2 in res)) {
+              res[key_2] = proxyNormalSlot(normalSlots, key_2);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -6711,15 +6345,6 @@
   }
 
   /* @flow */
-  var currentRenderingInstance = null;
-
-  /* @flow */
-  function ensureCtor(comp, base) {
-      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-          comp = comp.default;
-      }
-      return isObject(comp) ? base.extend(comp) : comp;
-  }
   function createAsyncPlaceholder(factory, data, context, children, tag) {
       var node = createEmptyVNode();
       node.asyncFactory = factory;
@@ -6733,114 +6358,17 @@
       if (isDef(factory.resolved)) {
           return factory.resolved;
       }
-      var owner = currentRenderingInstance;
-      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-          // already pending
-          factory.owners.push(owner);
-      }
       if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
           return factory.loadingComp;
       }
-      if (owner && !isDef(factory.owners)) {
-          var owners = (factory.owners = [owner]);
-          var sync = true;
-          var timerLoading = null;
-          var timerTimeout = null;
-          owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-          var forceRender = function (renderCompleted) {
-              for (var i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
-              }
-              if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
-                  }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
-                  }
-              }
-          };
-          var resolve = once(function (res) {
-              // cache resolved
-              factory.resolved = ensureCtor(res, baseCtor);
-              // invoke callbacks only if this is not a synchronous resolve
-              // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
-              }
-              else {
-                  owners.length = 0;
-              }
-          });
-          var reject = once(function (reason) {
-              warn("Failed to resolve async component: " + (String(factory)) +
-                      (reason ? ("\nReason: " + reason) : ''));
-              if (isDef(factory.errorComp)) {
-                  factory.error = true;
-                  forceRender(true);
-              }
-          });
-          var res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
-                  // () => Promise
-                  if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
-                  }
-              }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
-                  }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
-                          factory.loading = true;
-                      }
-                      else {
-                          // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(function () {
-                              timerLoading = null;
-                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                  factory.loading = true;
-                                  forceRender(false);
-                              }
-                          }, res.delay || 200);
-                      }
-                  }
-                  if (isDef(res.timeout)) {
-                      // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(function () {
-                          timerTimeout = null;
-                          if (isUndef(factory.resolved)) {
-                              reject("timeout (" + (res.timeout) + "ms)");
-                          }
-                      }, res.timeout);
-                  }
-              }
-          }
-          sync = false;
-          // return in case resolved synchronously
-          return factory.loading ? factory.loadingComp : factory.resolved;
-      }
   }
 
-  /* @flow */
-
-  /* @flow */
-
-  /* @flow */
-
   /* @flow */
   var target;
   function add(event, fn) {
       target.$on(event, fn);
   }
-  function remove$1(event, fn) {
+  function remove(event, fn) {
       target.$off(event, fn);
   }
   function createOnceHandler(event, fn) {
@@ -6854,7 +6382,7 @@
   }
   function updateComponentListeners(vm, listeners, oldListeners) {
       target = vm;
-      updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
       target = undefined;
   }
 
@@ -6984,15 +6512,15 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
+      var performance_1 = window.performance;
+      if (performance_1 &&
+          typeof performance_1.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
           // if the event timestamp, although evaluated AFTER the Date.now(), is
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance.now(); };
+          getNow = function () { return performance_1.now(); };
       }
   }
   /**
@@ -7005,10 +6533,6 @@
       vm._inactive = false;
   }
 
-  /* @flow */
-
-  /* @flow */
-
   /* @flow */
   function resolveInject(inject, vm) {
       if (inject) {
@@ -7040,7 +6564,7 @@
                   }
                   else {
                       // @ts-ignore
-                      warn(("Injection \"" + key + "\" not found"), vm);
+                      warn$2("Injection \"" + key + "\" not found", vm);
                   }
               }
           }
@@ -7088,8 +6612,7 @@
 
   /* @flow */
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var this$1 = this;
-
+      var _this = this;
       var options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
@@ -7116,14 +6639,14 @@
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
       this.slots = function () {
-          if (!this$1.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          if (!_this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
           }
-          return this$1.$slots;
+          return _this.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function get() {
+          get: function () {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -7146,7 +6669,9 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+          this._c = function (a, b, c, d) {
+              return createElement(contextVm, a, b, c, d, needNormalization);
+          };
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
@@ -7200,14 +6725,10 @@
       }
   }
 
-  /* @flow */
-
-  /* @flow */
-
   /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function init(vnode, hydrating) {
+      init: function (vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
@@ -7220,7 +6741,7 @@
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function prepatch(oldVnode, vnode) {
+      prepatch: function (oldVnode, vnode) {
           var options = vnode.componentOptions;
           var child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
@@ -7229,9 +6750,8 @@
           options.children // new children
           );
       },
-      insert: function insert(vnode) {
-          var context = vnode.context;
-          var componentInstance = vnode.componentInstance;
+      insert: function (vnode) {
+          var context = vnode.context, componentInstance = vnode.componentInstance;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
               callHook(componentInstance, 'mounted');
@@ -7250,7 +6770,7 @@
               }
           }
       },
-      destroy: function destroy(vnode) {
+      destroy: function (vnode) {
           var componentInstance = vnode.componentInstance;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
@@ -7276,7 +6796,7 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn(("Invalid Component definition: " + (String(Ctor))), context);
+              warn$2("Invalid Component definition: " + String(Ctor), context);
           }
           return;
       }
@@ -7285,7 +6805,7 @@
       // @ts-expect-error
       if (isUndef(Ctor.cid)) {
           asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          Ctor = resolveAsyncComponent(asyncFactory);
           if (Ctor === undefined) {
               // return a placeholder node for async component, which is rendered
               // as a comment node but preserves all the raw information for the node.
@@ -7334,7 +6854,7 @@
       var name = Ctor.options.name || tag;
       var vnode = new VNode(
       // @ts-expect-error
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
       // @ts-expect-error
       { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
       return vnode;
@@ -7365,11 +6885,11 @@
           var toMerge = componentVNodeHooks[key];
           // @ts-expect-error
           if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
           }
       }
   }
-  function mergeHook$1(f1, f2) {
+  function mergeHook(f1, f2) {
       var merged = function (a, b) {
           // flow complains about extra args which is why we use any
           f1(a, b);
@@ -7405,18 +6925,15 @@
       if (!warned[msg]) {
           warned[msg] = true;
           // eslint-disable-next-line no-console
-          console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
+          console.warn("\n\u001B[31m" + msg + "\u001B[39m\n");
       }
   };
   var onCompilationError = function (err, vm) {
       var trace = vm ? generateComponentTrace(vm) : '';
-      throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"));
+      throw new Error("\n\u001B[31m" + err + trace + "\u001B[39m\n");
   };
   var normalizeRender = function (vm) {
-      var ref = vm.$options;
-      var render = ref.render;
-      var template = ref.template;
-      var _scopeId = ref._scopeId;
+      var _a = vm.$options, render = _a.render, template = _a.template, _scopeId = _a._scopeId;
       if (isUndef(render)) {
           if (template) {
               var compiled = compileToFunctions(template, {
@@ -7427,7 +6944,7 @@
               vm.$options.staticRenderFns = compiled.staticRenderFns;
           }
           else {
-              throw new Error(("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous')));
+              throw new Error("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'));
           }
       }
   };
@@ -7455,7 +6972,7 @@
   }
   function renderNode(node, isRoot, context) {
       if (node.isString) {
-          renderStringNode$1(node, context);
+          renderStringNode(node, context);
       }
       else if (isDef(node.componentOptions)) {
           renderComponent(node, isRoot, context);
@@ -7469,7 +6986,7 @@
               renderAsyncComponent(node, isRoot, context);
           }
           else {
-              context.write(("<!--" + (node.text) + "-->"), context.next);
+              context.write("<!--" + node.text + "-->", context.next);
           }
       }
       else {
@@ -7486,9 +7003,7 @@
       return register;
   }
   function renderComponent(node, isRoot, context) {
-      var write = context.write;
-      var next = context.next;
-      var userContext = context.userContext;
+      var write = context.write, next = context.next, userContext = context.userContext;
       // check cache hit
       var Ctor = node.componentOptions.Ctor;
       var getKey = Ctor.options.serverCacheKey;
@@ -7501,13 +7016,12 @@
               renderComponentInner(node, isRoot, context);
               return;
           }
-          var key = name + '::' + rawKey;
-          var has = context.has;
-          var get = context.get;
+          var key_1 = name + '::' + rawKey;
+          var has = context.has, get_1 = context.get;
           if (isDef(has)) {
-              has(key, function (hit) {
-                  if (hit === true && isDef(get)) {
-                      get(key, function (res) {
+              has(key_1, function (hit) {
+                  if (hit === true && isDef(get_1)) {
+                      get_1(key_1, function (res) {
                           if (isDef(registerComponent)) {
                               registerComponent(userContext);
                           }
@@ -7516,12 +7030,12 @@
                       });
                   }
                   else {
-                      renderComponentWithCache(node, isRoot, key, context);
+                      renderComponentWithCache(node, isRoot, key_1, context);
                   }
               });
           }
-          else if (isDef(get)) {
-              get(key, function (res) {
+          else if (isDef(get_1)) {
+              get_1(key_1, function (res) {
                   if (isDef(res)) {
                       if (isDef(registerComponent)) {
                           registerComponent(userContext);
@@ -7530,7 +7044,7 @@
                       write(res.html, next);
                   }
                   else {
-                      renderComponentWithCache(node, isRoot, key, context);
+                      renderComponentWithCache(node, isRoot, key_1, context);
                   }
               });
           }
@@ -7587,10 +7101,7 @@
           if (comp.__esModule && comp.default) {
               comp = comp.default;
           }
-          var ref = node.asyncMeta;
-          var data = ref.data;
-          var children = ref.children;
-          var tag = ref.tag;
+          var _a = node.asyncMeta, data = _a.data, children = _a.children, tag = _a.tag;
           var nodeContext = node.asyncMeta.context;
           var resolvedNode = createComponent(comp, data, nodeContext, children, tag);
           if (resolvedNode) {
@@ -7644,9 +7155,8 @@
           }
       }
   }
-  function renderStringNode$1(el, context) {
-      var write = context.write;
-      var next = context.next;
+  function renderStringNode(el, context) {
+      var write = context.write, next = context.next;
       if (isUndef(el.children) || el.children.length === 0) {
           write(el.open + (el.close || ''), next);
       }
@@ -7663,8 +7173,7 @@
       }
   }
   function renderElement(el, isRoot, context) {
-      var write = context.write;
-      var next = context.next;
+      var write = context.write, next = context.next;
       if (isTrue(isRoot)) {
           if (!el.data)
               { el.data = {}; }
@@ -7676,7 +7185,7 @@
           registerComponentForCache(el.fnOptions, write);
       }
       var startTag = renderStartingTag(el, context);
-      var endTag = "</" + (el.tag) + ">";
+      var endTag = "</" + el.tag + ">";
       if (context.isUnaryTag(el.tag)) {
           write(startTag, next);
       }
@@ -7715,9 +7224,8 @@
       return dir;
   }
   function renderStartingTag(node, context) {
-      var markup = "<" + (node.tag);
-      var directives = context.directives;
-      var modules = context.modules;
+      var markup = "<" + node.tag;
+      var directives = context.directives, modules = context.modules;
       // construct synthetic data for module processing
       // because modules like style also produce code by parent VNode data
       if (isUndef(node.data) && hasAncestorData(node)) {
@@ -7728,9 +7236,9 @@
           var dirs = node.data.directives;
           if (dirs) {
               for (var i = 0; i < dirs.length; i++) {
-                  var name = dirs[i].name;
-                  if (name !== 'show') {
-                      var dirRenderer = resolveAsset(context, 'directives', name);
+                  var name_1 = dirs[i].name;
+                  if (name_1 !== 'show') {
+                      var dirRenderer = resolveAsset(context, 'directives', name_1);
                       if (dirRenderer) {
                           // directives mutate the node's data
                           // which then gets rendered by modules
@@ -7745,8 +7253,8 @@
               directives.show(node, vshowDirectiveInfo);
           }
           // apply other modules
-          for (var i$1 = 0; i$1 < modules.length; i$1++) {
-              var res = modules[i$1](node);
+          for (var i = 0; i < modules.length; i++) {
+              var res = modules[i](node);
               if (res) {
                   markup += res;
               }
@@ -7761,7 +7269,7 @@
           markup += " " + scopeId;
       }
       if (isDef(node.fnScopeId)) {
-          markup += " " + (node.fnScopeId);
+          markup += " " + node.fnScopeId;
       }
       else {
           while (isDef(node)) {
@@ -7798,13 +7306,8 @@
   }
 
   /* @flow */
-  function createBasicRenderer(ref) {
-      if ( ref === void 0 ) ref = {};
-      var modules = ref.modules; if ( modules === void 0 ) modules = [];
-      var directives = ref.directives; if ( directives === void 0 ) directives = {};
-      var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = function () { return false; };
-      var cache = ref.cache;
-
+  function createBasicRenderer(_a) {
+      var _b = _a === void 0 ? {} : _a, _c = _b.modules, modules = _c === void 0 ? [] : _c, _d = _b.directives, directives = _d === void 0 ? {} : _d, _e = _b.isUnaryTag, isUnaryTag = _e === void 0 ? function () { return false; } : _e, cache = _b.cache;
       var render = createRenderFunction(modules, directives, isUnaryTag, cache);
       return function renderToString(component, context, done) {
           if (typeof context === 'function') {
@@ -7831,12 +7334,12 @@
   /* @flow */
   var entryServerBasicRenderer = createBasicRenderer({
       // @ts-expect-error
-      modules: modules,
-      directives: directives,
+      modules: modules$1,
+      directives: directives$1,
       isUnaryTag: isUnaryTag,
       canBeLeftOpenTag: canBeLeftOpenTag,
   });
 
   return entryServerBasicRenderer;
 
-}));
+})));
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index 8f3479b24b0..57ff848bf42 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -3,7 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var stream = require('stream');
-var he = require('he');
 
 /* @flow */
 var emptyObject = Object.freeze({});
@@ -106,7 +105,7 @@ var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove(arr, item) {
+function remove$1(arr, item) {
     if (arr.length) {
         var index = arr.indexOf(item);
         if (index > -1) {
@@ -151,31 +150,6 @@ var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        var l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Mix properties into target object.
  */
@@ -203,7 +177,7 @@ function toObject(arr) {
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop(a, b, c) { }
+function noop$1(a, b, c) { }
 /**
  * Always return false.
  */
@@ -282,18 +256,6 @@ function looseIndexOf(arr, val) {
     }
     return -1;
 }
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    var called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
 
 /* @flow */
 var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
@@ -383,7 +345,7 @@ var noUnitNumericStyleProps = {
 /* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+makeMap('style,class');
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
@@ -413,22 +375,22 @@ var isFalsyAttrValue = function (val) {
 };
 
 /* @flow */
-function renderAttrs(node) {
+function renderAttrs$1(node) {
     var attrs = node.data.attrs;
     var res = '';
     var opts = node.parent && node.parent.componentOptions;
     if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-        var parent = node.parent;
-        while (isDef(parent)) {
+        var parent_1 = node.parent;
+        while (isDef(parent_1)) {
             // Stop fallthrough in case parent has inheritAttrs option set to false
-            if (parent.componentOptions &&
-                parent.componentOptions.Ctor.options.inheritAttrs === false) {
+            if (parent_1.componentOptions &&
+                parent_1.componentOptions.Ctor.options.inheritAttrs === false) {
                 break;
             }
-            if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                attrs = extend(extend({}, attrs), parent.data.attrs);
+            if (isDef(parent_1.data) && isDef(parent_1.data.attrs)) {
+                attrs = extend(extend({}, attrs), parent_1.data.attrs);
             }
-            parent = parent.parent;
+            parent_1 = parent_1.parent;
         }
     }
     if (isUndef(attrs)) {
@@ -449,55 +411,57 @@ function renderAttrs(node) {
 function renderAttr(key, value) {
     if (isBooleanAttr(key)) {
         if (!isFalsyAttrValue(value)) {
-            return (" " + key + "=\"" + key + "\"");
+            return " " + key + "=\"" + key + "\"";
         }
     }
     else if (isEnumeratedAttr(key)) {
-        return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"");
+        return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
     }
     else if (!isFalsyAttrValue(value)) {
-        return (" " + key + "=\"" + (escape(String(value))) + "\"");
+        return " " + key + "=\"" + escape(String(value)) + "\"";
     }
     return '';
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
+    if (text === void 0) { text = ''; }
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -531,7 +495,7 @@ function cloneVNode(vnode) {
 }
 
 /* @flow */
-function renderDOMProps(node) {
+function renderDOMProps$1(node) {
     var props = node.data.domProps;
     var res = '';
     var parent = node.parent;
@@ -605,21 +569,24 @@ typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
 var nativeWatch = {}.watch;
+var supportsPassive = false;
 if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get: function () {
+                /* istanbul ignore next */
+                supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
         // @ts-ignore
@@ -645,9 +612,6 @@ var isServerRendering = function () {
     }
     return _isServer;
 };
-// detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
@@ -663,20 +627,19 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
+    _Set = /** @class */ (function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function has (key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function add (key) {
+        Set.prototype.add = function (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function clear () {
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
         };
-
         return Set;
     }());
 }
@@ -755,7 +718,7 @@ var config = {
     /**
      * Get the namespace of an element
      */
-    getTagNamespace: noop,
+    getTagNamespace: noop$1,
     /**
      * Parse the real tag name for the specific platform.
      */
@@ -777,22 +740,24 @@ var config = {
 };
 
 /* @flow */
-var warn = noop;
-var tip = noop;
+var warn$2 = noop$1;
+var tip = noop$1;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn = function (msg, vm) {
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+        if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole && !config.silent) {
+        if (hasConsole_1 && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -815,10 +780,10 @@ var formatComponentName;
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    var repeat = function (str, n) {
+    var repeat_1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -852,13 +817,15 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
@@ -868,28 +835,31 @@ var uid = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
-    }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid++;
+        this.subs = [];
     }
-};
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$1(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -925,9 +895,12 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
+        var arguments$1 = arguments;
 
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -963,43 +936,46 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
     }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive$$1(obj, keys[i]);
-    }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
-    }
-};
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -1049,7 +1025,7 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
+function defineReactive(obj, key, val, customSetter, shallow) {
     var dep = new Dep();
     var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -1108,8 +1084,8 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
  * already exist.
  */
 function set(target, key, val) {
-    if (isUndef(target) || isPrimitive(target)) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -1123,7 +1099,7 @@ function set(target, key, val) {
     var ob = target.__ob__;
     // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
         return val;
     }
@@ -1131,7 +1107,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -1140,7 +1116,7 @@ function set(target, key, val) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1162,7 +1138,7 @@ var strats = config.optionMergeStrategies;
 {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
+            warn$2("option \"" + key + "\" can only be used during instance " +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1238,7 +1214,7 @@ function mergeDataOrFn(parentVal, childVal, vm) {
 strats.data = function (parentVal, childVal, vm) {
     if (!vm) {
         if (childVal && typeof childVal !== 'function') {
-            warn('The "data" option should be a function ' +
+            warn$2('The "data" option should be a function ' +
                     'that returns a per-instance value in component ' +
                     'definitions.', vm);
             return parentVal;
@@ -1250,7 +1226,7 @@ strats.data = function (parentVal, childVal, vm) {
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(parentVal, childVal) {
+function mergeHook$1(parentVal, childVal) {
     var res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
@@ -1270,7 +1246,7 @@ function dedupeHooks(hooks) {
     return res;
 }
 LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+    strats[hook] = mergeHook$1;
 });
 /**
  * Assets
@@ -1316,14 +1292,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key$1] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1361,14 +1337,14 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-        warn('Invalid component name: "' +
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+        warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
             'should conform to valid custom element name in html5 specification.');
     }
     if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
             'id: ' +
             name);
     }
@@ -1392,7 +1368,7 @@ function normalizeProps(options, vm) {
                 res[name] = { type: null };
             }
             else {
-                warn('props must be strings when using array syntax.');
+                warn$2('props must be strings when using array syntax.');
             }
         }
     }
@@ -1404,8 +1380,8 @@ function normalizeProps(options, vm) {
         }
     }
     else {
-        warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
+            ("but got " + toRawType(props) + "."), vm);
     }
     options.props = res;
 }
@@ -1431,8 +1407,8 @@ function normalizeInject(options, vm) {
         }
     }
     else {
-        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
+            ("but got " + toRawType(inject) + "."), vm);
     }
 }
 /**
@@ -1442,17 +1418,17 @@ function normalizeDirectives(options) {
     var dirs = options.directives;
     if (dirs) {
         for (var key in dirs) {
-            var def$$1 = dirs[key];
-            if (typeof def$$1 === 'function') {
-                dirs[key] = { bind: def$$1, update: def$$1 };
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
             }
         }
     }
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 /**
@@ -1523,7 +1499,7 @@ function resolveAsset(options, type, id, warnMissing) {
     // fallback to prototype chain
     var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
     return res;
 }
@@ -1574,7 +1550,7 @@ function getPropDefaultValue(vm, prop, key) {
     var def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (isObject(def)) {
-        warn('Invalid default value for prop "' +
+        warn$2('Invalid default value for prop "' +
             key +
             '": ' +
             'Props with type Object/Array must use a factory function ' +
@@ -1599,7 +1575,7 @@ function getPropDefaultValue(vm, prop, key) {
  */
 function assertProp(prop, name, value, vm, absent) {
     if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
+        warn$2('Missing required prop: "' + name + '"', vm);
         return;
     }
     if (value == null && !prop.required) {
@@ -1621,13 +1597,13 @@ function assertProp(prop, name, value, vm, absent) {
     }
     var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
     if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
     var validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
@@ -1654,7 +1630,7 @@ function assertType(value, type, vm) {
             valid = value instanceof type;
         }
         catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
             valid = false;
         }
     }
@@ -1689,7 +1665,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1697,24 +1673,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += " with value " + styleValue(value, expectedType);
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += "with value " + styleValue(value, receivedType) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return "\"" + value + "\"";
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return "" + Number(value);
     }
     else {
-        return ("" + value);
+        return "" + value;
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1722,9 +1698,12 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
+    var arguments$1 = arguments;
 
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments$1[_i];
+    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1778,7 +1757,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1814,16 +1793,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
+    var counter_1 = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
 }
 else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/* @flow */
+else ;
 
 /* @flow */
 function genClassForVnode(vnode) {
@@ -1841,7 +1819,7 @@ function genClassForVnode(vnode) {
             data = mergeClassData(data, parentNode.data);
         }
     }
-    return renderClass(data.staticClass, data.class);
+    return renderClass$1(data.staticClass, data.class);
 }
 function mergeClassData(child, parent) {
     return {
@@ -1849,7 +1827,7 @@ function mergeClassData(child, parent) {
         class: isDef(child.class) ? [child.class, parent.class] : parent.class,
     };
 }
-function renderClass(staticClass, dynamicClass) {
+function renderClass$1(staticClass, dynamicClass) {
     if (isDef(staticClass) || isDef(dynamicClass)) {
         return concat(staticClass, stringifyClass(dynamicClass));
     }
@@ -1927,15 +1905,13 @@ function getTagNamespace(tag) {
         return 'math';
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+makeMap('text,number,password,search,email,tel,url');
 
 /* @flow */
-
-/* @flow */
-function renderClass$1(node) {
+function renderClass(node) {
     var classList = genClassForVnode(node);
     if (classList !== '') {
-        return (" class=\"" + (escape(classList)) + "\"");
+        return " class=\"" + escape(classList) + "\"";
     }
 }
 
@@ -2020,7 +1996,7 @@ function normalizeValue(key, value) {
     if (typeof value === 'string' ||
         (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
         value === 0) {
-        return (key + ":" + value + ";");
+        return key + ":" + value + ";";
     }
     else {
         // invalid values
@@ -2030,11 +2006,11 @@ function normalizeValue(key, value) {
 function renderStyle(vnode) {
     var styleText = genStyle(getStyle(vnode, false));
     if (styleText !== '') {
-        return (" style=" + (JSON.stringify(escape(styleText))));
+        return " style=" + JSON.stringify(escape(styleText));
     }
 }
 
-var modules = [renderAttrs, renderDOMProps, renderClass$1, renderStyle];
+var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
 /* @flow */
 function show(node, dir) {
@@ -2052,7 +2028,7 @@ function show(node, dir) {
 /* @flow */
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
-function model(node, dir) {
+function model$2(node, dir) {
     if (!node.children)
         { return; }
     var value = dir.value;
@@ -2087,9 +2063,9 @@ function setSelected(option) {
     attrs.selected = '';
 }
 
-var baseDirectives = {
+var baseDirectives$1 = {
     show: show,
-    model: model,
+    model: model$2,
 };
 
 /* @flow */
@@ -2106,17 +2082,48 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
 /* @flow */
 var MAX_STACK_DEPTH = 800;
-var noop$1 = function (_) { return _; };
+var noop = function (_) { return _; };
 var defer = typeof process !== 'undefined' && process.nextTick
     ? process.nextTick
     : typeof Promise !== 'undefined'
         ? function (fn) { return Promise.resolve().then(fn); }
         : typeof setTimeout !== 'undefined'
             ? setTimeout
-            : noop$1;
-if (defer === noop$1) {
+            : noop;
+if (defer === noop) {
     throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
         'that are required by vue-server-renderer. Please use a polyfill for ' +
         'either Promise or setTimeout.');
@@ -2153,44 +2160,40 @@ function createWriteFunction(write, onError) {
 }
 
 /* @flow */
-var RenderStream = /*@__PURE__*/(function (Readable) {
+var RenderStream = /** @class */ (function (_super) {
+    __extends(RenderStream, _super);
     function RenderStream(render) {
-        var this$1 = this;
-
-        Readable.call(this);
-        this.buffer = '';
+        var _this = _super.call(this) || this;
+        _this.buffer = '';
         //@ts-expect-error
-        this.render = render;
-        this.expectedSize = 0;
-        this.write = createWriteFunction(function (text, next) {
-            var n = this$1.expectedSize;
-            this$1.buffer += text;
-            if (this$1.buffer.length >= n) {
-                this$1.next = next;
-                this$1.pushBySize(n);
+        _this.render = render;
+        _this.expectedSize = 0;
+        _this.write = createWriteFunction(function (text, next) {
+            var n = _this.expectedSize;
+            _this.buffer += text;
+            if (_this.buffer.length >= n) {
+                _this.next = next;
+                _this.pushBySize(n);
                 return true; // we will decide when to call next
             }
             return false;
         }, function (err) {
-            this$1.emit('error', err);
+            _this.emit('error', err);
         });
-        this.end = function () {
-            this$1.emit('beforeEnd');
+        _this.end = function () {
+            _this.emit('beforeEnd');
             // the rendering is finished; we should push out the last of the buffer.
-            this$1.done = true;
-            this$1.push(this$1.buffer);
+            _this.done = true;
+            _this.push(_this.buffer);
         };
+        return _this;
     }
-
-    if ( Readable ) RenderStream.__proto__ = Readable;
-    RenderStream.prototype = Object.create( Readable && Readable.prototype );
-    RenderStream.prototype.constructor = RenderStream;
-    RenderStream.prototype.pushBySize = function pushBySize (n) {
+    RenderStream.prototype.pushBySize = function (n) {
         var bufferToPush = this.buffer.substring(0, n);
         this.buffer = this.buffer.substring(n);
         this.push(bufferToPush);
     };
-    RenderStream.prototype.tryRender = function tryRender () {
+    RenderStream.prototype.tryRender = function () {
         try {
             this.render(this.write, this.end);
         }
@@ -2198,7 +2201,7 @@ var RenderStream = /*@__PURE__*/(function (Readable) {
             this.emit('error', e);
         }
     };
-    RenderStream.prototype.tryNext = function tryNext () {
+    RenderStream.prototype.tryNext = function () {
         try {
             this.next();
         }
@@ -2206,7 +2209,7 @@ var RenderStream = /*@__PURE__*/(function (Readable) {
             this.emit('error', e);
         }
     };
-    RenderStream.prototype._read = function _read (n) {
+    RenderStream.prototype._read = function (n) {
         this.expectedSize = n;
         // it's possible that the last chunk added bumped the buffer up to > 2 * n,
         // which means we will need to go through multiple read calls to drain it
@@ -2228,90 +2231,94 @@ var RenderStream = /*@__PURE__*/(function (Readable) {
             this.tryNext();
         }
     };
-
     return RenderStream;
 }(stream.Readable));
 
 /* @flow */
-var RenderContext = function RenderContext(options) {
-    this.userContext = options.userContext;
-    this.activeInstance = options.activeInstance;
-    this.renderStates = [];
-    this.write = options.write;
-    this.done = options.done;
-    this.renderNode = options.renderNode;
-    this.isUnaryTag = options.isUnaryTag;
-    this.modules = options.modules;
-    this.directives = options.directives;
-    var cache = options.cache;
-    if (cache && (!cache.get || !cache.set)) {
-        throw new Error('renderer cache must implement at least get & set.');
-    }
-    this.cache = cache;
-    this.get = cache && normalizeAsync(cache, 'get');
-    this.has = cache && normalizeAsync(cache, 'has');
+var RenderContext = /** @class */ (function () {
+    function RenderContext(options) {
+        this.userContext = options.userContext;
+        this.activeInstance = options.activeInstance;
+        this.renderStates = [];
+        this.write = options.write;
+        this.done = options.done;
+        this.renderNode = options.renderNode;
+        this.isUnaryTag = options.isUnaryTag;
+        this.modules = options.modules;
+        this.directives = options.directives;
+        var cache = options.cache;
+        if (cache && (!cache.get || !cache.set)) {
+            throw new Error('renderer cache must implement at least get & set.');
+        }
+        this.cache = cache;
+        this.get = cache && normalizeAsync(cache, 'get');
+        this.has = cache && normalizeAsync(cache, 'has');
+        //@ts-expect-error
+        this.next = this.next.bind(this);
+    }
     //@ts-expect-error
-    this.next = this.next.bind(this);
-};
-//@ts-expect-error
-RenderContext.prototype.next = function next () {
-    // eslint-disable-next-line
-    while (true) {
-        var lastState = this.renderStates[this.renderStates.length - 1];
-        if (isUndef(lastState)) {
-            return this.done();
-        }
-        /* eslint-disable no-case-declarations */
-        switch (lastState.type) {
-            case 'Element':
-            case 'Fragment':
-                var children = lastState.children;
-            var total = lastState.total;
-                var rendered = lastState.rendered++;
-                if (rendered < total) {
-                    return this.renderNode(children[rendered], false, this);
-                }
-                else {
-                    this.renderStates.pop();
-                    if (lastState.type === 'Element') {
-                        return this.write(lastState.endTag, this.next);
+    RenderContext.prototype.next = function () {
+        var _loop_1 = function () {
+            var lastState = this_1.renderStates[this_1.renderStates.length - 1];
+            if (isUndef(lastState)) {
+                return { value: this_1.done() };
+            }
+            /* eslint-disable no-case-declarations */
+            switch (lastState.type) {
+                case 'Element':
+                case 'Fragment':
+                    var children = lastState.children, total = lastState.total;
+                    var rendered = lastState.rendered++;
+                    if (rendered < total) {
+                        return { value: this_1.renderNode(children[rendered], false, this_1) };
                     }
-                }
-                break;
-            case 'Component':
-                this.renderStates.pop();
-                this.activeInstance = lastState.prevActive;
-                break;
-            case 'ComponentWithCache':
-                this.renderStates.pop();
-                var buffer = lastState.buffer;
-            var bufferIndex = lastState.bufferIndex;
-            var componentBuffer = lastState.componentBuffer;
-            var key = lastState.key;
-                var result = {
-                    html: buffer[bufferIndex],
-                    components: componentBuffer[bufferIndex],
-                };
-                this.cache.set(key, result);
-                if (bufferIndex === 0) {
-                    // this is a top-level cached component,
-                    // exit caching mode.
-                    //@ts-expect-error
-                    this.write.caching = false;
-                }
-                else {
-                    // parent component is also being cached,
-                    // merge self into parent's result
-                    buffer[bufferIndex - 1] += result.html;
-                    var prev = componentBuffer[bufferIndex - 1];
-                    result.components.forEach(function (c) { return prev.add(c); });
-                }
-                buffer.length = bufferIndex;
-                componentBuffer.length = bufferIndex;
-                break;
+                    else {
+                        this_1.renderStates.pop();
+                        if (lastState.type === 'Element') {
+                            return { value: this_1.write(lastState.endTag, this_1.next) };
+                        }
+                    }
+                    break;
+                case 'Component':
+                    this_1.renderStates.pop();
+                    this_1.activeInstance = lastState.prevActive;
+                    break;
+                case 'ComponentWithCache':
+                    this_1.renderStates.pop();
+                    var buffer = lastState.buffer, bufferIndex = lastState.bufferIndex, componentBuffer = lastState.componentBuffer, key = lastState.key;
+                    var result = {
+                        html: buffer[bufferIndex],
+                        components: componentBuffer[bufferIndex],
+                    };
+                    this_1.cache.set(key, result);
+                    if (bufferIndex === 0) {
+                        // this is a top-level cached component,
+                        // exit caching mode.
+                        //@ts-expect-error
+                        this_1.write.caching = false;
+                    }
+                    else {
+                        // parent component is also being cached,
+                        // merge self into parent's result
+                        buffer[bufferIndex - 1] += result.html;
+                        var prev_1 = componentBuffer[bufferIndex - 1];
+                        result.components.forEach(function (c) { return prev_1.add(c); });
+                    }
+                    buffer.length = bufferIndex;
+                    componentBuffer.length = bufferIndex;
+                    break;
+            }
+        };
+        var this_1 = this;
+        // eslint-disable-next-line
+        while (true) {
+            var state_1 = _loop_1();
+            if (typeof state_1 === "object")
+                { return state_1.value; }
         }
-    }
-};
+    };
+    return RenderContext;
+}());
 function normalizeAsync(cache, method) {
     var fn = cache[method];
     if (isUndef(fn)) {
@@ -2404,7 +2411,9 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p = (void 0);
+                var p 
+                // find first non-whitespace prev char
+                = void 0;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -2438,12 +2447,12 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return ("_f(\"" + filter + "\")(" + exp + ")");
+        return "_f(\"" + filter + "\")(" + exp + ")";
     }
     else {
-        var name = filter.slice(0, i);
+        var name_1 = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
     }
 }
 
@@ -2474,7 +2483,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push(("_s(" + exp + ")"));
+        tokens.push("_s(" + exp + ")");
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -2491,7 +2500,7 @@ function parseText(text, delimiters) {
 /* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+    console.error("[Vue compiler]: " + msg);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -2525,7 +2534,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -2656,7 +2665,7 @@ function rangeSetItem(item, range) {
 }
 
 /* @flow */
-function transformNode(el, options) {
+function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
     if (staticClass) {
@@ -2676,24 +2685,24 @@ function transformNode(el, options) {
         el.classBinding = classBinding;
     }
 }
-function genData(el) {
+function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + (el.staticClass) + ",";
+        data += "staticClass:" + el.staticClass + ",";
     }
     if (el.classBinding) {
-        data += "class:" + (el.classBinding) + ",";
+        data += "class:" + el.classBinding + ",";
     }
     return data;
 }
 var klass = {
     staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData,
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
 /* @flow */
-function transformNode$1(el, options) {
+function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
@@ -2717,16 +2726,16 @@ function transformNode$1(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + (el.staticStyle) + ",";
+        data += "staticStyle:" + el.staticStyle + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + (el.styleBinding) + "),";
+        data += "style:(" + el.styleBinding + "),";
     }
     return data;
 }
 var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
+    transformNode: transformNode,
     genData: genData$1,
 };
 
@@ -2736,11 +2745,11 @@ var style = {
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
+var startTagOpen = new RegExp("^<" + qnameCapture);
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -2761,7 +2770,9 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+};
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -2769,11 +2780,11 @@ function decodeAttr(value, shouldDecodeNewlines) {
 function parseHTML(html, options) {
     var stack = [];
     var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var isUnaryTag = options.isUnaryTag || no;
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    while (html) {
+    var _loop_1 = function () {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -2787,7 +2798,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        continue;
+                        return "continue";
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -2795,14 +2806,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        continue;
+                        return "continue";
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    continue;
+                    return "continue";
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -2810,7 +2821,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
+                    return "continue";
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -2819,10 +2830,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    continue;
+                    return "continue";
                 }
             }
-            var text = (void 0), rest = (void 0), next = (void 0);
+            var text = void 0, rest = void 0, next = void 0;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -2849,18 +2860,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength = 0;
-            var stackedTag = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+            var endTagLength_1 = 0;
+            var stackedTag_1 = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag_1] ||
+                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+            var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength_1 = endTag.length;
+                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -2868,20 +2879,25 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest$1.length;
-            html = rest$1;
-            parseEndTag(stackedTag, index - endTagLength, index);
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag_1, index - endTagLength_1, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                     start: index + html.length,
                 });
             }
-            break;
+            return "break";
         }
+    };
+    while (html) {
+        var state_1 = _loop_1();
+        if (state_1 === "break")
+            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -2898,7 +2914,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end, attr;
+            var end = void 0, attr = void 0;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -2921,11 +2937,11 @@ function parseHTML(html, options) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
             }
-            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var unary = isUnaryTag(tagName) || !!unarySlash;
         var l = match.attrs.length;
         var attrs = new Array(l);
         for (var i = 0; i < l; i++) {
@@ -2979,9 +2995,9 @@ function parseHTML(html, options) {
         if (pos >= 0) {
             // Close all the open elements, up the stack
             for (var i = stack.length - 1; i >= pos; i--) {
-                if (i > pos || !tagName &&
+                if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -3015,25 +3031,23 @@ function parseHTML(html, options) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                "? " + baseValueExpression + ".trim()" +
-                ": " + baseValueExpression + ")";
+                ("? " + baseValueExpression + ".trim()") +
+                (": " + baseValueExpression + ")");
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: ("(" + value + ")"),
+        value: "(" + value + ")",
         expression: JSON.stringify(value),
-        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
     };
 }
 /**
@@ -3042,10 +3056,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return (value + "=" + assignment);
+        return value + "=" + assignment;
     }
     else {
-        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
     }
 }
 /**
@@ -3139,6 +3153,7 @@ function parseString(chr) {
 }
 
 /* @flow */
+var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -3235,8 +3250,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                    var name_1 = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -3262,7 +3277,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode;
+            var lastNode = void 0;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -3272,7 +3287,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -3289,7 +3304,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function start(tag, attrs, unary, start$1, end) {
+        start: function (tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -3304,7 +3319,7 @@ function parse(template, options) {
             }
             {
                 if (options.outputSourceRange) {
-                    element.start = start$1;
+                    element.start = start;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -3325,7 +3340,7 @@ function parse(template, options) {
                 element.forbidden = true;
                 warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        "<" + tag + ">" +
+                        ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -3364,24 +3379,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function end(tag, start, end$1) {
+        end: function (tag, start, end) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (options.outputSourceRange) {
-                element.end = end$1;
+                element.end = end;
             }
             closeElement(element);
         },
-        chars: function chars(text, start, end) {
+        chars: function (text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                             start: start,
                         });
                     }
@@ -3421,8 +3436,8 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res;
-                var child;
+                var res = void 0;
+                var child = void 0;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -3448,7 +3463,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function comment(text, start, end) {
+        comment: function (text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -3518,11 +3533,11 @@ function processKey(el) {
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent = el.parent;
+                var parent_1 = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
+                    parent_1 &&
+                    parent_1.tag === 'transition-group') {
                     warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
@@ -3546,7 +3561,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -3599,7 +3614,7 @@ function processIfConditions(el, parent) {
     }
     else {
         warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -3610,7 +3625,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -3624,8 +3639,8 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
+    var once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
         el.once = true;
     }
 }
@@ -3647,7 +3662,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -3679,45 +3694,41 @@ function processSlotContent(el) {
                             "the receiving component", el);
                     }
                 }
-                var ref = getSlotName(slotBinding);
-                var name = ref.name;
-                var dynamic = ref.dynamic;
-                el.slotTarget = name;
+                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                el.slotTarget = name_2;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding$1) {
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
                         warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
                         warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding$1);
+                            "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var ref$1 = getSlotName(slotBinding$1);
-                var name$1 = ref$1.name;
-                var dynamic$1 = ref$1.dynamic;
-                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name$1;
-                slotContainer.slotTargetDynamic = dynamic$1;
-                slotContainer.children = el.children.filter(function (c) {
+                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                slotContainer_1.slotTarget = name_3;
+                slotContainer_1.slotTargetDynamic = dynamic;
+                slotContainer_1.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer;
+                        c.parent = slotContainer_1;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -3740,7 +3751,7 @@ function getSlotName(binding) {
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: ("\"" + name + "\""), dynamic: false };
+            { name: "\"" + name + "\"", dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
@@ -3786,7 +3797,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -3800,14 +3811,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -3884,11 +3895,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret = {};
+        var ret_1 = {};
         match.forEach(function (m) {
-            ret[m.slice(1)] = true;
+            ret_1[m.slice(1)] = true;
         });
-        return ret;
+        return ret_1;
     }
 }
 function makeAttrsMap(attrs) {
@@ -3930,7 +3941,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -3947,16 +3958,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding;
+        var typeBinding = void 0;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + (map['v-bind']) + ").type";
+            typeBinding = "(" + map['v-bind'] + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -4006,15 +4017,15 @@ var model$1 = {
     preTransformNode: preTransformNode,
 };
 
-var modules$1 = [klass, style, model$1];
+var modules = [klass, style, model$1];
 
 /* @flow */
-var warn$2;
+var warn;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
-function model$2(el, dir, _warn) {
-    warn$2 = _warn;
+function model(el, dir, _warn) {
+    warn = _warn;
     var value = dir.value;
     var modifiers = dir.modifiers;
     var tag = el.tag;
@@ -4023,7 +4034,7 @@ function model$2(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -4058,25 +4069,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        "?_i(" + value + "," + valueBinding + ")>-1" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
         (trueValueBinding === 'true'
-            ? (":(" + value + ")")
-            : (":_q(" + value + "," + trueValueBinding + ")")));
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
         'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
         '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -4084,10 +4095,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        "return " + (number ? '_n(val)' : 'val') + "})";
+        ("return " + (number ? '_n(val)' : 'val') + "})");
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
+    code = code + " " + genAssignmentCode(value, assignment);
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -4095,18 +4106,15 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     {
-        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value$1 && !typeBinding) {
+        if (value_1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -4120,7 +4128,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', ("(" + value + ")"));
+    addProp(el, 'value', "(" + value + ")");
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -4130,19 +4138,19 @@ function genDefaultModel(el, value, modifiers) {
 /* @flow */
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
 /* @flow */
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
     }
 }
 
 var directives = {
-    model: model$2,
+    model: model,
     text: text,
     html: html,
 };
@@ -4150,7 +4158,7 @@ var directives = {
 /* @flow */
 var baseOptions = {
     expectHTML: true,
-    modules: modules$1,
+    modules: modules,
     directives: directives,
     isPreTag: isPreTag,
     isUnaryTag: isUnaryTag,
@@ -4159,7 +4167,7 @@ var baseOptions = {
     isReservedTag: isReservedTag,
     getTagNamespace: getTagNamespace,
     // @ts-ignore
-    staticKeys: genStaticKeys(modules$1),
+    staticKeys: genStaticKeys(modules),
 };
 
 /* @flow */
@@ -4197,7 +4205,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -4214,19 +4222,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name in events) {
-        var handlerCode = genHandler(events[name]);
+    for (var name_1 in events) {
+        var handlerCode = genHandler(events[name_1]);
         //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += name + "," + handlerCode + ",";
+        if (events[name_1] && events[name_1].dynamic) {
+            dynamicHandlers += name_1 + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
     if (dynamicHandlers) {
-        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
     }
     else {
         return prefix + staticHandlers;
@@ -4237,7 +4245,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -4246,13 +4254,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        for (var key in handler.modifiers) {
+        var _loop_1 = function (key) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -4261,15 +4269,18 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers = handler.modifiers;
+                var modifiers_1 = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
+        };
+        for (var key in handler.modifiers) {
+            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -4279,13 +4290,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            ? "return " + handler.value + ".apply(null, arguments)"
             : isFunctionExpression
-                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                ? "return (" + handler.value + ").apply(null, arguments)"
                 : isFunctionInvocation
-                    ? ("return " + (handler.value))
+                    ? "return " + handler.value
                     : handler.value;
-        return ("function($event){" + code + handlerCode + "}");
+        return "function($event){" + code + handlerCode + "}";
     }
 }
 function genKeyFilter(keys) {
@@ -4294,60 +4305,65 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&')) + ")return null;");
+        (keys.map(genFilterCode).join('&&') + ")return null;"));
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return ("$event.keyCode!==" + keyVal);
+        return "$event.keyCode!==" + keyVal;
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key)) + "," +
-        (JSON.stringify(keyCode)) + "," +
+        (JSON.stringify(key) + ",") +
+        (JSON.stringify(keyCode) + ",") +
         "$event.key," +
-        "" + (JSON.stringify(keyName)) +
+        ("" + JSON.stringify(keyName)) +
         ")");
 }
 
 /* @flow */
 function on(el, dir) {
     if (dir.modifiers) {
-        warn("v-on without argument does not support modifiers.");
+        warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
 /* @flow */
-function bind$1(el, dir) {
+function bind(el, dir) {
     el.wrapData = function (code) {
-        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
 /* @flow */
-var baseDirectives$1 = {
+var baseDirectives = {
     on: on,
-    bind: bind$1,
-    cloak: noop,
+    bind: bind,
+    cloak: noop$1,
 };
 
 /* @flow */
-var CodegenState = function CodegenState(options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives$1), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-};
-function generate(ast, options) {
+var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        var isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = function (el) {
+            return !!el.component || !isReservedTag(el.tag);
+        };
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+    return CodegenState;
+}());
+function generate$1(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
     var code = ast
@@ -4356,7 +4372,7 @@ function generate(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -4384,17 +4400,19 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code;
+        var code = void 0;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data;
+            var data = void 0;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData$2(el, state);
+                data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+            ) + (children ? "," + children : '' // children
+            ) + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -4413,9 +4431,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
     state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
 }
 // v-once
 function genOnce(el, state) {
@@ -4425,19 +4443,19 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
+        var parent_1 = el.parent;
+        while (parent_1) {
+            if (parent_1.for) {
+                key = parent_1.key;
                 break;
             }
-            parent = parent.parent;
+            parent_1 = parent_1.parent;
         }
         if (!key) {
             state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
     }
     else {
         return genStatic(el, state);
@@ -4453,10 +4471,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
     }
     else {
-        return ("" + (genTernaryExp(condition.block)));
+        return "" + genTernaryExp(condition.block);
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -4470,23 +4488,23 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
+        ("function(" + alias + iterator1 + iterator2 + "){") +
+        ("return " + (altGen || genElement)(el, state)) +
         '})');
 }
-function genData$2(el, state) {
+function genData(el, state) {
     var data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
@@ -4495,11 +4513,11 @@ function genData$2(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + (el.key) + ",";
+        data += "key:" + el.key + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + (el.ref) + ",";
+        data += "ref:" + el.ref + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -4510,7 +4528,7 @@ function genData$2(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + (el.tag) + "\",";
+        data += "tag:\"" + el.tag + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -4518,31 +4536,31 @@ function genData$2(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + (genProps(el.attrs)) + ",";
+        data += "attrs:" + genProps(el.attrs) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + (genProps(el.props)) + ",";
+        data += "domProps:" + genProps(el.props) + ",";
     }
     // event handlers
     if (el.events) {
-        data += (genHandlers(el.events, false)) + ",";
+        data += genHandlers(el.events, false) + ",";
     }
     if (el.nativeEvents) {
-        data += (genHandlers(el.nativeEvents, true)) + ",";
+        data += genHandlers(el.nativeEvents, true) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + (el.slotTarget) + ",";
+        data += "slot:" + el.slotTarget + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+        data += genScopedSlots(el, el.scopedSlots, state) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -4556,7 +4574,7 @@ function genData$2(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -4586,9 +4604,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -4597,14 +4615,14 @@ function genDirectives(el, state) {
 }
 function genInlineTemplate(el, state) {
     var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
+    if ((el.children.length !== 1 || ast.type !== 1)) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
-        var inlineRenderFns = generate(ast, state.options);
-        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-            .map(function (code) { return ("function(){" + code + "}"); })
-            .join(',')) + "]}");
+        var inlineRenderFns = generate$1(ast, state.options);
+        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+            .map(function (code) { return "function(){" + code + "}"; })
+            .join(',') + "]}";
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -4629,23 +4647,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
+        var parent_2 = el.parent;
+        while (parent_2) {
+            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                parent_2.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent.if) {
+            if (parent_2.if) {
                 needsKey = true;
             }
-            parent = parent.parent;
+            parent_2 = parent_2.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
 }
 function hash(str) {
     var hash = 5381;
@@ -4674,36 +4692,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        "return " + (el.tag === 'template'
+        ("return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}";
+            : genElement(el, state)) + "}");
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el$1 = children[0];
+        var el_1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el$1.for &&
-            el$1.tag !== 'template' &&
-            el$1.tag !== 'slot') {
-            var normalizationType = checkSkip
-                ? state.maybeComponent(el$1)
+            el_1.for &&
+            el_1.tag !== 'template' &&
+            el_1.tag !== 'slot') {
+            var normalizationType_1 = checkSkip
+                ? state.maybeComponent(el_1)
                     ? ",1"
                     : ",0"
                 : "";
-            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
         }
-        var normalizationType$1 = checkSkip
+        var normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen = altGenNode || genNode;
-        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+        var gen_1 = altGenNode || genNode;
+        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
     }
 }
 // determine the normalization needed for the children array.
@@ -4745,17 +4763,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return ("_v(" + (text.type === 2
+    return "_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
 }
 function genComment(comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+    return "_e(" + JSON.stringify(comment.text) + ")";
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var res = "_t(" + slotName + (children ? "," + children : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -4764,22 +4782,22 @@ function genSlot(el, state) {
             dynamic: attr.dynamic,
         }); }))
         : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
+    var bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
         res += ",null";
     }
     if (attrs) {
         res += "," + attrs;
     }
-    if (bind$$1) {
-        res += (attrs ? '' : ',null') + "," + bind$$1;
+    if (bind) {
+        res += (attrs ? '' : ',null') + "," + bind;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
 }
 function genProps(props) {
     var staticProps = "";
@@ -4788,15 +4806,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += (prop.name) + "," + value + ",";
+            dynamicProps += prop.name + "," + value + ",";
         }
         else {
-            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+            staticProps += "\"" + prop.name + "\":" + value + ",";
         }
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    staticProps = "{" + staticProps.slice(0, -1) + "}";
     if (dynamicProps) {
-        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
     }
     else {
         return staticProps;
@@ -4827,19 +4845,15 @@ function applyModelTransform(el, state) {
     }
 }
 function genAttrSegments(attrs) {
-    return attrs.map(function (ref) {
-        var name = ref.name;
-        var value = ref.value;
-
+    return attrs.map(function (_a) {
+        var name = _a.name, value = _a.value;
         return genAttrSegment(name, value);
     });
 }
 function genDOMPropSegments(props, attrs) {
     var segments = [];
-    props.forEach(function (ref) {
-        var name = ref.name;
-        var value = ref.value;
-
+    props.forEach(function (_a) {
+        var name = _a.name, value = _a.value;
         name = propsToAttrMap[name] || name.toLowerCase();
         if (isRenderableAttr(name) &&
             !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -4859,42 +4873,42 @@ function genAttrSegment(name, value) {
         return {
             type: RAW,
             value: isBooleanAttr(name)
-                ? (" " + name + "=\"" + name + "\"")
+                ? " " + name + "=\"" + name + "\""
                 : value === '""'
-                    ? (" " + name)
-                    : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+                    ? " " + name
+                    : " " + name + "=\"" + JSON.parse(value) + "\"",
         };
     }
     else {
         return {
             type: EXPRESSION,
-            value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+            value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
         };
     }
 }
 function genClassSegments(staticClass, classBinding) {
     if (staticClass && !classBinding) {
-        return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
+        return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+                value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
             } ];
     }
 }
 function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
     if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+        return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                    ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-                    : 'null') + ")"),
+                value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                    ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
+                    : 'null') + ")",
             } ];
     }
 }
@@ -4939,8 +4953,8 @@ function walk(node, isRoot) {
             check(child);
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
                 walk(block, isRoot);
                 check(block);
             }
@@ -5022,11 +5036,11 @@ function isSelectWithModel(node) {
 var RAW = 0;
 var INTERPOLATION = 1;
 var EXPRESSION = 2;
-function generate$1(ast, options) {
+function generate(ast, options) {
     var state = new CodegenState(options);
     var code = ast ? genSSRElement(ast, state) : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -5061,11 +5075,11 @@ function genSSRElement(el, state) {
     }
 }
 function genNormalElement(el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData$2(el, state);
+    var data = el.plain ? undefined : genData(el, state);
     var children = stringifyChildren
-        ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+        ? "[" + genChildrenAsStringNode(el, state) + "]"
         : genSSRChildren(el, state, true);
-    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+    return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
 }
 function genSSRChildren(el, state, checkSkip) {
     return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -5075,18 +5089,18 @@ function genSSRNode(el, state) {
 }
 function genChildrenAsStringNode(el, state) {
     return el.children.length
-        ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+        ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
         : '';
 }
 function genStringElement(el, state) {
-    return ("_ssrNode(" + (elementToString(el, state)) + ")");
+    return "_ssrNode(" + elementToString(el, state) + ")";
 }
 function genStringElementWithChildren(el, state) {
     var children = genSSRChildren(el, state, true);
-    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+    return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
 }
 function elementToString(el, state) {
-    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+    return "(" + flattenSegments(elementToSegments(el, state)) + ")";
 }
 function elementToSegments(el, state) {
     // v-for / v-if
@@ -5111,17 +5125,16 @@ function elementToSegments(el, state) {
     }
     var openSegments = elementToOpenTagSegments(el, state);
     var childrenSegments = childrenToSegments(el, state);
-    var ref = state.options;
-    var isUnaryTag = ref.isUnaryTag;
+    var isUnaryTag = state.options.isUnaryTag;
     var close = isUnaryTag && isUnaryTag(el.tag)
         ? []
-        : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+        : [{ type: RAW, value: "</" + el.tag + ">" }];
     return openSegments.concat(childrenSegments, close);
 }
 function elementToOpenTagSegments(el, state) {
     applyModelTransform(el, state);
     var binding;
-    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+    var segments = [{ type: RAW, value: "<" + el.tag }];
     // attrs
     if (el.attrs) {
         segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -5132,11 +5145,11 @@ function elementToOpenTagSegments(el, state) {
     }
     // v-bind="object"
     if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+        segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
     }
     // v-bind.prop="object"
     if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+        segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
     }
     // class
     if (el.staticClass || el.classBinding) {
@@ -5148,7 +5161,7 @@ function elementToOpenTagSegments(el, state) {
     }
     // _scopedId
     if (state.options.scopeId) {
-        segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+        segments.push({ type: RAW, value: " " + state.options.scopeId });
     }
     segments.push({ type: RAW, value: ">" });
     return segments;
@@ -5156,13 +5169,13 @@ function elementToOpenTagSegments(el, state) {
 function childrenToSegments(el, state) {
     var binding;
     if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+        return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
     }
     if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
     }
     if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
     }
     return el.children ? nodesToSegments(el.children, state) : [];
 }
@@ -5202,11 +5215,11 @@ function flattenSegments(segments) {
         }
         else if (s.type === INTERPOLATION) {
             pushBuffer();
-            mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+            mergedSegments.push("_ssrEscape(" + s.value + ")");
         }
         else if (s.type === EXPRESSION) {
             pushBuffer();
-            mergedSegments.push(("(" + (s.value) + ")"));
+            mergedSegments.push("(" + s.value + ")");
         }
     }
     pushBuffer();
@@ -5237,22 +5250,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                var value = node.attrsMap[name];
+        for (var name_1 in node.attrsMap) {
+            if (dirRE.test(name_1)) {
+                var value = node.attrsMap[name_1];
                 if (value) {
-                    var range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    var range = node.rawAttrsMap[name_1];
+                    if (name_1 === 'v-for') {
+                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
                     }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (onRE.test(name_1)) {
+                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                     else {
-                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                 }
             }
@@ -5272,7 +5285,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -5285,16 +5298,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(("var " + ident + "=_"));
+            new Function("var " + ident + "=_");
         }
         catch (e) {
-            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(("return " + exp));
+        new Function("return " + exp);
     }
     catch (e) {
         var keywordMatch = exp
@@ -5302,12 +5315,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
         }
         else {
-            warn("invalid expression: " + (e.message) + " in\n\n" +
-                "    " + exp + "\n\n" +
-                "  Raw expression: " + (text.trim()) + "\n", range);
+            warn("invalid expression: " + e.message + " in\n\n" +
+                ("    " + exp + "\n\n") +
+                ("  Raw expression: " + text.trim() + "\n"), range);
         }
     }
 }
@@ -5316,18 +5329,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-            "    " + exp + "\n\n" +
-            "  Raw expression: " + (text.trim()) + "\n", range);
+        warn("invalid function parameter expression: " + e.message + " in\n\n" +
+            ("    " + exp + "\n\n") +
+            ("  Raw expression: " + text.trim() + "\n"), range);
     }
 }
 
 /* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
+    if (start === void 0) { start = 0; }
+    if (end === void 0) { end = source.length; }
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -5337,18 +5349,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                    var length_1 = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length$1 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat$1("^", length$1));
+                        var length_2 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length_2));
                     }
                     count += lineLength + 1;
                 }
@@ -5358,7 +5370,7 @@ function generateCodeFrame(source, start, end) {
     }
     return res.join('\n');
 }
-function repeat$1(str, n) {
+function repeat(str, n) {
     var result = '';
     if (n > 0) {
         while (true) {
@@ -5381,14 +5393,14 @@ function createFunction(code, errors) {
     }
     catch (err) {
         errors.push({ err: err, code: code });
-        return noop;
+        return noop$1;
     }
 }
 function createCompileToFunctionFn(compile) {
     var cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn$$1 = options.warn || warn;
+        var warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         {
@@ -5398,7 +5410,7 @@ function createCompileToFunctionFn(compile) {
             }
             catch (e) {
                 if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
                         'environment with Content Security Policy that prohibits unsafe-eval. ' +
                         'The template compiler cannot work in this environment. Consider ' +
                         'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -5420,13 +5432,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                    warn("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -5452,14 +5464,12 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn$$1("Failed to generate render function:\n\n" +
+                warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (ref) {
-                            var err = ref.err;
-                            var code = ref.code;
-
-                            return ((err.toString()) + " in\n\n" + code + "\n");
-                })
+                        .map(function (_a) {
+                        var err = _a.err, code = _a.code;
+                        return err.toString() + " in\n\n" + code + "\n";
+                    })
                         .join('\n'), vm);
             }
         }
@@ -5480,15 +5490,15 @@ function createCompilerCreator(baseCompile) {
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
+                                data.start = range.start + leadingSpaceLength_1;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
+                                data.end = range.end + leadingSpaceLength_1;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -5529,7 +5539,7 @@ function createCompilerCreator(baseCompile) {
 var createCompiler = createCompilerCreator(function baseCompile(template, options) {
     var ast = parse(template.trim(), options);
     optimize(ast, options);
-    var code = generate$1(ast, options);
+    var code = generate(ast, options);
     return {
         ast: ast,
         render: code.render,
@@ -5538,9 +5548,7 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
 });
 
 /* @flow */
-var ref = createCompiler(baseOptions);
-var compile = ref.compile;
-var compileToFunctions = ref.compileToFunctions;
+var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
 /* @flow */
 // The template compiler attempts to minimize the need for normalization by
@@ -5588,7 +5596,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -5632,11 +5640,11 @@ function normalizeArrayChildren(children, nestedIndex) {
 /* @flow */
 var ssrHelpers = {
     _ssrEscape: escape,
-    _ssrNode: renderStringNode,
+    _ssrNode: renderStringNode$1,
     _ssrList: renderStringList,
     _ssrAttr: renderAttr,
-    _ssrAttrs: renderAttrs$1,
-    _ssrDOMProps: renderDOMProps$1,
+    _ssrAttrs: renderAttrs,
+    _ssrDOMProps: renderDOMProps,
     _ssrClass: renderSSRClass,
     _ssrStyle: renderSSRStyle,
 };
@@ -5657,23 +5665,26 @@ function installSSRHelpers(vm) {
         extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
     }
 }
-var StringNode = function StringNode(open, close, children, normalizationType) {
-    this.isString = true;
-    this.open = open;
-    this.close = close;
-    if (children) {
-        this.children =
-            normalizationType === 1
-                ? simpleNormalizeChildren(children)
-                : normalizationType === 2
-                    ? normalizeChildren(children)
-                    : children;
-    }
-    else {
-        this.children = void 0;
+var StringNode = /** @class */ (function () {
+    function StringNode(open, close, children, normalizationType) {
+        this.isString = true;
+        this.open = open;
+        this.close = close;
+        if (children) {
+            this.children =
+                normalizationType === 1
+                    ? simpleNormalizeChildren(children)
+                    : normalizationType === 2
+                        ? normalizeChildren(children)
+                        : children;
+        }
+        else {
+            this.children = void 0;
+        }
     }
-};
-function renderStringNode(open, close, children, normalizationType) {
+    return StringNode;
+}());
+function renderStringNode$1(open, close, children, normalizationType) {
     return new StringNode(open, close, children, normalizationType);
 }
 function renderStringList(val, render) {
@@ -5698,7 +5709,7 @@ function renderStringList(val, render) {
     }
     return ret;
 }
-function renderAttrs$1(obj) {
+function renderAttrs(obj) {
     var res = '';
     for (var key in obj) {
         if (isSSRUnsafeAttr(key)) {
@@ -5708,7 +5719,7 @@ function renderAttrs$1(obj) {
     }
     return res;
 }
-function renderDOMProps$1(obj) {
+function renderDOMProps(obj) {
     var res = '';
     for (var key in obj) {
         var attr = propsToAttrMap[key] || key.toLowerCase();
@@ -5719,8 +5730,8 @@ function renderDOMProps$1(obj) {
     return res;
 }
 function renderSSRClass(staticClass, dynamic) {
-    var res = renderClass(staticClass, dynamic);
-    return res === '' ? res : (" class=\"" + (escape(res)) + "\"");
+    var res = renderClass$1(staticClass, dynamic);
+    return res === '' ? res : " class=\"" + escape(res) + "\"";
 }
 function renderSSRStyle(staticStyle, dynamic, extra) {
     var style = {};
@@ -5731,23 +5742,23 @@ function renderSSRStyle(staticStyle, dynamic, extra) {
     if (extra)
         { extend(style, extra); }
     var res = genStyle(style);
-    return res === '' ? res : (" style=" + (JSON.stringify(escape(res))));
+    return res === '' ? res : " style=" + JSON.stringify(escape(res));
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
 {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
                     return false;
                 }
                 else {
@@ -5799,25 +5810,25 @@ function _traverse(val, seen) {
 }
 
 {
-    var perf = inBrowser && window.performance;
+    var perf_1 = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) ;
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) ;
 }
 
 var normalizeEvent = cached(function (name) {
     var passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
     var capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
         name: name,
-        once: once$$1,
+        once: once,
         capture: capture,
         passive: passive,
     };
@@ -5841,14 +5852,14 @@ function createFnInvoker(fns, vm) {
     invoker.fns = fns;
     return invoker;
 }
-function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
-    var name, def$$1, cur, old, event;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, cur, old, event;
     for (name in on) {
-        def$$1 = cur = on[name];
+        cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+            warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -5867,13 +5878,11 @@ function updateListeners(on, oldOn, add, remove$$1, createOnceHandler, vm) {
     for (name in oldOn) {
         if (isUndef(on[name])) {
             event = normalizeEvent(name);
-            remove$$1(event.name, oldOn[name], event.capture);
+            remove(event.name, oldOn[name], event.capture);
         }
     }
 }
 
-/* @flow */
-
 /* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
@@ -5884,8 +5893,7 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    var attrs = data.attrs, props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -5895,11 +5903,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -5946,7 +5954,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -5963,7 +5971,7 @@ function _createElement(context, tag, data, children, normalizationType) {
         !isPrimitive(data.key)) {
         // @ts-expect-error
         {
-            warn('Avoid using non-primitive value as key, ' +
+            warn$2('Avoid using non-primitive value as key, ' +
                 'use string/number value instead.', context);
         }
     }
@@ -5981,7 +5989,7 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        var Ctor = void 0;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if ((!data || !data.pre) &&
             isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
@@ -6096,7 +6104,7 @@ function renderSlot(name, fallback, props, bindObject) {
         props = props || {};
         if (bindObject) {
             if (!isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
+                warn$2('slot v-bind without argument expects an Object', this);
             }
             props = extend(extend({}, bindObject), props);
         }
@@ -6155,14 +6163,14 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
 function bindObjectProps(data, tag, value, asProp, isSync) {
     if (value) {
         if (!isObject(value)) {
-            warn('v-bind without argument expects an Object or Array value', this);
+            warn$2('v-bind without argument expects an Object or Array value', this);
         }
         else {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            var hash = void 0;
+            var _loop_1 = function (key) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -6179,14 +6187,15 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        on["update:" + key] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-
-            for (var key in value) loop( key );
+            for (var key in value) {
+                _loop_1(key);
+            }
         }
     }
     return data;
@@ -6206,7 +6215,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic(tree, "__static__" + index, false);
     return tree;
 }
 /**
@@ -6214,14 +6223,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], key + "_" + i, isOnce);
             }
         }
     }
@@ -6239,7 +6248,7 @@ function markStaticNode(node, key, isOnce) {
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
-            warn('v-on without argument expects an Object value', this);
+            warn$2('v-on without argument expects an Object value', this);
         }
         else {
             var on = (data.on = data.on ? extend({}, data.on) : {});
@@ -6288,7 +6297,7 @@ function bindDynamicKeys(baseObj, values) {
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
         }
     }
     return baseObj;
@@ -6342,8 +6351,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -6356,9 +6365,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
         }
     }
     return slots;
@@ -6392,16 +6401,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -6442,15 +6451,6 @@ function proxyNormalSlot(slots, key) {
 }
 
 /* @flow */
-var currentRenderingInstance = null;
-
-/* @flow */
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
 function createAsyncPlaceholder(factory, data, context, children, tag) {
     var node = createEmptyVNode();
     node.asyncFactory = factory;
@@ -6464,114 +6464,17 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    var owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
     if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
         return factory.loadingComp;
     }
-    if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        var resolve = once(function (res) {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        var reject = once(function (reason) {
-            warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        var res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject("timeout (" + (res.timeout) + "ms)");
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
 }
 
-/* @flow */
-
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 var target;
 function add(event, fn) {
     target.$on(event, fn);
 }
-function remove$1(event, fn) {
+function remove(event, fn) {
     target.$off(event, fn);
 }
 function createOnceHandler(event, fn) {
@@ -6585,7 +6488,7 @@ function createOnceHandler(event, fn) {
 }
 function updateComponentListeners(vm, listeners, oldListeners) {
     target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
+    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
     target = undefined;
 }
 
@@ -6715,15 +6618,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = function () { return performance_1.now(); };
     }
 }
 /**
@@ -6736,10 +6639,6 @@ function queueActivatedComponent(vm) {
     vm._inactive = false;
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 function resolveInject(inject, vm) {
     if (inject) {
@@ -6771,7 +6670,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn$2("Injection \"" + key + "\" not found", vm);
                 }
             }
         }
@@ -6819,8 +6718,7 @@ function resolveModifiedOptions(Ctor) {
 
 /* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
+    var _this = this;
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -6847,14 +6745,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return _this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get: function () {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -6877,7 +6775,9 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
+        this._c = function (a, b, c, d) {
+            return createElement(contextVm, a, b, c, d, needNormalization);
+        };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -6931,14 +6831,10 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
-
-/* @flow */
-
 /* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+    init: function (vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -6951,7 +6847,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
+    prepatch: function (oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -6960,9 +6856,8 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook(componentInstance, 'mounted');
@@ -6981,7 +6876,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
+    destroy: function (vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -7007,7 +6902,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn$2("Invalid Component definition: " + String(Ctor), context);
         }
         return;
     }
@@ -7016,7 +6911,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        Ctor = resolveAsyncComponent(asyncFactory);
         if (Ctor === undefined) {
             // return a placeholder node for async component, which is rendered
             // as a comment node but preserves all the raw information for the node.
@@ -7065,7 +6960,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -7096,11 +6991,11 @@ function installComponentHooks(data) {
         var toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
     }
 }
-function mergeHook$1(f1, f2) {
+function mergeHook(f1, f2) {
     var merged = function (a, b) {
         // flow complains about extra args which is why we use any
         f1(a, b);
@@ -7136,18 +7031,15 @@ var warnOnce = function (msg) {
     if (!warned[msg]) {
         warned[msg] = true;
         // eslint-disable-next-line no-console
-        console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
+        console.warn("\n\u001B[31m" + msg + "\u001B[39m\n");
     }
 };
 var onCompilationError = function (err, vm) {
     var trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"));
+    throw new Error("\n\u001B[31m" + err + trace + "\u001B[39m\n");
 };
 var normalizeRender = function (vm) {
-    var ref = vm.$options;
-    var render = ref.render;
-    var template = ref.template;
-    var _scopeId = ref._scopeId;
+    var _a = vm.$options, render = _a.render, template = _a.template, _scopeId = _a._scopeId;
     if (isUndef(render)) {
         if (template) {
             var compiled = compileToFunctions(template, {
@@ -7158,7 +7050,7 @@ var normalizeRender = function (vm) {
             vm.$options.staticRenderFns = compiled.staticRenderFns;
         }
         else {
-            throw new Error(("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous')));
+            throw new Error("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'));
         }
     }
 };
@@ -7186,7 +7078,7 @@ function waitForServerPrefetch(vm, resolve, reject) {
 }
 function renderNode(node, isRoot, context) {
     if (node.isString) {
-        renderStringNode$1(node, context);
+        renderStringNode(node, context);
     }
     else if (isDef(node.componentOptions)) {
         renderComponent(node, isRoot, context);
@@ -7200,7 +7092,7 @@ function renderNode(node, isRoot, context) {
             renderAsyncComponent(node, isRoot, context);
         }
         else {
-            context.write(("<!--" + (node.text) + "-->"), context.next);
+            context.write("<!--" + node.text + "-->", context.next);
         }
     }
     else {
@@ -7217,9 +7109,7 @@ function registerComponentForCache(options, write) {
     return register;
 }
 function renderComponent(node, isRoot, context) {
-    var write = context.write;
-    var next = context.next;
-    var userContext = context.userContext;
+    var write = context.write, next = context.next, userContext = context.userContext;
     // check cache hit
     var Ctor = node.componentOptions.Ctor;
     var getKey = Ctor.options.serverCacheKey;
@@ -7232,13 +7122,12 @@ function renderComponent(node, isRoot, context) {
             renderComponentInner(node, isRoot, context);
             return;
         }
-        var key = name + '::' + rawKey;
-        var has = context.has;
-        var get = context.get;
+        var key_1 = name + '::' + rawKey;
+        var has = context.has, get_1 = context.get;
         if (isDef(has)) {
-            has(key, function (hit) {
-                if (hit === true && isDef(get)) {
-                    get(key, function (res) {
+            has(key_1, function (hit) {
+                if (hit === true && isDef(get_1)) {
+                    get_1(key_1, function (res) {
                         if (isDef(registerComponent)) {
                             registerComponent(userContext);
                         }
@@ -7247,12 +7136,12 @@ function renderComponent(node, isRoot, context) {
                     });
                 }
                 else {
-                    renderComponentWithCache(node, isRoot, key, context);
+                    renderComponentWithCache(node, isRoot, key_1, context);
                 }
             });
         }
-        else if (isDef(get)) {
-            get(key, function (res) {
+        else if (isDef(get_1)) {
+            get_1(key_1, function (res) {
                 if (isDef(res)) {
                     if (isDef(registerComponent)) {
                         registerComponent(userContext);
@@ -7261,7 +7150,7 @@ function renderComponent(node, isRoot, context) {
                     write(res.html, next);
                 }
                 else {
-                    renderComponentWithCache(node, isRoot, key, context);
+                    renderComponentWithCache(node, isRoot, key_1, context);
                 }
             });
         }
@@ -7318,10 +7207,7 @@ function renderAsyncComponent(node, isRoot, context) {
         if (comp.__esModule && comp.default) {
             comp = comp.default;
         }
-        var ref = node.asyncMeta;
-        var data = ref.data;
-        var children = ref.children;
-        var tag = ref.tag;
+        var _a = node.asyncMeta, data = _a.data, children = _a.children, tag = _a.tag;
         var nodeContext = node.asyncMeta.context;
         var resolvedNode = createComponent(comp, data, nodeContext, children, tag);
         if (resolvedNode) {
@@ -7375,9 +7261,8 @@ function renderAsyncComponent(node, isRoot, context) {
         }
     }
 }
-function renderStringNode$1(el, context) {
-    var write = context.write;
-    var next = context.next;
+function renderStringNode(el, context) {
+    var write = context.write, next = context.next;
     if (isUndef(el.children) || el.children.length === 0) {
         write(el.open + (el.close || ''), next);
     }
@@ -7394,8 +7279,7 @@ function renderStringNode$1(el, context) {
     }
 }
 function renderElement(el, isRoot, context) {
-    var write = context.write;
-    var next = context.next;
+    var write = context.write, next = context.next;
     if (isTrue(isRoot)) {
         if (!el.data)
             { el.data = {}; }
@@ -7407,7 +7291,7 @@ function renderElement(el, isRoot, context) {
         registerComponentForCache(el.fnOptions, write);
     }
     var startTag = renderStartingTag(el, context);
-    var endTag = "</" + (el.tag) + ">";
+    var endTag = "</" + el.tag + ">";
     if (context.isUnaryTag(el.tag)) {
         write(startTag, next);
     }
@@ -7446,9 +7330,8 @@ function getVShowDirectiveInfo(node) {
     return dir;
 }
 function renderStartingTag(node, context) {
-    var markup = "<" + (node.tag);
-    var directives = context.directives;
-    var modules = context.modules;
+    var markup = "<" + node.tag;
+    var directives = context.directives, modules = context.modules;
     // construct synthetic data for module processing
     // because modules like style also produce code by parent VNode data
     if (isUndef(node.data) && hasAncestorData(node)) {
@@ -7459,9 +7342,9 @@ function renderStartingTag(node, context) {
         var dirs = node.data.directives;
         if (dirs) {
             for (var i = 0; i < dirs.length; i++) {
-                var name = dirs[i].name;
-                if (name !== 'show') {
-                    var dirRenderer = resolveAsset(context, 'directives', name);
+                var name_1 = dirs[i].name;
+                if (name_1 !== 'show') {
+                    var dirRenderer = resolveAsset(context, 'directives', name_1);
                     if (dirRenderer) {
                         // directives mutate the node's data
                         // which then gets rendered by modules
@@ -7476,8 +7359,8 @@ function renderStartingTag(node, context) {
             directives.show(node, vshowDirectiveInfo);
         }
         // apply other modules
-        for (var i$1 = 0; i$1 < modules.length; i$1++) {
-            var res = modules[i$1](node);
+        for (var i = 0; i < modules.length; i++) {
+            var res = modules[i](node);
             if (res) {
                 markup += res;
             }
@@ -7492,7 +7375,7 @@ function renderStartingTag(node, context) {
         markup += " " + scopeId;
     }
     if (isDef(node.fnScopeId)) {
-        markup += " " + (node.fnScopeId);
+        markup += " " + node.fnScopeId;
     }
     else {
         while (isDef(node)) {
@@ -7546,20 +7429,18 @@ function createPromiseCallback() {
 }
 
 /* @flow */
-var TemplateStream = /*@__PURE__*/(function (Transform) {
+var TemplateStream = /** @class */ (function (_super) {
+    __extends(TemplateStream, _super);
     function TemplateStream(renderer, template, context) {
-        Transform.call(this);
-        this.started = false;
-        this.renderer = renderer;
-        this.template = template;
-        this.context = context || {};
-        this.inject = renderer.inject;
-    }
-
-    if ( Transform ) TemplateStream.__proto__ = Transform;
-    TemplateStream.prototype = Object.create( Transform && Transform.prototype );
-    TemplateStream.prototype.constructor = TemplateStream;
-    TemplateStream.prototype._transform = function _transform (data, encoding, done) {
+        var _this = _super.call(this) || this;
+        _this.started = false;
+        _this.renderer = renderer;
+        _this.template = template;
+        _this.context = context || {};
+        _this.inject = renderer.inject;
+        return _this;
+    }
+    TemplateStream.prototype._transform = function (data, encoding, done) {
         if (!this.started) {
             this.emit('beforeStart');
             this.start();
@@ -7567,7 +7448,7 @@ var TemplateStream = /*@__PURE__*/(function (Transform) {
         this.push(data);
         done();
     };
-    TemplateStream.prototype.start = function start () {
+    TemplateStream.prototype.start = function () {
         this.started = true;
         this.push(this.template.head(this.context));
         if (this.inject) {
@@ -7588,7 +7469,7 @@ var TemplateStream = /*@__PURE__*/(function (Transform) {
         }
         this.push(this.template.neck(this.context));
     };
-    TemplateStream.prototype._flush = function _flush (done) {
+    TemplateStream.prototype._flush = function (done) {
         this.emit('beforeEnd');
         if (this.inject) {
             // inline initial store state
@@ -7605,19 +7486,17 @@ var TemplateStream = /*@__PURE__*/(function (Transform) {
         this.push(this.template.tail(this.context));
         done();
     };
-
     return TemplateStream;
 }(stream.Transform));
 
 /* @flow */
-var compile$1 = require('lodash.template');
+var compile = require('lodash.template');
 var compileOptions = {
     escape: /{{([^{][\s\S]+?[^}])}}/g,
     interpolate: /{{{([\s\S]+?)}}}/g,
 };
 function parseTemplate(template, contentPlaceholder) {
-    if ( contentPlaceholder === void 0 ) contentPlaceholder = '<!--vue-ssr-outlet-->';
-
+    if (contentPlaceholder === void 0) { contentPlaceholder = '<!--vue-ssr-outlet-->'; }
     if (typeof template === 'object') {
         return template;
     }
@@ -7633,9 +7512,9 @@ function parseTemplate(template, contentPlaceholder) {
         }
     }
     return {
-        head: compile$1(template.slice(0, i), compileOptions),
-        neck: compile$1(template.slice(i, j), compileOptions),
-        tail: compile$1(template.slice(j + contentPlaceholder.length), compileOptions),
+        head: compile(template.slice(0, i), compileOptions),
+        neck: compile(template.slice(i, j), compileOptions),
+        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
     };
 }
 
@@ -7681,233 +7560,218 @@ function mapIdToFile(id, clientManifest) {
 }
 
 /* @flow */
-var path = require('path');
+var path$2 = require('path');
 var serialize = require('serialize-javascript');
-var TemplateRenderer = function TemplateRenderer(options) {
-    this.options = options;
-    this.inject = options.inject !== false;
-    // if no template option is provided, the renderer is created
-    // as a utility object for rendering assets like preload links and scripts.
-    var template = options.template;
-    this.parsedTemplate = template
-        ? typeof template === 'string'
-            ? parseTemplate(template)
-            : template
-        : null;
-    // function used to serialize initial state JSON
-    this.serialize =
-        options.serializer ||
-            (function (state) {
-                return serialize(state, { isJSON: true });
-            });
-    // extra functionality with client manifest
-    if (options.clientManifest) {
-        var clientManifest = (this.clientManifest = options.clientManifest);
-        // ensure publicPath ends with /
-        this.publicPath =
-            clientManifest.publicPath === ''
-                ? ''
-                : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-        // preload/prefetch directives
-        this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-        this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-        // initial async chunk mapping
-        this.mapFiles = createMapper(clientManifest);
-    }
-};
-TemplateRenderer.prototype.bindRenderFns = function bindRenderFns (context) {
-    var renderer = this;
-    ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
-        context[("render" + type)] = renderer[("render" + type)].bind(renderer, context);
-    });
-    // also expose getPreloadFiles, useful for HTTP/2 push
-    context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
-};
-// render synchronously given rendered app content and render context
-TemplateRenderer.prototype.render = function render (content, context) {
-    var template = this.parsedTemplate;
-    if (!template) {
-        throw new Error('render cannot be called without a template.');
-    }
-    context = context || {};
-    if (typeof template === 'function') {
-        return template(content, context);
-    }
-    if (this.inject) {
-        return (template.head(context) +
-            (context.head || '') +
-            this.renderResourceHints(context) +
-            this.renderStyles(context) +
-            template.neck(context) +
-            content +
-            this.renderState(context) +
-            this.renderScripts(context) +
-            template.tail(context));
-    }
-    else {
-        return (template.head(context) +
-            template.neck(context) +
-            content +
-            template.tail(context));
-    }
-};
-TemplateRenderer.prototype.renderStyles = function renderStyles (context) {
-        var this$1 = this;
-
-    var initial = this.preloadFiles || [];
-    var async = this.getUsedAsyncFiles(context) || [];
-    var cssFiles = initial.concat(async).filter(function (ref) {
-            var file = ref.file;
-
+var TemplateRenderer = /** @class */ (function () {
+    function TemplateRenderer(options) {
+        this.options = options;
+        this.inject = options.inject !== false;
+        // if no template option is provided, the renderer is created
+        // as a utility object for rendering assets like preload links and scripts.
+        var template = options.template;
+        this.parsedTemplate = template
+            ? typeof template === 'string'
+                ? parseTemplate(template)
+                : template
+            : null;
+        // function used to serialize initial state JSON
+        this.serialize =
+            options.serializer ||
+                (function (state) {
+                    return serialize(state, { isJSON: true });
+                });
+        // extra functionality with client manifest
+        if (options.clientManifest) {
+            var clientManifest = (this.clientManifest = options.clientManifest);
+            // ensure publicPath ends with /
+            this.publicPath =
+                clientManifest.publicPath === ''
+                    ? ''
+                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
+            // preload/prefetch directives
+            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
+            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
+            // initial async chunk mapping
+            this.mapFiles = createMapper(clientManifest);
+        }
+    }
+    TemplateRenderer.prototype.bindRenderFns = function (context) {
+        var renderer = this;
+        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
+            context["render" + type] = renderer["render" + type].bind(renderer, context);
+        });
+        // also expose getPreloadFiles, useful for HTTP/2 push
+        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
+    };
+    // render synchronously given rendered app content and render context
+    TemplateRenderer.prototype.render = function (content, context) {
+        var template = this.parsedTemplate;
+        if (!template) {
+            throw new Error('render cannot be called without a template.');
+        }
+        context = context || {};
+        if (typeof template === 'function') {
+            return template(content, context);
+        }
+        if (this.inject) {
+            return (template.head(context) +
+                (context.head || '') +
+                this.renderResourceHints(context) +
+                this.renderStyles(context) +
+                template.neck(context) +
+                content +
+                this.renderState(context) +
+                this.renderScripts(context) +
+                template.tail(context));
+        }
+        else {
+            return (template.head(context) +
+                template.neck(context) +
+                content +
+                template.tail(context));
+        }
+    };
+    TemplateRenderer.prototype.renderStyles = function (context) {
+        var _this = this;
+        var initial = this.preloadFiles || [];
+        var async = this.getUsedAsyncFiles(context) || [];
+        var cssFiles = initial.concat(async).filter(function (_a) {
+            var file = _a.file;
             return isCSS(file);
         });
-    return (
-    // render links for css files
-    (cssFiles.length
-        ? cssFiles
-            .map(function (ref) {
-                    var file = ref.file;
-
-                    return ("<link rel=\"stylesheet\" href=\"" + (this$1.publicPath) + file + "\">");
-        })
-            .join('')
-        : '') +
-        // context.styles is a getter exposed by vue-style-loader which contains
-        // the inline component styles collected during SSR
-        (context.styles || ''));
-};
-TemplateRenderer.prototype.renderResourceHints = function renderResourceHints (context) {
-    return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
-};
-TemplateRenderer.prototype.getPreloadFiles = function getPreloadFiles (context) {
-    var usedAsyncFiles = this.getUsedAsyncFiles(context);
-    if (this.preloadFiles || usedAsyncFiles) {
-        return (this.preloadFiles || []).concat(usedAsyncFiles || []);
-    }
-    else {
-        return [];
-    }
-};
-TemplateRenderer.prototype.renderPreloadLinks = function renderPreloadLinks (context) {
-        var this$1 = this;
-
-    var files = this.getPreloadFiles(context);
-    var shouldPreload = this.options.shouldPreload;
-    if (files.length) {
-        return files
-            .map(function (ref) {
-                var file = ref.file;
-                var extension = ref.extension;
-                var fileWithoutQuery = ref.fileWithoutQuery;
-                var asType = ref.asType;
-
-            var extra = '';
-            // by default, we only preload scripts or css
-            if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-                return '';
-            }
-            // user wants to explicitly control what to preload
-            if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-                return '';
-            }
-            if (asType === 'font') {
-                extra = " type=\"font/" + extension + "\" crossorigin";
-            }
-            return ("<link rel=\"preload\" href=\"" + (this$1.publicPath) + file + "\"" + (asType !== '' ? (" as=\"" + asType + "\"") : '') + extra + ">");
-        })
-            .join('');
-    }
-    else {
-        return '';
-    }
-};
-TemplateRenderer.prototype.renderPrefetchLinks = function renderPrefetchLinks (context) {
-        var this$1 = this;
-
-    var shouldPrefetch = this.options.shouldPrefetch;
-    if (this.prefetchFiles) {
+        return (
+        // render links for css files
+        (cssFiles.length
+            ? cssFiles
+                .map(function (_a) {
+                var file = _a.file;
+                return "<link rel=\"stylesheet\" href=\"" + _this.publicPath + file + "\">";
+            })
+                .join('')
+            : '') +
+            // context.styles is a getter exposed by vue-style-loader which contains
+            // the inline component styles collected during SSR
+            (context.styles || ''));
+    };
+    TemplateRenderer.prototype.renderResourceHints = function (context) {
+        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
+    };
+    TemplateRenderer.prototype.getPreloadFiles = function (context) {
         var usedAsyncFiles = this.getUsedAsyncFiles(context);
-        var alreadyRendered = function (file) {
-            return usedAsyncFiles && usedAsyncFiles.some(function (f) { return f.file === file; });
-        };
-        return this.prefetchFiles
-            .map(function (ref) {
-                var file = ref.file;
-                var fileWithoutQuery = ref.fileWithoutQuery;
-                var asType = ref.asType;
-
-            if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-                return '';
-            }
-            if (alreadyRendered(file)) {
-                return '';
-            }
-            return ("<link rel=\"prefetch\" href=\"" + (this$1.publicPath) + file + "\">");
-        })
-            .join('');
-    }
-    else {
-        return '';
-    }
-};
-TemplateRenderer.prototype.renderState = function renderState (context, options) {
-    var ref = options || {};
-        var contextKey = ref.contextKey; if ( contextKey === void 0 ) contextKey = 'state';
-        var windowKey = ref.windowKey; if ( windowKey === void 0 ) windowKey = '__INITIAL_STATE__';
-    var state = this.serialize(context[contextKey]);
-    var autoRemove = '';
-    var nonceAttr = context.nonce ? (" nonce=\"" + (context.nonce) + "\"") : '';
-    return context[contextKey]
-        ? ("<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>")
-        : '';
-};
-TemplateRenderer.prototype.renderScripts = function renderScripts (context) {
-        var this$1 = this;
-
-    if (this.clientManifest) {
-        var initial = this.preloadFiles.filter(function (ref) {
-                var file = ref.file;
-
+        if (this.preloadFiles || usedAsyncFiles) {
+            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
+        }
+        else {
+            return [];
+        }
+    };
+    TemplateRenderer.prototype.renderPreloadLinks = function (context) {
+        var _this = this;
+        var files = this.getPreloadFiles(context);
+        var shouldPreload = this.options.shouldPreload;
+        if (files.length) {
+            return files
+                .map(function (_a) {
+                var file = _a.file, extension = _a.extension, fileWithoutQuery = _a.fileWithoutQuery, asType = _a.asType;
+                var extra = '';
+                // by default, we only preload scripts or css
+                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+                    return '';
+                }
+                // user wants to explicitly control what to preload
+                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (asType === 'font') {
+                    extra = " type=\"font/" + extension + "\" crossorigin";
+                }
+                return "<link rel=\"preload\" href=\"" + _this.publicPath + file + "\"" + (asType !== '' ? " as=\"" + asType + "\"" : '') + extra + ">";
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    };
+    TemplateRenderer.prototype.renderPrefetchLinks = function (context) {
+        var _this = this;
+        var shouldPrefetch = this.options.shouldPrefetch;
+        if (this.prefetchFiles) {
+            var usedAsyncFiles_1 = this.getUsedAsyncFiles(context);
+            var alreadyRendered_1 = function (file) {
+                return usedAsyncFiles_1 && usedAsyncFiles_1.some(function (f) { return f.file === file; });
+            };
+            return this.prefetchFiles
+                .map(function (_a) {
+                var file = _a.file, fileWithoutQuery = _a.fileWithoutQuery, asType = _a.asType;
+                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (alreadyRendered_1(file)) {
+                    return '';
+                }
+                return "<link rel=\"prefetch\" href=\"" + _this.publicPath + file + "\">";
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    };
+    TemplateRenderer.prototype.renderState = function (context, options) {
+        var _a = options || {}, _b = _a.contextKey, contextKey = _b === void 0 ? 'state' : _b, _c = _a.windowKey, windowKey = _c === void 0 ? '__INITIAL_STATE__' : _c;
+        var state = this.serialize(context[contextKey]);
+        var autoRemove = '';
+        var nonceAttr = context.nonce ? " nonce=\"" + context.nonce + "\"" : '';
+        return context[contextKey]
+            ? "<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>"
+            : '';
+    };
+    TemplateRenderer.prototype.renderScripts = function (context) {
+        var _this = this;
+        if (this.clientManifest) {
+            var initial = this.preloadFiles.filter(function (_a) {
+                var file = _a.file;
                 return isJS(file);
             });
-        var async = (this.getUsedAsyncFiles(context) || []).filter(function (ref) {
-                var file = ref.file;
-
+            var async = (this.getUsedAsyncFiles(context) || []).filter(function (_a) {
+                var file = _a.file;
                 return isJS(file);
             });
-        var needed = [initial[0]].concat(async, initial.slice(1));
-        return needed
-            .map(function (ref) {
-                var file = ref.file;
-
-            return ("<script src=\"" + (this$1.publicPath) + file + "\" defer></script>");
-        })
-            .join('');
-    }
-    else {
-        return '';
-    }
-};
-TemplateRenderer.prototype.getUsedAsyncFiles = function getUsedAsyncFiles (context) {
-    if (!context._mappedFiles &&
-        context._registeredComponents &&
-        this.mapFiles) {
-        var registered = Array.from(context._registeredComponents);
-        context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-    }
-    return context._mappedFiles;
-};
-// create a transform stream
-TemplateRenderer.prototype.createStream = function createStream (context) {
-    if (!this.parsedTemplate) {
-        throw new Error('createStream cannot be called without a template.');
-    }
-    //@ts-expect-error
-    return new TemplateStream(this, this.parsedTemplate, context || {});
-};
+            var needed = [initial[0]].concat(async, initial.slice(1));
+            return needed
+                .map(function (_a) {
+                var file = _a.file;
+                return "<script src=\"" + _this.publicPath + file + "\" defer></script>";
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    };
+    TemplateRenderer.prototype.getUsedAsyncFiles = function (context) {
+        if (!context._mappedFiles &&
+            context._registeredComponents &&
+            this.mapFiles) {
+            var registered = Array.from(context._registeredComponents);
+            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
+        }
+        return context._mappedFiles;
+    };
+    // create a transform stream
+    TemplateRenderer.prototype.createStream = function (context) {
+        if (!this.parsedTemplate) {
+            throw new Error('createStream cannot be called without a template.');
+        }
+        //@ts-expect-error
+        return new TemplateStream(this, this.parsedTemplate, context || {});
+    };
+    return TemplateRenderer;
+}());
 function normalizeFile(file) {
     var withoutQuery = file.replace(/\?.*/, '');
-    var extension = path.extname(withoutQuery).slice(1);
+    var extension = path$2.extname(withoutQuery).slice(1);
     return {
         file: file,
         extension: extension,
@@ -7935,19 +7799,8 @@ function getPreloadType(ext) {
 }
 
 /* @flow */
-function createRenderer(ref) {
-    if ( ref === void 0 ) ref = {};
-    var modules = ref.modules; if ( modules === void 0 ) modules = [];
-    var directives = ref.directives; if ( directives === void 0 ) directives = {};
-    var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = function () { return false; };
-    var template = ref.template;
-    var inject = ref.inject;
-    var cache = ref.cache;
-    var shouldPreload = ref.shouldPreload;
-    var shouldPrefetch = ref.shouldPrefetch;
-    var clientManifest = ref.clientManifest;
-    var serializer = ref.serializer;
-
+function createRenderer$1(_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.modules, modules = _c === void 0 ? [] : _c, _d = _b.directives, directives = _d === void 0 ? {} : _d, _e = _b.isUnaryTag, isUnaryTag = _e === void 0 ? function () { return false; } : _e, template = _b.template, inject = _b.inject, cache = _b.cache, shouldPreload = _b.shouldPreload, shouldPrefetch = _b.shouldPrefetch, clientManifest = _b.clientManifest, serializer = _b.serializer;
     var render = createRenderFunction(modules, directives, isUnaryTag, cache);
     var templateRenderer = new TemplateRenderer({
         template: template,
@@ -7960,9 +7813,8 @@ function createRenderer(ref) {
         serializer: serializer,
     });
     return {
-        renderToString: function renderToString(component, context, cb) {
-            var assign;
-
+        renderToString: function (component, context, cb) {
+            var _a;
             if (typeof context === 'function') {
                 cb = context;
                 context = {};
@@ -7973,7 +7825,7 @@ function createRenderer(ref) {
             // no callback, return Promise
             var promise;
             if (!cb) {
-                ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
+                (_a = createPromiseCallback(), promise = _a.promise, cb = _a.cb);
             }
             var result = '';
             var write = createWriteFunction(function (text) {
@@ -8014,7 +7866,7 @@ function createRenderer(ref) {
             }
             return promise;
         },
-        renderToStream: function renderToStream(component, context) {
+        renderToStream: function (component, context) {
             if (context) {
                 templateRenderer.bindRenderFns(context);
             }
@@ -8026,9 +7878,9 @@ function createRenderer(ref) {
                 // @ts-expect-error
                 if (context && context.rendered) {
                     // @ts-expect-error
-                    var rendered = context.rendered;
+                    var rendered_1 = context.rendered;
                     renderStream.once('beforeEnd', function () {
-                        rendered(context);
+                        rendered_1(context);
                     });
                 }
                 return renderStream;
@@ -8037,20 +7889,20 @@ function createRenderer(ref) {
                 throw new Error("function template is only supported in renderToString.");
             }
             else {
-                var templateStream = templateRenderer.createStream(context);
+                var templateStream_1 = templateRenderer.createStream(context);
                 renderStream.on('error', function (err) {
-                    templateStream.emit('error', err);
+                    templateStream_1.emit('error', err);
                 });
-                renderStream.pipe(templateStream);
+                renderStream.pipe(templateStream_1);
                 //@ts-expect-error
                 if (context && context.rendered) {
                     //@ts-expect-error
-                    var rendered$1 = context.rendered;
+                    var rendered_2 = context.rendered;
                     renderStream.once('beforeEnd', function () {
-                        rendered$1(context);
+                        rendered_2(context);
                     });
                 }
-                return templateStream;
+                return templateStream_1;
             }
         },
     };
@@ -8094,8 +7946,7 @@ function compileModule(files, basedir, runInNewContext) {
         return script;
     }
     function evaluateModule(filename, sandbox, evaluatedFiles) {
-        if ( evaluatedFiles === void 0 ) evaluatedFiles = {};
-
+        if (evaluatedFiles === void 0) { evaluatedFiles = {}; }
         if (evaluatedFiles[filename]) {
             return evaluatedFiles[filename];
         }
@@ -8149,14 +8000,13 @@ function createBundleRunner(entry, files, basedir, runInNewContext) {
         // on each render. Ensures entire application state is fresh for each
         // render, but incurs extra evaluation cost.
         return function (userContext) {
-            if ( userContext === void 0 ) userContext = {};
-
+            if (userContext === void 0) { userContext = {}; }
             return new Promise(function (resolve) {
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            var res = evaluate(entry, createSandbox(userContext));
-            resolve(typeof res === 'function' ? res(userContext) : res);
-        });
+                // @ts-expect-error
+                userContext._registeredComponents = new Set();
+                var res = evaluate(entry, createSandbox(userContext));
+                resolve(typeof res === 'function' ? res(userContext) : res);
+            });
         };
     }
     else {
@@ -8164,50 +8014,49 @@ function createBundleRunner(entry, files, basedir, runInNewContext) {
         // each render, it simply calls the exported function. This avoids the
         // module evaluation costs but requires the source code to be structured
         // slightly differently.
-        var runner; // lazy creation so that errors can be caught by user
-        var initialContext;
+        var runner_1; // lazy creation so that errors can be caught by user
+        var initialContext_1;
         return function (userContext) {
-            if ( userContext === void 0 ) userContext = {};
-
+            if (userContext === void 0) { userContext = {}; }
             return new Promise(function (resolve) {
-            if (!runner) {
-                var sandbox = runInNewContext === 'once' ? createSandbox() : global;
-                // the initial context is only used for collecting possible non-component
-                // styles injected by vue-style-loader.
-                // @ts-expect-error
-                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
-                runner = evaluate(entry, sandbox);
-                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-                // to prevent cross-request pollution.
-                // @ts-expect-error
-                delete sandbox.__VUE_SSR_CONTEXT__;
-                if (typeof runner !== 'function') {
-                    throw new Error('bundle export should be a function when using ' +
-                        '{ runInNewContext: false }.');
+                if (!runner_1) {
+                    var sandbox = runInNewContext === 'once' ? createSandbox() : global;
+                    // the initial context is only used for collecting possible non-component
+                    // styles injected by vue-style-loader.
+                    // @ts-expect-error
+                    initialContext_1 = sandbox.__VUE_SSR_CONTEXT__ = {};
+                    runner_1 = evaluate(entry, sandbox);
+                    // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+                    // to prevent cross-request pollution.
+                    // @ts-expect-error
+                    delete sandbox.__VUE_SSR_CONTEXT__;
+                    if (typeof runner_1 !== 'function') {
+                        throw new Error('bundle export should be a function when using ' +
+                            '{ runInNewContext: false }.');
+                    }
                 }
-            }
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            // vue-style-loader styles imported outside of component lifecycle hooks
-            if (initialContext._styles) {
                 // @ts-expect-error
-                userContext._styles = deepClone(initialContext._styles);
-                // #6353 ensure "styles" is exposed even if no styles are injected
-                // in component lifecycles.
-                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-                var renderStyles = initialContext._renderStyles;
-                if (renderStyles) {
-                    Object.defineProperty(userContext, 'styles', {
-                        enumerable: true,
-                        get: function get() {
-                            // @ts-expect-error
-                            return renderStyles(userContext._styles);
-                        },
-                    });
+                userContext._registeredComponents = new Set();
+                // vue-style-loader styles imported outside of component lifecycle hooks
+                if (initialContext_1._styles) {
+                    // @ts-expect-error
+                    userContext._styles = deepClone(initialContext_1._styles);
+                    // #6353 ensure "styles" is exposed even if no styles are injected
+                    // in component lifecycles.
+                    // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+                    var renderStyles_1 = initialContext_1._renderStyles;
+                    if (renderStyles_1) {
+                        Object.defineProperty(userContext, 'styles', {
+                            enumerable: true,
+                            get: function () {
+                                // @ts-expect-error
+                                return renderStyles_1(userContext._styles);
+                            },
+                        });
+                    }
                 }
-            }
-            resolve(runner(userContext));
-        });
+                resolve(runner_1(userContext));
+            });
         };
     }
 }
@@ -8241,10 +8090,8 @@ function rewriteTraceLine(trace, mapConsumers) {
             column: Number(m[3]),
         });
         if (originalPosition.source != null) {
-            var source = originalPosition.source;
-            var line = originalPosition.line;
-            var column = originalPosition.column;
-            var mappedPosition = "(" + (source.replace(/^webpack:\/\/\//, '')) + ":" + (String(line)) + ":" + (String(column)) + ")";
+            var source = originalPosition.source, line = originalPosition.line, column = originalPosition.column;
+            var mappedPosition = "(" + source.replace(/^webpack:\/\/\//, '') + ":" + String(line) + ":" + String(column) + ")";
             return trace.replace(filenameRE, mappedPosition);
         }
         else {
@@ -8258,24 +8105,23 @@ function rewriteTraceLine(trace, mapConsumers) {
 
 /* @flow */
 var fs = require('fs');
-var path$2 = require('path');
+var path = require('path');
 var PassThrough = require('stream').PassThrough;
 var INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
     'or a bundle Object of type:\n\n' +
     "{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";
 function createBundleRendererCreator(createRenderer) {
     return function createBundleRenderer(bundle, rendererOptions) {
-        if ( rendererOptions === void 0 ) rendererOptions = {};
-
+        if (rendererOptions === void 0) { rendererOptions = {}; }
         var files, entry, maps;
         var basedir = rendererOptions.basedir;
         // load bundle if given filepath
         if (typeof bundle === 'string' &&
             /\.js(on)?$/.test(bundle) &&
-            path$2.isAbsolute(bundle)) {
+            path.isAbsolute(bundle)) {
             if (fs.existsSync(bundle)) {
                 var isJSON = /\.json$/.test(bundle);
-                basedir = basedir || path$2.dirname(bundle);
+                basedir = basedir || path.dirname(bundle);
                 bundle = fs.readFileSync(bundle, 'utf-8');
                 if (isJSON) {
                     try {
@@ -8283,12 +8129,12 @@ function createBundleRendererCreator(createRenderer) {
                         bundle = JSON.parse(bundle);
                     }
                     catch (e) {
-                        throw new Error(("Invalid JSON bundle file: " + bundle));
+                        throw new Error("Invalid JSON bundle file: " + bundle);
                     }
                 }
             }
             else {
-                throw new Error(("Cannot locate bundle file: " + bundle));
+                throw new Error("Cannot locate bundle file: " + bundle);
             }
         }
         if (typeof bundle === 'object') {
@@ -8312,15 +8158,14 @@ function createBundleRendererCreator(createRenderer) {
         var run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
         return {
             renderToString: function (context, cb) {
-                var assign;
-
+                var _a;
                 if (typeof context === 'function') {
                     cb = context;
                     context = {};
                 }
                 var promise;
                 if (!cb) {
-                    ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
+                    (_a = createPromiseCallback(), promise = _a.promise, cb = _a.cb);
                 }
                 run(context)
                     .catch(function (err) {
@@ -8377,19 +8222,18 @@ function createBundleRendererCreator(createRenderer) {
 
 /* @flow */
 process.env.VUE_ENV = 'server';
-function createRenderer$1(options) {
-    if ( options === void 0 ) options = {};
-
-    return createRenderer(extend(extend({}, options), {
+function createRenderer(options) {
+    if (options === void 0) { options = {}; }
+    return createRenderer$1(extend(extend({}, options), {
         isUnaryTag: isUnaryTag,
         canBeLeftOpenTag: canBeLeftOpenTag,
-        modules: modules,
+        modules: modules$1,
         // user can provide server-side implementations for custom directives
         // when creating the renderer.
-        directives: extend(baseDirectives, options.directives),
+        directives: extend(baseDirectives$1, options.directives),
     }));
 }
-var createBundleRenderer = createBundleRendererCreator(createRenderer$1);
+var createBundleRenderer = createBundleRendererCreator(createRenderer);
 
-exports.createRenderer = createRenderer$1;
 exports.createBundleRenderer = createBundleRenderer;
+exports.createRenderer = createRenderer;
diff --git a/packages/vue-server-renderer/build.prod.js b/packages/vue-server-renderer/build.prod.js
index e14d8fd57a1..5a8db191ba0 100644
--- a/packages/vue-server-renderer/build.prod.js
+++ b/packages/vue-server-renderer/build.prod.js
@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream"),t=require("he"),r=Object.freeze({});function n(e){return null==e}function i(e){return null!=e}function o(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function s(e){return null!==e&&"object"==typeof e}var c=Object.prototype.toString;function u(e){return"[object Object]"===c.call(e)}function l(e){return i(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function f(e){return null==e?"":Array.isArray(e)||u(e)&&e.toString===c?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)return e.splice(r,1)}}var y=Object.prototype.hasOwnProperty;function g(e,t){return y.call(e,t)}function b(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var _=/-(\w)/g,w=b(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),x=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),S=/\B([A-Z])/g,$=b(function(e){return e.replace(S,"-$1").toLowerCase()});Function.prototype.bind;function A(e,t){for(var r in t)e[r]=t[r];return e}function O(e){for(var t={},r=0;r<e.length;r++)e[r]&&A(t,e[r]);return t}function k(e,t,r){}var C=function(e,t,r){return!1},T=function(e){return e};function F(e,t){if(e===t)return!0;var r=s(e),n=s(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return F(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),c=Object.keys(t);return a.length===c.length&&a.every(function(r){return F(e[r],t[r])})}catch(e){return!1}}function j(e,t){for(var r=0;r<e.length;r++)if(F(e[r],t))return r;return-1}function P(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var E=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),N=/[>/="'\u0009\u000a\u000c\u0020]/,L=function(e){return N.test(e)},I=function(e){return E(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},M={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},R={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function D(e){return e.replace(/[<>"&]/g,U)}function U(e){return R[e]||e}var z={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},B=d("input,textarea,option,select,progress"),q=d("contenteditable,draggable,spellcheck"),J=d("events,caret,typing,plaintext-only"),H=function(e,t){return V(t)||"false"===t?"false":"contenteditable"===e&&J(t)?t:"true"},K=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),V=function(e){return null==e||!1===e};function W(e,t){if(K(e)){if(!V(t))return" "+e+'="'+e+'"'}else{if(q(e))return" "+e+'="'+D(H(e,t))+'"';if(!V(t))return" "+e+'="'+D(String(t))+'"'}return""}var Z=function(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},X={child:{configurable:!0}};X.child.get=function(){return this.componentInstance},Object.defineProperties(Z.prototype,X);var G=function(e){void 0===e&&(e="");var t=new Z;return t.text=e,t.isComment=!0,t};function Q(e){return new Z(void 0,void 0,void 0,String(e))}function Y(e,t,r){var n=new Z(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ee(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var te,re="__proto__"in{},ne="undefined"!=typeof window,ie="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,oe=ie&&WXEnvironment.platform.toLowerCase(),ae=ne&&window.navigator.userAgent.toLowerCase(),se=ae&&/msie|trident/.test(ae),ce=(ae&&ae.indexOf("msie 9.0"),ae&&ae.indexOf("edge/")>0),ue=(ae&&ae.indexOf("android"),ae&&/iphone|ipad|ipod|ios/.test(ae),ae&&/chrome\/\d+/.test(ae),ae&&/phantomjs/.test(ae),ae&&ae.match(/firefox\/(\d+)/),{}.watch);if(ne)try{var le={};Object.defineProperty(le,"passive",{get:function(){}}),window.addEventListener("test-passive",null,le)}catch(e){}var fe=function(){return void 0===te&&(te=!ne&&!ie&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),te};ne&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function pe(e){return"function"==typeof e&&/native code/.test(e.toString())}var de,ve="undefined"!=typeof Symbol&&pe(Symbol)&&"undefined"!=typeof Reflect&&pe(Reflect.ownKeys);de="undefined"!=typeof Set&&pe(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var he="data-server-rendered",me=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],ye={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:C,isReservedAttr:C,isUnknownElement:C,getTagNamespace:k,parsePlatformTagName:T,mustUseProp:C,async:!0,_lifecycleHooks:me},ge=0,be=function(){this.id=ge++,this.subs=[]};be.prototype.addSub=function(e){this.subs.push(e)},be.prototype.removeSub=function(e){m(this.subs,e)},be.prototype.depend=function(){be.target&&be.target.addDep(this)},be.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},be.target=null;var _e=[];function we(e){_e.push(e),be.target=e}function xe(){_e.pop(),be.target=_e[_e.length-1]}var Se=Array.prototype,$e=Object.create(Se);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=Se[e];ee($e,e,function(){for(var r=[],n=arguments.length;n--;)r[n]=arguments[n];var i,o=t.apply(this,r),a=this.__ob__;switch(e){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var Ae=Object.getOwnPropertyNames($e),Oe=!0;function ke(e){Oe=e}var Ce=function(e){var t;this.value=e,this.dep=new be,this.vmCount=0,ee(e,"__ob__",this),Array.isArray(e)?(re?(t=$e,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ee(e,o,t[o])}}(e,$e,Ae),this.observeArray(e)):this.walk(e)};function Te(e,t){var r;if(s(e)&&!(e instanceof Z))return g(e,"__ob__")&&e.__ob__ instanceof Ce?r=e.__ob__:Oe&&!fe()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Ce(e)),t&&r&&r.vmCount++,r}function Fe(e,t,r,n,i){var o=new be,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&Te(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return be.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&Te(t),o.notify())}})}}function je(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Fe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}Ce.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Fe(e,t[r])},Ce.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)Te(e[t])};var Pe=ye.optionMergeStrategies;function Ee(e,t){if(!t)return e;for(var r,n,i,o=ve?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],g(e,r)?n!==i&&u(n)&&u(i)&&Ee(n,i):je(e,r,i));return e}function Ne(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ee(n,i):i}:t?e?function(){return Ee("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Le(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Ie(e,t,r,n){var i=Object.create(e||null);return t?A(i,t):i}Pe.data=function(e,t,r){return r?Ne(e,t,r):t&&"function"!=typeof t?e:Ne(e,t)},me.forEach(function(e){Pe[e]=Le}),["component","directive","filter"].forEach(function(e){Pe[e+"s"]=Ie}),Pe.watch=function(e,t,r,n){if(e===ue&&(e=void 0),t===ue&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Pe.props=Pe.methods=Pe.inject=Pe.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Pe.provide=Ne;var Me=function(e,t){return void 0===t?e:t};function Re(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[w(i)]={type:null});else if(u(r))for(var a in r)i=r[a],o[w(a)]=u(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(u(r))for(var o in r){var a=r[o];n[o]=u(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=Re(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=Re(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)g(e,o)||s(o);function s(n){var i=Pe[n]||Me;a[n]=i(e[n],t[n],r,n)}return a}function De(e,t,r,n){if("string"==typeof r){var i=e[t];if(g(i,r))return i[r];var o=w(r);if(g(i,o))return i[o];var a=x(o);return g(i,a)?i[a]:i[r]||i[o]||i[a]}}function Ue(e,t,r,n){var i=t[e],o=!g(r,e),a=r[e],s=Je(Boolean,i.type);if(s>-1)if(o&&!g(i,"default"))a=!1;else if(""===a||a===$(e)){var c=Je(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!g(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Be(t.type)?n.call(e):n}(n,i,e);var u=Oe;ke(!0),Te(a),ke(u)}return a}var ze=/^\s*function (\w+)/;function Be(e){var t=e&&e.toString().match(ze);return t?t[1]:""}function qe(e,t){return Be(e)===Be(t)}function Je(e,t){if(!Array.isArray(t))return qe(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(qe(t[r],e))return r;return-1}function He(e,t,r){we();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){Ve(e,n,"errorCaptured hook")}}Ve(e,t,r)}finally{xe()}}function Ke(e,t,r,n,i){var o;try{(o=r?e.apply(t,r):e.call(t))&&!o._isVue&&l(o)&&!o._handled&&(o.catch(function(e){return He(e,n,i+" (Promise/async)")}),o._handled=!0)}catch(e){He(e,n,i)}return o}function Ve(e,t,r){!function(e,t,r){if(!ne&&!ie||"undefined"==typeof console)throw e;console.error(e)}(e)}var We=[];if("undefined"!=typeof Promise&&pe(Promise));else if(se||"undefined"==typeof MutationObserver||!pe(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&pe(setImmediate);else{var Ze=new MutationObserver(function(){var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}),Xe=document.createTextNode(String(1));Ze.observe(Xe,{characterData:!0})}function Ge(e,t){return{staticClass:Ye(e.staticClass,t.staticClass),class:i(e.class)?[e.class,t.class]:t.class}}function Qe(e,t){return i(e)||i(t)?Ye(e,et(t)):""}function Ye(e,t){return e?t?e+" "+t:e:t||""}function et(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,o=e.length;n<o;n++)i(t=et(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):s(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var tt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),rt=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var nt=b(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function it(e){var t=ot(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ot(e){return Array.isArray(e)?O(e):"string"==typeof e?nt(e):e}function at(e){var t="";for(var r in e){var n=e[r],i=$(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=st(i,n[o]);else t+=st(i,n)}return t}function st(e,t){return"string"==typeof t||"number"==typeof t&&z[e]||0===t?e+":"+t+";":""}var ct=[function(e){var t=e.data.attrs,r="",o=e.parent&&e.parent.componentOptions;if(n(o)||!1!==o.Ctor.options.inheritAttrs)for(var a=e.parent;i(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)i(a.data)&&i(a.data.attrs)&&(t=A(A({},t),a.data.attrs)),a=a.parent;if(n(t))return r;for(var s in t)L(s)||"style"!==s&&(r+=W(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",o=e.parent;i(o);)o.data&&o.data.domProps&&(t=A(A({},t),o.data.domProps)),o=o.parent;if(n(t))return r;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)Y(e,t[s],!0);else if("textContent"===s)Y(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)Y(e,f(t[s]),!1);else{var c=M[s]||s.toLowerCase();!I(c)||i(a)&&i(a[c])||(r+=W(c,t[s]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;i(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Ge(n.data,t));for(;i(r=r.parent);)r&&r.data&&(t=Ge(t,r.data));return Qe(t.staticClass,t.class)}(e);if(""!==t)return' class="'+D(t)+'"'},function(e){var t=at(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=it(i.data))&&A(n,r);(r=it(e.data))&&A(n,r);for(var o=e;o=o.parent;)o.data&&(r=it(o.data))&&A(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(D(t))}];function ut(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function lt(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var ft={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&j(r,ut(a))>-1&&lt(a);else if(F(r,ut(a)))return void lt(a)}}},pt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),dt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),vt=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ht=800,mt=function(e){return e},yt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:mt;if(yt===mt)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function gt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=ht?yt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var bt=function(e){function t(t){var r=this;e.call(this),this.buffer="",this.render=t,this.expectedSize=0,this.write=gt(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),this.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)}}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,o(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):n(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),_t=function(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&wt(t,"get"),this.has=t&&wt(t,"has"),this.next=this.next.bind(this)};function wt(e,t){var r=e[t];return n(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}_t.prototype.next=function(){for(;;){var e=this.renderStates[this.renderStates.length-1];if(n(e))return this.done();switch(e.type){case"Element":case"Fragment":var t=e.children,r=e.total,i=e.rendered++;if(i<r)return this.renderNode(t[i],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();var o=e.buffer,a=e.bufferIndex,s=e.componentBuffer,c=e.key,u={html:o[a],components:s[a]};if(this.cache.set(c,u),0===a)this.write.caching=!1;else{o[a-1]+=u.html;var l=s[a-1];u.components.forEach(function(e){return l.add(e)})}o.length=a,s.length=a}}};var xt=/[\w).+\-_$\]]/;function St(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&xt.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=$t(i,o[n]);return i}function $t(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var At=/\{\{((?:.|\r?\n)+?)\}\}/g,Ot=/[-.*+?^${}()|[\]\/\\]/g,kt=b(function(e){var t=e[0].replace(Ot,"\\$&"),r=e[1].replace(Ot,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function Ct(e,t){console.error("[Vue compiler]: "+e)}function Tt(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Ft(e,t,r,n,i){(e.props||(e.props=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function jt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function Pt(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Dt({name:t,value:r},n))}function Et(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Dt({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Nt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Lt(e,t,n,i,o,a,s,c){var u;(i=i||r).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Nt("!",t,c)),i.once&&(delete i.once,t=Nt("~",t,c)),i.passive&&(delete i.passive,t=Nt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Dt({value:n.trim(),dynamic:c},s);i!==r&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function It(e,t,r){var n=Mt(e,":"+t)||Mt(e,"v-bind:"+t);if(null!=n)return St(n);if(!1!==r){var i=Mt(e,t);if(null!=i)return JSON.stringify(i)}}function Mt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Rt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Dt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var Ut={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Mt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=It(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var zt,Bt,qt,Jt,Ht,Kt,Vt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Mt(e,"style");r&&(e.staticStyle=JSON.stringify(nt(r)));var n=It(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Wt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Zt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Xt="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Gt="((?:"+Xt+"\\:)?"+Xt+")",Qt=new RegExp("^<"+Gt),Yt=/^\s*(\/?)>/,er=new RegExp("^<\\/"+Gt+"[^>]*>"),tr=/^<!DOCTYPE [^>]+>/i,rr=/^<!\--/,nr=/^<!\[/,ir=d("script,style,textarea",!0),or={},ar={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},sr=/&(?:lt|gt|quot|amp|#39);/g,cr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,ur=d("pre,textarea",!0),lr=function(e,t){return e&&ur(e)&&"\n"===t[0]};function fr(e,t){var r=t?cr:sr;return e.replace(r,function(e){return ar[e]})}function pr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=dr(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function dr(e,t){var r=function(e){if(e=e.trim(),zt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<zt-1)return(Jt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Jt),key:'"'+e.slice(Jt+1)+'"'}:{exp:e,key:null};Bt=e,Jt=Ht=Kt=0;for(;!hr();)mr(qt=vr())?gr(qt):91===qt&&yr(qt);return{exp:e.slice(0,Ht),key:e.slice(Ht+1,Kt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function vr(){return Bt.charCodeAt(++Jt)}function hr(){return Jt>=zt}function mr(e){return 34===e||39===e}function yr(e){var t=1;for(Ht=Jt;!hr();)if(mr(e=vr()))gr(e);else if(91===e&&t++,93===e&&t--,0===t){Kt=Jt;break}}function gr(e){for(var t=e;!hr()&&(e=vr())!==t;);}var br,_r,wr,xr,Sr,$r,Ar,Or,kr=/^@|^v-on:/,Cr=/^v-|^@|^:|^#/,Tr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,jr=/^\(|\)$/g,Pr=/^\[.*\]$/,Er=/:(.*)$/,Nr=/^:|^\.|^v-bind:/,Lr=/\.[^.\]]+(?=[^\]]*$)/g,Ir=/^v-slot(:|$)|^#/,Mr=/[\r\n]/,Rr=/[ \f\t\r\n]+/g,Dr=b(t.decode),Ur="_empty_";function zr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Wr(t),rawAttrsMap:{},parent:r,children:[]}}function Br(e,t){br=t.warn||Ct,$r=t.isPreTag||C,Ar=t.mustUseProp||C,Or=t.getTagNamespace||C;t.isReservedTag;wr=Tt(t.modules,"transformNode"),xr=Tt(t.modules,"preTransformNode"),Sr=Tt(t.modules,"postTransformNode"),_r=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=qr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Hr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Hr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),$r(e.tag)&&(c=!1);for(var f=0;f<Sr.length;f++)Sr[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||C,s=t.canBeLeftOpenTag||C,c=0;e;){if(r=e,n&&ir(n)){var u=0,l=n.toLowerCase(),f=or[l]||(or[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,function(e,r,n){return u=n.length,ir(l)||"noscript"===l||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),lr(l,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-p.length,e=p,O(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(rr.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),S(v+3);continue}}if(nr.test(e)){var h=e.indexOf("]>");if(h>=0){S(h+2);continue}}var m=e.match(tr);if(m){S(m[0].length);continue}var y=e.match(er);if(y){var g=c;S(y[0].length),O(y[1],g,c);continue}var b=$();if(b){A(b),lr(b.tagName,e)&&S(1);continue}}var _=void 0,w=void 0,x=void 0;if(d>=0){for(w=e.slice(d);!(er.test(w)||Qt.test(w)||rr.test(w)||nr.test(w)||(x=w.indexOf("<",1))<0);)d+=x,w=e.slice(d);_=e.substring(0,d)}d<0&&(_=e),_&&S(_.length),t.chars&&_&&t.chars(_,c-_.length,c)}if(e===r){t.chars&&t.chars(e);break}}function S(t){c+=t,e=e.substring(t)}function $(){var t=e.match(Qt);if(t){var r,n,i={tagName:t[1],attrs:[],start:c};for(S(t[0].length);!(r=e.match(Yt))&&(n=e.match(Zt)||e.match(Wt));)n.start=c,S(n[0].length),n.end=c,i.attrs.push(n);if(r)return i.unarySlash=r[1],S(r[0].length),i.end=c,i}}function A(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&vt(r)&&O(n),s(r)&&n===r&&O(r));for(var u=a(r)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===r&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:fr(v,h)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:f,start:e.start,end:e.end}),n=r),t.start&&t.start(r,f,u,e.start,e.end)}function O(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}O()}(e,{warn:br,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||Or(e);se&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Zr.test(n.name)||(n.name=n.name.replace(Xr,""),t.push(n))}return t}(o));var d,v=zr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||fe()||(v.forbidden=!0);for(var h=0;h<xr.length;h++)v=xr[h](v,t)||v;s||(!function(e){null!=Mt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),$r(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Jr(v),function(e){var t=Mt(e,"v-if");if(t)e.if=t,Hr(e,{exp:t,block:e});else{null!=Mt(e,"v-else")&&(e.else=!0);var r=Mt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Mt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!se||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u,l,f=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Dr(e):f.length?a?"condense"===a&&Mr.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(Rr," ")),!s&&" "!==e&&(u=function(e,t){var r=t?kt(t):At;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=St(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,_r))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function qr(e,t){var r,n;(n=It(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=It(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Mt(e,"scope"),e.slotScope=t||Mt(e,"slot-scope")):(t=Mt(e,"slot-scope"))&&(e.slotScope=t);var r=It(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||jt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Rt(e,Ir);if(n){var i=Kr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Ur}}else{var s=Rt(e,Ir);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=Kr(s),l=u.name,f=u.dynamic,p=c[l]=zr("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=p,!0}),p.slotScope=s.value||Ur,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=It(e,"name"))}(e),function(e){var t;(t=It(e,"is"))&&(e.component=t);null!=Mt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<wr.length;i++)e=wr[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Cr.test(n))if(e.hasBindings=!0,(a=Vr(n.replace(Cr,"")))&&(n=n.replace(Lr,"")),Nr.test(n))n=n.replace(Nr,""),o=St(o),(c=Pr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),a.camel&&!c&&(n=w(n)),a.sync&&(s=dr(o,"$event"),c?Lt(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Lt(e,"update:"+w(n),s,null,!1,0,u[t]),$(n)!==w(n)&&Lt(e,"update:"+$(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Ar(e.tag,e.attrsMap.type,n)?Ft(e,n,o,u[t],c):jt(e,n,o,u[t],c);else if(kr.test(n))n=n.replace(kr,""),(c=Pr.test(n))&&(n=n.slice(1,-1)),Lt(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Cr,"")).match(Er),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Pr.test(f)&&(f=f.slice(1,-1),c=!0)),Et(e,n,i,o,f,c,a,u[t])}else jt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&Ar(e.tag,e.attrsMap.type,n)&&Ft(e,n,"true",u[t])}(e),e}function Jr(e){var t;if(t=Mt(e,"v-for")){var r=function(e){var t=e.match(Tr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(jr,""),i=n.match(Fr);i?(r.alias=n.replace(Fr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&A(e,r)}}function Hr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Kr(e){var t=e.name.replace(Ir,"");return t||"#"!==e.name[0]&&(t="default"),Pr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Vr(e){var t=e.match(Lr);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function Wr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Zr=/^xmlns:NS\d+/,Xr=/^NS\d+:/;function Gr(e){return zr(e.tag,e.attrsList.slice(),e.parent)}var Qr=[Ut,Vt,{preTransformNode:function(e,t){if("input"===e.tag){var r,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(r=It(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Mt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Mt(e,"v-else",!0),s=Mt(e,"v-else-if",!0),c=Gr(e);Jr(c),Pt(c,"type","checkbox"),qr(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,Hr(c,{exp:c.if,block:c});var u=Gr(e);Mt(u,"v-for",!0),Pt(u,"type","radio"),qr(u,t),Hr(c,{exp:"("+r+")==='radio'"+o,block:u});var l=Gr(e);return Mt(l,"v-for",!0),Pt(l,":type",r),qr(l,t),Hr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],Yr="__r";var en={expectHTML:!0,modules:Qr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return pr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+dr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lt(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null",o=It(e,"true-value")||"true",a=It(e,"false-value")||"false";Ft(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Lt(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+dr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+dr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+dr(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null";Ft(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Lt(e,"change",dr(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return pr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Yr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=dr(t,l);c&&(f="if($event.target.composing)return;"+f),Ft(e,"value","("+t+")"),Lt(e,u,f,null,!0),(s||a)&&Lt(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&Ft(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Ft(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:pt,mustUseProp:function(e,t,r){return"value"===r&&B(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:dt,isReservedTag:function(e){return tt(e)||rt(e)},getTagNamespace:function(e){return rt(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Qr)},tn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,rn=/\([^)]*?\);*$/,nn=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,on={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},an={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},sn=function(e){return"if("+e+")return null;"},cn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:sn("$event.target !== $event.currentTarget"),ctrl:sn("!$event.ctrlKey"),shift:sn("!$event.shiftKey"),alt:sn("!$event.altKey"),meta:sn("!$event.metaKey"),left:sn("'button' in $event && $event.button !== 0"),middle:sn("'button' in $event && $event.button !== 1"),right:sn("'button' in $event && $event.button !== 2")};function un(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=ln(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function ln(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return ln(e)}).join(",")+"]";var t=nn.test(e.value),r=tn.test(e.value),n=nn.test(e.value.replace(rn,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(cn[s])o+=cn[s],on[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=sn(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(fn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function fn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=on[e],n=an[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var pn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:k},dn=function(e){this.options=e,this.warn=e.warn||Ct,this.transforms=Tt(e.modules,"transformCode"),this.dataGenFns=Tt(e.modules,"genData"),this.directives=A(A({},pn),e.directives);var t=e.isReservedTag||C;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function vn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return hn(e,t);if(e.once&&!e.onceProcessed)return mn(e,t);if(e.for&&!e.forProcessed)return gn(e,t);if(e.if&&!e.ifProcessed)return yn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=xn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?On((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:xn(t,r,!0);return"_c("+e+","+bn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=bn(e,t));var i=e.inlineTemplate?null:xn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return xn(e,t)||"void 0"}function hn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+vn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function mn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return yn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+vn(e,t)+","+t.onceId+++","+r+")":vn(e,t)}return hn(e,t)}function yn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?mn(e,r):vn(e,r)}}(e.ifConditions.slice(),t,r,n)}function gn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||vn)(e,t)+"})"}function bn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+On(e.attrs)+","),e.props&&(r+="domProps:"+On(e.props)+","),e.events&&(r+=un(e.events,!1)+","),e.nativeEvents&&(r+=un(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||_n(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Ur||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return wn(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":vn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+On(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function _n(e){return 1===e.type&&("slot"===e.tag||e.children.some(_n))}function wn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return yn(e,t,wn,"null");if(e.for&&!e.forProcessed)return gn(e,t,wn);var n=e.slotScope===Ur?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(xn(e,t)||"undefined")+":undefined":xn(e,t)||"undefined":vn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function xn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||vn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(Sn(i)||i.ifConditions&&i.ifConditions.some(function(e){return Sn(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||$n;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Sn(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function $n(e,t){return 1===e.type?vn(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):An(e);var r}function An(e){return"_v("+(2===e.type?e.expression:kn(JSON.stringify(e.text)))+")"}function On(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=kn(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function kn(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Cn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function Tn(e,t){return Cn.test(t)?(t=t.replace(/^'|'$/g,'"'),q(e)&&'"false"'!==t&&(t='"true"'),{type:Nn,value:K(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:In,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var Fn,jn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Pn(e,t){e&&(Fn=t.isReservedTag||C,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!Fn(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=jn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!En(e.name)})}(t);var i=function(e){e.ssrOptimizability!==jn.FULL&&(t.ssrOptimizability=n?jn.PARTIAL:jn.SELF)};n&&(t.ssrOptimizability=jn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var c=1,u=t.ifConditions.length;c<u;c++){var l=t.ifConditions[c].block;e(l,r),i(l)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=jn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:jn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===jn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=jn.FULL}(e,!0))}var En=d("text,html,show,on,bind,model,pre,cloak,once");var Nn=0,Ln=1,In=2;function Mn(e,t){if(e.for&&!e.forProcessed)return gn(e,t,Mn);if(e.if&&!e.ifProcessed)return yn(e,t,Mn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===jn.FULL?zn(e,t):Dn(e,t)||"void 0";switch(e.ssrOptimizability){case jn.FULL:return function(e,t){return"_ssrNode("+Bn(e,t)+")"}(e,t);case jn.SELF:return function(e,t){var r=Dn(e,t,!0);return"_ssrNode("+Kn(Jn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case jn.CHILDREN:return Rn(e,t,!0);case jn.PARTIAL:return Rn(e,t,!1);default:return vn(e,t)}}function Rn(e,t,r){var n=e.plain?void 0:bn(e,t),i=r?"["+zn(e,t)+"]":Dn(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Dn(e,t,r){return xn(e,t,r,Mn,Un)}function Un(e,t){return 1===e.type?Mn(e,t):An(e)}function zn(e,t){return e.children.length?"_ssrNode("+Kn(Hn(e,t))+")":""}function Bn(e,t){return"("+Kn(qn(e,t))+")"}function qn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:In,value:gn(e,t,Bn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:In,value:yn(e,t,Bn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Hn(e,t);var r=Jn(e,t),n=Hn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:Nn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Jn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:Nn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return Tn(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=M[n]||n.toLowerCase(),!I(n)||t&&t.some(function(e){return e.name===n})||r.push(Tn(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:In,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:In,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:Nn,value:' class="'+JSON.parse(n)+'"'}]:[{type:In,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:In,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:Nn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:Nn,value:" "+t.options.scopeId}),u.push({type:Nn,value:">"}),u}function Hn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:In,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Ln,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Ln,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,qn(i,t));else if(2===i.type)r.push({type:Ln,value:i.expression});else if(3===i.type){var o=D(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:Nn,value:o})}}return r}(e.children,t):[]}function Kn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===Nn?r+=o.value:o.type===Ln?(n(),t.push("_ssrEscape("+o.value+")")):o.type===In&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Vn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),k}}function Wn(e){var t=Object.create(null);return function(r,n,i){(n=A({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Vn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Vn(e,c)}),t[o]=s}}var Zn,Xn=(Zn=function(e,t){var r=Br(e.trim(),t);Pn(r,t);var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?Mn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=A(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=Zn(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Wn(t)}})(en),Gn=(Xn.compile,Xn.compileToFunctions);function Qn(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Yn(e){return a(e)?[Q(e)]:Array.isArray(e)?function e(t,r){var s=[];var c,u,l,f;for(c=0;c<t.length;c++)n(u=t[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ei((u=e(u,(r||"")+"_"+c))[0])&&ei(f)&&(s[l]=Q(f.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?ei(f)?s[l]=Q(f.text+u):""!==u&&s.push(Q(u)):ei(u)&&ei(f)?s[l]=Q(f.text+u.text):(o(t._isVList)&&i(u.tag)&&n(u.key)&&i(r)&&(u.key="__vlist"+r+"_"+c+"__"),s.push(u)));return s}(e):void 0}function ei(e){return i(e)&&i(e.text)&&!1===e.isComment}var ti={_ssrEscape:D,_ssrNode:function(e,t,r,n){return new ri(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(s(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:W,_ssrAttrs:function(e){var t="";for(var r in e)L(r)||(t+=W(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=M[r]||r.toLowerCase();I(n)&&(t+=W(n,e[r]))}return t},_ssrClass:function(e,t){var r=Qe(e,t);return""===r?r:' class="'+D(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&A(n,e);t&&A(n,ot(t));r&&A(n,r);var i=at(n);return""===i?i:" style="+JSON.stringify(D(i))}};var ri=function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?Qn(r):2===n?Yn(r):r:void 0};var ni=new de;function ii(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!s(t)||Object.isFrozen(t)||t instanceof Z)return;if(t.__ob__){var a=t.__ob__.dep.id;if(r.has(a))return;r.add(a)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,ni),ni.clear()}var oi=b(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function ai(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return Ke(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)Ke(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function si(e,t,r,n,o){if(i(t)){if(g(t,r))return e[r]=t[r],o||delete t[r],!0;if(g(t,n))return e[r]=t[n],o||delete t[n],!0}return!1}var ci=1,ui=2;function li(e,t,r,c,u,l){return(Array.isArray(r)||a(r))&&(u=c,c=r,r=void 0),o(l)&&(u=ui),function(e,t,r,a,c){if(i(r)&&i(r.__ob__))return G();i(r)&&i(r.is)&&(t=r.is);if(!t)return G();Array.isArray(a)&&"function"==typeof a[0]&&((r=r||{}).scopedSlots={default:a[0]},a.length=0);c===ui?a=Yn(a):c===ci&&(a=Qn(a));var u,l;if("string"==typeof t){var f;l=e.$vnode&&e.$vnode.ns||ye.getTagNamespace(t),u=r&&r.pre||!i(f=De(e.$options,"components",t))?new Z(t,r,a,void 0,void 0,e):Ki(f,r,e,a,t)}else u=Ki(t,r,e,a);return Array.isArray(u)?u:i(u)?(i(l)&&function e(t,r,a){t.ns=r;"foreignObject"===t.tag&&(r=void 0,a=!0);if(i(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];i(u.tag)&&(n(u.ns)||o(a)&&"svg"!==u.tag)&&e(u,r,a)}}(u,l),i(r)&&function(e){s(e.style)&&ii(e.style);s(e.class)&&ii(e.class)}(r),u):G()}(e,t,r,c,u)}function fi(e,t){var r,n,o,a,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,n=e.length;r<n;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(s(e))if(ve&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,n=o.length;r<n;r++)a=o[r],c[r]=t(e[a],a,r);return i(c)||(c=[]),c._isVList=!0,c}function pi(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=A(A({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function di(e){return De(this.$options,"filters",e)||T}function vi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function hi(e,t,r,n,i){var o=ye.keyCodes[t]||r;return i&&n&&!ye.keyCodes[t]?vi(i,n):o?vi(o,e):n?$(n)!==t:void 0}function mi(e,t,r,n,i){if(r)if(s(r)){var o;Array.isArray(r)&&(r=O(r));var a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||ye.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(a),u=$(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var c in r)a(c)}else;return e}function yi(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(bi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function gi(e,t,r){return bi(e,"__once__"+t+(r?"_"+r:""),!0),e}function bi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&_i(e[n],t+"_"+n,r);else _i(e,t,r)}function _i(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function wi(e,t){if(t)if(u(t)){var r=e.on=e.on?A({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function xi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?xi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function Si(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function $i(e,t){return"string"==typeof e?t+e:e}function Ai(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Oi)&&delete r[u];return r}function Oi(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ki(e,t,n){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&n&&n!==r&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Ci(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Ti(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ee(i,"$stable",a),ee(i,"$key",s),ee(i,"$hasNormal",o),i}function Ci(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Yn(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Ti(e,t){return function(){return e[t]}}var Fi,ji=null;function Pi(e,t){return(e.__esModule||ve&&"Module"===e[Symbol.toStringTag])&&(e=e.default),s(e)?t.extend(e):e}function Ei(e,t){Fi.$on(e,t)}function Ni(e,t){Fi.$off(e,t)}function Li(e,t){var r=Fi;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ii(e,t,r){Fi=e,function(e,t,r,i,a,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=oi(c),n(u)||(n(l)?(n(u.fns)&&(u=e[c]=ai(u,s)),o(f.once)&&(u=e[c]=a(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)n(e[c])&&i((f=oi(c)).name,t[c],f.capture)}(t,r||{},Ei,Ni,Li,e),Fi=void 0}function Mi(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Ri(e,t){we();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)Ke(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),xe()}var Di=Date.now;if(ne&&!se){var Ui=window.performance;Ui&&"function"==typeof Ui.now&&Di()>document.createEvent("Event").timeStamp&&(Di=function(){return Ui.now()})}function zi(e,t,n,i,a){var s,c=this,u=a.options;g(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=o(u._compiled),f=!l;this.data=e,this.props=t,this.children=n,this.parent=i,this.listeners=e.on||r,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=ve?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&g(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||ki(e.scopedSlots,c.$slots=Ai(n,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ki(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ki(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=li(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return li(s,e,t,r,n,f)}}function Bi(e,t,r,n,i){var o=function(e){var t=new Z(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function qi(e,t){for(var r in t)e[w(r)]=t[r]}!function(e){e._o=gi,e._n=p,e._s=f,e._l=fi,e._t=pi,e._q=F,e._i=j,e._m=yi,e._f=di,e._k=hi,e._b=mi,e._v=Q,e._e=G,e._u=xi,e._g=wi,e._d=Si,e._p=$i}(zi.prototype);var Ji={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ji.prepatch(r,r)}else{(e.componentInstance=Vi(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var n=t.componentOptions;!function(e,t,n,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==r&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||r,e.$listeners=n||r,t&&e.$options.props){ke(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Ue(d,v,t,e)}ke(!0),e.$options.propsData=t}n=n||r;var h=e.$options._parentListeners;e.$options._parentListeners=n,Ii(e,n,h),u&&(e.$slots=Ai(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Ri(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,Mi(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Ri(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,Mi(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Ri(t,"deactivated")}}(t,!0):t.$destroy())}},Hi=Object.keys(Ji);function Ki(e,t,a,c,u){if(!n(e)){var f=a.$options._base;if(s(e)&&(e=f.extend(e)),"function"==typeof e){var p;if(n(e.cid)&&void 0===(e=function(e,t){if(o(e.error)&&i(e.errorComp))return e.errorComp;if(i(e.resolved))return e.resolved;var r=ji;if(r&&i(e.owners)&&-1===e.owners.indexOf(r)&&e.owners.push(r),o(e.loading)&&i(e.loadingComp))return e.loadingComp;if(r&&!i(e.owners)){var a=e.owners=[r],c=!0,u=null,f=null;r.$on("hook:destroyed",function(){return m(a,r)});var p=function(e){for(var t=0,r=a.length;t<r;t++)a[t].$forceUpdate();e&&(a.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=P(function(r){e.resolved=Pi(r,t),c?a.length=0:p(!0)}),v=P(function(t){i(e.errorComp)&&(e.error=!0,p(!0))}),h=e(d,v);return s(h)&&(l(h)?n(e.resolved)&&h.then(d,v):l(h.component)&&(h.component.then(d,v),i(h.error)&&(e.errorComp=Pi(h.error,t)),i(h.loading)&&(e.loadingComp=Pi(h.loading,t),0===h.delay?e.loading=!0:u=setTimeout(function(){u=null,n(e.resolved)&&n(e.error)&&(e.loading=!0,p(!1))},h.delay||200)),i(h.timeout)&&(f=setTimeout(function(){f=null,n(e.resolved)&&v(null)},h.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=e,f)))return function(e,t,r,n,i){var o=G();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(p,t,a,c,u);t=t||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&A(t.extendOptions,i),(r=t.options=Re(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),i(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[n],s=t.model.callback;i(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[n]=[s].concat(a)):o[n]=s}(e.options,t);var d=function(e,t,r){var o=t.options.props;if(!n(o)){var a={},s=e.attrs,c=e.props;if(i(s)||i(c))for(var u in o){var l=$(u);si(a,c,u,l,!0)||si(a,s,u,l,!1)}return a}}(t,e);if(o(e.options.functional))return function(e,t,n,o,a){var s=e.options,c={},u=s.props;if(i(u))for(var l in u)c[l]=Ue(l,u,t||r);else i(n.attrs)&&qi(c,n.attrs),i(n.props)&&qi(c,n.props);var f=new zi(n,c,a,o,e),p=s.render.call(null,f._c,f);if(p instanceof Z)return Bi(p,n,f.parent,s);if(Array.isArray(p)){for(var d=Yn(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Bi(d[h],n,f.parent,s);return v}}(e,d,t,a,c);var v=t.on;if(t.on=t.nativeOn,o(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Hi.length;r++){var n=Hi[r],i=t[n],o=Ji[n];i===o||i&&i._merged||(t[n]=i?Wi(o,i):o)}}(t);var y=e.options.name||u;return new Z("vue-component-"+e.cid+(y?"-"+y:""),t,void 0,void 0,void 0,a,{Ctor:e,propsData:d,listeners:v,tag:u,children:c},p)}}}function Vi(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return i(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function Wi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var Zi=Object.create(null),Xi=function(e){Zi[e]||(Zi[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},Gi=function(e,t){var r=t?(void 0)(t):"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},Qi=function(e){var t=e.$options,r=t.render,i=t.template,o=t._scopeId;if(n(r)){if(!i)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=Gn(i,{scopeId:o,warn:Gi},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function Yi(e,t,r){var n=e.$options.serverPrefetch;if(i(n)){Array.isArray(n)||(n=[n]);try{for(var o=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&o.push(c)}return void Promise.all(o).then(t).catch(r)}catch(e){r(e)}}t()}function eo(e,t,r){e.isString?function(e,t){var r=t.write,i=t.next;if(n(e.children)||0===e.children.length)r(e.open+(e.close||""),i);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,i)}}(e,r):i(e.componentOptions)?ro(e,t,r):i(e.tag)?function(e,t,r){var a=r.write,s=r.next;o(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[he]="true");e.fnOptions&&to(e.fnOptions,a);var c=function(e,t){var r,o="<"+e.tag,a=t.directives,s=t.modules;n(e.data)&&function e(t){var r=t.parent;return i(r)&&(i(r.data)||e(r))}(e)&&(e.data={});if(i(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=De(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;i(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var d=0;d<s.length;d++){var v=s[d](e);v&&(o+=v)}}var h=t.activeInstance;i(h)&&h!==e.context&&i(r=h.$options._scopeId)&&(o+=" "+r);if(i(e.fnScopeId))o+=" "+e.fnScopeId;else for(;i(e);)i(r=e.context.$options._scopeId)&&(o+=" "+r),e=e.parent;return o+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))a(c,s);else if(n(e.children)||0===e.children.length)a(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),a(c,s)}}(e,t,r):o(e.isComment)?i(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=Ki(n,o,c,a,s);u?u.componentOptions?ro(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):eo(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:D(String(e.text)),r.next)}function to(e,t){var r=e._ssrRegister;return t.caching&&i(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function ro(e,t,r){var o=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=to(c.options,o);if(i(u)&&i(f)&&i(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void io(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;i(h)?h(v,function(n){!0===n&&i(m)?m(v,function(e){i(p)&&p(s),e.components.forEach(function(e){return e(s)}),o(e.html,a)}):no(e,t,v,r)}):i(m)&&m(v,function(n){i(n)?(i(p)&&p(s),n.components.forEach(function(e){return e(s)}),o(n.html,a)):no(e,t,v,r)})}else i(u)&&n(f)&&Xi("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),i(u)&&n(l)&&Xi('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),io(e,t,r)}function no(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),io(e,t,n)}function io(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Vi(e,r.activeInstance);Qi(i);var o=r.done;Yi(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),eo(o,t,r)},o)}function oo(e,t,r,n){return function(i,o,a,s){Zi=Object.create(null);var c=new _t({activeInstance:i,userContext:a,write:o,done:s,renderNode:eo,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;A(t.prototype,ti),t.FunctionalRenderContext&&A(t.FunctionalRenderContext.prototype,ti)}}(i),Qi(i);Yi(i,function(){eo(i._render(),!0,c)},s)}}var ao=function(e){return/\.js(\?[^.]+)?$/.test(e)};function so(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var co=function(e){function t(t,r,n){e.call(this),this.started=!1,this.renderer=t,this.template=r,this.context=n||{},this.inject=t.inject}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),uo=require("lodash.template"),lo={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function fo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var po=require("path"),vo=require("serialize-javascript"),ho=function(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:uo(e.slice(0,r),lo),neck:uo(e.slice(r,n),lo),tail:uo(e.slice(n+t.length),lo)}}(t):t:null,this.serialize=e.serializer||function(e){return vo(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(mo),this.prefetchFiles=(r.async||[]).map(mo),this.mapFiles=fo(r)}};function mo(e){var t=e.replace(/\?.*/,""),r=po.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:yo(r)}}function yo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}ho.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},ho.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},ho.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},ho.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},ho.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},ho.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},ho.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},ho.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey;void 0===n&&(n="state");var i=r.windowKey;void 0===i&&(i="__INITIAL_STATE__");var o=this.serialize(e[n]),a=e.nonce?' nonce="'+e.nonce+'"':"";return e[n]?"<script"+a+">window."+i+"="+o+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},ho.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return ao(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return ao(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},ho.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(mo)}return e._mappedFiles},ho.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new co(this,this.parsedTemplate,e||{})};var go=require("vm"),bo=require("path"),_o=require("resolve"),wo=require("module");function xo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function So(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=wo.wrap(r),o=new go.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=bo.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=_o.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function $o(e,t,r,n){var i,o,a=So(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,xo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?xo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(u(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))})}}var Ao=require("source-map").SourceMapConsumer,Oo=/\(([^)]+\.js):(\d+):(\d+)\)$/;function ko(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(Oo),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(Oo,c)}return e}return e}(e,t)}).join("\n"))}var Co=require("fs"),To=require("path"),Fo=require("stream").PassThrough,jo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Po(e){return void 0===e&&(e={}),function(e){void 0===e&&(e={});var t=e.modules;void 0===t&&(t=[]);var r=e.directives;void 0===r&&(r={});var n=e.isUnaryTag;void 0===n&&(n=function(){return!1});var i=e.template,o=e.inject,a=e.cache,s=e.shouldPreload,c=e.shouldPrefetch,u=e.clientManifest,l=e.serializer,f=oo(t,r,n,a),p=new ho({template:i,inject:o,shouldPreload:s,shouldPrefetch:c,clientManifest:u,serializer:l});return{renderToString:function(e,t,r){var n,o;"function"==typeof t&&(r=t,t={}),t&&p.bindRenderFns(t),r||(o=(n=so()).promise,r=n.cb);var a="",s=gt(function(e){return a+=e,!1},r);try{f(e,s,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),i)try{var n=p.render(a,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,a)})}catch(e){r(e)}return o},renderToStream:function(e,t){t&&p.bindRenderFns(t);var r=new bt(function(r,n){f(e,r,t,n)});if(i){if("function"==typeof i)throw new Error("function template is only supported in renderToString.");var n=p.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return n}if(t&&t.rendered){var a=t.rendered;r.once("beforeEnd",function(){a(t)})}return r}}}(A(A({},e),{isUnaryTag:pt,canBeLeftOpenTag:dt,modules:ct,directives:A(ft,e.directives)}))}process.env.VUE_ENV="server";var Eo=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&To.isAbsolute(t)){if(!Co.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||To.dirname(t),t=Co.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new Ao(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(jo)}else{if("string"!=typeof t)throw new Error(jo);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=$o(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=so()).promise,t=r.cb),u(e).catch(function(e){ko(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){ko(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new Fo;return u(e).catch(function(e){ko(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){ko(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(Po);exports.createRenderer=Po,exports.createBundleRenderer=Eo;
\ No newline at end of file
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream"),t=Object.freeze({});function r(e){return null==e}function n(e){return null!=e}function i(e){return!0===e}function o(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var s=Object.prototype.toString;function c(e){return"[object Object]"===s.call(e)}function u(e){return null==e?"":Array.isArray(e)||c(e)&&e.toString===s?JSON.stringify(e,null,2):String(e)}function l(e){var t=parseFloat(e);return isNaN(t)?e:t}function f(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var p=f("slot,component",!0),d=f("key,ref,slot,slot-scope,is");var v=Object.prototype.hasOwnProperty;function h(e,t){return v.call(e,t)}function m(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var y=/-(\w)/g,g=m(function(e){return e.replace(y,function(e,t){return t?t.toUpperCase():""})}),b=m(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),_=/\B([A-Z])/g,w=m(function(e){return e.replace(_,"-$1").toLowerCase()});function x(e,t){for(var r in t)e[r]=t[r];return e}function S(e){for(var t={},r=0;r<e.length;r++)e[r]&&x(t,e[r]);return t}function $(e,t,r){}var A=function(e,t,r){return!1},k=function(e){return e};function O(e,t){if(e===t)return!0;var r=a(e),n=a(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return O(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(r){return O(e[r],t[r])})}catch(e){return!1}}function C(e,t){for(var r=0;r<e.length;r++)if(O(e[r],t))return r;return-1}var T=f("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),F=/[>/="'\u0009\u000a\u000c\u0020]/,j=function(e){return F.test(e)},P=function(e){return T(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},E={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},N={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function I(e){return e.replace(/[<>"&]/g,L)}function L(e){return N[e]||e}var M={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},R=f("input,textarea,option,select,progress"),D=f("contenteditable,draggable,spellcheck"),z=f("events,caret,typing,plaintext-only"),U=function(e,t){return q(t)||"false"===t?"false":"contenteditable"===e&&z(t)?t:"true"},B=f("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),q=function(e){return null==e||!1===e};function J(e,t){if(B(e)){if(!q(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+I(U(e,t))+'"';if(!q(t))return" "+e+'="'+I(String(t))+'"'}return""}var H=function(){function e(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),K=function(e){void 0===e&&(e="");var t=new H;return t.text=e,t.isComment=!0,t};function V(e){return new H(void 0,void 0,void 0,String(e))}function W(e,t,r){var n=new H(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function Z(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var X="__proto__"in{},G="undefined"!=typeof window,Q="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,Y=(Q&&WXEnvironment.platform.toLowerCase(),G&&window.navigator.userAgent.toLowerCase()),ee=Y&&/msie|trident/.test(Y);Y&&Y.indexOf("msie 9.0");Y&&Y.indexOf("edge/");Y&&Y.indexOf("android"),Y&&/iphone|ipad|ipod|ios/.test(Y),Y&&/chrome\/\d+/.test(Y),Y&&/phantomjs/.test(Y),Y&&Y.match(/firefox\/(\d+)/);var te,re={}.watch;if(G)try{var ne={};Object.defineProperty(ne,"passive",{get:function(){!0}}),window.addEventListener("test-passive",null,ne)}catch(e){}var ie=function(){return void 0===te&&(te=!G&&!Q&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),te};function oe(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,se="undefined"!=typeof Symbol&&oe(Symbol)&&"undefined"!=typeof Reflect&&oe(Reflect.ownKeys);ae="undefined"!=typeof Set&&oe(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ce="data-server-rendered",ue=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],le={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:A,isReservedAttr:A,isUnknownElement:A,getTagNamespace:$,parsePlatformTagName:k,mustUseProp:A,async:!0,_lifecycleHooks:ue},fe=0,pe=function(){function e(){this.id=fe++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){!function(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)e.splice(r,1)}}(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},e}();pe.target=null;var de=[];function ve(e){de.push(e),pe.target=e}function he(){de.pop(),pe.target=de[de.length-1]}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];Z(ye,e,function(){for(var r=arguments,n=[],i=0;i<arguments.length;i++)n[i]=r[i];var o,a=t.apply(this,n),s=this.__ob__;switch(e){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),be=!0;function _e(e){be=e}var we=function(){function e(e){var t;this.value=e,this.dep=new pe,this.vmCount=0,Z(e,"__ob__",this),Array.isArray(e)?(X?(t=ye,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];Z(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Se(e,t[r])},e.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)xe(e[t])},e}();function xe(e,t){var r;if(a(e)&&!(e instanceof H))return h(e,"__ob__")&&e.__ob__ instanceof we?r=e.__ob__:be&&!ie()&&(Array.isArray(e)||c(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new we(e)),t&&r&&r.vmCount++,r}function Se(e,t,r,n,i){var o=new pe,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&xe(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return pe.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&xe(t),o.notify())}})}}function $e(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Se(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}var Ae=le.optionMergeStrategies;function ke(e,t){if(!t)return e;for(var r,n,i,o=se?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],h(e,r)?n!==i&&c(n)&&c(i)&&ke(n,i):$e(e,r,i));return e}function Oe(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?ke(n,i):i}:t?e?function(){return ke("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ce(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Te(e,t,r,n){var i=Object.create(e||null);return t?x(i,t):i}Ae.data=function(e,t,r){return r?Oe(e,t,r):t&&"function"!=typeof t?e:Oe(e,t)},ue.forEach(function(e){Ae[e]=Ce}),["component","directive","filter"].forEach(function(e){Ae[e+"s"]=Te}),Ae.watch=function(e,t,r,n){if(e===re&&(e=void 0),t===re&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in x(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return x(i,e),t&&x(i,t),i},Ae.provide=Oe;var Fe=function(e,t){return void 0===t?e:t};function je(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[g(i)]={type:null});else if(c(r))for(var a in r)i=r[a],o[g(a)]=c(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(c(r))for(var o in r){var a=r[o];n[o]=c(a)?x({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=je(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)h(e,o)||s(o);function s(n){var i=Ae[n]||Fe;a[n]=i(e[n],t[n],r,n)}return a}function Pe(e,t,r,n){if("string"==typeof r){var i=e[t];if(h(i,r))return i[r];var o=g(r);if(h(i,o))return i[o];var a=b(o);return h(i,a)?i[a]:i[r]||i[o]||i[a]}}function Ee(e,t,r,n){var i=t[e],o=!h(r,e),a=r[e],s=Me(Boolean,i.type);if(s>-1)if(o&&!h(i,"default"))a=!1;else if(""===a||a===w(e)){var c=Me(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!h(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Ie(t.type)?n.call(e):n}(n,i,e);var u=be;_e(!0),xe(a),_e(u)}return a}var Ne=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Ne);return t?t[1]:""}function Le(e,t){return Ie(e)===Ie(t)}function Me(e,t){if(!Array.isArray(t))return Le(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(Le(t[r],e))return r;return-1}function Re(e,t,r){ve();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){ze(e,n,"errorCaptured hook")}}ze(e,t,r)}finally{he()}}function De(e,t,r,i,o){var a,s;try{(a=r?e.apply(t,r):e.call(t))&&!a._isVue&&(n(s=a)&&"function"==typeof s.then&&"function"==typeof s.catch)&&!a._handled&&(a.catch(function(e){return Re(e,i,o+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,i,o)}return a}function ze(e,t,r){!function(e,t,r){if(!G&&!Q||"undefined"==typeof console)throw e;console.error(e)}(e)}var Ue=[];if("undefined"!=typeof Promise&&oe(Promise));else if(ee||"undefined"==typeof MutationObserver||!oe(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&oe(setImmediate);else{var Be=new MutationObserver(function(){var e=Ue.slice(0);Ue.length=0;for(var t=0;t<e.length;t++)e[t]()}),qe=document.createTextNode(String(1));Be.observe(qe,{characterData:!0})}function Je(e,t){return{staticClass:Ke(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function He(e,t){return n(e)||n(t)?Ke(e,Ve(t)):""}function Ke(e,t){return e?t?e+" "+t:e:t||""}function Ve(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Ve(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var We=f("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ze=f("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var Xe=m(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function Ge(e){var t=Qe(e.style);return e.staticStyle?x(e.staticStyle,t):t}function Qe(e){return Array.isArray(e)?S(e):"string"==typeof e?Xe(e):e}function Ye(e){var t="";for(var r in e){var n=e[r],i=w(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=et(i,n[o]);else t+=et(i,n)}return t}function et(e,t){return"string"==typeof t||"number"==typeof t&&M[e]||0===t?e+":"+t+";":""}var tt=[function(e){var t=e.data.attrs,i="",o=e.parent&&e.parent.componentOptions;if(r(o)||!1!==o.Ctor.options.inheritAttrs)for(var a=e.parent;n(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)n(a.data)&&n(a.data.attrs)&&(t=x(x({},t),a.data.attrs)),a=a.parent;if(r(t))return i;for(var s in t)j(s)||"style"!==s&&(i+=J(s,t[s]));return i},function(e){for(var t=e.data.domProps,i="",o=e.parent;n(o);)o.data&&o.data.domProps&&(t=x(x({},t),o.data.domProps)),o=o.parent;if(r(t))return i;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)W(e,t[s],!0);else if("textContent"===s)W(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)W(e,u(t[s]),!1);else{var c=E[s]||s.toLowerCase();!P(c)||n(a)&&n(a[c])||(i+=J(c,t[s]))}return i},function(e){var t=function(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Je(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Je(t,r.data));return He(t.staticClass,t.class)}(e);if(""!==t)return' class="'+I(t)+'"'},function(e){var t=Ye(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=Ge(i.data))&&x(n,r);(r=Ge(e.data))&&x(n,r);for(var o=e;o=o.parent;)o.data&&(r=Ge(o.data))&&x(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(I(t))}];function rt(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function nt(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var it={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&C(r,rt(a))>-1&&nt(a);else if(O(r,rt(a)))return void nt(a)}}},ot=f("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),at=f("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),st=f("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ct=function(e,t){return(ct=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(e[r]=t[r])})(e,t)};function ut(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function r(){this.constructor=e}ct(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}var lt=800,ft=function(e){return e},pt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:ft;if(pt===ft)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function dt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=lt?pt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var vt=function(e){function t(t){var r=e.call(this)||this;return r.buffer="",r.render=t,r.expectedSize=0,r.write=dt(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),r.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)},r}return ut(t,e),t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,i(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):r(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),ht=function(){function e(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&mt(t,"get"),this.has=t&&mt(t,"has"),this.next=this.next.bind(this)}return e.prototype.next=function(){for(var e=function(){var e=t.renderStates[t.renderStates.length-1];if(r(e))return{value:t.done()};switch(e.type){case"Element":case"Fragment":var n=e.children,i=e.total,o=e.rendered++;if(o<i)return{value:t.renderNode(n[o],!1,t)};if(t.renderStates.pop(),"Element"===e.type)return{value:t.write(e.endTag,t.next)};break;case"Component":t.renderStates.pop(),t.activeInstance=e.prevActive;break;case"ComponentWithCache":t.renderStates.pop();var a=e.buffer,s=e.bufferIndex,c=e.componentBuffer,u=e.key,l={html:a[s],components:c[s]};if(t.cache.set(u,l),0===s)t.write.caching=!1;else{a[s-1]+=l.html;var f=c[s-1];l.components.forEach(function(e){return f.add(e)})}a.length=s,c.length=s}},t=this;;){var n=e();if("object"==typeof n)return n.value}},e}();function mt(e,t){var n=e[t];return r(n)?void 0:n.length>1?function(t,r){return n.call(e,t,r)}:function(t,r){return r(n.call(e,t))}}var yt=/[\w).+\-_$\]]/;function gt(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&yt.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=bt(i,o[n]);return i}function bt(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var _t=/\{\{((?:.|\r?\n)+?)\}\}/g,wt=/[-.*+?^${}()|[\]\/\\]/g,xt=m(function(e){var t=e[0].replace(wt,"\\$&"),r=e[1].replace(wt,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function St(e,t){console.error("[Vue compiler]: "+e)}function $t(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function At(e,t,r,n,i){(e.props||(e.props=[])).push(Nt({name:t,value:r,dynamic:i},n)),e.plain=!1}function kt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Nt({name:t,value:r,dynamic:i},n)),e.plain=!1}function Ot(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Nt({name:t,value:r},n))}function Ct(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Nt({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Tt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Ft(e,r,n,i,o,a,s,c){var u;(i=i||t).right?c?r="("+r+")==='click'?'contextmenu':("+r+")":"click"===r&&(r="contextmenu",delete i.right):i.middle&&(c?r="("+r+")==='click'?'mouseup':("+r+")":"click"===r&&(r="mouseup")),i.capture&&(delete i.capture,r=Tt("!",r,c)),i.once&&(delete i.once,r=Tt("~",r,c)),i.passive&&(delete i.passive,r=Tt("&",r,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Nt({value:n.trim(),dynamic:c},s);i!==t&&(l.modifiers=i);var f=u[r];Array.isArray(f)?o?f.unshift(l):f.push(l):u[r]=f?o?[l,f]:[f,l]:l,e.plain=!1}function jt(e,t,r){var n=Pt(e,":"+t)||Pt(e,"v-bind:"+t);if(null!=n)return gt(n);if(!1!==r){var i=Pt(e,t);if(null!=i)return JSON.stringify(i)}}function Pt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Et(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Nt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var It={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Pt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=jt(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Lt,Mt,Rt,Dt,zt,Ut,Bt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Pt(e,"style");r&&(e.staticStyle=JSON.stringify(Xe(r)));var n=jt(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},qt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Jt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ht="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Kt="((?:"+Ht+"\\:)?"+Ht+")",Vt=new RegExp("^<"+Kt),Wt=/^\s*(\/?)>/,Zt=new RegExp("^<\\/"+Kt+"[^>]*>"),Xt=/^<!DOCTYPE [^>]+>/i,Gt=/^<!\--/,Qt=/^<!\[/,Yt=f("script,style,textarea",!0),er={},tr={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},rr=/&(?:lt|gt|quot|amp|#39);/g,nr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,ir=f("pre,textarea",!0),or=function(e,t){return e&&ir(e)&&"\n"===t[0]};function ar(e,t){var r=t?nr:rr;return e.replace(r,function(e){return tr[e]})}function sr(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||A,s=t.canBeLeftOpenTag||A,c=0,u=function(){if(r=e,n&&Yt(n)){var u=0,p=n.toLowerCase(),d=er[p]||(er[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));x=e.replace(d,function(e,r,n){return u=n.length,Yt(p)||"noscript"===p||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),or(p,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-x.length,e=x,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(Gt.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(Qt.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(Xt);if(y)return l(y[0].length),"continue";var g=e.match(Zt);if(g){var b=c;return l(g[0].length),f(g[1],b,c),"continue"}var _=function(){var t=e.match(Vt);if(t){var r={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var n=void 0,i=void 0;!(n=e.match(Wt))&&(i=e.match(Jt)||e.match(qt));)i.start=c,l(i[0].length),i.end=c,r.attrs.push(i);if(n)return r.unarySlash=n[1],l(n[0].length),r.end=c,r}}();if(_)return function(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&st(r)&&f(n),s(r)&&n===r&&f(r));for(var u=a(r)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===r&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:ar(h,m)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=r);t.start&&t.start(r,p,u,e.start,e.end)}(_),or(_.tagName,e)&&l(1),"continue"}var w=void 0,x=void 0,S=void 0;if(v>=0){for(x=e.slice(v);!(Zt.test(x)||Vt.test(x)||Gt.test(x)||Qt.test(x)||(S=x.indexOf("<",1))<0);)v+=S,x=e.slice(v);w=e.substring(0,v)}v<0&&(w=e),w&&l(w.length),t.chars&&w&&t.chars(w,c-w.length,c)}if(e===r)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}f()}function cr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=ur(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function ur(e,t){var r=function(e){if(e=e.trim(),Lt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Lt-1)return(Dt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Dt),key:'"'+e.slice(Dt+1)+'"'}:{exp:e,key:null};Mt=e,Dt=zt=Ut=0;for(;!fr();)pr(Rt=lr())?vr(Rt):91===Rt&&dr(Rt);return{exp:e.slice(0,zt),key:e.slice(zt+1,Ut)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function lr(){return Mt.charCodeAt(++Dt)}function fr(){return Dt>=Lt}function pr(e){return 34===e||39===e}function dr(e){var t=1;for(zt=Dt;!fr();)if(pr(e=lr()))vr(e);else if(91===e&&t++,93===e&&t--,0===t){Ut=Dt;break}}function vr(e){for(var t=e;!fr()&&(e=lr())!==t;);}var hr,mr,yr,gr,br,_r,wr,xr,Sr=require("he"),$r=/^@|^v-on:/,Ar=/^v-|^@|^:|^#/,kr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Or=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Cr=/^\(|\)$/g,Tr=/^\[.*\]$/,Fr=/:(.*)$/,jr=/^:|^\.|^v-bind:/,Pr=/\.[^.\]]+(?=[^\]]*$)/g,Er=/^v-slot(:|$)|^#/,Nr=/[\r\n]/,Ir=/[ \f\t\r\n]+/g,Lr=m(Sr.decode),Mr="_empty_";function Rr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Hr(t),rawAttrsMap:{},parent:r,children:[]}}function Dr(e,t){hr=t.warn||St,_r=t.isPreTag||A,wr=t.mustUseProp||A,xr=t.getTagNamespace||A,t.isReservedTag,yr=$t(t.modules,"transformNode"),gr=$t(t.modules,"preTransformNode"),br=$t(t.modules,"postTransformNode"),mr=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=zr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Br(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Br(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),_r(e.tag)&&(c=!1);for(var f=0;f<br.length;f++)br[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return sr(e,{warn:hr,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||xr(e);ee&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Kr.test(n.name)||(n.name=n.name.replace(Vr,""),t.push(n))}return t}(o));var d,v=Rr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||ie()||(v.forbidden=!0);for(var h=0;h<gr.length;h++)v=gr[h](v,t)||v;s||(!function(e){null!=Pt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),_r(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Ur(v),function(e){var t=Pt(e,"v-if");if(t)e.if=t,Br(e,{exp:t,block:e});else{null!=Pt(e,"v-else")&&(e.else=!0);var r=Pt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Pt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!ee||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Lr(e):u.length?a?"condense"===a&&Nr.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(Ir," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var r=t?xt(t):_t;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=gt(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,mr))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function zr(e,t){var r,n;(n=jt(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jt(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Pt(e,"scope"),e.slotScope=t||Pt(e,"slot-scope")):(t=Pt(e,"slot-scope"))&&(e.slotScope=t);var r=jt(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||kt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Et(e,Er);if(n){var i=qr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Mr}}else{var n=Et(e,Er);if(n){var s=e.scopedSlots||(e.scopedSlots={}),c=qr(n),u=c.name,a=c.dynamic,l=s[u]=Rr("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=n.value||Mr,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jt(e,"name"))}(e),function(e){var t;(t=jt(e,"is"))&&(e.component=t);null!=Pt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<yr.length;i++)e=yr[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Ar.test(n))if(e.hasBindings=!0,(a=Jr(n.replace(Ar,"")))&&(n=n.replace(Pr,"")),jr.test(n))n=n.replace(jr,""),o=gt(o),(c=Tr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=g(n))&&(n="innerHTML"),a.camel&&!c&&(n=g(n)),a.sync&&(s=ur(o,"$event"),c?Ft(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Ft(e,"update:"+g(n),s,null,!1,0,u[t]),w(n)!==g(n)&&Ft(e,"update:"+w(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&wr(e.tag,e.attrsMap.type,n)?At(e,n,o,u[t],c):kt(e,n,o,u[t],c);else if($r.test(n))n=n.replace($r,""),(c=Tr.test(n))&&(n=n.slice(1,-1)),Ft(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Ar,"")).match(Fr),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Tr.test(f)&&(f=f.slice(1,-1),c=!0)),Ct(e,n,i,o,f,c,a,u[t])}else kt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&wr(e.tag,e.attrsMap.type,n)&&At(e,n,"true",u[t])}(e),e}function Ur(e){var t;if(t=Pt(e,"v-for")){var r=function(e){var t=e.match(kr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(Cr,""),i=n.match(Or);i?(r.alias=n.replace(Or,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&x(e,r)}}function Br(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function qr(e){var t=e.name.replace(Er,"");return t||"#"!==e.name[0]&&(t="default"),Tr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Jr(e){var t=e.match(Pr);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function Hr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Kr=/^xmlns:NS\d+/,Vr=/^NS\d+:/;function Wr(e){return Rr(e.tag,e.attrsList.slice(),e.parent)}var Zr=[It,Bt,{preTransformNode:function(e,t){if("input"===e.tag){var r=e.attrsMap;if(!r["v-model"])return;var n=void 0;if((r[":type"]||r["v-bind:type"])&&(n=jt(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Pt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Pt(e,"v-else",!0),s=Pt(e,"v-else-if",!0),c=Wr(e);Ur(c),Ot(c,"type","checkbox"),zr(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,Br(c,{exp:c.if,block:c});var u=Wr(e);Pt(u,"v-for",!0),Ot(u,"type","radio"),zr(u,t),Br(c,{exp:"("+n+")==='radio'"+o,block:u});var l=Wr(e);return Pt(l,"v-for",!0),Ot(l,":type",n),zr(l,t),Br(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],Xr="__r";var Gr={expectHTML:!0,modules:Zr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return cr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+ur(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Ft(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=jt(e,"value")||"null",o=jt(e,"true-value")||"true",a=jt(e,"false-value")||"false";At(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Ft(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+ur(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+ur(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+ur(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=jt(e,"value")||"null";At(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Ft(e,"change",ur(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return cr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Xr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=ur(t,l);c&&(f="if($event.target.composing)return;"+f),At(e,"value","("+t+")"),Ft(e,u,f,null,!0),(s||a)&&Ft(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&At(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&At(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:ot,mustUseProp:function(e,t,r){return"value"===r&&R(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:at,isReservedTag:function(e){return We(e)||Ze(e)},getTagNamespace:function(e){return Ze(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Zr)},Qr=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Yr=/\([^)]*?\);*$/,en=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,tn={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},rn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},nn=function(e){return"if("+e+")return null;"},on={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:nn("$event.target !== $event.currentTarget"),ctrl:nn("!$event.ctrlKey"),shift:nn("!$event.shiftKey"),alt:nn("!$event.altKey"),meta:nn("!$event.metaKey"),left:nn("'button' in $event && $event.button !== 0"),middle:nn("'button' in $event && $event.button !== 1"),right:nn("'button' in $event && $event.button !== 2")};function an(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=sn(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function sn(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return sn(e)}).join(",")+"]";var t=en.test(e.value),r=Qr.test(e.value),n=en.test(e.value.replace(Yr,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(on[t])o+=on[t],tn[t]&&a.push(t);else if("exact"===t){var r=e.modifiers;o+=nn(["ctrl","shift","alt","meta"].filter(function(e){return!r[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(cn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function cn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=tn[e],n=rn[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var un={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:$},ln=function(){return function(e){this.options=e,this.warn=e.warn||St,this.transforms=$t(e.modules,"transformCode"),this.dataGenFns=$t(e.modules,"genData"),this.directives=x(x({},un),e.directives);var t=e.isReservedTag||A;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function fn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return pn(e,t);if(e.once&&!e.onceProcessed)return dn(e,t);if(e.for&&!e.forProcessed)return hn(e,t);if(e.if&&!e.ifProcessed)return vn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=bn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Sn((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:g(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r=void 0;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:bn(t,r,!0);return"_c("+e+","+mn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=mn(e,t));var i=e.inlineTemplate?null:bn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return bn(e,t)||"void 0"}function pn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+fn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function dn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return vn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+fn(e,t)+","+t.onceId+++","+r+")":fn(e,t)}return pn(e,t)}function vn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?dn(e,r):fn(e,r)}}(e.ifConditions.slice(),t,r,n)}function hn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||fn)(e,t)+"})"}function mn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+Sn(e.attrs)+","),e.props&&(r+="domProps:"+Sn(e.props)+","),e.events&&(r+=an(e.events,!1)+","),e.nativeEvents&&(r+=an(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||yn(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Mr||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return gn(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new ln(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":fn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+Sn(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function yn(e){return 1===e.type&&("slot"===e.tag||e.children.some(yn))}function gn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return vn(e,t,gn,"null");if(e.for&&!e.forProcessed)return hn(e,t,gn);var n=e.slotScope===Mr?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(bn(e,t)||"undefined")+":undefined":bn(e,t)||"undefined":fn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function bn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||fn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(_n(i)||i.ifConditions&&i.ifConditions.some(function(e){return _n(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||wn;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function _n(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function wn(e,t){return 1===e.type?fn(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):xn(e);var r}function xn(e){return"_v("+(2===e.type?e.expression:$n(JSON.stringify(e.text)))+")"}function Sn(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=$n(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function $n(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var An=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function kn(e,t){return An.test(t)?(t=t.replace(/^'|'$/g,'"'),D(e)&&'"false"'!==t&&(t='"true"'),{type:jn,value:B(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:En,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var On,Cn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Tn(e,t){e&&(On=t.isReservedTag||A,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return p(e.tag)||!On(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=Cn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!Fn(e.name)})}(t);var i=function(e){e.ssrOptimizability!==Cn.FULL&&(t.ssrOptimizability=n?Cn.PARTIAL:Cn.SELF)};n&&(t.ssrOptimizability=Cn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++){var c=t.ifConditions[o].block;e(c,r),i(c)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=Cn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:Cn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===Cn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=Cn.FULL}(e,!0))}var Fn=f("text,html,show,on,bind,model,pre,cloak,once");var jn=0,Pn=1,En=2;function Nn(e,t){if(e.for&&!e.forProcessed)return hn(e,t,Nn);if(e.if&&!e.ifProcessed)return vn(e,t,Nn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===Cn.FULL?Rn(e,t):Ln(e,t)||"void 0";switch(e.ssrOptimizability){case Cn.FULL:return function(e,t){return"_ssrNode("+Dn(e,t)+")"}(e,t);case Cn.SELF:return function(e,t){var r=Ln(e,t,!0);return"_ssrNode("+qn(Un(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case Cn.CHILDREN:return In(e,t,!0);case Cn.PARTIAL:return In(e,t,!1);default:return fn(e,t)}}function In(e,t,r){var n=e.plain?void 0:mn(e,t),i=r?"["+Rn(e,t)+"]":Ln(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Ln(e,t,r){return bn(e,t,r,Nn,Mn)}function Mn(e,t){return 1===e.type?Nn(e,t):xn(e)}function Rn(e,t){return e.children.length?"_ssrNode("+qn(Bn(e,t))+")":""}function Dn(e,t){return"("+qn(zn(e,t))+")"}function zn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:En,value:hn(e,t,Dn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:En,value:vn(e,t,Dn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Bn(e,t);var r=Un(e,t),n=Bn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:jn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Un(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:jn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return kn(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=E[n]||n.toLowerCase(),!P(n)||t&&t.some(function(e){return e.name===n})||r.push(kn(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:En,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:En,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:jn,value:' class="'+JSON.parse(n)+'"'}]:[{type:En,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:En,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:jn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:jn,value:" "+t.options.scopeId}),u.push({type:jn,value:">"}),u}function Bn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:En,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Pn,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Pn,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,zn(i,t));else if(2===i.type)r.push({type:Pn,value:i.expression});else if(3===i.type){var o=I(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:jn,value:o})}}return r}(e.children,t):[]}function qn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===jn?r+=o.value:o.type===Pn?(n(),t.push("_ssrEscape("+o.value+")")):o.type===En&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}function Jn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),$}}function Hn(e){var t=Object.create(null);return function(r,n,i){(n=x({},n)).warn,delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Jn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Jn(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var Kn,Vn=(Kn=function(e,t){var r=Dr(e.trim(),t);Tn(r,t);var n=function(e,t){var r=new ln(t);return{render:"with(this){return "+(e?Nn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=x(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=Kn(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Hn(t)}})(Gr).compileToFunctions;function Wn(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Zn(e){return o(e)?[V(e)]:Array.isArray(e)?function e(t,a){var s=[];var c,u,l,f;for(c=0;c<t.length;c++)r(u=t[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(Xn((u=e(u,(a||"")+"_"+c))[0])&&Xn(f)&&(s[l]=V(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?Xn(f)?s[l]=V(f.text+u):""!==u&&s.push(V(u)):Xn(u)&&Xn(f)?s[l]=V(f.text+u.text):(i(t._isVList)&&n(u.tag)&&r(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function Xn(e){return n(e)&&n(e.text)&&!1===e.isComment}var Gn={_ssrEscape:I,_ssrNode:function(e,t,r,n){return new Qn(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,s="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)s+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)s+=t(r+1,r);else if(a(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],s+=t(e[o],o,r);return s},_ssrAttr:J,_ssrAttrs:function(e){var t="";for(var r in e)j(r)||(t+=J(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=E[r]||r.toLowerCase();P(n)&&(t+=J(n,e[r]))}return t},_ssrClass:function(e,t){var r=He(e,t);return""===r?r:' class="'+I(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&x(n,e);t&&x(n,Qe(t));r&&x(n,r);var i=Ye(n);return""===i?i:" style="+JSON.stringify(I(i))}};var Qn=function(){return function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?Wn(r):2===n?Zn(r):r:void 0}}();var Yn=new ae;function ei(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof H)return;if(t.__ob__){var s=t.__ob__.dep.id;if(r.has(s))return;r.add(s)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,Yn),Yn.clear()}var ti=m(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function ri(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return De(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)De(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function ni(e,t,r,i,o){if(n(t)){if(h(t,r))return e[r]=t[r],o||delete t[r],!0;if(h(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}var ii,oi=1,ai=2;function si(e,t,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),i(l)&&(u=ai),function(e,t,o,s,c){if(n(o)&&n(o.__ob__))return K();n(o)&&n(o.is)&&(t=o.is);if(!t)return K();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===ai?s=Zn(s):c===oi&&(s=Wn(s));var u,l;if("string"==typeof t){var f=void 0;l=e.$vnode&&e.$vnode.ns||le.getTagNamespace(t),u=o&&o.pre||!n(f=Pe(e.$options,"components",t))?new H(t,o,s,void 0,void 0,e):zi(f,o,e,s,t)}else u=zi(t,o,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(t,o,a){t.ns=o;"foreignObject"===t.tag&&(o=void 0,a=!0);if(n(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];n(u.tag)&&(r(u.ns)||i(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(o)&&function(e){a(e.style)&&ei(e.style);a(e.class)&&ei(e.class)}(o),u):K()}(e,t,s,c,u)}function ci(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(se&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ui(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=x(x({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function li(e){return Pe(this.$options,"filters",e)||k}function fi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function pi(e,t,r,n,i){var o=le.keyCodes[t]||r;return i&&n&&!le.keyCodes[t]?fi(i,n):o?fi(o,e):n?w(n)!==t:void 0}function di(e,t,r,n,i){if(r)if(a(r)){Array.isArray(r)&&(r=S(r));var o=void 0,s=function(a){if("class"===a||"style"===a||d(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||le.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=g(a),u=w(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var c in r)s(c)}else;return e}function vi(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(mi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function hi(e,t,r){return mi(e,"__once__"+t+(r?"_"+r:""),!0),e}function mi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&yi(e[n],t+"_"+n,r);else yi(e,t,r)}function yi(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function gi(e,t){if(t)if(c(t)){var r=e.on=e.on?x({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function bi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?bi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function _i(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function wi(e,t){return"string"==typeof e?t+e:e}function xi(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Si)&&delete r[u];return r}function Si(e){return e.isComment&&!e.asyncFactory||" "===e.text}function $i(e,r,n){var i,o=Object.keys(r).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&n&&n!==t&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Ai(r,c,e[c]))}else i={};for(var u in r)u in i||(i[u]=ki(r,u));return e&&Object.isExtensible(e)&&(e._normalized=i),Z(i,"$stable",a),Z(i,"$key",s),Z(i,"$hasNormal",o),i}function Ai(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Zn(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function ki(e,t){return function(){return e[t]}}function Oi(e,t){ii.$on(e,t)}function Ci(e,t){ii.$off(e,t)}function Ti(e,t){var r=ii;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Fi(e,t,n){ii=e,function(e,t,n,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=ti(c),r(u)||(r(l)?(r(u.fns)&&(u=e[c]=ri(u,s)),i(f.once)&&(u=e[c]=a(f.name,u,f.capture)),n(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)r(e[c])&&o((f=ti(c)).name,t[c],f.capture)}(t,n||{},Oi,Ci,Ti,e),ii=void 0}function ji(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Pi(e,t){ve();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)De(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),he()}var Ei=Date.now;if(G&&!ee){var Ni=window.performance;Ni&&"function"==typeof Ni.now&&Ei()>document.createEvent("Event").timeStamp&&(Ei=function(){return Ni.now()})}function Ii(e,r,n,o,a){var s,c=this,u=a.options;h(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=i(u._compiled),f=!l;this.data=e,this.props=r,this.children=n,this.parent=o,this.listeners=e.on||t,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=se?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&h(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,o),this.slots=function(){return c.$slots||$i(e.scopedSlots,c.$slots=xi(n,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return $i(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=$i(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var i=si(s,e,t,r,n,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,r,n){return si(s,e,t,r,n,f)}}function Li(e,t,r,n,i){var o=function(e){var t=new H(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Mi(e,t){for(var r in t)e[g(r)]=t[r]}!function(e){e._o=hi,e._n=l,e._s=u,e._l=ci,e._t=ui,e._q=O,e._i=C,e._m=vi,e._f=li,e._k=pi,e._b=di,e._v=V,e._e=K,e._u=bi,e._g=gi,e._d=_i,e._p=wi}(Ii.prototype);var Ri={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ri.prepatch(r,r)}else{(e.componentInstance=Ui(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,r){var n=r.componentOptions;!function(e,r,n,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||t,e.$listeners=n||t,r&&e.$options.props){_e(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Ee(d,v,r,e)}_e(!0),e.$options.propsData=r}n=n||t;var h=e.$options._parentListeners;e.$options._parentListeners=n,Fi(e,n,h),u&&(e.$slots=xi(o,i.context),e.$forceUpdate())}(r.componentInstance=e.componentInstance,n.propsData,n.listeners,r,n.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Pi(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,ji(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Pi(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,ji(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Pi(t,"deactivated")}}(t,!0):t.$destroy())}},Di=Object.keys(Ri);function zi(e,o,s,c,u){if(!r(e)){var l=s.$options._base;if(a(e)&&(e=l.extend(e)),"function"==typeof e){var f,p;if(r(e.cid)&&void 0===(e=i((p=f=e).error)&&n(p.errorComp)?p.errorComp:n(p.resolved)?p.resolved:i(p.loading)&&n(p.loadingComp)?p.loadingComp:void 0))return function(e,t,r,n,i){var o=K();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(f,o,s,c,u);o=o||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&x(t.extendOptions,i),(r=t.options=je(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(e.options,o);var d=function(e,t,i){var o=t.options.props;if(!r(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=w(u);ni(a,c,u,l,!0)||ni(a,s,u,l,!1)}return a}}(o,e);if(i(e.options.functional))return function(e,r,i,o,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Ee(l,u,r||t);else n(i.attrs)&&Mi(c,i.attrs),n(i.props)&&Mi(c,i.props);var f=new Ii(i,c,a,o,e),p=s.render.call(null,f._c,f);if(p instanceof H)return Li(p,i,f.parent,s);if(Array.isArray(p)){for(var d=Zn(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Li(d[h],i,f.parent,s);return v}}(e,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,i(e.options.abstract)){var h=o.slot;o={},h&&(o.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Di.length;r++){var n=Di[r],i=t[n],o=Ri[n];i===o||i&&i._merged||(t[n]=i?Bi(o,i):o)}}(o);var m=e.options.name||u;return new H("vue-component-"+e.cid+(m?"-"+m:""),o,void 0,void 0,void 0,s,{Ctor:e,propsData:d,listeners:v,tag:u,children:c},f)}}}function Ui(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;return n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns),new e.componentOptions.Ctor(r)}function Bi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var qi=Object.create(null),Ji=function(e){qi[e]||(qi[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},Hi=function(e,t){var r=t?(void 0)():"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},Ki=function(e){var t=e.$options,n=t.render,i=t.template,o=t._scopeId;if(r(n)){if(!i)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=Vn(i,{scopeId:o,warn:Hi},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function Vi(e,t,r){var i=e.$options.serverPrefetch;if(n(i)){Array.isArray(i)||(i=[i]);try{for(var o=[],a=0,s=i.length;a<s;a++){var c=i[a].call(e,e);c&&"function"==typeof c.then&&o.push(c)}return void Promise.all(o).then(t).catch(r)}catch(e){r(e)}}t()}function Wi(e,t,o){e.isString?function(e,t){var n=t.write,i=t.next;if(r(e.children)||0===e.children.length)n(e.open+(e.close||""),i);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),n(e.open,i)}}(e,o):n(e.componentOptions)?Xi(e,t,o):n(e.tag)?function(e,t,o){var a=o.write,s=o.next;i(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[ce]="true");e.fnOptions&&Zi(e.fnOptions,a);var c=function(e,t){var i,o="<"+e.tag,a=t.directives,s=t.modules;r(e.data)&&function e(t){var r=t.parent;return n(r)&&(n(r.data)||e(r))}(e)&&(e.data={});if(n(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=Pe(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;n(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var u=0;u<s.length;u++){var d=s[u](e);d&&(o+=d)}}var v=t.activeInstance;n(v)&&v!==e.context&&n(i=v.$options._scopeId)&&(o+=" "+i);if(n(e.fnScopeId))o+=" "+e.fnScopeId;else for(;n(e);)n(i=e.context.$options._scopeId)&&(o+=" "+i),e=e.parent;return o+">"}(e,o),u="</"+e.tag+">";if(o.isUnaryTag(e.tag))a(c,s);else if(r(e.children)||0===e.children.length)a(c+u,s);else{var l=e.children;o.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),a(c,s)}}(e,t,o):i(e.isComment)?n(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=zi(n,o,c,a,s);u?u.componentOptions?Xi(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):Wi(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,o):o.write("\x3c!--"+e.text+"--\x3e",o.next):o.write(e.raw?e.text:I(String(e.text)),o.next)}function Zi(e,t){var r=e._ssrRegister;return t.caching&&n(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function Xi(e,t,i){var o=i.write,a=i.next,s=i.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=i.cache,p=Zi(c.options,o);if(n(u)&&n(f)&&n(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void Qi(e,t,i);var v=l+"::"+d,h=i.has,m=i.get;n(h)?h(v,function(r){!0===r&&n(m)?m(v,function(e){n(p)&&p(s),e.components.forEach(function(e){return e(s)}),o(e.html,a)}):Gi(e,t,v,i)}):n(m)&&m(v,function(r){n(r)?(n(p)&&p(s),r.components.forEach(function(e){return e(s)}),o(r.html,a)):Gi(e,t,v,i)})}else n(u)&&r(f)&&Ji("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),n(u)&&r(l)&&Ji('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),Qi(e,t,i)}function Gi(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),Qi(e,t,n)}function Qi(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Ui(e,r.activeInstance);Ki(i);var o=r.done;Vi(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),Wi(o,t,r)},o)}function Yi(e,t,r,n){return function(i,o,a,s){qi=Object.create(null);var c=new ht({activeInstance:i,userContext:a,write:o,done:s,renderNode:Wi,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;x(t.prototype,Gn),t.FunctionalRenderContext&&x(t.FunctionalRenderContext.prototype,Gn)}}(i),Ki(i);Vi(i,function(){Wi(i._render(),!0,c)},s)}}var eo=function(e){return/\.js(\?[^.]+)?$/.test(e)};function to(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var ro=function(e){function t(t,r,n){var i=e.call(this)||this;return i.started=!1,i.renderer=t,i.template=r,i.context=n||{},i.inject=t.inject,i}return ut(t,e),t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),no=require("lodash.template"),io={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function oo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var ao=require("path"),so=require("serialize-javascript"),co=function(){function e(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:no(e.slice(0,r),io),neck:no(e.slice(r,n),io),tail:no(e.slice(n+t.length),io)}}(t):t:null,this.serialize=e.serializer||function(e){return so(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(uo),this.prefetchFiles=(r.async||[]).map(uo),this.mapFiles=oo(r)}}return e.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},e.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},e.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},e.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},e.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},e.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},e.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},e.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey,i=void 0===n?"state":n,o=r.windowKey,a=void 0===o?"__INITIAL_STATE__":o,s=this.serialize(e[i]),c=e.nonce?' nonce="'+e.nonce+'"':"";return e[i]?"<script"+c+">window."+a+"="+s+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},e.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return eo(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return eo(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},e.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(uo)}return e._mappedFiles},e.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new ro(this,this.parsedTemplate,e||{})},e}();function uo(e){var t=e.replace(/\?.*/,""),r=ao.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:lo(r)}}function lo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}var fo=require("vm"),po=require("path"),vo=require("resolve"),ho=require("module");function mo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function yo(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=ho.wrap(r),o=new fo.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=po.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=vo.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function go(e,t,r,n){var i,o,a=yo(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,mo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?mo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(c(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var u=o._renderStyles;u&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return u(t._styles)}})}r(i(t))})}}var bo=require("source-map").SourceMapConsumer,_o=/\(([^)]+\.js):(\d+):(\d+)\)$/;function wo(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(_o),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(_o,c)}return e}return e}(e,t)}).join("\n"))}var xo=require("fs"),So=require("path"),$o=require("stream").PassThrough,Ao="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function ko(e){return void 0===e&&(e={}),function(e){var t=void 0===e?{}:e,r=t.modules,n=void 0===r?[]:r,i=t.directives,o=void 0===i?{}:i,a=t.isUnaryTag,s=void 0===a?function(){return!1}:a,c=t.template,u=t.inject,l=t.cache,f=t.shouldPreload,p=t.shouldPrefetch,d=t.clientManifest,v=t.serializer,h=Yi(n,o,s,l),m=new co({template:c,inject:u,shouldPreload:f,shouldPrefetch:p,clientManifest:d,serializer:v});return{renderToString:function(e,t,r){var n,i;"function"==typeof t&&(r=t,t={}),t&&m.bindRenderFns(t),r||(i=(n=to()).promise,r=n.cb);var o="",a=dt(function(e){return o+=e,!1},r);try{h(e,a,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),c)try{var n=m.render(o,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,o)})}catch(e){r(e)}return i},renderToStream:function(e,t){t&&m.bindRenderFns(t);var r=new vt(function(r,n){h(e,r,t,n)});if(c){if("function"==typeof c)throw new Error("function template is only supported in renderToString.");var n=m.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var i=t.rendered;r.once("beforeEnd",function(){i(t)})}return n}if(t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return r}}}(x(x({},e),{isUnaryTag:ot,canBeLeftOpenTag:at,modules:tt,directives:x(it,e.directives)}))}process.env.VUE_ENV="server";var Oo=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&So.isAbsolute(t)){if(!xo.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||So.dirname(t),t=xo.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new bo(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(Ao)}else{if("string"!=typeof t)throw new Error(Ao);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=go(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=to()).promise,t=r.cb),u(e).catch(function(e){wo(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){wo(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new $o;return u(e).catch(function(e){wo(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){wo(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(ko);exports.createBundleRenderer=Oo,exports.createRenderer=ko;
\ No newline at end of file
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 3a17291425d..75eaae0f649 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -4,12 +4,10 @@
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
 
-var ref = require('chalk');
-var red = ref.red;
-var yellow = ref.yellow;
+var _a = require('chalk'), red = _a.red, yellow = _a.yellow;
 var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = (exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); });
-var tip = (exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); });
+(exports.warn = function (msg) { return console.error(red(prefix + " " + msg + "\n")); });
+(exports.tip = function (msg) { return console.log(yellow(prefix + " " + msg + "\n")); });
 var onEmit = function (compiler, name, hook) {
     if (compiler.hooks) {
         // Webpack >= 4.0.0
@@ -23,64 +21,65 @@ var onEmit = function (compiler, name, hook) {
 
 var hash = require('hash-sum');
 var uniq = require('lodash.uniq');
-var VueSSRClientPlugin = function VueSSRClientPlugin(options) {
-    if ( options === void 0 ) options = {};
-
-    //@ts-expect-error
-    this.options = Object.assign({
-        filename: 'vue-ssr-client-manifest.json',
-    }, options);
-};
-VueSSRClientPlugin.prototype.apply = function apply (compiler) {
-        var this$1 = this;
-
-    onEmit(compiler, 'vue-client-plugin', function (compilation, cb) {
-        var stats = compilation.getStats().toJson();
-        var allFiles = uniq(stats.assets.map(function (a) { return a.name; }));
-        var initialFiles = uniq(Object.keys(stats.entrypoints)
-            .map(function (name) { return stats.entrypoints[name].assets; })
-            .reduce(function (assets, all) { return all.concat(assets); }, [])
-            .filter(function (file) { return isJS(file) || isCSS(file); }));
-        var asyncFiles = allFiles
-            .filter(function (file) { return isJS(file) || isCSS(file); })
-            .filter(function (file) { return initialFiles.indexOf(file) < 0; });
-        var manifest = {
-            publicPath: stats.publicPath,
-            all: allFiles,
-            initial: initialFiles,
-            async: asyncFiles,
-            modules: {
-            /* [identifier: string]: Array<index: number> */
-            },
-        };
-        var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
-        var fileToIndex = function (file) { return manifest.all.indexOf(file); };
-        stats.modules.forEach(function (m) {
-            // ignore modules duplicated in multiple chunks
-            if (m.chunks.length === 1) {
-                var cid = m.chunks[0];
-                var chunk = stats.chunks.find(function (c) { return c.id === cid; });
-                if (!chunk || !chunk.files) {
-                    return;
-                }
-                var id = m.identifier.replace(/\s\w+$/, ''); // remove appended hash
-                var files = (manifest.modules[hash(id)] = chunk.files.map(fileToIndex));
-                // find all asset modules associated with the same chunk
-                assetModules.forEach(function (m) {
-                    if (m.chunks.some(function (id) { return id === cid; })) {
-                        files.push.apply(files, m.assets.map(fileToIndex));
+var VueSSRClientPlugin = /** @class */ (function () {
+    function VueSSRClientPlugin(options) {
+        if (options === void 0) { options = {}; }
+        //@ts-expect-error
+        this.options = Object.assign({
+            filename: 'vue-ssr-client-manifest.json',
+        }, options);
+    }
+    VueSSRClientPlugin.prototype.apply = function (compiler) {
+        var _this = this;
+        onEmit(compiler, 'vue-client-plugin', function (compilation, cb) {
+            var stats = compilation.getStats().toJson();
+            var allFiles = uniq(stats.assets.map(function (a) { return a.name; }));
+            var initialFiles = uniq(Object.keys(stats.entrypoints)
+                .map(function (name) { return stats.entrypoints[name].assets; })
+                .reduce(function (assets, all) { return all.concat(assets); }, [])
+                .filter(function (file) { return isJS(file) || isCSS(file); }));
+            var asyncFiles = allFiles
+                .filter(function (file) { return isJS(file) || isCSS(file); })
+                .filter(function (file) { return initialFiles.indexOf(file) < 0; });
+            var manifest = {
+                publicPath: stats.publicPath,
+                all: allFiles,
+                initial: initialFiles,
+                async: asyncFiles,
+                modules: {
+                /* [identifier: string]: Array<index: number> */
+                },
+            };
+            var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
+            var fileToIndex = function (file) { return manifest.all.indexOf(file); };
+            stats.modules.forEach(function (m) {
+                // ignore modules duplicated in multiple chunks
+                if (m.chunks.length === 1) {
+                    var cid_1 = m.chunks[0];
+                    var chunk = stats.chunks.find(function (c) { return c.id === cid_1; });
+                    if (!chunk || !chunk.files) {
+                        return;
                     }
-                });
-            }
+                    var id = m.identifier.replace(/\s\w+$/, ''); // remove appended hash
+                    var files_1 = (manifest.modules[hash(id)] = chunk.files.map(fileToIndex));
+                    // find all asset modules associated with the same chunk
+                    assetModules.forEach(function (m) {
+                        if (m.chunks.some(function (id) { return id === cid_1; })) {
+                            files_1.push.apply(files_1, m.assets.map(fileToIndex));
+                        }
+                    });
+                }
+            });
+            var json = JSON.stringify(manifest, null, 2);
+            //@ts-expect-error
+            compilation.assets[_this.options.filename] = {
+                source: function () { return json; },
+                size: function () { return json.length; },
+            };
+            cb();
         });
-        var json = JSON.stringify(manifest, null, 2);
-        //@ts-expect-error
-        compilation.assets[this$1.options.filename] = {
-            source: function () { return json; },
-            size: function () { return json.length; },
-        };
-        cb();
-    });
-};
+    };
+    return VueSSRClientPlugin;
+}());
 
 module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index 866b41a87d4..a007dec2db2 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -3,12 +3,10 @@
 /* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 
-var ref = require('chalk');
-var red = ref.red;
-var yellow = ref.yellow;
+var _a = require('chalk'), red = _a.red, yellow = _a.yellow;
 var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = (exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); });
-var tip = (exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); });
+var warn = (exports.warn = function (msg) { return console.error(red(prefix + " " + msg + "\n")); });
+var tip = (exports.tip = function (msg) { return console.log(yellow(prefix + " " + msg + "\n")); });
 var validate = function (compiler) {
     if (compiler.options.target !== 'node') {
         warn('webpack config `target` should be "node".');
@@ -33,59 +31,60 @@ var onEmit = function (compiler, name, hook) {
     }
 };
 
-var VueSSRServerPlugin = function VueSSRServerPlugin(options) {
-    if ( options === void 0 ) options = {};
-
-    //@ts-expect-error
-    this.options = Object.assign({
-        filename: 'vue-ssr-server-bundle.json',
-    }, options);
-};
-VueSSRServerPlugin.prototype.apply = function apply (compiler) {
-        var this$1 = this;
-
-    validate(compiler);
-    onEmit(compiler, 'vue-server-plugin', function (compilation, cb) {
-        var stats = compilation.getStats().toJson();
-        var entryName = Object.keys(stats.entrypoints)[0];
-        var entryInfo = stats.entrypoints[entryName];
-        if (!entryInfo) {
-            // #5553
-            return cb();
-        }
-        var entryAssets = entryInfo.assets.filter(isJS);
-        if (entryAssets.length > 1) {
-            throw new Error("Server-side bundle should have one single entry file. " +
-                "Avoid using CommonsChunkPlugin in the server config.");
-        }
-        var entry = entryAssets[0];
-        if (!entry || typeof entry !== 'string') {
-            throw new Error(("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?"));
-        }
-        var bundle = {
-            entry: entry,
-            files: {},
-            maps: {},
-        };
-        stats.assets.forEach(function (asset) {
-            if (isJS(asset.name)) {
-                bundle.files[asset.name] = compilation.assets[asset.name].source();
+var VueSSRServerPlugin = /** @class */ (function () {
+    function VueSSRServerPlugin(options) {
+        if (options === void 0) { options = {}; }
+        //@ts-expect-error
+        this.options = Object.assign({
+            filename: 'vue-ssr-server-bundle.json',
+        }, options);
+    }
+    VueSSRServerPlugin.prototype.apply = function (compiler) {
+        var _this = this;
+        validate(compiler);
+        onEmit(compiler, 'vue-server-plugin', function (compilation, cb) {
+            var stats = compilation.getStats().toJson();
+            var entryName = Object.keys(stats.entrypoints)[0];
+            var entryInfo = stats.entrypoints[entryName];
+            if (!entryInfo) {
+                // #5553
+                return cb();
+            }
+            var entryAssets = entryInfo.assets.filter(isJS);
+            if (entryAssets.length > 1) {
+                throw new Error("Server-side bundle should have one single entry file. " +
+                    "Avoid using CommonsChunkPlugin in the server config.");
             }
-            else if (asset.name.match(/\.js\.map$/)) {
-                bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source());
+            var entry = entryAssets[0];
+            if (!entry || typeof entry !== 'string') {
+                throw new Error("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?");
             }
-            // do not emit anything else for server
-            delete compilation.assets[asset.name];
+            var bundle = {
+                entry: entry,
+                files: {},
+                maps: {},
+            };
+            stats.assets.forEach(function (asset) {
+                if (isJS(asset.name)) {
+                    bundle.files[asset.name] = compilation.assets[asset.name].source();
+                }
+                else if (asset.name.match(/\.js\.map$/)) {
+                    bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source());
+                }
+                // do not emit anything else for server
+                delete compilation.assets[asset.name];
+            });
+            var json = JSON.stringify(bundle, null, 2);
+            //@ts-expect-error
+            var filename = _this.options.filename;
+            compilation.assets[filename] = {
+                source: function () { return json; },
+                size: function () { return json.length; },
+            };
+            cb();
         });
-        var json = JSON.stringify(bundle, null, 2);
-        //@ts-expect-error
-        var filename = this$1.options.filename;
-        compilation.assets[filename] = {
-            source: function () { return json; },
-            size: function () { return json.length; },
-        };
-        cb();
-    });
-};
+    };
+    return VueSSRServerPlugin;
+}());
 
 module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index c73b00097e6..93d102c335e 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -1,10 +1,10 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = global || self, factory(global.VueTemplateCompiler = {}));
-}(this, function (exports) { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VueTemplateCompiler = {}));
+}(this, (function (exports) { 'use strict';
 
-  var splitRE = /\r?\n/g;
+  var splitRE$1 = /\r?\n/g;
   var emptyRE = /^\s*$/;
   var needFixRE = /^(\r?\n)*[\t\s]/;
 
@@ -12,7 +12,7 @@
     if (!needFixRE.test(str)) {
       return str
     }
-    var lines = str.split(splitRE);
+    var lines = str.split(splitRE$1);
     var min = Infinity;
     var type, cur, c;
     for (var i = 0; i < lines.length; i++) {
@@ -115,7 +115,7 @@
   /**
    * Check if an attribute is a reserved attribute.
    */
-  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  makeMap('key,ref,slot,slot-scope,is');
   /**
    * Remove an item from an array.
    */
@@ -158,31 +158,6 @@
   var hyphenate = cached(function (str) {
       return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-  /* istanbul ignore next */
-  function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          var l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
-  }
-  function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
-  }
-  // @ts-expect-error bind cannot be `undefined`
-  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Mix properties into target object.
    */
@@ -211,7 +186,7 @@
   /**
    * Generate a string containing static keys from compiler modules.
    */
-  function genStaticKeys(modules) {
+  function genStaticKeys$1(modules) {
       return modules
           .reduce(function (keys, m) {
           return keys.concat(m.staticKeys || []);
@@ -258,11 +233,11 @@
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp(("^<" + qnameCapture));
+  var startTagOpen = new RegExp("^<" + qnameCapture);
   var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+  var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
   var doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
@@ -283,7 +258,9 @@
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+  var shouldIgnoreFirstNewline = function (tag, html) {
+      return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  };
   function decodeAttr(value, shouldDecodeNewlines) {
       var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
       return value.replace(re, function (match) { return decodingMap[match]; });
@@ -291,11 +268,11 @@
   function parseHTML(html, options) {
       var stack = [];
       var expectHTML = options.expectHTML;
-      var isUnaryTag$$1 = options.isUnaryTag || no;
-      var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+      var isUnaryTag = options.isUnaryTag || no;
+      var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
       var index = 0;
       var last, lastTag;
-      while (html) {
+      var _loop_1 = function () {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -309,7 +286,7 @@
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                           }
                           advance(commentEnd + 3);
-                          continue;
+                          return "continue";
                       }
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -317,14 +294,14 @@
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
-                          continue;
+                          return "continue";
                       }
                   }
                   // Doctype:
                   var doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
-                      continue;
+                      return "continue";
                   }
                   // End tag:
                   var endTagMatch = html.match(endTag);
@@ -332,7 +309,7 @@
                       var curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
+                      return "continue";
                   }
                   // Start tag:
                   var startTagMatch = parseStartTag();
@@ -341,10 +318,10 @@
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                           advance(1);
                       }
-                      continue;
+                      return "continue";
                   }
               }
-              var text = (void 0), rest = (void 0), next = (void 0);
+              var text = void 0, rest = void 0, next = void 0;
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -371,18 +348,18 @@
               }
           }
           else {
-              var endTagLength = 0;
-              var stackedTag = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+              var endTagLength_1 = 0;
+              var stackedTag_1 = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag_1] ||
+                  (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+              var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength_1 = endTag.length;
+                  if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                       text = text
                           .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                           .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                   }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                  if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                       text = text.slice(1);
                   }
                   if (options.chars) {
@@ -390,20 +367,25 @@
                   }
                   return '';
               });
-              index += html.length - rest$1.length;
-              html = rest$1;
-              parseEndTag(stackedTag, index - endTagLength, index);
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag_1, index - endTagLength_1, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                  options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                       start: index + html.length,
                   });
               }
-              break;
+              return "break";
           }
+      };
+      while (html) {
+          var state_1 = _loop_1();
+          if (state_1 === "break")
+              { break; }
       }
       // Clean up any remaining tags
       parseEndTag();
@@ -420,7 +402,7 @@
                   start: index,
               };
               advance(start[0].length);
-              var end, attr;
+              var end = void 0, attr = void 0;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -443,11 +425,11 @@
               if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                   parseEndTag(lastTag);
               }
-              if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                   parseEndTag(tagName);
               }
           }
-          var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+          var unary = isUnaryTag(tagName) || !!unarySlash;
           var l = match.attrs.length;
           var attrs = new Array(l);
           for (var i = 0; i < l; i++) {
@@ -501,9 +483,9 @@
           if (pos >= 0) {
               // Close all the open elements, up the stack
               for (var i = stack.length - 1; i >= pos; i--) {
-                  if (i > pos || !tagName &&
+                  if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                      options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -533,15 +515,14 @@
   }
 
   /* @flow */
-  var splitRE$1 = /\r?\n/g;
+  var splitRE = /\r?\n/g;
   var replaceRE = /./g;
   var isSpecialTag = makeMap('script,style,template', true);
   /**
    * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
    */
   function parseComponent(content, options) {
-      if ( options === void 0 ) options = {};
-
+      if (options === void 0) { options = {}; }
       var sfc = {
           template: null,
           script: null,
@@ -572,10 +553,8 @@
                   type: tag,
                   content: '',
                   start: end,
-                  attrs: attrs.reduce(function (cumulated, ref) {
-                      var name = ref.name;
-                      var value = ref.value;
-
+                  attrs: attrs.reduce(function (cumulated, _a) {
+                      var name = _a.name, value = _a.value;
                       cumulated[name] = value || true;
                       return cumulated;
                   }, {}),
@@ -638,7 +617,7 @@
               return content.slice(0, block.start).replace(replaceRE, ' ');
           }
           else {
-              var offset = content.slice(0, block.start).split(splitRE$1).length;
+              var offset = content.slice(0, block.start).split(splitRE).length;
               var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
               return Array(offset).join(padChar);
           }
@@ -665,21 +644,24 @@
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  UA && UA.indexOf('msie 9.0') > 0;
   var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-  var isPhantomJS = UA && /phantomjs/.test(UA);
-  var isFF = UA && UA.match(/firefox\/(\d+)/);
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
   // @ts-ignore
   var nativeWatch = {}.watch;
+  var supportsPassive = false;
   if (inBrowser) {
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function get() {
+              get: function () {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
               },
           }); // https://github.com/facebook/flow/issues/285
           // @ts-ignore
@@ -705,9 +687,6 @@
       }
       return _isServer;
   };
-  // detect devtools
-  // @ts-ignore TODO decalre this types
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
   /* istanbul ignore next */
   function isNative(Ctor) {
       return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
@@ -716,29 +695,24 @@
       isNative(Symbol) &&
       typeof Reflect !== 'undefined' &&
       isNative(Reflect.ownKeys);
-  var _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
+      /** @class */ ((function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function has (key) {
+          Set.prototype.has = function (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function add (key) {
+          Set.prototype.add = function (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function clear () {
+          Set.prototype.clear = function () {
               this.set = Object.create(null);
           };
-
           return Set;
-      }());
+      })());
   }
 
   var ASSET_TYPES = ['component', 'directive', 'filter'];
@@ -836,22 +810,24 @@
   };
 
   /* @flow */
-  var warn = noop;
+  var warn$2 = noop;
   var tip = noop;
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-      warn = function (msg, vm) {
+      var hasConsole_1 = typeof console !== 'undefined';
+      var classifyRE_1 = /(?:^|[-_])(\w)/g;
+      var classify_1 = function (str) {
+          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+      };
+      warn$2 = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
+          if (hasConsole_1 && !config.silent) {
+              console.error("[Vue warn]: " + msg + trace);
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole && !config.silent) {
+          if (hasConsole_1 && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -874,10 +850,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
+          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+              (file && includeFile !== false ? " at " + file : ''));
       };
-      var repeat = function (str, n) {
+      var repeat_1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -911,13 +887,15 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
+                      .map(function (vm, i) {
+                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                          : formatComponentName(vm));
+                  })
                       .join('\n'));
           }
           else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+              return "\n\n(found in " + formatComponentName(vm) + ")";
           }
       };
   }
@@ -927,67 +905,73 @@
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep() {
-      this.id = uid++;
-      this.subs = [];
-  };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
-  };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove(this.subs, sub);
-  };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
-      }
-  };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
+  var Dep = /** @class */ (function () {
+      function Dep() {
+          this.id = uid++;
+          this.subs = [];
       }
-  };
+      Dep.prototype.addSub = function (sub) {
+          this.subs.push(sub);
+      };
+      Dep.prototype.removeSub = function (sub) {
+          remove(this.subs, sub);
+      };
+      Dep.prototype.depend = function () {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      };
+      Dep.prototype.notify = function () {
+          // stabilize the subscriber list first
+          var subs = this.subs.slice();
+          for (var i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      };
+      return Dep;
+  }());
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-      return this.componentInstance;
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
+  var VNode = /** @class */ (function () {
+      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      Object.defineProperty(VNode.prototype, "child", {
+          // DEPRECATED: alias for componentInstance for backwards compat.
+          /* istanbul ignore next */
+          get: function () {
+              return this.componentInstance;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return VNode;
+  }());
 
   /*
    * not type checking this file because flow doesn't play well with
@@ -1010,9 +994,12 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
+          var arguments$1 = arguments;
 
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              args[_i] = arguments$1[_i];
+          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -1034,54 +1021,52 @@
   });
 
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  var shouldObserve = true;
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
+  var Observer = /** @class */ (function () {
+      function Observer(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
           }
           else {
-              copyAugment(value, arrayMethods, arrayKeys);
+              this.walk(value);
           }
-          this.observeArray(value);
       }
-      else {
-          this.walk(value);
-      }
-  };
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive$$1(obj, keys[i]);
-      }
-  };
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
-      }
-  };
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      Observer.prototype.walk = function (obj) {
+          var keys = Object.keys(obj);
+          for (var i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      };
+      /**
+       * Observe a list of Array items.
+       */
+      Observer.prototype.observeArray = function (items) {
+          for (var i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      };
+      return Observer;
+  }());
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -1116,8 +1101,7 @@
       if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
           ob = value.__ob__;
       }
-      else if (shouldObserve &&
-          !isServerRendering() &&
+      else if (!isServerRendering() &&
           (Array.isArray(value) || isPlainObject(value)) &&
           Object.isExtensible(value) &&
           !value._isVue) {
@@ -1131,7 +1115,7 @@
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1(obj, key, val, customSetter, shallow) {
+  function defineReactive(obj, key, val, customSetter, shallow) {
       var dep = new Dep();
       var property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
@@ -1190,8 +1174,8 @@
    * already exist.
    */
   function set(target, key, val) {
-      if (isUndef(target) || isPrimitive(target)) {
-          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -1205,7 +1189,7 @@
       var ob = target.__ob__;
       // @ts-ignore
       if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                   'at runtime - declare it upfront in the data option.');
           return val;
       }
@@ -1213,7 +1197,7 @@
           target[key] = val;
           return val;
       }
-      defineReactive$$1(ob.value, key, val);
+      defineReactive(ob.value, key, val);
       ob.dep.notify();
       return val;
   }
@@ -1222,7 +1206,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1244,7 +1228,7 @@
   {
       strats.el = strats.propsData = function (parent, child, vm, key) {
           if (!vm) {
-              warn("option \"" + key + "\" can only be used during instance " +
+              warn$2("option \"" + key + "\" can only be used during instance " +
                   'creation with the `new` keyword.');
           }
           return defaultStrat(parent, child);
@@ -1320,7 +1304,7 @@
   strats.data = function (parentVal, childVal, vm) {
       if (!vm) {
           if (childVal && typeof childVal !== 'function') {
-              warn('The "data" option should be a function ' +
+              warn$2('The "data" option should be a function ' +
                       'that returns a per-instance value in component ' +
                       'definitions.', vm);
               return parentVal;
@@ -1398,14 +1382,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key$1] = parent
-              ? parent.concat(child)
+      for (var key_1 in childVal) {
+          var parent_1 = ret[key_1];
+          var child = childVal[key_1];
+          if (parent_1 && !Array.isArray(parent_1)) {
+              parent_1 = [parent_1];
+          }
+          ret[key_1] = parent_1
+              ? parent_1.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1436,13 +1420,11 @@
   };
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
-          warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
+          warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+              ("but got " + toRawType(value) + "."), vm);
       }
   }
 
-  /* @flow */
-
   /* @flow */
   var callbacks = [];
   function flushCallbacks() {
@@ -1468,21 +1450,20 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
+      var counter_1 = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
+      var textNode_1 = document.createTextNode(String(counter_1));
+      observer.observe(textNode_1, {
           characterData: true,
       });
   }
   else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-  /* @flow */
+  else ;
 
   /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap('style,class');
+  makeMap('style,class');
   // attributes that should be using props for binding
   var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
@@ -1492,7 +1473,7 @@
           (attr === 'muted' && tag === 'video'));
   };
   var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  makeMap('events,caret,typing,plaintext-only');
   var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
       'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
       'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
@@ -1500,8 +1481,6 @@
       'required,reversed,scoped,seamless,selected,sortable,' +
       'truespeed,typemustmatch,visible');
 
-  /* @flow */
-
   /* @flow */
   var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
@@ -1533,9 +1512,7 @@
           return 'math';
       }
   }
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-  /* @flow */
+  makeMap('text,number,password,search,email,tel,url');
 
   /* @flow */
   var validDivisionCharRE = /[\w).+\-_$\]]/;
@@ -1616,7 +1593,9 @@
               if (c === 0x2f) {
                   // /
                   var j = i - 1;
-                  var p = (void 0);
+                  var p 
+                  // find first non-whitespace prev char
+                  = void 0;
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
@@ -1650,12 +1629,12 @@
       var i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return ("_f(\"" + filter + "\")(" + exp + ")");
+          return "_f(\"" + filter + "\")(" + exp + ")";
       }
       else {
-          var name = filter.slice(0, i);
+          var name_1 = filter.slice(0, i);
           var args = filter.slice(i + 1);
-          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+          return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
       }
   }
 
@@ -1686,7 +1665,7 @@
           }
           // tag token
           var exp = parseFilters(match[1].trim());
-          tokens.push(("_s(" + exp + ")"));
+          tokens.push("_s(" + exp + ")");
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -1703,7 +1682,7 @@
   /* @flow */
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error(("[Vue compiler]: " + msg));
+      console.error("[Vue compiler]: " + msg);
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
@@ -1737,7 +1716,7 @@
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+      return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -1868,7 +1847,7 @@
   }
 
   /* @flow */
-  function transformNode(el, options) {
+  function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
       if (staticClass) {
@@ -1888,20 +1867,20 @@
           el.classBinding = classBinding;
       }
   }
-  function genData(el) {
+  function genData$2(el) {
       var data = '';
       if (el.staticClass) {
-          data += "staticClass:" + (el.staticClass) + ",";
+          data += "staticClass:" + el.staticClass + ",";
       }
       if (el.classBinding) {
-          data += "class:" + (el.classBinding) + ",";
+          data += "class:" + el.classBinding + ",";
       }
       return data;
   }
   var klass = {
       staticKeys: ['staticClass'],
-      transformNode: transformNode,
-      genData: genData,
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
   /* @flow */
@@ -1919,7 +1898,7 @@
   });
 
   /* @flow */
-  function transformNode$1(el, options) {
+  function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
       if (staticStyle) {
@@ -1943,393 +1922,41 @@
   function genData$1(el) {
       var data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + (el.staticStyle) + ",";
+          data += "staticStyle:" + el.staticStyle + ",";
       }
       if (el.styleBinding) {
-          data += "style:(" + (el.styleBinding) + "),";
+          data += "style:(" + el.styleBinding + "),";
       }
       return data;
   }
   var style = {
       staticKeys: ['staticStyle'],
-      transformNode: transformNode$1,
+      transformNode: transformNode,
       genData: genData$1,
   };
 
-  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  function createCommonjsModule(fn, module) {
-  	return module = { exports: {} }, fn(module, module.exports), module.exports;
-  }
-
-  var he = createCommonjsModule(function (module, exports) {
-  (function(root) {
-
-  	// Detect free variables `exports`.
-  	var freeExports = exports;
-
-  	// Detect free variable `module`.
-  	var freeModule = module &&
-  		module.exports == freeExports && module;
-
-  	// Detect free variable `global`, from Node.js or Browserified code,
-  	// and use it as `root`.
-  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-  		root = freeGlobal;
-  	}
-
-  	/*--------------------------------------------------------------------------*/
-
-  	// All astral symbols.
-  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  	// All ASCII symbols (not just printable ASCII) except those listed in the
-  	// first column of the overrides table.
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-  	// code points listed in the first column of the overrides table on
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-  	var regexEscape = /["&'<>`]/g;
-  	var escapeMap = {
-  		'"': '&quot;',
-  		'&': '&amp;',
-  		'\'': '&#x27;',
-  		'<': '&lt;',
-  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-  		// following is not strictly necessary unless it’s part of a tag or an
-  		// unquoted attribute value. We’re only escaping it to support those
-  		// situations, and for XML support.
-  		'>': '&gt;',
-  		// In Internet Explorer ≤ 8, the backtick character can be used
-  		// to break out of (un)quoted attribute values or HTML comments.
-  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-  		// http://html5sec.org/#133.
-  		'`': '&#x60;'
-  	};
-
-  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var stringFromCharCode = String.fromCharCode;
-
-  	var object = {};
-  	var hasOwnProperty = object.hasOwnProperty;
-  	var has = function(object, propertyName) {
-  		return hasOwnProperty.call(object, propertyName);
-  	};
-
-  	var contains = function(array, value) {
-  		var index = -1;
-  		var length = array.length;
-  		while (++index < length) {
-  			if (array[index] == value) {
-  				return true;
-  			}
-  		}
-  		return false;
-  	};
-
-  	var merge = function(options, defaults) {
-  		if (!options) {
-  			return defaults;
-  		}
-  		var result = {};
-  		var key;
-  		for (key in defaults) {
-  			// A `hasOwnProperty` check is not needed here, since only recognized
-  			// option names are used anyway. Any others are ignored.
-  			result[key] = has(options, key) ? options[key] : defaults[key];
-  		}
-  		return result;
-  	};
-
-  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-  	var codePointToSymbol = function(codePoint, strict) {
-  		var output = '';
-  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-  			// See issue #4:
-  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-  			// REPLACEMENT CHARACTER.”
-  			if (strict) {
-  				parseError('character reference outside the permissible Unicode range');
-  			}
-  			return '\uFFFD';
-  		}
-  		if (has(decodeMapNumeric, codePoint)) {
-  			if (strict) {
-  				parseError('disallowed character reference');
-  			}
-  			return decodeMapNumeric[codePoint];
-  		}
-  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-  			parseError('disallowed character reference');
-  		}
-  		if (codePoint > 0xFFFF) {
-  			codePoint -= 0x10000;
-  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-  			codePoint = 0xDC00 | codePoint & 0x3FF;
-  		}
-  		output += stringFromCharCode(codePoint);
-  		return output;
-  	};
-
-  	var hexEscape = function(codePoint) {
-  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-  	};
-
-  	var decEscape = function(codePoint) {
-  		return '&#' + codePoint + ';';
-  	};
-
-  	var parseError = function(message) {
-  		throw Error('Parse error: ' + message);
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var encode = function(string, options) {
-  		options = merge(options, encode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidRawCodePoint.test(string)) {
-  			parseError('forbidden code point');
-  		}
-  		var encodeEverything = options.encodeEverything;
-  		var useNamedReferences = options.useNamedReferences;
-  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-  		var escapeBmpSymbol = function(symbol) {
-  			return escapeCodePoint(symbol.charCodeAt(0));
-  		};
-
-  		if (encodeEverything) {
-  			// Encode ASCII symbols.
-  			string = string.replace(regexAsciiWhitelist, function(symbol) {
-  				// Use named references if requested & possible.
-  				if (useNamedReferences && has(encodeMap, symbol)) {
-  					return '&' + encodeMap[symbol] + ';';
-  				}
-  				return escapeBmpSymbol(symbol);
-  			});
-  			// Shorten a few escapes that represent two symbols, of which at least one
-  			// is within the ASCII range.
-  			if (useNamedReferences) {
-  				string = string
-  					.replace(/&gt;\u20D2/g, '&nvgt;')
-  					.replace(/&lt;\u20D2/g, '&nvlt;')
-  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-  			}
-  			// Encode non-ASCII symbols.
-  			if (useNamedReferences) {
-  				// Encode non-ASCII symbols that can be replaced with a named reference.
-  				string = string.replace(regexEncodeNonAscii, function(string) {
-  					// Note: there is no need to check `has(encodeMap, string)` here.
-  					return '&' + encodeMap[string] + ';';
-  				});
-  			}
-  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-  		} else if (useNamedReferences) {
-  			// Apply named character references.
-  			// Encode `<>"'&` using named character references.
-  			if (!allowUnsafeSymbols) {
-  				string = string.replace(regexEscape, function(string) {
-  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-  				});
-  			}
-  			// Shorten escapes that represent two symbols, of which at least one is
-  			// `<>"'&`.
-  			string = string
-  				.replace(/&gt;\u20D2/g, '&nvgt;')
-  				.replace(/&lt;\u20D2/g, '&nvlt;');
-  			// Encode non-ASCII symbols that can be replaced with a named reference.
-  			string = string.replace(regexEncodeNonAscii, function(string) {
-  				// Note: there is no need to check `has(encodeMap, string)` here.
-  				return '&' + encodeMap[string] + ';';
-  			});
-  		} else if (!allowUnsafeSymbols) {
-  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-  			// using named character references.
-  			string = string.replace(regexEscape, escapeBmpSymbol);
-  		}
-  		return string
-  			// Encode astral symbols.
-  			.replace(regexAstralSymbols, function($0) {
-  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-  				var high = $0.charCodeAt(0);
-  				var low = $0.charCodeAt(1);
-  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-  				return escapeCodePoint(codePoint);
-  			})
-  			// Encode any remaining BMP symbols that are not printable ASCII symbols
-  			// using a hexadecimal escape.
-  			.replace(regexBmpWhitelist, escapeBmpSymbol);
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	encode.options = {
-  		'allowUnsafeSymbols': false,
-  		'encodeEverything': false,
-  		'strict': false,
-  		'useNamedReferences': false,
-  		'decimal' : false
-  	};
-
-  	var decode = function(html, options) {
-  		options = merge(options, decode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidEntity.test(html)) {
-  			parseError('malformed character reference');
-  		}
-  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  			var codePoint;
-  			var semicolon;
-  			var decDigits;
-  			var hexDigits;
-  			var reference;
-  			var next;
-
-  			if ($1) {
-  				reference = $1;
-  				// Note: there is no need to check `has(decodeMap, reference)`.
-  				return decodeMap[reference];
-  			}
-
-  			if ($2) {
-  				// Decode named character references without trailing `;`, e.g. `&amp`.
-  				// This is only a parse error if it gets converted to `&`, or if it is
-  				// followed by `=` in an attribute context.
-  				reference = $2;
-  				next = $3;
-  				if (next && options.isAttributeValue) {
-  					if (strict && next == '=') {
-  						parseError('`&` did not start a character reference');
-  					}
-  					return $0;
-  				} else {
-  					if (strict) {
-  						parseError(
-  							'named character reference was not terminated by a semicolon'
-  						);
-  					}
-  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-  					return decodeMapLegacy[reference] + (next || '');
-  				}
-  			}
-
-  			if ($4) {
-  				// Decode decimal escapes, e.g. `&#119558;`.
-  				decDigits = $4;
-  				semicolon = $5;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(decDigits, 10);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			if ($6) {
-  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-  				hexDigits = $6;
-  				semicolon = $7;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(hexDigits, 16);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-  			if (strict) {
-  				parseError(
-  					'named character reference was not terminated by a semicolon'
-  				);
-  			}
-  			return $0;
-  		});
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	decode.options = {
-  		'isAttributeValue': false,
-  		'strict': false
-  	};
-
-  	var escape = function(string) {
-  		return string.replace(regexEscape, function($0) {
-  			// Note: there is no need to check `has(escapeMap, $0)` here.
-  			return escapeMap[$0];
-  		});
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var he = {
-  		'version': '1.2.0',
-  		'encode': encode,
-  		'decode': decode,
-  		'escape': escape,
-  		'unescape': decode
-  	};
-
-  	// Some AMD build optimizers, like r.js, check for specific condition patterns
-  	// like the following:
-  	if (freeExports && !freeExports.nodeType) {
-  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-  			freeModule.exports = he;
-  		} else { // in Narwhal or RingoJS v0.7.0-
-  			for (var key in he) {
-  				has(he, key) && (freeExports[key] = he[key]);
-  			}
-  		}
-  	} else { // in Rhino or a web browser
-  		root.he = he;
-  	}
-
-  }(commonjsGlobal));
-  });
-
-  var he$1 = /*#__PURE__*/Object.freeze({
-    default: he,
-    __moduleExports: he
-  });
-
   /* @flow */
   /**
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var ref = modifiers || {};
-      var number = ref.number;
-      var trim = ref.trim;
+      var _a = modifiers || {}, number = _a.number, trim = _a.trim;
       var baseValueExpression = '$$v';
       var valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
               "(typeof " + baseValueExpression + " === 'string'" +
-                  "? " + baseValueExpression + ".trim()" +
-                  ": " + baseValueExpression + ")";
+                  ("? " + baseValueExpression + ".trim()") +
+                  (": " + baseValueExpression + ")");
       }
       if (number) {
           valueExpression = "_n(" + valueExpression + ")";
       }
       var assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: ("(" + value + ")"),
+          value: "(" + value + ")",
           expression: JSON.stringify(value),
-          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+          callback: "function (" + baseValueExpression + ") {" + assignment + "}",
       };
   }
   /**
@@ -2338,10 +1965,10 @@
   function genAssignmentCode(value, assignment) {
       var res = parseModel(value);
       if (res.key === null) {
-          return (value + "=" + assignment);
+          return value + "=" + assignment;
       }
       else {
-          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+          return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
       }
   }
   /**
@@ -2435,6 +2062,7 @@
   }
 
   /* @flow */
+  var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -2448,7 +2076,7 @@
   var lineBreakRE = /[\r\n]/;
   var whitespaceRE = /[ \f\t\r\n]+/g;
   var invalidAttributeRE = /[\s"'<>\/=]/;
-  var decodeHTMLCached = cached(undefined);
+  var decodeHTMLCached = cached(he.decode);
   var emptySlotScopeToken = "_empty_";
   // configurable state
   var warn$1;
@@ -2531,8 +2159,8 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                      var name_1 = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                   }
                   currentParent.children.push(element);
                   element.parent = currentParent;
@@ -2558,7 +2186,7 @@
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode;
+              var lastNode = void 0;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -2568,7 +2196,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+              warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -2585,7 +2213,7 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function start(tag, attrs, unary, start$1, end) {
+          start: function (tag, attrs, unary, start, end) {
               // check namespace.
               // inherit parent ns if there is one
               var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -2600,7 +2228,7 @@
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start$1;
+                      element.start = start;
                       element.end = end;
                       element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                           cumulated[attr.name] = attr;
@@ -2621,7 +2249,7 @@
                   element.forbidden = true;
                   warn$1('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          "<" + tag + ">" +
+                          ("<" + tag + ">") +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
@@ -2660,24 +2288,24 @@
                   closeElement(element);
               }
           },
-          end: function end(tag, start, end$1) {
+          end: function (tag, start, end) {
               var element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end$1;
+                  element.end = end;
               }
               closeElement(element);
           },
-          chars: function chars(text, start, end) {
+          chars: function (text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
                           warnOnce('Component template requires a root element, rather than just text.', { start: start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                          warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                               start: start,
                           });
                       }
@@ -2717,8 +2345,8 @@
                       // condense consecutive whitespaces into single space
                       text = text.replace(whitespaceRE, ' ');
                   }
-                  var res;
-                  var child;
+                  var res = void 0;
+                  var child = void 0;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
@@ -2744,7 +2372,7 @@
                   }
               }
           },
-          comment: function comment(text, start, end) {
+          comment: function (text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
@@ -2814,11 +2442,11 @@
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
-                  var parent = el.parent;
+                  var parent_1 = el.parent;
                   if (iterator &&
                       iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
+                      parent_1 &&
+                      parent_1.tag === 'transition-group') {
                       warn$1("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
@@ -2842,7 +2470,7 @@
               extend(el, res);
           }
           else {
-              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+              warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -2895,7 +2523,7 @@
       }
       else {
           warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+              ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
@@ -2906,7 +2534,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                  warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -2920,8 +2548,8 @@
       el.ifConditions.push(condition);
   }
   function processOnce(el) {
-      var once$$1 = getAndRemoveAttr(el, 'v-once');
-      if (once$$1 != null) {
+      var once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
           el.once = true;
       }
   }
@@ -2943,7 +2571,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -2975,45 +2603,41 @@
                               "the receiving component", el);
                       }
                   }
-                  var ref = getSlotName(slotBinding);
-                  var name = ref.name;
-                  var dynamic = ref.dynamic;
-                  el.slotTarget = name;
+                  var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                  el.slotTarget = name_2;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
               }
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding$1) {
+              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding);
                       }
                       if (el.slotScope || el.slotTarget) {
                           warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
                           warn$1("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding$1);
+                              "<template> syntax when there are other named slots.", slotBinding);
                       }
                   }
                   // add the component's children to its default slot
                   var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var ref$1 = getSlotName(slotBinding$1);
-                  var name$1 = ref$1.name;
-                  var dynamic$1 = ref$1.dynamic;
-                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name$1;
-                  slotContainer.slotTargetDynamic = dynamic$1;
-                  slotContainer.children = el.children.filter(function (c) {
+                  var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                  var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                  slotContainer_1.slotTarget = name_3;
+                  slotContainer_1.slotTargetDynamic = dynamic;
+                  slotContainer_1.children = el.children.filter(function (c) {
                       if (!c.slotScope) {
-                          c.parent = slotContainer;
+                          c.parent = slotContainer_1;
                           return true;
                       }
                   });
-                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -3036,7 +2660,7 @@
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: ("\"" + name + "\""), dynamic: false };
+              { name: "\"" + name + "\"", dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
@@ -3082,7 +2706,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                      warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -3096,14 +2720,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                               );
                           }
                       }
@@ -3180,11 +2804,11 @@
   function parseModifiers(name) {
       var match = name.match(modifierRE);
       if (match) {
-          var ret = {};
+          var ret_1 = {};
           match.forEach(function (m) {
-              ret[m.slice(1)] = true;
+              ret_1[m.slice(1)] = true;
           });
-          return ret;
+          return ret_1;
       }
   }
   function makeAttrsMap(attrs) {
@@ -3226,7 +2850,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+              warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -3243,16 +2867,16 @@
           if (!map['v-model']) {
               return;
           }
-          var typeBinding;
+          var typeBinding = void 0;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + (map['v-bind']) + ").type";
+              typeBinding = "(" + map['v-bind'] + ").type";
           }
           if (typeBinding) {
               var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+              var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
               var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
               var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
@@ -3298,19 +2922,19 @@
   function cloneASTElement(el) {
       return createASTElement(el.tag, el.attrsList.slice(), el.parent);
   }
-  var model = {
+  var model$1 = {
       preTransformNode: preTransformNode,
   };
 
-  var modules = [klass, style, model];
+  var modules = [klass, style, model$1];
 
   /* @flow */
-  var warn$2;
+  var warn;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
-  function model$1(el, dir, _warn) {
-      warn$2 = _warn;
+  function model(el, dir, _warn) {
+      warn = _warn;
       var value = dir.value;
       var modifiers = dir.modifiers;
       var tag = el.tag;
@@ -3319,7 +2943,7 @@
           // inputs with type="file" are read only and setting the input's
           // value will throw an error.
           if (tag === 'input' && type === 'file') {
-              warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+              warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                   "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
           }
       }
@@ -3340,17 +2964,11 @@
       else if (tag === 'input' || tag === 'textarea') {
           genDefaultModel(el, value, modifiers);
       }
-      else if (!config.isReservedTag(tag)) {
+      else {
           genComponentModel(el, value, modifiers);
           // component v-model doesn't need extra runtime
           return false;
       }
-      else {
-          warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-              "v-model is not supported on this element type. " +
-              "If you are working with contenteditable, it's recommended to " +
-              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-      }
       // ensure runtime directive metadata
       return true;
   }
@@ -3360,25 +2978,25 @@
       var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
       var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
       addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          "?_i(" + value + "," + valueBinding + ")>-1" +
+          ("?_i(" + value + "," + valueBinding + ")>-1") +
           (trueValueBinding === 'true'
-              ? (":(" + value + ")")
-              : (":_q(" + value + "," + trueValueBinding + ")")));
+              ? ":(" + value + ")"
+              : ":_q(" + value + "," + trueValueBinding + ")"));
       addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
-          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
           'if(Array.isArray($$a)){' +
-          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
           '$$i=_i($$a,$$v);' +
-          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
   }
   function genRadioModel(el, value, modifiers) {
       var number = modifiers && modifiers.number;
       var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
       addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
   }
   function genSelect(el, value, modifiers) {
@@ -3386,10 +3004,10 @@
       var selectedVal = "Array.prototype.filter" +
           ".call($event.target.options,function(o){return o.selected})" +
           ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          "return " + (number ? '_n(val)' : 'val') + "})";
+          ("return " + (number ? '_n(val)' : 'val') + "})");
       var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
       var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + (genAssignmentCode(value, assignment));
+      code = code + " " + genAssignmentCode(value, assignment);
       addHandler(el, 'change', code, null, true);
   }
   function genDefaultModel(el, value, modifiers) {
@@ -3397,18 +3015,15 @@
       // warn if v-bind:value conflicts with v-model
       // except for inputs with v-bind:type
       {
-          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
           var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value$1 && !typeBinding) {
+          if (value_1 && !typeBinding) {
               var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+              warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                   'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
           }
       }
-      var ref = modifiers || {};
-      var lazy = ref.lazy;
-      var number = ref.number;
-      var trim = ref.trim;
+      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
       var needCompositionGuard = !lazy && type !== 'range';
       var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
       var valueExpression = '$event.target.value';
@@ -3422,7 +3037,7 @@
       if (needCompositionGuard) {
           code = "if($event.target.composing)return;" + code;
       }
-      addProp(el, 'value', ("(" + value + ")"));
+      addProp(el, 'value', "(" + value + ")");
       addHandler(el, event, code, null, true);
       if (trim || number) {
           addHandler(el, 'blur', '$forceUpdate()');
@@ -3432,19 +3047,19 @@
   /* @flow */
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
   /* @flow */
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
       }
   }
 
   var directives = {
-      model: model$1,
+      model: model,
       text: text,
       html: html,
   };
@@ -3461,13 +3076,13 @@
       isReservedTag: isReservedTag,
       getTagNamespace: getTagNamespace,
       // @ts-ignore
-      staticKeys: genStaticKeys(modules),
+      staticKeys: genStaticKeys$1(modules),
   };
 
   /* @flow */
   var isStaticKey;
-  var isPlatformReservedTag;
-  var genStaticKeysCached = cached(genStaticKeys$1);
+  var isPlatformReservedTag$1;
+  var genStaticKeysCached = cached(genStaticKeys);
   /**
    * Goal of the optimizer: walk the generated template AST tree
    * and detect sub-trees that are purely static, i.e. parts of
@@ -3479,17 +3094,17 @@
    *    create fresh nodes for them on each re-render;
    * 2. Completely skip them in the patching process.
    */
-  function optimize(root, options) {
+  function optimize$1(root, options) {
       if (!root)
           { return; }
       isStaticKey = genStaticKeysCached(options.staticKeys || '');
-      isPlatformReservedTag = options.isReservedTag || no;
+      isPlatformReservedTag$1 = options.isReservedTag || no;
       // first pass: mark all non-static nodes.
       markStatic(root);
       // second pass: mark static roots.
       markStaticRoots(root, false);
   }
-  function genStaticKeys$1(keys) {
+  function genStaticKeys(keys) {
       return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
           (keys ? ',' + keys : ''));
   }
@@ -3499,7 +3114,7 @@
           // do not make component slot content static. this avoids
           // 1. components not able to mutate slot nodes
           // 2. static slot content fails for hot-reloading
-          if (!isPlatformReservedTag(node.tag) &&
+          if (!isPlatformReservedTag$1(node.tag) &&
               node.tag !== 'slot' &&
               node.attrsMap['inline-template'] == null) {
               return;
@@ -3512,8 +3127,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  var block = node.ifConditions[i$1].block;
+              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                  var block = node.ifConditions[i].block;
                   markStatic(block);
                   if (!block.static) {
                       node.static = false;
@@ -3545,8 +3160,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
+              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                  markStaticRoots(node.ifConditions[i].block, isInFor);
               }
           }
       }
@@ -3565,7 +3180,7 @@
               !node.if &&
               !node.for && // not v-if or v-for or v-else
               !isBuiltInTag(node.tag) && // not a built-in
-              isPlatformReservedTag(node.tag) && // not a component
+              isPlatformReservedTag$1(node.tag) && // not a component
               !isDirectChildOfTemplateFor(node) &&
               Object.keys(node).every(isStaticKey)));
   }
@@ -3617,7 +3232,7 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+  var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
   var modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
@@ -3634,19 +3249,19 @@
       var prefix = isNative ? 'nativeOn:' : 'on:';
       var staticHandlers = "";
       var dynamicHandlers = "";
-      for (var name in events) {
-          var handlerCode = genHandler(events[name]);
+      for (var name_1 in events) {
+          var handlerCode = genHandler(events[name_1]);
           //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += name + "," + handlerCode + ",";
+          if (events[name_1] && events[name_1].dynamic) {
+              dynamicHandlers += name_1 + "," + handlerCode + ",";
           }
           else {
-              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+              staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
           }
       }
-      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
       if (dynamicHandlers) {
-          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+          return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
       }
       else {
           return prefix + staticHandlers;
@@ -3657,7 +3272,7 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+          return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
       }
       var isMethodPath = simplePathRE.test(handler.value);
       var isFunctionExpression = fnExpRE.test(handler.value);
@@ -3666,13 +3281,13 @@
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+          return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
       }
       else {
           var code = '';
           var genModifierCode = '';
           var keys = [];
-          for (var key in handler.modifiers) {
+          var _loop_1 = function (key) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -3681,15 +3296,18 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers = handler.modifiers;
+                  var modifiers_1 = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                      .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                       .join('||'));
               }
               else {
                   keys.push(key);
               }
+          };
+          for (var key in handler.modifiers) {
+              _loop_1(key);
           }
           if (keys.length) {
               code += genKeyFilter(keys);
@@ -3699,13 +3317,13 @@
               code += genModifierCode;
           }
           var handlerCode = isMethodPath
-              ? ("return " + (handler.value) + ".apply(null, arguments)")
+              ? "return " + handler.value + ".apply(null, arguments)"
               : isFunctionExpression
-                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  ? "return (" + handler.value + ").apply(null, arguments)"
                   : isFunctionInvocation
-                      ? ("return " + (handler.value))
+                      ? "return " + handler.value
                       : handler.value;
-          return ("function($event){" + code + handlerCode + "}");
+          return "function($event){" + code + handlerCode + "}";
       }
   }
   function genKeyFilter(keys) {
@@ -3714,60 +3332,65 @@
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&')) + ")return null;");
+          (keys.map(genFilterCode).join('&&') + ")return null;"));
   }
   function genFilterCode(key) {
       var keyVal = parseInt(key, 10);
       if (keyVal) {
-          return ("$event.keyCode!==" + keyVal);
+          return "$event.keyCode!==" + keyVal;
       }
       var keyCode = keyCodes[key];
       var keyName = keyNames[key];
       return ("_k($event.keyCode," +
-          (JSON.stringify(key)) + "," +
-          (JSON.stringify(keyCode)) + "," +
+          (JSON.stringify(key) + ",") +
+          (JSON.stringify(keyCode) + ",") +
           "$event.key," +
-          "" + (JSON.stringify(keyName)) +
+          ("" + JSON.stringify(keyName)) +
           ")");
   }
 
   /* @flow */
   function on(el, dir) {
       if (dir.modifiers) {
-          warn("v-on without argument does not support modifiers.");
+          warn$2("v-on without argument does not support modifiers.");
       }
-      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+      el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
   /* @flow */
-  function bind$1(el, dir) {
+  function bind(el, dir) {
       el.wrapData = function (code) {
-          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+          return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
   /* @flow */
   var baseDirectives = {
       on: on,
-      bind: bind$1,
+      bind: bind,
       cloak: noop,
   };
 
   /* @flow */
-  var CodegenState = function CodegenState(options) {
-      this.options = options;
-      this.warn = options.warn || baseWarn;
-      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-      this.directives = extend(extend({}, baseDirectives), options.directives);
-      var isReservedTag = options.isReservedTag || no;
-      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-      this.onceId = 0;
-      this.staticRenderFns = [];
-      this.pre = false;
-  };
-  function generate(ast, options) {
+  var CodegenState = /** @class */ (function () {
+      function CodegenState(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          var isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = function (el) {
+              return !!el.component || !isReservedTag(el.tag);
+          };
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+      return CodegenState;
+  }());
+  function generate$1(ast, options) {
       var state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
       var code = ast
@@ -3776,7 +3399,7 @@
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: ("with(this){return " + code + "}"),
+          render: "with(this){return " + code + "}",
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -3804,17 +3427,19 @@
       }
       else {
           // component or element
-          var code;
+          var code = void 0;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data;
+              var data = void 0;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData$2(el, state);
+                  data = genData(el, state);
               }
               var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+              code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+              ) + (children ? "," + children : '' // children
+              ) + ")";
           }
           // module transforms
           for (var i = 0; i < state.transforms.length; i++) {
@@ -3833,9 +3458,9 @@
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
       state.pre = originalPreState;
-      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+      return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
   }
   // v-once
   function genOnce(el, state) {
@@ -3845,19 +3470,19 @@
       }
       else if (el.staticInFor) {
           var key = '';
-          var parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
+          var parent_1 = el.parent;
+          while (parent_1) {
+              if (parent_1.for) {
+                  key = parent_1.key;
                   break;
               }
-              parent = parent.parent;
+              parent_1 = parent_1.parent;
           }
           if (!key) {
               state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+          return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
       }
       else {
           return genStatic(el, state);
@@ -3873,10 +3498,10 @@
       }
       var condition = conditions.shift();
       if (condition.exp) {
-          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+          return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
       }
       else {
-          return ("" + (genTernaryExp(condition.block)));
+          return "" + genTernaryExp(condition.block);
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -3890,23 +3515,23 @@
   function genFor(el, state, altGen, altHelper) {
       var exp = el.for;
       var alias = el.alias;
-      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+      var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+          state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
               "v-for should have explicit keys. " +
               "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ((altHelper || '_l') + "((" + exp + ")," +
-          "function(" + alias + iterator1 + iterator2 + "){" +
-          "return " + ((altGen || genElement)(el, state)) +
+          ("function(" + alias + iterator1 + iterator2 + "){") +
+          ("return " + (altGen || genElement)(el, state)) +
           '})');
   }
-  function genData$2(el, state) {
+  function genData(el, state) {
       var data = '{';
       // directives first.
       // directives may mutate the el's other properties before they are generated.
@@ -3915,11 +3540,11 @@
           { data += dirs + ','; }
       // key
       if (el.key) {
-          data += "key:" + (el.key) + ",";
+          data += "key:" + el.key + ",";
       }
       // ref
       if (el.ref) {
-          data += "ref:" + (el.ref) + ",";
+          data += "ref:" + el.ref + ",";
       }
       if (el.refInFor) {
           data += "refInFor:true,";
@@ -3930,7 +3555,7 @@
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + (el.tag) + "\",";
+          data += "tag:\"" + el.tag + "\",";
       }
       // module data generation functions
       for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -3938,31 +3563,31 @@
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + (genProps(el.attrs)) + ",";
+          data += "attrs:" + genProps(el.attrs) + ",";
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + (genProps(el.props)) + ",";
+          data += "domProps:" + genProps(el.props) + ",";
       }
       // event handlers
       if (el.events) {
-          data += (genHandlers(el.events, false)) + ",";
+          data += genHandlers(el.events, false) + ",";
       }
       if (el.nativeEvents) {
-          data += (genHandlers(el.nativeEvents, true)) + ",";
+          data += genHandlers(el.nativeEvents, true) + ",";
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + (el.slotTarget) + ",";
+          data += "slot:" + el.slotTarget + ",";
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+          data += genScopedSlots(el, el.scopedSlots, state) + ",";
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+          data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
       }
       // inline-template
       if (el.inlineTemplate) {
@@ -3976,7 +3601,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+          data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -4006,9 +3631,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+              res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                  ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                  : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
           }
       }
       if (hasRuntime) {
@@ -4017,14 +3642,14 @@
   }
   function genInlineTemplate(el, state) {
       var ast = el.children[0];
-      if (el.children.length !== 1 || ast.type !== 1) {
+      if ((el.children.length !== 1 || ast.type !== 1)) {
           state.warn('Inline-template components must have exactly one child element.', { start: el.start });
       }
       if (ast && ast.type === 1) {
-          var inlineRenderFns = generate(ast, state.options);
-          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-              .map(function (code) { return ("function(){" + code + "}"); })
-              .join(',')) + "]}");
+          var inlineRenderFns = generate$1(ast, state.options);
+          return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+              .map(function (code) { return "function(){" + code + "}"; })
+              .join(',') + "]}";
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -4049,23 +3674,23 @@
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
+          var parent_2 = el.parent;
+          while (parent_2) {
+              if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                  parent_2.for) {
                   needsForceUpdate = true;
                   break;
               }
-              if (parent.if) {
+              if (parent_2.if) {
                   needsKey = true;
               }
-              parent = parent.parent;
+              parent_2 = parent_2.parent;
           }
       }
       var generatedSlots = Object.keys(slots)
           .map(function (key) { return genScopedSlot(slots[key], state); })
           .join(',');
-      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+      return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
   }
   function hash(str) {
       var hash = 5381;
@@ -4094,36 +3719,36 @@
       }
       var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
       var fn = "function(" + slotScope + "){" +
-          "return " + (el.tag === 'template'
+          ("return " + (el.tag === 'template'
               ? el.if && isLegacySyntax
-                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                  ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                   : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}";
+              : genElement(el, state)) + "}");
       // reverse proxy v-slot without scope on this.$slots
       var reverseProxy = slotScope ? "" : ",proxy:true";
-      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+      return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
       var children = el.children;
       if (children.length) {
-          var el$1 = children[0];
+          var el_1 = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el$1.for &&
-              el$1.tag !== 'template' &&
-              el$1.tag !== 'slot') {
-              var normalizationType = checkSkip
-                  ? state.maybeComponent(el$1)
+              el_1.for &&
+              el_1.tag !== 'template' &&
+              el_1.tag !== 'slot') {
+              var normalizationType_1 = checkSkip
+                  ? state.maybeComponent(el_1)
                       ? ",1"
                       : ",0"
                   : "";
-              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+              return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
           }
-          var normalizationType$1 = checkSkip
+          var normalizationType = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen = altGenNode || genNode;
-          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+          var gen_1 = altGenNode || genNode;
+          return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
       }
   }
   // determine the normalization needed for the children array.
@@ -4165,17 +3790,17 @@
       }
   }
   function genText(text) {
-      return ("_v(" + (text.type === 2
+      return "_v(" + (text.type === 2
           ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
   }
   function genComment(comment) {
-      return ("_e(" + (JSON.stringify(comment.text)) + ")");
+      return "_e(" + JSON.stringify(comment.text) + ")";
   }
   function genSlot(el, state) {
       var slotName = el.slotName || '"default"';
       var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? ("," + children) : '');
+      var res = "_t(" + slotName + (children ? "," + children : '');
       var attrs = el.attrs || el.dynamicAttrs
           ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
               // slot props are camelized
@@ -4184,22 +3809,22 @@
               dynamic: attr.dynamic,
           }); }))
           : null;
-      var bind$$1 = el.attrsMap['v-bind'];
-      if ((attrs || bind$$1) && !children) {
+      var bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
           res += ",null";
       }
       if (attrs) {
           res += "," + attrs;
       }
-      if (bind$$1) {
-          res += (attrs ? '' : ',null') + "," + bind$$1;
+      if (bind) {
+          res += (attrs ? '' : ',null') + "," + bind;
       }
       return res + ')';
   }
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
       var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+      return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
   }
   function genProps(props) {
       var staticProps = "";
@@ -4208,15 +3833,15 @@
           var prop = props[i];
           var value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += (prop.name) + "," + value + ",";
+              dynamicProps += prop.name + "," + value + ",";
           }
           else {
-              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+              staticProps += "\"" + prop.name + "\":" + value + ",";
           }
       }
-      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      staticProps = "{" + staticProps.slice(0, -1) + "}";
       if (dynamicProps) {
-          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+          return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
       }
       else {
           return staticProps;
@@ -4251,22 +3876,22 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  var value = node.attrsMap[name];
+          for (var name_1 in node.attrsMap) {
+              if (dirRE.test(name_1)) {
+                  var value = node.attrsMap[name_1];
                   if (value) {
-                      var range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                      var range = node.rawAttrsMap[name_1];
+                      if (name_1 === 'v-for') {
+                          checkFor(node, "v-for=\"" + value + "\"", warn, range);
                       }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                      else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                          checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                      else if (onRE.test(name_1)) {
+                          checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
                       else {
-                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                          checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                       }
                   }
               }
@@ -4286,7 +3911,7 @@
       var keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
           warn("avoid using JavaScript unary operator as property name: " +
-              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+              ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -4299,16 +3924,16 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function(("var " + ident + "=_"));
+              new Function("var " + ident + "=_");
           }
           catch (e) {
-              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+              warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function(("return " + exp));
+          new Function("return " + exp);
       }
       catch (e) {
           var keywordMatch = exp
@@ -4316,12 +3941,12 @@
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
               warn("avoid using JavaScript keyword as property name: " +
-                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                  ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
           }
           else {
-              warn("invalid expression: " + (e.message) + " in\n\n" +
-                  "    " + exp + "\n\n" +
-                  "  Raw expression: " + (text.trim()) + "\n", range);
+              warn("invalid expression: " + e.message + " in\n\n" +
+                  ("    " + exp + "\n\n") +
+                  ("  Raw expression: " + text.trim() + "\n"), range);
           }
       }
   }
@@ -4330,18 +3955,17 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-              "    " + exp + "\n\n" +
-              "  Raw expression: " + (text.trim()) + "\n", range);
+          warn("invalid function parameter expression: " + e.message + " in\n\n" +
+              ("    " + exp + "\n\n") +
+              ("  Raw expression: " + text.trim() + "\n"), range);
       }
   }
 
   /* @flow */
   var range = 2;
   function generateCodeFrame(source, start, end) {
-      if ( start === void 0 ) start = 0;
-      if ( end === void 0 ) end = source.length;
-
+      if (start === void 0) { start = 0; }
+      if (end === void 0) { end = source.length; }
       var lines = source.split(/\r?\n/);
       var count = 0;
       var res = [];
@@ -4351,18 +3975,18 @@
               for (var j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
                       { continue; }
-                  res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                  res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                   var lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
                       var pad = start - (count - lineLength) + 1;
-                      var length = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                      var length_1 = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length$1 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat$1("^", length$1));
+                          var length_2 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat("^", length_2));
                       }
                       count += lineLength + 1;
                   }
@@ -4372,7 +3996,7 @@
       }
       return res.join('\n');
   }
-  function repeat$1(str, n) {
+  function repeat(str, n) {
       var result = '';
       if (n > 0) {
           while (true) {
@@ -4402,7 +4026,7 @@
       var cache = Object.create(null);
       return function compileToFunctions(template, options, vm) {
           options = extend({}, options);
-          var warn$$1 = options.warn || warn;
+          var warn = options.warn || warn$2;
           delete options.warn;
           /* istanbul ignore if */
           {
@@ -4412,7 +4036,7 @@
               }
               catch (e) {
                   if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
                           'environment with Content Security Policy that prohibits unsafe-eval. ' +
                           'The template compiler cannot work in this environment. Consider ' +
                           'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -4434,13 +4058,13 @@
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
                       compiled.errors.forEach(function (e) {
-                          warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                          warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
-                      warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                      warn("Error compiling template:\n\n" + template + "\n\n" +
+                          compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                           '\n', vm);
                   }
               }
@@ -4466,14 +4090,12 @@
           /* istanbul ignore if */
           {
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn$$1("Failed to generate render function:\n\n" +
+                  warn("Failed to generate render function:\n\n" +
                       fnGenErrors
-                          .map(function (ref) {
-                              var err = ref.err;
-                              var code = ref.code;
-
-                              return ((err.toString()) + " in\n\n" + code + "\n");
-                  })
+                          .map(function (_a) {
+                          var err = _a.err, code = _a.code;
+                          return err.toString() + " in\n\n" + code + "\n";
+                      })
                           .join('\n'), vm);
               }
           }
@@ -4494,15 +4116,15 @@
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                       warn = function (msg, range, tip) {
                           var data = { msg: msg };
                           if (range) {
                               if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
+                                  data.start = range.start + leadingSpaceLength_1;
                               }
                               if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
+                                  data.end = range.end + leadingSpaceLength_1;
                               }
                           }
                           (tip ? tips : errors).push(data);
@@ -4543,12 +4165,12 @@
   // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
-  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+  var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
       var ast = parse(template.trim(), options);
       if (options.optimize !== false) {
-          optimize(ast, options);
+          optimize$1(ast, options);
       }
-      var code = generate(ast, options);
+      var code = generate$1(ast, options);
       return {
           ast: ast,
           render: code.render,
@@ -4557,9 +4179,7 @@
   });
 
   /* @flow */
-  var ref = createCompiler(baseOptions);
-  var compile = ref.compile;
-  var compileToFunctions = ref.compileToFunctions;
+  var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
 
   /* @flow */
   var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
@@ -4618,19 +4238,15 @@
       }
   }
   function genAttrSegments(attrs) {
-      return attrs.map(function (ref) {
-          var name = ref.name;
-          var value = ref.value;
-
+      return attrs.map(function (_a) {
+          var name = _a.name, value = _a.value;
           return genAttrSegment(name, value);
       });
   }
   function genDOMPropSegments(props, attrs) {
       var segments = [];
-      props.forEach(function (ref) {
-          var name = ref.name;
-          var value = ref.value;
-
+      props.forEach(function (_a) {
+          var name = _a.name, value = _a.value;
           name = propsToAttrMap[name] || name.toLowerCase();
           if (isRenderableAttr(name) &&
               !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -4650,42 +4266,42 @@
           return {
               type: RAW,
               value: isBooleanAttr(name)
-                  ? (" " + name + "=\"" + name + "\"")
+                  ? " " + name + "=\"" + name + "\""
                   : value === '""'
-                      ? (" " + name)
-                      : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+                      ? " " + name
+                      : " " + name + "=\"" + JSON.parse(value) + "\"",
           };
       }
       else {
           return {
               type: EXPRESSION,
-              value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+              value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
           };
       }
   }
   function genClassSegments(staticClass, classBinding) {
       if (staticClass && !classBinding) {
-          return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
+          return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+                  value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
               } ];
       }
   }
   function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
       if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+          return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                      ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-                      : 'null') + ")"),
+                  value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                      ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
+                      : 'null') + ")",
               } ];
       }
   }
@@ -4699,11 +4315,11 @@
       CHILDREN: 3,
       PARTIAL: 4, // self un-optimizable with some un-optimizable children
   };
-  var isPlatformReservedTag$1;
-  function optimize$1(root, options) {
+  var isPlatformReservedTag;
+  function optimize(root, options) {
       if (!root)
           { return; }
-      isPlatformReservedTag$1 = options.isReservedTag || no;
+      isPlatformReservedTag = options.isReservedTag || no;
       walk(root, true);
   }
   function walk(node, isRoot) {
@@ -4730,8 +4346,8 @@
               check(child);
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  var block = node.ifConditions[i$1].block;
+              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                  var block = node.ifConditions[i].block;
                   walk(block, isRoot);
                   check(block);
               }
@@ -4788,7 +4404,7 @@
           return false;
       }
       return (isBuiltInTag(node.tag) || // built-in (slot, component)
-          !isPlatformReservedTag$1(node.tag) || // custom component
+          !isPlatformReservedTag(node.tag) || // custom component
           !!node.component || // "is" component
           isSelectWithModel(node) // <select v-model> requires runtime inspection
       );
@@ -4813,11 +4429,11 @@
   var RAW = 0;
   var INTERPOLATION = 1;
   var EXPRESSION = 2;
-  function generate$1(ast, options) {
+  function generate(ast, options) {
       var state = new CodegenState(options);
       var code = ast ? genSSRElement(ast, state) : '_c("div")';
       return {
-          render: ("with(this){return " + code + "}"),
+          render: "with(this){return " + code + "}",
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -4852,11 +4468,11 @@
       }
   }
   function genNormalElement(el, state, stringifyChildren) {
-      var data = el.plain ? undefined : genData$2(el, state);
+      var data = el.plain ? undefined : genData(el, state);
       var children = stringifyChildren
-          ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+          ? "[" + genChildrenAsStringNode(el, state) + "]"
           : genSSRChildren(el, state, true);
-      return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+      return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
   }
   function genSSRChildren(el, state, checkSkip) {
       return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -4866,18 +4482,18 @@
   }
   function genChildrenAsStringNode(el, state) {
       return el.children.length
-          ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+          ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
           : '';
   }
   function genStringElement(el, state) {
-      return ("_ssrNode(" + (elementToString(el, state)) + ")");
+      return "_ssrNode(" + elementToString(el, state) + ")";
   }
   function genStringElementWithChildren(el, state) {
       var children = genSSRChildren(el, state, true);
-      return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+      return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
   }
   function elementToString(el, state) {
-      return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+      return "(" + flattenSegments(elementToSegments(el, state)) + ")";
   }
   function elementToSegments(el, state) {
       // v-for / v-if
@@ -4902,17 +4518,16 @@
       }
       var openSegments = elementToOpenTagSegments(el, state);
       var childrenSegments = childrenToSegments(el, state);
-      var ref = state.options;
-      var isUnaryTag = ref.isUnaryTag;
+      var isUnaryTag = state.options.isUnaryTag;
       var close = isUnaryTag && isUnaryTag(el.tag)
           ? []
-          : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+          : [{ type: RAW, value: "</" + el.tag + ">" }];
       return openSegments.concat(childrenSegments, close);
   }
   function elementToOpenTagSegments(el, state) {
       applyModelTransform(el, state);
       var binding;
-      var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+      var segments = [{ type: RAW, value: "<" + el.tag }];
       // attrs
       if (el.attrs) {
           segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -4923,11 +4538,11 @@
       }
       // v-bind="object"
       if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+          segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
       }
       // v-bind.prop="object"
       if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+          segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
       }
       // class
       if (el.staticClass || el.classBinding) {
@@ -4939,7 +4554,7 @@
       }
       // _scopedId
       if (state.options.scopeId) {
-          segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+          segments.push({ type: RAW, value: " " + state.options.scopeId });
       }
       segments.push({ type: RAW, value: ">" });
       return segments;
@@ -4947,13 +4562,13 @@
   function childrenToSegments(el, state) {
       var binding;
       if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+          return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
       }
       if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
       }
       if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
       }
       return el.children ? nodesToSegments(el.children, state) : [];
   }
@@ -4993,11 +4608,11 @@
           }
           else if (s.type === INTERPOLATION) {
               pushBuffer();
-              mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+              mergedSegments.push("_ssrEscape(" + s.value + ")");
           }
           else if (s.type === EXPRESSION) {
               pushBuffer();
-              mergedSegments.push(("(" + (s.value) + ")"));
+              mergedSegments.push("(" + s.value + ")");
           }
       }
       pushBuffer();
@@ -5005,10 +4620,10 @@
   }
 
   /* @flow */
-  var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
       var ast = parse(template.trim(), options);
-      optimize$1(ast, options);
-      var code = generate$1(ast, options);
+      optimize(ast, options);
+      var code = generate(ast, options);
       return {
           ast: ast,
           render: code.render,
@@ -5017,19 +4632,15 @@
   });
 
   /* @flow */
-  var ref$1 = createCompiler$1(baseOptions);
-  var compile$1 = ref$1.compile;
-  var compileToFunctions$1 = ref$1.compileToFunctions;
-
-  /* @flow */
+  var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
 
-  exports.parseComponent = parseComponent;
-  exports.compile = compile;
-  exports.compileToFunctions = compileToFunctions;
-  exports.ssrCompile = compile$1;
-  exports.ssrCompileToFunctions = compileToFunctions$1;
+  exports.compile = compile$1;
+  exports.compileToFunctions = compileToFunctions$1;
   exports.generateCodeFrame = generateCodeFrame;
+  exports.parseComponent = parseComponent;
+  exports.ssrCompile = compile;
+  exports.ssrCompileToFunctions = compileToFunctions;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-}));
+})));
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index ea282103df3..918d9f87013 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -2,10 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+var deindent = require('de-indent');
 
-var deindent = _interopDefault(require('de-indent'));
-var he = require('he');
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
 
 /* @flow */
 var emptyObject = Object.freeze({});
@@ -72,7 +73,7 @@ var isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
@@ -115,31 +116,6 @@ var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        var l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Mix properties into target object.
  */
@@ -168,7 +144,7 @@ var identity = function (_) { return _; };
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys(modules) {
+function genStaticKeys$1(modules) {
     return modules
         .reduce(function (keys, m) {
         return keys.concat(m.staticKeys || []);
@@ -215,11 +191,11 @@ function def(obj, key, val, enumerable) {
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
+var startTagOpen = new RegExp("^<" + qnameCapture);
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -240,7 +216,9 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+};
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -248,11 +226,11 @@ function decodeAttr(value, shouldDecodeNewlines) {
 function parseHTML(html, options) {
     var stack = [];
     var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
+    var isUnaryTag = options.isUnaryTag || no;
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    while (html) {
+    var _loop_1 = function () {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -266,7 +244,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        continue;
+                        return "continue";
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -274,14 +252,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        continue;
+                        return "continue";
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    continue;
+                    return "continue";
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -289,7 +267,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
+                    return "continue";
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -298,10 +276,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    continue;
+                    return "continue";
                 }
             }
-            var text = (void 0), rest = (void 0), next = (void 0);
+            var text = void 0, rest = void 0, next = void 0;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -328,18 +306,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength = 0;
-            var stackedTag = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+            var endTagLength_1 = 0;
+            var stackedTag_1 = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag_1] ||
+                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+            var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength_1 = endTag.length;
+                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -347,21 +325,26 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest$1.length;
-            html = rest$1;
-            parseEndTag(stackedTag, index - endTagLength, index);
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag_1, index - endTagLength_1, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (process.env.NODE_ENV !== 'production' &&
                 !stack.length &&
                 options.warn) {
-                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
                     start: index + html.length,
                 });
             }
-            break;
+            return "break";
         }
+    };
+    while (html) {
+        var state_1 = _loop_1();
+        if (state_1 === "break")
+            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -378,7 +361,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end, attr;
+            var end = void 0, attr = void 0;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -401,11 +384,11 @@ function parseHTML(html, options) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
             }
-            if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag$$1(tagName) || !!unarySlash;
+        var unary = isUnaryTag(tagName) || !!unarySlash;
         var l = match.attrs.length;
         var attrs = new Array(l);
         for (var i = 0; i < l; i++) {
@@ -462,7 +445,7 @@ function parseHTML(html, options) {
                 if (process.env.NODE_ENV !== 'production' &&
                     (i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -499,8 +482,7 @@ var isSpecialTag = makeMap('script,style,template', true);
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
 function parseComponent(content, options) {
-    if ( options === void 0 ) options = {};
-
+    if (options === void 0) { options = {}; }
     var sfc = {
         template: null,
         script: null,
@@ -531,10 +513,8 @@ function parseComponent(content, options) {
                 type: tag,
                 content: '',
                 start: end,
-                attrs: attrs.reduce(function (cumulated, ref) {
-                    var name = ref.name;
-                    var value = ref.value;
-
+                attrs: attrs.reduce(function (cumulated, _a) {
+                    var name = _a.name, value = _a.value;
                     cumulated[name] = value || true;
                     return cumulated;
                 }, {}),
@@ -580,7 +560,7 @@ function parseComponent(content, options) {
             var text = content.slice(currentBlock.start, currentBlock.end);
             if (options.deindent !== false) {
                 //@ts-expect-error
-                text = deindent(text);
+                text = deindent__default['default'](text);
             }
             // pad content so that linters and pre-processors can output correct
             // line numbers in errors and warnings
@@ -624,21 +604,24 @@ typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
 var nativeWatch = {}.watch;
+var supportsPassive = false;
 if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get: function () {
+                /* istanbul ignore next */
+                supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
         // @ts-ignore
@@ -664,9 +647,6 @@ var isServerRendering = function () {
     }
     return _isServer;
 };
-// detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
@@ -675,29 +655,24 @@ var hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
+    /** @class */ ((function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function has (key) {
+        Set.prototype.has = function (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function add (key) {
+        Set.prototype.add = function (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function clear () {
+        Set.prototype.clear = function () {
             this.set = Object.create(null);
         };
-
         return Set;
-    }());
+    })());
 }
 
 var ASSET_TYPES = ['component', 'directive', 'filter'];
@@ -795,22 +770,24 @@ var config = {
 };
 
 /* @flow */
-var warn = noop;
+var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn = function (msg, vm) {
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+        if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole && !config.silent) {
+        if (hasConsole_1 && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -833,10 +810,10 @@ if (process.env.NODE_ENV !== 'production') {
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
     };
-    var repeat = function (str, n) {
+    var repeat_1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -870,13 +847,15 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return "\n\n(found in " + formatComponentName(vm) + ")";
         }
     };
 }
@@ -886,73 +865,79 @@ var uid = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
-    }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid++;
+        this.subs = [];
     }
-};
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 
 /*
  * not type checking this file because flow doesn't play well with
@@ -975,9 +960,12 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
+        var arguments$1 = arguments;
 
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -999,54 +987,52 @@ methodsToPatch.forEach(function (method) {
 });
 
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-var shouldObserve = true;
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
     }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive$$1(obj, keys[i]);
-    }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
-    }
-};
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -1081,8 +1067,7 @@ function observe(value, asRootData) {
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
-    else if (shouldObserve &&
-        !isServerRendering() &&
+    else if (!isServerRendering() &&
         (Array.isArray(value) || isPlainObject(value)) &&
         Object.isExtensible(value) &&
         !value._isVue) {
@@ -1096,7 +1081,7 @@ function observe(value, asRootData) {
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1(obj, key, val, customSetter, shallow) {
+function defineReactive(obj, key, val, customSetter, shallow) {
     var dep = new Dep();
     var property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -1157,7 +1142,7 @@ function defineReactive$$1(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -1172,7 +1157,7 @@ function set(target, key, val) {
     // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
-            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
         return val;
     }
@@ -1180,7 +1165,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    defineReactive$$1(ob.value, key, val);
+    defineReactive(ob.value, key, val);
     ob.dep.notify();
     return val;
 }
@@ -1189,7 +1174,7 @@ function set(target, key, val) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1211,7 +1196,7 @@ var strats = config.optionMergeStrategies;
 if (process.env.NODE_ENV !== 'production') {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
+            warn$2("option \"" + key + "\" can only be used during instance " +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1288,7 +1273,7 @@ strats.data = function (parentVal, childVal, vm) {
     if (!vm) {
         if (childVal && typeof childVal !== 'function') {
             process.env.NODE_ENV !== 'production' &&
-                warn('The "data" option should be a function ' +
+                warn$2('The "data" option should be a function ' +
                     'that returns a per-instance value in component ' +
                     'definitions.', vm);
             return parentVal;
@@ -1366,14 +1351,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key$1] = parent
-            ? parent.concat(child)
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1404,13 +1389,11 @@ var defaultStrat = function (parentVal, childVal) {
 };
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
     }
 }
 
-/* @flow */
-
 /* @flow */
 var callbacks = [];
 function flushCallbacks() {
@@ -1436,21 +1419,20 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
+    var counter_1 = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
         characterData: true,
     });
 }
 else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/* @flow */
+else ;
 
 /* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+makeMap('style,class');
 // attributes that should be using props for binding
 var acceptValue = makeMap('input,textarea,option,select,progress');
 var mustUseProp = function (tag, type, attr) {
@@ -1460,7 +1442,7 @@ var mustUseProp = function (tag, type, attr) {
         (attr === 'muted' && tag === 'video'));
 };
 var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+makeMap('events,caret,typing,plaintext-only');
 var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
@@ -1468,8 +1450,6 @@ var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,co
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
 
-/* @flow */
-
 /* @flow */
 var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
@@ -1501,9 +1481,7 @@ function getTagNamespace(tag) {
         return 'math';
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/* @flow */
+makeMap('text,number,password,search,email,tel,url');
 
 /* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
@@ -1584,7 +1562,9 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p = (void 0);
+                var p 
+                // find first non-whitespace prev char
+                = void 0;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -1618,12 +1598,12 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return ("_f(\"" + filter + "\")(" + exp + ")");
+        return "_f(\"" + filter + "\")(" + exp + ")";
     }
     else {
-        var name = filter.slice(0, i);
+        var name_1 = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
     }
 }
 
@@ -1654,7 +1634,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push(("_s(" + exp + ")"));
+        tokens.push("_s(" + exp + ")");
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -1671,7 +1651,7 @@ function parseText(text, delimiters) {
 /* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+    console.error("[Vue compiler]: " + msg);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -1705,7 +1685,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -1837,7 +1817,7 @@ function rangeSetItem(item, range) {
 }
 
 /* @flow */
-function transformNode(el, options) {
+function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
     if (process.env.NODE_ENV !== 'production' && staticClass) {
@@ -1857,20 +1837,20 @@ function transformNode(el, options) {
         el.classBinding = classBinding;
     }
 }
-function genData(el) {
+function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + (el.staticClass) + ",";
+        data += "staticClass:" + el.staticClass + ",";
     }
     if (el.classBinding) {
-        data += "class:" + (el.classBinding) + ",";
+        data += "class:" + el.classBinding + ",";
     }
     return data;
 }
 var klass = {
     staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData,
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
 /* @flow */
@@ -1888,7 +1868,7 @@ var parseStyleText = cached(function (cssText) {
 });
 
 /* @flow */
-function transformNode$1(el, options) {
+function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
@@ -1912,16 +1892,16 @@ function transformNode$1(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + (el.staticStyle) + ",";
+        data += "staticStyle:" + el.staticStyle + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + (el.styleBinding) + "),";
+        data += "style:(" + el.styleBinding + "),";
     }
     return data;
 }
 var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
+    transformNode: transformNode,
     genData: genData$1,
 };
 
@@ -1930,25 +1910,23 @@ var style = {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                "? " + baseValueExpression + ".trim()" +
-                ": " + baseValueExpression + ")";
+                ("? " + baseValueExpression + ".trim()") +
+                (": " + baseValueExpression + ")");
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: ("(" + value + ")"),
+        value: "(" + value + ")",
         expression: JSON.stringify(value),
-        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
     };
 }
 /**
@@ -1957,10 +1935,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return (value + "=" + assignment);
+        return value + "=" + assignment;
     }
     else {
-        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
     }
 }
 /**
@@ -2054,6 +2032,7 @@ function parseString(chr) {
 }
 
 /* @flow */
+var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -2150,8 +2129,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                    var name_1 = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -2177,7 +2156,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode;
+            var lastNode = void 0;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -2187,7 +2166,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -2204,7 +2183,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function start(tag, attrs, unary, start$1, end) {
+        start: function (tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -2219,7 +2198,7 @@ function parse(template, options) {
             }
             if (process.env.NODE_ENV !== 'production') {
                 if (options.outputSourceRange) {
-                    element.start = start$1;
+                    element.start = start;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -2241,7 +2220,7 @@ function parse(template, options) {
                 process.env.NODE_ENV !== 'production' &&
                     warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        "<" + tag + ">" +
+                        ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -2280,24 +2259,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function end(tag, start, end$1) {
+        end: function (tag, start, end) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end$1;
+                element.end = end;
             }
             closeElement(element);
         },
-        chars: function chars(text, start, end) {
+        chars: function (text, start, end) {
             if (!currentParent) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
+                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
                             start: start,
                         });
                     }
@@ -2337,8 +2316,8 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res;
-                var child;
+                var res = void 0;
+                var child = void 0;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -2365,7 +2344,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function comment(text, start, end) {
+        comment: function (text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -2436,11 +2415,11 @@ function processKey(el) {
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent = el.parent;
+                var parent_1 = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
+                    parent_1 &&
+                    parent_1.tag === 'transition-group') {
                     warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
@@ -2464,7 +2443,7 @@ function processFor(el) {
             extend(el, res);
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -2517,7 +2496,7 @@ function processIfConditions(el, parent) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -2528,7 +2507,7 @@ function findPrevElement(children) {
         }
         else {
             if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -2542,8 +2521,8 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
+    var once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
         el.once = true;
     }
 }
@@ -2565,7 +2544,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -2597,45 +2576,41 @@ function processSlotContent(el) {
                             "the receiving component", el);
                     }
                 }
-                var ref = getSlotName(slotBinding);
-                var name = ref.name;
-                var dynamic = ref.dynamic;
-                el.slotTarget = name;
+                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                el.slotTarget = name_2;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding$1) {
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
                         warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
                         warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding$1);
+                            "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var ref$1 = getSlotName(slotBinding$1);
-                var name$1 = ref$1.name;
-                var dynamic$1 = ref$1.dynamic;
-                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name$1;
-                slotContainer.slotTargetDynamic = dynamic$1;
-                slotContainer.children = el.children.filter(function (c) {
+                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                slotContainer_1.slotTarget = name_3;
+                slotContainer_1.slotTargetDynamic = dynamic;
+                slotContainer_1.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer;
+                        c.parent = slotContainer_1;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -2658,7 +2633,7 @@ function getSlotName(binding) {
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: ("\"" + name + "\""), dynamic: false };
+            { name: "\"" + name + "\"", dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
@@ -2705,7 +2680,7 @@ function processAttrs(el) {
                 }
                 if (process.env.NODE_ENV !== 'production' &&
                     value.trim().length === 0) {
-                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -2719,14 +2694,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -2803,11 +2778,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret = {};
+        var ret_1 = {};
         match.forEach(function (m) {
-            ret[m.slice(1)] = true;
+            ret_1[m.slice(1)] = true;
         });
-        return ret;
+        return ret_1;
     }
 }
 function makeAttrsMap(attrs) {
@@ -2850,7 +2825,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -2867,16 +2842,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding;
+        var typeBinding = void 0;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + (map['v-bind']) + ").type";
+            typeBinding = "(" + map['v-bind'] + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
+            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -2922,19 +2897,19 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model = {
+var model$1 = {
     preTransformNode: preTransformNode,
 };
 
-var modules = [klass, style, model];
+var modules = [klass, style, model$1];
 
 /* @flow */
-var warn$2;
+var warn;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
-function model$1(el, dir, _warn) {
-    warn$2 = _warn;
+function model(el, dir, _warn) {
+    warn = _warn;
     var value = dir.value;
     var modifiers = dir.modifiers;
     var tag = el.tag;
@@ -2943,7 +2918,7 @@ function model$1(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn$2("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -2964,17 +2939,11 @@ function model$1(el, dir, _warn) {
     else if (tag === 'input' || tag === 'textarea') {
         genDefaultModel(el, value, modifiers);
     }
-    else if (!config.isReservedTag(tag)) {
+    else {
         genComponentModel(el, value, modifiers);
         // component v-model doesn't need extra runtime
         return false;
     }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$2("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
     // ensure runtime directive metadata
     return true;
 }
@@ -2984,25 +2953,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        "?_i(" + value + "," + valueBinding + ")>-1" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
         (trueValueBinding === 'true'
-            ? (":(" + value + ")")
-            : (":_q(" + value + "," + trueValueBinding + ")")));
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
         'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
         '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -3010,10 +2979,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        "return " + (number ? '_n(val)' : 'val') + "})";
+        ("return " + (number ? '_n(val)' : 'val') + "})");
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
+    code = code + " " + genAssignmentCode(value, assignment);
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -3021,18 +2990,15 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     if (process.env.NODE_ENV !== 'production') {
-        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value$1 && !typeBinding) {
+        if (value_1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$2(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
+            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -3046,7 +3012,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', ("(" + value + ")"));
+    addProp(el, 'value', "(" + value + ")");
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -3056,19 +3022,19 @@ function genDefaultModel(el, value, modifiers) {
 /* @flow */
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
 /* @flow */
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
     }
 }
 
 var directives = {
-    model: model$1,
+    model: model,
     text: text,
     html: html,
 };
@@ -3085,13 +3051,13 @@ var baseOptions = {
     isReservedTag: isReservedTag,
     getTagNamespace: getTagNamespace,
     // @ts-ignore
-    staticKeys: genStaticKeys(modules),
+    staticKeys: genStaticKeys$1(modules),
 };
 
 /* @flow */
 var isStaticKey;
-var isPlatformReservedTag;
-var genStaticKeysCached = cached(genStaticKeys$1);
+var isPlatformReservedTag$1;
+var genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -3103,17 +3069,17 @@ var genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize(root, options) {
+function optimize$1(root, options) {
     if (!root)
         { return; }
     isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
+    isPlatformReservedTag$1 = options.isReservedTag || no;
     // first pass: mark all non-static nodes.
     markStatic(root);
     // second pass: mark static roots.
     markStaticRoots(root, false);
 }
-function genStaticKeys$1(keys) {
+function genStaticKeys(keys) {
     return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
         (keys ? ',' + keys : ''));
 }
@@ -3123,7 +3089,7 @@ function markStatic(node) {
         // do not make component slot content static. this avoids
         // 1. components not able to mutate slot nodes
         // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
+        if (!isPlatformReservedTag$1(node.tag) &&
             node.tag !== 'slot' &&
             node.attrsMap['inline-template'] == null) {
             return;
@@ -3136,8 +3102,8 @@ function markStatic(node) {
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -3169,8 +3135,8 @@ function markStaticRoots(node, isInFor) {
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
     }
@@ -3189,7 +3155,7 @@ function isStatic(node) {
             !node.if &&
             !node.for && // not v-if or v-for or v-else
             !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
+            isPlatformReservedTag$1(node.tag) && // not a component
             !isDirectChildOfTemplateFor(node) &&
             Object.keys(node).every(isStaticKey)));
 }
@@ -3241,7 +3207,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
+var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -3258,19 +3224,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name in events) {
-        var handlerCode = genHandler(events[name]);
+    for (var name_1 in events) {
+        var handlerCode = genHandler(events[name_1]);
         //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += name + "," + handlerCode + ",";
+        if (events[name_1] && events[name_1].dynamic) {
+            dynamicHandlers += name_1 + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
     if (dynamicHandlers) {
-        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
     }
     else {
         return prefix + staticHandlers;
@@ -3281,7 +3247,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -3290,13 +3256,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        for (var key in handler.modifiers) {
+        var _loop_1 = function (key) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -3305,15 +3271,18 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers = handler.modifiers;
+                var modifiers_1 = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
+        };
+        for (var key in handler.modifiers) {
+            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -3323,13 +3292,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? ("return " + (handler.value) + ".apply(null, arguments)")
+            ? "return " + handler.value + ".apply(null, arguments)"
             : isFunctionExpression
-                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                ? "return (" + handler.value + ").apply(null, arguments)"
                 : isFunctionInvocation
-                    ? ("return " + (handler.value))
+                    ? "return " + handler.value
                     : handler.value;
-        return ("function($event){" + code + handlerCode + "}");
+        return "function($event){" + code + handlerCode + "}";
     }
 }
 function genKeyFilter(keys) {
@@ -3338,60 +3307,65 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&')) + ")return null;");
+        (keys.map(genFilterCode).join('&&') + ")return null;"));
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return ("$event.keyCode!==" + keyVal);
+        return "$event.keyCode!==" + keyVal;
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key)) + "," +
-        (JSON.stringify(keyCode)) + "," +
+        (JSON.stringify(key) + ",") +
+        (JSON.stringify(keyCode) + ",") +
         "$event.key," +
-        "" + (JSON.stringify(keyName)) +
+        ("" + JSON.stringify(keyName)) +
         ")");
 }
 
 /* @flow */
 function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn("v-on without argument does not support modifiers.");
+        warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
 /* @flow */
-function bind$1(el, dir) {
+function bind(el, dir) {
     el.wrapData = function (code) {
-        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
 /* @flow */
 var baseDirectives = {
     on: on,
-    bind: bind$1,
+    bind: bind,
     cloak: noop,
 };
 
 /* @flow */
-var CodegenState = function CodegenState(options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-};
-function generate(ast, options) {
+var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        var isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = function (el) {
+            return !!el.component || !isReservedTag(el.tag);
+        };
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+    return CodegenState;
+}());
+function generate$1(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
     var code = ast
@@ -3400,7 +3374,7 @@ function generate(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -3428,17 +3402,19 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code;
+        var code = void 0;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data;
+            var data = void 0;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData$2(el, state);
+                data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+            ) + (children ? "," + children : '' // children
+            ) + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -3457,9 +3433,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
     state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
 }
 // v-once
 function genOnce(el, state) {
@@ -3469,20 +3445,20 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
+        var parent_1 = el.parent;
+        while (parent_1) {
+            if (parent_1.for) {
+                key = parent_1.key;
                 break;
             }
-            parent = parent.parent;
+            parent_1 = parent_1.parent;
         }
         if (!key) {
             process.env.NODE_ENV !== 'production' &&
                 state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
     }
     else {
         return genStatic(el, state);
@@ -3498,10 +3474,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
     }
     else {
-        return ("" + (genTernaryExp(condition.block)));
+        return "" + genTernaryExp(condition.block);
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -3515,24 +3491,24 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
     if (process.env.NODE_ENV !== 'production' &&
         state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
+        ("function(" + alias + iterator1 + iterator2 + "){") +
+        ("return " + (altGen || genElement)(el, state)) +
         '})');
 }
-function genData$2(el, state) {
+function genData(el, state) {
     var data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
@@ -3541,11 +3517,11 @@ function genData$2(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + (el.key) + ",";
+        data += "key:" + el.key + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + (el.ref) + ",";
+        data += "ref:" + el.ref + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -3556,7 +3532,7 @@ function genData$2(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + (el.tag) + "\",";
+        data += "tag:\"" + el.tag + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -3564,31 +3540,31 @@ function genData$2(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + (genProps(el.attrs)) + ",";
+        data += "attrs:" + genProps(el.attrs) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + (genProps(el.props)) + ",";
+        data += "domProps:" + genProps(el.props) + ",";
     }
     // event handlers
     if (el.events) {
-        data += (genHandlers(el.events, false)) + ",";
+        data += genHandlers(el.events, false) + ",";
     }
     if (el.nativeEvents) {
-        data += (genHandlers(el.nativeEvents, true)) + ",";
+        data += genHandlers(el.nativeEvents, true) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + (el.slotTarget) + ",";
+        data += "slot:" + el.slotTarget + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+        data += genScopedSlots(el, el.scopedSlots, state) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -3602,7 +3578,7 @@ function genData$2(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -3632,9 +3608,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -3648,10 +3624,10 @@ function genInlineTemplate(el, state) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
-        var inlineRenderFns = generate(ast, state.options);
-        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-            .map(function (code) { return ("function(){" + code + "}"); })
-            .join(',')) + "]}");
+        var inlineRenderFns = generate$1(ast, state.options);
+        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+            .map(function (code) { return "function(){" + code + "}"; })
+            .join(',') + "]}";
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -3676,23 +3652,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
+        var parent_2 = el.parent;
+        while (parent_2) {
+            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                parent_2.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent.if) {
+            if (parent_2.if) {
                 needsKey = true;
             }
-            parent = parent.parent;
+            parent_2 = parent_2.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
 }
 function hash(str) {
     var hash = 5381;
@@ -3721,36 +3697,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        "return " + (el.tag === 'template'
+        ("return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}";
+            : genElement(el, state)) + "}");
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el$1 = children[0];
+        var el_1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el$1.for &&
-            el$1.tag !== 'template' &&
-            el$1.tag !== 'slot') {
-            var normalizationType = checkSkip
-                ? state.maybeComponent(el$1)
+            el_1.for &&
+            el_1.tag !== 'template' &&
+            el_1.tag !== 'slot') {
+            var normalizationType_1 = checkSkip
+                ? state.maybeComponent(el_1)
                     ? ",1"
                     : ",0"
                 : "";
-            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
+            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
         }
-        var normalizationType$1 = checkSkip
+        var normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen = altGenNode || genNode;
-        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+        var gen_1 = altGenNode || genNode;
+        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
     }
 }
 // determine the normalization needed for the children array.
@@ -3792,17 +3768,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return ("_v(" + (text.type === 2
+    return "_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
 }
 function genComment(comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+    return "_e(" + JSON.stringify(comment.text) + ")";
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
+    var res = "_t(" + slotName + (children ? "," + children : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -3811,22 +3787,22 @@ function genSlot(el, state) {
             dynamic: attr.dynamic,
         }); }))
         : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
+    var bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
         res += ",null";
     }
     if (attrs) {
         res += "," + attrs;
     }
-    if (bind$$1) {
-        res += (attrs ? '' : ',null') + "," + bind$$1;
+    if (bind) {
+        res += (attrs ? '' : ',null') + "," + bind;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")");
+    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
 }
 function genProps(props) {
     var staticProps = "";
@@ -3835,15 +3811,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += (prop.name) + "," + value + ",";
+            dynamicProps += prop.name + "," + value + ",";
         }
         else {
-            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+            staticProps += "\"" + prop.name + "\":" + value + ",";
         }
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    staticProps = "{" + staticProps.slice(0, -1) + "}";
     if (dynamicProps) {
-        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
     }
     else {
         return staticProps;
@@ -3878,22 +3854,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                var value = node.attrsMap[name];
+        for (var name_1 in node.attrsMap) {
+            if (dirRE.test(name_1)) {
+                var value = node.attrsMap[name_1];
                 if (value) {
-                    var range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                    var range = node.rawAttrsMap[name_1];
+                    if (name_1 === 'v-for') {
+                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
                     }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                    else if (onRE.test(name_1)) {
+                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                     else {
-                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
                     }
                 }
             }
@@ -3913,7 +3889,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -3926,16 +3902,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(("var " + ident + "=_"));
+            new Function("var " + ident + "=_");
         }
         catch (e) {
-            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(("return " + exp));
+        new Function("return " + exp);
     }
     catch (e) {
         var keywordMatch = exp
@@ -3943,12 +3919,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
         }
         else {
-            warn("invalid expression: " + (e.message) + " in\n\n" +
-                "    " + exp + "\n\n" +
-                "  Raw expression: " + (text.trim()) + "\n", range);
+            warn("invalid expression: " + e.message + " in\n\n" +
+                ("    " + exp + "\n\n") +
+                ("  Raw expression: " + text.trim() + "\n"), range);
         }
     }
 }
@@ -3957,18 +3933,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-            "    " + exp + "\n\n" +
-            "  Raw expression: " + (text.trim()) + "\n", range);
+        warn("invalid function parameter expression: " + e.message + " in\n\n" +
+            ("    " + exp + "\n\n") +
+            ("  Raw expression: " + text.trim() + "\n"), range);
     }
 }
 
 /* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
+    if (start === void 0) { start = 0; }
+    if (end === void 0) { end = source.length; }
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -3978,18 +3953,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
+                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
+                    var length_1 = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length$1 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat$1("^", length$1));
+                        var length_2 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length_2));
                     }
                     count += lineLength + 1;
                 }
@@ -3999,7 +3974,7 @@ function generateCodeFrame(source, start, end) {
     }
     return res.join('\n');
 }
-function repeat$1(str, n) {
+function repeat(str, n) {
     var result = '';
     if (n > 0) {
         while (true) {
@@ -4029,7 +4004,7 @@ function createCompileToFunctionFn(compile) {
     var cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn$$1 = options.warn || warn;
+        var warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
@@ -4039,7 +4014,7 @@ function createCompileToFunctionFn(compile) {
             }
             catch (e) {
                 if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn$$1('It seems you are using the standalone build of Vue.js in an ' +
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
                         'environment with Content Security Policy that prohibits unsafe-eval. ' +
                         'The template compiler cannot work in this environment. Consider ' +
                         'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
@@ -4061,13 +4036,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn$$1("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn$$1("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                    warn("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -4093,14 +4068,12 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn$$1("Failed to generate render function:\n\n" +
+                warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (ref) {
-                            var err = ref.err;
-                            var code = ref.code;
-
-                            return ((err.toString()) + " in\n\n" + code + "\n");
-                })
+                        .map(function (_a) {
+                        var err = _a.err, code = _a.code;
+                        return err.toString() + " in\n\n" + code + "\n";
+                    })
                         .join('\n'), vm);
             }
         }
@@ -4122,15 +4095,15 @@ function createCompilerCreator(baseCompile) {
                 if (process.env.NODE_ENV !== 'production' &&
                     options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
+                                data.start = range.start + leadingSpaceLength_1;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
+                                data.end = range.end + leadingSpaceLength_1;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -4171,12 +4144,12 @@ function createCompilerCreator(baseCompile) {
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
     var ast = parse(template.trim(), options);
     if (options.optimize !== false) {
-        optimize(ast, options);
+        optimize$1(ast, options);
     }
-    var code = generate(ast, options);
+    var code = generate$1(ast, options);
     return {
         ast: ast,
         render: code.render,
@@ -4185,9 +4158,7 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
 });
 
 /* @flow */
-var ref = createCompiler(baseOptions);
-var compile = ref.compile;
-var compileToFunctions = ref.compileToFunctions;
+var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
 
 /* @flow */
 var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
@@ -4246,19 +4217,15 @@ function applyModelTransform(el, state) {
     }
 }
 function genAttrSegments(attrs) {
-    return attrs.map(function (ref) {
-        var name = ref.name;
-        var value = ref.value;
-
+    return attrs.map(function (_a) {
+        var name = _a.name, value = _a.value;
         return genAttrSegment(name, value);
     });
 }
 function genDOMPropSegments(props, attrs) {
     var segments = [];
-    props.forEach(function (ref) {
-        var name = ref.name;
-        var value = ref.value;
-
+    props.forEach(function (_a) {
+        var name = _a.name, value = _a.value;
         name = propsToAttrMap[name] || name.toLowerCase();
         if (isRenderableAttr(name) &&
             !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -4278,42 +4245,42 @@ function genAttrSegment(name, value) {
         return {
             type: RAW,
             value: isBooleanAttr(name)
-                ? (" " + name + "=\"" + name + "\"")
+                ? " " + name + "=\"" + name + "\""
                 : value === '""'
-                    ? (" " + name)
-                    : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
+                    ? " " + name
+                    : " " + name + "=\"" + JSON.parse(value) + "\"",
         };
     }
     else {
         return {
             type: EXPRESSION,
-            value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
+            value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
         };
     }
 }
 function genClassSegments(staticClass, classBinding) {
     if (staticClass && !classBinding) {
-        return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
+        return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
+                value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
             } ];
     }
 }
 function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
     if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
+        return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                    ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-                    : 'null') + ")"),
+                value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                    ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
+                    : 'null') + ")",
             } ];
     }
 }
@@ -4327,11 +4294,11 @@ var optimizability = {
     CHILDREN: 3,
     PARTIAL: 4, // self un-optimizable with some un-optimizable children
 };
-var isPlatformReservedTag$1;
-function optimize$1(root, options) {
+var isPlatformReservedTag;
+function optimize(root, options) {
     if (!root)
         { return; }
-    isPlatformReservedTag$1 = options.isReservedTag || no;
+    isPlatformReservedTag = options.isReservedTag || no;
     walk(root, true);
 }
 function walk(node, isRoot) {
@@ -4358,8 +4325,8 @@ function walk(node, isRoot) {
             check(child);
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
                 walk(block, isRoot);
                 check(block);
             }
@@ -4416,7 +4383,7 @@ function isUnOptimizableTree(node) {
         return false;
     }
     return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag$1(node.tag) || // custom component
+        !isPlatformReservedTag(node.tag) || // custom component
         !!node.component || // "is" component
         isSelectWithModel(node) // <select v-model> requires runtime inspection
     );
@@ -4441,11 +4408,11 @@ function isSelectWithModel(node) {
 var RAW = 0;
 var INTERPOLATION = 1;
 var EXPRESSION = 2;
-function generate$1(ast, options) {
+function generate(ast, options) {
     var state = new CodegenState(options);
     var code = ast ? genSSRElement(ast, state) : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: "with(this){return " + code + "}",
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -4480,11 +4447,11 @@ function genSSRElement(el, state) {
     }
 }
 function genNormalElement(el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData$2(el, state);
+    var data = el.plain ? undefined : genData(el, state);
     var children = stringifyChildren
-        ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
+        ? "[" + genChildrenAsStringNode(el, state) + "]"
         : genSSRChildren(el, state, true);
-    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
+    return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
 }
 function genSSRChildren(el, state, checkSkip) {
     return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -4494,18 +4461,18 @@ function genSSRNode(el, state) {
 }
 function genChildrenAsStringNode(el, state) {
     return el.children.length
-        ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
+        ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
         : '';
 }
 function genStringElement(el, state) {
-    return ("_ssrNode(" + (elementToString(el, state)) + ")");
+    return "_ssrNode(" + elementToString(el, state) + ")";
 }
 function genStringElementWithChildren(el, state) {
     var children = genSSRChildren(el, state, true);
-    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
+    return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
 }
 function elementToString(el, state) {
-    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
+    return "(" + flattenSegments(elementToSegments(el, state)) + ")";
 }
 function elementToSegments(el, state) {
     // v-for / v-if
@@ -4530,17 +4497,16 @@ function elementToSegments(el, state) {
     }
     var openSegments = elementToOpenTagSegments(el, state);
     var childrenSegments = childrenToSegments(el, state);
-    var ref = state.options;
-    var isUnaryTag = ref.isUnaryTag;
+    var isUnaryTag = state.options.isUnaryTag;
     var close = isUnaryTag && isUnaryTag(el.tag)
         ? []
-        : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
+        : [{ type: RAW, value: "</" + el.tag + ">" }];
     return openSegments.concat(childrenSegments, close);
 }
 function elementToOpenTagSegments(el, state) {
     applyModelTransform(el, state);
     var binding;
-    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
+    var segments = [{ type: RAW, value: "<" + el.tag }];
     // attrs
     if (el.attrs) {
         segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -4551,11 +4517,11 @@ function elementToOpenTagSegments(el, state) {
     }
     // v-bind="object"
     if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
+        segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
     }
     // v-bind.prop="object"
     if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
+        segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
     }
     // class
     if (el.staticClass || el.classBinding) {
@@ -4567,7 +4533,7 @@ function elementToOpenTagSegments(el, state) {
     }
     // _scopedId
     if (state.options.scopeId) {
-        segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
+        segments.push({ type: RAW, value: " " + state.options.scopeId });
     }
     segments.push({ type: RAW, value: ">" });
     return segments;
@@ -4575,13 +4541,13 @@ function elementToOpenTagSegments(el, state) {
 function childrenToSegments(el, state) {
     var binding;
     if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
+        return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
     }
     if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
     }
     if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
+        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
     }
     return el.children ? nodesToSegments(el.children, state) : [];
 }
@@ -4621,11 +4587,11 @@ function flattenSegments(segments) {
         }
         else if (s.type === INTERPOLATION) {
             pushBuffer();
-            mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
+            mergedSegments.push("_ssrEscape(" + s.value + ")");
         }
         else if (s.type === EXPRESSION) {
             pushBuffer();
-            mergedSegments.push(("(" + (s.value) + ")"));
+            mergedSegments.push("(" + s.value + ")");
         }
     }
     pushBuffer();
@@ -4633,10 +4599,10 @@ function flattenSegments(segments) {
 }
 
 /* @flow */
-var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
     var ast = parse(template.trim(), options);
-    optimize$1(ast, options);
-    var code = generate$1(ast, options);
+    optimize(ast, options);
+    var code = generate(ast, options);
     return {
         ast: ast,
         render: code.render,
@@ -4645,15 +4611,11 @@ var createCompiler$1 = createCompilerCreator(function baseCompile(template, opti
 });
 
 /* @flow */
-var ref$1 = createCompiler$1(baseOptions);
-var compile$1 = ref$1.compile;
-var compileToFunctions$1 = ref$1.compileToFunctions;
+var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
 
-/* @flow */
-
-exports.parseComponent = parseComponent;
-exports.compile = compile;
-exports.compileToFunctions = compileToFunctions;
-exports.ssrCompile = compile$1;
-exports.ssrCompileToFunctions = compileToFunctions$1;
+exports.compile = compile$1;
+exports.compileToFunctions = compileToFunctions$1;
 exports.generateCodeFrame = generateCodeFrame;
+exports.parseComponent = parseComponent;
+exports.ssrCompile = compile;
+exports.ssrCompileToFunctions = compileToFunctions;
diff --git a/scripts/config.js b/scripts/config.js
index 0e47accdc2e..2d6794186cb 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -1,10 +1,11 @@
 const path = require('path')
-const buble = require('rollup-plugin-buble')
-const alias = require('rollup-plugin-alias')
-const cjs = require('rollup-plugin-commonjs')
-const replace = require('rollup-plugin-replace')
-const node = require('rollup-plugin-node-resolve')
+const buble = require('@rollup/plugin-buble')
+const alias = require('@rollup/plugin-alias')
+const cjs = require('@rollup/plugin-commonjs')
+const replace = require('@rollup/plugin-replace')
+const node = require('@rollup/plugin-node-resolve').nodeResolve
 const ts = require('rollup-plugin-typescript2')
+const babel = require('@rollup/plugin-babel').babel
 
 const version = process.env.VERSION || require('../package.json').version
 const weexVersion = process.env.WEEX_VERSION || require('../packages/weex-vue-framework/package.json').version
@@ -232,16 +233,20 @@ function genConfig (name) {
           //   declaration: shouldEmitDeclarations,
           //   declarationMap: shouldEmitDeclarations
           // },
-          exclude: ['tests', 'test-dts']
+          exclude: ['test', 'test-dts']
         }
       }),
+      // babel({
+      //   extensions: ['.js', '.jsx', '.ts', '.tsx']
+      // }),
       alias(Object.assign({}, aliases, opts.alias))
     ].concat(opts.plugins || []),
     output: {
       file: opts.dest,
       format: opts.format,
       banner: opts.banner,
-      name: opts.moduleName || 'Vue'
+      name: opts.moduleName || 'Vue',
+      exports: 'auto'
     },
     onwarn: (msg, warn) => {
       if (!/Circular/.test(msg)) {
@@ -264,6 +269,8 @@ function genConfig (name) {
   if (opts.env) {
     vars['process.env.NODE_ENV'] = JSON.stringify(opts.env)
   }
+
+  vars.preventAssignment = true
   config.plugins.push(replace(vars))
 
   if (opts.transpile !== false) {
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index 7a54f043b4f..b5f9be295c6 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -1,6 +1,7 @@
 /* @flow */
 
-import * as he from 'he'
+const he = require('he')
+// import * as he from 'he'
 import { parseHTML } from './html-parser'
 import { parseText } from './text-parser'
 import { parseFilters } from './filter-parser'
@@ -337,7 +338,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
       }
       const children = currentParent.children
       if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text)
+        text = isTextTag(currentParent) ? text : decodeHTMLCached(text) as string
       } else if (!children.length) {
         // remove the whitespace-only node right after an opening tag
         text = ''
diff --git a/tsconfig.json b/tsconfig.json
index 55173de3e70..834374f2b7f 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,8 +3,8 @@
     "baseUrl": ".",
     "outDir": "dist",
     "sourceMap": true,
-    "target": "esnext",
-    "module": "esnext",
+    "target": "ES5",
+    "module": "ESNext",
     "moduleResolution": "node",
     "allowJs": true,
     "strict": true,
@@ -18,7 +18,6 @@
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
     "types": ["node", "jasmine"],
-    "rootDir": ".",
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
diff --git a/yarn.lock b/yarn.lock
index 2727fea70ae..3fea922dfbf 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -129,6 +129,13 @@
   dependencies:
     "@babel/types" "^7.0.0"
 
+"@babel/helper-module-imports@^7.10.4":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz#c6a369a6f3621cb25da014078684da9196b61977"
+  integrity sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==
+  dependencies:
+    "@babel/types" "^7.13.12"
+
 "@babel/helper-module-transforms@^7.1.0":
   version "7.2.2"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.2.2.tgz#ab2f8e8d231409f8370c883d20c335190284b963"
@@ -196,6 +203,11 @@
   dependencies:
     "@babel/types" "^7.0.0"
 
+"@babel/helper-validator-identifier@^7.12.11":
+  version "7.12.11"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz#c9a1f021917dcb5ccf0d4e453e399022981fc9ed"
+  integrity sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==
+
 "@babel/helper-wrap-function@^7.1.0":
   version "7.2.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.2.0.tgz#c4e0012445769e2815b55296ead43a958549f6fa"
@@ -644,6 +656,15 @@
     lodash "^4.17.10"
     to-fast-properties "^2.0.0"
 
+"@babel/types@^7.13.12":
+  version "7.13.14"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.14.tgz#c35a4abb15c7cd45a2746d78ab328e362cbace0d"
+  integrity sha512-A2aa3QTkWoyqsZZFl56MLUsfmh7O0gN41IPvXAE/++8ojpbz12SszD7JEGYVdn4f9Kt4amIei07swF1h4AqmmQ==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.12.11"
+    lodash "^4.17.19"
+    to-fast-properties "^2.0.0"
+
 "@iamstarkov/listr-update-renderer@0.4.1":
   version "0.4.1"
   resolved "https://registry.yarnpkg.com/@iamstarkov/listr-update-renderer/-/listr-update-renderer-0.4.1.tgz#d7c48092a2dcf90fd672b6c8b458649cb350c77e"
@@ -658,6 +679,72 @@
     log-update "^2.3.0"
     strip-ansi "^3.0.1"
 
+"@rollup/plugin-alias@^3.1.2":
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-3.1.2.tgz#c585b05be4a7782d269c69d13def56f44e417772"
+  integrity sha512-wzDnQ6v7CcoRzS0qVwFPrFdYA4Qlr+ookA217Y2Z3DPZE1R8jrFNM3jvGgOf6o6DMjbnQIn5lCIJgHPe1Bt3uw==
+  dependencies:
+    slash "^3.0.0"
+
+"@rollup/plugin-babel@^5.3.0":
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-babel/-/plugin-babel-5.3.0.tgz#9cb1c5146ddd6a4968ad96f209c50c62f92f9879"
+  integrity sha512-9uIC8HZOnVLrLHxayq/PTzw+uS25E14KPUBh5ktF+18Mjo5yK0ToMMx6epY0uEgkjwJw0aBW4x2horYXh8juWw==
+  dependencies:
+    "@babel/helper-module-imports" "^7.10.4"
+    "@rollup/pluginutils" "^3.1.0"
+
+"@rollup/plugin-buble@^0.21.3":
+  version "0.21.3"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-buble/-/plugin-buble-0.21.3.tgz#1649a915b1d051a4f430d40e7734a7f67a69b33e"
+  integrity sha512-Iv8cCuFPnMdqV4pcyU+OrfjOfagPArRQ1PyQjx5KgHk3dARedI+8PNTLSMpJts0lQJr8yF2pAU4GxpxCBJ9HYw==
+  dependencies:
+    "@rollup/pluginutils" "^3.0.8"
+    "@types/buble" "^0.19.2"
+    buble "^0.20.0"
+
+"@rollup/plugin-commonjs@^18.0.0":
+  version "18.0.0"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-18.0.0.tgz#50dc7518b5aa9e66a270e529ea85115d269825c4"
+  integrity sha512-fj92shhg8luw7XbA0HowAqz90oo7qtLGwqTKbyZ8pmOyH8ui5e+u0wPEgeHLH3djcVma6gUCUrjY6w5R2o1u6g==
+  dependencies:
+    "@rollup/pluginutils" "^3.1.0"
+    commondir "^1.0.1"
+    estree-walker "^2.0.1"
+    glob "^7.1.6"
+    is-reference "^1.2.1"
+    magic-string "^0.25.7"
+    resolve "^1.17.0"
+
+"@rollup/plugin-node-resolve@^11.2.1":
+  version "11.2.1"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz#82aa59397a29cd4e13248b106e6a4a1880362a60"
+  integrity sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==
+  dependencies:
+    "@rollup/pluginutils" "^3.1.0"
+    "@types/resolve" "1.17.1"
+    builtin-modules "^3.1.0"
+    deepmerge "^4.2.2"
+    is-module "^1.0.0"
+    resolve "^1.19.0"
+
+"@rollup/plugin-replace@^2.4.2":
+  version "2.4.2"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-replace/-/plugin-replace-2.4.2.tgz#a2d539314fbc77c244858faa523012825068510a"
+  integrity sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==
+  dependencies:
+    "@rollup/pluginutils" "^3.1.0"
+    magic-string "^0.25.7"
+
+"@rollup/pluginutils@^3.0.8", "@rollup/pluginutils@^3.1.0":
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-3.1.0.tgz#706b4524ee6dc8b103b3c995533e5ad680c02b9b"
+  integrity sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==
+  dependencies:
+    "@types/estree" "0.0.39"
+    estree-walker "^1.0.1"
+    picomatch "^2.2.2"
+
 "@rollup/pluginutils@^4.1.0":
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.1.0.tgz#0dcc61c780e39257554feb7f77207dceca13c838"
@@ -678,6 +765,18 @@
   resolved "https://registry.yarnpkg.com/@types/anymatch/-/anymatch-1.3.0.tgz#d1d55958d1fccc5527d4aba29fc9c4b942f563ff"
   integrity sha512-7WcbyctkE8GTzogDb0ulRAEw7v8oIS54ft9mQTU7PfM0hp5e+8kpa+HeQ7IQrFbKtJXBKcZ4bh+Em9dTw5L6AQ==
 
+"@types/buble@^0.19.2":
+  version "0.19.2"
+  resolved "https://registry.yarnpkg.com/@types/buble/-/buble-0.19.2.tgz#a4289d20b175b3c206aaad80caabdabe3ecdfdd1"
+  integrity sha512-uUD8zIfXMKThmFkahTXDGI3CthFH1kMg2dOm3KLi4GlC5cbARA64bEcUMbbWdWdE73eoc/iBB9PiTMqH0dNS2Q==
+  dependencies:
+    magic-string "^0.25.0"
+
+"@types/estree@*":
+  version "0.0.47"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.47.tgz#d7a51db20f0650efec24cd04994f523d93172ed4"
+  integrity sha512-c5ciR06jK8u9BstrmJyO97m+klJrrhCf9u3rLu3DEAJBirxRqSCvDQoYKmxuYwQI5SZChAWu+tq9oVlGRuzPAg==
+
 "@types/estree@0.0.39":
   version "0.0.39"
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
@@ -694,15 +793,22 @@
   integrity sha512-Lwh0lzzqT5Pqh6z61P3c3P5nm6fzQK/MMHl9UKeneAeInVflBSz1O2EkX6gM6xfJd7FBXBY5purtLx7fUiZ7Hw==
 
 "@types/node@*":
-  version "10.12.18"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-10.12.18.tgz#1d3ca764718915584fcd9f6344621b7672665c67"
-  integrity sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ==
+  version "14.14.37"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.37.tgz#a3dd8da4eb84a996c36e331df98d82abd76b516e"
+  integrity sha512-XYmBiy+ohOR4Lh5jE379fV2IU+6Jn4g5qASinhitfyO71b/sCo6MKsMLF5tc7Zf2CE8hViVQyYSobJNke8OvUw==
 
 "@types/node@^12.12.0":
   version "12.12.0"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-12.12.0.tgz#ff3201972d6dc851a9275308a17b9b5094e68057"
   integrity sha512-6N8Sa5AaENRtJnpKXZgvc119PKxT1Lk9VPy4kfT8JF23tIe1qDfaGkBR2DRKJFIA7NptMz+fps//C6aLi1Uoug==
 
+"@types/resolve@1.17.1":
+  version "1.17.1"
+  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.17.1.tgz#3afd6ad8967c77e4376c598a82ddd58f46ec45d6"
+  integrity sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==
+  dependencies:
+    "@types/node" "*"
+
 "@types/tapable@*":
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/@types/tapable/-/tapable-1.0.4.tgz#b4ffc7dc97b498c969b360a41eee247f82616370"
@@ -912,21 +1018,36 @@ acorn-dynamic-import@^3.0.0:
   dependencies:
     acorn "^5.0.0"
 
+acorn-dynamic-import@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz#482210140582a36b83c3e342e1cfebcaa9240948"
+  integrity sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==
+
 acorn-jsx@^5.0.0:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.0.1.tgz#32a064fd925429216a09b141102bfdd185fae40e"
   integrity sha512-HJ7CfNHrfJLlNTzIEUTj43LNWGkqpRLxm3YjAlcD0ACydk9XynzYsCBHxut+iqt+1aBXkx9UP/w/ZqMr13XIzg==
 
+acorn-jsx@^5.2.0:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
+  integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==
+
 acorn@^5.0.0, acorn@^5.2.1, acorn@^5.6.2:
   version "5.7.3"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.3.tgz#67aa231bf8812974b85235a96771eb6bd07ea279"
   integrity sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==
 
-acorn@^6.0.2, acorn@^6.0.4:
+acorn@^6.0.2:
   version "6.0.5"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.0.5.tgz#81730c0815f3f3b34d8efa95cb7430965f4d887a"
   integrity sha512-i33Zgp3XWtmZBMNvCr4azvOFeWVw1Rk6p3hfi3LUDvIFraOMywb1kAtrbi+med14m4Xfpqm3zRZMT+c0FNE7kg==
 
+acorn@^6.4.1:
+  version "6.4.2"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
+  integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
+
 adm-zip@~0.4.3:
   version "0.4.13"
   resolved "https://registry.yarnpkg.com/adm-zip/-/adm-zip-0.4.13.tgz#597e2f8cc3672151e1307d3e95cddbc75672314a"
@@ -1398,7 +1519,7 @@ babel-types@^6.24.1, babel-types@^6.26.0:
     lodash "^4.17.4"
     to-fast-properties "^1.0.3"
 
-babylon@^6.18.0, babylon@^6.8.4:
+babylon@^6.18.0:
   version "6.18.0"
   resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3"
   integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==
@@ -1626,7 +1747,7 @@ browserslist@^4.3.4:
     electron-to-chromium "^1.3.96"
     node-releases "^1.1.3"
 
-buble@^0.19.3, buble@^0.19.6:
+buble@^0.19.3:
   version "0.19.6"
   resolved "https://registry.yarnpkg.com/buble/-/buble-0.19.6.tgz#915909b6bd5b11ee03b1c885ec914a8b974d34d3"
   integrity sha512-9kViM6nJA1Q548Jrd06x0geh+BG2ru2+RMDkIHHgJY/8AcyCs34lTHwra9BX7YdPrZXd5aarkpr/SY8bmPgPdg==
@@ -1638,6 +1759,19 @@ buble@^0.19.3, buble@^0.19.6:
     regexpu-core "^4.2.0"
     vlq "^1.0.0"
 
+buble@^0.20.0:
+  version "0.20.0"
+  resolved "https://registry.yarnpkg.com/buble/-/buble-0.20.0.tgz#a143979a8d968b7f76b57f38f2e7ce7cfe938d1f"
+  integrity sha512-/1gnaMQE8xvd5qsNBl+iTuyjJ9XxeaVxAMF86dQ4EyxFJOZtsgOS8Ra+7WHgZTam5IFDtt4BguN0sH0tVTKrOw==
+  dependencies:
+    acorn "^6.4.1"
+    acorn-dynamic-import "^4.0.0"
+    acorn-jsx "^5.2.0"
+    chalk "^2.4.2"
+    magic-string "^0.25.7"
+    minimist "^1.2.5"
+    regexpu-core "4.5.4"
+
 buffer-alloc-unsafe@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz#bd7dc26ae2972d0eda253be061dba992349c19f0"
@@ -1680,10 +1814,10 @@ builtin-modules@^1.0.0:
   resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f"
   integrity sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=
 
-builtin-modules@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.0.0.tgz#1e587d44b006620d90286cc7a9238bbc6129cab1"
-  integrity sha512-hMIeU4K2ilbXV6Uv93ZZ0Avg/M91RaKXucQ+4me2Do1txxBDyDZWCBa5bJSLqoNTRpXTLwEzIk1KmloenDDjhg==
+builtin-modules@^3.1.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
+  integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
 
 builtin-status-codes@^3.0.0:
   version "3.0.0"
@@ -1803,7 +1937,7 @@ chalk@1.1.3, chalk@^1.0.0, chalk@^1.1.3:
     strip-ansi "^3.0.0"
     supports-color "^2.0.0"
 
-chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4.1:
+chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4.1, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
@@ -2594,6 +2728,11 @@ deep-is@^0.1.3, deep-is@~0.1.3:
   resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
   integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
 
+deepmerge@^4.2.2:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955"
+  integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==
+
 define-properties@^1.1.2:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
@@ -3104,15 +3243,10 @@ estraverse@^4.0.0, estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0:
   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
   integrity sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=
 
-estree-walker@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.2.1.tgz#bdafe8095383d8414d5dc2ecf4c9173b6db9412e"
-  integrity sha1-va/oCVOD2EFNXcLs9MkXO225QS4=
-
-estree-walker@^0.5.2:
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.5.2.tgz#d3850be7529c9580d815600b53126515e146dd39"
-  integrity sha512-XpCnW/AE10ws/kDAs37cngSkvgIR8aN3G0MS85m7dUpuK2EREo9VJ00uvw6Dg/hXEpfsE1I1TvJOJr+Z+TL+ig==
+estree-walker@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-1.0.1.tgz#31bc5d612c96b704106b477e6dd5d8aa138cb700"
+  integrity sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==
 
 estree-walker@^2.0.1:
   version "2.0.2"
@@ -3531,14 +3665,6 @@ flow-bin@^0.61.0:
   resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.61.0.tgz#d0473a8c35dbbf4de573823f4932124397d32d35"
   integrity sha512-w6SGi5CDfKLNGzYssRhW6N37qKclDXijsxDQ5M8c3WbivRYta0Horv22bwakegfKBVDnyeS0lRW3OqBC74eq2g==
 
-flow-remove-types-no-whitespace@^1.0.3:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/flow-remove-types-no-whitespace/-/flow-remove-types-no-whitespace-1.0.5.tgz#3d297985a0bed5197b8fb0cbe89ec163f8dea9eb"
-  integrity sha1-PSl5haC+1Rl7j7DL6J7BY/jeqes=
-  dependencies:
-    babylon "^6.8.4"
-    magic-string "^0.16.0"
-
 flush-write-stream@^1.0.0:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/flush-write-stream/-/flush-write-stream-1.0.3.tgz#c5d586ef38af6097650b49bc41b55fabb19f35bd"
@@ -3653,6 +3779,11 @@ fsevents@^1.2.2:
     nan "^2.9.2"
     node-pre-gyp "^0.10.0"
 
+fsevents@~2.3.1:
+  version "2.3.2"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
+  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
+
 ftp@~0.3.10:
   version "0.3.10"
   resolved "https://registry.yarnpkg.com/ftp/-/ftp-0.3.10.tgz#9197d861ad8142f3e63d5a83bfe4c59f7330885d"
@@ -3855,6 +3986,18 @@ glob@^7.0.0, glob@^7.0.3, glob@^7.0.6, glob@^7.1.1, glob@^7.1.2, glob@^7.1.3:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
+glob@^7.1.6:
+  version "7.1.6"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
+  integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.0.4"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
 global-modules@^0.2.3:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-0.2.3.tgz#ea5a3bed42c6d6ce995a4f8a1269b5dae223828d"
@@ -4605,6 +4748,13 @@ is-promise@^2.1.0:
   resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
   integrity sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=
 
+is-reference@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/is-reference/-/is-reference-1.2.1.tgz#8b2dac0b371f4bc994fdeaba9eb542d03002d0b7"
+  integrity sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==
+  dependencies:
+    "@types/estree" "*"
+
 is-regex@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
@@ -5408,6 +5558,11 @@ lodash@^4.0.1, lodash@^4.16.6, lodash@^4.17.0, lodash@^4.17.10, lodash@^4.17.11,
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52"
   integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==
 
+lodash@^4.17.19:
+  version "4.17.21"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
+  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
+
 lodash@^4.17.4:
   version "4.17.19"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.19.tgz#e48ddedbe30b3321783c5b4301fbd353bc1e4a4b"
@@ -5494,12 +5649,12 @@ lru-cache@~2.6.5:
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-2.6.5.tgz#e56d6354148ede8d7707b58d143220fd08df0fd5"
   integrity sha1-5W1jVBSO3o13B7WNFDIg/QjfD9U=
 
-magic-string@^0.16.0:
-  version "0.16.0"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.16.0.tgz#970ebb0da7193301285fb1aa650f39bdd81eb45a"
-  integrity sha1-lw67DacZMwEoX7GqZQ85vdgetFo=
+magic-string@^0.25.0, magic-string@^0.25.7:
+  version "0.25.7"
+  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051"
+  integrity sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA==
   dependencies:
-    vlq "^0.2.1"
+    sourcemap-codec "^1.4.4"
 
 magic-string@^0.25.1:
   version "0.25.1"
@@ -5622,7 +5777,7 @@ merge@^1.2.0:
   resolved "https://registry.yarnpkg.com/merge/-/merge-1.2.1.tgz#38bebf80c3220a8a487b6fcfb3941bb11720c145"
   integrity sha512-VjFo4P5Whtj4vsLzsYBu5ayHhoHJ0UqNm7ibvShmbmoz7tGi0vXaoJbGdB+GmDMLUdg8DpQXEIeVDAe8MaABvQ==
 
-micromatch@^2.3.11, micromatch@^2.3.7:
+micromatch@^2.3.7:
   version "2.3.11"
   resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565"
   integrity sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=
@@ -7001,6 +7156,13 @@ regenerate-unicode-properties@^7.0.0:
   dependencies:
     regenerate "^1.4.0"
 
+regenerate-unicode-properties@^8.0.2:
+  version "8.2.0"
+  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz#e5de7111d655e7ba60c057dbe9ff37c87e65cdec"
+  integrity sha512-F9DjY1vKLo/tPePDycuH3dn9H1OTPIkVD9Kz4LODu+F2C75mgjAJ7x/gwy6ZcSNRAAkhNlJSOHRe8k3p+K9WhA==
+  dependencies:
+    regenerate "^1.4.0"
+
 regenerate@^1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.0.tgz#4a856ec4b56e4077c557589cae85e7a4c8869a11"
@@ -7043,6 +7205,18 @@ regexpp@^2.0.1:
   resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-2.0.1.tgz#8d19d31cf632482b589049f8281f93dbcba4d07f"
   integrity sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw==
 
+regexpu-core@4.5.4:
+  version "4.5.4"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.5.4.tgz#080d9d02289aa87fe1667a4f5136bc98a6aebaae"
+  integrity sha512-BtizvGtFQKGPUcTy56o3nk1bGRp4SZOTYrDtGNlqCQufptV5IkkLN6Emw+yunAJjzf+C9FQFtvq7IoA3+oMYHQ==
+  dependencies:
+    regenerate "^1.4.0"
+    regenerate-unicode-properties "^8.0.2"
+    regjsgen "^0.5.0"
+    regjsparser "^0.6.0"
+    unicode-match-property-ecmascript "^1.0.4"
+    unicode-match-property-value-ecmascript "^1.1.0"
+
 regexpu-core@^4.1.3, regexpu-core@^4.2.0:
   version "4.4.0"
   resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.4.0.tgz#8d43e0d1266883969720345e70c275ee0aec0d32"
@@ -7160,7 +7334,7 @@ resolve@1.1.x:
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b"
   integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=
 
-resolve@1.20.0:
+resolve@1.20.0, resolve@^1.17.0, resolve@^1.19.0:
   version "1.20.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
   integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
@@ -7168,7 +7342,7 @@ resolve@1.20.0:
     is-core-module "^2.2.0"
     path-parse "^1.0.6"
 
-resolve@^1.1.6, resolve@^1.3.2, resolve@^1.3.3, resolve@^1.8.1:
+resolve@^1.1.6, resolve@^1.3.2, resolve@^1.3.3:
   version "1.9.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.9.0.tgz#a14c6fdfa8f92a7df1d996cb7105fa744658ea06"
   integrity sha512-TZNye00tI67lwYvzxCxHGjwTNlUV70io54/Ed4j6PscB8xVfuBJpRenI/o6dVk0cY0PYTY27AgCoGGxRnYuItQ==
@@ -7221,57 +7395,6 @@ ripemd160@^2.0.0, ripemd160@^2.0.1:
     hash-base "^3.0.0"
     inherits "^2.0.1"
 
-rollup-plugin-alias@^1.3.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-alias/-/rollup-plugin-alias-1.5.1.tgz#80cce3a967befda5b09c86abc14a043a78035b46"
-  integrity sha512-pQTYBRNfLedoVOO7AYHNegIavEIp4jKTga5jUi1r//KYgHKGWgG4qJXYhbcWKt2k1FwGlR5wCYoY+IFkme0t4A==
-  dependencies:
-    slash "^2.0.0"
-
-rollup-plugin-buble@^0.19.6:
-  version "0.19.6"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-buble/-/rollup-plugin-buble-0.19.6.tgz#55ee0995d8870d536f01f4277c3eef4276e8747e"
-  integrity sha512-El5Fut4/wEO17ZN/n9BZvqd7DXXB2WbJr/DKvr89LXChC/cHllE0XwiUDeAalrTkgr0WrnyLDTCQvEv+cGywWQ==
-  dependencies:
-    buble "^0.19.6"
-    rollup-pluginutils "^2.3.3"
-
-rollup-plugin-commonjs@^9.2.0:
-  version "9.2.0"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-commonjs/-/rollup-plugin-commonjs-9.2.0.tgz#4604e25069e0c78a09e08faa95dc32dec27f7c89"
-  integrity sha512-0RM5U4Vd6iHjL6rLvr3lKBwnPsaVml+qxOGaaNUWN1lSq6S33KhITOfHmvxV3z2vy9Mk4t0g4rNlVaJJsNQPWA==
-  dependencies:
-    estree-walker "^0.5.2"
-    magic-string "^0.25.1"
-    resolve "^1.8.1"
-    rollup-pluginutils "^2.3.3"
-
-rollup-plugin-flow-no-whitespace@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-flow-no-whitespace/-/rollup-plugin-flow-no-whitespace-1.0.0.tgz#bd4ba1bcd99ad5b88234d72e6e2dacea9aa02d16"
-  integrity sha1-vUuhvNma1biCNNcubi2s6pqgLRY=
-  dependencies:
-    flow-remove-types-no-whitespace "^1.0.3"
-    rollup-pluginutils "^1.5.2"
-
-rollup-plugin-node-resolve@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-node-resolve/-/rollup-plugin-node-resolve-4.0.0.tgz#9bc6b8205e9936cc0e26bba2415f1ecf1e64d9b2"
-  integrity sha512-7Ni+/M5RPSUBfUaP9alwYQiIKnKeXCOHiqBpKUl9kwp3jX5ZJtgXAait1cne6pGEVUUztPD6skIKH9Kq9sNtfw==
-  dependencies:
-    builtin-modules "^3.0.0"
-    is-module "^1.0.0"
-    resolve "^1.8.1"
-
-rollup-plugin-replace@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-replace/-/rollup-plugin-replace-2.1.0.tgz#f9c07a4a89a2f8be912ee54b3f0f68d91e9ed0ae"
-  integrity sha512-SxrAIgpH/B5/W4SeULgreOemxcpEgKs2gcD42zXw50bhqGWmcnlXneVInQpAqzA/cIly4bJrOpeelmB9p4YXSQ==
-  dependencies:
-    magic-string "^0.25.1"
-    minimatch "^3.0.2"
-    rollup-pluginutils "^2.0.1"
-
 rollup-plugin-typescript2@^0.30.0:
   version "0.30.0"
   resolved "https://registry.yarnpkg.com/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.30.0.tgz#1cc99ac2309bf4b9d0a3ebdbc2002aecd56083d3"
@@ -7283,30 +7406,12 @@ rollup-plugin-typescript2@^0.30.0:
     resolve "1.20.0"
     tslib "2.1.0"
 
-rollup-pluginutils@^1.5.2:
-  version "1.5.2"
-  resolved "https://registry.yarnpkg.com/rollup-pluginutils/-/rollup-pluginutils-1.5.2.tgz#1e156e778f94b7255bfa1b3d0178be8f5c552408"
-  integrity sha1-HhVud4+UtyVb+hs9AXi+j1xVJAg=
-  dependencies:
-    estree-walker "^0.2.1"
-    minimatch "^3.0.2"
-
-rollup-pluginutils@^2.0.1, rollup-pluginutils@^2.3.3:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/rollup-pluginutils/-/rollup-pluginutils-2.3.3.tgz#3aad9b1eb3e7fe8262820818840bf091e5ae6794"
-  integrity sha512-2XZwja7b6P5q4RZ5FhyX1+f46xi1Z3qBKigLRZ6VTZjwbN0K1IFGMlwm06Uu0Emcre2Z63l77nq/pzn+KxIEoA==
-  dependencies:
-    estree-walker "^0.5.2"
-    micromatch "^2.3.11"
-
-rollup@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-1.0.2.tgz#df88abda5cfe96afaa07dbd540510f87e60d1baf"
-  integrity sha512-FkkSrWUVo1WliS+/GIgEmKQPILubgVdBRTWampfdhkasxx7sM2nfwSfKiX3paIBVnN0HG3DvkTy13RfjkyBX9w==
-  dependencies:
-    "@types/estree" "0.0.39"
-    "@types/node" "*"
-    acorn "^6.0.4"
+rollup@^2.44.0:
+  version "2.44.0"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.44.0.tgz#8da324d1c4fd12beef9ae6e12f4068265b6d95eb"
+  integrity sha512-rGSF4pLwvuaH/x4nAS+zP6UNn5YUDWf/TeEU5IoXSZKBbKRNTCI3qMnYXKZgrC0D2KzS2baiOZt1OlqhMu5rnQ==
+  optionalDependencies:
+    fsevents "~2.3.1"
 
 run-async@^2.2.0:
   version "2.3.0"
@@ -7535,10 +7640,10 @@ simple-git@^1.85.0:
   dependencies:
     debug "^4.0.1"
 
-slash@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44"
-  integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==
+slash@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
+  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
 slice-ansi@0.0.4:
   version "0.0.4"
@@ -7703,6 +7808,11 @@ sourcemap-codec@^1.4.1:
   resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.4.tgz#c63ea927c029dd6bd9a2b7fa03b3fec02ad56e9f"
   integrity sha512-CYAPYdBu34781kLHkaW3m6b/uUSyMOC2R61gcYMWooeuaGtjof86ZA/8T+qVPPt7np1085CR9hmMGrySwEc8Xg==
 
+sourcemap-codec@^1.4.4:
+  version "1.4.8"
+  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
+  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
+
 spawn-sync@^1.0.15:
   version "1.0.15"
   resolved "https://registry.yarnpkg.com/spawn-sync/-/spawn-sync-1.0.15.tgz#b00799557eb7fb0c8376c29d44e8a1ea67e57476"
@@ -8224,6 +8334,11 @@ tslib@^1.9.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286"
   integrity sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==
 
+tslib@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c"
+  integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==
+
 tty-browserify@0.0.0:
   version "0.0.0"
   resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6"
@@ -8299,6 +8414,11 @@ unicode-match-property-value-ecmascript@^1.0.2:
   resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.0.2.tgz#9f1dc76926d6ccf452310564fd834ace059663d4"
   integrity sha512-Rx7yODZC1L/T8XKo/2kNzVAQaRE88AaMvI1EF/Xnj3GW2wzN6fop9DDWuFAKUVFH7vozkz26DzP0qyWLKLIVPQ==
 
+unicode-match-property-value-ecmascript@^1.1.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz#0d91f600eeeb3096aa962b1d6fc88876e64ea531"
+  integrity sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==
+
 unicode-property-aliases-ecmascript@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.0.4.tgz#5a533f31b4317ea76f17d807fa0d116546111dd0"
@@ -8455,11 +8575,6 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
-vlq@^0.2.1:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/vlq/-/vlq-0.2.3.tgz#8f3e4328cf63b1540c0d67e1b2778386f8975b26"
-  integrity sha512-DRibZL6DsNhIgYQ+wNdWDL2SL3bKPlVrRiBqV5yuMm++op8W4kGFtaQfCs4KEJn0wBZcHVHJ3eoywX8983k1ow==
-
 vlq@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/vlq/-/vlq-1.0.0.tgz#8101be90843422954c2b13eb27f2f3122bdcc806"

From 54ee448abfee5b42b7878e81fff32d8fa82d2720 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 6 Apr 2021 17:05:05 +0100
Subject: [PATCH 007/317] replace flow with ts-check

---
 .circleci/config.yml | 12 ++++++------
 package.json         |  1 +
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 9075ab237c9..9c940960845 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -25,13 +25,13 @@ jobs:
           paths:
             - vue
 
-  lint-flow-types:
+  lint-ts-types:
     <<: *defaults
     steps:
       - attach_workspace:
           at: ~/project
       - run: npm run lint
-      - run: npm run flow
+      - run: npm run ts-check
       - run: npm run test:types
 
   test-cover:
@@ -80,7 +80,7 @@ workflows:
       - test-cover:
           requires:
             - install
-      - lint-flow-types:
+      - lint-ts-types:
           requires:
             - install
       - test-e2e:
@@ -97,7 +97,7 @@ workflows:
                 - regression-test
           requires:
             - test-cover
-            - lint-flow-types
+            - lint-ts-types
             - test-e2e
             - test-ssr-weex
   weekly_regression_test:
@@ -114,7 +114,7 @@ workflows:
       - test-cover:
           requires:
             - install
-      - lint-flow-types:
+      - lint-ts-types:
           requires:
             - install
       - test-e2e:
@@ -126,6 +126,6 @@ workflows:
       - trigger-regression-test:
           requires:
             - test-cover
-            - lint-flow-types
+            - lint-ts-types
             - test-e2e
             - test-ssr-weex
diff --git a/package.json b/package.json
index 61fe0e1fd30..81a689dcab0 100644
--- a/package.json
+++ b/package.json
@@ -36,6 +36,7 @@
     "test:types": "tsc -p ./types/test/tsconfig.json",
     "lint": "eslint src scripts test",
     "flow": "flow check",
+    "ts-check": "tsc --noEmit",
     "sauce": "karma start test/unit/karma.sauce.config.js",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
     "release": "bash scripts/release.sh",

From 0af78c57b3dbe6bf5296f87b7be542a475a26e12 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 6 Apr 2021 17:11:58 +0100
Subject: [PATCH 008/317] remove @flow

---
 packages/vue-server-renderer/build.dev.js     |  79 -----------
 packages/vue-template-compiler/browser.js     | 126 ++++++------------
 scripts/config.js                             |   2 +-
 src/compiler/codeframe.ts                     |   1 -
 src/compiler/codegen/events.ts                |   1 -
 src/compiler/codegen/index.ts                 |   1 -
 src/compiler/create-compiler.ts               |   1 -
 src/compiler/directives/bind.ts               |   1 -
 src/compiler/directives/index.ts              |   1 -
 src/compiler/directives/model.ts              |   1 -
 src/compiler/directives/on.ts                 |   1 -
 src/compiler/error-detector.ts                |   1 -
 src/compiler/helpers.ts                       |   1 -
 src/compiler/index.ts                         |   1 -
 src/compiler/optimizer.ts                     |   1 -
 src/compiler/parser/entity-decoder.ts         |   1 -
 src/compiler/parser/filter-parser.ts          |   1 -
 src/compiler/parser/index.ts                  |   1 -
 src/compiler/parser/text-parser.ts            |   1 -
 src/compiler/to-function.ts                   |   1 -
 src/core/config.ts                            |   1 -
 src/core/global-api/assets.ts                 |   1 -
 src/core/global-api/extend.ts                 |   1 -
 src/core/global-api/index.ts                  |   1 -
 src/core/global-api/mixin.ts                  |   1 -
 src/core/global-api/use.ts                    |   1 -
 src/core/instance/events.ts                   |   1 -
 src/core/instance/init.ts                     |   1 -
 src/core/instance/inject.ts                   |   1 -
 src/core/instance/lifecycle.ts                |   1 -
 .../render-helpers/bind-dynamic-keys.ts       |   1 -
 .../render-helpers/bind-object-listeners.ts   |   1 -
 .../render-helpers/bind-object-props.ts       |   1 -
 .../instance/render-helpers/check-keycodes.ts |   1 -
 src/core/instance/render-helpers/index.ts     |   1 -
 .../instance/render-helpers/resolve-slots.ts  |   1 -
 src/core/instance/render.ts                   |   1 -
 src/core/instance/state.ts                    |   1 -
 src/core/observer/scheduler.ts                |   1 -
 src/core/observer/traverse.ts                 |   1 -
 src/core/observer/watcher.ts                  |   1 -
 src/core/util/debug.ts                        |   1 -
 src/core/util/env.ts                          |   1 -
 src/core/util/index.ts                        |   1 -
 src/core/util/lang.ts                         |   1 -
 src/core/util/next-tick.ts                    |   1 -
 src/core/util/options.ts                      |   1 -
 src/core/util/props.ts                        |   1 -
 src/core/vdom/create-component.ts             |   1 -
 src/core/vdom/create-element.ts               |   1 -
 src/core/vdom/create-functional-component.ts  |   1 -
 src/core/vdom/helpers/extract-props.ts        |   1 -
 .../vdom/helpers/get-first-component-child.ts |   1 -
 src/core/vdom/helpers/index.ts                |   1 -
 src/core/vdom/helpers/is-async-placeholder.ts |   1 -
 src/core/vdom/helpers/merge-hook.ts           |   1 -
 src/core/vdom/helpers/normalize-children.ts   |   1 -
 .../vdom/helpers/normalize-scoped-slots.ts    |   1 -
 .../vdom/helpers/resolve-async-component.ts   |   1 -
 src/core/vdom/modules/directives.ts           |   1 -
 src/core/vdom/modules/ref.ts                  |   1 -
 src/platforms/web/compiler/directives/html.ts |   1 -
 .../web/compiler/directives/model.ts          |   1 -
 src/platforms/web/compiler/directives/text.ts |   1 -
 src/platforms/web/compiler/index.ts           |   1 -
 src/platforms/web/compiler/modules/class.ts   |   1 -
 src/platforms/web/compiler/modules/model.ts   |   1 -
 src/platforms/web/compiler/modules/style.ts   |   1 -
 src/platforms/web/compiler/options.ts         |   1 -
 src/platforms/web/compiler/util.ts            |   1 -
 src/platforms/web/entry-compiler.ts           |   1 -
 .../web/entry-runtime-with-compiler.ts        |   1 -
 src/platforms/web/entry-runtime.ts            |   1 -
 .../web/entry-server-basic-renderer.ts        |   1 -
 src/platforms/web/entry-server-renderer.ts    |   1 -
 src/platforms/web/runtime/class-util.ts       |   1 -
 .../web/runtime/components/transition.ts      |   1 -
 src/platforms/web/runtime/directives/show.ts  |   1 -
 src/platforms/web/runtime/modules/attrs.ts    |   1 -
 src/platforms/web/runtime/modules/class.ts    |   1 -
 .../web/runtime/modules/dom-props.ts          |   1 -
 src/platforms/web/runtime/modules/events.ts   |   1 -
 src/platforms/web/runtime/modules/style.ts    |   1 -
 .../web/runtime/modules/transition.ts         |   1 -
 src/platforms/web/runtime/node-ops.ts         |   1 -
 src/platforms/web/runtime/patch.ts            |   1 -
 src/platforms/web/server/compiler.ts          |   1 -
 src/platforms/web/server/directives/model.ts  |   1 -
 src/platforms/web/server/directives/show.ts   |   1 -
 src/platforms/web/server/modules/attrs.ts     |   1 -
 src/platforms/web/server/modules/class.ts     |   1 -
 src/platforms/web/server/modules/dom-props.ts |   1 -
 src/platforms/web/server/modules/style.ts     |   1 -
 src/platforms/web/server/util.ts              |   1 -
 src/platforms/web/util/attrs.ts               |   1 -
 src/platforms/web/util/class.ts               |   1 -
 src/platforms/web/util/compat.ts              |   1 -
 src/platforms/web/util/element.ts             |   1 -
 src/platforms/web/util/index.ts               |   1 -
 src/platforms/web/util/style.ts               |   1 -
 .../weex/compiler/directives/model.ts         |   1 -
 src/platforms/weex/compiler/index.ts          |   1 -
 src/platforms/weex/compiler/modules/append.ts |   1 -
 src/platforms/weex/compiler/modules/class.ts  |   1 -
 src/platforms/weex/compiler/modules/props.ts  |   1 -
 .../modules/recycle-list/component-root.ts    |   1 -
 .../modules/recycle-list/component.ts         |   1 -
 .../compiler/modules/recycle-list/index.ts    |   1 -
 .../modules/recycle-list/recycle-list.ts      |   1 -
 .../compiler/modules/recycle-list/text.ts     |   1 -
 .../compiler/modules/recycle-list/v-bind.ts   |   1 -
 .../compiler/modules/recycle-list/v-for.ts    |   1 -
 .../compiler/modules/recycle-list/v-if.ts     |   1 -
 .../compiler/modules/recycle-list/v-on.ts     |   1 -
 .../compiler/modules/recycle-list/v-once.ts   |   1 -
 src/platforms/weex/compiler/modules/style.ts  |   1 -
 src/platforms/weex/entry-framework.ts         |   1 -
 .../weex/runtime/components/richtext.ts       |   1 -
 src/platforms/weex/runtime/modules/attrs.ts   |   1 -
 src/platforms/weex/runtime/modules/class.ts   |   1 -
 src/platforms/weex/runtime/modules/events.ts  |   1 -
 src/platforms/weex/runtime/modules/style.ts   |   1 -
 src/platforms/weex/runtime/node-ops.ts        |   1 -
 src/platforms/weex/runtime/patch.ts           |   1 -
 .../recycle-list/render-component-template.ts |   1 -
 .../runtime/recycle-list/virtual-component.ts |   1 -
 src/platforms/weex/util/element.ts            |   1 -
 src/platforms/weex/util/index.ts              |   1 -
 src/platforms/weex/util/parser.ts             |   1 -
 .../bundle-renderer/create-bundle-renderer.ts |   1 -
 .../bundle-renderer/source-map-support.ts     |   1 -
 src/server/create-basic-renderer.ts           |   1 -
 src/server/create-renderer.ts                 |   1 -
 src/server/optimizing-compiler/codegen.ts     |   1 -
 src/server/optimizing-compiler/index.ts       |   1 -
 src/server/optimizing-compiler/modules.ts     |   1 -
 src/server/optimizing-compiler/optimizer.ts   |   1 -
 .../optimizing-compiler/runtime-helpers.ts    |   1 -
 src/server/render-context.ts                  |   1 -
 src/server/render-stream.ts                   |   1 -
 src/server/render.ts                          |   1 -
 .../create-async-file-mapper.ts               |   1 -
 src/server/template-renderer/index.ts         |   1 -
 .../template-renderer/parse-template.ts       |   1 -
 .../template-renderer/template-stream.ts      |   1 -
 src/server/util.ts                            |   1 -
 src/server/write.ts                           |   1 -
 src/sfc/parser.ts                             |   1 -
 src/shared/util.ts                            |   1 -
 149 files changed, 43 insertions(+), 310 deletions(-)

diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index 57ff848bf42..bac0f6701c5 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var stream = require('stream');
 
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -257,7 +256,6 @@ function looseIndexOf(arr, val) {
     return -1;
 }
 
-/* @flow */
 var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
     'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
     'checked,cite,class,code,codebase,color,cols,colspan,content,' +
@@ -342,7 +340,6 @@ var noUnitNumericStyleProps = {
     'stroke-width': true,
 };
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 makeMap('style,class');
@@ -374,7 +371,6 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
-/* @flow */
 function renderAttrs$1(node) {
     var attrs = node.data.attrs;
     var res = '';
@@ -494,7 +490,6 @@ function cloneVNode(vnode) {
     return cloned;
 }
 
-/* @flow */
 function renderDOMProps$1(node) {
     var props = node.data.domProps;
     var res = '';
@@ -537,7 +532,6 @@ function setText(node, text, raw) {
     node.children = [child];
 }
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -556,7 +550,6 @@ function def(obj, key, val, enumerable) {
     });
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -660,7 +653,6 @@ var LIFECYCLE_HOOKS = [
     'errorCaptured',
     'serverPrefetch' ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -739,7 +731,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 var warn$2 = noop$1;
 var tip = noop$1;
 var generateComponentTrace; // work around flow check
@@ -1125,7 +1116,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1504,7 +1494,6 @@ function resolveAsset(options, type, id, warnMissing) {
     return res;
 }
 
-/* @flow */
 function validateProp(key, propOptions, propsData, vm) {
     var prop = propOptions[key];
     var absent = !hasOwn(propsData, key);
@@ -1768,7 +1757,6 @@ function logError(err, vm, info) {
     }
 }
 
-/* @flow */
 var callbacks = [];
 function flushCallbacks() {
     var copies = callbacks.slice(0);
@@ -1803,7 +1791,6 @@ else if (!isIE &&
 else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 else ;
 
-/* @flow */
 function genClassForVnode(vnode) {
     var data = vnode.data;
     var parentNode = vnode;
@@ -1874,7 +1861,6 @@ function stringifyObject(value) {
     return res;
 }
 
-/* @flow */
 var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
@@ -1907,7 +1893,6 @@ function getTagNamespace(tag) {
 }
 makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 function renderClass(node) {
     var classList = genClassForVnode(node);
     if (classList !== '') {
@@ -1915,7 +1900,6 @@ function renderClass(node) {
     }
 }
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -1975,7 +1959,6 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-/* @flow */
 function genStyle(style) {
     var styleText = '';
     for (var key in style) {
@@ -2012,7 +1995,6 @@ function renderStyle(vnode) {
 
 var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-/* @flow */
 function show(node, dir) {
     if (!dir.value) {
         var style = node.data.style || (node.data.style = {});
@@ -2025,7 +2007,6 @@ function show(node, dir) {
     }
 }
 
-/* @flow */
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
 function model$2(node, dir) {
@@ -2068,7 +2049,6 @@ var baseDirectives$1 = {
     model: model$2,
 };
 
-/* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
@@ -2113,7 +2093,6 @@ function __extends(d, b) {
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
 
-/* @flow */
 var MAX_STACK_DEPTH = 800;
 var noop = function (_) { return _; };
 var defer = typeof process !== 'undefined' && process.nextTick
@@ -2159,7 +2138,6 @@ function createWriteFunction(write, onError) {
     return cachedWrite;
 }
 
-/* @flow */
 var RenderStream = /** @class */ (function (_super) {
     __extends(RenderStream, _super);
     function RenderStream(render) {
@@ -2234,7 +2212,6 @@ var RenderStream = /** @class */ (function (_super) {
     return RenderStream;
 }(stream.Readable));
 
-/* @flow */
 var RenderContext = /** @class */ (function () {
     function RenderContext(options) {
         this.userContext = options.userContext;
@@ -2332,7 +2309,6 @@ function normalizeAsync(cache, method) {
     }
 }
 
-/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
     var inSingle = false;
@@ -2456,7 +2432,6 @@ function wrapFilter(exp, filter) {
     }
 }
 
-/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -2497,7 +2472,6 @@ function parseText(text, delimiters) {
     };
 }
 
-/* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
     console.error("[Vue compiler]: " + msg);
@@ -2664,7 +2638,6 @@ function rangeSetItem(item, range) {
     return item;
 }
 
-/* @flow */
 function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
@@ -2701,7 +2674,6 @@ var klass = {
     genData: genData$2,
 };
 
-/* @flow */
 function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
@@ -3026,7 +2998,6 @@ function parseHTML(html, options) {
     }
 }
 
-/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
@@ -3152,7 +3123,6 @@ function parseString(chr) {
     }
 }
 
-/* @flow */
 var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
@@ -3951,7 +3921,6 @@ function checkForAliasModel(el, value) {
     }
 }
 
-/* @flow */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
         var map = el.attrsMap;
@@ -4019,7 +3988,6 @@ var model$1 = {
 
 var modules = [klass, style, model$1];
 
-/* @flow */
 var warn;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -4135,14 +4103,12 @@ function genDefaultModel(el, value, modifiers) {
     }
 }
 
-/* @flow */
 function text(el, dir) {
     if (dir.value) {
         addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
-/* @flow */
 function html(el, dir) {
     if (dir.value) {
         addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -4155,7 +4121,6 @@ var directives = {
     html: html,
 };
 
-/* @flow */
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -4170,7 +4135,6 @@ var baseOptions = {
     staticKeys: genStaticKeys(modules),
 };
 
-/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -4322,7 +4286,6 @@ function genFilterCode(key) {
         ")");
 }
 
-/* @flow */
 function on(el, dir) {
     if (dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
@@ -4330,21 +4293,18 @@ function on(el, dir) {
     el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
-/* @flow */
 function bind(el, dir) {
     el.wrapData = function (code) {
         return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
-/* @flow */
 var baseDirectives = {
     on: on,
     bind: bind,
     cloak: noop$1,
 };
 
-/* @flow */
 var CodegenState = /** @class */ (function () {
     function CodegenState(options) {
         this.options = options;
@@ -4825,7 +4785,6 @@ function transformSpecialNewlines(text) {
     return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/* @flow */
 var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
 // let the model AST transform translate v-model into appropriate
 // props bindings
@@ -4913,7 +4872,6 @@ function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExp
     }
 }
 
-/* @flow */
 // optimizability constants
 var optimizability = {
     FALSE: 0,
@@ -5031,7 +4989,6 @@ function isSelectWithModel(node) {
         node.directives.some(function (d) { return d.name === 'model'; }));
 }
 
-/* @flow */
 // segment types
 var RAW = 0;
 var INTERPOLATION = 1;
@@ -5226,7 +5183,6 @@ function flattenSegments(segments) {
     return mergedSegments.join('+');
 }
 
-/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
 var prohibitedKeywordRE = new RegExp('\\b' +
@@ -5335,7 +5291,6 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
     }
 }
 
-/* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
     if (start === void 0) { start = 0; }
@@ -5386,7 +5341,6 @@ function repeat(str, n) {
     return result;
 }
 
-/* @flow */
 function createFunction(code, errors) {
     try {
         return new Function(code);
@@ -5477,7 +5431,6 @@ function createCompileToFunctionFn(compile) {
     };
 }
 
-/* @flow */
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
@@ -5535,7 +5488,6 @@ function createCompilerCreator(baseCompile) {
     };
 }
 
-/* @flow */
 var createCompiler = createCompilerCreator(function baseCompile(template, options) {
     var ast = parse(template.trim(), options);
     optimize(ast, options);
@@ -5547,10 +5499,8 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-/* @flow */
 var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
-/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -5637,7 +5587,6 @@ function normalizeArrayChildren(children, nestedIndex) {
     return res;
 }
 
-/* @flow */
 var ssrHelpers = {
     _ssrEscape: escape,
     _ssrNode: renderStringNode$1,
@@ -5770,7 +5719,6 @@ function renderSSRStyle(staticStyle, dynamic, extra) {
     }
 }
 
-/* @flow */
 var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
@@ -5883,7 +5831,6 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
     }
 }
 
-/* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
@@ -5936,7 +5883,6 @@ function checkProp(res, hash, key, altKey, preserve) {
     return false;
 }
 
-/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
@@ -6129,7 +6075,6 @@ function resolveFilter(id) {
     return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/* @flow */
 function isKeyNotMatch(expect, actual) {
     if (Array.isArray(expect)) {
         return expect.indexOf(actual) === -1;
@@ -6156,7 +6101,6 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
@@ -6244,7 +6188,6 @@ function markStaticNode(node, key, isOnce) {
     node.isOnce = isOnce;
 }
 
-/* @flow */
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
@@ -6287,7 +6230,6 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
-/* @flow */
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -6309,7 +6251,6 @@ function prependModifier(value, symbol) {
     return typeof value === 'string' ? symbol + value : value;
 }
 
-/* @flow */
 function installRenderHelpers(target) {
     target._o = markOnce;
     target._n = toNumber;
@@ -6330,7 +6271,6 @@ function installRenderHelpers(target) {
     target._p = prependModifier;
 }
 
-/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
@@ -6376,7 +6316,6 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     var res;
     var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -6450,7 +6389,6 @@ function proxyNormalSlot(slots, key) {
     return function () { return slots[key]; };
 }
 
-/* @flow */
 function createAsyncPlaceholder(factory, data, context, children, tag) {
     var node = createEmptyVNode();
     node.asyncFactory = factory;
@@ -6469,7 +6407,6 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-/* @flow */
 var target;
 function add(event, fn) {
     target.$on(event, fn);
@@ -6492,7 +6429,6 @@ function updateComponentListeners(vm, listeners, oldListeners) {
     target = undefined;
 }
 
-/* @flow */
 var activeInstance = null;
 function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
     // determine whether component has slot children
@@ -6608,7 +6544,6 @@ function callHook(vm, hook) {
     popTarget();
 }
 
-/* @flow */
 // Async edge case fix requires storing an event listener's attach timestamp.
 var getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
@@ -6639,7 +6574,6 @@ function queueActivatedComponent(vm) {
     vm._inactive = false;
 }
 
-/* @flow */
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
@@ -6678,7 +6612,6 @@ function resolveInject(inject, vm) {
     }
 }
 
-/* @flow */
 function resolveConstructorOptions(Ctor) {
     var options = Ctor.options;
     if (Ctor.super) {
@@ -6716,7 +6649,6 @@ function resolveModifiedOptions(Ctor) {
     return modified;
 }
 
-/* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
     var _this = this;
     var options = Ctor.options;
@@ -6831,7 +6763,6 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
     init: function (vnode, hydrating) {
@@ -7025,7 +6956,6 @@ function transformModel(options, data) {
     }
 }
 
-/* @flow */
 var warned = Object.create(null);
 var warnOnce = function (msg) {
     if (!warned[msg]) {
@@ -7411,7 +7341,6 @@ function createRenderFunction(modules, directives, isUnaryTag, cache) {
     };
 }
 
-/* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
 function createPromiseCallback() {
@@ -7428,7 +7357,6 @@ function createPromiseCallback() {
     return { promise: promise, cb: cb };
 }
 
-/* @flow */
 var TemplateStream = /** @class */ (function (_super) {
     __extends(TemplateStream, _super);
     function TemplateStream(renderer, template, context) {
@@ -7489,7 +7417,6 @@ var TemplateStream = /** @class */ (function (_super) {
     return TemplateStream;
 }(stream.Transform));
 
-/* @flow */
 var compile = require('lodash.template');
 var compileOptions = {
     escape: /{{([^{][\s\S]+?[^}])}}/g,
@@ -7518,7 +7445,6 @@ function parseTemplate(template, contentPlaceholder) {
     };
 }
 
-/* @flow */
 function createMapper(clientManifest) {
     var map = createMap(clientManifest);
     // map server-side moduleIds to client-side files
@@ -7559,7 +7485,6 @@ function mapIdToFile(id, clientManifest) {
     return files;
 }
 
-/* @flow */
 var path$2 = require('path');
 var serialize = require('serialize-javascript');
 var TemplateRenderer = /** @class */ (function () {
@@ -7798,7 +7723,6 @@ function getPreloadType(ext) {
     }
 }
 
-/* @flow */
 function createRenderer$1(_a) {
     var _b = _a === void 0 ? {} : _a, _c = _b.modules, modules = _c === void 0 ? [] : _c, _d = _b.directives, directives = _d === void 0 ? {} : _d, _e = _b.isUnaryTag, isUnaryTag = _e === void 0 ? function () { return false; } : _e, template = _b.template, inject = _b.inject, cache = _b.cache, shouldPreload = _b.shouldPreload, shouldPrefetch = _b.shouldPrefetch, clientManifest = _b.clientManifest, serializer = _b.serializer;
     var render = createRenderFunction(modules, directives, isUnaryTag, cache);
@@ -8061,7 +7985,6 @@ function createBundleRunner(entry, files, basedir, runInNewContext) {
     }
 }
 
-/* @flow */
 var SourceMapConsumer = require('source-map').SourceMapConsumer;
 var filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
 function createSourceMapConsumers(rawMaps) {
@@ -8103,7 +8026,6 @@ function rewriteTraceLine(trace, mapConsumers) {
     }
 }
 
-/* @flow */
 var fs = require('fs');
 var path = require('path');
 var PassThrough = require('stream').PassThrough;
@@ -8220,7 +8142,6 @@ function createBundleRendererCreator(createRenderer) {
     };
 }
 
-/* @flow */
 process.env.VUE_ENV = 'server';
 function createRenderer(options) {
     if (options === void 0) { options = {}; }
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index 93d102c335e..a7bb71893a0 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -50,8 +50,7 @@
     return i
   }
 
-  /* @flow */
-  var emptyObject = Object.freeze({});
+    var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
   function isUndef(v) {
@@ -194,8 +193,7 @@
           .join(',');
   }
 
-  /* @flow */
-  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
@@ -208,8 +206,7 @@
       'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
       'title,tr,track');
 
-  /* @flow */
-  /**
+    /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
@@ -514,8 +511,7 @@
       }
   }
 
-  /* @flow */
-  var splitRE = /\r?\n/g;
+    var splitRE = /\r?\n/g;
   var replaceRE = /./g;
   var isSpecialTag = makeMap('script,style,template', true);
   /**
@@ -631,8 +627,7 @@
       return sfc;
   }
 
-  /* @flow */
-  // can we use __proto__?
+    // can we use __proto__?
   var hasProto = '__proto__' in {};
   // Browser environment sniffing
   var inBrowser = typeof window !== 'undefined';
@@ -730,8 +725,7 @@
       'errorCaptured',
       'serverPrefetch' ];
 
-  /* @flow */
-  var config = {
+    var config = {
       /**
        * Option merge strategies (used in core/util/options)
        */
@@ -809,8 +803,7 @@
       _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  /* @flow */
-  var warn$2 = noop;
+    var warn$2 = noop;
   var tip = noop;
   var generateComponentTrace; // work around flow check
   var formatComponentName;
@@ -1215,8 +1208,7 @@
       }
   }
 
-  /* @flow */
-  /**
+    /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
@@ -1425,8 +1417,7 @@
       }
   }
 
-  /* @flow */
-  var callbacks = [];
+    var callbacks = [];
   function flushCallbacks() {
       var copies = callbacks.slice(0);
       callbacks.length = 0;
@@ -1460,8 +1451,7 @@
   else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
   else ;
 
-  /* @flow */
-  // these are reserved for web because they are directly compiled away
+    // these are reserved for web because they are directly compiled away
   // during template compilation
   makeMap('style,class');
   // attributes that should be using props for binding
@@ -1481,8 +1471,7 @@
       'required,reversed,scoped,seamless,selected,sortable,' +
       'truespeed,typemustmatch,visible');
 
-  /* @flow */
-  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
       'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
       'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -1514,8 +1503,7 @@
   }
   makeMap('text,number,password,search,email,tel,url');
 
-  /* @flow */
-  var validDivisionCharRE = /[\w).+\-_$\]]/;
+    var validDivisionCharRE = /[\w).+\-_$\]]/;
   function parseFilters(exp) {
       var inSingle = false;
       var inDouble = false;
@@ -1638,8 +1626,7 @@
       }
   }
 
-  /* @flow */
-  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+    var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
   var buildRegex = cached(function (delimiters) {
       var open = delimiters[0].replace(regexEscapeRE, '\\$&');
@@ -1679,8 +1666,7 @@
       };
   }
 
-  /* @flow */
-  /* eslint-disable no-unused-vars */
+    /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
       console.error("[Vue compiler]: " + msg);
   }
@@ -1846,8 +1832,7 @@
       return item;
   }
 
-  /* @flow */
-  function transformNode$1(el, options) {
+    function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
       if (staticClass) {
@@ -1883,8 +1868,7 @@
       genData: genData$2,
   };
 
-  /* @flow */
-  var parseStyleText = cached(function (cssText) {
+    var parseStyleText = cached(function (cssText) {
       var res = {};
       var listDelimiter = /;(?![^(]*\))/g;
       var propertyDelimiter = /:(.+)/;
@@ -1897,8 +1881,7 @@
       return res;
   });
 
-  /* @flow */
-  function transformNode(el, options) {
+    function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
       if (staticStyle) {
@@ -1935,8 +1918,7 @@
       genData: genData$1,
   };
 
-  /* @flow */
-  /**
+    /**
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
@@ -2061,8 +2043,7 @@
       }
   }
 
-  /* @flow */
-  var he = require('he');
+    var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -2860,8 +2841,7 @@
       }
   }
 
-  /* @flow */
-  function preTransformNode(el, options) {
+    function preTransformNode(el, options) {
       if (el.tag === 'input') {
           var map = el.attrsMap;
           if (!map['v-model']) {
@@ -2928,8 +2908,7 @@
 
   var modules = [klass, style, model$1];
 
-  /* @flow */
-  var warn;
+    var warn;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
@@ -3044,15 +3023,13 @@
       }
   }
 
-  /* @flow */
-  function text(el, dir) {
+    function text(el, dir) {
       if (dir.value) {
           addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
-  /* @flow */
-  function html(el, dir) {
+    function html(el, dir) {
       if (dir.value) {
           addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
       }
@@ -3064,8 +3041,7 @@
       html: html,
   };
 
-  /* @flow */
-  var baseOptions = {
+    var baseOptions = {
       expectHTML: true,
       modules: modules,
       directives: directives,
@@ -3079,8 +3055,7 @@
       staticKeys: genStaticKeys$1(modules),
   };
 
-  /* @flow */
-  var isStaticKey;
+    var isStaticKey;
   var isPlatformReservedTag$1;
   var genStaticKeysCached = cached(genStaticKeys);
   /**
@@ -3197,8 +3172,7 @@
       return false;
   }
 
-  /* @flow */
-  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+    var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
   // KeyboardEvent.keyCode aliases
@@ -3349,30 +3323,26 @@
           ")");
   }
 
-  /* @flow */
-  function on(el, dir) {
+    function on(el, dir) {
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
       }
       el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
-  /* @flow */
-  function bind(el, dir) {
+    function bind(el, dir) {
       el.wrapData = function (code) {
           return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
-  /* @flow */
-  var baseDirectives = {
+    var baseDirectives = {
       on: on,
       bind: bind,
       cloak: noop,
   };
 
-  /* @flow */
-  var CodegenState = /** @class */ (function () {
+    var CodegenState = /** @class */ (function () {
       function CodegenState(options) {
           this.options = options;
           this.warn = options.warn || baseWarn;
@@ -3852,8 +3822,7 @@
       return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  /* @flow */
-  // these keywords should not appear inside expressions, but operators like
+    // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
   var prohibitedKeywordRE = new RegExp('\\b' +
       ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
@@ -3961,8 +3930,7 @@
       }
   }
 
-  /* @flow */
-  var range = 2;
+    var range = 2;
   function generateCodeFrame(source, start, end) {
       if (start === void 0) { start = 0; }
       if (end === void 0) { end = source.length; }
@@ -4012,8 +3980,7 @@
       return result;
   }
 
-  /* @flow */
-  function createFunction(code, errors) {
+    function createFunction(code, errors) {
       try {
           return new Function(code);
       }
@@ -4103,8 +4070,7 @@
       };
   }
 
-  /* @flow */
-  function createCompilerCreator(baseCompile) {
+    function createCompilerCreator(baseCompile) {
       return function createCompiler(baseOptions) {
           function compile(template, options) {
               var finalOptions = Object.create(baseOptions);
@@ -4161,8 +4127,7 @@
       };
   }
 
-  /* @flow */
-  // `createCompilerCreator` allows creating compilers that use alternative
+    // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
   var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
@@ -4178,11 +4143,9 @@
       };
   });
 
-  /* @flow */
-  var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
+    var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
 
-  /* @flow */
-  var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
       'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
       'checked,cite,class,code,codebase,color,cols,colspan,content,' +
       'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
@@ -4218,8 +4181,7 @@
       return ESC[a] || a;
   }
 
-  /* @flow */
-  var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+    var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
   // let the model AST transform translate v-model into appropriate
   // props bindings
   function applyModelTransform(el, state) {
@@ -4306,8 +4268,7 @@
       }
   }
 
-  /* @flow */
-  // optimizability constants
+    // optimizability constants
   var optimizability = {
       FALSE: 0,
       FULL: 1,
@@ -4424,8 +4385,7 @@
           node.directives.some(function (d) { return d.name === 'model'; }));
   }
 
-  /* @flow */
-  // segment types
+    // segment types
   var RAW = 0;
   var INTERPOLATION = 1;
   var EXPRESSION = 2;
@@ -4619,8 +4579,7 @@
       return mergedSegments.join('+');
   }
 
-  /* @flow */
-  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var createCompiler = createCompilerCreator(function baseCompile(template, options) {
       var ast = parse(template.trim(), options);
       optimize(ast, options);
       var code = generate(ast, options);
@@ -4631,8 +4590,7 @@
       };
   });
 
-  /* @flow */
-  var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
+    var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
 
   exports.compile = compile$1;
   exports.compileToFunctions = compileToFunctions$1;
diff --git a/scripts/config.js b/scripts/config.js
index 2d6794186cb..ee272d1f489 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -5,7 +5,7 @@ const cjs = require('@rollup/plugin-commonjs')
 const replace = require('@rollup/plugin-replace')
 const node = require('@rollup/plugin-node-resolve').nodeResolve
 const ts = require('rollup-plugin-typescript2')
-const babel = require('@rollup/plugin-babel').babel
+// const babel = require('@rollup/plugin-babel').babel
 
 const version = process.env.VERSION || require('../package.json').version
 const weexVersion = process.env.WEEX_VERSION || require('../packages/weex-vue-framework/package.json').version
diff --git a/src/compiler/codeframe.ts b/src/compiler/codeframe.ts
index 037e07ea23c..7fdd132476f 100644
--- a/src/compiler/codeframe.ts
+++ b/src/compiler/codeframe.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const range = 2
 
diff --git a/src/compiler/codegen/events.ts b/src/compiler/codegen/events.ts
index 47f66a59823..1fbe914f41e 100644
--- a/src/compiler/codegen/events.ts
+++ b/src/compiler/codegen/events.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
 const fnInvokeRE = /\([^)]*?\);*$/
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index e7cc7bd1185..58991acf756 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { genHandlers } from './events'
 import baseDirectives from '../directives/index'
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index 6f5f2b9493d..5f7414488ca 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { extend } from 'shared/util'
 import { detectErrors } from './error-detector'
diff --git a/src/compiler/directives/bind.ts b/src/compiler/directives/bind.ts
index 7bf69426d0c..409852ba5f1 100644
--- a/src/compiler/directives/bind.ts
+++ b/src/compiler/directives/bind.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 export default function bind(el: ASTElement, dir: ASTDirective) {
   el.wrapData = (code: string) => {
diff --git a/src/compiler/directives/index.ts b/src/compiler/directives/index.ts
index 3b31e554b60..e04df4f1071 100644
--- a/src/compiler/directives/index.ts
+++ b/src/compiler/directives/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import on from './on'
 import bind from './bind'
diff --git a/src/compiler/directives/model.ts b/src/compiler/directives/model.ts
index a5e69df236e..39262b53777 100644
--- a/src/compiler/directives/model.ts
+++ b/src/compiler/directives/model.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 /**
  * Cross-platform code generation for component v-model
diff --git a/src/compiler/directives/on.ts b/src/compiler/directives/on.ts
index 435ff16bbb0..2ca2d124a07 100644
--- a/src/compiler/directives/on.ts
+++ b/src/compiler/directives/on.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { warn } from 'core/util/index'
 
diff --git a/src/compiler/error-detector.ts b/src/compiler/error-detector.ts
index e41394c34ed..3b81742298f 100644
--- a/src/compiler/error-detector.ts
+++ b/src/compiler/error-detector.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { dirRE, onRE } from './parser/index'
 
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index cbb316d64aa..aad4823470e 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { emptyObject } from 'shared/util'
 import { parseFilters } from './parser/filter-parser'
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index 35da8abc696..997689ccd2b 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parse } from './parser/index'
 import { optimize } from './optimizer'
diff --git a/src/compiler/optimizer.ts b/src/compiler/optimizer.ts
index d33f7036d68..5b4cb718df9 100644
--- a/src/compiler/optimizer.ts
+++ b/src/compiler/optimizer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { makeMap, isBuiltInTag, cached, no } from 'shared/util'
 
diff --git a/src/compiler/parser/entity-decoder.ts b/src/compiler/parser/entity-decoder.ts
index d681297c3c7..7e693d8ab0e 100644
--- a/src/compiler/parser/entity-decoder.ts
+++ b/src/compiler/parser/entity-decoder.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 let decoder
 
diff --git a/src/compiler/parser/filter-parser.ts b/src/compiler/parser/filter-parser.ts
index 0703a86feb4..17d07276b56 100644
--- a/src/compiler/parser/filter-parser.ts
+++ b/src/compiler/parser/filter-parser.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const validDivisionCharRE = /[\w).+\-_$\]]/
 
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index b5f9be295c6..2eb55b07d4f 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const he = require('he')
 // import * as he from 'he'
diff --git a/src/compiler/parser/text-parser.ts b/src/compiler/parser/text-parser.ts
index bb4dcd7a5eb..a1e569a16df 100644
--- a/src/compiler/parser/text-parser.ts
+++ b/src/compiler/parser/text-parser.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { cached } from 'shared/util'
 import { parseFilters } from './filter-parser'
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index 6a434fbccf2..125655e1d21 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
diff --git a/src/core/config.ts b/src/core/config.ts
index 893f62228df..eb202b2cb3c 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { no, noop, identity } from 'shared/util'
 
diff --git a/src/core/global-api/assets.ts b/src/core/global-api/assets.ts
index cdfe18fc6bc..82f02a30597 100644
--- a/src/core/global-api/assets.ts
+++ b/src/core/global-api/assets.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { ASSET_TYPES } from 'shared/constants'
 import type { GlobalAPI } from 'typescript/global-api'
diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index 546ae0b0659..bcb210b97ff 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { ASSET_TYPES } from 'shared/constants'
 import type { Component } from 'typescript/component'
diff --git a/src/core/global-api/index.ts b/src/core/global-api/index.ts
index 74c2dce8cd1..008dea41077 100644
--- a/src/core/global-api/index.ts
+++ b/src/core/global-api/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import { initUse } from './use'
diff --git a/src/core/global-api/mixin.ts b/src/core/global-api/mixin.ts
index 9947a5b22ee..7b53b510f66 100644
--- a/src/core/global-api/mixin.ts
+++ b/src/core/global-api/mixin.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import type { GlobalAPI } from 'typescript/global-api'
 import { mergeOptions } from '../util/index'
diff --git a/src/core/global-api/use.ts b/src/core/global-api/use.ts
index ea5b1e91571..a0f8eace629 100644
--- a/src/core/global-api/use.ts
+++ b/src/core/global-api/use.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import type { GlobalAPI } from 'typescript/global-api'
 import { toArray } from '../util/index'
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index f8d301cc663..c7f5e2d11ff 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import type { Component } from 'typescript/component'
 import {
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 298370fe703..c03083a4a13 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import { initProxy } from './proxy'
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index d61a99b8f26..466e50033b0 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { hasOwn } from 'shared/util'
 import { warn, hasSymbol } from '../util/index'
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index bcd6d65b2f8..744c5d4574b 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import Watcher from '../observer/watcher'
diff --git a/src/core/instance/render-helpers/bind-dynamic-keys.ts b/src/core/instance/render-helpers/bind-dynamic-keys.ts
index d9fb03a377e..455b9647588 100644
--- a/src/core/instance/render-helpers/bind-dynamic-keys.ts
+++ b/src/core/instance/render-helpers/bind-dynamic-keys.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 // For example, the following template:
diff --git a/src/core/instance/render-helpers/bind-object-listeners.ts b/src/core/instance/render-helpers/bind-object-listeners.ts
index 858fe233d78..648f01b6d76 100644
--- a/src/core/instance/render-helpers/bind-object-listeners.ts
+++ b/src/core/instance/render-helpers/bind-object-listeners.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { warn, extend, isPlainObject } from 'core/util/index'
 import type { VNodeData } from 'typescript/vnode'
diff --git a/src/core/instance/render-helpers/bind-object-props.ts b/src/core/instance/render-helpers/bind-object-props.ts
index c5f24c43fd6..eaf4219a932 100644
--- a/src/core/instance/render-helpers/bind-object-props.ts
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from 'core/config'
 
diff --git a/src/core/instance/render-helpers/check-keycodes.ts b/src/core/instance/render-helpers/check-keycodes.ts
index 70f77f798fd..5368b721bcd 100644
--- a/src/core/instance/render-helpers/check-keycodes.ts
+++ b/src/core/instance/render-helpers/check-keycodes.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from 'core/config'
 import { hyphenate } from 'shared/util'
diff --git a/src/core/instance/render-helpers/index.ts b/src/core/instance/render-helpers/index.ts
index 64d131c1004..480e8d9a00f 100644
--- a/src/core/instance/render-helpers/index.ts
+++ b/src/core/instance/render-helpers/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { toNumber, toString, looseEqual, looseIndexOf } from 'shared/util'
 import { createTextVNode, createEmptyVNode } from 'core/vdom/vnode'
diff --git a/src/core/instance/render-helpers/resolve-slots.ts b/src/core/instance/render-helpers/resolve-slots.ts
index d6a780272bc..1a98719eec2 100644
--- a/src/core/instance/render-helpers/resolve-slots.ts
+++ b/src/core/instance/render-helpers/resolve-slots.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import type VNode from 'core/vdom/vnode'
 import type { Component } from 'typescript/component'
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index c16c6c60f13..887beb61531 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import {
   warn,
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index d337b1a084b..9ea7d2188f9 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import Watcher from '../observer/watcher'
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index 42a84d0fdcc..efeaec64c0e 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import type Watcher from './watcher'
 import config from '../config'
diff --git a/src/core/observer/traverse.ts b/src/core/observer/traverse.ts
index 7523cacdabe..c52efe0ac89 100644
--- a/src/core/observer/traverse.ts
+++ b/src/core/observer/traverse.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { _Set as Set, isObject } from '../util/index'
 import type { SimpleSet } from '../util/index'
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index df929201332..dba4bd5d595 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import {
   warn,
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index ddbea7befe1..ea607b0607e 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import { noop } from 'shared/util'
diff --git a/src/core/util/env.ts b/src/core/util/env.ts
index 28fac6b2fcd..bc7fd82bc5c 100644
--- a/src/core/util/env.ts
+++ b/src/core/util/env.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // can we use __proto__?
 export const hasProto = '__proto__' in {}
diff --git a/src/core/util/index.ts b/src/core/util/index.ts
index 115d77cd175..af73de55cb0 100644
--- a/src/core/util/index.ts
+++ b/src/core/util/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 export * from 'shared/util'
 export * from './lang'
diff --git a/src/core/util/lang.ts b/src/core/util/lang.ts
index e084e30fab9..2f49594b0b1 100644
--- a/src/core/util/lang.ts
+++ b/src/core/util/lang.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 /**
  * unicode letters used for parsing html tags, component names and property paths.
diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index 8d725aa65c9..3f0c80a0e23 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -1,4 +1,3 @@
-/* @flow */
 /* globals MutationObserver */
 
 import { noop } from 'shared/util'
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index c01a8ce21ae..af279c4b0b2 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import { warn } from './debug'
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index d7030ec2939..04a19b685ca 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { warn } from './debug'
 import { observe, toggleObserving, shouldObserve } from '../observer/index'
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index c6e0172c31d..cbe4ce9b3a1 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from './vnode'
 import { resolveConstructorOptions } from 'core/instance/init'
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index e87ef802617..1da4f29a42d 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from '../config'
 import VNode, { createEmptyVNode } from './vnode'
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index 3e1fa3ced88..8d371a82510 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode, { cloneVNode } from './vnode'
 import { createElement } from './create-element'
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index a0507782c0c..26e456e6da5 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import {
   tip,
diff --git a/src/core/vdom/helpers/get-first-component-child.ts b/src/core/vdom/helpers/get-first-component-child.ts
index 664afe0a48f..23a8433ed35 100644
--- a/src/core/vdom/helpers/get-first-component-child.ts
+++ b/src/core/vdom/helpers/get-first-component-child.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { isDef } from 'shared/util'
 import VNode from '../vnode'
diff --git a/src/core/vdom/helpers/index.ts b/src/core/vdom/helpers/index.ts
index 320cf4c4343..50d719e8537 100644
--- a/src/core/vdom/helpers/index.ts
+++ b/src/core/vdom/helpers/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 export * from './merge-hook'
 export * from './extract-props'
diff --git a/src/core/vdom/helpers/is-async-placeholder.ts b/src/core/vdom/helpers/is-async-placeholder.ts
index 3f901578c1a..fe2e12b8a9f 100644
--- a/src/core/vdom/helpers/is-async-placeholder.ts
+++ b/src/core/vdom/helpers/is-async-placeholder.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from '../vnode'
 
diff --git a/src/core/vdom/helpers/merge-hook.ts b/src/core/vdom/helpers/merge-hook.ts
index 4fe811660b0..6c846653126 100644
--- a/src/core/vdom/helpers/merge-hook.ts
+++ b/src/core/vdom/helpers/merge-hook.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from '../vnode'
 import { createFnInvoker } from './update-listeners'
diff --git a/src/core/vdom/helpers/normalize-children.ts b/src/core/vdom/helpers/normalize-children.ts
index 201210a17cd..b9bb12dd8f5 100644
--- a/src/core/vdom/helpers/normalize-children.ts
+++ b/src/core/vdom/helpers/normalize-children.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode, { createTextVNode } from 'core/vdom/vnode'
 import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index 24548796c5d..9ac3ebbd05c 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { def } from 'core/util/lang'
 import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
diff --git a/src/core/vdom/helpers/resolve-async-component.ts b/src/core/vdom/helpers/resolve-async-component.ts
index 532425ca594..c3d7c61c34f 100644
--- a/src/core/vdom/helpers/resolve-async-component.ts
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import {
   warn,
diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 9b89aa5cba1..dd17ca19069 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { emptyNode } from 'core/vdom/patch'
 import { resolveAsset, handleError } from 'core/util/index'
diff --git a/src/core/vdom/modules/ref.ts b/src/core/vdom/modules/ref.ts
index 74cf22635bc..662c5c46550 100644
--- a/src/core/vdom/modules/ref.ts
+++ b/src/core/vdom/modules/ref.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { remove, isDef } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/web/compiler/directives/html.ts b/src/platforms/web/compiler/directives/html.ts
index 631c3652b34..b12be5e616f 100644
--- a/src/platforms/web/compiler/directives/html.ts
+++ b/src/platforms/web/compiler/directives/html.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addProp } from 'compiler/helpers'
 
diff --git a/src/platforms/web/compiler/directives/model.ts b/src/platforms/web/compiler/directives/model.ts
index 7b9d0f0d4ec..82892dc26e2 100644
--- a/src/platforms/web/compiler/directives/model.ts
+++ b/src/platforms/web/compiler/directives/model.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import config from 'core/config'
 import { addHandler, addProp, getBindingAttr } from 'compiler/helpers'
diff --git a/src/platforms/web/compiler/directives/text.ts b/src/platforms/web/compiler/directives/text.ts
index 59bffc79953..1502797c477 100644
--- a/src/platforms/web/compiler/directives/text.ts
+++ b/src/platforms/web/compiler/directives/text.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addProp } from 'compiler/helpers'
 
diff --git a/src/platforms/web/compiler/index.ts b/src/platforms/web/compiler/index.ts
index 7ace0936d46..5e50ce90c86 100644
--- a/src/platforms/web/compiler/index.ts
+++ b/src/platforms/web/compiler/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { baseOptions } from './options'
 import { createCompiler } from 'compiler/index'
diff --git a/src/platforms/web/compiler/modules/class.ts b/src/platforms/web/compiler/modules/class.ts
index a8f4ceb9dda..81a02947577 100644
--- a/src/platforms/web/compiler/modules/class.ts
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parseText } from 'compiler/parser/text-parser'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
diff --git a/src/platforms/web/compiler/modules/model.ts b/src/platforms/web/compiler/modules/model.ts
index b1b17994747..955fbb7df63 100644
--- a/src/platforms/web/compiler/modules/model.ts
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 /**
  * Expand input[v-model] with dynamic type bindings into v-if-else chains
diff --git a/src/platforms/web/compiler/modules/style.ts b/src/platforms/web/compiler/modules/style.ts
index 114e94443bd..bb5eb4869c9 100644
--- a/src/platforms/web/compiler/modules/style.ts
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parseText } from 'compiler/parser/text-parser'
 import { parseStyleText } from 'web/util/style'
diff --git a/src/platforms/web/compiler/options.ts b/src/platforms/web/compiler/options.ts
index 975bbe57399..d8e3d467c21 100644
--- a/src/platforms/web/compiler/options.ts
+++ b/src/platforms/web/compiler/options.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import {
   isPreTag,
diff --git a/src/platforms/web/compiler/util.ts b/src/platforms/web/compiler/util.ts
index 88fa745dc35..b1412c07475 100644
--- a/src/platforms/web/compiler/util.ts
+++ b/src/platforms/web/compiler/util.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { makeMap } from 'shared/util'
 
diff --git a/src/platforms/web/entry-compiler.ts b/src/platforms/web/entry-compiler.ts
index 15a4f685999..b14a1f699fe 100644
--- a/src/platforms/web/entry-compiler.ts
+++ b/src/platforms/web/entry-compiler.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 export { parseComponent } from 'sfc/parser'
 export { compile, compileToFunctions } from './compiler/index'
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index 846e92877ef..8ac91a4e1bd 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -1,4 +1,3 @@
-/* @flow */
 import config from 'core/config'
 import { warn, cached } from 'core/util/index'
 import { mark, measure } from 'core/util/perf'
diff --git a/src/platforms/web/entry-runtime.ts b/src/platforms/web/entry-runtime.ts
index 27c97ff014b..0ce6019264f 100644
--- a/src/platforms/web/entry-runtime.ts
+++ b/src/platforms/web/entry-runtime.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import Vue from './runtime/index'
 
diff --git a/src/platforms/web/entry-server-basic-renderer.ts b/src/platforms/web/entry-server-basic-renderer.ts
index 836b02b5df0..9c6d3175f5d 100644
--- a/src/platforms/web/entry-server-basic-renderer.ts
+++ b/src/platforms/web/entry-server-basic-renderer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import modules from './server/modules/index'
 import directives from './server/directives/index'
diff --git a/src/platforms/web/entry-server-renderer.ts b/src/platforms/web/entry-server-renderer.ts
index a640e6d5810..d0e7f8fb00c 100644
--- a/src/platforms/web/entry-server-renderer.ts
+++ b/src/platforms/web/entry-server-renderer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 process.env.VUE_ENV = 'server'
 
diff --git a/src/platforms/web/runtime/class-util.ts b/src/platforms/web/runtime/class-util.ts
index 93a19ae7b97..b24cce0d9b2 100644
--- a/src/platforms/web/runtime/class-util.ts
+++ b/src/platforms/web/runtime/class-util.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const whitespaceRE = /\s+/
 
diff --git a/src/platforms/web/runtime/components/transition.ts b/src/platforms/web/runtime/components/transition.ts
index 12d299a1987..a1f82e3c1dc 100644
--- a/src/platforms/web/runtime/components/transition.ts
+++ b/src/platforms/web/runtime/components/transition.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // Provides transition support for a single element/component.
 // supports transition mode (out-in / in-out)
diff --git a/src/platforms/web/runtime/directives/show.ts b/src/platforms/web/runtime/directives/show.ts
index 1a9991ab118..f1219a9751d 100644
--- a/src/platforms/web/runtime/directives/show.ts
+++ b/src/platforms/web/runtime/directives/show.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/web/runtime/modules/attrs.ts b/src/platforms/web/runtime/modules/attrs.ts
index 42e6d8e12e3..780e283b6cf 100644
--- a/src/platforms/web/runtime/modules/attrs.ts
+++ b/src/platforms/web/runtime/modules/attrs.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { isIE, isIE9, isEdge } from 'core/util/env'
 
diff --git a/src/platforms/web/runtime/modules/class.ts b/src/platforms/web/runtime/modules/class.ts
index 6046f9b4751..3f183098360 100644
--- a/src/platforms/web/runtime/modules/class.ts
+++ b/src/platforms/web/runtime/modules/class.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { isDef, isUndef } from 'shared/util'
 import type { VNodeData } from 'typescript/vnode'
diff --git a/src/platforms/web/runtime/modules/dom-props.ts b/src/platforms/web/runtime/modules/dom-props.ts
index aa080c6b5df..f2decc84406 100644
--- a/src/platforms/web/runtime/modules/dom-props.ts
+++ b/src/platforms/web/runtime/modules/dom-props.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { isDef, isUndef, extend, toNumber } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/web/runtime/modules/events.ts b/src/platforms/web/runtime/modules/events.ts
index fd9923aa2d1..6cb75f9faeb 100644
--- a/src/platforms/web/runtime/modules/events.ts
+++ b/src/platforms/web/runtime/modules/events.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { isDef, isUndef } from 'shared/util'
 import { updateListeners } from 'core/vdom/helpers/index'
diff --git a/src/platforms/web/runtime/modules/style.ts b/src/platforms/web/runtime/modules/style.ts
index 45d042d341f..c40c9f50fb8 100644
--- a/src/platforms/web/runtime/modules/style.ts
+++ b/src/platforms/web/runtime/modules/style.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { getStyle, normalizeStyleBinding } from 'web/util/style'
 import {
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index 21e33b7a54a..aff7d09e45a 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { inBrowser, isIE9, warn } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
diff --git a/src/platforms/web/runtime/node-ops.ts b/src/platforms/web/runtime/node-ops.ts
index d90dc9c0474..5eca28e3615 100644
--- a/src/platforms/web/runtime/node-ops.ts
+++ b/src/platforms/web/runtime/node-ops.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 import { namespaceMap } from 'web/util/index'
diff --git a/src/platforms/web/runtime/patch.ts b/src/platforms/web/runtime/patch.ts
index d982afe92f6..76cc4c0cc3f 100644
--- a/src/platforms/web/runtime/patch.ts
+++ b/src/platforms/web/runtime/patch.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import * as nodeOps from 'web/runtime/node-ops'
 import { createPatchFunction } from 'core/vdom/patch'
diff --git a/src/platforms/web/server/compiler.ts b/src/platforms/web/server/compiler.ts
index c442633fc80..55dc68ec3f9 100644
--- a/src/platforms/web/server/compiler.ts
+++ b/src/platforms/web/server/compiler.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { baseOptions } from '../compiler/options'
 import { createCompiler } from 'server/optimizing-compiler/index'
diff --git a/src/platforms/web/server/directives/model.ts b/src/platforms/web/server/directives/model.ts
index 7ba5600182d..cab659512b7 100644
--- a/src/platforms/web/server/directives/model.ts
+++ b/src/platforms/web/server/directives/model.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { looseEqual, looseIndexOf } from 'shared/util'
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/web/server/directives/show.ts b/src/platforms/web/server/directives/show.ts
index ed1a7a4a2cf..3ab67bf6266 100644
--- a/src/platforms/web/server/directives/show.ts
+++ b/src/platforms/web/server/directives/show.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 
diff --git a/src/platforms/web/server/modules/attrs.ts b/src/platforms/web/server/modules/attrs.ts
index 18b2938b7d4..e64f24dc053 100644
--- a/src/platforms/web/server/modules/attrs.ts
+++ b/src/platforms/web/server/modules/attrs.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { escape } from '../util'
 
diff --git a/src/platforms/web/server/modules/class.ts b/src/platforms/web/server/modules/class.ts
index 1db7206b4cc..f087c7f5d86 100644
--- a/src/platforms/web/server/modules/class.ts
+++ b/src/platforms/web/server/modules/class.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { escape } from '../util'
 import { genClassForVnode } from 'web/util/index'
diff --git a/src/platforms/web/server/modules/dom-props.ts b/src/platforms/web/server/modules/dom-props.ts
index 1676c8949f4..e57bf9cab04 100644
--- a/src/platforms/web/server/modules/dom-props.ts
+++ b/src/platforms/web/server/modules/dom-props.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 import { renderAttr } from './attrs'
diff --git a/src/platforms/web/server/modules/style.ts b/src/platforms/web/server/modules/style.ts
index 0e14124d0c7..d9ea3901c40 100644
--- a/src/platforms/web/server/modules/style.ts
+++ b/src/platforms/web/server/modules/style.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { escape, noUnitNumericStyleProps } from '../util'
 import { hyphenate } from 'shared/util'
diff --git a/src/platforms/web/server/util.ts b/src/platforms/web/server/util.ts
index 2538f1fa0da..6ad3a1ed5bf 100644
--- a/src/platforms/web/server/util.ts
+++ b/src/platforms/web/server/util.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { makeMap } from 'shared/util'
 
diff --git a/src/platforms/web/util/attrs.ts b/src/platforms/web/util/attrs.ts
index 49aa22abdac..aa3db7aae03 100644
--- a/src/platforms/web/util/attrs.ts
+++ b/src/platforms/web/util/attrs.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { makeMap } from 'shared/util'
 
diff --git a/src/platforms/web/util/class.ts b/src/platforms/web/util/class.ts
index a2fafe91383..52dbefa7c05 100644
--- a/src/platforms/web/util/class.ts
+++ b/src/platforms/web/util/class.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 import { isDef, isObject } from 'shared/util'
diff --git a/src/platforms/web/util/compat.ts b/src/platforms/web/util/compat.ts
index 48763c47a18..08d1d4e0635 100644
--- a/src/platforms/web/util/compat.ts
+++ b/src/platforms/web/util/compat.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { inBrowser } from 'core/util/index'
 
diff --git a/src/platforms/web/util/element.ts b/src/platforms/web/util/element.ts
index 8c18153ba23..14fc8a3bacc 100644
--- a/src/platforms/web/util/element.ts
+++ b/src/platforms/web/util/element.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { inBrowser } from 'core/util/env'
 import { makeMap } from 'shared/util'
diff --git a/src/platforms/web/util/index.ts b/src/platforms/web/util/index.ts
index 10c6d78019b..d7a53c6bf4e 100644
--- a/src/platforms/web/util/index.ts
+++ b/src/platforms/web/util/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { warn } from 'core/util/index'
 
diff --git a/src/platforms/web/util/style.ts b/src/platforms/web/util/style.ts
index df2306771f2..524c86804c7 100644
--- a/src/platforms/web/util/style.ts
+++ b/src/platforms/web/util/style.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 import { cached, extend, toObject } from 'shared/util'
diff --git a/src/platforms/weex/compiler/directives/model.ts b/src/platforms/weex/compiler/directives/model.ts
index f54df16bb01..e333ddad263 100644
--- a/src/platforms/weex/compiler/directives/model.ts
+++ b/src/platforms/weex/compiler/directives/model.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addHandler, addAttr } from 'compiler/helpers'
 import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
diff --git a/src/platforms/weex/compiler/index.ts b/src/platforms/weex/compiler/index.ts
index 31ecfaa14b0..fb6de3bbfe7 100644
--- a/src/platforms/weex/compiler/index.ts
+++ b/src/platforms/weex/compiler/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { genStaticKeys } from 'shared/util'
 import { createCompiler } from 'compiler/index'
diff --git a/src/platforms/weex/compiler/modules/append.ts b/src/platforms/weex/compiler/modules/append.ts
index 2e916faa295..644b21a0763 100644
--- a/src/platforms/weex/compiler/modules/append.ts
+++ b/src/platforms/weex/compiler/modules/append.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { makeMap } from 'shared/util'
 
diff --git a/src/platforms/weex/compiler/modules/class.ts b/src/platforms/weex/compiler/modules/class.ts
index 5d3f493b18c..602101487d0 100644
--- a/src/platforms/weex/compiler/modules/class.ts
+++ b/src/platforms/weex/compiler/modules/class.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parseText } from 'compiler/parser/text-parser'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
diff --git a/src/platforms/weex/compiler/modules/props.ts b/src/platforms/weex/compiler/modules/props.ts
index 582d8490c33..1bf89d08c54 100644
--- a/src/platforms/weex/compiler/modules/props.ts
+++ b/src/platforms/weex/compiler/modules/props.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { cached, camelize } from 'shared/util'
 
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component-root.ts b/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
index cc81f93062a..f82989cbad1 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addAttr } from 'compiler/helpers'
 
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component.ts b/src/platforms/weex/compiler/modules/recycle-list/component.ts
index f167cf0e1ce..0fa37100901 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/component.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/component.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addAttr } from 'compiler/helpers'
 import type { WeexCompilerOptions } from 'typescript/weex'
diff --git a/src/platforms/weex/compiler/modules/recycle-list/index.ts b/src/platforms/weex/compiler/modules/recycle-list/index.ts
index 9b2ee5bde0b..2fdeab16008 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/index.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { preTransformRecycleList } from './recycle-list'
 import { postTransformComponent } from './component'
diff --git a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
index bc3893ace3f..c3f3a58b72d 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parseFor } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
diff --git a/src/platforms/weex/compiler/modules/recycle-list/text.ts b/src/platforms/weex/compiler/modules/recycle-list/text.ts
index 095c86dce9a..be8cddbc85f 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/text.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/text.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addAttr } from 'compiler/helpers'
 
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts b/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
index b93a9b7a4aa..04b42ff0f27 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { camelize } from 'shared/util'
 import { generateBinding } from 'weex/util/parser'
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-for.ts b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
index 5a99827fa91..c441819c0ba 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parseFor } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
index df29bc02099..d8aaed20886 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { addIfCondition } from 'compiler/parser/index'
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-on.ts b/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
index 7207de4cfd3..94051ad3356 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const inlineStatementRE = /^\s*([A-Za-z_$0-9\['\."\]]+)*\s*\(\s*(([A-Za-z_$0-9\['\."\]]+)?(\s*,\s*([A-Za-z_$0-9\['\."\]]+))*)\s*\)$/
 
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-once.ts b/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
index 22fa78048ad..a3e4d29bc84 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
 
diff --git a/src/platforms/weex/compiler/modules/style.ts b/src/platforms/weex/compiler/modules/style.ts
index 90914e3f6cd..9eda4e83a64 100644
--- a/src/platforms/weex/compiler/modules/style.ts
+++ b/src/platforms/weex/compiler/modules/style.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { cached, camelize, isPlainObject } from 'shared/util'
 import { parseText } from 'compiler/parser/text-parser'
diff --git a/src/platforms/weex/entry-framework.ts b/src/platforms/weex/entry-framework.ts
index 2c8ba3606ec..6dc4622f49c 100644
--- a/src/platforms/weex/entry-framework.ts
+++ b/src/platforms/weex/entry-framework.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { GlobalAPI } from 'typescript/global-api'
 import type {
diff --git a/src/platforms/weex/runtime/components/richtext.ts b/src/platforms/weex/runtime/components/richtext.ts
index 4e9db9c259b..5d3e400a8e3 100644
--- a/src/platforms/weex/runtime/components/richtext.ts
+++ b/src/platforms/weex/runtime/components/richtext.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 
diff --git a/src/platforms/weex/runtime/modules/attrs.ts b/src/platforms/weex/runtime/modules/attrs.ts
index 7d3b3b6b217..fd17bcfde9c 100644
--- a/src/platforms/weex/runtime/modules/attrs.ts
+++ b/src/platforms/weex/runtime/modules/attrs.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { extend } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/weex/runtime/modules/class.ts b/src/platforms/weex/runtime/modules/class.ts
index 80dbac8f1a9..d6eecdad87d 100644
--- a/src/platforms/weex/runtime/modules/class.ts
+++ b/src/platforms/weex/runtime/modules/class.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { extend, isObject } from 'shared/util'
 import type { Component } from 'typescript/component'
diff --git a/src/platforms/weex/runtime/modules/events.ts b/src/platforms/weex/runtime/modules/events.ts
index 1bc1a874568..1605abd9fa9 100644
--- a/src/platforms/weex/runtime/modules/events.ts
+++ b/src/platforms/weex/runtime/modules/events.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { updateListeners } from 'core/vdom/helpers/update-listeners'
 import type { VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/weex/runtime/modules/style.ts b/src/platforms/weex/runtime/modules/style.ts
index 6abcf6fe8d5..81494d54000 100644
--- a/src/platforms/weex/runtime/modules/style.ts
+++ b/src/platforms/weex/runtime/modules/style.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { extend, cached, camelize } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/weex/runtime/node-ops.ts b/src/platforms/weex/runtime/node-ops.ts
index e7ad4d50c90..61aba841d27 100644
--- a/src/platforms/weex/runtime/node-ops.ts
+++ b/src/platforms/weex/runtime/node-ops.ts
@@ -1,4 +1,3 @@
-/* @flow */
 declare var document: WeexDocument
 
 import type { WeexDocument, WeexElement } from 'typescript/weex'
diff --git a/src/platforms/weex/runtime/patch.ts b/src/platforms/weex/runtime/patch.ts
index 3d0f76a6db8..a590411ec01 100644
--- a/src/platforms/weex/runtime/patch.ts
+++ b/src/platforms/weex/runtime/patch.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import * as nodeOps from 'weex/runtime/node-ops'
 import { createPatchFunction } from 'core/vdom/patch'
diff --git a/src/platforms/weex/runtime/recycle-list/render-component-template.ts b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
index 1a7f222e930..8dd61955d95 100644
--- a/src/platforms/weex/runtime/recycle-list/render-component-template.ts
+++ b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { warn } from 'core/util/debug'
 import { handleError } from 'core/util/error'
diff --git a/src/platforms/weex/runtime/recycle-list/virtual-component.ts b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
index a56d520d063..7523e1f7d40 100644
--- a/src/platforms/weex/runtime/recycle-list/virtual-component.ts
+++ b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // https://github.com/Hanks10100/weex-native-directive/tree/master/component
 
diff --git a/src/platforms/weex/util/element.ts b/src/platforms/weex/util/element.ts
index 929f48f4705..b521f39412a 100644
--- a/src/platforms/weex/util/element.ts
+++ b/src/platforms/weex/util/element.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // These util functions are split into its own file because Rollup cannot drop
 // makeMap() due to potential side effects, so these variables end up
diff --git a/src/platforms/weex/util/index.ts b/src/platforms/weex/util/index.ts
index 7f233115c3f..c2492d098c8 100644
--- a/src/platforms/weex/util/index.ts
+++ b/src/platforms/weex/util/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 declare var document: WeexDocument
 
 import { warn } from 'core/util/index'
diff --git a/src/platforms/weex/util/parser.ts b/src/platforms/weex/util/parser.ts
index f43c7d08be6..8414f138056 100644
--- a/src/platforms/weex/util/parser.ts
+++ b/src/platforms/weex/util/parser.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // import { warn } from 'core/util/index'
 
diff --git a/src/server/bundle-renderer/create-bundle-renderer.ts b/src/server/bundle-renderer/create-bundle-renderer.ts
index 83e192e70ec..6e0fc9272b2 100644
--- a/src/server/bundle-renderer/create-bundle-renderer.ts
+++ b/src/server/bundle-renderer/create-bundle-renderer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { createPromiseCallback } from '../util'
 import { createBundleRunner } from './create-bundle-runner'
diff --git a/src/server/bundle-renderer/source-map-support.ts b/src/server/bundle-renderer/source-map-support.ts
index 0990afba57b..27f8a46dcce 100644
--- a/src/server/bundle-renderer/source-map-support.ts
+++ b/src/server/bundle-renderer/source-map-support.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const SourceMapConsumer = require('source-map').SourceMapConsumer
 
diff --git a/src/server/create-basic-renderer.ts b/src/server/create-basic-renderer.ts
index 47867777ff5..6843119f729 100644
--- a/src/server/create-basic-renderer.ts
+++ b/src/server/create-basic-renderer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { createWriteFunction } from './write'
 import { createRenderFunction } from './render'
diff --git a/src/server/create-renderer.ts b/src/server/create-renderer.ts
index 57480a26ea0..0cfd587591a 100644
--- a/src/server/create-renderer.ts
+++ b/src/server/create-renderer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import RenderStream from './render-stream'
 import { createWriteFunction } from './write'
diff --git a/src/server/optimizing-compiler/codegen.ts b/src/server/optimizing-compiler/codegen.ts
index 5d40663a268..1c5dc7bfe65 100644
--- a/src/server/optimizing-compiler/codegen.ts
+++ b/src/server/optimizing-compiler/codegen.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // The SSR codegen is essentially extending the default codegen to handle
 // SSR-optimizable nodes and turn them into string render fns. In cases where
diff --git a/src/server/optimizing-compiler/index.ts b/src/server/optimizing-compiler/index.ts
index 622875d4b68..a07588d37f3 100644
--- a/src/server/optimizing-compiler/index.ts
+++ b/src/server/optimizing-compiler/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { parse } from 'compiler/parser/index'
 import { generate } from './codegen'
diff --git a/src/server/optimizing-compiler/modules.ts b/src/server/optimizing-compiler/modules.ts
index f6bf515368b..20c7239718c 100644
--- a/src/server/optimizing-compiler/modules.ts
+++ b/src/server/optimizing-compiler/modules.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import {
   RAW,
diff --git a/src/server/optimizing-compiler/optimizer.ts b/src/server/optimizing-compiler/optimizer.ts
index c9134d012e8..8e8a70ba176 100644
--- a/src/server/optimizing-compiler/optimizer.ts
+++ b/src/server/optimizing-compiler/optimizer.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 /**
  * In SSR, the vdom tree is generated only once and never patched, so
diff --git a/src/server/optimizing-compiler/runtime-helpers.ts b/src/server/optimizing-compiler/runtime-helpers.ts
index 91d3e55a68a..e4f1e187a94 100644
--- a/src/server/optimizing-compiler/runtime-helpers.ts
+++ b/src/server/optimizing-compiler/runtime-helpers.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { escape, isSSRUnsafeAttr } from 'web/server/util'
 import { isObject, extend } from 'shared/util'
diff --git a/src/server/render-context.ts b/src/server/render-context.ts
index 519ca6d383e..2e15f9b702b 100644
--- a/src/server/render-context.ts
+++ b/src/server/render-context.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import VNode from 'core/vdom/vnode'
 import { isUndef } from 'shared/util'
diff --git a/src/server/render-stream.ts b/src/server/render-stream.ts
index 361b3533925..998ad391232 100644
--- a/src/server/render-stream.ts
+++ b/src/server/render-stream.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 /**
  * Original RenderStream implementation by Sasha Aickin (@aickin)
diff --git a/src/server/render.ts b/src/server/render.ts
index f5e3e0fd0bf..46074ef2a5e 100644
--- a/src/server/render.ts
+++ b/src/server/render.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import { escape } from 'web/server/util'
 import { SSR_ATTR } from 'shared/constants'
diff --git a/src/server/template-renderer/create-async-file-mapper.ts b/src/server/template-renderer/create-async-file-mapper.ts
index 34269f5a8e9..168b16ace12 100644
--- a/src/server/template-renderer/create-async-file-mapper.ts
+++ b/src/server/template-renderer/create-async-file-mapper.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 /**
  * Creates a mapper that maps components used during a server-side render
diff --git a/src/server/template-renderer/index.ts b/src/server/template-renderer/index.ts
index f3d0603cd60..7c0ddd91a9f 100644
--- a/src/server/template-renderer/index.ts
+++ b/src/server/template-renderer/index.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const path = require('path')
 const serialize = require('serialize-javascript')
diff --git a/src/server/template-renderer/parse-template.ts b/src/server/template-renderer/parse-template.ts
index d200655e560..7aedead5556 100644
--- a/src/server/template-renderer/parse-template.ts
+++ b/src/server/template-renderer/parse-template.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const compile = require('lodash.template')
 const compileOptions = {
diff --git a/src/server/template-renderer/template-stream.ts b/src/server/template-renderer/template-stream.ts
index 8644f09ff13..438161f984e 100644
--- a/src/server/template-renderer/template-stream.ts
+++ b/src/server/template-renderer/template-stream.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 // const Transform = require("stream").Transform;
 import type TemplateRenderer from './index'
diff --git a/src/server/util.ts b/src/server/util.ts
index 3f85530f137..428f5703be6 100644
--- a/src/server/util.ts
+++ b/src/server/util.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 export const isJS = (file: string): boolean => /\.js(\?[^.]+)?$/.test(file)
 
diff --git a/src/server/write.ts b/src/server/write.ts
index 5148d1ef1e9..c079eea248b 100644
--- a/src/server/write.ts
+++ b/src/server/write.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 const MAX_STACK_DEPTH = 800
 const noop = (_) => _
diff --git a/src/sfc/parser.ts b/src/sfc/parser.ts
index 6ef98558354..b3e36926ad6 100644
--- a/src/sfc/parser.ts
+++ b/src/sfc/parser.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 import deindent from 'de-indent'
 import { parseHTML } from 'compiler/parser/html-parser'
diff --git a/src/shared/util.ts b/src/shared/util.ts
index 49059d6acb4..bd6f04ee7fe 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -1,4 +1,3 @@
-/* @flow */
 
 export const emptyObject = Object.freeze({})
 

From 5f4763e5983ebd07b490361f382566257afd9cc4 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 6 Apr 2021 17:12:14 +0100
Subject: [PATCH 009/317] fix keepalive to ts

---
 dist/vue.runtime.common.dev.js    | 58 -------------------------------
 src/core/components/keep-alive.ts | 21 ++++++-----
 2 files changed, 10 insertions(+), 69 deletions(-)

diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index dd020e74184..4e640510c0e 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -5,7 +5,6 @@
  */
 'use strict';
 
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -316,7 +315,6 @@ var LIFECYCLE_HOOKS = [
     'errorCaptured',
     'serverPrefetch' ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -395,7 +393,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -439,7 +436,6 @@ function parsePath(path) {
     };
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -530,7 +526,6 @@ else {
     }());
 }
 
-/* @flow */
 var warn = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
@@ -1023,7 +1018,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1402,7 +1396,6 @@ function resolveAsset(options, type, id, warnMissing) {
     return res;
 }
 
-/* @flow */
 function validateProp(key, propOptions, propsData, vm) {
     var prop = propOptions[key];
     var absent = !hasOwn(propsData, key);
@@ -1678,7 +1671,6 @@ function logError(err, vm, info) {
     }
 }
 
-/* @flow */
 var isUsingMicroTask = false;
 var callbacks = [];
 var pending = false;
@@ -1861,7 +1853,6 @@ var initProxy;
     };
 }
 
-/* @flow */
 var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
@@ -1984,7 +1975,6 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
     }
 }
 
-/* @flow */
 function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
@@ -2017,7 +2007,6 @@ function mergeVNodeHook(def, hookKey, hook) {
     def[hookKey] = invoker;
 }
 
-/* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
@@ -2070,7 +2059,6 @@ function checkProp(res, hash, key, altKey, preserve) {
     return false;
 }
 
-/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -2157,7 +2145,6 @@ function normalizeArrayChildren(children, nestedIndex) {
     return res;
 }
 
-/* @flow */
 function initProvide(vm) {
     var provide = vm.$options.provide;
     if (provide) {
@@ -2223,7 +2210,6 @@ function resolveInject(inject, vm) {
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
@@ -2269,7 +2255,6 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     var res;
     var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2422,7 +2407,6 @@ function resolveFilter(id) {
     return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/* @flow */
 function isKeyNotMatch(expect, actual) {
     if (Array.isArray(expect)) {
         return expect.indexOf(actual) === -1;
@@ -2449,7 +2433,6 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
@@ -2537,7 +2520,6 @@ function markStaticNode(node, key, isOnce) {
     node.isOnce = isOnce;
 }
 
-/* @flow */
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
@@ -2580,7 +2562,6 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
-/* @flow */
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -2602,7 +2583,6 @@ function prependModifier(value, symbol) {
     return typeof value === 'string' ? symbol + value : value;
 }
 
-/* @flow */
 function installRenderHelpers(target) {
     target._o = markOnce;
     target._n = toNumber;
@@ -2623,7 +2603,6 @@ function installRenderHelpers(target) {
     target._p = prependModifier;
 }
 
-/* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
     var _this = this;
     var options = Ctor.options;
@@ -2738,7 +2717,6 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
     init: function (vnode, hydrating) {
@@ -2932,7 +2910,6 @@ function transformModel(options, data) {
     }
 }
 
-/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
@@ -3055,7 +3032,6 @@ function registerDeepBindings(data) {
     }
 }
 
-/* @flow */
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
@@ -3151,7 +3127,6 @@ function renderMixin(Vue) {
     };
 }
 
-/* @flow */
 function ensureCtor(comp, base) {
     if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
         comp = comp.default;
@@ -3268,13 +3243,11 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-/* @flow */
 function isAsyncPlaceholder(node) {
     // @ts-expect-error not really boolean type
     return node.isComment && node.asyncFactory;
 }
 
-/* @flow */
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
         for (var i = 0; i < children.length; i++) {
@@ -3286,7 +3259,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
@@ -3406,7 +3378,6 @@ function eventsMixin(Vue) {
     };
 }
 
-/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
@@ -3703,7 +3674,6 @@ function callHook$1(vm, hook) {
     popTarget();
 }
 
-/* @flow */
 var MAX_UPDATE_COUNT = 100;
 var queue = [];
 var activatedChildren = [];
@@ -3859,7 +3829,6 @@ function queueWatcher(watcher) {
     }
 }
 
-/* @flow */
 var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
@@ -4055,7 +4024,6 @@ var Watcher = /** @class */ (function () {
     return Watcher;
 }());
 
-/* @flow */
 var sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
@@ -4342,7 +4310,6 @@ function stateMixin(Vue) {
     };
 }
 
-/* @flow */
 var uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
@@ -4464,7 +4431,6 @@ lifecycleMixin(Vue);
 //@ts-ignore
 renderMixin(Vue);
 
-/* @flow */
 function initUse(Vue) {
     Vue.use = function (plugin) {
         var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4485,7 +4451,6 @@ function initUse(Vue) {
     };
 }
 
-/* @flow */
 function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
@@ -4493,7 +4458,6 @@ function initMixin(Vue) {
     };
 }
 
-/* @flow */
 function initExtend(Vue) {
     /**
      * Each instance constructor, including Vue, has a unique
@@ -4571,7 +4535,6 @@ function initComputed(Comp) {
     }
 }
 
-/* @flow */
 function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
@@ -4713,7 +4676,6 @@ var builtInComponents = {
     KeepAlive: KeepAlive,
 };
 
-/* @flow */
 function initGlobalAPI(Vue) {
     // config
     var configDef = {};
@@ -4771,7 +4733,6 @@ Object.defineProperty(Vue, 'FunctionalRenderContext', {
 });
 Vue.version = '2.6.12';
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
@@ -4810,7 +4771,6 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
-/* @flow */
 function genClassForVnode(vnode) {
     var data = vnode.data;
     var parentNode = vnode;
@@ -4881,7 +4841,6 @@ function stringifyObject(value) {
     return res;
 }
 
-/* @flow */
 var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
@@ -4942,7 +4901,6 @@ function isUnknownElement(tag) {
 }
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
@@ -4960,7 +4918,6 @@ function query(el) {
     }
 }
 
-/* @flow */
 function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
@@ -5024,7 +4981,6 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/* @flow */
 var ref = {
     create: function (_, vnode) {
         registerRef(vnode);
@@ -5805,7 +5761,6 @@ function createPatchFunction(backend) {
     };
 }
 
-/* @flow */
 var directives = {
     create: updateDirectives,
     update: updateDirectives,
@@ -5913,7 +5868,6 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 
 var baseModules = [ref, directives];
 
-/* @flow */
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6017,7 +5971,6 @@ var attrs = {
     update: updateAttrs,
 };
 
-/* @flow */
 function updateClass(oldVnode, vnode) {
     var el = vnode.elm;
     var data = vnode.data;
@@ -6045,13 +5998,11 @@ var klass = {
     update: updateClass,
 };
 
-/* @flow */
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
 
-/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
@@ -6140,7 +6091,6 @@ var events = {
     update: updateDOMListeners,
 };
 
-/* @flow */
 var svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6252,7 +6202,6 @@ var domProps = {
     update: updateDOMProps,
 };
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -6312,7 +6261,6 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
@@ -6393,7 +6341,6 @@ var style = {
     update: updateStyle,
 };
 
-/* @flow */
 var whitespaceRE = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
@@ -6623,7 +6570,6 @@ function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-/* @flow */
 function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
@@ -6876,7 +6822,6 @@ var transition = inBrowser
 
 var platformModules = [attrs, klass, events, domProps, style, transition];
 
-/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
@@ -7014,7 +6959,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-/* @flow */
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -7075,7 +7019,6 @@ var platformDirectives = {
     show: show,
 };
 
-/* @flow */
 var transitionProps = {
     name: String,
     appear: Boolean,
@@ -7457,6 +7400,5 @@ if (inBrowser) {
     }, 0);
 }
 
-/* @flow */
 
 module.exports = Vue;
diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index a5b08bd7b47..a17fab996fa 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -1,9 +1,7 @@
-// @ts-nocheck
-
 import { isRegExp, remove } from 'shared/util'
 import { getFirstComponentChild } from 'core/vdom/helpers/index'
 import VNode from 'core/vdom/vnode'
-import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
+import type { VNodeComponentOptions } from 'typescript/vnode'
 
 type VNodeCache = { [key: string]: VNode | null }
 
@@ -47,6 +45,7 @@ function pruneCacheEntry(
 ) {
   const cached = cache[key]
   if (cached && (!current || cached.tag !== current.tag)) {
+    //@ts-expect-error has void type
     cached.componentInstance.$destroy()
   }
   cache[key] = null
@@ -88,12 +87,12 @@ export default {
 
   render() {
     const slot = this.$slots.default
-    const vnode: VNode = getFirstComponentChild(slot)
-    const componentOptions: ?VNodeComponentOptions =
+    const vnode = getFirstComponentChild(slot)
+    const componentOptions =
       vnode && vnode.componentOptions
     if (componentOptions) {
       // check pattern
-      const name: ?string = getComponentName(componentOptions)
+      const name = getComponentName(componentOptions)
       const { include, exclude } = this
       if (
         // not included
@@ -105,15 +104,15 @@ export default {
       }
 
       const { cache, keys } = this
-      const key: ?string =
-        vnode.key == null
+      const key =
+        vnode!.key == null
           ? // same constructor may get registered as different local components
             // so cid alone is not enough (#3269)
             componentOptions.Ctor.cid +
             (componentOptions.tag ? `::${componentOptions.tag}` : '')
-          : vnode.key
+          : vnode!.key
       if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance
+        vnode!.componentInstance = cache[key].componentInstance
         // make current key freshest
         remove(keys, key)
         keys.push(key)
@@ -126,7 +125,7 @@ export default {
         }
       }
 
-      vnode.data.keepAlive = true
+      vnode!.data!.keepAlive = true
     }
     return vnode || (slot && slot[0])
   },

From 6c86065307db74425cc0d6cf5b4aabf6da605c1f Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 6 Apr 2021 17:17:25 +0100
Subject: [PATCH 010/317] changed to eslint and updated babel deps

---
 .eslintrc.js                                  |   30 +-
 dist/vue.common.dev.js                        |   97 +-
 dist/vue.esm.browser.js                       |   97 +-
 dist/vue.esm.js                               |   97 +-
 dist/vue.js                                   |   97 +-
 dist/vue.runtime.common.dev.js                |    6 +-
 dist/vue.runtime.esm.js                       |   64 +-
 dist/vue.runtime.js                           |   64 +-
 package.json                                  |   18 +-
 packages/vue-server-renderer/basic.js         |   92 +-
 packages/vue-server-renderer/build.dev.js     |   33 +
 packages/vue-server-renderer/client-plugin.js |    1 -
 packages/vue-server-renderer/server-plugin.js |    1 -
 packages/vue-template-compiler/browser.js     |  104 +-
 packages/vue-template-compiler/build.js       |   62 +-
 yarn.lock                                     | 2216 ++++++++++++-----
 16 files changed, 1752 insertions(+), 1327 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index e27aad552a1..514b4f14f98 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,29 +1,29 @@
 module.exports = {
   root: true,
+  parser: "@typescript-eslint/parser",
+
   parserOptions: {
-    parser: require.resolve('babel-eslint'),
-    ecmaVersion: 2018,
-    sourceType: 'module'
+    // parser: "@typescript-eslint/parser",
+    // ecmaVersion: 2018,
+    sourceType: "module",
   },
   env: {
     es6: true,
     node: true,
-    browser: true
+    browser: true,
   },
-  plugins: [
-    "flowtype"
-  ],
+  // plugins: ["flowtype"],
   extends: [
     "eslint:recommended",
-    "plugin:flowtype/recommended"
+    "plugin:@typescript-eslint/eslint-recommended",
   ],
   globals: {
-    "__WEEX__": true,
-    "WXEnvironment": true
+    __WEEX__: true,
+    WXEnvironment: true,
   },
   rules: {
-    'no-console': process.env.NODE_ENV !== 'production' ? 0 : 2,
-    'no-useless-escape': 0,
-    'no-empty': 0
-  }
-}
+    "no-console": process.env.NODE_ENV !== "production" ? 0 : 2,
+    "no-useless-escape": 0,
+    "no-empty": 0,
+  },
+};
diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index ee880f933a0..3e862a975ab 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -5,7 +5,6 @@
  */
 'use strict';
 
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -326,7 +325,6 @@ var LIFECYCLE_HOOKS = [
     'errorCaptured',
     'serverPrefetch' ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -405,7 +403,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -449,7 +446,6 @@ function parsePath(path) {
     };
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -540,7 +536,6 @@ else {
     }());
 }
 
-/* @flow */
 var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
@@ -1033,7 +1028,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1412,7 +1406,6 @@ function resolveAsset(options, type, id, warnMissing) {
     return res;
 }
 
-/* @flow */
 function validateProp(key, propOptions, propsData, vm) {
     var prop = propOptions[key];
     var absent = !hasOwn(propsData, key);
@@ -1688,7 +1681,7 @@ function logError(err, vm, info) {
     }
 }
 
-/* @flow */
+/* globals MutationObserver */
 var isUsingMicroTask = false;
 var callbacks = [];
 var pending = false;
@@ -1891,7 +1884,6 @@ var initProxy;
     };
 }
 
-/* @flow */
 var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
@@ -1994,7 +1986,6 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
     }
 }
 
-/* @flow */
 function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
@@ -2027,7 +2018,6 @@ function mergeVNodeHook(def, hookKey, hook) {
     def[hookKey] = invoker;
 }
 
-/* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
@@ -2080,7 +2070,6 @@ function checkProp(res, hash, key, altKey, preserve) {
     return false;
 }
 
-/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -2167,7 +2156,6 @@ function normalizeArrayChildren(children, nestedIndex) {
     return res;
 }
 
-/* @flow */
 function initProvide(vm) {
     var provide = vm.$options.provide;
     if (provide) {
@@ -2233,7 +2221,6 @@ function resolveInject(inject, vm) {
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
@@ -2279,7 +2266,6 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     var res;
     var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2432,7 +2418,6 @@ function resolveFilter(id) {
     return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/* @flow */
 function isKeyNotMatch(expect, actual) {
     if (Array.isArray(expect)) {
         return expect.indexOf(actual) === -1;
@@ -2459,7 +2444,6 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
@@ -2547,7 +2531,6 @@ function markStaticNode(node, key, isOnce) {
     node.isOnce = isOnce;
 }
 
-/* @flow */
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
@@ -2590,7 +2573,7 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
-/* @flow */
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -2612,7 +2595,6 @@ function prependModifier(value, symbol) {
     return typeof value === 'string' ? symbol + value : value;
 }
 
-/* @flow */
 function installRenderHelpers(target) {
     target._o = markOnce;
     target._n = toNumber;
@@ -2633,7 +2615,6 @@ function installRenderHelpers(target) {
     target._p = prependModifier;
 }
 
-/* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
     var _this = this;
     var options = Ctor.options;
@@ -2748,7 +2729,6 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
     init: function (vnode, hydrating) {
@@ -2942,7 +2922,6 @@ function transformModel(options, data) {
     }
 }
 
-/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
@@ -3065,7 +3044,6 @@ function registerDeepBindings(data) {
     }
 }
 
-/* @flow */
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
@@ -3161,7 +3139,6 @@ function renderMixin(Vue) {
     };
 }
 
-/* @flow */
 function ensureCtor(comp, base) {
     if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
         comp = comp.default;
@@ -3278,13 +3255,11 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-/* @flow */
 function isAsyncPlaceholder(node) {
     // @ts-expect-error not really boolean type
     return node.isComment && node.asyncFactory;
 }
 
-/* @flow */
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
         for (var i = 0; i < children.length; i++) {
@@ -3296,7 +3271,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
@@ -3416,7 +3390,6 @@ function eventsMixin(Vue) {
     };
 }
 
-/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
@@ -3713,7 +3686,6 @@ function callHook$1(vm, hook) {
     popTarget();
 }
 
-/* @flow */
 var MAX_UPDATE_COUNT = 100;
 var queue = [];
 var activatedChildren = [];
@@ -3869,7 +3841,6 @@ function queueWatcher(watcher) {
     }
 }
 
-/* @flow */
 var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
@@ -4065,7 +4036,6 @@ var Watcher = /** @class */ (function () {
     return Watcher;
 }());
 
-/* @flow */
 var sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
@@ -4352,7 +4322,6 @@ function stateMixin(Vue) {
     };
 }
 
-/* @flow */
 var uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
@@ -4474,7 +4443,6 @@ lifecycleMixin(Vue);
 //@ts-ignore
 renderMixin(Vue);
 
-/* @flow */
 function initUse(Vue) {
     Vue.use = function (plugin) {
         var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4495,7 +4463,6 @@ function initUse(Vue) {
     };
 }
 
-/* @flow */
 function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
@@ -4503,7 +4470,6 @@ function initMixin(Vue) {
     };
 }
 
-/* @flow */
 function initExtend(Vue) {
     /**
      * Each instance constructor, including Vue, has a unique
@@ -4581,7 +4547,6 @@ function initComputed(Comp) {
     }
 }
 
-/* @flow */
 function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
@@ -4612,7 +4577,6 @@ function initAssetRegisters(Vue) {
     });
 }
 
-// @ts-nocheck
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4644,6 +4608,7 @@ function pruneCache(keepAliveInstance, filter) {
 function pruneCacheEntry(cache, key, keys, current) {
     var cached = cache[key];
     if (cached && (!current || cached.tag !== current.tag)) {
+        //@ts-expect-error has void type
         cached.componentInstance.$destroy();
     }
     cache[key] = null;
@@ -4723,7 +4688,6 @@ var builtInComponents = {
     KeepAlive: KeepAlive,
 };
 
-/* @flow */
 function initGlobalAPI(Vue) {
     // config
     var configDef = {};
@@ -4781,7 +4745,6 @@ Object.defineProperty(Vue, 'FunctionalRenderContext', {
 });
 Vue.version = '2.6.12';
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
@@ -4820,7 +4783,6 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
-/* @flow */
 function genClassForVnode(vnode) {
     var data = vnode.data;
     var parentNode = vnode;
@@ -4891,7 +4853,6 @@ function stringifyObject(value) {
     return res;
 }
 
-/* @flow */
 var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
@@ -4953,7 +4914,6 @@ function isUnknownElement(tag) {
 }
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
@@ -4971,7 +4931,6 @@ function query(el) {
     }
 }
 
-/* @flow */
 function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
@@ -5035,7 +4994,6 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/* @flow */
 var ref = {
     create: function (_, vnode) {
         registerRef(vnode);
@@ -5816,7 +5774,6 @@ function createPatchFunction(backend) {
     };
 }
 
-/* @flow */
 var directives$1 = {
     create: updateDirectives,
     update: updateDirectives,
@@ -5924,7 +5881,6 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 
 var baseModules = [ref, directives$1];
 
-/* @flow */
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6028,7 +5984,6 @@ var attrs = {
     update: updateAttrs,
 };
 
-/* @flow */
 function updateClass(oldVnode, vnode) {
     var el = vnode.elm;
     var data = vnode.data;
@@ -6056,7 +6011,6 @@ var klass$1 = {
     update: updateClass,
 };
 
-/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
     var inSingle = false;
@@ -6180,7 +6134,6 @@ function wrapFilter(exp, filter) {
     }
 }
 
-/* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
     console.error("[Vue compiler]: " + msg);
@@ -6347,7 +6300,6 @@ function rangeSetItem(item, range) {
     return item;
 }
 
-/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
@@ -6473,7 +6425,6 @@ function parseString(chr) {
     }
 }
 
-/* @flow */
 var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -6596,7 +6547,6 @@ function genDefaultModel(el, value, modifiers) {
     }
 }
 
-/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
@@ -6685,7 +6635,6 @@ var events = {
     update: updateDOMListeners,
 };
 
-/* @flow */
 var svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6797,7 +6746,6 @@ var domProps = {
     update: updateDOMProps,
 };
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -6857,7 +6805,6 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
@@ -6938,7 +6885,6 @@ var style$1 = {
     update: updateStyle,
 };
 
-/* @flow */
 var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
@@ -7168,7 +7114,6 @@ function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-/* @flow */
 function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
@@ -7421,7 +7366,6 @@ var transition = inBrowser
 
 var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules$1 = platformModules.concat(baseModules);
@@ -7559,7 +7503,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-/* @flow */
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -7620,7 +7563,7 @@ var platformDirectives = {
     show: show,
 };
 
-/* @flow */
+// Provides transition support for a single element/component.
 var transitionProps = {
     name: String,
     appear: Boolean,
@@ -8002,7 +7945,6 @@ if (inBrowser) {
     }, 0);
 }
 
-/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -8043,7 +7985,6 @@ function parseText(text, delimiters) {
     };
 }
 
-/* @flow */
 function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
@@ -8080,7 +8021,6 @@ var klass = {
     genData: genData$2,
 };
 
-/* @flow */
 function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
@@ -8118,7 +8058,6 @@ var style = {
     genData: genData$1,
 };
 
-/* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
@@ -8419,7 +8358,6 @@ function parseHTML(html, options) {
     }
 }
 
-/* @flow */
 var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
@@ -9218,7 +9156,15 @@ function checkForAliasModel(el, value) {
     }
 }
 
-/* @flow */
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
         var map = el.attrsMap;
@@ -9286,14 +9232,12 @@ var model = {
 
 var modules = [klass, style, model];
 
-/* @flow */
 function text(el, dir) {
     if (dir.value) {
         addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
-/* @flow */
 function html(el, dir) {
     if (dir.value) {
         addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -9306,7 +9250,6 @@ var directives = {
     html: html,
 };
 
-/* @flow */
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -9321,7 +9264,6 @@ var baseOptions = {
     staticKeys: genStaticKeys$1(modules),
 };
 
-/* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
 var genStaticKeysCached = cached(genStaticKeys);
@@ -9439,7 +9381,6 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -9591,7 +9532,6 @@ function genFilterCode(key) {
         ")");
 }
 
-/* @flow */
 function on(el, dir) {
     if (dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
@@ -9599,21 +9539,18 @@ function on(el, dir) {
     el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
-/* @flow */
 function bind(el, dir) {
     el.wrapData = function (code) {
         return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
-/* @flow */
 var baseDirectives = {
     on: on,
     bind: bind,
     cloak: noop,
 };
 
-/* @flow */
 var CodegenState = /** @class */ (function () {
     function CodegenState(options) {
         this.options = options;
@@ -10094,7 +10031,6 @@ function transformSpecialNewlines(text) {
     return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
 var prohibitedKeywordRE = new RegExp('\\b' +
@@ -10203,7 +10139,6 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
     }
 }
 
-/* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
     if (start === void 0) { start = 0; }
@@ -10254,7 +10189,6 @@ function repeat(str, n) {
     return result;
 }
 
-/* @flow */
 function createFunction(code, errors) {
     try {
         return new Function(code);
@@ -10345,7 +10279,6 @@ function createCompileToFunctionFn(compile) {
     };
 }
 
-/* @flow */
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
@@ -10403,7 +10336,6 @@ function createCompilerCreator(baseCompile) {
     };
 }
 
-/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
@@ -10420,10 +10352,8 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-/* @flow */
 var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
-/* @flow */
 // check whether current browser encodes a char inside attribute values
 var div;
 function getShouldDecode(href) {
@@ -10438,7 +10368,6 @@ var shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
-/* @flow */
 var idToTemplate = cached(function (id) {
     var el = query(id);
     return el && el.innerHTML;
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index 79d3da366cd..25da182ed27 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -3,7 +3,6 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -325,7 +324,6 @@ var LIFECYCLE_HOOKS = [
     'serverPrefetch',
 ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -404,7 +402,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -448,7 +445,6 @@ function parsePath(path) {
     };
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -539,7 +535,6 @@ else {
     }());
 }
 
-/* @flow */
 var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
@@ -1031,7 +1026,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1410,7 +1404,6 @@ function resolveAsset(options, type, id, warnMissing) {
     return res;
 }
 
-/* @flow */
 function validateProp(key, propOptions, propsData, vm) {
     var prop = propOptions[key];
     var absent = !hasOwn(propsData, key);
@@ -1684,7 +1677,7 @@ function logError(err, vm, info) {
     }
 }
 
-/* @flow */
+/* globals MutationObserver */
 var isUsingMicroTask = false;
 var callbacks = [];
 var pending = false;
@@ -1887,7 +1880,6 @@ var initProxy;
     };
 }
 
-/* @flow */
 var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
@@ -1988,7 +1980,6 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
     }
 }
 
-/* @flow */
 function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
@@ -2021,7 +2012,6 @@ function mergeVNodeHook(def, hookKey, hook) {
     def[hookKey] = invoker;
 }
 
-/* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
@@ -2074,7 +2064,6 @@ function checkProp(res, hash, key, altKey, preserve) {
     return false;
 }
 
-/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -2161,7 +2150,6 @@ function normalizeArrayChildren(children, nestedIndex) {
     return res;
 }
 
-/* @flow */
 function initProvide(vm) {
     var provide = vm.$options.provide;
     if (provide) {
@@ -2227,7 +2215,6 @@ function resolveInject(inject, vm) {
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
@@ -2273,7 +2260,6 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     var res;
     var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2426,7 +2412,6 @@ function resolveFilter(id) {
     return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/* @flow */
 function isKeyNotMatch(expect, actual) {
     if (Array.isArray(expect)) {
         return expect.indexOf(actual) === -1;
@@ -2453,7 +2438,6 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
@@ -2541,7 +2525,6 @@ function markStaticNode(node, key, isOnce) {
     node.isOnce = isOnce;
 }
 
-/* @flow */
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
@@ -2584,7 +2567,7 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
-/* @flow */
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -2606,7 +2589,6 @@ function prependModifier(value, symbol) {
     return typeof value === 'string' ? symbol + value : value;
 }
 
-/* @flow */
 function installRenderHelpers(target) {
     target._o = markOnce;
     target._n = toNumber;
@@ -2627,7 +2609,6 @@ function installRenderHelpers(target) {
     target._p = prependModifier;
 }
 
-/* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
     var _this = this;
     var options = Ctor.options;
@@ -2742,7 +2723,6 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
     init: function (vnode, hydrating) {
@@ -2936,7 +2916,6 @@ function transformModel(options, data) {
     }
 }
 
-/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
@@ -3059,7 +3038,6 @@ function registerDeepBindings(data) {
     }
 }
 
-/* @flow */
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
@@ -3155,7 +3133,6 @@ function renderMixin(Vue) {
     };
 }
 
-/* @flow */
 function ensureCtor(comp, base) {
     if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
         comp = comp.default;
@@ -3272,13 +3249,11 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-/* @flow */
 function isAsyncPlaceholder(node) {
     // @ts-expect-error not really boolean type
     return node.isComment && node.asyncFactory;
 }
 
-/* @flow */
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
         for (var i = 0; i < children.length; i++) {
@@ -3290,7 +3265,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
@@ -3410,7 +3384,6 @@ function eventsMixin(Vue) {
     };
 }
 
-/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
@@ -3707,7 +3680,6 @@ function callHook$1(vm, hook) {
     popTarget();
 }
 
-/* @flow */
 var MAX_UPDATE_COUNT = 100;
 var queue = [];
 var activatedChildren = [];
@@ -3863,7 +3835,6 @@ function queueWatcher(watcher) {
     }
 }
 
-/* @flow */
 var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
@@ -4059,7 +4030,6 @@ var Watcher = /** @class */ (function () {
     return Watcher;
 }());
 
-/* @flow */
 var sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
@@ -4346,7 +4316,6 @@ function stateMixin(Vue) {
     };
 }
 
-/* @flow */
 var uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
@@ -4468,7 +4437,6 @@ lifecycleMixin(Vue);
 //@ts-ignore
 renderMixin(Vue);
 
-/* @flow */
 function initUse(Vue) {
     Vue.use = function (plugin) {
         var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4489,7 +4457,6 @@ function initUse(Vue) {
     };
 }
 
-/* @flow */
 function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
@@ -4497,7 +4464,6 @@ function initMixin(Vue) {
     };
 }
 
-/* @flow */
 function initExtend(Vue) {
     /**
      * Each instance constructor, including Vue, has a unique
@@ -4575,7 +4541,6 @@ function initComputed(Comp) {
     }
 }
 
-/* @flow */
 function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
@@ -4606,7 +4571,6 @@ function initAssetRegisters(Vue) {
     });
 }
 
-// @ts-nocheck
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4638,6 +4602,7 @@ function pruneCache(keepAliveInstance, filter) {
 function pruneCacheEntry(cache, key, keys, current) {
     var cached = cache[key];
     if (cached && (!current || cached.tag !== current.tag)) {
+        //@ts-expect-error has void type
         cached.componentInstance.$destroy();
     }
     cache[key] = null;
@@ -4717,7 +4682,6 @@ var builtInComponents = {
     KeepAlive: KeepAlive,
 };
 
-/* @flow */
 function initGlobalAPI(Vue) {
     // config
     var configDef = {};
@@ -4775,7 +4739,6 @@ Object.defineProperty(Vue, 'FunctionalRenderContext', {
 });
 Vue.version = '2.6.12';
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
@@ -4814,7 +4777,6 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
-/* @flow */
 function genClassForVnode(vnode) {
     var data = vnode.data;
     var parentNode = vnode;
@@ -4885,7 +4847,6 @@ function stringifyObject(value) {
     return res;
 }
 
-/* @flow */
 var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
@@ -4947,7 +4908,6 @@ function isUnknownElement(tag) {
 }
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
@@ -4965,7 +4925,6 @@ function query(el) {
     }
 }
 
-/* @flow */
 function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
@@ -5029,7 +4988,6 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/* @flow */
 var ref = {
     create: function (_, vnode) {
         registerRef(vnode);
@@ -5810,7 +5768,6 @@ function createPatchFunction(backend) {
     };
 }
 
-/* @flow */
 var directives$1 = {
     create: updateDirectives,
     update: updateDirectives,
@@ -5918,7 +5875,6 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 
 var baseModules = [ref, directives$1];
 
-/* @flow */
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6022,7 +5978,6 @@ var attrs = {
     update: updateAttrs,
 };
 
-/* @flow */
 function updateClass(oldVnode, vnode) {
     var el = vnode.elm;
     var data = vnode.data;
@@ -6050,7 +6005,6 @@ var klass$1 = {
     update: updateClass,
 };
 
-/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
     var inSingle = false;
@@ -6174,7 +6128,6 @@ function wrapFilter(exp, filter) {
     }
 }
 
-/* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
     console.error("[Vue compiler]: " + msg);
@@ -6341,7 +6294,6 @@ function rangeSetItem(item, range) {
     return item;
 }
 
-/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
@@ -6467,7 +6419,6 @@ function parseString(chr) {
     }
 }
 
-/* @flow */
 var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -6590,7 +6541,6 @@ function genDefaultModel(el, value, modifiers) {
     }
 }
 
-/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
@@ -6679,7 +6629,6 @@ var events = {
     update: updateDOMListeners,
 };
 
-/* @flow */
 var svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6791,7 +6740,6 @@ var domProps = {
     update: updateDOMProps,
 };
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -6851,7 +6799,6 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
@@ -6932,7 +6879,6 @@ var style$1 = {
     update: updateStyle,
 };
 
-/* @flow */
 var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
@@ -7162,7 +7108,6 @@ function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-/* @flow */
 function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
@@ -7415,7 +7360,6 @@ var transition = inBrowser
 
 var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules$1 = platformModules.concat(baseModules);
@@ -7553,7 +7497,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-/* @flow */
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -7614,7 +7557,7 @@ var platformDirectives = {
     show: show,
 };
 
-/* @flow */
+// Provides transition support for a single element/component.
 var transitionProps = {
     name: String,
     appear: Boolean,
@@ -7996,7 +7939,6 @@ if (inBrowser) {
     }, 0);
 }
 
-/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -8037,7 +7979,6 @@ function parseText(text, delimiters) {
     };
 }
 
-/* @flow */
 function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
@@ -8074,7 +8015,6 @@ var klass = {
     genData: genData$2,
 };
 
-/* @flow */
 function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
@@ -8112,7 +8052,6 @@ var style = {
     genData: genData$1,
 };
 
-/* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
@@ -8413,7 +8352,6 @@ function parseHTML(html, options) {
     }
 }
 
-/* @flow */
 var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
@@ -9212,7 +9150,15 @@ function checkForAliasModel(el, value) {
     }
 }
 
-/* @flow */
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
         var map = el.attrsMap;
@@ -9280,14 +9226,12 @@ var model = {
 
 var modules = [klass, style, model];
 
-/* @flow */
 function text(el, dir) {
     if (dir.value) {
         addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
-/* @flow */
 function html(el, dir) {
     if (dir.value) {
         addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -9300,7 +9244,6 @@ var directives = {
     html: html,
 };
 
-/* @flow */
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -9315,7 +9258,6 @@ var baseOptions = {
     staticKeys: genStaticKeys$1(modules),
 };
 
-/* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
 var genStaticKeysCached = cached(genStaticKeys);
@@ -9433,7 +9375,6 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -9585,7 +9526,6 @@ function genFilterCode(key) {
         ")");
 }
 
-/* @flow */
 function on(el, dir) {
     if (dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
@@ -9593,21 +9533,18 @@ function on(el, dir) {
     el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
-/* @flow */
 function bind(el, dir) {
     el.wrapData = function (code) {
         return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
-/* @flow */
 var baseDirectives = {
     on: on,
     bind: bind,
     cloak: noop,
 };
 
-/* @flow */
 var CodegenState = /** @class */ (function () {
     function CodegenState(options) {
         this.options = options;
@@ -10088,7 +10025,6 @@ function transformSpecialNewlines(text) {
     return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
 var prohibitedKeywordRE = new RegExp('\\b' +
@@ -10197,7 +10133,6 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
     }
 }
 
-/* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
     if (start === void 0) { start = 0; }
@@ -10248,7 +10183,6 @@ function repeat(str, n) {
     return result;
 }
 
-/* @flow */
 function createFunction(code, errors) {
     try {
         return new Function(code);
@@ -10339,7 +10273,6 @@ function createCompileToFunctionFn(compile) {
     };
 }
 
-/* @flow */
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
@@ -10397,7 +10330,6 @@ function createCompilerCreator(baseCompile) {
     };
 }
 
-/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
@@ -10414,10 +10346,8 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-/* @flow */
 var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
-/* @flow */
 // check whether current browser encodes a char inside attribute values
 var div;
 function getShouldDecode(href) {
@@ -10432,7 +10362,6 @@ var shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
-/* @flow */
 var idToTemplate = cached(function (id) {
     var el = query(id);
     return el && el.innerHTML;
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index 2c7f13f1038..1286a8d4272 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -3,7 +3,6 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -324,7 +323,6 @@ var LIFECYCLE_HOOKS = [
     'errorCaptured',
     'serverPrefetch' ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -403,7 +401,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -447,7 +444,6 @@ function parsePath(path) {
     };
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -538,7 +534,6 @@ else {
     }());
 }
 
-/* @flow */
 var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
@@ -1035,7 +1030,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1415,7 +1409,6 @@ function resolveAsset(options, type, id, warnMissing) {
     return res;
 }
 
-/* @flow */
 function validateProp(key, propOptions, propsData, vm) {
     var prop = propOptions[key];
     var absent = !hasOwn(propsData, key);
@@ -1693,7 +1686,7 @@ function logError(err, vm, info) {
     }
 }
 
-/* @flow */
+/* globals MutationObserver */
 var isUsingMicroTask = false;
 var callbacks = [];
 var pending = false;
@@ -1896,7 +1889,6 @@ if (process.env.NODE_ENV !== 'production') {
     };
 }
 
-/* @flow */
 var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
@@ -2000,7 +1992,6 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
     }
 }
 
-/* @flow */
 function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
@@ -2033,7 +2024,6 @@ function mergeVNodeHook(def, hookKey, hook) {
     def[hookKey] = invoker;
 }
 
-/* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
@@ -2086,7 +2076,6 @@ function checkProp(res, hash, key, altKey, preserve) {
     return false;
 }
 
-/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -2173,7 +2162,6 @@ function normalizeArrayChildren(children, nestedIndex) {
     return res;
 }
 
-/* @flow */
 function initProvide(vm) {
     var provide = vm.$options.provide;
     if (provide) {
@@ -2242,7 +2230,6 @@ function resolveInject(inject, vm) {
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
@@ -2288,7 +2275,6 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     var res;
     var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2441,7 +2427,6 @@ function resolveFilter(id) {
     return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/* @flow */
 function isKeyNotMatch(expect, actual) {
     if (Array.isArray(expect)) {
         return expect.indexOf(actual) === -1;
@@ -2468,7 +2453,6 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
@@ -2557,7 +2541,6 @@ function markStaticNode(node, key, isOnce) {
     node.isOnce = isOnce;
 }
 
-/* @flow */
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
@@ -2601,7 +2584,7 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
-/* @flow */
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -2624,7 +2607,6 @@ function prependModifier(value, symbol) {
     return typeof value === 'string' ? symbol + value : value;
 }
 
-/* @flow */
 function installRenderHelpers(target) {
     target._o = markOnce;
     target._n = toNumber;
@@ -2645,7 +2627,6 @@ function installRenderHelpers(target) {
     target._p = prependModifier;
 }
 
-/* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
     var _this = this;
     var options = Ctor.options;
@@ -2760,7 +2741,6 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
     init: function (vnode, hydrating) {
@@ -2954,7 +2934,6 @@ function transformModel(options, data) {
     }
 }
 
-/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
@@ -3080,7 +3059,6 @@ function registerDeepBindings(data) {
     }
 }
 
-/* @flow */
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
@@ -3180,7 +3158,6 @@ function renderMixin(Vue) {
     };
 }
 
-/* @flow */
 function ensureCtor(comp, base) {
     if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
         comp = comp.default;
@@ -3299,13 +3276,11 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-/* @flow */
 function isAsyncPlaceholder(node) {
     // @ts-expect-error not really boolean type
     return node.isComment && node.asyncFactory;
 }
 
-/* @flow */
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
         for (var i = 0; i < children.length; i++) {
@@ -3317,7 +3292,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
@@ -3437,7 +3411,6 @@ function eventsMixin(Vue) {
     };
 }
 
-/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
@@ -3734,7 +3707,6 @@ function callHook$1(vm, hook) {
     popTarget();
 }
 
-/* @flow */
 var MAX_UPDATE_COUNT = 100;
 var queue = [];
 var activatedChildren = [];
@@ -3890,7 +3862,6 @@ function queueWatcher(watcher) {
     }
 }
 
-/* @flow */
 var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
@@ -4087,7 +4058,6 @@ var Watcher = /** @class */ (function () {
     return Watcher;
 }());
 
-/* @flow */
 var sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
@@ -4380,7 +4350,6 @@ function stateMixin(Vue) {
     };
 }
 
-/* @flow */
 var uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
@@ -4505,7 +4474,6 @@ lifecycleMixin(Vue);
 //@ts-ignore
 renderMixin(Vue);
 
-/* @flow */
 function initUse(Vue) {
     Vue.use = function (plugin) {
         var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4526,7 +4494,6 @@ function initUse(Vue) {
     };
 }
 
-/* @flow */
 function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
@@ -4534,7 +4501,6 @@ function initMixin(Vue) {
     };
 }
 
-/* @flow */
 function initExtend(Vue) {
     /**
      * Each instance constructor, including Vue, has a unique
@@ -4612,7 +4578,6 @@ function initComputed(Comp) {
     }
 }
 
-/* @flow */
 function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
@@ -4643,7 +4608,6 @@ function initAssetRegisters(Vue) {
     });
 }
 
-// @ts-nocheck
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4675,6 +4639,7 @@ function pruneCache(keepAliveInstance, filter) {
 function pruneCacheEntry(cache, key, keys, current) {
     var cached = cache[key];
     if (cached && (!current || cached.tag !== current.tag)) {
+        //@ts-expect-error has void type
         cached.componentInstance.$destroy();
     }
     cache[key] = null;
@@ -4754,7 +4719,6 @@ var builtInComponents = {
     KeepAlive: KeepAlive,
 };
 
-/* @flow */
 function initGlobalAPI(Vue) {
     // config
     var configDef = {};
@@ -4812,7 +4776,6 @@ Object.defineProperty(Vue, 'FunctionalRenderContext', {
 });
 Vue.version = '2.6.12';
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
@@ -4851,7 +4814,6 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
-/* @flow */
 function genClassForVnode(vnode) {
     var data = vnode.data;
     var parentNode = vnode;
@@ -4922,7 +4884,6 @@ function stringifyObject(value) {
     return res;
 }
 
-/* @flow */
 var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
@@ -4984,7 +4945,6 @@ function isUnknownElement(tag) {
 }
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
@@ -5003,7 +4963,6 @@ function query(el) {
     }
 }
 
-/* @flow */
 function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
@@ -5067,7 +5026,6 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/* @flow */
 var ref = {
     create: function (_, vnode) {
         registerRef(vnode);
@@ -5850,7 +5808,6 @@ function createPatchFunction(backend) {
     };
 }
 
-/* @flow */
 var directives$1 = {
     create: updateDirectives,
     update: updateDirectives,
@@ -5958,7 +5915,6 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 
 var baseModules = [ref, directives$1];
 
-/* @flow */
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6062,7 +6018,6 @@ var attrs = {
     update: updateAttrs,
 };
 
-/* @flow */
 function updateClass(oldVnode, vnode) {
     var el = vnode.elm;
     var data = vnode.data;
@@ -6090,7 +6045,6 @@ var klass$1 = {
     update: updateClass,
 };
 
-/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
     var inSingle = false;
@@ -6214,7 +6168,6 @@ function wrapFilter(exp, filter) {
     }
 }
 
-/* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
     console.error("[Vue compiler]: " + msg);
@@ -6382,7 +6335,6 @@ function rangeSetItem(item, range) {
     return item;
 }
 
-/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
@@ -6508,7 +6460,6 @@ function parseString(chr) {
     }
 }
 
-/* @flow */
 var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -6631,7 +6582,6 @@ function genDefaultModel(el, value, modifiers) {
     }
 }
 
-/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
@@ -6720,7 +6670,6 @@ var events = {
     update: updateDOMListeners,
 };
 
-/* @flow */
 var svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6832,7 +6781,6 @@ var domProps = {
     update: updateDOMProps,
 };
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -6892,7 +6840,6 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
@@ -6973,7 +6920,6 @@ var style$1 = {
     update: updateStyle,
 };
 
-/* @flow */
 var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
@@ -7203,7 +7149,6 @@ function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-/* @flow */
 function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
@@ -7456,7 +7401,6 @@ var transition = inBrowser
 
 var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules$1 = platformModules.concat(baseModules);
@@ -7595,7 +7539,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-/* @flow */
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -7656,7 +7599,7 @@ var platformDirectives = {
     show: show,
 };
 
-/* @flow */
+// Provides transition support for a single element/component.
 var transitionProps = {
     name: String,
     appear: Boolean,
@@ -8042,7 +7985,6 @@ if (inBrowser) {
     }, 0);
 }
 
-/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -8083,7 +8025,6 @@ function parseText(text, delimiters) {
     };
 }
 
-/* @flow */
 function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
@@ -8120,7 +8061,6 @@ var klass = {
     genData: genData$2,
 };
 
-/* @flow */
 function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
@@ -8158,7 +8098,6 @@ var style = {
     genData: genData$1,
 };
 
-/* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
@@ -8461,7 +8400,6 @@ function parseHTML(html, options) {
     }
 }
 
-/* @flow */
 var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
@@ -9265,7 +9203,15 @@ function checkForAliasModel(el, value) {
     }
 }
 
-/* @flow */
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
         var map = el.attrsMap;
@@ -9333,14 +9279,12 @@ var model = {
 
 var modules = [klass, style, model];
 
-/* @flow */
 function text(el, dir) {
     if (dir.value) {
         addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
-/* @flow */
 function html(el, dir) {
     if (dir.value) {
         addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -9353,7 +9297,6 @@ var directives = {
     html: html,
 };
 
-/* @flow */
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -9368,7 +9311,6 @@ var baseOptions = {
     staticKeys: genStaticKeys$1(modules),
 };
 
-/* @flow */
 var isStaticKey;
 var isPlatformReservedTag;
 var genStaticKeysCached = cached(genStaticKeys);
@@ -9486,7 +9428,6 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -9638,7 +9579,6 @@ function genFilterCode(key) {
         ")");
 }
 
-/* @flow */
 function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
@@ -9646,21 +9586,18 @@ function on(el, dir) {
     el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
-/* @flow */
 function bind(el, dir) {
     el.wrapData = function (code) {
         return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
-/* @flow */
 var baseDirectives = {
     on: on,
     bind: bind,
     cloak: noop,
 };
 
-/* @flow */
 var CodegenState = /** @class */ (function () {
     function CodegenState(options) {
         this.options = options;
@@ -10144,7 +10081,6 @@ function transformSpecialNewlines(text) {
     return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
 var prohibitedKeywordRE = new RegExp('\\b' +
@@ -10253,7 +10189,6 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
     }
 }
 
-/* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
     if (start === void 0) { start = 0; }
@@ -10304,7 +10239,6 @@ function repeat(str, n) {
     return result;
 }
 
-/* @flow */
 function createFunction(code, errors) {
     try {
         return new Function(code);
@@ -10395,7 +10329,6 @@ function createCompileToFunctionFn(compile) {
     };
 }
 
-/* @flow */
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
@@ -10454,7 +10387,6 @@ function createCompilerCreator(baseCompile) {
     };
 }
 
-/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
@@ -10471,10 +10403,8 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-/* @flow */
 var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
-/* @flow */
 // check whether current browser encodes a char inside attribute values
 var div;
 function getShouldDecode(href) {
@@ -10489,7 +10419,6 @@ var shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
-/* @flow */
 var idToTemplate = cached(function (id) {
     var el = query(id);
     return el && el.innerHTML;
diff --git a/dist/vue.js b/dist/vue.js
index 2eb5cf4e43e..5f87cb32293 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -9,7 +9,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
 }(this, (function () { 'use strict';
 
-  /* @flow */
   var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
@@ -330,7 +329,6 @@
       'errorCaptured',
       'serverPrefetch' ];
 
-  /* @flow */
   var config = {
       /**
        * Option merge strategies (used in core/util/options)
@@ -409,7 +407,6 @@
       _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -453,7 +450,6 @@
       };
   }
 
-  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
   // Browser environment sniffing
@@ -544,7 +540,6 @@
       }());
   }
 
-  /* @flow */
   var warn$2 = noop;
   var tip = noop;
   var generateComponentTrace; // work around flow check
@@ -1037,7 +1032,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
@@ -1416,7 +1410,6 @@
       return res;
   }
 
-  /* @flow */
   function validateProp(key, propOptions, propsData, vm) {
       var prop = propOptions[key];
       var absent = !hasOwn(propsData, key);
@@ -1692,7 +1685,7 @@
       }
   }
 
-  /* @flow */
+  /* globals MutationObserver */
   var isUsingMicroTask = false;
   var callbacks = [];
   var pending = false;
@@ -1895,7 +1888,6 @@
       };
   }
 
-  /* @flow */
   var seenObjects = new _Set();
   /**
    * Recursively traverse an object to evoke all converted
@@ -1998,7 +1990,6 @@
       }
   }
 
-  /* @flow */
   function mergeVNodeHook(def, hookKey, hook) {
       if (def instanceof VNode) {
           def = def.data.hook || (def.data.hook = {});
@@ -2031,7 +2022,6 @@
       def[hookKey] = invoker;
   }
 
-  /* @flow */
   function extractPropsFromVNodeData(data, Ctor, tag) {
       // we are only extracting raw values here.
       // validation and default values are handled in the child
@@ -2084,7 +2074,6 @@
       return false;
   }
 
-  /* @flow */
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
@@ -2171,7 +2160,6 @@
       return res;
   }
 
-  /* @flow */
   function initProvide(vm) {
       var provide = vm.$options.provide;
       if (provide) {
@@ -2237,7 +2225,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
@@ -2283,7 +2270,6 @@
       return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
-  /* @flow */
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
       var res;
       var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2436,7 +2422,6 @@
       return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /* @flow */
   function isKeyNotMatch(expect, actual) {
       if (Array.isArray(expect)) {
           return expect.indexOf(actual) === -1;
@@ -2463,7 +2448,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
@@ -2551,7 +2535,6 @@
       node.isOnce = isOnce;
   }
 
-  /* @flow */
   function bindObjectListeners(data, value) {
       if (value) {
           if (!isPlainObject(value)) {
@@ -2594,7 +2577,7 @@
       return res;
   }
 
-  /* @flow */
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
       for (var i = 0; i < values.length; i += 2) {
           var key = values[i];
@@ -2616,7 +2599,6 @@
       return typeof value === 'string' ? symbol + value : value;
   }
 
-  /* @flow */
   function installRenderHelpers(target) {
       target._o = markOnce;
       target._n = toNumber;
@@ -2637,7 +2619,6 @@
       target._p = prependModifier;
   }
 
-  /* @flow */
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
       var _this = this;
       var options = Ctor.options;
@@ -2752,7 +2733,6 @@
       }
   }
 
-  /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
       init: function (vnode, hydrating) {
@@ -2946,7 +2926,6 @@
       }
   }
 
-  /* @flow */
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
@@ -3069,7 +3048,6 @@
       }
   }
 
-  /* @flow */
   function initRender(vm) {
       vm._vnode = null; // the root of the child tree
       vm._staticTrees = null; // v-once cached trees
@@ -3165,7 +3143,6 @@
       };
   }
 
-  /* @flow */
   function ensureCtor(comp, base) {
       if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
           comp = comp.default;
@@ -3282,13 +3259,11 @@
       }
   }
 
-  /* @flow */
   function isAsyncPlaceholder(node) {
       // @ts-expect-error not really boolean type
       return node.isComment && node.asyncFactory;
   }
 
-  /* @flow */
   function getFirstComponentChild(children) {
       if (Array.isArray(children)) {
           for (var i = 0; i < children.length; i++) {
@@ -3300,7 +3275,6 @@
       }
   }
 
-  /* @flow */
   function initEvents(vm) {
       vm._events = Object.create(null);
       vm._hasHookEvent = false;
@@ -3420,7 +3394,6 @@
       };
   }
 
-  /* @flow */
   var activeInstance = null;
   var isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
@@ -3717,7 +3690,6 @@
       popTarget();
   }
 
-  /* @flow */
   var MAX_UPDATE_COUNT = 100;
   var queue = [];
   var activatedChildren = [];
@@ -3873,7 +3845,6 @@
       }
   }
 
-  /* @flow */
   var uid$1 = 0;
   /**
    * A watcher parses an expression, collects dependencies,
@@ -4069,7 +4040,6 @@
       return Watcher;
   }());
 
-  /* @flow */
   var sharedPropertyDefinition = {
       enumerable: true,
       configurable: true,
@@ -4356,7 +4326,6 @@
       };
   }
 
-  /* @flow */
   var uid = 0;
   function initMixin$1(Vue) {
       Vue.prototype._init = function (options) {
@@ -4478,7 +4447,6 @@
   //@ts-ignore
   renderMixin(Vue);
 
-  /* @flow */
   function initUse(Vue) {
       Vue.use = function (plugin) {
           var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4499,7 +4467,6 @@
       };
   }
 
-  /* @flow */
   function initMixin(Vue) {
       Vue.mixin = function (mixin) {
           this.options = mergeOptions(this.options, mixin);
@@ -4507,7 +4474,6 @@
       };
   }
 
-  /* @flow */
   function initExtend(Vue) {
       /**
        * Each instance constructor, including Vue, has a unique
@@ -4585,7 +4551,6 @@
       }
   }
 
-  /* @flow */
   function initAssetRegisters(Vue) {
       /**
        * Create asset registration methods.
@@ -4616,7 +4581,6 @@
       });
   }
 
-  // @ts-nocheck
   function getComponentName(opts) {
       return opts && (opts.Ctor.options.name || opts.tag);
   }
@@ -4648,6 +4612,7 @@
   function pruneCacheEntry(cache, key, keys, current) {
       var cached = cache[key];
       if (cached && (!current || cached.tag !== current.tag)) {
+          //@ts-expect-error has void type
           cached.componentInstance.$destroy();
       }
       cache[key] = null;
@@ -4727,7 +4692,6 @@
       KeepAlive: KeepAlive,
   };
 
-  /* @flow */
   function initGlobalAPI(Vue) {
       // config
       var configDef = {};
@@ -4785,7 +4749,6 @@
   });
   Vue.version = '2.6.12';
 
-  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   var isReservedAttr = makeMap('style,class');
@@ -4824,7 +4787,6 @@
       return val == null || val === false;
   };
 
-  /* @flow */
   function genClassForVnode(vnode) {
       var data = vnode.data;
       var parentNode = vnode;
@@ -4895,7 +4857,6 @@
       return res;
   }
 
-  /* @flow */
   var namespaceMap = {
       svg: 'http://www.w3.org/2000/svg',
       math: 'http://www.w3.org/1998/Math/MathML',
@@ -4957,7 +4918,6 @@
   }
   var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /* @flow */
   /**
    * Query an element selector if it's not an element already.
    */
@@ -4975,7 +4935,6 @@
       }
   }
 
-  /* @flow */
   function createElement(tagName, vnode) {
       var elm = document.createElement(tagName);
       if (tagName !== 'select') {
@@ -5039,7 +4998,6 @@
     setStyleScope: setStyleScope
   });
 
-  /* @flow */
   var ref = {
       create: function (_, vnode) {
           registerRef(vnode);
@@ -5820,7 +5778,6 @@
       };
   }
 
-  /* @flow */
   var directives$1 = {
       create: updateDirectives,
       update: updateDirectives,
@@ -5928,7 +5885,6 @@
 
   var baseModules = [ref, directives$1];
 
-  /* @flow */
   function updateAttrs(oldVnode, vnode) {
       var opts = vnode.componentOptions;
       if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6032,7 +5988,6 @@
       update: updateAttrs,
   };
 
-  /* @flow */
   function updateClass(oldVnode, vnode) {
       var el = vnode.elm;
       var data = vnode.data;
@@ -6060,7 +6015,6 @@
       update: updateClass,
   };
 
-  /* @flow */
   var validDivisionCharRE = /[\w).+\-_$\]]/;
   function parseFilters(exp) {
       var inSingle = false;
@@ -6184,7 +6138,6 @@
       }
   }
 
-  /* @flow */
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
       console.error("[Vue compiler]: " + msg);
@@ -6351,7 +6304,6 @@
       return item;
   }
 
-  /* @flow */
   /**
    * Cross-platform code generation for component v-model
    */
@@ -6477,7 +6429,6 @@
       }
   }
 
-  /* @flow */
   var warn$1;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
@@ -6600,7 +6551,6 @@
       }
   }
 
-  /* @flow */
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
   // the whole point is ensuring the v-model callback gets called before
@@ -6689,7 +6639,6 @@
       update: updateDOMListeners,
   };
 
-  /* @flow */
   var svgContainer;
   function updateDOMProps(oldVnode, vnode) {
       if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6801,7 +6750,6 @@
       update: updateDOMProps,
   };
 
-  /* @flow */
   var parseStyleText = cached(function (cssText) {
       var res = {};
       var listDelimiter = /;(?![^(]*\))/g;
@@ -6861,7 +6809,6 @@
       return res;
   }
 
-  /* @flow */
   var cssVarRE = /^--/;
   var importantRE = /\s*!important$/;
   var setProp = function (el, name, val) {
@@ -6942,7 +6889,6 @@
       update: updateStyle,
   };
 
-  /* @flow */
   var whitespaceRE$1 = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
@@ -7172,7 +7118,6 @@
       return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  /* @flow */
   function enter(vnode, toggleDisplay) {
       var el = vnode.elm;
       // call leave callback now
@@ -7425,7 +7370,6 @@
 
   var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-  /* @flow */
   // the directive module should be applied last, after all
   // built-in modules have been applied.
   var modules$1 = platformModules.concat(baseModules);
@@ -7563,7 +7507,6 @@
       el.dispatchEvent(e);
   }
 
-  /* @flow */
   // recursively search for possible transition defined inside the component root
   function locateNode(vnode) {
       // @ts-expect-error
@@ -7624,7 +7567,7 @@
       show: show,
   };
 
-  /* @flow */
+  // Provides transition support for a single element/component.
   var transitionProps = {
       name: String,
       appear: Boolean,
@@ -8006,7 +7949,6 @@
       }, 0);
   }
 
-  /* @flow */
   var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
   var buildRegex = cached(function (delimiters) {
@@ -8047,7 +7989,6 @@
       };
   }
 
-  /* @flow */
   function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
@@ -8084,7 +8025,6 @@
       genData: genData$2,
   };
 
-  /* @flow */
   function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
@@ -8122,7 +8062,6 @@
       genData: genData$1,
   };
 
-  /* @flow */
   var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
@@ -8423,7 +8362,6 @@
       }
   }
 
-  /* @flow */
   var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
@@ -9222,7 +9160,15 @@
       }
   }
 
-  /* @flow */
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
   function preTransformNode(el, options) {
       if (el.tag === 'input') {
           var map = el.attrsMap;
@@ -9290,14 +9236,12 @@
 
   var modules = [klass, style, model];
 
-  /* @flow */
   function text(el, dir) {
       if (dir.value) {
           addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
-  /* @flow */
   function html(el, dir) {
       if (dir.value) {
           addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -9310,7 +9254,6 @@
       html: html,
   };
 
-  /* @flow */
   var baseOptions = {
       expectHTML: true,
       modules: modules,
@@ -9325,7 +9268,6 @@
       staticKeys: genStaticKeys$1(modules),
   };
 
-  /* @flow */
   var isStaticKey;
   var isPlatformReservedTag;
   var genStaticKeysCached = cached(genStaticKeys);
@@ -9443,7 +9385,6 @@
       return false;
   }
 
-  /* @flow */
   var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -9595,7 +9536,6 @@
           ")");
   }
 
-  /* @flow */
   function on(el, dir) {
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
@@ -9603,21 +9543,18 @@
       el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
-  /* @flow */
   function bind(el, dir) {
       el.wrapData = function (code) {
           return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
-  /* @flow */
   var baseDirectives = {
       on: on,
       bind: bind,
       cloak: noop,
   };
 
-  /* @flow */
   var CodegenState = /** @class */ (function () {
       function CodegenState(options) {
           this.options = options;
@@ -10098,7 +10035,6 @@
       return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  /* @flow */
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
   var prohibitedKeywordRE = new RegExp('\\b' +
@@ -10207,7 +10143,6 @@
       }
   }
 
-  /* @flow */
   var range = 2;
   function generateCodeFrame(source, start, end) {
       if (start === void 0) { start = 0; }
@@ -10258,7 +10193,6 @@
       return result;
   }
 
-  /* @flow */
   function createFunction(code, errors) {
       try {
           return new Function(code);
@@ -10349,7 +10283,6 @@
       };
   }
 
-  /* @flow */
   function createCompilerCreator(baseCompile) {
       return function createCompiler(baseOptions) {
           function compile(template, options) {
@@ -10407,7 +10340,6 @@
       };
   }
 
-  /* @flow */
   // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
@@ -10424,10 +10356,8 @@
       };
   });
 
-  /* @flow */
   var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
-  /* @flow */
   // check whether current browser encodes a char inside attribute values
   var div;
   function getShouldDecode(href) {
@@ -10442,7 +10372,6 @@
       ? getShouldDecode(true)
       : false;
 
-  /* @flow */
   var idToTemplate = cached(function (id) {
       var el = query(id);
       return el && el.innerHTML;
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index 4e640510c0e..594abc137b7 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -1671,6 +1671,7 @@ function logError(err, vm, info) {
     }
 }
 
+/* globals MutationObserver */
 var isUsingMicroTask = false;
 var callbacks = [];
 var pending = false;
@@ -2562,6 +2563,7 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -4565,7 +4567,6 @@ function initAssetRegisters(Vue) {
     });
 }
 
-// @ts-nocheck
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4597,6 +4598,7 @@ function pruneCache(keepAliveInstance, filter) {
 function pruneCacheEntry(cache, key, keys, current) {
     var cached = cache[key];
     if (cached && (!current || cached.tag !== current.tag)) {
+        //@ts-expect-error has void type
         cached.componentInstance.$destroy();
     }
     cache[key] = null;
@@ -7019,6 +7021,7 @@ var platformDirectives = {
     show: show,
 };
 
+// Provides transition support for a single element/component.
 var transitionProps = {
     name: String,
     appear: Boolean,
@@ -7400,5 +7403,4 @@ if (inBrowser) {
     }, 0);
 }
 
-
 module.exports = Vue;
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index 4ca266587b6..df8d4545a0c 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -3,7 +3,6 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -314,7 +313,6 @@ var LIFECYCLE_HOOKS = [
     'errorCaptured',
     'serverPrefetch' ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -393,7 +391,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -437,7 +434,6 @@ function parsePath(path) {
     };
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -528,7 +524,6 @@ else {
     }());
 }
 
-/* @flow */
 var warn = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
@@ -1025,7 +1020,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1405,7 +1399,6 @@ function resolveAsset(options, type, id, warnMissing) {
     return res;
 }
 
-/* @flow */
 function validateProp(key, propOptions, propsData, vm) {
     var prop = propOptions[key];
     var absent = !hasOwn(propsData, key);
@@ -1683,7 +1676,7 @@ function logError(err, vm, info) {
     }
 }
 
-/* @flow */
+/* globals MutationObserver */
 var isUsingMicroTask = false;
 var callbacks = [];
 var pending = false;
@@ -1866,7 +1859,6 @@ if (process.env.NODE_ENV !== 'production') {
     };
 }
 
-/* @flow */
 var seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
@@ -1990,7 +1982,6 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
     }
 }
 
-/* @flow */
 function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
@@ -2023,7 +2014,6 @@ function mergeVNodeHook(def, hookKey, hook) {
     def[hookKey] = invoker;
 }
 
-/* @flow */
 function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
@@ -2076,7 +2066,6 @@ function checkProp(res, hash, key, altKey, preserve) {
     return false;
 }
 
-/* @flow */
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -2163,7 +2152,6 @@ function normalizeArrayChildren(children, nestedIndex) {
     return res;
 }
 
-/* @flow */
 function initProvide(vm) {
     var provide = vm.$options.provide;
     if (provide) {
@@ -2232,7 +2220,6 @@ function resolveInject(inject, vm) {
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
@@ -2278,7 +2265,6 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/* @flow */
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     var res;
     var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2431,7 +2417,6 @@ function resolveFilter(id) {
     return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/* @flow */
 function isKeyNotMatch(expect, actual) {
     if (Array.isArray(expect)) {
         return expect.indexOf(actual) === -1;
@@ -2458,7 +2443,6 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     }
 }
 
-/* @flow */
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
@@ -2547,7 +2531,6 @@ function markStaticNode(node, key, isOnce) {
     node.isOnce = isOnce;
 }
 
-/* @flow */
 function bindObjectListeners(data, value) {
     if (value) {
         if (!isPlainObject(value)) {
@@ -2591,7 +2574,7 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
-/* @flow */
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -2614,7 +2597,6 @@ function prependModifier(value, symbol) {
     return typeof value === 'string' ? symbol + value : value;
 }
 
-/* @flow */
 function installRenderHelpers(target) {
     target._o = markOnce;
     target._n = toNumber;
@@ -2635,7 +2617,6 @@ function installRenderHelpers(target) {
     target._p = prependModifier;
 }
 
-/* @flow */
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
     var _this = this;
     var options = Ctor.options;
@@ -2750,7 +2731,6 @@ function mergeProps(to, from) {
     }
 }
 
-/* @flow */
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
     init: function (vnode, hydrating) {
@@ -2944,7 +2924,6 @@ function transformModel(options, data) {
     }
 }
 
-/* @flow */
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
@@ -3070,7 +3049,6 @@ function registerDeepBindings(data) {
     }
 }
 
-/* @flow */
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
@@ -3170,7 +3148,6 @@ function renderMixin(Vue) {
     };
 }
 
-/* @flow */
 function ensureCtor(comp, base) {
     if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
         comp = comp.default;
@@ -3289,13 +3266,11 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-/* @flow */
 function isAsyncPlaceholder(node) {
     // @ts-expect-error not really boolean type
     return node.isComment && node.asyncFactory;
 }
 
-/* @flow */
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
         for (var i = 0; i < children.length; i++) {
@@ -3307,7 +3282,6 @@ function getFirstComponentChild(children) {
     }
 }
 
-/* @flow */
 function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
@@ -3427,7 +3401,6 @@ function eventsMixin(Vue) {
     };
 }
 
-/* @flow */
 var activeInstance = null;
 var isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
@@ -3724,7 +3697,6 @@ function callHook$1(vm, hook) {
     popTarget();
 }
 
-/* @flow */
 var MAX_UPDATE_COUNT = 100;
 var queue = [];
 var activatedChildren = [];
@@ -3880,7 +3852,6 @@ function queueWatcher(watcher) {
     }
 }
 
-/* @flow */
 var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
@@ -4077,7 +4048,6 @@ var Watcher = /** @class */ (function () {
     return Watcher;
 }());
 
-/* @flow */
 var sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
@@ -4370,7 +4340,6 @@ function stateMixin(Vue) {
     };
 }
 
-/* @flow */
 var uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
@@ -4495,7 +4464,6 @@ lifecycleMixin(Vue);
 //@ts-ignore
 renderMixin(Vue);
 
-/* @flow */
 function initUse(Vue) {
     Vue.use = function (plugin) {
         var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4516,7 +4484,6 @@ function initUse(Vue) {
     };
 }
 
-/* @flow */
 function initMixin(Vue) {
     Vue.mixin = function (mixin) {
         this.options = mergeOptions(this.options, mixin);
@@ -4524,7 +4491,6 @@ function initMixin(Vue) {
     };
 }
 
-/* @flow */
 function initExtend(Vue) {
     /**
      * Each instance constructor, including Vue, has a unique
@@ -4602,7 +4568,6 @@ function initComputed(Comp) {
     }
 }
 
-/* @flow */
 function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
@@ -4633,7 +4598,6 @@ function initAssetRegisters(Vue) {
     });
 }
 
-// @ts-nocheck
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4665,6 +4629,7 @@ function pruneCache(keepAliveInstance, filter) {
 function pruneCacheEntry(cache, key, keys, current) {
     var cached = cache[key];
     if (cached && (!current || cached.tag !== current.tag)) {
+        //@ts-expect-error has void type
         cached.componentInstance.$destroy();
     }
     cache[key] = null;
@@ -4744,7 +4709,6 @@ var builtInComponents = {
     KeepAlive: KeepAlive,
 };
 
-/* @flow */
 function initGlobalAPI(Vue) {
     // config
     var configDef = {};
@@ -4802,7 +4766,6 @@ Object.defineProperty(Vue, 'FunctionalRenderContext', {
 });
 Vue.version = '2.6.12';
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 var isReservedAttr = makeMap('style,class');
@@ -4841,7 +4804,6 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
-/* @flow */
 function genClassForVnode(vnode) {
     var data = vnode.data;
     var parentNode = vnode;
@@ -4912,7 +4874,6 @@ function stringifyObject(value) {
     return res;
 }
 
-/* @flow */
 var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
@@ -4973,7 +4934,6 @@ function isUnknownElement(tag) {
 }
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 /**
  * Query an element selector if it's not an element already.
  */
@@ -4992,7 +4952,6 @@ function query(el) {
     }
 }
 
-/* @flow */
 function createElement(tagName, vnode) {
     var elm = document.createElement(tagName);
     if (tagName !== 'select') {
@@ -5056,7 +5015,6 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/* @flow */
 var ref = {
     create: function (_, vnode) {
         registerRef(vnode);
@@ -5839,7 +5797,6 @@ function createPatchFunction(backend) {
     };
 }
 
-/* @flow */
 var directives = {
     create: updateDirectives,
     update: updateDirectives,
@@ -5947,7 +5904,6 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 
 var baseModules = [ref, directives];
 
-/* @flow */
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6051,7 +6007,6 @@ var attrs = {
     update: updateAttrs,
 };
 
-/* @flow */
 function updateClass(oldVnode, vnode) {
     var el = vnode.elm;
     var data = vnode.data;
@@ -6079,13 +6034,11 @@ var klass = {
     update: updateClass,
 };
 
-/* @flow */
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
 var RANGE_TOKEN = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
 
-/* @flow */
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
 // the whole point is ensuring the v-model callback gets called before
@@ -6174,7 +6127,6 @@ var events = {
     update: updateDOMListeners,
 };
 
-/* @flow */
 var svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6286,7 +6238,6 @@ var domProps = {
     update: updateDOMProps,
 };
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -6346,7 +6297,6 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-/* @flow */
 var cssVarRE = /^--/;
 var importantRE = /\s*!important$/;
 var setProp = function (el, name, val) {
@@ -6427,7 +6377,6 @@ var style = {
     update: updateStyle,
 };
 
-/* @flow */
 var whitespaceRE = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
@@ -6657,7 +6606,6 @@ function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-/* @flow */
 function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
@@ -6910,7 +6858,6 @@ var transition = inBrowser
 
 var platformModules = [attrs, klass, events, domProps, style, transition];
 
-/* @flow */
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
@@ -7049,7 +6996,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-/* @flow */
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -7110,7 +7056,7 @@ var platformDirectives = {
     show: show,
 };
 
-/* @flow */
+// Provides transition support for a single element/component.
 var transitionProps = {
     name: String,
     appear: Boolean,
@@ -7496,6 +7442,4 @@ if (inBrowser) {
     }, 0);
 }
 
-/* @flow */
-
 export default Vue;
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 050daa627f1..23b3dac3edd 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -9,7 +9,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
 }(this, (function () { 'use strict';
 
-  /* @flow */
   var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
@@ -320,7 +319,6 @@
       'errorCaptured',
       'serverPrefetch' ];
 
-  /* @flow */
   var config = {
       /**
        * Option merge strategies (used in core/util/options)
@@ -399,7 +397,6 @@
       _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -443,7 +440,6 @@
       };
   }
 
-  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
   // Browser environment sniffing
@@ -534,7 +530,6 @@
       }());
   }
 
-  /* @flow */
   var warn = noop;
   var tip = noop;
   var generateComponentTrace; // work around flow check
@@ -1027,7 +1022,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
@@ -1406,7 +1400,6 @@
       return res;
   }
 
-  /* @flow */
   function validateProp(key, propOptions, propsData, vm) {
       var prop = propOptions[key];
       var absent = !hasOwn(propsData, key);
@@ -1682,7 +1675,7 @@
       }
   }
 
-  /* @flow */
+  /* globals MutationObserver */
   var isUsingMicroTask = false;
   var callbacks = [];
   var pending = false;
@@ -1865,7 +1858,6 @@
       };
   }
 
-  /* @flow */
   var seenObjects = new _Set();
   /**
    * Recursively traverse an object to evoke all converted
@@ -1988,7 +1980,6 @@
       }
   }
 
-  /* @flow */
   function mergeVNodeHook(def, hookKey, hook) {
       if (def instanceof VNode) {
           def = def.data.hook || (def.data.hook = {});
@@ -2021,7 +2012,6 @@
       def[hookKey] = invoker;
   }
 
-  /* @flow */
   function extractPropsFromVNodeData(data, Ctor, tag) {
       // we are only extracting raw values here.
       // validation and default values are handled in the child
@@ -2074,7 +2064,6 @@
       return false;
   }
 
-  /* @flow */
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
@@ -2161,7 +2150,6 @@
       return res;
   }
 
-  /* @flow */
   function initProvide(vm) {
       var provide = vm.$options.provide;
       if (provide) {
@@ -2227,7 +2215,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
@@ -2273,7 +2260,6 @@
       return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
-  /* @flow */
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
       var res;
       var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2426,7 +2412,6 @@
       return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /* @flow */
   function isKeyNotMatch(expect, actual) {
       if (Array.isArray(expect)) {
           return expect.indexOf(actual) === -1;
@@ -2453,7 +2438,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
@@ -2541,7 +2525,6 @@
       node.isOnce = isOnce;
   }
 
-  /* @flow */
   function bindObjectListeners(data, value) {
       if (value) {
           if (!isPlainObject(value)) {
@@ -2584,7 +2567,7 @@
       return res;
   }
 
-  /* @flow */
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
       for (var i = 0; i < values.length; i += 2) {
           var key = values[i];
@@ -2606,7 +2589,6 @@
       return typeof value === 'string' ? symbol + value : value;
   }
 
-  /* @flow */
   function installRenderHelpers(target) {
       target._o = markOnce;
       target._n = toNumber;
@@ -2627,7 +2609,6 @@
       target._p = prependModifier;
   }
 
-  /* @flow */
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
       var _this = this;
       var options = Ctor.options;
@@ -2742,7 +2723,6 @@
       }
   }
 
-  /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
       init: function (vnode, hydrating) {
@@ -2936,7 +2916,6 @@
       }
   }
 
-  /* @flow */
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
@@ -3059,7 +3038,6 @@
       }
   }
 
-  /* @flow */
   function initRender(vm) {
       vm._vnode = null; // the root of the child tree
       vm._staticTrees = null; // v-once cached trees
@@ -3155,7 +3133,6 @@
       };
   }
 
-  /* @flow */
   function ensureCtor(comp, base) {
       if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
           comp = comp.default;
@@ -3272,13 +3249,11 @@
       }
   }
 
-  /* @flow */
   function isAsyncPlaceholder(node) {
       // @ts-expect-error not really boolean type
       return node.isComment && node.asyncFactory;
   }
 
-  /* @flow */
   function getFirstComponentChild(children) {
       if (Array.isArray(children)) {
           for (var i = 0; i < children.length; i++) {
@@ -3290,7 +3265,6 @@
       }
   }
 
-  /* @flow */
   function initEvents(vm) {
       vm._events = Object.create(null);
       vm._hasHookEvent = false;
@@ -3410,7 +3384,6 @@
       };
   }
 
-  /* @flow */
   var activeInstance = null;
   var isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
@@ -3707,7 +3680,6 @@
       popTarget();
   }
 
-  /* @flow */
   var MAX_UPDATE_COUNT = 100;
   var queue = [];
   var activatedChildren = [];
@@ -3863,7 +3835,6 @@
       }
   }
 
-  /* @flow */
   var uid$1 = 0;
   /**
    * A watcher parses an expression, collects dependencies,
@@ -4059,7 +4030,6 @@
       return Watcher;
   }());
 
-  /* @flow */
   var sharedPropertyDefinition = {
       enumerable: true,
       configurable: true,
@@ -4346,7 +4316,6 @@
       };
   }
 
-  /* @flow */
   var uid = 0;
   function initMixin$1(Vue) {
       Vue.prototype._init = function (options) {
@@ -4468,7 +4437,6 @@
   //@ts-ignore
   renderMixin(Vue);
 
-  /* @flow */
   function initUse(Vue) {
       Vue.use = function (plugin) {
           var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
@@ -4489,7 +4457,6 @@
       };
   }
 
-  /* @flow */
   function initMixin(Vue) {
       Vue.mixin = function (mixin) {
           this.options = mergeOptions(this.options, mixin);
@@ -4497,7 +4464,6 @@
       };
   }
 
-  /* @flow */
   function initExtend(Vue) {
       /**
        * Each instance constructor, including Vue, has a unique
@@ -4575,7 +4541,6 @@
       }
   }
 
-  /* @flow */
   function initAssetRegisters(Vue) {
       /**
        * Create asset registration methods.
@@ -4606,7 +4571,6 @@
       });
   }
 
-  // @ts-nocheck
   function getComponentName(opts) {
       return opts && (opts.Ctor.options.name || opts.tag);
   }
@@ -4638,6 +4602,7 @@
   function pruneCacheEntry(cache, key, keys, current) {
       var cached = cache[key];
       if (cached && (!current || cached.tag !== current.tag)) {
+          //@ts-expect-error has void type
           cached.componentInstance.$destroy();
       }
       cache[key] = null;
@@ -4717,7 +4682,6 @@
       KeepAlive: KeepAlive,
   };
 
-  /* @flow */
   function initGlobalAPI(Vue) {
       // config
       var configDef = {};
@@ -4775,7 +4739,6 @@
   });
   Vue.version = '2.6.12';
 
-  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   var isReservedAttr = makeMap('style,class');
@@ -4814,7 +4777,6 @@
       return val == null || val === false;
   };
 
-  /* @flow */
   function genClassForVnode(vnode) {
       var data = vnode.data;
       var parentNode = vnode;
@@ -4885,7 +4847,6 @@
       return res;
   }
 
-  /* @flow */
   var namespaceMap = {
       svg: 'http://www.w3.org/2000/svg',
       math: 'http://www.w3.org/1998/Math/MathML',
@@ -4946,7 +4907,6 @@
   }
   var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /* @flow */
   /**
    * Query an element selector if it's not an element already.
    */
@@ -4964,7 +4924,6 @@
       }
   }
 
-  /* @flow */
   function createElement(tagName, vnode) {
       var elm = document.createElement(tagName);
       if (tagName !== 'select') {
@@ -5028,7 +4987,6 @@
     setStyleScope: setStyleScope
   });
 
-  /* @flow */
   var ref = {
       create: function (_, vnode) {
           registerRef(vnode);
@@ -5809,7 +5767,6 @@
       };
   }
 
-  /* @flow */
   var directives = {
       create: updateDirectives,
       update: updateDirectives,
@@ -5917,7 +5874,6 @@
 
   var baseModules = [ref, directives];
 
-  /* @flow */
   function updateAttrs(oldVnode, vnode) {
       var opts = vnode.componentOptions;
       if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
@@ -6021,7 +5977,6 @@
       update: updateAttrs,
   };
 
-  /* @flow */
   function updateClass(oldVnode, vnode) {
       var el = vnode.elm;
       var data = vnode.data;
@@ -6049,13 +6004,11 @@
       update: updateClass,
   };
 
-  /* @flow */
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
   var CHECKBOX_RADIO_TOKEN = '__c';
 
-  /* @flow */
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
   // the whole point is ensuring the v-model callback gets called before
@@ -6144,7 +6097,6 @@
       update: updateDOMListeners,
   };
 
-  /* @flow */
   var svgContainer;
   function updateDOMProps(oldVnode, vnode) {
       if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
@@ -6256,7 +6208,6 @@
       update: updateDOMProps,
   };
 
-  /* @flow */
   var parseStyleText = cached(function (cssText) {
       var res = {};
       var listDelimiter = /;(?![^(]*\))/g;
@@ -6316,7 +6267,6 @@
       return res;
   }
 
-  /* @flow */
   var cssVarRE = /^--/;
   var importantRE = /\s*!important$/;
   var setProp = function (el, name, val) {
@@ -6397,7 +6347,6 @@
       update: updateStyle,
   };
 
-  /* @flow */
   var whitespaceRE = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
@@ -6627,7 +6576,6 @@
       return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  /* @flow */
   function enter(vnode, toggleDisplay) {
       var el = vnode.elm;
       // call leave callback now
@@ -6880,7 +6828,6 @@
 
   var platformModules = [attrs, klass, events, domProps, style, transition];
 
-  /* @flow */
   // the directive module should be applied last, after all
   // built-in modules have been applied.
   var modules = platformModules.concat(baseModules);
@@ -7018,7 +6965,6 @@
       el.dispatchEvent(e);
   }
 
-  /* @flow */
   // recursively search for possible transition defined inside the component root
   function locateNode(vnode) {
       // @ts-expect-error
@@ -7079,7 +7025,7 @@
       show: show,
   };
 
-  /* @flow */
+  // Provides transition support for a single element/component.
   var transitionProps = {
       name: String,
       appear: Boolean,
@@ -7461,8 +7407,6 @@
       }, 0);
   }
 
-  /* @flow */
-
   return Vue;
 
 })));
diff --git a/package.json b/package.json
index 81a689dcab0..09c9a3b5f91 100644
--- a/package.json
+++ b/package.json
@@ -68,13 +68,13 @@
   },
   "homepage": "https://github.com/vuejs/vue#readme",
   "devDependencies": {
-    "@babel/core": "^7.0.0",
-    "@babel/plugin-proposal-class-properties": "^7.1.0",
-    "@babel/plugin-syntax-dynamic-import": "^7.0.0",
-    "@babel/plugin-syntax-jsx": "^7.0.0",
-    "@babel/plugin-transform-flow-strip-types": "^7.0.0",
-    "@babel/preset-env": "^7.0.0",
-    "@babel/register": "^7.0.0",
+    "@babel/core": "^7.13.14",
+    "@babel/plugin-proposal-class-properties": "^7.13.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-jsx": "^7.12.13",
+    "@babel/plugin-transform-flow-strip-types": "^7.13.0",
+    "@babel/preset-env": "^7.13.12",
+    "@babel/register": "^7.13.14",
     "@rollup/plugin-alias": "^3.1.2",
     "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-buble": "^0.21.3",
@@ -85,6 +85,8 @@
     "@types/mocha": "^8.2.2",
     "@types/node": "^12.12.0",
     "@types/webpack": "^4.4.22",
+    "@typescript-eslint/eslint-plugin": "^4.21.0",
+    "@typescript-eslint/parser": "^4.21.0",
     "acorn": "^5.2.1",
     "babel-eslint": "^10.0.1",
     "babel-helper-vue-jsx-merge-props": "^2.0.3",
@@ -103,7 +105,7 @@
     "de-indent": "^1.0.2",
     "es6-promise": "^4.1.0",
     "escodegen": "^1.8.1",
-    "eslint": "^5.7.0",
+    "eslint": "^7.23.0",
     "eslint-plugin-flowtype": "^2.34.0",
     "eslint-plugin-jasmine": "^2.8.4",
     "file-loader": "^3.0.1",
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 979fd652b07..59b2cd3efdd 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -4,7 +4,6 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.renderVueComponentToString = factory());
 }(this, (function () { 'use strict';
 
-  /* @flow */
   var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
@@ -257,7 +256,6 @@
       return -1;
   }
 
-  /* @flow */
   var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
       'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
       'checked,cite,class,code,codebase,color,cols,colspan,content,' +
@@ -342,7 +340,6 @@
       'stroke-width': true,
   };
 
-  /* @flow */
   // these are reserved for web because they are directly compiled away
   // during template compilation
   makeMap('style,class');
@@ -374,7 +371,6 @@
       return val == null || val === false;
   };
 
-  /* @flow */
   function renderAttrs$1(node) {
       var attrs = node.data.attrs;
       var res = '';
@@ -494,7 +490,6 @@
       return cloned;
   }
 
-  /* @flow */
   function renderDOMProps$1(node) {
       var props = node.data.domProps;
       var res = '';
@@ -537,7 +532,6 @@
       node.children = [child];
   }
 
-  /* @flow */
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -556,7 +550,6 @@
       });
   }
 
-  /* @flow */
   // can we use __proto__?
   var hasProto = '__proto__' in {};
   // Browser environment sniffing
@@ -660,7 +653,6 @@
       'errorCaptured',
       'serverPrefetch' ];
 
-  /* @flow */
   var config = {
       /**
        * Option merge strategies (used in core/util/options)
@@ -739,7 +731,6 @@
       _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  /* @flow */
   var warn$2 = noop$1;
   var tip = noop$1;
   var generateComponentTrace; // work around flow check
@@ -1125,7 +1116,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
@@ -1504,7 +1494,6 @@
       return res;
   }
 
-  /* @flow */
   function validateProp(key, propOptions, propsData, vm) {
       var prop = propOptions[key];
       var absent = !hasOwn(propsData, key);
@@ -1768,7 +1757,7 @@
       }
   }
 
-  /* @flow */
+  /* globals MutationObserver */
   var callbacks = [];
   function flushCallbacks() {
       var copies = callbacks.slice(0);
@@ -1803,7 +1792,6 @@
   else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
   else ;
 
-  /* @flow */
   function genClassForVnode(vnode) {
       var data = vnode.data;
       var parentNode = vnode;
@@ -1874,7 +1862,6 @@
       return res;
   }
 
-  /* @flow */
   var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
       'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
@@ -1907,7 +1894,6 @@
   }
   makeMap('text,number,password,search,email,tel,url');
 
-  /* @flow */
   function renderClass(node) {
       var classList = genClassForVnode(node);
       if (classList !== '') {
@@ -1915,7 +1901,6 @@
       }
   }
 
-  /* @flow */
   var parseStyleText = cached(function (cssText) {
       var res = {};
       var listDelimiter = /;(?![^(]*\))/g;
@@ -1975,7 +1960,6 @@
       return res;
   }
 
-  /* @flow */
   function genStyle(style) {
       var styleText = '';
       for (var key in style) {
@@ -2012,7 +1996,6 @@
 
   var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-  /* @flow */
   function show(node, dir) {
       if (!dir.value) {
           var style = node.data.style || (node.data.style = {});
@@ -2025,7 +2008,6 @@
       }
   }
 
-  /* @flow */
   // this is only applied for <select v-model> because it is the only edge case
   // that must be done at runtime instead of compile time.
   function model$2(node, dir) {
@@ -2068,7 +2050,6 @@
       model: model$2,
   };
 
-  /* @flow */
   var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
@@ -2082,7 +2063,6 @@
       'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
       'title,tr,track');
 
-  /* @flow */
   var MAX_STACK_DEPTH = 800;
   var noop = function (_) { return _; };
   var defer = typeof process !== 'undefined' && process.nextTick
@@ -2128,7 +2108,6 @@
       return cachedWrite;
   }
 
-  /* @flow */
   var RenderContext = /** @class */ (function () {
       function RenderContext(options) {
           this.userContext = options.userContext;
@@ -2226,7 +2205,6 @@
       }
   }
 
-  /* @flow */
   var validDivisionCharRE = /[\w).+\-_$\]]/;
   function parseFilters(exp) {
       var inSingle = false;
@@ -2350,7 +2328,6 @@
       }
   }
 
-  /* @flow */
   var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
   var buildRegex = cached(function (delimiters) {
@@ -2391,7 +2368,6 @@
       };
   }
 
-  /* @flow */
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
       console.error("[Vue compiler]: " + msg);
@@ -2558,7 +2534,6 @@
       return item;
   }
 
-  /* @flow */
   function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
@@ -2595,7 +2570,6 @@
       genData: genData$2,
   };
 
-  /* @flow */
   function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
@@ -2920,7 +2894,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Cross-platform code generation for component v-model
    */
@@ -3046,7 +3019,6 @@
       }
   }
 
-  /* @flow */
   var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
@@ -3845,7 +3817,15 @@
       }
   }
 
-  /* @flow */
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
   function preTransformNode(el, options) {
       if (el.tag === 'input') {
           var map = el.attrsMap;
@@ -3913,7 +3893,6 @@
 
   var modules = [klass, style, model$1];
 
-  /* @flow */
   var warn;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
@@ -4029,14 +4008,12 @@
       }
   }
 
-  /* @flow */
   function text(el, dir) {
       if (dir.value) {
           addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
-  /* @flow */
   function html(el, dir) {
       if (dir.value) {
           addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -4049,7 +4026,6 @@
       html: html,
   };
 
-  /* @flow */
   var baseOptions = {
       expectHTML: true,
       modules: modules,
@@ -4064,7 +4040,6 @@
       staticKeys: genStaticKeys(modules),
   };
 
-  /* @flow */
   var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -4216,7 +4191,6 @@
           ")");
   }
 
-  /* @flow */
   function on(el, dir) {
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
@@ -4224,21 +4198,18 @@
       el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
-  /* @flow */
   function bind(el, dir) {
       el.wrapData = function (code) {
           return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
-  /* @flow */
   var baseDirectives = {
       on: on,
       bind: bind,
       cloak: noop$1,
   };
 
-  /* @flow */
   var CodegenState = /** @class */ (function () {
       function CodegenState(options) {
           this.options = options;
@@ -4719,7 +4690,6 @@
       return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  /* @flow */
   var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
   // let the model AST transform translate v-model into appropriate
   // props bindings
@@ -4807,7 +4777,15 @@
       }
   }
 
-  /* @flow */
+  /**
+   * In SSR, the vdom tree is generated only once and never patched, so
+   * we can optimize most element / trees into plain string render functions.
+   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+   *
+   * The criteria for SSR optimizability is quite a bit looser than static tree
+   * detection (which is designed for client re-render). In SSR we bail only for
+   * components/slots/custom directives.
+   */
   // optimizability constants
   var optimizability = {
       FALSE: 0,
@@ -4925,7 +4903,7 @@
           node.directives.some(function (d) { return d.name === 'model'; }));
   }
 
-  /* @flow */
+  // The SSR codegen is essentially extending the default codegen to handle
   // segment types
   var RAW = 0;
   var INTERPOLATION = 1;
@@ -5120,7 +5098,6 @@
       return mergedSegments.join('+');
   }
 
-  /* @flow */
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
   var prohibitedKeywordRE = new RegExp('\\b' +
@@ -5229,7 +5206,6 @@
       }
   }
 
-  /* @flow */
   var range = 2;
   function generateCodeFrame(source, start, end) {
       if (start === void 0) { start = 0; }
@@ -5280,7 +5256,6 @@
       return result;
   }
 
-  /* @flow */
   function createFunction(code, errors) {
       try {
           return new Function(code);
@@ -5371,7 +5346,6 @@
       };
   }
 
-  /* @flow */
   function createCompilerCreator(baseCompile) {
       return function createCompiler(baseOptions) {
           function compile(template, options) {
@@ -5429,7 +5403,6 @@
       };
   }
 
-  /* @flow */
   var createCompiler = createCompilerCreator(function baseCompile(template, options) {
       var ast = parse(template.trim(), options);
       optimize(ast, options);
@@ -5441,10 +5414,8 @@
       };
   });
 
-  /* @flow */
   var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
-  /* @flow */
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
@@ -5531,7 +5502,6 @@
       return res;
   }
 
-  /* @flow */
   var ssrHelpers = {
       _ssrEscape: escape,
       _ssrNode: renderStringNode$1,
@@ -5664,7 +5634,6 @@
       }
   }
 
-  /* @flow */
   var seenObjects = new _Set();
   /**
    * Recursively traverse an object to evoke all converted
@@ -5777,7 +5746,6 @@
       }
   }
 
-  /* @flow */
   function extractPropsFromVNodeData(data, Ctor, tag) {
       // we are only extracting raw values here.
       // validation and default values are handled in the child
@@ -5830,7 +5798,6 @@
       return false;
   }
 
-  /* @flow */
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
@@ -6023,7 +5990,6 @@
       return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /* @flow */
   function isKeyNotMatch(expect, actual) {
       if (Array.isArray(expect)) {
           return expect.indexOf(actual) === -1;
@@ -6050,7 +6016,6 @@
       }
   }
 
-  /* @flow */
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
@@ -6138,7 +6103,6 @@
       node.isOnce = isOnce;
   }
 
-  /* @flow */
   function bindObjectListeners(data, value) {
       if (value) {
           if (!isPlainObject(value)) {
@@ -6181,7 +6145,7 @@
       return res;
   }
 
-  /* @flow */
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
       for (var i = 0; i < values.length; i += 2) {
           var key = values[i];
@@ -6203,7 +6167,6 @@
       return typeof value === 'string' ? symbol + value : value;
   }
 
-  /* @flow */
   function installRenderHelpers(target) {
       target._o = markOnce;
       target._n = toNumber;
@@ -6224,7 +6187,6 @@
       target._p = prependModifier;
   }
 
-  /* @flow */
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
@@ -6270,7 +6232,6 @@
       return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
-  /* @flow */
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
       var res;
       var hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -6344,7 +6305,6 @@
       return function () { return slots[key]; };
   }
 
-  /* @flow */
   function createAsyncPlaceholder(factory, data, context, children, tag) {
       var node = createEmptyVNode();
       node.asyncFactory = factory;
@@ -6363,7 +6323,6 @@
       }
   }
 
-  /* @flow */
   var target;
   function add(event, fn) {
       target.$on(event, fn);
@@ -6386,7 +6345,6 @@
       target = undefined;
   }
 
-  /* @flow */
   var activeInstance = null;
   function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
       // determine whether component has slot children
@@ -6502,7 +6460,6 @@
       popTarget();
   }
 
-  /* @flow */
   // Async edge case fix requires storing an event listener's attach timestamp.
   var getNow = Date.now;
   // Determine what event timestamp the browser is using. Annoyingly, the
@@ -6533,7 +6490,6 @@
       vm._inactive = false;
   }
 
-  /* @flow */
   function resolveInject(inject, vm) {
       if (inject) {
           // inject is :any because flow is not smart enough to figure out cached
@@ -6572,7 +6528,6 @@
       }
   }
 
-  /* @flow */
   function resolveConstructorOptions(Ctor) {
       var options = Ctor.options;
       if (Ctor.super) {
@@ -6610,7 +6565,6 @@
       return modified;
   }
 
-  /* @flow */
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
       var _this = this;
       var options = Ctor.options;
@@ -6725,7 +6679,6 @@
       }
   }
 
-  /* @flow */
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
       init: function (vnode, hydrating) {
@@ -6919,7 +6872,6 @@
       }
   }
 
-  /* @flow */
   var warned = Object.create(null);
   var warnOnce = function (msg) {
       if (!warned[msg]) {
@@ -7305,7 +7257,6 @@
       };
   }
 
-  /* @flow */
   function createBasicRenderer(_a) {
       var _b = _a === void 0 ? {} : _a, _c = _b.modules, modules = _c === void 0 ? [] : _c, _d = _b.directives, directives = _d === void 0 ? {} : _d, _e = _b.isUnaryTag, isUnaryTag = _e === void 0 ? function () { return false; } : _e, cache = _b.cache;
       var render = createRenderFunction(modules, directives, isUnaryTag, cache);
@@ -7331,7 +7282,6 @@
       };
   }
 
-  /* @flow */
   var entryServerBasicRenderer = createBasicRenderer({
       // @ts-expect-error
       modules: modules$1,
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index bac0f6701c5..e95d4e2d28f 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -1757,6 +1757,7 @@ function logError(err, vm, info) {
     }
 }
 
+/* globals MutationObserver */
 var callbacks = [];
 function flushCallbacks() {
     var copies = callbacks.slice(0);
@@ -2138,6 +2139,13 @@ function createWriteFunction(write, onError) {
     return cachedWrite;
 }
 
+/**
+ * Original RenderStream implementation by Sasha Aickin (@aickin)
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Modified by Evan You (@yyx990803)
+ */
 var RenderStream = /** @class */ (function (_super) {
     __extends(RenderStream, _super);
     function RenderStream(render) {
@@ -3921,6 +3929,15 @@ function checkForAliasModel(el, value) {
     }
 }
 
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
         var map = el.attrsMap;
@@ -4872,6 +4889,15 @@ function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExp
     }
 }
 
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
 // optimizability constants
 var optimizability = {
     FALSE: 0,
@@ -4989,6 +5015,7 @@ function isSelectWithModel(node) {
         node.directives.some(function (d) { return d.name === 'model'; }));
 }
 
+// The SSR codegen is essentially extending the default codegen to handle
 // segment types
 var RAW = 0;
 var INTERPOLATION = 1;
@@ -6230,6 +6257,7 @@ hasDynamicKeys, contentHashKey) {
     return res;
 }
 
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
     for (var i = 0; i < values.length; i += 2) {
         var key = values[i];
@@ -7445,6 +7473,11 @@ function parseTemplate(template, contentPlaceholder) {
     };
 }
 
+/**
+ * Creates a mapper that maps components used during a server-side render
+ * to async chunk files in the client-side build, so that we can inline them
+ * directly in the rendered HTML to avoid waterfall requests.
+ */
 function createMapper(clientManifest) {
     var map = createMap(clientManifest);
     // map server-side moduleIds to client-side files
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 75eaae0f649..0433736910b 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -1,6 +1,5 @@
 'use strict';
 
-/* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
 
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index a007dec2db2..992fcfa0d92 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -1,6 +1,5 @@
 'use strict';
 
-/* @flow */
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 
 var _a = require('chalk'), red = _a.red, yellow = _a.yellow;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index a7bb71893a0..48749570b3d 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -50,7 +50,7 @@
     return i
   }
 
-    var emptyObject = Object.freeze({});
+  var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
   function isUndef(v) {
@@ -193,7 +193,7 @@
           .join(',');
   }
 
-    var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
@@ -206,7 +206,7 @@
       'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
       'title,tr,track');
 
-    /**
+  /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
@@ -511,7 +511,7 @@
       }
   }
 
-    var splitRE = /\r?\n/g;
+  var splitRE = /\r?\n/g;
   var replaceRE = /./g;
   var isSpecialTag = makeMap('script,style,template', true);
   /**
@@ -627,7 +627,7 @@
       return sfc;
   }
 
-    // can we use __proto__?
+  // can we use __proto__?
   var hasProto = '__proto__' in {};
   // Browser environment sniffing
   var inBrowser = typeof window !== 'undefined';
@@ -725,7 +725,7 @@
       'errorCaptured',
       'serverPrefetch' ];
 
-    var config = {
+  var config = {
       /**
        * Option merge strategies (used in core/util/options)
        */
@@ -803,7 +803,7 @@
       _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-    var warn$2 = noop;
+  var warn$2 = noop;
   var tip = noop;
   var generateComponentTrace; // work around flow check
   var formatComponentName;
@@ -1208,7 +1208,7 @@
       }
   }
 
-    /**
+  /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
@@ -1417,7 +1417,8 @@
       }
   }
 
-    var callbacks = [];
+  /* globals MutationObserver */
+  var callbacks = [];
   function flushCallbacks() {
       var copies = callbacks.slice(0);
       callbacks.length = 0;
@@ -1451,7 +1452,7 @@
   else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
   else ;
 
-    // these are reserved for web because they are directly compiled away
+  // these are reserved for web because they are directly compiled away
   // during template compilation
   makeMap('style,class');
   // attributes that should be using props for binding
@@ -1471,7 +1472,7 @@
       'required,reversed,scoped,seamless,selected,sortable,' +
       'truespeed,typemustmatch,visible');
 
-    var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
       'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
       'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -1503,7 +1504,7 @@
   }
   makeMap('text,number,password,search,email,tel,url');
 
-    var validDivisionCharRE = /[\w).+\-_$\]]/;
+  var validDivisionCharRE = /[\w).+\-_$\]]/;
   function parseFilters(exp) {
       var inSingle = false;
       var inDouble = false;
@@ -1626,7 +1627,7 @@
       }
   }
 
-    var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
   var buildRegex = cached(function (delimiters) {
       var open = delimiters[0].replace(regexEscapeRE, '\\$&');
@@ -1666,7 +1667,7 @@
       };
   }
 
-    /* eslint-disable no-unused-vars */
+  /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
       console.error("[Vue compiler]: " + msg);
   }
@@ -1832,7 +1833,7 @@
       return item;
   }
 
-    function transformNode$1(el, options) {
+  function transformNode$1(el, options) {
       var warn = options.warn || baseWarn;
       var staticClass = getAndRemoveAttr(el, 'class');
       if (staticClass) {
@@ -1868,7 +1869,7 @@
       genData: genData$2,
   };
 
-    var parseStyleText = cached(function (cssText) {
+  var parseStyleText = cached(function (cssText) {
       var res = {};
       var listDelimiter = /;(?![^(]*\))/g;
       var propertyDelimiter = /:(.+)/;
@@ -1881,7 +1882,7 @@
       return res;
   });
 
-    function transformNode(el, options) {
+  function transformNode(el, options) {
       var warn = options.warn || baseWarn;
       var staticStyle = getAndRemoveAttr(el, 'style');
       if (staticStyle) {
@@ -1918,7 +1919,7 @@
       genData: genData$1,
   };
 
-    /**
+  /**
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
@@ -2043,7 +2044,7 @@
       }
   }
 
-    var he = require('he');
+  var he = require('he');
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -2841,7 +2842,16 @@
       }
   }
 
-    function preTransformNode(el, options) {
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
+  function preTransformNode(el, options) {
       if (el.tag === 'input') {
           var map = el.attrsMap;
           if (!map['v-model']) {
@@ -2908,7 +2918,7 @@
 
   var modules = [klass, style, model$1];
 
-    var warn;
+  var warn;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
   var RANGE_TOKEN = '__r';
@@ -3023,13 +3033,13 @@
       }
   }
 
-    function text(el, dir) {
+  function text(el, dir) {
       if (dir.value) {
           addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
       }
   }
 
-    function html(el, dir) {
+  function html(el, dir) {
       if (dir.value) {
           addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
       }
@@ -3041,7 +3051,7 @@
       html: html,
   };
 
-    var baseOptions = {
+  var baseOptions = {
       expectHTML: true,
       modules: modules,
       directives: directives,
@@ -3055,7 +3065,7 @@
       staticKeys: genStaticKeys$1(modules),
   };
 
-    var isStaticKey;
+  var isStaticKey;
   var isPlatformReservedTag$1;
   var genStaticKeysCached = cached(genStaticKeys);
   /**
@@ -3172,7 +3182,7 @@
       return false;
   }
 
-    var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
   var fnInvokeRE = /\([^)]*?\);*$/;
   var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
   // KeyboardEvent.keyCode aliases
@@ -3323,26 +3333,26 @@
           ")");
   }
 
-    function on(el, dir) {
+  function on(el, dir) {
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
       }
       el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
   }
 
-    function bind(el, dir) {
+  function bind(el, dir) {
       el.wrapData = function (code) {
           return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
       };
   }
 
-    var baseDirectives = {
+  var baseDirectives = {
       on: on,
       bind: bind,
       cloak: noop,
   };
 
-    var CodegenState = /** @class */ (function () {
+  var CodegenState = /** @class */ (function () {
       function CodegenState(options) {
           this.options = options;
           this.warn = options.warn || baseWarn;
@@ -3822,7 +3832,7 @@
       return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-    // these keywords should not appear inside expressions, but operators like
+  // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
   var prohibitedKeywordRE = new RegExp('\\b' +
       ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
@@ -3930,7 +3940,7 @@
       }
   }
 
-    var range = 2;
+  var range = 2;
   function generateCodeFrame(source, start, end) {
       if (start === void 0) { start = 0; }
       if (end === void 0) { end = source.length; }
@@ -3980,7 +3990,7 @@
       return result;
   }
 
-    function createFunction(code, errors) {
+  function createFunction(code, errors) {
       try {
           return new Function(code);
       }
@@ -4070,7 +4080,7 @@
       };
   }
 
-    function createCompilerCreator(baseCompile) {
+  function createCompilerCreator(baseCompile) {
       return function createCompiler(baseOptions) {
           function compile(template, options) {
               var finalOptions = Object.create(baseOptions);
@@ -4127,7 +4137,7 @@
       };
   }
 
-    // `createCompilerCreator` allows creating compilers that use alternative
+  // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
   var createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
@@ -4143,9 +4153,9 @@
       };
   });
 
-    var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
+  var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
 
-    var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+  var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
       'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
       'checked,cite,class,code,codebase,color,cols,colspan,content,' +
       'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
@@ -4181,7 +4191,7 @@
       return ESC[a] || a;
   }
 
-    var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+  var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
   // let the model AST transform translate v-model into appropriate
   // props bindings
   function applyModelTransform(el, state) {
@@ -4268,7 +4278,16 @@
       }
   }
 
-    // optimizability constants
+  /**
+   * In SSR, the vdom tree is generated only once and never patched, so
+   * we can optimize most element / trees into plain string render functions.
+   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+   *
+   * The criteria for SSR optimizability is quite a bit looser than static tree
+   * detection (which is designed for client re-render). In SSR we bail only for
+   * components/slots/custom directives.
+   */
+  // optimizability constants
   var optimizability = {
       FALSE: 0,
       FULL: 1,
@@ -4385,7 +4404,8 @@
           node.directives.some(function (d) { return d.name === 'model'; }));
   }
 
-    // segment types
+  // The SSR codegen is essentially extending the default codegen to handle
+  // segment types
   var RAW = 0;
   var INTERPOLATION = 1;
   var EXPRESSION = 2;
@@ -4579,7 +4599,7 @@
       return mergedSegments.join('+');
   }
 
-    var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
       var ast = parse(template.trim(), options);
       optimize(ast, options);
       var code = generate(ast, options);
@@ -4590,7 +4610,7 @@
       };
   });
 
-    var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
+  var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
 
   exports.compile = compile$1;
   exports.compileToFunctions = compileToFunctions$1;
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index 918d9f87013..5acbcd7a97f 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -8,7 +8,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
 
-/* @flow */
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -152,7 +151,6 @@ function genStaticKeys$1(modules) {
         .join(',');
 }
 
-/* @flow */
 var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
@@ -166,7 +164,6 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/* @flow */
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
@@ -474,7 +471,6 @@ function parseHTML(html, options) {
     }
 }
 
-/* @flow */
 var splitRE = /\r?\n/g;
 var replaceRE = /./g;
 var isSpecialTag = makeMap('script,style,template', true);
@@ -591,7 +587,6 @@ function parseComponent(content, options) {
     return sfc;
 }
 
-/* @flow */
 // can we use __proto__?
 var hasProto = '__proto__' in {};
 // Browser environment sniffing
@@ -690,7 +685,6 @@ var LIFECYCLE_HOOKS = [
     'errorCaptured',
     'serverPrefetch' ];
 
-/* @flow */
 var config = {
     /**
      * Option merge strategies (used in core/util/options)
@@ -769,7 +763,6 @@ var config = {
     _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/* @flow */
 var warn$2 = noop;
 var tip = noop;
 var generateComponentTrace; // work around flow check
@@ -1183,7 +1176,6 @@ function dependArray(value) {
     }
 }
 
-/* @flow */
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
@@ -1394,7 +1386,7 @@ function assertObjectType(name, value, vm) {
     }
 }
 
-/* @flow */
+/* globals MutationObserver */
 var callbacks = [];
 function flushCallbacks() {
     var copies = callbacks.slice(0);
@@ -1429,7 +1421,6 @@ else if (!isIE &&
 else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 else ;
 
-/* @flow */
 // these are reserved for web because they are directly compiled away
 // during template compilation
 makeMap('style,class');
@@ -1450,7 +1441,6 @@ var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,co
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
 
-/* @flow */
 var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
@@ -1483,7 +1473,6 @@ function getTagNamespace(tag) {
 }
 makeMap('text,number,password,search,email,tel,url');
 
-/* @flow */
 var validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
     var inSingle = false;
@@ -1607,7 +1596,6 @@ function wrapFilter(exp, filter) {
     }
 }
 
-/* @flow */
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -1648,7 +1636,6 @@ function parseText(text, delimiters) {
     };
 }
 
-/* @flow */
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
     console.error("[Vue compiler]: " + msg);
@@ -1816,7 +1803,6 @@ function rangeSetItem(item, range) {
     return item;
 }
 
-/* @flow */
 function transformNode$1(el, options) {
     var warn = options.warn || baseWarn;
     var staticClass = getAndRemoveAttr(el, 'class');
@@ -1853,7 +1839,6 @@ var klass = {
     genData: genData$2,
 };
 
-/* @flow */
 var parseStyleText = cached(function (cssText) {
     var res = {};
     var listDelimiter = /;(?![^(]*\))/g;
@@ -1867,7 +1852,6 @@ var parseStyleText = cached(function (cssText) {
     return res;
 });
 
-/* @flow */
 function transformNode(el, options) {
     var warn = options.warn || baseWarn;
     var staticStyle = getAndRemoveAttr(el, 'style');
@@ -1905,7 +1889,6 @@ var style = {
     genData: genData$1,
 };
 
-/* @flow */
 /**
  * Cross-platform code generation for component v-model
  */
@@ -2031,7 +2014,6 @@ function parseString(chr) {
     }
 }
 
-/* @flow */
 var he = require('he');
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
@@ -2835,7 +2817,15 @@ function checkForAliasModel(el, value) {
     }
 }
 
-/* @flow */
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
         var map = el.attrsMap;
@@ -2903,7 +2893,6 @@ var model$1 = {
 
 var modules = [klass, style, model$1];
 
-/* @flow */
 var warn;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
@@ -3019,14 +3008,12 @@ function genDefaultModel(el, value, modifiers) {
     }
 }
 
-/* @flow */
 function text(el, dir) {
     if (dir.value) {
         addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
     }
 }
 
-/* @flow */
 function html(el, dir) {
     if (dir.value) {
         addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
@@ -3039,7 +3026,6 @@ var directives = {
     html: html,
 };
 
-/* @flow */
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -3054,7 +3040,6 @@ var baseOptions = {
     staticKeys: genStaticKeys$1(modules),
 };
 
-/* @flow */
 var isStaticKey;
 var isPlatformReservedTag$1;
 var genStaticKeysCached = cached(genStaticKeys);
@@ -3172,7 +3157,6 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-/* @flow */
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
@@ -3324,7 +3308,6 @@ function genFilterCode(key) {
         ")");
 }
 
-/* @flow */
 function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
@@ -3332,21 +3315,18 @@ function on(el, dir) {
     el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
-/* @flow */
 function bind(el, dir) {
     el.wrapData = function (code) {
         return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
     };
 }
 
-/* @flow */
 var baseDirectives = {
     on: on,
     bind: bind,
     cloak: noop,
 };
 
-/* @flow */
 var CodegenState = /** @class */ (function () {
     function CodegenState(options) {
         this.options = options;
@@ -3830,7 +3810,6 @@ function transformSpecialNewlines(text) {
     return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/* @flow */
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
 var prohibitedKeywordRE = new RegExp('\\b' +
@@ -3939,7 +3918,6 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
     }
 }
 
-/* @flow */
 var range = 2;
 function generateCodeFrame(source, start, end) {
     if (start === void 0) { start = 0; }
@@ -3990,7 +3968,6 @@ function repeat(str, n) {
     return result;
 }
 
-/* @flow */
 function createFunction(code, errors) {
     try {
         return new Function(code);
@@ -4081,7 +4058,6 @@ function createCompileToFunctionFn(compile) {
     };
 }
 
-/* @flow */
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
@@ -4140,7 +4116,6 @@ function createCompilerCreator(baseCompile) {
     };
 }
 
-/* @flow */
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
@@ -4157,10 +4132,8 @@ var createCompiler$1 = createCompilerCreator(function baseCompile(template, opti
     };
 });
 
-/* @flow */
 var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
 
-/* @flow */
 var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
     'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
     'checked,cite,class,code,codebase,color,cols,colspan,content,' +
@@ -4197,7 +4170,6 @@ function escapeChar(a) {
     return ESC[a] || a;
 }
 
-/* @flow */
 var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
 // let the model AST transform translate v-model into appropriate
 // props bindings
@@ -4285,7 +4257,15 @@ function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExp
     }
 }
 
-/* @flow */
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
 // optimizability constants
 var optimizability = {
     FALSE: 0,
@@ -4403,7 +4383,7 @@ function isSelectWithModel(node) {
         node.directives.some(function (d) { return d.name === 'model'; }));
 }
 
-/* @flow */
+// The SSR codegen is essentially extending the default codegen to handle
 // segment types
 var RAW = 0;
 var INTERPOLATION = 1;
@@ -4598,7 +4578,6 @@ function flattenSegments(segments) {
     return mergedSegments.join('+');
 }
 
-/* @flow */
 var createCompiler = createCompilerCreator(function baseCompile(template, options) {
     var ast = parse(template.trim(), options);
     optimize(ast, options);
@@ -4610,7 +4589,6 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-/* @flow */
 var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
 
 exports.compile = compile$1;
diff --git a/yarn.lock b/yarn.lock
index 3fea922dfbf..59c65aaef1b 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,6 +2,13 @@
 # yarn lockfile v1
 
 
+"@babel/code-frame@7.12.11":
+  version "7.12.11"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.11.tgz#f4ad435aa263db935b8f10f2c552d23fb716a63f"
+  integrity sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw==
+  dependencies:
+    "@babel/highlight" "^7.10.4"
+
 "@babel/code-frame@^7.0.0":
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.0.0.tgz#06e2ab19bdb535385559aabb5ba59729482800f8"
@@ -9,24 +16,37 @@
   dependencies:
     "@babel/highlight" "^7.0.0"
 
-"@babel/core@^7.0.0":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.2.2.tgz#07adba6dde27bb5ad8d8672f15fde3e08184a687"
-  integrity sha512-59vB0RWt09cAct5EIe58+NzGP4TFSD3Bz//2/ELy3ZeTeKF6VTD1AXlH8BGGbCX0PuobZBsIzO7IAI9PH67eKw==
+"@babel/code-frame@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.13.tgz#dcfc826beef65e75c50e21d3837d7d95798dd658"
+  integrity sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==
   dependencies:
-    "@babel/code-frame" "^7.0.0"
-    "@babel/generator" "^7.2.2"
-    "@babel/helpers" "^7.2.0"
-    "@babel/parser" "^7.2.2"
-    "@babel/template" "^7.2.2"
-    "@babel/traverse" "^7.2.2"
-    "@babel/types" "^7.2.2"
-    convert-source-map "^1.1.0"
+    "@babel/highlight" "^7.12.13"
+
+"@babel/compat-data@^7.13.0", "@babel/compat-data@^7.13.12", "@babel/compat-data@^7.13.8":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.13.12.tgz#a8a5ccac19c200f9dd49624cac6e19d7be1236a1"
+  integrity sha512-3eJJ841uKxeV8dcN/2yGEUy+RfgQspPEgQat85umsE1rotuquQ2AbIub4S6j7c50a2d+4myc+zSlnXeIHrOnhQ==
+
+"@babel/core@^7.13.14":
+  version "7.13.14"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.13.14.tgz#8e46ebbaca460a63497c797e574038ab04ae6d06"
+  integrity sha512-wZso/vyF4ki0l0znlgM4inxbdrUvCb+cVz8grxDq+6C9k6qbqoIJteQOKicaKjCipU3ISV+XedCqpL2RJJVehA==
+  dependencies:
+    "@babel/code-frame" "^7.12.13"
+    "@babel/generator" "^7.13.9"
+    "@babel/helper-compilation-targets" "^7.13.13"
+    "@babel/helper-module-transforms" "^7.13.14"
+    "@babel/helpers" "^7.13.10"
+    "@babel/parser" "^7.13.13"
+    "@babel/template" "^7.12.13"
+    "@babel/traverse" "^7.13.13"
+    "@babel/types" "^7.13.14"
+    convert-source-map "^1.7.0"
     debug "^4.1.0"
-    json5 "^2.1.0"
-    lodash "^4.17.10"
-    resolve "^1.3.2"
-    semver "^5.4.1"
+    gensync "^1.0.0-beta.2"
+    json5 "^2.1.2"
+    semver "^6.3.0"
     source-map "^0.5.0"
 
 "@babel/generator@^7.0.0", "@babel/generator@^7.2.2":
@@ -40,57 +60,79 @@
     source-map "^0.5.0"
     trim-right "^1.0.1"
 
-"@babel/helper-annotate-as-pure@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.0.0.tgz#323d39dd0b50e10c7c06ca7d7638e6864d8c5c32"
-  integrity sha512-3UYcJUj9kvSLbLbUIfQTqzcy5VX7GRZ/CCDrnOaZorFFM01aXp1+GJwuFGV4NDDoAS+mOUyHcO6UD/RfqOks3Q==
+"@babel/generator@^7.13.9":
+  version "7.13.9"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.13.9.tgz#3a7aa96f9efb8e2be42d38d80e2ceb4c64d8de39"
+  integrity sha512-mHOOmY0Axl/JCTkxTU6Lf5sWOg/v8nUa+Xkt4zMTftX0wqmb6Sh7J8gvcehBw7q0AhrhAR+FDacKjCZ2X8K+Sw==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.13.0"
+    jsesc "^2.5.1"
+    source-map "^0.5.0"
 
-"@babel/helper-builder-binary-assignment-operator-visitor@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.1.0.tgz#6b69628dfe4087798e0c4ed98e3d4a6b2fbd2f5f"
-  integrity sha512-qNSR4jrmJ8M1VMM9tibvyRAHXQs2PmaksQF7c1CGJNipfe3D8p+wgNwgso/P2A2r2mdgBWAXljNWR0QRZAMW8w==
+"@babel/helper-annotate-as-pure@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz#0f58e86dfc4bb3b1fcd7db806570e177d439b6ab"
+  integrity sha512-7YXfX5wQ5aYM/BOlbSccHDbuXXFPxeoUmfWtz8le2yTkTZc+BxsiEnENFoi2SlmA8ewDkG2LgIMIVzzn2h8kfw==
   dependencies:
-    "@babel/helper-explode-assignable-expression" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.12.13"
 
-"@babel/helper-call-delegate@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-call-delegate/-/helper-call-delegate-7.1.0.tgz#6a957f105f37755e8645343d3038a22e1449cc4a"
-  integrity sha512-YEtYZrw3GUK6emQHKthltKNZwszBcHK58Ygcis+gVUrF4/FmTVr5CCqQNSfmvg2y+YDEANyYoaLz/SHsnusCwQ==
+"@babel/helper-builder-binary-assignment-operator-visitor@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.12.13.tgz#6bc20361c88b0a74d05137a65cac8d3cbf6f61fc"
+  integrity sha512-CZOv9tGphhDRlVjVkAgm8Nhklm9RzSmWpX2my+t7Ua/KT616pEzXsQCjinzvkRvHWJ9itO4f296efroX23XCMA==
   dependencies:
-    "@babel/helper-hoist-variables" "^7.0.0"
-    "@babel/traverse" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/helper-explode-assignable-expression" "^7.12.13"
+    "@babel/types" "^7.12.13"
 
-"@babel/helper-create-class-features-plugin@^7.2.3":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.2.3.tgz#f6e719abb90cb7f4a69591e35fd5eb89047c4a7c"
-  integrity sha512-xO/3Gn+2C7/eOUeb0VRnSP1+yvWHNxlpAot1eMhtoKDCN7POsyQP5excuT5UsV5daHxMWBeIIOeI5cmB8vMRgQ==
+"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.10", "@babel/helper-compilation-targets@^7.13.13", "@babel/helper-compilation-targets@^7.13.8":
+  version "7.13.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.13.tgz#2b2972a0926474853f41e4adbc69338f520600e5"
+  integrity sha512-q1kcdHNZehBwD9jYPh3WyXcsFERi39X4I59I3NadciWtNDyZ6x+GboOxncFK0kXlKIv6BJm5acncehXWUjWQMQ==
   dependencies:
-    "@babel/helper-function-name" "^7.1.0"
-    "@babel/helper-member-expression-to-functions" "^7.0.0"
-    "@babel/helper-optimise-call-expression" "^7.0.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-replace-supers" "^7.2.3"
+    "@babel/compat-data" "^7.13.12"
+    "@babel/helper-validator-option" "^7.12.17"
+    browserslist "^4.14.5"
+    semver "^6.3.0"
 
-"@babel/helper-define-map@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-define-map/-/helper-define-map-7.1.0.tgz#3b74caec329b3c80c116290887c0dd9ae468c20c"
-  integrity sha512-yPPcW8dc3gZLN+U1mhYV91QU3n5uTbx7DUdf8NnPbjS0RMwBuHi9Xt2MUgppmNz7CJxTBWsGczTiEp1CSOTPRg==
+"@babel/helper-create-class-features-plugin@^7.13.0":
+  version "7.13.11"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.11.tgz#30d30a005bca2c953f5653fc25091a492177f4f6"
+  integrity sha512-ays0I7XYq9xbjCSvT+EvysLgfc3tOkwCULHjrnscGT3A9qD4sk3wXnJ3of0MAWsWGjdinFvajHU2smYuqXKMrw==
   dependencies:
-    "@babel/helper-function-name" "^7.1.0"
-    "@babel/types" "^7.0.0"
-    lodash "^4.17.10"
+    "@babel/helper-function-name" "^7.12.13"
+    "@babel/helper-member-expression-to-functions" "^7.13.0"
+    "@babel/helper-optimise-call-expression" "^7.12.13"
+    "@babel/helper-replace-supers" "^7.13.0"
+    "@babel/helper-split-export-declaration" "^7.12.13"
 
-"@babel/helper-explode-assignable-expression@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.1.0.tgz#537fa13f6f1674df745b0c00ec8fe4e99681c8f6"
-  integrity sha512-NRQpfHrJ1msCHtKjbzs9YcMmJZOg6mQMmGRB+hbamEdG5PNpaSm95275VD92DvJKuyl0s2sFiDmMZ+EnnvufqA==
+"@babel/helper-create-regexp-features-plugin@^7.12.13":
+  version "7.12.17"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.12.17.tgz#a2ac87e9e319269ac655b8d4415e94d38d663cb7"
+  integrity sha512-p2VGmBu9oefLZ2nQpgnEnG0ZlRPvL8gAGvPUMQwUdaE8k49rOMuZpOwdQoy5qJf6K8jL3bcAMhVUlHAjIgJHUg==
   dependencies:
-    "@babel/traverse" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/helper-annotate-as-pure" "^7.12.13"
+    regexpu-core "^4.7.1"
+
+"@babel/helper-define-polyfill-provider@^0.1.5":
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.1.5.tgz#3c2f91b7971b9fc11fe779c945c014065dea340e"
+  integrity sha512-nXuzCSwlJ/WKr8qxzW816gwyT6VZgiJG17zR40fou70yfAcqjoNyTLl/DQ+FExw5Hx5KNqshmN8Ldl/r2N7cTg==
+  dependencies:
+    "@babel/helper-compilation-targets" "^7.13.0"
+    "@babel/helper-module-imports" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/traverse" "^7.13.0"
+    debug "^4.1.1"
+    lodash.debounce "^4.0.8"
+    resolve "^1.14.2"
+    semver "^6.1.2"
+
+"@babel/helper-explode-assignable-expression@^7.12.13":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.13.0.tgz#17b5c59ff473d9f956f40ef570cf3a76ca12657f"
+  integrity sha512-qS0peLTDP8kOisG1blKbaoBg/o9OSa1qoumMjTK5pM+KDTtpxpsiubnCGP34vK8BXGcb2M9eigwgvoJryrzwWA==
+  dependencies:
+    "@babel/types" "^7.13.0"
 
 "@babel/helper-function-name@^7.1.0":
   version "7.1.0"
@@ -101,6 +143,15 @@
     "@babel/template" "^7.1.0"
     "@babel/types" "^7.0.0"
 
+"@babel/helper-function-name@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz#93ad656db3c3c2232559fd7b2c3dbdcbe0eb377a"
+  integrity sha512-TZvmPn0UOqmvi5G4vvw0qZTpVptGkB1GL61R6lKvrSdIxGm5Pky7Q3fpKiIkQCAtRCBUwB0PaThlx9vebCDSwA==
+  dependencies:
+    "@babel/helper-get-function-arity" "^7.12.13"
+    "@babel/template" "^7.12.13"
+    "@babel/types" "^7.12.13"
+
 "@babel/helper-get-function-arity@^7.0.0":
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0.tgz#83572d4320e2a4657263734113c42868b64e49c3"
@@ -108,93 +159,98 @@
   dependencies:
     "@babel/types" "^7.0.0"
 
-"@babel/helper-hoist-variables@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.0.0.tgz#46adc4c5e758645ae7a45deb92bab0918c23bb88"
-  integrity sha512-Ggv5sldXUeSKsuzLkddtyhyHe2YantsxWKNi7A+7LeD12ExRDWTRk29JCXpaHPAbMaIPZSil7n+lq78WY2VY7w==
+"@babel/helper-get-function-arity@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz#bc63451d403a3b3082b97e1d8b3fe5bd4091e583"
+  integrity sha512-DjEVzQNz5LICkzN0REdpD5prGoidvbdYk1BVgRUOINaWJP2t6avB27X1guXK1kXNrX0WMfsrm1A/ZBthYuIMQg==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.12.13"
 
-"@babel/helper-member-expression-to-functions@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.0.0.tgz#8cd14b0a0df7ff00f009e7d7a436945f47c7a16f"
-  integrity sha512-avo+lm/QmZlv27Zsi0xEor2fKcqWG56D5ae9dzklpIaY7cQMK5N8VSpaNVPPagiqmy7LrEjK1IWdGMOqPu5csg==
+"@babel/helper-hoist-variables@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.0.tgz#5d5882e855b5c5eda91e0cadc26c6e7a2c8593d8"
+  integrity sha512-0kBzvXiIKfsCA0y6cFEIJf4OdzfpRuNk4+YTeHZpGGc666SATFKTz6sRncwFnQk7/ugJ4dSrCj6iJuvW4Qwr2g==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/traverse" "^7.13.0"
+    "@babel/types" "^7.13.0"
 
-"@babel/helper-module-imports@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.0.0.tgz#96081b7111e486da4d2cd971ad1a4fe216cc2e3d"
-  integrity sha512-aP/hlLq01DWNEiDg4Jn23i+CXxW/owM4WpDLFUbpjxe4NS3BhLVZQ5i7E0ZrxuQ/vwekIeciyamgB1UIYxxM6A==
+"@babel/helper-member-expression-to-functions@^7.13.0", "@babel/helper-member-expression-to-functions@^7.13.12":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.12.tgz#dfe368f26d426a07299d8d6513821768216e6d72"
+  integrity sha512-48ql1CLL59aKbU94Y88Xgb2VFy7a95ykGRbJJaaVv+LX5U8wFpLfiGXJJGUozsmA1oEh/o5Bp60Voq7ACyA/Sw==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.13.12"
 
-"@babel/helper-module-imports@^7.10.4":
+"@babel/helper-module-imports@^7.10.4", "@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.13.12":
   version "7.13.12"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz#c6a369a6f3621cb25da014078684da9196b61977"
   integrity sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==
   dependencies:
     "@babel/types" "^7.13.12"
 
-"@babel/helper-module-transforms@^7.1.0":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.2.2.tgz#ab2f8e8d231409f8370c883d20c335190284b963"
-  integrity sha512-YRD7I6Wsv+IHuTPkAmAS4HhY0dkPobgLftHp0cRGZSdrRvmZY8rFvae/GVu3bD00qscuvK3WPHB3YdNpBXUqrA==
+"@babel/helper-module-transforms@^7.13.0", "@babel/helper-module-transforms@^7.13.14":
+  version "7.13.14"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.13.14.tgz#e600652ba48ccb1641775413cb32cfa4e8b495ef"
+  integrity sha512-QuU/OJ0iAOSIatyVZmfqB0lbkVP0kDRiKj34xy+QNsnVZi/PA6BoSoreeqnxxa9EHFAIL0R9XOaAR/G9WlIy5g==
   dependencies:
-    "@babel/helper-module-imports" "^7.0.0"
-    "@babel/helper-simple-access" "^7.1.0"
-    "@babel/helper-split-export-declaration" "^7.0.0"
-    "@babel/template" "^7.2.2"
-    "@babel/types" "^7.2.2"
-    lodash "^4.17.10"
+    "@babel/helper-module-imports" "^7.13.12"
+    "@babel/helper-replace-supers" "^7.13.12"
+    "@babel/helper-simple-access" "^7.13.12"
+    "@babel/helper-split-export-declaration" "^7.12.13"
+    "@babel/helper-validator-identifier" "^7.12.11"
+    "@babel/template" "^7.12.13"
+    "@babel/traverse" "^7.13.13"
+    "@babel/types" "^7.13.14"
 
-"@babel/helper-optimise-call-expression@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.0.0.tgz#a2920c5702b073c15de51106200aa8cad20497d5"
-  integrity sha512-u8nd9NQePYNQV8iPWu/pLLYBqZBa4ZaY1YWRFMuxrid94wKI1QNt67NEZ7GAe5Kc/0LLScbim05xZFWkAdrj9g==
+"@babel/helper-optimise-call-expression@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz#5c02d171b4c8615b1e7163f888c1c81c30a2aaea"
+  integrity sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.12.13"
 
 "@babel/helper-plugin-utils@^7.0.0":
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.0.0.tgz#bbb3fbee98661c569034237cc03967ba99b4f250"
   integrity sha512-CYAOUCARwExnEixLdB6sDm2dIJ/YgEAKDM1MOeMeZu9Ld/bDgVo8aiWrXwcY7OBh+1Ea2uUcVRcxKk0GJvW7QA==
 
-"@babel/helper-regex@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-regex/-/helper-regex-7.0.0.tgz#2c1718923b57f9bbe64705ffe5640ac64d9bdb27"
-  integrity sha512-TR0/N0NDCcUIUEbqV6dCO+LptmmSQFQ7q70lfcEB4URsjD0E1HzicrwUH+ap6BAQ2jhCX9Q4UqZy4wilujWlkg==
+"@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz#806526ce125aed03373bc416a828321e3a6a33af"
+  integrity sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==
+
+"@babel/helper-remap-async-to-generator@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.13.0.tgz#376a760d9f7b4b2077a9dd05aa9c3927cadb2209"
+  integrity sha512-pUQpFBE9JvC9lrQbpX0TmeNIy5s7GnZjna2lhhcHC7DzgBs6fWn722Y5cfwgrtrqc7NAJwMvOa0mKhq6XaE4jg==
   dependencies:
-    lodash "^4.17.10"
+    "@babel/helper-annotate-as-pure" "^7.12.13"
+    "@babel/helper-wrap-function" "^7.13.0"
+    "@babel/types" "^7.13.0"
 
-"@babel/helper-remap-async-to-generator@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.1.0.tgz#361d80821b6f38da75bd3f0785ece20a88c5fe7f"
-  integrity sha512-3fOK0L+Fdlg8S5al8u/hWE6vhufGSn0bN09xm2LXMy//REAF8kDCrYoOBKYmA8m5Nom+sV9LyLCwrFynA8/slg==
+"@babel/helper-replace-supers@^7.12.13", "@babel/helper-replace-supers@^7.13.0", "@babel/helper-replace-supers@^7.13.12":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.13.12.tgz#6442f4c1ad912502481a564a7386de0c77ff3804"
+  integrity sha512-Gz1eiX+4yDO8mT+heB94aLVNCL+rbuT2xy4YfyNqu8F+OI6vMvJK891qGBTqL9Uc8wxEvRW92Id6G7sDen3fFw==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.0.0"
-    "@babel/helper-wrap-function" "^7.1.0"
-    "@babel/template" "^7.1.0"
-    "@babel/traverse" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/helper-member-expression-to-functions" "^7.13.12"
+    "@babel/helper-optimise-call-expression" "^7.12.13"
+    "@babel/traverse" "^7.13.0"
+    "@babel/types" "^7.13.12"
 
-"@babel/helper-replace-supers@^7.1.0", "@babel/helper-replace-supers@^7.2.3":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.2.3.tgz#19970020cf22677d62b3a689561dbd9644d8c5e5"
-  integrity sha512-GyieIznGUfPXPWu0yLS6U55Mz67AZD9cUk0BfirOWlPrXlBcan9Gz+vHGz+cPfuoweZSnPzPIm67VtQM0OWZbA==
+"@babel/helper-simple-access@^7.12.13", "@babel/helper-simple-access@^7.13.12":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz#dd6c538afb61819d205a012c31792a39c7a5eaf6"
+  integrity sha512-7FEjbrx5SL9cWvXioDbnlYTppcZGuCY6ow3/D5vMggb2Ywgu4dMrpTJX0JdQAIcRRUElOIxF3yEooa9gUb9ZbA==
   dependencies:
-    "@babel/helper-member-expression-to-functions" "^7.0.0"
-    "@babel/helper-optimise-call-expression" "^7.0.0"
-    "@babel/traverse" "^7.2.3"
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.13.12"
 
-"@babel/helper-simple-access@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.1.0.tgz#65eeb954c8c245beaa4e859da6188f39d71e585c"
-  integrity sha512-Vk+78hNjRbsiu49zAPALxTb+JUQCz1aolpd8osOF16BGnLtseD21nbHgLPGUwrXEurZgiCOUmvs3ExTu4F5x6w==
+"@babel/helper-skip-transparent-expression-wrappers@^7.12.1":
+  version "7.12.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz#462dc63a7e435ade8468385c63d2b84cce4b3cbf"
+  integrity sha512-Mf5AUuhG1/OCChOJ/HcADmvcHM42WJockombn8ATJG3OnyiSxBK/Mm5x78BQWvmtXZKHgbjdGL2kin/HOLlZGA==
   dependencies:
-    "@babel/template" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.12.1"
 
 "@babel/helper-split-export-declaration@^7.0.0":
   version "7.0.0"
@@ -203,29 +259,41 @@
   dependencies:
     "@babel/types" "^7.0.0"
 
+"@babel/helper-split-export-declaration@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz#e9430be00baf3e88b0e13e6f9d4eaf2136372b05"
+  integrity sha512-tCJDltF83htUtXx5NLcaDqRmknv652ZWCHyoTETf1CXYJdPC7nohZohjUgieXhv0hTJdRf2FjDueFehdNucpzg==
+  dependencies:
+    "@babel/types" "^7.12.13"
+
 "@babel/helper-validator-identifier@^7.12.11":
   version "7.12.11"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz#c9a1f021917dcb5ccf0d4e453e399022981fc9ed"
   integrity sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==
 
-"@babel/helper-wrap-function@^7.1.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.2.0.tgz#c4e0012445769e2815b55296ead43a958549f6fa"
-  integrity sha512-o9fP1BZLLSrYlxYEYyl2aS+Flun5gtjTIG8iln+XuEzQTs0PLagAGSXUcqruJwD5fM48jzIEggCKpIfWTcR7pQ==
+"@babel/helper-validator-option@^7.12.17":
+  version "7.12.17"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz#d1fbf012e1a79b7eebbfdc6d270baaf8d9eb9831"
+  integrity sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==
+
+"@babel/helper-wrap-function@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.13.0.tgz#bdb5c66fda8526ec235ab894ad53a1235c79fcc4"
+  integrity sha512-1UX9F7K3BS42fI6qd2A4BjKzgGjToscyZTdp1DjknHLCIvpgne6918io+aL5LXFcER/8QWiwpoY902pVEqgTXA==
   dependencies:
-    "@babel/helper-function-name" "^7.1.0"
-    "@babel/template" "^7.1.0"
-    "@babel/traverse" "^7.1.0"
-    "@babel/types" "^7.2.0"
+    "@babel/helper-function-name" "^7.12.13"
+    "@babel/template" "^7.12.13"
+    "@babel/traverse" "^7.13.0"
+    "@babel/types" "^7.13.0"
 
-"@babel/helpers@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.2.0.tgz#8335f3140f3144270dc63c4732a4f8b0a50b7a21"
-  integrity sha512-Fr07N+ea0dMcMN8nFpuK6dUIT7/ivt9yKQdEEnjVS83tG2pHwPi03gYmk/tyuwONnZ+sY+GFFPlWGgCtW1hF9A==
+"@babel/helpers@^7.13.10":
+  version "7.13.10"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.13.10.tgz#fd8e2ba7488533cdeac45cc158e9ebca5e3c7df8"
+  integrity sha512-4VO883+MWPDUVRF3PhiLBUFHoX/bsLTGFpFK/HqvvfBZz2D57u9XzPVNFVBTc0PW/CWR9BXTOKt8NF4DInUHcQ==
   dependencies:
-    "@babel/template" "^7.1.2"
-    "@babel/traverse" "^7.1.5"
-    "@babel/types" "^7.2.0"
+    "@babel/template" "^7.12.13"
+    "@babel/traverse" "^7.13.0"
+    "@babel/types" "^7.13.0"
 
 "@babel/highlight@^7.0.0":
   version "7.0.0"
@@ -236,394 +304,602 @@
     esutils "^2.0.2"
     js-tokens "^4.0.0"
 
+"@babel/highlight@^7.10.4", "@babel/highlight@^7.12.13":
+  version "7.13.10"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.13.10.tgz#a8b2a66148f5b27d666b15d81774347a731d52d1"
+  integrity sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.12.11"
+    chalk "^2.0.0"
+    js-tokens "^4.0.0"
+
 "@babel/parser@^7.0.0", "@babel/parser@^7.2.2", "@babel/parser@^7.2.3":
   version "7.2.3"
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.2.3.tgz#32f5df65744b70888d17872ec106b02434ba1489"
   integrity sha512-0LyEcVlfCoFmci8mXx8A5oIkpkOgyo8dRHtxBnK9RRBwxO2+JZPNsqtVEZQ7mJFPxnXF9lfmU24mHOPI0qnlkA==
 
-"@babel/plugin-proposal-async-generator-functions@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.2.0.tgz#b289b306669dce4ad20b0252889a15768c9d417e"
-  integrity sha512-+Dfo/SCQqrwx48ptLVGLdE39YtWRuKc/Y9I5Fy0P1DDBB9lsAHpjcEJQt+4IifuSOSTLBKJObJqMvaO1pIE8LQ==
+"@babel/parser@^7.12.13", "@babel/parser@^7.13.13":
+  version "7.13.13"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.13.tgz#42f03862f4aed50461e543270916b47dd501f0df"
+  integrity sha512-OhsyMrqygfk5v8HmWwOzlYjJrtLaFhF34MrfG/Z73DgYCI6ojNUTUp2TYbtnjo8PegeJp12eamsNettCQjKjVw==
+
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.13.12":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.13.12.tgz#a3484d84d0b549f3fc916b99ee4783f26fabad2a"
+  integrity sha512-d0u3zWKcoZf379fOeJdr1a5WPDny4aOFZ6hlfKivgK0LY7ZxNfoaHL2fWwdGtHyVvra38FC+HVYkO+byfSA8AQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
+    "@babel/plugin-proposal-optional-chaining" "^7.13.12"
+
+"@babel/plugin-proposal-async-generator-functions@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.13.8.tgz#87aacb574b3bc4b5603f6fe41458d72a5a2ec4b1"
+  integrity sha512-rPBnhj+WgoSmgq+4gQUtXx/vOcU+UYtjy1AA/aeD61Hwj410fwYyqfUcRP3lR8ucgliVJL/G7sXcNUecC75IXA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-remap-async-to-generator" "^7.13.0"
+    "@babel/plugin-syntax-async-generators" "^7.8.4"
+
+"@babel/plugin-proposal-class-properties@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz#146376000b94efd001e57a40a88a525afaab9f37"
+  integrity sha512-KnTDjFNC1g+45ka0myZNvSBFLhNCLN+GeGYLDEA8Oq7MZ6yMgfLoIRh86GRT0FjtJhZw8JyUskP9uvj5pHM9Zg==
+  dependencies:
+    "@babel/helper-create-class-features-plugin" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+
+"@babel/plugin-proposal-dynamic-import@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.13.8.tgz#876a1f6966e1dec332e8c9451afda3bebcdf2e1d"
+  integrity sha512-ONWKj0H6+wIRCkZi9zSbZtE/r73uOhMVHh256ys0UzfM7I3d4n+spZNWjOnJv2gzopumP2Wxi186vI8N0Y2JyQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
+
+"@babel/plugin-proposal-export-namespace-from@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.12.13.tgz#393be47a4acd03fa2af6e3cde9b06e33de1b446d"
+  integrity sha512-INAgtFo4OnLN3Y/j0VwAgw3HDXcDtX+C/erMvWzuV9v71r7urb6iyMXu7eM9IgLr1ElLlOkaHjJ0SbCmdOQ3Iw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
+
+"@babel/plugin-proposal-json-strings@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.13.8.tgz#bf1fb362547075afda3634ed31571c5901afef7b"
+  integrity sha512-w4zOPKUFPX1mgvTmL/fcEqy34hrQ1CRcGxdphBc6snDnnqJ47EZDIyop6IwXzAC8G916hsIuXB2ZMBCExC5k7Q==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-json-strings" "^7.8.3"
+
+"@babel/plugin-proposal-logical-assignment-operators@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.13.8.tgz#93fa78d63857c40ce3c8c3315220fd00bfbb4e1a"
+  integrity sha512-aul6znYB4N4HGweImqKn59Su9RS8lbUIqxtXTOcAGtNIDczoEFv+l1EhmX8rUBp3G1jMjKJm8m0jXVp63ZpS4A==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
+
+"@babel/plugin-proposal-nullish-coalescing-operator@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.13.8.tgz#3730a31dafd3c10d8ccd10648ed80a2ac5472ef3"
+  integrity sha512-iePlDPBn//UhxExyS9KyeYU7RM9WScAG+D3Hhno0PLJebAEpDZMocbDe64eqynhNAnwz/vZoL/q/QB2T1OH39A==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
+
+"@babel/plugin-proposal-numeric-separator@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.12.13.tgz#bd9da3188e787b5120b4f9d465a8261ce67ed1db"
+  integrity sha512-O1jFia9R8BUCl3ZGB7eitaAPu62TXJRHn7rh+ojNERCFyqRwJMTmhz+tJ+k0CwI6CLjX/ee4qW74FSqlq9I35w==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
+
+"@babel/plugin-proposal-object-rest-spread@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz#5d210a4d727d6ce3b18f9de82cc99a3964eed60a"
+  integrity sha512-DhB2EuB1Ih7S3/IRX5AFVgZ16k3EzfRbq97CxAVI1KSYcW+lexV8VZb7G7L8zuPVSdQMRn0kiBpf/Yzu9ZKH0g==
+  dependencies:
+    "@babel/compat-data" "^7.13.8"
+    "@babel/helper-compilation-targets" "^7.13.8"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
+    "@babel/plugin-transform-parameters" "^7.13.0"
+
+"@babel/plugin-proposal-optional-catch-binding@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.13.8.tgz#3ad6bd5901506ea996fc31bdcf3ccfa2bed71107"
+  integrity sha512-0wS/4DUF1CuTmGo+NiaHfHcVSeSLj5S3e6RivPTg/2k3wOv3jO35tZ6/ZWsQhQMvdgI7CwphjQa/ccarLymHVA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
+
+"@babel/plugin-proposal-optional-chaining@^7.13.12":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.13.12.tgz#ba9feb601d422e0adea6760c2bd6bbb7bfec4866"
+  integrity sha512-fcEdKOkIB7Tf4IxrgEVeFC4zeJSTr78no9wTdBuZZbqF64kzllU0ybo2zrzm7gUQfxGhBgq4E39oRs8Zx/RMYQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-remap-async-to-generator" "^7.1.0"
-    "@babel/plugin-syntax-async-generators" "^7.2.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
+    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
 
-"@babel/plugin-proposal-class-properties@^7.1.0":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.2.3.tgz#c9e1294363b346cff333007a92080f3203698461"
-  integrity sha512-FVuQngLoN2iDrpW7LmhPZ2sO4DJxf35FOcwidwB9Ru9tMvI5URthnkVHuG14IStV+TzkMTyLMoOUlSTtrdVwqw==
+"@babel/plugin-proposal-private-methods@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.13.0.tgz#04bd4c6d40f6e6bbfa2f57e2d8094bad900ef787"
+  integrity sha512-MXyyKQd9inhx1kDYPkFRVOBXQ20ES8Pto3T7UZ92xj2mY0EVD8oAVzeyYuVfy/mxAdTSIayOvg+aVzcHV2bn6Q==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.2.3"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-create-class-features-plugin" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-proposal-json-strings@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.2.0.tgz#568ecc446c6148ae6b267f02551130891e29f317"
-  integrity sha512-MAFV1CA/YVmYwZG0fBQyXhmj0BHCB5egZHCKWIFVv/XCxAeVGIHfos3SwDck4LvCllENIAg7xMKOG5kH0dzyUg==
+"@babel/plugin-proposal-unicode-property-regex@^7.12.13", "@babel/plugin-proposal-unicode-property-regex@^7.4.4":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.12.13.tgz#bebde51339be829c17aaaaced18641deb62b39ba"
+  integrity sha512-XyJmZidNfofEkqFV5VC/bLabGmO5QzenPO/YOfGuEbgU+2sSwMmio3YLb4WtBgcmmdwZHyVyv8on77IUjQ5Gvg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-json-strings" "^7.2.0"
+    "@babel/helper-create-regexp-features-plugin" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-proposal-object-rest-spread@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.2.0.tgz#88f5fec3e7ad019014c97f7ee3c992f0adbf7fb8"
-  integrity sha512-1L5mWLSvR76XYUQJXkd/EEQgjq8HHRP6lQuZTTg0VA4tTGPpGemmCdAfQIz1rzEuWAm+ecP8PyyEm30jC1eQCg==
+"@babel/plugin-syntax-async-generators@^7.8.4":
+  version "7.8.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
+  integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-object-rest-spread" "^7.2.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-proposal-optional-catch-binding@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.2.0.tgz#135d81edb68a081e55e56ec48541ece8065c38f5"
-  integrity sha512-mgYj3jCcxug6KUcX4OBoOJz3CMrwRfQELPQ5560F70YQUBZB7uac9fqaWamKR1iWUzGiK2t0ygzjTScZnVz75g==
+"@babel/plugin-syntax-class-properties@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
+  integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.2.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-proposal-unicode-property-regex@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.2.0.tgz#abe7281fe46c95ddc143a65e5358647792039520"
-  integrity sha512-LvRVYb7kikuOtIoUeWTkOxQEV1kYvL5B6U3iWEGCzPNRus1MzJweFqORTj+0jkxozkTSYNJozPOddxmqdqsRpw==
+"@babel/plugin-syntax-dynamic-import@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz#62bf98b2da3cd21d626154fc96ee5b3cb68eacb3"
+  integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-regex" "^7.0.0"
-    regexpu-core "^4.2.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-syntax-async-generators@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.2.0.tgz#69e1f0db34c6f5a0cf7e2b3323bf159a76c8cb7f"
-  integrity sha512-1ZrIRBv2t0GSlcwVoQ6VgSLpLgiN/FVQUzt9znxo7v2Ov4jJrs8RY8tv0wvDmFN3qIdMKWrmMMW6yZ0G19MfGg==
+"@babel/plugin-syntax-export-namespace-from@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz#028964a9ba80dbc094c915c487ad7c4e7a66465a"
+  integrity sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.8.3"
 
-"@babel/plugin-syntax-dynamic-import@^7.0.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.2.0.tgz#69c159ffaf4998122161ad8ebc5e6d1f55df8612"
-  integrity sha512-mVxuJ0YroI/h/tbFTPGZR8cv6ai+STMKNBq0f8hFxsxWjl94qqhsb+wXbpNMDPU3cfR1TIsVFzU3nXyZMqyK4w==
+"@babel/plugin-syntax-flow@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.12.13.tgz#5df9962503c0a9c918381c929d51d4d6949e7e86"
+  integrity sha512-J/RYxnlSLXZLVR7wTRsozxKT8qbsx1mNKJzXEEjQ0Kjx1ZACcyHgbanNWNCFtc36IzuWhYWPpvJFFoexoOWFmA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-syntax-flow@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.2.0.tgz#a765f061f803bc48f240c26f8747faf97c26bf7c"
-  integrity sha512-r6YMuZDWLtLlu0kqIim5o/3TNRAlWb073HwT3e2nKf9I8IIvOggPrnILYPsrrKilmn/mYEMCf/Z07w3yQJF6dg==
+"@babel/plugin-syntax-json-strings@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
+  integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-syntax-json-strings@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.2.0.tgz#72bd13f6ffe1d25938129d2a186b11fd62951470"
-  integrity sha512-5UGYnMSLRE1dqqZwug+1LISpA403HzlSfsg6P9VXU6TBjcSHeNlw4DxDx7LgpF+iKZoOG/+uzqoRHTdcUpiZNg==
+"@babel/plugin-syntax-jsx@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.13.tgz#044fb81ebad6698fe62c478875575bcbb9b70f15"
+  integrity sha512-d4HM23Q1K7oq/SLNmG6mRt85l2csmQ0cHRaxRXjKW0YFdEXqlZ5kzFQKH5Uc3rDJECgu+yCRgPkG04Mm98R/1g==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-syntax-jsx@^7.0.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.2.0.tgz#0b85a3b4bc7cdf4cc4b8bf236335b907ca22e7c7"
-  integrity sha512-VyN4QANJkRW6lDBmENzRszvZf3/4AXaj9YR7GwrWeeN9tEBPuXbmDYVU9bYBN0D70zCWVwUy0HWq2553VCb6Hw==
+"@babel/plugin-syntax-logical-assignment-operators@^7.10.4":
+  version "7.10.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699"
+  integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.10.4"
 
-"@babel/plugin-syntax-object-rest-spread@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.2.0.tgz#3b7a3e733510c57e820b9142a6579ac8b0dfad2e"
-  integrity sha512-t0JKGgqk2We+9may3t0xDdmneaXmyxq0xieYcKHxIsrJO64n1OiMWNUtc5gQK1PA0NpdCRrtZp4z+IUaKugrSA==
+"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9"
+  integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-syntax-optional-catch-binding@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.2.0.tgz#a94013d6eda8908dfe6a477e7f9eda85656ecf5c"
-  integrity sha512-bDe4xKNhb0LI7IvZHiA13kff0KEfaGX/Hv4lMA9+7TEc63hMNvfKo6ZFpXhKuEp+II/q35Gc4NoMeDZyaUbj9w==
+"@babel/plugin-syntax-numeric-separator@^7.10.4":
+  version "7.10.4"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97"
+  integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.10.4"
 
-"@babel/plugin-transform-arrow-functions@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.2.0.tgz#9aeafbe4d6ffc6563bf8f8372091628f00779550"
-  integrity sha512-ER77Cax1+8/8jCB9fo4Ud161OZzWN5qawi4GusDuRLcDbDG+bIGYY20zb2dfAFdTRGzrfq2xZPvF0R64EHnimg==
+"@babel/plugin-syntax-object-rest-spread@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
+  integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-transform-async-to-generator@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.2.0.tgz#68b8a438663e88519e65b776f8938f3445b1a2ff"
-  integrity sha512-CEHzg4g5UraReozI9D4fblBYABs7IM6UerAVG7EJVrTLC5keh00aEuLUT+O40+mJCEzaXkYfTCUKIyeDfMOFFQ==
+"@babel/plugin-syntax-optional-catch-binding@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1"
+  integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==
   dependencies:
-    "@babel/helper-module-imports" "^7.0.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-remap-async-to-generator" "^7.1.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-transform-block-scoped-functions@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.2.0.tgz#5d3cc11e8d5ddd752aa64c9148d0db6cb79fd190"
-  integrity sha512-ntQPR6q1/NKuphly49+QiQiTN0O63uOwjdD6dhIjSWBI5xlrbUFh720TIpzBhpnrLfv2tNH/BXvLIab1+BAI0w==
+"@babel/plugin-syntax-optional-chaining@^7.8.3":
+  version "7.8.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a"
+  integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-transform-block-scoping@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.2.0.tgz#f17c49d91eedbcdf5dd50597d16f5f2f770132d4"
-  integrity sha512-vDTgf19ZEV6mx35yiPJe4fS02mPQUUcBNwWQSZFXSzTSbsJFQvHt7DqyS3LK8oOWALFOsJ+8bbqBgkirZteD5Q==
+"@babel/plugin-syntax-top-level-await@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz#c5f0fa6e249f5b739727f923540cf7a806130178"
+  integrity sha512-A81F9pDwyS7yM//KwbCSDqy3Uj4NMIurtplxphWxoYtNPov7cJsDkAFNNyVlIZ3jwGycVsurZ+LtOA8gZ376iQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    lodash "^4.17.10"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-classes@^7.2.0":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.2.2.tgz#6c90542f210ee975aa2aa8c8b5af7fa73a126953"
-  integrity sha512-gEZvgTy1VtcDOaQty1l10T3jQmJKlNVxLDCs+3rCVPr6nMkODLELxViq5X9l+rfxbie3XrfrMCYYY6eX3aOcOQ==
+"@babel/plugin-transform-arrow-functions@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz#10a59bebad52d637a027afa692e8d5ceff5e3dae"
+  integrity sha512-96lgJagobeVmazXFaDrbmCLQxBysKu7U6Do3mLsx27gf5Dk85ezysrs2BZUpXD703U/Su1xTBDxxar2oa4jAGg==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.0.0"
-    "@babel/helper-define-map" "^7.1.0"
-    "@babel/helper-function-name" "^7.1.0"
-    "@babel/helper-optimise-call-expression" "^7.0.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-replace-supers" "^7.1.0"
-    "@babel/helper-split-export-declaration" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+
+"@babel/plugin-transform-async-to-generator@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.13.0.tgz#8e112bf6771b82bf1e974e5e26806c5c99aa516f"
+  integrity sha512-3j6E004Dx0K3eGmhxVJxwwI89CTJrce7lg3UrtFuDAVQ/2+SJ/h/aSFOeE6/n0WB1GsOffsJp6MnPQNQ8nmwhg==
+  dependencies:
+    "@babel/helper-module-imports" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-remap-async-to-generator" "^7.13.0"
+
+"@babel/plugin-transform-block-scoped-functions@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz#a9bf1836f2a39b4eb6cf09967739de29ea4bf4c4"
+  integrity sha512-zNyFqbc3kI/fVpqwfqkg6RvBgFpC4J18aKKMmv7KdQ/1GgREapSJAykLMVNwfRGO3BtHj3YQZl8kxCXPcVMVeg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/plugin-transform-block-scoping@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.12.13.tgz#f36e55076d06f41dfd78557ea039c1b581642e61"
+  integrity sha512-Pxwe0iqWJX4fOOM2kEZeUuAxHMWb9nK+9oh5d11bsLoB0xMg+mkDpt0eYuDZB7ETrY9bbcVlKUGTOGWy7BHsMQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/plugin-transform-classes@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz#0265155075c42918bf4d3a4053134176ad9b533b"
+  integrity sha512-9BtHCPUARyVH1oXGcSJD3YpsqRLROJx5ZNP6tN5vnk17N0SVf9WCtf8Nuh1CFmgByKKAIMstitKduoCmsaDK5g==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.12.13"
+    "@babel/helper-function-name" "^7.12.13"
+    "@babel/helper-optimise-call-expression" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-replace-supers" "^7.13.0"
+    "@babel/helper-split-export-declaration" "^7.12.13"
     globals "^11.1.0"
 
-"@babel/plugin-transform-computed-properties@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.2.0.tgz#83a7df6a658865b1c8f641d510c6f3af220216da"
-  integrity sha512-kP/drqTxY6Xt3NNpKiMomfgkNn4o7+vKxK2DDKcBG9sHj51vHqMBGy8wbDS/J4lMxnqs153/T3+DmCEAkC5cpA==
+"@babel/plugin-transform-computed-properties@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz#845c6e8b9bb55376b1fa0b92ef0bdc8ea06644ed"
+  integrity sha512-RRqTYTeZkZAz8WbieLTvKUEUxZlUTdmL5KGMyZj7FnMfLNKV4+r5549aORG/mgojRmFlQMJDUupwAMiF2Q7OUg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-destructuring@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.2.0.tgz#e75269b4b7889ec3a332cd0d0c8cff8fed0dc6f3"
-  integrity sha512-coVO2Ayv7g0qdDbrNiadE4bU7lvCd9H539m2gMknyVjjMdwF/iCOM7R+E8PkntoqLkltO0rk+3axhpp/0v68VQ==
+"@babel/plugin-transform-destructuring@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.0.tgz#c5dce270014d4e1ebb1d806116694c12b7028963"
+  integrity sha512-zym5em7tePoNT9s964c0/KU3JPPnuq7VhIxPRefJ4/s82cD+q1mgKfuGRDMCPL0HTyKz4dISuQlCusfgCJ86HA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-dotall-regex@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.2.0.tgz#f0aabb93d120a8ac61e925ea0ba440812dbe0e49"
-  integrity sha512-sKxnyHfizweTgKZf7XsXu/CNupKhzijptfTM+bozonIuyVrLWVUvYjE2bhuSBML8VQeMxq4Mm63Q9qvcvUcciQ==
+"@babel/plugin-transform-dotall-regex@^7.12.13", "@babel/plugin-transform-dotall-regex@^7.4.4":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.12.13.tgz#3f1601cc29905bfcb67f53910f197aeafebb25ad"
+  integrity sha512-foDrozE65ZFdUC2OfgeOCrEPTxdB3yjqxpXh8CH+ipd9CHd4s/iq81kcUpyH8ACGNEPdFqbtzfgzbT/ZGlbDeQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-regex" "^7.0.0"
-    regexpu-core "^4.1.3"
+    "@babel/helper-create-regexp-features-plugin" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-duplicate-keys@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.2.0.tgz#d952c4930f312a4dbfff18f0b2914e60c35530b3"
-  integrity sha512-q+yuxW4DsTjNceUiTzK0L+AfQ0zD9rWaTLiUqHA8p0gxx7lu1EylenfzjeIWNkPy6e/0VG/Wjw9uf9LueQwLOw==
+"@babel/plugin-transform-duplicate-keys@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.12.13.tgz#6f06b87a8b803fd928e54b81c258f0a0033904de"
+  integrity sha512-NfADJiiHdhLBW3pulJlJI2NB0t4cci4WTZ8FtdIuNc2+8pslXdPtRRAEWqUY+m9kNOk2eRYbTAOipAxlrOcwwQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-exponentiation-operator@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.2.0.tgz#a63868289e5b4007f7054d46491af51435766008"
-  integrity sha512-umh4hR6N7mu4Elq9GG8TOu9M0bakvlsREEC+ialrQN6ABS4oDQ69qJv1VtR3uxlKMCQMCvzk7vr17RHKcjx68A==
+"@babel/plugin-transform-exponentiation-operator@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.12.13.tgz#4d52390b9a273e651e4aba6aee49ef40e80cd0a1"
+  integrity sha512-fbUelkM1apvqez/yYx1/oICVnGo2KM5s63mhGylrmXUxK/IAXSIf87QIxVfZldWf4QsOafY6vV3bX8aMHSvNrA==
   dependencies:
-    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.1.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-flow-strip-types@^7.0.0":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.2.3.tgz#e3ac2a594948454e7431c7db33e1d02d51b5cd69"
-  integrity sha512-xnt7UIk9GYZRitqCnsVMjQK1O2eKZwFB3CvvHjf5SGx6K6vr/MScCKQDnf1DxRaj501e3pXjti+inbSXX2ZUoQ==
+"@babel/plugin-transform-flow-strip-types@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.13.0.tgz#58177a48c209971e8234e99906cb6bd1122addd3"
+  integrity sha512-EXAGFMJgSX8gxWD7PZtW/P6M+z74jpx3wm/+9pn+c2dOawPpBkUX7BrfyPvo6ZpXbgRIEuwgwDb/MGlKvu2pOg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-syntax-flow" "^7.2.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/plugin-syntax-flow" "^7.12.13"
 
-"@babel/plugin-transform-for-of@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.2.0.tgz#ab7468befa80f764bb03d3cb5eef8cc998e1cad9"
-  integrity sha512-Kz7Mt0SsV2tQk6jG5bBv5phVbkd0gd27SgYD4hH1aLMJRchM0dzHaXvrWhVZ+WxAlDoAKZ7Uy3jVTW2mKXQ1WQ==
+"@babel/plugin-transform-for-of@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz#c799f881a8091ac26b54867a845c3e97d2696062"
+  integrity sha512-IHKT00mwUVYE0zzbkDgNRP6SRzvfGCYsOxIRz8KsiaaHCcT9BWIkO+H9QRJseHBLOGBZkHUdHiqj6r0POsdytg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-function-name@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.2.0.tgz#f7930362829ff99a3174c39f0afcc024ef59731a"
-  integrity sha512-kWgksow9lHdvBC2Z4mxTsvc7YdY7w/V6B2vy9cTIPtLEE9NhwoWivaxdNM/S37elu5bqlLP/qOY906LukO9lkQ==
+"@babel/plugin-transform-function-name@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz#bb024452f9aaed861d374c8e7a24252ce3a50051"
+  integrity sha512-6K7gZycG0cmIwwF7uMK/ZqeCikCGVBdyP2J5SKNCXO5EOHcqi+z7Jwf8AmyDNcBgxET8DrEtCt/mPKPyAzXyqQ==
   dependencies:
-    "@babel/helper-function-name" "^7.1.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-function-name" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-literals@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.2.0.tgz#690353e81f9267dad4fd8cfd77eafa86aba53ea1"
-  integrity sha512-2ThDhm4lI4oV7fVQ6pNNK+sx+c/GM5/SaML0w/r4ZB7sAneD/piDJtwdKlNckXeyGK7wlwg2E2w33C/Hh+VFCg==
+"@babel/plugin-transform-literals@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz#2ca45bafe4a820197cf315794a4d26560fe4bdb9"
+  integrity sha512-FW+WPjSR7hiUxMcKqyNjP05tQ2kmBCdpEpZHY1ARm96tGQCCBvXKnpjILtDplUnJ/eHZ0lALLM+d2lMFSpYJrQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-modules-amd@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.2.0.tgz#82a9bce45b95441f617a24011dc89d12da7f4ee6"
-  integrity sha512-mK2A8ucqz1qhrdqjS9VMIDfIvvT2thrEsIQzbaTdc5QFzhDjQv2CkJJ5f6BXIkgbmaoax3zBr2RyvV/8zeoUZw==
+"@babel/plugin-transform-member-expression-literals@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz#5ffa66cd59b9e191314c9f1f803b938e8c081e40"
+  integrity sha512-kxLkOsg8yir4YeEPHLuO2tXP9R/gTjpuTOjshqSpELUN3ZAg2jfDnKUvzzJxObun38sw3wm4Uu69sX/zA7iRvg==
   dependencies:
-    "@babel/helper-module-transforms" "^7.1.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-modules-commonjs@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.2.0.tgz#c4f1933f5991d5145e9cfad1dfd848ea1727f404"
-  integrity sha512-V6y0uaUQrQPXUrmj+hgnks8va2L0zcZymeU7TtWEgdRLNkceafKXEduv7QzgQAE4lT+suwooG9dC7LFhdRAbVQ==
+"@babel/plugin-transform-modules-amd@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.13.0.tgz#19f511d60e3d8753cc5a6d4e775d3a5184866cc3"
+  integrity sha512-EKy/E2NHhY/6Vw5d1k3rgoobftcNUmp9fGjb9XZwQLtTctsRBOTRO7RHHxfIky1ogMN5BxN7p9uMA3SzPfotMQ==
   dependencies:
-    "@babel/helper-module-transforms" "^7.1.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-simple-access" "^7.1.0"
+    "@babel/helper-module-transforms" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    babel-plugin-dynamic-import-node "^2.3.3"
 
-"@babel/plugin-transform-modules-systemjs@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.2.0.tgz#912bfe9e5ff982924c81d0937c92d24994bb9068"
-  integrity sha512-aYJwpAhoK9a+1+O625WIjvMY11wkB/ok0WClVwmeo3mCjcNRjt+/8gHWrB5i+00mUju0gWsBkQnPpdvQ7PImmQ==
+"@babel/plugin-transform-modules-commonjs@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz#7b01ad7c2dcf2275b06fa1781e00d13d420b3e1b"
+  integrity sha512-9QiOx4MEGglfYZ4XOnU79OHr6vIWUakIj9b4mioN8eQIoEh+pf5p/zEB36JpDFWA12nNMiRf7bfoRvl9Rn79Bw==
   dependencies:
-    "@babel/helper-hoist-variables" "^7.0.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-module-transforms" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-simple-access" "^7.12.13"
+    babel-plugin-dynamic-import-node "^2.3.3"
 
-"@babel/plugin-transform-modules-umd@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.2.0.tgz#7678ce75169f0877b8eb2235538c074268dd01ae"
-  integrity sha512-BV3bw6MyUH1iIsGhXlOK6sXhmSarZjtJ/vMiD9dNmpY8QXFFQTj+6v92pcfy1iqa8DeAfJFwoxcrS/TUZda6sw==
+"@babel/plugin-transform-modules-systemjs@^7.13.8":
+  version "7.13.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.13.8.tgz#6d066ee2bff3c7b3d60bf28dec169ad993831ae3"
+  integrity sha512-hwqctPYjhM6cWvVIlOIe27jCIBgHCsdH2xCJVAYQm7V5yTMoilbVMi9f6wKg0rpQAOn6ZG4AOyvCqFF/hUh6+A==
   dependencies:
-    "@babel/helper-module-transforms" "^7.1.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-hoist-variables" "^7.13.0"
+    "@babel/helper-module-transforms" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-validator-identifier" "^7.12.11"
+    babel-plugin-dynamic-import-node "^2.3.3"
 
-"@babel/plugin-transform-new-target@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.0.0.tgz#ae8fbd89517fa7892d20e6564e641e8770c3aa4a"
-  integrity sha512-yin069FYjah+LbqfGeTfzIBODex/e++Yfa0rH0fpfam9uTbuEeEOx5GLGr210ggOV77mVRNoeqSYqeuaqSzVSw==
+"@babel/plugin-transform-modules-umd@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.13.0.tgz#8a3d96a97d199705b9fd021580082af81c06e70b"
+  integrity sha512-D/ILzAh6uyvkWjKKyFE/W0FzWwasv6vPTSqPcjxFqn6QpX3u8DjRVliq4F2BamO2Wee/om06Vyy+vPkNrd4wxw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-module-transforms" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-object-super@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.2.0.tgz#b35d4c10f56bab5d650047dad0f1d8e8814b6598"
-  integrity sha512-VMyhPYZISFZAqAPVkiYb7dUe2AsVi2/wCT5+wZdsNO31FojQJa9ns40hzZ6U9f50Jlq4w6qwzdBB2uwqZ00ebg==
+"@babel/plugin-transform-named-capturing-groups-regex@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.12.13.tgz#2213725a5f5bbbe364b50c3ba5998c9599c5c9d9"
+  integrity sha512-Xsm8P2hr5hAxyYblrfACXpQKdQbx4m2df9/ZZSQ8MAhsadw06+jW7s9zsSw6he+mJZXRlVMyEnVktJo4zjk1WA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-replace-supers" "^7.1.0"
+    "@babel/helper-create-regexp-features-plugin" "^7.12.13"
 
-"@babel/plugin-transform-parameters@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.2.0.tgz#0d5ad15dc805e2ea866df4dd6682bfe76d1408c2"
-  integrity sha512-kB9+hhUidIgUoBQ0MsxMewhzr8i60nMa2KgeJKQWYrqQpqcBYtnpR+JgkadZVZoaEZ/eKu9mclFaVwhRpLNSzA==
+"@babel/plugin-transform-new-target@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.12.13.tgz#e22d8c3af24b150dd528cbd6e685e799bf1c351c"
+  integrity sha512-/KY2hbLxrG5GTQ9zzZSc3xWiOy379pIETEhbtzwZcw9rvuaVV4Fqy7BYGYOWZnaoXIQYbbJ0ziXLa/sKcGCYEQ==
   dependencies:
-    "@babel/helper-call-delegate" "^7.1.0"
-    "@babel/helper-get-function-arity" "^7.0.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-regenerator@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.0.0.tgz#5b41686b4ed40bef874d7ed6a84bdd849c13e0c1"
-  integrity sha512-sj2qzsEx8KDVv1QuJc/dEfilkg3RRPvPYx/VnKLtItVQRWt1Wqf5eVCOLZm29CiGFfYYsA3VPjfizTCV0S0Dlw==
+"@babel/plugin-transform-object-super@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz#b4416a2d63b8f7be314f3d349bd55a9c1b5171f7"
+  integrity sha512-JzYIcj3XtYspZDV8j9ulnoMPZZnF/Cj0LUxPOjR89BdBVx+zYJI9MdMIlUZjbXDX+6YVeS6I3e8op+qQ3BYBoQ==
   dependencies:
-    regenerator-transform "^0.13.3"
+    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-replace-supers" "^7.12.13"
 
-"@babel/plugin-transform-shorthand-properties@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.2.0.tgz#6333aee2f8d6ee7e28615457298934a3b46198f0"
-  integrity sha512-QP4eUM83ha9zmYtpbnyjTLAGKQritA5XW/iG9cjtuOI8s1RuL/3V6a3DeSHfKutJQ+ayUfeZJPcnCYEQzaPQqg==
+"@babel/plugin-transform-parameters@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz#8fa7603e3097f9c0b7ca1a4821bc2fb52e9e5007"
+  integrity sha512-Jt8k/h/mIwE2JFEOb3lURoY5C85ETcYPnbuAJ96zRBzh1XHtQZfs62ChZ6EP22QlC8c7Xqr9q+e1SU5qttwwjw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.13.0"
 
-"@babel/plugin-transform-spread@^7.2.0":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.2.2.tgz#3103a9abe22f742b6d406ecd3cd49b774919b406"
-  integrity sha512-KWfky/58vubwtS0hLqEnrWJjsMGaOeSBn90Ezn5Jeg9Z8KKHmELbP1yGylMlm5N6TPKeY9A2+UaSYLdxahg01w==
+"@babel/plugin-transform-property-literals@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz#4e6a9e37864d8f1b3bc0e2dce7bf8857db8b1a81"
+  integrity sha512-nqVigwVan+lR+g8Fj8Exl0UQX2kymtjcWfMOYM1vTYEKujeyv2SkMgazf2qNcK7l4SDiKyTA/nHCPqL4e2zo1A==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-sticky-regex@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.2.0.tgz#a1e454b5995560a9c1e0d537dfc15061fd2687e1"
-  integrity sha512-KKYCoGaRAf+ckH8gEL3JHUaFVyNHKe3ASNsZ+AlktgHevvxGigoIttrEJb8iKN03Q7Eazlv1s6cx2B2cQ3Jabw==
+"@babel/plugin-transform-regenerator@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.12.13.tgz#b628bcc9c85260ac1aeb05b45bde25210194a2f5"
+  integrity sha512-lxb2ZAvSLyJ2PEe47hoGWPmW22v7CtSl9jW8mingV4H2sEX/JOcrAj2nPuGWi56ERUm2bUpjKzONAuT6HCn2EA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-regex" "^7.0.0"
+    regenerator-transform "^0.14.2"
 
-"@babel/plugin-transform-template-literals@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.2.0.tgz#d87ed01b8eaac7a92473f608c97c089de2ba1e5b"
-  integrity sha512-FkPix00J9A/XWXv4VoKJBMeSkyY9x/TqIh76wzcdfl57RJJcf8CehQ08uwfhCDNtRQYtHQKBTwKZDEyjE13Lwg==
+"@babel/plugin-transform-reserved-words@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.12.13.tgz#7d9988d4f06e0fe697ea1d9803188aa18b472695"
+  integrity sha512-xhUPzDXxZN1QfiOy/I5tyye+TRz6lA7z6xaT4CLOjPRMVg1ldRf0LHw0TDBpYL4vG78556WuHdyO9oi5UmzZBg==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.0.0"
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-typeof-symbol@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.2.0.tgz#117d2bcec2fbf64b4b59d1f9819894682d29f2b2"
-  integrity sha512-2LNhETWYxiYysBtrBTqL8+La0jIoQQnIScUJc74OYvUGRmkskNY4EzLCnjHBzdmb38wqtTaixpo1NctEcvMDZw==
+"@babel/plugin-transform-shorthand-properties@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz#db755732b70c539d504c6390d9ce90fe64aff7ad"
+  integrity sha512-xpL49pqPnLtf0tVluuqvzWIgLEhuPpZzvs2yabUHSKRNlN7ScYU7aMlmavOeyXJZKgZKQRBlh8rHbKiJDraTSw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
+    "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-unicode-regex@^7.2.0":
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.2.0.tgz#4eb8db16f972f8abb5062c161b8b115546ade08b"
-  integrity sha512-m48Y0lMhrbXEJnVUaYly29jRXbQ3ksxPrS1Tg8t+MHqzXhtBYAvI51euOBaoAlZLPHsieY9XPVMf80a5x0cPcA==
+"@babel/plugin-transform-spread@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz#84887710e273c1815ace7ae459f6f42a5d31d5fd"
+  integrity sha512-V6vkiXijjzYeFmQTr3dBxPtZYLPcUfY34DebOU27jIl2M/Y8Egm52Hw82CSjjPqd54GTlJs5x+CR7HeNr24ckg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/helper-regex" "^7.0.0"
-    regexpu-core "^4.1.3"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
 
-"@babel/preset-env@^7.0.0":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.2.3.tgz#948c8df4d4609c99c7e0130169f052ea6a7a8933"
-  integrity sha512-AuHzW7a9rbv5WXmvGaPX7wADxFkZIqKlbBh1dmZUQp4iwiPpkE/Qnrji6SC4UQCQzvWY/cpHET29eUhXS9cLPw==
+"@babel/plugin-transform-sticky-regex@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.12.13.tgz#760ffd936face73f860ae646fb86ee82f3d06d1f"
+  integrity sha512-Jc3JSaaWT8+fr7GRvQP02fKDsYk4K/lYwWq38r/UGfaxo89ajud321NH28KRQ7xy1Ybc0VUE5Pz8psjNNDUglg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/plugin-transform-template-literals@^7.13.0":
+  version "7.13.0"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz#a36049127977ad94438dee7443598d1cefdf409d"
+  integrity sha512-d67umW6nlfmr1iehCcBv69eSUSySk1EsIS8aTDX4Xo9qajAh6mYtcl4kJrBkGXuxZPEgVr7RVfAvNW6YQkd4Mw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.13.0"
+
+"@babel/plugin-transform-typeof-symbol@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.12.13.tgz#785dd67a1f2ea579d9c2be722de8c84cb85f5a7f"
+  integrity sha512-eKv/LmUJpMnu4npgfvs3LiHhJua5fo/CysENxa45YCQXZwKnGCQKAg87bvoqSW1fFT+HA32l03Qxsm8ouTY3ZQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/plugin-transform-unicode-escapes@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.12.13.tgz#840ced3b816d3b5127dd1d12dcedc5dead1a5e74"
+  integrity sha512-0bHEkdwJ/sN/ikBHfSmOXPypN/beiGqjo+o4/5K+vxEFNPRPdImhviPakMKG4x96l85emoa0Z6cDflsdBusZbw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/plugin-transform-unicode-regex@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.12.13.tgz#b52521685804e155b1202e83fc188d34bb70f5ac"
+  integrity sha512-mDRzSNY7/zopwisPZ5kM9XKCfhchqIYwAKRERtEnhYscZB79VRekuRSoYbN0+KVe3y8+q1h6A4svXtP7N+UoCA==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.12.13"
+
+"@babel/preset-env@^7.13.12":
+  version "7.13.12"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.13.12.tgz#6dff470478290582ac282fb77780eadf32480237"
+  integrity sha512-JzElc6jk3Ko6zuZgBtjOd01pf9yYDEIH8BcqVuYIuOkzOwDesoa/Nz4gIo4lBG6K861KTV9TvIgmFuT6ytOaAA==
+  dependencies:
+    "@babel/compat-data" "^7.13.12"
+    "@babel/helper-compilation-targets" "^7.13.10"
+    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-validator-option" "^7.12.17"
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.13.12"
+    "@babel/plugin-proposal-async-generator-functions" "^7.13.8"
+    "@babel/plugin-proposal-class-properties" "^7.13.0"
+    "@babel/plugin-proposal-dynamic-import" "^7.13.8"
+    "@babel/plugin-proposal-export-namespace-from" "^7.12.13"
+    "@babel/plugin-proposal-json-strings" "^7.13.8"
+    "@babel/plugin-proposal-logical-assignment-operators" "^7.13.8"
+    "@babel/plugin-proposal-nullish-coalescing-operator" "^7.13.8"
+    "@babel/plugin-proposal-numeric-separator" "^7.12.13"
+    "@babel/plugin-proposal-object-rest-spread" "^7.13.8"
+    "@babel/plugin-proposal-optional-catch-binding" "^7.13.8"
+    "@babel/plugin-proposal-optional-chaining" "^7.13.12"
+    "@babel/plugin-proposal-private-methods" "^7.13.0"
+    "@babel/plugin-proposal-unicode-property-regex" "^7.12.13"
+    "@babel/plugin-syntax-async-generators" "^7.8.4"
+    "@babel/plugin-syntax-class-properties" "^7.12.13"
+    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
+    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
+    "@babel/plugin-syntax-json-strings" "^7.8.3"
+    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
+    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
+    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
+    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
+    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
+    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
+    "@babel/plugin-syntax-top-level-await" "^7.12.13"
+    "@babel/plugin-transform-arrow-functions" "^7.13.0"
+    "@babel/plugin-transform-async-to-generator" "^7.13.0"
+    "@babel/plugin-transform-block-scoped-functions" "^7.12.13"
+    "@babel/plugin-transform-block-scoping" "^7.12.13"
+    "@babel/plugin-transform-classes" "^7.13.0"
+    "@babel/plugin-transform-computed-properties" "^7.13.0"
+    "@babel/plugin-transform-destructuring" "^7.13.0"
+    "@babel/plugin-transform-dotall-regex" "^7.12.13"
+    "@babel/plugin-transform-duplicate-keys" "^7.12.13"
+    "@babel/plugin-transform-exponentiation-operator" "^7.12.13"
+    "@babel/plugin-transform-for-of" "^7.13.0"
+    "@babel/plugin-transform-function-name" "^7.12.13"
+    "@babel/plugin-transform-literals" "^7.12.13"
+    "@babel/plugin-transform-member-expression-literals" "^7.12.13"
+    "@babel/plugin-transform-modules-amd" "^7.13.0"
+    "@babel/plugin-transform-modules-commonjs" "^7.13.8"
+    "@babel/plugin-transform-modules-systemjs" "^7.13.8"
+    "@babel/plugin-transform-modules-umd" "^7.13.0"
+    "@babel/plugin-transform-named-capturing-groups-regex" "^7.12.13"
+    "@babel/plugin-transform-new-target" "^7.12.13"
+    "@babel/plugin-transform-object-super" "^7.12.13"
+    "@babel/plugin-transform-parameters" "^7.13.0"
+    "@babel/plugin-transform-property-literals" "^7.12.13"
+    "@babel/plugin-transform-regenerator" "^7.12.13"
+    "@babel/plugin-transform-reserved-words" "^7.12.13"
+    "@babel/plugin-transform-shorthand-properties" "^7.12.13"
+    "@babel/plugin-transform-spread" "^7.13.0"
+    "@babel/plugin-transform-sticky-regex" "^7.12.13"
+    "@babel/plugin-transform-template-literals" "^7.13.0"
+    "@babel/plugin-transform-typeof-symbol" "^7.12.13"
+    "@babel/plugin-transform-unicode-escapes" "^7.12.13"
+    "@babel/plugin-transform-unicode-regex" "^7.12.13"
+    "@babel/preset-modules" "^0.1.4"
+    "@babel/types" "^7.13.12"
+    babel-plugin-polyfill-corejs2 "^0.1.4"
+    babel-plugin-polyfill-corejs3 "^0.1.3"
+    babel-plugin-polyfill-regenerator "^0.1.2"
+    core-js-compat "^3.9.0"
+    semver "^6.3.0"
+
+"@babel/preset-modules@^0.1.4":
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.4.tgz#362f2b68c662842970fdb5e254ffc8fc1c2e415e"
+  integrity sha512-J36NhwnfdzpmH41M1DrnkkgAqhZaqr/NBdPfQ677mLzlaXo+oDiv1deyCDtgAhz8p328otdob0Du7+xgHGZbKg==
   dependencies:
-    "@babel/helper-module-imports" "^7.0.0"
     "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-proposal-async-generator-functions" "^7.2.0"
-    "@babel/plugin-proposal-json-strings" "^7.2.0"
-    "@babel/plugin-proposal-object-rest-spread" "^7.2.0"
-    "@babel/plugin-proposal-optional-catch-binding" "^7.2.0"
-    "@babel/plugin-proposal-unicode-property-regex" "^7.2.0"
-    "@babel/plugin-syntax-async-generators" "^7.2.0"
-    "@babel/plugin-syntax-object-rest-spread" "^7.2.0"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.2.0"
-    "@babel/plugin-transform-arrow-functions" "^7.2.0"
-    "@babel/plugin-transform-async-to-generator" "^7.2.0"
-    "@babel/plugin-transform-block-scoped-functions" "^7.2.0"
-    "@babel/plugin-transform-block-scoping" "^7.2.0"
-    "@babel/plugin-transform-classes" "^7.2.0"
-    "@babel/plugin-transform-computed-properties" "^7.2.0"
-    "@babel/plugin-transform-destructuring" "^7.2.0"
-    "@babel/plugin-transform-dotall-regex" "^7.2.0"
-    "@babel/plugin-transform-duplicate-keys" "^7.2.0"
-    "@babel/plugin-transform-exponentiation-operator" "^7.2.0"
-    "@babel/plugin-transform-for-of" "^7.2.0"
-    "@babel/plugin-transform-function-name" "^7.2.0"
-    "@babel/plugin-transform-literals" "^7.2.0"
-    "@babel/plugin-transform-modules-amd" "^7.2.0"
-    "@babel/plugin-transform-modules-commonjs" "^7.2.0"
-    "@babel/plugin-transform-modules-systemjs" "^7.2.0"
-    "@babel/plugin-transform-modules-umd" "^7.2.0"
-    "@babel/plugin-transform-new-target" "^7.0.0"
-    "@babel/plugin-transform-object-super" "^7.2.0"
-    "@babel/plugin-transform-parameters" "^7.2.0"
-    "@babel/plugin-transform-regenerator" "^7.0.0"
-    "@babel/plugin-transform-shorthand-properties" "^7.2.0"
-    "@babel/plugin-transform-spread" "^7.2.0"
-    "@babel/plugin-transform-sticky-regex" "^7.2.0"
-    "@babel/plugin-transform-template-literals" "^7.2.0"
-    "@babel/plugin-transform-typeof-symbol" "^7.2.0"
-    "@babel/plugin-transform-unicode-regex" "^7.2.0"
-    browserslist "^4.3.4"
-    invariant "^2.2.2"
-    js-levenshtein "^1.1.3"
-    semver "^5.3.0"
+    "@babel/plugin-proposal-unicode-property-regex" "^7.4.4"
+    "@babel/plugin-transform-dotall-regex" "^7.4.4"
+    "@babel/types" "^7.4.4"
+    esutils "^2.0.2"
 
-"@babel/register@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.0.0.tgz#fa634bae1bfa429f60615b754fc1f1d745edd827"
-  integrity sha512-f/+CRmaCe7rVEvcvPvxeA8j5aJhHC3aJie7YuqcMDhUOuyWLA7J/aNrTaHIzoWPEhpHA54mec4Mm8fv8KBlv3g==
+"@babel/register@^7.13.14":
+  version "7.13.14"
+  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.13.14.tgz#bbfa8f4f027c2ebc432e8e69e078b632605f2d9b"
+  integrity sha512-iyw0hUwjh/fzN8qklVqZodbyWjEBOG0KdDnBOpv3zzIgK3NmuRXBmIXH39ZBdspkn8LTHvSboN+oYb4MT43+9Q==
   dependencies:
-    core-js "^2.5.7"
-    find-cache-dir "^1.0.0"
-    home-or-tmp "^3.0.0"
-    lodash "^4.17.10"
-    mkdirp "^0.5.1"
+    find-cache-dir "^2.0.0"
+    lodash "^4.17.19"
+    make-dir "^2.1.0"
     pirates "^4.0.0"
-    source-map-support "^0.5.9"
+    source-map-support "^0.5.16"
+
+"@babel/runtime@^7.8.4":
+  version "7.13.10"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.13.10.tgz#47d42a57b6095f4468da440388fdbad8bebf0d7d"
+  integrity sha512-4QPkjJq6Ns3V/RgpEahRk+AGfL0eO6RHHtTWoNNr5mO49G6B5+X6d6THgWEAvTrznU5xYpbAlVKRYcsCgh/Akw==
+  dependencies:
+    regenerator-runtime "^0.13.4"
 
-"@babel/template@^7.0.0", "@babel/template@^7.1.0", "@babel/template@^7.1.2", "@babel/template@^7.2.2":
+"@babel/template@^7.0.0", "@babel/template@^7.1.0":
   version "7.2.2"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.2.2.tgz#005b3fdf0ed96e88041330379e0da9a708eb2907"
   integrity sha512-zRL0IMM02AUDwghf5LMSSDEz7sBCO2YnNmpg3uWTZj/v1rcG2BmQUvaGU8GhU8BvfMh1k2KIAYZ7Ji9KXPUg7g==
@@ -632,7 +908,16 @@
     "@babel/parser" "^7.2.2"
     "@babel/types" "^7.2.2"
 
-"@babel/traverse@^7.0.0", "@babel/traverse@^7.1.0", "@babel/traverse@^7.1.5", "@babel/traverse@^7.2.2", "@babel/traverse@^7.2.3":
+"@babel/template@^7.12.13":
+  version "7.12.13"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.12.13.tgz#530265be8a2589dbb37523844c5bcb55947fb327"
+  integrity sha512-/7xxiGA57xMo/P2GVvdEumr8ONhFOhfgq2ihK3h1e6THqzTAkHbkXgB0xI9yeTfIUoH3+oAeHhqm/I43OTbbjA==
+  dependencies:
+    "@babel/code-frame" "^7.12.13"
+    "@babel/parser" "^7.12.13"
+    "@babel/types" "^7.12.13"
+
+"@babel/traverse@^7.0.0":
   version "7.2.3"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.2.3.tgz#7ff50cefa9c7c0bd2d81231fdac122f3957748d8"
   integrity sha512-Z31oUD/fJvEWVR0lNZtfgvVt512ForCTNKYcJBGbPb1QZfve4WGH8Wsy7+Mev33/45fhP/hwQtvgusNdcCMgSw==
@@ -647,7 +932,21 @@
     globals "^11.1.0"
     lodash "^4.17.10"
 
-"@babel/types@^7.0.0", "@babel/types@^7.2.0", "@babel/types@^7.2.2":
+"@babel/traverse@^7.13.0", "@babel/traverse@^7.13.13":
+  version "7.13.13"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.13.13.tgz#39aa9c21aab69f74d948a486dd28a2dbdbf5114d"
+  integrity sha512-CblEcwmXKR6eP43oQGG++0QMTtCjAsa3frUuzHoiIJWpaIIi8dwMyEFUJoXRLxagGqCK+jALRwIO+o3R9p/uUg==
+  dependencies:
+    "@babel/code-frame" "^7.12.13"
+    "@babel/generator" "^7.13.9"
+    "@babel/helper-function-name" "^7.12.13"
+    "@babel/helper-split-export-declaration" "^7.12.13"
+    "@babel/parser" "^7.13.13"
+    "@babel/types" "^7.13.13"
+    debug "^4.1.0"
+    globals "^11.1.0"
+
+"@babel/types@^7.0.0", "@babel/types@^7.2.2":
   version "7.2.2"
   resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.2.2.tgz#44e10fc24e33af524488b716cdaee5360ea8ed1e"
   integrity sha512-fKCuD6UFUMkR541eDWL+2ih/xFZBXPOg/7EQFeTluMDebfqR4jrpaCjLhkWlQS4hT6nRa2PMEgXKbRB5/H2fpg==
@@ -656,7 +955,7 @@
     lodash "^4.17.10"
     to-fast-properties "^2.0.0"
 
-"@babel/types@^7.13.12":
+"@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.13.13", "@babel/types@^7.13.14", "@babel/types@^7.4.4":
   version "7.13.14"
   resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.14.tgz#c35a4abb15c7cd45a2746d78ab328e362cbace0d"
   integrity sha512-A2aa3QTkWoyqsZZFl56MLUsfmh7O0gN41IPvXAE/++8ojpbz12SszD7JEGYVdn4f9Kt4amIei07swF1h4AqmmQ==
@@ -665,6 +964,21 @@
     lodash "^4.17.19"
     to-fast-properties "^2.0.0"
 
+"@eslint/eslintrc@^0.4.0":
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.0.tgz#99cc0a0584d72f1df38b900fb062ba995f395547"
+  integrity sha512-2ZPCc+uNbjV5ERJr+aKSPRwZgKd2z11x0EgLvb1PURmUrn9QNRXFqje0Ldq454PfAVyaJYyrDvvIKSFP4NnBog==
+  dependencies:
+    ajv "^6.12.4"
+    debug "^4.1.1"
+    espree "^7.3.0"
+    globals "^12.1.0"
+    ignore "^4.0.6"
+    import-fresh "^3.2.1"
+    js-yaml "^3.13.1"
+    minimatch "^3.0.4"
+    strip-json-comments "^3.1.1"
+
 "@iamstarkov/listr-update-renderer@0.4.1":
   version "0.4.1"
   resolved "https://registry.yarnpkg.com/@iamstarkov/listr-update-renderer/-/listr-update-renderer-0.4.1.tgz#d7c48092a2dcf90fd672b6c8b458649cb350c77e"
@@ -679,6 +993,27 @@
     log-update "^2.3.0"
     strip-ansi "^3.0.1"
 
+"@nodelib/fs.scandir@2.1.4":
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69"
+  integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==
+  dependencies:
+    "@nodelib/fs.stat" "2.0.4"
+    run-parallel "^1.1.9"
+
+"@nodelib/fs.stat@2.0.4", "@nodelib/fs.stat@^2.0.2":
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz#a3f2dd61bab43b8db8fa108a121cfffe4c676655"
+  integrity sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q==
+
+"@nodelib/fs.walk@^1.2.3":
+  version "1.2.6"
+  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz#cce9396b30aa5afe9e3756608f5831adcb53d063"
+  integrity sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow==
+  dependencies:
+    "@nodelib/fs.scandir" "2.1.4"
+    fastq "^1.6.0"
+
 "@rollup/plugin-alias@^3.1.2":
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-3.1.2.tgz#c585b05be4a7782d269c69d13def56f44e417772"
@@ -787,6 +1122,11 @@
   resolved "https://registry.yarnpkg.com/@types/jasmine/-/jasmine-3.6.9.tgz#8785870f87839b7d91b45d7b226380f28dee5d9f"
   integrity sha512-B53NIwMj/AO0O+xfSWLYmKB0Mo6TYxfv2Mk8/c1T2w/e38t55iaPR6p7pHXTTtqfTmevPK3i8T1YweYFTZlxDw==
 
+"@types/json-schema@^7.0.3":
+  version "7.0.7"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"
+  integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==
+
 "@types/mocha@^8.2.2":
   version "8.2.2"
   resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-8.2.2.tgz#91daa226eb8c2ff261e6a8cbf8c7304641e095e0"
@@ -832,6 +1172,76 @@
     "@types/uglify-js" "*"
     source-map "^0.6.0"
 
+"@typescript-eslint/eslint-plugin@^4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.21.0.tgz#3fce2bfa76d95c00ac4f33dff369cb593aab8878"
+  integrity sha512-FPUyCPKZbVGexmbCFI3EQHzCZdy2/5f+jv6k2EDljGdXSRc0cKvbndd2nHZkSLqCNOPk0jB6lGzwIkglXcYVsQ==
+  dependencies:
+    "@typescript-eslint/experimental-utils" "4.21.0"
+    "@typescript-eslint/scope-manager" "4.21.0"
+    debug "^4.1.1"
+    functional-red-black-tree "^1.0.1"
+    lodash "^4.17.15"
+    regexpp "^3.0.0"
+    semver "^7.3.2"
+    tsutils "^3.17.1"
+
+"@typescript-eslint/experimental-utils@4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.21.0.tgz#0b0bb7c15d379140a660c003bdbafa71ae9134b6"
+  integrity sha512-cEbgosW/tUFvKmkg3cU7LBoZhvUs+ZPVM9alb25XvR0dal4qHL3SiUqHNrzoWSxaXA9gsifrYrS1xdDV6w/gIA==
+  dependencies:
+    "@types/json-schema" "^7.0.3"
+    "@typescript-eslint/scope-manager" "4.21.0"
+    "@typescript-eslint/types" "4.21.0"
+    "@typescript-eslint/typescript-estree" "4.21.0"
+    eslint-scope "^5.0.0"
+    eslint-utils "^2.0.0"
+
+"@typescript-eslint/parser@^4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.21.0.tgz#a227fc2af4001668c3e3f7415d4feee5093894c1"
+  integrity sha512-eyNf7QmE5O/l1smaQgN0Lj2M/1jOuNg2NrBm1dqqQN0sVngTLyw8tdCbih96ixlhbF1oINoN8fDCyEH9SjLeIA==
+  dependencies:
+    "@typescript-eslint/scope-manager" "4.21.0"
+    "@typescript-eslint/types" "4.21.0"
+    "@typescript-eslint/typescript-estree" "4.21.0"
+    debug "^4.1.1"
+
+"@typescript-eslint/scope-manager@4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.21.0.tgz#c81b661c4b8af1ec0c010d847a8f9ab76ab95b4d"
+  integrity sha512-kfOjF0w1Ix7+a5T1knOw00f7uAP9Gx44+OEsNQi0PvvTPLYeXJlsCJ4tYnDj5PQEYfpcgOH5yBlw7K+UEI9Agw==
+  dependencies:
+    "@typescript-eslint/types" "4.21.0"
+    "@typescript-eslint/visitor-keys" "4.21.0"
+
+"@typescript-eslint/types@4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.21.0.tgz#abdc3463bda5d31156984fa5bc316789c960edef"
+  integrity sha512-+OQaupjGVVc8iXbt6M1oZMwyKQNehAfLYJJ3SdvnofK2qcjfor9pEM62rVjBknhowTkh+2HF+/KdRAc/wGBN2w==
+
+"@typescript-eslint/typescript-estree@4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.21.0.tgz#3817bd91857beeaeff90f69f1f112ea58d350b0a"
+  integrity sha512-ZD3M7yLaVGVYLw4nkkoGKumb7Rog7QID9YOWobFDMQKNl+vPxqVIW/uDk+MDeGc+OHcoG2nJ2HphwiPNajKw3w==
+  dependencies:
+    "@typescript-eslint/types" "4.21.0"
+    "@typescript-eslint/visitor-keys" "4.21.0"
+    debug "^4.1.1"
+    globby "^11.0.1"
+    is-glob "^4.0.1"
+    semver "^7.3.2"
+    tsutils "^3.17.1"
+
+"@typescript-eslint/visitor-keys@4.21.0":
+  version "4.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.21.0.tgz#990a9acdc124331f5863c2cf21c88ba65233cd8d"
+  integrity sha512-dH22dROWGi5Z6p+Igc8bLVLmwy7vEe8r+8c+raPQU0LxgogPUrRAtRGtvBWmlr9waTu3n+QLt/qrS/hWzk1x5w==
+  dependencies:
+    "@typescript-eslint/types" "4.21.0"
+    eslint-visitor-keys "^2.0.0"
+
 "@webassemblyjs/ast@1.7.11":
   version "1.7.11"
   resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.7.11.tgz#b988582cafbb2b095e8b556526f30c90d057cace"
@@ -1023,12 +1433,7 @@ acorn-dynamic-import@^4.0.0:
   resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz#482210140582a36b83c3e342e1cfebcaa9240948"
   integrity sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==
 
-acorn-jsx@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.0.1.tgz#32a064fd925429216a09b141102bfdd185fae40e"
-  integrity sha512-HJ7CfNHrfJLlNTzIEUTj43LNWGkqpRLxm3YjAlcD0ACydk9XynzYsCBHxut+iqt+1aBXkx9UP/w/ZqMr13XIzg==
-
-acorn-jsx@^5.2.0:
+acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
   version "5.3.1"
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
   integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==
@@ -1038,16 +1443,16 @@ acorn@^5.0.0, acorn@^5.2.1, acorn@^5.6.2:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.3.tgz#67aa231bf8812974b85235a96771eb6bd07ea279"
   integrity sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==
 
-acorn@^6.0.2:
-  version "6.0.5"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.0.5.tgz#81730c0815f3f3b34d8efa95cb7430965f4d887a"
-  integrity sha512-i33Zgp3XWtmZBMNvCr4azvOFeWVw1Rk6p3hfi3LUDvIFraOMywb1kAtrbi+med14m4Xfpqm3zRZMT+c0FNE7kg==
-
 acorn@^6.4.1:
   version "6.4.2"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
   integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
 
+acorn@^7.4.0:
+  version "7.4.1"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
+  integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
+
 adm-zip@~0.4.3:
   version "0.4.13"
   resolved "https://registry.yarnpkg.com/adm-zip/-/adm-zip-0.4.13.tgz#597e2f8cc3672151e1307d3e95cddbc75672314a"
@@ -1083,7 +1488,7 @@ ajv-keywords@^3.1.0:
   resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.2.0.tgz#e86b819c602cf8821ad637413698f1dec021847a"
   integrity sha1-6GuBnGAs+IIa1jdBNpjx3sAhhHo=
 
-ajv@^6.1.0, ajv@^6.5.3, ajv@^6.5.5, ajv@^6.6.1:
+ajv@^6.1.0, ajv@^6.5.5:
   version "6.6.2"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.6.2.tgz#caceccf474bf3fc3ce3b147443711a24063cc30d"
   integrity sha512-FBHEW6Jf5TB9MGBgUUA9XHkTbjXYfAUjY43ACMfmdMRHniyoMHjHjzD50OK8LGDWQwp4rWEsIq5kEqq7rvIM1g==
@@ -1093,6 +1498,26 @@ ajv@^6.1.0, ajv@^6.5.3, ajv@^6.5.5, ajv@^6.6.1:
     json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
+ajv@^6.10.0, ajv@^6.12.4:
+  version "6.12.6"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
+  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
+    uri-js "^4.2.2"
+
+ajv@^8.0.1:
+  version "8.0.5"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.0.5.tgz#f07d6fdeffcdbb80485570ce3f1bc845fcc812b9"
+  integrity sha512-RkiLa/AeJx7+9OvniQ/qeWu0w74A8DiPPBclQ6ji3ZQkv5KamO+QGpqmi7O4JIw3rHGUXZ6CoP9tsAkn3gyazg==
+  dependencies:
+    fast-deep-equal "^3.1.1"
+    json-schema-traverse "^1.0.0"
+    require-from-string "^2.0.2"
+    uri-js "^4.2.2"
+
 amdefine@>=0.0.4:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
@@ -1103,6 +1528,11 @@ ansi-colors@^3.0.0:
   resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.3.tgz#57d35b8686e851e2cc04c403f1c00203976a1813"
   integrity sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==
 
+ansi-colors@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
+  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
+
 ansi-escapes@^1.1.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-1.4.0.tgz#d3a8a83b319aa67793662b13e761c7911422306e"
@@ -1123,10 +1553,10 @@ ansi-regex@^3.0.0:
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
   integrity sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=
 
-ansi-regex@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.0.0.tgz#70de791edf021404c3fd615aa89118ae0432e5a9"
-  integrity sha512-iB5Dda8t/UqpPI/IjsejXu5jOGDrzn41wJyljwPH65VCIbk6+1BzFIMJGFwTNrYXT1CrD+B4l19U7awiQ8rk7w==
+ansi-regex@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75"
+  integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==
 
 ansi-styles@^2.2.1:
   version "2.2.1"
@@ -1140,7 +1570,7 @@ ansi-styles@^3.2.0, ansi-styles@^3.2.1:
   dependencies:
     color-convert "^1.9.0"
 
-ansi-styles@^4.1.0:
+ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
   integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
@@ -1229,6 +1659,11 @@ array-union@^1.0.1:
   dependencies:
     array-uniq "^1.0.1"
 
+array-union@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
+  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
+
 array-uniq@^1.0.1:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
@@ -1297,10 +1732,10 @@ ast-types@0.x.x:
   resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.11.7.tgz#f318bf44e339db6a320be0009ded64ec1471f46c"
   integrity sha512-2mP3TwtkY/aTv5X3ZsMpNAbOnyoC/aMJwJSoaELPkHId0nSQgFcnU4dRW3isxiz7+zBexk0ym3WNVjMiQBnJSw==
 
-astral-regex@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-1.0.0.tgz#6c8c3fb827dd43ee3918f27b82782ab7658a6fd9"
-  integrity sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg==
+astral-regex@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
+  integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
 
 async-each@^1.0.0:
   version "1.0.1"
@@ -1413,14 +1848,45 @@ babel-messages@^6.23.0:
   dependencies:
     babel-runtime "^6.22.0"
 
+babel-plugin-dynamic-import-node@^2.3.3:
+  version "2.3.3"
+  resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz#84fda19c976ec5c6defef57f9427b3def66e17a3"
+  integrity sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==
+  dependencies:
+    object.assign "^4.1.0"
+
 babel-plugin-istanbul@^5.1.0:
   version "5.1.0"
   resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-5.1.0.tgz#6892f529eff65a3e2d33d87dc5888ffa2ecd4a30"
   integrity sha512-CLoXPRSUWiR8yao8bShqZUIC6qLfZVVY3X1wj+QPNXu0wfmrRRfarh1LYy+dYMVI+bDj0ghy3tuqFFRFZmL1Nw==
   dependencies:
-    find-up "^3.0.0"
-    istanbul-lib-instrument "^3.0.0"
-    test-exclude "^5.0.0"
+    find-up "^3.0.0"
+    istanbul-lib-instrument "^3.0.0"
+    test-exclude "^5.0.0"
+
+babel-plugin-polyfill-corejs2@^0.1.4:
+  version "0.1.10"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.1.10.tgz#a2c5c245f56c0cac3dbddbf0726a46b24f0f81d1"
+  integrity sha512-DO95wD4g0A8KRaHKi0D51NdGXzvpqVLnLu5BTvDlpqUEpTmeEtypgC1xqesORaWmiUOQI14UHKlzNd9iZ2G3ZA==
+  dependencies:
+    "@babel/compat-data" "^7.13.0"
+    "@babel/helper-define-polyfill-provider" "^0.1.5"
+    semver "^6.1.1"
+
+babel-plugin-polyfill-corejs3@^0.1.3:
+  version "0.1.7"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.1.7.tgz#80449d9d6f2274912e05d9e182b54816904befd0"
+  integrity sha512-u+gbS9bbPhZWEeyy1oR/YaaSpod/KDT07arZHb80aTpl8H5ZBq+uN1nN9/xtX7jQyfLdPfoqI4Rue/MQSWJquw==
+  dependencies:
+    "@babel/helper-define-polyfill-provider" "^0.1.5"
+    core-js-compat "^3.8.1"
+
+babel-plugin-polyfill-regenerator@^0.1.2:
+  version "0.1.6"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.1.6.tgz#0fe06a026fe0faa628ccc8ba3302da0a6ce02f3f"
+  integrity sha512-OUrYG9iKPKz8NxswXbRAdSwF0GhRdIEMTloQATJi4bDuFqrXaXcCUT/VGNrr8pBcjMh1RxZ7Xt9cytVJTJfvMg==
+  dependencies:
+    "@babel/helper-define-polyfill-provider" "^0.1.5"
 
 babel-plugin-syntax-class-properties@^6.8.0:
   version "6.13.0"
@@ -1738,14 +2204,16 @@ browserify-zlib@^0.2.0:
   dependencies:
     pako "~1.0.5"
 
-browserslist@^4.3.4:
-  version "4.3.7"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.3.7.tgz#f1de479a6466ea47a0a26dcc725e7504817e624a"
-  integrity sha512-pWQv51Ynb0MNk9JGMCZ8VkM785/4MQNXiFYtPqI7EEP0TJO+/d/NqRVn1uiAN0DNbnlUSpL2sh16Kspasv3pUQ==
+browserslist@^4.14.5, browserslist@^4.16.3:
+  version "4.16.3"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.3.tgz#340aa46940d7db878748567c5dea24a48ddf3717"
+  integrity sha512-vIyhWmIkULaq04Gt93txdh+j02yX/JzlyhLYbV3YQCn/zvES3JnY7TifHHvvr1w5hTDluNKMkV05cs4vy8Q7sw==
   dependencies:
-    caniuse-lite "^1.0.30000925"
-    electron-to-chromium "^1.3.96"
-    node-releases "^1.1.3"
+    caniuse-lite "^1.0.30001181"
+    colorette "^1.2.1"
+    electron-to-chromium "^1.3.649"
+    escalade "^3.1.1"
+    node-releases "^1.1.70"
 
 buble@^0.19.3:
   version "0.19.6"
@@ -1871,6 +2339,14 @@ cachedir@^1.1.0:
   dependencies:
     os-homedir "^1.0.1"
 
+call-bind@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
+  integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
+  dependencies:
+    function-bind "^1.1.1"
+    get-intrinsic "^1.0.2"
+
 callsite@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/callsite/-/callsite-1.0.0.tgz#280398e5d664bd74038b6f0905153e6e8af1bc20"
@@ -1908,10 +2384,10 @@ camelcase@^4.1.0:
   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd"
   integrity sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=
 
-caniuse-lite@^1.0.30000925:
-  version "1.0.30000927"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30000927.tgz#114a9de4ff1e01f5790fe578ecd93421c7524665"
-  integrity sha512-ogq4NbUWf1uG/j66k0AmiO3GjqJAlQyF8n4w8a954cbCyFKmYGvRtgz6qkq2fWuduTXHibX7GyYL5Pg58Aks2g==
+caniuse-lite@^1.0.30001181:
+  version "1.0.30001207"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001207.tgz#364d47d35a3007e528f69adb6fecb07c2bb2cc50"
+  integrity sha512-UPQZdmAsyp2qfCTiMU/zqGSWOYaY9F9LL61V8f+8MrubsaDGpaHD9HRV/EWZGULZn0Hxu48SKzI5DgFwTvHuYw==
 
 caseless@~0.12.0:
   version "0.12.0"
@@ -1946,7 +2422,7 @@ chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4
     escape-string-regexp "^1.0.5"
     supports-color "^5.3.0"
 
-chalk@^4.1.0:
+chalk@^4.0.0, chalk@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
   integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
@@ -1959,11 +2435,6 @@ chardet@^0.4.0:
   resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
   integrity sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=
 
-chardet@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
-  integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
-
 chokidar@^2.0.2, chokidar@^2.0.3:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.0.4.tgz#356ff4e2b0e8e43e322d18a372460bbcf3accd26"
@@ -2020,11 +2491,6 @@ cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
     inherits "^2.0.1"
     safe-buffer "^5.0.1"
 
-circular-json@^0.3.1:
-  version "0.3.3"
-  resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.3.3.tgz#815c99ea84f6809529d2f45791bdf82711352d66"
-  integrity sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==
-
 circular-json@^0.5.5:
   version "0.5.9"
   resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.5.9.tgz#932763ae88f4f7dead7a0d09c8a51a4743a53b1d"
@@ -2120,6 +2586,11 @@ color-name@~1.1.4:
   resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
+colorette@^1.2.1:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
+  integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
+
 colors@^1.1.0:
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.3.tgz#39e005d546afe01e01f9c4ca8fa50f686a01205d"
@@ -2406,10 +2877,10 @@ conventional-commits-parser@^2.1.7:
     through2 "^2.0.0"
     trim-off-newlines "^1.0.0"
 
-convert-source-map@^1.1.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.6.0.tgz#51b537a8c43e0f04dec1993bffcdd504e758ac20"
-  integrity sha512-eFu7XigvxdZ1ETfbgPBohgyQ/Z++C0eEhTor0qRwBw9unw+L0/6V8wkSuGgzdThkiS5lSpdptOQPD8Ak40a+7A==
+convert-source-map@^1.7.0:
+  version "1.7.0"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442"
+  integrity sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==
   dependencies:
     safe-buffer "~5.1.1"
 
@@ -2435,7 +2906,15 @@ copy-descriptor@^0.1.0:
   resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
   integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
 
-core-js@^2.2.0, core-js@^2.4.0, core-js@^2.5.7:
+core-js-compat@^3.8.1, core-js-compat@^3.9.0:
+  version "3.10.0"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.10.0.tgz#3600dc72869673c110215ee7a005a8609dea0fe1"
+  integrity sha512-9yVewub2MXNYyGvuLnMHcN1k9RkvB7/ofktpeKTIaASyB88YYqGzUnu0ywMMhJrDHOMiTjSHWGzR+i7Wb9Z1kQ==
+  dependencies:
+    browserslist "^4.16.3"
+    semver "7.0.0"
+
+core-js@^2.2.0, core-js@^2.4.0:
   version "2.6.1"
   resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.1.tgz#87416ae817de957a3f249b3b5ca475d4aaed6042"
   integrity sha512-L72mmmEayPJBejKIWe2pYtGis5r0tQ5NaJekdhyXgeMQTpJoBsH0NL4ElY2LfSoV15xeQWKQ+XTTOZdyero5Xg==
@@ -2515,6 +2994,15 @@ cross-spawn@^6.0.0, cross-spawn@^6.0.5:
     shebang-command "^1.2.0"
     which "^1.2.9"
 
+cross-spawn@^7.0.2:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
+  dependencies:
+    path-key "^3.1.0"
+    shebang-command "^2.0.0"
+    which "^2.0.1"
+
 crypto-browserify@^3.11.0:
   version "3.12.0"
   resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
@@ -2676,6 +3164,13 @@ debug@^4.0.1, debug@^4.1.0:
   dependencies:
     ms "^2.1.1"
 
+debug@^4.1.1:
+  version "4.3.1"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
+  integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
+  dependencies:
+    ms "2.1.2"
+
 debug@~3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
@@ -2733,7 +3228,7 @@ deepmerge@^4.2.2:
   resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955"
   integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==
 
-define-properties@^1.1.2:
+define-properties@^1.1.2, define-properties@^1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
   integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==
@@ -2844,10 +3339,17 @@ diffie-hellman@^5.0.0:
     miller-rabin "^4.0.0"
     randombytes "^2.0.0"
 
-doctrine@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d"
-  integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==
+dir-glob@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
+  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
+  dependencies:
+    path-type "^4.0.0"
+
+doctrine@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
+  integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
   dependencies:
     esutils "^2.0.2"
 
@@ -2911,10 +3413,10 @@ ejs@2.5.7:
   resolved "https://registry.yarnpkg.com/ejs/-/ejs-2.5.7.tgz#cc872c168880ae3c7189762fd5ffc00896c9518a"
   integrity sha1-zIcsFoiArjxxiXYv1f/ACJbJUYo=
 
-electron-to-chromium@^1.3.96:
-  version "1.3.98"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.98.tgz#f200bdac84b1110d7d9904f34f4fc6d5573a8a9c"
-  integrity sha512-WIZdNuvE3dFr6kkPgv4d/cfswNZD6XbeLBM8baOIQTsnbf4xWrVEaLvp7oNnbnMWWXDqq7Tbv+H5JfciLTJm4Q==
+electron-to-chromium@^1.3.649:
+  version "1.3.708"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.708.tgz#127970d2fc665ab356be59e668f2914856419176"
+  integrity sha512-+A8ggYZ5riOLMcVAuzHx6bforaPzaiLnW1QOMD2SlMYQVi7QQTyQ/WrlZoebIH9ikmgr+tLJGpNITFFCUiQcPw==
 
 elegant-spinner@^1.0.1:
   version "1.0.1"
@@ -2934,6 +3436,11 @@ elliptic@^6.0.0:
     minimalistic-assert "^1.0.1"
     minimalistic-crypto-utils "^1.0.1"
 
+emoji-regex@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
+  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
+
 emojis-list@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-2.1.0.tgz#4daa4d9db00f9819880c79fa457ae5b09a1fd389"
@@ -3021,6 +3528,13 @@ enhanced-resolve@^4.1.0:
     memory-fs "^0.4.0"
     tapable "^1.0.0"
 
+enquirer@^2.3.5:
+  version "2.3.6"
+  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
+  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
+  dependencies:
+    ansi-colors "^4.1.1"
+
 ent@~2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/ent/-/ent-2.2.0.tgz#e964219325a21d05f44466a2f686ed6ce5f5dd1d"
@@ -3078,6 +3592,11 @@ es6-promisify@^5.0.0:
   dependencies:
     es6-promise "^4.0.3"
 
+escalade@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
+  integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
+
 escape-html@~1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
@@ -3140,69 +3659,87 @@ eslint-scope@^4.0.0:
     esrecurse "^4.1.0"
     estraverse "^4.1.1"
 
-eslint-utils@^1.3.1:
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.2.tgz#166a5180ef6ab7eb462f162fd0e6f2463d7309ab"
-  integrity sha512-eAZS2sEUMlIeCjBeubdj45dmBHQwPHWyBcT1VSYB7o9x9WRRqKxyUoiXlRjyAwzN7YEzHJlYg0NmzDRWx6GP4Q==
+eslint-scope@^5.0.0, eslint-scope@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
+  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
+  dependencies:
+    esrecurse "^4.3.0"
+    estraverse "^4.1.1"
+
+eslint-utils@^2.0.0, eslint-utils@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-2.1.0.tgz#d2de5e03424e707dc10c74068ddedae708741b27"
+  integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==
   dependencies:
-    eslint-visitor-keys "^1.0.0"
+    eslint-visitor-keys "^1.1.0"
 
 eslint-visitor-keys@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz#e2a82cea84ff246ad6fb57f9bde5b46621459ec2"
   integrity sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==
 
-eslint@^5.7.0:
-  version "5.12.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-5.12.0.tgz#fab3b908f60c52671fb14e996a450b96c743c859"
-  integrity sha512-LntwyPxtOHrsJdcSwyQKVtHofPHdv+4+mFwEe91r2V13vqpM8yLr7b1sW+Oo/yheOPkWYsYlYJCkzlFAt8KV7g==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    ajv "^6.5.3"
-    chalk "^2.1.0"
-    cross-spawn "^6.0.5"
+eslint-visitor-keys@^1.1.0, eslint-visitor-keys@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e"
+  integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==
+
+eslint-visitor-keys@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz#21fdc8fbcd9c795cc0321f0563702095751511a8"
+  integrity sha512-QudtT6av5WXels9WjIM7qz1XD1cWGvX4gGXvp/zBn9nXG02D0utdU3Em2m/QjTnrsk6bBjmCygl3rmj118msQQ==
+
+eslint@^7.23.0:
+  version "7.23.0"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.23.0.tgz#8d029d252f6e8cf45894b4bee08f5493f8e94325"
+  integrity sha512-kqvNVbdkjzpFy0XOszNwjkKzZ+6TcwCQ/h+ozlcIWwaimBBuhlQ4nN6kbiM2L+OjDcznkTJxzYfRFH92sx4a0Q==
+  dependencies:
+    "@babel/code-frame" "7.12.11"
+    "@eslint/eslintrc" "^0.4.0"
+    ajv "^6.10.0"
+    chalk "^4.0.0"
+    cross-spawn "^7.0.2"
     debug "^4.0.1"
-    doctrine "^2.1.0"
-    eslint-scope "^4.0.0"
-    eslint-utils "^1.3.1"
-    eslint-visitor-keys "^1.0.0"
-    espree "^5.0.0"
-    esquery "^1.0.1"
+    doctrine "^3.0.0"
+    enquirer "^2.3.5"
+    eslint-scope "^5.1.1"
+    eslint-utils "^2.1.0"
+    eslint-visitor-keys "^2.0.0"
+    espree "^7.3.1"
+    esquery "^1.4.0"
     esutils "^2.0.2"
-    file-entry-cache "^2.0.0"
+    file-entry-cache "^6.0.1"
     functional-red-black-tree "^1.0.1"
-    glob "^7.1.2"
-    globals "^11.7.0"
+    glob-parent "^5.0.0"
+    globals "^13.6.0"
     ignore "^4.0.6"
     import-fresh "^3.0.0"
     imurmurhash "^0.1.4"
-    inquirer "^6.1.0"
-    js-yaml "^3.12.0"
+    is-glob "^4.0.0"
+    js-yaml "^3.13.1"
     json-stable-stringify-without-jsonify "^1.0.1"
-    levn "^0.3.0"
-    lodash "^4.17.5"
+    levn "^0.4.1"
+    lodash "^4.17.21"
     minimatch "^3.0.4"
-    mkdirp "^0.5.1"
     natural-compare "^1.4.0"
-    optionator "^0.8.2"
-    path-is-inside "^1.0.2"
-    pluralize "^7.0.0"
+    optionator "^0.9.1"
     progress "^2.0.0"
-    regexpp "^2.0.1"
-    semver "^5.5.1"
-    strip-ansi "^4.0.0"
-    strip-json-comments "^2.0.1"
-    table "^5.0.2"
+    regexpp "^3.1.0"
+    semver "^7.2.1"
+    strip-ansi "^6.0.0"
+    strip-json-comments "^3.1.0"
+    table "^6.0.4"
     text-table "^0.2.0"
+    v8-compile-cache "^2.0.3"
 
-espree@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-5.0.0.tgz#fc7f984b62b36a0f543b13fb9cd7b9f4a7f5b65c"
-  integrity sha512-1MpUfwsdS9MMoN7ZXqAr9e9UKdVHDcvrJpyx7mm1WuQlx/ygErEQBzgi5Nh5qBHIoYweprhtMkTCb9GhcAIcsA==
+espree@^7.3.0, espree@^7.3.1:
+  version "7.3.1"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-7.3.1.tgz#f2df330b752c6f55019f8bd89b7660039c1bbbb6"
+  integrity sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g==
   dependencies:
-    acorn "^6.0.2"
-    acorn-jsx "^5.0.0"
-    eslint-visitor-keys "^1.0.0"
+    acorn "^7.4.0"
+    acorn-jsx "^5.3.1"
+    eslint-visitor-keys "^1.3.0"
 
 esprima@2.7.x, esprima@^2.7.1:
   version "2.7.3"
@@ -3219,12 +3756,12 @@ esprima@^4.0.0:
   resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
-esquery@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.0.1.tgz#406c51658b1f5991a5f9b62b1dc25b00e3e5c708"
-  integrity sha512-SmiyZ5zIWH9VM+SRUReLS5Q8a7GxtRdxEBVZpm98rJM7Sb+A9DVCndXfkeFUd3byderg+EbDkfnevfCwynWaNA==
+esquery@^1.4.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5"
+  integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==
   dependencies:
-    estraverse "^4.0.0"
+    estraverse "^5.1.0"
 
 esrecurse@^4.1.0:
   version "4.2.1"
@@ -3233,16 +3770,28 @@ esrecurse@^4.1.0:
   dependencies:
     estraverse "^4.1.0"
 
+esrecurse@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
+  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
+  dependencies:
+    estraverse "^5.2.0"
+
 estraverse@^1.9.1:
   version "1.9.3"
   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-1.9.3.tgz#af67f2dc922582415950926091a4005d29c9bb44"
   integrity sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=
 
-estraverse@^4.0.0, estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0:
+estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
   integrity sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=
 
+estraverse@^5.1.0, estraverse@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.2.0.tgz#307df42547e6cc7324d3cf03c155d5cdb8c53880"
+  integrity sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==
+
 estree-walker@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-1.0.1.tgz#31bc5d612c96b704106b477e6dd5d8aa138cb700"
@@ -3401,15 +3950,6 @@ external-editor@^2.0.1:
     iconv-lite "^0.4.17"
     tmp "^0.0.33"
 
-external-editor@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-3.0.3.tgz#5866db29a97826dbe4bf3afd24070ead9ea43a27"
-  integrity sha512-bn71H9+qWoOQKyZDo25mOMVpSmXROAsTJVVVYzrrtol3d4y+AsKjf4Iwl2Q+IuT0kFSQ1qo166UuIwqYq7mGnA==
-  dependencies:
-    chardet "^0.7.0"
-    iconv-lite "^0.4.24"
-    tmp "^0.0.33"
-
 extglob@^0.3.1:
   version "0.3.2"
   resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1"
@@ -3456,16 +3996,40 @@ fast-deep-equal@^2.0.1:
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz#7b05218ddf9667bf7f370bf7fdb2cb15fdd0aa49"
   integrity sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=
 
+fast-deep-equal@^3.1.1:
+  version "3.1.3"
+  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
+  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
+
+fast-glob@^3.1.1:
+  version "3.2.5"
+  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.5.tgz#7939af2a656de79a4f1901903ee8adcaa7cb9661"
+  integrity sha512-2DtFcgT68wiTTiwZ2hNdJfcHNke9XOfnwmBRWXhmeKM8rF0TGwmC/Qto3S7RoZKp5cilZbxzO5iTNTQsJ+EeDg==
+  dependencies:
+    "@nodelib/fs.stat" "^2.0.2"
+    "@nodelib/fs.walk" "^1.2.3"
+    glob-parent "^5.1.0"
+    merge2 "^1.3.0"
+    micromatch "^4.0.2"
+    picomatch "^2.2.1"
+
 fast-json-stable-stringify@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz#d5142c0caee6b1189f87d3a76111064f86c8bbf2"
   integrity sha1-1RQsDK7msRifh9OnYREGT4bIu/I=
 
-fast-levenshtein@~2.0.4:
+fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.4:
   version "2.0.6"
   resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
   integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
 
+fastq@^1.6.0:
+  version "1.11.0"
+  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.11.0.tgz#bb9fb955a07130a918eb63c1f5161cc32a5d0858"
+  integrity sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==
+  dependencies:
+    reusify "^1.0.4"
+
 fd-slicer@~1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.0.1.tgz#8b5bcbd9ec327c5041bf9ab023fd6750f1177e65"
@@ -3493,13 +4057,12 @@ figures@^2.0.0:
   dependencies:
     escape-string-regexp "^1.0.5"
 
-file-entry-cache@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-2.0.0.tgz#c392990c3e684783d838b8c84a45d8a048458361"
-  integrity sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=
+file-entry-cache@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
+  integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
   dependencies:
-    flat-cache "^1.2.1"
-    object-assign "^4.0.1"
+    flat-cache "^3.0.4"
 
 file-loader@^3.0.1:
   version "3.0.1"
@@ -3560,15 +4123,6 @@ finalhandler@1.1.0:
     statuses "~1.3.1"
     unpipe "~1.0.0"
 
-find-cache-dir@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-1.0.0.tgz#9288e3e9e3cc3748717d39eade17cf71fc30ee6f"
-  integrity sha1-kojj6ePMN0hxfTnq3hfPcfww7m8=
-  dependencies:
-    commondir "^1.0.1"
-    make-dir "^1.0.0"
-    pkg-dir "^2.0.0"
-
 find-cache-dir@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-2.0.0.tgz#4c1faed59f45184530fb9d7fa123a4d04a98472d"
@@ -3613,7 +4167,7 @@ find-up@^1.0.0:
     path-exists "^2.0.0"
     pinkie-promise "^2.0.0"
 
-find-up@^2.0.0, find-up@^2.1.0:
+find-up@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
   integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c=
@@ -3645,21 +4199,24 @@ findup-sync@0.4.2:
     micromatch "^2.3.7"
     resolve-dir "^0.1.0"
 
-flat-cache@^1.2.1:
-  version "1.3.4"
-  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-1.3.4.tgz#2c2ef77525cc2929007dfffa1dd314aa9c9dee6f"
-  integrity sha512-VwyB3Lkgacfik2vhqR4uv2rvebqmDvFu4jlN/C1RzWoJEo8I7z4Q404oiqYCkq41mni8EzQnm95emU9seckwtg==
+flat-cache@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
+  integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
   dependencies:
-    circular-json "^0.3.1"
-    graceful-fs "^4.1.2"
-    rimraf "~2.6.2"
-    write "^0.2.1"
+    flatted "^3.1.0"
+    rimraf "^3.0.2"
 
 flatted@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/flatted/-/flatted-2.0.0.tgz#55122b6536ea496b4b44893ee2608141d10d9916"
   integrity sha512-R+H8IZclI8AAkSBRQJLVOsxwAoHd6WC40b4QTNWIjzAa6BXOBfQcM587MXDTVPeYaopFNWHUFLx7eNmHDSxMWg==
 
+flatted@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.1.1.tgz#c4b489e80096d9df1dfc97c79871aea7c617c469"
+  integrity sha512-zAoAQiudy+r5SvnSw3KJy5os/oRJYHzrzja/tBDqrZtNhUw8bt6y8OBzMWcjWr+8liV8Eb6yOhw8WZ7VFZ5ZzA==
+
 flow-bin@^0.61.0:
   version "0.61.0"
   resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.61.0.tgz#d0473a8c35dbbf4de573823f4932124397d32d35"
@@ -3825,6 +4382,20 @@ gauge@~2.7.3:
     strip-ansi "^3.0.1"
     wide-align "^1.1.0"
 
+gensync@^1.0.0-beta.2:
+  version "1.0.0-beta.2"
+  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
+  integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
+
+get-intrinsic@^1.0.2:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
+  integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==
+  dependencies:
+    function-bind "^1.1.1"
+    has "^1.0.3"
+    has-symbols "^1.0.1"
+
 get-own-enumerable-property-symbols@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.0.tgz#b877b49a5c16aefac3655f2ed2ea5b684df8d203"
@@ -3939,6 +4510,13 @@ glob-parent@^3.1.0:
     is-glob "^3.1.0"
     path-dirname "^1.0.0"
 
+glob-parent@^5.0.0, glob-parent@^5.1.0:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
+  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
+  dependencies:
+    is-glob "^4.0.1"
+
 glob@7.0.5:
   version "7.0.5"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.0.5.tgz#b4202a69099bbb4d292a7c1b95b6682b67ebdc95"
@@ -3974,7 +4552,7 @@ glob@^5.0.15:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-glob@^7.0.0, glob@^7.0.3, glob@^7.0.6, glob@^7.1.1, glob@^7.1.2, glob@^7.1.3:
+glob@^7.0.0, glob@^7.0.3, glob@^7.0.6, glob@^7.1.1, glob@^7.1.3:
   version "7.1.3"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.3.tgz#3960832d3f1574108342dafd3a67b332c0969df1"
   integrity sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==
@@ -4016,16 +4594,42 @@ global-prefix@^0.1.4:
     is-windows "^0.2.0"
     which "^1.2.12"
 
-globals@^11.1.0, globals@^11.7.0:
+globals@^11.1.0:
   version "11.9.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-11.9.0.tgz#bde236808e987f290768a93d065060d78e6ab249"
   integrity sha512-5cJVtyXWH8PiJPVLZzzoIizXx944O4OmRro5MWKx5fT4MgcN7OfaMutPeaTdJCCURwbWdhhcCWcKIffPnmTzBg==
 
+globals@^12.1.0:
+  version "12.4.0"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-12.4.0.tgz#a18813576a41b00a24a97e7f815918c2e19925f8"
+  integrity sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==
+  dependencies:
+    type-fest "^0.8.1"
+
+globals@^13.6.0:
+  version "13.7.0"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-13.7.0.tgz#aed3bcefd80ad3ec0f0be2cf0c895110c0591795"
+  integrity sha512-Aipsz6ZKRxa/xQkZhNg0qIWXT6x6rD46f6x/PCnBomlttdIyAPak4YD9jTmKpZ72uROSMU87qJtcgpgHaVchiA==
+  dependencies:
+    type-fest "^0.20.2"
+
 globals@^9.18.0:
   version "9.18.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a"
   integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==
 
+globby@^11.0.1:
+  version "11.0.3"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.3.tgz#9b1f0cb523e171dd1ad8c7b2a9fb4b644b9593cb"
+  integrity sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg==
+  dependencies:
+    array-union "^2.1.0"
+    dir-glob "^3.0.1"
+    fast-glob "^3.1.1"
+    ignore "^5.1.4"
+    merge2 "^1.3.0"
+    slash "^3.0.0"
+
 globby@^6.1.0:
   version "6.1.0"
   resolved "https://registry.yarnpkg.com/globby/-/globby-6.1.0.tgz#f5a6d70e8395e21c858fb0489d64df02424d506c"
@@ -4121,6 +4725,11 @@ has-symbols@^1.0.0:
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.0.tgz#ba1a8f1af2a0fc39650f5c850367704122063b44"
   integrity sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=
 
+has-symbols@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423"
+  integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==
+
 has-unicode@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
@@ -4207,11 +4816,6 @@ hmac-drbg@^1.0.1:
     minimalistic-assert "^1.0.0"
     minimalistic-crypto-utils "^1.0.1"
 
-home-or-tmp@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/home-or-tmp/-/home-or-tmp-3.0.0.tgz#57a8fe24cf33cdd524860a15821ddc25c86671fb"
-  integrity sha1-V6j+JM8zzdUkhgoVgh3cJchmcfs=
-
 homedir-polyfill@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz#4c2bbc8a758998feebf5ed68580f76d46768b4bc"
@@ -4306,7 +4910,7 @@ iconv-lite@0.4.23:
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
-iconv-lite@^0.4.17, iconv-lite@^0.4.24, iconv-lite@^0.4.4, iconv-lite@~0.4.13:
+iconv-lite@^0.4.17, iconv-lite@^0.4.4, iconv-lite@~0.4.13:
   version "0.4.24"
   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
@@ -4335,6 +4939,11 @@ ignore@^4.0.6:
   resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
   integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==
 
+ignore@^5.1.4:
+  version "5.1.8"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.8.tgz#f150a8b50a34289b33e22f5889abd4d8016f0e57"
+  integrity sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==
+
 immediate@~3.0.5:
   version "3.0.6"
   resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.0.6.tgz#9db1dbd0faf8de6fbe0f5dd5e56bb606280de69b"
@@ -4348,6 +4957,14 @@ import-fresh@^3.0.0:
     parent-module "^1.0.0"
     resolve-from "^4.0.0"
 
+import-fresh@^3.2.1:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
+  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
+  dependencies:
+    parent-module "^1.0.0"
+    resolve-from "^4.0.0"
+
 imurmurhash@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
@@ -4437,25 +5054,6 @@ inquirer@3.0.6:
     strip-ansi "^3.0.0"
     through "^2.3.6"
 
-inquirer@^6.1.0:
-  version "6.2.1"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-6.2.1.tgz#9943fc4882161bdb0b0c9276769c75b32dbfcd52"
-  integrity sha512-088kl3DRT2dLU5riVMKKr1DlImd6X7smDhpXUCkJDCKvTEJeRiXh0G132HG9u5a+6Ylw9plFRY7RuTnwohYSpg==
-  dependencies:
-    ansi-escapes "^3.0.0"
-    chalk "^2.0.0"
-    cli-cursor "^2.1.0"
-    cli-width "^2.0.0"
-    external-editor "^3.0.0"
-    figures "^2.0.0"
-    lodash "^4.17.10"
-    mute-stream "0.0.7"
-    run-async "^2.2.0"
-    rxjs "^6.1.0"
-    string-width "^2.1.0"
-    strip-ansi "^5.0.0"
-    through "^2.3.6"
-
 interpret@^1.0.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.2.0.tgz#d5061a6224be58e8083985f5014d844359576296"
@@ -4509,6 +5107,13 @@ is-binary-path@^1.0.0:
   dependencies:
     binary-extensions "^1.0.0"
 
+is-boolean-object@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.0.tgz#e2aaad3a3a8fca34c28f6eee135b156ed2587ff0"
+  integrity sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==
+  dependencies:
+    call-bind "^1.0.0"
+
 is-buffer@^1.1.5:
   version "1.1.6"
   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
@@ -4635,6 +5240,11 @@ is-fullwidth-code-point@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
   integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=
 
+is-fullwidth-code-point@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
+  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
+
 is-glob@^2.0.0, is-glob@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
@@ -4656,11 +5266,23 @@ is-glob@^4.0.0:
   dependencies:
     is-extglob "^2.1.1"
 
+is-glob@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
+  integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
+  dependencies:
+    is-extglob "^2.1.1"
+
 is-module@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
   integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=
 
+is-number-object@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.4.tgz#36ac95e741cf18b283fc1ddf5e83da798e3ec197"
+  integrity sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==
+
 is-number@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-0.1.1.tgz#69a7af116963d47206ec9bd9b48a14216f1e3806"
@@ -4772,6 +5394,11 @@ is-stream@^1.0.1, is-stream@^1.1.0:
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
   integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
 
+is-string@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.5.tgz#40493ed198ef3ff477b8c7f92f644ec82a5cd3a6"
+  integrity sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==
+
 is-subset@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/is-subset/-/is-subset-0.1.1.tgz#8a59117d932de1de00f245fcdd39ce43f1e939a6"
@@ -4936,11 +5563,6 @@ jest-validate@^23.5.0:
     leven "^2.1.0"
     pretty-format "^23.6.0"
 
-js-levenshtein@^1.1.3:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/js-levenshtein/-/js-levenshtein-1.1.4.tgz#3a56e3cbf589ca0081eb22cd9ba0b1290a16d26e"
-  integrity sha512-PxfGzSs0ztShKrUYPIn5r0MtyAhYcCwmndozzpz8YObbPnD1jFxzlBGbRnX2mIu6Z13xN6+PTu05TQFnZFlzow==
-
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
@@ -4959,6 +5581,14 @@ js-yaml@3.x, js-yaml@^3.12.0, js-yaml@^3.9.0:
     argparse "^1.0.7"
     esprima "^4.0.0"
 
+js-yaml@^3.13.1:
+  version "3.14.1"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
+  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
+  dependencies:
+    argparse "^1.0.7"
+    esprima "^4.0.0"
+
 jsbn@~0.1.0:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
@@ -4984,6 +5614,11 @@ json-schema-traverse@^0.4.1:
   resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
+json-schema-traverse@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
+  integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
+
 json-schema@0.2.3:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
@@ -5011,13 +5646,6 @@ json5@^1.0.1:
   dependencies:
     minimist "^1.2.0"
 
-json5@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.1.0.tgz#e7a0c62c48285c628d20a10b85c89bb807c32850"
-  integrity sha512-8Mh9h6xViijj36g7Dxi+Y4S6hNGV96vcJZr/SrlHh1LR/pEn/8j/+qIBbs44YKl69Lrfctp4QD+AdWLTMqEZAQ==
-  dependencies:
-    minimist "^1.2.0"
-
 json5@^2.1.2:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
@@ -5217,7 +5845,15 @@ leven@^2.1.0:
   resolved "https://registry.yarnpkg.com/leven/-/leven-2.1.0.tgz#c2e7a9f772094dee9d34202ae8acce4687875580"
   integrity sha1-wuep93IJTe6dNCAq6KzORoeHVYA=
 
-levn@^0.3.0, levn@~0.3.0:
+levn@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
+  integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
+  dependencies:
+    prelude-ls "^1.2.1"
+    type-check "~0.4.0"
+
+levn@~0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
   integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=
@@ -5458,6 +6094,11 @@ lodash.clone@3.0.3:
     lodash._bindcallback "^3.0.0"
     lodash._isiterateecall "^3.0.0"
 
+lodash.clonedeep@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
+  integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
+
 lodash.create@3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/lodash.create/-/lodash.create-3.1.1.tgz#d7f2849f0dbda7e04682bb8cd72ab022461debe7"
@@ -5484,6 +6125,11 @@ lodash.defaultsdeep@4.3.2:
     lodash.mergewith "^4.0.0"
     lodash.rest "^4.0.0"
 
+lodash.flatten@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
+  integrity sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=
+
 lodash.isarguments@^3.0.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz#2f573d85c6a24289ff00663b491c1d338ff3458a"
@@ -5543,6 +6189,11 @@ lodash.templatesettings@^4.0.0:
   dependencies:
     lodash._reinterpolate "~3.0.0"
 
+lodash.truncate@^4.4.2:
+  version "4.4.2"
+  resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193"
+  integrity sha1-WjUNoLERO4N+z//VgSy+WNbq4ZM=
+
 lodash.uniq@^4.5.0:
   version "4.5.0"
   resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
@@ -5553,12 +6204,12 @@ lodash@4.17.5:
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.5.tgz#99a92d65c0272debe8c96b6057bc8fbfa3bed511"
   integrity sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==
 
-lodash@^4.0.1, lodash@^4.16.6, lodash@^4.17.0, lodash@^4.17.10, lodash@^4.17.11, lodash@^4.17.14, lodash@^4.17.5, lodash@^4.2.1, lodash@^4.3.0, lodash@^4.5.0:
+lodash@^4.0.1, lodash@^4.16.6, lodash@^4.17.0, lodash@^4.17.10, lodash@^4.17.14, lodash@^4.17.5, lodash@^4.2.1, lodash@^4.3.0, lodash@^4.5.0:
   version "4.17.20"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52"
   integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==
 
-lodash@^4.17.19:
+lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.21:
   version "4.17.21"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
@@ -5670,6 +6321,14 @@ make-dir@^1.0.0:
   dependencies:
     pify "^3.0.0"
 
+make-dir@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
+  integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
+  dependencies:
+    pify "^4.0.1"
+    semver "^5.6.0"
+
 make-dir@^3.0.2:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
@@ -5772,6 +6431,11 @@ meow@^4.0.0:
     redent "^2.0.0"
     trim-newlines "^2.0.0"
 
+merge2@^1.3.0:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
+  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
+
 merge@^1.2.0:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/merge/-/merge-1.2.1.tgz#38bebf80c3220a8a487b6fcfb3941bb11720c145"
@@ -5815,7 +6479,7 @@ micromatch@^3.1.10, micromatch@^3.1.4, micromatch@^3.1.8:
     snapdragon "^0.8.1"
     to-regex "^3.0.2"
 
-micromatch@^4.0.0:
+micromatch@^4.0.0, micromatch@^4.0.2:
   version "4.0.2"
   resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.2.tgz#4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259"
   integrity sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==
@@ -6012,6 +6676,11 @@ ms@2.0.0:
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
   integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
 
+ms@2.1.2:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
+
 ms@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.1.tgz#30a5864eb3ebb0a66f2ebe6d727af06a09d86e0a"
@@ -6162,12 +6831,10 @@ node-pre-gyp@^0.10.0:
     semver "^5.3.0"
     tar "^4"
 
-node-releases@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.3.tgz#aad9ce0dcb98129c753f772c0aa01360fb90fbd2"
-  integrity sha512-6VrvH7z6jqqNFY200kdB6HdzkgM96Oaj9v3dqGfgp6mF+cHmU4wyQKZ2/WPDRVoR0Jz9KqbamaBN0ZhdUaysUQ==
-  dependencies:
-    semver "^5.3.0"
+node-releases@^1.1.70:
+  version "1.1.71"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.71.tgz#cb1334b179896b1c89ecfdd4b725fb7bbdfc7dbb"
+  integrity sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==
 
 nopt@3.x:
   version "3.0.6"
@@ -6291,6 +6958,11 @@ object-keys@^1.0.12:
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.0.12.tgz#09c53855377575310cca62f55bb334abff7b3ed2"
   integrity sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==
 
+object-keys@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
+  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
+
 object-visit@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
@@ -6298,6 +6970,16 @@ object-visit@^1.0.0:
   dependencies:
     isobject "^3.0.0"
 
+object.assign@^4.1.0:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
+  integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==
+  dependencies:
+    call-bind "^1.0.0"
+    define-properties "^1.1.3"
+    has-symbols "^1.0.1"
+    object-keys "^1.1.1"
+
 object.getownpropertydescriptors@^2.0.3:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz#8758c846f5b407adab0f236e0986f14b051caa16"
@@ -6380,7 +7062,7 @@ optimist@0.6.1, optimist@^0.6.1:
     minimist "~0.0.1"
     wordwrap "~0.0.2"
 
-optionator@^0.8.1, optionator@^0.8.2:
+optionator@^0.8.1:
   version "0.8.2"
   resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
   integrity sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=
@@ -6392,6 +7074,18 @@ optionator@^0.8.1, optionator@^0.8.2:
     type-check "~0.3.2"
     wordwrap "~1.0.0"
 
+optionator@^0.9.1:
+  version "0.9.1"
+  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499"
+  integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
+  dependencies:
+    deep-is "^0.1.3"
+    fast-levenshtein "^2.0.6"
+    levn "^0.4.1"
+    prelude-ls "^1.2.1"
+    type-check "^0.4.0"
+    word-wrap "^1.2.3"
+
 os-browserify@^0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
@@ -6653,6 +7347,11 @@ path-key@^2.0.0, path-key@^2.0.1:
   resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
   integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=
 
+path-key@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
+  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
+
 path-parse@^1.0.6:
   version "1.0.6"
   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
@@ -6674,6 +7373,11 @@ path-type@^3.0.0:
   dependencies:
     pify "^3.0.0"
 
+path-type@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
+  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
+
 pbkdf2@^3.0.3:
   version "3.0.17"
   resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.0.17.tgz#976c206530617b14ebb32114239f7b09336e93a6"
@@ -6710,7 +7414,7 @@ phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
     request-progress "^2.0.1"
     which "^1.2.10"
 
-picomatch@^2.0.5, picomatch@^2.2.2:
+picomatch@^2.0.5, picomatch@^2.2.1, picomatch@^2.2.2:
   version "2.2.2"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
   integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
@@ -6725,6 +7429,11 @@ pify@^3.0.0:
   resolved "https://registry.yarnpkg.com/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176"
   integrity sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=
 
+pify@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
+  integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
+
 pinkie-promise@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
@@ -6744,13 +7453,6 @@ pirates@^4.0.0:
   dependencies:
     node-modules-regexp "^1.0.0"
 
-pkg-dir@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-2.0.0.tgz#f6d5d1109e19d63edf428e0bd57e12777615334b"
-  integrity sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=
-  dependencies:
-    find-up "^2.1.0"
-
 pkg-dir@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
@@ -6772,11 +7474,6 @@ please-upgrade-node@^3.0.2:
   dependencies:
     semver-compare "^1.0.0"
 
-pluralize@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-7.0.0.tgz#298b89df8b93b0221dbf421ad2b1b1ea23fc6777"
-  integrity sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==
-
 portfinder@^1.0.25:
   version "1.0.28"
   resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.28.tgz#67c4622852bd5374dd1dd900f779f53462fac778"
@@ -6791,6 +7488,11 @@ posix-character-classes@^0.1.0:
   resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
   integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=
 
+prelude-ls@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
+  integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
+
 prelude-ls@~1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
@@ -6809,11 +7511,6 @@ pretty-format@^23.6.0:
     ansi-regex "^3.0.0"
     ansi-styles "^3.2.0"
 
-private@^0.1.6:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/private/-/private-0.1.8.tgz#2381edb3689f7a53d653190060fcf822d2f368ff"
-  integrity sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==
-
 process-nextick-args@~1.0.6:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3"
@@ -6979,6 +7676,11 @@ querystring@0.2.0:
   resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
   integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
 
+queue-microtask@^1.2.2:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
+  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
+
 quick-lru@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8"
@@ -7156,7 +7858,7 @@ regenerate-unicode-properties@^7.0.0:
   dependencies:
     regenerate "^1.4.0"
 
-regenerate-unicode-properties@^8.0.2:
+regenerate-unicode-properties@^8.0.2, regenerate-unicode-properties@^8.2.0:
   version "8.2.0"
   resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz#e5de7111d655e7ba60c057dbe9ff37c87e65cdec"
   integrity sha512-F9DjY1vKLo/tPePDycuH3dn9H1OTPIkVD9Kz4LODu+F2C75mgjAJ7x/gwy6ZcSNRAAkhNlJSOHRe8k3p+K9WhA==
@@ -7178,12 +7880,17 @@ regenerator-runtime@^0.11.0:
   resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
   integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==
 
-regenerator-transform@^0.13.3:
-  version "0.13.3"
-  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.13.3.tgz#264bd9ff38a8ce24b06e0636496b2c856b57bcbb"
-  integrity sha512-5ipTrZFSq5vU2YoGoww4uaRVAK4wyYC4TSICibbfEPOruUu8FFP7ErV0BjmbIOEpn3O/k9na9UEdYR/3m7N6uA==
+regenerator-runtime@^0.13.4:
+  version "0.13.7"
+  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz#cac2dacc8a1ea675feaabaeb8ae833898ae46f55"
+  integrity sha512-a54FxoJDIr27pgf7IgeQGxmqUNYrcV338lf/6gH456HZ/PhX+5BcwHXG9ajESmwe6WRO0tAzRUrRmNONWgkrew==
+
+regenerator-transform@^0.14.2:
+  version "0.14.5"
+  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.14.5.tgz#c98da154683671c9c4dcb16ece736517e1b7feb4"
+  integrity sha512-eOf6vka5IO151Jfsw2NO9WpGX58W6wWmefK3I1zEGr0lOD0u8rwPaNqQL1aRxUaxLeKO3ArNh3VYg1KbaD+FFw==
   dependencies:
-    private "^0.1.6"
+    "@babel/runtime" "^7.8.4"
 
 regex-cache@^0.4.2:
   version "0.4.4"
@@ -7200,10 +7907,10 @@ regex-not@^1.0.0, regex-not@^1.0.2:
     extend-shallow "^3.0.2"
     safe-regex "^1.1.0"
 
-regexpp@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-2.0.1.tgz#8d19d31cf632482b589049f8281f93dbcba4d07f"
-  integrity sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw==
+regexpp@^3.0.0, regexpp@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.1.0.tgz#206d0ad0a5648cffbdb8ae46438f3dc51c9f78e2"
+  integrity sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q==
 
 regexpu-core@4.5.4:
   version "4.5.4"
@@ -7217,7 +7924,7 @@ regexpu-core@4.5.4:
     unicode-match-property-ecmascript "^1.0.4"
     unicode-match-property-value-ecmascript "^1.1.0"
 
-regexpu-core@^4.1.3, regexpu-core@^4.2.0:
+regexpu-core@^4.2.0:
   version "4.4.0"
   resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.4.0.tgz#8d43e0d1266883969720345e70c275ee0aec0d32"
   integrity sha512-eDDWElbwwI3K0Lo6CqbQbA6FwgtCz4kYTarrri1okfkRLZAqstU+B3voZBCjg8Fl6iq0gXrJG6MvRgLthfvgOA==
@@ -7229,11 +7936,28 @@ regexpu-core@^4.1.3, regexpu-core@^4.2.0:
     unicode-match-property-ecmascript "^1.0.4"
     unicode-match-property-value-ecmascript "^1.0.2"
 
+regexpu-core@^4.7.1:
+  version "4.7.1"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.7.1.tgz#2dea5a9a07233298fbf0db91fa9abc4c6e0f8ad6"
+  integrity sha512-ywH2VUraA44DZQuRKzARmw6S66mr48pQVva4LBeRhcOltJ6hExvWly5ZjFLYo67xbIxb6W1q4bAGtgfEl20zfQ==
+  dependencies:
+    regenerate "^1.4.0"
+    regenerate-unicode-properties "^8.2.0"
+    regjsgen "^0.5.1"
+    regjsparser "^0.6.4"
+    unicode-match-property-ecmascript "^1.0.4"
+    unicode-match-property-value-ecmascript "^1.2.0"
+
 regjsgen@^0.5.0:
   version "0.5.0"
   resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.0.tgz#a7634dc08f89209c2049adda3525711fb97265dd"
   integrity sha512-RnIrLhrXCX5ow/E5/Mh2O4e/oa1/jW0eaBKTSy3LaCj+M3Bqvm97GWDp2yUtzIs4LEn65zR2yiYGFqb2ApnzDA==
 
+regjsgen@^0.5.1:
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.2.tgz#92ff295fb1deecbf6ecdab2543d207e91aa33733"
+  integrity sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==
+
 regjsparser@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.0.tgz#f1e6ae8b7da2bae96c99399b868cd6c933a2ba9c"
@@ -7241,6 +7965,13 @@ regjsparser@^0.6.0:
   dependencies:
     jsesc "~0.5.0"
 
+regjsparser@^0.6.4:
+  version "0.6.9"
+  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.9.tgz#b489eef7c9a2ce43727627011429cf833a7183e6"
+  integrity sha512-ZqbNRz1SNjLAiYuwY0zoXW8Ne675IX5q+YHioAGbCw4X96Mjl2+dcX9B2ciaeyYjViDAfvIjFpQjJgLttTEERQ==
+  dependencies:
+    jsesc "~0.5.0"
+
 remove-trailing-separator@^1.0.1:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
@@ -7301,6 +8032,11 @@ request@^2.81.0, request@^2.87.0, request@^2.88.0:
     tunnel-agent "^0.6.0"
     uuid "^3.3.2"
 
+require-from-string@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
+  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
+
 require-main-filename@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
@@ -7334,7 +8070,7 @@ resolve@1.1.x:
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b"
   integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=
 
-resolve@1.20.0, resolve@^1.17.0, resolve@^1.19.0:
+resolve@1.20.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0:
   version "1.20.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
   integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
@@ -7342,7 +8078,7 @@ resolve@1.20.0, resolve@^1.17.0, resolve@^1.19.0:
     is-core-module "^2.2.0"
     path-parse "^1.0.6"
 
-resolve@^1.1.6, resolve@^1.3.2, resolve@^1.3.3:
+resolve@^1.1.6, resolve@^1.3.3:
   version "1.9.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.9.0.tgz#a14c6fdfa8f92a7df1d996cb7105fa744658ea06"
   integrity sha512-TZNye00tI67lwYvzxCxHGjwTNlUV70io54/Ed4j6PscB8xVfuBJpRenI/o6dVk0cY0PYTY27AgCoGGxRnYuItQ==
@@ -7370,6 +8106,11 @@ ret@~0.1.10:
   resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
 
+reusify@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
+  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
+
 rfdc@^1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.1.2.tgz#e6e72d74f5dc39de8f538f65e00c36c18018e349"
@@ -7380,13 +8121,20 @@ right-pad@^1.0.1:
   resolved "https://registry.yarnpkg.com/right-pad/-/right-pad-1.0.1.tgz#8ca08c2cbb5b55e74dafa96bf7fd1a27d568c8d0"
   integrity sha1-jKCMLLtbVedNr6lr9/0aJ9VoyNA=
 
-rimraf@^2.2.8, rimraf@^2.5.4, rimraf@^2.6.0, rimraf@^2.6.1, rimraf@^2.6.2, rimraf@~2.6.2:
+rimraf@^2.2.8, rimraf@^2.5.4, rimraf@^2.6.0, rimraf@^2.6.1, rimraf@^2.6.2:
   version "2.6.3"
   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
   integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
   dependencies:
     glob "^7.1.3"
 
+rimraf@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
+  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
+  dependencies:
+    glob "^7.1.3"
+
 ripemd160@^2.0.0, ripemd160@^2.0.1:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
@@ -7420,6 +8168,13 @@ run-async@^2.2.0:
   dependencies:
     is-promise "^2.1.0"
 
+run-parallel@^1.1.9:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
+  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
+  dependencies:
+    queue-microtask "^1.2.2"
+
 run-queue@^1.0.0, run-queue@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/run-queue/-/run-queue-1.0.3.tgz#e848396f057d223f24386924618e25694161ec47"
@@ -7432,7 +8187,7 @@ rx@^4.1.0:
   resolved "https://registry.yarnpkg.com/rx/-/rx-4.1.0.tgz#a5f13ff79ef3b740fe30aa803fb09f98805d4782"
   integrity sha1-pfE/957zt0D+MKqAP7CfmIBdR4I=
 
-rxjs@^6.1.0, rxjs@^6.3.3:
+rxjs@^6.3.3:
   version "6.3.3"
   resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.3.3.tgz#3c6a7fa420e844a81390fb1158a9ec614f4bad55"
   integrity sha512-JTWmoY9tWCs7zvIk/CvRjhjGaOd+OVBM987mxFo+OW66cGpdKjZcpmc74ES1sB//7Kl/PAe8+wEakuhG4pcgOw==
@@ -7521,17 +8276,27 @@ semver-compare@^1.0.0:
   resolved "https://registry.yarnpkg.com/semver-compare/-/semver-compare-1.0.0.tgz#0dee216a1c941ab37e9efb1788f6afc5ff5537fc"
   integrity sha1-De4hahyUGrN+nvsXiPavxf9VN/w=
 
-"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.4.1, semver@^5.5.0, semver@^5.5.1:
+"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0:
   version "5.6.0"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.6.0.tgz#7e74256fbaa49c75aa7c7a205cc22799cac80004"
   integrity sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==
 
-semver@^6.0.0:
+semver@7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.0.0.tgz#5f3ca35761e47e05b206c6daff2cf814f0316b8e"
+  integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==
+
+semver@^5.6.0:
+  version "5.7.1"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
+  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
+
+semver@^6.0.0, semver@^6.1.1, semver@^6.1.2, semver@^6.3.0:
   version "6.3.0"
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
-semver@^7.3.4:
+semver@^7.2.1, semver@^7.3.2, semver@^7.3.4:
   version "7.3.5"
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
   integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
@@ -7605,11 +8370,23 @@ shebang-command@^1.2.0:
   dependencies:
     shebang-regex "^1.0.0"
 
+shebang-command@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
+  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
+  dependencies:
+    shebang-regex "^3.0.0"
+
 shebang-regex@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
   integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=
 
+shebang-regex@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
+  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
+
 shelljs@0.7.6:
   version "0.7.6"
   resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.7.6.tgz#379cccfb56b91c8601e4793356eb5382924de9ad"
@@ -7650,14 +8427,14 @@ slice-ansi@0.0.4:
   resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35"
   integrity sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=
 
-slice-ansi@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-2.0.0.tgz#5373bdb8559b45676e8541c66916cdd6251612e7"
-  integrity sha512-4j2WTWjp3GsZ+AOagyzVbzp4vWGtZ0hEZ/gDY/uTvm6MTxUfTUIsnMIFb1bn8o0RuXiqUw15H1bue8f22Vw2oQ==
+slice-ansi@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
+  integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
   dependencies:
-    ansi-styles "^3.2.0"
-    astral-regex "^1.0.0"
-    is-fullwidth-code-point "^2.0.0"
+    ansi-styles "^4.0.0"
+    astral-regex "^2.0.0"
+    is-fullwidth-code-point "^3.0.0"
 
 smart-buffer@^1.0.13:
   version "1.1.15"
@@ -7773,7 +8550,15 @@ source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
     source-map-url "^0.4.0"
     urix "^0.1.0"
 
-source-map-support@^0.5.9, source-map-support@~0.5.6:
+source-map-support@^0.5.16:
+  version "0.5.19"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
+  integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
+source-map-support@~0.5.6:
   version "0.5.9"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.9.tgz#41bc953b2534267ea2d605bccfa7bfa3111ced5f"
   integrity sha512-gR6Rw4MvUlYy83vP0vxoVNzM6t8MUXqNuRsuBmBHQDu1Fh6X015FrLdgoDKcNdkwGubozq0P4N0Q37UyFVr1EA==
@@ -7974,7 +8759,7 @@ string-width@^1.0.1:
     is-fullwidth-code-point "^1.0.0"
     strip-ansi "^3.0.0"
 
-"string-width@^1.0.2 || 2", string-width@^2.0.0, string-width@^2.1.0, string-width@^2.1.1:
+"string-width@^1.0.2 || 2", string-width@^2.0.0, string-width@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
   integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
@@ -7982,6 +8767,15 @@ string-width@^1.0.1:
     is-fullwidth-code-point "^2.0.0"
     strip-ansi "^4.0.0"
 
+string-width@^4.2.0:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5"
+  integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.0"
+
 string_decoder@^1.0.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.2.0.tgz#fe86e738b19544afe70469243b2a1ee9240eae8d"
@@ -8024,12 +8818,12 @@ strip-ansi@^4.0.0:
   dependencies:
     ansi-regex "^3.0.0"
 
-strip-ansi@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.0.0.tgz#f78f68b5d0866c20b2c9b8c61b5298508dc8756f"
-  integrity sha512-Uu7gQyZI7J7gn5qLn1Np3G9vcYGTVqB+lFTytnDJv83dd8T22aGH451P3jueT2/QemInJDfxHB5Tde5OzgG1Ow==
+strip-ansi@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.0.tgz#0b1571dd7669ccd4f3e06e14ef1eed26225ae532"
+  integrity sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==
   dependencies:
-    ansi-regex "^4.0.0"
+    ansi-regex "^5.0.0"
 
 strip-bom@^2.0.0:
   version "2.0.0"
@@ -8060,11 +8854,16 @@ strip-indent@^2.0.0:
   resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
   integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
 
-strip-json-comments@2.0.1, strip-json-comments@^2.0.1, strip-json-comments@~2.0.1:
+strip-json-comments@2.0.1, strip-json-comments@~2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
   integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
 
+strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
+  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
+
 supports-color@3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.1.2.tgz#72a262894d9d408b956ca05ff37b2ed8a6e2a2d5"
@@ -8103,15 +8902,20 @@ symbol-observable@^1.1.0:
   resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.2.0.tgz#c22688aed4eab3cdc2dfeacbb561660560a00804"
   integrity sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==
 
-table@^5.0.2:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/table/-/table-5.1.1.tgz#92030192f1b7b51b6eeab23ed416862e47b70837"
-  integrity sha512-NUjapYb/qd4PeFW03HnAuOJ7OMcBkJlqeClWxeNlQ0lXGSb52oZXGzkO0/I0ARegQ2eUT1g2VDJH0eUxDRcHmw==
-  dependencies:
-    ajv "^6.6.1"
-    lodash "^4.17.11"
-    slice-ansi "2.0.0"
-    string-width "^2.1.1"
+table@^6.0.4:
+  version "6.0.9"
+  resolved "https://registry.yarnpkg.com/table/-/table-6.0.9.tgz#790a12bf1e09b87b30e60419bafd6a1fd85536fb"
+  integrity sha512-F3cLs9a3hL1Z7N4+EkSscsel3z55XT950AvB05bwayrNg5T1/gykXtigioTAjbltvbMSJvvhFCbnf6mX+ntnJQ==
+  dependencies:
+    ajv "^8.0.1"
+    is-boolean-object "^1.1.0"
+    is-number-object "^1.0.4"
+    is-string "^1.0.5"
+    lodash.clonedeep "^4.5.0"
+    lodash.flatten "^4.4.0"
+    lodash.truncate "^4.4.2"
+    slice-ansi "^4.0.0"
+    string-width "^4.2.0"
 
 tapable@^1.0.0, tapable@^1.1.0:
   version "1.1.1"
@@ -8329,6 +9133,11 @@ tslib@2.1.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
   integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
 
+tslib@^1.8.1:
+  version "1.14.1"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
+  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
+
 tslib@^1.9.0:
   version "1.9.3"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286"
@@ -8339,6 +9148,13 @@ tslib@^2.2.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c"
   integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==
 
+tsutils@^3.17.1:
+  version "3.21.0"
+  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
+  integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
+  dependencies:
+    tslib "^1.8.1"
+
 tty-browserify@0.0.0:
   version "0.0.0"
   resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6"
@@ -8356,6 +9172,13 @@ tweetnacl@^0.14.3, tweetnacl@~0.14.0:
   resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
   integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=
 
+type-check@^0.4.0, type-check@~0.4.0:
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
+  integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
+  dependencies:
+    prelude-ls "^1.2.1"
+
 type-check@~0.3.2:
   version "0.3.2"
   resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
@@ -8368,6 +9191,16 @@ type-detect@0.1.1:
   resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-0.1.1.tgz#0ba5ec2a885640e470ea4e8505971900dac58822"
   integrity sha1-C6XsKohWQORw6k6FBZcZANrFiCI=
 
+type-fest@^0.20.2:
+  version "0.20.2"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
+  integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
+
+type-fest@^0.8.1:
+  version "0.8.1"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
+  integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
+
 type-is@~1.6.16:
   version "1.6.16"
   resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.16.tgz#f89ce341541c672b25ee7ae3c73dee3b2be50194"
@@ -8414,7 +9247,7 @@ unicode-match-property-value-ecmascript@^1.0.2:
   resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.0.2.tgz#9f1dc76926d6ccf452310564fd834ace059663d4"
   integrity sha512-Rx7yODZC1L/T8XKo/2kNzVAQaRE88AaMvI1EF/Xnj3GW2wzN6fop9DDWuFAKUVFH7vozkz26DzP0qyWLKLIVPQ==
 
-unicode-match-property-value-ecmascript@^1.1.0:
+unicode-match-property-value-ecmascript@^1.1.0, unicode-match-property-value-ecmascript@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz#0d91f600eeeb3096aa962b1d6fc88876e64ea531"
   integrity sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==
@@ -8558,6 +9391,11 @@ uuid@^3.3.2:
   resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.3.2.tgz#1b4af4955eb3077c501c23872fc6513811587131"
   integrity sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==
 
+v8-compile-cache@^2.0.3:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
+  integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
+
 validate-npm-package-license@^3.0.1:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
@@ -8676,6 +9514,13 @@ which@^1.1.1, which@^1.2.1, which@^1.2.10, which@^1.2.12, which@^1.2.9:
   dependencies:
     isexe "^2.0.0"
 
+which@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
+  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
+  dependencies:
+    isexe "^2.0.0"
+
 wide-align@^1.1.0:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
@@ -8683,7 +9528,7 @@ wide-align@^1.1.0:
   dependencies:
     string-width "^1.0.2 || 2"
 
-word-wrap@^1.0.3:
+word-wrap@^1.0.3, word-wrap@^1.2.3:
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
   integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
@@ -8718,13 +9563,6 @@ wrappy@1:
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
 
-write@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/write/-/write-0.2.1.tgz#5fc03828e264cea3fe91455476f7a3c566cb0757"
-  integrity sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=
-  dependencies:
-    mkdirp "^0.5.1"
-
 ws@^6.1.0:
   version "6.1.2"
   resolved "https://registry.yarnpkg.com/ws/-/ws-6.1.2.tgz#3cc7462e98792f0ac679424148903ded3b9c3ad8"

From 69a1bc909b342259b74b5f9c3c596ba9bded7207 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 6 Apr 2021 17:21:58 +0100
Subject: [PATCH 011/317] eslint fixes

---
 .eslintrc.js                                             | 9 +++++++++
 src/compiler/codeframe.ts                                | 1 +
 src/compiler/create-compiler.ts                          | 4 ++--
 src/compiler/helpers.ts                                  | 4 ++--
 src/compiler/parser/filter-parser.ts                     | 2 +-
 src/compiler/parser/index.ts                             | 2 +-
 src/core/instance/events.ts                              | 2 +-
 src/core/instance/render-helpers/render-list.ts          | 2 +-
 src/core/instance/render-helpers/resolve-scoped-slots.ts | 2 +-
 src/core/instance/render-helpers/resolve-slots.ts        | 2 +-
 src/core/vdom/create-functional-component.ts             | 4 ++--
 src/global.d.ts                                          | 2 +-
 src/platforms/web/runtime/modules/events.ts              | 2 +-
 src/platforms/web/runtime/modules/transition.ts          | 2 +-
 src/platforms/weex/runtime/modules/events.ts             | 2 +-
 src/platforms/weex/runtime/modules/transition.ts         | 2 +-
 src/platforms/weex/runtime/node-ops.ts                   | 2 +-
 src/platforms/weex/util/index.ts                         | 2 +-
 src/server/bundle-renderer/create-bundle-renderer.ts     | 2 +-
 src/server/create-renderer.ts                            | 2 +-
 test/unit/modules/observer/observer.spec.js              | 1 +
 21 files changed, 32 insertions(+), 21 deletions(-)

diff --git a/.eslintrc.js b/.eslintrc.js
index 514b4f14f98..e1739e9cfbd 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -22,6 +22,15 @@ module.exports = {
     WXEnvironment: true,
   },
   rules: {
+    'no-unused-vars': [
+      'error',
+      // we are only using this rule to check for unused arguments since TS
+      // catches unused variables but not args.
+      { varsIgnorePattern: '.*', args: 'none' }
+    ],
+    'prefer-spread': 0,
+    'prefer-rest-params': 0,
+    'no-prototype-builtins': 0,
     "no-console": process.env.NODE_ENV !== "production" ? 0 : 2,
     "no-useless-escape": 0,
     "no-empty": 0,
diff --git a/src/compiler/codeframe.ts b/src/compiler/codeframe.ts
index 7fdd132476f..021592727e5 100644
--- a/src/compiler/codeframe.ts
+++ b/src/compiler/codeframe.ts
@@ -40,6 +40,7 @@ export function generateCodeFrame(
 function repeat(str, n) {
   let result = ''
   if (n > 0) {
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       // eslint-disable-line
       if (n & 1) result += str
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index 5f7414488ca..63872650af8 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -14,7 +14,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
       const tips: WarningMessage[] = []
 
       let warn = (msg, range, tip) => {
-        ;(tip ? tips : errors).push(msg)
+        (tip ? tips : errors).push(msg)
       }
 
       if (options) {
@@ -35,7 +35,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
                 data.end = range.end + leadingSpaceLength
               }
             }
-            ;(tip ? tips : errors).push(data)
+            (tip ? tips : errors).push(data)
           }
         }
         // merge custom modules
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index aad4823470e..93c661f785b 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -24,7 +24,7 @@ export function addProp(
   range?: Range,
   dynamic?: boolean
 ) {
-  ;(el.props || (el.props = [])).push(
+  (el.props || (el.props = [])).push(
     rangeSetItem({ name, value, dynamic }, range)
   )
   el.plain = false
@@ -65,7 +65,7 @@ export function addDirective(
   modifiers?: ASTModifiers,
   range?: Range
 ) {
-  ;(el.directives || (el.directives = [])).push(
+  (el.directives || (el.directives = [])).push(
     rangeSetItem(
       {
         name,
diff --git a/src/compiler/parser/filter-parser.ts b/src/compiler/parser/filter-parser.ts
index 17d07276b56..0684a3751ec 100644
--- a/src/compiler/parser/filter-parser.ts
+++ b/src/compiler/parser/filter-parser.ts
@@ -91,7 +91,7 @@ export function parseFilters(exp: string): string {
   }
 
   function pushFilter() {
-    ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
+    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
     lastFilterIndex = i + 1
   }
 
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index 2eb55b07d4f..edc83f06c98 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -773,7 +773,7 @@ function processAttrs(el) {
       modifiers = parseModifiers(name.replace(dirRE, ''))
       // support .foo shorthand syntax for the .prop modifier
       if (process.env.VBIND_PROP_SHORTHAND && propBindRE.test(name)) {
-        ;(modifiers || (modifiers = {})).prop = true
+        (modifiers || (modifiers = {})).prop = true
         name = `.` + name.slice(1).replace(modifierRE, '')
       } else if (modifiers) {
         name = name.replace(modifierRE, '')
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index c7f5e2d11ff..24fa7aa6c7a 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -68,7 +68,7 @@ export function eventsMixin(Vue: Component) {
         vm.$on(event[i], fn)
       }
     } else {
-      ;(vm._events[event] || (vm._events[event] = [])).push(fn)
+      (vm._events[event] || (vm._events[event] = [])).push(fn)
       // optimize hook:event cost by using a boolean flag marked at registration
       // instead of a hash lookup
       if (hookRE.test(event)) {
diff --git a/src/core/instance/render-helpers/render-list.ts b/src/core/instance/render-helpers/render-list.ts
index 8f7f6ed9e28..cc8a800eb3a 100644
--- a/src/core/instance/render-helpers/render-list.ts
+++ b/src/core/instance/render-helpers/render-list.ts
@@ -44,6 +44,6 @@ export function renderList(
   if (!isDef(ret)) {
     ret = []
   }
-  ;(ret as any)._isVList = true
+  (ret as any)._isVList = true
   return ret
 }
diff --git a/src/core/instance/render-helpers/resolve-scoped-slots.ts b/src/core/instance/render-helpers/resolve-scoped-slots.ts
index c5bd2903316..0b7869546ae 100644
--- a/src/core/instance/render-helpers/resolve-scoped-slots.ts
+++ b/src/core/instance/render-helpers/resolve-scoped-slots.ts
@@ -23,7 +23,7 @@ export function resolveScopedSlots(
     }
   }
   if (contentHashKey) {
-    ;(res as any).$key = contentHashKey
+    (res as any).$key = contentHashKey
   }
   return res as any
 }
diff --git a/src/core/instance/render-helpers/resolve-slots.ts b/src/core/instance/render-helpers/resolve-slots.ts
index 1a98719eec2..17f79c158c4 100644
--- a/src/core/instance/render-helpers/resolve-slots.ts
+++ b/src/core/instance/render-helpers/resolve-slots.ts
@@ -35,7 +35,7 @@ export function resolveSlots(
         slot.push(child)
       }
     } else {
-      ;(slots.default || (slots.default = [])).push(child)
+      (slots.default || (slots.default = [])).push(child)
     }
   }
   // ignore slots that contains only whitespace
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index 8d371a82510..99915b764de 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -160,10 +160,10 @@ function cloneAndMarkFunctionalResult(
   clone.fnContext = contextVm
   clone.fnOptions = options
   if (process.env.NODE_ENV !== 'production') {
-    ;(clone.devtoolsMeta = clone.devtoolsMeta || {} as any).renderContext = renderContext
+    (clone.devtoolsMeta = clone.devtoolsMeta || {} as any).renderContext = renderContext
   }
   if (data.slot) {
-    ;(clone.data || (clone.data = {})).slot = data.slot
+    (clone.data || (clone.data = {})).slot = data.slot
   }
   return clone
 }
diff --git a/src/global.d.ts b/src/global.d.ts
index b148c97c0bd..fe43838c759 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -19,4 +19,4 @@ declare type WeexEnvironment = {
   dpr?: number;
   rem?: number;
 };
-declare var WXEnvironment: WeexEnvironment;
+declare let WXEnvironment: WeexEnvironment;
diff --git a/src/platforms/web/runtime/modules/events.ts b/src/platforms/web/runtime/modules/events.ts
index 6cb75f9faeb..27007df3649 100644
--- a/src/platforms/web/runtime/modules/events.ts
+++ b/src/platforms/web/runtime/modules/events.ts
@@ -97,7 +97,7 @@ function remove(
   capture: boolean,
   _target?: HTMLElement
 ) {
-  ;(_target || target).removeEventListener(
+  (_target || target).removeEventListener(
     name,
     //@ts-expect-error
     handler._wrapper || handler,
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index aff7d09e45a..c91f3e185f4 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -242,7 +242,7 @@ export function leave(vnode: VNodeWithData, rm: Function) {
     }
     // record leaving element
     if (!vnode.data.show && el.parentNode) {
-      ;(el.parentNode._pending || (el.parentNode._pending = {}))[
+      (el.parentNode._pending || (el.parentNode._pending = {}))[
         vnode.key!
       ] = vnode
     }
diff --git a/src/platforms/weex/runtime/modules/events.ts b/src/platforms/weex/runtime/modules/events.ts
index 1605abd9fa9..6a3a409e9d4 100644
--- a/src/platforms/weex/runtime/modules/events.ts
+++ b/src/platforms/weex/runtime/modules/events.ts
@@ -29,7 +29,7 @@ function add(
 }
 
 function remove(event: string, handler: any, capture: any, _target?: any) {
-  ;(_target || target).removeEvent(event)
+  (_target || target).removeEvent(event)
 }
 
 function updateDOMListeners(oldVnode: VNodeWithData, vnode: VNodeWithData) {
diff --git a/src/platforms/weex/runtime/modules/transition.ts b/src/platforms/weex/runtime/modules/transition.ts
index 551d1d7127a..e83b73e2bf5 100644
--- a/src/platforms/weex/runtime/modules/transition.ts
+++ b/src/platforms/weex/runtime/modules/transition.ts
@@ -224,7 +224,7 @@ function leave(vnode, rm) {
     }
     // record leaving element
     if (!vnode.data.show) {
-      ;(el.parentNode._pending || (el.parentNode._pending = {}))[
+      (el.parentNode._pending || (el.parentNode._pending = {}))[
         vnode.key
       ] = vnode
     }
diff --git a/src/platforms/weex/runtime/node-ops.ts b/src/platforms/weex/runtime/node-ops.ts
index 61aba841d27..32b42032a33 100644
--- a/src/platforms/weex/runtime/node-ops.ts
+++ b/src/platforms/weex/runtime/node-ops.ts
@@ -1,4 +1,4 @@
-declare var document: WeexDocument
+declare let document: WeexDocument
 
 import type { WeexDocument, WeexElement } from 'typescript/weex'
 import TextNode from 'weex/runtime/text-node'
diff --git a/src/platforms/weex/util/index.ts b/src/platforms/weex/util/index.ts
index c2492d098c8..ddbd695b568 100644
--- a/src/platforms/weex/util/index.ts
+++ b/src/platforms/weex/util/index.ts
@@ -1,4 +1,4 @@
-declare var document: WeexDocument
+declare let document: WeexDocument
 
 import { warn } from 'core/util/index'
 import type { WeexDocument } from 'typescript/weex'
diff --git a/src/server/bundle-renderer/create-bundle-renderer.ts b/src/server/bundle-renderer/create-bundle-renderer.ts
index 6e0fc9272b2..cd59d93d752 100644
--- a/src/server/bundle-renderer/create-bundle-renderer.ts
+++ b/src/server/bundle-renderer/create-bundle-renderer.ts
@@ -97,7 +97,7 @@ export function createBundleRendererCreator(
 
         let promise
         if (!cb) {
-          ;({ promise, cb } = createPromiseCallback())
+          ({ promise, cb } = createPromiseCallback())
         }
 
         run(context)
diff --git a/src/server/create-renderer.ts b/src/server/create-renderer.ts
index 0cfd587591a..3db25174a06 100644
--- a/src/server/create-renderer.ts
+++ b/src/server/create-renderer.ts
@@ -80,7 +80,7 @@ export function createRenderer({
       // no callback, return Promise
       let promise
       if (!cb) {
-        ;({ promise, cb } = createPromiseCallback())
+        ({ promise, cb } = createPromiseCallback())
       }
 
       let result = ''
diff --git a/test/unit/modules/observer/observer.spec.js b/test/unit/modules/observer/observer.spec.js
index 5a8d47c1bc2..f81813717d8 100644
--- a/test/unit/modules/observer/observer.spec.js
+++ b/test/unit/modules/observer/observer.spec.js
@@ -221,6 +221,7 @@ describe('Observer', () => {
       get () { return this.val },
       set (v) {
         this.val = v
+        // eslint-disable-next-line no-setter-return
         return this.val
       }
     })

From b3de21c2ba3c9ab14cde719f92f85368aca0e6f9 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 12:07:59 +0100
Subject: [PATCH 012/317] fix ts-check

---
 tsconfig.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tsconfig.json b/tsconfig.json
index 834374f2b7f..7316b0d6b56 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -31,7 +31,7 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "test-dts", "typescript", "test"],
+  "include": ["src", "test-dts", "typescript"],
 
-  "exclude": ["flow", "node_modules", "packages"]
+  "exclude": ["flow", "node_modules", "packages", "types"]
 }

From e643e44daf3f0fd26093fe7201260c245c89e69e Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 12:21:31 +0100
Subject: [PATCH 013/317] removed jasmine types

---
 package.json  |  2 --
 tsconfig.json |  4 ++--
 yarn.lock     | 10 ----------
 3 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/package.json b/package.json
index 09c9a3b5f91..add289b6db1 100644
--- a/package.json
+++ b/package.json
@@ -81,8 +81,6 @@
     "@rollup/plugin-commonjs": "^18.0.0",
     "@rollup/plugin-node-resolve": "^11.2.1",
     "@rollup/plugin-replace": "^2.4.2",
-    "@types/jasmine": "^3.6.9",
-    "@types/mocha": "^8.2.2",
     "@types/node": "^12.12.0",
     "@types/webpack": "^4.4.22",
     "@typescript-eslint/eslint-plugin": "^4.21.0",
diff --git a/tsconfig.json b/tsconfig.json
index 7316b0d6b56..001ecd34e32 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -17,7 +17,7 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": ["node", "jasmine"],
+    "types": ["node"],
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
@@ -31,7 +31,7 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "test-dts", "typescript"],
+  "include": ["src", "test-dts", "typescript", "types"],
 
   "exclude": ["flow", "node_modules", "packages", "types"]
 }
diff --git a/yarn.lock b/yarn.lock
index 59c65aaef1b..a334facb75f 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1117,21 +1117,11 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
   integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
 
-"@types/jasmine@^3.6.9":
-  version "3.6.9"
-  resolved "https://registry.yarnpkg.com/@types/jasmine/-/jasmine-3.6.9.tgz#8785870f87839b7d91b45d7b226380f28dee5d9f"
-  integrity sha512-B53NIwMj/AO0O+xfSWLYmKB0Mo6TYxfv2Mk8/c1T2w/e38t55iaPR6p7pHXTTtqfTmevPK3i8T1YweYFTZlxDw==
-
 "@types/json-schema@^7.0.3":
   version "7.0.7"
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"
   integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==
 
-"@types/mocha@^8.2.2":
-  version "8.2.2"
-  resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-8.2.2.tgz#91daa226eb8c2ff261e6a8cbf8c7304641e095e0"
-  integrity sha512-Lwh0lzzqT5Pqh6z61P3c3P5nm6fzQK/MMHl9UKeneAeInVflBSz1O2EkX6gM6xfJd7FBXBY5purtLx7fUiZ7Hw==
-
 "@types/node@*":
   version "14.14.37"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.37.tgz#a3dd8da4eb84a996c36e331df98d82abd76b516e"

From 180474dc17b20f28818a0e1cecab9e806b057e8c Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 14:02:42 +0100
Subject: [PATCH 014/317] fix "he" dep thanks @sodatea

---
 dist/vue.common.dev.js                     | 1135 ++++++++++++++-----
 dist/vue.common.prod.js                    |    2 +-
 dist/vue.esm.browser.js                    | 1135 ++++++++++++++-----
 dist/vue.esm.browser.min.js                |    2 +-
 dist/vue.esm.js                            | 1136 +++++++++++++++-----
 dist/vue.js                                | 1135 ++++++++++++++-----
 dist/vue.min.js                            |    2 +-
 dist/vue.runtime.common.dev.js             |  628 +++++++++--
 dist/vue.runtime.common.prod.js            |    2 +-
 dist/vue.runtime.esm.js                    |  628 +++++++++--
 dist/vue.runtime.js                        |  628 +++++++++--
 dist/vue.runtime.min.js                    |    2 +-
 packages/vue-server-renderer/basic.js      |  555 +++++++++-
 packages/vue-server-renderer/build.dev.js  |  214 +++-
 packages/vue-server-renderer/build.prod.js |    2 +-
 packages/vue-template-compiler/browser.js  |  386 ++++++-
 packages/vue-template-compiler/build.js    |   42 +-
 scripts/config.js                          |    7 +-
 src/compiler/parser/index.ts               |    4 +-
 19 files changed, 6135 insertions(+), 1510 deletions(-)

diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index 3e862a975ab..9ed78bbde65 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -4749,9 +4749,9 @@ Vue.version = '2.6.12';
 // during template compilation
 var isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+var acceptValue$1 = makeMap('input,textarea,option,select,progress');
+var mustUseProp$1 = function (tag, type, attr) {
+    return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
@@ -4857,7 +4857,7 @@ var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4870,15 +4870,14 @@ var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isPreTag = function (tag) { return tag === 'pre'; };
-var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag);
+var isReservedTag$1 = function (tag) {
+    return isHTMLTag$1(tag) || isSVG$1(tag);
 };
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
+function getTagNamespace$1(tag) {
+    if (isSVG$1(tag)) {
         return 'svg';
     }
     // basic support for MathML
@@ -4893,7 +4892,7 @@ function isUnknownElement(tag) {
     if (!inBrowser) {
         return true;
     }
-    if (isReservedTag(tag)) {
+    if (isReservedTag$1(tag)) {
         return false;
     }
     tag = tag.toLowerCase();
@@ -4917,7 +4916,7 @@ var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 /**
  * Query an element selector if it's not an element already.
  */
-function query(el) {
+function query$1(el) {
     if (typeof el === 'string') {
         var selected = document.querySelector(el);
         if (!selected) {
@@ -6425,127 +6424,10 @@ function parseString(chr) {
     }
 }
 
-var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
+var RANGE_TOKEN$1 = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
-        (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
-    addHandler(el, 'change', "var $$a=" + value + "," +
-        '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
-        'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
-        '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-        ".call($event.target.options,function(o){return o.selected})" +
-        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
-            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    var valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
-    }
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = "if($event.target.composing)return;" + code;
-    }
-    addProp(el, 'value', "(" + value + ")");
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6553,11 +6435,11 @@ function genDefaultModel(el, value, modifiers) {
 // user-attached handlers.
 function normalizeEvents(on) {
     /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
+    if (isDef(on[RANGE_TOKEN$1])) {
         // IE input[type=range] only supports `change` event
         var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
-        delete on[RANGE_TOKEN];
+        on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+        delete on[RANGE_TOKEN$1];
     }
     // This was originally intended to fix #4521 but no longer necessary
     // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6680,7 +6562,7 @@ function updateDOMProps(oldVnode, vnode) {
             }
         }
         else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
+            isSVG$1(elm.tagName) &&
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
@@ -6885,12 +6767,12 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+var whitespaceRE$2 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass(el, cls) {
+function addClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6898,7 +6780,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6915,7 +6797,7 @@ function addClass(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass(el, cls) {
+function removeClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6923,7 +6805,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6948,7 +6830,7 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def) {
+function resolveTransition$1(def) {
     if (!def) {
         return;
     }
@@ -6956,16 +6838,16 @@ function resolveTransition(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
+            extend(res, autoCssTransition$1(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition(def);
+        return autoCssTransition$1(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+var autoCssTransition$1 = cached(function (name) {
     return {
         enterClass: name + "-enter",
         enterToClass: name + "-enter-to",
@@ -6975,59 +6857,59 @@ var autoCssTransition = cached(function (name) {
         leaveActiveClass: name + "-leave-active",
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+var hasTransition$1 = inBrowser && !isIE9;
+var TRANSITION$1 = 'transition';
+var ANIMATION$1 = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
+var transitionProp$1 = 'transition';
+var transitionEndEvent$1 = 'transitionend';
+var animationProp$1 = 'animation';
+var animationEndEvent$1 = 'animationend';
+if (hasTransition$1) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
+        transitionProp$1 = 'WebkitTransition';
+        transitionEndEvent$1 = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
+        animationProp$1 = 'WebkitAnimation';
+        animationEndEvent$1 = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+var raf$1 = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
+function nextFrame$1(fn) {
+    raf$1(function () {
         // @ts-expect-error
-        raf(fn);
+        raf$1(fn);
     });
 }
-function addTransitionClass(el, cls) {
+function addTransitionClass$1(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass(el, cls);
+        addClass$1(el, cls);
     }
 }
-function removeTransitionClass(el, cls) {
+function removeTransitionClass$1(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass(el, cls);
+    removeClass$1(el, cls);
 }
-function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+function whenTransitionEnds$1(el, expectedType, cb) {
+    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -7047,30 +6929,30 @@ function whenTransitionEnds(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
+var transformRE$1 = /\b(transform|all)(,|$)/;
+function getTransitionInfo$1(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
+    if (expectedType === TRANSITION$1) {
         if (transitionTimeout > 0) {
-            type = TRANSITION;
+            type = TRANSITION$1;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION) {
+    else if (expectedType === ANIMATION$1) {
         if (animationTimeout > 0) {
-            type = ANIMATION;
+            type = ANIMATION$1;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -7080,16 +6962,16 @@ function getTransitionInfo(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
+                    ? TRANSITION$1
+                    : ANIMATION$1
                 : null;
         propCount = type
-            ? type === TRANSITION
+            ? type === TRANSITION$1
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -7097,31 +6979,31 @@ function getTransitionInfo(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout(delays, durations) {
+function getTimeout$1(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
+        return toMs$1(d) + toMs$1(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs(s) {
+function toMs$1(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
+function enter$1(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7159,19 +7041,19 @@ function enter(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
+        checkDuration$1(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
+    var userWantsControl = getHookArgumentsLength$1(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
+            removeTransitionClass$1(el, toClass);
+            removeTransitionClass$1(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, startClass);
+                removeTransitionClass$1(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -7196,19 +7078,19 @@ function enter(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
+        addTransitionClass$1(el, startClass);
+        addTransitionClass$1(el, activeClass);
+        nextFrame$1(function () {
+            removeTransitionClass$1(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
+                addTransitionClass$1(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
+                    if (isValidDuration$1(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds(el, type, cb);
+                        whenTransitionEnds$1(el, type, cb);
                     }
                 }
             }
@@ -7222,14 +7104,14 @@ function enter(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave(vnode, rm) {
+function leave$1(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7239,23 +7121,23 @@ function leave(vnode, rm) {
     }
     var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
+    var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
+        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
+            removeTransitionClass$1(el, leaveToClass);
+            removeTransitionClass$1(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
+                removeTransitionClass$1(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -7283,19 +7165,19 @@ function leave(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
+            addTransitionClass$1(el, leaveClass);
+            addTransitionClass$1(el, leaveActiveClass);
+            nextFrame$1(function () {
+                removeTransitionClass$1(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
+                    addTransitionClass$1(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
+                        if (isValidDuration$1(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds(el, type, cb);
+                            whenTransitionEnds$1(el, type, cb);
                         }
                     }
                 }
@@ -7308,7 +7190,7 @@ function leave(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration(val, name, vnode) {
+function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
             ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -7318,7 +7200,7 @@ function checkDuration(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration(val) {
+function isValidDuration$1(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -7327,7 +7209,7 @@ function isValidDuration(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength(fn) {
+function getHookArgumentsLength$1(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -7335,7 +7217,7 @@ function getHookArgumentsLength(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -7344,7 +7226,7 @@ function getHookArgumentsLength(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter(vnode);
+        enter$1(vnode);
     }
 }
 var transition = inBrowser
@@ -7355,7 +7237,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave(vnode, rm);
+                leave$1(vnode, rm);
             }
             else {
                 rm();
@@ -7503,43 +7385,501 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
-        vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, function () {
-                el.style.display = originalDisplay;
-            });
+var whitespaceRE$1 = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
-            el.style.display = value ? originalDisplay : 'none';
+            el.classList.add(cls);
         }
-    },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            { return; }
-        vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, function () {
-                    el.style.display = el.__vOriginalDisplay;
-                });
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
+}
+
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+var autoCssTransition = cached(function (name) {
+    return {
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
+    };
+});
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
+// Transition property/event sniffing
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+var raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn$2("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
+        vnode = locateNode(vnode);
+        var transition = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            { return; }
+        vnode = locateNode(vnode);
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
             }
             else {
                 leave(vnode, function () {
@@ -7906,10 +8246,10 @@ var platformComponents = {
 };
 
 // install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
+Vue.config.mustUseProp = mustUseProp$1;
+Vue.config.isReservedTag = isReservedTag$1;
 Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.getTagNamespace = getTagNamespace$1;
 Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
@@ -7918,7 +8258,7 @@ extend(Vue.options.components, platformComponents);
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
 // public mount method
 Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
+    el = el && inBrowser ? query$1(el) : undefined;
     return mountComponent(this, el, hydrating);
 };
 // devtools global hook
@@ -7945,6 +8285,75 @@ if (inBrowser) {
     }, 0);
 }
 
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+var acceptValue = makeMap('input,textarea,option,select,progress');
+var mustUseProp = function (tag, type, attr) {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+var isPreTag = function (tag) { return tag === 'pre'; };
+var isReservedTag = function (tag) {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+makeMap('text,number,password,search,email,tel,url');
+
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            warn$2('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
+}
+
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -8058,11 +8467,20 @@ var style = {
     genData: genData$1,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+var decoder;
+var he = {
+    decode: function (html) {
+        decoder = decoder || document.createElement('div');
+        decoder.innerHTML = html;
+        return decoder.textContent;
+    },
+};
+
+makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -8358,7 +8776,7 @@ function parseHTML(html, options) {
     }
 }
 
-var he = require('he');
+// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8375,7 +8793,7 @@ var invalidAttributeRE = /[\s"'<>\/=]/;
 var decodeHTMLCached = cached(he.decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
-var warn;
+var warn$1;
 var delimiters;
 var transforms;
 var preTransforms;
@@ -8399,7 +8817,7 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn = options.warn || baseWarn;
+    warn$1 = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
@@ -8420,7 +8838,7 @@ function parse(template, options) {
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn(msg, range);
+            warn$1(msg, range);
         }
     }
     function closeElement(element) {
@@ -8501,7 +8919,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn,
+        warn: warn$1,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8533,7 +8951,7 @@ function parse(template, options) {
                 }
                 attrs.forEach(function (attr) {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn("Invalid dynamic argument expression: attribute names cannot contain " +
+                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
                             "spaces, quotes, <, >, / or =.", {
                             start: attr.start + attr.name.indexOf("["),
                             end: attr.start + attr.name.length,
@@ -8543,7 +8961,7 @@ function parse(template, options) {
             }
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
-                warn('Templates should only be responsible for mapping the state to the ' +
+                warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
                         ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
@@ -8734,7 +9152,7 @@ function processKey(el) {
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
@@ -8743,7 +9161,7 @@ function processKey(el) {
                     iterator === exp &&
                     parent_1 &&
                     parent_1.tag === 'transition-group') {
-                    warn("Do not use v-for index as key on <transition-group> children, " +
+                    warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
@@ -8766,7 +9184,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -8818,7 +9236,7 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
             ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
@@ -8830,7 +9248,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -8857,7 +9275,7 @@ function processSlotContent(el) {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn("the \"scope\" attribute for scoped slots have been deprecated and " +
+            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
                 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                 "can also be used on plain elements in addition to <template> to " +
                 "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -8867,7 +9285,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -8892,10 +9310,10 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn("<template v-slot> can only appear at the root level inside " +
+                        warn$1("<template v-slot> can only appear at the root level inside " +
                             "the receiving component", el);
                     }
                 }
@@ -8911,13 +9329,13 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
-                        warn("To avoid scope ambiguity, the default slot should also use " +
+                        warn$1("To avoid scope ambiguity, the default slot should also use " +
                             "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
@@ -8949,7 +9367,7 @@ function getSlotName(binding) {
             name = 'default';
         }
         else {
-            warn("v-slot shorthand syntax requires a slot name.", binding);
+            warn$1("v-slot shorthand syntax requires a slot name.", binding);
         }
     }
     return dynamicArgRE.test(name)
@@ -8963,7 +9381,7 @@ function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn("`key` does not work on <slot> because slots are abstract outlets " +
+            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
                 "and can possibly expand into multiple elements. " +
                 "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
         }
@@ -9002,7 +9420,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9016,14 +9434,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -9043,7 +9461,7 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
             }
             else {
                 // normal directives
@@ -9070,7 +9488,7 @@ function processAttrs(el) {
             {
                 var res = parseText(value, delimiters);
                 if (res) {
-                    warn(name + "=\"" + value + "\": " +
+                    warn$1(name + "=\"" + value + "\": " +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9113,7 +9531,7 @@ function makeAttrsMap(attrs) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9146,7 +9564,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9226,11 +9644,132 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model = {
+var model$1 = {
     preTransformNode: preTransformNode,
 };
 
-var modules = [klass, style, model];
+var modules = [klass, style, model$1];
+
+var warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+var RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        (trueValueBinding === 'true'
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
+    addHandler(el, 'change', "var $$a=" + value + "," +
+        '$$el=$event.target,' +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        'if(Array.isArray($$a)){' +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        '$$i=_i($$a,$$v);' +
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        ("return " + (number ? '_n(val)' : 'val') + "})");
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + genAssignmentCode(value, assignment);
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value_1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', "(" + value + ")");
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
 function text(el, dir) {
     if (dir.value) {
@@ -9245,11 +9784,24 @@ function html(el, dir) {
 }
 
 var directives = {
-    model: model$1,
+    model: model,
     text: text,
     html: html,
 };
 
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
+
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -10176,6 +10728,7 @@ function generateCodeFrame(source, start, end) {
 function repeat(str, n) {
     var result = '';
     if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
index 7dd3bc1ea9d..d63fd7d0d1c 100644
--- a/dist/vue.common.prod.js
+++ b/dist/vue.common.prod.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(){function e(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var o,a=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":o=r;break;case"splice":o=r.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&we(t),o.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function je(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=je(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Ae[r]||Ee;a[r]=i(e[r],t[r],n,r)}return a}function De(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Le(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=_e;be(!0),we(a),be(u)}return a}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),Z&&setTimeout(S)},Ve=!0}else if(J||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)He(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=ve(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=ve(f.text+u):""!==u&&s.push(ve(u)):st(u)&&st(f)?s[l]=ve(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return De(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=E,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var o=he(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Le(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=de();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Le(l,u,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return de();n(a)&&n(a.is)&&(i=a.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f=void 0;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=De(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):de()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(U&&!J){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var o=function(o){i.push(o);var a=Le(o,t,n,e);Ce(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=je(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=je(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=je($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;Ce(t,"$attrs",o&&o.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){le();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:je,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=je(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=De(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(J||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(J&&!q&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=J?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=U&&!q,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ni(e){Ti(function(){Ti(e)})}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,N=O&&v?v:l,E=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!q,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,N),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),E&&E(i),F&&(Ei(i,S),Ei(i,T),Ni(function(){ji(i,S),R.cancelled||(Ei(i,N),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ni(function(){ji(i,u),w.cancelled||(Ei(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=he(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,U?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});q&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),q&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t),(J||W)&&setTimeout(function(){Ji(e,t)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(E(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!E(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){(l=i[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(o.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=e(t,null,c),this.removed=u}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!U)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=U?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?Yn(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},go=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),_o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,No=/^<!\[/,Eo=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,function(e){return Do[e]})}function Ro(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,u=function(){if(n=e,r&&Eo(r)){var u=0,p=r.toLowerCase(),d=jo[p]||(jo[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return u=r.length,Eo(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(To.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(No.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(So);if(y)return l(y[0].length),"continue";var g=e.match(Oo);if(g){var _=c;return l(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(ko);if(t){var n={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Ao))&&(i=e.match(wo)||e.match($o));)i.start=c,l(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&f(r),s(n)&&r===n&&f(n));for(var u=a(n)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:Po(h,m)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,u,e.start,e.end)}(b),Fo(b.tagName,e)&&l(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Oo.test(w)||ko.test(w)||To.test(w)||No.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&l($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}f()}var Ho,Bo,Uo,zo,Vo,Ko,Jo,qo,Wo=require("he"),Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/[ \f\t\r\n]+/g,sa=g(Wo.decode),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Ho=t.warn||Sr,Ko=t.isPreTag||T,Jo=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Uo=Tr(t.modules,"transformNode"),zo=Tr(t.modules,"preTransformNode"),Vo=Tr(t.modules,"postTransformNode"),Bo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ko(e.tag)&&(c=!1);for(var f=0;f<Vo.length;f++)Vo[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return Ro(e,{warn:Ho,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<zo.length;h++)v=zo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ko(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):u.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(aa," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Bo))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var r=Pr(e,ia);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=va(r),u=c.name,a=c.dynamic,l=s[u]=ua("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=r.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Uo.length;i++)e=Uo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Jo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):Er(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Er(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Jo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,yo,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=Ir(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+r+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",r),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Nr(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:go,mustUseProp:jn,canBeLeftOpenTag:_o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var o=t.ifConditions[n].block;e(o),o.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Na={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(ja[t])o+=ja[t],Ta[t]&&a.push(t);else if("exact"===t){var n=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Na[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(){return function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g(function(e){var t=Yn(e);return t&&t.innerHTML}),ss=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},wn.compile=ns,module.exports=wn;
\ No newline at end of file
+"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(){function e(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var a,o=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":a=r;break;case"splice":a=r.slice(2)}return a&&s.observeArray(a),s.dep.notify(),o})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&we(t),a.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in A(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?A({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Ae[r]||Ee;o[r]=i(e[r],t[r],n,r)}return o}function je(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function De(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Pe(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var l=_e;be(!0),we(o),be(l)}return o}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch(function(e){return Re(e,r,i+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,r,i)}return a}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],qe=!1;function Je(){qe=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(Je),Z&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Je)}:function(){setTimeout(Je,0)};else{var Ze=1,Ge=new MutationObserver(Je),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),qe||(qe=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(o)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)He(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=tt(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=nt(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=tt(c)).name,n[c],f.capture)}function it(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=nt([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=nt([s,c]),o.merged=!0,e[i]=o}function at(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ot(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(a,o){var s=[];var c,l,u,f;for(c=0;c<a.length;c++)t(l=a[c])||"boolean"==typeof l||(u=s.length-1,f=s[u],Array.isArray(l)?l.length>0&&(st((l=e(l,(o||"")+"_"+c))[0])&&st(f)&&(s[u]=ve(f.text+l[0].text),l.shift()),s.push.apply(s,l)):i(l)?st(f)?s[u]=ve(f.text+l):""!==l&&s.push(ve(l)):st(l)&&st(f)?s[u]=ve(f.text+l.text):(r(a._isVList)&&n(l.tag)&&t(l.key)&&n(o)&&(l.key="__vlist"+o+"_"+c+"__"),s.push(l)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function lt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ut)&&delete n[l];return n}function ut(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=dt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ot(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=A(A({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function mt(e){return je(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):a?yt(a,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(a(n)){Array.isArray(n)&&(n=O(n));var o=void 0,s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?kt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=u,e._l=vt,e._t=ht,e._q=E,e._i=L,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=ct(l.inject,a),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=lt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var a=he(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var Lt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Lt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=De(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Jt(t,r,h),l&&(t.$slots=lt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},jt=Object.keys(Lt);function Dt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Ht;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",function(){return h(s,o)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=j(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout(function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=de();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},$n(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);at(o,c,l,u,!0)||at(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=De(u,l,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ot(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<jt.length;n++){var r=jt[n],i=t[r],a=Lt[r];i===a||i&&i._merged||(t[r]=i?Mt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,o,s,c,l,u){return(Array.isArray(s)||i(s))&&(l=c,c=s,s=void 0),r(u)&&(l=Ft),function(e,i,o,s,c){if(n(o)&&n(o.__ob__))return de();n(o)&&n(o.is)&&(i=o.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=ot(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var l,u;if("string"==typeof i){var f=void 0;u=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),l=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),o,s,void 0,void 0,e):o&&o.pre||!n(f=je(e.$options,"components",i))?new pe(i,o,s,void 0,void 0,e):Dt(f,o,e,s,i)}else l=Dt(i,o,e,s);return Array.isArray(l)?l:n(l)?(n(u)&&function e(i,a,o){i.ns=a;"foreignObject"===i.tag&&(a=void 0,o=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var l=i.children[s];n(l.tag)&&(t(l.ns)||r(o)&&"svg"!==l.tag)&&e(l,a,o)}}(l,u),n(o)&&function(e){a(e.style)&&et(e.style);a(e.class)&&et(e.class)}(o),l):de()}(e,o,s,c,l)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function qt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function Jt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,qt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,an=0;var on=0,sn=Date.now;if(U&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function ln(){var e,t;for(on=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),an=0;an<Qt.length;an++)(e=Qt[an]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();an=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var un=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>an&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(ln))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var a=function(a){i.push(a);var o=De(a,t,n,e);Ce(r,a,o),a in e||dn(e,"_props",a)};for(var o in t)a(o);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||(o=void 0,36!==(o=(a+"").charCodeAt(0))&&95!==o&&dn(e,"_data",a))}var o;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new fn(e,o||S,S,hn)),i in e||mn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Le(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach(function(e){o[e]=n[e]}),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=A({},o.options),i[r]=o,o}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=xn(o.componentOptions);s&&!t(s)&&On(n,a,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Jt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=lt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var a=r&&r.data;Ce(t,"$attrs",a&&a.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){ue();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,a=t.length;i<a;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,a=this.exclude;if(i&&(!r||!kn(i,r))||a&&r&&kn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:A,mergeOptions:Le,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),Ln=p("contenteditable,draggable,spellcheck"),jn=p("events,caret,typing,plaintext-only"),Dn=function(e,t){return Rn(t)||"false"===t?"false":"contenteditable"===e&&jn(t)?t:"true"},Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Fn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Pn=function(e){return Fn(e)?e.slice(6,e.length):""},Rn=function(e){return null==e||!1===e};function Hn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Bn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Bn(t,r.data));return function(e,t){if(n(e)||n(t))return Un(e,zn(t));return""}(t.staticClass,t.class)}function Bn(e,t){return{staticClass:Un(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Un(e,t){return e?t?e+" "+t:e:t||""}function zn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=zn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Jn=function(e){return Kn(e)||qn(e)};var Wn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Vn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Xn={create:function(e,t){Yn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(Yn(e,!0),Yn(t))},destroy:function(e){Yn(e,!0)}};function Yn(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var Qn=new pe("",{},[]),er=["create","activate","update","remove","destroy"];function tr(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Zn(i)&&Zn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function nr(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var rr={create:ir,update:ir,destroy:function(e){ir(e,Qn)}};function ir(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===Qn,o=t===Qn,s=or(e.data.directives,e.context),c=or(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,cr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(cr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)cr(l[n],"inserted",t,e)};a?it(t,"insert",f):f()}u.length&&it(t,"postpatch",function(){for(var n=0;n<u.length;n++)cr(u[n],"componentUpdated",t,e)});if(!a)for(n in s)c[n]||cr(s[n],"unbind",e,e,o)}(e,t)}var ar=Object.create(null);function or(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ar),i[sr(r)]=r,r.def=je(t.$options,"directives",r.name);return i}function sr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function cr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var lr=[Xn,rr];function ur(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=A({},l)),l)o=l[a],c[a]!==o&&fr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&fr(s,"value",l.value),c)t(l[a])&&(Fn(a)?s.removeAttributeNS(In,Pn(a)):Ln(a)||s.removeAttribute(a))}}function fr(e,t,n,r){r||e.tagName.indexOf("-")>-1?pr(e,t,n):Mn(t)?Rn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Ln(t)?e.setAttribute(t,Dn(t,n)):Fn(t)?Rn(n)?e.removeAttributeNS(In,Pn(t)):e.setAttributeNS(In,t,n):pr(e,t,n)}function pr(e,t,n){if(Rn(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var dr={create:ur,update:ur};function vr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Hn(r),c=i._transitionClasses;n(c)&&(s=Un(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var hr,mr,yr,gr,_r,br,$r={create:vr,update:vr},wr=/[\w).+\-_$\]]/;function Cr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&wr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=xr(i,a[r]);return i}function xr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function kr(e,t){console.error("[Vue compiler]: "+e)}function Ar(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Or(e,t,n,r,i){(e.props||(e.props=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Sr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Tr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Ir({name:t,value:n},r))}function Nr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Ir({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Er(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Lr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Er("!",n,c)),i.once&&(delete i.once,n=Er("~",n,c)),i.passive&&(delete i.passive,n=Er("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Ir({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function jr(e,t,n){var r=Dr(e,":"+t)||Dr(e,"v-bind:"+t);if(null!=r)return Cr(r);if(!1!==n){var i=Dr(e,t);if(null!=i)return JSON.stringify(i)}}function Dr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Mr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Ir(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Fr(e,t,n){var r=n||{},i=r.number,a="$$v";r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var o=Pr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+o+"}"}}function Pr(e,t){var n=function(e){if(e=e.trim(),hr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<hr-1)return(gr=e.lastIndexOf("."))>-1?{exp:e.slice(0,gr),key:'"'+e.slice(gr+1)+'"'}:{exp:e,key:null};mr=e,gr=_r=br=0;for(;!Hr();)Br(yr=Rr())?zr(yr):91===yr&&Ur(yr);return{exp:e.slice(0,_r),key:e.slice(_r+1,br)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Rr(){return mr.charCodeAt(++gr)}function Hr(){return gr>=hr}function Br(e){return 34===e||39===e}function Ur(e){var t=1;for(_r=gr;!Hr();)if(Br(e=Rr()))zr(e);else if(91===e&&t++,93===e&&t--,0===t){br=gr;break}}function zr(e){for(var t=e;!Hr()&&(e=Rr())!==t;);}var Vr,Kr="__r",qr="__c";function Jr(e,t,n){var r=Vr;return function i(){null!==t.apply(null,arguments)&&Gr(e,i,n,r)}}var Wr=Ve&&!(X&&Number(X[1])<=53);function Zr(e,t,n,r){if(Wr){var i=on,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Vr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Gr(e,t,n,r){(r||Vr).removeEventListener(e,t._wrapper||t,n)}function Xr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Vr=r.elm,function(e){if(n(e[Kr])){var t=q?"change":"input";e[t]=[].concat(e[Kr],e[t]||[]),delete e[Kr]}n(e[qr])&&(e.change=[].concat(e[qr],e.change||[]),delete e[qr])}(i),rt(i,a,Zr,Gr,Jr,r.context),Vr=void 0}}var Yr,Qr={create:Xr,update:Xr};function ei(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ti(o,l)&&(o.value=l)}else if("innerHTML"===i&&qn(o.tagName)&&t(o.innerHTML)){(Yr=Yr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Yr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ti(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ni={create:ei,update:ei},ri=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function ii(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ri(e):e}var oi,si=/^--/,ci=/\s*!important$/,li=function(e,t,n){if(si.test(t))e.style.setProperty(t,n);else if(ci.test(n))e.style.setProperty(C(t),n.replace(ci,""),"important");else{var r=fi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},ui=["Webkit","Moz","ms"],fi=g(function(e){if(oi=oi||document.createElement("div").style,"filter"!==(e=b(e))&&e in oi)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<ui.length;n++){var r=ui[n]+t;if(r in oi)return r}});function pi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ii(i.data))&&A(r,n);(n=ii(e.data))&&A(r,n);for(var a=e;a=a.parent;)a.data&&(n=ii(a.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(o=d[s])!==f[s]&&li(c,s,null==o?"":o)}}var di={create:pi,update:pi},vi=/\s+/;function hi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,mi(e.name||"v")),A(t,e),t}return"string"==typeof e?mi(e):void 0}}var mi=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),yi="transition",gi="animation",_i="transition",bi="transitionend",$i="animation",wi="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_i="WebkitTransition",bi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($i="WebkitAnimation",wi="webkitAnimationEnd"));var Ci=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function xi(e){Ci(function(){Ci(e)})}function ki(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Oi(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[_i+"Delay"]||"").split(", "),a=(r[_i+"Duration"]||"").split(", "),o=Ti(i,a),s=(r[$i+"Delay"]||"").split(", "),c=(r[$i+"Duration"]||"").split(", "),l=Ti(s,c),u=0,f=0;t===yi?o>0&&(n=yi,u=o,f=a.length):t===gi?l>0&&(n=gi,u=l,f=c.length):(u=Math.max(o,l),f=(n=u>0?o>l?yi:gi:null)?n===yi?a.length:c.length:0);var p=n===yi&&Si.test(r[_i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===yi?bi:wi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var Si=/\b(transform|all)(,|$)/;function Ti(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Ni(t)+Ni(e[n])}))}function Ni(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ei(e){return"number"==typeof e&&!isNaN(e)}function Li(e){if(t(e))return!1;var r=e.fns;return n(r)?Li(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ji(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=hi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Li(L),R=i._enterCb=j(function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ki(i,S),ki(i,T),xi(function(){Ai(i,S),R.cancelled||(ki(i,N),P||(Ei(I)?setTimeout(R,I):Oi(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Di=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<er.length;++a)for(s[er[a]]=[],o=0;o<c.length;++o)n(c[o][er[a]])&&s[er[a]].push(c[o][er[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=he(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){for(var a,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,n(a=o.data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](Qn,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(Yn(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](Qn,e);n(a=e.data.hook)&&(n(a.create)&&a.create(Qn,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&tr(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:tr(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):tr(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):tr(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):tr(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=nr(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):tr(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&tr(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Qn,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else Yn(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Gn,modules:[dr,$r,Qr,ni,di,U?{create:ji,activate:ji,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=hi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Li(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ki(i,l),ki(i,p),xi(function(){Ai(i,l),w.cancelled||(ki(i,u),b||(Ei($)?setTimeout(w,$):Oi(i,c,w)))})),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(lr)});J&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Ui(e,"input")});var Mi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Mi.componentUpdated(e,t,n)}):Ii(e,t,n.context),e._vOptions=[].map.call(e.options,Ri)):("textarea"===n.tag||Zn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Hi),e.addEventListener("compositionend",Bi),e.addEventListener("change",Bi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ii(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ri);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return Pi(e,i)}):t.value!==t.oldValue&&Pi(t.value,i))&&Ui(e,"change")}}};function Ii(e,t,n){Fi(e,t),(q||W)&&setTimeout(function(){Fi(e,t)},0)}function Fi(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Ri(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Ri(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Pi(e,t){return t.every(function(t){return!E(t,e)})}function Ri(e){return"_value"in e?e._value:e.value}function Hi(e){e.target.composing=!0}function Bi(e){e.target.composing&&(e.target.composing=!1,Ui(e.target,"input"))}function Ui(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var zi=/\s+/;function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ki(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function qi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,Ji(e.name||"v")),A(t,e),t}return"string"==typeof e?Ji(e):void 0}}var Ji=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Wi=U&&!J,Zi="transition",Gi="animation",Xi="transition",Yi="transitionend",Qi="animation",ea="animationend";Wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xi="WebkitTransition",Yi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Qi="WebkitAnimation",ea="webkitAnimationEnd"));var ta=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function na(e){ta(function(){ta(e)})}function ra(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),Vi(e,t))}function ia(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ki(e,t)}function aa(e,t,n){var r=sa(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Zi?Yi:ea,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var oa=/\b(transform|all)(,|$)/;function sa(e,t){var n,r=window.getComputedStyle(e),i=(r[Xi+"Delay"]||"").split(", "),a=(r[Xi+"Duration"]||"").split(", "),o=ca(i,a),s=(r[Qi+"Delay"]||"").split(", "),c=(r[Qi+"Duration"]||"").split(", "),l=ca(s,c),u=0,f=0;return t===Zi?o>0&&(n=Zi,u=o,f=a.length):t===Gi?l>0&&(n=Gi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Zi:Gi:null)?n===Zi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Zi&&oa.test(r[Xi+"Property"])}}function ca(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return la(t)+la(e[n])}))}function la(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ua(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=qi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=pa(L),R=i._enterCb=j(function(){F&&(ia(i,N),ia(i,T)),R.cancelled?(F&&ia(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ra(i,S),ra(i,T),na(function(){ia(i,S),R.cancelled||(ra(i,N),P||(fa(I)?setTimeout(R,I):aa(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function fa(e){return"number"==typeof e&&!isNaN(e)}function pa(e){if(t(e))return!1;var r=e.fns;return n(r)?pa(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}var va={model:Mi,show:{bind:function(e,t,n){var r=t.value,i=(n=da(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,ua(n,function(){e.style.display=a})):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=da(i)).data&&i.data.transition?(i.data.show=!0,o?ua(i,function(){e.style.display=e.__vOriginalDisplay}):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=qi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=pa(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ia(i,u),ia(i,p)),w.cancelled?(_&&ia(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ra(i,l),ra(i,p),na(function(){ia(i,l),w.cancelled||(ra(i,u),b||(fa($)?setTimeout(w,$):aa(i,c,w)))})),v&&v(i,w),_||b||w())}}(i,function(){e.style.display="none"})):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ha={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ma(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ma(zt(t.children)):e}function ya(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ga(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var _a=function(e){return e.tag||Ut(e)},ba=function(e){return"show"===e.name},$a={name:"transition",props:ha,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(_a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ma(a);if(!o)return a;if(this._leaving)return ga(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=ya(this),l=this._vnode,u=ma(l);if(o.data.directives&&o.data.directives.some(ba)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Ut(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ga(e,a);if("in-out"===r){if(Ut(o))return l;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return a}}},wa=A({tag:String,moveClass:String},ha);function Ca(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function xa(e){e.data.newPos=e.elm.getBoundingClientRect()}function ka(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete wa.mode;var Aa={Transition:$a,TransitionGroup:{props:wa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=ya(this),s=0;s<i.length;s++){(u=i[s]).tag&&null!=u.key&&0!==String(u.key).indexOf("__vlist")&&(a.push(u),n[u.key]=u,(u.data||(u.data={})).transition=o)}if(r){var c=[],l=[];for(s=0;s<r.length;s++){var u;(u=r[s]).data.transition=o,u.data.pos=u.elm.getBoundingClientRect(),n[u.key]?c.push(u):l.push(u)}this.kept=e(t,null,c),this.removed=l}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Ca),e.forEach(xa),e.forEach(ka),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;ra(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Yi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Yi,e),n._moveCb=null,ia(n,t))})}}))},methods:{hasMove:function(e,t){if(!Wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Ki(n,e)}),Vi(n,t),n.style.display="none",this.$el.appendChild(n);var r=sa(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},wn.config.isReservedTag=Jn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=function(e){return qn(e)?"svg":"math"===e?"math":void 0},wn.config.isUnknownElement=function(e){if(!U)return!0;if(Jn(e))return!1;if(e=e.toLowerCase(),null!=Wn[e])return Wn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Wn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Wn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,va),A(wn.options.components,Aa),wn.prototype.__patch__=U?Di:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var Oa=p("input,textarea,option,select,progress"),Sa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ta=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Na(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Ea=/\{\{((?:.|\r?\n)+?)\}\}/g,La=/[-.*+?^${}()|[\]\/\\]/g,ja=g(function(e){var t=e[0].replace(La,"\\$&"),n=e[1].replace(La,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var Da={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Dr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=jr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Ma,Ia={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Dr(e,"style");n&&(e.staticStyle=JSON.stringify(ri(n)));var r=jr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Fa=function(e){return(Ma=Ma||document.createElement("div")).innerHTML=e,Ma.textContent},Pa=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ra=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ha=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ba="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ua="((?:"+Ba+"\\:)?"+Ba+")",za=new RegExp("^<"+Ua),Va=/^\s*(\/?)>/,Ka=new RegExp("^<\\/"+Ua+"[^>]*>"),qa=/^<!DOCTYPE [^>]+>/i,Ja=/^<!\--/,Wa=/^<!\[/,Za=p("script,style,textarea",!0),Ga={},Xa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ya=/&(?:lt|gt|quot|amp|#39);/g,Qa=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,eo=p("pre,textarea",!0),to=function(e,t){return e&&eo(e)&&"\n"===t[0]};function no(e,t){var n=t?Qa:Ya;return e.replace(n,function(e){return Xa[e]})}function ro(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,l=function(){if(n=e,r&&Za(r)){var l=0,p=r.toLowerCase(),d=Ga[p]||(Ga[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return l=r.length,Za(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),to(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-l,c)}else{var v=e.indexOf("<");if(0===v){if(Ja.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),u(h+3),"continue"}if(Wa.test(e)){var m=e.indexOf("]>");if(m>=0)return u(m+2),"continue"}var y=e.match(qa);if(y)return u(y[0].length),"continue";var g=e.match(Ka);if(g){var _=c;return u(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(za);if(t){var n={tagName:t[1],attrs:[],start:c};u(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Va))&&(i=e.match(Ha)||e.match(Ra));)i.start=c,u(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],u(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Pa(n)&&f(r),s(n)&&r===n&&f(n));for(var l=o(n)||!!c,u=e.attrs.length,p=new Array(u),d=0;d<u;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:no(h,m)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,l,e.start,e.end)}(b),to(b.tagName,e)&&u(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Ka.test(w)||za.test(w)||Ja.test(w)||Wa.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&u($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===l())break}function u(t){c+=t,e=e.substring(t)}function f(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}f()}var io,ao,oo,so,co,lo,uo,fo,po=/^@|^v-on:/,vo=/^v-|^@|^:|^#/,ho=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,mo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,yo=/^\(|\)$/g,go=/^\[.*\]$/,_o=/:(.*)$/,bo=/^:|^\.|^v-bind:/,$o=/\.[^.\]]+(?=[^\]]*$)/g,wo=/^v-slot(:|$)|^#/,Co=/[\r\n]/,xo=/[ \f\t\r\n]+/g,ko=g(Fa),Ao="_empty_";function Oo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Do(t),rawAttrsMap:{},parent:n,children:[]}}function So(e,t){io=t.warn||kr,lo=t.isPreTag||T,uo=t.mustUseProp||T,fo=t.getTagNamespace||T,t.isReservedTag,oo=Ar(t.modules,"transformNode"),so=Ar(t.modules,"preTransformNode"),co=Ar(t.modules,"postTransformNode"),ao=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=To(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Eo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Eo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter(function(e){return!e.slotScope}),u(e),e.pre&&(s=!1),lo(e.tag)&&(c=!1);for(var f=0;f<co.length;f++)co[f](e,t)}function u(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return ro(e,{warn:io,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||fo(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Mo.test(r.name)||(r.name=r.name.replace(Io,""),t.push(r))}return t}(a));var d,v=Oo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<so.length;h++)v=so[h](v,t)||v;s||(!function(e){null!=Dr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),lo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(No(v),function(e){var t=Dr(e,"v-if");if(t)e.if=t,Eo(e,{exp:t,block:e});else{null!=Dr(e,"v-else")&&(e.else=!0);var n=Dr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Dr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):l.length?o?"condense"===o&&Co.test(e)?"":" ":a?" ":"":""){c||"condense"!==o||(e=e.replace(xo," "));var u=void 0,f=void 0;!s&&" "!==e&&(u=function(e,t){var n=t?ja(t):Ea;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Cr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,ao))?f={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&l.length&&" "===l[l.length-1].text||(f={type:3,text:e}),f&&l.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function To(e,t){var n,r;(r=jr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dr(e,"scope"),e.slotScope=t||Dr(e,"slot-scope")):(t=Dr(e,"slot-scope"))&&(e.slotScope=t);var n=jr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Sr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Mr(e,wo);if(r){var i=Lo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Ao}}else{var r=Mr(e,wo);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=Lo(r),l=c.name,o=c.dynamic,u=s[l]=Oo("template",[],e);u.slotTarget=l,u.slotTargetDynamic=o,u.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=u,!0}),u.slotScope=r.value||Ao,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jr(e,"name"))}(e),function(e){var t;(t=jr(e,"is"))&&(e.component=t);null!=Dr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<oo.length;i++)e=oo[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,vo.test(r))if(e.hasBindings=!0,(o=jo(r.replace(vo,"")))&&(r=r.replace($o,"")),bo.test(r))r=r.replace(bo,""),a=Cr(a),(c=go.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Pr(a,"$event"),c?Lr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Lr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Lr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&uo(e.tag,e.attrsMap.type,r)?Or(e,r,a,l[t],c):Sr(e,r,a,l[t],c);else if(po.test(r))r=r.replace(po,""),(c=go.test(r))&&(r=r.slice(1,-1)),Lr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(vo,"")).match(_o),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),go.test(f)&&(f=f.slice(1,-1),c=!0)),Nr(e,r,i,a,f,c,o,l[t])}else Sr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&uo(e.tag,e.attrsMap.type,r)&&Or(e,r,"true",l[t])}(e),e}function No(e){var t;if(t=Dr(e,"v-for")){var n=function(e){var t=e.match(ho);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(yo,""),i=r.match(mo);i?(n.alias=r.replace(mo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function Eo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Lo(e){var t=e.name.replace(wo,"");return t||"#"!==e.name[0]&&(t="default"),go.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function jo(e){var t=e.match($o);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function Do(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Mo=/^xmlns:NS\d+/,Io=/^NS\d+:/;function Fo(e){return Oo(e.tag,e.attrsList.slice(),e.parent)}var Po=[Da,Ia,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=jr(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Dr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Dr(e,"v-else",!0),s=Dr(e,"v-else-if",!0),c=Fo(e);No(c),Tr(c,"type","checkbox"),To(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+a,Eo(c,{exp:c.if,block:c});var l=Fo(e);Dr(l,"v-for",!0),Tr(l,"type","radio"),To(l,t),Eo(c,{exp:"("+r+")==='radio'"+a,block:l});var u=Fo(e);return Dr(u,"v-for",!0),Tr(u,":type",r),To(u,t),Eo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}],Ro="__r";var Ho,Bo,Uo={expectHTML:!0,modules:Po,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Fr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Pr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null",a=jr(e,"true-value")||"true",o=jr(e,"false-value")||"false";Or(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Lr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pr(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null";Or(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Lr(e,"change",Pr(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?Ro:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),o&&(u="_n("+u+")");var f=Pr(t,u);c&&(f="if($event.target.composing)return;"+f),Or(e,"value","("+t+")"),Lr(e,l,f,null,!0),(s||o)&&Lr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Fr(e,r,i),!1;return!0},text:function(e,t){t.value&&Or(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Or(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Oa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Sa(e)||Ta(e)},getTagNamespace:function(e){return Ta(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Po)},zo=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(t);if(1===t.type){if(!Bo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var a=t.ifConditions[n].block;e(a),a.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Ko=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,qo=/\([^)]*?\);*$/,Jo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Go=function(e){return"if("+e+")return null;"},Xo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Go("$event.target !== $event.currentTarget"),ctrl:Go("!$event.ctrlKey"),shift:Go("!$event.shiftKey"),alt:Go("!$event.altKey"),meta:Go("!$event.metaKey"),left:Go("'button' in $event && $event.button !== 0"),middle:Go("'button' in $event && $event.button !== 1"),right:Go("'button' in $event && $event.button !== 2")};function Yo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Qo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Qo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Qo(e)}).join(",")+"]";var t=Jo.test(e.value),n=Ko.test(e.value),r=Jo.test(e.value.replace(qo,""));if(e.modifiers){var i="",a="",o=[],s=function(t){if(Xo[t])a+=Xo[t],Wo[t]&&o.push(t);else if("exact"===t){var n=e.modifiers;a+=Go(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else o.push(t)};for(var c in e.modifiers)s(c);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(es).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function es(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Wo[e],r=Zo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ts={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},ns=function(){return function(e){this.options=e,this.warn=e.warn||kr,this.transforms=Ar(e.modules,"transformCode"),this.dataGenFns=Ar(e.modules,"genData"),this.directives=A(A({},ts),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function rs(e,t){var n=new ns(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":is(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function is(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return as(e,t);if(e.once&&!e.onceProcessed)return os(e,t);if(e.for&&!e.forProcessed)return cs(e,t);if(e.if&&!e.ifProcessed)return ss(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ps(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?hs((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ps(t,n,!0);return"_c("+e+","+ls(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ls(e,t));var i=e.inlineTemplate?null:ps(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ps(e,t)||"void 0"}function as(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+is(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function os(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ss(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+is(e,t)+","+t.onceId+++","+n+")":is(e,t)}return as(e,t)}function ss(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var a=t.shift();return a.exp?"("+a.exp+")?"+o(a.block)+":"+e(t,n,r,i):""+o(a.block);function o(e){return r?r(e,n):e.once?os(e,n):is(e,n)}}(e.ifConditions.slice(),t,n,r)}function cs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||is)(e,t)+"})"}function ls(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+hs(e.attrs)+","),e.props&&(n+="domProps:"+hs(e.props)+","),e.events&&(n+=Yo(e.events,!1)+","),e.nativeEvents&&(n+=Yo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||us(n)}),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Ao||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map(function(e){return fs(t[e],n)}).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=rs(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+hs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function us(e){return 1===e.type&&("slot"===e.tag||e.children.some(us))}function fs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ss(e,t,fs,"null");if(e.for&&!e.forProcessed)return cs(e,t,fs);var r=e.slotScope===Ao?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ps(e,t)||"undefined")+":undefined":ps(e,t)||"undefined":is(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ps(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||is)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ds(i)||i.ifConditions&&i.ifConditions.some(function(e){return ds(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||vs;return"["+a.map(function(e){return l(e,t)}).join(",")+"]"+(c?","+c:"")}}function ds(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function vs(e,t){return 1===e.type?is(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:ms(JSON.stringify(n.text)))+")";var n,r}function hs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ms(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ms(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ys(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function gs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=ys(o.render,c),s.staticRenderFns=o.staticRenderFns.map(function(e){return ys(e,c)}),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var _s,bs,$s=(_s=function(e,t){var n=So(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=rs(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=_s(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:gs(t)}})(Uo).compileToFunctions;function ws(e){return(bs=bs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',bs.innerHTML.indexOf("&#10;")>0}var Cs=!!U&&ws(!1),xs=!!U&&ws(!0),ks=g(function(e){var t=Na(e);return t&&t.innerHTML}),As=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Na(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ks(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=$s(r,{outputSourceRange:!1,shouldDecodeNewlines:Cs,shouldDecodeNewlinesForHref:xs,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return As.call(this,e,t)},wn.compile=$s,module.exports=wn;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index 25da182ed27..12289be017a 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -4743,9 +4743,9 @@ Vue.version = '2.6.12';
 // during template compilation
 var isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+var acceptValue$1 = makeMap('input,textarea,option,select,progress');
+var mustUseProp$1 = function (tag, type, attr) {
+    return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
@@ -4851,7 +4851,7 @@ var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4864,15 +4864,14 @@ var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isPreTag = function (tag) { return tag === 'pre'; };
-var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag);
+var isReservedTag$1 = function (tag) {
+    return isHTMLTag$1(tag) || isSVG$1(tag);
 };
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
+function getTagNamespace$1(tag) {
+    if (isSVG$1(tag)) {
         return 'svg';
     }
     // basic support for MathML
@@ -4887,7 +4886,7 @@ function isUnknownElement(tag) {
     if (!inBrowser) {
         return true;
     }
-    if (isReservedTag(tag)) {
+    if (isReservedTag$1(tag)) {
         return false;
     }
     tag = tag.toLowerCase();
@@ -4911,7 +4910,7 @@ var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 /**
  * Query an element selector if it's not an element already.
  */
-function query(el) {
+function query$1(el) {
     if (typeof el === 'string') {
         var selected = document.querySelector(el);
         if (!selected) {
@@ -6419,127 +6418,10 @@ function parseString(chr) {
     }
 }
 
-var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
+var RANGE_TOKEN$1 = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
-        (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
-    addHandler(el, 'change', "var $$a=" + value + "," +
-        '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
-        'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
-        '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-        ".call($event.target.options,function(o){return o.selected})" +
-        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
-            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    var valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
-    }
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = "if($event.target.composing)return;" + code;
-    }
-    addProp(el, 'value', "(" + value + ")");
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6547,11 +6429,11 @@ function genDefaultModel(el, value, modifiers) {
 // user-attached handlers.
 function normalizeEvents(on) {
     /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
+    if (isDef(on[RANGE_TOKEN$1])) {
         // IE input[type=range] only supports `change` event
         var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
-        delete on[RANGE_TOKEN];
+        on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+        delete on[RANGE_TOKEN$1];
     }
     // This was originally intended to fix #4521 but no longer necessary
     // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6674,7 +6556,7 @@ function updateDOMProps(oldVnode, vnode) {
             }
         }
         else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
+            isSVG$1(elm.tagName) &&
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
@@ -6879,12 +6761,12 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+var whitespaceRE$2 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass(el, cls) {
+function addClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6892,7 +6774,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6909,7 +6791,7 @@ function addClass(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass(el, cls) {
+function removeClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6917,7 +6799,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6942,7 +6824,7 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def) {
+function resolveTransition$1(def) {
     if (!def) {
         return;
     }
@@ -6950,16 +6832,16 @@ function resolveTransition(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
+            extend(res, autoCssTransition$1(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition(def);
+        return autoCssTransition$1(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+var autoCssTransition$1 = cached(function (name) {
     return {
         enterClass: name + "-enter",
         enterToClass: name + "-enter-to",
@@ -6969,59 +6851,59 @@ var autoCssTransition = cached(function (name) {
         leaveActiveClass: name + "-leave-active",
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+var hasTransition$1 = inBrowser && !isIE9;
+var TRANSITION$1 = 'transition';
+var ANIMATION$1 = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
+var transitionProp$1 = 'transition';
+var transitionEndEvent$1 = 'transitionend';
+var animationProp$1 = 'animation';
+var animationEndEvent$1 = 'animationend';
+if (hasTransition$1) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
+        transitionProp$1 = 'WebkitTransition';
+        transitionEndEvent$1 = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
+        animationProp$1 = 'WebkitAnimation';
+        animationEndEvent$1 = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+var raf$1 = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
+function nextFrame$1(fn) {
+    raf$1(function () {
         // @ts-expect-error
-        raf(fn);
+        raf$1(fn);
     });
 }
-function addTransitionClass(el, cls) {
+function addTransitionClass$1(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass(el, cls);
+        addClass$1(el, cls);
     }
 }
-function removeTransitionClass(el, cls) {
+function removeTransitionClass$1(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass(el, cls);
+    removeClass$1(el, cls);
 }
-function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+function whenTransitionEnds$1(el, expectedType, cb) {
+    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         return cb();
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -7041,30 +6923,30 @@ function whenTransitionEnds(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
+var transformRE$1 = /\b(transform|all)(,|$)/;
+function getTransitionInfo$1(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
+    if (expectedType === TRANSITION$1) {
         if (transitionTimeout > 0) {
-            type = TRANSITION;
+            type = TRANSITION$1;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION) {
+    else if (expectedType === ANIMATION$1) {
         if (animationTimeout > 0) {
-            type = ANIMATION;
+            type = ANIMATION$1;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -7074,16 +6956,16 @@ function getTransitionInfo(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
+                    ? TRANSITION$1
+                    : ANIMATION$1
                 : null;
         propCount = type
-            ? type === TRANSITION
+            ? type === TRANSITION$1
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -7091,31 +6973,31 @@ function getTransitionInfo(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout(delays, durations) {
+function getTimeout$1(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
+        return toMs$1(d) + toMs$1(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs(s) {
+function toMs$1(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
+function enter$1(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7153,19 +7035,19 @@ function enter(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
+        checkDuration$1(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
+    var userWantsControl = getHookArgumentsLength$1(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
+            removeTransitionClass$1(el, toClass);
+            removeTransitionClass$1(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, startClass);
+                removeTransitionClass$1(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -7190,19 +7072,19 @@ function enter(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
+        addTransitionClass$1(el, startClass);
+        addTransitionClass$1(el, activeClass);
+        nextFrame$1(function () {
+            removeTransitionClass$1(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
+                addTransitionClass$1(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
+                    if (isValidDuration$1(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds(el, type, cb);
+                        whenTransitionEnds$1(el, type, cb);
                     }
                 }
             }
@@ -7216,14 +7098,14 @@ function enter(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave(vnode, rm) {
+function leave$1(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7233,23 +7115,23 @@ function leave(vnode, rm) {
     }
     var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
+    var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
+        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
+            removeTransitionClass$1(el, leaveToClass);
+            removeTransitionClass$1(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
+                removeTransitionClass$1(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -7277,19 +7159,19 @@ function leave(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
+            addTransitionClass$1(el, leaveClass);
+            addTransitionClass$1(el, leaveActiveClass);
+            nextFrame$1(function () {
+                removeTransitionClass$1(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
+                    addTransitionClass$1(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
+                        if (isValidDuration$1(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds(el, type, cb);
+                            whenTransitionEnds$1(el, type, cb);
                         }
                     }
                 }
@@ -7302,7 +7184,7 @@ function leave(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration(val, name, vnode) {
+function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
             ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -7312,7 +7194,7 @@ function checkDuration(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration(val) {
+function isValidDuration$1(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -7321,7 +7203,7 @@ function isValidDuration(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength(fn) {
+function getHookArgumentsLength$1(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -7329,7 +7211,7 @@ function getHookArgumentsLength(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -7338,7 +7220,7 @@ function getHookArgumentsLength(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter(vnode);
+        enter$1(vnode);
     }
 }
 var transition = inBrowser
@@ -7349,7 +7231,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave(vnode, rm);
+                leave$1(vnode, rm);
             }
             else {
                 rm();
@@ -7497,43 +7379,501 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
-        vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, function () {
-                el.style.display = originalDisplay;
-            });
+var whitespaceRE$1 = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
-            el.style.display = value ? originalDisplay : 'none';
+            el.classList.add(cls);
         }
-    },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, function () {
-                    el.style.display = el.__vOriginalDisplay;
-                });
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
+}
+
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+var autoCssTransition = cached(function (name) {
+    return {
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
+    };
+});
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
+// Transition property/event sniffing
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+var raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    if (!type)
+        return cb();
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn$2("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
+        vnode = locateNode(vnode);
+        var transition = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
             }
             else {
                 leave(vnode, function () {
@@ -7900,10 +8240,10 @@ var platformComponents = {
 };
 
 // install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
+Vue.config.mustUseProp = mustUseProp$1;
+Vue.config.isReservedTag = isReservedTag$1;
 Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.getTagNamespace = getTagNamespace$1;
 Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
@@ -7912,7 +8252,7 @@ extend(Vue.options.components, platformComponents);
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
 // public mount method
 Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
+    el = el && inBrowser ? query$1(el) : undefined;
     return mountComponent(this, el, hydrating);
 };
 // devtools global hook
@@ -7939,6 +8279,75 @@ if (inBrowser) {
     }, 0);
 }
 
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+var acceptValue = makeMap('input,textarea,option,select,progress');
+var mustUseProp = function (tag, type, attr) {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+var isPreTag = function (tag) { return tag === 'pre'; };
+var isReservedTag = function (tag) {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+makeMap('text,number,password,search,email,tel,url');
+
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            warn$2('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
+}
+
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -8052,11 +8461,20 @@ var style = {
     genData: genData$1,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+var decoder;
+var he = {
+    decode: function (html) {
+        decoder = decoder || document.createElement('div');
+        decoder.innerHTML = html;
+        return decoder.textContent;
+    },
+};
+
+makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -8352,7 +8770,7 @@ function parseHTML(html, options) {
     }
 }
 
-var he = require('he');
+// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8369,7 +8787,7 @@ var invalidAttributeRE = /[\s"'<>\/=]/;
 var decodeHTMLCached = cached(he.decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
-var warn;
+var warn$1;
 var delimiters;
 var transforms;
 var preTransforms;
@@ -8393,7 +8811,7 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn = options.warn || baseWarn;
+    warn$1 = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
@@ -8414,7 +8832,7 @@ function parse(template, options) {
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn(msg, range);
+            warn$1(msg, range);
         }
     }
     function closeElement(element) {
@@ -8495,7 +8913,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn,
+        warn: warn$1,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8527,7 +8945,7 @@ function parse(template, options) {
                 }
                 attrs.forEach(function (attr) {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn("Invalid dynamic argument expression: attribute names cannot contain " +
+                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
                             "spaces, quotes, <, >, / or =.", {
                             start: attr.start + attr.name.indexOf("["),
                             end: attr.start + attr.name.length,
@@ -8537,7 +8955,7 @@ function parse(template, options) {
             }
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
-                warn('Templates should only be responsible for mapping the state to the ' +
+                warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
                         ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
@@ -8728,7 +9146,7 @@ function processKey(el) {
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
@@ -8737,7 +9155,7 @@ function processKey(el) {
                     iterator === exp &&
                     parent_1 &&
                     parent_1.tag === 'transition-group') {
-                    warn("Do not use v-for index as key on <transition-group> children, " +
+                    warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
@@ -8760,7 +9178,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -8812,7 +9230,7 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
             ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
@@ -8824,7 +9242,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -8851,7 +9269,7 @@ function processSlotContent(el) {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn("the \"scope\" attribute for scoped slots have been deprecated and " +
+            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
                 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                 "can also be used on plain elements in addition to <template> to " +
                 "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -8861,7 +9279,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -8886,10 +9304,10 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn("<template v-slot> can only appear at the root level inside " +
+                        warn$1("<template v-slot> can only appear at the root level inside " +
                             "the receiving component", el);
                     }
                 }
@@ -8905,13 +9323,13 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
-                        warn("To avoid scope ambiguity, the default slot should also use " +
+                        warn$1("To avoid scope ambiguity, the default slot should also use " +
                             "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
@@ -8943,7 +9361,7 @@ function getSlotName(binding) {
             name = 'default';
         }
         else {
-            warn("v-slot shorthand syntax requires a slot name.", binding);
+            warn$1("v-slot shorthand syntax requires a slot name.", binding);
         }
     }
     return dynamicArgRE.test(name)
@@ -8957,7 +9375,7 @@ function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn("`key` does not work on <slot> because slots are abstract outlets " +
+            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
                 "and can possibly expand into multiple elements. " +
                 "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
         }
@@ -8996,7 +9414,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9010,14 +9428,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -9037,7 +9455,7 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
             }
             else {
                 // normal directives
@@ -9064,7 +9482,7 @@ function processAttrs(el) {
             {
                 var res = parseText(value, delimiters);
                 if (res) {
-                    warn(name + "=\"" + value + "\": " +
+                    warn$1(name + "=\"" + value + "\": " +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9107,7 +9525,7 @@ function makeAttrsMap(attrs) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9140,7 +9558,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9220,11 +9638,132 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model = {
+var model$1 = {
     preTransformNode: preTransformNode,
 };
 
-var modules = [klass, style, model];
+var modules = [klass, style, model$1];
+
+var warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+var RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        (trueValueBinding === 'true'
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
+    addHandler(el, 'change', "var $$a=" + value + "," +
+        '$$el=$event.target,' +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        'if(Array.isArray($$a)){' +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        '$$i=_i($$a,$$v);' +
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        ("return " + (number ? '_n(val)' : 'val') + "})");
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + genAssignmentCode(value, assignment);
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value_1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', "(" + value + ")");
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
 function text(el, dir) {
     if (dir.value) {
@@ -9239,11 +9778,24 @@ function html(el, dir) {
 }
 
 var directives = {
-    model: model$1,
+    model: model,
     text: text,
     html: html,
 };
 
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
+
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -10170,6 +10722,7 @@ function generateCodeFrame(source, start, end) {
 function repeat(str, n) {
     var result = '';
     if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
index 4f800369322..1c0fab411d7 100644
--- a/dist/vue.esm.browser.min.js
+++ b/dist/vue.esm.browser.min.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(){function e(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=[],r=0;r<arguments.length;r++)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&we(t),o.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function je(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=je(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Ae[r]||Ee;a[r]=i(e[r],t[r],n,r)}return a}function De(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Le(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=_e;be(!0),we(a),be(u)}return a}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),Z&&setTimeout(S)},Ve=!0}else if(J||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=n.fns;if(!Array.isArray(e))return He(e,null,arguments,t,"v-on handler");for(var r=e.slice(),i=0;i<r.length;i++)He(r[i],null,arguments,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=ve(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=ve(f.text+u):""!==u&&s.push(ve(u)):st(u)&&st(f)?s[l]=ve(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return De(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=E,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var o=he(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Le(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=de();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Le(l,u,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return de();n(a)&&n(a.is)&&(i=a.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f=void 0;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=De(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):de()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(U&&!J){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var o=function(o){i.push(o);var a=Le(o,t,n,e);Ce(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=je(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=je(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=je($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;Ce(t,"$attrs",o&&o.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){le();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:je,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=je(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=De(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(J||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(J&&!q&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=J?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=U&&!q,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ni(e){Ti(function(){Ti(e)})}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,N=O&&v?v:l,E=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!q,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,N),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),E&&E(i),F&&(Ei(i,S),Ei(i,T),Ni(function(){ji(i,S),R.cancelled||(Ei(i,N),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ni(function(){ji(i,u),w.cancelled||(Ei(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=he(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,U?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});q&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),q&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t),(J||W)&&setTimeout(function(){Ji(e,t)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(E(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!E(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){(l=i[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(o.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=e(t,null,c),this.removed=u}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!U)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=U?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?Yn(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},go=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),_o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,No=/^<!\[/,Eo=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,function(e){return Do[e]})}function Ro(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,u=function(){if(n=e,r&&Eo(r)){var u=0,p=r.toLowerCase(),d=jo[p]||(jo[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return u=r.length,Eo(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(To.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(No.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(So);if(y)return l(y[0].length),"continue";var g=e.match(Oo);if(g){var _=c;return l(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(ko);if(t){var n={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Ao))&&(i=e.match(wo)||e.match($o));)i.start=c,l(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&f(r),s(n)&&r===n&&f(n));for(var u=a(n)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:Po(h,m)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,u,e.start,e.end)}(b),Fo(b.tagName,e)&&l(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Oo.test(w)||ko.test(w)||To.test(w)||No.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&l($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}f()}var Ho,Bo,Uo,zo,Vo,Ko,Jo,qo,Wo=require("he"),Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/[ \f\t\r\n]+/g,sa=g(Wo.decode),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Ho=t.warn||Sr,Ko=t.isPreTag||T,Jo=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Uo=Tr(t.modules,"transformNode"),zo=Tr(t.modules,"preTransformNode"),Vo=Tr(t.modules,"postTransformNode"),Bo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ko(e.tag)&&(c=!1);for(var f=0;f<Vo.length;f++)Vo[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return Ro(e,{warn:Ho,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<zo.length;h++)v=zo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ko(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):u.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(aa," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Bo))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var r=Pr(e,ia);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=va(r),u=c.name,a=c.dynamic,l=s[u]=ua("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=r.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Uo.length;i++)e=Uo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Jo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):Er(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Er(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Jo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,yo,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=Ir(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+r+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",r),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Nr(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:go,mustUseProp:jn,canBeLeftOpenTag:_o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var o=t.ifConditions[n].block;e(o),o.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Na={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(ja[t])o+=ja[t],Ta[t]&&a.push(t);else if("exact"===t){var n=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Na[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(){return function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g(function(e){var t=Yn(e);return t&&t.innerHTML}),ss=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},wn.compile=ns;export default wn;
\ No newline at end of file
+var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(){function e(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=[],r=0;r<arguments.length;r++)n[r]=arguments[r];var i,a=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&o.observeArray(i),o.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&we(t),a.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in A(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?A({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Ae[r]||Ee;o[r]=i(e[r],t[r],n,r)}return o}function je(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function De(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Pe(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var l=_e;be(!0),we(o),be(l)}return o}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch(function(e){return Re(e,r,i+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,r,i)}return a}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],qe=!1;function Je(){qe=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(Je),Z&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Je)}:function(){setTimeout(Je,0)};else{var Ze=1,Ge=new MutationObserver(Je),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),qe||(qe=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(o)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=n.fns;if(!Array.isArray(e))return He(e,null,arguments,t,"v-on handler");for(var r=e.slice(),i=0;i<r.length;i++)He(r[i],null,arguments,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=tt(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=nt(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=tt(c)).name,n[c],f.capture)}function it(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=nt([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=nt([s,c]),o.merged=!0,e[i]=o}function at(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ot(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(a,o){var s=[];var c,l,u,f;for(c=0;c<a.length;c++)t(l=a[c])||"boolean"==typeof l||(u=s.length-1,f=s[u],Array.isArray(l)?l.length>0&&(st((l=e(l,(o||"")+"_"+c))[0])&&st(f)&&(s[u]=ve(f.text+l[0].text),l.shift()),s.push.apply(s,l)):i(l)?st(f)?s[u]=ve(f.text+l):""!==l&&s.push(ve(l)):st(l)&&st(f)?s[u]=ve(f.text+l.text):(r(a._isVList)&&n(l.tag)&&t(l.key)&&n(o)&&(l.key="__vlist"+o+"_"+c+"__"),s.push(l)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function lt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ut)&&delete n[l];return n}function ut(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=dt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ot(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=A(A({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function mt(e){return je(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):a?yt(a,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(a(n)){Array.isArray(n)&&(n=O(n));var o=void 0,s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?kt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=u,e._l=vt,e._t=ht,e._q=E,e._i=L,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=ct(l.inject,a),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=lt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var a=he(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var Lt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Lt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=De(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Jt(t,r,h),l&&(t.$slots=lt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},jt=Object.keys(Lt);function Dt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Ht;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",function(){return h(s,o)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=j(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout(function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=de();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},$n(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);at(o,c,l,u,!0)||at(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=De(u,l,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ot(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<jt.length;n++){var r=jt[n],i=t[r],a=Lt[r];i===a||i&&i._merged||(t[r]=i?Mt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,o,s,c,l,u){return(Array.isArray(s)||i(s))&&(l=c,c=s,s=void 0),r(u)&&(l=Ft),function(e,i,o,s,c){if(n(o)&&n(o.__ob__))return de();n(o)&&n(o.is)&&(i=o.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=ot(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var l,u;if("string"==typeof i){var f=void 0;u=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),l=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),o,s,void 0,void 0,e):o&&o.pre||!n(f=je(e.$options,"components",i))?new pe(i,o,s,void 0,void 0,e):Dt(f,o,e,s,i)}else l=Dt(i,o,e,s);return Array.isArray(l)?l:n(l)?(n(u)&&function e(i,a,o){i.ns=a;"foreignObject"===i.tag&&(a=void 0,o=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var l=i.children[s];n(l.tag)&&(t(l.ns)||r(o)&&"svg"!==l.tag)&&e(l,a,o)}}(l,u),n(o)&&function(e){a(e.style)&&et(e.style);a(e.class)&&et(e.class)}(o),l):de()}(e,o,s,c,l)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function qt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function Jt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,qt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,an=0;var on=0,sn=Date.now;if(U&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function ln(){var e,t;for(on=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),an=0;an<Qt.length;an++)(e=Qt[an]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();an=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var un=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>an&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(ln))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var a=function(a){i.push(a);var o=De(a,t,n,e);Ce(r,a,o),a in e||dn(e,"_props",a)};for(var o in t)a(o);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||(o=void 0,36!==(o=(a+"").charCodeAt(0))&&95!==o&&dn(e,"_data",a))}var o;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new fn(e,o||S,S,hn)),i in e||mn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Le(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach(function(e){o[e]=n[e]}),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=A({},o.options),i[r]=o,o}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=xn(o.componentOptions);s&&!t(s)&&On(n,a,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Jt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=lt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var a=r&&r.data;Ce(t,"$attrs",a&&a.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){ue();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,a=t.length;i<a;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,a=this.exclude;if(i&&(!r||!kn(i,r))||a&&r&&kn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:A,mergeOptions:Le,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),Ln=p("contenteditable,draggable,spellcheck"),jn=p("events,caret,typing,plaintext-only"),Dn=function(e,t){return Rn(t)||"false"===t?"false":"contenteditable"===e&&jn(t)?t:"true"},Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Fn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Pn=function(e){return Fn(e)?e.slice(6,e.length):""},Rn=function(e){return null==e||!1===e};function Hn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Bn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Bn(t,r.data));return function(e,t){if(n(e)||n(t))return Un(e,zn(t));return""}(t.staticClass,t.class)}function Bn(e,t){return{staticClass:Un(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Un(e,t){return e?t?e+" "+t:e:t||""}function zn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=zn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Jn=function(e){return Kn(e)||qn(e)};var Wn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Vn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Xn={create:function(e,t){Yn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(Yn(e,!0),Yn(t))},destroy:function(e){Yn(e,!0)}};function Yn(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var Qn=new pe("",{},[]),er=["create","activate","update","remove","destroy"];function tr(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Zn(i)&&Zn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function nr(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var rr={create:ir,update:ir,destroy:function(e){ir(e,Qn)}};function ir(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===Qn,o=t===Qn,s=or(e.data.directives,e.context),c=or(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,cr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(cr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)cr(l[n],"inserted",t,e)};a?it(t,"insert",f):f()}u.length&&it(t,"postpatch",function(){for(var n=0;n<u.length;n++)cr(u[n],"componentUpdated",t,e)});if(!a)for(n in s)c[n]||cr(s[n],"unbind",e,e,o)}(e,t)}var ar=Object.create(null);function or(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ar),i[sr(r)]=r,r.def=je(t.$options,"directives",r.name);return i}function sr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function cr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var lr=[Xn,rr];function ur(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=A({},l)),l)o=l[a],c[a]!==o&&fr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&fr(s,"value",l.value),c)t(l[a])&&(Fn(a)?s.removeAttributeNS(In,Pn(a)):Ln(a)||s.removeAttribute(a))}}function fr(e,t,n,r){r||e.tagName.indexOf("-")>-1?pr(e,t,n):Mn(t)?Rn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Ln(t)?e.setAttribute(t,Dn(t,n)):Fn(t)?Rn(n)?e.removeAttributeNS(In,Pn(t)):e.setAttributeNS(In,t,n):pr(e,t,n)}function pr(e,t,n){if(Rn(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var dr={create:ur,update:ur};function vr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Hn(r),c=i._transitionClasses;n(c)&&(s=Un(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var hr,mr,yr,gr,_r,br,$r={create:vr,update:vr},wr=/[\w).+\-_$\]]/;function Cr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&wr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=xr(i,a[r]);return i}function xr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function kr(e,t){console.error("[Vue compiler]: "+e)}function Ar(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Or(e,t,n,r,i){(e.props||(e.props=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Sr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Tr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Ir({name:t,value:n},r))}function Nr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Ir({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Er(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Lr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Er("!",n,c)),i.once&&(delete i.once,n=Er("~",n,c)),i.passive&&(delete i.passive,n=Er("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Ir({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function jr(e,t,n){var r=Dr(e,":"+t)||Dr(e,"v-bind:"+t);if(null!=r)return Cr(r);if(!1!==n){var i=Dr(e,t);if(null!=i)return JSON.stringify(i)}}function Dr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Mr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Ir(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Fr(e,t,n){var r=n||{},i=r.number,a="$$v";r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var o=Pr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+o+"}"}}function Pr(e,t){var n=function(e){if(e=e.trim(),hr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<hr-1)return(gr=e.lastIndexOf("."))>-1?{exp:e.slice(0,gr),key:'"'+e.slice(gr+1)+'"'}:{exp:e,key:null};mr=e,gr=_r=br=0;for(;!Hr();)Br(yr=Rr())?zr(yr):91===yr&&Ur(yr);return{exp:e.slice(0,_r),key:e.slice(_r+1,br)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Rr(){return mr.charCodeAt(++gr)}function Hr(){return gr>=hr}function Br(e){return 34===e||39===e}function Ur(e){var t=1;for(_r=gr;!Hr();)if(Br(e=Rr()))zr(e);else if(91===e&&t++,93===e&&t--,0===t){br=gr;break}}function zr(e){for(var t=e;!Hr()&&(e=Rr())!==t;);}var Vr,Kr="__r",qr="__c";function Jr(e,t,n){var r=Vr;return function i(){null!==t.apply(null,arguments)&&Gr(e,i,n,r)}}var Wr=Ve&&!(X&&Number(X[1])<=53);function Zr(e,t,n,r){if(Wr){var i=on,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Vr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Gr(e,t,n,r){(r||Vr).removeEventListener(e,t._wrapper||t,n)}function Xr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Vr=r.elm,function(e){if(n(e[Kr])){var t=q?"change":"input";e[t]=[].concat(e[Kr],e[t]||[]),delete e[Kr]}n(e[qr])&&(e.change=[].concat(e[qr],e.change||[]),delete e[qr])}(i),rt(i,a,Zr,Gr,Jr,r.context),Vr=void 0}}var Yr,Qr={create:Xr,update:Xr};function ei(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ti(o,l)&&(o.value=l)}else if("innerHTML"===i&&qn(o.tagName)&&t(o.innerHTML)){(Yr=Yr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Yr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ti(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ni={create:ei,update:ei},ri=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function ii(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ri(e):e}var oi,si=/^--/,ci=/\s*!important$/,li=function(e,t,n){if(si.test(t))e.style.setProperty(t,n);else if(ci.test(n))e.style.setProperty(C(t),n.replace(ci,""),"important");else{var r=fi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},ui=["Webkit","Moz","ms"],fi=g(function(e){if(oi=oi||document.createElement("div").style,"filter"!==(e=b(e))&&e in oi)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<ui.length;n++){var r=ui[n]+t;if(r in oi)return r}});function pi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ii(i.data))&&A(r,n);(n=ii(e.data))&&A(r,n);for(var a=e;a=a.parent;)a.data&&(n=ii(a.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(o=d[s])!==f[s]&&li(c,s,null==o?"":o)}}var di={create:pi,update:pi},vi=/\s+/;function hi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,mi(e.name||"v")),A(t,e),t}return"string"==typeof e?mi(e):void 0}}var mi=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),yi="transition",gi="animation",_i="transition",bi="transitionend",$i="animation",wi="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_i="WebkitTransition",bi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($i="WebkitAnimation",wi="webkitAnimationEnd"));var Ci=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function xi(e){Ci(function(){Ci(e)})}function ki(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Oi(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[_i+"Delay"]||"").split(", "),a=(r[_i+"Duration"]||"").split(", "),o=Ti(i,a),s=(r[$i+"Delay"]||"").split(", "),c=(r[$i+"Duration"]||"").split(", "),l=Ti(s,c),u=0,f=0;t===yi?o>0&&(n=yi,u=o,f=a.length):t===gi?l>0&&(n=gi,u=l,f=c.length):(u=Math.max(o,l),f=(n=u>0?o>l?yi:gi:null)?n===yi?a.length:c.length:0);var p=n===yi&&Si.test(r[_i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===yi?bi:wi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var Si=/\b(transform|all)(,|$)/;function Ti(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Ni(t)+Ni(e[n])}))}function Ni(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ei(e){return"number"==typeof e&&!isNaN(e)}function Li(e){if(t(e))return!1;var r=e.fns;return n(r)?Li(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ji(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=hi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Li(L),R=i._enterCb=j(function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ki(i,S),ki(i,T),xi(function(){Ai(i,S),R.cancelled||(ki(i,N),P||(Ei(I)?setTimeout(R,I):Oi(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Di=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<er.length;++a)for(s[er[a]]=[],o=0;o<c.length;++o)n(c[o][er[a]])&&s[er[a]].push(c[o][er[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=he(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){for(var a,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,n(a=o.data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](Qn,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(Yn(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](Qn,e);n(a=e.data.hook)&&(n(a.create)&&a.create(Qn,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&tr(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:tr(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):tr(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):tr(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):tr(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=nr(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):tr(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&tr(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Qn,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else Yn(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Gn,modules:[dr,$r,Qr,ni,di,U?{create:ji,activate:ji,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=hi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Li(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ki(i,l),ki(i,p),xi(function(){Ai(i,l),w.cancelled||(ki(i,u),b||(Ei($)?setTimeout(w,$):Oi(i,c,w)))})),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(lr)});J&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Ui(e,"input")});var Mi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Mi.componentUpdated(e,t,n)}):Ii(e,t,n.context),e._vOptions=[].map.call(e.options,Ri)):("textarea"===n.tag||Zn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Hi),e.addEventListener("compositionend",Bi),e.addEventListener("change",Bi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ii(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ri);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return Pi(e,i)}):t.value!==t.oldValue&&Pi(t.value,i))&&Ui(e,"change")}}};function Ii(e,t,n){Fi(e,t),(q||W)&&setTimeout(function(){Fi(e,t)},0)}function Fi(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Ri(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Ri(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Pi(e,t){return t.every(function(t){return!E(t,e)})}function Ri(e){return"_value"in e?e._value:e.value}function Hi(e){e.target.composing=!0}function Bi(e){e.target.composing&&(e.target.composing=!1,Ui(e.target,"input"))}function Ui(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var zi=/\s+/;function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ki(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function qi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,Ji(e.name||"v")),A(t,e),t}return"string"==typeof e?Ji(e):void 0}}var Ji=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Wi=U&&!J,Zi="transition",Gi="animation",Xi="transition",Yi="transitionend",Qi="animation",ea="animationend";Wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xi="WebkitTransition",Yi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Qi="WebkitAnimation",ea="webkitAnimationEnd"));var ta=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function na(e){ta(function(){ta(e)})}function ra(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),Vi(e,t))}function ia(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ki(e,t)}function aa(e,t,n){var r=sa(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Zi?Yi:ea,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var oa=/\b(transform|all)(,|$)/;function sa(e,t){var n,r=window.getComputedStyle(e),i=(r[Xi+"Delay"]||"").split(", "),a=(r[Xi+"Duration"]||"").split(", "),o=ca(i,a),s=(r[Qi+"Delay"]||"").split(", "),c=(r[Qi+"Duration"]||"").split(", "),l=ca(s,c),u=0,f=0;return t===Zi?o>0&&(n=Zi,u=o,f=a.length):t===Gi?l>0&&(n=Gi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Zi:Gi:null)?n===Zi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Zi&&oa.test(r[Xi+"Property"])}}function ca(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return la(t)+la(e[n])}))}function la(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ua(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=qi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=pa(L),R=i._enterCb=j(function(){F&&(ia(i,N),ia(i,T)),R.cancelled?(F&&ia(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ra(i,S),ra(i,T),na(function(){ia(i,S),R.cancelled||(ra(i,N),P||(fa(I)?setTimeout(R,I):aa(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function fa(e){return"number"==typeof e&&!isNaN(e)}function pa(e){if(t(e))return!1;var r=e.fns;return n(r)?pa(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}var va={model:Mi,show:{bind:function(e,t,n){var r=t.value,i=(n=da(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,ua(n,function(){e.style.display=a})):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=da(i)).data&&i.data.transition?(i.data.show=!0,o?ua(i,function(){e.style.display=e.__vOriginalDisplay}):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=qi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=pa(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ia(i,u),ia(i,p)),w.cancelled?(_&&ia(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ra(i,l),ra(i,p),na(function(){ia(i,l),w.cancelled||(ra(i,u),b||(fa($)?setTimeout(w,$):aa(i,c,w)))})),v&&v(i,w),_||b||w())}}(i,function(){e.style.display="none"})):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ha={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ma(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ma(zt(t.children)):e}function ya(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ga(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var _a=function(e){return e.tag||Ut(e)},ba=function(e){return"show"===e.name},$a={name:"transition",props:ha,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(_a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ma(a);if(!o)return a;if(this._leaving)return ga(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=ya(this),l=this._vnode,u=ma(l);if(o.data.directives&&o.data.directives.some(ba)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Ut(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ga(e,a);if("in-out"===r){if(Ut(o))return l;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return a}}},wa=A({tag:String,moveClass:String},ha);function Ca(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function xa(e){e.data.newPos=e.elm.getBoundingClientRect()}function ka(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete wa.mode;var Aa={Transition:$a,TransitionGroup:{props:wa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=ya(this),s=0;s<i.length;s++){(u=i[s]).tag&&null!=u.key&&0!==String(u.key).indexOf("__vlist")&&(a.push(u),n[u.key]=u,(u.data||(u.data={})).transition=o)}if(r){var c=[],l=[];for(s=0;s<r.length;s++){var u;(u=r[s]).data.transition=o,u.data.pos=u.elm.getBoundingClientRect(),n[u.key]?c.push(u):l.push(u)}this.kept=e(t,null,c),this.removed=l}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Ca),e.forEach(xa),e.forEach(ka),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;ra(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Yi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Yi,e),n._moveCb=null,ia(n,t))})}}))},methods:{hasMove:function(e,t){if(!Wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Ki(n,e)}),Vi(n,t),n.style.display="none",this.$el.appendChild(n);var r=sa(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},wn.config.isReservedTag=Jn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=function(e){return qn(e)?"svg":"math"===e?"math":void 0},wn.config.isUnknownElement=function(e){if(!U)return!0;if(Jn(e))return!1;if(e=e.toLowerCase(),null!=Wn[e])return Wn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Wn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Wn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,va),A(wn.options.components,Aa),wn.prototype.__patch__=U?Di:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var Oa=p("input,textarea,option,select,progress"),Sa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ta=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Na(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Ea=/\{\{((?:.|\r?\n)+?)\}\}/g,La=/[-.*+?^${}()|[\]\/\\]/g,ja=g(function(e){var t=e[0].replace(La,"\\$&"),n=e[1].replace(La,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var Da={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Dr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=jr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Ma,Ia={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Dr(e,"style");n&&(e.staticStyle=JSON.stringify(ri(n)));var r=jr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Fa=function(e){return(Ma=Ma||document.createElement("div")).innerHTML=e,Ma.textContent},Pa=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ra=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ha=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ba="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ua="((?:"+Ba+"\\:)?"+Ba+")",za=new RegExp("^<"+Ua),Va=/^\s*(\/?)>/,Ka=new RegExp("^<\\/"+Ua+"[^>]*>"),qa=/^<!DOCTYPE [^>]+>/i,Ja=/^<!\--/,Wa=/^<!\[/,Za=p("script,style,textarea",!0),Ga={},Xa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ya=/&(?:lt|gt|quot|amp|#39);/g,Qa=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,eo=p("pre,textarea",!0),to=function(e,t){return e&&eo(e)&&"\n"===t[0]};function no(e,t){var n=t?Qa:Ya;return e.replace(n,function(e){return Xa[e]})}function ro(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,l=function(){if(n=e,r&&Za(r)){var l=0,p=r.toLowerCase(),d=Ga[p]||(Ga[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return l=r.length,Za(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),to(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-l,c)}else{var v=e.indexOf("<");if(0===v){if(Ja.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),u(h+3),"continue"}if(Wa.test(e)){var m=e.indexOf("]>");if(m>=0)return u(m+2),"continue"}var y=e.match(qa);if(y)return u(y[0].length),"continue";var g=e.match(Ka);if(g){var _=c;return u(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(za);if(t){var n={tagName:t[1],attrs:[],start:c};u(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Va))&&(i=e.match(Ha)||e.match(Ra));)i.start=c,u(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],u(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Pa(n)&&f(r),s(n)&&r===n&&f(n));for(var l=o(n)||!!c,u=e.attrs.length,p=new Array(u),d=0;d<u;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:no(h,m)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,l,e.start,e.end)}(b),to(b.tagName,e)&&u(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Ka.test(w)||za.test(w)||Ja.test(w)||Wa.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&u($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===l())break}function u(t){c+=t,e=e.substring(t)}function f(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}f()}var io,ao,oo,so,co,lo,uo,fo,po=/^@|^v-on:/,vo=/^v-|^@|^:|^#/,ho=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,mo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,yo=/^\(|\)$/g,go=/^\[.*\]$/,_o=/:(.*)$/,bo=/^:|^\.|^v-bind:/,$o=/\.[^.\]]+(?=[^\]]*$)/g,wo=/^v-slot(:|$)|^#/,Co=/[\r\n]/,xo=/[ \f\t\r\n]+/g,ko=g(Fa),Ao="_empty_";function Oo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Do(t),rawAttrsMap:{},parent:n,children:[]}}function So(e,t){io=t.warn||kr,lo=t.isPreTag||T,uo=t.mustUseProp||T,fo=t.getTagNamespace||T,t.isReservedTag,oo=Ar(t.modules,"transformNode"),so=Ar(t.modules,"preTransformNode"),co=Ar(t.modules,"postTransformNode"),ao=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=To(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Eo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Eo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter(function(e){return!e.slotScope}),u(e),e.pre&&(s=!1),lo(e.tag)&&(c=!1);for(var f=0;f<co.length;f++)co[f](e,t)}function u(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return ro(e,{warn:io,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||fo(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Mo.test(r.name)||(r.name=r.name.replace(Io,""),t.push(r))}return t}(a));var d,v=Oo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<so.length;h++)v=so[h](v,t)||v;s||(!function(e){null!=Dr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),lo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(No(v),function(e){var t=Dr(e,"v-if");if(t)e.if=t,Eo(e,{exp:t,block:e});else{null!=Dr(e,"v-else")&&(e.else=!0);var n=Dr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Dr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):l.length?o?"condense"===o&&Co.test(e)?"":" ":a?" ":"":""){c||"condense"!==o||(e=e.replace(xo," "));var u=void 0,f=void 0;!s&&" "!==e&&(u=function(e,t){var n=t?ja(t):Ea;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Cr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,ao))?f={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&l.length&&" "===l[l.length-1].text||(f={type:3,text:e}),f&&l.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function To(e,t){var n,r;(r=jr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dr(e,"scope"),e.slotScope=t||Dr(e,"slot-scope")):(t=Dr(e,"slot-scope"))&&(e.slotScope=t);var n=jr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Sr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Mr(e,wo);if(r){var i=Lo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Ao}}else{var r=Mr(e,wo);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=Lo(r),l=c.name,o=c.dynamic,u=s[l]=Oo("template",[],e);u.slotTarget=l,u.slotTargetDynamic=o,u.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=u,!0}),u.slotScope=r.value||Ao,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jr(e,"name"))}(e),function(e){var t;(t=jr(e,"is"))&&(e.component=t);null!=Dr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<oo.length;i++)e=oo[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,vo.test(r))if(e.hasBindings=!0,(o=jo(r.replace(vo,"")))&&(r=r.replace($o,"")),bo.test(r))r=r.replace(bo,""),a=Cr(a),(c=go.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Pr(a,"$event"),c?Lr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Lr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Lr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&uo(e.tag,e.attrsMap.type,r)?Or(e,r,a,l[t],c):Sr(e,r,a,l[t],c);else if(po.test(r))r=r.replace(po,""),(c=go.test(r))&&(r=r.slice(1,-1)),Lr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(vo,"")).match(_o),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),go.test(f)&&(f=f.slice(1,-1),c=!0)),Nr(e,r,i,a,f,c,o,l[t])}else Sr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&uo(e.tag,e.attrsMap.type,r)&&Or(e,r,"true",l[t])}(e),e}function No(e){var t;if(t=Dr(e,"v-for")){var n=function(e){var t=e.match(ho);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(yo,""),i=r.match(mo);i?(n.alias=r.replace(mo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function Eo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Lo(e){var t=e.name.replace(wo,"");return t||"#"!==e.name[0]&&(t="default"),go.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function jo(e){var t=e.match($o);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function Do(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Mo=/^xmlns:NS\d+/,Io=/^NS\d+:/;function Fo(e){return Oo(e.tag,e.attrsList.slice(),e.parent)}var Po=[Da,Ia,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=jr(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Dr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Dr(e,"v-else",!0),s=Dr(e,"v-else-if",!0),c=Fo(e);No(c),Tr(c,"type","checkbox"),To(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+a,Eo(c,{exp:c.if,block:c});var l=Fo(e);Dr(l,"v-for",!0),Tr(l,"type","radio"),To(l,t),Eo(c,{exp:"("+r+")==='radio'"+a,block:l});var u=Fo(e);return Dr(u,"v-for",!0),Tr(u,":type",r),To(u,t),Eo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}],Ro="__r";var Ho,Bo,Uo={expectHTML:!0,modules:Po,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Fr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Pr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null",a=jr(e,"true-value")||"true",o=jr(e,"false-value")||"false";Or(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Lr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pr(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null";Or(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Lr(e,"change",Pr(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?Ro:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),o&&(u="_n("+u+")");var f=Pr(t,u);c&&(f="if($event.target.composing)return;"+f),Or(e,"value","("+t+")"),Lr(e,l,f,null,!0),(s||o)&&Lr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Fr(e,r,i),!1;return!0},text:function(e,t){t.value&&Or(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Or(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Oa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Sa(e)||Ta(e)},getTagNamespace:function(e){return Ta(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Po)},zo=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(t);if(1===t.type){if(!Bo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var a=t.ifConditions[n].block;e(a),a.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Ko=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,qo=/\([^)]*?\);*$/,Jo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Go=function(e){return"if("+e+")return null;"},Xo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Go("$event.target !== $event.currentTarget"),ctrl:Go("!$event.ctrlKey"),shift:Go("!$event.shiftKey"),alt:Go("!$event.altKey"),meta:Go("!$event.metaKey"),left:Go("'button' in $event && $event.button !== 0"),middle:Go("'button' in $event && $event.button !== 1"),right:Go("'button' in $event && $event.button !== 2")};function Yo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Qo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Qo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Qo(e)}).join(",")+"]";var t=Jo.test(e.value),n=Ko.test(e.value),r=Jo.test(e.value.replace(qo,""));if(e.modifiers){var i="",a="",o=[],s=function(t){if(Xo[t])a+=Xo[t],Wo[t]&&o.push(t);else if("exact"===t){var n=e.modifiers;a+=Go(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else o.push(t)};for(var c in e.modifiers)s(c);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(es).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function es(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Wo[e],r=Zo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ts={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},ns=function(){return function(e){this.options=e,this.warn=e.warn||kr,this.transforms=Ar(e.modules,"transformCode"),this.dataGenFns=Ar(e.modules,"genData"),this.directives=A(A({},ts),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function rs(e,t){var n=new ns(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":is(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function is(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return as(e,t);if(e.once&&!e.onceProcessed)return os(e,t);if(e.for&&!e.forProcessed)return cs(e,t);if(e.if&&!e.ifProcessed)return ss(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ps(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?hs((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ps(t,n,!0);return"_c("+e+","+ls(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ls(e,t));var i=e.inlineTemplate?null:ps(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ps(e,t)||"void 0"}function as(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+is(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function os(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ss(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+is(e,t)+","+t.onceId+++","+n+")":is(e,t)}return as(e,t)}function ss(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var a=t.shift();return a.exp?"("+a.exp+")?"+o(a.block)+":"+e(t,n,r,i):""+o(a.block);function o(e){return r?r(e,n):e.once?os(e,n):is(e,n)}}(e.ifConditions.slice(),t,n,r)}function cs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||is)(e,t)+"})"}function ls(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+hs(e.attrs)+","),e.props&&(n+="domProps:"+hs(e.props)+","),e.events&&(n+=Yo(e.events,!1)+","),e.nativeEvents&&(n+=Yo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||us(n)}),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Ao||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map(function(e){return fs(t[e],n)}).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=rs(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+hs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function us(e){return 1===e.type&&("slot"===e.tag||e.children.some(us))}function fs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ss(e,t,fs,"null");if(e.for&&!e.forProcessed)return cs(e,t,fs);var r=e.slotScope===Ao?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ps(e,t)||"undefined")+":undefined":ps(e,t)||"undefined":is(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ps(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||is)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ds(i)||i.ifConditions&&i.ifConditions.some(function(e){return ds(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||vs;return"["+a.map(function(e){return l(e,t)}).join(",")+"]"+(c?","+c:"")}}function ds(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function vs(e,t){return 1===e.type?is(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:ms(JSON.stringify(n.text)))+")";var n,r}function hs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ms(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ms(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ys(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function gs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=ys(o.render,c),s.staticRenderFns=o.staticRenderFns.map(function(e){return ys(e,c)}),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var _s,bs,$s=(_s=function(e,t){var n=So(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=rs(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=_s(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:gs(t)}})(Uo).compileToFunctions;function ws(e){return(bs=bs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',bs.innerHTML.indexOf("&#10;")>0}var Cs=!!U&&ws(!1),xs=!!U&&ws(!0),ks=g(function(e){var t=Na(e);return t&&t.innerHTML}),As=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Na(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ks(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=$s(r,{outputSourceRange:!1,shouldDecodeNewlines:Cs,shouldDecodeNewlinesForHref:xs,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return As.call(this,e,t)},wn.compile=$s;export default wn;
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index 1286a8d4272..d6fc96be8d2 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -4780,9 +4780,9 @@ Vue.version = '2.6.12';
 // during template compilation
 var isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+var acceptValue$1 = makeMap('input,textarea,option,select,progress');
+var mustUseProp$1 = function (tag, type, attr) {
+    return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
@@ -4888,7 +4888,7 @@ var namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4901,15 +4901,14 @@ var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isPreTag = function (tag) { return tag === 'pre'; };
-var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag);
+var isReservedTag$1 = function (tag) {
+    return isHTMLTag$1(tag) || isSVG$1(tag);
 };
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
+function getTagNamespace$1(tag) {
+    if (isSVG$1(tag)) {
         return 'svg';
     }
     // basic support for MathML
@@ -4924,7 +4923,7 @@ function isUnknownElement(tag) {
     if (!inBrowser) {
         return true;
     }
-    if (isReservedTag(tag)) {
+    if (isReservedTag$1(tag)) {
         return false;
     }
     tag = tag.toLowerCase();
@@ -4948,7 +4947,7 @@ var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 /**
  * Query an element selector if it's not an element already.
  */
-function query(el) {
+function query$1(el) {
     if (typeof el === 'string') {
         var selected = document.querySelector(el);
         if (!selected) {
@@ -6460,127 +6459,10 @@ function parseString(chr) {
     }
 }
 
-var warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
+var RANGE_TOKEN$1 = '__r';
 var CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
-        (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
-    addHandler(el, 'change', "var $$a=" + value + "," +
-        '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
-        'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
-        '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-        ".call($event.target.options,function(o){return o.selected})" +
-        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
-            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    var valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
-    }
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = "if($event.target.composing)return;" + code;
-    }
-    addProp(el, 'value', "(" + value + ")");
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6588,11 +6470,11 @@ function genDefaultModel(el, value, modifiers) {
 // user-attached handlers.
 function normalizeEvents(on) {
     /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
+    if (isDef(on[RANGE_TOKEN$1])) {
         // IE input[type=range] only supports `change` event
         var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
-        delete on[RANGE_TOKEN];
+        on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+        delete on[RANGE_TOKEN$1];
     }
     // This was originally intended to fix #4521 but no longer necessary
     // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6715,7 +6597,7 @@ function updateDOMProps(oldVnode, vnode) {
             }
         }
         else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
+            isSVG$1(elm.tagName) &&
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
@@ -6920,12 +6802,12 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+var whitespaceRE$2 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass(el, cls) {
+function addClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6933,7 +6815,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6950,7 +6832,7 @@ function addClass(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass(el, cls) {
+function removeClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6958,7 +6840,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6983,7 +6865,7 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def) {
+function resolveTransition$1(def) {
     if (!def) {
         return;
     }
@@ -6991,16 +6873,16 @@ function resolveTransition(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
+            extend(res, autoCssTransition$1(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition(def);
+        return autoCssTransition$1(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+var autoCssTransition$1 = cached(function (name) {
     return {
         enterClass: name + "-enter",
         enterToClass: name + "-enter-to",
@@ -7010,59 +6892,59 @@ var autoCssTransition = cached(function (name) {
         leaveActiveClass: name + "-leave-active",
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+var hasTransition$1 = inBrowser && !isIE9;
+var TRANSITION$1 = 'transition';
+var ANIMATION$1 = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
+var transitionProp$1 = 'transition';
+var transitionEndEvent$1 = 'transitionend';
+var animationProp$1 = 'animation';
+var animationEndEvent$1 = 'animationend';
+if (hasTransition$1) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
+        transitionProp$1 = 'WebkitTransition';
+        transitionEndEvent$1 = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
+        animationProp$1 = 'WebkitAnimation';
+        animationEndEvent$1 = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+var raf$1 = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
+function nextFrame$1(fn) {
+    raf$1(function () {
         // @ts-expect-error
-        raf(fn);
+        raf$1(fn);
     });
 }
-function addTransitionClass(el, cls) {
+function addTransitionClass$1(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass(el, cls);
+        addClass$1(el, cls);
     }
 }
-function removeTransitionClass(el, cls) {
+function removeTransitionClass$1(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass(el, cls);
+    removeClass$1(el, cls);
 }
-function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+function whenTransitionEnds$1(el, expectedType, cb) {
+    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -7082,30 +6964,30 @@ function whenTransitionEnds(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
+var transformRE$1 = /\b(transform|all)(,|$)/;
+function getTransitionInfo$1(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
+    if (expectedType === TRANSITION$1) {
         if (transitionTimeout > 0) {
-            type = TRANSITION;
+            type = TRANSITION$1;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION) {
+    else if (expectedType === ANIMATION$1) {
         if (animationTimeout > 0) {
-            type = ANIMATION;
+            type = ANIMATION$1;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -7115,16 +6997,16 @@ function getTransitionInfo(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
+                    ? TRANSITION$1
+                    : ANIMATION$1
                 : null;
         propCount = type
-            ? type === TRANSITION
+            ? type === TRANSITION$1
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -7132,31 +7014,31 @@ function getTransitionInfo(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout(delays, durations) {
+function getTimeout$1(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
+        return toMs$1(d) + toMs$1(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs(s) {
+function toMs$1(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
+function enter$1(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7194,19 +7076,19 @@ function enter(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
+        checkDuration$1(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
+    var userWantsControl = getHookArgumentsLength$1(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
+            removeTransitionClass$1(el, toClass);
+            removeTransitionClass$1(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, startClass);
+                removeTransitionClass$1(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -7231,19 +7113,19 @@ function enter(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
+        addTransitionClass$1(el, startClass);
+        addTransitionClass$1(el, activeClass);
+        nextFrame$1(function () {
+            removeTransitionClass$1(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
+                addTransitionClass$1(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
+                    if (isValidDuration$1(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds(el, type, cb);
+                        whenTransitionEnds$1(el, type, cb);
                     }
                 }
             }
@@ -7257,14 +7139,14 @@ function enter(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave(vnode, rm) {
+function leave$1(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7274,23 +7156,23 @@ function leave(vnode, rm) {
     }
     var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
+    var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
+        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
+            removeTransitionClass$1(el, leaveToClass);
+            removeTransitionClass$1(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
+                removeTransitionClass$1(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -7318,19 +7200,19 @@ function leave(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
+            addTransitionClass$1(el, leaveClass);
+            addTransitionClass$1(el, leaveActiveClass);
+            nextFrame$1(function () {
+                removeTransitionClass$1(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
+                    addTransitionClass$1(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
+                        if (isValidDuration$1(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds(el, type, cb);
+                            whenTransitionEnds$1(el, type, cb);
                         }
                     }
                 }
@@ -7343,7 +7225,7 @@ function leave(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration(val, name, vnode) {
+function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
             ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -7353,7 +7235,7 @@ function checkDuration(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration(val) {
+function isValidDuration$1(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -7362,7 +7244,7 @@ function isValidDuration(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength(fn) {
+function getHookArgumentsLength$1(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -7370,7 +7252,7 @@ function getHookArgumentsLength(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -7379,7 +7261,7 @@ function getHookArgumentsLength(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter(vnode);
+        enter$1(vnode);
     }
 }
 var transition = inBrowser
@@ -7390,7 +7272,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave(vnode, rm);
+                leave$1(vnode, rm);
             }
             else {
                 rm();
@@ -7539,43 +7421,501 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
-        vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, function () {
-                el.style.display = originalDisplay;
-            });
+var whitespaceRE$1 = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
-            el.style.display = value ? originalDisplay : 'none';
+            el.classList.add(cls);
         }
-    },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            { return; }
-        vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, function () {
-                    el.style.display = el.__vOriginalDisplay;
-                });
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
+}
+
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+var autoCssTransition = cached(function (name) {
+    return {
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
+    };
+});
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
+// Transition property/event sniffing
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+var raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn$2("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind: function (el, _a, vnode) {
+        var value = _a.value;
+        vnode = locateNode(vnode);
+        var transition = vnode.data && vnode.data.transition;
+        var originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, function () {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update: function (el, _a, vnode) {
+        var value = _a.value, oldValue = _a.oldValue;
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            { return; }
+        vnode = locateNode(vnode);
+        var transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, function () {
+                    el.style.display = el.__vOriginalDisplay;
+                });
             }
             else {
                 leave(vnode, function () {
@@ -7943,10 +8283,10 @@ var platformComponents = {
 };
 
 // install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
+Vue.config.mustUseProp = mustUseProp$1;
+Vue.config.isReservedTag = isReservedTag$1;
 Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.getTagNamespace = getTagNamespace$1;
 Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
@@ -7955,7 +8295,7 @@ extend(Vue.options.components, platformComponents);
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
 // public mount method
 Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
+    el = el && inBrowser ? query$1(el) : undefined;
     return mountComponent(this, el, hydrating);
 };
 // devtools global hook
@@ -7985,6 +8325,76 @@ if (inBrowser) {
     }, 0);
 }
 
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+var acceptValue = makeMap('input,textarea,option,select,progress');
+var mustUseProp = function (tag, type, attr) {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+
+var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+var isPreTag = function (tag) { return tag === 'pre'; };
+var isReservedTag = function (tag) {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+makeMap('text,number,password,search,email,tel,url');
+
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        var selected = document.querySelector(el);
+        if (!selected) {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
+}
+
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 var buildRegex = cached(function (delimiters) {
@@ -8098,11 +8508,20 @@ var style = {
     genData: genData$1,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+var decoder;
+var he = {
+    decode: function (html) {
+        decoder = decoder || document.createElement('div');
+        decoder.innerHTML = html;
+        return decoder.textContent;
+    },
+};
+
+makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -8400,7 +8819,7 @@ function parseHTML(html, options) {
     }
 }
 
-var he = require('he');
+// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8417,7 +8836,7 @@ var invalidAttributeRE = /[\s"'<>\/=]/;
 var decodeHTMLCached = cached(he.decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
-var warn;
+var warn$1;
 var delimiters;
 var transforms;
 var preTransforms;
@@ -8441,7 +8860,7 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn = options.warn || baseWarn;
+    warn$1 = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
@@ -8462,7 +8881,7 @@ function parse(template, options) {
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn(msg, range);
+            warn$1(msg, range);
         }
     }
     function closeElement(element) {
@@ -8543,7 +8962,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn,
+        warn: warn$1,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8575,7 +8994,7 @@ function parse(template, options) {
                 }
                 attrs.forEach(function (attr) {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn("Invalid dynamic argument expression: attribute names cannot contain " +
+                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
                             "spaces, quotes, <, >, / or =.", {
                             start: attr.start + attr.name.indexOf("["),
                             end: attr.start + attr.name.length,
@@ -8586,7 +9005,7 @@ function parse(template, options) {
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
                 process.env.NODE_ENV !== 'production' &&
-                    warn('Templates should only be responsible for mapping the state to the ' +
+                    warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
                         ("<" + tag + ">") +
                         ', as they will not be parsed.', { start: element.start });
@@ -8779,7 +9198,7 @@ function processKey(el) {
     if (exp) {
         if (process.env.NODE_ENV !== 'production') {
             if (el.tag === 'template') {
-                warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
@@ -8788,7 +9207,7 @@ function processKey(el) {
                     iterator === exp &&
                     parent_1 &&
                     parent_1.tag === 'transition-group') {
-                    warn("Do not use v-for index as key on <transition-group> children, " +
+                    warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
@@ -8811,7 +9230,7 @@ function processFor(el) {
             extend(el, res);
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -8863,7 +9282,7 @@ function processIfConditions(el, parent) {
         });
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
             ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
@@ -8875,7 +9294,7 @@ function findPrevElement(children) {
         }
         else {
             if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -8902,7 +9321,7 @@ function processSlotContent(el) {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn("the \"scope\" attribute for scoped slots have been deprecated and " +
+            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
                 "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                 "can also be used on plain elements in addition to <template> to " +
                 "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -8912,7 +9331,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -8937,10 +9356,10 @@ function processSlotContent(el) {
             if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (el.slotTarget || el.slotScope) {
-                        warn("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn("<template v-slot> can only appear at the root level inside " +
+                        warn$1("<template v-slot> can only appear at the root level inside " +
                             "the receiving component", el);
                     }
                 }
@@ -8956,13 +9375,13 @@ function processSlotContent(el) {
             if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (!maybeComponent(el)) {
-                        warn("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
-                        warn("To avoid scope ambiguity, the default slot should also use " +
+                        warn$1("To avoid scope ambiguity, the default slot should also use " +
                             "<template> syntax when there are other named slots.", slotBinding);
                     }
                 }
@@ -8994,7 +9413,7 @@ function getSlotName(binding) {
             name = 'default';
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn("v-slot shorthand syntax requires a slot name.", binding);
+            warn$1("v-slot shorthand syntax requires a slot name.", binding);
         }
     }
     return dynamicArgRE.test(name)
@@ -9008,7 +9427,7 @@ function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn("`key` does not work on <slot> because slots are abstract outlets " +
+            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
                 "and can possibly expand into multiple elements. " +
                 "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
         }
@@ -9048,7 +9467,7 @@ function processAttrs(el) {
                 }
                 if (process.env.NODE_ENV !== 'production' &&
                     value.trim().length === 0) {
-                    warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9062,14 +9481,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -9089,7 +9508,7 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
             }
             else {
                 // normal directives
@@ -9116,7 +9535,7 @@ function processAttrs(el) {
             if (process.env.NODE_ENV !== 'production') {
                 var res = parseText(value, delimiters);
                 if (res) {
-                    warn(name + "=\"" + value + "\": " +
+                    warn$1(name + "=\"" + value + "\": " +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9160,7 +9579,7 @@ function makeAttrsMap(attrs) {
             map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9193,7 +9612,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9273,11 +9692,132 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model = {
+var model$1 = {
     preTransformNode: preTransformNode,
 };
 
-var modules = [klass, style, model];
+var modules = [klass, style, model$1];
+
+var warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+var RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    var value = dir.value;
+    var modifiers = dir.modifiers;
+    var tag = el.tag;
+    var type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+            "v-model is not supported on this element type. " +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', "Array.isArray(" + value + ")" +
+        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        (trueValueBinding === 'true'
+            ? ":(" + value + ")"
+            : ":_q(" + value + "," + trueValueBinding + ")"));
+    addHandler(el, 'change', "var $$a=" + value + "," +
+        '$$el=$event.target,' +
+        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        'if(Array.isArray($$a)){' +
+        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        '$$i=_i($$a,$$v);' +
+        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number;
+    var selectedVal = "Array.prototype.filter" +
+        ".call($event.target.options,function(o){return o.selected})" +
+        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+        ("return " + (number ? '_n(val)' : 'val') + "})");
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    var code = "var $$selectedVal = " + selectedVal + ";";
+    code = code + " " + genAssignmentCode(value, assignment);
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value_1 && !typeBinding) {
+            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var needCompositionGuard = !lazy && type !== 'range';
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    var valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = "$event.target.value.trim()";
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = "if($event.target.composing)return;" + code;
+    }
+    addProp(el, 'value', "(" + value + ")");
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
 function text(el, dir) {
     if (dir.value) {
@@ -9292,11 +9832,24 @@ function html(el, dir) {
 }
 
 var directives = {
-    model: model$1,
+    model: model,
     text: text,
     html: html,
 };
 
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
+
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -10226,6 +10779,7 @@ function generateCodeFrame(source, start, end) {
 function repeat(str, n) {
     var result = '';
     if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
diff --git a/dist/vue.js b/dist/vue.js
index 5f87cb32293..801e2938962 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -4753,9 +4753,9 @@
   // during template compilation
   var isReservedAttr = makeMap('style,class');
   // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress');
-  var mustUseProp = function (tag, type, attr) {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+  var acceptValue$1 = makeMap('input,textarea,option,select,progress');
+  var mustUseProp$1 = function (tag, type, attr) {
+      return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
           (attr === 'selected' && tag === 'option') ||
           (attr === 'checked' && tag === 'input') ||
           (attr === 'muted' && tag === 'video'));
@@ -4861,7 +4861,7 @@
       svg: 'http://www.w3.org/2000/svg',
       math: 'http://www.w3.org/1998/Math/MathML',
   };
-  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+  var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
       'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
       'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4874,15 +4874,14 @@
       'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+  var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
       'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
       'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  var isPreTag = function (tag) { return tag === 'pre'; };
-  var isReservedTag = function (tag) {
-      return isHTMLTag(tag) || isSVG(tag);
+  var isReservedTag$1 = function (tag) {
+      return isHTMLTag$1(tag) || isSVG$1(tag);
   };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
+  function getTagNamespace$1(tag) {
+      if (isSVG$1(tag)) {
           return 'svg';
       }
       // basic support for MathML
@@ -4897,7 +4896,7 @@
       if (!inBrowser) {
           return true;
       }
-      if (isReservedTag(tag)) {
+      if (isReservedTag$1(tag)) {
           return false;
       }
       tag = tag.toLowerCase();
@@ -4921,7 +4920,7 @@
   /**
    * Query an element selector if it's not an element already.
    */
-  function query(el) {
+  function query$1(el) {
       if (typeof el === 'string') {
           var selected = document.querySelector(el);
           if (!selected) {
@@ -6429,127 +6428,10 @@
       }
   }
 
-  var warn$1;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r';
+  var RANGE_TOKEN$1 = '__r';
   var CHECKBOX_RADIO_TOKEN = '__c';
-  function model$1(el, dir, _warn) {
-      warn$1 = _warn;
-      var value = dir.value;
-      var modifiers = dir.modifiers;
-      var tag = el.tag;
-      var type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn$1("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                  "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else if (!config.isReservedTag(tag)) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else {
-          warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
-              "v-model is not supported on this element type. " +
-              "If you are working with contenteditable, it's recommended to " +
-              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      var number = modifiers && modifiers.number;
-      var valueBinding = getBindingAttr(el, 'value') || 'null';
-      var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          ("?_i(" + value + "," + valueBinding + ")>-1") +
-          (trueValueBinding === 'true'
-              ? ":(" + value + ")"
-              : ":_q(" + value + "," + trueValueBinding + ")"));
-      addHandler(el, 'change', "var $$a=" + value + "," +
-          '$$el=$event.target,' +
-          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
-          'if(Array.isArray($$a)){' +
-          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
-          '$$i=_i($$a,$$v);' +
-          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      var number = modifiers && modifiers.number;
-      var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      var number = modifiers && modifiers.number;
-      var selectedVal = "Array.prototype.filter" +
-          ".call($event.target.options,function(o){return o.selected})" +
-          ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          ("return " + (number ? '_n(val)' : 'val') + "})");
-      var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + genAssignmentCode(value, assignment);
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      var type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value_1 && !typeBinding) {
-              var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn$1(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
-      var needCompositionGuard = !lazy && type !== 'range';
-      var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      var valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = "$event.target.value.trim()";
-      }
-      if (number) {
-          valueExpression = "_n(" + valueExpression + ")";
-      }
-      var code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = "if($event.target.composing)return;" + code;
-      }
-      addProp(el, 'value', "(" + value + ")");
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
-  }
 
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
@@ -6557,11 +6439,11 @@
   // user-attached handlers.
   function normalizeEvents(on) {
       /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN])) {
+      if (isDef(on[RANGE_TOKEN$1])) {
           // IE input[type=range] only supports `change` event
           var event_1 = isIE ? 'change' : 'input';
-          on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
-          delete on[RANGE_TOKEN];
+          on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+          delete on[RANGE_TOKEN$1];
       }
       // This was originally intended to fix #4521 but no longer necessary
       // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6684,7 +6566,7 @@
               }
           }
           else if (key === 'innerHTML' &&
-              isSVG(elm.tagName) &&
+              isSVG$1(elm.tagName) &&
               isUndef(elm.innerHTML)) {
               // IE doesn't support innerHTML for SVG elements
               svgContainer = svgContainer || document.createElement('div');
@@ -6889,12 +6771,12 @@
       update: updateStyle,
   };
 
-  var whitespaceRE$1 = /\s+/;
+  var whitespaceRE$2 = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function addClass(el, cls) {
+  function addClass$1(el, cls) {
       /* istanbul ignore if */
       if (!cls || !(cls = cls.trim())) {
           return;
@@ -6902,7 +6784,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+              cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
           }
           else {
               el.classList.add(cls);
@@ -6919,7 +6801,7 @@
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function removeClass(el, cls) {
+  function removeClass$1(el, cls) {
       /* istanbul ignore if */
       if (!cls || !(cls = cls.trim())) {
           return;
@@ -6927,7 +6809,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+              cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
           }
           else {
               el.classList.remove(cls);
@@ -6952,7 +6834,7 @@
       }
   }
 
-  function resolveTransition(def) {
+  function resolveTransition$1(def) {
       if (!def) {
           return;
       }
@@ -6960,16 +6842,16 @@
       if (typeof def === 'object') {
           var res = {};
           if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
+              extend(res, autoCssTransition$1(def.name || 'v'));
           }
           extend(res, def);
           return res;
       }
       else if (typeof def === 'string') {
-          return autoCssTransition(def);
+          return autoCssTransition$1(def);
       }
   }
-  var autoCssTransition = cached(function (name) {
+  var autoCssTransition$1 = cached(function (name) {
       return {
           enterClass: name + "-enter",
           enterToClass: name + "-enter-to",
@@ -6979,59 +6861,59 @@
           leaveActiveClass: name + "-leave-active",
       };
   });
-  var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = 'transition';
-  var ANIMATION = 'animation';
+  var hasTransition$1 = inBrowser && !isIE9;
+  var TRANSITION$1 = 'transition';
+  var ANIMATION$1 = 'animation';
   // Transition property/event sniffing
-  var transitionProp = 'transition';
-  var transitionEndEvent = 'transitionend';
-  var animationProp = 'animation';
-  var animationEndEvent = 'animationend';
-  if (hasTransition) {
+  var transitionProp$1 = 'transition';
+  var transitionEndEvent$1 = 'transitionend';
+  var animationProp$1 = 'animation';
+  var animationEndEvent$1 = 'animationend';
+  if (hasTransition$1) {
       /* istanbul ignore if */
       if (window.ontransitionend === undefined &&
           // @ts-expect-error
           window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
+          transitionProp$1 = 'WebkitTransition';
+          transitionEndEvent$1 = 'webkitTransitionEnd';
       }
       if (window.onanimationend === undefined &&
           // @ts-expect-error
           window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
+          animationProp$1 = 'WebkitAnimation';
+          animationEndEvent$1 = 'webkitAnimationEnd';
       }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf = inBrowser
+  var raf$1 = inBrowser
       ? window.requestAnimationFrame
           ? window.requestAnimationFrame.bind(window)
           : setTimeout
       : /* istanbul ignore next */ function (fn) { return fn(); };
-  function nextFrame(fn) {
-      raf(function () {
+  function nextFrame$1(fn) {
+      raf$1(function () {
           // @ts-expect-error
-          raf(fn);
+          raf$1(fn);
       });
   }
-  function addTransitionClass(el, cls) {
+  function addTransitionClass$1(el, cls) {
       var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
       if (transitionClasses.indexOf(cls) < 0) {
           transitionClasses.push(cls);
-          addClass(el, cls);
+          addClass$1(el, cls);
       }
   }
-  function removeTransitionClass(el, cls) {
+  function removeTransitionClass$1(el, cls) {
       if (el._transitionClasses) {
           remove$2(el._transitionClasses, cls);
       }
-      removeClass(el, cls);
+      removeClass$1(el, cls);
   }
-  function whenTransitionEnds(el, expectedType, cb) {
-      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+  function whenTransitionEnds$1(el, expectedType, cb) {
+      var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
       if (!type)
           { return cb(); }
-      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
       var ended = 0;
       var end = function () {
           el.removeEventListener(event, onEnd);
@@ -7051,30 +6933,30 @@
       }, timeout + 1);
       el.addEventListener(event, onEnd);
   }
-  var transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
+  var transformRE$1 = /\b(transform|all)(,|$)/;
+  function getTransitionInfo$1(el, expectedType) {
       var styles = window.getComputedStyle(el);
       // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout$1(animationDelays, animationDurations);
       var type;
       var timeout = 0;
       var propCount = 0;
       /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
+      if (expectedType === TRANSITION$1) {
           if (transitionTimeout > 0) {
-              type = TRANSITION;
+              type = TRANSITION$1;
               timeout = transitionTimeout;
               propCount = transitionDurations.length;
           }
       }
-      else if (expectedType === ANIMATION) {
+      else if (expectedType === ANIMATION$1) {
           if (animationTimeout > 0) {
-              type = ANIMATION;
+              type = ANIMATION$1;
               timeout = animationTimeout;
               propCount = animationDurations.length;
           }
@@ -7084,16 +6966,16 @@
           type =
               timeout > 0
                   ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
+                      ? TRANSITION$1
+                      : ANIMATION$1
                   : null;
           propCount = type
-              ? type === TRANSITION
+              ? type === TRANSITION$1
                   ? transitionDurations.length
                   : animationDurations.length
               : 0;
       }
-      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
       return {
           type: type,
           timeout: timeout,
@@ -7101,31 +6983,31 @@
           hasTransform: hasTransform,
       };
   }
-  function getTimeout(delays, durations) {
+  function getTimeout$1(delays, durations) {
       /* istanbul ignore next */
       while (delays.length < durations.length) {
           delays = delays.concat(delays);
       }
       return Math.max.apply(null, durations.map(function (d, i) {
-          return toMs(d) + toMs(delays[i]);
+          return toMs$1(d) + toMs$1(delays[i]);
       }));
   }
   // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
   // in a locale-dependent way, using a comma instead of a dot.
   // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
   // as a floor function) causing unexpected behaviors
-  function toMs(s) {
+  function toMs$1(s) {
       return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  function enter(vnode, toggleDisplay) {
+  function enter$1(vnode, toggleDisplay) {
       var el = vnode.elm;
       // call leave callback now
       if (isDef(el._leaveCb)) {
           el._leaveCb.cancelled = true;
           el._leaveCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      var data = resolveTransition$1(vnode.data.transition);
       if (isUndef(data)) {
           return;
       }
@@ -7163,19 +7045,19 @@
           : enterCancelled;
       var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
       if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
+          checkDuration$1(explicitEnterDuration, 'enter', vnode);
       }
       var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(enterHook);
+      var userWantsControl = getHookArgumentsLength$1(enterHook);
       var cb = (el._enterCb = once(function () {
           if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
+              removeTransitionClass$1(el, toClass);
+              removeTransitionClass$1(el, activeClass);
           }
           // @ts-expect-error
           if (cb.cancelled) {
               if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
+                  removeTransitionClass$1(el, startClass);
               }
               enterCancelledHook && enterCancelledHook(el);
           }
@@ -7200,19 +7082,19 @@
       // start enter transition
       beforeEnterHook && beforeEnterHook(el);
       if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(function () {
-              removeTransitionClass(el, startClass);
+          addTransitionClass$1(el, startClass);
+          addTransitionClass$1(el, activeClass);
+          nextFrame$1(function () {
+              removeTransitionClass$1(el, startClass);
               // @ts-expect-error
               if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
+                  addTransitionClass$1(el, toClass);
                   if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
+                      if (isValidDuration$1(explicitEnterDuration)) {
                           setTimeout(cb, explicitEnterDuration);
                       }
                       else {
-                          whenTransitionEnds(el, type, cb);
+                          whenTransitionEnds$1(el, type, cb);
                       }
                   }
               }
@@ -7226,14 +7108,14 @@
           cb();
       }
   }
-  function leave(vnode, rm) {
+  function leave$1(vnode, rm) {
       var el = vnode.elm;
       // call enter callback now
       if (isDef(el._enterCb)) {
           el._enterCb.cancelled = true;
           el._enterCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      var data = resolveTransition$1(vnode.data.transition);
       if (isUndef(data) || el.nodeType !== 1) {
           return rm();
       }
@@ -7243,23 +7125,23 @@
       }
       var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(leave);
+      var userWantsControl = getHookArgumentsLength$1(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
       if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
+          checkDuration$1(explicitLeaveDuration, 'leave', vnode);
       }
       var cb = (el._leaveCb = once(function () {
           if (el.parentNode && el.parentNode._pending) {
               el.parentNode._pending[vnode.key] = null;
           }
           if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
+              removeTransitionClass$1(el, leaveToClass);
+              removeTransitionClass$1(el, leaveActiveClass);
           }
           // @ts-expect-error
           if (cb.cancelled) {
               if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
+                  removeTransitionClass$1(el, leaveClass);
               }
               leaveCancelled && leaveCancelled(el);
           }
@@ -7287,19 +7169,19 @@
           }
           beforeLeave && beforeLeave(el);
           if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(function () {
-                  removeTransitionClass(el, leaveClass);
+              addTransitionClass$1(el, leaveClass);
+              addTransitionClass$1(el, leaveActiveClass);
+              nextFrame$1(function () {
+                  removeTransitionClass$1(el, leaveClass);
                   // @ts-expect-error
                   if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
+                      addTransitionClass$1(el, leaveToClass);
                       if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
+                          if (isValidDuration$1(explicitLeaveDuration)) {
                               setTimeout(cb, explicitLeaveDuration);
                           }
                           else {
-                              whenTransitionEnds(el, type, cb);
+                              whenTransitionEnds$1(el, type, cb);
                           }
                       }
                   }
@@ -7312,7 +7194,7 @@
       }
   }
   // only used in dev mode
-  function checkDuration(val, name, vnode) {
+  function checkDuration$1(val, name, vnode) {
       if (typeof val !== 'number') {
           warn$2("<transition> explicit " + name + " duration is not a valid number - " +
               ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -7322,7 +7204,7 @@
               'the duration expression might be incorrect.', vnode.context);
       }
   }
-  function isValidDuration(val) {
+  function isValidDuration$1(val) {
       return typeof val === 'number' && !isNaN(val);
   }
   /**
@@ -7331,7 +7213,7 @@
    * - a wrapped component method (check ._length)
    * - a plain function (.length)
    */
-  function getHookArgumentsLength(fn) {
+  function getHookArgumentsLength$1(fn) {
       if (isUndef(fn)) {
           return false;
       }
@@ -7339,7 +7221,7 @@
       var invokerFns = fn.fns;
       if (isDef(invokerFns)) {
           // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+          return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
       }
       else {
           // @ts-expect-error
@@ -7348,7 +7230,7 @@
   }
   function _enter(_, vnode) {
       if (vnode.data.show !== true) {
-          enter(vnode);
+          enter$1(vnode);
       }
   }
   var transition = inBrowser
@@ -7359,7 +7241,7 @@
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
-                  leave(vnode, rm);
+                  leave$1(vnode, rm);
               }
               else {
                   rm();
@@ -7507,43 +7389,501 @@
       el.dispatchEvent(e);
   }
 
-  // recursively search for possible transition defined inside the component root
-  function locateNode(vnode) {
-      // @ts-expect-error
-      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-          ? locateNode(vnode.componentInstance._vnode)
-          : vnode;
-  }
-  var show = {
-      bind: function (el, _a, vnode) {
-          var value = _a.value;
-          vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
-          var originalDisplay = (el.__vOriginalDisplay =
-              el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition) {
-              vnode.data.show = true;
-              enter(vnode, function () {
-                  el.style.display = originalDisplay;
-              });
+  var whitespaceRE$1 = /\s+/;
+  /**
+   * Add class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function addClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
           }
           else {
-              el.style.display = value ? originalDisplay : 'none';
+              el.classList.add(cls);
           }
-      },
-      update: function (el, _a, vnode) {
-          var value = _a.value, oldValue = _a.oldValue;
-          /* istanbul ignore if */
-          if (!value === !oldValue)
-              { return; }
-          vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
-          if (transition) {
-              vnode.data.show = true;
-              if (value) {
-                  enter(vnode, function () {
-                      el.style.display = el.__vOriginalDisplay;
-                  });
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
+      }
+  }
+  /**
+   * Remove class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function removeClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          var tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
+      }
+  }
+
+  function resolveTransition(def) {
+      if (!def) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def === 'object') {
+          var res = {};
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
+          }
+          extend(res, def);
+          return res;
+      }
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
+      }
+  }
+  var autoCssTransition = cached(function (name) {
+      return {
+          enterClass: name + "-enter",
+          enterToClass: name + "-enter-to",
+          enterActiveClass: name + "-enter-active",
+          leaveClass: name + "-leave",
+          leaveToClass: name + "-leave-to",
+          leaveActiveClass: name + "-leave-active",
+      };
+  });
+  var hasTransition = inBrowser && !isIE9;
+  var TRANSITION = 'transition';
+  var ANIMATION = 'animation';
+  // Transition property/event sniffing
+  var transitionProp = 'transition';
+  var transitionEndEvent = 'transitionend';
+  var animationProp = 'animation';
+  var animationEndEvent = 'animationend';
+  if (hasTransition) {
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          // @ts-expect-error
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          // @ts-expect-error
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
+  }
+  // binding to window is necessary to make hot reload work in IE in strict mode
+  var raf = inBrowser
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ function (fn) { return fn(); };
+  function nextFrame(fn) {
+      raf(function () {
+          // @ts-expect-error
+          raf(fn);
+      });
+  }
+  function addTransitionClass(el, cls) {
+      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
+  }
+  function removeTransitionClass(el, cls) {
+      if (el._transitionClasses) {
+          remove$2(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
+  }
+  function whenTransitionEnds(el, expectedType, cb) {
+      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+      if (!type)
+          { return cb(); }
+      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var ended = 0;
+      var end = function () {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      var onEnd = function (e) {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(function () {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
+  }
+  var transformRE = /\b(transform|all)(,|$)/;
+  function getTransitionInfo(el, expectedType) {
+      var styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var type;
+      var timeout = 0;
+      var propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
+      }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type: type,
+          timeout: timeout,
+          propCount: propCount,
+          hasTransform: hasTransform,
+      };
+  }
+  function getTimeout(delays, durations) {
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map(function (d, i) {
+          return toMs(d) + toMs(delays[i]);
+      }));
+  }
+  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+  // in a locale-dependent way, using a comma instead of a dot.
+  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+  // as a floor function) causing unexpected behaviors
+  function toMs(s) {
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+  }
+
+  function enter(vnode, toggleDisplay) {
+      var el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
+      }
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      var context = activeInstance;
+      var transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      var startClass = isAppear && appearClass ? appearClass : enterClass;
+      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      var enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      var enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(enterHook);
+      var cb = (el._enterCb = once(function () {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', function () {
+              var parent = el.parentNode;
+              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
+      }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
+      if (expectsCSS) {
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(function () {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
+      if (!expectsCSS && !userWantsControl) {
+          cb();
+      }
+  }
+  function leave(vnode, rm) {
+      var el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
+      }
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
+      }
+      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(leave);
+      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      var cb = (el._leaveCb = once(function () {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
+              }
+              leaveCancelled && leaveCancelled(el);
+          }
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
+      }
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(function () {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
+      }
+  }
+  // only used in dev mode
+  function checkDuration(val, name, vnode) {
+      if (typeof val !== 'number') {
+          warn$2("<transition> explicit " + name + " duration is not a valid number - " +
+              ("got " + JSON.stringify(val) + "."), vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn$2("<transition> explicit " + name + " duration is NaN - " +
+              'the duration expression might be incorrect.', vnode.context);
+      }
+  }
+  function isValidDuration(val) {
+      return typeof val === 'number' && !isNaN(val);
+  }
+  /**
+   * Normalize a transition hook's argument length. The hook may be:
+   * - a merged hook (invoker) with the original in .fns
+   * - a wrapped component method (check ._length)
+   * - a plain function (.length)
+   */
+  function getHookArgumentsLength(fn) {
+      if (isUndef(fn)) {
+          return false;
+      }
+      // @ts-expect-error
+      var invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
+  }
+
+  // recursively search for possible transition defined inside the component root
+  function locateNode(vnode) {
+      // @ts-expect-error
+      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+          ? locateNode(vnode.componentInstance._vnode)
+          : vnode;
+  }
+  var show = {
+      bind: function (el, _a, vnode) {
+          var value = _a.value;
+          vnode = locateNode(vnode);
+          var transition = vnode.data && vnode.data.transition;
+          var originalDisplay = (el.__vOriginalDisplay =
+              el.style.display === 'none' ? '' : el.style.display);
+          if (value && transition) {
+              vnode.data.show = true;
+              enter(vnode, function () {
+                  el.style.display = originalDisplay;
+              });
+          }
+          else {
+              el.style.display = value ? originalDisplay : 'none';
+          }
+      },
+      update: function (el, _a, vnode) {
+          var value = _a.value, oldValue = _a.oldValue;
+          /* istanbul ignore if */
+          if (!value === !oldValue)
+              { return; }
+          vnode = locateNode(vnode);
+          var transition = vnode.data && vnode.data.transition;
+          if (transition) {
+              vnode.data.show = true;
+              if (value) {
+                  enter(vnode, function () {
+                      el.style.display = el.__vOriginalDisplay;
+                  });
               }
               else {
                   leave(vnode, function () {
@@ -7910,10 +8250,10 @@
   };
 
   // install platform specific utils
-  Vue.config.mustUseProp = mustUseProp;
-  Vue.config.isReservedTag = isReservedTag;
+  Vue.config.mustUseProp = mustUseProp$1;
+  Vue.config.isReservedTag = isReservedTag$1;
   Vue.config.isReservedAttr = isReservedAttr;
-  Vue.config.getTagNamespace = getTagNamespace;
+  Vue.config.getTagNamespace = getTagNamespace$1;
   Vue.config.isUnknownElement = isUnknownElement;
   // install platform runtime directives & components
   extend(Vue.options.directives, platformDirectives);
@@ -7922,7 +8262,7 @@
   Vue.prototype.__patch__ = inBrowser ? patch : noop;
   // public mount method
   Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query(el) : undefined;
+      el = el && inBrowser ? query$1(el) : undefined;
       return mountComponent(this, el, hydrating);
   };
   // devtools global hook
@@ -7949,6 +8289,75 @@
       }, 0);
   }
 
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  makeMap('style,class');
+  // attributes that should be using props for binding
+  var acceptValue = makeMap('input,textarea,option,select,progress');
+  var mustUseProp = function (tag, type, attr) {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
+  };
+  makeMap('contenteditable,draggable,spellcheck');
+  makeMap('events,caret,typing,plaintext-only');
+  makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
+  // this map is intentionally selective, only covering SVG elements that may
+  // contain child elements.
+  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  var isPreTag = function (tag) { return tag === 'pre'; };
+  var isReservedTag = function (tag) {
+      return isHTMLTag(tag) || isSVG(tag);
+  };
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
+  }
+  makeMap('text,number,password,search,email,tel,url');
+
+  /**
+   * Query an element selector if it's not an element already.
+   */
+  function query(el) {
+      if (typeof el === 'string') {
+          var selected = document.querySelector(el);
+          if (!selected) {
+              warn$2('Cannot find element: ' + el);
+              return document.createElement('div');
+          }
+          return selected;
+      }
+      else {
+          return el;
+      }
+  }
+
   var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
   var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
   var buildRegex = cached(function (delimiters) {
@@ -8062,11 +8471,20 @@
       genData: genData$1,
   };
 
-  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+  var decoder;
+  var he = {
+      decode: function (html) {
+          decoder = decoder || document.createElement('div');
+          decoder.innerHTML = html;
+          return decoder.textContent;
+      },
+  };
+
+  makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
   var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -8362,7 +8780,7 @@
       }
   }
 
-  var he = require('he');
+  // const he = require('he')
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -8379,7 +8797,7 @@
   var decodeHTMLCached = cached(he.decode);
   var emptySlotScopeToken = "_empty_";
   // configurable state
-  var warn;
+  var warn$1;
   var delimiters;
   var transforms;
   var preTransforms;
@@ -8403,7 +8821,7 @@
    * Convert HTML string to AST.
    */
   function parse(template, options) {
-      warn = options.warn || baseWarn;
+      warn$1 = options.warn || baseWarn;
       platformIsPreTag = options.isPreTag || no;
       platformMustUseProp = options.mustUseProp || no;
       platformGetTagNamespace = options.getTagNamespace || no;
@@ -8424,7 +8842,7 @@
       function warnOnce(msg, range) {
           if (!warned) {
               warned = true;
-              warn(msg, range);
+              warn$1(msg, range);
           }
       }
       function closeElement(element) {
@@ -8505,7 +8923,7 @@
           }
       }
       parseHTML(template, {
-          warn: warn,
+          warn: warn$1,
           expectHTML: options.expectHTML,
           isUnaryTag: options.isUnaryTag,
           canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8537,7 +8955,7 @@
                   }
                   attrs.forEach(function (attr) {
                       if (invalidAttributeRE.test(attr.name)) {
-                          warn("Invalid dynamic argument expression: attribute names cannot contain " +
+                          warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
                               "spaces, quotes, <, >, / or =.", {
                               start: attr.start + attr.name.indexOf("["),
                               end: attr.start + attr.name.length,
@@ -8547,7 +8965,7 @@
               }
               if (isForbiddenTag(element) && !isServerRendering()) {
                   element.forbidden = true;
-                  warn('Templates should only be responsible for mapping the state to the ' +
+                  warn$1('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
                           ("<" + tag + ">") +
                           ', as they will not be parsed.', { start: element.start });
@@ -8738,7 +9156,7 @@
       if (exp) {
           {
               if (el.tag === 'template') {
-                  warn("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                  warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
@@ -8747,7 +9165,7 @@
                       iterator === exp &&
                       parent_1 &&
                       parent_1.tag === 'transition-group') {
-                      warn("Do not use v-for index as key on <transition-group> children, " +
+                      warn$1("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
               }
@@ -8770,7 +9188,7 @@
               extend(el, res);
           }
           else {
-              warn("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+              warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -8822,7 +9240,7 @@
           });
       }
       else {
-          warn("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+          warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
               ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
@@ -8834,7 +9252,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                  warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -8861,7 +9279,7 @@
           slotScope = getAndRemoveAttr(el, 'scope');
           /* istanbul ignore if */
           if (slotScope) {
-              warn("the \"scope\" attribute for scoped slots have been deprecated and " +
+              warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
                   "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
                   "can also be used on plain elements in addition to <template> to " +
                   "denote scoped slots.", el.rawAttrsMap['scope'], true);
@@ -8871,7 +9289,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -8896,10 +9314,10 @@
               if (slotBinding) {
                   {
                       if (el.slotTarget || el.slotScope) {
-                          warn("Unexpected mixed usage of different slot syntaxes.", el);
+                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.parent && !maybeComponent(el.parent)) {
-                          warn("<template v-slot> can only appear at the root level inside " +
+                          warn$1("<template v-slot> can only appear at the root level inside " +
                               "the receiving component", el);
                       }
                   }
@@ -8915,13 +9333,13 @@
               if (slotBinding) {
                   {
                       if (!maybeComponent(el)) {
-                          warn("v-slot can only be used on components or <template>.", slotBinding);
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding);
                       }
                       if (el.slotScope || el.slotTarget) {
-                          warn("Unexpected mixed usage of different slot syntaxes.", el);
+                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
-                          warn("To avoid scope ambiguity, the default slot should also use " +
+                          warn$1("To avoid scope ambiguity, the default slot should also use " +
                               "<template> syntax when there are other named slots.", slotBinding);
                       }
                   }
@@ -8953,7 +9371,7 @@
               name = 'default';
           }
           else {
-              warn("v-slot shorthand syntax requires a slot name.", binding);
+              warn$1("v-slot shorthand syntax requires a slot name.", binding);
           }
       }
       return dynamicArgRE.test(name)
@@ -8967,7 +9385,7 @@
       if (el.tag === 'slot') {
           el.slotName = getBindingAttr(el, 'name');
           if (el.key) {
-              warn("`key` does not work on <slot> because slots are abstract outlets " +
+              warn$1("`key` does not work on <slot> because slots are abstract outlets " +
                   "and can possibly expand into multiple elements. " +
                   "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
           }
@@ -9006,7 +9424,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                      warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -9020,14 +9438,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn, list[i]);
+                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn, list[i]);
+                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn, list[i], true // dynamic
+                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
                               );
                           }
                       }
@@ -9047,7 +9465,7 @@
                   if (isDynamic) {
                       name = name.slice(1, -1);
                   }
-                  addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
               }
               else {
                   // normal directives
@@ -9074,7 +9492,7 @@
               {
                   var res = parseText(value, delimiters);
                   if (res) {
-                      warn(name + "=\"" + value + "\": " +
+                      warn$1(name + "=\"" + value + "\": " +
                           'Interpolation inside attributes has been removed. ' +
                           'Use v-bind or the colon shorthand instead. For example, ' +
                           'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9117,7 +9535,7 @@
           if (map[attrs[i].name] &&
               !isIE &&
               !isEdge) {
-              warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
           }
           map[attrs[i].name] = attrs[i].value;
       }
@@ -9150,7 +9568,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+              warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -9230,11 +9648,132 @@
   function cloneASTElement(el) {
       return createASTElement(el.tag, el.attrsList.slice(), el.parent);
   }
-  var model = {
+  var model$1 = {
       preTransformNode: preTransformNode,
   };
 
-  var modules = [klass, style, model];
+  var modules = [klass, style, model$1];
+
+  var warn;
+  // in some cases, the event used has to be determined at runtime
+  // so we used some reserved tokens during compile.
+  var RANGE_TOKEN = '__r';
+  function model(el, dir, _warn) {
+      warn = _warn;
+      var value = dir.value;
+      var modifiers = dir.modifiers;
+      var tag = el.tag;
+      var type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+                  "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else if (!config.isReservedTag(tag)) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else {
+          warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+              "v-model is not supported on this element type. " +
+              "If you are working with contenteditable, it's recommended to " +
+              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', "Array.isArray(" + value + ")" +
+          ("?_i(" + value + "," + valueBinding + ")>-1") +
+          (trueValueBinding === 'true'
+              ? ":(" + value + ")"
+              : ":_q(" + value + "," + trueValueBinding + ")"));
+      addHandler(el, 'change', "var $$a=" + value + "," +
+          '$$el=$event.target,' +
+          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+          'if(Array.isArray($$a)){' +
+          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+          '$$i=_i($$a,$$v);' +
+          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
+          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
+          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
+      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      var number = modifiers && modifiers.number;
+      var selectedVal = "Array.prototype.filter" +
+          ".call($event.target.options,function(o){return o.selected})" +
+          ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
+          ("return " + (number ? '_n(val)' : 'val') + "})");
+      var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      var code = "var $$selectedVal = " + selectedVal + ";";
+      code = code + " " + genAssignmentCode(value, assignment);
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      var type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value_1 && !typeBinding) {
+              var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+      var needCompositionGuard = !lazy && type !== 'range';
+      var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      var valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = "$event.target.value.trim()";
+      }
+      if (number) {
+          valueExpression = "_n(" + valueExpression + ")";
+      }
+      var code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = "if($event.target.composing)return;" + code;
+      }
+      addProp(el, 'value', "(" + value + ")");
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
+  }
 
   function text(el, dir) {
       if (dir.value) {
@@ -9249,11 +9788,24 @@
   }
 
   var directives = {
-      model: model$1,
+      model: model,
       text: text,
       html: html,
   };
 
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
+
   var baseOptions = {
       expectHTML: true,
       modules: modules,
@@ -10180,6 +10732,7 @@
   function repeat(str, n) {
       var result = '';
       if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
           while (true) {
               // eslint-disable-line
               if (n & 1)
diff --git a/dist/vue.min.js b/dist/vue.min.js
index d6f19e63635..3bf7f1b738b 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(){function e(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var o,a=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":o=r;break;case"splice":o=r.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&we(t),o.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function je(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=je(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Ae[r]||Ee;a[r]=i(e[r],t[r],n,r)}return a}function De(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Le(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Pe(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var u=_e;be(!0),we(a),be(u)}return a}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch(function(e){return Re(e,r,i+" (Promise/async)")}),o._handled=!0)}catch(e){Re(e,r,i)}return o}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],Je=!1;function qe(){Je=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(qe),Z&&setTimeout(S)},Ve=!0}else if(J||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(qe)}:function(){setTimeout(qe,0)};else{var Ze=1,Ge=new MutationObserver(qe),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),Je||(Je=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var a=Array.isArray(t);if(!a&&!o(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)He(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=tt(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=nt(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=tt(c)).name,n[c],f.capture)}function it(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=nt([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=nt([s,c]),a.merged=!0,e[i]=a}function ot(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function at(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(o,a){var s=[];var c,u,l,f;for(c=0;c<o.length;c++)t(u=o[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(st((u=e(u,(a||"")+"_"+c))[0])&&st(f)&&(s[l]=ve(f.text+u[0].text),u.shift()),s.push.apply(s,u)):i(u)?st(f)?s[l]=ve(f.text+u):""!==u&&s.push(ve(u)):st(u)&&st(f)?s[l]=ve(f.text+u.text):(r(o._isVList)&&n(u.tag)&&t(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function ut(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(lt)&&delete n[u];return n}function lt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=dt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:at(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function mt(e){return De(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):o?yt(o,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(o(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?kt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=l,e._l=vt,e._t=ht,e._q=E,e._i=j,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=ct(u.inject,o),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=ut(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var o=he(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var jt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;jt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Le(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,qt(t,r,h),u&&(t.$slots=ut(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},Dt=Object.keys(jt);function Lt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Ht;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return h(s,a)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=D(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout(function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=de();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},$n(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ot(a,c,u,l,!0)||ot(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Le(l,u,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=at(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Dt.length;n++){var r=Dt[n],i=t[r],o=jt[r];i===o||i&&i._merged||(t[r]=i?Mt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,a,s,c,u,l){return(Array.isArray(s)||i(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Ft),function(e,i,a,s,c){if(n(a)&&n(a.__ob__))return de();n(a)&&n(a.is)&&(i=a.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=at(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var u,l;if("string"==typeof i){var f=void 0;l=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),u=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),a,s,void 0,void 0,e):a&&a.pre||!n(f=De(e.$options,"components",i))?new pe(i,a,s,void 0,void 0,e):Lt(f,a,e,s,i)}else u=Lt(i,a,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(i,o,a){i.ns=o;"foreignObject"===i.tag&&(o=void 0,a=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var u=i.children[s];n(u.tag)&&(t(u.ns)||r(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(a)&&function(e){o(e.style)&&et(e.style);o(e.class)&&et(e.class)}(a),u):de()}(e,a,s,c,u)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function Jt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function qt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,Jt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,on=0;var an=0,sn=Date.now;if(U&&!J){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function un(){var e,t;for(an=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),on=0;on<Qt.length;on++)(e=Qt[on]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();on=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var ln=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++ln,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>on&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(un))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var o=function(o){i.push(o);var a=Le(o,t,n,e);Ce(r,o,a),o in e||dn(e,"_props",o)};for(var a in t)o(a);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||(a=void 0,36!==(a=(o+"").charCodeAt(0))&&95!==a&&dn(e,"_data",o))}var a;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new fn(e,a||S,S,hn)),i in e||mn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=je(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=je(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach(function(e){a[e]=n[e]}),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=xn(a.componentOptions);s&&!t(s)&&On(n,o,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=je($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&qt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=ut(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var o=r&&r.data;Ce(t,"$attrs",o&&o.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){le();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,o=t.length;i<o;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,o=this.exclude;if(i&&(!r||!kn(i,r))||o&&r&&kn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:je,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=je(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},Dn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=function(e,t){return Hn(t)||"false"===t?"false":"contenteditable"===e&&Ln(t)?t:"true"},In=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Pn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Rn=function(e){return Pn(e)?e.slice(6,e.length):""},Hn=function(e){return null==e||!1===e};function Bn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Un(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Un(t,r.data));return function(e,t){if(n(e)||n(t))return zn(e,Vn(t));return""}(t.staticClass,t.class)}function Un(e,t){return{staticClass:zn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function zn(e,t){return e?t?e+" "+t:e:t||""}function Vn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Vn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Kn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Jn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(e){return Jn(e)||qn(e)};function Zn(e){return qn(e)?"svg":"math"===e?"math":void 0}var Gn=Object.create(null);var Xn=p("text,number,password,search,email,tel,url");function Yn(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Kn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Xn(i)&&Xn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?it(t,"insert",f):f()}l.length&&it(t,"postpatch",function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)});if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=De(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(J||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Pn(o)?s.removeAttributeNS(Fn,Rn(o)):Dn(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):In(t)?Hn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Dn(t)?e.setAttribute(t,Mn(t,n)):Pn(t)?Hn(n)?e.removeAttributeNS(Fn,Rn(t)):e.setAttributeNS(Fn,t,n):hr(e,t,n)}function hr(e,t,n){if(Hn(n))e.removeAttribute(t);else{if(J&&!q&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=zn(s,Vn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v";r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?Jr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function Jr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var qr,Wr="__r",Zr="__c";function Gr(e,t,n){var r=qr;return function i(){null!==t.apply(null,arguments)&&Qr(e,i,n,r)}}var Xr=Ve&&!(X&&Number(X[1])<=53);function Yr(e,t,n,r){if(Xr){var i=an,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}qr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Qr(e,t,n,r){(r||qr).removeEventListener(e,t._wrapper||t,n)}function ei(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};qr=r.elm,function(e){if(n(e[Wr])){var t=J?"change":"input";e[t]=[].concat(e[Wr],e[t]||[]),delete e[Wr]}n(e[Zr])&&(e.change=[].concat(e[Zr],e.change||[]),delete e[Zr])}(i),rt(i,o,Yr,Qr,Gr,r.context),qr=void 0}}var ti,ni={create:ei,update:ei};function ri(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ii(a,u)&&(a.value=u)}else if("innerHTML"===i&&qn(a.tagName)&&t(a.innerHTML)){(ti=ti||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ti.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ii(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var oi={create:ri,update:ri},ai=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function si(e){var t=ci(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ci(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ui,li=/^--/,fi=/\s*!important$/,pi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(fi.test(n))e.style.setProperty(C(t),n.replace(fi,""),"important");else{var r=vi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},di=["Webkit","Moz","ms"],vi=g(function(e){if(ui=ui||document.createElement("div").style,"filter"!==(e=b(e))&&e in ui)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<di.length;n++){var r=di[n]+t;if(r in ui)return r}});function hi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ci(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=si(i.data))&&A(r,n);(n=si(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=si(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&pi(c,s,"");for(s in d)(a=d[s])!==f[s]&&pi(c,s,null==a?"":a)}}var mi={create:hi,update:hi},yi=/\s+/;function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function _i(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(yi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function bi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,$i(e.name||"v")),A(t,e),t}return"string"==typeof e?$i(e):void 0}}var $i=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),wi=U&&!q,Ci="transition",xi="animation",ki="transition",Ai="transitionend",Oi="animation",Si="animationend";wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(ki="WebkitTransition",Ai="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Oi="WebkitAnimation",Si="webkitAnimationEnd"));var Ti=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ni(e){Ti(function(){Ti(e)})}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),gi(e,t))}function ji(e,t){e._transitionClasses&&h(e._transitionClasses,t),_i(e,t)}function Di(e,t,n){var r=Mi(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===Ci?Ai:Si,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout(function(){c<a&&u()},o+1),e.addEventListener(s,l)}var Li=/\b(transform|all)(,|$)/;function Mi(e,t){var n,r=window.getComputedStyle(e),i=(r[ki+"Delay"]||"").split(", "),o=(r[ki+"Duration"]||"").split(", "),a=Ii(i,o),s=(r[Oi+"Delay"]||"").split(", "),c=(r[Oi+"Duration"]||"").split(", "),u=Ii(s,c),l=0,f=0;return t===Ci?a>0&&(n=Ci,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Ci:xi:null)?n===Ci?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===Ci&&Li.test(r[ki+"Property"])}}function Ii(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Fi(t)+Fi(e[n])}))}function Fi(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Pi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=bi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,N=O&&v?v:l,E=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!q,P=Bi(j),R=i._enterCb=D(function(){F&&(ji(i,N),ji(i,T)),R.cancelled?(F&&ji(i,S),M&&M(i)):L&&L(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)}),E&&E(i),F&&(Ei(i,S),Ei(i,T),Ni(function(){ji(i,S),R.cancelled||(Ei(i,N),P||(Hi(I)?setTimeout(R,I):Di(i,c,R)))})),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Ri(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=bi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Bi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ji(i,l),ji(i,p)),w.cancelled?(_&&ji(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ni(function(){ji(i,u),w.cancelled||(Ei(i,l),b||(Hi($)?setTimeout(w,$):Di(i,c,w)))})),v&&v(i,w),_||b||w())}}function Hi(e){return"number"==typeof e&&!isNaN(e)}function Bi(e){if(t(e))return!1;var r=e.fns;return n(r)?Bi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Ui(e,t){!0!==t.data.show&&Pi(t)}var zi=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=he(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){for(var o,a=e;a.componentInstance;)if(a=a.componentInstance._vnode,n(o=a.data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ni,oi,mi,U?{create:Ui,activate:Ui,remove:function(e,t){!0!==e.data.show?Ri(e,t):t()}}:{}].concat(pr)});q&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Xi(e,"input")});var Vi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Vi.componentUpdated(e,t,n)}):Ki(e,t,n.context),e._vOptions=[].map.call(e.options,Wi)):("textarea"===n.tag||Xn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Zi),e.addEventListener("compositionend",Gi),e.addEventListener("change",Gi),q&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ki(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Wi);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return qi(e,i)}):t.value!==t.oldValue&&qi(t.value,i))&&Xi(e,"change")}}};function Ki(e,t,n){Ji(e,t),(J||W)&&setTimeout(function(){Ji(e,t)},0)}function Ji(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Wi(a))>-1,a.selected!==o&&(a.selected=o);else if(E(Wi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every(function(t){return!E(t,e)})}function Wi(e){return"_value"in e?e._value:e.value}function Zi(e){e.target.composing=!0}function Gi(e){e.target.composing&&(e.target.composing=!1,Xi(e.target,"input"))}function Xi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Yi(e){return!e.componentInstance||e.data&&e.data.transition?e:Yi(e.componentInstance._vnode)}var Qi={model:Vi,show:{bind:function(e,t,n){var r=t.value,i=(n=Yi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Pi(n,function(){e.style.display=o})):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Yi(n)).data&&n.data.transition?(n.data.show=!0,r?Pi(n,function(){e.style.display=e.__vOriginalDisplay}):Ri(n,function(){e.style.display="none"})):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},eo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function to(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?to(zt(t.children)):e}function no(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ro(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var io=function(e){return e.tag||Ut(e)},oo=function(e){return"show"===e.name},ao={name:"transition",props:eo,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(io)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=to(o);if(!a)return o;if(this._leaving)return ro(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=no(this),u=this._vnode,l=to(u);if(a.data.directives&&a.data.directives.some(oo)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Ut(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ro(e,o);if("in-out"===r){if(Ut(a))return u;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return o}}},so=A({tag:String,moveClass:String},eo);function co(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function uo(e){e.data.newPos=e.elm.getBoundingClientRect()}function lo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete so.mode;var fo={Transition:ao,TransitionGroup:{props:so,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=no(this),s=0;s<i.length;s++){(l=i[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(o.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=e(t,null,c),this.removed=u}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(co),e.forEach(uo),e.forEach(lo),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ai,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ai,e),n._moveCb=null,ji(n,t))})}}))},methods:{hasMove:function(e,t){if(!wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){_i(n,e)}),gi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Mi(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=jn,wn.config.isReservedTag=Wn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=Zn,wn.config.isUnknownElement=function(e){if(!U)return!0;if(Wn(e))return!1;if(e=e.toLowerCase(),null!=Gn[e])return Gn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Gn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Gn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,Qi),A(wn.options.components,fo),wn.prototype.__patch__=U?zi:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?Yn(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g(function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},go=p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),_o=p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,No=/^<!\[/,Eo=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,function(e){return Do[e]})}function Ro(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,u=function(){if(n=e,r&&Eo(r)){var u=0,p=r.toLowerCase(),d=jo[p]||(jo[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return u=r.length,Eo(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(To.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(No.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(So);if(y)return l(y[0].length),"continue";var g=e.match(Oo);if(g){var _=c;return l(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(ko);if(t){var n={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Ao))&&(i=e.match(wo)||e.match($o));)i.start=c,l(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&f(r),s(n)&&r===n&&f(n));for(var u=a(n)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:Po(h,m)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,u,e.start,e.end)}(b),Fo(b.tagName,e)&&l(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Oo.test(w)||ko.test(w)||To.test(w)||No.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&l($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}f()}var Ho,Bo,Uo,zo,Vo,Ko,Jo,qo,Wo=require("he"),Zo=/^@|^v-on:/,Go=/^v-|^@|^:|^#/,Xo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Qo=/^\(|\)$/g,ea=/^\[.*\]$/,ta=/:(.*)$/,na=/^:|^\.|^v-bind:/,ra=/\.[^.\]]+(?=[^\]]*$)/g,ia=/^v-slot(:|$)|^#/,oa=/[\r\n]/,aa=/[ \f\t\r\n]+/g,sa=g(Wo.decode),ca="_empty_";function ua(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ma(t),rawAttrsMap:{},parent:n,children:[]}}function la(e,t){Ho=t.warn||Sr,Ko=t.isPreTag||T,Jo=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Uo=Tr(t.modules,"transformNode"),zo=Tr(t.modules,"preTransformNode"),Vo=Tr(t.modules,"postTransformNode"),Bo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=fa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&da(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&da(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ko(e.tag)&&(c=!1);for(var f=0;f<Vo.length;f++)Vo[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return Ro(e,{warn:Ho,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ya.test(r.name)||(r.name=r.name.replace(ga,""),t.push(r))}return t}(o));var d,v=ua(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<zo.length;h++)v=zo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ko(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(pa(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,da(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:sa(e):u.length?a?"condense"===a&&oa.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(aa," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Bo))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function fa(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,ia);if(r){var i=va(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ca}}else{var r=Pr(e,ia);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=va(r),u=c.name,a=c.dynamic,l=s[u]=ua("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=r.value||ca,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Uo.length;i++)e=Uo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Go.test(r))if(e.hasBindings=!0,(a=ha(r.replace(Go,"")))&&(r=r.replace(ra,"")),na.test(r))r=r.replace(na,""),o=Ar(o),(c=ea.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Jo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):Er(e,r,o,u[t],c);else if(Zo.test(r))r=r.replace(Zo,""),(c=ea.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Go,"")).match(ta),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ea.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Er(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Jo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function pa(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Xo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Qo,""),i=r.match(Yo);i?(n.alias=r.replace(Yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function da(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function va(e){var t=e.name.replace(ia,"");return t||"#"!==e.name[0]&&(t="default"),ea.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ha(e){var t=e.match(ra);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function ma(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ya=/^xmlns:NS\d+/,ga=/^NS\d+:/;function _a(e){return ua(e.tag,e.attrsList.slice(),e.parent)}var ba=[mo,yo,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=Ir(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=_a(e);pa(c),jr(c,"type","checkbox"),fa(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,da(c,{exp:c.if,block:c});var u=_a(e);Fr(u,"v-for",!0),jr(u,"type","radio"),fa(u,t),da(c,{exp:"("+r+")==='radio'"+o,block:u});var l=_a(e);return Fr(l,"v-for",!0),jr(l,":type",r),fa(l,t),da(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var $a,wa,Ca={expectHTML:!0,modules:ba,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?Wr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f),Nr(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:go,mustUseProp:jn,canBeLeftOpenTag:_o,isReservedTag:Wn,getTagNamespace:Zn,staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(ba)},xa=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function ka(e,t){e&&($a=xa(t.staticKeys||""),wa=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!wa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every($a)))}(t);if(1===t.type){if(!wa(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var o=t.ifConditions[n].block;e(o),o.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Aa=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Oa=/\([^)]*?\);*$/,Sa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ta={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Na={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},ja={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function Da(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=La(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function La(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return La(e)}).join(",")+"]";var t=Sa.test(e.value),n=Aa.test(e.value),r=Sa.test(e.value.replace(Oa,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(ja[t])o+=ja[t],Ta[t]&&a.push(t);else if("exact"===t){var n=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Ma).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Ma(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Ta[e],r=Na[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ia={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Fa=function(){return function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ia),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function Pa(e,t){var n=new Fa(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ra(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ra(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ha(e,t);if(e.once&&!e.onceProcessed)return Ba(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ua(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=qa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:qa(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:qa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return qa(e,t)||"void 0"}function Ha(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ra(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ba(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ua(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ra(e,t)+","+t.onceId+++","+n+")":Ra(e,t)}return Ha(e,t)}function Ua(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,n,r,i):""+a(o.block);function a(e){return r?r(e,n):e.once?Ba(e,n):Ra(e,n)}}(e.ifConditions.slice(),t,n,r)}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ra)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=Da(e.events,!1)+","),e.nativeEvents&&(n+=Da(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)}),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ca||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return Ja(t[e],n)}).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Pa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function Ja(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ua(e,t,Ja,"null");if(e.for&&!e.forProcessed)return za(e,t,Ja);var r=e.slotScope===ca?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(qa(e,t)||"undefined")+":undefined":qa(e,t)||"undefined":Ra(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function qa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ra)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some(function(e){return Wa(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Ra(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:Xa(JSON.stringify(n.text)))+")";var n,r}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Ya(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=la(e.trim(),t);!1!==t.optimize&&ka(n,t);var r=Pa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(Ca).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g(function(e){var t=Yn(e);return t&&t.innerHTML}),ss=wn.prototype.$mount;return wn.prototype.$mount=function(e,t){if((e=e&&Yn(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},wn.compile=ns,wn});
\ No newline at end of file
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(){function e(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var a,o=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":a=r;break;case"splice":a=r.slice(2)}return a&&s.observeArray(a),s.dep.notify(),o})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&we(t),a.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in A(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?A({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Ae[r]||Ee;o[r]=i(e[r],t[r],n,r)}return o}function je(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function De(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Pe(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var l=_e;be(!0),we(o),be(l)}return o}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch(function(e){return Re(e,r,i+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,r,i)}return a}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],qe=!1;function Je(){qe=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(Je),Z&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Je)}:function(){setTimeout(Je,0)};else{var Ze=1,Ge=new MutationObserver(Je),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),qe||(qe=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(o)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)He(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=tt(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=nt(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=tt(c)).name,n[c],f.capture)}function it(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=nt([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=nt([s,c]),o.merged=!0,e[i]=o}function at(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ot(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(a,o){var s=[];var c,l,u,f;for(c=0;c<a.length;c++)t(l=a[c])||"boolean"==typeof l||(u=s.length-1,f=s[u],Array.isArray(l)?l.length>0&&(st((l=e(l,(o||"")+"_"+c))[0])&&st(f)&&(s[u]=ve(f.text+l[0].text),l.shift()),s.push.apply(s,l)):i(l)?st(f)?s[u]=ve(f.text+l):""!==l&&s.push(ve(l)):st(l)&&st(f)?s[u]=ve(f.text+l.text):(r(a._isVList)&&n(l.tag)&&t(l.key)&&n(o)&&(l.key="__vlist"+o+"_"+c+"__"),s.push(l)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function lt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ut)&&delete n[l];return n}function ut(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=dt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ot(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=A(A({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function mt(e){return je(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):a?yt(a,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(a(n)){Array.isArray(n)&&(n=O(n));var o=void 0,s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?kt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=u,e._l=vt,e._t=ht,e._q=E,e._i=L,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=ct(l.inject,a),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=lt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var a=he(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var Lt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Lt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=De(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Jt(t,r,h),l&&(t.$slots=lt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},jt=Object.keys(Lt);function Dt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Ht;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",function(){return h(s,o)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=j(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout(function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=de();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},$n(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);at(o,c,l,u,!0)||at(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=De(u,l,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ot(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<jt.length;n++){var r=jt[n],i=t[r],a=Lt[r];i===a||i&&i._merged||(t[r]=i?Mt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,o,s,c,l,u){return(Array.isArray(s)||i(s))&&(l=c,c=s,s=void 0),r(u)&&(l=Ft),function(e,i,o,s,c){if(n(o)&&n(o.__ob__))return de();n(o)&&n(o.is)&&(i=o.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=ot(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var l,u;if("string"==typeof i){var f=void 0;u=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),l=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),o,s,void 0,void 0,e):o&&o.pre||!n(f=je(e.$options,"components",i))?new pe(i,o,s,void 0,void 0,e):Dt(f,o,e,s,i)}else l=Dt(i,o,e,s);return Array.isArray(l)?l:n(l)?(n(u)&&function e(i,a,o){i.ns=a;"foreignObject"===i.tag&&(a=void 0,o=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var l=i.children[s];n(l.tag)&&(t(l.ns)||r(o)&&"svg"!==l.tag)&&e(l,a,o)}}(l,u),n(o)&&function(e){a(e.style)&&et(e.style);a(e.class)&&et(e.class)}(o),l):de()}(e,o,s,c,l)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function qt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function Jt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,qt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,an=0;var on=0,sn=Date.now;if(U&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function ln(){var e,t;for(on=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),an=0;an<Qt.length;an++)(e=Qt[an]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();an=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var un=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>an&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(ln))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var a=function(a){i.push(a);var o=De(a,t,n,e);Ce(r,a,o),a in e||dn(e,"_props",a)};for(var o in t)a(o);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||(o=void 0,36!==(o=(a+"").charCodeAt(0))&&95!==o&&dn(e,"_data",a))}var o;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new fn(e,o||S,S,hn)),i in e||mn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Le(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach(function(e){o[e]=n[e]}),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=A({},o.options),i[r]=o,o}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=xn(o.componentOptions);s&&!t(s)&&On(n,a,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Jt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=lt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var a=r&&r.data;Ce(t,"$attrs",a&&a.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){ue();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,a=t.length;i<a;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,a=this.exclude;if(i&&(!r||!kn(i,r))||a&&r&&kn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:A,mergeOptions:Le,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),Ln=p("contenteditable,draggable,spellcheck"),jn=p("events,caret,typing,plaintext-only"),Dn=function(e,t){return Rn(t)||"false"===t?"false":"contenteditable"===e&&jn(t)?t:"true"},Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Fn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Pn=function(e){return Fn(e)?e.slice(6,e.length):""},Rn=function(e){return null==e||!1===e};function Hn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Bn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Bn(t,r.data));return function(e,t){if(n(e)||n(t))return Un(e,zn(t));return""}(t.staticClass,t.class)}function Bn(e,t){return{staticClass:Un(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Un(e,t){return e?t?e+" "+t:e:t||""}function zn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=zn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Jn=function(e){return Kn(e)||qn(e)};var Wn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Vn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Xn={create:function(e,t){Yn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(Yn(e,!0),Yn(t))},destroy:function(e){Yn(e,!0)}};function Yn(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var Qn=new pe("",{},[]),er=["create","activate","update","remove","destroy"];function tr(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Zn(i)&&Zn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function nr(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var rr={create:ir,update:ir,destroy:function(e){ir(e,Qn)}};function ir(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===Qn,o=t===Qn,s=or(e.data.directives,e.context),c=or(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,cr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(cr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)cr(l[n],"inserted",t,e)};a?it(t,"insert",f):f()}u.length&&it(t,"postpatch",function(){for(var n=0;n<u.length;n++)cr(u[n],"componentUpdated",t,e)});if(!a)for(n in s)c[n]||cr(s[n],"unbind",e,e,o)}(e,t)}var ar=Object.create(null);function or(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ar),i[sr(r)]=r,r.def=je(t.$options,"directives",r.name);return i}function sr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function cr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var lr=[Xn,rr];function ur(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=A({},l)),l)o=l[a],c[a]!==o&&fr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&fr(s,"value",l.value),c)t(l[a])&&(Fn(a)?s.removeAttributeNS(In,Pn(a)):Ln(a)||s.removeAttribute(a))}}function fr(e,t,n,r){r||e.tagName.indexOf("-")>-1?pr(e,t,n):Mn(t)?Rn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Ln(t)?e.setAttribute(t,Dn(t,n)):Fn(t)?Rn(n)?e.removeAttributeNS(In,Pn(t)):e.setAttributeNS(In,t,n):pr(e,t,n)}function pr(e,t,n){if(Rn(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var dr={create:ur,update:ur};function vr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Hn(r),c=i._transitionClasses;n(c)&&(s=Un(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var hr,mr,yr,gr,_r,br,$r={create:vr,update:vr},wr=/[\w).+\-_$\]]/;function Cr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&wr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=xr(i,a[r]);return i}function xr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function kr(e,t){console.error("[Vue compiler]: "+e)}function Ar(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Or(e,t,n,r,i){(e.props||(e.props=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Sr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Tr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Ir({name:t,value:n},r))}function Nr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Ir({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Er(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Lr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Er("!",n,c)),i.once&&(delete i.once,n=Er("~",n,c)),i.passive&&(delete i.passive,n=Er("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Ir({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function jr(e,t,n){var r=Dr(e,":"+t)||Dr(e,"v-bind:"+t);if(null!=r)return Cr(r);if(!1!==n){var i=Dr(e,t);if(null!=i)return JSON.stringify(i)}}function Dr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Mr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Ir(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Fr(e,t,n){var r=n||{},i=r.number,a="$$v";r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var o=Pr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+o+"}"}}function Pr(e,t){var n=function(e){if(e=e.trim(),hr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<hr-1)return(gr=e.lastIndexOf("."))>-1?{exp:e.slice(0,gr),key:'"'+e.slice(gr+1)+'"'}:{exp:e,key:null};mr=e,gr=_r=br=0;for(;!Hr();)Br(yr=Rr())?zr(yr):91===yr&&Ur(yr);return{exp:e.slice(0,_r),key:e.slice(_r+1,br)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Rr(){return mr.charCodeAt(++gr)}function Hr(){return gr>=hr}function Br(e){return 34===e||39===e}function Ur(e){var t=1;for(_r=gr;!Hr();)if(Br(e=Rr()))zr(e);else if(91===e&&t++,93===e&&t--,0===t){br=gr;break}}function zr(e){for(var t=e;!Hr()&&(e=Rr())!==t;);}var Vr,Kr="__r",qr="__c";function Jr(e,t,n){var r=Vr;return function i(){null!==t.apply(null,arguments)&&Gr(e,i,n,r)}}var Wr=Ve&&!(X&&Number(X[1])<=53);function Zr(e,t,n,r){if(Wr){var i=on,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Vr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Gr(e,t,n,r){(r||Vr).removeEventListener(e,t._wrapper||t,n)}function Xr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Vr=r.elm,function(e){if(n(e[Kr])){var t=q?"change":"input";e[t]=[].concat(e[Kr],e[t]||[]),delete e[Kr]}n(e[qr])&&(e.change=[].concat(e[qr],e.change||[]),delete e[qr])}(i),rt(i,a,Zr,Gr,Jr,r.context),Vr=void 0}}var Yr,Qr={create:Xr,update:Xr};function ei(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ti(o,l)&&(o.value=l)}else if("innerHTML"===i&&qn(o.tagName)&&t(o.innerHTML)){(Yr=Yr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Yr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ti(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ni={create:ei,update:ei},ri=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function ii(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ri(e):e}var oi,si=/^--/,ci=/\s*!important$/,li=function(e,t,n){if(si.test(t))e.style.setProperty(t,n);else if(ci.test(n))e.style.setProperty(C(t),n.replace(ci,""),"important");else{var r=fi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},ui=["Webkit","Moz","ms"],fi=g(function(e){if(oi=oi||document.createElement("div").style,"filter"!==(e=b(e))&&e in oi)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<ui.length;n++){var r=ui[n]+t;if(r in oi)return r}});function pi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ii(i.data))&&A(r,n);(n=ii(e.data))&&A(r,n);for(var a=e;a=a.parent;)a.data&&(n=ii(a.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(o=d[s])!==f[s]&&li(c,s,null==o?"":o)}}var di={create:pi,update:pi},vi=/\s+/;function hi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,mi(e.name||"v")),A(t,e),t}return"string"==typeof e?mi(e):void 0}}var mi=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),yi="transition",gi="animation",_i="transition",bi="transitionend",$i="animation",wi="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_i="WebkitTransition",bi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($i="WebkitAnimation",wi="webkitAnimationEnd"));var Ci=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function xi(e){Ci(function(){Ci(e)})}function ki(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Oi(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[_i+"Delay"]||"").split(", "),a=(r[_i+"Duration"]||"").split(", "),o=Ti(i,a),s=(r[$i+"Delay"]||"").split(", "),c=(r[$i+"Duration"]||"").split(", "),l=Ti(s,c),u=0,f=0;t===yi?o>0&&(n=yi,u=o,f=a.length):t===gi?l>0&&(n=gi,u=l,f=c.length):(u=Math.max(o,l),f=(n=u>0?o>l?yi:gi:null)?n===yi?a.length:c.length:0);var p=n===yi&&Si.test(r[_i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===yi?bi:wi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var Si=/\b(transform|all)(,|$)/;function Ti(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Ni(t)+Ni(e[n])}))}function Ni(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ei(e){return"number"==typeof e&&!isNaN(e)}function Li(e){if(t(e))return!1;var r=e.fns;return n(r)?Li(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ji(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=hi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Li(L),R=i._enterCb=j(function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ki(i,S),ki(i,T),xi(function(){Ai(i,S),R.cancelled||(ki(i,N),P||(Ei(I)?setTimeout(R,I):Oi(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Di=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<er.length;++a)for(s[er[a]]=[],o=0;o<c.length;++o)n(c[o][er[a]])&&s[er[a]].push(c[o][er[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=he(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){for(var a,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,n(a=o.data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](Qn,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(Yn(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](Qn,e);n(a=e.data.hook)&&(n(a.create)&&a.create(Qn,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&tr(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:tr(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):tr(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):tr(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):tr(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=nr(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):tr(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&tr(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Qn,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else Yn(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Gn,modules:[dr,$r,Qr,ni,di,U?{create:ji,activate:ji,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=hi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Li(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ki(i,l),ki(i,p),xi(function(){Ai(i,l),w.cancelled||(ki(i,u),b||(Ei($)?setTimeout(w,$):Oi(i,c,w)))})),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(lr)});J&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Ui(e,"input")});var Mi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Mi.componentUpdated(e,t,n)}):Ii(e,t,n.context),e._vOptions=[].map.call(e.options,Ri)):("textarea"===n.tag||Zn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Hi),e.addEventListener("compositionend",Bi),e.addEventListener("change",Bi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ii(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ri);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return Pi(e,i)}):t.value!==t.oldValue&&Pi(t.value,i))&&Ui(e,"change")}}};function Ii(e,t,n){Fi(e,t),(q||W)&&setTimeout(function(){Fi(e,t)},0)}function Fi(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Ri(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Ri(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Pi(e,t){return t.every(function(t){return!E(t,e)})}function Ri(e){return"_value"in e?e._value:e.value}function Hi(e){e.target.composing=!0}function Bi(e){e.target.composing&&(e.target.composing=!1,Ui(e.target,"input"))}function Ui(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var zi=/\s+/;function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ki(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function qi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,Ji(e.name||"v")),A(t,e),t}return"string"==typeof e?Ji(e):void 0}}var Ji=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Wi=U&&!J,Zi="transition",Gi="animation",Xi="transition",Yi="transitionend",Qi="animation",ea="animationend";Wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xi="WebkitTransition",Yi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Qi="WebkitAnimation",ea="webkitAnimationEnd"));var ta=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function na(e){ta(function(){ta(e)})}function ra(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),Vi(e,t))}function ia(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ki(e,t)}function aa(e,t,n){var r=sa(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Zi?Yi:ea,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var oa=/\b(transform|all)(,|$)/;function sa(e,t){var n,r=window.getComputedStyle(e),i=(r[Xi+"Delay"]||"").split(", "),a=(r[Xi+"Duration"]||"").split(", "),o=ca(i,a),s=(r[Qi+"Delay"]||"").split(", "),c=(r[Qi+"Duration"]||"").split(", "),l=ca(s,c),u=0,f=0;return t===Zi?o>0&&(n=Zi,u=o,f=a.length):t===Gi?l>0&&(n=Gi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Zi:Gi:null)?n===Zi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Zi&&oa.test(r[Xi+"Property"])}}function ca(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return la(t)+la(e[n])}))}function la(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ua(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=qi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=pa(L),R=i._enterCb=j(function(){F&&(ia(i,N),ia(i,T)),R.cancelled?(F&&ia(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ra(i,S),ra(i,T),na(function(){ia(i,S),R.cancelled||(ra(i,N),P||(fa(I)?setTimeout(R,I):aa(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function fa(e){return"number"==typeof e&&!isNaN(e)}function pa(e){if(t(e))return!1;var r=e.fns;return n(r)?pa(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}var va={model:Mi,show:{bind:function(e,t,n){var r=t.value,i=(n=da(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,ua(n,function(){e.style.display=a})):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=da(i)).data&&i.data.transition?(i.data.show=!0,o?ua(i,function(){e.style.display=e.__vOriginalDisplay}):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=qi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=pa(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ia(i,u),ia(i,p)),w.cancelled?(_&&ia(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ra(i,l),ra(i,p),na(function(){ia(i,l),w.cancelled||(ra(i,u),b||(fa($)?setTimeout(w,$):aa(i,c,w)))})),v&&v(i,w),_||b||w())}}(i,function(){e.style.display="none"})):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ha={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ma(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ma(zt(t.children)):e}function ya(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ga(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var _a=function(e){return e.tag||Ut(e)},ba=function(e){return"show"===e.name},$a={name:"transition",props:ha,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(_a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ma(a);if(!o)return a;if(this._leaving)return ga(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=ya(this),l=this._vnode,u=ma(l);if(o.data.directives&&o.data.directives.some(ba)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Ut(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ga(e,a);if("in-out"===r){if(Ut(o))return l;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return a}}},wa=A({tag:String,moveClass:String},ha);function Ca(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function xa(e){e.data.newPos=e.elm.getBoundingClientRect()}function ka(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete wa.mode;var Aa={Transition:$a,TransitionGroup:{props:wa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=ya(this),s=0;s<i.length;s++){(u=i[s]).tag&&null!=u.key&&0!==String(u.key).indexOf("__vlist")&&(a.push(u),n[u.key]=u,(u.data||(u.data={})).transition=o)}if(r){var c=[],l=[];for(s=0;s<r.length;s++){var u;(u=r[s]).data.transition=o,u.data.pos=u.elm.getBoundingClientRect(),n[u.key]?c.push(u):l.push(u)}this.kept=e(t,null,c),this.removed=l}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Ca),e.forEach(xa),e.forEach(ka),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;ra(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Yi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Yi,e),n._moveCb=null,ia(n,t))})}}))},methods:{hasMove:function(e,t){if(!Wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Ki(n,e)}),Vi(n,t),n.style.display="none",this.$el.appendChild(n);var r=sa(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},wn.config.isReservedTag=Jn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=function(e){return qn(e)?"svg":"math"===e?"math":void 0},wn.config.isUnknownElement=function(e){if(!U)return!0;if(Jn(e))return!1;if(e=e.toLowerCase(),null!=Wn[e])return Wn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Wn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Wn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,va),A(wn.options.components,Aa),wn.prototype.__patch__=U?Di:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var Oa=p("input,textarea,option,select,progress"),Sa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ta=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Na(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Ea=/\{\{((?:.|\r?\n)+?)\}\}/g,La=/[-.*+?^${}()|[\]\/\\]/g,ja=g(function(e){var t=e[0].replace(La,"\\$&"),n=e[1].replace(La,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var Da={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Dr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=jr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Ma,Ia={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Dr(e,"style");n&&(e.staticStyle=JSON.stringify(ri(n)));var r=jr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Fa=function(e){return(Ma=Ma||document.createElement("div")).innerHTML=e,Ma.textContent},Pa=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ra=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ha=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ba="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ua="((?:"+Ba+"\\:)?"+Ba+")",za=new RegExp("^<"+Ua),Va=/^\s*(\/?)>/,Ka=new RegExp("^<\\/"+Ua+"[^>]*>"),qa=/^<!DOCTYPE [^>]+>/i,Ja=/^<!\--/,Wa=/^<!\[/,Za=p("script,style,textarea",!0),Ga={},Xa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ya=/&(?:lt|gt|quot|amp|#39);/g,Qa=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,eo=p("pre,textarea",!0),to=function(e,t){return e&&eo(e)&&"\n"===t[0]};function no(e,t){var n=t?Qa:Ya;return e.replace(n,function(e){return Xa[e]})}function ro(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,l=function(){if(n=e,r&&Za(r)){var l=0,p=r.toLowerCase(),d=Ga[p]||(Ga[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return l=r.length,Za(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),to(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-l,c)}else{var v=e.indexOf("<");if(0===v){if(Ja.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),u(h+3),"continue"}if(Wa.test(e)){var m=e.indexOf("]>");if(m>=0)return u(m+2),"continue"}var y=e.match(qa);if(y)return u(y[0].length),"continue";var g=e.match(Ka);if(g){var _=c;return u(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(za);if(t){var n={tagName:t[1],attrs:[],start:c};u(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Va))&&(i=e.match(Ha)||e.match(Ra));)i.start=c,u(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],u(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Pa(n)&&f(r),s(n)&&r===n&&f(n));for(var l=o(n)||!!c,u=e.attrs.length,p=new Array(u),d=0;d<u;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:no(h,m)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,l,e.start,e.end)}(b),to(b.tagName,e)&&u(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Ka.test(w)||za.test(w)||Ja.test(w)||Wa.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&u($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===l())break}function u(t){c+=t,e=e.substring(t)}function f(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}f()}var io,ao,oo,so,co,lo,uo,fo,po=/^@|^v-on:/,vo=/^v-|^@|^:|^#/,ho=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,mo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,yo=/^\(|\)$/g,go=/^\[.*\]$/,_o=/:(.*)$/,bo=/^:|^\.|^v-bind:/,$o=/\.[^.\]]+(?=[^\]]*$)/g,wo=/^v-slot(:|$)|^#/,Co=/[\r\n]/,xo=/[ \f\t\r\n]+/g,ko=g(Fa),Ao="_empty_";function Oo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Do(t),rawAttrsMap:{},parent:n,children:[]}}function So(e,t){io=t.warn||kr,lo=t.isPreTag||T,uo=t.mustUseProp||T,fo=t.getTagNamespace||T,t.isReservedTag,oo=Ar(t.modules,"transformNode"),so=Ar(t.modules,"preTransformNode"),co=Ar(t.modules,"postTransformNode"),ao=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=To(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Eo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Eo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter(function(e){return!e.slotScope}),u(e),e.pre&&(s=!1),lo(e.tag)&&(c=!1);for(var f=0;f<co.length;f++)co[f](e,t)}function u(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return ro(e,{warn:io,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||fo(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Mo.test(r.name)||(r.name=r.name.replace(Io,""),t.push(r))}return t}(a));var d,v=Oo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<so.length;h++)v=so[h](v,t)||v;s||(!function(e){null!=Dr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),lo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(No(v),function(e){var t=Dr(e,"v-if");if(t)e.if=t,Eo(e,{exp:t,block:e});else{null!=Dr(e,"v-else")&&(e.else=!0);var n=Dr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Dr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):l.length?o?"condense"===o&&Co.test(e)?"":" ":a?" ":"":""){c||"condense"!==o||(e=e.replace(xo," "));var u=void 0,f=void 0;!s&&" "!==e&&(u=function(e,t){var n=t?ja(t):Ea;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Cr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,ao))?f={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&l.length&&" "===l[l.length-1].text||(f={type:3,text:e}),f&&l.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function To(e,t){var n,r;(r=jr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dr(e,"scope"),e.slotScope=t||Dr(e,"slot-scope")):(t=Dr(e,"slot-scope"))&&(e.slotScope=t);var n=jr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Sr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Mr(e,wo);if(r){var i=Lo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Ao}}else{var r=Mr(e,wo);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=Lo(r),l=c.name,o=c.dynamic,u=s[l]=Oo("template",[],e);u.slotTarget=l,u.slotTargetDynamic=o,u.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=u,!0}),u.slotScope=r.value||Ao,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jr(e,"name"))}(e),function(e){var t;(t=jr(e,"is"))&&(e.component=t);null!=Dr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<oo.length;i++)e=oo[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,vo.test(r))if(e.hasBindings=!0,(o=jo(r.replace(vo,"")))&&(r=r.replace($o,"")),bo.test(r))r=r.replace(bo,""),a=Cr(a),(c=go.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Pr(a,"$event"),c?Lr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Lr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Lr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&uo(e.tag,e.attrsMap.type,r)?Or(e,r,a,l[t],c):Sr(e,r,a,l[t],c);else if(po.test(r))r=r.replace(po,""),(c=go.test(r))&&(r=r.slice(1,-1)),Lr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(vo,"")).match(_o),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),go.test(f)&&(f=f.slice(1,-1),c=!0)),Nr(e,r,i,a,f,c,o,l[t])}else Sr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&uo(e.tag,e.attrsMap.type,r)&&Or(e,r,"true",l[t])}(e),e}function No(e){var t;if(t=Dr(e,"v-for")){var n=function(e){var t=e.match(ho);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(yo,""),i=r.match(mo);i?(n.alias=r.replace(mo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function Eo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Lo(e){var t=e.name.replace(wo,"");return t||"#"!==e.name[0]&&(t="default"),go.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function jo(e){var t=e.match($o);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function Do(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Mo=/^xmlns:NS\d+/,Io=/^NS\d+:/;function Fo(e){return Oo(e.tag,e.attrsList.slice(),e.parent)}var Po=[Da,Ia,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=jr(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Dr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Dr(e,"v-else",!0),s=Dr(e,"v-else-if",!0),c=Fo(e);No(c),Tr(c,"type","checkbox"),To(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+a,Eo(c,{exp:c.if,block:c});var l=Fo(e);Dr(l,"v-for",!0),Tr(l,"type","radio"),To(l,t),Eo(c,{exp:"("+r+")==='radio'"+a,block:l});var u=Fo(e);return Dr(u,"v-for",!0),Tr(u,":type",r),To(u,t),Eo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}],Ro="__r";var Ho,Bo,Uo={expectHTML:!0,modules:Po,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Fr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Pr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null",a=jr(e,"true-value")||"true",o=jr(e,"false-value")||"false";Or(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Lr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pr(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null";Or(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Lr(e,"change",Pr(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?Ro:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),o&&(u="_n("+u+")");var f=Pr(t,u);c&&(f="if($event.target.composing)return;"+f),Or(e,"value","("+t+")"),Lr(e,l,f,null,!0),(s||o)&&Lr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Fr(e,r,i),!1;return!0},text:function(e,t){t.value&&Or(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Or(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Oa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Sa(e)||Ta(e)},getTagNamespace:function(e){return Ta(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Po)},zo=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(t);if(1===t.type){if(!Bo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var a=t.ifConditions[n].block;e(a),a.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Ko=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,qo=/\([^)]*?\);*$/,Jo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Go=function(e){return"if("+e+")return null;"},Xo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Go("$event.target !== $event.currentTarget"),ctrl:Go("!$event.ctrlKey"),shift:Go("!$event.shiftKey"),alt:Go("!$event.altKey"),meta:Go("!$event.metaKey"),left:Go("'button' in $event && $event.button !== 0"),middle:Go("'button' in $event && $event.button !== 1"),right:Go("'button' in $event && $event.button !== 2")};function Yo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Qo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Qo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Qo(e)}).join(",")+"]";var t=Jo.test(e.value),n=Ko.test(e.value),r=Jo.test(e.value.replace(qo,""));if(e.modifiers){var i="",a="",o=[],s=function(t){if(Xo[t])a+=Xo[t],Wo[t]&&o.push(t);else if("exact"===t){var n=e.modifiers;a+=Go(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else o.push(t)};for(var c in e.modifiers)s(c);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(es).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function es(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Wo[e],r=Zo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ts={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},ns=function(){return function(e){this.options=e,this.warn=e.warn||kr,this.transforms=Ar(e.modules,"transformCode"),this.dataGenFns=Ar(e.modules,"genData"),this.directives=A(A({},ts),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function rs(e,t){var n=new ns(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":is(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function is(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return as(e,t);if(e.once&&!e.onceProcessed)return os(e,t);if(e.for&&!e.forProcessed)return cs(e,t);if(e.if&&!e.ifProcessed)return ss(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ps(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?hs((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ps(t,n,!0);return"_c("+e+","+ls(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ls(e,t));var i=e.inlineTemplate?null:ps(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ps(e,t)||"void 0"}function as(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+is(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function os(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ss(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+is(e,t)+","+t.onceId+++","+n+")":is(e,t)}return as(e,t)}function ss(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var a=t.shift();return a.exp?"("+a.exp+")?"+o(a.block)+":"+e(t,n,r,i):""+o(a.block);function o(e){return r?r(e,n):e.once?os(e,n):is(e,n)}}(e.ifConditions.slice(),t,n,r)}function cs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||is)(e,t)+"})"}function ls(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+hs(e.attrs)+","),e.props&&(n+="domProps:"+hs(e.props)+","),e.events&&(n+=Yo(e.events,!1)+","),e.nativeEvents&&(n+=Yo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||us(n)}),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Ao||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map(function(e){return fs(t[e],n)}).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=rs(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+hs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function us(e){return 1===e.type&&("slot"===e.tag||e.children.some(us))}function fs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ss(e,t,fs,"null");if(e.for&&!e.forProcessed)return cs(e,t,fs);var r=e.slotScope===Ao?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ps(e,t)||"undefined")+":undefined":ps(e,t)||"undefined":is(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ps(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||is)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ds(i)||i.ifConditions&&i.ifConditions.some(function(e){return ds(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||vs;return"["+a.map(function(e){return l(e,t)}).join(",")+"]"+(c?","+c:"")}}function ds(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function vs(e,t){return 1===e.type?is(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:ms(JSON.stringify(n.text)))+")";var n,r}function hs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ms(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ms(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ys(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function gs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=ys(o.render,c),s.staticRenderFns=o.staticRenderFns.map(function(e){return ys(e,c)}),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var _s,bs,$s=(_s=function(e,t){var n=So(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=rs(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=_s(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:gs(t)}})(Uo).compileToFunctions;function ws(e){return(bs=bs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',bs.innerHTML.indexOf("&#10;")>0}var Cs=!!U&&ws(!1),xs=!!U&&ws(!0),ks=g(function(e){var t=Na(e);return t&&t.innerHTML}),As=wn.prototype.$mount;return wn.prototype.$mount=function(e,t){if((e=e&&Na(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ks(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=$s(r,{outputSourceRange:!1,shouldDecodeNewlines:Cs,shouldDecodeNewlinesForHref:xs,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return As.call(this,e,t)},wn.compile=$s,wn});
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index 594abc137b7..340cf3e33de 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -6343,12 +6343,12 @@ var style = {
     update: updateStyle,
 };
 
-var whitespaceRE = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass(el, cls) {
+function addClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6356,7 +6356,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6373,7 +6373,7 @@ function addClass(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass(el, cls) {
+function removeClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6381,7 +6381,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6406,7 +6406,7 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def) {
+function resolveTransition$1(def) {
     if (!def) {
         return;
     }
@@ -6414,16 +6414,16 @@ function resolveTransition(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
+            extend(res, autoCssTransition$1(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition(def);
+        return autoCssTransition$1(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+var autoCssTransition$1 = cached(function (name) {
     return {
         enterClass: name + "-enter",
         enterToClass: name + "-enter-to",
@@ -6433,59 +6433,59 @@ var autoCssTransition = cached(function (name) {
         leaveActiveClass: name + "-leave-active",
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+var hasTransition$1 = inBrowser && !isIE9;
+var TRANSITION$1 = 'transition';
+var ANIMATION$1 = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
+var transitionProp$1 = 'transition';
+var transitionEndEvent$1 = 'transitionend';
+var animationProp$1 = 'animation';
+var animationEndEvent$1 = 'animationend';
+if (hasTransition$1) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
+        transitionProp$1 = 'WebkitTransition';
+        transitionEndEvent$1 = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
+        animationProp$1 = 'WebkitAnimation';
+        animationEndEvent$1 = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+var raf$1 = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
+function nextFrame$1(fn) {
+    raf$1(function () {
         // @ts-expect-error
-        raf(fn);
+        raf$1(fn);
     });
 }
-function addTransitionClass(el, cls) {
+function addTransitionClass$1(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass(el, cls);
+        addClass$1(el, cls);
     }
 }
-function removeTransitionClass(el, cls) {
+function removeTransitionClass$1(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass(el, cls);
+    removeClass$1(el, cls);
 }
-function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+function whenTransitionEnds$1(el, expectedType, cb) {
+    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -6505,30 +6505,30 @@ function whenTransitionEnds(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
+var transformRE$1 = /\b(transform|all)(,|$)/;
+function getTransitionInfo$1(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
+    if (expectedType === TRANSITION$1) {
         if (transitionTimeout > 0) {
-            type = TRANSITION;
+            type = TRANSITION$1;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION) {
+    else if (expectedType === ANIMATION$1) {
         if (animationTimeout > 0) {
-            type = ANIMATION;
+            type = ANIMATION$1;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6538,16 +6538,16 @@ function getTransitionInfo(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
+                    ? TRANSITION$1
+                    : ANIMATION$1
                 : null;
         propCount = type
-            ? type === TRANSITION
+            ? type === TRANSITION$1
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -6555,31 +6555,31 @@ function getTransitionInfo(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout(delays, durations) {
+function getTimeout$1(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
+        return toMs$1(d) + toMs$1(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs(s) {
+function toMs$1(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
+function enter$1(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -6617,19 +6617,19 @@ function enter(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
+        checkDuration$1(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
+    var userWantsControl = getHookArgumentsLength$1(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
+            removeTransitionClass$1(el, toClass);
+            removeTransitionClass$1(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, startClass);
+                removeTransitionClass$1(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -6654,19 +6654,19 @@ function enter(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
+        addTransitionClass$1(el, startClass);
+        addTransitionClass$1(el, activeClass);
+        nextFrame$1(function () {
+            removeTransitionClass$1(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
+                addTransitionClass$1(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
+                    if (isValidDuration$1(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds(el, type, cb);
+                        whenTransitionEnds$1(el, type, cb);
                     }
                 }
             }
@@ -6680,14 +6680,14 @@ function enter(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave(vnode, rm) {
+function leave$1(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -6697,23 +6697,23 @@ function leave(vnode, rm) {
     }
     var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
+    var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
+        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
+            removeTransitionClass$1(el, leaveToClass);
+            removeTransitionClass$1(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
+                removeTransitionClass$1(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -6741,19 +6741,19 @@ function leave(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
+            addTransitionClass$1(el, leaveClass);
+            addTransitionClass$1(el, leaveActiveClass);
+            nextFrame$1(function () {
+                removeTransitionClass$1(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
+                    addTransitionClass$1(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
+                        if (isValidDuration$1(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds(el, type, cb);
+                            whenTransitionEnds$1(el, type, cb);
                         }
                     }
                 }
@@ -6766,7 +6766,7 @@ function leave(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration(val, name, vnode) {
+function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
             ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -6776,7 +6776,7 @@ function checkDuration(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration(val) {
+function isValidDuration$1(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -6785,7 +6785,7 @@ function isValidDuration(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength(fn) {
+function getHookArgumentsLength$1(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -6793,7 +6793,7 @@ function getHookArgumentsLength(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -6802,7 +6802,7 @@ function getHookArgumentsLength(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter(vnode);
+        enter$1(vnode);
     }
 }
 var transition = inBrowser
@@ -6813,7 +6813,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave(vnode, rm);
+                leave$1(vnode, rm);
             }
             else {
                 rm();
@@ -6961,6 +6961,464 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
+var whitespaceRE = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
+}
+
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+var autoCssTransition = cached(function (name) {
+    return {
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
+    };
+});
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
+// Transition property/event sniffing
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+var raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
index 0adec3a8753..8d2d1d13836 100644
--- a/dist/vue.runtime.common.prod.js
+++ b/dist/vue.runtime.common.prod.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function dt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function wt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var At=L.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):$t(t,n,o));return t}function Ot(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function kt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}At.data=function(t,e,n){return n?Ot(t,e,n):e&&"function"!=typeof e?t:Ot(t,e)},P.forEach(function(t){At[t]=kt}),N.forEach(function(t){At[t+"s"]=St}),At.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},At.props=At.methods=At.inject=At.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},At.provide=Ot;var Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=jt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=At[r]||Et;a[r]=o(t[r],e[r],n,r)}return a}function Tt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Lt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Lt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Bt,Ht=!1,Vt=[],zt=!1;function Wt(){zt=!1;var t=Vt.slice(0);Vt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Bt=function(){qt.then(Wt),K&&setTimeout(k)},Ht=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Bt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Ht=!0}function Zt(t,e){var n;if(Vt.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[pt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=pt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=pt(f.text+u):""!==u&&s.push(pt(u)):ie(u)&&ie(f)?s[l]=pt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function pe(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function de(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return Tt(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?he(o,r):i?he(i,t):r?$(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?we(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ae(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=l,t._l=pe,t._t=de,t._q=j,t._i=T,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=pt,t._e=ft,t._u=we,t._g=$e,t._d=Ae,t._p=xe}function ke(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Le(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Le(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=dt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ee(t,e){for(var n in e)t[_(n)]=e[n]}Oe(ke.prototype);var je={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;je.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=It(d,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},Te=Object.keys(je);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I(function(e){t.resolved=Re(e,o),c?s.length=0:p(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,p(!0))}),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Ee(c,o.attrs),n(o.props)&&Ee(c,o.props);var f=new ke(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Se(p,o,f.parent,s);if(Array.isArray(p)){for(var d=oe(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Se(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Te.length;n++){var r=Te[n],o=e[r],i=je[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Pe=2;function Le(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Pe),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Pe?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=Tt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Be(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function He(t,e){Me.$on(t,e)}function Ve(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},He,Ve,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:k,set:k};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function pn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||k,k,dn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var dn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=k):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):k,ln.set=n.set||k),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=jt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=jt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function $n(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function An(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=$n(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Le(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Le(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),pn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=wt,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var On=[String,RegExp,Array],kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:On,exclude:On,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){An(t,function(t){return wn(e,t)})}),this.$watch("exclude",function(e){An(t,function(t){return!wn(e,t)})})},render:function(){var t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){var r=$n(n),o=this.include,i=this.exclude;if(o&&(!r||!wn(o,r))||i&&r&&wn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:jt,defineReactive:Ct},t.set=$t,t.delete=wt,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,kn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:ke}),bn.version="2.6.12";var Sn=p("style,class"),En=p("input,textarea,option,select,progress"),jn=p("contenteditable,draggable,spellcheck"),Tn=p("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true"},Dn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Pn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Ln=function(t){return Pn(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Bn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Bn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Vn(t)||zn(t)};var qn=Object.create(null);var Kn=p("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=Tt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Pn(i)?s.removeAttributeNS(Nn,Ln(i)):jn(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):jn(e)?t.setAttribute(e,In(e,n)):Pn(e)?Mn(n)?t.removeAttributeNS(Nn,Ln(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function pr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Bn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var dr,vr={create:pr,update:pr},hr="__r",mr="__c";function yr(t,e,n){var r=dr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Ht&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}dr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||dr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};dr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),dr=void 0}}var $r,wr={create:Cr,update:Cr};function Ar(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:Ar,update:Ar},kr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?O(t):"string"==typeof t?kr(t):t}var jr,Tr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(Tr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty($(e),n.replace(Ir,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Pr=y(function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in jr)return r}});function Lr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=Er(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Dr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Lr,update:Lr},Fr=/\s+/;function Rr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Br(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Hr(t.name||"v")),x(e,t),e}return"string"==typeof t?Hr(t):void 0}}var Hr=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Vr=U&&!W,zr="transition",Wr="animation",qr="transition",Kr="transitionend",Xr="animation",Gr="animationend";Vr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(qr="WebkitTransition",Kr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Xr="WebkitAnimation",Gr="webkitAnimationEnd"));var Zr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Jr(t){Zr(function(){Zr(t)})}function Qr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Rr(t,e))}function Yr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Ur(t,e)}function to(t,e,n){var r=no(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===zr?Kr:Gr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var eo=/\b(transform|all)(,|$)/;function no(t,e){var n,r=window.getComputedStyle(t),o=(r[qr+"Delay"]||"").split(", "),i=(r[qr+"Duration"]||"").split(", "),a=ro(o,i),s=(r[Xr+"Delay"]||"").split(", "),c=(r[Xr+"Duration"]||"").split(", "),u=ro(s,c),l=0,f=0;return e===zr?a>0&&(n=zr,l=a,f=i.length):e===Wr?u>0&&(n=Wr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?zr:Wr:null)?n===zr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===zr&&eo.test(r[qr+"Property"])}}function ro(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return oo(e)+oo(t[n])}))}function oo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function io(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Br(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=qe,O=qe.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!W,F=co(D),R=o._enterCb=I(function(){M&&(Yr(o,j),Yr(o,E)),R.cancelled?(M&&Yr(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Qr(o,S),Qr(o,E),Jr(function(){Yr(o,S),R.cancelled||(Qr(o,j),F||(so(L)?setTimeout(R,L):to(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function ao(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Br(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=co(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Yr(o,l),Yr(o,p)),$.cancelled?(_&&Yr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Qr(o,u),Qr(o,p),Jr(function(){Yr(o,u),$.cancelled||(Qr(o,l),b||(so(C)?setTimeout($,C):to(o,c,$)))})),v&&v(o,$),_||b||$())}}function so(t){return"number"==typeof t&&!isNaN(t)}function co(t){if(e(t))return!1;var r=t.fns;return n(r)?co(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function uo(t,e){!0!==e.data.show&&io(e)}var lo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=dt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=dt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:Yn(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):Yn(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):Yn(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=tr(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):Yn(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&Yn(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Jn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,wr,Or,Mr,U?{create:uo,activate:uo,remove:function(t,e){!0!==t.data.show?ao(t,e):e()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&_o(t,"input")});var fo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){fo.componentUpdated(t,e,n)}):po(t,e,n.context),t._vOptions=[].map.call(t.options,mo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",yo),t.addEventListener("compositionend",go),t.addEventListener("change",go),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){po(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,mo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return ho(t,o)}):e.value!==e.oldValue&&ho(e.value,o))&&_o(t,"change")}}};function po(t,e,n){vo(t,e),(z||q)&&setTimeout(function(){vo(t,e)},0)}function vo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,mo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(mo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function ho(t,e){return e.every(function(e){return!j(e,t)})}function mo(t){return"_value"in t?t._value:t.value}function yo(t){t.target.composing=!0}function go(t){t.target.composing&&(t.target.composing=!1,_o(t.target,"input"))}function _o(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function bo(t){return!t.componentInstance||t.data&&t.data.transition?t:bo(t.componentInstance._vnode)}var Co={model:fo,show:{bind:function(t,e,n){var r=e.value,o=(n=bo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,io(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=bo(n)).data&&n.data.transition?(n.data.show=!0,r?io(n,function(){t.style.display=t.__vOriginalDisplay}):ao(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},$o={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function wo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?wo(Be(e.children)):t}function Ao(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function xo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Oo=function(t){return t.tag||Ue(t)},ko=function(t){return"show"===t.name},So={name:"transition",props:$o,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Oo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=wo(i);if(!a)return i;if(this._leaving)return xo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ao(this),u=this._vnode,l=wo(u);if(a.data.directives&&a.data.directives.some(ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),xo(t,i);if("in-out"===r){if(Ue(a))return u;var p,d=function(){p()};ne(c,"afterEnter",d),ne(c,"enterCancelled",d),ne(f,"delayLeave",function(t){p=t})}}return i}}},Eo=x({tag:String,moveClass:String},$o);function jo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function To(t){t.data.newPos=t.elm.getBoundingClientRect()}function Io(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Eo.mode;var Do={Transition:So,TransitionGroup:{props:Eo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ao(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(jo),t.forEach(To),t.forEach(Io),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Qr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Kr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Kr,t),n._moveCb=null,Yr(n,e))})}}))},methods:{hasMove:function(t,e){if(!Vr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Ur(n,t)}),Rr(n,e),n.style.display="none",this.$el.appendChild(n);var r=no(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};bn.config.mustUseProp=function(t,e,n){return"value"===n&&En(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Co),x(bn.options.components,Do),bn.prototype.__patch__=U?lo:k,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",bn)},0),module.exports=bn;
\ No newline at end of file
+"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,w=y(function(t){return t.replace(C,"-$1").toLowerCase()});var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return E(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return E(t[n],e[n])})}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:L};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=O,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function pt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var $t=P.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Ot(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}$t.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},L.forEach(function(t){$t[t]=Ot}),N.forEach(function(t){$t[t+"s"]=St}),$t.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},$t.props=$t.methods=$t.inject=$t.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},$t.provide=kt;var Tt=function(t,e){return void 0===e?t:e};function Et(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Et(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Et(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=$t[r]||Tt;a[r]=o(t[r],e[r],n,r)}return a}function jt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Pt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===w(t)){var c=Pt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Lt(t,e){return Nt(t)===Nt(e)}function Pt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Bt,Ht=!1,Vt=[],zt=!1;function Wt(){zt=!1;var t=Vt.slice(0);Vt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Bt=function(){qt.then(Wt),K&&setTimeout(O)},Ht=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Bt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Ht=!0}function Zt(t,e){var n;if(Vt.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return jt(this.$options,"filters",t)||T}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?he(o,r):i?he(i,t):r?w(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=k(n));var a=void 0,s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=w(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function $e(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=E,t._i=j,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=ft,t._u=Ae,t._g=we,t._d=$e,t._p=xe}function Oe(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Pe(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Pe(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=pt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Te(t,e){for(var n in e)t[_(n)]=e[n]}ke(Oe.prototype);var Ee={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ee.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=It(p,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},je=Object.keys(Ee);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=w(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Te(c,o.attrs),n(o.props)&&Te(c,o.props);var f=new Oe(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<je.length;n++){var r=je[n],o=e[r],i=Ee[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Le=2;function Pe(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||P.getTagNamespace(o),u=P.isReservedTag(o)?new lt(P.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=jt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Be(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function He(t,e){Me.$on(t,e)}function Ve(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},He,Ve,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&P.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:O,set:O};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||O,O,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=O):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):O,ln.set=n.set||O),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Et(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Et(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function $n(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Et(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Pe(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Pe(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?$(e):e;for(var n=$(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var kn=[String,RegExp,Array],On={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){$n(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){$n(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Et,defineReactive:Ct},t.set=wt,t.delete=At,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,On),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Et(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:Oe}),bn.version="2.6.12";var Sn=d("style,class"),Tn=d("input,textarea,option,select,progress"),En=d("contenteditable,draggable,spellcheck"),jn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&jn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Pn=function(t){return Ln(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Bn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Bn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Vn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=jt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Nn,Pn(i)):En(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):En(e)?t.setAttribute(e,In(e,n)):Ln(e)?Mn(n)?t.removeAttributeNS(Nn,Pn(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Bn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Ht&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var wr,Ar={create:Cr,update:Cr};function $r(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:$r,update:$r},Or=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Tr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Tr(t){return Array.isArray(t)?k(t):"string"==typeof t?Or(t):t}var Er,jr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(jr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty(w(e),n.replace(Ir,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Lr=y(function(t){if(Er=Er||document.createElement("div").style,"filter"!==(t=_(t))&&t in Er)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in Er)return r}});function Pr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Tr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Pr,update:Pr},Fr=/\s+/;function Rr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Ur(t.name||"v")),x(e,t),e}return"string"==typeof t?Ur(t):void 0}}var Ur=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Br="transition",Hr="animation",Vr="transition",zr="transitionend",Wr="animation",qr="animationend";U&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Vr="WebkitTransition",zr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Wr="WebkitAnimation",qr="webkitAnimationEnd"));var Kr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Xr(t){Kr(function(){Kr(t)})}function Gr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Zr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Jr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),o=(r[Vr+"Delay"]||"").split(", "),i=(r[Vr+"Duration"]||"").split(", "),a=Yr(o,i),s=(r[Wr+"Delay"]||"").split(", "),c=(r[Wr+"Duration"]||"").split(", "),u=Yr(s,c),l=0,f=0;e===Br?a>0&&(n=Br,l=a,f=i.length):e===Hr?u>0&&(n=Hr,l=u,f=c.length):(l=Math.max(a,u),f=(n=l>0?a>u?Br:Hr:null)?n===Br?i.length:c.length:0);var d=n===Br&&Qr.test(r[Vr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Br?zr:qr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var Qr=/\b(transform|all)(,|$)/;function Yr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return to(e)+to(t[n])}))}function to(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function eo(t){return"number"==typeof t&&!isNaN(t)}function no(t){if(e(t))return!1;var r=t.fns;return n(r)?no(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function ro(t,r){!0!==r.data.show&&function(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Rr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=no(D),R=o._enterCb=I(function(){M&&(Zr(o,E),Zr(o,T)),R.cancelled?(M&&Zr(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(Gr(o,S),Gr(o,T),Xr(function(){Zr(o,S),R.cancelled||(Gr(o,E),F||(eo(P)?setTimeout(R,P):Jr(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}(r)}var oo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=pt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function $(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=pt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?O(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?($(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?($(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?($(h,b,i,o,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?($(m,g,i,o,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?($(l,g,i,o,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))$(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&O(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Jn,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,Ar,kr,Mr,U?{create:ro,activate:ro,remove:function(t,r){!0!==t.data.show?function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Rr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=no(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Zr(o,l),Zr(o,d)),w.cancelled?(_&&Zr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Gr(o,u),Gr(o,d),Xr(function(){Zr(o,u),w.cancelled||(Gr(o,l),b||(eo(C)?setTimeout(w,C):Jr(o,c,w)))})),v&&v(o,w),_||b||w())}}(t,r):r()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&po(t,"input")});var io={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){io.componentUpdated(t,e,n)}):ao(t,e,n.context),t._vOptions=[].map.call(t.options,uo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",lo),t.addEventListener("compositionend",fo),t.addEventListener("change",fo),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ao(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,uo);if(o.some(function(t,e){return!E(t,r[e])}))(t.multiple?e.value.some(function(t){return co(t,o)}):e.value!==e.oldValue&&co(e.value,o))&&po(t,"change")}}};function ao(t,e,n){so(t,e),(z||q)&&setTimeout(function(){so(t,e)},0)}function so(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=j(r,uo(a))>-1,a.selected!==i&&(a.selected=i);else if(E(uo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function co(t,e){return e.every(function(e){return!E(e,t)})}function uo(t){return"_value"in t?t._value:t.value}function lo(t){t.target.composing=!0}function fo(t){t.target.composing&&(t.target.composing=!1,po(t.target,"input"))}function po(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var vo=/\s+/;function ho(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function mo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function yo(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,go(t.name||"v")),x(e,t),e}return"string"==typeof t?go(t):void 0}}var go=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),_o=U&&!W,bo="transition",Co="animation",wo="transition",Ao="transitionend",$o="animation",xo="animationend";_o&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(wo="WebkitTransition",Ao="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($o="WebkitAnimation",xo="webkitAnimationEnd"));var ko=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Oo(t){ko(function(){ko(t)})}function So(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),ho(t,e))}function To(t,e){t._transitionClasses&&v(t._transitionClasses,e),mo(t,e)}function Eo(t,e,n){var r=Io(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===bo?Ao:xo,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var jo=/\b(transform|all)(,|$)/;function Io(t,e){var n,r=window.getComputedStyle(t),o=(r[wo+"Delay"]||"").split(", "),i=(r[wo+"Duration"]||"").split(", "),a=Do(o,i),s=(r[$o+"Delay"]||"").split(", "),c=(r[$o+"Duration"]||"").split(", "),u=Do(s,c),l=0,f=0;return e===bo?a>0&&(n=bo,l=a,f=i.length):e===Co?u>0&&(n=Co,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?bo:Co:null)?n===bo?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===bo&&jo.test(r[wo+"Property"])}}function Do(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return No(e)+No(t[n])}))}function No(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Lo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=yo(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=Mo(D),R=o._enterCb=I(function(){M&&(To(o,E),To(o,T)),R.cancelled?(M&&To(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(So(o,S),So(o,T),Oo(function(){To(o,S),R.cancelled||(So(o,E),F||(Po(P)?setTimeout(R,P):Eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function Po(t){return"number"==typeof t&&!isNaN(t)}function Mo(t){if(e(t))return!1;var r=t.fns;return n(r)?Mo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Fo(t){return!t.componentInstance||t.data&&t.data.transition?t:Fo(t.componentInstance._vnode)}var Ro={model:io,show:{bind:function(t,e,n){var r=e.value,o=(n=Fo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,Lo(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,r,o){var a=r.value;!a!=!r.oldValue&&((o=Fo(o)).data&&o.data.transition?(o.data.show=!0,a?Lo(o,function(){t.style.display=t.__vOriginalDisplay}):function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=yo(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Mo(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(To(o,l),To(o,d)),w.cancelled?(_&&To(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(So(o,u),So(o,d),Oo(function(){To(o,u),w.cancelled||(So(o,l),b||(Po(C)?setTimeout(w,C):Eo(o,c,w)))})),v&&v(o,w),_||b||w())}}(o,function(){t.style.display="none"})):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Uo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Bo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Bo(Be(e.children)):t}function Ho(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function Vo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var zo=function(t){return t.tag||Ue(t)},Wo=function(t){return"show"===t.name},qo={name:"transition",props:Uo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(zo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Bo(i);if(!a)return i;if(this._leaving)return Vo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ho(this),u=this._vnode,l=Bo(u);if(a.data.directives&&a.data.directives.some(Wo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Vo(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Ko=x({tag:String,moveClass:String},Uo);function Xo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Go(t){t.data.newPos=t.elm.getBoundingClientRect()}function Zo(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Ko.mode;var Jo={Transition:qo,TransitionGroup:{props:Ko,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ho(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Xo),t.forEach(Go),t.forEach(Zo),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;So(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ao,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ao,t),n._moveCb=null,To(n,e))})}}))},methods:{hasMove:function(t,e){if(!_o)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){mo(n,t)}),ho(n,e),n.style.display="none",this.$el.appendChild(n);var r=Io(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};bn.config.mustUseProp=function(t,e,n){return"value"===n&&Tn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Ro),x(bn.options.components,Jo),bn.prototype.__patch__=U?oo:O,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){P.devtools&&tt&&tt.emit("init",bn)},0),module.exports=bn;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index df8d4545a0c..24897b41f42 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -6377,12 +6377,12 @@ var style = {
     update: updateStyle,
 };
 
-var whitespaceRE = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass(el, cls) {
+function addClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6390,7 +6390,7 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6407,7 +6407,7 @@ function addClass(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass(el, cls) {
+function removeClass$1(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6415,7 +6415,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6440,7 +6440,7 @@ function removeClass(el, cls) {
     }
 }
 
-function resolveTransition(def) {
+function resolveTransition$1(def) {
     if (!def) {
         return;
     }
@@ -6448,16 +6448,16 @@ function resolveTransition(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
+            extend(res, autoCssTransition$1(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition(def);
+        return autoCssTransition$1(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+var autoCssTransition$1 = cached(function (name) {
     return {
         enterClass: name + "-enter",
         enterToClass: name + "-enter-to",
@@ -6467,59 +6467,59 @@ var autoCssTransition = cached(function (name) {
         leaveActiveClass: name + "-leave-active",
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+var hasTransition$1 = inBrowser && !isIE9;
+var TRANSITION$1 = 'transition';
+var ANIMATION$1 = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
+var transitionProp$1 = 'transition';
+var transitionEndEvent$1 = 'transitionend';
+var animationProp$1 = 'animation';
+var animationEndEvent$1 = 'animationend';
+if (hasTransition$1) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
+        transitionProp$1 = 'WebkitTransition';
+        transitionEndEvent$1 = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
+        animationProp$1 = 'WebkitAnimation';
+        animationEndEvent$1 = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+var raf$1 = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
+function nextFrame$1(fn) {
+    raf$1(function () {
         // @ts-expect-error
-        raf(fn);
+        raf$1(fn);
     });
 }
-function addTransitionClass(el, cls) {
+function addTransitionClass$1(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass(el, cls);
+        addClass$1(el, cls);
     }
 }
-function removeTransitionClass(el, cls) {
+function removeTransitionClass$1(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass(el, cls);
+    removeClass$1(el, cls);
 }
-function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+function whenTransitionEnds$1(el, expectedType, cb) {
+    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -6539,30 +6539,30 @@ function whenTransitionEnds(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
+var transformRE$1 = /\b(transform|all)(,|$)/;
+function getTransitionInfo$1(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
+    if (expectedType === TRANSITION$1) {
         if (transitionTimeout > 0) {
-            type = TRANSITION;
+            type = TRANSITION$1;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION) {
+    else if (expectedType === ANIMATION$1) {
         if (animationTimeout > 0) {
-            type = ANIMATION;
+            type = ANIMATION$1;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6572,16 +6572,16 @@ function getTransitionInfo(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
+                    ? TRANSITION$1
+                    : ANIMATION$1
                 : null;
         propCount = type
-            ? type === TRANSITION
+            ? type === TRANSITION$1
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -6589,31 +6589,31 @@ function getTransitionInfo(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout(delays, durations) {
+function getTimeout$1(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
+        return toMs$1(d) + toMs$1(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs(s) {
+function toMs$1(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
+function enter$1(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -6651,19 +6651,19 @@ function enter(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
+        checkDuration$1(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
+    var userWantsControl = getHookArgumentsLength$1(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
+            removeTransitionClass$1(el, toClass);
+            removeTransitionClass$1(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, startClass);
+                removeTransitionClass$1(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -6688,19 +6688,19 @@ function enter(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
+        addTransitionClass$1(el, startClass);
+        addTransitionClass$1(el, activeClass);
+        nextFrame$1(function () {
+            removeTransitionClass$1(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
+                addTransitionClass$1(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
+                    if (isValidDuration$1(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds(el, type, cb);
+                        whenTransitionEnds$1(el, type, cb);
                     }
                 }
             }
@@ -6714,14 +6714,14 @@ function enter(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave(vnode, rm) {
+function leave$1(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    var data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -6731,23 +6731,23 @@ function leave(vnode, rm) {
     }
     var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
+    var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
+        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
+            removeTransitionClass$1(el, leaveToClass);
+            removeTransitionClass$1(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
+                removeTransitionClass$1(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -6775,19 +6775,19 @@ function leave(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
+            addTransitionClass$1(el, leaveClass);
+            addTransitionClass$1(el, leaveActiveClass);
+            nextFrame$1(function () {
+                removeTransitionClass$1(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
+                    addTransitionClass$1(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
+                        if (isValidDuration$1(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds(el, type, cb);
+                            whenTransitionEnds$1(el, type, cb);
                         }
                     }
                 }
@@ -6800,7 +6800,7 @@ function leave(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration(val, name, vnode) {
+function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
             ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -6810,7 +6810,7 @@ function checkDuration(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration(val) {
+function isValidDuration$1(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -6819,7 +6819,7 @@ function isValidDuration(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength(fn) {
+function getHookArgumentsLength$1(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -6827,7 +6827,7 @@ function getHookArgumentsLength(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -6836,7 +6836,7 @@ function getHookArgumentsLength(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter(vnode);
+        enter$1(vnode);
     }
 }
 var transition = inBrowser
@@ -6847,7 +6847,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave(vnode, rm);
+                leave$1(vnode, rm);
             }
             else {
                 rm();
@@ -6996,6 +6996,464 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
+var whitespaceRE = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        var cur = " " + (el.getAttribute('class') || '') + " ";
+        var tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
+}
+
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+var autoCssTransition = cached(function (name) {
+    return {
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
+    };
+});
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
+// Transition property/event sniffing
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        // @ts-expect-error
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        // @ts-expect-error
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+var raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
+function nextFrame(fn) {
+    raf(function () {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    if (!type)
+        { return cb(); }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    var onEnd = function (e) {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(function () {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type: type,
+        timeout: timeout,
+        propCount: propCount,
+        hasTransform: hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+}
+
+function enter(vnode, toggleDisplay) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', function () {
+            var parent = el.parentNode;
+            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn("<transition> explicit " + name + " duration is not a valid number - " +
+            ("got " + JSON.stringify(val) + "."), vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn("<transition> explicit " + name + " duration is NaN - " +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 23b3dac3edd..1f7cb2057c5 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -6347,12 +6347,12 @@
       update: updateStyle,
   };
 
-  var whitespaceRE = /\s+/;
+  var whitespaceRE$1 = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function addClass(el, cls) {
+  function addClass$1(el, cls) {
       /* istanbul ignore if */
       if (!cls || !(cls = cls.trim())) {
           return;
@@ -6360,7 +6360,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
           }
           else {
               el.classList.add(cls);
@@ -6377,7 +6377,7 @@
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function removeClass(el, cls) {
+  function removeClass$1(el, cls) {
       /* istanbul ignore if */
       if (!cls || !(cls = cls.trim())) {
           return;
@@ -6385,7 +6385,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
           }
           else {
               el.classList.remove(cls);
@@ -6410,7 +6410,7 @@
       }
   }
 
-  function resolveTransition(def) {
+  function resolveTransition$1(def) {
       if (!def) {
           return;
       }
@@ -6418,16 +6418,16 @@
       if (typeof def === 'object') {
           var res = {};
           if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
+              extend(res, autoCssTransition$1(def.name || 'v'));
           }
           extend(res, def);
           return res;
       }
       else if (typeof def === 'string') {
-          return autoCssTransition(def);
+          return autoCssTransition$1(def);
       }
   }
-  var autoCssTransition = cached(function (name) {
+  var autoCssTransition$1 = cached(function (name) {
       return {
           enterClass: name + "-enter",
           enterToClass: name + "-enter-to",
@@ -6437,59 +6437,59 @@
           leaveActiveClass: name + "-leave-active",
       };
   });
-  var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = 'transition';
-  var ANIMATION = 'animation';
+  var hasTransition$1 = inBrowser && !isIE9;
+  var TRANSITION$1 = 'transition';
+  var ANIMATION$1 = 'animation';
   // Transition property/event sniffing
-  var transitionProp = 'transition';
-  var transitionEndEvent = 'transitionend';
-  var animationProp = 'animation';
-  var animationEndEvent = 'animationend';
-  if (hasTransition) {
+  var transitionProp$1 = 'transition';
+  var transitionEndEvent$1 = 'transitionend';
+  var animationProp$1 = 'animation';
+  var animationEndEvent$1 = 'animationend';
+  if (hasTransition$1) {
       /* istanbul ignore if */
       if (window.ontransitionend === undefined &&
           // @ts-expect-error
           window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
+          transitionProp$1 = 'WebkitTransition';
+          transitionEndEvent$1 = 'webkitTransitionEnd';
       }
       if (window.onanimationend === undefined &&
           // @ts-expect-error
           window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
+          animationProp$1 = 'WebkitAnimation';
+          animationEndEvent$1 = 'webkitAnimationEnd';
       }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf = inBrowser
+  var raf$1 = inBrowser
       ? window.requestAnimationFrame
           ? window.requestAnimationFrame.bind(window)
           : setTimeout
       : /* istanbul ignore next */ function (fn) { return fn(); };
-  function nextFrame(fn) {
-      raf(function () {
+  function nextFrame$1(fn) {
+      raf$1(function () {
           // @ts-expect-error
-          raf(fn);
+          raf$1(fn);
       });
   }
-  function addTransitionClass(el, cls) {
+  function addTransitionClass$1(el, cls) {
       var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
       if (transitionClasses.indexOf(cls) < 0) {
           transitionClasses.push(cls);
-          addClass(el, cls);
+          addClass$1(el, cls);
       }
   }
-  function removeTransitionClass(el, cls) {
+  function removeTransitionClass$1(el, cls) {
       if (el._transitionClasses) {
           remove$2(el._transitionClasses, cls);
       }
-      removeClass(el, cls);
+      removeClass$1(el, cls);
   }
-  function whenTransitionEnds(el, expectedType, cb) {
-      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+  function whenTransitionEnds$1(el, expectedType, cb) {
+      var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
       if (!type)
           { return cb(); }
-      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
       var ended = 0;
       var end = function () {
           el.removeEventListener(event, onEnd);
@@ -6509,30 +6509,30 @@
       }, timeout + 1);
       el.addEventListener(event, onEnd);
   }
-  var transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
+  var transformRE$1 = /\b(transform|all)(,|$)/;
+  function getTransitionInfo$1(el, expectedType) {
       var styles = window.getComputedStyle(el);
       // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout$1(animationDelays, animationDurations);
       var type;
       var timeout = 0;
       var propCount = 0;
       /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
+      if (expectedType === TRANSITION$1) {
           if (transitionTimeout > 0) {
-              type = TRANSITION;
+              type = TRANSITION$1;
               timeout = transitionTimeout;
               propCount = transitionDurations.length;
           }
       }
-      else if (expectedType === ANIMATION) {
+      else if (expectedType === ANIMATION$1) {
           if (animationTimeout > 0) {
-              type = ANIMATION;
+              type = ANIMATION$1;
               timeout = animationTimeout;
               propCount = animationDurations.length;
           }
@@ -6542,16 +6542,16 @@
           type =
               timeout > 0
                   ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
+                      ? TRANSITION$1
+                      : ANIMATION$1
                   : null;
           propCount = type
-              ? type === TRANSITION
+              ? type === TRANSITION$1
                   ? transitionDurations.length
                   : animationDurations.length
               : 0;
       }
-      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
       return {
           type: type,
           timeout: timeout,
@@ -6559,31 +6559,31 @@
           hasTransform: hasTransform,
       };
   }
-  function getTimeout(delays, durations) {
+  function getTimeout$1(delays, durations) {
       /* istanbul ignore next */
       while (delays.length < durations.length) {
           delays = delays.concat(delays);
       }
       return Math.max.apply(null, durations.map(function (d, i) {
-          return toMs(d) + toMs(delays[i]);
+          return toMs$1(d) + toMs$1(delays[i]);
       }));
   }
   // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
   // in a locale-dependent way, using a comma instead of a dot.
   // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
   // as a floor function) causing unexpected behaviors
-  function toMs(s) {
+  function toMs$1(s) {
       return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  function enter(vnode, toggleDisplay) {
+  function enter$1(vnode, toggleDisplay) {
       var el = vnode.elm;
       // call leave callback now
       if (isDef(el._leaveCb)) {
           el._leaveCb.cancelled = true;
           el._leaveCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      var data = resolveTransition$1(vnode.data.transition);
       if (isUndef(data)) {
           return;
       }
@@ -6621,19 +6621,19 @@
           : enterCancelled;
       var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
       if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
+          checkDuration$1(explicitEnterDuration, 'enter', vnode);
       }
       var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(enterHook);
+      var userWantsControl = getHookArgumentsLength$1(enterHook);
       var cb = (el._enterCb = once(function () {
           if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
+              removeTransitionClass$1(el, toClass);
+              removeTransitionClass$1(el, activeClass);
           }
           // @ts-expect-error
           if (cb.cancelled) {
               if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
+                  removeTransitionClass$1(el, startClass);
               }
               enterCancelledHook && enterCancelledHook(el);
           }
@@ -6658,19 +6658,19 @@
       // start enter transition
       beforeEnterHook && beforeEnterHook(el);
       if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(function () {
-              removeTransitionClass(el, startClass);
+          addTransitionClass$1(el, startClass);
+          addTransitionClass$1(el, activeClass);
+          nextFrame$1(function () {
+              removeTransitionClass$1(el, startClass);
               // @ts-expect-error
               if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
+                  addTransitionClass$1(el, toClass);
                   if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
+                      if (isValidDuration$1(explicitEnterDuration)) {
                           setTimeout(cb, explicitEnterDuration);
                       }
                       else {
-                          whenTransitionEnds(el, type, cb);
+                          whenTransitionEnds$1(el, type, cb);
                       }
                   }
               }
@@ -6684,14 +6684,14 @@
           cb();
       }
   }
-  function leave(vnode, rm) {
+  function leave$1(vnode, rm) {
       var el = vnode.elm;
       // call enter callback now
       if (isDef(el._enterCb)) {
           el._enterCb.cancelled = true;
           el._enterCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      var data = resolveTransition$1(vnode.data.transition);
       if (isUndef(data) || el.nodeType !== 1) {
           return rm();
       }
@@ -6701,23 +6701,23 @@
       }
       var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(leave);
+      var userWantsControl = getHookArgumentsLength$1(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
       if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
+          checkDuration$1(explicitLeaveDuration, 'leave', vnode);
       }
       var cb = (el._leaveCb = once(function () {
           if (el.parentNode && el.parentNode._pending) {
               el.parentNode._pending[vnode.key] = null;
           }
           if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
+              removeTransitionClass$1(el, leaveToClass);
+              removeTransitionClass$1(el, leaveActiveClass);
           }
           // @ts-expect-error
           if (cb.cancelled) {
               if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
+                  removeTransitionClass$1(el, leaveClass);
               }
               leaveCancelled && leaveCancelled(el);
           }
@@ -6745,19 +6745,19 @@
           }
           beforeLeave && beforeLeave(el);
           if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(function () {
-                  removeTransitionClass(el, leaveClass);
+              addTransitionClass$1(el, leaveClass);
+              addTransitionClass$1(el, leaveActiveClass);
+              nextFrame$1(function () {
+                  removeTransitionClass$1(el, leaveClass);
                   // @ts-expect-error
                   if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
+                      addTransitionClass$1(el, leaveToClass);
                       if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
+                          if (isValidDuration$1(explicitLeaveDuration)) {
                               setTimeout(cb, explicitLeaveDuration);
                           }
                           else {
-                              whenTransitionEnds(el, type, cb);
+                              whenTransitionEnds$1(el, type, cb);
                           }
                       }
                   }
@@ -6770,7 +6770,7 @@
       }
   }
   // only used in dev mode
-  function checkDuration(val, name, vnode) {
+  function checkDuration$1(val, name, vnode) {
       if (typeof val !== 'number') {
           warn("<transition> explicit " + name + " duration is not a valid number - " +
               ("got " + JSON.stringify(val) + "."), vnode.context);
@@ -6780,7 +6780,7 @@
               'the duration expression might be incorrect.', vnode.context);
       }
   }
-  function isValidDuration(val) {
+  function isValidDuration$1(val) {
       return typeof val === 'number' && !isNaN(val);
   }
   /**
@@ -6789,7 +6789,7 @@
    * - a wrapped component method (check ._length)
    * - a plain function (.length)
    */
-  function getHookArgumentsLength(fn) {
+  function getHookArgumentsLength$1(fn) {
       if (isUndef(fn)) {
           return false;
       }
@@ -6797,7 +6797,7 @@
       var invokerFns = fn.fns;
       if (isDef(invokerFns)) {
           // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+          return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
       }
       else {
           // @ts-expect-error
@@ -6806,7 +6806,7 @@
   }
   function _enter(_, vnode) {
       if (vnode.data.show !== true) {
-          enter(vnode);
+          enter$1(vnode);
       }
   }
   var transition = inBrowser
@@ -6817,7 +6817,7 @@
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
-                  leave(vnode, rm);
+                  leave$1(vnode, rm);
               }
               else {
                   rm();
@@ -6965,6 +6965,464 @@
       el.dispatchEvent(e);
   }
 
+  var whitespaceRE = /\s+/;
+  /**
+   * Add class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function addClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+          }
+          else {
+              el.classList.add(cls);
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
+      }
+  }
+  /**
+   * Remove class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function removeClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          var tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
+      }
+  }
+
+  function resolveTransition(def) {
+      if (!def) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def === 'object') {
+          var res = {};
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
+          }
+          extend(res, def);
+          return res;
+      }
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
+      }
+  }
+  var autoCssTransition = cached(function (name) {
+      return {
+          enterClass: name + "-enter",
+          enterToClass: name + "-enter-to",
+          enterActiveClass: name + "-enter-active",
+          leaveClass: name + "-leave",
+          leaveToClass: name + "-leave-to",
+          leaveActiveClass: name + "-leave-active",
+      };
+  });
+  var hasTransition = inBrowser && !isIE9;
+  var TRANSITION = 'transition';
+  var ANIMATION = 'animation';
+  // Transition property/event sniffing
+  var transitionProp = 'transition';
+  var transitionEndEvent = 'transitionend';
+  var animationProp = 'animation';
+  var animationEndEvent = 'animationend';
+  if (hasTransition) {
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          // @ts-expect-error
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          // @ts-expect-error
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
+  }
+  // binding to window is necessary to make hot reload work in IE in strict mode
+  var raf = inBrowser
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ function (fn) { return fn(); };
+  function nextFrame(fn) {
+      raf(function () {
+          // @ts-expect-error
+          raf(fn);
+      });
+  }
+  function addTransitionClass(el, cls) {
+      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
+  }
+  function removeTransitionClass(el, cls) {
+      if (el._transitionClasses) {
+          remove$2(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
+  }
+  function whenTransitionEnds(el, expectedType, cb) {
+      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+      if (!type)
+          { return cb(); }
+      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var ended = 0;
+      var end = function () {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      var onEnd = function (e) {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(function () {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
+  }
+  var transformRE = /\b(transform|all)(,|$)/;
+  function getTransitionInfo(el, expectedType) {
+      var styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var type;
+      var timeout = 0;
+      var propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
+      }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type: type,
+          timeout: timeout,
+          propCount: propCount,
+          hasTransform: hasTransform,
+      };
+  }
+  function getTimeout(delays, durations) {
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map(function (d, i) {
+          return toMs(d) + toMs(delays[i]);
+      }));
+  }
+  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+  // in a locale-dependent way, using a comma instead of a dot.
+  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+  // as a floor function) causing unexpected behaviors
+  function toMs(s) {
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+  }
+
+  function enter(vnode, toggleDisplay) {
+      var el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
+      }
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      var context = activeInstance;
+      var transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      var startClass = isAppear && appearClass ? appearClass : enterClass;
+      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      var enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      var enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(enterHook);
+      var cb = (el._enterCb = once(function () {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', function () {
+              var parent = el.parentNode;
+              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
+      }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
+      if (expectsCSS) {
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(function () {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
+      if (!expectsCSS && !userWantsControl) {
+          cb();
+      }
+  }
+  function leave(vnode, rm) {
+      var el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
+      }
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
+      }
+      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(leave);
+      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      var cb = (el._leaveCb = once(function () {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
+              }
+              leaveCancelled && leaveCancelled(el);
+          }
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
+      }
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(function () {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
+      }
+  }
+  // only used in dev mode
+  function checkDuration(val, name, vnode) {
+      if (typeof val !== 'number') {
+          warn("<transition> explicit " + name + " duration is not a valid number - " +
+              ("got " + JSON.stringify(val) + "."), vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn("<transition> explicit " + name + " duration is NaN - " +
+              'the duration expression might be incorrect.', vnode.context);
+      }
+  }
+  function isValidDuration(val) {
+      return typeof val === 'number' && !isNaN(val);
+  }
+  /**
+   * Normalize a transition hook's argument length. The hook may be:
+   * - a merged hook (invoker) with the original in .fns
+   * - a wrapped component method (check ._length)
+   * - a plain function (.length)
+   */
+  function getHookArgumentsLength(fn) {
+      if (isUndef(fn)) {
+          return false;
+      }
+      // @ts-expect-error
+      var invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
+  }
+
   // recursively search for possible transition defined inside the component root
   function locateNode(vnode) {
       // @ts-expect-error
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
index 9b4bf801bbf..adf93603c31 100644
--- a/dist/vue.runtime.min.js
+++ b/dist/vue.runtime.min.js
@@ -3,4 +3,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,$=y(function(t){return t.replace(C,"-$1").toLowerCase()});var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return j(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return j(t[n],e[n])})}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),H=U&&window.navigator.userAgent.toLowerCase(),z=H&&/msie|trident/.test(H),W=H&&H.indexOf("msie 9.0")>0,q=H&&H.indexOf("edge/")>0;H&&H.indexOf("android");var K=H&&/iphone|ipad|ipod|ios/.test(H)||"ios"===B;H&&/chrome\/\d+/.test(H),H&&/phantomjs/.test(H);var X,G=H&&H.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function pt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function wt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var At=L.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):$t(t,n,o));return t}function Ot(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function kt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}At.data=function(t,e,n){return n?Ot(t,e,n):e&&"function"!=typeof e?t:Ot(t,e)},P.forEach(function(t){At[t]=kt}),N.forEach(function(t){At[t+"s"]=St}),At.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},At.props=At.methods=At.inject=At.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},At.provide=Ot;var Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=jt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=At[r]||Et;a[r]=o(t[r],e[r],n,r)}return a}function Tt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Lt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Lt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!V||"undefined"==typeof console)throw t;console.error(t)}var Vt,Bt=!1,Ht=[],zt=!1;function Wt(){zt=!1;var t=Ht.slice(0);Ht.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Vt=function(){qt.then(Wt),K&&setTimeout(k)},Bt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Vt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Bt=!0}function Zt(t,e){var n;if(Ht.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return Tt(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?he(o,r):i?he(i,t):r?$(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=O(n));var a=void 0,s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function we(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?we(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ae(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=j,t._i=T,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=ft,t._u=we,t._g=$e,t._d=Ae,t._p=xe}function ke(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Le(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Le(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=pt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ee(t,e){for(var n in e)t[_(n)]=e[n]}Oe(ke.prototype);var je={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;je.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=It(p,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},Te=Object.keys(je);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Ee(c,o.attrs),n(o.props)&&Ee(c,o.props);var f=new ke(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Te.length;n++){var r=Te[n],o=e[r],i=je[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Pe=2;function Le(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Pe),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Pe?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||L.getTagNamespace(o),u=L.isReservedTag(o)?new lt(L.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=Tt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Ve(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function Be(t,e){Me.$on(t,e)}function He(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},Be,He,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:k,set:k};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||k,k,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=k):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):k,ln.set=n.set||k),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=jt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=jt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function $n(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function An(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=$n(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Le(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Le(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=wt,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?A(e):e;for(var n=A(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var On=[String,RegExp,Array],kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:On,exclude:On,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){An(t,function(t){return wn(e,t)})}),this.$watch("exclude",function(e){An(t,function(t){return!wn(e,t)})})},render:function(){var t=this.$slots.default,e=Ve(t),n=e&&e.componentOptions;if(n){var r=$n(n),o=this.include,i=this.exclude;if(o&&(!r||!wn(o,r))||i&&r&&wn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:jt,defineReactive:Ct},t.set=$t,t.delete=wt,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,kn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:ke}),bn.version="2.6.12";var Sn=d("style,class"),En=d("input,textarea,option,select,progress"),jn=d("contenteditable,draggable,spellcheck"),Tn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Pn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Ln=function(t){return Pn(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Vn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Vn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Vn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Hn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Hn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=Tt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Pn(i)?s.removeAttributeNS(Nn,Ln(i)):jn(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):jn(e)?t.setAttribute(e,In(e,n)):Pn(e)?Mn(n)?t.removeAttributeNS(Nn,Ln(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Vn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Bt&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var $r,wr={create:Cr,update:Cr};function Ar(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:Ar,update:Ar},kr=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?O(t):"string"==typeof t?kr(t):t}var jr,Tr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(Tr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty($(e),n.replace(Ir,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Pr=y(function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in jr)return r}});function Lr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Er(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Lr,update:Lr},Fr=/\s+/;function Rr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Vr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Hr=U&&!W,zr="transition",Wr="animation",qr="transition",Kr="transitionend",Xr="animation",Gr="animationend";Hr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(qr="WebkitTransition",Kr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Xr="WebkitAnimation",Gr="webkitAnimationEnd"));var Zr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Jr(t){Zr(function(){Zr(t)})}function Qr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Rr(t,e))}function Yr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Ur(t,e)}function to(t,e,n){var r=no(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===zr?Kr:Gr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var eo=/\b(transform|all)(,|$)/;function no(t,e){var n,r=window.getComputedStyle(t),o=(r[qr+"Delay"]||"").split(", "),i=(r[qr+"Duration"]||"").split(", "),a=ro(o,i),s=(r[Xr+"Delay"]||"").split(", "),c=(r[Xr+"Duration"]||"").split(", "),u=ro(s,c),l=0,f=0;return e===zr?a>0&&(n=zr,l=a,f=i.length):e===Wr?u>0&&(n=Wr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?zr:Wr:null)?n===zr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===zr&&eo.test(r[qr+"Property"])}}function ro(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return oo(e)+oo(t[n])}))}function oo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function io(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Vr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=qe,O=qe.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&p?p:u,E=k&&h?h:d,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!W,F=co(D),R=o._enterCb=I(function(){M&&(Yr(o,j),Yr(o,E)),R.cancelled?(M&&Yr(o,S),P&&P(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),T&&T(o),M&&(Qr(o,S),Qr(o,E),Jr(function(){Yr(o,S),R.cancelled||(Qr(o,j),F||(so(L)?setTimeout(R,L):to(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function ao(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Vr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=co(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Yr(o,l),Yr(o,d)),$.cancelled?(_&&Yr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Qr(o,u),Qr(o,d),Jr(function(){Yr(o,u),$.cancelled||(Qr(o,l),b||(so(C)?setTimeout($,C):to(o,c,$)))})),v&&v(o,$),_||b||$())}}function so(t){return"number"==typeof t&&!isNaN(t)}function co(t){if(e(t))return!1;var r=t.fns;return n(r)?co(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function uo(t,e){!0!==e.data.show&&io(e)}var lo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=pt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=pt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?(A(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?(A(m,g,i,o,p),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:w(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?(A(l,g,i,o,p),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=d("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!k(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))A(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](Jn,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,wr,Or,Mr,U?{create:uo,activate:uo,remove:function(t,e){!0!==t.data.show?ao(t,e):e()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&_o(t,"input")});var fo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){fo.componentUpdated(t,e,n)}):po(t,e,n.context),t._vOptions=[].map.call(t.options,mo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",yo),t.addEventListener("compositionend",go),t.addEventListener("change",go),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){po(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,mo);if(o.some(function(t,e){return!j(t,r[e])}))(t.multiple?e.value.some(function(t){return ho(t,o)}):e.value!==e.oldValue&&ho(e.value,o))&&_o(t,"change")}}};function po(t,e,n){vo(t,e),(z||q)&&setTimeout(function(){vo(t,e)},0)}function vo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,mo(a))>-1,a.selected!==i&&(a.selected=i);else if(j(mo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function ho(t,e){return e.every(function(e){return!j(e,t)})}function mo(t){return"_value"in t?t._value:t.value}function yo(t){t.target.composing=!0}function go(t){t.target.composing&&(t.target.composing=!1,_o(t.target,"input"))}function _o(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function bo(t){return!t.componentInstance||t.data&&t.data.transition?t:bo(t.componentInstance._vnode)}var Co={model:fo,show:{bind:function(t,e,n){var r=e.value,o=(n=bo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,io(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=bo(n)).data&&n.data.transition?(n.data.show=!0,r?io(n,function(){t.style.display=t.__vOriginalDisplay}):ao(n,function(){t.style.display="none"})):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},$o={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function wo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?wo(Ve(e.children)):t}function Ao(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function xo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Oo=function(t){return t.tag||Ue(t)},ko=function(t){return"show"===t.name},So={name:"transition",props:$o,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Oo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=wo(i);if(!a)return i;if(this._leaving)return xo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ao(this),u=this._vnode,l=wo(u);if(a.data.directives&&a.data.directives.some(ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),xo(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Eo=x({tag:String,moveClass:String},$o);function jo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function To(t){t.data.newPos=t.elm.getBoundingClientRect()}function Io(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Eo.mode;var Do={Transition:So,TransitionGroup:{props:Eo,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ao(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(jo),t.forEach(To),t.forEach(Io),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;Qr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Kr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Kr,t),n._moveCb=null,Yr(n,e))})}}))},methods:{hasMove:function(t,e){if(!Hr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){Ur(n,t)}),Rr(n,e),n.style.display="none",this.$el.appendChild(n);var r=no(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return bn.config.mustUseProp=function(t,e,n){return"value"===n&&En(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Co),x(bn.options.components,Do),bn.prototype.__patch__=U?lo:k,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){L.devtools&&tt&&tt.emit("init",bn)},0),bn});
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,w=y(function(t){return t.replace(C,"-$1").toLowerCase()});var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return E(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return E(t[n],e[n])})}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:L};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),H=U&&window.navigator.userAgent.toLowerCase(),z=H&&/msie|trident/.test(H),W=H&&H.indexOf("msie 9.0")>0,q=H&&H.indexOf("edge/")>0;H&&H.indexOf("android");var K=H&&/iphone|ipad|ipod|ios/.test(H)||"ios"===B;H&&/chrome\/\d+/.test(H),H&&/phantomjs/.test(H);var X,G=H&&H.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=O,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function pt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var $t=P.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Ot(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}$t.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},L.forEach(function(t){$t[t]=Ot}),N.forEach(function(t){$t[t+"s"]=St}),$t.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},$t.props=$t.methods=$t.inject=$t.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},$t.provide=kt;var Tt=function(t,e){return void 0===e?t:e};function Et(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Et(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Et(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=$t[r]||Tt;a[r]=o(t[r],e[r],n,r)}return a}function jt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Pt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===w(t)){var c=Pt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Lt(t,e){return Nt(t)===Nt(e)}function Pt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!V||"undefined"==typeof console)throw t;console.error(t)}var Vt,Bt=!1,Ht=[],zt=!1;function Wt(){zt=!1;var t=Ht.slice(0);Ht.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Vt=function(){qt.then(Wt),K&&setTimeout(O)},Bt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Vt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Bt=!0}function Zt(t,e){var n;if(Ht.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return jt(this.$options,"filters",t)||T}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?he(o,r):i?he(i,t):r?w(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=k(n));var a=void 0,s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=w(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function $e(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=E,t._i=j,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=ft,t._u=Ae,t._g=we,t._d=$e,t._p=xe}function Oe(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Pe(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Pe(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=pt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Te(t,e){for(var n in e)t[_(n)]=e[n]}ke(Oe.prototype);var Ee={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ee.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=It(p,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},je=Object.keys(Ee);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=w(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Te(c,o.attrs),n(o.props)&&Te(c,o.props);var f=new Oe(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<je.length;n++){var r=je[n],o=e[r],i=Ee[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Le=2;function Pe(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||P.getTagNamespace(o),u=P.isReservedTag(o)?new lt(P.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=jt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Ve(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function Be(t,e){Me.$on(t,e)}function He(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},Be,He,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&P.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:O,set:O};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||O,O,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=O):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):O,ln.set=n.set||O),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Et(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Et(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function $n(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Et(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Pe(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Pe(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?$(e):e;for(var n=$(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var kn=[String,RegExp,Array],On={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){$n(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){$n(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Ve(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Et,defineReactive:Ct},t.set=wt,t.delete=At,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,On),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Et(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:Oe}),bn.version="2.6.12";var Sn=d("style,class"),Tn=d("input,textarea,option,select,progress"),En=d("contenteditable,draggable,spellcheck"),jn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&jn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Pn=function(t){return Ln(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Vn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Vn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Vn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Hn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Hn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=jt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Nn,Pn(i)):En(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):En(e)?t.setAttribute(e,In(e,n)):Ln(e)?Mn(n)?t.removeAttributeNS(Nn,Pn(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Vn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Bt&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var wr,Ar={create:Cr,update:Cr};function $r(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:$r,update:$r},Or=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Tr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Tr(t){return Array.isArray(t)?k(t):"string"==typeof t?Or(t):t}var Er,jr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(jr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty(w(e),n.replace(Ir,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Lr=y(function(t){if(Er=Er||document.createElement("div").style,"filter"!==(t=_(t))&&t in Er)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in Er)return r}});function Pr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Tr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Pr,update:Pr},Fr=/\s+/;function Rr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Ur(t.name||"v")),x(e,t),e}return"string"==typeof t?Ur(t):void 0}}var Ur=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Vr="transition",Br="animation",Hr="transition",zr="transitionend",Wr="animation",qr="animationend";U&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Hr="WebkitTransition",zr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Wr="WebkitAnimation",qr="webkitAnimationEnd"));var Kr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Xr(t){Kr(function(){Kr(t)})}function Gr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Zr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Jr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),o=(r[Hr+"Delay"]||"").split(", "),i=(r[Hr+"Duration"]||"").split(", "),a=Yr(o,i),s=(r[Wr+"Delay"]||"").split(", "),c=(r[Wr+"Duration"]||"").split(", "),u=Yr(s,c),l=0,f=0;e===Vr?a>0&&(n=Vr,l=a,f=i.length):e===Br?u>0&&(n=Br,l=u,f=c.length):(l=Math.max(a,u),f=(n=l>0?a>u?Vr:Br:null)?n===Vr?i.length:c.length:0);var d=n===Vr&&Qr.test(r[Hr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Vr?zr:qr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var Qr=/\b(transform|all)(,|$)/;function Yr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return to(e)+to(t[n])}))}function to(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function eo(t){return"number"==typeof t&&!isNaN(t)}function no(t){if(e(t))return!1;var r=t.fns;return n(r)?no(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function ro(t,r){!0!==r.data.show&&function(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Rr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=no(D),R=o._enterCb=I(function(){M&&(Zr(o,E),Zr(o,T)),R.cancelled?(M&&Zr(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(Gr(o,S),Gr(o,T),Xr(function(){Zr(o,S),R.cancelled||(Gr(o,E),F||(eo(P)?setTimeout(R,P):Jr(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}(r)}var oo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=pt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function $(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=pt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?O(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?($(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?($(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?($(h,b,i,o,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?($(m,g,i,o,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?($(l,g,i,o,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))$(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&O(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Jn,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,Ar,kr,Mr,U?{create:ro,activate:ro,remove:function(t,r){!0!==t.data.show?function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Rr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=no(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Zr(o,l),Zr(o,d)),w.cancelled?(_&&Zr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Gr(o,u),Gr(o,d),Xr(function(){Zr(o,u),w.cancelled||(Gr(o,l),b||(eo(C)?setTimeout(w,C):Jr(o,c,w)))})),v&&v(o,w),_||b||w())}}(t,r):r()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&po(t,"input")});var io={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){io.componentUpdated(t,e,n)}):ao(t,e,n.context),t._vOptions=[].map.call(t.options,uo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",lo),t.addEventListener("compositionend",fo),t.addEventListener("change",fo),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ao(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,uo);if(o.some(function(t,e){return!E(t,r[e])}))(t.multiple?e.value.some(function(t){return co(t,o)}):e.value!==e.oldValue&&co(e.value,o))&&po(t,"change")}}};function ao(t,e,n){so(t,e),(z||q)&&setTimeout(function(){so(t,e)},0)}function so(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=j(r,uo(a))>-1,a.selected!==i&&(a.selected=i);else if(E(uo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function co(t,e){return e.every(function(e){return!E(e,t)})}function uo(t){return"_value"in t?t._value:t.value}function lo(t){t.target.composing=!0}function fo(t){t.target.composing&&(t.target.composing=!1,po(t.target,"input"))}function po(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var vo=/\s+/;function ho(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function mo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function yo(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,go(t.name||"v")),x(e,t),e}return"string"==typeof t?go(t):void 0}}var go=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),_o=U&&!W,bo="transition",Co="animation",wo="transition",Ao="transitionend",$o="animation",xo="animationend";_o&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(wo="WebkitTransition",Ao="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($o="WebkitAnimation",xo="webkitAnimationEnd"));var ko=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Oo(t){ko(function(){ko(t)})}function So(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),ho(t,e))}function To(t,e){t._transitionClasses&&v(t._transitionClasses,e),mo(t,e)}function Eo(t,e,n){var r=Io(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===bo?Ao:xo,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var jo=/\b(transform|all)(,|$)/;function Io(t,e){var n,r=window.getComputedStyle(t),o=(r[wo+"Delay"]||"").split(", "),i=(r[wo+"Duration"]||"").split(", "),a=Do(o,i),s=(r[$o+"Delay"]||"").split(", "),c=(r[$o+"Duration"]||"").split(", "),u=Do(s,c),l=0,f=0;return e===bo?a>0&&(n=bo,l=a,f=i.length):e===Co?u>0&&(n=Co,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?bo:Co:null)?n===bo?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===bo&&jo.test(r[wo+"Property"])}}function Do(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return No(e)+No(t[n])}))}function No(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Lo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=yo(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=Mo(D),R=o._enterCb=I(function(){M&&(To(o,E),To(o,T)),R.cancelled?(M&&To(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(So(o,S),So(o,T),Oo(function(){To(o,S),R.cancelled||(So(o,E),F||(Po(P)?setTimeout(R,P):Eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function Po(t){return"number"==typeof t&&!isNaN(t)}function Mo(t){if(e(t))return!1;var r=t.fns;return n(r)?Mo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Fo(t){return!t.componentInstance||t.data&&t.data.transition?t:Fo(t.componentInstance._vnode)}var Ro={model:io,show:{bind:function(t,e,n){var r=e.value,o=(n=Fo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,Lo(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,r,o){var a=r.value;!a!=!r.oldValue&&((o=Fo(o)).data&&o.data.transition?(o.data.show=!0,a?Lo(o,function(){t.style.display=t.__vOriginalDisplay}):function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=yo(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Mo(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(To(o,l),To(o,d)),w.cancelled?(_&&To(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(So(o,u),So(o,d),Oo(function(){To(o,u),w.cancelled||(So(o,l),b||(Po(C)?setTimeout(w,C):Eo(o,c,w)))})),v&&v(o,w),_||b||w())}}(o,function(){t.style.display="none"})):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Uo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Vo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Vo(Ve(e.children)):t}function Bo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function Ho(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var zo=function(t){return t.tag||Ue(t)},Wo=function(t){return"show"===t.name},qo={name:"transition",props:Uo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(zo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Vo(i);if(!a)return i;if(this._leaving)return Ho(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Bo(this),u=this._vnode,l=Vo(u);if(a.data.directives&&a.data.directives.some(Wo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Ho(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Ko=x({tag:String,moveClass:String},Uo);function Xo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Go(t){t.data.newPos=t.elm.getBoundingClientRect()}function Zo(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Ko.mode;var Jo={Transition:qo,TransitionGroup:{props:Ko,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Bo(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Xo),t.forEach(Go),t.forEach(Zo),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;So(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ao,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ao,t),n._moveCb=null,To(n,e))})}}))},methods:{hasMove:function(t,e){if(!_o)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){mo(n,t)}),ho(n,e),n.style.display="none",this.$el.appendChild(n);var r=Io(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return bn.config.mustUseProp=function(t,e,n){return"value"===n&&Tn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Ro),x(bn.options.components,Jo),bn.prototype.__patch__=U?oo:O,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){P.devtools&&tt&&tt.emit("init",bn)},0),bn});
\ No newline at end of file
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 59b2cd3efdd..0446e6301f8 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -256,7 +256,7 @@
       return -1;
   }
 
-  var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+  var isAttr$1 = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
       'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
       'checked,cite,class,code,codebase,color,cols,colspan,content,' +
       'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
@@ -269,33 +269,29 @@
       'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
       'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
       'target,title,usemap,value,width,wrap');
-  var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-  var isSSRUnsafeAttr = function (name) {
-      return unsafeAttrCharRE.test(name);
-  };
   /* istanbul ignore next */
-  var isRenderableAttr = function (name) {
-      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+  var isRenderableAttr$1 = function (name) {
+      return (isAttr$1(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
   };
-  var propsToAttrMap = {
+  var propsToAttrMap$1 = {
       acceptCharset: 'accept-charset',
       className: 'class',
       htmlFor: 'for',
       httpEquiv: 'http-equiv',
   };
-  var ESC = {
+  var ESC$1 = {
       '<': '&lt;',
       '>': '&gt;',
       '"': '&quot;',
       '&': '&amp;',
   };
-  function escape(s) {
-      return s.replace(/[<>"&]/g, escapeChar);
+  function escape$1(s) {
+      return s.replace(/[<>"&]/g, escapeChar$1);
   }
-  function escapeChar(a) {
-      return ESC[a] || a;
+  function escapeChar$1(a) {
+      return ESC$1[a] || a;
   }
-  var noUnitNumericStyleProps = {
+  var noUnitNumericStyleProps$1 = {
       'animation-iteration-count': true,
       'border-image-outset': true,
       'border-image-slice': true,
@@ -371,6 +367,90 @@
       return val == null || val === false;
   };
 
+  var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap');
+  var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+  var isSSRUnsafeAttr = function (name) {
+      return unsafeAttrCharRE.test(name);
+  };
+  /* istanbul ignore next */
+  var isRenderableAttr = function (name) {
+      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+  };
+  var propsToAttrMap = {
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv',
+  };
+  var ESC = {
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;',
+  };
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
+  }
+  function escapeChar(a) {
+      return ESC[a] || a;
+  }
+  var noUnitNumericStyleProps = {
+      'animation-iteration-count': true,
+      'border-image-outset': true,
+      'border-image-slice': true,
+      'border-image-width': true,
+      'box-flex': true,
+      'box-flex-group': true,
+      'box-ordinal-group': true,
+      'column-count': true,
+      columns: true,
+      flex: true,
+      'flex-grow': true,
+      'flex-positive': true,
+      'flex-shrink': true,
+      'flex-negative': true,
+      'flex-order': true,
+      'grid-row': true,
+      'grid-row-end': true,
+      'grid-row-span': true,
+      'grid-row-start': true,
+      'grid-column': true,
+      'grid-column-end': true,
+      'grid-column-span': true,
+      'grid-column-start': true,
+      'font-weight': true,
+      'line-clamp': true,
+      'line-height': true,
+      opacity: true,
+      order: true,
+      orphans: true,
+      'tab-size': true,
+      widows: true,
+      'z-index': true,
+      zoom: true,
+      // SVG
+      'fill-opacity': true,
+      'flood-opacity': true,
+      'stop-opacity': true,
+      'stroke-dasharray': true,
+      'stroke-dashoffset': true,
+      'stroke-miterlimit': true,
+      'stroke-opacity': true,
+      'stroke-width': true,
+  };
+
   function renderAttrs$1(node) {
       var attrs = node.data.attrs;
       var res = '';
@@ -400,21 +480,21 @@
               // leave it to the style module
               continue;
           }
-          res += renderAttr(key, attrs[key]);
+          res += renderAttr$1(key, attrs[key]);
       }
       return res;
   }
-  function renderAttr(key, value) {
+  function renderAttr$1(key, value) {
       if (isBooleanAttr(key)) {
           if (!isFalsyAttrValue(value)) {
               return " " + key + "=\"" + key + "\"";
           }
       }
       else if (isEnumeratedAttr(key)) {
-          return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
+          return " " + key + "=\"" + escape$1(convertEnumeratedValue(key, value)) + "\"";
       }
       else if (!isFalsyAttrValue(value)) {
-          return " " + key + "=\"" + escape(String(value)) + "\"";
+          return " " + key + "=\"" + escape$1(String(value)) + "\"";
       }
       return '';
   }
@@ -516,11 +596,11 @@
           }
           else {
               // $flow-disable-line (WTF?)
-              var attr = propsToAttrMap[key] || key.toLowerCase();
-              if (isRenderableAttr(attr) &&
+              var attr = propsToAttrMap$1[key] || key.toLowerCase();
+              if (isRenderableAttr$1(attr) &&
                   // avoid rendering double-bound props/attrs twice
                   !(isDef(attrs) && isDef(attrs[attr]))) {
-                  res += renderAttr(attr, props[key]);
+                  res += renderAttr$1(attr, props[key]);
               }
           }
       }
@@ -1897,7 +1977,7 @@
   function renderClass(node) {
       var classList = genClassForVnode(node);
       if (classList !== '') {
-          return " class=\"" + escape(classList) + "\"";
+          return " class=\"" + escape$1(classList) + "\"";
       }
   }
 
@@ -1960,25 +2040,25 @@
       return res;
   }
 
-  function genStyle(style) {
+  function genStyle$1(style) {
       var styleText = '';
       for (var key in style) {
           var value = style[key];
           var hyphenatedKey = hyphenate(key);
           if (Array.isArray(value)) {
               for (var i = 0, len = value.length; i < len; i++) {
-                  styleText += normalizeValue(hyphenatedKey, value[i]);
+                  styleText += normalizeValue$1(hyphenatedKey, value[i]);
               }
           }
           else {
-              styleText += normalizeValue(hyphenatedKey, value);
+              styleText += normalizeValue$1(hyphenatedKey, value);
           }
       }
       return styleText;
   }
-  function normalizeValue(key, value) {
+  function normalizeValue$1(key, value) {
       if (typeof value === 'string' ||
-          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+          (typeof value === 'number' && noUnitNumericStyleProps$1[key]) ||
           value === 0) {
           return key + ":" + value + ";";
       }
@@ -1988,9 +2068,9 @@
       }
   }
   function renderStyle(vnode) {
-      var styleText = genStyle(getStyle(vnode, false));
+      var styleText = genStyle$1(getStyle(vnode, false));
       if (styleText !== '') {
-          return " style=" + JSON.stringify(escape(styleText));
+          return " style=" + JSON.stringify(escape$1(styleText));
       }
   }
 
@@ -2050,14 +2130,14 @@
       model: model$2,
   };
 
-  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+  var isUnaryTag$1 = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  var canBeLeftOpenTag$1 = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+  makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
       'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
       'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
       'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -2607,6 +2687,367 @@
       genData: genData$1,
   };
 
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function createCommonjsModule(fn) {
+    var module = { exports: {} };
+  	return fn(module, module.exports), module.exports;
+  }
+
+  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+
+  var he = createCommonjsModule(function (module, exports) {
+  (function(root) {
+
+  	// Detect free variables `exports`.
+  	var freeExports = exports;
+
+  	// Detect free variable `module`.
+  	var freeModule = module &&
+  		module.exports == freeExports && module;
+
+  	// Detect free variable `global`, from Node.js or Browserified code,
+  	// and use it as `root`.
+  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+  		root = freeGlobal;
+  	}
+
+  	/*--------------------------------------------------------------------------*/
+
+  	// All astral symbols.
+  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  	// All ASCII symbols (not just printable ASCII) except those listed in the
+  	// first column of the overrides table.
+  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
+  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+  	// code points listed in the first column of the overrides table on
+  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+  	var regexEscape = /["&'<>`]/g;
+  	var escapeMap = {
+  		'"': '&quot;',
+  		'&': '&amp;',
+  		'\'': '&#x27;',
+  		'<': '&lt;',
+  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+  		// following is not strictly necessary unless it’s part of a tag or an
+  		// unquoted attribute value. We’re only escaping it to support those
+  		// situations, and for XML support.
+  		'>': '&gt;',
+  		// In Internet Explorer ≤ 8, the backtick character can be used
+  		// to break out of (un)quoted attribute values or HTML comments.
+  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
+  		// http://html5sec.org/#133.
+  		'`': '&#x60;'
+  	};
+
+  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var stringFromCharCode = String.fromCharCode;
+
+  	var object = {};
+  	var hasOwnProperty = object.hasOwnProperty;
+  	var has = function(object, propertyName) {
+  		return hasOwnProperty.call(object, propertyName);
+  	};
+
+  	var contains = function(array, value) {
+  		var index = -1;
+  		var length = array.length;
+  		while (++index < length) {
+  			if (array[index] == value) {
+  				return true;
+  			}
+  		}
+  		return false;
+  	};
+
+  	var merge = function(options, defaults) {
+  		if (!options) {
+  			return defaults;
+  		}
+  		var result = {};
+  		var key;
+  		for (key in defaults) {
+  			// A `hasOwnProperty` check is not needed here, since only recognized
+  			// option names are used anyway. Any others are ignored.
+  			result[key] = has(options, key) ? options[key] : defaults[key];
+  		}
+  		return result;
+  	};
+
+  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
+  	var codePointToSymbol = function(codePoint, strict) {
+  		var output = '';
+  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+  			// See issue #4:
+  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+  			// REPLACEMENT CHARACTER.”
+  			if (strict) {
+  				parseError('character reference outside the permissible Unicode range');
+  			}
+  			return '\uFFFD';
+  		}
+  		if (has(decodeMapNumeric, codePoint)) {
+  			if (strict) {
+  				parseError('disallowed character reference');
+  			}
+  			return decodeMapNumeric[codePoint];
+  		}
+  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+  			parseError('disallowed character reference');
+  		}
+  		if (codePoint > 0xFFFF) {
+  			codePoint -= 0x10000;
+  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+  			codePoint = 0xDC00 | codePoint & 0x3FF;
+  		}
+  		output += stringFromCharCode(codePoint);
+  		return output;
+  	};
+
+  	var hexEscape = function(codePoint) {
+  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+  	};
+
+  	var decEscape = function(codePoint) {
+  		return '&#' + codePoint + ';';
+  	};
+
+  	var parseError = function(message) {
+  		throw Error('Parse error: ' + message);
+  	};
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var encode = function(string, options) {
+  		options = merge(options, encode.options);
+  		var strict = options.strict;
+  		if (strict && regexInvalidRawCodePoint.test(string)) {
+  			parseError('forbidden code point');
+  		}
+  		var encodeEverything = options.encodeEverything;
+  		var useNamedReferences = options.useNamedReferences;
+  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
+  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+  		var escapeBmpSymbol = function(symbol) {
+  			return escapeCodePoint(symbol.charCodeAt(0));
+  		};
+
+  		if (encodeEverything) {
+  			// Encode ASCII symbols.
+  			string = string.replace(regexAsciiWhitelist, function(symbol) {
+  				// Use named references if requested & possible.
+  				if (useNamedReferences && has(encodeMap, symbol)) {
+  					return '&' + encodeMap[symbol] + ';';
+  				}
+  				return escapeBmpSymbol(symbol);
+  			});
+  			// Shorten a few escapes that represent two symbols, of which at least one
+  			// is within the ASCII range.
+  			if (useNamedReferences) {
+  				string = string
+  					.replace(/&gt;\u20D2/g, '&nvgt;')
+  					.replace(/&lt;\u20D2/g, '&nvlt;')
+  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
+  			}
+  			// Encode non-ASCII symbols.
+  			if (useNamedReferences) {
+  				// Encode non-ASCII symbols that can be replaced with a named reference.
+  				string = string.replace(regexEncodeNonAscii, function(string) {
+  					// Note: there is no need to check `has(encodeMap, string)` here.
+  					return '&' + encodeMap[string] + ';';
+  				});
+  			}
+  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+  		} else if (useNamedReferences) {
+  			// Apply named character references.
+  			// Encode `<>"'&` using named character references.
+  			if (!allowUnsafeSymbols) {
+  				string = string.replace(regexEscape, function(string) {
+  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+  				});
+  			}
+  			// Shorten escapes that represent two symbols, of which at least one is
+  			// `<>"'&`.
+  			string = string
+  				.replace(/&gt;\u20D2/g, '&nvgt;')
+  				.replace(/&lt;\u20D2/g, '&nvlt;');
+  			// Encode non-ASCII symbols that can be replaced with a named reference.
+  			string = string.replace(regexEncodeNonAscii, function(string) {
+  				// Note: there is no need to check `has(encodeMap, string)` here.
+  				return '&' + encodeMap[string] + ';';
+  			});
+  		} else if (!allowUnsafeSymbols) {
+  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+  			// using named character references.
+  			string = string.replace(regexEscape, escapeBmpSymbol);
+  		}
+  		return string
+  			// Encode astral symbols.
+  			.replace(regexAstralSymbols, function($0) {
+  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+  				var high = $0.charCodeAt(0);
+  				var low = $0.charCodeAt(1);
+  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+  				return escapeCodePoint(codePoint);
+  			})
+  			// Encode any remaining BMP symbols that are not printable ASCII symbols
+  			// using a hexadecimal escape.
+  			.replace(regexBmpWhitelist, escapeBmpSymbol);
+  	};
+  	// Expose default options (so they can be overridden globally).
+  	encode.options = {
+  		'allowUnsafeSymbols': false,
+  		'encodeEverything': false,
+  		'strict': false,
+  		'useNamedReferences': false,
+  		'decimal' : false
+  	};
+
+  	var decode = function(html, options) {
+  		options = merge(options, decode.options);
+  		var strict = options.strict;
+  		if (strict && regexInvalidEntity.test(html)) {
+  			parseError('malformed character reference');
+  		}
+  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+  			var codePoint;
+  			var semicolon;
+  			var decDigits;
+  			var hexDigits;
+  			var reference;
+  			var next;
+
+  			if ($1) {
+  				reference = $1;
+  				// Note: there is no need to check `has(decodeMap, reference)`.
+  				return decodeMap[reference];
+  			}
+
+  			if ($2) {
+  				// Decode named character references without trailing `;`, e.g. `&amp`.
+  				// This is only a parse error if it gets converted to `&`, or if it is
+  				// followed by `=` in an attribute context.
+  				reference = $2;
+  				next = $3;
+  				if (next && options.isAttributeValue) {
+  					if (strict && next == '=') {
+  						parseError('`&` did not start a character reference');
+  					}
+  					return $0;
+  				} else {
+  					if (strict) {
+  						parseError(
+  							'named character reference was not terminated by a semicolon'
+  						);
+  					}
+  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+  					return decodeMapLegacy[reference] + (next || '');
+  				}
+  			}
+
+  			if ($4) {
+  				// Decode decimal escapes, e.g. `&#119558;`.
+  				decDigits = $4;
+  				semicolon = $5;
+  				if (strict && !semicolon) {
+  					parseError('character reference was not terminated by a semicolon');
+  				}
+  				codePoint = parseInt(decDigits, 10);
+  				return codePointToSymbol(codePoint, strict);
+  			}
+
+  			if ($6) {
+  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+  				hexDigits = $6;
+  				semicolon = $7;
+  				if (strict && !semicolon) {
+  					parseError('character reference was not terminated by a semicolon');
+  				}
+  				codePoint = parseInt(hexDigits, 16);
+  				return codePointToSymbol(codePoint, strict);
+  			}
+
+  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+  			if (strict) {
+  				parseError(
+  					'named character reference was not terminated by a semicolon'
+  				);
+  			}
+  			return $0;
+  		});
+  	};
+  	// Expose default options (so they can be overridden globally).
+  	decode.options = {
+  		'isAttributeValue': false,
+  		'strict': false
+  	};
+
+  	var escape = function(string) {
+  		return string.replace(regexEscape, function($0) {
+  			// Note: there is no need to check `has(escapeMap, $0)` here.
+  			return escapeMap[$0];
+  		});
+  	};
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var he = {
+  		'version': '1.2.0',
+  		'encode': encode,
+  		'decode': decode,
+  		'escape': escape,
+  		'unescape': decode
+  	};
+
+  	// Some AMD build optimizers, like r.js, check for specific condition patterns
+  	// like the following:
+  	if (freeExports && !freeExports.nodeType) {
+  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+  			freeModule.exports = he;
+  		} else { // in Narwhal or RingoJS v0.7.0-
+  			for (var key in he) {
+  				has(he, key) && (freeExports[key] = he[key]);
+  			}
+  		}
+  	} else { // in Rhino or a web browser
+  		root.he = he;
+  	}
+
+  }(commonjsGlobal));
+  });
+
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
+
   /**
    * Not type-checking this file because it's mostly vendor code.
    */
@@ -3019,7 +3460,7 @@
       }
   }
 
-  var he = require('he');
+  // const he = require('he')
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -5243,6 +5684,7 @@
   function repeat(str, n) {
       var result = '';
       if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
           while (true) {
               // eslint-disable-line
               if (n & 1)
@@ -5416,6 +5858,49 @@
 
   var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
+  function renderAttr(key, value) {
+      if (isBooleanAttr(key)) {
+          if (!isFalsyAttrValue(value)) {
+              return " " + key + "=\"" + key + "\"";
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
+      }
+      else if (!isFalsyAttrValue(value)) {
+          return " " + key + "=\"" + escape(String(value)) + "\"";
+      }
+      return '';
+  }
+
+  function genStyle(style) {
+      var styleText = '';
+      for (var key in style) {
+          var value = style[key];
+          var hyphenatedKey = hyphenate(key);
+          if (Array.isArray(value)) {
+              for (var i = 0, len = value.length; i < len; i++) {
+                  styleText += normalizeValue(hyphenatedKey, value[i]);
+              }
+          }
+          else {
+              styleText += normalizeValue(hyphenatedKey, value);
+          }
+      }
+      return styleText;
+  }
+  function normalizeValue(key, value) {
+      if (typeof value === 'string' ||
+          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+          value === 0) {
+          return key + ":" + value + ";";
+      }
+      else {
+          // invalid values
+          return "";
+      }
+  }
+
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
   //
@@ -7286,8 +7771,8 @@
       // @ts-expect-error
       modules: modules$1,
       directives: directives$1,
-      isUnaryTag: isUnaryTag,
-      canBeLeftOpenTag: canBeLeftOpenTag,
+      isUnaryTag: isUnaryTag$1,
+      canBeLeftOpenTag: canBeLeftOpenTag$1,
   });
 
   return entryServerBasicRenderer;
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index e95d4e2d28f..20f8f7371df 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -3,6 +3,11 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var stream = require('stream');
+var he = require('he');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
@@ -256,7 +261,7 @@ function looseIndexOf(arr, val) {
     return -1;
 }
 
-var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+var isAttr$1 = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
     'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
     'checked,cite,class,code,codebase,color,cols,colspan,content,' +
     'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
@@ -269,33 +274,29 @@ var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,aut
     'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
     'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
     'target,title,usemap,value,width,wrap');
-var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-var isSSRUnsafeAttr = function (name) {
-    return unsafeAttrCharRE.test(name);
-};
 /* istanbul ignore next */
-var isRenderableAttr = function (name) {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+var isRenderableAttr$1 = function (name) {
+    return (isAttr$1(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
 };
-var propsToAttrMap = {
+var propsToAttrMap$1 = {
     acceptCharset: 'accept-charset',
     className: 'class',
     htmlFor: 'for',
     httpEquiv: 'http-equiv',
 };
-var ESC = {
+var ESC$1 = {
     '<': '&lt;',
     '>': '&gt;',
     '"': '&quot;',
     '&': '&amp;',
 };
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
+function escape$1(s) {
+    return s.replace(/[<>"&]/g, escapeChar$1);
 }
-function escapeChar(a) {
-    return ESC[a] || a;
+function escapeChar$1(a) {
+    return ESC$1[a] || a;
 }
-var noUnitNumericStyleProps = {
+var noUnitNumericStyleProps$1 = {
     'animation-iteration-count': true,
     'border-image-outset': true,
     'border-image-slice': true,
@@ -371,6 +372,90 @@ var isFalsyAttrValue = function (val) {
     return val == null || val === false;
 };
 
+var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
+var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+var isSSRUnsafeAttr = function (name) {
+    return unsafeAttrCharRE.test(name);
+};
+/* istanbul ignore next */
+var isRenderableAttr = function (name) {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+};
+var propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
+};
+var ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
+};
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
+}
+var noUnitNumericStyleProps = {
+    'animation-iteration-count': true,
+    'border-image-outset': true,
+    'border-image-slice': true,
+    'border-image-width': true,
+    'box-flex': true,
+    'box-flex-group': true,
+    'box-ordinal-group': true,
+    'column-count': true,
+    columns: true,
+    flex: true,
+    'flex-grow': true,
+    'flex-positive': true,
+    'flex-shrink': true,
+    'flex-negative': true,
+    'flex-order': true,
+    'grid-row': true,
+    'grid-row-end': true,
+    'grid-row-span': true,
+    'grid-row-start': true,
+    'grid-column': true,
+    'grid-column-end': true,
+    'grid-column-span': true,
+    'grid-column-start': true,
+    'font-weight': true,
+    'line-clamp': true,
+    'line-height': true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    'tab-size': true,
+    widows: true,
+    'z-index': true,
+    zoom: true,
+    // SVG
+    'fill-opacity': true,
+    'flood-opacity': true,
+    'stop-opacity': true,
+    'stroke-dasharray': true,
+    'stroke-dashoffset': true,
+    'stroke-miterlimit': true,
+    'stroke-opacity': true,
+    'stroke-width': true,
+};
+
 function renderAttrs$1(node) {
     var attrs = node.data.attrs;
     var res = '';
@@ -400,21 +485,21 @@ function renderAttrs$1(node) {
             // leave it to the style module
             continue;
         }
-        res += renderAttr(key, attrs[key]);
+        res += renderAttr$1(key, attrs[key]);
     }
     return res;
 }
-function renderAttr(key, value) {
+function renderAttr$1(key, value) {
     if (isBooleanAttr(key)) {
         if (!isFalsyAttrValue(value)) {
             return " " + key + "=\"" + key + "\"";
         }
     }
     else if (isEnumeratedAttr(key)) {
-        return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
+        return " " + key + "=\"" + escape$1(convertEnumeratedValue(key, value)) + "\"";
     }
     else if (!isFalsyAttrValue(value)) {
-        return " " + key + "=\"" + escape(String(value)) + "\"";
+        return " " + key + "=\"" + escape$1(String(value)) + "\"";
     }
     return '';
 }
@@ -516,11 +601,11 @@ function renderDOMProps$1(node) {
         }
         else {
             // $flow-disable-line (WTF?)
-            var attr = propsToAttrMap[key] || key.toLowerCase();
-            if (isRenderableAttr(attr) &&
+            var attr = propsToAttrMap$1[key] || key.toLowerCase();
+            if (isRenderableAttr$1(attr) &&
                 // avoid rendering double-bound props/attrs twice
                 !(isDef(attrs) && isDef(attrs[attr]))) {
-                res += renderAttr(attr, props[key]);
+                res += renderAttr$1(attr, props[key]);
             }
         }
     }
@@ -1897,7 +1982,7 @@ makeMap('text,number,password,search,email,tel,url');
 function renderClass(node) {
     var classList = genClassForVnode(node);
     if (classList !== '') {
-        return " class=\"" + escape(classList) + "\"";
+        return " class=\"" + escape$1(classList) + "\"";
     }
 }
 
@@ -1960,25 +2045,25 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-function genStyle(style) {
+function genStyle$1(style) {
     var styleText = '';
     for (var key in style) {
         var value = style[key];
         var hyphenatedKey = hyphenate(key);
         if (Array.isArray(value)) {
             for (var i = 0, len = value.length; i < len; i++) {
-                styleText += normalizeValue(hyphenatedKey, value[i]);
+                styleText += normalizeValue$1(hyphenatedKey, value[i]);
             }
         }
         else {
-            styleText += normalizeValue(hyphenatedKey, value);
+            styleText += normalizeValue$1(hyphenatedKey, value);
         }
     }
     return styleText;
 }
-function normalizeValue(key, value) {
+function normalizeValue$1(key, value) {
     if (typeof value === 'string' ||
-        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+        (typeof value === 'number' && noUnitNumericStyleProps$1[key]) ||
         value === 0) {
         return key + ":" + value + ";";
     }
@@ -1988,9 +2073,9 @@ function normalizeValue(key, value) {
     }
 }
 function renderStyle(vnode) {
-    var styleText = genStyle(getStyle(vnode, false));
+    var styleText = genStyle$1(getStyle(vnode, false));
     if (styleText !== '') {
-        return " style=" + JSON.stringify(escape(styleText));
+        return " style=" + JSON.stringify(escape$1(styleText));
     }
 }
 
@@ -2050,14 +2135,14 @@ var baseDirectives$1 = {
     model: model$2,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+var isUnaryTag$1 = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+var canBeLeftOpenTag$1 = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
     'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -2719,6 +2804,19 @@ var style = {
     genData: genData$1,
 };
 
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
+
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
@@ -3131,7 +3229,7 @@ function parseString(chr) {
     }
 }
 
-var he = require('he');
+// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -3145,7 +3243,7 @@ var slotRE = /^v-slot(:|$)|^#/;
 var lineBreakRE = /[\r\n]/;
 var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(he.decode);
+var decodeHTMLCached = cached(he__default['default'].decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
 var warn$1;
@@ -5355,6 +5453,7 @@ function generateCodeFrame(source, start, end) {
 function repeat(str, n) {
     var result = '';
     if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
@@ -5528,6 +5627,49 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
 
 var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
 
+function renderAttr(key, value) {
+    if (isBooleanAttr(key)) {
+        if (!isFalsyAttrValue(value)) {
+            return " " + key + "=\"" + key + "\"";
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
+    }
+    else if (!isFalsyAttrValue(value)) {
+        return " " + key + "=\"" + escape(String(value)) + "\"";
+    }
+    return '';
+}
+
+function genStyle(style) {
+    var styleText = '';
+    for (var key in style) {
+        var value = style[key];
+        var hyphenatedKey = hyphenate(key);
+        if (Array.isArray(value)) {
+            for (var i = 0, len = value.length; i < len; i++) {
+                styleText += normalizeValue(hyphenatedKey, value[i]);
+            }
+        }
+        else {
+            styleText += normalizeValue(hyphenatedKey, value);
+        }
+    }
+    return styleText;
+}
+function normalizeValue(key, value) {
+    if (typeof value === 'string' ||
+        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+        value === 0) {
+        return key + ":" + value + ";";
+    }
+    else {
+        // invalid values
+        return "";
+    }
+}
+
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
 //
@@ -8179,8 +8321,8 @@ process.env.VUE_ENV = 'server';
 function createRenderer(options) {
     if (options === void 0) { options = {}; }
     return createRenderer$1(extend(extend({}, options), {
-        isUnaryTag: isUnaryTag,
-        canBeLeftOpenTag: canBeLeftOpenTag,
+        isUnaryTag: isUnaryTag$1,
+        canBeLeftOpenTag: canBeLeftOpenTag$1,
         modules: modules$1,
         // user can provide server-side implementations for custom directives
         // when creating the renderer.
diff --git a/packages/vue-server-renderer/build.prod.js b/packages/vue-server-renderer/build.prod.js
index 5a8db191ba0..9bdc3dffad7 100644
--- a/packages/vue-server-renderer/build.prod.js
+++ b/packages/vue-server-renderer/build.prod.js
@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream"),t=Object.freeze({});function r(e){return null==e}function n(e){return null!=e}function i(e){return!0===e}function o(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var s=Object.prototype.toString;function c(e){return"[object Object]"===s.call(e)}function u(e){return null==e?"":Array.isArray(e)||c(e)&&e.toString===s?JSON.stringify(e,null,2):String(e)}function l(e){var t=parseFloat(e);return isNaN(t)?e:t}function f(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var p=f("slot,component",!0),d=f("key,ref,slot,slot-scope,is");var v=Object.prototype.hasOwnProperty;function h(e,t){return v.call(e,t)}function m(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var y=/-(\w)/g,g=m(function(e){return e.replace(y,function(e,t){return t?t.toUpperCase():""})}),b=m(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),_=/\B([A-Z])/g,w=m(function(e){return e.replace(_,"-$1").toLowerCase()});function x(e,t){for(var r in t)e[r]=t[r];return e}function S(e){for(var t={},r=0;r<e.length;r++)e[r]&&x(t,e[r]);return t}function $(e,t,r){}var A=function(e,t,r){return!1},k=function(e){return e};function O(e,t){if(e===t)return!0;var r=a(e),n=a(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return O(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(r){return O(e[r],t[r])})}catch(e){return!1}}function C(e,t){for(var r=0;r<e.length;r++)if(O(e[r],t))return r;return-1}var T=f("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),F=/[>/="'\u0009\u000a\u000c\u0020]/,j=function(e){return F.test(e)},P=function(e){return T(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},E={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},N={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function I(e){return e.replace(/[<>"&]/g,L)}function L(e){return N[e]||e}var M={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},R=f("input,textarea,option,select,progress"),D=f("contenteditable,draggable,spellcheck"),z=f("events,caret,typing,plaintext-only"),U=function(e,t){return q(t)||"false"===t?"false":"contenteditable"===e&&z(t)?t:"true"},B=f("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),q=function(e){return null==e||!1===e};function J(e,t){if(B(e)){if(!q(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+I(U(e,t))+'"';if(!q(t))return" "+e+'="'+I(String(t))+'"'}return""}var H=function(){function e(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),K=function(e){void 0===e&&(e="");var t=new H;return t.text=e,t.isComment=!0,t};function V(e){return new H(void 0,void 0,void 0,String(e))}function W(e,t,r){var n=new H(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function Z(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var X="__proto__"in{},G="undefined"!=typeof window,Q="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,Y=(Q&&WXEnvironment.platform.toLowerCase(),G&&window.navigator.userAgent.toLowerCase()),ee=Y&&/msie|trident/.test(Y);Y&&Y.indexOf("msie 9.0");Y&&Y.indexOf("edge/");Y&&Y.indexOf("android"),Y&&/iphone|ipad|ipod|ios/.test(Y),Y&&/chrome\/\d+/.test(Y),Y&&/phantomjs/.test(Y),Y&&Y.match(/firefox\/(\d+)/);var te,re={}.watch;if(G)try{var ne={};Object.defineProperty(ne,"passive",{get:function(){!0}}),window.addEventListener("test-passive",null,ne)}catch(e){}var ie=function(){return void 0===te&&(te=!G&&!Q&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),te};function oe(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,se="undefined"!=typeof Symbol&&oe(Symbol)&&"undefined"!=typeof Reflect&&oe(Reflect.ownKeys);ae="undefined"!=typeof Set&&oe(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ce="data-server-rendered",ue=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],le={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:A,isReservedAttr:A,isUnknownElement:A,getTagNamespace:$,parsePlatformTagName:k,mustUseProp:A,async:!0,_lifecycleHooks:ue},fe=0,pe=function(){function e(){this.id=fe++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){!function(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)e.splice(r,1)}}(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},e}();pe.target=null;var de=[];function ve(e){de.push(e),pe.target=e}function he(){de.pop(),pe.target=de[de.length-1]}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];Z(ye,e,function(){for(var r=arguments,n=[],i=0;i<arguments.length;i++)n[i]=r[i];var o,a=t.apply(this,n),s=this.__ob__;switch(e){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),be=!0;function _e(e){be=e}var we=function(){function e(e){var t;this.value=e,this.dep=new pe,this.vmCount=0,Z(e,"__ob__",this),Array.isArray(e)?(X?(t=ye,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];Z(e,o,t[o])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Se(e,t[r])},e.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)xe(e[t])},e}();function xe(e,t){var r;if(a(e)&&!(e instanceof H))return h(e,"__ob__")&&e.__ob__ instanceof we?r=e.__ob__:be&&!ie()&&(Array.isArray(e)||c(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new we(e)),t&&r&&r.vmCount++,r}function Se(e,t,r,n,i){var o=new pe,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&xe(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return pe.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&xe(t),o.notify())}})}}function $e(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Se(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}var Ae=le.optionMergeStrategies;function ke(e,t){if(!t)return e;for(var r,n,i,o=se?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],h(e,r)?n!==i&&c(n)&&c(i)&&ke(n,i):$e(e,r,i));return e}function Oe(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?ke(n,i):i}:t?e?function(){return ke("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ce(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Te(e,t,r,n){var i=Object.create(e||null);return t?x(i,t):i}Ae.data=function(e,t,r){return r?Oe(e,t,r):t&&"function"!=typeof t?e:Oe(e,t)},ue.forEach(function(e){Ae[e]=Ce}),["component","directive","filter"].forEach(function(e){Ae[e+"s"]=Te}),Ae.watch=function(e,t,r,n){if(e===re&&(e=void 0),t===re&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in x(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return x(i,e),t&&x(i,t),i},Ae.provide=Oe;var Fe=function(e,t){return void 0===t?e:t};function je(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[g(i)]={type:null});else if(c(r))for(var a in r)i=r[a],o[g(a)]=c(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(c(r))for(var o in r){var a=r[o];n[o]=c(a)?x({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=je(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=je(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)h(e,o)||s(o);function s(n){var i=Ae[n]||Fe;a[n]=i(e[n],t[n],r,n)}return a}function Pe(e,t,r,n){if("string"==typeof r){var i=e[t];if(h(i,r))return i[r];var o=g(r);if(h(i,o))return i[o];var a=b(o);return h(i,a)?i[a]:i[r]||i[o]||i[a]}}function Ee(e,t,r,n){var i=t[e],o=!h(r,e),a=r[e],s=Me(Boolean,i.type);if(s>-1)if(o&&!h(i,"default"))a=!1;else if(""===a||a===w(e)){var c=Me(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!h(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Ie(t.type)?n.call(e):n}(n,i,e);var u=be;_e(!0),xe(a),_e(u)}return a}var Ne=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Ne);return t?t[1]:""}function Le(e,t){return Ie(e)===Ie(t)}function Me(e,t){if(!Array.isArray(t))return Le(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(Le(t[r],e))return r;return-1}function Re(e,t,r){ve();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){ze(e,n,"errorCaptured hook")}}ze(e,t,r)}finally{he()}}function De(e,t,r,i,o){var a,s;try{(a=r?e.apply(t,r):e.call(t))&&!a._isVue&&(n(s=a)&&"function"==typeof s.then&&"function"==typeof s.catch)&&!a._handled&&(a.catch(function(e){return Re(e,i,o+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,i,o)}return a}function ze(e,t,r){!function(e,t,r){if(!G&&!Q||"undefined"==typeof console)throw e;console.error(e)}(e)}var Ue=[];if("undefined"!=typeof Promise&&oe(Promise));else if(ee||"undefined"==typeof MutationObserver||!oe(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&oe(setImmediate);else{var Be=new MutationObserver(function(){var e=Ue.slice(0);Ue.length=0;for(var t=0;t<e.length;t++)e[t]()}),qe=document.createTextNode(String(1));Be.observe(qe,{characterData:!0})}function Je(e,t){return{staticClass:Ke(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function He(e,t){return n(e)||n(t)?Ke(e,Ve(t)):""}function Ke(e,t){return e?t?e+" "+t:e:t||""}function Ve(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Ve(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var We=f("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ze=f("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var Xe=m(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function Ge(e){var t=Qe(e.style);return e.staticStyle?x(e.staticStyle,t):t}function Qe(e){return Array.isArray(e)?S(e):"string"==typeof e?Xe(e):e}function Ye(e){var t="";for(var r in e){var n=e[r],i=w(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=et(i,n[o]);else t+=et(i,n)}return t}function et(e,t){return"string"==typeof t||"number"==typeof t&&M[e]||0===t?e+":"+t+";":""}var tt=[function(e){var t=e.data.attrs,i="",o=e.parent&&e.parent.componentOptions;if(r(o)||!1!==o.Ctor.options.inheritAttrs)for(var a=e.parent;n(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)n(a.data)&&n(a.data.attrs)&&(t=x(x({},t),a.data.attrs)),a=a.parent;if(r(t))return i;for(var s in t)j(s)||"style"!==s&&(i+=J(s,t[s]));return i},function(e){for(var t=e.data.domProps,i="",o=e.parent;n(o);)o.data&&o.data.domProps&&(t=x(x({},t),o.data.domProps)),o=o.parent;if(r(t))return i;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)W(e,t[s],!0);else if("textContent"===s)W(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)W(e,u(t[s]),!1);else{var c=E[s]||s.toLowerCase();!P(c)||n(a)&&n(a[c])||(i+=J(c,t[s]))}return i},function(e){var t=function(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Je(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Je(t,r.data));return He(t.staticClass,t.class)}(e);if(""!==t)return' class="'+I(t)+'"'},function(e){var t=Ye(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=Ge(i.data))&&x(n,r);(r=Ge(e.data))&&x(n,r);for(var o=e;o=o.parent;)o.data&&(r=Ge(o.data))&&x(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(I(t))}];function rt(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function nt(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var it={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&C(r,rt(a))>-1&&nt(a);else if(O(r,rt(a)))return void nt(a)}}},ot=f("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),at=f("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),st=f("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ct=function(e,t){return(ct=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(e[r]=t[r])})(e,t)};function ut(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function r(){this.constructor=e}ct(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}var lt=800,ft=function(e){return e},pt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:ft;if(pt===ft)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function dt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=lt?pt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var vt=function(e){function t(t){var r=e.call(this)||this;return r.buffer="",r.render=t,r.expectedSize=0,r.write=dt(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),r.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)},r}return ut(t,e),t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,i(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):r(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),ht=function(){function e(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&mt(t,"get"),this.has=t&&mt(t,"has"),this.next=this.next.bind(this)}return e.prototype.next=function(){for(var e=function(){var e=t.renderStates[t.renderStates.length-1];if(r(e))return{value:t.done()};switch(e.type){case"Element":case"Fragment":var n=e.children,i=e.total,o=e.rendered++;if(o<i)return{value:t.renderNode(n[o],!1,t)};if(t.renderStates.pop(),"Element"===e.type)return{value:t.write(e.endTag,t.next)};break;case"Component":t.renderStates.pop(),t.activeInstance=e.prevActive;break;case"ComponentWithCache":t.renderStates.pop();var a=e.buffer,s=e.bufferIndex,c=e.componentBuffer,u=e.key,l={html:a[s],components:c[s]};if(t.cache.set(u,l),0===s)t.write.caching=!1;else{a[s-1]+=l.html;var f=c[s-1];l.components.forEach(function(e){return f.add(e)})}a.length=s,c.length=s}},t=this;;){var n=e();if("object"==typeof n)return n.value}},e}();function mt(e,t){var n=e[t];return r(n)?void 0:n.length>1?function(t,r){return n.call(e,t,r)}:function(t,r){return r(n.call(e,t))}}var yt=/[\w).+\-_$\]]/;function gt(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&yt.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=bt(i,o[n]);return i}function bt(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var _t=/\{\{((?:.|\r?\n)+?)\}\}/g,wt=/[-.*+?^${}()|[\]\/\\]/g,xt=m(function(e){var t=e[0].replace(wt,"\\$&"),r=e[1].replace(wt,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function St(e,t){console.error("[Vue compiler]: "+e)}function $t(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function At(e,t,r,n,i){(e.props||(e.props=[])).push(Nt({name:t,value:r,dynamic:i},n)),e.plain=!1}function kt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Nt({name:t,value:r,dynamic:i},n)),e.plain=!1}function Ot(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Nt({name:t,value:r},n))}function Ct(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Nt({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Tt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Ft(e,r,n,i,o,a,s,c){var u;(i=i||t).right?c?r="("+r+")==='click'?'contextmenu':("+r+")":"click"===r&&(r="contextmenu",delete i.right):i.middle&&(c?r="("+r+")==='click'?'mouseup':("+r+")":"click"===r&&(r="mouseup")),i.capture&&(delete i.capture,r=Tt("!",r,c)),i.once&&(delete i.once,r=Tt("~",r,c)),i.passive&&(delete i.passive,r=Tt("&",r,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Nt({value:n.trim(),dynamic:c},s);i!==t&&(l.modifiers=i);var f=u[r];Array.isArray(f)?o?f.unshift(l):f.push(l):u[r]=f?o?[l,f]:[f,l]:l,e.plain=!1}function jt(e,t,r){var n=Pt(e,":"+t)||Pt(e,"v-bind:"+t);if(null!=n)return gt(n);if(!1!==r){var i=Pt(e,t);if(null!=i)return JSON.stringify(i)}}function Pt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Et(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Nt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var It={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Pt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=jt(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Lt,Mt,Rt,Dt,zt,Ut,Bt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Pt(e,"style");r&&(e.staticStyle=JSON.stringify(Xe(r)));var n=jt(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},qt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Jt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ht="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Kt="((?:"+Ht+"\\:)?"+Ht+")",Vt=new RegExp("^<"+Kt),Wt=/^\s*(\/?)>/,Zt=new RegExp("^<\\/"+Kt+"[^>]*>"),Xt=/^<!DOCTYPE [^>]+>/i,Gt=/^<!\--/,Qt=/^<!\[/,Yt=f("script,style,textarea",!0),er={},tr={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},rr=/&(?:lt|gt|quot|amp|#39);/g,nr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,ir=f("pre,textarea",!0),or=function(e,t){return e&&ir(e)&&"\n"===t[0]};function ar(e,t){var r=t?nr:rr;return e.replace(r,function(e){return tr[e]})}function sr(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||A,s=t.canBeLeftOpenTag||A,c=0,u=function(){if(r=e,n&&Yt(n)){var u=0,p=n.toLowerCase(),d=er[p]||(er[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));x=e.replace(d,function(e,r,n){return u=n.length,Yt(p)||"noscript"===p||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),or(p,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-x.length,e=x,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(Gt.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(Qt.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(Xt);if(y)return l(y[0].length),"continue";var g=e.match(Zt);if(g){var b=c;return l(g[0].length),f(g[1],b,c),"continue"}var _=function(){var t=e.match(Vt);if(t){var r={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var n=void 0,i=void 0;!(n=e.match(Wt))&&(i=e.match(Jt)||e.match(qt));)i.start=c,l(i[0].length),i.end=c,r.attrs.push(i);if(n)return r.unarySlash=n[1],l(n[0].length),r.end=c,r}}();if(_)return function(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&st(r)&&f(n),s(r)&&n===r&&f(r));for(var u=a(r)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===r&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:ar(h,m)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=r);t.start&&t.start(r,p,u,e.start,e.end)}(_),or(_.tagName,e)&&l(1),"continue"}var w=void 0,x=void 0,S=void 0;if(v>=0){for(x=e.slice(v);!(Zt.test(x)||Vt.test(x)||Gt.test(x)||Qt.test(x)||(S=x.indexOf("<",1))<0);)v+=S,x=e.slice(v);w=e.substring(0,v)}v<0&&(w=e),w&&l(w.length),t.chars&&w&&t.chars(w,c-w.length,c)}if(e===r)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}f()}function cr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=ur(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function ur(e,t){var r=function(e){if(e=e.trim(),Lt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Lt-1)return(Dt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Dt),key:'"'+e.slice(Dt+1)+'"'}:{exp:e,key:null};Mt=e,Dt=zt=Ut=0;for(;!fr();)pr(Rt=lr())?vr(Rt):91===Rt&&dr(Rt);return{exp:e.slice(0,zt),key:e.slice(zt+1,Ut)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function lr(){return Mt.charCodeAt(++Dt)}function fr(){return Dt>=Lt}function pr(e){return 34===e||39===e}function dr(e){var t=1;for(zt=Dt;!fr();)if(pr(e=lr()))vr(e);else if(91===e&&t++,93===e&&t--,0===t){Ut=Dt;break}}function vr(e){for(var t=e;!fr()&&(e=lr())!==t;);}var hr,mr,yr,gr,br,_r,wr,xr,Sr=require("he"),$r=/^@|^v-on:/,Ar=/^v-|^@|^:|^#/,kr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Or=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Cr=/^\(|\)$/g,Tr=/^\[.*\]$/,Fr=/:(.*)$/,jr=/^:|^\.|^v-bind:/,Pr=/\.[^.\]]+(?=[^\]]*$)/g,Er=/^v-slot(:|$)|^#/,Nr=/[\r\n]/,Ir=/[ \f\t\r\n]+/g,Lr=m(Sr.decode),Mr="_empty_";function Rr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Hr(t),rawAttrsMap:{},parent:r,children:[]}}function Dr(e,t){hr=t.warn||St,_r=t.isPreTag||A,wr=t.mustUseProp||A,xr=t.getTagNamespace||A,t.isReservedTag,yr=$t(t.modules,"transformNode"),gr=$t(t.modules,"preTransformNode"),br=$t(t.modules,"postTransformNode"),mr=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=zr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Br(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Br(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),_r(e.tag)&&(c=!1);for(var f=0;f<br.length;f++)br[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return sr(e,{warn:hr,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||xr(e);ee&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Kr.test(n.name)||(n.name=n.name.replace(Vr,""),t.push(n))}return t}(o));var d,v=Rr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||ie()||(v.forbidden=!0);for(var h=0;h<gr.length;h++)v=gr[h](v,t)||v;s||(!function(e){null!=Pt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),_r(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Ur(v),function(e){var t=Pt(e,"v-if");if(t)e.if=t,Br(e,{exp:t,block:e});else{null!=Pt(e,"v-else")&&(e.else=!0);var r=Pt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Pt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!ee||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Lr(e):u.length?a?"condense"===a&&Nr.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(Ir," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var r=t?xt(t):_t;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=gt(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,mr))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function zr(e,t){var r,n;(n=jt(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jt(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Pt(e,"scope"),e.slotScope=t||Pt(e,"slot-scope")):(t=Pt(e,"slot-scope"))&&(e.slotScope=t);var r=jt(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||kt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Et(e,Er);if(n){var i=qr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Mr}}else{var n=Et(e,Er);if(n){var s=e.scopedSlots||(e.scopedSlots={}),c=qr(n),u=c.name,a=c.dynamic,l=s[u]=Rr("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=n.value||Mr,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jt(e,"name"))}(e),function(e){var t;(t=jt(e,"is"))&&(e.component=t);null!=Pt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<yr.length;i++)e=yr[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Ar.test(n))if(e.hasBindings=!0,(a=Jr(n.replace(Ar,"")))&&(n=n.replace(Pr,"")),jr.test(n))n=n.replace(jr,""),o=gt(o),(c=Tr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=g(n))&&(n="innerHTML"),a.camel&&!c&&(n=g(n)),a.sync&&(s=ur(o,"$event"),c?Ft(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Ft(e,"update:"+g(n),s,null,!1,0,u[t]),w(n)!==g(n)&&Ft(e,"update:"+w(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&wr(e.tag,e.attrsMap.type,n)?At(e,n,o,u[t],c):kt(e,n,o,u[t],c);else if($r.test(n))n=n.replace($r,""),(c=Tr.test(n))&&(n=n.slice(1,-1)),Ft(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Ar,"")).match(Fr),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Tr.test(f)&&(f=f.slice(1,-1),c=!0)),Ct(e,n,i,o,f,c,a,u[t])}else kt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&wr(e.tag,e.attrsMap.type,n)&&At(e,n,"true",u[t])}(e),e}function Ur(e){var t;if(t=Pt(e,"v-for")){var r=function(e){var t=e.match(kr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(Cr,""),i=n.match(Or);i?(r.alias=n.replace(Or,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&x(e,r)}}function Br(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function qr(e){var t=e.name.replace(Er,"");return t||"#"!==e.name[0]&&(t="default"),Tr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Jr(e){var t=e.match(Pr);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function Hr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Kr=/^xmlns:NS\d+/,Vr=/^NS\d+:/;function Wr(e){return Rr(e.tag,e.attrsList.slice(),e.parent)}var Zr=[It,Bt,{preTransformNode:function(e,t){if("input"===e.tag){var r=e.attrsMap;if(!r["v-model"])return;var n=void 0;if((r[":type"]||r["v-bind:type"])&&(n=jt(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Pt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Pt(e,"v-else",!0),s=Pt(e,"v-else-if",!0),c=Wr(e);Ur(c),Ot(c,"type","checkbox"),zr(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,Br(c,{exp:c.if,block:c});var u=Wr(e);Pt(u,"v-for",!0),Ot(u,"type","radio"),zr(u,t),Br(c,{exp:"("+n+")==='radio'"+o,block:u});var l=Wr(e);return Pt(l,"v-for",!0),Ot(l,":type",n),zr(l,t),Br(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],Xr="__r";var Gr={expectHTML:!0,modules:Zr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return cr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+ur(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Ft(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=jt(e,"value")||"null",o=jt(e,"true-value")||"true",a=jt(e,"false-value")||"false";At(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Ft(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+ur(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+ur(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+ur(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=jt(e,"value")||"null";At(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Ft(e,"change",ur(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return cr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?Xr:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=ur(t,l);c&&(f="if($event.target.composing)return;"+f),At(e,"value","("+t+")"),Ft(e,u,f,null,!0),(s||a)&&Ft(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&At(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&At(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:ot,mustUseProp:function(e,t,r){return"value"===r&&R(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:at,isReservedTag:function(e){return We(e)||Ze(e)},getTagNamespace:function(e){return Ze(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Zr)},Qr=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Yr=/\([^)]*?\);*$/,en=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,tn={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},rn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},nn=function(e){return"if("+e+")return null;"},on={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:nn("$event.target !== $event.currentTarget"),ctrl:nn("!$event.ctrlKey"),shift:nn("!$event.shiftKey"),alt:nn("!$event.altKey"),meta:nn("!$event.metaKey"),left:nn("'button' in $event && $event.button !== 0"),middle:nn("'button' in $event && $event.button !== 1"),right:nn("'button' in $event && $event.button !== 2")};function an(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=sn(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function sn(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return sn(e)}).join(",")+"]";var t=en.test(e.value),r=Qr.test(e.value),n=en.test(e.value.replace(Yr,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(on[t])o+=on[t],tn[t]&&a.push(t);else if("exact"===t){var r=e.modifiers;o+=nn(["ctrl","shift","alt","meta"].filter(function(e){return!r[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(cn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function cn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=tn[e],n=rn[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var un={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:$},ln=function(){return function(e){this.options=e,this.warn=e.warn||St,this.transforms=$t(e.modules,"transformCode"),this.dataGenFns=$t(e.modules,"genData"),this.directives=x(x({},un),e.directives);var t=e.isReservedTag||A;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function fn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return pn(e,t);if(e.once&&!e.onceProcessed)return dn(e,t);if(e.for&&!e.forProcessed)return hn(e,t);if(e.if&&!e.ifProcessed)return vn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=bn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Sn((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:g(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r=void 0;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:bn(t,r,!0);return"_c("+e+","+mn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=mn(e,t));var i=e.inlineTemplate?null:bn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return bn(e,t)||"void 0"}function pn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+fn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function dn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return vn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+fn(e,t)+","+t.onceId+++","+r+")":fn(e,t)}return pn(e,t)}function vn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?dn(e,r):fn(e,r)}}(e.ifConditions.slice(),t,r,n)}function hn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||fn)(e,t)+"})"}function mn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+Sn(e.attrs)+","),e.props&&(r+="domProps:"+Sn(e.props)+","),e.events&&(r+=an(e.events,!1)+","),e.nativeEvents&&(r+=an(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||yn(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Mr||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return gn(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new ln(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":fn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+Sn(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function yn(e){return 1===e.type&&("slot"===e.tag||e.children.some(yn))}function gn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return vn(e,t,gn,"null");if(e.for&&!e.forProcessed)return hn(e,t,gn);var n=e.slotScope===Mr?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(bn(e,t)||"undefined")+":undefined":bn(e,t)||"undefined":fn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function bn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||fn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(_n(i)||i.ifConditions&&i.ifConditions.some(function(e){return _n(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||wn;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function _n(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function wn(e,t){return 1===e.type?fn(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):xn(e);var r}function xn(e){return"_v("+(2===e.type?e.expression:$n(JSON.stringify(e.text)))+")"}function Sn(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=$n(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function $n(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var An=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function kn(e,t){return An.test(t)?(t=t.replace(/^'|'$/g,'"'),D(e)&&'"false"'!==t&&(t='"true"'),{type:jn,value:B(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:En,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var On,Cn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Tn(e,t){e&&(On=t.isReservedTag||A,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return p(e.tag)||!On(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=Cn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!Fn(e.name)})}(t);var i=function(e){e.ssrOptimizability!==Cn.FULL&&(t.ssrOptimizability=n?Cn.PARTIAL:Cn.SELF)};n&&(t.ssrOptimizability=Cn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++){var c=t.ifConditions[o].block;e(c,r),i(c)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=Cn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:Cn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===Cn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=Cn.FULL}(e,!0))}var Fn=f("text,html,show,on,bind,model,pre,cloak,once");var jn=0,Pn=1,En=2;function Nn(e,t){if(e.for&&!e.forProcessed)return hn(e,t,Nn);if(e.if&&!e.ifProcessed)return vn(e,t,Nn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===Cn.FULL?Rn(e,t):Ln(e,t)||"void 0";switch(e.ssrOptimizability){case Cn.FULL:return function(e,t){return"_ssrNode("+Dn(e,t)+")"}(e,t);case Cn.SELF:return function(e,t){var r=Ln(e,t,!0);return"_ssrNode("+qn(Un(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case Cn.CHILDREN:return In(e,t,!0);case Cn.PARTIAL:return In(e,t,!1);default:return fn(e,t)}}function In(e,t,r){var n=e.plain?void 0:mn(e,t),i=r?"["+Rn(e,t)+"]":Ln(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Ln(e,t,r){return bn(e,t,r,Nn,Mn)}function Mn(e,t){return 1===e.type?Nn(e,t):xn(e)}function Rn(e,t){return e.children.length?"_ssrNode("+qn(Bn(e,t))+")":""}function Dn(e,t){return"("+qn(zn(e,t))+")"}function zn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:En,value:hn(e,t,Dn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:En,value:vn(e,t,Dn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Bn(e,t);var r=Un(e,t),n=Bn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:jn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Un(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:jn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return kn(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=E[n]||n.toLowerCase(),!P(n)||t&&t.some(function(e){return e.name===n})||r.push(kn(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:En,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:En,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:jn,value:' class="'+JSON.parse(n)+'"'}]:[{type:En,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:En,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:jn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:jn,value:" "+t.options.scopeId}),u.push({type:jn,value:">"}),u}function Bn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:En,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Pn,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Pn,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,zn(i,t));else if(2===i.type)r.push({type:Pn,value:i.expression});else if(3===i.type){var o=I(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:jn,value:o})}}return r}(e.children,t):[]}function qn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===jn?r+=o.value:o.type===Pn?(n(),t.push("_ssrEscape("+o.value+")")):o.type===En&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}function Jn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),$}}function Hn(e){var t=Object.create(null);return function(r,n,i){(n=x({},n)).warn,delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Jn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Jn(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var Kn,Vn=(Kn=function(e,t){var r=Dr(e.trim(),t);Tn(r,t);var n=function(e,t){var r=new ln(t);return{render:"with(this){return "+(e?Nn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=x(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=Kn(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Hn(t)}})(Gr).compileToFunctions;function Wn(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Zn(e){return o(e)?[V(e)]:Array.isArray(e)?function e(t,a){var s=[];var c,u,l,f;for(c=0;c<t.length;c++)r(u=t[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(Xn((u=e(u,(a||"")+"_"+c))[0])&&Xn(f)&&(s[l]=V(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?Xn(f)?s[l]=V(f.text+u):""!==u&&s.push(V(u)):Xn(u)&&Xn(f)?s[l]=V(f.text+u.text):(i(t._isVList)&&n(u.tag)&&r(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(e):void 0}function Xn(e){return n(e)&&n(e.text)&&!1===e.isComment}var Gn={_ssrEscape:I,_ssrNode:function(e,t,r,n){return new Qn(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,s="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)s+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)s+=t(r+1,r);else if(a(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],s+=t(e[o],o,r);return s},_ssrAttr:J,_ssrAttrs:function(e){var t="";for(var r in e)j(r)||(t+=J(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=E[r]||r.toLowerCase();P(n)&&(t+=J(n,e[r]))}return t},_ssrClass:function(e,t){var r=He(e,t);return""===r?r:' class="'+I(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&x(n,e);t&&x(n,Qe(t));r&&x(n,r);var i=Ye(n);return""===i?i:" style="+JSON.stringify(I(i))}};var Qn=function(){return function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?Wn(r):2===n?Zn(r):r:void 0}}();var Yn=new ae;function ei(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof H)return;if(t.__ob__){var s=t.__ob__.dep.id;if(r.has(s))return;r.add(s)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,Yn),Yn.clear()}var ti=m(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function ri(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return De(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)De(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function ni(e,t,r,i,o){if(n(t)){if(h(t,r))return e[r]=t[r],o||delete t[r],!0;if(h(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}var ii,oi=1,ai=2;function si(e,t,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),i(l)&&(u=ai),function(e,t,o,s,c){if(n(o)&&n(o.__ob__))return K();n(o)&&n(o.is)&&(t=o.is);if(!t)return K();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===ai?s=Zn(s):c===oi&&(s=Wn(s));var u,l;if("string"==typeof t){var f=void 0;l=e.$vnode&&e.$vnode.ns||le.getTagNamespace(t),u=o&&o.pre||!n(f=Pe(e.$options,"components",t))?new H(t,o,s,void 0,void 0,e):zi(f,o,e,s,t)}else u=zi(t,o,e,s);return Array.isArray(u)?u:n(u)?(n(l)&&function e(t,o,a){t.ns=o;"foreignObject"===t.tag&&(o=void 0,a=!0);if(n(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];n(u.tag)&&(r(u.ns)||i(a)&&"svg"!==u.tag)&&e(u,o,a)}}(u,l),n(o)&&function(e){a(e.style)&&ei(e.style);a(e.class)&&ei(e.class)}(o),u):K()}(e,t,s,c,u)}function ci(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(se&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ui(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=x(x({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function li(e){return Pe(this.$options,"filters",e)||k}function fi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function pi(e,t,r,n,i){var o=le.keyCodes[t]||r;return i&&n&&!le.keyCodes[t]?fi(i,n):o?fi(o,e):n?w(n)!==t:void 0}function di(e,t,r,n,i){if(r)if(a(r)){Array.isArray(r)&&(r=S(r));var o=void 0,s=function(a){if("class"===a||"style"===a||d(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||le.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=g(a),u=w(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var c in r)s(c)}else;return e}function vi(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(mi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function hi(e,t,r){return mi(e,"__once__"+t+(r?"_"+r:""),!0),e}function mi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&yi(e[n],t+"_"+n,r);else yi(e,t,r)}function yi(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function gi(e,t){if(t)if(c(t)){var r=e.on=e.on?x({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function bi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?bi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function _i(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function wi(e,t){return"string"==typeof e?t+e:e}function xi(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Si)&&delete r[u];return r}function Si(e){return e.isComment&&!e.asyncFactory||" "===e.text}function $i(e,r,n){var i,o=Object.keys(r).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&n&&n!==t&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Ai(r,c,e[c]))}else i={};for(var u in r)u in i||(i[u]=ki(r,u));return e&&Object.isExtensible(e)&&(e._normalized=i),Z(i,"$stable",a),Z(i,"$key",s),Z(i,"$hasNormal",o),i}function Ai(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Zn(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function ki(e,t){return function(){return e[t]}}function Oi(e,t){ii.$on(e,t)}function Ci(e,t){ii.$off(e,t)}function Ti(e,t){var r=ii;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Fi(e,t,n){ii=e,function(e,t,n,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=ti(c),r(u)||(r(l)?(r(u.fns)&&(u=e[c]=ri(u,s)),i(f.once)&&(u=e[c]=a(f.name,u,f.capture)),n(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)r(e[c])&&o((f=ti(c)).name,t[c],f.capture)}(t,n||{},Oi,Ci,Ti,e),ii=void 0}function ji(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Pi(e,t){ve();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)De(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),he()}var Ei=Date.now;if(G&&!ee){var Ni=window.performance;Ni&&"function"==typeof Ni.now&&Ei()>document.createEvent("Event").timeStamp&&(Ei=function(){return Ni.now()})}function Ii(e,r,n,o,a){var s,c=this,u=a.options;h(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=i(u._compiled),f=!l;this.data=e,this.props=r,this.children=n,this.parent=o,this.listeners=e.on||t,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=se?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&h(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,o),this.slots=function(){return c.$slots||$i(e.scopedSlots,c.$slots=xi(n,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return $i(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=$i(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var i=si(s,e,t,r,n,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,r,n){return si(s,e,t,r,n,f)}}function Li(e,t,r,n,i){var o=function(e){var t=new H(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Mi(e,t){for(var r in t)e[g(r)]=t[r]}!function(e){e._o=hi,e._n=l,e._s=u,e._l=ci,e._t=ui,e._q=O,e._i=C,e._m=vi,e._f=li,e._k=pi,e._b=di,e._v=V,e._e=K,e._u=bi,e._g=gi,e._d=_i,e._p=wi}(Ii.prototype);var Ri={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ri.prepatch(r,r)}else{(e.componentInstance=Ui(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,r){var n=r.componentOptions;!function(e,r,n,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||t,e.$listeners=n||t,r&&e.$options.props){_e(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Ee(d,v,r,e)}_e(!0),e.$options.propsData=r}n=n||t;var h=e.$options._parentListeners;e.$options._parentListeners=n,Fi(e,n,h),u&&(e.$slots=xi(o,i.context),e.$forceUpdate())}(r.componentInstance=e.componentInstance,n.propsData,n.listeners,r,n.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Pi(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,ji(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Pi(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,ji(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Pi(t,"deactivated")}}(t,!0):t.$destroy())}},Di=Object.keys(Ri);function zi(e,o,s,c,u){if(!r(e)){var l=s.$options._base;if(a(e)&&(e=l.extend(e)),"function"==typeof e){var f,p;if(r(e.cid)&&void 0===(e=i((p=f=e).error)&&n(p.errorComp)?p.errorComp:n(p.resolved)?p.resolved:i(p.loading)&&n(p.loadingComp)?p.loadingComp:void 0))return function(e,t,r,n,i){var o=K();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(f,o,s,c,u);o=o||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&x(t.extendOptions,i),(r=t.options=je(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(e.options,o);var d=function(e,t,i){var o=t.options.props;if(!r(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=w(u);ni(a,c,u,l,!0)||ni(a,s,u,l,!1)}return a}}(o,e);if(i(e.options.functional))return function(e,r,i,o,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Ee(l,u,r||t);else n(i.attrs)&&Mi(c,i.attrs),n(i.props)&&Mi(c,i.props);var f=new Ii(i,c,a,o,e),p=s.render.call(null,f._c,f);if(p instanceof H)return Li(p,i,f.parent,s);if(Array.isArray(p)){for(var d=Zn(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Li(d[h],i,f.parent,s);return v}}(e,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,i(e.options.abstract)){var h=o.slot;o={},h&&(o.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Di.length;r++){var n=Di[r],i=t[n],o=Ri[n];i===o||i&&i._merged||(t[n]=i?Bi(o,i):o)}}(o);var m=e.options.name||u;return new H("vue-component-"+e.cid+(m?"-"+m:""),o,void 0,void 0,void 0,s,{Ctor:e,propsData:d,listeners:v,tag:u,children:c},f)}}}function Ui(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;return n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns),new e.componentOptions.Ctor(r)}function Bi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var qi=Object.create(null),Ji=function(e){qi[e]||(qi[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},Hi=function(e,t){var r=t?(void 0)():"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},Ki=function(e){var t=e.$options,n=t.render,i=t.template,o=t._scopeId;if(r(n)){if(!i)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=Vn(i,{scopeId:o,warn:Hi},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function Vi(e,t,r){var i=e.$options.serverPrefetch;if(n(i)){Array.isArray(i)||(i=[i]);try{for(var o=[],a=0,s=i.length;a<s;a++){var c=i[a].call(e,e);c&&"function"==typeof c.then&&o.push(c)}return void Promise.all(o).then(t).catch(r)}catch(e){r(e)}}t()}function Wi(e,t,o){e.isString?function(e,t){var n=t.write,i=t.next;if(r(e.children)||0===e.children.length)n(e.open+(e.close||""),i);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),n(e.open,i)}}(e,o):n(e.componentOptions)?Xi(e,t,o):n(e.tag)?function(e,t,o){var a=o.write,s=o.next;i(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[ce]="true");e.fnOptions&&Zi(e.fnOptions,a);var c=function(e,t){var i,o="<"+e.tag,a=t.directives,s=t.modules;r(e.data)&&function e(t){var r=t.parent;return n(r)&&(n(r.data)||e(r))}(e)&&(e.data={});if(n(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=Pe(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;n(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var u=0;u<s.length;u++){var d=s[u](e);d&&(o+=d)}}var v=t.activeInstance;n(v)&&v!==e.context&&n(i=v.$options._scopeId)&&(o+=" "+i);if(n(e.fnScopeId))o+=" "+e.fnScopeId;else for(;n(e);)n(i=e.context.$options._scopeId)&&(o+=" "+i),e=e.parent;return o+">"}(e,o),u="</"+e.tag+">";if(o.isUnaryTag(e.tag))a(c,s);else if(r(e.children)||0===e.children.length)a(c+u,s);else{var l=e.children;o.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),a(c,s)}}(e,t,o):i(e.isComment)?n(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=zi(n,o,c,a,s);u?u.componentOptions?Xi(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):Wi(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,o):o.write("\x3c!--"+e.text+"--\x3e",o.next):o.write(e.raw?e.text:I(String(e.text)),o.next)}function Zi(e,t){var r=e._ssrRegister;return t.caching&&n(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function Xi(e,t,i){var o=i.write,a=i.next,s=i.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=i.cache,p=Zi(c.options,o);if(n(u)&&n(f)&&n(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void Qi(e,t,i);var v=l+"::"+d,h=i.has,m=i.get;n(h)?h(v,function(r){!0===r&&n(m)?m(v,function(e){n(p)&&p(s),e.components.forEach(function(e){return e(s)}),o(e.html,a)}):Gi(e,t,v,i)}):n(m)&&m(v,function(r){n(r)?(n(p)&&p(s),r.components.forEach(function(e){return e(s)}),o(r.html,a)):Gi(e,t,v,i)})}else n(u)&&r(f)&&Ji("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),n(u)&&r(l)&&Ji('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),Qi(e,t,i)}function Gi(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),Qi(e,t,n)}function Qi(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Ui(e,r.activeInstance);Ki(i);var o=r.done;Vi(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),Wi(o,t,r)},o)}function Yi(e,t,r,n){return function(i,o,a,s){qi=Object.create(null);var c=new ht({activeInstance:i,userContext:a,write:o,done:s,renderNode:Wi,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;x(t.prototype,Gn),t.FunctionalRenderContext&&x(t.FunctionalRenderContext.prototype,Gn)}}(i),Ki(i);Vi(i,function(){Wi(i._render(),!0,c)},s)}}var eo=function(e){return/\.js(\?[^.]+)?$/.test(e)};function to(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var ro=function(e){function t(t,r,n){var i=e.call(this)||this;return i.started=!1,i.renderer=t,i.template=r,i.context=n||{},i.inject=t.inject,i}return ut(t,e),t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),no=require("lodash.template"),io={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function oo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var ao=require("path"),so=require("serialize-javascript"),co=function(){function e(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:no(e.slice(0,r),io),neck:no(e.slice(r,n),io),tail:no(e.slice(n+t.length),io)}}(t):t:null,this.serialize=e.serializer||function(e){return so(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(uo),this.prefetchFiles=(r.async||[]).map(uo),this.mapFiles=oo(r)}}return e.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},e.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},e.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},e.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},e.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},e.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},e.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},e.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey,i=void 0===n?"state":n,o=r.windowKey,a=void 0===o?"__INITIAL_STATE__":o,s=this.serialize(e[i]),c=e.nonce?' nonce="'+e.nonce+'"':"";return e[i]?"<script"+c+">window."+a+"="+s+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},e.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return eo(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return eo(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},e.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(uo)}return e._mappedFiles},e.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new ro(this,this.parsedTemplate,e||{})},e}();function uo(e){var t=e.replace(/\?.*/,""),r=ao.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:lo(r)}}function lo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}var fo=require("vm"),po=require("path"),vo=require("resolve"),ho=require("module");function mo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function yo(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=ho.wrap(r),o=new fo.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=po.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=vo.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function go(e,t,r,n){var i,o,a=yo(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,mo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?mo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(c(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var u=o._renderStyles;u&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return u(t._styles)}})}r(i(t))})}}var bo=require("source-map").SourceMapConsumer,_o=/\(([^)]+\.js):(\d+):(\d+)\)$/;function wo(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(_o),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(_o,c)}return e}return e}(e,t)}).join("\n"))}var xo=require("fs"),So=require("path"),$o=require("stream").PassThrough,Ao="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function ko(e){return void 0===e&&(e={}),function(e){var t=void 0===e?{}:e,r=t.modules,n=void 0===r?[]:r,i=t.directives,o=void 0===i?{}:i,a=t.isUnaryTag,s=void 0===a?function(){return!1}:a,c=t.template,u=t.inject,l=t.cache,f=t.shouldPreload,p=t.shouldPrefetch,d=t.clientManifest,v=t.serializer,h=Yi(n,o,s,l),m=new co({template:c,inject:u,shouldPreload:f,shouldPrefetch:p,clientManifest:d,serializer:v});return{renderToString:function(e,t,r){var n,i;"function"==typeof t&&(r=t,t={}),t&&m.bindRenderFns(t),r||(i=(n=to()).promise,r=n.cb);var o="",a=dt(function(e){return o+=e,!1},r);try{h(e,a,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),c)try{var n=m.render(o,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,o)})}catch(e){r(e)}return i},renderToStream:function(e,t){t&&m.bindRenderFns(t);var r=new vt(function(r,n){h(e,r,t,n)});if(c){if("function"==typeof c)throw new Error("function template is only supported in renderToString.");var n=m.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var i=t.rendered;r.once("beforeEnd",function(){i(t)})}return n}if(t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return r}}}(x(x({},e),{isUnaryTag:ot,canBeLeftOpenTag:at,modules:tt,directives:x(it,e.directives)}))}process.env.VUE_ENV="server";var Oo=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&So.isAbsolute(t)){if(!xo.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||So.dirname(t),t=xo.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new bo(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(Ao)}else{if("string"!=typeof t)throw new Error(Ao);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=go(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=to()).promise,t=r.cb),u(e).catch(function(e){wo(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){wo(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new $o;return u(e).catch(function(e){wo(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){wo(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(ko);exports.createBundleRenderer=Oo,exports.createRenderer=ko;
\ No newline at end of file
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream");function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var r=t(require("he")),n=Object.freeze({});function i(e){return null==e}function o(e){return null!=e}function a(e){return!0===e}function s(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function c(e){return null!==e&&"object"==typeof e}var u=Object.prototype.toString;function l(e){return"[object Object]"===u.call(e)}function f(e){return null==e?"":Array.isArray(e)||l(e)&&e.toString===u?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var b=/-(\w)/g,_=g(function(e){return e.replace(b,function(e,t){return t?t.toUpperCase():""})}),w=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),x=/\B([A-Z])/g,S=g(function(e){return e.replace(x,"-$1").toLowerCase()});function $(e,t){for(var r in t)e[r]=t[r];return e}function k(e){for(var t={},r=0;r<e.length;r++)e[r]&&$(t,e[r]);return t}function A(e,t,r){}var O=function(e,t,r){return!1},C=function(e){return e};function T(e,t){if(e===t)return!0;var r=c(e),n=c(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return T(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),s=Object.keys(t);return a.length===s.length&&a.every(function(r){return T(e[r],t[r])})}catch(e){return!1}}function F(e,t){for(var r=0;r<e.length;r++)if(T(e[r],t))return r;return-1}var j=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),P=function(e){return j(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},E={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},N={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function I(e){return e.replace(/[<>"&]/g,L)}function L(e){return N[e]||e}var M={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},R=d("input,textarea,option,select,progress"),D=d("contenteditable,draggable,spellcheck"),z=d("events,caret,typing,plaintext-only"),U=function(e,t){return B(t)||"false"===t?"false":"contenteditable"===e&&z(t)?t:"true"},q=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),B=function(e){return null==e||!1===e},J=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),H=/[>/="'\u0009\u000a\u000c\u0020]/,K=function(e){return H.test(e)},V=function(e){return J(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},W={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},Z={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function X(e){return e.replace(/[<>"&]/g,G)}function G(e){return Z[e]||e}var Q={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0};function Y(e,t){if(q(e)){if(!B(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+I(U(e,t))+'"';if(!B(t))return" "+e+'="'+I(String(t))+'"'}return""}var ee=function(){function e(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),te=function(e){void 0===e&&(e="");var t=new ee;return t.text=e,t.isComment=!0,t};function re(e){return new ee(void 0,void 0,void 0,String(e))}function ne(e,t,r){var n=new ee(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ie(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var oe="__proto__"in{},ae="undefined"!=typeof window,se="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,ce=(se&&WXEnvironment.platform.toLowerCase(),ae&&window.navigator.userAgent.toLowerCase()),ue=ce&&/msie|trident/.test(ce);ce&&ce.indexOf("msie 9.0");ce&&ce.indexOf("edge/");ce&&ce.indexOf("android"),ce&&/iphone|ipad|ipod|ios/.test(ce),ce&&/chrome\/\d+/.test(ce),ce&&/phantomjs/.test(ce),ce&&ce.match(/firefox\/(\d+)/);var le,fe={}.watch;if(ae)try{var pe={};Object.defineProperty(pe,"passive",{get:function(){!0}}),window.addEventListener("test-passive",null,pe)}catch(e){}var de=function(){return void 0===le&&(le=!ae&&!se&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),le};function ve(e){return"function"==typeof e&&/native code/.test(e.toString())}var he,me="undefined"!=typeof Symbol&&ve(Symbol)&&"undefined"!=typeof Reflect&&ve(Reflect.ownKeys);he="undefined"!=typeof Set&&ve(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ye="data-server-rendered",ge=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],be={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:O,isReservedAttr:O,isUnknownElement:O,getTagNamespace:A,parsePlatformTagName:C,mustUseProp:O,async:!0,_lifecycleHooks:ge},_e=0,we=function(){function e(){this.id=_e++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){!function(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)e.splice(r,1)}}(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},e}();we.target=null;var xe=[];function Se(e){xe.push(e),we.target=e}function $e(){xe.pop(),we.target=xe[xe.length-1]}var ke=Array.prototype,Ae=Object.create(ke);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=ke[e];ie(Ae,e,function(){for(var r=arguments,n=[],i=0;i<arguments.length;i++)n[i]=r[i];var o,a=t.apply(this,n),s=this.__ob__;switch(e){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var Oe=Object.getOwnPropertyNames(Ae),Ce=!0;function Te(e){Ce=e}var Fe=function(){function e(e){var t;this.value=e,this.dep=new we,this.vmCount=0,ie(e,"__ob__",this),Array.isArray(e)?(oe?(t=Ae,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ie(e,o,t[o])}}(e,Ae,Oe),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Pe(e,t[r])},e.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)je(e[t])},e}();function je(e,t){var r;if(c(e)&&!(e instanceof ee))return y(e,"__ob__")&&e.__ob__ instanceof Fe?r=e.__ob__:Ce&&!de()&&(Array.isArray(e)||l(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Fe(e)),t&&r&&r.vmCount++,r}function Pe(e,t,r,n,i){var o=new we,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&je(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return we.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&je(t),o.notify())}})}}function Ee(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Pe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}var Ne=be.optionMergeStrategies;function Ie(e,t){if(!t)return e;for(var r,n,i,o=me?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],y(e,r)?n!==i&&l(n)&&l(i)&&Ie(n,i):Ee(e,r,i));return e}function Le(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ie(n,i):i}:t?e?function(){return Ie("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Me(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Re(e,t,r,n){var i=Object.create(e||null);return t?$(i,t):i}Ne.data=function(e,t,r){return r?Le(e,t,r):t&&"function"!=typeof t?e:Le(e,t)},ge.forEach(function(e){Ne[e]=Me}),["component","directive","filter"].forEach(function(e){Ne[e+"s"]=Re}),Ne.watch=function(e,t,r,n){if(e===fe&&(e=void 0),t===fe&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in $(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ne.props=Ne.methods=Ne.inject=Ne.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return $(i,e),t&&$(i,t),i},Ne.provide=Le;var De=function(e,t){return void 0===t?e:t};function ze(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[_(i)]={type:null});else if(l(r))for(var a in r)i=r[a],o[_(a)]=l(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(l(r))for(var o in r){var a=r[o];n[o]=l(a)?$({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=ze(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=ze(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)y(e,o)||s(o);function s(n){var i=Ne[n]||De;a[n]=i(e[n],t[n],r,n)}return a}function Ue(e,t,r,n){if("string"==typeof r){var i=e[t];if(y(i,r))return i[r];var o=_(r);if(y(i,o))return i[o];var a=w(o);return y(i,a)?i[a]:i[r]||i[o]||i[a]}}function qe(e,t,r,n){var i=t[e],o=!y(r,e),a=r[e],s=Ke(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===S(e)){var c=Ke(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!y(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Je(t.type)?n.call(e):n}(n,i,e);var u=Ce;Te(!0),je(a),Te(u)}return a}var Be=/^\s*function (\w+)/;function Je(e){var t=e&&e.toString().match(Be);return t?t[1]:""}function He(e,t){return Je(e)===Je(t)}function Ke(e,t){if(!Array.isArray(t))return He(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(He(t[r],e))return r;return-1}function Ve(e,t,r){Se();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){Ze(e,n,"errorCaptured hook")}}Ze(e,t,r)}finally{$e()}}function We(e,t,r,n,i){var a,s;try{(a=r?e.apply(t,r):e.call(t))&&!a._isVue&&(o(s=a)&&"function"==typeof s.then&&"function"==typeof s.catch)&&!a._handled&&(a.catch(function(e){return Ve(e,n,i+" (Promise/async)")}),a._handled=!0)}catch(e){Ve(e,n,i)}return a}function Ze(e,t,r){!function(e,t,r){if(!ae&&!se||"undefined"==typeof console)throw e;console.error(e)}(e)}var Xe=[];if("undefined"!=typeof Promise&&ve(Promise));else if(ue||"undefined"==typeof MutationObserver||!ve(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&ve(setImmediate);else{var Ge=new MutationObserver(function(){var e=Xe.slice(0);Xe.length=0;for(var t=0;t<e.length;t++)e[t]()}),Qe=document.createTextNode(String(1));Ge.observe(Qe,{characterData:!0})}function Ye(e,t){return{staticClass:tt(e.staticClass,t.staticClass),class:o(e.class)?[e.class,t.class]:t.class}}function et(e,t){return o(e)||o(t)?tt(e,rt(t)):""}function tt(e,t){return e?t?e+" "+t:e:t||""}function rt(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,i=e.length;n<i;n++)o(t=rt(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):c(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var nt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),it=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var ot=g(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function at(e){var t=st(e.style);return e.staticStyle?$(e.staticStyle,t):t}function st(e){return Array.isArray(e)?k(e):"string"==typeof e?ot(e):e}function ct(e,t){return"string"==typeof t||"number"==typeof t&&M[e]||0===t?e+":"+t+";":""}var ut=[function(e){var t=e.data.attrs,r="",n=e.parent&&e.parent.componentOptions;if(i(n)||!1!==n.Ctor.options.inheritAttrs)for(var a=e.parent;o(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)o(a.data)&&o(a.data.attrs)&&(t=$($({},t),a.data.attrs)),a=a.parent;if(i(t))return r;for(var s in t)K(s)||"style"!==s&&(r+=Y(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",n=e.parent;o(n);)n.data&&n.data.domProps&&(t=$($({},t),n.data.domProps)),n=n.parent;if(i(t))return r;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)ne(e,t[s],!0);else if("textContent"===s)ne(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)ne(e,f(t[s]),!1);else{var c=E[s]||s.toLowerCase();!P(c)||o(a)&&o(a[c])||(r+=Y(c,t[s]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;o(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Ye(n.data,t));for(;o(r=r.parent);)r&&r.data&&(t=Ye(t,r.data));return et(t.staticClass,t.class)}(e);if(""!==t)return' class="'+I(t)+'"'},function(e){var t=function(e){var t="";for(var r in e){var n=e[r],i=S(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ct(i,n[o]);else t+=ct(i,n)}return t}(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=at(i.data))&&$(n,r);(r=at(e.data))&&$(n,r);for(var o=e;o=o.parent;)o.data&&(r=at(o.data))&&$(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(I(t))}];function lt(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function ft(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var pt={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&F(r,lt(a))>-1&&ft(a);else if(T(r,lt(a)))return void ft(a)}}},dt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),vt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ht=function(e,t){return(ht=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(e[r]=t[r])})(e,t)};function mt(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function r(){this.constructor=e}ht(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}var yt=800,gt=function(e){return e},bt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:gt;if(bt===gt)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function _t(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=yt?bt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var wt=function(e){function t(t){var r=e.call(this)||this;return r.buffer="",r.render=t,r.expectedSize=0,r.write=_t(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),r.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)},r}return mt(t,e),t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,a(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):i(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),xt=function(){function e(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&St(t,"get"),this.has=t&&St(t,"has"),this.next=this.next.bind(this)}return e.prototype.next=function(){for(var e=function(){var e=t.renderStates[t.renderStates.length-1];if(i(e))return{value:t.done()};switch(e.type){case"Element":case"Fragment":var r=e.children,n=e.total,o=e.rendered++;if(o<n)return{value:t.renderNode(r[o],!1,t)};if(t.renderStates.pop(),"Element"===e.type)return{value:t.write(e.endTag,t.next)};break;case"Component":t.renderStates.pop(),t.activeInstance=e.prevActive;break;case"ComponentWithCache":t.renderStates.pop();var a=e.buffer,s=e.bufferIndex,c=e.componentBuffer,u=e.key,l={html:a[s],components:c[s]};if(t.cache.set(u,l),0===s)t.write.caching=!1;else{a[s-1]+=l.html;var f=c[s-1];l.components.forEach(function(e){return f.add(e)})}a.length=s,c.length=s}},t=this;;){var r=e();if("object"==typeof r)return r.value}},e}();function St(e,t){var r=e[t];return i(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}var $t=/[\w).+\-_$\]]/;function kt(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&$t.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=At(i,o[n]);return i}function At(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var Ot=/\{\{((?:.|\r?\n)+?)\}\}/g,Ct=/[-.*+?^${}()|[\]\/\\]/g,Tt=g(function(e){var t=e[0].replace(Ct,"\\$&"),r=e[1].replace(Ct,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function Ft(e,t){console.error("[Vue compiler]: "+e)}function jt(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Pt(e,t,r,n,i){(e.props||(e.props=[])).push(Ut({name:t,value:r,dynamic:i},n)),e.plain=!1}function Et(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ut({name:t,value:r,dynamic:i},n)),e.plain=!1}function Nt(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Ut({name:t,value:r},n))}function It(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Ut({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Mt(e,t,r,i,o,a,s,c){var u;(i=i||n).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Lt("!",t,c)),i.once&&(delete i.once,t=Lt("~",t,c)),i.passive&&(delete i.passive,t=Lt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Ut({value:r.trim(),dynamic:c},s);i!==n&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function Rt(e,t,r){var n=Dt(e,":"+t)||Dt(e,"v-bind:"+t);if(null!=n)return kt(n);if(!1!==r){var i=Dt(e,t);if(null!=i)return JSON.stringify(i)}}function Dt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function zt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Ut(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var qt={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Dt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=Rt(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Bt,Jt,Ht,Kt,Vt,Wt,Zt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Dt(e,"style");r&&(e.staticStyle=JSON.stringify(ot(r)));var n=Rt(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Xt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),Gt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Qt=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Yt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,er=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,tr="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",rr="((?:"+tr+"\\:)?"+tr+")",nr=new RegExp("^<"+rr),ir=/^\s*(\/?)>/,or=new RegExp("^<\\/"+rr+"[^>]*>"),ar=/^<!DOCTYPE [^>]+>/i,sr=/^<!\--/,cr=/^<!\[/,ur=d("script,style,textarea",!0),lr={},fr={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},pr=/&(?:lt|gt|quot|amp|#39);/g,dr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,vr=d("pre,textarea",!0),hr=function(e,t){return e&&vr(e)&&"\n"===t[0]};function mr(e,t){var r=t?dr:pr;return e.replace(r,function(e){return fr[e]})}function yr(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||O,s=t.canBeLeftOpenTag||O,c=0,u=function(){if(r=e,n&&ur(n)){var u=0,p=n.toLowerCase(),d=lr[p]||(lr[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));x=e.replace(d,function(e,r,n){return u=n.length,ur(p)||"noscript"===p||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),hr(p,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-x.length,e=x,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(sr.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(cr.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(ar);if(y)return l(y[0].length),"continue";var g=e.match(or);if(g){var b=c;return l(g[0].length),f(g[1],b,c),"continue"}var _=function(){var t=e.match(nr);if(t){var r={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var n=void 0,i=void 0;!(n=e.match(ir))&&(i=e.match(er)||e.match(Yt));)i.start=c,l(i[0].length),i.end=c,r.attrs.push(i);if(n)return r.unarySlash=n[1],l(n[0].length),r.end=c,r}}();if(_)return function(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&Qt(r)&&f(n),s(r)&&n===r&&f(r));for(var u=a(r)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===r&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:mr(h,m)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=r);t.start&&t.start(r,p,u,e.start,e.end)}(_),hr(_.tagName,e)&&l(1),"continue"}var w=void 0,x=void 0,S=void 0;if(v>=0){for(x=e.slice(v);!(or.test(x)||nr.test(x)||sr.test(x)||cr.test(x)||(S=x.indexOf("<",1))<0);)v+=S,x=e.slice(v);w=e.substring(0,v)}v<0&&(w=e),w&&l(w.length),t.chars&&w&&t.chars(w,c-w.length,c)}if(e===r)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}f()}function gr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function br(e,t){var r=function(e){if(e=e.trim(),Bt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Bt-1)return(Kt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Kt),key:'"'+e.slice(Kt+1)+'"'}:{exp:e,key:null};Jt=e,Kt=Vt=Wt=0;for(;!wr();)xr(Ht=_r())?$r(Ht):91===Ht&&Sr(Ht);return{exp:e.slice(0,Vt),key:e.slice(Vt+1,Wt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function _r(){return Jt.charCodeAt(++Kt)}function wr(){return Kt>=Bt}function xr(e){return 34===e||39===e}function Sr(e){var t=1;for(Vt=Kt;!wr();)if(xr(e=_r()))$r(e);else if(91===e&&t++,93===e&&t--,0===t){Wt=Kt;break}}function $r(e){for(var t=e;!wr()&&(e=_r())!==t;);}var kr,Ar,Or,Cr,Tr,Fr,jr,Pr,Er=/^@|^v-on:/,Nr=/^v-|^@|^:|^#/,Ir=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Lr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Mr=/^\(|\)$/g,Rr=/^\[.*\]$/,Dr=/:(.*)$/,zr=/^:|^\.|^v-bind:/,Ur=/\.[^.\]]+(?=[^\]]*$)/g,qr=/^v-slot(:|$)|^#/,Br=/[\r\n]/,Jr=/[ \f\t\r\n]+/g,Hr=g(r.default.decode),Kr="_empty_";function Vr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:en(t),rawAttrsMap:{},parent:r,children:[]}}function Wr(e,t){kr=t.warn||Ft,Fr=t.isPreTag||O,jr=t.mustUseProp||O,Pr=t.getTagNamespace||O,t.isReservedTag,Or=jt(t.modules,"transformNode"),Cr=jt(t.modules,"preTransformNode"),Tr=jt(t.modules,"postTransformNode"),Ar=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=Zr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Gr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Gr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Fr(e.tag)&&(c=!1);for(var f=0;f<Tr.length;f++)Tr[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return yr(e,{warn:kr,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||Pr(e);ue&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];tn.test(n.name)||(n.name=n.name.replace(rn,""),t.push(n))}return t}(o));var d,v=Vr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||de()||(v.forbidden=!0);for(var h=0;h<Cr.length;h++)v=Cr[h](v,t)||v;s||(!function(e){null!=Dt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Fr(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Xr(v),function(e){var t=Dt(e,"v-if");if(t)e.if=t,Gr(e,{exp:t,block:e});else{null!=Dt(e,"v-else")&&(e.else=!0);var r=Dt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Dt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!ue||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Hr(e):u.length?a?"condense"===a&&Br.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(Jr," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var r=t?Tt(t):Ot;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=kt(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Ar))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function Zr(e,t){var r,n;(n=Rt(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Rt(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dt(e,"scope"),e.slotScope=t||Dt(e,"slot-scope")):(t=Dt(e,"slot-scope"))&&(e.slotScope=t);var r=Rt(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Et(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=zt(e,qr);if(n){var i=Qr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Kr}}else{var n=zt(e,qr);if(n){var s=e.scopedSlots||(e.scopedSlots={}),c=Qr(n),u=c.name,a=c.dynamic,l=s[u]=Vr("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=n.value||Kr,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Rt(e,"name"))}(e),function(e){var t;(t=Rt(e,"is"))&&(e.component=t);null!=Dt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Or.length;i++)e=Or[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Nr.test(n))if(e.hasBindings=!0,(a=Yr(n.replace(Nr,"")))&&(n=n.replace(Ur,"")),zr.test(n))n=n.replace(zr,""),o=kt(o),(c=Rr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=_(n))&&(n="innerHTML"),a.camel&&!c&&(n=_(n)),a.sync&&(s=br(o,"$event"),c?Mt(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Mt(e,"update:"+_(n),s,null,!1,0,u[t]),S(n)!==_(n)&&Mt(e,"update:"+S(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&jr(e.tag,e.attrsMap.type,n)?Pt(e,n,o,u[t],c):Et(e,n,o,u[t],c);else if(Er.test(n))n=n.replace(Er,""),(c=Rr.test(n))&&(n=n.slice(1,-1)),Mt(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Nr,"")).match(Dr),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Rr.test(f)&&(f=f.slice(1,-1),c=!0)),It(e,n,i,o,f,c,a,u[t])}else Et(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&jr(e.tag,e.attrsMap.type,n)&&Pt(e,n,"true",u[t])}(e),e}function Xr(e){var t;if(t=Dt(e,"v-for")){var r=function(e){var t=e.match(Ir);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(Mr,""),i=n.match(Lr);i?(r.alias=n.replace(Lr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&$(e,r)}}function Gr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Qr(e){var t=e.name.replace(qr,"");return t||"#"!==e.name[0]&&(t="default"),Rr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Yr(e){var t=e.match(Ur);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function en(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var tn=/^xmlns:NS\d+/,rn=/^NS\d+:/;function nn(e){return Vr(e.tag,e.attrsList.slice(),e.parent)}var on=[qt,Zt,{preTransformNode:function(e,t){if("input"===e.tag){var r=e.attrsMap;if(!r["v-model"])return;var n=void 0;if((r[":type"]||r["v-bind:type"])&&(n=Rt(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Dt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Dt(e,"v-else",!0),s=Dt(e,"v-else-if",!0),c=nn(e);Xr(c),Nt(c,"type","checkbox"),Zr(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,Gr(c,{exp:c.if,block:c});var u=nn(e);Dt(u,"v-for",!0),Nt(u,"type","radio"),Zr(u,t),Gr(c,{exp:"("+n+")==='radio'"+o,block:u});var l=nn(e);return Dt(l,"v-for",!0),Nt(l,":type",n),Zr(l,t),Gr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],an="__r";var sn={expectHTML:!0,modules:on,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return gr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mt(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=Rt(e,"value")||"null",o=Rt(e,"true-value")||"true",a=Rt(e,"false-value")||"false";Pt(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mt(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+br(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=Rt(e,"value")||"null";Pt(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Mt(e,"change",br(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return gr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?an:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=br(t,l);c&&(f="if($event.target.composing)return;"+f),Pt(e,"value","("+t+")"),Mt(e,u,f,null,!0),(s||a)&&Mt(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&Pt(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Pt(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:Xt,mustUseProp:function(e,t,r){return"value"===r&&R(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:Gt,isReservedTag:function(e){return nt(e)||it(e)},getTagNamespace:function(e){return it(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(on)},cn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,un=/\([^)]*?\);*$/,ln=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,fn={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},pn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},dn=function(e){return"if("+e+")return null;"},vn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:dn("$event.target !== $event.currentTarget"),ctrl:dn("!$event.ctrlKey"),shift:dn("!$event.shiftKey"),alt:dn("!$event.altKey"),meta:dn("!$event.metaKey"),left:dn("'button' in $event && $event.button !== 0"),middle:dn("'button' in $event && $event.button !== 1"),right:dn("'button' in $event && $event.button !== 2")};function hn(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=mn(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function mn(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return mn(e)}).join(",")+"]";var t=ln.test(e.value),r=cn.test(e.value),n=ln.test(e.value.replace(un,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(vn[t])o+=vn[t],fn[t]&&a.push(t);else if("exact"===t){var r=e.modifiers;o+=dn(["ctrl","shift","alt","meta"].filter(function(e){return!r[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(yn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function yn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=fn[e],n=pn[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var gn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:A},bn=function(){return function(e){this.options=e,this.warn=e.warn||Ft,this.transforms=jt(e.modules,"transformCode"),this.dataGenFns=jt(e.modules,"genData"),this.directives=$($({},gn),e.directives);var t=e.isReservedTag||O;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function _n(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return wn(e,t);if(e.once&&!e.onceProcessed)return xn(e,t);if(e.for&&!e.forProcessed)return $n(e,t);if(e.if&&!e.ifProcessed)return Sn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=Cn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Pn((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:_(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r=void 0;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:Cn(t,r,!0);return"_c("+e+","+kn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=kn(e,t));var i=e.inlineTemplate?null:Cn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return Cn(e,t)||"void 0"}function wn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+_n(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function xn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Sn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+_n(e,t)+","+t.onceId+++","+r+")":_n(e,t)}return wn(e,t)}function Sn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?xn(e,r):_n(e,r)}}(e.ifConditions.slice(),t,r,n)}function $n(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||_n)(e,t)+"})"}function kn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+Pn(e.attrs)+","),e.props&&(r+="domProps:"+Pn(e.props)+","),e.events&&(r+=hn(e.events,!1)+","),e.nativeEvents&&(r+=hn(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||An(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Kr||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return On(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new bn(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":_n(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+Pn(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function An(e){return 1===e.type&&("slot"===e.tag||e.children.some(An))}function On(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return Sn(e,t,On,"null");if(e.for&&!e.forProcessed)return $n(e,t,On);var n=e.slotScope===Kr?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(Cn(e,t)||"undefined")+":undefined":Cn(e,t)||"undefined":_n(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Cn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||_n)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(Tn(i)||i.ifConditions&&i.ifConditions.some(function(e){return Tn(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||Fn;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Tn(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Fn(e,t){return 1===e.type?_n(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):jn(e);var r}function jn(e){return"_v("+(2===e.type?e.expression:En(JSON.stringify(e.text)))+")"}function Pn(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=En(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function En(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Nn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function In(e,t){return Nn.test(t)?(t=t.replace(/^'|'$/g,'"'),D(e)&&'"false"'!==t&&(t='"true"'),{type:zn,value:q(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:qn,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var Ln,Mn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Rn(e,t){e&&(Ln=t.isReservedTag||O,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!Ln(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=Mn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!Dn(e.name)})}(t);var i=function(e){e.ssrOptimizability!==Mn.FULL&&(t.ssrOptimizability=n?Mn.PARTIAL:Mn.SELF)};n&&(t.ssrOptimizability=Mn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++){var c=t.ifConditions[o].block;e(c,r),i(c)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=Mn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:Mn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===Mn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=Mn.FULL}(e,!0))}var Dn=d("text,html,show,on,bind,model,pre,cloak,once");var zn=0,Un=1,qn=2;function Bn(e,t){if(e.for&&!e.forProcessed)return $n(e,t,Bn);if(e.if&&!e.ifProcessed)return Sn(e,t,Bn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===Mn.FULL?Vn(e,t):Hn(e,t)||"void 0";switch(e.ssrOptimizability){case Mn.FULL:return function(e,t){return"_ssrNode("+Wn(e,t)+")"}(e,t);case Mn.SELF:return function(e,t){var r=Hn(e,t,!0);return"_ssrNode("+Qn(Xn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case Mn.CHILDREN:return Jn(e,t,!0);case Mn.PARTIAL:return Jn(e,t,!1);default:return _n(e,t)}}function Jn(e,t,r){var n=e.plain?void 0:kn(e,t),i=r?"["+Vn(e,t)+"]":Hn(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Hn(e,t,r){return Cn(e,t,r,Bn,Kn)}function Kn(e,t){return 1===e.type?Bn(e,t):jn(e)}function Vn(e,t){return e.children.length?"_ssrNode("+Qn(Gn(e,t))+")":""}function Wn(e,t){return"("+Qn(Zn(e,t))+")"}function Zn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:qn,value:$n(e,t,Wn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:qn,value:Sn(e,t,Wn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Gn(e,t);var r=Xn(e,t),n=Gn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:zn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Xn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:zn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return In(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=W[n]||n.toLowerCase(),!V(n)||t&&t.some(function(e){return e.name===n})||r.push(In(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:qn,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:qn,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:zn,value:' class="'+JSON.parse(n)+'"'}]:[{type:qn,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:qn,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:zn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:zn,value:" "+t.options.scopeId}),u.push({type:zn,value:">"}),u}function Gn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:qn,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Un,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Un,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,Zn(i,t));else if(2===i.type)r.push({type:Un,value:i.expression});else if(3===i.type){var o=X(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:zn,value:o})}}return r}(e.children,t):[]}function Qn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===zn?r+=o.value:o.type===Un?(n(),t.push("_ssrEscape("+o.value+")")):o.type===qn&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}function Yn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),A}}function ei(e){var t=Object.create(null);return function(r,n,i){(n=$({},n)).warn,delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Yn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Yn(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ti,ri=(ti=function(e,t){var r=Wr(e.trim(),t);Rn(r,t);var n=function(e,t){var r=new bn(t);return{render:"with(this){return "+(e?Bn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=$(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=ti(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:ei(t)}})(sn).compileToFunctions;function ni(e,t){if(q(e)){if(!B(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+X(U(e,t))+'"';if(!B(t))return" "+e+'="'+X(String(t))+'"'}return""}function ii(e,t){return"string"==typeof t||"number"==typeof t&&Q[e]||0===t?e+":"+t+";":""}function oi(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function ai(e){return s(e)?[re(e)]:Array.isArray(e)?function e(t,r){var n=[];var c,u,l,f;for(c=0;c<t.length;c++)i(u=t[c])||"boolean"==typeof u||(l=n.length-1,f=n[l],Array.isArray(u)?u.length>0&&(si((u=e(u,(r||"")+"_"+c))[0])&&si(f)&&(n[l]=re(f.text+u[0].text),u.shift()),n.push.apply(n,u)):s(u)?si(f)?n[l]=re(f.text+u):""!==u&&n.push(re(u)):si(u)&&si(f)?n[l]=re(f.text+u.text):(a(t._isVList)&&o(u.tag)&&i(u.key)&&o(r)&&(u.key="__vlist"+r+"_"+c+"__"),n.push(u)));return n}(e):void 0}function si(e){return o(e)&&o(e.text)&&!1===e.isComment}var ci={_ssrEscape:X,_ssrNode:function(e,t,r,n){return new ui(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(c(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:ni,_ssrAttrs:function(e){var t="";for(var r in e)K(r)||(t+=ni(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=W[r]||r.toLowerCase();V(n)&&(t+=ni(n,e[r]))}return t},_ssrClass:function(e,t){var r=et(e,t);return""===r?r:' class="'+X(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&$(n,e);t&&$(n,st(t));r&&$(n,r);var i=function(e){var t="";for(var r in e){var n=e[r],i=S(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ii(i,n[o]);else t+=ii(i,n)}return t}(n);return""===i?i:" style="+JSON.stringify(X(i))}};var ui=function(){return function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?oi(r):2===n?ai(r):r:void 0}}();var li=new he;function fi(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!c(t)||Object.isFrozen(t)||t instanceof ee)return;if(t.__ob__){var a=t.__ob__.dep.id;if(r.has(a))return;r.add(a)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,li),li.clear()}var pi=g(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function di(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return We(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)We(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function vi(e,t,r,n,i){if(o(t)){if(y(t,r))return e[r]=t[r],i||delete t[r],!0;if(y(t,n))return e[r]=t[n],i||delete t[n],!0}return!1}var hi,mi=1,yi=2;function gi(e,t,r,n,u,l){return(Array.isArray(r)||s(r))&&(u=n,n=r,r=void 0),a(l)&&(u=yi),function(e,t,r,n,s){if(o(r)&&o(r.__ob__))return te();o(r)&&o(r.is)&&(t=r.is);if(!t)return te();Array.isArray(n)&&"function"==typeof n[0]&&((r=r||{}).scopedSlots={default:n[0]},n.length=0);s===yi?n=ai(n):s===mi&&(n=oi(n));var u,l;if("string"==typeof t){var f=void 0;l=e.$vnode&&e.$vnode.ns||be.getTagNamespace(t),u=r&&r.pre||!o(f=Ue(e.$options,"components",t))?new ee(t,r,n,void 0,void 0,e):Gi(f,r,e,n,t)}else u=Gi(t,r,e,n);return Array.isArray(u)?u:o(u)?(o(l)&&function e(t,r,n){t.ns=r;"foreignObject"===t.tag&&(r=void 0,n=!0);if(o(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];o(u.tag)&&(i(u.ns)||a(n)&&"svg"!==u.tag)&&e(u,r,n)}}(u,l),o(r)&&function(e){c(e.style)&&fi(e.style);c(e.class)&&fi(e.class)}(r),u):te()}(e,t,r,n,u)}function bi(e,t){var r,n,i,a,s=null;if(Array.isArray(e)||"string"==typeof e)for(s=new Array(e.length),r=0,n=e.length;r<n;r++)s[r]=t(e[r],r);else if("number"==typeof e)for(s=new Array(e),r=0;r<e;r++)s[r]=t(r+1,r);else if(c(e))if(me&&e[Symbol.iterator]){s=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)s.push(t(l.value,s.length)),l=u.next()}else for(i=Object.keys(e),s=new Array(i.length),r=0,n=i.length;r<n;r++)a=i[r],s[r]=t(e[a],a,r);return o(s)||(s=[]),s._isVList=!0,s}function _i(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=$($({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function wi(e){return Ue(this.$options,"filters",e)||C}function xi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function Si(e,t,r,n,i){var o=be.keyCodes[t]||r;return i&&n&&!be.keyCodes[t]?xi(i,n):o?xi(o,e):n?S(n)!==t:void 0}function $i(e,t,r,n,i){if(r)if(c(r)){Array.isArray(r)&&(r=k(r));var o=void 0,a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||be.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=_(a),u=S(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var s in r)a(s)}else;return e}function ki(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(Oi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function Ai(e,t,r){return Oi(e,"__once__"+t+(r?"_"+r:""),!0),e}function Oi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&Ci(e[n],t+"_"+n,r);else Ci(e,t,r)}function Ci(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function Ti(e,t){if(t)if(l(t)){var r=e.on=e.on?$({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function Fi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Fi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function ji(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function Pi(e,t){return"string"==typeof e?t+e:e}function Ei(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Ni)&&delete r[u];return r}function Ni(e){return e.isComment&&!e.asyncFactory||" "===e.text}function Ii(e,t,r){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==n&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Li(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Mi(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ie(i,"$stable",a),ie(i,"$key",s),ie(i,"$hasNormal",o),i}function Li(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ai(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Mi(e,t){return function(){return e[t]}}function Ri(e,t){hi.$on(e,t)}function Di(e,t){hi.$off(e,t)}function zi(e,t){var r=hi;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ui(e,t,r){hi=e,function(e,t,r,n,o,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=pi(c),i(u)||(i(l)?(i(u.fns)&&(u=e[c]=di(u,s)),a(f.once)&&(u=e[c]=o(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)i(e[c])&&n((f=pi(c)).name,t[c],f.capture)}(t,r||{},Ri,Di,zi,e),hi=void 0}function qi(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Bi(e,t){Se();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)We(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),$e()}var Ji=Date.now;if(ae&&!ue){var Hi=window.performance;Hi&&"function"==typeof Hi.now&&Ji()>document.createEvent("Event").timeStamp&&(Ji=function(){return Hi.now()})}function Ki(e,t,r,i,o){var s,c=this,u=o.options;y(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=a(u._compiled),f=!l;this.data=e,this.props=t,this.children=r,this.parent=i,this.listeners=e.on||n,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=me?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||Ii(e.scopedSlots,c.$slots=Ei(r,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return Ii(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=Ii(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=gi(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return gi(s,e,t,r,n,f)}}function Vi(e,t,r,n,i){var o=function(e){var t=new ee(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Wi(e,t){for(var r in t)e[_(r)]=t[r]}!function(e){e._o=Ai,e._n=p,e._s=f,e._l=bi,e._t=_i,e._q=T,e._i=F,e._m=ki,e._f=wi,e._k=Si,e._b=$i,e._v=re,e._e=te,e._u=Fi,e._g=Ti,e._d=ji,e._p=Pi}(Ki.prototype);var Zi={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Zi.prepatch(r,r)}else{(e.componentInstance=Qi(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var r=t.componentOptions;!function(e,t,r,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==n&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||n,e.$listeners=r||n,t&&e.$options.props){Te(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=qe(d,v,t,e)}Te(!0),e.$options.propsData=t}r=r||n;var h=e.$options._parentListeners;e.$options._parentListeners=r,Ui(e,r,h),u&&(e.$slots=Ei(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,r.propsData,r.listeners,t,r.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Bi(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,qi(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Bi(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,qi(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Bi(t,"deactivated")}}(t,!0):t.$destroy())}},Xi=Object.keys(Zi);function Gi(e,t,r,s,u){if(!i(e)){var l=r.$options._base;if(c(e)&&(e=l.extend(e)),"function"==typeof e){var f,p;if(i(e.cid)&&void 0===(e=a((p=f=e).error)&&o(p.errorComp)?p.errorComp:o(p.resolved)?p.resolved:a(p.loading)&&o(p.loadingComp)?p.loadingComp:void 0))return function(e,t,r,n,i){var o=te();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(f,t,r,s,u);t=t||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&$(t.extendOptions,i),(r=t.options=ze(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),o(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var i=t.on||(t.on={}),a=i[n],s=t.model.callback;o(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[n]=[s].concat(a)):i[n]=s}(e.options,t);var d=function(e,t,r){var n=t.options.props;if(!i(n)){var a={},s=e.attrs,c=e.props;if(o(s)||o(c))for(var u in n){var l=S(u);vi(a,c,u,l,!0)||vi(a,s,u,l,!1)}return a}}(t,e);if(a(e.options.functional))return function(e,t,r,i,a){var s=e.options,c={},u=s.props;if(o(u))for(var l in u)c[l]=qe(l,u,t||n);else o(r.attrs)&&Wi(c,r.attrs),o(r.props)&&Wi(c,r.props);var f=new Ki(r,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof ee)return Vi(p,r,f.parent,s);if(Array.isArray(p)){for(var d=ai(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Vi(d[h],r,f.parent,s);return v}}(e,d,t,r,s);var v=t.on;if(t.on=t.nativeOn,a(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Xi.length;r++){var n=Xi[r],i=t[n],o=Zi[n];i===o||i&&i._merged||(t[n]=i?Yi(o,i):o)}}(t);var m=e.options.name||u;return new ee("vue-component-"+e.cid+(m?"-"+m:""),t,void 0,void 0,void 0,r,{Ctor:e,propsData:d,listeners:v,tag:u,children:s},f)}}}function Qi(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return o(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function Yi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var eo=Object.create(null),to=function(e){eo[e]||(eo[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},ro=function(e,t){var r=t?(void 0)():"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},no=function(e){var t=e.$options,r=t.render,n=t.template,o=t._scopeId;if(i(r)){if(!n)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=ri(n,{scopeId:o,warn:ro},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function io(e,t,r){var n=e.$options.serverPrefetch;if(o(n)){Array.isArray(n)||(n=[n]);try{for(var i=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&i.push(c)}return void Promise.all(i).then(t).catch(r)}catch(e){r(e)}}t()}function oo(e,t,r){e.isString?function(e,t){var r=t.write,n=t.next;if(i(e.children)||0===e.children.length)r(e.open+(e.close||""),n);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,n)}}(e,r):o(e.componentOptions)?so(e,t,r):o(e.tag)?function(e,t,r){var n=r.write,s=r.next;a(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[ye]="true");e.fnOptions&&ao(e.fnOptions,n);var c=function(e,t){var r,n="<"+e.tag,a=t.directives,s=t.modules;i(e.data)&&function e(t){var r=t.parent;return o(r)&&(o(r.data)||e(r))}(e)&&(e.data={});if(o(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=Ue(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;o(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var u=0;u<s.length;u++){var d=s[u](e);d&&(n+=d)}}var v=t.activeInstance;o(v)&&v!==e.context&&o(r=v.$options._scopeId)&&(n+=" "+r);if(o(e.fnScopeId))n+=" "+e.fnScopeId;else for(;o(e);)o(r=e.context.$options._scopeId)&&(n+=" "+r),e=e.parent;return n+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))n(c,s);else if(i(e.children)||0===e.children.length)n(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),n(c,s)}}(e,t,r):a(e.isComment)?o(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=Gi(n,o,c,a,s);u?u.componentOptions?so(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):oo(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:X(String(e.text)),r.next)}function ao(e,t){var r=e._ssrRegister;return t.caching&&o(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function so(e,t,r){var n=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=ao(c.options,n);if(o(u)&&o(f)&&o(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void uo(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;o(h)?h(v,function(i){!0===i&&o(m)?m(v,function(e){o(p)&&p(s),e.components.forEach(function(e){return e(s)}),n(e.html,a)}):co(e,t,v,r)}):o(m)&&m(v,function(i){o(i)?(o(p)&&p(s),i.components.forEach(function(e){return e(s)}),n(i.html,a)):co(e,t,v,r)})}else o(u)&&i(f)&&to("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),o(u)&&i(l)&&to('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),uo(e,t,r)}function co(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),uo(e,t,n)}function uo(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Qi(e,r.activeInstance);no(i);var o=r.done;io(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),oo(o,t,r)},o)}function lo(e,t,r,n){return function(i,o,a,s){eo=Object.create(null);var c=new xt({activeInstance:i,userContext:a,write:o,done:s,renderNode:oo,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;$(t.prototype,ci),t.FunctionalRenderContext&&$(t.FunctionalRenderContext.prototype,ci)}}(i),no(i);io(i,function(){oo(i._render(),!0,c)},s)}}var fo=function(e){return/\.js(\?[^.]+)?$/.test(e)};function po(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var vo=function(e){function t(t,r,n){var i=e.call(this)||this;return i.started=!1,i.renderer=t,i.template=r,i.context=n||{},i.inject=t.inject,i}return mt(t,e),t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),ho=require("lodash.template"),mo={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function yo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var go=require("path"),bo=require("serialize-javascript"),_o=function(){function e(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:ho(e.slice(0,r),mo),neck:ho(e.slice(r,n),mo),tail:ho(e.slice(n+t.length),mo)}}(t):t:null,this.serialize=e.serializer||function(e){return bo(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(wo),this.prefetchFiles=(r.async||[]).map(wo),this.mapFiles=yo(r)}}return e.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},e.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},e.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},e.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},e.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},e.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},e.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},e.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey,i=void 0===n?"state":n,o=r.windowKey,a=void 0===o?"__INITIAL_STATE__":o,s=this.serialize(e[i]),c=e.nonce?' nonce="'+e.nonce+'"':"";return e[i]?"<script"+c+">window."+a+"="+s+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},e.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return fo(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return fo(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},e.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(wo)}return e._mappedFiles},e.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new vo(this,this.parsedTemplate,e||{})},e}();function wo(e){var t=e.replace(/\?.*/,""),r=go.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:xo(r)}}function xo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}var So=require("vm"),$o=require("path"),ko=require("resolve"),Ao=require("module");function Oo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function Co(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=Ao.wrap(r),o=new So.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=$o.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=ko.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function To(e,t,r,n){var i,o,a=Co(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,Oo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?Oo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(l(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))})}}var Fo=require("source-map").SourceMapConsumer,jo=/\(([^)]+\.js):(\d+):(\d+)\)$/;function Po(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(jo),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(jo,c)}return e}return e}(e,t)}).join("\n"))}var Eo=require("fs"),No=require("path"),Io=require("stream").PassThrough,Lo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Mo(e){return void 0===e&&(e={}),t=$($({},e),{isUnaryTag:dt,canBeLeftOpenTag:vt,modules:ut,directives:$(pt,e.directives)}),n=(r=void 0===t?{}:t).modules,i=void 0===n?[]:n,o=r.directives,a=void 0===o?{}:o,s=r.isUnaryTag,c=void 0===s?function(){return!1}:s,u=r.template,l=r.inject,f=r.cache,p=r.shouldPreload,d=r.shouldPrefetch,v=r.clientManifest,h=r.serializer,m=lo(i,a,c,f),y=new _o({template:u,inject:l,shouldPreload:p,shouldPrefetch:d,clientManifest:v,serializer:h}),{renderToString:function(e,t,r){var n,i;"function"==typeof t&&(r=t,t={}),t&&y.bindRenderFns(t),r||(i=(n=po()).promise,r=n.cb);var o="",a=_t(function(e){return o+=e,!1},r);try{m(e,a,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),u)try{var n=y.render(o,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,o)})}catch(e){r(e)}return i},renderToStream:function(e,t){t&&y.bindRenderFns(t);var r=new wt(function(r,n){m(e,r,t,n)});if(u){if("function"==typeof u)throw new Error("function template is only supported in renderToString.");var n=y.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var i=t.rendered;r.once("beforeEnd",function(){i(t)})}return n}if(t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return r}};var t,r,n,i,o,a,s,c,u,l,f,p,d,v,h,m,y}process.env.VUE_ENV="server";var Ro=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&No.isAbsolute(t)){if(!Eo.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||No.dirname(t),t=Eo.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new Fo(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(Lo)}else{if("string"!=typeof t)throw new Error(Lo);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=To(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=po()).promise,t=r.cb),u(e).catch(function(e){Po(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){Po(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new Io;return u(e).catch(function(e){Po(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){Po(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(Mo);exports.createBundleRenderer=Ro,exports.createRenderer=Mo;
\ No newline at end of file
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index 48749570b3d..e90685dc0cc 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -193,11 +193,11 @@
           .join(',');
   }
 
-  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+  makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
   var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -1463,9 +1463,9 @@
           (attr === 'checked' && tag === 'input') ||
           (attr === 'muted' && tag === 'video'));
   };
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  makeMap('contenteditable,draggable,spellcheck');
   makeMap('events,caret,typing,plaintext-only');
-  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+  makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
       'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
       'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
       'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
@@ -1919,6 +1919,354 @@
       genData: genData$1,
   };
 
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function createCommonjsModule(fn) {
+    var module = { exports: {} };
+  	return fn(module, module.exports), module.exports;
+  }
+
+  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+
+  var he = createCommonjsModule(function (module, exports) {
+  (function(root) {
+
+  	// Detect free variables `exports`.
+  	var freeExports = exports;
+
+  	// Detect free variable `module`.
+  	var freeModule = module &&
+  		module.exports == freeExports && module;
+
+  	// Detect free variable `global`, from Node.js or Browserified code,
+  	// and use it as `root`.
+  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+  		root = freeGlobal;
+  	}
+
+  	/*--------------------------------------------------------------------------*/
+
+  	// All astral symbols.
+  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  	// All ASCII symbols (not just printable ASCII) except those listed in the
+  	// first column of the overrides table.
+  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
+  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+  	// code points listed in the first column of the overrides table on
+  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+  	var regexEscape = /["&'<>`]/g;
+  	var escapeMap = {
+  		'"': '&quot;',
+  		'&': '&amp;',
+  		'\'': '&#x27;',
+  		'<': '&lt;',
+  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+  		// following is not strictly necessary unless it’s part of a tag or an
+  		// unquoted attribute value. We’re only escaping it to support those
+  		// situations, and for XML support.
+  		'>': '&gt;',
+  		// In Internet Explorer ≤ 8, the backtick character can be used
+  		// to break out of (un)quoted attribute values or HTML comments.
+  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
+  		// http://html5sec.org/#133.
+  		'`': '&#x60;'
+  	};
+
+  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var stringFromCharCode = String.fromCharCode;
+
+  	var object = {};
+  	var hasOwnProperty = object.hasOwnProperty;
+  	var has = function(object, propertyName) {
+  		return hasOwnProperty.call(object, propertyName);
+  	};
+
+  	var contains = function(array, value) {
+  		var index = -1;
+  		var length = array.length;
+  		while (++index < length) {
+  			if (array[index] == value) {
+  				return true;
+  			}
+  		}
+  		return false;
+  	};
+
+  	var merge = function(options, defaults) {
+  		if (!options) {
+  			return defaults;
+  		}
+  		var result = {};
+  		var key;
+  		for (key in defaults) {
+  			// A `hasOwnProperty` check is not needed here, since only recognized
+  			// option names are used anyway. Any others are ignored.
+  			result[key] = has(options, key) ? options[key] : defaults[key];
+  		}
+  		return result;
+  	};
+
+  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
+  	var codePointToSymbol = function(codePoint, strict) {
+  		var output = '';
+  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+  			// See issue #4:
+  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+  			// REPLACEMENT CHARACTER.”
+  			if (strict) {
+  				parseError('character reference outside the permissible Unicode range');
+  			}
+  			return '\uFFFD';
+  		}
+  		if (has(decodeMapNumeric, codePoint)) {
+  			if (strict) {
+  				parseError('disallowed character reference');
+  			}
+  			return decodeMapNumeric[codePoint];
+  		}
+  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+  			parseError('disallowed character reference');
+  		}
+  		if (codePoint > 0xFFFF) {
+  			codePoint -= 0x10000;
+  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+  			codePoint = 0xDC00 | codePoint & 0x3FF;
+  		}
+  		output += stringFromCharCode(codePoint);
+  		return output;
+  	};
+
+  	var hexEscape = function(codePoint) {
+  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+  	};
+
+  	var decEscape = function(codePoint) {
+  		return '&#' + codePoint + ';';
+  	};
+
+  	var parseError = function(message) {
+  		throw Error('Parse error: ' + message);
+  	};
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var encode = function(string, options) {
+  		options = merge(options, encode.options);
+  		var strict = options.strict;
+  		if (strict && regexInvalidRawCodePoint.test(string)) {
+  			parseError('forbidden code point');
+  		}
+  		var encodeEverything = options.encodeEverything;
+  		var useNamedReferences = options.useNamedReferences;
+  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
+  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+  		var escapeBmpSymbol = function(symbol) {
+  			return escapeCodePoint(symbol.charCodeAt(0));
+  		};
+
+  		if (encodeEverything) {
+  			// Encode ASCII symbols.
+  			string = string.replace(regexAsciiWhitelist, function(symbol) {
+  				// Use named references if requested & possible.
+  				if (useNamedReferences && has(encodeMap, symbol)) {
+  					return '&' + encodeMap[symbol] + ';';
+  				}
+  				return escapeBmpSymbol(symbol);
+  			});
+  			// Shorten a few escapes that represent two symbols, of which at least one
+  			// is within the ASCII range.
+  			if (useNamedReferences) {
+  				string = string
+  					.replace(/&gt;\u20D2/g, '&nvgt;')
+  					.replace(/&lt;\u20D2/g, '&nvlt;')
+  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
+  			}
+  			// Encode non-ASCII symbols.
+  			if (useNamedReferences) {
+  				// Encode non-ASCII symbols that can be replaced with a named reference.
+  				string = string.replace(regexEncodeNonAscii, function(string) {
+  					// Note: there is no need to check `has(encodeMap, string)` here.
+  					return '&' + encodeMap[string] + ';';
+  				});
+  			}
+  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+  		} else if (useNamedReferences) {
+  			// Apply named character references.
+  			// Encode `<>"'&` using named character references.
+  			if (!allowUnsafeSymbols) {
+  				string = string.replace(regexEscape, function(string) {
+  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+  				});
+  			}
+  			// Shorten escapes that represent two symbols, of which at least one is
+  			// `<>"'&`.
+  			string = string
+  				.replace(/&gt;\u20D2/g, '&nvgt;')
+  				.replace(/&lt;\u20D2/g, '&nvlt;');
+  			// Encode non-ASCII symbols that can be replaced with a named reference.
+  			string = string.replace(regexEncodeNonAscii, function(string) {
+  				// Note: there is no need to check `has(encodeMap, string)` here.
+  				return '&' + encodeMap[string] + ';';
+  			});
+  		} else if (!allowUnsafeSymbols) {
+  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+  			// using named character references.
+  			string = string.replace(regexEscape, escapeBmpSymbol);
+  		}
+  		return string
+  			// Encode astral symbols.
+  			.replace(regexAstralSymbols, function($0) {
+  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+  				var high = $0.charCodeAt(0);
+  				var low = $0.charCodeAt(1);
+  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+  				return escapeCodePoint(codePoint);
+  			})
+  			// Encode any remaining BMP symbols that are not printable ASCII symbols
+  			// using a hexadecimal escape.
+  			.replace(regexBmpWhitelist, escapeBmpSymbol);
+  	};
+  	// Expose default options (so they can be overridden globally).
+  	encode.options = {
+  		'allowUnsafeSymbols': false,
+  		'encodeEverything': false,
+  		'strict': false,
+  		'useNamedReferences': false,
+  		'decimal' : false
+  	};
+
+  	var decode = function(html, options) {
+  		options = merge(options, decode.options);
+  		var strict = options.strict;
+  		if (strict && regexInvalidEntity.test(html)) {
+  			parseError('malformed character reference');
+  		}
+  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+  			var codePoint;
+  			var semicolon;
+  			var decDigits;
+  			var hexDigits;
+  			var reference;
+  			var next;
+
+  			if ($1) {
+  				reference = $1;
+  				// Note: there is no need to check `has(decodeMap, reference)`.
+  				return decodeMap[reference];
+  			}
+
+  			if ($2) {
+  				// Decode named character references without trailing `;`, e.g. `&amp`.
+  				// This is only a parse error if it gets converted to `&`, or if it is
+  				// followed by `=` in an attribute context.
+  				reference = $2;
+  				next = $3;
+  				if (next && options.isAttributeValue) {
+  					if (strict && next == '=') {
+  						parseError('`&` did not start a character reference');
+  					}
+  					return $0;
+  				} else {
+  					if (strict) {
+  						parseError(
+  							'named character reference was not terminated by a semicolon'
+  						);
+  					}
+  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+  					return decodeMapLegacy[reference] + (next || '');
+  				}
+  			}
+
+  			if ($4) {
+  				// Decode decimal escapes, e.g. `&#119558;`.
+  				decDigits = $4;
+  				semicolon = $5;
+  				if (strict && !semicolon) {
+  					parseError('character reference was not terminated by a semicolon');
+  				}
+  				codePoint = parseInt(decDigits, 10);
+  				return codePointToSymbol(codePoint, strict);
+  			}
+
+  			if ($6) {
+  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+  				hexDigits = $6;
+  				semicolon = $7;
+  				if (strict && !semicolon) {
+  					parseError('character reference was not terminated by a semicolon');
+  				}
+  				codePoint = parseInt(hexDigits, 16);
+  				return codePointToSymbol(codePoint, strict);
+  			}
+
+  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+  			if (strict) {
+  				parseError(
+  					'named character reference was not terminated by a semicolon'
+  				);
+  			}
+  			return $0;
+  		});
+  	};
+  	// Expose default options (so they can be overridden globally).
+  	decode.options = {
+  		'isAttributeValue': false,
+  		'strict': false
+  	};
+
+  	var escape = function(string) {
+  		return string.replace(regexEscape, function($0) {
+  			// Note: there is no need to check `has(escapeMap, $0)` here.
+  			return escapeMap[$0];
+  		});
+  	};
+
+  	/*--------------------------------------------------------------------------*/
+
+  	var he = {
+  		'version': '1.2.0',
+  		'encode': encode,
+  		'decode': decode,
+  		'escape': escape,
+  		'unescape': decode
+  	};
+
+  	// Some AMD build optimizers, like r.js, check for specific condition patterns
+  	// like the following:
+  	if (freeExports && !freeExports.nodeType) {
+  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+  			freeModule.exports = he;
+  		} else { // in Narwhal or RingoJS v0.7.0-
+  			for (var key in he) {
+  				has(he, key) && (freeExports[key] = he[key]);
+  			}
+  		}
+  	} else { // in Rhino or a web browser
+  		root.he = he;
+  	}
+
+  }(commonjsGlobal));
+  });
+
   /**
    * Cross-platform code generation for component v-model
    */
@@ -2044,7 +2392,7 @@
       }
   }
 
-  var he = require('he');
+  // const he = require('he')
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -3051,6 +3399,19 @@
       html: html,
   };
 
+  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
+
   var baseOptions = {
       expectHTML: true,
       modules: modules,
@@ -3977,6 +4338,7 @@
   function repeat(str, n) {
       var result = '';
       if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
           while (true) {
               // eslint-disable-line
               if (n & 1)
@@ -4191,6 +4553,20 @@
       return ESC[a] || a;
   }
 
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  makeMap('style,class');
+  // attributes that should be using props for binding
+  makeMap('input,textarea,option,select,progress');
+  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  makeMap('events,caret,typing,plaintext-only');
+  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+
   var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
   // let the model AST transform translate v-model into appropriate
   // props bindings
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index 5acbcd7a97f..4e4bfb37361 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -3,10 +3,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var deindent = require('de-indent');
+var he = require('he');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
+var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
 var emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
@@ -151,11 +153,11 @@ function genStaticKeys$1(modules) {
         .join(',');
 }
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -1432,9 +1434,9 @@ var mustUseProp = function (tag, type, attr) {
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+makeMap('contenteditable,draggable,spellcheck');
 makeMap('events,caret,typing,plaintext-only');
-var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
@@ -2014,7 +2016,7 @@ function parseString(chr) {
     }
 }
 
-var he = require('he');
+// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
@@ -2028,7 +2030,7 @@ var slotRE = /^v-slot(:|$)|^#/;
 var lineBreakRE = /[\r\n]/;
 var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(he.decode);
+var decodeHTMLCached = cached(he__default['default'].decode);
 var emptySlotScopeToken = "_empty_";
 // configurable state
 var warn$1;
@@ -3026,6 +3028,19 @@ var directives = {
     html: html,
 };
 
+var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
+
 var baseOptions = {
     expectHTML: true,
     modules: modules,
@@ -3955,6 +3970,7 @@ function generateCodeFrame(source, start, end) {
 function repeat(str, n) {
     var result = '';
     if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
@@ -4170,6 +4186,20 @@ function escapeChar(a) {
     return ESC[a] || a;
 }
 
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+makeMap('input,textarea,option,select,progress');
+var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+
 var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
 // let the model AST transform translate v-model into appropriate
 // props bindings
diff --git a/scripts/config.js b/scripts/config.js
index ee272d1f489..5e6ef12ddd8 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -219,10 +219,14 @@ function genConfig (name) {
   const opts = builds[name]
 
   // console.log('__dir', __dirname)
+  // console.log('doing alisas', Object.assign({}, aliases, opts.alias))
   const config = {
     input: opts.entry,
     external: opts.external,
     plugins: [
+      alias({
+        entries: Object.assign({}, aliases, opts.alias)
+      }),
       // flow(),
       ts({
         tsconfig: path.resolve(__dirname, '../', 'tsconfig.json'),
@@ -239,7 +243,6 @@ function genConfig (name) {
       // babel({
       //   extensions: ['.js', '.jsx', '.ts', '.tsx']
       // }),
-      alias(Object.assign({}, aliases, opts.alias))
     ].concat(opts.plugins || []),
     output: {
       file: opts.dest,
@@ -255,6 +258,8 @@ function genConfig (name) {
     }
   }
 
+  // console.log('pluging', config.plugins)
+
   // built-in vars
   const vars = {
     __WEEX__: !!opts.weex,
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index edc83f06c98..2b1456e7a8d 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -1,6 +1,6 @@
 
-const he = require('he')
-// import * as he from 'he'
+// const he = require('he')
+import he from 'he'
 import { parseHTML } from './html-parser'
 import { parseText } from './text-parser'
 import { parseFilters } from './filter-parser'

From 3fd8bb4e0fc3114863d0fca6bcd253da87fe4443 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 14:41:48 +0100
Subject: [PATCH 015/317] fix test:weex

---
 .babelrc.js                                   |    32 +-
 package.json                                  |     7 +-
 packages/weex-template-compiler/build.js      |  7940 +++++-----
 packages/weex-template-compiler/package.json  |     3 +-
 packages/weex-template-compiler/yarn.lock     |    97 +
 packages/weex-vue-framework/factory.js        | 12763 +++++++---------
 packages/weex-vue-framework/index.js          |   306 +-
 src/platforms/weex/util/parser.ts             |    68 +-
 .../{parser.spec.js => parser.spec.ts}        |     0
 yarn.lock                                     |   165 +-
 10 files changed, 9944 insertions(+), 11437 deletions(-)
 create mode 100644 packages/weex-template-compiler/yarn.lock
 rename test/weex/compiler/{parser.spec.js => parser.spec.ts} (100%)

diff --git a/.babelrc.js b/.babelrc.js
index 400866bfa7e..ea2ea97a712 100644
--- a/.babelrc.js
+++ b/.babelrc.js
@@ -1,23 +1,23 @@
-const babelPresetFlowVue = {
-  plugins: [
-    require('@babel/plugin-proposal-class-properties'),
-    // require('@babel/plugin-syntax-flow'), // not needed, included in transform-flow-strip-types
-    require('@babel/plugin-transform-flow-strip-types')
-  ]
-}
+// const babelPresetFlowVue = {
+//   plugins: [
+//     require("@babel/plugin-proposal-class-properties"),
+//     // require('@babel/plugin-syntax-flow'), // not needed, included in transform-flow-strip-types
+//     require("@babel/plugin-transform-flow-strip-types"),
+//   ],
+// };
 
 module.exports = {
   presets: [
-    require('@babel/preset-env'),
+    // require("@babel/preset-env"),
+    "@babel/preset-env",
+
     // require('babel-preset-flow-vue')
-    babelPresetFlowVue
+    // babelPresetFlowVue,
   ],
   plugins: [
-    require('babel-plugin-transform-vue-jsx'),
-    require('@babel/plugin-syntax-dynamic-import')
+    require("babel-plugin-transform-vue-jsx"),
+    require("@babel/plugin-syntax-dynamic-import"),
   ],
-  ignore: [
-    'dist/*.js',
-    'packages/**/*.js'
-  ]
-}
+
+  ignore: ["dist/*.js", "packages/**/*.js"],
+};
diff --git a/package.json b/package.json
index add289b6db1..1e888dad210 100644
--- a/package.json
+++ b/package.json
@@ -30,7 +30,7 @@
     "test:unit": "karma start test/unit/karma.unit.config.js",
     "test:cover": "karma start test/unit/karma.cover.config.js",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.js",
-    "test:weex": "npm run build:weex && jasmine JASMINE_CONFIG_PATH=test/weex/jasmine.js",
+    "test:weex": "npm run build:weex && jasmine-ts JASMINE_CONFIG_PATH=test/weex/jasmine.js",
     "test:ssr": "npm run build:ssr && jasmine JASMINE_CONFIG_PATH=test/ssr/jasmine.js",
     "test:sauce": "npm run sauce -- 0 && npm run sauce -- 1 && npm run sauce -- 2",
     "test:types": "tsc -p ./types/test/tsconfig.json",
@@ -85,7 +85,8 @@
     "@types/webpack": "^4.4.22",
     "@typescript-eslint/eslint-plugin": "^4.21.0",
     "@typescript-eslint/parser": "^4.21.0",
-    "acorn": "^5.2.1",
+    "acorn": "^8.1.0",
+    "acorn-walk": "^8.0.2",
     "babel-eslint": "^10.0.1",
     "babel-helper-vue-jsx-merge-props": "^2.0.3",
     "babel-loader": "^8.0.4",
@@ -113,6 +114,7 @@
     "http-server": "^0.12.3",
     "jasmine": "^2.99.0",
     "jasmine-core": "^2.99.0",
+    "jasmine-ts": "^0.3.2",
     "karma": "^3.1.1",
     "karma-chrome-launcher": "^2.1.1",
     "karma-coverage": "^1.1.1",
@@ -141,6 +143,7 @@
     "shelljs": "^0.8.1",
     "terser": "^3.10.2",
     "ts-loader": "^8.1.0",
+    "ts-node": "^9.1.1",
     "tslib": "^2.2.0",
     "typescript": "^4.2.2",
     "webpack": "~4.28.4",
diff --git a/packages/weex-template-compiler/build.js b/packages/weex-template-compiler/build.js
index 7739a4b5c74..02f271749d6 100644
--- a/packages/weex-template-compiler/build.js
+++ b/packages/weex-template-compiler/build.js
@@ -2,237 +2,171 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+var he = require('he');
+var acorn = require('acorn');
+var walk = require('acorn-walk');
 
-var he = _interopDefault(require('he'));
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-/*  */
+var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
+var acorn__default = /*#__PURE__*/_interopDefaultLegacy(acorn);
+var walk__default = /*#__PURE__*/_interopDefaultLegacy(walk);
 
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
+makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-
-/* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce(function (keys, m) {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
 
-/*  */
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
-
+makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
-
-/*  */
+var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
 /**
  * unicode letters used for parsing html tags, component names and property paths.
@@ -240,510 +174,505 @@ var isNonPhrasingTag = makeMap(
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
+var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
+var startTagOpen = new RegExp("^<" + qnameCapture);
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
+var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
 var conditionalComment = /^<!\[/;
-
 // Special Elements (can contain anything)
 var isPlainTextElement = makeMap('script,style,textarea', true);
 var reCache = {};
-
 var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
 var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+};
+function decodeAttr(value, shouldDecodeNewlines) {
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, function (match) { return decodingMap[match]; });
+}
+function parseHTML(html, options) {
+    var stack = [];
+    var expectHTML = options.expectHTML;
+    var isUnaryTag = options.isUnaryTag || no;
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    var index = 0;
+    var last, lastTag;
+    var _loop_1 = function () {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            var textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    var commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        return "continue";
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    var conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        return "continue";
+                    }
+                }
+                // Doctype:
+                var doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    return "continue";
+                }
+                // End tag:
+                var endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    var curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    return "continue";
+                }
+                // Start tag:
+                var startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    return "continue";
+                }
+            }
+            var text = void 0, rest = void 0, next = void 0;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        { break; }
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
             }
-            advance(commentEnd + 3);
-            continue
-          }
         }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
+        else {
+            var endTagLength_1 = 0;
+            var stackedTag_1 = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag_1] ||
+                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
+            var rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength_1 = endTag.length;
+                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag_1, index - endTagLength_1, index);
         }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                    start: index + html.length,
+                });
+            }
+            return "break";
         }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
+    };
+    while (html) {
+        var state_1 = _loop_1();
+        if (state_1 === "break")
+            { break; }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        var start = html.match(startTagOpen);
+        if (start) {
+            var match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            var end = void 0, attr = void 0;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
         }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
     }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
+    function handleStartTag(match) {
+        var tagName = match.tagName;
+        var unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        var unary = isUnaryTag(tagName) || !!unarySlash;
+        var l = match.attrs.length;
+        var attrs = new Array(l);
+        for (var i = 0; i < l; i++) {
+            var args = match.attrs[i];
+            var value = args[3] || args[4] || args[5] || '';
+            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
     }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
+    function parseEndTag(tagName, start, end) {
+        var pos, lowerCasedTagName;
+        if (start == null)
+            { start = index; }
+        if (end == null)
+            { end = index; }
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (var i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
     }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
 }
 
-/*  */
-
 var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function parseFilters(exp) {
+    var inSingle = false;
+    var inDouble = false;
+    var inTemplateString = false;
+    var inRegex = false;
+    var curly = 0;
+    var square = 0;
+    var paren = 0;
+    var lastFilterIndex = 0;
+    var c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                { inSingle = false; }
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                { inDouble = false; }
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                { inTemplateString = false; }
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                { inRegex = false; }
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                var j = i - 1;
+                var p 
+                // find first non-whitespace prev char
+                = void 0;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        { break; }
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
     }
-  }
-
-  return expression
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
 }
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
+function wrapFilter(exp, filter) {
+    var i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return "_f(\"" + filter + "\")(" + exp + ")";
+    }
+    else {
+        var name_1 = filter.slice(0, i);
+        var args = filter.slice(i + 1);
+        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+    }
 }
 
-/*  */
-
 var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
 var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    var tokens = [];
+    var rawTokens = [];
+    var lastIndex = (tagRE.lastIndex = 0);
+    var match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        var exp = parseFilters(match[1].trim());
+        tokens.push("_s(" + exp + ")");
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/*  */
-
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+    var baseValueExpression = '$$v';
+    var valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            "(typeof " + baseValueExpression + " === 'string'" +
+                ("? " + baseValueExpression + ".trim()") +
+                (": " + baseValueExpression + ")");
+    }
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: "(" + value + ")",
+        expression: JSON.stringify(value),
+        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    var res = parseModel(value);
+    if (res.key === null) {
+        return value + "=" + assignment;
+    }
+    else {
+        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -758,432 +687,350 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
 var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.');
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-
-  str = val;
-  index = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index)
+function next() {
+    return str.charCodeAt(++index);
 }
-
-function eof () {
-  return index >= len
+function eof() {
+    return index >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index;
-      break
-    }
-  }
+function parseBracket(chr) {
+    var inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            { inBracket++; }
+        if (chr === 0x5d)
+            { inBracket--; }
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    var stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
-
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// @ts-ignore
+var nativeWatch = {}.watch;
+var supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function () {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
-// detect devtools
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
-
-    return Set;
-  }());
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    /** @class */ ((function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function () {
+            this.set = Object.create(null);
+        };
+        return Set;
+    })());
 }
 
-/*  */
-
-
-
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error("[Vue compiler]: " + msg);
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    var attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    var events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    var handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
 }
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
 }
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function getBindingAttr(el, name, getStatic) {
+    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        var staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
+function getAndRemoveAttr(el, name, removeFromMap) {
+    var val;
+    if ((val = el.attrsMap[name]) != null) {
+        var list = el.attrsList;
+        for (var i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
     var list = el.attrsList;
     for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
+        var attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
-    }
-  }
 }
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
-    }
-    if (range.end != null) {
-      item.end = range.end;
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
     }
-  }
-  return item
+    return item;
 }
 
-/*  */
-
+// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
 var stripParensRE = /^\(|\)$/g;
 var dynamicArgRE = /^\[.*\]$/;
-
 var argRE = /:(.*)$/;
 var bindRE = /^:|^\.|^v-bind:/;
 var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
 var slotRE = /^v-slot(:|$)|^#/;
-
 var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /\s+/g;
-
+var whitespaceRE = /[ \f\t\r\n]+/g;
 var invalidAttributeRE = /[\s"'<>\/=]/;
-
-var decodeHTMLCached = cached(he.decode);
-
+var decodeHTMLCached = cached(he__default['default'].decode);
 var emptySlotScopeToken = "_empty_";
-
 // configurable state
-var warn;
+var warn$1;
 var delimiters;
 var transforms;
 var preTransforms;
@@ -1192,927 +1039,786 @@ var platformIsPreTag;
 var platformMustUseProp;
 var platformGetTagNamespace;
 var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag: tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent: parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn(msg, range);
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    var isReservedTag = options.isReservedTag || no;
+    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    var stack = [];
+    var preserveWhitespace = options.preserveWhitespace !== false;
+    var whitespaceOption = options.whitespace;
+    var root;
+    var currentParent;
+    var inVPre = false;
+    var inPre = false;
+    var warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
+        }
     }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element);
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce("Component template should contain exactly one root element. " +
+                    "If you are using v-if on multiple elements, " +
+                    "use v-else-if to chain them instead.", { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    var name_1 = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (var i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
     }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            var lastNode = void 0;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
     }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
     }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start: function (tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            var element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach(function (attr) {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
+                            "spaces, quotes, <, >, / or =.", {
+                            start: attr.start + attr.name.indexOf("["),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        ("<" + tag + ">") +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (var i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end: function (tag, start, end) {
+            var element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars: function (text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                            start: start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            var children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                var res = void 0;
+                var child = void 0;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text: text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text: text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment: function (text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                var child = {
+                    type: 3,
+                    text: text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
     }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        process.env.NODE_ENV !== 'production' && warn(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
-        if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root);
+}
+function processRawAttrs(el) {
+    var list = el.attrsList;
+    var len = list.length;
+    if (len) {
+        var attrs = (el.attrs = new Array(len));
+        for (var i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (var i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    var exp = getBindingAttr(el, 'key');
+    if (exp) {
         if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anyting as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
+            if (el.tag === 'template') {
+                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                var iterator = el.iterator2 || el.iterator1;
+                var parent_1 = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent_1 &&
+                    parent_1.tag === 'transition-group') {
+                    warn$1("Do not use v-for index as key on <transition-group> children, " +
+                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
         }
-        currentParent.children.push(child);
-      }
+        el.key = exp;
     }
-  });
-  return root
 }
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
-}
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
+function processRef(el) {
+    var ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
 }
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
+function processFor(el) {
+    var exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        var res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+        }
     }
-  }
 }
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
+function parseFor(exp) {
+    var inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        { return; }
+    var res = {};
+    res.for = inMatch[2].trim();
+    var alias = inMatch[1].trim().replace(stripParensRE, '');
+    var iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
 }
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+function processIf(el) {
+    var exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
     }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
+function processIfConditions(el, parent) {
+    var prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
+            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
 }
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
-    }
-  }
+function findPrevElement(children) {
+    var i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                    "will be ignored.", children[i]);
+            }
+            children.pop();
+        }
+    }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
 }
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function processOnce(el) {
+    var once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    var slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
-        }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
+                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
+                "can also be used on plain elements in addition to <template> to " +
+                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+                "(v-for takes higher priority). Use a wrapper <template> for the " +
+                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    var slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1("<template v-slot> can only appear at the root level inside " +
+                            "the receiving component", el);
+                    }
+                }
+                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
+                el.slotTarget = name_2;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1("To avoid scope ambiguity, the default slot should also use " +
+                            "<template> syntax when there are other named slots.", slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                var slots = el.scopedSlots || (el.scopedSlots = {});
+                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
+                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
+                slotContainer_1.slotTarget = name_3;
+                slotContainer_1.slotTargetDynamic = dynamic;
+                slotContainer_1.children = el.children.filter(function (c) {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer_1;
+                        return true;
+                    }
+                });
+                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
     }
-  }
 }
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+function getSlotName(binding) {
+    var name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1("v-slot shorthand syntax requires a slot name.", binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: "\"" + name + "\"", dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
+                "and can possibly expand into multiple elements. " +
+                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
+function processComponent(el) {
+    var binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
 }
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn,
-                list[i],
-                true // dynamic
-              );
+function processAttrs(el) {
+    var list = el.attrsList;
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
             }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            { name = 'innerHTML'; }
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, "$event");
+                        if (!isDynamic) {
+                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                var argMatch = name.match(argRE);
+                var arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                var res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(name + "=\"" + value + "\": " +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
 }
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
+function checkInFor(el) {
+    var parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
     }
-    parent = parent.parent;
-  }
-  return false
+    return false;
 }
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function parseModifiers(name) {
+    var match = name.match(modifierRE);
+    if (match) {
+        var ret_1 = {};
+        match.forEach(function (m) {
+            ret_1[m.slice(1)] = true;
+        });
+        return ret_1;
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-    }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
+function makeAttrsMap(attrs) {
+    var map = {};
+    for (var i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
 }
-
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
 var ieNSBug = /^xmlns:NS\d+/;
 var ieNSPrefix = /^NS\d+:/;
-
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
+function guardIESVGBug(attrs) {
+    var res = [];
+    for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    var _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+                "You are binding v-model directly to a v-for iteration alias. " +
+                "This will not be able to modify the v-for source array because " +
+                "writing to the alias is like modifying a function local variable. " +
+                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
     }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
 }
 
-/*  */
-
 var isStaticKey;
 var isPlatformReservedTag;
-
-var genStaticKeysCached = cached(genStaticKeys$1);
-
+var genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -2124,1029 +1830,914 @@ var genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize (root, options) {
-  if (!root) { return }
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      markStatic(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        markStatic(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        markStaticRoots(node.ifConditions[i$1].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
+function optimize(root, options) {
+    if (!root)
+        { return; }
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (var i = 0, l = node.children.length; i < l; i++) {
+            var child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                var block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
 }
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (var i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
     }
-    if (node.for) {
-      return true
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
     }
-  }
-  return false
+    return false;
 }
 
-/*  */
-
 var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
 var fnInvokeRE = /\([^)]*?\);*$/;
 var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
 // KeyboardEvent.keyCode aliases
 var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
 var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
+var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
 var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard("$event.target !== $event.currentTarget"),
+    ctrl: genGuard("!$event.ctrlKey"),
+    shift: genGuard("!$event.shiftKey"),
+    alt: genGuard("!$event.altKey"),
+    meta: genGuard("!$event.metaKey"),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2"),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
+function genHandlers(events, isNative) {
+    var prefix = isNative ? 'nativeOn:' : 'on:';
+    var staticHandlers = "";
+    var dynamicHandlers = "";
+    for (var name_1 in events) {
+        var handlerCode = genHandler(events[name_1]);
+        //@ts-expect-error
+        if (events[name_1] && events[name_1].dynamic) {
+            dynamicHandlers += name_1 + "," + handlerCode + ",";
+        }
+        else {
+            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+        }
+    }
+    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+    if (dynamicHandlers) {
+        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+    }
+    else {
+        return prefix + staticHandlers;
+    }
 }
-
 // Generate handler code with binding params on Weex
 /* istanbul ignore next */
-function genWeexHandler (params, handlerCode) {
-  var innerHandlerCode = handlerCode;
-  var exps = params.filter(function (exp) { return simplePathRE.test(exp) && exp !== '$event'; });
-  var bindings = exps.map(function (exp) { return ({ '@binding': exp }); });
-  var args = exps.map(function (exp, i) {
-    var key = "$_" + (i + 1);
-    innerHandlerCode = innerHandlerCode.replace(exp, key);
-    return key
-  });
-  args.push('$event');
-  return '{\n' +
-    "handler:function(" + (args.join(',')) + "){" + innerHandlerCode + "},\n" +
-    "params:" + (JSON.stringify(bindings)) + "\n" +
-    '}'
+function genWeexHandler(params, handlerCode) {
+    var innerHandlerCode = handlerCode;
+    var exps = params.filter(function (exp) { return simplePathRE.test(exp) && exp !== '$event'; });
+    var bindings = exps.map(function (exp) { return ({ '@binding': exp }); });
+    var args = exps.map(function (exp, i) {
+        var key = "$_" + (i + 1);
+        innerHandlerCode = innerHandlerCode.replace(exp, key);
+        return key;
+    });
+    args.push('$event');
+    return ('{\n' +
+        ("handler:function(" + args.join(',') + "){" + innerHandlerCode + "},\n") +
+        ("params:" + JSON.stringify(bindings) + "\n") +
+        '}');
 }
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
     }
-    /* istanbul ignore if */
-    if (handler.params) {
-      return genWeexHandler(handler.params, handler.value)
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys);
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
-    }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + "($event)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ")($event)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    /* istanbul ignore if */
-    if (handler.params) {
-      return genWeexHandler(handler.params, code + handlerCode)
+    if (Array.isArray(handler)) {
+        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+    }
+    var isMethodPath = simplePathRE.test(handler.value);
+    var isFunctionExpression = fnExpRE.test(handler.value);
+    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        /* istanbul ignore if */
+        if (handler.params) {
+            return genWeexHandler(handler.params, handler.value);
+        }
+        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+    }
+    else {
+        var code = '';
+        var genModifierCode = '';
+        var keys = [];
+        var _loop_1 = function (key) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                var modifiers_1 = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
+                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        };
+        for (var key in handler.modifiers) {
+            _loop_1(key);
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        var handlerCode = isMethodPath
+            ? "return " + handler.value + ".apply(null, arguments)"
+            : isFunctionExpression
+                ? "return (" + handler.value + ").apply(null, arguments)"
+                : isFunctionInvocation
+                    ? "return " + handler.value
+                    : handler.value;
+        /* istanbul ignore if */
+        if (handler.params) {
+            return genWeexHandler(handler.params, code + handlerCode);
+        }
+        return "function($event){" + code + handlerCode + "}";
     }
-    return ("function($event){" + code + handlerCode + "}")
-  }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+        (keys.map(genFilterCode).join('&&') + ")return null;"));
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    var keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return "$event.keyCode!==" + keyVal;
+    }
+    var keyCode = keyCodes[key];
+    var keyName = keyNames[key];
+    return ("_k($event.keyCode," +
+        (JSON.stringify(key) + ",") +
+        (JSON.stringify(keyCode) + ",") +
+        "$event.key," +
+        ("" + JSON.stringify(keyName)) +
+        ")");
 }
 
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
-var warn$1 = noop;
+var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn$1 = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole_1 && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
+    };
+    var repeat_1 = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
+                    .join('\n'));
+        }
+        else {
+            return "\n\n(found in " + formatComponentName(vm) + ")";
+        }
+    };
 }
 
-/*  */
-
 var uid = 0;
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
-};
-
-Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
-};
-
-Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
-};
-
-Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
-};
-
-Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
-};
-
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-  return this.componentInstance
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var arguments$1 = arguments;
+
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-var shouldObserve = true;
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
-};
-
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
-};
-
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
-};
-
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (!isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn$1(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn$1(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn$1(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn$1(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
     }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -3154,119 +2745,95 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn$1(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
+    }
 }
 
-/*  */
-
-/*  */
-
-/*  */
-
+/* globals MutationObserver */
 var callbacks = [];
-
-function flushCallbacks () {
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -3274,1204 +2841,1043 @@ function flushCallbacks () {
 // completely stops working after triggering a few times... so, if native
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/*  */
-
-/*  */
-
-function on (el, dir) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn$1("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+if (typeof Promise !== 'undefined' && isNative(Promise)) ;
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter_1 = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
+        characterData: true,
+    });
 }
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+else ;
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn("v-on without argument does not support modifiers.");
+    }
+    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
 }
 
-/*  */
+function bind(el, dir) {
+    el.wrapData = function (code) {
+        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+    };
+}
 
 var baseDirectives = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
-};
-
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
+    on: on,
+    bind: bind,
+    cloak: noop,
 };
 
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
+var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        var isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = function (el) {
+            return !!el.component || !isReservedTag(el.tag);
+        };
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+    return CodegenState;
+}());
+function generate(ast, options) {
+    var state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    var code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: "with(this){return " + code + "}",
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else {
+        // component or element
+        var code = void 0;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            var data = void 0;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData$3(el, state);
+            }
+            var children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
+            ) + (children ? "," + children : '' // children
+            ) + ")";
+        }
+        // module transforms
+        for (var i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    var originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+    state.pre = originalPreState;
+    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        var key = '';
+        var parent_1 = el.parent;
+        while (parent_1) {
+            if (parent_1.for) {
+                key = parent_1.key;
+                break;
+            }
+            parent_1 = parent_1.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    var condition = conditions.shift();
+    if (condition.exp) {
+        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+    }
+    else {
+        return "" + genTernaryExp(condition.block);
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    var exp = el.for;
+    var alias = el.alias;
+    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
+    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+            "v-for should have explicit keys. " +
+            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return ((altHelper || '_l') + "((" + exp + ")," +
+        ("function(" + alias + iterator1 + iterator2 + "){") +
+        ("return " + (altGen || genElement)(el, state)) +
+        '})');
+}
+function genData$3(el, state) {
+    var data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    var dirs = genDirectives(el, state);
+    if (dirs)
+        { data += dirs + ','; }
+    // key
+    if (el.key) {
+        data += "key:" + el.key + ",";
+    }
+    // ref
+    if (el.ref) {
+        data += "ref:" + el.ref + ",";
+    }
+    if (el.refInFor) {
+        data += "refInFor:true,";
+    }
+    // pre
+    if (el.pre) {
+        data += "pre:true,";
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += "tag:\"" + el.tag + "\",";
+    }
+    // module data generation functions
+    for (var i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += "attrs:" + genProps(el.attrs) + ",";
+    }
+    // DOM props
+    if (el.props) {
+        data += "domProps:" + genProps(el.props) + ",";
+    }
+    // event handlers
+    if (el.events) {
+        data += genHandlers(el.events, false) + ",";
+    }
+    if (el.nativeEvents) {
+        data += genHandlers(el.nativeEvents, true) + ",";
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += "slot:" + el.slotTarget + ",";
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += genScopedSlots(el, el.scopedSlots, state) + ",";
+    }
+    // component v-model
+    if (el.model) {
+        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        var inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += inlineTemplate + ",";
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    var dirs = el.directives;
+    if (!dirs)
+        { return; }
+    var res = 'directives:[';
+    var hasRuntime = false;
+    var i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        var gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
+                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
+                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
 }
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
+function genInlineTemplate(el, state) {
+    var ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        var inlineRenderFns = generate(ast, state.options);
+        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
+            .map(function (code) { return "function(){" + code + "}"; })
+            .join(',') + "]}";
+    }
 }
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
-    }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    var needsForceUpdate = el.for ||
+        Object.keys(slots).some(function (key) {
+            var slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    var needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        var parent_2 = el.parent;
+        while (parent_2) {
+            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+                parent_2.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent_2.if) {
+                needsKey = true;
+            }
+            parent_2 = parent_2.parent;
+        }
+    }
+    var generatedSlots = Object.keys(slots)
+        .map(function (key) { return genScopedSlot(slots[key], state); })
+        .join(',');
+    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
 }
-
 function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
-}
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
+    var hash = 5381;
+    var i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
     }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
+    return hash >>> 0;
 }
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    var isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, "null");
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
+    var fn = "function(" + slotScope + "){" +
+        ("return " + (el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)) + "}");
+    // reverse proxy v-slot without scope on this.$slots
+    var reverseProxy = slotScope ? "" : ",proxy:true";
+    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    var children = el.children;
+    if (children.length) {
+        var el_1 = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el_1.for &&
+            el_1.tag !== 'template' &&
+            el_1.tag !== 'slot') {
+            var normalizationType_1 = checkSkip
+                ? state.maybeComponent(el_1)
+                    ? ",1"
+                    : ",0"
+                : "";
+            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+        }
+        var normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        var gen_1 = altGenNode || genNode;
+        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
-}
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+function getNormalizationType(children, maybeComponent) {
+    var res = 0;
+    for (var i = 0; i < children.length; i++) {
+        var el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            res = 1;
+        }
+    }
+    return res;
 }
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
 }
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText$1(node);
+    }
 }
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
+function genText$1(text) {
+    return "_v(" + (text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
 }
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? ("," + children) : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function genComment(comment) {
+    return "_e(" + JSON.stringify(comment.text) + ")";
 }
-
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")")
+function genSlot(el, state) {
+    var slotName = el.slotName || '"default"';
+    var children = genChildren(el, state);
+    var res = "_t(" + slotName + (children ? "," + children : '');
+    var attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic,
+        }); }))
+        : null;
+    var bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += ",null";
+    }
+    if (attrs) {
+        res += "," + attrs;
+    }
+    if (bind) {
+        res += (attrs ? '' : ',null') + "," + bind;
+    }
+    return res + ')';
 }
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = generateValue(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    var children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return "_c(" + componentName + "," + genData$3(el, state) + (children ? "," + children : '') + ")";
+}
+function genProps(props) {
+    var staticProps = "";
+    var dynamicProps = "";
+    for (var i = 0; i < props.length; i++) {
+        var prop = props[i];
+        var value = generateValue(prop.value)
+            ;
+        if (prop.dynamic) {
+            dynamicProps += prop.name + "," + value + ",";
+        }
+        else {
+            staticProps += "\"" + prop.name + "\":" + value + ",";
+        }
+    }
+    staticProps = "{" + staticProps.slice(0, -1) + "}";
+    if (dynamicProps) {
+        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+    }
+    else {
+        return staticProps;
+    }
 }
-
 /* istanbul ignore next */
-function generateValue (value) {
-  if (typeof value === 'string') {
-    return transformSpecialNewlines(value)
-  }
-  return JSON.stringify(value)
+function generateValue(value) {
+    if (typeof value === 'string') {
+        return transformSpecialNewlines(value);
+    }
+    return JSON.stringify(value);
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+var prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+var unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
 var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
 // detect problematic expressions in a template
-function detectErrors (ast, warn$$1) {
-  if (ast) {
-    checkNode(ast, warn$$1);
-  }
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (var name_1 in node.attrsMap) {
+            if (dirRE.test(name_1)) {
+                var value = node.attrsMap[name_1];
+                if (value) {
+                    var range = node.rawAttrsMap[name_1];
+                    if (name_1 === 'v-for') {
+                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                    }
+                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
+                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    }
+                    else if (onRE.test(name_1)) {
+                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                    }
+                    else {
+                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (var i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkNode (node, warn$$1) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn$$1, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn$$1, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn$$1, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn$$1, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn$$1);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn$$1, node);
-  }
+function checkEvent(exp, text, warn, range) {
+    var stripped = exp.replace(stripStringRE, '');
+    var keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn("avoid using JavaScript unary operator as property name: " +
+            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkEvent (exp, text, warn$$1, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn$$1(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn$$1, range);
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
 }
-
-function checkFor (node, text, warn$$1, range) {
-  checkExpression(node.for || '', text, warn$$1, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn$$1, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn$$1, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn$$1, range);
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function("var " + ident + "=_");
+        }
+        catch (e) {
+            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+        }
+    }
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn$$1,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn$$1(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        new Function("return " + exp);
+    }
+    catch (e) {
+        var keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn("avoid using JavaScript keyword as property name: " +
+                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+        }
+        else {
+            warn("invalid expression: " + e.message + " in\n\n" +
+                ("    " + exp + "\n\n") +
+                ("  Raw expression: " + text.trim() + "\n"), range);
+        }
     }
-  }
-}
-
-function checkExpression (exp, text, warn$$1, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn$$1(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn$$1(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
 }
-
-function checkFunctionParameterExpression (exp, text, warn$$1, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn$$1(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn("invalid function parameter expression: " + e.message + " in\n\n" +
+            ("    " + exp + "\n\n") +
+            ("  Raw expression: " + text.trim() + "\n"), range);
+    }
 }
 
-/*  */
-
 var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn$1;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
+function generateCodeFrame(source, start, end) {
+    if (start === void 0) { start = 0; }
+    if (end === void 0) { end = source.length; }
+    var lines = source.split(/\r?\n/);
+    var count = 0;
+    var res = [];
+    for (var i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (var j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    { continue; }
+                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                var lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    var pad = start - (count - lineLength) + 1;
+                    var length_1 = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        var length_2 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length_2));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
     }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
+    return res.join('\n');
+}
+function repeat(str, n) {
+    var result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                { result += str; }
+            n >>>= 1;
+            if (n <= 0)
+                { break; }
+            str += str;
+        }
     }
+    return result;
+}
 
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-        }
-      }
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
+    catch (err) {
+        errors.push({ err: err, code: code });
+        return noop;
     }
-
-    return (cache[key] = res)
-  }
 }
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
+function createCompileToFunctionFn(compile) {
+    var cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        var warn$1 = options.warn || warn;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
             }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
-    }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn$1('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        var key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        var compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach(function (e) {
+                        warn$1("Error compiling template:\n\n" + e.msg + "\n\n" +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn$1("Error compiling template:\n\n" + template + "\n\n" +
+                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                }
+                else {
+                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                }
+            }
+        }
+        // turn code into functions
+        var res = {};
+        var fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn$1("Failed to generate render function:\n\n" +
+                    fnGenErrors
+                        .map(function (_a) {
+                        var err = _a.err, code = _a.code;
+                        return err.toString() + " in\n\n" + code + "\n";
+                    })
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            var finalOptions = Object.create(baseOptions);
+            var errors = [];
+            var tips = [];
+            var warn = function (msg, range, tip) {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                    warn = function (msg, range, tip) {
+                        var data = { msg: msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength_1;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength_1;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (var key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            var compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile: compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  var code = generate(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+var createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    var ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    var code = generate(ast, options);
+    return {
+        ast: ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
-
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  var ref = parseStaticClass(staticClass, options);
-  var dynamic = ref.dynamic;
-  var classResult = ref.classResult;
-  if (process.env.NODE_ENV !== 'production' && dynamic && staticClass) {
-    warn(
-      "class=\"" + staticClass + "\": " +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['class']
-    );
-  }
-  if (!dynamic && classResult) {
-    el.staticClass = classResult;
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  } else if (dynamic) {
-    el.classBinding = classResult;
-  }
-}
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
-}
-
-function parseStaticClass (staticClass, options) {
-  // "a b c" -> ["a", "b", "c"] => staticClass: ["a", "b", "c"]
-  // "a {{x}} c" -> ["a", x, "c"] => classBinding: '["a", x, "c"]'
-  var dynamic = false;
-  var classResult = '';
-  if (staticClass) {
-    var classList = staticClass.trim().split(' ').map(function (name) {
-      var result = parseText(name, options.delimiters);
-      if (result) {
-        dynamic = true;
-        return result.expression
-      }
-      return JSON.stringify(name)
-    });
-    if (classList.length) {
-      classResult = '[' + classList.join(',') + ']';
+function transformNode$3(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticClass = getAndRemoveAttr(el, 'class');
+    var _a = parseStaticClass(staticClass, options), dynamic = _a.dynamic, classResult = _a.classResult;
+    if (process.env.NODE_ENV !== 'production' && dynamic && staticClass) {
+        warn("class=\"" + staticClass + "\": " +
+            'Interpolation inside attributes has been deprecated. ' +
+            'Use v-bind or the colon shorthand instead.', el.rawAttrsMap['class']);
+    }
+    if (!dynamic && classResult) {
+        el.staticClass = classResult;
+    }
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+    else if (dynamic) {
+        el.classBinding = classResult;
+    }
+}
+function genData$2(el) {
+    var data = '';
+    if (el.staticClass) {
+        data += "staticClass:" + el.staticClass + ",";
+    }
+    if (el.classBinding) {
+        data += "class:" + el.classBinding + ",";
+    }
+    return data;
+}
+function parseStaticClass(staticClass, options) {
+    // "a b c" -> ["a", "b", "c"] => staticClass: ["a", "b", "c"]
+    // "a {{x}} c" -> ["a", x, "c"] => classBinding: '["a", x, "c"]'
+    var dynamic = false;
+    var classResult = '';
+    if (staticClass) {
+        var classList = staticClass
+            .trim()
+            .split(' ')
+            .map(function (name) {
+            var result = parseText(name, options.delimiters);
+            if (result) {
+                dynamic = true;
+                return result.expression;
+            }
+            return JSON.stringify(name);
+        });
+        if (classList.length) {
+            classResult = '[' + classList.join(',') + ']';
+        }
     }
-  }
-  return { dynamic: dynamic, classResult: classResult }
+    return { dynamic: dynamic, classResult: classResult };
 }
-
 var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData$1
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$3,
+    genData: genData$2,
 };
 
-/*  */
-
-
-
-var normalize = cached(camelize);
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  var ref = parseStaticStyle(staticStyle, options);
-  var dynamic = ref.dynamic;
-  var styleResult = ref.styleResult;
-  if (process.env.NODE_ENV !== 'production' && dynamic) {
-    warn(
-      "style=\"" + (String(staticStyle)) + "\": " +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['style']
-    );
-  }
-  if (!dynamic && styleResult) {
-    // $flow-disable-line
-    el.staticStyle = styleResult;
-  }
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  } else if (dynamic) {
-    // $flow-disable-line
-    el.styleBinding = styleResult;
-  }
-}
-
-function genData$2 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:" + (el.styleBinding) + ",";
-  }
-  return data
-}
-
-function parseStaticStyle (staticStyle, options) {
-  // "width: 200px; height: 200px;" -> {width: 200, height: 200}
-  // "width: 200px; height: {{y}}" -> {width: 200, height: y}
-  var dynamic = false;
-  var styleResult = '';
-  if (typeof staticStyle === 'string') {
-    var styleList = staticStyle.trim().split(';').map(function (style) {
-      var result = style.trim().split(':');
-      if (result.length !== 2) {
-        return
-      }
-      var key = normalize(result[0].trim());
-      var value = result[1].trim();
-      var dynamicValue = parseText(value, options.delimiters);
-      if (dynamicValue) {
-        dynamic = true;
-        return key + ':' + dynamicValue.expression
-      }
-      return key + ':' + JSON.stringify(value)
-    }).filter(function (result) { return result; });
-    if (styleList.length) {
-      styleResult = '{' + styleList.join(',') + '}';
-    }
-  } else if (isPlainObject(staticStyle)) {
-    styleResult = JSON.stringify(staticStyle) || '';
-  }
-  return { dynamic: dynamic, styleResult: styleResult }
+var normalize$1 = cached(camelize);
+function transformNode$2(el, options) {
+    var warn = options.warn || baseWarn;
+    var staticStyle = getAndRemoveAttr(el, 'style');
+    var _a = parseStaticStyle(staticStyle, options), dynamic = _a.dynamic, styleResult = _a.styleResult;
+    if (process.env.NODE_ENV !== 'production' && dynamic) {
+        warn("style=\"" + String(staticStyle) + "\": " +
+            'Interpolation inside attributes has been deprecated. ' +
+            'Use v-bind or the colon shorthand instead.', el.rawAttrsMap['style']);
+    }
+    if (!dynamic && styleResult) {
+        // @ts-ignore
+        el.staticStyle = styleResult;
+    }
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+    else if (dynamic) {
+        // @ts-ignore
+        el.styleBinding = styleResult;
+    }
+}
+function genData$1(el) {
+    var data = '';
+    if (el.staticStyle) {
+        data += "staticStyle:" + el.staticStyle + ",";
+    }
+    if (el.styleBinding) {
+        data += "style:" + el.styleBinding + ",";
+    }
+    return data;
+}
+function parseStaticStyle(staticStyle, options) {
+    // "width: 200px; height: 200px;" -> {width: 200, height: 200}
+    // "width: 200px; height: {{y}}" -> {width: 200, height: y}
+    var dynamic = false;
+    var styleResult = '';
+    if (typeof staticStyle === 'string') {
+        var styleList = staticStyle
+            .trim()
+            .split(';')
+            .map(function (style) {
+            var result = style.trim().split(':');
+            if (result.length !== 2) {
+                return;
+            }
+            var key = normalize$1(result[0].trim());
+            var value = result[1].trim();
+            var dynamicValue = parseText(value, options.delimiters);
+            if (dynamicValue) {
+                dynamic = true;
+                return key + ':' + dynamicValue.expression;
+            }
+            return key + ':' + JSON.stringify(value);
+        })
+            .filter(function (result) { return result; });
+        if (styleList.length) {
+            styleResult = '{' + styleList.join(',') + '}';
+        }
+    }
+    else if (isPlainObject(staticStyle)) {
+        styleResult = JSON.stringify(staticStyle) || '';
+    }
+    return { dynamic: dynamic, styleResult: styleResult };
 }
-
 var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$2
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode$2,
+    genData: genData$1,
 };
 
-/*  */
-
-var normalize$1 = cached(camelize);
-
-function normalizeKeyName (str) {
-  if (str.match(/^v\-/)) {
-    return str.replace(/(v-[a-z\-]+\:)([a-z\-]+)$/i, function ($, directive, prop) {
-      return directive + normalize$1(prop)
-    })
-  }
-  return normalize$1(str)
-}
-
-function transformNode$2 (el) {
-  if (Array.isArray(el.attrsList)) {
-    el.attrsList.forEach(function (attr) {
-      if (attr.name && attr.name.match(/\-/)) {
-        var realName = normalizeKeyName(attr.name);
-        if (el.attrsMap) {
-          el.attrsMap[realName] = el.attrsMap[attr.name];
-          delete el.attrsMap[attr.name];
-        }
-        if (el.rawAttrsMap && el.rawAttrsMap[attr.name]) {
-          el.rawAttrsMap[realName] = el.rawAttrsMap[attr.name];
-          // $flow-disable-line
-          delete el.rawAttrsMap[attr.name];
-        }
-        attr.name = realName;
-      }
-    });
-  }
+var normalize = cached(camelize);
+function normalizeKeyName(str) {
+    if (str.match(/^v\-/)) {
+        return str.replace(/(v-[a-z\-]+\:)([a-z\-]+)$/i, function ($, directive, prop) {
+            return directive + normalize(prop);
+        });
+    }
+    return normalize(str);
+}
+function transformNode$1(el) {
+    if (Array.isArray(el.attrsList)) {
+        el.attrsList.forEach(function (attr) {
+            if (attr.name && attr.name.match(/\-/)) {
+                var realName = normalizeKeyName(attr.name);
+                if (el.attrsMap) {
+                    el.attrsMap[realName] = el.attrsMap[attr.name];
+                    delete el.attrsMap[attr.name];
+                }
+                if (el.rawAttrsMap && el.rawAttrsMap[attr.name]) {
+                    el.rawAttrsMap[realName] = el.rawAttrsMap[attr.name];
+                    // $flow-disable-line
+                    delete el.rawAttrsMap[attr.name];
+                }
+                attr.name = realName;
+            }
+        });
+    }
 }
 var props = {
-  transformNode: transformNode$2
+    transformNode: transformNode$1,
 };
 
-/*  */
-
 // The "unitary tag" means that the tag node and its children
 // must be sent to the native together.
 var isUnitaryTag = makeMap('cell,header,cell-slot,recycle-list', true);
-
-function preTransformNode (el) {
-  if (isUnitaryTag(el.tag) && !el.attrsList.some(function (item) { return item.name === 'append'; })) {
-    el.attrsMap.append = 'tree';
-    el.attrsList.push({ name: 'append', value: 'tree' });
-  }
-  if (el.attrsMap.append === 'tree') {
-    el.appendAsTree = true;
-  }
+function preTransformNode$1(el) {
+    if (isUnitaryTag(el.tag) &&
+        !el.attrsList.some(function (item) { return item.name === 'append'; })) {
+        el.attrsMap.append = 'tree';
+        el.attrsList.push({ name: 'append', value: 'tree' });
+    }
+    if (el.attrsMap.append === 'tree') {
+        el.appendAsTree = true;
+    }
 }
-
-function genData$3 (el) {
-  return el.appendAsTree ? "appendAsTree:true," : ''
+function genData(el) {
+    return el.appendAsTree ? "appendAsTree:true," : '';
 }
-
 var append = {
-  staticKeys: ['appendAsTree'],
-  preTransformNode: preTransformNode,
-  genData: genData$3
+    staticKeys: ['appendAsTree'],
+    preTransformNode: preTransformNode$1,
+    genData: genData,
 };
 
-/*  */
-
 /**
  * Map the following syntax to corresponding attrs:
  *
@@ -4480,478 +3886,382 @@ var append = {
  *   <cell-slot case="B"> ... </cell-slot>
  * </recycle-list>
  */
-
-function preTransformRecycleList (
-  el,
-  options
-) {
-  var exp = getAndRemoveAttr(el, 'for');
-  if (!exp) {
-    if (options.warn) {
-      options.warn("Invalid <recycle-list> syntax: missing \"for\" expression.");
-    }
-    return
-  }
-
-  var res = parseFor(exp);
-  if (!res) {
-    if (options.warn) {
-      options.warn(("Invalid <recycle-list> syntax: " + exp + "."));
+function preTransformRecycleList(el, options) {
+    var exp = getAndRemoveAttr(el, 'for');
+    if (!exp) {
+        if (options.warn) {
+            options.warn("Invalid <recycle-list> syntax: missing \"for\" expression.");
+        }
+        return;
+    }
+    var res = parseFor(exp);
+    if (!res) {
+        if (options.warn) {
+            options.warn("Invalid <recycle-list> syntax: " + exp + ".");
+        }
+        return;
+    }
+    addRawAttr(el, ':list-data', res.for);
+    addRawAttr(el, 'binding-expression', res.for);
+    addRawAttr(el, 'alias', res.alias);
+    if (res.iterator2) {
+        // (item, key, index) for object iteration
+        // is this even supported?
+        addRawAttr(el, 'index', res.iterator2);
+    }
+    else if (res.iterator1) {
+        addRawAttr(el, 'index', res.iterator1);
+    }
+    var switchKey = getAndRemoveAttr(el, 'switch');
+    if (switchKey) {
+        addRawAttr(el, 'switch', switchKey);
     }
-    return
-  }
-
-  addRawAttr(el, ':list-data', res.for);
-  addRawAttr(el, 'binding-expression', res.for);
-  addRawAttr(el, 'alias', res.alias);
-  if (res.iterator2) {
-    // (item, key, index) for object iteration
-    // is this even supported?
-    addRawAttr(el, 'index', res.iterator2);
-  } else if (res.iterator1) {
-    addRawAttr(el, 'index', res.iterator1);
-  }
-
-  var switchKey = getAndRemoveAttr(el, 'switch');
-  if (switchKey) {
-    addRawAttr(el, 'switch', switchKey);
-  }
 }
 
-/*  */
-
 var RECYCLE_LIST_MARKER = '@inRecycleList';
 
-/*  */
-
 // mark components as inside recycle-list so that we know we need to invoke
 // their special @render function instead of render in create-component.js
-function postTransformComponent (
-  el,
-  options
-) {
-  // $flow-disable-line (we know isReservedTag is there)
-  if (!options.isReservedTag(el.tag) && el.tag !== 'cell-slot') {
-    addAttr(el, RECYCLE_LIST_MARKER, 'true');
-  }
+function postTransformComponent(el, options) {
+    // $flow-disable-line (we know isReservedTag is there)
+    if (!options.isReservedTag(el.tag) && el.tag !== 'cell-slot') {
+        addAttr(el, RECYCLE_LIST_MARKER, 'true');
+    }
 }
 
-/*  */
-
 // mark component root nodes as
-function postTransformComponentRoot (el) {
-  if (!el.parent) {
-    // component root
-    addAttr(el, '@isComponentRoot', 'true');
-    addAttr(el, '@templateId', '_uid');
-    addAttr(el, '@componentProps', '$props || {}');
-  }
-}
-
-/*  */
-
-function genText$1 (node) {
-  var value = node.type === 3
-    ? node.text
-    : node.type === 2
-      ? node.tokens.length === 1
-        ? node.tokens[0]
-        : node.tokens
-      : '';
-  return JSON.stringify(value)
-}
-
-function postTransformText (el) {
-  // weex <text> can only contain text, so the parser
-  // always generates a single child.
-  if (el.children.length) {
-    addAttr(el, 'value', genText$1(el.children[0]));
-    el.children = [];
-  }
+function postTransformComponentRoot(el) {
+    if (!el.parent) {
+        // component root
+        addAttr(el, '@isComponentRoot', 'true');
+        addAttr(el, '@templateId', '_uid');
+        addAttr(el, '@componentProps', '$props || {}');
+    }
+}
+
+function genText(node) {
+    var value = node.type === 3
+        ? node.text
+        : node.type === 2
+            ? node.tokens.length === 1
+                ? node.tokens[0]
+                : node.tokens
+            : '';
+    return JSON.stringify(value);
+}
+function postTransformText(el) {
+    // weex <text> can only contain text, so the parser
+    // always generates a single child.
+    if (el.children.length) {
+        addAttr(el, 'value', genText(el.children[0]));
+        el.children = [];
+    }
 }
 
-/*  */
-
 // import { warn } from 'core/util/index'
-
-// this will be preserved during build
-// $flow-disable-line
-var acorn = require('acorn'); // $flow-disable-line
-var walk = require('acorn/dist/walk'); // $flow-disable-line
-var escodegen = require('escodegen');
-
-function nodeToBinding (node) {
-  switch (node.type) {
-    case 'Literal': return node.value
-    case 'Identifier':
-    case 'UnaryExpression':
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-    case 'ConditionalExpression':
-    case 'MemberExpression': return { '@binding': escodegen.generate(node) }
-    case 'ArrayExpression': return node.elements.map(function (_) { return nodeToBinding(_); })
-    case 'ObjectExpression': {
-      var object = {};
-      node.properties.forEach(function (prop) {
-        if (!prop.key || prop.key.type !== 'Identifier') {
-          return
-        }
-        var key = escodegen.generate(prop.key);
-        var value = nodeToBinding(prop.value);
-        if (key && value) {
-          object[key] = value;
-        }
-      });
-      return object
-    }
-    default: {
-      // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
-      return ''
-    }
-  }
+var escodegen = require("escodegen");
+function nodeToBinding(node) {
+    switch (node.type) {
+        case "Literal":
+            return node.value;
+        case "Identifier":
+        case "UnaryExpression":
+        case "BinaryExpression":
+        case "LogicalExpression":
+        case "ConditionalExpression":
+        case "MemberExpression":
+            return { "@binding": escodegen.generate(node) };
+        case "ArrayExpression":
+            return node.elements.map(function (_) { return nodeToBinding(_); });
+        case "ObjectExpression": {
+            var object_1 = {};
+            node.properties.forEach(function (prop) {
+                if (!prop.key || prop.key.type !== "Identifier") {
+                    return;
+                }
+                var key = escodegen.generate(prop.key);
+                var value = nodeToBinding(prop.value);
+                if (key && value) {
+                    object_1[key] = value;
+                }
+            });
+            return object_1;
+        }
+        default: {
+            // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
+            return "";
+        }
+    }
 }
-
-function generateBinding (exp) {
-  if (exp && typeof exp === 'string') {
-    var ast = null;
-    try {
-      ast = acorn.parse(("(" + exp + ")"));
-    } catch (e) {
-      // warn(`Failed to parse the expression: "${exp}"`)
-      return ''
+function generateBinding(exp) {
+    if (exp && typeof exp === "string") {
+        var ast = null;
+        try {
+            ast = acorn__default['default'].parse("(" + exp + ")", { ecmaVersion: 5 });
+        }
+        catch (e) {
+            // warn(`Failed to parse the expression: "${exp}"`)
+            return "";
+        }
+        var output_1 = "";
+        walk__default['default'].simple(ast, {
+            Expression: function (node) {
+                output_1 = nodeToBinding(node);
+            },
+        });
+        return output_1;
     }
-
-    var output = '';
-    walk.simple(ast, {
-      Expression: function Expression (node) {
-        output = nodeToBinding(node);
-      }
-    });
-    return output
-  }
 }
 
-/*  */
-
-function parseAttrName (name) {
-  return camelize(name.replace(bindRE, ''))
+function parseAttrName(name) {
+    return camelize(name.replace(bindRE, ''));
 }
-
-function preTransformVBind (el) {
-  for (var attr in el.attrsMap) {
-    if (bindRE.test(attr)) {
-      var name = parseAttrName(attr);
-      var value = generateBinding(getAndRemoveAttr(el, attr));
-      delete el.attrsMap[attr];
-      addRawAttr(el, name, value);
+function preTransformVBind(el) {
+    for (var attr in el.attrsMap) {
+        if (bindRE.test(attr)) {
+            var name_1 = parseAttrName(attr);
+            var value = generateBinding(getAndRemoveAttr(el, attr));
+            delete el.attrsMap[attr];
+            addRawAttr(el, name_1, value);
+        }
     }
-  }
 }
 
-/*  */
-
-function hasConditionDirective (el) {
-  for (var attr in el.attrsMap) {
-    if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
-      return true
+function hasConditionDirective(el) {
+    for (var attr in el.attrsMap) {
+        if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getPreviousConditions(el) {
+    var conditions = [];
+    if (el.parent && el.parent.children) {
+        for (var c = 0, n = el.parent.children.length; c < n; ++c) {
+            // @ts-ignore
+            var ifConditions = el.parent.children[c].ifConditions;
+            if (ifConditions) {
+                for (var i = 0, l = ifConditions.length; i < l; ++i) {
+                    var condition = ifConditions[i];
+                    if (condition && condition.exp) {
+                        conditions.push(condition.exp);
+                    }
+                }
+            }
+        }
+    }
+    return conditions;
+}
+function preTransformVIf(el, options) {
+    if (hasConditionDirective(el)) {
+        var exp = void 0;
+        var ifExp = getAndRemoveAttr(el, 'v-if', true /* remove from attrsMap */);
+        var elseifExp = getAndRemoveAttr(el, 'v-else-if', true);
+        // don't need the value, but remove it to avoid being generated as a
+        // custom directive
+        getAndRemoveAttr(el, 'v-else', true);
+        if (ifExp) {
+            exp = ifExp;
+            addIfCondition(el, { exp: ifExp, block: el });
+        }
+        else {
+            elseifExp && addIfCondition(el, { exp: elseifExp, block: el });
+            var prevConditions = getPreviousConditions(el);
+            if (prevConditions.length) {
+                var prevMatch = prevConditions.join(' || ');
+                exp = elseifExp
+                    ? "!(" + prevMatch + ") && (" + elseifExp + ")" // v-else-if
+                    : "!(" + prevMatch + ")"; // v-else
+            }
+            else if (process.env.NODE_ENV !== 'production' && options.warn) {
+                options.warn("v-" + (elseifExp ? 'else-if="' + elseifExp + '"' : 'else') + " " +
+                    ("used on element <" + el.tag + "> without corresponding v-if."));
+                return;
+            }
+        }
+        addRawAttr(el, '[[match]]', exp);
     }
-  }
-  return false
-}
-
-function getPreviousConditions (el) {
-  var conditions = [];
-  if (el.parent && el.parent.children) {
-    for (var c = 0, n = el.parent.children.length; c < n; ++c) {
-      // $flow-disable-line
-      var ifConditions = el.parent.children[c].ifConditions;
-      if (ifConditions) {
-        for (var i = 0, l = ifConditions.length; i < l; ++i) {
-          var condition = ifConditions[i];
-          if (condition && condition.exp) {
-            conditions.push(condition.exp);
-          }
-        }
-      }
-    }
-  }
-  return conditions
-}
-
-function preTransformVIf (el, options) {
-  if (hasConditionDirective(el)) {
-    var exp;
-    var ifExp = getAndRemoveAttr(el, 'v-if', true /* remove from attrsMap */);
-    var elseifExp = getAndRemoveAttr(el, 'v-else-if', true);
-    // don't need the value, but remove it to avoid being generated as a
-    // custom directive
-    getAndRemoveAttr(el, 'v-else', true);
-    if (ifExp) {
-      exp = ifExp;
-      addIfCondition(el, { exp: ifExp, block: el });
-    } else {
-      elseifExp && addIfCondition(el, { exp: elseifExp, block: el });
-      var prevConditions = getPreviousConditions(el);
-      if (prevConditions.length) {
-        var prevMatch = prevConditions.join(' || ');
-        exp = elseifExp
-          ? ("!(" + prevMatch + ") && (" + elseifExp + ")") // v-else-if
-          : ("!(" + prevMatch + ")"); // v-else
-      } else if (process.env.NODE_ENV !== 'production' && options.warn) {
-        options.warn(
-          "v-" + (elseifExp ? ('else-if="' + elseifExp + '"') : 'else') + " " +
-          "used on element <" + (el.tag) + "> without corresponding v-if."
-        );
-        return
-      }
-    }
-    addRawAttr(el, '[[match]]', exp);
-  }
 }
 
-/*  */
-
-function preTransformVFor (el, options) {
-  var exp = getAndRemoveAttr(el, 'v-for');
-  if (!exp) {
-    return
-  }
-
-  var res = parseFor(exp);
-  if (!res) {
-    if (process.env.NODE_ENV !== 'production' && options.warn) {
-      options.warn(("Invalid v-for expression: " + exp));
+function preTransformVFor(el, options) {
+    var exp = getAndRemoveAttr(el, 'v-for');
+    if (!exp) {
+        return;
     }
-    return
-  }
-
-  var desc = {
-    '@expression': res.for,
-    '@alias': res.alias
-  };
-  if (res.iterator2) {
-    desc['@key'] = res.iterator1;
-    desc['@index'] = res.iterator2;
-  } else {
-    desc['@index'] = res.iterator1;
-  }
-
-  delete el.attrsMap['v-for'];
-  addRawAttr(el, '[[repeat]]', desc);
+    var res = parseFor(exp);
+    if (!res) {
+        if (process.env.NODE_ENV !== 'production' && options.warn) {
+            options.warn("Invalid v-for expression: " + exp);
+        }
+        return;
+    }
+    var desc = {
+        '@expression': res.for,
+        '@alias': res.alias,
+    };
+    if (res.iterator2) {
+        desc['@key'] = res.iterator1;
+        desc['@index'] = res.iterator2;
+    }
+    else {
+        desc['@index'] = res.iterator1;
+    }
+    delete el.attrsMap['v-for'];
+    addRawAttr(el, '[[repeat]]', desc);
 }
 
-/*  */
-
 var inlineStatementRE = /^\s*([A-Za-z_$0-9\['\."\]]+)*\s*\(\s*(([A-Za-z_$0-9\['\."\]]+)?(\s*,\s*([A-Za-z_$0-9\['\."\]]+))*)\s*\)$/;
-
-function parseHandlerParams (handler) {
-  var res = inlineStatementRE.exec(handler.value);
-  if (res && res[2]) {
-    handler.params = res[2].split(/\s*,\s*/);
-  }
+function parseHandlerParams(handler) {
+    var res = inlineStatementRE.exec(handler.value);
+    if (res && res[2]) {
+        handler.params = res[2].split(/\s*,\s*/);
+    }
 }
-
-function postTransformVOn (el) {
-  var events = el.events;
-  if (!events) {
-    return
-  }
-  for (var name in events) {
-    var handler = events[name];
-    if (Array.isArray(handler)) {
-      handler.map(function (fn) { return parseHandlerParams(fn); });
-    } else {
-      parseHandlerParams(handler);
+function postTransformVOn(el) {
+    var events = el.events;
+    if (!events) {
+        return;
+    }
+    for (var name_1 in events) {
+        var handler = events[name_1];
+        if (Array.isArray(handler)) {
+            handler.map(function (fn) { return parseHandlerParams(fn); });
+        }
+        else {
+            parseHandlerParams(handler);
+        }
     }
-  }
 }
 
-/*  */
-
-function containVOnce (el) {
-  for (var attr in el.attrsMap) {
-    if (/^v\-once$/i.test(attr)) {
-      return true
+function containVOnce(el) {
+    for (var attr in el.attrsMap) {
+        if (/^v\-once$/i.test(attr)) {
+            return true;
+        }
     }
-  }
-  return false
+    return false;
 }
-
-function preTransformVOnce (el) {
-  if (containVOnce(el)) {
-    getAndRemoveAttr(el, 'v-once', true);
-    addRawAttr(el, '[[once]]', true);
-  }
+function preTransformVOnce(el) {
+    if (containVOnce(el)) {
+        getAndRemoveAttr(el, 'v-once', true);
+        addRawAttr(el, '[[once]]', true);
+    }
 }
 
-/*  */
-
 var currentRecycleList = null;
-
-function shouldCompile (el, options) {
-  return options.recyclable ||
-    (currentRecycleList && el !== currentRecycleList)
-}
-
-function preTransformNode$1 (el, options) {
-  if (el.tag === 'recycle-list') {
-    preTransformRecycleList(el, options);
-    currentRecycleList = el;
-  }
-  if (shouldCompile(el, options)) {
-    preTransformVBind(el);
-    preTransformVIf(el, options); // also v-else-if and v-else
-    preTransformVFor(el, options);
-    preTransformVOnce(el);
-  }
-}
-
-function transformNode$3 (el, options) {
-  if (shouldCompile(el, options)) ;
-}
-
-function postTransformNode (el, options) {
-  if (shouldCompile(el, options)) {
-    // mark child component in parent template
-    postTransformComponent(el, options);
-    // mark root in child component template
-    postTransformComponentRoot(el);
-    // <text>: transform children text into value attr
-    if (el.tag === 'text') {
-      postTransformText(el);
-    }
-    postTransformVOn(el);
-  }
-  if (el === currentRecycleList) {
-    currentRecycleList = null;
-  }
+function shouldCompile(el, options) {
+    return options.recyclable || (currentRecycleList && el !== currentRecycleList);
+}
+function preTransformNode(el, options) {
+    if (el.tag === 'recycle-list') {
+        preTransformRecycleList(el, options);
+        currentRecycleList = el;
+    }
+    if (shouldCompile(el, options)) {
+        preTransformVBind(el);
+        preTransformVIf(el, options); // also v-else-if and v-else
+        preTransformVFor(el, options);
+        preTransformVOnce(el);
+    }
+}
+function transformNode(el, options) {
+    if (shouldCompile(el, options)) ;
+}
+function postTransformNode(el, options) {
+    if (shouldCompile(el, options)) {
+        // mark child component in parent template
+        postTransformComponent(el, options);
+        // mark root in child component template
+        postTransformComponentRoot(el);
+        // <text>: transform children text into value attr
+        if (el.tag === 'text') {
+            postTransformText(el);
+        }
+        postTransformVOn(el);
+    }
+    if (el === currentRecycleList) {
+        currentRecycleList = null;
+    }
 }
-
 var recycleList = {
-  preTransformNode: preTransformNode$1,
-  transformNode: transformNode$3,
-  postTransformNode: postTransformNode
+    preTransformNode: preTransformNode,
+    transformNode: transformNode,
+    postTransformNode: postTransformNode,
 };
 
-var modules = [
-  recycleList,
-  klass,
-  style,
-  props,
-  append
-];
-
-/*  */
+var modules = [recycleList, klass, style, props, append];
 
-function model (
-  el,
-  dir
-) {
-  if (el.tag === 'input' || el.tag === 'textarea') {
-    genDefaultModel(el, dir.value, dir.modifiers);
-  } else {
-    genComponentModel(el, dir.value, dir.modifiers);
-  }
+function model(el, dir) {
+    if (el.tag === 'input' || el.tag === 'textarea') {
+        genDefaultModel(el, dir.value, dir.modifiers);
+    }
+    else {
+        genComponentModel(el, dir.value, dir.modifiers);
+    }
 }
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var trim = ref.trim;
-  var number = ref.number;
-  var event = lazy ? 'change' : 'input';
-
-  var valueExpression = "$event.target.attr.value" + (trim ? '.trim()' : '');
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  addAttr(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
+function genDefaultModel(el, value, modifiers) {
+    var _a = modifiers || {}, lazy = _a.lazy, trim = _a.trim, number = _a.number;
+    var event = lazy ? 'change' : 'input';
+    var valueExpression = "$event.target.attr.value" + (trim ? '.trim()' : '');
+    if (number) {
+        valueExpression = "_n(" + valueExpression + ")";
+    }
+    var code = genAssignmentCode(value, valueExpression);
+    addAttr(el, 'value', "(" + value + ")");
+    addHandler(el, event, code, null, true);
 }
 
 var directives = {
-  model: model
+    model: model,
 };
 
-/*  */
-
-var isReservedTag = makeMap(
-  'template,script,style,element,content,slot,link,meta,svg,view,' +
-  'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-  'slider,slider-neighbor,indicator,canvas,' +
-  'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-  'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
-  true
-);
-
+// These util functions are split into its own file because Rollup cannot drop
+var isReservedTag = makeMap('template,script,style,element,content,slot,link,meta,svg,view,' +
+    'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
+    'slider,slider-neighbor,indicator,canvas,' +
+    'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
+    'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown', true);
 // Elements that you can, intentionally, leave open (and which close themselves)
 // more flexible than web
-var canBeLeftOpenTag$1 = makeMap(
-  'web,spinner,switch,video,textarea,canvas,' +
-  'indicator,marquee,countdown',
-  true
-);
-
-var isRuntimeComponent = makeMap(
-  'richtext,transition,transition-group',
-  true
-);
-
-var isUnaryTag$1 = makeMap(
-  'embed,img,image,input,link,meta',
-  true
-);
-
-function mustUseProp () {
-  return false
+var canBeLeftOpenTag = makeMap('web,spinner,switch,video,textarea,canvas,' + 'indicator,marquee,countdown', true);
+makeMap('richtext,transition,transition-group', true);
+var isUnaryTag = makeMap('embed,img,image,input,link,meta', true);
+function mustUseProp() {
+    return false;
 }
-
-function getTagNamespace () { }
-
-/*  */
+function getTagNamespace() { }
 
 var baseOptions = {
-  modules: modules,
-  directives: directives,
-  isUnaryTag: isUnaryTag$1,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag$1,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  preserveWhitespace: false,
-  recyclable: false,
-  staticKeys: genStaticKeys(modules)
+    modules: modules,
+    directives: directives,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
+    preserveWhitespace: false,
+    recyclable: false,
+    // @ts-ignore
+    staticKeys: genStaticKeys$1(modules),
 };
-
 var compiler = createCompiler(baseOptions);
-
-function compile (
-  template,
-  options
-) {
-  var generateAltRender = false;
-  if (options && options.recyclable === true) {
-    generateAltRender = true;
-    options.recyclable = false;
-  }
-  var result = compiler.compile(template, options);
-
-  // generate @render function for <recycle-list>
-  if (options && generateAltRender) {
-    options.recyclable = true;
-    // disable static optimizations
-    options.optimize = false;
-    var ref = compiler.compile(template, options);
-    var render = ref.render;
-    result['@render'] = render;
-  }
-  return result
+function compile(template, options) {
+    var generateAltRender = false;
+    if (options && options.recyclable === true) {
+        generateAltRender = true;
+        options.recyclable = false;
+    }
+    var result = compiler.compile(template, options);
+    // generate @render function for <recycle-list>
+    if (options && generateAltRender) {
+        options.recyclable = true;
+        // disable static optimizations
+        options.optimize = false;
+        var render = compiler.compile(template, options).render;
+        result['@render'] = render;
+    }
+    return result;
 }
 
 exports.compile = compile;
diff --git a/packages/weex-template-compiler/package.json b/packages/weex-template-compiler/package.json
index ad08235d07f..f1155267109 100644
--- a/packages/weex-template-compiler/package.json
+++ b/packages/weex-template-compiler/package.json
@@ -18,7 +18,8 @@
   },
   "homepage": "https://github.com/vuejs/vue/tree/dev/packages/weex-template-compiler#readme",
   "dependencies": {
-    "acorn": "^5.2.1",
+    "acorn": "^8.1.0",
+    "acorn-walk": "^8.0.2",
     "escodegen": "^1.8.1",
     "he": "^1.1.0"
   }
diff --git a/packages/weex-template-compiler/yarn.lock b/packages/weex-template-compiler/yarn.lock
new file mode 100644
index 00000000000..3c4f9004f0d
--- /dev/null
+++ b/packages/weex-template-compiler/yarn.lock
@@ -0,0 +1,97 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+acorn-walk@^8.0.2:
+  version "8.0.2"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.0.2.tgz#d4632bfc63fd93d0f15fd05ea0e984ffd3f5a8c3"
+  integrity sha512-+bpA9MJsHdZ4bgfDcpk0ozQyhhVct7rzOmO0s1IIr0AGGgKBljss8n2zp11rRP2wid5VGeh04CgeKzgat5/25A==
+
+acorn@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.1.0.tgz#52311fd7037ae119cbb134309e901aa46295b3fe"
+  integrity sha512-LWCF/Wn0nfHOmJ9rzQApGnxnvgfROzGilS8936rqN/lfcYkY9MYZzdMqN+2NJ4SlTc+m5HiSa+kNfDtI64dwUA==
+
+deep-is@~0.1.3:
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
+  integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
+
+escodegen@^1.8.1:
+  version "1.14.3"
+  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.14.3.tgz#4e7b81fba61581dc97582ed78cab7f0e8d63f503"
+  integrity sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==
+  dependencies:
+    esprima "^4.0.1"
+    estraverse "^4.2.0"
+    esutils "^2.0.2"
+    optionator "^0.8.1"
+  optionalDependencies:
+    source-map "~0.6.1"
+
+esprima@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
+  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
+
+estraverse@^4.2.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
+  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
+
+esutils@^2.0.2:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
+  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
+
+fast-levenshtein@~2.0.6:
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
+  integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
+
+he@^1.1.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
+  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
+
+levn@~0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
+  integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=
+  dependencies:
+    prelude-ls "~1.1.2"
+    type-check "~0.3.2"
+
+optionator@^0.8.1:
+  version "0.8.3"
+  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495"
+  integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==
+  dependencies:
+    deep-is "~0.1.3"
+    fast-levenshtein "~2.0.6"
+    levn "~0.3.0"
+    prelude-ls "~1.1.2"
+    type-check "~0.3.2"
+    word-wrap "~1.2.3"
+
+prelude-ls@~1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
+  integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=
+
+source-map@~0.6.1:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
+type-check@~0.3.2:
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
+  integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=
+  dependencies:
+    prelude-ls "~1.1.2"
+
+word-wrap@~1.2.3:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
+  integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
diff --git a/packages/weex-vue-framework/factory.js b/packages/weex-vue-framework/factory.js
index 4cb547b5250..38bbf0534d0 100644
--- a/packages/weex-vue-framework/factory.js
+++ b/packages/weex-vue-framework/factory.js
@@ -4,189 +4,154 @@
 
 module.exports = function weexFactory (exports, document) {
 
-/*  */
-
 var emptyObject = Object.freeze({});
-
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
  * Objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
 var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
-function isRegExp (v) {
-  return _toString.call(v) === '[object RegExp]'
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null);
+    var list = str.split(',');
+    for (var i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
 var isBuiltInTag = makeMap('slot,component', true);
-
 /**
  * Check if an attribute is a reserved attribute.
  */
 var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove$2(arr, item) {
+    if (arr.length) {
+        var index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
 var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+        var hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
 var camelizeRE = /-(\w)/g;
 var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
 });
-
 /**
  * Capitalize a string.
  */
 var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
 var hyphenateRE = /\B([A-Z])/g;
 var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
 /**
  * Simple bind polyfill for environments that do not support it,
  * e.g., PhantomJS 1.x. Technically, we don't need this anymore
@@ -194,273 +159,238 @@ var hyphenate = cached(function (str) {
  * But removing it would mean breaking code that was able to run in
  * PhantomJS 1.x, so this must be kept for backward compatibility.
  */
-
 /* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        var l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+var bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
-function toArray (list, start) {
-  start = start || 0;
-  var i = list.length - start;
-  var ret = new Array(i);
-  while (i--) {
-    ret[i] = list[i + start];
-  }
-  return ret
+function toArray(list, start) {
+    start = start || 0;
+    var i = list.length - start;
+    var ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
 }
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (var key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject$1(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
 var no = function (a, b, c) { return false; };
-
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
 var identity = function (_) { return _; };
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
+function looseEqual(a, b) {
+    if (a === b)
+        { return true; }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            var isArrayA = Array.isArray(a);
+            var isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every(function (e, i) {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                var keysA = Object.keys(a);
+                var keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every(function (key) {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
+function looseIndexOf(arr, val) {
+    for (var i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            { return i; }
+    }
+    return -1;
 }
-
 /**
  * Ensure a function is called only once.
  */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
+function once(fn) {
+    var called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
 var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
+var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch' ];
+
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
 /**
  * unicode letters used for parsing html tags, component names and property paths.
@@ -468,828 +398,752 @@ var config = ({
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
 var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
 /**
  * Check if a string starts with $ or _
  */
-function isReserved (str) {
-  var c = (str + '').charCodeAt(0);
-  return c === 0x24 || c === 0x5F
+function isReserved(str) {
+    var c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
 }
-
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
-
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-function parsePath (path) {
-  if (bailRE.test(path)) {
-    return
-  }
-  var segments = path.split('.');
-  return function (obj) {
-    for (var i = 0; i < segments.length; i++) {
-      if (!obj) { return }
-      obj = obj[segments[i]];
-    }
-    return obj
-  }
+var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    var segments = path.split('.');
+    return function (obj) {
+        for (var i = 0; i < segments.length; i++) {
+            if (!obj)
+                { return; }
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-/*  */
-
 // can we use __proto__?
 var hasProto = '__proto__' in {};
-
 // Browser environment sniffing
 var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
+var inWeex = 
+// @ts-ignore
+typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+// @ts-ignore
 var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 var UA = inBrowser && window.navigator.userAgent.toLowerCase();
 var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+UA && UA.indexOf('msie 9.0') > 0;
 var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
-
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// @ts-ignore
+var nativeWatch = {}.watch;
+var supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        var opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get: function () {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        // @ts-ignore
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
 var _isServer;
 var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
 // detect devtools
+// @ts-ignore TODO decalre this types
 var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
-
-    return Set;
-  }());
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+var hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+var _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /** @class */ (function () {
+        function Set() {
+            this.set = Object.create(null);
+        }
+        Set.prototype.has = function (key) {
+            return this.set[key] === true;
+        };
+        Set.prototype.add = function (key) {
+            this.set[key] = true;
+        };
+        Set.prototype.clear = function () {
+            this.set = Object.create(null);
+        };
+        return Set;
+    }());
 }
 
-/*  */
-
 var warn = noop;
 var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
+var generateComponentTrace; // work around flow check
+var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (config.warnHandler) {
-      config.warnHandler.call(null, msg, vm, trace);
-    } else if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
+    var hasConsole_1 = typeof console !== 'undefined';
+    var classifyRE_1 = /(?:^|[-_])(\w)/g;
+    var classify_1 = function (str) {
+        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
+    };
+    warn = function (msg, vm) {
+        var trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole_1 && !config.silent) {
+            console.error("[Vue warn]: " + msg + trace);
+        }
+    };
+    tip = function (msg, vm) {
+        if (hasConsole_1 && !config.silent) {
+            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = function (vm, includeFile) {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        var options = 
+        // @ts-ignore
+        typeof vm === 'function' && vm.cid != null
+            ? // @ts-ignore
+                vm.options
+            : vm._isVue
+                ? // @ts-ignore
+                    vm.$options || vm.constructor.options
+                : vm;
+        var name = options.name || options._componentTag;
+        var file = options.__file;
+        if (!name && file) {
+            var match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
+            (file && includeFile !== false ? " at " + file : ''));
+    };
+    var repeat_1 = function (str, n) {
+        var res = '';
+        while (n) {
+            if (n % 2 === 1)
+                { res += str; }
+            if (n > 1)
+                { str += str; }
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = function (vm) {
+        // @ts-ignore
+        if (vm._isVue && vm.$parent) {
+            var tree = [];
+            var currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    var last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map(function (vm, i) {
+                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
+                        : formatComponentName(vm));
+                })
+                    .join('\n'));
+        }
+        else {
+            return "\n\n(found in " + formatComponentName(vm) + ")";
+        }
+    };
 }
 
-/*  */
-
-var uid = 0;
-
+var uid$3 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
-};
-
-Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
-};
-
-Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
-};
-
-Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
-};
-
-Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
-};
-
+var Dep = /** @class */ (function () {
+    function Dep() {
+        this.id = uid$3++;
+        this.subs = [];
+    }
+    Dep.prototype.addSub = function (sub) {
+        this.subs.push(sub);
+    };
+    Dep.prototype.removeSub = function (sub) {
+        remove$2(this.subs, sub);
+    };
+    Dep.prototype.depend = function () {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    };
+    Dep.prototype.notify = function () {
+        // stabilize the subscriber list first
+        var subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort(function (a, b) { return a.id - b.id; });
+        }
+        for (var i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    };
+    return Dep;
+}());
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
-}
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
-}
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-  return this.componentInstance
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
+}
+
+var VNode = /** @class */ (function () {
+    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    Object.defineProperty(VNode.prototype, "child", {
+        // DEPRECATED: alias for componentInstance for backwards compat.
+        /* istanbul ignore next */
+        get: function () {
+            return this.componentInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return VNode;
+}());
 var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
-
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+    if (text === void 0) { text = ''; }
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    var cloned = new VNode(
+    //@ts-expect-error void type not valid here
+    vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
 var arrayProto = Array.prototype;
 var arrayMethods = Object.create(arrayProto);
-
 var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse' ];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+        var arguments$1 = arguments;
+
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments$1[_i];
+        }
+        var result = original.apply(this, args);
+        var ob = this.__ob__;
+        var inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            { ob.observeArray(inserted); }
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
 var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
 var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
-};
-
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
-};
-
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
-};
-
+var Observer = /** @class */ (function () {
+    function Observer(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+        var keys = Object.keys(obj);
+        for (var i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    };
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+        for (var i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    };
+    return Observer;
+}());
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+        var key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    var ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive(obj, key, val, customSetter, shallow) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            var value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            var value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                { return; }
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Delete a property and trigger change if necessary.
  */
-function del (target, key) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot delete reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.splice(key, 1);
-    return
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid deleting properties on a Vue instance or its root $data ' +
-      '- just set it to null.'
-    );
-    return
-  }
-  if (!hasOwn(target, key)) {
-    return
-  }
-  delete target[key];
-  if (!ob) {
-    return
-  }
-  ob.dep.notify();
-}
-
+function del(target, key) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    var ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
+}
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
 var strats = config.optionMergeStrategies;
-
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn("option \"" + key + "\" can only be used during instance " +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        { return to; }
+    var key, toVal, fromVal;
+    var keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            { continue; }
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(
+            // @ts-ignore
+            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+            // @ts-ignore
+            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
     }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook$1(parentVal, childVal) {
+    var res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+    strats[hook] = mergeHook$1;
 });
-
 /**
  * Assets
  *
@@ -1297,611 +1151,543 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        { parentVal = undefined; }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        { childVal = undefined; }
+    /* istanbul ignore if */
+    if (!childVal)
+        { return Object.create(parentVal || null); }
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key_1 in childVal) {
+        var parent_1 = ret[key_1];
+        var child = childVal[key_1];
+        if (parent_1 && !Array.isArray(parent_1)) {
+            parent_1 = [parent_1];
+        }
+        ret[key_1] = parent_1
+            ? parent_1.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        { return childVal; }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        { extend(ret, childVal); }
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
 var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (var key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else if (process.env.NODE_ENV !== 'production') {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    var props = options.props;
+    if (!props)
+        { return; }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (var key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("Invalid value for option \"props\": expected an Array or an Object, " +
+            ("but got " + toRawType(props) + "."), vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    var inject = options.inject;
+    if (!inject)
+        { return; }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (var i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (var key in inject) {
+            var val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+            ("but got " + toRawType(inject) + "."), vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
+function normalizeDirectives$1(options) {
+    var dirs = options.directives;
+    if (dirs) {
+        for (var key in dirs) {
+            var def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
     }
-  }
 }
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn("Invalid value for option \"" + name + "\": expected an Object, " +
+            ("but got " + toRawType(value) + "."), vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (var i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        var strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    // skip validation for weex recycle-list child component props
-    !(isObject(value) && ('@binding' in value))
-  ) {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        { return assets[id]; }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        { return assets[camelizedId]; }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        { return assets[PascalCaseId]; }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+function validateProp(key, propOptions, propsData, vm) {
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            var stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        var prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        // skip validation for weex recycle-list child component props
+        !(isObject(value) && '@binding' in value)) {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i]);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  if (!valid) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (var i = 0; i < type.length && !valid; i++) {
+            var assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
-
-function assertType (value, type) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    valid = value instanceof type;
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        var t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid: valid,
+        expectedType: expectedType,
+    };
 }
-
+var functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(/^\s*function (\w+)/);
-  return match ? match[1] : ''
+function getType(fn) {
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
 }
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
+function isSameType(a, b) {
+    return getType(a) === getType(b);
 }
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
     }
-  }
-  return -1
+    return -1;
 }
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  var expectedValue = styleValue(value, expectedType);
-  var receivedValue = styleValue(value, receivedType);
-  // check if we need to specify expected value
-  if (expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      !isBoolean(expectedType, receivedType)) {
-    message += " with value " + expectedValue;
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + receivedValue + ".";
-  }
-  return message
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+        (" Expected " + expectedTypes.map(capitalize).join(', '));
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += " with value " + styleValue(value, expectedType);
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += "with value " + styleValue(value, receivedType) + ".";
+    }
+    return message;
 }
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
+function styleValue(value, type) {
+    if (type === 'String') {
+        return "\"" + value + "\"";
+    }
+    else if (type === 'Number') {
+        return "" + Number(value);
+    }
+    else {
+        return "" + value;
+    }
 }
-
-function isExplicable (value) {
-  var explicitTypes = ['string', 'number', 'boolean'];
-  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
+var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
+function isBoolean() {
+    var arguments$1 = arguments;
 
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments$1[_i];
+    }
+    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            var cur = vm;
+            while ((cur = cur.$parent)) {
+                var hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (var i = 0; i < hooks.length; i++) {
+                        try {
+                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                { return; }
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
             }
-          }
         }
-      }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
-}
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
 }
-
-function globalHandleError (err, vm, info) {
-  if (config.errorHandler) {
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    var res;
     try {
-      return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
-      // if the user intentionally throws the original error in the handler,
-      // do not log it twice
-      if (e !== err) {
-        logError(e, null, 'config.errorHandler');
-      }
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
     }
-  }
-  logError(err, vm, info);
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
 }
-
-function logError (err, vm, info) {
-  if (process.env.NODE_ENV !== 'production') {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    if (process.env.NODE_ENV !== 'production') {
+        warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/*  */
-
+/* globals MutationObserver */
 var callbacks = [];
 var pending = false;
-
-function flushCallbacks () {
-  pending = false;
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+function flushCallbacks() {
+    pending = false;
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // Here we have async deferring wrappers using microtasks.
 // In 2.5 we used (macro) tasks (in combination with microtasks).
 // However, it has subtle problems when state is changed right before repaint
@@ -1914,7 +1700,6 @@ function flushCallbacks () {
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
 var timerFunc;
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1923,407 +1708,366 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  var p = Promise.resolve();
-  timerFunc = function () {
-    p.then(flushCallbacks);
-    // In problematic UIWebViews, Promise.then doesn't completely break, but
-    // it can get stuck in a weird state where callbacks are pushed into the
-    // microtask queue but the queue isn't being flushed, until the browser
-    // needs to do some other work, e.g. handle a timer. Therefore we can
-    // "force" the microtask queue to be flushed by adding an empty timer.
-    if (isIOS) { setTimeout(noop); }
-  };
-} else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-  timerFunc = function () {
-    counter = (counter + 1) % 2;
-    textNode.data = String(counter);
-  };
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-  // Fallback to setImmediate.
-  // Technically it leverages the (macro) task queue,
-  // but it is still a better choice than setTimeout.
-  timerFunc = function () {
-    setImmediate(flushCallbacks);
-  };
-} else {
-  // Fallback to setTimeout.
-  timerFunc = function () {
-    setTimeout(flushCallbacks, 0);
-  };
+    var p_1 = Promise.resolve();
+    timerFunc = function () {
+        p_1.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            { setTimeout(noop); }
+    };
 }
-
-function nextTick (cb, ctx) {
-  var _resolve;
-  callbacks.push(function () {
-    if (cb) {
-      try {
-        cb.call(ctx);
-      } catch (e) {
-        handleError(e, ctx, 'nextTick');
-      }
-    } else if (_resolve) {
-      _resolve(ctx);
-    }
-  });
-  if (!pending) {
-    pending = true;
-    timerFunc();
-  }
-  // $flow-disable-line
-  if (!cb && typeof Promise !== 'undefined') {
-    return new Promise(function (resolve) {
-      _resolve = resolve;
-    })
-  }
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter_1 = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode_1 = document.createTextNode(String(counter_1));
+    observer.observe(textNode_1, {
+        characterData: true,
+    });
+    timerFunc = function () {
+        counter_1 = (counter_1 + 1) % 2;
+        textNode_1.data = String(counter_1);
+    };
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = function () {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = function () {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    var _resolve;
+    callbacks.push(function () {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise(function (resolve) {
+            _resolve = resolve;
+        });
+    }
 }
-
-/*  */
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 var initProxy;
-
 if (process.env.NODE_ENV !== 'production') {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var warnNonPresent = function (target, key) {
-    warn(
-      "Property or method \"" + key + "\" is not defined on the instance but " +
-      'referenced during render. Make sure that this property is reactive, ' +
-      'either in the data option, or for class-based components, by ' +
-      'initializing the property. ' +
-      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
-      target
-    );
-  };
-
-  var warnReservedPrefix = function (target, key) {
-    warn(
-      "Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-      'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-      'prevent conflicts with Vue internals. ' +
-      'See: https://vuejs.org/v2/api/#data',
-      target
+    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
     );
-  };
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
-
-  var hasHandler = {
-    has: function has (target, key) {
-      var has = key in target;
-      var isAllowed = allowedGlobals(key) ||
-        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
-      if (!has && !isAllowed) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return has || !isAllowed
-    }
-  };
-
-  var getHandler = {
-    get: function get (target, key) {
-      if (typeof key === 'string' && !(key in target)) {
-        if (key in target.$data) { warnReservedPrefix(target, key); }
-        else { warnNonPresent(target, key); }
-      }
-      return target[key]
-    }
-  };
-
-  initProxy = function initProxy (vm) {
-    if (hasProxy) {
-      // determine which proxy handler to use
-      var options = vm.$options;
-      var handlers = options.render && options.render._withStripped
-        ? getHandler
-        : hasHandler;
-      vm._renderProxy = new Proxy(vm, handlers);
-    } else {
-      vm._renderProxy = vm;
-    }
-  };
+    var warnNonPresent_1 = function (target, key) {
+        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    var warnReservedPrefix_1 = function (target, key) {
+        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy_1) {
+        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set: function (target, key, value) {
+                if (isBuiltInModifier_1(key)) {
+                    warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
+    var hasHandler_1 = {
+        has: function (target, key) {
+            var has = key in target;
+            var isAllowed = allowedGlobals_1(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    { warnReservedPrefix_1(target, key); }
+                else
+                    { warnNonPresent_1(target, key); }
+            }
+            return has || !isAllowed;
+        },
+    };
+    var getHandler_1 = {
+        get: function (target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    { warnReservedPrefix_1(target, key); }
+                else
+                    { warnNonPresent_1(target, key); }
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy_1) {
+            // determine which proxy handler to use
+            var options = vm.$options;
+            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-/*  */
-
 var seenObjects = new _Set();
-
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    var i, keys;
+    var isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        var depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            { _traverse(val[i], seen); }
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            { _traverse(val[keys[i]], seen); }
+    }
 }
 
 var mark;
 var measure;
-
 if (process.env.NODE_ENV !== 'production') {
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) {
-    mark = function (tag) { return perf.mark(tag); };
-    measure = function (name, startTag, endTag) {
-      perf.measure(name, startTag, endTag);
-      perf.clearMarks(startTag);
-      perf.clearMarks(endTag);
-      // perf.clearMeasures(name)
-    };
-  }
+    var perf_1 = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf_1 &&
+        perf_1.mark &&
+        perf_1.measure &&
+        perf_1.clearMarks &&
+        perf_1.clearMeasures) {
+        mark = function (tag) { return perf_1.mark(tag); };
+        measure = function (name, startTag, endTag) {
+            perf_1.measure(name, startTag, endTag);
+            perf_1.clearMarks(startTag);
+            perf_1.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-/*  */
-
 var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+    var passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    var capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name: name,
+        once: once,
+        capture: capture,
+        passive: passive,
+    };
 });
-
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    /* istanbul ignore if */
-    if (isPlainObject(def$$1)) {
-      cur = def$$1.handler;
-      event.params = def$$1.params;
-    }
-    if (isUndef(cur)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        var arguments$1 = arguments;
+
+        var fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            var cloned = fns.slice();
+            for (var i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
 }
-
-/*  */
-
-function mergeVNodeHook (def, hookKey, hook) {
-  if (def instanceof VNode) {
-    def = def.data.hook || (def.data.hook = {});
-  }
-  var invoker;
-  var oldHook = def[hookKey];
-
-  function wrappedHook () {
-    hook.apply(this, arguments);
-    // important: remove merged hook to ensure it's called only once
-    // and prevent memory leak
-    remove(invoker.fns, wrappedHook);
-  }
-
-  if (isUndef(oldHook)) {
-    // no existing hook
-    invoker = createFnInvoker([wrappedHook]);
-  } else {
-    /* istanbul ignore if */
-    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-      // already a merged invoker
-      invoker = oldHook;
-      invoker.fns.push(wrappedHook);
-    } else {
-      // existing plain hook
-      invoker = createFnInvoker([oldHook, wrappedHook]);
-    }
-  }
-
-  invoker.merged = true;
-  def[hookKey] = invoker;
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    var name, def, cur, old, event;
+    for (name in on) {
+        def = cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        /* istanbul ignore if */
+        if (isPlainObject(def)) {
+            cur = def.handler;
+            event.params = def.params;
+        }
+        if (isUndef(cur)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      if (process.env.NODE_ENV !== 'production') {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    var invoker;
+    var oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    var res = {};
+    var attrs = data.attrs, props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+        for (var key in propOptions) {
+            var altKey = hyphenate(key);
+            if (process.env.NODE_ENV !== 'production') {
+                var keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                        (formatComponentName(
+                        // @ts-ignore
+                        tag || Ctor) + ", but the declared prop name is") +
+                        (" \"" + key + "\". ") +
+                        "Note that HTML attributes are case-insensitive and camelCased " +
+                        "props need to use their kebab-case equivalents when using in-DOM " +
+                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
-
-/*  */
 
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
@@ -2331,2096 +2075,1796 @@ function checkProp (
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (var i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
-}
-
-/*  */
-
-function initProvide (vm) {
-  var provide = vm.$options.provide;
-  if (provide) {
-    vm._provided = typeof provide === 'function'
-      ? provide.call(vm)
-      : provide;
-  }
-}
-
-function initInjections (vm) {
-  var result = resolveInject(vm.$options.inject, vm);
-  if (result) {
-    toggleObserving(false);
-    Object.keys(result).forEach(function (key) {
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
-        defineReactive$$1(vm, key, result[key], function () {
-          warn(
-            "Avoid mutating an injected value directly since the changes will be " +
-            "overwritten whenever the provided component re-renders. " +
-            "injection being mutated: \"" + key + "\"",
-            vm
-          );
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            { continue; }
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
+}
+
+function initProvide(vm) {
+    var provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    var result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach(function (key) {
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production') {
+                defineReactive(vm, key, result[key], function () {
+                    warn("Avoid mutating an injected value directly since the changes will be " +
+                        "overwritten whenever the provided component re-renders. " +
+                        ("injection being mutated: \"" + key + "\""), vm);
+                });
+            }
+            else {
+                defineReactive(vm, key, result[key]);
+            }
         });
-      } else {
-        defineReactive$$1(vm, key, result[key]);
-      }
-    });
-    toggleObserving(true);
-  }
-}
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
-        }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else if (process.env.NODE_ENV !== 'production') {
-          warn(("Injection \"" + key + "\" not found"), vm);
-        }
-      }
-    }
-    return result
-  }
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        var result = Object.create(null);
+        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                { continue; }
+            var provideKey = inject[key].from;
+            var source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    var provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    // @ts-ignore
+                    warn("Injection \"" + key + "\" not found", vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/*  */
-
-
-
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
-}
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
-}
-
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+        var child = children[i];
+        var data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            var name_1 = data.slot;
+            var slot = slots[name_1] || (slots[name_1] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (var name_2 in slots) {
+        if (slots[name_2].every(isWhitespace)) {
+            delete slots[name_2];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+}
+
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (var key_1 in slots) {
+            if (slots[key_1] && key_1[0] !== '$') {
+                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (var key_2 in normalSlots) {
+        if (!(key_2 in res)) {
+            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, '$stable', isStable);
+    def(res, '$key', key);
+    def(res, '$hasNormal', hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    return res && (
-      res.length === 0 ||
-      (res.length === 1 && res[0].isComment) // #9658
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    var normalized = function () {
+        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === 'object' && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return function () { return slots[key]; };
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    var ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            var iterator = val[Symbol.iterator]();
+            var result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
+    ret._isVList = true;
+    return ret;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallback,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) { // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-        warn(
-          'slot v-bind without argument expects an Object',
-          this
-        );
-      }
-      props = extend(extend({}, bindObject), props);
+function renderSlot(name, fallback, props, bindObject) {
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
+                warn('slot v-bind without argument expects an Object', this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes = scopedSlotFn(props) || fallback;
+    }
+    else {
+        nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+        return this.$createElement('template', { slot: target }, nodes);
+    }
+    else {
+        return nodes;
     }
-    nodes = scopedSlotFn(props) || fallback;
-  } else {
-    nodes = this.$slots[name] || fallback;
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
 }
 
-/*  */
-
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject$1(value);
+            }
+            var hash = void 0;
+            var _loop_1 = function (key) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    var type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                var camelizedKey = camelize(key);
+                var hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        var on = data.on || (data.on = {});
+                        on["update:" + key] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
             };
-          }
+            for (var key in value) {
+                _loop_1(key);
+            }
         }
-      };
-
-      for (var key in value) loop( key );
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, "__static__" + index, false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
-}
-
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
-    }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+function markOnce(tree, index, key) {
+    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (var i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], key + "_" + i, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
 }
-
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            var on = (data.on = data.on ? extend({}, data.on) : {});
+            for (var key in value) {
+                var existing = on[key];
+                var ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+        var slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (var i = 0; i < values.length; i += 2) {
+        var key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (process.env.NODE_ENV !== 'production' &&
+            key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
-}
-
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
+}
+
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    var _this = this;
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
     }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+        if (!_this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+        }
+        return _this.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get: function () {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = function (a, b, c, d) {
+            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = function (a, b, c, d) {
+            return createElement$1(contextVm, a, b, c, d, needNormalization);
+        };
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
-
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (var key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            { mergeProps(props, data.attrs); }
+        if (isDef(data.props))
+            { mergeProps(props, data.props); }
+    }
+    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        var vnodes = normalizeChildren(vnode) || [];
+        var res = new Array(vnodes.length);
+        for (var i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
     }
-    return res
-  }
 }
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    if (process.env.NODE_ENV !== 'production') {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
 }
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
+function mergeProps(to, from) {
+    for (var key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-/*  */
-
 var RECYCLE_LIST_MARKER = '@inRecycleList';
-
 // Register the component hook to weex native render engine.
 // The hook will be triggered by native, not javascript.
-function registerComponentHook (
-  componentId,
-  type, // hook type, could be "lifecycle" or "instance"
-  hook, // hook name
-  fn
-) {
-  if (!document || !document.taskCenter) {
-    warn("Can't find available \"document\" or \"taskCenter\".");
-    return
-  }
-  if (typeof document.taskCenter.registerHook === 'function') {
-    return document.taskCenter.registerHook(componentId, type, hook, fn)
-  }
-  warn(("Failed to register component hook \"" + type + "@" + hook + "#" + componentId + "\"."));
+function registerComponentHook(componentId, type, // hook type, could be "lifecycle" or "instance"
+hook, // hook name
+fn) {
+    if (!document || !document.taskCenter) {
+        warn("Can't find available \"document\" or \"taskCenter\".");
+        return;
+    }
+    if (typeof document.taskCenter.registerHook === 'function') {
+        return document.taskCenter.registerHook(componentId, type, hook, fn);
+    }
+    warn("Failed to register component hook \"" + type + "@" + hook + "#" + componentId + "\".");
 }
-
 // Updates the state of the component to weex native render engine.
-function updateComponentData (
-  componentId,
-  newData,
-  callback
-) {
-  if (!document || !document.taskCenter) {
-    warn("Can't find available \"document\" or \"taskCenter\".");
-    return
-  }
-  if (typeof document.taskCenter.updateData === 'function') {
-    return document.taskCenter.updateData(componentId, newData, callback)
-  }
-  warn(("Failed to update component data (" + componentId + ")."));
+function updateComponentData(componentId, newData, callback) {
+    if (!document || !document.taskCenter) {
+        warn("Can't find available \"document\" or \"taskCenter\".");
+        return;
+    }
+    if (typeof document.taskCenter.updateData === 'function') {
+        return document.taskCenter.updateData(componentId, newData, callback);
+    }
+    warn("Failed to update component data (" + componentId + ").");
 }
 
-/*  */
-
-var uid$1 = 0;
-
+// https://github.com/Hanks10100/weex-native-directive/tree/master/component
+var uid$2 = 0;
 // override Vue.prototype._init
-function initVirtualComponent (options) {
-  if ( options === void 0 ) options = {};
-
-  var vm = this;
-  var componentId = options.componentId;
-
-  // virtual component uid
-  vm._uid = "virtual-component-" + (uid$1++);
-
-  // a flag to avoid this being observed
-  vm._isVue = true;
-  // merge options
-  if (options && options._isComponent) {
-    // optimize internal component instantiation
-    // since dynamic options merging is pretty slow, and none of the
-    // internal component options needs special treatment.
-    initInternalComponent(vm, options);
-  } else {
-    vm.$options = mergeOptions(
-      resolveConstructorOptions(vm.constructor),
-      options || {},
-      vm
-    );
-  }
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    initProxy(vm);
-  } else {
-    vm._renderProxy = vm;
-  }
-
-  vm._self = vm;
-  initLifecycle(vm);
-  initEvents(vm);
-  initRender(vm);
-  callHook(vm, 'beforeCreate');
-  initInjections(vm); // resolve injections before data/props
-  initState(vm);
-  initProvide(vm); // resolve provide after data/props
-  callHook(vm, 'created');
-
-  // send initial data to native
-  var data = vm.$options.data;
-  var params = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (isPlainObject(params)) {
-    updateComponentData(componentId, params);
-  }
-
-  registerComponentHook(componentId, 'lifecycle', 'attach', function () {
-    callHook(vm, 'beforeMount');
-
-    var updateComponent = function () {
-      vm._update(vm._vnode, false);
-    };
-    new Watcher(vm, updateComponent, noop, null, true);
-
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  });
-
-  registerComponentHook(componentId, 'lifecycle', 'detach', function () {
-    vm.$destroy();
-  });
-}
-
-// override Vue.prototype._update
-function updateVirtualComponent (vnode) {
-  var vm = this;
-  var componentId = vm.$options.componentId;
-  if (vm._isMounted) {
-    callHook(vm, 'beforeUpdate');
-  }
-  vm._vnode = vnode;
-  if (vm._isMounted && componentId) {
-    // TODO: data should be filtered and without bindings
-    var data = Object.assign({}, vm._data);
-    updateComponentData(componentId, data, function () {
-      callHook(vm, 'updated');
+function initVirtualComponent(options) {
+    if (options === void 0) { options = {}; }
+    var vm = this;
+    var componentId = options.componentId;
+    // virtual component uid
+    vm._uid = "virtual-component-" + uid$2++;
+    // a flag to avoid this being observed
+    vm._isVue = true;
+    // merge options
+    if (options && options._isComponent) {
+        // optimize internal component instantiation
+        // since dynamic options merging is pretty slow, and none of the
+        // internal component options needs special treatment.
+        //@ts-expect-error
+        initInternalComponent(vm, options);
+    }
+    else {
+        vm.$options = mergeOptions(
+        //@ts-expect-error
+        resolveConstructorOptions(vm.constructor), options || {}, vm);
+    }
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+        initProxy(vm);
+    }
+    else {
+        vm._renderProxy = vm;
+    }
+    vm._self = vm;
+    initLifecycle(vm);
+    initEvents(vm);
+    initRender(vm);
+    callHook$1(vm, 'beforeCreate');
+    initInjections(vm); // resolve injections before data/props
+    initState(vm);
+    initProvide(vm); // resolve provide after data/props
+    callHook$1(vm, 'created');
+    // send initial data to native
+    var data = vm.$options.data;
+    var params = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (isPlainObject(params)) {
+        updateComponentData(componentId, params);
+    }
+    registerComponentHook(componentId, 'lifecycle', 'attach', function () {
+        callHook$1(vm, 'beforeMount');
+        var updateComponent = function () {
+            vm._update(vm._vnode, false);
+        };
+        new Watcher(vm, updateComponent, noop, null, true);
+        vm._isMounted = true;
+        callHook$1(vm, 'mounted');
+    });
+    registerComponentHook(componentId, 'lifecycle', 'detach', function () {
+        vm.$destroy();
     });
-  }
 }
-
-// listening on native callback
-function resolveVirtualComponent (vnode) {
-  var BaseCtor = vnode.componentOptions.Ctor;
-  var VirtualComponent = BaseCtor.extend({});
-  var cid = VirtualComponent.cid;
-  VirtualComponent.prototype._init = initVirtualComponent;
-  VirtualComponent.prototype._update = updateVirtualComponent;
-
-  vnode.componentOptions.Ctor = BaseCtor.extend({
-    beforeCreate: function beforeCreate () {
-      // const vm: Component = this
-
-      // TODO: listen on all events and dispatch them to the
-      // corresponding virtual components according to the componentId.
-      // vm._virtualComponents = {}
-      var createVirtualComponent = function (componentId, propsData) {
-        // create virtual component
-        // const subVm =
-        new VirtualComponent({
-          componentId: componentId,
-          propsData: propsData
+// override Vue.prototype._update
+function updateVirtualComponent(vnode) {
+    var vm = this;
+    var componentId = vm.$options.componentId;
+    if (vm._isMounted) {
+        callHook$1(vm, 'beforeUpdate');
+    }
+    vm._vnode = vnode;
+    if (vm._isMounted && componentId) {
+        // TODO: data should be filtered and without bindings
+        var data = Object.assign({}, vm._data);
+        updateComponentData(componentId, data, function () {
+            callHook$1(vm, 'updated');
         });
-        // if (vm._virtualComponents) {
-        //   vm._virtualComponents[componentId] = subVm
-        // }
-      };
-
-      registerComponentHook(cid, 'lifecycle', 'create', createVirtualComponent);
-    },
-    beforeDestroy: function beforeDestroy () {
-      delete this._virtualComponents;
     }
-  });
 }
-
-/*  */
-
-function isRecyclableComponent (vnode) {
-  return vnode.data.attrs
-    ? (RECYCLE_LIST_MARKER in vnode.data.attrs)
-    : false
+// listening on native callback
+function resolveVirtualComponent(vnode) {
+    var BaseCtor = vnode.componentOptions.Ctor;
+    var VirtualComponent = BaseCtor.extend({});
+    var cid = VirtualComponent.cid;
+    VirtualComponent.prototype._init = initVirtualComponent;
+    VirtualComponent.prototype._update = updateVirtualComponent;
+    vnode.componentOptions.Ctor = BaseCtor.extend({
+        beforeCreate: function () {
+            // const vm: Component = this
+            // TODO: listen on all events and dispatch them to the
+            // corresponding virtual components according to the componentId.
+            // vm._virtualComponents = {}
+            var createVirtualComponent = function (componentId, propsData) {
+                // create virtual component
+                // const subVm =
+                new VirtualComponent({
+                    componentId: componentId,
+                    propsData: propsData,
+                });
+                // if (vm._virtualComponents) {
+                //   vm._virtualComponents[componentId] = subVm
+                // }
+            };
+            registerComponentHook(cid, 'lifecycle', 'create', createVirtualComponent);
+        },
+        beforeDestroy: function () {
+            delete this._virtualComponents;
+        },
+    });
 }
 
-function renderRecyclableComponentTemplate (vnode) {
-  // $flow-disable-line
-  delete vnode.data.attrs[RECYCLE_LIST_MARKER];
-  resolveVirtualComponent(vnode);
-  var vm = createComponentInstanceForVnode(vnode);
-  var render = (vm.$options)['@render'];
-  if (render) {
-    try {
-      return render.call(vm)
-    } catch (err) {
-      handleError(err, vm, "@render");
-    }
-  } else {
-    warn(
-      "@render function not defined on component used in <recycle-list>. " +
-      "Make sure to declare `recyclable=\"true\"` on the component's template.",
-      vm
-    );
-  }
+function isRecyclableComponent(vnode) {
+    return vnode.data.attrs ? RECYCLE_LIST_MARKER in vnode.data.attrs : false;
+}
+function renderRecyclableComponentTemplate(vnode) {
+    //@ts-expect-error
+    delete vnode.data.attrs[RECYCLE_LIST_MARKER];
+    resolveVirtualComponent(vnode);
+    var vm = createComponentInstanceForVnode(vnode);
+    var render = vm.$options['@render'];
+    if (render) {
+        try {
+            return render.call(vm);
+        }
+        catch (err) {
+            handleError(err, vm, "@render");
+        }
+    }
+    else {
+        warn("@render function not defined on component used in <recycle-list>. " +
+            "Make sure to declare `recyclable=\"true\"` on the component's template.", vm);
+    }
 }
-
-/*  */
 
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
+    init: function (vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            var mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch: function (oldVnode, vnode) {
+        var options = vnode.componentOptions;
+        var child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert: function (vnode) {
+        var context = vnode.context, componentInstance = vnode.componentInstance;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook$1(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy: function (vnode) {
+        var componentInstance = vnode.componentInstance;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
 };
-
 var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
-    if (process.env.NODE_ENV !== 'production') {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        if (process.env.NODE_ENV !== 'production') {
+            warn("Invalid Component definition: " + String(Ctor), context);
+        }
+        return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
     }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        var slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
     }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  // Weex specific: invoke recycle-list optimized @render function for
-  // extracting cell-slot template.
-  // https://github.com/Hanks10100/weex-native-directive/tree/master/component
-  /* istanbul ignore if */
-  if (isRecyclableComponent(vnode)) {
-    return renderRecyclableComponentTemplate(vnode)
-  }
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  vnode, // we know it's MountedComponentVNode but flow doesn't
-  parent // activeInstance in lifecycle state
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
-}
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
+    // @ts-expect-error
+    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    // Weex specific: invoke recycle-list optimized @render function for
+    // extracting cell-slot template.
+    // https://github.com/Hanks10100/weex-native-directive/tree/master/component
+    /* istanbul ignore if */
+    if (isRecyclableComponent(vnode)) {
+        return renderRecyclableComponentTemplate(vnode);
+    }
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    var options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+        var key = hooksToMerge[i];
+        var existing = hooks[key];
+        var toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
     }
-  }
 }
-
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
+function mergeHook(f1, f2) {
+    var merged = function (a, b) {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
+function transformModel(options, data) {
+    var prop = (options.model && options.model.prop) || 'value';
+    var event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-/*  */
-
 var SIMPLE_NORMALIZE = 1;
 var ALWAYS_NORMALIZE = 2;
-
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (process.env.NODE_ENV !== 'production' &&
-    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    if (!('@binding' in data.key)) {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if (config.isReservedTag(tag)) {
-      // platform built-in elements
-      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {
-        warn(
-          ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
-          context
-        );
-      }
-      vnode = new VNode(
-        config.parsePlatformTagName(tag), data, children,
-        undefined, undefined, context
-      );
-    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
 }
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (process.env.NODE_ENV !== 'production' &&
+        isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        if (!('@binding' in data.key)) {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === 'string') {
+        var Ctor = void 0;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (process.env.NODE_ENV !== 'production' &&
+                isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            { applyNS(vnode, ns); }
+        if (isDef(data))
+            { registerDeepBindings(data); }
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (var i = 0, l = vnode.children.length; i < l; i++) {
+            var child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
-}
-
-/*  */
-
-function initRender (vm) {
-  vm._vnode = null; // the root of the child tree
-  vm._staticTrees = null; // v-once cached trees
-  var options = vm.$options;
-  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree
-  var renderContext = parentVnode && parentVnode.context;
-  vm.$slots = resolveSlots(options._renderChildren, renderContext);
-  vm.$scopedSlots = emptyObject;
-  // bind the createElement fn to this instance
-  // so that we get proper render context inside it.
-  // args order: tag, data, children, normalizationType, alwaysNormalize
-  // internal version is used by render functions compiled from templates
-  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
-  // normalization is always applied for the public version, used in
-  // user-written render functions.
-  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
-
-  // $attrs & $listeners are exposed for easier HOC creation.
-  // they need to be reactive so that HOCs using them are always updated
-  var parentData = parentVnode && parentVnode.data;
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-    }, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
-      !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-    }, true);
-  } else {
-    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);
-    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-  }
-}
-
-var currentRenderingInstance = null;
-
-function renderMixin (Vue) {
-  // install runtime convenience helpers
-  installRenderHelpers(Vue.prototype);
-
-  Vue.prototype.$nextTick = function (fn) {
-    return nextTick(fn, this)
-  };
-
-  Vue.prototype._render = function () {
-    var vm = this;
-    var ref = vm.$options;
-    var render = ref.render;
-    var _parentVnode = ref._parentVnode;
-
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      );
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
+}
+
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    var parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        }, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
+            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        }, true);
     }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode;
-    // render self
-    var vnode;
-    try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm;
-      vnode = render.call(vm._renderProxy, vm.$createElement);
-    } catch (e) {
-      handleError(e, vm, "render");
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-        } catch (e) {
-          handleError(e, vm, "renderError");
-          vnode = vm._vnode;
-        }
-      } else {
-        vnode = vm._vnode;
-      }
-    } finally {
-      currentRenderingInstance = null;
-    }
-    // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0];
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-          'should return a single root node.',
-          vm
-        );
-      }
-      vnode = createEmptyVNode();
+    else {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
     }
-    // set parent
-    vnode.parent = _parentVnode;
-    return vnode
-  };
 }
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
-}
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
-}
-
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
+var currentRenderingInstance = null;
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        var vm = this;
+        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        var vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
         }
-      }
-    };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+        catch (e) {
+            handleError(e, vm, "render");
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e$1) {
+                    handleError(e$1, vm, "renderError");
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        finally {
+            currentRenderingInstance = null;
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                process.env.NODE_ENV !== 'production'
-                  ? ("timeout (" + (res.timeout) + "ms)")
-                  : null
-              );
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
             }
-          }, res.timeout);
+            vnode = createEmptyVNode();
         }
-      }
-    }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-/*  */
-
-function getFirstComponentChild (children) {
-  if (Array.isArray(children)) {
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-        return c
-      }
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
     }
-  }
+    return isObject(comp) ? base.extend(comp) : comp;
 }
-
-/*  */
-
-/*  */
-
-function initEvents (vm) {
-  vm._events = Object.create(null);
-  vm._hasHookEvent = false;
-  // init parent attached events
-  var listeners = vm.$options._parentListeners;
-  if (listeners) {
-    updateComponentListeners(vm, listeners);
-  }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    return node;
 }
-
-var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    var owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        var owners_1 = (factory.owners = [owner]);
+        var sync_1 = true;
+        var timerLoading_1 = null;
+        var timerTimeout_1 = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
+        var forceRender_1 = function (renderCompleted) {
+            for (var i = 0, l = owners_1.length; i < l; i++) {
+                owners_1[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners_1.length = 0;
+                if (timerLoading_1 !== null) {
+                    clearTimeout(timerLoading_1);
+                    timerLoading_1 = null;
+                }
+                if (timerTimeout_1 !== null) {
+                    clearTimeout(timerTimeout_1);
+                    timerTimeout_1 = null;
+                }
+            }
+        };
+        var resolve = once(function (res) {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync_1) {
+                forceRender_1(true);
+            }
+            else {
+                owners_1.length = 0;
+            }
+        });
+        var reject_1 = once(function (reason) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("Failed to resolve async component: " + String(factory) +
+                    (reason ? "\nReason: " + reason : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender_1(true);
+            }
+        });
+        var res_1 = factory(resolve, reject_1);
+        if (isObject(res_1)) {
+            if (isPromise(res_1)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res_1.then(resolve, reject_1);
+                }
+            }
+            else if (isPromise(res_1.component)) {
+                res_1.component.then(resolve, reject_1);
+                if (isDef(res_1.error)) {
+                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
+                }
+                if (isDef(res_1.loading)) {
+                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
+                    if (res_1.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading_1 = setTimeout(function () {
+                            timerLoading_1 = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender_1(false);
+                            }
+                        }, res_1.delay || 200);
+                    }
+                }
+                if (isDef(res_1.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout_1 = setTimeout(function () {
+                        timerTimeout_1 = null;
+                        if (isUndef(factory.resolved)) {
+                            reject_1(process.env.NODE_ENV !== 'production'
+                                ? "timeout (" + res_1.timeout + "ms)"
+                                : null);
+                        }
+                    }, res_1.timeout);
+                }
+            }
+        }
+        sync_1 = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function remove$1 (event, fn) {
-  target.$off(event, fn);
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (var i = 0; i < children.length; i++) {
+            var c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
     }
-  }
 }
 
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
-}
-
-function eventsMixin (Vue) {
-  var hookRE = /^hook:/;
-  Vue.prototype.$on = function (event, fn) {
-    var vm = this;
-    if (Array.isArray(event)) {
-      for (var i = 0, l = event.length; i < l; i++) {
-        vm.$on(event[i], fn);
-      }
-    } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn);
-      // optimize hook:event cost by using a boolean flag marked at registration
-      // instead of a hash lookup
-      if (hookRE.test(event)) {
-        vm._hasHookEvent = true;
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$once = function (event, fn) {
-    var vm = this;
-    function on () {
-      vm.$off(event, on);
-      fn.apply(vm, arguments);
-    }
-    on.fn = fn;
-    vm.$on(event, on);
-    return vm
-  };
-
-  Vue.prototype.$off = function (event, fn) {
-    var vm = this;
-    // all
-    if (!arguments.length) {
-      vm._events = Object.create(null);
-      return vm
-    }
-    // array of events
-    if (Array.isArray(event)) {
-      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-        vm.$off(event[i$1], fn);
-      }
-      return vm
-    }
-    // specific event
-    var cbs = vm._events[event];
-    if (!cbs) {
-      return vm
-    }
-    if (!fn) {
-      vm._events[event] = null;
-      return vm
-    }
-    // specific handler
-    var cb;
-    var i = cbs.length;
-    while (i--) {
-      cb = cbs[i];
-      if (cb === fn || cb.fn === fn) {
-        cbs.splice(i, 1);
-        break
-      }
-    }
-    return vm
-  };
-
-  Vue.prototype.$emit = function (event) {
-    var vm = this;
-    if (process.env.NODE_ENV !== 'production') {
-      var lowerCaseEvent = event.toLowerCase();
-      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-        tip(
-          "Event \"" + lowerCaseEvent + "\" is emitted in component " +
-          (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-          "Note that HTML attributes are case-insensitive and you cannot use " +
-          "v-on to listen to camelCase events when using in-DOM templates. " +
-          "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
-        );
-      }
-    }
-    var cbs = vm._events[event];
-    if (cbs) {
-      cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-      var args = toArray(arguments, 1);
-      var info = "event handler for \"" + event + "\"";
-      for (var i = 0, l = cbs.length; i < l; i++) {
-        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-      }
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    var listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
     }
-    return vm
-  };
 }
-
-/*  */
+var target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target$1.$off(event, fn);
+}
+function createOnceHandler$1(event, fn) {
+    var _target = target$1;
+    return function onceHandler() {
+        var res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
+}
+function eventsMixin(Vue) {
+    var hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        var vm = this;
+        if (Array.isArray(event)) {
+            for (var i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        var vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        var vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
+                vm.$off(event[i_1], fn);
+            }
+            return vm;
+        }
+        // specific event
+        var cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        var cb;
+        var i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        var vm = this;
+        if (process.env.NODE_ENV !== 'production') {
+            var lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                    "Note that HTML attributes are case-insensitive and you cannot use " +
+                    "v-on to listen to camelCase events when using in-DOM templates. " +
+                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+            }
+        }
+        var cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            var args = toArray(arguments, 1);
+            var info = "event handler for \"" + event + "\"";
+            for (var i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
+}
 
 var activeInstance = null;
 var isUpdatingChildComponent = false;
-
 function setActiveInstance(vm) {
-  var prevActiveInstance = activeInstance;
-  activeInstance = vm;
-  return function () {
-    activeInstance = prevActiveInstance;
-  }
+    var prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return function () {
+        activeInstance = prevActiveInstance;
+    };
 }
-
-function initLifecycle (vm) {
-  var options = vm.$options;
-
-  // locate first non-abstract parent
-  var parent = options.parent;
-  if (parent && !options.abstract) {
-    while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
-    }
-    parent.$children.push(vm);
-  }
-
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
-
-  vm.$children = [];
-  vm.$refs = {};
-
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
+function initLifecycle(vm) {
+    var options = vm.$options;
+    // locate first non-abstract parent
+    var parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        var vm = this;
+        var prevEl = vm.$el;
+        var prevVnode = vm._vnode;
+        var restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        var vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        var vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook$1(vm, 'beforeDestroy');
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        var parent = vm.$parent;
+        // @ts-ignore
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove$2(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        var i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook$1(vm, 'destroyed');
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            // @ts-expect-error null is not undefined
+            vm.$vnode.parent = null;
+        }
+    };
 }
-
-function lifecycleMixin (Vue) {
-  Vue.prototype._update = function (vnode, hydrating) {
-    var vm = this;
-    var prevEl = vm.$el;
-    var prevVnode = vm._vnode;
-    var restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
-    // Vue.prototype.__patch__ is injected in entry points
-    // based on the rendering backend used.
-    if (!prevVnode) {
-      // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-    } else {
-      // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
-    }
-    restoreActiveInstance();
-    // update __vue__ reference
-    if (prevEl) {
-      prevEl.__vue__ = null;
-    }
-    if (vm.$el) {
-      vm.$el.__vue__ = vm;
-    }
-    // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
-    }
-    // updated hook is called by the scheduler to ensure that children are
-    // updated in a parent's updated hook.
-  };
-
-  Vue.prototype.$forceUpdate = function () {
-    var vm = this;
-    if (vm._watcher) {
-      vm._watcher.update();
-    }
-  };
-
-  Vue.prototype.$destroy = function () {
-    var vm = this;
-    if (vm._isBeingDestroyed) {
-      return
-    }
-    callHook(vm, 'beforeDestroy');
-    vm._isBeingDestroyed = true;
-    // remove self from parent
-    var parent = vm.$parent;
-    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        if (process.env.NODE_ENV !== 'production') {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                vm.$options.el ||
+                el) {
+                warn('You are using the runtime-only build of Vue where the template ' +
+                    'compiler is not available. Either pre-compile the templates into ' +
+                    'render functions, or use the compiler-included build.', vm);
+            }
+            else {
+                warn('Failed to mount component: template or render function not defined.', vm);
+            }
+        }
     }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown();
+    callHook$1(vm, 'beforeMount');
+    var updateComponent;
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+        updateComponent = function () {
+            var name = vm._name;
+            var id = vm._uid;
+            var startTag = "vue-perf-start:" + id;
+            var endTag = "vue-perf-end:" + id;
+            mark(startTag);
+            var vnode = vm._render();
+            mark(endTag);
+            measure("vue " + name + " render", startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure("vue " + name + " patch", startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = function () {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before: function () {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook$1(vm, 'beforeUpdate');
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook$1(vm, 'mounted');
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    if (process.env.NODE_ENV !== 'production') {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        // @ts-ignore
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        var props = vm._props;
+        var propKeys = vm.$options._propKeys || [];
+        for (var i = 0; i < propKeys.length; i++) {
+            var key = propKeys[i];
+            var propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
     }
-    var i = vm._watchers.length;
-    while (i--) {
-      vm._watchers[i].teardown();
-    }
-    // remove reference from data ob
-    // frozen object may not have observer.
-    if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
-    }
-    // call the last hook...
-    vm._isDestroyed = true;
-    // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
-    // fire destroyed hook
-    callHook(vm, 'destroyed');
-    // turn off all instance listeners.
-    vm.$off();
-    // remove __vue__ reference
-    if (vm.$el) {
-      vm.$el.__vue__ = null;
-    }
-    // release circular reference (#6759)
-    if (vm.$vnode) {
-      vm.$vnode.parent = null;
-    }
-  };
-}
-
-function mountComponent (
-  vm,
-  el,
-  hydrating
-) {
-  vm.$el = el;
-  if (!vm.$options.render) {
-    vm.$options.render = createEmptyVNode;
     if (process.env.NODE_ENV !== 'production') {
-      /* istanbul ignore if */
-      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-        vm.$options.el || el) {
-        warn(
-          'You are using the runtime-only build of Vue where the template ' +
-          'compiler is not available. Either pre-compile the templates into ' +
-          'render functions, or use the compiler-included build.',
-          vm
-        );
-      } else {
-        warn(
-          'Failed to mount component: template or render function not defined.',
-          vm
-        );
-      }
+        isUpdatingChildComponent = false;
     }
-  }
-  callHook(vm, 'beforeMount');
-
-  var updateComponent;
-  /* istanbul ignore if */
-  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-    updateComponent = function () {
-      var name = vm._name;
-      var id = vm._uid;
-      var startTag = "vue-perf-start:" + id;
-      var endTag = "vue-perf-end:" + id;
-
-      mark(startTag);
-      var vnode = vm._render();
-      mark(endTag);
-      measure(("vue " + name + " render"), startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(("vue " + name + " patch"), startTag, endTag);
-    };
-  } else {
-    updateComponent = function () {
-      vm._update(vm._render(), hydrating);
-    };
-  }
-
-  // we set this to vm._watcher inside the watcher's constructor
-  // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-  // component's mounted hook), which relies on vm._watcher being already defined
-  new Watcher(vm, updateComponent, noop, {
-    before: function before () {
-      if (vm._isMounted && !vm._isDestroyed) {
-        callHook(vm, 'beforeUpdate');
-      }
-    }
-  }, true /* isRenderWatcher */);
-  hydrating = false;
-
-  // manually mounted instance, call mounted on self
-  // mounted is called for render-created child components in its inserted hook
-  if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, 'mounted');
-  }
-  return vm
 }
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = true;
-  }
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            { return true; }
     }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = false;
-  }
+    return false;
 }
-
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
-}
-
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (var i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, 'activated');
     }
-    callHook(vm, 'activated');
-  }
 }
-
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (var i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, 'deactivated');
     }
-    callHook(vm, 'deactivated');
-  }
 }
-
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-    }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
+function callHook$1(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+        for (var i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit('hook:' + hook);
+    }
+    popTarget();
 }
 
-/*  */
-
 var MAX_UPDATE_COUNT = 100;
-
 var queue = [];
 var activatedChildren = [];
 var has = {};
@@ -4428,29 +3872,19 @@ var circular = {};
 var waiting = false;
 var flushing = false;
 var index = 0;
-
 /**
  * Reset the scheduler's state.
  */
-function resetSchedulerState () {
-  index = queue.length = activatedChildren.length = 0;
-  has = {};
-  if (process.env.NODE_ENV !== 'production') {
-    circular = {};
-  }
-  waiting = flushing = false;
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    if (process.env.NODE_ENV !== 'production') {
+        circular = {};
+    }
+    waiting = flushing = false;
 }
-
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-var currentFlushTimestamp = 0;
-
 // Async edge case fix requires storing an event listener's attach timestamp.
 var getNow = Date.now;
-
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -4458,1294 +3892,1125 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+    var performance_1 = window.performance;
+    if (performance_1 &&
+        typeof performance_1.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = function () { return performance_1.now(); };
+    }
 }
-
 /**
  * Flush both queues and run the watchers.
  */
-function flushSchedulerQueue () {
-  currentFlushTimestamp = getNow();
-  flushing = true;
-  var watcher, id;
-
-  // Sort queue before flush.
-  // This ensures that:
-  // 1. Components are updated from parent to child. (because parent is always
-  //    created before the child)
-  // 2. A component's user watchers are run before its render watcher (because
-  //    user watchers are created before the render watcher)
-  // 3. If a component is destroyed during a parent component's watcher run,
-  //    its watchers can be skipped.
-  queue.sort(function (a, b) { return a.id - b.id; });
-
-  // do not cache length because more watchers might be pushed
-  // as we run existing watchers
-  for (index = 0; index < queue.length; index++) {
-    watcher = queue[index];
-    if (watcher.before) {
-      watcher.before();
-    }
-    id = watcher.id;
-    has[id] = null;
-    watcher.run();
-    // in dev build, check and stop circular updates.
-    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-      circular[id] = (circular[id] || 0) + 1;
-      if (circular[id] > MAX_UPDATE_COUNT) {
-        warn(
-          'You may have an infinite update loop ' + (
-            watcher.user
-              ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-              : "in a component render function."
-          ),
-          watcher.vm
-        );
-        break
-      }
+function flushSchedulerQueue() {
+    getNow();
+    flushing = true;
+    var watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort(function (a, b) { return a.id - b.id; });
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? "in watcher with expression \"" + watcher.expression + "\""
+                        : "in a component render function."), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
     }
-  }
-
-  // keep copies of post queues before resetting state
-  var activatedQueue = activatedChildren.slice();
-  var updatedQueue = queue.slice();
-
-  resetSchedulerState();
-
-  // call component updated and activated hooks
-  callActivatedHooks(activatedQueue);
-  callUpdatedHooks(updatedQueue);
-
-  // devtool hook
-  /* istanbul ignore if */
-  if (devtools && config.devtools) {
-    devtools.emit('flush');
-  }
 }
-
-function callUpdatedHooks (queue) {
-  var i = queue.length;
-  while (i--) {
-    var watcher = queue[i];
-    var vm = watcher.vm;
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-      callHook(vm, 'updated');
+function callUpdatedHooks(queue) {
+    var i = queue.length;
+    while (i--) {
+        var watcher = queue[i];
+        var vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, 'updated');
+        }
     }
-  }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-  activatedChildren.push(vm);
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
 }
-
-function callActivatedHooks (queue) {
-  for (var i = 0; i < queue.length; i++) {
-    queue[i]._inactive = true;
-    activateChildComponent(queue[i], true /* true */);
-  }
+function callActivatedHooks(queue) {
+    for (var i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
 }
-
 /**
  * Push a watcher into the watcher queue.
  * Jobs with duplicate IDs will be skipped unless it's
  * pushed when the queue is being flushed.
  */
-function queueWatcher (watcher) {
-  var id = watcher.id;
-  if (has[id] == null) {
-    has[id] = true;
-    if (!flushing) {
-      queue.push(watcher);
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      var i = queue.length - 1;
-      while (i > index && queue[i].id > watcher.id) {
-        i--;
-      }
-      queue.splice(i + 1, 0, watcher);
-    }
-    // queue the flush
-    if (!waiting) {
-      waiting = true;
-
-      if (process.env.NODE_ENV !== 'production' && !config.async) {
-        flushSchedulerQueue();
-        return
-      }
-      nextTick(flushSchedulerQueue);
+function queueWatcher(watcher) {
+    var id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            var i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (process.env.NODE_ENV !== 'production' && !config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
     }
-  }
 }
 
-/*  */
-
-
-
-var uid$2 = 0;
-
+var uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher (
-  vm,
-  expOrFn,
-  cb,
-  options,
-  isRenderWatcher
-) {
-  this.vm = vm;
-  if (isRenderWatcher) {
-    vm._watcher = this;
-  }
-  vm._watchers.push(this);
-  // options
-  if (options) {
-    this.deep = !!options.deep;
-    this.user = !!options.user;
-    this.lazy = !!options.lazy;
-    this.sync = !!options.sync;
-    this.before = options.before;
-  } else {
-    this.deep = this.user = this.lazy = this.sync = false;
-  }
-  this.cb = cb;
-  this.id = ++uid$2; // uid for batching
-  this.active = true;
-  this.dirty = this.lazy; // for lazy watchers
-  this.deps = [];
-  this.newDeps = [];
-  this.depIds = new _Set();
-  this.newDepIds = new _Set();
-  this.expression = process.env.NODE_ENV !== 'production'
-    ? expOrFn.toString()
-    : '';
-  // parse expression for getter
-  if (typeof expOrFn === 'function') {
-    this.getter = expOrFn;
-  } else {
-    this.getter = parsePath(expOrFn);
-    if (!this.getter) {
-      this.getter = noop;
-      process.env.NODE_ENV !== 'production' && warn(
-        "Failed watching path: \"" + expOrFn + "\" " +
-        'Watcher only accepts simple dot-delimited paths. ' +
-        'For full control, use a function instead.',
-        vm
-      );
-    }
-  }
-  this.value = this.lazy
-    ? undefined
-    : this.get();
-};
-
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-  pushTarget(this);
-  var value;
-  var vm = this.vm;
-  try {
-    value = this.getter.call(vm, vm);
-  } catch (e) {
-    if (this.user) {
-      handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-    } else {
-      throw e
-    }
-  } finally {
-    // "touch" every property so they are all tracked as
-    // dependencies for deep watching
-    if (this.deep) {
-      traverse(value);
-    }
-    popTarget();
-    this.cleanupDeps();
-  }
-  return value
-};
-
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-  var id = dep.id;
-  if (!this.newDepIds.has(id)) {
-    this.newDepIds.add(id);
-    this.newDeps.push(dep);
-    if (!this.depIds.has(id)) {
-      dep.addSub(this);
-    }
-  }
-};
-
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-  var i = this.deps.length;
-  while (i--) {
-    var dep = this.deps[i];
-    if (!this.newDepIds.has(dep.id)) {
-      dep.removeSub(this);
-    }
-  }
-  var tmp = this.depIds;
-  this.depIds = this.newDepIds;
-  this.newDepIds = tmp;
-  this.newDepIds.clear();
-  tmp = this.deps;
-  this.deps = this.newDeps;
-  this.newDeps = tmp;
-  this.newDeps.length = 0;
-};
-
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-  /* istanbul ignore else */
-  if (this.lazy) {
-    this.dirty = true;
-  } else if (this.sync) {
-    this.run();
-  } else {
-    queueWatcher(this);
-  }
-};
-
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-  if (this.active) {
-    var value = this.get();
-    if (
-      value !== this.value ||
-      // Deep watchers and watchers on Object/Arrays should fire even
-      // when the value is the same, because the value may
-      // have mutated.
-      isObject(value) ||
-      this.deep
-    ) {
-      // set new value
-      var oldValue = this.value;
-      this.value = value;
-      if (this.user) {
+var Watcher = /** @class */ (function () {
+    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression =
+            process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' &&
+                    warn("Failed watching path: \"" + expOrFn + "\" " +
+                        'Watcher only accepts simple dot-delimited paths. ' +
+                        'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy ? undefined : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    Watcher.prototype.get = function () {
+        pushTarget(this);
+        var value;
+        var vm = this.vm;
         try {
-          this.cb.call(this.vm, value, oldValue);
-        } catch (e) {
-          handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+            value = this.getter.call(vm, vm);
         }
-      } else {
-        this.cb.call(this.vm, value, oldValue);
-      }
-    }
-  }
-};
-
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-  this.value = this.get();
-  this.dirty = false;
-};
-
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-  var i = this.deps.length;
-  while (i--) {
-    this.deps[i].depend();
-  }
-};
-
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-  if (this.active) {
-    // remove self from vm's watcher list
-    // this is a somewhat expensive operation so we skip it
-    // if the vm is being destroyed.
-    if (!this.vm._isBeingDestroyed) {
-      remove(this.vm._watchers, this);
-    }
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].removeSub(this);
-    }
-    this.active = false;
-  }
-};
-
-/*  */
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    };
+    /**
+     * Add a dependency to this directive.
+     */
+    Watcher.prototype.addDep = function (dep) {
+        var id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    };
+    /**
+     * Clean up for dependency collection.
+     */
+    Watcher.prototype.cleanupDeps = function () {
+        var i = this.deps.length;
+        while (i--) {
+            var dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        var tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    };
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    Watcher.prototype.update = function () {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    };
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    Watcher.prototype.run = function () {
+        if (this.active) {
+            var value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                var oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    try {
+                        this.cb.call(this.vm, value, oldValue);
+                    }
+                    catch (e) {
+                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                    }
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    };
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    Watcher.prototype.evaluate = function () {
+        this.value = this.get();
+        this.dirty = false;
+    };
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    Watcher.prototype.depend = function () {
+        var i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    };
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    Watcher.prototype.teardown = function () {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            var i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    };
+    return Watcher;
+}());
 
 var sharedPropertyDefinition = {
-  enumerable: true,
-  configurable: true,
-  get: noop,
-  set: noop
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
 };
-
-function proxy (target, sourceKey, key) {
-  sharedPropertyDefinition.get = function proxyGetter () {
-    return this[sourceKey][key]
-  };
-  sharedPropertyDefinition.set = function proxySetter (val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function initState (vm) {
-  vm._watchers = [];
-  var opts = vm.$options;
-  if (opts.props) { initProps(vm, opts.props); }
-  if (opts.methods) { initMethods(vm, opts.methods); }
-  if (opts.data) {
-    initData(vm);
-  } else {
-    observe(vm._data = {}, true /* asRootData */);
-  }
-  if (opts.computed) { initComputed(vm, opts.computed); }
-  if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
-  }
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    var opts = vm.$options;
+    if (opts.props)
+        { initProps$1(vm, opts.props); }
+    if (opts.methods)
+        { initMethods(vm, opts.methods); }
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        { initComputed$1(vm, opts.computed); }
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps$1(vm, propsOptions) {
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    var _loop_1 = function (key) {
+        keys.push(key);
+        var value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            var hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+            }
+            defineReactive(props, key, value, function () {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn("Avoid mutating a prop directly since the value will be " +
+                        "overwritten whenever the parent component re-renders. " +
+                        "Instead, use a data or computed property based on the prop's " +
+                        ("value. Prop being mutated: \"" + key + "\""), vm);
+                }
+            });
+        }
+        else {
+            defineReactive(props, key, value);
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, "_props", key);
+        }
+    };
+    for (var key in propsOptions) {
+        _loop_1(key);
+    }
+    toggleObserving(true);
 }
-
-function initProps (vm, propsOptions) {
-  var propsData = vm.$options.propsData || {};
-  var props = vm._props = {};
-  // cache prop keys so that future props updates can iterate using Array
-  // instead of dynamic object key enumeration.
-  var keys = vm.$options._propKeys = [];
-  var isRoot = !vm.$parent;
-  // root instance props should be converted
-  if (!isRoot) {
-    toggleObserving(false);
-  }
-  var loop = function ( key ) {
-    keys.push(key);
-    var value = validateProp(key, propsOptions, propsData, vm);
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      var hyphenatedKey = hyphenate(key);
-      if (isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)) {
-        warn(
-          ("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."),
-          vm
-        );
-      }
-      defineReactive$$1(props, key, value, function () {
-        if (!isRoot && !isUpdatingChildComponent) {
-          warn(
-            "Avoid mutating a prop directly since the value will be " +
-            "overwritten whenever the parent component re-renders. " +
-            "Instead, use a data or computed property based on the prop's " +
-            "value. Prop being mutated: \"" + key + "\"",
-            vm
-          );
-        }
-      });
-    } else {
-      defineReactive$$1(props, key, value);
-    }
-    // static props are already proxied on the component's prototype
-    // during Vue.extend(). We only need to proxy props defined at
-    // instantiation here.
-    if (!(key in vm)) {
-      proxy(vm, "_props", key);
-    }
-  };
-
-  for (var key in propsOptions) loop( key );
-  toggleObserving(true);
+function initData(vm) {
+    var data = vm.$options.data;
+    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        process.env.NODE_ENV !== 'production' &&
+            warn('data functions should return an object:\n' +
+                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+    }
+    // proxy data on instance
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
+    while (i--) {
+        var key = keys[i];
+        if (process.env.NODE_ENV !== 'production') {
+            if (methods && hasOwn(methods, key)) {
+                warn("Method \"" + key + "\" has already been defined as a data property.", vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn("The data property \"" + key + "\" is already declared as a prop. " +
+                    "Use prop default value instead.", vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, "_data", key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
 }
-
-function initData (vm) {
-  var data = vm.$options.data;
-  data = vm._data = typeof data === 'function'
-    ? getData(data, vm)
-    : data || {};
-  if (!isPlainObject(data)) {
-    data = {};
-    process.env.NODE_ENV !== 'production' && warn(
-      'data functions should return an object:\n' +
-      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
-      vm
-    );
-  }
-  // proxy data on instance
-  var keys = Object.keys(data);
-  var props = vm.$options.props;
-  var methods = vm.$options.methods;
-  var i = keys.length;
-  while (i--) {
-    var key = keys[i];
-    if (process.env.NODE_ENV !== 'production') {
-      if (methods && hasOwn(methods, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a data property."),
-          vm
-        );
-      }
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
     }
-    if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== 'production' && warn(
-        "The data property \"" + key + "\" is already declared as a prop. " +
-        "Use prop default value instead.",
-        vm
-      );
-    } else if (!isReserved(key)) {
-      proxy(vm, "_data", key);
+    catch (e) {
+        handleError(e, vm, "data()");
+        return {};
+    }
+    finally {
+        popTarget();
     }
-  }
-  // observe data
-  observe(data, true /* asRootData */);
-}
-
-function getData (data, vm) {
-  // #7573 disable dep collection when invoking data getters
-  pushTarget();
-  try {
-    return data.call(vm, vm)
-  } catch (e) {
-    handleError(e, vm, "data()");
-    return {}
-  } finally {
-    popTarget();
-  }
 }
-
 var computedWatcherOptions = { lazy: true };
-
-function initComputed (vm, computed) {
-  // $flow-disable-line
-  var watchers = vm._computedWatchers = Object.create(null);
-  // computed properties are just getters during SSR
-  var isSSR = isServerRendering();
-
-  for (var key in computed) {
-    var userDef = computed[key];
-    var getter = typeof userDef === 'function' ? userDef : userDef.get;
-    if (process.env.NODE_ENV !== 'production' && getter == null) {
-      warn(
-        ("Getter is missing for computed property \"" + key + "\"."),
-        vm
-      );
-    }
-
-    if (!isSSR) {
-      // create internal watcher for the computed property.
-      watchers[key] = new Watcher(
-        vm,
-        getter || noop,
-        noop,
-        computedWatcherOptions
-      );
+function initComputed$1(vm, computed) {
+    // $flow-disable-line
+    var watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+        var userDef = computed[key];
+        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== 'production' && getter == null) {
+            warn("Getter is missing for computed property \"" + key + "\".", vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            if (key in vm.$data) {
+                warn("The computed property \"" + key + "\" is already defined in data.", vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
+            }
+        }
     }
-
-    // component-defined computed properties are already defined on the
-    // component prototype. We only need to define computed properties defined
-    // at instantiation here.
-    if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else if (process.env.NODE_ENV !== 'production') {
-      if (key in vm.$data) {
-        warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-      } else if (vm.$options.props && key in vm.$options.props) {
-        warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-      }
-    }
-  }
 }
-
-function defineComputed (
-  target,
-  key,
-  userDef
-) {
-  var shouldCache = !isServerRendering();
-  if (typeof userDef === 'function') {
-    sharedPropertyDefinition.get = shouldCache
-      ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
-  } else {
-    sharedPropertyDefinition.get = userDef.get
-      ? shouldCache && userDef.cache !== false
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
-  }
-  if (process.env.NODE_ENV !== 'production' &&
-      sharedPropertyDefinition.set === noop) {
-    sharedPropertyDefinition.set = function () {
-      warn(
-        ("Computed property \"" + key + "\" was assigned to but it has no setter."),
-        this
-      );
+function defineComputed(target, key, userDef) {
+    var shouldCache = !isServerRendering();
+    if (typeof userDef === 'function') {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        var watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
     };
-  }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-
-function createComputedGetter (key) {
-  return function computedGetter () {
-    var watcher = this._computedWatchers && this._computedWatchers[key];
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate();
-      }
-      if (Dep.target) {
-        watcher.depend();
-      }
-      return watcher.value
-    }
-  }
 }
-
 function createGetterInvoker(fn) {
-  return function computedGetter () {
-    return fn.call(this, this)
-  }
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
 }
-
-function initMethods (vm, methods) {
-  var props = vm.$options.props;
-  for (var key in methods) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (typeof methods[key] !== 'function') {
-        warn(
-          "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-          "Did you reference the function correctly?",
-          vm
-        );
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          ("Method \"" + key + "\" has already been defined as a prop."),
-          vm
-        );
-      }
-      if ((key in vm) && isReserved(key)) {
-        warn(
-          "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-          "Avoid defining component methods that start with _ or $."
-        );
-      }
+function initMethods(vm, methods) {
+    var props = vm.$options.props;
+    for (var key in methods) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (typeof methods[key] !== 'function') {
+                warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                    "Did you reference the function correctly?", vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn("Method \"" + key + "\" has already been defined as a prop.", vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                    "Avoid defining component methods that start with _ or $.");
+            }
+        }
+        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
     }
-    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-  }
-}
-
-function initWatch (vm, watch) {
-  for (var key in watch) {
-    var handler = watch[key];
-    if (Array.isArray(handler)) {
-      for (var i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
-      }
-    } else {
-      createWatcher(vm, key, handler);
-    }
-  }
-}
-
-function createWatcher (
-  vm,
-  expOrFn,
-  handler,
-  options
-) {
-  if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
-  }
-  if (typeof handler === 'string') {
-    handler = vm[handler];
-  }
-  return vm.$watch(expOrFn, handler, options)
 }
-
-function stateMixin (Vue) {
-  // flow somehow has problems with directly declared definition object
-  // when using Object.defineProperty, so we have to procedurally build up
-  // the object here.
-  var dataDef = {};
-  dataDef.get = function () { return this._data };
-  var propsDef = {};
-  propsDef.get = function () { return this._props };
-  if (process.env.NODE_ENV !== 'production') {
-    dataDef.set = function () {
-      warn(
-        'Avoid replacing instance root $data. ' +
-        'Use nested data properties instead.',
-        this
-      );
-    };
-    propsDef.set = function () {
-      warn("$props is readonly.", this);
-    };
-  }
-  Object.defineProperty(Vue.prototype, '$data', dataDef);
-  Object.defineProperty(Vue.prototype, '$props', propsDef);
-
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
-
-  Vue.prototype.$watch = function (
-    expOrFn,
-    cb,
-    options
-  ) {
-    var vm = this;
-    if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options)
-    }
-    options = options || {};
-    options.user = true;
-    var watcher = new Watcher(vm, expOrFn, cb, options);
-    if (options.immediate) {
-      try {
-        cb.call(vm, watcher.value);
-      } catch (error) {
-        handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-      }
-    }
-    return function unwatchFn () {
-      watcher.teardown();
+function initWatch(vm, watch) {
+    for (var key in watch) {
+        var handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (var i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
     }
-  };
 }
-
-/*  */
-
-var uid$3 = 0;
-
-function initMixin (Vue) {
-  Vue.prototype._init = function (options) {
-    var vm = this;
-    // a uid
-    vm._uid = uid$3++;
-
-    var startTag, endTag;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      startTag = "vue-perf-start:" + (vm._uid);
-      endTag = "vue-perf-end:" + (vm._uid);
-      mark(startTag);
-    }
-
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-      // optimize internal component instantiation
-      // since dynamic options merging is pretty slow, and none of the
-      // internal component options needs special treatment.
-      initInternalComponent(vm, options);
-    } else {
-      vm.$options = mergeOptions(
-        resolveConstructorOptions(vm.constructor),
-        options || {},
-        vm
-      );
-    }
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-      initProxy(vm);
-    } else {
-      vm._renderProxy = vm;
-    }
-    // expose real self
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook(vm, 'created');
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-      vm._name = formatComponentName(vm, false);
-      mark(endTag);
-      measure(("vue " + (vm._name) + " init"), startTag, endTag);
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
     }
-
-    if (vm.$options.el) {
-      vm.$mount(vm.$options.el);
+    if (typeof handler === 'string') {
+        handler = vm[handler];
     }
-  };
+    return vm.$watch(expOrFn, handler, options);
 }
-
-function initInternalComponent (vm, options) {
-  var opts = vm.$options = Object.create(vm.constructor.options);
-  // doing this because it's faster than dynamic enumeration.
-  var parentVnode = options._parentVnode;
-  opts.parent = options.parent;
-  opts._parentVnode = parentVnode;
-
-  var vnodeComponentOptions = parentVnode.componentOptions;
-  opts.propsData = vnodeComponentOptions.propsData;
-  opts._parentListeners = vnodeComponentOptions.listeners;
-  opts._renderChildren = vnodeComponentOptions.children;
-  opts._componentTag = vnodeComponentOptions.tag;
-
-  if (options.render) {
-    opts.render = options.render;
-    opts.staticRenderFns = options.staticRenderFns;
-  }
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    var dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    var propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    if (process.env.NODE_ENV !== 'production') {
+        dataDef.set = function () {
+            warn('Avoid replacing instance root $data. ' +
+                'Use nested data properties instead.', this);
+        };
+        propsDef.set = function () {
+            warn("$props is readonly.", this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, '$data', dataDef);
+    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        var vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        var watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            pushTarget();
+            try {
+                cb.call(vm, watcher.value);
+            }
+            catch (error) {
+                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+            }
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
+var uid = 0;
+function initMixin$1(Vue) {
+    Vue.prototype._init = function (options) {
+        var vm = this;
+        // a uid
+        vm._uid = uid++;
+        var startTag, endTag;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            startTag = "vue-perf-start:" + vm._uid;
+            endTag = "vue-perf-end:" + vm._uid;
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            initProxy(vm);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook$1(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook$1(vm, 'created');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure("vue " + vm._name + " init", startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
 }
-
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
+function initInternalComponent(vm, options) {
+    // @ts-ignore
+    var opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    var parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    var vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    var options = Ctor.options;
+    if (Ctor.super) {
+        var superOptions = resolveConstructorOptions(Ctor.super);
+        var cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            var modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                { modified = {}; }
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function Vue (options) {
-  if (process.env.NODE_ENV !== 'production' &&
-    !(this instanceof Vue)
-  ) {
-    warn('Vue is a constructor and should be called with the `new` keyword');
-  }
-  this._init(options);
+function Vue(options) {
+    if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
+        warn('Vue is a constructor and should be called with the `new` keyword');
+    }
+    this._init(options);
 }
-
-initMixin(Vue);
+//@ts-ignore
+initMixin$1(Vue);
+//@ts-ignore
 stateMixin(Vue);
+//@ts-ignore
 eventsMixin(Vue);
+//@ts-ignore
 lifecycleMixin(Vue);
+//@ts-ignore
 renderMixin(Vue);
 
-/*  */
-
-function initUse (Vue) {
-  Vue.use = function (plugin) {
-    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
-    if (installedPlugins.indexOf(plugin) > -1) {
-      return this
-    }
-
-    // additional parameters
-    var args = toArray(arguments, 1);
-    args.unshift(this);
-    if (typeof plugin.install === 'function') {
-      plugin.install.apply(plugin, args);
-    } else if (typeof plugin === 'function') {
-      plugin.apply(null, args);
-    }
-    installedPlugins.push(plugin);
-    return this
-  };
-}
-
-/*  */
-
-function initMixin$1 (Vue) {
-  Vue.mixin = function (mixin) {
-    this.options = mergeOptions(this.options, mixin);
-    return this
-  };
-}
-
-/*  */
-
-function initExtend (Vue) {
-  /**
-   * Each instance constructor, including Vue, has a unique
-   * cid. This enables us to create wrapped "child
-   * constructors" for prototypal inheritance and cache them.
-   */
-  Vue.cid = 0;
-  var cid = 1;
-
-  /**
-   * Class inheritance
-   */
-  Vue.extend = function (extendOptions) {
-    extendOptions = extendOptions || {};
-    var Super = this;
-    var SuperId = Super.cid;
-    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-    if (cachedCtors[SuperId]) {
-      return cachedCtors[SuperId]
-    }
-
-    var name = extendOptions.name || Super.options.name;
-    if (process.env.NODE_ENV !== 'production' && name) {
-      validateComponentName(name);
-    }
-
-    var Sub = function VueComponent (options) {
-      this._init(options);
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        var args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
     };
-    Sub.prototype = Object.create(Super.prototype);
-    Sub.prototype.constructor = Sub;
-    Sub.cid = cid++;
-    Sub.options = mergeOptions(
-      Super.options,
-      extendOptions
-    );
-    Sub['super'] = Super;
-
-    // For props and computed properties, we define the proxy getters on
-    // the Vue instances at extension time, on the extended prototype. This
-    // avoids Object.defineProperty calls for each instance created.
-    if (Sub.options.props) {
-      initProps$1(Sub);
-    }
-    if (Sub.options.computed) {
-      initComputed$1(Sub);
-    }
-
-    // allow further extension/mixin/plugin usage
-    Sub.extend = Super.extend;
-    Sub.mixin = Super.mixin;
-    Sub.use = Super.use;
-
-    // create asset registers, so extended classes
-    // can have their private assets too.
-    ASSET_TYPES.forEach(function (type) {
-      Sub[type] = Super[type];
-    });
-    // enable recursive self-lookup
-    if (name) {
-      Sub.options.components[name] = Sub;
-    }
-
-    // keep a reference to the super options at extension time.
-    // later at instantiation we can check if Super's options have
-    // been updated.
-    Sub.superOptions = Super.options;
-    Sub.extendOptions = extendOptions;
-    Sub.sealedOptions = extend({}, Sub.options);
-
-    // cache constructor
-    cachedCtors[SuperId] = Sub;
-    return Sub
-  };
 }
 
-function initProps$1 (Comp) {
-  var props = Comp.options.props;
-  for (var key in props) {
-    proxy(Comp.prototype, "_props", key);
-  }
-}
-
-function initComputed$1 (Comp) {
-  var computed = Comp.options.computed;
-  for (var key in computed) {
-    defineComputed(Comp.prototype, key, computed[key]);
-  }
+function initMixin(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-/*  */
-
-function initAssetRegisters (Vue) {
-  /**
-   * Create asset registration methods.
-   */
-  ASSET_TYPES.forEach(function (type) {
-    Vue[type] = function (
-      id,
-      definition
-    ) {
-      if (!definition) {
-        return this.options[type + 's'][id]
-      } else {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && type === 'component') {
-          validateComponentName(id);
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    var cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        var Super = this;
+        var SuperId = Super.cid;
+        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        var name = extendOptions.name || Super.options.name;
+        if (process.env.NODE_ENV !== 'production' && name) {
+            validateComponentName(name);
         }
-        if (type === 'component' && isPlainObject(definition)) {
-          definition.name = definition.name || id;
-          definition = this.options._base.extend(definition);
+        var Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps(Sub);
         }
-        if (type === 'directive' && typeof definition === 'function') {
-          definition = { bind: definition, update: definition };
+        if (Sub.options.computed) {
+            initComputed(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
         }
-        this.options[type + 's'][id] = definition;
-        return definition
-      }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
     };
-  });
 }
-
-/*  */
-
-
-
-function getComponentName (opts) {
-  return opts && (opts.Ctor.options.name || opts.tag)
+function initProps(Comp) {
+    var props = Comp.options.props;
+    for (var key in props) {
+        proxy(Comp.prototype, "_props", key);
+    }
 }
-
-function matches (pattern, name) {
-  if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1
-  } else if (typeof pattern === 'string') {
-    return pattern.split(',').indexOf(name) > -1
-  } else if (isRegExp(pattern)) {
-    return pattern.test(name)
-  }
-  /* istanbul ignore next */
-  return false
+function initComputed(Comp) {
+    var computed = Comp.options.computed;
+    for (var key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function pruneCache (keepAliveInstance, filter) {
-  var cache = keepAliveInstance.cache;
-  var keys = keepAliveInstance.keys;
-  var _vnode = keepAliveInstance._vnode;
-  for (var key in cache) {
-    var cachedNode = cache[key];
-    if (cachedNode) {
-      var name = getComponentName(cachedNode.componentOptions);
-      if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
-      }
-    }
-  }
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach(function (type) {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (process.env.NODE_ENV !== 'production' && type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-function pruneCacheEntry (
-  cache,
-  key,
-  keys,
-  current
-) {
-  var cached$$1 = cache[key];
-  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {
-    cached$$1.componentInstance.$destroy();
-  }
-  cache[key] = null;
-  remove(keys, key);
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
 }
-
-var patternTypes = [String, RegExp, Array];
-
-var KeepAlive = {
-  name: 'keep-alive',
-  abstract: true,
-
-  props: {
-    include: patternTypes,
-    exclude: patternTypes,
-    max: [String, Number]
-  },
-
-  created: function created () {
-    this.cache = Object.create(null);
-    this.keys = [];
-  },
-
-  destroyed: function destroyed () {
-    for (var key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
     }
-  },
-
-  mounted: function mounted () {
-    var this$1 = this;
-
-    this.$watch('include', function (val) {
-      pruneCache(this$1, function (name) { return matches(val, name); });
-    });
-    this.$watch('exclude', function (val) {
-      pruneCache(this$1, function (name) { return !matches(val, name); });
-    });
-  },
-
-  render: function render () {
-    var slot = this.$slots.default;
-    var vnode = getFirstComponentChild(slot);
-    var componentOptions = vnode && vnode.componentOptions;
-    if (componentOptions) {
-      // check pattern
-      var name = getComponentName(componentOptions);
-      var ref = this;
-      var include = ref.include;
-      var exclude = ref.exclude;
-      if (
-        // not included
-        (include && (!name || !matches(include, name))) ||
-        // excluded
-        (exclude && name && matches(exclude, name))
-      ) {
-        return vnode
-      }
-
-      var ref$1 = this;
-      var cache = ref$1.cache;
-      var keys = ref$1.keys;
-      var key = vnode.key == null
-        // same constructor may get registered as different local components
-        // so cid alone is not enough (#3269)
-        ? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-        : vnode.key;
-      if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
-        // make current key freshest
-        remove(keys, key);
-        keys.push(key);
-      } else {
-        cache[key] = vnode;
-        keys.push(key);
-        // prune oldest entry
-        if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+    else if (typeof pattern === 'string') {
+        return pattern.split(',').indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+        var cachedNode = cache[key];
+        if (cachedNode) {
+            var name_1 = getComponentName(cachedNode.componentOptions);
+            if (name_1 && !filter(name_1)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
         }
-      }
-
-      vnode.data.keepAlive = true;
     }
-    return vnode || (slot && slot[0])
-  }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+        //@ts-expect-error has void type
+        cached.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
+}
+var patternTypes = [String, RegExp, Array];
+// TODO use defineComponent
+var KeepAlive = {
+    name: 'keep-alive',
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    created: function () {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed: function () {
+        for (var key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted: function () {
+        var _this = this;
+        this.$watch('include', function (val) {
+            pruneCache(_this, function (name) { return matches(val, name); });
+        });
+        this.$watch('exclude', function (val) {
+            pruneCache(_this, function (name) { return !matches(val, name); });
+        });
+    },
+    render: function () {
+        var slot = this.$slots.default;
+        var vnode = getFirstComponentChild(slot);
+        var componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            var name_2 = getComponentName(componentOptions);
+            var _a = this, include = _a.include, exclude = _a.exclude;
+            if (
+            // not included
+            (include && (!name_2 || !matches(include, name_2))) ||
+                // excluded
+                (exclude && name_2 && matches(exclude, name_2))) {
+                return vnode;
+            }
+            var _b = this, cache = _b.cache, keys = _b.keys;
+            var key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? "::" + componentOptions.tag : '')
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove$2(keys, key);
+                keys.push(key);
+            }
+            else {
+                cache[key] = vnode;
+                keys.push(key);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+            }
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
 var builtInComponents = {
-  KeepAlive: KeepAlive
+    KeepAlive: KeepAlive,
 };
 
-/*  */
-
-function initGlobalAPI (Vue) {
-  // config
-  var configDef = {};
-  configDef.get = function () { return config; };
-  if (process.env.NODE_ENV !== 'production') {
-    configDef.set = function () {
-      warn(
-        'Do not replace the Vue.config object, set individual fields instead.'
-      );
+function initGlobalAPI(Vue) {
+    // config
+    var configDef = {};
+    configDef.get = function () { return config; };
+    if (process.env.NODE_ENV !== 'production') {
+        configDef.set = function () {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn,
+        extend: extend,
+        mergeOptions: mergeOptions,
+        defineReactive: defineReactive,
     };
-  }
-  Object.defineProperty(Vue, 'config', configDef);
-
-  // exposed util methods.
-  // NOTE: these are not considered part of the public API - avoid relying on
-  // them unless you are aware of the risk.
-  Vue.util = {
-    warn: warn,
-    extend: extend,
-    mergeOptions: mergeOptions,
-    defineReactive: defineReactive$$1
-  };
-
-  Vue.set = set;
-  Vue.delete = del;
-  Vue.nextTick = nextTick;
-
-  // 2.6 explicit observable API
-  Vue.observable = function (obj) {
-    observe(obj);
-    return obj
-  };
-
-  Vue.options = Object.create(null);
-  ASSET_TYPES.forEach(function (type) {
-    Vue.options[type + 's'] = Object.create(null);
-  });
-
-  // this is used to identify the "base" constructor to extend all plain-object
-  // components with in Weex's multi-instance scenarios.
-  Vue.options._base = Vue;
-
-  extend(Vue.options.components, builtInComponents);
-
-  initUse(Vue);
-  initMixin$1(Vue);
-  initExtend(Vue);
-  initAssetRegisters(Vue);
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = function (obj) {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach(function (type) {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
 initGlobalAPI(Vue);
-
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering
+    get: isServerRendering,
 });
-
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-  get: function get () {
-    /* istanbul ignore next */
-    return this.$vnode && this.$vnode.ssrContext
-  }
+    get: function () {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
 });
-
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext
+    value: FunctionalRenderContext,
 });
-
-Vue.version = '2.6.10';
+Vue.version = '2.6.12';
 
 var latestNodeId = 1;
-
-function TextNode (text) {
-  this.instanceId = '';
-  this.nodeId = latestNodeId++;
-  this.parentNode = null;
-  this.nodeType = 3;
-  this.text = text;
+function TextNode(text) {
+    this.instanceId = '';
+    this.nodeId = latestNodeId++;
+    this.parentNode = null;
+    this.nodeType = 3;
+    this.text = text;
 }
 
-/*  */
-
 var namespaceMap = {};
-
-function createElement$1 (tagName) {
-  return document.createElement(tagName)
+function createElement(tagName) {
+    return document.createElement(tagName);
 }
-
-function createElementNS (namespace, tagName) {
-  return document.createElement(namespace + ':' + tagName)
+function createElementNS(namespace, tagName) {
+    return document.createElement(namespace + ':' + tagName);
 }
-
-function createTextNode (text) {
-  return new TextNode(text)
+function createTextNode(text) {
+    return new TextNode(text);
 }
-
-function createComment (text) {
-  return document.createComment(text)
+function createComment(text) {
+    return document.createComment(text);
 }
-
-function insertBefore (
-  node,
-  target,
-  before
-) {
-  if (target.nodeType === 3) {
-    if (node.type === 'text') {
-      node.setAttr('value', target.text);
-      target.parentNode = node;
-    } else {
-      var text = createElement$1('text');
-      text.setAttr('value', target.text);
-      node.insertBefore(text, before);
-    }
-    return
-  }
-  node.insertBefore(target, before);
+function insertBefore(node, target, before) {
+    if (target.nodeType === 3) {
+        if (node.type === 'text') {
+            node.setAttr('value', target.text);
+            target.parentNode = node;
+        }
+        else {
+            var text = createElement('text');
+            text.setAttr('value', target.text);
+            node.insertBefore(text, before);
+        }
+        return;
+    }
+    node.insertBefore(target, before);
 }
-
-function removeChild (node, child) {
-  if (child.nodeType === 3) {
-    node.setAttr('value', '');
-    return
-  }
-  node.removeChild(child);
+function removeChild(node, child) {
+    if (child.nodeType === 3) {
+        node.setAttr('value', '');
+        return;
+    }
+    node.removeChild(child);
 }
-
-function appendChild (node, child) {
-  if (child.nodeType === 3) {
-    if (node.type === 'text') {
-      node.setAttr('value', child.text);
-      child.parentNode = node;
-    } else {
-      var text = createElement$1('text');
-      text.setAttr('value', child.text);
-      node.appendChild(text);
-    }
-    return
-  }
-
-  node.appendChild(child);
+function appendChild(node, child) {
+    if (child.nodeType === 3) {
+        if (node.type === 'text') {
+            node.setAttr('value', child.text);
+            child.parentNode = node;
+        }
+        else {
+            var text = createElement('text');
+            text.setAttr('value', child.text);
+            node.appendChild(text);
+        }
+        return;
+    }
+    node.appendChild(child);
 }
-
-function parentNode (node) {
-  return node.parentNode
+function parentNode(node) {
+    return node.parentNode;
 }
-
-function nextSibling (node) {
-  return node.nextSibling
+function nextSibling(node) {
+    return node.nextSibling;
 }
-
-function tagName (node) {
-  return node.type
+function tagName(node) {
+    return node.type;
 }
-
-function setTextContent (node, text) {
-  if (node.parentNode) {
-    node.parentNode.setAttr('value', text);
-  }
+function setTextContent(node, text) {
+    if (node.parentNode) {
+        node.parentNode.setAttr('value', text);
+    }
 }
-
-function setAttribute (node, key, val) {
-  node.setAttr(key, val);
+function setAttribute(node, key, val) {
+    node.setAttr(key, val);
 }
-
-function setStyleScope (node, scopeId) {
-  node.setAttr('@styleScope', scopeId);
+function setStyleScope(node, scopeId) {
+    node.setAttr('@styleScope', scopeId);
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
+  __proto__: null,
   namespaceMap: namespaceMap,
-  createElement: createElement$1,
+  createElement: createElement,
   createElementNS: createElementNS,
   createTextNode: createTextNode,
   createComment: createComment,
@@ -5760,75 +5025,70 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-/*  */
-
 var ref = {
-  create: function create (_, vnode) {
-    registerRef(vnode);
-  },
-  update: function update (oldVnode, vnode) {
-    if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
-    }
-  },
-  destroy: function destroy (vnode) {
-    registerRef(vnode, true);
-  }
+    create: function (_, vnode) {
+        registerRef(vnode);
+    },
+    update: function (oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy: function (vnode) {
+        registerRef(vnode, true);
+    },
 };
-
-function registerRef (vnode, isRemoval) {
-  var key = vnode.data.ref;
-  if (!isDef(key)) { return }
-
-  var vm = vnode.context;
-  var ref = vnode.componentInstance || vnode.elm;
-  var refs = vm.$refs;
-  if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      remove(refs[key], ref);
-    } else if (refs[key] === ref) {
-      refs[key] = undefined;
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref];
-      } else if (refs[key].indexOf(ref) < 0) {
-        // $flow-disable-line
-        refs[key].push(ref);
-      }
-    } else {
-      refs[key] = ref;
+function registerRef(vnode, isRemoval) {
+    var key = vnode.data.ref;
+    if (!isDef(key))
+        { return; }
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
+    if (isRemoval) {
+        if (Array.isArray(refs[key])) {
+            // @ts-expect-error invalid typings
+            remove$2(refs[key], ref);
+        }
+        else if (refs[key] === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        // @ts-expect-error invalid typings
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(refs[key])) {
+                refs[key] = [ref];
+                // @ts-expect-error invalid typings
+            }
+            else if (refs[key].indexOf(ref) < 0) {
+                // @ts-expect-error invalid typings
+                refs[key].push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
     }
-  }
 }
 
-/*  */
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
+makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
 var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /**
@@ -5842,1901 +5102,1696 @@ var isTextInputType = makeMap('text,number,password,search,email,tel,url');
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-
 var emptyNode = new VNode('', {}, []);
-
 var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-
-function sameVnode (a, b) {
-  return (
-    a.key === b.key && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        a.asyncFactory === b.asyncFactory &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
-  )
-}
-
-function sameInputType (a, b) {
-  if (a.tag !== 'input') { return true }
-  var i;
-  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
-  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
-  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        ((a.tag === b.tag &&
+            a.isComment === b.isComment &&
+            isDef(a.data) === isDef(b.data) &&
+            sameInputType(a, b)) ||
+            (isTrue(a.isAsyncPlaceholder) &&
+                a.asyncFactory === b.asyncFactory &&
+                isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        { return true; }
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
-
-function createKeyToOldIdx (children, beginIdx, endIdx) {
-  var i, key;
-  var map = {};
-  for (i = beginIdx; i <= endIdx; ++i) {
-    key = children[i].key;
-    if (isDef(key)) { map[key] = i; }
-  }
-  return map
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    var i, key;
+    var map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            { map[key] = i; }
+    }
+    return map;
 }
-
-function createPatchFunction (backend) {
-  var i, j;
-  var cbs = {};
-
-  var modules = backend.modules;
-  var nodeOps = backend.nodeOps;
-
-  for (i = 0; i < hooks.length; ++i) {
-    cbs[hooks[i]] = [];
-    for (j = 0; j < modules.length; ++j) {
-      if (isDef(modules[j][hooks[i]])) {
-        cbs[hooks[i]].push(modules[j][hooks[i]]);
-      }
-    }
-  }
-
-  function emptyNodeAt (elm) {
-    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
-  }
-
-  function createRmCb (childElm, listeners) {
-    function remove$$1 () {
-      if (--remove$$1.listeners === 0) {
-        removeNode(childElm);
-      }
-    }
-    remove$$1.listeners = listeners;
-    return remove$$1
-  }
-
-  function removeNode (el) {
-    var parent = nodeOps.parentNode(el);
-    // element may have already been removed due to v-html / v-text
-    if (isDef(parent)) {
-      nodeOps.removeChild(parent, el);
+function createPatchFunction(backend) {
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules, nodeOps = backend.nodeOps;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
     }
-  }
-
-  function isUnknownElement$$1 (vnode, inVPre) {
-    return (
-      !inVPre &&
-      !vnode.ns &&
-      !(
-        config.ignoredElements.length &&
-        config.ignoredElements.some(function (ignore) {
-          return isRegExp(ignore)
-            ? ignore.test(vnode.tag)
-            : ignore === vnode.tag
-        })
-      ) &&
-      config.isUnknownElement(vnode.tag)
-    )
-  }
-
-  var creatingElmInVPre = 0;
-
-  function createElm (
-    vnode,
-    insertedVnodeQueue,
-    parentElm,
-    refElm,
-    nested,
-    ownerArray,
-    index
-  ) {
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // This vnode was used in a previous render!
-      // now it's used as a new node, overwriting its elm would cause
-      // potential patch errors down the road when it's used as an insertion
-      // reference node. Instead, we clone the node on-demand before creating
-      // associated DOM element for it.
-      vnode = ownerArray[index] = cloneVNode(vnode);
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
     }
-
-    vnode.isRootInsert = !nested; // for transition enter check
-    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-      return
+    function createRmCb(childElm, listeners) {
+        function remove() {
+            if (--remove.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove.listeners = listeners;
+        return remove;
+    }
+    function removeNode(el) {
+        var parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
     }
-
-    var data = vnode.data;
-    var children = vnode.children;
-    var tag = vnode.tag;
-    if (isDef(tag)) {
-      if (process.env.NODE_ENV !== 'production') {
-        if (data && data.pre) {
-          creatingElmInVPre++;
-        }
-        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
-          warn(
-            'Unknown custom element: <' + tag + '> - did you ' +
-            'register the component correctly? For recursive components, ' +
-            'make sure to provide the "name" option.',
-            vnode.context
-          );
-        }
-      }
-
-      vnode.elm = vnode.ns
-        ? nodeOps.createElementNS(vnode.ns, tag)
-        : nodeOps.createElement(tag, vnode);
-      setScope(vnode);
-
-      /* istanbul ignore if */
-      {
-        // in Weex, the default insertion order is parent-first.
-        // List items can be optimized to use children-first insertion
-        // with append="tree".
-        var appendAsTree = isDef(data) && isTrue(data.appendAsTree);
-        if (!appendAsTree) {
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-          }
-          insert(parentElm, vnode.elm, refElm);
+    function isUnknownElement(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some(function (ignore) {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    var creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        createChildren(vnode, children, insertedVnodeQueue);
-        if (appendAsTree) {
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-          }
-          insert(parentElm, vnode.elm, refElm);
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
         }
-      }
-
-      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-        creatingElmInVPre--;
-      }
-    } else if (isTrue(vnode.isComment)) {
-      vnode.elm = nodeOps.createComment(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    } else {
-      vnode.elm = nodeOps.createTextNode(vnode.text);
-      insert(parentElm, vnode.elm, refElm);
-    }
-  }
-
-  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i = vnode.data;
-    if (isDef(i)) {
-      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-      if (isDef(i = i.hook) && isDef(i = i.init)) {
-        i(vnode, false /* hydrating */);
-      }
-      // after calling the init hook, if the vnode is a child component
-      // it should've created a child instance and mounted it. the child
-      // component also has set the placeholder vnode's elm.
-      // in that case we can just return the element and be done.
-      if (isDef(vnode.componentInstance)) {
-        initComponent(vnode, insertedVnodeQueue);
-        insert(parentElm, vnode.elm, refElm);
-        if (isTrue(isReactivated)) {
-          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+        var data = vnode.data;
+        var children = vnode.children;
+        var tag = vnode.tag;
+        if (isDef(tag)) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                // in Weex, the default insertion order is parent-first.
+                // List items can be optimized to use children-first insertion
+                // with append="tree".
+                var appendAsTree = isDef(data) && isTrue(data.appendAsTree);
+                if (!appendAsTree) {
+                    if (isDef(data)) {
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                    }
+                    insert(parentElm, vnode.elm, refElm);
+                }
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (appendAsTree) {
+                    if (isDef(data)) {
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                    }
+                    insert(parentElm, vnode.elm, refElm);
+                }
+            }
+            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
         }
-        return true
-      }
     }
-  }
-
-  function initComponent (vnode, insertedVnodeQueue) {
-    if (isDef(vnode.data.pendingInsert)) {
-      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-      vnode.data.pendingInsert = null;
-    }
-    vnode.elm = vnode.componentInstance.$el;
-    if (isPatchable(vnode)) {
-      invokeCreateHooks(vnode, insertedVnodeQueue);
-      setScope(vnode);
-    } else {
-      // empty component root.
-      // skip all element-related modules except for ref (#3455)
-      registerRef(vnode);
-      // make sure to invoke the insert hook
-      insertedVnodeQueue.push(vnode);
-    }
-  }
-
-  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
-    var i;
-    // hack for #4339: a reactivated component with inner transition
-    // does not trigger because the inner node's created hooks are not called
-    // again. It's not ideal to involve module-specific logic in here but
-    // there doesn't seem to be a better way to do it.
-    var innerNode = vnode;
-    while (innerNode.componentInstance) {
-      innerNode = innerNode.componentInstance._vnode;
-      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
-        for (i = 0; i < cbs.activate.length; ++i) {
-          cbs.activate[i](emptyNode, innerNode);
-        }
-        insertedVnodeQueue.push(innerNode);
-        break
-      }
-    }
-    // unlike a newly created component,
-    // a reactivated keep-alive component doesn't insert itself
-    insert(parentElm, vnode.elm, refElm);
-  }
-
-  function insert (parent, elm, ref$$1) {
-    if (isDef(parent)) {
-      if (isDef(ref$$1)) {
-        if (nodeOps.parentNode(ref$$1) === parent) {
-          nodeOps.insertBefore(parent, elm, ref$$1);
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i = vnode.data;
+        if (isDef(i)) {
+            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
         }
-      } else {
-        nodeOps.appendChild(parent, elm);
-      }
     }
-  }
-
-  function createChildren (vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
-      if (process.env.NODE_ENV !== 'production') {
-        checkDuplicateKeys(children);
-      }
-      for (var i = 0; i < children.length; ++i) {
-        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-      }
-    } else if (isPrimitive(vnode.text)) {
-      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-    }
-  }
-
-  function isPatchable (vnode) {
-    while (vnode.componentInstance) {
-      vnode = vnode.componentInstance._vnode;
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
     }
-    return isDef(vnode.tag)
-  }
-
-  function invokeCreateHooks (vnode, insertedVnodeQueue) {
-    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-      cbs.create[i$1](emptyNode, vnode);
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        var i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        var innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
     }
-    i = vnode.data.hook; // Reuse variable
-    if (isDef(i)) {
-      if (isDef(i.create)) { i.create(emptyNode, vnode); }
-      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
+    function insert(parent, elm, ref) {
+        if (isDef(parent)) {
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
     }
-  }
-
-  // set scope id attribute for scoped CSS.
-  // this is implemented as a special case to avoid the overhead
-  // of going through the normal attribute patching process.
-  function setScope (vnode) {
-    var i;
-    if (isDef(i = vnode.fnScopeId)) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    } else {
-      var ancestor = vnode;
-      while (ancestor) {
-        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-          nodeOps.setStyleScope(vnode.elm, i);
-        }
-        ancestor = ancestor.parent;
-      }
-    }
-    // for slot content they should also get the scopeId from the host instance.
-    if (isDef(i = activeInstance) &&
-      i !== vnode.context &&
-      i !== vnode.fnContext &&
-      isDef(i = i.$options._scopeId)
-    ) {
-      nodeOps.setStyleScope(vnode.elm, i);
-    }
-  }
-
-  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            if (process.env.NODE_ENV !== 'production') {
+                checkDuplicateKeys(children);
+            }
+            for (var i_1 = 0; i_1 < children.length; ++i_1) {
+                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
     }
-  }
-
-  function invokeDestroyHook (vnode) {
-    var i, j;
-    var data = vnode.data;
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
-      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
     }
-    if (isDef(i = vnode.children)) {
-      for (j = 0; j < vnode.children.length; ++j) {
-        invokeDestroyHook(vnode.children[j]);
-      }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
+            cbs.create[i_2](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                { i.create(emptyNode, vnode); }
+            if (isDef(i.insert))
+                { insertedVnodeQueue.push(vnode); }
+        }
     }
-  }
-
-  function removeVnodes (vnodes, startIdx, endIdx) {
-    for (; startIdx <= endIdx; ++startIdx) {
-      var ch = vnodes[startIdx];
-      if (isDef(ch)) {
-        if (isDef(ch.tag)) {
-          removeAndInvokeRemoveHook(ch);
-          invokeDestroyHook(ch);
-        } else { // Text node
-          removeNode(ch.elm);
-        }
-      }
-    }
-  }
-
-  function removeAndInvokeRemoveHook (vnode, rm) {
-    if (isDef(rm) || isDef(vnode.data)) {
-      var i;
-      var listeners = cbs.remove.length + 1;
-      if (isDef(rm)) {
-        // we have a recursively passed down rm callback
-        // increase the listeners count
-        rm.listeners += listeners;
-      } else {
-        // directly removing
-        rm = createRmCb(vnode.elm, listeners);
-      }
-      // recursively invoke hooks on child component root node
-      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
-        removeAndInvokeRemoveHook(i, rm);
-      }
-      for (i = 0; i < cbs.remove.length; ++i) {
-        cbs.remove[i](vnode, rm);
-      }
-      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
-        i(vnode, rm);
-      } else {
-        rm();
-      }
-    } else {
-      removeNode(vnode.elm);
-    }
-  }
-
-  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-    var oldStartIdx = 0;
-    var newStartIdx = 0;
-    var oldEndIdx = oldCh.length - 1;
-    var oldStartVnode = oldCh[0];
-    var oldEndVnode = oldCh[oldEndIdx];
-    var newEndIdx = newCh.length - 1;
-    var newStartVnode = newCh[0];
-    var newEndVnode = newCh[newEndIdx];
-    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-
-    // removeOnly is a special flag used only by <transition-group>
-    // to ensure removed elements stay in correct relative positions
-    // during leaving transitions
-    var canMove = !removeOnly;
-
-    if (process.env.NODE_ENV !== 'production') {
-      checkDuplicateKeys(newCh);
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        var i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            var ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
     }
-
-    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-      if (isUndef(oldStartVnode)) {
-        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-      } else if (isUndef(oldEndVnode)) {
-        oldEndVnode = oldCh[--oldEndIdx];
-      } else if (sameVnode(oldStartVnode, newStartVnode)) {
-        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        oldStartVnode = oldCh[++oldStartIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else if (sameVnode(oldEndVnode, newEndVnode)) {
-        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
-        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-        oldStartVnode = oldCh[++oldStartIdx];
-        newEndVnode = newCh[--newEndIdx];
-      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
-        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-        oldEndVnode = oldCh[--oldEndIdx];
-        newStartVnode = newCh[++newStartIdx];
-      } else {
-        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-        idxInOld = isDef(newStartVnode.key)
-          ? oldKeyToIdx[newStartVnode.key]
-          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-        if (isUndef(idxInOld)) { // New element
-          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-        } else {
-          vnodeToMove = oldCh[idxInOld];
-          if (sameVnode(vnodeToMove, newStartVnode)) {
-            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-            oldCh[idxInOld] = undefined;
-            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-          } else {
-            // same key but different element. treat as new element
-            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-          }
-        }
-        newStartVnode = newCh[++newStartIdx];
-      }
-    }
-    if (oldStartIdx > oldEndIdx) {
-      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-    } else if (newStartIdx > newEndIdx) {
-      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-    }
-  }
-
-  function checkDuplicateKeys (children) {
-    var seenKeys = {};
-    for (var i = 0; i < children.length; i++) {
-      var vnode = children[i];
-      var key = vnode.key;
-      if (isDef(key)) {
-        if (seenKeys[key]) {
-          warn(
-            ("Duplicate keys detected: '" + key + "'. This may cause an update error."),
-            vnode.context
-          );
-        } else {
-          seenKeys[key] = true;
-        }
-      }
-    }
-  }
-
-  function findIdxInOld (node, oldCh, start, end) {
-    for (var i = start; i < end; i++) {
-      var c = oldCh[i];
-      if (isDef(c) && sameVnode(node, c)) { return i }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
     }
-  }
-
-  function patchVnode (
-    oldVnode,
-    vnode,
-    insertedVnodeQueue,
-    ownerArray,
-    index,
-    removeOnly
-  ) {
-    if (oldVnode === vnode) {
-      return
+    function invokeDestroyHook(vnode) {
+        var i, j;
+        var data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                { i(vnode); }
+            for (i = 0; i < cbs.destroy.length; ++i)
+                { cbs.destroy[i](vnode); }
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
     }
-
-    if (isDef(vnode.elm) && isDef(ownerArray)) {
-      // clone reused vnode
-      vnode = ownerArray[index] = cloneVNode(vnode);
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            var ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
     }
-
-    var elm = vnode.elm = oldVnode.elm;
-
-    if (isTrue(oldVnode.isAsyncPlaceholder)) {
-      if (isDef(vnode.asyncFactory.resolved)) {
-        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-      } else {
-        vnode.isAsyncPlaceholder = true;
-      }
-      return
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            var i_3;
+            var listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i_3 = vnode.componentInstance)) &&
+                isDef((i_3 = i_3._vnode)) &&
+                isDef(i_3.data)) {
+                removeAndInvokeRemoveHook(i_3, rm);
+            }
+            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
+                cbs.remove[i_3](vnode, rm);
+            }
+            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
+                i_3(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
     }
-
-    // reuse element for static trees.
-    // note we only do this if the vnode is cloned -
-    // if the new node is not cloned it means the render functions have been
-    // reset by the hot-reload-api and we need to do a proper re-render.
-    if (isTrue(vnode.isStatic) &&
-      isTrue(oldVnode.isStatic) &&
-      vnode.key === oldVnode.key &&
-      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-    ) {
-      vnode.componentInstance = oldVnode.componentInstance;
-      return
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        var oldStartIdx = 0;
+        var newStartIdx = 0;
+        var oldEndIdx = oldCh.length - 1;
+        var oldStartVnode = oldCh[0];
+        var oldEndVnode = oldCh[oldEndIdx];
+        var newEndIdx = newCh.length - 1;
+        var newStartVnode = newCh[0];
+        var newEndVnode = newCh[newEndIdx];
+        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        var canMove = !removeOnly;
+        if (process.env.NODE_ENV !== 'production') {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
     }
-
-    var i;
-    var data = vnode.data;
-    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-      i(oldVnode, vnode);
+    function checkDuplicateKeys(children) {
+        var seenKeys = {};
+        for (var i_4 = 0; i_4 < children.length; i_4++) {
+            var vnode = children[i_4];
+            var key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
     }
-
-    var oldCh = oldVnode.children;
-    var ch = vnode.children;
-    if (isDef(data) && isPatchable(vnode)) {
-      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
-      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
-    }
-    if (isUndef(vnode.text)) {
-      if (isDef(oldCh) && isDef(ch)) {
-        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-      } else if (isDef(ch)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkDuplicateKeys(ch);
-        }
-        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-      } else if (isDef(oldCh)) {
-        removeVnodes(oldCh, 0, oldCh.length - 1);
-      } else if (isDef(oldVnode.text)) {
-        nodeOps.setTextContent(elm, '');
-      }
-    } else if (oldVnode.text !== vnode.text) {
-      nodeOps.setTextContent(elm, vnode.text);
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
-    }
-  }
-
-  function invokeInsertHook (vnode, queue, initial) {
-    // delay insert hooks for component root nodes, invoke them after the
-    // element is really inserted
-    if (isTrue(initial) && isDef(vnode.parent)) {
-      vnode.parent.data.pendingInsert = queue;
-    } else {
-      for (var i = 0; i < queue.length; ++i) {
-        queue[i].data.hook.insert(queue[i]);
-      }
-    }
-  }
-
-  var hydrationBailed = false;
-  // list of modules that can skip create hook during hydration because they
-  // are already rendered on the client or has no need for initialization
-  // Note: style is excluded because it relies on initial clone for future
-  // deep updates (#7063).
-  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-
-  // Note: this is a browser-only function so we can assume elms are DOM nodes.
-  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
-    var i;
-    var tag = vnode.tag;
-    var data = vnode.data;
-    var children = vnode.children;
-    inVPre = inVPre || (data && data.pre);
-    vnode.elm = elm;
-
-    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-      vnode.isAsyncPlaceholder = true;
-      return true
+    function findIdxInOld(node, oldCh, start, end) {
+        for (var i_5 = start; i_5 < end; i_5++) {
+            var c = oldCh[i_5];
+            if (isDef(c) && sameVnode(node, c))
+                { return i_5; }
+        }
     }
-    // assert node match
-    if (process.env.NODE_ENV !== 'production') {
-      if (!assertNodeMatch(elm, vnode, inVPre)) {
-        return false
-      }
-    }
-    if (isDef(data)) {
-      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
-      if (isDef(i = vnode.componentInstance)) {
-        // child component. it should have hydrated its own tree.
-        initComponent(vnode, insertedVnodeQueue);
-        return true
-      }
-    }
-    if (isDef(tag)) {
-      if (isDef(children)) {
-        // empty element, allow client to pick up and populate children
-        if (!elm.hasChildNodes()) {
-          createChildren(vnode, children, insertedVnodeQueue);
-        } else {
-          // v-html and domProps: innerHTML
-          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
-            if (i !== elm.innerHTML) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('server innerHTML: ', i);
-                console.warn('client innerHTML: ', elm.innerHTML);
-              }
-              return false
-            }
-          } else {
-            // iterate and compare children lists
-            var childrenMatch = true;
-            var childNode = elm.firstChild;
-            for (var i$1 = 0; i$1 < children.length; i$1++) {
-              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                childrenMatch = false;
-                break
-              }
-              childNode = childNode.nextSibling;
-            }
-            // if childNode is not null, it means the actual childNodes list is
-            // longer than the virtual children list.
-            if (!childrenMatch || childNode) {
-              /* istanbul ignore if */
-              if (process.env.NODE_ENV !== 'production' &&
-                typeof console !== 'undefined' &&
-                !hydrationBailed
-              ) {
-                hydrationBailed = true;
-                console.warn('Parent: ', elm);
-                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-              }
-              return false
-            }
-          }
-        }
-      }
-      if (isDef(data)) {
-        var fullInvoke = false;
-        for (var key in data) {
-          if (!isRenderedModule(key)) {
-            fullInvoke = true;
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            break
-          }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        var elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
         }
-        if (!fullInvoke && data['class']) {
-          // ensure collecting deps for deep class bindings for future updates
-          traverse(data['class']);
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        var i;
+        var data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        var oldCh = oldVnode.children;
+        var ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                { cbs.update[i](oldVnode, vnode); }
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                { i(oldVnode, vnode); }
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+            }
+            else if (isDef(ch)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    { nodeOps.setTextContent(elm, ''); }
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                { i(oldVnode, vnode); }
         }
-      }
-    } else if (elm.data !== vnode.text) {
-      elm.data = vnode.text;
     }
-    return true
-  }
-
-  function assertNodeMatch (node, vnode, inVPre) {
-    if (isDef(vnode.tag)) {
-      return vnode.tag.indexOf('vue-component') === 0 || (
-        !isUnknownElement$$1(vnode, inVPre) &&
-        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
-      )
-    } else {
-      return node.nodeType === (vnode.isComment ? 8 : 3)
-    }
-  }
-
-  return function patch (oldVnode, vnode, hydrating, removeOnly) {
-    if (isUndef(vnode)) {
-      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
-      return
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
+                queue[i_6].data.hook.insert(queue[i_6]);
+            }
+        }
     }
-
-    var isInitialPatch = false;
-    var insertedVnodeQueue = [];
-
-    if (isUndef(oldVnode)) {
-      // empty mount (likely as component), create new root element
-      isInitialPatch = true;
-      createElm(vnode, insertedVnodeQueue);
-    } else {
-      var isRealElement = isDef(oldVnode.nodeType);
-      if (!isRealElement && sameVnode(oldVnode, vnode)) {
-        // patch existing root node
-        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-      } else {
-        if (isRealElement) {
-          // mounting to a real element
-          // check if this is server-rendered content and if we can perform
-          // a successful hydration.
-          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-            oldVnode.removeAttribute(SSR_ATTR);
-            hydrating = true;
-          }
-          if (isTrue(hydrating)) {
-            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-              invokeInsertHook(vnode, insertedVnodeQueue, true);
-              return oldVnode
-            } else if (process.env.NODE_ENV !== 'production') {
-              warn(
-                'The client-side rendered virtual DOM tree is not matching ' +
-                'server-rendered content. This is likely caused by incorrect ' +
-                'HTML markup, for example nesting block-level elements inside ' +
-                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                'full client-side render.'
-              );
-            }
-          }
-          // either not server-rendered, or hydration failed.
-          // create an empty node and replace it
-          oldVnode = emptyNodeAt(oldVnode);
+    var hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        var i;
+        var tag = vnode.tag, data = vnode.data, children = vnode.children;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
         }
-
-        // replacing existing element
-        var oldElm = oldVnode.elm;
-        var parentElm = nodeOps.parentNode(oldElm);
-
-        // create new node
-        createElm(
-          vnode,
-          insertedVnodeQueue,
-          // extremely rare edge case: do not insert if old element is in a
-          // leaving transition. Only happens when combining transition +
-          // keep-alive + HOCs. (#4590)
-          oldElm._leaveCb ? null : parentElm,
-          nodeOps.nextSibling(oldElm)
-        );
-
-        // update parent placeholder node element, recursively
-        if (isDef(vnode.parent)) {
-          var ancestor = vnode.parent;
-          var patchable = isPatchable(vnode);
-          while (ancestor) {
-            for (var i = 0; i < cbs.destroy.length; ++i) {
-              cbs.destroy[i](ancestor);
-            }
-            ancestor.elm = vnode.elm;
-            if (patchable) {
-              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                cbs.create[i$1](emptyNode, ancestor);
-              }
-              // #6513
-              // invoke insert hooks that may have been merged by create hooks.
-              // e.g. for directives that uses the "inserted" hook.
-              var insert = ancestor.data.hook.insert;
-              if (insert.merged) {
-                // start at index 1 to avoid re-invoking component mounted hook
-                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                  insert.fns[i$2]();
+        // assert node match
+        if (process.env.NODE_ENV !== 'production') {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                { i(vnode, true /* hydrating */); }
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        var childrenMatch = true;
+                        var childNode = elm.firstChild;
+                        for (var i_7 = 0; i_7 < children.length; i_7++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                var fullInvoke = false;
+                for (var key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
                 }
-              }
-            } else {
-              registerRef(ancestor);
             }
-            ancestor = ancestor.parent;
-          }
         }
-
-        // destroy old node
-        if (isDef(parentElm)) {
-          removeVnodes([oldVnode], 0, 0);
-        } else if (isDef(oldVnode.tag)) {
-          invokeDestroyHook(oldVnode);
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
         }
-      }
     }
-
-    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-    return vnode.elm
-  }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                { invokeDestroyHook(oldVnode); }
+            return;
+        }
+        var isInitialPatch = false;
+        var insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            var isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else if (process.env.NODE_ENV !== 'production') {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                var oldElm = oldVnode.elm;
+                var parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    var ancestor = vnode.parent;
+                    var patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
+                            cbs.destroy[i_8](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
+                                cbs.create[i_9](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            var insert_1 = ancestor.data.hook.insert;
+                            if (insert_1.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
+                                    insert_1.fns[i_10]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-/*  */
-
 var directives = {
-  create: updateDirectives,
-  update: updateDirectives,
-  destroy: function unbindDirectives (vnode) {
-    updateDirectives(vnode, emptyNode);
-  }
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
 };
-
-function updateDirectives (oldVnode, vnode) {
-  if (oldVnode.data.directives || vnode.data.directives) {
-    _update(oldVnode, vnode);
-  }
-}
-
-function _update (oldVnode, vnode) {
-  var isCreate = oldVnode === emptyNode;
-  var isDestroy = vnode === emptyNode;
-  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
-  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
-
-  var dirsWithInsert = [];
-  var dirsWithPostpatch = [];
-
-  var key, oldDir, dir;
-  for (key in newDirs) {
-    oldDir = oldDirs[key];
-    dir = newDirs[key];
-    if (!oldDir) {
-      // new directive, bind
-      callHook$1(dir, 'bind', vnode, oldVnode);
-      if (dir.def && dir.def.inserted) {
-        dirsWithInsert.push(dir);
-      }
-    } else {
-      // existing directive, update
-      dir.oldValue = oldDir.value;
-      dir.oldArg = oldDir.arg;
-      callHook$1(dir, 'update', vnode, oldVnode);
-      if (dir.def && dir.def.componentUpdated) {
-        dirsWithPostpatch.push(dir);
-      }
-    }
-  }
-
-  if (dirsWithInsert.length) {
-    var callInsert = function () {
-      for (var i = 0; i < dirsWithInsert.length; i++) {
-        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-      }
-    };
-    if (isCreate) {
-      mergeVNodeHook(vnode, 'insert', callInsert);
-    } else {
-      callInsert();
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
     }
-  }
-
-  if (dirsWithPostpatch.length) {
-    mergeVNodeHook(vnode, 'postpatch', function () {
-      for (var i = 0; i < dirsWithPostpatch.length; i++) {
-        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-      }
-    });
-  }
-
-  if (!isCreate) {
-    for (key in oldDirs) {
-      if (!newDirs[key]) {
-        // no longer present, unbind
-        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-      }
+    if (dirsWithInsert.length) {
+        var callInsert = function () {
+            for (var i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', function () {
+            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
     }
-  }
 }
-
 var emptyModifiers = Object.create(null);
-
-function normalizeDirectives$1 (
-  dirs,
-  vm
-) {
-  var res = Object.create(null);
-  if (!dirs) {
+function normalizeDirectives(dirs, vm) {
+    var res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    var i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
     // $flow-disable-line
-    return res
-  }
-  var i, dir;
-  for (i = 0; i < dirs.length; i++) {
-    dir = dirs[i];
-    if (!dir.modifiers) {
-      // $flow-disable-line
-      dir.modifiers = emptyModifiers;
-    }
-    res[getRawDirName(dir)] = dir;
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-  }
-  // $flow-disable-line
-  return res
+    return res;
 }
-
-function getRawDirName (dir) {
-  return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
+function getRawDirName(dir) {
+    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
 }
-
-function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
-  var fn = dir.def && dir.def[hook];
-  if (fn) {
-    try {
-      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-    } catch (e) {
-      handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    var fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+        }
     }
-  }
 }
 
-var baseModules = [
-  ref,
-  directives
-];
+var baseModules = [ref, directives];
 
-/*  */
-
-function updateAttrs (oldVnode, vnode) {
-  if (!oldVnode.data.attrs && !vnode.data.attrs) {
-    return
-  }
-  var key, cur, old;
-  var elm = vnode.elm;
-  var oldAttrs = oldVnode.data.attrs || {};
-  var attrs = vnode.data.attrs || {};
-  // clone observed objects, as the user probably wants to mutate it
-  if (attrs.__ob__) {
-    attrs = vnode.data.attrs = extend({}, attrs);
-  }
-
-  var supportBatchUpdate = typeof elm.setAttrs === 'function';
-  var batchedAttrs = {};
-  for (key in attrs) {
-    cur = attrs[key];
-    old = oldAttrs[key];
-    if (old !== cur) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = cur)
-        : elm.setAttr(key, cur);
-    }
-  }
-  for (key in oldAttrs) {
-    if (attrs[key] == null) {
-      supportBatchUpdate
-        ? (batchedAttrs[key] = undefined)
-        : elm.setAttr(key);
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setAttrs(batchedAttrs);
-  }
+function updateAttrs(oldVnode, vnode) {
+    if (!oldVnode.data.attrs && !vnode.data.attrs) {
+        return;
+    }
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (attrs.__ob__) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    var supportBatchUpdate = typeof elm.setAttrs === 'function';
+    var batchedAttrs = {};
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            supportBatchUpdate ? (batchedAttrs[key] = cur) : elm.setAttr(key, cur);
+        }
+    }
+    for (key in oldAttrs) {
+        if (attrs[key] == null) {
+            supportBatchUpdate ? (batchedAttrs[key] = undefined) : elm.setAttr(key);
+        }
+    }
+    if (supportBatchUpdate) {
+        elm.setAttrs(batchedAttrs);
+    }
 }
-
 var attrs = {
-  create: updateAttrs,
-  update: updateAttrs
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-/*  */
-
-function updateClass (oldVnode, vnode) {
-  var el = vnode.elm;
-  var ctx = vnode.context;
-
-  var data = vnode.data;
-  var oldData = oldVnode.data;
-  if (!data.staticClass &&
-    !data.class &&
-    (!oldData || (!oldData.staticClass && !oldData.class))
-  ) {
-    return
-  }
-
-  var oldClassList = makeClassList(oldData);
-  var classList = makeClassList(data);
-
-  if (typeof el.setClassList === 'function') {
-    el.setClassList(classList);
-  } else {
-    var style = getStyle(oldClassList, classList, ctx);
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(style);
-    } else {
-      for (var key in style) {
-        el.setStyle(key, style[key]);
-      }
-    }
-  }
+function updateClass(oldVnode, vnode) {
+    var el = vnode.elm;
+    var ctx = vnode.context;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (!data.staticClass &&
+        !data.class &&
+        (!oldData || (!oldData.staticClass && !oldData.class))) {
+        return;
+    }
+    var oldClassList = makeClassList(oldData);
+    var classList = makeClassList(data);
+    if (typeof el.setClassList === 'function') {
+        el.setClassList(classList);
+    }
+    else {
+        var style = getStyle(oldClassList, classList, ctx);
+        if (typeof el.setStyles === 'function') {
+            el.setStyles(style);
+        }
+        else {
+            for (var key in style) {
+                el.setStyle(key, style[key]);
+            }
+        }
+    }
 }
-
-function makeClassList (data) {
-  var classList = [];
-  // unlike web, weex vnode staticClass is an Array
-  var staticClass = data.staticClass;
-  var dataClass = data.class;
-  if (staticClass) {
-    classList.push.apply(classList, staticClass);
-  }
-  if (Array.isArray(dataClass)) {
-    classList.push.apply(classList, dataClass);
-  } else if (isObject(dataClass)) {
-    classList.push.apply(classList, Object.keys(dataClass).filter(function (className) { return dataClass[className]; }));
-  } else if (typeof dataClass === 'string') {
-    classList.push.apply(classList, dataClass.trim().split(/\s+/));
-  }
-  return classList
+function makeClassList(data) {
+    var classList = [];
+    // unlike web, weex vnode staticClass is an Array
+    var staticClass = data.staticClass;
+    var dataClass = data.class;
+    if (staticClass) {
+        classList.push.apply(classList, staticClass);
+    }
+    if (Array.isArray(dataClass)) {
+        classList.push.apply(classList, dataClass);
+    }
+    else if (isObject(dataClass)) {
+        classList.push.apply(classList, Object.keys(dataClass).filter(function (className) { return dataClass[className]; }));
+    }
+    else if (typeof dataClass === 'string') {
+        classList.push.apply(classList, dataClass.trim().split(/\s+/));
+    }
+    return classList;
 }
-
-function getStyle (oldClassList, classList, ctx) {
-  // style is a weex-only injected object
-  // compiled from <style> tags in weex files
-  var stylesheet = ctx.$options.style || {};
-  var result = {};
-  classList.forEach(function (name) {
-    var style = stylesheet[name];
-    extend(result, style);
-  });
-  oldClassList.forEach(function (name) {
-    var style = stylesheet[name];
-    for (var key in style) {
-      if (!result.hasOwnProperty(key)) {
-        result[key] = '';
-      }
-    }
-  });
-  return result
+function getStyle(oldClassList, classList, ctx) {
+    // style is a weex-only injected object
+    // compiled from <style> tags in weex files
+    //@ts-expect-error
+    var stylesheet = ctx.$options.style || {};
+    var result = {};
+    classList.forEach(function (name) {
+        var style = stylesheet[name];
+        extend(result, style);
+    });
+    oldClassList.forEach(function (name) {
+        var style = stylesheet[name];
+        for (var key in style) {
+            if (!result.hasOwnProperty(key)) {
+                result[key] = '';
+            }
+        }
+    });
+    return result;
 }
-
 var klass = {
-  create: updateClass,
-  update: updateClass
+    create: updateClass,
+    update: updateClass,
 };
 
-/*  */
-
-var target$1;
-
-function createOnceHandler$1 (event, handler, capture) {
-  var _target = target$1; // save current target element in closure
-  return function onceHandler () {
-    var res = handler.apply(null, arguments);
-    if (res !== null) {
-      remove$2(event, onceHandler, capture, _target);
-    }
-  }
+var target;
+function createOnceHandler(event, handler, capture) {
+    var _target = target; // save current target element in closure
+    return function onceHandler() {
+        var res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove(event, onceHandler, capture, _target);
+        }
+    };
 }
-
-function add$1 (
-  event,
-  handler,
-  capture,
-  passive,
-  params
-) {
-  if (capture) {
-    console.log('Weex do not support event in bubble phase.');
-    return
-  }
-  target$1.addEvent(event, handler, params);
+function add(event, handler, capture, passive, params) {
+    if (capture) {
+        console.log('Weex do not support event in bubble phase.');
+        return;
+    }
+    target.addEvent(event, handler, params);
 }
-
-function remove$2 (
-  event,
-  handler,
-  capture,
-  _target
-) {
-  (_target || target$1).removeEvent(event);
+function remove(event, handler, capture, _target) {
+    (_target || target).removeEvent(event);
 }
-
-function updateDOMListeners (oldVnode, vnode) {
-  if (!oldVnode.data.on && !vnode.data.on) {
-    return
-  }
-  var on = vnode.data.on || {};
-  var oldOn = oldVnode.data.on || {};
-  target$1 = vnode.elm;
-  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);
-  target$1 = undefined;
+function updateDOMListeners(oldVnode, vnode) {
+    if (!oldVnode.data.on && !vnode.data.on) {
+        return;
+    }
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target = vnode.elm;
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
 }
-
 var events = {
-  create: updateDOMListeners,
-  update: updateDOMListeners
+    create: updateDOMListeners,
+    update: updateDOMListeners,
 };
 
-/*  */
-
 var normalize = cached(camelize);
-
-function createStyle (oldVnode, vnode) {
-  if (!vnode.data.staticStyle) {
+function createStyle(oldVnode, vnode) {
+    if (!vnode.data.staticStyle) {
+        updateStyle(oldVnode, vnode);
+        return;
+    }
+    var elm = vnode.elm;
+    var staticStyle = vnode.data.staticStyle;
+    var supportBatchUpdate = typeof elm.setStyles === 'function';
+    var batchedStyles = {};
+    for (var name_1 in staticStyle) {
+        if (staticStyle[name_1]) {
+            supportBatchUpdate
+                ? (batchedStyles[normalize(name_1)] = staticStyle[name_1])
+                : elm.setStyle(normalize(name_1), staticStyle[name_1]);
+        }
+    }
+    if (supportBatchUpdate) {
+        elm.setStyles(batchedStyles);
+    }
     updateStyle(oldVnode, vnode);
-    return
-  }
-  var elm = vnode.elm;
-  var staticStyle = vnode.data.staticStyle;
-  var supportBatchUpdate = typeof elm.setStyles === 'function';
-  var batchedStyles = {};
-  for (var name in staticStyle) {
-    if (staticStyle[name]) {
-      supportBatchUpdate
-        ? (batchedStyles[normalize(name)] = staticStyle[name])
-        : elm.setStyle(normalize(name), staticStyle[name]);
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setStyles(batchedStyles);
-  }
-  updateStyle(oldVnode, vnode);
 }
-
-function updateStyle (oldVnode, vnode) {
-  if (!oldVnode.data.style && !vnode.data.style) {
-    return
-  }
-  var cur, name;
-  var elm = vnode.elm;
-  var oldStyle = oldVnode.data.style || {};
-  var style = vnode.data.style || {};
-
-  var needClone = style.__ob__;
-
-  // handle array syntax
-  if (Array.isArray(style)) {
-    style = vnode.data.style = toObject$1(style);
-  }
-
-  // clone the style for future updates,
-  // in case the user mutates the style object in-place.
-  if (needClone) {
-    style = vnode.data.style = extend({}, style);
-  }
-
-  var supportBatchUpdate = typeof elm.setStyles === 'function';
-  var batchedStyles = {};
-  for (name in oldStyle) {
-    if (!style[name]) {
-      supportBatchUpdate
-        ? (batchedStyles[normalize(name)] = '')
-        : elm.setStyle(normalize(name), '');
-    }
-  }
-  for (name in style) {
-    cur = style[name];
-    supportBatchUpdate
-      ? (batchedStyles[normalize(name)] = cur)
-      : elm.setStyle(normalize(name), cur);
-  }
-  if (supportBatchUpdate) {
-    elm.setStyles(batchedStyles);
-  }
+function updateStyle(oldVnode, vnode) {
+    if (!oldVnode.data.style && !vnode.data.style) {
+        return;
+    }
+    var cur, name;
+    var elm = vnode.elm;
+    var oldStyle = oldVnode.data.style || {};
+    var style = vnode.data.style || {};
+    var needClone = style.__ob__;
+    // handle array syntax
+    if (Array.isArray(style)) {
+        style = vnode.data.style = toObject(style);
+    }
+    // clone the style for future updates,
+    // in case the user mutates the style object in-place.
+    if (needClone) {
+        style = vnode.data.style = extend({}, style);
+    }
+    var supportBatchUpdate = typeof elm.setStyles === 'function';
+    var batchedStyles = {};
+    for (name in oldStyle) {
+        if (!style[name]) {
+            supportBatchUpdate
+                ? (batchedStyles[normalize(name)] = '')
+                : elm.setStyle(normalize(name), '');
+        }
+    }
+    for (name in style) {
+        cur = style[name];
+        supportBatchUpdate
+            ? (batchedStyles[normalize(name)] = cur)
+            : elm.setStyle(normalize(name), cur);
+    }
+    if (supportBatchUpdate) {
+        elm.setStyles(batchedStyles);
+    }
 }
-
-function toObject$1 (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 var style = {
-  create: createStyle,
-  update: updateStyle
+    create: createStyle,
+    update: updateStyle,
 };
 
-/*  */
-
-/*  */
-
-function resolveTransition (def$$1) {
-  if (!def$$1) {
-    return
-  }
-  /* istanbul ignore else */
-  if (typeof def$$1 === 'object') {
-    var res = {};
-    if (def$$1.css !== false) {
-      extend(res, autoCssTransition(def$$1.name || 'v'));
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        var res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
     }
-    extend(res, def$$1);
-    return res
-  } else if (typeof def$$1 === 'string') {
-    return autoCssTransition(def$$1)
-  }
 }
-
 var autoCssTransition = cached(function (name) {
-  return {
-    enterClass: (name + "-enter"),
-    enterToClass: (name + "-enter-to"),
-    enterActiveClass: (name + "-enter-active"),
-    leaveClass: (name + "-leave"),
-    leaveToClass: (name + "-leave-to"),
-    leaveActiveClass: (name + "-leave-active")
-  }
+    return {
+        enterClass: name + "-enter",
+        enterToClass: name + "-enter-to",
+        enterActiveClass: name + "-enter-active",
+        leaveClass: name + "-leave",
+        leaveToClass: name + "-leave-to",
+        leaveActiveClass: name + "-leave-active",
+    };
 });
-
-var hasTransition = inBrowser && !isIE9;
-if (hasTransition) {
-  /* istanbul ignore if */
-  if (window.ontransitionend === undefined &&
-    window.onwebkittransitionend !== undefined
-  ) ;
-  if (window.onanimationend === undefined &&
-    window.onwebkitanimationend !== undefined
-  ) ;
-}
-
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
-  ? window.requestAnimationFrame
-    ? window.requestAnimationFrame.bind(window)
-    : setTimeout
-  : /* istanbul ignore next */ function (fn) { return fn(); };
+inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ function (fn) { return fn(); };
 
 var transition = {
-  create: enter,
-  activate: enter,
-  remove: leave
+    create: enter,
+    activate: enter,
+    remove: leave,
 };
-
-function enter (_, vnode) {
-  var el = vnode.elm;
-
-  // call leave callback now
-  if (el._leaveCb) {
-    el._leaveCb.cancelled = true;
-    el._leaveCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (!data) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (el._enterCb) {
-    return
-  }
-
-  var enterClass = data.enterClass;
-  var enterToClass = data.enterToClass;
-  var enterActiveClass = data.enterActiveClass;
-  var appearClass = data.appearClass;
-  var appearToClass = data.appearToClass;
-  var appearActiveClass = data.appearActiveClass;
-  var beforeEnter = data.beforeEnter;
-  var enter = data.enter;
-  var afterEnter = data.afterEnter;
-  var enterCancelled = data.enterCancelled;
-  var beforeAppear = data.beforeAppear;
-  var appear = data.appear;
-  var afterAppear = data.afterAppear;
-  var appearCancelled = data.appearCancelled;
-
-  var context = activeInstance;
-  var transitionNode = activeInstance.$vnode;
-  while (transitionNode && transitionNode.parent) {
-    transitionNode = transitionNode.parent;
-    context = transitionNode.context;
-  }
-
-  var isAppear = !context._isMounted || !vnode.isRootInsert;
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  var startClass = isAppear ? appearClass : enterClass;
-  var toClass = isAppear ? appearToClass : enterToClass;
-  var activeClass = isAppear ? appearActiveClass : enterActiveClass;
-  var beforeEnterHook = isAppear ? (beforeAppear || beforeEnter) : beforeEnter;
-  var enterHook = isAppear ? (typeof appear === 'function' ? appear : enter) : enter;
-  var afterEnterHook = isAppear ? (afterAppear || afterEnter) : afterEnter;
-  var enterCancelledHook = isAppear ? (appearCancelled || enterCancelled) : enterCancelled;
-
-  var userWantsControl =
-    enterHook &&
-    // enterHook may be a bound method which exposes
-    // the length of original fn as _length
-    (enterHook._length || enterHook.length) > 1;
-
-  var stylesheet = vnode.context.$options.style || {};
-  var startState = stylesheet[startClass];
-  var transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {};
-  var endState = getEnterTargetState(el, stylesheet, startClass, toClass, activeClass);
-  var needAnimation = Object.keys(endState).length > 0;
-
-  var cb = el._enterCb = once(function () {
-    if (cb.cancelled) {
-      enterCancelledHook && enterCancelledHook(el);
-    } else {
-      afterEnterHook && afterEnterHook(el);
-    }
-    el._enterCb = null;
-  });
-
-  // We need to wait until the native element has been inserted, but currently
-  // there's no API to do that. So we have to wait "one frame" - not entirely
-  // sure if this is guaranteed to be enough (e.g. on slow devices?)
-  setTimeout(function () {
-    var parent = el.parentNode;
-    var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-    if (pendingNode &&
-      pendingNode.context === vnode.context &&
-      pendingNode.tag === vnode.tag &&
-      pendingNode.elm._leaveCb
-    ) {
-      pendingNode.elm._leaveCb();
-    }
-    enterHook && enterHook(el, cb);
-
-    if (needAnimation) {
-      var animation = vnode.context.$requireWeexModule('animation');
-      animation.transition(el.ref, {
-        styles: endState,
-        duration: transitionProperties.duration || 0,
-        delay: transitionProperties.delay || 0,
-        timingFunction: transitionProperties.timingFunction || 'linear'
-      }, userWantsControl ? noop : cb);
-    } else if (!userWantsControl) {
-      cb();
-    }
-  }, 16);
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el);
-
-  if (startState) {
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(startState);
-    } else {
-      for (var key in startState) {
-        el.setStyle(key, startState[key]);
-      }
-    }
-  }
-
-  if (!needAnimation && !userWantsControl) {
-    cb();
-  }
-}
-
-function leave (vnode, rm) {
-  var el = vnode.elm;
-
-  // call enter callback now
-  if (el._enterCb) {
-    el._enterCb.cancelled = true;
-    el._enterCb();
-  }
-
-  var data = resolveTransition(vnode.data.transition);
-  if (!data) {
-    return rm()
-  }
-
-  if (el._leaveCb) {
-    return
-  }
-
-  var leaveClass = data.leaveClass;
-  var leaveToClass = data.leaveToClass;
-  var leaveActiveClass = data.leaveActiveClass;
-  var beforeLeave = data.beforeLeave;
-  var leave = data.leave;
-  var afterLeave = data.afterLeave;
-  var leaveCancelled = data.leaveCancelled;
-  var delayLeave = data.delayLeave;
-
-  var userWantsControl =
-    leave &&
-    // leave hook may be a bound method which exposes
-    // the length of original fn as _length
-    (leave._length || leave.length) > 1;
-
-  var stylesheet = vnode.context.$options.style || {};
-  var startState = stylesheet[leaveClass];
-  var endState = stylesheet[leaveToClass] || stylesheet[leaveActiveClass];
-  var transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][leaveActiveClass]) || {};
-
-  var cb = el._leaveCb = once(function () {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null;
-    }
-    if (cb.cancelled) {
-      leaveCancelled && leaveCancelled(el);
-    } else {
-      rm();
-      afterLeave && afterLeave(el);
-    }
-    el._leaveCb = null;
-  });
-
-  if (delayLeave) {
-    delayLeave(performLeave);
-  } else {
-    performLeave();
-  }
-
-  function performLeave () {
-    var animation = vnode.context.$requireWeexModule('animation');
-    // the delayed leave may have already been cancelled
-    if (cb.cancelled) {
-      return
+function enter(_, vnode) {
+    var el = vnode.elm;
+    // call leave callback now
+    if (el._leaveCb) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
     }
-    // record leaving element
-    if (!vnode.data.show) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+    var data = resolveTransition(vnode.data.transition);
+    if (!data) {
+        return;
     }
-    beforeLeave && beforeLeave(el);
-
+    /* istanbul ignore if */
+    if (el._enterCb) {
+        return;
+    }
+    var enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled;
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        transitionNode = transitionNode.parent;
+        context = transitionNode.context;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    var startClass = isAppear ? appearClass : enterClass;
+    var toClass = isAppear ? appearToClass : enterToClass;
+    var activeClass = isAppear ? appearActiveClass : enterActiveClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    var userWantsControl = enterHook &&
+        // enterHook may be a bound method which exposes
+        // the length of original fn as _length
+        (enterHook._length || enterHook.length) > 1;
+    var stylesheet = vnode.context.$options.style || {};
+    var startState = stylesheet[startClass];
+    var transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {};
+    var endState = getEnterTargetState(el, stylesheet, startClass, toClass, activeClass);
+    var needAnimation = Object.keys(endState).length > 0;
+    var cb = (el._enterCb = once(function () {
+        //@ts-expect-error
+        if (cb.cancelled) {
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    // We need to wait until the native element has been inserted, but currently
+    // there's no API to do that. So we have to wait "one frame" - not entirely
+    // sure if this is guaranteed to be enough (e.g. on slow devices?)
+    setTimeout(function () {
+        var parent = el.parentNode;
+        var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        if (pendingNode &&
+            pendingNode.context === vnode.context &&
+            pendingNode.tag === vnode.tag &&
+            pendingNode.elm._leaveCb) {
+            pendingNode.elm._leaveCb();
+        }
+        enterHook && enterHook(el, cb);
+        if (needAnimation) {
+            var animation = vnode.context.$requireWeexModule('animation');
+            animation.transition(el.ref, {
+                styles: endState,
+                duration: transitionProperties.duration || 0,
+                delay: transitionProperties.delay || 0,
+                timingFunction: transitionProperties.timingFunction || 'linear',
+            }, userWantsControl ? noop : cb);
+        }
+        else if (!userWantsControl) {
+            cb();
+        }
+    }, 16);
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
     if (startState) {
-      animation.transition(el.ref, {
-        styles: startState
-      }, next);
-    } else {
-      next();
-    }
-
-    function next () {
-      animation.transition(el.ref, {
-        styles: endState,
-        duration: transitionProperties.duration || 0,
-        delay: transitionProperties.delay || 0,
-        timingFunction: transitionProperties.timingFunction || 'linear'
-      }, userWantsControl ? noop : cb);
+        if (typeof el.setStyles === 'function') {
+            el.setStyles(startState);
+        }
+        else {
+            for (var key in startState) {
+                el.setStyle(key, startState[key]);
+            }
+        }
     }
-
-    leave && leave(el, cb);
-    if (!endState && !userWantsControl) {
-      cb();
+    if (!needAnimation && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    var el = vnode.elm;
+    // call enter callback now
+    if (el._enterCb) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (!data) {
+        return rm();
+    }
+    if (el._leaveCb) {
+        return;
+    }
+    var leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave;
+    var userWantsControl = leave &&
+        // leave hook may be a bound method which exposes
+        // the length of original fn as _length
+        (leave._length || leave.length) > 1;
+    var stylesheet = vnode.context.$options.style || {};
+    var startState = stylesheet[leaveClass];
+    var endState = stylesheet[leaveToClass] || stylesheet[leaveActiveClass];
+    var transitionProperties = (stylesheet['@TRANSITION'] &&
+        stylesheet['@TRANSITION'][leaveActiveClass]) ||
+        {};
+    var cb = (el._leaveCb = once(function () {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        //@ts-expect-error
+        if (cb.cancelled) {
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        var animation = vnode.context.$requireWeexModule('animation');
+        // the delayed leave may have already been cancelled
+        //@ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (startState) {
+            animation.transition(el.ref, {
+                styles: startState,
+            }, next);
+        }
+        else {
+            next();
+        }
+        function next() {
+            animation.transition(el.ref, {
+                styles: endState,
+                duration: transitionProperties.duration || 0,
+                delay: transitionProperties.delay || 0,
+                timingFunction: transitionProperties.timingFunction || 'linear',
+            }, userWantsControl ? noop : cb);
+        }
+        leave && leave(el, cb);
+        if (!endState && !userWantsControl) {
+            cb();
+        }
     }
-  }
 }
-
 // determine the target animation style for an entering transition.
-function getEnterTargetState (el, stylesheet, startClass, endClass, activeClass) {
-  var targetState = {};
-  var startState = stylesheet[startClass];
-  var endState = stylesheet[endClass];
-  var activeState = stylesheet[activeClass];
-  // 1. fallback to element's default styling
-  if (startState) {
-    for (var key in startState) {
-      targetState[key] = el.style[key];
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        targetState[key] == null &&
-        (!activeState || activeState[key] == null) &&
-        (!endState || endState[key] == null)
-      ) {
-        warn(
-          "transition property \"" + key + "\" is declared in enter starting class (." + startClass + "), " +
-          "but not declared anywhere in enter ending class (." + endClass + "), " +
-          "enter active cass (." + activeClass + ") or the element's default styling. " +
-          "Note in Weex, CSS properties need explicit values to be transitionable."
-        );
-      }
-    }
-  }
-  // 2. if state is mixed in active state, extract them while excluding
-  //    transition properties
-  if (activeState) {
-    for (var key$1 in activeState) {
-      if (key$1.indexOf('transition') !== 0) {
-        targetState[key$1] = activeState[key$1];
-      }
-    }
-  }
-  // 3. explicit endState has highest priority
-  if (endState) {
-    extend(targetState, endState);
-  }
-  return targetState
+function getEnterTargetState(el, stylesheet, startClass, endClass, activeClass) {
+    var targetState = {};
+    var startState = stylesheet[startClass];
+    var endState = stylesheet[endClass];
+    var activeState = stylesheet[activeClass];
+    // 1. fallback to element's default styling
+    if (startState) {
+        for (var key in startState) {
+            targetState[key] = el.style[key];
+            if (process.env.NODE_ENV !== 'production' &&
+                targetState[key] == null &&
+                (!activeState || activeState[key] == null) &&
+                (!endState || endState[key] == null)) {
+                warn("transition property \"" + key + "\" is declared in enter starting class (." + startClass + "), " +
+                    ("but not declared anywhere in enter ending class (." + endClass + "), ") +
+                    ("enter active cass (." + activeClass + ") or the element's default styling. ") +
+                    "Note in Weex, CSS properties need explicit values to be transitionable.");
+            }
+        }
+    }
+    // 2. if state is mixed in active state, extract them while excluding
+    //    transition properties
+    if (activeState) {
+        for (var key in activeState) {
+            if (key.indexOf('transition') !== 0) {
+                targetState[key] = activeState[key];
+            }
+        }
+    }
+    // 3. explicit endState has highest priority
+    if (endState) {
+        extend(targetState, endState);
+    }
+    return targetState;
 }
 
-var platformModules = [
-  attrs,
-  klass,
-  events,
-  style,
-  transition
-];
-
-/*  */
+var platformModules = [attrs, klass, events, style, transition];
 
 // the directive module should be applied last, after all
 // built-in modules have been applied.
 var modules = platformModules.concat(baseModules);
-
 var patch = createPatchFunction({
-  nodeOps: nodeOps,
-  modules: modules,
-  LONG_LIST_THRESHOLD: 10
+    nodeOps: nodeOps,
+    modules: modules,
+    LONG_LIST_THRESHOLD: 10,
 });
 
-var platformDirectives = {
-};
-
-/*  */
-
-function getVNodeType (vnode) {
-  if (!vnode.tag) {
-    return ''
-  }
-  return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '')
-}
+var platformDirectives = {};
 
-function isSimpleSpan (vnode) {
-  return vnode.children &&
-    vnode.children.length === 1 &&
-    !vnode.children[0].tag
+function getVNodeType(vnode) {
+    if (!vnode.tag) {
+        return '';
+    }
+    return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '');
 }
-
-function parseStyle (vnode) {
-  if (!vnode || !vnode.data) {
-    return
-  }
-  var ref = vnode.data;
-  var staticStyle = ref.staticStyle;
-  var staticClass = ref.staticClass;
-  if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
-    var styles = Object.assign({}, staticStyle, vnode.data.style);
-    var cssMap = vnode.context.$options.style || {};
-    var classList = [].concat(staticClass, vnode.data.class);
-    classList.forEach(function (name) {
-      if (name && cssMap[name]) {
-        Object.assign(styles, cssMap[name]);
-      }
-    });
-    return styles
-  }
+function isSimpleSpan(vnode) {
+    return (vnode.children &&
+        vnode.children.length === 1 &&
+        !vnode.children[0].tag);
 }
-
-function convertVNodeChildren (children) {
-  if (!children.length) {
-    return
-  }
-
-  return children.map(function (vnode) {
-    var type = getVNodeType(vnode);
-    var props = { type: type };
-
-    // convert raw text node
-    if (!type) {
-      props.type = 'span';
-      props.attr = {
-        value: (vnode.text || '').trim()
-      };
-    } else {
-      props.style = parseStyle(vnode);
-      if (vnode.data) {
-        props.attr = vnode.data.attrs;
-        if (vnode.data.on) {
-          props.events = vnode.data.on;
-        }
-      }
-      if (type === 'span' && isSimpleSpan(vnode)) {
-        props.attr = props.attr || {};
-        props.attr.value = vnode.children[0].text.trim();
-        return props
-      }
+function parseStyle(vnode) {
+    if (!vnode || !vnode.data) {
+        return;
     }
-
-    if (vnode.children && vnode.children.length) {
-      props.children = convertVNodeChildren(vnode.children);
+    var _a = vnode.data, staticStyle = _a.staticStyle, staticClass = _a.staticClass;
+    if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
+        var styles_1 = Object.assign({}, staticStyle, vnode.data.style);
+        // @ts-expect-error
+        var cssMap_1 = vnode.context.$options.style || {};
+        var classList = [].concat(staticClass, vnode.data.class);
+        classList.forEach(function (name) {
+            if (name && cssMap_1[name]) {
+                Object.assign(styles_1, cssMap_1[name]);
+            }
+        });
+        return styles_1;
     }
-
-    return props
-  })
 }
-
+function convertVNodeChildren(children) {
+    if (!children.length) {
+        return;
+    }
+    return children.map(function (vnode) {
+        var type = getVNodeType(vnode);
+        var props = { type: type };
+        // convert raw text node
+        if (!type) {
+            props.type = 'span';
+            props.attr = {
+                value: (vnode.text || '').trim(),
+            };
+        }
+        else {
+            props.style = parseStyle(vnode);
+            if (vnode.data) {
+                props.attr = vnode.data.attrs;
+                if (vnode.data.on) {
+                    props.events = vnode.data.on;
+                }
+            }
+            if (type === 'span' && isSimpleSpan(vnode)) {
+                props.attr = props.attr || {};
+                //@ts-expect-error
+                props.attr.value = vnode.children[0].text.trim();
+                return props;
+            }
+        }
+        if (vnode.children && vnode.children.length) {
+            props.children = convertVNodeChildren(vnode.children);
+        }
+        return props;
+    });
+}
 var Richtext = {
-  name: 'richtext',
-  render: function render (h) {
-    return h('weex:richtext', {
-      on: this._events,
-      attrs: {
-        value: convertVNodeChildren(this.$options._renderChildren || [])
-      }
-    })
-  }
+    name: 'richtext',
+    render: function (h) {
+        return h('weex:richtext', {
+            on: this._events,
+            attrs: {
+                value: convertVNodeChildren(this.$options._renderChildren || []),
+            },
+        });
+    },
 };
 
-/*  */
-
+// Provides transition support for a single element/component.
 var transitionProps = {
-  name: String,
-  appear: Boolean,
-  css: Boolean,
-  mode: String,
-  type: String,
-  enterClass: String,
-  leaveClass: String,
-  enterToClass: String,
-  leaveToClass: String,
-  enterActiveClass: String,
-  leaveActiveClass: String,
-  appearClass: String,
-  appearActiveClass: String,
-  appearToClass: String,
-  duration: [Number, String, Object]
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
 };
-
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
-function getRealChild (vnode) {
-  var compOptions = vnode && vnode.componentOptions;
-  if (compOptions && compOptions.Ctor.options.abstract) {
-    return getRealChild(getFirstComponentChild(compOptions.children))
-  } else {
-    return vnode
-  }
-}
-
-function extractTransitionData (comp) {
-  var data = {};
-  var options = comp.$options;
-  // props
-  for (var key in options.propsData) {
-    data[key] = comp[key];
-  }
-  // events.
-  // extract listeners and pass them directly to the transition methods
-  var listeners = options._parentListeners;
-  for (var key$1 in listeners) {
-    data[camelize(key$1)] = listeners[key$1];
-  }
-  return data
-}
-
-function placeholder (h, rawChild) {
-  if (/\d-keep-alive$/.test(rawChild.tag)) {
-    return h('keep-alive', {
-      props: rawChild.componentOptions.propsData
-    })
-  }
+function getRealChild(vnode) {
+    var compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    var data = {};
+    var options = comp.$options;
+    // props
+    for (var key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    var listeners = options._parentListeners;
+    for (var key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
 }
-
-function hasParentTransition (vnode) {
-  while ((vnode = vnode.parent)) {
-    if (vnode.data.transition) {
-      return true
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
     }
-  }
 }
-
-function isSameChild (child, oldChild) {
-  return oldChild.key === child.key && oldChild.tag === child.tag
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-
 var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-
 var isVShowDirective = function (d) { return d.name === 'show'; };
-
 var Transition = {
-  name: 'transition',
-  props: transitionProps,
-  abstract: true,
-
-  render: function render (h) {
-    var this$1 = this;
-
-    var children = this.$slots.default;
-    if (!children) {
-      return
-    }
-
-    // filter out text nodes (possible whitespaces)
-    children = children.filter(isNotTextNode);
-    /* istanbul ignore if */
-    if (!children.length) {
-      return
-    }
-
-    // warn multiple elements
-    if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-      warn(
-        '<transition> can only be used on a single element. Use ' +
-        '<transition-group> for lists.',
-        this.$parent
-      );
-    }
-
-    var mode = this.mode;
-
-    // warn invalid mode
-    if (process.env.NODE_ENV !== 'production' &&
-      mode && mode !== 'in-out' && mode !== 'out-in'
-    ) {
-      warn(
-        'invalid <transition> mode: ' + mode,
-        this.$parent
-      );
-    }
-
-    var rawChild = children[0];
-
-    // if this is a component root node and the component's
-    // parent container node also has transition, skip.
-    if (hasParentTransition(this.$vnode)) {
-      return rawChild
-    }
-
-    // apply transition data to child
-    // use getRealChild() to ignore abstract components e.g. keep-alive
-    var child = getRealChild(rawChild);
-    /* istanbul ignore if */
-    if (!child) {
-      return rawChild
-    }
-
-    if (this._leaving) {
-      return placeholder(h, rawChild)
-    }
-
-    // ensure a key that is unique to the vnode type and to this transition
-    // component instance. This key will be used to remove pending leaving nodes
-    // during entering.
-    var id = "__transition-" + (this._uid) + "-";
-    child.key = child.key == null
-      ? child.isComment
-        ? id + 'comment'
-        : id + child.tag
-      : isPrimitive(child.key)
-        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)
-        : child.key;
-
-    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);
-    var oldRawChild = this._vnode;
-    var oldChild = getRealChild(oldRawChild);
-
-    // mark v-show
-    // so that the transition module can hand over the control to the directive
-    if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-      child.data.show = true;
-    }
-
-    if (
-      oldChild &&
-      oldChild.data &&
-      !isSameChild(child, oldChild) &&
-      !isAsyncPlaceholder(oldChild) &&
-      // #6687 component root is a comment node
-      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)
-    ) {
-      // replace old child transition data with fresh one
-      // important for dynamic transitions!
-      var oldData = oldChild.data.transition = extend({}, data);
-      // handle transition mode
-      if (mode === 'out-in') {
-        // return placeholder node and queue update when leave finishes
-        this._leaving = true;
-        mergeVNodeHook(oldData, 'afterLeave', function () {
-          this$1._leaving = false;
-          this$1.$forceUpdate();
-        });
-        return placeholder(h, rawChild)
-      } else if (mode === 'in-out') {
-        if (isAsyncPlaceholder(child)) {
-          return oldRawChild
-        }
-        var delayedLeave;
-        var performLeave = function () { delayedLeave(); };
-        mergeVNodeHook(data, 'afterEnter', performLeave);
-        mergeVNodeHook(data, 'enterCancelled', performLeave);
-        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
-      }
-    }
-
-    return rawChild
-  }
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render: function (h) {
+        var _this = this;
+        var children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        var mode = this.mode;
+        // warn invalid mode
+        if (process.env.NODE_ENV !== 'production' &&
+            mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        var rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        var child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        var id = "__transition-" + this._uid + "-";
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        var oldRawChild = this._vnode;
+        var oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            var oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', function () {
+                    _this._leaving = false;
+                    _this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                var delayedLeave_1;
+                var performLeave = function () {
+                    delayedLeave_1();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                    delayedLeave_1 = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-// reuse same transition component logic from web
-
 var props = extend({
-  tag: String,
-  moveClass: String
+    tag: String,
+    moveClass: String,
 }, transitionProps);
-
 delete props.mode;
-
 var TransitionGroup = {
-  props: props,
-
-  created: function created () {
-    var dom = this.$requireWeexModule('dom');
-    this.getPosition = function (el) { return new Promise(function (resolve, reject) {
-      dom.getComponentRect(el.ref, function (res) {
-        if (!res.result) {
-          reject(new Error(("failed to get rect for element: " + (el.tag))));
-        } else {
-          resolve(res.size);
-        }
-      });
-    }); };
-
-    var animation = this.$requireWeexModule('animation');
-    this.animate = function (el, options) { return new Promise(function (resolve) {
-      animation.transition(el.ref, options, resolve);
-    }); };
-  },
-
-  render: function render (h) {
-    var tag = this.tag || this.$vnode.data.tag || 'span';
-    var map = Object.create(null);
-    var prevChildren = this.prevChildren = this.children;
-    var rawChildren = this.$slots.default || [];
-    var children = this.children = [];
-    var transitionData = extractTransitionData(this);
-
-    for (var i = 0; i < rawChildren.length; i++) {
-      var c = rawChildren[i];
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c);
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData;
-        } else if (process.env.NODE_ENV !== 'production') {
-          var opts = c.componentOptions;
-          var name = opts
-            ? (opts.Ctor.options.name || opts.tag)
-            : c.tag;
-          warn(("<transition-group> children must be keyed: <" + name + ">"));
-        }
-      }
-    }
-
-    if (prevChildren) {
-      var kept = [];
-      var removed = [];
-      prevChildren.forEach(function (c) {
-        c.data.transition = transitionData;
-
-        // TODO: record before patch positions
-
-        if (map[c.key]) {
-          kept.push(c);
-        } else {
-          removed.push(c);
+    props: props,
+    created: function () {
+        var dom = this.$requireWeexModule('dom');
+        this.getPosition = function (el) {
+            return new Promise(function (resolve, reject) {
+                dom.getComponentRect(el.ref, function (res) {
+                    if (!res.result) {
+                        reject(new Error("failed to get rect for element: " + el.tag));
+                    }
+                    else {
+                        resolve(res.size);
+                    }
+                });
+            });
+        };
+        var animation = this.$requireWeexModule('animation');
+        this.animate = function (el, options) {
+            return new Promise(function (resolve) {
+                animation.transition(el.ref, options, resolve);
+            });
+        };
+    },
+    render: function (h) {
+        var tag = this.tag || this.$vnode.data.tag || 'span';
+        var map = Object.create(null);
+        var prevChildren = (this.prevChildren = this.children);
+        var rawChildren = this.$slots.default || [];
+        var children = (this.children = []);
+        var transitionData = extractTransitionData(this);
+        for (var i = 0; i < rawChildren.length; i++) {
+            var c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    var opts = c.componentOptions;
+                    var name_1 = opts ? opts.Ctor.options.name || opts.tag : c.tag;
+                    warn("<transition-group> children must be keyed: <" + name_1 + ">");
+                }
+            }
         }
-      });
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
-    }
-
-    return h(tag, null, children)
-  },
-
-  beforeUpdate: function beforeUpdate () {
-    // force removing pass
-    this.__patch__(
-      this._vnode,
-      this.kept,
-      false, // hydrating
-      true // removeOnly (!important, avoids unnecessary moves)
-    );
-    this._vnode = this.kept;
-  },
-
-  updated: function updated () {
-    var children = this.prevChildren;
-    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
-    var moveData = children.length && this.getMoveData(children[0].context, moveClass);
-    if (!moveData) {
-      return
-    }
-
-    // TODO: finish implementing move animations once
-    // we have access to sync getComponentRect()
-
-    // children.forEach(callPendingCbs)
-
-    // Promise.all(children.map(c => {
-    //   const oldPos = c.data.pos
-    //   const newPos = c.data.newPos
-    //   const dx = oldPos.left - newPos.left
-    //   const dy = oldPos.top - newPos.top
-    //   if (dx || dy) {
-    //     c.data.moved = true
-    //     return this.animate(c.elm, {
-    //       styles: {
-    //         transform: `translate(${dx}px,${dy}px)`
-    //       }
-    //     })
-    //   }
-    // })).then(() => {
-    //   children.forEach(c => {
-    //     if (c.data.moved) {
-    //       this.animate(c.elm, {
-    //         styles: {
-    //           transform: ''
-    //         },
-    //         duration: moveData.duration || 0,
-    //         delay: moveData.delay || 0,
-    //         timingFunction: moveData.timingFunction || 'linear'
-    //       })
-    //     }
-    //   })
-    // })
-  },
-
-  methods: {
-    getMoveData: function getMoveData (context, moveClass) {
-      var stylesheet = context.$options.style || {};
-      return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass]
-    }
-  }
+        if (prevChildren) {
+            var kept_1 = [];
+            var removed_1 = [];
+            prevChildren.forEach(function (c) {
+                c.data.transition = transitionData;
+                // TODO: record before patch positions
+                if (map[c.key]) {
+                    kept_1.push(c);
+                }
+                else {
+                    removed_1.push(c);
+                }
+            });
+            this.kept = h(tag, null, kept_1);
+            this.removed = removed_1;
+        }
+        return h(tag, null, children);
+    },
+    beforeUpdate: function () {
+        // force removing pass
+        this.__patch__(this._vnode, this.kept, false, // hydrating
+        true // removeOnly (!important, avoids unnecessary moves)
+        );
+        this._vnode = this.kept;
+    },
+    updated: function () {
+        var children = this.prevChildren;
+        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+        var moveData = children.length && this.getMoveData(children[0].context, moveClass);
+        if (!moveData) {
+            return;
+        }
+        // TODO: finish implementing move animations once
+        // we have access to sync getComponentRect()
+        // children.forEach(callPendingCbs)
+        // Promise.all(children.map(c => {
+        //   const oldPos = c.data.pos
+        //   const newPos = c.data.newPos
+        //   const dx = oldPos.left - newPos.left
+        //   const dy = oldPos.top - newPos.top
+        //   if (dx || dy) {
+        //     c.data.moved = true
+        //     return this.animate(c.elm, {
+        //       styles: {
+        //         transform: `translate(${dx}px,${dy}px)`
+        //       }
+        //     })
+        //   }
+        // })).then(() => {
+        //   children.forEach(c => {
+        //     if (c.data.moved) {
+        //       this.animate(c.elm, {
+        //         styles: {
+        //           transform: ''
+        //         },
+        //         duration: moveData.duration || 0,
+        //         delay: moveData.delay || 0,
+        //         timingFunction: moveData.timingFunction || 'linear'
+        //       })
+        //     }
+        //   })
+        // })
+    },
+    methods: {
+        getMoveData: function (context, moveClass) {
+            var stylesheet = context.$options.style || {};
+            return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass];
+        },
+    },
 };
-
 // function callPendingCbs (c) {
 //   /* istanbul ignore if */
 //   if (c.elm._moveCb) {
@@ -7749,85 +6804,53 @@ var TransitionGroup = {
 // }
 
 var platformComponents = {
-  Richtext: Richtext,
-  Transition: Transition,
-  TransitionGroup: TransitionGroup
+    Richtext: Richtext,
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
 };
 
-/*  */
-
-var isReservedTag$1 = makeMap(
-  'template,script,style,element,content,slot,link,meta,svg,view,' +
-  'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-  'slider,slider-neighbor,indicator,canvas,' +
-  'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-  'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
-  true
-);
-
+// These util functions are split into its own file because Rollup cannot drop
+var isReservedTag = makeMap('template,script,style,element,content,slot,link,meta,svg,view,' +
+    'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
+    'slider,slider-neighbor,indicator,canvas,' +
+    'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
+    'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown', true);
 // Elements that you can, intentionally, leave open (and which close themselves)
 // more flexible than web
-var canBeLeftOpenTag = makeMap(
-  'web,spinner,switch,video,textarea,canvas,' +
-  'indicator,marquee,countdown',
-  true
-);
-
-var isRuntimeComponent = makeMap(
-  'richtext,transition,transition-group',
-  true
-);
-
-var isUnaryTag = makeMap(
-  'embed,img,image,input,link,meta',
-  true
-);
-
-function mustUseProp () {
-  return false
+makeMap('web,spinner,switch,video,textarea,canvas,' + 'indicator,marquee,countdown', true);
+var isRuntimeComponent = makeMap('richtext,transition,transition-group', true);
+makeMap('embed,img,image,input,link,meta', true);
+function mustUseProp() {
+    return false;
 }
-
-function isUnknownElement$1 () {
-  return false
+function isUnknownElement() {
+    return false;
 }
-
-function query (el, document) {
-  // document is injected by weex factory wrapper
-  var placeholder = document.createComment('root');
-  placeholder.hasAttribute = placeholder.removeAttribute = noop; // hack for patch
-  document.documentElement.appendChild(placeholder);
-  return placeholder
+function query(el, document) {
+    // document is injected by weex factory wrapper
+    var placeholder = document.createComment('root');
+    placeholder.hasAttribute = placeholder.removeAttribute = noop; // hack for patch
+    document.documentElement.appendChild(placeholder);
+    return placeholder;
 }
 
-/*  */
-
+//@ts-nocheck
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag$1;
+Vue.config.isReservedTag = isReservedTag;
 Vue.config.isRuntimeComponent = isRuntimeComponent;
-Vue.config.isUnknownElement = isUnknownElement$1;
-
+Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives and components
 Vue.options.directives = platformDirectives;
 Vue.options.components = platformComponents;
-
 // install platform patch function
 Vue.prototype.__patch__ = patch;
-
 // wrap mount
-Vue.prototype.$mount = function (
-  el,
-  hydrating
-) {
-  return mountComponent(
-    this,
-    el && query(el, this.$document),
-    hydrating
-  )
+Vue.prototype.$mount = function (el, hydrating) {
+    return mountComponent(this, el && query(el, this.$document), hydrating);
 };
 
 // this entry is built and wrapped with a factory function
-
 exports.Vue = Vue;
 
 
diff --git a/packages/weex-vue-framework/index.js b/packages/weex-vue-framework/index.js
index 487c97be7ef..a3b3eefab22 100644
--- a/packages/weex-vue-framework/index.js
+++ b/packages/weex-vue-framework/index.js
@@ -2,156 +2,133 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/*  */
-
 // this will be preserved during build
 // $flow-disable-line
 var VueFactory = require('./factory');
-
 var instanceOptions = {};
-
 /**
  * Create instance context.
  */
-function createInstanceContext (
-  instanceId,
-  runtimeContext,
-  data
-) {
-  if ( data === void 0 ) data = {};
-
-  var weex = runtimeContext.weex;
-  var instance = instanceOptions[instanceId] = {
-    instanceId: instanceId,
-    config: weex.config,
-    document: weex.document,
-    data: data
-  };
-
-  // Each instance has a independent `Vue` module instance
-  var Vue = instance.Vue = createVueModuleInstance(instanceId, weex);
-
-  // DEPRECATED
-  var timerAPIs = getInstanceTimer(instanceId, weex.requireModule);
-
-  var instanceContext = Object.assign({ Vue: Vue }, timerAPIs);
-  Object.freeze(instanceContext);
-  return instanceContext
+function createInstanceContext(instanceId, runtimeContext, data) {
+    if (data === void 0) { data = {}; }
+    var weex = runtimeContext.weex;
+    var instance = (instanceOptions[instanceId] = {
+        instanceId: instanceId,
+        config: weex.config,
+        document: weex.document,
+        data: data,
+    });
+    // Each instance has a independent `Vue` module instance
+    var Vue = (instance.Vue = createVueModuleInstance(instanceId, weex));
+    // DEPRECATED
+    var timerAPIs = getInstanceTimer(instanceId, weex.requireModule);
+    var instanceContext = Object.assign({ Vue: Vue }, timerAPIs);
+    Object.freeze(instanceContext);
+    return instanceContext;
 }
-
 /**
  * Destroy an instance with id. It will make sure all memory of
  * this instance released and no more leaks.
  */
-function destroyInstance (instanceId) {
-  var instance = instanceOptions[instanceId];
-  if (instance && instance.app instanceof instance.Vue) {
-    try {
-      instance.app.$destroy();
-      instance.document.destroy();
-    } catch (e) {}
-    delete instance.document;
-    delete instance.app;
-  }
-  delete instanceOptions[instanceId];
+function destroyInstance(instanceId) {
+    var instance = instanceOptions[instanceId];
+    //@ts-expect-error
+    if (instance && instance.app instanceof instance.Vue) {
+        try {
+            instance.app.$destroy();
+            instance.document.destroy();
+        }
+        catch (e) { }
+        //@ts-expect-error
+        delete instance.document;
+        delete instance.app;
+    }
+    delete instanceOptions[instanceId];
 }
-
 /**
  * Refresh an instance with id and new top-level component data.
  * It will use `Vue.set` on all keys of the new data. So it's better
  * define all possible meaningful keys when instance created.
  */
-function refreshInstance (
-  instanceId,
-  data
-) {
-  var instance = instanceOptions[instanceId];
-  if (!instance || !(instance.app instanceof instance.Vue)) {
-    return new Error(("refreshInstance: instance " + instanceId + " not found!"))
-  }
-  if (instance.Vue && instance.Vue.set) {
-    for (var key in data) {
-      instance.Vue.set(instance.app, key, data[key]);
+function refreshInstance(instanceId, data) {
+    var instance = instanceOptions[instanceId];
+    //@ts-expect-error
+    if (!instance || !(instance.app instanceof instance.Vue)) {
+        return new Error("refreshInstance: instance " + instanceId + " not found!");
+    }
+    if (instance.Vue && instance.Vue.set) {
+        for (var key in data) {
+            instance.Vue.set(instance.app, key, data[key]);
+        }
     }
-  }
-  // Finally `refreshFinish` signal needed.
-  instance.document.taskCenter.send('dom', { action: 'refreshFinish' }, []);
+    // Finally `refreshFinish` signal needed.
+    instance.document.taskCenter.send('dom', { action: 'refreshFinish' }, []);
 }
-
 /**
  * Create a fresh instance of Vue for each Weex instance.
  */
-function createVueModuleInstance (
-  instanceId,
-  weex
-) {
-  var exports = {};
-  VueFactory(exports, weex.document);
-  var Vue = exports.Vue;
-
-  var instance = instanceOptions[instanceId];
-
-  // patch reserved tag detection to account for dynamically registered
-  // components
-  var weexRegex = /^weex:/i;
-  var isReservedTag = Vue.config.isReservedTag || (function () { return false; });
-  var isRuntimeComponent = Vue.config.isRuntimeComponent || (function () { return false; });
-  Vue.config.isReservedTag = function (name) {
-    return (!isRuntimeComponent(name) && weex.supports(("@component/" + name))) ||
-      isReservedTag(name) ||
-      weexRegex.test(name)
-  };
-  Vue.config.parsePlatformTagName = function (name) { return name.replace(weexRegex, ''); };
-
-  // expose weex-specific info
-  Vue.prototype.$instanceId = instanceId;
-  Vue.prototype.$document = instance.document;
-
-  // expose weex native module getter on subVue prototype so that
-  // vdom runtime modules can access native modules via vnode.context
-  Vue.prototype.$requireWeexModule = weex.requireModule;
-
-  // Hack `Vue` behavior to handle instance information and data
-  // before root component created.
-  Vue.mixin({
-    beforeCreate: function beforeCreate () {
-      var options = this.$options;
-      // root component (vm)
-      if (options.el) {
-        // set external data of instance
-        var dataOption = options.data;
-        var internalData = (typeof dataOption === 'function' ? dataOption() : dataOption) || {};
-        options.data = Object.assign(internalData, instance.data);
-        // record instance by id
-        instance.app = this;
-      }
-    },
-    mounted: function mounted () {
-      var options = this.$options;
-      // root component (vm)
-      if (options.el && weex.document && instance.app === this) {
-        try {
-          // Send "createFinish" signal to native.
-          weex.document.taskCenter.send('dom', { action: 'createFinish' }, []);
-        } catch (e) {}
-      }
-    }
-  });
-
-  /**
-   * @deprecated Just instance variable `weex.config`
-   * Get instance config.
-   * @return {object}
-   */
-  Vue.prototype.$getConfig = function () {
-    if (instance.app instanceof Vue) {
-      return instance.config
-    }
-  };
-
-  return Vue
+function createVueModuleInstance(instanceId, weex) {
+    var exports = {};
+    VueFactory(exports, weex.document);
+    //@ts-expect-error
+    var Vue = exports.Vue;
+    var instance = instanceOptions[instanceId];
+    // patch reserved tag detection to account for dynamically registered
+    // components
+    var weexRegex = /^weex:/i;
+    var isReservedTag = Vue.config.isReservedTag || (function () { return false; });
+    var isRuntimeComponent = Vue.config.isRuntimeComponent || (function () { return false; });
+    Vue.config.isReservedTag = function (name) {
+        return ((!isRuntimeComponent(name) && weex.supports("@component/" + name)) ||
+            isReservedTag(name) ||
+            weexRegex.test(name));
+    };
+    Vue.config.parsePlatformTagName = function (name) { return name.replace(weexRegex, ''); };
+    // expose weex-specific info
+    Vue.prototype.$instanceId = instanceId;
+    Vue.prototype.$document = instance.document;
+    // expose weex native module getter on subVue prototype so that
+    // vdom runtime modules can access native modules via vnode.context
+    Vue.prototype.$requireWeexModule = weex.requireModule;
+    // Hack `Vue` behavior to handle instance information and data
+    // before root component created.
+    Vue.mixin({
+        beforeCreate: function () {
+            var options = this.$options;
+            // root component (vm)
+            if (options.el) {
+                // set external data of instance
+                var dataOption = options.data;
+                var internalData = (typeof dataOption === 'function' ? dataOption() : dataOption) || {};
+                options.data = Object.assign(internalData, instance.data);
+                // record instance by id
+                instance.app = this;
+            }
+        },
+        mounted: function () {
+            var options = this.$options;
+            // root component (vm)
+            if (options.el && weex.document && instance.app === this) {
+                try {
+                    // Send "createFinish" signal to native.
+                    weex.document.taskCenter.send('dom', { action: 'createFinish' }, []);
+                }
+                catch (e) { }
+            }
+        },
+    });
+    /**
+     * @deprecated Just instance variable `weex.config`
+     * Get instance config.
+     * @return {object}
+     */
+    Vue.prototype.$getConfig = function () {
+        if (instance.app instanceof Vue) {
+            return instance.config;
+        }
+    };
+    return Vue;
 }
-
 /**
  * DEPRECATED
  * Generate HTML5 Timer APIs. An important point is that the callback
@@ -159,43 +136,46 @@ function createVueModuleInstance (
  * framework can make sure no side effect of the callback happened after
  * an instance destroyed.
  */
-function getInstanceTimer (
-  instanceId,
-  moduleGetter
-) {
-  var instance = instanceOptions[instanceId];
-  var timer = moduleGetter('timer');
-  var timerAPIs = {
-    setTimeout: function () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var handler = function () {
-        args[0].apply(args, args.slice(2));
-      };
-
-      timer.setTimeout(handler, args[1]);
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    setInterval: function () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var handler = function () {
-        args[0].apply(args, args.slice(2));
-      };
-
-      timer.setInterval(handler, args[1]);
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    clearTimeout: function (n) {
-      timer.clearTimeout(n);
-    },
-    clearInterval: function (n) {
-      timer.clearInterval(n);
-    }
-  };
-  return timerAPIs
+function getInstanceTimer(instanceId, moduleGetter) {
+    var instance = instanceOptions[instanceId];
+    var timer = moduleGetter('timer');
+    var timerAPIs = {
+        setTimeout: function () {
+            var arguments$1 = arguments;
+
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments$1[_i];
+            }
+            var handler = function () {
+                args[0].apply(args, args.slice(2));
+            };
+            timer.setTimeout(handler, args[1]);
+            //@ts-expect-error
+            return instance.document.taskCenter.callbackManager.lastCallbackId.toString();
+        },
+        setInterval: function () {
+            var arguments$1 = arguments;
+
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments$1[_i];
+            }
+            var handler = function () {
+                args[0].apply(args, args.slice(2));
+            };
+            timer.setInterval(handler, args[1]);
+            //@ts-expect-error
+            return instance.document.taskCenter.callbackManager.lastCallbackId.toString();
+        },
+        clearTimeout: function (n) {
+            timer.clearTimeout(n);
+        },
+        clearInterval: function (n) {
+            timer.clearInterval(n);
+        },
+    };
+    return timerAPIs;
 }
 
 exports.createInstanceContext = createInstanceContext;
diff --git a/src/platforms/weex/util/parser.ts b/src/platforms/weex/util/parser.ts
index 8414f138056..d8b6ba86dad 100644
--- a/src/platforms/weex/util/parser.ts
+++ b/src/platforms/weex/util/parser.ts
@@ -1,62 +1,60 @@
-
 // import { warn } from 'core/util/index'
 
-// this will be preserved during build
-// $flow-disable-line
-const acorn = require('acorn') // $flow-disable-line
-const walk = require('acorn/dist/walk') // $flow-disable-line
-const escodegen = require('escodegen')
+import acorn from 'acorn'
+import walk from "acorn-walk";
+const escodegen = require("escodegen");
+
 
 export function nodeToBinding(node: any): any {
   switch (node.type) {
-    case 'Literal':
-      return node.value
-    case 'Identifier':
-    case 'UnaryExpression':
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-    case 'ConditionalExpression':
-    case 'MemberExpression':
-      return { '@binding': escodegen.generate(node) }
-    case 'ArrayExpression':
-      return node.elements.map((_) => nodeToBinding(_))
-    case 'ObjectExpression': {
-      const object = {}
+    case "Literal":
+      return node.value;
+    case "Identifier":
+    case "UnaryExpression":
+    case "BinaryExpression":
+    case "LogicalExpression":
+    case "ConditionalExpression":
+    case "MemberExpression":
+      return { "@binding": escodegen.generate(node) };
+    case "ArrayExpression":
+      return node.elements.map((_) => nodeToBinding(_));
+    case "ObjectExpression": {
+      const object = {};
       node.properties.forEach((prop) => {
-        if (!prop.key || prop.key.type !== 'Identifier') {
-          return
+        if (!prop.key || prop.key.type !== "Identifier") {
+          return;
         }
-        const key = escodegen.generate(prop.key)
-        const value = nodeToBinding(prop.value)
+        const key = escodegen.generate(prop.key);
+        const value = nodeToBinding(prop.value);
         if (key && value) {
-          object[key] = value
+          object[key] = value;
         }
-      })
-      return object
+      });
+      return object;
     }
     default: {
       // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
-      return ''
+      return "";
     }
   }
 }
 
 export function generateBinding(exp?: string): any {
-  if (exp && typeof exp === 'string') {
-    let ast = null
+  if (exp && typeof exp === "string") {
+    let ast: acorn.Node| null = null;
     try {
-      ast = acorn.parse(`(${exp})`)
+      ast = acorn.parse(`(${exp})`, {ecmaVersion: 5});
     } catch (e) {
       // warn(`Failed to parse the expression: "${exp}"`)
-      return ''
+      return "";
     }
 
-    let output = ''
+    let output = "";
     walk.simple(ast, {
       Expression(node) {
-        output = nodeToBinding(node)
+        output = nodeToBinding(node);
       },
-    })
-    return output
+    });
+    return output;
   }
 }
diff --git a/test/weex/compiler/parser.spec.js b/test/weex/compiler/parser.spec.ts
similarity index 100%
rename from test/weex/compiler/parser.spec.js
rename to test/weex/compiler/parser.spec.ts
diff --git a/yarn.lock b/yarn.lock
index a334facb75f..6d2dab2d75e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -209,12 +209,7 @@
   dependencies:
     "@babel/types" "^7.12.13"
 
-"@babel/helper-plugin-utils@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.0.0.tgz#bbb3fbee98661c569034237cc03967ba99b4f250"
-  integrity sha512-CYAOUCARwExnEixLdB6sDm2dIJ/YgEAKDM1MOeMeZu9Ld/bDgVo8aiWrXwcY7OBh+1Ea2uUcVRcxKk0GJvW7QA==
-
-"@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
+"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
   version "7.13.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz#806526ce125aed03373bc416a828321e3a6a33af"
   integrity sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==
@@ -1428,7 +1423,12 @@ acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
   integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==
 
-acorn@^5.0.0, acorn@^5.2.1, acorn@^5.6.2:
+acorn-walk@^8.0.2:
+  version "8.0.2"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.0.2.tgz#d4632bfc63fd93d0f15fd05ea0e984ffd3f5a8c3"
+  integrity sha512-+bpA9MJsHdZ4bgfDcpk0ozQyhhVct7rzOmO0s1IIr0AGGgKBljss8n2zp11rRP2wid5VGeh04CgeKzgat5/25A==
+
+acorn@^5.0.0, acorn@^5.6.2:
   version "5.7.3"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.3.tgz#67aa231bf8812974b85235a96771eb6bd07ea279"
   integrity sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==
@@ -1443,6 +1443,11 @@ acorn@^7.4.0:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
   integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
 
+acorn@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.1.0.tgz#52311fd7037ae119cbb134309e901aa46295b3fe"
+  integrity sha512-LWCF/Wn0nfHOmJ9rzQApGnxnvgfROzGilS8936rqN/lfcYkY9MYZzdMqN+2NJ4SlTc+m5HiSa+kNfDtI64dwUA==
+
 adm-zip@~0.4.3:
   version "0.4.13"
   resolved "https://registry.yarnpkg.com/adm-zip/-/adm-zip-0.4.13.tgz#597e2f8cc3672151e1307d3e95cddbc75672314a"
@@ -1593,6 +1598,11 @@ are-we-there-yet@~1.1.2:
     delegates "^1.0.0"
     readable-stream "^2.0.6"
 
+arg@^4.1.0:
+  version "4.1.3"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
+  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
+
 argparse@^1.0.7:
   version "1.0.10"
   resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
@@ -2523,6 +2533,15 @@ cli-width@^2.0.0:
   resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.0.tgz#ff19ede8a9a5e579324147b0c11f0fbcbabed639"
   integrity sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=
 
+cliui@^7.0.2:
+  version "7.0.4"
+  resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
+  integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
+  dependencies:
+    string-width "^4.2.0"
+    strip-ansi "^6.0.0"
+    wrap-ansi "^7.0.0"
+
 co@~3.0.6:
   version "3.0.6"
   resolved "https://registry.yarnpkg.com/co/-/co-3.0.6.tgz#1445f226c5eb956138e68c9ac30167ea7d2e6bda"
@@ -2964,6 +2983,11 @@ create-hmac@^1.1.0, create-hmac@^1.1.2, create-hmac@^1.1.4:
     safe-buffer "^5.0.1"
     sha.js "^2.4.8"
 
+create-require@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
+  integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
+
 cross-spawn@^5.0.1:
   version "5.1.0"
   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-5.1.0.tgz#e8bd0efee58fcff6f8f94510a0a554bbfa235449"
@@ -3147,14 +3171,14 @@ debug@^3.1.1:
   dependencies:
     ms "^2.1.1"
 
-debug@^4.0.1, debug@^4.1.0:
+debug@^4.0.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
   integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==
   dependencies:
     ms "^2.1.1"
 
-debug@^4.1.1:
+debug@^4.1.0, debug@^4.1.1:
   version "4.3.1"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
   integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
@@ -3320,6 +3344,11 @@ diff@1.4.0:
   resolved "https://registry.yarnpkg.com/diff/-/diff-1.4.0.tgz#7f28d2eb9ee7b15a97efd89ce63dcfdaa3ccbabf"
   integrity sha1-fyjS657nsVqX79ic5j3P2qPMur8=
 
+diff@^4.0.1:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
+  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
+
 diffie-hellman@^5.0.0:
   version "5.0.3"
   resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
@@ -3404,9 +3433,9 @@ ejs@2.5.7:
   integrity sha1-zIcsFoiArjxxiXYv1f/ACJbJUYo=
 
 electron-to-chromium@^1.3.649:
-  version "1.3.708"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.708.tgz#127970d2fc665ab356be59e668f2914856419176"
-  integrity sha512-+A8ggYZ5riOLMcVAuzHx6bforaPzaiLnW1QOMD2SlMYQVi7QQTyQ/WrlZoebIH9ikmgr+tLJGpNITFFCUiQcPw==
+  version "1.3.709"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.709.tgz#d7be0b5686a2fdfe8bad898faa3a428d04d8f656"
+  integrity sha512-LolItk2/ikSGQ7SN8UkuKVNMBZp3RG7Itgaxj1npsHRzQobj9JjMneZOZfLhtwlYBe5fCJ75k+cVCiDFUs23oA==
 
 elegant-spinner@^1.0.1:
   version "1.0.1"
@@ -3793,9 +3822,9 @@ estree-walker@^2.0.1:
   integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
 
 esutils@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b"
-  integrity sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
+  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
 eventemitter3@^4.0.0:
   version "4.0.7"
@@ -4377,6 +4406,11 @@ gensync@^1.0.0-beta.2:
   resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
   integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
 
+get-caller-file@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
+  integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
+
 get-intrinsic@^1.0.2:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
@@ -4585,9 +4619,9 @@ global-prefix@^0.1.4:
     which "^1.2.12"
 
 globals@^11.1.0:
-  version "11.9.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-11.9.0.tgz#bde236808e987f290768a93d065060d78e6ab249"
-  integrity sha512-5cJVtyXWH8PiJPVLZzzoIizXx944O4OmRro5MWKx5fT4MgcN7OfaMutPeaTdJCCURwbWdhhcCWcKIffPnmTzBg==
+  version "11.12.0"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
+  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
 
 globals@^12.1.0:
   version "12.4.0"
@@ -5529,6 +5563,13 @@ jasmine-core@^2.99.0, jasmine-core@~2.99.0:
   resolved "https://registry.yarnpkg.com/jasmine-core/-/jasmine-core-2.99.1.tgz#e6400df1e6b56e130b61c4bcd093daa7f6e8ca15"
   integrity sha1-5kAN8ea1bhMLYcS80JPap/boyhU=
 
+jasmine-ts@^0.3.2:
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/jasmine-ts/-/jasmine-ts-0.3.2.tgz#831cad901a070f7fe919c91e2c87b61f9ee7cb95"
+  integrity sha512-ze8IxVX2E6j4ux4W0m8tBwbVds6XYWA0CMER50dV0lp83dF2UoONdbzE+aJLeu5n7Bi2IKTzcGHWGt7n/Yo6sw==
+  dependencies:
+    yargs "^16.2.0"
+
 jasmine@^2.99.0:
   version "2.99.0"
   resolved "https://registry.yarnpkg.com/jasmine/-/jasmine-2.99.0.tgz#8ca72d102e639b867c6489856e0e18a9c7aa42b7"
@@ -6326,6 +6367,11 @@ make-dir@^3.0.2:
   dependencies:
     semver "^6.0.0"
 
+make-error@^1.1.1:
+  version "1.3.6"
+  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
+  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
+
 map-cache@^0.2.2:
   version "0.2.2"
   resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
@@ -6672,9 +6718,9 @@ ms@2.1.2:
   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
 
 ms@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.1.tgz#30a5864eb3ebb0a66f2ebe6d727af06a09d86e0a"
-  integrity sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==
+  version "2.1.3"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
+  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
 mute-stream@0.0.6:
   version "0.0.6"
@@ -6943,12 +6989,7 @@ object-copy@^0.1.0:
     define-property "^0.2.5"
     kind-of "^3.0.3"
 
-object-keys@^1.0.12:
-  version "1.0.12"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.0.12.tgz#09c53855377575310cca62f55bb334abff7b3ed2"
-  integrity sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==
-
-object-keys@^1.1.1:
+object-keys@^1.0.12, object-keys@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
@@ -7856,9 +7897,9 @@ regenerate-unicode-properties@^8.0.2, regenerate-unicode-properties@^8.2.0:
     regenerate "^1.4.0"
 
 regenerate@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.0.tgz#4a856ec4b56e4077c557589cae85e7a4c8869a11"
-  integrity sha512-1G6jJVDWrt0rK99kBjvEtziZNCICAuvIPkSiUFIQxVP06RCVpq3dmDo2oi6ABpYaDYaTRr67BEhL8r1wgEZZKg==
+  version "1.4.2"
+  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
+  integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
 regenerator-runtime@^0.10.0:
   version "0.10.5"
@@ -8022,6 +8063,11 @@ request@^2.81.0, request@^2.87.0, request@^2.88.0:
     tunnel-agent "^0.6.0"
     uuid "^3.3.2"
 
+require-directory@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
+  integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
+
 require-from-string@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
@@ -8540,7 +8586,7 @@ source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
     source-map-url "^0.4.0"
     urix "^0.1.0"
 
-source-map-support@^0.5.16:
+source-map-support@^0.5.16, source-map-support@^0.5.17:
   version "0.5.19"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
   integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
@@ -8757,7 +8803,7 @@ string-width@^1.0.1:
     is-fullwidth-code-point "^2.0.0"
     strip-ansi "^4.0.0"
 
-string-width@^4.2.0:
+string-width@^4.1.0, string-width@^4.2.0:
   version "4.2.2"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5"
   integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==
@@ -9118,6 +9164,18 @@ ts-loader@^8.1.0:
     micromatch "^4.0.0"
     semver "^7.3.4"
 
+ts-node@^9.1.1:
+  version "9.1.1"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-9.1.1.tgz#51a9a450a3e959401bda5f004a72d54b936d376d"
+  integrity sha512-hPlt7ZACERQGf03M253ytLY3dHbGNGrAq9qIHWUY9XHYl1z7wYngSr3OQ5xmui8o2AaxsONxIzjafLUiWBo1Fg==
+  dependencies:
+    arg "^4.1.0"
+    create-require "^1.1.0"
+    diff "^4.0.1"
+    make-error "^1.1.1"
+    source-map-support "^0.5.17"
+    yn "3.1.1"
+
 tslib@2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
@@ -9243,9 +9301,9 @@ unicode-match-property-value-ecmascript@^1.1.0, unicode-match-property-value-ecm
   integrity sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==
 
 unicode-property-aliases-ecmascript@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.0.4.tgz#5a533f31b4317ea76f17d807fa0d116546111dd0"
-  integrity sha512-2WSLa6OdYd2ng8oqiGIWnJqyFArvhn+5vgx5GTxMbUYjCYKUcuKS62YLFF0R/BDGlB1yzXjQOLtPAfHsgirEpg==
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz#dd57a99f6207bedff4628abefb94c50db941c8f4"
+  integrity sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==
 
 union-value@^1.0.0:
   version "1.0.0"
@@ -9548,6 +9606,15 @@ wrap-ansi@^3.0.1:
     string-width "^2.1.1"
     strip-ansi "^4.0.0"
 
+wrap-ansi@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
+  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
 wrappy@1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
@@ -9602,6 +9669,11 @@ y18n@^4.0.0:
   resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.1.tgz#8db2b83c31c5d75099bb890b23f3094891e247d4"
   integrity sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==
 
+y18n@^5.0.5:
+  version "5.0.7"
+  resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.7.tgz#0c514aba53fc40e2db911aeb8b51566a3374efe7"
+  integrity sha512-oOhslryvNcA1lB9WYr+M6TMyLkLg81Dgmyb48ZDU0lvR+5bmNDTMz7iobM1QXooaLhbbrcHrlNaABhI6Vo6StQ==
+
 yallist@^2.1.2:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52"
@@ -9617,6 +9689,24 @@ yallist@^4.0.0:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
+yargs-parser@^20.2.2:
+  version "20.2.7"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.7.tgz#61df85c113edfb5a7a4e36eb8aa60ef423cbc90a"
+  integrity sha512-FiNkvbeHzB/syOjIUxFDCnhSfzAL8R5vs40MgLFBorXACCOAEaWu0gRZl14vG8MR9AOJIZbmkjhusqBYZ3HTHw==
+
+yargs@^16.2.0:
+  version "16.2.0"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
+  integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
+  dependencies:
+    cliui "^7.0.2"
+    escalade "^3.1.1"
+    get-caller-file "^2.0.5"
+    require-directory "^2.1.1"
+    string-width "^4.2.0"
+    y18n "^5.0.5"
+    yargs-parser "^20.2.2"
+
 yauzl@2.4.1:
   version "2.4.1"
   resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.4.1.tgz#9528f442dab1b2284e58b4379bb194e22e0c4005"
@@ -9629,6 +9719,11 @@ yeast@0.1.2:
   resolved "https://registry.yarnpkg.com/yeast/-/yeast-0.1.2.tgz#008e06d8094320c372dbc2f8ed76a0ca6c8ac419"
   integrity sha1-AI4G2AlDIMNy28L47XagymyKxBk=
 
+yn@3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
+
 yorkie@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/yorkie/-/yorkie-2.0.0.tgz#92411912d435214e12c51c2ae1093e54b6bb83d9"

From 00ef43b445f093de647973837e07c967e1e4fe9e Mon Sep 17 00:00:00 2001
From: Carlos Rodrigues <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 17:28:47 +0100
Subject: [PATCH 016/317] Update typescript/modules.d.ts

Co-authored-by: Kael <kaelwd@gmail.com>
---
 typescript/modules.d.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/typescript/modules.d.ts b/typescript/modules.d.ts
index deb38b7a8f1..22a090e1c6f 100644
--- a/typescript/modules.d.ts
+++ b/typescript/modules.d.ts
@@ -29,9 +29,7 @@ declare module 'lru-cache' {
 }
 
 declare module 'de-indent' {
-  var exports: {
-    (input: string): string
-  }
+  export default function deindent (input: string): string
 }
 
 declare module 'serialize-javascript' {

From 52d3a7c773454b3fdfb62629f9952766b52efa76 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 17:25:57 +0100
Subject: [PATCH 017/317] update terser and buble

---
 .babelrc.js                                   |   11 -
 dist/vue.common.dev.js                        | 1879 ++++----
 dist/vue.common.prod.js                       |    7 +-
 dist/vue.esm.browser.js                       | 4071 ++++++++---------
 dist/vue.esm.browser.min.js                   |    7 +-
 dist/vue.esm.js                               | 1883 ++++----
 dist/vue.js                                   | 1879 ++++----
 dist/vue.min.js                               |    7 +-
 dist/vue.runtime.common.dev.js                | 1310 +++---
 dist/vue.runtime.common.prod.js               |    7 +-
 dist/vue.runtime.esm.js                       | 1314 +++---
 dist/vue.runtime.js                           | 1310 +++---
 dist/vue.runtime.min.js                       |    7 +-
 package.json                                  |    5 +-
 packages/vue-server-renderer/basic.js         | 1332 +++---
 packages/vue-server-renderer/build.dev.js     | 2004 ++++----
 packages/vue-server-renderer/build.prod.js    |    2 +-
 packages/vue-server-renderer/client-plugin.js |  123 +-
 packages/vue-server-renderer/server-plugin.js |  111 +-
 packages/vue-template-compiler/browser.js     |  908 ++--
 packages/vue-template-compiler/build.js       |  920 ++--
 scripts/build.js                              |   15 +-
 scripts/config.js                             |   11 -
 tsconfig.json                                 |    4 +-
 yarn.lock                                     |   84 +-
 25 files changed, 9693 insertions(+), 9518 deletions(-)

diff --git a/.babelrc.js b/.babelrc.js
index ea2ea97a712..4d2b9e504cc 100644
--- a/.babelrc.js
+++ b/.babelrc.js
@@ -1,18 +1,7 @@
-// const babelPresetFlowVue = {
-//   plugins: [
-//     require("@babel/plugin-proposal-class-properties"),
-//     // require('@babel/plugin-syntax-flow'), // not needed, included in transform-flow-strip-types
-//     require("@babel/plugin-transform-flow-strip-types"),
-//   ],
-// };
 
 module.exports = {
   presets: [
-    // require("@babel/preset-env"),
     "@babel/preset-env",
-
-    // require('babel-preset-flow-vue')
-    // babelPresetFlowVue,
   ],
   plugins: [
     require("babel-plugin-transform-vue-jsx"),
diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index 9ed78bbde65..766f3a8b429 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -430,7 +430,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -473,7 +473,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get: function get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -519,19 +519,20 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
+    _Set = /*@__PURE__*/(function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function (key) {
+        Set.prototype.has = function has (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function (key) {
+        Set.prototype.add = function add (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function () {
+        Set.prototype.clear = function clear () {
             this.set = Object.create(null);
         };
+
         return Set;
     }());
 }
@@ -541,22 +542,20 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
     warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
+        if (hasConsole && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -579,10 +578,10 @@ var formatComponentName;
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
     };
-    var repeat_1 = function (str, n) {
+    var repeat$1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -616,15 +615,13 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
         }
     };
 }
@@ -634,37 +631,34 @@ var uid$2 = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid$2++;
-        this.subs = [];
+var Dep = function Dep() {
+    this.id = uid$2++;
+    this.subs = [];
+};
+Dep.prototype.addSub = function addSub (sub) {
+    this.subs.push(sub);
+};
+Dep.prototype.removeSub = function removeSub (sub) {
+    remove$2(this.subs, sub);
+};
+Dep.prototype.depend = function depend () {
+    if (Dep.target) {
+        Dep.target.addDep(this);
     }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove$2(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort(function (a, b) { return a.id - b.id; });
-        }
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
+};
+Dep.prototype.notify = function notify () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (!config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
+};
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -679,45 +673,43 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
+};
+
+var prototypeAccessors = { child: { configurable: true } };
+// DEPRECATED: alias for componentInstance for backwards compat.
+/* istanbul ignore next */
+prototypeAccessors.child.get = function () {
+    return this.componentInstance;
+};
+
+Object.defineProperties( VNode.prototype, prototypeAccessors );
 var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
+    if ( text === void 0 ) text = '';
+
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -771,12 +763,9 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -812,46 +801,43 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
         }
         else {
-            this.walk(value);
+            copyAugment(value, arrayMethods, arrayKeys);
         }
+        this.observeArray(value);
     }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
+    else {
+        this.walk(value);
+    }
+};
+/**
+ * Walk through all properties and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ */
+Observer.prototype.walk = function walk (obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i]);
+    }
+};
+/**
+ * Observe a list of Array items.
+ */
+Observer.prototype.observeArray = function observeArray (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
+};
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -961,7 +947,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
  */
 function set(target, key, val) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -992,7 +978,7 @@ function set(target, key, val) {
  */
 function del(target, key) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+        warn$2(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -1019,7 +1005,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1194,14 +1180,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1239,7 +1225,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
         warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1283,7 +1269,7 @@ function normalizeProps(options, vm) {
     }
     else {
         warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
+            "but got " + (toRawType(props)) + ".", vm);
     }
     options.props = res;
 }
@@ -1310,7 +1296,7 @@ function normalizeInject(options, vm) {
     }
     else {
         warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
+            "but got " + (toRawType(inject)) + ".", vm);
     }
 }
 /**
@@ -1330,7 +1316,7 @@ function normalizeDirectives$1(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+            "but got " + (toRawType(value)) + ".", vm);
     }
 }
 /**
@@ -1566,7 +1552,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1574,24 +1560,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
+        message += " with value " + (styleValue(value, expectedType));
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
+        message += "with value " + (styleValue(value, receivedType)) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return "\"" + value + "\"";
+        return ("\"" + value + "\"");
     }
     else if (type === 'Number') {
-        return "" + Number(value);
+        return ("" + (Number(value)));
     }
     else {
-        return "" + value;
+        return ("" + value);
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1599,12 +1585,9 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var arguments$1 = arguments;
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments$1[_i];
-    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1670,7 +1653,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
+        warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1713,9 +1696,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p_1 = Promise.resolve();
+    var p = Promise.resolve();
     timerFunc = function () {
-        p_1.then(flushCallbacks);
+        p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1734,15 +1717,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
+    var counter = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
     timerFunc = function () {
-        counter_1 = (counter_1 + 1) % 2;
-        textNode_1.data = String(counter_1);
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
     };
     isUsingMicroTask = true;
 }
@@ -1790,18 +1773,18 @@ function nextTick(cb, ctx) {
 var mark;
 var measure;
 {
-    var perf_1 = inBrowser && window.performance;
+    var perf = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) {
-        mark = function (tag) { return perf_1.mark(tag); };
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf_1.measure(name, startTag, endTag);
-            perf_1.clearMarks(startTag);
-            perf_1.clearMarks(endTag);
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1810,31 +1793,31 @@ var measure;
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 {
-    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent_1 = function (target, key) {
+    var warnNonPresent = function (target, key) {
         warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix_1 = function (target, key) {
+    var warnReservedPrefix = function (target, key) {
         warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                     return false;
                 }
                 else {
@@ -1844,38 +1827,38 @@ var initProxy;
             },
         });
     }
-    var hasHandler_1 = {
-        has: function (target, key) {
+    var hasHandler = {
+        has: function has(target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals_1(key) ||
+            var isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler_1 = {
-        get: function (target, key) {
+    var getHandler = {
+        get: function get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy_1) {
+        if (hasProxy) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1962,7 +1945,7 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+            warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -2027,7 +2010,8 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs, props = data.props;
+    var attrs = data.attrs;
+    var props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2037,11 +2021,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2115,7 +2099,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2176,7 +2160,7 @@ function initInjections(vm) {
                 defineReactive(vm, key, result[key], function () {
                     warn$2("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        ("injection being mutated: \"" + key + "\""), vm);
+                        "injection being mutated: \"" + key + "\"", vm);
                 });
             }
         });
@@ -2213,7 +2197,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn$2("Injection \"" + key + "\" not found", vm);
+                    warn$2(("Injection \"" + key + "\" not found"), vm);
                 }
             }
         }
@@ -2241,8 +2225,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2255,9 +2239,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
         }
     }
     return slots;
@@ -2290,16 +2274,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2456,8 +2440,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash = void 0;
-            var _loop_1 = function (key) {
+            var hash;
+            var loop = function ( key ) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2474,15 +2458,14 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
+                        on[("update:" + key)] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-            for (var key in value) {
-                _loop_1(key);
-            }
+
+            for (var key in value) loop( key );
         }
     }
     return data;
@@ -2502,7 +2485,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic$1(tree, "__static__" + index, false);
+    markStatic$1(tree, ("__static__" + index), false);
     return tree;
 }
 /**
@@ -2510,14 +2493,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    markStatic$1(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
     return tree;
 }
 function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
             }
         }
     }
@@ -2583,7 +2566,7 @@ function bindDynamicKeys(baseObj, values) {
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+            warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
         }
     }
     return baseObj;
@@ -2616,7 +2599,8 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
+    var this$1 = this;
+
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2643,14 +2627,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
         }
-        return _this.$slots;
+        return this$1.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function () {
+        get: function get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2673,9 +2657,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) {
-            return createElement$1(contextVm, a, b, c, d, needNormalization);
-        };
+        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2731,7 +2713,7 @@ function mergeProps(to, from) {
 
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
+    init: function init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2744,7 +2726,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function (oldVnode, vnode) {
+    prepatch: function prepatch(oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2753,8 +2735,9 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2773,7 +2756,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2799,7 +2782,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn$2("Invalid Component definition: " + String(Ctor), context);
+            warn$2(("Invalid Component definition: " + (String(Ctor))), context);
         }
         return;
     }
@@ -2857,7 +2840,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2939,7 +2922,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2974,14 +2957,14 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor = void 0;
+        var Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                warn$2(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3084,7 +3067,9 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3167,24 +3152,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners_1 = (factory.owners = [owner]);
-        var sync_1 = true;
-        var timerLoading_1 = null;
-        var timerTimeout_1 = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-        var forceRender_1 = function (renderCompleted) {
-            for (var i = 0, l = owners_1.length; i < l; i++) {
-                owners_1[i].$forceUpdate();
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners_1.length = 0;
-                if (timerLoading_1 !== null) {
-                    clearTimeout(timerLoading_1);
-                    timerLoading_1 = null;
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
                 }
-                if (timerTimeout_1 !== null) {
-                    clearTimeout(timerTimeout_1);
-                    timerTimeout_1 = null;
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
                 }
             }
         };
@@ -3193,63 +3178,63 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync_1) {
-                forceRender_1(true);
+            if (!sync) {
+                forceRender(true);
             }
             else {
-                owners_1.length = 0;
+                owners.length = 0;
             }
         });
-        var reject_1 = once(function (reason) {
-            warn$2("Failed to resolve async component: " + String(factory) +
-                    (reason ? "\nReason: " + reason : ''));
+        var reject = once(function (reason) {
+            warn$2("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender_1(true);
+                forceRender(true);
             }
         });
-        var res_1 = factory(resolve, reject_1);
-        if (isObject(res_1)) {
-            if (isPromise(res_1)) {
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res_1.then(resolve, reject_1);
+                    res.then(resolve, reject);
                 }
             }
-            else if (isPromise(res_1.component)) {
-                res_1.component.then(resolve, reject_1);
-                if (isDef(res_1.error)) {
-                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
                 }
-                if (isDef(res_1.loading)) {
-                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                    if (res_1.delay === 0) {
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading_1 = setTimeout(function () {
-                            timerLoading_1 = null;
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender_1(false);
+                                forceRender(false);
                             }
-                        }, res_1.delay || 200);
+                        }, res.delay || 200);
                     }
                 }
-                if (isDef(res_1.timeout)) {
+                if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout_1 = setTimeout(function () {
-                        timerTimeout_1 = null;
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject_1("timeout (" + res_1.timeout + "ms)"
+                            reject(("timeout (" + (res.timeout) + "ms)")
                                 );
                         }
-                    }, res_1.timeout);
+                    }, res.timeout);
                 }
             }
         }
-        sync_1 = false;
+        sync = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3339,8 +3324,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                vm.$off(event[i_1], fn);
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
             }
             return vm;
         }
@@ -3371,10 +3356,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
             }
         }
         var cbs = vm._events[event];
@@ -3535,11 +3520,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure("vue " + name + " render", startTag, endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure("vue " + name + " patch", startTag, endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
         };
     }
     else {
@@ -3551,7 +3536,7 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function () {
+        before: function before() {
             if (vm._isMounted && !vm._isDestroyed) {
                 callHook$1(vm, 'beforeUpdate');
             }
@@ -3720,15 +3705,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance_1.now(); };
+        getNow = function () { return performance.now(); };
     }
 }
 /**
@@ -3763,7 +3748,7 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? "in watcher with expression \"" + watcher.expression + "\""
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3847,194 +3832,191 @@ var uid$1 = 0;
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = /** @class */ (function () {
-    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$1; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        expOrFn.toString() ;
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
         }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression =
-            expOrFn.toString() ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
+    }
+    this.value = this.lazy ? undefined : this.get();
+};
+/**
+ * Evaluate the getter, and re-collect dependencies.
+ */
+Watcher.prototype.get = function get () {
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
+    }
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
         }
         else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn$2("Failed watching path: \"" + expOrFn + "\" " +
-                        'Watcher only accepts simple dot-delimited paths. ' +
-                        'For full control, use a function instead.', vm);
-            }
+            throw e;
         }
-        this.value = this.lazy ? undefined : this.get();
     }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    Watcher.prototype.get = function () {
-        pushTarget(this);
-        var value;
-        var vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
         }
-        catch (e) {
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
+};
+/**
+ * Add a dependency to this directive.
+ */
+Watcher.prototype.addDep = function addDep (dep) {
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
+};
+/**
+ * Clean up for dependency collection.
+ */
+Watcher.prototype.cleanupDeps = function cleanupDeps () {
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
+};
+/**
+ * Subscriber interface.
+ * Will be called when a dependency changes.
+ */
+Watcher.prototype.update = function update () {
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
+};
+/**
+ * Scheduler job interface.
+ * Will be called by the scheduler.
+ */
+Watcher.prototype.run = function run () {
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
             if (this.user) {
-                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
             }
             else {
-                throw e;
+                this.cb.call(this.vm, value, oldValue);
             }
         }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    };
-    /**
-     * Add a dependency to this directive.
-     */
-    Watcher.prototype.addDep = function (dep) {
-        var id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    };
-    /**
-     * Clean up for dependency collection.
-     */
-    Watcher.prototype.cleanupDeps = function () {
-        var i = this.deps.length;
-        while (i--) {
-            var dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        var tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    };
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    Watcher.prototype.update = function () {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    };
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    Watcher.prototype.run = function () {
-        if (this.active) {
-            var value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                var oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    try {
-                        this.cb.call(this.vm, value, oldValue);
-                    }
-                    catch (e) {
-                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                    }
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
+    }
+};
+/**
+ * Evaluate the value of the watcher.
+ * This only gets called for lazy watchers.
+ */
+Watcher.prototype.evaluate = function evaluate () {
+    this.value = this.get();
+    this.dirty = false;
+};
+/**
+ * Depend on all deps collected by this watcher.
+ */
+Watcher.prototype.depend = function depend () {
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
+};
+/**
+ * Remove self from all dependencies' subscriber list.
+ */
+Watcher.prototype.teardown = function teardown () {
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove$2(this.vm._watchers, this);
         }
-    };
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    Watcher.prototype.evaluate = function () {
-        this.value = this.get();
-        this.dirty = false;
-    };
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    Watcher.prototype.depend = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].depend();
+            this.deps[i].removeSub(this);
         }
-    };
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    Watcher.prototype.teardown = function () {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            var i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    };
-    return Watcher;
-}());
+        this.active = false;
+    }
+};
 
 var sharedPropertyDefinition = {
     enumerable: true,
@@ -4081,7 +4063,7 @@ function initProps$1(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var _loop_1 = function (key) {
+    var loop = function ( key ) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4089,14 +4071,14 @@ function initProps$1(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                warn$2(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
             }
             defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
                     warn$2("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        ("value. Prop being mutated: \"" + key + "\""), vm);
+                        "value. Prop being mutated: \"" + key + "\"", vm);
                 }
             });
         }
@@ -4107,9 +4089,8 @@ function initProps$1(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-    for (var key in propsOptions) {
-        _loop_1(key);
-    }
+
+    for (var key in propsOptions) loop( key );
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4129,7 +4110,7 @@ function initData(vm) {
         var key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
+                warn$2(("Method \"" + key + "\" has already been defined as a data property."), vm);
             }
         }
         if (props && hasOwn(props, key)) {
@@ -4167,7 +4148,7 @@ function initComputed$1(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (getter == null) {
-            warn$2("Getter is missing for computed property \"" + key + "\".", vm);
+            warn$2(("Getter is missing for computed property \"" + key + "\"."), vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4181,10 +4162,10 @@ function initComputed$1(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
+                warn$2(("The computed property \"" + key + "\" is already defined in data."), vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                warn$2(("The computed property \"" + key + "\" is already defined as a prop."), vm);
             }
         }
     }
@@ -4207,7 +4188,7 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+            warn$2(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4236,11 +4217,11 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         {
             if (typeof methods[key] !== 'function') {
-                warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                warn$2("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
+                warn$2(("Method \"" + key + "\" has already been defined as a prop."), vm);
             }
             if (key in vm && isReserved(key)) {
                 warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4312,7 +4293,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
             }
             popTarget();
         }
@@ -4331,8 +4312,8 @@ function initMixin$1(Vue) {
         var startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + vm._uid;
-            endTag = "vue-perf-end:" + vm._uid;
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4365,7 +4346,7 @@ function initMixin$1(Vue) {
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure("vue " + vm._name + " init", startTag, endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4594,12 +4575,14 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name_1 = getComponentName(cachedNode.componentOptions);
-            if (name_1 && !filter(name_1)) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
@@ -4624,45 +4607,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function () {
+    created: function created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function () {
+    destroyed: function destroyed() {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function () {
-        var _this = this;
+    mounted: function mounted() {
+        var this$1 = this;
+
         this.$watch('include', function (val) {
-            pruneCache(_this, function (name) { return matches(val, name); });
+            pruneCache(this$1, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(_this, function (name) { return !matches(val, name); });
+            pruneCache(this$1, function (name) { return !matches(val, name); });
         });
     },
-    render: function () {
+    render: function render() {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name_2 = getComponentName(componentOptions);
-            var _a = this, include = _a.include, exclude = _a.exclude;
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
             if (
             // not included
-            (include && (!name_2 || !matches(include, name_2))) ||
+            (include && (!name || !matches(include, name))) ||
                 // excluded
-                (exclude && name_2 && matches(exclude, name_2))) {
+                (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var _b = this, cache = _b.cache, keys = _b.keys;
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? "::" + componentOptions.tag : '')
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4734,7 +4722,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function () {
+    get: function get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4993,17 +4981,17 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create: function (_, vnode) {
+var ref$1 = {
+    create: function create(_, vnode) {
         registerRef(vnode);
     },
-    update: function (oldVnode, vnode) {
+    update: function update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5085,7 +5073,8 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules, nodeOps = backend.nodeOps;
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5256,8 +5245,8 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5271,8 +5260,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-            cbs.create[i_2](emptyNode, vnode);
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5344,7 +5333,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i_3;
+            var i;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5356,16 +5345,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i_3 = vnode.componentInstance)) &&
-                isDef((i_3 = i_3._vnode)) &&
-                isDef(i_3.data)) {
-                removeAndInvokeRemoveHook(i_3, rm);
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
             }
-            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                cbs.remove[i_3](vnode, rm);
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
             }
-            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                i_3(vnode, rm);
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
             }
             else {
                 rm();
@@ -5461,12 +5450,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i_4 = 0; i_4 < children.length; i_4++) {
-            var vnode = children[i_4];
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                    warn$2(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5475,10 +5464,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i_5 = start; i_5 < end; i_5++) {
-            var c = oldCh[i_5];
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i_5; }
+                { return i; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5558,8 +5547,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                queue[i_6].data.hook.insert(queue[i_6]);
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
             }
         }
     }
@@ -5572,7 +5561,9 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag, data = vnode.data, children = vnode.children;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5621,9 +5612,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i_7 = 0; i_7 < children.length; i_7++) {
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5734,22 +5725,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                            cbs.destroy[i_8](ancestor);
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                cbs.create[i_9](emptyNode, ancestor);
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert_1 = ancestor.data.hook.insert;
-                            if (insert_1.merged) {
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                    insert_1.fns[i_10]();
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
                                 }
                             }
                         }
@@ -5864,7 +5855,7 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
@@ -5873,12 +5864,12 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
         }
     }
 }
 
-var baseModules = [ref, directives$1];
+var baseModules = [ref$1, directives$1];
 
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
@@ -5967,11 +5958,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker_1 = function (e) {
+            var blocker = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker_1);
+                el.removeEventListener('input', blocker);
             };
-            el.addEventListener('input', blocker_1);
+            el.addEventListener('input', blocker);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6088,9 +6079,7 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p 
-                // find first non-whitespace prev char
-                = void 0;
+                var p = (void 0);
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -6124,18 +6113,18 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return "_f(\"" + filter + "\")(" + exp + ")";
+        return ("_f(\"" + filter + "\")(" + exp + ")");
     }
     else {
-        var name_1 = filter.slice(0, i);
+        var name = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
     }
 }
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error("[Vue compiler]: " + msg);
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -6169,7 +6158,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6303,23 +6292,25 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                ("? " + baseValueExpression + ".trim()") +
-                (": " + baseValueExpression + ")");
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: "(" + value + ")",
+        value: ("(" + value + ")"),
         expression: JSON.stringify(value),
-        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
     };
 }
 /**
@@ -6328,10 +6319,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return value + "=" + assignment;
+        return (value + "=" + assignment);
     }
     else {
-        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
     }
 }
 /**
@@ -6437,8 +6428,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN$1])) {
         // IE input[type=range] only supports `change` event
-        var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
         delete on[RANGE_TOKEN$1];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6471,17 +6462,17 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp_1 = currentFlushTimestamp;
-        var original_1 = handler;
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
         //@ts-expect-error
-        handler = original_1._wrapper = function (e) {
+        handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp_1 ||
+                e.timeStamp >= attachedTimestamp ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6490,7 +6481,7 @@ function add(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original_1.apply(this, arguments);
+                return original.apply(this, arguments);
             }
         };
     }
@@ -6722,9 +6713,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name_1 = vendorNames[i] + capName;
-        if (name_1 in emptyStyle) {
-            return name_1;
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
         }
     }
 });
@@ -6849,12 +6840,12 @@ function resolveTransition$1(def) {
 }
 var autoCssTransition$1 = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition$1 = inBrowser && !isIE9;
@@ -6906,7 +6897,10 @@ function removeTransitionClass$1(el, cls) {
     removeClass$1(el, cls);
 }
 function whenTransitionEnds$1(el, expectedType, cb) {
-    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo$1(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
@@ -7011,7 +7005,23 @@ function enter$1(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7119,7 +7129,17 @@ function leave$1(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7193,7 +7213,7 @@ function leave$1(vnode, rm) {
 function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn$2("<transition> explicit " + name + " duration is NaN - " +
@@ -7233,7 +7253,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function (vnode, rm) {
+        remove: function remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7269,7 +7289,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function (el, binding, vnode, oldVnode) {
+    inserted: function inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -7299,22 +7319,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function (el, binding, vnode) {
+    componentUpdated: function componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions_1 = el._vOptions;
-            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions_1);
+                        hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7335,8 +7355,8 @@ function actuallySetSelected(el, binding, vm) {
     var value = binding.value;
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
-                ("expects an Array value for its binding, but got " + Object.prototype.toString
+        warn$2("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7467,12 +7487,12 @@ function resolveTransition(def) {
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -7524,7 +7544,10 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7629,7 +7652,23 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7737,7 +7776,17 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7811,7 +7860,7 @@ function leave(vnode, rm) {
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn$2("<transition> explicit " + name + " duration is NaN - " +
@@ -7851,8 +7900,9 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
         vnode = locateNode(vnode);
         var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
@@ -7867,8 +7917,10 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
+
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
@@ -7891,7 +7943,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7942,8 +7994,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key in listeners) {
-        data[camelize(key)] = listeners[key];
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
     }
     return data;
 }
@@ -7971,8 +8023,9 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function (h) {
-        var _this = this;
+    render: function render(h) {
+        var this$1 = this;
+
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -8014,7 +8067,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + this._uid + "-";
+        var id = "__transition-" + (this._uid) + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -8048,8 +8101,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    _this._leaving = false;
-                    _this.$forceUpdate();
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -8057,14 +8110,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave_1;
+                var delayedLeave;
                 var performLeave = function () {
-                    delayedLeave_1();
+                    delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave_1 = leave;
+                    delayedLeave = leave;
                 });
             }
         }
@@ -8081,21 +8134,22 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function () {
-        var _this = this;
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(_this);
+            var restoreActiveInstance = setActiveInstance(this$1);
             // force removing pass
-            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            _this._vnode = _this.kept;
+            this$1._vnode = this$1.kept;
             restoreActiveInstance();
-            update.call(_this, vnode, hydrating);
+            update.call(this$1, vnode, hydrating);
         };
     },
-    render: function (h) {
+    render: function render(h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -8112,27 +8166,27 @@ var TransitionGroup = {
                 }
                 else {
                     var opts = c.componentOptions;
-                    var name_1 = opts
+                    var name = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
+                    warn$2(("<transition-group> children must be keyed: <" + name + ">"));
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i = 0; i < prevChildren.length; i++) {
-                var c = prevChildren[i];
-                c.data.transition = transitionData;
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
                 // @ts-ignore
-                c.data.pos = c.elm.getBoundingClientRect();
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c.key]) {
-                    kept.push(c);
+                if (map[c$1.key]) {
+                    kept.push(c$1);
                 }
                 else {
-                    removed.push(c);
+                    removed.push(c$1);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -8140,7 +8194,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function () {
+    updated: function updated() {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -8158,25 +8212,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el_1 = c.elm;
-                var s = el_1.style;
-                addTransitionClass(el_1, moveClass);
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                    if (e && e.target !== el_1) {
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el_1.removeEventListener(transitionEndEvent, cb);
-                        el_1._moveCb = null;
-                        removeTransitionClass(el_1, moveClass);
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function (el, moveClass) {
+        hasMove: function hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -8380,7 +8434,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push("_s(" + exp + ")");
+        tokens.push(("_s(" + exp + ")"));
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8417,10 +8471,10 @@ function transformNode$1(el, options) {
 function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + el.staticClass + ",";
+        data += "staticClass:" + (el.staticClass) + ",";
     }
     if (el.classBinding) {
-        data += "class:" + el.classBinding + ",";
+        data += "class:" + (el.classBinding) + ",";
     }
     return data;
 }
@@ -8454,10 +8508,10 @@ function transformNode(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + el.staticStyle + ",";
+        data += "staticStyle:" + (el.staticStyle) + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + el.styleBinding + "),";
+        data += "style:(" + (el.styleBinding) + "),";
     }
     return data;
 }
@@ -8469,7 +8523,7 @@ var style = {
 
 var decoder;
 var he = {
-    decode: function (html) {
+    decode: function decode(html) {
         decoder = decoder || document.createElement('div');
         decoder.innerHTML = html;
         return decoder.textContent;
@@ -8495,11 +8549,11 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp("^<" + qnameCapture);
+var startTagOpen = new RegExp(("^<" + qnameCapture));
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -8520,9 +8574,7 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) {
-    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-};
+var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -8534,7 +8586,7 @@ function parseHTML(html, options) {
     var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    var _loop_1 = function () {
+    while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -8548,7 +8600,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        return "continue";
+                        continue;
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -8556,14 +8608,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        return "continue";
+                        continue;
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    return "continue";
+                    continue;
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -8571,7 +8623,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    return "continue";
+                    continue;
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -8580,10 +8632,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    return "continue";
+                    continue;
                 }
             }
-            var text = void 0, rest = void 0, next = void 0;
+            var text = (void 0), rest = (void 0), next = (void 0);
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8610,18 +8662,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength_1 = 0;
-            var stackedTag_1 = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag_1] ||
-                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-            var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength_1 = endTag.length;
-                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -8629,25 +8681,20 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag_1, index - endTagLength_1, index);
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                     start: index + html.length,
                 });
             }
-            return "break";
+            break;
         }
-    };
-    while (html) {
-        var state_1 = _loop_1();
-        if (state_1 === "break")
-            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -8664,7 +8711,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end = void 0, attr = void 0;
+            var end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8747,7 +8794,7 @@ function parseHTML(html, options) {
             for (var i = stack.length - 1; i >= pos; i--) {
                 if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8822,7 +8869,10 @@ function parse(template, options) {
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
     var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    maybeComponent = function (el) { return !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -8873,8 +8923,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name_1 = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -8900,7 +8950,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode = void 0;
+            var lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8910,7 +8960,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8927,7 +8977,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function (tag, attrs, unary, start, end) {
+        start: function start(tag, attrs, unary, start$1, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -8942,7 +8992,7 @@ function parse(template, options) {
             }
             {
                 if (options.outputSourceRange) {
-                    element.start = start;
+                    element.start = start$1;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -8963,7 +9013,7 @@ function parse(template, options) {
                 element.forbidden = true;
                 warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        ("<" + tag + ">") +
+                        "<" + tag + ">" +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -9002,24 +9052,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function (tag, start, end) {
+        end: function end(tag, start, end$1) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (options.outputSourceRange) {
-                element.end = end;
+                element.end = end$1;
             }
             closeElement(element);
         },
-        chars: function (text, start, end) {
+        chars: function chars(text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                             start: start,
                         });
                     }
@@ -9059,8 +9109,8 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res = void 0;
-                var child = void 0;
+                var res;
+                var child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -9086,7 +9136,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function (text, start, end) {
+        comment: function comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -9156,11 +9206,11 @@ function processKey(el) {
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent_1 = el.parent;
+                var parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent_1 &&
-                    parent_1.tag === 'transition-group') {
+                    parent &&
+                    parent.tag === 'transition-group') {
                     warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
@@ -9184,7 +9234,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -9237,7 +9287,7 @@ function processIfConditions(el, parent) {
     }
     else {
         warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -9248,7 +9298,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -9285,7 +9335,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -9317,41 +9367,45 @@ function processSlotContent(el) {
                             "the receiving component", el);
                     }
                 }
-                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                el.slotTarget = name_2;
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                     }
                     if (el.slotScope || el.slotTarget) {
                         warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
                         warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding);
+                            "<template> syntax when there are other named slots.", slotBinding$1);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                slotContainer_1.slotTarget = name_3;
-                slotContainer_1.slotTargetDynamic = dynamic;
-                slotContainer_1.children = el.children.filter(function (c) {
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer_1;
+                        c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -9374,7 +9428,7 @@ function getSlotName(binding) {
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: "\"" + name + "\"", dynamic: false };
+            { name: ("\"" + name + "\""), dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
@@ -9420,7 +9474,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9434,14 +9488,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -9518,11 +9572,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret_1 = {};
+        var ret = {};
         match.forEach(function (m) {
-            ret_1[m.slice(1)] = true;
+            ret[m.slice(1)] = true;
         });
-        return ret_1;
+        return ret;
     }
 }
 function makeAttrsMap(attrs) {
@@ -9564,7 +9618,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9589,16 +9643,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding = void 0;
+        var typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + map['v-bind'] + ").type";
+            typeBinding = "(" + (map['v-bind']) + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -9664,7 +9718,7 @@ function model(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -9691,7 +9745,7 @@ function model(el, dir, _warn) {
         return false;
     }
     else {
-        warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+        warn("<" + (el.tag) + " v-model=\"" + value + "\">: " +
             "v-model is not supported on this element type. " +
             "If you are working with contenteditable, it's recommended to " +
             'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
@@ -9705,25 +9759,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
         (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
         'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
         '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -9731,10 +9785,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
+        "return " + (number ? '_n(val)' : 'val') + "})";
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
+    code = code + " " + (genAssignmentCode(value, assignment));
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -9742,15 +9796,18 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
+        if (value$1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+            warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -9764,7 +9821,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', "(" + value + ")");
+    addProp(el, 'value', ("(" + value + ")"));
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -9773,13 +9830,13 @@ function genDefaultModel(el, value, modifiers) {
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
@@ -9863,8 +9920,8 @@ function markStatic(node) {
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                var block = node.ifConditions[i].block;
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -9896,8 +9953,8 @@ function markStaticRoots(node, isInFor) {
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                markStaticRoots(node.ifConditions[i$1].block, isInFor);
             }
         }
     }
@@ -9967,7 +10024,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -9984,19 +10041,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name_1 in events) {
-        var handlerCode = genHandler(events[name_1]);
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
         //@ts-expect-error
-        if (events[name_1] && events[name_1].dynamic) {
-            dynamicHandlers += name_1 + "," + handlerCode + ",";
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
     if (dynamicHandlers) {
-        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
     }
     else {
         return prefix + staticHandlers;
@@ -10007,7 +10064,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -10016,13 +10073,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        var _loop_1 = function (key) {
+        for (var key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -10031,18 +10088,15 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers_1 = handler.modifiers;
+                var modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
-        };
-        for (var key in handler.modifiers) {
-            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -10052,13 +10106,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? "return " + handler.value + ".apply(null, arguments)"
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
             : isFunctionExpression
-                ? "return (" + handler.value + ").apply(null, arguments)"
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
                 : isFunctionInvocation
-                    ? "return " + handler.value
+                    ? ("return " + (handler.value))
                     : handler.value;
-        return "function($event){" + code + handlerCode + "}";
+        return ("function($event){" + code + handlerCode + "}");
     }
 }
 function genKeyFilter(keys) {
@@ -10067,20 +10121,20 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&') + ")return null;"));
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return "$event.keyCode!==" + keyVal;
+        return ("$event.keyCode!==" + keyVal);
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key) + ",") +
-        (JSON.stringify(keyCode) + ",") +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
         "$event.key," +
-        ("" + JSON.stringify(keyName)) +
+        "" + (JSON.stringify(keyName)) +
         ")");
 }
 
@@ -10088,12 +10142,12 @@ function on(el, dir) {
     if (dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
 function bind(el, dir) {
     el.wrapData = function (code) {
-        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
     };
 }
 
@@ -10103,24 +10157,19 @@ var baseDirectives = {
     cloak: noop,
 };
 
-var CodegenState = /** @class */ (function () {
-    function CodegenState(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        var isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = function (el) {
-            return !!el.component || !isReservedTag(el.tag);
-        };
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-    return CodegenState;
-}());
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
+};
 function generate(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
@@ -10130,7 +10179,7 @@ function generate(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: ("with(this){return " + code + "}"),
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -10158,19 +10207,17 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code = void 0;
+        var code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data = void 0;
+            var data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-            ) + (children ? "," + children : '' // children
-            ) + ")";
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -10189,9 +10236,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
     state.pre = originalPreState;
-    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
 // v-once
 function genOnce(el, state) {
@@ -10201,19 +10248,19 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent_1 = el.parent;
-        while (parent_1) {
-            if (parent_1.for) {
-                key = parent_1.key;
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
                 break;
             }
-            parent_1 = parent_1.parent;
+            parent = parent.parent;
         }
         if (!key) {
             state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
     }
     else {
         return genStatic(el, state);
@@ -10229,10 +10276,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
     }
     else {
-        return "" + genTernaryExp(condition.block);
+        return ("" + (genTernaryExp(condition.block)));
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -10246,20 +10293,20 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        ("function(" + alias + iterator1 + iterator2 + "){") +
-        ("return " + (altGen || genElement)(el, state)) +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
         '})');
 }
 function genData(el, state) {
@@ -10271,11 +10318,11 @@ function genData(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + el.key + ",";
+        data += "key:" + (el.key) + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + el.ref + ",";
+        data += "ref:" + (el.ref) + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -10286,7 +10333,7 @@ function genData(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + el.tag + "\",";
+        data += "tag:\"" + (el.tag) + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -10294,31 +10341,31 @@ function genData(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + genProps(el.attrs) + ",";
+        data += "attrs:" + (genProps(el.attrs)) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + genProps(el.props) + ",";
+        data += "domProps:" + (genProps(el.props)) + ",";
     }
     // event handlers
     if (el.events) {
-        data += genHandlers(el.events, false) + ",";
+        data += (genHandlers(el.events, false)) + ",";
     }
     if (el.nativeEvents) {
-        data += genHandlers(el.nativeEvents, true) + ",";
+        data += (genHandlers(el.nativeEvents, true)) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + el.slotTarget + ",";
+        data += "slot:" + (el.slotTarget) + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += genScopedSlots(el, el.scopedSlots, state) + ",";
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -10332,7 +10379,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -10362,9 +10409,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -10378,9 +10425,9 @@ function genInlineTemplate(el, state) {
     }
     if (ast && ast.type === 1) {
         var inlineRenderFns = generate(ast, state.options);
-        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-            .map(function (code) { return "function(){" + code + "}"; })
-            .join(',') + "]}";
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -10405,23 +10452,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent_2 = el.parent;
-        while (parent_2) {
-            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                parent_2.for) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent_2.if) {
+            if (parent.if) {
                 needsKey = true;
             }
-            parent_2 = parent_2.parent;
+            parent = parent.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
 }
 function hash(str) {
     var hash = 5381;
@@ -10450,36 +10497,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        ("return " + (el.tag === 'template'
+        "return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}");
+            : genElement(el, state)) + "}";
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el_1 = children[0];
+        var el$1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el_1.for &&
-            el_1.tag !== 'template' &&
-            el_1.tag !== 'slot') {
-            var normalizationType_1 = checkSkip
-                ? state.maybeComponent(el_1)
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
                     ? ",1"
                     : ",0"
                 : "";
-            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
         }
-        var normalizationType = checkSkip
+        var normalizationType$1 = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen_1 = altGenNode || genNode;
-        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
     }
 }
 // determine the normalization needed for the children array.
@@ -10521,17 +10568,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return "_v(" + (text.type === 2
+    return ("_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
 }
 function genComment(comment) {
-    return "_e(" + JSON.stringify(comment.text) + ")";
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? "," + children : '');
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -10555,7 +10602,7 @@ function genSlot(el, state) {
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+    return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
 }
 function genProps(props) {
     var staticProps = "";
@@ -10564,15 +10611,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += prop.name + "," + value + ",";
+            dynamicProps += (prop.name) + "," + value + ",";
         }
         else {
-            staticProps += "\"" + prop.name + "\":" + value + ",";
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
         }
     }
-    staticProps = "{" + staticProps.slice(0, -1) + "}";
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
     if (dynamicProps) {
-        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
     }
     else {
         return staticProps;
@@ -10606,22 +10653,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name_1 in node.attrsMap) {
-            if (dirRE.test(name_1)) {
-                var value = node.attrsMap[name_1];
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name_1];
-                    if (name_1 === 'v-for') {
-                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                     }
-                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
-                    else if (onRE.test(name_1)) {
-                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                     }
                     else {
-                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
                 }
             }
@@ -10641,7 +10688,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10654,16 +10701,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function("var " + ident + "=_");
+            new Function(("var " + ident + "=_"));
         }
         catch (e) {
-            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function("return " + exp);
+        new Function(("return " + exp));
     }
     catch (e) {
         var keywordMatch = exp
@@ -10671,12 +10718,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
         }
         else {
-            warn("invalid expression: " + e.message + " in\n\n" +
-                ("    " + exp + "\n\n") +
-                ("  Raw expression: " + text.trim() + "\n"), range);
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
         }
     }
 }
@@ -10685,16 +10732,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + e.message + " in\n\n" +
-            ("    " + exp + "\n\n") +
-            ("  Raw expression: " + text.trim() + "\n"), range);
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
     }
 }
 
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if (start === void 0) { start = 0; }
-    if (end === void 0) { end = source.length; }
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -10704,18 +10752,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length_1 = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length_2 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length_2));
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length$1));
                     }
                     count += lineLength + 1;
                 }
@@ -10787,13 +10835,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                        warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
                     warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -10821,10 +10869,12 @@ function createCompileToFunctionFn(compile) {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                 warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (_a) {
-                        var err = _a.err, code = _a.code;
-                        return err.toString() + " in\n\n" + code + "\n";
-                    })
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
                         .join('\n'), vm);
             }
         }
@@ -10844,15 +10894,15 @@ function createCompilerCreator(baseCompile) {
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength_1;
+                                data.start = range.start + leadingSpaceLength;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength_1;
+                                data.end = range.end + leadingSpaceLength;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -10905,7 +10955,8 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
+var ref = createCompiler(baseOptions);
+var compileToFunctions = ref.compileToFunctions;
 
 // check whether current browser encodes a char inside attribute values
 var div;
@@ -10943,7 +10994,7 @@ Vue.prototype.$mount = function (el, hydrating) {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (!template) {
-                        warn$2("Template element not found or is empty: " + options.template, this);
+                        warn$2(("Template element not found or is empty: " + (options.template)), this);
                     }
                 }
             }
@@ -10966,19 +11017,21 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (config.performance && mark) {
                 mark('compile');
             }
-            var _a = compileToFunctions(template, {
+            var ref = compileToFunctions(template, {
                 outputSourceRange: "development" !== 'production',
                 shouldDecodeNewlines: shouldDecodeNewlines,
                 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
-            }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
+            }, this);
+            var render = ref.render;
+            var staticRenderFns = ref.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (config.performance && mark) {
                 mark('compile end');
-                measure("vue " + this._name + " compile", 'compile', 'compile end');
+                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
             }
         }
     }
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
index d63fd7d0d1c..a1acfb920e0 100644
--- a/dist/vue.common.prod.js
+++ b/dist/vue.common.prod.js
@@ -3,4 +3,9 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(){function e(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var a,o=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":a=r;break;case"splice":a=r.slice(2)}return a&&s.observeArray(a),s.dep.notify(),o})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&we(t),a.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in A(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?A({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Ae[r]||Ee;o[r]=i(e[r],t[r],n,r)}return o}function je(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function De(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Pe(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var l=_e;be(!0),we(o),be(l)}return o}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch(function(e){return Re(e,r,i+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,r,i)}return a}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],qe=!1;function Je(){qe=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(Je),Z&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Je)}:function(){setTimeout(Je,0)};else{var Ze=1,Ge=new MutationObserver(Je),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),qe||(qe=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(o)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)He(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=tt(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=nt(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=tt(c)).name,n[c],f.capture)}function it(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=nt([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=nt([s,c]),o.merged=!0,e[i]=o}function at(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ot(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(a,o){var s=[];var c,l,u,f;for(c=0;c<a.length;c++)t(l=a[c])||"boolean"==typeof l||(u=s.length-1,f=s[u],Array.isArray(l)?l.length>0&&(st((l=e(l,(o||"")+"_"+c))[0])&&st(f)&&(s[u]=ve(f.text+l[0].text),l.shift()),s.push.apply(s,l)):i(l)?st(f)?s[u]=ve(f.text+l):""!==l&&s.push(ve(l)):st(l)&&st(f)?s[u]=ve(f.text+l.text):(r(a._isVList)&&n(l.tag)&&t(l.key)&&n(o)&&(l.key="__vlist"+o+"_"+c+"__"),s.push(l)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function lt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ut)&&delete n[l];return n}function ut(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=dt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ot(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=A(A({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function mt(e){return je(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):a?yt(a,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(a(n)){Array.isArray(n)&&(n=O(n));var o=void 0,s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?kt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=u,e._l=vt,e._t=ht,e._q=E,e._i=L,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=ct(l.inject,a),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=lt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var a=he(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var Lt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Lt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=De(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Jt(t,r,h),l&&(t.$slots=lt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},jt=Object.keys(Lt);function Dt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Ht;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",function(){return h(s,o)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=j(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout(function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=de();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},$n(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);at(o,c,l,u,!0)||at(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=De(u,l,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ot(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<jt.length;n++){var r=jt[n],i=t[r],a=Lt[r];i===a||i&&i._merged||(t[r]=i?Mt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,o,s,c,l,u){return(Array.isArray(s)||i(s))&&(l=c,c=s,s=void 0),r(u)&&(l=Ft),function(e,i,o,s,c){if(n(o)&&n(o.__ob__))return de();n(o)&&n(o.is)&&(i=o.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=ot(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var l,u;if("string"==typeof i){var f=void 0;u=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),l=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),o,s,void 0,void 0,e):o&&o.pre||!n(f=je(e.$options,"components",i))?new pe(i,o,s,void 0,void 0,e):Dt(f,o,e,s,i)}else l=Dt(i,o,e,s);return Array.isArray(l)?l:n(l)?(n(u)&&function e(i,a,o){i.ns=a;"foreignObject"===i.tag&&(a=void 0,o=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var l=i.children[s];n(l.tag)&&(t(l.ns)||r(o)&&"svg"!==l.tag)&&e(l,a,o)}}(l,u),n(o)&&function(e){a(e.style)&&et(e.style);a(e.class)&&et(e.class)}(o),l):de()}(e,o,s,c,l)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function qt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function Jt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,qt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,an=0;var on=0,sn=Date.now;if(U&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function ln(){var e,t;for(on=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),an=0;an<Qt.length;an++)(e=Qt[an]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();an=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var un=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>an&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(ln))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var a=function(a){i.push(a);var o=De(a,t,n,e);Ce(r,a,o),a in e||dn(e,"_props",a)};for(var o in t)a(o);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||(o=void 0,36!==(o=(a+"").charCodeAt(0))&&95!==o&&dn(e,"_data",a))}var o;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new fn(e,o||S,S,hn)),i in e||mn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Le(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach(function(e){o[e]=n[e]}),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=A({},o.options),i[r]=o,o}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=xn(o.componentOptions);s&&!t(s)&&On(n,a,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Jt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=lt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var a=r&&r.data;Ce(t,"$attrs",a&&a.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){ue();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,a=t.length;i<a;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,a=this.exclude;if(i&&(!r||!kn(i,r))||a&&r&&kn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:A,mergeOptions:Le,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),Ln=p("contenteditable,draggable,spellcheck"),jn=p("events,caret,typing,plaintext-only"),Dn=function(e,t){return Rn(t)||"false"===t?"false":"contenteditable"===e&&jn(t)?t:"true"},Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Fn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Pn=function(e){return Fn(e)?e.slice(6,e.length):""},Rn=function(e){return null==e||!1===e};function Hn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Bn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Bn(t,r.data));return function(e,t){if(n(e)||n(t))return Un(e,zn(t));return""}(t.staticClass,t.class)}function Bn(e,t){return{staticClass:Un(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Un(e,t){return e?t?e+" "+t:e:t||""}function zn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=zn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Jn=function(e){return Kn(e)||qn(e)};var Wn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Vn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Xn={create:function(e,t){Yn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(Yn(e,!0),Yn(t))},destroy:function(e){Yn(e,!0)}};function Yn(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var Qn=new pe("",{},[]),er=["create","activate","update","remove","destroy"];function tr(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Zn(i)&&Zn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function nr(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var rr={create:ir,update:ir,destroy:function(e){ir(e,Qn)}};function ir(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===Qn,o=t===Qn,s=or(e.data.directives,e.context),c=or(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,cr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(cr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)cr(l[n],"inserted",t,e)};a?it(t,"insert",f):f()}u.length&&it(t,"postpatch",function(){for(var n=0;n<u.length;n++)cr(u[n],"componentUpdated",t,e)});if(!a)for(n in s)c[n]||cr(s[n],"unbind",e,e,o)}(e,t)}var ar=Object.create(null);function or(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ar),i[sr(r)]=r,r.def=je(t.$options,"directives",r.name);return i}function sr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function cr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var lr=[Xn,rr];function ur(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=A({},l)),l)o=l[a],c[a]!==o&&fr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&fr(s,"value",l.value),c)t(l[a])&&(Fn(a)?s.removeAttributeNS(In,Pn(a)):Ln(a)||s.removeAttribute(a))}}function fr(e,t,n,r){r||e.tagName.indexOf("-")>-1?pr(e,t,n):Mn(t)?Rn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Ln(t)?e.setAttribute(t,Dn(t,n)):Fn(t)?Rn(n)?e.removeAttributeNS(In,Pn(t)):e.setAttributeNS(In,t,n):pr(e,t,n)}function pr(e,t,n){if(Rn(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var dr={create:ur,update:ur};function vr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Hn(r),c=i._transitionClasses;n(c)&&(s=Un(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var hr,mr,yr,gr,_r,br,$r={create:vr,update:vr},wr=/[\w).+\-_$\]]/;function Cr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&wr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=xr(i,a[r]);return i}function xr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function kr(e,t){console.error("[Vue compiler]: "+e)}function Ar(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Or(e,t,n,r,i){(e.props||(e.props=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Sr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Tr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Ir({name:t,value:n},r))}function Nr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Ir({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Er(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Lr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Er("!",n,c)),i.once&&(delete i.once,n=Er("~",n,c)),i.passive&&(delete i.passive,n=Er("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Ir({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function jr(e,t,n){var r=Dr(e,":"+t)||Dr(e,"v-bind:"+t);if(null!=r)return Cr(r);if(!1!==n){var i=Dr(e,t);if(null!=i)return JSON.stringify(i)}}function Dr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Mr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Ir(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Fr(e,t,n){var r=n||{},i=r.number,a="$$v";r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var o=Pr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+o+"}"}}function Pr(e,t){var n=function(e){if(e=e.trim(),hr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<hr-1)return(gr=e.lastIndexOf("."))>-1?{exp:e.slice(0,gr),key:'"'+e.slice(gr+1)+'"'}:{exp:e,key:null};mr=e,gr=_r=br=0;for(;!Hr();)Br(yr=Rr())?zr(yr):91===yr&&Ur(yr);return{exp:e.slice(0,_r),key:e.slice(_r+1,br)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Rr(){return mr.charCodeAt(++gr)}function Hr(){return gr>=hr}function Br(e){return 34===e||39===e}function Ur(e){var t=1;for(_r=gr;!Hr();)if(Br(e=Rr()))zr(e);else if(91===e&&t++,93===e&&t--,0===t){br=gr;break}}function zr(e){for(var t=e;!Hr()&&(e=Rr())!==t;);}var Vr,Kr="__r",qr="__c";function Jr(e,t,n){var r=Vr;return function i(){null!==t.apply(null,arguments)&&Gr(e,i,n,r)}}var Wr=Ve&&!(X&&Number(X[1])<=53);function Zr(e,t,n,r){if(Wr){var i=on,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Vr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Gr(e,t,n,r){(r||Vr).removeEventListener(e,t._wrapper||t,n)}function Xr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Vr=r.elm,function(e){if(n(e[Kr])){var t=q?"change":"input";e[t]=[].concat(e[Kr],e[t]||[]),delete e[Kr]}n(e[qr])&&(e.change=[].concat(e[qr],e.change||[]),delete e[qr])}(i),rt(i,a,Zr,Gr,Jr,r.context),Vr=void 0}}var Yr,Qr={create:Xr,update:Xr};function ei(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ti(o,l)&&(o.value=l)}else if("innerHTML"===i&&qn(o.tagName)&&t(o.innerHTML)){(Yr=Yr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Yr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ti(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ni={create:ei,update:ei},ri=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function ii(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ri(e):e}var oi,si=/^--/,ci=/\s*!important$/,li=function(e,t,n){if(si.test(t))e.style.setProperty(t,n);else if(ci.test(n))e.style.setProperty(C(t),n.replace(ci,""),"important");else{var r=fi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},ui=["Webkit","Moz","ms"],fi=g(function(e){if(oi=oi||document.createElement("div").style,"filter"!==(e=b(e))&&e in oi)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<ui.length;n++){var r=ui[n]+t;if(r in oi)return r}});function pi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ii(i.data))&&A(r,n);(n=ii(e.data))&&A(r,n);for(var a=e;a=a.parent;)a.data&&(n=ii(a.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(o=d[s])!==f[s]&&li(c,s,null==o?"":o)}}var di={create:pi,update:pi},vi=/\s+/;function hi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,mi(e.name||"v")),A(t,e),t}return"string"==typeof e?mi(e):void 0}}var mi=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),yi="transition",gi="animation",_i="transition",bi="transitionend",$i="animation",wi="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_i="WebkitTransition",bi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($i="WebkitAnimation",wi="webkitAnimationEnd"));var Ci=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function xi(e){Ci(function(){Ci(e)})}function ki(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Oi(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[_i+"Delay"]||"").split(", "),a=(r[_i+"Duration"]||"").split(", "),o=Ti(i,a),s=(r[$i+"Delay"]||"").split(", "),c=(r[$i+"Duration"]||"").split(", "),l=Ti(s,c),u=0,f=0;t===yi?o>0&&(n=yi,u=o,f=a.length):t===gi?l>0&&(n=gi,u=l,f=c.length):(u=Math.max(o,l),f=(n=u>0?o>l?yi:gi:null)?n===yi?a.length:c.length:0);var p=n===yi&&Si.test(r[_i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===yi?bi:wi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var Si=/\b(transform|all)(,|$)/;function Ti(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Ni(t)+Ni(e[n])}))}function Ni(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ei(e){return"number"==typeof e&&!isNaN(e)}function Li(e){if(t(e))return!1;var r=e.fns;return n(r)?Li(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ji(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=hi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Li(L),R=i._enterCb=j(function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ki(i,S),ki(i,T),xi(function(){Ai(i,S),R.cancelled||(ki(i,N),P||(Ei(I)?setTimeout(R,I):Oi(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Di=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<er.length;++a)for(s[er[a]]=[],o=0;o<c.length;++o)n(c[o][er[a]])&&s[er[a]].push(c[o][er[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=he(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){for(var a,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,n(a=o.data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](Qn,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(Yn(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](Qn,e);n(a=e.data.hook)&&(n(a.create)&&a.create(Qn,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&tr(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:tr(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):tr(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):tr(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):tr(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=nr(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):tr(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&tr(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Qn,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else Yn(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Gn,modules:[dr,$r,Qr,ni,di,U?{create:ji,activate:ji,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=hi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Li(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ki(i,l),ki(i,p),xi(function(){Ai(i,l),w.cancelled||(ki(i,u),b||(Ei($)?setTimeout(w,$):Oi(i,c,w)))})),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(lr)});J&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Ui(e,"input")});var Mi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Mi.componentUpdated(e,t,n)}):Ii(e,t,n.context),e._vOptions=[].map.call(e.options,Ri)):("textarea"===n.tag||Zn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Hi),e.addEventListener("compositionend",Bi),e.addEventListener("change",Bi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ii(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ri);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return Pi(e,i)}):t.value!==t.oldValue&&Pi(t.value,i))&&Ui(e,"change")}}};function Ii(e,t,n){Fi(e,t),(q||W)&&setTimeout(function(){Fi(e,t)},0)}function Fi(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Ri(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Ri(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Pi(e,t){return t.every(function(t){return!E(t,e)})}function Ri(e){return"_value"in e?e._value:e.value}function Hi(e){e.target.composing=!0}function Bi(e){e.target.composing&&(e.target.composing=!1,Ui(e.target,"input"))}function Ui(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var zi=/\s+/;function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ki(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function qi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,Ji(e.name||"v")),A(t,e),t}return"string"==typeof e?Ji(e):void 0}}var Ji=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Wi=U&&!J,Zi="transition",Gi="animation",Xi="transition",Yi="transitionend",Qi="animation",ea="animationend";Wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xi="WebkitTransition",Yi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Qi="WebkitAnimation",ea="webkitAnimationEnd"));var ta=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function na(e){ta(function(){ta(e)})}function ra(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),Vi(e,t))}function ia(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ki(e,t)}function aa(e,t,n){var r=sa(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Zi?Yi:ea,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var oa=/\b(transform|all)(,|$)/;function sa(e,t){var n,r=window.getComputedStyle(e),i=(r[Xi+"Delay"]||"").split(", "),a=(r[Xi+"Duration"]||"").split(", "),o=ca(i,a),s=(r[Qi+"Delay"]||"").split(", "),c=(r[Qi+"Duration"]||"").split(", "),l=ca(s,c),u=0,f=0;return t===Zi?o>0&&(n=Zi,u=o,f=a.length):t===Gi?l>0&&(n=Gi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Zi:Gi:null)?n===Zi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Zi&&oa.test(r[Xi+"Property"])}}function ca(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return la(t)+la(e[n])}))}function la(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ua(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=qi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=pa(L),R=i._enterCb=j(function(){F&&(ia(i,N),ia(i,T)),R.cancelled?(F&&ia(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ra(i,S),ra(i,T),na(function(){ia(i,S),R.cancelled||(ra(i,N),P||(fa(I)?setTimeout(R,I):aa(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function fa(e){return"number"==typeof e&&!isNaN(e)}function pa(e){if(t(e))return!1;var r=e.fns;return n(r)?pa(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}var va={model:Mi,show:{bind:function(e,t,n){var r=t.value,i=(n=da(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,ua(n,function(){e.style.display=a})):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=da(i)).data&&i.data.transition?(i.data.show=!0,o?ua(i,function(){e.style.display=e.__vOriginalDisplay}):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=qi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=pa(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ia(i,u),ia(i,p)),w.cancelled?(_&&ia(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ra(i,l),ra(i,p),na(function(){ia(i,l),w.cancelled||(ra(i,u),b||(fa($)?setTimeout(w,$):aa(i,c,w)))})),v&&v(i,w),_||b||w())}}(i,function(){e.style.display="none"})):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ha={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ma(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ma(zt(t.children)):e}function ya(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ga(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var _a=function(e){return e.tag||Ut(e)},ba=function(e){return"show"===e.name},$a={name:"transition",props:ha,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(_a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ma(a);if(!o)return a;if(this._leaving)return ga(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=ya(this),l=this._vnode,u=ma(l);if(o.data.directives&&o.data.directives.some(ba)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Ut(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ga(e,a);if("in-out"===r){if(Ut(o))return l;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return a}}},wa=A({tag:String,moveClass:String},ha);function Ca(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function xa(e){e.data.newPos=e.elm.getBoundingClientRect()}function ka(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete wa.mode;var Aa={Transition:$a,TransitionGroup:{props:wa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=ya(this),s=0;s<i.length;s++){(u=i[s]).tag&&null!=u.key&&0!==String(u.key).indexOf("__vlist")&&(a.push(u),n[u.key]=u,(u.data||(u.data={})).transition=o)}if(r){var c=[],l=[];for(s=0;s<r.length;s++){var u;(u=r[s]).data.transition=o,u.data.pos=u.elm.getBoundingClientRect(),n[u.key]?c.push(u):l.push(u)}this.kept=e(t,null,c),this.removed=l}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Ca),e.forEach(xa),e.forEach(ka),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;ra(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Yi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Yi,e),n._moveCb=null,ia(n,t))})}}))},methods:{hasMove:function(e,t){if(!Wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Ki(n,e)}),Vi(n,t),n.style.display="none",this.$el.appendChild(n);var r=sa(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},wn.config.isReservedTag=Jn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=function(e){return qn(e)?"svg":"math"===e?"math":void 0},wn.config.isUnknownElement=function(e){if(!U)return!0;if(Jn(e))return!1;if(e=e.toLowerCase(),null!=Wn[e])return Wn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Wn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Wn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,va),A(wn.options.components,Aa),wn.prototype.__patch__=U?Di:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var Oa=p("input,textarea,option,select,progress"),Sa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ta=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Na(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Ea=/\{\{((?:.|\r?\n)+?)\}\}/g,La=/[-.*+?^${}()|[\]\/\\]/g,ja=g(function(e){var t=e[0].replace(La,"\\$&"),n=e[1].replace(La,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var Da={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Dr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=jr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Ma,Ia={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Dr(e,"style");n&&(e.staticStyle=JSON.stringify(ri(n)));var r=jr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Fa=function(e){return(Ma=Ma||document.createElement("div")).innerHTML=e,Ma.textContent},Pa=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ra=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ha=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ba="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ua="((?:"+Ba+"\\:)?"+Ba+")",za=new RegExp("^<"+Ua),Va=/^\s*(\/?)>/,Ka=new RegExp("^<\\/"+Ua+"[^>]*>"),qa=/^<!DOCTYPE [^>]+>/i,Ja=/^<!\--/,Wa=/^<!\[/,Za=p("script,style,textarea",!0),Ga={},Xa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ya=/&(?:lt|gt|quot|amp|#39);/g,Qa=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,eo=p("pre,textarea",!0),to=function(e,t){return e&&eo(e)&&"\n"===t[0]};function no(e,t){var n=t?Qa:Ya;return e.replace(n,function(e){return Xa[e]})}function ro(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,l=function(){if(n=e,r&&Za(r)){var l=0,p=r.toLowerCase(),d=Ga[p]||(Ga[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return l=r.length,Za(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),to(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-l,c)}else{var v=e.indexOf("<");if(0===v){if(Ja.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),u(h+3),"continue"}if(Wa.test(e)){var m=e.indexOf("]>");if(m>=0)return u(m+2),"continue"}var y=e.match(qa);if(y)return u(y[0].length),"continue";var g=e.match(Ka);if(g){var _=c;return u(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(za);if(t){var n={tagName:t[1],attrs:[],start:c};u(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Va))&&(i=e.match(Ha)||e.match(Ra));)i.start=c,u(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],u(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Pa(n)&&f(r),s(n)&&r===n&&f(n));for(var l=o(n)||!!c,u=e.attrs.length,p=new Array(u),d=0;d<u;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:no(h,m)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,l,e.start,e.end)}(b),to(b.tagName,e)&&u(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Ka.test(w)||za.test(w)||Ja.test(w)||Wa.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&u($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===l())break}function u(t){c+=t,e=e.substring(t)}function f(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}f()}var io,ao,oo,so,co,lo,uo,fo,po=/^@|^v-on:/,vo=/^v-|^@|^:|^#/,ho=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,mo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,yo=/^\(|\)$/g,go=/^\[.*\]$/,_o=/:(.*)$/,bo=/^:|^\.|^v-bind:/,$o=/\.[^.\]]+(?=[^\]]*$)/g,wo=/^v-slot(:|$)|^#/,Co=/[\r\n]/,xo=/[ \f\t\r\n]+/g,ko=g(Fa),Ao="_empty_";function Oo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Do(t),rawAttrsMap:{},parent:n,children:[]}}function So(e,t){io=t.warn||kr,lo=t.isPreTag||T,uo=t.mustUseProp||T,fo=t.getTagNamespace||T,t.isReservedTag,oo=Ar(t.modules,"transformNode"),so=Ar(t.modules,"preTransformNode"),co=Ar(t.modules,"postTransformNode"),ao=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=To(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Eo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Eo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter(function(e){return!e.slotScope}),u(e),e.pre&&(s=!1),lo(e.tag)&&(c=!1);for(var f=0;f<co.length;f++)co[f](e,t)}function u(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return ro(e,{warn:io,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||fo(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Mo.test(r.name)||(r.name=r.name.replace(Io,""),t.push(r))}return t}(a));var d,v=Oo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<so.length;h++)v=so[h](v,t)||v;s||(!function(e){null!=Dr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),lo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(No(v),function(e){var t=Dr(e,"v-if");if(t)e.if=t,Eo(e,{exp:t,block:e});else{null!=Dr(e,"v-else")&&(e.else=!0);var n=Dr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Dr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):l.length?o?"condense"===o&&Co.test(e)?"":" ":a?" ":"":""){c||"condense"!==o||(e=e.replace(xo," "));var u=void 0,f=void 0;!s&&" "!==e&&(u=function(e,t){var n=t?ja(t):Ea;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Cr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,ao))?f={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&l.length&&" "===l[l.length-1].text||(f={type:3,text:e}),f&&l.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function To(e,t){var n,r;(r=jr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dr(e,"scope"),e.slotScope=t||Dr(e,"slot-scope")):(t=Dr(e,"slot-scope"))&&(e.slotScope=t);var n=jr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Sr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Mr(e,wo);if(r){var i=Lo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Ao}}else{var r=Mr(e,wo);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=Lo(r),l=c.name,o=c.dynamic,u=s[l]=Oo("template",[],e);u.slotTarget=l,u.slotTargetDynamic=o,u.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=u,!0}),u.slotScope=r.value||Ao,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jr(e,"name"))}(e),function(e){var t;(t=jr(e,"is"))&&(e.component=t);null!=Dr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<oo.length;i++)e=oo[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,vo.test(r))if(e.hasBindings=!0,(o=jo(r.replace(vo,"")))&&(r=r.replace($o,"")),bo.test(r))r=r.replace(bo,""),a=Cr(a),(c=go.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Pr(a,"$event"),c?Lr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Lr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Lr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&uo(e.tag,e.attrsMap.type,r)?Or(e,r,a,l[t],c):Sr(e,r,a,l[t],c);else if(po.test(r))r=r.replace(po,""),(c=go.test(r))&&(r=r.slice(1,-1)),Lr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(vo,"")).match(_o),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),go.test(f)&&(f=f.slice(1,-1),c=!0)),Nr(e,r,i,a,f,c,o,l[t])}else Sr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&uo(e.tag,e.attrsMap.type,r)&&Or(e,r,"true",l[t])}(e),e}function No(e){var t;if(t=Dr(e,"v-for")){var n=function(e){var t=e.match(ho);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(yo,""),i=r.match(mo);i?(n.alias=r.replace(mo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function Eo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Lo(e){var t=e.name.replace(wo,"");return t||"#"!==e.name[0]&&(t="default"),go.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function jo(e){var t=e.match($o);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function Do(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Mo=/^xmlns:NS\d+/,Io=/^NS\d+:/;function Fo(e){return Oo(e.tag,e.attrsList.slice(),e.parent)}var Po=[Da,Ia,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=jr(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Dr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Dr(e,"v-else",!0),s=Dr(e,"v-else-if",!0),c=Fo(e);No(c),Tr(c,"type","checkbox"),To(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+a,Eo(c,{exp:c.if,block:c});var l=Fo(e);Dr(l,"v-for",!0),Tr(l,"type","radio"),To(l,t),Eo(c,{exp:"("+r+")==='radio'"+a,block:l});var u=Fo(e);return Dr(u,"v-for",!0),Tr(u,":type",r),To(u,t),Eo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}],Ro="__r";var Ho,Bo,Uo={expectHTML:!0,modules:Po,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Fr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Pr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null",a=jr(e,"true-value")||"true",o=jr(e,"false-value")||"false";Or(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Lr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pr(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null";Or(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Lr(e,"change",Pr(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?Ro:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),o&&(u="_n("+u+")");var f=Pr(t,u);c&&(f="if($event.target.composing)return;"+f),Or(e,"value","("+t+")"),Lr(e,l,f,null,!0),(s||o)&&Lr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Fr(e,r,i),!1;return!0},text:function(e,t){t.value&&Or(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Or(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Oa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Sa(e)||Ta(e)},getTagNamespace:function(e){return Ta(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Po)},zo=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(t);if(1===t.type){if(!Bo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var a=t.ifConditions[n].block;e(a),a.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Ko=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,qo=/\([^)]*?\);*$/,Jo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Go=function(e){return"if("+e+")return null;"},Xo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Go("$event.target !== $event.currentTarget"),ctrl:Go("!$event.ctrlKey"),shift:Go("!$event.shiftKey"),alt:Go("!$event.altKey"),meta:Go("!$event.metaKey"),left:Go("'button' in $event && $event.button !== 0"),middle:Go("'button' in $event && $event.button !== 1"),right:Go("'button' in $event && $event.button !== 2")};function Yo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Qo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Qo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Qo(e)}).join(",")+"]";var t=Jo.test(e.value),n=Ko.test(e.value),r=Jo.test(e.value.replace(qo,""));if(e.modifiers){var i="",a="",o=[],s=function(t){if(Xo[t])a+=Xo[t],Wo[t]&&o.push(t);else if("exact"===t){var n=e.modifiers;a+=Go(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else o.push(t)};for(var c in e.modifiers)s(c);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(es).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function es(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Wo[e],r=Zo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ts={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},ns=function(){return function(e){this.options=e,this.warn=e.warn||kr,this.transforms=Ar(e.modules,"transformCode"),this.dataGenFns=Ar(e.modules,"genData"),this.directives=A(A({},ts),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function rs(e,t){var n=new ns(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":is(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function is(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return as(e,t);if(e.once&&!e.onceProcessed)return os(e,t);if(e.for&&!e.forProcessed)return cs(e,t);if(e.if&&!e.ifProcessed)return ss(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ps(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?hs((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ps(t,n,!0);return"_c("+e+","+ls(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ls(e,t));var i=e.inlineTemplate?null:ps(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ps(e,t)||"void 0"}function as(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+is(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function os(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ss(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+is(e,t)+","+t.onceId+++","+n+")":is(e,t)}return as(e,t)}function ss(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var a=t.shift();return a.exp?"("+a.exp+")?"+o(a.block)+":"+e(t,n,r,i):""+o(a.block);function o(e){return r?r(e,n):e.once?os(e,n):is(e,n)}}(e.ifConditions.slice(),t,n,r)}function cs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||is)(e,t)+"})"}function ls(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+hs(e.attrs)+","),e.props&&(n+="domProps:"+hs(e.props)+","),e.events&&(n+=Yo(e.events,!1)+","),e.nativeEvents&&(n+=Yo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||us(n)}),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Ao||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map(function(e){return fs(t[e],n)}).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=rs(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+hs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function us(e){return 1===e.type&&("slot"===e.tag||e.children.some(us))}function fs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ss(e,t,fs,"null");if(e.for&&!e.forProcessed)return cs(e,t,fs);var r=e.slotScope===Ao?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ps(e,t)||"undefined")+":undefined":ps(e,t)||"undefined":is(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ps(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||is)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ds(i)||i.ifConditions&&i.ifConditions.some(function(e){return ds(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||vs;return"["+a.map(function(e){return l(e,t)}).join(",")+"]"+(c?","+c:"")}}function ds(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function vs(e,t){return 1===e.type?is(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:ms(JSON.stringify(n.text)))+")";var n,r}function hs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ms(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ms(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ys(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function gs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=ys(o.render,c),s.staticRenderFns=o.staticRenderFns.map(function(e){return ys(e,c)}),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var _s,bs,$s=(_s=function(e,t){var n=So(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=rs(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=_s(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:gs(t)}})(Uo).compileToFunctions;function ws(e){return(bs=bs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',bs.innerHTML.indexOf("&#10;")>0}var Cs=!!U&&ws(!1),xs=!!U&&ws(!0),ks=g(function(e){var t=Na(e);return t&&t.innerHTML}),As=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Na(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ks(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=$s(r,{outputSourceRange:!1,shouldDecodeNewlines:Cs,shouldDecodeNewlinesForHref:xs,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return As.call(this,e,t)},wn.compile=$s,module.exports=wn;
\ No newline at end of file
+/*!
+ * Vue.js v2.6.12
+ * (c) 2014-2021 Evan You
+ * Released under the MIT License.
+ */
+var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,C=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function A(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function k(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&k(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every((function(e,n){return E(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return E(e[n],t[n])}))}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M},F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+F.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(pe.prototype,de);var ve=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function he(e){return new pe(void 0,void 0,void 0,String(e))}function me(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ye[e];R(ge,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,a=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&o.observeArray(i),o.dep.notify(),a}))}));var _e=Object.getOwnPropertyNames(ge),be=!0;function $e(e){be=e}var we=function(e){this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?function(e,t){e.__proto__=t}(e,ge):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ge,_e),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof we?n=e.__ob__:be&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new we(e)),t&&n&&n.vmCount++,n}function xe(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&Oe(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&Ce(t),a.notify())}})}}function Ae(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(xe(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Oe(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Oe(t)}we.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)xe(e,t[n])},we.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Se=I.optionMergeStrategies;function Te(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Te(r,i):Ae(e,n,i));return e}function Ne(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Te(r,i):i}:t?e?function(){return Te("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ee(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Le(e,t,n,r){var i=Object.create(e||null);return t?k(i,t):i}Se.data=function(e,t,n){return n?Ne(e,t,n):t&&"function"!=typeof t?e:Ne(e,t)},M.forEach((function(e){Se[e]=Ee})),D.forEach((function(e){Se[e+"s"]=Le})),Se.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in k(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Se.props=Se.methods=Se.inject=Se.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return k(i,e),t&&k(i,t),i},Se.provide=Ne;var je=function(e,t){return void 0===t?e:t};function De(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?k({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=De(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=De(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Se[r]||je;o[r]=i(e[r],t[r],n,r)}return o}function Me(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function Ie(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=He(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=He(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Pe(t.type)?r.call(e):r}(r,i,e);var l=be;$e(!0),Ce(o),$e(l)}return o}var Fe=/^\s*function (\w+)/;function Pe(e){var t=e&&e.toString().match(Fe);return t?t[1]:""}function Re(e,t){return Pe(e)===Pe(t)}function He(e,t){if(!Array.isArray(t))return Re(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Re(t[n],e))return n;return-1}function Be(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){ze(e,r,"errorCaptured hook")}}ze(e,t,n)}finally{fe()}}function Ue(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch((function(e){return Be(e,r,i+" (Promise/async)")})),a._handled=!0)}catch(e){Be(e,r,i)}return a}function ze(e,t,n){if(I.errorHandler)try{return I.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ve(t)}Ve(e)}function Ve(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var Ke,qe=!1,Je=[],We=!1;function Ze(){We=!1;var e=Je.slice(0);Je.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var Ge=Promise.resolve();Ke=function(){Ge.then(Ze),Z&&setTimeout(S)},qe=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ke="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Ze)}:function(){setTimeout(Ze,0)};else{var Xe=1,Ye=new MutationObserver(Ze),Qe=document.createTextNode(String(Xe));Ye.observe(Qe,{characterData:!0}),Ke=function(){Xe=(Xe+1)%2,Qe.data=String(Xe)},qe=!0}function et(e,t){var n;if(Je.push((function(){if(e)try{e.call(t)}catch(e){Be(e,t,"nextTick")}else n&&n(t)})),We||(We=!0,Ke()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var tt=new ie;function nt(e){rt(e,tt),tt.clear()}function rt(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!a(e)||Object.isFrozen(e)||e instanceof pe)){if(e.__ob__){var o=e.__ob__.dep.id;if(t.has(o))return;t.add(o)}if(i)for(n=e.length;n--;)rt(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)rt(e[r[n]],t)}}var it=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function at(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return Ue(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)Ue(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function ot(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=it(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=at(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=it(c)).name,n[c],f.capture)}function st(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=at([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=at([s,c]),o.merged=!0,e[i]=o}function ct(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function lt(e){return i(e)?[he(e)]:Array.isArray(e)?ft(e):void 0}function ut(e){return n(e)&&n(e.text)&&!1===e.isComment}function ft(e,a){var o,s,c,l,u=[];for(o=0;o<e.length;o++)t(s=e[o])||"boolean"==typeof s||(l=u[c=u.length-1],Array.isArray(s)?s.length>0&&(ut((s=ft(s,(a||"")+"_"+o))[0])&&ut(l)&&(u[c]=he(l.text+s[0].text),s.shift()),u.push.apply(u,s)):i(s)?ut(l)?u[c]=he(l.text+s):""!==s&&u.push(he(s)):ut(s)&&ut(l)?u[c]=he(l.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(a)&&(s.key="__vlist"+a+"_"+o+"__"),u.push(s)));return u}function pt(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function dt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(vt)&&delete n[l];return n}function vt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ht(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=mt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=yt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function mt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:lt(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function yt(e,t){return function(){return e[t]}}function gt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function _t(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=k(k({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function bt(e){return Me(this.$options,"filters",e)||N}function $t(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function wt(e,t,n,r,i){var a=I.keyCodes[t]||n;return i&&r&&!I.keyCodes[t]?$t(i,r):a?$t(a,e):r?C(r)!==t:void 0}function Ct(e,t,n,r,i){if(n)if(a(n)){var o;Array.isArray(n)&&(n=O(n));var s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||I.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function xt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||kt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function At(e,t,n){return kt(e,"__once__"+t+(n?"_"+n:""),!0),e}function kt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ot(e[r],t+"_"+r,n);else Ot(e,t,n)}function Ot(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function St(e,t){if(t)if(s(t)){var n=e.on=e.on?k({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function Tt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?Tt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function Nt(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Et(e,t){return"string"==typeof e?t+e:e}function Lt(e){e._o=At,e._n=f,e._s=u,e._l=gt,e._t=_t,e._q=E,e._i=L,e._m=xt,e._f=bt,e._k=wt,e._b=Ct,e._v=he,e._e=ve,e._u=Tt,e._g=St,e._d=Nt,e._p=Et}function jt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=pt(l.inject,a),this.slots=function(){return c.$slots||ht(t.scopedSlots,c.$slots=dt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ht(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ht(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Ht(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Ht(s,e,t,n,r,f)}}function Dt(e,t,n,r,i){var a=me(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Mt(e,t){for(var n in t)e[b(n)]=t[n]}Lt(jt.prototype);var It={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;It.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Xt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){$e(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=Ie(d,v,n,t)}$e(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Gt(t,r,h),l&&(t.$slots=dt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,nn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,an.push(t)):en(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?tn(t,!0):t.$destroy())}},Ft=Object.keys(It);function Pt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=zt;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",(function(){return h(s,o)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j((function(t){e.resolved=Vt(t,i),c?s.length=0:p(!0)})),v=j((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Vt(m.error,i)),n(m.loading)&&(e.loadingComp=Vt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout((function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=ve();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},An(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);ct(o,c,l,u,!0)||ct(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=Ie(u,l,r||e);else n(i.attrs)&&Mt(c,i.attrs),n(i.props)&&Mt(c,i.props);var f=new jt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Dt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=lt(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Dt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Ft.length;n++){var r=Ft[n],i=t[r],a=It[r];i===a||i&&i._merged||(t[r]=i?Rt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Rt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Ht(e,t,o,s,c,l){return(Array.isArray(o)||i(o))&&(c=s,s=o,o=void 0),r(l)&&(c=2),function(e,t,r,i,o){if(n(r)&&n(r.__ob__))return ve();n(r)&&n(r.is)&&(t=r.is);if(!t)return ve();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===o?i=lt(i):1===o&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var l;c=e.$vnode&&e.$vnode.ns||I.getTagNamespace(t),s=I.isReservedTag(t)?new pe(I.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(l=Me(e.$options,"components",t))?new pe(t,r,i,void 0,void 0,e):Pt(l,r,e,i,t)}else s=Pt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Bt(s,c),n(r)&&function(e){a(e.style)&&nt(e.style);a(e.class)&&nt(e.class)}(r),s):ve()}(e,t,o,s,c)}function Bt(e,i,a){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,a=!0),n(e.children))for(var o=0,s=e.children.length;o<s;o++){var c=e.children[o];n(c.tag)&&(t(c.ns)||r(a)&&"svg"!==c.tag)&&Bt(c,i,a)}}var Ut,zt=null;function Vt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Kt(e){return e.isComment&&e.asyncFactory}function qt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Kt(r)))return r}}function Jt(e,t){Ut.$on(e,t)}function Wt(e,t){Ut.$off(e,t)}function Zt(e,t){var n=Ut;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Gt(e,t,n){Ut=e,ot(t,n||{},Jt,Wt,Zt,e),Ut=void 0}var Xt=null;function Yt(e){var t=Xt;return Xt=e,function(){Xt=t}}function Qt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function en(e,t){if(t){if(e._directInactive=!1,Qt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)en(e.$children[n]);nn(e,"activated")}}function tn(e,t){if(!(t&&(e._directInactive=!0,Qt(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);nn(e,"deactivated")}}function nn(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)Ue(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var rn=[],an=[],on={},sn=!1,cn=!1,ln=0;var un=0,fn=Date.now;if(U&&!q){var pn=window.performance;pn&&"function"==typeof pn.now&&fn()>document.createEvent("Event").timeStamp&&(fn=function(){return pn.now()})}function dn(){var e,t;for(un=fn(),cn=!0,rn.sort((function(e,t){return e.id-t.id})),ln=0;ln<rn.length;ln++)(e=rn[ln]).before&&e.before(),t=e.id,on[t]=null,e.run();var n=an.slice(),r=rn.slice();ln=rn.length=an.length=0,on={},sn=cn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,en(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&nn(r,"updated")}}(r),ne&&I.devtools&&ne.emit("flush")}var vn=0,hn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++vn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};hn.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Be(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&nt(e),fe(),this.cleanupDeps()}return e},hn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},hn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},hn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==on[t]){if(on[t]=!0,cn){for(var n=rn.length-1;n>ln&&rn[n].id>e.id;)n--;rn.splice(n+1,0,e)}else rn.push(e);sn||(sn=!0,et(dn))}}(this)},hn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Be(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},hn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},hn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},hn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var mn={enumerable:!0,configurable:!0,get:S,set:S};function yn(e,t,n){mn.get=function(){return this[t][n]},mn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,mn)}function gn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var a=function(a){i.push(a);var o=Ie(a,t,n,e);xe(r,a,o),a in e||yn(e,"_props",a)};for(var o in t)a(o);$e(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Be(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||P(a)||yn(e,"_data",a)}Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new hn(e,o||S,S,_n)),i in e||bn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(e,n,r[i]);else Cn(e,n,r)}}(e,t.watch)}var _n={lazy:!0};function bn(e,t,n){var r=!te();"function"==typeof n?(mn.get=r?$n(t):wn(n),mn.set=S):(mn.get=n.get?r&&!1!==n.cache?$n(t):wn(n.get):S,mn.set=n.set||S),Object.defineProperty(e,t,mn)}function $n(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function wn(e){return function(){return e.call(this,this)}}function Cn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var xn=0;function An(e){var t=e.options;if(e.super){var n=An(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&k(e.extendOptions,r),(t=e.options=De(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function kn(e){this._init(e)}function On(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=De(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)yn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)bn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,D.forEach((function(e){o[e]=n[e]})),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=k({},o.options),i[r]=o,o}}function Sn(e){return e&&(e.Ctor.options.name||e.tag)}function Tn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function Nn(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=Sn(o.componentOptions);s&&!t(s)&&En(n,a,r,i)}}}function En(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=xn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=De(An(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Gt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=dt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Ht(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Ht(t,e,n,r,i,!0)};var a=r&&r.data;xe(t,"$attrs",a&&a.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),nn(n,"beforeCreate"),function(e){var t=pt(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach((function(n){xe(e,n,t[n])})),$e(!0))}(n),gn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),nn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(kn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=Ae,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return Cn(r,e,t,n);(n=n||{}).user=!0;var i=new hn(r,e,t,n);if(n.immediate){ue();try{t.call(r,i.value)}catch(e){Be(e,r,'callback for immediate watcher "'+i.expression+'"')}fe()}return function(){i.teardown()}}}(kn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),i='event handler for "'+e+'"',a=0,o=n.length;a<o;a++)Ue(n[a],t,r,t,i)}return t}}(kn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Yt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){nn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),nn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(kn),function(e){Lt(e.prototype),e.prototype.$nextTick=function(e){return et(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ht(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{zt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Be(n,t,"render"),e=t._vnode}finally{zt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=ve()),e.parent=i,e}}(kn);var Ln=[String,RegExp,Array],jn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Ln,exclude:Ln,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)En(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){Nn(e,(function(e){return Tn(t,e)}))})),this.$watch("exclude",(function(t){Nn(e,(function(e){return!Tn(t,e)}))}))},render:function(){var e=this.$slots.default,t=qt(e),n=t&&t.componentOptions;if(n){var r=Sn(n),i=this.include,a=this.exclude;if(i&&(!r||!Tn(i,r))||a&&r&&Tn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&En(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return I}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:k,mergeOptions:De,defineReactive:xe},e.set=Ae,e.delete=ke,e.nextTick=et,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),D.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,k(e.options.components,jn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=De(this.options,e),this}}(e),On(e),function(e){D.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(kn),Object.defineProperty(kn.prototype,"$isServer",{get:te}),Object.defineProperty(kn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(kn,"FunctionalRenderContext",{value:jt}),kn.version="2.6.12";var Dn=p("style,class"),Mn=p("input,textarea,option,select,progress"),In=p("contenteditable,draggable,spellcheck"),Fn=p("events,caret,typing,plaintext-only"),Pn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Rn="http://www.w3.org/1999/xlink",Hn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Bn=function(e){return Hn(e)?e.slice(6,e.length):""},Un=function(e){return null==e||!1===e};function zn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Vn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Vn(t,r.data));return function(e,t){if(n(e)||n(t))return Kn(e,qn(t));return""}(t.staticClass,t.class)}function Vn(e,t){return{staticClass:Kn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Kn(e,t){return e?t?e+" "+t:e:t||""}function qn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=qn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Jn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Wn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(e){return Wn(e)||Zn(e)};var Xn=Object.create(null);var Yn=p("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Jn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Yn(i)&&Yn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function ar(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var or={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===nr,o=t===nr,s=lr(e.data.directives,e.context),c=lr(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)fr(l[n],"inserted",t,e)};a?st(t,"insert",f):f()}u.length&&st(t,"postpatch",(function(){for(var n=0;n<u.length;n++)fr(u[n],"componentUpdated",t,e)}));if(!a)for(n in s)c[n]||fr(s[n],"unbind",e,e,o)}(e,t)}var cr=Object.create(null);function lr(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[ur(r)]=r,r.def=Me(t.$options,"directives",r.name);return i}function ur(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Be(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,or];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=k({},l)),l)o=l[a],c[a]!==o&&vr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&vr(s,"value",l.value),c)t(l[a])&&(Hn(a)?s.removeAttributeNS(Rn,Bn(a)):In(a)||s.removeAttribute(a))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):Pn(t)?Un(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):In(t)?e.setAttribute(t,function(e,t){return Un(t)||"false"===t?"false":"contenteditable"===e&&Fn(t)?t:"true"}(t,n)):Hn(t)?Un(n)?e.removeAttributeNS(Rn,Bn(t)):e.setAttributeNS(Rn,t,n):hr(e,t,n)}function hr(e,t,n){if(Un(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=zn(r),c=i._transitionClasses;n(c)&&(s=Kn(s,qn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},Ar=/[\w).+\-_$\]]/;function kr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&Ar.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=Or(i,a[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Lr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function jr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Dr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Dr("!",n,c)),i.once&&(delete i.once,n=Dr("~",n,c)),i.passive&&(delete i.passive,n=Dr("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Rr({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return kr(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,a="$$v",o=a;r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var s=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?qr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))qr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function qr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var Jr;function Wr(e,t,n){var r=Jr;return function i(){var a=t.apply(null,arguments);null!==a&&Xr(e,i,n,r)}}var Zr=qe&&!(X&&Number(X[1])<=53);function Gr(e,t,n,r){if(Zr){var i=un,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Jr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Xr(e,t,n,r){(r||Jr).removeEventListener(e,t._wrapper||t,n)}function Yr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Jr=r.elm,function(e){if(n(e.__r)){var t=q?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),ot(i,a,Gr,Xr,Wr,r.context),Jr=void 0}}var Qr,ei={create:Yr,update:Yr};function ti(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=k({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ni(o,l)&&(o.value=l)}else if("innerHTML"===i&&Zn(o.tagName)&&t(o.innerHTML)){(Qr=Qr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Qr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ni(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ri={create:ti,update:ti},ii=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function ai(e){var t=oi(e.style);return e.staticStyle?k(e.staticStyle,t):t}function oi(e){return Array.isArray(e)?O(e):"string"==typeof e?ii(e):e}var si,ci=/^--/,li=/\s*!important$/,ui=function(e,t,n){if(ci.test(t))e.style.setProperty(t,n);else if(li.test(n))e.style.setProperty(C(t),n.replace(li,""),"important");else{var r=pi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},fi=["Webkit","Moz","ms"],pi=g((function(e){if(si=si||document.createElement("div").style,"filter"!==(e=b(e))&&e in si)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<fi.length;n++){var r=fi[n]+t;if(r in si)return r}}));function di(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=oi(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?k({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ai(i.data))&&k(r,n);(n=ai(e.data))&&k(r,n);for(var a=e;a=a.parent;)a.data&&(n=ai(a.data))&&k(r,n);return r}(r,!0);for(s in f)t(d[s])&&ui(c,s,"");for(s in d)(o=d[s])!==f[s]&&ui(c,s,null==o?"":o)}}var vi={create:di,update:di},hi=/\s+/;function mi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,yi(e.name||"v")),k(t,e),t}return"string"==typeof e?yi(e):void 0}}var yi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),gi="transition",_i="transitionend",bi="animation",$i="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(gi="WebkitTransition",_i="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(bi="WebkitAnimation",$i="webkitAnimationEnd"));var wi=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ci(e){wi((function(){wi(e)}))}function xi(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function ki(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[gi+"Delay"]||"").split(", "),a=(r[gi+"Duration"]||"").split(", "),o=Si(i,a),s=(r[bi+"Delay"]||"").split(", "),c=(r[bi+"Duration"]||"").split(", "),l=Si(s,c),u=0,f=0;"transition"===t?o>0&&(n="transition",u=o,f=a.length):"animation"===t?l>0&&(n="animation",u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?"transition":"animation":null)?"transition"===n?a.length:c.length:0;var p="transition"===n&&Oi.test(r[gi+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s="transition"===i?_i:$i,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var Oi=/\b(transform|all)(,|$)/;function Si(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Ti(t)+Ti(e[n])})))}function Ti(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ni(e){return"number"==typeof e&&!isNaN(e)}function Ei(e){if(t(e))return!1;var r=e.fns;return n(r)?Ei(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Li(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=mi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Xt,k=Xt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Ei(L),R=i._enterCb=j((function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||st(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(xi(i,S),xi(i,T),Ci((function(){Ai(i,S),R.cancelled||(xi(i,N),P||(Ni(I)?setTimeout(R,I):ki(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var ji=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<rr.length;++a)for(s[rr[a]]=[],o=0;o<c.length;++o)n(c[o][rr[a]])&&s[rr[a]].push(c[o][rr[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=me(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){var a,o=e;for(;o.componentInstance;)if(n(a=(o=o.componentInstance._vnode).data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](nr,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(a=e.data.hook)&&(n(a.create)&&a.create(nr,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Xt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&ir(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=me(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=ar(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):ir(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function A(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var k=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(t,i);break}!v&&c.class&&nt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute("data-server-rendered")&&(e.removeAttribute("data-server-rendered"),a=!0),r(a)&&O(e,i,p))return A(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var k=1;k<C.fns.length;k++)C.fns[k]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return A(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ei,ri,vi,U?{create:Li,activate:Li,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=mi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Ei(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(xi(i,l),xi(i,p),Ci((function(){Ai(i,l),w.cancelled||(xi(i,u),b||(Ni($)?setTimeout(w,$):ki(i,c,w)))}))),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(pr)});J&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Bi(e,"input")}));var Di={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?st(n,"postpatch",(function(){Di.componentUpdated(e,t,n)})):Mi(e,t,n.context),e._vOptions=[].map.call(e.options,Pi)):("textarea"===n.tag||Yn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Ri),e.addEventListener("compositionend",Hi),e.addEventListener("change",Hi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Mi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Pi);if(i.some((function(e,t){return!E(e,r[t])})))(e.multiple?t.value.some((function(e){return Fi(e,i)})):t.value!==t.oldValue&&Fi(t.value,i))&&Bi(e,"change")}}};function Mi(e,t,n){Ii(e,t),(q||W)&&setTimeout((function(){Ii(e,t)}),0)}function Ii(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Pi(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Pi(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Fi(e,t){return t.every((function(t){return!E(t,e)}))}function Pi(e){return"_value"in e?e._value:e.value}function Ri(e){e.target.composing=!0}function Hi(e){e.target.composing&&(e.target.composing=!1,Bi(e.target,"input"))}function Bi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var Ui=/\s+/;function zi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ui).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ui).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function Ki(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,qi(e.name||"v")),k(t,e),t}return"string"==typeof e?qi(e):void 0}}var qi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),Ji=U&&!J,Wi="transition",Zi="transitionend",Gi="animation",Xi="animationend";Ji&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Wi="WebkitTransition",Zi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Gi="WebkitAnimation",Xi="webkitAnimationEnd"));var Yi=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Qi(e){Yi((function(){Yi(e)}))}function ea(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),zi(e,t))}function ta(e,t){e._transitionClasses&&h(e._transitionClasses,t),Vi(e,t)}function na(e,t,n){var r=ia(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s="transition"===i?Zi:Xi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var ra=/\b(transform|all)(,|$)/;function ia(e,t){var n,r=window.getComputedStyle(e),i=(r[Wi+"Delay"]||"").split(", "),a=(r[Wi+"Duration"]||"").split(", "),o=aa(i,a),s=(r[Gi+"Delay"]||"").split(", "),c=(r[Gi+"Duration"]||"").split(", "),l=aa(s,c),u=0,f=0;return"transition"===t?o>0&&(n="transition",u=o,f=a.length):"animation"===t?l>0&&(n="animation",u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?"transition":"animation":null)?"transition"===n?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:"transition"===n&&ra.test(r[Wi+"Property"])}}function aa(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return oa(t)+oa(e[n])})))}function oa(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function sa(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=Ki(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Xt,k=Xt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=la(L),R=i._enterCb=j((function(){F&&(ta(i,N),ta(i,T)),R.cancelled?(F&&ta(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||st(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(ea(i,S),ea(i,T),Qi((function(){ta(i,S),R.cancelled||(ea(i,N),P||(ca(I)?setTimeout(R,I):na(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function ca(e){return"number"==typeof e&&!isNaN(e)}function la(e){if(t(e))return!1;var r=e.fns;return n(r)?la(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ua(e){return!e.componentInstance||e.data&&e.data.transition?e:ua(e.componentInstance._vnode)}var fa={model:Di,show:{bind:function(e,t,n){var r=t.value,i=(n=ua(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,sa(n,(function(){e.style.display=a}))):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=ua(i)).data&&i.data.transition?(i.data.show=!0,o?sa(i,(function(){e.style.display=e.__vOriginalDisplay})):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=Ki(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=la(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ta(i,u),ta(i,p)),w.cancelled?(_&&ta(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ea(i,l),ea(i,p),Qi((function(){ta(i,l),w.cancelled||(ea(i,u),b||(ca($)?setTimeout(w,$):na(i,c,w)))}))),v&&v(i,w),_||b||w())}}(i,(function(){e.style.display="none"}))):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},pa={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function da(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?da(qt(t.children)):e}function va(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var a in i)t[b(a)]=i[a];return t}function ha(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var ma=function(e){return e.tag||Kt(e)},ya=function(e){return"show"===e.name},ga={name:"transition",props:pa,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(ma)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=da(a);if(!o)return a;if(this._leaving)return ha(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=va(this),l=this._vnode,u=da(l);if(o.data.directives&&o.data.directives.some(ya)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Kt(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=k({},c);if("out-in"===r)return this._leaving=!0,st(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),ha(e,a);if("in-out"===r){if(Kt(o))return l;var p,d=function(){p()};st(c,"afterEnter",d),st(c,"enterCancelled",d),st(f,"delayLeave",(function(e){p=e}))}}return a}}},_a=k({tag:String,moveClass:String},pa);function ba(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function $a(e){e.data.newPos=e.elm.getBoundingClientRect()}function wa(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete _a.mode;var Ca={Transition:ga,TransitionGroup:{props:_a,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Yt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=va(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(a.push(c),n[c.key]=c,(c.data||(c.data={})).transition=o)}if(r){for(var l=[],u=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=o,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?l.push(p):u.push(p)}this.kept=e(t,null,l),this.removed=u}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(ba),e.forEach($a),e.forEach(wa),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;ea(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Zi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Zi,e),n._moveCb=null,ta(n,t))})}})))},methods:{hasMove:function(e,t){if(!Ji)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){Vi(n,e)})),zi(n,t),n.style.display="none",this.$el.appendChild(n);var r=ia(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};kn.config.mustUseProp=function(e,t,n){return"value"===n&&Mn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},kn.config.isReservedTag=Gn,kn.config.isReservedAttr=Dn,kn.config.getTagNamespace=function(e){return Zn(e)?"svg":"math"===e?"math":void 0},kn.config.isUnknownElement=function(e){if(!U)return!0;if(Gn(e))return!1;if(e=e.toLowerCase(),null!=Xn[e])return Xn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Xn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Xn[e]=/HTMLUnknownElement/.test(t.toString())},k(kn.options.directives,fa),k(kn.options.components,Ca),kn.prototype.__patch__=U?ji:S,kn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),nn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new hn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&nn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,nn(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout((function(){I.devtools&&ne&&ne.emit("init",kn)}),0);var xa=p("input,textarea,option,select,progress"),Aa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),ka=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Oa(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Sa=/\{\{((?:.|\r?\n)+?)\}\}/g,Ta=/[-.*+?^${}()|[\]\/\\]/g,Na=g((function(e){var t=e[0].replace(Ta,"\\$&"),n=e[1].replace(Ta,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var Ea={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var La,ja={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ii(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Da=function(e){return(La=La||document.createElement("div")).innerHTML=e,La.textContent},Ma=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ia=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Fa=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Pa="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+F.source+"]*",Ra="((?:"+Pa+"\\:)?"+Pa+")",Ha=new RegExp("^<"+Ra),Ba=/^\s*(\/?)>/,Ua=new RegExp("^<\\/"+Ra+"[^>]*>"),za=/^<!DOCTYPE [^>]+>/i,Va=/^<!\--/,Ka=/^<!\[/,qa=p("script,style,textarea",!0),Ja={},Wa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Za=/&(?:lt|gt|quot|amp|#39);/g,Ga=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Xa=p("pre,textarea",!0),Ya=function(e,t){return e&&Xa(e)&&"\n"===t[0]};function Qa(e,t){var n=t?Ga:Za;return e.replace(n,(function(e){return Wa[e]}))}var eo,to,no,ro,io,ao,oo,so,co=/^@|^v-on:/,lo=/^v-|^@|^:|^#/,uo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,fo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,po=/^\(|\)$/g,vo=/^\[.*\]$/,ho=/:(.*)$/,mo=/^:|^\.|^v-bind:/,yo=/\.[^.\]]+(?=[^\]]*$)/g,go=/^v-slot(:|$)|^#/,_o=/[\r\n]/,bo=/[ \f\t\r\n]+/g,$o=g(Da);function wo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:To(t),rawAttrsMap:{},parent:n,children:[]}}function Co(e,t){eo=t.warn||Sr,ao=t.isPreTag||T,oo=t.mustUseProp||T,so=t.getTagNamespace||T,t.isReservedTag,no=Tr(t.modules,"transformNode"),ro=Tr(t.modules,"preTransformNode"),io=Tr(t.modules,"postTransformNode"),to=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=xo(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&ko(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&ko(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter((function(e){return!e.slotScope})),u(e),e.pre&&(s=!1),ao(e.tag)&&(c=!1);for(var f=0;f<io.length;f++)io[f](e,t)}function u(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&qa(r)){var l=0,u=r.toLowerCase(),f=Ja[u]||(Ja[u]=new RegExp("([\\s\\S]*?)(</"+u+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return l=r.length,qa(u)||"noscript"===u||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ya(u,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,k(u,c-l,c)}else{var d=e.indexOf("<");if(0===d){if(Va.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(Ka.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(za);if(m){C(m[0].length);continue}var y=e.match(Ua);if(y){var g=c;C(y[0].length),k(y[1],g,c);continue}var _=x();if(_){A(_),Ya(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Ua.test($)||Ha.test($)||Va.test($)||Ka.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Ha);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(Ba))&&(r=e.match(Fa)||e.match(Ia));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function A(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Ma(n)&&k(r),s(n)&&r===n&&k(n));for(var l=o(n)||!!c,u=e.attrs.length,f=new Array(u),p=0;p<u;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Qa(v,h)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,l,e.start,e.end)}function k(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}k()}(e,{warn:eo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||so(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];No.test(r.name)||(r.name=r.name.replace(Eo,""),t.push(r))}return t}(a));var d,v=wo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<ro.length;h++)v=ro[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),ao(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Ao(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,ko(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l,u,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:$o(e):f.length?o?"condense"===o&&_o.test(e)?"":" ":a?" ":"":"")c||"condense"!==o||(e=e.replace(bo," ")),!s&&" "!==e&&(l=function(e,t){var n=t?Na(t):Sa;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=kr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,to))?u={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(u={type:3,text:e}),u&&f.push(u)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function xo(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,go);if(r){var i=Oo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||"_empty_"}}else{var s=Pr(e,go);if(s){var c=e.scopedSlots||(e.scopedSlots={}),l=Oo(s),u=l.name,f=l.dynamic,p=c[u]=wo("template",[],e);p.slotTarget=u,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||"_empty_",e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<no.length;i++)e=no[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,lo.test(r))if(e.hasBindings=!0,(o=So(r.replace(lo,"")))&&(r=r.replace(yo,"")),mo.test(r))r=r.replace(mo,""),a=kr(a),(c=vo.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Br(a,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&oo(e.tag,e.attrsMap.type,r)?Nr(e,r,a,l[t],c):Er(e,r,a,l[t],c);else if(co.test(r))r=r.replace(co,""),(c=vo.test(r))&&(r=r.slice(1,-1)),Mr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(lo,"")).match(ho),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),vo.test(f)&&(f=f.slice(1,-1),c=!0)),jr(e,r,i,a,f,c,o,l[t])}else Er(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&oo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",l[t])}(e),e}function Ao(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(uo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(po,""),i=r.match(fo);i?(n.alias=r.replace(fo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&k(e,n)}}function ko(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Oo(e){var t=e.name.replace(go,"");return t||"#"!==e.name[0]&&(t="default"),vo.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function So(e){var t=e.match(yo);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function To(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var No=/^xmlns:NS\d+/,Eo=/^NS\d+:/;function Lo(e){return wo(e.tag,e.attrsList.slice(),e.parent)}var jo=[Ea,ja,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Ir(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Fr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=Lo(e);Ao(c),Lr(c,"type","checkbox"),xo(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+a,ko(c,{exp:c.if,block:c});var l=Lo(e);Fr(l,"v-for",!0),Lr(l,"type","radio"),xo(l,t),ko(c,{exp:"("+n+")==='radio'"+a,block:l});var u=Lo(e);return Fr(u,"v-for",!0),Lr(u,":type",n),xo(u,t),ko(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}];var Do,Mo,Io={expectHTML:!0,modules:jo,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",a=Ir(e,"true-value")||"true",o=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?"__r":"input",u="$event.target.value";s&&(u="$event.target.value.trim()");o&&(u="_n("+u+")");var f=Br(t,u);c&&(f="if($event.target.composing)return;"+f);Nr(e,"value","("+t+")"),Mr(e,l,f,null,!0),(s||o)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!I.isReservedTag(a))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&xa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Aa(e)||ka(e)},getTagNamespace:function(e){return ka(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(jo)},Fo=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function Po(e,t){e&&(Do=Fo(t.staticKeys||""),Mo=t.isReservedTag||T,Ro(e),Ho(e,!1))}function Ro(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Mo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Do)))}(e),1===e.type){if(!Mo(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Ro(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++){var o=e.ifConditions[i].block;Ro(o),o.static||(e.static=!1)}}}function Ho(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)Ho(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++)Ho(e.ifConditions[i].block,t)}}var Bo=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Uo=/\([^)]*?\);*$/,zo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Vo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ko={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},qo=function(e){return"if("+e+")return null;"},Jo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:qo("$event.target !== $event.currentTarget"),ctrl:qo("!$event.ctrlKey"),shift:qo("!$event.shiftKey"),alt:qo("!$event.altKey"),meta:qo("!$event.metaKey"),left:qo("'button' in $event && $event.button !== 0"),middle:qo("'button' in $event && $event.button !== 1"),right:qo("'button' in $event && $event.button !== 2")};function Wo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Zo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Zo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return Zo(e)})).join(",")+"]";var t=zo.test(e.value),n=Bo.test(e.value),r=zo.test(e.value.replace(Uo,""));if(e.modifiers){var i="",a="",o=[];for(var s in e.modifiers)if(Jo[s])a+=Jo[s],Vo[s]&&o.push(s);else if("exact"===s){var c=e.modifiers;a+=qo(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else o.push(s);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Go).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Go(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Vo[e],r=Ko[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Xo={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Yo=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=k(k({},Xo),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Qo(e,t){var n=new Yo(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":es(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function es(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return ts(e,t);if(e.once&&!e.onceProcessed)return ns(e,t);if(e.for&&!e.forProcessed)return as(e,t);if(e.if&&!e.ifProcessed)return rs(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ls(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?ps((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ls(t,n,!0);return"_c("+e+","+os(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=os(e,t));var i=e.inlineTemplate?null:ls(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ls(e,t)||"void 0"}function ts(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+es(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function ns(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return rs(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+es(e,t)+","+t.onceId+++","+n+")":es(e,t)}return ts(e,t)}function rs(e,t,n,r){return e.ifProcessed=!0,is(e.ifConditions.slice(),t,n,r)}function is(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+a(i.block)+":"+is(e,t,n,r):""+a(i.block);function a(e){return n?n(e,t):e.once?ns(e,t):es(e,t)}}function as(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||es)(e,t)+"})"}function os(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+ps(e.attrs)+","),e.props&&(n+="domProps:"+ps(e.props)+","),e.events&&(n+=Wo(e.events,!1)+","),e.nativeEvents&&(n+=Wo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||ss(n)})),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&"_empty_"!==a.slotScope||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map((function(e){return cs(t[e],n)})).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Qo(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+ps(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function ss(e){return 1===e.type&&("slot"===e.tag||e.children.some(ss))}function cs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return rs(e,t,cs,"null");if(e.for&&!e.forProcessed)return as(e,t,cs);var r="_empty_"===e.slotScope?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ls(e,t)||"undefined")+":undefined":ls(e,t)||"undefined":es(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ls(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||es)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(us(i)||i.ifConditions&&i.ifConditions.some((function(e){return us(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||fs;return"["+a.map((function(e){return l(e,t)})).join(",")+"]"+(c?","+c:"")}}function us(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function fs(e,t){return 1===e.type?es(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:ds(JSON.stringify(e.text)))+")"}(e)}function ps(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ds(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ds(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function vs(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function hs(e){var t=Object.create(null);return function(n,r,i){(r=k({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=vs(o.render,c),s.staticRenderFns=o.staticRenderFns.map((function(e){return vs(e,c)})),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ms,ys,gs=(ms=function(e,t){var n=Co(e.trim(),t);!1!==t.optimize&&Po(n,t);var r=Qo(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=k(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=ms(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:hs(t)}})(Io).compileToFunctions;function _s(e){return(ys=ys||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ys.innerHTML.indexOf("&#10;")>0}var bs=!!U&&_s(!1),$s=!!U&&_s(!0),ws=g((function(e){var t=Oa(e);return t&&t.innerHTML})),Cs=kn.prototype.$mount;kn.prototype.$mount=function(e,t){if((e=e&&Oa(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ws(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=gs(r,{outputSourceRange:!1,shouldDecodeNewlines:bs,shouldDecodeNewlinesForHref:$s,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return Cs.call(this,e,t)},kn.compile=gs,module.exports=kn;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index 12289be017a..104cf11eceb 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -3,7 +3,7 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-var emptyObject = Object.freeze({});
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 function isUndef(v) {
@@ -39,7 +39,7 @@ function isObject(obj) {
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
+const _toString = Object.prototype.toString;
 function toRawType(value) {
     return _toString.call(value).slice(8, -1);
 }
@@ -57,7 +57,7 @@ function isRegExp(v) {
  * Check if val is a valid array index.
  */
 function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
+    const n = parseFloat(String(val));
     return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
 function isPromise(val) {
@@ -80,7 +80,7 @@ function toString(val) {
  * If the conversion fails, return original string.
  */
 function toNumber(val) {
-    var n = parseFloat(val);
+    const n = parseFloat(val);
     return isNaN(n) ? val : n;
 }
 /**
@@ -88,27 +88,27 @@ function toNumber(val) {
  * is in that map.
  */
 function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
         map[list[i]] = true;
     }
-    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
 function remove$2(arr, item) {
     if (arr.length) {
-        var index = arr.indexOf(item);
+        const index = arr.indexOf(item);
         if (index > -1) {
             return arr.splice(index, 1);
         }
@@ -117,7 +117,7 @@ function remove$2(arr, item) {
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
 }
@@ -125,30 +125,30 @@ function hasOwn(obj, key) {
  * Create a cached version of a pure function.
  */
 function cached(fn) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function cachedFn(str) {
-        var hit = cache[str];
+        const hit = cache[str];
         return hit || (cache[str] = fn(str));
     };
 }
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
 /**
  * Capitalize a string.
  */
-var capitalize = cached(function (str) {
+const capitalize = cached((str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
 /**
@@ -161,7 +161,7 @@ var hyphenate = cached(function (str) {
 /* istanbul ignore next */
 function polyfillBind(fn, ctx) {
     function boundFn(a) {
-        var l = arguments.length;
+        const l = arguments.length;
         return l
             ? l > 1
                 ? fn.apply(ctx, arguments)
@@ -175,14 +175,14 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
 function toArray(list, start) {
     start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
+    let i = list.length - start;
+    const ret = new Array(i);
     while (i--) {
         ret[i] = list[i + start];
     }
@@ -192,7 +192,7 @@ function toArray(list, start) {
  * Mix properties into target object.
  */
 function extend(to, _from) {
-    for (var key in _from) {
+    for (const key in _from) {
         to[key] = _from[key];
     }
     return to;
@@ -201,8 +201,8 @@ function extend(to, _from) {
  * Merge an Array of Objects into a single Object.
  */
 function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
         if (arr[i]) {
             extend(res, arr[i]);
         }
@@ -219,18 +219,18 @@ function noop(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
+const identity = (_) => _;
 /**
  * Generate a string containing static keys from compiler modules.
  */
 function genStaticKeys$1(modules) {
     return modules
-        .reduce(function (keys, m) {
+        .reduce((keys, m) => {
         return keys.concat(m.staticKeys || []);
     }, [])
         .join(',');
@@ -242,15 +242,15 @@ function genStaticKeys$1(modules) {
 function looseEqual(a, b) {
     if (a === b)
         return true;
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
     if (isObjectA && isObjectB) {
         try {
-            var isArrayA = Array.isArray(a);
-            var isArrayB = Array.isArray(b);
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
             if (isArrayA && isArrayB) {
                 return (a.length === b.length &&
-                    a.every(function (e, i) {
+                    a.every((e, i) => {
                         return looseEqual(e, b[i]);
                     }));
             }
@@ -258,10 +258,10 @@ function looseEqual(a, b) {
                 return a.getTime() === b.getTime();
             }
             else if (!isArrayA && !isArrayB) {
-                var keysA = Object.keys(a);
-                var keysB = Object.keys(b);
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
                 return (keysA.length === keysB.length &&
-                    keysA.every(function (key) {
+                    keysA.every((key) => {
                         return looseEqual(a[key], b[key]);
                     }));
             }
@@ -288,7 +288,7 @@ function looseEqual(a, b) {
  * contain an object of the same shape), or -1 if it is not present.
  */
 function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
+    for (let i = 0; i < arr.length; i++) {
         if (looseEqual(arr[i], val))
             return i;
     }
@@ -298,7 +298,7 @@ function looseIndexOf(arr, val) {
  * Ensure a function is called only once.
  */
 function once(fn) {
-    var called = false;
+    let called = false;
     return function () {
         if (!called) {
             called = true;
@@ -307,9 +307,9 @@ function once(fn) {
     };
 }
 
-var SSR_ATTR = 'data-server-rendered';
-var ASSET_TYPES = ['component', 'directive', 'filter'];
-var LIFECYCLE_HOOKS = [
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
     'beforeCreate',
     'created',
     'beforeMount',
@@ -407,12 +407,12 @@ var config = {
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Check if a string starts with $ or _
  */
 function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
+    const c = (str + '').charCodeAt(0);
     return c === 0x24 || c === 0x5f;
 }
 /**
@@ -429,14 +429,14 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
     }
-    var segments = path.split('.');
+    const segments = path.split('.');
     return function (obj) {
-        for (var i = 0; i < segments.length; i++) {
+        for (let i = 0; i < segments.length; i++) {
             if (!obj)
                 return;
             obj = obj[segments[i]];
@@ -446,33 +446,33 @@ function parsePath(path) {
 }
 
 // can we use __proto__?
-var hasProto = '__proto__' in {};
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
+const inBrowser = typeof window !== 'undefined';
 // @ts-ignore
-var inWeex = 
+const inWeex = 
 // @ts-ignore
 typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
 // @ts-ignore
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
 (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 UA && /chrome\/\d+/.test(UA) && !isEdge;
 UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
 // @ts-ignore
-var nativeWatch = {}.watch;
-var supportsPassive = false;
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
     try {
-        var opts = {};
+        const opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -484,8 +484,8 @@ if (inBrowser) {
 }
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
+let _isServer;
+const isServerRendering = () => {
     if (_isServer === undefined) {
         /* istanbul ignore if */
         if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -502,68 +502,65 @@ var isServerRendering = function () {
 };
 // detect devtools
 // @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
 }
-var hasSymbol = typeof Symbol !== 'undefined' &&
+const hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
+let _Set; // $flow-disable-line
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
     // use native Set when available.
     _Set = Set;
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
-        function Set() {
+    _Set = class Set {
+        constructor() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function (key) {
+        has(key) {
             return this.set[key] === true;
-        };
-        Set.prototype.add = function (key) {
+        }
+        add(key) {
             this.set[key] = true;
-        };
-        Set.prototype.clear = function () {
+        }
+        clear() {
             this.set = Object.create(null);
-        };
-        return Set;
-    }());
+        }
+    };
 }
 
-var warn$2 = noop;
-var tip = noop;
-var generateComponentTrace; // work around flow check
-var formatComponentName;
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
-    warn$2 = function (msg, vm) {
-        var trace = vm ? generateComponentTrace(vm) : '';
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
         }
     };
-    tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
-            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
         }
     };
-    formatComponentName = function (vm, includeFile) {
+    formatComponentName = (vm, includeFile) => {
         if (vm.$root === vm) {
             return '<Root>';
         }
-        var options = 
+        const options = 
         // @ts-ignore
         typeof vm === 'function' && vm.cid != null
             ? // @ts-ignore
@@ -572,17 +569,17 @@ var formatComponentName;
                 ? // @ts-ignore
                     vm.$options || vm.constructor.options
                 : vm;
-        var name = options.name || options._componentTag;
-        var file = options.__file;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
         if (!name && file) {
-            var match = file.match(/([^/\\]+)\.vue$/);
+            const match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
     };
-    var repeat_1 = function (str, n) {
-        var res = '';
+    const repeat = (str, n) => {
+        let res = '';
         while (n) {
             if (n % 2 === 1)
                 res += str;
@@ -592,14 +589,14 @@ var formatComponentName;
         }
         return res;
     };
-    generateComponentTrace = function (vm) {
+    generateComponentTrace = (vm) => {
         // @ts-ignore
         if (vm._isVue && vm.$parent) {
-            var tree = [];
-            var currentRecursiveSequence = 0;
+            const tree = [];
+            let currentRecursiveSequence = 0;
             while (vm) {
                 if (tree.length > 0) {
-                    var last = tree[tree.length - 1];
+                    const last = tree[tree.length - 1];
                     if (last.constructor === vm.constructor) {
                         currentRecursiveSequence++;
                         vm = vm.$parent;
@@ -615,60 +612,57 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return `\n\n(found in ${formatComponentName(vm)})`;
         }
     };
 }
 
-var uid$2 = 0;
+let uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
+class Dep {
+    constructor() {
         this.id = uid$2++;
         this.subs = [];
     }
-    Dep.prototype.addSub = function (sub) {
+    addSub(sub) {
         this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
+    }
+    removeSub(sub) {
         remove$2(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
+    }
+    depend() {
         if (Dep.target) {
             Dep.target.addDep(this);
         }
-    };
-    Dep.prototype.notify = function () {
+    }
+    notify() {
         // stabilize the subscriber list first
-        var subs = this.subs.slice();
+        const subs = this.subs.slice();
         if (!config.async) {
             // subs aren't sorted in scheduler if not running async
             // we need to sort them now to make sure they fire in correct
             // order
-            subs.sort(function (a, b) { return a.id - b.id; });
+            subs.sort((a, b) => a.id - b.id);
         }
-        for (var i = 0, l = subs.length; i < l; i++) {
+        for (let i = 0, l = subs.length; i < l; i++) {
             subs[i].update();
         }
-    };
-    return Dep;
-}());
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-var targetStack = [];
+const targetStack = [];
 function pushTarget(target) {
     targetStack.push(target);
     Dep.target = target;
@@ -678,8 +672,8 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+class VNode {
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
         this.tag = tag;
         this.data = data;
         this.children = children;
@@ -704,20 +698,14 @@ var VNode = /** @class */ (function () {
         this.asyncMeta = undefined;
         this.isAsyncPlaceholder = false;
     }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
-var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
-    var node = new VNode();
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = '') => {
+    const node = new VNode();
     node.text = text;
     node.isComment = true;
     return node;
@@ -730,7 +718,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    var cloned = new VNode(
+    const cloned = new VNode(
     //@ts-expect-error void type not valid here
     vnode.tag, vnode.data, 
     // #7975
@@ -753,9 +741,9 @@ function cloneVNode(vnode) {
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-var methodsToPatch = [
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
     'push',
     'pop',
     'shift',
@@ -769,15 +757,11 @@ var methodsToPatch = [
  */
 methodsToPatch.forEach(function (method) {
     // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var result = original.apply(this, args);
-        var ob = this.__ob__;
-        var inserted;
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
         switch (method) {
             case 'push':
             case 'unshift':
@@ -795,12 +779,12 @@ methodsToPatch.forEach(function (method) {
     });
 });
 
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-var shouldObserve = true;
+let shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
@@ -810,8 +794,8 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
+class Observer {
+    constructor(value) {
         this.value = value;
         this.dep = new Dep();
         this.vmCount = 0;
@@ -834,22 +818,21 @@ var Observer = /** @class */ (function () {
      * getter/setters. This method should only be called when
      * value type is Object.
      */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
             defineReactive(obj, keys[i]);
         }
-    };
+    }
     /**
      * Observe a list of Array items.
      */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
             observe(items[i]);
         }
-    };
-    return Observer;
-}());
+    }
+}
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -866,8 +849,8 @@ function protoAugment(target, src) {
  */
 /* istanbul ignore next */
 function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-        var key = keys[i];
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
         def(target, key, src[key]);
     }
 }
@@ -880,7 +863,7 @@ function observe(value, asRootData) {
     if (!isObject(value) || value instanceof VNode) {
         return;
     }
-    var ob;
+    let ob;
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
@@ -900,23 +883,23 @@ function observe(value, asRootData) {
  * Define a reactive property on an Object.
  */
 function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
         return;
     }
     // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
+    const getter = property && property.get;
+    const setter = property && property.set;
     if ((!getter || setter) && arguments.length === 2) {
         val = obj[key];
     }
-    var childOb = !shallow && observe(val);
+    let childOb = !shallow && observe(val);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
         get: function reactiveGetter() {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             if (Dep.target) {
                 dep.depend();
                 if (childOb) {
@@ -929,7 +912,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             return value;
         },
         set: function reactiveSetter(newVal) {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             /* eslint-disable no-self-compare */
             if (newVal === value || (newVal !== newVal && value !== value)) {
                 return;
@@ -959,7 +942,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
  */
 function set(target, key, val) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -970,7 +953,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    var ob = target.__ob__;
+    const ob = target.__ob__;
     // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
@@ -990,13 +973,13 @@ function set(target, key, val) {
  */
 function del(target, key) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
         return;
     }
-    var ob = target.__ob__;
+    const ob = target.__ob__;
     //@ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
@@ -1017,7 +1000,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1031,14 +1014,14 @@ function dependArray(value) {
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn$2("option \"" + key + "\" can only be used during instance " +
+            warn$2(`option "${key}" can only be used during instance ` +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1050,11 +1033,11 @@ var strats = config.optionMergeStrategies;
 function mergeData(to, from) {
     if (!from)
         return to;
-    var key, toVal, fromVal;
-    var keys = hasSymbol
+    let key, toVal, fromVal;
+    const keys = hasSymbol
         ? Reflect.ownKeys(from)
         : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
+    for (let i = 0; i < keys.length; i++) {
         key = keys[i];
         // in case the object is already observed...
         if (key === '__ob__')
@@ -1100,8 +1083,8 @@ function mergeDataOrFn(parentVal, childVal, vm) {
     else {
         return function mergedInstanceDataFn() {
             // instance merge
-            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
             if (instanceData) {
                 return mergeData(instanceData, defaultData);
             }
@@ -1127,7 +1110,7 @@ strats.data = function (parentVal, childVal, vm) {
  * Hooks and props are merged as arrays.
  */
 function mergeHook$1(parentVal, childVal) {
-    var res = childVal
+    const res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : Array.isArray(childVal)
@@ -1137,15 +1120,15 @@ function mergeHook$1(parentVal, childVal) {
     return res ? dedupeHooks(res) : res;
 }
 function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
         if (res.indexOf(hooks[i]) === -1) {
             res.push(hooks[i]);
         }
     }
     return res;
 }
-LIFECYCLE_HOOKS.forEach(function (hook) {
+LIFECYCLE_HOOKS.forEach((hook) => {
     strats[hook] = mergeHook$1;
 });
 /**
@@ -1156,7 +1139,7 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * options and parent options.
  */
 function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
+    const res = Object.create(parentVal || null);
     if (childVal) {
         assertObjectType(key, childVal, vm);
         return extend(res, childVal);
@@ -1190,16 +1173,16 @@ strats.watch = function (parentVal, childVal, vm, key) {
     }
     if (!parentVal)
         return childVal;
-    var ret = {};
+    const ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1215,7 +1198,7 @@ strats.props = strats.methods = strats.inject = strats.computed = function (pare
     }
     if (!parentVal)
         return childVal;
-    var ret = Object.create(null);
+    const ret = Object.create(null);
     extend(ret, parentVal);
     if (childVal)
         extend(ret, childVal);
@@ -1225,19 +1208,19 @@ strats.provide = mergeDataOrFn;
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
+const defaultStrat = function (parentVal, childVal) {
     return childVal === undefined ? parentVal : childVal;
 };
 /**
  * Validate component names
  */
 function checkComponents(options) {
-    for (var key in options.components) {
+    for (const key in options.components) {
         validateComponentName(key);
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
         warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1254,11 +1237,11 @@ function validateComponentName(name) {
  * Object-based format.
  */
 function normalizeProps(options, vm) {
-    var props = options.props;
+    const props = options.props;
     if (!props)
         return;
-    var res = {};
-    var i, val, name;
+    const res = {};
+    let i, val, name;
     if (Array.isArray(props)) {
         i = props.length;
         while (i--) {
@@ -1273,15 +1256,15 @@ function normalizeProps(options, vm) {
         }
     }
     else if (isPlainObject(props)) {
-        for (var key in props) {
+        for (const key in props) {
             val = props[key];
             name = camelize(key);
             res[name] = isPlainObject(val) ? val : { type: val };
         }
     }
     else {
-        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
     }
     options.props = res;
 }
@@ -1289,36 +1272,36 @@ function normalizeProps(options, vm) {
  * Normalize all injections into Object-based format
  */
 function normalizeInject(options, vm) {
-    var inject = options.inject;
+    const inject = options.inject;
     if (!inject)
         return;
-    var normalized = (options.inject = {});
+    const normalized = (options.inject = {});
     if (Array.isArray(inject)) {
-        for (var i = 0; i < inject.length; i++) {
+        for (let i = 0; i < inject.length; i++) {
             normalized[inject[i]] = { from: inject[i] };
         }
     }
     else if (isPlainObject(inject)) {
-        for (var key in inject) {
-            var val = inject[key];
+        for (const key in inject) {
+            const val = inject[key];
             normalized[key] = isPlainObject(val)
                 ? extend({ from: key }, val)
                 : { from: val };
         }
     }
     else {
-        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
 function normalizeDirectives$1(options) {
-    var dirs = options.directives;
+    const dirs = options.directives;
     if (dirs) {
-        for (var key in dirs) {
-            var def = dirs[key];
+        for (const key in dirs) {
+            const def = dirs[key];
             if (typeof def === 'function') {
                 dirs[key] = { bind: def, update: def };
             }
@@ -1327,8 +1310,8 @@ function normalizeDirectives$1(options) {
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
     }
 }
 /**
@@ -1355,13 +1338,13 @@ function mergeOptions(parent, child, vm) {
             parent = mergeOptions(parent, child.extends, vm);
         }
         if (child.mixins) {
-            for (var i = 0, l = child.mixins.length; i < l; i++) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
                 parent = mergeOptions(parent, child.mixins[i], vm);
             }
         }
     }
-    var options = {};
-    var key;
+    const options = {};
+    let key;
     for (key in parent) {
         mergeField(key);
     }
@@ -1371,7 +1354,7 @@ function mergeOptions(parent, child, vm) {
         }
     }
     function mergeField(key) {
-        var strat = strats[key] || defaultStrat;
+        const strat = strats[key] || defaultStrat;
         options[key] = strat(parent[key], child[key], vm, key);
     }
     return options;
@@ -1386,18 +1369,18 @@ function resolveAsset(options, type, id, warnMissing) {
     if (typeof id !== 'string') {
         return;
     }
-    var assets = options[type];
+    const assets = options[type];
     // check local registration variations first
     if (hasOwn(assets, id))
         return assets[id];
-    var camelizedId = camelize(id);
+    const camelizedId = camelize(id);
     if (hasOwn(assets, camelizedId))
         return assets[camelizedId];
-    var PascalCaseId = capitalize(camelizedId);
+    const PascalCaseId = capitalize(camelizedId);
     if (hasOwn(assets, PascalCaseId))
         return assets[PascalCaseId];
     // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (warnMissing && !res) {
         warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
@@ -1405,11 +1388,11 @@ function resolveAsset(options, type, id, warnMissing) {
 }
 
 function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
     // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
     if (booleanIndex > -1) {
         if (absent && !hasOwn(prop, 'default')) {
             value = false;
@@ -1417,7 +1400,7 @@ function validateProp(key, propOptions, propsData, vm) {
         else if (value === '' || value === hyphenate(key)) {
             // only cast empty string / same name to boolean if
             // boolean has higher priority
-            var stringIndex = getTypeIndex(String, prop.type);
+            const stringIndex = getTypeIndex(String, prop.type);
             if (stringIndex < 0 || booleanIndex < stringIndex) {
                 value = true;
             }
@@ -1428,7 +1411,7 @@ function validateProp(key, propOptions, propsData, vm) {
         value = getPropDefaultValue(vm, prop, key);
         // since the default value is a fresh copy,
         // make sure to observe it.
-        var prevShouldObserve = shouldObserve;
+        const prevShouldObserve = shouldObserve;
         toggleObserving(true);
         observe(value);
         toggleObserving(prevShouldObserve);
@@ -1446,7 +1429,7 @@ function getPropDefaultValue(vm, prop, key) {
     if (!hasOwn(prop, 'default')) {
         return undefined;
     }
-    var def = prop.default;
+    const def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (isObject(def)) {
         warn$2('Invalid default value for prop "' +
@@ -1480,38 +1463,38 @@ function assertProp(prop, name, value, vm, absent) {
     if (value == null && !prop.required) {
         return;
     }
-    var type = prop.type;
+    let type = prop.type;
     // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
+    let valid = !type || type === true;
+    const expectedTypes = [];
     if (type) {
         if (!Array.isArray(type)) {
             type = [type];
         }
-        for (var i = 0; i < type.length && !valid; i++) {
-            var assertedType = assertType(value, type[i], vm);
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
             expectedTypes.push(assertedType.expectedType || '');
             valid = assertedType.valid;
         }
     }
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    const haveExpectedTypes = expectedTypes.some((t) => t);
     if (!valid && haveExpectedTypes) {
         warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
-    var validator = prop.validator;
+    const validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
             warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
 function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
+    let valid;
+    const expectedType = getType(type);
     if (simpleCheckRE.test(expectedType)) {
-        var t = typeof value;
+        const t = typeof value;
         valid = t === expectedType.toLowerCase();
         // for primitive wrapper objects
         if (!valid && t === 'object') {
@@ -1534,18 +1517,18 @@ function assertType(value, type, vm) {
         }
     }
     return {
-        valid: valid,
-        expectedType: expectedType,
+        valid,
+        expectedType,
     };
 }
-var functionTypeCheckRE = /^\s*function (\w+)/;
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
 function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
+    const match = fn && fn.toString().match(functionTypeCheckRE);
     return match ? match[1] : '';
 }
 function isSameType(a, b) {
@@ -1555,7 +1538,7 @@ function getTypeIndex(type, expectedTypes) {
     if (!Array.isArray(expectedTypes)) {
         return isSameType(expectedTypes, type) ? 0 : -1;
     }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
         if (isSameType(expectedTypes[i], type)) {
             return i;
         }
@@ -1563,45 +1546,41 @@ function getTypeIndex(type, expectedTypes) {
     return -1;
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
     // check if we need to specify expected value
     if (expectedTypes.length === 1 &&
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
+        message += ` with value ${styleValue(value, expectedType)}`;
     }
-    message += ", got " + receivedType + " ";
+    message += `, got ${receivedType} `;
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
+        message += `with value ${styleValue(value, receivedType)}.`;
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return "\"" + value + "\"";
+        return `"${value}"`;
     }
     else if (type === 'Number') {
-        return "" + Number(value);
+        return `${Number(value)}`;
     }
     else {
-        return "" + value;
+        return `${value}`;
     }
 }
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
 function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
 }
-function isBoolean() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
 function handleError(err, vm, info) {
@@ -1610,13 +1589,13 @@ function handleError(err, vm, info) {
     pushTarget();
     try {
         if (vm) {
-            var cur = vm;
+            let cur = vm;
             while ((cur = cur.$parent)) {
-                var hooks = cur.$options.errorCaptured;
+                const hooks = cur.$options.errorCaptured;
                 if (hooks) {
-                    for (var i = 0; i < hooks.length; i++) {
+                    for (let i = 0; i < hooks.length; i++) {
                         try {
-                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
                             if (capture)
                                 return;
                         }
@@ -1634,11 +1613,11 @@ function handleError(err, vm, info) {
     }
 }
 function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
+    let res;
     try {
         res = args ? handler.apply(context, args) : handler.call(context);
         if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
             // issue #9511
             // avoid catch triggering multiple times when nested calls
             res._handled = true;
@@ -1666,7 +1645,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1678,14 +1657,14 @@ function logError(err, vm, info) {
 }
 
 /* globals MutationObserver */
-var isUsingMicroTask = false;
-var callbacks = [];
-var pending = false;
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
 function flushCallbacks() {
     pending = false;
-    var copies = callbacks.slice(0);
+    const copies = callbacks.slice(0);
     callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
+    for (let i = 0; i < copies.length; i++) {
         copies[i]();
     }
 }
@@ -1700,7 +1679,7 @@ function flushCallbacks() {
 // where microtasks have too high a priority and fire in between supposedly
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
-var timerFunc;
+let timerFunc;
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1709,9 +1688,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p_1 = Promise.resolve();
-    timerFunc = function () {
-        p_1.then(flushCallbacks);
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1730,15 +1709,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
-    timerFunc = function () {
-        counter_1 = (counter_1 + 1) % 2;
-        textNode_1.data = String(counter_1);
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
     };
     isUsingMicroTask = true;
 }
@@ -1746,19 +1725,19 @@ else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
     // Fallback to setImmediate.
     // Technically it leverages the (macro) task queue,
     // but it is still a better choice than setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setImmediate(flushCallbacks);
     };
 }
 else {
     // Fallback to setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setTimeout(flushCallbacks, 0);
     };
 }
 function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
+    let _resolve;
+    callbacks.push(() => {
         if (cb) {
             try {
                 cb.call(ctx);
@@ -1777,60 +1756,60 @@ function nextTick(cb, ctx) {
     }
     // $flow-disable-line
     if (!cb && typeof Promise !== 'undefined') {
-        return new Promise(function (resolve) {
+        return new Promise((resolve) => {
             _resolve = resolve;
         });
     }
 }
 
-var mark;
-var measure;
+let mark;
+let measure;
 {
-    var perf_1 = inBrowser && window.performance;
+    const perf = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) {
-        mark = function (tag) { return perf_1.mark(tag); };
-        measure = function (name, startTag, endTag) {
-            perf_1.measure(name, startTag, endTag);
-            perf_1.clearMarks(startTag);
-            perf_1.clearMarks(endTag);
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-var initProxy;
+let initProxy;
 {
-    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent_1 = function (target, key) {
-        warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
+    const warnNonPresent = (target, key) => {
+        warn$2(`Property or method "${key}" is not defined on the instance but ` +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix_1 = function (target, key) {
-        warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    const warnReservedPrefix = (target, key) => {
+        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                     return false;
                 }
                 else {
@@ -1840,38 +1819,38 @@ var initProxy;
             },
         });
     }
-    var hasHandler_1 = {
-        has: function (target, key) {
-            var has = key in target;
-            var isAllowed = allowedGlobals_1(key) ||
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    warnReservedPrefix_1(target, key);
+                    warnReservedPrefix(target, key);
                 else
-                    warnNonPresent_1(target, key);
+                    warnNonPresent(target, key);
             }
             return has || !isAllowed;
         },
     };
-    var getHandler_1 = {
-        get: function (target, key) {
+    const getHandler = {
+        get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    warnReservedPrefix_1(target, key);
+                    warnReservedPrefix(target, key);
                 else
-                    warnNonPresent_1(target, key);
+                    warnNonPresent(target, key);
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy_1) {
+        if (hasProxy) {
             // determine which proxy handler to use
-            var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1880,7 +1859,7 @@ var initProxy;
     };
 }
 
-var seenObjects = new _Set();
+const seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
@@ -1891,15 +1870,15 @@ function traverse(val) {
     seenObjects.clear();
 }
 function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
+    let i, keys;
+    const isA = Array.isArray(val);
     if ((!isA && !isObject(val)) ||
         Object.isFrozen(val) ||
         val instanceof VNode) {
         return;
     }
     if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
+        const depId = val.__ob__.dep.id;
         if (seen.has(depId)) {
             return;
         }
@@ -1918,45 +1897,45 @@ function _traverse(val, seen) {
     }
 }
 
-var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
     name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
+    const capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
-        name: name,
-        once: once,
-        capture: capture,
-        passive: passive,
+        name,
+        once,
+        capture,
+        passive,
     };
 });
 function createFnInvoker(fns, vm) {
     function invoker() {
-        var fns = invoker.fns;
+        const fns = invoker.fns;
         if (Array.isArray(fns)) {
-            var cloned = fns.slice();
-            for (var i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, "v-on handler");
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
             }
         }
         else {
             // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
         }
     }
     invoker.fns = fns;
     return invoker;
 }
 function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, cur, old, event;
+    let name, cur, old, event;
     for (name in on) {
         cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1984,8 +1963,8 @@ function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
     }
-    var invoker;
-    var oldHook = def[hookKey];
+    let invoker;
+    const oldHook = def[hookKey];
     function wrappedHook() {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
@@ -2016,26 +1995,26 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
     // component itself.
-    var propOptions = Ctor.options.props;
+    const propOptions = Ctor.options.props;
     if (isUndef(propOptions)) {
         return;
     }
-    var res = {};
-    var attrs = data.attrs, props = data.props;
+    const res = {};
+    const { attrs, props } = data;
     if (isDef(attrs) || isDef(props)) {
-        for (var key in propOptions) {
-            var altKey = hyphenate(key);
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
             {
-                var keyInLowerCase = key.toLowerCase();
+                const keyInLowerCase = key.toLowerCase();
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                        (formatComponentName(
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
                         // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
-                        "Note that HTML attributes are case-insensitive and camelCased " +
-                        "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2076,7 +2055,7 @@ function checkProp(res, hash, key, altKey, preserve) {
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
 function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
+    for (let i = 0; i < children.length; i++) {
         if (Array.isArray(children[i])) {
             return Array.prototype.concat.apply([], children);
         }
@@ -2098,8 +2077,8 @@ function isTextNode(node) {
     return isDef(node) && isDef(node.text) && isFalse(node.isComment);
 }
 function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
+    const res = [];
+    let i, c, lastIndex, last;
     for (i = 0; i < children.length; i++) {
         c = children[i];
         if (isUndef(c) || typeof c === 'boolean')
@@ -2109,7 +2088,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2141,7 +2120,7 @@ function normalizeArrayChildren(children, nestedIndex) {
                     isDef(c.tag) &&
                     isUndef(c.key) &&
                     isDef(nestedIndex)) {
-                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                    c.key = `__vlist${nestedIndex}_${i}__`;
                 }
                 res.push(c);
             }
@@ -2151,7 +2130,7 @@ function normalizeArrayChildren(children, nestedIndex) {
 }
 
 function initProvide(vm) {
-    var provide = vm.$options.provide;
+    const provide = vm.$options.provide;
     if (provide) {
         vm._provided =
             typeof provide === 'function'
@@ -2161,16 +2140,16 @@ function initProvide(vm) {
     }
 }
 function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
+    const result = resolveInject(vm.$options.inject, vm);
     if (result) {
         toggleObserving(false);
-        Object.keys(result).forEach(function (key) {
+        Object.keys(result).forEach((key) => {
             /* istanbul ignore else */
             {
-                defineReactive(vm, key, result[key], function () {
-                    warn$2("Avoid mutating an injected value directly since the changes will be " +
-                        "overwritten whenever the provided component re-renders. " +
-                        ("injection being mutated: \"" + key + "\""), vm);
+                defineReactive(vm, key, result[key], () => {
+                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
                 });
             }
         });
@@ -2180,15 +2159,15 @@ function initInjections(vm) {
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
-        var result = Object.create(null);
-        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (var i = 0; i < keys.length; i++) {
-            var key = keys[i];
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             // #6574 in case the inject object is observed...
             if (key === '__ob__')
                 continue;
-            var provideKey = inject[key].from;
-            var source = vm;
+            const provideKey = inject[key].from;
+            let source = vm;
             while (source) {
                 if (source._provided && hasOwn(source._provided, provideKey)) {
                     result[key] = source._provided[provideKey];
@@ -2199,7 +2178,7 @@ function resolveInject(inject, vm) {
             }
             if (!source) {
                 if ('default' in inject[key]) {
-                    var provideDefault = inject[key].default;
+                    const provideDefault = inject[key].default;
                     result[key] =
                         typeof provideDefault === 'function'
                             ? provideDefault.call(vm)
@@ -2207,7 +2186,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn$2("Injection \"" + key + "\" not found", vm);
+                    warn$2(`Injection "${key}" not found`, vm);
                 }
             }
         }
@@ -2222,10 +2201,10 @@ function resolveSlots(children, context) {
     if (!children || !children.length) {
         return {};
     }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var data = child.data;
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
         // remove slot attribute if the node is resolved as a Vue slot node
         if (data && data.attrs && data.attrs.slot) {
             delete data.attrs.slot;
@@ -2235,8 +2214,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2249,9 +2228,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
         }
     }
     return slots;
@@ -2261,10 +2240,10 @@ function isWhitespace(node) {
 }
 
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
     if (!slots) {
         res = {};
     }
@@ -2284,16 +2263,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+        for (const key in slots) {
+            if (slots[key] && key[0] !== '$') {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2307,8 +2286,8 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
             res && typeof res === 'object' && !Array.isArray(res)
                 ? [res] // single vnode
@@ -2330,14 +2309,14 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     return normalized;
 }
 function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; };
+    return () => slots[key];
 }
 
 /**
  * Runtime helper for rendering v-for lists.
  */
 function renderList(val, render) {
-    var ret = null, i, l, keys, key;
+    let ret = null, i, l, keys, key;
     if (Array.isArray(val) || typeof val === 'string') {
         ret = new Array(val.length);
         for (i = 0, l = val.length; i < l; i++) {
@@ -2353,8 +2332,8 @@ function renderList(val, render) {
     else if (isObject(val)) {
         if (hasSymbol && val[Symbol.iterator]) {
             ret = [];
-            var iterator = val[Symbol.iterator]();
-            var result = iterator.next();
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
             while (!result.done) {
                 ret.push(render(result.value, ret.length));
                 result = iterator.next();
@@ -2380,8 +2359,8 @@ function renderList(val, render) {
  * Runtime helper for rendering <slot>
  */
 function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
     if (scopedSlotFn) {
         // scoped slot
         props = props || {};
@@ -2396,7 +2375,7 @@ function renderSlot(name, fallback, props, bindObject) {
     else {
         nodes = this.$slots[name] || fallback;
     }
-    var target = props && props.slot;
+    const target = props && props.slot;
     if (target) {
         return this.$createElement('template', { slot: target }, nodes);
     }
@@ -2426,7 +2405,7 @@ function isKeyNotMatch(expect, actual) {
  * passing in eventKeyName as last argument separately for backwards compat
  */
 function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
     if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
         return isKeyNotMatch(builtInKeyName, eventKeyName);
     }
@@ -2450,32 +2429,29 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash = void 0;
-            var _loop_1 = function (key) {
+            let hash;
+            for (const key in value) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
                 else {
-                    var type = data.attrs && data.attrs.type;
+                    const type = data.attrs && data.attrs.type;
                     hash =
                         asProp || config.mustUseProp(tag, type, key)
                             ? data.domProps || (data.domProps = {})
                             : data.attrs || (data.attrs = {});
                 }
-                var camelizedKey = camelize(key);
-                var hyphenatedKey = hyphenate(key);
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
                 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                     hash[key] = value[key];
                     if (isSync) {
-                        var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
-            };
-            for (var key in value) {
-                _loop_1(key);
             }
         }
     }
@@ -2486,8 +2462,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
  * Runtime helper for rendering static trees.
  */
 function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
     // if has already-rendered static tree and not inside v-for,
     // we can reuse the same tree.
     if (tree && !isInFor) {
@@ -2496,7 +2472,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic$1(tree, "__static__" + index, false);
+    markStatic$1(tree, `__static__${index}`, false);
     return tree;
 }
 /**
@@ -2504,14 +2480,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
     return tree;
 }
 function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
-        for (var i = 0; i < tree.length; i++) {
+        for (let i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
             }
         }
     }
@@ -2531,10 +2507,10 @@ function bindObjectListeners(data, value) {
             warn$2('v-on without argument expects an Object value', this);
         }
         else {
-            var on = (data.on = data.on ? extend({}, data.on) : {});
-            for (var key in value) {
-                var existing = on[key];
-                var ours = value[key];
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
                 on[key] = existing ? [].concat(existing, ours) : ours;
             }
         }
@@ -2546,8 +2522,8 @@ function resolveScopedSlots(fns, res,
 // the following are added in 2.6
 hasDynamicKeys, contentHashKey) {
     res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-        var slot = fns[i];
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
         if (Array.isArray(slot)) {
             resolveScopedSlots(slot, res, hasDynamicKeys);
         }
@@ -2569,15 +2545,15 @@ hasDynamicKeys, contentHashKey) {
 
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-        var key = values[i];
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
         if (typeof key === 'string' && key) {
             baseObj[values[i]] = values[i + 1];
         }
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
         }
     }
     return baseObj;
@@ -2610,11 +2586,10 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
-    var options = Ctor.options;
+    const options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
+    let contextVm;
     if (hasOwn(parent, '_uid')) {
         contextVm = Object.create(parent);
         // $flow-disable-line
@@ -2628,23 +2603,23 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         // $flow-disable-line
         parent = parent._original;
     }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
     this.data = data;
     this.props = props;
     this.children = children;
     this.parent = parent;
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
         }
-        return _this.$slots;
+        return this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function () {
+        get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2657,8 +2632,8 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
     }
     if (options._scopeId) {
-        this._c = function (a, b, c, d) {
-            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2667,18 +2642,16 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) {
-            return createElement$1(contextVm, a, b, c, d, needNormalization);
-        };
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
 function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
     if (isDef(propOptions)) {
-        for (var key in propOptions) {
+        for (const key in propOptions) {
             props[key] = validateProp(key, propOptions, propsData || emptyObject);
         }
     }
@@ -2688,15 +2661,15 @@ function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
         if (isDef(data.props))
             mergeProps(props, data.props);
     }
-    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    var vnode = options.render.call(null, renderContext._c, renderContext);
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
     if (vnode instanceof VNode) {
         return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
     }
     else if (Array.isArray(vnode)) {
-        var vnodes = normalizeChildren(vnode) || [];
-        var res = new Array(vnodes.length);
-        for (var i = 0; i < vnodes.length; i++) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
             res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
         }
         return res;
@@ -2706,7 +2679,7 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     // #7817 clone node before setting fnContext, otherwise if the node is reused
     // (e.g. it was from a cached normal slot) the fnContext causes named slots
     // that should not be matched to match.
-    var clone = cloneVNode(vnode);
+    const clone = cloneVNode(vnode);
     clone.fnContext = contextVm;
     clone.fnOptions = options;
     {
@@ -2718,37 +2691,37 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     return clone;
 }
 function mergeProps(to, from) {
-    for (var key in from) {
+    for (const key in from) {
         to[camelize(key)] = from[key];
     }
 }
 
 // inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
             // kept-alive components, treat as a patch
-            var mountedNode = vnode; // work around flow
+            const mountedNode = vnode; // work around flow
             componentVNodeHooks.prepatch(mountedNode, mountedNode);
         }
         else {
-            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function (oldVnode, vnode) {
-        var options = vnode.componentOptions;
-        var child = (vnode.componentInstance = oldVnode.componentInstance);
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
         options.listeners, // updated listeners
         vnode, // new parent vnode
         options.children // new children
         );
     },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2767,8 +2740,8 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function (vnode) {
-        var componentInstance = vnode.componentInstance;
+    destroy(vnode) {
+        const { componentInstance } = vnode;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
                 componentInstance.$destroy();
@@ -2779,12 +2752,12 @@ var componentVNodeHooks = {
         }
     },
 };
-var hooksToMerge = Object.keys(componentVNodeHooks);
+const hooksToMerge = Object.keys(componentVNodeHooks);
 function createComponent(Ctor, data, context, children, tag) {
     if (isUndef(Ctor)) {
         return;
     }
-    var baseCtor = context.$options._base;
+    const baseCtor = context.$options._base;
     // plain options object: turn it into a constructor
     if (isObject(Ctor)) {
         Ctor = baseCtor.extend(Ctor);
@@ -2793,12 +2766,12 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn$2("Invalid Component definition: " + String(Ctor), context);
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
         }
         return;
     }
     // async component
-    var asyncFactory;
+    let asyncFactory;
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
@@ -2821,7 +2794,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract props
     // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
     // functional component
     // @ts-expect-error
     if (isTrue(Ctor.options.functional)) {
@@ -2829,7 +2802,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract listeners, since these needs to be treated as
     // child component listeners instead of DOM listeners
-    var listeners = data.on;
+    const listeners = data.on;
     // replace with listeners with .native modifier
     // so it gets processed during parent component patch.
     data.on = data.nativeOn;
@@ -2838,7 +2811,7 @@ function createComponent(Ctor, data, context, children, tag) {
         // abstract components do not keep anything
         // other than props & listeners & slot
         // work around flow
-        var slot = data.slot;
+        const slot = data.slot;
         data = {};
         if (slot) {
             data.slot = slot;
@@ -2848,12 +2821,12 @@ function createComponent(Ctor, data, context, children, tag) {
     installComponentHooks(data);
     // return a placeholder vnode
     // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
     // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
     // @ts-expect-error
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
     return vnode;
 }
 function createComponentInstanceForVnode(
@@ -2861,13 +2834,13 @@ function createComponentInstanceForVnode(
 vnode, 
 // activeInstance in lifecycle state
 parent) {
-    var options = {
+    const options = {
         _isComponent: true,
         _parentVnode: vnode,
-        parent: parent,
+        parent,
     };
     // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
+    const inlineTemplate = vnode.data.inlineTemplate;
     if (isDef(inlineTemplate)) {
         options.render = inlineTemplate.render;
         options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2875,11 +2848,11 @@ parent) {
     return new vnode.componentOptions.Ctor(options);
 }
 function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-        var key = hooksToMerge[i];
-        var existing = hooks[key];
-        var toMerge = componentVNodeHooks[key];
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
             hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2887,7 +2860,7 @@ function installComponentHooks(data) {
     }
 }
 function mergeHook(f1, f2) {
-    var merged = function (a, b) {
+    const merged = (a, b) => {
         // flow complains about extra args which is why we use any
         f1(a, b);
         f2(a, b);
@@ -2898,12 +2871,12 @@ function mergeHook(f1, f2) {
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
 function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input';
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
     (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
     if (isDef(existing)) {
         if (Array.isArray(existing)
             ? existing.indexOf(callback) === -1
@@ -2916,8 +2889,8 @@ function transformModel(options, data) {
     }
 }
 
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
 function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2933,7 +2906,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2966,16 +2939,16 @@ function _createElement(context, tag, data, children, normalizationType) {
     else if (normalizationType === SIMPLE_NORMALIZE) {
         children = simpleNormalizeChildren(children);
     }
-    var vnode, ns;
+    let vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor = void 0;
+        let Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3017,8 +2990,8 @@ function applyNS(vnode, ns, force) {
         force = true;
     }
     if (isDef(vnode.children)) {
-        for (var i = 0, l = vnode.children.length; i < l; i++) {
-            var child = vnode.children[i];
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
             if (isDef(child.tag) &&
                 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                 applyNS(child, ns, force);
@@ -3041,9 +3014,9 @@ function registerDeepBindings(data) {
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
     vm.$slots = resolveSlots(options._renderChildren, renderContext);
     vm.$scopedSlots = emptyObject;
     // bind the createElement fn to this instance
@@ -3051,25 +3024,25 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
+    const parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
         }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
         }, true);
     }
 }
-var currentRenderingInstance = null;
+let currentRenderingInstance = null;
 function renderMixin(Vue) {
     // install runtime convenience helpers
     installRenderHelpers(Vue.prototype);
@@ -3077,8 +3050,8 @@ function renderMixin(Vue) {
         return nextTick(fn, this);
     };
     Vue.prototype._render = function () {
-        var vm = this;
-        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3086,7 +3059,7 @@ function renderMixin(Vue) {
         // to the data on the placeholder node.
         vm.$vnode = _parentVnode;
         // render self
-        var vnode;
+        let vnode;
         try {
             // There's no need to maintain a stack because all render fns are called
             // separately from one another. Nested component's render fns are called
@@ -3095,7 +3068,7 @@ function renderMixin(Vue) {
             vnode = render.call(vm._renderProxy, vm.$createElement);
         }
         catch (e) {
-            handleError(e, vm, "render");
+            handleError(e, vm, `render`);
             // return error render result,
             // or previous vnode to prevent render error causing blank component
             /* istanbul ignore else */
@@ -3104,7 +3077,7 @@ function renderMixin(Vue) {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
                 catch (e) {
-                    handleError(e, vm, "renderError");
+                    handleError(e, vm, `renderError`);
                     vnode = vm._vnode;
                 }
             }
@@ -3140,9 +3113,9 @@ function ensureCtor(comp, base) {
     return isObject(comp) ? base.extend(comp) : comp;
 }
 function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
+    const node = createEmptyVNode();
     node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    node.asyncMeta = { data, context, children, tag };
     return node;
 }
 function resolveAsyncComponent(factory, baseCtor) {
@@ -3152,7 +3125,7 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    var owner = currentRenderingInstance;
+    const owner = currentRenderingInstance;
     if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
         // already pending
         factory.owners.push(owner);
@@ -3161,89 +3134,89 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners_1 = (factory.owners = [owner]);
-        var sync_1 = true;
-        var timerLoading_1 = null;
-        var timerTimeout_1 = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-        var forceRender_1 = function (renderCompleted) {
-            for (var i = 0, l = owners_1.length; i < l; i++) {
-                owners_1[i].$forceUpdate();
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners_1.length = 0;
-                if (timerLoading_1 !== null) {
-                    clearTimeout(timerLoading_1);
-                    timerLoading_1 = null;
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
                 }
-                if (timerTimeout_1 !== null) {
-                    clearTimeout(timerTimeout_1);
-                    timerTimeout_1 = null;
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
                 }
             }
         };
-        var resolve = once(function (res) {
+        const resolve = once((res) => {
             // cache resolved
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync_1) {
-                forceRender_1(true);
+            if (!sync) {
+                forceRender(true);
             }
             else {
-                owners_1.length = 0;
+                owners.length = 0;
             }
         });
-        var reject_1 = once(function (reason) {
-            warn$2("Failed to resolve async component: " + String(factory) +
-                    (reason ? "\nReason: " + reason : ''));
+        const reject = once((reason) => {
+            warn$2(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender_1(true);
+                forceRender(true);
             }
         });
-        var res_1 = factory(resolve, reject_1);
-        if (isObject(res_1)) {
-            if (isPromise(res_1)) {
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res_1.then(resolve, reject_1);
+                    res.then(resolve, reject);
                 }
             }
-            else if (isPromise(res_1.component)) {
-                res_1.component.then(resolve, reject_1);
-                if (isDef(res_1.error)) {
-                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
                 }
-                if (isDef(res_1.loading)) {
-                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                    if (res_1.delay === 0) {
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading_1 = setTimeout(function () {
-                            timerLoading_1 = null;
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender_1(false);
+                                forceRender(false);
                             }
-                        }, res_1.delay || 200);
+                        }, res.delay || 200);
                     }
                 }
-                if (isDef(res_1.timeout)) {
+                if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout_1 = setTimeout(function () {
-                        timerTimeout_1 = null;
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject_1("timeout (" + res_1.timeout + "ms)"
+                            reject(`timeout (${res.timeout}ms)`
                                 );
                         }
-                    }, res_1.timeout);
+                    }, res.timeout);
                 }
             }
         }
-        sync_1 = false;
+        sync = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3256,8 +3229,8 @@ function isAsyncPlaceholder(node) {
 
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-            var c = children[i];
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
             if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                 return c;
             }
@@ -3269,12 +3242,12 @@ function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
     // init parent attached events
-    var listeners = vm.$options._parentListeners;
+    const listeners = vm.$options._parentListeners;
     if (listeners) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target$1;
+let target$1;
 function add$1(event, fn) {
     target$1.$on(event, fn);
 }
@@ -3282,9 +3255,9 @@ function remove$1(event, fn) {
     target$1.$off(event, fn);
 }
 function createOnceHandler$1(event, fn) {
-    var _target = target$1;
+    const _target = target$1;
     return function onceHandler() {
-        var res = fn.apply(null, arguments);
+        const res = fn.apply(null, arguments);
         if (res !== null) {
             _target.$off(event, onceHandler);
         }
@@ -3296,11 +3269,11 @@ function updateComponentListeners(vm, listeners, oldListeners) {
     target$1 = undefined;
 }
 function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
+    const hookRE = /^hook:/;
     Vue.prototype.$on = function (event, fn) {
-        var vm = this;
+        const vm = this;
         if (Array.isArray(event)) {
-            for (var i = 0, l = event.length; i < l; i++) {
+            for (let i = 0, l = event.length; i < l; i++) {
                 vm.$on(event[i], fn);
             }
         }
@@ -3315,7 +3288,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$once = function (event, fn) {
-        var vm = this;
+        const vm = this;
         function on() {
             vm.$off(event, on);
             fn.apply(vm, arguments);
@@ -3325,7 +3298,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$off = function (event, fn) {
-        var vm = this;
+        const vm = this;
         // all
         if (!arguments.length) {
             vm._events = Object.create(null);
@@ -3333,13 +3306,13 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                vm.$off(event[i_1], fn);
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
             }
             return vm;
         }
         // specific event
-        var cbs = vm._events[event];
+        const cbs = vm._events[event];
         if (!cbs) {
             return vm;
         }
@@ -3348,8 +3321,8 @@ function eventsMixin(Vue) {
             return vm;
         }
         // specific handler
-        var cb;
-        var i = cbs.length;
+        let cb;
+        let i = cbs.length;
         while (i--) {
             cb = cbs[i];
             if (cb === fn || cb.fn === fn) {
@@ -3360,23 +3333,23 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$emit = function (event) {
-        var vm = this;
+        const vm = this;
         {
-            var lowerCaseEvent = event.toLowerCase();
+            const lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
-                    "Note that HTML attributes are case-insensitive and you cannot use " +
-                    "v-on to listen to camelCase events when using in-DOM templates. " +
-                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
             }
         }
-        var cbs = vm._events[event];
+        let cbs = vm._events[event];
         if (cbs) {
             cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            var args = toArray(arguments, 1);
-            var info = "event handler for \"" + event + "\"";
-            for (var i = 0, l = cbs.length; i < l; i++) {
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
                 invokeWithErrorHandling(cbs[i], vm, args, vm, info);
             }
         }
@@ -3384,19 +3357,19 @@ function eventsMixin(Vue) {
     };
 }
 
-var activeInstance = null;
-var isUpdatingChildComponent = false;
+let activeInstance = null;
+let isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
+    const prevActiveInstance = activeInstance;
     activeInstance = vm;
-    return function () {
+    return () => {
         activeInstance = prevActiveInstance;
     };
 }
 function initLifecycle(vm) {
-    var options = vm.$options;
+    const options = vm.$options;
     // locate first non-abstract parent
-    var parent = options.parent;
+    let parent = options.parent;
     if (parent && !options.abstract) {
         while (parent.$options.abstract && parent.$parent) {
             parent = parent.$parent;
@@ -3417,10 +3390,10 @@ function initLifecycle(vm) {
 }
 function lifecycleMixin(Vue) {
     Vue.prototype._update = function (vnode, hydrating) {
-        var vm = this;
-        var prevEl = vm.$el;
-        var prevVnode = vm._vnode;
-        var restoreActiveInstance = setActiveInstance(vm);
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
         vm._vnode = vnode;
         // Vue.prototype.__patch__ is injected in entry points
         // based on the rendering backend used.
@@ -3448,20 +3421,20 @@ function lifecycleMixin(Vue) {
         // updated in a parent's updated hook.
     };
     Vue.prototype.$forceUpdate = function () {
-        var vm = this;
+        const vm = this;
         if (vm._watcher) {
             vm._watcher.update();
         }
     };
     Vue.prototype.$destroy = function () {
-        var vm = this;
+        const vm = this;
         if (vm._isBeingDestroyed) {
             return;
         }
         callHook$1(vm, 'beforeDestroy');
         vm._isBeingDestroyed = true;
         // remove self from parent
-        var parent = vm.$parent;
+        const parent = vm.$parent;
         // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
             remove$2(parent.$children, vm);
@@ -3470,7 +3443,7 @@ function lifecycleMixin(Vue) {
         if (vm._watcher) {
             vm._watcher.teardown();
         }
-        var i = vm._watchers.length;
+        let i = vm._watchers.length;
         while (i--) {
             vm._watchers[i].teardown();
         }
@@ -3518,26 +3491,26 @@ function mountComponent(vm, el, hydrating) {
         }
     }
     callHook$1(vm, 'beforeMount');
-    var updateComponent;
+    let updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
-        updateComponent = function () {
-            var name = vm._name;
-            var id = vm._uid;
-            var startTag = "vue-perf-start:" + id;
-            var endTag = "vue-perf-end:" + id;
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
             mark(startTag);
-            var vnode = vm._render();
+            const vnode = vm._render();
             mark(endTag);
-            measure("vue " + name + " render", startTag, endTag);
+            measure(`vue ${name} render`, startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure("vue " + name + " patch", startTag, endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
         };
     }
     else {
-        updateComponent = function () {
+        updateComponent = () => {
             vm._update(vm._render(), hydrating);
         };
     }
@@ -3545,7 +3518,7 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function () {
+        before() {
             if (vm._isMounted && !vm._isDestroyed) {
                 callHook$1(vm, 'beforeUpdate');
             }
@@ -3569,15 +3542,15 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // check if there are dynamic scopedSlots (hand-written or compiled but with
     // dynamic slot names). Static scoped slots compiled from template has the
     // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
         (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(renderChildren || // has new static slots
+    const needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
     // @ts-ignore
@@ -3599,11 +3572,11 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // update props
     if (propsData && vm.$options.props) {
         toggleObserving(false);
-        var props = vm._props;
-        var propKeys = vm.$options._propKeys || [];
-        for (var i = 0; i < propKeys.length; i++) {
-            var key = propKeys[i];
-            var propOptions = vm.$options.props; // wtf flow?
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
             props[key] = validateProp(key, propOptions, propsData, vm);
         }
         toggleObserving(true);
@@ -3612,7 +3585,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     }
     // update listeners
     listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
+    const oldListeners = vm.$options._parentListeners;
     vm.$options._parentListeners = listeners;
     updateComponentListeners(vm, listeners, oldListeners);
     // resolve slots + force update if has children
@@ -3643,7 +3616,7 @@ function activateChildComponent(vm, direct) {
     }
     if (vm._inactive || vm._inactive === null) {
         vm._inactive = false;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
         callHook$1(vm, 'activated');
@@ -3658,7 +3631,7 @@ function deactivateChildComponent(vm, direct) {
     }
     if (!vm._inactive) {
         vm._inactive = true;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
         callHook$1(vm, 'deactivated');
@@ -3667,10 +3640,10 @@ function deactivateChildComponent(vm, direct) {
 function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
     if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
             invokeWithErrorHandling(handlers[i], vm, null, vm, info);
         }
     }
@@ -3680,14 +3653,14 @@ function callHook$1(vm, hook) {
     popTarget();
 }
 
-var MAX_UPDATE_COUNT = 100;
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index$1 = 0;
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index$1 = 0;
 /**
  * Reset the scheduler's state.
  */
@@ -3704,9 +3677,9 @@ function resetSchedulerState() {
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
-var currentFlushTimestamp = 0;
+let currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
+let getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3714,15 +3687,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance_1.now(); };
+        getNow = () => performance.now();
     }
 }
 /**
@@ -3731,7 +3704,7 @@ if (inBrowser && !isIE) {
 function flushSchedulerQueue() {
     currentFlushTimestamp = getNow();
     flushing = true;
-    var watcher, id;
+    let watcher, id;
     // Sort queue before flush.
     // This ensures that:
     // 1. Components are updated from parent to child. (because parent is always
@@ -3740,7 +3713,7 @@ function flushSchedulerQueue() {
     //    user watchers are created before the render watcher)
     // 3. If a component is destroyed during a parent component's watcher run,
     //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
+    queue.sort((a, b) => a.id - b.id);
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
     for (index$1 = 0; index$1 < queue.length; index$1++) {
@@ -3757,15 +3730,15 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? "in watcher with expression \"" + watcher.expression + "\""
-                        : "in a component render function."), watcher.vm);
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
                 break;
             }
         }
     }
     // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
     resetSchedulerState();
     // call component updated and activated hooks
     callActivatedHooks(activatedQueue);
@@ -3777,10 +3750,10 @@ function flushSchedulerQueue() {
     }
 }
 function callUpdatedHooks(queue) {
-    var i = queue.length;
+    let i = queue.length;
     while (i--) {
-        var watcher = queue[i];
-        var vm = watcher.vm;
+        const watcher = queue[i];
+        const vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
             callHook$1(vm, 'updated');
         }
@@ -3797,7 +3770,7 @@ function queueActivatedComponent(vm) {
     activatedChildren.push(vm);
 }
 function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
+    for (let i = 0; i < queue.length; i++) {
         queue[i]._inactive = true;
         activateChildComponent(queue[i], true /* true */);
     }
@@ -3808,7 +3781,7 @@ function callActivatedHooks(queue) {
  * pushed when the queue is being flushed.
  */
 function queueWatcher(watcher) {
-    var id = watcher.id;
+    const id = watcher.id;
     if (has[id] == null) {
         has[id] = true;
         if (!flushing) {
@@ -3817,7 +3790,7 @@ function queueWatcher(watcher) {
         else {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
-            var i = queue.length - 1;
+            let i = queue.length - 1;
             while (i > index$1 && queue[i].id > watcher.id) {
                 i--;
             }
@@ -3835,14 +3808,14 @@ function queueWatcher(watcher) {
     }
 }
 
-var uid$1 = 0;
+let uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = /** @class */ (function () {
-    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+class Watcher {
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
         this.vm = vm;
         if (isRenderWatcher) {
             vm._watcher = this;
@@ -3877,7 +3850,7 @@ var Watcher = /** @class */ (function () {
             this.getter = parsePath(expOrFn);
             if (!this.getter) {
                 this.getter = noop;
-                warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                warn$2(`Failed watching path: "${expOrFn}" ` +
                         'Watcher only accepts simple dot-delimited paths. ' +
                         'For full control, use a function instead.', vm);
             }
@@ -3887,16 +3860,16 @@ var Watcher = /** @class */ (function () {
     /**
      * Evaluate the getter, and re-collect dependencies.
      */
-    Watcher.prototype.get = function () {
+    get() {
         pushTarget(this);
-        var value;
-        var vm = this.vm;
+        let value;
+        const vm = this.vm;
         try {
             value = this.getter.call(vm, vm);
         }
         catch (e) {
             if (this.user) {
-                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
             }
             else {
                 throw e;
@@ -3912,12 +3885,12 @@ var Watcher = /** @class */ (function () {
             this.cleanupDeps();
         }
         return value;
-    };
+    }
     /**
      * Add a dependency to this directive.
      */
-    Watcher.prototype.addDep = function (dep) {
-        var id = dep.id;
+    addDep(dep) {
+        const id = dep.id;
         if (!this.newDepIds.has(id)) {
             this.newDepIds.add(id);
             this.newDeps.push(dep);
@@ -3925,19 +3898,19 @@ var Watcher = /** @class */ (function () {
                 dep.addSub(this);
             }
         }
-    };
+    }
     /**
      * Clean up for dependency collection.
      */
-    Watcher.prototype.cleanupDeps = function () {
-        var i = this.deps.length;
+    cleanupDeps() {
+        let i = this.deps.length;
         while (i--) {
-            var dep = this.deps[i];
+            const dep = this.deps[i];
             if (!this.newDepIds.has(dep.id)) {
                 dep.removeSub(this);
             }
         }
-        var tmp = this.depIds;
+        let tmp = this.depIds;
         this.depIds = this.newDepIds;
         this.newDepIds = tmp;
         this.newDepIds.clear();
@@ -3945,12 +3918,12 @@ var Watcher = /** @class */ (function () {
         this.deps = this.newDeps;
         this.newDeps = tmp;
         this.newDeps.length = 0;
-    };
+    }
     /**
      * Subscriber interface.
      * Will be called when a dependency changes.
      */
-    Watcher.prototype.update = function () {
+    update() {
         /* istanbul ignore else */
         if (this.lazy) {
             this.dirty = true;
@@ -3961,14 +3934,14 @@ var Watcher = /** @class */ (function () {
         else {
             queueWatcher(this);
         }
-    };
+    }
     /**
      * Scheduler job interface.
      * Will be called by the scheduler.
      */
-    Watcher.prototype.run = function () {
+    run() {
         if (this.active) {
-            var value = this.get();
+            const value = this.get();
             if (value !== this.value ||
                 // Deep watchers and watchers on Object/Arrays should fire even
                 // when the value is the same, because the value may
@@ -3976,14 +3949,14 @@ var Watcher = /** @class */ (function () {
                 isObject(value) ||
                 this.deep) {
                 // set new value
-                var oldValue = this.value;
+                const oldValue = this.value;
                 this.value = value;
                 if (this.user) {
                     try {
                         this.cb.call(this.vm, value, oldValue);
                     }
                     catch (e) {
-                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
+                        handleError(e, this.vm, `callback for watcher "${this.expression}"`);
                     }
                 }
                 else {
@@ -3991,28 +3964,28 @@ var Watcher = /** @class */ (function () {
                 }
             }
         }
-    };
+    }
     /**
      * Evaluate the value of the watcher.
      * This only gets called for lazy watchers.
      */
-    Watcher.prototype.evaluate = function () {
+    evaluate() {
         this.value = this.get();
         this.dirty = false;
-    };
+    }
     /**
      * Depend on all deps collected by this watcher.
      */
-    Watcher.prototype.depend = function () {
-        var i = this.deps.length;
+    depend() {
+        let i = this.deps.length;
         while (i--) {
             this.deps[i].depend();
         }
-    };
+    }
     /**
      * Remove self from all dependencies' subscriber list.
      */
-    Watcher.prototype.teardown = function () {
+    teardown() {
         if (this.active) {
             // remove self from vm's watcher list
             // this is a somewhat expensive operation so we skip it
@@ -4020,17 +3993,16 @@ var Watcher = /** @class */ (function () {
             if (!this.vm._isBeingDestroyed) {
                 remove$2(this.vm._watchers, this);
             }
-            var i = this.deps.length;
+            let i = this.deps.length;
             while (i--) {
                 this.deps[i].removeSub(this);
             }
             this.active = false;
         }
-    };
-    return Watcher;
-}());
+    }
+}
 
-var sharedPropertyDefinition = {
+const sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
     get: noop,
@@ -4047,7 +4019,7 @@ function proxy(target, sourceKey, key) {
 }
 function initState(vm) {
     vm._watchers = [];
-    var opts = vm.$options;
+    const opts = vm.$options;
     if (opts.props)
         initProps$1(vm, opts.props);
     if (opts.methods)
@@ -4065,32 +4037,32 @@ function initState(vm) {
     }
 }
 function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
     // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
     // root instance props should be converted
     if (!isRoot) {
         toggleObserving(false);
     }
-    var _loop_1 = function (key) {
+    for (const key in propsOptions) {
         keys.push(key);
-        var value = validateProp(key, propsOptions, propsData, vm);
+        const value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
         {
-            var hyphenatedKey = hyphenate(key);
+            const hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
             }
-            defineReactive(props, key, value, function () {
+            defineReactive(props, key, value, () => {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2("Avoid mutating a prop directly since the value will be " +
-                        "overwritten whenever the parent component re-renders. " +
-                        "Instead, use a data or computed property based on the prop's " +
-                        ("value. Prop being mutated: \"" + key + "\""), vm);
+                    warn$2(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
                 }
             });
         }
@@ -4098,16 +4070,13 @@ function initProps$1(vm, propsOptions) {
         // during Vue.extend(). We only need to proxy props defined at
         // instantiation here.
         if (!(key in vm)) {
-            proxy(vm, "_props", key);
+            proxy(vm, `_props`, key);
         }
-    };
-    for (var key in propsOptions) {
-        _loop_1(key);
     }
     toggleObserving(true);
 }
 function initData(vm) {
-    var data = vm.$options.data;
+    let data = vm.$options.data;
     data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
@@ -4115,23 +4084,23 @@ function initData(vm) {
                 'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
     }
     // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
     while (i--) {
-        var key = keys[i];
+        const key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
+                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            warn$2("The data property \"" + key + "\" is already declared as a prop. " +
-                    "Use prop default value instead.", vm);
+            warn$2(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
         }
         else if (!isReserved(key)) {
-            proxy(vm, "_data", key);
+            proxy(vm, `_data`, key);
         }
     }
     // observe data
@@ -4144,24 +4113,24 @@ function getData(data, vm) {
         return data.call(vm, vm);
     }
     catch (e) {
-        handleError(e, vm, "data()");
+        handleError(e, vm, `data()`);
         return {};
     }
     finally {
         popTarget();
     }
 }
-var computedWatcherOptions = { lazy: true };
+const computedWatcherOptions = { lazy: true };
 function initComputed$1(vm, computed) {
     // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
+    const watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-        var userDef = computed[key];
-        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (getter == null) {
-            warn$2("Getter is missing for computed property \"" + key + "\".", vm);
+            warn$2(`Getter is missing for computed property "${key}".`, vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4175,16 +4144,16 @@ function initComputed$1(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
+                warn$2(`The computed property "${key}" is already defined in data.`, vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
             }
         }
     }
 }
 function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
+    const shouldCache = !isServerRendering();
     if (typeof userDef === 'function') {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
@@ -4201,14 +4170,14 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
 }
 function createComputedGetter(key) {
     return function computedGetter() {
-        var watcher = this._computedWatchers && this._computedWatchers[key];
+        const watcher = this._computedWatchers && this._computedWatchers[key];
         if (watcher) {
             if (watcher.dirty) {
                 watcher.evaluate();
@@ -4226,29 +4195,29 @@ function createGetterInvoker(fn) {
     };
 }
 function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
         {
             if (typeof methods[key] !== 'function') {
-                warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
-                    "Did you reference the function correctly?", vm);
+                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
             }
             if (props && hasOwn(props, key)) {
-                warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
+                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
             }
             if (key in vm && isReserved(key)) {
-                warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                    "Avoid defining component methods that start with _ or $.");
+                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
             }
         }
         vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
-    for (var key in watch) {
-        var handler = watch[key];
+    for (const key in watch) {
+        const handler = watch[key];
         if (Array.isArray(handler)) {
-            for (var i = 0; i < handler.length; i++) {
+            for (let i = 0; i < handler.length; i++) {
                 createWatcher(vm, key, handler[i]);
             }
         }
@@ -4271,11 +4240,11 @@ function stateMixin(Vue) {
     // flow somehow has problems with directly declared definition object
     // when using Object.defineProperty, so we have to procedurally build up
     // the object here.
-    var dataDef = {};
+    const dataDef = {};
     dataDef.get = function () {
         return this._data;
     };
-    var propsDef = {};
+    const propsDef = {};
     propsDef.get = function () {
         return this._props;
     };
@@ -4285,7 +4254,7 @@ function stateMixin(Vue) {
                 'Use nested data properties instead.', this);
         };
         propsDef.set = function () {
-            warn$2("$props is readonly.", this);
+            warn$2(`$props is readonly.`, this);
         };
     }
     Object.defineProperty(Vue.prototype, '$data', dataDef);
@@ -4293,20 +4262,20 @@ function stateMixin(Vue) {
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
-        var vm = this;
+        const vm = this;
         if (isPlainObject(cb)) {
             return createWatcher(vm, expOrFn, cb, options);
         }
         options = options || {};
         options.user = true;
-        var watcher = new Watcher(vm, expOrFn, cb, options);
+        const watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
             pushTarget();
             try {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`);
             }
             popTarget();
         }
@@ -4316,17 +4285,17 @@ function stateMixin(Vue) {
     };
 }
 
-var uid = 0;
+let uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
-        var vm = this;
+        const vm = this;
         // a uid
         vm._uid = uid++;
-        var startTag, endTag;
+        let startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + vm._uid;
-            endTag = "vue-perf-end:" + vm._uid;
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4359,7 +4328,7 @@ function initMixin$1(Vue) {
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure("vue " + vm._name + " init", startTag, endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4368,12 +4337,12 @@ function initMixin$1(Vue) {
 }
 function initInternalComponent(vm, options) {
     // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
+    const opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
+    const parentVnode = options._parentVnode;
     opts.parent = options.parent;
     opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
+    const vnodeComponentOptions = parentVnode.componentOptions;
     opts.propsData = vnodeComponentOptions.propsData;
     opts._parentListeners = vnodeComponentOptions.listeners;
     opts._renderChildren = vnodeComponentOptions.children;
@@ -4384,16 +4353,16 @@ function initInternalComponent(vm, options) {
     }
 }
 function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
+    let options = Ctor.options;
     if (Ctor.super) {
-        var superOptions = resolveConstructorOptions(Ctor.super);
-        var cachedSuperOptions = Ctor.superOptions;
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
         if (superOptions !== cachedSuperOptions) {
             // super option changed,
             // need to resolve new options.
             Ctor.superOptions = superOptions;
             // check if there are any late-modified/attached options (#4976)
-            var modifiedOptions = resolveModifiedOptions(Ctor);
+            const modifiedOptions = resolveModifiedOptions(Ctor);
             // update base extend options
             if (modifiedOptions) {
                 extend(Ctor.extendOptions, modifiedOptions);
@@ -4407,10 +4376,10 @@ function resolveConstructorOptions(Ctor) {
     return options;
 }
 function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
         if (latest[key] !== sealed[key]) {
             if (!modified)
                 modified = {};
@@ -4439,12 +4408,12 @@ renderMixin(Vue);
 
 function initUse(Vue) {
     Vue.use = function (plugin) {
-        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
         if (installedPlugins.indexOf(plugin) > -1) {
             return this;
         }
         // additional parameters
-        var args = toArray(arguments, 1);
+        const args = toArray(arguments, 1);
         args.unshift(this);
         if (typeof plugin.install === 'function') {
             plugin.install.apply(plugin, args);
@@ -4471,23 +4440,23 @@ function initExtend(Vue) {
      * constructors" for prototypal inheritance and cache them.
      */
     Vue.cid = 0;
-    var cid = 1;
+    let cid = 1;
     /**
      * Class inheritance
      */
     Vue.extend = function (extendOptions) {
         extendOptions = extendOptions || {};
-        var Super = this;
-        var SuperId = Super.cid;
-        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
         if (cachedCtors[SuperId]) {
             return cachedCtors[SuperId];
         }
-        var name = extendOptions.name || Super.options.name;
+        const name = extendOptions.name || Super.options.name;
         if (name) {
             validateComponentName(name);
         }
-        var Sub = function VueComponent(options) {
+        const Sub = function VueComponent(options) {
             this._init(options);
         };
         Sub.prototype = Object.create(Super.prototype);
@@ -4529,14 +4498,14 @@ function initExtend(Vue) {
     };
 }
 function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-        proxy(Comp.prototype, "_props", key);
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
     }
 }
 function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
     }
 }
@@ -4545,7 +4514,7 @@ function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
      */
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         // @ts-expect-error function is not exact same type
         Vue[type] = function (id, definition) {
             if (!definition) {
@@ -4588,19 +4557,19 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-        var cachedNode = cache[key];
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const cachedNode = cache[key];
         if (cachedNode) {
-            var name_1 = getComponentName(cachedNode.componentOptions);
-            if (name_1 && !filter(name_1)) {
+            const name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
+    const cached = cache[key];
     if (cached && (!current || cached.tag !== current.tag)) {
         //@ts-expect-error has void type
         cached.componentInstance.$destroy();
@@ -4608,7 +4577,7 @@ function pruneCacheEntry(cache, key, keys, current) {
     cache[key] = null;
     remove$2(keys, key);
 }
-var patternTypes = [String, RegExp, Array];
+const patternTypes = [String, RegExp, Array];
 // TODO use defineComponent
 var KeepAlive = {
     name: 'keep-alive',
@@ -4618,45 +4587,44 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function () {
+    created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function () {
-        for (var key in this.cache) {
+    destroyed() {
+        for (const key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function () {
-        var _this = this;
-        this.$watch('include', function (val) {
-            pruneCache(_this, function (name) { return matches(val, name); });
+    mounted() {
+        this.$watch('include', (val) => {
+            pruneCache(this, (name) => matches(val, name));
         });
-        this.$watch('exclude', function (val) {
-            pruneCache(_this, function (name) { return !matches(val, name); });
+        this.$watch('exclude', (val) => {
+            pruneCache(this, (name) => !matches(val, name));
         });
     },
-    render: function () {
-        var slot = this.$slots.default;
-        var vnode = getFirstComponentChild(slot);
-        var componentOptions = vnode && vnode.componentOptions;
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name_2 = getComponentName(componentOptions);
-            var _a = this, include = _a.include, exclude = _a.exclude;
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
             if (
             // not included
-            (include && (!name_2 || !matches(include, name_2))) ||
+            (include && (!name || !matches(include, name))) ||
                 // excluded
-                (exclude && name_2 && matches(exclude, name_2))) {
+                (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var _b = this, cache = _b.cache, keys = _b.keys;
-            var key = vnode.key == null
+            const { cache, keys } = this;
+            const key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? "::" + componentOptions.tag : '')
+                        (componentOptions.tag ? `::${componentOptions.tag}` : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4679,15 +4647,15 @@ var KeepAlive = {
 };
 
 var builtInComponents = {
-    KeepAlive: KeepAlive,
+    KeepAlive,
 };
 
 function initGlobalAPI(Vue) {
     // config
-    var configDef = {};
-    configDef.get = function () { return config; };
+    const configDef = {};
+    configDef.get = () => config;
     {
-        configDef.set = function () {
+        configDef.set = () => {
             warn$2('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
@@ -4697,20 +4665,20 @@ function initGlobalAPI(Vue) {
     // them unless you are aware of the risk.
     Vue.util = {
         warn: warn$2,
-        extend: extend,
-        mergeOptions: mergeOptions,
-        defineReactive: defineReactive,
+        extend,
+        mergeOptions,
+        defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
     Vue.nextTick = nextTick;
     // 2.6 explicit observable API
-    Vue.observable = function (obj) {
+    Vue.observable = (obj) => {
         observe(obj);
         return obj;
     };
     Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         Vue.options[type + 's'] = Object.create(null);
     });
     // this is used to identify the "base" constructor to extend all plain-object
@@ -4728,7 +4696,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function () {
+    get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4741,18 +4709,18 @@ Vue.version = '2.6.12';
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+const isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue$1 = makeMap('input,textarea,option,select,progress');
-var mustUseProp$1 = function (tag, type, attr) {
+const acceptValue$1 = makeMap('input,textarea,option,select,progress');
+const mustUseProp$1 = (tag, type, attr) => {
     return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-var convertEnumeratedValue = function (key, value) {
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
     return isFalsyAttrValue(value) || value === 'false'
         ? 'false'
         : // allow arbitrary string value for contenteditable
@@ -4760,27 +4728,27 @@ var convertEnumeratedValue = function (key, value) {
                 ? value
                 : 'true';
 };
-var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
-var xlinkNS = 'http://www.w3.org/1999/xlink';
-var isXlink = function (name) {
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
     return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-var getXlinkProp = function (name) {
+const getXlinkProp = (name) => {
     return isXlink(name) ? name.slice(6, name.length) : '';
 };
-var isFalsyAttrValue = function (val) {
+const isFalsyAttrValue = (val) => {
     return val == null || val === false;
 };
 
 function genClassForVnode(vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
     while (isDef(childNode.componentInstance)) {
         childNode = childNode.componentInstance._vnode;
         if (childNode && childNode.data) {
@@ -4824,9 +4792,9 @@ function stringifyClass(value) {
     return '';
 }
 function stringifyArray(value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
         if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
             if (res)
                 res += ' ';
@@ -4836,8 +4804,8 @@ function stringifyArray(value) {
     return res;
 }
 function stringifyObject(value) {
-    var res = '';
-    for (var key in value) {
+    let res = '';
+    for (const key in value) {
         if (value[key]) {
             if (res)
                 res += ' ';
@@ -4847,11 +4815,11 @@ function stringifyObject(value) {
     return res;
 }
 
-var namespaceMap = {
+const namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4864,10 +4832,10 @@ var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isReservedTag$1 = function (tag) {
+const isReservedTag$1 = (tag) => {
     return isHTMLTag$1(tag) || isSVG$1(tag);
 };
 function getTagNamespace$1(tag) {
@@ -4880,7 +4848,7 @@ function getTagNamespace$1(tag) {
         return 'math';
     }
 }
-var unknownElementCache = Object.create(null);
+const unknownElementCache = Object.create(null);
 function isUnknownElement(tag) {
     /* istanbul ignore if */
     if (!inBrowser) {
@@ -4894,7 +4862,7 @@ function isUnknownElement(tag) {
     if (unknownElementCache[tag] != null) {
         return unknownElementCache[tag];
     }
-    var el = document.createElement(tag);
+    const el = document.createElement(tag);
     if (tag.indexOf('-') > -1) {
         // http://stackoverflow.com/a/28210364/1070244
         return (unknownElementCache[tag] =
@@ -4905,14 +4873,14 @@ function isUnknownElement(tag) {
         return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /**
  * Query an element selector if it's not an element already.
  */
 function query$1(el) {
     if (typeof el === 'string') {
-        var selected = document.querySelector(el);
+        const selected = document.querySelector(el);
         if (!selected) {
             warn$2('Cannot find element: ' + el);
             return document.createElement('div');
@@ -4925,7 +4893,7 @@ function query$1(el) {
 }
 
 function createElement(tagName, vnode) {
-    var elm = document.createElement(tagName);
+    const elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
     }
@@ -4988,26 +4956,26 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 });
 
 var ref = {
-    create: function (_, vnode) {
+    create(_, vnode) {
         registerRef(vnode);
     },
-    update: function (oldVnode, vnode) {
+    update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function (vnode) {
+    destroy(vnode) {
         registerRef(vnode, true);
     },
 };
 function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
+    const key = vnode.data.ref;
     if (!isDef(key))
         return;
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
     if (isRemoval) {
         if (Array.isArray(refs[key])) {
             // @ts-expect-error invalid typings
@@ -5046,8 +5014,8 @@ function registerRef(vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-var emptyNode = new VNode('', {}, []);
-var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
         ((a.tag === b.tag &&
@@ -5061,14 +5029,14 @@ function sameVnode(a, b) {
 function sameInputType(a, b) {
     if (a.tag !== 'input')
         return true;
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
     return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
 function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
+    let i, key;
+    const map = {};
     for (i = beginIdx; i <= endIdx; ++i) {
         key = children[i].key;
         if (isDef(key))
@@ -5077,9 +5045,9 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
     return map;
 }
 function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules, nodeOps = backend.nodeOps;
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5101,7 +5069,7 @@ function createPatchFunction(backend) {
         return remove;
     }
     function removeNode(el) {
-        var parent = nodeOps.parentNode(el);
+        const parent = nodeOps.parentNode(el);
         // element may have already been removed due to v-html / v-text
         if (isDef(parent)) {
             nodeOps.removeChild(parent, el);
@@ -5111,14 +5079,14 @@ function createPatchFunction(backend) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
-                config.ignoredElements.some(function (ignore) {
+                config.ignoredElements.some((ignore) => {
                     return isRegExp(ignore)
                         ? ignore.test(vnode.tag)
                         : ignore === vnode.tag;
                 })) &&
             config.isUnknownElement(vnode.tag));
     }
-    var creatingElmInVPre = 0;
+    let creatingElmInVPre = 0;
     function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
         if (isDef(vnode.elm) && isDef(ownerArray)) {
             // This vnode was used in a previous render!
@@ -5132,9 +5100,9 @@ function createPatchFunction(backend) {
         if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
             return;
         }
-        var data = vnode.data;
-        var children = vnode.children;
-        var tag = vnode.tag;
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
         if (isDef(tag)) {
             {
                 if (data && data.pre) {
@@ -5174,9 +5142,9 @@ function createPatchFunction(backend) {
         }
     }
     function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i = vnode.data;
+        let i = vnode.data;
         if (isDef(i)) {
-            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
             if (isDef((i = i.hook)) && isDef((i = i.init))) {
                 i(vnode, false /* hydrating */);
             }
@@ -5213,12 +5181,12 @@ function createPatchFunction(backend) {
         }
     }
     function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i;
+        let i;
         // hack for #4339: a reactivated component with inner transition
         // does not trigger because the inner node's created hooks are not called
         // again. It's not ideal to involve module-specific logic in here but
         // there doesn't seem to be a better way to do it.
-        var innerNode = vnode;
+        let innerNode = vnode;
         while (innerNode.componentInstance) {
             innerNode = innerNode.componentInstance._vnode;
             if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5250,8 +5218,8 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5265,8 +5233,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-            cbs.create[i_2](emptyNode, vnode);
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5280,12 +5248,12 @@ function createPatchFunction(backend) {
     // this is implemented as a special case to avoid the overhead
     // of going through the normal attribute patching process.
     function setScope(vnode) {
-        var i;
+        let i;
         if (isDef((i = vnode.fnScopeId))) {
             nodeOps.setStyleScope(vnode.elm, i);
         }
         else {
-            var ancestor = vnode;
+            let ancestor = vnode;
             while (ancestor) {
                 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                     nodeOps.setStyleScope(vnode.elm, i);
@@ -5307,8 +5275,8 @@ function createPatchFunction(backend) {
         }
     }
     function invokeDestroyHook(vnode) {
-        var i, j;
-        var data = vnode.data;
+        let i, j;
+        const data = vnode.data;
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.destroy)))
                 i(vnode);
@@ -5323,7 +5291,7 @@ function createPatchFunction(backend) {
     }
     function removeVnodes(vnodes, startIdx, endIdx) {
         for (; startIdx <= endIdx; ++startIdx) {
-            var ch = vnodes[startIdx];
+            const ch = vnodes[startIdx];
             if (isDef(ch)) {
                 if (isDef(ch.tag)) {
                     removeAndInvokeRemoveHook(ch);
@@ -5338,8 +5306,8 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i_3;
-            var listeners = cbs.remove.length + 1;
+            let i;
+            const listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
                 // increase the listeners count
@@ -5350,16 +5318,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i_3 = vnode.componentInstance)) &&
-                isDef((i_3 = i_3._vnode)) &&
-                isDef(i_3.data)) {
-                removeAndInvokeRemoveHook(i_3, rm);
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
             }
-            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                cbs.remove[i_3](vnode, rm);
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
             }
-            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                i_3(vnode, rm);
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
             }
             else {
                 rm();
@@ -5370,19 +5338,19 @@ function createPatchFunction(backend) {
         }
     }
     function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        var oldStartIdx = 0;
-        var newStartIdx = 0;
-        var oldEndIdx = oldCh.length - 1;
-        var oldStartVnode = oldCh[0];
-        var oldEndVnode = oldCh[oldEndIdx];
-        var newEndIdx = newCh.length - 1;
-        var newStartVnode = newCh[0];
-        var newEndVnode = newCh[newEndIdx];
-        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
         // removeOnly is a special flag used only by <transition-group>
         // to ensure removed elements stay in correct relative positions
         // during leaving transitions
-        var canMove = !removeOnly;
+        const canMove = !removeOnly;
         {
             checkDuplicateKeys(newCh);
         }
@@ -5454,13 +5422,13 @@ function createPatchFunction(backend) {
         }
     }
     function checkDuplicateKeys(children) {
-        var seenKeys = {};
-        for (var i_4 = 0; i_4 < children.length; i_4++) {
-            var vnode = children[i_4];
-            var key = vnode.key;
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5469,10 +5437,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i_5 = start; i_5 < end; i_5++) {
-            var c = oldCh[i_5];
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                return i_5;
+                return i;
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5483,7 +5451,7 @@ function createPatchFunction(backend) {
             // clone reused vnode
             vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        var elm = (vnode.elm = oldVnode.elm);
+        const elm = (vnode.elm = oldVnode.elm);
         if (isTrue(oldVnode.isAsyncPlaceholder)) {
             if (isDef(vnode.asyncFactory.resolved)) {
                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5504,13 +5472,13 @@ function createPatchFunction(backend) {
             vnode.componentInstance = oldVnode.componentInstance;
             return;
         }
-        var i;
-        var data = vnode.data;
+        let i;
+        const data = vnode.data;
         if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
             i(oldVnode, vnode);
         }
-        var oldCh = oldVnode.children;
-        var ch = vnode.children;
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
         if (isDef(data) && isPatchable(vnode)) {
             for (i = 0; i < cbs.update.length; ++i)
                 cbs.update[i](oldVnode, vnode);
@@ -5552,21 +5520,21 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                queue[i_6].data.hook.insert(queue[i_6]);
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
             }
         }
     }
-    var hydrationBailed = false;
+    let hydrationBailed = false;
     // list of modules that can skip create hook during hydration because they
     // are already rendered on the client or has no need for initialization
     // Note: style is excluded because it relies on initial clone for future
     // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        var i;
-        var tag = vnode.tag, data = vnode.data, children = vnode.children;
+        let i;
+        const { tag, data, children } = vnode;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5613,11 +5581,11 @@ function createPatchFunction(backend) {
                     }
                     else {
                         // iterate and compare children lists
-                        var childrenMatch = true;
-                        var childNode = elm.firstChild;
-                        for (var i_7 = 0; i_7 < children.length; i_7++) {
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5639,8 +5607,8 @@ function createPatchFunction(backend) {
                 }
             }
             if (isDef(data)) {
-                var fullInvoke = false;
-                for (var key in data) {
+                let fullInvoke = false;
+                for (const key in data) {
                     if (!isRenderedModule(key)) {
                         fullInvoke = true;
                         invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5675,15 +5643,15 @@ function createPatchFunction(backend) {
                 invokeDestroyHook(oldVnode);
             return;
         }
-        var isInitialPatch = false;
-        var insertedVnodeQueue = [];
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
         if (isUndef(oldVnode)) {
             // empty mount (likely as component), create new root element
             isInitialPatch = true;
             createElm(vnode, insertedVnodeQueue);
         }
         else {
-            var isRealElement = isDef(oldVnode.nodeType);
+            const isRealElement = isDef(oldVnode.nodeType);
             if (!isRealElement && sameVnode(oldVnode, vnode)) {
                 // patch existing root node
                 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5715,8 +5683,8 @@ function createPatchFunction(backend) {
                     oldVnode = emptyNodeAt(oldVnode);
                 }
                 // replacing existing element
-                var oldElm = oldVnode.elm;
-                var parentElm = nodeOps.parentNode(oldElm);
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
                 // create new node
                 createElm(vnode, insertedVnodeQueue, 
                 // extremely rare edge case: do not insert if old element is in a
@@ -5725,25 +5693,25 @@ function createPatchFunction(backend) {
                 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                 // update parent placeholder node element, recursively
                 if (isDef(vnode.parent)) {
-                    var ancestor = vnode.parent;
-                    var patchable = isPatchable(vnode);
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                            cbs.destroy[i_8](ancestor);
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                cbs.create[i_9](emptyNode, ancestor);
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert_1 = ancestor.data.hook.insert;
-                            if (insert_1.merged) {
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                    insert_1.fns[i_10]();
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
                                 }
                             }
                         }
@@ -5781,13 +5749,13 @@ function updateDirectives(oldVnode, vnode) {
     }
 }
 function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
     for (key in newDirs) {
         oldDir = oldDirs[key];
         dir = newDirs[key];
@@ -5809,8 +5777,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithInsert.length) {
-        var callInsert = function () {
-            for (var i = 0; i < dirsWithInsert.length; i++) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
                 callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
@@ -5822,8 +5790,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
                 callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
@@ -5837,14 +5805,14 @@ function _update(oldVnode, vnode) {
         }
     }
 }
-var emptyModifiers = Object.create(null);
+const emptyModifiers = Object.create(null);
 function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
+    const res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
         return res;
     }
-    var i, dir;
+    let i, dir;
     for (i = 0; i < dirs.length; i++) {
         dir = dirs[i];
         if (!dir.modifiers) {
@@ -5858,16 +5826,16 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
+    const fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
         }
     }
 }
@@ -5875,17 +5843,17 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 var baseModules = [ref, directives$1];
 
 function updateAttrs(oldVnode, vnode) {
-    var opts = vnode.componentOptions;
+    const opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
         return;
     }
     if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
         return;
     }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(attrs.__ob__)) {
         attrs = vnode.data.attrs = extend({}, attrs);
@@ -5961,11 +5929,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker_1 = function (e) {
+            const blocker = (e) => {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker_1);
+                el.removeEventListener('input', blocker);
             };
-            el.addEventListener('input', blocker_1);
+            el.addEventListener('input', blocker);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -5978,18 +5946,18 @@ var attrs = {
 };
 
 function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticClass) &&
         isUndef(data.class) &&
         (isUndef(oldData) ||
             (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
         return;
     }
-    var cls = genClassForVnode(vnode);
+    let cls = genClassForVnode(vnode);
     // handle transition classes
-    var transitionClass = el._transitionClasses;
+    const transitionClass = el._transitionClasses;
     if (isDef(transitionClass)) {
         cls = concat(cls, stringifyClass(transitionClass));
     }
@@ -6004,17 +5972,17 @@ var klass$1 = {
     update: updateClass,
 };
 
-var validDivisionCharRE = /[\w).+\-_$\]]/;
+const validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
     for (i = 0; i < exp.length; i++) {
         prev = c;
         c = exp.charCodeAt(i);
@@ -6081,10 +6049,8 @@ function parseFilters(exp) {
             }
             if (c === 0x2f) {
                 // /
-                var j = i - 1;
-                var p 
-                // find first non-whitespace prev char
-                = void 0;
+                let j = i - 1;
+                let p;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -6115,55 +6081,55 @@ function parseFilters(exp) {
     return expression;
 }
 function wrapFilter(exp, filter) {
-    var i = filter.indexOf('(');
+    const i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return "_f(\"" + filter + "\")(" + exp + ")";
+        return `_f("${filter}")(${exp})`;
     }
     else {
-        var name_1 = filter.slice(0, i);
-        var args = filter.slice(i + 1);
-        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
     }
 }
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error("[Vue compiler]: " + msg);
+    console.error(`[Vue compiler]: ${msg}`);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
-    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
 }
 function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
     el.plain = false;
 }
 function addAttr(el, name, value, range, dynamic) {
-    var attrs = dynamic
+    const attrs = dynamic
         ? el.dynamicAttrs || (el.dynamicAttrs = [])
         : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
     el.plain = false;
 }
 // add a raw attr (use this in preTransforms)
 function addRawAttr(el, name, value, range) {
     el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+    el.attrsList.push(rangeSetItem({ name, value }, range));
 }
 function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
     (el.directives || (el.directives = [])).push(rangeSetItem({
-        name: name,
-        rawName: rawName,
-        value: value,
-        arg: arg,
-        isDynamicArg: isDynamicArg,
-        modifiers: modifiers,
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
     }, range));
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6180,7 +6146,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     // the only target envs that have right/middle clicks.
     if (modifiers.right) {
         if (dynamic) {
-            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+            name = `(${name})==='click'?'contextmenu':(${name})`;
         }
         else if (name === 'click') {
             name = 'contextmenu';
@@ -6189,7 +6155,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     }
     else if (modifiers.middle) {
         if (dynamic) {
-            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+            name = `(${name})==='click'?'mouseup':(${name})`;
         }
         else if (name === 'click') {
             name = 'mouseup';
@@ -6209,7 +6175,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
         delete modifiers.passive;
         name = prependModifierMarker('&', name, dynamic);
     }
-    var events;
+    let events;
     if (modifiers.native) {
         delete modifiers.native;
         events = el.nativeEvents || (el.nativeEvents = {});
@@ -6217,11 +6183,11 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     else {
         events = el.events || (el.events = {});
     }
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
     if (modifiers !== emptyObject) {
         newHandler.modifiers = modifiers;
     }
-    var handlers = events[name];
+    const handlers = events[name];
     /* istanbul ignore if */
     if (Array.isArray(handlers)) {
         important ? handlers.unshift(newHandler) : handlers.push(newHandler);
@@ -6240,12 +6206,12 @@ function getRawBindingAttr(el, name) {
         el.rawAttrsMap[name]);
 }
 function getBindingAttr(el, name, getStatic) {
-    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
     if (dynamicValue != null) {
         return parseFilters(dynamicValue);
     }
     else if (getStatic !== false) {
-        var staticValue = getAndRemoveAttr(el, name);
+        const staticValue = getAndRemoveAttr(el, name);
         if (staticValue != null) {
             return JSON.stringify(staticValue);
         }
@@ -6256,10 +6222,10 @@ function getBindingAttr(el, name, getStatic) {
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
 function getAndRemoveAttr(el, name, removeFromMap) {
-    var val;
+    let val;
     if ((val = el.attrsMap[name]) != null) {
-        var list = el.attrsList;
-        for (var i = 0, l = list.length; i < l; i++) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
             if (list[i].name === name) {
                 list.splice(i, 1);
                 break;
@@ -6272,9 +6238,9 @@ function getAndRemoveAttr(el, name, removeFromMap) {
     return val;
 }
 function getAndRemoveAttrByRegex(el, name) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-        var attr = list[i];
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
         if (name.test(attr.name)) {
             list.splice(i, 1);
             return attr;
@@ -6297,35 +6263,35 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
-            "(typeof " + baseValueExpression + " === 'string'" +
-                ("? " + baseValueExpression + ".trim()") +
-                (": " + baseValueExpression + ")");
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
     }
     if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
+        valueExpression = `_n(${valueExpression})`;
     }
-    var assignment = genAssignmentCode(value, valueExpression);
+    const assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: "(" + value + ")",
+        value: `(${value})`,
         expression: JSON.stringify(value),
-        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+        callback: `function (${baseValueExpression}) {${assignment}}`,
     };
 }
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
 function genAssignmentCode(value, assignment) {
-    var res = parseModel(value);
+    const res = parseModel(value);
     if (res.key === null) {
-        return value + "=" + assignment;
+        return `${value}=${assignment}`;
     }
     else {
-        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
     }
 }
 /**
@@ -6342,7 +6308,7 @@ function genAssignmentCode(value, assignment) {
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-var len, str, chr, index, expressionPos, expressionEndPos;
+let len, str, chr, index, expressionPos, expressionEndPos;
 function parseModel(val) {
     // Fix https://github.com/vuejs/vue/pull/7730
     // allow v-model="obj.val " (trailing whitespace)
@@ -6390,7 +6356,7 @@ function isStringStart(chr) {
     return chr === 0x22 || chr === 0x27;
 }
 function parseBracket(chr) {
-    var inBracket = 1;
+    let inBracket = 1;
     expressionPos = index;
     while (!eof()) {
         chr = next();
@@ -6409,7 +6375,7 @@ function parseBracket(chr) {
     }
 }
 function parseString(chr) {
-    var stringQuote = chr;
+    const stringQuote = chr;
     while (!eof()) {
         chr = next();
         if (chr === stringQuote) {
@@ -6420,8 +6386,8 @@ function parseString(chr) {
 
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN$1 = '__r';
-var CHECKBOX_RADIO_TOKEN = '__c';
+const RANGE_TOKEN$1 = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6431,8 +6397,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN$1])) {
         // IE input[type=range] only supports `change` event
-        var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
         delete on[RANGE_TOKEN$1];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6443,11 +6409,11 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target;
+let target;
 function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
+    const _target = target; // save current target element in closure
     return function onceHandler() {
-        var res = handler.apply(null, arguments);
+        const res = handler.apply(null, arguments);
         if (res !== null) {
             remove(event, onceHandler, capture, _target);
         }
@@ -6456,7 +6422,7 @@ function createOnceHandler(event, handler, capture) {
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
-var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
 function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
@@ -6465,17 +6431,17 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp_1 = currentFlushTimestamp;
-        var original_1 = handler;
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
         //@ts-expect-error
-        handler = original_1._wrapper = function (e) {
+        handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp_1 ||
+                e.timeStamp >= attachedTimestamp ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6484,11 +6450,11 @@ function add(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original_1.apply(this, arguments);
+                return original.apply(this, arguments);
             }
         };
     }
-    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
 }
 function remove(name, handler, capture, _target) {
     (_target || target).removeEventListener(name, 
@@ -6499,8 +6465,8 @@ function updateDOMListeners(oldVnode, vnode) {
     if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
         return;
     }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
     target = vnode.elm;
     normalizeEvents(on);
     updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
@@ -6511,15 +6477,15 @@ var events = {
     update: updateDOMListeners,
 };
 
-var svgContainer;
+let svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
         return;
     }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(props.__ob__)) {
         props = vnode.data.domProps = extend({}, props);
@@ -6550,7 +6516,7 @@ function updateDOMProps(oldVnode, vnode) {
             // non-string values will be stringified
             elm._value = cur;
             // avoid resetting cursor position when value is the same
-            var strCur = isUndef(cur) ? '' : String(cur);
+            const strCur = isUndef(cur) ? '' : String(cur);
             if (shouldUpdateValue(elm, strCur)) {
                 elm.value = strCur;
             }
@@ -6560,8 +6526,8 @@ function updateDOMProps(oldVnode, vnode) {
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-            var svg = svgContainer.firstChild;
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
             while (elm.firstChild) {
                 elm.removeChild(elm.firstChild);
             }
@@ -6595,7 +6561,7 @@ function shouldUpdateValue(elm, checkVal) {
 function isNotInFocusAndDirty(elm, checkVal) {
     // return true when textbox (.number and .trim) loses focus and its value is
     // not equal to the updated value
-    var notInFocus = true;
+    let notInFocus = true;
     // #6157
     // work around IE bug when accessing document.activeElement in an iframe
     try {
@@ -6605,8 +6571,8 @@ function isNotInFocusAndDirty(elm, checkVal) {
     return notInFocus && elm.value !== checkVal;
 }
 function isDirtyWithModifiers(elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
     if (isDef(modifiers)) {
         if (modifiers.number) {
             return toNumber(value) !== toNumber(newVal);
@@ -6622,13 +6588,13 @@ var domProps = {
     update: updateDOMProps,
 };
 
-var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
     cssText.split(listDelimiter).forEach(function (item) {
         if (item) {
-            var tmp = item.split(propertyDelimiter);
+            const tmp = item.split(propertyDelimiter);
             tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
         }
     });
@@ -6636,7 +6602,7 @@ var parseStyleText = cached(function (cssText) {
 });
 // merge static and dynamic style data on the same vnode
 function normalizeStyleData(data) {
-    var style = normalizeStyleBinding(data.style);
+    const style = normalizeStyleBinding(data.style);
     // static style is pre-processed into an object during compilation
     // and is always a fresh object, so it's safe to merge into it
     return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6656,10 +6622,10 @@ function normalizeStyleBinding(bindingStyle) {
  * so that parent component's style could override it
  */
 function getStyle(vnode, checkChild) {
-    var res = {};
-    var styleData;
+    const res = {};
+    let styleData;
     if (checkChild) {
-        var childNode = vnode;
+        let childNode = vnode;
         while (childNode.componentInstance) {
             childNode = childNode.componentInstance._vnode;
             if (childNode &&
@@ -6672,7 +6638,7 @@ function getStyle(vnode, checkChild) {
     if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
     }
-    var parentNode = vnode;
+    let parentNode = vnode;
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6681,9 +6647,9 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-var cssVarRE = /^--/;
-var importantRE = /\s*!important$/;
-var setProp = function (el, name, val) {
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
     /* istanbul ignore if */
     if (cssVarRE.test(name)) {
         el.style.setProperty(name, val);
@@ -6692,12 +6658,12 @@ var setProp = function (el, name, val) {
         el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
     }
     else {
-        var normalizedName = normalize(name);
+        const normalizedName = normalize(name);
         if (Array.isArray(val)) {
             // Support values array created by autoprefixer, e.g.
             // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
             // Set them one by one, and the browser will only set those it can recognize
-            for (var i = 0, len = val.length; i < len; i++) {
+            for (let i = 0, len = val.length; i < len; i++) {
                 el.style[normalizedName] = val[i];
             }
         }
@@ -6706,43 +6672,43 @@ var setProp = function (el, name, val) {
         }
     }
 };
-var vendorNames = ['Webkit', 'Moz', 'ms'];
-var emptyStyle;
-var normalize = cached(function (prop) {
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
     emptyStyle = emptyStyle || document.createElement('div').style;
     prop = camelize(prop);
     if (prop !== 'filter' && prop in emptyStyle) {
         return prop;
     }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-        var name_1 = vendorNames[i] + capName;
-        if (name_1 in emptyStyle) {
-            return name_1;
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
         }
     }
 });
 function updateStyle(oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticStyle) &&
         isUndef(data.style) &&
         isUndef(oldData.staticStyle) &&
         isUndef(oldData.style)) {
         return;
     }
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
     // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-    var style = normalizeStyleBinding(vnode.data.style) || {};
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
     // store normalized style under a different key for next diff
     // make sure to clone it if it's reactive, since the user likely wants
     // to mutate it.
     vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    var newStyle = getStyle(vnode, true);
+    const newStyle = getStyle(vnode, true);
     for (name in oldStyle) {
         if (isUndef(newStyle[name])) {
             setProp(el, name, '');
@@ -6761,7 +6727,7 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$2 = /\s+/;
+const whitespaceRE$2 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6774,14 +6740,14 @@ function addClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$2).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
+        const cur = ` ${el.getAttribute('class') || ''} `;
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -6799,7 +6765,7 @@ function removeClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$2).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -6809,8 +6775,8 @@ function removeClass$1(el, cls) {
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -6830,7 +6796,7 @@ function resolveTransition$1(def) {
     }
     /* istanbul ignore else */
     if (typeof def === 'object') {
-        var res = {};
+        const res = {};
         if (def.css !== false) {
             extend(res, autoCssTransition$1(def.name || 'v'));
         }
@@ -6841,24 +6807,24 @@ function resolveTransition$1(def) {
         return autoCssTransition$1(def);
     }
 }
-var autoCssTransition$1 = cached(function (name) {
+const autoCssTransition$1 = cached((name) => {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
     };
 });
-var hasTransition$1 = inBrowser && !isIE9;
-var TRANSITION$1 = 'transition';
-var ANIMATION$1 = 'animation';
+const hasTransition$1 = inBrowser && !isIE9;
+const TRANSITION$1 = 'transition';
+const ANIMATION$1 = 'animation';
 // Transition property/event sniffing
-var transitionProp$1 = 'transition';
-var transitionEndEvent$1 = 'transitionend';
-var animationProp$1 = 'animation';
-var animationEndEvent$1 = 'animationend';
+let transitionProp$1 = 'transition';
+let transitionEndEvent$1 = 'transitionend';
+let animationProp$1 = 'animation';
+let animationEndEvent$1 = 'animationend';
 if (hasTransition$1) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
@@ -6875,19 +6841,19 @@ if (hasTransition$1) {
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf$1 = inBrowser
+const raf$1 = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
+    : /* istanbul ignore next */ (fn) => fn();
 function nextFrame$1(fn) {
-    raf$1(function () {
+    raf$1(() => {
         // @ts-expect-error
         raf$1(fn);
     });
 }
 function addTransitionClass$1(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass$1(el, cls);
@@ -6900,42 +6866,42 @@ function removeTransitionClass$1(el, cls) {
     removeClass$1(el, cls);
 }
 function whenTransitionEnds$1(el, expectedType, cb) {
-    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    const { type, timeout, propCount } = getTransitionInfo$1(el, expectedType);
     if (!type)
         return cb();
-    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
-    var ended = 0;
-    var end = function () {
+    const event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+    let ended = 0;
+    const end = () => {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    var onEnd = function (e) {
+    const onEnd = (e) => {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(function () {
+    setTimeout(() => {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE$1 = /\b(transform|all)(,|$)/;
+const transformRE$1 = /\b(transform|all)(,|$)/;
 function getTransitionInfo$1(el, expectedType) {
-    var styles = window.getComputedStyle(el);
+    const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
+    const transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout$1(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION$1) {
         if (transitionTimeout > 0) {
@@ -6965,12 +6931,12 @@ function getTransitionInfo$1(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+    const hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
     return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
+        type,
+        timeout,
+        propCount,
+        hasTransform,
     };
 }
 function getTimeout$1(delays, durations) {
@@ -6978,7 +6944,7 @@ function getTimeout$1(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map(function (d, i) {
+    return Math.max.apply(null, durations.map((d, i) => {
         return toMs$1(d) + toMs$1(delays[i]);
     }));
 }
@@ -6991,13 +6957,13 @@ function toMs$1(s) {
 }
 
 function enter$1(vnode, toggleDisplay) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    const data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7005,41 +6971,41 @@ function enter$1(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
         checkDuration$1(explicitEnterDuration, 'enter', vnode);
     }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(enterHook);
-    var cb = (el._enterCb = once(function () {
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength$1(enterHook);
+    const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
             removeTransitionClass$1(el, toClass);
             removeTransitionClass$1(el, activeClass);
@@ -7058,9 +7024,9 @@ function enter$1(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -7074,7 +7040,7 @@ function enter$1(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass$1(el, startClass);
         addTransitionClass$1(el, activeClass);
-        nextFrame$1(function () {
+        nextFrame$1(() => {
             removeTransitionClass$1(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -7099,13 +7065,13 @@ function enter$1(vnode, toggleDisplay) {
     }
 }
 function leave$1(vnode, rm) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    const data = resolveTransition$1(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7113,14 +7079,14 @@ function leave$1(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength$1(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
         checkDuration$1(explicitLeaveDuration, 'leave', vnode);
     }
-    var cb = (el._leaveCb = once(function () {
+    const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -7161,7 +7127,7 @@ function leave$1(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass$1(el, leaveClass);
             addTransitionClass$1(el, leaveActiveClass);
-            nextFrame$1(function () {
+            nextFrame$1(() => {
                 removeTransitionClass$1(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -7186,11 +7152,11 @@ function leave$1(vnode, rm) {
 // only used in dev mode
 function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
     }
     else if (isNaN(val)) {
-        warn$2("<transition> explicit " + name + " duration is NaN - " +
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7208,7 +7174,7 @@ function getHookArgumentsLength$1(fn) {
         return false;
     }
     // @ts-expect-error
-    var invokerFns = fn.fns;
+    const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -7227,7 +7193,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function (vnode, rm) {
+        remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7244,8 +7210,8 @@ var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules$1 = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
+const modules$1 = platformModules.concat(baseModules);
+const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -7254,20 +7220,20 @@ var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 /* istanbul ignore if */
 if (isIE9) {
     // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-        var el = document.activeElement;
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
         // @ts-expect-error
         if (el && el.vmodel) {
             trigger(el, 'input');
         }
     });
 }
-var directive = {
-    inserted: function (el, binding, vnode, oldVnode) {
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', function () {
+                mergeVNodeHook(vnode, 'postpatch', () => {
                     directive.componentUpdated(el, binding, vnode);
                 });
             }
@@ -7293,22 +7259,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function (el, binding, vnode) {
+    componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions_1 = el._vOptions;
-            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                 // trigger change event if
                 // no matching option found for at least one value
-                var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions_1);
+                        hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7320,23 +7286,23 @@ function setSelected(el, binding, vm) {
     actuallySetSelected(el, binding, vm);
     /* istanbul ignore if */
     if (isIE || isEdge) {
-        setTimeout(function () {
+        setTimeout(() => {
             actuallySetSelected(el, binding, vm);
         }, 0);
     }
 }
 function actuallySetSelected(el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
+    const value = binding.value;
+    const isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
-                ("expects an Array value for its binding, but got " + Object.prototype.toString
+        warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
                     .call(value)
-                    .slice(8, -1)), vm);
+                    .slice(8, -1)}`, vm);
         return;
     }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
         option = el.options[i];
         if (isMultiple) {
             selected = looseIndexOf(value, getValue(option)) > -1;
@@ -7358,7 +7324,7 @@ function actuallySetSelected(el, binding, vm) {
     }
 }
 function hasNoMatchingOption(value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); });
+    return options.every((o) => !looseEqual(o, value));
 }
 function getValue(option) {
     return '_value' in option ? option._value : option.value;
@@ -7374,12 +7340,12 @@ function onCompositionEnd(e) {
     trigger(e.target, 'input');
 }
 function trigger(el, type) {
-    var e = document.createEvent('HTMLEvents');
+    const e = document.createEvent('HTMLEvents');
     e.initEvent(type, true, true);
     el.dispatchEvent(e);
 }
 
-var whitespaceRE$1 = /\s+/;
+const whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -7392,14 +7358,14 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
+        const cur = ` ${el.getAttribute('class') || ''} `;
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -7417,7 +7383,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -7427,8 +7393,8 @@ function removeClass(el, cls) {
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -7448,7 +7414,7 @@ function resolveTransition(def) {
     }
     /* istanbul ignore else */
     if (typeof def === 'object') {
-        var res = {};
+        const res = {};
         if (def.css !== false) {
             extend(res, autoCssTransition(def.name || 'v'));
         }
@@ -7459,24 +7425,24 @@ function resolveTransition(def) {
         return autoCssTransition(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+const autoCssTransition = cached((name) => {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
@@ -7493,19 +7459,19 @@ if (hasTransition) {
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+const raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
+    : /* istanbul ignore next */ (fn) => fn();
 function nextFrame(fn) {
-    raf(function () {
+    raf(() => {
         // @ts-expect-error
         raf(fn);
     });
 }
 function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass(el, cls);
@@ -7518,42 +7484,42 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
     if (!type)
         return cb();
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    var onEnd = function (e) {
+    const onEnd = (e) => {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(function () {
+    setTimeout(() => {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
+const transformRE = /\b(transform|all)(,|$)/;
 function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
+    const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
@@ -7583,12 +7549,12 @@ function getTransitionInfo(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
+        type,
+        timeout,
+        propCount,
+        hasTransform,
     };
 }
 function getTimeout(delays, durations) {
@@ -7596,7 +7562,7 @@ function getTimeout(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map(function (d, i) {
+    return Math.max.apply(null, durations.map((d, i) => {
         return toMs(d) + toMs(delays[i]);
     }));
 }
@@ -7609,13 +7575,13 @@ function toMs(s) {
 }
 
 function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7623,41 +7589,41 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
         checkDuration(explicitEnterDuration, 'enter', vnode);
     }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
             removeTransitionClass(el, toClass);
             removeTransitionClass(el, activeClass);
@@ -7676,9 +7642,9 @@ function enter(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -7692,7 +7658,7 @@ function enter(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass(el, startClass);
         addTransitionClass(el, activeClass);
-        nextFrame(function () {
+        nextFrame(() => {
             removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -7717,13 +7683,13 @@ function enter(vnode, toggleDisplay) {
     }
 }
 function leave(vnode, rm) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7731,14 +7697,14 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
         checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
-    var cb = (el._leaveCb = once(function () {
+    const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -7779,7 +7745,7 @@ function leave(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass(el, leaveClass);
             addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
+            nextFrame(() => {
                 removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -7804,11 +7770,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
     }
     else if (isNaN(val)) {
-        warn$2("<transition> explicit " + name + " duration is NaN - " +
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7826,7 +7792,7 @@ function getHookArgumentsLength(fn) {
         return false;
     }
     // @ts-expect-error
-    var invokerFns = fn.fns;
+    const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -7845,15 +7811,14 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
+    bind(el, { value }, vnode) {
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
         if (value && transition) {
             vnode.data.show = true;
-            enter(vnode, function () {
+            enter(vnode, () => {
                 el.style.display = originalDisplay;
             });
         }
@@ -7861,22 +7826,21 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
+    update(el, { value, oldValue }, vnode) {
         /* istanbul ignore if */
         if (!value === !oldValue)
             return;
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
+        const transition = vnode.data && vnode.data.transition;
         if (transition) {
             vnode.data.show = true;
             if (value) {
-                enter(vnode, function () {
+                enter(vnode, () => {
                     el.style.display = el.__vOriginalDisplay;
                 });
             }
             else {
-                leave(vnode, function () {
+                leave(vnode, () => {
                     el.style.display = 'none';
                 });
             }
@@ -7885,7 +7849,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7894,11 +7858,11 @@ var show = {
 
 var platformDirectives = {
     model: directive,
-    show: show,
+    show,
 };
 
 // Provides transition support for a single element/component.
-var transitionProps = {
+const transitionProps = {
     name: String,
     appear: Boolean,
     css: Boolean,
@@ -7918,7 +7882,7 @@ var transitionProps = {
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
 function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
+    const compOptions = vnode && vnode.componentOptions;
     if (compOptions && compOptions.Ctor.options.abstract) {
         return getRealChild(getFirstComponentChild(compOptions.children));
     }
@@ -7927,16 +7891,16 @@ function getRealChild(vnode) {
     }
 }
 function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
+    const data = {};
+    const options = comp.$options;
     // props
-    for (var key in options.propsData) {
+    for (const key in options.propsData) {
         data[key] = comp[key];
     }
     // events.
     // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key in listeners) {
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
         data[camelize(key)] = listeners[key];
     }
     return data;
@@ -7959,15 +7923,14 @@ function hasParentTransition(vnode) {
 function isSameChild(child, oldChild) {
     return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-var isVShowDirective = function (d) { return d.name === 'show'; };
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
 var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function (h) {
-        var _this = this;
-        var children = this.$slots.default;
+    render(h) {
+        let children = this.$slots.default;
         if (!children) {
             return;
         }
@@ -7982,14 +7945,14 @@ var Transition = {
             warn$2('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
-        var mode = this.mode;
+        const mode = this.mode;
         // warn invalid mode
         if (mode &&
             mode !== 'in-out' &&
             mode !== 'out-in') {
             warn$2('invalid <transition> mode: ' + mode, this.$parent);
         }
-        var rawChild = children[0];
+        const rawChild = children[0];
         // if this is a component root node and the component's
         // parent container node also has transition, skip.
         if (hasParentTransition(this.$vnode)) {
@@ -7997,7 +7960,7 @@ var Transition = {
         }
         // apply transition data to child
         // use getRealChild() to ignore abstract components e.g. keep-alive
-        var child = getRealChild(rawChild);
+        const child = getRealChild(rawChild);
         /* istanbul ignore if */
         if (!child) {
             return rawChild;
@@ -8008,7 +7971,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + this._uid + "-";
+        const id = `__transition-${this._uid}-`;
         child.key =
             child.key == null
                 ? child.isComment
@@ -8019,9 +7982,9 @@ var Transition = {
                         ? child.key
                         : id + child.key
                     : child.key;
-        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        var oldRawChild = this._vnode;
-        var oldChild = getRealChild(oldRawChild);
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
         // mark v-show
         // so that the transition module can hand over the control to the directive
         if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -8036,14 +7999,14 @@ var Transition = {
                 oldChild.componentInstance._vnode.isComment)) {
             // replace old child transition data with fresh one
             // important for dynamic transitions!
-            var oldData = (oldChild.data.transition = extend({}, data));
+            const oldData = (oldChild.data.transition = extend({}, data));
             // handle transition mode
             if (mode === 'out-in') {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', function () {
-                    _this._leaving = false;
-                    _this.$forceUpdate();
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -8051,14 +8014,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave_1;
-                var performLeave = function () {
-                    delayedLeave_1();
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave_1 = leave;
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
                 });
             }
         }
@@ -8067,37 +8030,36 @@ var Transition = {
 };
 
 // Provides transition support for list items.
-var props = extend({
+const props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
 // @ts-ignore
 delete props.mode;
 var TransitionGroup = {
-    props: props,
-    beforeMount: function () {
-        var _this = this;
-        var update = this._update;
-        this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(_this);
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
             // force removing pass
-            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+            this.__patch__(this._vnode, this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            _this._vnode = _this.kept;
+            this._vnode = this.kept;
             restoreActiveInstance();
-            update.call(_this, vnode, hydrating);
+            update.call(this, vnode, hydrating);
         };
     },
-    render: function (h) {
-        var tag = this.tag || this.$vnode.data.tag || 'span';
-        var map = Object.create(null);
-        var prevChildren = (this.prevChildren = this.children);
-        var rawChildren = this.$slots.default || [];
-        var children = (this.children = []);
-        var transitionData = extractTransitionData(this);
-        for (var i = 0; i < rawChildren.length; i++) {
-            var c = rawChildren[i];
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || 'span';
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
             if (c.tag) {
                 if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
                     children.push(c);
@@ -8105,19 +8067,19 @@ var TransitionGroup = {
                     (c.data || (c.data = {})).transition = transitionData;
                 }
                 else {
-                    var opts = c.componentOptions;
-                    var name_1 = opts
+                    const opts = c.componentOptions;
+                    const name = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
+                    warn$2(`<transition-group> children must be keyed: <${name}>`);
                 }
             }
         }
         if (prevChildren) {
-            var kept = [];
-            var removed = [];
-            for (var i = 0; i < prevChildren.length; i++) {
-                var c = prevChildren[i];
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
                 c.data.transition = transitionData;
                 // @ts-ignore
                 c.data.pos = c.elm.getBoundingClientRect();
@@ -8134,9 +8096,9 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function () {
-        var children = this.prevChildren;
-        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -8149,28 +8111,28 @@ var TransitionGroup = {
         // assign to this to avoid being removed in tree-shaking
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
-        children.forEach(function (c) {
+        children.forEach((c) => {
             // @ts-ignore
             if (c.data.moved) {
-                var el_1 = c.elm;
-                var s = el_1.style;
-                addTransitionClass(el_1, moveClass);
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                    if (e && e.target !== el_1) {
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el_1.removeEventListener(transitionEndEvent, cb);
-                        el_1._moveCb = null;
-                        removeTransitionClass(el_1, moveClass);
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function (el, moveClass) {
+        hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -8184,16 +8146,16 @@ var TransitionGroup = {
             // transition at this very moment, we make a clone of it and remove
             // all other transition classes applied to ensure only the move class
             // is applied.
-            var clone = el.cloneNode();
+            const clone = el.cloneNode();
             if (el._transitionClasses) {
-                el._transitionClasses.forEach(function (cls) {
+                el._transitionClasses.forEach((cls) => {
                     removeClass(clone, cls);
                 });
             }
             addClass(clone, moveClass);
             clone.style.display = 'none';
             this.$el.appendChild(clone);
-            var info = getTransitionInfo(clone);
+            const info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
             return (this._hasMove = info.hasTransform);
         },
@@ -8219,24 +8181,24 @@ function recordPosition(c) {
 }
 function applyTranslation(c) {
     //@ts-ignore
-    var oldPos = c.data.pos;
+    const oldPos = c.data.pos;
     //@ts-ignore
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
     if (dx || dy) {
         //@ts-ignore
         c.data.moved = true;
         //@ts-ignore
-        var s = c.elm.style;
-        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
         s.transitionDuration = '0s';
     }
 }
 
 var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
+    Transition,
+    TransitionGroup,
 };
 
 // install platform specific utils
@@ -8258,7 +8220,7 @@ Vue.prototype.$mount = function (el, hydrating) {
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-    setTimeout(function () {
+    setTimeout(() => {
         if (config.devtools) {
             if (devtools) {
                 devtools.emit('init', Vue);
@@ -8272,9 +8234,9 @@ if (inBrowser) {
         if (config.productionTip !== false &&
             typeof console !== 'undefined') {
             // @ts-expect-error
-            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                "Make sure to turn on production mode when deploying for production.\n" +
-                "See more tips at https://vuejs.org/guide/deployment.html");
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
         }
     }, 0);
 }
@@ -8283,8 +8245,8 @@ if (inBrowser) {
 // during template compilation
 makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
     return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
@@ -8299,7 +8261,7 @@ makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,decla
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
 
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -8312,11 +8274,11 @@ var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isPreTag = function (tag) { return tag === 'pre'; };
-var isReservedTag = function (tag) {
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
     return isHTMLTag(tag) || isSVG(tag);
 };
 function getTagNamespace(tag) {
@@ -8336,7 +8298,7 @@ makeMap('text,number,password,search,email,tel,url');
  */
 function query(el) {
     if (typeof el === 'string') {
-        var selected = document.querySelector(el);
+        const selected = document.querySelector(el);
         if (!selected) {
             warn$2('Cannot find element: ' + el);
             return document.createElement('div');
@@ -8348,23 +8310,23 @@ function query(el) {
     }
 }
 
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
     return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
 function parseText(text, delimiters) {
     //@ts-expect-error
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
     if (!tagRE.test(text)) {
         return;
     }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = (tagRE.lastIndex = 0);
-    var match, index, tokenValue;
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
     while ((match = tagRE.exec(text))) {
         index = match.index;
         // push text token
@@ -8373,8 +8335,8 @@ function parseText(text, delimiters) {
             tokens.push(JSON.stringify(tokenValue));
         }
         // tag token
-        var exp = parseFilters(match[1].trim());
-        tokens.push("_s(" + exp + ")");
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8389,12 +8351,12 @@ function parseText(text, delimiters) {
 }
 
 function transformNode$1(el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
     if (staticClass) {
-        var res = parseText(staticClass, options.delimiters);
+        const res = parseText(staticClass, options.delimiters);
         if (res) {
-            warn("class=\"" + staticClass + "\": " +
+            warn(`class="${staticClass}": ` +
                 'Interpolation inside attributes has been removed. ' +
                 'Use v-bind or the colon shorthand instead. For example, ' +
                 'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
@@ -8403,18 +8365,18 @@ function transformNode$1(el, options) {
     if (staticClass) {
         el.staticClass = JSON.stringify(staticClass);
     }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
     if (classBinding) {
         el.classBinding = classBinding;
     }
 }
 function genData$2(el) {
-    var data = '';
+    let data = '';
     if (el.staticClass) {
-        data += "staticClass:" + el.staticClass + ",";
+        data += `staticClass:${el.staticClass},`;
     }
     if (el.classBinding) {
-        data += "class:" + el.classBinding + ",";
+        data += `class:${el.classBinding},`;
     }
     return data;
 }
@@ -8425,14 +8387,14 @@ var klass = {
 };
 
 function transformNode(el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
         /* istanbul ignore if */
         {
-            var res = parseText(staticStyle, options.delimiters);
+            const res = parseText(staticStyle, options.delimiters);
             if (res) {
-                warn("style=\"" + staticStyle + "\": " +
+                warn(`style="${staticStyle}": ` +
                     'Interpolation inside attributes has been removed. ' +
                     'Use v-bind or the colon shorthand instead. For example, ' +
                     'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
@@ -8440,30 +8402,30 @@ function transformNode(el, options) {
         }
         el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
     }
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
     if (styleBinding) {
         el.styleBinding = styleBinding;
     }
 }
 function genData$1(el) {
-    var data = '';
+    let data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + el.staticStyle + ",";
+        data += `staticStyle:${el.staticStyle},`;
     }
     if (el.styleBinding) {
-        data += "style:(" + el.styleBinding + "),";
+        data += `style:(${el.styleBinding}),`;
     }
     return data;
 }
 var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode,
+    transformNode,
     genData: genData$1,
 };
 
-var decoder;
+let decoder;
 var he = {
-    decode: function (html) {
+    decode(html) {
         decoder = decoder || document.createElement('div');
         decoder.innerHTML = html;
         return decoder.textContent;
@@ -8477,7 +8439,7 @@ makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
 makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
     'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -8487,21 +8449,21 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
  * Not type-checking this file because it's mostly vendor code.
  */
 // Regular Expressions for parsing tags and attributes
-var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
-var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp("^<" + qnameCapture);
-var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
-var doctype = /^<!DOCTYPE [^>]+>/i;
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/;
-var conditionalComment = /^<!\[/;
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
 // Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true);
-var reCache = {};
-var decodingMap = {
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
     '&lt;': '<',
     '&gt;': '>',
     '&quot;': '"',
@@ -8510,74 +8472,72 @@ var decodingMap = {
     '&#9;': '\t',
     '&#39;': "'",
 };
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) {
-    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-};
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
 function decodeAttr(value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; });
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
 }
 function parseHTML(html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag = options.isUnaryTag || no;
-    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
-    var _loop_1 = function () {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
-            var textEnd = html.indexOf('<');
+            let textEnd = html.indexOf('<');
             if (textEnd === 0) {
                 // Comment:
                 if (comment.test(html)) {
-                    var commentEnd = html.indexOf('-->');
+                    const commentEnd = html.indexOf('-->');
                     if (commentEnd >= 0) {
                         if (options.shouldKeepComment) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        return "continue";
+                        continue;
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
                 if (conditionalComment.test(html)) {
-                    var conditionalEnd = html.indexOf(']>');
+                    const conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        return "continue";
+                        continue;
                     }
                 }
                 // Doctype:
-                var doctypeMatch = html.match(doctype);
+                const doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    return "continue";
+                    continue;
                 }
                 // End tag:
-                var endTagMatch = html.match(endTag);
+                const endTagMatch = html.match(endTag);
                 if (endTagMatch) {
-                    var curIndex = index;
+                    const curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    return "continue";
+                    continue;
                 }
                 // Start tag:
-                var startTagMatch = parseStartTag();
+                const startTagMatch = parseStartTag();
                 if (startTagMatch) {
                     handleStartTag(startTagMatch);
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    return "continue";
+                    continue;
                 }
             }
-            var text = void 0, rest = void 0, next = void 0;
+            let text, rest, next;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8604,18 +8564,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength_1 = 0;
-            var stackedTag_1 = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag_1] ||
-                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-            var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength_1 = endTag.length;
-                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -8625,23 +8585,18 @@ function parseHTML(html, options) {
             });
             index += html.length - rest.length;
             html = rest;
-            parseEndTag(stackedTag_1, index - endTagLength_1, index);
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
                     start: index + html.length,
                 });
             }
-            return "break";
-        }
-    };
-    while (html) {
-        var state_1 = _loop_1();
-        if (state_1 === "break")
             break;
+        }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -8650,15 +8605,15 @@ function parseHTML(html, options) {
         html = html.substring(n);
     }
     function parseStartTag() {
-        var start = html.match(startTagOpen);
+        const start = html.match(startTagOpen);
         if (start) {
-            var match = {
+            const match = {
                 tagName: start[1],
                 attrs: [],
                 start: index,
             };
             advance(start[0].length);
-            var end = void 0, attr = void 0;
+            let end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8675,8 +8630,8 @@ function parseHTML(html, options) {
         }
     }
     function handleStartTag(match) {
-        var tagName = match.tagName;
-        var unarySlash = match.unarySlash;
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
         if (expectHTML) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
@@ -8685,13 +8640,13 @@ function parseHTML(html, options) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag(tagName) || !!unarySlash;
-        var l = match.attrs.length;
-        var attrs = new Array(l);
-        for (var i = 0; i < l; i++) {
-            var args = match.attrs[i];
-            var value = args[3] || args[4] || args[5] || '';
-            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
                 ? options.shouldDecodeNewlinesForHref
                 : options.shouldDecodeNewlines;
             attrs[i] = {
@@ -8718,7 +8673,7 @@ function parseHTML(html, options) {
         }
     }
     function parseEndTag(tagName, start, end) {
-        var pos, lowerCasedTagName;
+        let pos, lowerCasedTagName;
         if (start == null)
             start = index;
         if (end == null)
@@ -8738,10 +8693,10 @@ function parseHTML(html, options) {
         }
         if (pos >= 0) {
             // Close all the open elements, up the stack
-            for (var i = stack.length - 1; i >= pos; i--) {
+            for (let i = stack.length - 1; i >= pos; i--) {
                 if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8771,39 +8726,39 @@ function parseHTML(html, options) {
 }
 
 // const he = require('he')
-var onRE = /^@|^v-on:/;
-var dirRE = /^v-|^@|^:|^#/;
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-var stripParensRE = /^\(|\)$/g;
-var dynamicArgRE = /^\[.*\]$/;
-var argRE = /:(.*)$/;
-var bindRE = /^:|^\.|^v-bind:/;
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-var slotRE = /^v-slot(:|$)|^#/;
-var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /[ \f\t\r\n]+/g;
-var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(he.decode);
-var emptySlotScopeToken = "_empty_";
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he.decode);
+const emptySlotScopeToken = `_empty_`;
 // configurable state
-var warn$1;
-var delimiters;
-var transforms;
-var preTransforms;
-var postTransforms;
-var platformIsPreTag;
-var platformMustUseProp;
-var platformGetTagNamespace;
-var maybeComponent;
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
 function createASTElement(tag, attrs, parent) {
     return {
         type: 1,
-        tag: tag,
+        tag,
         attrsList: attrs,
         attrsMap: makeAttrsMap(attrs),
         rawAttrsMap: {},
-        parent: parent,
+        parent,
         children: [],
     };
 }
@@ -8815,20 +8770,23 @@ function parse(template, options) {
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
     delimiters = options.delimiters;
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
@@ -8853,9 +8811,9 @@ function parse(template, options) {
                 });
             }
             else {
-                warnOnce("Component template should contain exactly one root element. " +
-                    "If you are using v-if on multiple elements, " +
-                    "use v-else-if to chain them instead.", { start: element.start });
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
             }
         }
         if (currentParent && !element.forbidden) {
@@ -8867,8 +8825,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name_1 = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -8876,7 +8834,7 @@ function parse(template, options) {
         }
         // final children cleanup
         // filter out scoped slots
-        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        element.children = element.children.filter((c) => !c.slotScope);
         // remove trailing whitespace node again
         trimEndingWhitespace(element);
         // check pre state
@@ -8887,14 +8845,14 @@ function parse(template, options) {
             inPre = false;
         }
         // apply post-transforms
-        for (var i = 0; i < postTransforms.length; i++) {
+        for (let i = 0; i < postTransforms.length; i++) {
             postTransforms[i](element, options);
         }
     }
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode = void 0;
+            let lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8904,7 +8862,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8921,16 +8879,16 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function (tag, attrs, unary, start, end) {
+        start(tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
-            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
             // handle IE svg bug
             /* istanbul ignore if */
             if (isIE && ns === 'svg') {
                 attrs = guardIESVGBug(attrs);
             }
-            var element = createASTElement(tag, attrs, currentParent);
+            let element = createASTElement(tag, attrs, currentParent);
             if (ns) {
                 element.ns = ns;
             }
@@ -8938,16 +8896,16 @@ function parse(template, options) {
                 if (options.outputSourceRange) {
                     element.start = start;
                     element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
                         cumulated[attr.name] = attr;
                         return cumulated;
                     }, {});
                 }
-                attrs.forEach(function (attr) {
+                attrs.forEach((attr) => {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
-                            "spaces, quotes, <, >, / or =.", {
-                            start: attr.start + attr.name.indexOf("["),
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
                             end: attr.start + attr.name.length,
                         });
                     }
@@ -8957,11 +8915,11 @@ function parse(template, options) {
                 element.forbidden = true;
                 warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        ("<" + tag + ">") +
+                        `<${tag}>` +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
-            for (var i = 0; i < preTransforms.length; i++) {
+            for (let i = 0; i < preTransforms.length; i++) {
                 element = preTransforms[i](element, options) || element;
             }
             if (!inVPre) {
@@ -8996,8 +8954,8 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function (tag, start, end) {
-            var element = stack[stack.length - 1];
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
@@ -9006,15 +8964,15 @@ function parse(template, options) {
             }
             closeElement(element);
         },
-        chars: function (text, start, end) {
+        chars(text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
-                            start: start,
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
                         });
                     }
                 }
@@ -9027,7 +8985,7 @@ function parse(template, options) {
                 currentParent.attrsMap.placeholder === text) {
                 return;
             }
-            var children = currentParent.children;
+            const children = currentParent.children;
             if (inPre || text.trim()) {
                 text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
             }
@@ -9053,14 +9011,14 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res = void 0;
-                var child = void 0;
+                let res;
+                let child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
                         expression: res.expression,
                         tokens: res.tokens,
-                        text: text,
+                        text,
                     };
                 }
                 else if (text !== ' ' ||
@@ -9068,7 +9026,7 @@ function parse(template, options) {
                     children[children.length - 1].text !== ' ') {
                     child = {
                         type: 3,
-                        text: text,
+                        text,
                     };
                 }
                 if (child) {
@@ -9080,13 +9038,13 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function (text, start, end) {
+        comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
-                var child = {
+                const child = {
                     type: 3,
-                    text: text,
+                    text,
                     isComment: true,
                 };
                 if (options.outputSourceRange) {
@@ -9105,11 +9063,11 @@ function processPre(el) {
     }
 }
 function processRawAttrs(el) {
-    var list = el.attrsList;
-    var len = list.length;
+    const list = el.attrsList;
+    const len = list.length;
     if (len) {
-        var attrs = (el.attrs = new Array(len));
-        for (var i = 0; i < len; i++) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
             attrs[i] = {
                 name: list[i].name,
                 value: JSON.stringify(list[i].value),
@@ -9135,28 +9093,28 @@ function processElement(element, options) {
     processSlotContent(element);
     processSlotOutlet(element);
     processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
+    for (let i = 0; i < transforms.length; i++) {
         element = transforms[i](element, options) || element;
     }
     processAttrs(element);
     return element;
 }
 function processKey(el) {
-    var exp = getBindingAttr(el, 'key');
+    const exp = getBindingAttr(el, 'key');
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
-                var iterator = el.iterator2 || el.iterator1;
-                var parent_1 = el.parent;
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent_1 &&
-                    parent_1.tag === 'transition-group') {
-                    warn$1("Do not use v-for index as key on <transition-group> children, " +
-                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
         }
@@ -9164,32 +9122,32 @@ function processKey(el) {
     }
 }
 function processRef(el) {
-    var ref = getBindingAttr(el, 'ref');
+    const ref = getBindingAttr(el, 'ref');
     if (ref) {
         el.ref = ref;
         el.refInFor = checkInFor(el);
     }
 }
 function processFor(el) {
-    var exp;
+    let exp;
     if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        var res = parseFor(exp);
+        const res = parseFor(exp);
         if (res) {
             extend(el, res);
         }
         else {
-            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
         }
     }
 }
 function parseFor(exp) {
-    var inMatch = exp.match(forAliasRE);
+    const inMatch = exp.match(forAliasRE);
     if (!inMatch)
         return;
-    var res = {};
+    const res = {};
     res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
     if (iteratorMatch) {
         res.alias = alias.replace(forIteratorRE, '').trim();
         res.iterator1 = iteratorMatch[1].trim();
@@ -9203,7 +9161,7 @@ function parseFor(exp) {
     return res;
 }
 function processIf(el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
+    const exp = getAndRemoveAttr(el, 'v-if');
     if (exp) {
         el.if = exp;
         addIfCondition(el, {
@@ -9215,14 +9173,14 @@ function processIf(el) {
         if (getAndRemoveAttr(el, 'v-else') != null) {
             el.else = true;
         }
-        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
         if (elseif) {
             el.elseif = elseif;
         }
     }
 }
 function processIfConditions(el, parent) {
-    var prev = findPrevElement(parent.children);
+    const prev = findPrevElement(parent.children);
     if (prev && prev.if) {
         addIfCondition(prev, {
             exp: el.elseif,
@@ -9230,20 +9188,20 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
-    var i = children.length;
+    let i = children.length;
     while (i--) {
         if (children[i].type === 1) {
             return children[i];
         }
         else {
             if (children[i].text !== ' ') {
-                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
-                    "will be ignored.", children[i]);
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
             }
             children.pop();
         }
@@ -9256,7 +9214,7 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once = getAndRemoveAttr(el, 'v-once');
+    const once = getAndRemoveAttr(el, 'v-once');
     if (once != null) {
         el.once = true;
     }
@@ -9264,29 +9222,29 @@ function processOnce(el) {
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
 function processSlotContent(el) {
-    var slotScope;
+    let slotScope;
     if (el.tag === 'template') {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
-                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-                "can also be used on plain elements in addition to <template> to " +
-                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
         }
         el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
     }
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
-                "(v-for takes higher priority). Use a wrapper <template> for the " +
-                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
         }
         el.slotScope = slotScope;
     }
     // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
+    const slotTarget = getBindingAttr(el, 'slot');
     if (slotTarget) {
         el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
         el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
@@ -9300,52 +9258,52 @@ function processSlotContent(el) {
     {
         if (el.tag === 'template') {
             // v-slot on <template>
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1("<template v-slot> can only appear at the root level inside " +
-                            "the receiving component", el);
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
                     }
                 }
-                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                el.slotTarget = name_2;
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
             if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.scopedSlots) {
-                        warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding);
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
                     }
                 }
                 // add the component's children to its default slot
-                var slots = el.scopedSlots || (el.scopedSlots = {});
-                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                slotContainer_1.slotTarget = name_3;
-                slotContainer_1.slotTargetDynamic = dynamic;
-                slotContainer_1.children = el.children.filter(function (c) {
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
                     if (!c.slotScope) {
-                        c.parent = slotContainer_1;
+                        c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -9355,34 +9313,34 @@ function processSlotContent(el) {
     }
 }
 function getSlotName(binding) {
-    var name = binding.name.replace(slotRE, '');
+    let name = binding.name.replace(slotRE, '');
     if (!name) {
         if (binding.name[0] !== '#') {
             name = 'default';
         }
         else {
-            warn$1("v-slot shorthand syntax requires a slot name.", binding);
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
         }
     }
     return dynamicArgRE.test(name)
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: "\"" + name + "\"", dynamic: false };
+            { name: `"${name}"`, dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
-                "and can possibly expand into multiple elements. " +
-                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
         }
     }
 }
 function processComponent(el) {
-    var binding;
+    let binding;
     if ((binding = getBindingAttr(el, 'is'))) {
         el.component = binding;
     }
@@ -9391,8 +9349,8 @@ function processComponent(el) {
     }
 }
 function processAttrs(el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
     for (i = 0, l = list.length; i < l; i++) {
         name = rawName = list[i].name;
         value = list[i].value;
@@ -9414,7 +9372,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9426,16 +9384,16 @@ function processAttrs(el) {
                         name = camelize(name);
                     }
                     if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, "$event");
+                        syncGen = genAssignmentCode(value, `$event`);
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -9461,8 +9419,8 @@ function processAttrs(el) {
                 // normal directives
                 name = name.replace(dirRE, '');
                 // parse arg
-                var argMatch = name.match(argRE);
-                var arg = argMatch && argMatch[1];
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
                 isDynamic = false;
                 if (arg) {
                     name = name.slice(0, -(arg.length + 1));
@@ -9480,9 +9438,9 @@ function processAttrs(el) {
         else {
             // literal attribute
             {
-                var res = parseText(value, delimiters);
+                const res = parseText(value, delimiters);
                 if (res) {
-                    warn$1(name + "=\"" + value + "\": " +
+                    warn$1(`${name}="${value}": ` +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9500,7 +9458,7 @@ function processAttrs(el) {
     }
 }
 function checkInFor(el) {
-    var parent = el;
+    let parent = el;
     while (parent) {
         if (parent.for !== undefined) {
             return true;
@@ -9510,18 +9468,18 @@ function checkInFor(el) {
     return false;
 }
 function parseModifiers(name) {
-    var match = name.match(modifierRE);
+    const match = name.match(modifierRE);
     if (match) {
-        var ret_1 = {};
-        match.forEach(function (m) {
-            ret_1[m.slice(1)] = true;
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
         });
-        return ret_1;
+        return ret;
     }
 }
 function makeAttrsMap(attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
@@ -9540,13 +9498,13 @@ function isForbiddenTag(el) {
         (el.tag === 'script' &&
             (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-var ieNSBug = /^xmlns:NS\d+/;
-var ieNSPrefix = /^NS\d+:/;
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
 /* istanbul ignore next */
 function guardIESVGBug(attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-        var attr = attrs[i];
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
         if (!ieNSBug.test(attr.name)) {
             attr.name = attr.name.replace(ieNSPrefix, '');
             res.push(attr);
@@ -9555,14 +9513,14 @@ function guardIESVGBug(attrs) {
     return res;
 }
 function checkForAliasModel(el, value) {
-    var _el = el;
+    let _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
-                "You are binding v-model directly to a v-for iteration alias. " +
-                "This will not be able to modify the v-for source array because " +
-                "writing to the alias is like modifying a function local variable. " +
-                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
         }
         _el = _el.parent;
     }
@@ -9579,45 +9537,45 @@ function checkForAliasModel(el, value) {
  */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
-        var map = el.attrsMap;
+        const map = el.attrsMap;
         if (!map['v-model']) {
             return;
         }
-        var typeBinding = void 0;
+        let typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + map['v-bind'] + ").type";
+            typeBinding = `(${map['v-bind']}).type`;
         }
         if (typeBinding) {
-            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
-            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
-            var branch0 = cloneASTElement(el);
+            const branch0 = cloneASTElement(el);
             // process for on the main node
             processFor(branch0);
             addRawAttr(branch0, 'type', 'checkbox');
             processElement(branch0, options);
             branch0.processed = true; // prevent it from double-processed
-            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
             addIfCondition(branch0, {
                 exp: branch0.if,
                 block: branch0,
             });
             // 2. add radio else-if condition
-            var branch1 = cloneASTElement(el);
+            const branch1 = cloneASTElement(el);
             getAndRemoveAttr(branch1, 'v-for', true);
             addRawAttr(branch1, 'type', 'radio');
             processElement(branch1, options);
             addIfCondition(branch0, {
-                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
                 block: branch1,
             });
             // 3. other
-            var branch2 = cloneASTElement(el);
+            const branch2 = cloneASTElement(el);
             getAndRemoveAttr(branch2, 'v-for', true);
             addRawAttr(branch2, ':type', typeBinding);
             processElement(branch2, options);
@@ -9639,27 +9597,27 @@ function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
 var model$1 = {
-    preTransformNode: preTransformNode,
+    preTransformNode,
 };
 
 var modules = [klass, style, model$1];
 
-var warn;
+let warn;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
+const RANGE_TOKEN = '__r';
 function model(el, dir, _warn) {
     warn = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
     {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
         }
     }
     if (el.component) {
@@ -9685,8 +9643,8 @@ function model(el, dir, _warn) {
         return false;
     }
     else {
-        warn("<" + el.tag + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
+        warn(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
             "If you are working with contenteditable, it's recommended to " +
             'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
     }
@@ -9694,71 +9652,71 @@ function model(el, dir, _warn) {
     return true;
 }
 function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
         (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
-    addHandler(el, 'change', "var $$a=" + value + "," +
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
         '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
         'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
         '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
 }
 function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-        ".call($event.target.options,function(o){return o.selected})" +
-        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type;
+    const type = el.attrsMap.type;
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
-            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    var valueExpression = '$event.target.value';
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
     if (trim) {
-        valueExpression = "$event.target.value.trim()";
+        valueExpression = `$event.target.value.trim()`;
     }
     if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
+        valueExpression = `_n(${valueExpression})`;
     }
-    var code = genAssignmentCode(value, valueExpression);
+    let code = genAssignmentCode(value, valueExpression);
     if (needCompositionGuard) {
-        code = "if($event.target.composing)return;" + code;
+        code = `if($event.target.composing)return;${code}`;
     }
-    addProp(el, 'value', "(" + value + ")");
+    addProp(el, 'value', `(${value})`);
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -9767,27 +9725,27 @@ function genDefaultModel(el, value, modifiers) {
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
     }
 }
 
 var directives = {
-    model: model,
-    text: text,
-    html: html,
+    model,
+    text,
+    html,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -9796,23 +9754,23 @@ makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-var baseOptions = {
+const baseOptions = {
     expectHTML: true,
-    modules: modules,
-    directives: directives,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
     // @ts-ignore
     staticKeys: genStaticKeys$1(modules),
 };
 
-var isStaticKey;
-var isPlatformReservedTag;
-var genStaticKeysCached = cached(genStaticKeys);
+let isStaticKey;
+let isPlatformReservedTag;
+const genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -9849,16 +9807,16 @@ function markStatic(node) {
             node.attrsMap['inline-template'] == null) {
             return;
         }
-        for (var i = 0, l = node.children.length; i < l; i++) {
-            var child = node.children[i];
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
             markStatic(child);
             if (!child.static) {
                 node.static = false;
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                var block = node.ifConditions[i].block;
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -9885,12 +9843,12 @@ function markStaticRoots(node, isInFor) {
             node.staticRoot = false;
         }
         if (node.children) {
-            for (var i = 0, l = node.children.length; i < l; i++) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
                 markStaticRoots(node.children[i], isInFor || !!node.for);
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
                 markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
@@ -9927,11 +9885,11 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-var fnInvokeRE = /\([^)]*?\);*$/;
-var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
 // KeyboardEvent.keyCode aliases
-var keyCodes = {
+const keyCodes = {
     esc: 27,
     tab: 9,
     enter: 13,
@@ -9943,7 +9901,7 @@ var keyCodes = {
     delete: [8, 46],
 };
 // KeyboardEvent.key aliases
-var keyNames = {
+const keyNames = {
     // #7880: IE11 and Edge use `Esc` for Escape key name.
     esc: ['Esc', 'Escape'],
     tab: 'Tab',
@@ -9961,36 +9919,36 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
-var modifierCode = {
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2"),
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
 };
 function genHandlers(events, isNative) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name_1 in events) {
-        var handlerCode = genHandler(events[name_1]);
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
         //@ts-expect-error
-        if (events[name_1] && events[name_1].dynamic) {
-            dynamicHandlers += name_1 + "," + handlerCode + ",";
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
         }
         else {
-            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+            staticHandlers += `"${name}":${handlerCode},`;
         }
     }
-    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
     if (dynamicHandlers) {
-        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
     }
     else {
         return prefix + staticHandlers;
@@ -10001,22 +9959,22 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
     }
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
     if (!handler.modifiers) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
     }
     else {
-        var code = '';
-        var genModifierCode = '';
-        var keys = [];
-        var _loop_1 = function (key) {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -10025,18 +9983,15 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers_1 = handler.modifiers;
+                const modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
-        };
-        for (var key in handler.modifiers) {
-            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -10045,14 +10000,14 @@ function genHandler(handler) {
         if (genModifierCode) {
             code += genModifierCode;
         }
-        var handlerCode = isMethodPath
-            ? "return " + handler.value + ".apply(null, arguments)"
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
             : isFunctionExpression
-                ? "return (" + handler.value + ").apply(null, arguments)"
+                ? `return (${handler.value}).apply(null, arguments)`
                 : isFunctionInvocation
-                    ? "return " + handler.value
+                    ? `return ${handler.value}`
                     : handler.value;
-        return "function($event){" + code + handlerCode + "}";
+        return `function($event){${code}${handlerCode}}`;
     }
 }
 function genKeyFilter(keys) {
@@ -10060,71 +10015,68 @@ function genKeyFilter(keys) {
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&') + ")return null;"));
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
 }
 function genFilterCode(key) {
-    var keyVal = parseInt(key, 10);
+    const keyVal = parseInt(key, 10);
     if (keyVal) {
-        return "$event.keyCode!==" + keyVal;
+        return `$event.keyCode!==${keyVal}`;
     }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return ("_k($event.keyCode," +
-        (JSON.stringify(key) + ",") +
-        (JSON.stringify(keyCode) + ",") +
-        "$event.key," +
-        ("" + JSON.stringify(keyName)) +
-        ")");
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
 function on(el, dir) {
     if (dir.modifiers) {
-        warn$2("v-on without argument does not support modifiers.");
+        warn$2(`v-on without argument does not support modifiers.`);
     }
-    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
 function bind(el, dir) {
-    el.wrapData = function (code) {
-        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
     };
 }
 
 var baseDirectives = {
-    on: on,
-    bind: bind,
+    on,
+    bind,
     cloak: noop,
 };
 
-var CodegenState = /** @class */ (function () {
-    function CodegenState(options) {
+class CodegenState {
+    constructor(options) {
         this.options = options;
         this.warn = options.warn || baseWarn;
         //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
         this.transforms = pluckModuleFunction(options.modules, 'transformCode');
         this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
         this.directives = extend(extend({}, baseDirectives), options.directives);
-        var isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = function (el) {
-            return !!el.component || !isReservedTag(el.tag);
-        };
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
         this.onceId = 0;
         this.staticRenderFns = [];
         this.pre = false;
     }
-    return CodegenState;
-}());
+}
 function generate(ast, options) {
-    var state = new CodegenState(options);
+    const state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
-    var code = ast
+    const code = ast
         ? ast.tag === 'script'
             ? 'null'
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: `with(this){return ${code}}`,
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -10152,22 +10104,22 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code = void 0;
+        let code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data = void 0;
+            let data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
-            var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-            ) + (children ? "," + children : '' // children
-            ) + ")";
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
         }
         // module transforms
-        for (var i = 0; i < state.transforms.length; i++) {
+        for (let i = 0; i < state.transforms.length; i++) {
             code = state.transforms[i](el, code);
         }
         return code;
@@ -10179,13 +10131,13 @@ function genStatic(el, state) {
     // Some elements (templates) need to behave differently inside of a v-pre
     // node.  All pre nodes are static roots, so we can use this as a location to
     // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
+    const originalPreState = state.pre;
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
     state.pre = originalPreState;
-    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
 }
 // v-once
 function genOnce(el, state) {
@@ -10194,20 +10146,20 @@ function genOnce(el, state) {
         return genIf(el, state);
     }
     else if (el.staticInFor) {
-        var key = '';
-        var parent_1 = el.parent;
-        while (parent_1) {
-            if (parent_1.for) {
-                key = parent_1.key;
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
                 break;
             }
-            parent_1 = parent_1.parent;
+            parent = parent.parent;
         }
         if (!key) {
-            state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
     }
     else {
         return genStatic(el, state);
@@ -10221,12 +10173,12 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     if (!conditions.length) {
         return altEmpty || '_e()';
     }
-    var condition = conditions.shift();
+    const condition = conditions.shift();
     if (condition.exp) {
-        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
     }
     else {
-        return "" + genTernaryExp(condition.block);
+        return `${genTernaryExp(condition.block)}`;
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -10238,87 +10190,87 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
 }
 function genFor(el, state, altGen, altHelper) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-            "v-for should have explicit keys. " +
-            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
-    return ((altHelper || '_l') + "((" + exp + ")," +
-        ("function(" + alias + iterator1 + iterator2 + "){") +
-        ("return " + (altGen || genElement)(el, state)) +
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
         '})');
 }
 function genData(el, state) {
-    var data = '{';
+    let data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
+    const dirs = genDirectives(el, state);
     if (dirs)
         data += dirs + ',';
     // key
     if (el.key) {
-        data += "key:" + el.key + ",";
+        data += `key:${el.key},`;
     }
     // ref
     if (el.ref) {
-        data += "ref:" + el.ref + ",";
+        data += `ref:${el.ref},`;
     }
     if (el.refInFor) {
-        data += "refInFor:true,";
+        data += `refInFor:true,`;
     }
     // pre
     if (el.pre) {
-        data += "pre:true,";
+        data += `pre:true,`;
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + el.tag + "\",";
+        data += `tag:"${el.tag}",`;
     }
     // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
+    for (let i = 0; i < state.dataGenFns.length; i++) {
         data += state.dataGenFns[i](el);
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + genProps(el.attrs) + ",";
+        data += `attrs:${genProps(el.attrs)},`;
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + genProps(el.props) + ",";
+        data += `domProps:${genProps(el.props)},`;
     }
     // event handlers
     if (el.events) {
-        data += genHandlers(el.events, false) + ",";
+        data += `${genHandlers(el.events, false)},`;
     }
     if (el.nativeEvents) {
-        data += genHandlers(el.nativeEvents, true) + ",";
+        data += `${genHandlers(el.nativeEvents, true)},`;
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + el.slotTarget + ",";
+        data += `slot:${el.slotTarget},`;
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += genScopedSlots(el, el.scopedSlots, state) + ",";
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
     }
     // inline-template
     if (el.inlineTemplate) {
-        var inlineTemplate = genInlineTemplate(el, state);
+        const inlineTemplate = genInlineTemplate(el, state);
         if (inlineTemplate) {
-            data += inlineTemplate + ",";
+            data += `${inlineTemplate},`;
         }
     }
     data = data.replace(/,$/, '') + '}';
@@ -10326,7 +10278,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -10339,16 +10291,16 @@ function genData(el, state) {
     return data;
 }
 function genDirectives(el, state) {
-    var dirs = el.directives;
+    const dirs = el.directives;
     if (!dirs)
         return;
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
     for (i = 0, l = dirs.length; i < l; i++) {
         dir = dirs[i];
         needRuntime = true;
-        var gen = state.directives[dir.name];
+        const gen = state.directives[dir.name];
         if (gen) {
             // compile-time directive that manipulates AST.
             // returns true if it also needs a runtime counterpart.
@@ -10356,9 +10308,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
         }
     }
     if (hasRuntime) {
@@ -10366,15 +10318,15 @@ function genDirectives(el, state) {
     }
 }
 function genInlineTemplate(el, state) {
-    var ast = el.children[0];
+    const ast = el.children[0];
     if ((el.children.length !== 1 || ast.type !== 1)) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
-        var inlineRenderFns = generate(ast, state.options);
-        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-            .map(function (code) { return "function(){" + code + "}"; })
-            .join(',') + "]}";
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -10382,9 +10334,9 @@ function genScopedSlots(el, slots, state) {
     // components with only scoped slots to skip forced updates from parent.
     // but in some cases we have to bail-out of this optimization
     // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for ||
-        Object.keys(slots).some(function (key) {
-            var slot = slots[key];
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
             return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
             );
         });
@@ -10392,34 +10344,34 @@ function genScopedSlots(el, slots, state) {
     // it's possible for the same component to be reused but with different
     // compiled slot content. To avoid that, we generate a unique key based on
     // the generated code of all the slot contents.
-    var needsKey = !!el.if;
+    let needsKey = !!el.if;
     // OR when it is inside another scoped slot or v-for (the reactivity may be
     // disconnected due to the intermediate scope variable)
     // #9438, #9506
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent_2 = el.parent;
-        while (parent_2) {
-            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                parent_2.for) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent_2.if) {
+            if (parent.if) {
                 needsKey = true;
             }
-            parent_2 = parent_2.parent;
+            parent = parent.parent;
         }
     }
-    var generatedSlots = Object.keys(slots)
-        .map(function (key) { return genScopedSlot(slots[key], state); })
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
         .join(',');
-    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
 }
 function hash(str) {
-    var hash = 5381;
-    var i = str.length;
+    let hash = 5381;
+    let i = str.length;
     while (i) {
         hash = (hash * 33) ^ str.charCodeAt(--i);
     }
@@ -10435,45 +10387,45 @@ function containsSlotChild(el) {
     return false;
 }
 function genScopedSlot(el, state) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
+    const isLegacySyntax = el.attrsMap['slot-scope'];
     if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, "null");
+        return genIf(el, state, genScopedSlot, `null`);
     }
     if (el.for && !el.forProcessed) {
         return genFor(el, state, genScopedSlot);
     }
-    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-        ("return " + (el.tag === 'template'
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}");
+            : genElement(el, state)}}`;
     // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    var children = el.children;
+    const children = el.children;
     if (children.length) {
-        var el_1 = children[0];
+        const el = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el_1.for &&
-            el_1.tag !== 'template' &&
-            el_1.tag !== 'slot') {
-            var normalizationType_1 = checkSkip
-                ? state.maybeComponent(el_1)
-                    ? ",1"
-                    : ",0"
-                : "";
-            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
-        }
-        var normalizationType = checkSkip
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen_1 = altGenNode || genNode;
-        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
     }
 }
 // determine the normalization needed for the children array.
@@ -10481,20 +10433,20 @@ function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
 function getNormalizationType(children, maybeComponent) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-        var el = children[i];
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
         if (el.type !== 1) {
             continue;
         }
         if (needsNormalization(el) ||
             (el.ifConditions &&
-                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
             res = 2;
             break;
         }
         if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
             res = 1;
         }
     }
@@ -10515,58 +10467,58 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return "_v(" + (text.type === 2
+    return `_v(${text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
 }
 function genComment(comment) {
-    return "_e(" + JSON.stringify(comment.text) + ")";
+    return `_e(${JSON.stringify(comment.text)})`;
 }
 function genSlot(el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? "," + children : '');
-    var attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,${children}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
             // slot props are camelized
             name: camelize(attr.name),
             value: attr.value,
             dynamic: attr.dynamic,
-        }); }))
+        })))
         : null;
-    var bind = el.attrsMap['v-bind'];
+    const bind = el.attrsMap['v-bind'];
     if ((attrs || bind) && !children) {
-        res += ",null";
+        res += `,null`;
     }
     if (attrs) {
-        res += "," + attrs;
+        res += `,${attrs}`;
     }
     if (bind) {
-        res += (attrs ? '' : ',null') + "," + bind;
+        res += `${attrs ? '' : ',null'},${bind}`;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
 }
 function genProps(props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-        var prop = props[i];
-        var value = transformSpecialNewlines(prop.value);
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += prop.name + "," + value + ",";
+            dynamicProps += `${prop.name},${value},`;
         }
         else {
-            staticProps += "\"" + prop.name + "\":" + value + ",";
+            staticProps += `"${prop.name}":${value},`;
         }
     }
-    staticProps = "{" + staticProps.slice(0, -1) + "}";
+    staticProps = `{${staticProps.slice(0, -1)}}`;
     if (dynamicProps) {
-        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
     }
     else {
         return staticProps;
@@ -10579,7 +10531,7 @@ function transformSpecialNewlines(text) {
 
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' +
+const prohibitedKeywordRE = new RegExp('\\b' +
     ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
         'super,throw,while,yield,delete,export,import,return,switch,default,' +
         'extends,finally,continue,debugger,function,arguments')
@@ -10587,11 +10539,11 @@ var prohibitedKeywordRE = new RegExp('\\b' +
         .join('\\b|\\b') +
     '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' +
+const unaryOperatorsRE = new RegExp('\\b' +
     'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
     '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
-var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
 // detect problematic expressions in a template
 function detectErrors(ast, warn) {
     if (ast) {
@@ -10600,28 +10552,28 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name_1 in node.attrsMap) {
-            if (dirRE.test(name_1)) {
-                var value = node.attrsMap[name_1];
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name_1];
-                    if (name_1 === 'v-for') {
-                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
                     }
-                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
                     }
-                    else if (onRE.test(name_1)) {
-                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
                     }
                     else {
-                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                        checkExpression(value, `${name}="${value}"`, warn, range);
                     }
                 }
             }
         }
         if (node.children) {
-            for (var i = 0; i < node.children.length; i++) {
+            for (let i = 0; i < node.children.length; i++) {
                 checkNode(node.children[i], warn);
             }
         }
@@ -10631,11 +10583,11 @@ function checkNode(node, warn) {
     }
 }
 function checkEvent(exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn("avoid using JavaScript unary operator as property name: " +
-            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10648,29 +10600,29 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function("var " + ident + "=_");
+            new Function(`var ${ident}=_`);
         }
         catch (e) {
-            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function("return " + exp);
+        new Function(`return ${exp}`);
     }
     catch (e) {
-        var keywordMatch = exp
+        const keywordMatch = exp
             .replace(stripStringRE, '')
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
-            warn("avoid using JavaScript keyword as property name: " +
-                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
         }
         else {
-            warn("invalid expression: " + e.message + " in\n\n" +
-                ("    " + exp + "\n\n") +
-                ("  Raw expression: " + text.trim() + "\n"), range);
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
         }
     }
 }
@@ -10679,37 +10631,35 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + e.message + " in\n\n" +
-            ("    " + exp + "\n\n") +
-            ("  Raw expression: " + text.trim() + "\n"), range);
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
     }
 }
 
-var range = 2;
-function generateCodeFrame(source, start, end) {
-    if (start === void 0) { start = 0; }
-    if (end === void 0) { end = source.length; }
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
         count += lines[i].length + 1;
         if (count >= start) {
-            for (var j = i - range; j <= i + range || end > count; j++) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     continue;
-                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
-                var lineLength = lines[j].length;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
-                    var pad = start - (count - lineLength) + 1;
-                    var length_1 = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length_2 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length_2));
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
                     }
                     count += lineLength + 1;
                 }
@@ -10720,7 +10670,7 @@ function generateCodeFrame(source, start, end) {
     return res.join('\n');
 }
 function repeat(str, n) {
-    var result = '';
+    let result = '';
     if (n > 0) {
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -10741,15 +10691,15 @@ function createFunction(code, errors) {
         return new Function(code);
     }
     catch (err) {
-        errors.push({ err: err, code: code });
+        errors.push({ err, code });
         return noop;
     }
 }
 function createCompileToFunctionFn(compile) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn = options.warn || warn$2;
+        const warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         {
@@ -10768,43 +10718,43 @@ function createCompileToFunctionFn(compile) {
             }
         }
         // check cache
-        var key = options.delimiters
+        const key = options.delimiters
             ? String(options.delimiters) + template
             : template;
         if (cache[key]) {
             return cache[key];
         }
         // compile
-        var compiled = compile(template, options);
+        const compiled = compile(template, options);
         // check compilation errors/tips
         {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
-                    compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
                         '\n', vm);
                 }
             }
             if (compiled.tips && compiled.tips.length) {
                 if (options.outputSourceRange) {
-                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
                 }
                 else {
-                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                    compiled.tips.forEach((msg) => tip(msg, vm));
                 }
             }
         }
         // turn code into functions
-        var res = {};
-        var fnGenErrors = [];
+        const res = {};
+        const fnGenErrors = [];
         res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
             return createFunction(code, fnGenErrors);
         });
         // check function generation errors.
@@ -10813,12 +10763,9 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn("Failed to generate render function:\n\n" +
+                warn(`Failed to generate render function:\n\n` +
                     fnGenErrors
-                        .map(function (_a) {
-                        var err = _a.err, code = _a.code;
-                        return err.toString() + " in\n\n" + code + "\n";
-                    })
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
                         .join('\n'), vm);
             }
         }
@@ -10829,24 +10776,24 @@ function createCompileToFunctionFn(compile) {
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
-            var finalOptions = Object.create(baseOptions);
-            var errors = [];
-            var tips = [];
-            var warn = function (msg, range, tip) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
                 (tip ? tips : errors).push(msg);
             };
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
-                    warn = function (msg, range, tip) {
-                        var data = { msg: msg };
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength_1;
+                                data.start = range.start + leadingSpaceLength;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength_1;
+                                data.end = range.end + leadingSpaceLength;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -10861,14 +10808,14 @@ function createCompilerCreator(baseCompile) {
                     finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
                 }
                 // copy other options
-                for (var key in options) {
+                for (const key in options) {
                     if (key !== 'modules' && key !== 'directives') {
                         finalOptions[key] = options[key];
                     }
                 }
             }
             finalOptions.warn = warn;
-            var compiled = baseCompile(template.trim(), finalOptions);
+            const compiled = baseCompile(template.trim(), finalOptions);
             {
                 detectErrors(compiled.ast, warn);
             }
@@ -10877,7 +10824,7 @@ function createCompilerCreator(baseCompile) {
             return compiled;
         }
         return {
-            compile: compile,
+            compile,
             compileToFunctions: createCompileToFunctionFn(compile),
         };
     };
@@ -10886,58 +10833,58 @@ function createCompilerCreator(baseCompile) {
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    var ast = parse(template.trim(), options);
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
     if (options.optimize !== false) {
         optimize(ast, options);
     }
-    var code = generate(ast, options);
+    const code = generate(ast, options);
     return {
-        ast: ast,
+        ast,
         render: code.render,
         staticRenderFns: code.staticRenderFns,
     };
 });
 
-var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
+const { compile, compileToFunctions } = createCompiler(baseOptions);
 
 // check whether current browser encodes a char inside attribute values
-var div;
+let div;
 function getShouldDecode(href) {
     div = div || document.createElement('div');
-    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
     return div.innerHTML.indexOf('&#10;') > 0;
 }
 // #3663: IE encodes newlines inside attribute values while other browsers don't
-var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-var shouldDecodeNewlinesForHref = inBrowser
+const shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
-var idToTemplate = cached(function (id) {
-    var el = query(id);
+const idToTemplate = cached((id) => {
+    const el = query(id);
     return el && el.innerHTML;
 });
-var mount = Vue.prototype.$mount;
+const mount = Vue.prototype.$mount;
 Vue.prototype.$mount = function (el, hydrating) {
     el = el && query(el);
     /* istanbul ignore if */
     if (el === document.body || el === document.documentElement) {
-        warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
         return this;
     }
-    var options = this.$options;
+    const options = this.$options;
     // resolve template/el and convert to render function
     if (!options.render) {
-        var template = options.template;
+        let template = options.template;
         if (template) {
             if (typeof template === 'string') {
                 if (template.charAt(0) === '#') {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (!template) {
-                        warn$2("Template element not found or is empty: " + options.template, this);
+                        warn$2(`Template element not found or is empty: ${options.template}`, this);
                     }
                 }
             }
@@ -10960,19 +10907,19 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (config.performance && mark) {
                 mark('compile');
             }
-            var _a = compileToFunctions(template, {
+            const { render, staticRenderFns } = compileToFunctions(template, {
                 outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines: shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
-            }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
+            }, this);
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (config.performance && mark) {
                 mark('compile end');
-                measure("vue " + this._name + " compile", 'compile', 'compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
             }
         }
     }
@@ -10987,7 +10934,7 @@ function getOuterHTML(el) {
         return el.outerHTML;
     }
     else {
-        var container = document.createElement('div');
+        const container = document.createElement('div');
         container.appendChild(el.cloneNode(true));
         return container.innerHTML;
     }
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
index 1c0fab411d7..6b28466b459 100644
--- a/dist/vue.esm.browser.min.js
+++ b/dist/vue.esm.browser.min.js
@@ -3,4 +3,9 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(){function e(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=[],r=0;r<arguments.length;r++)n[r]=arguments[r];var i,a=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&o.observeArray(i),o.dep.notify(),a})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&we(t),a.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in A(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?A({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Ae[r]||Ee;o[r]=i(e[r],t[r],n,r)}return o}function je(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function De(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Pe(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var l=_e;be(!0),we(o),be(l)}return o}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch(function(e){return Re(e,r,i+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,r,i)}return a}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],qe=!1;function Je(){qe=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(Je),Z&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Je)}:function(){setTimeout(Je,0)};else{var Ze=1,Ge=new MutationObserver(Je),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),qe||(qe=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(o)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=n.fns;if(!Array.isArray(e))return He(e,null,arguments,t,"v-on handler");for(var r=e.slice(),i=0;i<r.length;i++)He(r[i],null,arguments,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=tt(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=nt(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=tt(c)).name,n[c],f.capture)}function it(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=nt([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=nt([s,c]),o.merged=!0,e[i]=o}function at(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ot(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(a,o){var s=[];var c,l,u,f;for(c=0;c<a.length;c++)t(l=a[c])||"boolean"==typeof l||(u=s.length-1,f=s[u],Array.isArray(l)?l.length>0&&(st((l=e(l,(o||"")+"_"+c))[0])&&st(f)&&(s[u]=ve(f.text+l[0].text),l.shift()),s.push.apply(s,l)):i(l)?st(f)?s[u]=ve(f.text+l):""!==l&&s.push(ve(l)):st(l)&&st(f)?s[u]=ve(f.text+l.text):(r(a._isVList)&&n(l.tag)&&t(l.key)&&n(o)&&(l.key="__vlist"+o+"_"+c+"__"),s.push(l)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function lt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ut)&&delete n[l];return n}function ut(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=dt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ot(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=A(A({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function mt(e){return je(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):a?yt(a,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(a(n)){Array.isArray(n)&&(n=O(n));var o=void 0,s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?kt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=u,e._l=vt,e._t=ht,e._q=E,e._i=L,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=ct(l.inject,a),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=lt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var a=he(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var Lt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Lt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=De(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Jt(t,r,h),l&&(t.$slots=lt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},jt=Object.keys(Lt);function Dt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Ht;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",function(){return h(s,o)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=j(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout(function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=de();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},$n(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);at(o,c,l,u,!0)||at(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=De(u,l,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ot(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<jt.length;n++){var r=jt[n],i=t[r],a=Lt[r];i===a||i&&i._merged||(t[r]=i?Mt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,o,s,c,l,u){return(Array.isArray(s)||i(s))&&(l=c,c=s,s=void 0),r(u)&&(l=Ft),function(e,i,o,s,c){if(n(o)&&n(o.__ob__))return de();n(o)&&n(o.is)&&(i=o.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=ot(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var l,u;if("string"==typeof i){var f=void 0;u=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),l=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),o,s,void 0,void 0,e):o&&o.pre||!n(f=je(e.$options,"components",i))?new pe(i,o,s,void 0,void 0,e):Dt(f,o,e,s,i)}else l=Dt(i,o,e,s);return Array.isArray(l)?l:n(l)?(n(u)&&function e(i,a,o){i.ns=a;"foreignObject"===i.tag&&(a=void 0,o=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var l=i.children[s];n(l.tag)&&(t(l.ns)||r(o)&&"svg"!==l.tag)&&e(l,a,o)}}(l,u),n(o)&&function(e){a(e.style)&&et(e.style);a(e.class)&&et(e.class)}(o),l):de()}(e,o,s,c,l)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function qt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function Jt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,qt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,an=0;var on=0,sn=Date.now;if(U&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function ln(){var e,t;for(on=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),an=0;an<Qt.length;an++)(e=Qt[an]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();an=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var un=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>an&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(ln))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var a=function(a){i.push(a);var o=De(a,t,n,e);Ce(r,a,o),a in e||dn(e,"_props",a)};for(var o in t)a(o);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||(o=void 0,36!==(o=(a+"").charCodeAt(0))&&95!==o&&dn(e,"_data",a))}var o;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new fn(e,o||S,S,hn)),i in e||mn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Le(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach(function(e){o[e]=n[e]}),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=A({},o.options),i[r]=o,o}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=xn(o.componentOptions);s&&!t(s)&&On(n,a,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Jt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=lt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var a=r&&r.data;Ce(t,"$attrs",a&&a.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){ue();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,a=t.length;i<a;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,a=this.exclude;if(i&&(!r||!kn(i,r))||a&&r&&kn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:A,mergeOptions:Le,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),Ln=p("contenteditable,draggable,spellcheck"),jn=p("events,caret,typing,plaintext-only"),Dn=function(e,t){return Rn(t)||"false"===t?"false":"contenteditable"===e&&jn(t)?t:"true"},Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Fn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Pn=function(e){return Fn(e)?e.slice(6,e.length):""},Rn=function(e){return null==e||!1===e};function Hn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Bn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Bn(t,r.data));return function(e,t){if(n(e)||n(t))return Un(e,zn(t));return""}(t.staticClass,t.class)}function Bn(e,t){return{staticClass:Un(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Un(e,t){return e?t?e+" "+t:e:t||""}function zn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=zn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Jn=function(e){return Kn(e)||qn(e)};var Wn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Vn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Xn={create:function(e,t){Yn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(Yn(e,!0),Yn(t))},destroy:function(e){Yn(e,!0)}};function Yn(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var Qn=new pe("",{},[]),er=["create","activate","update","remove","destroy"];function tr(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Zn(i)&&Zn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function nr(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var rr={create:ir,update:ir,destroy:function(e){ir(e,Qn)}};function ir(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===Qn,o=t===Qn,s=or(e.data.directives,e.context),c=or(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,cr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(cr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)cr(l[n],"inserted",t,e)};a?it(t,"insert",f):f()}u.length&&it(t,"postpatch",function(){for(var n=0;n<u.length;n++)cr(u[n],"componentUpdated",t,e)});if(!a)for(n in s)c[n]||cr(s[n],"unbind",e,e,o)}(e,t)}var ar=Object.create(null);function or(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ar),i[sr(r)]=r,r.def=je(t.$options,"directives",r.name);return i}function sr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function cr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var lr=[Xn,rr];function ur(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=A({},l)),l)o=l[a],c[a]!==o&&fr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&fr(s,"value",l.value),c)t(l[a])&&(Fn(a)?s.removeAttributeNS(In,Pn(a)):Ln(a)||s.removeAttribute(a))}}function fr(e,t,n,r){r||e.tagName.indexOf("-")>-1?pr(e,t,n):Mn(t)?Rn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Ln(t)?e.setAttribute(t,Dn(t,n)):Fn(t)?Rn(n)?e.removeAttributeNS(In,Pn(t)):e.setAttributeNS(In,t,n):pr(e,t,n)}function pr(e,t,n){if(Rn(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var dr={create:ur,update:ur};function vr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Hn(r),c=i._transitionClasses;n(c)&&(s=Un(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var hr,mr,yr,gr,_r,br,$r={create:vr,update:vr},wr=/[\w).+\-_$\]]/;function Cr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&wr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=xr(i,a[r]);return i}function xr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function kr(e,t){console.error("[Vue compiler]: "+e)}function Ar(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Or(e,t,n,r,i){(e.props||(e.props=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Sr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Tr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Ir({name:t,value:n},r))}function Nr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Ir({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Er(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Lr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Er("!",n,c)),i.once&&(delete i.once,n=Er("~",n,c)),i.passive&&(delete i.passive,n=Er("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Ir({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function jr(e,t,n){var r=Dr(e,":"+t)||Dr(e,"v-bind:"+t);if(null!=r)return Cr(r);if(!1!==n){var i=Dr(e,t);if(null!=i)return JSON.stringify(i)}}function Dr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Mr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Ir(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Fr(e,t,n){var r=n||{},i=r.number,a="$$v";r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var o=Pr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+o+"}"}}function Pr(e,t){var n=function(e){if(e=e.trim(),hr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<hr-1)return(gr=e.lastIndexOf("."))>-1?{exp:e.slice(0,gr),key:'"'+e.slice(gr+1)+'"'}:{exp:e,key:null};mr=e,gr=_r=br=0;for(;!Hr();)Br(yr=Rr())?zr(yr):91===yr&&Ur(yr);return{exp:e.slice(0,_r),key:e.slice(_r+1,br)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Rr(){return mr.charCodeAt(++gr)}function Hr(){return gr>=hr}function Br(e){return 34===e||39===e}function Ur(e){var t=1;for(_r=gr;!Hr();)if(Br(e=Rr()))zr(e);else if(91===e&&t++,93===e&&t--,0===t){br=gr;break}}function zr(e){for(var t=e;!Hr()&&(e=Rr())!==t;);}var Vr,Kr="__r",qr="__c";function Jr(e,t,n){var r=Vr;return function i(){null!==t.apply(null,arguments)&&Gr(e,i,n,r)}}var Wr=Ve&&!(X&&Number(X[1])<=53);function Zr(e,t,n,r){if(Wr){var i=on,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Vr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Gr(e,t,n,r){(r||Vr).removeEventListener(e,t._wrapper||t,n)}function Xr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Vr=r.elm,function(e){if(n(e[Kr])){var t=q?"change":"input";e[t]=[].concat(e[Kr],e[t]||[]),delete e[Kr]}n(e[qr])&&(e.change=[].concat(e[qr],e.change||[]),delete e[qr])}(i),rt(i,a,Zr,Gr,Jr,r.context),Vr=void 0}}var Yr,Qr={create:Xr,update:Xr};function ei(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ti(o,l)&&(o.value=l)}else if("innerHTML"===i&&qn(o.tagName)&&t(o.innerHTML)){(Yr=Yr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Yr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ti(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ni={create:ei,update:ei},ri=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function ii(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ri(e):e}var oi,si=/^--/,ci=/\s*!important$/,li=function(e,t,n){if(si.test(t))e.style.setProperty(t,n);else if(ci.test(n))e.style.setProperty(C(t),n.replace(ci,""),"important");else{var r=fi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},ui=["Webkit","Moz","ms"],fi=g(function(e){if(oi=oi||document.createElement("div").style,"filter"!==(e=b(e))&&e in oi)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<ui.length;n++){var r=ui[n]+t;if(r in oi)return r}});function pi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ii(i.data))&&A(r,n);(n=ii(e.data))&&A(r,n);for(var a=e;a=a.parent;)a.data&&(n=ii(a.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(o=d[s])!==f[s]&&li(c,s,null==o?"":o)}}var di={create:pi,update:pi},vi=/\s+/;function hi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,mi(e.name||"v")),A(t,e),t}return"string"==typeof e?mi(e):void 0}}var mi=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),yi="transition",gi="animation",_i="transition",bi="transitionend",$i="animation",wi="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_i="WebkitTransition",bi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($i="WebkitAnimation",wi="webkitAnimationEnd"));var Ci=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function xi(e){Ci(function(){Ci(e)})}function ki(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Oi(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[_i+"Delay"]||"").split(", "),a=(r[_i+"Duration"]||"").split(", "),o=Ti(i,a),s=(r[$i+"Delay"]||"").split(", "),c=(r[$i+"Duration"]||"").split(", "),l=Ti(s,c),u=0,f=0;t===yi?o>0&&(n=yi,u=o,f=a.length):t===gi?l>0&&(n=gi,u=l,f=c.length):(u=Math.max(o,l),f=(n=u>0?o>l?yi:gi:null)?n===yi?a.length:c.length:0);var p=n===yi&&Si.test(r[_i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===yi?bi:wi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var Si=/\b(transform|all)(,|$)/;function Ti(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Ni(t)+Ni(e[n])}))}function Ni(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ei(e){return"number"==typeof e&&!isNaN(e)}function Li(e){if(t(e))return!1;var r=e.fns;return n(r)?Li(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ji(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=hi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Li(L),R=i._enterCb=j(function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ki(i,S),ki(i,T),xi(function(){Ai(i,S),R.cancelled||(ki(i,N),P||(Ei(I)?setTimeout(R,I):Oi(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Di=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<er.length;++a)for(s[er[a]]=[],o=0;o<c.length;++o)n(c[o][er[a]])&&s[er[a]].push(c[o][er[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=he(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){for(var a,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,n(a=o.data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](Qn,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(Yn(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](Qn,e);n(a=e.data.hook)&&(n(a.create)&&a.create(Qn,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&tr(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:tr(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):tr(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):tr(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):tr(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=nr(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):tr(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&tr(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Qn,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else Yn(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Gn,modules:[dr,$r,Qr,ni,di,U?{create:ji,activate:ji,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=hi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Li(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ki(i,l),ki(i,p),xi(function(){Ai(i,l),w.cancelled||(ki(i,u),b||(Ei($)?setTimeout(w,$):Oi(i,c,w)))})),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(lr)});J&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Ui(e,"input")});var Mi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Mi.componentUpdated(e,t,n)}):Ii(e,t,n.context),e._vOptions=[].map.call(e.options,Ri)):("textarea"===n.tag||Zn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Hi),e.addEventListener("compositionend",Bi),e.addEventListener("change",Bi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ii(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ri);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return Pi(e,i)}):t.value!==t.oldValue&&Pi(t.value,i))&&Ui(e,"change")}}};function Ii(e,t,n){Fi(e,t),(q||W)&&setTimeout(function(){Fi(e,t)},0)}function Fi(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Ri(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Ri(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Pi(e,t){return t.every(function(t){return!E(t,e)})}function Ri(e){return"_value"in e?e._value:e.value}function Hi(e){e.target.composing=!0}function Bi(e){e.target.composing&&(e.target.composing=!1,Ui(e.target,"input"))}function Ui(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var zi=/\s+/;function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ki(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function qi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,Ji(e.name||"v")),A(t,e),t}return"string"==typeof e?Ji(e):void 0}}var Ji=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Wi=U&&!J,Zi="transition",Gi="animation",Xi="transition",Yi="transitionend",Qi="animation",ea="animationend";Wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xi="WebkitTransition",Yi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Qi="WebkitAnimation",ea="webkitAnimationEnd"));var ta=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function na(e){ta(function(){ta(e)})}function ra(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),Vi(e,t))}function ia(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ki(e,t)}function aa(e,t,n){var r=sa(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Zi?Yi:ea,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var oa=/\b(transform|all)(,|$)/;function sa(e,t){var n,r=window.getComputedStyle(e),i=(r[Xi+"Delay"]||"").split(", "),a=(r[Xi+"Duration"]||"").split(", "),o=ca(i,a),s=(r[Qi+"Delay"]||"").split(", "),c=(r[Qi+"Duration"]||"").split(", "),l=ca(s,c),u=0,f=0;return t===Zi?o>0&&(n=Zi,u=o,f=a.length):t===Gi?l>0&&(n=Gi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Zi:Gi:null)?n===Zi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Zi&&oa.test(r[Xi+"Property"])}}function ca(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return la(t)+la(e[n])}))}function la(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ua(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=qi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=pa(L),R=i._enterCb=j(function(){F&&(ia(i,N),ia(i,T)),R.cancelled?(F&&ia(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ra(i,S),ra(i,T),na(function(){ia(i,S),R.cancelled||(ra(i,N),P||(fa(I)?setTimeout(R,I):aa(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function fa(e){return"number"==typeof e&&!isNaN(e)}function pa(e){if(t(e))return!1;var r=e.fns;return n(r)?pa(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}var va={model:Mi,show:{bind:function(e,t,n){var r=t.value,i=(n=da(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,ua(n,function(){e.style.display=a})):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=da(i)).data&&i.data.transition?(i.data.show=!0,o?ua(i,function(){e.style.display=e.__vOriginalDisplay}):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=qi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=pa(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ia(i,u),ia(i,p)),w.cancelled?(_&&ia(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ra(i,l),ra(i,p),na(function(){ia(i,l),w.cancelled||(ra(i,u),b||(fa($)?setTimeout(w,$):aa(i,c,w)))})),v&&v(i,w),_||b||w())}}(i,function(){e.style.display="none"})):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ha={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ma(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ma(zt(t.children)):e}function ya(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ga(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var _a=function(e){return e.tag||Ut(e)},ba=function(e){return"show"===e.name},$a={name:"transition",props:ha,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(_a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ma(a);if(!o)return a;if(this._leaving)return ga(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=ya(this),l=this._vnode,u=ma(l);if(o.data.directives&&o.data.directives.some(ba)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Ut(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ga(e,a);if("in-out"===r){if(Ut(o))return l;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return a}}},wa=A({tag:String,moveClass:String},ha);function Ca(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function xa(e){e.data.newPos=e.elm.getBoundingClientRect()}function ka(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete wa.mode;var Aa={Transition:$a,TransitionGroup:{props:wa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=ya(this),s=0;s<i.length;s++){(u=i[s]).tag&&null!=u.key&&0!==String(u.key).indexOf("__vlist")&&(a.push(u),n[u.key]=u,(u.data||(u.data={})).transition=o)}if(r){var c=[],l=[];for(s=0;s<r.length;s++){var u;(u=r[s]).data.transition=o,u.data.pos=u.elm.getBoundingClientRect(),n[u.key]?c.push(u):l.push(u)}this.kept=e(t,null,c),this.removed=l}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Ca),e.forEach(xa),e.forEach(ka),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;ra(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Yi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Yi,e),n._moveCb=null,ia(n,t))})}}))},methods:{hasMove:function(e,t){if(!Wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Ki(n,e)}),Vi(n,t),n.style.display="none",this.$el.appendChild(n);var r=sa(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},wn.config.isReservedTag=Jn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=function(e){return qn(e)?"svg":"math"===e?"math":void 0},wn.config.isUnknownElement=function(e){if(!U)return!0;if(Jn(e))return!1;if(e=e.toLowerCase(),null!=Wn[e])return Wn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Wn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Wn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,va),A(wn.options.components,Aa),wn.prototype.__patch__=U?Di:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var Oa=p("input,textarea,option,select,progress"),Sa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ta=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Na(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Ea=/\{\{((?:.|\r?\n)+?)\}\}/g,La=/[-.*+?^${}()|[\]\/\\]/g,ja=g(function(e){var t=e[0].replace(La,"\\$&"),n=e[1].replace(La,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var Da={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Dr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=jr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Ma,Ia={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Dr(e,"style");n&&(e.staticStyle=JSON.stringify(ri(n)));var r=jr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Fa=function(e){return(Ma=Ma||document.createElement("div")).innerHTML=e,Ma.textContent},Pa=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ra=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ha=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ba="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ua="((?:"+Ba+"\\:)?"+Ba+")",za=new RegExp("^<"+Ua),Va=/^\s*(\/?)>/,Ka=new RegExp("^<\\/"+Ua+"[^>]*>"),qa=/^<!DOCTYPE [^>]+>/i,Ja=/^<!\--/,Wa=/^<!\[/,Za=p("script,style,textarea",!0),Ga={},Xa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ya=/&(?:lt|gt|quot|amp|#39);/g,Qa=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,eo=p("pre,textarea",!0),to=function(e,t){return e&&eo(e)&&"\n"===t[0]};function no(e,t){var n=t?Qa:Ya;return e.replace(n,function(e){return Xa[e]})}function ro(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,l=function(){if(n=e,r&&Za(r)){var l=0,p=r.toLowerCase(),d=Ga[p]||(Ga[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return l=r.length,Za(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),to(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-l,c)}else{var v=e.indexOf("<");if(0===v){if(Ja.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),u(h+3),"continue"}if(Wa.test(e)){var m=e.indexOf("]>");if(m>=0)return u(m+2),"continue"}var y=e.match(qa);if(y)return u(y[0].length),"continue";var g=e.match(Ka);if(g){var _=c;return u(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(za);if(t){var n={tagName:t[1],attrs:[],start:c};u(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Va))&&(i=e.match(Ha)||e.match(Ra));)i.start=c,u(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],u(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Pa(n)&&f(r),s(n)&&r===n&&f(n));for(var l=o(n)||!!c,u=e.attrs.length,p=new Array(u),d=0;d<u;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:no(h,m)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,l,e.start,e.end)}(b),to(b.tagName,e)&&u(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Ka.test(w)||za.test(w)||Ja.test(w)||Wa.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&u($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===l())break}function u(t){c+=t,e=e.substring(t)}function f(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}f()}var io,ao,oo,so,co,lo,uo,fo,po=/^@|^v-on:/,vo=/^v-|^@|^:|^#/,ho=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,mo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,yo=/^\(|\)$/g,go=/^\[.*\]$/,_o=/:(.*)$/,bo=/^:|^\.|^v-bind:/,$o=/\.[^.\]]+(?=[^\]]*$)/g,wo=/^v-slot(:|$)|^#/,Co=/[\r\n]/,xo=/[ \f\t\r\n]+/g,ko=g(Fa),Ao="_empty_";function Oo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Do(t),rawAttrsMap:{},parent:n,children:[]}}function So(e,t){io=t.warn||kr,lo=t.isPreTag||T,uo=t.mustUseProp||T,fo=t.getTagNamespace||T,t.isReservedTag,oo=Ar(t.modules,"transformNode"),so=Ar(t.modules,"preTransformNode"),co=Ar(t.modules,"postTransformNode"),ao=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=To(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Eo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Eo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter(function(e){return!e.slotScope}),u(e),e.pre&&(s=!1),lo(e.tag)&&(c=!1);for(var f=0;f<co.length;f++)co[f](e,t)}function u(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return ro(e,{warn:io,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||fo(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Mo.test(r.name)||(r.name=r.name.replace(Io,""),t.push(r))}return t}(a));var d,v=Oo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<so.length;h++)v=so[h](v,t)||v;s||(!function(e){null!=Dr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),lo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(No(v),function(e){var t=Dr(e,"v-if");if(t)e.if=t,Eo(e,{exp:t,block:e});else{null!=Dr(e,"v-else")&&(e.else=!0);var n=Dr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Dr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):l.length?o?"condense"===o&&Co.test(e)?"":" ":a?" ":"":""){c||"condense"!==o||(e=e.replace(xo," "));var u=void 0,f=void 0;!s&&" "!==e&&(u=function(e,t){var n=t?ja(t):Ea;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Cr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,ao))?f={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&l.length&&" "===l[l.length-1].text||(f={type:3,text:e}),f&&l.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function To(e,t){var n,r;(r=jr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dr(e,"scope"),e.slotScope=t||Dr(e,"slot-scope")):(t=Dr(e,"slot-scope"))&&(e.slotScope=t);var n=jr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Sr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Mr(e,wo);if(r){var i=Lo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Ao}}else{var r=Mr(e,wo);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=Lo(r),l=c.name,o=c.dynamic,u=s[l]=Oo("template",[],e);u.slotTarget=l,u.slotTargetDynamic=o,u.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=u,!0}),u.slotScope=r.value||Ao,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jr(e,"name"))}(e),function(e){var t;(t=jr(e,"is"))&&(e.component=t);null!=Dr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<oo.length;i++)e=oo[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,vo.test(r))if(e.hasBindings=!0,(o=jo(r.replace(vo,"")))&&(r=r.replace($o,"")),bo.test(r))r=r.replace(bo,""),a=Cr(a),(c=go.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Pr(a,"$event"),c?Lr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Lr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Lr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&uo(e.tag,e.attrsMap.type,r)?Or(e,r,a,l[t],c):Sr(e,r,a,l[t],c);else if(po.test(r))r=r.replace(po,""),(c=go.test(r))&&(r=r.slice(1,-1)),Lr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(vo,"")).match(_o),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),go.test(f)&&(f=f.slice(1,-1),c=!0)),Nr(e,r,i,a,f,c,o,l[t])}else Sr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&uo(e.tag,e.attrsMap.type,r)&&Or(e,r,"true",l[t])}(e),e}function No(e){var t;if(t=Dr(e,"v-for")){var n=function(e){var t=e.match(ho);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(yo,""),i=r.match(mo);i?(n.alias=r.replace(mo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function Eo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Lo(e){var t=e.name.replace(wo,"");return t||"#"!==e.name[0]&&(t="default"),go.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function jo(e){var t=e.match($o);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function Do(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Mo=/^xmlns:NS\d+/,Io=/^NS\d+:/;function Fo(e){return Oo(e.tag,e.attrsList.slice(),e.parent)}var Po=[Da,Ia,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=jr(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Dr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Dr(e,"v-else",!0),s=Dr(e,"v-else-if",!0),c=Fo(e);No(c),Tr(c,"type","checkbox"),To(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+a,Eo(c,{exp:c.if,block:c});var l=Fo(e);Dr(l,"v-for",!0),Tr(l,"type","radio"),To(l,t),Eo(c,{exp:"("+r+")==='radio'"+a,block:l});var u=Fo(e);return Dr(u,"v-for",!0),Tr(u,":type",r),To(u,t),Eo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}],Ro="__r";var Ho,Bo,Uo={expectHTML:!0,modules:Po,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Fr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Pr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null",a=jr(e,"true-value")||"true",o=jr(e,"false-value")||"false";Or(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Lr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pr(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null";Or(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Lr(e,"change",Pr(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?Ro:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),o&&(u="_n("+u+")");var f=Pr(t,u);c&&(f="if($event.target.composing)return;"+f),Or(e,"value","("+t+")"),Lr(e,l,f,null,!0),(s||o)&&Lr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Fr(e,r,i),!1;return!0},text:function(e,t){t.value&&Or(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Or(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Oa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Sa(e)||Ta(e)},getTagNamespace:function(e){return Ta(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Po)},zo=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(t);if(1===t.type){if(!Bo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var a=t.ifConditions[n].block;e(a),a.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Ko=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,qo=/\([^)]*?\);*$/,Jo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Go=function(e){return"if("+e+")return null;"},Xo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Go("$event.target !== $event.currentTarget"),ctrl:Go("!$event.ctrlKey"),shift:Go("!$event.shiftKey"),alt:Go("!$event.altKey"),meta:Go("!$event.metaKey"),left:Go("'button' in $event && $event.button !== 0"),middle:Go("'button' in $event && $event.button !== 1"),right:Go("'button' in $event && $event.button !== 2")};function Yo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Qo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Qo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Qo(e)}).join(",")+"]";var t=Jo.test(e.value),n=Ko.test(e.value),r=Jo.test(e.value.replace(qo,""));if(e.modifiers){var i="",a="",o=[],s=function(t){if(Xo[t])a+=Xo[t],Wo[t]&&o.push(t);else if("exact"===t){var n=e.modifiers;a+=Go(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else o.push(t)};for(var c in e.modifiers)s(c);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(es).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function es(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Wo[e],r=Zo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ts={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},ns=function(){return function(e){this.options=e,this.warn=e.warn||kr,this.transforms=Ar(e.modules,"transformCode"),this.dataGenFns=Ar(e.modules,"genData"),this.directives=A(A({},ts),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function rs(e,t){var n=new ns(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":is(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function is(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return as(e,t);if(e.once&&!e.onceProcessed)return os(e,t);if(e.for&&!e.forProcessed)return cs(e,t);if(e.if&&!e.ifProcessed)return ss(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ps(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?hs((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ps(t,n,!0);return"_c("+e+","+ls(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ls(e,t));var i=e.inlineTemplate?null:ps(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ps(e,t)||"void 0"}function as(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+is(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function os(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ss(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+is(e,t)+","+t.onceId+++","+n+")":is(e,t)}return as(e,t)}function ss(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var a=t.shift();return a.exp?"("+a.exp+")?"+o(a.block)+":"+e(t,n,r,i):""+o(a.block);function o(e){return r?r(e,n):e.once?os(e,n):is(e,n)}}(e.ifConditions.slice(),t,n,r)}function cs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||is)(e,t)+"})"}function ls(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+hs(e.attrs)+","),e.props&&(n+="domProps:"+hs(e.props)+","),e.events&&(n+=Yo(e.events,!1)+","),e.nativeEvents&&(n+=Yo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||us(n)}),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Ao||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map(function(e){return fs(t[e],n)}).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=rs(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+hs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function us(e){return 1===e.type&&("slot"===e.tag||e.children.some(us))}function fs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ss(e,t,fs,"null");if(e.for&&!e.forProcessed)return cs(e,t,fs);var r=e.slotScope===Ao?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ps(e,t)||"undefined")+":undefined":ps(e,t)||"undefined":is(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ps(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||is)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ds(i)||i.ifConditions&&i.ifConditions.some(function(e){return ds(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||vs;return"["+a.map(function(e){return l(e,t)}).join(",")+"]"+(c?","+c:"")}}function ds(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function vs(e,t){return 1===e.type?is(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:ms(JSON.stringify(n.text)))+")";var n,r}function hs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ms(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ms(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ys(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function gs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=ys(o.render,c),s.staticRenderFns=o.staticRenderFns.map(function(e){return ys(e,c)}),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var _s,bs,$s=(_s=function(e,t){var n=So(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=rs(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=_s(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:gs(t)}})(Uo).compileToFunctions;function ws(e){return(bs=bs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',bs.innerHTML.indexOf("&#10;")>0}var Cs=!!U&&ws(!1),xs=!!U&&ws(!0),ks=g(function(e){var t=Na(e);return t&&t.innerHTML}),As=wn.prototype.$mount;wn.prototype.$mount=function(e,t){if((e=e&&Na(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ks(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=$s(r,{outputSourceRange:!1,shouldDecodeNewlines:Cs,shouldDecodeNewlinesForHref:xs,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return As.call(this,e,t)},wn.compile=$s;export default wn;
\ No newline at end of file
+/*!
+ * Vue.js v2.6.12
+ * (c) 2014-2021 Evan You
+ * Released under the MIT License.
+ */
+const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}const s=Object.prototype.toString;function a(t){return"[object Object]"===s.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===s?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function k(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&k(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=i(t),o=i(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function L(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function j(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const D=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const G=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{constructor(){this.set=Object.create(null)}has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let it=S,st=0;class at{constructor(){this.id=st++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{constructor(t,e,n,o,r,i,s,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=s,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let i;switch(t){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&r.observeArray(i),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!i(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const i=new at,s=Object.getOwnPropertyDescriptor(t,e);if(s&&!1===s.configurable)return;const a=s&&s.get,c=s&&s.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(i.depend(),l&&(l.dep.depend(),Array.isArray(e)&&At(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),i.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function At(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&At(e)}const kt=I.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const i=ot?Reflect.ownKeys(e):Object.keys(e);for(let s=0;s<i.length;s++)n=i[s],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Nt(t,e,n,o){const r=Object.create(t||null);return e?k(r,e):r}kt.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{kt[t]=Tt})),D.forEach((function(t){kt[t+"s"]=Nt})),kt.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};k(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},kt.props=kt.methods=kt.inject=kt.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return k(r,t),e&&k(r,e),r},kt.provide=St;const Et=function(t,e){return void 0===e?t:e};function Lt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,i,s;if(Array.isArray(n))for(r=n.length;r--;)i=n[r],"string"==typeof i&&(s=_(i),o[s]={type:null});else if(a(n))for(const t in n)i=n[t],s=_(t),o[s]=a(i)?i:{type:i};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?k({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=Lt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=Lt(t,e.mixins[o],n);const o={};let r;for(r in t)i(r);for(r in e)g(t,r)||i(r);function i(r){const i=kt[r]||Et;o[r]=i(t[r],e[r],n,r)}return o}function jt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const i=_(n);if(g(r,i))return r[i];const s=b(i);if(g(r,s))return r[s];return r[n]||r[i]||r[s]}function Dt(t,e,n,o){const r=e[t],i=!g(n,t);let s=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(i&&!g(r,"default"))s=!1;else if(""===s||s===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(s=!0)}if(void 0===s){s=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==It(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(s),$t(e)}return s}const Mt=/^\s*function (\w+)/;function It(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return It(t)===It(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let i=0;i<r.length;i++)try{if(!1===r[i].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let i;try{i=n?t.apply(e,n):t.call(e),i&&!i._isVue&&l(i)&&!i._handled&&(i.catch((t=>Rt(t,o,r+" (Promise/async)"))),i._handled=!0)}catch(t){Rt(t,o,r)}return i}function Bt(t,e,n){if(I.errorHandler)try{return I.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,qt=!1;function Jt(){qt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(Jt),Z&&setTimeout(S)},zt=!0}else if(q||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(Jt)}:()=>{setTimeout(Jt,0)};else{let t=1;const e=new MutationObserver(Jt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Zt=new rt;function Gt(t){Xt(t,Zt),Zt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!i(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,i,s,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=s(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),i(f.name,n[c],f.capture))}function ee(t,r,i){let s;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){i.apply(this,arguments),m(s.fns,c)}e(a)?s=Qt([c]):n(a.fns)&&o(a.merged)?(s=a,s.fns.push(c)):s=Qt([a,c]),s.merged=!0,t[r]=s}function ne(t,e,o,r,i){if(n(e)){if(g(e,o))return t[o]=e[o],i||delete e[o],!0;if(g(e,r))return t[o]=e[r],i||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?ie(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function ie(t,i){const s=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=s.length-1,u=s[l],Array.isArray(c)?c.length>0&&(c=ie(c,`${i||""}_${a}`),re(c[0])&&re(u)&&(s[l]=pt(u.text+c[0].text),c.shift()),s.push.apply(s,c)):r(c)?re(u)?s[l]=pt(u.text+c):""!==c&&s.push(pt(c)):re(c)&&re(u)?s[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(i)&&(c.key=`__vlist${i}_${a}__`),s.push(c)));return s}function se(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const i=o[r];if("__ob__"===i)continue;const s=t[i].from;let a=e;for(;a;){if(a._provided&&g(a._provided,s)){n[i]=a._provided[s];break}a=a.$parent}if(!a&&"default"in t[i]){const o=t[i].default;n[i]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],i=r.data;if(i&&i.attrs&&i.attrs.slot&&delete i.attrs.slot,r.context!==e&&r.fnContext!==e||!i||null==i.slot)(n.default||(n.default=[])).push(r);else{const t=i.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,o){let r;const i=Object.keys(n).length>0,s=e?!!e.$stable:!i,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(s&&o&&o!==t&&a===o.$key&&!i&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ue(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=fe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",s),R(r,"$key",a),R(r,"$hasNormal",i),r}function ue(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});return t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t),t&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function fe(t,e){return()=>t[e]}function de(t,e){let o,r,s,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(i(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(s=Object.keys(t),c=new Array(s.length),o=0,r=s.length;o<r;o++)a=s[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,o){const r=this.$scopedSlots[t];let i;r?(n=n||{},o&&(n=k(k({},o),n)),i=r(n)||e):i=this.$slots[t]||e;const s=n&&n.slot;return s?this.$createElement("template",{slot:s},i):i}function he(t){return jt(this.$options,"filters",t)||N}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,o,r){const i=I.keyCodes[e]||n;return r&&o&&!I.keyCodes[e]?me(r,o):i?me(i,t):o?C(o)!==e:void 0}function ge(t,e,n,o,r){if(n)if(i(n)){let i;Array.isArray(n)&&(n=O(n));for(const s in n){if("class"===s||"style"===s||h(s))i=t;else{const n=t.attrs&&t.attrs.type;i=o||I.mustUseProp(e,n,s)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(s),c=C(s);if(!(a in i)&&!(c in i)&&(i[s]=n[s],r)){(t.on||(t.on={}))[`update:${s}`]=function(t){n[s]=t}}}}else;return t}function ve(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),_e(o,`__static__${t}`,!1)),o}function $e(t,e,n){return _e(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function _e(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&be(t[o],`${e}_${o}`,n);else be(t,e,n)}function be(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(a(e)){const n=t.on=t.on?k({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function Ce(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?Ce(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function xe(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=$e,t._n=f,t._s=u,t._l=de,t._t=pe,t._q=E,t._i=L,t._m=ve,t._f=he,t._k=ye,t._b=ge,t._v=pt,t._e=dt,t._u=Ce,t._g=we,t._d=xe,t._p=Ae}function Oe(e,n,r,i,s){const a=s.options;let c;g(i,"_uid")?(c=Object.create(i),c._original=i):(c=i,i=i._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=i,this.listeners=e.on||t,this.injections=se(a.inject,i),this.slots=()=>(this.$slots||le(e.scopedSlots,this.$slots=ae(r,i)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=De(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=i),r}:this._c=(t,e,n,o)=>De(c,t,e,n,o,u)}function Se(t,e,n,o,r){const i=ht(t);return i.fnContext=n,i.fnOptions=o,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Te(t,e){for(const n in e)t[_(n)]=e[n]}ke(Oe.prototype);const Ne={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ne.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,i){const s=r.data.scopedSlots,a=e.$scopedSlots,c=!!(s&&!s.$stable||a!==t&&!a.$stable||s&&e.$scopedSlots.$key!==s.$key),l=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=i,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const i=o[r],s=e.$options.props;t[i]=Dt(i,s,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(i,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ge(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ze(e,!0):e.$destroy())}},Ee=Object.keys(Ne);function Le(r,s,a,c,u){if(e(r))return;const f=a.$options._base;if(i(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,void 0===(r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const s=Fe;s&&n(t.owners)&&-1===t.owners.indexOf(s)&&t.owners.push(s);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(s&&!n(t.owners)){const o=t.owners=[s];let a=!0,c=null,u=null;s.$on("hook:destroyed",(()=>m(o,s)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=j((e=>{t.resolved=Pe(e,r),a?o.length=0:f(!0)})),p=j((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return i(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Pe(h.error,r)),n(h.loading)&&(t.loadingComp=Pe(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f))))return function(t,e,n,o,r){const i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:o,tag:r},i}(d,s,a,c,u);s=s||{},vn(r),n(s.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const i=e.on||(e.on={}),s=i[r],a=e.model.callback;n(s)?(Array.isArray(s)?-1===s.indexOf(a):s!==a)&&(i[r]=[a].concat(s)):i[r]=a}(r.options,s);const p=function(t,o,r){const i=o.options.props;if(e(i))return;const s={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in i){const e=C(t);ne(s,c,t,e,!0)||ne(s,a,t,e,!1)}return s}(s,r);if(o(r.options.functional))return function(e,o,r,i,s){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Dt(e,l,o||t);else n(r.attrs)&&Te(c,r.attrs),n(r.props)&&Te(c,r.props);const u=new Oe(r,c,s,i,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Se(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Se(t[n],r,u.parent,a);return e}}(r,p,s,a,c);const h=s.on;if(s.on=s.nativeOn,o(r.options.abstract)){const t=s.slot;s={},t&&(s.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Ee.length;t++){const n=Ee[t],o=e[n],r=Ne[n];o===r||o&&o._merged||(e[n]=o?je(r,o):r)}}(s);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,s,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function je(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function De(t,e,s,a,c,l){return(Array.isArray(s)||r(s))&&(c=a,a=s,s=void 0),o(l)&&(c=2),function(t,e,o,r,s){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===s?r=oe(r):1===s&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let i;c=t.$vnode&&t.$vnode.ns||I.getTagNamespace(e),a=I.isReservedTag(e)?new ft(I.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(i=jt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):Le(i,o,t,r,e)}else a=Le(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Me(a,c),n(o)&&function(t){i(t.style)&&Gt(t.style);i(t.class)&&Gt(t.class)}(o),a):dt()}(t,e,s,a,c)}function Me(t,r,i){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,i=!0),n(t.children))for(let s=0,a=t.children.length;s<a;s++){const a=t.children[s];n(a.tag)&&(e(a.ns)||o(i)&&"svg"!==a.tag)&&Me(a,r,i)}}let Ie,Fe=null;function Pe(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Re(t){return t.isComment&&t.asyncFactory}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||Re(o)))return o}}function Be(t,e){Ie.$on(t,e)}function Ue(t,e){Ie.$off(t,e)}function ze(t,e){const n=Ie;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Ie=t,te(e,n||{},Be,Ue,ze,t),Ie=void 0}let Ke=null;function qe(t){const e=Ke;return Ke=t,()=>{Ke=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ge(t,"activated")}}function Ze(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ze(t.$children[e]);Ge(t,"deactivated")}}function Ge(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!q){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ge(o,"updated")}}(o),et&&I.devtools&&et.emit("flush")}let an=0;class cn{constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Gt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||i(t)||this.deep){const e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const i in e){r.push(i);wt(o,i,Dt(i,e,n,t)),i in t||un(t,"_props",i)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const i=e[r],s="function"==typeof i?i:i.get;o||(n[r]=new cn(t,s||S,S,dn)),r in t||pn(t,r,i)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&k(t.extendOptions,o),e=t.options=Lt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const i=t.name||n.options.name,s=function(t){this._init(t)};return(s.prototype=Object.create(n.prototype)).constructor=s,s.cid=e++,s.options=Lt(n.options,t),s.super=n,s.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(s),s.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(s),s.extend=n.extend,s.mixin=n.mixin,s.use=n.use,D.forEach((function(t){s[t]=n[t]})),i&&(s.options.components[i]=s),s.superOptions=n.options,s.extendOptions=t,s.sealedOptions=k({},s.options),r[o]=s,s}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===s.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const i=n[t];if(i){const s=bn(i.componentOptions);s&&!e(s)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Lt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>De(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>De(e,t,n,o,r,!0);const i=o&&o.data;wt(e,"$attrs",i&&i.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ge(n,"beforeCreate"),function(t){const e=se(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ge(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){lt();try{e.call(o,r.value)}catch(t){Rt(t,o,`callback for immediate watcher "${r.expression}"`)}ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,i=o.length;for(;i--;)if(r=o[i],r===e||r.fn===e){o.splice(i,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?A(n):n;const o=A(arguments,1),r=`event handler for "${t}"`;for(let t=0,i=n.length;t<i;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,i=qe(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),i(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ge(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ge(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=le(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Fe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Fe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const An=[String,RegExp,Array];var kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:An,exclude:An,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:i,keys:s}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;i[a]?(e.componentInstance=i[a].componentInstance,m(s,a),s.push(a)):(i[a]=e,s.push(a),this.max&&s.length>parseInt(this.max)&&xn(i,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>I};Object.defineProperty(t,"config",e),t.util={warn:it,extend:k,mergeOptions:Lt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),D.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,k(t.options.components,kn),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Lt(this.options,t),this}}(t),_n(t),function(t){D.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Oe}),$n.version="2.6.12";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=d("contenteditable,draggable,spellcheck"),Nn=d("events,caret,typing,plaintext-only"),En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Ln="http://www.w3.org/1999/xlink",jn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Dn=t=>jn(t)?t.slice(6,t.length):"",Mn=t=>null==t||!1===t;function In(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Fn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Fn(e,o.data));return function(t,e){if(n(t)||n(e))return Pn(t,Rn(e));return""}(e.staticClass,e.class)}function Fn(t,e){return{staticClass:Pn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Pn(t,e){return t?e?t+" "+e:t:e||""}function Rn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,i=t.length;r<i;r++)n(e=Rn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):i(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Bn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Un=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),zn=t=>Bn(t)||Un(t);const Vn=Object.create(null);const Kn=d("text,number,password,search,email,tel,url");var qn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Jn={create(t,e){Wn(e)},update(t,e){t.data.ref!==e.data.ref&&(Wn(t,!0),Wn(e))},destroy(t){Wn(t,!0)}};function Wn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,i=t.componentInstance||t.elm,s=r.$refs;e?Array.isArray(s[o])?m(s[o],i):s[o]===i&&(s[o]=void 0):t.data.refInFor?Array.isArray(s[o])?s[o].indexOf(i)<0&&s[o].push(i):s[o]=[i]:s[o]=i}const Zn=new ft("",{},[]),Gn=["create","activate","update","remove","destroy"];function Xn(t,r){return t.key===r.key&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,i=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===i||Kn(r)&&Kn(i)}(t,r)||o(t.isAsyncPlaceholder)&&t.asyncFactory===r.asyncFactory&&e(r.asyncFactory.error))}function Yn(t,e,o){let r,i;const s={};for(r=e;r<=o;++r)i=t[r].key,n(i)&&(s[i]=r);return s}var Qn={create:to,update:to,destroy:function(t){to(t,Zn)}};function to(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Zn,o=e===Zn,r=no(t.data.directives,t.context),i=no(e.data.directives,e.context),s=[],a=[];let c,l,u;for(c in i)l=r[c],u=i[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ro(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ro(u,"bind",e,t),u.def&&u.def.inserted&&s.push(u));if(s.length){const o=()=>{for(let n=0;n<s.length;n++)ro(s[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ro(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)i[c]||ro(r[c],"unbind",t,t,o)}(t,e)}const eo=Object.create(null);function no(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=eo),n[oo(r)]=r,r.def=jt(e.$options,"directives",r.name);return n}function oo(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ro(t,e,n,o,r){const i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var io=[Jn,Qn];function so(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let i,s,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(i in n(u.__ob__)&&(u=o.data.attrs=k({},u)),u)s=u[i],a=l[i],a!==s&&ao(c,i,s,o.data.pre);for(i in(q||W)&&u.value!==l.value&&ao(c,"value",u.value),l)e(u[i])&&(jn(i)?c.removeAttributeNS(Ln,Dn(i)):Tn(i)||c.removeAttribute(i))}function ao(t,e,n,o){o||t.tagName.indexOf("-")>-1?co(t,e,n):En(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,((t,e)=>Mn(e)||"false"===e?"false":"contenteditable"===t&&Nn(e)?e:"true")(e,n)):jn(e)?Mn(n)?t.removeAttributeNS(Ln,Dn(e)):t.setAttributeNS(Ln,e,n):co(t,e,n)}function co(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(q&&!J&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var lo={create:so,update:so};function uo(t,o){const r=o.elm,i=o.data,s=t.data;if(e(i.staticClass)&&e(i.class)&&(e(s)||e(s.staticClass)&&e(s.class)))return;let a=In(o);const c=r._transitionClasses;n(c)&&(a=Pn(a,Rn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var fo={create:uo,update:uo};const po=/[\w).+\-_$\]]/;function ho(t){let e,n,o,r,i,s=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),s)39===e&&92!==n&&(s=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:s=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&po.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(i||(i=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),i)for(o=0;o<i.length;o++)r=mo(r,i[o]);return r}function mo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function yo(t,e){console.error(`[Vue compiler]: ${t}`)}function go(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function vo(t,e,n,o,r){(t.props||(t.props=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function $o(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function _o(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(Oo({name:e,value:n},o))}function bo(t,e,n,o,r,i,s,a){(t.directives||(t.directives=[])).push(Oo({name:e,rawName:n,value:o,arg:r,isDynamicArg:i,modifiers:s},a)),t.plain=!1}function wo(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Co(e,n,o,r,i,s,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=wo("!",n,c)),r.once&&(delete r.once,n=wo("~",n,c)),r.passive&&(delete r.passive,n=wo("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=Oo({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?i?f.unshift(u):f.push(u):l[n]=f?i?[u,f]:[f,u]:u,e.plain=!1}function xo(t,e,n){const o=Ao(t,":"+e)||Ao(t,"v-bind:"+e);if(null!=o)return ho(o);if(!1!==n){const n=Ao(t,e);if(null!=n)return JSON.stringify(n)}}function Ao(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function ko(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function Oo(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function So(t,e,n){const{number:o,trim:r}=n||{},i="$$v";let s=i;r&&(s="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(s=`_n(${s})`);const a=To(e,s);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function To(t,e){const n=function(t){if(t=t.trim(),No=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<No-1)return jo=t.lastIndexOf("."),jo>-1?{exp:t.slice(0,jo),key:'"'+t.slice(jo+1)+'"'}:{exp:t,key:null};Eo=t,jo=Do=Mo=0;for(;!Fo();)Lo=Io(),Po(Lo)?Ho(Lo):91===Lo&&Ro(Lo);return{exp:t.slice(0,Do),key:t.slice(Do+1,Mo)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let No,Eo,Lo,jo,Do,Mo;function Io(){return Eo.charCodeAt(++jo)}function Fo(){return jo>=No}function Po(t){return 34===t||39===t}function Ro(t){let e=1;for(Do=jo;!Fo();)if(Po(t=Io()))Ho(t);else if(91===t&&e++,93===t&&e--,0===e){Mo=jo;break}}function Ho(t){const e=t;for(;!Fo()&&(t=Io())!==e;);}let Bo;function Uo(t,e,n){const o=Bo;return function r(){const i=e.apply(null,arguments);null!==i&&Ko(t,r,n,o)}}const zo=zt&&!(G&&Number(G[1])<=53);function Vo(t,e,n,o){if(zo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Bo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Ko(t,e,n,o){(o||Bo).removeEventListener(t,e._wrapper||e,n)}function qo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},i=t.data.on||{};Bo=o.elm,function(t){if(n(t.__r)){const e=q?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,i,Vo,Ko,Uo,o.context),Bo=void 0}var Jo={create:qo,update:qo};let Wo;function Zo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,i;const s=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=k({},c)),a)r in c||(s[r]="");for(r in c){if(i=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),i===a[r])continue;1===s.childNodes.length&&s.removeChild(s.childNodes[0])}if("value"===r&&"PROGRESS"!==s.tagName){s._value=i;const t=e(i)?"":String(i);Go(s,t)&&(s.value=t)}else if("innerHTML"===r&&Un(s.tagName)&&e(s.innerHTML)){Wo=Wo||document.createElement("div"),Wo.innerHTML=`<svg>${i}</svg>`;const t=Wo.firstChild;for(;s.firstChild;)s.removeChild(s.firstChild);for(;t.firstChild;)s.appendChild(t.firstChild)}else if(i!==a[r])try{s[r]=i}catch(t){}}}function Go(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var Xo={create:Zo,update:Zo};const Yo=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function Qo(t){const e=tr(t.style);return t.staticStyle?k(t.staticStyle,e):e}function tr(t){return Array.isArray(t)?O(t):"string"==typeof t?Yo(t):t}const er=/^--/,nr=/\s*!important$/,or=(t,e,n)=>{if(er.test(e))t.style.setProperty(e,n);else if(nr.test(n))t.style.setProperty(C(e),n.replace(nr,""),"important");else{const o=sr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},rr=["Webkit","Moz","ms"];let ir;const sr=v((function(t){if(ir=ir||document.createElement("div").style,"filter"!==(t=_(t))&&t in ir)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<rr.length;t++){const n=rr[t]+e;if(n in ir)return n}}));function ar(t,o){const r=o.data,i=t.data;if(e(r.staticStyle)&&e(r.style)&&e(i.staticStyle)&&e(i.style))return;let s,a;const c=o.elm,l=i.staticStyle,u=i.normalizedStyle||i.style||{},f=l||u,d=tr(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?k({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=Qo(e.data))&&k(n,o)}(o=Qo(t.data))&&k(n,o);let r=t;for(;r=r.parent;)r.data&&(o=Qo(r.data))&&k(n,o);return n}(o,!0);for(a in f)e(p[a])&&or(c,a,"");for(a in p)s=p[a],s!==f[a]&&or(c,a,null==s?"":s)}var cr={create:ar,update:ar};const lr=/\s+/;function ur(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&k(e,fr(t.name||"v")),k(e,t),e}return"string"==typeof t?fr(t):void 0}}const fr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`})));let dr="transition",pr="transitionend",hr="animation",mr="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(dr="WebkitTransition",pr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(hr="WebkitAnimation",mr="webkitAnimationEnd"));const yr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function gr(t){yr((()=>{yr(t)}))}function vr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function $r(t,e){t._transitionClasses&&m(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function _r(t,e,n){const{type:o,timeout:r,propCount:i}=function(t,e){const n=window.getComputedStyle(t),o=(n[dr+"Delay"]||"").split(", "),r=(n[dr+"Duration"]||"").split(", "),i=wr(o,r),s=(n[hr+"Delay"]||"").split(", "),a=(n[hr+"Duration"]||"").split(", "),c=wr(s,a);let l,u=0,f=0;"transition"===e?i>0&&(l="transition",u=i,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(i,c),l=u>0?i>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);const d="transition"===l&&br.test(n[dr+"Property"]);return{type:l,timeout:u,propCount:f,hasTransform:d}}(t,e);if(!o)return n();const s="transition"===o?pr:mr;let a=0;const c=()=>{t.removeEventListener(s,l),n()},l=e=>{e.target===t&&++a>=i&&c()};setTimeout((()=>{a<i&&c()}),r+1),t.addEventListener(s,l)}const br=/\b(transform|all)(,|$)/;function wr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Cr(e)+Cr(t[n]))))}function Cr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function xr(t){return"number"==typeof t&&!isNaN(t)}function Ar(t){if(e(t))return!1;const o=t.fns;return n(o)?Ar(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function kr(t,o){!0!==o.data.show&&function(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const s=ur(t.data.transition);if(e(s))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=s;let A=Ke,k=Ke.$vnode;for(;k&&k.parent;)A=k.context,k=k.parent;const O=!A._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,L=O&&"function"==typeof b?b:g,D=O&&w||v,M=O&&C||$,I=f(i(x)?x.enter:x),F=!1!==a&&!J,P=Ar(L),R=r._enterCb=j((()=>{F&&($r(r,N),$r(r,T)),R.cancelled?(F&&$r(r,S),M&&M(r)):D&&D(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(r,R)})),E&&E(r),F&&(vr(r,S),vr(r,T),gr((()=>{$r(r,S),R.cancelled||(vr(r,N),P||(xr(I)?setTimeout(R,I):_r(r,c,R)))}))),t.data.show&&(o&&o(),L&&L(r,R)),F||P||R()}(o)}const Or=function(t){let i,s;const a={},{modules:c,nodeOps:l}=t;for(i=0;i<Gn.length;++i)for(a[Gn[i]]=[],s=0;s<c.length;++s)n(c[s][Gn[i]])&&a[Gn[i]].push(c[s][Gn[i]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,i,s,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!s,function(t,e,r,i){let s=t.data;if(n(s)){const c=n(t.componentInstance)&&s.keepAlive;if(n(s=s.hook)&&n(s=s.init)&&s(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,i),o(c)&&function(t,e,o,r){let i,s=t;for(;s.componentInstance;)if(s=s.componentInstance._vnode,n(i=s.data)&&n(i=i.transition)){for(i=0;i<a.activate.length;++i)a.activate[i](Zn,s);e.push(s);break}h(o,t.elm,r)}(t,e,r,i),!0}}(t,e,r,i))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,i)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,i)):(t.elm=l.createTextNode(t.text),h(r,t.elm,i))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Wn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);i=t.data.hook,n(i)&&(n(i.create)&&i.create(Zn,t),n(i.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,i){for(;o<=r;++o)f(n[o],i,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let i=o;i<r;i++){const o=e[i];if(n(o)&&Xn(t,o))return i}}function x(t,r,i,s,c,u){if(t===r)return;n(r.elm)&&n(s)&&(r=s[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,i):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,i,s){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const A=!s;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:Xn(y,_)?(x(y,_,i,r,h),y=o[++p],_=r[++h]):Xn(g,w)?(x(g,w,i,r,v),g=o[--m],w=r[--v]):Xn(y,w)?(x(y,w,i,r,v),A&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):Xn(g,_)?(x(g,_,i,r,h),A&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=Yn(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,i,t,y.elm,!1,r,h):(u=o[c],Xn(u,_)?(x(u,_,i,r,h),o[c]=void 0,A&&l.insertBefore(t,u.elm,y.elm)):f(_,i,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,i)):h>v&&b(o,p,m)}(d,m,g,i,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,i)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function A(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,i){let s;const{tag:a,data:c,children:l}=e;if(i=i||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(s=c.hook)&&n(s=s.init)&&s(e,!0),n(s=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(s=c)&&n(s=s.domProps)&&n(s=s.innerHTML)){if(s!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,i)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!k(n)){t=!0,g(e,r);break}!t&&c.class&&Gt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,i,s){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Xn(t,r))x(t,r,u,null,null,s);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),i=!0),o(i)&&O(t,r,u))return A(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const s=t.elm,c=l.parentNode(s);if(f(r,u,s._leaveCb?null:c,l.nextSibling(s)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Wn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return A(r,u,c),r.elm}}({nodeOps:qn,modules:[lo,fo,Jo,Xo,cr,U?{create:kr,activate:kr,remove(t,o){!0!==t.data.show?function(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const s=ur(t.data.transition);if(e(s)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=s,$=!1!==a&&!J,_=Ar(h),b=f(i(v)?v.leave:v),w=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&($r(r,u),$r(r,d)),w.cancelled?($&&$r(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(vr(r,l),vr(r,d),gr((()=>{$r(r,l),w.cancelled||(vr(r,u),_||(xr(b)?setTimeout(w,b):_r(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}(t,o):o()}}:{}].concat(io)});J&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Mr(t,"input")}));const Sr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Sr.componentUpdated(t,e,n)})):Tr(t,e,n.context),t._vOptions=[].map.call(t.options,Lr)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",jr),t.addEventListener("compositionend",Dr),t.addEventListener("change",Dr),J&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Tr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Lr);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>Er(t,r))):e.value!==e.oldValue&&Er(e.value,r))&&Mr(t,"change")}}}};function Tr(t,e,n){Nr(t,e),(q||W)&&setTimeout((()=>{Nr(t,e)}),0)}function Nr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let i,s;for(let e=0,n=t.options.length;e<n;e++)if(s=t.options[e],r)i=L(o,Lr(s))>-1,s.selected!==i&&(s.selected=i);else if(E(Lr(s),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Er(t,e){return e.every((e=>!E(e,t)))}function Lr(t){return"_value"in t?t._value:t.value}function jr(t){t.target.composing=!0}function Dr(t){t.target.composing&&(t.target.composing=!1,Mr(t.target,"input"))}function Mr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}const Ir=/\s+/;function Fr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ir).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ir).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function Rr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&k(e,Hr(t.name||"v")),k(e,t),e}return"string"==typeof t?Hr(t):void 0}}const Hr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),Br=U&&!J;let Ur="transition",zr="transitionend",Vr="animation",Kr="animationend";Br&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ur="WebkitTransition",zr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Vr="WebkitAnimation",Kr="webkitAnimationEnd"));const qr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Jr(t){qr((()=>{qr(t)}))}function Wr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Fr(t,e))}function Zr(t,e){t._transitionClasses&&m(t._transitionClasses,e),Pr(t,e)}function Gr(t,e,n){const{type:o,timeout:r,propCount:i}=Yr(t,e);if(!o)return n();const s="transition"===o?zr:Kr;let a=0;const c=()=>{t.removeEventListener(s,l),n()},l=e=>{e.target===t&&++a>=i&&c()};setTimeout((()=>{a<i&&c()}),r+1),t.addEventListener(s,l)}const Xr=/\b(transform|all)(,|$)/;function Yr(t,e){const n=window.getComputedStyle(t),o=(n[Ur+"Delay"]||"").split(", "),r=(n[Ur+"Duration"]||"").split(", "),i=Qr(o,r),s=(n[Vr+"Delay"]||"").split(", "),a=(n[Vr+"Duration"]||"").split(", "),c=Qr(s,a);let l,u=0,f=0;"transition"===e?i>0&&(l="transition",u=i,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(i,c),l=u>0?i>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Xr.test(n[Ur+"Property"])}}function Qr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>ti(e)+ti(t[n]))))}function ti(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ei(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const s=Rr(t.data.transition);if(e(s))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=s;let A=Ke,k=Ke.$vnode;for(;k&&k.parent;)A=k.context,k=k.parent;const O=!A._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,L=O&&"function"==typeof b?b:g,D=O&&w||v,M=O&&C||$,I=f(i(x)?x.enter:x),F=!1!==a&&!J,P=oi(L),R=r._enterCb=j((()=>{F&&(Zr(r,N),Zr(r,T)),R.cancelled?(F&&Zr(r,S),M&&M(r)):D&&D(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(r,R)})),E&&E(r),F&&(Wr(r,S),Wr(r,T),Jr((()=>{Zr(r,S),R.cancelled||(Wr(r,N),P||(ni(I)?setTimeout(R,I):Gr(r,c,R)))}))),t.data.show&&(o&&o(),L&&L(r,R)),F||P||R()}function ni(t){return"number"==typeof t&&!isNaN(t)}function oi(t){if(e(t))return!1;const o=t.fns;return n(o)?oi(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function ri(t){return!t.componentInstance||t.data&&t.data.transition?t:ri(t.componentInstance._vnode)}var ii={model:Sr,show:{bind(t,{value:e},n){const o=(n=ri(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,ei(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:o,oldValue:r},s){if(!o==!r)return;(s=ri(s)).data&&s.data.transition?(s.data.show=!0,o?ei(s,(()=>{t.style.display=t.__vOriginalDisplay})):function(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const s=Rr(t.data.transition);if(e(s)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=s,$=!1!==a&&!J,_=oi(h),b=f(i(v)?v.leave:v),w=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(Zr(r,u),Zr(r,d)),w.cancelled?($&&Zr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(Wr(r,l),Wr(r,d),Jr((()=>{Zr(r,l),w.cancelled||(Wr(r,u),_||(ni(b)?setTimeout(w,b):Gr(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}(s,(()=>{t.style.display="none"}))):t.style.display=o?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}}};const si={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ai(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?ai(He(e.children)):t}function ci(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function li(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const ui=t=>t.tag||Re(t),fi=t=>"show"===t.name;var di={name:"transition",props:si,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(ui),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const i=ai(o);if(!i)return o;if(this._leaving)return li(t,o);const s=`__transition-${this._uid}-`;i.key=null==i.key?i.isComment?s+"comment":s+i.tag:r(i.key)?0===String(i.key).indexOf(s)?i.key:s+i.key:i.key;const a=(i.data||(i.data={})).transition=ci(this),c=this._vnode,l=ai(c);if(i.data.directives&&i.data.directives.some(fi)&&(i.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(i,l)&&!Re(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=k({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),li(t,o);if("in-out"===n){if(Re(i))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const pi=k({tag:String,moveClass:String},si);function hi(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function mi(t){t.data.newPos=t.elm.getBoundingClientRect()}function yi(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete pi.mode;var gi={Transition:di,TransitionGroup:{props:pi,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=qe(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],i=this.children=[],s=ci(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(i.push(e),n[e.key]=e,(e.data||(e.data={})).transition=s)}if(o){const r=[],i=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=s,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):i.push(e)}this.kept=t(e,null,r),this.removed=i}return t(e,null,i)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(hi),t.forEach(mi),t.forEach(yi),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Wr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(zr,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(zr,t),n._moveCb=null,Zr(n,e))})}})))},methods:{hasMove(t,e){if(!Br)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{Pr(n,t)})),Fr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Yr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,$n.config.isReservedTag=zn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=function(t){return Un(t)?"svg":"math"===t?"math":void 0},$n.config.isUnknownElement=function(t){if(!U)return!0;if(zn(t))return!1;if(t=t.toLowerCase(),null!=Vn[t])return Vn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Vn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Vn[t]=/HTMLUnknownElement/.test(e.toString())},k($n.options.directives,ii),k($n.options.components,gi),$n.prototype.__patch__=U?Or:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ge(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ge(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ge(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((()=>{I.devtools&&et&&et.emit("init",$n)}),0);const vi=d("input,textarea,option,select,progress"),$i=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),_i=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function bi(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}const wi=/\{\{((?:.|\r?\n)+?)\}\}/g,Ci=/[-.*+?^${}()|[\]\/\\]/g,xi=v((t=>{const e=t[0].replace(Ci,"\\$&"),n=t[1].replace(Ci,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var Ai={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=Ao(t,"class");n&&(t.staticClass=JSON.stringify(n));const o=xo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var ki={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=Ao(t,"style");n&&(t.staticStyle=JSON.stringify(Yo(n)));const o=xo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let Oi;var Si={decode:t=>(Oi=Oi||document.createElement("div"),Oi.innerHTML=t,Oi.textContent)};const Ti=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ni=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ei=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Li=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,ji=`((?:${Li}\\:)?${Li})`,Di=new RegExp(`^<${ji}`),Mi=/^\s*(\/?)>/,Ii=new RegExp(`^<\\/${ji}[^>]*>`),Fi=/^<!DOCTYPE [^>]+>/i,Pi=/^<!\--/,Ri=/^<!\[/,Hi=d("script,style,textarea",!0),Bi={},Ui={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},zi=/&(?:lt|gt|quot|amp|#39);/g,Vi=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ki=d("pre,textarea",!0),qi=(t,e)=>t&&Ki(t)&&"\n"===e[0];function Ji(t,e){const n=e?Vi:zi;return t.replace(n,(t=>Ui[t]))}const Wi=/^@|^v-on:/,Zi=/^v-|^@|^:|^#/,Gi=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Xi=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Yi=/^\(|\)$/g,Qi=/^\[.*\]$/,ts=/:(.*)$/,es=/^:|^\.|^v-bind:/,ns=/\.[^.\]]+(?=[^\]]*$)/g,os=/^v-slot(:|$)|^#/,rs=/[\r\n]/,is=/[ \f\t\r\n]+/g,ss=v(Si.decode);let as,cs,ls,us,fs,ds,ps,hs;function ms(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ws(e),rawAttrsMap:{},parent:n,children:[]}}function ys(t,e){as=e.warn||yo,ds=e.isPreTag||T,ps=e.mustUseProp||T,hs=e.getTagNamespace||T,e.isReservedTag,ls=go(e.modules,"transformNode"),us=go(e.modules,"preTransformNode"),fs=go(e.modules,"postTransformNode"),cs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let i,s,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=gs(t,e)),n.length||t===i||i.if&&(t.elseif||t.else)&&$s(i,{exp:t.elseif,block:t}),s&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&$s(n,{exp:t.elseif,block:t})}(t,s);else{if(t.slotScope){const e=t.slotTarget||'"default"';(s.scopedSlots||(s.scopedSlots={}))[e]=t}s.children.push(t),t.parent=s}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),ds(t.tag)&&(c=!1);for(let n=0;n<fs.length;n++)fs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,i=e.canBeLeftOpenTag||T;let s,a,c=0;for(;t;){if(s=t,a&&Hi(a)){let n=0;const o=a.toLowerCase(),r=Bi[o]||(Bi[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),i=t.replace(r,(function(t,r,i){return n=i.length,Hi(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),qi(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-i.length,t=i,d(o,c-n,c)}else{let n,o,r,i=t.indexOf("<");if(0===i){if(Pi.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(Ri.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Fi);if(n){l(n[0].length);continue}const o=t.match(Ii);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),qi(r.tagName,t)&&l(1);continue}}if(i>=0){for(o=t.slice(i);!(Ii.test(o)||Di.test(o)||Pi.test(o)||Ri.test(o)||(r=o.indexOf("<",1),r<0));)i+=r,o=t.slice(i);n=t.substring(0,i)}i<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===s){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(Di);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(Mi))&&(r=t.match(Ei)||t.match(Ni));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const s=t.tagName,c=t.unarySlash;o&&("p"===a&&Ti(s)&&d(a),i(s)&&a===s&&d(s));const l=r(s)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",i="a"===s&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ji(r,i)}}l||(n.push({tag:s,lowerCasedTag:s.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=s),e.start&&e.start(s,f,l,t.start,t.end)}function d(t,o,r){let i,s;if(null==o&&(o=c),null==r&&(r=c),t)for(s=t.toLowerCase(),i=n.length-1;i>=0&&n[i].lowerCasedTag!==s;i--);else i=0;if(i>=0){for(let t=n.length-1;t>=i;t--)e.end&&e.end(n[t].tag,o,r);n.length=i,a=i&&n[i-1].tag}else"br"===s?e.start&&e.start(t,[],!0,o,r):"p"===s&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:as,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=s&&s.ns||hs(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];Cs.test(o.name)||(o.name=o.name.replace(xs,""),e.push(o))}return e}(o));let p=ms(t,o,s);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<us.length;t++)p=us[t](p,e)||p;a||(!function(t){null!=Ao(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),ds(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(vs(p),function(t){const e=Ao(t,"v-if");if(e)t.if=e,$s(t,{exp:e,block:t});else{null!=Ao(t,"v-else")&&(t.else=!0);const e=Ao(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=Ao(t,"v-once")&&(t.once=!0)}(p)),i||(i=p),r?l(p):(s=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,s=n[n.length-1],l(r)},chars(t,e,n){if(!s)return;if(q&&"textarea"===s.tag&&s.attrsMap.placeholder===t)return;const i=s.children;var l;if(t=c||t.trim()?"script"===(l=s).tag||"style"===l.tag?t:ss(t):i.length?r?"condense"===r&&rs.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(is," ")),!a&&" "!==t&&(e=function(t,e){const n=e?xi(e):wi;if(!n.test(t))return;const o=[],r=[];let i,s,a,c=n.lastIndex=0;for(;i=n.exec(t);){s=i.index,s>c&&(r.push(a=t.slice(c,s)),o.push(JSON.stringify(a)));const e=ho(i[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=s+i[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,cs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&i.length&&" "===i[i.length-1].text||(n={type:3,text:t}),n&&i.push(n)}},comment(t,e,n){if(s){const e={type:3,text:t,isComment:!0};s.children.push(e)}}}),i}function gs(t,e){var n;!function(t){const e=xo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=xo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=Ao(t,"scope"),t.slotScope=e||Ao(t,"slot-scope")):(e=Ao(t,"slot-scope"))&&(t.slotScope=e);const n=xo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||$o(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=ko(t,os);if(e){const{name:n,dynamic:o}=_s(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=ko(t,os);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=_s(e),i=n[o]=ms("template",[],t);i.slotTarget=o,i.slotTargetDynamic=r,i.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=i,!0})),i.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=xo(n,"name")),function(t){let e;(e=xo(t,"is"))&&(t.component=e);null!=Ao(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<ls.length;n++)t=ls[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,i,s,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=i=e[n].name,s=e[n].value,Zi.test(r))if(t.hasBindings=!0,a=bs(r.replace(Zi,"")),a&&(r=r.replace(ns,"")),es.test(r))r=r.replace(es,""),s=ho(s),l=Qi.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=To(s,"$event"),l?Co(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Co(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Co(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&ps(t.tag,t.attrsMap.type,r)?vo(t,r,s,e[n],l):$o(t,r,s,e[n],l);else if(Wi.test(r))r=r.replace(Wi,""),l=Qi.test(r),l&&(r=r.slice(1,-1)),Co(t,r,s,a,!1,0,e[n],l);else{r=r.replace(Zi,"");const o=r.match(ts);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Qi.test(c)&&(c=c.slice(1,-1),l=!0)),bo(t,r,i,s,c,l,a,e[n])}else $o(t,r,JSON.stringify(s),e[n]),!t.component&&"muted"===r&&ps(t.tag,t.attrsMap.type,r)&&vo(t,r,"true",e[n])}(t),t}function vs(t){let e;if(e=Ao(t,"v-for")){const n=function(t){const e=t.match(Gi);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Yi,""),r=o.match(Xi);r?(n.alias=o.replace(Xi,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&k(t,n)}}function $s(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function _s(t){let e=t.name.replace(os,"");return e||"#"!==t.name[0]&&(e="default"),Qi.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function bs(t){const e=t.match(ns);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ws(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const Cs=/^xmlns:NS\d+/,xs=/^NS\d+:/;function As(t){return ms(t.tag,t.attrsList.slice(),t.parent)}var ks=[Ai,ki,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=xo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=Ao(t,"v-if",!0),r=n?`&&(${n})`:"",i=null!=Ao(t,"v-else",!0),s=Ao(t,"v-else-if",!0),a=As(t);vs(a),_o(a,"type","checkbox"),gs(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,$s(a,{exp:a.if,block:a});const c=As(t);Ao(c,"v-for",!0),_o(c,"type","radio"),gs(c,e),$s(a,{exp:`(${o})==='radio'`+r,block:c});const l=As(t);return Ao(l,"v-for",!0),_o(l,":type",o),gs(l,e),$s(a,{exp:n,block:l}),i?a.else=!0:s&&(a.elseif=s),a}}}}];const Os={expectHTML:!0,modules:ks,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,i=t.tag,s=t.attrsMap.type;if(t.component)return So(t,o,r),!1;if("select"===i)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${To(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Co(t,"change",r,null,!0)}(t,o,r);else if("input"===i&&"checkbox"===s)!function(t,e,n){const o=n&&n.number,r=xo(t,"value")||"null",i=xo(t,"true-value")||"true",s=xo(t,"false-value")||"false";vo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===i?`:(${e})`:`:_q(${e},${i})`)),Co(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${i}):(${s});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${To(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${To(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${To(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===i&&"radio"===s)!function(t,e,n){const o=n&&n.number;let r=xo(t,"value")||"null";r=o?`_n(${r})`:r,vo(t,"checked",`_q(${e},${r})`),Co(t,"change",To(e,r),null,!0)}(t,o,r);else if("input"===i||"textarea"===i)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:i,trim:s}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";s&&(l="$event.target.value.trim()");i&&(l=`_n(${l})`);let u=To(e,l);a&&(u=`if($event.target.composing)return;${u}`);vo(t,"value",`(${e})`),Co(t,c,u,null,!0),(s||i)&&Co(t,"blur","$forceUpdate()")}(t,o,r);else if(!I.isReservedTag(i))return So(t,o,r),!1;return!0},text:function(t,e){e.value&&vo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&vo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:(t,e,n)=>"value"===n&&vi(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,canBeLeftOpenTag:d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:t=>$i(t)||_i(t),getTagNamespace:function(t){return _i(t)?"svg":"math"===t?"math":void 0},staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(ks)};let Ss,Ts;const Ns=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function Es(t,e){t&&(Ss=Ns(e.staticKeys||""),Ts=e.isReservedTag||T,Ls(t),js(t,!1))}function Ls(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!Ts(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(Ss)))}(t),1===t.type){if(!Ts(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];Ls(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;Ls(n),n.static||(t.static=!1)}}}function js(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)js(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)js(t.ifConditions[n].block,e)}}const Ds=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ms=/\([^)]*?\);*$/,Is=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Fs={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ps={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Rs=t=>`if(${t})return null;`,Hs={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Rs("$event.target !== $event.currentTarget"),ctrl:Rs("!$event.ctrlKey"),shift:Rs("!$event.shiftKey"),alt:Rs("!$event.altKey"),meta:Rs("!$event.metaKey"),left:Rs("'button' in $event && $event.button !== 0"),middle:Rs("'button' in $event && $event.button !== 1"),right:Rs("'button' in $event && $event.button !== 2")};function Bs(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Us(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Us(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Us(t))).join(",")}]`;const e=Is.test(t.value),n=Ds.test(t.value),o=Is.test(t.value.replace(Ms,""));if(t.modifiers){let r="",i="";const s=[];for(const e in t.modifiers)if(Hs[e])i+=Hs[e],Fs[e]&&s.push(e);else if("exact"===e){const e=t.modifiers;i+=Rs(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else s.push(e);s.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(zs).join("&&")})return null;`}(s)),i&&(r+=i);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function zs(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Fs[t],o=Ps[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Vs={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ks{constructor(t){this.options=t,this.warn=t.warn||yo,this.transforms=go(t.modules,"transformCode"),this.dataGenFns=go(t.modules,"genData"),this.directives=k(k({},Vs),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function qs(t,e){const n=new Ks(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Js(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Js(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ws(t,e);if(t.once&&!t.onceProcessed)return Zs(t,e);if(t.for&&!t.forProcessed)return Ys(t,e);if(t.if&&!t.ifProcessed)return Gs(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=na(t,e);let r=`_t(${n}${o?`,${o}`:""}`;const i=t.attrs||t.dynamicAttrs?ia((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,s=t.attrsMap["v-bind"];!i&&!s||o||(r+=",null");i&&(r+=`,${i}`);s&&(r+=`${i?"":",null"},${s}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:na(e,n,!0);return`_c(${t},${Qs(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Qs(t,e));const r=t.inlineTemplate?null:na(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return na(t,e)||"void 0"}function Ws(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Js(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Zs(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Gs(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Js(t,e)},${e.onceId++},${n})`:Js(t,e)}return Ws(t,e)}function Gs(t,e,n,o){return t.ifProcessed=!0,Xs(t.ifConditions.slice(),e,n,o)}function Xs(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${i(r.block)}:${Xs(t,e,n,o)}`:`${i(r.block)}`;function i(t){return n?n(t,e):t.once?Zs(t,e):Js(t,e)}}function Ys(t,e,n,o){const r=t.for,i=t.alias,s=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${i}${s}${a}){return ${(n||Js)(t,e)}})`}function Qs(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,i,s,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){i=n[o],s=!0;const r=e.directives[i.name];r&&(s=!!r(t,i,e.warn)),s&&(c=!0,a+=`{name:"${i.name}",rawName:"${i.rawName}"${i.value?`,value:(${i.value}),expression:${JSON.stringify(i.value)}`:""}${i.arg?`,arg:${i.isDynamicArg?i.arg:`"${i.arg}"`}`:""}${i.modifiers?`,modifiers:${JSON.stringify(i.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${ia(t.attrs)},`),t.props&&(n+=`domProps:${ia(t.props)},`),t.events&&(n+=`${Bs(t.events,!1)},`),t.nativeEvents&&(n+=`${Bs(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||ta(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const i=Object.keys(e).map((t=>ea(e[t],n))).join(",");return`scopedSlots:_u([${i}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(i)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=qs(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${ia(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function ta(t){return 1===t.type&&("slot"===t.tag||t.children.some(ta))}function ea(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Gs(t,e,ea,"null");if(t.for&&!t.forProcessed)return Ys(t,e,ea);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${na(t,e)||"undefined"}:undefined`:na(t,e)||"undefined":Js(t,e)}}`,i=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${i}}`}function na(t,e,n,o,r){const i=t.children;if(i.length){const t=i[0];if(1===i.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Js)(t,e)}${r}`}const s=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(oa(r)||r.ifConditions&&r.ifConditions.some((t=>oa(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(i,e.maybeComponent):0,a=r||ra;return`[${i.map((t=>a(t,e))).join(",")}]${s?`,${s}`:""}`}}function oa(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function ra(t,e){return 1===t.type?Js(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:sa(JSON.stringify(t.text))})`}(t)}function ia(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],i=sa(r.value);r.dynamic?n+=`${r.name},${i},`:e+=`"${r.name}":${i},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function sa(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function aa(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function ca(t){const e=Object.create(null);return function(n,o,r){(o=k({},o)).warn,delete o.warn;const i=o.delimiters?String(o.delimiters)+n:n;if(e[i])return e[i];const s=t(n,o),a={},c=[];return a.render=aa(s.render,c),a.staticRenderFns=s.staticRenderFns.map((t=>aa(t,c))),e[i]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");const la=(ua=function(t,e){const n=ys(t.trim(),e);!1!==e.optimize&&Es(n,e);const o=qs(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],i=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=k(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?i:r).push(t)};const s=ua(e.trim(),o);return s.errors=r,s.tips=i,s}return{compile:e,compileToFunctions:ca(e)}});var ua;const{compile:fa,compileToFunctions:da}=la(Os);let pa;function ha(t){return pa=pa||document.createElement("div"),pa.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',pa.innerHTML.indexOf("&#10;")>0}const ma=!!U&&ha(!1),ya=!!U&&ha(!0),ga=v((t=>{const e=bi(t);return e&&e.innerHTML})),va=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&bi(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=ga(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=da(e,{outputSourceRange:!1,shouldDecodeNewlines:ma,shouldDecodeNewlinesForHref:ya,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return va.call(this,t,e)},$n.compile=da;export default $n;
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index d6fc96be8d2..578ccf7f190 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -428,7 +428,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -471,7 +471,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get: function get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -517,19 +517,20 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
+    _Set = /*@__PURE__*/(function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function (key) {
+        Set.prototype.has = function has (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function (key) {
+        Set.prototype.add = function add (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function () {
+        Set.prototype.clear = function clear () {
             this.set = Object.create(null);
         };
+
         return Set;
     }());
 }
@@ -539,22 +540,20 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
     warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
+        if (hasConsole && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -577,10 +576,10 @@ if (process.env.NODE_ENV !== 'production') {
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
     };
-    var repeat_1 = function (str, n) {
+    var repeat$1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -614,15 +613,13 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
         }
     };
 }
@@ -632,37 +629,34 @@ var uid$2 = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid$2++;
-        this.subs = [];
+var Dep = function Dep() {
+    this.id = uid$2++;
+    this.subs = [];
+};
+Dep.prototype.addSub = function addSub (sub) {
+    this.subs.push(sub);
+};
+Dep.prototype.removeSub = function removeSub (sub) {
+    remove$2(this.subs, sub);
+};
+Dep.prototype.depend = function depend () {
+    if (Dep.target) {
+        Dep.target.addDep(this);
     }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove$2(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort(function (a, b) { return a.id - b.id; });
-        }
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
+};
+Dep.prototype.notify = function notify () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
+};
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -677,45 +671,43 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
+};
+
+var prototypeAccessors = { child: { configurable: true } };
+// DEPRECATED: alias for componentInstance for backwards compat.
+/* istanbul ignore next */
+prototypeAccessors.child.get = function () {
+    return this.componentInstance;
+};
+
+Object.defineProperties( VNode.prototype, prototypeAccessors );
 var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
+    if ( text === void 0 ) text = '';
+
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -769,12 +761,9 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -810,46 +799,43 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
         }
         else {
-            this.walk(value);
+            copyAugment(value, arrayMethods, arrayKeys);
         }
+        this.observeArray(value);
     }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
+    else {
+        this.walk(value);
+    }
+};
+/**
+ * Walk through all properties and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ */
+Observer.prototype.walk = function walk (obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i]);
+    }
+};
+/**
+ * Observe a list of Array items.
+ */
+Observer.prototype.observeArray = function observeArray (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
+};
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -960,7 +946,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -993,7 +979,7 @@ function set(target, key, val) {
 function del(target, key) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+        warn$2(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -1021,7 +1007,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1197,14 +1183,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1242,7 +1228,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
         warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1286,7 +1272,7 @@ function normalizeProps(options, vm) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
+            "but got " + (toRawType(props)) + ".", vm);
     }
     options.props = res;
 }
@@ -1313,7 +1299,7 @@ function normalizeInject(options, vm) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
+            "but got " + (toRawType(inject)) + ".", vm);
     }
 }
 /**
@@ -1333,7 +1319,7 @@ function normalizeDirectives$1(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+            "but got " + (toRawType(value)) + ".", vm);
     }
 }
 /**
@@ -1571,7 +1557,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1579,24 +1565,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
+        message += " with value " + (styleValue(value, expectedType));
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
+        message += "with value " + (styleValue(value, receivedType)) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return "\"" + value + "\"";
+        return ("\"" + value + "\"");
     }
     else if (type === 'Number') {
-        return "" + Number(value);
+        return ("" + (Number(value)));
     }
     else {
-        return "" + value;
+        return ("" + value);
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1604,12 +1590,9 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var arguments$1 = arguments;
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments$1[_i];
-    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1675,7 +1658,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     if (process.env.NODE_ENV !== 'production') {
-        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
+        warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1718,9 +1701,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p_1 = Promise.resolve();
+    var p = Promise.resolve();
     timerFunc = function () {
-        p_1.then(flushCallbacks);
+        p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1739,15 +1722,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
+    var counter = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
     timerFunc = function () {
-        counter_1 = (counter_1 + 1) % 2;
-        textNode_1.data = String(counter_1);
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
     };
     isUsingMicroTask = true;
 }
@@ -1795,18 +1778,18 @@ function nextTick(cb, ctx) {
 var mark;
 var measure;
 if (process.env.NODE_ENV !== 'production') {
-    var perf_1 = inBrowser && window.performance;
+    var perf = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) {
-        mark = function (tag) { return perf_1.mark(tag); };
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf_1.measure(name, startTag, endTag);
-            perf_1.clearMarks(startTag);
-            perf_1.clearMarks(endTag);
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1815,31 +1798,31 @@ if (process.env.NODE_ENV !== 'production') {
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent_1 = function (target, key) {
+    var warnNonPresent = function (target, key) {
         warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix_1 = function (target, key) {
+    var warnReservedPrefix = function (target, key) {
         warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                     return false;
                 }
                 else {
@@ -1849,38 +1832,38 @@ if (process.env.NODE_ENV !== 'production') {
             },
         });
     }
-    var hasHandler_1 = {
-        has: function (target, key) {
+    var hasHandler = {
+        has: function has(target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals_1(key) ||
+            var isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler_1 = {
-        get: function (target, key) {
+    var getHandler = {
+        get: function get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy_1) {
+        if (hasProxy) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1968,7 +1951,7 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
         event = normalizeEvent(name);
         if (isUndef(cur)) {
             process.env.NODE_ENV !== 'production' &&
-                warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+                warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -2033,7 +2016,8 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs, props = data.props;
+    var attrs = data.attrs;
+    var props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2043,11 +2027,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2121,7 +2105,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2182,7 +2166,7 @@ function initInjections(vm) {
                 defineReactive(vm, key, result[key], function () {
                     warn$2("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        ("injection being mutated: \"" + key + "\""), vm);
+                        "injection being mutated: \"" + key + "\"", vm);
                 });
             }
             else {
@@ -2222,7 +2206,7 @@ function resolveInject(inject, vm) {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     // @ts-ignore
-                    warn$2("Injection \"" + key + "\" not found", vm);
+                    warn$2(("Injection \"" + key + "\" not found"), vm);
                 }
             }
         }
@@ -2250,8 +2234,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2264,9 +2248,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
         }
     }
     return slots;
@@ -2299,16 +2283,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2466,8 +2450,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash = void 0;
-            var _loop_1 = function (key) {
+            var hash;
+            var loop = function ( key ) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2484,15 +2468,14 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
+                        on[("update:" + key)] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-            for (var key in value) {
-                _loop_1(key);
-            }
+
+            for (var key in value) loop( key );
         }
     }
     return data;
@@ -2512,7 +2495,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic$1(tree, "__static__" + index, false);
+    markStatic$1(tree, ("__static__" + index), false);
     return tree;
 }
 /**
@@ -2520,14 +2503,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    markStatic$1(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
     return tree;
 }
 function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
             }
         }
     }
@@ -2595,7 +2578,7 @@ function bindDynamicKeys(baseObj, values) {
             key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+            warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
         }
     }
     return baseObj;
@@ -2628,7 +2611,8 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
+    var this$1 = this;
+
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2655,14 +2639,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
         }
-        return _this.$slots;
+        return this$1.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function () {
+        get: function get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2685,9 +2669,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) {
-            return createElement$1(contextVm, a, b, c, d, needNormalization);
-        };
+        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2743,7 +2725,7 @@ function mergeProps(to, from) {
 
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
+    init: function init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2756,7 +2738,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function (oldVnode, vnode) {
+    prepatch: function prepatch(oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2765,8 +2747,9 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2785,7 +2768,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2811,7 +2794,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         if (process.env.NODE_ENV !== 'production') {
-            warn$2("Invalid Component definition: " + String(Ctor), context);
+            warn$2(("Invalid Component definition: " + (String(Ctor))), context);
         }
         return;
     }
@@ -2869,7 +2852,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2952,7 +2935,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
         process.env.NODE_ENV !== 'production' &&
-            warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+            warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2988,7 +2971,7 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor = void 0;
+        var Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
@@ -2996,7 +2979,7 @@ function _createElement(context, tag, data, children, normalizationType) {
                 isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                warn$2(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3103,7 +3086,9 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3186,24 +3171,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners_1 = (factory.owners = [owner]);
-        var sync_1 = true;
-        var timerLoading_1 = null;
-        var timerTimeout_1 = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-        var forceRender_1 = function (renderCompleted) {
-            for (var i = 0, l = owners_1.length; i < l; i++) {
-                owners_1[i].$forceUpdate();
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners_1.length = 0;
-                if (timerLoading_1 !== null) {
-                    clearTimeout(timerLoading_1);
-                    timerLoading_1 = null;
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
                 }
-                if (timerTimeout_1 !== null) {
-                    clearTimeout(timerTimeout_1);
-                    timerTimeout_1 = null;
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
                 }
             }
         };
@@ -3212,65 +3197,65 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync_1) {
-                forceRender_1(true);
+            if (!sync) {
+                forceRender(true);
             }
             else {
-                owners_1.length = 0;
+                owners.length = 0;
             }
         });
-        var reject_1 = once(function (reason) {
+        var reject = once(function (reason) {
             process.env.NODE_ENV !== 'production' &&
-                warn$2("Failed to resolve async component: " + String(factory) +
-                    (reason ? "\nReason: " + reason : ''));
+                warn$2("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender_1(true);
+                forceRender(true);
             }
         });
-        var res_1 = factory(resolve, reject_1);
-        if (isObject(res_1)) {
-            if (isPromise(res_1)) {
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res_1.then(resolve, reject_1);
+                    res.then(resolve, reject);
                 }
             }
-            else if (isPromise(res_1.component)) {
-                res_1.component.then(resolve, reject_1);
-                if (isDef(res_1.error)) {
-                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
                 }
-                if (isDef(res_1.loading)) {
-                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                    if (res_1.delay === 0) {
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading_1 = setTimeout(function () {
-                            timerLoading_1 = null;
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender_1(false);
+                                forceRender(false);
                             }
-                        }, res_1.delay || 200);
+                        }, res.delay || 200);
                     }
                 }
-                if (isDef(res_1.timeout)) {
+                if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout_1 = setTimeout(function () {
-                        timerTimeout_1 = null;
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject_1(process.env.NODE_ENV !== 'production'
-                                ? "timeout (" + res_1.timeout + "ms)"
+                            reject(process.env.NODE_ENV !== 'production'
+                                ? ("timeout (" + (res.timeout) + "ms)")
                                 : null);
                         }
-                    }, res_1.timeout);
+                    }, res.timeout);
                 }
             }
         }
-        sync_1 = false;
+        sync = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3360,8 +3345,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                vm.$off(event[i_1], fn);
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
             }
             return vm;
         }
@@ -3392,10 +3377,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
             }
         }
         var cbs = vm._events[event];
@@ -3556,11 +3541,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure("vue " + name + " render", startTag, endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure("vue " + name + " patch", startTag, endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
         };
     }
     else {
@@ -3572,7 +3557,7 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function () {
+        before: function before() {
             if (vm._isMounted && !vm._isDestroyed) {
                 callHook$1(vm, 'beforeUpdate');
             }
@@ -3741,15 +3726,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance_1.now(); };
+        getNow = function () { return performance.now(); };
     }
 }
 /**
@@ -3784,7 +3769,7 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? "in watcher with expression \"" + watcher.expression + "\""
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3868,195 +3853,192 @@ var uid$1 = 0;
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = /** @class */ (function () {
-    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$1; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            process.env.NODE_ENV !== 'production' &&
+                warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
         }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression =
-            process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
+    }
+    this.value = this.lazy ? undefined : this.get();
+};
+/**
+ * Evaluate the getter, and re-collect dependencies.
+ */
+Watcher.prototype.get = function get () {
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
+    }
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
         }
         else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' &&
-                    warn$2("Failed watching path: \"" + expOrFn + "\" " +
-                        'Watcher only accepts simple dot-delimited paths. ' +
-                        'For full control, use a function instead.', vm);
-            }
+            throw e;
         }
-        this.value = this.lazy ? undefined : this.get();
     }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    Watcher.prototype.get = function () {
-        pushTarget(this);
-        var value;
-        var vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
         }
-        catch (e) {
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
+};
+/**
+ * Add a dependency to this directive.
+ */
+Watcher.prototype.addDep = function addDep (dep) {
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
+};
+/**
+ * Clean up for dependency collection.
+ */
+Watcher.prototype.cleanupDeps = function cleanupDeps () {
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
+};
+/**
+ * Subscriber interface.
+ * Will be called when a dependency changes.
+ */
+Watcher.prototype.update = function update () {
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
+};
+/**
+ * Scheduler job interface.
+ * Will be called by the scheduler.
+ */
+Watcher.prototype.run = function run () {
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
             if (this.user) {
-                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
             }
             else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
+                this.cb.call(this.vm, value, oldValue);
             }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    };
-    /**
-     * Add a dependency to this directive.
-     */
-    Watcher.prototype.addDep = function (dep) {
-        var id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    };
-    /**
-     * Clean up for dependency collection.
-     */
-    Watcher.prototype.cleanupDeps = function () {
-        var i = this.deps.length;
-        while (i--) {
-            var dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        var tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    };
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    Watcher.prototype.update = function () {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
         }
-        else {
-            queueWatcher(this);
-        }
-    };
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    Watcher.prototype.run = function () {
-        if (this.active) {
-            var value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                var oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    try {
-                        this.cb.call(this.vm, value, oldValue);
-                    }
-                    catch (e) {
-                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                    }
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
+    }
+};
+/**
+ * Evaluate the value of the watcher.
+ * This only gets called for lazy watchers.
+ */
+Watcher.prototype.evaluate = function evaluate () {
+    this.value = this.get();
+    this.dirty = false;
+};
+/**
+ * Depend on all deps collected by this watcher.
+ */
+Watcher.prototype.depend = function depend () {
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
+};
+/**
+ * Remove self from all dependencies' subscriber list.
+ */
+Watcher.prototype.teardown = function teardown () {
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove$2(this.vm._watchers, this);
         }
-    };
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    Watcher.prototype.evaluate = function () {
-        this.value = this.get();
-        this.dirty = false;
-    };
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    Watcher.prototype.depend = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].depend();
+            this.deps[i].removeSub(this);
         }
-    };
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    Watcher.prototype.teardown = function () {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            var i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    };
-    return Watcher;
-}());
+        this.active = false;
+    }
+};
 
 var sharedPropertyDefinition = {
     enumerable: true,
@@ -4103,7 +4085,7 @@ function initProps$1(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var _loop_1 = function (key) {
+    var loop = function ( key ) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4111,14 +4093,14 @@ function initProps$1(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                warn$2(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
             }
             defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
                     warn$2("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        ("value. Prop being mutated: \"" + key + "\""), vm);
+                        "value. Prop being mutated: \"" + key + "\"", vm);
                 }
             });
         }
@@ -4132,9 +4114,8 @@ function initProps$1(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-    for (var key in propsOptions) {
-        _loop_1(key);
-    }
+
+    for (var key in propsOptions) loop( key );
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4155,7 +4136,7 @@ function initData(vm) {
         var key = keys[i];
         if (process.env.NODE_ENV !== 'production') {
             if (methods && hasOwn(methods, key)) {
-                warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
+                warn$2(("Method \"" + key + "\" has already been defined as a data property."), vm);
             }
         }
         if (props && hasOwn(props, key)) {
@@ -4194,7 +4175,7 @@ function initComputed$1(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn$2("Getter is missing for computed property \"" + key + "\".", vm);
+            warn$2(("Getter is missing for computed property \"" + key + "\"."), vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4208,10 +4189,10 @@ function initComputed$1(vm, computed) {
         }
         else if (process.env.NODE_ENV !== 'production') {
             if (key in vm.$data) {
-                warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
+                warn$2(("The computed property \"" + key + "\" is already defined in data."), vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                warn$2(("The computed property \"" + key + "\" is already defined as a prop."), vm);
             }
         }
     }
@@ -4235,7 +4216,7 @@ function defineComputed(target, key, userDef) {
     if (process.env.NODE_ENV !== 'production' &&
         sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+            warn$2(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4264,11 +4245,11 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         if (process.env.NODE_ENV !== 'production') {
             if (typeof methods[key] !== 'function') {
-                warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                warn$2("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
+                warn$2(("Method \"" + key + "\" has already been defined as a prop."), vm);
             }
             if (key in vm && isReserved(key)) {
                 warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4340,7 +4321,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
             }
             popTarget();
         }
@@ -4359,8 +4340,8 @@ function initMixin$1(Vue) {
         var startTag, endTag;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + vm._uid;
-            endTag = "vue-perf-end:" + vm._uid;
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4396,7 +4377,7 @@ function initMixin$1(Vue) {
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure("vue " + vm._name + " init", startTag, endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4625,12 +4606,14 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name_1 = getComponentName(cachedNode.componentOptions);
-            if (name_1 && !filter(name_1)) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
@@ -4655,45 +4638,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function () {
+    created: function created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function () {
+    destroyed: function destroyed() {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function () {
-        var _this = this;
+    mounted: function mounted() {
+        var this$1 = this;
+
         this.$watch('include', function (val) {
-            pruneCache(_this, function (name) { return matches(val, name); });
+            pruneCache(this$1, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(_this, function (name) { return !matches(val, name); });
+            pruneCache(this$1, function (name) { return !matches(val, name); });
         });
     },
-    render: function () {
+    render: function render() {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name_2 = getComponentName(componentOptions);
-            var _a = this, include = _a.include, exclude = _a.exclude;
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
             if (
             // not included
-            (include && (!name_2 || !matches(include, name_2))) ||
+            (include && (!name || !matches(include, name))) ||
                 // excluded
-                (exclude && name_2 && matches(exclude, name_2))) {
+                (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var _b = this, cache = _b.cache, keys = _b.keys;
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? "::" + componentOptions.tag : '')
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4765,7 +4753,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function () {
+    get: function get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -5025,17 +5013,17 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create: function (_, vnode) {
+var ref$1 = {
+    create: function create(_, vnode) {
         registerRef(vnode);
     },
-    update: function (oldVnode, vnode) {
+    update: function update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5117,7 +5105,8 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules, nodeOps = backend.nodeOps;
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5288,8 +5277,8 @@ function createPatchFunction(backend) {
             if (process.env.NODE_ENV !== 'production') {
                 checkDuplicateKeys(children);
             }
-            for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5303,8 +5292,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-            cbs.create[i_2](emptyNode, vnode);
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5376,7 +5365,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i_3;
+            var i;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5388,16 +5377,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i_3 = vnode.componentInstance)) &&
-                isDef((i_3 = i_3._vnode)) &&
-                isDef(i_3.data)) {
-                removeAndInvokeRemoveHook(i_3, rm);
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
             }
-            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                cbs.remove[i_3](vnode, rm);
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
             }
-            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                i_3(vnode, rm);
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
             }
             else {
                 rm();
@@ -5493,12 +5482,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i_4 = 0; i_4 < children.length; i_4++) {
-            var vnode = children[i_4];
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                    warn$2(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5507,10 +5496,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i_5 = start; i_5 < end; i_5++) {
-            var c = oldCh[i_5];
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i_5; }
+                { return i; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5590,8 +5579,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                queue[i_6].data.hook.insert(queue[i_6]);
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
             }
         }
     }
@@ -5604,7 +5593,9 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag, data = vnode.data, children = vnode.children;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5654,9 +5645,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i_7 = 0; i_7 < children.length; i_7++) {
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5768,22 +5759,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                            cbs.destroy[i_8](ancestor);
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                cbs.create[i_9](emptyNode, ancestor);
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert_1 = ancestor.data.hook.insert;
-                            if (insert_1.merged) {
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                    insert_1.fns[i_10]();
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
                                 }
                             }
                         }
@@ -5898,7 +5889,7 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
@@ -5907,12 +5898,12 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
         }
     }
 }
 
-var baseModules = [ref, directives$1];
+var baseModules = [ref$1, directives$1];
 
 function updateAttrs(oldVnode, vnode) {
     var opts = vnode.componentOptions;
@@ -6001,11 +5992,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker_1 = function (e) {
+            var blocker = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker_1);
+                el.removeEventListener('input', blocker);
             };
-            el.addEventListener('input', blocker_1);
+            el.addEventListener('input', blocker);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6122,9 +6113,7 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p 
-                // find first non-whitespace prev char
-                = void 0;
+                var p = (void 0);
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -6158,18 +6147,18 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return "_f(\"" + filter + "\")(" + exp + ")";
+        return ("_f(\"" + filter + "\")(" + exp + ")");
     }
     else {
-        var name_1 = filter.slice(0, i);
+        var name = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
     }
 }
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error("[Vue compiler]: " + msg);
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -6203,7 +6192,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6338,23 +6327,25 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                ("? " + baseValueExpression + ".trim()") +
-                (": " + baseValueExpression + ")");
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: "(" + value + ")",
+        value: ("(" + value + ")"),
         expression: JSON.stringify(value),
-        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
     };
 }
 /**
@@ -6363,10 +6354,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return value + "=" + assignment;
+        return (value + "=" + assignment);
     }
     else {
-        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
     }
 }
 /**
@@ -6472,8 +6463,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN$1])) {
         // IE input[type=range] only supports `change` event
-        var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
         delete on[RANGE_TOKEN$1];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6506,17 +6497,17 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp_1 = currentFlushTimestamp;
-        var original_1 = handler;
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
         //@ts-expect-error
-        handler = original_1._wrapper = function (e) {
+        handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp_1 ||
+                e.timeStamp >= attachedTimestamp ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6525,7 +6516,7 @@ function add(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original_1.apply(this, arguments);
+                return original.apply(this, arguments);
             }
         };
     }
@@ -6757,9 +6748,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name_1 = vendorNames[i] + capName;
-        if (name_1 in emptyStyle) {
-            return name_1;
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
         }
     }
 });
@@ -6884,12 +6875,12 @@ function resolveTransition$1(def) {
 }
 var autoCssTransition$1 = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition$1 = inBrowser && !isIE9;
@@ -6941,7 +6932,10 @@ function removeTransitionClass$1(el, cls) {
     removeClass$1(el, cls);
 }
 function whenTransitionEnds$1(el, expectedType, cb) {
-    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo$1(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
@@ -7046,7 +7040,23 @@ function enter$1(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7154,7 +7164,17 @@ function leave$1(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7228,7 +7248,7 @@ function leave$1(vnode, rm) {
 function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn$2("<transition> explicit " + name + " duration is NaN - " +
@@ -7268,7 +7288,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function (vnode, rm) {
+        remove: function remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7304,7 +7324,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function (el, binding, vnode, oldVnode) {
+    inserted: function inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -7334,22 +7354,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function (el, binding, vnode) {
+    componentUpdated: function componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions_1 = el._vOptions;
-            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions_1);
+                        hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -7371,8 +7391,8 @@ function actuallySetSelected(el, binding, vm) {
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
         process.env.NODE_ENV !== 'production' &&
-            warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
-                ("expects an Array value for its binding, but got " + Object.prototype.toString
+            warn$2("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7503,12 +7523,12 @@ function resolveTransition(def) {
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -7560,7 +7580,10 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7665,7 +7688,23 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7773,7 +7812,17 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7847,7 +7896,7 @@ function leave(vnode, rm) {
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn$2("<transition> explicit " + name + " duration is NaN - " +
@@ -7887,8 +7936,9 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
         vnode = locateNode(vnode);
         var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
@@ -7903,8 +7953,10 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
+
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
@@ -7927,7 +7979,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7978,8 +8030,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key in listeners) {
-        data[camelize(key)] = listeners[key];
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
     }
     return data;
 }
@@ -8007,8 +8059,9 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function (h) {
-        var _this = this;
+    render: function render(h) {
+        var this$1 = this;
+
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -8051,7 +8104,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + this._uid + "-";
+        var id = "__transition-" + (this._uid) + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -8085,8 +8138,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    _this._leaving = false;
-                    _this.$forceUpdate();
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -8094,14 +8147,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave_1;
+                var delayedLeave;
                 var performLeave = function () {
-                    delayedLeave_1();
+                    delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave_1 = leave;
+                    delayedLeave = leave;
                 });
             }
         }
@@ -8118,21 +8171,22 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function () {
-        var _this = this;
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(_this);
+            var restoreActiveInstance = setActiveInstance(this$1);
             // force removing pass
-            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            _this._vnode = _this.kept;
+            this$1._vnode = this$1.kept;
             restoreActiveInstance();
-            update.call(_this, vnode, hydrating);
+            update.call(this$1, vnode, hydrating);
         };
     },
-    render: function (h) {
+    render: function render(h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -8149,27 +8203,27 @@ var TransitionGroup = {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     var opts = c.componentOptions;
-                    var name_1 = opts
+                    var name = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
+                    warn$2(("<transition-group> children must be keyed: <" + name + ">"));
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i = 0; i < prevChildren.length; i++) {
-                var c = prevChildren[i];
-                c.data.transition = transitionData;
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
                 // @ts-ignore
-                c.data.pos = c.elm.getBoundingClientRect();
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c.key]) {
-                    kept.push(c);
+                if (map[c$1.key]) {
+                    kept.push(c$1);
                 }
                 else {
-                    removed.push(c);
+                    removed.push(c$1);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -8177,7 +8231,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function () {
+    updated: function updated() {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -8195,25 +8249,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el_1 = c.elm;
-                var s = el_1.style;
-                addTransitionClass(el_1, moveClass);
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                    if (e && e.target !== el_1) {
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el_1.removeEventListener(transitionEndEvent, cb);
-                        el_1._moveCb = null;
-                        removeTransitionClass(el_1, moveClass);
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function (el, moveClass) {
+        hasMove: function hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -8421,7 +8475,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push("_s(" + exp + ")");
+        tokens.push(("_s(" + exp + ")"));
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8458,10 +8512,10 @@ function transformNode$1(el, options) {
 function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + el.staticClass + ",";
+        data += "staticClass:" + (el.staticClass) + ",";
     }
     if (el.classBinding) {
-        data += "class:" + el.classBinding + ",";
+        data += "class:" + (el.classBinding) + ",";
     }
     return data;
 }
@@ -8495,10 +8549,10 @@ function transformNode(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + el.staticStyle + ",";
+        data += "staticStyle:" + (el.staticStyle) + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + el.styleBinding + "),";
+        data += "style:(" + (el.styleBinding) + "),";
     }
     return data;
 }
@@ -8510,7 +8564,7 @@ var style = {
 
 var decoder;
 var he = {
-    decode: function (html) {
+    decode: function decode(html) {
         decoder = decoder || document.createElement('div');
         decoder.innerHTML = html;
         return decoder.textContent;
@@ -8536,11 +8590,11 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp("^<" + qnameCapture);
+var startTagOpen = new RegExp(("^<" + qnameCapture));
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -8561,9 +8615,7 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) {
-    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-};
+var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -8575,7 +8627,7 @@ function parseHTML(html, options) {
     var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    var _loop_1 = function () {
+    while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -8589,7 +8641,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        return "continue";
+                        continue;
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -8597,14 +8649,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        return "continue";
+                        continue;
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    return "continue";
+                    continue;
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -8612,7 +8664,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    return "continue";
+                    continue;
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -8621,10 +8673,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    return "continue";
+                    continue;
                 }
             }
-            var text = void 0, rest = void 0, next = void 0;
+            var text = (void 0), rest = (void 0), next = (void 0);
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8651,18 +8703,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength_1 = 0;
-            var stackedTag_1 = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag_1] ||
-                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-            var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength_1 = endTag.length;
-                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -8670,26 +8722,21 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag_1, index - endTagLength_1, index);
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (process.env.NODE_ENV !== 'production' &&
                 !stack.length &&
                 options.warn) {
-                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                     start: index + html.length,
                 });
             }
-            return "break";
+            break;
         }
-    };
-    while (html) {
-        var state_1 = _loop_1();
-        if (state_1 === "break")
-            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -8706,7 +8753,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end = void 0, attr = void 0;
+            var end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8790,7 +8837,7 @@ function parseHTML(html, options) {
                 if (process.env.NODE_ENV !== 'production' &&
                     (i > pos || !tagName) &&
                     options.warn) {
-                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8865,7 +8912,10 @@ function parse(template, options) {
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
     var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    maybeComponent = function (el) { return !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -8916,8 +8966,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name_1 = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -8943,7 +8993,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode = void 0;
+            var lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8953,7 +9003,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8970,7 +9020,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function (tag, attrs, unary, start, end) {
+        start: function start(tag, attrs, unary, start$1, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -8985,7 +9035,7 @@ function parse(template, options) {
             }
             if (process.env.NODE_ENV !== 'production') {
                 if (options.outputSourceRange) {
-                    element.start = start;
+                    element.start = start$1;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -9007,7 +9057,7 @@ function parse(template, options) {
                 process.env.NODE_ENV !== 'production' &&
                     warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        ("<" + tag + ">") +
+                        "<" + tag + ">" +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -9046,24 +9096,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function (tag, start, end) {
+        end: function end(tag, start, end$1) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
+                element.end = end$1;
             }
             closeElement(element);
         },
-        chars: function (text, start, end) {
+        chars: function chars(text, start, end) {
             if (!currentParent) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                             start: start,
                         });
                     }
@@ -9103,8 +9153,8 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res = void 0;
-                var child = void 0;
+                var res;
+                var child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -9131,7 +9181,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function (text, start, end) {
+        comment: function comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -9202,11 +9252,11 @@ function processKey(el) {
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent_1 = el.parent;
+                var parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent_1 &&
-                    parent_1.tag === 'transition-group') {
+                    parent &&
+                    parent.tag === 'transition-group') {
                     warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
@@ -9230,7 +9280,7 @@ function processFor(el) {
             extend(el, res);
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -9283,7 +9333,7 @@ function processIfConditions(el, parent) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -9294,7 +9344,7 @@ function findPrevElement(children) {
         }
         else {
             if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -9331,7 +9381,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -9363,41 +9413,45 @@ function processSlotContent(el) {
                             "the receiving component", el);
                     }
                 }
-                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                el.slotTarget = name_2;
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                     }
                     if (el.slotScope || el.slotTarget) {
                         warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
                         warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding);
+                            "<template> syntax when there are other named slots.", slotBinding$1);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                slotContainer_1.slotTarget = name_3;
-                slotContainer_1.slotTargetDynamic = dynamic;
-                slotContainer_1.children = el.children.filter(function (c) {
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer_1;
+                        c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -9420,7 +9474,7 @@ function getSlotName(binding) {
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: "\"" + name + "\"", dynamic: false };
+            { name: ("\"" + name + "\""), dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
@@ -9467,7 +9521,7 @@ function processAttrs(el) {
                 }
                 if (process.env.NODE_ENV !== 'production' &&
                     value.trim().length === 0) {
-                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -9481,14 +9535,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -9565,11 +9619,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret_1 = {};
+        var ret = {};
         match.forEach(function (m) {
-            ret_1[m.slice(1)] = true;
+            ret[m.slice(1)] = true;
         });
-        return ret_1;
+        return ret;
     }
 }
 function makeAttrsMap(attrs) {
@@ -9612,7 +9666,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -9637,16 +9691,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding = void 0;
+        var typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + map['v-bind'] + ").type";
+            typeBinding = "(" + (map['v-bind']) + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -9712,7 +9766,7 @@ function model(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -9739,7 +9793,7 @@ function model(el, dir, _warn) {
         return false;
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+        warn("<" + (el.tag) + " v-model=\"" + value + "\">: " +
             "v-model is not supported on this element type. " +
             "If you are working with contenteditable, it's recommended to " +
             'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
@@ -9753,25 +9807,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
         (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
         'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
         '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -9779,10 +9833,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
+        "return " + (number ? '_n(val)' : 'val') + "})";
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
+    code = code + " " + (genAssignmentCode(value, assignment));
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -9790,15 +9844,18 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     if (process.env.NODE_ENV !== 'production') {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
+        if (value$1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+            warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -9812,7 +9869,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', "(" + value + ")");
+    addProp(el, 'value', ("(" + value + ")"));
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -9821,13 +9878,13 @@ function genDefaultModel(el, value, modifiers) {
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
@@ -9911,8 +9968,8 @@ function markStatic(node) {
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                var block = node.ifConditions[i].block;
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -9944,8 +10001,8 @@ function markStaticRoots(node, isInFor) {
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                markStaticRoots(node.ifConditions[i$1].block, isInFor);
             }
         }
     }
@@ -10015,7 +10072,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -10032,19 +10089,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name_1 in events) {
-        var handlerCode = genHandler(events[name_1]);
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
         //@ts-expect-error
-        if (events[name_1] && events[name_1].dynamic) {
-            dynamicHandlers += name_1 + "," + handlerCode + ",";
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
     if (dynamicHandlers) {
-        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
     }
     else {
         return prefix + staticHandlers;
@@ -10055,7 +10112,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -10064,13 +10121,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        var _loop_1 = function (key) {
+        for (var key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -10079,18 +10136,15 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers_1 = handler.modifiers;
+                var modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
-        };
-        for (var key in handler.modifiers) {
-            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -10100,13 +10154,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? "return " + handler.value + ".apply(null, arguments)"
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
             : isFunctionExpression
-                ? "return (" + handler.value + ").apply(null, arguments)"
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
                 : isFunctionInvocation
-                    ? "return " + handler.value
+                    ? ("return " + (handler.value))
                     : handler.value;
-        return "function($event){" + code + handlerCode + "}";
+        return ("function($event){" + code + handlerCode + "}");
     }
 }
 function genKeyFilter(keys) {
@@ -10115,20 +10169,20 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&') + ")return null;"));
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return "$event.keyCode!==" + keyVal;
+        return ("$event.keyCode!==" + keyVal);
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key) + ",") +
-        (JSON.stringify(keyCode) + ",") +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
         "$event.key," +
-        ("" + JSON.stringify(keyName)) +
+        "" + (JSON.stringify(keyName)) +
         ")");
 }
 
@@ -10136,12 +10190,12 @@ function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
 function bind(el, dir) {
     el.wrapData = function (code) {
-        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
     };
 }
 
@@ -10151,24 +10205,19 @@ var baseDirectives = {
     cloak: noop,
 };
 
-var CodegenState = /** @class */ (function () {
-    function CodegenState(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        var isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = function (el) {
-            return !!el.component || !isReservedTag(el.tag);
-        };
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-    return CodegenState;
-}());
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
+};
 function generate(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
@@ -10178,7 +10227,7 @@ function generate(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: ("with(this){return " + code + "}"),
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -10206,19 +10255,17 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code = void 0;
+        var code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data = void 0;
+            var data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-            ) + (children ? "," + children : '' // children
-            ) + ")";
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -10237,9 +10284,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
     state.pre = originalPreState;
-    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
 // v-once
 function genOnce(el, state) {
@@ -10249,20 +10296,20 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent_1 = el.parent;
-        while (parent_1) {
-            if (parent_1.for) {
-                key = parent_1.key;
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
                 break;
             }
-            parent_1 = parent_1.parent;
+            parent = parent.parent;
         }
         if (!key) {
             process.env.NODE_ENV !== 'production' &&
                 state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
     }
     else {
         return genStatic(el, state);
@@ -10278,10 +10325,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
     }
     else {
-        return "" + genTernaryExp(condition.block);
+        return ("" + (genTernaryExp(condition.block)));
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -10295,21 +10342,21 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
     if (process.env.NODE_ENV !== 'production' &&
         state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        ("function(" + alias + iterator1 + iterator2 + "){") +
-        ("return " + (altGen || genElement)(el, state)) +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
         '})');
 }
 function genData(el, state) {
@@ -10321,11 +10368,11 @@ function genData(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + el.key + ",";
+        data += "key:" + (el.key) + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + el.ref + ",";
+        data += "ref:" + (el.ref) + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -10336,7 +10383,7 @@ function genData(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + el.tag + "\",";
+        data += "tag:\"" + (el.tag) + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -10344,31 +10391,31 @@ function genData(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + genProps(el.attrs) + ",";
+        data += "attrs:" + (genProps(el.attrs)) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + genProps(el.props) + ",";
+        data += "domProps:" + (genProps(el.props)) + ",";
     }
     // event handlers
     if (el.events) {
-        data += genHandlers(el.events, false) + ",";
+        data += (genHandlers(el.events, false)) + ",";
     }
     if (el.nativeEvents) {
-        data += genHandlers(el.nativeEvents, true) + ",";
+        data += (genHandlers(el.nativeEvents, true)) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + el.slotTarget + ",";
+        data += "slot:" + (el.slotTarget) + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += genScopedSlots(el, el.scopedSlots, state) + ",";
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -10382,7 +10429,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -10412,9 +10459,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -10429,9 +10476,9 @@ function genInlineTemplate(el, state) {
     }
     if (ast && ast.type === 1) {
         var inlineRenderFns = generate(ast, state.options);
-        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-            .map(function (code) { return "function(){" + code + "}"; })
-            .join(',') + "]}";
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -10456,23 +10503,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent_2 = el.parent;
-        while (parent_2) {
-            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                parent_2.for) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent_2.if) {
+            if (parent.if) {
                 needsKey = true;
             }
-            parent_2 = parent_2.parent;
+            parent = parent.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
 }
 function hash(str) {
     var hash = 5381;
@@ -10501,36 +10548,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        ("return " + (el.tag === 'template'
+        "return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}");
+            : genElement(el, state)) + "}";
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el_1 = children[0];
+        var el$1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el_1.for &&
-            el_1.tag !== 'template' &&
-            el_1.tag !== 'slot') {
-            var normalizationType_1 = checkSkip
-                ? state.maybeComponent(el_1)
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
                     ? ",1"
                     : ",0"
                 : "";
-            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
         }
-        var normalizationType = checkSkip
+        var normalizationType$1 = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen_1 = altGenNode || genNode;
-        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
     }
 }
 // determine the normalization needed for the children array.
@@ -10572,17 +10619,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return "_v(" + (text.type === 2
+    return ("_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
 }
 function genComment(comment) {
-    return "_e(" + JSON.stringify(comment.text) + ")";
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? "," + children : '');
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -10606,7 +10653,7 @@ function genSlot(el, state) {
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+    return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
 }
 function genProps(props) {
     var staticProps = "";
@@ -10615,15 +10662,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += prop.name + "," + value + ",";
+            dynamicProps += (prop.name) + "," + value + ",";
         }
         else {
-            staticProps += "\"" + prop.name + "\":" + value + ",";
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
         }
     }
-    staticProps = "{" + staticProps.slice(0, -1) + "}";
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
     if (dynamicProps) {
-        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
     }
     else {
         return staticProps;
@@ -10657,22 +10704,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name_1 in node.attrsMap) {
-            if (dirRE.test(name_1)) {
-                var value = node.attrsMap[name_1];
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name_1];
-                    if (name_1 === 'v-for') {
-                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                     }
-                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
-                    else if (onRE.test(name_1)) {
-                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                     }
                     else {
-                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
                 }
             }
@@ -10692,7 +10739,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10705,16 +10752,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function("var " + ident + "=_");
+            new Function(("var " + ident + "=_"));
         }
         catch (e) {
-            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function("return " + exp);
+        new Function(("return " + exp));
     }
     catch (e) {
         var keywordMatch = exp
@@ -10722,12 +10769,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
         }
         else {
-            warn("invalid expression: " + e.message + " in\n\n" +
-                ("    " + exp + "\n\n") +
-                ("  Raw expression: " + text.trim() + "\n"), range);
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
         }
     }
 }
@@ -10736,16 +10783,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + e.message + " in\n\n" +
-            ("    " + exp + "\n\n") +
-            ("  Raw expression: " + text.trim() + "\n"), range);
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
     }
 }
 
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if (start === void 0) { start = 0; }
-    if (end === void 0) { end = source.length; }
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -10755,18 +10803,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length_1 = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length_2 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length_2));
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length$1));
                     }
                     count += lineLength + 1;
                 }
@@ -10838,13 +10886,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                        warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
                     warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -10872,10 +10920,12 @@ function createCompileToFunctionFn(compile) {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                 warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (_a) {
-                        var err = _a.err, code = _a.code;
-                        return err.toString() + " in\n\n" + code + "\n";
-                    })
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
                         .join('\n'), vm);
             }
         }
@@ -10896,15 +10946,15 @@ function createCompilerCreator(baseCompile) {
                 if (process.env.NODE_ENV !== 'production' &&
                     options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength_1;
+                                data.start = range.start + leadingSpaceLength;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength_1;
+                                data.end = range.end + leadingSpaceLength;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -10957,7 +11007,8 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
+var ref = createCompiler(baseOptions);
+var compileToFunctions = ref.compileToFunctions;
 
 // check whether current browser encodes a char inside attribute values
 var div;
@@ -10996,7 +11047,7 @@ Vue.prototype.$mount = function (el, hydrating) {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (process.env.NODE_ENV !== 'production' && !template) {
-                        warn$2("Template element not found or is empty: " + options.template, this);
+                        warn$2(("Template element not found or is empty: " + (options.template)), this);
                     }
                 }
             }
@@ -11019,19 +11070,21 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
                 mark('compile');
             }
-            var _a = compileToFunctions(template, {
+            var ref = compileToFunctions(template, {
                 outputSourceRange: process.env.NODE_ENV !== 'production',
                 shouldDecodeNewlines: shouldDecodeNewlines,
                 shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
-            }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
+            }, this);
+            var render = ref.render;
+            var staticRenderFns = ref.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
                 mark('compile end');
-                measure("vue " + this._name + " compile", 'compile', 'compile end');
+                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
             }
         }
     }
diff --git a/dist/vue.js b/dist/vue.js
index 801e2938962..3379d276c54 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -434,7 +434,7 @@
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
   function parsePath(path) {
       if (bailRE.test(path)) {
           return;
@@ -477,7 +477,7 @@
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function () {
+              get: function get() {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
@@ -523,19 +523,20 @@
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /** @class */ (function () {
+      _Set = /*@__PURE__*/(function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function (key) {
+          Set.prototype.has = function has (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function (key) {
+          Set.prototype.add = function add (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function () {
+          Set.prototype.clear = function clear () {
               this.set = Object.create(null);
           };
+
           return Set;
       }());
   }
@@ -545,22 +546,20 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole_1 = typeof console !== 'undefined';
-      var classifyRE_1 = /(?:^|[-_])(\w)/g;
-      var classify_1 = function (str) {
-          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-      };
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
       warn$2 = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
           if (config.warnHandler) {
               config.warnHandler.call(null, msg, vm, trace);
           }
-          else if (hasConsole_1 && !config.silent) {
-              console.error("[Vue warn]: " + msg + trace);
+          else if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole_1 && !config.silent) {
+          if (hasConsole && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -583,10 +582,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-              (file && includeFile !== false ? " at " + file : ''));
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
       };
-      var repeat_1 = function (str, n) {
+      var repeat$1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -620,15 +619,13 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) {
-                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                          : formatComponentName(vm));
-                  })
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
                       .join('\n'));
           }
           else {
-              return "\n\n(found in " + formatComponentName(vm) + ")";
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
           }
       };
   }
@@ -638,37 +635,34 @@
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = /** @class */ (function () {
-      function Dep() {
-          this.id = uid$2++;
-          this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid$2++;
+      this.subs = [];
+  };
+  Dep.prototype.addSub = function addSub (sub) {
+      this.subs.push(sub);
+  };
+  Dep.prototype.removeSub = function removeSub (sub) {
+      remove$2(this.subs, sub);
+  };
+  Dep.prototype.depend = function depend () {
+      if (Dep.target) {
+          Dep.target.addDep(this);
       }
-      Dep.prototype.addSub = function (sub) {
-          this.subs.push(sub);
-      };
-      Dep.prototype.removeSub = function (sub) {
-          remove$2(this.subs, sub);
-      };
-      Dep.prototype.depend = function () {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      };
-      Dep.prototype.notify = function () {
-          // stabilize the subscriber list first
-          var subs = this.subs.slice();
-          if (!config.async) {
-              // subs aren't sorted in scheduler if not running async
-              // we need to sort them now to make sure they fire in correct
-              // order
-              subs.sort(function (a, b) { return a.id - b.id; });
-          }
-          for (var i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      };
-      return Dep;
-  }());
+  };
+  Dep.prototype.notify = function notify () {
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      if (!config.async) {
+          // subs aren't sorted in scheduler if not running async
+          // we need to sort them now to make sure they fire in correct
+          // order
+          subs.sort(function (a, b) { return a.id - b.id; });
+      }
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
+  };
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
@@ -683,45 +677,43 @@
       Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = /** @class */ (function () {
-      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      Object.defineProperty(VNode.prototype, "child", {
-          // DEPRECATED: alias for componentInstance for backwards compat.
-          /* istanbul ignore next */
-          get: function () {
-              return this.componentInstance;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return VNode;
-  }());
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
+  };
+
+  var prototypeAccessors = { child: { configurable: true } };
+  // DEPRECATED: alias for componentInstance for backwards compat.
+  /* istanbul ignore next */
+  prototypeAccessors.child.get = function () {
+      return this.componentInstance;
+  };
+
+  Object.defineProperties( VNode.prototype, prototypeAccessors );
   var createEmptyVNode = function (text) {
-      if (text === void 0) { text = ''; }
+      if ( text === void 0 ) text = '';
+
       var node = new VNode();
       node.text = text;
       node.isComment = true;
@@ -775,12 +767,9 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var arguments$1 = arguments;
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
 
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments$1[_i];
-          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -816,46 +805,43 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = /** @class */ (function () {
-      function Observer(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
           }
           else {
-              this.walk(value);
+              copyAugment(value, arrayMethods, arrayKeys);
           }
+          this.observeArray(value);
       }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      Observer.prototype.walk = function (obj) {
-          var keys = Object.keys(obj);
-          for (var i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      };
-      /**
-       * Observe a list of Array items.
-       */
-      Observer.prototype.observeArray = function (items) {
-          for (var i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      };
-      return Observer;
-  }());
+      else {
+          this.walk(value);
+      }
+  };
+  /**
+   * Walk through all properties and convert them into
+   * getter/setters. This method should only be called when
+   * value type is Object.
+   */
+  Observer.prototype.walk = function walk (obj) {
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive(obj, keys[i]);
+      }
+  };
+  /**
+   * Observe a list of Array items.
+   */
+  Observer.prototype.observeArray = function observeArray (items) {
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
+  };
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -965,7 +951,7 @@
    */
   function set(target, key, val) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+          warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -996,7 +982,7 @@
    */
   function del(target, key) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn$2("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+          warn$2(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.splice(key, 1);
@@ -1023,7 +1009,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1198,14 +1184,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key_1 in childVal) {
-          var parent_1 = ret[key_1];
-          var child = childVal[key_1];
-          if (parent_1 && !Array.isArray(parent_1)) {
-              parent_1 = [parent_1];
-          }
-          ret[key_1] = parent_1
-              ? parent_1.concat(child)
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1243,7 +1229,7 @@
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
           warn$2('Invalid component name: "' +
               name +
               '". Component names ' +
@@ -1287,7 +1273,7 @@
       }
       else {
           warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-              ("but got " + toRawType(props) + "."), vm);
+              "but got " + (toRawType(props)) + ".", vm);
       }
       options.props = res;
   }
@@ -1314,7 +1300,7 @@
       }
       else {
           warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-              ("but got " + toRawType(inject) + "."), vm);
+              "but got " + (toRawType(inject)) + ".", vm);
       }
   }
   /**
@@ -1334,7 +1320,7 @@
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
           warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-              ("but got " + toRawType(value) + "."), vm);
+              "but got " + (toRawType(value)) + ".", vm);
       }
   }
   /**
@@ -1570,7 +1556,7 @@
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
       var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          (" Expected " + expectedTypes.map(capitalize).join(', '));
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
       var expectedType = expectedTypes[0];
       var receivedType = toRawType(value);
       // check if we need to specify expected value
@@ -1578,24 +1564,24 @@
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + styleValue(value, expectedType);
+          message += " with value " + (styleValue(value, expectedType));
       }
       message += ", got " + receivedType + " ";
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + styleValue(value, receivedType) + ".";
+          message += "with value " + (styleValue(value, receivedType)) + ".";
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return "\"" + value + "\"";
+          return ("\"" + value + "\"");
       }
       else if (type === 'Number') {
-          return "" + Number(value);
+          return ("" + (Number(value)));
       }
       else {
-          return "" + value;
+          return ("" + value);
       }
   }
   var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1603,12 +1589,9 @@
       return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-      var arguments$1 = arguments;
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments$1[_i];
-      }
       return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
@@ -1674,7 +1657,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
+          warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1717,9 +1700,9 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p_1 = Promise.resolve();
+      var p = Promise.resolve();
       timerFunc = function () {
-          p_1.then(flushCallbacks);
+          p.then(flushCallbacks);
           // In problematic UIWebViews, Promise.then doesn't completely break, but
           // it can get stuck in a weird state where callbacks are pushed into the
           // microtask queue but the queue isn't being flushed, until the browser
@@ -1738,15 +1721,15 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter_1 = 1;
+      var counter = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode_1 = document.createTextNode(String(counter_1));
-      observer.observe(textNode_1, {
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
           characterData: true,
       });
       timerFunc = function () {
-          counter_1 = (counter_1 + 1) % 2;
-          textNode_1.data = String(counter_1);
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
       };
       isUsingMicroTask = true;
   }
@@ -1794,18 +1777,18 @@
   var mark;
   var measure;
   {
-      var perf_1 = inBrowser && window.performance;
+      var perf = inBrowser && window.performance;
       /* istanbul ignore if */
-      if (perf_1 &&
-          perf_1.mark &&
-          perf_1.measure &&
-          perf_1.clearMarks &&
-          perf_1.clearMeasures) {
-          mark = function (tag) { return perf_1.mark(tag); };
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = function (tag) { return perf.mark(tag); };
           measure = function (name, startTag, endTag) {
-              perf_1.measure(name, startTag, endTag);
-              perf_1.clearMarks(startTag);
-              perf_1.clearMarks(endTag);
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
               // perf.clearMeasures(name)
           };
       }
@@ -1814,31 +1797,31 @@
   /* not type checking this file because flow doesn't play well with Proxy */
   var initProxy;
   {
-      var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var warnNonPresent_1 = function (target, key) {
+      var warnNonPresent = function (target, key) {
           warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
               'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
-      var warnReservedPrefix_1 = function (target, key) {
+      var warnReservedPrefix = function (target, key) {
           warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
               'See: https://vuejs.org/v2/api/#data', target);
       };
-      var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy_1) {
-          var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function (target, key, value) {
-                  if (isBuiltInModifier_1(key)) {
-                      warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                       return false;
                   }
                   else {
@@ -1848,38 +1831,38 @@
               },
           });
       }
-      var hasHandler_1 = {
-          has: function (target, key) {
+      var hasHandler = {
+          has: function has(target, key) {
               var has = key in target;
-              var isAllowed = allowedGlobals_1(key) ||
+              var isAllowed = allowedGlobals(key) ||
                   (typeof key === 'string' &&
                       key.charAt(0) === '_' &&
                       !(key in target.$data));
               if (!has && !isAllowed) {
                   if (key in target.$data)
-                      { warnReservedPrefix_1(target, key); }
+                      { warnReservedPrefix(target, key); }
                   else
-                      { warnNonPresent_1(target, key); }
+                      { warnNonPresent(target, key); }
               }
               return has || !isAllowed;
           },
       };
-      var getHandler_1 = {
-          get: function (target, key) {
+      var getHandler = {
+          get: function get(target, key) {
               if (typeof key === 'string' && !(key in target)) {
                   if (key in target.$data)
-                      { warnReservedPrefix_1(target, key); }
+                      { warnReservedPrefix(target, key); }
                   else
-                      { warnNonPresent_1(target, key); }
+                      { warnNonPresent(target, key); }
               }
               return target[key];
           },
       };
       initProxy = function initProxy(vm) {
-          if (hasProxy_1) {
+          if (hasProxy) {
               // determine which proxy handler to use
               var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
               vm._renderProxy = new Proxy(vm, handlers);
           }
           else {
@@ -1966,7 +1949,7 @@
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+              warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -2031,7 +2014,8 @@
           return;
       }
       var res = {};
-      var attrs = data.attrs, props = data.props;
+      var attrs = data.attrs;
+      var props = data.props;
       if (isDef(attrs) || isDef(props)) {
           for (var key in propOptions) {
               var altKey = hyphenate(key);
@@ -2041,11 +2025,11 @@
                       tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                           (formatComponentName(
                           // @ts-ignore
-                          tag || Ctor) + ", but the declared prop name is") +
-                          (" \"" + key + "\". ") +
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
                           "Note that HTML attributes are case-insensitive and camelCased " +
                           "props need to use their kebab-case equivalents when using in-DOM " +
-                          ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -2119,7 +2103,7 @@
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2180,7 +2164,7 @@
                   defineReactive(vm, key, result[key], function () {
                       warn$2("Avoid mutating an injected value directly since the changes will be " +
                           "overwritten whenever the provided component re-renders. " +
-                          ("injection being mutated: \"" + key + "\""), vm);
+                          "injection being mutated: \"" + key + "\"", vm);
                   });
               }
           });
@@ -2217,7 +2201,7 @@
                   }
                   else {
                       // @ts-ignore
-                      warn$2("Injection \"" + key + "\" not found", vm);
+                      warn$2(("Injection \"" + key + "\" not found"), vm);
                   }
               }
           }
@@ -2245,8 +2229,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name_1 = data.slot;
-              var slot = slots[name_1] || (slots[name_1] = []);
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -2259,9 +2243,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name_2 in slots) {
-          if (slots[name_2].every(isWhitespace)) {
-              delete slots[name_2];
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
           }
       }
       return slots;
@@ -2294,16 +2278,16 @@
       }
       else {
           res = {};
-          for (var key_1 in slots) {
-              if (slots[key_1] && key_1[0] !== '$') {
-                  res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key_2 in normalSlots) {
-          if (!(key_2 in res)) {
-              res[key_2] = proxyNormalSlot(normalSlots, key_2);
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2460,8 +2444,8 @@
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash = void 0;
-              var _loop_1 = function (key) {
+              var hash;
+              var loop = function ( key ) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
@@ -2478,15 +2462,14 @@
                       hash[key] = value[key];
                       if (isSync) {
                           var on = data.on || (data.on = {});
-                          on["update:" + key] = function ($event) {
+                          on[("update:" + key)] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
               };
-              for (var key in value) {
-                  _loop_1(key);
-              }
+
+              for (var key in value) loop( key );
           }
       }
       return data;
@@ -2506,7 +2489,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic$1(tree, "__static__" + index, false);
+      markStatic$1(tree, ("__static__" + index), false);
       return tree;
   }
   /**
@@ -2514,14 +2497,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic$1(tree, "__once__" + index + (key ? "_" + key : ""), true);
+      markStatic$1(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
       return tree;
   }
   function markStatic$1(tree, key, isOnce) {
       if (Array.isArray(tree)) {
           for (var i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], key + "_" + i, isOnce);
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
               }
           }
       }
@@ -2587,7 +2570,7 @@
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+              warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
           }
       }
       return baseObj;
@@ -2620,7 +2603,8 @@
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var _this = this;
+      var this$1 = this;
+
       var options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
@@ -2647,14 +2631,14 @@
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
       this.slots = function () {
-          if (!_this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
           }
-          return _this.$slots;
+          return this$1.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function () {
+          get: function get() {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -2677,9 +2661,7 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) {
-              return createElement$1(contextVm, a, b, c, d, needNormalization);
-          };
+          this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2735,7 +2717,7 @@
 
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function (vnode, hydrating) {
+      init: function init(vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
@@ -2748,7 +2730,7 @@
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function (oldVnode, vnode) {
+      prepatch: function prepatch(oldVnode, vnode) {
           var options = vnode.componentOptions;
           var child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
@@ -2757,8 +2739,9 @@
           options.children // new children
           );
       },
-      insert: function (vnode) {
-          var context = vnode.context, componentInstance = vnode.componentInstance;
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
               callHook$1(componentInstance, 'mounted');
@@ -2777,7 +2760,7 @@
               }
           }
       },
-      destroy: function (vnode) {
+      destroy: function destroy(vnode) {
           var componentInstance = vnode.componentInstance;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
@@ -2803,7 +2786,7 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn$2("Invalid Component definition: " + String(Ctor), context);
+              warn$2(("Invalid Component definition: " + (String(Ctor))), context);
           }
           return;
       }
@@ -2861,7 +2844,7 @@
       var name = Ctor.options.name || tag;
       var vnode = new VNode(
       // @ts-expect-error
-      "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
       // @ts-expect-error
       { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
       return vnode;
@@ -2943,7 +2926,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -2978,14 +2961,14 @@
       }
       var vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor = void 0;
+          var Ctor;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if (config.isReservedTag(tag)) {
               // platform built-in elements
               if (isDef(data) &&
                   isDef(data.nativeOn) &&
                   data.tag !== 'component') {
-                  warn$2("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                  warn$2(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
               }
               vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
           }
@@ -3088,7 +3071,9 @@
       };
       Vue.prototype._render = function () {
           var vm = this;
-          var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+          var ref = vm.$options;
+          var render = ref.render;
+          var _parentVnode = ref._parentVnode;
           if (_parentVnode) {
               vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
@@ -3171,24 +3156,24 @@
           return factory.loadingComp;
       }
       if (owner && !isDef(factory.owners)) {
-          var owners_1 = (factory.owners = [owner]);
-          var sync_1 = true;
-          var timerLoading_1 = null;
-          var timerTimeout_1 = null;
-          owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-          var forceRender_1 = function (renderCompleted) {
-              for (var i = 0, l = owners_1.length; i < l; i++) {
-                  owners_1[i].$forceUpdate();
+          var owners = (factory.owners = [owner]);
+          var sync = true;
+          var timerLoading = null;
+          var timerTimeout = null;
+          owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+          var forceRender = function (renderCompleted) {
+              for (var i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
               }
               if (renderCompleted) {
-                  owners_1.length = 0;
-                  if (timerLoading_1 !== null) {
-                      clearTimeout(timerLoading_1);
-                      timerLoading_1 = null;
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
                   }
-                  if (timerTimeout_1 !== null) {
-                      clearTimeout(timerTimeout_1);
-                      timerTimeout_1 = null;
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
                   }
               }
           };
@@ -3197,63 +3182,63 @@
               factory.resolved = ensureCtor(res, baseCtor);
               // invoke callbacks only if this is not a synchronous resolve
               // (async resolves are shimmed as synchronous during SSR)
-              if (!sync_1) {
-                  forceRender_1(true);
+              if (!sync) {
+                  forceRender(true);
               }
               else {
-                  owners_1.length = 0;
+                  owners.length = 0;
               }
           });
-          var reject_1 = once(function (reason) {
-              warn$2("Failed to resolve async component: " + String(factory) +
-                      (reason ? "\nReason: " + reason : ''));
+          var reject = once(function (reason) {
+              warn$2("Failed to resolve async component: " + (String(factory)) +
+                      (reason ? ("\nReason: " + reason) : ''));
               if (isDef(factory.errorComp)) {
                   factory.error = true;
-                  forceRender_1(true);
+                  forceRender(true);
               }
           });
-          var res_1 = factory(resolve, reject_1);
-          if (isObject(res_1)) {
-              if (isPromise(res_1)) {
+          var res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
                   // () => Promise
                   if (isUndef(factory.resolved)) {
-                      res_1.then(resolve, reject_1);
+                      res.then(resolve, reject);
                   }
               }
-              else if (isPromise(res_1.component)) {
-                  res_1.component.then(resolve, reject_1);
-                  if (isDef(res_1.error)) {
-                      factory.errorComp = ensureCtor(res_1.error, baseCtor);
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
                   }
-                  if (isDef(res_1.loading)) {
-                      factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                      if (res_1.delay === 0) {
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
                           factory.loading = true;
                       }
                       else {
                           // @ts-expect-error NodeJS timeout type
-                          timerLoading_1 = setTimeout(function () {
-                              timerLoading_1 = null;
+                          timerLoading = setTimeout(function () {
+                              timerLoading = null;
                               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                   factory.loading = true;
-                                  forceRender_1(false);
+                                  forceRender(false);
                               }
-                          }, res_1.delay || 200);
+                          }, res.delay || 200);
                       }
                   }
-                  if (isDef(res_1.timeout)) {
+                  if (isDef(res.timeout)) {
                       // @ts-expect-error NodeJS timeout type
-                      timerTimeout_1 = setTimeout(function () {
-                          timerTimeout_1 = null;
+                      timerTimeout = setTimeout(function () {
+                          timerTimeout = null;
                           if (isUndef(factory.resolved)) {
-                              reject_1("timeout (" + res_1.timeout + "ms)"
+                              reject(("timeout (" + (res.timeout) + "ms)")
                                   );
                           }
-                      }, res_1.timeout);
+                      }, res.timeout);
                   }
               }
           }
-          sync_1 = false;
+          sync = false;
           // return in case resolved synchronously
           return factory.loading ? factory.loadingComp : factory.resolved;
       }
@@ -3343,8 +3328,8 @@
           }
           // array of events
           if (Array.isArray(event)) {
-              for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                  vm.$off(event[i_1], fn);
+              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                  vm.$off(event[i$1], fn);
               }
               return vm;
           }
@@ -3375,10 +3360,10 @@
               var lowerCaseEvent = event.toLowerCase();
               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                   tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
                       "Note that HTML attributes are case-insensitive and you cannot use " +
                       "v-on to listen to camelCase events when using in-DOM templates. " +
-                      ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
               }
           }
           var cbs = vm._events[event];
@@ -3539,11 +3524,11 @@
               mark(startTag);
               var vnode = vm._render();
               mark(endTag);
-              measure("vue " + name + " render", startTag, endTag);
+              measure(("vue " + name + " render"), startTag, endTag);
               mark(startTag);
               vm._update(vnode, hydrating);
               mark(endTag);
-              measure("vue " + name + " patch", startTag, endTag);
+              measure(("vue " + name + " patch"), startTag, endTag);
           };
       }
       else {
@@ -3555,7 +3540,7 @@
       // since the watcher's initial patch may call $forceUpdate (e.g. inside child
       // component's mounted hook), which relies on vm._watcher being already defined
       new Watcher(vm, updateComponent, noop, {
-          before: function () {
+          before: function before() {
               if (vm._isMounted && !vm._isDestroyed) {
                   callHook$1(vm, 'beforeUpdate');
               }
@@ -3724,15 +3709,15 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance_1 = window.performance;
-      if (performance_1 &&
-          typeof performance_1.now === 'function' &&
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
           // if the event timestamp, although evaluated AFTER the Date.now(), is
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance_1.now(); };
+          getNow = function () { return performance.now(); };
       }
   }
   /**
@@ -3767,7 +3752,7 @@
               if (circular[id] > MAX_UPDATE_COUNT) {
                   warn$2('You may have an infinite update loop ' +
                       (watcher.user
-                          ? "in watcher with expression \"" + watcher.expression + "\""
+                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
                           : "in a component render function."), watcher.vm);
                   break;
               }
@@ -3851,194 +3836,191 @@
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = /** @class */ (function () {
-      function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-          this.vm = vm;
-          if (isRenderWatcher) {
-              vm._watcher = this;
-          }
-          vm._watchers.push(this);
-          // options
-          if (options) {
-              this.deep = !!options.deep;
-              this.user = !!options.user;
-              this.lazy = !!options.lazy;
-              this.sync = !!options.sync;
-              this.before = options.before;
+  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+      this.vm = vm;
+      if (isRenderWatcher) {
+          vm._watcher = this;
+      }
+      vm._watchers.push(this);
+      // options
+      if (options) {
+          this.deep = !!options.deep;
+          this.user = !!options.user;
+          this.lazy = !!options.lazy;
+          this.sync = !!options.sync;
+          this.before = options.before;
+      }
+      else {
+          this.deep = this.user = this.lazy = this.sync = false;
+      }
+      this.cb = cb;
+      this.id = ++uid$1; // uid for batching
+      this.active = true;
+      this.dirty = this.lazy; // for lazy watchers
+      this.deps = [];
+      this.newDeps = [];
+      this.depIds = new _Set();
+      this.newDepIds = new _Set();
+      this.expression =
+          expOrFn.toString() ;
+      // parse expression for getter
+      if (typeof expOrFn === 'function') {
+          this.getter = expOrFn;
+      }
+      else {
+          this.getter = parsePath(expOrFn);
+          if (!this.getter) {
+              this.getter = noop;
+              warn$2("Failed watching path: \"" + expOrFn + "\" " +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
           }
-          else {
-              this.deep = this.user = this.lazy = this.sync = false;
-          }
-          this.cb = cb;
-          this.id = ++uid$1; // uid for batching
-          this.active = true;
-          this.dirty = this.lazy; // for lazy watchers
-          this.deps = [];
-          this.newDeps = [];
-          this.depIds = new _Set();
-          this.newDepIds = new _Set();
-          this.expression =
-              expOrFn.toString() ;
-          // parse expression for getter
-          if (typeof expOrFn === 'function') {
-              this.getter = expOrFn;
+      }
+      this.value = this.lazy ? undefined : this.get();
+  };
+  /**
+   * Evaluate the getter, and re-collect dependencies.
+   */
+  Watcher.prototype.get = function get () {
+      pushTarget(this);
+      var value;
+      var vm = this.vm;
+      try {
+          value = this.getter.call(vm, vm);
+      }
+      catch (e) {
+          if (this.user) {
+              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
           }
           else {
-              this.getter = parsePath(expOrFn);
-              if (!this.getter) {
-                  this.getter = noop;
-                  warn$2("Failed watching path: \"" + expOrFn + "\" " +
-                          'Watcher only accepts simple dot-delimited paths. ' +
-                          'For full control, use a function instead.', vm);
-              }
+              throw e;
           }
-          this.value = this.lazy ? undefined : this.get();
       }
-      /**
-       * Evaluate the getter, and re-collect dependencies.
-       */
-      Watcher.prototype.get = function () {
-          pushTarget(this);
-          var value;
-          var vm = this.vm;
-          try {
-              value = this.getter.call(vm, vm);
+      finally {
+          // "touch" every property so they are all tracked as
+          // dependencies for deep watching
+          if (this.deep) {
+              traverse(value);
           }
-          catch (e) {
+          popTarget();
+          this.cleanupDeps();
+      }
+      return value;
+  };
+  /**
+   * Add a dependency to this directive.
+   */
+  Watcher.prototype.addDep = function addDep (dep) {
+      var id = dep.id;
+      if (!this.newDepIds.has(id)) {
+          this.newDepIds.add(id);
+          this.newDeps.push(dep);
+          if (!this.depIds.has(id)) {
+              dep.addSub(this);
+          }
+      }
+  };
+  /**
+   * Clean up for dependency collection.
+   */
+  Watcher.prototype.cleanupDeps = function cleanupDeps () {
+      var i = this.deps.length;
+      while (i--) {
+          var dep = this.deps[i];
+          if (!this.newDepIds.has(dep.id)) {
+              dep.removeSub(this);
+          }
+      }
+      var tmp = this.depIds;
+      this.depIds = this.newDepIds;
+      this.newDepIds = tmp;
+      this.newDepIds.clear();
+      tmp = this.deps;
+      this.deps = this.newDeps;
+      this.newDeps = tmp;
+      this.newDeps.length = 0;
+  };
+  /**
+   * Subscriber interface.
+   * Will be called when a dependency changes.
+   */
+  Watcher.prototype.update = function update () {
+      /* istanbul ignore else */
+      if (this.lazy) {
+          this.dirty = true;
+      }
+      else if (this.sync) {
+          this.run();
+      }
+      else {
+          queueWatcher(this);
+      }
+  };
+  /**
+   * Scheduler job interface.
+   * Will be called by the scheduler.
+   */
+  Watcher.prototype.run = function run () {
+      if (this.active) {
+          var value = this.get();
+          if (value !== this.value ||
+              // Deep watchers and watchers on Object/Arrays should fire even
+              // when the value is the same, because the value may
+              // have mutated.
+              isObject(value) ||
+              this.deep) {
+              // set new value
+              var oldValue = this.value;
+              this.value = value;
               if (this.user) {
-                  handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                  try {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+                  catch (e) {
+                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  }
               }
               else {
-                  throw e;
+                  this.cb.call(this.vm, value, oldValue);
               }
           }
-          finally {
-              // "touch" every property so they are all tracked as
-              // dependencies for deep watching
-              if (this.deep) {
-                  traverse(value);
-              }
-              popTarget();
-              this.cleanupDeps();
-          }
-          return value;
-      };
-      /**
-       * Add a dependency to this directive.
-       */
-      Watcher.prototype.addDep = function (dep) {
-          var id = dep.id;
-          if (!this.newDepIds.has(id)) {
-              this.newDepIds.add(id);
-              this.newDeps.push(dep);
-              if (!this.depIds.has(id)) {
-                  dep.addSub(this);
-              }
-          }
-      };
-      /**
-       * Clean up for dependency collection.
-       */
-      Watcher.prototype.cleanupDeps = function () {
-          var i = this.deps.length;
-          while (i--) {
-              var dep = this.deps[i];
-              if (!this.newDepIds.has(dep.id)) {
-                  dep.removeSub(this);
-              }
-          }
-          var tmp = this.depIds;
-          this.depIds = this.newDepIds;
-          this.newDepIds = tmp;
-          this.newDepIds.clear();
-          tmp = this.deps;
-          this.deps = this.newDeps;
-          this.newDeps = tmp;
-          this.newDeps.length = 0;
-      };
-      /**
-       * Subscriber interface.
-       * Will be called when a dependency changes.
-       */
-      Watcher.prototype.update = function () {
-          /* istanbul ignore else */
-          if (this.lazy) {
-              this.dirty = true;
-          }
-          else if (this.sync) {
-              this.run();
-          }
-          else {
-              queueWatcher(this);
-          }
-      };
-      /**
-       * Scheduler job interface.
-       * Will be called by the scheduler.
-       */
-      Watcher.prototype.run = function () {
-          if (this.active) {
-              var value = this.get();
-              if (value !== this.value ||
-                  // Deep watchers and watchers on Object/Arrays should fire even
-                  // when the value is the same, because the value may
-                  // have mutated.
-                  isObject(value) ||
-                  this.deep) {
-                  // set new value
-                  var oldValue = this.value;
-                  this.value = value;
-                  if (this.user) {
-                      try {
-                          this.cb.call(this.vm, value, oldValue);
-                      }
-                      catch (e) {
-                          handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                      }
-                  }
-                  else {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-              }
+      }
+  };
+  /**
+   * Evaluate the value of the watcher.
+   * This only gets called for lazy watchers.
+   */
+  Watcher.prototype.evaluate = function evaluate () {
+      this.value = this.get();
+      this.dirty = false;
+  };
+  /**
+   * Depend on all deps collected by this watcher.
+   */
+  Watcher.prototype.depend = function depend () {
+      var i = this.deps.length;
+      while (i--) {
+          this.deps[i].depend();
+      }
+  };
+  /**
+   * Remove self from all dependencies' subscriber list.
+   */
+  Watcher.prototype.teardown = function teardown () {
+      if (this.active) {
+          // remove self from vm's watcher list
+          // this is a somewhat expensive operation so we skip it
+          // if the vm is being destroyed.
+          if (!this.vm._isBeingDestroyed) {
+              remove$2(this.vm._watchers, this);
           }
-      };
-      /**
-       * Evaluate the value of the watcher.
-       * This only gets called for lazy watchers.
-       */
-      Watcher.prototype.evaluate = function () {
-          this.value = this.get();
-          this.dirty = false;
-      };
-      /**
-       * Depend on all deps collected by this watcher.
-       */
-      Watcher.prototype.depend = function () {
           var i = this.deps.length;
           while (i--) {
-              this.deps[i].depend();
+              this.deps[i].removeSub(this);
           }
-      };
-      /**
-       * Remove self from all dependencies' subscriber list.
-       */
-      Watcher.prototype.teardown = function () {
-          if (this.active) {
-              // remove self from vm's watcher list
-              // this is a somewhat expensive operation so we skip it
-              // if the vm is being destroyed.
-              if (!this.vm._isBeingDestroyed) {
-                  remove$2(this.vm._watchers, this);
-              }
-              var i = this.deps.length;
-              while (i--) {
-                  this.deps[i].removeSub(this);
-              }
-              this.active = false;
-          }
-      };
-      return Watcher;
-  }());
+          this.active = false;
+      }
+  };
 
   var sharedPropertyDefinition = {
       enumerable: true,
@@ -4085,7 +4067,7 @@
       if (!isRoot) {
           toggleObserving(false);
       }
-      var _loop_1 = function (key) {
+      var loop = function ( key ) {
           keys.push(key);
           var value = validateProp(key, propsOptions, propsData, vm);
           /* istanbul ignore else */
@@ -4093,14 +4075,14 @@
               var hyphenatedKey = hyphenate(key);
               if (isReservedAttribute(hyphenatedKey) ||
                   config.isReservedAttr(hyphenatedKey)) {
-                  warn$2("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                  warn$2(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
               }
               defineReactive(props, key, value, function () {
                   if (!isRoot && !isUpdatingChildComponent) {
                       warn$2("Avoid mutating a prop directly since the value will be " +
                           "overwritten whenever the parent component re-renders. " +
                           "Instead, use a data or computed property based on the prop's " +
-                          ("value. Prop being mutated: \"" + key + "\""), vm);
+                          "value. Prop being mutated: \"" + key + "\"", vm);
                   }
               });
           }
@@ -4111,9 +4093,8 @@
               proxy(vm, "_props", key);
           }
       };
-      for (var key in propsOptions) {
-          _loop_1(key);
-      }
+
+      for (var key in propsOptions) loop( key );
       toggleObserving(true);
   }
   function initData(vm) {
@@ -4133,7 +4114,7 @@
           var key = keys[i];
           {
               if (methods && hasOwn(methods, key)) {
-                  warn$2("Method \"" + key + "\" has already been defined as a data property.", vm);
+                  warn$2(("Method \"" + key + "\" has already been defined as a data property."), vm);
               }
           }
           if (props && hasOwn(props, key)) {
@@ -4171,7 +4152,7 @@
           var userDef = computed[key];
           var getter = typeof userDef === 'function' ? userDef : userDef.get;
           if (getter == null) {
-              warn$2("Getter is missing for computed property \"" + key + "\".", vm);
+              warn$2(("Getter is missing for computed property \"" + key + "\"."), vm);
           }
           if (!isSSR) {
               // create internal watcher for the computed property.
@@ -4185,10 +4166,10 @@
           }
           else {
               if (key in vm.$data) {
-                  warn$2("The computed property \"" + key + "\" is already defined in data.", vm);
+                  warn$2(("The computed property \"" + key + "\" is already defined in data."), vm);
               }
               else if (vm.$options.props && key in vm.$options.props) {
-                  warn$2("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                  warn$2(("The computed property \"" + key + "\" is already defined as a prop."), vm);
               }
           }
       }
@@ -4211,7 +4192,7 @@
       }
       if (sharedPropertyDefinition.set === noop) {
           sharedPropertyDefinition.set = function () {
-              warn$2("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+              warn$2(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
           };
       }
       Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4240,11 +4221,11 @@
       for (var key in methods) {
           {
               if (typeof methods[key] !== 'function') {
-                  warn$2("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                  warn$2("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
                       "Did you reference the function correctly?", vm);
               }
               if (props && hasOwn(props, key)) {
-                  warn$2("Method \"" + key + "\" has already been defined as a prop.", vm);
+                  warn$2(("Method \"" + key + "\" has already been defined as a prop."), vm);
               }
               if (key in vm && isReserved(key)) {
                   warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4316,7 +4297,7 @@
                   cb.call(vm, watcher.value);
               }
               catch (error) {
-                  handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
               }
               popTarget();
           }
@@ -4335,8 +4316,8 @@
           var startTag, endTag;
           /* istanbul ignore if */
           if (config.performance && mark) {
-              startTag = "vue-perf-start:" + vm._uid;
-              endTag = "vue-perf-end:" + vm._uid;
+              startTag = "vue-perf-start:" + (vm._uid);
+              endTag = "vue-perf-end:" + (vm._uid);
               mark(startTag);
           }
           // a flag to avoid this being observed
@@ -4369,7 +4350,7 @@
           if (config.performance && mark) {
               vm._name = formatComponentName(vm, false);
               mark(endTag);
-              measure("vue " + vm._name + " init", startTag, endTag);
+              measure(("vue " + (vm._name) + " init"), startTag, endTag);
           }
           if (vm.$options.el) {
               vm.$mount(vm.$options.el);
@@ -4598,12 +4579,14 @@
       return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+      var cache = keepAliveInstance.cache;
+      var keys = keepAliveInstance.keys;
+      var _vnode = keepAliveInstance._vnode;
       for (var key in cache) {
           var cachedNode = cache[key];
           if (cachedNode) {
-              var name_1 = getComponentName(cachedNode.componentOptions);
-              if (name_1 && !filter(name_1)) {
+              var name = getComponentName(cachedNode.componentOptions);
+              if (name && !filter(name)) {
                   pruneCacheEntry(cache, key, keys, _vnode);
               }
           }
@@ -4628,45 +4611,50 @@
           exclude: patternTypes,
           max: [String, Number],
       },
-      created: function () {
+      created: function created() {
           this.cache = Object.create(null);
           this.keys = [];
       },
-      destroyed: function () {
+      destroyed: function destroyed() {
           for (var key in this.cache) {
               pruneCacheEntry(this.cache, key, this.keys);
           }
       },
-      mounted: function () {
-          var _this = this;
+      mounted: function mounted() {
+          var this$1 = this;
+
           this.$watch('include', function (val) {
-              pruneCache(_this, function (name) { return matches(val, name); });
+              pruneCache(this$1, function (name) { return matches(val, name); });
           });
           this.$watch('exclude', function (val) {
-              pruneCache(_this, function (name) { return !matches(val, name); });
+              pruneCache(this$1, function (name) { return !matches(val, name); });
           });
       },
-      render: function () {
+      render: function render() {
           var slot = this.$slots.default;
           var vnode = getFirstComponentChild(slot);
           var componentOptions = vnode && vnode.componentOptions;
           if (componentOptions) {
               // check pattern
-              var name_2 = getComponentName(componentOptions);
-              var _a = this, include = _a.include, exclude = _a.exclude;
+              var name = getComponentName(componentOptions);
+              var ref = this;
+              var include = ref.include;
+              var exclude = ref.exclude;
               if (
               // not included
-              (include && (!name_2 || !matches(include, name_2))) ||
+              (include && (!name || !matches(include, name))) ||
                   // excluded
-                  (exclude && name_2 && matches(exclude, name_2))) {
+                  (exclude && name && matches(exclude, name))) {
                   return vnode;
               }
-              var _b = this, cache = _b.cache, keys = _b.keys;
+              var ref$1 = this;
+              var cache = ref$1.cache;
+              var keys = ref$1.keys;
               var key = vnode.key == null
                   ? // same constructor may get registered as different local components
                       // so cid alone is not enough (#3269)
                       componentOptions.Ctor.cid +
-                          (componentOptions.tag ? "::" + componentOptions.tag : '')
+                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
                   : vnode.key;
               if (cache[key]) {
                   vnode.componentInstance = cache[key].componentInstance;
@@ -4738,7 +4726,7 @@
       get: isServerRendering,
   });
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function () {
+      get: function get() {
           /* istanbul ignore next */
           return this.$vnode && this.$vnode.ssrContext;
       },
@@ -4997,17 +4985,17 @@
     setStyleScope: setStyleScope
   });
 
-  var ref = {
-      create: function (_, vnode) {
+  var ref$1 = {
+      create: function create(_, vnode) {
           registerRef(vnode);
       },
-      update: function (oldVnode, vnode) {
+      update: function update(oldVnode, vnode) {
           if (oldVnode.data.ref !== vnode.data.ref) {
               registerRef(oldVnode, true);
               registerRef(vnode);
           }
       },
-      destroy: function (vnode) {
+      destroy: function destroy(vnode) {
           registerRef(vnode, true);
       },
   };
@@ -5089,7 +5077,8 @@
   function createPatchFunction(backend) {
       var i, j;
       var cbs = {};
-      var modules = backend.modules, nodeOps = backend.nodeOps;
+      var modules = backend.modules;
+      var nodeOps = backend.nodeOps;
       for (i = 0; i < hooks.length; ++i) {
           cbs[hooks[i]] = [];
           for (j = 0; j < modules.length; ++j) {
@@ -5260,8 +5249,8 @@
               {
                   checkDuplicateKeys(children);
               }
-              for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                  createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+              for (var i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
               }
           }
           else if (isPrimitive(vnode.text)) {
@@ -5275,8 +5264,8 @@
           return isDef(vnode.tag);
       }
       function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-              cbs.create[i_2](emptyNode, vnode);
+          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+              cbs.create[i$1](emptyNode, vnode);
           }
           i = vnode.data.hook; // Reuse variable
           if (isDef(i)) {
@@ -5348,7 +5337,7 @@
       }
       function removeAndInvokeRemoveHook(vnode, rm) {
           if (isDef(rm) || isDef(vnode.data)) {
-              var i_3;
+              var i;
               var listeners = cbs.remove.length + 1;
               if (isDef(rm)) {
                   // we have a recursively passed down rm callback
@@ -5360,16 +5349,16 @@
                   rm = createRmCb(vnode.elm, listeners);
               }
               // recursively invoke hooks on child component root node
-              if (isDef((i_3 = vnode.componentInstance)) &&
-                  isDef((i_3 = i_3._vnode)) &&
-                  isDef(i_3.data)) {
-                  removeAndInvokeRemoveHook(i_3, rm);
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
               }
-              for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                  cbs.remove[i_3](vnode, rm);
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
               }
-              if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                  i_3(vnode, rm);
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
               }
               else {
                   rm();
@@ -5465,12 +5454,12 @@
       }
       function checkDuplicateKeys(children) {
           var seenKeys = {};
-          for (var i_4 = 0; i_4 < children.length; i_4++) {
-              var vnode = children[i_4];
+          for (var i = 0; i < children.length; i++) {
+              var vnode = children[i];
               var key = vnode.key;
               if (isDef(key)) {
                   if (seenKeys[key]) {
-                      warn$2("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                      warn$2(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
                   }
                   else {
                       seenKeys[key] = true;
@@ -5479,10 +5468,10 @@
           }
       }
       function findIdxInOld(node, oldCh, start, end) {
-          for (var i_5 = start; i_5 < end; i_5++) {
-              var c = oldCh[i_5];
+          for (var i = start; i < end; i++) {
+              var c = oldCh[i];
               if (isDef(c) && sameVnode(node, c))
-                  { return i_5; }
+                  { return i; }
           }
       }
       function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5562,8 +5551,8 @@
               vnode.parent.data.pendingInsert = queue;
           }
           else {
-              for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                  queue[i_6].data.hook.insert(queue[i_6]);
+              for (var i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
               }
           }
       }
@@ -5576,7 +5565,9 @@
       // Note: this is a browser-only function so we can assume elms are DOM nodes.
       function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
           var i;
-          var tag = vnode.tag, data = vnode.data, children = vnode.children;
+          var tag = vnode.tag;
+          var data = vnode.data;
+          var children = vnode.children;
           inVPre = inVPre || (data && data.pre);
           vnode.elm = elm;
           if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5625,9 +5616,9 @@
                           // iterate and compare children lists
                           var childrenMatch = true;
                           var childNode = elm.firstChild;
-                          for (var i_7 = 0; i_7 < children.length; i_7++) {
+                          for (var i$1 = 0; i$1 < children.length; i$1++) {
                               if (!childNode ||
-                                  !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                   childrenMatch = false;
                                   break;
                               }
@@ -5738,22 +5729,22 @@
                       var ancestor = vnode.parent;
                       var patchable = isPatchable(vnode);
                       while (ancestor) {
-                          for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                              cbs.destroy[i_8](ancestor);
+                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
                           }
                           ancestor.elm = vnode.elm;
                           if (patchable) {
-                              for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                  cbs.create[i_9](emptyNode, ancestor);
+                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                  cbs.create[i$1](emptyNode, ancestor);
                               }
                               // #6513
                               // invoke insert hooks that may have been merged by create hooks.
                               // e.g. for directives that uses the "inserted" hook.
-                              var insert_1 = ancestor.data.hook.insert;
-                              if (insert_1.merged) {
+                              var insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                      insert_1.fns[i_10]();
+                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                      insert.fns[i$2]();
                                   }
                               }
                           }
@@ -5868,7 +5859,7 @@
       return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
   }
   function callHook(dir, hook, vnode, oldVnode, isDestroy) {
       var fn = dir.def && dir.def[hook];
@@ -5877,12 +5868,12 @@
               fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
           }
           catch (e) {
-              handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
           }
       }
   }
 
-  var baseModules = [ref, directives$1];
+  var baseModules = [ref$1, directives$1];
 
   function updateAttrs(oldVnode, vnode) {
       var opts = vnode.componentOptions;
@@ -5971,11 +5962,11 @@
               key === 'placeholder' &&
               value !== '' &&
               !el.__ieph) {
-              var blocker_1 = function (e) {
+              var blocker = function (e) {
                   e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker_1);
+                  el.removeEventListener('input', blocker);
               };
-              el.addEventListener('input', blocker_1);
+              el.addEventListener('input', blocker);
               // $flow-disable-line
               el.__ieph = true; /* IE placeholder patched */
           }
@@ -6092,9 +6083,7 @@
               if (c === 0x2f) {
                   // /
                   var j = i - 1;
-                  var p 
-                  // find first non-whitespace prev char
-                  = void 0;
+                  var p = (void 0);
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
@@ -6128,18 +6117,18 @@
       var i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return "_f(\"" + filter + "\")(" + exp + ")";
+          return ("_f(\"" + filter + "\")(" + exp + ")");
       }
       else {
-          var name_1 = filter.slice(0, i);
+          var name = filter.slice(0, i);
           var args = filter.slice(i + 1);
-          return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
       }
   }
 
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error("[Vue compiler]: " + msg);
+      console.error(("[Vue compiler]: " + msg));
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
@@ -6173,7 +6162,7 @@
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -6307,23 +6296,25 @@
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+      var ref = modifiers || {};
+      var number = ref.number;
+      var trim = ref.trim;
       var baseValueExpression = '$$v';
       var valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
               "(typeof " + baseValueExpression + " === 'string'" +
-                  ("? " + baseValueExpression + ".trim()") +
-                  (": " + baseValueExpression + ")");
+                  "? " + baseValueExpression + ".trim()" +
+                  ": " + baseValueExpression + ")";
       }
       if (number) {
           valueExpression = "_n(" + valueExpression + ")";
       }
       var assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: "(" + value + ")",
+          value: ("(" + value + ")"),
           expression: JSON.stringify(value),
-          callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
       };
   }
   /**
@@ -6332,10 +6323,10 @@
   function genAssignmentCode(value, assignment) {
       var res = parseModel(value);
       if (res.key === null) {
-          return value + "=" + assignment;
+          return (value + "=" + assignment);
       }
       else {
-          return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
       }
   }
   /**
@@ -6441,8 +6432,8 @@
       /* istanbul ignore if */
       if (isDef(on[RANGE_TOKEN$1])) {
           // IE input[type=range] only supports `change` event
-          var event_1 = isIE ? 'change' : 'input';
-          on[event_1] = [].concat(on[RANGE_TOKEN$1], on[event_1] || []);
+          var event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
           delete on[RANGE_TOKEN$1];
       }
       // This was originally intended to fix #4521 but no longer necessary
@@ -6475,17 +6466,17 @@
       // and the handler would only fire if the event passed to it was fired
       // AFTER it was attached.
       if (useMicrotaskFix) {
-          var attachedTimestamp_1 = currentFlushTimestamp;
-          var original_1 = handler;
+          var attachedTimestamp = currentFlushTimestamp;
+          var original = handler;
           //@ts-expect-error
-          handler = original_1._wrapper = function (e) {
+          handler = original._wrapper = function (e) {
               if (
               // no bubbling, should always fire.
               // this is just a safety net in case event.timeStamp is unreliable in
               // certain weird environments...
               e.target === e.currentTarget ||
                   // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp_1 ||
+                  e.timeStamp >= attachedTimestamp ||
                   // bail for environments that have buggy event.timeStamp implementations
                   // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                   // #9681 QtWebEngine event.timeStamp is negative value
@@ -6494,7 +6485,7 @@
                   // electron/nw.js app, since event.timeStamp will be using a different
                   // starting reference
                   e.target.ownerDocument !== document) {
-                  return original_1.apply(this, arguments);
+                  return original.apply(this, arguments);
               }
           };
       }
@@ -6726,9 +6717,9 @@
       }
       var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
       for (var i = 0; i < vendorNames.length; i++) {
-          var name_1 = vendorNames[i] + capName;
-          if (name_1 in emptyStyle) {
-              return name_1;
+          var name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
           }
       }
   });
@@ -6853,12 +6844,12 @@
   }
   var autoCssTransition$1 = cached(function (name) {
       return {
-          enterClass: name + "-enter",
-          enterToClass: name + "-enter-to",
-          enterActiveClass: name + "-enter-active",
-          leaveClass: name + "-leave",
-          leaveToClass: name + "-leave-to",
-          leaveActiveClass: name + "-leave-active",
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
       };
   });
   var hasTransition$1 = inBrowser && !isIE9;
@@ -6910,7 +6901,10 @@
       removeClass$1(el, cls);
   }
   function whenTransitionEnds$1(el, expectedType, cb) {
-      var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+      var ref = getTransitionInfo$1(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
       if (!type)
           { return cb(); }
       var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
@@ -7015,7 +7009,23 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
@@ -7123,7 +7133,17 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
       var userWantsControl = getHookArgumentsLength$1(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7197,7 +7217,7 @@
   function checkDuration$1(val, name, vnode) {
       if (typeof val !== 'number') {
           warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-              ("got " + JSON.stringify(val) + "."), vnode.context);
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
       }
       else if (isNaN(val)) {
           warn$2("<transition> explicit " + name + " duration is NaN - " +
@@ -7237,7 +7257,7 @@
       ? {
           create: _enter,
           activate: _enter,
-          remove: function (vnode, rm) {
+          remove: function remove(vnode, rm) {
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
@@ -7273,7 +7293,7 @@
       });
   }
   var directive = {
-      inserted: function (el, binding, vnode, oldVnode) {
+      inserted: function inserted(el, binding, vnode, oldVnode) {
           if (vnode.tag === 'select') {
               // #6903
               if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -7303,22 +7323,22 @@
               }
           }
       },
-      componentUpdated: function (el, binding, vnode) {
+      componentUpdated: function componentUpdated(el, binding, vnode) {
           if (vnode.tag === 'select') {
               setSelected(el, binding, vnode.context);
               // in case the options rendered by v-for have changed,
               // it's possible that the value is out-of-sync with the rendered options.
               // detect such cases and filter out values that no longer has a matching
               // option in the DOM.
-              var prevOptions_1 = el._vOptions;
-              var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+              var prevOptions = el._vOptions;
+              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
                   // trigger change event if
                   // no matching option found for at least one value
                   var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
                       : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions_1);
+                          hasNoMatchingOption(binding.value, curOptions);
                   if (needReset) {
                       trigger(el, 'change');
                   }
@@ -7339,8 +7359,8 @@
       var value = binding.value;
       var isMultiple = el.multiple;
       if (isMultiple && !Array.isArray(value)) {
-          warn$2("<select multiple v-model=\"" + binding.expression + "\"> " +
-                  ("expects an Array value for its binding, but got " + Object.prototype.toString
+          warn$2("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                  "expects an Array value for its binding, but got " + (Object.prototype.toString
                       .call(value)
                       .slice(8, -1)), vm);
           return;
@@ -7471,12 +7491,12 @@
   }
   var autoCssTransition = cached(function (name) {
       return {
-          enterClass: name + "-enter",
-          enterToClass: name + "-enter-to",
-          enterActiveClass: name + "-enter-active",
-          leaveClass: name + "-leave",
-          leaveToClass: name + "-leave-to",
-          leaveActiveClass: name + "-leave-active",
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
       };
   });
   var hasTransition = inBrowser && !isIE9;
@@ -7528,7 +7548,10 @@
       removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+      var ref = getTransitionInfo(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
       if (!type)
           { return cb(); }
       var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7633,7 +7656,23 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
@@ -7741,7 +7780,17 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
       var userWantsControl = getHookArgumentsLength(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7815,7 +7864,7 @@
   function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
           warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-              ("got " + JSON.stringify(val) + "."), vnode.context);
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
       }
       else if (isNaN(val)) {
           warn$2("<transition> explicit " + name + " duration is NaN - " +
@@ -7855,8 +7904,9 @@
           : vnode;
   }
   var show = {
-      bind: function (el, _a, vnode) {
-          var value = _a.value;
+      bind: function bind(el, ref, vnode) {
+          var value = ref.value;
+
           vnode = locateNode(vnode);
           var transition = vnode.data && vnode.data.transition;
           var originalDisplay = (el.__vOriginalDisplay =
@@ -7871,8 +7921,10 @@
               el.style.display = value ? originalDisplay : 'none';
           }
       },
-      update: function (el, _a, vnode) {
-          var value = _a.value, oldValue = _a.oldValue;
+      update: function update(el, ref, vnode) {
+          var value = ref.value;
+          var oldValue = ref.oldValue;
+
           /* istanbul ignore if */
           if (!value === !oldValue)
               { return; }
@@ -7895,7 +7947,7 @@
               el.style.display = value ? el.__vOriginalDisplay : 'none';
           }
       },
-      unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
           if (!isDestroy) {
               el.style.display = el.__vOriginalDisplay;
           }
@@ -7946,8 +7998,8 @@
       // events.
       // extract listeners and pass them directly to the transition methods
       var listeners = options._parentListeners;
-      for (var key in listeners) {
-          data[camelize(key)] = listeners[key];
+      for (var key$1 in listeners) {
+          data[camelize(key$1)] = listeners[key$1];
       }
       return data;
   }
@@ -7975,8 +8027,9 @@
       name: 'transition',
       props: transitionProps,
       abstract: true,
-      render: function (h) {
-          var _this = this;
+      render: function render(h) {
+          var this$1 = this;
+
           var children = this.$slots.default;
           if (!children) {
               return;
@@ -8018,7 +8071,7 @@
           // ensure a key that is unique to the vnode type and to this transition
           // component instance. This key will be used to remove pending leaving nodes
           // during entering.
-          var id = "__transition-" + this._uid + "-";
+          var id = "__transition-" + (this._uid) + "-";
           child.key =
               child.key == null
                   ? child.isComment
@@ -8052,8 +8105,8 @@
                   // return placeholder node and queue update when leave finishes
                   this._leaving = true;
                   mergeVNodeHook(oldData, 'afterLeave', function () {
-                      _this._leaving = false;
-                      _this.$forceUpdate();
+                      this$1._leaving = false;
+                      this$1.$forceUpdate();
                   });
                   return placeholder(h, rawChild);
               }
@@ -8061,14 +8114,14 @@
                   if (isAsyncPlaceholder(child)) {
                       return oldRawChild;
                   }
-                  var delayedLeave_1;
+                  var delayedLeave;
                   var performLeave = function () {
-                      delayedLeave_1();
+                      delayedLeave();
                   };
                   mergeVNodeHook(data, 'afterEnter', performLeave);
                   mergeVNodeHook(data, 'enterCancelled', performLeave);
                   mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                      delayedLeave_1 = leave;
+                      delayedLeave = leave;
                   });
               }
           }
@@ -8085,21 +8138,22 @@
   delete props.mode;
   var TransitionGroup = {
       props: props,
-      beforeMount: function () {
-          var _this = this;
+      beforeMount: function beforeMount() {
+          var this$1 = this;
+
           var update = this._update;
           this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(_this);
+              var restoreActiveInstance = setActiveInstance(this$1);
               // force removing pass
-              _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
               true // removeOnly (!important, avoids unnecessary moves)
               );
-              _this._vnode = _this.kept;
+              this$1._vnode = this$1.kept;
               restoreActiveInstance();
-              update.call(_this, vnode, hydrating);
+              update.call(this$1, vnode, hydrating);
           };
       },
-      render: function (h) {
+      render: function render(h) {
           var tag = this.tag || this.$vnode.data.tag || 'span';
           var map = Object.create(null);
           var prevChildren = (this.prevChildren = this.children);
@@ -8116,27 +8170,27 @@
                   }
                   else {
                       var opts = c.componentOptions;
-                      var name_1 = opts
+                      var name = opts
                           ? opts.Ctor.options.name || opts.tag || ''
                           : c.tag;
-                      warn$2("<transition-group> children must be keyed: <" + name_1 + ">");
+                      warn$2(("<transition-group> children must be keyed: <" + name + ">"));
                   }
               }
           }
           if (prevChildren) {
               var kept = [];
               var removed = [];
-              for (var i = 0; i < prevChildren.length; i++) {
-                  var c = prevChildren[i];
-                  c.data.transition = transitionData;
+              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                  var c$1 = prevChildren[i$1];
+                  c$1.data.transition = transitionData;
                   // @ts-ignore
-                  c.data.pos = c.elm.getBoundingClientRect();
+                  c$1.data.pos = c$1.elm.getBoundingClientRect();
                   // @ts-ignore
-                  if (map[c.key]) {
-                      kept.push(c);
+                  if (map[c$1.key]) {
+                      kept.push(c$1);
                   }
                   else {
-                      removed.push(c);
+                      removed.push(c$1);
                   }
               }
               this.kept = h(tag, null, kept);
@@ -8144,7 +8198,7 @@
           }
           return h(tag, null, children);
       },
-      updated: function () {
+      updated: function updated() {
           var children = this.prevChildren;
           var moveClass = this.moveClass || (this.name || 'v') + '-move';
           if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -8162,25 +8216,25 @@
           children.forEach(function (c) {
               // @ts-ignore
               if (c.data.moved) {
-                  var el_1 = c.elm;
-                  var s = el_1.style;
-                  addTransitionClass(el_1, moveClass);
+                  var el = c.elm;
+                  var s = el.style;
+                  addTransitionClass(el, moveClass);
                   s.transform = s.WebkitTransform = s.transitionDuration = '';
-                  el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                      if (e && e.target !== el_1) {
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
                           return;
                       }
                       if (!e || /transform$/.test(e.propertyName)) {
-                          el_1.removeEventListener(transitionEndEvent, cb);
-                          el_1._moveCb = null;
-                          removeTransitionClass(el_1, moveClass);
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
                       }
                   }));
               }
           });
       },
       methods: {
-          hasMove: function (el, moveClass) {
+          hasMove: function hasMove(el, moveClass) {
               /* istanbul ignore if */
               if (!hasTransition) {
                   return false;
@@ -8384,7 +8438,7 @@
           }
           // tag token
           var exp = parseFilters(match[1].trim());
-          tokens.push("_s(" + exp + ")");
+          tokens.push(("_s(" + exp + ")"));
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -8421,10 +8475,10 @@
   function genData$2(el) {
       var data = '';
       if (el.staticClass) {
-          data += "staticClass:" + el.staticClass + ",";
+          data += "staticClass:" + (el.staticClass) + ",";
       }
       if (el.classBinding) {
-          data += "class:" + el.classBinding + ",";
+          data += "class:" + (el.classBinding) + ",";
       }
       return data;
   }
@@ -8458,10 +8512,10 @@
   function genData$1(el) {
       var data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + el.staticStyle + ",";
+          data += "staticStyle:" + (el.staticStyle) + ",";
       }
       if (el.styleBinding) {
-          data += "style:(" + el.styleBinding + "),";
+          data += "style:(" + (el.styleBinding) + "),";
       }
       return data;
   }
@@ -8473,7 +8527,7 @@
 
   var decoder;
   var he = {
-      decode: function (html) {
+      decode: function decode(html) {
           decoder = decoder || document.createElement('div');
           decoder.innerHTML = html;
           return decoder.textContent;
@@ -8499,11 +8553,11 @@
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp("^<" + qnameCapture);
+  var startTagOpen = new RegExp(("^<" + qnameCapture));
   var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
   var doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
@@ -8524,9 +8578,7 @@
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) {
-      return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  };
+  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
   function decodeAttr(value, shouldDecodeNewlines) {
       var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
       return value.replace(re, function (match) { return decodingMap[match]; });
@@ -8538,7 +8590,7 @@
       var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
       var index = 0;
       var last, lastTag;
-      var _loop_1 = function () {
+      while (html) {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -8552,7 +8604,7 @@
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                           }
                           advance(commentEnd + 3);
-                          return "continue";
+                          continue;
                       }
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -8560,14 +8612,14 @@
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
-                          return "continue";
+                          continue;
                       }
                   }
                   // Doctype:
                   var doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
-                      return "continue";
+                      continue;
                   }
                   // End tag:
                   var endTagMatch = html.match(endTag);
@@ -8575,7 +8627,7 @@
                       var curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
-                      return "continue";
+                      continue;
                   }
                   // Start tag:
                   var startTagMatch = parseStartTag();
@@ -8584,10 +8636,10 @@
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                           advance(1);
                       }
-                      return "continue";
+                      continue;
                   }
               }
-              var text = void 0, rest = void 0, next = void 0;
+              var text = (void 0), rest = (void 0), next = (void 0);
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -8614,18 +8666,18 @@
               }
           }
           else {
-              var endTagLength_1 = 0;
-              var stackedTag_1 = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag_1] ||
-                  (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-              var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength_1 = endTag.length;
-                  if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+              var endTagLength = 0;
+              var stackedTag = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                       text = text
                           .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                           .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                   }
-                  if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
                       text = text.slice(1);
                   }
                   if (options.chars) {
@@ -8633,25 +8685,20 @@
                   }
                   return '';
               });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag_1, index - endTagLength_1, index);
+              index += html.length - rest$1.length;
+              html = rest$1;
+              parseEndTag(stackedTag, index - endTagLength, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                       start: index + html.length,
                   });
               }
-              return "break";
+              break;
           }
-      };
-      while (html) {
-          var state_1 = _loop_1();
-          if (state_1 === "break")
-              { break; }
       }
       // Clean up any remaining tags
       parseEndTag();
@@ -8668,7 +8715,7 @@
                   start: index,
               };
               advance(start[0].length);
-              var end = void 0, attr = void 0;
+              var end, attr;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -8751,7 +8798,7 @@
               for (var i = stack.length - 1; i >= pos; i--) {
                   if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -8826,7 +8873,10 @@
       platformMustUseProp = options.mustUseProp || no;
       platformGetTagNamespace = options.getTagNamespace || no;
       var isReservedTag = options.isReservedTag || no;
-      maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      maybeComponent = function (el) { return !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
       transforms = pluckModuleFunction(options.modules, 'transformNode');
       preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
       postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -8877,8 +8927,8 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name_1 = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                      var name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                   }
                   currentParent.children.push(element);
                   element.parent = currentParent;
@@ -8904,7 +8954,7 @@
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode = void 0;
+              var lastNode;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -8914,7 +8964,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8931,7 +8981,7 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function (tag, attrs, unary, start, end) {
+          start: function start(tag, attrs, unary, start$1, end) {
               // check namespace.
               // inherit parent ns if there is one
               var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -8946,7 +8996,7 @@
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start;
+                      element.start = start$1;
                       element.end = end;
                       element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                           cumulated[attr.name] = attr;
@@ -8967,7 +9017,7 @@
                   element.forbidden = true;
                   warn$1('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          ("<" + tag + ">") +
+                          "<" + tag + ">" +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
@@ -9006,24 +9056,24 @@
                   closeElement(element);
               }
           },
-          end: function (tag, start, end) {
+          end: function end(tag, start, end$1) {
               var element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end;
+                  element.end = end$1;
               }
               closeElement(element);
           },
-          chars: function (text, start, end) {
+          chars: function chars(text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
                           warnOnce('Component template requires a root element, rather than just text.', { start: start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                               start: start,
                           });
                       }
@@ -9063,8 +9113,8 @@
                       // condense consecutive whitespaces into single space
                       text = text.replace(whitespaceRE, ' ');
                   }
-                  var res = void 0;
-                  var child = void 0;
+                  var res;
+                  var child;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
@@ -9090,7 +9140,7 @@
                   }
               }
           },
-          comment: function (text, start, end) {
+          comment: function comment(text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
@@ -9160,11 +9210,11 @@
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
-                  var parent_1 = el.parent;
+                  var parent = el.parent;
                   if (iterator &&
                       iterator === exp &&
-                      parent_1 &&
-                      parent_1.tag === 'transition-group') {
+                      parent &&
+                      parent.tag === 'transition-group') {
                       warn$1("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
@@ -9188,7 +9238,7 @@
               extend(el, res);
           }
           else {
-              warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -9241,7 +9291,7 @@
       }
       else {
           warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
@@ -9252,7 +9302,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -9289,7 +9339,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -9321,41 +9371,45 @@
                               "the receiving component", el);
                       }
                   }
-                  var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                  el.slotTarget = name_2;
+                  var ref = getSlotName(slotBinding);
+                  var name = ref.name;
+                  var dynamic = ref.dynamic;
+                  el.slotTarget = name;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
               }
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
+              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding$1) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                       }
                       if (el.slotScope || el.slotTarget) {
                           warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
                           warn$1("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding);
+                              "<template> syntax when there are other named slots.", slotBinding$1);
                       }
                   }
                   // add the component's children to its default slot
                   var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                  var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                  slotContainer_1.slotTarget = name_3;
-                  slotContainer_1.slotTargetDynamic = dynamic;
-                  slotContainer_1.children = el.children.filter(function (c) {
+                  var ref$1 = getSlotName(slotBinding$1);
+                  var name$1 = ref$1.name;
+                  var dynamic$1 = ref$1.dynamic;
+                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name$1;
+                  slotContainer.slotTargetDynamic = dynamic$1;
+                  slotContainer.children = el.children.filter(function (c) {
                       if (!c.slotScope) {
-                          c.parent = slotContainer_1;
+                          c.parent = slotContainer;
                           return true;
                       }
                   });
-                  slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -9378,7 +9432,7 @@
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: "\"" + name + "\"", dynamic: false };
+              { name: ("\"" + name + "\""), dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
@@ -9424,7 +9478,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -9438,14 +9492,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                               );
                           }
                       }
@@ -9522,11 +9576,11 @@
   function parseModifiers(name) {
       var match = name.match(modifierRE);
       if (match) {
-          var ret_1 = {};
+          var ret = {};
           match.forEach(function (m) {
-              ret_1[m.slice(1)] = true;
+              ret[m.slice(1)] = true;
           });
-          return ret_1;
+          return ret;
       }
   }
   function makeAttrsMap(attrs) {
@@ -9568,7 +9622,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -9593,16 +9647,16 @@
           if (!map['v-model']) {
               return;
           }
-          var typeBinding = void 0;
+          var typeBinding;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + map['v-bind'] + ").type";
+              typeBinding = "(" + (map['v-bind']) + ").type";
           }
           if (typeBinding) {
               var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
               var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
               var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
@@ -9668,7 +9722,7 @@
           // inputs with type="file" are read only and setting the input's
           // value will throw an error.
           if (tag === 'input' && type === 'file') {
-              warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+              warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                   "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
           }
       }
@@ -9695,7 +9749,7 @@
           return false;
       }
       else {
-          warn("<" + el.tag + " v-model=\"" + value + "\">: " +
+          warn("<" + (el.tag) + " v-model=\"" + value + "\">: " +
               "v-model is not supported on this element type. " +
               "If you are working with contenteditable, it's recommended to " +
               'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
@@ -9709,25 +9763,25 @@
       var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
       var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
       addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          ("?_i(" + value + "," + valueBinding + ")>-1") +
+          "?_i(" + value + "," + valueBinding + ")>-1" +
           (trueValueBinding === 'true'
-              ? ":(" + value + ")"
-              : ":_q(" + value + "," + trueValueBinding + ")"));
+              ? (":(" + value + ")")
+              : (":_q(" + value + "," + trueValueBinding + ")")));
       addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
-          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
           'if(Array.isArray($$a)){' +
-          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
           '$$i=_i($$a,$$v);' +
-          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
   }
   function genRadioModel(el, value, modifiers) {
       var number = modifiers && modifiers.number;
       var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
       addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
   }
   function genSelect(el, value, modifiers) {
@@ -9735,10 +9789,10 @@
       var selectedVal = "Array.prototype.filter" +
           ".call($event.target.options,function(o){return o.selected})" +
           ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          ("return " + (number ? '_n(val)' : 'val') + "})");
+          "return " + (number ? '_n(val)' : 'val') + "})";
       var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
       var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + genAssignmentCode(value, assignment);
+      code = code + " " + (genAssignmentCode(value, assignment));
       addHandler(el, 'change', code, null, true);
   }
   function genDefaultModel(el, value, modifiers) {
@@ -9746,15 +9800,18 @@
       // warn if v-bind:value conflicts with v-model
       // except for inputs with v-bind:type
       {
-          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
           var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value_1 && !typeBinding) {
+          if (value$1 && !typeBinding) {
               var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+              warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                   'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
           }
       }
-      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+      var ref = modifiers || {};
+      var lazy = ref.lazy;
+      var number = ref.number;
+      var trim = ref.trim;
       var needCompositionGuard = !lazy && type !== 'range';
       var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
       var valueExpression = '$event.target.value';
@@ -9768,7 +9825,7 @@
       if (needCompositionGuard) {
           code = "if($event.target.composing)return;" + code;
       }
-      addProp(el, 'value', "(" + value + ")");
+      addProp(el, 'value', ("(" + value + ")"));
       addHandler(el, event, code, null, true);
       if (trim || number) {
           addHandler(el, 'blur', '$forceUpdate()');
@@ -9777,13 +9834,13 @@
 
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
       }
   }
 
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
       }
   }
 
@@ -9867,8 +9924,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                  var block = node.ifConditions[i].block;
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
                   markStatic(block);
                   if (!block.static) {
                       node.static = false;
@@ -9900,8 +9957,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                  markStaticRoots(node.ifConditions[i].block, isInFor);
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
               }
           }
       }
@@ -9971,7 +10028,7 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
   var modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
@@ -9988,19 +10045,19 @@
       var prefix = isNative ? 'nativeOn:' : 'on:';
       var staticHandlers = "";
       var dynamicHandlers = "";
-      for (var name_1 in events) {
-          var handlerCode = genHandler(events[name_1]);
+      for (var name in events) {
+          var handlerCode = genHandler(events[name]);
           //@ts-expect-error
-          if (events[name_1] && events[name_1].dynamic) {
-              dynamicHandlers += name_1 + "," + handlerCode + ",";
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += name + "," + handlerCode + ",";
           }
           else {
-              staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
           }
       }
-      staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
       if (dynamicHandlers) {
-          return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
       }
       else {
           return prefix + staticHandlers;
@@ -10011,7 +10068,7 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
       }
       var isMethodPath = simplePathRE.test(handler.value);
       var isFunctionExpression = fnExpRE.test(handler.value);
@@ -10020,13 +10077,13 @@
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
       }
       else {
           var code = '';
           var genModifierCode = '';
           var keys = [];
-          var _loop_1 = function (key) {
+          for (var key in handler.modifiers) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -10035,18 +10092,15 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers_1 = handler.modifiers;
+                  var modifiers = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                      .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                       .join('||'));
               }
               else {
                   keys.push(key);
               }
-          };
-          for (var key in handler.modifiers) {
-              _loop_1(key);
           }
           if (keys.length) {
               code += genKeyFilter(keys);
@@ -10056,13 +10110,13 @@
               code += genModifierCode;
           }
           var handlerCode = isMethodPath
-              ? "return " + handler.value + ".apply(null, arguments)"
+              ? ("return " + (handler.value) + ".apply(null, arguments)")
               : isFunctionExpression
-                  ? "return (" + handler.value + ").apply(null, arguments)"
+                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
                   : isFunctionInvocation
-                      ? "return " + handler.value
+                      ? ("return " + (handler.value))
                       : handler.value;
-          return "function($event){" + code + handlerCode + "}";
+          return ("function($event){" + code + handlerCode + "}");
       }
   }
   function genKeyFilter(keys) {
@@ -10071,20 +10125,20 @@
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&') + ")return null;"));
+          (keys.map(genFilterCode).join('&&')) + ")return null;");
   }
   function genFilterCode(key) {
       var keyVal = parseInt(key, 10);
       if (keyVal) {
-          return "$event.keyCode!==" + keyVal;
+          return ("$event.keyCode!==" + keyVal);
       }
       var keyCode = keyCodes[key];
       var keyName = keyNames[key];
       return ("_k($event.keyCode," +
-          (JSON.stringify(key) + ",") +
-          (JSON.stringify(keyCode) + ",") +
+          (JSON.stringify(key)) + "," +
+          (JSON.stringify(keyCode)) + "," +
           "$event.key," +
-          ("" + JSON.stringify(keyName)) +
+          "" + (JSON.stringify(keyName)) +
           ")");
   }
 
@@ -10092,12 +10146,12 @@
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
       }
-      el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
   }
 
   function bind(el, dir) {
       el.wrapData = function (code) {
-          return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
       };
   }
 
@@ -10107,24 +10161,19 @@
       cloak: noop,
   };
 
-  var CodegenState = /** @class */ (function () {
-      function CodegenState(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          var isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = function (el) {
-              return !!el.component || !isReservedTag(el.tag);
-          };
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-      return CodegenState;
-  }());
+  var CodegenState = function CodegenState(options) {
+      this.options = options;
+      this.warn = options.warn || baseWarn;
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+      this.directives = extend(extend({}, baseDirectives), options.directives);
+      var isReservedTag = options.isReservedTag || no;
+      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      this.onceId = 0;
+      this.staticRenderFns = [];
+      this.pre = false;
+  };
   function generate(ast, options) {
       var state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
@@ -10134,7 +10183,7 @@
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: "with(this){return " + code + "}",
+          render: ("with(this){return " + code + "}"),
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -10162,19 +10211,17 @@
       }
       else {
           // component or element
-          var code = void 0;
+          var code;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data = void 0;
+              var data;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
                   data = genData(el, state);
               }
               var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-              ) + (children ? "," + children : '' // children
-              ) + ")";
+              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
           }
           // module transforms
           for (var i = 0; i < state.transforms.length; i++) {
@@ -10193,9 +10240,9 @@
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
       state.pre = originalPreState;
-      return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
   }
   // v-once
   function genOnce(el, state) {
@@ -10205,19 +10252,19 @@
       }
       else if (el.staticInFor) {
           var key = '';
-          var parent_1 = el.parent;
-          while (parent_1) {
-              if (parent_1.for) {
-                  key = parent_1.key;
+          var parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
                   break;
               }
-              parent_1 = parent_1.parent;
+              parent = parent.parent;
           }
           if (!key) {
               state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
       }
       else {
           return genStatic(el, state);
@@ -10233,10 +10280,10 @@
       }
       var condition = conditions.shift();
       if (condition.exp) {
-          return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
       }
       else {
-          return "" + genTernaryExp(condition.block);
+          return ("" + (genTernaryExp(condition.block)));
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -10250,20 +10297,20 @@
   function genFor(el, state, altGen, altHelper) {
       var exp = el.for;
       var alias = el.alias;
-      var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-      var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
               "v-for should have explicit keys. " +
               "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ((altHelper || '_l') + "((" + exp + ")," +
-          ("function(" + alias + iterator1 + iterator2 + "){") +
-          ("return " + (altGen || genElement)(el, state)) +
+          "function(" + alias + iterator1 + iterator2 + "){" +
+          "return " + ((altGen || genElement)(el, state)) +
           '})');
   }
   function genData(el, state) {
@@ -10275,11 +10322,11 @@
           { data += dirs + ','; }
       // key
       if (el.key) {
-          data += "key:" + el.key + ",";
+          data += "key:" + (el.key) + ",";
       }
       // ref
       if (el.ref) {
-          data += "ref:" + el.ref + ",";
+          data += "ref:" + (el.ref) + ",";
       }
       if (el.refInFor) {
           data += "refInFor:true,";
@@ -10290,7 +10337,7 @@
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + el.tag + "\",";
+          data += "tag:\"" + (el.tag) + "\",";
       }
       // module data generation functions
       for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -10298,31 +10345,31 @@
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + genProps(el.attrs) + ",";
+          data += "attrs:" + (genProps(el.attrs)) + ",";
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + genProps(el.props) + ",";
+          data += "domProps:" + (genProps(el.props)) + ",";
       }
       // event handlers
       if (el.events) {
-          data += genHandlers(el.events, false) + ",";
+          data += (genHandlers(el.events, false)) + ",";
       }
       if (el.nativeEvents) {
-          data += genHandlers(el.nativeEvents, true) + ",";
+          data += (genHandlers(el.nativeEvents, true)) + ",";
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + el.slotTarget + ",";
+          data += "slot:" + (el.slotTarget) + ",";
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += genScopedSlots(el, el.scopedSlots, state) + ",";
+          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
       }
       // inline-template
       if (el.inlineTemplate) {
@@ -10336,7 +10383,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -10366,9 +10413,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                  ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                  : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
           }
       }
       if (hasRuntime) {
@@ -10382,9 +10429,9 @@
       }
       if (ast && ast.type === 1) {
           var inlineRenderFns = generate(ast, state.options);
-          return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-              .map(function (code) { return "function(){" + code + "}"; })
-              .join(',') + "]}";
+          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+              .map(function (code) { return ("function(){" + code + "}"); })
+              .join(',')) + "]}");
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -10409,23 +10456,23 @@
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent_2 = el.parent;
-          while (parent_2) {
-              if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                  parent_2.for) {
+          var parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
                   needsForceUpdate = true;
                   break;
               }
-              if (parent_2.if) {
+              if (parent.if) {
                   needsKey = true;
               }
-              parent_2 = parent_2.parent;
+              parent = parent.parent;
           }
       }
       var generatedSlots = Object.keys(slots)
           .map(function (key) { return genScopedSlot(slots[key], state); })
           .join(',');
-      return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
   }
   function hash(str) {
       var hash = 5381;
@@ -10454,36 +10501,36 @@
       }
       var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
       var fn = "function(" + slotScope + "){" +
-          ("return " + (el.tag === 'template'
+          "return " + (el.tag === 'template'
               ? el.if && isLegacySyntax
-                  ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                   : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}");
+              : genElement(el, state)) + "}";
       // reverse proxy v-slot without scope on this.$slots
       var reverseProxy = slotScope ? "" : ",proxy:true";
-      return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
       var children = el.children;
       if (children.length) {
-          var el_1 = children[0];
+          var el$1 = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el_1.for &&
-              el_1.tag !== 'template' &&
-              el_1.tag !== 'slot') {
-              var normalizationType_1 = checkSkip
-                  ? state.maybeComponent(el_1)
+              el$1.for &&
+              el$1.tag !== 'template' &&
+              el$1.tag !== 'slot') {
+              var normalizationType = checkSkip
+                  ? state.maybeComponent(el$1)
                       ? ",1"
                       : ",0"
                   : "";
-              return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
           }
-          var normalizationType = checkSkip
+          var normalizationType$1 = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen_1 = altGenNode || genNode;
-          return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+          var gen = altGenNode || genNode;
+          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
       }
   }
   // determine the normalization needed for the children array.
@@ -10525,17 +10572,17 @@
       }
   }
   function genText(text) {
-      return "_v(" + (text.type === 2
+      return ("_v(" + (text.type === 2
           ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
   }
   function genComment(comment) {
-      return "_e(" + JSON.stringify(comment.text) + ")";
+      return ("_e(" + (JSON.stringify(comment.text)) + ")");
   }
   function genSlot(el, state) {
       var slotName = el.slotName || '"default"';
       var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? "," + children : '');
+      var res = "_t(" + slotName + (children ? ("," + children) : '');
       var attrs = el.attrs || el.dynamicAttrs
           ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
               // slot props are camelized
@@ -10559,7 +10606,7 @@
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
       var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+      return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
   }
   function genProps(props) {
       var staticProps = "";
@@ -10568,15 +10615,15 @@
           var prop = props[i];
           var value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += prop.name + "," + value + ",";
+              dynamicProps += (prop.name) + "," + value + ",";
           }
           else {
-              staticProps += "\"" + prop.name + "\":" + value + ",";
+              staticProps += "\"" + (prop.name) + "\":" + value + ",";
           }
       }
-      staticProps = "{" + staticProps.slice(0, -1) + "}";
+      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
       if (dynamicProps) {
-          return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
       }
       else {
           return staticProps;
@@ -10610,22 +10657,22 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name_1 in node.attrsMap) {
-              if (dirRE.test(name_1)) {
-                  var value = node.attrsMap[name_1];
+          for (var name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  var value = node.attrsMap[name];
                   if (value) {
-                      var range = node.rawAttrsMap[name_1];
-                      if (name_1 === 'v-for') {
-                          checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                      var range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                       }
-                      else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                          checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                       }
-                      else if (onRE.test(name_1)) {
-                          checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                      else if (onRE.test(name)) {
+                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                       }
                       else {
-                          checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                       }
                   }
               }
@@ -10645,7 +10692,7 @@
       var keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
           warn("avoid using JavaScript unary operator as property name: " +
-              ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -10658,16 +10705,16 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function("var " + ident + "=_");
+              new Function(("var " + ident + "=_"));
           }
           catch (e) {
-              warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function("return " + exp);
+          new Function(("return " + exp));
       }
       catch (e) {
           var keywordMatch = exp
@@ -10675,12 +10722,12 @@
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
               warn("avoid using JavaScript keyword as property name: " +
-                  ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
           }
           else {
-              warn("invalid expression: " + e.message + " in\n\n" +
-                  ("    " + exp + "\n\n") +
-                  ("  Raw expression: " + text.trim() + "\n"), range);
+              warn("invalid expression: " + (e.message) + " in\n\n" +
+                  "    " + exp + "\n\n" +
+                  "  Raw expression: " + (text.trim()) + "\n", range);
           }
       }
   }
@@ -10689,16 +10736,17 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + e.message + " in\n\n" +
-              ("    " + exp + "\n\n") +
-              ("  Raw expression: " + text.trim() + "\n"), range);
+          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+              "    " + exp + "\n\n" +
+              "  Raw expression: " + (text.trim()) + "\n", range);
       }
   }
 
   var range = 2;
   function generateCodeFrame(source, start, end) {
-      if (start === void 0) { start = 0; }
-      if (end === void 0) { end = source.length; }
+      if ( start === void 0 ) start = 0;
+      if ( end === void 0 ) end = source.length;
+
       var lines = source.split(/\r?\n/);
       var count = 0;
       var res = [];
@@ -10708,18 +10756,18 @@
               for (var j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
                       { continue; }
-                  res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                  res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                   var lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
                       var pad = start - (count - lineLength) + 1;
-                      var length_1 = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                      var length = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length_2 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat("^", length_2));
+                          var length$1 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat("^", length$1));
                       }
                       count += lineLength + 1;
                   }
@@ -10791,13 +10839,13 @@
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
                       compiled.errors.forEach(function (e) {
-                          warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                          warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
                       warn("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                           '\n', vm);
                   }
               }
@@ -10825,10 +10873,12 @@
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                   warn("Failed to generate render function:\n\n" +
                       fnGenErrors
-                          .map(function (_a) {
-                          var err = _a.err, code = _a.code;
-                          return err.toString() + " in\n\n" + code + "\n";
-                      })
+                          .map(function (ref) {
+                              var err = ref.err;
+                              var code = ref.code;
+
+                              return ((err.toString()) + " in\n\n" + code + "\n");
+                  })
                           .join('\n'), vm);
               }
           }
@@ -10848,15 +10898,15 @@
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
                       warn = function (msg, range, tip) {
                           var data = { msg: msg };
                           if (range) {
                               if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength_1;
+                                  data.start = range.start + leadingSpaceLength;
                               }
                               if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength_1;
+                                  data.end = range.end + leadingSpaceLength;
                               }
                           }
                           (tip ? tips : errors).push(data);
@@ -10909,7 +10959,8 @@
       };
   });
 
-  var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
+  var ref = createCompiler(baseOptions);
+  var compileToFunctions = ref.compileToFunctions;
 
   // check whether current browser encodes a char inside attribute values
   var div;
@@ -10947,7 +10998,7 @@
                       template = idToTemplate(template);
                       /* istanbul ignore if */
                       if (!template) {
-                          warn$2("Template element not found or is empty: " + options.template, this);
+                          warn$2(("Template element not found or is empty: " + (options.template)), this);
                       }
                   }
               }
@@ -10970,19 +11021,21 @@
               if (config.performance && mark) {
                   mark('compile');
               }
-              var _a = compileToFunctions(template, {
+              var ref = compileToFunctions(template, {
                   outputSourceRange: "development" !== 'production',
                   shouldDecodeNewlines: shouldDecodeNewlines,
                   shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
                   delimiters: options.delimiters,
                   comments: options.comments,
-              }, this), render = _a.render, staticRenderFns = _a.staticRenderFns;
+              }, this);
+              var render = ref.render;
+              var staticRenderFns = ref.staticRenderFns;
               options.render = render;
               options.staticRenderFns = staticRenderFns;
               /* istanbul ignore if */
               if (config.performance && mark) {
                   mark('compile end');
-                  measure("vue " + this._name + " compile", 'compile', 'compile end');
+                  measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
               }
           }
       }
diff --git a/dist/vue.min.js b/dist/vue.min.js
index 3bf7f1b738b..0703699d85e 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -3,4 +3,9 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),$=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),w=/\B([A-Z])/g,C=g(function(e){return e.replace(w,"-$1").toLowerCase()});var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,n){return E(e,t[n])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every(function(n){return E(e[n],t[n])})}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+P.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){function e(){this.id=se++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){h(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},e}();ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(){function e(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),de=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function ve(e){return new pe(void 0,void 0,void 0,String(e))}function he(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var me=Array.prototype,ye=Object.create(me);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=me[e];R(ye,e,function(){for(var n=arguments,r=[],i=0;i<arguments.length;i++)r[i]=n[i];var a,o=t.apply(this,r),s=this.__ob__;switch(e){case"push":case"unshift":a=r;break;case"splice":a=r.slice(2)}return a&&s.observeArray(a),s.dep.notify(),o})});var ge=Object.getOwnPropertyNames(ye),_e=!0;function be(e){_e=e}var $e=function(){function e(e){var t;this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?(t=ye,e.__proto__=t):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ye,ge),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ce(e,t[n])},e.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)we(e[t])},e}();function we(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof $e?n=e.__ob__:_e&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new $e(e)),t&&n&&n.vmCount++,n}function Ce(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&we(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&function e(t){for(var n=void 0,r=0,i=t.length;r<i;r++)(n=t[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&e(n)}(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&we(t),a.notify())}})}}function xe(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ce(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}var Ae=F.optionMergeStrategies;function Oe(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Oe(r,i):xe(e,n,i));return e}function Se(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Oe(r,i):i}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Ne(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Ae.data=function(e,t,n){return n?Se(e,t,n):t&&"function"!=typeof t?e:Se(e,t)},I.forEach(function(e){Ae[e]=Te}),M.forEach(function(e){Ae[e+"s"]=Ne}),Ae.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in A(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ae.provide=Se;var Ee=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?A({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Ae[r]||Ee;o[r]=i(e[r],t[r],n,r)}return o}function je(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function De(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Pe(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Pe(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Ie(t.type)?r.call(e):r}(r,i,e);var l=_e;be(!0),we(o),be(l)}return o}var Me=/^\s*function (\w+)/;function Ie(e){var t=e&&e.toString().match(Me);return t?t[1]:""}function Fe(e,t){return Ie(e)===Ie(t)}function Pe(e,t){if(!Array.isArray(t))return Fe(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Fe(t[n],e))return n;return-1}function Re(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}Be(e,t,n)}finally{fe()}}function He(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch(function(e){return Re(e,r,i+" (Promise/async)")}),a._handled=!0)}catch(e){Re(e,r,i)}return a}function Be(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ue(t)}Ue(e)}function Ue(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var ze,Ve=!1,Ke=[],qe=!1;function Je(){qe=!1;var e=Ke.slice(0);Ke.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var We=Promise.resolve();ze=function(){We.then(Je),Z&&setTimeout(S)},Ve=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())ze="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Je)}:function(){setTimeout(Je,0)};else{var Ze=1,Ge=new MutationObserver(Je),Xe=document.createTextNode(String(Ze));Ge.observe(Xe,{characterData:!0}),ze=function(){Ze=(Ze+1)%2,Xe.data=String(Ze)},Ve=!0}function Ye(e,t){var n;if(Ke.push(function(){if(e)try{e.call(t)}catch(e){Re(e,t,"nextTick")}else n&&n(t)}),qe||(qe=!0,ze()),!e&&"undefined"!=typeof Promise)return new Promise(function(e){n=e})}var Qe=new ie;function et(e){!function e(t,n){var r,i;var o=Array.isArray(t);if(!o&&!a(t)||Object.isFrozen(t)||t instanceof pe)return;if(t.__ob__){var s=t.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(o)for(r=t.length;r--;)e(t[r],n);else for(i=Object.keys(t),r=i.length;r--;)e(t[i[r]],n)}(e,Qe),Qe.clear()}var tt=g(function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}});function nt(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return He(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)He(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function rt(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=tt(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=nt(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=tt(c)).name,n[c],f.capture)}function it(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=nt([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=nt([s,c]),o.merged=!0,e[i]=o}function at(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ot(e){return i(e)?[ve(e)]:Array.isArray(e)?function e(a,o){var s=[];var c,l,u,f;for(c=0;c<a.length;c++)t(l=a[c])||"boolean"==typeof l||(u=s.length-1,f=s[u],Array.isArray(l)?l.length>0&&(st((l=e(l,(o||"")+"_"+c))[0])&&st(f)&&(s[u]=ve(f.text+l[0].text),l.shift()),s.push.apply(s,l)):i(l)?st(f)?s[u]=ve(f.text+l):""!==l&&s.push(ve(l)):st(l)&&st(f)?s[u]=ve(f.text+l.text):(r(a._isVList)&&n(l.tag)&&t(l.key)&&n(o)&&(l.key="__vlist"+o+"_"+c+"__"),s.push(l)));return s}(e):void 0}function st(e){return n(e)&&n(e.text)&&!1===e.isComment}function ct(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function lt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ut)&&delete n[l];return n}function ut(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ft(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=pt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=dt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function pt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ot(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function dt(e,t){return function(){return e[t]}}function vt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ht(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=A(A({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function mt(e){return je(this.$options,"filters",e)||N}function yt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function gt(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?yt(i,r):a?yt(a,e):r?C(r)!==t:void 0}function _t(e,t,n,r,i){if(n)if(a(n)){Array.isArray(n)&&(n=O(n));var o=void 0,s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function bt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t?r:(wt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r)}function $t(e,t,n){return wt(e,"__once__"+t+(n?"_"+n:""),!0),e}function wt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ct(e[r],t+"_"+r,n);else Ct(e,t,n)}function Ct(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function xt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function kt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?kt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function At(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Ot(e,t){return"string"==typeof e?t+e:e}function St(e){e._o=$t,e._n=f,e._s=u,e._l=vt,e._t=ht,e._q=E,e._i=L,e._m=bt,e._f=mt,e._k=gt,e._b=_t,e._v=ve,e._e=de,e._u=kt,e._g=xt,e._d=At,e._p=Ot}function Tt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=ct(l.inject,a),this.slots=function(){return c.$slots||ft(t.scopedSlots,c.$slots=lt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ft(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ft(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Pt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Pt(s,e,t,n,r,f)}}function Nt(e,t,n,r,i){var a=he(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Et(e,t){for(var n in t)e[b(n)]=t[n]}St(Tt.prototype);var Lt={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Lt.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Wt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){be(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=De(d,v,n,t)}be(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Jt(t,r,h),l&&(t.$slots=lt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Yt(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,en.push(t)):Xt(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,n){if(n&&(t._directInactive=!0,Gt(t)))return;if(!t._inactive){t._inactive=!0;for(var r=0;r<t.$children.length;r++)e(t.$children[r]);Yt(t,"deactivated")}}(t,!0):t.$destroy())}},jt=Object.keys(Lt);function Dt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Ht;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",function(){return h(s,o)});var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j(function(t){e.resolved=Bt(t,i),c?s.length=0:p(!0)}),v=j(function(t){n(e.errorComp)&&(e.error=!0,p(!0))}),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Bt(m.error,i)),n(m.loading)&&(e.loadingComp=Bt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout(function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,t(e.resolved)&&v(null)},m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=de();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},$n(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);at(o,c,l,u,!0)||at(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=De(u,l,r||e);else n(i.attrs)&&Et(c,i.attrs),n(i.props)&&Et(c,i.props);var f=new Tt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Nt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ot(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Nt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<jt.length;n++){var r=jt[n],i=t[r],a=Lt[r];i===a||i&&i._merged||(t[r]=i?Mt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Mt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}var It=1,Ft=2;function Pt(e,o,s,c,l,u){return(Array.isArray(s)||i(s))&&(l=c,c=s,s=void 0),r(u)&&(l=Ft),function(e,i,o,s,c){if(n(o)&&n(o.__ob__))return de();n(o)&&n(o.is)&&(i=o.is);if(!i)return de();Array.isArray(s)&&"function"==typeof s[0]&&((o=o||{}).scopedSlots={default:s[0]},s.length=0);c===Ft?s=ot(s):c===It&&(s=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(s));var l,u;if("string"==typeof i){var f=void 0;u=e.$vnode&&e.$vnode.ns||F.getTagNamespace(i),l=F.isReservedTag(i)?new pe(F.parsePlatformTagName(i),o,s,void 0,void 0,e):o&&o.pre||!n(f=je(e.$options,"components",i))?new pe(i,o,s,void 0,void 0,e):Dt(f,o,e,s,i)}else l=Dt(i,o,e,s);return Array.isArray(l)?l:n(l)?(n(u)&&function e(i,a,o){i.ns=a;"foreignObject"===i.tag&&(a=void 0,o=!0);if(n(i.children))for(var s=0,c=i.children.length;s<c;s++){var l=i.children[s];n(l.tag)&&(t(l.ns)||r(o)&&"svg"!==l.tag)&&e(l,a,o)}}(l,u),n(o)&&function(e){a(e.style)&&et(e.style);a(e.class)&&et(e.class)}(o),l):de()}(e,o,s,c,l)}var Rt,Ht=null;function Bt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Ut(e){return e.isComment&&e.asyncFactory}function zt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Ut(r)))return r}}function Vt(e,t){Rt.$on(e,t)}function Kt(e,t){Rt.$off(e,t)}function qt(e,t){var n=Rt;return function r(){null!==t.apply(null,arguments)&&n.$off(e,r)}}function Jt(e,t,n){Rt=e,rt(t,n||{},Vt,Kt,qt,e),Rt=void 0}var Wt=null;function Zt(e){var t=Wt;return Wt=e,function(){Wt=t}}function Gt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Xt(e,t){if(t){if(e._directInactive=!1,Gt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)Xt(e.$children[n]);Yt(e,"activated")}}function Yt(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)He(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var Qt=[],en=[],tn={},nn=!1,rn=!1,an=0;var on=0,sn=Date.now;if(U&&!q){var cn=window.performance;cn&&"function"==typeof cn.now&&sn()>document.createEvent("Event").timeStamp&&(sn=function(){return cn.now()})}function ln(){var e,t;for(on=sn(),rn=!0,Qt.sort(function(e,t){return e.id-t.id}),an=0;an<Qt.length;an++)(e=Qt[an]).before&&e.before(),t=e.id,tn[t]=null,e.run();var n=en.slice(),r=Qt.slice();an=Qt.length=en.length=0,tn={},nn=rn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,Xt(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Yt(r,"updated")}}(r),ne&&F.devtools&&ne.emit("flush")}var un=0,fn=function(){function e(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++un,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}return e.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Re(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&et(e),fe(),this.cleanupDeps()}return e},e.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},e.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},e.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==tn[t]){if(tn[t]=!0,rn){for(var n=Qt.length-1;n>an&&Qt[n].id>e.id;)n--;Qt.splice(n+1,0,e)}else Qt.push(e);nn||(nn=!0,Ye(ln))}}(this)},e.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Re(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},e.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},e.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},e.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}},e}(),pn={enumerable:!0,configurable:!0,get:S,set:S};function dn(e,t,n){pn.get=function(){return this[t][n]},pn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,pn)}function vn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&be(!1);var a=function(a){i.push(a);var o=De(a,t,n,e);Ce(r,a,o),a in e||dn(e,"_props",a)};for(var o in t)a(o);be(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Re(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||(o=void 0,36!==(o=(a+"").charCodeAt(0))&&95!==o&&dn(e,"_data",a))}var o;we(t,!0)}(e):we(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new fn(e,o||S,S,hn)),i in e||mn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)_n(e,n,r[i]);else _n(e,n,r)}}(e,t.watch)}var hn={lazy:!0};function mn(e,t,n){var r=!te();"function"==typeof n?(pn.get=r?yn(t):gn(n),pn.set=S):(pn.get=n.get?r&&!1!==n.cache?yn(t):gn(n.get):S,pn.set=n.set||S),Object.defineProperty(e,t,pn)}function yn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function gn(e){return function(){return e.call(this,this)}}function _n(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var bn=0;function $n(e){var t=e.options;if(e.super){var n=$n(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function wn(e){this._init(e)}function Cn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Le(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)dn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)mn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach(function(e){o[e]=n[e]}),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=A({},o.options),i[r]=o,o}}function xn(e){return e&&(e.Ctor.options.name||e.tag)}function kn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function An(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=xn(o.componentOptions);s&&!t(s)&&On(n,a,r,i)}}}function On(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=bn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le($n(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Jt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=lt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Pt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Pt(t,e,n,r,i,!0)};var a=r&&r.data;Ce(t,"$attrs",a&&a.attrs||e,null,!0),Ce(t,"$listeners",n._parentListeners||e,null,!0)}(n),Yt(n,"beforeCreate"),function(e){var t=ct(e.$options.inject,e);t&&(be(!1),Object.keys(t).forEach(function(n){Ce(e,n,t[n])}),be(!0))}(n),vn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),Yt(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(wn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=xe,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){if(s(t))return _n(this,e,t,n);(n=n||{}).user=!0;var r=new fn(this,e,t,n);if(n.immediate){ue();try{t.call(this,r.value)}catch(e){Re(e,this,'callback for immediate watcher "'+r.expression+'"')}fe()}return function(){r.teardown()}}}(wn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this._events[e];if(t){t=t.length>1?k(t):t;for(var n=k(arguments,1),r='event handler for "'+e+'"',i=0,a=t.length;i<a;i++)He(t[i],this,n,this,r)}return this}}(wn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Zt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){Yt(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),Yt(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(wn),function(e){St(e.prototype),e.prototype.$nextTick=function(e){return Ye(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ft(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Ht=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Re(n,t,"render"),e=t._vnode}finally{Ht=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=de()),e.parent=i,e}}(wn);var Sn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Sn,exclude:Sn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)On(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",function(t){An(e,function(e){return kn(t,e)})}),this.$watch("exclude",function(t){An(e,function(e){return!kn(t,e)})})},render:function(){var e=this.$slots.default,t=zt(e),n=t&&t.componentOptions;if(n){var r=xn(n),i=this.include,a=this.exclude;if(i&&(!r||!kn(i,r))||a&&r&&kn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&On(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:A,mergeOptions:Le,defineReactive:Ce},e.set=xe,e.delete=ke,e.nextTick=Ye,e.observable=function(e){return we(e),e},e.options=Object.create(null),M.forEach(function(t){e.options[t+"s"]=Object.create(null)}),e.options._base=e,A(e.options.components,Tn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),Cn(e),function(e){M.forEach(function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}})}(e)}(wn),Object.defineProperty(wn.prototype,"$isServer",{get:te}),Object.defineProperty(wn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(wn,"FunctionalRenderContext",{value:Tt}),wn.version="2.6.12";var Nn=p("style,class"),En=p("input,textarea,option,select,progress"),Ln=p("contenteditable,draggable,spellcheck"),jn=p("events,caret,typing,plaintext-only"),Dn=function(e,t){return Rn(t)||"false"===t?"false":"contenteditable"===e&&jn(t)?t:"true"},Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Fn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Pn=function(e){return Fn(e)?e.slice(6,e.length):""},Rn=function(e){return null==e||!1===e};function Hn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Bn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Bn(t,r.data));return function(e,t){if(n(e)||n(t))return Un(e,zn(t));return""}(t.staticClass,t.class)}function Bn(e,t){return{staticClass:Un(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Un(e,t){return e?t?e+" "+t:e:t||""}function zn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=zn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Vn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),qn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Jn=function(e){return Kn(e)||qn(e)};var Wn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Gn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e?n:(t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(e,t){return document.createElementNS(Vn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),Xn={create:function(e,t){Yn(t)},update:function(e,t){e.data.ref!==t.data.ref&&(Yn(e,!0),Yn(t))},destroy:function(e){Yn(e,!0)}};function Yn(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var Qn=new pe("",{},[]),er=["create","activate","update","remove","destroy"];function tr(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Zn(i)&&Zn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function nr(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var rr={create:ir,update:ir,destroy:function(e){ir(e,Qn)}};function ir(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===Qn,o=t===Qn,s=or(e.data.directives,e.context),c=or(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,cr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(cr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)cr(l[n],"inserted",t,e)};a?it(t,"insert",f):f()}u.length&&it(t,"postpatch",function(){for(var n=0;n<u.length;n++)cr(u[n],"componentUpdated",t,e)});if(!a)for(n in s)c[n]||cr(s[n],"unbind",e,e,o)}(e,t)}var ar=Object.create(null);function or(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ar),i[sr(r)]=r,r.def=je(t.$options,"directives",r.name);return i}function sr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function cr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Re(r,n.context,"directive "+e.name+" "+t+" hook")}}var lr=[Xn,rr];function ur(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=A({},l)),l)o=l[a],c[a]!==o&&fr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&fr(s,"value",l.value),c)t(l[a])&&(Fn(a)?s.removeAttributeNS(In,Pn(a)):Ln(a)||s.removeAttribute(a))}}function fr(e,t,n,r){r||e.tagName.indexOf("-")>-1?pr(e,t,n):Mn(t)?Rn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Ln(t)?e.setAttribute(t,Dn(t,n)):Fn(t)?Rn(n)?e.removeAttributeNS(In,Pn(t)):e.setAttributeNS(In,t,n):pr(e,t,n)}function pr(e,t,n){if(Rn(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var dr={create:ur,update:ur};function vr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Hn(r),c=i._transitionClasses;n(c)&&(s=Un(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var hr,mr,yr,gr,_r,br,$r={create:vr,update:vr},wr=/[\w).+\-_$\]]/;function Cr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&wr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=xr(i,a[r]);return i}function xr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function kr(e,t){console.error("[Vue compiler]: "+e)}function Ar(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Or(e,t,n,r,i){(e.props||(e.props=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Sr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ir({name:t,value:n,dynamic:i},r)),e.plain=!1}function Tr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Ir({name:t,value:n},r))}function Nr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Ir({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Er(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Lr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Er("!",n,c)),i.once&&(delete i.once,n=Er("~",n,c)),i.passive&&(delete i.passive,n=Er("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Ir({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function jr(e,t,n){var r=Dr(e,":"+t)||Dr(e,"v-bind:"+t);if(null!=r)return Cr(r);if(!1!==n){var i=Dr(e,t);if(null!=i)return JSON.stringify(i)}}function Dr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Mr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Ir(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Fr(e,t,n){var r=n||{},i=r.number,a="$$v";r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var o=Pr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+o+"}"}}function Pr(e,t){var n=function(e){if(e=e.trim(),hr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<hr-1)return(gr=e.lastIndexOf("."))>-1?{exp:e.slice(0,gr),key:'"'+e.slice(gr+1)+'"'}:{exp:e,key:null};mr=e,gr=_r=br=0;for(;!Hr();)Br(yr=Rr())?zr(yr):91===yr&&Ur(yr);return{exp:e.slice(0,_r),key:e.slice(_r+1,br)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Rr(){return mr.charCodeAt(++gr)}function Hr(){return gr>=hr}function Br(e){return 34===e||39===e}function Ur(e){var t=1;for(_r=gr;!Hr();)if(Br(e=Rr()))zr(e);else if(91===e&&t++,93===e&&t--,0===t){br=gr;break}}function zr(e){for(var t=e;!Hr()&&(e=Rr())!==t;);}var Vr,Kr="__r",qr="__c";function Jr(e,t,n){var r=Vr;return function i(){null!==t.apply(null,arguments)&&Gr(e,i,n,r)}}var Wr=Ve&&!(X&&Number(X[1])<=53);function Zr(e,t,n,r){if(Wr){var i=on,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Vr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Gr(e,t,n,r){(r||Vr).removeEventListener(e,t._wrapper||t,n)}function Xr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Vr=r.elm,function(e){if(n(e[Kr])){var t=q?"change":"input";e[t]=[].concat(e[Kr],e[t]||[]),delete e[Kr]}n(e[qr])&&(e.change=[].concat(e[qr],e.change||[]),delete e[qr])}(i),rt(i,a,Zr,Gr,Jr,r.context),Vr=void 0}}var Yr,Qr={create:Xr,update:Xr};function ei(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ti(o,l)&&(o.value=l)}else if("innerHTML"===i&&qn(o.tagName)&&t(o.innerHTML)){(Yr=Yr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Yr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ti(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ni={create:ei,update:ei},ri=g(function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}}),t});function ii(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ri(e):e}var oi,si=/^--/,ci=/\s*!important$/,li=function(e,t,n){if(si.test(t))e.style.setProperty(t,n);else if(ci.test(n))e.style.setProperty(C(t),n.replace(ci,""),"important");else{var r=fi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},ui=["Webkit","Moz","ms"],fi=g(function(e){if(oi=oi||document.createElement("div").style,"filter"!==(e=b(e))&&e in oi)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<ui.length;n++){var r=ui[n]+t;if(r in oi)return r}});function pi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ii(i.data))&&A(r,n);(n=ii(e.data))&&A(r,n);for(var a=e;a=a.parent;)a.data&&(n=ii(a.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(o=d[s])!==f[s]&&li(c,s,null==o?"":o)}}var di={create:pi,update:pi},vi=/\s+/;function hi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,mi(e.name||"v")),A(t,e),t}return"string"==typeof e?mi(e):void 0}}var mi=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),yi="transition",gi="animation",_i="transition",bi="transitionend",$i="animation",wi="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(_i="WebkitTransition",bi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($i="WebkitAnimation",wi="webkitAnimationEnd"));var Ci=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function xi(e){Ci(function(){Ci(e)})}function ki(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(vi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Oi(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[_i+"Delay"]||"").split(", "),a=(r[_i+"Duration"]||"").split(", "),o=Ti(i,a),s=(r[$i+"Delay"]||"").split(", "),c=(r[$i+"Duration"]||"").split(", "),l=Ti(s,c),u=0,f=0;t===yi?o>0&&(n=yi,u=o,f=a.length):t===gi?l>0&&(n=gi,u=l,f=c.length):(u=Math.max(o,l),f=(n=u>0?o>l?yi:gi:null)?n===yi?a.length:c.length:0);var p=n===yi&&Si.test(r[_i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===yi?bi:wi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var Si=/\b(transform|all)(,|$)/;function Ti(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return Ni(t)+Ni(e[n])}))}function Ni(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ei(e){return"number"==typeof e&&!isNaN(e)}function Li(e){if(t(e))return!1;var r=e.fns;return n(r)?Li(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ji(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=hi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Li(L),R=i._enterCb=j(function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ki(i,S),ki(i,T),xi(function(){Ai(i,S),R.cancelled||(ki(i,N),P||(Ei(I)?setTimeout(R,I):Oi(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Di=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<er.length;++a)for(s[er[a]]=[],o=0;o<c.length;++o)n(c[o][er[a]])&&s[er[a]].push(c[o][er[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=he(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){for(var a,o=e;o.componentInstance;)if(o=o.componentInstance._vnode,n(a=o.data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](Qn,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(Yn(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](Qn,e);n(a=e.data.hook)&&(n(a.create)&&a.create(Qn,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Wt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&tr(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=he(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:tr(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):tr(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):tr(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):tr(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=nr(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):tr(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&et(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&tr(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Qn,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else Yn(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Gn,modules:[dr,$r,Qr,ni,di,U?{create:ji,activate:ji,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=hi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Li(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ki(i,l),ki(i,p),xi(function(){Ai(i,l),w.cancelled||(ki(i,u),b||(Ei($)?setTimeout(w,$):Oi(i,c,w)))})),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(lr)});J&&document.addEventListener("selectionchange",function(){var e=document.activeElement;e&&e.vmodel&&Ui(e,"input")});var Mi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?it(n,"postpatch",function(){Mi.componentUpdated(e,t,n)}):Ii(e,t,n.context),e._vOptions=[].map.call(e.options,Ri)):("textarea"===n.tag||Zn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Hi),e.addEventListener("compositionend",Bi),e.addEventListener("change",Bi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Ii(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ri);if(i.some(function(e,t){return!E(e,r[t])}))(e.multiple?t.value.some(function(e){return Pi(e,i)}):t.value!==t.oldValue&&Pi(t.value,i))&&Ui(e,"change")}}};function Ii(e,t,n){Fi(e,t),(q||W)&&setTimeout(function(){Fi(e,t)},0)}function Fi(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Ri(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Ri(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Pi(e,t){return t.every(function(t){return!E(t,e)})}function Ri(e){return"_value"in e?e._value:e.value}function Hi(e){e.target.composing=!0}function Bi(e){e.target.composing&&(e.target.composing=!1,Ui(e.target,"input"))}function Ui(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var zi=/\s+/;function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.add(t)}):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ki(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(zi).forEach(function(t){return e.classList.remove(t)}):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function qi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,Ji(e.name||"v")),A(t,e),t}return"string"==typeof e?Ji(e):void 0}}var Ji=g(function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}}),Wi=U&&!J,Zi="transition",Gi="animation",Xi="transition",Yi="transitionend",Qi="animation",ea="animationend";Wi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xi="WebkitTransition",Yi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Qi="WebkitAnimation",ea="webkitAnimationEnd"));var ta=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function na(e){ta(function(){ta(e)})}function ra(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),Vi(e,t))}function ia(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ki(e,t)}function aa(e,t,n){var r=sa(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Zi?Yi:ea,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout(function(){c<o&&l()},a+1),e.addEventListener(s,u)}var oa=/\b(transform|all)(,|$)/;function sa(e,t){var n,r=window.getComputedStyle(e),i=(r[Xi+"Delay"]||"").split(", "),a=(r[Xi+"Duration"]||"").split(", "),o=ca(i,a),s=(r[Qi+"Delay"]||"").split(", "),c=(r[Qi+"Duration"]||"").split(", "),l=ca(s,c),u=0,f=0;return t===Zi?o>0&&(n=Zi,u=o,f=a.length):t===Gi?l>0&&(n=Gi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Zi:Gi:null)?n===Zi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Zi&&oa.test(r[Xi+"Property"])}}function ca(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map(function(t,n){return la(t)+la(e[n])}))}function la(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ua(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=qi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,k=Wt,A=Wt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=pa(L),R=i._enterCb=j(function(){F&&(ia(i,N),ia(i,T)),R.cancelled?(F&&ia(i,S),M&&M(i)):D&&D(i),i._enterCb=null});e.data.show||it(e,"insert",function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)}),E&&E(i),F&&(ra(i,S),ra(i,T),na(function(){ia(i,S),R.cancelled||(ra(i,N),P||(fa(I)?setTimeout(R,I):aa(i,c,R)))})),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function fa(e){return"number"==typeof e&&!isNaN(e)}function pa(e){if(t(e))return!1;var r=e.fns;return n(r)?pa(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function da(e){return!e.componentInstance||e.data&&e.data.transition?e:da(e.componentInstance._vnode)}var va={model:Mi,show:{bind:function(e,t,n){var r=t.value,i=(n=da(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,ua(n,function(){e.style.display=a})):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=da(i)).data&&i.data.transition?(i.data.show=!0,o?ua(i,function(){e.style.display=e.__vOriginalDisplay}):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=qi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=pa(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j(function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ia(i,u),ia(i,p)),w.cancelled?(_&&ia(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null});y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ra(i,l),ra(i,p),na(function(){ia(i,l),w.cancelled||(ra(i,u),b||(fa($)?setTimeout(w,$):aa(i,c,w)))})),v&&v(i,w),_||b||w())}}(i,function(){e.style.display="none"})):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ha={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ma(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ma(zt(t.children)):e}function ya(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var r in i)t[b(r)]=i[r];return t}function ga(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var _a=function(e){return e.tag||Ut(e)},ba=function(e){return"show"===e.name},$a={name:"transition",props:ha,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(_a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ma(a);if(!o)return a;if(this._leaving)return ga(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=ya(this),l=this._vnode,u=ma(l);if(o.data.directives&&o.data.directives.some(ba)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Ut(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,it(f,"afterLeave",function(){t._leaving=!1,t.$forceUpdate()}),ga(e,a);if("in-out"===r){if(Ut(o))return l;var p,d=function(){p()};it(c,"afterEnter",d),it(c,"enterCancelled",d),it(f,"delayLeave",function(e){p=e})}}return a}}},wa=A({tag:String,moveClass:String},ha);function Ca(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function xa(e){e.data.newPos=e.elm.getBoundingClientRect()}function ka(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete wa.mode;var Aa={Transition:$a,TransitionGroup:{props:wa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Zt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=ya(this),s=0;s<i.length;s++){(u=i[s]).tag&&null!=u.key&&0!==String(u.key).indexOf("__vlist")&&(a.push(u),n[u.key]=u,(u.data||(u.data={})).transition=o)}if(r){var c=[],l=[];for(s=0;s<r.length;s++){var u;(u=r[s]).data.transition=o,u.data.pos=u.elm.getBoundingClientRect(),n[u.key]?c.push(u):l.push(u)}this.kept=e(t,null,c),this.removed=l}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Ca),e.forEach(xa),e.forEach(ka),this._reflow=document.body.offsetHeight,e.forEach(function(e){if(e.data.moved){var n=e.elm,r=n.style;ra(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Yi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Yi,e),n._moveCb=null,ia(n,t))})}}))},methods:{hasMove:function(e,t){if(!Wi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach(function(e){Ki(n,e)}),Vi(n,t),n.style.display="none",this.$el.appendChild(n);var r=sa(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};wn.config.mustUseProp=function(e,t,n){return"value"===n&&En(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},wn.config.isReservedTag=Jn,wn.config.isReservedAttr=Nn,wn.config.getTagNamespace=function(e){return qn(e)?"svg":"math"===e?"math":void 0},wn.config.isUnknownElement=function(e){if(!U)return!0;if(Jn(e))return!1;if(e=e.toLowerCase(),null!=Wn[e])return Wn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Wn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Wn[e]=/HTMLUnknownElement/.test(t.toString())},A(wn.options.directives,va),A(wn.options.components,Aa),wn.prototype.__patch__=U?Di:S,wn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=de),Yt(e,"beforeMount"),r=function(){e._update(e._render(),n)},new fn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&Yt(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,Yt(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout(function(){F.devtools&&ne&&ne.emit("init",wn)},0);var Oa=p("input,textarea,option,select,progress"),Sa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ta=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Na(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Ea=/\{\{((?:.|\r?\n)+?)\}\}/g,La=/[-.*+?^${}()|[\]\/\\]/g,ja=g(function(e){var t=e[0].replace(La,"\\$&"),n=e[1].replace(La,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")});var Da={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Dr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=jr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Ma,Ia={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Dr(e,"style");n&&(e.staticStyle=JSON.stringify(ri(n)));var r=jr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Fa=function(e){return(Ma=Ma||document.createElement("div")).innerHTML=e,Ma.textContent},Pa=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ra=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ha=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ba="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Ua="((?:"+Ba+"\\:)?"+Ba+")",za=new RegExp("^<"+Ua),Va=/^\s*(\/?)>/,Ka=new RegExp("^<\\/"+Ua+"[^>]*>"),qa=/^<!DOCTYPE [^>]+>/i,Ja=/^<!\--/,Wa=/^<!\[/,Za=p("script,style,textarea",!0),Ga={},Xa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ya=/&(?:lt|gt|quot|amp|#39);/g,Qa=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,eo=p("pre,textarea",!0),to=function(e,t){return e&&eo(e)&&"\n"===t[0]};function no(e,t){var n=t?Qa:Ya;return e.replace(n,function(e){return Xa[e]})}function ro(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0,l=function(){if(n=e,r&&Za(r)){var l=0,p=r.toLowerCase(),d=Ga[p]||(Ga[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));w=e.replace(d,function(e,n,r){return l=r.length,Za(p)||"noscript"===p||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),to(p,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""});c+=e.length-w.length,e=w,f(p,c-l,c)}else{var v=e.indexOf("<");if(0===v){if(Ja.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),u(h+3),"continue"}if(Wa.test(e)){var m=e.indexOf("]>");if(m>=0)return u(m+2),"continue"}var y=e.match(qa);if(y)return u(y[0].length),"continue";var g=e.match(Ka);if(g){var _=c;return u(g[0].length),f(g[1],_,c),"continue"}var b=function(){var t=e.match(za);if(t){var n={tagName:t[1],attrs:[],start:c};u(t[0].length);for(var r=void 0,i=void 0;!(r=e.match(Va))&&(i=e.match(Ha)||e.match(Ra));)i.start=c,u(i[0].length),i.end=c,n.attrs.push(i);if(r)return n.unarySlash=r[1],u(r[0].length),n.end=c,n}}();if(b)return function(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Pa(n)&&f(r),s(n)&&r===n&&f(n));for(var l=o(n)||!!c,u=e.attrs.length,p=new Array(u),d=0;d<u;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===n&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:no(h,m)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:p,start:e.start,end:e.end}),r=n);t.start&&t.start(n,p,l,e.start,e.end)}(b),to(b.tagName,e)&&u(1),"continue"}var $=void 0,w=void 0,C=void 0;if(v>=0){for(w=e.slice(v);!(Ka.test(w)||za.test(w)||Ja.test(w)||Wa.test(w)||(C=w.indexOf("<",1))<0);)v+=C,w=e.slice(v);$=e.substring(0,v)}v<0&&($=e),$&&u($.length),t.chars&&$&&t.chars($,c-$.length,c)}if(e===n)return t.chars&&t.chars(e),"break"};e;){if("break"===l())break}function u(t){c+=t,e=e.substring(t)}function f(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}f()}var io,ao,oo,so,co,lo,uo,fo,po=/^@|^v-on:/,vo=/^v-|^@|^:|^#/,ho=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,mo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,yo=/^\(|\)$/g,go=/^\[.*\]$/,_o=/:(.*)$/,bo=/^:|^\.|^v-bind:/,$o=/\.[^.\]]+(?=[^\]]*$)/g,wo=/^v-slot(:|$)|^#/,Co=/[\r\n]/,xo=/[ \f\t\r\n]+/g,ko=g(Fa),Ao="_empty_";function Oo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Do(t),rawAttrsMap:{},parent:n,children:[]}}function So(e,t){io=t.warn||kr,lo=t.isPreTag||T,uo=t.mustUseProp||T,fo=t.getTagNamespace||T,t.isReservedTag,oo=Ar(t.modules,"transformNode"),so=Ar(t.modules,"preTransformNode"),co=Ar(t.modules,"postTransformNode"),ao=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=To(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Eo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Eo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter(function(e){return!e.slotScope}),u(e),e.pre&&(s=!1),lo(e.tag)&&(c=!1);for(var f=0;f<co.length;f++)co[f](e,t)}function u(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return ro(e,{warn:io,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||fo(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Mo.test(r.name)||(r.name=r.name.replace(Io,""),t.push(r))}return t}(a));var d,v=Oo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<so.length;h++)v=so[h](v,t)||v;s||(!function(e){null!=Dr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),lo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(No(v),function(e){var t=Dr(e,"v-if");if(t)e.if=t,Eo(e,{exp:t,block:e});else{null!=Dr(e,"v-else")&&(e.else=!0);var n=Dr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Dr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):l.length?o?"condense"===o&&Co.test(e)?"":" ":a?" ":"":""){c||"condense"!==o||(e=e.replace(xo," "));var u=void 0,f=void 0;!s&&" "!==e&&(u=function(e,t){var n=t?ja(t):Ea;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Cr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,ao))?f={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&l.length&&" "===l[l.length-1].text||(f={type:3,text:e}),f&&l.push(f)}}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function To(e,t){var n,r;(r=jr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=jr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dr(e,"scope"),e.slotScope=t||Dr(e,"slot-scope")):(t=Dr(e,"slot-scope"))&&(e.slotScope=t);var n=jr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Sr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Mr(e,wo);if(r){var i=Lo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Ao}}else{var r=Mr(e,wo);if(r){var s=e.scopedSlots||(e.scopedSlots={}),c=Lo(r),l=c.name,o=c.dynamic,u=s[l]=Oo("template",[],e);u.slotTarget=l,u.slotTargetDynamic=o,u.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=u,!0}),u.slotScope=r.value||Ao,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=jr(e,"name"))}(e),function(e){var t;(t=jr(e,"is"))&&(e.component=t);null!=Dr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<oo.length;i++)e=oo[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,vo.test(r))if(e.hasBindings=!0,(o=jo(r.replace(vo,"")))&&(r=r.replace($o,"")),bo.test(r))r=r.replace(bo,""),a=Cr(a),(c=go.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Pr(a,"$event"),c?Lr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Lr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Lr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&uo(e.tag,e.attrsMap.type,r)?Or(e,r,a,l[t],c):Sr(e,r,a,l[t],c);else if(po.test(r))r=r.replace(po,""),(c=go.test(r))&&(r=r.slice(1,-1)),Lr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(vo,"")).match(_o),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),go.test(f)&&(f=f.slice(1,-1),c=!0)),Nr(e,r,i,a,f,c,o,l[t])}else Sr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&uo(e.tag,e.attrsMap.type,r)&&Or(e,r,"true",l[t])}(e),e}function No(e){var t;if(t=Dr(e,"v-for")){var n=function(e){var t=e.match(ho);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(yo,""),i=r.match(mo);i?(n.alias=r.replace(mo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function Eo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Lo(e){var t=e.name.replace(wo,"");return t||"#"!==e.name[0]&&(t="default"),go.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function jo(e){var t=e.match($o);if(t){var n={};return t.forEach(function(e){n[e.slice(1)]=!0}),n}}function Do(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Mo=/^xmlns:NS\d+/,Io=/^NS\d+:/;function Fo(e){return Oo(e.tag,e.attrsList.slice(),e.parent)}var Po=[Da,Ia,{preTransformNode:function(e,t){if("input"===e.tag){var n=e.attrsMap;if(!n["v-model"])return;var r=void 0;if((n[":type"]||n["v-bind:type"])&&(r=jr(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Dr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Dr(e,"v-else",!0),s=Dr(e,"v-else-if",!0),c=Fo(e);No(c),Tr(c,"type","checkbox"),To(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+a,Eo(c,{exp:c.if,block:c});var l=Fo(e);Dr(l,"v-for",!0),Tr(l,"type","radio"),To(l,t),Eo(c,{exp:"("+r+")==='radio'"+a,block:l});var u=Fo(e);return Dr(u,"v-for",!0),Tr(u,":type",r),To(u,t),Eo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}],Ro="__r";var Ho,Bo,Uo={expectHTML:!0,modules:Po,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Fr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Pr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Lr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null",a=jr(e,"true-value")||"true",o=jr(e,"false-value")||"false";Or(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Lr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Pr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Pr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Pr(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=jr(e,"value")||"null";Or(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Lr(e,"change",Pr(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?Ro:"input",u="$event.target.value";s&&(u="$event.target.value.trim()"),o&&(u="_n("+u+")");var f=Pr(t,u);c&&(f="if($event.target.composing)return;"+f),Or(e,"value","("+t+")"),Lr(e,l,f,null,!0),(s||o)&&Lr(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Fr(e,r,i),!1;return!0},text:function(e,t){t.value&&Or(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Or(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Oa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Sa(e)||Ta(e)},getTagNamespace:function(e){return Ta(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Po)},zo=g(function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))});function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,function e(t){t.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(t);if(1===t.type){if(!Bo(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(var n=0,r=t.children.length;n<r;n++){var i=t.children[n];e(i),i.static||(t.static=!1)}if(t.ifConditions)for(var n=1,r=t.ifConditions.length;n<r;n++){var a=t.ifConditions[n].block;e(a),a.static||(t.static=!1)}}}(e),function e(t,n){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=n),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(var r=0,i=t.children.length;r<i;r++)e(t.children[r],n||!!t.for);if(t.ifConditions)for(var r=1,i=t.ifConditions.length;r<i;r++)e(t.ifConditions[r].block,n)}}(e,!1))}var Ko=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,qo=/\([^)]*?\);*$/,Jo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Go=function(e){return"if("+e+")return null;"},Xo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Go("$event.target !== $event.currentTarget"),ctrl:Go("!$event.ctrlKey"),shift:Go("!$event.shiftKey"),alt:Go("!$event.altKey"),meta:Go("!$event.metaKey"),left:Go("'button' in $event && $event.button !== 0"),middle:Go("'button' in $event && $event.button !== 1"),right:Go("'button' in $event && $event.button !== 2")};function Yo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Qo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Qo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return Qo(e)}).join(",")+"]";var t=Jo.test(e.value),n=Ko.test(e.value),r=Jo.test(e.value.replace(qo,""));if(e.modifiers){var i="",a="",o=[],s=function(t){if(Xo[t])a+=Xo[t],Wo[t]&&o.push(t);else if("exact"===t){var n=e.modifiers;a+=Go(["ctrl","shift","alt","meta"].filter(function(e){return!n[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else o.push(t)};for(var c in e.modifiers)s(c);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(es).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function es(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Wo[e],r=Zo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var ts={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},ns=function(){return function(e){this.options=e,this.warn=e.warn||kr,this.transforms=Ar(e.modules,"transformCode"),this.dataGenFns=Ar(e.modules,"genData"),this.directives=A(A({},ts),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function rs(e,t){var n=new ns(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":is(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function is(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return as(e,t);if(e.once&&!e.onceProcessed)return os(e,t);if(e.for&&!e.forProcessed)return cs(e,t);if(e.if&&!e.ifProcessed)return ss(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ps(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?hs((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}})):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n=void 0;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ps(t,n,!0);return"_c("+e+","+ls(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ls(e,t));var i=e.inlineTemplate?null:ps(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ps(e,t)||"void 0"}function as(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+is(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function os(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ss(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+is(e,t)+","+t.onceId+++","+n+")":is(e,t)}return as(e,t)}function ss(e,t,n,r){return e.ifProcessed=!0,function e(t,n,r,i){if(!t.length)return i||"_e()";var a=t.shift();return a.exp?"("+a.exp+")?"+o(a.block)+":"+e(t,n,r,i):""+o(a.block);function o(e){return r?r(e,n):e.once?os(e,n):is(e,n)}}(e.ifConditions.slice(),t,n,r)}function cs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||is)(e,t)+"})"}function ls(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+hs(e.attrs)+","),e.props&&(n+="domProps:"+hs(e.props)+","),e.events&&(n+=Yo(e.events,!1)+","),e.nativeEvents&&(n+=Yo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some(function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||us(n)}),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Ao||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map(function(e){return fs(t[e],n)}).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=rs(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+hs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function us(e){return 1===e.type&&("slot"===e.tag||e.children.some(us))}function fs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ss(e,t,fs,"null");if(e.for&&!e.forProcessed)return cs(e,t,fs);var r=e.slotScope===Ao?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ps(e,t)||"undefined")+":undefined":ps(e,t)||"undefined":is(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ps(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||is)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ds(i)||i.ifConditions&&i.ifConditions.some(function(e){return ds(e.block)})){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||vs;return"["+a.map(function(e){return l(e,t)}).join(",")+"]"+(c?","+c:"")}}function ds(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function vs(e,t){return 1===e.type?is(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):"_v("+(2===(n=e).type?n.expression:ms(JSON.stringify(n.text)))+")";var n,r}function hs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ms(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ms(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ys(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function gs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=ys(o.render,c),s.staticRenderFns=o.staticRenderFns.map(function(e){return ys(e,c)}),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var _s,bs,$s=(_s=function(e,t){var n=So(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=rs(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=_s(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:gs(t)}})(Uo).compileToFunctions;function ws(e){return(bs=bs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',bs.innerHTML.indexOf("&#10;")>0}var Cs=!!U&&ws(!1),xs=!!U&&ws(!0),ks=g(function(e){var t=Na(e);return t&&t.innerHTML}),As=wn.prototype.$mount;return wn.prototype.$mount=function(e,t){if((e=e&&Na(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ks(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=$s(r,{outputSourceRange:!1,shouldDecodeNewlines:Cs,shouldDecodeNewlinesForHref:xs,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return As.call(this,e,t)},wn.compile=$s,wn});
\ No newline at end of file
+/*!
+ * Vue.js v2.6.12
+ * (c) 2014-2021 Evan You
+ * Released under the MIT License.
+ */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,(function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,C=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function A(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function k(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&k(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every((function(e,n){return E(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return E(e[n],t[n])}))}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function H(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var B=new RegExp("[^"+P.source+".$_\\d]");var U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),q=z&&window.navigator.userAgent.toLowerCase(),J=q&&/msie|trident/.test(q),W=q&&q.indexOf("msie 9.0")>0,Z=q&&q.indexOf("edge/")>0;q&&q.indexOf("android");var G=q&&/iphone|ipad|ipod|ios/.test(q)||"ios"===K;q&&/chrome\/\d+/.test(q),q&&/phantomjs/.test(q);var X,Y=q&&q.match(/firefox\/(\d+)/),Q={}.watch,ee=!1;if(z)try{var te={};Object.defineProperty(te,"passive",{get:function(){ee=!0}}),window.addEventListener("test-passive",null,te)}catch(e){}var ne=function(){return void 0===X&&(X=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},re=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ie(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,oe="undefined"!=typeof Symbol&&ie(Symbol)&&"undefined"!=typeof Reflect&&ie(Reflect.ownKeys);ae="undefined"!=typeof Set&&ie(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var se=S,ce=0,le=function(){this.id=ce++,this.subs=[]};le.prototype.addSub=function(e){this.subs.push(e)},le.prototype.removeSub=function(e){h(this.subs,e)},le.prototype.depend=function(){le.target&&le.target.addDep(this)},le.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},le.target=null;var ue=[];function fe(e){ue.push(e),le.target=e}function pe(){ue.pop(),le.target=ue[ue.length-1]}var de=function(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ve={child:{configurable:!0}};ve.child.get=function(){return this.componentInstance},Object.defineProperties(de.prototype,ve);var he=function(e){void 0===e&&(e="");var t=new de;return t.text=e,t.isComment=!0,t};function me(e){return new de(void 0,void 0,void 0,String(e))}function ye(e){var t=new de(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ge=Array.prototype,_e=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ge[e];H(_e,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,a=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&o.observeArray(i),o.dep.notify(),a}))}));var be=Object.getOwnPropertyNames(_e),$e=!0;function we(e){$e=e}var Ce=function(e){this.value=e,this.dep=new le,this.vmCount=0,H(e,"__ob__",this),Array.isArray(e)?(U?function(e,t){e.__proto__=t}(e,_e):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];H(e,a,t[a])}}(e,_e,be),this.observeArray(e)):this.walk(e)};function xe(e,t){var n;if(a(e)&&!(e instanceof de))return y(e,"__ob__")&&e.__ob__ instanceof Ce?n=e.__ob__:$e&&!ne()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new Ce(e)),t&&n&&n.vmCount++,n}function Ae(e,t,n,r,i){var a=new le,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&xe(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return le.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&Se(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&xe(t),a.notify())}})}}function ke(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ae(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Oe(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Se(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Se(t)}Ce.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ae(e,t[n])},Ce.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)xe(e[t])};var Te=F.optionMergeStrategies;function Ne(e,t){if(!t)return e;for(var n,r,i,a=oe?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Ne(r,i):ke(e,n,i));return e}function Ee(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Ne(r,i):i}:t?e?function(){return Ne("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Le(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function je(e,t,n,r){var i=Object.create(e||null);return t?k(i,t):i}Te.data=function(e,t,n){return n?Ee(e,t,n):t&&"function"!=typeof t?e:Ee(e,t)},I.forEach((function(e){Te[e]=Le})),M.forEach((function(e){Te[e+"s"]=je})),Te.watch=function(e,t,n,r){if(e===Q&&(e=void 0),t===Q&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in k(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Te.props=Te.methods=Te.inject=Te.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return k(i,e),t&&k(i,t),i},Te.provide=Ee;var De=function(e,t){return void 0===t?e:t};function Me(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?k({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Me(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Me(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Te[r]||De;o[r]=i(e[r],t[r],n,r)}return o}function Ie(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function Fe(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Be(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Be(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Re(t.type)?r.call(e):r}(r,i,e);var l=$e;we(!0),xe(o),we(l)}return o}var Pe=/^\s*function (\w+)/;function Re(e){var t=e&&e.toString().match(Pe);return t?t[1]:""}function He(e,t){return Re(e)===Re(t)}function Be(e,t){if(!Array.isArray(t))return He(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(He(t[n],e))return n;return-1}function Ue(e,t,n){fe();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Ve(e,r,"errorCaptured hook")}}Ve(e,t,n)}finally{pe()}}function ze(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch((function(e){return Ue(e,r,i+" (Promise/async)")})),a._handled=!0)}catch(e){Ue(e,r,i)}return a}function Ve(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ke(t)}Ke(e)}function Ke(e,t,n){if(!z&&!V||"undefined"==typeof console)throw e;console.error(e)}var qe,Je=!1,We=[],Ze=!1;function Ge(){Ze=!1;var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&ie(Promise)){var Xe=Promise.resolve();qe=function(){Xe.then(Ge),G&&setTimeout(S)},Je=!0}else if(J||"undefined"==typeof MutationObserver||!ie(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())qe="undefined"!=typeof setImmediate&&ie(setImmediate)?function(){setImmediate(Ge)}:function(){setTimeout(Ge,0)};else{var Ye=1,Qe=new MutationObserver(Ge),et=document.createTextNode(String(Ye));Qe.observe(et,{characterData:!0}),qe=function(){Ye=(Ye+1)%2,et.data=String(Ye)},Je=!0}function tt(e,t){var n;if(We.push((function(){if(e)try{e.call(t)}catch(e){Ue(e,t,"nextTick")}else n&&n(t)})),Ze||(Ze=!0,qe()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var nt=new ae;function rt(e){it(e,nt),nt.clear()}function it(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!a(e)||Object.isFrozen(e)||e instanceof de)){if(e.__ob__){var o=e.__ob__.dep.id;if(t.has(o))return;t.add(o)}if(i)for(n=e.length;n--;)it(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)it(e[r[n]],t)}}var at=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function ot(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return ze(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)ze(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function st(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=at(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=ot(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=at(c)).name,n[c],f.capture)}function ct(e,i,a){var o;e instanceof de&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=ot([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=ot([s,c]),o.merged=!0,e[i]=o}function lt(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ut(e){return i(e)?[me(e)]:Array.isArray(e)?pt(e):void 0}function ft(e){return n(e)&&n(e.text)&&!1===e.isComment}function pt(e,a){var o,s,c,l,u=[];for(o=0;o<e.length;o++)t(s=e[o])||"boolean"==typeof s||(l=u[c=u.length-1],Array.isArray(s)?s.length>0&&(ft((s=pt(s,(a||"")+"_"+o))[0])&&ft(l)&&(u[c]=me(l.text+s[0].text),s.shift()),u.push.apply(u,s)):i(s)?ft(l)?u[c]=me(l.text+s):""!==s&&u.push(me(s)):ft(s)&&ft(l)?u[c]=me(l.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(a)&&(s.key="__vlist"+a+"_"+o+"__"),u.push(s)));return u}function dt(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function vt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ht)&&delete n[l];return n}function ht(e){return e.isComment&&!e.asyncFactory||" "===e.text}function mt(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=yt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=gt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),H(i,"$stable",o),H(i,"$key",s),H(i,"$hasNormal",a),i}function yt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ut(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function gt(e,t){return function(){return e[t]}}function _t(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(oe&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function bt(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=k(k({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function $t(e){return Ie(this.$options,"filters",e)||N}function wt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function Ct(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?wt(i,r):a?wt(a,e):r?C(r)!==t:void 0}function xt(e,t,n,r,i){if(n)if(a(n)){var o;Array.isArray(n)&&(n=O(n));var s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function At(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||Ot(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function kt(e,t,n){return Ot(e,"__once__"+t+(n?"_"+n:""),!0),e}function Ot(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&St(e[r],t+"_"+r,n);else St(e,t,n)}function St(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function Tt(e,t){if(t)if(s(t)){var n=e.on=e.on?k({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function Nt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?Nt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function Et(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Lt(e,t){return"string"==typeof e?t+e:e}function jt(e){e._o=kt,e._n=f,e._s=u,e._l=_t,e._t=bt,e._q=E,e._i=L,e._m=At,e._f=$t,e._k=Ct,e._b=xt,e._v=me,e._e=he,e._u=Nt,e._g=Tt,e._d=Et,e._p=Lt}function Dt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=dt(l.inject,a),this.slots=function(){return c.$slots||mt(t.scopedSlots,c.$slots=vt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return mt(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=mt(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Bt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Bt(s,e,t,n,r,f)}}function Mt(e,t,n,r,i){var a=ye(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function It(e,t){for(var n in t)e[b(n)]=t[n]}jt(Dt.prototype);var Ft={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ft.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Yt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){we(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=Fe(d,v,n,t)}we(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Xt(t,r,h),l&&(t.$slots=vt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,rn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,on.push(t)):tn(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?nn(t,!0):t.$destroy())}},Pt=Object.keys(Ft);function Rt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Vt;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",(function(){return h(s,o)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j((function(t){e.resolved=Kt(t,i),c?s.length=0:p(!0)})),v=j((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Kt(m.error,i)),n(m.loading)&&(e.loadingComp=Kt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout((function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=he();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},kn(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);lt(o,c,l,u,!0)||lt(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=Fe(u,l,r||e);else n(i.attrs)&&It(c,i.attrs),n(i.props)&&It(c,i.props);var f=new Dt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof de)return Mt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ut(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Mt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Pt.length;n++){var r=Pt[n],i=t[r],a=Ft[r];i===a||i&&i._merged||(t[r]=i?Ht(a,i):a)}}(o);var y=i.options.name||u;return new de("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Ht(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Bt(e,t,o,s,c,l){return(Array.isArray(o)||i(o))&&(c=s,s=o,o=void 0),r(l)&&(c=2),function(e,t,r,i,o){if(n(r)&&n(r.__ob__))return he();n(r)&&n(r.is)&&(t=r.is);if(!t)return he();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===o?i=ut(i):1===o&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var l;c=e.$vnode&&e.$vnode.ns||F.getTagNamespace(t),s=F.isReservedTag(t)?new de(F.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(l=Ie(e.$options,"components",t))?new de(t,r,i,void 0,void 0,e):Rt(l,r,e,i,t)}else s=Rt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Ut(s,c),n(r)&&function(e){a(e.style)&&rt(e.style);a(e.class)&&rt(e.class)}(r),s):he()}(e,t,o,s,c)}function Ut(e,i,a){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,a=!0),n(e.children))for(var o=0,s=e.children.length;o<s;o++){var c=e.children[o];n(c.tag)&&(t(c.ns)||r(a)&&"svg"!==c.tag)&&Ut(c,i,a)}}var zt,Vt=null;function Kt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function qt(e){return e.isComment&&e.asyncFactory}function Jt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||qt(r)))return r}}function Wt(e,t){zt.$on(e,t)}function Zt(e,t){zt.$off(e,t)}function Gt(e,t){var n=zt;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Xt(e,t,n){zt=e,st(t,n||{},Wt,Zt,Gt,e),zt=void 0}var Yt=null;function Qt(e){var t=Yt;return Yt=e,function(){Yt=t}}function en(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function tn(e,t){if(t){if(e._directInactive=!1,en(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);rn(e,"activated")}}function nn(e,t){if(!(t&&(e._directInactive=!0,en(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)nn(e.$children[n]);rn(e,"deactivated")}}function rn(e,t){fe();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)ze(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),pe()}var an=[],on=[],sn={},cn=!1,ln=!1,un=0;var fn=0,pn=Date.now;if(z&&!J){var dn=window.performance;dn&&"function"==typeof dn.now&&pn()>document.createEvent("Event").timeStamp&&(pn=function(){return dn.now()})}function vn(){var e,t;for(fn=pn(),ln=!0,an.sort((function(e,t){return e.id-t.id})),un=0;un<an.length;un++)(e=an[un]).before&&e.before(),t=e.id,sn[t]=null,e.run();var n=on.slice(),r=an.slice();un=an.length=on.length=0,sn={},cn=ln=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,tn(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&rn(r,"updated")}}(r),re&&F.devtools&&re.emit("flush")}var hn=0,mn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++hn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ae,this.newDepIds=new ae,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!B.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};mn.prototype.get=function(){var e;fe(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Ue(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rt(e),pe(),this.cleanupDeps()}return e},mn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},mn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},mn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==sn[t]){if(sn[t]=!0,ln){for(var n=an.length-1;n>un&&an[n].id>e.id;)n--;an.splice(n+1,0,e)}else an.push(e);cn||(cn=!0,tt(vn))}}(this)},mn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Ue(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},mn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},mn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},mn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var yn={enumerable:!0,configurable:!0,get:S,set:S};function gn(e,t,n){yn.get=function(){return this[t][n]},yn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,yn)}function _n(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&we(!1);var a=function(a){i.push(a);var o=Fe(a,t,n,e);Ae(r,a,o),a in e||gn(e,"_props",a)};for(var o in t)a(o);we(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){fe();try{return e.call(t,t)}catch(e){return Ue(e,t,"data()"),{}}finally{pe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||R(a)||gn(e,"_data",a)}xe(t,!0)}(e):xe(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=ne();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new mn(e,o||S,S,bn)),i in e||$n(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Q&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)xn(e,n,r[i]);else xn(e,n,r)}}(e,t.watch)}var bn={lazy:!0};function $n(e,t,n){var r=!ne();"function"==typeof n?(yn.get=r?wn(t):Cn(n),yn.set=S):(yn.get=n.get?r&&!1!==n.cache?wn(t):Cn(n.get):S,yn.set=n.set||S),Object.defineProperty(e,t,yn)}function wn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),le.target&&t.depend(),t.value}}function Cn(e){return function(){return e.call(this,this)}}function xn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var An=0;function kn(e){var t=e.options;if(e.super){var n=kn(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&k(e.extendOptions,r),(t=e.options=Me(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function On(e){this._init(e)}function Sn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Me(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)gn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)$n(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach((function(e){o[e]=n[e]})),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=k({},o.options),i[r]=o,o}}function Tn(e){return e&&(e.Ctor.options.name||e.tag)}function Nn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function En(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=Tn(o.componentOptions);s&&!t(s)&&Ln(n,a,r,i)}}}function Ln(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=An++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Me(kn(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Xt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=vt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Bt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Bt(t,e,n,r,i,!0)};var a=r&&r.data;Ae(t,"$attrs",a&&a.attrs||e,null,!0),Ae(t,"$listeners",n._parentListeners||e,null,!0)}(n),rn(n,"beforeCreate"),function(e){var t=dt(e.$options.inject,e);t&&(we(!1),Object.keys(t).forEach((function(n){Ae(e,n,t[n])})),we(!0))}(n),_n(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),rn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(On),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Oe,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return xn(r,e,t,n);(n=n||{}).user=!0;var i=new mn(r,e,t,n);if(n.immediate){fe();try{t.call(r,i.value)}catch(e){Ue(e,r,'callback for immediate watcher "'+i.expression+'"')}pe()}return function(){i.teardown()}}}(On),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),i='event handler for "'+e+'"',a=0,o=n.length;a<o;a++)ze(n[a],t,r,t,i)}return t}}(On),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Qt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){rn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),rn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(On),function(e){jt(e.prototype),e.prototype.$nextTick=function(e){return tt(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=mt(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Vt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Ue(n,t,"render"),e=t._vnode}finally{Vt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof de||(e=he()),e.parent=i,e}}(On);var jn=[String,RegExp,Array],Dn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)Ln(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){En(e,(function(e){return Nn(t,e)}))})),this.$watch("exclude",(function(t){En(e,(function(e){return!Nn(t,e)}))}))},render:function(){var e=this.$slots.default,t=Jt(e),n=t&&t.componentOptions;if(n){var r=Tn(n),i=this.include,a=this.exclude;if(i&&(!r||!Nn(i,r))||a&&r&&Nn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&Ln(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:se,extend:k,mergeOptions:Me,defineReactive:Ae},e.set=ke,e.delete=Oe,e.nextTick=tt,e.observable=function(e){return xe(e),e},e.options=Object.create(null),M.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,k(e.options.components,Dn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Me(this.options,e),this}}(e),Sn(e),function(e){M.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(On),Object.defineProperty(On.prototype,"$isServer",{get:ne}),Object.defineProperty(On.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(On,"FunctionalRenderContext",{value:Dt}),On.version="2.6.12";var Mn=p("style,class"),In=p("input,textarea,option,select,progress"),Fn=p("contenteditable,draggable,spellcheck"),Pn=p("events,caret,typing,plaintext-only"),Rn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Hn="http://www.w3.org/1999/xlink",Bn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Un=function(e){return Bn(e)?e.slice(6,e.length):""},zn=function(e){return null==e||!1===e};function Vn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Kn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Kn(t,r.data));return function(e,t){if(n(e)||n(t))return qn(e,Jn(t));return""}(t.staticClass,t.class)}function Kn(e,t){return{staticClass:qn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function qn(e,t){return e?t?e+" "+t:e:t||""}function Jn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=Jn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Zn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Gn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(e){return Zn(e)||Gn(e)};var Yn=Object.create(null);var Qn=p("text,number,password,search,email,tel,url");var er=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Wn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),tr={create:function(e,t){nr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(nr(e,!0),nr(t))},destroy:function(e){nr(e,!0)}};function nr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var rr=new de("",{},[]),ir=["create","activate","update","remove","destroy"];function ar(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Qn(i)&&Qn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var sr={create:cr,update:cr,destroy:function(e){cr(e,rr)}};function cr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===rr,o=t===rr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,pr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(pr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)pr(l[n],"inserted",t,e)};a?ct(t,"insert",f):f()}u.length&&ct(t,"postpatch",(function(){for(var n=0;n<u.length;n++)pr(u[n],"componentUpdated",t,e)}));if(!a)for(n in s)c[n]||pr(s[n],"unbind",e,e,o)}(e,t)}var lr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=lr),i[fr(r)]=r,r.def=Ie(t.$options,"directives",r.name);return i}function fr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function pr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Ue(r,n.context,"directive "+e.name+" "+t+" hook")}}var dr=[tr,sr];function vr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=k({},l)),l)o=l[a],c[a]!==o&&hr(s,a,o,r.data.pre);for(a in(J||Z)&&l.value!==c.value&&hr(s,"value",l.value),c)t(l[a])&&(Bn(a)?s.removeAttributeNS(Hn,Un(a)):Fn(a)||s.removeAttribute(a))}}function hr(e,t,n,r){r||e.tagName.indexOf("-")>-1?mr(e,t,n):Rn(t)?zn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Fn(t)?e.setAttribute(t,function(e,t){return zn(t)||"false"===t?"false":"contenteditable"===e&&Pn(t)?t:"true"}(t,n)):Bn(t)?zn(n)?e.removeAttributeNS(Hn,Un(t)):e.setAttributeNS(Hn,t,n):mr(e,t,n)}function mr(e,t,n){if(zn(n))e.removeAttribute(t);else{if(J&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var yr={create:vr,update:vr};function gr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Vn(r),c=i._transitionClasses;n(c)&&(s=qn(s,Jn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var _r,br,$r,wr,Cr,xr,Ar={create:gr,update:gr},kr=/[\w).+\-_$\]]/;function Or(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=Sr(i,a[r]);return i}function Sr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Tr(e,t){console.error("[Vue compiler]: "+e)}function Nr(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Er(e,t,n,r,i){(e.props||(e.props=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Lr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Hr({name:t,value:n},r))}function Dr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Hr({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Mr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Ir(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Mr("!",n,c)),i.once&&(delete i.once,n=Mr("~",n,c)),i.passive&&(delete i.passive,n=Mr("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Hr({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function Fr(e,t,n){var r=Pr(e,":"+t)||Pr(e,"v-bind:"+t);if(null!=r)return Or(r);if(!1!==n){var i=Pr(e,t);if(null!=i)return JSON.stringify(i)}}function Pr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Rr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Hr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Br(e,t,n){var r=n||{},i=r.number,a="$$v",o=a;r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var s=Ur(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Ur(e,t){var n=function(e){if(e=e.trim(),_r=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<_r-1)return(wr=e.lastIndexOf("."))>-1?{exp:e.slice(0,wr),key:'"'+e.slice(wr+1)+'"'}:{exp:e,key:null};br=e,wr=Cr=xr=0;for(;!Vr();)Kr($r=zr())?Jr($r):91===$r&&qr($r);return{exp:e.slice(0,Cr),key:e.slice(Cr+1,xr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function zr(){return br.charCodeAt(++wr)}function Vr(){return wr>=_r}function Kr(e){return 34===e||39===e}function qr(e){var t=1;for(Cr=wr;!Vr();)if(Kr(e=zr()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){xr=wr;break}}function Jr(e){for(var t=e;!Vr()&&(e=zr())!==t;);}var Wr;function Zr(e,t,n){var r=Wr;return function i(){var a=t.apply(null,arguments);null!==a&&Yr(e,i,n,r)}}var Gr=Je&&!(Y&&Number(Y[1])<=53);function Xr(e,t,n,r){if(Gr){var i=fn,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Wr.addEventListener(e,t,ee?{capture:n,passive:r}:n)}function Yr(e,t,n,r){(r||Wr).removeEventListener(e,t._wrapper||t,n)}function Qr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Wr=r.elm,function(e){if(n(e.__r)){var t=J?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),st(i,a,Xr,Yr,Zr,r.context),Wr=void 0}}var ei,ti={create:Qr,update:Qr};function ni(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=k({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ri(o,l)&&(o.value=l)}else if("innerHTML"===i&&Gn(o.tagName)&&t(o.innerHTML)){(ei=ei||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=ei.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ri(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ii={create:ni,update:ni},ai=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function oi(e){var t=si(e.style);return e.staticStyle?k(e.staticStyle,t):t}function si(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ci,li=/^--/,ui=/\s*!important$/,fi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(ui.test(n))e.style.setProperty(C(t),n.replace(ui,""),"important");else{var r=di(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},pi=["Webkit","Moz","ms"],di=g((function(e){if(ci=ci||document.createElement("div").style,"filter"!==(e=b(e))&&e in ci)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<pi.length;n++){var r=pi[n]+t;if(r in ci)return r}}));function vi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=si(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?k({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=oi(i.data))&&k(r,n);(n=oi(e.data))&&k(r,n);for(var a=e;a=a.parent;)a.data&&(n=oi(a.data))&&k(r,n);return r}(r,!0);for(s in f)t(d[s])&&fi(c,s,"");for(s in d)(o=d[s])!==f[s]&&fi(c,s,null==o?"":o)}}var hi={create:vi,update:vi},mi=/\s+/;function yi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,gi(e.name||"v")),k(t,e),t}return"string"==typeof e?gi(e):void 0}}var gi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),_i="transition",bi="animation",$i="transition",wi="transitionend",Ci="animation",xi="animationend";z&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&($i="WebkitTransition",wi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ci="WebkitAnimation",xi="webkitAnimationEnd"));var Ai=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function ki(e){Ai((function(){Ai(e)}))}function Oi(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Si(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Ti(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[$i+"Delay"]||"").split(", "),a=(r[$i+"Duration"]||"").split(", "),o=Ei(i,a),s=(r[Ci+"Delay"]||"").split(", "),c=(r[Ci+"Duration"]||"").split(", "),l=Ei(s,c),u=0,f=0;t===_i?o>0&&(n=_i,u=o,f=a.length):t===bi?l>0&&(n=bi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?_i:bi:null)?n===_i?a.length:c.length:0;var p=n===_i&&Ni.test(r[$i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===_i?wi:xi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var Ni=/\b(transform|all)(,|$)/;function Ei(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Li(t)+Li(e[n])})))}function Li(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ji(e){return"number"==typeof e&&!isNaN(e)}function Di(e){if(t(e))return!1;var r=e.fns;return n(r)?Di(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Mi(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=yi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Yt,k=Yt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!W,P=Di(L),R=i._enterCb=j((function(){F&&(Si(i,N),Si(i,T)),R.cancelled?(F&&Si(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||ct(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(Oi(i,S),Oi(i,T),ki((function(){Si(i,S),R.cancelled||(Oi(i,N),P||(ji(I)?setTimeout(R,I):Ti(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Ii=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<ir.length;++a)for(s[ir[a]]=[],o=0;o<c.length;++o)n(c[o][ir[a]])&&s[ir[a]].push(c[o][ir[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=ye(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){var a,o=e;for(;o.componentInstance;)if(n(a=(o=o.componentInstance._vnode).data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](rr,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(nr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](rr,e);n(a=e.data.hook)&&(n(a.create)&&a.create(rr,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Yt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&ar(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=ye(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ar(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):ar(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):ar(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):ar(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):ar(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function A(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var k=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(t,i);break}!v&&c.class&&rt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ar(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return A(i,p,!0),e;c=e,e=new de(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](rr,y);var C=y.data.hook.insert;if(C.merged)for(var k=1;k<C.fns.length;k++)C.fns[k]()}else nr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return A(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:er,modules:[yr,Ar,ti,ii,hi,z?{create:Mi,activate:Mi,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=yi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!W,b=Di(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Si(i,u),Si(i,p)),w.cancelled?(_&&Si(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Oi(i,l),Oi(i,p),ki((function(){Si(i,l),w.cancelled||(Oi(i,u),b||(ji($)?setTimeout(w,$):Ti(i,c,w)))}))),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(dr)});W&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Vi(e,"input")}));var Fi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ct(n,"postpatch",(function(){Fi.componentUpdated(e,t,n)})):Pi(e,t,n.context),e._vOptions=[].map.call(e.options,Bi)):("textarea"===n.tag||Qn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Ui),e.addEventListener("compositionend",zi),e.addEventListener("change",zi),W&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Pi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Bi);if(i.some((function(e,t){return!E(e,r[t])})))(e.multiple?t.value.some((function(e){return Hi(e,i)})):t.value!==t.oldValue&&Hi(t.value,i))&&Vi(e,"change")}}};function Pi(e,t,n){Ri(e,t),(J||Z)&&setTimeout((function(){Ri(e,t)}),0)}function Ri(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Bi(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Bi(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Hi(e,t){return t.every((function(t){return!E(t,e)}))}function Bi(e){return"_value"in e?e._value:e.value}function Ui(e){e.target.composing=!0}function zi(e){e.target.composing&&(e.target.composing=!1,Vi(e.target,"input"))}function Vi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var Ki=/\s+/;function qi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ki).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ji(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ki).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function Wi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,Zi(e.name||"v")),k(t,e),t}return"string"==typeof e?Zi(e):void 0}}var Zi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),Gi=z&&!W,Xi="transition",Yi="animation",Qi="transition",ea="transitionend",ta="animation",na="animationend";Gi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Qi="WebkitTransition",ea="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(ta="WebkitAnimation",na="webkitAnimationEnd"));var ra=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function ia(e){ra((function(){ra(e)}))}function aa(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),qi(e,t))}function oa(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ji(e,t)}function sa(e,t,n){var r=la(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Xi?ea:na,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var ca=/\b(transform|all)(,|$)/;function la(e,t){var n,r=window.getComputedStyle(e),i=(r[Qi+"Delay"]||"").split(", "),a=(r[Qi+"Duration"]||"").split(", "),o=ua(i,a),s=(r[ta+"Delay"]||"").split(", "),c=(r[ta+"Duration"]||"").split(", "),l=ua(s,c),u=0,f=0;return t===Xi?o>0&&(n=Xi,u=o,f=a.length):t===Yi?l>0&&(n=Yi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Xi:Yi:null)?n===Xi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Xi&&ca.test(r[Qi+"Property"])}}function ua(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return fa(t)+fa(e[n])})))}function fa(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function pa(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=Wi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Yt,k=Yt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!W,P=va(L),R=i._enterCb=j((function(){F&&(oa(i,N),oa(i,T)),R.cancelled?(F&&oa(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||ct(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(aa(i,S),aa(i,T),ia((function(){oa(i,S),R.cancelled||(aa(i,N),P||(da(I)?setTimeout(R,I):sa(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function da(e){return"number"==typeof e&&!isNaN(e)}function va(e){if(t(e))return!1;var r=e.fns;return n(r)?va(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ha(e){return!e.componentInstance||e.data&&e.data.transition?e:ha(e.componentInstance._vnode)}var ma={model:Fi,show:{bind:function(e,t,n){var r=t.value,i=(n=ha(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,pa(n,(function(){e.style.display=a}))):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=ha(i)).data&&i.data.transition?(i.data.show=!0,o?pa(i,(function(){e.style.display=e.__vOriginalDisplay})):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=Wi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!W,b=va(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(oa(i,u),oa(i,p)),w.cancelled?(_&&oa(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(aa(i,l),aa(i,p),ia((function(){oa(i,l),w.cancelled||(aa(i,u),b||(da($)?setTimeout(w,$):sa(i,c,w)))}))),v&&v(i,w),_||b||w())}}(i,(function(){e.style.display="none"}))):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ya={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ga(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ga(Jt(t.children)):e}function _a(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var a in i)t[b(a)]=i[a];return t}function ba(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var $a=function(e){return e.tag||qt(e)},wa=function(e){return"show"===e.name},Ca={name:"transition",props:ya,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter($a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ga(a);if(!o)return a;if(this._leaving)return ba(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=_a(this),l=this._vnode,u=ga(l);if(o.data.directives&&o.data.directives.some(wa)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!qt(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=k({},c);if("out-in"===r)return this._leaving=!0,ct(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),ba(e,a);if("in-out"===r){if(qt(o))return l;var p,d=function(){p()};ct(c,"afterEnter",d),ct(c,"enterCancelled",d),ct(f,"delayLeave",(function(e){p=e}))}}return a}}},xa=k({tag:String,moveClass:String},ya);function Aa(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function ka(e){e.data.newPos=e.elm.getBoundingClientRect()}function Oa(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete xa.mode;var Sa={Transition:Ca,TransitionGroup:{props:xa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Qt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=_a(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(a.push(c),n[c.key]=c,(c.data||(c.data={})).transition=o)}if(r){for(var l=[],u=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=o,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?l.push(p):u.push(p)}this.kept=e(t,null,l),this.removed=u}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Aa),e.forEach(ka),e.forEach(Oa),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;aa(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(ea,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(ea,e),n._moveCb=null,oa(n,t))})}})))},methods:{hasMove:function(e,t){if(!Gi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){Ji(n,e)})),qi(n,t),n.style.display="none",this.$el.appendChild(n);var r=la(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};On.config.mustUseProp=function(e,t,n){return"value"===n&&In(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},On.config.isReservedTag=Xn,On.config.isReservedAttr=Mn,On.config.getTagNamespace=function(e){return Gn(e)?"svg":"math"===e?"math":void 0},On.config.isUnknownElement=function(e){if(!z)return!0;if(Xn(e))return!1;if(e=e.toLowerCase(),null!=Yn[e])return Yn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Yn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Yn[e]=/HTMLUnknownElement/.test(t.toString())},k(On.options.directives,ma),k(On.options.components,Sa),On.prototype.__patch__=z?Ii:S,On.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=he),rn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new mn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&rn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,rn(e,"mounted")),e}(this,e=e&&z?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},z&&setTimeout((function(){F.devtools&&re&&re.emit("init",On)}),0);var Ta=p("input,textarea,option,select,progress"),Na=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ea=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function La(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var ja=/\{\{((?:.|\r?\n)+?)\}\}/g,Da=/[-.*+?^${}()|[\]\/\\]/g,Ma=g((function(e){var t=e[0].replace(Da,"\\$&"),n=e[1].replace(Da,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var Ia={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Pr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Fr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Fa,Pa={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Pr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Fr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Ra=function(e){return(Fa=Fa||document.createElement("div")).innerHTML=e,Fa.textContent},Ha=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ba=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ua=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,za="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Va="((?:"+za+"\\:)?"+za+")",Ka=new RegExp("^<"+Va),qa=/^\s*(\/?)>/,Ja=new RegExp("^<\\/"+Va+"[^>]*>"),Wa=/^<!DOCTYPE [^>]+>/i,Za=/^<!\--/,Ga=/^<!\[/,Xa=p("script,style,textarea",!0),Ya={},Qa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},eo=/&(?:lt|gt|quot|amp|#39);/g,to=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,no=p("pre,textarea",!0),ro=function(e,t){return e&&no(e)&&"\n"===t[0]};function io(e,t){var n=t?to:eo;return e.replace(n,(function(e){return Qa[e]}))}var ao,oo,so,co,lo,uo,fo,po,vo=/^@|^v-on:/,ho=/^v-|^@|^:|^#/,mo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,go=/^\(|\)$/g,_o=/^\[.*\]$/,bo=/:(.*)$/,$o=/^:|^\.|^v-bind:/,wo=/\.[^.\]]+(?=[^\]]*$)/g,Co=/^v-slot(:|$)|^#/,xo=/[\r\n]/,Ao=/[ \f\t\r\n]+/g,ko=g(Ra),Oo="_empty_";function So(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Mo(t),rawAttrsMap:{},parent:n,children:[]}}function To(e,t){ao=t.warn||Tr,uo=t.isPreTag||T,fo=t.mustUseProp||T,po=t.getTagNamespace||T,t.isReservedTag,so=Nr(t.modules,"transformNode"),co=Nr(t.modules,"preTransformNode"),lo=Nr(t.modules,"postTransformNode"),oo=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=No(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Lo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Lo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter((function(e){return!e.slotScope})),u(e),e.pre&&(s=!1),uo(e.tag)&&(c=!1);for(var f=0;f<lo.length;f++)lo[f](e,t)}function u(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&Xa(r)){var l=0,u=r.toLowerCase(),f=Ya[u]||(Ya[u]=new RegExp("([\\s\\S]*?)(</"+u+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return l=r.length,Xa(u)||"noscript"===u||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),ro(u,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,k(u,c-l,c)}else{var d=e.indexOf("<");if(0===d){if(Za.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(Ga.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(Wa);if(m){C(m[0].length);continue}var y=e.match(Ja);if(y){var g=c;C(y[0].length),k(y[1],g,c);continue}var _=x();if(_){A(_),ro(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Ja.test($)||Ka.test($)||Za.test($)||Ga.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Ka);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(qa))&&(r=e.match(Ua)||e.match(Ba));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function A(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Ha(n)&&k(r),s(n)&&r===n&&k(n));for(var l=o(n)||!!c,u=e.attrs.length,f=new Array(u),p=0;p<u;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:io(v,h)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,l,e.start,e.end)}function k(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}k()}(e,{warn:ao,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||po(e);J&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Io.test(r.name)||(r.name=r.name.replace(Fo,""),t.push(r))}return t}(a));var d,v=So(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||ne()||(v.forbidden=!0);for(var h=0;h<co.length;h++)v=co[h](v,t)||v;s||(!function(e){null!=Pr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),uo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Eo(v),function(e){var t=Pr(e,"v-if");if(t)e.if=t,Lo(e,{exp:t,block:e});else{null!=Pr(e,"v-else")&&(e.else=!0);var n=Pr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Pr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l,u,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):f.length?o?"condense"===o&&xo.test(e)?"":" ":a?" ":"":"")c||"condense"!==o||(e=e.replace(Ao," ")),!s&&" "!==e&&(l=function(e,t){var n=t?Ma(t):ja;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Or(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,oo))?u={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(u={type:3,text:e}),u&&f.push(u)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function No(e,t){var n,r;(r=Fr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Fr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Pr(e,"scope"),e.slotScope=t||Pr(e,"slot-scope")):(t=Pr(e,"slot-scope"))&&(e.slotScope=t);var n=Fr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Lr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Rr(e,Co);if(r){var i=jo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Oo}}else{var s=Rr(e,Co);if(s){var c=e.scopedSlots||(e.scopedSlots={}),l=jo(s),u=l.name,f=l.dynamic,p=c[u]=So("template",[],e);p.slotTarget=u,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||Oo,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Fr(e,"name"))}(e),function(e){var t;(t=Fr(e,"is"))&&(e.component=t);null!=Pr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<so.length;i++)e=so[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,ho.test(r))if(e.hasBindings=!0,(o=Do(r.replace(ho,"")))&&(r=r.replace(wo,"")),$o.test(r))r=r.replace($o,""),a=Or(a),(c=_o.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Ur(a,"$event"),c?Ir(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Ir(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Ir(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&fo(e.tag,e.attrsMap.type,r)?Er(e,r,a,l[t],c):Lr(e,r,a,l[t],c);else if(vo.test(r))r=r.replace(vo,""),(c=_o.test(r))&&(r=r.slice(1,-1)),Ir(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(ho,"")).match(bo),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),_o.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,a,f,c,o,l[t])}else Lr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&fo(e.tag,e.attrsMap.type,r)&&Er(e,r,"true",l[t])}(e),e}function Eo(e){var t;if(t=Pr(e,"v-for")){var n=function(e){var t=e.match(mo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(go,""),i=r.match(yo);i?(n.alias=r.replace(yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&k(e,n)}}function Lo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function jo(e){var t=e.name.replace(Co,"");return t||"#"!==e.name[0]&&(t="default"),_o.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Do(e){var t=e.match(wo);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function Mo(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Io=/^xmlns:NS\d+/,Fo=/^NS\d+:/;function Po(e){return So(e.tag,e.attrsList.slice(),e.parent)}var Ro=[Ia,Pa,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Fr(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Pr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Pr(e,"v-else",!0),s=Pr(e,"v-else-if",!0),c=Po(e);Eo(c),jr(c,"type","checkbox"),No(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+a,Lo(c,{exp:c.if,block:c});var l=Po(e);Pr(l,"v-for",!0),jr(l,"type","radio"),No(l,t),Lo(c,{exp:"("+n+")==='radio'"+a,block:l});var u=Po(e);return Pr(u,"v-for",!0),jr(u,":type",n),No(u,t),Lo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}];var Ho,Bo,Uo={expectHTML:!0,modules:Ro,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Br(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Ur(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Ir(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null",a=Fr(e,"true-value")||"true",o=Fr(e,"false-value")||"false";Er(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Ir(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Ur(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Ur(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Ur(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Ir(e,"change",Ur(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?"__r":"input",u="$event.target.value";s&&(u="$event.target.value.trim()");o&&(u="_n("+u+")");var f=Ur(t,u);c&&(f="if($event.target.composing)return;"+f);Er(e,"value","("+t+")"),Ir(e,l,f,null,!0),(s||o)&&Ir(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Br(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Ta(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Na(e)||Ea(e)},getTagNamespace:function(e){return Ea(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(Ro)},zo=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,Ko(e),qo(e,!1))}function Ko(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(e),1===e.type){if(!Bo(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Ko(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++){var o=e.ifConditions[i].block;Ko(o),o.static||(e.static=!1)}}}function qo(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)qo(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++)qo(e.ifConditions[i].block,t)}}var Jo=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Wo=/\([^)]*?\);*$/,Zo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Go={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Xo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Yo=function(e){return"if("+e+")return null;"},Qo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Yo("$event.target !== $event.currentTarget"),ctrl:Yo("!$event.ctrlKey"),shift:Yo("!$event.shiftKey"),alt:Yo("!$event.altKey"),meta:Yo("!$event.metaKey"),left:Yo("'button' in $event && $event.button !== 0"),middle:Yo("'button' in $event && $event.button !== 1"),right:Yo("'button' in $event && $event.button !== 2")};function es(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=ts(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function ts(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return ts(e)})).join(",")+"]";var t=Zo.test(e.value),n=Jo.test(e.value),r=Zo.test(e.value.replace(Wo,""));if(e.modifiers){var i="",a="",o=[];for(var s in e.modifiers)if(Qo[s])a+=Qo[s],Go[s]&&o.push(s);else if("exact"===s){var c=e.modifiers;a+=Yo(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else o.push(s);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(ns).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function ns(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Go[e],r=Xo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var rs={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},is=function(e){this.options=e,this.warn=e.warn||Tr,this.transforms=Nr(e.modules,"transformCode"),this.dataGenFns=Nr(e.modules,"genData"),this.directives=k(k({},rs),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function as(e,t){var n=new is(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":os(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function os(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return ss(e,t);if(e.once&&!e.onceProcessed)return cs(e,t);if(e.for&&!e.forProcessed)return fs(e,t);if(e.if&&!e.ifProcessed)return ls(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=hs(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?gs((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:hs(t,n,!0);return"_c("+e+","+ps(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ps(e,t));var i=e.inlineTemplate?null:hs(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return hs(e,t)||"void 0"}function ss(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+os(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function cs(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ls(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+os(e,t)+","+t.onceId+++","+n+")":os(e,t)}return ss(e,t)}function ls(e,t,n,r){return e.ifProcessed=!0,us(e.ifConditions.slice(),t,n,r)}function us(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+a(i.block)+":"+us(e,t,n,r):""+a(i.block);function a(e){return n?n(e,t):e.once?cs(e,t):os(e,t)}}function fs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||os)(e,t)+"})"}function ps(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+gs(e.attrs)+","),e.props&&(n+="domProps:"+gs(e.props)+","),e.events&&(n+=es(e.events,!1)+","),e.nativeEvents&&(n+=es(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||ds(n)})),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Oo||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map((function(e){return vs(t[e],n)})).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=as(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+gs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function ds(e){return 1===e.type&&("slot"===e.tag||e.children.some(ds))}function vs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ls(e,t,vs,"null");if(e.for&&!e.forProcessed)return fs(e,t,vs);var r=e.slotScope===Oo?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(hs(e,t)||"undefined")+":undefined":hs(e,t)||"undefined":os(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function hs(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||os)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ms(i)||i.ifConditions&&i.ifConditions.some((function(e){return ms(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||ys;return"["+a.map((function(e){return l(e,t)})).join(",")+"]"+(c?","+c:"")}}function ms(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function ys(e,t){return 1===e.type?os(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:_s(JSON.stringify(e.text)))+")"}(e)}function gs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=_s(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function _s(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function bs(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function $s(e){var t=Object.create(null);return function(n,r,i){(r=k({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=bs(o.render,c),s.staticRenderFns=o.staticRenderFns.map((function(e){return bs(e,c)})),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ws,Cs,xs=(ws=function(e,t){var n=To(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=as(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=k(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=ws(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:$s(t)}})(Uo).compileToFunctions;function As(e){return(Cs=Cs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',Cs.innerHTML.indexOf("&#10;")>0}var ks=!!z&&As(!1),Os=!!z&&As(!0),Ss=g((function(e){var t=La(e);return t&&t.innerHTML})),Ts=On.prototype.$mount;return On.prototype.$mount=function(e,t){if((e=e&&La(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=Ss(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=xs(r,{outputSourceRange:!1,shouldDecodeNewlines:ks,shouldDecodeNewlinesForHref:Os,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return Ts.call(this,e,t)},On.compile=xs,On}));
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index 340cf3e33de..abf8b710ea3 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -420,7 +420,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -463,7 +463,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get: function get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -509,19 +509,20 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
+    _Set = /*@__PURE__*/(function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function (key) {
+        Set.prototype.has = function has (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function (key) {
+        Set.prototype.add = function add (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function () {
+        Set.prototype.clear = function clear () {
             this.set = Object.create(null);
         };
+
         return Set;
     }());
 }
@@ -531,22 +532,20 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
     warn = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
+        if (hasConsole && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -569,10 +568,10 @@ var formatComponentName;
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
     };
-    var repeat_1 = function (str, n) {
+    var repeat = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -606,15 +605,13 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
         }
     };
 }
@@ -624,37 +621,34 @@ var uid$2 = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid$2++;
-        this.subs = [];
+var Dep = function Dep() {
+    this.id = uid$2++;
+    this.subs = [];
+};
+Dep.prototype.addSub = function addSub (sub) {
+    this.subs.push(sub);
+};
+Dep.prototype.removeSub = function removeSub (sub) {
+    remove$2(this.subs, sub);
+};
+Dep.prototype.depend = function depend () {
+    if (Dep.target) {
+        Dep.target.addDep(this);
     }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove$2(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort(function (a, b) { return a.id - b.id; });
-        }
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
+};
+Dep.prototype.notify = function notify () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (!config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
+};
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -669,45 +663,43 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
+};
+
+var prototypeAccessors = { child: { configurable: true } };
+// DEPRECATED: alias for componentInstance for backwards compat.
+/* istanbul ignore next */
+prototypeAccessors.child.get = function () {
+    return this.componentInstance;
+};
+
+Object.defineProperties( VNode.prototype, prototypeAccessors );
 var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
+    if ( text === void 0 ) text = '';
+
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -761,12 +753,9 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -802,46 +791,43 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
         }
         else {
-            this.walk(value);
+            copyAugment(value, arrayMethods, arrayKeys);
         }
+        this.observeArray(value);
     }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
+    else {
+        this.walk(value);
+    }
+};
+/**
+ * Walk through all properties and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ */
+Observer.prototype.walk = function walk (obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i]);
+    }
+};
+/**
+ * Observe a list of Array items.
+ */
+Observer.prototype.observeArray = function observeArray (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
+};
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -951,7 +937,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
  */
 function set(target, key, val) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -982,7 +968,7 @@ function set(target, key, val) {
  */
 function del(target, key) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -1009,7 +995,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1184,14 +1170,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1229,7 +1215,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
         warn('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1273,7 +1259,7 @@ function normalizeProps(options, vm) {
     }
     else {
         warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
+            "but got " + (toRawType(props)) + ".", vm);
     }
     options.props = res;
 }
@@ -1300,7 +1286,7 @@ function normalizeInject(options, vm) {
     }
     else {
         warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
+            "but got " + (toRawType(inject)) + ".", vm);
     }
 }
 /**
@@ -1320,7 +1306,7 @@ function normalizeDirectives$1(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+            "but got " + (toRawType(value)) + ".", vm);
     }
 }
 /**
@@ -1556,7 +1542,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1564,24 +1550,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
+        message += " with value " + (styleValue(value, expectedType));
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
+        message += "with value " + (styleValue(value, receivedType)) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return "\"" + value + "\"";
+        return ("\"" + value + "\"");
     }
     else if (type === 'Number') {
-        return "" + Number(value);
+        return ("" + (Number(value)));
     }
     else {
-        return "" + value;
+        return ("" + value);
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1589,12 +1575,9 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var arguments$1 = arguments;
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments$1[_i];
-    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1660,7 +1643,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1703,9 +1686,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p_1 = Promise.resolve();
+    var p = Promise.resolve();
     timerFunc = function () {
-        p_1.then(flushCallbacks);
+        p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1724,15 +1707,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
+    var counter = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
     timerFunc = function () {
-        counter_1 = (counter_1 + 1) % 2;
-        textNode_1.data = String(counter_1);
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
     };
     isUsingMicroTask = true;
 }
@@ -1780,31 +1763,31 @@ function nextTick(cb, ctx) {
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 {
-    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent_1 = function (target, key) {
+    var warnNonPresent = function (target, key) {
         warn("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix_1 = function (target, key) {
+    var warnReservedPrefix = function (target, key) {
         warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                     return false;
                 }
                 else {
@@ -1814,38 +1797,38 @@ var initProxy;
             },
         });
     }
-    var hasHandler_1 = {
-        has: function (target, key) {
+    var hasHandler = {
+        has: function has(target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals_1(key) ||
+            var isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler_1 = {
-        get: function (target, key) {
+    var getHandler = {
+        get: function get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy_1) {
+        if (hasProxy) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1895,18 +1878,18 @@ function _traverse(val, seen) {
 var mark;
 var measure;
 {
-    var perf_1 = inBrowser && window.performance;
+    var perf = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) {
-        mark = function (tag) { return perf_1.mark(tag); };
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf_1.measure(name, startTag, endTag);
-            perf_1.clearMarks(startTag);
-            perf_1.clearMarks(endTag);
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1952,7 +1935,7 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -2017,7 +2000,8 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs, props = data.props;
+    var attrs = data.attrs;
+    var props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2027,11 +2011,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2105,7 +2089,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2166,7 +2150,7 @@ function initInjections(vm) {
                 defineReactive(vm, key, result[key], function () {
                     warn("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        ("injection being mutated: \"" + key + "\""), vm);
+                        "injection being mutated: \"" + key + "\"", vm);
                 });
             }
         });
@@ -2203,7 +2187,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn("Injection \"" + key + "\" not found", vm);
+                    warn(("Injection \"" + key + "\" not found"), vm);
                 }
             }
         }
@@ -2231,8 +2215,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2245,9 +2229,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
         }
     }
     return slots;
@@ -2280,16 +2264,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2446,8 +2430,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash = void 0;
-            var _loop_1 = function (key) {
+            var hash;
+            var loop = function ( key ) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2464,15 +2448,14 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
+                        on[("update:" + key)] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-            for (var key in value) {
-                _loop_1(key);
-            }
+
+            for (var key in value) loop( key );
         }
     }
     return data;
@@ -2492,7 +2475,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, "__static__" + index, false);
+    markStatic(tree, ("__static__" + index), false);
     return tree;
 }
 /**
@@ -2500,14 +2483,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
             }
         }
     }
@@ -2573,7 +2556,7 @@ function bindDynamicKeys(baseObj, values) {
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
         }
     }
     return baseObj;
@@ -2606,7 +2589,8 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
+    var this$1 = this;
+
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2633,14 +2617,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
         }
-        return _this.$slots;
+        return this$1.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function () {
+        get: function get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2663,9 +2647,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) {
-            return createElement$1(contextVm, a, b, c, d, needNormalization);
-        };
+        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2721,7 +2703,7 @@ function mergeProps(to, from) {
 
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
+    init: function init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2734,7 +2716,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function (oldVnode, vnode) {
+    prepatch: function prepatch(oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2743,8 +2725,9 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2763,7 +2746,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2789,7 +2772,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn("Invalid Component definition: " + String(Ctor), context);
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
         }
         return;
     }
@@ -2847,7 +2830,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2929,7 +2912,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2964,14 +2947,14 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor = void 0;
+        var Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3074,7 +3057,9 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3157,24 +3142,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners_1 = (factory.owners = [owner]);
-        var sync_1 = true;
-        var timerLoading_1 = null;
-        var timerTimeout_1 = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-        var forceRender_1 = function (renderCompleted) {
-            for (var i = 0, l = owners_1.length; i < l; i++) {
-                owners_1[i].$forceUpdate();
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners_1.length = 0;
-                if (timerLoading_1 !== null) {
-                    clearTimeout(timerLoading_1);
-                    timerLoading_1 = null;
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
                 }
-                if (timerTimeout_1 !== null) {
-                    clearTimeout(timerTimeout_1);
-                    timerTimeout_1 = null;
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
                 }
             }
         };
@@ -3183,63 +3168,63 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync_1) {
-                forceRender_1(true);
+            if (!sync) {
+                forceRender(true);
             }
             else {
-                owners_1.length = 0;
+                owners.length = 0;
             }
         });
-        var reject_1 = once(function (reason) {
-            warn("Failed to resolve async component: " + String(factory) +
-                    (reason ? "\nReason: " + reason : ''));
+        var reject = once(function (reason) {
+            warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender_1(true);
+                forceRender(true);
             }
         });
-        var res_1 = factory(resolve, reject_1);
-        if (isObject(res_1)) {
-            if (isPromise(res_1)) {
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res_1.then(resolve, reject_1);
+                    res.then(resolve, reject);
                 }
             }
-            else if (isPromise(res_1.component)) {
-                res_1.component.then(resolve, reject_1);
-                if (isDef(res_1.error)) {
-                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
                 }
-                if (isDef(res_1.loading)) {
-                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                    if (res_1.delay === 0) {
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading_1 = setTimeout(function () {
-                            timerLoading_1 = null;
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender_1(false);
+                                forceRender(false);
                             }
-                        }, res_1.delay || 200);
+                        }, res.delay || 200);
                     }
                 }
-                if (isDef(res_1.timeout)) {
+                if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout_1 = setTimeout(function () {
-                        timerTimeout_1 = null;
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject_1("timeout (" + res_1.timeout + "ms)"
+                            reject(("timeout (" + (res.timeout) + "ms)")
                                 );
                         }
-                    }, res_1.timeout);
+                    }, res.timeout);
                 }
             }
         }
-        sync_1 = false;
+        sync = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3329,8 +3314,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                vm.$off(event[i_1], fn);
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
             }
             return vm;
         }
@@ -3361,10 +3346,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
             }
         }
         var cbs = vm._events[event];
@@ -3525,11 +3510,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure("vue " + name + " render", startTag, endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure("vue " + name + " patch", startTag, endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
         };
     }
     else {
@@ -3541,7 +3526,7 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function () {
+        before: function before() {
             if (vm._isMounted && !vm._isDestroyed) {
                 callHook$1(vm, 'beforeUpdate');
             }
@@ -3710,15 +3695,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance_1.now(); };
+        getNow = function () { return performance.now(); };
     }
 }
 /**
@@ -3753,7 +3738,7 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn('You may have an infinite update loop ' +
                     (watcher.user
-                        ? "in watcher with expression \"" + watcher.expression + "\""
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3837,194 +3822,191 @@ var uid$1 = 0;
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = /** @class */ (function () {
-    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$1; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        expOrFn.toString() ;
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            warn("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
         }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression =
-            expOrFn.toString() ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
+    }
+    this.value = this.lazy ? undefined : this.get();
+};
+/**
+ * Evaluate the getter, and re-collect dependencies.
+ */
+Watcher.prototype.get = function get () {
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
+    }
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
         }
         else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn("Failed watching path: \"" + expOrFn + "\" " +
-                        'Watcher only accepts simple dot-delimited paths. ' +
-                        'For full control, use a function instead.', vm);
-            }
+            throw e;
         }
-        this.value = this.lazy ? undefined : this.get();
     }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    Watcher.prototype.get = function () {
-        pushTarget(this);
-        var value;
-        var vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
         }
-        catch (e) {
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
+};
+/**
+ * Add a dependency to this directive.
+ */
+Watcher.prototype.addDep = function addDep (dep) {
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
+};
+/**
+ * Clean up for dependency collection.
+ */
+Watcher.prototype.cleanupDeps = function cleanupDeps () {
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
+};
+/**
+ * Subscriber interface.
+ * Will be called when a dependency changes.
+ */
+Watcher.prototype.update = function update () {
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
+};
+/**
+ * Scheduler job interface.
+ * Will be called by the scheduler.
+ */
+Watcher.prototype.run = function run () {
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
             if (this.user) {
-                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
             }
             else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    };
-    /**
-     * Add a dependency to this directive.
-     */
-    Watcher.prototype.addDep = function (dep) {
-        var id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
+                this.cb.call(this.vm, value, oldValue);
             }
         }
-    };
-    /**
-     * Clean up for dependency collection.
-     */
-    Watcher.prototype.cleanupDeps = function () {
-        var i = this.deps.length;
-        while (i--) {
-            var dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        var tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    };
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    Watcher.prototype.update = function () {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    };
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    Watcher.prototype.run = function () {
-        if (this.active) {
-            var value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                var oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    try {
-                        this.cb.call(this.vm, value, oldValue);
-                    }
-                    catch (e) {
-                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                    }
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
+    }
+};
+/**
+ * Evaluate the value of the watcher.
+ * This only gets called for lazy watchers.
+ */
+Watcher.prototype.evaluate = function evaluate () {
+    this.value = this.get();
+    this.dirty = false;
+};
+/**
+ * Depend on all deps collected by this watcher.
+ */
+Watcher.prototype.depend = function depend () {
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
+};
+/**
+ * Remove self from all dependencies' subscriber list.
+ */
+Watcher.prototype.teardown = function teardown () {
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove$2(this.vm._watchers, this);
         }
-    };
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    Watcher.prototype.evaluate = function () {
-        this.value = this.get();
-        this.dirty = false;
-    };
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    Watcher.prototype.depend = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].depend();
+            this.deps[i].removeSub(this);
         }
-    };
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    Watcher.prototype.teardown = function () {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            var i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    };
-    return Watcher;
-}());
+        this.active = false;
+    }
+};
 
 var sharedPropertyDefinition = {
     enumerable: true,
@@ -4071,7 +4053,7 @@ function initProps$1(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var _loop_1 = function (key) {
+    var loop = function ( key ) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4079,14 +4061,14 @@ function initProps$1(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
             }
             defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
                     warn("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        ("value. Prop being mutated: \"" + key + "\""), vm);
+                        "value. Prop being mutated: \"" + key + "\"", vm);
                 }
             });
         }
@@ -4097,9 +4079,8 @@ function initProps$1(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-    for (var key in propsOptions) {
-        _loop_1(key);
-    }
+
+    for (var key in propsOptions) loop( key );
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4119,7 +4100,7 @@ function initData(vm) {
         var key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn("Method \"" + key + "\" has already been defined as a data property.", vm);
+                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
             }
         }
         if (props && hasOwn(props, key)) {
@@ -4157,7 +4138,7 @@ function initComputed$1(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (getter == null) {
-            warn("Getter is missing for computed property \"" + key + "\".", vm);
+            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4171,10 +4152,10 @@ function initComputed$1(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn("The computed property \"" + key + "\" is already defined in data.", vm);
+                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
             }
         }
     }
@@ -4197,7 +4178,7 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4226,11 +4207,11 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         {
             if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn("Method \"" + key + "\" has already been defined as a prop.", vm);
+                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
             }
             if (key in vm && isReserved(key)) {
                 warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4302,7 +4283,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
             }
             popTarget();
         }
@@ -4321,8 +4302,8 @@ function initMixin$1(Vue) {
         var startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + vm._uid;
-            endTag = "vue-perf-end:" + vm._uid;
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4355,7 +4336,7 @@ function initMixin$1(Vue) {
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure("vue " + vm._name + " init", startTag, endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4584,12 +4565,14 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name_1 = getComponentName(cachedNode.componentOptions);
-            if (name_1 && !filter(name_1)) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
@@ -4614,45 +4597,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function () {
+    created: function created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function () {
+    destroyed: function destroyed() {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function () {
-        var _this = this;
+    mounted: function mounted() {
+        var this$1 = this;
+
         this.$watch('include', function (val) {
-            pruneCache(_this, function (name) { return matches(val, name); });
+            pruneCache(this$1, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(_this, function (name) { return !matches(val, name); });
+            pruneCache(this$1, function (name) { return !matches(val, name); });
         });
     },
-    render: function () {
+    render: function render() {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name_2 = getComponentName(componentOptions);
-            var _a = this, include = _a.include, exclude = _a.exclude;
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
             if (
             // not included
-            (include && (!name_2 || !matches(include, name_2))) ||
+            (include && (!name || !matches(include, name))) ||
                 // excluded
-                (exclude && name_2 && matches(exclude, name_2))) {
+                (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var _b = this, cache = _b.cache, keys = _b.keys;
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? "::" + componentOptions.tag : '')
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4724,7 +4712,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function () {
+    get: function get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4984,16 +4972,16 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 });
 
 var ref = {
-    create: function (_, vnode) {
+    create: function create(_, vnode) {
         registerRef(vnode);
     },
-    update: function (oldVnode, vnode) {
+    update: function update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5075,7 +5063,8 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules, nodeOps = backend.nodeOps;
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5246,8 +5235,8 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5261,8 +5250,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-            cbs.create[i_2](emptyNode, vnode);
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5334,7 +5323,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i_3;
+            var i;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5346,16 +5335,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i_3 = vnode.componentInstance)) &&
-                isDef((i_3 = i_3._vnode)) &&
-                isDef(i_3.data)) {
-                removeAndInvokeRemoveHook(i_3, rm);
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
             }
-            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                cbs.remove[i_3](vnode, rm);
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
             }
-            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                i_3(vnode, rm);
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
             }
             else {
                 rm();
@@ -5451,12 +5440,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i_4 = 0; i_4 < children.length; i_4++) {
-            var vnode = children[i_4];
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5465,10 +5454,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i_5 = start; i_5 < end; i_5++) {
-            var c = oldCh[i_5];
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i_5; }
+                { return i; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5548,8 +5537,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                queue[i_6].data.hook.insert(queue[i_6]);
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
             }
         }
     }
@@ -5562,7 +5551,9 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag, data = vnode.data, children = vnode.children;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5611,9 +5602,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i_7 = 0; i_7 < children.length; i_7++) {
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5724,22 +5715,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                            cbs.destroy[i_8](ancestor);
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                cbs.create[i_9](emptyNode, ancestor);
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert_1 = ancestor.data.hook.insert;
-                            if (insert_1.merged) {
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                    insert_1.fns[i_10]();
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
                                 }
                             }
                         }
@@ -5854,7 +5845,7 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
@@ -5863,7 +5854,7 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
         }
     }
 }
@@ -5957,11 +5948,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker_1 = function (e) {
+            var blocker = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker_1);
+                el.removeEventListener('input', blocker);
             };
-            el.addEventListener('input', blocker_1);
+            el.addEventListener('input', blocker);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6013,8 +6004,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6047,17 +6038,17 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp_1 = currentFlushTimestamp;
-        var original_1 = handler;
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
         //@ts-expect-error
-        handler = original_1._wrapper = function (e) {
+        handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp_1 ||
+                e.timeStamp >= attachedTimestamp ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6066,7 +6057,7 @@ function add(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original_1.apply(this, arguments);
+                return original.apply(this, arguments);
             }
         };
     }
@@ -6298,9 +6289,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name_1 = vendorNames[i] + capName;
-        if (name_1 in emptyStyle) {
-            return name_1;
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
         }
     }
 });
@@ -6425,12 +6416,12 @@ function resolveTransition$1(def) {
 }
 var autoCssTransition$1 = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition$1 = inBrowser && !isIE9;
@@ -6482,7 +6473,10 @@ function removeTransitionClass$1(el, cls) {
     removeClass$1(el, cls);
 }
 function whenTransitionEnds$1(el, expectedType, cb) {
-    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo$1(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
@@ -6587,7 +6581,23 @@ function enter$1(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -6695,7 +6705,17 @@ function leave$1(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -6769,7 +6789,7 @@ function leave$1(vnode, rm) {
 function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn("<transition> explicit " + name + " duration is NaN - " +
@@ -6809,7 +6829,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function (vnode, rm) {
+        remove: function remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -6845,7 +6865,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function (el, binding, vnode, oldVnode) {
+    inserted: function inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -6875,22 +6895,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function (el, binding, vnode) {
+    componentUpdated: function componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions_1 = el._vOptions;
-            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions_1);
+                        hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -6911,8 +6931,8 @@ function actuallySetSelected(el, binding, vm) {
     var value = binding.value;
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn("<select multiple v-model=\"" + binding.expression + "\"> " +
-                ("expects an Array value for its binding, but got " + Object.prototype.toString
+        warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7043,12 +7063,12 @@ function resolveTransition(def) {
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -7100,7 +7120,10 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7205,7 +7228,23 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7313,7 +7352,17 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7387,7 +7436,7 @@ function leave(vnode, rm) {
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn("<transition> explicit " + name + " duration is NaN - " +
@@ -7427,8 +7476,9 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
         vnode = locateNode(vnode);
         var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
@@ -7443,8 +7493,10 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
+
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
@@ -7467,7 +7519,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7518,8 +7570,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key in listeners) {
-        data[camelize(key)] = listeners[key];
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
     }
     return data;
 }
@@ -7547,8 +7599,9 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function (h) {
-        var _this = this;
+    render: function render(h) {
+        var this$1 = this;
+
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -7590,7 +7643,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + this._uid + "-";
+        var id = "__transition-" + (this._uid) + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7624,8 +7677,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    _this._leaving = false;
-                    _this.$forceUpdate();
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7633,14 +7686,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave_1;
+                var delayedLeave;
                 var performLeave = function () {
-                    delayedLeave_1();
+                    delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave_1 = leave;
+                    delayedLeave = leave;
                 });
             }
         }
@@ -7657,21 +7710,22 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function () {
-        var _this = this;
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(_this);
+            var restoreActiveInstance = setActiveInstance(this$1);
             // force removing pass
-            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            _this._vnode = _this.kept;
+            this$1._vnode = this$1.kept;
             restoreActiveInstance();
-            update.call(_this, vnode, hydrating);
+            update.call(this$1, vnode, hydrating);
         };
     },
-    render: function (h) {
+    render: function render(h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -7688,27 +7742,27 @@ var TransitionGroup = {
                 }
                 else {
                     var opts = c.componentOptions;
-                    var name_1 = opts
+                    var name = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn("<transition-group> children must be keyed: <" + name_1 + ">");
+                    warn(("<transition-group> children must be keyed: <" + name + ">"));
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i = 0; i < prevChildren.length; i++) {
-                var c = prevChildren[i];
-                c.data.transition = transitionData;
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
                 // @ts-ignore
-                c.data.pos = c.elm.getBoundingClientRect();
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c.key]) {
-                    kept.push(c);
+                if (map[c$1.key]) {
+                    kept.push(c$1);
                 }
                 else {
-                    removed.push(c);
+                    removed.push(c$1);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7716,7 +7770,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function () {
+    updated: function updated() {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7734,25 +7788,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el_1 = c.elm;
-                var s = el_1.style;
-                addTransitionClass(el_1, moveClass);
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                    if (e && e.target !== el_1) {
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el_1.removeEventListener(transitionEndEvent, cb);
-                        el_1._moveCb = null;
-                        removeTransitionClass(el_1, moveClass);
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function (el, moveClass) {
+        hasMove: function hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
index 8d2d1d13836..8cde5e48a58 100644
--- a/dist/vue.runtime.common.prod.js
+++ b/dist/vue.runtime.common.prod.js
@@ -3,4 +3,9 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,w=y(function(t){return t.replace(C,"-$1").toLowerCase()});var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return E(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return E(t[n],e[n])})}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:L};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=O,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function pt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var $t=P.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Ot(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}$t.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},L.forEach(function(t){$t[t]=Ot}),N.forEach(function(t){$t[t+"s"]=St}),$t.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},$t.props=$t.methods=$t.inject=$t.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},$t.provide=kt;var Tt=function(t,e){return void 0===e?t:e};function Et(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Et(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Et(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=$t[r]||Tt;a[r]=o(t[r],e[r],n,r)}return a}function jt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Pt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===w(t)){var c=Pt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Lt(t,e){return Nt(t)===Nt(e)}function Pt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Bt,Ht=!1,Vt=[],zt=!1;function Wt(){zt=!1;var t=Vt.slice(0);Vt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Bt=function(){qt.then(Wt),K&&setTimeout(O)},Ht=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Bt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Ht=!0}function Zt(t,e){var n;if(Vt.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return jt(this.$options,"filters",t)||T}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?he(o,r):i?he(i,t):r?w(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=k(n));var a=void 0,s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=w(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function $e(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=E,t._i=j,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=ft,t._u=Ae,t._g=we,t._d=$e,t._p=xe}function Oe(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Pe(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Pe(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=pt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Te(t,e){for(var n in e)t[_(n)]=e[n]}ke(Oe.prototype);var Ee={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ee.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=It(p,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},je=Object.keys(Ee);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=w(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Te(c,o.attrs),n(o.props)&&Te(c,o.props);var f=new Oe(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<je.length;n++){var r=je[n],o=e[r],i=Ee[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Le=2;function Pe(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||P.getTagNamespace(o),u=P.isReservedTag(o)?new lt(P.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=jt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Be(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function He(t,e){Me.$on(t,e)}function Ve(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},He,Ve,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&P.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:O,set:O};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||O,O,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=O):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):O,ln.set=n.set||O),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Et(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Et(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function $n(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Et(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Pe(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Pe(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?$(e):e;for(var n=$(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var kn=[String,RegExp,Array],On={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){$n(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){$n(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Et,defineReactive:Ct},t.set=wt,t.delete=At,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,On),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Et(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:Oe}),bn.version="2.6.12";var Sn=d("style,class"),Tn=d("input,textarea,option,select,progress"),En=d("contenteditable,draggable,spellcheck"),jn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&jn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Pn=function(t){return Ln(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Bn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Bn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Vn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=jt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Nn,Pn(i)):En(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):En(e)?t.setAttribute(e,In(e,n)):Ln(e)?Mn(n)?t.removeAttributeNS(Nn,Pn(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Bn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Ht&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var wr,Ar={create:Cr,update:Cr};function $r(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:$r,update:$r},Or=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Tr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Tr(t){return Array.isArray(t)?k(t):"string"==typeof t?Or(t):t}var Er,jr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(jr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty(w(e),n.replace(Ir,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Lr=y(function(t){if(Er=Er||document.createElement("div").style,"filter"!==(t=_(t))&&t in Er)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in Er)return r}});function Pr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Tr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Pr,update:Pr},Fr=/\s+/;function Rr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Ur(t.name||"v")),x(e,t),e}return"string"==typeof t?Ur(t):void 0}}var Ur=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Br="transition",Hr="animation",Vr="transition",zr="transitionend",Wr="animation",qr="animationend";U&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Vr="WebkitTransition",zr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Wr="WebkitAnimation",qr="webkitAnimationEnd"));var Kr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Xr(t){Kr(function(){Kr(t)})}function Gr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Zr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Jr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),o=(r[Vr+"Delay"]||"").split(", "),i=(r[Vr+"Duration"]||"").split(", "),a=Yr(o,i),s=(r[Wr+"Delay"]||"").split(", "),c=(r[Wr+"Duration"]||"").split(", "),u=Yr(s,c),l=0,f=0;e===Br?a>0&&(n=Br,l=a,f=i.length):e===Hr?u>0&&(n=Hr,l=u,f=c.length):(l=Math.max(a,u),f=(n=l>0?a>u?Br:Hr:null)?n===Br?i.length:c.length:0);var d=n===Br&&Qr.test(r[Vr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Br?zr:qr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var Qr=/\b(transform|all)(,|$)/;function Yr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return to(e)+to(t[n])}))}function to(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function eo(t){return"number"==typeof t&&!isNaN(t)}function no(t){if(e(t))return!1;var r=t.fns;return n(r)?no(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function ro(t,r){!0!==r.data.show&&function(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Rr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=no(D),R=o._enterCb=I(function(){M&&(Zr(o,E),Zr(o,T)),R.cancelled?(M&&Zr(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(Gr(o,S),Gr(o,T),Xr(function(){Zr(o,S),R.cancelled||(Gr(o,E),F||(eo(P)?setTimeout(R,P):Jr(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}(r)}var oo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=pt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function $(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=pt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?O(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?($(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?($(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?($(h,b,i,o,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?($(m,g,i,o,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?($(l,g,i,o,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))$(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&O(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Jn,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,Ar,kr,Mr,U?{create:ro,activate:ro,remove:function(t,r){!0!==t.data.show?function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Rr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=no(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Zr(o,l),Zr(o,d)),w.cancelled?(_&&Zr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Gr(o,u),Gr(o,d),Xr(function(){Zr(o,u),w.cancelled||(Gr(o,l),b||(eo(C)?setTimeout(w,C):Jr(o,c,w)))})),v&&v(o,w),_||b||w())}}(t,r):r()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&po(t,"input")});var io={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){io.componentUpdated(t,e,n)}):ao(t,e,n.context),t._vOptions=[].map.call(t.options,uo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",lo),t.addEventListener("compositionend",fo),t.addEventListener("change",fo),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ao(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,uo);if(o.some(function(t,e){return!E(t,r[e])}))(t.multiple?e.value.some(function(t){return co(t,o)}):e.value!==e.oldValue&&co(e.value,o))&&po(t,"change")}}};function ao(t,e,n){so(t,e),(z||q)&&setTimeout(function(){so(t,e)},0)}function so(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=j(r,uo(a))>-1,a.selected!==i&&(a.selected=i);else if(E(uo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function co(t,e){return e.every(function(e){return!E(e,t)})}function uo(t){return"_value"in t?t._value:t.value}function lo(t){t.target.composing=!0}function fo(t){t.target.composing&&(t.target.composing=!1,po(t.target,"input"))}function po(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var vo=/\s+/;function ho(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function mo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function yo(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,go(t.name||"v")),x(e,t),e}return"string"==typeof t?go(t):void 0}}var go=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),_o=U&&!W,bo="transition",Co="animation",wo="transition",Ao="transitionend",$o="animation",xo="animationend";_o&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(wo="WebkitTransition",Ao="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($o="WebkitAnimation",xo="webkitAnimationEnd"));var ko=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Oo(t){ko(function(){ko(t)})}function So(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),ho(t,e))}function To(t,e){t._transitionClasses&&v(t._transitionClasses,e),mo(t,e)}function Eo(t,e,n){var r=Io(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===bo?Ao:xo,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var jo=/\b(transform|all)(,|$)/;function Io(t,e){var n,r=window.getComputedStyle(t),o=(r[wo+"Delay"]||"").split(", "),i=(r[wo+"Duration"]||"").split(", "),a=Do(o,i),s=(r[$o+"Delay"]||"").split(", "),c=(r[$o+"Duration"]||"").split(", "),u=Do(s,c),l=0,f=0;return e===bo?a>0&&(n=bo,l=a,f=i.length):e===Co?u>0&&(n=Co,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?bo:Co:null)?n===bo?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===bo&&jo.test(r[wo+"Property"])}}function Do(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return No(e)+No(t[n])}))}function No(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Lo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=yo(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=Mo(D),R=o._enterCb=I(function(){M&&(To(o,E),To(o,T)),R.cancelled?(M&&To(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(So(o,S),So(o,T),Oo(function(){To(o,S),R.cancelled||(So(o,E),F||(Po(P)?setTimeout(R,P):Eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function Po(t){return"number"==typeof t&&!isNaN(t)}function Mo(t){if(e(t))return!1;var r=t.fns;return n(r)?Mo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Fo(t){return!t.componentInstance||t.data&&t.data.transition?t:Fo(t.componentInstance._vnode)}var Ro={model:io,show:{bind:function(t,e,n){var r=e.value,o=(n=Fo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,Lo(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,r,o){var a=r.value;!a!=!r.oldValue&&((o=Fo(o)).data&&o.data.transition?(o.data.show=!0,a?Lo(o,function(){t.style.display=t.__vOriginalDisplay}):function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=yo(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Mo(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(To(o,l),To(o,d)),w.cancelled?(_&&To(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(So(o,u),So(o,d),Oo(function(){To(o,u),w.cancelled||(So(o,l),b||(Po(C)?setTimeout(w,C):Eo(o,c,w)))})),v&&v(o,w),_||b||w())}}(o,function(){t.style.display="none"})):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Uo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Bo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Bo(Be(e.children)):t}function Ho(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function Vo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var zo=function(t){return t.tag||Ue(t)},Wo=function(t){return"show"===t.name},qo={name:"transition",props:Uo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(zo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Bo(i);if(!a)return i;if(this._leaving)return Vo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Ho(this),u=this._vnode,l=Bo(u);if(a.data.directives&&a.data.directives.some(Wo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Vo(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Ko=x({tag:String,moveClass:String},Uo);function Xo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Go(t){t.data.newPos=t.elm.getBoundingClientRect()}function Zo(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Ko.mode;var Jo={Transition:qo,TransitionGroup:{props:Ko,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Ho(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Xo),t.forEach(Go),t.forEach(Zo),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;So(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ao,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ao,t),n._moveCb=null,To(n,e))})}}))},methods:{hasMove:function(t,e){if(!_o)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){mo(n,t)}),ho(n,e),n.style.display="none",this.$el.appendChild(n);var r=Io(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};bn.config.mustUseProp=function(t,e,n){return"value"===n&&Tn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Ro),x(bn.options.components,Jo),bn.prototype.__patch__=U?oo:O,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){P.devtools&&tt&&tt.emit("init",bn)},0),module.exports=bn;
\ No newline at end of file
+/*!
+ * Vue.js v2.6.12
+ * (c) 2014-2021 Evan You
+ * Released under the MIT License.
+ */
+var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function i(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function o(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,w=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=o(t),r=o(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var i=Array.isArray(t),a=Array.isArray(e);if(i&&a)return t.length===e.length&&t.every((function(t,n){return E(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(i||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return E(t[n],e[n])}))}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D=["component","directive","filter"],N=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:N};function P(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var it=O,ot=0,at=function(){this.id=ot++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,i,o,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var dt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=ht[t];M(mt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?function(t,e){t.__proto__=e}(t,mt):function(t,e,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];M(t,o,e[o])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(o(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,r,i){var o=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!i&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(e)&&xt(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!i&&Ct(e),o.notify())}})}}function At(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(wt(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function $t(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function xt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&xt(e)}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)wt(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var kt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,i,o=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=t[n],i=e[n],m(t,n)?r!==i&&s(r)&&s(i)&&Ot(r,i):At(t,n,i));return t}function St(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,i="function"==typeof t?t.call(n,n):t;return r?Ot(r,i):i}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var i=Object.create(t||null);return e?x(i,e):i}kt.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},N.forEach((function(t){kt[t]=Tt})),D.forEach((function(t){kt[t+"s"]=Et})),kt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var i={};for(var o in x(i,t),e){var a=i[o],s=e[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},kt.props=kt.methods=kt.inject=kt.computed=function(t,e,n,r){if(!t)return e;var i=Object.create(null);return x(i,t),e&&x(i,e),i},kt.provide=St;var jt=function(t,e){return void 0===e?t:e};function It(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[_(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[_(a)]=s(i)?i:{type:i};t.props=o}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?x({from:o},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=It(t,e.extends,n)),e.mixins))for(var r=0,i=e.mixins.length;r<i;r++)t=It(t,e.mixins[r],n);var o,a={};for(o in t)c(o);for(o in e)m(t,o)||c(o);function c(r){var i=kt[r]||jt;a[r]=i(t[r],e[r],n,r)}return a}function Dt(t,e,n,r){if("string"==typeof n){var i=t[e];if(m(i,n))return i[n];var o=_(n);if(m(i,o))return i[o];var a=b(o);return m(i,a)?i[a]:i[n]||i[o]||i[a]}}function Nt(t,e,n,r){var i=e[t],o=!m(n,t),a=n[t],s=Ft(Boolean,i.type);if(s>-1)if(o&&!m(i,"default"))a=!1;else if(""===a||a===w(t)){var c=Ft(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Pt(e.type)?r.call(t):r}(r,i,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Lt=/^\s*function (\w+)/;function Pt(t){var e=t&&t.toString().match(Lt);return e?e[1]:""}function Mt(t,e){return Pt(t)===Pt(e)}function Ft(t,e){if(!Array.isArray(e))return Mt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Mt(e[n],t))return n;return-1}function Rt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{ut()}}function Ut(t,e,n,r,i){var o;try{(o=n?t.apply(e,n):t.call(e))&&!o._isVue&&u(o)&&!o._handled&&(o.catch((function(t){return Rt(t,r,i+" (Promise/async)")})),o._handled=!0)}catch(t){Rt(t,r,i)}return o}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Vt,zt=!1,Wt=[],qt=!1;function Kt(){qt=!1;var t=Wt.slice(0);Wt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Xt=Promise.resolve();Vt=function(){Xt.then(Kt),K&&setTimeout(O)},zt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Kt)}:function(){setTimeout(Kt,0)};else{var Gt=1,Zt=new MutationObserver(Kt),Jt=document.createTextNode(String(Gt));Zt.observe(Jt,{characterData:!0}),Vt=function(){Gt=(Gt+1)%2,Jt.data=String(Gt)},zt=!0}function Qt(t,e){var n;if(Wt.push((function(){if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var Yt=new nt;function te(t){ee(t,Yt),Yt.clear()}function ee(t,e){var n,r,i=Array.isArray(t);if(!(!i&&!o(t)||Object.isFrozen(t)||t instanceof lt)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(i)for(n=t.length;n--;)ee(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ee(t[r[n]],e)}}var ne=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function re(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ut(r,null,arguments,e,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)Ut(i[o],null,t,e,"v-on handler")}return n.fns=t,n}function ie(t,n,i,o,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=ne(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=re(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&o((f=ne(c)).name,n[c],f.capture)}function oe(t,i,o){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[i];function c(){o.apply(this,arguments),v(a.fns,c)}e(s)?a=re([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=re([s,c]),a.merged=!0,t[i]=a}function ae(t,e,r,i,o){if(n(e)){if(m(e,r))return t[r]=e[r],o||delete e[r],!0;if(m(e,i))return t[r]=e[i],o||delete e[i],!0}return!1}function se(t){return i(t)?[pt(t)]:Array.isArray(t)?ue(t):void 0}function ce(t){return n(t)&&n(t.text)&&!1===t.isComment}function ue(t,o){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ce((s=ue(s,(o||"")+"_"+a))[0])&&ce(u)&&(l[c]=pt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):i(s)?ce(u)?l[c]=pt(u.text+s):""!==s&&l.push(pt(s)):ce(s)&&ce(u)?l[c]=pt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(o)&&(s.key="__vlist"+o+"_"+a+"__"),l.push(s)));return l}function le(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=t[o].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[o]){var c=t[o].default;n[o]="function"==typeof c?c.call(e):c}}}return n}}function fe(t,e){if(!t||!t.length)return{};for(var n={},r=0,i=t.length;r<i;r++){var o=t[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==e&&o.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(de)&&delete n[u];return n}function de(t){return t.isComment&&!t.asyncFactory||" "===t.text}function pe(e,n,r){var i,o=Object.keys(n).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=ve(n,c,e[c]))}else i={};for(var u in n)u in i||(i[u]=he(n,u));return e&&Object.isExtensible(e)&&(e._normalized=i),M(i,"$stable",a),M(i,"$key",s),M(i,"$hasNormal",o),i}function ve(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:se(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function he(t,e){return function(){return t[e]}}function me(t,e){var r,i,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,i=t.length;r<i;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(o(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ye(t,e,n,r){var i,o=this.$scopedSlots[t];o?(n=n||{},r&&(n=x(x({},r),n)),i=o(n)||e):i=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function ge(t){return Dt(this.$options,"filters",t)||T}function _e(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function be(t,e,n,r,i){var o=L.keyCodes[e]||n;return i&&r&&!L.keyCodes[e]?_e(i,r):o?_e(o,t):r?w(r)!==e:void 0}function Ce(t,e,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=k(n));var s=function(o){if("class"===o||"style"===o||p(o))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,o)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(o),u=w(o);c in a||u in a||(a[o]=n[o],i&&((t.on||(t.on={}))["update:"+o]=function(t){n[o]=t}))};for(var c in n)s(c)}else;return t}function we(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||$e(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function Ae(t,e,n){return $e(t,"__once__"+e+(n?"_"+n:""),!0),t}function $e(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&xe(t[r],e+"_"+r,n);else xe(t,e,n)}function xe(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function ke(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var i=n[r],o=e[r];n[r]=i?[].concat(i,o):o}}else;return t}function Oe(t,e,n,r){e=e||{$stable:!n};for(var i=0;i<t.length;i++){var o=t[i];Array.isArray(o)?Oe(o,e,n):o&&(o.proxy&&(o.fn.proxy=!0),e[o.key]=o.fn)}return r&&(e.$key=r),e}function Se(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Te(t,e){return"string"==typeof t?e+t:t}function Ee(t){t._o=Ae,t._n=f,t._s=l,t._l=me,t._t=ye,t._q=E,t._i=j,t._m=we,t._f=ge,t._k=be,t._b=Ce,t._v=pt,t._e=dt,t._u=Oe,t._g=ke,t._d=Se,t._p=Te}function je(e,n,i,o,a){var s,c=this,u=a.options;m(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=i,this.parent=o,this.listeners=e.on||t,this.injections=le(u.inject,o),this.slots=function(){return c.$slots||pe(e.scopedSlots,c.$slots=fe(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return pe(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=pe(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var i=Fe(s,t,e,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(t,e,n,r){return Fe(s,t,e,n,r,f)}}function Ie(t,e,n,r,i){var o=vt(t);return o.fnContext=n,o.fnOptions=r,e.slot&&((o.data||(o.data={})).slot=e.slot),o}function De(t,e){for(var n in e)t[_(n)]=e[n]}Ee(je.prototype);var Ne={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ne.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},i=t.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ge)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i);if(e.$options._renderChildren=o,e.$attrs=i.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Nt(p,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Xe(e,r,h),u&&(e.$slots=fe(o,i.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,tn(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,nn.push(e)):Qe(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?Ye(e,!0):e.$destroy())}},Le=Object.keys(Ne);function Pe(i,a,s,c,l){if(!e(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var d;if(e(i.cid)&&void 0===(i=function(t,i){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I((function(e){t.resolved=He(e,i),c?s.length=0:d(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,d(!0))})),m=t(p,h);return o(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=He(m.error,i)),n(m.loading)&&(t.loadingComp=He(m.loading,i),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=i,f)))return function(t,e,n,r,i){var o=dt();return o.asyncFactory=t,o.asyncMeta={data:e,context:n,children:r,tag:i},o}(d,a,s,c,l);a=a||{},An(i),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",i=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var o=e.on||(e.on={}),a=o[i],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var p=function(t,r,i){var o=r.options.props;if(!e(o)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in o){var l=w(u);ae(a,c,u,l,!0)||ae(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(e,r,i,o,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Nt(l,u,r||t);else n(i.attrs)&&De(c,i.attrs),n(i.props)&&De(c,i.props);var f=new je(i,c,a,o,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Ie(d,i,f.parent,s);if(Array.isArray(d)){for(var p=se(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Ie(p[h],i,f.parent,s);return v}}(i,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Le.length;n++){var r=Le[n],i=e[r],o=Ne[r];i===o||i&&i._merged||(e[r]=i?Me(o,i):o)}}(a);var y=i.options.name||l;return new lt("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:p,listeners:h,tag:l,children:c},d)}}}function Me(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Fe(t,e,a,s,c,u){return(Array.isArray(a)||i(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,i,a){if(n(r)&&n(r.__ob__))return dt();n(r)&&n(r.is)&&(e=r.is);if(!e)return dt();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===a?i=se(i):1===a&&(i=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(i));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),s=L.isReservedTag(e)?new lt(L.parsePlatformTagName(e),r,i,void 0,void 0,t):r&&r.pre||!n(u=Dt(t.$options,"components",e))?new lt(e,r,i,void 0,void 0,t):Pe(u,r,t,i,e)}else s=Pe(e,r,t,i);return Array.isArray(s)?s:n(s)?(n(c)&&Re(s,c),n(r)&&function(t){o(t.style)&&te(t.style);o(t.class)&&te(t.class)}(r),s):dt()}(t,e,a,s,c)}function Re(t,i,o){if(t.ns=i,"foreignObject"===t.tag&&(i=void 0,o=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(o)&&"svg"!==c.tag)&&Re(c,i,o)}}var Ue,Be=null;function He(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),o(t)?e.extend(t):t}function Ve(t){return t.isComment&&t.asyncFactory}function ze(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ve(r)))return r}}function We(t,e){Ue.$on(t,e)}function qe(t,e){Ue.$off(t,e)}function Ke(t,e){var n=Ue;return function r(){var i=e.apply(null,arguments);null!==i&&n.$off(t,r)}}function Xe(t,e,n){Ue=t,ie(e,n||{},We,qe,Ke,t),Ue=void 0}var Ge=null;function Ze(t){var e=Ge;return Ge=t,function(){Ge=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Qe(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Qe(t.$children[n]);tn(t,"activated")}}function Ye(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);tn(t,"deactivated")}}function tn(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var i=0,o=n.length;i<o;i++)Ut(n[i],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var en=[],nn=[],rn={},on=!1,an=!1,sn=0;var cn=0,un=Date.now;if(U&&!z){var ln=window.performance;ln&&"function"==typeof ln.now&&un()>document.createEvent("Event").timeStamp&&(un=function(){return ln.now()})}function fn(){var t,e;for(cn=un(),an=!0,en.sort((function(t,e){return t.id-e.id})),sn=0;sn<en.length;sn++)(t=en[sn]).before&&t.before(),e=t.id,rn[e]=null,t.run();var n=nn.slice(),r=en.slice();sn=en.length=nn.length=0,rn={},on=an=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Qe(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&tn(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var dn=0,pn=function(t,e,n,r,i){this.vm=t,i&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++dn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()};pn.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&te(t),ut(),this.cleanupDeps()}return t},pn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},pn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},pn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==rn[e]){if(rn[e]=!0,an){for(var n=en.length-1;n>sn&&en[n].id>t.id;)n--;en.splice(n+1,0,t)}else en.push(t);on||(on=!0,Qt(fn))}}(this)},pn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||o(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},pn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},pn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},pn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var vn={enumerable:!0,configurable:!0,get:O,set:O};function hn(t,e,n){vn.get=function(){return this[e][n]},vn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,vn)}function mn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},i=t.$options._propKeys=[];t.$parent&&_t(!1);var o=function(o){i.push(o);var a=Nt(o,e,n,t);wt(r,o,a),o in t||hn(t,"_props",o)};for(var a in e)o(a);_t(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&m(r,o)||P(o)||hn(t,"_data",o)}Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var i in e){var o=e[i],a="function"==typeof o?o:o.get;r||(n[i]=new pn(t,a||O,O,yn)),i in t||gn(t,i,o)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(t,n,r[i]);else Cn(t,n,r)}}(t,e.watch)}var yn={lazy:!0};function gn(t,e,n){var r=!Y();"function"==typeof n?(vn.get=r?_n(e):bn(n),vn.set=O):(vn.get=n.get?r&&!1!==n.cache?_n(e):bn(n.get):O,vn.set=n.set||O),Object.defineProperty(t,e,vn)}function _n(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function bn(t){return function(){return t.call(this,this)}}function Cn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var wn=0;function An(t){var e=t.options;if(t.super){var n=An(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var i in n)n[i]!==r[i]&&(e||(e={}),e[i]=n[i]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=It(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function xn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,i=t._Ctor||(t._Ctor={});if(i[r])return i[r];var o=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=It(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)hn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)gn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,D.forEach((function(t){a[t]=n[t]})),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),i[r]=a,a}}function kn(t){return t&&(t.Ctor.options.name||t.tag)}function On(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function Sn(t,e){var n=t.cache,r=t.keys,i=t._vnode;for(var o in n){var a=n[o];if(a){var s=kn(a.componentOptions);s&&!e(s)&&Tn(n,o,r,i)}}}function Tn(t,e,n,r){var i=t[e];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=wn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=It(An(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Xe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,i=r&&r.context;e.$slots=fe(n._renderChildren,i),e.$scopedSlots=t,e._c=function(t,n,r,i){return Fe(e,t,n,r,i,!1)},e.$createElement=function(t,n,r,i){return Fe(e,t,n,r,i,!0)};var o=r&&r.data;wt(e,"$attrs",o&&o.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),tn(n,"beforeCreate"),function(t){var e=le(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach((function(n){wt(t,n,e[n])})),_t(!0))}(n),mn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),tn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=At,t.prototype.$delete=$t,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return Cn(r,t,e,n);(n=n||{}).user=!0;var i=new pn(r,t,e,n);if(n.immediate){ct();try{e.call(r,i.value)}catch(t){Rt(t,r,'callback for immediate watcher "'+i.expression+'"')}ut()}return function(){i.teardown()}}}($n),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var i=0,o=t.length;i<o;i++)r.$on(t[i],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,i=t.length;r<i;r++)n.$off(t[r],e);return n}var o,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((o=a[s])===e||o.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?$(n):n;for(var r=$(arguments,1),i='event handler for "'+t+'"',o=0,a=n.length;o<a;o++)Ut(n[o],e,r,e,i)}return e}}($n),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,i=n._vnode,o=Ze(n);n._vnode=t,n.$el=i?n.__patch__(i,t):n.__patch__(n.$el,t,e,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){tn(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),tn(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}($n),function(t){Ee(t.prototype),t.prototype.$nextTick=function(t){return Qt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,i=n._parentVnode;i&&(e.$scopedSlots=pe(i.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=i;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Rt(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=dt()),t.parent=i,t}}($n);var En=[String,RegExp,Array],jn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:En,exclude:En,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)Tn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){Sn(t,(function(t){return On(e,t)}))})),this.$watch("exclude",(function(e){Sn(t,(function(t){return!On(e,t)}))}))},render:function(){var t=this.$slots.default,e=ze(t),n=e&&e.componentOptions;if(n){var r=kn(n),i=this.include,o=this.exclude;if(i&&(!r||!On(i,r))||o&&r&&On(o,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&Tn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:it,extend:x,mergeOptions:It,defineReactive:wt},t.set=At,t.delete=$t,t.nextTick=Qt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),D.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,jn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=It(this.options,t),this}}(t),xn(t),function(t){D.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:Y}),Object.defineProperty($n.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:je}),$n.version="2.6.12";var In=d("style,class"),Dn=d("input,textarea,option,select,progress"),Nn=d("contenteditable,draggable,spellcheck"),Ln=d("events,caret,typing,plaintext-only"),Pn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Mn="http://www.w3.org/1999/xlink",Fn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Rn=function(t){return Fn(t)?t.slice(6,t.length):""},Un=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,i=t;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(e=Hn(i.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return Vn(t,zn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:Vn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Vn(t,e){return t?e?t+" "+e:t:e||""}function zn(t){return Array.isArray(t)?function(t){for(var e,r="",i=0,o=t.length;i<o;i++)n(e=zn(t[i]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):o(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},qn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Kn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(t){return qn(t)||Kn(t)};var Gn=Object.create(null);var Zn=d("text,number,password,search,email,tel,url");var Jn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Wn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Qn={create:function(t,e){Yn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Yn(t,!0),Yn(e))},destroy:function(t){Yn(t,!0)}};function Yn(t,e){var r=t.data.ref;if(n(r)){var i=t.context,o=t.componentInstance||t.elm,a=i.$refs;e?Array.isArray(a[r])?v(a[r],o):a[r]===o&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var tr=new lt("",{},[]),er=["create","activate","update","remove","destroy"];function nr(t,i){return t.key===i.key&&(t.tag===i.tag&&t.isComment===i.isComment&&n(t.data)===n(i.data)&&function(t,e){if("input"!==t.tag)return!0;var r,i=n(r=t.data)&&n(r=r.attrs)&&r.type,o=n(r=e.data)&&n(r=r.attrs)&&r.type;return i===o||Zn(i)&&Zn(o)}(t,i)||r(t.isAsyncPlaceholder)&&t.asyncFactory===i.asyncFactory&&e(i.asyncFactory.error))}function rr(t,e,r){var i,o,a={};for(i=e;i<=r;++i)n(o=t[i].key)&&(a[o]=i);return a}var ir={create:or,update:or,destroy:function(t){or(t,tr)}};function or(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,i,o=t===tr,a=e===tr,s=sr(t.data.directives,t.context),c=sr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,ur(i,"update",e,t),i.def&&i.def.componentUpdated&&l.push(i)):(ur(i,"bind",e,t),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ur(u[n],"inserted",e,t)};o?oe(e,"insert",f):f()}l.length&&oe(e,"postpatch",(function(){for(var n=0;n<l.length;n++)ur(l[n],"componentUpdated",e,t)}));if(!o)for(n in s)c[n]||ur(s[n],"unbind",t,t,a)}(t,e)}var ar=Object.create(null);function sr(t,e){var n,r,i=Object.create(null);if(!t)return i;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=ar),i[cr(r)]=r,r.def=Dt(e.$options,"directives",r.name);return i}function cr(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ur(t,e,n,r,i){var o=t.def&&t.def[e];if(o)try{o(n.elm,t,n,r,i)}catch(r){Rt(r,n.context,"directive "+t.name+" "+e+" hook")}}var lr=[Qn,ir];function fr(t,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var o,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[o],c[o]!==a&&dr(s,o,a,r.data.pre);for(o in(z||q)&&u.value!==c.value&&dr(s,"value",u.value),c)e(u[o])&&(Fn(o)?s.removeAttributeNS(Mn,Rn(o)):Nn(o)||s.removeAttribute(o))}}function dr(t,e,n,r){r||t.tagName.indexOf("-")>-1?pr(t,e,n):Pn(e)?Un(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,function(t,e){return Un(e)||"false"===e?"false":"contenteditable"===t&&Ln(e)?e:"true"}(e,n)):Fn(e)?Un(n)?t.removeAttributeNS(Mn,Rn(e)):t.setAttributeNS(Mn,e,n):pr(t,e,n)}function pr(t,e,n){if(Un(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var vr={create:fr,update:fr};function hr(t,r){var i=r.elm,o=r.data,a=t.data;if(!(e(o.staticClass)&&e(o.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=Vn(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var mr,yr={create:hr,update:hr};function gr(t,e,n){var r=mr;return function i(){var o=e.apply(null,arguments);null!==o&&Cr(t,i,n,r)}}var _r=zt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var i=cn,o=e;e=o._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=i||t.timeStamp<=0||t.target.ownerDocument!==document)return o.apply(this,arguments)}}mr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||mr).removeEventListener(t,e._wrapper||e,n)}function wr(t,r){if(!e(t.data.on)||!e(r.data.on)){var i=r.data.on||{},o=t.data.on||{};mr=r.elm,function(t){if(n(t.__r)){var e=z?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(i),ie(i,o,br,Cr,gr,r.context),mr=void 0}}var Ar,$r={create:wr,update:wr};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var i,o,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=e(o)?"":String(o);kr(a,u)&&(a.value=u)}else if("innerHTML"===i&&Kn(a.tagName)&&e(a.innerHTML)){(Ar=Ar||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=Ar.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(t){}}}}function kr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,i=t._vModifiers;if(n(i)){if(i.number)return f(r)!==f(e);if(i.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:xr,update:xr},Sr=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function Tr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?k(t):"string"==typeof t?Sr(t):t}var jr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty(w(e),n.replace(Dr,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)t.style[r]=n[i];else t.style[r]=n}},Lr=["Webkit","Moz","ms"],Pr=y((function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Lr.length;n++){var r=Lr[n]+e;if(r in jr)return r}}));function Mr(t,r){var i=r.data,o=t.data;if(!(e(i.staticStyle)&&e(i.style)&&e(o.staticStyle)&&e(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,d=Er(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var i=t;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=Tr(i.data))&&x(r,n);(n=Tr(t.data))&&x(r,n);for(var o=t;o=o.parent;)o.data&&(n=Tr(o.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Nr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Hr="transition",Vr="transitionend",zr="animation",Wr="animationend";U&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Hr="WebkitTransition",Vr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(zr="WebkitAnimation",Wr="webkitAnimationEnd"));var qr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Kr(t){qr((function(){qr(t)}))}function Xr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Gr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Zr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),i=(r[Hr+"Delay"]||"").split(", "),o=(r[Hr+"Duration"]||"").split(", "),a=Qr(i,o),s=(r[zr+"Delay"]||"").split(", "),c=(r[zr+"Duration"]||"").split(", "),u=Qr(s,c),l=0,f=0;"transition"===e?a>0&&(n="transition",l=a,f=o.length):"animation"===e?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?o.length:c.length:0;var d="transition"===n&&Jr.test(r[Hr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s="transition"===i?Vr:Wr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),t.addEventListener(s,l)}var Jr=/\b(transform|all)(,|$)/;function Qr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return Yr(e)+Yr(t[n])})))}function Yr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ti(t){return"number"==typeof t&&!isNaN(t)}function ei(t){if(e(t))return!1;var r=t.fns;return n(r)?ei(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function ni(t,r){!0!==r.data.show&&function(t,r){var i=t.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=Ur(t.data.transition);if(!e(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ge,k=Ge.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(o($)?$.enter:$),M=!1!==s&&!W,F=ei(D),R=i._enterCb=I((function(){M&&(Gr(i,E),Gr(i,T)),R.cancelled?(M&&Gr(i,S),L&&L(i)):N&&N(i),i._enterCb=null}));t.data.show||oe(t,"insert",(function(){var e=i.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(i,R)})),j&&j(i),M&&(Xr(i,S),Xr(i,T),Kr((function(){Gr(i,S),R.cancelled||(Xr(i,E),F||(ti(P)?setTimeout(R,P):Zr(i,c,R)))}))),t.data.show&&(r&&r(),D&&D(i,R)),M||F||R()}}}(r)}var ri=function(t){var o,a,s={},c=t.modules,u=t.nodeOps;for(o=0;o<er.length;++o)for(s[er[o]]=[],a=0;a<c.length;++a)n(c[a][er[o]])&&s[er[o]].push(c[a][er[o]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,i,o,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,i,o){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(i,t.elm,o),r(c)&&function(t,e,r,i){var o,a=t;for(;a.componentInstance;)if(n(o=(a=a.componentInstance._vnode).data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](tr,a);e.push(a);break}v(r,t.elm,i)}(t,e,i,o),!0}}(t,e,i,o)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(i,t.elm,o)):r(t.isComment)?(t.elm=u.createComment(t.text),v(i,t.elm,o)):(t.elm=u.createTextNode(t.text),v(i,t.elm,o))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Yn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else i(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](tr,t);n(o=t.data.hook)&&(n(o.create)&&o.create(tr,t),n(o.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ge)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,i,o){for(;r<=i;++r)f(n[r],o,t,e,!1,n,r)}function b(t){var e,r,i=t.data;if(n(i))for(n(e=i.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var i=t[e];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,i=s.remove.length+1;for(n(e)?e.listeners+=i:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,i),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,i){for(var o=r;o<i;o++){var a=e[o];if(n(a)&&nr(t,a))return o}}function $(t,i,o,a,c,l){if(t!==i){n(i.elm)&&n(a)&&(i=a[c]=vt(i));var d=i.elm=t.elm;if(r(t.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(t.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(t.isStatic)&&i.key===t.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=t.componentInstance;else{var p,v=i.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,i);var h=t.children,y=i.children;if(n(v)&&m(i)){for(p=0;p<s.update.length;++p)s.update[p](t,i);n(p=v.hook)&&n(p=p.update)&&p(t,i)}e(i.text)?n(h)&&n(y)?h!==y&&function(t,r,i,o,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:nr(h,g)?($(h,g,o,i,p),h=r[++d],g=i[++p]):nr(m,b)?($(m,b,o,i,y),m=r[--v],b=i[--y]):nr(h,b)?($(h,b,o,i,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=i[--y]):nr(m,g)?($(m,g,o,i,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=i[++p]):(e(s)&&(s=rr(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,o,t,h.elm,!1,i,p):nr(l=r[c],g)?($(l,g,o,i,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,o,t,h.elm,!1,i,p),g=i[++p]);d>v?_(t,e(i[y+1])?null:i[y+1].elm,i,p,y,o):p>y&&C(r,d,v)}(d,h,y,o,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,o)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==i.text&&u.setTextContent(d,i.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,i)}}}function x(t,e,i){if(r(i)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var o=0;o<e.length;++o)e[o].data.hook.insert(e[o])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,i,o){var a,s=e.tag,c=e.data,u=e.children;if(o=o||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,i),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,i);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,i);break}!v&&c.class&&te(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,i,o,a){if(!e(i)){var c,l=!1,d=[];if(e(t))l=!0,f(i,d);else{var p=n(t.nodeType);if(!p&&nr(t,i))$(t,i,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),o=!0),r(o)&&O(t,i,d))return x(i,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(i,d,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](tr,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else Yn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(i,d,l),i.elm}n(t)&&b(t)}}({nodeOps:Jn,modules:[vr,yr,$r,Or,Fr,U?{create:ni,activate:ni,remove:function(t,r){!0!==t.data.show?function(t,r){var i=t.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=Ur(t.data.transition);if(e(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=ei(v),C=f(o(g)?g.leave:g),w=i._leaveCb=I((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[t.key]=null),_&&(Gr(i,l),Gr(i,d)),w.cancelled?(_&&Gr(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[t.key]=t),p&&p(i),_&&(Xr(i,u),Xr(i,d),Kr((function(){Gr(i,u),w.cancelled||(Xr(i,l),b||(ti(C)?setTimeout(w,C):Zr(i,c,w)))}))),v&&v(i,w),_||b||w())}}(t,r):r()}}:{}].concat(lr)});W&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&fi(t,"input")}));var ii={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?oe(n,"postpatch",(function(){ii.componentUpdated(t,e,n)})):oi(t,e,n.context),t._vOptions=[].map.call(t.options,ci)):("textarea"===n.tag||Zn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",ui),t.addEventListener("compositionend",li),t.addEventListener("change",li),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){oi(t,e,n.context);var r=t._vOptions,i=t._vOptions=[].map.call(t.options,ci);if(i.some((function(t,e){return!E(t,r[e])})))(t.multiple?e.value.some((function(t){return si(t,i)})):e.value!==e.oldValue&&si(e.value,i))&&fi(t,"change")}}};function oi(t,e,n){ai(t,e),(z||q)&&setTimeout((function(){ai(t,e)}),0)}function ai(t,e,n){var r=e.value,i=t.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],i)o=j(r,ci(a))>-1,a.selected!==o&&(a.selected=o);else if(E(ci(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));i||(t.selectedIndex=-1)}}function si(t,e){return e.every((function(e){return!E(e,t)}))}function ci(t){return"_value"in t?t._value:t.value}function ui(t){t.target.composing=!0}function li(t){t.target.composing&&(t.target.composing=!1,fi(t.target,"input"))}function fi(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var di=/\s+/;function pi(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(di).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function vi(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(di).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function hi(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,mi(t.name||"v")),x(e,t),e}return"string"==typeof t?mi(t):void 0}}var mi=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),yi=U&&!W,gi="transition",_i="transitionend",bi="animation",Ci="animationend";yi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(gi="WebkitTransition",_i="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(bi="WebkitAnimation",Ci="webkitAnimationEnd"));var wi=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Ai(t){wi((function(){wi(t)}))}function $i(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pi(t,e))}function xi(t,e){t._transitionClasses&&v(t._transitionClasses,e),vi(t,e)}function ki(t,e,n){var r=Si(t,e),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s="transition"===i?_i:Ci,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),t.addEventListener(s,l)}var Oi=/\b(transform|all)(,|$)/;function Si(t,e){var n,r=window.getComputedStyle(t),i=(r[gi+"Delay"]||"").split(", "),o=(r[gi+"Duration"]||"").split(", "),a=Ti(i,o),s=(r[bi+"Delay"]||"").split(", "),c=(r[bi+"Duration"]||"").split(", "),u=Ti(s,c),l=0,f=0;return"transition"===e?a>0&&(n="transition",l=a,f=o.length):"animation"===e?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:"transition"===n&&Oi.test(r[gi+"Property"])}}function Ti(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return Ei(e)+Ei(t[n])})))}function Ei(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ji(t,r){var i=t.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=hi(t.data.transition);if(!e(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ge,k=Ge.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(o($)?$.enter:$),M=!1!==s&&!W,F=Di(D),R=i._enterCb=I((function(){M&&(xi(i,E),xi(i,T)),R.cancelled?(M&&xi(i,S),L&&L(i)):N&&N(i),i._enterCb=null}));t.data.show||oe(t,"insert",(function(){var e=i.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(i,R)})),j&&j(i),M&&($i(i,S),$i(i,T),Ai((function(){xi(i,S),R.cancelled||($i(i,E),F||(Ii(P)?setTimeout(R,P):ki(i,c,R)))}))),t.data.show&&(r&&r(),D&&D(i,R)),M||F||R()}}}function Ii(t){return"number"==typeof t&&!isNaN(t)}function Di(t){if(e(t))return!1;var r=t.fns;return n(r)?Di(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Ni(t){return!t.componentInstance||t.data&&t.data.transition?t:Ni(t.componentInstance._vnode)}var Li={model:ii,show:{bind:function(t,e,n){var r=e.value,i=(n=Ni(n)).data&&n.data.transition,o=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&i?(n.data.show=!0,ji(n,(function(){t.style.display=o}))):t.style.display=r?o:"none"},update:function(t,r,i){var a=r.value;!a!=!r.oldValue&&((i=Ni(i)).data&&i.data.transition?(i.data.show=!0,a?ji(i,(function(){t.style.display=t.__vOriginalDisplay})):function(t,r){var i=t.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=hi(t.data.transition);if(e(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Di(v),C=f(o(g)?g.leave:g),w=i._leaveCb=I((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[t.key]=null),_&&(xi(i,l),xi(i,d)),w.cancelled?(_&&xi(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[t.key]=t),p&&p(i),_&&($i(i,u),$i(i,d),Ai((function(){xi(i,u),w.cancelled||($i(i,l),b||(Ii(C)?setTimeout(w,C):ki(i,c,w)))}))),v&&v(i,w),_||b||w())}}(i,(function(){t.style.display="none"}))):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,i){i||(t.style.display=t.__vOriginalDisplay)}}},Pi={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Mi(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Mi(ze(e.children)):t}function Fi(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var i=n._parentListeners;for(var o in i)e[_(o)]=i[o];return e}function Ri(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Ui=function(t){return t.tag||Ve(t)},Bi=function(t){return"show"===t.name},Hi={name:"transition",props:Pi,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Ui)).length){var r=this.mode,o=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;var a=Mi(o);if(!a)return o;if(this._leaving)return Ri(t,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Fi(this),u=this._vnode,l=Mi(u);if(a.data.directives&&a.data.directives.some(Bi)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ve(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,oe(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Ri(t,o);if("in-out"===r){if(Ve(a))return u;var d,p=function(){d()};oe(c,"afterEnter",p),oe(c,"enterCancelled",p),oe(f,"delayLeave",(function(t){d=t}))}}return o}}},Vi=x({tag:String,moveClass:String},Pi);function zi(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Wi(t){t.data.newPos=t.elm.getBoundingClientRect()}function qi(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,i=e.top-n.top;if(r||i){t.data.moved=!0;var o=t.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete Vi.mode;var Ki={Transition:Hi,TransitionGroup:{props:Vi,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var i=Ze(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,i(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=Fi(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,o)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(zi),t.forEach(Wi),t.forEach(qi),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;$i(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(_i,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(_i,t),n._moveCb=null,xi(n,e))})}})))},methods:{hasMove:function(t,e){if(!yi)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){vi(n,t)})),pi(n,e),n.style.display="none",this.$el.appendChild(n);var r=Si(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};$n.config.mustUseProp=function(t,e,n){return"value"===n&&Dn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},$n.config.isReservedTag=Xn,$n.config.isReservedAttr=In,$n.config.getTagNamespace=function(t){return Kn(t)?"svg":"math"===t?"math":void 0},$n.config.isUnknownElement=function(t){if(!U)return!0;if(Xn(t))return!1;if(t=t.toLowerCase(),null!=Gn[t])return Gn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Gn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Gn[t]=/HTMLUnknownElement/.test(e.toString())},x($n.options.directives,Li),x($n.options.components,Ki),$n.prototype.__patch__=U?ri:O,$n.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),tn(t,"beforeMount"),r=function(){t._update(t._render(),n)},new pn(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&tn(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,tn(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((function(){L.devtools&&tt&&tt.emit("init",$n)}),0),module.exports=$n;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index 24897b41f42..28d97681d14 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -418,7 +418,7 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
@@ -461,7 +461,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get: function get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -507,19 +507,20 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
+    _Set = /*@__PURE__*/(function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function (key) {
+        Set.prototype.has = function has (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function (key) {
+        Set.prototype.add = function add (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function () {
+        Set.prototype.clear = function clear () {
             this.set = Object.create(null);
         };
+
         return Set;
     }());
 }
@@ -529,22 +530,20 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
     warn = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
-        else if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        else if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
+        if (hasConsole && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -567,10 +566,10 @@ if (process.env.NODE_ENV !== 'production') {
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
     };
-    var repeat_1 = function (str, n) {
+    var repeat = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -604,15 +603,13 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
         }
     };
 }
@@ -622,37 +619,34 @@ var uid$2 = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid$2++;
-        this.subs = [];
+var Dep = function Dep() {
+    this.id = uid$2++;
+    this.subs = [];
+};
+Dep.prototype.addSub = function addSub (sub) {
+    this.subs.push(sub);
+};
+Dep.prototype.removeSub = function removeSub (sub) {
+    remove$2(this.subs, sub);
+};
+Dep.prototype.depend = function depend () {
+    if (Dep.target) {
+        Dep.target.addDep(this);
     }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove$2(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort(function (a, b) { return a.id - b.id; });
-        }
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
+};
+Dep.prototype.notify = function notify () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
+};
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -667,45 +661,43 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
+};
+
+var prototypeAccessors = { child: { configurable: true } };
+// DEPRECATED: alias for componentInstance for backwards compat.
+/* istanbul ignore next */
+prototypeAccessors.child.get = function () {
+    return this.componentInstance;
+};
+
+Object.defineProperties( VNode.prototype, prototypeAccessors );
 var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
+    if ( text === void 0 ) text = '';
+
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -759,12 +751,9 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -800,46 +789,43 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
         }
         else {
-            this.walk(value);
+            copyAugment(value, arrayMethods, arrayKeys);
         }
+        this.observeArray(value);
     }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
+    else {
+        this.walk(value);
+    }
+};
+/**
+ * Walk through all properties and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ */
+Observer.prototype.walk = function walk (obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i]);
+    }
+};
+/**
+ * Observe a list of Array items.
+ */
+Observer.prototype.observeArray = function observeArray (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
+};
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -950,7 +936,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -983,7 +969,7 @@ function set(target, key, val) {
 function del(target, key) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
@@ -1011,7 +997,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1187,14 +1173,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1232,7 +1218,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
         warn('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1276,7 +1262,7 @@ function normalizeProps(options, vm) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
+            "but got " + (toRawType(props)) + ".", vm);
     }
     options.props = res;
 }
@@ -1303,7 +1289,7 @@ function normalizeInject(options, vm) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
+            "but got " + (toRawType(inject)) + ".", vm);
     }
 }
 /**
@@ -1323,7 +1309,7 @@ function normalizeDirectives$1(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+            "but got " + (toRawType(value)) + ".", vm);
     }
 }
 /**
@@ -1561,7 +1547,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1569,24 +1555,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
+        message += " with value " + (styleValue(value, expectedType));
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
+        message += "with value " + (styleValue(value, receivedType)) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return "\"" + value + "\"";
+        return ("\"" + value + "\"");
     }
     else if (type === 'Number') {
-        return "" + Number(value);
+        return ("" + (Number(value)));
     }
     else {
-        return "" + value;
+        return ("" + value);
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1594,12 +1580,9 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var arguments$1 = arguments;
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments$1[_i];
-    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1665,7 +1648,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     if (process.env.NODE_ENV !== 'production') {
-        warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
+        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1708,9 +1691,9 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p_1 = Promise.resolve();
+    var p = Promise.resolve();
     timerFunc = function () {
-        p_1.then(flushCallbacks);
+        p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
         // microtask queue but the queue isn't being flushed, until the browser
@@ -1729,15 +1712,15 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
+    var counter = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
     timerFunc = function () {
-        counter_1 = (counter_1 + 1) % 2;
-        textNode_1.data = String(counter_1);
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
     };
     isUsingMicroTask = true;
 }
@@ -1785,31 +1768,31 @@ function nextTick(cb, ctx) {
 /* not type checking this file because flow doesn't play well with Proxy */
 var initProxy;
 if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent_1 = function (target, key) {
+    var warnNonPresent = function (target, key) {
         warn("Property or method \"" + key + "\" is not defined on the instance but " +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix_1 = function (target, key) {
+    var warnReservedPrefix = function (target, key) {
         warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                     return false;
                 }
                 else {
@@ -1819,38 +1802,38 @@ if (process.env.NODE_ENV !== 'production') {
             },
         });
     }
-    var hasHandler_1 = {
-        has: function (target, key) {
+    var hasHandler = {
+        has: function has(target, key) {
             var has = key in target;
-            var isAllowed = allowedGlobals_1(key) ||
+            var isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return has || !isAllowed;
         },
     };
-    var getHandler_1 = {
-        get: function (target, key) {
+    var getHandler = {
+        get: function get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
+                    { warnReservedPrefix(target, key); }
                 else
-                    { warnNonPresent_1(target, key); }
+                    { warnNonPresent(target, key); }
             }
             return target[key];
         },
     };
     initProxy = function initProxy(vm) {
-        if (hasProxy_1) {
+        if (hasProxy) {
             // determine which proxy handler to use
             var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1900,18 +1883,18 @@ function _traverse(val, seen) {
 var mark;
 var measure;
 if (process.env.NODE_ENV !== 'production') {
-    var perf_1 = inBrowser && window.performance;
+    var perf = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) {
-        mark = function (tag) { return perf_1.mark(tag); };
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = function (tag) { return perf.mark(tag); };
         measure = function (name, startTag, endTag) {
-            perf_1.measure(name, startTag, endTag);
-            perf_1.clearMarks(startTag);
-            perf_1.clearMarks(endTag);
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
             // perf.clearMeasures(name)
         };
     }
@@ -1958,7 +1941,7 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
         event = normalizeEvent(name);
         if (isUndef(cur)) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+                warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -2023,7 +2006,8 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs, props = data.props;
+    var attrs = data.attrs;
+    var props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -2033,11 +2017,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2111,7 +2095,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2172,7 +2156,7 @@ function initInjections(vm) {
                 defineReactive(vm, key, result[key], function () {
                     warn("Avoid mutating an injected value directly since the changes will be " +
                         "overwritten whenever the provided component re-renders. " +
-                        ("injection being mutated: \"" + key + "\""), vm);
+                        "injection being mutated: \"" + key + "\"", vm);
                 });
             }
             else {
@@ -2212,7 +2196,7 @@ function resolveInject(inject, vm) {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     // @ts-ignore
-                    warn("Injection \"" + key + "\" not found", vm);
+                    warn(("Injection \"" + key + "\" not found"), vm);
                 }
             }
         }
@@ -2240,8 +2224,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2254,9 +2238,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
         }
     }
     return slots;
@@ -2289,16 +2273,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2456,8 +2440,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash = void 0;
-            var _loop_1 = function (key) {
+            var hash;
+            var loop = function ( key ) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -2474,15 +2458,14 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
+                        on[("update:" + key)] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-            for (var key in value) {
-                _loop_1(key);
-            }
+
+            for (var key in value) loop( key );
         }
     }
     return data;
@@ -2502,7 +2485,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, "__static__" + index, false);
+    markStatic(tree, ("__static__" + index), false);
     return tree;
 }
 /**
@@ -2510,14 +2493,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
             }
         }
     }
@@ -2585,7 +2568,7 @@ function bindDynamicKeys(baseObj, values) {
             key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
         }
     }
     return baseObj;
@@ -2618,7 +2601,8 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
+    var this$1 = this;
+
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -2645,14 +2629,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
         }
-        return _this.$slots;
+        return this$1.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function () {
+        get: function get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2675,9 +2659,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) {
-            return createElement$1(contextVm, a, b, c, d, needNormalization);
-        };
+        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2733,7 +2715,7 @@ function mergeProps(to, from) {
 
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
+    init: function init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -2746,7 +2728,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function (oldVnode, vnode) {
+    prepatch: function prepatch(oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -2755,8 +2737,9 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2775,7 +2758,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -2801,7 +2784,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         if (process.env.NODE_ENV !== 'production') {
-            warn("Invalid Component definition: " + String(Ctor), context);
+            warn(("Invalid Component definition: " + (String(Ctor))), context);
         }
         return;
     }
@@ -2859,7 +2842,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -2942,7 +2925,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+            warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2978,7 +2961,7 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor = void 0;
+        var Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
@@ -2986,7 +2969,7 @@ function _createElement(context, tag, data, children, normalizationType) {
                 isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3093,7 +3076,9 @@ function renderMixin(Vue) {
     };
     Vue.prototype._render = function () {
         var vm = this;
-        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+        var ref = vm.$options;
+        var render = ref.render;
+        var _parentVnode = ref._parentVnode;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3176,24 +3161,24 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners_1 = (factory.owners = [owner]);
-        var sync_1 = true;
-        var timerLoading_1 = null;
-        var timerTimeout_1 = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-        var forceRender_1 = function (renderCompleted) {
-            for (var i = 0, l = owners_1.length; i < l; i++) {
-                owners_1[i].$forceUpdate();
+        var owners = (factory.owners = [owner]);
+        var sync = true;
+        var timerLoading = null;
+        var timerTimeout = null;
+        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+        var forceRender = function (renderCompleted) {
+            for (var i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
             }
             if (renderCompleted) {
-                owners_1.length = 0;
-                if (timerLoading_1 !== null) {
-                    clearTimeout(timerLoading_1);
-                    timerLoading_1 = null;
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
                 }
-                if (timerTimeout_1 !== null) {
-                    clearTimeout(timerTimeout_1);
-                    timerTimeout_1 = null;
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
                 }
             }
         };
@@ -3202,65 +3187,65 @@ function resolveAsyncComponent(factory, baseCtor) {
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
             // (async resolves are shimmed as synchronous during SSR)
-            if (!sync_1) {
-                forceRender_1(true);
+            if (!sync) {
+                forceRender(true);
             }
             else {
-                owners_1.length = 0;
+                owners.length = 0;
             }
         });
-        var reject_1 = once(function (reason) {
+        var reject = once(function (reason) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Failed to resolve async component: " + String(factory) +
-                    (reason ? "\nReason: " + reason : ''));
+                warn("Failed to resolve async component: " + (String(factory)) +
+                    (reason ? ("\nReason: " + reason) : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
-                forceRender_1(true);
+                forceRender(true);
             }
         });
-        var res_1 = factory(resolve, reject_1);
-        if (isObject(res_1)) {
-            if (isPromise(res_1)) {
+        var res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
                 // () => Promise
                 if (isUndef(factory.resolved)) {
-                    res_1.then(resolve, reject_1);
+                    res.then(resolve, reject);
                 }
             }
-            else if (isPromise(res_1.component)) {
-                res_1.component.then(resolve, reject_1);
-                if (isDef(res_1.error)) {
-                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
                 }
-                if (isDef(res_1.loading)) {
-                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                    if (res_1.delay === 0) {
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
                         factory.loading = true;
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading_1 = setTimeout(function () {
-                            timerLoading_1 = null;
+                        timerLoading = setTimeout(function () {
+                            timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
-                                forceRender_1(false);
+                                forceRender(false);
                             }
-                        }, res_1.delay || 200);
+                        }, res.delay || 200);
                     }
                 }
-                if (isDef(res_1.timeout)) {
+                if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout_1 = setTimeout(function () {
-                        timerTimeout_1 = null;
+                    timerTimeout = setTimeout(function () {
+                        timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject_1(process.env.NODE_ENV !== 'production'
-                                ? "timeout (" + res_1.timeout + "ms)"
+                            reject(process.env.NODE_ENV !== 'production'
+                                ? ("timeout (" + (res.timeout) + "ms)")
                                 : null);
                         }
-                    }, res_1.timeout);
+                    }, res.timeout);
                 }
             }
         }
-        sync_1 = false;
+        sync = false;
         // return in case resolved synchronously
         return factory.loading ? factory.loadingComp : factory.resolved;
     }
@@ -3350,8 +3335,8 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                vm.$off(event[i_1], fn);
+            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                vm.$off(event[i$1], fn);
             }
             return vm;
         }
@@ -3382,10 +3367,10 @@ function eventsMixin(Vue) {
             var lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                 tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
                     "Note that HTML attributes are case-insensitive and you cannot use " +
                     "v-on to listen to camelCase events when using in-DOM templates. " +
-                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
             }
         }
         var cbs = vm._events[event];
@@ -3546,11 +3531,11 @@ function mountComponent(vm, el, hydrating) {
             mark(startTag);
             var vnode = vm._render();
             mark(endTag);
-            measure("vue " + name + " render", startTag, endTag);
+            measure(("vue " + name + " render"), startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure("vue " + name + " patch", startTag, endTag);
+            measure(("vue " + name + " patch"), startTag, endTag);
         };
     }
     else {
@@ -3562,7 +3547,7 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function () {
+        before: function before() {
             if (vm._isMounted && !vm._isDestroyed) {
                 callHook$1(vm, 'beforeUpdate');
             }
@@ -3731,15 +3716,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance_1.now(); };
+        getNow = function () { return performance.now(); };
     }
 }
 /**
@@ -3774,7 +3759,7 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn('You may have an infinite update loop ' +
                     (watcher.user
-                        ? "in watcher with expression \"" + watcher.expression + "\""
+                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
                         : "in a component render function."), watcher.vm);
                 break;
             }
@@ -3858,195 +3843,192 @@ var uid$1 = 0;
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = /** @class */ (function () {
-    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
+var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+    this.vm = vm;
+    if (isRenderWatcher) {
+        vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+        this.deep = !!options.deep;
+        this.user = !!options.user;
+        this.lazy = !!options.lazy;
+        this.sync = !!options.sync;
+        this.before = options.before;
+    }
+    else {
+        this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$1; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression =
+        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
+    // parse expression for getter
+    if (typeof expOrFn === 'function') {
+        this.getter = expOrFn;
+    }
+    else {
+        this.getter = parsePath(expOrFn);
+        if (!this.getter) {
+            this.getter = noop;
+            process.env.NODE_ENV !== 'production' &&
+                warn("Failed watching path: \"" + expOrFn + "\" " +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
         }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression =
-            process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
+    }
+    this.value = this.lazy ? undefined : this.get();
+};
+/**
+ * Evaluate the getter, and re-collect dependencies.
+ */
+Watcher.prototype.get = function get () {
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+        value = this.getter.call(vm, vm);
+    }
+    catch (e) {
+        if (this.user) {
+            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
         }
         else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' &&
-                    warn("Failed watching path: \"" + expOrFn + "\" " +
-                        'Watcher only accepts simple dot-delimited paths. ' +
-                        'For full control, use a function instead.', vm);
-            }
+            throw e;
         }
-        this.value = this.lazy ? undefined : this.get();
     }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    Watcher.prototype.get = function () {
-        pushTarget(this);
-        var value;
-        var vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
+    finally {
+        // "touch" every property so they are all tracked as
+        // dependencies for deep watching
+        if (this.deep) {
+            traverse(value);
         }
-        catch (e) {
+        popTarget();
+        this.cleanupDeps();
+    }
+    return value;
+};
+/**
+ * Add a dependency to this directive.
+ */
+Watcher.prototype.addDep = function addDep (dep) {
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+        this.newDepIds.add(id);
+        this.newDeps.push(dep);
+        if (!this.depIds.has(id)) {
+            dep.addSub(this);
+        }
+    }
+};
+/**
+ * Clean up for dependency collection.
+ */
+Watcher.prototype.cleanupDeps = function cleanupDeps () {
+    var i = this.deps.length;
+    while (i--) {
+        var dep = this.deps[i];
+        if (!this.newDepIds.has(dep.id)) {
+            dep.removeSub(this);
+        }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
+};
+/**
+ * Subscriber interface.
+ * Will be called when a dependency changes.
+ */
+Watcher.prototype.update = function update () {
+    /* istanbul ignore else */
+    if (this.lazy) {
+        this.dirty = true;
+    }
+    else if (this.sync) {
+        this.run();
+    }
+    else {
+        queueWatcher(this);
+    }
+};
+/**
+ * Scheduler job interface.
+ * Will be called by the scheduler.
+ */
+Watcher.prototype.run = function run () {
+    if (this.active) {
+        var value = this.get();
+        if (value !== this.value ||
+            // Deep watchers and watchers on Object/Arrays should fire even
+            // when the value is the same, because the value may
+            // have mutated.
+            isObject(value) ||
+            this.deep) {
+            // set new value
+            var oldValue = this.value;
+            this.value = value;
             if (this.user) {
-                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                try {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+                catch (e) {
+                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                }
             }
             else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    };
-    /**
-     * Add a dependency to this directive.
-     */
-    Watcher.prototype.addDep = function (dep) {
-        var id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
+                this.cb.call(this.vm, value, oldValue);
             }
         }
-    };
-    /**
-     * Clean up for dependency collection.
-     */
-    Watcher.prototype.cleanupDeps = function () {
-        var i = this.deps.length;
-        while (i--) {
-            var dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        var tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    };
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    Watcher.prototype.update = function () {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    };
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    Watcher.prototype.run = function () {
-        if (this.active) {
-            var value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                var oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    try {
-                        this.cb.call(this.vm, value, oldValue);
-                    }
-                    catch (e) {
-                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                    }
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
+    }
+};
+/**
+ * Evaluate the value of the watcher.
+ * This only gets called for lazy watchers.
+ */
+Watcher.prototype.evaluate = function evaluate () {
+    this.value = this.get();
+    this.dirty = false;
+};
+/**
+ * Depend on all deps collected by this watcher.
+ */
+Watcher.prototype.depend = function depend () {
+    var i = this.deps.length;
+    while (i--) {
+        this.deps[i].depend();
+    }
+};
+/**
+ * Remove self from all dependencies' subscriber list.
+ */
+Watcher.prototype.teardown = function teardown () {
+    if (this.active) {
+        // remove self from vm's watcher list
+        // this is a somewhat expensive operation so we skip it
+        // if the vm is being destroyed.
+        if (!this.vm._isBeingDestroyed) {
+            remove$2(this.vm._watchers, this);
         }
-    };
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    Watcher.prototype.evaluate = function () {
-        this.value = this.get();
-        this.dirty = false;
-    };
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    Watcher.prototype.depend = function () {
         var i = this.deps.length;
         while (i--) {
-            this.deps[i].depend();
+            this.deps[i].removeSub(this);
         }
-    };
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    Watcher.prototype.teardown = function () {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            var i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    };
-    return Watcher;
-}());
+        this.active = false;
+    }
+};
 
 var sharedPropertyDefinition = {
     enumerable: true,
@@ -4093,7 +4075,7 @@ function initProps$1(vm, propsOptions) {
     if (!isRoot) {
         toggleObserving(false);
     }
-    var _loop_1 = function (key) {
+    var loop = function ( key ) {
         keys.push(key);
         var value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
@@ -4101,14 +4083,14 @@ function initProps$1(vm, propsOptions) {
             var hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
             }
             defineReactive(props, key, value, function () {
                 if (!isRoot && !isUpdatingChildComponent) {
                     warn("Avoid mutating a prop directly since the value will be " +
                         "overwritten whenever the parent component re-renders. " +
                         "Instead, use a data or computed property based on the prop's " +
-                        ("value. Prop being mutated: \"" + key + "\""), vm);
+                        "value. Prop being mutated: \"" + key + "\"", vm);
                 }
             });
         }
@@ -4122,9 +4104,8 @@ function initProps$1(vm, propsOptions) {
             proxy(vm, "_props", key);
         }
     };
-    for (var key in propsOptions) {
-        _loop_1(key);
-    }
+
+    for (var key in propsOptions) loop( key );
     toggleObserving(true);
 }
 function initData(vm) {
@@ -4145,7 +4126,7 @@ function initData(vm) {
         var key = keys[i];
         if (process.env.NODE_ENV !== 'production') {
             if (methods && hasOwn(methods, key)) {
-                warn("Method \"" + key + "\" has already been defined as a data property.", vm);
+                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
             }
         }
         if (props && hasOwn(props, key)) {
@@ -4184,7 +4165,7 @@ function initComputed$1(vm, computed) {
         var userDef = computed[key];
         var getter = typeof userDef === 'function' ? userDef : userDef.get;
         if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn("Getter is missing for computed property \"" + key + "\".", vm);
+            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4198,10 +4179,10 @@ function initComputed$1(vm, computed) {
         }
         else if (process.env.NODE_ENV !== 'production') {
             if (key in vm.$data) {
-                warn("The computed property \"" + key + "\" is already defined in data.", vm);
+                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
             }
         }
     }
@@ -4225,7 +4206,7 @@ function defineComputed(target, key, userDef) {
     if (process.env.NODE_ENV !== 'production' &&
         sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4254,11 +4235,11 @@ function initMethods(vm, methods) {
     for (var key in methods) {
         if (process.env.NODE_ENV !== 'production') {
             if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
                     "Did you reference the function correctly?", vm);
             }
             if (props && hasOwn(props, key)) {
-                warn("Method \"" + key + "\" has already been defined as a prop.", vm);
+                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
             }
             if (key in vm && isReserved(key)) {
                 warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4330,7 +4311,7 @@ function stateMixin(Vue) {
                 cb.call(vm, watcher.value);
             }
             catch (error) {
-                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
             }
             popTarget();
         }
@@ -4349,8 +4330,8 @@ function initMixin$1(Vue) {
         var startTag, endTag;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + vm._uid;
-            endTag = "vue-perf-end:" + vm._uid;
+            startTag = "vue-perf-start:" + (vm._uid);
+            endTag = "vue-perf-end:" + (vm._uid);
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4386,7 +4367,7 @@ function initMixin$1(Vue) {
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure("vue " + vm._name + " init", startTag, endTag);
+            measure(("vue " + (vm._name) + " init"), startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4615,12 +4596,14 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
     for (var key in cache) {
         var cachedNode = cache[key];
         if (cachedNode) {
-            var name_1 = getComponentName(cachedNode.componentOptions);
-            if (name_1 && !filter(name_1)) {
+            var name = getComponentName(cachedNode.componentOptions);
+            if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
         }
@@ -4645,45 +4628,50 @@ var KeepAlive = {
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function () {
+    created: function created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function () {
+    destroyed: function destroyed() {
         for (var key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function () {
-        var _this = this;
+    mounted: function mounted() {
+        var this$1 = this;
+
         this.$watch('include', function (val) {
-            pruneCache(_this, function (name) { return matches(val, name); });
+            pruneCache(this$1, function (name) { return matches(val, name); });
         });
         this.$watch('exclude', function (val) {
-            pruneCache(_this, function (name) { return !matches(val, name); });
+            pruneCache(this$1, function (name) { return !matches(val, name); });
         });
     },
-    render: function () {
+    render: function render() {
         var slot = this.$slots.default;
         var vnode = getFirstComponentChild(slot);
         var componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name_2 = getComponentName(componentOptions);
-            var _a = this, include = _a.include, exclude = _a.exclude;
+            var name = getComponentName(componentOptions);
+            var ref = this;
+            var include = ref.include;
+            var exclude = ref.exclude;
             if (
             // not included
-            (include && (!name_2 || !matches(include, name_2))) ||
+            (include && (!name || !matches(include, name))) ||
                 // excluded
-                (exclude && name_2 && matches(exclude, name_2))) {
+                (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var _b = this, cache = _b.cache, keys = _b.keys;
+            var ref$1 = this;
+            var cache = ref$1.cache;
+            var keys = ref$1.keys;
             var key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? "::" + componentOptions.tag : '')
+                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4755,7 +4743,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function () {
+    get: function get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -5016,16 +5004,16 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 });
 
 var ref = {
-    create: function (_, vnode) {
+    create: function create(_, vnode) {
         registerRef(vnode);
     },
-    update: function (oldVnode, vnode) {
+    update: function update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         registerRef(vnode, true);
     },
 };
@@ -5107,7 +5095,8 @@ function createKeyToOldIdx(children, beginIdx, endIdx) {
 function createPatchFunction(backend) {
     var i, j;
     var cbs = {};
-    var modules = backend.modules, nodeOps = backend.nodeOps;
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5278,8 +5267,8 @@ function createPatchFunction(backend) {
             if (process.env.NODE_ENV !== 'production') {
                 checkDuplicateKeys(children);
             }
-            for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+            for (var i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
         else if (isPrimitive(vnode.text)) {
@@ -5293,8 +5282,8 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-            cbs.create[i_2](emptyNode, vnode);
+        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+            cbs.create[i$1](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
@@ -5366,7 +5355,7 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i_3;
+            var i;
             var listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
@@ -5378,16 +5367,16 @@ function createPatchFunction(backend) {
                 rm = createRmCb(vnode.elm, listeners);
             }
             // recursively invoke hooks on child component root node
-            if (isDef((i_3 = vnode.componentInstance)) &&
-                isDef((i_3 = i_3._vnode)) &&
-                isDef(i_3.data)) {
-                removeAndInvokeRemoveHook(i_3, rm);
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
             }
-            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                cbs.remove[i_3](vnode, rm);
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
             }
-            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                i_3(vnode, rm);
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
             }
             else {
                 rm();
@@ -5483,12 +5472,12 @@ function createPatchFunction(backend) {
     }
     function checkDuplicateKeys(children) {
         var seenKeys = {};
-        for (var i_4 = 0; i_4 < children.length; i_4++) {
-            var vnode = children[i_4];
+        for (var i = 0; i < children.length; i++) {
+            var vnode = children[i];
             var key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5497,10 +5486,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i_5 = start; i_5 < end; i_5++) {
-            var c = oldCh[i_5];
+        for (var i = start; i < end; i++) {
+            var c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i_5; }
+                { return i; }
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5580,8 +5569,8 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                queue[i_6].data.hook.insert(queue[i_6]);
+            for (var i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
             }
         }
     }
@@ -5594,7 +5583,9 @@ function createPatchFunction(backend) {
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
         var i;
-        var tag = vnode.tag, data = vnode.data, children = vnode.children;
+        var tag = vnode.tag;
+        var data = vnode.data;
+        var children = vnode.children;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5644,9 +5635,9 @@ function createPatchFunction(backend) {
                         // iterate and compare children lists
                         var childrenMatch = true;
                         var childNode = elm.firstChild;
-                        for (var i_7 = 0; i_7 < children.length; i_7++) {
+                        for (var i$1 = 0; i$1 < children.length; i$1++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5758,22 +5749,22 @@ function createPatchFunction(backend) {
                     var ancestor = vnode.parent;
                     var patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                            cbs.destroy[i_8](ancestor);
+                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                cbs.create[i_9](emptyNode, ancestor);
+                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                cbs.create[i$1](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert_1 = ancestor.data.hook.insert;
-                            if (insert_1.merged) {
+                            var insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                    insert_1.fns[i_10]();
+                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                    insert.fns[i$2]();
                                 }
                             }
                         }
@@ -5888,7 +5879,7 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
     var fn = dir.def && dir.def[hook];
@@ -5897,7 +5888,7 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
         }
     }
 }
@@ -5991,11 +5982,11 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker_1 = function (e) {
+            var blocker = function (e) {
                 e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker_1);
+                el.removeEventListener('input', blocker);
             };
-            el.addEventListener('input', blocker_1);
+            el.addEventListener('input', blocker);
             // $flow-disable-line
             el.__ieph = true; /* IE placeholder patched */
         }
@@ -6047,8 +6038,8 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event_1 = isIE ? 'change' : 'input';
-        on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
+        var event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
         delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
@@ -6081,17 +6072,17 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp_1 = currentFlushTimestamp;
-        var original_1 = handler;
+        var attachedTimestamp = currentFlushTimestamp;
+        var original = handler;
         //@ts-expect-error
-        handler = original_1._wrapper = function (e) {
+        handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
             // this is just a safety net in case event.timeStamp is unreliable in
             // certain weird environments...
             e.target === e.currentTarget ||
                 // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp_1 ||
+                e.timeStamp >= attachedTimestamp ||
                 // bail for environments that have buggy event.timeStamp implementations
                 // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                 // #9681 QtWebEngine event.timeStamp is negative value
@@ -6100,7 +6091,7 @@ function add(name, handler, capture, passive) {
                 // electron/nw.js app, since event.timeStamp will be using a different
                 // starting reference
                 e.target.ownerDocument !== document) {
-                return original_1.apply(this, arguments);
+                return original.apply(this, arguments);
             }
         };
     }
@@ -6332,9 +6323,9 @@ var normalize = cached(function (prop) {
     }
     var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
     for (var i = 0; i < vendorNames.length; i++) {
-        var name_1 = vendorNames[i] + capName;
-        if (name_1 in emptyStyle) {
-            return name_1;
+        var name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
         }
     }
 });
@@ -6459,12 +6450,12 @@ function resolveTransition$1(def) {
 }
 var autoCssTransition$1 = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition$1 = inBrowser && !isIE9;
@@ -6516,7 +6507,10 @@ function removeTransitionClass$1(el, cls) {
     removeClass$1(el, cls);
 }
 function whenTransitionEnds$1(el, expectedType, cb) {
-    var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo$1(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
@@ -6621,7 +6615,23 @@ function enter$1(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -6729,7 +6739,17 @@ function leave$1(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength$1(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -6803,7 +6823,7 @@ function leave$1(vnode, rm) {
 function checkDuration$1(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn("<transition> explicit " + name + " duration is NaN - " +
@@ -6843,7 +6863,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function (vnode, rm) {
+        remove: function remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -6879,7 +6899,7 @@ if (isIE9) {
     });
 }
 var directive = {
-    inserted: function (el, binding, vnode, oldVnode) {
+    inserted: function inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -6909,22 +6929,22 @@ var directive = {
             }
         }
     },
-    componentUpdated: function (el, binding, vnode) {
+    componentUpdated: function componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions_1 = el._vOptions;
-            var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+            var prevOptions = el._vOptions;
+            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
                 // trigger change event if
                 // no matching option found for at least one value
                 var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
                     : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions_1);
+                        hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
                     trigger(el, 'change');
                 }
@@ -6946,8 +6966,8 @@ function actuallySetSelected(el, binding, vm) {
     var isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("<select multiple v-model=\"" + binding.expression + "\"> " +
-                ("expects an Array value for its binding, but got " + Object.prototype.toString
+            warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                "expects an Array value for its binding, but got " + (Object.prototype.toString
                     .call(value)
                     .slice(8, -1)), vm);
         return;
@@ -7078,12 +7098,12 @@ function resolveTransition(def) {
 }
 var autoCssTransition = cached(function (name) {
     return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
+        enterClass: (name + "-enter"),
+        enterToClass: (name + "-enter-to"),
+        enterActiveClass: (name + "-enter-active"),
+        leaveClass: (name + "-leave"),
+        leaveToClass: (name + "-leave-to"),
+        leaveActiveClass: (name + "-leave-active"),
     };
 });
 var hasTransition = inBrowser && !isIE9;
@@ -7135,7 +7155,10 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
     if (!type)
         { return cb(); }
     var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7240,7 +7263,23 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
@@ -7348,7 +7387,17 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
     var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7422,7 +7471,7 @@ function leave(vnode, rm) {
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
-            ("got " + JSON.stringify(val) + "."), vnode.context);
+            "got " + (JSON.stringify(val)) + ".", vnode.context);
     }
     else if (isNaN(val)) {
         warn("<transition> explicit " + name + " duration is NaN - " +
@@ -7462,8 +7511,9 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function (el, _a, vnode) {
-        var value = _a.value;
+    bind: function bind(el, ref, vnode) {
+        var value = ref.value;
+
         vnode = locateNode(vnode);
         var transition = vnode.data && vnode.data.transition;
         var originalDisplay = (el.__vOriginalDisplay =
@@ -7478,8 +7528,10 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function (el, _a, vnode) {
-        var value = _a.value, oldValue = _a.oldValue;
+    update: function update(el, ref, vnode) {
+        var value = ref.value;
+        var oldValue = ref.oldValue;
+
         /* istanbul ignore if */
         if (!value === !oldValue)
             { return; }
@@ -7502,7 +7554,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7553,8 +7605,8 @@ function extractTransitionData(comp) {
     // events.
     // extract listeners and pass them directly to the transition methods
     var listeners = options._parentListeners;
-    for (var key in listeners) {
-        data[camelize(key)] = listeners[key];
+    for (var key$1 in listeners) {
+        data[camelize(key$1)] = listeners[key$1];
     }
     return data;
 }
@@ -7582,8 +7634,9 @@ var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function (h) {
-        var _this = this;
+    render: function render(h) {
+        var this$1 = this;
+
         var children = this.$slots.default;
         if (!children) {
             return;
@@ -7626,7 +7679,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + this._uid + "-";
+        var id = "__transition-" + (this._uid) + "-";
         child.key =
             child.key == null
                 ? child.isComment
@@ -7660,8 +7713,8 @@ var Transition = {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
                 mergeVNodeHook(oldData, 'afterLeave', function () {
-                    _this._leaving = false;
-                    _this.$forceUpdate();
+                    this$1._leaving = false;
+                    this$1.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7669,14 +7722,14 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave_1;
+                var delayedLeave;
                 var performLeave = function () {
-                    delayedLeave_1();
+                    delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
                 mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave_1 = leave;
+                    delayedLeave = leave;
                 });
             }
         }
@@ -7693,21 +7746,22 @@ var props = extend({
 delete props.mode;
 var TransitionGroup = {
     props: props,
-    beforeMount: function () {
-        var _this = this;
+    beforeMount: function beforeMount() {
+        var this$1 = this;
+
         var update = this._update;
         this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(_this);
+            var restoreActiveInstance = setActiveInstance(this$1);
             // force removing pass
-            _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            _this._vnode = _this.kept;
+            this$1._vnode = this$1.kept;
             restoreActiveInstance();
-            update.call(_this, vnode, hydrating);
+            update.call(this$1, vnode, hydrating);
         };
     },
-    render: function (h) {
+    render: function render(h) {
         var tag = this.tag || this.$vnode.data.tag || 'span';
         var map = Object.create(null);
         var prevChildren = (this.prevChildren = this.children);
@@ -7724,27 +7778,27 @@ var TransitionGroup = {
                 }
                 else if (process.env.NODE_ENV !== 'production') {
                     var opts = c.componentOptions;
-                    var name_1 = opts
+                    var name = opts
                         ? opts.Ctor.options.name || opts.tag || ''
                         : c.tag;
-                    warn("<transition-group> children must be keyed: <" + name_1 + ">");
+                    warn(("<transition-group> children must be keyed: <" + name + ">"));
                 }
             }
         }
         if (prevChildren) {
             var kept = [];
             var removed = [];
-            for (var i = 0; i < prevChildren.length; i++) {
-                var c = prevChildren[i];
-                c.data.transition = transitionData;
+            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                var c$1 = prevChildren[i$1];
+                c$1.data.transition = transitionData;
                 // @ts-ignore
-                c.data.pos = c.elm.getBoundingClientRect();
+                c$1.data.pos = c$1.elm.getBoundingClientRect();
                 // @ts-ignore
-                if (map[c.key]) {
-                    kept.push(c);
+                if (map[c$1.key]) {
+                    kept.push(c$1);
                 }
                 else {
-                    removed.push(c);
+                    removed.push(c$1);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7752,7 +7806,7 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function () {
+    updated: function updated() {
         var children = this.prevChildren;
         var moveClass = this.moveClass || (this.name || 'v') + '-move';
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7770,25 +7824,25 @@ var TransitionGroup = {
         children.forEach(function (c) {
             // @ts-ignore
             if (c.data.moved) {
-                var el_1 = c.elm;
-                var s = el_1.style;
-                addTransitionClass(el_1, moveClass);
+                var el = c.elm;
+                var s = el.style;
+                addTransitionClass(el, moveClass);
                 s.transform = s.WebkitTransform = s.transitionDuration = '';
-                el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                    if (e && e.target !== el_1) {
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
                         return;
                     }
                     if (!e || /transform$/.test(e.propertyName)) {
-                        el_1.removeEventListener(transitionEndEvent, cb);
-                        el_1._moveCb = null;
-                        removeTransitionClass(el_1, moveClass);
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
                     }
                 }));
             }
         });
     },
     methods: {
-        hasMove: function (el, moveClass) {
+        hasMove: function hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 1f7cb2057c5..19156ffc450 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -424,7 +424,7 @@
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
   function parsePath(path) {
       if (bailRE.test(path)) {
           return;
@@ -467,7 +467,7 @@
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function () {
+              get: function get() {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
@@ -513,19 +513,20 @@
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /** @class */ (function () {
+      _Set = /*@__PURE__*/(function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function (key) {
+          Set.prototype.has = function has (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function (key) {
+          Set.prototype.add = function add (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function () {
+          Set.prototype.clear = function clear () {
               this.set = Object.create(null);
           };
+
           return Set;
       }());
   }
@@ -535,22 +536,20 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole_1 = typeof console !== 'undefined';
-      var classifyRE_1 = /(?:^|[-_])(\w)/g;
-      var classify_1 = function (str) {
-          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-      };
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
       warn = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
           if (config.warnHandler) {
               config.warnHandler.call(null, msg, vm, trace);
           }
-          else if (hasConsole_1 && !config.silent) {
-              console.error("[Vue warn]: " + msg + trace);
+          else if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole_1 && !config.silent) {
+          if (hasConsole && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -573,10 +572,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-              (file && includeFile !== false ? " at " + file : ''));
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
       };
-      var repeat_1 = function (str, n) {
+      var repeat = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -610,15 +609,13 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) {
-                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                          : formatComponentName(vm));
-                  })
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
                       .join('\n'));
           }
           else {
-              return "\n\n(found in " + formatComponentName(vm) + ")";
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
           }
       };
   }
@@ -628,37 +625,34 @@
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = /** @class */ (function () {
-      function Dep() {
-          this.id = uid$2++;
-          this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid$2++;
+      this.subs = [];
+  };
+  Dep.prototype.addSub = function addSub (sub) {
+      this.subs.push(sub);
+  };
+  Dep.prototype.removeSub = function removeSub (sub) {
+      remove$2(this.subs, sub);
+  };
+  Dep.prototype.depend = function depend () {
+      if (Dep.target) {
+          Dep.target.addDep(this);
       }
-      Dep.prototype.addSub = function (sub) {
-          this.subs.push(sub);
-      };
-      Dep.prototype.removeSub = function (sub) {
-          remove$2(this.subs, sub);
-      };
-      Dep.prototype.depend = function () {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      };
-      Dep.prototype.notify = function () {
-          // stabilize the subscriber list first
-          var subs = this.subs.slice();
-          if (!config.async) {
-              // subs aren't sorted in scheduler if not running async
-              // we need to sort them now to make sure they fire in correct
-              // order
-              subs.sort(function (a, b) { return a.id - b.id; });
-          }
-          for (var i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      };
-      return Dep;
-  }());
+  };
+  Dep.prototype.notify = function notify () {
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      if (!config.async) {
+          // subs aren't sorted in scheduler if not running async
+          // we need to sort them now to make sure they fire in correct
+          // order
+          subs.sort(function (a, b) { return a.id - b.id; });
+      }
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
+  };
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
@@ -673,45 +667,43 @@
       Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = /** @class */ (function () {
-      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      Object.defineProperty(VNode.prototype, "child", {
-          // DEPRECATED: alias for componentInstance for backwards compat.
-          /* istanbul ignore next */
-          get: function () {
-              return this.componentInstance;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return VNode;
-  }());
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
+  };
+
+  var prototypeAccessors = { child: { configurable: true } };
+  // DEPRECATED: alias for componentInstance for backwards compat.
+  /* istanbul ignore next */
+  prototypeAccessors.child.get = function () {
+      return this.componentInstance;
+  };
+
+  Object.defineProperties( VNode.prototype, prototypeAccessors );
   var createEmptyVNode = function (text) {
-      if (text === void 0) { text = ''; }
+      if ( text === void 0 ) text = '';
+
       var node = new VNode();
       node.text = text;
       node.isComment = true;
@@ -765,12 +757,9 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var arguments$1 = arguments;
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
 
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments$1[_i];
-          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -806,46 +795,43 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = /** @class */ (function () {
-      function Observer(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
           }
           else {
-              this.walk(value);
+              copyAugment(value, arrayMethods, arrayKeys);
           }
+          this.observeArray(value);
       }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      Observer.prototype.walk = function (obj) {
-          var keys = Object.keys(obj);
-          for (var i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      };
-      /**
-       * Observe a list of Array items.
-       */
-      Observer.prototype.observeArray = function (items) {
-          for (var i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      };
-      return Observer;
-  }());
+      else {
+          this.walk(value);
+      }
+  };
+  /**
+   * Walk through all properties and convert them into
+   * getter/setters. This method should only be called when
+   * value type is Object.
+   */
+  Observer.prototype.walk = function walk (obj) {
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive(obj, keys[i]);
+      }
+  };
+  /**
+   * Observe a list of Array items.
+   */
+  Observer.prototype.observeArray = function observeArray (items) {
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
+  };
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -955,7 +941,7 @@
    */
   function set(target, key, val) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
+          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -986,7 +972,7 @@
    */
   function del(target, key) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
+          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.splice(key, 1);
@@ -1013,7 +999,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1188,14 +1174,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key_1 in childVal) {
-          var parent_1 = ret[key_1];
-          var child = childVal[key_1];
-          if (parent_1 && !Array.isArray(parent_1)) {
-              parent_1 = [parent_1];
-          }
-          ret[key_1] = parent_1
-              ? parent_1.concat(child)
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1233,7 +1219,7 @@
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
           warn('Invalid component name: "' +
               name +
               '". Component names ' +
@@ -1277,7 +1263,7 @@
       }
       else {
           warn("Invalid value for option \"props\": expected an Array or an Object, " +
-              ("but got " + toRawType(props) + "."), vm);
+              "but got " + (toRawType(props)) + ".", vm);
       }
       options.props = res;
   }
@@ -1304,7 +1290,7 @@
       }
       else {
           warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-              ("but got " + toRawType(inject) + "."), vm);
+              "but got " + (toRawType(inject)) + ".", vm);
       }
   }
   /**
@@ -1324,7 +1310,7 @@
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
           warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              ("but got " + toRawType(value) + "."), vm);
+              "but got " + (toRawType(value)) + ".", vm);
       }
   }
   /**
@@ -1560,7 +1546,7 @@
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
       var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          (" Expected " + expectedTypes.map(capitalize).join(', '));
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
       var expectedType = expectedTypes[0];
       var receivedType = toRawType(value);
       // check if we need to specify expected value
@@ -1568,24 +1554,24 @@
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + styleValue(value, expectedType);
+          message += " with value " + (styleValue(value, expectedType));
       }
       message += ", got " + receivedType + " ";
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + styleValue(value, receivedType) + ".";
+          message += "with value " + (styleValue(value, receivedType)) + ".";
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return "\"" + value + "\"";
+          return ("\"" + value + "\"");
       }
       else if (type === 'Number') {
-          return "" + Number(value);
+          return ("" + (Number(value)));
       }
       else {
-          return "" + value;
+          return ("" + value);
       }
   }
   var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1593,12 +1579,9 @@
       return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-      var arguments$1 = arguments;
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments$1[_i];
-      }
       return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
@@ -1664,7 +1647,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
+          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1707,9 +1690,9 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p_1 = Promise.resolve();
+      var p = Promise.resolve();
       timerFunc = function () {
-          p_1.then(flushCallbacks);
+          p.then(flushCallbacks);
           // In problematic UIWebViews, Promise.then doesn't completely break, but
           // it can get stuck in a weird state where callbacks are pushed into the
           // microtask queue but the queue isn't being flushed, until the browser
@@ -1728,15 +1711,15 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter_1 = 1;
+      var counter = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode_1 = document.createTextNode(String(counter_1));
-      observer.observe(textNode_1, {
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
           characterData: true,
       });
       timerFunc = function () {
-          counter_1 = (counter_1 + 1) % 2;
-          textNode_1.data = String(counter_1);
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
       };
       isUsingMicroTask = true;
   }
@@ -1784,31 +1767,31 @@
   /* not type checking this file because flow doesn't play well with Proxy */
   var initProxy;
   {
-      var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var warnNonPresent_1 = function (target, key) {
+      var warnNonPresent = function (target, key) {
           warn("Property or method \"" + key + "\" is not defined on the instance but " +
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
               'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
-      var warnReservedPrefix_1 = function (target, key) {
+      var warnReservedPrefix = function (target, key) {
           warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
               'See: https://vuejs.org/v2/api/#data', target);
       };
-      var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy_1) {
-          var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function (target, key, value) {
-                  if (isBuiltInModifier_1(key)) {
-                      warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                       return false;
                   }
                   else {
@@ -1818,38 +1801,38 @@
               },
           });
       }
-      var hasHandler_1 = {
-          has: function (target, key) {
+      var hasHandler = {
+          has: function has(target, key) {
               var has = key in target;
-              var isAllowed = allowedGlobals_1(key) ||
+              var isAllowed = allowedGlobals(key) ||
                   (typeof key === 'string' &&
                       key.charAt(0) === '_' &&
                       !(key in target.$data));
               if (!has && !isAllowed) {
                   if (key in target.$data)
-                      { warnReservedPrefix_1(target, key); }
+                      { warnReservedPrefix(target, key); }
                   else
-                      { warnNonPresent_1(target, key); }
+                      { warnNonPresent(target, key); }
               }
               return has || !isAllowed;
           },
       };
-      var getHandler_1 = {
-          get: function (target, key) {
+      var getHandler = {
+          get: function get(target, key) {
               if (typeof key === 'string' && !(key in target)) {
                   if (key in target.$data)
-                      { warnReservedPrefix_1(target, key); }
+                      { warnReservedPrefix(target, key); }
                   else
-                      { warnNonPresent_1(target, key); }
+                      { warnNonPresent(target, key); }
               }
               return target[key];
           },
       };
       initProxy = function initProxy(vm) {
-          if (hasProxy_1) {
+          if (hasProxy) {
               // determine which proxy handler to use
               var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
+              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
               vm._renderProxy = new Proxy(vm, handlers);
           }
           else {
@@ -1899,18 +1882,18 @@
   var mark;
   var measure;
   {
-      var perf_1 = inBrowser && window.performance;
+      var perf = inBrowser && window.performance;
       /* istanbul ignore if */
-      if (perf_1 &&
-          perf_1.mark &&
-          perf_1.measure &&
-          perf_1.clearMarks &&
-          perf_1.clearMeasures) {
-          mark = function (tag) { return perf_1.mark(tag); };
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = function (tag) { return perf.mark(tag); };
           measure = function (name, startTag, endTag) {
-              perf_1.measure(name, startTag, endTag);
-              perf_1.clearMarks(startTag);
-              perf_1.clearMarks(endTag);
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
               // perf.clearMeasures(name)
           };
       }
@@ -1956,7 +1939,7 @@
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -2021,7 +2004,8 @@
           return;
       }
       var res = {};
-      var attrs = data.attrs, props = data.props;
+      var attrs = data.attrs;
+      var props = data.props;
       if (isDef(attrs) || isDef(props)) {
           for (var key in propOptions) {
               var altKey = hyphenate(key);
@@ -2031,11 +2015,11 @@
                       tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                           (formatComponentName(
                           // @ts-ignore
-                          tag || Ctor) + ", but the declared prop name is") +
-                          (" \"" + key + "\". ") +
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
                           "Note that HTML attributes are case-insensitive and camelCased " +
                           "props need to use their kebab-case equivalents when using in-DOM " +
-                          ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -2109,7 +2093,7 @@
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2170,7 +2154,7 @@
                   defineReactive(vm, key, result[key], function () {
                       warn("Avoid mutating an injected value directly since the changes will be " +
                           "overwritten whenever the provided component re-renders. " +
-                          ("injection being mutated: \"" + key + "\""), vm);
+                          "injection being mutated: \"" + key + "\"", vm);
                   });
               }
           });
@@ -2207,7 +2191,7 @@
                   }
                   else {
                       // @ts-ignore
-                      warn("Injection \"" + key + "\" not found", vm);
+                      warn(("Injection \"" + key + "\" not found"), vm);
                   }
               }
           }
@@ -2235,8 +2219,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name_1 = data.slot;
-              var slot = slots[name_1] || (slots[name_1] = []);
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -2249,9 +2233,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name_2 in slots) {
-          if (slots[name_2].every(isWhitespace)) {
-              delete slots[name_2];
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
           }
       }
       return slots;
@@ -2284,16 +2268,16 @@
       }
       else {
           res = {};
-          for (var key_1 in slots) {
-              if (slots[key_1] && key_1[0] !== '$') {
-                  res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key_2 in normalSlots) {
-          if (!(key_2 in res)) {
-              res[key_2] = proxyNormalSlot(normalSlots, key_2);
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2450,8 +2434,8 @@
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash = void 0;
-              var _loop_1 = function (key) {
+              var hash;
+              var loop = function ( key ) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
@@ -2468,15 +2452,14 @@
                       hash[key] = value[key];
                       if (isSync) {
                           var on = data.on || (data.on = {});
-                          on["update:" + key] = function ($event) {
+                          on[("update:" + key)] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
               };
-              for (var key in value) {
-                  _loop_1(key);
-              }
+
+              for (var key in value) loop( key );
           }
       }
       return data;
@@ -2496,7 +2479,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic(tree, "__static__" + index, false);
+      markStatic(tree, ("__static__" + index), false);
       return tree;
   }
   /**
@@ -2504,14 +2487,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
       return tree;
   }
   function markStatic(tree, key, isOnce) {
       if (Array.isArray(tree)) {
           for (var i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], key + "_" + i, isOnce);
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
               }
           }
       }
@@ -2577,7 +2560,7 @@
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
           }
       }
       return baseObj;
@@ -2610,7 +2593,8 @@
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var _this = this;
+      var this$1 = this;
+
       var options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
@@ -2637,14 +2621,14 @@
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
       this.slots = function () {
-          if (!_this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
           }
-          return _this.$slots;
+          return this$1.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function () {
+          get: function get() {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -2667,9 +2651,7 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) {
-              return createElement$1(contextVm, a, b, c, d, needNormalization);
-          };
+          this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
@@ -2725,7 +2707,7 @@
 
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function (vnode, hydrating) {
+      init: function init(vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
@@ -2738,7 +2720,7 @@
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function (oldVnode, vnode) {
+      prepatch: function prepatch(oldVnode, vnode) {
           var options = vnode.componentOptions;
           var child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
@@ -2747,8 +2729,9 @@
           options.children // new children
           );
       },
-      insert: function (vnode) {
-          var context = vnode.context, componentInstance = vnode.componentInstance;
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
               callHook$1(componentInstance, 'mounted');
@@ -2767,7 +2750,7 @@
               }
           }
       },
-      destroy: function (vnode) {
+      destroy: function destroy(vnode) {
           var componentInstance = vnode.componentInstance;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
@@ -2793,7 +2776,7 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn("Invalid Component definition: " + String(Ctor), context);
+              warn(("Invalid Component definition: " + (String(Ctor))), context);
           }
           return;
       }
@@ -2851,7 +2834,7 @@
       var name = Ctor.options.name || tag;
       var vnode = new VNode(
       // @ts-expect-error
-      "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
       // @ts-expect-error
       { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
       return vnode;
@@ -2933,7 +2916,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -2968,14 +2951,14 @@
       }
       var vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor = void 0;
+          var Ctor;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if (config.isReservedTag(tag)) {
               // platform built-in elements
               if (isDef(data) &&
                   isDef(data.nativeOn) &&
                   data.tag !== 'component') {
-                  warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
+                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
               }
               vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
           }
@@ -3078,7 +3061,9 @@
       };
       Vue.prototype._render = function () {
           var vm = this;
-          var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
+          var ref = vm.$options;
+          var render = ref.render;
+          var _parentVnode = ref._parentVnode;
           if (_parentVnode) {
               vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
@@ -3161,24 +3146,24 @@
           return factory.loadingComp;
       }
       if (owner && !isDef(factory.owners)) {
-          var owners_1 = (factory.owners = [owner]);
-          var sync_1 = true;
-          var timerLoading_1 = null;
-          var timerTimeout_1 = null;
-          owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-          var forceRender_1 = function (renderCompleted) {
-              for (var i = 0, l = owners_1.length; i < l; i++) {
-                  owners_1[i].$forceUpdate();
+          var owners = (factory.owners = [owner]);
+          var sync = true;
+          var timerLoading = null;
+          var timerTimeout = null;
+          owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+          var forceRender = function (renderCompleted) {
+              for (var i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
               }
               if (renderCompleted) {
-                  owners_1.length = 0;
-                  if (timerLoading_1 !== null) {
-                      clearTimeout(timerLoading_1);
-                      timerLoading_1 = null;
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
                   }
-                  if (timerTimeout_1 !== null) {
-                      clearTimeout(timerTimeout_1);
-                      timerTimeout_1 = null;
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
                   }
               }
           };
@@ -3187,63 +3172,63 @@
               factory.resolved = ensureCtor(res, baseCtor);
               // invoke callbacks only if this is not a synchronous resolve
               // (async resolves are shimmed as synchronous during SSR)
-              if (!sync_1) {
-                  forceRender_1(true);
+              if (!sync) {
+                  forceRender(true);
               }
               else {
-                  owners_1.length = 0;
+                  owners.length = 0;
               }
           });
-          var reject_1 = once(function (reason) {
-              warn("Failed to resolve async component: " + String(factory) +
-                      (reason ? "\nReason: " + reason : ''));
+          var reject = once(function (reason) {
+              warn("Failed to resolve async component: " + (String(factory)) +
+                      (reason ? ("\nReason: " + reason) : ''));
               if (isDef(factory.errorComp)) {
                   factory.error = true;
-                  forceRender_1(true);
+                  forceRender(true);
               }
           });
-          var res_1 = factory(resolve, reject_1);
-          if (isObject(res_1)) {
-              if (isPromise(res_1)) {
+          var res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
                   // () => Promise
                   if (isUndef(factory.resolved)) {
-                      res_1.then(resolve, reject_1);
+                      res.then(resolve, reject);
                   }
               }
-              else if (isPromise(res_1.component)) {
-                  res_1.component.then(resolve, reject_1);
-                  if (isDef(res_1.error)) {
-                      factory.errorComp = ensureCtor(res_1.error, baseCtor);
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
                   }
-                  if (isDef(res_1.loading)) {
-                      factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                      if (res_1.delay === 0) {
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
                           factory.loading = true;
                       }
                       else {
                           // @ts-expect-error NodeJS timeout type
-                          timerLoading_1 = setTimeout(function () {
-                              timerLoading_1 = null;
+                          timerLoading = setTimeout(function () {
+                              timerLoading = null;
                               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                   factory.loading = true;
-                                  forceRender_1(false);
+                                  forceRender(false);
                               }
-                          }, res_1.delay || 200);
+                          }, res.delay || 200);
                       }
                   }
-                  if (isDef(res_1.timeout)) {
+                  if (isDef(res.timeout)) {
                       // @ts-expect-error NodeJS timeout type
-                      timerTimeout_1 = setTimeout(function () {
-                          timerTimeout_1 = null;
+                      timerTimeout = setTimeout(function () {
+                          timerTimeout = null;
                           if (isUndef(factory.resolved)) {
-                              reject_1("timeout (" + res_1.timeout + "ms)"
+                              reject(("timeout (" + (res.timeout) + "ms)")
                                   );
                           }
-                      }, res_1.timeout);
+                      }, res.timeout);
                   }
               }
           }
-          sync_1 = false;
+          sync = false;
           // return in case resolved synchronously
           return factory.loading ? factory.loadingComp : factory.resolved;
       }
@@ -3333,8 +3318,8 @@
           }
           // array of events
           if (Array.isArray(event)) {
-              for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                  vm.$off(event[i_1], fn);
+              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                  vm.$off(event[i$1], fn);
               }
               return vm;
           }
@@ -3365,10 +3350,10 @@
               var lowerCaseEvent = event.toLowerCase();
               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
                   tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
+                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
                       "Note that HTML attributes are case-insensitive and you cannot use " +
                       "v-on to listen to camelCase events when using in-DOM templates. " +
-                      ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
+                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
               }
           }
           var cbs = vm._events[event];
@@ -3529,11 +3514,11 @@
               mark(startTag);
               var vnode = vm._render();
               mark(endTag);
-              measure("vue " + name + " render", startTag, endTag);
+              measure(("vue " + name + " render"), startTag, endTag);
               mark(startTag);
               vm._update(vnode, hydrating);
               mark(endTag);
-              measure("vue " + name + " patch", startTag, endTag);
+              measure(("vue " + name + " patch"), startTag, endTag);
           };
       }
       else {
@@ -3545,7 +3530,7 @@
       // since the watcher's initial patch may call $forceUpdate (e.g. inside child
       // component's mounted hook), which relies on vm._watcher being already defined
       new Watcher(vm, updateComponent, noop, {
-          before: function () {
+          before: function before() {
               if (vm._isMounted && !vm._isDestroyed) {
                   callHook$1(vm, 'beforeUpdate');
               }
@@ -3714,15 +3699,15 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance_1 = window.performance;
-      if (performance_1 &&
-          typeof performance_1.now === 'function' &&
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
           // if the event timestamp, although evaluated AFTER the Date.now(), is
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance_1.now(); };
+          getNow = function () { return performance.now(); };
       }
   }
   /**
@@ -3757,7 +3742,7 @@
               if (circular[id] > MAX_UPDATE_COUNT) {
                   warn('You may have an infinite update loop ' +
                       (watcher.user
-                          ? "in watcher with expression \"" + watcher.expression + "\""
+                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
                           : "in a component render function."), watcher.vm);
                   break;
               }
@@ -3841,194 +3826,191 @@
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = /** @class */ (function () {
-      function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-          this.vm = vm;
-          if (isRenderWatcher) {
-              vm._watcher = this;
-          }
-          vm._watchers.push(this);
-          // options
-          if (options) {
-              this.deep = !!options.deep;
-              this.user = !!options.user;
-              this.lazy = !!options.lazy;
-              this.sync = !!options.sync;
-              this.before = options.before;
+  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
+      this.vm = vm;
+      if (isRenderWatcher) {
+          vm._watcher = this;
+      }
+      vm._watchers.push(this);
+      // options
+      if (options) {
+          this.deep = !!options.deep;
+          this.user = !!options.user;
+          this.lazy = !!options.lazy;
+          this.sync = !!options.sync;
+          this.before = options.before;
+      }
+      else {
+          this.deep = this.user = this.lazy = this.sync = false;
+      }
+      this.cb = cb;
+      this.id = ++uid$1; // uid for batching
+      this.active = true;
+      this.dirty = this.lazy; // for lazy watchers
+      this.deps = [];
+      this.newDeps = [];
+      this.depIds = new _Set();
+      this.newDepIds = new _Set();
+      this.expression =
+          expOrFn.toString() ;
+      // parse expression for getter
+      if (typeof expOrFn === 'function') {
+          this.getter = expOrFn;
+      }
+      else {
+          this.getter = parsePath(expOrFn);
+          if (!this.getter) {
+              this.getter = noop;
+              warn("Failed watching path: \"" + expOrFn + "\" " +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
           }
-          else {
-              this.deep = this.user = this.lazy = this.sync = false;
-          }
-          this.cb = cb;
-          this.id = ++uid$1; // uid for batching
-          this.active = true;
-          this.dirty = this.lazy; // for lazy watchers
-          this.deps = [];
-          this.newDeps = [];
-          this.depIds = new _Set();
-          this.newDepIds = new _Set();
-          this.expression =
-              expOrFn.toString() ;
-          // parse expression for getter
-          if (typeof expOrFn === 'function') {
-              this.getter = expOrFn;
+      }
+      this.value = this.lazy ? undefined : this.get();
+  };
+  /**
+   * Evaluate the getter, and re-collect dependencies.
+   */
+  Watcher.prototype.get = function get () {
+      pushTarget(this);
+      var value;
+      var vm = this.vm;
+      try {
+          value = this.getter.call(vm, vm);
+      }
+      catch (e) {
+          if (this.user) {
+              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
           }
           else {
-              this.getter = parsePath(expOrFn);
-              if (!this.getter) {
-                  this.getter = noop;
-                  warn("Failed watching path: \"" + expOrFn + "\" " +
-                          'Watcher only accepts simple dot-delimited paths. ' +
-                          'For full control, use a function instead.', vm);
-              }
+              throw e;
           }
-          this.value = this.lazy ? undefined : this.get();
       }
-      /**
-       * Evaluate the getter, and re-collect dependencies.
-       */
-      Watcher.prototype.get = function () {
-          pushTarget(this);
-          var value;
-          var vm = this.vm;
-          try {
-              value = this.getter.call(vm, vm);
+      finally {
+          // "touch" every property so they are all tracked as
+          // dependencies for deep watching
+          if (this.deep) {
+              traverse(value);
           }
-          catch (e) {
+          popTarget();
+          this.cleanupDeps();
+      }
+      return value;
+  };
+  /**
+   * Add a dependency to this directive.
+   */
+  Watcher.prototype.addDep = function addDep (dep) {
+      var id = dep.id;
+      if (!this.newDepIds.has(id)) {
+          this.newDepIds.add(id);
+          this.newDeps.push(dep);
+          if (!this.depIds.has(id)) {
+              dep.addSub(this);
+          }
+      }
+  };
+  /**
+   * Clean up for dependency collection.
+   */
+  Watcher.prototype.cleanupDeps = function cleanupDeps () {
+      var i = this.deps.length;
+      while (i--) {
+          var dep = this.deps[i];
+          if (!this.newDepIds.has(dep.id)) {
+              dep.removeSub(this);
+          }
+      }
+      var tmp = this.depIds;
+      this.depIds = this.newDepIds;
+      this.newDepIds = tmp;
+      this.newDepIds.clear();
+      tmp = this.deps;
+      this.deps = this.newDeps;
+      this.newDeps = tmp;
+      this.newDeps.length = 0;
+  };
+  /**
+   * Subscriber interface.
+   * Will be called when a dependency changes.
+   */
+  Watcher.prototype.update = function update () {
+      /* istanbul ignore else */
+      if (this.lazy) {
+          this.dirty = true;
+      }
+      else if (this.sync) {
+          this.run();
+      }
+      else {
+          queueWatcher(this);
+      }
+  };
+  /**
+   * Scheduler job interface.
+   * Will be called by the scheduler.
+   */
+  Watcher.prototype.run = function run () {
+      if (this.active) {
+          var value = this.get();
+          if (value !== this.value ||
+              // Deep watchers and watchers on Object/Arrays should fire even
+              // when the value is the same, because the value may
+              // have mutated.
+              isObject(value) ||
+              this.deep) {
+              // set new value
+              var oldValue = this.value;
+              this.value = value;
               if (this.user) {
-                  handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
+                  try {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+                  catch (e) {
+                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  }
               }
               else {
-                  throw e;
-              }
-          }
-          finally {
-              // "touch" every property so they are all tracked as
-              // dependencies for deep watching
-              if (this.deep) {
-                  traverse(value);
-              }
-              popTarget();
-              this.cleanupDeps();
-          }
-          return value;
-      };
-      /**
-       * Add a dependency to this directive.
-       */
-      Watcher.prototype.addDep = function (dep) {
-          var id = dep.id;
-          if (!this.newDepIds.has(id)) {
-              this.newDepIds.add(id);
-              this.newDeps.push(dep);
-              if (!this.depIds.has(id)) {
-                  dep.addSub(this);
+                  this.cb.call(this.vm, value, oldValue);
               }
           }
-      };
-      /**
-       * Clean up for dependency collection.
-       */
-      Watcher.prototype.cleanupDeps = function () {
-          var i = this.deps.length;
-          while (i--) {
-              var dep = this.deps[i];
-              if (!this.newDepIds.has(dep.id)) {
-                  dep.removeSub(this);
-              }
-          }
-          var tmp = this.depIds;
-          this.depIds = this.newDepIds;
-          this.newDepIds = tmp;
-          this.newDepIds.clear();
-          tmp = this.deps;
-          this.deps = this.newDeps;
-          this.newDeps = tmp;
-          this.newDeps.length = 0;
-      };
-      /**
-       * Subscriber interface.
-       * Will be called when a dependency changes.
-       */
-      Watcher.prototype.update = function () {
-          /* istanbul ignore else */
-          if (this.lazy) {
-              this.dirty = true;
-          }
-          else if (this.sync) {
-              this.run();
-          }
-          else {
-              queueWatcher(this);
-          }
-      };
-      /**
-       * Scheduler job interface.
-       * Will be called by the scheduler.
-       */
-      Watcher.prototype.run = function () {
-          if (this.active) {
-              var value = this.get();
-              if (value !== this.value ||
-                  // Deep watchers and watchers on Object/Arrays should fire even
-                  // when the value is the same, because the value may
-                  // have mutated.
-                  isObject(value) ||
-                  this.deep) {
-                  // set new value
-                  var oldValue = this.value;
-                  this.value = value;
-                  if (this.user) {
-                      try {
-                          this.cb.call(this.vm, value, oldValue);
-                      }
-                      catch (e) {
-                          handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                      }
-                  }
-                  else {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-              }
+      }
+  };
+  /**
+   * Evaluate the value of the watcher.
+   * This only gets called for lazy watchers.
+   */
+  Watcher.prototype.evaluate = function evaluate () {
+      this.value = this.get();
+      this.dirty = false;
+  };
+  /**
+   * Depend on all deps collected by this watcher.
+   */
+  Watcher.prototype.depend = function depend () {
+      var i = this.deps.length;
+      while (i--) {
+          this.deps[i].depend();
+      }
+  };
+  /**
+   * Remove self from all dependencies' subscriber list.
+   */
+  Watcher.prototype.teardown = function teardown () {
+      if (this.active) {
+          // remove self from vm's watcher list
+          // this is a somewhat expensive operation so we skip it
+          // if the vm is being destroyed.
+          if (!this.vm._isBeingDestroyed) {
+              remove$2(this.vm._watchers, this);
           }
-      };
-      /**
-       * Evaluate the value of the watcher.
-       * This only gets called for lazy watchers.
-       */
-      Watcher.prototype.evaluate = function () {
-          this.value = this.get();
-          this.dirty = false;
-      };
-      /**
-       * Depend on all deps collected by this watcher.
-       */
-      Watcher.prototype.depend = function () {
           var i = this.deps.length;
           while (i--) {
-              this.deps[i].depend();
+              this.deps[i].removeSub(this);
           }
-      };
-      /**
-       * Remove self from all dependencies' subscriber list.
-       */
-      Watcher.prototype.teardown = function () {
-          if (this.active) {
-              // remove self from vm's watcher list
-              // this is a somewhat expensive operation so we skip it
-              // if the vm is being destroyed.
-              if (!this.vm._isBeingDestroyed) {
-                  remove$2(this.vm._watchers, this);
-              }
-              var i = this.deps.length;
-              while (i--) {
-                  this.deps[i].removeSub(this);
-              }
-              this.active = false;
-          }
-      };
-      return Watcher;
-  }());
+          this.active = false;
+      }
+  };
 
   var sharedPropertyDefinition = {
       enumerable: true,
@@ -4075,7 +4057,7 @@
       if (!isRoot) {
           toggleObserving(false);
       }
-      var _loop_1 = function (key) {
+      var loop = function ( key ) {
           keys.push(key);
           var value = validateProp(key, propsOptions, propsData, vm);
           /* istanbul ignore else */
@@ -4083,14 +4065,14 @@
               var hyphenatedKey = hyphenate(key);
               if (isReservedAttribute(hyphenatedKey) ||
                   config.isReservedAttr(hyphenatedKey)) {
-                  warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
+                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
               }
               defineReactive(props, key, value, function () {
                   if (!isRoot && !isUpdatingChildComponent) {
                       warn("Avoid mutating a prop directly since the value will be " +
                           "overwritten whenever the parent component re-renders. " +
                           "Instead, use a data or computed property based on the prop's " +
-                          ("value. Prop being mutated: \"" + key + "\""), vm);
+                          "value. Prop being mutated: \"" + key + "\"", vm);
                   }
               });
           }
@@ -4101,9 +4083,8 @@
               proxy(vm, "_props", key);
           }
       };
-      for (var key in propsOptions) {
-          _loop_1(key);
-      }
+
+      for (var key in propsOptions) loop( key );
       toggleObserving(true);
   }
   function initData(vm) {
@@ -4123,7 +4104,7 @@
           var key = keys[i];
           {
               if (methods && hasOwn(methods, key)) {
-                  warn("Method \"" + key + "\" has already been defined as a data property.", vm);
+                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
               }
           }
           if (props && hasOwn(props, key)) {
@@ -4161,7 +4142,7 @@
           var userDef = computed[key];
           var getter = typeof userDef === 'function' ? userDef : userDef.get;
           if (getter == null) {
-              warn("Getter is missing for computed property \"" + key + "\".", vm);
+              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
           }
           if (!isSSR) {
               // create internal watcher for the computed property.
@@ -4175,10 +4156,10 @@
           }
           else {
               if (key in vm.$data) {
-                  warn("The computed property \"" + key + "\" is already defined in data.", vm);
+                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
               }
               else if (vm.$options.props && key in vm.$options.props) {
-                  warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
+                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
               }
           }
       }
@@ -4201,7 +4182,7 @@
       }
       if (sharedPropertyDefinition.set === noop) {
           sharedPropertyDefinition.set = function () {
-              warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
+              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
           };
       }
       Object.defineProperty(target, key, sharedPropertyDefinition);
@@ -4230,11 +4211,11 @@
       for (var key in methods) {
           {
               if (typeof methods[key] !== 'function') {
-                  warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
+                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
                       "Did you reference the function correctly?", vm);
               }
               if (props && hasOwn(props, key)) {
-                  warn("Method \"" + key + "\" has already been defined as a prop.", vm);
+                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
               }
               if (key in vm && isReserved(key)) {
                   warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
@@ -4306,7 +4287,7 @@
                   cb.call(vm, watcher.value);
               }
               catch (error) {
-                  handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
+                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
               }
               popTarget();
           }
@@ -4325,8 +4306,8 @@
           var startTag, endTag;
           /* istanbul ignore if */
           if (config.performance && mark) {
-              startTag = "vue-perf-start:" + vm._uid;
-              endTag = "vue-perf-end:" + vm._uid;
+              startTag = "vue-perf-start:" + (vm._uid);
+              endTag = "vue-perf-end:" + (vm._uid);
               mark(startTag);
           }
           // a flag to avoid this being observed
@@ -4359,7 +4340,7 @@
           if (config.performance && mark) {
               vm._name = formatComponentName(vm, false);
               mark(endTag);
-              measure("vue " + vm._name + " init", startTag, endTag);
+              measure(("vue " + (vm._name) + " init"), startTag, endTag);
           }
           if (vm.$options.el) {
               vm.$mount(vm.$options.el);
@@ -4588,12 +4569,14 @@
       return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
+      var cache = keepAliveInstance.cache;
+      var keys = keepAliveInstance.keys;
+      var _vnode = keepAliveInstance._vnode;
       for (var key in cache) {
           var cachedNode = cache[key];
           if (cachedNode) {
-              var name_1 = getComponentName(cachedNode.componentOptions);
-              if (name_1 && !filter(name_1)) {
+              var name = getComponentName(cachedNode.componentOptions);
+              if (name && !filter(name)) {
                   pruneCacheEntry(cache, key, keys, _vnode);
               }
           }
@@ -4618,45 +4601,50 @@
           exclude: patternTypes,
           max: [String, Number],
       },
-      created: function () {
+      created: function created() {
           this.cache = Object.create(null);
           this.keys = [];
       },
-      destroyed: function () {
+      destroyed: function destroyed() {
           for (var key in this.cache) {
               pruneCacheEntry(this.cache, key, this.keys);
           }
       },
-      mounted: function () {
-          var _this = this;
+      mounted: function mounted() {
+          var this$1 = this;
+
           this.$watch('include', function (val) {
-              pruneCache(_this, function (name) { return matches(val, name); });
+              pruneCache(this$1, function (name) { return matches(val, name); });
           });
           this.$watch('exclude', function (val) {
-              pruneCache(_this, function (name) { return !matches(val, name); });
+              pruneCache(this$1, function (name) { return !matches(val, name); });
           });
       },
-      render: function () {
+      render: function render() {
           var slot = this.$slots.default;
           var vnode = getFirstComponentChild(slot);
           var componentOptions = vnode && vnode.componentOptions;
           if (componentOptions) {
               // check pattern
-              var name_2 = getComponentName(componentOptions);
-              var _a = this, include = _a.include, exclude = _a.exclude;
+              var name = getComponentName(componentOptions);
+              var ref = this;
+              var include = ref.include;
+              var exclude = ref.exclude;
               if (
               // not included
-              (include && (!name_2 || !matches(include, name_2))) ||
+              (include && (!name || !matches(include, name))) ||
                   // excluded
-                  (exclude && name_2 && matches(exclude, name_2))) {
+                  (exclude && name && matches(exclude, name))) {
                   return vnode;
               }
-              var _b = this, cache = _b.cache, keys = _b.keys;
+              var ref$1 = this;
+              var cache = ref$1.cache;
+              var keys = ref$1.keys;
               var key = vnode.key == null
                   ? // same constructor may get registered as different local components
                       // so cid alone is not enough (#3269)
                       componentOptions.Ctor.cid +
-                          (componentOptions.tag ? "::" + componentOptions.tag : '')
+                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
                   : vnode.key;
               if (cache[key]) {
                   vnode.componentInstance = cache[key].componentInstance;
@@ -4728,7 +4716,7 @@
       get: isServerRendering,
   });
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function () {
+      get: function get() {
           /* istanbul ignore next */
           return this.$vnode && this.$vnode.ssrContext;
       },
@@ -4988,16 +4976,16 @@
   });
 
   var ref = {
-      create: function (_, vnode) {
+      create: function create(_, vnode) {
           registerRef(vnode);
       },
-      update: function (oldVnode, vnode) {
+      update: function update(oldVnode, vnode) {
           if (oldVnode.data.ref !== vnode.data.ref) {
               registerRef(oldVnode, true);
               registerRef(vnode);
           }
       },
-      destroy: function (vnode) {
+      destroy: function destroy(vnode) {
           registerRef(vnode, true);
       },
   };
@@ -5079,7 +5067,8 @@
   function createPatchFunction(backend) {
       var i, j;
       var cbs = {};
-      var modules = backend.modules, nodeOps = backend.nodeOps;
+      var modules = backend.modules;
+      var nodeOps = backend.nodeOps;
       for (i = 0; i < hooks.length; ++i) {
           cbs[hooks[i]] = [];
           for (j = 0; j < modules.length; ++j) {
@@ -5250,8 +5239,8 @@
               {
                   checkDuplicateKeys(children);
               }
-              for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                  createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
+              for (var i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
               }
           }
           else if (isPrimitive(vnode.text)) {
@@ -5265,8 +5254,8 @@
           return isDef(vnode.tag);
       }
       function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-              cbs.create[i_2](emptyNode, vnode);
+          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+              cbs.create[i$1](emptyNode, vnode);
           }
           i = vnode.data.hook; // Reuse variable
           if (isDef(i)) {
@@ -5338,7 +5327,7 @@
       }
       function removeAndInvokeRemoveHook(vnode, rm) {
           if (isDef(rm) || isDef(vnode.data)) {
-              var i_3;
+              var i;
               var listeners = cbs.remove.length + 1;
               if (isDef(rm)) {
                   // we have a recursively passed down rm callback
@@ -5350,16 +5339,16 @@
                   rm = createRmCb(vnode.elm, listeners);
               }
               // recursively invoke hooks on child component root node
-              if (isDef((i_3 = vnode.componentInstance)) &&
-                  isDef((i_3 = i_3._vnode)) &&
-                  isDef(i_3.data)) {
-                  removeAndInvokeRemoveHook(i_3, rm);
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
               }
-              for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                  cbs.remove[i_3](vnode, rm);
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
               }
-              if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                  i_3(vnode, rm);
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
               }
               else {
                   rm();
@@ -5455,12 +5444,12 @@
       }
       function checkDuplicateKeys(children) {
           var seenKeys = {};
-          for (var i_4 = 0; i_4 < children.length; i_4++) {
-              var vnode = children[i_4];
+          for (var i = 0; i < children.length; i++) {
+              var vnode = children[i];
               var key = vnode.key;
               if (isDef(key)) {
                   if (seenKeys[key]) {
-                      warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
+                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
                   }
                   else {
                       seenKeys[key] = true;
@@ -5469,10 +5458,10 @@
           }
       }
       function findIdxInOld(node, oldCh, start, end) {
-          for (var i_5 = start; i_5 < end; i_5++) {
-              var c = oldCh[i_5];
+          for (var i = start; i < end; i++) {
+              var c = oldCh[i];
               if (isDef(c) && sameVnode(node, c))
-                  { return i_5; }
+                  { return i; }
           }
       }
       function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5552,8 +5541,8 @@
               vnode.parent.data.pendingInsert = queue;
           }
           else {
-              for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                  queue[i_6].data.hook.insert(queue[i_6]);
+              for (var i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
               }
           }
       }
@@ -5566,7 +5555,9 @@
       // Note: this is a browser-only function so we can assume elms are DOM nodes.
       function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
           var i;
-          var tag = vnode.tag, data = vnode.data, children = vnode.children;
+          var tag = vnode.tag;
+          var data = vnode.data;
+          var children = vnode.children;
           inVPre = inVPre || (data && data.pre);
           vnode.elm = elm;
           if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5615,9 +5606,9 @@
                           // iterate and compare children lists
                           var childrenMatch = true;
                           var childNode = elm.firstChild;
-                          for (var i_7 = 0; i_7 < children.length; i_7++) {
+                          for (var i$1 = 0; i$1 < children.length; i$1++) {
                               if (!childNode ||
-                                  !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
+                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                                   childrenMatch = false;
                                   break;
                               }
@@ -5728,22 +5719,22 @@
                       var ancestor = vnode.parent;
                       var patchable = isPatchable(vnode);
                       while (ancestor) {
-                          for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                              cbs.destroy[i_8](ancestor);
+                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
                           }
                           ancestor.elm = vnode.elm;
                           if (patchable) {
-                              for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                  cbs.create[i_9](emptyNode, ancestor);
+                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                  cbs.create[i$1](emptyNode, ancestor);
                               }
                               // #6513
                               // invoke insert hooks that may have been merged by create hooks.
                               // e.g. for directives that uses the "inserted" hook.
-                              var insert_1 = ancestor.data.hook.insert;
-                              if (insert_1.merged) {
+                              var insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                      insert_1.fns[i_10]();
+                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                      insert.fns[i$2]();
                                   }
                               }
                           }
@@ -5858,7 +5849,7 @@
       return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
+      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
   }
   function callHook(dir, hook, vnode, oldVnode, isDestroy) {
       var fn = dir.def && dir.def[hook];
@@ -5867,7 +5858,7 @@
               fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
           }
           catch (e) {
-              handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
+              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
           }
       }
   }
@@ -5961,11 +5952,11 @@
               key === 'placeholder' &&
               value !== '' &&
               !el.__ieph) {
-              var blocker_1 = function (e) {
+              var blocker = function (e) {
                   e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker_1);
+                  el.removeEventListener('input', blocker);
               };
-              el.addEventListener('input', blocker_1);
+              el.addEventListener('input', blocker);
               // $flow-disable-line
               el.__ieph = true; /* IE placeholder patched */
           }
@@ -6017,8 +6008,8 @@
       /* istanbul ignore if */
       if (isDef(on[RANGE_TOKEN])) {
           // IE input[type=range] only supports `change` event
-          var event_1 = isIE ? 'change' : 'input';
-          on[event_1] = [].concat(on[RANGE_TOKEN], on[event_1] || []);
+          var event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
           delete on[RANGE_TOKEN];
       }
       // This was originally intended to fix #4521 but no longer necessary
@@ -6051,17 +6042,17 @@
       // and the handler would only fire if the event passed to it was fired
       // AFTER it was attached.
       if (useMicrotaskFix) {
-          var attachedTimestamp_1 = currentFlushTimestamp;
-          var original_1 = handler;
+          var attachedTimestamp = currentFlushTimestamp;
+          var original = handler;
           //@ts-expect-error
-          handler = original_1._wrapper = function (e) {
+          handler = original._wrapper = function (e) {
               if (
               // no bubbling, should always fire.
               // this is just a safety net in case event.timeStamp is unreliable in
               // certain weird environments...
               e.target === e.currentTarget ||
                   // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp_1 ||
+                  e.timeStamp >= attachedTimestamp ||
                   // bail for environments that have buggy event.timeStamp implementations
                   // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
                   // #9681 QtWebEngine event.timeStamp is negative value
@@ -6070,7 +6061,7 @@
                   // electron/nw.js app, since event.timeStamp will be using a different
                   // starting reference
                   e.target.ownerDocument !== document) {
-                  return original_1.apply(this, arguments);
+                  return original.apply(this, arguments);
               }
           };
       }
@@ -6302,9 +6293,9 @@
       }
       var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
       for (var i = 0; i < vendorNames.length; i++) {
-          var name_1 = vendorNames[i] + capName;
-          if (name_1 in emptyStyle) {
-              return name_1;
+          var name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
           }
       }
   });
@@ -6429,12 +6420,12 @@
   }
   var autoCssTransition$1 = cached(function (name) {
       return {
-          enterClass: name + "-enter",
-          enterToClass: name + "-enter-to",
-          enterActiveClass: name + "-enter-active",
-          leaveClass: name + "-leave",
-          leaveToClass: name + "-leave-to",
-          leaveActiveClass: name + "-leave-active",
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
       };
   });
   var hasTransition$1 = inBrowser && !isIE9;
@@ -6486,7 +6477,10 @@
       removeClass$1(el, cls);
   }
   function whenTransitionEnds$1(el, expectedType, cb) {
-      var _a = getTransitionInfo$1(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+      var ref = getTransitionInfo$1(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
       if (!type)
           { return cb(); }
       var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
@@ -6591,7 +6585,23 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
@@ -6699,7 +6709,17 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
       var userWantsControl = getHookArgumentsLength$1(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -6773,7 +6793,7 @@
   function checkDuration$1(val, name, vnode) {
       if (typeof val !== 'number') {
           warn("<transition> explicit " + name + " duration is not a valid number - " +
-              ("got " + JSON.stringify(val) + "."), vnode.context);
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
       }
       else if (isNaN(val)) {
           warn("<transition> explicit " + name + " duration is NaN - " +
@@ -6813,7 +6833,7 @@
       ? {
           create: _enter,
           activate: _enter,
-          remove: function (vnode, rm) {
+          remove: function remove(vnode, rm) {
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
@@ -6849,7 +6869,7 @@
       });
   }
   var directive = {
-      inserted: function (el, binding, vnode, oldVnode) {
+      inserted: function inserted(el, binding, vnode, oldVnode) {
           if (vnode.tag === 'select') {
               // #6903
               if (oldVnode.elm && !oldVnode.elm._vOptions) {
@@ -6879,22 +6899,22 @@
               }
           }
       },
-      componentUpdated: function (el, binding, vnode) {
+      componentUpdated: function componentUpdated(el, binding, vnode) {
           if (vnode.tag === 'select') {
               setSelected(el, binding, vnode.context);
               // in case the options rendered by v-for have changed,
               // it's possible that the value is out-of-sync with the rendered options.
               // detect such cases and filter out values that no longer has a matching
               // option in the DOM.
-              var prevOptions_1 = el._vOptions;
-              var curOptions_1 = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions_1.some(function (o, i) { return !looseEqual(o, prevOptions_1[i]); })) {
+              var prevOptions = el._vOptions;
+              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
                   // trigger change event if
                   // no matching option found for at least one value
                   var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions_1); })
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
                       : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions_1);
+                          hasNoMatchingOption(binding.value, curOptions);
                   if (needReset) {
                       trigger(el, 'change');
                   }
@@ -6915,8 +6935,8 @@
       var value = binding.value;
       var isMultiple = el.multiple;
       if (isMultiple && !Array.isArray(value)) {
-          warn("<select multiple v-model=\"" + binding.expression + "\"> " +
-                  ("expects an Array value for its binding, but got " + Object.prototype.toString
+          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                  "expects an Array value for its binding, but got " + (Object.prototype.toString
                       .call(value)
                       .slice(8, -1)), vm);
           return;
@@ -7047,12 +7067,12 @@
   }
   var autoCssTransition = cached(function (name) {
       return {
-          enterClass: name + "-enter",
-          enterToClass: name + "-enter-to",
-          enterActiveClass: name + "-enter-active",
-          leaveClass: name + "-leave",
-          leaveToClass: name + "-leave-to",
-          leaveActiveClass: name + "-leave-active",
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
       };
   });
   var hasTransition = inBrowser && !isIE9;
@@ -7104,7 +7124,10 @@
       removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var _a = getTransitionInfo(el, expectedType), type = _a.type, timeout = _a.timeout, propCount = _a.propCount;
+      var ref = getTransitionInfo(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
       if (!type)
           { return cb(); }
       var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
@@ -7209,7 +7232,23 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css, type = data.type, enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
@@ -7317,7 +7356,17 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css, type = data.type, leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave, duration = data.duration;
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
       var userWantsControl = getHookArgumentsLength(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
@@ -7391,7 +7440,7 @@
   function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
           warn("<transition> explicit " + name + " duration is not a valid number - " +
-              ("got " + JSON.stringify(val) + "."), vnode.context);
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
       }
       else if (isNaN(val)) {
           warn("<transition> explicit " + name + " duration is NaN - " +
@@ -7431,8 +7480,9 @@
           : vnode;
   }
   var show = {
-      bind: function (el, _a, vnode) {
-          var value = _a.value;
+      bind: function bind(el, ref, vnode) {
+          var value = ref.value;
+
           vnode = locateNode(vnode);
           var transition = vnode.data && vnode.data.transition;
           var originalDisplay = (el.__vOriginalDisplay =
@@ -7447,8 +7497,10 @@
               el.style.display = value ? originalDisplay : 'none';
           }
       },
-      update: function (el, _a, vnode) {
-          var value = _a.value, oldValue = _a.oldValue;
+      update: function update(el, ref, vnode) {
+          var value = ref.value;
+          var oldValue = ref.oldValue;
+
           /* istanbul ignore if */
           if (!value === !oldValue)
               { return; }
@@ -7471,7 +7523,7 @@
               el.style.display = value ? el.__vOriginalDisplay : 'none';
           }
       },
-      unbind: function (el, binding, vnode, oldVnode, isDestroy) {
+      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
           if (!isDestroy) {
               el.style.display = el.__vOriginalDisplay;
           }
@@ -7522,8 +7574,8 @@
       // events.
       // extract listeners and pass them directly to the transition methods
       var listeners = options._parentListeners;
-      for (var key in listeners) {
-          data[camelize(key)] = listeners[key];
+      for (var key$1 in listeners) {
+          data[camelize(key$1)] = listeners[key$1];
       }
       return data;
   }
@@ -7551,8 +7603,9 @@
       name: 'transition',
       props: transitionProps,
       abstract: true,
-      render: function (h) {
-          var _this = this;
+      render: function render(h) {
+          var this$1 = this;
+
           var children = this.$slots.default;
           if (!children) {
               return;
@@ -7594,7 +7647,7 @@
           // ensure a key that is unique to the vnode type and to this transition
           // component instance. This key will be used to remove pending leaving nodes
           // during entering.
-          var id = "__transition-" + this._uid + "-";
+          var id = "__transition-" + (this._uid) + "-";
           child.key =
               child.key == null
                   ? child.isComment
@@ -7628,8 +7681,8 @@
                   // return placeholder node and queue update when leave finishes
                   this._leaving = true;
                   mergeVNodeHook(oldData, 'afterLeave', function () {
-                      _this._leaving = false;
-                      _this.$forceUpdate();
+                      this$1._leaving = false;
+                      this$1.$forceUpdate();
                   });
                   return placeholder(h, rawChild);
               }
@@ -7637,14 +7690,14 @@
                   if (isAsyncPlaceholder(child)) {
                       return oldRawChild;
                   }
-                  var delayedLeave_1;
+                  var delayedLeave;
                   var performLeave = function () {
-                      delayedLeave_1();
+                      delayedLeave();
                   };
                   mergeVNodeHook(data, 'afterEnter', performLeave);
                   mergeVNodeHook(data, 'enterCancelled', performLeave);
                   mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                      delayedLeave_1 = leave;
+                      delayedLeave = leave;
                   });
               }
           }
@@ -7661,21 +7714,22 @@
   delete props.mode;
   var TransitionGroup = {
       props: props,
-      beforeMount: function () {
-          var _this = this;
+      beforeMount: function beforeMount() {
+          var this$1 = this;
+
           var update = this._update;
           this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(_this);
+              var restoreActiveInstance = setActiveInstance(this$1);
               // force removing pass
-              _this.__patch__(_this._vnode, _this.kept, false, // hydrating
+              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
               true // removeOnly (!important, avoids unnecessary moves)
               );
-              _this._vnode = _this.kept;
+              this$1._vnode = this$1.kept;
               restoreActiveInstance();
-              update.call(_this, vnode, hydrating);
+              update.call(this$1, vnode, hydrating);
           };
       },
-      render: function (h) {
+      render: function render(h) {
           var tag = this.tag || this.$vnode.data.tag || 'span';
           var map = Object.create(null);
           var prevChildren = (this.prevChildren = this.children);
@@ -7692,27 +7746,27 @@
                   }
                   else {
                       var opts = c.componentOptions;
-                      var name_1 = opts
+                      var name = opts
                           ? opts.Ctor.options.name || opts.tag || ''
                           : c.tag;
-                      warn("<transition-group> children must be keyed: <" + name_1 + ">");
+                      warn(("<transition-group> children must be keyed: <" + name + ">"));
                   }
               }
           }
           if (prevChildren) {
               var kept = [];
               var removed = [];
-              for (var i = 0; i < prevChildren.length; i++) {
-                  var c = prevChildren[i];
-                  c.data.transition = transitionData;
+              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                  var c$1 = prevChildren[i$1];
+                  c$1.data.transition = transitionData;
                   // @ts-ignore
-                  c.data.pos = c.elm.getBoundingClientRect();
+                  c$1.data.pos = c$1.elm.getBoundingClientRect();
                   // @ts-ignore
-                  if (map[c.key]) {
-                      kept.push(c);
+                  if (map[c$1.key]) {
+                      kept.push(c$1);
                   }
                   else {
-                      removed.push(c);
+                      removed.push(c$1);
                   }
               }
               this.kept = h(tag, null, kept);
@@ -7720,7 +7774,7 @@
           }
           return h(tag, null, children);
       },
-      updated: function () {
+      updated: function updated() {
           var children = this.prevChildren;
           var moveClass = this.moveClass || (this.name || 'v') + '-move';
           if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
@@ -7738,25 +7792,25 @@
           children.forEach(function (c) {
               // @ts-ignore
               if (c.data.moved) {
-                  var el_1 = c.elm;
-                  var s = el_1.style;
-                  addTransitionClass(el_1, moveClass);
+                  var el = c.elm;
+                  var s = el.style;
+                  addTransitionClass(el, moveClass);
                   s.transform = s.WebkitTransform = s.transitionDuration = '';
-                  el_1.addEventListener(transitionEndEvent, (el_1._moveCb = function cb(e) {
-                      if (e && e.target !== el_1) {
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
                           return;
                       }
                       if (!e || /transform$/.test(e.propertyName)) {
-                          el_1.removeEventListener(transitionEndEvent, cb);
-                          el_1._moveCb = null;
-                          removeTransitionClass(el_1, moveClass);
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
                       }
                   }));
               }
           });
       },
       methods: {
-          hasMove: function (el, moveClass) {
+          hasMove: function hasMove(el, moveClass) {
               /* istanbul ignore if */
               if (!hasTransition) {
                   return false;
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
index adf93603c31..95374026c19 100644
--- a/dist/vue.runtime.min.js
+++ b/dist/vue.runtime.min.js
@@ -3,4 +3,9 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y(function(t){return t.replace(g,function(t,e){return e?e.toUpperCase():""})}),b=y(function(t){return t.charAt(0).toUpperCase()+t.slice(1)}),C=/\B([A-Z])/g,w=y(function(t){return t.replace(C,"-$1").toLowerCase()});var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every(function(t,n){return E(t,e[n])});if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every(function(n){return E(t[n],e[n])})}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:L};function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=V&&WXEnvironment.platform.toLowerCase(),H=U&&window.navigator.userAgent.toLowerCase(),z=H&&/msie|trident/.test(H),W=H&&H.indexOf("msie 9.0")>0,q=H&&H.indexOf("edge/")>0;H&&H.indexOf("android");var K=H&&/iphone|ipad|ipod|ios/.test(H)||"ios"===B;H&&/chrome\/\d+/.test(H),H&&/phantomjs/.test(H);var X,G=H&&H.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=O,it=0,at=function(){function t(){this.id=it++,this.subs=[]}return t.prototype.addSub=function(t){this.subs.push(t)},t.prototype.removeSub=function(t){v(this.subs,t)},t.prototype.depend=function(){t.target&&t.target.addDep(this)},t.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},t}();at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(){function t(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(t.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),t}(),ft=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function pt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var vt=Array.prototype,ht=Object.create(vt);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(t){var e=vt[t];M(ht,t,function(){for(var n=arguments,r=[],o=0;o<arguments.length;o++)r[o]=n[o];var i,a=e.apply(this,r),s=this.__ob__;switch(t){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&s.observeArray(i),s.dep.notify(),a})});var mt=Object.getOwnPropertyNames(ht),yt=!0;function gt(t){yt=t}var _t=function(){function t(t){var e;this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?(e=ht,t.__proto__=e):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}return t.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)Ct(t,e[n])},t.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)bt(t[e])},t}();function bt(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:yt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&function t(e){for(var n=void 0,r=0,o=e.length;r<o;r++)(n=e[r])&&n.__ob__&&n.__ob__.dep.depend(),Array.isArray(n)&&t(n)}(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&bt(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(Ct(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}var $t=P.optionMergeStrategies;function xt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&xt(r,o):wt(t,n,o));return t}function kt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?xt(r,o):o}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Ot(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}$t.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},L.forEach(function(t){$t[t]=Ot}),N.forEach(function(t){$t[t+"s"]=St}),$t.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},$t.props=$t.methods=$t.inject=$t.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},$t.provide=kt;var Tt=function(t,e){return void 0===e?t:e};function Et(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Et(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Et(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=$t[r]||Tt;a[r]=o(t[r],e[r],n,r)}return a}function jt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function It(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Pt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===w(t)){var c=Pt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Nt(e.type)?r.call(t):r}(r,o,t);var u=yt;gt(!0),bt(a),gt(u)}return a}var Dt=/^\s*function (\w+)/;function Nt(t){var e=t&&t.toString().match(Dt);return e?e[1]:""}function Lt(t,e){return Nt(t)===Nt(e)}function Pt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Lt(e[n],t))return n;return-1}function Mt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Rt(t,r,"errorCaptured hook")}}Rt(t,e,n)}finally{ut()}}function Ft(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch(function(t){return Mt(t,r,o+" (Promise/async)")}),i._handled=!0)}catch(t){Mt(t,r,o)}return i}function Rt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!V||"undefined"==typeof console)throw t;console.error(t)}var Vt,Bt=!1,Ht=[],zt=!1;function Wt(){zt=!1;var t=Ht.slice(0);Ht.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var qt=Promise.resolve();Vt=function(){qt.then(Wt),K&&setTimeout(O)},Bt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Wt)}:function(){setTimeout(Wt,0)};else{var Kt=1,Xt=new MutationObserver(Wt),Gt=document.createTextNode(String(Kt));Xt.observe(Gt,{characterData:!0}),Vt=function(){Kt=(Kt+1)%2,Gt.data=String(Kt)},Bt=!0}function Zt(t,e){var n;if(Ht.push(function(){if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)}),zt||(zt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise(function(t){n=t})}var Jt=new nt;function Qt(t){!function t(e,n){var r,o;var a=Array.isArray(e);if(!a&&!i(e)||Object.isFrozen(e)||e instanceof lt)return;if(e.__ob__){var s=e.__ob__.dep.id;if(n.has(s))return;n.add(s)}if(a)for(r=e.length;r--;)t(e[r],n);else for(o=Object.keys(e),r=o.length;r--;)t(e[o[r]],n)}(t,Jt),Jt.clear()}var Yt=y(function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}});function te(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ft(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ft(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ee(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=Yt(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=te(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=Yt(c)).name,n[c],f.capture)}function ne(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=te([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=te([s,c]),a.merged=!0,t[o]=a}function re(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function oe(t){return o(t)?[dt(t)]:Array.isArray(t)?function t(i,a){var s=[];var c,u,l,f;for(c=0;c<i.length;c++)e(u=i[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ie((u=t(u,(a||"")+"_"+c))[0])&&ie(f)&&(s[l]=dt(f.text+u[0].text),u.shift()),s.push.apply(s,u)):o(u)?ie(f)?s[l]=dt(f.text+u):""!==u&&s.push(dt(u)):ie(u)&&ie(f)?s[l]=dt(f.text+u.text):(r(i._isVList)&&n(u.tag)&&e(u.key)&&n(a)&&(u.key="__vlist"+a+"_"+c+"__"),s.push(u)));return s}(t):void 0}function ie(t){return n(t)&&n(t.text)&&!1===t.isComment}function ae(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function se(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(ce)&&delete n[u];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=le(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=fe(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function le(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function fe(t,e){return function(){return t[e]}}function de(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ve(t){return jt(this.$options,"filters",t)||T}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?he(o,r):i?he(i,t):r?w(r)!==e:void 0}function ye(t,e,n,r,o){if(n)if(i(n)){Array.isArray(n)&&(n=k(n));var a=void 0,s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=w(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function ge(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e?r:(be(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r)}function _e(t,e,n){return be(t,"__once__"+e+(n?"_"+n:""),!0),t}function be(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Ce(t[r],e+"_"+r,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Ae(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Ae(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function $e(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=_e,t._n=f,t._s=l,t._l=de,t._t=pe,t._q=E,t._i=j,t._m=ge,t._f=ve,t._k=me,t._b=ye,t._v=dt,t._e=ft,t._u=Ae,t._g=we,t._d=$e,t._p=xe}function Oe(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=ae(u.inject,i),this.slots=function(){return c.$slots||ue(e.scopedSlots,c.$slots=se(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Pe(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Pe(s,t,e,n,r,f)}}function Se(t,e,n,r,o){var i=pt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Te(t,e){for(var n in e)t[_(n)]=e[n]}ke(Oe.prototype);var Ee={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ee.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,qe)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){gt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=It(p,v,n,e)}gt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,We(e,r,h),u&&(e.$slots=se(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,Ze(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,Qe.push(e)):Ge(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?function t(e,n){if(n&&(e._directInactive=!0,Xe(e)))return;if(!e._inactive){e._inactive=!0;for(var r=0;r<e.$children.length;r++)t(e.$children[r]);Ze(e,"deactivated")}}(e,!0):e.$destroy())}},je=Object.keys(Ee);function Ie(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Fe;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",function(){return v(s,a)});var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I(function(e){t.resolved=Re(e,o),c?s.length=0:d(!0)}),h=I(function(e){n(t.errorComp)&&(t.error=!0,d(!0))}),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=Re(m.error,o)),n(m.loading)&&(t.loadingComp=Re(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout(function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))},m.delay||200)),n(m.timeout)&&(f=setTimeout(function(){f=null,e(t.resolved)&&h(null)},m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=ft();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},_n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=w(u);re(a,c,u,l,!0)||re(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=It(l,u,r||t);else n(o.attrs)&&Te(c,o.attrs),n(o.props)&&Te(c,o.props);var f=new Oe(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Se(d,o,f.parent,s);if(Array.isArray(d)){for(var p=oe(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Se(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<je.length;n++){var r=je[n],o=e[r],i=Ee[r];o===i||o&&o._merged||(e[r]=o?De(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function De(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}var Ne=1,Le=2;function Pe(t,a,s,c,u,l){return(Array.isArray(s)||o(s))&&(u=c,c=s,s=void 0),r(l)&&(u=Le),function(t,o,a,s,c){if(n(a)&&n(a.__ob__))return ft();n(a)&&n(a.is)&&(o=a.is);if(!o)return ft();Array.isArray(s)&&"function"==typeof s[0]&&((a=a||{}).scopedSlots={default:s[0]},s.length=0);c===Le?s=oe(s):c===Ne&&(s=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(s));var u,l;if("string"==typeof o){var f=void 0;l=t.$vnode&&t.$vnode.ns||P.getTagNamespace(o),u=P.isReservedTag(o)?new lt(P.parsePlatformTagName(o),a,s,void 0,void 0,t):a&&a.pre||!n(f=jt(t.$options,"components",o))?new lt(o,a,s,void 0,void 0,t):Ie(f,a,t,s,o)}else u=Ie(o,a,t,s);return Array.isArray(u)?u:n(u)?(n(l)&&function t(o,i,a){o.ns=i;"foreignObject"===o.tag&&(i=void 0,a=!0);if(n(o.children))for(var s=0,c=o.children.length;s<c;s++){var u=o.children[s];n(u.tag)&&(e(u.ns)||r(a)&&"svg"!==u.tag)&&t(u,i,a)}}(u,l),n(a)&&function(t){i(t.style)&&Qt(t.style);i(t.class)&&Qt(t.class)}(a),u):ft()}(t,a,s,c,u)}var Me,Fe=null;function Re(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ue(t){return t.isComment&&t.asyncFactory}function Ve(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ue(r)))return r}}function Be(t,e){Me.$on(t,e)}function He(t,e){Me.$off(t,e)}function ze(t,e){var n=Me;return function r(){null!==e.apply(null,arguments)&&n.$off(t,r)}}function We(t,e,n){Me=t,ee(e,n||{},Be,He,ze,t),Me=void 0}var qe=null;function Ke(t){var e=qe;return qe=t,function(){qe=e}}function Xe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,Xe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ge(t.$children[n]);Ze(t,"activated")}}function Ze(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ft(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var Je=[],Qe=[],Ye={},tn=!1,en=!1,nn=0;var rn=0,on=Date.now;if(U&&!z){var an=window.performance;an&&"function"==typeof an.now&&on()>document.createEvent("Event").timeStamp&&(on=function(){return an.now()})}function sn(){var t,e;for(rn=on(),en=!0,Je.sort(function(t,e){return t.id-e.id}),nn=0;nn<Je.length;nn++)(t=Je[nn]).before&&t.before(),e=t.id,Ye[e]=null,t.run();var n=Qe.slice(),r=Je.slice();nn=Je.length=Qe.length=0,Ye={},tn=en=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&Ze(r,"updated")}}(r),tt&&P.devtools&&tt.emit("flush")}var cn=0,un=function(){function t(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}return t.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&Qt(t),ut(),this.cleanupDeps()}return t},t.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},t.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},t.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==Ye[e]){if(Ye[e]=!0,en){for(var n=Je.length-1;n>nn&&Je[n].id>t.id;)n--;Je.splice(n+1,0,t)}else Je.push(t);tn||(tn=!0,Zt(sn))}}(this)},t.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Mt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},t.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},t.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},t.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}},t}(),ln={enumerable:!0,configurable:!0,get:O,set:O};function fn(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function dn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&gt(!1);var i=function(i){o.push(i);var a=It(i,e,n,t);Ct(r,i,a),i in t||fn(t,"_props",i)};for(var a in e)i(a);gt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||(a=void 0,36!==(a=(i+"").charCodeAt(0))&&95!==a&&fn(t,"_data",i))}var a;bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new un(t,a||O,O,pn)),o in t||vn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)yn(t,n,r[o]);else yn(t,n,r)}}(t,e.watch)}var pn={lazy:!0};function vn(t,e,n){var r=!Y();"function"==typeof n?(ln.get=r?hn(e):mn(n),ln.set=O):(ln.get=n.get?r&&!1!==n.cache?hn(e):mn(n.get):O,ln.set=n.set||O),Object.defineProperty(t,e,ln)}function hn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var gn=0;function _n(t){var e=t.options;if(t.super){var n=_n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Et(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function bn(t){this._init(t)}function Cn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Et(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)fn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)vn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach(function(t){a[t]=n[t]}),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function An(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function $n(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=wn(a.componentOptions);s&&!e(s)&&xn(n,i,r,o)}}}function xn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Et(_n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&We(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=se(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Pe(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Pe(e,t,n,r,o,!0)};var i=r&&r.data;Ct(e,"$attrs",i&&i.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){var e=ae(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach(function(n){Ct(t,n,e[n])}),gt(!0))}(n),dn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(bn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){if(s(e))return yn(this,t,e,n);(n=n||{}).user=!0;var r=new un(this,t,e,n);if(n.immediate){ct();try{e.call(this,r.value)}catch(t){Mt(t,this,'callback for immediate watcher "'+r.expression+'"')}ut()}return function(){r.teardown()}}}(bn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this._events[t];if(e){e=e.length>1?$(e):e;for(var n=$(arguments,1),r='event handler for "'+t+'"',o=0,i=e.length;o<i;o++)Ft(e[o],this,n,this,r)}return this}}(bn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ke(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(bn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Zt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ue(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Fe=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Mt(n,e,"render"),t=e._vnode}finally{Fe=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=ft()),t.parent=o,t}}(bn);var kn=[String,RegExp,Array],On={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)xn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",function(e){$n(t,function(t){return An(e,t)})}),this.$watch("exclude",function(e){$n(t,function(t){return!An(e,t)})})},render:function(){var t=this.$slots.default,e=Ve(t),n=e&&e.componentOptions;if(n){var r=wn(n),o=this.include,i=this.exclude;if(o&&(!r||!An(o,r))||i&&r&&An(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&xn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Et,defineReactive:Ct},t.set=wt,t.delete=At,t.nextTick=Zt,t.observable=function(t){return bt(t),t},t.options=Object.create(null),N.forEach(function(e){t.options[e+"s"]=Object.create(null)}),t.options._base=t,x(t.options.components,On),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Et(this.options,t),this}}(t),Cn(t),function(t){N.forEach(function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}})}(t)}(bn),Object.defineProperty(bn.prototype,"$isServer",{get:Y}),Object.defineProperty(bn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(bn,"FunctionalRenderContext",{value:Oe}),bn.version="2.6.12";var Sn=d("style,class"),Tn=d("input,textarea,option,select,progress"),En=d("contenteditable,draggable,spellcheck"),jn=d("events,caret,typing,plaintext-only"),In=function(t,e){return Mn(e)||"false"===e?"false":"contenteditable"===t&&jn(e)?e:"true"},Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Nn="http://www.w3.org/1999/xlink",Ln=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Pn=function(t){return Ln(t)?t.slice(6,t.length):""},Mn=function(t){return null==t||!1===t};function Fn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Rn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Rn(e,r.data));return function(t,e){if(n(t)||n(e))return Un(t,Vn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Un(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Un(t,e){return t?e?t+" "+e:t:e||""}function Vn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Vn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Hn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Wn=function(t){return Hn(t)||zn(t)};var qn=Object.create(null);var Kn=d("text,number,password,search,email,tel,url");var Xn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t?n:(e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n)},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Gn={create:function(t,e){Zn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Zn(t,!0),Zn(e))},destroy:function(t){Zn(t,!0)}};function Zn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var Jn=new lt("",{},[]),Qn=["create","activate","update","remove","destroy"];function Yn(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Kn(o)&&Kn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function tr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var er={create:nr,update:nr,destroy:function(t){nr(t,Jn)}};function nr(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===Jn,a=e===Jn,s=or(t.data.directives,t.context),c=or(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ar(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ar(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ar(u[n],"inserted",e,t)};i?ne(e,"insert",f):f()}l.length&&ne(e,"postpatch",function(){for(var n=0;n<l.length;n++)ar(l[n],"componentUpdated",e,t)});if(!i)for(n in s)c[n]||ar(s[n],"unbind",t,t,a)}(t,e)}var rr=Object.create(null);function or(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=rr),o[ir(r)]=r,r.def=jt(e.$options,"directives",r.name);return o}function ir(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ar(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Mt(r,n.context,"directive "+t.name+" "+e+" hook")}}var sr=[Gn,er];function cr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&ur(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&ur(s,"value",u.value),c)e(u[i])&&(Ln(i)?s.removeAttributeNS(Nn,Pn(i)):En(i)||s.removeAttribute(i))}}function ur(t,e,n,r){r||t.tagName.indexOf("-")>-1?lr(t,e,n):Dn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):En(e)?t.setAttribute(e,In(e,n)):Ln(e)?Mn(n)?t.removeAttributeNS(Nn,Pn(e)):t.setAttributeNS(Nn,e,n):lr(t,e,n)}function lr(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var fr={create:cr,update:cr};function dr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Fn(r),c=o._transitionClasses;n(c)&&(s=Un(s,Vn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var pr,vr={create:dr,update:dr},hr="__r",mr="__c";function yr(t,e,n){var r=pr;return function o(){null!==e.apply(null,arguments)&&br(t,o,n,r)}}var gr=Bt&&!(G&&Number(G[1])<=53);function _r(t,e,n,r){if(gr){var o=rn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}pr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function br(t,e,n,r){(r||pr).removeEventListener(t,e._wrapper||e,n)}function Cr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};pr=r.elm,function(t){if(n(t[hr])){var e=z?"change":"input";t[e]=[].concat(t[hr],t[e]||[]),delete t[hr]}n(t[mr])&&(t.change=[].concat(t[mr],t.change||[]),delete t[mr])}(o),ee(o,i,_r,br,yr,r.context),pr=void 0}}var wr,Ar={create:Cr,update:Cr};function $r(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);xr(a,u)&&(a.value=u)}else if("innerHTML"===o&&zn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function xr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:$r,update:$r},Or=y(function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach(function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}}),e});function Sr(t){var e=Tr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Tr(t){return Array.isArray(t)?k(t):"string"==typeof t?Or(t):t}var Er,jr=/^--/,Ir=/\s*!important$/,Dr=function(t,e,n){if(jr.test(e))t.style.setProperty(e,n);else if(Ir.test(n))t.style.setProperty(w(e),n.replace(Ir,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Nr=["Webkit","Moz","ms"],Lr=y(function(t){if(Er=Er||document.createElement("div").style,"filter"!==(t=_(t))&&t in Er)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Nr.length;n++){var r=Nr[n]+e;if(r in Er)return r}});function Pr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=Tr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Sr(o.data))&&x(r,n);(n=Sr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Sr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Dr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Dr(c,s,null==a?"":a)}}var Mr={create:Pr,update:Pr},Fr=/\s+/;function Rr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Ur(t.name||"v")),x(e,t),e}return"string"==typeof t?Ur(t):void 0}}var Ur=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),Vr="transition",Br="animation",Hr="transition",zr="transitionend",Wr="animation",qr="animationend";U&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Hr="WebkitTransition",zr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Wr="WebkitAnimation",qr="webkitAnimationEnd"));var Kr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Xr(t){Kr(function(){Kr(t)})}function Gr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Zr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Fr).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Jr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),o=(r[Hr+"Delay"]||"").split(", "),i=(r[Hr+"Duration"]||"").split(", "),a=Yr(o,i),s=(r[Wr+"Delay"]||"").split(", "),c=(r[Wr+"Duration"]||"").split(", "),u=Yr(s,c),l=0,f=0;e===Vr?a>0&&(n=Vr,l=a,f=i.length):e===Br?u>0&&(n=Br,l=u,f=c.length):(l=Math.max(a,u),f=(n=l>0?a>u?Vr:Br:null)?n===Vr?i.length:c.length:0);var d=n===Vr&&Qr.test(r[Hr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Vr?zr:qr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var Qr=/\b(transform|all)(,|$)/;function Yr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return to(e)+to(t[n])}))}function to(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function eo(t){return"number"==typeof t&&!isNaN(t)}function no(t){if(e(t))return!1;var r=t.fns;return n(r)?no(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function ro(t,r){!0!==r.data.show&&function(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Rr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=no(D),R=o._enterCb=I(function(){M&&(Zr(o,E),Zr(o,T)),R.cancelled?(M&&Zr(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(Gr(o,S),Gr(o,T),Xr(function(){Zr(o,S),R.cancelled||(Gr(o,E),F||(eo(P)?setTimeout(R,P):Jr(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}(r)}var oo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<Qn.length;++i)for(s[Qn[i]]=[],a=0;a<c.length;++a)n(c[a][Qn[i]])&&s[Qn[i]].push(c[a][Qn[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=pt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){for(var i,a=t;a.componentInstance;)if(a=a.componentInstance._vnode,n(i=a.data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](Jn,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Zn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](Jn,t);n(i=t.data.hook)&&(n(i.create)&&i.create(Jn,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=qe)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&Yn(t,a))return i}}function $(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=pt(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?O(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:Yn(h,g)?($(h,g,i,o,p),h=r[++d],g=o[++p]):Yn(m,b)?($(m,b,i,o,y),m=r[--v],b=o[--y]):Yn(h,b)?($(h,b,i,o,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):Yn(m,g)?($(m,g,i,o,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=tr(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):Yn(l=r[c],g)?($(l,g,i,o,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,o);break}!v&&c.class&&Qt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&Yn(t,o))$(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&O(t,o,d))return x(o,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](Jn,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else Zn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Xn,modules:[fr,vr,Ar,kr,Mr,U?{create:ro,activate:ro,remove:function(t,r){!0!==t.data.show?function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Rr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=no(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Zr(o,l),Zr(o,d)),w.cancelled?(_&&Zr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Gr(o,u),Gr(o,d),Xr(function(){Zr(o,u),w.cancelled||(Gr(o,l),b||(eo(C)?setTimeout(w,C):Jr(o,c,w)))})),v&&v(o,w),_||b||w())}}(t,r):r()}}:{}].concat(sr)});W&&document.addEventListener("selectionchange",function(){var t=document.activeElement;t&&t.vmodel&&po(t,"input")});var io={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ne(n,"postpatch",function(){io.componentUpdated(t,e,n)}):ao(t,e,n.context),t._vOptions=[].map.call(t.options,uo)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",lo),t.addEventListener("compositionend",fo),t.addEventListener("change",fo),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ao(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,uo);if(o.some(function(t,e){return!E(t,r[e])}))(t.multiple?e.value.some(function(t){return co(t,o)}):e.value!==e.oldValue&&co(e.value,o))&&po(t,"change")}}};function ao(t,e,n){so(t,e),(z||q)&&setTimeout(function(){so(t,e)},0)}function so(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=j(r,uo(a))>-1,a.selected!==i&&(a.selected=i);else if(E(uo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function co(t,e){return e.every(function(e){return!E(e,t)})}function uo(t){return"_value"in t?t._value:t.value}function lo(t){t.target.composing=!0}function fo(t){t.target.composing&&(t.target.composing=!1,po(t.target,"input"))}function po(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var vo=/\s+/;function ho(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.add(e)}):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function mo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(vo).forEach(function(e){return t.classList.remove(e)}):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function yo(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,go(t.name||"v")),x(e,t),e}return"string"==typeof t?go(t):void 0}}var go=y(function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}}),_o=U&&!W,bo="transition",Co="animation",wo="transition",Ao="transitionend",$o="animation",xo="animationend";_o&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(wo="WebkitTransition",Ao="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&($o="WebkitAnimation",xo="webkitAnimationEnd"));var ko=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Oo(t){ko(function(){ko(t)})}function So(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),ho(t,e))}function To(t,e){t._transitionClasses&&v(t._transitionClasses,e),mo(t,e)}function Eo(t,e,n){var r=Io(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===bo?Ao:xo,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout(function(){c<a&&u()},i+1),t.addEventListener(s,l)}var jo=/\b(transform|all)(,|$)/;function Io(t,e){var n,r=window.getComputedStyle(t),o=(r[wo+"Delay"]||"").split(", "),i=(r[wo+"Duration"]||"").split(", "),a=Do(o,i),s=(r[$o+"Delay"]||"").split(", "),c=(r[$o+"Duration"]||"").split(", "),u=Do(s,c),l=0,f=0;return e===bo?a>0&&(n=bo,l=a,f=i.length):e===Co?u>0&&(n=Co,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?bo:Co:null)?n===bo?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===bo&&jo.test(r[wo+"Property"])}}function Do(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(function(e,n){return No(e)+No(t[n])}))}function No(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Lo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=yo(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=qe,k=qe.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!W,F=Mo(D),R=o._enterCb=I(function(){M&&(To(o,E),To(o,T)),R.cancelled?(M&&To(o,S),L&&L(o)):N&&N(o),o._enterCb=null});t.data.show||ne(t,"insert",function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)}),j&&j(o),M&&(So(o,S),So(o,T),Oo(function(){To(o,S),R.cancelled||(So(o,E),F||(Po(P)?setTimeout(R,P):Eo(o,c,R)))})),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function Po(t){return"number"==typeof t&&!isNaN(t)}function Mo(t){if(e(t))return!1;var r=t.fns;return n(r)?Mo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Fo(t){return!t.componentInstance||t.data&&t.data.transition?t:Fo(t.componentInstance._vnode)}var Ro={model:io,show:{bind:function(t,e,n){var r=e.value,o=(n=Fo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,Lo(n,function(){t.style.display=i})):t.style.display=r?i:"none"},update:function(t,r,o){var a=r.value;!a!=!r.oldValue&&((o=Fo(o)).data&&o.data.transition?(o.data.show=!0,a?Lo(o,function(){t.style.display=t.__vOriginalDisplay}):function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=yo(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Mo(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I(function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(To(o,l),To(o,d)),w.cancelled?(_&&To(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null});y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(So(o,u),So(o,d),Oo(function(){To(o,u),w.cancelled||(So(o,l),b||(Po(C)?setTimeout(w,C):Eo(o,c,w)))})),v&&v(o,w),_||b||w())}}(o,function(){t.style.display="none"})):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Uo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Vo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Vo(Ve(e.children)):t}function Bo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var r in o)e[_(r)]=o[r];return e}function Ho(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var zo=function(t){return t.tag||Ue(t)},Wo=function(t){return"show"===t.name},qo={name:"transition",props:Uo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(zo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Vo(i);if(!a)return i;if(this._leaving)return Ho(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Bo(this),u=this._vnode,l=Vo(u);if(a.data.directives&&a.data.directives.some(Wo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ne(f,"afterLeave",function(){e._leaving=!1,e.$forceUpdate()}),Ho(t,i);if("in-out"===r){if(Ue(a))return u;var d,p=function(){d()};ne(c,"afterEnter",p),ne(c,"enterCancelled",p),ne(f,"delayLeave",function(t){d=t})}}return i}}},Ko=x({tag:String,moveClass:String},Uo);function Xo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Go(t){t.data.newPos=t.elm.getBoundingClientRect()}function Zo(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Ko.mode;var Jo={Transition:qo,TransitionGroup:{props:Ko,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ke(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Bo(this),s=0;s<o.length;s++){(l=o[s]).tag&&null!=l.key&&0!==String(l.key).indexOf("__vlist")&&(i.push(l),n[l.key]=l,(l.data||(l.data={})).transition=a)}if(r){var c=[],u=[];for(s=0;s<r.length;s++){var l;(l=r[s]).data.transition=a,l.data.pos=l.elm.getBoundingClientRect(),n[l.key]?c.push(l):u.push(l)}this.kept=t(e,null,c),this.removed=u}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Xo),t.forEach(Go),t.forEach(Zo),this._reflow=document.body.offsetHeight,t.forEach(function(t){if(t.data.moved){var n=t.elm,r=n.style;So(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Ao,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Ao,t),n._moveCb=null,To(n,e))})}}))},methods:{hasMove:function(t,e){if(!_o)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach(function(t){mo(n,t)}),ho(n,e),n.style.display="none",this.$el.appendChild(n);var r=Io(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return bn.config.mustUseProp=function(t,e,n){return"value"===n&&Tn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},bn.config.isReservedTag=Wn,bn.config.isReservedAttr=Sn,bn.config.getTagNamespace=function(t){return zn(t)?"svg":"math"===t?"math":void 0},bn.config.isUnknownElement=function(t){if(!U)return!0;if(Wn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];var e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},x(bn.options.directives,Ro),x(bn.options.components,Jo),bn.prototype.__patch__=U?oo:O,bn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=ft),Ze(t,"beforeMount"),r=function(){t._update(t._render(),n)},new un(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){var e=document.querySelector(t);return e||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout(function(){P.devtools&&tt&&tt.emit("init",bn)},0),bn});
\ No newline at end of file
+/*!
+ * Vue.js v2.6.12
+ * (c) 2014-2021 Evan You
+ * Released under the MIT License.
+ */
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,w=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every((function(t,n){return E(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return E(t[n],e[n])}))}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:L};function M(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function F(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var R=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var U="__proto__"in{},V="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),z=V&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0;z&&z.indexOf("android");var X=z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===H;z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z);var G,Z=z&&z.match(/firefox\/(\d+)/),J={}.watch,Q=!1;if(V)try{var Y={};Object.defineProperty(Y,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,Y)}catch(t){}var tt=function(){return void 0===G&&(G=!V&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},et=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}var rt,ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);rt="undefined"!=typeof Set&&nt(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var it=O,at=0,st=function(){this.id=at++,this.subs=[]};st.prototype.addSub=function(t){this.subs.push(t)},st.prototype.removeSub=function(t){v(this.subs,t)},st.prototype.depend=function(){st.target&&st.target.addDep(this)},st.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},st.target=null;var ct=[];function ut(t){ct.push(t),st.target=t}function lt(){ct.pop(),st.target=ct[ct.length-1]}var ft=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},dt={child:{configurable:!0}};dt.child.get=function(){return this.componentInstance},Object.defineProperties(ft.prototype,dt);var pt=function(t){void 0===t&&(t="");var e=new ft;return e.text=t,e.isComment=!0,e};function vt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){var e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=mt[t];F(yt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i}))}));var gt=Object.getOwnPropertyNames(yt),_t=!0;function bt(t){_t=t}var Ct=function(t){this.value=t,this.dep=new st,this.vmCount=0,F(t,"__ob__",this),Array.isArray(t)?(U?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];F(t,i,e[i])}}(t,yt,gt),this.observeArray(t)):this.walk(t)};function wt(t,e){var n;if(i(t)&&!(t instanceof ft))return m(t,"__ob__")&&t.__ob__ instanceof Ct?n=t.__ob__:_t&&!tt()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new Ct(t)),e&&n&&n.vmCount++,n}function At(t,e,n,r,o){var i=new st,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&wt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return st.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&wt(e),i.notify())}})}}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(At(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function kt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}Ct.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)At(t,e[n])},Ct.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)wt(t[e])};var Ot=P.optionMergeStrategies;function St(t,e){if(!e)return t;for(var n,r,o,i=ot?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&St(r,o):$t(t,n,o));return t}function Tt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?St(r,o):o}:e?t?function(){return St("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Et(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function jt(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}Ot.data=function(t,e,n){return n?Tt(t,e,n):e&&"function"!=typeof e?t:Tt(t,e)},L.forEach((function(t){Ot[t]=Et})),N.forEach((function(t){Ot[t+"s"]=jt})),Ot.watch=function(t,e,n,r){if(t===J&&(t=void 0),e===J&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},Ot.props=Ot.methods=Ot.inject=Ot.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},Ot.provide=Tt;var It=function(t,e){return void 0===e?t:e};function Dt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Dt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Dt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=Ot[r]||It;a[r]=o(t[r],e[r],n,r)}return a}function Nt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Lt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Rt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===w(t)){var c=Rt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Mt(e.type)?r.call(t):r}(r,o,t);var u=_t;bt(!0),wt(a),bt(u)}return a}var Pt=/^\s*function (\w+)/;function Mt(t){var e=t&&t.toString().match(Pt);return e?e[1]:""}function Ft(t,e){return Mt(t)===Mt(e)}function Rt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Ft(e[n],t))return n;return-1}function Ut(t,e,n){ut();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{lt()}}function Vt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch((function(t){return Ut(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(t){Ut(t,r,o)}return i}function Bt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!V&&!B||"undefined"==typeof console)throw t;console.error(t)}var zt,Wt=!1,qt=[],Kt=!1;function Xt(){Kt=!1;var t=qt.slice(0);qt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){var Gt=Promise.resolve();zt=function(){Gt.then(Xt),X&&setTimeout(O)},Wt=!0}else if(W||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())zt="undefined"!=typeof setImmediate&&nt(setImmediate)?function(){setImmediate(Xt)}:function(){setTimeout(Xt,0)};else{var Zt=1,Jt=new MutationObserver(Xt),Qt=document.createTextNode(String(Zt));Jt.observe(Qt,{characterData:!0}),zt=function(){Zt=(Zt+1)%2,Qt.data=String(Zt)},Wt=!0}function Yt(t,e){var n;if(qt.push((function(){if(t)try{t.call(e)}catch(t){Ut(t,e,"nextTick")}else n&&n(e)})),Kt||(Kt=!0,zt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var te=new rt;function ee(t){ne(t,te),te.clear()}function ne(t,e){var n,r,o=Array.isArray(t);if(!(!o&&!i(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(o)for(n=t.length;n--;)ne(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ne(t[r[n]],e)}}var re=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function oe(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Vt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Vt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ie(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=re(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=oe(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=re(c)).name,n[c],f.capture)}function ae(t,o,i){var a;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=oe([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=oe([s,c]),a.merged=!0,t[o]=a}function se(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ce(t){return o(t)?[vt(t)]:Array.isArray(t)?le(t):void 0}function ue(t){return n(t)&&n(t.text)&&!1===t.isComment}function le(t,i){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ue((s=le(s,(i||"")+"_"+a))[0])&&ue(u)&&(l[c]=vt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):o(s)?ue(u)?l[c]=vt(u.text+s):""!==s&&l.push(vt(s)):ue(s)&&ue(u)?l[c]=vt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(i)&&(s.key="__vlist"+i+"_"+a+"__"),l.push(s)));return l}function fe(t,e){if(t){for(var n=Object.create(null),r=ot?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function de(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(pe)&&delete n[u];return n}function pe(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ve(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=he(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=me(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),F(o,"$stable",a),F(o,"$key",s),F(o,"$hasNormal",i),o}function he(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ce(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function me(t,e){return function(){return t[e]}}function ye(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(ot&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ge(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function _e(t){return Nt(this.$options,"filters",t)||T}function be(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function Ce(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?be(o,r):i?be(i,t):r?w(r)!==e:void 0}function we(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=k(n));var s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=w(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function Ae(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||xe(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function $e(t,e,n){return xe(t,"__once__"+e+(n?"_"+n:""),!0),t}function xe(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&ke(t[r],e+"_"+r,n);else ke(t,e,n)}function ke(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Oe(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Se(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Se(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Te(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Ee(t,e){return"string"==typeof t?e+t:t}function je(t){t._o=$e,t._n=f,t._s=l,t._l=ye,t._t=ge,t._q=E,t._i=j,t._m=Ae,t._f=_e,t._k=Ce,t._b=we,t._v=vt,t._e=pt,t._u=Se,t._g=Oe,t._d=Te,t._p=Ee}function Ie(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=fe(u.inject,i),this.slots=function(){return c.$slots||ve(e.scopedSlots,c.$slots=de(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ve(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ve(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Re(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Re(s,t,e,n,r,f)}}function De(t,e,n,r,o){var i=ht(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ne(t,e){for(var n in e)t[_(n)]=e[n]}je(Ie.prototype);var Le={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Le.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ze)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){bt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Lt(p,v,n,e)}bt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Ge(e,r,h),u&&(e.$slots=de(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,en(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,rn.push(e)):Ye(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?tn(e,!0):e.$destroy())}},Pe=Object.keys(Le);function Me(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I((function(e){t.resolved=He(e,o),c?s.length=0:d(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,d(!0))})),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=He(m.error,o)),n(m.loading)&&(t.loadingComp=He(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},$n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=w(u);se(a,c,u,l,!0)||se(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Lt(l,u,r||t);else n(o.attrs)&&Ne(c,o.attrs),n(o.props)&&Ne(c,o.props);var f=new Ie(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof ft)return De(d,o,f.parent,s);if(Array.isArray(d)){for(var p=ce(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=De(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Pe.length;n++){var r=Pe[n],o=e[r],i=Le[r];o===i||o&&o._merged||(e[r]=o?Fe(i,o):i)}}(a);var y=o.options.name||l;return new ft("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function Fe(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Re(t,e,a,s,c,u){return(Array.isArray(a)||o(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,o,a){if(n(r)&&n(r.__ob__))return pt();n(r)&&n(r.is)&&(e=r.is);if(!e)return pt();Array.isArray(o)&&"function"==typeof o[0]&&((r=r||{}).scopedSlots={default:o[0]},o.length=0);2===a?o=ce(o):1===a&&(o=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(o));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||P.getTagNamespace(e),s=P.isReservedTag(e)?new ft(P.parsePlatformTagName(e),r,o,void 0,void 0,t):r&&r.pre||!n(u=Nt(t.$options,"components",e))?new ft(e,r,o,void 0,void 0,t):Me(u,r,t,o,e)}else s=Me(e,r,t,o);return Array.isArray(s)?s:n(s)?(n(c)&&Ue(s,c),n(r)&&function(t){i(t.style)&&ee(t.style);i(t.class)&&ee(t.class)}(r),s):pt()}(t,e,a,s,c)}function Ue(t,o,i){if(t.ns=o,"foreignObject"===t.tag&&(o=void 0,i=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(i)&&"svg"!==c.tag)&&Ue(c,o,i)}}var Ve,Be=null;function He(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function ze(t){return t.isComment&&t.asyncFactory}function We(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||ze(r)))return r}}function qe(t,e){Ve.$on(t,e)}function Ke(t,e){Ve.$off(t,e)}function Xe(t,e){var n=Ve;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function Ge(t,e,n){Ve=t,ie(e,n||{},qe,Ke,Xe,t),Ve=void 0}var Ze=null;function Je(t){var e=Ze;return Ze=t,function(){Ze=e}}function Qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ye(t,e){if(e){if(t._directInactive=!1,Qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);en(t,"activated")}}function tn(t,e){if(!(e&&(t._directInactive=!0,Qe(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)tn(t.$children[n]);en(t,"deactivated")}}function en(t,e){ut();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Vt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),lt()}var nn=[],rn=[],on={},an=!1,sn=!1,cn=0;var un=0,ln=Date.now;if(V&&!W){var fn=window.performance;fn&&"function"==typeof fn.now&&ln()>document.createEvent("Event").timeStamp&&(ln=function(){return fn.now()})}function dn(){var t,e;for(un=ln(),sn=!0,nn.sort((function(t,e){return t.id-e.id})),cn=0;cn<nn.length;cn++)(t=nn[cn]).before&&t.before(),e=t.id,on[e]=null,t.run();var n=rn.slice(),r=nn.slice();cn=nn.length=rn.length=0,on={},an=sn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ye(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&en(r,"updated")}}(r),et&&P.devtools&&et.emit("flush")}var pn=0,vn=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++pn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!R.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()};vn.prototype.get=function(){var t;ut(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ut(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&ee(t),lt(),this.cleanupDeps()}return t},vn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},vn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},vn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==on[e]){if(on[e]=!0,sn){for(var n=nn.length-1;n>cn&&nn[n].id>t.id;)n--;nn.splice(n+1,0,t)}else nn.push(t);an||(an=!0,Yt(dn))}}(this)},vn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ut(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},vn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},vn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},vn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var hn={enumerable:!0,configurable:!0,get:O,set:O};function mn(t,e,n){hn.get=function(){return this[e][n]},hn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,hn)}function yn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&bt(!1);var i=function(i){o.push(i);var a=Lt(i,e,n,t);At(r,i,a),i in t||mn(t,"_props",i)};for(var a in e)i(a);bt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Ut(t,e,"data()"),{}}finally{lt()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||M(i)||mn(t,"_data",i)}wt(e,!0)}(t):wt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=tt();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new vn(t,a||O,O,gn)),o in t||_n(t,o,i)}}(t,e.computed),e.watch&&e.watch!==J&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)wn(t,n,r[o]);else wn(t,n,r)}}(t,e.watch)}var gn={lazy:!0};function _n(t,e,n){var r=!tt();"function"==typeof n?(hn.get=r?bn(e):Cn(n),hn.set=O):(hn.get=n.get?r&&!1!==n.cache?bn(e):Cn(n.get):O,hn.set=n.set||O),Object.defineProperty(t,e,hn)}function bn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),st.target&&e.depend(),e.value}}function Cn(t){return function(){return t.call(this,this)}}function wn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var An=0;function $n(t){var e=t.options;if(t.super){var n=$n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Dt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function xn(t){this._init(t)}function kn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Dt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)mn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)_n(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function On(t){return t&&(t.Ctor.options.name||t.tag)}function Sn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function Tn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=On(a.componentOptions);s&&!e(s)&&En(n,i,r,o)}}}function En(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=An++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Dt($n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Ge(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=de(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Re(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Re(e,t,n,r,o,!0)};var i=r&&r.data;At(e,"$attrs",i&&i.attrs||t,null,!0),At(e,"$listeners",n._parentListeners||t,null,!0)}(n),en(n,"beforeCreate"),function(t){var e=fe(t.$options.inject,t);e&&(bt(!1),Object.keys(e).forEach((function(n){At(t,n,e[n])})),bt(!0))}(n),yn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),en(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(xn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return wn(r,t,e,n);(n=n||{}).user=!0;var o=new vn(r,t,e,n);if(n.immediate){ut();try{e.call(r,o.value)}catch(t){Ut(t,r,'callback for immediate watcher "'+o.expression+'"')}lt()}return function(){o.teardown()}}}(xn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?$(n):n;for(var r=$(arguments,1),o='event handler for "'+t+'"',i=0,a=n.length;i<a;i++)Vt(n[i],e,r,e,o)}return e}}(xn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Je(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){en(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),en(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(xn),function(t){je(t.prototype),t.prototype.$nextTick=function(t){return Yt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ve(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ut(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof ft||(t=pt()),t.parent=o,t}}(xn);var jn=[String,RegExp,Array],In={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)En(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){Tn(t,(function(t){return Sn(e,t)}))})),this.$watch("exclude",(function(e){Tn(t,(function(t){return!Sn(e,t)}))}))},render:function(){var t=this.$slots.default,e=We(t),n=e&&e.componentOptions;if(n){var r=On(n),o=this.include,i=this.exclude;if(o&&(!r||!Sn(o,r))||i&&r&&Sn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&En(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:it,extend:x,mergeOptions:Dt,defineReactive:At},t.set=$t,t.delete=xt,t.nextTick=Yt,t.observable=function(t){return wt(t),t},t.options=Object.create(null),N.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,In),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Dt(this.options,t),this}}(t),kn(t),function(t){N.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(xn),Object.defineProperty(xn.prototype,"$isServer",{get:tt}),Object.defineProperty(xn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(xn,"FunctionalRenderContext",{value:Ie}),xn.version="2.6.12";var Dn=d("style,class"),Nn=d("input,textarea,option,select,progress"),Ln=d("contenteditable,draggable,spellcheck"),Pn=d("events,caret,typing,plaintext-only"),Mn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Rn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Un=function(t){return Rn(t)?t.slice(6,t.length):""},Vn=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Hn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return zn(t,Wn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:zn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function zn(t,e){return t?e?t+" "+e:t:e||""}function Wn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Wn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var qn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Xn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(t){return Kn(t)||Xn(t)};var Zn=Object.create(null);var Jn=d("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(qn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Yn={create:function(t,e){tr(e)},update:function(t,e){t.data.ref!==e.data.ref&&(tr(t,!0),tr(e))},destroy:function(t){tr(t,!0)}};function tr(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var er=new ft("",{},[]),nr=["create","activate","update","remove","destroy"];function rr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Jn(o)&&Jn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function or(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var ir={create:ar,update:ar,destroy:function(t){ar(t,er)}};function ar(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===er,a=e===er,s=cr(t.data.directives,t.context),c=cr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,lr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(lr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)lr(u[n],"inserted",e,t)};i?ae(e,"insert",f):f()}l.length&&ae(e,"postpatch",(function(){for(var n=0;n<l.length;n++)lr(l[n],"componentUpdated",e,t)}));if(!i)for(n in s)c[n]||lr(s[n],"unbind",t,t,a)}(t,e)}var sr=Object.create(null);function cr(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=sr),o[ur(r)]=r,r.def=Nt(e.$options,"directives",r.name);return o}function ur(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function lr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ut(r,n.context,"directive "+t.name+" "+e+" hook")}}var fr=[Yn,ir];function dr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&pr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&pr(s,"value",u.value),c)e(u[i])&&(Rn(i)?s.removeAttributeNS(Fn,Un(i)):Ln(i)||s.removeAttribute(i))}}function pr(t,e,n,r){r||t.tagName.indexOf("-")>-1?vr(t,e,n):Mn(e)?Vn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Ln(e)?t.setAttribute(e,function(t,e){return Vn(e)||"false"===e?"false":"contenteditable"===t&&Pn(e)?e:"true"}(e,n)):Rn(e)?Vn(n)?t.removeAttributeNS(Fn,Un(e)):t.setAttributeNS(Fn,e,n):vr(t,e,n)}function vr(t,e,n){if(Vn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var hr={create:dr,update:dr};function mr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=o._transitionClasses;n(c)&&(s=zn(s,Wn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var yr,gr={create:mr,update:mr};function _r(t,e,n){var r=yr;return function o(){var i=e.apply(null,arguments);null!==i&&wr(t,o,n,r)}}var br=Wt&&!(Z&&Number(Z[1])<=53);function Cr(t,e,n,r){if(br){var o=un,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}yr.addEventListener(t,e,Q?{capture:n,passive:r}:n)}function wr(t,e,n,r){(r||yr).removeEventListener(t,e._wrapper||e,n)}function Ar(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};yr=r.elm,function(t){if(n(t.__r)){var e=W?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(o),ie(o,i,Cr,wr,_r,r.context),yr=void 0}}var $r,xr={create:Ar,update:Ar};function kr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Xn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Sr={create:kr,update:kr},Tr=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?k(t):"string"==typeof t?Tr(t):t}var Ir,Dr=/^--/,Nr=/\s*!important$/,Lr=function(t,e,n){if(Dr.test(e))t.style.setProperty(e,n);else if(Nr.test(n))t.style.setProperty(w(e),n.replace(Nr,""),"important");else{var r=Mr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Mr=y((function(t){if(Ir=Ir||document.createElement("div").style,"filter"!==(t=_(t))&&t in Ir)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Ir)return r}}));function Fr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=jr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Lr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Lr(c,s,null==a?"":a)}}var Rr={create:Fr,update:Fr},Ur=/\s+/;function Vr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Hr="transition",zr="animation",Wr="transition",qr="transitionend",Kr="animation",Xr="animationend";V&&!q&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Wr="WebkitTransition",qr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Kr="WebkitAnimation",Xr="webkitAnimationEnd"));var Gr=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Zr(t){Gr((function(){Gr(t)}))}function Jr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Qr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Yr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),o=(r[Wr+"Delay"]||"").split(", "),i=(r[Wr+"Duration"]||"").split(", "),a=eo(o,i),s=(r[Kr+"Delay"]||"").split(", "),c=(r[Kr+"Duration"]||"").split(", "),u=eo(s,c),l=0,f=0;e===Hr?a>0&&(n=Hr,l=a,f=i.length):e===zr?u>0&&(n=zr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Hr:zr:null)?n===Hr?i.length:c.length:0;var d=n===Hr&&to.test(r[Wr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Hr?qr:Xr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var to=/\b(transform|all)(,|$)/;function eo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return no(e)+no(t[n])})))}function no(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ro(t){return"number"==typeof t&&!isNaN(t)}function oo(t){if(e(t))return!1;var r=t.fns;return n(r)?oo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function io(t,r){!0!==r.data.show&&function(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Vr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ze,k=Ze.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!q,F=oo(D),R=o._enterCb=I((function(){M&&(Qr(o,E),Qr(o,T)),R.cancelled?(M&&Qr(o,S),L&&L(o)):N&&N(o),o._enterCb=null}));t.data.show||ae(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),j&&j(o),M&&(Jr(o,S),Jr(o,T),Zr((function(){Qr(o,S),R.cancelled||(Jr(o,E),F||(ro(P)?setTimeout(R,P):Yr(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}(r)}var ao=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<nr.length;++i)for(s[nr[i]]=[],a=0;a<c.length;++a)n(c[a][nr[i]])&&s[nr[i]].push(c[a][nr[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=ht(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){var i,a=t;for(;a.componentInstance;)if(n(i=(a=a.componentInstance._vnode).data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](er,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(tr(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](er,t);n(i=t.data.hook)&&(n(i.create)&&i.create(er,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ze)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&rr(t,a))return i}}function $(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=ht(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?O(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:rr(h,g)?($(h,g,i,o,p),h=r[++d],g=o[++p]):rr(m,b)?($(m,b,i,o,y),m=r[--v],b=o[--y]):rr(h,b)?($(h,b,i,o,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):rr(m,g)?($(m,g,i,o,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=or(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):rr(l=r[c],g)?($(l,g,i,o,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,o);break}!v&&c.class&&ee(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&rr(t,o))$(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&O(t,o,d))return x(o,d,!0),t;c=t,t=new ft(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](er,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else tr(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Qn,modules:[hr,gr,xr,Sr,Rr,V?{create:io,activate:io,remove:function(t,r){!0!==t.data.show?function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Vr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=oo(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Qr(o,l),Qr(o,d)),w.cancelled?(_&&Qr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Jr(o,u),Jr(o,d),Zr((function(){Qr(o,u),w.cancelled||(Jr(o,l),b||(ro(C)?setTimeout(w,C):Yr(o,c,w)))}))),v&&v(o,w),_||b||w())}}(t,r):r()}}:{}].concat(fr)});q&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&ho(t,"input")}));var so={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ae(n,"postpatch",(function(){so.componentUpdated(t,e,n)})):co(t,e,n.context),t._vOptions=[].map.call(t.options,fo)):("textarea"===n.tag||Jn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",po),t.addEventListener("compositionend",vo),t.addEventListener("change",vo),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){co(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,fo);if(o.some((function(t,e){return!E(t,r[e])})))(t.multiple?e.value.some((function(t){return lo(t,o)})):e.value!==e.oldValue&&lo(e.value,o))&&ho(t,"change")}}};function co(t,e,n){uo(t,e),(W||K)&&setTimeout((function(){uo(t,e)}),0)}function uo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=j(r,fo(a))>-1,a.selected!==i&&(a.selected=i);else if(E(fo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function lo(t,e){return e.every((function(e){return!E(e,t)}))}function fo(t){return"_value"in t?t._value:t.value}function po(t){t.target.composing=!0}function vo(t){t.target.composing&&(t.target.composing=!1,ho(t.target,"input"))}function ho(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var mo=/\s+/;function yo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(mo).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function go(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(mo).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function _o(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,bo(t.name||"v")),x(e,t),e}return"string"==typeof t?bo(t):void 0}}var bo=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Co=V&&!q,wo="transition",Ao="animation",$o="transition",xo="transitionend",ko="animation",Oo="animationend";Co&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&($o="WebkitTransition",xo="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(ko="WebkitAnimation",Oo="webkitAnimationEnd"));var So=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function To(t){So((function(){So(t)}))}function Eo(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),yo(t,e))}function jo(t,e){t._transitionClasses&&v(t._transitionClasses,e),go(t,e)}function Io(t,e,n){var r=No(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===wo?xo:Oo,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var Do=/\b(transform|all)(,|$)/;function No(t,e){var n,r=window.getComputedStyle(t),o=(r[$o+"Delay"]||"").split(", "),i=(r[$o+"Duration"]||"").split(", "),a=Lo(o,i),s=(r[ko+"Delay"]||"").split(", "),c=(r[ko+"Duration"]||"").split(", "),u=Lo(s,c),l=0,f=0;return e===wo?a>0&&(n=wo,l=a,f=i.length):e===Ao?u>0&&(n=Ao,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?wo:Ao:null)?n===wo?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===wo&&Do.test(r[$o+"Property"])}}function Lo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return Po(e)+Po(t[n])})))}function Po(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Mo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=_o(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ze,k=Ze.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!q,F=Ro(D),R=o._enterCb=I((function(){M&&(jo(o,E),jo(o,T)),R.cancelled?(M&&jo(o,S),L&&L(o)):N&&N(o),o._enterCb=null}));t.data.show||ae(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),j&&j(o),M&&(Eo(o,S),Eo(o,T),To((function(){jo(o,S),R.cancelled||(Eo(o,E),F||(Fo(P)?setTimeout(R,P):Io(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function Fo(t){return"number"==typeof t&&!isNaN(t)}function Ro(t){if(e(t))return!1;var r=t.fns;return n(r)?Ro(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Uo(t){return!t.componentInstance||t.data&&t.data.transition?t:Uo(t.componentInstance._vnode)}var Vo={model:so,show:{bind:function(t,e,n){var r=e.value,o=(n=Uo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,Mo(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,r,o){var a=r.value;!a!=!r.oldValue&&((o=Uo(o)).data&&o.data.transition?(o.data.show=!0,a?Mo(o,(function(){t.style.display=t.__vOriginalDisplay})):function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=_o(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Ro(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(jo(o,l),jo(o,d)),w.cancelled?(_&&jo(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Eo(o,u),Eo(o,d),To((function(){jo(o,u),w.cancelled||(Eo(o,l),b||(Fo(C)?setTimeout(w,C):Io(o,c,w)))}))),v&&v(o,w),_||b||w())}}(o,(function(){t.style.display="none"}))):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Bo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ho(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ho(We(e.children)):t}function zo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Wo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var qo=function(t){return t.tag||ze(t)},Ko=function(t){return"show"===t.name},Xo={name:"transition",props:Bo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(qo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Ho(i);if(!a)return i;if(this._leaving)return Wo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=zo(this),u=this._vnode,l=Ho(u);if(a.data.directives&&a.data.directives.some(Ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!ze(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ae(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Wo(t,i);if("in-out"===r){if(ze(a))return u;var d,p=function(){d()};ae(c,"afterEnter",p),ae(c,"enterCancelled",p),ae(f,"delayLeave",(function(t){d=t}))}}return i}}},Go=x({tag:String,moveClass:String},Bo);function Zo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Jo(t){t.data.newPos=t.elm.getBoundingClientRect()}function Qo(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Go.mode;var Yo={Transition:Xo,TransitionGroup:{props:Go,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Je(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=zo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Zo),t.forEach(Jo),t.forEach(Qo),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;Eo(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(xo,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(xo,t),n._moveCb=null,jo(n,e))})}})))},methods:{hasMove:function(t,e){if(!Co)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){go(n,t)})),yo(n,e),n.style.display="none",this.$el.appendChild(n);var r=No(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return xn.config.mustUseProp=function(t,e,n){return"value"===n&&Nn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},xn.config.isReservedTag=Gn,xn.config.isReservedAttr=Dn,xn.config.getTagNamespace=function(t){return Xn(t)?"svg":"math"===t?"math":void 0},xn.config.isUnknownElement=function(t){if(!V)return!0;if(Gn(t))return!1;if(t=t.toLowerCase(),null!=Zn[t])return Zn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Zn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Zn[t]=/HTMLUnknownElement/.test(e.toString())},x(xn.options.directives,Vo),x(xn.options.components,Yo),xn.prototype.__patch__=V?ao:O,xn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),en(t,"beforeMount"),r=function(){t._update(t._render(),n)},new vn(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&en(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,en(t,"mounted")),t}(this,t=t&&V?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},V&&setTimeout((function(){P.devtools&&et&&et.emit("init",xn)}),0),xn}));
\ No newline at end of file
diff --git a/package.json b/package.json
index 1e888dad210..4a136d5195f 100644
--- a/package.json
+++ b/package.json
@@ -76,7 +76,6 @@
     "@babel/preset-env": "^7.13.12",
     "@babel/register": "^7.13.14",
     "@rollup/plugin-alias": "^3.1.2",
-    "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-buble": "^0.21.3",
     "@rollup/plugin-commonjs": "^18.0.0",
     "@rollup/plugin-node-resolve": "^11.2.1",
@@ -93,7 +92,7 @@
     "babel-plugin-istanbul": "^5.1.0",
     "babel-plugin-transform-vue-jsx": "^4.0.1",
     "babel-preset-flow-vue": "^1.0.0",
-    "buble": "^0.19.3",
+    "buble": "^0.20.0",
     "chalk": "^2.3.0",
     "chromedriver": "^2.45.0",
     "codecov": "^3.0.0",
@@ -141,7 +140,7 @@
     "selenium-server": "^2.53.1",
     "serialize-javascript": "^3.1.0",
     "shelljs": "^0.8.1",
-    "terser": "^3.10.2",
+    "terser": "^5.6.1",
     "ts-loader": "^8.1.0",
     "ts-node": "^9.1.1",
     "tslib": "^2.2.0",
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 0446e6301f8..891ef1e1d51 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -456,17 +456,17 @@
       var res = '';
       var opts = node.parent && node.parent.componentOptions;
       if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-          var parent_1 = node.parent;
-          while (isDef(parent_1)) {
+          var parent = node.parent;
+          while (isDef(parent)) {
               // Stop fallthrough in case parent has inheritAttrs option set to false
-              if (parent_1.componentOptions &&
-                  parent_1.componentOptions.Ctor.options.inheritAttrs === false) {
+              if (parent.componentOptions &&
+                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
                   break;
               }
-              if (isDef(parent_1.data) && isDef(parent_1.data.attrs)) {
-                  attrs = extend(extend({}, attrs), parent_1.data.attrs);
+              if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                  attrs = extend(extend({}, attrs), parent.data.attrs);
               }
-              parent_1 = parent_1.parent;
+              parent = parent.parent;
           }
       }
       if (isUndef(attrs)) {
@@ -487,57 +487,55 @@
   function renderAttr$1(key, value) {
       if (isBooleanAttr(key)) {
           if (!isFalsyAttrValue(value)) {
-              return " " + key + "=\"" + key + "\"";
+              return (" " + key + "=\"" + key + "\"");
           }
       }
       else if (isEnumeratedAttr(key)) {
-          return " " + key + "=\"" + escape$1(convertEnumeratedValue(key, value)) + "\"";
+          return (" " + key + "=\"" + (escape$1(convertEnumeratedValue(key, value))) + "\"");
       }
       else if (!isFalsyAttrValue(value)) {
-          return " " + key + "=\"" + escape$1(String(value)) + "\"";
+          return (" " + key + "=\"" + (escape$1(String(value))) + "\"");
       }
       return '';
   }
 
-  var VNode = /** @class */ (function () {
-      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      Object.defineProperty(VNode.prototype, "child", {
-          // DEPRECATED: alias for componentInstance for backwards compat.
-          /* istanbul ignore next */
-          get: function () {
-              return this.componentInstance;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return VNode;
-  }());
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
+  };
+
+  var prototypeAccessors = { child: { configurable: true } };
+  // DEPRECATED: alias for componentInstance for backwards compat.
+  /* istanbul ignore next */
+  prototypeAccessors.child.get = function () {
+      return this.componentInstance;
+  };
+
+  Object.defineProperties( VNode.prototype, prototypeAccessors );
   var createEmptyVNode = function (text) {
-      if (text === void 0) { text = ''; }
+      if ( text === void 0 ) text = '';
+
       var node = new VNode();
       node.text = text;
       node.isComment = true;
@@ -657,7 +655,7 @@
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function () {
+              get: function get() {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
@@ -700,19 +698,20 @@
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /** @class */ (function () {
+      _Set = /*@__PURE__*/(function () {
           function Set() {
               this.set = Object.create(null);
           }
-          Set.prototype.has = function (key) {
+          Set.prototype.has = function has (key) {
               return this.set[key] === true;
           };
-          Set.prototype.add = function (key) {
+          Set.prototype.add = function add (key) {
               this.set[key] = true;
           };
-          Set.prototype.clear = function () {
+          Set.prototype.clear = function clear () {
               this.set = Object.create(null);
           };
+
           return Set;
       }());
   }
@@ -816,19 +815,17 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole_1 = typeof console !== 'undefined';
-      var classifyRE_1 = /(?:^|[-_])(\w)/g;
-      var classify_1 = function (str) {
-          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-      };
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
       warn$2 = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole_1 && !config.silent) {
-              console.error("[Vue warn]: " + msg + trace);
+          if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole_1 && !config.silent) {
+          if (hasConsole && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -851,10 +848,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-              (file && includeFile !== false ? " at " + file : ''));
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
       };
-      var repeat_1 = function (str, n) {
+      var repeat$1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -888,15 +885,13 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) {
-                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                          : formatComponentName(vm));
-                  })
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
                       .join('\n'));
           }
           else {
-              return "\n\n(found in " + formatComponentName(vm) + ")";
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
           }
       };
   }
@@ -906,31 +901,28 @@
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = /** @class */ (function () {
-      function Dep() {
-          this.id = uid++;
-          this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid++;
+      this.subs = [];
+  };
+  Dep.prototype.addSub = function addSub (sub) {
+      this.subs.push(sub);
+  };
+  Dep.prototype.removeSub = function removeSub (sub) {
+      remove$1(this.subs, sub);
+  };
+  Dep.prototype.depend = function depend () {
+      if (Dep.target) {
+          Dep.target.addDep(this);
       }
-      Dep.prototype.addSub = function (sub) {
-          this.subs.push(sub);
-      };
-      Dep.prototype.removeSub = function (sub) {
-          remove$1(this.subs, sub);
-      };
-      Dep.prototype.depend = function () {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      };
-      Dep.prototype.notify = function () {
-          // stabilize the subscriber list first
-          var subs = this.subs.slice();
-          for (var i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      };
-      return Dep;
-  }());
+  };
+  Dep.prototype.notify = function notify () {
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
+  };
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
@@ -966,12 +958,9 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var arguments$1 = arguments;
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
 
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments$1[_i];
-          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -1007,46 +996,43 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = /** @class */ (function () {
-      function Observer(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
           }
           else {
-              this.walk(value);
+              copyAugment(value, arrayMethods, arrayKeys);
           }
+          this.observeArray(value);
       }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      Observer.prototype.walk = function (obj) {
-          var keys = Object.keys(obj);
-          for (var i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      };
-      /**
-       * Observe a list of Array items.
-       */
-      Observer.prototype.observeArray = function (items) {
-          for (var i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      };
-      return Observer;
-  }());
+      else {
+          this.walk(value);
+      }
+  };
+  /**
+   * Walk through all properties and convert them into
+   * getter/setters. This method should only be called when
+   * value type is Object.
+   */
+  Observer.prototype.walk = function walk (obj) {
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive(obj, keys[i]);
+      }
+  };
+  /**
+   * Observe a list of Array items.
+   */
+  Observer.prototype.observeArray = function observeArray (items) {
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
+  };
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -1156,7 +1142,7 @@
    */
   function set(target, key, val) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+          warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -1187,7 +1173,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1362,14 +1348,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key_1 in childVal) {
-          var parent_1 = ret[key_1];
-          var child = childVal[key_1];
-          if (parent_1 && !Array.isArray(parent_1)) {
-              parent_1 = [parent_1];
-          }
-          ret[key_1] = parent_1
-              ? parent_1.concat(child)
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1407,7 +1393,7 @@
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
           warn$2('Invalid component name: "' +
               name +
               '". Component names ' +
@@ -1451,7 +1437,7 @@
       }
       else {
           warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-              ("but got " + toRawType(props) + "."), vm);
+              "but got " + (toRawType(props)) + ".", vm);
       }
       options.props = res;
   }
@@ -1478,7 +1464,7 @@
       }
       else {
           warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-              ("but got " + toRawType(inject) + "."), vm);
+              "but got " + (toRawType(inject)) + ".", vm);
       }
   }
   /**
@@ -1498,7 +1484,7 @@
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
           warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-              ("but got " + toRawType(value) + "."), vm);
+              "but got " + (toRawType(value)) + ".", vm);
       }
   }
   /**
@@ -1734,7 +1720,7 @@
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
       var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          (" Expected " + expectedTypes.map(capitalize).join(', '));
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
       var expectedType = expectedTypes[0];
       var receivedType = toRawType(value);
       // check if we need to specify expected value
@@ -1742,24 +1728,24 @@
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + styleValue(value, expectedType);
+          message += " with value " + (styleValue(value, expectedType));
       }
       message += ", got " + receivedType + " ";
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + styleValue(value, receivedType) + ".";
+          message += "with value " + (styleValue(value, receivedType)) + ".";
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return "\"" + value + "\"";
+          return ("\"" + value + "\"");
       }
       else if (type === 'Number') {
-          return "" + Number(value);
+          return ("" + (Number(value)));
       }
       else {
-          return "" + value;
+          return ("" + value);
       }
   }
   var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1767,12 +1753,9 @@
       return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-      var arguments$1 = arguments;
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-          args[_i] = arguments$1[_i];
-      }
       return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
@@ -1826,7 +1809,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
+          warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1862,10 +1845,10 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter_1 = 1;
+      var counter = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode_1 = document.createTextNode(String(counter_1));
-      observer.observe(textNode_1, {
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
           characterData: true,
       });
   }
@@ -1977,7 +1960,7 @@
   function renderClass(node) {
       var classList = genClassForVnode(node);
       if (classList !== '') {
-          return " class=\"" + escape$1(classList) + "\"";
+          return (" class=\"" + (escape$1(classList)) + "\"");
       }
   }
 
@@ -2060,7 +2043,7 @@
       if (typeof value === 'string' ||
           (typeof value === 'number' && noUnitNumericStyleProps$1[key]) ||
           value === 0) {
-          return key + ":" + value + ";";
+          return (key + ":" + value + ";");
       }
       else {
           // invalid values
@@ -2070,7 +2053,7 @@
   function renderStyle(vnode) {
       var styleText = genStyle$1(getStyle(vnode, false));
       if (styleText !== '') {
-          return " style=" + JSON.stringify(escape$1(styleText));
+          return (" style=" + (JSON.stringify(escape$1(styleText))));
       }
   }
 
@@ -2188,90 +2171,85 @@
       return cachedWrite;
   }
 
-  var RenderContext = /** @class */ (function () {
-      function RenderContext(options) {
-          this.userContext = options.userContext;
-          this.activeInstance = options.activeInstance;
-          this.renderStates = [];
-          this.write = options.write;
-          this.done = options.done;
-          this.renderNode = options.renderNode;
-          this.isUnaryTag = options.isUnaryTag;
-          this.modules = options.modules;
-          this.directives = options.directives;
-          var cache = options.cache;
-          if (cache && (!cache.get || !cache.set)) {
-              throw new Error('renderer cache must implement at least get & set.');
-          }
-          this.cache = cache;
-          this.get = cache && normalizeAsync(cache, 'get');
-          this.has = cache && normalizeAsync(cache, 'has');
-          //@ts-expect-error
-          this.next = this.next.bind(this);
-      }
+  var RenderContext = function RenderContext(options) {
+      this.userContext = options.userContext;
+      this.activeInstance = options.activeInstance;
+      this.renderStates = [];
+      this.write = options.write;
+      this.done = options.done;
+      this.renderNode = options.renderNode;
+      this.isUnaryTag = options.isUnaryTag;
+      this.modules = options.modules;
+      this.directives = options.directives;
+      var cache = options.cache;
+      if (cache && (!cache.get || !cache.set)) {
+          throw new Error('renderer cache must implement at least get & set.');
+      }
+      this.cache = cache;
+      this.get = cache && normalizeAsync(cache, 'get');
+      this.has = cache && normalizeAsync(cache, 'has');
       //@ts-expect-error
-      RenderContext.prototype.next = function () {
-          var _loop_1 = function () {
-              var lastState = this_1.renderStates[this_1.renderStates.length - 1];
-              if (isUndef(lastState)) {
-                  return { value: this_1.done() };
-              }
-              /* eslint-disable no-case-declarations */
-              switch (lastState.type) {
-                  case 'Element':
-                  case 'Fragment':
-                      var children = lastState.children, total = lastState.total;
-                      var rendered = lastState.rendered++;
-                      if (rendered < total) {
-                          return { value: this_1.renderNode(children[rendered], false, this_1) };
-                      }
-                      else {
-                          this_1.renderStates.pop();
-                          if (lastState.type === 'Element') {
-                              return { value: this_1.write(lastState.endTag, this_1.next) };
-                          }
-                      }
-                      break;
-                  case 'Component':
-                      this_1.renderStates.pop();
-                      this_1.activeInstance = lastState.prevActive;
-                      break;
-                  case 'ComponentWithCache':
-                      this_1.renderStates.pop();
-                      var buffer = lastState.buffer, bufferIndex = lastState.bufferIndex, componentBuffer = lastState.componentBuffer, key = lastState.key;
-                      var result = {
-                          html: buffer[bufferIndex],
-                          components: componentBuffer[bufferIndex],
-                      };
-                      this_1.cache.set(key, result);
-                      if (bufferIndex === 0) {
-                          // this is a top-level cached component,
-                          // exit caching mode.
-                          //@ts-expect-error
-                          this_1.write.caching = false;
-                      }
-                      else {
-                          // parent component is also being cached,
-                          // merge self into parent's result
-                          buffer[bufferIndex - 1] += result.html;
-                          var prev_1 = componentBuffer[bufferIndex - 1];
-                          result.components.forEach(function (c) { return prev_1.add(c); });
+      this.next = this.next.bind(this);
+  };
+  //@ts-expect-error
+  RenderContext.prototype.next = function next () {
+      // eslint-disable-next-line
+      while (true) {
+          var lastState = this.renderStates[this.renderStates.length - 1];
+          if (isUndef(lastState)) {
+              return this.done();
+          }
+          /* eslint-disable no-case-declarations */
+          switch (lastState.type) {
+              case 'Element':
+              case 'Fragment':
+                  var children = lastState.children;
+              var total = lastState.total;
+                  var rendered = lastState.rendered++;
+                  if (rendered < total) {
+                      return this.renderNode(children[rendered], false, this);
+                  }
+                  else {
+                      this.renderStates.pop();
+                      if (lastState.type === 'Element') {
+                          return this.write(lastState.endTag, this.next);
                       }
-                      buffer.length = bufferIndex;
-                      componentBuffer.length = bufferIndex;
-                      break;
-              }
-          };
-          var this_1 = this;
-          // eslint-disable-next-line
-          while (true) {
-              var state_1 = _loop_1();
-              if (typeof state_1 === "object")
-                  { return state_1.value; }
+                  }
+                  break;
+              case 'Component':
+                  this.renderStates.pop();
+                  this.activeInstance = lastState.prevActive;
+                  break;
+              case 'ComponentWithCache':
+                  this.renderStates.pop();
+                  var buffer = lastState.buffer;
+              var bufferIndex = lastState.bufferIndex;
+              var componentBuffer = lastState.componentBuffer;
+              var key = lastState.key;
+                  var result = {
+                      html: buffer[bufferIndex],
+                      components: componentBuffer[bufferIndex],
+                  };
+                  this.cache.set(key, result);
+                  if (bufferIndex === 0) {
+                      // this is a top-level cached component,
+                      // exit caching mode.
+                      //@ts-expect-error
+                      this.write.caching = false;
+                  }
+                  else {
+                      // parent component is also being cached,
+                      // merge self into parent's result
+                      buffer[bufferIndex - 1] += result.html;
+                      var prev = componentBuffer[bufferIndex - 1];
+                      result.components.forEach(function (c) { return prev.add(c); });
+                  }
+                  buffer.length = bufferIndex;
+                  componentBuffer.length = bufferIndex;
+                  break;
           }
-      };
-      return RenderContext;
-  }());
+      }
+  };
   function normalizeAsync(cache, method) {
       var fn = cache[method];
       if (isUndef(fn)) {
@@ -2363,9 +2341,7 @@
               if (c === 0x2f) {
                   // /
                   var j = i - 1;
-                  var p 
-                  // find first non-whitespace prev char
-                  = void 0;
+                  var p = (void 0);
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
@@ -2399,12 +2375,12 @@
       var i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return "_f(\"" + filter + "\")(" + exp + ")";
+          return ("_f(\"" + filter + "\")(" + exp + ")");
       }
       else {
-          var name_1 = filter.slice(0, i);
+          var name = filter.slice(0, i);
           var args = filter.slice(i + 1);
-          return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
       }
   }
 
@@ -2434,7 +2410,7 @@
           }
           // tag token
           var exp = parseFilters(match[1].trim());
-          tokens.push("_s(" + exp + ")");
+          tokens.push(("_s(" + exp + ")"));
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -2450,7 +2426,7 @@
 
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error("[Vue compiler]: " + msg);
+      console.error(("[Vue compiler]: " + msg));
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
@@ -2484,7 +2460,7 @@
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -2637,10 +2613,10 @@
   function genData$2(el) {
       var data = '';
       if (el.staticClass) {
-          data += "staticClass:" + el.staticClass + ",";
+          data += "staticClass:" + (el.staticClass) + ",";
       }
       if (el.classBinding) {
-          data += "class:" + el.classBinding + ",";
+          data += "class:" + (el.classBinding) + ",";
       }
       return data;
   }
@@ -2674,10 +2650,10 @@
   function genData$1(el) {
       var data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + el.staticStyle + ",";
+          data += "staticStyle:" + (el.staticStyle) + ",";
       }
       if (el.styleBinding) {
-          data += "style:(" + el.styleBinding + "),";
+          data += "style:(" + (el.styleBinding) + "),";
       }
       return data;
   }
@@ -3054,11 +3030,11 @@
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp("^<" + qnameCapture);
+  var startTagOpen = new RegExp(("^<" + qnameCapture));
   var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
   var doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
@@ -3079,9 +3055,7 @@
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) {
-      return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  };
+  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
   function decodeAttr(value, shouldDecodeNewlines) {
       var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
       return value.replace(re, function (match) { return decodingMap[match]; });
@@ -3093,7 +3067,7 @@
       var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
       var index = 0;
       var last, lastTag;
-      var _loop_1 = function () {
+      while (html) {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -3107,7 +3081,7 @@
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                           }
                           advance(commentEnd + 3);
-                          return "continue";
+                          continue;
                       }
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -3115,14 +3089,14 @@
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
-                          return "continue";
+                          continue;
                       }
                   }
                   // Doctype:
                   var doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
-                      return "continue";
+                      continue;
                   }
                   // End tag:
                   var endTagMatch = html.match(endTag);
@@ -3130,7 +3104,7 @@
                       var curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
-                      return "continue";
+                      continue;
                   }
                   // Start tag:
                   var startTagMatch = parseStartTag();
@@ -3139,10 +3113,10 @@
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                           advance(1);
                       }
-                      return "continue";
+                      continue;
                   }
               }
-              var text = void 0, rest = void 0, next = void 0;
+              var text = (void 0), rest = (void 0), next = (void 0);
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -3169,18 +3143,18 @@
               }
           }
           else {
-              var endTagLength_1 = 0;
-              var stackedTag_1 = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag_1] ||
-                  (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-              var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength_1 = endTag.length;
-                  if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+              var endTagLength = 0;
+              var stackedTag = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                       text = text
                           .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                           .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                   }
-                  if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
                       text = text.slice(1);
                   }
                   if (options.chars) {
@@ -3188,25 +3162,20 @@
                   }
                   return '';
               });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag_1, index - endTagLength_1, index);
+              index += html.length - rest$1.length;
+              html = rest$1;
+              parseEndTag(stackedTag, index - endTagLength, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                       start: index + html.length,
                   });
               }
-              return "break";
+              break;
           }
-      };
-      while (html) {
-          var state_1 = _loop_1();
-          if (state_1 === "break")
-              { break; }
       }
       // Clean up any remaining tags
       parseEndTag();
@@ -3223,7 +3192,7 @@
                   start: index,
               };
               advance(start[0].length);
-              var end = void 0, attr = void 0;
+              var end, attr;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -3306,7 +3275,7 @@
               for (var i = stack.length - 1; i >= pos; i--) {
                   if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -3339,23 +3308,25 @@
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+      var ref = modifiers || {};
+      var number = ref.number;
+      var trim = ref.trim;
       var baseValueExpression = '$$v';
       var valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
               "(typeof " + baseValueExpression + " === 'string'" +
-                  ("? " + baseValueExpression + ".trim()") +
-                  (": " + baseValueExpression + ")");
+                  "? " + baseValueExpression + ".trim()" +
+                  ": " + baseValueExpression + ")";
       }
       if (number) {
           valueExpression = "_n(" + valueExpression + ")";
       }
       var assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: "(" + value + ")",
+          value: ("(" + value + ")"),
           expression: JSON.stringify(value),
-          callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
       };
   }
   /**
@@ -3364,10 +3335,10 @@
   function genAssignmentCode(value, assignment) {
       var res = parseModel(value);
       if (res.key === null) {
-          return value + "=" + assignment;
+          return (value + "=" + assignment);
       }
       else {
-          return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
       }
   }
   /**
@@ -3506,7 +3477,10 @@
       platformMustUseProp = options.mustUseProp || no;
       platformGetTagNamespace = options.getTagNamespace || no;
       var isReservedTag = options.isReservedTag || no;
-      maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      maybeComponent = function (el) { return !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
       transforms = pluckModuleFunction(options.modules, 'transformNode');
       preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
       postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -3557,8 +3531,8 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name_1 = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                      var name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                   }
                   currentParent.children.push(element);
                   element.parent = currentParent;
@@ -3584,7 +3558,7 @@
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode = void 0;
+              var lastNode;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -3594,7 +3568,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -3611,7 +3585,7 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function (tag, attrs, unary, start, end) {
+          start: function start(tag, attrs, unary, start$1, end) {
               // check namespace.
               // inherit parent ns if there is one
               var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -3626,7 +3600,7 @@
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start;
+                      element.start = start$1;
                       element.end = end;
                       element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                           cumulated[attr.name] = attr;
@@ -3647,7 +3621,7 @@
                   element.forbidden = true;
                   warn$1('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          ("<" + tag + ">") +
+                          "<" + tag + ">" +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
@@ -3686,24 +3660,24 @@
                   closeElement(element);
               }
           },
-          end: function (tag, start, end) {
+          end: function end(tag, start, end$1) {
               var element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end;
+                  element.end = end$1;
               }
               closeElement(element);
           },
-          chars: function (text, start, end) {
+          chars: function chars(text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
                           warnOnce('Component template requires a root element, rather than just text.', { start: start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                               start: start,
                           });
                       }
@@ -3743,8 +3717,8 @@
                       // condense consecutive whitespaces into single space
                       text = text.replace(whitespaceRE, ' ');
                   }
-                  var res = void 0;
-                  var child = void 0;
+                  var res;
+                  var child;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
@@ -3770,7 +3744,7 @@
                   }
               }
           },
-          comment: function (text, start, end) {
+          comment: function comment(text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
@@ -3840,11 +3814,11 @@
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
-                  var parent_1 = el.parent;
+                  var parent = el.parent;
                   if (iterator &&
                       iterator === exp &&
-                      parent_1 &&
-                      parent_1.tag === 'transition-group') {
+                      parent &&
+                      parent.tag === 'transition-group') {
                       warn$1("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
@@ -3868,7 +3842,7 @@
               extend(el, res);
           }
           else {
-              warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -3921,7 +3895,7 @@
       }
       else {
           warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
@@ -3932,7 +3906,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -3969,7 +3943,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -4001,41 +3975,45 @@
                               "the receiving component", el);
                       }
                   }
-                  var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                  el.slotTarget = name_2;
+                  var ref = getSlotName(slotBinding);
+                  var name = ref.name;
+                  var dynamic = ref.dynamic;
+                  el.slotTarget = name;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
               }
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
+              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding$1) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                       }
                       if (el.slotScope || el.slotTarget) {
                           warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
                           warn$1("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding);
+                              "<template> syntax when there are other named slots.", slotBinding$1);
                       }
                   }
                   // add the component's children to its default slot
                   var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                  var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                  slotContainer_1.slotTarget = name_3;
-                  slotContainer_1.slotTargetDynamic = dynamic;
-                  slotContainer_1.children = el.children.filter(function (c) {
+                  var ref$1 = getSlotName(slotBinding$1);
+                  var name$1 = ref$1.name;
+                  var dynamic$1 = ref$1.dynamic;
+                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name$1;
+                  slotContainer.slotTargetDynamic = dynamic$1;
+                  slotContainer.children = el.children.filter(function (c) {
                       if (!c.slotScope) {
-                          c.parent = slotContainer_1;
+                          c.parent = slotContainer;
                           return true;
                       }
                   });
-                  slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -4058,7 +4036,7 @@
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: "\"" + name + "\"", dynamic: false };
+              { name: ("\"" + name + "\""), dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
@@ -4104,7 +4082,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -4118,14 +4096,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                               );
                           }
                       }
@@ -4202,11 +4180,11 @@
   function parseModifiers(name) {
       var match = name.match(modifierRE);
       if (match) {
-          var ret_1 = {};
+          var ret = {};
           match.forEach(function (m) {
-              ret_1[m.slice(1)] = true;
+              ret[m.slice(1)] = true;
           });
-          return ret_1;
+          return ret;
       }
   }
   function makeAttrsMap(attrs) {
@@ -4248,7 +4226,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -4273,16 +4251,16 @@
           if (!map['v-model']) {
               return;
           }
-          var typeBinding = void 0;
+          var typeBinding;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + map['v-bind'] + ").type";
+              typeBinding = "(" + (map['v-bind']) + ").type";
           }
           if (typeBinding) {
               var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
               var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
               var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
@@ -4348,7 +4326,7 @@
           // inputs with type="file" are read only and setting the input's
           // value will throw an error.
           if (tag === 'input' && type === 'file') {
-              warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+              warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                   "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
           }
       }
@@ -4383,25 +4361,25 @@
       var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
       var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
       addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          ("?_i(" + value + "," + valueBinding + ")>-1") +
+          "?_i(" + value + "," + valueBinding + ")>-1" +
           (trueValueBinding === 'true'
-              ? ":(" + value + ")"
-              : ":_q(" + value + "," + trueValueBinding + ")"));
+              ? (":(" + value + ")")
+              : (":_q(" + value + "," + trueValueBinding + ")")));
       addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
-          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
           'if(Array.isArray($$a)){' +
-          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
           '$$i=_i($$a,$$v);' +
-          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
   }
   function genRadioModel(el, value, modifiers) {
       var number = modifiers && modifiers.number;
       var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
       addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
   }
   function genSelect(el, value, modifiers) {
@@ -4409,10 +4387,10 @@
       var selectedVal = "Array.prototype.filter" +
           ".call($event.target.options,function(o){return o.selected})" +
           ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          ("return " + (number ? '_n(val)' : 'val') + "})");
+          "return " + (number ? '_n(val)' : 'val') + "})";
       var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
       var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + genAssignmentCode(value, assignment);
+      code = code + " " + (genAssignmentCode(value, assignment));
       addHandler(el, 'change', code, null, true);
   }
   function genDefaultModel(el, value, modifiers) {
@@ -4420,15 +4398,18 @@
       // warn if v-bind:value conflicts with v-model
       // except for inputs with v-bind:type
       {
-          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
           var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value_1 && !typeBinding) {
+          if (value$1 && !typeBinding) {
               var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+              warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                   'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
           }
       }
-      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+      var ref = modifiers || {};
+      var lazy = ref.lazy;
+      var number = ref.number;
+      var trim = ref.trim;
       var needCompositionGuard = !lazy && type !== 'range';
       var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
       var valueExpression = '$event.target.value';
@@ -4442,7 +4423,7 @@
       if (needCompositionGuard) {
           code = "if($event.target.composing)return;" + code;
       }
-      addProp(el, 'value', "(" + value + ")");
+      addProp(el, 'value', ("(" + value + ")"));
       addHandler(el, event, code, null, true);
       if (trim || number) {
           addHandler(el, 'blur', '$forceUpdate()');
@@ -4451,13 +4432,13 @@
 
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
       }
   }
 
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
       }
   }
 
@@ -4515,7 +4496,7 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
   var modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
@@ -4532,19 +4513,19 @@
       var prefix = isNative ? 'nativeOn:' : 'on:';
       var staticHandlers = "";
       var dynamicHandlers = "";
-      for (var name_1 in events) {
-          var handlerCode = genHandler(events[name_1]);
+      for (var name in events) {
+          var handlerCode = genHandler(events[name]);
           //@ts-expect-error
-          if (events[name_1] && events[name_1].dynamic) {
-              dynamicHandlers += name_1 + "," + handlerCode + ",";
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += name + "," + handlerCode + ",";
           }
           else {
-              staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
           }
       }
-      staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
       if (dynamicHandlers) {
-          return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
       }
       else {
           return prefix + staticHandlers;
@@ -4555,7 +4536,7 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
       }
       var isMethodPath = simplePathRE.test(handler.value);
       var isFunctionExpression = fnExpRE.test(handler.value);
@@ -4564,13 +4545,13 @@
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
       }
       else {
           var code = '';
           var genModifierCode = '';
           var keys = [];
-          var _loop_1 = function (key) {
+          for (var key in handler.modifiers) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -4579,18 +4560,15 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers_1 = handler.modifiers;
+                  var modifiers = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                      .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                       .join('||'));
               }
               else {
                   keys.push(key);
               }
-          };
-          for (var key in handler.modifiers) {
-              _loop_1(key);
           }
           if (keys.length) {
               code += genKeyFilter(keys);
@@ -4600,13 +4578,13 @@
               code += genModifierCode;
           }
           var handlerCode = isMethodPath
-              ? "return " + handler.value + ".apply(null, arguments)"
+              ? ("return " + (handler.value) + ".apply(null, arguments)")
               : isFunctionExpression
-                  ? "return (" + handler.value + ").apply(null, arguments)"
+                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
                   : isFunctionInvocation
-                      ? "return " + handler.value
+                      ? ("return " + (handler.value))
                       : handler.value;
-          return "function($event){" + code + handlerCode + "}";
+          return ("function($event){" + code + handlerCode + "}");
       }
   }
   function genKeyFilter(keys) {
@@ -4615,20 +4593,20 @@
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&') + ")return null;"));
+          (keys.map(genFilterCode).join('&&')) + ")return null;");
   }
   function genFilterCode(key) {
       var keyVal = parseInt(key, 10);
       if (keyVal) {
-          return "$event.keyCode!==" + keyVal;
+          return ("$event.keyCode!==" + keyVal);
       }
       var keyCode = keyCodes[key];
       var keyName = keyNames[key];
       return ("_k($event.keyCode," +
-          (JSON.stringify(key) + ",") +
-          (JSON.stringify(keyCode) + ",") +
+          (JSON.stringify(key)) + "," +
+          (JSON.stringify(keyCode)) + "," +
           "$event.key," +
-          ("" + JSON.stringify(keyName)) +
+          "" + (JSON.stringify(keyName)) +
           ")");
   }
 
@@ -4636,12 +4614,12 @@
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
       }
-      el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
   }
 
   function bind(el, dir) {
       el.wrapData = function (code) {
-          return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
       };
   }
 
@@ -4651,24 +4629,19 @@
       cloak: noop$1,
   };
 
-  var CodegenState = /** @class */ (function () {
-      function CodegenState(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          var isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = function (el) {
-              return !!el.component || !isReservedTag(el.tag);
-          };
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-      return CodegenState;
-  }());
+  var CodegenState = function CodegenState(options) {
+      this.options = options;
+      this.warn = options.warn || baseWarn;
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+      this.directives = extend(extend({}, baseDirectives), options.directives);
+      var isReservedTag = options.isReservedTag || no;
+      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      this.onceId = 0;
+      this.staticRenderFns = [];
+      this.pre = false;
+  };
   function generate$1(ast, options) {
       var state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
@@ -4678,7 +4651,7 @@
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: "with(this){return " + code + "}",
+          render: ("with(this){return " + code + "}"),
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -4706,19 +4679,17 @@
       }
       else {
           // component or element
-          var code = void 0;
+          var code;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data = void 0;
+              var data;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
                   data = genData(el, state);
               }
               var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-              ) + (children ? "," + children : '' // children
-              ) + ")";
+              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
           }
           // module transforms
           for (var i = 0; i < state.transforms.length; i++) {
@@ -4737,9 +4708,9 @@
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
       state.pre = originalPreState;
-      return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
   }
   // v-once
   function genOnce(el, state) {
@@ -4749,19 +4720,19 @@
       }
       else if (el.staticInFor) {
           var key = '';
-          var parent_1 = el.parent;
-          while (parent_1) {
-              if (parent_1.for) {
-                  key = parent_1.key;
+          var parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
                   break;
               }
-              parent_1 = parent_1.parent;
+              parent = parent.parent;
           }
           if (!key) {
               state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
       }
       else {
           return genStatic(el, state);
@@ -4777,10 +4748,10 @@
       }
       var condition = conditions.shift();
       if (condition.exp) {
-          return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
       }
       else {
-          return "" + genTernaryExp(condition.block);
+          return ("" + (genTernaryExp(condition.block)));
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -4794,20 +4765,20 @@
   function genFor(el, state, altGen, altHelper) {
       var exp = el.for;
       var alias = el.alias;
-      var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-      var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
               "v-for should have explicit keys. " +
               "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ((altHelper || '_l') + "((" + exp + ")," +
-          ("function(" + alias + iterator1 + iterator2 + "){") +
-          ("return " + (altGen || genElement)(el, state)) +
+          "function(" + alias + iterator1 + iterator2 + "){" +
+          "return " + ((altGen || genElement)(el, state)) +
           '})');
   }
   function genData(el, state) {
@@ -4819,11 +4790,11 @@
           { data += dirs + ','; }
       // key
       if (el.key) {
-          data += "key:" + el.key + ",";
+          data += "key:" + (el.key) + ",";
       }
       // ref
       if (el.ref) {
-          data += "ref:" + el.ref + ",";
+          data += "ref:" + (el.ref) + ",";
       }
       if (el.refInFor) {
           data += "refInFor:true,";
@@ -4834,7 +4805,7 @@
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + el.tag + "\",";
+          data += "tag:\"" + (el.tag) + "\",";
       }
       // module data generation functions
       for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -4842,31 +4813,31 @@
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + genProps(el.attrs) + ",";
+          data += "attrs:" + (genProps(el.attrs)) + ",";
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + genProps(el.props) + ",";
+          data += "domProps:" + (genProps(el.props)) + ",";
       }
       // event handlers
       if (el.events) {
-          data += genHandlers(el.events, false) + ",";
+          data += (genHandlers(el.events, false)) + ",";
       }
       if (el.nativeEvents) {
-          data += genHandlers(el.nativeEvents, true) + ",";
+          data += (genHandlers(el.nativeEvents, true)) + ",";
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + el.slotTarget + ",";
+          data += "slot:" + (el.slotTarget) + ",";
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += genScopedSlots(el, el.scopedSlots, state) + ",";
+          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
       }
       // inline-template
       if (el.inlineTemplate) {
@@ -4880,7 +4851,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -4910,9 +4881,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                  ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                  : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
           }
       }
       if (hasRuntime) {
@@ -4926,9 +4897,9 @@
       }
       if (ast && ast.type === 1) {
           var inlineRenderFns = generate$1(ast, state.options);
-          return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-              .map(function (code) { return "function(){" + code + "}"; })
-              .join(',') + "]}";
+          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+              .map(function (code) { return ("function(){" + code + "}"); })
+              .join(',')) + "]}");
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -4953,23 +4924,23 @@
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent_2 = el.parent;
-          while (parent_2) {
-              if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                  parent_2.for) {
+          var parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
                   needsForceUpdate = true;
                   break;
               }
-              if (parent_2.if) {
+              if (parent.if) {
                   needsKey = true;
               }
-              parent_2 = parent_2.parent;
+              parent = parent.parent;
           }
       }
       var generatedSlots = Object.keys(slots)
           .map(function (key) { return genScopedSlot(slots[key], state); })
           .join(',');
-      return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
   }
   function hash(str) {
       var hash = 5381;
@@ -4998,36 +4969,36 @@
       }
       var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
       var fn = "function(" + slotScope + "){" +
-          ("return " + (el.tag === 'template'
+          "return " + (el.tag === 'template'
               ? el.if && isLegacySyntax
-                  ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                   : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}");
+              : genElement(el, state)) + "}";
       // reverse proxy v-slot without scope on this.$slots
       var reverseProxy = slotScope ? "" : ",proxy:true";
-      return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
       var children = el.children;
       if (children.length) {
-          var el_1 = children[0];
+          var el$1 = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el_1.for &&
-              el_1.tag !== 'template' &&
-              el_1.tag !== 'slot') {
-              var normalizationType_1 = checkSkip
-                  ? state.maybeComponent(el_1)
+              el$1.for &&
+              el$1.tag !== 'template' &&
+              el$1.tag !== 'slot') {
+              var normalizationType = checkSkip
+                  ? state.maybeComponent(el$1)
                       ? ",1"
                       : ",0"
                   : "";
-              return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
           }
-          var normalizationType = checkSkip
+          var normalizationType$1 = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen_1 = altGenNode || genNode;
-          return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+          var gen = altGenNode || genNode;
+          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
       }
   }
   // determine the normalization needed for the children array.
@@ -5069,17 +5040,17 @@
       }
   }
   function genText(text) {
-      return "_v(" + (text.type === 2
+      return ("_v(" + (text.type === 2
           ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
   }
   function genComment(comment) {
-      return "_e(" + JSON.stringify(comment.text) + ")";
+      return ("_e(" + (JSON.stringify(comment.text)) + ")");
   }
   function genSlot(el, state) {
       var slotName = el.slotName || '"default"';
       var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? "," + children : '');
+      var res = "_t(" + slotName + (children ? ("," + children) : '');
       var attrs = el.attrs || el.dynamicAttrs
           ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
               // slot props are camelized
@@ -5103,7 +5074,7 @@
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
       var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+      return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
   }
   function genProps(props) {
       var staticProps = "";
@@ -5112,15 +5083,15 @@
           var prop = props[i];
           var value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += prop.name + "," + value + ",";
+              dynamicProps += (prop.name) + "," + value + ",";
           }
           else {
-              staticProps += "\"" + prop.name + "\":" + value + ",";
+              staticProps += "\"" + (prop.name) + "\":" + value + ",";
           }
       }
-      staticProps = "{" + staticProps.slice(0, -1) + "}";
+      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
       if (dynamicProps) {
-          return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
       }
       else {
           return staticProps;
@@ -5150,15 +5121,19 @@
       }
   }
   function genAttrSegments(attrs) {
-      return attrs.map(function (_a) {
-          var name = _a.name, value = _a.value;
+      return attrs.map(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
+
           return genAttrSegment(name, value);
       });
   }
   function genDOMPropSegments(props, attrs) {
       var segments = [];
-      props.forEach(function (_a) {
-          var name = _a.name, value = _a.value;
+      props.forEach(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
+
           name = propsToAttrMap[name] || name.toLowerCase();
           if (isRenderableAttr(name) &&
               !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -5178,42 +5153,42 @@
           return {
               type: RAW,
               value: isBooleanAttr(name)
-                  ? " " + name + "=\"" + name + "\""
+                  ? (" " + name + "=\"" + name + "\"")
                   : value === '""'
-                      ? " " + name
-                      : " " + name + "=\"" + JSON.parse(value) + "\"",
+                      ? (" " + name)
+                      : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
           };
       }
       else {
           return {
               type: EXPRESSION,
-              value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
+              value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
           };
       }
   }
   function genClassSegments(staticClass, classBinding) {
       if (staticClass && !classBinding) {
-          return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
+          return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
+                  value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
               } ];
       }
   }
   function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
       if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
+          return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                      ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
-                      : 'null') + ")",
+                  value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                      ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                      : 'null') + ")"),
               } ];
       }
   }
@@ -5266,8 +5241,8 @@
               check(child);
           }
           if (node.ifConditions) {
-              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                  var block = node.ifConditions[i].block;
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
                   walk(block, isRoot);
                   check(block);
               }
@@ -5353,7 +5328,7 @@
       var state = new CodegenState(options);
       var code = ast ? genSSRElement(ast, state) : '_c("div")';
       return {
-          render: "with(this){return " + code + "}",
+          render: ("with(this){return " + code + "}"),
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -5390,9 +5365,9 @@
   function genNormalElement(el, state, stringifyChildren) {
       var data = el.plain ? undefined : genData(el, state);
       var children = stringifyChildren
-          ? "[" + genChildrenAsStringNode(el, state) + "]"
+          ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
           : genSSRChildren(el, state, true);
-      return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
+      return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
   }
   function genSSRChildren(el, state, checkSkip) {
       return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -5402,18 +5377,18 @@
   }
   function genChildrenAsStringNode(el, state) {
       return el.children.length
-          ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
+          ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
           : '';
   }
   function genStringElement(el, state) {
-      return "_ssrNode(" + elementToString(el, state) + ")";
+      return ("_ssrNode(" + (elementToString(el, state)) + ")");
   }
   function genStringElementWithChildren(el, state) {
       var children = genSSRChildren(el, state, true);
-      return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
+      return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
   }
   function elementToString(el, state) {
-      return "(" + flattenSegments(elementToSegments(el, state)) + ")";
+      return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
   }
   function elementToSegments(el, state) {
       // v-for / v-if
@@ -5438,16 +5413,17 @@
       }
       var openSegments = elementToOpenTagSegments(el, state);
       var childrenSegments = childrenToSegments(el, state);
-      var isUnaryTag = state.options.isUnaryTag;
+      var ref = state.options;
+      var isUnaryTag = ref.isUnaryTag;
       var close = isUnaryTag && isUnaryTag(el.tag)
           ? []
-          : [{ type: RAW, value: "</" + el.tag + ">" }];
+          : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
       return openSegments.concat(childrenSegments, close);
   }
   function elementToOpenTagSegments(el, state) {
       applyModelTransform(el, state);
       var binding;
-      var segments = [{ type: RAW, value: "<" + el.tag }];
+      var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
       // attrs
       if (el.attrs) {
           segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -5458,11 +5434,11 @@
       }
       // v-bind="object"
       if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
+          segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
       }
       // v-bind.prop="object"
       if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
+          segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
       }
       // class
       if (el.staticClass || el.classBinding) {
@@ -5474,7 +5450,7 @@
       }
       // _scopedId
       if (state.options.scopeId) {
-          segments.push({ type: RAW, value: " " + state.options.scopeId });
+          segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
       }
       segments.push({ type: RAW, value: ">" });
       return segments;
@@ -5482,13 +5458,13 @@
   function childrenToSegments(el, state) {
       var binding;
       if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
+          return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
       }
       if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
       }
       if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
       }
       return el.children ? nodesToSegments(el.children, state) : [];
   }
@@ -5528,11 +5504,11 @@
           }
           else if (s.type === INTERPOLATION) {
               pushBuffer();
-              mergedSegments.push("_ssrEscape(" + s.value + ")");
+              mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
           }
           else if (s.type === EXPRESSION) {
               pushBuffer();
-              mergedSegments.push("(" + s.value + ")");
+              mergedSegments.push(("(" + (s.value) + ")"));
           }
       }
       pushBuffer();
@@ -5562,22 +5538,22 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name_1 in node.attrsMap) {
-              if (dirRE.test(name_1)) {
-                  var value = node.attrsMap[name_1];
+          for (var name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  var value = node.attrsMap[name];
                   if (value) {
-                      var range = node.rawAttrsMap[name_1];
-                      if (name_1 === 'v-for') {
-                          checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                      var range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                       }
-                      else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                          checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                       }
-                      else if (onRE.test(name_1)) {
-                          checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                      else if (onRE.test(name)) {
+                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                       }
                       else {
-                          checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                       }
                   }
               }
@@ -5597,7 +5573,7 @@
       var keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
           warn("avoid using JavaScript unary operator as property name: " +
-              ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -5610,16 +5586,16 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function("var " + ident + "=_");
+              new Function(("var " + ident + "=_"));
           }
           catch (e) {
-              warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function("return " + exp);
+          new Function(("return " + exp));
       }
       catch (e) {
           var keywordMatch = exp
@@ -5627,12 +5603,12 @@
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
               warn("avoid using JavaScript keyword as property name: " +
-                  ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
           }
           else {
-              warn("invalid expression: " + e.message + " in\n\n" +
-                  ("    " + exp + "\n\n") +
-                  ("  Raw expression: " + text.trim() + "\n"), range);
+              warn("invalid expression: " + (e.message) + " in\n\n" +
+                  "    " + exp + "\n\n" +
+                  "  Raw expression: " + (text.trim()) + "\n", range);
           }
       }
   }
@@ -5641,16 +5617,17 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + e.message + " in\n\n" +
-              ("    " + exp + "\n\n") +
-              ("  Raw expression: " + text.trim() + "\n"), range);
+          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+              "    " + exp + "\n\n" +
+              "  Raw expression: " + (text.trim()) + "\n", range);
       }
   }
 
   var range = 2;
   function generateCodeFrame(source, start, end) {
-      if (start === void 0) { start = 0; }
-      if (end === void 0) { end = source.length; }
+      if ( start === void 0 ) start = 0;
+      if ( end === void 0 ) end = source.length;
+
       var lines = source.split(/\r?\n/);
       var count = 0;
       var res = [];
@@ -5660,18 +5637,18 @@
               for (var j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
                       { continue; }
-                  res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                  res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                   var lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
                       var pad = start - (count - lineLength) + 1;
-                      var length_1 = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                      var length = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length_2 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat("^", length_2));
+                          var length$1 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat("^", length$1));
                       }
                       count += lineLength + 1;
                   }
@@ -5743,13 +5720,13 @@
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
                       compiled.errors.forEach(function (e) {
-                          warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                          warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
                       warn("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                           '\n', vm);
                   }
               }
@@ -5777,10 +5754,12 @@
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                   warn("Failed to generate render function:\n\n" +
                       fnGenErrors
-                          .map(function (_a) {
-                          var err = _a.err, code = _a.code;
-                          return err.toString() + " in\n\n" + code + "\n";
-                      })
+                          .map(function (ref) {
+                              var err = ref.err;
+                              var code = ref.code;
+
+                              return ((err.toString()) + " in\n\n" + code + "\n");
+                  })
                           .join('\n'), vm);
               }
           }
@@ -5800,15 +5779,15 @@
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
                       warn = function (msg, range, tip) {
                           var data = { msg: msg };
                           if (range) {
                               if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength_1;
+                                  data.start = range.start + leadingSpaceLength;
                               }
                               if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength_1;
+                                  data.end = range.end + leadingSpaceLength;
                               }
                           }
                           (tip ? tips : errors).push(data);
@@ -5856,19 +5835,20 @@
       };
   });
 
-  var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
+  var ref = createCompiler(baseOptions);
+  var compileToFunctions = ref.compileToFunctions;
 
   function renderAttr(key, value) {
       if (isBooleanAttr(key)) {
           if (!isFalsyAttrValue(value)) {
-              return " " + key + "=\"" + key + "\"";
+              return (" " + key + "=\"" + key + "\"");
           }
       }
       else if (isEnumeratedAttr(key)) {
-          return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
+          return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"");
       }
       else if (!isFalsyAttrValue(value)) {
-          return " " + key + "=\"" + escape(String(value)) + "\"";
+          return (" " + key + "=\"" + (escape(String(value))) + "\"");
       }
       return '';
   }
@@ -5893,7 +5873,7 @@
       if (typeof value === 'string' ||
           (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
           value === 0) {
-          return key + ":" + value + ";";
+          return (key + ":" + value + ";");
       }
       else {
           // invalid values
@@ -5946,7 +5926,7 @@
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -6014,25 +5994,22 @@
           extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
       }
   }
-  var StringNode = /** @class */ (function () {
-      function StringNode(open, close, children, normalizationType) {
-          this.isString = true;
-          this.open = open;
-          this.close = close;
-          if (children) {
-              this.children =
-                  normalizationType === 1
-                      ? simpleNormalizeChildren(children)
-                      : normalizationType === 2
-                          ? normalizeChildren(children)
-                          : children;
-          }
-          else {
-              this.children = void 0;
-          }
+  var StringNode = function StringNode(open, close, children, normalizationType) {
+      this.isString = true;
+      this.open = open;
+      this.close = close;
+      if (children) {
+          this.children =
+              normalizationType === 1
+                  ? simpleNormalizeChildren(children)
+                  : normalizationType === 2
+                      ? normalizeChildren(children)
+                      : children;
+      }
+      else {
+          this.children = void 0;
       }
-      return StringNode;
-  }());
+  };
   function renderStringNode$1(open, close, children, normalizationType) {
       return new StringNode(open, close, children, normalizationType);
   }
@@ -6080,7 +6057,7 @@
   }
   function renderSSRClass(staticClass, dynamic) {
       var res = renderClass$1(staticClass, dynamic);
-      return res === '' ? res : " class=\"" + escape(res) + "\"";
+      return res === '' ? res : (" class=\"" + (escape(res)) + "\"");
   }
   function renderSSRStyle(staticStyle, dynamic, extra) {
       var style = {};
@@ -6091,7 +6068,7 @@
       if (extra)
           { extend(style, extra); }
       var res = genStyle(style);
-      return res === '' ? res : " style=" + JSON.stringify(escape(res));
+      return res === '' ? res : (" style=" + (JSON.stringify(escape(res))));
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
@@ -6101,13 +6078,13 @@
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy_1) {
-          var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function (target, key, value) {
-                  if (isBuiltInModifier_1(key)) {
-                      warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                       return false;
                   }
                   else {
@@ -6158,13 +6135,13 @@
   }
 
   {
-      var perf_1 = inBrowser && window.performance;
+      var perf = inBrowser && window.performance;
       /* istanbul ignore if */
-      if (perf_1 &&
-          perf_1.mark &&
-          perf_1.measure &&
-          perf_1.clearMarks &&
-          perf_1.clearMeasures) ;
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) ;
   }
 
   var normalizeEvent = cached(function (name) {
@@ -6207,7 +6184,7 @@
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+              warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -6240,7 +6217,8 @@
           return;
       }
       var res = {};
-      var attrs = data.attrs, props = data.props;
+      var attrs = data.attrs;
+      var props = data.props;
       if (isDef(attrs) || isDef(props)) {
           for (var key in propOptions) {
               var altKey = hyphenate(key);
@@ -6250,11 +6228,11 @@
                       tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                           (formatComponentName(
                           // @ts-ignore
-                          tag || Ctor) + ", but the declared prop name is") +
-                          (" \"" + key + "\". ") +
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
                           "Note that HTML attributes are case-insensitive and camelCased " +
                           "props need to use their kebab-case equivalents when using in-DOM " +
-                          ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -6300,7 +6278,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -6335,7 +6313,7 @@
       }
       var vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor = void 0;
+          var Ctor;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if ((!data || !data.pre) &&
               isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
@@ -6513,8 +6491,8 @@
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash = void 0;
-              var _loop_1 = function (key) {
+              var hash;
+              var loop = function ( key ) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
@@ -6531,15 +6509,14 @@
                       hash[key] = value[key];
                       if (isSync) {
                           var on = data.on || (data.on = {});
-                          on["update:" + key] = function ($event) {
+                          on[("update:" + key)] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
               };
-              for (var key in value) {
-                  _loop_1(key);
-              }
+
+              for (var key in value) loop( key );
           }
       }
       return data;
@@ -6559,7 +6536,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic(tree, "__static__" + index, false);
+      markStatic(tree, ("__static__" + index), false);
       return tree;
   }
   /**
@@ -6567,14 +6544,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
       return tree;
   }
   function markStatic(tree, key, isOnce) {
       if (Array.isArray(tree)) {
           for (var i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], key + "_" + i, isOnce);
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
               }
           }
       }
@@ -6640,7 +6617,7 @@
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+              warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
           }
       }
       return baseObj;
@@ -6692,8 +6669,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name_1 = data.slot;
-              var slot = slots[name_1] || (slots[name_1] = []);
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -6706,9 +6683,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name_2 in slots) {
-          if (slots[name_2].every(isWhitespace)) {
-              delete slots[name_2];
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
           }
       }
       return slots;
@@ -6741,16 +6718,16 @@
       }
       else {
           res = {};
-          for (var key_1 in slots) {
-              if (slots[key_1] && key_1[0] !== '$') {
-                  res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key_2 in normalSlots) {
-          if (!(key_2 in res)) {
-              res[key_2] = proxyNormalSlot(normalSlots, key_2);
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -6954,15 +6931,15 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance_1 = window.performance;
-      if (performance_1 &&
-          typeof performance_1.now === 'function' &&
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
           // if the event timestamp, although evaluated AFTER the Date.now(), is
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance_1.now(); };
+          getNow = function () { return performance.now(); };
       }
   }
   /**
@@ -7005,7 +6982,7 @@
                   }
                   else {
                       // @ts-ignore
-                      warn$2("Injection \"" + key + "\" not found", vm);
+                      warn$2(("Injection \"" + key + "\" not found"), vm);
                   }
               }
           }
@@ -7051,7 +7028,8 @@
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var _this = this;
+      var this$1 = this;
+
       var options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
@@ -7078,14 +7056,14 @@
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
       this.slots = function () {
-          if (!_this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
           }
-          return _this.$slots;
+          return this$1.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function () {
+          get: function get() {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -7108,9 +7086,7 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) {
-              return createElement(contextVm, a, b, c, d, needNormalization);
-          };
+          this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
@@ -7166,7 +7142,7 @@
 
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function (vnode, hydrating) {
+      init: function init(vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
@@ -7179,7 +7155,7 @@
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function (oldVnode, vnode) {
+      prepatch: function prepatch(oldVnode, vnode) {
           var options = vnode.componentOptions;
           var child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
@@ -7188,8 +7164,9 @@
           options.children // new children
           );
       },
-      insert: function (vnode) {
-          var context = vnode.context, componentInstance = vnode.componentInstance;
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
               callHook(componentInstance, 'mounted');
@@ -7208,7 +7185,7 @@
               }
           }
       },
-      destroy: function (vnode) {
+      destroy: function destroy(vnode) {
           var componentInstance = vnode.componentInstance;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
@@ -7234,7 +7211,7 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn$2("Invalid Component definition: " + String(Ctor), context);
+              warn$2(("Invalid Component definition: " + (String(Ctor))), context);
           }
           return;
       }
@@ -7292,7 +7269,7 @@
       var name = Ctor.options.name || tag;
       var vnode = new VNode(
       // @ts-expect-error
-      "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
       // @ts-expect-error
       { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
       return vnode;
@@ -7362,15 +7339,18 @@
       if (!warned[msg]) {
           warned[msg] = true;
           // eslint-disable-next-line no-console
-          console.warn("\n\u001B[31m" + msg + "\u001B[39m\n");
+          console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
       }
   };
   var onCompilationError = function (err, vm) {
       var trace = vm ? generateComponentTrace(vm) : '';
-      throw new Error("\n\u001B[31m" + err + trace + "\u001B[39m\n");
+      throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"));
   };
   var normalizeRender = function (vm) {
-      var _a = vm.$options, render = _a.render, template = _a.template, _scopeId = _a._scopeId;
+      var ref = vm.$options;
+      var render = ref.render;
+      var template = ref.template;
+      var _scopeId = ref._scopeId;
       if (isUndef(render)) {
           if (template) {
               var compiled = compileToFunctions(template, {
@@ -7381,7 +7361,7 @@
               vm.$options.staticRenderFns = compiled.staticRenderFns;
           }
           else {
-              throw new Error("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'));
+              throw new Error(("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous')));
           }
       }
   };
@@ -7423,7 +7403,7 @@
               renderAsyncComponent(node, isRoot, context);
           }
           else {
-              context.write("<!--" + node.text + "-->", context.next);
+              context.write(("<!--" + (node.text) + "-->"), context.next);
           }
       }
       else {
@@ -7440,7 +7420,9 @@
       return register;
   }
   function renderComponent(node, isRoot, context) {
-      var write = context.write, next = context.next, userContext = context.userContext;
+      var write = context.write;
+      var next = context.next;
+      var userContext = context.userContext;
       // check cache hit
       var Ctor = node.componentOptions.Ctor;
       var getKey = Ctor.options.serverCacheKey;
@@ -7453,12 +7435,13 @@
               renderComponentInner(node, isRoot, context);
               return;
           }
-          var key_1 = name + '::' + rawKey;
-          var has = context.has, get_1 = context.get;
+          var key = name + '::' + rawKey;
+          var has = context.has;
+          var get = context.get;
           if (isDef(has)) {
-              has(key_1, function (hit) {
-                  if (hit === true && isDef(get_1)) {
-                      get_1(key_1, function (res) {
+              has(key, function (hit) {
+                  if (hit === true && isDef(get)) {
+                      get(key, function (res) {
                           if (isDef(registerComponent)) {
                               registerComponent(userContext);
                           }
@@ -7467,12 +7450,12 @@
                       });
                   }
                   else {
-                      renderComponentWithCache(node, isRoot, key_1, context);
+                      renderComponentWithCache(node, isRoot, key, context);
                   }
               });
           }
-          else if (isDef(get_1)) {
-              get_1(key_1, function (res) {
+          else if (isDef(get)) {
+              get(key, function (res) {
                   if (isDef(res)) {
                       if (isDef(registerComponent)) {
                           registerComponent(userContext);
@@ -7481,7 +7464,7 @@
                       write(res.html, next);
                   }
                   else {
-                      renderComponentWithCache(node, isRoot, key_1, context);
+                      renderComponentWithCache(node, isRoot, key, context);
                   }
               });
           }
@@ -7538,7 +7521,10 @@
           if (comp.__esModule && comp.default) {
               comp = comp.default;
           }
-          var _a = node.asyncMeta, data = _a.data, children = _a.children, tag = _a.tag;
+          var ref = node.asyncMeta;
+          var data = ref.data;
+          var children = ref.children;
+          var tag = ref.tag;
           var nodeContext = node.asyncMeta.context;
           var resolvedNode = createComponent(comp, data, nodeContext, children, tag);
           if (resolvedNode) {
@@ -7593,7 +7579,8 @@
       }
   }
   function renderStringNode(el, context) {
-      var write = context.write, next = context.next;
+      var write = context.write;
+      var next = context.next;
       if (isUndef(el.children) || el.children.length === 0) {
           write(el.open + (el.close || ''), next);
       }
@@ -7610,7 +7597,8 @@
       }
   }
   function renderElement(el, isRoot, context) {
-      var write = context.write, next = context.next;
+      var write = context.write;
+      var next = context.next;
       if (isTrue(isRoot)) {
           if (!el.data)
               { el.data = {}; }
@@ -7622,7 +7610,7 @@
           registerComponentForCache(el.fnOptions, write);
       }
       var startTag = renderStartingTag(el, context);
-      var endTag = "</" + el.tag + ">";
+      var endTag = "</" + (el.tag) + ">";
       if (context.isUnaryTag(el.tag)) {
           write(startTag, next);
       }
@@ -7661,8 +7649,9 @@
       return dir;
   }
   function renderStartingTag(node, context) {
-      var markup = "<" + node.tag;
-      var directives = context.directives, modules = context.modules;
+      var markup = "<" + (node.tag);
+      var directives = context.directives;
+      var modules = context.modules;
       // construct synthetic data for module processing
       // because modules like style also produce code by parent VNode data
       if (isUndef(node.data) && hasAncestorData(node)) {
@@ -7673,9 +7662,9 @@
           var dirs = node.data.directives;
           if (dirs) {
               for (var i = 0; i < dirs.length; i++) {
-                  var name_1 = dirs[i].name;
-                  if (name_1 !== 'show') {
-                      var dirRenderer = resolveAsset(context, 'directives', name_1);
+                  var name = dirs[i].name;
+                  if (name !== 'show') {
+                      var dirRenderer = resolveAsset(context, 'directives', name);
                       if (dirRenderer) {
                           // directives mutate the node's data
                           // which then gets rendered by modules
@@ -7690,8 +7679,8 @@
               directives.show(node, vshowDirectiveInfo);
           }
           // apply other modules
-          for (var i = 0; i < modules.length; i++) {
-              var res = modules[i](node);
+          for (var i$1 = 0; i$1 < modules.length; i$1++) {
+              var res = modules[i$1](node);
               if (res) {
                   markup += res;
               }
@@ -7706,7 +7695,7 @@
           markup += " " + scopeId;
       }
       if (isDef(node.fnScopeId)) {
-          markup += " " + node.fnScopeId;
+          markup += " " + (node.fnScopeId);
       }
       else {
           while (isDef(node)) {
@@ -7742,8 +7731,13 @@
       };
   }
 
-  function createBasicRenderer(_a) {
-      var _b = _a === void 0 ? {} : _a, _c = _b.modules, modules = _c === void 0 ? [] : _c, _d = _b.directives, directives = _d === void 0 ? {} : _d, _e = _b.isUnaryTag, isUnaryTag = _e === void 0 ? function () { return false; } : _e, cache = _b.cache;
+  function createBasicRenderer(ref) {
+      if ( ref === void 0 ) ref = {};
+      var modules = ref.modules; if ( modules === void 0 ) modules = [];
+      var directives = ref.directives; if ( directives === void 0 ) directives = {};
+      var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = function () { return false; };
+      var cache = ref.cache;
+
       var render = createRenderFunction(modules, directives, isUnaryTag, cache);
       return function renderToString(component, context, done) {
           if (typeof context === 'function') {
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index 20f8f7371df..089eda75243 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -461,17 +461,17 @@ function renderAttrs$1(node) {
     var res = '';
     var opts = node.parent && node.parent.componentOptions;
     if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-        var parent_1 = node.parent;
-        while (isDef(parent_1)) {
+        var parent = node.parent;
+        while (isDef(parent)) {
             // Stop fallthrough in case parent has inheritAttrs option set to false
-            if (parent_1.componentOptions &&
-                parent_1.componentOptions.Ctor.options.inheritAttrs === false) {
+            if (parent.componentOptions &&
+                parent.componentOptions.Ctor.options.inheritAttrs === false) {
                 break;
             }
-            if (isDef(parent_1.data) && isDef(parent_1.data.attrs)) {
-                attrs = extend(extend({}, attrs), parent_1.data.attrs);
+            if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                attrs = extend(extend({}, attrs), parent.data.attrs);
             }
-            parent_1 = parent_1.parent;
+            parent = parent.parent;
         }
     }
     if (isUndef(attrs)) {
@@ -492,57 +492,55 @@ function renderAttrs$1(node) {
 function renderAttr$1(key, value) {
     if (isBooleanAttr(key)) {
         if (!isFalsyAttrValue(value)) {
-            return " " + key + "=\"" + key + "\"";
+            return (" " + key + "=\"" + key + "\"");
         }
     }
     else if (isEnumeratedAttr(key)) {
-        return " " + key + "=\"" + escape$1(convertEnumeratedValue(key, value)) + "\"";
+        return (" " + key + "=\"" + (escape$1(convertEnumeratedValue(key, value))) + "\"");
     }
     else if (!isFalsyAttrValue(value)) {
-        return " " + key + "=\"" + escape$1(String(value)) + "\"";
+        return (" " + key + "=\"" + (escape$1(String(value))) + "\"");
     }
     return '';
 }
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
+};
+
+var prototypeAccessors = { child: { configurable: true } };
+// DEPRECATED: alias for componentInstance for backwards compat.
+/* istanbul ignore next */
+prototypeAccessors.child.get = function () {
+    return this.componentInstance;
+};
+
+Object.defineProperties( VNode.prototype, prototypeAccessors );
 var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
+    if ( text === void 0 ) text = '';
+
     var node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -662,7 +660,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get: function get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -705,19 +703,20 @@ var _Set; // $flow-disable-line
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
+    _Set = /*@__PURE__*/(function () {
         function Set() {
             this.set = Object.create(null);
         }
-        Set.prototype.has = function (key) {
+        Set.prototype.has = function has (key) {
             return this.set[key] === true;
         };
-        Set.prototype.add = function (key) {
+        Set.prototype.add = function add (key) {
             this.set[key] = true;
         };
-        Set.prototype.clear = function () {
+        Set.prototype.clear = function clear () {
             this.set = Object.create(null);
         };
+
         return Set;
     }());
 }
@@ -821,19 +820,17 @@ var tip = noop$1;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
     warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
+        if (hasConsole && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -856,10 +853,10 @@ var formatComponentName;
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
     };
-    var repeat_1 = function (str, n) {
+    var repeat$1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -893,15 +890,13 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
         }
     };
 }
@@ -911,31 +906,28 @@ var uid = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid++;
-        this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
+};
+Dep.prototype.addSub = function addSub (sub) {
+    this.subs.push(sub);
+};
+Dep.prototype.removeSub = function removeSub (sub) {
+    remove$1(this.subs, sub);
+};
+Dep.prototype.depend = function depend () {
+    if (Dep.target) {
+        Dep.target.addDep(this);
     }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove$1(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
+};
+Dep.prototype.notify = function notify () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
+};
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
@@ -971,12 +963,9 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -1012,46 +1001,43 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
         }
         else {
-            this.walk(value);
+            copyAugment(value, arrayMethods, arrayKeys);
         }
+        this.observeArray(value);
     }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
+    else {
+        this.walk(value);
+    }
+};
+/**
+ * Walk through all properties and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ */
+Observer.prototype.walk = function walk (obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i]);
+    }
+};
+/**
+ * Observe a list of Array items.
+ */
+Observer.prototype.observeArray = function observeArray (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
+};
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -1161,7 +1147,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
  */
 function set(target, key, val) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -1192,7 +1178,7 @@ function set(target, key, val) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1367,14 +1353,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1412,7 +1398,7 @@ function checkComponents(options) {
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
+    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
         warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1456,7 +1442,7 @@ function normalizeProps(options, vm) {
     }
     else {
         warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
+            "but got " + (toRawType(props)) + ".", vm);
     }
     options.props = res;
 }
@@ -1483,7 +1469,7 @@ function normalizeInject(options, vm) {
     }
     else {
         warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
+            "but got " + (toRawType(inject)) + ".", vm);
     }
 }
 /**
@@ -1503,7 +1489,7 @@ function normalizeDirectives(options) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+            "but got " + (toRawType(value)) + ".", vm);
     }
 }
 /**
@@ -1739,7 +1725,7 @@ function getTypeIndex(type, expectedTypes) {
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
     var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
+        " Expected " + (expectedTypes.map(capitalize).join(', '));
     var expectedType = expectedTypes[0];
     var receivedType = toRawType(value);
     // check if we need to specify expected value
@@ -1747,24 +1733,24 @@ function getInvalidTypeMessage(name, value, expectedTypes) {
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
+        message += " with value " + (styleValue(value, expectedType));
     }
     message += ", got " + receivedType + " ";
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
+        message += "with value " + (styleValue(value, receivedType)) + ".";
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return "\"" + value + "\"";
+        return ("\"" + value + "\"");
     }
     else if (type === 'Number') {
-        return "" + Number(value);
+        return ("" + (Number(value)));
     }
     else {
-        return "" + value;
+        return ("" + value);
     }
 }
 var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
@@ -1772,12 +1758,9 @@ function isExplicable(value) {
     return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
 }
 function isBoolean() {
-    var arguments$1 = arguments;
+    var args = [], len = arguments.length;
+    while ( len-- ) args[ len ] = arguments[ len ];
 
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments$1[_i];
-    }
     return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
 }
 
@@ -1831,7 +1814,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn$2("Error in " + info + ": \"" + err.toString() + "\"", vm);
+        warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1867,10 +1850,10 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
+    var counter = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
 }
@@ -1982,7 +1965,7 @@ makeMap('text,number,password,search,email,tel,url');
 function renderClass(node) {
     var classList = genClassForVnode(node);
     if (classList !== '') {
-        return " class=\"" + escape$1(classList) + "\"";
+        return (" class=\"" + (escape$1(classList)) + "\"");
     }
 }
 
@@ -2065,7 +2048,7 @@ function normalizeValue$1(key, value) {
     if (typeof value === 'string' ||
         (typeof value === 'number' && noUnitNumericStyleProps$1[key]) ||
         value === 0) {
-        return key + ":" + value + ";";
+        return (key + ":" + value + ";");
     }
     else {
         // invalid values
@@ -2075,7 +2058,7 @@ function normalizeValue$1(key, value) {
 function renderStyle(vnode) {
     var styleText = genStyle$1(getStyle(vnode, false));
     if (styleText !== '') {
-        return " style=" + JSON.stringify(escape$1(styleText));
+        return (" style=" + (JSON.stringify(escape$1(styleText))));
     }
 }
 
@@ -2148,37 +2131,6 @@ makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
 var MAX_STACK_DEPTH = 800;
 var noop = function (_) { return _; };
 var defer = typeof process !== 'undefined' && process.nextTick
@@ -2231,40 +2183,44 @@ function createWriteFunction(write, onError) {
  *
  * Modified by Evan You (@yyx990803)
  */
-var RenderStream = /** @class */ (function (_super) {
-    __extends(RenderStream, _super);
+var RenderStream = /*@__PURE__*/(function (Readable) {
     function RenderStream(render) {
-        var _this = _super.call(this) || this;
-        _this.buffer = '';
+        var this$1 = this;
+
+        Readable.call(this);
+        this.buffer = '';
         //@ts-expect-error
-        _this.render = render;
-        _this.expectedSize = 0;
-        _this.write = createWriteFunction(function (text, next) {
-            var n = _this.expectedSize;
-            _this.buffer += text;
-            if (_this.buffer.length >= n) {
-                _this.next = next;
-                _this.pushBySize(n);
+        this.render = render;
+        this.expectedSize = 0;
+        this.write = createWriteFunction(function (text, next) {
+            var n = this$1.expectedSize;
+            this$1.buffer += text;
+            if (this$1.buffer.length >= n) {
+                this$1.next = next;
+                this$1.pushBySize(n);
                 return true; // we will decide when to call next
             }
             return false;
         }, function (err) {
-            _this.emit('error', err);
+            this$1.emit('error', err);
         });
-        _this.end = function () {
-            _this.emit('beforeEnd');
+        this.end = function () {
+            this$1.emit('beforeEnd');
             // the rendering is finished; we should push out the last of the buffer.
-            _this.done = true;
-            _this.push(_this.buffer);
+            this$1.done = true;
+            this$1.push(this$1.buffer);
         };
-        return _this;
     }
-    RenderStream.prototype.pushBySize = function (n) {
+
+    if ( Readable ) RenderStream.__proto__ = Readable;
+    RenderStream.prototype = Object.create( Readable && Readable.prototype );
+    RenderStream.prototype.constructor = RenderStream;
+    RenderStream.prototype.pushBySize = function pushBySize (n) {
         var bufferToPush = this.buffer.substring(0, n);
         this.buffer = this.buffer.substring(n);
         this.push(bufferToPush);
     };
-    RenderStream.prototype.tryRender = function () {
+    RenderStream.prototype.tryRender = function tryRender () {
         try {
             this.render(this.write, this.end);
         }
@@ -2272,7 +2228,7 @@ var RenderStream = /** @class */ (function (_super) {
             this.emit('error', e);
         }
     };
-    RenderStream.prototype.tryNext = function () {
+    RenderStream.prototype.tryNext = function tryNext () {
         try {
             this.next();
         }
@@ -2280,7 +2236,7 @@ var RenderStream = /** @class */ (function (_super) {
             this.emit('error', e);
         }
     };
-    RenderStream.prototype._read = function (n) {
+    RenderStream.prototype._read = function _read (n) {
         this.expectedSize = n;
         // it's possible that the last chunk added bumped the buffer up to > 2 * n,
         // which means we will need to go through multiple read calls to drain it
@@ -2302,93 +2258,89 @@ var RenderStream = /** @class */ (function (_super) {
             this.tryNext();
         }
     };
+
     return RenderStream;
 }(stream.Readable));
 
-var RenderContext = /** @class */ (function () {
-    function RenderContext(options) {
-        this.userContext = options.userContext;
-        this.activeInstance = options.activeInstance;
-        this.renderStates = [];
-        this.write = options.write;
-        this.done = options.done;
-        this.renderNode = options.renderNode;
-        this.isUnaryTag = options.isUnaryTag;
-        this.modules = options.modules;
-        this.directives = options.directives;
-        var cache = options.cache;
-        if (cache && (!cache.get || !cache.set)) {
-            throw new Error('renderer cache must implement at least get & set.');
-        }
-        this.cache = cache;
-        this.get = cache && normalizeAsync(cache, 'get');
-        this.has = cache && normalizeAsync(cache, 'has');
-        //@ts-expect-error
-        this.next = this.next.bind(this);
-    }
+var RenderContext = function RenderContext(options) {
+    this.userContext = options.userContext;
+    this.activeInstance = options.activeInstance;
+    this.renderStates = [];
+    this.write = options.write;
+    this.done = options.done;
+    this.renderNode = options.renderNode;
+    this.isUnaryTag = options.isUnaryTag;
+    this.modules = options.modules;
+    this.directives = options.directives;
+    var cache = options.cache;
+    if (cache && (!cache.get || !cache.set)) {
+        throw new Error('renderer cache must implement at least get & set.');
+    }
+    this.cache = cache;
+    this.get = cache && normalizeAsync(cache, 'get');
+    this.has = cache && normalizeAsync(cache, 'has');
     //@ts-expect-error
-    RenderContext.prototype.next = function () {
-        var _loop_1 = function () {
-            var lastState = this_1.renderStates[this_1.renderStates.length - 1];
-            if (isUndef(lastState)) {
-                return { value: this_1.done() };
-            }
-            /* eslint-disable no-case-declarations */
-            switch (lastState.type) {
-                case 'Element':
-                case 'Fragment':
-                    var children = lastState.children, total = lastState.total;
-                    var rendered = lastState.rendered++;
-                    if (rendered < total) {
-                        return { value: this_1.renderNode(children[rendered], false, this_1) };
-                    }
-                    else {
-                        this_1.renderStates.pop();
-                        if (lastState.type === 'Element') {
-                            return { value: this_1.write(lastState.endTag, this_1.next) };
-                        }
-                    }
-                    break;
-                case 'Component':
-                    this_1.renderStates.pop();
-                    this_1.activeInstance = lastState.prevActive;
-                    break;
-                case 'ComponentWithCache':
-                    this_1.renderStates.pop();
-                    var buffer = lastState.buffer, bufferIndex = lastState.bufferIndex, componentBuffer = lastState.componentBuffer, key = lastState.key;
-                    var result = {
-                        html: buffer[bufferIndex],
-                        components: componentBuffer[bufferIndex],
-                    };
-                    this_1.cache.set(key, result);
-                    if (bufferIndex === 0) {
-                        // this is a top-level cached component,
-                        // exit caching mode.
-                        //@ts-expect-error
-                        this_1.write.caching = false;
-                    }
-                    else {
-                        // parent component is also being cached,
-                        // merge self into parent's result
-                        buffer[bufferIndex - 1] += result.html;
-                        var prev_1 = componentBuffer[bufferIndex - 1];
-                        result.components.forEach(function (c) { return prev_1.add(c); });
+    this.next = this.next.bind(this);
+};
+//@ts-expect-error
+RenderContext.prototype.next = function next () {
+    // eslint-disable-next-line
+    while (true) {
+        var lastState = this.renderStates[this.renderStates.length - 1];
+        if (isUndef(lastState)) {
+            return this.done();
+        }
+        /* eslint-disable no-case-declarations */
+        switch (lastState.type) {
+            case 'Element':
+            case 'Fragment':
+                var children = lastState.children;
+            var total = lastState.total;
+                var rendered = lastState.rendered++;
+                if (rendered < total) {
+                    return this.renderNode(children[rendered], false, this);
+                }
+                else {
+                    this.renderStates.pop();
+                    if (lastState.type === 'Element') {
+                        return this.write(lastState.endTag, this.next);
                     }
-                    buffer.length = bufferIndex;
-                    componentBuffer.length = bufferIndex;
-                    break;
-            }
-        };
-        var this_1 = this;
-        // eslint-disable-next-line
-        while (true) {
-            var state_1 = _loop_1();
-            if (typeof state_1 === "object")
-                { return state_1.value; }
+                }
+                break;
+            case 'Component':
+                this.renderStates.pop();
+                this.activeInstance = lastState.prevActive;
+                break;
+            case 'ComponentWithCache':
+                this.renderStates.pop();
+                var buffer = lastState.buffer;
+            var bufferIndex = lastState.bufferIndex;
+            var componentBuffer = lastState.componentBuffer;
+            var key = lastState.key;
+                var result = {
+                    html: buffer[bufferIndex],
+                    components: componentBuffer[bufferIndex],
+                };
+                this.cache.set(key, result);
+                if (bufferIndex === 0) {
+                    // this is a top-level cached component,
+                    // exit caching mode.
+                    //@ts-expect-error
+                    this.write.caching = false;
+                }
+                else {
+                    // parent component is also being cached,
+                    // merge self into parent's result
+                    buffer[bufferIndex - 1] += result.html;
+                    var prev = componentBuffer[bufferIndex - 1];
+                    result.components.forEach(function (c) { return prev.add(c); });
+                }
+                buffer.length = bufferIndex;
+                componentBuffer.length = bufferIndex;
+                break;
         }
-    };
-    return RenderContext;
-}());
+    }
+};
 function normalizeAsync(cache, method) {
     var fn = cache[method];
     if (isUndef(fn)) {
@@ -2480,9 +2432,7 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p 
-                // find first non-whitespace prev char
-                = void 0;
+                var p = (void 0);
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -2516,12 +2466,12 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return "_f(\"" + filter + "\")(" + exp + ")";
+        return ("_f(\"" + filter + "\")(" + exp + ")");
     }
     else {
-        var name_1 = filter.slice(0, i);
+        var name = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
     }
 }
 
@@ -2551,7 +2501,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push("_s(" + exp + ")");
+        tokens.push(("_s(" + exp + ")"));
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -2567,7 +2517,7 @@ function parseText(text, delimiters) {
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error("[Vue compiler]: " + msg);
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -2601,7 +2551,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -2754,10 +2704,10 @@ function transformNode$1(el, options) {
 function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + el.staticClass + ",";
+        data += "staticClass:" + (el.staticClass) + ",";
     }
     if (el.classBinding) {
-        data += "class:" + el.classBinding + ",";
+        data += "class:" + (el.classBinding) + ",";
     }
     return data;
 }
@@ -2791,10 +2741,10 @@ function transformNode(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + el.staticStyle + ",";
+        data += "staticStyle:" + (el.staticStyle) + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + el.styleBinding + "),";
+        data += "style:(" + (el.styleBinding) + "),";
     }
     return data;
 }
@@ -2823,11 +2773,11 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp("^<" + qnameCapture);
+var startTagOpen = new RegExp(("^<" + qnameCapture));
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -2848,9 +2798,7 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) {
-    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-};
+var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -2862,7 +2810,7 @@ function parseHTML(html, options) {
     var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    var _loop_1 = function () {
+    while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -2876,7 +2824,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        return "continue";
+                        continue;
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -2884,14 +2832,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        return "continue";
+                        continue;
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    return "continue";
+                    continue;
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -2899,7 +2847,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    return "continue";
+                    continue;
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -2908,10 +2856,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    return "continue";
+                    continue;
                 }
             }
-            var text = void 0, rest = void 0, next = void 0;
+            var text = (void 0), rest = (void 0), next = (void 0);
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -2938,18 +2886,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength_1 = 0;
-            var stackedTag_1 = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag_1] ||
-                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-            var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength_1 = endTag.length;
-                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -2957,25 +2905,20 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag_1, index - endTagLength_1, index);
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                     start: index + html.length,
                 });
             }
-            return "break";
+            break;
         }
-    };
-    while (html) {
-        var state_1 = _loop_1();
-        if (state_1 === "break")
-            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -2992,7 +2935,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end = void 0, attr = void 0;
+            var end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -3075,7 +3018,7 @@ function parseHTML(html, options) {
             for (var i = stack.length - 1; i >= pos; i--) {
                 if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -3108,23 +3051,25 @@ function parseHTML(html, options) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                ("? " + baseValueExpression + ".trim()") +
-                (": " + baseValueExpression + ")");
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: "(" + value + ")",
+        value: ("(" + value + ")"),
         expression: JSON.stringify(value),
-        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
     };
 }
 /**
@@ -3133,10 +3078,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return value + "=" + assignment;
+        return (value + "=" + assignment);
     }
     else {
-        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
     }
 }
 /**
@@ -3275,7 +3220,10 @@ function parse(template, options) {
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
     var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    maybeComponent = function (el) { return !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -3326,8 +3274,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name_1 = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -3353,7 +3301,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode = void 0;
+            var lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -3363,7 +3311,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -3380,7 +3328,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function (tag, attrs, unary, start, end) {
+        start: function start(tag, attrs, unary, start$1, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -3395,7 +3343,7 @@ function parse(template, options) {
             }
             {
                 if (options.outputSourceRange) {
-                    element.start = start;
+                    element.start = start$1;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -3416,7 +3364,7 @@ function parse(template, options) {
                 element.forbidden = true;
                 warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        ("<" + tag + ">") +
+                        "<" + tag + ">" +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -3455,24 +3403,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function (tag, start, end) {
+        end: function end(tag, start, end$1) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (options.outputSourceRange) {
-                element.end = end;
+                element.end = end$1;
             }
             closeElement(element);
         },
-        chars: function (text, start, end) {
+        chars: function chars(text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                             start: start,
                         });
                     }
@@ -3512,8 +3460,8 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res = void 0;
-                var child = void 0;
+                var res;
+                var child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -3539,7 +3487,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function (text, start, end) {
+        comment: function comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -3609,11 +3557,11 @@ function processKey(el) {
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent_1 = el.parent;
+                var parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent_1 &&
-                    parent_1.tag === 'transition-group') {
+                    parent &&
+                    parent.tag === 'transition-group') {
                     warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
@@ -3637,7 +3585,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -3690,7 +3638,7 @@ function processIfConditions(el, parent) {
     }
     else {
         warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -3701,7 +3649,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -3738,7 +3686,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -3770,41 +3718,45 @@ function processSlotContent(el) {
                             "the receiving component", el);
                     }
                 }
-                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                el.slotTarget = name_2;
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                     }
                     if (el.slotScope || el.slotTarget) {
                         warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
                         warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding);
+                            "<template> syntax when there are other named slots.", slotBinding$1);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                slotContainer_1.slotTarget = name_3;
-                slotContainer_1.slotTargetDynamic = dynamic;
-                slotContainer_1.children = el.children.filter(function (c) {
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer_1;
+                        c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -3827,7 +3779,7 @@ function getSlotName(binding) {
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: "\"" + name + "\"", dynamic: false };
+            { name: ("\"" + name + "\""), dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
@@ -3873,7 +3825,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -3887,14 +3839,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -3971,11 +3923,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret_1 = {};
+        var ret = {};
         match.forEach(function (m) {
-            ret_1[m.slice(1)] = true;
+            ret[m.slice(1)] = true;
         });
-        return ret_1;
+        return ret;
     }
 }
 function makeAttrsMap(attrs) {
@@ -4017,7 +3969,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -4042,16 +3994,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding = void 0;
+        var typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + map['v-bind'] + ").type";
+            typeBinding = "(" + (map['v-bind']) + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -4117,7 +4069,7 @@ function model(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -4152,25 +4104,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
         (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
         'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
         '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -4178,10 +4130,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
+        "return " + (number ? '_n(val)' : 'val') + "})";
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
+    code = code + " " + (genAssignmentCode(value, assignment));
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -4189,15 +4141,18 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
+        if (value$1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+            warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -4211,7 +4166,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', "(" + value + ")");
+    addProp(el, 'value', ("(" + value + ")"));
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -4220,13 +4175,13 @@ function genDefaultModel(el, value, modifiers) {
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
@@ -4284,7 +4239,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -4301,19 +4256,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name_1 in events) {
-        var handlerCode = genHandler(events[name_1]);
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
         //@ts-expect-error
-        if (events[name_1] && events[name_1].dynamic) {
-            dynamicHandlers += name_1 + "," + handlerCode + ",";
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
     if (dynamicHandlers) {
-        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
     }
     else {
         return prefix + staticHandlers;
@@ -4324,7 +4279,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -4333,13 +4288,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        var _loop_1 = function (key) {
+        for (var key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -4348,18 +4303,15 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers_1 = handler.modifiers;
+                var modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
-        };
-        for (var key in handler.modifiers) {
-            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -4369,13 +4321,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? "return " + handler.value + ".apply(null, arguments)"
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
             : isFunctionExpression
-                ? "return (" + handler.value + ").apply(null, arguments)"
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
                 : isFunctionInvocation
-                    ? "return " + handler.value
+                    ? ("return " + (handler.value))
                     : handler.value;
-        return "function($event){" + code + handlerCode + "}";
+        return ("function($event){" + code + handlerCode + "}");
     }
 }
 function genKeyFilter(keys) {
@@ -4384,20 +4336,20 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&') + ")return null;"));
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return "$event.keyCode!==" + keyVal;
+        return ("$event.keyCode!==" + keyVal);
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key) + ",") +
-        (JSON.stringify(keyCode) + ",") +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
         "$event.key," +
-        ("" + JSON.stringify(keyName)) +
+        "" + (JSON.stringify(keyName)) +
         ")");
 }
 
@@ -4405,12 +4357,12 @@ function on(el, dir) {
     if (dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
 function bind(el, dir) {
     el.wrapData = function (code) {
-        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
     };
 }
 
@@ -4420,24 +4372,19 @@ var baseDirectives = {
     cloak: noop$1,
 };
 
-var CodegenState = /** @class */ (function () {
-    function CodegenState(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        var isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = function (el) {
-            return !!el.component || !isReservedTag(el.tag);
-        };
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-    return CodegenState;
-}());
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
+};
 function generate$1(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
@@ -4447,7 +4394,7 @@ function generate$1(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: ("with(this){return " + code + "}"),
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -4475,19 +4422,17 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code = void 0;
+        var code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data = void 0;
+            var data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-            ) + (children ? "," + children : '' // children
-            ) + ")";
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -4506,9 +4451,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
     state.pre = originalPreState;
-    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
 // v-once
 function genOnce(el, state) {
@@ -4518,19 +4463,19 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent_1 = el.parent;
-        while (parent_1) {
-            if (parent_1.for) {
-                key = parent_1.key;
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
                 break;
             }
-            parent_1 = parent_1.parent;
+            parent = parent.parent;
         }
         if (!key) {
             state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
     }
     else {
         return genStatic(el, state);
@@ -4546,10 +4491,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
     }
     else {
-        return "" + genTernaryExp(condition.block);
+        return ("" + (genTernaryExp(condition.block)));
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -4563,20 +4508,20 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        ("function(" + alias + iterator1 + iterator2 + "){") +
-        ("return " + (altGen || genElement)(el, state)) +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
         '})');
 }
 function genData(el, state) {
@@ -4588,11 +4533,11 @@ function genData(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + el.key + ",";
+        data += "key:" + (el.key) + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + el.ref + ",";
+        data += "ref:" + (el.ref) + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -4603,7 +4548,7 @@ function genData(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + el.tag + "\",";
+        data += "tag:\"" + (el.tag) + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -4611,31 +4556,31 @@ function genData(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + genProps(el.attrs) + ",";
+        data += "attrs:" + (genProps(el.attrs)) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + genProps(el.props) + ",";
+        data += "domProps:" + (genProps(el.props)) + ",";
     }
     // event handlers
     if (el.events) {
-        data += genHandlers(el.events, false) + ",";
+        data += (genHandlers(el.events, false)) + ",";
     }
     if (el.nativeEvents) {
-        data += genHandlers(el.nativeEvents, true) + ",";
+        data += (genHandlers(el.nativeEvents, true)) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + el.slotTarget + ",";
+        data += "slot:" + (el.slotTarget) + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += genScopedSlots(el, el.scopedSlots, state) + ",";
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -4649,7 +4594,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -4679,9 +4624,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -4695,9 +4640,9 @@ function genInlineTemplate(el, state) {
     }
     if (ast && ast.type === 1) {
         var inlineRenderFns = generate$1(ast, state.options);
-        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-            .map(function (code) { return "function(){" + code + "}"; })
-            .join(',') + "]}";
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -4722,23 +4667,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent_2 = el.parent;
-        while (parent_2) {
-            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                parent_2.for) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent_2.if) {
+            if (parent.if) {
                 needsKey = true;
             }
-            parent_2 = parent_2.parent;
+            parent = parent.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
 }
 function hash(str) {
     var hash = 5381;
@@ -4767,36 +4712,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        ("return " + (el.tag === 'template'
+        "return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}");
+            : genElement(el, state)) + "}";
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el_1 = children[0];
+        var el$1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el_1.for &&
-            el_1.tag !== 'template' &&
-            el_1.tag !== 'slot') {
-            var normalizationType_1 = checkSkip
-                ? state.maybeComponent(el_1)
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
                     ? ",1"
                     : ",0"
                 : "";
-            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
         }
-        var normalizationType = checkSkip
+        var normalizationType$1 = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen_1 = altGenNode || genNode;
-        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
     }
 }
 // determine the normalization needed for the children array.
@@ -4838,17 +4783,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return "_v(" + (text.type === 2
+    return ("_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
 }
 function genComment(comment) {
-    return "_e(" + JSON.stringify(comment.text) + ")";
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? "," + children : '');
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -4872,7 +4817,7 @@ function genSlot(el, state) {
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+    return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
 }
 function genProps(props) {
     var staticProps = "";
@@ -4881,15 +4826,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += prop.name + "," + value + ",";
+            dynamicProps += (prop.name) + "," + value + ",";
         }
         else {
-            staticProps += "\"" + prop.name + "\":" + value + ",";
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
         }
     }
-    staticProps = "{" + staticProps.slice(0, -1) + "}";
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
     if (dynamicProps) {
-        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
     }
     else {
         return staticProps;
@@ -4919,15 +4864,19 @@ function applyModelTransform(el, state) {
     }
 }
 function genAttrSegments(attrs) {
-    return attrs.map(function (_a) {
-        var name = _a.name, value = _a.value;
+    return attrs.map(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
+
         return genAttrSegment(name, value);
     });
 }
 function genDOMPropSegments(props, attrs) {
     var segments = [];
-    props.forEach(function (_a) {
-        var name = _a.name, value = _a.value;
+    props.forEach(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
+
         name = propsToAttrMap[name] || name.toLowerCase();
         if (isRenderableAttr(name) &&
             !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -4947,42 +4896,42 @@ function genAttrSegment(name, value) {
         return {
             type: RAW,
             value: isBooleanAttr(name)
-                ? " " + name + "=\"" + name + "\""
+                ? (" " + name + "=\"" + name + "\"")
                 : value === '""'
-                    ? " " + name
-                    : " " + name + "=\"" + JSON.parse(value) + "\"",
+                    ? (" " + name)
+                    : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
         };
     }
     else {
         return {
             type: EXPRESSION,
-            value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
+            value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
         };
     }
 }
 function genClassSegments(staticClass, classBinding) {
     if (staticClass && !classBinding) {
-        return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
+        return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
+                value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
             } ];
     }
 }
 function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
     if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
+        return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                    ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
-                    : 'null') + ")",
+                value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                    ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                    : 'null') + ")"),
             } ];
     }
 }
@@ -5035,8 +4984,8 @@ function walk(node, isRoot) {
             check(child);
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                var block = node.ifConditions[i].block;
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
                 walk(block, isRoot);
                 check(block);
             }
@@ -5122,7 +5071,7 @@ function generate(ast, options) {
     var state = new CodegenState(options);
     var code = ast ? genSSRElement(ast, state) : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: ("with(this){return " + code + "}"),
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -5159,9 +5108,9 @@ function genSSRElement(el, state) {
 function genNormalElement(el, state, stringifyChildren) {
     var data = el.plain ? undefined : genData(el, state);
     var children = stringifyChildren
-        ? "[" + genChildrenAsStringNode(el, state) + "]"
+        ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
         : genSSRChildren(el, state, true);
-    return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
+    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
 }
 function genSSRChildren(el, state, checkSkip) {
     return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -5171,18 +5120,18 @@ function genSSRNode(el, state) {
 }
 function genChildrenAsStringNode(el, state) {
     return el.children.length
-        ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
+        ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
         : '';
 }
 function genStringElement(el, state) {
-    return "_ssrNode(" + elementToString(el, state) + ")";
+    return ("_ssrNode(" + (elementToString(el, state)) + ")");
 }
 function genStringElementWithChildren(el, state) {
     var children = genSSRChildren(el, state, true);
-    return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
+    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
 }
 function elementToString(el, state) {
-    return "(" + flattenSegments(elementToSegments(el, state)) + ")";
+    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
 }
 function elementToSegments(el, state) {
     // v-for / v-if
@@ -5207,16 +5156,17 @@ function elementToSegments(el, state) {
     }
     var openSegments = elementToOpenTagSegments(el, state);
     var childrenSegments = childrenToSegments(el, state);
-    var isUnaryTag = state.options.isUnaryTag;
+    var ref = state.options;
+    var isUnaryTag = ref.isUnaryTag;
     var close = isUnaryTag && isUnaryTag(el.tag)
         ? []
-        : [{ type: RAW, value: "</" + el.tag + ">" }];
+        : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
     return openSegments.concat(childrenSegments, close);
 }
 function elementToOpenTagSegments(el, state) {
     applyModelTransform(el, state);
     var binding;
-    var segments = [{ type: RAW, value: "<" + el.tag }];
+    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
     // attrs
     if (el.attrs) {
         segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -5227,11 +5177,11 @@ function elementToOpenTagSegments(el, state) {
     }
     // v-bind="object"
     if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
+        segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
     }
     // v-bind.prop="object"
     if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
+        segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
     }
     // class
     if (el.staticClass || el.classBinding) {
@@ -5243,7 +5193,7 @@ function elementToOpenTagSegments(el, state) {
     }
     // _scopedId
     if (state.options.scopeId) {
-        segments.push({ type: RAW, value: " " + state.options.scopeId });
+        segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
     }
     segments.push({ type: RAW, value: ">" });
     return segments;
@@ -5251,13 +5201,13 @@ function elementToOpenTagSegments(el, state) {
 function childrenToSegments(el, state) {
     var binding;
     if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
+        return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
     }
     if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
     }
     if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
     }
     return el.children ? nodesToSegments(el.children, state) : [];
 }
@@ -5297,11 +5247,11 @@ function flattenSegments(segments) {
         }
         else if (s.type === INTERPOLATION) {
             pushBuffer();
-            mergedSegments.push("_ssrEscape(" + s.value + ")");
+            mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
         }
         else if (s.type === EXPRESSION) {
             pushBuffer();
-            mergedSegments.push("(" + s.value + ")");
+            mergedSegments.push(("(" + (s.value) + ")"));
         }
     }
     pushBuffer();
@@ -5331,22 +5281,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name_1 in node.attrsMap) {
-            if (dirRE.test(name_1)) {
-                var value = node.attrsMap[name_1];
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name_1];
-                    if (name_1 === 'v-for') {
-                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                     }
-                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
-                    else if (onRE.test(name_1)) {
-                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                     }
                     else {
-                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
                 }
             }
@@ -5366,7 +5316,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -5379,16 +5329,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function("var " + ident + "=_");
+            new Function(("var " + ident + "=_"));
         }
         catch (e) {
-            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function("return " + exp);
+        new Function(("return " + exp));
     }
     catch (e) {
         var keywordMatch = exp
@@ -5396,12 +5346,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
         }
         else {
-            warn("invalid expression: " + e.message + " in\n\n" +
-                ("    " + exp + "\n\n") +
-                ("  Raw expression: " + text.trim() + "\n"), range);
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
         }
     }
 }
@@ -5410,16 +5360,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + e.message + " in\n\n" +
-            ("    " + exp + "\n\n") +
-            ("  Raw expression: " + text.trim() + "\n"), range);
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
     }
 }
 
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if (start === void 0) { start = 0; }
-    if (end === void 0) { end = source.length; }
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -5429,18 +5380,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length_1 = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length_2 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length_2));
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length$1));
                     }
                     count += lineLength + 1;
                 }
@@ -5512,13 +5463,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                        warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
                     warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -5546,10 +5497,12 @@ function createCompileToFunctionFn(compile) {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                 warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (_a) {
-                        var err = _a.err, code = _a.code;
-                        return err.toString() + " in\n\n" + code + "\n";
-                    })
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
                         .join('\n'), vm);
             }
         }
@@ -5569,15 +5522,15 @@ function createCompilerCreator(baseCompile) {
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength_1;
+                                data.start = range.start + leadingSpaceLength;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength_1;
+                                data.end = range.end + leadingSpaceLength;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -5625,19 +5578,20 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-var _a = createCompiler(baseOptions), compileToFunctions = _a.compileToFunctions;
+var ref = createCompiler(baseOptions);
+var compileToFunctions = ref.compileToFunctions;
 
 function renderAttr(key, value) {
     if (isBooleanAttr(key)) {
         if (!isFalsyAttrValue(value)) {
-            return " " + key + "=\"" + key + "\"";
+            return (" " + key + "=\"" + key + "\"");
         }
     }
     else if (isEnumeratedAttr(key)) {
-        return " " + key + "=\"" + escape(convertEnumeratedValue(key, value)) + "\"";
+        return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"");
     }
     else if (!isFalsyAttrValue(value)) {
-        return " " + key + "=\"" + escape(String(value)) + "\"";
+        return (" " + key + "=\"" + (escape(String(value))) + "\"");
     }
     return '';
 }
@@ -5662,7 +5616,7 @@ function normalizeValue(key, value) {
     if (typeof value === 'string' ||
         (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
         value === 0) {
-        return key + ":" + value + ";";
+        return (key + ":" + value + ";");
     }
     else {
         // invalid values
@@ -5715,7 +5669,7 @@ function normalizeArrayChildren(children, nestedIndex) {
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
+                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -5783,25 +5737,22 @@ function installSSRHelpers(vm) {
         extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
     }
 }
-var StringNode = /** @class */ (function () {
-    function StringNode(open, close, children, normalizationType) {
-        this.isString = true;
-        this.open = open;
-        this.close = close;
-        if (children) {
-            this.children =
-                normalizationType === 1
-                    ? simpleNormalizeChildren(children)
-                    : normalizationType === 2
-                        ? normalizeChildren(children)
-                        : children;
-        }
-        else {
-            this.children = void 0;
-        }
+var StringNode = function StringNode(open, close, children, normalizationType) {
+    this.isString = true;
+    this.open = open;
+    this.close = close;
+    if (children) {
+        this.children =
+            normalizationType === 1
+                ? simpleNormalizeChildren(children)
+                : normalizationType === 2
+                    ? normalizeChildren(children)
+                    : children;
+    }
+    else {
+        this.children = void 0;
     }
-    return StringNode;
-}());
+};
 function renderStringNode$1(open, close, children, normalizationType) {
     return new StringNode(open, close, children, normalizationType);
 }
@@ -5849,7 +5800,7 @@ function renderDOMProps(obj) {
 }
 function renderSSRClass(staticClass, dynamic) {
     var res = renderClass$1(staticClass, dynamic);
-    return res === '' ? res : " class=\"" + escape(res) + "\"";
+    return res === '' ? res : (" class=\"" + (escape(res)) + "\"");
 }
 function renderSSRStyle(staticStyle, dynamic, extra) {
     var style = {};
@@ -5860,7 +5811,7 @@ function renderSSRStyle(staticStyle, dynamic, extra) {
     if (extra)
         { extend(style, extra); }
     var res = genStyle(style);
-    return res === '' ? res : " style=" + JSON.stringify(escape(res));
+    return res === '' ? res : (" style=" + (JSON.stringify(escape(res))));
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
@@ -5870,13 +5821,13 @@ function renderSSRStyle(staticStyle, dynamic, extra) {
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn$2("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
+            set: function set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
                     return false;
                 }
                 else {
@@ -5927,13 +5878,13 @@ function _traverse(val, seen) {
 }
 
 {
-    var perf_1 = inBrowser && window.performance;
+    var perf = inBrowser && window.performance;
     /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) ;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) ;
 }
 
 var normalizeEvent = cached(function (name) {
@@ -5976,7 +5927,7 @@ function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn$2("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
+            warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -6009,7 +5960,8 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
         return;
     }
     var res = {};
-    var attrs = data.attrs, props = data.props;
+    var attrs = data.attrs;
+    var props = data.props;
     if (isDef(attrs) || isDef(props)) {
         for (var key in propOptions) {
             var altKey = hyphenate(key);
@@ -6019,11 +5971,11 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                     tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
                         (formatComponentName(
                         // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
+                        tag || Ctor)) + ", but the declared prop name is" +
+                        " \"" + key + "\". " +
                         "Note that HTML attributes are case-insensitive and camelCased " +
                         "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
+                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -6069,7 +6021,7 @@ function createElement(context, tag, data, children, normalizationType, alwaysNo
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn$2("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -6104,7 +6056,7 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     var vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor = void 0;
+        var Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if ((!data || !data.pre) &&
             isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
@@ -6282,8 +6234,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash = void 0;
-            var _loop_1 = function (key) {
+            var hash;
+            var loop = function ( key ) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
@@ -6300,15 +6252,14 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
                     hash[key] = value[key];
                     if (isSync) {
                         var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
+                        on[("update:" + key)] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
             };
-            for (var key in value) {
-                _loop_1(key);
-            }
+
+            for (var key in value) loop( key );
         }
     }
     return data;
@@ -6328,7 +6279,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, "__static__" + index, false);
+    markStatic(tree, ("__static__" + index), false);
     return tree;
 }
 /**
@@ -6336,14 +6287,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
         for (var i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
+                markStaticNode(tree[i], (key + "_" + i), isOnce);
             }
         }
     }
@@ -6409,7 +6360,7 @@ function bindDynamicKeys(baseObj, values) {
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn$2("Invalid value for dynamic directive argument (expected string or null): " + key, this);
+            warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
         }
     }
     return baseObj;
@@ -6461,8 +6412,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
+            var name = data.slot;
+            var slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -6475,9 +6426,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
+    for (var name$1 in slots) {
+        if (slots[name$1].every(isWhitespace)) {
+            delete slots[name$1];
         }
     }
     return slots;
@@ -6510,16 +6461,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
+        for (var key$1 in slots) {
+            if (slots[key$1] && key$1[0] !== '$') {
+                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
+    for (var key$2 in normalSlots) {
+        if (!(key$2 in res)) {
+            res[key$2] = proxyNormalSlot(normalSlots, key$2);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -6723,15 +6674,15 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
+    var performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
         // if the event timestamp, although evaluated AFTER the Date.now(), is
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance_1.now(); };
+        getNow = function () { return performance.now(); };
     }
 }
 /**
@@ -6774,7 +6725,7 @@ function resolveInject(inject, vm) {
                 }
                 else {
                     // @ts-ignore
-                    warn$2("Injection \"" + key + "\" not found", vm);
+                    warn$2(("Injection \"" + key + "\" not found"), vm);
                 }
             }
         }
@@ -6820,7 +6771,8 @@ function resolveModifiedOptions(Ctor) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
+    var this$1 = this;
+
     var options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
@@ -6847,14 +6799,14 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
     this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
+        if (!this$1.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
         }
-        return _this.$slots;
+        return this$1.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function () {
+        get: function get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -6877,9 +6829,7 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) {
-            return createElement(contextVm, a, b, c, d, needNormalization);
-        };
+        this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
@@ -6935,7 +6885,7 @@ function mergeProps(to, from) {
 
 // inline hooks to be invoked on component VNodes during patch
 var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
+    init: function init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
@@ -6948,7 +6898,7 @@ var componentVNodeHooks = {
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function (oldVnode, vnode) {
+    prepatch: function prepatch(oldVnode, vnode) {
         var options = vnode.componentOptions;
         var child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
@@ -6957,8 +6907,9 @@ var componentVNodeHooks = {
         options.children // new children
         );
     },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
+    insert: function insert(vnode) {
+        var context = vnode.context;
+        var componentInstance = vnode.componentInstance;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook(componentInstance, 'mounted');
@@ -6977,7 +6928,7 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function (vnode) {
+    destroy: function destroy(vnode) {
         var componentInstance = vnode.componentInstance;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
@@ -7003,7 +6954,7 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn$2("Invalid Component definition: " + String(Ctor), context);
+            warn$2(("Invalid Component definition: " + (String(Ctor))), context);
         }
         return;
     }
@@ -7061,7 +7012,7 @@ function createComponent(Ctor, data, context, children, tag) {
     var name = Ctor.options.name || tag;
     var vnode = new VNode(
     // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
+    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
     // @ts-expect-error
     { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
     return vnode;
@@ -7131,15 +7082,18 @@ var warnOnce = function (msg) {
     if (!warned[msg]) {
         warned[msg] = true;
         // eslint-disable-next-line no-console
-        console.warn("\n\u001B[31m" + msg + "\u001B[39m\n");
+        console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
     }
 };
 var onCompilationError = function (err, vm) {
     var trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error("\n\u001B[31m" + err + trace + "\u001B[39m\n");
+    throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"));
 };
 var normalizeRender = function (vm) {
-    var _a = vm.$options, render = _a.render, template = _a.template, _scopeId = _a._scopeId;
+    var ref = vm.$options;
+    var render = ref.render;
+    var template = ref.template;
+    var _scopeId = ref._scopeId;
     if (isUndef(render)) {
         if (template) {
             var compiled = compileToFunctions(template, {
@@ -7150,7 +7104,7 @@ var normalizeRender = function (vm) {
             vm.$options.staticRenderFns = compiled.staticRenderFns;
         }
         else {
-            throw new Error("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'));
+            throw new Error(("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous')));
         }
     }
 };
@@ -7192,7 +7146,7 @@ function renderNode(node, isRoot, context) {
             renderAsyncComponent(node, isRoot, context);
         }
         else {
-            context.write("<!--" + node.text + "-->", context.next);
+            context.write(("<!--" + (node.text) + "-->"), context.next);
         }
     }
     else {
@@ -7209,7 +7163,9 @@ function registerComponentForCache(options, write) {
     return register;
 }
 function renderComponent(node, isRoot, context) {
-    var write = context.write, next = context.next, userContext = context.userContext;
+    var write = context.write;
+    var next = context.next;
+    var userContext = context.userContext;
     // check cache hit
     var Ctor = node.componentOptions.Ctor;
     var getKey = Ctor.options.serverCacheKey;
@@ -7222,12 +7178,13 @@ function renderComponent(node, isRoot, context) {
             renderComponentInner(node, isRoot, context);
             return;
         }
-        var key_1 = name + '::' + rawKey;
-        var has = context.has, get_1 = context.get;
+        var key = name + '::' + rawKey;
+        var has = context.has;
+        var get = context.get;
         if (isDef(has)) {
-            has(key_1, function (hit) {
-                if (hit === true && isDef(get_1)) {
-                    get_1(key_1, function (res) {
+            has(key, function (hit) {
+                if (hit === true && isDef(get)) {
+                    get(key, function (res) {
                         if (isDef(registerComponent)) {
                             registerComponent(userContext);
                         }
@@ -7236,12 +7193,12 @@ function renderComponent(node, isRoot, context) {
                     });
                 }
                 else {
-                    renderComponentWithCache(node, isRoot, key_1, context);
+                    renderComponentWithCache(node, isRoot, key, context);
                 }
             });
         }
-        else if (isDef(get_1)) {
-            get_1(key_1, function (res) {
+        else if (isDef(get)) {
+            get(key, function (res) {
                 if (isDef(res)) {
                     if (isDef(registerComponent)) {
                         registerComponent(userContext);
@@ -7250,7 +7207,7 @@ function renderComponent(node, isRoot, context) {
                     write(res.html, next);
                 }
                 else {
-                    renderComponentWithCache(node, isRoot, key_1, context);
+                    renderComponentWithCache(node, isRoot, key, context);
                 }
             });
         }
@@ -7307,7 +7264,10 @@ function renderAsyncComponent(node, isRoot, context) {
         if (comp.__esModule && comp.default) {
             comp = comp.default;
         }
-        var _a = node.asyncMeta, data = _a.data, children = _a.children, tag = _a.tag;
+        var ref = node.asyncMeta;
+        var data = ref.data;
+        var children = ref.children;
+        var tag = ref.tag;
         var nodeContext = node.asyncMeta.context;
         var resolvedNode = createComponent(comp, data, nodeContext, children, tag);
         if (resolvedNode) {
@@ -7362,7 +7322,8 @@ function renderAsyncComponent(node, isRoot, context) {
     }
 }
 function renderStringNode(el, context) {
-    var write = context.write, next = context.next;
+    var write = context.write;
+    var next = context.next;
     if (isUndef(el.children) || el.children.length === 0) {
         write(el.open + (el.close || ''), next);
     }
@@ -7379,7 +7340,8 @@ function renderStringNode(el, context) {
     }
 }
 function renderElement(el, isRoot, context) {
-    var write = context.write, next = context.next;
+    var write = context.write;
+    var next = context.next;
     if (isTrue(isRoot)) {
         if (!el.data)
             { el.data = {}; }
@@ -7391,7 +7353,7 @@ function renderElement(el, isRoot, context) {
         registerComponentForCache(el.fnOptions, write);
     }
     var startTag = renderStartingTag(el, context);
-    var endTag = "</" + el.tag + ">";
+    var endTag = "</" + (el.tag) + ">";
     if (context.isUnaryTag(el.tag)) {
         write(startTag, next);
     }
@@ -7430,8 +7392,9 @@ function getVShowDirectiveInfo(node) {
     return dir;
 }
 function renderStartingTag(node, context) {
-    var markup = "<" + node.tag;
-    var directives = context.directives, modules = context.modules;
+    var markup = "<" + (node.tag);
+    var directives = context.directives;
+    var modules = context.modules;
     // construct synthetic data for module processing
     // because modules like style also produce code by parent VNode data
     if (isUndef(node.data) && hasAncestorData(node)) {
@@ -7442,9 +7405,9 @@ function renderStartingTag(node, context) {
         var dirs = node.data.directives;
         if (dirs) {
             for (var i = 0; i < dirs.length; i++) {
-                var name_1 = dirs[i].name;
-                if (name_1 !== 'show') {
-                    var dirRenderer = resolveAsset(context, 'directives', name_1);
+                var name = dirs[i].name;
+                if (name !== 'show') {
+                    var dirRenderer = resolveAsset(context, 'directives', name);
                     if (dirRenderer) {
                         // directives mutate the node's data
                         // which then gets rendered by modules
@@ -7459,8 +7422,8 @@ function renderStartingTag(node, context) {
             directives.show(node, vshowDirectiveInfo);
         }
         // apply other modules
-        for (var i = 0; i < modules.length; i++) {
-            var res = modules[i](node);
+        for (var i$1 = 0; i$1 < modules.length; i$1++) {
+            var res = modules[i$1](node);
             if (res) {
                 markup += res;
             }
@@ -7475,7 +7438,7 @@ function renderStartingTag(node, context) {
         markup += " " + scopeId;
     }
     if (isDef(node.fnScopeId)) {
-        markup += " " + node.fnScopeId;
+        markup += " " + (node.fnScopeId);
     }
     else {
         while (isDef(node)) {
@@ -7527,18 +7490,20 @@ function createPromiseCallback() {
     return { promise: promise, cb: cb };
 }
 
-var TemplateStream = /** @class */ (function (_super) {
-    __extends(TemplateStream, _super);
+var TemplateStream = /*@__PURE__*/(function (Transform) {
     function TemplateStream(renderer, template, context) {
-        var _this = _super.call(this) || this;
-        _this.started = false;
-        _this.renderer = renderer;
-        _this.template = template;
-        _this.context = context || {};
-        _this.inject = renderer.inject;
-        return _this;
-    }
-    TemplateStream.prototype._transform = function (data, encoding, done) {
+        Transform.call(this);
+        this.started = false;
+        this.renderer = renderer;
+        this.template = template;
+        this.context = context || {};
+        this.inject = renderer.inject;
+    }
+
+    if ( Transform ) TemplateStream.__proto__ = Transform;
+    TemplateStream.prototype = Object.create( Transform && Transform.prototype );
+    TemplateStream.prototype.constructor = TemplateStream;
+    TemplateStream.prototype._transform = function _transform (data, encoding, done) {
         if (!this.started) {
             this.emit('beforeStart');
             this.start();
@@ -7546,7 +7511,7 @@ var TemplateStream = /** @class */ (function (_super) {
         this.push(data);
         done();
     };
-    TemplateStream.prototype.start = function () {
+    TemplateStream.prototype.start = function start () {
         this.started = true;
         this.push(this.template.head(this.context));
         if (this.inject) {
@@ -7567,7 +7532,7 @@ var TemplateStream = /** @class */ (function (_super) {
         }
         this.push(this.template.neck(this.context));
     };
-    TemplateStream.prototype._flush = function (done) {
+    TemplateStream.prototype._flush = function _flush (done) {
         this.emit('beforeEnd');
         if (this.inject) {
             // inline initial store state
@@ -7584,6 +7549,7 @@ var TemplateStream = /** @class */ (function (_super) {
         this.push(this.template.tail(this.context));
         done();
     };
+
     return TemplateStream;
 }(stream.Transform));
 
@@ -7593,7 +7559,8 @@ var compileOptions = {
     interpolate: /{{{([\s\S]+?)}}}/g,
 };
 function parseTemplate(template, contentPlaceholder) {
-    if (contentPlaceholder === void 0) { contentPlaceholder = '<!--vue-ssr-outlet-->'; }
+    if ( contentPlaceholder === void 0 ) contentPlaceholder = '<!--vue-ssr-outlet-->';
+
     if (typeof template === 'object') {
         return template;
     }
@@ -7662,213 +7629,228 @@ function mapIdToFile(id, clientManifest) {
 
 var path$2 = require('path');
 var serialize = require('serialize-javascript');
-var TemplateRenderer = /** @class */ (function () {
-    function TemplateRenderer(options) {
-        this.options = options;
-        this.inject = options.inject !== false;
-        // if no template option is provided, the renderer is created
-        // as a utility object for rendering assets like preload links and scripts.
-        var template = options.template;
-        this.parsedTemplate = template
-            ? typeof template === 'string'
-                ? parseTemplate(template)
-                : template
-            : null;
-        // function used to serialize initial state JSON
-        this.serialize =
-            options.serializer ||
-                (function (state) {
-                    return serialize(state, { isJSON: true });
-                });
-        // extra functionality with client manifest
-        if (options.clientManifest) {
-            var clientManifest = (this.clientManifest = options.clientManifest);
-            // ensure publicPath ends with /
-            this.publicPath =
-                clientManifest.publicPath === ''
-                    ? ''
-                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-            // preload/prefetch directives
-            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-            // initial async chunk mapping
-            this.mapFiles = createMapper(clientManifest);
-        }
-    }
-    TemplateRenderer.prototype.bindRenderFns = function (context) {
-        var renderer = this;
-        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
-            context["render" + type] = renderer["render" + type].bind(renderer, context);
-        });
-        // also expose getPreloadFiles, useful for HTTP/2 push
-        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
-    };
-    // render synchronously given rendered app content and render context
-    TemplateRenderer.prototype.render = function (content, context) {
-        var template = this.parsedTemplate;
-        if (!template) {
-            throw new Error('render cannot be called without a template.');
-        }
-        context = context || {};
-        if (typeof template === 'function') {
-            return template(content, context);
-        }
-        if (this.inject) {
-            return (template.head(context) +
-                (context.head || '') +
-                this.renderResourceHints(context) +
-                this.renderStyles(context) +
-                template.neck(context) +
-                content +
-                this.renderState(context) +
-                this.renderScripts(context) +
-                template.tail(context));
-        }
-        else {
-            return (template.head(context) +
-                template.neck(context) +
-                content +
-                template.tail(context));
-        }
-    };
-    TemplateRenderer.prototype.renderStyles = function (context) {
-        var _this = this;
-        var initial = this.preloadFiles || [];
-        var async = this.getUsedAsyncFiles(context) || [];
-        var cssFiles = initial.concat(async).filter(function (_a) {
-            var file = _a.file;
+var TemplateRenderer = function TemplateRenderer(options) {
+    this.options = options;
+    this.inject = options.inject !== false;
+    // if no template option is provided, the renderer is created
+    // as a utility object for rendering assets like preload links and scripts.
+    var template = options.template;
+    this.parsedTemplate = template
+        ? typeof template === 'string'
+            ? parseTemplate(template)
+            : template
+        : null;
+    // function used to serialize initial state JSON
+    this.serialize =
+        options.serializer ||
+            (function (state) {
+                return serialize(state, { isJSON: true });
+            });
+    // extra functionality with client manifest
+    if (options.clientManifest) {
+        var clientManifest = (this.clientManifest = options.clientManifest);
+        // ensure publicPath ends with /
+        this.publicPath =
+            clientManifest.publicPath === ''
+                ? ''
+                : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
+        // preload/prefetch directives
+        this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
+        this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
+        // initial async chunk mapping
+        this.mapFiles = createMapper(clientManifest);
+    }
+};
+TemplateRenderer.prototype.bindRenderFns = function bindRenderFns (context) {
+    var renderer = this;
+    ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
+        context[("render" + type)] = renderer[("render" + type)].bind(renderer, context);
+    });
+    // also expose getPreloadFiles, useful for HTTP/2 push
+    context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
+};
+// render synchronously given rendered app content and render context
+TemplateRenderer.prototype.render = function render (content, context) {
+    var template = this.parsedTemplate;
+    if (!template) {
+        throw new Error('render cannot be called without a template.');
+    }
+    context = context || {};
+    if (typeof template === 'function') {
+        return template(content, context);
+    }
+    if (this.inject) {
+        return (template.head(context) +
+            (context.head || '') +
+            this.renderResourceHints(context) +
+            this.renderStyles(context) +
+            template.neck(context) +
+            content +
+            this.renderState(context) +
+            this.renderScripts(context) +
+            template.tail(context));
+    }
+    else {
+        return (template.head(context) +
+            template.neck(context) +
+            content +
+            template.tail(context));
+    }
+};
+TemplateRenderer.prototype.renderStyles = function renderStyles (context) {
+        var this$1 = this;
+
+    var initial = this.preloadFiles || [];
+    var async = this.getUsedAsyncFiles(context) || [];
+    var cssFiles = initial.concat(async).filter(function (ref) {
+            var file = ref.file;
+
             return isCSS(file);
         });
-        return (
-        // render links for css files
-        (cssFiles.length
-            ? cssFiles
-                .map(function (_a) {
-                var file = _a.file;
-                return "<link rel=\"stylesheet\" href=\"" + _this.publicPath + file + "\">";
-            })
-                .join('')
-            : '') +
-            // context.styles is a getter exposed by vue-style-loader which contains
-            // the inline component styles collected during SSR
-            (context.styles || ''));
-    };
-    TemplateRenderer.prototype.renderResourceHints = function (context) {
-        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
-    };
-    TemplateRenderer.prototype.getPreloadFiles = function (context) {
+    return (
+    // render links for css files
+    (cssFiles.length
+        ? cssFiles
+            .map(function (ref) {
+                    var file = ref.file;
+
+                    return ("<link rel=\"stylesheet\" href=\"" + (this$1.publicPath) + file + "\">");
+        })
+            .join('')
+        : '') +
+        // context.styles is a getter exposed by vue-style-loader which contains
+        // the inline component styles collected during SSR
+        (context.styles || ''));
+};
+TemplateRenderer.prototype.renderResourceHints = function renderResourceHints (context) {
+    return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
+};
+TemplateRenderer.prototype.getPreloadFiles = function getPreloadFiles (context) {
+    var usedAsyncFiles = this.getUsedAsyncFiles(context);
+    if (this.preloadFiles || usedAsyncFiles) {
+        return (this.preloadFiles || []).concat(usedAsyncFiles || []);
+    }
+    else {
+        return [];
+    }
+};
+TemplateRenderer.prototype.renderPreloadLinks = function renderPreloadLinks (context) {
+        var this$1 = this;
+
+    var files = this.getPreloadFiles(context);
+    var shouldPreload = this.options.shouldPreload;
+    if (files.length) {
+        return files
+            .map(function (ref) {
+                var file = ref.file;
+                var extension = ref.extension;
+                var fileWithoutQuery = ref.fileWithoutQuery;
+                var asType = ref.asType;
+
+            var extra = '';
+            // by default, we only preload scripts or css
+            if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+                return '';
+            }
+            // user wants to explicitly control what to preload
+            if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+                return '';
+            }
+            if (asType === 'font') {
+                extra = " type=\"font/" + extension + "\" crossorigin";
+            }
+            return ("<link rel=\"preload\" href=\"" + (this$1.publicPath) + file + "\"" + (asType !== '' ? (" as=\"" + asType + "\"") : '') + extra + ">");
+        })
+            .join('');
+    }
+    else {
+        return '';
+    }
+};
+TemplateRenderer.prototype.renderPrefetchLinks = function renderPrefetchLinks (context) {
+        var this$1 = this;
+
+    var shouldPrefetch = this.options.shouldPrefetch;
+    if (this.prefetchFiles) {
         var usedAsyncFiles = this.getUsedAsyncFiles(context);
-        if (this.preloadFiles || usedAsyncFiles) {
-            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
-        }
-        else {
-            return [];
-        }
-    };
-    TemplateRenderer.prototype.renderPreloadLinks = function (context) {
-        var _this = this;
-        var files = this.getPreloadFiles(context);
-        var shouldPreload = this.options.shouldPreload;
-        if (files.length) {
-            return files
-                .map(function (_a) {
-                var file = _a.file, extension = _a.extension, fileWithoutQuery = _a.fileWithoutQuery, asType = _a.asType;
-                var extra = '';
-                // by default, we only preload scripts or css
-                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-                    return '';
-                }
-                // user wants to explicitly control what to preload
-                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (asType === 'font') {
-                    extra = " type=\"font/" + extension + "\" crossorigin";
-                }
-                return "<link rel=\"preload\" href=\"" + _this.publicPath + file + "\"" + (asType !== '' ? " as=\"" + asType + "\"" : '') + extra + ">";
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    };
-    TemplateRenderer.prototype.renderPrefetchLinks = function (context) {
-        var _this = this;
-        var shouldPrefetch = this.options.shouldPrefetch;
-        if (this.prefetchFiles) {
-            var usedAsyncFiles_1 = this.getUsedAsyncFiles(context);
-            var alreadyRendered_1 = function (file) {
-                return usedAsyncFiles_1 && usedAsyncFiles_1.some(function (f) { return f.file === file; });
-            };
-            return this.prefetchFiles
-                .map(function (_a) {
-                var file = _a.file, fileWithoutQuery = _a.fileWithoutQuery, asType = _a.asType;
-                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (alreadyRendered_1(file)) {
-                    return '';
-                }
-                return "<link rel=\"prefetch\" href=\"" + _this.publicPath + file + "\">";
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    };
-    TemplateRenderer.prototype.renderState = function (context, options) {
-        var _a = options || {}, _b = _a.contextKey, contextKey = _b === void 0 ? 'state' : _b, _c = _a.windowKey, windowKey = _c === void 0 ? '__INITIAL_STATE__' : _c;
-        var state = this.serialize(context[contextKey]);
-        var autoRemove = '';
-        var nonceAttr = context.nonce ? " nonce=\"" + context.nonce + "\"" : '';
-        return context[contextKey]
-            ? "<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>"
-            : '';
-    };
-    TemplateRenderer.prototype.renderScripts = function (context) {
-        var _this = this;
-        if (this.clientManifest) {
-            var initial = this.preloadFiles.filter(function (_a) {
-                var file = _a.file;
+        var alreadyRendered = function (file) {
+            return usedAsyncFiles && usedAsyncFiles.some(function (f) { return f.file === file; });
+        };
+        return this.prefetchFiles
+            .map(function (ref) {
+                var file = ref.file;
+                var fileWithoutQuery = ref.fileWithoutQuery;
+                var asType = ref.asType;
+
+            if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+                return '';
+            }
+            if (alreadyRendered(file)) {
+                return '';
+            }
+            return ("<link rel=\"prefetch\" href=\"" + (this$1.publicPath) + file + "\">");
+        })
+            .join('');
+    }
+    else {
+        return '';
+    }
+};
+TemplateRenderer.prototype.renderState = function renderState (context, options) {
+    var ref = options || {};
+        var contextKey = ref.contextKey; if ( contextKey === void 0 ) contextKey = 'state';
+        var windowKey = ref.windowKey; if ( windowKey === void 0 ) windowKey = '__INITIAL_STATE__';
+    var state = this.serialize(context[contextKey]);
+    var autoRemove = '';
+    var nonceAttr = context.nonce ? (" nonce=\"" + (context.nonce) + "\"") : '';
+    return context[contextKey]
+        ? ("<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>")
+        : '';
+};
+TemplateRenderer.prototype.renderScripts = function renderScripts (context) {
+        var this$1 = this;
+
+    if (this.clientManifest) {
+        var initial = this.preloadFiles.filter(function (ref) {
+                var file = ref.file;
+
                 return isJS(file);
             });
-            var async = (this.getUsedAsyncFiles(context) || []).filter(function (_a) {
-                var file = _a.file;
+        var async = (this.getUsedAsyncFiles(context) || []).filter(function (ref) {
+                var file = ref.file;
+
                 return isJS(file);
             });
-            var needed = [initial[0]].concat(async, initial.slice(1));
-            return needed
-                .map(function (_a) {
-                var file = _a.file;
-                return "<script src=\"" + _this.publicPath + file + "\" defer></script>";
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    };
-    TemplateRenderer.prototype.getUsedAsyncFiles = function (context) {
-        if (!context._mappedFiles &&
-            context._registeredComponents &&
-            this.mapFiles) {
-            var registered = Array.from(context._registeredComponents);
-            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-        }
-        return context._mappedFiles;
-    };
-    // create a transform stream
-    TemplateRenderer.prototype.createStream = function (context) {
-        if (!this.parsedTemplate) {
-            throw new Error('createStream cannot be called without a template.');
-        }
-        //@ts-expect-error
-        return new TemplateStream(this, this.parsedTemplate, context || {});
-    };
-    return TemplateRenderer;
-}());
+        var needed = [initial[0]].concat(async, initial.slice(1));
+        return needed
+            .map(function (ref) {
+                var file = ref.file;
+
+            return ("<script src=\"" + (this$1.publicPath) + file + "\" defer></script>");
+        })
+            .join('');
+    }
+    else {
+        return '';
+    }
+};
+TemplateRenderer.prototype.getUsedAsyncFiles = function getUsedAsyncFiles (context) {
+    if (!context._mappedFiles &&
+        context._registeredComponents &&
+        this.mapFiles) {
+        var registered = Array.from(context._registeredComponents);
+        context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
+    }
+    return context._mappedFiles;
+};
+// create a transform stream
+TemplateRenderer.prototype.createStream = function createStream (context) {
+    if (!this.parsedTemplate) {
+        throw new Error('createStream cannot be called without a template.');
+    }
+    //@ts-expect-error
+    return new TemplateStream(this, this.parsedTemplate, context || {});
+};
 function normalizeFile(file) {
     var withoutQuery = file.replace(/\?.*/, '');
     var extension = path$2.extname(withoutQuery).slice(1);
@@ -7898,8 +7880,19 @@ function getPreloadType(ext) {
     }
 }
 
-function createRenderer$1(_a) {
-    var _b = _a === void 0 ? {} : _a, _c = _b.modules, modules = _c === void 0 ? [] : _c, _d = _b.directives, directives = _d === void 0 ? {} : _d, _e = _b.isUnaryTag, isUnaryTag = _e === void 0 ? function () { return false; } : _e, template = _b.template, inject = _b.inject, cache = _b.cache, shouldPreload = _b.shouldPreload, shouldPrefetch = _b.shouldPrefetch, clientManifest = _b.clientManifest, serializer = _b.serializer;
+function createRenderer$1(ref) {
+    if ( ref === void 0 ) ref = {};
+    var modules = ref.modules; if ( modules === void 0 ) modules = [];
+    var directives = ref.directives; if ( directives === void 0 ) directives = {};
+    var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = function () { return false; };
+    var template = ref.template;
+    var inject = ref.inject;
+    var cache = ref.cache;
+    var shouldPreload = ref.shouldPreload;
+    var shouldPrefetch = ref.shouldPrefetch;
+    var clientManifest = ref.clientManifest;
+    var serializer = ref.serializer;
+
     var render = createRenderFunction(modules, directives, isUnaryTag, cache);
     var templateRenderer = new TemplateRenderer({
         template: template,
@@ -7912,8 +7905,9 @@ function createRenderer$1(_a) {
         serializer: serializer,
     });
     return {
-        renderToString: function (component, context, cb) {
-            var _a;
+        renderToString: function renderToString(component, context, cb) {
+            var assign;
+
             if (typeof context === 'function') {
                 cb = context;
                 context = {};
@@ -7924,7 +7918,7 @@ function createRenderer$1(_a) {
             // no callback, return Promise
             var promise;
             if (!cb) {
-                (_a = createPromiseCallback(), promise = _a.promise, cb = _a.cb);
+                ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
             }
             var result = '';
             var write = createWriteFunction(function (text) {
@@ -7965,7 +7959,7 @@ function createRenderer$1(_a) {
             }
             return promise;
         },
-        renderToStream: function (component, context) {
+        renderToStream: function renderToStream(component, context) {
             if (context) {
                 templateRenderer.bindRenderFns(context);
             }
@@ -7977,9 +7971,9 @@ function createRenderer$1(_a) {
                 // @ts-expect-error
                 if (context && context.rendered) {
                     // @ts-expect-error
-                    var rendered_1 = context.rendered;
+                    var rendered = context.rendered;
                     renderStream.once('beforeEnd', function () {
-                        rendered_1(context);
+                        rendered(context);
                     });
                 }
                 return renderStream;
@@ -7988,20 +7982,20 @@ function createRenderer$1(_a) {
                 throw new Error("function template is only supported in renderToString.");
             }
             else {
-                var templateStream_1 = templateRenderer.createStream(context);
+                var templateStream = templateRenderer.createStream(context);
                 renderStream.on('error', function (err) {
-                    templateStream_1.emit('error', err);
+                    templateStream.emit('error', err);
                 });
-                renderStream.pipe(templateStream_1);
+                renderStream.pipe(templateStream);
                 //@ts-expect-error
                 if (context && context.rendered) {
                     //@ts-expect-error
-                    var rendered_2 = context.rendered;
+                    var rendered$1 = context.rendered;
                     renderStream.once('beforeEnd', function () {
-                        rendered_2(context);
+                        rendered$1(context);
                     });
                 }
-                return templateStream_1;
+                return templateStream;
             }
         },
     };
@@ -8045,7 +8039,8 @@ function compileModule(files, basedir, runInNewContext) {
         return script;
     }
     function evaluateModule(filename, sandbox, evaluatedFiles) {
-        if (evaluatedFiles === void 0) { evaluatedFiles = {}; }
+        if ( evaluatedFiles === void 0 ) evaluatedFiles = {};
+
         if (evaluatedFiles[filename]) {
             return evaluatedFiles[filename];
         }
@@ -8099,13 +8094,14 @@ function createBundleRunner(entry, files, basedir, runInNewContext) {
         // on each render. Ensures entire application state is fresh for each
         // render, but incurs extra evaluation cost.
         return function (userContext) {
-            if (userContext === void 0) { userContext = {}; }
+            if ( userContext === void 0 ) userContext = {};
+
             return new Promise(function (resolve) {
-                // @ts-expect-error
-                userContext._registeredComponents = new Set();
-                var res = evaluate(entry, createSandbox(userContext));
-                resolve(typeof res === 'function' ? res(userContext) : res);
-            });
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            var res = evaluate(entry, createSandbox(userContext));
+            resolve(typeof res === 'function' ? res(userContext) : res);
+        });
         };
     }
     else {
@@ -8113,49 +8109,50 @@ function createBundleRunner(entry, files, basedir, runInNewContext) {
         // each render, it simply calls the exported function. This avoids the
         // module evaluation costs but requires the source code to be structured
         // slightly differently.
-        var runner_1; // lazy creation so that errors can be caught by user
-        var initialContext_1;
+        var runner; // lazy creation so that errors can be caught by user
+        var initialContext;
         return function (userContext) {
-            if (userContext === void 0) { userContext = {}; }
+            if ( userContext === void 0 ) userContext = {};
+
             return new Promise(function (resolve) {
-                if (!runner_1) {
-                    var sandbox = runInNewContext === 'once' ? createSandbox() : global;
-                    // the initial context is only used for collecting possible non-component
-                    // styles injected by vue-style-loader.
-                    // @ts-expect-error
-                    initialContext_1 = sandbox.__VUE_SSR_CONTEXT__ = {};
-                    runner_1 = evaluate(entry, sandbox);
-                    // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-                    // to prevent cross-request pollution.
-                    // @ts-expect-error
-                    delete sandbox.__VUE_SSR_CONTEXT__;
-                    if (typeof runner_1 !== 'function') {
-                        throw new Error('bundle export should be a function when using ' +
-                            '{ runInNewContext: false }.');
-                    }
+            if (!runner) {
+                var sandbox = runInNewContext === 'once' ? createSandbox() : global;
+                // the initial context is only used for collecting possible non-component
+                // styles injected by vue-style-loader.
+                // @ts-expect-error
+                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
+                runner = evaluate(entry, sandbox);
+                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+                // to prevent cross-request pollution.
+                // @ts-expect-error
+                delete sandbox.__VUE_SSR_CONTEXT__;
+                if (typeof runner !== 'function') {
+                    throw new Error('bundle export should be a function when using ' +
+                        '{ runInNewContext: false }.');
                 }
+            }
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            // vue-style-loader styles imported outside of component lifecycle hooks
+            if (initialContext._styles) {
                 // @ts-expect-error
-                userContext._registeredComponents = new Set();
-                // vue-style-loader styles imported outside of component lifecycle hooks
-                if (initialContext_1._styles) {
-                    // @ts-expect-error
-                    userContext._styles = deepClone(initialContext_1._styles);
-                    // #6353 ensure "styles" is exposed even if no styles are injected
-                    // in component lifecycles.
-                    // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-                    var renderStyles_1 = initialContext_1._renderStyles;
-                    if (renderStyles_1) {
-                        Object.defineProperty(userContext, 'styles', {
-                            enumerable: true,
-                            get: function () {
-                                // @ts-expect-error
-                                return renderStyles_1(userContext._styles);
-                            },
-                        });
-                    }
+                userContext._styles = deepClone(initialContext._styles);
+                // #6353 ensure "styles" is exposed even if no styles are injected
+                // in component lifecycles.
+                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+                var renderStyles = initialContext._renderStyles;
+                if (renderStyles) {
+                    Object.defineProperty(userContext, 'styles', {
+                        enumerable: true,
+                        get: function get() {
+                            // @ts-expect-error
+                            return renderStyles(userContext._styles);
+                        },
+                    });
                 }
-                resolve(runner_1(userContext));
-            });
+            }
+            resolve(runner(userContext));
+        });
         };
     }
 }
@@ -8188,8 +8185,10 @@ function rewriteTraceLine(trace, mapConsumers) {
             column: Number(m[3]),
         });
         if (originalPosition.source != null) {
-            var source = originalPosition.source, line = originalPosition.line, column = originalPosition.column;
-            var mappedPosition = "(" + source.replace(/^webpack:\/\/\//, '') + ":" + String(line) + ":" + String(column) + ")";
+            var source = originalPosition.source;
+            var line = originalPosition.line;
+            var column = originalPosition.column;
+            var mappedPosition = "(" + (source.replace(/^webpack:\/\/\//, '')) + ":" + (String(line)) + ":" + (String(column)) + ")";
             return trace.replace(filenameRE, mappedPosition);
         }
         else {
@@ -8209,7 +8208,8 @@ var INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string '
     "{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";
 function createBundleRendererCreator(createRenderer) {
     return function createBundleRenderer(bundle, rendererOptions) {
-        if (rendererOptions === void 0) { rendererOptions = {}; }
+        if ( rendererOptions === void 0 ) rendererOptions = {};
+
         var files, entry, maps;
         var basedir = rendererOptions.basedir;
         // load bundle if given filepath
@@ -8226,12 +8226,12 @@ function createBundleRendererCreator(createRenderer) {
                         bundle = JSON.parse(bundle);
                     }
                     catch (e) {
-                        throw new Error("Invalid JSON bundle file: " + bundle);
+                        throw new Error(("Invalid JSON bundle file: " + bundle));
                     }
                 }
             }
             else {
-                throw new Error("Cannot locate bundle file: " + bundle);
+                throw new Error(("Cannot locate bundle file: " + bundle));
             }
         }
         if (typeof bundle === 'object') {
@@ -8255,14 +8255,15 @@ function createBundleRendererCreator(createRenderer) {
         var run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
         return {
             renderToString: function (context, cb) {
-                var _a;
+                var assign;
+
                 if (typeof context === 'function') {
                     cb = context;
                     context = {};
                 }
                 var promise;
                 if (!cb) {
-                    (_a = createPromiseCallback(), promise = _a.promise, cb = _a.cb);
+                    ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
                 }
                 run(context)
                     .catch(function (err) {
@@ -8319,7 +8320,8 @@ function createBundleRendererCreator(createRenderer) {
 
 process.env.VUE_ENV = 'server';
 function createRenderer(options) {
-    if (options === void 0) { options = {}; }
+    if ( options === void 0 ) options = {};
+
     return createRenderer$1(extend(extend({}, options), {
         isUnaryTag: isUnaryTag$1,
         canBeLeftOpenTag: canBeLeftOpenTag$1,
diff --git a/packages/vue-server-renderer/build.prod.js b/packages/vue-server-renderer/build.prod.js
index 9bdc3dffad7..98b52fcee2a 100644
--- a/packages/vue-server-renderer/build.prod.js
+++ b/packages/vue-server-renderer/build.prod.js
@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream");function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var r=t(require("he")),n=Object.freeze({});function i(e){return null==e}function o(e){return null!=e}function a(e){return!0===e}function s(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function c(e){return null!==e&&"object"==typeof e}var u=Object.prototype.toString;function l(e){return"[object Object]"===u.call(e)}function f(e){return null==e?"":Array.isArray(e)||l(e)&&e.toString===u?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var b=/-(\w)/g,_=g(function(e){return e.replace(b,function(e,t){return t?t.toUpperCase():""})}),w=g(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),x=/\B([A-Z])/g,S=g(function(e){return e.replace(x,"-$1").toLowerCase()});function $(e,t){for(var r in t)e[r]=t[r];return e}function k(e){for(var t={},r=0;r<e.length;r++)e[r]&&$(t,e[r]);return t}function A(e,t,r){}var O=function(e,t,r){return!1},C=function(e){return e};function T(e,t){if(e===t)return!0;var r=c(e),n=c(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return T(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),s=Object.keys(t);return a.length===s.length&&a.every(function(r){return T(e[r],t[r])})}catch(e){return!1}}function F(e,t){for(var r=0;r<e.length;r++)if(T(e[r],t))return r;return-1}var j=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),P=function(e){return j(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},E={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},N={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function I(e){return e.replace(/[<>"&]/g,L)}function L(e){return N[e]||e}var M={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},R=d("input,textarea,option,select,progress"),D=d("contenteditable,draggable,spellcheck"),z=d("events,caret,typing,plaintext-only"),U=function(e,t){return B(t)||"false"===t?"false":"contenteditable"===e&&z(t)?t:"true"},q=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),B=function(e){return null==e||!1===e},J=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),H=/[>/="'\u0009\u000a\u000c\u0020]/,K=function(e){return H.test(e)},V=function(e){return J(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},W={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},Z={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function X(e){return e.replace(/[<>"&]/g,G)}function G(e){return Z[e]||e}var Q={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0};function Y(e,t){if(q(e)){if(!B(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+I(U(e,t))+'"';if(!B(t))return" "+e+'="'+I(String(t))+'"'}return""}var ee=function(){function e(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}return Object.defineProperty(e.prototype,"child",{get:function(){return this.componentInstance},enumerable:!1,configurable:!0}),e}(),te=function(e){void 0===e&&(e="");var t=new ee;return t.text=e,t.isComment=!0,t};function re(e){return new ee(void 0,void 0,void 0,String(e))}function ne(e,t,r){var n=new ee(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ie(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var oe="__proto__"in{},ae="undefined"!=typeof window,se="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,ce=(se&&WXEnvironment.platform.toLowerCase(),ae&&window.navigator.userAgent.toLowerCase()),ue=ce&&/msie|trident/.test(ce);ce&&ce.indexOf("msie 9.0");ce&&ce.indexOf("edge/");ce&&ce.indexOf("android"),ce&&/iphone|ipad|ipod|ios/.test(ce),ce&&/chrome\/\d+/.test(ce),ce&&/phantomjs/.test(ce),ce&&ce.match(/firefox\/(\d+)/);var le,fe={}.watch;if(ae)try{var pe={};Object.defineProperty(pe,"passive",{get:function(){!0}}),window.addEventListener("test-passive",null,pe)}catch(e){}var de=function(){return void 0===le&&(le=!ae&&!se&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),le};function ve(e){return"function"==typeof e&&/native code/.test(e.toString())}var he,me="undefined"!=typeof Symbol&&ve(Symbol)&&"undefined"!=typeof Reflect&&ve(Reflect.ownKeys);he="undefined"!=typeof Set&&ve(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ye="data-server-rendered",ge=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],be={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:O,isReservedAttr:O,isUnknownElement:O,getTagNamespace:A,parsePlatformTagName:C,mustUseProp:O,async:!0,_lifecycleHooks:ge},_e=0,we=function(){function e(){this.id=_e++,this.subs=[]}return e.prototype.addSub=function(e){this.subs.push(e)},e.prototype.removeSub=function(e){!function(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)e.splice(r,1)}}(this.subs,e)},e.prototype.depend=function(){e.target&&e.target.addDep(this)},e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},e}();we.target=null;var xe=[];function Se(e){xe.push(e),we.target=e}function $e(){xe.pop(),we.target=xe[xe.length-1]}var ke=Array.prototype,Ae=Object.create(ke);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=ke[e];ie(Ae,e,function(){for(var r=arguments,n=[],i=0;i<arguments.length;i++)n[i]=r[i];var o,a=t.apply(this,n),s=this.__ob__;switch(e){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&s.observeArray(o),s.dep.notify(),a})});var Oe=Object.getOwnPropertyNames(Ae),Ce=!0;function Te(e){Ce=e}var Fe=function(){function e(e){var t;this.value=e,this.dep=new we,this.vmCount=0,ie(e,"__ob__",this),Array.isArray(e)?(oe?(t=Ae,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ie(e,o,t[o])}}(e,Ae,Oe),this.observeArray(e)):this.walk(e)}return e.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Pe(e,t[r])},e.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)je(e[t])},e}();function je(e,t){var r;if(c(e)&&!(e instanceof ee))return y(e,"__ob__")&&e.__ob__ instanceof Fe?r=e.__ob__:Ce&&!de()&&(Array.isArray(e)||l(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Fe(e)),t&&r&&r.vmCount++,r}function Pe(e,t,r,n,i){var o=new we,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&je(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return we.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&je(t),o.notify())}})}}function Ee(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Pe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}var Ne=be.optionMergeStrategies;function Ie(e,t){if(!t)return e;for(var r,n,i,o=me?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],y(e,r)?n!==i&&l(n)&&l(i)&&Ie(n,i):Ee(e,r,i));return e}function Le(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ie(n,i):i}:t?e?function(){return Ie("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Me(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Re(e,t,r,n){var i=Object.create(e||null);return t?$(i,t):i}Ne.data=function(e,t,r){return r?Le(e,t,r):t&&"function"!=typeof t?e:Le(e,t)},ge.forEach(function(e){Ne[e]=Me}),["component","directive","filter"].forEach(function(e){Ne[e+"s"]=Re}),Ne.watch=function(e,t,r,n){if(e===fe&&(e=void 0),t===fe&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in $(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ne.props=Ne.methods=Ne.inject=Ne.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return $(i,e),t&&$(i,t),i},Ne.provide=Le;var De=function(e,t){return void 0===t?e:t};function ze(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[_(i)]={type:null});else if(l(r))for(var a in r)i=r[a],o[_(a)]=l(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(l(r))for(var o in r){var a=r[o];n[o]=l(a)?$({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=ze(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=ze(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)y(e,o)||s(o);function s(n){var i=Ne[n]||De;a[n]=i(e[n],t[n],r,n)}return a}function Ue(e,t,r,n){if("string"==typeof r){var i=e[t];if(y(i,r))return i[r];var o=_(r);if(y(i,o))return i[o];var a=w(o);return y(i,a)?i[a]:i[r]||i[o]||i[a]}}function qe(e,t,r,n){var i=t[e],o=!y(r,e),a=r[e],s=Ke(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===S(e)){var c=Ke(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!y(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Je(t.type)?n.call(e):n}(n,i,e);var u=Ce;Te(!0),je(a),Te(u)}return a}var Be=/^\s*function (\w+)/;function Je(e){var t=e&&e.toString().match(Be);return t?t[1]:""}function He(e,t){return Je(e)===Je(t)}function Ke(e,t){if(!Array.isArray(t))return He(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(He(t[r],e))return r;return-1}function Ve(e,t,r){Se();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){Ze(e,n,"errorCaptured hook")}}Ze(e,t,r)}finally{$e()}}function We(e,t,r,n,i){var a,s;try{(a=r?e.apply(t,r):e.call(t))&&!a._isVue&&(o(s=a)&&"function"==typeof s.then&&"function"==typeof s.catch)&&!a._handled&&(a.catch(function(e){return Ve(e,n,i+" (Promise/async)")}),a._handled=!0)}catch(e){Ve(e,n,i)}return a}function Ze(e,t,r){!function(e,t,r){if(!ae&&!se||"undefined"==typeof console)throw e;console.error(e)}(e)}var Xe=[];if("undefined"!=typeof Promise&&ve(Promise));else if(ue||"undefined"==typeof MutationObserver||!ve(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&ve(setImmediate);else{var Ge=new MutationObserver(function(){var e=Xe.slice(0);Xe.length=0;for(var t=0;t<e.length;t++)e[t]()}),Qe=document.createTextNode(String(1));Ge.observe(Qe,{characterData:!0})}function Ye(e,t){return{staticClass:tt(e.staticClass,t.staticClass),class:o(e.class)?[e.class,t.class]:t.class}}function et(e,t){return o(e)||o(t)?tt(e,rt(t)):""}function tt(e,t){return e?t?e+" "+t:e:t||""}function rt(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,i=e.length;n<i;n++)o(t=rt(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):c(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var nt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),it=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var ot=g(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function at(e){var t=st(e.style);return e.staticStyle?$(e.staticStyle,t):t}function st(e){return Array.isArray(e)?k(e):"string"==typeof e?ot(e):e}function ct(e,t){return"string"==typeof t||"number"==typeof t&&M[e]||0===t?e+":"+t+";":""}var ut=[function(e){var t=e.data.attrs,r="",n=e.parent&&e.parent.componentOptions;if(i(n)||!1!==n.Ctor.options.inheritAttrs)for(var a=e.parent;o(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)o(a.data)&&o(a.data.attrs)&&(t=$($({},t),a.data.attrs)),a=a.parent;if(i(t))return r;for(var s in t)K(s)||"style"!==s&&(r+=Y(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",n=e.parent;o(n);)n.data&&n.data.domProps&&(t=$($({},t),n.data.domProps)),n=n.parent;if(i(t))return r;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)ne(e,t[s],!0);else if("textContent"===s)ne(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)ne(e,f(t[s]),!1);else{var c=E[s]||s.toLowerCase();!P(c)||o(a)&&o(a[c])||(r+=Y(c,t[s]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;o(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Ye(n.data,t));for(;o(r=r.parent);)r&&r.data&&(t=Ye(t,r.data));return et(t.staticClass,t.class)}(e);if(""!==t)return' class="'+I(t)+'"'},function(e){var t=function(e){var t="";for(var r in e){var n=e[r],i=S(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ct(i,n[o]);else t+=ct(i,n)}return t}(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=at(i.data))&&$(n,r);(r=at(e.data))&&$(n,r);for(var o=e;o=o.parent;)o.data&&(r=at(o.data))&&$(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(I(t))}];function lt(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function ft(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var pt={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&F(r,lt(a))>-1&&ft(a);else if(T(r,lt(a)))return void ft(a)}}},dt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),vt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ht=function(e,t){return(ht=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)Object.prototype.hasOwnProperty.call(t,r)&&(e[r]=t[r])})(e,t)};function mt(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function r(){this.constructor=e}ht(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}var yt=800,gt=function(e){return e},bt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:gt;if(bt===gt)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function _t(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=yt?bt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var wt=function(e){function t(t){var r=e.call(this)||this;return r.buffer="",r.render=t,r.expectedSize=0,r.write=_t(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),r.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)},r}return mt(t,e),t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,a(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):i(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),xt=function(){function e(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&St(t,"get"),this.has=t&&St(t,"has"),this.next=this.next.bind(this)}return e.prototype.next=function(){for(var e=function(){var e=t.renderStates[t.renderStates.length-1];if(i(e))return{value:t.done()};switch(e.type){case"Element":case"Fragment":var r=e.children,n=e.total,o=e.rendered++;if(o<n)return{value:t.renderNode(r[o],!1,t)};if(t.renderStates.pop(),"Element"===e.type)return{value:t.write(e.endTag,t.next)};break;case"Component":t.renderStates.pop(),t.activeInstance=e.prevActive;break;case"ComponentWithCache":t.renderStates.pop();var a=e.buffer,s=e.bufferIndex,c=e.componentBuffer,u=e.key,l={html:a[s],components:c[s]};if(t.cache.set(u,l),0===s)t.write.caching=!1;else{a[s-1]+=l.html;var f=c[s-1];l.components.forEach(function(e){return f.add(e)})}a.length=s,c.length=s}},t=this;;){var r=e();if("object"==typeof r)return r.value}},e}();function St(e,t){var r=e[t];return i(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}var $t=/[\w).+\-_$\]]/;function kt(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&$t.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=At(i,o[n]);return i}function At(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var Ot=/\{\{((?:.|\r?\n)+?)\}\}/g,Ct=/[-.*+?^${}()|[\]\/\\]/g,Tt=g(function(e){var t=e[0].replace(Ct,"\\$&"),r=e[1].replace(Ct,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function Ft(e,t){console.error("[Vue compiler]: "+e)}function jt(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function Pt(e,t,r,n,i){(e.props||(e.props=[])).push(Ut({name:t,value:r,dynamic:i},n)),e.plain=!1}function Et(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ut({name:t,value:r,dynamic:i},n)),e.plain=!1}function Nt(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Ut({name:t,value:r},n))}function It(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Ut({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Mt(e,t,r,i,o,a,s,c){var u;(i=i||n).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Lt("!",t,c)),i.once&&(delete i.once,t=Lt("~",t,c)),i.passive&&(delete i.passive,t=Lt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Ut({value:r.trim(),dynamic:c},s);i!==n&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function Rt(e,t,r){var n=Dt(e,":"+t)||Dt(e,"v-bind:"+t);if(null!=n)return kt(n);if(!1!==r){var i=Dt(e,t);if(null!=i)return JSON.stringify(i)}}function Dt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function zt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Ut(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var qt={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Dt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=Rt(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Bt,Jt,Ht,Kt,Vt,Wt,Zt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Dt(e,"style");r&&(e.staticStyle=JSON.stringify(ot(r)));var n=Rt(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Xt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),Gt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Qt=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Yt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,er=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,tr="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",rr="((?:"+tr+"\\:)?"+tr+")",nr=new RegExp("^<"+rr),ir=/^\s*(\/?)>/,or=new RegExp("^<\\/"+rr+"[^>]*>"),ar=/^<!DOCTYPE [^>]+>/i,sr=/^<!\--/,cr=/^<!\[/,ur=d("script,style,textarea",!0),lr={},fr={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},pr=/&(?:lt|gt|quot|amp|#39);/g,dr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,vr=d("pre,textarea",!0),hr=function(e,t){return e&&vr(e)&&"\n"===t[0]};function mr(e,t){var r=t?dr:pr;return e.replace(r,function(e){return fr[e]})}function yr(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||O,s=t.canBeLeftOpenTag||O,c=0,u=function(){if(r=e,n&&ur(n)){var u=0,p=n.toLowerCase(),d=lr[p]||(lr[p]=new RegExp("([\\s\\S]*?)(</"+p+"[^>]*>)","i"));x=e.replace(d,function(e,r,n){return u=n.length,ur(p)||"noscript"===p||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),hr(p,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-x.length,e=x,f(p,c-u,c)}else{var v=e.indexOf("<");if(0===v){if(sr.test(e)){var h=e.indexOf("--\x3e");if(h>=0)return t.shouldKeepComment&&t.comment(e.substring(4,h),c,c+h+3),l(h+3),"continue"}if(cr.test(e)){var m=e.indexOf("]>");if(m>=0)return l(m+2),"continue"}var y=e.match(ar);if(y)return l(y[0].length),"continue";var g=e.match(or);if(g){var b=c;return l(g[0].length),f(g[1],b,c),"continue"}var _=function(){var t=e.match(nr);if(t){var r={tagName:t[1],attrs:[],start:c};l(t[0].length);for(var n=void 0,i=void 0;!(n=e.match(ir))&&(i=e.match(er)||e.match(Yt));)i.start=c,l(i[0].length),i.end=c,r.attrs.push(i);if(n)return r.unarySlash=n[1],l(n[0].length),r.end=c,r}}();if(_)return function(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&Qt(r)&&f(n),s(r)&&n===r&&f(r));for(var u=a(r)||!!c,l=e.attrs.length,p=new Array(l),d=0;d<l;d++){var v=e.attrs[d],h=v[3]||v[4]||v[5]||"",m="a"===r&&"href"===v[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;p[d]={name:v[1],value:mr(h,m)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:p,start:e.start,end:e.end}),n=r);t.start&&t.start(r,p,u,e.start,e.end)}(_),hr(_.tagName,e)&&l(1),"continue"}var w=void 0,x=void 0,S=void 0;if(v>=0){for(x=e.slice(v);!(or.test(x)||nr.test(x)||sr.test(x)||cr.test(x)||(S=x.indexOf("<",1))<0);)v+=S,x=e.slice(v);w=e.substring(0,v)}v<0&&(w=e),w&&l(w.length),t.chars&&w&&t.chars(w,c-w.length,c)}if(e===r)return t.chars&&t.chars(e),"break"};e;){if("break"===u())break}function l(t){c+=t,e=e.substring(t)}function f(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}f()}function gr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function br(e,t){var r=function(e){if(e=e.trim(),Bt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Bt-1)return(Kt=e.lastIndexOf("."))>-1?{exp:e.slice(0,Kt),key:'"'+e.slice(Kt+1)+'"'}:{exp:e,key:null};Jt=e,Kt=Vt=Wt=0;for(;!wr();)xr(Ht=_r())?$r(Ht):91===Ht&&Sr(Ht);return{exp:e.slice(0,Vt),key:e.slice(Vt+1,Wt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function _r(){return Jt.charCodeAt(++Kt)}function wr(){return Kt>=Bt}function xr(e){return 34===e||39===e}function Sr(e){var t=1;for(Vt=Kt;!wr();)if(xr(e=_r()))$r(e);else if(91===e&&t++,93===e&&t--,0===t){Wt=Kt;break}}function $r(e){for(var t=e;!wr()&&(e=_r())!==t;);}var kr,Ar,Or,Cr,Tr,Fr,jr,Pr,Er=/^@|^v-on:/,Nr=/^v-|^@|^:|^#/,Ir=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Lr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Mr=/^\(|\)$/g,Rr=/^\[.*\]$/,Dr=/:(.*)$/,zr=/^:|^\.|^v-bind:/,Ur=/\.[^.\]]+(?=[^\]]*$)/g,qr=/^v-slot(:|$)|^#/,Br=/[\r\n]/,Jr=/[ \f\t\r\n]+/g,Hr=g(r.default.decode),Kr="_empty_";function Vr(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:en(t),rawAttrsMap:{},parent:r,children:[]}}function Wr(e,t){kr=t.warn||Ft,Fr=t.isPreTag||O,jr=t.mustUseProp||O,Pr=t.getTagNamespace||O,t.isReservedTag,Or=jt(t.modules,"transformNode"),Cr=jt(t.modules,"preTransformNode"),Tr=jt(t.modules,"postTransformNode"),Ar=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=Zr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Gr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Gr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Fr(e.tag)&&(c=!1);for(var f=0;f<Tr.length;f++)Tr[f](e,t)}function l(e){if(!c)for(var t=void 0;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return yr(e,{warn:kr,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||Pr(e);ue&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];tn.test(n.name)||(n.name=n.name.replace(rn,""),t.push(n))}return t}(o));var d,v=Vr(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||de()||(v.forbidden=!0);for(var h=0;h<Cr.length;h++)v=Cr[h](v,t)||v;s||(!function(e){null!=Dt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Fr(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Xr(v),function(e){var t=Dt(e,"v-if");if(t)e.if=t,Gr(e,{exp:t,block:e});else{null!=Dt(e,"v-else")&&(e.else=!0);var r=Dt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Dt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!ue||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Hr(e):u.length?a?"condense"===a&&Br.test(e)?"":" ":o?" ":"":""){c||"condense"!==a||(e=e.replace(Jr," "));var l=void 0,f=void 0;!s&&" "!==e&&(l=function(e,t){var r=t?Tt(t):Ot;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=kt(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Ar))?f={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&u.length&&" "===u[u.length-1].text||(f={type:3,text:e}),f&&u.push(f)}}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function Zr(e,t){var r,n;(n=Rt(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Rt(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Dt(e,"scope"),e.slotScope=t||Dt(e,"slot-scope")):(t=Dt(e,"slot-scope"))&&(e.slotScope=t);var r=Rt(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Et(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=zt(e,qr);if(n){var i=Qr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||Kr}}else{var n=zt(e,qr);if(n){var s=e.scopedSlots||(e.scopedSlots={}),c=Qr(n),u=c.name,a=c.dynamic,l=s[u]=Vr("template",[],e);l.slotTarget=u,l.slotTargetDynamic=a,l.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=l,!0}),l.slotScope=n.value||Kr,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Rt(e,"name"))}(e),function(e){var t;(t=Rt(e,"is"))&&(e.component=t);null!=Dt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Or.length;i++)e=Or[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Nr.test(n))if(e.hasBindings=!0,(a=Yr(n.replace(Nr,"")))&&(n=n.replace(Ur,"")),zr.test(n))n=n.replace(zr,""),o=kt(o),(c=Rr.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=_(n))&&(n="innerHTML"),a.camel&&!c&&(n=_(n)),a.sync&&(s=br(o,"$event"),c?Mt(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Mt(e,"update:"+_(n),s,null,!1,0,u[t]),S(n)!==_(n)&&Mt(e,"update:"+S(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&jr(e.tag,e.attrsMap.type,n)?Pt(e,n,o,u[t],c):Et(e,n,o,u[t],c);else if(Er.test(n))n=n.replace(Er,""),(c=Rr.test(n))&&(n=n.slice(1,-1)),Mt(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Nr,"")).match(Dr),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Rr.test(f)&&(f=f.slice(1,-1),c=!0)),It(e,n,i,o,f,c,a,u[t])}else Et(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&jr(e.tag,e.attrsMap.type,n)&&Pt(e,n,"true",u[t])}(e),e}function Xr(e){var t;if(t=Dt(e,"v-for")){var r=function(e){var t=e.match(Ir);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(Mr,""),i=n.match(Lr);i?(r.alias=n.replace(Lr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&$(e,r)}}function Gr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Qr(e){var t=e.name.replace(qr,"");return t||"#"!==e.name[0]&&(t="default"),Rr.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Yr(e){var t=e.match(Ur);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function en(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var tn=/^xmlns:NS\d+/,rn=/^NS\d+:/;function nn(e){return Vr(e.tag,e.attrsList.slice(),e.parent)}var on=[qt,Zt,{preTransformNode:function(e,t){if("input"===e.tag){var r=e.attrsMap;if(!r["v-model"])return;var n=void 0;if((r[":type"]||r["v-bind:type"])&&(n=Rt(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Dt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Dt(e,"v-else",!0),s=Dt(e,"v-else-if",!0),c=nn(e);Xr(c),Nt(c,"type","checkbox"),Zr(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,Gr(c,{exp:c.if,block:c});var u=nn(e);Dt(u,"v-for",!0),Nt(u,"type","radio"),Zr(u,t),Gr(c,{exp:"("+n+")==='radio'"+o,block:u});var l=nn(e);return Dt(l,"v-for",!0),Nt(l,":type",n),Zr(l,t),Gr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],an="__r";var sn={expectHTML:!0,modules:on,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return gr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mt(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=Rt(e,"value")||"null",o=Rt(e,"true-value")||"true",a=Rt(e,"false-value")||"false";Pt(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mt(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+br(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=Rt(e,"value")||"null";Pt(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Mt(e,"change",br(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return gr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?an:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=br(t,l);c&&(f="if($event.target.composing)return;"+f),Pt(e,"value","("+t+")"),Mt(e,u,f,null,!0),(s||a)&&Mt(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&Pt(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Pt(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:Xt,mustUseProp:function(e,t,r){return"value"===r&&R(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:Gt,isReservedTag:function(e){return nt(e)||it(e)},getTagNamespace:function(e){return it(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(on)},cn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,un=/\([^)]*?\);*$/,ln=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,fn={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},pn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},dn=function(e){return"if("+e+")return null;"},vn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:dn("$event.target !== $event.currentTarget"),ctrl:dn("!$event.ctrlKey"),shift:dn("!$event.shiftKey"),alt:dn("!$event.altKey"),meta:dn("!$event.metaKey"),left:dn("'button' in $event && $event.button !== 0"),middle:dn("'button' in $event && $event.button !== 1"),right:dn("'button' in $event && $event.button !== 2")};function hn(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=mn(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function mn(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return mn(e)}).join(",")+"]";var t=ln.test(e.value),r=cn.test(e.value),n=ln.test(e.value.replace(un,""));if(e.modifiers){var i="",o="",a=[],s=function(t){if(vn[t])o+=vn[t],fn[t]&&a.push(t);else if("exact"===t){var r=e.modifiers;o+=dn(["ctrl","shift","alt","meta"].filter(function(e){return!r[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(t)};for(var c in e.modifiers)s(c);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(yn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function yn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=fn[e],n=pn[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var gn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:A},bn=function(){return function(e){this.options=e,this.warn=e.warn||Ft,this.transforms=jt(e.modules,"transformCode"),this.dataGenFns=jt(e.modules,"genData"),this.directives=$($({},gn),e.directives);var t=e.isReservedTag||O;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1}}();function _n(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return wn(e,t);if(e.once&&!e.onceProcessed)return xn(e,t);if(e.for&&!e.forProcessed)return $n(e,t);if(e.if&&!e.ifProcessed)return Sn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=Cn(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?Pn((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:_(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r=void 0;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:Cn(t,r,!0);return"_c("+e+","+kn(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n=void 0;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=kn(e,t));var i=e.inlineTemplate?null:Cn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return Cn(e,t)||"void 0"}function wn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+_n(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function xn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Sn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+_n(e,t)+","+t.onceId+++","+r+")":_n(e,t)}return wn(e,t)}function Sn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?xn(e,r):_n(e,r)}}(e.ifConditions.slice(),t,r,n)}function $n(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||_n)(e,t)+"})"}function kn(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+Pn(e.attrs)+","),e.props&&(r+="domProps:"+Pn(e.props)+","),e.events&&(r+=hn(e.events,!1)+","),e.nativeEvents&&(r+=hn(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||An(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==Kr||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return On(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new bn(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":_n(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+Pn(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function An(e){return 1===e.type&&("slot"===e.tag||e.children.some(An))}function On(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return Sn(e,t,On,"null");if(e.for&&!e.forProcessed)return $n(e,t,On);var n=e.slotScope===Kr?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(Cn(e,t)||"undefined")+":undefined":Cn(e,t)||"undefined":_n(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Cn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||_n)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(Tn(i)||i.ifConditions&&i.ifConditions.some(function(e){return Tn(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||Fn;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function Tn(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Fn(e,t){return 1===e.type?_n(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):jn(e);var r}function jn(e){return"_v("+(2===e.type?e.expression:En(JSON.stringify(e.text)))+")"}function Pn(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=En(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function En(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Nn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function In(e,t){return Nn.test(t)?(t=t.replace(/^'|'$/g,'"'),D(e)&&'"false"'!==t&&(t='"true"'),{type:zn,value:q(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:qn,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var Ln,Mn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function Rn(e,t){e&&(Ln=t.isReservedTag||O,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!Ln(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=Mn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!Dn(e.name)})}(t);var i=function(e){e.ssrOptimizability!==Mn.FULL&&(t.ssrOptimizability=n?Mn.PARTIAL:Mn.SELF)};n&&(t.ssrOptimizability=Mn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var o=1,a=t.ifConditions.length;o<a;o++){var c=t.ifConditions[o].block;e(c,r),i(c)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=Mn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:Mn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===Mn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=Mn.FULL}(e,!0))}var Dn=d("text,html,show,on,bind,model,pre,cloak,once");var zn=0,Un=1,qn=2;function Bn(e,t){if(e.for&&!e.forProcessed)return $n(e,t,Bn);if(e.if&&!e.ifProcessed)return Sn(e,t,Bn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===Mn.FULL?Vn(e,t):Hn(e,t)||"void 0";switch(e.ssrOptimizability){case Mn.FULL:return function(e,t){return"_ssrNode("+Wn(e,t)+")"}(e,t);case Mn.SELF:return function(e,t){var r=Hn(e,t,!0);return"_ssrNode("+Qn(Xn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case Mn.CHILDREN:return Jn(e,t,!0);case Mn.PARTIAL:return Jn(e,t,!1);default:return _n(e,t)}}function Jn(e,t,r){var n=e.plain?void 0:kn(e,t),i=r?"["+Vn(e,t)+"]":Hn(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Hn(e,t,r){return Cn(e,t,r,Bn,Kn)}function Kn(e,t){return 1===e.type?Bn(e,t):jn(e)}function Vn(e,t){return e.children.length?"_ssrNode("+Qn(Gn(e,t))+")":""}function Wn(e,t){return"("+Qn(Zn(e,t))+")"}function Zn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:qn,value:$n(e,t,Wn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:qn,value:Sn(e,t,Wn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Gn(e,t);var r=Xn(e,t),n=Gn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:zn,value:"</"+e.tag+">"}];return r.concat(n,o)}function Xn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:zn,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return In(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=W[n]||n.toLowerCase(),!V(n)||t&&t.some(function(e){return e.name===n})||r.push(In(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:qn,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:qn,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:zn,value:' class="'+JSON.parse(n)+'"'}]:[{type:qn,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:qn,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:zn,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:zn,value:" "+t.options.scopeId}),u.push({type:zn,value:">"}),u}function Gn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:qn,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:Un,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:Un,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,Zn(i,t));else if(2===i.type)r.push({type:Un,value:i.expression});else if(3===i.type){var o=X(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:zn,value:o})}}return r}(e.children,t):[]}function Qn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===zn?r+=o.value:o.type===Un?(n(),t.push("_ssrEscape("+o.value+")")):o.type===qn&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}function Yn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),A}}function ei(e){var t=Object.create(null);return function(r,n,i){(n=$({},n)).warn,delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Yn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Yn(e,c)}),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ti,ri=(ti=function(e,t){var r=Wr(e.trim(),t);Rn(r,t);var n=function(e,t){var r=new bn(t);return{render:"with(this){return "+(e?Bn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=$(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=ti(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:ei(t)}})(sn).compileToFunctions;function ni(e,t){if(q(e)){if(!B(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+X(U(e,t))+'"';if(!B(t))return" "+e+'="'+X(String(t))+'"'}return""}function ii(e,t){return"string"==typeof t||"number"==typeof t&&Q[e]||0===t?e+":"+t+";":""}function oi(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function ai(e){return s(e)?[re(e)]:Array.isArray(e)?function e(t,r){var n=[];var c,u,l,f;for(c=0;c<t.length;c++)i(u=t[c])||"boolean"==typeof u||(l=n.length-1,f=n[l],Array.isArray(u)?u.length>0&&(si((u=e(u,(r||"")+"_"+c))[0])&&si(f)&&(n[l]=re(f.text+u[0].text),u.shift()),n.push.apply(n,u)):s(u)?si(f)?n[l]=re(f.text+u):""!==u&&n.push(re(u)):si(u)&&si(f)?n[l]=re(f.text+u.text):(a(t._isVList)&&o(u.tag)&&i(u.key)&&o(r)&&(u.key="__vlist"+r+"_"+c+"__"),n.push(u)));return n}(e):void 0}function si(e){return o(e)&&o(e.text)&&!1===e.isComment}var ci={_ssrEscape:X,_ssrNode:function(e,t,r,n){return new ui(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(c(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:ni,_ssrAttrs:function(e){var t="";for(var r in e)K(r)||(t+=ni(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=W[r]||r.toLowerCase();V(n)&&(t+=ni(n,e[r]))}return t},_ssrClass:function(e,t){var r=et(e,t);return""===r?r:' class="'+X(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&$(n,e);t&&$(n,st(t));r&&$(n,r);var i=function(e){var t="";for(var r in e){var n=e[r],i=S(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ii(i,n[o]);else t+=ii(i,n)}return t}(n);return""===i?i:" style="+JSON.stringify(X(i))}};var ui=function(){return function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?oi(r):2===n?ai(r):r:void 0}}();var li=new he;function fi(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!c(t)||Object.isFrozen(t)||t instanceof ee)return;if(t.__ob__){var a=t.__ob__.dep.id;if(r.has(a))return;r.add(a)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,li),li.clear()}var pi=g(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function di(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return We(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)We(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function vi(e,t,r,n,i){if(o(t)){if(y(t,r))return e[r]=t[r],i||delete t[r],!0;if(y(t,n))return e[r]=t[n],i||delete t[n],!0}return!1}var hi,mi=1,yi=2;function gi(e,t,r,n,u,l){return(Array.isArray(r)||s(r))&&(u=n,n=r,r=void 0),a(l)&&(u=yi),function(e,t,r,n,s){if(o(r)&&o(r.__ob__))return te();o(r)&&o(r.is)&&(t=r.is);if(!t)return te();Array.isArray(n)&&"function"==typeof n[0]&&((r=r||{}).scopedSlots={default:n[0]},n.length=0);s===yi?n=ai(n):s===mi&&(n=oi(n));var u,l;if("string"==typeof t){var f=void 0;l=e.$vnode&&e.$vnode.ns||be.getTagNamespace(t),u=r&&r.pre||!o(f=Ue(e.$options,"components",t))?new ee(t,r,n,void 0,void 0,e):Gi(f,r,e,n,t)}else u=Gi(t,r,e,n);return Array.isArray(u)?u:o(u)?(o(l)&&function e(t,r,n){t.ns=r;"foreignObject"===t.tag&&(r=void 0,n=!0);if(o(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];o(u.tag)&&(i(u.ns)||a(n)&&"svg"!==u.tag)&&e(u,r,n)}}(u,l),o(r)&&function(e){c(e.style)&&fi(e.style);c(e.class)&&fi(e.class)}(r),u):te()}(e,t,r,n,u)}function bi(e,t){var r,n,i,a,s=null;if(Array.isArray(e)||"string"==typeof e)for(s=new Array(e.length),r=0,n=e.length;r<n;r++)s[r]=t(e[r],r);else if("number"==typeof e)for(s=new Array(e),r=0;r<e;r++)s[r]=t(r+1,r);else if(c(e))if(me&&e[Symbol.iterator]){s=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)s.push(t(l.value,s.length)),l=u.next()}else for(i=Object.keys(e),s=new Array(i.length),r=0,n=i.length;r<n;r++)a=i[r],s[r]=t(e[a],a,r);return o(s)||(s=[]),s._isVList=!0,s}function _i(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=$($({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function wi(e){return Ue(this.$options,"filters",e)||C}function xi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function Si(e,t,r,n,i){var o=be.keyCodes[t]||r;return i&&n&&!be.keyCodes[t]?xi(i,n):o?xi(o,e):n?S(n)!==t:void 0}function $i(e,t,r,n,i){if(r)if(c(r)){Array.isArray(r)&&(r=k(r));var o=void 0,a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||be.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=_(a),u=S(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var s in r)a(s)}else;return e}function ki(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(Oi(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function Ai(e,t,r){return Oi(e,"__once__"+t+(r?"_"+r:""),!0),e}function Oi(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&Ci(e[n],t+"_"+n,r);else Ci(e,t,r)}function Ci(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function Ti(e,t){if(t)if(l(t)){var r=e.on=e.on?$({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function Fi(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Fi(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function ji(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function Pi(e,t){return"string"==typeof e?t+e:e}function Ei(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Ni)&&delete r[u];return r}function Ni(e){return e.isComment&&!e.asyncFactory||" "===e.text}function Ii(e,t,r){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==n&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Li(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Mi(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ie(i,"$stable",a),ie(i,"$key",s),ie(i,"$hasNormal",o),i}function Li(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ai(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Mi(e,t){return function(){return e[t]}}function Ri(e,t){hi.$on(e,t)}function Di(e,t){hi.$off(e,t)}function zi(e,t){var r=hi;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Ui(e,t,r){hi=e,function(e,t,r,n,o,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=pi(c),i(u)||(i(l)?(i(u.fns)&&(u=e[c]=di(u,s)),a(f.once)&&(u=e[c]=o(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)i(e[c])&&n((f=pi(c)).name,t[c],f.capture)}(t,r||{},Ri,Di,zi,e),hi=void 0}function qi(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Bi(e,t){Se();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)We(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),$e()}var Ji=Date.now;if(ae&&!ue){var Hi=window.performance;Hi&&"function"==typeof Hi.now&&Ji()>document.createEvent("Event").timeStamp&&(Ji=function(){return Hi.now()})}function Ki(e,t,r,i,o){var s,c=this,u=o.options;y(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=a(u._compiled),f=!l;this.data=e,this.props=t,this.children=r,this.parent=i,this.listeners=e.on||n,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=me?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||Ii(e.scopedSlots,c.$slots=Ei(r,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return Ii(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=Ii(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=gi(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return gi(s,e,t,r,n,f)}}function Vi(e,t,r,n,i){var o=function(e){var t=new ee(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Wi(e,t){for(var r in t)e[_(r)]=t[r]}!function(e){e._o=Ai,e._n=p,e._s=f,e._l=bi,e._t=_i,e._q=T,e._i=F,e._m=ki,e._f=wi,e._k=Si,e._b=$i,e._v=re,e._e=te,e._u=Fi,e._g=Ti,e._d=ji,e._p=Pi}(Ki.prototype);var Zi={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Zi.prepatch(r,r)}else{(e.componentInstance=Qi(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var r=t.componentOptions;!function(e,t,r,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==n&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||n,e.$listeners=r||n,t&&e.$options.props){Te(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=qe(d,v,t,e)}Te(!0),e.$options.propsData=t}r=r||n;var h=e.$options._parentListeners;e.$options._parentListeners=r,Ui(e,r,h),u&&(e.$slots=Ei(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,r.propsData,r.listeners,t,r.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Bi(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,qi(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Bi(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,qi(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Bi(t,"deactivated")}}(t,!0):t.$destroy())}},Xi=Object.keys(Zi);function Gi(e,t,r,s,u){if(!i(e)){var l=r.$options._base;if(c(e)&&(e=l.extend(e)),"function"==typeof e){var f,p;if(i(e.cid)&&void 0===(e=a((p=f=e).error)&&o(p.errorComp)?p.errorComp:o(p.resolved)?p.resolved:a(p.loading)&&o(p.loadingComp)?p.loadingComp:void 0))return function(e,t,r,n,i){var o=te();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(f,t,r,s,u);t=t||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&$(t.extendOptions,i),(r=t.options=ze(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),o(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var i=t.on||(t.on={}),a=i[n],s=t.model.callback;o(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[n]=[s].concat(a)):i[n]=s}(e.options,t);var d=function(e,t,r){var n=t.options.props;if(!i(n)){var a={},s=e.attrs,c=e.props;if(o(s)||o(c))for(var u in n){var l=S(u);vi(a,c,u,l,!0)||vi(a,s,u,l,!1)}return a}}(t,e);if(a(e.options.functional))return function(e,t,r,i,a){var s=e.options,c={},u=s.props;if(o(u))for(var l in u)c[l]=qe(l,u,t||n);else o(r.attrs)&&Wi(c,r.attrs),o(r.props)&&Wi(c,r.props);var f=new Ki(r,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof ee)return Vi(p,r,f.parent,s);if(Array.isArray(p)){for(var d=ai(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Vi(d[h],r,f.parent,s);return v}}(e,d,t,r,s);var v=t.on;if(t.on=t.nativeOn,a(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Xi.length;r++){var n=Xi[r],i=t[n],o=Zi[n];i===o||i&&i._merged||(t[n]=i?Yi(o,i):o)}}(t);var m=e.options.name||u;return new ee("vue-component-"+e.cid+(m?"-"+m:""),t,void 0,void 0,void 0,r,{Ctor:e,propsData:d,listeners:v,tag:u,children:s},f)}}}function Qi(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return o(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function Yi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var eo=Object.create(null),to=function(e){eo[e]||(eo[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},ro=function(e,t){var r=t?(void 0)():"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},no=function(e){var t=e.$options,r=t.render,n=t.template,o=t._scopeId;if(i(r)){if(!n)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=ri(n,{scopeId:o,warn:ro},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function io(e,t,r){var n=e.$options.serverPrefetch;if(o(n)){Array.isArray(n)||(n=[n]);try{for(var i=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&i.push(c)}return void Promise.all(i).then(t).catch(r)}catch(e){r(e)}}t()}function oo(e,t,r){e.isString?function(e,t){var r=t.write,n=t.next;if(i(e.children)||0===e.children.length)r(e.open+(e.close||""),n);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,n)}}(e,r):o(e.componentOptions)?so(e,t,r):o(e.tag)?function(e,t,r){var n=r.write,s=r.next;a(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[ye]="true");e.fnOptions&&ao(e.fnOptions,n);var c=function(e,t){var r,n="<"+e.tag,a=t.directives,s=t.modules;i(e.data)&&function e(t){var r=t.parent;return o(r)&&(o(r.data)||e(r))}(e)&&(e.data={});if(o(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=Ue(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;o(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var u=0;u<s.length;u++){var d=s[u](e);d&&(n+=d)}}var v=t.activeInstance;o(v)&&v!==e.context&&o(r=v.$options._scopeId)&&(n+=" "+r);if(o(e.fnScopeId))n+=" "+e.fnScopeId;else for(;o(e);)o(r=e.context.$options._scopeId)&&(n+=" "+r),e=e.parent;return n+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))n(c,s);else if(i(e.children)||0===e.children.length)n(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),n(c,s)}}(e,t,r):a(e.isComment)?o(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=Gi(n,o,c,a,s);u?u.componentOptions?so(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):oo(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:X(String(e.text)),r.next)}function ao(e,t){var r=e._ssrRegister;return t.caching&&o(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function so(e,t,r){var n=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=ao(c.options,n);if(o(u)&&o(f)&&o(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void uo(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;o(h)?h(v,function(i){!0===i&&o(m)?m(v,function(e){o(p)&&p(s),e.components.forEach(function(e){return e(s)}),n(e.html,a)}):co(e,t,v,r)}):o(m)&&m(v,function(i){o(i)?(o(p)&&p(s),i.components.forEach(function(e){return e(s)}),n(i.html,a)):co(e,t,v,r)})}else o(u)&&i(f)&&to("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),o(u)&&i(l)&&to('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),uo(e,t,r)}function co(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),uo(e,t,n)}function uo(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Qi(e,r.activeInstance);no(i);var o=r.done;io(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),oo(o,t,r)},o)}function lo(e,t,r,n){return function(i,o,a,s){eo=Object.create(null);var c=new xt({activeInstance:i,userContext:a,write:o,done:s,renderNode:oo,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;$(t.prototype,ci),t.FunctionalRenderContext&&$(t.FunctionalRenderContext.prototype,ci)}}(i),no(i);io(i,function(){oo(i._render(),!0,c)},s)}}var fo=function(e){return/\.js(\?[^.]+)?$/.test(e)};function po(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var vo=function(e){function t(t,r,n){var i=e.call(this)||this;return i.started=!1,i.renderer=t,i.template=r,i.context=n||{},i.inject=t.inject,i}return mt(t,e),t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),ho=require("lodash.template"),mo={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function yo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var go=require("path"),bo=require("serialize-javascript"),_o=function(){function e(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:ho(e.slice(0,r),mo),neck:ho(e.slice(r,n),mo),tail:ho(e.slice(n+t.length),mo)}}(t):t:null,this.serialize=e.serializer||function(e){return bo(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(wo),this.prefetchFiles=(r.async||[]).map(wo),this.mapFiles=yo(r)}}return e.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},e.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},e.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},e.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},e.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},e.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},e.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},e.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey,i=void 0===n?"state":n,o=r.windowKey,a=void 0===o?"__INITIAL_STATE__":o,s=this.serialize(e[i]),c=e.nonce?' nonce="'+e.nonce+'"':"";return e[i]?"<script"+c+">window."+a+"="+s+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},e.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return fo(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return fo(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},e.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(wo)}return e._mappedFiles},e.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new vo(this,this.parsedTemplate,e||{})},e}();function wo(e){var t=e.replace(/\?.*/,""),r=go.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:xo(r)}}function xo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}var So=require("vm"),$o=require("path"),ko=require("resolve"),Ao=require("module");function Oo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function Co(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=Ao.wrap(r),o=new So.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=$o.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=ko.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function To(e,t,r,n){var i,o,a=Co(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,Oo(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?Oo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(l(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))})}}var Fo=require("source-map").SourceMapConsumer,jo=/\(([^)]+\.js):(\d+):(\d+)\)$/;function Po(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(jo),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(jo,c)}return e}return e}(e,t)}).join("\n"))}var Eo=require("fs"),No=require("path"),Io=require("stream").PassThrough,Lo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Mo(e){return void 0===e&&(e={}),t=$($({},e),{isUnaryTag:dt,canBeLeftOpenTag:vt,modules:ut,directives:$(pt,e.directives)}),n=(r=void 0===t?{}:t).modules,i=void 0===n?[]:n,o=r.directives,a=void 0===o?{}:o,s=r.isUnaryTag,c=void 0===s?function(){return!1}:s,u=r.template,l=r.inject,f=r.cache,p=r.shouldPreload,d=r.shouldPrefetch,v=r.clientManifest,h=r.serializer,m=lo(i,a,c,f),y=new _o({template:u,inject:l,shouldPreload:p,shouldPrefetch:d,clientManifest:v,serializer:h}),{renderToString:function(e,t,r){var n,i;"function"==typeof t&&(r=t,t={}),t&&y.bindRenderFns(t),r||(i=(n=po()).promise,r=n.cb);var o="",a=_t(function(e){return o+=e,!1},r);try{m(e,a,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),u)try{var n=y.render(o,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,o)})}catch(e){r(e)}return i},renderToStream:function(e,t){t&&y.bindRenderFns(t);var r=new wt(function(r,n){m(e,r,t,n)});if(u){if("function"==typeof u)throw new Error("function template is only supported in renderToString.");var n=y.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var i=t.rendered;r.once("beforeEnd",function(){i(t)})}return n}if(t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return r}};var t,r,n,i,o,a,s,c,u,l,f,p,d,v,h,m,y}process.env.VUE_ENV="server";var Ro=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&No.isAbsolute(t)){if(!Eo.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||No.dirname(t),t=Eo.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new Fo(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(Lo)}else{if("string"!=typeof t)throw new Error(Lo);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=To(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=po()).promise,t=r.cb),u(e).catch(function(e){Po(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){Po(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new Io;return u(e).catch(function(e){Po(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){Po(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(Mo);exports.createBundleRenderer=Ro,exports.createRenderer=Mo;
\ No newline at end of file
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream");function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var r=t(require("he")),n=Object.freeze({});function i(e){return null==e}function o(e){return null!=e}function a(e){return!0===e}function s(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function c(e){return null!==e&&"object"==typeof e}var u=Object.prototype.toString;function l(e){return"[object Object]"===u.call(e)}function f(e){return null==e?"":Array.isArray(e)||l(e)&&e.toString===u?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var b=/-(\w)/g,_=g((function(e){return e.replace(b,(function(e,t){return t?t.toUpperCase():""}))})),x=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,$=g((function(e){return e.replace(w,"-$1").toLowerCase()}));function S(e,t){for(var r in t)e[r]=t[r];return e}function k(e){for(var t={},r=0;r<e.length;r++)e[r]&&S(t,e[r]);return t}function O(e,t,r){}var A=function(e,t,r){return!1},C=function(e){return e};function T(e,t){if(e===t)return!0;var r=c(e),n=c(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every((function(e,r){return T(e,t[r])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),s=Object.keys(t);return a.length===s.length&&a.every((function(r){return T(e[r],t[r])}))}catch(e){return!1}}function j(e,t){for(var r=0;r<e.length;r++)if(T(e[r],t))return r;return-1}var F=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),P={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},N={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function E(e){return e.replace(/[<>"&]/g,I)}function I(e){return N[e]||e}var M={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},R=d("input,textarea,option,select,progress"),D=d("contenteditable,draggable,spellcheck"),z=d("events,caret,typing,plaintext-only"),L=function(e,t){return B(t)||"false"===t?"false":"contenteditable"===e&&z(t)?t:"true"},q=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),B=function(e){return null==e||!1===e},U=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),J=/[>/="'\u0009\u000a\u000c\u0020]/,K=function(e){return J.test(e)},H=function(e){return U(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},V={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},W={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function Z(e){return e.replace(/[<>"&]/g,X)}function X(e){return W[e]||e}var G={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0};function Q(e,t){if(q(e)){if(!B(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+E(L(e,t))+'"';if(!B(t))return" "+e+'="'+E(String(t))+'"'}return""}var Y=function(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ee={child:{configurable:!0}};ee.child.get=function(){return this.componentInstance},Object.defineProperties(Y.prototype,ee);var te=function(e){void 0===e&&(e="");var t=new Y;return t.text=e,t.isComment=!0,t};function re(e){return new Y(void 0,void 0,void 0,String(e))}function ne(e,t,r){var n=new Y(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ie(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var oe="__proto__"in{},ae="undefined"!=typeof window,se="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,ce=(se&&WXEnvironment.platform.toLowerCase(),ae&&window.navigator.userAgent.toLowerCase()),ue=ce&&/msie|trident/.test(ce);ce&&ce.indexOf("msie 9.0");ce&&ce.indexOf("edge/");ce&&ce.indexOf("android"),ce&&/iphone|ipad|ipod|ios/.test(ce),ce&&/chrome\/\d+/.test(ce),ce&&/phantomjs/.test(ce),ce&&ce.match(/firefox\/(\d+)/);var le,fe={}.watch;if(ae)try{var pe={};Object.defineProperty(pe,"passive",{get:function(){!0}}),window.addEventListener("test-passive",null,pe)}catch(e){}var de=function(){return void 0===le&&(le=!ae&&!se&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),le};function ve(e){return"function"==typeof e&&/native code/.test(e.toString())}var he,me="undefined"!=typeof Symbol&&ve(Symbol)&&"undefined"!=typeof Reflect&&ve(Reflect.ownKeys);he="undefined"!=typeof Set&&ve(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ye=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],ge={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:A,isReservedAttr:A,isUnknownElement:A,getTagNamespace:O,parsePlatformTagName:C,mustUseProp:A,async:!0,_lifecycleHooks:ye},be=0,_e=function(){this.id=be++,this.subs=[]};_e.prototype.addSub=function(e){this.subs.push(e)},_e.prototype.removeSub=function(e){!function(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)e.splice(r,1)}}(this.subs,e)},_e.prototype.depend=function(){_e.target&&_e.target.addDep(this)},_e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},_e.target=null;var xe=[];function we(e){xe.push(e),_e.target=e}function $e(){xe.pop(),_e.target=xe[xe.length-1]}var Se=Array.prototype,ke=Object.create(Se);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=Se[e];ie(ke,e,(function(){for(var r=[],n=arguments.length;n--;)r[n]=arguments[n];var i,o=t.apply(this,r),a=this.__ob__;switch(e){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var Oe=Object.getOwnPropertyNames(ke),Ae=!0;function Ce(e){Ae=e}var Te=function(e){this.value=e,this.dep=new _e,this.vmCount=0,ie(e,"__ob__",this),Array.isArray(e)?(oe?function(e,t){e.__proto__=t}(e,ke):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ie(e,o,t[o])}}(e,ke,Oe),this.observeArray(e)):this.walk(e)};function je(e,t){var r;if(c(e)&&!(e instanceof Y))return y(e,"__ob__")&&e.__ob__ instanceof Te?r=e.__ob__:Ae&&!de()&&(Array.isArray(e)||l(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Te(e)),t&&r&&r.vmCount++,r}function Fe(e,t,r,n,i){var o=new _e,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&je(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return _e.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&Ne(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&je(t),o.notify())}})}}function Pe(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(Fe(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}function Ne(e){for(var t=void 0,r=0,n=e.length;r<n;r++)(t=e[r])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Ne(t)}Te.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)Fe(e,t[r])},Te.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)je(e[t])};var Ee=ge.optionMergeStrategies;function Ie(e,t){if(!t)return e;for(var r,n,i,o=me?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],y(e,r)?n!==i&&l(n)&&l(i)&&Ie(n,i):Pe(e,r,i));return e}function Me(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ie(n,i):i}:t?e?function(){return Ie("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Re(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function De(e,t,r,n){var i=Object.create(e||null);return t?S(i,t):i}Ee.data=function(e,t,r){return r?Me(e,t,r):t&&"function"!=typeof t?e:Me(e,t)},ye.forEach((function(e){Ee[e]=Re})),["component","directive","filter"].forEach((function(e){Ee[e+"s"]=De})),Ee.watch=function(e,t,r,n){if(e===fe&&(e=void 0),t===fe&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in S(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ee.props=Ee.methods=Ee.inject=Ee.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return S(i,e),t&&S(i,t),i},Ee.provide=Me;var ze=function(e,t){return void 0===t?e:t};function Le(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[_(i)]={type:null});else if(l(r))for(var a in r)i=r[a],o[_(a)]=l(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(l(r))for(var o in r){var a=r[o];n[o]=l(a)?S({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=Le(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)y(e,o)||s(o);function s(n){var i=Ee[n]||ze;a[n]=i(e[n],t[n],r,n)}return a}function qe(e,t,r,n){if("string"==typeof r){var i=e[t];if(y(i,r))return i[r];var o=_(r);if(y(i,o))return i[o];var a=x(o);return y(i,a)?i[a]:i[r]||i[o]||i[a]}}function Be(e,t,r,n){var i=t[e],o=!y(r,e),a=r[e],s=He(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===$(e)){var c=He(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!y(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==Je(t.type)?n.call(e):n}(n,i,e);var u=Ae;Ce(!0),je(a),Ce(u)}return a}var Ue=/^\s*function (\w+)/;function Je(e){var t=e&&e.toString().match(Ue);return t?t[1]:""}function Ke(e,t){return Je(e)===Je(t)}function He(e,t){if(!Array.isArray(t))return Ke(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(Ke(t[r],e))return r;return-1}function Ve(e,t,r){we();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){Ze(e,n,"errorCaptured hook")}}Ze(e,t,r)}finally{$e()}}function We(e,t,r,n,i){var a,s;try{(a=r?e.apply(t,r):e.call(t))&&!a._isVue&&(o(s=a)&&"function"==typeof s.then&&"function"==typeof s.catch)&&!a._handled&&(a.catch((function(e){return Ve(e,n,i+" (Promise/async)")})),a._handled=!0)}catch(e){Ve(e,n,i)}return a}function Ze(e,t,r){!function(e,t,r){if(!ae&&!se||"undefined"==typeof console)throw e;console.error(e)}(e)}var Xe=[];if("undefined"!=typeof Promise&&ve(Promise));else if(ue||"undefined"==typeof MutationObserver||!ve(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&ve(setImmediate);else{var Ge=new MutationObserver((function(){var e=Xe.slice(0);Xe.length=0;for(var t=0;t<e.length;t++)e[t]()})),Qe=document.createTextNode(String(1));Ge.observe(Qe,{characterData:!0})}function Ye(e,t){return{staticClass:tt(e.staticClass,t.staticClass),class:o(e.class)?[e.class,t.class]:t.class}}function et(e,t){return o(e)||o(t)?tt(e,rt(t)):""}function tt(e,t){return e?t?e+" "+t:e:t||""}function rt(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,i=e.length;n<i;n++)o(t=rt(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):c(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var nt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),it=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var ot=g((function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}})),t}));function at(e){var t=st(e.style);return e.staticStyle?S(e.staticStyle,t):t}function st(e){return Array.isArray(e)?k(e):"string"==typeof e?ot(e):e}function ct(e,t){return"string"==typeof t||"number"==typeof t&&M[e]||0===t?e+":"+t+";":""}var ut=[function(e){var t=e.data.attrs,r="",n=e.parent&&e.parent.componentOptions;if(i(n)||!1!==n.Ctor.options.inheritAttrs)for(var a=e.parent;o(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)o(a.data)&&o(a.data.attrs)&&(t=S(S({},t),a.data.attrs)),a=a.parent;if(i(t))return r;for(var s in t)K(s)||"style"!==s&&(r+=Q(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",n=e.parent;o(n);)n.data&&n.data.domProps&&(t=S(S({},t),n.data.domProps)),n=n.parent;if(i(t))return r;var a,s=e.data.attrs;for(var c in t)if("innerHTML"===c)ne(e,t[c],!0);else if("textContent"===c)ne(e,t[c],!1);else if("value"===c&&"textarea"===e.tag)ne(e,f(t[c]),!1);else{var u=P[c]||c.toLowerCase();!F(a=u)&&0!==a.indexOf("data-")&&0!==a.indexOf("aria-")||o(s)&&o(s[u])||(r+=Q(u,t[c]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;o(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Ye(n.data,t));for(;o(r=r.parent);)r&&r.data&&(t=Ye(t,r.data));return et(t.staticClass,t.class)}(e);if(""!==t)return' class="'+E(t)+'"'},function(e){var t=function(e){var t="";for(var r in e){var n=e[r],i=$(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ct(i,n[o]);else t+=ct(i,n)}return t}(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=at(i.data))&&S(n,r);(r=at(e.data))&&S(n,r);for(var o=e;o=o.parent;)o.data&&(r=at(o.data))&&S(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(E(t))}];function lt(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function ft(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var pt={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&j(r,lt(a))>-1&&ft(a);else if(T(r,lt(a)))return void ft(a)}}},dt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),vt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ht=function(e){return e},mt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:ht;if(mt===ht)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function yt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=800?mt((function(){try{o()}catch(e){t(e)}})):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var gt=function(e){function t(t){var r=this;e.call(this),this.buffer="",this.render=t,this.expectedSize=0,this.write=yt((function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)}),(function(e){r.emit("error",e)})),this.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)}}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,a(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):i(this.next)?this.tryRender():this.tryNext()},t}(e.Readable),bt=function(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&_t(t,"get"),this.has=t&&_t(t,"has"),this.next=this.next.bind(this)};function _t(e,t){var r=e[t];return i(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}bt.prototype.next=function(){for(;;){var e=this.renderStates[this.renderStates.length-1];if(i(e))return this.done();switch(e.type){case"Element":case"Fragment":var t=e.children,r=e.total,n=e.rendered++;if(n<r)return this.renderNode(t[n],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();var o=e.buffer,a=e.bufferIndex,s=e.componentBuffer,c=e.key,u={html:o[a],components:s[a]};if(this.cache.set(c,u),0===a)this.write.caching=!1;else{o[a-1]+=u.html;var l=s[a-1];u.components.forEach((function(e){return l.add(e)}))}o.length=a,s.length=a}}};var xt=/[\w).+\-_$\]]/;function wt(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&xt.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=$t(i,o[n]);return i}function $t(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var St=/\{\{((?:.|\r?\n)+?)\}\}/g,kt=/[-.*+?^${}()|[\]\/\\]/g,Ot=g((function(e){var t=e[0].replace(kt,"\\$&"),r=e[1].replace(kt,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")}));function At(e,t){console.error("[Vue compiler]: "+e)}function Ct(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Tt(e,t,r,n,i){(e.props||(e.props=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function jt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Dt({name:t,value:r,dynamic:i},n)),e.plain=!1}function Ft(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Dt({name:t,value:r},n))}function Pt(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Dt({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Nt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function Et(e,t,r,i,o,a,s,c){var u;(i=i||n).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Nt("!",t,c)),i.once&&(delete i.once,t=Nt("~",t,c)),i.passive&&(delete i.passive,t=Nt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Dt({value:r.trim(),dynamic:c},s);i!==n&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function It(e,t,r){var n=Mt(e,":"+t)||Mt(e,"v-bind:"+t);if(null!=n)return wt(n);if(!1!==r){var i=Mt(e,t);if(null!=i)return JSON.stringify(i)}}function Mt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Rt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Dt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var zt={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Mt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=It(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Lt,qt,Bt,Ut,Jt,Kt,Ht={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Mt(e,"style");r&&(e.staticStyle=JSON.stringify(ot(r)));var n=It(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Vt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),Wt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),Zt=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Xt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Gt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Qt="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Yt="((?:"+Qt+"\\:)?"+Qt+")",er=new RegExp("^<"+Yt),tr=/^\s*(\/?)>/,rr=new RegExp("^<\\/"+Yt+"[^>]*>"),nr=/^<!DOCTYPE [^>]+>/i,ir=/^<!\--/,or=/^<!\[/,ar=d("script,style,textarea",!0),sr={},cr={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},ur=/&(?:lt|gt|quot|amp|#39);/g,lr=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,fr=d("pre,textarea",!0),pr=function(e,t){return e&&fr(e)&&"\n"===t[0]};function dr(e,t){var r=t?lr:ur;return e.replace(r,(function(e){return cr[e]}))}function vr(e,t,r){var n=r||{},i=n.number,o="$$v",a=o;n.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var s=hr(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function hr(e,t){var r=function(e){if(e=e.trim(),Lt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Lt-1)return(Ut=e.lastIndexOf("."))>-1?{exp:e.slice(0,Ut),key:'"'+e.slice(Ut+1)+'"'}:{exp:e,key:null};qt=e,Ut=Jt=Kt=0;for(;!yr();)gr(Bt=mr())?_r(Bt):91===Bt&&br(Bt);return{exp:e.slice(0,Jt),key:e.slice(Jt+1,Kt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function mr(){return qt.charCodeAt(++Ut)}function yr(){return Ut>=Lt}function gr(e){return 34===e||39===e}function br(e){var t=1;for(Jt=Ut;!yr();)if(gr(e=mr()))_r(e);else if(91===e&&t++,93===e&&t--,0===t){Kt=Ut;break}}function _r(e){for(var t=e;!yr()&&(e=mr())!==t;);}var xr,wr,$r,Sr,kr,Or,Ar,Cr,Tr=/^@|^v-on:/,jr=/^v-|^@|^:|^#/,Fr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Pr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Nr=/^\(|\)$/g,Er=/^\[.*\]$/,Ir=/:(.*)$/,Mr=/^:|^\.|^v-bind:/,Rr=/\.[^.\]]+(?=[^\]]*$)/g,Dr=/^v-slot(:|$)|^#/,zr=/[\r\n]/,Lr=/[ \f\t\r\n]+/g,qr=g(r.default.decode);function Br(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Zr(t),rawAttrsMap:{},parent:r,children:[]}}function Ur(e,t){xr=t.warn||At,Or=t.isPreTag||A,Ar=t.mustUseProp||A,Cr=t.getTagNamespace||A,t.isReservedTag,$r=Ct(t.modules,"transformNode"),Sr=Ct(t.modules,"preTransformNode"),kr=Ct(t.modules,"postTransformNode"),wr=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=Jr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Hr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Hr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter((function(e){return!e.slotScope})),l(e),e.pre&&(s=!1),Or(e.tag)&&(c=!1);for(var f=0;f<kr.length;f++)kr[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||A,s=t.canBeLeftOpenTag||A,c=0;e;){if(r=e,n&&ar(n)){var u=0,l=n.toLowerCase(),f=sr[l]||(sr[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,(function(e,r,n){return u=n.length,ar(l)||"noscript"===l||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),pr(l,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""}));c+=e.length-p.length,e=p,O(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(ir.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),$(v+3);continue}}if(or.test(e)){var h=e.indexOf("]>");if(h>=0){$(h+2);continue}}var m=e.match(nr);if(m){$(m[0].length);continue}var y=e.match(rr);if(y){var g=c;$(y[0].length),O(y[1],g,c);continue}var b=S();if(b){k(b),pr(b.tagName,e)&&$(1);continue}}var _=void 0,x=void 0,w=void 0;if(d>=0){for(x=e.slice(d);!(rr.test(x)||er.test(x)||ir.test(x)||or.test(x)||(w=x.indexOf("<",1))<0);)d+=w,x=e.slice(d);_=e.substring(0,d)}d<0&&(_=e),_&&$(_.length),t.chars&&_&&t.chars(_,c-_.length,c)}if(e===r){t.chars&&t.chars(e);break}}function $(t){c+=t,e=e.substring(t)}function S(){var t=e.match(er);if(t){var r,n,i={tagName:t[1],attrs:[],start:c};for($(t[0].length);!(r=e.match(tr))&&(n=e.match(Gt)||e.match(Xt));)n.start=c,$(n[0].length),n.end=c,i.attrs.push(n);if(r)return i.unarySlash=r[1],$(r[0].length),i.end=c,i}}function k(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&Zt(r)&&O(n),s(r)&&n===r&&O(r));for(var u=a(r)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===r&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:dr(v,h)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:f,start:e.start,end:e.end}),n=r),t.start&&t.start(r,f,u,e.start,e.end)}function O(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}O()}(e,{warn:xr,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||Cr(e);ue&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Xr.test(n.name)||(n.name=n.name.replace(Gr,""),t.push(n))}return t}(o));var d,v=Br(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||de()||(v.forbidden=!0);for(var h=0;h<Sr.length;h++)v=Sr[h](v,t)||v;s||(!function(e){null!=Mt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Or(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Kr(v),function(e){var t=Mt(e,"v-if");if(t)e.if=t,Hr(e,{exp:t,block:e});else{null!=Mt(e,"v-else")&&(e.else=!0);var r=Mt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Mt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!ue||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u,l,f=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:qr(e):f.length?a?"condense"===a&&zr.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(Lr," ")),!s&&" "!==e&&(u=function(e,t){var r=t?Ot(t):St;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=wt(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,wr))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function Jr(e,t){var r,n;(n=It(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=It(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Mt(e,"scope"),e.slotScope=t||Mt(e,"slot-scope")):(t=Mt(e,"slot-scope"))&&(e.slotScope=t);var r=It(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||jt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Rt(e,Dr);if(n){var i=Vr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||"_empty_"}}else{var s=Rt(e,Dr);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=Vr(s),l=u.name,f=u.dynamic,p=c[l]=Br("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||"_empty_",e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=It(e,"name"))}(e),function(e){var t;(t=It(e,"is"))&&(e.component=t);null!=Mt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<$r.length;i++)e=$r[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,jr.test(n))if(e.hasBindings=!0,(a=Wr(n.replace(jr,"")))&&(n=n.replace(Rr,"")),Mr.test(n))n=n.replace(Mr,""),o=wt(o),(c=Er.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=_(n))&&(n="innerHTML"),a.camel&&!c&&(n=_(n)),a.sync&&(s=hr(o,"$event"),c?Et(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(Et(e,"update:"+_(n),s,null,!1,0,u[t]),$(n)!==_(n)&&Et(e,"update:"+$(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Ar(e.tag,e.attrsMap.type,n)?Tt(e,n,o,u[t],c):jt(e,n,o,u[t],c);else if(Tr.test(n))n=n.replace(Tr,""),(c=Er.test(n))&&(n=n.slice(1,-1)),Et(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(jr,"")).match(Ir),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Er.test(f)&&(f=f.slice(1,-1),c=!0)),Pt(e,n,i,o,f,c,a,u[t])}else jt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&Ar(e.tag,e.attrsMap.type,n)&&Tt(e,n,"true",u[t])}(e),e}function Kr(e){var t;if(t=Mt(e,"v-for")){var r=function(e){var t=e.match(Fr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(Nr,""),i=n.match(Pr);i?(r.alias=n.replace(Pr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&S(e,r)}}function Hr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Vr(e){var t=e.name.replace(Dr,"");return t||"#"!==e.name[0]&&(t="default"),Er.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Wr(e){var t=e.match(Rr);if(t){var r={};return t.forEach((function(e){r[e.slice(1)]=!0})),r}}function Zr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Xr=/^xmlns:NS\d+/,Gr=/^NS\d+:/;function Qr(e){return Br(e.tag,e.attrsList.slice(),e.parent)}var Yr=[zt,Ht,{preTransformNode:function(e,t){if("input"===e.tag){var r,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(r=It(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Mt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Mt(e,"v-else",!0),s=Mt(e,"v-else-if",!0),c=Qr(e);Kr(c),Ft(c,"type","checkbox"),Jr(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,Hr(c,{exp:c.if,block:c});var u=Qr(e);Mt(u,"v-for",!0),Ft(u,"type","radio"),Jr(u,t),Hr(c,{exp:"("+r+")==='radio'"+o,block:u});var l=Qr(e);return Mt(l,"v-for",!0),Ft(l,":type",r),Jr(l,t),Hr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var en={expectHTML:!0,modules:Yr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return vr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+hr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Et(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null",o=It(e,"true-value")||"true",a=It(e,"false-value")||"false";Tt(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Et(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+hr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+hr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+hr(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=It(e,"value")||"null";Tt(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),Et(e,"change",hr(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return vr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?"__r":"input",l="$event.target.value";s&&(l="$event.target.value.trim()");a&&(l="_n("+l+")");var f=hr(t,l);c&&(f="if($event.target.composing)return;"+f);Tt(e,"value","("+t+")"),Et(e,u,f,null,!0),(s||a)&&Et(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&Tt(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Tt(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:Vt,mustUseProp:function(e,t,r){return"value"===r&&R(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:Wt,isReservedTag:function(e){return nt(e)||it(e)},getTagNamespace:function(e){return it(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(Yr)},tn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,rn=/\([^)]*?\);*$/,nn=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,on={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},an={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},sn=function(e){return"if("+e+")return null;"},cn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:sn("$event.target !== $event.currentTarget"),ctrl:sn("!$event.ctrlKey"),shift:sn("!$event.shiftKey"),alt:sn("!$event.altKey"),meta:sn("!$event.metaKey"),left:sn("'button' in $event && $event.button !== 0"),middle:sn("'button' in $event && $event.button !== 1"),right:sn("'button' in $event && $event.button !== 2")};function un(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=ln(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function ln(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return ln(e)})).join(",")+"]";var t=nn.test(e.value),r=tn.test(e.value),n=nn.test(e.value.replace(rn,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(cn[s])o+=cn[s],on[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=sn(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(fn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function fn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=on[e],n=an[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var pn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:O},dn=function(e){this.options=e,this.warn=e.warn||At,this.transforms=Ct(e.modules,"transformCode"),this.dataGenFns=Ct(e.modules,"genData"),this.directives=S(S({},pn),e.directives);var t=e.isReservedTag||A;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function vn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return hn(e,t);if(e.once&&!e.onceProcessed)return mn(e,t);if(e.for&&!e.forProcessed)return bn(e,t);if(e.if&&!e.ifProcessed)return yn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=$n(e,t),i="_t("+r+(n?","+n:""),o=e.attrs||e.dynamicAttrs?An((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:_(e.name),value:e.value,dynamic:e.dynamic}}))):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:$n(t,r,!0);return"_c("+e+","+_n(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=_n(e,t));var i=e.inlineTemplate?null:$n(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return $n(e,t)||"void 0"}function hn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+vn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function mn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return yn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+vn(e,t)+","+t.onceId+++","+r+")":vn(e,t)}return hn(e,t)}function yn(e,t,r,n){return e.ifProcessed=!0,gn(e.ifConditions.slice(),t,r,n)}function gn(e,t,r,n){if(!e.length)return n||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+o(i.block)+":"+gn(e,t,r,n):""+o(i.block);function o(e){return r?r(e,t):e.once?mn(e,t):vn(e,t)}}function bn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||vn)(e,t)+"})"}function _n(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+An(e.attrs)+","),e.props&&(r+="domProps:"+An(e.props)+","),e.events&&(r+=un(e.events,!1)+","),e.nativeEvents&&(r+=un(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some((function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||xn(r)})),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&"_empty_"!==o.slotScope||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map((function(e){return wn(t[e],r)})).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":vn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+An(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function xn(e){return 1===e.type&&("slot"===e.tag||e.children.some(xn))}function wn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return yn(e,t,wn,"null");if(e.for&&!e.forProcessed)return bn(e,t,wn);var n="_empty_"===e.slotScope?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+($n(e,t)||"undefined")+":undefined":$n(e,t)||"undefined":vn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function $n(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||vn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if(Sn(i)||i.ifConditions&&i.ifConditions.some((function(e){return Sn(e.block)}))){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||kn;return"["+o.map((function(e){return u(e,t)})).join(",")+"]"+(c?","+c:"")}}function Sn(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function kn(e,t){return 1===e.type?vn(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):On(e)}function On(e){return"_v("+(2===e.type?e.expression:Cn(JSON.stringify(e.text)))+")"}function An(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=Cn(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function Cn(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Tn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function jn(e,t){return Tn.test(t)?(t=t.replace(/^'|'$/g,'"'),D(e)&&'"false"'!==t&&(t='"true"'),{type:Ln,value:q(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:qn,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var Fn,Pn=0,Nn=1,En=2,In=3,Mn=4;function Rn(e,t){e&&(Fn=t.isReservedTag||A,Dn(e,!0))}function Dn(e,t){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!Fn(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some((function(e){return"model"===e.name}))}(e)}(e))e.ssrOptimizability=Pn;else{var r=t||function(e){return 1===e.type&&e.directives&&e.directives.some((function(e){return!zn(e.name)}))}(e),n=function(t){t.ssrOptimizability!==Nn&&(e.ssrOptimizability=r?Mn:En)};if(r&&(e.ssrOptimizability=In),1===e.type){for(var i=0,o=e.children.length;i<o;i++){var a=e.children[i];Dn(a),n(a)}if(e.ifConditions)for(var s=1,c=e.ifConditions.length;s<c;s++){var u=e.ifConditions[s].block;Dn(u,t),n(u)}null==e.ssrOptimizability||!t&&(e.attrsMap["v-html"]||e.attrsMap["v-text"])?e.ssrOptimizability=Nn:e.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:Nn}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===Nn?n.push(a):(i(),r.push(a))}return i(),r}(e)}else e.ssrOptimizability=Nn}}var zn=d("text,html,show,on,bind,model,pre,cloak,once");var Ln=0,qn=2;function Bn(e,t){if(e.for&&!e.forProcessed)return bn(e,t,Bn);if(e.if&&!e.ifProcessed)return yn(e,t,Bn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===Nn?Hn(e,t):Jn(e,t)||"void 0";switch(e.ssrOptimizability){case Nn:return function(e,t){return"_ssrNode("+Vn(e,t)+")"}(e,t);case En:return function(e,t){var r=Jn(e,t,!0);return"_ssrNode("+Gn(Zn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case In:return Un(e,t,!0);case Mn:return Un(e,t,!1);default:return vn(e,t)}}function Un(e,t,r){var n=e.plain?void 0:_n(e,t),i=r?"["+Hn(e,t)+"]":Jn(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Jn(e,t,r){return $n(e,t,r,Bn,Kn)}function Kn(e,t){return 1===e.type?Bn(e,t):On(e)}function Hn(e,t){return e.children.length?"_ssrNode("+Gn(Xn(e,t))+")":""}function Vn(e,t){return"("+Gn(Wn(e,t))+")"}function Wn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:qn,value:bn(e,t,Vn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:qn,value:yn(e,t,Vn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Xn(e,t);var r=Zn(e,t),n=Xn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:Ln,value:"</"+e.tag+">"}];return r.concat(n,o)}function Zn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter((function(e){return"value"!==e.name})));break}}}(e,t);var n,i,o,a,s,c,u=[{type:Ln,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map((function(e){return jn(e.name,e.value)}))),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach((function(e){var n=e.name,i=e.value;n=V[n]||n.toLowerCase(),!H(n)||t&&t.some((function(e){return e.name===n}))||r.push(jn(n,i))})),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:qn,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:qn,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:Ln,value:' class="'+JSON.parse(n)+'"'}]:[{type:qn,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:qn,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:Ln,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:Ln,value:" "+t.options.scopeId}),u.push({type:Ln,value:">"}),u}function Xn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:qn,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])||"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:1,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,Wn(i,t));else if(2===i.type)r.push({type:1,value:i.expression});else if(3===i.type){var o=Z(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:Ln,value:o})}}return r}(e.children,t):[]}function Gn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===Ln?r+=o.value:1===o.type?(n(),t.push("_ssrEscape("+o.value+")")):o.type===qn&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}function Qn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),O}}function Yn(e){var t=Object.create(null);return function(r,n,i){(n=S({},n)).warn,delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Qn(a.render,c),s.staticRenderFns=a.staticRenderFns.map((function(e){return Qn(e,c)})),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ei,ti=(ei=function(e,t){var r=Ur(e.trim(),t);Rn(r,t);var n=function(e,t){var r=new dn(t);return{render:"with(this){return "+(e?Bn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=S(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=ei(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Yn(t)}})(en).compileToFunctions;function ri(e,t){if(q(e)){if(!B(t))return" "+e+'="'+e+'"'}else{if(D(e))return" "+e+'="'+Z(L(e,t))+'"';if(!B(t))return" "+e+'="'+Z(String(t))+'"'}return""}function ni(e,t){return"string"==typeof t||"number"==typeof t&&G[e]||0===t?e+":"+t+";":""}function ii(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function oi(e){return s(e)?[re(e)]:Array.isArray(e)?si(e):void 0}function ai(e){return o(e)&&o(e.text)&&!1===e.isComment}function si(e,t){var r,n,c,u,l=[];for(r=0;r<e.length;r++)i(n=e[r])||"boolean"==typeof n||(u=l[c=l.length-1],Array.isArray(n)?n.length>0&&(ai((n=si(n,(t||"")+"_"+r))[0])&&ai(u)&&(l[c]=re(u.text+n[0].text),n.shift()),l.push.apply(l,n)):s(n)?ai(u)?l[c]=re(u.text+n):""!==n&&l.push(re(n)):ai(n)&&ai(u)?l[c]=re(u.text+n.text):(a(e._isVList)&&o(n.tag)&&i(n.key)&&o(t)&&(n.key="__vlist"+t+"_"+r+"__"),l.push(n)));return l}var ci={_ssrEscape:Z,_ssrNode:function(e,t,r,n){return new ui(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(c(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:ri,_ssrAttrs:function(e){var t="";for(var r in e)K(r)||(t+=ri(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=V[r]||r.toLowerCase();H(n)&&(t+=ri(n,e[r]))}return t},_ssrClass:function(e,t){var r=et(e,t);return""===r?r:' class="'+Z(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&S(n,e);t&&S(n,st(t));r&&S(n,r);var i=function(e){var t="";for(var r in e){var n=e[r],i=$(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ni(i,n[o]);else t+=ni(i,n)}return t}(n);return""===i?i:" style="+JSON.stringify(Z(i))}};var ui=function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?ii(r):2===n?oi(r):r:void 0};var li=new he;function fi(e){pi(e,li),li.clear()}function pi(e,t){var r,n,i=Array.isArray(e);if(!(!i&&!c(e)||Object.isFrozen(e)||e instanceof Y)){if(e.__ob__){var o=e.__ob__.dep.id;if(t.has(o))return;t.add(o)}if(i)for(r=e.length;r--;)pi(e[r],t);else for(r=(n=Object.keys(e)).length;r--;)pi(e[n[r]],t)}}var di=g((function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}}));function vi(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return We(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)We(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function hi(e,t,r,n,i){if(o(t)){if(y(t,r))return e[r]=t[r],i||delete t[r],!0;if(y(t,n))return e[r]=t[n],i||delete t[n],!0}return!1}var mi;function yi(e,t,r,n,i,u){return(Array.isArray(r)||s(r))&&(i=n,n=r,r=void 0),a(u)&&(i=2),function(e,t,r,n,i){if(o(r)&&o(r.__ob__))return te();o(r)&&o(r.is)&&(t=r.is);if(!t)return te();Array.isArray(n)&&"function"==typeof n[0]&&((r=r||{}).scopedSlots={default:n[0]},n.length=0);2===i?n=oi(n):1===i&&(n=ii(n));var a,s;if("string"==typeof t){var u;s=e.$vnode&&e.$vnode.ns||ge.getTagNamespace(t),a=r&&r.pre||!o(u=qe(e.$options,"components",t))?new Y(t,r,n,void 0,void 0,e):eo(u,r,e,n,t)}else a=eo(t,r,e,n);return Array.isArray(a)?a:o(a)?(o(s)&&gi(a,s),o(r)&&function(e){c(e.style)&&fi(e.style);c(e.class)&&fi(e.class)}(r),a):te()}(e,t,r,n,i)}function gi(e,t,r){if(e.ns=t,"foreignObject"===e.tag&&(t=void 0,r=!0),o(e.children))for(var n=0,s=e.children.length;n<s;n++){var c=e.children[n];o(c.tag)&&(i(c.ns)||a(r)&&"svg"!==c.tag)&&gi(c,t,r)}}function bi(e,t){var r,n,i,a,s=null;if(Array.isArray(e)||"string"==typeof e)for(s=new Array(e.length),r=0,n=e.length;r<n;r++)s[r]=t(e[r],r);else if("number"==typeof e)for(s=new Array(e),r=0;r<e;r++)s[r]=t(r+1,r);else if(c(e))if(me&&e[Symbol.iterator]){s=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)s.push(t(l.value,s.length)),l=u.next()}else for(i=Object.keys(e),s=new Array(i.length),r=0,n=i.length;r<n;r++)a=i[r],s[r]=t(e[a],a,r);return o(s)||(s=[]),s._isVList=!0,s}function _i(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=S(S({},n),r)),i=o(r)||t):i=this.$slots[e]||t;var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function xi(e){return qe(this.$options,"filters",e)||C}function wi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function $i(e,t,r,n,i){var o=ge.keyCodes[t]||r;return i&&n&&!ge.keyCodes[t]?wi(i,n):o?wi(o,e):n?$(n)!==t:void 0}function Si(e,t,r,n,i){if(r)if(c(r)){var o;Array.isArray(r)&&(r=k(r));var a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||ge.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=_(a),u=$(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var s in r)a(s)}else;return e}function ki(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t||Ai(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n}function Oi(e,t,r){return Ai(e,"__once__"+t+(r?"_"+r:""),!0),e}function Ai(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&Ci(e[n],t+"_"+n,r);else Ci(e,t,r)}function Ci(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function Ti(e,t){if(t)if(l(t)){var r=e.on=e.on?S({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function ji(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?ji(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function Fi(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function Pi(e,t){return"string"==typeof e?t+e:e}function Ni(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(Ei)&&delete r[u];return r}function Ei(e){return e.isComment&&!e.asyncFactory||" "===e.text}function Ii(e,t,r){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==n&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Mi(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Ri(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ie(i,"$stable",a),ie(i,"$key",s),ie(i,"$hasNormal",o),i}function Mi(e,t,r){var n=function(){var e=arguments.length?r.apply(null,arguments):r({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:oi(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Ri(e,t){return function(){return e[t]}}function Di(e,t){mi.$on(e,t)}function zi(e,t){mi.$off(e,t)}function Li(e,t){var r=mi;return function n(){var i=t.apply(null,arguments);null!==i&&r.$off(e,n)}}function qi(e,t,r){mi=e,function(e,t,r,n,o,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=di(c),i(u)||(i(l)?(i(u.fns)&&(u=e[c]=vi(u,s)),a(f.once)&&(u=e[c]=o(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)i(e[c])&&n((f=di(c)).name,t[c],f.capture)}(t,r||{},Di,zi,Li,e),mi=void 0}function Bi(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Ui(e,t){if(t){if(e._directInactive=!1,Bi(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var r=0;r<e.$children.length;r++)Ui(e.$children[r]);Ki(e,"activated")}}function Ji(e,t){if(!(t&&(e._directInactive=!0,Bi(e))||e._inactive)){e._inactive=!0;for(var r=0;r<e.$children.length;r++)Ji(e.$children[r]);Ki(e,"deactivated")}}function Ki(e,t){we();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)We(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),$e()}var Hi=Date.now;if(ae&&!ue){var Vi=window.performance;Vi&&"function"==typeof Vi.now&&Hi()>document.createEvent("Event").timeStamp&&(Hi=function(){return Vi.now()})}function Wi(e){var t=e.options;if(e.super){var r=Wi(e.super);if(r!==e.superOptions){e.superOptions=r;var n=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(e);n&&S(e.extendOptions,n),(t=e.options=Le(r,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function Zi(e,t,r,i,o){var s,c=this,u=o.options;y(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=a(u._compiled),f=!l;this.data=e,this.props=t,this.children=r,this.parent=i,this.listeners=e.on||n,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=me?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||Ii(e.scopedSlots,c.$slots=Ni(r,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return Ii(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=Ii(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=yi(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return yi(s,e,t,r,n,f)}}function Xi(e,t,r,n,i){var o=function(e){var t=new Y(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Gi(e,t){for(var r in t)e[_(r)]=t[r]}!function(e){e._o=Oi,e._n=p,e._s=f,e._l=bi,e._t=_i,e._q=T,e._i=j,e._m=ki,e._f=xi,e._k=$i,e._b=Si,e._v=re,e._e=te,e._u=ji,e._g=Ti,e._d=Fi,e._p=Pi}(Zi.prototype);var Qi={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Qi.prepatch(r,r)}else{(e.componentInstance=to(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var r=t.componentOptions;!function(e,t,r,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==n&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||n,e.$listeners=r||n,t&&e.$options.props){Ce(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Be(d,v,t,e)}Ce(!0),e.$options.propsData=t}r=r||n;var h=e.$options._parentListeners;e.$options._parentListeners=r,qi(e,r,h),u&&(e.$slots=Ni(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,r.propsData,r.listeners,t,r.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Ki(r,"mounted")),e.data.keepAlive&&(t._isMounted?function(e){e._inactive=!1}(r):Ui(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?Ji(t,!0):t.$destroy())}},Yi=Object.keys(Qi);function eo(e,t,r,s,u){if(!i(e)){var l=r.$options._base;if(c(e)&&(e=l.extend(e)),"function"==typeof e){var f,p;if(i(e.cid)&&void 0===(e=a((p=f=e).error)&&o(p.errorComp)?p.errorComp:o(p.resolved)?p.resolved:a(p.loading)&&o(p.loadingComp)?p.loadingComp:void 0))return function(e,t,r,n,i){var o=te();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(f,t,r,s,u);t=t||{},Wi(e),o(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var i=t.on||(t.on={}),a=i[n],s=t.model.callback;o(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[n]=[s].concat(a)):i[n]=s}(e.options,t);var d=function(e,t,r){var n=t.options.props;if(!i(n)){var a={},s=e.attrs,c=e.props;if(o(s)||o(c))for(var u in n){var l=$(u);hi(a,c,u,l,!0)||hi(a,s,u,l,!1)}return a}}(t,e);if(a(e.options.functional))return function(e,t,r,i,a){var s=e.options,c={},u=s.props;if(o(u))for(var l in u)c[l]=Be(l,u,t||n);else o(r.attrs)&&Gi(c,r.attrs),o(r.props)&&Gi(c,r.props);var f=new Zi(r,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof Y)return Xi(p,r,f.parent,s);if(Array.isArray(p)){for(var d=oi(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Xi(d[h],r,f.parent,s);return v}}(e,d,t,r,s);var v=t.on;if(t.on=t.nativeOn,a(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Yi.length;r++){var n=Yi[r],i=t[n],o=Qi[n];i===o||i&&i._merged||(t[n]=i?ro(o,i):o)}}(t);var m=e.options.name||u;return new Y("vue-component-"+e.cid+(m?"-"+m:""),t,void 0,void 0,void 0,r,{Ctor:e,propsData:d,listeners:v,tag:u,children:s},f)}}}function to(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return o(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function ro(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var no=Object.create(null),io=function(e){no[e]||(no[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},oo=function(e,t){var r=t?undefined():"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},ao=function(e){var t=e.$options,r=t.render,n=t.template,o=t._scopeId;if(i(r)){if(!n)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=ti(n,{scopeId:o,warn:oo},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function so(e,t,r){var n=e.$options.serverPrefetch;if(o(n)){Array.isArray(n)||(n=[n]);try{for(var i=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&i.push(c)}return void Promise.all(i).then(t).catch(r)}catch(e){r(e)}}t()}function co(e,t,r){e.isString?function(e,t){var r=t.write,n=t.next;if(i(e.children)||0===e.children.length)r(e.open+(e.close||""),n);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,n)}}(e,r):o(e.componentOptions)?lo(e,t,r):o(e.tag)?function(e,t,r){var n=r.write,s=r.next;a(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs["data-server-rendered"]="true");e.fnOptions&&uo(e.fnOptions,n);var c=function(e,t){var r,n="<"+e.tag,a=t.directives,s=t.modules;i(e.data)&&vo(e)&&(e.data={});if(o(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=qe(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;o(e);)e.data&&e.data.directives&&(r=e.data.directives.find((function(e){return"show"===e.name})))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var d=0;d<s.length;d++){var v=s[d](e);v&&(n+=v)}}var h=t.activeInstance;o(h)&&h!==e.context&&o(r=h.$options._scopeId)&&(n+=" "+r);if(o(e.fnScopeId))n+=" "+e.fnScopeId;else for(;o(e);)o(r=e.context.$options._scopeId)&&(n+=" "+r),e=e.parent;return n+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))n(c,s);else if(i(e.children)||0===e.children.length)n(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),n(c,s)}}(e,t,r):a(e.isComment)?o(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=eo(n,o,e.asyncMeta.context,a,s);c?c.componentOptions?lo(c,t,r):Array.isArray(c)?(r.renderStates.push({type:"Fragment",children:c,rendered:0,total:c.length}),r.next()):co(c,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:Z(String(e.text)),r.next)}function uo(e,t){var r=e._ssrRegister;return t.caching&&o(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function lo(e,t,r){var n=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=uo(c.options,n);if(o(u)&&o(f)&&o(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void po(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;o(h)?h(v,(function(i){!0===i&&o(m)?m(v,(function(e){o(p)&&p(s),e.components.forEach((function(e){return e(s)})),n(e.html,a)})):fo(e,t,v,r)})):o(m)&&m(v,(function(i){o(i)?(o(p)&&p(s),i.components.forEach((function(e){return e(s)})),n(i.html,a)):fo(e,t,v,r)}))}else o(u)&&i(f)&&io("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),o(u)&&i(l)&&io('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),po(e,t,r)}function fo(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),po(e,t,n)}function po(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=to(e,r.activeInstance);ao(i);var o=r.done;so(i,(function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),co(o,t,r)}),o)}function vo(e){var t=e.parent;return o(t)&&(o(t.data)||vo(t))}function ho(e,t,r,n){return function(i,o,a,s){no=Object.create(null);var c=new bt({activeInstance:i,userContext:a,write:o,done:s,renderNode:co,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;S(t.prototype,ci),t.FunctionalRenderContext&&S(t.FunctionalRenderContext.prototype,ci)}}(i),ao(i);so(i,(function(){co(i._render(),!0,c)}),s)}}var mo=function(e){return/\.js(\?[^.]+)?$/.test(e)};function yo(){var e,t;return{promise:new Promise((function(r,n){e=r,t=n})),cb:function(r,n){if(r)return t(r);e(n||"")}}}var go=function(e){function t(t,r,n){e.call(this),this.started=!1,this.renderer=t,this.template=r,this.context=n||{},this.inject=t.inject}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(e.Transform),bo=require("lodash.template"),_o={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function xo(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach((function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];n&&n.forEach((function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}));return r}(r,e))})),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var wo=require("path"),$o=require("serialize-javascript"),So=function(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:bo(e.slice(0,r),_o),neck:bo(e.slice(r,n),_o),tail:bo(e.slice(n+t.length),_o)}}(t):t:null,this.serialize=e.serializer||function(e){return $o(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(ko),this.prefetchFiles=(r.async||[]).map(ko),this.mapFiles=xo(r)}};function ko(e){var t=e.replace(/\?.*/,""),r=wo.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:Oo(r)}}function Oo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}So.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach((function(r){e["render"+r]=t["render"+r].bind(t,e)})),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},So.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},So.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter((function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)}));return(i.length?i.map((function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'})).join(""):"")+(e.styles||"")},So.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},So.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},So.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map((function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""})).join(""):""},So.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map((function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)||function(e){return n&&n.some((function(t){return t.file===e}))}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'})).join("")}return""},So.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey;void 0===n&&(n="state");var i=r.windowKey;void 0===i&&(i="__INITIAL_STATE__");var o=this.serialize(e[n]),a=e.nonce?' nonce="'+e.nonce+'"':"";return e[n]?"<script"+a+">window."+i+"="+o+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},So.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter((function(e){var t=e.file;return mo(t)})),n=(this.getUsedAsyncFiles(e)||[]).filter((function(e){var t=e.file;return mo(t)}));return[r[0]].concat(n,r.slice(1)).map((function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'})).join("")}return""},So.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(ko)}return e._mappedFiles},So.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new go(this,this.parsedTemplate,e||{})};var Ao=require("vm"),Co=require("path"),To=require("resolve"),jo=require("module");function Fo(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function Po(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=jo.wrap(r),o=new Ao.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,(function(r){return r=Co.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=To.sync(r,{basedir:t}))):require(r)}),l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function No(e){if(l(e)){var t={};for(var r in e)t[r]=No(e[r]);return t}return Array.isArray(e)?e.slice():e}function Eo(e,t,r,n){var i,o,a=Po(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise((function(r){t._registeredComponents=new Set;var n=a(e,Fo(t));r("function"==typeof n?n(t):n)}))}:function(t){return void 0===t&&(t={}),new Promise((function(r){if(!i){var s="once"===n?Fo():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=No(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))}))}}var Io=require("source-map").SourceMapConsumer,Mo=/\(([^)]+\.js):(\d+):(\d+)\)$/;function Ro(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map((function(e){return function(e,t){var r=e.match(Mo),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(Mo,c)}return e}return e}(e,t)})).join("\n"))}var Do=require("fs"),zo=require("path"),Lo=require("stream").PassThrough,qo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Bo(e){return void 0===e&&(e={}),function(e){void 0===e&&(e={});var t=e.modules;void 0===t&&(t=[]);var r=e.directives;void 0===r&&(r={});var n=e.isUnaryTag;void 0===n&&(n=function(){return!1});var i=e.template,o=e.inject,a=e.cache,s=e.shouldPreload,c=e.shouldPrefetch,u=e.clientManifest,l=e.serializer,f=ho(t,r,n,a),p=new So({template:i,inject:o,shouldPreload:s,shouldPrefetch:c,clientManifest:u,serializer:l});return{renderToString:function(e,t,r){var n,o;"function"==typeof t&&(r=t,t={}),t&&p.bindRenderFns(t),r||(o=(n=yo()).promise,r=n.cb);var a="",s=yt((function(e){return a+=e,!1}),r);try{f(e,s,t,(function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),i)try{var n=p.render(a,t);"string"!=typeof n?n.then((function(e){return r(null,e)})).catch(r):r(null,n)}catch(e){r(e)}else r(null,a)}))}catch(e){r(e)}return o},renderToStream:function(e,t){t&&p.bindRenderFns(t);var r=new gt((function(r,n){f(e,r,t,n)}));if(i){if("function"==typeof i)throw new Error("function template is only supported in renderToString.");var n=p.createStream(t);if(r.on("error",(function(e){n.emit("error",e)})),r.pipe(n),t&&t.rendered){var o=t.rendered;r.once("beforeEnd",(function(){o(t)}))}return n}if(t&&t.rendered){var a=t.rendered;r.once("beforeEnd",(function(){a(t)}))}return r}}}(S(S({},e),{isUnaryTag:dt,canBeLeftOpenTag:vt,modules:ut,directives:S(pt,e.directives)}))}process.env.VUE_ENV="server";var Uo=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&zo.isAbsolute(t)){if(!Do.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||zo.dirname(t),t=Do.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach((function(r){t[r]=new Io(e[r])})),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(qo)}else{if("string"!=typeof t)throw new Error(qo);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=Eo(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=yo()).promise,t=r.cb),u(e).catch((function(e){Ro(e,o),t(e)})).then((function(r){r&&c.renderToString(r,e,(function(e,r){Ro(e,o),t(e,r)}))})),n},renderToStream:function(e){var t=new Lo;return u(e).catch((function(e){Ro(e,o),process.nextTick((function(){t.emit("error",e)}))})).then((function(n){if(n){var i=c.renderToStream(n,e);i.on("error",(function(e){Ro(e,o),t.emit("error",e)})),r&&r.template&&(i.on("beforeStart",(function(){t.emit("beforeStart")})),i.on("beforeEnd",(function(){t.emit("beforeEnd")}))),i.pipe(t)}})),t}}}}(Bo);exports.createBundleRenderer=Uo,exports.createRenderer=Bo;
\ No newline at end of file
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 0433736910b..956f6a74973 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -3,10 +3,12 @@
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
 
-var _a = require('chalk'), red = _a.red, yellow = _a.yellow;
+var ref = require('chalk');
+var red = ref.red;
+var yellow = ref.yellow;
 var prefix = "[vue-server-renderer-webpack-plugin]";
-(exports.warn = function (msg) { return console.error(red(prefix + " " + msg + "\n")); });
-(exports.tip = function (msg) { return console.log(yellow(prefix + " " + msg + "\n")); });
+(exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); });
+(exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); });
 var onEmit = function (compiler, name, hook) {
     if (compiler.hooks) {
         // Webpack >= 4.0.0
@@ -20,65 +22,64 @@ var onEmit = function (compiler, name, hook) {
 
 var hash = require('hash-sum');
 var uniq = require('lodash.uniq');
-var VueSSRClientPlugin = /** @class */ (function () {
-    function VueSSRClientPlugin(options) {
-        if (options === void 0) { options = {}; }
-        //@ts-expect-error
-        this.options = Object.assign({
-            filename: 'vue-ssr-client-manifest.json',
-        }, options);
-    }
-    VueSSRClientPlugin.prototype.apply = function (compiler) {
-        var _this = this;
-        onEmit(compiler, 'vue-client-plugin', function (compilation, cb) {
-            var stats = compilation.getStats().toJson();
-            var allFiles = uniq(stats.assets.map(function (a) { return a.name; }));
-            var initialFiles = uniq(Object.keys(stats.entrypoints)
-                .map(function (name) { return stats.entrypoints[name].assets; })
-                .reduce(function (assets, all) { return all.concat(assets); }, [])
-                .filter(function (file) { return isJS(file) || isCSS(file); }));
-            var asyncFiles = allFiles
-                .filter(function (file) { return isJS(file) || isCSS(file); })
-                .filter(function (file) { return initialFiles.indexOf(file) < 0; });
-            var manifest = {
-                publicPath: stats.publicPath,
-                all: allFiles,
-                initial: initialFiles,
-                async: asyncFiles,
-                modules: {
-                /* [identifier: string]: Array<index: number> */
-                },
-            };
-            var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
-            var fileToIndex = function (file) { return manifest.all.indexOf(file); };
-            stats.modules.forEach(function (m) {
-                // ignore modules duplicated in multiple chunks
-                if (m.chunks.length === 1) {
-                    var cid_1 = m.chunks[0];
-                    var chunk = stats.chunks.find(function (c) { return c.id === cid_1; });
-                    if (!chunk || !chunk.files) {
-                        return;
-                    }
-                    var id = m.identifier.replace(/\s\w+$/, ''); // remove appended hash
-                    var files_1 = (manifest.modules[hash(id)] = chunk.files.map(fileToIndex));
-                    // find all asset modules associated with the same chunk
-                    assetModules.forEach(function (m) {
-                        if (m.chunks.some(function (id) { return id === cid_1; })) {
-                            files_1.push.apply(files_1, m.assets.map(fileToIndex));
-                        }
-                    });
+var VueSSRClientPlugin = function VueSSRClientPlugin(options) {
+    if ( options === void 0 ) options = {};
+
+    //@ts-expect-error
+    this.options = Object.assign({
+        filename: 'vue-ssr-client-manifest.json',
+    }, options);
+};
+VueSSRClientPlugin.prototype.apply = function apply (compiler) {
+        var this$1 = this;
+
+    onEmit(compiler, 'vue-client-plugin', function (compilation, cb) {
+        var stats = compilation.getStats().toJson();
+        var allFiles = uniq(stats.assets.map(function (a) { return a.name; }));
+        var initialFiles = uniq(Object.keys(stats.entrypoints)
+            .map(function (name) { return stats.entrypoints[name].assets; })
+            .reduce(function (assets, all) { return all.concat(assets); }, [])
+            .filter(function (file) { return isJS(file) || isCSS(file); }));
+        var asyncFiles = allFiles
+            .filter(function (file) { return isJS(file) || isCSS(file); })
+            .filter(function (file) { return initialFiles.indexOf(file) < 0; });
+        var manifest = {
+            publicPath: stats.publicPath,
+            all: allFiles,
+            initial: initialFiles,
+            async: asyncFiles,
+            modules: {
+            /* [identifier: string]: Array<index: number> */
+            },
+        };
+        var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
+        var fileToIndex = function (file) { return manifest.all.indexOf(file); };
+        stats.modules.forEach(function (m) {
+            // ignore modules duplicated in multiple chunks
+            if (m.chunks.length === 1) {
+                var cid = m.chunks[0];
+                var chunk = stats.chunks.find(function (c) { return c.id === cid; });
+                if (!chunk || !chunk.files) {
+                    return;
                 }
-            });
-            var json = JSON.stringify(manifest, null, 2);
-            //@ts-expect-error
-            compilation.assets[_this.options.filename] = {
-                source: function () { return json; },
-                size: function () { return json.length; },
-            };
-            cb();
+                var id = m.identifier.replace(/\s\w+$/, ''); // remove appended hash
+                var files = (manifest.modules[hash(id)] = chunk.files.map(fileToIndex));
+                // find all asset modules associated with the same chunk
+                assetModules.forEach(function (m) {
+                    if (m.chunks.some(function (id) { return id === cid; })) {
+                        files.push.apply(files, m.assets.map(fileToIndex));
+                    }
+                });
+            }
         });
-    };
-    return VueSSRClientPlugin;
-}());
+        var json = JSON.stringify(manifest, null, 2);
+        //@ts-expect-error
+        compilation.assets[this$1.options.filename] = {
+            source: function () { return json; },
+            size: function () { return json.length; },
+        };
+        cb();
+    });
+};
 
 module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index 992fcfa0d92..191c3c0f762 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -2,10 +2,12 @@
 
 var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
 
-var _a = require('chalk'), red = _a.red, yellow = _a.yellow;
+var ref = require('chalk');
+var red = ref.red;
+var yellow = ref.yellow;
 var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = (exports.warn = function (msg) { return console.error(red(prefix + " " + msg + "\n")); });
-var tip = (exports.tip = function (msg) { return console.log(yellow(prefix + " " + msg + "\n")); });
+var warn = (exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); });
+var tip = (exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); });
 var validate = function (compiler) {
     if (compiler.options.target !== 'node') {
         warn('webpack config `target` should be "node".');
@@ -30,60 +32,59 @@ var onEmit = function (compiler, name, hook) {
     }
 };
 
-var VueSSRServerPlugin = /** @class */ (function () {
-    function VueSSRServerPlugin(options) {
-        if (options === void 0) { options = {}; }
-        //@ts-expect-error
-        this.options = Object.assign({
-            filename: 'vue-ssr-server-bundle.json',
-        }, options);
-    }
-    VueSSRServerPlugin.prototype.apply = function (compiler) {
-        var _this = this;
-        validate(compiler);
-        onEmit(compiler, 'vue-server-plugin', function (compilation, cb) {
-            var stats = compilation.getStats().toJson();
-            var entryName = Object.keys(stats.entrypoints)[0];
-            var entryInfo = stats.entrypoints[entryName];
-            if (!entryInfo) {
-                // #5553
-                return cb();
-            }
-            var entryAssets = entryInfo.assets.filter(isJS);
-            if (entryAssets.length > 1) {
-                throw new Error("Server-side bundle should have one single entry file. " +
-                    "Avoid using CommonsChunkPlugin in the server config.");
+var VueSSRServerPlugin = function VueSSRServerPlugin(options) {
+    if ( options === void 0 ) options = {};
+
+    //@ts-expect-error
+    this.options = Object.assign({
+        filename: 'vue-ssr-server-bundle.json',
+    }, options);
+};
+VueSSRServerPlugin.prototype.apply = function apply (compiler) {
+        var this$1 = this;
+
+    validate(compiler);
+    onEmit(compiler, 'vue-server-plugin', function (compilation, cb) {
+        var stats = compilation.getStats().toJson();
+        var entryName = Object.keys(stats.entrypoints)[0];
+        var entryInfo = stats.entrypoints[entryName];
+        if (!entryInfo) {
+            // #5553
+            return cb();
+        }
+        var entryAssets = entryInfo.assets.filter(isJS);
+        if (entryAssets.length > 1) {
+            throw new Error("Server-side bundle should have one single entry file. " +
+                "Avoid using CommonsChunkPlugin in the server config.");
+        }
+        var entry = entryAssets[0];
+        if (!entry || typeof entry !== 'string') {
+            throw new Error(("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?"));
+        }
+        var bundle = {
+            entry: entry,
+            files: {},
+            maps: {},
+        };
+        stats.assets.forEach(function (asset) {
+            if (isJS(asset.name)) {
+                bundle.files[asset.name] = compilation.assets[asset.name].source();
             }
-            var entry = entryAssets[0];
-            if (!entry || typeof entry !== 'string') {
-                throw new Error("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?");
+            else if (asset.name.match(/\.js\.map$/)) {
+                bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source());
             }
-            var bundle = {
-                entry: entry,
-                files: {},
-                maps: {},
-            };
-            stats.assets.forEach(function (asset) {
-                if (isJS(asset.name)) {
-                    bundle.files[asset.name] = compilation.assets[asset.name].source();
-                }
-                else if (asset.name.match(/\.js\.map$/)) {
-                    bundle.maps[asset.name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[asset.name].source());
-                }
-                // do not emit anything else for server
-                delete compilation.assets[asset.name];
-            });
-            var json = JSON.stringify(bundle, null, 2);
-            //@ts-expect-error
-            var filename = _this.options.filename;
-            compilation.assets[filename] = {
-                source: function () { return json; },
-                size: function () { return json.length; },
-            };
-            cb();
+            // do not emit anything else for server
+            delete compilation.assets[asset.name];
         });
-    };
-    return VueSSRServerPlugin;
-}());
+        var json = JSON.stringify(bundle, null, 2);
+        //@ts-expect-error
+        var filename = this$1.options.filename;
+        compilation.assets[filename] = {
+            source: function () { return json; },
+            size: function () { return json.length; },
+        };
+        cb();
+    });
+};
 
 module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index e90685dc0cc..aa82fa502be 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -230,11 +230,11 @@
   // Regular Expressions for parsing tags and attributes
   var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
   var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
   var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp("^<" + qnameCapture);
+  var startTagOpen = new RegExp(("^<" + qnameCapture));
   var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
   var doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
   var comment = /^<!\--/;
@@ -255,9 +255,7 @@
   var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
   var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) {
-      return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  };
+  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
   function decodeAttr(value, shouldDecodeNewlines) {
       var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
       return value.replace(re, function (match) { return decodingMap[match]; });
@@ -269,7 +267,7 @@
       var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
       var index = 0;
       var last, lastTag;
-      var _loop_1 = function () {
+      while (html) {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -283,7 +281,7 @@
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                           }
                           advance(commentEnd + 3);
-                          return "continue";
+                          continue;
                       }
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -291,14 +289,14 @@
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
-                          return "continue";
+                          continue;
                       }
                   }
                   // Doctype:
                   var doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
-                      return "continue";
+                      continue;
                   }
                   // End tag:
                   var endTagMatch = html.match(endTag);
@@ -306,7 +304,7 @@
                       var curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
-                      return "continue";
+                      continue;
                   }
                   // Start tag:
                   var startTagMatch = parseStartTag();
@@ -315,10 +313,10 @@
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                           advance(1);
                       }
-                      return "continue";
+                      continue;
                   }
               }
-              var text = void 0, rest = void 0, next = void 0;
+              var text = (void 0), rest = (void 0), next = (void 0);
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -345,18 +343,18 @@
               }
           }
           else {
-              var endTagLength_1 = 0;
-              var stackedTag_1 = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag_1] ||
-                  (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-              var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength_1 = endTag.length;
-                  if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+              var endTagLength = 0;
+              var stackedTag = lastTag.toLowerCase();
+              var reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                       text = text
                           .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                           .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                   }
-                  if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
                       text = text.slice(1);
                   }
                   if (options.chars) {
@@ -364,25 +362,20 @@
                   }
                   return '';
               });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag_1, index - endTagLength_1, index);
+              index += html.length - rest$1.length;
+              html = rest$1;
+              parseEndTag(stackedTag, index - endTagLength, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                       start: index + html.length,
                   });
               }
-              return "break";
+              break;
           }
-      };
-      while (html) {
-          var state_1 = _loop_1();
-          if (state_1 === "break")
-              { break; }
       }
       // Clean up any remaining tags
       parseEndTag();
@@ -399,7 +392,7 @@
                   start: index,
               };
               advance(start[0].length);
-              var end = void 0, attr = void 0;
+              var end, attr;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -482,7 +475,7 @@
               for (var i = stack.length - 1; i >= pos; i--) {
                   if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -518,7 +511,8 @@
    * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
    */
   function parseComponent(content, options) {
-      if (options === void 0) { options = {}; }
+      if ( options === void 0 ) options = {};
+
       var sfc = {
           template: null,
           script: null,
@@ -549,8 +543,10 @@
                   type: tag,
                   content: '',
                   start: end,
-                  attrs: attrs.reduce(function (cumulated, _a) {
-                      var name = _a.name, value = _a.value;
+                  attrs: attrs.reduce(function (cumulated, ref) {
+                      var name = ref.name;
+                      var value = ref.value;
+
                       cumulated[name] = value || true;
                       return cumulated;
                   }, {}),
@@ -654,7 +650,7 @@
       try {
           var opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function () {
+              get: function get() {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
@@ -691,24 +687,6 @@
       typeof Reflect !== 'undefined' &&
       isNative(Reflect.ownKeys);
   /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      /** @class */ ((function () {
-          function Set() {
-              this.set = Object.create(null);
-          }
-          Set.prototype.has = function (key) {
-              return this.set[key] === true;
-          };
-          Set.prototype.add = function (key) {
-              this.set[key] = true;
-          };
-          Set.prototype.clear = function () {
-              this.set = Object.create(null);
-          };
-          return Set;
-      })());
-  }
 
   var ASSET_TYPES = ['component', 'directive', 'filter'];
   var LIFECYCLE_HOOKS = [
@@ -808,19 +786,17 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole_1 = typeof console !== 'undefined';
-      var classifyRE_1 = /(?:^|[-_])(\w)/g;
-      var classify_1 = function (str) {
-          return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-      };
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
       warn$2 = function (msg, vm) {
           var trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole_1 && !config.silent) {
-              console.error("[Vue warn]: " + msg + trace);
+          if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
           }
       };
       tip = function (msg, vm) {
-          if (hasConsole_1 && !config.silent) {
+          if (hasConsole && !config.silent) {
               console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
           }
       };
@@ -843,10 +819,10 @@
               var match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-              (file && includeFile !== false ? " at " + file : ''));
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
       };
-      var repeat_1 = function (str, n) {
+      var repeat$1 = function (str, n) {
           var res = '';
           while (n) {
               if (n % 2 === 1)
@@ -880,15 +856,13 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) {
-                      return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                          ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                          : formatComponentName(vm));
-                  })
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
                       .join('\n'));
           }
           else {
-              return "\n\n(found in " + formatComponentName(vm) + ")";
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
           }
       };
   }
@@ -898,73 +872,67 @@
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = /** @class */ (function () {
-      function Dep() {
-          this.id = uid++;
-          this.subs = [];
+  var Dep = function Dep() {
+      this.id = uid++;
+      this.subs = [];
+  };
+  Dep.prototype.addSub = function addSub (sub) {
+      this.subs.push(sub);
+  };
+  Dep.prototype.removeSub = function removeSub (sub) {
+      remove(this.subs, sub);
+  };
+  Dep.prototype.depend = function depend () {
+      if (Dep.target) {
+          Dep.target.addDep(this);
       }
-      Dep.prototype.addSub = function (sub) {
-          this.subs.push(sub);
-      };
-      Dep.prototype.removeSub = function (sub) {
-          remove(this.subs, sub);
-      };
-      Dep.prototype.depend = function () {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      };
-      Dep.prototype.notify = function () {
-          // stabilize the subscriber list first
-          var subs = this.subs.slice();
-          for (var i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      };
-      return Dep;
-  }());
+  };
+  Dep.prototype.notify = function notify () {
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
+  };
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
 
-  var VNode = /** @class */ (function () {
-      function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      Object.defineProperty(VNode.prototype, "child", {
-          // DEPRECATED: alias for componentInstance for backwards compat.
-          /* istanbul ignore next */
-          get: function () {
-              return this.componentInstance;
-          },
-          enumerable: false,
-          configurable: true
-      });
-      return VNode;
-  }());
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
+  };
+
+  var prototypeAccessors = { child: { configurable: true } };
+  // DEPRECATED: alias for componentInstance for backwards compat.
+  /* istanbul ignore next */
+  prototypeAccessors.child.get = function () {
+      return this.componentInstance;
+  };
+
+  Object.defineProperties( VNode.prototype, prototypeAccessors );
 
   /*
    * not type checking this file because flow doesn't play well with
@@ -987,12 +955,9 @@
       // cache original method
       var original = arrayProto[method];
       def(arrayMethods, method, function mutator() {
-          var arguments$1 = arguments;
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
 
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments$1[_i];
-          }
           var result = original.apply(this, args);
           var ob = this.__ob__;
           var inserted;
@@ -1020,46 +985,43 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = /** @class */ (function () {
-      function Observer(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
+  var Observer = function Observer(value) {
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
           }
           else {
-              this.walk(value);
+              copyAugment(value, arrayMethods, arrayKeys);
           }
+          this.observeArray(value);
       }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      Observer.prototype.walk = function (obj) {
-          var keys = Object.keys(obj);
-          for (var i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      };
-      /**
-       * Observe a list of Array items.
-       */
-      Observer.prototype.observeArray = function (items) {
-          for (var i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      };
-      return Observer;
-  }());
+      else {
+          this.walk(value);
+      }
+  };
+  /**
+   * Walk through all properties and convert them into
+   * getter/setters. This method should only be called when
+   * value type is Object.
+   */
+  Observer.prototype.walk = function walk (obj) {
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive(obj, keys[i]);
+      }
+  };
+  /**
+   * Observe a list of Array items.
+   */
+  Observer.prototype.observeArray = function observeArray (items) {
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
+  };
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -1168,7 +1130,7 @@
    */
   function set(target, key, val) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+          warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -1199,7 +1161,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1374,14 +1336,14 @@
           { return childVal; }
       var ret = {};
       extend(ret, parentVal);
-      for (var key_1 in childVal) {
-          var parent_1 = ret[key_1];
-          var child = childVal[key_1];
-          if (parent_1 && !Array.isArray(parent_1)) {
-              parent_1 = [parent_1];
-          }
-          ret[key_1] = parent_1
-              ? parent_1.concat(child)
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
               : Array.isArray(child)
                   ? child
                   : [child];
@@ -1413,7 +1375,7 @@
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
           warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-              ("but got " + toRawType(value) + "."), vm);
+              "but got " + (toRawType(value)) + ".", vm);
       }
   }
 
@@ -1442,10 +1404,10 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter_1 = 1;
+      var counter = 1;
       var observer = new MutationObserver(flushCallbacks);
-      var textNode_1 = document.createTextNode(String(counter_1));
-      observer.observe(textNode_1, {
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
           characterData: true,
       });
   }
@@ -1582,9 +1544,7 @@
               if (c === 0x2f) {
                   // /
                   var j = i - 1;
-                  var p 
-                  // find first non-whitespace prev char
-                  = void 0;
+                  var p = (void 0);
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
@@ -1618,12 +1578,12 @@
       var i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return "_f(\"" + filter + "\")(" + exp + ")";
+          return ("_f(\"" + filter + "\")(" + exp + ")");
       }
       else {
-          var name_1 = filter.slice(0, i);
+          var name = filter.slice(0, i);
           var args = filter.slice(i + 1);
-          return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
       }
   }
 
@@ -1653,7 +1613,7 @@
           }
           // tag token
           var exp = parseFilters(match[1].trim());
-          tokens.push("_s(" + exp + ")");
+          tokens.push(("_s(" + exp + ")"));
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -1669,7 +1629,7 @@
 
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error("[Vue compiler]: " + msg);
+      console.error(("[Vue compiler]: " + msg));
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
@@ -1703,7 +1663,7 @@
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -1856,10 +1816,10 @@
   function genData$2(el) {
       var data = '';
       if (el.staticClass) {
-          data += "staticClass:" + el.staticClass + ",";
+          data += "staticClass:" + (el.staticClass) + ",";
       }
       if (el.classBinding) {
-          data += "class:" + el.classBinding + ",";
+          data += "class:" + (el.classBinding) + ",";
       }
       return data;
   }
@@ -1906,10 +1866,10 @@
   function genData$1(el) {
       var data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + el.staticStyle + ",";
+          data += "staticStyle:" + (el.staticStyle) + ",";
       }
       if (el.styleBinding) {
-          data += "style:(" + el.styleBinding + "),";
+          data += "style:(" + (el.styleBinding) + "),";
       }
       return data;
   }
@@ -2271,23 +2231,25 @@
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+      var ref = modifiers || {};
+      var number = ref.number;
+      var trim = ref.trim;
       var baseValueExpression = '$$v';
       var valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
               "(typeof " + baseValueExpression + " === 'string'" +
-                  ("? " + baseValueExpression + ".trim()") +
-                  (": " + baseValueExpression + ")");
+                  "? " + baseValueExpression + ".trim()" +
+                  ": " + baseValueExpression + ")";
       }
       if (number) {
           valueExpression = "_n(" + valueExpression + ")";
       }
       var assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: "(" + value + ")",
+          value: ("(" + value + ")"),
           expression: JSON.stringify(value),
-          callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
       };
   }
   /**
@@ -2296,10 +2258,10 @@
   function genAssignmentCode(value, assignment) {
       var res = parseModel(value);
       if (res.key === null) {
-          return value + "=" + assignment;
+          return (value + "=" + assignment);
       }
       else {
-          return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
       }
   }
   /**
@@ -2438,7 +2400,10 @@
       platformMustUseProp = options.mustUseProp || no;
       platformGetTagNamespace = options.getTagNamespace || no;
       var isReservedTag = options.isReservedTag || no;
-      maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      maybeComponent = function (el) { return !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
       transforms = pluckModuleFunction(options.modules, 'transformNode');
       preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
       postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -2489,8 +2454,8 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name_1 = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                      var name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                   }
                   currentParent.children.push(element);
                   element.parent = currentParent;
@@ -2516,7 +2481,7 @@
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode = void 0;
+              var lastNode;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -2526,7 +2491,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -2543,7 +2508,7 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function (tag, attrs, unary, start, end) {
+          start: function start(tag, attrs, unary, start$1, end) {
               // check namespace.
               // inherit parent ns if there is one
               var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -2558,7 +2523,7 @@
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start;
+                      element.start = start$1;
                       element.end = end;
                       element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                           cumulated[attr.name] = attr;
@@ -2579,7 +2544,7 @@
                   element.forbidden = true;
                   warn$1('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          ("<" + tag + ">") +
+                          "<" + tag + ">" +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
@@ -2618,24 +2583,24 @@
                   closeElement(element);
               }
           },
-          end: function (tag, start, end) {
+          end: function end(tag, start, end$1) {
               var element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end;
+                  element.end = end$1;
               }
               closeElement(element);
           },
-          chars: function (text, start, end) {
+          chars: function chars(text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
                           warnOnce('Component template requires a root element, rather than just text.', { start: start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                               start: start,
                           });
                       }
@@ -2675,8 +2640,8 @@
                       // condense consecutive whitespaces into single space
                       text = text.replace(whitespaceRE, ' ');
                   }
-                  var res = void 0;
-                  var child = void 0;
+                  var res;
+                  var child;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
@@ -2702,7 +2667,7 @@
                   }
               }
           },
-          comment: function (text, start, end) {
+          comment: function comment(text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
@@ -2772,11 +2737,11 @@
               }
               if (el.for) {
                   var iterator = el.iterator2 || el.iterator1;
-                  var parent_1 = el.parent;
+                  var parent = el.parent;
                   if (iterator &&
                       iterator === exp &&
-                      parent_1 &&
-                      parent_1.tag === 'transition-group') {
+                      parent &&
+                      parent.tag === 'transition-group') {
                       warn$1("Do not use v-for index as key on <transition-group> children, " +
                           "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                   }
@@ -2800,7 +2765,7 @@
               extend(el, res);
           }
           else {
-              warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
           }
       }
   }
@@ -2853,7 +2818,7 @@
       }
       else {
           warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
@@ -2864,7 +2829,7 @@
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                       "will be ignored.", children[i]);
               }
               children.pop();
@@ -2901,7 +2866,7 @@
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                   "(v-for takes higher priority). Use a wrapper <template> for the " +
                   "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
           }
@@ -2933,41 +2898,45 @@
                               "the receiving component", el);
                       }
                   }
-                  var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                  el.slotTarget = name_2;
+                  var ref = getSlotName(slotBinding);
+                  var name = ref.name;
+                  var dynamic = ref.dynamic;
+                  el.slotTarget = name;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
               }
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
+              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding$1) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                       }
                       if (el.slotScope || el.slotTarget) {
                           warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                       }
                       if (el.scopedSlots) {
                           warn$1("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding);
+                              "<template> syntax when there are other named slots.", slotBinding$1);
                       }
                   }
                   // add the component's children to its default slot
                   var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                  var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                  slotContainer_1.slotTarget = name_3;
-                  slotContainer_1.slotTargetDynamic = dynamic;
-                  slotContainer_1.children = el.children.filter(function (c) {
+                  var ref$1 = getSlotName(slotBinding$1);
+                  var name$1 = ref$1.name;
+                  var dynamic$1 = ref$1.dynamic;
+                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name$1;
+                  slotContainer.slotTargetDynamic = dynamic$1;
+                  slotContainer.children = el.children.filter(function (c) {
                       if (!c.slotScope) {
-                          c.parent = slotContainer_1;
+                          c.parent = slotContainer;
                           return true;
                       }
                   });
-                  slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -2990,7 +2959,7 @@
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: "\"" + name + "\"", dynamic: false };
+              { name: ("\"" + name + "\""), dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
@@ -3036,7 +3005,7 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
@@ -3050,14 +3019,14 @@
                       if (modifiers.sync) {
                           syncGen = genAssignmentCode(value, "$event");
                           if (!isDynamic) {
-                              addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                               );
                           }
                       }
@@ -3134,11 +3103,11 @@
   function parseModifiers(name) {
       var match = name.match(modifierRE);
       if (match) {
-          var ret_1 = {};
+          var ret = {};
           match.forEach(function (m) {
-              ret_1[m.slice(1)] = true;
+              ret[m.slice(1)] = true;
           });
-          return ret_1;
+          return ret;
       }
   }
   function makeAttrsMap(attrs) {
@@ -3180,7 +3149,7 @@
       var _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                   "You are binding v-model directly to a v-for iteration alias. " +
                   "This will not be able to modify the v-for source array because " +
                   "writing to the alias is like modifying a function local variable. " +
@@ -3205,16 +3174,16 @@
           if (!map['v-model']) {
               return;
           }
-          var typeBinding = void 0;
+          var typeBinding;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + map['v-bind'] + ").type";
+              typeBinding = "(" + (map['v-bind']) + ").type";
           }
           if (typeBinding) {
               var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
               var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
               var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
@@ -3280,7 +3249,7 @@
           // inputs with type="file" are read only and setting the input's
           // value will throw an error.
           if (tag === 'input' && type === 'file') {
-              warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+              warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                   "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
           }
       }
@@ -3315,25 +3284,25 @@
       var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
       var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
       addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          ("?_i(" + value + "," + valueBinding + ")>-1") +
+          "?_i(" + value + "," + valueBinding + ")>-1" +
           (trueValueBinding === 'true'
-              ? ":(" + value + ")"
-              : ":_q(" + value + "," + trueValueBinding + ")"));
+              ? (":(" + value + ")")
+              : (":_q(" + value + "," + trueValueBinding + ")")));
       addHandler(el, 'change', "var $$a=" + value + "," +
           '$$el=$event.target,' +
-          ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
           'if(Array.isArray($$a)){' +
-          ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
           '$$i=_i($$a,$$v);' +
-          ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-          ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-          ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
   }
   function genRadioModel(el, value, modifiers) {
       var number = modifiers && modifiers.number;
       var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-      addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
       addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
   }
   function genSelect(el, value, modifiers) {
@@ -3341,10 +3310,10 @@
       var selectedVal = "Array.prototype.filter" +
           ".call($event.target.options,function(o){return o.selected})" +
           ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          ("return " + (number ? '_n(val)' : 'val') + "})");
+          "return " + (number ? '_n(val)' : 'val') + "})";
       var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
       var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + genAssignmentCode(value, assignment);
+      code = code + " " + (genAssignmentCode(value, assignment));
       addHandler(el, 'change', code, null, true);
   }
   function genDefaultModel(el, value, modifiers) {
@@ -3352,15 +3321,18 @@
       // warn if v-bind:value conflicts with v-model
       // except for inputs with v-bind:type
       {
-          var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
           var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value_1 && !typeBinding) {
+          if (value$1 && !typeBinding) {
               var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+              warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                   'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
           }
       }
-      var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+      var ref = modifiers || {};
+      var lazy = ref.lazy;
+      var number = ref.number;
+      var trim = ref.trim;
       var needCompositionGuard = !lazy && type !== 'range';
       var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
       var valueExpression = '$event.target.value';
@@ -3374,7 +3346,7 @@
       if (needCompositionGuard) {
           code = "if($event.target.composing)return;" + code;
       }
-      addProp(el, 'value', "(" + value + ")");
+      addProp(el, 'value', ("(" + value + ")"));
       addHandler(el, event, code, null, true);
       if (trim || number) {
           addHandler(el, 'blur', '$forceUpdate()');
@@ -3383,13 +3355,13 @@
 
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
       }
   }
 
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
       }
   }
 
@@ -3473,8 +3445,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                  var block = node.ifConditions[i].block;
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
                   markStatic(block);
                   if (!block.static) {
                       node.static = false;
@@ -3506,8 +3478,8 @@
               }
           }
           if (node.ifConditions) {
-              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                  markStaticRoots(node.ifConditions[i].block, isInFor);
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
               }
           }
       }
@@ -3577,7 +3549,7 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
   var modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
@@ -3594,19 +3566,19 @@
       var prefix = isNative ? 'nativeOn:' : 'on:';
       var staticHandlers = "";
       var dynamicHandlers = "";
-      for (var name_1 in events) {
-          var handlerCode = genHandler(events[name_1]);
+      for (var name in events) {
+          var handlerCode = genHandler(events[name]);
           //@ts-expect-error
-          if (events[name_1] && events[name_1].dynamic) {
-              dynamicHandlers += name_1 + "," + handlerCode + ",";
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += name + "," + handlerCode + ",";
           }
           else {
-              staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
           }
       }
-      staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
       if (dynamicHandlers) {
-          return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
       }
       else {
           return prefix + staticHandlers;
@@ -3617,7 +3589,7 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
       }
       var isMethodPath = simplePathRE.test(handler.value);
       var isFunctionExpression = fnExpRE.test(handler.value);
@@ -3626,13 +3598,13 @@
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
       }
       else {
           var code = '';
           var genModifierCode = '';
           var keys = [];
-          var _loop_1 = function (key) {
+          for (var key in handler.modifiers) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -3641,18 +3613,15 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers_1 = handler.modifiers;
+                  var modifiers = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                      .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                       .join('||'));
               }
               else {
                   keys.push(key);
               }
-          };
-          for (var key in handler.modifiers) {
-              _loop_1(key);
           }
           if (keys.length) {
               code += genKeyFilter(keys);
@@ -3662,13 +3631,13 @@
               code += genModifierCode;
           }
           var handlerCode = isMethodPath
-              ? "return " + handler.value + ".apply(null, arguments)"
+              ? ("return " + (handler.value) + ".apply(null, arguments)")
               : isFunctionExpression
-                  ? "return (" + handler.value + ").apply(null, arguments)"
+                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
                   : isFunctionInvocation
-                      ? "return " + handler.value
+                      ? ("return " + (handler.value))
                       : handler.value;
-          return "function($event){" + code + handlerCode + "}";
+          return ("function($event){" + code + handlerCode + "}");
       }
   }
   function genKeyFilter(keys) {
@@ -3677,20 +3646,20 @@
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
       "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&') + ")return null;"));
+          (keys.map(genFilterCode).join('&&')) + ")return null;");
   }
   function genFilterCode(key) {
       var keyVal = parseInt(key, 10);
       if (keyVal) {
-          return "$event.keyCode!==" + keyVal;
+          return ("$event.keyCode!==" + keyVal);
       }
       var keyCode = keyCodes[key];
       var keyName = keyNames[key];
       return ("_k($event.keyCode," +
-          (JSON.stringify(key) + ",") +
-          (JSON.stringify(keyCode) + ",") +
+          (JSON.stringify(key)) + "," +
+          (JSON.stringify(keyCode)) + "," +
           "$event.key," +
-          ("" + JSON.stringify(keyName)) +
+          "" + (JSON.stringify(keyName)) +
           ")");
   }
 
@@ -3698,12 +3667,12 @@
       if (dir.modifiers) {
           warn$2("v-on without argument does not support modifiers.");
       }
-      el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
   }
 
   function bind(el, dir) {
       el.wrapData = function (code) {
-          return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
       };
   }
 
@@ -3713,24 +3682,19 @@
       cloak: noop,
   };
 
-  var CodegenState = /** @class */ (function () {
-      function CodegenState(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          var isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = function (el) {
-              return !!el.component || !isReservedTag(el.tag);
-          };
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-      return CodegenState;
-  }());
+  var CodegenState = function CodegenState(options) {
+      this.options = options;
+      this.warn = options.warn || baseWarn;
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+      this.directives = extend(extend({}, baseDirectives), options.directives);
+      var isReservedTag = options.isReservedTag || no;
+      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+      this.onceId = 0;
+      this.staticRenderFns = [];
+      this.pre = false;
+  };
   function generate$1(ast, options) {
       var state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
@@ -3740,7 +3704,7 @@
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: "with(this){return " + code + "}",
+          render: ("with(this){return " + code + "}"),
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -3768,19 +3732,17 @@
       }
       else {
           // component or element
-          var code = void 0;
+          var code;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data = void 0;
+              var data;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
                   data = genData(el, state);
               }
               var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-              ) + (children ? "," + children : '' // children
-              ) + ")";
+              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
           }
           // module transforms
           for (var i = 0; i < state.transforms.length; i++) {
@@ -3799,9 +3761,9 @@
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
       state.pre = originalPreState;
-      return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
   }
   // v-once
   function genOnce(el, state) {
@@ -3811,19 +3773,19 @@
       }
       else if (el.staticInFor) {
           var key = '';
-          var parent_1 = el.parent;
-          while (parent_1) {
-              if (parent_1.for) {
-                  key = parent_1.key;
+          var parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
                   break;
               }
-              parent_1 = parent_1.parent;
+              parent = parent.parent;
           }
           if (!key) {
               state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
       }
       else {
           return genStatic(el, state);
@@ -3839,10 +3801,10 @@
       }
       var condition = conditions.shift();
       if (condition.exp) {
-          return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
       }
       else {
-          return "" + genTernaryExp(condition.block);
+          return ("" + (genTernaryExp(condition.block)));
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -3856,20 +3818,20 @@
   function genFor(el, state, altGen, altHelper) {
       var exp = el.for;
       var alias = el.alias;
-      var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-      var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
               "v-for should have explicit keys. " +
               "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ((altHelper || '_l') + "((" + exp + ")," +
-          ("function(" + alias + iterator1 + iterator2 + "){") +
-          ("return " + (altGen || genElement)(el, state)) +
+          "function(" + alias + iterator1 + iterator2 + "){" +
+          "return " + ((altGen || genElement)(el, state)) +
           '})');
   }
   function genData(el, state) {
@@ -3881,11 +3843,11 @@
           { data += dirs + ','; }
       // key
       if (el.key) {
-          data += "key:" + el.key + ",";
+          data += "key:" + (el.key) + ",";
       }
       // ref
       if (el.ref) {
-          data += "ref:" + el.ref + ",";
+          data += "ref:" + (el.ref) + ",";
       }
       if (el.refInFor) {
           data += "refInFor:true,";
@@ -3896,7 +3858,7 @@
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + el.tag + "\",";
+          data += "tag:\"" + (el.tag) + "\",";
       }
       // module data generation functions
       for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -3904,31 +3866,31 @@
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + genProps(el.attrs) + ",";
+          data += "attrs:" + (genProps(el.attrs)) + ",";
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + genProps(el.props) + ",";
+          data += "domProps:" + (genProps(el.props)) + ",";
       }
       // event handlers
       if (el.events) {
-          data += genHandlers(el.events, false) + ",";
+          data += (genHandlers(el.events, false)) + ",";
       }
       if (el.nativeEvents) {
-          data += genHandlers(el.nativeEvents, true) + ",";
+          data += (genHandlers(el.nativeEvents, true)) + ",";
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + el.slotTarget + ",";
+          data += "slot:" + (el.slotTarget) + ",";
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += genScopedSlots(el, el.scopedSlots, state) + ",";
+          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
       }
       // inline-template
       if (el.inlineTemplate) {
@@ -3942,7 +3904,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -3972,9 +3934,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                  ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                  : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
           }
       }
       if (hasRuntime) {
@@ -3988,9 +3950,9 @@
       }
       if (ast && ast.type === 1) {
           var inlineRenderFns = generate$1(ast, state.options);
-          return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-              .map(function (code) { return "function(){" + code + "}"; })
-              .join(',') + "]}";
+          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+              .map(function (code) { return ("function(){" + code + "}"); })
+              .join(',')) + "]}");
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -4015,23 +3977,23 @@
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent_2 = el.parent;
-          while (parent_2) {
-              if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                  parent_2.for) {
+          var parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
                   needsForceUpdate = true;
                   break;
               }
-              if (parent_2.if) {
+              if (parent.if) {
                   needsKey = true;
               }
-              parent_2 = parent_2.parent;
+              parent = parent.parent;
           }
       }
       var generatedSlots = Object.keys(slots)
           .map(function (key) { return genScopedSlot(slots[key], state); })
           .join(',');
-      return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
   }
   function hash(str) {
       var hash = 5381;
@@ -4060,36 +4022,36 @@
       }
       var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
       var fn = "function(" + slotScope + "){" +
-          ("return " + (el.tag === 'template'
+          "return " + (el.tag === 'template'
               ? el.if && isLegacySyntax
-                  ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                   : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}");
+              : genElement(el, state)) + "}";
       // reverse proxy v-slot without scope on this.$slots
       var reverseProxy = slotScope ? "" : ",proxy:true";
-      return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
       var children = el.children;
       if (children.length) {
-          var el_1 = children[0];
+          var el$1 = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el_1.for &&
-              el_1.tag !== 'template' &&
-              el_1.tag !== 'slot') {
-              var normalizationType_1 = checkSkip
-                  ? state.maybeComponent(el_1)
+              el$1.for &&
+              el$1.tag !== 'template' &&
+              el$1.tag !== 'slot') {
+              var normalizationType = checkSkip
+                  ? state.maybeComponent(el$1)
                       ? ",1"
                       : ",0"
                   : "";
-              return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
           }
-          var normalizationType = checkSkip
+          var normalizationType$1 = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen_1 = altGenNode || genNode;
-          return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+          var gen = altGenNode || genNode;
+          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
       }
   }
   // determine the normalization needed for the children array.
@@ -4131,17 +4093,17 @@
       }
   }
   function genText(text) {
-      return "_v(" + (text.type === 2
+      return ("_v(" + (text.type === 2
           ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
   }
   function genComment(comment) {
-      return "_e(" + JSON.stringify(comment.text) + ")";
+      return ("_e(" + (JSON.stringify(comment.text)) + ")");
   }
   function genSlot(el, state) {
       var slotName = el.slotName || '"default"';
       var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? "," + children : '');
+      var res = "_t(" + slotName + (children ? ("," + children) : '');
       var attrs = el.attrs || el.dynamicAttrs
           ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
               // slot props are camelized
@@ -4165,7 +4127,7 @@
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
       var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+      return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
   }
   function genProps(props) {
       var staticProps = "";
@@ -4174,15 +4136,15 @@
           var prop = props[i];
           var value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += prop.name + "," + value + ",";
+              dynamicProps += (prop.name) + "," + value + ",";
           }
           else {
-              staticProps += "\"" + prop.name + "\":" + value + ",";
+              staticProps += "\"" + (prop.name) + "\":" + value + ",";
           }
       }
-      staticProps = "{" + staticProps.slice(0, -1) + "}";
+      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
       if (dynamicProps) {
-          return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
       }
       else {
           return staticProps;
@@ -4216,22 +4178,22 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name_1 in node.attrsMap) {
-              if (dirRE.test(name_1)) {
-                  var value = node.attrsMap[name_1];
+          for (var name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  var value = node.attrsMap[name];
                   if (value) {
-                      var range = node.rawAttrsMap[name_1];
-                      if (name_1 === 'v-for') {
-                          checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                      var range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                       }
-                      else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                          checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                       }
-                      else if (onRE.test(name_1)) {
-                          checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                      else if (onRE.test(name)) {
+                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                       }
                       else {
-                          checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                       }
                   }
               }
@@ -4251,7 +4213,7 @@
       var keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
           warn("avoid using JavaScript unary operator as property name: " +
-              ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -4264,16 +4226,16 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function("var " + ident + "=_");
+              new Function(("var " + ident + "=_"));
           }
           catch (e) {
-              warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function("return " + exp);
+          new Function(("return " + exp));
       }
       catch (e) {
           var keywordMatch = exp
@@ -4281,12 +4243,12 @@
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
               warn("avoid using JavaScript keyword as property name: " +
-                  ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
           }
           else {
-              warn("invalid expression: " + e.message + " in\n\n" +
-                  ("    " + exp + "\n\n") +
-                  ("  Raw expression: " + text.trim() + "\n"), range);
+              warn("invalid expression: " + (e.message) + " in\n\n" +
+                  "    " + exp + "\n\n" +
+                  "  Raw expression: " + (text.trim()) + "\n", range);
           }
       }
   }
@@ -4295,16 +4257,17 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + e.message + " in\n\n" +
-              ("    " + exp + "\n\n") +
-              ("  Raw expression: " + text.trim() + "\n"), range);
+          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+              "    " + exp + "\n\n" +
+              "  Raw expression: " + (text.trim()) + "\n", range);
       }
   }
 
   var range = 2;
   function generateCodeFrame(source, start, end) {
-      if (start === void 0) { start = 0; }
-      if (end === void 0) { end = source.length; }
+      if ( start === void 0 ) start = 0;
+      if ( end === void 0 ) end = source.length;
+
       var lines = source.split(/\r?\n/);
       var count = 0;
       var res = [];
@@ -4314,18 +4277,18 @@
               for (var j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
                       { continue; }
-                  res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                  res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                   var lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
                       var pad = start - (count - lineLength) + 1;
-                      var length_1 = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                      var length = end > count ? lineLength - pad : end - start;
+                      res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length_2 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat("^", length_2));
+                          var length$1 = Math.min(end - count, lineLength);
+                          res.push("   |  " + repeat("^", length$1));
                       }
                       count += lineLength + 1;
                   }
@@ -4397,13 +4360,13 @@
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
                       compiled.errors.forEach(function (e) {
-                          warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                          warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
                       warn("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                           '\n', vm);
                   }
               }
@@ -4431,10 +4394,12 @@
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                   warn("Failed to generate render function:\n\n" +
                       fnGenErrors
-                          .map(function (_a) {
-                          var err = _a.err, code = _a.code;
-                          return err.toString() + " in\n\n" + code + "\n";
-                      })
+                          .map(function (ref) {
+                              var err = ref.err;
+                              var code = ref.code;
+
+                              return ((err.toString()) + " in\n\n" + code + "\n");
+                  })
                           .join('\n'), vm);
               }
           }
@@ -4454,15 +4419,15 @@
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
                       warn = function (msg, range, tip) {
                           var data = { msg: msg };
                           if (range) {
                               if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength_1;
+                                  data.start = range.start + leadingSpaceLength;
                               }
                               if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength_1;
+                                  data.end = range.end + leadingSpaceLength;
                               }
                           }
                           (tip ? tips : errors).push(data);
@@ -4515,7 +4480,9 @@
       };
   });
 
-  var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
+  var ref$1 = createCompiler$1(baseOptions);
+  var compile$1 = ref$1.compile;
+  var compileToFunctions$1 = ref$1.compileToFunctions;
 
   var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
       'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
@@ -4586,15 +4553,19 @@
       }
   }
   function genAttrSegments(attrs) {
-      return attrs.map(function (_a) {
-          var name = _a.name, value = _a.value;
+      return attrs.map(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
+
           return genAttrSegment(name, value);
       });
   }
   function genDOMPropSegments(props, attrs) {
       var segments = [];
-      props.forEach(function (_a) {
-          var name = _a.name, value = _a.value;
+      props.forEach(function (ref) {
+          var name = ref.name;
+          var value = ref.value;
+
           name = propsToAttrMap[name] || name.toLowerCase();
           if (isRenderableAttr(name) &&
               !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -4614,42 +4585,42 @@
           return {
               type: RAW,
               value: isBooleanAttr(name)
-                  ? " " + name + "=\"" + name + "\""
+                  ? (" " + name + "=\"" + name + "\"")
                   : value === '""'
-                      ? " " + name
-                      : " " + name + "=\"" + JSON.parse(value) + "\"",
+                      ? (" " + name)
+                      : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
           };
       }
       else {
           return {
               type: EXPRESSION,
-              value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
+              value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
           };
       }
   }
   function genClassSegments(staticClass, classBinding) {
       if (staticClass && !classBinding) {
-          return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
+          return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
+                  value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
               } ];
       }
   }
   function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
       if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
+          return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
       }
       else {
           return [
               {
                   type: EXPRESSION,
-                  value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                      ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
-                      : 'null') + ")",
+                  value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                      ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                      : 'null') + ")"),
               } ];
       }
   }
@@ -4702,8 +4673,8 @@
               check(child);
           }
           if (node.ifConditions) {
-              for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                  var block = node.ifConditions[i].block;
+              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                  var block = node.ifConditions[i$1].block;
                   walk(block, isRoot);
                   check(block);
               }
@@ -4789,7 +4760,7 @@
       var state = new CodegenState(options);
       var code = ast ? genSSRElement(ast, state) : '_c("div")';
       return {
-          render: "with(this){return " + code + "}",
+          render: ("with(this){return " + code + "}"),
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -4826,9 +4797,9 @@
   function genNormalElement(el, state, stringifyChildren) {
       var data = el.plain ? undefined : genData(el, state);
       var children = stringifyChildren
-          ? "[" + genChildrenAsStringNode(el, state) + "]"
+          ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
           : genSSRChildren(el, state, true);
-      return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
+      return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
   }
   function genSSRChildren(el, state, checkSkip) {
       return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -4838,18 +4809,18 @@
   }
   function genChildrenAsStringNode(el, state) {
       return el.children.length
-          ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
+          ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
           : '';
   }
   function genStringElement(el, state) {
-      return "_ssrNode(" + elementToString(el, state) + ")";
+      return ("_ssrNode(" + (elementToString(el, state)) + ")");
   }
   function genStringElementWithChildren(el, state) {
       var children = genSSRChildren(el, state, true);
-      return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
+      return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
   }
   function elementToString(el, state) {
-      return "(" + flattenSegments(elementToSegments(el, state)) + ")";
+      return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
   }
   function elementToSegments(el, state) {
       // v-for / v-if
@@ -4874,16 +4845,17 @@
       }
       var openSegments = elementToOpenTagSegments(el, state);
       var childrenSegments = childrenToSegments(el, state);
-      var isUnaryTag = state.options.isUnaryTag;
+      var ref = state.options;
+      var isUnaryTag = ref.isUnaryTag;
       var close = isUnaryTag && isUnaryTag(el.tag)
           ? []
-          : [{ type: RAW, value: "</" + el.tag + ">" }];
+          : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
       return openSegments.concat(childrenSegments, close);
   }
   function elementToOpenTagSegments(el, state) {
       applyModelTransform(el, state);
       var binding;
-      var segments = [{ type: RAW, value: "<" + el.tag }];
+      var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
       // attrs
       if (el.attrs) {
           segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -4894,11 +4866,11 @@
       }
       // v-bind="object"
       if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
+          segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
       }
       // v-bind.prop="object"
       if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
+          segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
       }
       // class
       if (el.staticClass || el.classBinding) {
@@ -4910,7 +4882,7 @@
       }
       // _scopedId
       if (state.options.scopeId) {
-          segments.push({ type: RAW, value: " " + state.options.scopeId });
+          segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
       }
       segments.push({ type: RAW, value: ">" });
       return segments;
@@ -4918,13 +4890,13 @@
   function childrenToSegments(el, state) {
       var binding;
       if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
+          return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
       }
       if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
       }
       if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+          return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
       }
       return el.children ? nodesToSegments(el.children, state) : [];
   }
@@ -4964,11 +4936,11 @@
           }
           else if (s.type === INTERPOLATION) {
               pushBuffer();
-              mergedSegments.push("_ssrEscape(" + s.value + ")");
+              mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
           }
           else if (s.type === EXPRESSION) {
               pushBuffer();
-              mergedSegments.push("(" + s.value + ")");
+              mergedSegments.push(("(" + (s.value) + ")"));
           }
       }
       pushBuffer();
@@ -4986,7 +4958,9 @@
       };
   });
 
-  var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
+  var ref = createCompiler(baseOptions);
+  var compile = ref.compile;
+  var compileToFunctions = ref.compileToFunctions;
 
   exports.compile = compile$1;
   exports.compileToFunctions = compileToFunctions$1;
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index 4e4bfb37361..1f66663903e 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -190,11 +190,11 @@ function def(obj, key, val, enumerable) {
 // Regular Expressions for parsing tags and attributes
 var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
 var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + unicodeRegExp.source + "]*";
+var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
 var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp("^<" + qnameCapture);
+var startTagOpen = new RegExp(("^<" + qnameCapture));
 var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp("^<\\/" + qnameCapture + "[^>]*>");
+var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
 var doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
 var comment = /^<!\--/;
@@ -215,9 +215,7 @@ var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
 var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
 var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) {
-    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-};
+var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
 function decodeAttr(value, shouldDecodeNewlines) {
     var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
     return value.replace(re, function (match) { return decodingMap[match]; });
@@ -229,7 +227,7 @@ function parseHTML(html, options) {
     var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
     var index = 0;
     var last, lastTag;
-    var _loop_1 = function () {
+    while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
@@ -243,7 +241,7 @@ function parseHTML(html, options) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
                         }
                         advance(commentEnd + 3);
-                        return "continue";
+                        continue;
                     }
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
@@ -251,14 +249,14 @@ function parseHTML(html, options) {
                     var conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
-                        return "continue";
+                        continue;
                     }
                 }
                 // Doctype:
                 var doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
-                    return "continue";
+                    continue;
                 }
                 // End tag:
                 var endTagMatch = html.match(endTag);
@@ -266,7 +264,7 @@ function parseHTML(html, options) {
                     var curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
-                    return "continue";
+                    continue;
                 }
                 // Start tag:
                 var startTagMatch = parseStartTag();
@@ -275,10 +273,10 @@ function parseHTML(html, options) {
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
                         advance(1);
                     }
-                    return "continue";
+                    continue;
                 }
             }
-            var text = void 0, rest = void 0, next = void 0;
+            var text = (void 0), rest = (void 0), next = (void 0);
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -305,18 +303,18 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength_1 = 0;
-            var stackedTag_1 = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag_1] ||
-                (reCache[stackedTag_1] = new RegExp('([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)', 'i'));
-            var rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength_1 = endTag.length;
-                if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+            var endTagLength = 0;
+            var stackedTag = lastTag.toLowerCase();
+            var reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
                         .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
                         .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
                 }
-                if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
                     text = text.slice(1);
                 }
                 if (options.chars) {
@@ -324,26 +322,21 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag_1, index - endTagLength_1, index);
+            index += html.length - rest$1.length;
+            html = rest$1;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (process.env.NODE_ENV !== 'production' &&
                 !stack.length &&
                 options.warn) {
-                options.warn("Mal-formatted tag at end of template: \"" + html + "\"", {
+                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
                     start: index + html.length,
                 });
             }
-            return "break";
+            break;
         }
-    };
-    while (html) {
-        var state_1 = _loop_1();
-        if (state_1 === "break")
-            { break; }
     }
     // Clean up any remaining tags
     parseEndTag();
@@ -360,7 +353,7 @@ function parseHTML(html, options) {
                 start: index,
             };
             advance(start[0].length);
-            var end = void 0, attr = void 0;
+            var end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -444,7 +437,7 @@ function parseHTML(html, options) {
                 if (process.env.NODE_ENV !== 'production' &&
                     (i > pos || !tagName) &&
                     options.warn) {
-                    options.warn("tag <" + stack[i].tag + "> has no matching end tag.", {
+                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -480,7 +473,8 @@ var isSpecialTag = makeMap('script,style,template', true);
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
 function parseComponent(content, options) {
-    if (options === void 0) { options = {}; }
+    if ( options === void 0 ) options = {};
+
     var sfc = {
         template: null,
         script: null,
@@ -511,8 +505,10 @@ function parseComponent(content, options) {
                 type: tag,
                 content: '',
                 start: end,
-                attrs: attrs.reduce(function (cumulated, _a) {
-                    var name = _a.name, value = _a.value;
+                attrs: attrs.reduce(function (cumulated, ref) {
+                    var name = ref.name;
+                    var value = ref.value;
+
                     cumulated[name] = value || true;
                     return cumulated;
                 }, {}),
@@ -616,7 +612,7 @@ if (inBrowser) {
     try {
         var opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function () {
+            get: function get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
@@ -653,24 +649,6 @@ var hasSymbol = typeof Symbol !== 'undefined' &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    /** @class */ ((function () {
-        function Set() {
-            this.set = Object.create(null);
-        }
-        Set.prototype.has = function (key) {
-            return this.set[key] === true;
-        };
-        Set.prototype.add = function (key) {
-            this.set[key] = true;
-        };
-        Set.prototype.clear = function () {
-            this.set = Object.create(null);
-        };
-        return Set;
-    })());
-}
 
 var ASSET_TYPES = ['component', 'directive', 'filter'];
 var LIFECYCLE_HOOKS = [
@@ -770,19 +748,17 @@ var tip = noop;
 var generateComponentTrace; // work around flow check
 var formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
+    var hasConsole = typeof console !== 'undefined';
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
     warn$2 = function (msg, vm) {
         var trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
+        if (hasConsole && !config.silent) {
+            console.error(("[Vue warn]: " + msg + trace));
         }
     };
     tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
+        if (hasConsole && !config.silent) {
             console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
         }
     };
@@ -805,10 +781,10 @@ if (process.env.NODE_ENV !== 'production') {
             var match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
+        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+            (file && includeFile !== false ? (" at " + file) : ''));
     };
-    var repeat_1 = function (str, n) {
+    var repeat$1 = function (str, n) {
         var res = '';
         while (n) {
             if (n % 2 === 1)
@@ -842,15 +818,13 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
+                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
+                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                    : formatComponentName(vm))); })
                     .join('\n'));
         }
         else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
+            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
         }
     };
 }
@@ -860,79 +834,73 @@ var uid = 0;
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid++;
-        this.subs = [];
+var Dep = function Dep() {
+    this.id = uid++;
+    this.subs = [];
+};
+Dep.prototype.addSub = function addSub (sub) {
+    this.subs.push(sub);
+};
+Dep.prototype.removeSub = function removeSub (sub) {
+    remove(this.subs, sub);
+};
+Dep.prototype.depend = function depend () {
+    if (Dep.target) {
+        Dep.target.addDep(this);
     }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort(function (a, b) { return a.id - b.id; });
-        }
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
+};
+Dep.prototype.notify = function notify () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+        // subs aren't sorted in scheduler if not running async
+        // we need to sort them now to make sure they fire in correct
+        // order
+        subs.sort(function (a, b) { return a.id - b.id; });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update();
+    }
+};
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
+var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
+};
+
+var prototypeAccessors = { child: { configurable: true } };
+// DEPRECATED: alias for componentInstance for backwards compat.
+/* istanbul ignore next */
+prototypeAccessors.child.get = function () {
+    return this.componentInstance;
+};
+
+Object.defineProperties( VNode.prototype, prototypeAccessors );
 
 /*
  * not type checking this file because flow doesn't play well with
@@ -955,12 +923,9 @@ methodsToPatch.forEach(function (method) {
     // cache original method
     var original = arrayProto[method];
     def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
+        var args = [], len = arguments.length;
+        while ( len-- ) args[ len ] = arguments[ len ];
 
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
         var result = original.apply(this, args);
         var ob = this.__ob__;
         var inserted;
@@ -988,46 +953,43 @@ var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
+var Observer = function Observer(value) {
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, '__ob__', this);
+    if (Array.isArray(value)) {
+        if (hasProto) {
+            protoAugment(value, arrayMethods);
         }
         else {
-            this.walk(value);
+            copyAugment(value, arrayMethods, arrayKeys);
         }
+        this.observeArray(value);
     }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
+    else {
+        this.walk(value);
+    }
+};
+/**
+ * Walk through all properties and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object.
+ */
+Observer.prototype.walk = function walk (obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i]);
+    }
+};
+/**
+ * Observe a list of Array items.
+ */
+Observer.prototype.observeArray = function observeArray (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i]);
+    }
+};
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -1137,7 +1099,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn$2("Cannot set reactive property on undefined, null, or primitive value: " + target);
+        warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -1169,7 +1131,7 @@ function set(target, key, val) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1345,14 +1307,14 @@ strats.watch = function (parentVal, childVal, vm, key) {
         { return childVal; }
     var ret = {};
     extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
+    for (var key$1 in childVal) {
+        var parent = ret[key$1];
+        var child = childVal[key$1];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key$1] = parent
+            ? parent.concat(child)
             : Array.isArray(child)
                 ? child
                 : [child];
@@ -1384,7 +1346,7 @@ var defaultStrat = function (parentVal, childVal) {
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
         warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
+            "but got " + (toRawType(value)) + ".", vm);
     }
 }
 
@@ -1413,10 +1375,10 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
+    var counter = 1;
     var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
         characterData: true,
     });
 }
@@ -1553,9 +1515,7 @@ function parseFilters(exp) {
             if (c === 0x2f) {
                 // /
                 var j = i - 1;
-                var p 
-                // find first non-whitespace prev char
-                = void 0;
+                var p = (void 0);
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
@@ -1589,12 +1549,12 @@ function wrapFilter(exp, filter) {
     var i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return "_f(\"" + filter + "\")(" + exp + ")";
+        return ("_f(\"" + filter + "\")(" + exp + ")");
     }
     else {
-        var name_1 = filter.slice(0, i);
+        var name = filter.slice(0, i);
         var args = filter.slice(i + 1);
-        return "_f(\"" + name_1 + "\")(" + exp + (args !== ')' ? ',' + args : args);
+        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
     }
 }
 
@@ -1624,7 +1584,7 @@ function parseText(text, delimiters) {
         }
         // tag token
         var exp = parseFilters(match[1].trim());
-        tokens.push("_s(" + exp + ")");
+        tokens.push(("_s(" + exp + ")"));
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -1640,7 +1600,7 @@ function parseText(text, delimiters) {
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error("[Vue compiler]: " + msg);
+    console.error(("[Vue compiler]: " + msg));
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
@@ -1674,7 +1634,7 @@ function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, ra
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? "_p(" + name + ",\"" + symbol + "\")" : symbol + name; // mark the event as captured
+    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -1828,10 +1788,10 @@ function transformNode$1(el, options) {
 function genData$2(el) {
     var data = '';
     if (el.staticClass) {
-        data += "staticClass:" + el.staticClass + ",";
+        data += "staticClass:" + (el.staticClass) + ",";
     }
     if (el.classBinding) {
-        data += "class:" + el.classBinding + ",";
+        data += "class:" + (el.classBinding) + ",";
     }
     return data;
 }
@@ -1878,10 +1838,10 @@ function transformNode(el, options) {
 function genData$1(el) {
     var data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + el.staticStyle + ",";
+        data += "staticStyle:" + (el.staticStyle) + ",";
     }
     if (el.styleBinding) {
-        data += "style:(" + el.styleBinding + "),";
+        data += "style:(" + (el.styleBinding) + "),";
     }
     return data;
 }
@@ -1895,23 +1855,25 @@ var style = {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var _a = modifiers || {}, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var number = ref.number;
+    var trim = ref.trim;
     var baseValueExpression = '$$v';
     var valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
             "(typeof " + baseValueExpression + " === 'string'" +
-                ("? " + baseValueExpression + ".trim()") +
-                (": " + baseValueExpression + ")");
+                "? " + baseValueExpression + ".trim()" +
+                ": " + baseValueExpression + ")";
     }
     if (number) {
         valueExpression = "_n(" + valueExpression + ")";
     }
     var assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: "(" + value + ")",
+        value: ("(" + value + ")"),
         expression: JSON.stringify(value),
-        callback: "function (" + baseValueExpression + ") {" + assignment + "}",
+        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
     };
 }
 /**
@@ -1920,10 +1882,10 @@ function genComponentModel(el, value, modifiers) {
 function genAssignmentCode(value, assignment) {
     var res = parseModel(value);
     if (res.key === null) {
-        return value + "=" + assignment;
+        return (value + "=" + assignment);
     }
     else {
-        return "$set(" + res.exp + ", " + res.key + ", " + assignment + ")";
+        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
     }
 }
 /**
@@ -2062,7 +2024,10 @@ function parse(template, options) {
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
     var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    maybeComponent = function (el) { return !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
@@ -2113,8 +2078,8 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name_1 = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name_1] = element;
+                    var name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
                 element.parent = currentParent;
@@ -2140,7 +2105,7 @@ function parse(template, options) {
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode = void 0;
+            var lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -2150,7 +2115,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + el.tag + "> as component root element because it may " +
+            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -2167,7 +2132,7 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function (tag, attrs, unary, start, end) {
+        start: function start(tag, attrs, unary, start$1, end) {
             // check namespace.
             // inherit parent ns if there is one
             var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
@@ -2182,7 +2147,7 @@ function parse(template, options) {
             }
             if (process.env.NODE_ENV !== 'production') {
                 if (options.outputSourceRange) {
-                    element.start = start;
+                    element.start = start$1;
                     element.end = end;
                     element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
                         cumulated[attr.name] = attr;
@@ -2204,7 +2169,7 @@ function parse(template, options) {
                 process.env.NODE_ENV !== 'production' &&
                     warn$1('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        ("<" + tag + ">") +
+                        "<" + tag + ">" +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
@@ -2243,24 +2208,24 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function (tag, start, end) {
+        end: function end(tag, start, end$1) {
             var element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
+                element.end = end$1;
             }
             closeElement(element);
         },
-        chars: function (text, start, end) {
+        chars: function chars(text, start, end) {
             if (!currentParent) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (text === template) {
                         warnOnce('Component template requires a root element, rather than just text.', { start: start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce("text \"" + text + "\" outside root element will be ignored.", {
+                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
                             start: start,
                         });
                     }
@@ -2300,8 +2265,8 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res = void 0;
-                var child = void 0;
+                var res;
+                var child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
@@ -2328,7 +2293,7 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function (text, start, end) {
+        comment: function comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
@@ -2399,11 +2364,11 @@ function processKey(el) {
             }
             if (el.for) {
                 var iterator = el.iterator2 || el.iterator1;
-                var parent_1 = el.parent;
+                var parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
-                    parent_1 &&
-                    parent_1.tag === 'transition-group') {
+                    parent &&
+                    parent.tag === 'transition-group') {
                     warn$1("Do not use v-for index as key on <transition-group> children, " +
                         "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
                 }
@@ -2427,7 +2392,7 @@ function processFor(el) {
             extend(el, res);
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$1("Invalid v-for expression: " + exp, el.rawAttrsMap['v-for']);
+            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -2480,7 +2445,7 @@ function processIfConditions(el, parent) {
     }
     else if (process.env.NODE_ENV !== 'production') {
         warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            ("used on element <" + el.tag + "> without corresponding v-if."), el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
@@ -2491,7 +2456,7 @@ function findPrevElement(children) {
         }
         else {
             if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1("text \"" + children[i].text.trim() + "\" between v-if and v-else(-if) " +
+                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
                     "will be ignored.", children[i]);
             }
             children.pop();
@@ -2528,7 +2493,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + el.tag + "> " +
+            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
                 "(v-for takes higher priority). Use a wrapper <template> for the " +
                 "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
         }
@@ -2560,41 +2525,45 @@ function processSlotContent(el) {
                             "the receiving component", el);
                     }
                 }
-                var _a = getSlotName(slotBinding), name_2 = _a.name, dynamic = _a.dynamic;
-                el.slotTarget = name_2;
+                var ref = getSlotName(slotBinding);
+                var name = ref.name;
+                var dynamic = ref.dynamic;
+                el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
             }
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
+            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding$1) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding);
+                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
                     }
                     if (el.slotScope || el.slotTarget) {
                         warn$1("Unexpected mixed usage of different slot syntaxes.", el);
                     }
                     if (el.scopedSlots) {
                         warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding);
+                            "<template> syntax when there are other named slots.", slotBinding$1);
                     }
                 }
                 // add the component's children to its default slot
                 var slots = el.scopedSlots || (el.scopedSlots = {});
-                var _b = getSlotName(slotBinding), name_3 = _b.name, dynamic = _b.dynamic;
-                var slotContainer_1 = (slots[name_3] = createASTElement('template', [], el));
-                slotContainer_1.slotTarget = name_3;
-                slotContainer_1.slotTargetDynamic = dynamic;
-                slotContainer_1.children = el.children.filter(function (c) {
+                var ref$1 = getSlotName(slotBinding$1);
+                var name$1 = ref$1.name;
+                var dynamic$1 = ref$1.dynamic;
+                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name$1;
+                slotContainer.slotTargetDynamic = dynamic$1;
+                slotContainer.children = el.children.filter(function (c) {
                     if (!c.slotScope) {
-                        c.parent = slotContainer_1;
+                        c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -2617,7 +2586,7 @@ function getSlotName(binding) {
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: "\"" + name + "\"", dynamic: false };
+            { name: ("\"" + name + "\""), dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
@@ -2664,7 +2633,7 @@ function processAttrs(el) {
                 }
                 if (process.env.NODE_ENV !== 'production' &&
                     value.trim().length === 0) {
-                    warn$1("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"");
+                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -2678,14 +2647,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, "$event");
                         if (!isDynamic) {
-                            addHandler(el, "update:" + camelize(name), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, "update:" + hyphenate(name), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, "\"update:\"+(" + name + ")", syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
                             );
                         }
                     }
@@ -2762,11 +2731,11 @@ function checkInFor(el) {
 function parseModifiers(name) {
     var match = name.match(modifierRE);
     if (match) {
-        var ret_1 = {};
+        var ret = {};
         match.forEach(function (m) {
-            ret_1[m.slice(1)] = true;
+            ret[m.slice(1)] = true;
         });
-        return ret_1;
+        return ret;
     }
 }
 function makeAttrsMap(attrs) {
@@ -2809,7 +2778,7 @@ function checkForAliasModel(el, value) {
     var _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + el.tag + " v-model=\"" + value + "\">: " +
+            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
                 "You are binding v-model directly to a v-for iteration alias. " +
                 "This will not be able to modify the v-for source array because " +
                 "writing to the alias is like modifying a function local variable. " +
@@ -2834,16 +2803,16 @@ function preTransformNode(el, options) {
         if (!map['v-model']) {
             return;
         }
-        var typeBinding = void 0;
+        var typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + map['v-bind'] + ").type";
+            typeBinding = "(" + (map['v-bind']) + ").type";
         }
         if (typeBinding) {
             var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? "&&(" + ifCondition + ")" : "";
+            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
             var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
             var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
@@ -2909,7 +2878,7 @@ function model(el, dir, _warn) {
         // inputs with type="file" are read only and setting the input's
         // value will throw an error.
         if (tag === 'input' && type === 'file') {
-            warn("<" + el.tag + " v-model=\"" + value + "\" type=\"file\">:\n" +
+            warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
                 "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
         }
     }
@@ -2944,25 +2913,25 @@ function genCheckboxModel(el, value, modifiers) {
     var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
     var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
     addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        ("?_i(" + value + "," + valueBinding + ")>-1") +
+        "?_i(" + value + "," + valueBinding + ")>-1" +
         (trueValueBinding === 'true'
-            ? ":(" + value + ")"
-            : ":_q(" + value + "," + trueValueBinding + ")"));
+            ? (":(" + value + ")")
+            : (":_q(" + value + "," + trueValueBinding + ")")));
     addHandler(el, 'change', "var $$a=" + value + "," +
         '$$el=$event.target,' +
-        ("$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");") +
+        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
         'if(Array.isArray($$a)){' +
-        ("var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + ",") +
+        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
         '$$i=_i($$a,$$v);' +
-        ("if($$el.checked){$$i<0&&(" + genAssignmentCode(value, '$$a.concat([$$v])') + ")}") +
-        ("else{$$i>-1&&(" + genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))') + ")}") +
-        ("}else{" + genAssignmentCode(value, '$$c') + "}"), null, true);
+        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
+        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
+        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
 }
 function genRadioModel(el, value, modifiers) {
     var number = modifiers && modifiers.number;
     var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? "_n(" + valueBinding + ")" : valueBinding;
-    addProp(el, 'checked', "_q(" + value + "," + valueBinding + ")");
+    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
+    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
     addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
 }
 function genSelect(el, value, modifiers) {
@@ -2970,10 +2939,10 @@ function genSelect(el, value, modifiers) {
     var selectedVal = "Array.prototype.filter" +
         ".call($event.target.options,function(o){return o.selected})" +
         ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        ("return " + (number ? '_n(val)' : 'val') + "})");
+        "return " + (number ? '_n(val)' : 'val') + "})";
     var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
     var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + genAssignmentCode(value, assignment);
+    code = code + " " + (genAssignmentCode(value, assignment));
     addHandler(el, 'change', code, null, true);
 }
 function genDefaultModel(el, value, modifiers) {
@@ -2981,15 +2950,18 @@ function genDefaultModel(el, value, modifiers) {
     // warn if v-bind:value conflicts with v-model
     // except for inputs with v-bind:type
     if (process.env.NODE_ENV !== 'production') {
-        var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
         var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value_1 && !typeBinding) {
+        if (value$1 && !typeBinding) {
             var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value_1 + "\" conflicts with v-model on the same element " +
+            warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
                 'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
         }
     }
-    var _a = modifiers || {}, lazy = _a.lazy, number = _a.number, trim = _a.trim;
+    var ref = modifiers || {};
+    var lazy = ref.lazy;
+    var number = ref.number;
+    var trim = ref.trim;
     var needCompositionGuard = !lazy && type !== 'range';
     var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
     var valueExpression = '$event.target.value';
@@ -3003,7 +2975,7 @@ function genDefaultModel(el, value, modifiers) {
     if (needCompositionGuard) {
         code = "if($event.target.composing)return;" + code;
     }
-    addProp(el, 'value', "(" + value + ")");
+    addProp(el, 'value', ("(" + value + ")"));
     addHandler(el, event, code, null, true);
     if (trim || number) {
         addHandler(el, 'blur', '$forceUpdate()');
@@ -3012,13 +2984,13 @@ function genDefaultModel(el, value, modifiers) {
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', "_s(" + dir.value + ")", dir);
+        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', "_s(" + dir.value + ")", dir);
+        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
     }
 }
 
@@ -3102,8 +3074,8 @@ function markStatic(node) {
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                var block = node.ifConditions[i].block;
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -3135,8 +3107,8 @@ function markStaticRoots(node, isInFor) {
             }
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                markStaticRoots(node.ifConditions[i$1].block, isInFor);
             }
         }
     }
@@ -3206,7 +3178,7 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return "if(" + condition + ")return null;"; };
+var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
 var modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
@@ -3223,19 +3195,19 @@ function genHandlers(events, isNative) {
     var prefix = isNative ? 'nativeOn:' : 'on:';
     var staticHandlers = "";
     var dynamicHandlers = "";
-    for (var name_1 in events) {
-        var handlerCode = genHandler(events[name_1]);
+    for (var name in events) {
+        var handlerCode = genHandler(events[name]);
         //@ts-expect-error
-        if (events[name_1] && events[name_1].dynamic) {
-            dynamicHandlers += name_1 + "," + handlerCode + ",";
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += name + "," + handlerCode + ",";
         }
         else {
-            staticHandlers += "\"" + name_1 + "\":" + handlerCode + ",";
+            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
         }
     }
-    staticHandlers = "{" + staticHandlers.slice(0, -1) + "}";
+    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
     if (dynamicHandlers) {
-        return prefix + ("_d(" + staticHandlers + ",[" + dynamicHandlers.slice(0, -1) + "])");
+        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
     }
     else {
         return prefix + staticHandlers;
@@ -3246,7 +3218,7 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return "[" + handler.map(function (handler) { return genHandler(handler); }).join(',') + "]";
+        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
     }
     var isMethodPath = simplePathRE.test(handler.value);
     var isFunctionExpression = fnExpRE.test(handler.value);
@@ -3255,13 +3227,13 @@ function genHandler(handler) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return "function($event){" + (isFunctionInvocation ? "return " + handler.value : handler.value) + "}"; // inline statement
+        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
     }
     else {
         var code = '';
         var genModifierCode = '';
         var keys = [];
-        var _loop_1 = function (key) {
+        for (var key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -3270,18 +3242,15 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers_1 = handler.modifiers;
+                var modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers_1[keyModifier]; })
-                    .map(function (keyModifier) { return "$event." + keyModifier + "Key"; })
+                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
+                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
                     .join('||'));
             }
             else {
                 keys.push(key);
             }
-        };
-        for (var key in handler.modifiers) {
-            _loop_1(key);
         }
         if (keys.length) {
             code += genKeyFilter(keys);
@@ -3291,13 +3260,13 @@ function genHandler(handler) {
             code += genModifierCode;
         }
         var handlerCode = isMethodPath
-            ? "return " + handler.value + ".apply(null, arguments)"
+            ? ("return " + (handler.value) + ".apply(null, arguments)")
             : isFunctionExpression
-                ? "return (" + handler.value + ").apply(null, arguments)"
+                ? ("return (" + (handler.value) + ").apply(null, arguments)")
                 : isFunctionInvocation
-                    ? "return " + handler.value
+                    ? ("return " + (handler.value))
                     : handler.value;
-        return "function($event){" + code + handlerCode + "}";
+        return ("function($event){" + code + handlerCode + "}");
     }
 }
 function genKeyFilter(keys) {
@@ -3306,20 +3275,20 @@ function genKeyFilter(keys) {
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
     "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&') + ")return null;"));
+        (keys.map(genFilterCode).join('&&')) + ")return null;");
 }
 function genFilterCode(key) {
     var keyVal = parseInt(key, 10);
     if (keyVal) {
-        return "$event.keyCode!==" + keyVal;
+        return ("$event.keyCode!==" + keyVal);
     }
     var keyCode = keyCodes[key];
     var keyName = keyNames[key];
     return ("_k($event.keyCode," +
-        (JSON.stringify(key) + ",") +
-        (JSON.stringify(keyCode) + ",") +
+        (JSON.stringify(key)) + "," +
+        (JSON.stringify(keyCode)) + "," +
         "$event.key," +
-        ("" + JSON.stringify(keyName)) +
+        "" + (JSON.stringify(keyName)) +
         ")");
 }
 
@@ -3327,12 +3296,12 @@ function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
         warn$2("v-on without argument does not support modifiers.");
     }
-    el.wrapListeners = function (code) { return "_g(" + code + "," + dir.value + ")"; };
+    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
 }
 
 function bind(el, dir) {
     el.wrapData = function (code) {
-        return "_b(" + code + ",'" + el.tag + "'," + dir.value + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")";
+        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
     };
 }
 
@@ -3342,24 +3311,19 @@ var baseDirectives = {
     cloak: noop,
 };
 
-var CodegenState = /** @class */ (function () {
-    function CodegenState(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        var isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = function (el) {
-            return !!el.component || !isReservedTag(el.tag);
-        };
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-    return CodegenState;
-}());
+var CodegenState = function CodegenState(options) {
+    this.options = options;
+    this.warn = options.warn || baseWarn;
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+    this.directives = extend(extend({}, baseDirectives), options.directives);
+    var isReservedTag = options.isReservedTag || no;
+    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
+    this.onceId = 0;
+    this.staticRenderFns = [];
+    this.pre = false;
+};
 function generate$1(ast, options) {
     var state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
@@ -3369,7 +3333,7 @@ function generate$1(ast, options) {
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: ("with(this){return " + code + "}"),
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -3397,19 +3361,17 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code = void 0;
+        var code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data = void 0;
+            var data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
             var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + el.tag + "'" + (data ? "," + data : '' // data
-            ) + (children ? "," + children : '' // children
-            ) + ")";
+            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
         }
         // module transforms
         for (var i = 0; i < state.transforms.length; i++) {
@@ -3428,9 +3390,9 @@ function genStatic(el, state) {
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push("with(this){return " + genElement(el, state) + "}");
+    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
     state.pre = originalPreState;
-    return "_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")";
+    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
 }
 // v-once
 function genOnce(el, state) {
@@ -3440,20 +3402,20 @@ function genOnce(el, state) {
     }
     else if (el.staticInFor) {
         var key = '';
-        var parent_1 = el.parent;
-        while (parent_1) {
-            if (parent_1.for) {
-                key = parent_1.key;
+        var parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
                 break;
             }
-            parent_1 = parent_1.parent;
+            parent = parent.parent;
         }
         if (!key) {
             process.env.NODE_ENV !== 'production' &&
                 state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return "_o(" + genElement(el, state) + "," + state.onceId++ + "," + key + ")";
+        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
     }
     else {
         return genStatic(el, state);
@@ -3469,10 +3431,10 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
     var condition = conditions.shift();
     if (condition.exp) {
-        return "(" + condition.exp + ")?" + genTernaryExp(condition.block) + ":" + genIfConditions(conditions, state, altGen, altEmpty);
+        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
     }
     else {
-        return "" + genTernaryExp(condition.block);
+        return ("" + (genTernaryExp(condition.block)));
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -3486,21 +3448,21 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
 function genFor(el, state, altGen, altHelper) {
     var exp = el.for;
     var alias = el.alias;
-    var iterator1 = el.iterator1 ? "," + el.iterator1 : '';
-    var iterator2 = el.iterator2 ? "," + el.iterator2 : '';
+    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
+    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
     if (process.env.NODE_ENV !== 'production' &&
         state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + el.tag + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
+        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
             "v-for should have explicit keys. " +
             "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
     return ((altHelper || '_l') + "((" + exp + ")," +
-        ("function(" + alias + iterator1 + iterator2 + "){") +
-        ("return " + (altGen || genElement)(el, state)) +
+        "function(" + alias + iterator1 + iterator2 + "){" +
+        "return " + ((altGen || genElement)(el, state)) +
         '})');
 }
 function genData(el, state) {
@@ -3512,11 +3474,11 @@ function genData(el, state) {
         { data += dirs + ','; }
     // key
     if (el.key) {
-        data += "key:" + el.key + ",";
+        data += "key:" + (el.key) + ",";
     }
     // ref
     if (el.ref) {
-        data += "ref:" + el.ref + ",";
+        data += "ref:" + (el.ref) + ",";
     }
     if (el.refInFor) {
         data += "refInFor:true,";
@@ -3527,7 +3489,7 @@ function genData(el, state) {
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + el.tag + "\",";
+        data += "tag:\"" + (el.tag) + "\",";
     }
     // module data generation functions
     for (var i = 0; i < state.dataGenFns.length; i++) {
@@ -3535,31 +3497,31 @@ function genData(el, state) {
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + genProps(el.attrs) + ",";
+        data += "attrs:" + (genProps(el.attrs)) + ",";
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + genProps(el.props) + ",";
+        data += "domProps:" + (genProps(el.props)) + ",";
     }
     // event handlers
     if (el.events) {
-        data += genHandlers(el.events, false) + ",";
+        data += (genHandlers(el.events, false)) + ",";
     }
     if (el.nativeEvents) {
-        data += genHandlers(el.nativeEvents, true) + ",";
+        data += (genHandlers(el.nativeEvents, true)) + ",";
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + el.slotTarget + ",";
+        data += "slot:" + (el.slotTarget) + ",";
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += genScopedSlots(el, el.scopedSlots, state) + ",";
+        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + el.model.value + ",callback:" + el.model.callback + ",expression:" + el.model.expression + "},";
+        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
     }
     // inline-template
     if (el.inlineTemplate) {
@@ -3573,7 +3535,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + el.tag + "\"," + genProps(el.dynamicAttrs) + ")";
+        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -3603,9 +3565,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + dir.name + "\",rawName:\"" + dir.rawName + "\"" + (dir.value
-                ? ",value:(" + dir.value + "),expression:" + JSON.stringify(dir.value)
-                : '') + (dir.arg ? ",arg:" + (dir.isDynamicArg ? dir.arg : "\"" + dir.arg + "\"") : '') + (dir.modifiers ? ",modifiers:" + JSON.stringify(dir.modifiers) : '') + "},";
+            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
+                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
+                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
         }
     }
     if (hasRuntime) {
@@ -3620,9 +3582,9 @@ function genInlineTemplate(el, state) {
     }
     if (ast && ast.type === 1) {
         var inlineRenderFns = generate$1(ast, state.options);
-        return "inlineTemplate:{render:function(){" + inlineRenderFns.render + "},staticRenderFns:[" + inlineRenderFns.staticRenderFns
-            .map(function (code) { return "function(){" + code + "}"; })
-            .join(',') + "]}";
+        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
+            .map(function (code) { return ("function(){" + code + "}"); })
+            .join(',')) + "]}");
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -3647,23 +3609,23 @@ function genScopedSlots(el, slots, state) {
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent_2 = el.parent;
-        while (parent_2) {
-            if ((parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-                parent_2.for) {
+        var parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
                 needsForceUpdate = true;
                 break;
             }
-            if (parent_2.if) {
+            if (parent.if) {
                 needsKey = true;
             }
-            parent_2 = parent_2.parent;
+            parent = parent.parent;
         }
     }
     var generatedSlots = Object.keys(slots)
         .map(function (key) { return genScopedSlot(slots[key], state); })
         .join(',');
-    return "scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? ",null,false," + hash(generatedSlots) : "") + ")";
+    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
 }
 function hash(str) {
     var hash = 5381;
@@ -3692,36 +3654,36 @@ function genScopedSlot(el, state) {
     }
     var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
     var fn = "function(" + slotScope + "){" +
-        ("return " + (el.tag === 'template'
+        "return " + (el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? "(" + el.if + ")?" + (genChildren(el, state) || 'undefined') + ":undefined"
+                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}");
+            : genElement(el, state)) + "}";
     // reverse proxy v-slot without scope on this.$slots
     var reverseProxy = slotScope ? "" : ",proxy:true";
-    return "{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}";
+    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
     var children = el.children;
     if (children.length) {
-        var el_1 = children[0];
+        var el$1 = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el_1.for &&
-            el_1.tag !== 'template' &&
-            el_1.tag !== 'slot') {
-            var normalizationType_1 = checkSkip
-                ? state.maybeComponent(el_1)
+            el$1.for &&
+            el$1.tag !== 'template' &&
+            el$1.tag !== 'slot') {
+            var normalizationType = checkSkip
+                ? state.maybeComponent(el$1)
                     ? ",1"
                     : ",0"
                 : "";
-            return "" + (altGenElement || genElement)(el_1, state) + normalizationType_1;
+            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
         }
-        var normalizationType = checkSkip
+        var normalizationType$1 = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen_1 = altGenNode || genNode;
-        return "[" + children.map(function (c) { return gen_1(c, state); }).join(',') + "]" + (normalizationType ? "," + normalizationType : '');
+        var gen = altGenNode || genNode;
+        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
     }
 }
 // determine the normalization needed for the children array.
@@ -3763,17 +3725,17 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return "_v(" + (text.type === 2
+    return ("_v(" + (text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")";
+        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
 }
 function genComment(comment) {
-    return "_e(" + JSON.stringify(comment.text) + ")";
+    return ("_e(" + (JSON.stringify(comment.text)) + ")");
 }
 function genSlot(el, state) {
     var slotName = el.slotName || '"default"';
     var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? "," + children : '');
+    var res = "_t(" + slotName + (children ? ("," + children) : '');
     var attrs = el.attrs || el.dynamicAttrs
         ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
             // slot props are camelized
@@ -3797,7 +3759,7 @@ function genSlot(el, state) {
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
     var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return "_c(" + componentName + "," + genData(el, state) + (children ? "," + children : '') + ")";
+    return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
 }
 function genProps(props) {
     var staticProps = "";
@@ -3806,15 +3768,15 @@ function genProps(props) {
         var prop = props[i];
         var value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += prop.name + "," + value + ",";
+            dynamicProps += (prop.name) + "," + value + ",";
         }
         else {
-            staticProps += "\"" + prop.name + "\":" + value + ",";
+            staticProps += "\"" + (prop.name) + "\":" + value + ",";
         }
     }
-    staticProps = "{" + staticProps.slice(0, -1) + "}";
+    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
     if (dynamicProps) {
-        return "_d(" + staticProps + ",[" + dynamicProps.slice(0, -1) + "])";
+        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
     }
     else {
         return staticProps;
@@ -3848,22 +3810,22 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name_1 in node.attrsMap) {
-            if (dirRE.test(name_1)) {
-                var value = node.attrsMap[name_1];
+        for (var name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                var value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name_1];
-                    if (name_1 === 'v-for') {
-                        checkFor(node, "v-for=\"" + value + "\"", warn, range);
+                    var range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
                     }
-                    else if (name_1 === 'v-slot' || name_1[0] === '#') {
-                        checkFunctionParameterExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
-                    else if (onRE.test(name_1)) {
-                        checkEvent(value, name_1 + "=\"" + value + "\"", warn, range);
+                    else if (onRE.test(name)) {
+                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
                     }
                     else {
-                        checkExpression(value, name_1 + "=\"" + value + "\"", warn, range);
+                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
                     }
                 }
             }
@@ -3883,7 +3845,7 @@ function checkEvent(exp, text, warn, range) {
     var keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
         warn("avoid using JavaScript unary operator as property name: " +
-            ("\"" + keywordMatch[0] + "\" in expression " + text.trim()), range);
+            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -3896,16 +3858,16 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function("var " + ident + "=_");
+            new Function(("var " + ident + "=_"));
         }
         catch (e) {
-            warn("invalid " + type + " \"" + ident + "\" in expression: " + text.trim(), range);
+            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function("return " + exp);
+        new Function(("return " + exp));
     }
     catch (e) {
         var keywordMatch = exp
@@ -3913,12 +3875,12 @@ function checkExpression(exp, text, warn, range) {
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
             warn("avoid using JavaScript keyword as property name: " +
-                ("\"" + keywordMatch[0] + "\"\n  Raw expression: " + text.trim()), range);
+                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
         }
         else {
-            warn("invalid expression: " + e.message + " in\n\n" +
-                ("    " + exp + "\n\n") +
-                ("  Raw expression: " + text.trim() + "\n"), range);
+            warn("invalid expression: " + (e.message) + " in\n\n" +
+                "    " + exp + "\n\n" +
+                "  Raw expression: " + (text.trim()) + "\n", range);
         }
     }
 }
@@ -3927,16 +3889,17 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + e.message + " in\n\n" +
-            ("    " + exp + "\n\n") +
-            ("  Raw expression: " + text.trim() + "\n"), range);
+        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
+            "    " + exp + "\n\n" +
+            "  Raw expression: " + (text.trim()) + "\n", range);
     }
 }
 
 var range = 2;
 function generateCodeFrame(source, start, end) {
-    if (start === void 0) { start = 0; }
-    if (end === void 0) { end = source.length; }
+    if ( start === void 0 ) start = 0;
+    if ( end === void 0 ) end = source.length;
+
     var lines = source.split(/\r?\n/);
     var count = 0;
     var res = [];
@@ -3946,18 +3909,18 @@ function generateCodeFrame(source, start, end) {
             for (var j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
                     { continue; }
-                res.push("" + (j + 1) + repeat(" ", 3 - String(j + 1).length) + "|  " + lines[j]);
+                res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
                 var lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
                     var pad = start - (count - lineLength) + 1;
-                    var length_1 = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length_1));
+                    var length = end > count ? lineLength - pad : end - start;
+                    res.push("   |  " + repeat(" ", pad) + repeat("^", length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length_2 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length_2));
+                        var length$1 = Math.min(end - count, lineLength);
+                        res.push("   |  " + repeat("^", length$1));
                     }
                     count += lineLength + 1;
                 }
@@ -4029,13 +3992,13 @@ function createCompileToFunctionFn(compile) {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
                     compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + e.msg + "\n\n" +
+                        warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
                     warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return "- " + e; }).join('\n') +
+                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
                         '\n', vm);
                 }
             }
@@ -4063,10 +4026,12 @@ function createCompileToFunctionFn(compile) {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
                 warn("Failed to generate render function:\n\n" +
                     fnGenErrors
-                        .map(function (_a) {
-                        var err = _a.err, code = _a.code;
-                        return err.toString() + " in\n\n" + code + "\n";
-                    })
+                        .map(function (ref) {
+                            var err = ref.err;
+                            var code = ref.code;
+
+                            return ((err.toString()) + " in\n\n" + code + "\n");
+                })
                         .join('\n'), vm);
             }
         }
@@ -4087,15 +4052,15 @@ function createCompilerCreator(baseCompile) {
                 if (process.env.NODE_ENV !== 'production' &&
                     options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength_1 = template.match(/^\s*/)[0].length;
+                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
                     warn = function (msg, range, tip) {
                         var data = { msg: msg };
                         if (range) {
                             if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength_1;
+                                data.start = range.start + leadingSpaceLength;
                             }
                             if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength_1;
+                                data.end = range.end + leadingSpaceLength;
                             }
                         }
                         (tip ? tips : errors).push(data);
@@ -4148,7 +4113,9 @@ var createCompiler$1 = createCompilerCreator(function baseCompile(template, opti
     };
 });
 
-var _a$1 = createCompiler$1(baseOptions), compile$1 = _a$1.compile, compileToFunctions$1 = _a$1.compileToFunctions;
+var ref$1 = createCompiler$1(baseOptions);
+var compile$1 = ref$1.compile;
+var compileToFunctions$1 = ref$1.compileToFunctions;
 
 var isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
     'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
@@ -4219,15 +4186,19 @@ function applyModelTransform(el, state) {
     }
 }
 function genAttrSegments(attrs) {
-    return attrs.map(function (_a) {
-        var name = _a.name, value = _a.value;
+    return attrs.map(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
+
         return genAttrSegment(name, value);
     });
 }
 function genDOMPropSegments(props, attrs) {
     var segments = [];
-    props.forEach(function (_a) {
-        var name = _a.name, value = _a.value;
+    props.forEach(function (ref) {
+        var name = ref.name;
+        var value = ref.value;
+
         name = propsToAttrMap[name] || name.toLowerCase();
         if (isRenderableAttr(name) &&
             !(attrs && attrs.some(function (a) { return a.name === name; }))) {
@@ -4247,42 +4218,42 @@ function genAttrSegment(name, value) {
         return {
             type: RAW,
             value: isBooleanAttr(name)
-                ? " " + name + "=\"" + name + "\""
+                ? (" " + name + "=\"" + name + "\"")
                 : value === '""'
-                    ? " " + name
-                    : " " + name + "=\"" + JSON.parse(value) + "\"",
+                    ? (" " + name)
+                    : (" " + name + "=\"" + (JSON.parse(value)) + "\""),
         };
     }
     else {
         return {
             type: EXPRESSION,
-            value: "_ssrAttr(" + JSON.stringify(name) + "," + value + ")",
+            value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")"),
         };
     }
 }
 function genClassSegments(staticClass, classBinding) {
     if (staticClass && !classBinding) {
-        return [{ type: RAW, value: " class=\"" + JSON.parse(staticClass) + "\"" }];
+        return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: "_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")",
+                value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")"),
             } ];
     }
 }
 function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
     if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: " style=" + JSON.stringify(staticStyle) }];
+        return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }];
     }
     else {
         return [
             {
                 type: EXPRESSION,
-                value: "_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-                    ? "{ display: (" + vShowExpression + ") ? '' : 'none' }"
-                    : 'null') + ")",
+                value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
+                    ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
+                    : 'null') + ")"),
             } ];
     }
 }
@@ -4335,8 +4306,8 @@ function walk(node, isRoot) {
             check(child);
         }
         if (node.ifConditions) {
-            for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-                var block = node.ifConditions[i].block;
+            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
+                var block = node.ifConditions[i$1].block;
                 walk(block, isRoot);
                 check(block);
             }
@@ -4422,7 +4393,7 @@ function generate(ast, options) {
     var state = new CodegenState(options);
     var code = ast ? genSSRElement(ast, state) : '_c("div")';
     return {
-        render: "with(this){return " + code + "}",
+        render: ("with(this){return " + code + "}"),
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -4459,9 +4430,9 @@ function genSSRElement(el, state) {
 function genNormalElement(el, state, stringifyChildren) {
     var data = el.plain ? undefined : genData(el, state);
     var children = stringifyChildren
-        ? "[" + genChildrenAsStringNode(el, state) + "]"
+        ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
         : genSSRChildren(el, state, true);
-    return "_c('" + el.tag + "'" + (data ? "," + data : '') + (children ? "," + children : '') + ")";
+    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")");
 }
 function genSSRChildren(el, state, checkSkip) {
     return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
@@ -4471,18 +4442,18 @@ function genSSRNode(el, state) {
 }
 function genChildrenAsStringNode(el, state) {
     return el.children.length
-        ? "_ssrNode(" + flattenSegments(childrenToSegments(el, state)) + ")"
+        ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
         : '';
 }
 function genStringElement(el, state) {
-    return "_ssrNode(" + elementToString(el, state) + ")";
+    return ("_ssrNode(" + (elementToString(el, state)) + ")");
 }
 function genStringElementWithChildren(el, state) {
     var children = genSSRChildren(el, state, true);
-    return "_ssrNode(" + flattenSegments(elementToOpenTagSegments(el, state)) + ",\"</" + el.tag + ">\"" + (children ? "," + children : '') + ")";
+    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")");
 }
 function elementToString(el, state) {
-    return "(" + flattenSegments(elementToSegments(el, state)) + ")";
+    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")");
 }
 function elementToSegments(el, state) {
     // v-for / v-if
@@ -4507,16 +4478,17 @@ function elementToSegments(el, state) {
     }
     var openSegments = elementToOpenTagSegments(el, state);
     var childrenSegments = childrenToSegments(el, state);
-    var isUnaryTag = state.options.isUnaryTag;
+    var ref = state.options;
+    var isUnaryTag = ref.isUnaryTag;
     var close = isUnaryTag && isUnaryTag(el.tag)
         ? []
-        : [{ type: RAW, value: "</" + el.tag + ">" }];
+        : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
     return openSegments.concat(childrenSegments, close);
 }
 function elementToOpenTagSegments(el, state) {
     applyModelTransform(el, state);
     var binding;
-    var segments = [{ type: RAW, value: "<" + el.tag }];
+    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
     // attrs
     if (el.attrs) {
         segments.push.apply(segments, genAttrSegments(el.attrs));
@@ -4527,11 +4499,11 @@ function elementToOpenTagSegments(el, state) {
     }
     // v-bind="object"
     if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: "_ssrAttrs(" + binding + ")" });
+        segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
     }
     // v-bind.prop="object"
     if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: "_ssrDOMProps(" + binding + ")" });
+        segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
     }
     // class
     if (el.staticClass || el.classBinding) {
@@ -4543,7 +4515,7 @@ function elementToOpenTagSegments(el, state) {
     }
     // _scopedId
     if (state.options.scopeId) {
-        segments.push({ type: RAW, value: " " + state.options.scopeId });
+        segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
     }
     segments.push({ type: RAW, value: ">" });
     return segments;
@@ -4551,13 +4523,13 @@ function elementToOpenTagSegments(el, state) {
 function childrenToSegments(el, state) {
     var binding;
     if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: "_s(" + binding + ")" }];
+        return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }];
     }
     if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
     }
     if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: "_s(" + binding + ")" }];
+        return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }];
     }
     return el.children ? nodesToSegments(el.children, state) : [];
 }
@@ -4597,11 +4569,11 @@ function flattenSegments(segments) {
         }
         else if (s.type === INTERPOLATION) {
             pushBuffer();
-            mergedSegments.push("_ssrEscape(" + s.value + ")");
+            mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
         }
         else if (s.type === EXPRESSION) {
             pushBuffer();
-            mergedSegments.push("(" + s.value + ")");
+            mergedSegments.push(("(" + (s.value) + ")"));
         }
     }
     pushBuffer();
@@ -4619,7 +4591,9 @@ var createCompiler = createCompilerCreator(function baseCompile(template, option
     };
 });
 
-var _a = createCompiler(baseOptions), compile = _a.compile, compileToFunctions = _a.compileToFunctions;
+var ref = createCompiler(baseOptions);
+var compile = ref.compile;
+var compileToFunctions = ref.compileToFunctions;
 
 exports.compile = compile$1;
 exports.compileToFunctions = compileToFunctions$1;
diff --git a/scripts/build.js b/scripts/build.js
index d29d1e85f7e..131833b668f 100644
--- a/scripts/build.js
+++ b/scripts/build.js
@@ -46,17 +46,18 @@ function buildEntry (config) {
   const isProd = /(min|prod)\.js$/.test(file)
   return rollup.rollup(config)
     .then(bundle => bundle.generate(output))
-    .then(({ output: [{ code }] }) => {
+    .then(async ({ output: [{ code }] }) => {
       if (isProd) {
-        const minified = (banner ? banner + '\n' : '') + terser.minify(code, {
+        const {code: minifiedCode} =  await terser.minify(code, {
           toplevel: true,
-          output: {
-            ascii_only: true
-          },
           compress: {
-            pure_funcs: ['makeMap']
+            pure_funcs: ['makeMap'],
+          },
+          format: {
+            ascii_only: true,
           }
-        }).code
+        });
+        const minified = (banner ? banner + '\n' : '') + minifiedCode
         return write(file, minified, true)
       } else {
         return write(file, code)
diff --git a/scripts/config.js b/scripts/config.js
index 5e6ef12ddd8..6ca5a816b47 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -5,7 +5,6 @@ const cjs = require('@rollup/plugin-commonjs')
 const replace = require('@rollup/plugin-replace')
 const node = require('@rollup/plugin-node-resolve').nodeResolve
 const ts = require('rollup-plugin-typescript2')
-// const babel = require('@rollup/plugin-babel').babel
 
 const version = process.env.VERSION || require('../package.json').version
 const weexVersion = process.env.WEEX_VERSION || require('../packages/weex-vue-framework/package.json').version
@@ -219,7 +218,6 @@ function genConfig (name) {
   const opts = builds[name]
 
   // console.log('__dir', __dirname)
-  // console.log('doing alisas', Object.assign({}, aliases, opts.alias))
   const config = {
     input: opts.entry,
     external: opts.external,
@@ -227,22 +225,13 @@ function genConfig (name) {
       alias({
         entries: Object.assign({}, aliases, opts.alias)
       }),
-      // flow(),
       ts({
         tsconfig: path.resolve(__dirname, '../', 'tsconfig.json'),
         cacheRoot: path.resolve(__dirname, '../','node_modules/.rts2_cache'),
         tsconfigOverride: {
-          // compilerOptions: {
-          //   sourceMap: output.sourcemap,
-          //   declaration: shouldEmitDeclarations,
-          //   declarationMap: shouldEmitDeclarations
-          // },
           exclude: ['test', 'test-dts']
         }
       }),
-      // babel({
-      //   extensions: ['.js', '.jsx', '.ts', '.tsx']
-      // }),
     ].concat(opts.plugins || []),
     output: {
       file: opts.dest,
diff --git a/tsconfig.json b/tsconfig.json
index 001ecd34e32..dc0f692a514 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,7 +3,7 @@
     "baseUrl": ".",
     "outDir": "dist",
     "sourceMap": true,
-    "target": "ES5",
+    "target": "ESNext",
     "module": "ESNext",
     "moduleResolution": "node",
     "allowJs": true,
@@ -31,7 +31,7 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "test-dts", "typescript", "types"],
+  "include": ["src", "test-dts", "typescript"],
 
   "exclude": ["flow", "node_modules", "packages", "types"]
 }
diff --git a/yarn.lock b/yarn.lock
index 6d2dab2d75e..ea0b78e97c0 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -181,7 +181,7 @@
   dependencies:
     "@babel/types" "^7.13.12"
 
-"@babel/helper-module-imports@^7.10.4", "@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.13.12":
+"@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.13.12":
   version "7.13.12"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz#c6a369a6f3621cb25da014078684da9196b61977"
   integrity sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==
@@ -1016,14 +1016,6 @@
   dependencies:
     slash "^3.0.0"
 
-"@rollup/plugin-babel@^5.3.0":
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-babel/-/plugin-babel-5.3.0.tgz#9cb1c5146ddd6a4968ad96f209c50c62f92f9879"
-  integrity sha512-9uIC8HZOnVLrLHxayq/PTzw+uS25E14KPUBh5ktF+18Mjo5yK0ToMMx6epY0uEgkjwJw0aBW4x2horYXh8juWw==
-  dependencies:
-    "@babel/helper-module-imports" "^7.10.4"
-    "@rollup/pluginutils" "^3.1.0"
-
 "@rollup/plugin-buble@^0.21.3":
   version "0.21.3"
   resolved "https://registry.yarnpkg.com/@rollup/plugin-buble/-/plugin-buble-0.21.3.tgz#1649a915b1d051a4f430d40e7734a7f67a69b33e"
@@ -2215,18 +2207,6 @@ browserslist@^4.14.5, browserslist@^4.16.3:
     escalade "^3.1.1"
     node-releases "^1.1.70"
 
-buble@^0.19.3:
-  version "0.19.6"
-  resolved "https://registry.yarnpkg.com/buble/-/buble-0.19.6.tgz#915909b6bd5b11ee03b1c885ec914a8b974d34d3"
-  integrity sha512-9kViM6nJA1Q548Jrd06x0geh+BG2ru2+RMDkIHHgJY/8AcyCs34lTHwra9BX7YdPrZXd5aarkpr/SY8bmPgPdg==
-  dependencies:
-    chalk "^2.4.1"
-    magic-string "^0.25.1"
-    minimist "^1.2.0"
-    os-homedir "^1.0.1"
-    regexpu-core "^4.2.0"
-    vlq "^1.0.0"
-
 buble@^0.20.0:
   version "0.20.0"
   resolved "https://registry.yarnpkg.com/buble/-/buble-0.20.0.tgz#a143979a8d968b7f76b57f38f2e7ce7cfe938d1f"
@@ -2636,6 +2616,11 @@ commander@^2.14.1, commander@^2.9.0:
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.19.0.tgz#f6198aa84e5b83c46054b94ddedbfed5ee9ff12a"
   integrity sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==
 
+commander@^2.20.0:
+  version "2.20.3"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
+  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
+
 commander@~2.17.1:
   version "2.17.1"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"
@@ -6338,13 +6323,6 @@ magic-string@^0.25.0, magic-string@^0.25.7:
   dependencies:
     sourcemap-codec "^1.4.4"
 
-magic-string@^0.25.1:
-  version "0.25.1"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.1.tgz#b1c248b399cd7485da0fe7385c2fc7011843266e"
-  integrity sha512-sCuTz6pYom8Rlt4ISPFn6wuFodbKMIHUMv4Qko9P17dpxb7s52KJTmRuZZqHdGmLCK9AOcDare039nRIcfdkEg==
-  dependencies:
-    sourcemap-codec "^1.4.1"
-
 make-dir@^1.0.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-1.3.0.tgz#79c1033b80515bd6d24ec9933e860ca75ee27f0c"
@@ -7882,13 +7860,6 @@ redent@^2.0.0:
     indent-string "^3.0.0"
     strip-indent "^2.0.0"
 
-regenerate-unicode-properties@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-7.0.0.tgz#107405afcc4a190ec5ed450ecaa00ed0cafa7a4c"
-  integrity sha512-s5NGghCE4itSlUS+0WUj88G6cfMVMmH8boTPNvABf8od+2dhT9WDlWu8n01raQAJZMOK8Ch6jSexaRO7swd6aw==
-  dependencies:
-    regenerate "^1.4.0"
-
 regenerate-unicode-properties@^8.0.2, regenerate-unicode-properties@^8.2.0:
   version "8.2.0"
   resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz#e5de7111d655e7ba60c057dbe9ff37c87e65cdec"
@@ -7955,18 +7926,6 @@ regexpu-core@4.5.4:
     unicode-match-property-ecmascript "^1.0.4"
     unicode-match-property-value-ecmascript "^1.1.0"
 
-regexpu-core@^4.2.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.4.0.tgz#8d43e0d1266883969720345e70c275ee0aec0d32"
-  integrity sha512-eDDWElbwwI3K0Lo6CqbQbA6FwgtCz4kYTarrri1okfkRLZAqstU+B3voZBCjg8Fl6iq0gXrJG6MvRgLthfvgOA==
-  dependencies:
-    regenerate "^1.4.0"
-    regenerate-unicode-properties "^7.0.0"
-    regjsgen "^0.5.0"
-    regjsparser "^0.6.0"
-    unicode-match-property-ecmascript "^1.0.4"
-    unicode-match-property-value-ecmascript "^1.0.2"
-
 regexpu-core@^4.7.1:
   version "4.7.1"
   resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.7.1.tgz#2dea5a9a07233298fbf0db91fa9abc4c6e0f8ad6"
@@ -8586,7 +8545,7 @@ source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
     source-map-url "^0.4.0"
     urix "^0.1.0"
 
-source-map-support@^0.5.16, source-map-support@^0.5.17:
+source-map-support@^0.5.16, source-map-support@^0.5.17, source-map-support@~0.5.19:
   version "0.5.19"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
   integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
@@ -8624,10 +8583,10 @@ source-map@~0.2.0:
   dependencies:
     amdefine ">=0.0.4"
 
-sourcemap-codec@^1.4.1:
-  version "1.4.4"
-  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.4.tgz#c63ea927c029dd6bd9a2b7fa03b3fec02ad56e9f"
-  integrity sha512-CYAPYdBu34781kLHkaW3m6b/uUSyMOC2R61gcYMWooeuaGtjof86ZA/8T+qVPPt7np1085CR9hmMGrySwEc8Xg==
+source-map@~0.7.2:
+  version "0.7.3"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
+  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
 
 sourcemap-codec@^1.4.4:
   version "1.4.8"
@@ -8993,7 +8952,7 @@ terser-webpack-plugin@^1.1.0:
     webpack-sources "^1.1.0"
     worker-farm "^1.5.2"
 
-terser@^3.10.2, terser@^3.8.1:
+terser@^3.8.1:
   version "3.14.1"
   resolved "https://registry.yarnpkg.com/terser/-/terser-3.14.1.tgz#cc4764014af570bc79c79742358bd46926018a32"
   integrity sha512-NSo3E99QDbYSMeJaEk9YW2lTg3qS9V0aKGlb+PlOrei1X02r1wSBHCNX/O+yeTRFSWPKPIGj6MqvvdqV4rnVGw==
@@ -9002,6 +8961,15 @@ terser@^3.10.2, terser@^3.8.1:
     source-map "~0.6.1"
     source-map-support "~0.5.6"
 
+terser@^5.6.1:
+  version "5.6.1"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.6.1.tgz#a48eeac5300c0a09b36854bf90d9c26fb201973c"
+  integrity sha512-yv9YLFQQ+3ZqgWCUk+pvNJwgUTdlIxUk1WTN+RnaFJe2L7ipG2csPT0ra2XRm7Cs8cxN7QXmK1rFzEwYEQkzXw==
+  dependencies:
+    commander "^2.20.0"
+    source-map "~0.7.2"
+    source-map-support "~0.5.19"
+
 test-exclude@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-5.0.0.tgz#cdce7cece785e0e829cd5c2b27baf18bc583cfb7"
@@ -9290,11 +9258,6 @@ unicode-match-property-ecmascript@^1.0.4:
     unicode-canonical-property-names-ecmascript "^1.0.4"
     unicode-property-aliases-ecmascript "^1.0.4"
 
-unicode-match-property-value-ecmascript@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.0.2.tgz#9f1dc76926d6ccf452310564fd834ace059663d4"
-  integrity sha512-Rx7yODZC1L/T8XKo/2kNzVAQaRE88AaMvI1EF/Xnj3GW2wzN6fop9DDWuFAKUVFH7vozkz26DzP0qyWLKLIVPQ==
-
 unicode-match-property-value-ecmascript@^1.1.0, unicode-match-property-value-ecmascript@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz#0d91f600eeeb3096aa962b1d6fc88876e64ea531"
@@ -9461,11 +9424,6 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
-vlq@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/vlq/-/vlq-1.0.0.tgz#8101be90843422954c2b13eb27f2f3122bdcc806"
-  integrity sha512-o3WmXySo+oI5thgqr7Qy8uBkT/v9Zr+sRyrh1lr8aWPUkgDWdWt4Nae2WKBrLsocgE8BuWWD0jLc+VW8LeU+2g==
-
 vm-browserify@0.0.4:
   version "0.0.4"
   resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-0.0.4.tgz#5d7ea45bbef9e4a6ff65f95438e0a87c357d5a73"

From f036db5dd4ab2ac519efc3d374822543a6b3b621 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 17:31:25 +0100
Subject: [PATCH 018/317] remove custom modules and use the typescript ones

---
 package.json                 |  3 +++
 src/compiler/parser/index.ts |  1 -
 src/sfc/parser.ts            |  1 -
 typescript/modules.d.ts      | 44 +-----------------------------------
 yarn.lock                    |  5 ++++
 5 files changed, 9 insertions(+), 45 deletions(-)

diff --git a/package.json b/package.json
index 4a136d5195f..c94b91a2949 100644
--- a/package.json
+++ b/package.json
@@ -154,5 +154,8 @@
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
+  },
+  "dependencies": {
+    "@types/he": "^1.1.1"
   }
 }
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index f13fbf899da..5f238a3fdac 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -1,5 +1,4 @@
 
-// const he = require('he')
 import he from 'he'
 import { parseHTML } from './html-parser'
 import { parseText } from './text-parser'
diff --git a/src/sfc/parser.ts b/src/sfc/parser.ts
index b3e36926ad6..385b9138188 100644
--- a/src/sfc/parser.ts
+++ b/src/sfc/parser.ts
@@ -98,7 +98,6 @@ export function parseComponent(
       currentBlock.end = start
       let text = content.slice(currentBlock.start, currentBlock.end)
       if (options.deindent !== false) {
-        //@ts-expect-error
         text = deindent(text)
       }
       // pad content so that linters and pre-processors can output correct
diff --git a/typescript/modules.d.ts b/typescript/modules.d.ts
index 22a090e1c6f..393a6eb671a 100644
--- a/typescript/modules.d.ts
+++ b/typescript/modules.d.ts
@@ -1,45 +1,3 @@
-declare module 'he' {
-  function escape(html: string): string
-  function decode(html: string): string
-}
-
-declare module 'source-map' {
-  class SourceMapGenerator {
-    setSourceContent(filename: string, content: string): void
-    addMapping(mapping: Object): void
-    toString(): string
-  }
-  class SourceMapConsumer {
-    constructor(map: Object)
-    originalPositionFor(position: {
-      line: number
-      column: number
-    }): {
-      source: string | null
-      line: number | null
-      column: number | null
-    }
-  }
-}
-
-declare module 'lru-cache' {
-  var exports: {
-    (): any
-  }
-}
-
 declare module 'de-indent' {
   export default function deindent (input: string): string
-}
-
-declare module 'serialize-javascript' {
-  var exports: {
-    (input: string, options: { isJSON: boolean }): string
-  }
-}
-
-declare module 'lodash.template' {
-  var exports: {
-    (input: string, options: { interpolate: RegExp; escape: RegExp }): Function
-  }
-}
+}
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index ea0b78e97c0..3879354d438 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1104,6 +1104,11 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
   integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
 
+"@types/he@^1.1.1":
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/@types/he/-/he-1.1.1.tgz#19e14033c4ee8f1a702c74dcc6182664839ac2b7"
+  integrity sha512-jpzrsR1ns0n3kyWt92QfOUQhIuJGQ9+QGa7M62rO6toe98woQjnsnzjdMtsQXCdvjjmqjS2ZBCC7xKw0cdzU+Q==
+
 "@types/json-schema@^7.0.3":
   version "7.0.7"
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"

From b5f39bf02cce8d87ac7fbb709094b941fabeb292 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Wed, 7 Apr 2021 19:11:31 +0100
Subject: [PATCH 019/317] dedup functions

---
 dist/vue.runtime.js                           | 13218 ++++++++--------
 dist/vue.runtime.min.js                       |     2 +-
 .../runtime/components/transition-group.ts    |     4 +-
 src/platforms/web/runtime/directives/show.ts  |     3 +-
 .../web/runtime/modules/transition.ts         |     6 +-
 src/platforms/web/runtime/transition-util.ts  |     2 +-
 6 files changed, 6709 insertions(+), 6526 deletions(-)

diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 19156ffc450..f48a177d210 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -4,35 +4,42 @@
  * Released under the MIT License.
  */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
-}(this, (function () { 'use strict';
+  typeof exports === "object" && typeof module !== "undefined"
+    ? (module.exports = factory())
+    : typeof define === "function" && define.amd
+    ? define(factory)
+    : ((global =
+        typeof globalThis !== "undefined" ? globalThis : global || self),
+      (global.Vue = factory()));
+})(this, function () {
+  "use strict";
 
   var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
   function isUndef(v) {
-      return v === undefined || v === null;
+    return v === undefined || v === null;
   }
   function isDef(v) {
-      return v !== undefined && v !== null;
+    return v !== undefined && v !== null;
   }
   function isTrue(v) {
-      return v === true;
+    return v === true;
   }
   function isFalse(v) {
-      return v === false;
+    return v === false;
   }
   /**
    * Check if value is primitive.
    */
   function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
+    return (
+      typeof value === "string" ||
+      typeof value === "number" ||
+      // $flow-disable-line
+      typeof value === "symbol" ||
+      typeof value === "boolean"
+    );
   }
   /**
    * Quick object check - this is primarily used to tell
@@ -40,122 +47,132 @@
    * is a JSON-compliant type.
    */
   function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
+    return obj !== null && typeof obj === "object";
   }
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
   var _toString = Object.prototype.toString;
   function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
+    return _toString.call(value).slice(8, -1);
   }
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
   function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
+    return _toString.call(obj) === "[object Object]";
   }
   function isRegExp(v) {
-      return _toString.call(v) === '[object RegExp]';
+    return _toString.call(v) === "[object RegExp]";
   }
   /**
    * Check if val is a valid array index.
    */
   function isValidArrayIndex(val) {
-      var n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
+    var n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
   function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
+    return (
+      isDef(val) &&
+      typeof val.then === "function" &&
+      typeof val.catch === "function"
+    );
   }
   /**
    * Convert a value to a string that is actually rendered.
    */
   function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
+    return val == null
+      ? ""
+      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+      ? JSON.stringify(val, null, 2)
+      : String(val);
   }
   /**
    * Convert an input value to a number for persistence.
    * If the conversion fails, return original string.
    */
   function toNumber(val) {
-      var n = parseFloat(val);
-      return isNaN(n) ? val : n;
+    var n = parseFloat(val);
+    return isNaN(n) ? val : n;
   }
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
   function makeMap(str, expectsLowerCase) {
-      var map = Object.create(null);
-      var list = str.split(',');
-      for (var i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+    var map = Object.create(null);
+    var list = str.split(",");
+    for (var i = 0; i < list.length; i++) {
+      map[list[i]] = true;
+    }
+    return expectsLowerCase
+      ? function (val) {
+          return map[val.toLowerCase()];
+        }
+      : function (val) {
+          return map[val];
+        };
   }
   /**
    * Check if a tag is a built-in tag.
    */
-  var isBuiltInTag = makeMap('slot,component', true);
+  var isBuiltInTag = makeMap("slot,component", true);
   /**
    * Check if an attribute is a reserved attribute.
    */
-  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  var isReservedAttribute = makeMap("key,ref,slot,slot-scope,is");
   /**
    * Remove an item from an array.
    */
   function remove$2(arr, item) {
-      if (arr.length) {
-          var index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
+    if (arr.length) {
+      var index = arr.indexOf(item);
+      if (index > -1) {
+        return arr.splice(index, 1);
       }
+    }
   }
   /**
    * Check whether an object has the property.
    */
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
+    return hasOwnProperty.call(obj, key);
   }
   /**
    * Create a cached version of a pure function.
    */
   function cached(fn) {
-      var cache = Object.create(null);
-      return function cachedFn(str) {
-          var hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
+    var cache = Object.create(null);
+    return function cachedFn(str) {
+      var hit = cache[str];
+      return hit || (cache[str] = fn(str));
+    };
   }
   /**
    * Camelize a hyphen-delimited string.
    */
   var camelizeRE = /-(\w)/g;
   var camelize = cached(function (str) {
-      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+    return str.replace(camelizeRE, function (_, c) {
+      return c ? c.toUpperCase() : "";
+    });
   });
   /**
    * Capitalize a string.
    */
   var capitalize = cached(function (str) {
-      return str.charAt(0).toUpperCase() + str.slice(1);
+    return str.charAt(0).toUpperCase() + str.slice(1);
   });
   /**
    * Hyphenate a camelCase string.
    */
   var hyphenateRE = /\B([A-Z])/g;
   var hyphenate = cached(function (str) {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
+    return str.replace(hyphenateRE, "-$1").toLowerCase();
   });
   /**
    * Simple bind polyfill for environments that do not support it,
@@ -166,19 +183,19 @@
    */
   /* istanbul ignore next */
   function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          var l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
+    function boundFn(a) {
+      var l = arguments.length;
+      return l
+        ? l > 1
+          ? fn.apply(ctx, arguments)
+          : fn.call(ctx, a)
+        : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
   }
   function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
+    return fn.bind(ctx);
   }
   // @ts-expect-error bind cannot be `undefined`
   var bind = Function.prototype.bind ? nativeBind : polyfillBind;
@@ -186,34 +203,34 @@
    * Convert an Array-like object to a real Array.
    */
   function toArray(list, start) {
-      start = start || 0;
-      var i = list.length - start;
-      var ret = new Array(i);
-      while (i--) {
-          ret[i] = list[i + start];
-      }
-      return ret;
+    start = start || 0;
+    var i = list.length - start;
+    var ret = new Array(i);
+    while (i--) {
+      ret[i] = list[i + start];
+    }
+    return ret;
   }
   /**
    * Mix properties into target object.
    */
   function extend(to, _from) {
-      for (var key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
+    for (var key in _from) {
+      to[key] = _from[key];
+    }
+    return to;
   }
   /**
    * Merge an Array of Objects into a single Object.
    */
   function toObject(arr) {
-      var res = {};
-      for (var i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
+    var res = {};
+    for (var i = 0; i < arr.length; i++) {
+      if (arr[i]) {
+        extend(res, arr[i]);
       }
-      return res;
+    }
+    return res;
   }
   /* eslint-disable no-unused-vars */
   /**
@@ -221,62 +238,65 @@
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop(a, b, c) { }
+  function noop(a, b, c) {}
   /**
    * Always return false.
    */
-  var no = function (a, b, c) { return false; };
+  var no = function (a, b, c) {
+    return false;
+  };
   /* eslint-enable no-unused-vars */
   /**
    * Return the same value.
    */
-  var identity = function (_) { return _; };
+  var identity = function (_) {
+    return _;
+  };
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
   function looseEqual(a, b) {
-      if (a === b)
-          { return true; }
-      var isObjectA = isObject(a);
-      var isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              var isArrayA = Array.isArray(a);
-              var isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every(function (e, i) {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  var keysA = Object.keys(a);
-                  var keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every(function (key) {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
+    if (a === b) {
+      return true;
+    }
+    var isObjectA = isObject(a);
+    var isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+      try {
+        var isArrayA = Array.isArray(a);
+        var isArrayB = Array.isArray(b);
+        if (isArrayA && isArrayB) {
+          return (
+            a.length === b.length &&
+            a.every(function (e, i) {
+              return looseEqual(e, b[i]);
+            })
+          );
+        } else if (a instanceof Date && b instanceof Date) {
+          return a.getTime() === b.getTime();
+        } else if (!isArrayA && !isArrayB) {
+          var keysA = Object.keys(a);
+          var keysB = Object.keys(b);
+          return (
+            keysA.length === keysB.length &&
+            keysA.every(function (key) {
+              return looseEqual(a[key], b[key]);
+            })
+          );
+        } else {
+          /* istanbul ignore next */
           return false;
-      }
+        }
+      } catch (e) {
+        /* istanbul ignore next */
+        return false;
+      }
+    } else if (!isObjectA && !isObjectB) {
+      return String(a) === String(b);
+    } else {
+      return false;
+    }
   }
   /**
    * Return the first index at which a loosely equal value can be
@@ -284,117 +304,119 @@
    * contain an object of the same shape), or -1 if it is not present.
    */
   function looseIndexOf(arr, val) {
-      for (var i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              { return i; }
+    for (var i = 0; i < arr.length; i++) {
+      if (looseEqual(arr[i], val)) {
+        return i;
       }
-      return -1;
+    }
+    return -1;
   }
   /**
    * Ensure a function is called only once.
    */
   function once(fn) {
-      var called = false;
-      return function () {
-          if (!called) {
-              called = true;
-              fn.apply(this, arguments);
-          }
-      };
+    var called = false;
+    return function () {
+      if (!called) {
+        called = true;
+        fn.apply(this, arguments);
+      }
+    };
   }
 
-  var SSR_ATTR = 'data-server-rendered';
-  var ASSET_TYPES = ['component', 'directive', 'filter'];
+  var SSR_ATTR = "data-server-rendered";
+  var ASSET_TYPES = ["component", "directive", "filter"];
   var LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch' ];
+    "beforeCreate",
+    "created",
+    "beforeMount",
+    "mounted",
+    "beforeUpdate",
+    "updated",
+    "beforeDestroy",
+    "destroyed",
+    "activated",
+    "deactivated",
+    "errorCaptured",
+    "serverPrefetch",
+  ];
 
   var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== "production",
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== "production",
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
   /**
@@ -407,55 +429,56 @@
    * Check if a string starts with $ or _
    */
   function isReserved(str) {
-      var c = (str + '').charCodeAt(0);
-      return c === 0x24 || c === 0x5f;
+    var c = (str + "").charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
   }
   /**
    * Define a property.
    */
   function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
+    Object.defineProperty(obj, key, {
+      value: val,
+      enumerable: !!enumerable,
+      writable: true,
+      configurable: true,
+    });
   }
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+  var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
   function parsePath(path) {
-      if (bailRE.test(path)) {
+    if (bailRE.test(path)) {
+      return;
+    }
+    var segments = path.split(".");
+    return function (obj) {
+      for (var i = 0; i < segments.length; i++) {
+        if (!obj) {
           return;
+        }
+        obj = obj[segments[i]];
       }
-      var segments = path.split('.');
-      return function (obj) {
-          for (var i = 0; i < segments.length; i++) {
-              if (!obj)
-                  { return; }
-              obj = obj[segments[i]];
-          }
-          return obj;
-      };
+      return obj;
+    };
   }
 
   // can we use __proto__?
-  var hasProto = '__proto__' in {};
+  var hasProto = "__proto__" in {};
   // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined';
-  // @ts-ignore
-  var inWeex = 
+  var inBrowser = typeof window !== "undefined";
   // @ts-ignore
-  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  var inWeex =
+    // @ts-ignore
+    typeof WXEnvironment !== "undefined" && !!WXEnvironment.platform;
   // @ts-ignore
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  var isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  var isIE9 = UA && UA.indexOf("msie 9.0") > 0;
+  var isEdge = UA && UA.indexOf("edge/") > 0;
+  (UA && UA.indexOf("android") > 0) || weexPlatform === "android";
+  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === "ios";
   UA && /chrome\/\d+/.test(UA) && !isEdge;
   UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
@@ -464,71 +487,69 @@
   var nativeWatch = {}.watch;
   var supportsPassive = false;
   if (inBrowser) {
-      try {
-          var opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get: function get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          // @ts-ignore
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
+    try {
+      var opts = {};
+      Object.defineProperty(opts, "passive", {
+        get: function get() {
+          /* istanbul ignore next */
+          supportsPassive = true;
+        },
+      }); // https://github.com/facebook/flow/issues/285
+      // @ts-ignore
+      window.addEventListener("test-passive", null, opts);
+    } catch (e) {}
   }
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
   var _isServer;
   var isServerRendering = function () {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
+    if (_isServer === undefined) {
+      /* istanbul ignore if */
+      if (!inBrowser && !inWeex && typeof global !== "undefined") {
+        // detect presence of vue-server-renderer and avoid
+        // Webpack shimming the process
+        _isServer =
+          global["process"] && global["process"].env.VUE_ENV === "server";
+      } else {
+        _isServer = false;
+      }
+    }
+    return _isServer;
   };
   // detect devtools
   // @ts-ignore TODO decalre this types
   var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
   /* istanbul ignore next */
   function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+    return typeof Ctor === "function" && /native code/.test(Ctor.toString());
   }
-  var hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
+  var hasSymbol =
+    typeof Symbol !== "undefined" &&
+    isNative(Symbol) &&
+    typeof Reflect !== "undefined" &&
+    isNative(Reflect.ownKeys);
   var _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
-          function Set() {
-              this.set = Object.create(null);
-          }
-          Set.prototype.has = function has (key) {
-              return this.set[key] === true;
-          };
-          Set.prototype.add = function add (key) {
-              this.set[key] = true;
-          };
-          Set.prototype.clear = function clear () {
-              this.set = Object.create(null);
-          };
+  /* istanbul ignore if */ if (typeof Set !== "undefined" && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+  } else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = /*@__PURE__*/ (function () {
+      function Set() {
+        this.set = Object.create(null);
+      }
+      Set.prototype.has = function has(key) {
+        return this.set[key] === true;
+      };
+      Set.prototype.add = function add(key) {
+        this.set[key] = true;
+      };
+      Set.prototype.clear = function clear() {
+        this.set = Object.create(null);
+      };
 
-          return Set;
-      }());
+      return Set;
+    })();
   }
 
   var warn = noop;
@@ -536,88 +557,108 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-      warn = function (msg, vm) {
-          var trace = vm ? generateComponentTrace(vm) : '';
-          if (config.warnHandler) {
-              config.warnHandler.call(null, msg, vm, trace);
-          }
-          else if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
-          }
-      };
-      tip = function (msg, vm) {
-          if (hasConsole && !config.silent) {
-              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = function (vm, includeFile) {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          var options = 
-          // @ts-ignore
-          typeof vm === 'function' && vm.cid != null
-              ? // @ts-ignore
-                  vm.options
-              : vm._isVue
-                  ? // @ts-ignore
-                      vm.$options || vm.constructor.options
-                  : vm;
-          var name = options.name || options._componentTag;
-          var file = options.__file;
-          if (!name && file) {
-              var match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
-      };
-      var repeat = function (str, n) {
-          var res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  { res += str; }
-              if (n > 1)
-                  { str += str; }
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = function (vm) {
-          // @ts-ignore
-          if (vm._isVue && vm.$parent) {
-              var tree = [];
-              var currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      var last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
-                      .join('\n'));
-          }
-          else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
-          }
-      };
+    var hasConsole = typeof console !== "undefined";
+    var classifyRE = /(?:^|[-_])(\w)/g;
+    var classify = function (str) {
+      return str
+        .replace(classifyRE, function (c) {
+          return c.toUpperCase();
+        })
+        .replace(/[-_]/g, "");
+    };
+    warn = function (msg, vm) {
+      var trace = vm ? generateComponentTrace(vm) : "";
+      if (config.warnHandler) {
+        config.warnHandler.call(null, msg, vm, trace);
+      } else if (hasConsole && !config.silent) {
+        console.error("[Vue warn]: " + msg + trace);
+      }
+    };
+    tip = function (msg, vm) {
+      if (hasConsole && !config.silent) {
+        console.warn(
+          "[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : "")
+        );
+      }
+    };
+    formatComponentName = function (vm, includeFile) {
+      if (vm.$root === vm) {
+        return "<Root>";
+      }
+      var options =
+        // @ts-ignore
+        typeof vm === "function" && vm.cid != null
+          ? // @ts-ignore
+            vm.options
+          : vm._isVue
+          ? // @ts-ignore
+            vm.$options || vm.constructor.options
+          : vm;
+      var name = options.name || options._componentTag;
+      var file = options.__file;
+      if (!name && file) {
+        var match = file.match(/([^/\\]+)\.vue$/);
+        name = match && match[1];
+      }
+      return (
+        (name ? "<" + classify(name) + ">" : "<Anonymous>") +
+        (file && includeFile !== false ? " at " + file : "")
+      );
+    };
+    var repeat = function (str, n) {
+      var res = "";
+      while (n) {
+        if (n % 2 === 1) {
+          res += str;
+        }
+        if (n > 1) {
+          str += str;
+        }
+        n >>= 1;
+      }
+      return res;
+    };
+    generateComponentTrace = function (vm) {
+      // @ts-ignore
+      if (vm._isVue && vm.$parent) {
+        var tree = [];
+        var currentRecursiveSequence = 0;
+        while (vm) {
+          if (tree.length > 0) {
+            var last = tree[tree.length - 1];
+            if (last.constructor === vm.constructor) {
+              currentRecursiveSequence++;
+              vm = vm.$parent;
+              continue;
+            } else if (currentRecursiveSequence > 0) {
+              tree[tree.length - 1] = [last, currentRecursiveSequence];
+              currentRecursiveSequence = 0;
+            }
+          }
+          tree.push(vm);
+          vm = vm.$parent;
+        }
+        return (
+          "\n\nfound in\n\n" +
+          tree
+            .map(function (vm, i) {
+              return (
+                "" +
+                (i === 0 ? "---> " : repeat(" ", 5 + i * 2)) +
+                (Array.isArray(vm)
+                  ? formatComponentName(vm[0]) +
+                    "... (" +
+                    vm[1] +
+                    " recursive calls)"
+                  : formatComponentName(vm))
+              );
+            })
+            .join("\n")
+        );
+      } else {
+        return "\n\n(found in " + formatComponentName(vm) + ")";
+      }
+    };
   }
 
   var uid$2 = 0;
@@ -626,32 +667,34 @@
    * directives subscribing to it.
    */
   var Dep = function Dep() {
-      this.id = uid$2++;
-      this.subs = [];
+    this.id = uid$2++;
+    this.subs = [];
   };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
+  Dep.prototype.addSub = function addSub(sub) {
+    this.subs.push(sub);
   };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove$2(this.subs, sub);
+  Dep.prototype.removeSub = function removeSub(sub) {
+    remove$2(this.subs, sub);
   };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
-      }
+  Dep.prototype.depend = function depend() {
+    if (Dep.target) {
+      Dep.target.addDep(this);
+    }
   };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      if (!config.async) {
-          // subs aren't sorted in scheduler if not running async
-          // we need to sort them now to make sure they fire in correct
-          // order
-          subs.sort(function (a, b) { return a.id - b.id; });
-      }
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
-      }
+  Dep.prototype.notify = function notify() {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice();
+    if (!config.async) {
+      // subs aren't sorted in scheduler if not running async
+      // we need to sort them now to make sure they fire in correct
+      // order
+      subs.sort(function (a, b) {
+        return a.id - b.id;
+      });
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+      subs[i].update();
+    }
   };
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
@@ -659,81 +702,97 @@
   Dep.target = null;
   var targetStack = [];
   function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
+    targetStack.push(target);
+    Dep.target = target;
   }
   function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
+  var VNode = function VNode(
+    tag,
+    data,
+    children,
+    text,
+    elm,
+    context,
+    componentOptions,
+    asyncFactory
+  ) {
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
   };
 
   var prototypeAccessors = { child: { configurable: true } };
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   prototypeAccessors.child.get = function () {
-      return this.componentInstance;
+    return this.componentInstance;
   };
 
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
+  Object.defineProperties(VNode.prototype, prototypeAccessors);
   var createEmptyVNode = function (text) {
-      if ( text === void 0 ) text = '';
+    if (text === void 0) text = "";
 
-      var node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
+    var node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
   };
   function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
+    return new VNode(undefined, undefined, undefined, String(val));
   }
   // optimized shallow clone
   // used for static nodes and slot nodes because they may be reused across
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
   function cloneVNode(vnode) {
-      var cloned = new VNode(
+    var cloned = new VNode(
       //@ts-expect-error void type not valid here
-      vnode.tag, vnode.data, 
+      vnode.tag,
+      vnode.data,
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
+      vnode.children && vnode.children.slice(),
+      vnode.text,
+      vnode.elm,
+      vnode.context,
+      vnode.componentOptions,
+      vnode.asyncFactory
+    );
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
   }
 
   /*
@@ -743,41 +802,44 @@
   var arrayProto = Array.prototype;
   var arrayMethods = Object.create(arrayProto);
   var methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse' ];
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice",
+    "sort",
+    "reverse",
+  ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-      // cache original method
-      var original = arrayProto[method];
-      def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
+    // cache original method
+    var original = arrayProto[method];
+    def(arrayMethods, method, function mutator() {
+      var args = [],
+        len = arguments.length;
+      while (len--) args[len] = arguments[len];
 
-          var result = original.apply(this, args);
-          var ob = this.__ob__;
-          var inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              { ob.observeArray(inserted); }
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
+      var result = original.apply(this, args);
+      var ob = this.__ob__;
+      var inserted;
+      switch (method) {
+        case "push":
+        case "unshift":
+          inserted = args;
+          break;
+        case "splice":
+          inserted = args.slice(2);
+          break;
+      }
+      if (inserted) {
+        ob.observeArray(inserted);
+      }
+      // notify change
+      ob.dep.notify();
+      return result;
+    });
   });
 
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
@@ -787,7 +849,7 @@
    */
   var shouldObserve = true;
   function toggleObserving(value) {
-      shouldObserve = value;
+    shouldObserve = value;
   }
   /**
    * Observer class that is attached to each observed
@@ -796,41 +858,39 @@
    * collect dependencies and dispatch updates.
    */
   var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
-          }
-          else {
-              copyAugment(value, arrayMethods, arrayKeys);
-          }
-          this.observeArray(value);
-      }
-      else {
-          this.walk(value);
-      }
+    this.value = value;
+    this.dep = new Dep();
+    this.vmCount = 0;
+    def(value, "__ob__", this);
+    if (Array.isArray(value)) {
+      if (hasProto) {
+        protoAugment(value, arrayMethods);
+      } else {
+        copyAugment(value, arrayMethods, arrayKeys);
+      }
+      this.observeArray(value);
+    } else {
+      this.walk(value);
+    }
   };
   /**
    * Walk through all properties and convert them into
    * getter/setters. This method should only be called when
    * value type is Object.
    */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive(obj, keys[i]);
-      }
+  Observer.prototype.walk = function walk(obj) {
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+      defineReactive(obj, keys[i]);
+    }
   };
   /**
    * Observe a list of Array items.
    */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
-      }
+  Observer.prototype.observeArray = function observeArray(items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+      observe(items[i]);
+    }
   };
   // helpers
   /**
@@ -838,9 +898,9 @@
    * the prototype chain using __proto__
    */
   function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
   }
   /**
    * Augment a target Object or Array by defining
@@ -848,10 +908,10 @@
    */
   /* istanbul ignore next */
   function copyAugment(target, src, keys) {
-      for (var i = 0, l = keys.length; i < l; i++) {
-          var key = keys[i];
-          def(target, key, src[key]);
-      }
+    for (var i = 0, l = keys.length; i < l; i++) {
+      var key = keys[i];
+      def(target, key, src[key]);
+    }
   }
   /**
    * Attempt to create an observer instance for a value,
@@ -859,80 +919,81 @@
    * or the existing observer if the value already has one.
    */
   function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      var ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
+    if (!isObject(value) || value instanceof VNode) {
+      return;
+    }
+    var ob;
+    if (hasOwn(value, "__ob__") && value.__ob__ instanceof Observer) {
+      ob = value.__ob__;
+    } else if (
+      shouldObserve &&
+      !isServerRendering() &&
+      (Array.isArray(value) || isPlainObject(value)) &&
+      Object.isExtensible(value) &&
+      !value._isVue
+    ) {
+      ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+      ob.vmCount++;
+    }
+    return ob;
   }
   /**
    * Define a reactive property on an Object.
    */
   function defineReactive(obj, key, val, customSetter, shallow) {
-      var dep = new Dep();
-      var property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
+    var dep = new Dep();
+    var property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+      return;
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get;
+    var setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+      val = obj[key];
+    }
+    var childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+      enumerable: true,
+      configurable: true,
+      get: function reactiveGetter() {
+        var value = getter ? getter.call(obj) : val;
+        if (Dep.target) {
+          dep.depend();
+          if (childOb) {
+            childOb.dep.depend();
+            if (Array.isArray(value)) {
+              dependArray(value);
+            }
+          }
+        }
+        return value;
+      },
+      set: function reactiveSetter(newVal) {
+        var value = getter ? getter.call(obj) : val;
+        /* eslint-disable no-self-compare */
+        if (newVal === value || (newVal !== newVal && value !== value)) {
           return;
-      }
-      // cater for pre-defined getter/setters
-      var getter = property && property.get;
-      var setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      var childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              var value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              var value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  { return; }
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
+        }
+        /* eslint-enable no-self-compare */
+        if (customSetter) {
+          customSetter();
+        }
+        // #7981: for accessor properties without setter
+        if (getter && !setter) {
+          return;
+        }
+        if (setter) {
+          setter.call(obj, newVal);
+        } else {
+          val = newVal;
+        }
+        childOb = !shallow && observe(newVal);
+        dep.notify();
+      },
+    });
   }
   /**
    * Set a property on an object. Adds the new property and
@@ -940,72 +1001,82 @@
    * already exist.
    */
   function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      var ob = target.__ob__;
-      // @ts-ignore
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
+    if (isUndef(target) || isPrimitive(target)) {
+      warn(
+        "Cannot set reactive property on undefined, null, or primitive value: " +
+          target
+      );
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+      target.length = Math.max(target.length, key);
+      target.splice(key, 1, val);
+      return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+      target[key] = val;
+      return val;
+    }
+    var ob = target.__ob__;
+    // @ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+      warn(
+        "Avoid adding reactive properties to a Vue instance or its root $data " +
+          "at runtime - declare it upfront in the data option."
+      );
       return val;
+    }
+    if (!ob) {
+      target[key] = val;
+      return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
   }
   /**
    * Delete a property and trigger change if necessary.
    */
   function del(target, key) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.splice(key, 1);
-          return;
-      }
-      var ob = target.__ob__;
-      //@ts-ignore
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                  '- just set it to null.');
-          return;
-      }
-      if (!hasOwn(target, key)) {
-          return;
-      }
-      delete target[key];
-      if (!ob) {
-          return;
-      }
-      ob.dep.notify();
+    if (isUndef(target) || isPrimitive(target)) {
+      warn(
+        "Cannot delete reactive property on undefined, null, or primitive value: " +
+          target
+      );
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+      target.splice(key, 1);
+      return;
+    }
+    var ob = target.__ob__;
+    //@ts-ignore
+    if (target._isVue || (ob && ob.vmCount)) {
+      warn(
+        "Avoid deleting properties on a Vue instance or its root $data " +
+          "- just set it to null."
+      );
+      return;
+    }
+    if (!hasOwn(target, key)) {
+      return;
+    }
+    delete target[key];
+    if (!ob) {
+      return;
+    }
+    ob.dep.notify();
   }
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+      e = value[i];
+      e && e.__ob__ && e.__ob__.dep.depend();
+      if (Array.isArray(e)) {
+        dependArray(e);
       }
+    }
   }
 
   /**
@@ -1018,117 +1089,128 @@
    * Options with restrictions
    */
   {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn("option \"" + key + "\" can only be used during instance " +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+      if (!vm) {
+        warn(
+          'option "' +
+            key +
+            '" can only be used during instance ' +
+            "creation with the `new` keyword."
+        );
+      }
+      return defaultStrat(parent, child);
+    };
   }
   /**
    * Helper that recursively merges two data objects together.
    */
   function mergeData(to, from) {
-      if (!from)
-          { return to; }
-      var key, toVal, fromVal;
-      var keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (var i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              { continue; }
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
+    if (!from) {
       return to;
+    }
+    var key, toVal, fromVal;
+    var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);
+    for (var i = 0; i < keys.length; i++) {
+      key = keys[i];
+      // in case the object is already observed...
+      if (key === "__ob__") {
+        continue;
+      }
+      toVal = to[key];
+      fromVal = from[key];
+      if (!hasOwn(to, key)) {
+        set(to, key, fromVal);
+      } else if (
+        toVal !== fromVal &&
+        isPlainObject(toVal) &&
+        isPlainObject(fromVal)
+      ) {
+        mergeData(toVal, fromVal);
+      }
+    }
+    return to;
   }
   /**
    * Data
    */
   function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(
-              // @ts-ignore
-              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-              // @ts-ignore
-              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
+    if (!vm) {
+      // in a Vue.extend merge, both should be functions
+      if (!childVal) {
+        return parentVal;
+      }
+      if (!parentVal) {
+        return childVal;
+      }
+      // when parentVal & childVal are both present,
+      // we need to return a function that returns the
+      // merged result of both functions... no need to
+      // check if parentVal is a function here because
+      // it has to be a function to pass previous merges.
+      return function mergedDataFn() {
+        return mergeData(
+          // @ts-ignore
+          typeof childVal === "function" ? childVal.call(this, this) : childVal,
+          // @ts-ignore
+          typeof parentVal === "function"
+            ? parentVal.call(this, this)
+            : parentVal
+        );
+      };
+    } else {
+      return function mergedInstanceDataFn() {
+        // instance merge
+        var instanceData =
+          typeof childVal === "function" ? childVal.call(vm, vm) : childVal;
+        var defaultData =
+          typeof parentVal === "function" ? parentVal.call(vm, vm) : parentVal;
+        if (instanceData) {
+          return mergeData(instanceData, defaultData);
+        } else {
+          return defaultData;
+        }
+      };
+    }
   }
   strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
+    if (!vm) {
+      if (childVal && typeof childVal !== "function") {
+        warn(
+          'The "data" option should be a function ' +
+            "that returns a per-instance value in component " +
+            "definitions.",
+          vm
+        );
+        return parentVal;
+      }
+      return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
   };
   /**
    * Hooks and props are merged as arrays.
    */
   function mergeHook$1(parentVal, childVal) {
-      var res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
+    var res = childVal
+      ? parentVal
+        ? parentVal.concat(childVal)
+        : Array.isArray(childVal)
+        ? childVal
+        : [childVal]
+      : parentVal;
+    return res ? dedupeHooks(res) : res;
   }
   function dedupeHooks(hooks) {
-      var res = [];
-      for (var i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
+    var res = [];
+    for (var i = 0; i < hooks.length; i++) {
+      if (res.indexOf(hooks[i]) === -1) {
+        res.push(hooks[i]);
       }
-      return res;
+    }
+    return res;
   }
   LIFECYCLE_HOOKS.forEach(function (hook) {
-      strats[hook] = mergeHook$1;
+    strats[hook] = mergeHook$1;
   });
   /**
    * Assets
@@ -1138,17 +1220,16 @@
    * options and parent options.
    */
   function mergeAssets(parentVal, childVal, vm, key) {
-      var res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
+    var res = Object.create(parentVal || null);
+    if (childVal) {
+      assertObjectType(key, childVal, vm);
+      return extend(res, childVal);
+    } else {
+      return res;
+    }
   }
   ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
+    strats[type + "s"] = mergeAssets;
   });
   /**
    * Watchers.
@@ -1157,206 +1238,239 @@
    * another, so we merge them as arrays.
    */
   strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          { parentVal = undefined; }
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          { childVal = undefined; }
-      /* istanbul ignore if */
-      if (!childVal)
-          { return Object.create(parentVal || null); }
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          { return childVal; }
-      var ret = {};
-      extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key$1] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch) {
+      parentVal = undefined;
+    }
+    //@ts-expect-error work around
+    if (childVal === nativeWatch) {
+      childVal = undefined;
+    }
+    /* istanbul ignore if */
+    if (!childVal) {
+      return Object.create(parentVal || null);
+    }
+    {
+      assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal) {
+      return childVal;
+    }
+    var ret = {};
+    extend(ret, parentVal);
+    for (var key$1 in childVal) {
+      var parent = ret[key$1];
+      var child = childVal[key$1];
+      if (parent && !Array.isArray(parent)) {
+        parent = [parent];
+      }
+      ret[key$1] = parent
+        ? parent.concat(child)
+        : Array.isArray(child)
+        ? child
+        : [child];
+    }
+    return ret;
   };
   /**
    * Other object hashes.
    */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          { return childVal; }
-      var ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          { extend(ret, childVal); }
-      return ret;
+  strats.props = strats.methods = strats.inject = strats.computed = function (
+    parentVal,
+    childVal,
+    vm,
+    key
+  ) {
+    if (childVal && "development" !== "production") {
+      assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal) {
+      return childVal;
+    }
+    var ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal) {
+      extend(ret, childVal);
+    }
+    return ret;
   };
   strats.provide = mergeDataOrFn;
   /**
    * Default strategy.
    */
   var defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
+    return childVal === undefined ? parentVal : childVal;
   };
   /**
    * Validate component names
    */
   function checkComponents(options) {
-      for (var key in options.components) {
-          validateComponentName(key);
-      }
+    for (var key in options.components) {
+      validateComponentName(key);
+    }
   }
   function validateComponentName(name) {
-      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-          warn('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
+    if (
+      !new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(
+        name
+      )
+    ) {
+      warn(
+        'Invalid component name: "' +
+          name +
+          '". Component names ' +
+          "should conform to valid custom element name in html5 specification."
+      );
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+      warn(
+        "Do not use built-in or reserved HTML elements as component " +
+          "id: " +
+          name
+      );
+    }
   }
   /**
    * Ensure all props option syntax are normalized into the
    * Object-based format.
    */
   function normalizeProps(options, vm) {
-      var props = options.props;
-      if (!props)
-          { return; }
-      var res = {};
-      var i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (var key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn("Invalid value for option \"props\": expected an Array or an Object, " +
-              "but got " + (toRawType(props)) + ".", vm);
-      }
-      options.props = res;
+    var props = options.props;
+    if (!props) {
+      return;
+    }
+    var res = {};
+    var i, val, name;
+    if (Array.isArray(props)) {
+      i = props.length;
+      while (i--) {
+        val = props[i];
+        if (typeof val === "string") {
+          name = camelize(val);
+          res[name] = { type: null };
+        } else {
+          warn("props must be strings when using array syntax.");
+        }
+      }
+    } else if (isPlainObject(props)) {
+      for (var key in props) {
+        val = props[key];
+        name = camelize(key);
+        res[name] = isPlainObject(val) ? val : { type: val };
+      }
+    } else {
+      warn(
+        'Invalid value for option "props": expected an Array or an Object, ' +
+          "but got " +
+          toRawType(props) +
+          ".",
+        vm
+      );
+    }
+    options.props = res;
   }
   /**
    * Normalize all injections into Object-based format
    */
   function normalizeInject(options, vm) {
-      var inject = options.inject;
-      if (!inject)
-          { return; }
-      var normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (var i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (var key in inject) {
-              var val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-              "but got " + (toRawType(inject)) + ".", vm);
-      }
+    var inject = options.inject;
+    if (!inject) {
+      return;
+    }
+    var normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+      for (var i = 0; i < inject.length; i++) {
+        normalized[inject[i]] = { from: inject[i] };
+      }
+    } else if (isPlainObject(inject)) {
+      for (var key in inject) {
+        var val = inject[key];
+        normalized[key] = isPlainObject(val)
+          ? extend({ from: key }, val)
+          : { from: val };
+      }
+    } else {
+      warn(
+        'Invalid value for option "inject": expected an Array or an Object, ' +
+          "but got " +
+          toRawType(inject) +
+          ".",
+        vm
+      );
+    }
   }
   /**
    * Normalize raw function directives into object format.
    */
   function normalizeDirectives$1(options) {
-      var dirs = options.directives;
-      if (dirs) {
-          for (var key in dirs) {
-              var def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
+    var dirs = options.directives;
+    if (dirs) {
+      for (var key in dirs) {
+        var def = dirs[key];
+        if (typeof def === "function") {
+          dirs[key] = { bind: def, update: def };
+        }
       }
+    }
   }
   function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
-      }
+    if (!isPlainObject(value)) {
+      warn(
+        'Invalid value for option "' +
+          name +
+          '": expected an Object, ' +
+          "but got " +
+          toRawType(value) +
+          ".",
+        vm
+      );
+    }
   }
   /**
    * Merge two option objects into a new one.
    * Core utility used in both instantiation and inheritance.
    */
   function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives$1(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (var i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      var options = {};
-      var key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          var strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
+    {
+      checkComponents(child);
+    }
+    if (typeof child === "function") {
+      // @ts-expect-error
+      child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+      if (child.extends) {
+        parent = mergeOptions(parent, child.extends, vm);
+      }
+      if (child.mixins) {
+        for (var i = 0, l = child.mixins.length; i < l; i++) {
+          parent = mergeOptions(parent, child.mixins[i], vm);
+        }
+      }
+    }
+    var options = {};
+    var key;
+    for (key in parent) {
+      mergeField(key);
+    }
+    for (key in child) {
+      if (!hasOwn(parent, key)) {
+        mergeField(key);
+      }
+    }
+    function mergeField(key) {
+      var strat = strats[key] || defaultStrat;
+      options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
   }
   /**
    * Resolve an asset.
@@ -1364,161 +1478,174 @@
    * to assets defined in its ancestor chain.
    */
   function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      var assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          { return assets[id]; }
-      var camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          { return assets[camelizedId]; }
-      var PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          { return assets[PascalCaseId]; }
-      // fallback to prototype chain
-      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
+    /* istanbul ignore if */
+    if (typeof id !== "string") {
+      return;
+    }
+    var assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id)) {
+      return assets[id];
+    }
+    var camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId)) {
+      return assets[camelizedId];
+    }
+    var PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId)) {
+      return assets[PascalCaseId];
+    }
+    // fallback to prototype chain
+    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+      warn("Failed to resolve " + type.slice(0, -1) + ": " + id, options);
+    }
+    return res;
   }
 
   function validateProp(key, propOptions, propsData, vm) {
-      var prop = propOptions[key];
-      var absent = !hasOwn(propsData, key);
-      var value = propsData[key];
-      // boolean casting
-      var booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              var stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          var prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
+    var prop = propOptions[key];
+    var absent = !hasOwn(propsData, key);
+    var value = propsData[key];
+    // boolean casting
+    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+      if (absent && !hasOwn(prop, "default")) {
+        value = false;
+      } else if (value === "" || value === hyphenate(key)) {
+        // only cast empty string / same name to boolean if
+        // boolean has higher priority
+        var stringIndex = getTypeIndex(String, prop.type);
+        if (stringIndex < 0 || booleanIndex < stringIndex) {
+          value = true;
+        }
+      }
+    }
+    // check default value
+    if (value === undefined) {
+      value = getPropDefaultValue(vm, prop, key);
+      // since the default value is a fresh copy,
+      // make sure to observe it.
+      var prevShouldObserve = shouldObserve;
+      toggleObserving(true);
+      observe(value);
+      toggleObserving(prevShouldObserve);
+    }
+    {
+      assertProp(prop, key, value, vm, absent);
+    }
+    return value;
   }
   /**
    * Get the default value of a prop.
    */
   function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      var def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
+    // no default, return undefined
+    if (!hasOwn(prop, "default")) {
+      return undefined;
+    }
+    var def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+      warn(
+        'Invalid default value for prop "' +
+          key +
+          '": ' +
+          "Props with type Object/Array must use a factory function " +
+          "to return the default value.",
+        vm
+      );
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (
+      vm &&
+      vm.$options.propsData &&
+      vm.$options.propsData[key] === undefined &&
+      vm._props[key] !== undefined
+    ) {
+      return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === "function" && getType(prop.type) !== "Function"
+      ? def.call(vm)
+      : def;
   }
   /**
    * Assert whether a prop is valid.
    */
   function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      var type = prop.type;
-      // @ts-ignore
-      var valid = !type || type === true;
-      var expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (var i = 0; i < type.length && !valid; i++) {
-              var assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
-      if (!valid && haveExpectedTypes) {
-          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      var validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
+    if (prop.required && absent) {
+      warn('Missing required prop: "' + name + '"', vm);
+      return;
+    }
+    if (value == null && !prop.required) {
+      return;
+    }
+    var type = prop.type;
+    // @ts-ignore
+    var valid = !type || type === true;
+    var expectedTypes = [];
+    if (type) {
+      if (!Array.isArray(type)) {
+        type = [type];
+      }
+      for (var i = 0; i < type.length && !valid; i++) {
+        var assertedType = assertType(value, type[i], vm);
+        expectedTypes.push(assertedType.expectedType || "");
+        valid = assertedType.valid;
+      }
+    }
+    var haveExpectedTypes = expectedTypes.some(function (t) {
+      return t;
+    });
+    if (!valid && haveExpectedTypes) {
+      warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+      return;
+    }
+    var validator = prop.validator;
+    if (validator) {
+      if (!validator(value)) {
+        warn(
+          'Invalid prop: custom validator check failed for prop "' +
+            name +
+            '".',
+          vm
+        );
+      }
+    }
   }
   var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
   function assertType(value, type, vm) {
-      var valid;
-      var expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          var t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid: valid,
-          expectedType: expectedType,
-      };
+    var valid;
+    var expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+      var t = typeof value;
+      valid = t === expectedType.toLowerCase();
+      // for primitive wrapper objects
+      if (!valid && t === "object") {
+        valid = value instanceof type;
+      }
+    } else if (expectedType === "Object") {
+      valid = isPlainObject(value);
+    } else if (expectedType === "Array") {
+      valid = Array.isArray(value);
+    } else {
+      try {
+        valid = value instanceof type;
+      } catch (e) {
+        warn(
+          'Invalid prop type: "' + String(type) + '" is not a constructor',
+          vm
+        );
+        valid = false;
+      }
+    }
+    return {
+      valid: valid,
+      expectedType: expectedType,
+    };
   }
   var functionTypeCheckRE = /^\s*function (\w+)/;
   /**
@@ -1527,135 +1654,142 @@
    * across different vms / iframes.
    */
   function getType(fn) {
-      var match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
+    var match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : "";
   }
   function isSameType(a, b) {
-      return getType(a) === getType(b);
+    return getType(a) === getType(b);
   }
   function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (var i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
+    if (!Array.isArray(expectedTypes)) {
+      return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+      if (isSameType(expectedTypes[i], type)) {
+        return i;
       }
-      return -1;
+    }
+    return -1;
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
-      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          " Expected " + (expectedTypes.map(capitalize).join(', '));
-      var expectedType = expectedTypes[0];
-      var receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += " with value " + (styleValue(value, expectedType));
-      }
-      message += ", got " + receivedType + " ";
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += "with value " + (styleValue(value, receivedType)) + ".";
-      }
-      return message;
+    var message =
+      'Invalid prop: type check failed for prop "' +
+      name +
+      '".' +
+      " Expected " +
+      expectedTypes.map(capitalize).join(", ");
+    var expectedType = expectedTypes[0];
+    var receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (
+      expectedTypes.length === 1 &&
+      isExplicable(expectedType) &&
+      isExplicable(typeof value) &&
+      !isBoolean(expectedType, receivedType)
+    ) {
+      message += " with value " + styleValue(value, expectedType);
+    }
+    message += ", got " + receivedType + " ";
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+      message += "with value " + styleValue(value, receivedType) + ".";
+    }
+    return message;
   }
   function styleValue(value, type) {
-      if (type === 'String') {
-          return ("\"" + value + "\"");
-      }
-      else if (type === 'Number') {
-          return ("" + (Number(value)));
-      }
-      else {
-          return ("" + value);
-      }
-  }
-  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+    if (type === "String") {
+      return '"' + value + '"';
+    } else if (type === "Number") {
+      return "" + Number(value);
+    } else {
+      return "" + value;
+    }
+  }
+  var EXPLICABLE_TYPES = ["string", "number", "boolean"];
   function isExplicable(value) {
-      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+    return EXPLICABLE_TYPES.some(function (elem) {
+      return value.toLowerCase() === elem;
+    });
   }
   function isBoolean() {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
+    var args = [],
+      len = arguments.length;
+    while (len--) args[len] = arguments[len];
 
-      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+    return args.some(function (elem) {
+      return elem.toLowerCase() === "boolean";
+    });
   }
 
   function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              var cur = vm;
-              while ((cur = cur.$parent)) {
-                  var hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (var i = 0; i < hooks.length; i++) {
-                          try {
-                              var capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  { return; }
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+      if (vm) {
+        var cur = vm;
+        while ((cur = cur.$parent)) {
+          var hooks = cur.$options.errorCaptured;
+          if (hooks) {
+            for (var i = 0; i < hooks.length; i++) {
+              try {
+                var capture = hooks[i].call(cur, err, vm, info) === false;
+                if (capture) {
+                  return;
+                }
+              } catch (e) {
+                globalHandleError(e, cur, "errorCaptured hook");
               }
+            }
           }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
+        }
       }
+      globalHandleError(err, vm, info);
+    } finally {
+      popTarget();
+    }
   }
   function invokeWithErrorHandling(handler, context, args, vm, info) {
-      var res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          handleError(e, vm, info);
-      }
-      return res;
+    var res;
+    try {
+      res = args ? handler.apply(context, args) : handler.call(context);
+      if (res && !res._isVue && isPromise(res) && !res._handled) {
+        res.catch(function (e) {
+          return handleError(e, vm, info + " (Promise/async)");
+        });
+        // issue #9511
+        // avoid catch triggering multiple times when nested calls
+        res._handled = true;
+      }
+    } catch (e) {
+      handleError(e, vm, info);
+    }
+    return res;
   }
   function globalHandleError(err, vm, info) {
-      if (config.errorHandler) {
-          try {
-              return config.errorHandler.call(null, err, vm, info);
-          }
-          catch (e) {
-              // if the user intentionally throws the original error in the handler,
-              // do not log it twice
-              if (e !== err) {
-                  logError(e, null, 'config.errorHandler');
-              }
-          }
+    if (config.errorHandler) {
+      try {
+        return config.errorHandler.call(null, err, vm, info);
+      } catch (e) {
+        // if the user intentionally throws the original error in the handler,
+        // do not log it twice
+        if (e !== err) {
+          logError(e, null, "config.errorHandler");
+        }
       }
-      logError(err, vm, info);
+    }
+    logError(err, vm, info);
   }
   function logError(err, vm, info) {
-      {
-          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
+    {
+      warn("Error in " + info + ': "' + err.toString() + '"', vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== "undefined") {
+      console.error(err);
+    } else {
+      throw err;
+    }
   }
 
   /* globals MutationObserver */
@@ -1663,12 +1797,12 @@
   var callbacks = [];
   var pending = false;
   function flushCallbacks() {
-      pending = false;
-      var copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (var i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
+    pending = false;
+    var copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (var i = 0; i < copies.length; i++) {
+      copies[i]();
+    }
   }
   // Here we have async deferring wrappers using microtasks.
   // In 2.5 we used (macro) tasks (in combination with microtasks).
@@ -1689,156 +1823,175 @@
   // completely stops working after triggering a few times... so, if native
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p = Promise.resolve();
-      timerFunc = function () {
-          p.then(flushCallbacks);
-          // In problematic UIWebViews, Promise.then doesn't completely break, but
-          // it can get stuck in a weird state where callbacks are pushed into the
-          // microtask queue but the queue isn't being flushed, until the browser
-          // needs to do some other work, e.g. handle a timer. Therefore we can
-          // "force" the microtask queue to be flushed by adding an empty timer.
-          if (isIOS)
-              { setTimeout(noop); }
-      };
-      isUsingMicroTask = true;
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
-      var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-      timerFunc = function () {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-      // Fallback to setImmediate.
-      // Technically it leverages the (macro) task queue,
-      // but it is still a better choice than setTimeout.
-      timerFunc = function () {
-          setImmediate(flushCallbacks);
-      };
-  }
-  else {
-      // Fallback to setTimeout.
-      timerFunc = function () {
-          setTimeout(flushCallbacks, 0);
-      };
+  if (typeof Promise !== "undefined" && isNative(Promise)) {
+    var p = Promise.resolve();
+    timerFunc = function () {
+      p.then(flushCallbacks);
+      // In problematic UIWebViews, Promise.then doesn't completely break, but
+      // it can get stuck in a weird state where callbacks are pushed into the
+      // microtask queue but the queue isn't being flushed, until the browser
+      // needs to do some other work, e.g. handle a timer. Therefore we can
+      // "force" the microtask queue to be flushed by adding an empty timer.
+      if (isIOS) {
+        setTimeout(noop);
+      }
+    };
+    isUsingMicroTask = true;
+  } else if (
+    !isIE &&
+    typeof MutationObserver !== "undefined" &&
+    (isNative(MutationObserver) ||
+      // PhantomJS and iOS 7.x
+      MutationObserver.toString() === "[object MutationObserverConstructor]")
+  ) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter = 1;
+    var observer = new MutationObserver(flushCallbacks);
+    var textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+      characterData: true,
+    });
+    timerFunc = function () {
+      counter = (counter + 1) % 2;
+      textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+  } else if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = function () {
+      setImmediate(flushCallbacks);
+    };
+  } else {
+    // Fallback to setTimeout.
+    timerFunc = function () {
+      setTimeout(flushCallbacks, 0);
+    };
   }
   function nextTick(cb, ctx) {
-      var _resolve;
-      callbacks.push(function () {
-          if (cb) {
-              try {
-                  cb.call(ctx);
-              }
-              catch (e) {
-                  handleError(e, ctx, 'nextTick');
-              }
-          }
-          else if (_resolve) {
-              _resolve(ctx);
-          }
+    var _resolve;
+    callbacks.push(function () {
+      if (cb) {
+        try {
+          cb.call(ctx);
+        } catch (e) {
+          handleError(e, ctx, "nextTick");
+        }
+      } else if (_resolve) {
+        _resolve(ctx);
+      }
+    });
+    if (!pending) {
+      pending = true;
+      timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== "undefined") {
+      return new Promise(function (resolve) {
+        _resolve = resolve;
       });
-      if (!pending) {
-          pending = true;
-          timerFunc();
-      }
-      // $flow-disable-line
-      if (!cb && typeof Promise !== 'undefined') {
-          return new Promise(function (resolve) {
-              _resolve = resolve;
-          });
-      }
+    }
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
   var initProxy;
   {
-      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
+    var allowedGlobals = makeMap(
+      "Infinity,undefined,NaN,isFinite,isNaN," +
+        "parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent," +
+        "Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt," +
+        "require" // for Webpack/Browserify
+    );
+    var warnNonPresent = function (target, key) {
+      warn(
+        'Property or method "' +
+          key +
+          '" is not defined on the instance but ' +
+          "referenced during render. Make sure that this property is reactive, " +
+          "either in the data option, or for class-based components, by " +
+          "initializing the property. " +
+          "See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.",
+        target
       );
-      var warnNonPresent = function (target, key) {
-          warn("Property or method \"" + key + "\" is not defined on the instance but " +
-              'referenced during render. Make sure that this property is reactive, ' +
-              'either in the data option, or for class-based components, by ' +
-              'initializing the property. ' +
-              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-      };
-      var warnReservedPrefix = function (target, key) {
-          warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-              'prevent conflicts with Vue internals. ' +
-              'See: https://vuejs.org/v2/api/#data', target);
-      };
-      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    };
+    var warnReservedPrefix = function (target, key) {
+      warn(
+        'Property "' +
+          key +
+          '" must be accessed with "$data.' +
+          key +
+          '" because ' +
+          'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+          "prevent conflicts with Vue internals. " +
+          "See: https://vuejs.org/v2/api/#data",
+        target
+      );
+    };
+    var hasProxy = typeof Proxy !== "undefined" && isNative(Proxy);
+    if (hasProxy) {
+      var isBuiltInModifier = makeMap(
+        "stop,prevent,self,ctrl,shift,alt,meta,exact"
+      );
+      config.keyCodes = new Proxy(config.keyCodes, {
+        set: function set(target, key, value) {
+          if (isBuiltInModifier(key)) {
+            warn(
+              "Avoid overwriting built-in modifier in config.keyCodes: ." + key
+            );
+            return false;
+          } else {
+            target[key] = value;
+            return true;
+          }
+        },
+      });
+    }
+    var hasHandler = {
+      has: function has(target, key) {
+        var has = key in target;
+        var isAllowed =
+          allowedGlobals(key) ||
+          (typeof key === "string" &&
+            key.charAt(0) === "_" &&
+            !(key in target.$data));
+        if (!has && !isAllowed) {
+          if (key in target.$data) {
+            warnReservedPrefix(target, key);
+          } else {
+            warnNonPresent(target, key);
+          }
+        }
+        return has || !isAllowed;
+      },
+    };
+    var getHandler = {
+      get: function get(target, key) {
+        if (typeof key === "string" && !(key in target)) {
+          if (key in target.$data) {
+            warnReservedPrefix(target, key);
+          } else {
+            warnNonPresent(target, key);
+          }
+        }
+        return target[key];
+      },
+    };
+    initProxy = function initProxy(vm) {
       if (hasProxy) {
-          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set: function set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-      var hasHandler = {
-          has: function has(target, key) {
-              var has = key in target;
-              var isAllowed = allowedGlobals(key) ||
-                  (typeof key === 'string' &&
-                      key.charAt(0) === '_' &&
-                      !(key in target.$data));
-              if (!has && !isAllowed) {
-                  if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
-                  else
-                      { warnNonPresent(target, key); }
-              }
-              return has || !isAllowed;
-          },
-      };
-      var getHandler = {
-          get: function get(target, key) {
-              if (typeof key === 'string' && !(key in target)) {
-                  if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
-                  else
-                      { warnNonPresent(target, key); }
-              }
-              return target[key];
-          },
-      };
-      initProxy = function initProxy(vm) {
-          if (hasProxy) {
-              // determine which proxy handler to use
-              var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-              vm._renderProxy = new Proxy(vm, handlers);
-          }
-          else {
-              vm._renderProxy = vm;
-          }
-      };
+        // determine which proxy handler to use
+        var options = vm.$options;
+        var handlers =
+          options.render && options.render._withStripped
+            ? getHandler
+            : hasHandler;
+        vm._renderProxy = new Proxy(vm, handlers);
+      } else {
+        vm._renderProxy = vm;
+      }
+    };
   }
 
   var seenObjects = new _Set();
@@ -1848,204 +2001,236 @@
    * is collected as a "deep" dependency.
    */
   function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
+    _traverse(val, seenObjects);
+    seenObjects.clear();
   }
   function _traverse(val, seen) {
-      var i, keys;
-      var isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          var depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              { _traverse(val[i], seen); }
+    var i, keys;
+    var isA = Array.isArray(val);
+    if (
+      (!isA && !isObject(val)) ||
+      Object.isFrozen(val) ||
+      val instanceof VNode
+    ) {
+      return;
+    }
+    if (val.__ob__) {
+      var depId = val.__ob__.dep.id;
+      if (seen.has(depId)) {
+        return;
+      }
+      seen.add(depId);
+    }
+    if (isA) {
+      i = val.length;
+      while (i--) {
+        _traverse(val[i], seen);
       }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              { _traverse(val[keys[i]], seen); }
+    } else {
+      keys = Object.keys(val);
+      i = keys.length;
+      while (i--) {
+        _traverse(val[keys[i]], seen);
       }
+    }
   }
 
   var mark;
   var measure;
   {
-      var perf = inBrowser && window.performance;
-      /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = function (tag) { return perf.mark(tag); };
-          measure = function (name, startTag, endTag) {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
-              // perf.clearMeasures(name)
-          };
-      }
+    var perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (
+      perf &&
+      perf.mark &&
+      perf.measure &&
+      perf.clearMarks &&
+      perf.clearMeasures
+    ) {
+      mark = function (tag) {
+        return perf.mark(tag);
+      };
+      measure = function (name, startTag, endTag) {
+        perf.measure(name, startTag, endTag);
+        perf.clearMarks(startTag);
+        perf.clearMarks(endTag);
+        // perf.clearMeasures(name)
+      };
+    }
   }
 
   var normalizeEvent = cached(function (name) {
-      var passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      var once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      var capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name: name,
-          once: once,
-          capture: capture,
-          passive: passive,
-      };
+    var passive = name.charAt(0) === "&";
+    name = passive ? name.slice(1) : name;
+    var once = name.charAt(0) === "~"; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    var capture = name.charAt(0) === "!";
+    name = capture ? name.slice(1) : name;
+    return {
+      name: name,
+      once: once,
+      capture: capture,
+      passive: passive,
+    };
   });
   function createFnInvoker(fns, vm) {
-      function invoker() {
-          var arguments$1 = arguments;
+    function invoker() {
+      var arguments$1 = arguments;
 
-          var fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              var cloned = fns.slice();
-              for (var i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
+      var fns = invoker.fns;
+      if (Array.isArray(fns)) {
+        var cloned = fns.slice();
+        for (var i = 0; i < cloned.length; i++) {
+          invokeWithErrorHandling(
+            cloned[i],
+            null,
+            arguments$1,
+            vm,
+            "v-on handler"
+          );
+        }
+      } else {
+        // return handler return value for single handlers
+        return invokeWithErrorHandling(
+          fns,
+          null,
+          arguments,
+          vm,
+          "v-on handler"
+        );
+      }
+    }
+    invoker.fns = fns;
+    return invoker;
   }
   function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      var name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
+    var name, cur, old, event;
+    for (name in on) {
+      cur = on[name];
+      old = oldOn[name];
+      event = normalizeEvent(name);
+      if (isUndef(cur)) {
+        warn(
+          'Invalid handler for event "' + event.name + '": got ' + String(cur),
+          vm
+        );
+      } else if (isUndef(old)) {
+        if (isUndef(cur.fns)) {
+          cur = on[name] = createFnInvoker(cur, vm);
+        }
+        if (isTrue(event.once)) {
+          cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+        }
+        add(event.name, cur, event.capture, event.passive, event.params);
+      } else if (cur !== old) {
+        old.fns = cur;
+        on[name] = old;
+      }
+    }
+    for (name in oldOn) {
+      if (isUndef(on[name])) {
+        event = normalizeEvent(name);
+        remove(event.name, oldOn[name], event.capture);
+      }
+    }
   }
 
   function mergeVNodeHook(def, hookKey, hook) {
-      if (def instanceof VNode) {
-          def = def.data.hook || (def.data.hook = {});
-      }
-      var invoker;
-      var oldHook = def[hookKey];
-      function wrappedHook() {
-          hook.apply(this, arguments);
-          // important: remove merged hook to ensure it's called only once
-          // and prevent memory leak
-          remove$2(invoker.fns, wrappedHook);
-      }
-      if (isUndef(oldHook)) {
-          // no existing hook
-          invoker = createFnInvoker([wrappedHook]);
-      }
-      else {
-          /* istanbul ignore if */
-          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-              // already a merged invoker
-              invoker = oldHook;
-              invoker.fns.push(wrappedHook);
-          }
-          else {
-              // existing plain hook
-              invoker = createFnInvoker([oldHook, wrappedHook]);
-          }
-      }
-      invoker.merged = true;
-      def[hookKey] = invoker;
+    if (def instanceof VNode) {
+      def = def.data.hook || (def.data.hook = {});
+    }
+    var invoker;
+    var oldHook = def[hookKey];
+    function wrappedHook() {
+      hook.apply(this, arguments);
+      // important: remove merged hook to ensure it's called only once
+      // and prevent memory leak
+      remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+      // no existing hook
+      invoker = createFnInvoker([wrappedHook]);
+    } else {
+      /* istanbul ignore if */
+      if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+        // already a merged invoker
+        invoker = oldHook;
+        invoker.fns.push(wrappedHook);
+      } else {
+        // existing plain hook
+        invoker = createFnInvoker([oldHook, wrappedHook]);
+      }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
   }
 
   function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      var propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      var res = {};
-      var attrs = data.attrs;
-      var props = data.props;
-      if (isDef(attrs) || isDef(props)) {
-          for (var key in propOptions) {
-              var altKey = hyphenate(key);
-              {
-                  var keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                          (formatComponentName(
-                          // @ts-ignore
-                          tag || Ctor)) + ", but the declared prop name is" +
-                          " \"" + key + "\". " +
-                          "Note that HTML attributes are case-insensitive and camelCased " +
-                          "props need to use their kebab-case equivalents when using in-DOM " +
-                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    var propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+      return;
+    }
+    var res = {};
+    var attrs = data.attrs;
+    var props = data.props;
+    if (isDef(attrs) || isDef(props)) {
+      for (var key in propOptions) {
+        var altKey = hyphenate(key);
+        {
+          var keyInLowerCase = key.toLowerCase();
+          if (
+            key !== keyInLowerCase &&
+            attrs &&
+            hasOwn(attrs, keyInLowerCase)
+          ) {
+            tip(
+              'Prop "' +
+                keyInLowerCase +
+                '" is passed to component ' +
+                formatComponentName(
+                  // @ts-ignore
+                  tag || Ctor
+                ) +
+                ", but the declared prop name is" +
+                ' "' +
+                key +
+                '". ' +
+                "Note that HTML attributes are case-insensitive and camelCased " +
+                "props need to use their kebab-case equivalents when using in-DOM " +
+                'templates. You should probably use "' +
+                altKey +
+                '" instead of "' +
+                key +
+                '".'
+            );
+          }
+        }
+        checkProp(res, props, key, altKey, true) ||
+          checkProp(res, attrs, key, altKey, false);
+      }
+    }
+    return res;
   }
   function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
+    if (isDef(hash)) {
+      if (hasOwn(hash, key)) {
+        res[key] = hash[key];
+        if (!preserve) {
+          delete hash[key];
+        }
+        return true;
+      } else if (hasOwn(hash, altKey)) {
+        res[key] = hash[altKey];
+        if (!preserve) {
+          delete hash[altKey];
+        }
+        return true;
+      }
+    }
+    return false;
   }
 
   // The template compiler attempts to minimize the need for normalization by
@@ -2060,1609 +2245,1783 @@
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
   function simpleNormalizeChildren(children) {
-      for (var i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
+    for (var i = 0; i < children.length; i++) {
+      if (Array.isArray(children[i])) {
+        return Array.prototype.concat.apply([], children);
       }
-      return children;
+    }
+    return children;
   }
   // 2. When the children contains constructs that always generated nested Arrays,
   // e.g. <template>, <slot>, v-for, or when the children is provided by user
   // with hand-written render functions / JSX. In such cases a full normalization
   // is needed to cater to all possible types of children values.
   function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
+    return isPrimitive(children)
+      ? [createTextVNode(children)]
+      : Array.isArray(children)
+      ? normalizeArrayChildren(children)
+      : undefined;
   }
   function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
   }
   function normalizeArrayChildren(children, nestedIndex) {
-      var res = [];
-      var i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              { continue; }
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
+    var res = [];
+    var i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+      c = children[i];
+      if (isUndef(c) || typeof c === "boolean") {
+        continue;
+      }
+      lastIndex = res.length - 1;
+      last = res[lastIndex];
+      //  nested
+      if (Array.isArray(c)) {
+        if (c.length > 0) {
+          c = normalizeArrayChildren(c, (nestedIndex || "") + "_" + i);
+          // merge adjacent text nodes
+          if (isTextNode(c[0]) && isTextNode(last)) {
+            res[lastIndex] = createTextVNode(last.text + c[0].text);
+            c.shift();
+          }
+          res.push.apply(res, c);
+        }
+      } else if (isPrimitive(c)) {
+        if (isTextNode(last)) {
+          // merge adjacent text nodes
+          // this is necessary for SSR hydration because text nodes are
+          // essentially merged when rendered to HTML strings
+          res[lastIndex] = createTextVNode(last.text + c);
+        } else if (c !== "") {
+          // convert primitive to vnode
+          res.push(createTextVNode(c));
+        }
+      } else {
+        if (isTextNode(c) && isTextNode(last)) {
+          // merge adjacent text nodes
+          res[lastIndex] = createTextVNode(last.text + c.text);
+        } else {
+          // default key for nested array children (likely generated by v-for)
+          if (
+            isTrue(children._isVList) &&
+            isDef(c.tag) &&
+            isUndef(c.key) &&
+            isDef(nestedIndex)
+          ) {
+            c.key = "__vlist" + nestedIndex + "_" + i + "__";
+          }
+          res.push(c);
+        }
+      }
+    }
+    return res;
   }
 
   function initProvide(vm) {
-      var provide = vm.$options.provide;
-      if (provide) {
-          vm._provided =
-              typeof provide === 'function'
-                  ? // @ts-expect-error typing not correct
-                      provide.call(vm)
-                  : provide;
-      }
+    var provide = vm.$options.provide;
+    if (provide) {
+      vm._provided =
+        typeof provide === "function"
+          ? // @ts-expect-error typing not correct
+            provide.call(vm)
+          : provide;
+    }
   }
   function initInjections(vm) {
-      var result = resolveInject(vm.$options.inject, vm);
-      if (result) {
-          toggleObserving(false);
-          Object.keys(result).forEach(function (key) {
-              /* istanbul ignore else */
-              {
-                  defineReactive(vm, key, result[key], function () {
-                      warn("Avoid mutating an injected value directly since the changes will be " +
-                          "overwritten whenever the provided component re-renders. " +
-                          "injection being mutated: \"" + key + "\"", vm);
-                  });
-              }
+    var result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+      toggleObserving(false);
+      Object.keys(result).forEach(function (key) {
+        /* istanbul ignore else */
+        {
+          defineReactive(vm, key, result[key], function () {
+            warn(
+              "Avoid mutating an injected value directly since the changes will be " +
+                "overwritten whenever the provided component re-renders. " +
+                'injection being mutated: "' +
+                key +
+                '"',
+              vm
+            );
           });
-          toggleObserving(true);
-      }
+        }
+      });
+      toggleObserving(true);
+    }
   }
   function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          var result = Object.create(null);
-          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (var i = 0; i < keys.length; i++) {
-              var key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  { continue; }
-              var provideKey = inject[key].from;
-              var source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      var provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      // @ts-ignore
-                      warn(("Injection \"" + key + "\" not found"), vm);
-                  }
-              }
+    if (inject) {
+      // inject is :any because flow is not smart enough to figure out cached
+      var result = Object.create(null);
+      var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+      for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        // #6574 in case the inject object is observed...
+        if (key === "__ob__") {
+          continue;
+        }
+        var provideKey = inject[key].from;
+        var source = vm;
+        while (source) {
+          if (source._provided && hasOwn(source._provided, provideKey)) {
+            result[key] = source._provided[provideKey];
+            break;
           }
-          return result;
-      }
+          // @ts-expect-error
+          source = source.$parent;
+        }
+        if (!source) {
+          if ("default" in inject[key]) {
+            var provideDefault = inject[key].default;
+            result[key] =
+              typeof provideDefault === "function"
+                ? provideDefault.call(vm)
+                : provideDefault;
+          } else {
+            // @ts-ignore
+            warn('Injection "' + key + '" not found', vm);
+          }
+        }
+      }
+      return result;
+    }
   }
 
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
   function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      var slots = {};
-      for (var i = 0, l = children.length; i < l; i++) {
-          var child = children[i];
-          var data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              var name = data.slot;
-              var slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (var name$1 in slots) {
-          if (slots[name$1].every(isWhitespace)) {
-              delete slots[name$1];
-          }
-      }
-      return slots;
+    if (!children || !children.length) {
+      return {};
+    }
+    var slots = {};
+    for (var i = 0, l = children.length; i < l; i++) {
+      var child = children[i];
+      var data = child.data;
+      // remove slot attribute if the node is resolved as a Vue slot node
+      if (data && data.attrs && data.attrs.slot) {
+        delete data.attrs.slot;
+      }
+      // named slots should only be respected if the vnode was rendered in the
+      // same context.
+      if (
+        (child.context === context || child.fnContext === context) &&
+        data &&
+        data.slot != null
+      ) {
+        var name = data.slot;
+        var slot = slots[name] || (slots[name] = []);
+        if (child.tag === "template") {
+          slot.push.apply(slot, child.children || []);
+        } else {
+          slot.push(child);
+        }
+      } else {
+        (slots.default || (slots.default = [])).push(child);
+      }
+    }
+    // ignore slots that contains only whitespace
+    for (var name$1 in slots) {
+      if (slots[name$1].every(isWhitespace)) {
+        delete slots[name$1];
+      }
+    }
+    return slots;
   }
   function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+    return (node.isComment && !node.asyncFactory) || node.text === " ";
   }
 
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      var res;
-      var hasNormalSlots = Object.keys(normalSlots).length > 0;
-      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      var key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (var key$1 in slots) {
-              if (slots[key$1] && key$1[0] !== '$') {
-                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (var key$2 in normalSlots) {
-          if (!(key$2 in res)) {
-              res[key$2] = proxyNormalSlot(normalSlots, key$2);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, '$stable', isStable);
-      def(res, '$key', key);
-      def(res, '$hasNormal', hasNormalSlots);
-      return res;
+    var res;
+    var hasNormalSlots = Object.keys(normalSlots).length > 0;
+    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    var key = slots && slots.$key;
+    if (!slots) {
+      res = {};
+    } else if (slots._normalized) {
+      // fast path 1: child component re-render only, parent did not change
+      return slots._normalized;
+    } else if (
+      isStable &&
+      prevSlots &&
+      prevSlots !== emptyObject &&
+      key === prevSlots.$key &&
+      !hasNormalSlots &&
+      !prevSlots.$hasNormal
+    ) {
+      // fast path 2: stable scoped slots w/ no normal slots to proxy,
+      // only need to normalize once
+      return prevSlots;
+    } else {
+      res = {};
+      for (var key$1 in slots) {
+        if (slots[key$1] && key$1[0] !== "$") {
+          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        }
+      }
+    }
+    // expose normal slots on scopedSlots
+    for (var key$2 in normalSlots) {
+      if (!(key$2 in res)) {
+        res[key$2] = proxyNormalSlot(normalSlots, key$2);
+      }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+      slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
   }
   function normalizeScopedSlot(normalSlots, key, fn) {
-      var normalized = function () {
-          var res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === 'object' && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
+    var normalized = function () {
+      var res = arguments.length ? fn.apply(null, arguments) : fn({});
+      res =
+        res && typeof res === "object" && !Array.isArray(res)
+          ? [res] // single vnode
+          : normalizeChildren(res);
+      return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+        ? undefined
+        : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+      Object.defineProperty(normalSlots, key, {
+        get: normalized,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+    return normalized;
   }
   function proxyNormalSlot(slots, key) {
-      return function () { return slots[key]; };
+    return function () {
+      return slots[key];
+    };
   }
 
   /**
    * Runtime helper for rendering v-for lists.
    */
   function renderList(val, render) {
-      var ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              var iterator = val[Symbol.iterator]();
-              var result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
+    var ret = null,
+      i,
+      l,
+      keys,
+      key;
+    if (Array.isArray(val) || typeof val === "string") {
+      ret = new Array(val.length);
+      for (i = 0, l = val.length; i < l; i++) {
+        ret[i] = render(val[i], i);
+      }
+    } else if (typeof val === "number") {
+      ret = new Array(val);
+      for (i = 0; i < val; i++) {
+        ret[i] = render(i + 1, i);
+      }
+    } else if (isObject(val)) {
+      if (hasSymbol && val[Symbol.iterator]) {
+        ret = [];
+        var iterator = val[Symbol.iterator]();
+        var result = iterator.next();
+        while (!result.done) {
+          ret.push(render(result.value, ret.length));
+          result = iterator.next();
+        }
+      } else {
+        keys = Object.keys(val);
+        ret = new Array(keys.length);
+        for (i = 0, l = keys.length; i < l; i++) {
+          key = keys[i];
+          ret[i] = render(val[key], key, i);
+        }
       }
-      ret._isVList = true;
-      return ret;
+    }
+    if (!isDef(ret)) {
+      ret = [];
+    }
+    ret._isVList = true;
+    return ret;
   }
 
   /**
    * Runtime helper for rendering <slot>
    */
   function renderSlot(name, fallback, props, bindObject) {
-      var scopedSlotFn = this.$scopedSlots[name];
-      var nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn('slot v-bind without argument expects an Object', this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes = scopedSlotFn(props) || fallback;
-      }
-      else {
-          nodes = this.$slots[name] || fallback;
-      }
-      var target = props && props.slot;
-      if (target) {
-          return this.$createElement('template', { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
+    var scopedSlotFn = this.$scopedSlots[name];
+    var nodes;
+    if (scopedSlotFn) {
+      // scoped slot
+      props = props || {};
+      if (bindObject) {
+        if (!isObject(bindObject)) {
+          warn("slot v-bind without argument expects an Object", this);
+        }
+        props = extend(extend({}, bindObject), props);
+      }
+      nodes = scopedSlotFn(props) || fallback;
+    } else {
+      nodes = this.$slots[name] || fallback;
+    }
+    var target = props && props.slot;
+    if (target) {
+      return this.$createElement("template", { slot: target }, nodes);
+    } else {
+      return nodes;
+    }
   }
 
   /**
    * Runtime helper for resolving filters
    */
   function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
+    return resolveAsset(this.$options, "filters", id, true) || identity;
   }
 
   function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
+    if (Array.isArray(expect)) {
+      return expect.indexOf(actual) === -1;
+    } else {
+      return expect !== actual;
+    }
   }
   /**
    * Runtime helper for checking keyCodes from config.
    * exposed as Vue.prototype._k
    * passing in eventKeyName as last argument separately for backwards compat
    */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
+  function checkKeyCodes(
+    eventKeyCode,
+    key,
+    builtInKeyCode,
+    eventKeyName,
+    builtInKeyName
+  ) {
+    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+      return isKeyNotMatch(builtInKeyName, eventKeyName);
+    } else if (mappedKeyCode) {
+      return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    } else if (eventKeyName) {
+      return hyphenate(eventKeyName) !== key;
+    }
   }
 
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
   function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              var hash;
-              var loop = function ( key ) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      var type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  var camelizedKey = camelize(key);
-                  var hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          var on = data.on || (data.on = {});
-                          on[("update:" + key)] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
+    if (value) {
+      if (!isObject(value)) {
+        warn("v-bind without argument expects an Object or Array value", this);
+      } else {
+        if (Array.isArray(value)) {
+          value = toObject(value);
+        }
+        var hash;
+        var loop = function (key) {
+          if (key === "class" || key === "style" || isReservedAttribute(key)) {
+            hash = data;
+          } else {
+            var type = data.attrs && data.attrs.type;
+            hash =
+              asProp || config.mustUseProp(tag, type, key)
+                ? data.domProps || (data.domProps = {})
+                : data.attrs || (data.attrs = {});
+          }
+          var camelizedKey = camelize(key);
+          var hyphenatedKey = hyphenate(key);
+          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+            hash[key] = value[key];
+            if (isSync) {
+              var on = data.on || (data.on = {});
+              on["update:" + key] = function ($event) {
+                value[key] = $event;
               };
-
-              for (var key in value) loop( key );
+            }
           }
+        };
+
+        for (var key in value) loop(key);
       }
-      return data;
+    }
+    return data;
   }
 
   /**
    * Runtime helper for rendering static trees.
    */
   function renderStatic(index, isInFor) {
-      var cached = this._staticTrees || (this._staticTrees = []);
-      var tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic(tree, ("__static__" + index), false);
+    var cached = this._staticTrees || (this._staticTrees = []);
+    var tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
       return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(
+      this._renderProxy,
+      null,
+      this // for render fns generated for functional component templates
+    );
+    markStatic(tree, "__static__" + index, false);
+    return tree;
   }
   /**
    * Runtime helper for v-once.
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-      return tree;
+    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
+    return tree;
   }
   function markStatic(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (var i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], (key + "_" + i), isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
+    if (Array.isArray(tree)) {
+      for (var i = 0; i < tree.length; i++) {
+        if (tree[i] && typeof tree[i] !== "string") {
+          markStaticNode(tree[i], key + "_" + i, isOnce);
+        }
       }
+    } else {
+      markStaticNode(tree, key, isOnce);
+    }
   }
   function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
   }
 
   function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn('v-on without argument expects an Object value', this);
-          }
-          else {
-              var on = (data.on = data.on ? extend({}, data.on) : {});
-              for (var key in value) {
-                  var existing = on[key];
-                  var ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
+    if (value) {
+      if (!isPlainObject(value)) {
+        warn("v-on without argument expects an Object value", this);
+      } else {
+        var on = (data.on = data.on ? extend({}, data.on) : {});
+        for (var key in value) {
+          var existing = on[key];
+          var ours = value[key];
+          on[key] = existing ? [].concat(existing, ours) : ours;
+        }
+      }
+    }
+    return data;
   }
 
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (var i = 0; i < fns.length; i++) {
-          var slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
+  function resolveScopedSlots(
+    fns,
+    res,
+    // the following are added in 2.6
+    hasDynamicKeys,
+    contentHashKey
+  ) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (var i = 0; i < fns.length; i++) {
+      var slot = fns[i];
+      if (Array.isArray(slot)) {
+        resolveScopedSlots(slot, res, hasDynamicKeys);
+      } else if (slot) {
+        // marker for reverse proxying v-slot without scope on this.$slots
+        // @ts-expect-error
+        if (slot.proxy) {
+          // @ts-expect-error
+          slot.fn.proxy = true;
+        }
+        res[slot.key] = slot.fn;
       }
-      return res;
+    }
+    if (contentHashKey) {
+      res.$key = contentHashKey;
+    }
+    return res;
   }
 
   // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
-      for (var i = 0; i < values.length; i += 2) {
-          var key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
-          }
-      }
-      return baseObj;
+    for (var i = 0; i < values.length; i += 2) {
+      var key = values[i];
+      if (typeof key === "string" && key) {
+        baseObj[values[i]] = values[i + 1];
+      } else if (key !== "" && key !== null) {
+        // null is a special value for explicitly removing a binding
+        warn(
+          "Invalid value for dynamic directive argument (expected string or null): " +
+            key,
+          this
+        );
+      }
+    }
+    return baseObj;
   }
   // helper to dynamically append modifier runtime markers to event names.
   // ensure only append when value is already string, otherwise it will be cast
   // to string and cause the type check to miss.
   function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
+    return typeof value === "string" ? symbol + value : value;
   }
 
   function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var this$1 = this;
+    var this$1 = this;
 
-      var options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      var contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      var isCompiled = isTrue(options._compiled);
-      var needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = function () {
-          if (!this$1.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
-          }
-          return this$1.$slots;
+    var options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    var contextVm;
+    if (hasOwn(parent, "_uid")) {
+      contextVm = Object.create(parent);
+      // $flow-disable-line
+      contextVm._original = parent;
+    } else {
+      // the context vm passed in is a functional context as well.
+      // in this case we want to make sure we are able to get a hold to the
+      // real context instance.
+      contextVm = parent;
+      // $flow-disable-line
+      parent = parent._original;
+    }
+    var isCompiled = isTrue(options._compiled);
+    var needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = function () {
+      if (!this$1.$slots) {
+        normalizeScopedSlots(
+          data.scopedSlots,
+          (this$1.$slots = resolveSlots(children, parent))
+        );
+      }
+      return this$1.$slots;
+    };
+    Object.defineProperty(this, "scopedSlots", {
+      enumerable: true,
+      get: function get() {
+        return normalizeScopedSlots(data.scopedSlots, this.slots());
+      },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+      // exposing $options for renderStatic()
+      this.$options = options;
+      // pre-resolve slots for renderSlot()
+      this.$slots = this.slots();
+      this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+      this._c = function (a, b, c, d) {
+        var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+        if (vnode && !Array.isArray(vnode)) {
+          vnode.fnScopeId = options._scopeId;
+          vnode.fnContext = parent;
+        }
+        return vnode;
       };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get: function get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = function (a, b, c, d) {
-              var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
-      }
+    } else {
+      this._c = function (a, b, c, d) {
+        return createElement$1(contextVm, a, b, c, d, needNormalization);
+      };
+    }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      var options = Ctor.options;
-      var props = {};
-      var propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (var key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              { mergeProps(props, data.attrs); }
-          if (isDef(data.props))
-              { mergeProps(props, data.props); }
-      }
-      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      var vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          var vnodes = normalizeChildren(vnode) || [];
-          var res = new Array(vnodes.length);
-          for (var i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      var clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
+  function createFunctionalComponent(
+    Ctor,
+    propsData,
+    data,
+    contextVm,
+    children
+  ) {
+    var options = Ctor.options;
+    var props = {};
+    var propOptions = options.props;
+    if (isDef(propOptions)) {
+      for (var key in propOptions) {
+        props[key] = validateProp(key, propOptions, propsData || emptyObject);
+      }
+    } else {
+      if (isDef(data.attrs)) {
+        mergeProps(props, data.attrs);
+      }
+      if (isDef(data.props)) {
+        mergeProps(props, data.props);
+      }
+    }
+    var renderContext = new FunctionalRenderContext(
+      data,
+      props,
+      children,
+      contextVm,
+      Ctor
+    );
+    var vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+      return cloneAndMarkFunctionalResult(
+        vnode,
+        data,
+        renderContext.parent,
+        options,
+        renderContext
+      );
+    } else if (Array.isArray(vnode)) {
+      var vnodes = normalizeChildren(vnode) || [];
+      var res = new Array(vnodes.length);
+      for (var i = 0; i < vnodes.length; i++) {
+        res[i] = cloneAndMarkFunctionalResult(
+          vnodes[i],
+          data,
+          renderContext.parent,
+          options,
+          renderContext
+        );
       }
-      return clone;
+      return res;
+    }
+  }
+  function cloneAndMarkFunctionalResult(
+    vnode,
+    data,
+    contextVm,
+    options,
+    renderContext
+  ) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    var clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+      (clone.devtoolsMeta =
+        clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+      (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
   }
   function mergeProps(to, from) {
-      for (var key in from) {
-          to[camelize(key)] = from[key];
-      }
+    for (var key in from) {
+      to[camelize(key)] = from[key];
+    }
   }
 
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-      init: function init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              var mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch: function prepatch(oldVnode, vnode) {
-          var options = vnode.componentOptions;
-          var child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert: function insert(vnode) {
-          var context = vnode.context;
-          var componentInstance = vnode.componentInstance;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook$1(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy: function destroy(vnode) {
-          var componentInstance = vnode.componentInstance;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
+    init: function init(vnode, hydrating) {
+      if (
+        vnode.componentInstance &&
+        !vnode.componentInstance._isDestroyed &&
+        vnode.data.keepAlive
+      ) {
+        // kept-alive components, treat as a patch
+        var mountedNode = vnode; // work around flow
+        componentVNodeHooks.prepatch(mountedNode, mountedNode);
+      } else {
+        var child = (vnode.componentInstance = createComponentInstanceForVnode(
+          vnode,
+          activeInstance
+        ));
+        child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+      }
+    },
+    prepatch: function prepatch(oldVnode, vnode) {
+      var options = vnode.componentOptions;
+      var child = (vnode.componentInstance = oldVnode.componentInstance);
+      updateChildComponent(
+        child,
+        options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+      );
+    },
+    insert: function insert(vnode) {
+      var context = vnode.context;
+      var componentInstance = vnode.componentInstance;
+      if (!componentInstance._isMounted) {
+        componentInstance._isMounted = true;
+        callHook$1(componentInstance, "mounted");
+      }
+      if (vnode.data.keepAlive) {
+        if (context._isMounted) {
+          // vue-router#1212
+          // During updates, a kept-alive component's child components may
+          // change, so directly walking the tree here may call activated hooks
+          // on incorrect children. Instead we push them into a queue which will
+          // be processed after the whole patch process ended.
+          queueActivatedComponent(componentInstance);
+        } else {
+          activateChildComponent(componentInstance, true /* direct */);
+        }
+      }
+    },
+    destroy: function destroy(vnode) {
+      var componentInstance = vnode.componentInstance;
+      if (!componentInstance._isDestroyed) {
+        if (!vnode.data.keepAlive) {
+          componentInstance.$destroy();
+        } else {
+          deactivateChildComponent(componentInstance, true /* direct */);
+        }
+      }
+    },
   };
   var hooksToMerge = Object.keys(componentVNodeHooks);
   function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      var baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn(("Invalid Component definition: " + (String(Ctor))), context);
-          }
-          return;
-      }
-      // async component
-      var asyncFactory;
+    if (isUndef(Ctor)) {
+      return;
+    }
+    var baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+      Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== "function") {
+      {
+        warn("Invalid Component definition: " + String(Ctor), context);
+      }
+      return;
+    }
+    // async component
+    var asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+      asyncFactory = Ctor;
+      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+      if (Ctor === undefined) {
+        // return a placeholder node for async component, which is rendered
+        // as a comment node but preserves all the raw information for the node.
+        // the information will be used for async server-rendering and hydration.
+        return createAsyncPlaceholder(
+          asyncFactory,
+          data,
+          context,
+          children,
+          tag
+        );
+      }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
       // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
+      transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+      return createFunctionalComponent(
+        Ctor,
+        propsData,
+        data,
+        context,
+        children
+      );
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    var listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+      // abstract components do not keep anything
+      // other than props & listeners & slot
+      // work around flow
+      var slot = data.slot;
+      data = {};
+      if (slot) {
+        data.slot = slot;
+      }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    var name = Ctor.options.name || tag;
+    var vnode = new VNode(
       // @ts-expect-error
-      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
+      "vue-component-" + Ctor.cid + (name ? "-" + name : ""),
+      data,
+      undefined,
+      undefined,
+      undefined,
+      context,
       // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      var listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
+      {
+        Ctor: Ctor,
+        propsData: propsData,
+        listeners: listeners,
+        tag: tag,
+        children: children,
+      },
+      asyncFactory
+    );
+    return vnode;
+  }
+  function createComponentInstanceForVnode(
+    // we know it's MountedComponentVNode but flow doesn't
+    vnode,
+    // activeInstance in lifecycle state
+    parent
+  ) {
+    var options = {
+      _isComponent: true,
+      _parentVnode: vnode,
+      parent: parent,
+    };
+    // check inline-template render functions
+    var inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+      options.render = inlineTemplate.render;
+      options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+    var hooks = data.hook || (data.hook = {});
+    for (var i = 0; i < hooksToMerge.length; i++) {
+      var key = hooksToMerge[i];
+      var existing = hooks[key];
+      var toMerge = componentVNodeHooks[key];
       // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          var slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      var name = Ctor.options.name || tag;
-      var vnode = new VNode(
-      // @ts-expect-error
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      var options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent: parent,
-      };
-      // check inline-template render functions
-      var inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      var hooks = data.hook || (data.hook = {});
-      for (var i = 0; i < hooksToMerge.length; i++) {
-          var key = hooksToMerge[i];
-          var existing = hooks[key];
-          var toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
+      if (existing !== toMerge && !(existing && existing._merged)) {
+        hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
       }
+    }
   }
   function mergeHook(f1, f2) {
-      var merged = function (a, b) {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
+    var merged = function (a, b) {
+      // flow complains about extra args which is why we use any
+      f1(a, b);
+      f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
   }
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
   function transformModel(options, data) {
-      var prop = (options.model && options.model.prop) || 'value';
-      var event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      var on = data.on || (data.on = {});
-      var existing = on[event];
-      var callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
+    var prop = (options.model && options.model.prop) || "value";
+    var event = (options.model && options.model.event) || "input";
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    var on = data.on || (data.on = {});
+    var existing = on[event];
+    var callback = data.model.callback;
+    if (isDef(existing)) {
+      if (
+        Array.isArray(existing)
+          ? existing.indexOf(callback) === -1
+          : existing !== callback
+      ) {
+        on[event] = [callback].concat(existing);
+      }
+    } else {
+      on[event] = callback;
+    }
   }
 
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
+  function createElement$1(
+    context,
+    tag,
+    data,
+    children,
+    normalizationType,
+    alwaysNormalize
+  ) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+      normalizationType = children;
+      children = data;
+      data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+      normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
   }
   function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      var vnode, ns;
-      if (typeof tag === 'string') {
-          var Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if (config.isReservedTag(tag)) {
-              // platform built-in elements
-              if (isDef(data) &&
-                  isDef(data.nativeOn) &&
-                  data.tag !== 'component') {
-                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
-              }
-              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-          }
-          else if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              { applyNS(vnode, ns); }
-          if (isDef(data))
-              { registerDeepBindings(data); }
-          return vnode;
+    if (isDef(data) && isDef(data.__ob__)) {
+      warn(
+        "Avoid using observed data object as vnode data: " +
+          JSON.stringify(data) +
+          "\n" +
+          "Always create fresh vnode data objects in each render!",
+        context
+      );
+      return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+      tag = data.is;
+    }
+    if (!tag) {
+      // in case of component :is set to falsy value
+      return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)) {
+      // @ts-expect-error
+      {
+        warn(
+          "Avoid using non-primitive value as key, " +
+            "use string/number value instead.",
+          context
+        );
+      }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === "function") {
+      data = data || {};
+      data.scopedSlots = { default: children[0] };
+      children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+      children = normalizeChildren(children);
+    } else if (normalizationType === SIMPLE_NORMALIZE) {
+      children = simpleNormalizeChildren(children);
+    }
+    var vnode, ns;
+    if (typeof tag === "string") {
+      var Ctor;
+      ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+      if (config.isReservedTag(tag)) {
+        // platform built-in elements
+        if (isDef(data) && isDef(data.nativeOn) && data.tag !== "component") {
+          warn(
+            "The .native modifier for v-on is only valid on components but it was used on <" +
+              tag +
+              ">.",
+            context
+          );
+        }
+        vnode = new VNode(
+          config.parsePlatformTagName(tag),
+          data,
+          children,
+          undefined,
+          undefined,
+          context
+        );
+      } else if (
+        (!data || !data.pre) &&
+        isDef((Ctor = resolveAsset(context.$options, "components", tag)))
+      ) {
+        // component
+        vnode = createComponent(Ctor, data, context, children, tag);
+      } else {
+        // unknown or unlisted namespaced elements
+        // check at runtime because it may get assigned a namespace when its
+        // parent normalizes children
+        vnode = new VNode(tag, data, children, undefined, undefined, context);
+      }
+    } else {
+      // direct component options / constructor
+      vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+      return vnode;
+    } else if (isDef(vnode)) {
+      if (isDef(ns)) {
+        applyNS(vnode, ns);
       }
-      else {
-          return createEmptyVNode();
+      if (isDef(data)) {
+        registerDeepBindings(data);
       }
+      return vnode;
+    } else {
+      return createEmptyVNode();
+    }
   }
   function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (var i = 0, l = vnode.children.length; i < l; i++) {
-              var child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
+    vnode.ns = ns;
+    if (vnode.tag === "foreignObject") {
+      // use default namespace inside foreignObject
+      ns = undefined;
+      force = true;
+    }
+    if (isDef(vnode.children)) {
+      for (var i = 0, l = vnode.children.length; i < l; i++) {
+        var child = vnode.children[i];
+        if (
+          isDef(child.tag) &&
+          (isUndef(child.ns) || (isTrue(force) && child.tag !== "svg"))
+        ) {
+          applyNS(child, ns, force);
+        }
+      }
+    }
   }
   // ref #5318
   // necessary to ensure parent re-render when deep bindings like :style and
   // :class are used on slot nodes
   function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
+    if (isObject(data.style)) {
+      traverse(data.style);
+    }
+    if (isObject(data.class)) {
+      traverse(data.class);
+    }
   }
 
   function initRender(vm) {
-      vm._vnode = null; // the root of the child tree
-      vm._staticTrees = null; // v-once cached trees
-      var options = vm.$options;
-      var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      var renderContext = parentVnode && parentVnode.context;
-      vm.$slots = resolveSlots(options._renderChildren, renderContext);
-      vm.$scopedSlots = emptyObject;
-      // bind the createElement fn to this instance
-      // so that we get proper render context inside it.
-      // args order: tag, data, children, normalizationType, alwaysNormalize
-      // internal version is used by render functions compiled from templates
-      // @ts-expect-error
-      vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
-      // normalization is always applied for the public version, used in
-      // user-written render functions.
-      // @ts-expect-error
-      vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
-      // $attrs & $listeners are exposed for easier HOC creation.
-      // they need to be reactive so that HOCs using them are always updated
-      var parentData = parentVnode && parentVnode.data;
-      /* istanbul ignore else */
-      {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-              !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-          }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-              !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-          }, true);
-      }
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    var options = vm.$options;
+    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    var renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = function (a, b, c, d) {
+      return createElement$1(vm, a, b, c, d, false);
+    };
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = function (a, b, c, d) {
+      return createElement$1(vm, a, b, c, d, true);
+    };
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    var parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+      defineReactive(
+        vm,
+        "$attrs",
+        (parentData && parentData.attrs) || emptyObject,
+        function () {
+          !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        },
+        true
+      );
+      defineReactive(
+        vm,
+        "$listeners",
+        options._parentListeners || emptyObject,
+        function () {
+          !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        },
+        true
+      );
+    }
   }
   var currentRenderingInstance = null;
   function renderMixin(Vue) {
-      // install runtime convenience helpers
-      installRenderHelpers(Vue.prototype);
-      Vue.prototype.$nextTick = function (fn) {
-          return nextTick(fn, this);
-      };
-      Vue.prototype._render = function () {
-          var vm = this;
-          var ref = vm.$options;
-          var render = ref.render;
-          var _parentVnode = ref._parentVnode;
-          if (_parentVnode) {
-              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-          }
-          // set parent vnode. this allows render functions to have access
-          // to the data on the placeholder node.
-          vm.$vnode = _parentVnode;
-          // render self
-          var vnode;
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+      return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+      var vm = this;
+      var ref = vm.$options;
+      var render = ref.render;
+      var _parentVnode = ref._parentVnode;
+      if (_parentVnode) {
+        vm.$scopedSlots = normalizeScopedSlots(
+          _parentVnode.data.scopedSlots,
+          vm.$slots,
+          vm.$scopedSlots
+        );
+      }
+      // set parent vnode. this allows render functions to have access
+      // to the data on the placeholder node.
+      vm.$vnode = _parentVnode;
+      // render self
+      var vnode;
+      try {
+        // There's no need to maintain a stack because all render fns are called
+        // separately from one another. Nested component's render fns are called
+        // when parent component is patched.
+        currentRenderingInstance = vm;
+        vnode = render.call(vm._renderProxy, vm.$createElement);
+      } catch (e) {
+        handleError(e, vm, "render");
+        // return error render result,
+        // or previous vnode to prevent render error causing blank component
+        /* istanbul ignore else */
+        if (vm.$options.renderError) {
           try {
-              // There's no need to maintain a stack because all render fns are called
-              // separately from one another. Nested component's render fns are called
-              // when parent component is patched.
-              currentRenderingInstance = vm;
-              vnode = render.call(vm._renderProxy, vm.$createElement);
-          }
-          catch (e) {
-              handleError(e, vm, "render");
-              // return error render result,
-              // or previous vnode to prevent render error causing blank component
-              /* istanbul ignore else */
-              if (vm.$options.renderError) {
-                  try {
-                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                  }
-                  catch (e$1) {
-                      handleError(e$1, vm, "renderError");
-                      vnode = vm._vnode;
-                  }
-              }
-              else {
-                  vnode = vm._vnode;
-              }
-          }
-          finally {
-              currentRenderingInstance = null;
-          }
-          // if the returned array contains only a single node, allow it
-          if (Array.isArray(vnode) && vnode.length === 1) {
-              vnode = vnode[0];
-          }
-          // return empty vnode in case the render function errored out
-          if (!(vnode instanceof VNode)) {
-              if (Array.isArray(vnode)) {
-                  warn('Multiple root nodes returned from render function. Render function ' +
-                      'should return a single root node.', vm);
-              }
-              vnode = createEmptyVNode();
-          }
-          // set parent
-          vnode.parent = _parentVnode;
-          return vnode;
-      };
+            vnode = vm.$options.renderError.call(
+              vm._renderProxy,
+              vm.$createElement,
+              e
+            );
+          } catch (e$1) {
+            handleError(e$1, vm, "renderError");
+            vnode = vm._vnode;
+          }
+        } else {
+          vnode = vm._vnode;
+        }
+      } finally {
+        currentRenderingInstance = null;
+      }
+      // if the returned array contains only a single node, allow it
+      if (Array.isArray(vnode) && vnode.length === 1) {
+        vnode = vnode[0];
+      }
+      // return empty vnode in case the render function errored out
+      if (!(vnode instanceof VNode)) {
+        if (Array.isArray(vnode)) {
+          warn(
+            "Multiple root nodes returned from render function. Render function " +
+              "should return a single root node.",
+            vm
+          );
+        }
+        vnode = createEmptyVNode();
+      }
+      // set parent
+      vnode.parent = _parentVnode;
+      return vnode;
+    };
   }
 
   function ensureCtor(comp, base) {
-      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-          comp = comp.default;
-      }
-      return isObject(comp) ? base.extend(comp) : comp;
+    if (
+      comp.__esModule ||
+      (hasSymbol && comp[Symbol.toStringTag] === "Module")
+    ) {
+      comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
   }
   function createAsyncPlaceholder(factory, data, context, children, tag) {
-      var node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-      return node;
+    var node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = {
+      data: data,
+      context: context,
+      children: children,
+      tag: tag,
+    };
+    return node;
   }
   function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      var owner = currentRenderingInstance;
-      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-          // already pending
-          factory.owners.push(owner);
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-      if (owner && !isDef(factory.owners)) {
-          var owners = (factory.owners = [owner]);
-          var sync = true;
-          var timerLoading = null;
-          var timerTimeout = null;
-          owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-          var forceRender = function (renderCompleted) {
-              for (var i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
-              }
-              if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
-                  }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
-                  }
-              }
-          };
-          var resolve = once(function (res) {
-              // cache resolved
-              factory.resolved = ensureCtor(res, baseCtor);
-              // invoke callbacks only if this is not a synchronous resolve
-              // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
-              }
-              else {
-                  owners.length = 0;
-              }
-          });
-          var reject = once(function (reason) {
-              warn("Failed to resolve async component: " + (String(factory)) +
-                      (reason ? ("\nReason: " + reason) : ''));
-              if (isDef(factory.errorComp)) {
-                  factory.error = true;
-                  forceRender(true);
-              }
-          });
-          var res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
-                  // () => Promise
-                  if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
-                  }
-              }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
-                  }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
-                          factory.loading = true;
-                      }
-                      else {
-                          // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(function () {
-                              timerLoading = null;
-                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                  factory.loading = true;
-                                  forceRender(false);
-                              }
-                          }, res.delay || 200);
-                      }
-                  }
-                  if (isDef(res.timeout)) {
-                      // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(function () {
-                          timerTimeout = null;
-                          if (isUndef(factory.resolved)) {
-                              reject(("timeout (" + (res.timeout) + "ms)")
-                                  );
-                          }
-                      }, res.timeout);
-                  }
-              }
-          }
-          sync = false;
-          // return in case resolved synchronously
-          return factory.loading ? factory.loadingComp : factory.resolved;
-      }
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+      return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+      return factory.resolved;
+    }
+    var owner = currentRenderingInstance;
+    if (
+      owner &&
+      isDef(factory.owners) &&
+      factory.owners.indexOf(owner) === -1
+    ) {
+      // already pending
+      factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+      return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+      var owners = (factory.owners = [owner]);
+      var sync = true;
+      var timerLoading = null;
+      var timerTimeout = null;
+      owner.$on("hook:destroyed", function () {
+        return remove$2(owners, owner);
+      });
+      var forceRender = function (renderCompleted) {
+        for (var i = 0, l = owners.length; i < l; i++) {
+          owners[i].$forceUpdate();
+        }
+        if (renderCompleted) {
+          owners.length = 0;
+          if (timerLoading !== null) {
+            clearTimeout(timerLoading);
+            timerLoading = null;
+          }
+          if (timerTimeout !== null) {
+            clearTimeout(timerTimeout);
+            timerTimeout = null;
+          }
+        }
+      };
+      var resolve = once(function (res) {
+        // cache resolved
+        factory.resolved = ensureCtor(res, baseCtor);
+        // invoke callbacks only if this is not a synchronous resolve
+        // (async resolves are shimmed as synchronous during SSR)
+        if (!sync) {
+          forceRender(true);
+        } else {
+          owners.length = 0;
+        }
+      });
+      var reject = once(function (reason) {
+        warn(
+          "Failed to resolve async component: " +
+            String(factory) +
+            (reason ? "\nReason: " + reason : "")
+        );
+        if (isDef(factory.errorComp)) {
+          factory.error = true;
+          forceRender(true);
+        }
+      });
+      var res = factory(resolve, reject);
+      if (isObject(res)) {
+        if (isPromise(res)) {
+          // () => Promise
+          if (isUndef(factory.resolved)) {
+            res.then(resolve, reject);
+          }
+        } else if (isPromise(res.component)) {
+          res.component.then(resolve, reject);
+          if (isDef(res.error)) {
+            factory.errorComp = ensureCtor(res.error, baseCtor);
+          }
+          if (isDef(res.loading)) {
+            factory.loadingComp = ensureCtor(res.loading, baseCtor);
+            if (res.delay === 0) {
+              factory.loading = true;
+            } else {
+              // @ts-expect-error NodeJS timeout type
+              timerLoading = setTimeout(function () {
+                timerLoading = null;
+                if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                  factory.loading = true;
+                  forceRender(false);
+                }
+              }, res.delay || 200);
+            }
+          }
+          if (isDef(res.timeout)) {
+            // @ts-expect-error NodeJS timeout type
+            timerTimeout = setTimeout(function () {
+              timerTimeout = null;
+              if (isUndef(factory.resolved)) {
+                reject("timeout (" + res.timeout + "ms)");
+              }
+            }, res.timeout);
+          }
+        }
+      }
+      sync = false;
+      // return in case resolved synchronously
+      return factory.loading ? factory.loadingComp : factory.resolved;
+    }
   }
 
   function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
   }
 
   function getFirstComponentChild(children) {
-      if (Array.isArray(children)) {
-          for (var i = 0; i < children.length; i++) {
-              var c = children[i];
-              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                  return c;
-              }
-          }
+    if (Array.isArray(children)) {
+      for (var i = 0; i < children.length; i++) {
+        var c = children[i];
+        if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+          return c;
+        }
       }
+    }
   }
 
   function initEvents(vm) {
-      vm._events = Object.create(null);
-      vm._hasHookEvent = false;
-      // init parent attached events
-      var listeners = vm.$options._parentListeners;
-      if (listeners) {
-          updateComponentListeners(vm, listeners);
-      }
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    var listeners = vm.$options._parentListeners;
+    if (listeners) {
+      updateComponentListeners(vm, listeners);
+    }
   }
   var target$1;
   function add$1(event, fn) {
-      target$1.$on(event, fn);
+    target$1.$on(event, fn);
   }
   function remove$1(event, fn) {
-      target$1.$off(event, fn);
+    target$1.$off(event, fn);
   }
   function createOnceHandler$1(event, fn) {
-      var _target = target$1;
-      return function onceHandler() {
-          var res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
+    var _target = target$1;
+    return function onceHandler() {
+      var res = fn.apply(null, arguments);
+      if (res !== null) {
+        _target.$off(event, onceHandler);
+      }
+    };
   }
   function updateComponentListeners(vm, listeners, oldListeners) {
-      target$1 = vm;
-      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-      target$1 = undefined;
+    target$1 = vm;
+    updateListeners(
+      listeners,
+      oldListeners || {},
+      add$1,
+      remove$1,
+      createOnceHandler$1,
+      vm
+    );
+    target$1 = undefined;
   }
   function eventsMixin(Vue) {
-      var hookRE = /^hook:/;
-      Vue.prototype.$on = function (event, fn) {
-          var vm = this;
-          if (Array.isArray(event)) {
-              for (var i = 0, l = event.length; i < l; i++) {
-                  vm.$on(event[i], fn);
-              }
-          }
-          else {
-              (vm._events[event] || (vm._events[event] = [])).push(fn);
-              // optimize hook:event cost by using a boolean flag marked at registration
-              // instead of a hash lookup
-              if (hookRE.test(event)) {
-                  vm._hasHookEvent = true;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$once = function (event, fn) {
-          var vm = this;
-          function on() {
-              vm.$off(event, on);
-              fn.apply(vm, arguments);
-          }
-          on.fn = fn;
-          vm.$on(event, on);
-          return vm;
-      };
-      Vue.prototype.$off = function (event, fn) {
-          var vm = this;
-          // all
-          if (!arguments.length) {
-              vm._events = Object.create(null);
-              return vm;
-          }
-          // array of events
-          if (Array.isArray(event)) {
-              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                  vm.$off(event[i$1], fn);
-              }
-              return vm;
-          }
-          // specific event
-          var cbs = vm._events[event];
-          if (!cbs) {
-              return vm;
-          }
-          if (!fn) {
-              vm._events[event] = null;
-              return vm;
-          }
-          // specific handler
-          var cb;
-          var i = cbs.length;
-          while (i--) {
-              cb = cbs[i];
-              if (cb === fn || cb.fn === fn) {
-                  cbs.splice(i, 1);
-                  break;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$emit = function (event) {
-          var vm = this;
-          {
-              var lowerCaseEvent = event.toLowerCase();
-              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                      "Note that HTML attributes are case-insensitive and you cannot use " +
-                      "v-on to listen to camelCase events when using in-DOM templates. " +
-                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
-              }
-          }
-          var cbs = vm._events[event];
-          if (cbs) {
-              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              var args = toArray(arguments, 1);
-              var info = "event handler for \"" + event + "\"";
-              for (var i = 0, l = cbs.length; i < l; i++) {
-                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-              }
-          }
-          return vm;
-      };
+    var hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+      var vm = this;
+      if (Array.isArray(event)) {
+        for (var i = 0, l = event.length; i < l; i++) {
+          vm.$on(event[i], fn);
+        }
+      } else {
+        (vm._events[event] || (vm._events[event] = [])).push(fn);
+        // optimize hook:event cost by using a boolean flag marked at registration
+        // instead of a hash lookup
+        if (hookRE.test(event)) {
+          vm._hasHookEvent = true;
+        }
+      }
+      return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+      var vm = this;
+      function on() {
+        vm.$off(event, on);
+        fn.apply(vm, arguments);
+      }
+      on.fn = fn;
+      vm.$on(event, on);
+      return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+      var vm = this;
+      // all
+      if (!arguments.length) {
+        vm._events = Object.create(null);
+        return vm;
+      }
+      // array of events
+      if (Array.isArray(event)) {
+        for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+          vm.$off(event[i$1], fn);
+        }
+        return vm;
+      }
+      // specific event
+      var cbs = vm._events[event];
+      if (!cbs) {
+        return vm;
+      }
+      if (!fn) {
+        vm._events[event] = null;
+        return vm;
+      }
+      // specific handler
+      var cb;
+      var i = cbs.length;
+      while (i--) {
+        cb = cbs[i];
+        if (cb === fn || cb.fn === fn) {
+          cbs.splice(i, 1);
+          break;
+        }
+      }
+      return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+      var vm = this;
+      {
+        var lowerCaseEvent = event.toLowerCase();
+        if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+          tip(
+            'Event "' +
+              lowerCaseEvent +
+              '" is emitted in component ' +
+              formatComponentName(vm) +
+              ' but the handler is registered for "' +
+              event +
+              '". ' +
+              "Note that HTML attributes are case-insensitive and you cannot use " +
+              "v-on to listen to camelCase events when using in-DOM templates. " +
+              'You should probably use "' +
+              hyphenate(event) +
+              '" instead of "' +
+              event +
+              '".'
+          );
+        }
+      }
+      var cbs = vm._events[event];
+      if (cbs) {
+        cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+        var args = toArray(arguments, 1);
+        var info = 'event handler for "' + event + '"';
+        for (var i = 0, l = cbs.length; i < l; i++) {
+          invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+        }
+      }
+      return vm;
+    };
   }
 
   var activeInstance = null;
   var isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
-      var prevActiveInstance = activeInstance;
-      activeInstance = vm;
-      return function () {
-          activeInstance = prevActiveInstance;
-      };
+    var prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return function () {
+      activeInstance = prevActiveInstance;
+    };
   }
   function initLifecycle(vm) {
-      var options = vm.$options;
-      // locate first non-abstract parent
-      var parent = options.parent;
-      if (parent && !options.abstract) {
-          while (parent.$options.abstract && parent.$parent) {
-              parent = parent.$parent;
-          }
-          parent.$children.push(vm);
-      }
-      vm.$parent = parent;
-      vm.$root = parent ? parent.$root : vm;
-      vm.$children = [];
-      vm.$refs = {};
-      // @ts-ignore
-      vm._watcher = null;
-      vm._inactive = null;
-      vm._directInactive = false;
-      vm._isMounted = false;
-      vm._isDestroyed = false;
-      vm._isBeingDestroyed = false;
+    var options = vm.$options;
+    // locate first non-abstract parent
+    var parent = options.parent;
+    if (parent && !options.abstract) {
+      while (parent.$options.abstract && parent.$parent) {
+        parent = parent.$parent;
+      }
+      parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    // @ts-ignore
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
   }
   function lifecycleMixin(Vue) {
-      Vue.prototype._update = function (vnode, hydrating) {
-          var vm = this;
-          var prevEl = vm.$el;
-          var prevVnode = vm._vnode;
-          var restoreActiveInstance = setActiveInstance(vm);
-          vm._vnode = vnode;
-          // Vue.prototype.__patch__ is injected in entry points
-          // based on the rendering backend used.
-          if (!prevVnode) {
-              // initial render
-              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-          }
-          else {
-              // updates
-              vm.$el = vm.__patch__(prevVnode, vnode);
-          }
-          restoreActiveInstance();
-          // update __vue__ reference
-          if (prevEl) {
-              prevEl.__vue__ = null;
-          }
-          if (vm.$el) {
-              vm.$el.__vue__ = vm;
-          }
-          // if parent is an HOC, update its $el as well
-          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-              vm.$parent.$el = vm.$el;
-          }
-          // updated hook is called by the scheduler to ensure that children are
-          // updated in a parent's updated hook.
-      };
-      Vue.prototype.$forceUpdate = function () {
-          var vm = this;
-          if (vm._watcher) {
-              vm._watcher.update();
-          }
-      };
-      Vue.prototype.$destroy = function () {
-          var vm = this;
-          if (vm._isBeingDestroyed) {
-              return;
-          }
-          callHook$1(vm, 'beforeDestroy');
-          vm._isBeingDestroyed = true;
-          // remove self from parent
-          var parent = vm.$parent;
-          // @ts-ignore
-          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove$2(parent.$children, vm);
-          }
-          // teardown watchers
-          if (vm._watcher) {
-              vm._watcher.teardown();
-          }
-          var i = vm._watchers.length;
-          while (i--) {
-              vm._watchers[i].teardown();
-          }
-          // remove reference from data ob
-          // frozen object may not have observer.
-          if (vm._data.__ob__) {
-              vm._data.__ob__.vmCount--;
-          }
-          // call the last hook...
-          vm._isDestroyed = true;
-          // invoke destroy hooks on current rendered tree
-          vm.__patch__(vm._vnode, null);
-          // fire destroyed hook
-          callHook$1(vm, 'destroyed');
-          // turn off all instance listeners.
-          vm.$off();
-          // remove __vue__ reference
-          if (vm.$el) {
-              vm.$el.__vue__ = null;
-          }
-          // release circular reference (#6759)
-          if (vm.$vnode) {
-              // @ts-expect-error null is not undefined
-              vm.$vnode.parent = null;
-          }
-      };
-  }
-  function mountComponent(vm, el, hydrating) {
-      vm.$el = el;
-      if (!vm.$options.render) {
-          // @ts-expect-error invalid type
-          vm.$options.render = createEmptyVNode;
-          {
-              /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-                  vm.$options.el ||
-                  el) {
-                  warn('You are using the runtime-only build of Vue where the template ' +
-                      'compiler is not available. Either pre-compile the templates into ' +
-                      'render functions, or use the compiler-included build.', vm);
-              }
-              else {
-                  warn('Failed to mount component: template or render function not defined.', vm);
-              }
-          }
-      }
-      callHook$1(vm, 'beforeMount');
-      var updateComponent;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-          updateComponent = function () {
-              var name = vm._name;
-              var id = vm._uid;
-              var startTag = "vue-perf-start:" + id;
-              var endTag = "vue-perf-end:" + id;
-              mark(startTag);
-              var vnode = vm._render();
-              mark(endTag);
-              measure(("vue " + name + " render"), startTag, endTag);
-              mark(startTag);
-              vm._update(vnode, hydrating);
-              mark(endTag);
-              measure(("vue " + name + " patch"), startTag, endTag);
-          };
-      }
-      else {
-          updateComponent = function () {
-              vm._update(vm._render(), hydrating);
-          };
+    Vue.prototype._update = function (vnode, hydrating) {
+      var vm = this;
+      var prevEl = vm.$el;
+      var prevVnode = vm._vnode;
+      var restoreActiveInstance = setActiveInstance(vm);
+      vm._vnode = vnode;
+      // Vue.prototype.__patch__ is injected in entry points
+      // based on the rendering backend used.
+      if (!prevVnode) {
+        // initial render
+        vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+      } else {
+        // updates
+        vm.$el = vm.__patch__(prevVnode, vnode);
+      }
+      restoreActiveInstance();
+      // update __vue__ reference
+      if (prevEl) {
+        prevEl.__vue__ = null;
+      }
+      if (vm.$el) {
+        vm.$el.__vue__ = vm;
+      }
+      // if parent is an HOC, update its $el as well
+      if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+        vm.$parent.$el = vm.$el;
+      }
+      // updated hook is called by the scheduler to ensure that children are
+      // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+      var vm = this;
+      if (vm._watcher) {
+        vm._watcher.update();
+      }
+    };
+    Vue.prototype.$destroy = function () {
+      var vm = this;
+      if (vm._isBeingDestroyed) {
+        return;
+      }
+      callHook$1(vm, "beforeDestroy");
+      vm._isBeingDestroyed = true;
+      // remove self from parent
+      var parent = vm.$parent;
+      // @ts-ignore
+      if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+        remove$2(parent.$children, vm);
       }
-      // we set this to vm._watcher inside the watcher's constructor
-      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-      // component's mounted hook), which relies on vm._watcher being already defined
-      new Watcher(vm, updateComponent, noop, {
-          before: function before() {
-              if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, 'beforeUpdate');
-              }
-          },
-      }, true /* isRenderWatcher */);
-      hydrating = false;
-      // manually mounted instance, call mounted on self
-      // mounted is called for render-created child components in its inserted hook
-      if (vm.$vnode == null) {
-          vm._isMounted = true;
-          callHook$1(vm, 'mounted');
+      // teardown watchers
+      if (vm._watcher) {
+        vm._watcher.teardown();
       }
-      return vm;
+      var i = vm._watchers.length;
+      while (i--) {
+        vm._watchers[i].teardown();
+      }
+      // remove reference from data ob
+      // frozen object may not have observer.
+      if (vm._data.__ob__) {
+        vm._data.__ob__.vmCount--;
+      }
+      // call the last hook...
+      vm._isDestroyed = true;
+      // invoke destroy hooks on current rendered tree
+      vm.__patch__(vm._vnode, null);
+      // fire destroyed hook
+      callHook$1(vm, "destroyed");
+      // turn off all instance listeners.
+      vm.$off();
+      // remove __vue__ reference
+      if (vm.$el) {
+        vm.$el.__vue__ = null;
+      }
+      // release circular reference (#6759)
+      if (vm.$vnode) {
+        // @ts-expect-error null is not undefined
+        vm.$vnode.parent = null;
+      }
+    };
   }
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+  function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+      // @ts-expect-error invalid type
+      vm.$options.render = createEmptyVNode;
       {
-          isUpdatingChildComponent = true;
-      }
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      var newScopedSlots = parentVnode.data.scopedSlots;
-      var oldScopedSlots = vm.$scopedSlots;
-      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      var needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      // @ts-ignore
-      vm.$options._parentVnode = parentVnode;
-      // @ts-ignore
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          // @ts-ignore
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      // @ts-ignore
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          var props = vm._props;
-          var propKeys = vm.$options._propKeys || [];
-          for (var i = 0; i < propKeys.length; i++) {
-              var key = propKeys[i];
-              var propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      var oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
+        /* istanbul ignore if */
+        if (
+          (vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+          vm.$options.el ||
+          el
+        ) {
+          warn(
+            "You are using the runtime-only build of Vue where the template " +
+              "compiler is not available. Either pre-compile the templates into " +
+              "render functions, or use the compiler-included build.",
+            vm
+          );
+        } else {
+          warn(
+            "Failed to mount component: template or render function not defined.",
+            vm
+          );
+        }
+      }
+    }
+    callHook$1(vm, "beforeMount");
+    var updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+      updateComponent = function () {
+        var name = vm._name;
+        var id = vm._uid;
+        var startTag = "vue-perf-start:" + id;
+        var endTag = "vue-perf-end:" + id;
+        mark(startTag);
+        var vnode = vm._render();
+        mark(endTag);
+        measure("vue " + name + " render", startTag, endTag);
+        mark(startTag);
+        vm._update(vnode, hydrating);
+        mark(endTag);
+        measure("vue " + name + " patch", startTag, endTag);
+      };
+    } else {
+      updateComponent = function () {
+        vm._update(vm._render(), hydrating);
+      };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(
+      vm,
+      updateComponent,
+      noop,
       {
-          isUpdatingChildComponent = false;
+        before: function before() {
+          if (vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, "beforeUpdate");
+          }
+        },
+      },
+      true /* isRenderWatcher */
+    );
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+      vm._isMounted = true;
+      callHook$1(vm, "mounted");
+    }
+    return vm;
+  }
+  function updateChildComponent(
+    vm,
+    propsData,
+    listeners,
+    parentVnode,
+    renderChildren
+  ) {
+    {
+      isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    var newScopedSlots = parentVnode.data.scopedSlots;
+    var oldScopedSlots = vm.$scopedSlots;
+    var hasDynamicScopedSlot = !!(
+      (newScopedSlots && !newScopedSlots.$stable) ||
+      (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+      (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
+    );
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    var needsForceUpdate = !!(
+      renderChildren || // has new static slots
+      vm.$options._renderChildren || // has old static slots
+      hasDynamicScopedSlot
+    );
+    // @ts-ignore
+    vm.$options._parentVnode = parentVnode;
+    // @ts-ignore
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+      // update child tree's parent
+      // @ts-ignore
+      vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    // @ts-ignore
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+      toggleObserving(false);
+      var props = vm._props;
+      var propKeys = vm.$options._propKeys || [];
+      for (var i = 0; i < propKeys.length; i++) {
+        var key = propKeys[i];
+        var propOptions = vm.$options.props; // wtf flow?
+        props[key] = validateProp(key, propOptions, propsData, vm);
       }
+      toggleObserving(true);
+      // keep a copy of raw propsData
+      vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    var oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+      vm.$forceUpdate();
+    }
+    {
+      isUpdatingChildComponent = false;
+    }
   }
   function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              { return true; }
+    while (vm && (vm = vm.$parent)) {
+      if (vm._inactive) {
+        return true;
       }
-      return false;
+    }
+    return false;
   }
   function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
+    if (direct) {
+      vm._directInactive = false;
+      if (isInInactiveTree(vm)) {
+        return;
       }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (var i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, 'activated');
+    } else if (vm._directInactive) {
+      return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+      vm._inactive = false;
+      for (var i = 0; i < vm.$children.length; i++) {
+        activateChildComponent(vm.$children[i]);
       }
+      callHook$1(vm, "activated");
+    }
   }
   function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
+    if (direct) {
+      vm._directInactive = true;
+      if (isInInactiveTree(vm)) {
+        return;
       }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (var i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, 'deactivated');
+    }
+    if (!vm._inactive) {
+      vm._inactive = true;
+      for (var i = 0; i < vm.$children.length; i++) {
+        deactivateChildComponent(vm.$children[i]);
       }
+      callHook$1(vm, "deactivated");
+    }
   }
   function callHook$1(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      var handlers = vm.$options[hook];
-      var info = hook + " hook";
-      if (handlers) {
-          for (var i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit('hook:' + hook);
-      }
-      popTarget();
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    var handlers = vm.$options[hook];
+    var info = hook + " hook";
+    if (handlers) {
+      for (var i = 0, j = handlers.length; i < j; i++) {
+        invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+      }
+    }
+    if (vm._hasHookEvent) {
+      vm.$emit("hook:" + hook);
+    }
+    popTarget();
   }
 
   var MAX_UPDATE_COUNT = 100;
@@ -3677,12 +4036,12 @@
    * Reset the scheduler's state.
    */
   function resetSchedulerState() {
-      index = queue.length = activatedChildren.length = 0;
-      has = {};
-      {
-          circular = {};
-      }
-      waiting = flushing = false;
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+      circular = {};
+    }
+    waiting = flushing = false;
   }
   // Async edge case #6566 requires saving the timestamp when event listeners are
   // attached. However, calling performance.now() has a perf overhead especially
@@ -3699,93 +4058,102 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = function () { return performance.now(); };
-      }
+    var performance = window.performance;
+    if (
+      performance &&
+      typeof performance.now === "function" &&
+      getNow() > document.createEvent("Event").timeStamp
+    ) {
+      // if the event timestamp, although evaluated AFTER the Date.now(), is
+      // smaller than it, it means the event is using a hi-res timestamp,
+      // and we need to use the hi-res version for event listener timestamps as
+      // well.
+      getNow = function () {
+        return performance.now();
+      };
+    }
   }
   /**
    * Flush both queues and run the watchers.
    */
   function flushSchedulerQueue() {
-      currentFlushTimestamp = getNow();
-      flushing = true;
-      var watcher, id;
-      // Sort queue before flush.
-      // This ensures that:
-      // 1. Components are updated from parent to child. (because parent is always
-      //    created before the child)
-      // 2. A component's user watchers are run before its render watcher (because
-      //    user watchers are created before the render watcher)
-      // 3. If a component is destroyed during a parent component's watcher run,
-      //    its watchers can be skipped.
-      queue.sort(function (a, b) { return a.id - b.id; });
-      // do not cache length because more watchers might be pushed
-      // as we run existing watchers
-      for (index = 0; index < queue.length; index++) {
-          watcher = queue[index];
-          if (watcher.before) {
-              watcher.before();
-          }
-          id = watcher.id;
-          has[id] = null;
-          watcher.run();
-          // in dev build, check and stop circular updates.
-          if (has[id] != null) {
-              circular[id] = (circular[id] || 0) + 1;
-              if (circular[id] > MAX_UPDATE_COUNT) {
-                  warn('You may have an infinite update loop ' +
-                      (watcher.user
-                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                          : "in a component render function."), watcher.vm);
-                  break;
-              }
-          }
-      }
-      // keep copies of post queues before resetting state
-      var activatedQueue = activatedChildren.slice();
-      var updatedQueue = queue.slice();
-      resetSchedulerState();
-      // call component updated and activated hooks
-      callActivatedHooks(activatedQueue);
-      callUpdatedHooks(updatedQueue);
-      // devtool hook
-      /* istanbul ignore if */
-      if (devtools && config.devtools) {
-          devtools.emit('flush');
-      }
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    var watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort(function (a, b) {
+      return a.id - b.id;
+    });
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+      watcher = queue[index];
+      if (watcher.before) {
+        watcher.before();
+      }
+      id = watcher.id;
+      has[id] = null;
+      watcher.run();
+      // in dev build, check and stop circular updates.
+      if (has[id] != null) {
+        circular[id] = (circular[id] || 0) + 1;
+        if (circular[id] > MAX_UPDATE_COUNT) {
+          warn(
+            "You may have an infinite update loop " +
+              (watcher.user
+                ? 'in watcher with expression "' + watcher.expression + '"'
+                : "in a component render function."),
+            watcher.vm
+          );
+          break;
+        }
+      }
+    }
+    // keep copies of post queues before resetting state
+    var activatedQueue = activatedChildren.slice();
+    var updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+      devtools.emit("flush");
+    }
   }
   function callUpdatedHooks(queue) {
-      var i = queue.length;
-      while (i--) {
-          var watcher = queue[i];
-          var vm = watcher.vm;
-          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook$1(vm, 'updated');
-          }
+    var i = queue.length;
+    while (i--) {
+      var watcher = queue[i];
+      var vm = watcher.vm;
+      if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+        callHook$1(vm, "updated");
       }
+    }
   }
   /**
    * Queue a kept-alive component that was activated during patch.
    * The queue will be processed after the entire tree has been patched.
    */
   function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-      activatedChildren.push(vm);
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
   }
   function callActivatedHooks(queue) {
-      for (var i = 0; i < queue.length; i++) {
-          queue[i]._inactive = true;
-          activateChildComponent(queue[i], true /* true */);
-      }
+    for (var i = 0; i < queue.length; i++) {
+      queue[i]._inactive = true;
+      activateChildComponent(queue[i], true /* true */);
+    }
   }
   /**
    * Push a watcher into the watcher queue.
@@ -3793,31 +4161,30 @@
    * pushed when the queue is being flushed.
    */
   function queueWatcher(watcher) {
-      var id = watcher.id;
-      if (has[id] == null) {
-          has[id] = true;
-          if (!flushing) {
-              queue.push(watcher);
-          }
-          else {
-              // if already flushing, splice the watcher based on its id
-              // if already past its id, it will be run next immediately.
-              var i = queue.length - 1;
-              while (i > index && queue[i].id > watcher.id) {
-                  i--;
-              }
-              queue.splice(i + 1, 0, watcher);
-          }
-          // queue the flush
-          if (!waiting) {
-              waiting = true;
-              if (!config.async) {
-                  flushSchedulerQueue();
-                  return;
-              }
-              nextTick(flushSchedulerQueue);
-          }
+    var id = watcher.id;
+    if (has[id] == null) {
+      has[id] = true;
+      if (!flushing) {
+        queue.push(watcher);
+      } else {
+        // if already flushing, splice the watcher based on its id
+        // if already past its id, it will be run next immediately.
+        var i = queue.length - 1;
+        while (i > index && queue[i].id > watcher.id) {
+          i--;
+        }
+        queue.splice(i + 1, 0, watcher);
+      }
+      // queue the flush
+      if (!waiting) {
+        waiting = true;
+        if (!config.async) {
+          flushSchedulerQueue();
+          return;
+        }
+        nextTick(flushSchedulerQueue);
       }
+    }
   }
 
   var uid$1 = 0;
@@ -3827,585 +4194,643 @@
    * This is used for both the $watch() api and directives.
    */
   var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-      this.vm = vm;
-      if (isRenderWatcher) {
-          vm._watcher = this;
-      }
-      vm._watchers.push(this);
-      // options
-      if (options) {
-          this.deep = !!options.deep;
-          this.user = !!options.user;
-          this.lazy = !!options.lazy;
-          this.sync = !!options.sync;
-          this.before = options.before;
-      }
-      else {
-          this.deep = this.user = this.lazy = this.sync = false;
-      }
-      this.cb = cb;
-      this.id = ++uid$1; // uid for batching
-      this.active = true;
-      this.dirty = this.lazy; // for lazy watchers
-      this.deps = [];
-      this.newDeps = [];
-      this.depIds = new _Set();
-      this.newDepIds = new _Set();
-      this.expression =
-          expOrFn.toString() ;
-      // parse expression for getter
-      if (typeof expOrFn === 'function') {
-          this.getter = expOrFn;
-      }
-      else {
-          this.getter = parsePath(expOrFn);
-          if (!this.getter) {
-              this.getter = noop;
-              warn("Failed watching path: \"" + expOrFn + "\" " +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
-          }
-      }
-      this.value = this.lazy ? undefined : this.get();
+    this.vm = vm;
+    if (isRenderWatcher) {
+      vm._watcher = this;
+    }
+    vm._watchers.push(this);
+    // options
+    if (options) {
+      this.deep = !!options.deep;
+      this.user = !!options.user;
+      this.lazy = !!options.lazy;
+      this.sync = !!options.sync;
+      this.before = options.before;
+    } else {
+      this.deep = this.user = this.lazy = this.sync = false;
+    }
+    this.cb = cb;
+    this.id = ++uid$1; // uid for batching
+    this.active = true;
+    this.dirty = this.lazy; // for lazy watchers
+    this.deps = [];
+    this.newDeps = [];
+    this.depIds = new _Set();
+    this.newDepIds = new _Set();
+    this.expression = expOrFn.toString();
+    // parse expression for getter
+    if (typeof expOrFn === "function") {
+      this.getter = expOrFn;
+    } else {
+      this.getter = parsePath(expOrFn);
+      if (!this.getter) {
+        this.getter = noop;
+        warn(
+          'Failed watching path: "' +
+            expOrFn +
+            '" ' +
+            "Watcher only accepts simple dot-delimited paths. " +
+            "For full control, use a function instead.",
+          vm
+        );
+      }
+    }
+    this.value = this.lazy ? undefined : this.get();
   };
   /**
    * Evaluate the getter, and re-collect dependencies.
    */
-  Watcher.prototype.get = function get () {
-      pushTarget(this);
-      var value;
-      var vm = this.vm;
-      try {
-          value = this.getter.call(vm, vm);
-      }
-      catch (e) {
-          if (this.user) {
-              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
-          }
-          else {
-              throw e;
-          }
-      }
-      finally {
-          // "touch" every property so they are all tracked as
-          // dependencies for deep watching
-          if (this.deep) {
-              traverse(value);
-          }
-          popTarget();
-          this.cleanupDeps();
+  Watcher.prototype.get = function get() {
+    pushTarget(this);
+    var value;
+    var vm = this.vm;
+    try {
+      value = this.getter.call(vm, vm);
+    } catch (e) {
+      if (this.user) {
+        handleError(e, vm, 'getter for watcher "' + this.expression + '"');
+      } else {
+        throw e;
+      }
+    } finally {
+      // "touch" every property so they are all tracked as
+      // dependencies for deep watching
+      if (this.deep) {
+        traverse(value);
       }
-      return value;
+      popTarget();
+      this.cleanupDeps();
+    }
+    return value;
   };
   /**
    * Add a dependency to this directive.
    */
-  Watcher.prototype.addDep = function addDep (dep) {
-      var id = dep.id;
-      if (!this.newDepIds.has(id)) {
-          this.newDepIds.add(id);
-          this.newDeps.push(dep);
-          if (!this.depIds.has(id)) {
-              dep.addSub(this);
-          }
-      }
+  Watcher.prototype.addDep = function addDep(dep) {
+    var id = dep.id;
+    if (!this.newDepIds.has(id)) {
+      this.newDepIds.add(id);
+      this.newDeps.push(dep);
+      if (!this.depIds.has(id)) {
+        dep.addSub(this);
+      }
+    }
   };
   /**
    * Clean up for dependency collection.
    */
-  Watcher.prototype.cleanupDeps = function cleanupDeps () {
-      var i = this.deps.length;
-      while (i--) {
-          var dep = this.deps[i];
-          if (!this.newDepIds.has(dep.id)) {
-              dep.removeSub(this);
-          }
-      }
-      var tmp = this.depIds;
-      this.depIds = this.newDepIds;
-      this.newDepIds = tmp;
-      this.newDepIds.clear();
-      tmp = this.deps;
-      this.deps = this.newDeps;
-      this.newDeps = tmp;
-      this.newDeps.length = 0;
+  Watcher.prototype.cleanupDeps = function cleanupDeps() {
+    var i = this.deps.length;
+    while (i--) {
+      var dep = this.deps[i];
+      if (!this.newDepIds.has(dep.id)) {
+        dep.removeSub(this);
+      }
+    }
+    var tmp = this.depIds;
+    this.depIds = this.newDepIds;
+    this.newDepIds = tmp;
+    this.newDepIds.clear();
+    tmp = this.deps;
+    this.deps = this.newDeps;
+    this.newDeps = tmp;
+    this.newDeps.length = 0;
   };
   /**
    * Subscriber interface.
    * Will be called when a dependency changes.
    */
-  Watcher.prototype.update = function update () {
-      /* istanbul ignore else */
-      if (this.lazy) {
-          this.dirty = true;
-      }
-      else if (this.sync) {
-          this.run();
-      }
-      else {
-          queueWatcher(this);
-      }
+  Watcher.prototype.update = function update() {
+    /* istanbul ignore else */
+    if (this.lazy) {
+      this.dirty = true;
+    } else if (this.sync) {
+      this.run();
+    } else {
+      queueWatcher(this);
+    }
   };
   /**
    * Scheduler job interface.
    * Will be called by the scheduler.
    */
-  Watcher.prototype.run = function run () {
-      if (this.active) {
-          var value = this.get();
-          if (value !== this.value ||
-              // Deep watchers and watchers on Object/Arrays should fire even
-              // when the value is the same, because the value may
-              // have mutated.
-              isObject(value) ||
-              this.deep) {
-              // set new value
-              var oldValue = this.value;
-              this.value = value;
-              if (this.user) {
-                  try {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-                  catch (e) {
-                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
-                  }
-              }
-              else {
-                  this.cb.call(this.vm, value, oldValue);
-              }
-          }
-      }
+  Watcher.prototype.run = function run() {
+    if (this.active) {
+      var value = this.get();
+      if (
+        value !== this.value ||
+        // Deep watchers and watchers on Object/Arrays should fire even
+        // when the value is the same, because the value may
+        // have mutated.
+        isObject(value) ||
+        this.deep
+      ) {
+        // set new value
+        var oldValue = this.value;
+        this.value = value;
+        if (this.user) {
+          try {
+            this.cb.call(this.vm, value, oldValue);
+          } catch (e) {
+            handleError(
+              e,
+              this.vm,
+              'callback for watcher "' + this.expression + '"'
+            );
+          }
+        } else {
+          this.cb.call(this.vm, value, oldValue);
+        }
+      }
+    }
   };
   /**
    * Evaluate the value of the watcher.
    * This only gets called for lazy watchers.
    */
-  Watcher.prototype.evaluate = function evaluate () {
-      this.value = this.get();
-      this.dirty = false;
+  Watcher.prototype.evaluate = function evaluate() {
+    this.value = this.get();
+    this.dirty = false;
   };
   /**
    * Depend on all deps collected by this watcher.
    */
-  Watcher.prototype.depend = function depend () {
-      var i = this.deps.length;
-      while (i--) {
-          this.deps[i].depend();
-      }
+  Watcher.prototype.depend = function depend() {
+    var i = this.deps.length;
+    while (i--) {
+      this.deps[i].depend();
+    }
   };
   /**
    * Remove self from all dependencies' subscriber list.
    */
-  Watcher.prototype.teardown = function teardown () {
-      if (this.active) {
-          // remove self from vm's watcher list
-          // this is a somewhat expensive operation so we skip it
-          // if the vm is being destroyed.
-          if (!this.vm._isBeingDestroyed) {
-              remove$2(this.vm._watchers, this);
-          }
-          var i = this.deps.length;
-          while (i--) {
-              this.deps[i].removeSub(this);
-          }
-          this.active = false;
+  Watcher.prototype.teardown = function teardown() {
+    if (this.active) {
+      // remove self from vm's watcher list
+      // this is a somewhat expensive operation so we skip it
+      // if the vm is being destroyed.
+      if (!this.vm._isBeingDestroyed) {
+        remove$2(this.vm._watchers, this);
       }
-  };
+      var i = this.deps.length;
+      while (i--) {
+        this.deps[i].removeSub(this);
+      }
+      this.active = false;
+    }
+  };
 
   var sharedPropertyDefinition = {
-      enumerable: true,
-      configurable: true,
-      get: noop,
-      set: noop,
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
   };
   function proxy(target, sourceKey, key) {
-      sharedPropertyDefinition.get = function proxyGetter() {
-          return this[sourceKey][key];
-      };
-      sharedPropertyDefinition.set = function proxySetter(val) {
-          this[sourceKey][key] = val;
-      };
-      Object.defineProperty(target, key, sharedPropertyDefinition);
+    sharedPropertyDefinition.get = function proxyGetter() {
+      return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+      this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
   }
   function initState(vm) {
-      vm._watchers = [];
-      var opts = vm.$options;
-      if (opts.props)
-          { initProps$1(vm, opts.props); }
-      if (opts.methods)
-          { initMethods(vm, opts.methods); }
-      if (opts.data) {
-          initData(vm);
-      }
-      else {
-          observe((vm._data = {}), true /* asRootData */);
-      }
-      if (opts.computed)
-          { initComputed$1(vm, opts.computed); }
-      if (opts.watch && opts.watch !== nativeWatch) {
-          initWatch(vm, opts.watch);
-      }
+    vm._watchers = [];
+    var opts = vm.$options;
+    if (opts.props) {
+      initProps$1(vm, opts.props);
+    }
+    if (opts.methods) {
+      initMethods(vm, opts.methods);
+    }
+    if (opts.data) {
+      initData(vm);
+    } else {
+      observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed) {
+      initComputed$1(vm, opts.computed);
+    }
+    if (opts.watch && opts.watch !== nativeWatch) {
+      initWatch(vm, opts.watch);
+    }
   }
   function initProps$1(vm, propsOptions) {
-      var propsData = vm.$options.propsData || {};
-      var props = (vm._props = {});
-      // cache prop keys so that future props updates can iterate using Array
-      // instead of dynamic object key enumeration.
-      var keys = (vm.$options._propKeys = []);
-      var isRoot = !vm.$parent;
-      // root instance props should be converted
-      if (!isRoot) {
-          toggleObserving(false);
-      }
-      var loop = function ( key ) {
-          keys.push(key);
-          var value = validateProp(key, propsOptions, propsData, vm);
-          /* istanbul ignore else */
-          {
-              var hyphenatedKey = hyphenate(key);
-              if (isReservedAttribute(hyphenatedKey) ||
-                  config.isReservedAttr(hyphenatedKey)) {
-                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
-              }
-              defineReactive(props, key, value, function () {
-                  if (!isRoot && !isUpdatingChildComponent) {
-                      warn("Avoid mutating a prop directly since the value will be " +
-                          "overwritten whenever the parent component re-renders. " +
-                          "Instead, use a data or computed property based on the prop's " +
-                          "value. Prop being mutated: \"" + key + "\"", vm);
-                  }
-              });
-          }
-          // static props are already proxied on the component's prototype
-          // during Vue.extend(). We only need to proxy props defined at
-          // instantiation here.
-          if (!(key in vm)) {
-              proxy(vm, "_props", key);
-          }
-      };
+    var propsData = vm.$options.propsData || {};
+    var props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    var keys = (vm.$options._propKeys = []);
+    var isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+      toggleObserving(false);
+    }
+    var loop = function (key) {
+      keys.push(key);
+      var value = validateProp(key, propsOptions, propsData, vm);
+      /* istanbul ignore else */
+      {
+        var hyphenatedKey = hyphenate(key);
+        if (
+          isReservedAttribute(hyphenatedKey) ||
+          config.isReservedAttr(hyphenatedKey)
+        ) {
+          warn(
+            '"' +
+              hyphenatedKey +
+              '" is a reserved attribute and cannot be used as component prop.',
+            vm
+          );
+        }
+        defineReactive(props, key, value, function () {
+          if (!isRoot && !isUpdatingChildComponent) {
+            warn(
+              "Avoid mutating a prop directly since the value will be " +
+                "overwritten whenever the parent component re-renders. " +
+                "Instead, use a data or computed property based on the prop's " +
+                'value. Prop being mutated: "' +
+                key +
+                '"',
+              vm
+            );
+          }
+        });
+      }
+      // static props are already proxied on the component's prototype
+      // during Vue.extend(). We only need to proxy props defined at
+      // instantiation here.
+      if (!(key in vm)) {
+        proxy(vm, "_props", key);
+      }
+    };
 
-      for (var key in propsOptions) loop( key );
-      toggleObserving(true);
+    for (var key in propsOptions) loop(key);
+    toggleObserving(true);
   }
   function initData(vm) {
-      var data = vm.$options.data;
-      data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
-      if (!isPlainObject(data)) {
-          data = {};
-          warn('data functions should return an object:\n' +
-                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
-      }
-      // proxy data on instance
-      var keys = Object.keys(data);
-      var props = vm.$options.props;
-      var methods = vm.$options.methods;
-      var i = keys.length;
-      while (i--) {
-          var key = keys[i];
-          {
-              if (methods && hasOwn(methods, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
-              }
-          }
-          if (props && hasOwn(props, key)) {
-              warn("The data property \"" + key + "\" is already declared as a prop. " +
-                      "Use prop default value instead.", vm);
-          }
-          else if (!isReserved(key)) {
-              proxy(vm, "_data", key);
-          }
-      }
-      // observe data
-      observe(data, true /* asRootData */);
+    var data = vm.$options.data;
+    data = vm._data =
+      typeof data === "function" ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+      data = {};
+      warn(
+        "data functions should return an object:\n" +
+          "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function",
+        vm
+      );
+    }
+    // proxy data on instance
+    var keys = Object.keys(data);
+    var props = vm.$options.props;
+    var methods = vm.$options.methods;
+    var i = keys.length;
+    while (i--) {
+      var key = keys[i];
+      {
+        if (methods && hasOwn(methods, key)) {
+          warn(
+            'Method "' + key + '" has already been defined as a data property.',
+            vm
+          );
+        }
+      }
+      if (props && hasOwn(props, key)) {
+        warn(
+          'The data property "' +
+            key +
+            '" is already declared as a prop. ' +
+            "Use prop default value instead.",
+          vm
+        );
+      } else if (!isReserved(key)) {
+        proxy(vm, "_data", key);
+      }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
   }
   function getData(data, vm) {
-      // #7573 disable dep collection when invoking data getters
-      pushTarget();
-      try {
-          return data.call(vm, vm);
-      }
-      catch (e) {
-          handleError(e, vm, "data()");
-          return {};
-      }
-      finally {
-          popTarget();
-      }
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+      return data.call(vm, vm);
+    } catch (e) {
+      handleError(e, vm, "data()");
+      return {};
+    } finally {
+      popTarget();
+    }
   }
   var computedWatcherOptions = { lazy: true };
   function initComputed$1(vm, computed) {
-      // $flow-disable-line
-      var watchers = (vm._computedWatchers = Object.create(null));
-      // computed properties are just getters during SSR
-      var isSSR = isServerRendering();
-      for (var key in computed) {
-          var userDef = computed[key];
-          var getter = typeof userDef === 'function' ? userDef : userDef.get;
-          if (getter == null) {
-              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
-          }
-          if (!isSSR) {
-              // create internal watcher for the computed property.
-              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-          }
-          // component-defined computed properties are already defined on the
-          // component prototype. We only need to define computed properties defined
-          // at instantiation here.
-          if (!(key in vm)) {
-              defineComputed(vm, key, userDef);
-          }
-          else {
-              if (key in vm.$data) {
-                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
-              }
-              else if (vm.$options.props && key in vm.$options.props) {
-                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
-              }
-          }
+    // $flow-disable-line
+    var watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    var isSSR = isServerRendering();
+    for (var key in computed) {
+      var userDef = computed[key];
+      var getter = typeof userDef === "function" ? userDef : userDef.get;
+      if (getter == null) {
+        warn('Getter is missing for computed property "' + key + '".', vm);
+      }
+      if (!isSSR) {
+        // create internal watcher for the computed property.
+        watchers[key] = new Watcher(
+          vm,
+          getter || noop,
+          noop,
+          computedWatcherOptions
+        );
+      }
+      // component-defined computed properties are already defined on the
+      // component prototype. We only need to define computed properties defined
+      // at instantiation here.
+      if (!(key in vm)) {
+        defineComputed(vm, key, userDef);
+      } else {
+        if (key in vm.$data) {
+          warn(
+            'The computed property "' + key + '" is already defined in data.',
+            vm
+          );
+        } else if (vm.$options.props && key in vm.$options.props) {
+          warn(
+            'The computed property "' + key + '" is already defined as a prop.',
+            vm
+          );
+        }
       }
+    }
   }
   function defineComputed(target, key, userDef) {
-      var shouldCache = !isServerRendering();
-      if (typeof userDef === 'function') {
-          sharedPropertyDefinition.get = shouldCache
-              ? createComputedGetter(key)
-              : createGetterInvoker(userDef);
-          sharedPropertyDefinition.set = noop;
-      }
-      else {
-          sharedPropertyDefinition.get = userDef.get
-              ? shouldCache && userDef.cache !== false
-                  ? createComputedGetter(key)
-                  : createGetterInvoker(userDef.get)
-              : noop;
-          sharedPropertyDefinition.set = userDef.set || noop;
-      }
-      if (sharedPropertyDefinition.set === noop) {
-          sharedPropertyDefinition.set = function () {
-              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
-          };
-      }
-      Object.defineProperty(target, key, sharedPropertyDefinition);
+    var shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
+      sharedPropertyDefinition.get = shouldCache
+        ? createComputedGetter(key)
+        : createGetterInvoker(userDef);
+      sharedPropertyDefinition.set = noop;
+    } else {
+      sharedPropertyDefinition.get = userDef.get
+        ? shouldCache && userDef.cache !== false
+          ? createComputedGetter(key)
+          : createGetterInvoker(userDef.get)
+        : noop;
+      sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+      sharedPropertyDefinition.set = function () {
+        warn(
+          'Computed property "' +
+            key +
+            '" was assigned to but it has no setter.',
+          this
+        );
+      };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
   }
   function createComputedGetter(key) {
-      return function computedGetter() {
-          var watcher = this._computedWatchers && this._computedWatchers[key];
-          if (watcher) {
-              if (watcher.dirty) {
-                  watcher.evaluate();
-              }
-              if (Dep.target) {
-                  watcher.depend();
-              }
-              return watcher.value;
-          }
-      };
+    return function computedGetter() {
+      var watcher = this._computedWatchers && this._computedWatchers[key];
+      if (watcher) {
+        if (watcher.dirty) {
+          watcher.evaluate();
+        }
+        if (Dep.target) {
+          watcher.depend();
+        }
+        return watcher.value;
+      }
+    };
   }
   function createGetterInvoker(fn) {
-      return function computedGetter() {
-          return fn.call(this, this);
-      };
+    return function computedGetter() {
+      return fn.call(this, this);
+    };
   }
   function initMethods(vm, methods) {
-      var props = vm.$options.props;
-      for (var key in methods) {
-          {
-              if (typeof methods[key] !== 'function') {
-                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                      "Did you reference the function correctly?", vm);
-              }
-              if (props && hasOwn(props, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
-              }
-              if (key in vm && isReserved(key)) {
-                  warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                      "Avoid defining component methods that start with _ or $.");
-              }
-          }
-          vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+    var props = vm.$options.props;
+    for (var key in methods) {
+      {
+        if (typeof methods[key] !== "function") {
+          warn(
+            'Method "' +
+              key +
+              '" has type "' +
+              typeof methods[key] +
+              '" in the component definition. ' +
+              "Did you reference the function correctly?",
+            vm
+          );
+        }
+        if (props && hasOwn(props, key)) {
+          warn('Method "' + key + '" has already been defined as a prop.', vm);
+        }
+        if (key in vm && isReserved(key)) {
+          warn(
+            'Method "' +
+              key +
+              '" conflicts with an existing Vue instance method. ' +
+              "Avoid defining component methods that start with _ or $."
+          );
+        }
       }
+      vm[key] =
+        typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
+    }
   }
   function initWatch(vm, watch) {
-      for (var key in watch) {
-          var handler = watch[key];
-          if (Array.isArray(handler)) {
-              for (var i = 0; i < handler.length; i++) {
-                  createWatcher(vm, key, handler[i]);
-              }
-          }
-          else {
-              createWatcher(vm, key, handler);
-          }
+    for (var key in watch) {
+      var handler = watch[key];
+      if (Array.isArray(handler)) {
+        for (var i = 0; i < handler.length; i++) {
+          createWatcher(vm, key, handler[i]);
+        }
+      } else {
+        createWatcher(vm, key, handler);
       }
+    }
   }
   function createWatcher(vm, expOrFn, handler, options) {
-      if (isPlainObject(handler)) {
-          options = handler;
-          handler = handler.handler;
-      }
-      if (typeof handler === 'string') {
-          handler = vm[handler];
-      }
-      return vm.$watch(expOrFn, handler, options);
+    if (isPlainObject(handler)) {
+      options = handler;
+      handler = handler.handler;
+    }
+    if (typeof handler === "string") {
+      handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
   }
   function stateMixin(Vue) {
-      // flow somehow has problems with directly declared definition object
-      // when using Object.defineProperty, so we have to procedurally build up
-      // the object here.
-      var dataDef = {};
-      dataDef.get = function () {
-          return this._data;
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    var dataDef = {};
+    dataDef.get = function () {
+      return this._data;
+    };
+    var propsDef = {};
+    propsDef.get = function () {
+      return this._props;
+    };
+    {
+      dataDef.set = function () {
+        warn(
+          "Avoid replacing instance root $data. " +
+            "Use nested data properties instead.",
+          this
+        );
       };
-      var propsDef = {};
-      propsDef.get = function () {
-          return this._props;
+      propsDef.set = function () {
+        warn("$props is readonly.", this);
       };
-      {
-          dataDef.set = function () {
-              warn('Avoid replacing instance root $data. ' +
-                  'Use nested data properties instead.', this);
-          };
-          propsDef.set = function () {
-              warn("$props is readonly.", this);
-          };
+    }
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+      var vm = this;
+      if (isPlainObject(cb)) {
+        return createWatcher(vm, expOrFn, cb, options);
+      }
+      options = options || {};
+      options.user = true;
+      var watcher = new Watcher(vm, expOrFn, cb, options);
+      if (options.immediate) {
+        pushTarget();
+        try {
+          cb.call(vm, watcher.value);
+        } catch (error) {
+          handleError(
+            error,
+            vm,
+            'callback for immediate watcher "' + watcher.expression + '"'
+          );
+        }
+        popTarget();
       }
-      Object.defineProperty(Vue.prototype, '$data', dataDef);
-      Object.defineProperty(Vue.prototype, '$props', propsDef);
-      Vue.prototype.$set = set;
-      Vue.prototype.$delete = del;
-      Vue.prototype.$watch = function (expOrFn, cb, options) {
-          var vm = this;
-          if (isPlainObject(cb)) {
-              return createWatcher(vm, expOrFn, cb, options);
-          }
-          options = options || {};
-          options.user = true;
-          var watcher = new Watcher(vm, expOrFn, cb, options);
-          if (options.immediate) {
-              pushTarget();
-              try {
-                  cb.call(vm, watcher.value);
-              }
-              catch (error) {
-                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-              }
-              popTarget();
-          }
-          return function unwatchFn() {
-              watcher.teardown();
-          };
+      return function unwatchFn() {
+        watcher.teardown();
       };
+    };
   }
 
   var uid = 0;
   function initMixin$1(Vue) {
-      Vue.prototype._init = function (options) {
-          var vm = this;
-          // a uid
-          vm._uid = uid++;
-          var startTag, endTag;
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              startTag = "vue-perf-start:" + (vm._uid);
-              endTag = "vue-perf-end:" + (vm._uid);
-              mark(startTag);
-          }
-          // a flag to avoid this being observed
-          vm._isVue = true;
-          // merge options
-          if (options && options._isComponent) {
-              // optimize internal component instantiation
-              // since dynamic options merging is pretty slow, and none of the
-              // internal component options needs special treatment.
-              initInternalComponent(vm, options);
-          }
-          else {
-              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-          }
-          /* istanbul ignore else */
-          {
-              initProxy(vm);
-          }
-          // expose real self
-          vm._self = vm;
-          initLifecycle(vm);
-          initEvents(vm);
-          initRender(vm);
-          callHook$1(vm, 'beforeCreate');
-          initInjections(vm); // resolve injections before data/props
-          initState(vm);
-          initProvide(vm); // resolve provide after data/props
-          callHook$1(vm, 'created');
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              vm._name = formatComponentName(vm, false);
-              mark(endTag);
-              measure(("vue " + (vm._name) + " init"), startTag, endTag);
-          }
-          if (vm.$options.el) {
-              vm.$mount(vm.$options.el);
-          }
-      };
+    Vue.prototype._init = function (options) {
+      var vm = this;
+      // a uid
+      vm._uid = uid++;
+      var startTag, endTag;
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+        startTag = "vue-perf-start:" + vm._uid;
+        endTag = "vue-perf-end:" + vm._uid;
+        mark(startTag);
+      }
+      // a flag to avoid this being observed
+      vm._isVue = true;
+      // merge options
+      if (options && options._isComponent) {
+        // optimize internal component instantiation
+        // since dynamic options merging is pretty slow, and none of the
+        // internal component options needs special treatment.
+        initInternalComponent(vm, options);
+      } else {
+        vm.$options = mergeOptions(
+          resolveConstructorOptions(vm.constructor),
+          options || {},
+          vm
+        );
+      }
+      /* istanbul ignore else */
+      {
+        initProxy(vm);
+      }
+      // expose real self
+      vm._self = vm;
+      initLifecycle(vm);
+      initEvents(vm);
+      initRender(vm);
+      callHook$1(vm, "beforeCreate");
+      initInjections(vm); // resolve injections before data/props
+      initState(vm);
+      initProvide(vm); // resolve provide after data/props
+      callHook$1(vm, "created");
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+        vm._name = formatComponentName(vm, false);
+        mark(endTag);
+        measure("vue " + vm._name + " init", startTag, endTag);
+      }
+      if (vm.$options.el) {
+        vm.$mount(vm.$options.el);
+      }
+    };
   }
   function initInternalComponent(vm, options) {
-      // @ts-ignore
-      var opts = (vm.$options = Object.create(vm.constructor.options));
-      // doing this because it's faster than dynamic enumeration.
-      var parentVnode = options._parentVnode;
-      opts.parent = options.parent;
-      opts._parentVnode = parentVnode;
-      var vnodeComponentOptions = parentVnode.componentOptions;
-      opts.propsData = vnodeComponentOptions.propsData;
-      opts._parentListeners = vnodeComponentOptions.listeners;
-      opts._renderChildren = vnodeComponentOptions.children;
-      opts._componentTag = vnodeComponentOptions.tag;
-      if (options.render) {
-          opts.render = options.render;
-          opts.staticRenderFns = options.staticRenderFns;
-      }
+    // @ts-ignore
+    var opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    var parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    var vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+      opts.render = options.render;
+      opts.staticRenderFns = options.staticRenderFns;
+    }
   }
   function resolveConstructorOptions(Ctor) {
-      var options = Ctor.options;
-      if (Ctor.super) {
-          var superOptions = resolveConstructorOptions(Ctor.super);
-          var cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              var modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
+    var options = Ctor.options;
+    if (Ctor.super) {
+      var superOptions = resolveConstructorOptions(Ctor.super);
+      var cachedSuperOptions = Ctor.superOptions;
+      if (superOptions !== cachedSuperOptions) {
+        // super option changed,
+        // need to resolve new options.
+        Ctor.superOptions = superOptions;
+        // check if there are any late-modified/attached options (#4976)
+        var modifiedOptions = resolveModifiedOptions(Ctor);
+        // update base extend options
+        if (modifiedOptions) {
+          extend(Ctor.extendOptions, modifiedOptions);
+        }
+        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+        if (options.name) {
+          options.components[options.name] = Ctor;
+        }
+      }
+    }
+    return options;
   }
   function resolveModifiedOptions(Ctor) {
-      var modified;
-      var latest = Ctor.options;
-      var sealed = Ctor.sealedOptions;
-      for (var key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  { modified = {}; }
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
+    var modified;
+    var latest = Ctor.options;
+    var sealed = Ctor.sealedOptions;
+    for (var key in latest) {
+      if (latest[key] !== sealed[key]) {
+        if (!modified) {
+          modified = {};
+        }
+        modified[key] = latest[key];
+      }
+    }
+    return modified;
   }
 
   function Vue(options) {
-      if (!(this instanceof Vue)) {
-          warn('Vue is a constructor and should be called with the `new` keyword');
-      }
-      this._init(options);
+    if (!(this instanceof Vue)) {
+      warn("Vue is a constructor and should be called with the `new` keyword");
+    }
+    this._init(options);
   }
   //@ts-ignore
   initMixin$1(Vue);
@@ -4419,547 +4844,571 @@
   renderMixin(Vue);
 
   function initUse(Vue) {
-      Vue.use = function (plugin) {
-          var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-          if (installedPlugins.indexOf(plugin) > -1) {
-              return this;
-          }
-          // additional parameters
-          var args = toArray(arguments, 1);
-          args.unshift(this);
-          if (typeof plugin.install === 'function') {
-              plugin.install.apply(plugin, args);
-          }
-          else if (typeof plugin === 'function') {
-              plugin.apply(null, args);
-          }
-          installedPlugins.push(plugin);
-          return this;
-      };
+    Vue.use = function (plugin) {
+      var installedPlugins =
+        this._installedPlugins || (this._installedPlugins = []);
+      if (installedPlugins.indexOf(plugin) > -1) {
+        return this;
+      }
+      // additional parameters
+      var args = toArray(arguments, 1);
+      args.unshift(this);
+      if (typeof plugin.install === "function") {
+        plugin.install.apply(plugin, args);
+      } else if (typeof plugin === "function") {
+        plugin.apply(null, args);
+      }
+      installedPlugins.push(plugin);
+      return this;
+    };
   }
 
   function initMixin(Vue) {
-      Vue.mixin = function (mixin) {
-          this.options = mergeOptions(this.options, mixin);
-          return this;
-      };
+    Vue.mixin = function (mixin) {
+      this.options = mergeOptions(this.options, mixin);
+      return this;
+    };
   }
 
   function initExtend(Vue) {
-      /**
-       * Each instance constructor, including Vue, has a unique
-       * cid. This enables us to create wrapped "child
-       * constructors" for prototypal inheritance and cache them.
-       */
-      Vue.cid = 0;
-      var cid = 1;
-      /**
-       * Class inheritance
-       */
-      Vue.extend = function (extendOptions) {
-          extendOptions = extendOptions || {};
-          var Super = this;
-          var SuperId = Super.cid;
-          var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-          if (cachedCtors[SuperId]) {
-              return cachedCtors[SuperId];
-          }
-          var name = extendOptions.name || Super.options.name;
-          if (name) {
-              validateComponentName(name);
-          }
-          var Sub = function VueComponent(options) {
-              this._init(options);
-          };
-          Sub.prototype = Object.create(Super.prototype);
-          Sub.prototype.constructor = Sub;
-          Sub.cid = cid++;
-          Sub.options = mergeOptions(Super.options, extendOptions);
-          Sub['super'] = Super;
-          // For props and computed properties, we define the proxy getters on
-          // the Vue instances at extension time, on the extended prototype. This
-          // avoids Object.defineProperty calls for each instance created.
-          if (Sub.options.props) {
-              initProps(Sub);
-          }
-          if (Sub.options.computed) {
-              initComputed(Sub);
-          }
-          // allow further extension/mixin/plugin usage
-          Sub.extend = Super.extend;
-          Sub.mixin = Super.mixin;
-          Sub.use = Super.use;
-          // create asset registers, so extended classes
-          // can have their private assets too.
-          ASSET_TYPES.forEach(function (type) {
-              Sub[type] = Super[type];
-          });
-          // enable recursive self-lookup
-          if (name) {
-              Sub.options.components[name] = Sub;
-          }
-          // keep a reference to the super options at extension time.
-          // later at instantiation we can check if Super's options have
-          // been updated.
-          Sub.superOptions = Super.options;
-          Sub.extendOptions = extendOptions;
-          Sub.sealedOptions = extend({}, Sub.options);
-          // cache constructor
-          cachedCtors[SuperId] = Sub;
-          return Sub;
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    var cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+      extendOptions = extendOptions || {};
+      var Super = this;
+      var SuperId = Super.cid;
+      var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+      if (cachedCtors[SuperId]) {
+        return cachedCtors[SuperId];
+      }
+      var name = extendOptions.name || Super.options.name;
+      if (name) {
+        validateComponentName(name);
+      }
+      var Sub = function VueComponent(options) {
+        this._init(options);
       };
+      Sub.prototype = Object.create(Super.prototype);
+      Sub.prototype.constructor = Sub;
+      Sub.cid = cid++;
+      Sub.options = mergeOptions(Super.options, extendOptions);
+      Sub["super"] = Super;
+      // For props and computed properties, we define the proxy getters on
+      // the Vue instances at extension time, on the extended prototype. This
+      // avoids Object.defineProperty calls for each instance created.
+      if (Sub.options.props) {
+        initProps(Sub);
+      }
+      if (Sub.options.computed) {
+        initComputed(Sub);
+      }
+      // allow further extension/mixin/plugin usage
+      Sub.extend = Super.extend;
+      Sub.mixin = Super.mixin;
+      Sub.use = Super.use;
+      // create asset registers, so extended classes
+      // can have their private assets too.
+      ASSET_TYPES.forEach(function (type) {
+        Sub[type] = Super[type];
+      });
+      // enable recursive self-lookup
+      if (name) {
+        Sub.options.components[name] = Sub;
+      }
+      // keep a reference to the super options at extension time.
+      // later at instantiation we can check if Super's options have
+      // been updated.
+      Sub.superOptions = Super.options;
+      Sub.extendOptions = extendOptions;
+      Sub.sealedOptions = extend({}, Sub.options);
+      // cache constructor
+      cachedCtors[SuperId] = Sub;
+      return Sub;
+    };
   }
   function initProps(Comp) {
-      var props = Comp.options.props;
-      for (var key in props) {
-          proxy(Comp.prototype, "_props", key);
-      }
+    var props = Comp.options.props;
+    for (var key in props) {
+      proxy(Comp.prototype, "_props", key);
+    }
   }
   function initComputed(Comp) {
-      var computed = Comp.options.computed;
-      for (var key in computed) {
-          defineComputed(Comp.prototype, key, computed[key]);
-      }
+    var computed = Comp.options.computed;
+    for (var key in computed) {
+      defineComputed(Comp.prototype, key, computed[key]);
+    }
   }
 
   function initAssetRegisters(Vue) {
-      /**
-       * Create asset registration methods.
-       */
-      ASSET_TYPES.forEach(function (type) {
-          // @ts-expect-error function is not exact same type
-          Vue[type] = function (id, definition) {
-              if (!definition) {
-                  return this.options[type + 's'][id];
-              }
-              else {
-                  /* istanbul ignore if */
-                  if (type === 'component') {
-                      validateComponentName(id);
-                  }
-                  if (type === 'component' && isPlainObject(definition)) {
-                      // @ts-expect-error
-                      definition.name = definition.name || id;
-                      definition = this.options._base.extend(definition);
-                  }
-                  if (type === 'directive' && typeof definition === 'function') {
-                      definition = { bind: definition, update: definition };
-                  }
-                  this.options[type + 's'][id] = definition;
-                  return definition;
-              }
-          };
-      });
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach(function (type) {
+      // @ts-expect-error function is not exact same type
+      Vue[type] = function (id, definition) {
+        if (!definition) {
+          return this.options[type + "s"][id];
+        } else {
+          /* istanbul ignore if */
+          if (type === "component") {
+            validateComponentName(id);
+          }
+          if (type === "component" && isPlainObject(definition)) {
+            // @ts-expect-error
+            definition.name = definition.name || id;
+            definition = this.options._base.extend(definition);
+          }
+          if (type === "directive" && typeof definition === "function") {
+            definition = { bind: definition, update: definition };
+          }
+          this.options[type + "s"][id] = definition;
+          return definition;
+        }
+      };
+    });
   }
 
   function getComponentName(opts) {
-      return opts && (opts.Ctor.options.name || opts.tag);
+    return opts && (opts.Ctor.options.name || opts.tag);
   }
   function matches(pattern, name) {
-      if (Array.isArray(pattern)) {
-          return pattern.indexOf(name) > -1;
-      }
-      else if (typeof pattern === 'string') {
-          return pattern.split(',').indexOf(name) > -1;
-      }
-      else if (isRegExp(pattern)) {
-          return pattern.test(name);
-      }
-      /* istanbul ignore next */
-      return false;
+    if (Array.isArray(pattern)) {
+      return pattern.indexOf(name) > -1;
+    } else if (typeof pattern === "string") {
+      return pattern.split(",").indexOf(name) > -1;
+    } else if (isRegExp(pattern)) {
+      return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache;
-      var keys = keepAliveInstance.keys;
-      var _vnode = keepAliveInstance._vnode;
-      for (var key in cache) {
-          var cachedNode = cache[key];
-          if (cachedNode) {
-              var name = getComponentName(cachedNode.componentOptions);
-              if (name && !filter(name)) {
-                  pruneCacheEntry(cache, key, keys, _vnode);
-              }
-          }
-      }
+    var cache = keepAliveInstance.cache;
+    var keys = keepAliveInstance.keys;
+    var _vnode = keepAliveInstance._vnode;
+    for (var key in cache) {
+      var cachedNode = cache[key];
+      if (cachedNode) {
+        var name = getComponentName(cachedNode.componentOptions);
+        if (name && !filter(name)) {
+          pruneCacheEntry(cache, key, keys, _vnode);
+        }
+      }
+    }
   }
   function pruneCacheEntry(cache, key, keys, current) {
-      var cached = cache[key];
-      if (cached && (!current || cached.tag !== current.tag)) {
-          //@ts-expect-error has void type
-          cached.componentInstance.$destroy();
-      }
-      cache[key] = null;
-      remove$2(keys, key);
+    var cached = cache[key];
+    if (cached && (!current || cached.tag !== current.tag)) {
+      //@ts-expect-error has void type
+      cached.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
   }
   var patternTypes = [String, RegExp, Array];
   // TODO use defineComponent
   var KeepAlive = {
-      name: 'keep-alive',
-      abstract: true,
-      props: {
-          include: patternTypes,
-          exclude: patternTypes,
-          max: [String, Number],
-      },
-      created: function created() {
-          this.cache = Object.create(null);
-          this.keys = [];
-      },
-      destroyed: function destroyed() {
-          for (var key in this.cache) {
-              pruneCacheEntry(this.cache, key, this.keys);
-          }
-      },
-      mounted: function mounted() {
-          var this$1 = this;
+    name: "keep-alive",
+    abstract: true,
+    props: {
+      include: patternTypes,
+      exclude: patternTypes,
+      max: [String, Number],
+    },
+    created: function created() {
+      this.cache = Object.create(null);
+      this.keys = [];
+    },
+    destroyed: function destroyed() {
+      for (var key in this.cache) {
+        pruneCacheEntry(this.cache, key, this.keys);
+      }
+    },
+    mounted: function mounted() {
+      var this$1 = this;
 
-          this.$watch('include', function (val) {
-              pruneCache(this$1, function (name) { return matches(val, name); });
-          });
-          this.$watch('exclude', function (val) {
-              pruneCache(this$1, function (name) { return !matches(val, name); });
-          });
-      },
-      render: function render() {
-          var slot = this.$slots.default;
-          var vnode = getFirstComponentChild(slot);
-          var componentOptions = vnode && vnode.componentOptions;
-          if (componentOptions) {
-              // check pattern
-              var name = getComponentName(componentOptions);
-              var ref = this;
-              var include = ref.include;
-              var exclude = ref.exclude;
-              if (
-              // not included
-              (include && (!name || !matches(include, name))) ||
-                  // excluded
-                  (exclude && name && matches(exclude, name))) {
-                  return vnode;
-              }
-              var ref$1 = this;
-              var cache = ref$1.cache;
-              var keys = ref$1.keys;
-              var key = vnode.key == null
-                  ? // same constructor may get registered as different local components
-                      // so cid alone is not enough (#3269)
-                      componentOptions.Ctor.cid +
-                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
-                  : vnode.key;
-              if (cache[key]) {
-                  vnode.componentInstance = cache[key].componentInstance;
-                  // make current key freshest
-                  remove$2(keys, key);
-                  keys.push(key);
-              }
-              else {
-                  cache[key] = vnode;
-                  keys.push(key);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
-              }
-              vnode.data.keepAlive = true;
+      this.$watch("include", function (val) {
+        pruneCache(this$1, function (name) {
+          return matches(val, name);
+        });
+      });
+      this.$watch("exclude", function (val) {
+        pruneCache(this$1, function (name) {
+          return !matches(val, name);
+        });
+      });
+    },
+    render: function render() {
+      var slot = this.$slots.default;
+      var vnode = getFirstComponentChild(slot);
+      var componentOptions = vnode && vnode.componentOptions;
+      if (componentOptions) {
+        // check pattern
+        var name = getComponentName(componentOptions);
+        var ref = this;
+        var include = ref.include;
+        var exclude = ref.exclude;
+        if (
+          // not included
+          (include && (!name || !matches(include, name))) ||
+          // excluded
+          (exclude && name && matches(exclude, name))
+        ) {
+          return vnode;
+        }
+        var ref$1 = this;
+        var cache = ref$1.cache;
+        var keys = ref$1.keys;
+        var key =
+          vnode.key == null
+            ? // same constructor may get registered as different local components
+              // so cid alone is not enough (#3269)
+              componentOptions.Ctor.cid +
+              (componentOptions.tag ? "::" + componentOptions.tag : "")
+            : vnode.key;
+        if (cache[key]) {
+          vnode.componentInstance = cache[key].componentInstance;
+          // make current key freshest
+          remove$2(keys, key);
+          keys.push(key);
+        } else {
+          cache[key] = vnode;
+          keys.push(key);
+          // prune oldest entry
+          if (this.max && keys.length > parseInt(this.max)) {
+            pruneCacheEntry(cache, keys[0], keys, this._vnode);
           }
-          return vnode || (slot && slot[0]);
-      },
+        }
+        vnode.data.keepAlive = true;
+      }
+      return vnode || (slot && slot[0]);
+    },
   };
 
   var builtInComponents = {
-      KeepAlive: KeepAlive,
+    KeepAlive: KeepAlive,
   };
 
   function initGlobalAPI(Vue) {
-      // config
-      var configDef = {};
-      configDef.get = function () { return config; };
-      {
-          configDef.set = function () {
-              warn('Do not replace the Vue.config object, set individual fields instead.');
-          };
-      }
-      Object.defineProperty(Vue, 'config', configDef);
-      // exposed util methods.
-      // NOTE: these are not considered part of the public API - avoid relying on
-      // them unless you are aware of the risk.
-      Vue.util = {
-          warn: warn,
-          extend: extend,
-          mergeOptions: mergeOptions,
-          defineReactive: defineReactive,
+    // config
+    var configDef = {};
+    configDef.get = function () {
+      return config;
+    };
+    {
+      configDef.set = function () {
+        warn(
+          "Do not replace the Vue.config object, set individual fields instead."
+        );
       };
-      Vue.set = set;
-      Vue.delete = del;
-      Vue.nextTick = nextTick;
-      // 2.6 explicit observable API
-      Vue.observable = function (obj) {
-          observe(obj);
-          return obj;
-      };
-      Vue.options = Object.create(null);
-      ASSET_TYPES.forEach(function (type) {
-          Vue.options[type + 's'] = Object.create(null);
-      });
-      // this is used to identify the "base" constructor to extend all plain-object
-      // components with in Weex's multi-instance scenarios.
-      Vue.options._base = Vue;
-      extend(Vue.options.components, builtInComponents);
-      initUse(Vue);
-      initMixin(Vue);
-      initExtend(Vue);
-      initAssetRegisters(Vue);
+    }
+    Object.defineProperty(Vue, "config", configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+      warn: warn,
+      extend: extend,
+      mergeOptions: mergeOptions,
+      defineReactive: defineReactive,
+    };
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = function (obj) {
+      observe(obj);
+      return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach(function (type) {
+      Vue.options[type + "s"] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
   }
 
   initGlobalAPI(Vue);
-  Object.defineProperty(Vue.prototype, '$isServer', {
-      get: isServerRendering,
+  Object.defineProperty(Vue.prototype, "$isServer", {
+    get: isServerRendering,
   });
-  Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function get() {
-          /* istanbul ignore next */
-          return this.$vnode && this.$vnode.ssrContext;
-      },
+  Object.defineProperty(Vue.prototype, "$ssrContext", {
+    get: function get() {
+      /* istanbul ignore next */
+      return this.$vnode && this.$vnode.ssrContext;
+    },
   });
   // expose FunctionalRenderContext for ssr runtime helper installation
-  Object.defineProperty(Vue, 'FunctionalRenderContext', {
-      value: FunctionalRenderContext,
+  Object.defineProperty(Vue, "FunctionalRenderContext", {
+    value: FunctionalRenderContext,
   });
-  Vue.version = '2.6.12';
+  Vue.version = "2.6.12";
 
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap('style,class');
+  var isReservedAttr = makeMap("style,class");
   // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress');
+  var acceptValue = makeMap("input,textarea,option,select,progress");
   var mustUseProp = function (tag, type, attr) {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
+    return (
+      (attr === "value" && acceptValue(tag) && type !== "button") ||
+      (attr === "selected" && tag === "option") ||
+      (attr === "checked" && tag === "input") ||
+      (attr === "muted" && tag === "video")
+    );
   };
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  var isEnumeratedAttr = makeMap("contenteditable,draggable,spellcheck");
+  var isValidContentEditableValue = makeMap(
+    "events,caret,typing,plaintext-only"
+  );
   var convertEnumeratedValue = function (key, value) {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
+    return isFalsyAttrValue(value) || value === "false"
+      ? "false"
+      : // allow arbitrary string value for contenteditable
+      key === "contenteditable" && isValidContentEditableValue(value)
+      ? value
+      : "true";
   };
-  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  var xlinkNS = 'http://www.w3.org/1999/xlink';
+  var isBooleanAttr = makeMap(
+    "allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare," +
+      "default,defaultchecked,defaultmuted,defaultselected,defer,disabled," +
+      "enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple," +
+      "muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly," +
+      "required,reversed,scoped,seamless,selected,sortable," +
+      "truespeed,typemustmatch,visible"
+  );
+  var xlinkNS = "http://www.w3.org/1999/xlink";
   var isXlink = function (name) {
-      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+    return name.charAt(5) === ":" && name.slice(0, 5) === "xlink";
   };
   var getXlinkProp = function (name) {
-      return isXlink(name) ? name.slice(6, name.length) : '';
+    return isXlink(name) ? name.slice(6, name.length) : "";
   };
   var isFalsyAttrValue = function (val) {
-      return val == null || val === false;
+    return val == null || val === false;
   };
 
   function genClassForVnode(vnode) {
-      var data = vnode.data;
-      var parentNode = vnode;
-      var childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass(data.staticClass, data.class);
+    var data = vnode.data;
+    var parentNode = vnode;
+    var childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+      childNode = childNode.componentInstance._vnode;
+      if (childNode && childNode.data) {
+        data = mergeClassData(childNode.data, data);
+      }
+    }
+    while (isDef((parentNode = parentNode.parent))) {
+      if (parentNode && parentNode.data) {
+        data = mergeClassData(data, parentNode.data);
+      }
+    }
+    return renderClass(data.staticClass, data.class);
   }
   function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
+    return {
+      staticClass: concat(child.staticClass, parent.staticClass),
+      class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
   }
   function renderClass(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+      return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return "";
   }
   function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
+    return a ? (b ? a + " " + b : a) : b || "";
   }
   function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
+    if (Array.isArray(value)) {
+      return stringifyArray(value);
+    }
+    if (isObject(value)) {
+      return stringifyObject(value);
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    /* istanbul ignore next */
+    return "";
   }
   function stringifyArray(value) {
-      var res = '';
-      var stringified;
-      for (var i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  { res += ' '; }
-              res += stringified;
-          }
-      }
-      return res;
+    var res = "";
+    var stringified;
+    for (var i = 0, l = value.length; i < l; i++) {
+      if (
+        isDef((stringified = stringifyClass(value[i]))) &&
+        stringified !== ""
+      ) {
+        if (res) {
+          res += " ";
+        }
+        res += stringified;
+      }
+    }
+    return res;
   }
   function stringifyObject(value) {
-      var res = '';
-      for (var key in value) {
-          if (value[key]) {
-              if (res)
-                  { res += ' '; }
-              res += key;
-          }
+    var res = "";
+    for (var key in value) {
+      if (value[key]) {
+        if (res) {
+          res += " ";
+        }
+        res += key;
       }
-      return res;
+    }
+    return res;
   }
 
   var namespaceMap = {
-      svg: 'http://www.w3.org/2000/svg',
-      math: 'http://www.w3.org/1998/Math/MathML',
+    svg: "http://www.w3.org/2000/svg",
+    math: "http://www.w3.org/1998/Math/MathML",
   };
-  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
+  var isHTMLTag = makeMap(
+    "html,body,base,head,link,meta,style,title," +
+      "address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section," +
+      "div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul," +
+      "a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby," +
+      "s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video," +
+      "embed,object,param,source,canvas,script,noscript,del,ins," +
+      "caption,col,colgroup,table,thead,tbody,td,th,tr," +
+      "button,datalist,fieldset,form,input,label,legend,meter,optgroup,option," +
+      "output,progress,select,textarea," +
+      "details,dialog,menu,menuitem,summary," +
+      "content,element,shadow,template,blockquote,iframe,tfoot"
+  );
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  var isSVG = makeMap(
+    "svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face," +
+      "foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern," +
+      "polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",
+    true
+  );
   var isReservedTag = function (tag) {
-      return isHTMLTag(tag) || isSVG(tag);
+    return isHTMLTag(tag) || isSVG(tag);
   };
   function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
+    if (isSVG(tag)) {
+      return "svg";
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === "math") {
+      return "math";
+    }
   }
   var unknownElementCache = Object.create(null);
   function isUnknownElement(tag) {
-      /* istanbul ignore if */
-      if (!inBrowser) {
-          return true;
-      }
-      if (isReservedTag(tag)) {
-          return false;
-      }
-      tag = tag.toLowerCase();
-      /* istanbul ignore if */
-      if (unknownElementCache[tag] != null) {
-          return unknownElementCache[tag];
-      }
-      var el = document.createElement(tag);
-      if (tag.indexOf('-') > -1) {
-          // http://stackoverflow.com/a/28210364/1070244
-          return (unknownElementCache[tag] =
-              el.constructor === window.HTMLUnknownElement ||
-                  el.constructor === window.HTMLElement);
-      }
-      else {
-          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-      }
-  }
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+    /* istanbul ignore if */
+    if (!inBrowser) {
+      return true;
+    }
+    if (isReservedTag(tag)) {
+      return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+      return unknownElementCache[tag];
+    }
+    var el = document.createElement(tag);
+    if (tag.indexOf("-") > -1) {
+      // http://stackoverflow.com/a/28210364/1070244
+      return (unknownElementCache[tag] =
+        el.constructor === window.HTMLUnknownElement ||
+        el.constructor === window.HTMLElement);
+    } else {
+      return (unknownElementCache[tag] = /HTMLUnknownElement/.test(
+        el.toString()
+      ));
+    }
+  }
+  var isTextInputType = makeMap("text,number,password,search,email,tel,url");
 
   /**
    * Query an element selector if it's not an element already.
    */
   function query(el) {
-      if (typeof el === 'string') {
-          var selected = document.querySelector(el);
-          if (!selected) {
-              warn('Cannot find element: ' + el);
-              return document.createElement('div');
-          }
-          return selected;
-      }
-      else {
-          return el;
+    if (typeof el === "string") {
+      var selected = document.querySelector(el);
+      if (!selected) {
+        warn("Cannot find element: " + el);
+        return document.createElement("div");
       }
+      return selected;
+    } else {
+      return el;
+    }
   }
 
   function createElement(tagName, vnode) {
-      var elm = document.createElement(tagName);
-      if (tagName !== 'select') {
-          return elm;
-      }
-      // false or null will remove the attribute but undefined will not
-      if (vnode.data &&
-          vnode.data.attrs &&
-          vnode.data.attrs.multiple !== undefined) {
-          elm.setAttribute('multiple', 'multiple');
-      }
+    var elm = document.createElement(tagName);
+    if (tagName !== "select") {
       return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (
+      vnode.data &&
+      vnode.data.attrs &&
+      vnode.data.attrs.multiple !== undefined
+    ) {
+      elm.setAttribute("multiple", "multiple");
+    }
+    return elm;
   }
   function createElementNS(namespace, tagName) {
-      return document.createElementNS(namespaceMap[namespace], tagName);
+    return document.createElementNS(namespaceMap[namespace], tagName);
   }
   function createTextNode(text) {
-      return document.createTextNode(text);
+    return document.createTextNode(text);
   }
   function createComment(text) {
-      return document.createComment(text);
+    return document.createComment(text);
   }
   function insertBefore(parentNode, newNode, referenceNode) {
-      parentNode.insertBefore(newNode, referenceNode);
+    parentNode.insertBefore(newNode, referenceNode);
   }
   function removeChild(node, child) {
-      node.removeChild(child);
+    node.removeChild(child);
   }
   function appendChild(node, child) {
-      node.appendChild(child);
+    node.appendChild(child);
   }
   function parentNode(node) {
-      return node.parentNode;
+    return node.parentNode;
   }
   function nextSibling(node) {
-      return node.nextSibling;
+    return node.nextSibling;
   }
   function tagName(node) {
-      return node.tagName;
+    return node.tagName;
   }
   function setTextContent(node, text) {
-      node.textContent = text;
+    node.textContent = text;
   }
   function setStyleScope(node, scopeId) {
-      node.setAttribute(scopeId, '');
+    node.setAttribute(scopeId, "");
   }
 
-  var nodeOps = /*#__PURE__*/Object.freeze({
+  var nodeOps = /*#__PURE__*/ Object.freeze({
     __proto__: null,
     createElement: createElement,
     createElementNS: createElementNS,
@@ -4972,55 +5421,52 @@
     nextSibling: nextSibling,
     tagName: tagName,
     setTextContent: setTextContent,
-    setStyleScope: setStyleScope
+    setStyleScope: setStyleScope,
   });
 
   var ref = {
-      create: function create(_, vnode) {
-          registerRef(vnode);
-      },
-      update: function update(oldVnode, vnode) {
-          if (oldVnode.data.ref !== vnode.data.ref) {
-              registerRef(oldVnode, true);
-              registerRef(vnode);
-          }
-      },
-      destroy: function destroy(vnode) {
-          registerRef(vnode, true);
-      },
+    create: function create(_, vnode) {
+      registerRef(vnode);
+    },
+    update: function update(oldVnode, vnode) {
+      if (oldVnode.data.ref !== vnode.data.ref) {
+        registerRef(oldVnode, true);
+        registerRef(vnode);
+      }
+    },
+    destroy: function destroy(vnode) {
+      registerRef(vnode, true);
+    },
   };
   function registerRef(vnode, isRemoval) {
-      var key = vnode.data.ref;
-      if (!isDef(key))
-          { return; }
-      var vm = vnode.context;
-      var ref = vnode.componentInstance || vnode.elm;
-      var refs = vm.$refs;
-      if (isRemoval) {
-          if (Array.isArray(refs[key])) {
-              // @ts-expect-error invalid typings
-              remove$2(refs[key], ref);
-          }
-          else if (refs[key] === ref) {
-              refs[key] = undefined;
-          }
-      }
-      else {
+    var key = vnode.data.ref;
+    if (!isDef(key)) {
+      return;
+    }
+    var vm = vnode.context;
+    var ref = vnode.componentInstance || vnode.elm;
+    var refs = vm.$refs;
+    if (isRemoval) {
+      if (Array.isArray(refs[key])) {
+        // @ts-expect-error invalid typings
+        remove$2(refs[key], ref);
+      } else if (refs[key] === ref) {
+        refs[key] = undefined;
+      }
+    } else {
+      // @ts-expect-error invalid typings
+      if (vnode.data.refInFor) {
+        if (!Array.isArray(refs[key])) {
+          refs[key] = [ref];
           // @ts-expect-error invalid typings
-          if (vnode.data.refInFor) {
-              if (!Array.isArray(refs[key])) {
-                  refs[key] = [ref];
-                  // @ts-expect-error invalid typings
-              }
-              else if (refs[key].indexOf(ref) < 0) {
-                  // @ts-expect-error invalid typings
-                  refs[key].push(ref);
-              }
-          }
-          else {
-              refs[key] = ref;
-          }
+        } else if (refs[key].indexOf(ref) < 0) {
+          // @ts-expect-error invalid typings
+          refs[key].push(ref);
+        }
+      } else {
+        refs[key] = ref;
       }
+    }
   }
 
   /**
@@ -5034,1956 +5480,1477 @@
    * Not type-checking this because this file is perf-critical and the cost
    * of making flow understand it is not worth it.
    */
-  var emptyNode = new VNode('', {}, []);
-  var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+  var emptyNode = new VNode("", {}, []);
+  var hooks = ["create", "activate", "update", "remove", "destroy"];
   function sameVnode(a, b) {
-      return (a.key === b.key &&
-          ((a.tag === b.tag &&
-              a.isComment === b.isComment &&
-              isDef(a.data) === isDef(b.data) &&
-              sameInputType(a, b)) ||
-              (isTrue(a.isAsyncPlaceholder) &&
-                  a.asyncFactory === b.asyncFactory &&
-                  isUndef(b.asyncFactory.error))));
+    return (
+      a.key === b.key &&
+      ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) ||
+        (isTrue(a.isAsyncPlaceholder) &&
+          a.asyncFactory === b.asyncFactory &&
+          isUndef(b.asyncFactory.error)))
+    );
   }
   function sameInputType(a, b) {
-      if (a.tag !== 'input')
-          { return true; }
-      var i;
-      var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+    if (a.tag !== "input") {
+      return true;
+    }
+    var i;
+    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return (
+      typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB))
+    );
   }
   function createKeyToOldIdx(children, beginIdx, endIdx) {
-      var i, key;
-      var map = {};
-      for (i = beginIdx; i <= endIdx; ++i) {
-          key = children[i].key;
-          if (isDef(key))
-              { map[key] = i; }
+    var i, key;
+    var map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+      key = children[i].key;
+      if (isDef(key)) {
+        map[key] = i;
       }
-      return map;
+    }
+    return map;
   }
   function createPatchFunction(backend) {
-      var i, j;
-      var cbs = {};
-      var modules = backend.modules;
-      var nodeOps = backend.nodeOps;
-      for (i = 0; i < hooks.length; ++i) {
-          cbs[hooks[i]] = [];
-          for (j = 0; j < modules.length; ++j) {
-              if (isDef(modules[j][hooks[i]])) {
-                  cbs[hooks[i]].push(modules[j][hooks[i]]);
-              }
-          }
-      }
-      function emptyNodeAt(elm) {
-          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    var i, j;
+    var cbs = {};
+    var modules = backend.modules;
+    var nodeOps = backend.nodeOps;
+    for (i = 0; i < hooks.length; ++i) {
+      cbs[hooks[i]] = [];
+      for (j = 0; j < modules.length; ++j) {
+        if (isDef(modules[j][hooks[i]])) {
+          cbs[hooks[i]].push(modules[j][hooks[i]]);
+        }
+      }
+    }
+    function emptyNodeAt(elm) {
+      return new VNode(
+        nodeOps.tagName(elm).toLowerCase(),
+        {},
+        [],
+        undefined,
+        elm
+      );
+    }
+    function createRmCb(childElm, listeners) {
+      function remove() {
+        if (--remove.listeners === 0) {
+          removeNode(childElm);
+        }
+      }
+      remove.listeners = listeners;
+      return remove;
+    }
+    function removeNode(el) {
+      var parent = nodeOps.parentNode(el);
+      // element may have already been removed due to v-html / v-text
+      if (isDef(parent)) {
+        nodeOps.removeChild(parent, el);
+      }
+    }
+    function isUnknownElement(vnode, inVPre) {
+      return (
+        !inVPre &&
+        !vnode.ns &&
+        !(
+          config.ignoredElements.length &&
+          config.ignoredElements.some(function (ignore) {
+            return isRegExp(ignore)
+              ? ignore.test(vnode.tag)
+              : ignore === vnode.tag;
+          })
+        ) &&
+        config.isUnknownElement(vnode.tag)
+      );
+    }
+    var creatingElmInVPre = 0;
+    function createElm(
+      vnode,
+      insertedVnodeQueue,
+      parentElm,
+      refElm,
+      nested,
+      ownerArray,
+      index
+    ) {
+      if (isDef(vnode.elm) && isDef(ownerArray)) {
+        // This vnode was used in a previous render!
+        // now it's used as a new node, overwriting its elm would cause
+        // potential patch errors down the road when it's used as an insertion
+        // reference node. Instead, we clone the node on-demand before creating
+        // associated DOM element for it.
+        vnode = ownerArray[index] = cloneVNode(vnode);
+      }
+      vnode.isRootInsert = !nested; // for transition enter check
+      if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+        return;
       }
-      function createRmCb(childElm, listeners) {
-          function remove() {
-              if (--remove.listeners === 0) {
-                  removeNode(childElm);
-              }
+      var data = vnode.data;
+      var children = vnode.children;
+      var tag = vnode.tag;
+      if (isDef(tag)) {
+        {
+          if (data && data.pre) {
+            creatingElmInVPre++;
+          }
+          if (isUnknownElement(vnode, creatingElmInVPre)) {
+            warn(
+              "Unknown custom element: <" +
+                tag +
+                "> - did you " +
+                "register the component correctly? For recursive components, " +
+                'make sure to provide the "name" option.',
+              vnode.context
+            );
+          }
+        }
+        vnode.elm = vnode.ns
+          ? nodeOps.createElementNS(vnode.ns, tag)
+          : nodeOps.createElement(tag, vnode);
+        setScope(vnode);
+        /* istanbul ignore if */
+        {
+          createChildren(vnode, children, insertedVnodeQueue);
+          if (isDef(data)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
           }
-          remove.listeners = listeners;
-          return remove;
-      }
-      function removeNode(el) {
-          var parent = nodeOps.parentNode(el);
-          // element may have already been removed due to v-html / v-text
-          if (isDef(parent)) {
-              nodeOps.removeChild(parent, el);
+          insert(parentElm, vnode.elm, refElm);
+        }
+        if (data && data.pre) {
+          creatingElmInVPre--;
+        }
+      } else if (isTrue(vnode.isComment)) {
+        vnode.elm = nodeOps.createComment(vnode.text);
+        insert(parentElm, vnode.elm, refElm);
+      } else {
+        vnode.elm = nodeOps.createTextNode(vnode.text);
+        insert(parentElm, vnode.elm, refElm);
+      }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+      var i = vnode.data;
+      if (isDef(i)) {
+        var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+        if (isDef((i = i.hook)) && isDef((i = i.init))) {
+          i(vnode, false /* hydrating */);
+        }
+        // after calling the init hook, if the vnode is a child component
+        // it should've created a child instance and mounted it. the child
+        // component also has set the placeholder vnode's elm.
+        // in that case we can just return the element and be done.
+        if (isDef(vnode.componentInstance)) {
+          initComponent(vnode, insertedVnodeQueue);
+          insert(parentElm, vnode.elm, refElm);
+          if (isTrue(isReactivated)) {
+            reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
           }
+          return true;
+        }
+      }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+      if (isDef(vnode.data.pendingInsert)) {
+        insertedVnodeQueue.push.apply(
+          insertedVnodeQueue,
+          vnode.data.pendingInsert
+        );
+        vnode.data.pendingInsert = null;
+      }
+      vnode.elm = vnode.componentInstance.$el;
+      if (isPatchable(vnode)) {
+        invokeCreateHooks(vnode, insertedVnodeQueue);
+        setScope(vnode);
+      } else {
+        // empty component root.
+        // skip all element-related modules except for ref (#3455)
+        registerRef(vnode);
+        // make sure to invoke the insert hook
+        insertedVnodeQueue.push(vnode);
+      }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+      var i;
+      // hack for #4339: a reactivated component with inner transition
+      // does not trigger because the inner node's created hooks are not called
+      // again. It's not ideal to involve module-specific logic in here but
+      // there doesn't seem to be a better way to do it.
+      var innerNode = vnode;
+      while (innerNode.componentInstance) {
+        innerNode = innerNode.componentInstance._vnode;
+        if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+          for (i = 0; i < cbs.activate.length; ++i) {
+            cbs.activate[i](emptyNode, innerNode);
+          }
+          insertedVnodeQueue.push(innerNode);
+          break;
+        }
+      }
+      // unlike a newly created component,
+      // a reactivated keep-alive component doesn't insert itself
+      insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref) {
+      if (isDef(parent)) {
+        if (isDef(ref)) {
+          if (nodeOps.parentNode(ref) === parent) {
+            nodeOps.insertBefore(parent, elm, ref);
+          }
+        } else {
+          nodeOps.appendChild(parent, elm);
+        }
+      }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+      if (Array.isArray(children)) {
+        {
+          checkDuplicateKeys(children);
+        }
+        for (var i = 0; i < children.length; ++i) {
+          createElm(
+            children[i],
+            insertedVnodeQueue,
+            vnode.elm,
+            null,
+            true,
+            children,
+            i
+          );
+        }
+      } else if (isPrimitive(vnode.text)) {
+        nodeOps.appendChild(
+          vnode.elm,
+          nodeOps.createTextNode(String(vnode.text))
+        );
+      }
+    }
+    function isPatchable(vnode) {
+      while (vnode.componentInstance) {
+        vnode = vnode.componentInstance._vnode;
+      }
+      return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+      for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+        cbs.create[i$1](emptyNode, vnode);
+      }
+      i = vnode.data.hook; // Reuse variable
+      if (isDef(i)) {
+        if (isDef(i.create)) {
+          i.create(emptyNode, vnode);
+        }
+        if (isDef(i.insert)) {
+          insertedVnodeQueue.push(vnode);
+        }
+      }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+      var i;
+      if (isDef((i = vnode.fnScopeId))) {
+        nodeOps.setStyleScope(vnode.elm, i);
+      } else {
+        var ancestor = vnode;
+        while (ancestor) {
+          if (
+            isDef((i = ancestor.context)) &&
+            isDef((i = i.$options._scopeId))
+          ) {
+            nodeOps.setStyleScope(vnode.elm, i);
+          }
+          ancestor = ancestor.parent;
+        }
+      }
+      // for slot content they should also get the scopeId from the host instance.
+      if (
+        isDef((i = activeInstance)) &&
+        i !== vnode.context &&
+        i !== vnode.fnContext &&
+        isDef((i = i.$options._scopeId))
+      ) {
+        nodeOps.setStyleScope(vnode.elm, i);
+      }
+    }
+    function addVnodes(
+      parentElm,
+      refElm,
+      vnodes,
+      startIdx,
+      endIdx,
+      insertedVnodeQueue
+    ) {
+      for (; startIdx <= endIdx; ++startIdx) {
+        createElm(
+          vnodes[startIdx],
+          insertedVnodeQueue,
+          parentElm,
+          refElm,
+          false,
+          vnodes,
+          startIdx
+        );
+      }
+    }
+    function invokeDestroyHook(vnode) {
+      var i, j;
+      var data = vnode.data;
+      if (isDef(data)) {
+        if (isDef((i = data.hook)) && isDef((i = i.destroy))) {
+          i(vnode);
+        }
+        for (i = 0; i < cbs.destroy.length; ++i) {
+          cbs.destroy[i](vnode);
+        }
+      }
+      if (isDef((i = vnode.children))) {
+        for (j = 0; j < vnode.children.length; ++j) {
+          invokeDestroyHook(vnode.children[j]);
+        }
+      }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+      for (; startIdx <= endIdx; ++startIdx) {
+        var ch = vnodes[startIdx];
+        if (isDef(ch)) {
+          if (isDef(ch.tag)) {
+            removeAndInvokeRemoveHook(ch);
+            invokeDestroyHook(ch);
+          } else {
+            // Text node
+            removeNode(ch.elm);
+          }
+        }
+      }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+      if (isDef(rm) || isDef(vnode.data)) {
+        var i;
+        var listeners = cbs.remove.length + 1;
+        if (isDef(rm)) {
+          // we have a recursively passed down rm callback
+          // increase the listeners count
+          rm.listeners += listeners;
+        } else {
+          // directly removing
+          rm = createRmCb(vnode.elm, listeners);
+        }
+        // recursively invoke hooks on child component root node
+        if (
+          isDef((i = vnode.componentInstance)) &&
+          isDef((i = i._vnode)) &&
+          isDef(i.data)
+        ) {
+          removeAndInvokeRemoveHook(i, rm);
+        }
+        for (i = 0; i < cbs.remove.length; ++i) {
+          cbs.remove[i](vnode, rm);
+        }
+        if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+          i(vnode, rm);
+        } else {
+          rm();
+        }
+      } else {
+        removeNode(vnode.elm);
+      }
+    }
+    function updateChildren(
+      parentElm,
+      oldCh,
+      newCh,
+      insertedVnodeQueue,
+      removeOnly
+    ) {
+      var oldStartIdx = 0;
+      var newStartIdx = 0;
+      var oldEndIdx = oldCh.length - 1;
+      var oldStartVnode = oldCh[0];
+      var oldEndVnode = oldCh[oldEndIdx];
+      var newEndIdx = newCh.length - 1;
+      var newStartVnode = newCh[0];
+      var newEndVnode = newCh[newEndIdx];
+      var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+      // removeOnly is a special flag used only by <transition-group>
+      // to ensure removed elements stay in correct relative positions
+      // during leaving transitions
+      var canMove = !removeOnly;
+      {
+        checkDuplicateKeys(newCh);
+      }
+      while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+        if (isUndef(oldStartVnode)) {
+          oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+        } else if (isUndef(oldEndVnode)) {
+          oldEndVnode = oldCh[--oldEndIdx];
+        } else if (sameVnode(oldStartVnode, newStartVnode)) {
+          patchVnode(
+            oldStartVnode,
+            newStartVnode,
+            insertedVnodeQueue,
+            newCh,
+            newStartIdx
+          );
+          oldStartVnode = oldCh[++oldStartIdx];
+          newStartVnode = newCh[++newStartIdx];
+        } else if (sameVnode(oldEndVnode, newEndVnode)) {
+          patchVnode(
+            oldEndVnode,
+            newEndVnode,
+            insertedVnodeQueue,
+            newCh,
+            newEndIdx
+          );
+          oldEndVnode = oldCh[--oldEndIdx];
+          newEndVnode = newCh[--newEndIdx];
+        } else if (sameVnode(oldStartVnode, newEndVnode)) {
+          // Vnode moved right
+          patchVnode(
+            oldStartVnode,
+            newEndVnode,
+            insertedVnodeQueue,
+            newCh,
+            newEndIdx
+          );
+          canMove &&
+            nodeOps.insertBefore(
+              parentElm,
+              oldStartVnode.elm,
+              nodeOps.nextSibling(oldEndVnode.elm)
+            );
+          oldStartVnode = oldCh[++oldStartIdx];
+          newEndVnode = newCh[--newEndIdx];
+        } else if (sameVnode(oldEndVnode, newStartVnode)) {
+          // Vnode moved left
+          patchVnode(
+            oldEndVnode,
+            newStartVnode,
+            insertedVnodeQueue,
+            newCh,
+            newStartIdx
+          );
+          canMove &&
+            nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+          oldEndVnode = oldCh[--oldEndIdx];
+          newStartVnode = newCh[++newStartIdx];
+        } else {
+          if (isUndef(oldKeyToIdx)) {
+            oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+          }
+          idxInOld = isDef(newStartVnode.key)
+            ? oldKeyToIdx[newStartVnode.key]
+            : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+          if (isUndef(idxInOld)) {
+            // New element
+            createElm(
+              newStartVnode,
+              insertedVnodeQueue,
+              parentElm,
+              oldStartVnode.elm,
+              false,
+              newCh,
+              newStartIdx
+            );
+          } else {
+            vnodeToMove = oldCh[idxInOld];
+            if (sameVnode(vnodeToMove, newStartVnode)) {
+              patchVnode(
+                vnodeToMove,
+                newStartVnode,
+                insertedVnodeQueue,
+                newCh,
+                newStartIdx
+              );
+              oldCh[idxInOld] = undefined;
+              canMove &&
+                nodeOps.insertBefore(
+                  parentElm,
+                  vnodeToMove.elm,
+                  oldStartVnode.elm
+                );
+            } else {
+              // same key but different element. treat as new element
+              createElm(
+                newStartVnode,
+                insertedVnodeQueue,
+                parentElm,
+                oldStartVnode.elm,
+                false,
+                newCh,
+                newStartIdx
+              );
+            }
+          }
+          newStartVnode = newCh[++newStartIdx];
+        }
+      }
+      if (oldStartIdx > oldEndIdx) {
+        refElm = isUndef(newCh[newEndIdx + 1])
+          ? null
+          : newCh[newEndIdx + 1].elm;
+        addVnodes(
+          parentElm,
+          refElm,
+          newCh,
+          newStartIdx,
+          newEndIdx,
+          insertedVnodeQueue
+        );
+      } else if (newStartIdx > newEndIdx) {
+        removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+      }
+    }
+    function checkDuplicateKeys(children) {
+      var seenKeys = {};
+      for (var i = 0; i < children.length; i++) {
+        var vnode = children[i];
+        var key = vnode.key;
+        if (isDef(key)) {
+          if (seenKeys[key]) {
+            warn(
+              "Duplicate keys detected: '" +
+                key +
+                "'. This may cause an update error.",
+              vnode.context
+            );
+          } else {
+            seenKeys[key] = true;
+          }
+        }
+      }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+      for (var i = start; i < end; i++) {
+        var c = oldCh[i];
+        if (isDef(c) && sameVnode(node, c)) {
+          return i;
+        }
+      }
+    }
+    function patchVnode(
+      oldVnode,
+      vnode,
+      insertedVnodeQueue,
+      ownerArray,
+      index,
+      removeOnly
+    ) {
+      if (oldVnode === vnode) {
+        return;
+      }
+      if (isDef(vnode.elm) && isDef(ownerArray)) {
+        // clone reused vnode
+        vnode = ownerArray[index] = cloneVNode(vnode);
+      }
+      var elm = (vnode.elm = oldVnode.elm);
+      if (isTrue(oldVnode.isAsyncPlaceholder)) {
+        if (isDef(vnode.asyncFactory.resolved)) {
+          hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+        } else {
+          vnode.isAsyncPlaceholder = true;
+        }
+        return;
+      }
+      // reuse element for static trees.
+      // note we only do this if the vnode is cloned -
+      // if the new node is not cloned it means the render functions have been
+      // reset by the hot-reload-api and we need to do a proper re-render.
+      if (
+        isTrue(vnode.isStatic) &&
+        isTrue(oldVnode.isStatic) &&
+        vnode.key === oldVnode.key &&
+        (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
+      ) {
+        vnode.componentInstance = oldVnode.componentInstance;
+        return;
       }
-      function isUnknownElement(vnode, inVPre) {
-          return (!inVPre &&
-              !vnode.ns &&
-              !(config.ignoredElements.length &&
-                  config.ignoredElements.some(function (ignore) {
-                      return isRegExp(ignore)
-                          ? ignore.test(vnode.tag)
-                          : ignore === vnode.tag;
-                  })) &&
-              config.isUnknownElement(vnode.tag));
-      }
-      var creatingElmInVPre = 0;
-      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // This vnode was used in a previous render!
-              // now it's used as a new node, overwriting its elm would cause
-              // potential patch errors down the road when it's used as an insertion
-              // reference node. Instead, we clone the node on-demand before creating
-              // associated DOM element for it.
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          vnode.isRootInsert = !nested; // for transition enter check
-          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-              return;
-          }
-          var data = vnode.data;
-          var children = vnode.children;
-          var tag = vnode.tag;
-          if (isDef(tag)) {
-              {
-                  if (data && data.pre) {
-                      creatingElmInVPre++;
-                  }
-                  if (isUnknownElement(vnode, creatingElmInVPre)) {
-                      warn('Unknown custom element: <' +
-                          tag +
-                          '> - did you ' +
-                          'register the component correctly? For recursive components, ' +
-                          'make sure to provide the "name" option.', vnode.context);
-                  }
-              }
-              vnode.elm = vnode.ns
-                  ? nodeOps.createElementNS(vnode.ns, tag)
-                  : nodeOps.createElement(tag, vnode);
-              setScope(vnode);
-              /* istanbul ignore if */
-              {
-                  createChildren(vnode, children, insertedVnodeQueue);
-                  if (isDef(data)) {
-                      invokeCreateHooks(vnode, insertedVnodeQueue);
-                  }
-                  insert(parentElm, vnode.elm, refElm);
-              }
-              if (data && data.pre) {
-                  creatingElmInVPre--;
-              }
-          }
-          else if (isTrue(vnode.isComment)) {
-              vnode.elm = nodeOps.createComment(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-          else {
-              vnode.elm = nodeOps.createTextNode(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-      }
-      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          var i = vnode.data;
-          if (isDef(i)) {
-              var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-              if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                  i(vnode, false /* hydrating */);
-              }
-              // after calling the init hook, if the vnode is a child component
-              // it should've created a child instance and mounted it. the child
-              // component also has set the placeholder vnode's elm.
-              // in that case we can just return the element and be done.
-              if (isDef(vnode.componentInstance)) {
-                  initComponent(vnode, insertedVnodeQueue);
-                  insert(parentElm, vnode.elm, refElm);
-                  if (isTrue(isReactivated)) {
-                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                  }
-                  return true;
-              }
-          }
-      }
-      function initComponent(vnode, insertedVnodeQueue) {
-          if (isDef(vnode.data.pendingInsert)) {
-              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-              vnode.data.pendingInsert = null;
-          }
-          vnode.elm = vnode.componentInstance.$el;
-          if (isPatchable(vnode)) {
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              setScope(vnode);
-          }
-          else {
-              // empty component root.
-              // skip all element-related modules except for ref (#3455)
-              registerRef(vnode);
-              // make sure to invoke the insert hook
-              insertedVnodeQueue.push(vnode);
-          }
-      }
-      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          var i;
-          // hack for #4339: a reactivated component with inner transition
-          // does not trigger because the inner node's created hooks are not called
-          // again. It's not ideal to involve module-specific logic in here but
-          // there doesn't seem to be a better way to do it.
-          var innerNode = vnode;
-          while (innerNode.componentInstance) {
-              innerNode = innerNode.componentInstance._vnode;
-              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                  for (i = 0; i < cbs.activate.length; ++i) {
-                      cbs.activate[i](emptyNode, innerNode);
-                  }
-                  insertedVnodeQueue.push(innerNode);
-                  break;
-              }
-          }
-          // unlike a newly created component,
-          // a reactivated keep-alive component doesn't insert itself
-          insert(parentElm, vnode.elm, refElm);
-      }
-      function insert(parent, elm, ref) {
-          if (isDef(parent)) {
-              if (isDef(ref)) {
-                  if (nodeOps.parentNode(ref) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref);
-                  }
-              }
-              else {
-                  nodeOps.appendChild(parent, elm);
-              }
-          }
-      }
-      function createChildren(vnode, children, insertedVnodeQueue) {
-          if (Array.isArray(children)) {
-              {
-                  checkDuplicateKeys(children);
-              }
-              for (var i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-              }
-          }
-          else if (isPrimitive(vnode.text)) {
-              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-          }
-      }
-      function isPatchable(vnode) {
-          while (vnode.componentInstance) {
-              vnode = vnode.componentInstance._vnode;
-          }
-          return isDef(vnode.tag);
-      }
-      function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-              cbs.create[i$1](emptyNode, vnode);
-          }
-          i = vnode.data.hook; // Reuse variable
-          if (isDef(i)) {
-              if (isDef(i.create))
-                  { i.create(emptyNode, vnode); }
-              if (isDef(i.insert))
-                  { insertedVnodeQueue.push(vnode); }
-          }
-      }
-      // set scope id attribute for scoped CSS.
-      // this is implemented as a special case to avoid the overhead
-      // of going through the normal attribute patching process.
-      function setScope(vnode) {
-          var i;
-          if (isDef((i = vnode.fnScopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-          else {
-              var ancestor = vnode;
-              while (ancestor) {
-                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                      nodeOps.setStyleScope(vnode.elm, i);
-                  }
-                  ancestor = ancestor.parent;
-              }
-          }
-          // for slot content they should also get the scopeId from the host instance.
-          if (isDef((i = activeInstance)) &&
-              i !== vnode.context &&
-              i !== vnode.fnContext &&
-              isDef((i = i.$options._scopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-      }
-      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-          }
-      }
-      function invokeDestroyHook(vnode) {
-          var i, j;
-          var data = vnode.data;
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  { i(vnode); }
-              for (i = 0; i < cbs.destroy.length; ++i)
-                  { cbs.destroy[i](vnode); }
-          }
-          if (isDef((i = vnode.children))) {
-              for (j = 0; j < vnode.children.length; ++j) {
-                  invokeDestroyHook(vnode.children[j]);
-              }
-          }
-      }
-      function removeVnodes(vnodes, startIdx, endIdx) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              var ch = vnodes[startIdx];
-              if (isDef(ch)) {
-                  if (isDef(ch.tag)) {
-                      removeAndInvokeRemoveHook(ch);
-                      invokeDestroyHook(ch);
-                  }
-                  else {
-                      // Text node
-                      removeNode(ch.elm);
-                  }
-              }
-          }
-      }
-      function removeAndInvokeRemoveHook(vnode, rm) {
-          if (isDef(rm) || isDef(vnode.data)) {
-              var i;
-              var listeners = cbs.remove.length + 1;
-              if (isDef(rm)) {
-                  // we have a recursively passed down rm callback
-                  // increase the listeners count
-                  rm.listeners += listeners;
-              }
-              else {
-                  // directly removing
-                  rm = createRmCb(vnode.elm, listeners);
-              }
-              // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
-              }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
-              }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          }
-          else {
-              removeNode(vnode.elm);
-          }
-      }
-      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          var oldStartIdx = 0;
-          var newStartIdx = 0;
-          var oldEndIdx = oldCh.length - 1;
-          var oldStartVnode = oldCh[0];
-          var oldEndVnode = oldCh[oldEndIdx];
-          var newEndIdx = newCh.length - 1;
-          var newStartVnode = newCh[0];
-          var newEndVnode = newCh[newEndIdx];
-          var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-          // removeOnly is a special flag used only by <transition-group>
-          // to ensure removed elements stay in correct relative positions
-          // during leaving transitions
-          var canMove = !removeOnly;
-          {
-              checkDuplicateKeys(newCh);
-          }
-          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-              if (isUndef(oldStartVnode)) {
-                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-              }
-              else if (isUndef(oldEndVnode)) {
-                  oldEndVnode = oldCh[--oldEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newStartVnode)) {
-                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else if (sameVnode(oldEndVnode, newEndVnode)) {
-                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newEndVnode)) {
-                  // Vnode moved right
-                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldEndVnode, newStartVnode)) {
-                  // Vnode moved left
-                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else {
-                  if (isUndef(oldKeyToIdx))
-                      { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-                  idxInOld = isDef(newStartVnode.key)
-                      ? oldKeyToIdx[newStartVnode.key]
-                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                  if (isUndef(idxInOld)) {
-                      // New element
-                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                  }
-                  else {
-                      vnodeToMove = oldCh[idxInOld];
-                      if (sameVnode(vnodeToMove, newStartVnode)) {
-                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                          oldCh[idxInOld] = undefined;
-                          canMove &&
-                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                      }
-                      else {
-                          // same key but different element. treat as new element
-                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                      }
-                  }
-                  newStartVnode = newCh[++newStartIdx];
-              }
-          }
-          if (oldStartIdx > oldEndIdx) {
-              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-          }
-          else if (newStartIdx > newEndIdx) {
-              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-          }
-      }
-      function checkDuplicateKeys(children) {
-          var seenKeys = {};
-          for (var i = 0; i < children.length; i++) {
-              var vnode = children[i];
-              var key = vnode.key;
-              if (isDef(key)) {
-                  if (seenKeys[key]) {
-                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
-                  }
-                  else {
-                      seenKeys[key] = true;
-                  }
-              }
-          }
-      }
-      function findIdxInOld(node, oldCh, start, end) {
-          for (var i = start; i < end; i++) {
-              var c = oldCh[i];
-              if (isDef(c) && sameVnode(node, c))
-                  { return i; }
-          }
-      }
-      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-          if (oldVnode === vnode) {
-              return;
-          }
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // clone reused vnode
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          var elm = (vnode.elm = oldVnode.elm);
-          if (isTrue(oldVnode.isAsyncPlaceholder)) {
-              if (isDef(vnode.asyncFactory.resolved)) {
-                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-              }
-              else {
-                  vnode.isAsyncPlaceholder = true;
-              }
-              return;
-          }
-          // reuse element for static trees.
-          // note we only do this if the vnode is cloned -
-          // if the new node is not cloned it means the render functions have been
-          // reset by the hot-reload-api and we need to do a proper re-render.
-          if (isTrue(vnode.isStatic) &&
-              isTrue(oldVnode.isStatic) &&
-              vnode.key === oldVnode.key &&
-              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-              vnode.componentInstance = oldVnode.componentInstance;
-              return;
-          }
-          var i;
-          var data = vnode.data;
-          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-              i(oldVnode, vnode);
-          }
-          var oldCh = oldVnode.children;
-          var ch = vnode.children;
-          if (isDef(data) && isPatchable(vnode)) {
-              for (i = 0; i < cbs.update.length; ++i)
-                  { cbs.update[i](oldVnode, vnode); }
-              if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  { i(oldVnode, vnode); }
-          }
-          if (isUndef(vnode.text)) {
-              if (isDef(oldCh) && isDef(ch)) {
-                  if (oldCh !== ch)
-                      { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-              }
-              else if (isDef(ch)) {
-                  {
-                      checkDuplicateKeys(ch);
-                  }
-                  if (isDef(oldVnode.text))
-                      { nodeOps.setTextContent(elm, ''); }
-                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-              }
-              else if (isDef(oldCh)) {
-                  removeVnodes(oldCh, 0, oldCh.length - 1);
-              }
-              else if (isDef(oldVnode.text)) {
-                  nodeOps.setTextContent(elm, '');
-              }
-          }
-          else if (oldVnode.text !== vnode.text) {
-              nodeOps.setTextContent(elm, vnode.text);
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  { i(oldVnode, vnode); }
-          }
-      }
-      function invokeInsertHook(vnode, queue, initial) {
-          // delay insert hooks for component root nodes, invoke them after the
-          // element is really inserted
-          if (isTrue(initial) && isDef(vnode.parent)) {
-              vnode.parent.data.pendingInsert = queue;
-          }
-          else {
-              for (var i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
-              }
-          }
-      }
-      var hydrationBailed = false;
-      // list of modules that can skip create hook during hydration because they
-      // are already rendered on the client or has no need for initialization
-      // Note: style is excluded because it relies on initial clone for future
-      // deep updates (#7063).
-      var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-      // Note: this is a browser-only function so we can assume elms are DOM nodes.
-      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          var i;
-          var tag = vnode.tag;
-          var data = vnode.data;
-          var children = vnode.children;
-          inVPre = inVPre || (data && data.pre);
-          vnode.elm = elm;
-          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-              vnode.isAsyncPlaceholder = true;
-              return true;
-          }
-          // assert node match
+      var i;
+      var data = vnode.data;
+      if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+        i(oldVnode, vnode);
+      }
+      var oldCh = oldVnode.children;
+      var ch = vnode.children;
+      if (isDef(data) && isPatchable(vnode)) {
+        for (i = 0; i < cbs.update.length; ++i) {
+          cbs.update[i](oldVnode, vnode);
+        }
+        if (isDef((i = data.hook)) && isDef((i = i.update))) {
+          i(oldVnode, vnode);
+        }
+      }
+      if (isUndef(vnode.text)) {
+        if (isDef(oldCh) && isDef(ch)) {
+          if (oldCh !== ch) {
+            updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+          }
+        } else if (isDef(ch)) {
           {
-              if (!assertNodeMatch(elm, vnode, inVPre)) {
-                  return false;
-              }
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  { i(vnode, true /* hydrating */); }
-              if (isDef((i = vnode.componentInstance))) {
-                  // child component. it should have hydrated its own tree.
-                  initComponent(vnode, insertedVnodeQueue);
-                  return true;
-              }
-          }
-          if (isDef(tag)) {
-              if (isDef(children)) {
-                  // empty element, allow client to pick up and populate children
-                  if (!elm.hasChildNodes()) {
-                      createChildren(vnode, children, insertedVnodeQueue);
-                  }
-                  else {
-                      // v-html and domProps: innerHTML
-                      if (isDef((i = data)) &&
-                          isDef((i = i.domProps)) &&
-                          isDef((i = i.innerHTML))) {
-                          if (i !== elm.innerHTML) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('server innerHTML: ', i);
-                                  console.warn('client innerHTML: ', elm.innerHTML);
-                              }
-                              return false;
-                          }
-                      }
-                      else {
-                          // iterate and compare children lists
-                          var childrenMatch = true;
-                          var childNode = elm.firstChild;
-                          for (var i$1 = 0; i$1 < children.length; i$1++) {
-                              if (!childNode ||
-                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
-                                  childrenMatch = false;
-                                  break;
-                              }
-                              childNode = childNode.nextSibling;
-                          }
-                          // if childNode is not null, it means the actual childNodes list is
-                          // longer than the virtual children list.
-                          if (!childrenMatch || childNode) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                              }
-                              return false;
-                          }
-                      }
-                  }
-              }
-              if (isDef(data)) {
-                  var fullInvoke = false;
-                  for (var key in data) {
-                      if (!isRenderedModule(key)) {
-                          fullInvoke = true;
-                          invokeCreateHooks(vnode, insertedVnodeQueue);
-                          break;
-                      }
-                  }
-                  if (!fullInvoke && data['class']) {
-                      // ensure collecting deps for deep class bindings for future updates
-                      traverse(data['class']);
+            checkDuplicateKeys(ch);
+          }
+          if (isDef(oldVnode.text)) {
+            nodeOps.setTextContent(elm, "");
+          }
+          addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+        } else if (isDef(oldCh)) {
+          removeVnodes(oldCh, 0, oldCh.length - 1);
+        } else if (isDef(oldVnode.text)) {
+          nodeOps.setTextContent(elm, "");
+        }
+      } else if (oldVnode.text !== vnode.text) {
+        nodeOps.setTextContent(elm, vnode.text);
+      }
+      if (isDef(data)) {
+        if (isDef((i = data.hook)) && isDef((i = i.postpatch))) {
+          i(oldVnode, vnode);
+        }
+      }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+      // delay insert hooks for component root nodes, invoke them after the
+      // element is really inserted
+      if (isTrue(initial) && isDef(vnode.parent)) {
+        vnode.parent.data.pendingInsert = queue;
+      } else {
+        for (var i = 0; i < queue.length; ++i) {
+          queue[i].data.hook.insert(queue[i]);
+        }
+      }
+    }
+    var hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    var isRenderedModule = makeMap("attrs,class,staticClass,staticStyle,key");
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+      var i;
+      var tag = vnode.tag;
+      var data = vnode.data;
+      var children = vnode.children;
+      inVPre = inVPre || (data && data.pre);
+      vnode.elm = elm;
+      if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+        vnode.isAsyncPlaceholder = true;
+        return true;
+      }
+      // assert node match
+      {
+        if (!assertNodeMatch(elm, vnode, inVPre)) {
+          return false;
+        }
+      }
+      if (isDef(data)) {
+        if (isDef((i = data.hook)) && isDef((i = i.init))) {
+          i(vnode, true /* hydrating */);
+        }
+        if (isDef((i = vnode.componentInstance))) {
+          // child component. it should have hydrated its own tree.
+          initComponent(vnode, insertedVnodeQueue);
+          return true;
+        }
+      }
+      if (isDef(tag)) {
+        if (isDef(children)) {
+          // empty element, allow client to pick up and populate children
+          if (!elm.hasChildNodes()) {
+            createChildren(vnode, children, insertedVnodeQueue);
+          } else {
+            // v-html and domProps: innerHTML
+            if (
+              isDef((i = data)) &&
+              isDef((i = i.domProps)) &&
+              isDef((i = i.innerHTML))
+            ) {
+              if (i !== elm.innerHTML) {
+                /* istanbul ignore if */
+                if (typeof console !== "undefined" && !hydrationBailed) {
+                  hydrationBailed = true;
+                  console.warn("Parent: ", elm);
+                  console.warn("server innerHTML: ", i);
+                  console.warn("client innerHTML: ", elm.innerHTML);
+                }
+                return false;
+              }
+            } else {
+              // iterate and compare children lists
+              var childrenMatch = true;
+              var childNode = elm.firstChild;
+              for (var i$1 = 0; i$1 < children.length; i$1++) {
+                if (
+                  !childNode ||
+                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)
+                ) {
+                  childrenMatch = false;
+                  break;
+                }
+                childNode = childNode.nextSibling;
+              }
+              // if childNode is not null, it means the actual childNodes list is
+              // longer than the virtual children list.
+              if (!childrenMatch || childNode) {
+                /* istanbul ignore if */
+                if (typeof console !== "undefined" && !hydrationBailed) {
+                  hydrationBailed = true;
+                  console.warn("Parent: ", elm);
+                  console.warn(
+                    "Mismatching childNodes vs. VNodes: ",
+                    elm.childNodes,
+                    children
+                  );
+                }
+                return false;
+              }
+            }
+          }
+        }
+        if (isDef(data)) {
+          var fullInvoke = false;
+          for (var key in data) {
+            if (!isRenderedModule(key)) {
+              fullInvoke = true;
+              invokeCreateHooks(vnode, insertedVnodeQueue);
+              break;
+            }
+          }
+          if (!fullInvoke && data["class"]) {
+            // ensure collecting deps for deep class bindings for future updates
+            traverse(data["class"]);
+          }
+        }
+      } else if (elm.data !== vnode.text) {
+        elm.data = vnode.text;
+      }
+      return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+      if (isDef(vnode.tag)) {
+        return (
+          vnode.tag.indexOf("vue-component") === 0 ||
+          (!isUnknownElement(vnode, inVPre) &&
+            vnode.tag.toLowerCase() ===
+              (node.tagName && node.tagName.toLowerCase()))
+        );
+      } else {
+        return node.nodeType === (vnode.isComment ? 8 : 3);
+      }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+      if (isUndef(vnode)) {
+        if (isDef(oldVnode)) {
+          invokeDestroyHook(oldVnode);
+        }
+        return;
+      }
+      var isInitialPatch = false;
+      var insertedVnodeQueue = [];
+      if (isUndef(oldVnode)) {
+        // empty mount (likely as component), create new root element
+        isInitialPatch = true;
+        createElm(vnode, insertedVnodeQueue);
+      } else {
+        var isRealElement = isDef(oldVnode.nodeType);
+        if (!isRealElement && sameVnode(oldVnode, vnode)) {
+          // patch existing root node
+          patchVnode(
+            oldVnode,
+            vnode,
+            insertedVnodeQueue,
+            null,
+            null,
+            removeOnly
+          );
+        } else {
+          if (isRealElement) {
+            // mounting to a real element
+            // check if this is server-rendered content and if we can perform
+            // a successful hydration.
+            if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+              oldVnode.removeAttribute(SSR_ATTR);
+              hydrating = true;
+            }
+            if (isTrue(hydrating)) {
+              if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                invokeInsertHook(vnode, insertedVnodeQueue, true);
+                return oldVnode;
+              } else {
+                warn(
+                  "The client-side rendered virtual DOM tree is not matching " +
+                    "server-rendered content. This is likely caused by incorrect " +
+                    "HTML markup, for example nesting block-level elements inside " +
+                    "<p>, or missing <tbody>. Bailing hydration and performing " +
+                    "full client-side render."
+                );
+              }
+            }
+            // either not server-rendered, or hydration failed.
+            // create an empty node and replace it
+            oldVnode = emptyNodeAt(oldVnode);
+          }
+          // replacing existing element
+          var oldElm = oldVnode.elm;
+          var parentElm = nodeOps.parentNode(oldElm);
+          // create new node
+          createElm(
+            vnode,
+            insertedVnodeQueue,
+            // extremely rare edge case: do not insert if old element is in a
+            // leaving transition. Only happens when combining transition +
+            // keep-alive + HOCs. (#4590)
+            oldElm._leaveCb ? null : parentElm,
+            nodeOps.nextSibling(oldElm)
+          );
+          // update parent placeholder node element, recursively
+          if (isDef(vnode.parent)) {
+            var ancestor = vnode.parent;
+            var patchable = isPatchable(vnode);
+            while (ancestor) {
+              for (var i = 0; i < cbs.destroy.length; ++i) {
+                cbs.destroy[i](ancestor);
+              }
+              ancestor.elm = vnode.elm;
+              if (patchable) {
+                for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                  cbs.create[i$1](emptyNode, ancestor);
+                }
+                // #6513
+                // invoke insert hooks that may have been merged by create hooks.
+                // e.g. for directives that uses the "inserted" hook.
+                var insert = ancestor.data.hook.insert;
+                if (insert.merged) {
+                  // start at index 1 to avoid re-invoking component mounted hook
+                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                    insert.fns[i$2]();
                   }
+                }
+              } else {
+                registerRef(ancestor);
               }
+              ancestor = ancestor.parent;
+            }
           }
-          else if (elm.data !== vnode.text) {
-              elm.data = vnode.text;
-          }
-          return true;
-      }
-      function assertNodeMatch(node, vnode, inVPre) {
-          if (isDef(vnode.tag)) {
-              return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement(vnode, inVPre) &&
-                      vnode.tag.toLowerCase() ===
-                          (node.tagName && node.tagName.toLowerCase())));
-          }
-          else {
-              return node.nodeType === (vnode.isComment ? 8 : 3);
+          // destroy old node
+          if (isDef(parentElm)) {
+            removeVnodes([oldVnode], 0, 0);
+          } else if (isDef(oldVnode.tag)) {
+            invokeDestroyHook(oldVnode);
           }
+        }
       }
-      return function patch(oldVnode, vnode, hydrating, removeOnly) {
-          if (isUndef(vnode)) {
-              if (isDef(oldVnode))
-                  { invokeDestroyHook(oldVnode); }
-              return;
-          }
-          var isInitialPatch = false;
-          var insertedVnodeQueue = [];
-          if (isUndef(oldVnode)) {
-              // empty mount (likely as component), create new root element
-              isInitialPatch = true;
-              createElm(vnode, insertedVnodeQueue);
-          }
-          else {
-              var isRealElement = isDef(oldVnode.nodeType);
-              if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                  // patch existing root node
-                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-              }
-              else {
-                  if (isRealElement) {
-                      // mounting to a real element
-                      // check if this is server-rendered content and if we can perform
-                      // a successful hydration.
-                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                          oldVnode.removeAttribute(SSR_ATTR);
-                          hydrating = true;
-                      }
-                      if (isTrue(hydrating)) {
-                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                              invokeInsertHook(vnode, insertedVnodeQueue, true);
-                              return oldVnode;
-                          }
-                          else {
-                              warn('The client-side rendered virtual DOM tree is not matching ' +
-                                  'server-rendered content. This is likely caused by incorrect ' +
-                                  'HTML markup, for example nesting block-level elements inside ' +
-                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                  'full client-side render.');
-                          }
-                      }
-                      // either not server-rendered, or hydration failed.
-                      // create an empty node and replace it
-                      oldVnode = emptyNodeAt(oldVnode);
-                  }
-                  // replacing existing element
-                  var oldElm = oldVnode.elm;
-                  var parentElm = nodeOps.parentNode(oldElm);
-                  // create new node
-                  createElm(vnode, insertedVnodeQueue, 
-                  // extremely rare edge case: do not insert if old element is in a
-                  // leaving transition. Only happens when combining transition +
-                  // keep-alive + HOCs. (#4590)
-                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                  // update parent placeholder node element, recursively
-                  if (isDef(vnode.parent)) {
-                      var ancestor = vnode.parent;
-                      var patchable = isPatchable(vnode);
-                      while (ancestor) {
-                          for (var i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
-                          }
-                          ancestor.elm = vnode.elm;
-                          if (patchable) {
-                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                  cbs.create[i$1](emptyNode, ancestor);
-                              }
-                              // #6513
-                              // invoke insert hooks that may have been merged by create hooks.
-                              // e.g. for directives that uses the "inserted" hook.
-                              var insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
-                                  // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                      insert.fns[i$2]();
-                                  }
-                              }
-                          }
-                          else {
-                              registerRef(ancestor);
-                          }
-                          ancestor = ancestor.parent;
-                      }
-                  }
-                  // destroy old node
-                  if (isDef(parentElm)) {
-                      removeVnodes([oldVnode], 0, 0);
-                  }
-                  else if (isDef(oldVnode.tag)) {
-                      invokeDestroyHook(oldVnode);
-                  }
-              }
-          }
-          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-          return vnode.elm;
-      };
+      invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+      return vnode.elm;
+    };
   }
 
   var directives = {
-      create: updateDirectives,
-      update: updateDirectives,
-      destroy: function unbindDirectives(vnode) {
-          // @ts-expect-error emptyNode is not VNodeWithData
-          updateDirectives(vnode, emptyNode);
-      },
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+      // @ts-expect-error emptyNode is not VNodeWithData
+      updateDirectives(vnode, emptyNode);
+    },
   };
   function updateDirectives(oldVnode, vnode) {
-      if (oldVnode.data.directives || vnode.data.directives) {
-          _update(oldVnode, vnode);
-      }
+    if (oldVnode.data.directives || vnode.data.directives) {
+      _update(oldVnode, vnode);
+    }
   }
   function _update(oldVnode, vnode) {
-      var isCreate = oldVnode === emptyNode;
-      var isDestroy = vnode === emptyNode;
-      var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      var dirsWithInsert = [];
-      var dirsWithPostpatch = [];
-      var key, oldDir, dir;
-      for (key in newDirs) {
-          oldDir = oldDirs[key];
-          dir = newDirs[key];
-          if (!oldDir) {
-              // new directive, bind
-              callHook(dir, 'bind', vnode, oldVnode);
-              if (dir.def && dir.def.inserted) {
-                  dirsWithInsert.push(dir);
-              }
-          }
-          else {
-              // existing directive, update
-              dir.oldValue = oldDir.value;
-              dir.oldArg = oldDir.arg;
-              callHook(dir, 'update', vnode, oldVnode);
-              if (dir.def && dir.def.componentUpdated) {
-                  dirsWithPostpatch.push(dir);
-              }
-          }
-      }
-      if (dirsWithInsert.length) {
-          var callInsert = function () {
-              for (var i = 0; i < dirsWithInsert.length; i++) {
-                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-              }
-          };
-          if (isCreate) {
-              mergeVNodeHook(vnode, 'insert', callInsert);
-          }
-          else {
-              callInsert();
-          }
-      }
-      if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', function () {
-              for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-              }
-          });
-      }
-      if (!isCreate) {
-          for (key in oldDirs) {
-              if (!newDirs[key]) {
-                  // no longer present, unbind
-                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-              }
-          }
+    var isCreate = oldVnode === emptyNode;
+    var isDestroy = vnode === emptyNode;
+    var oldDirs = normalizeDirectives(
+      oldVnode.data.directives,
+      oldVnode.context
+    );
+    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    var dirsWithInsert = [];
+    var dirsWithPostpatch = [];
+    var key, oldDir, dir;
+    for (key in newDirs) {
+      oldDir = oldDirs[key];
+      dir = newDirs[key];
+      if (!oldDir) {
+        // new directive, bind
+        callHook(dir, "bind", vnode, oldVnode);
+        if (dir.def && dir.def.inserted) {
+          dirsWithInsert.push(dir);
+        }
+      } else {
+        // existing directive, update
+        dir.oldValue = oldDir.value;
+        dir.oldArg = oldDir.arg;
+        callHook(dir, "update", vnode, oldVnode);
+        if (dir.def && dir.def.componentUpdated) {
+          dirsWithPostpatch.push(dir);
+        }
+      }
+    }
+    if (dirsWithInsert.length) {
+      var callInsert = function () {
+        for (var i = 0; i < dirsWithInsert.length; i++) {
+          callHook(dirsWithInsert[i], "inserted", vnode, oldVnode);
+        }
+      };
+      if (isCreate) {
+        mergeVNodeHook(vnode, "insert", callInsert);
+      } else {
+        callInsert();
+      }
+    }
+    if (dirsWithPostpatch.length) {
+      mergeVNodeHook(vnode, "postpatch", function () {
+        for (var i = 0; i < dirsWithPostpatch.length; i++) {
+          callHook(dirsWithPostpatch[i], "componentUpdated", vnode, oldVnode);
+        }
+      });
+    }
+    if (!isCreate) {
+      for (key in oldDirs) {
+        if (!newDirs[key]) {
+          // no longer present, unbind
+          callHook(oldDirs[key], "unbind", oldVnode, oldVnode, isDestroy);
+        }
       }
+    }
   }
   var emptyModifiers = Object.create(null);
   function normalizeDirectives(dirs, vm) {
-      var res = Object.create(null);
-      if (!dirs) {
-          // $flow-disable-line
-          return res;
-      }
-      var i, dir;
-      for (i = 0; i < dirs.length; i++) {
-          dir = dirs[i];
-          if (!dir.modifiers) {
-              // $flow-disable-line
-              dir.modifiers = emptyModifiers;
-          }
-          res[getRawDirName(dir)] = dir;
-          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-      }
+    var res = Object.create(null);
+    if (!dirs) {
       // $flow-disable-line
       return res;
+    }
+    var i, dir;
+    for (i = 0; i < dirs.length; i++) {
+      dir = dirs[i];
+      if (!dir.modifiers) {
+        // $flow-disable-line
+        dir.modifiers = emptyModifiers;
+      }
+      res[getRawDirName(dir)] = dir;
+      dir.def = resolveAsset(vm.$options, "directives", dir.name, true);
+    }
+    // $flow-disable-line
+    return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (
+      dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join(".")
+    );
   }
   function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      var fn = dir.def && dir.def[hook];
-      if (fn) {
-          try {
-              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-          }
-          catch (e) {
-              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
-          }
+    var fn = dir.def && dir.def[hook];
+    if (fn) {
+      try {
+        fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+      } catch (e) {
+        handleError(
+          e,
+          vnode.context,
+          "directive " + dir.name + " " + hook + " hook"
+        );
       }
+    }
   }
 
   var baseModules = [ref, directives];
 
   function updateAttrs(oldVnode, vnode) {
-      var opts = vnode.componentOptions;
-      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-          return;
-      }
-      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-          return;
-      }
-      var key, cur, old;
-      var elm = vnode.elm;
-      var oldAttrs = oldVnode.data.attrs || {};
-      var attrs = vnode.data.attrs || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(attrs.__ob__)) {
-          attrs = vnode.data.attrs = extend({}, attrs);
-      }
-      for (key in attrs) {
-          cur = attrs[key];
-          old = oldAttrs[key];
-          if (old !== cur) {
-              setAttr(elm, key, cur, vnode.data.pre);
-          }
-      }
-      // #4391: in IE9, setting type can reset value for input[type=radio]
-      // #6666: IE/Edge forces progress value down to 1 before setting a max
-      /* istanbul ignore if */
-      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-          setAttr(elm, 'value', attrs.value);
-      }
-      for (key in oldAttrs) {
-          if (isUndef(attrs[key])) {
-              if (isXlink(key)) {
-                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-              }
-              else if (!isEnumeratedAttr(key)) {
-                  elm.removeAttribute(key);
-              }
-          }
-      }
+    var opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+      return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+      return;
+    }
+    var key, cur, old;
+    var elm = vnode.elm;
+    var oldAttrs = oldVnode.data.attrs || {};
+    var attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+      attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+      cur = attrs[key];
+      old = oldAttrs[key];
+      if (old !== cur) {
+        setAttr(elm, key, cur, vnode.data.pre);
+      }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+      setAttr(elm, "value", attrs.value);
+    }
+    for (key in oldAttrs) {
+      if (isUndef(attrs[key])) {
+        if (isXlink(key)) {
+          elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        } else if (!isEnumeratedAttr(key)) {
+          elm.removeAttribute(key);
+        }
+      }
+    }
   }
   function setAttr(el, key, value, isInPre) {
-      if (isInPre || el.tagName.indexOf('-') > -1) {
-          baseSetAttr(el, key, value);
-      }
-      else if (isBooleanAttr(key)) {
-          // set attribute for blank value
-          // e.g. <option disabled>Select one</option>
-          if (isFalsyAttrValue(value)) {
-              el.removeAttribute(key);
-          }
-          else {
-              // technically allowfullscreen is a boolean attribute for <iframe>,
-              // but Flash expects a value of "true" when used on <embed> tag
-              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-              el.setAttribute(key, value);
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          el.setAttribute(key, convertEnumeratedValue(key, value));
-      }
-      else if (isXlink(key)) {
-          if (isFalsyAttrValue(value)) {
-              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-          }
-          else {
-              el.setAttributeNS(xlinkNS, key, value);
-          }
-      }
-      else {
-          baseSetAttr(el, key, value);
+    if (isInPre || el.tagName.indexOf("-") > -1) {
+      baseSetAttr(el, key, value);
+    } else if (isBooleanAttr(key)) {
+      // set attribute for blank value
+      // e.g. <option disabled>Select one</option>
+      if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+      } else {
+        // technically allowfullscreen is a boolean attribute for <iframe>,
+        // but Flash expects a value of "true" when used on <embed> tag
+        value =
+          key === "allowfullscreen" && el.tagName === "EMBED" ? "true" : key;
+        el.setAttribute(key, value);
+      }
+    } else if (isEnumeratedAttr(key)) {
+      el.setAttribute(key, convertEnumeratedValue(key, value));
+    } else if (isXlink(key)) {
+      if (isFalsyAttrValue(value)) {
+        el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+      } else {
+        el.setAttributeNS(xlinkNS, key, value);
       }
+    } else {
+      baseSetAttr(el, key, value);
+    }
   }
   function baseSetAttr(el, key, value) {
-      if (isFalsyAttrValue(value)) {
-          el.removeAttribute(key);
-      }
-      else {
-          // #7138: IE10 & 11 fires input event when setting placeholder on
-          // <textarea>... block the first input event and remove the blocker
-          // immediately.
-          /* istanbul ignore if */
-          if (isIE &&
-              !isIE9 &&
-              el.tagName === 'TEXTAREA' &&
-              key === 'placeholder' &&
-              value !== '' &&
-              !el.__ieph) {
-              var blocker = function (e) {
-                  e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
-              };
-              el.addEventListener('input', blocker);
-              // $flow-disable-line
-              el.__ieph = true; /* IE placeholder patched */
-          }
-          el.setAttribute(key, value);
-      }
+    if (isFalsyAttrValue(value)) {
+      el.removeAttribute(key);
+    } else {
+      // #7138: IE10 & 11 fires input event when setting placeholder on
+      // <textarea>... block the first input event and remove the blocker
+      // immediately.
+      /* istanbul ignore if */
+      if (
+        isIE &&
+        !isIE9 &&
+        el.tagName === "TEXTAREA" &&
+        key === "placeholder" &&
+        value !== "" &&
+        !el.__ieph
+      ) {
+        var blocker = function (e) {
+          e.stopImmediatePropagation();
+          el.removeEventListener("input", blocker);
+        };
+        el.addEventListener("input", blocker);
+        // $flow-disable-line
+        el.__ieph = true; /* IE placeholder patched */
+      }
+      el.setAttribute(key, value);
+    }
   }
   var attrs = {
-      create: updateAttrs,
-      update: updateAttrs,
+    create: updateAttrs,
+    update: updateAttrs,
   };
 
   function updateClass(oldVnode, vnode) {
-      var el = vnode.elm;
-      var data = vnode.data;
-      var oldData = oldVnode.data;
-      if (isUndef(data.staticClass) &&
-          isUndef(data.class) &&
-          (isUndef(oldData) ||
-              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-          return;
-      }
-      var cls = genClassForVnode(vnode);
-      // handle transition classes
-      var transitionClass = el._transitionClasses;
-      if (isDef(transitionClass)) {
-          cls = concat(cls, stringifyClass(transitionClass));
-      }
-      // set the class
-      if (cls !== el._prevClass) {
-          el.setAttribute('class', cls);
-          el._prevClass = cls;
-      }
+    var el = vnode.elm;
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (
+      isUndef(data.staticClass) &&
+      isUndef(data.class) &&
+      (isUndef(oldData) ||
+        (isUndef(oldData.staticClass) && isUndef(oldData.class)))
+    ) {
+      return;
+    }
+    var cls = genClassForVnode(vnode);
+    // handle transition classes
+    var transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+      cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+      el.setAttribute("class", cls);
+      el._prevClass = cls;
+    }
   }
   var klass = {
-      create: updateClass,
-      update: updateClass,
+    create: updateClass,
+    update: updateClass,
   };
 
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r';
-  var CHECKBOX_RADIO_TOKEN = '__c';
+  var RANGE_TOKEN = "__r";
+  var CHECKBOX_RADIO_TOKEN = "__c";
 
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
   // the whole point is ensuring the v-model callback gets called before
   // user-attached handlers.
   function normalizeEvents(on) {
-      /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN])) {
-          // IE input[type=range] only supports `change` event
-          var event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-          delete on[RANGE_TOKEN];
-      }
-      // This was originally intended to fix #4521 but no longer necessary
-      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-      /* istanbul ignore if */
-      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-          delete on[CHECKBOX_RADIO_TOKEN];
-      }
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+      // IE input[type=range] only supports `change` event
+      var event = isIE ? "change" : "input";
+      on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+      delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+      on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+      delete on[CHECKBOX_RADIO_TOKEN];
+    }
   }
   var target;
   function createOnceHandler(event, handler, capture) {
-      var _target = target; // save current target element in closure
-      return function onceHandler() {
-          var res = handler.apply(null, arguments);
-          if (res !== null) {
-              remove(event, onceHandler, capture, _target);
-          }
-      };
+    var _target = target; // save current target element in closure
+    return function onceHandler() {
+      var res = handler.apply(null, arguments);
+      if (res !== null) {
+        remove(event, onceHandler, capture, _target);
+      }
+    };
   }
   // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
   var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
   function add(name, handler, capture, passive) {
-      // async edge case #6566: inner click event triggers patch, event handler
-      // attached to outer element during patch, and triggered again. This
-      // happens because browsers fire microtask ticks between event propagation.
-      // the solution is simple: we save the timestamp when a handler is attached,
-      // and the handler would only fire if the event passed to it was fired
-      // AFTER it was attached.
-      if (useMicrotaskFix) {
-          var attachedTimestamp = currentFlushTimestamp;
-          var original = handler;
-          //@ts-expect-error
-          handler = original._wrapper = function (e) {
-              if (
-              // no bubbling, should always fire.
-              // this is just a safety net in case event.timeStamp is unreliable in
-              // certain weird environments...
-              e.target === e.currentTarget ||
-                  // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
-                  // bail for environments that have buggy event.timeStamp implementations
-                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                  // #9681 QtWebEngine event.timeStamp is negative value
-                  e.timeStamp <= 0 ||
-                  // #9448 bail if event is fired in another document in a multi-page
-                  // electron/nw.js app, since event.timeStamp will be using a different
-                  // starting reference
-                  e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
-              }
-          };
-      }
-      target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+      var attachedTimestamp = currentFlushTimestamp;
+      var original = handler;
+      //@ts-expect-error
+      handler = original._wrapper = function (e) {
+        if (
+          // no bubbling, should always fire.
+          // this is just a safety net in case event.timeStamp is unreliable in
+          // certain weird environments...
+          e.target === e.currentTarget ||
+          // event is fired after handler attachment
+          e.timeStamp >= attachedTimestamp ||
+          // bail for environments that have buggy event.timeStamp implementations
+          // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+          // #9681 QtWebEngine event.timeStamp is negative value
+          e.timeStamp <= 0 ||
+          // #9448 bail if event is fired in another document in a multi-page
+          // electron/nw.js app, since event.timeStamp will be using a different
+          // starting reference
+          e.target.ownerDocument !== document
+        ) {
+          return original.apply(this, arguments);
+        }
+      };
+    }
+    target.addEventListener(
+      name,
+      handler,
+      supportsPassive ? { capture: capture, passive: passive } : capture
+    );
   }
   function remove(name, handler, capture, _target) {
-      (_target || target).removeEventListener(name, 
+    (_target || target).removeEventListener(
+      name,
       //@ts-expect-error
-      handler._wrapper || handler, capture);
+      handler._wrapper || handler,
+      capture
+    );
   }
   function updateDOMListeners(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-          return;
-      }
-      var on = vnode.data.on || {};
-      var oldOn = oldVnode.data.on || {};
-      target = vnode.elm;
-      normalizeEvents(on);
-      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-      target = undefined;
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+      return;
+    }
+    var on = vnode.data.on || {};
+    var oldOn = oldVnode.data.on || {};
+    target = vnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
   }
   var events = {
-      create: updateDOMListeners,
-      update: updateDOMListeners,
+    create: updateDOMListeners,
+    update: updateDOMListeners,
   };
 
   var svgContainer;
   function updateDOMProps(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-          return;
-      }
-      var key, cur;
-      var elm = vnode.elm;
-      var oldProps = oldVnode.data.domProps || {};
-      var props = vnode.data.domProps || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(props.__ob__)) {
-          props = vnode.data.domProps = extend({}, props);
-      }
-      for (key in oldProps) {
-          if (!(key in props)) {
-              elm[key] = '';
-          }
-      }
-      for (key in props) {
-          cur = props[key];
-          // ignore children if the node has textContent or innerHTML,
-          // as these will throw away existing DOM nodes and cause removal errors
-          // on subsequent patches (#3360)
-          if (key === 'textContent' || key === 'innerHTML') {
-              if (vnode.children)
-                  { vnode.children.length = 0; }
-              if (cur === oldProps[key])
-                  { continue; }
-              // #6601 work around Chrome version <= 55 bug where single textNode
-              // replaced by innerHTML/textContent retains its parentNode property
-              if (elm.childNodes.length === 1) {
-                  elm.removeChild(elm.childNodes[0]);
-              }
-          }
-          if (key === 'value' && elm.tagName !== 'PROGRESS') {
-              // store value as _value as well since
-              // non-string values will be stringified
-              elm._value = cur;
-              // avoid resetting cursor position when value is the same
-              var strCur = isUndef(cur) ? '' : String(cur);
-              if (shouldUpdateValue(elm, strCur)) {
-                  elm.value = strCur;
-              }
-          }
-          else if (key === 'innerHTML' &&
-              isSVG(elm.tagName) &&
-              isUndef(elm.innerHTML)) {
-              // IE doesn't support innerHTML for SVG elements
-              svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-              var svg = svgContainer.firstChild;
-              while (elm.firstChild) {
-                  elm.removeChild(elm.firstChild);
-              }
-              while (svg.firstChild) {
-                  elm.appendChild(svg.firstChild);
-              }
-          }
-          else if (
-          // skip the update if old and new VDOM state is the same.
-          // `value` is handled separately because the DOM value may be temporarily
-          // out of sync with VDOM state due to focus, composition and modifiers.
-          // This  #4521 by skipping the unnecessary `checked` update.
-          cur !== oldProps[key]) {
-              // some property updates can throw
-              // e.g. `value` on <progress> w/ non-finite value
-              try {
-                  elm[key] = cur;
-              }
-              catch (e) { }
-          }
-      }
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+      return;
+    }
+    var key, cur;
+    var elm = vnode.elm;
+    var oldProps = oldVnode.data.domProps || {};
+    var props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+      props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+      if (!(key in props)) {
+        elm[key] = "";
+      }
+    }
+    for (key in props) {
+      cur = props[key];
+      // ignore children if the node has textContent or innerHTML,
+      // as these will throw away existing DOM nodes and cause removal errors
+      // on subsequent patches (#3360)
+      if (key === "textContent" || key === "innerHTML") {
+        if (vnode.children) {
+          vnode.children.length = 0;
+        }
+        if (cur === oldProps[key]) {
+          continue;
+        }
+        // #6601 work around Chrome version <= 55 bug where single textNode
+        // replaced by innerHTML/textContent retains its parentNode property
+        if (elm.childNodes.length === 1) {
+          elm.removeChild(elm.childNodes[0]);
+        }
+      }
+      if (key === "value" && elm.tagName !== "PROGRESS") {
+        // store value as _value as well since
+        // non-string values will be stringified
+        elm._value = cur;
+        // avoid resetting cursor position when value is the same
+        var strCur = isUndef(cur) ? "" : String(cur);
+        if (shouldUpdateValue(elm, strCur)) {
+          elm.value = strCur;
+        }
+      } else if (
+        key === "innerHTML" &&
+        isSVG(elm.tagName) &&
+        isUndef(elm.innerHTML)
+      ) {
+        // IE doesn't support innerHTML for SVG elements
+        svgContainer = svgContainer || document.createElement("div");
+        svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+        var svg = svgContainer.firstChild;
+        while (elm.firstChild) {
+          elm.removeChild(elm.firstChild);
+        }
+        while (svg.firstChild) {
+          elm.appendChild(svg.firstChild);
+        }
+      } else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]
+      ) {
+        // some property updates can throw
+        // e.g. `value` on <progress> w/ non-finite value
+        try {
+          elm[key] = cur;
+        } catch (e) {}
+      }
+    }
   }
   function shouldUpdateValue(elm, checkVal) {
-      return (
+    return (
       //@ts-expect-error
       !elm.composing &&
-          (elm.tagName === 'OPTION' ||
-              isNotInFocusAndDirty(elm, checkVal) ||
-              isDirtyWithModifiers(elm, checkVal)));
+      (elm.tagName === "OPTION" ||
+        isNotInFocusAndDirty(elm, checkVal) ||
+        isDirtyWithModifiers(elm, checkVal))
+    );
   }
   function isNotInFocusAndDirty(elm, checkVal) {
-      // return true when textbox (.number and .trim) loses focus and its value is
-      // not equal to the updated value
-      var notInFocus = true;
-      // #6157
-      // work around IE bug when accessing document.activeElement in an iframe
-      try {
-          notInFocus = document.activeElement !== elm;
-      }
-      catch (e) { }
-      return notInFocus && elm.value !== checkVal;
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    var notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+      notInFocus = document.activeElement !== elm;
+    } catch (e) {}
+    return notInFocus && elm.value !== checkVal;
   }
   function isDirtyWithModifiers(elm, newVal) {
-      var value = elm.value;
-      var modifiers = elm._vModifiers; // injected by v-model runtime
-      if (isDef(modifiers)) {
-          if (modifiers.number) {
-              return toNumber(value) !== toNumber(newVal);
-          }
-          if (modifiers.trim) {
-              return value.trim() !== newVal.trim();
-          }
+    var value = elm.value;
+    var modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+      if (modifiers.number) {
+        return toNumber(value) !== toNumber(newVal);
+      }
+      if (modifiers.trim) {
+        return value.trim() !== newVal.trim();
       }
-      return value !== newVal;
+    }
+    return value !== newVal;
   }
   var domProps = {
-      create: updateDOMProps,
-      update: updateDOMProps,
+    create: updateDOMProps,
+    update: updateDOMProps,
   };
 
   var parseStyleText = cached(function (cssText) {
-      var res = {};
-      var listDelimiter = /;(?![^(]*\))/g;
-      var propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              var tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
+    var res = {};
+    var listDelimiter = /;(?![^(]*\))/g;
+    var propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+      if (item) {
+        var tmp = item.split(propertyDelimiter);
+        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+      }
+    });
+    return res;
   });
   // merge static and dynamic style data on the same vnode
   function normalizeStyleData(data) {
-      var style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
+    var style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
   }
   // normalize possible array / string values into Object
   function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
+    if (Array.isArray(bindingStyle)) {
+      return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === "string") {
+      return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
   }
   /**
    * parent component style should be after child's
    * so that parent component's style could override it
    */
   function getStyle(vnode, checkChild) {
-      var res = {};
-      var styleData;
-      if (checkChild) {
-          var childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
+    var res = {};
+    var styleData;
+    if (checkChild) {
+      var childNode = vnode;
+      while (childNode.componentInstance) {
+        childNode = childNode.componentInstance._vnode;
+        if (
+          childNode &&
+          childNode.data &&
+          (styleData = normalizeStyleData(childNode.data))
+        ) {
           extend(res, styleData);
-      }
-      var parentNode = vnode;
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
+        }
+      }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+      extend(res, styleData);
+    }
+    var parentNode = vnode;
+    while ((parentNode = parentNode.parent)) {
+      if (
+        parentNode.data &&
+        (styleData = normalizeStyleData(parentNode.data))
+      ) {
+        extend(res, styleData);
+      }
+    }
+    return res;
   }
 
   var cssVarRE = /^--/;
   var importantRE = /\s*!important$/;
   var setProp = function (el, name, val) {
-      /* istanbul ignore if */
-      if (cssVarRE.test(name)) {
-          el.style.setProperty(name, val);
-      }
-      else if (importantRE.test(val)) {
-          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-      }
-      else {
-          var normalizedName = normalize(name);
-          if (Array.isArray(val)) {
-              // Support values array created by autoprefixer, e.g.
-              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-              // Set them one by one, and the browser will only set those it can recognize
-              for (var i = 0, len = val.length; i < len; i++) {
-                  el.style[normalizedName] = val[i];
-              }
-          }
-          else {
-              el.style[normalizedName] = val;
-          }
-      }
-  };
-  var vendorNames = ['Webkit', 'Moz', 'ms'];
-  var emptyStyle;
-  var normalize = cached(function (prop) {
-      emptyStyle = emptyStyle || document.createElement('div').style;
-      prop = camelize(prop);
-      if (prop !== 'filter' && prop in emptyStyle) {
-          return prop;
-      }
-      var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (var i = 0; i < vendorNames.length; i++) {
-          var name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
-          }
-      }
-  });
-  function updateStyle(oldVnode, vnode) {
-      var data = vnode.data;
-      var oldData = oldVnode.data;
-      if (isUndef(data.staticStyle) &&
-          isUndef(data.style) &&
-          isUndef(oldData.staticStyle) &&
-          isUndef(oldData.style)) {
-          return;
-      }
-      var cur, name;
-      var el = vnode.elm;
-      var oldStaticStyle = oldData.staticStyle;
-      var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      var oldStyle = oldStaticStyle || oldStyleBinding;
-      var style = normalizeStyleBinding(vnode.data.style) || {};
-      // store normalized style under a different key for next diff
-      // make sure to clone it if it's reactive, since the user likely wants
-      // to mutate it.
-      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      var newStyle = getStyle(vnode, true);
-      for (name in oldStyle) {
-          if (isUndef(newStyle[name])) {
-              setProp(el, name, '');
-          }
-      }
-      for (name in newStyle) {
-          cur = newStyle[name];
-          if (cur !== oldStyle[name]) {
-              // ie9 setting to null has no effect, must use empty string
-              setProp(el, name, cur == null ? '' : cur);
-          }
-      }
-  }
-  var style = {
-      create: updateStyle,
-      update: updateStyle,
-  };
-
-  var whitespaceRE$1 = /\s+/;
-  /**
-   * Add class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function addClass$1(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
-  }
-  /**
-   * Remove class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function removeClass$1(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          var tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
-  }
-
-  function resolveTransition$1(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          var res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition$1(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition$1(def);
-      }
-  }
-  var autoCssTransition$1 = cached(function (name) {
-      return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
-      };
-  });
-  var hasTransition$1 = inBrowser && !isIE9;
-  var TRANSITION$1 = 'transition';
-  var ANIMATION$1 = 'animation';
-  // Transition property/event sniffing
-  var transitionProp$1 = 'transition';
-  var transitionEndEvent$1 = 'transitionend';
-  var animationProp$1 = 'animation';
-  var animationEndEvent$1 = 'animationend';
-  if (hasTransition$1) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          // @ts-expect-error
-          window.onwebkittransitionend !== undefined) {
-          transitionProp$1 = 'WebkitTransition';
-          transitionEndEvent$1 = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          // @ts-expect-error
-          window.onwebkitanimationend !== undefined) {
-          animationProp$1 = 'WebkitAnimation';
-          animationEndEvent$1 = 'webkitAnimationEnd';
-      }
-  }
-  // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf$1 = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ function (fn) { return fn(); };
-  function nextFrame$1(fn) {
-      raf$1(function () {
-          // @ts-expect-error
-          raf$1(fn);
-      });
-  }
-  function addTransitionClass$1(el, cls) {
-      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass$1(el, cls);
-      }
-  }
-  function removeTransitionClass$1(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass$1(el, cls);
-  }
-  function whenTransitionEnds$1(el, expectedType, cb) {
-      var ref = getTransitionInfo$1(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
-      if (!type)
-          { return cb(); }
-      var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
-      var ended = 0;
-      var end = function () {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      var onEnd = function (e) {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(function () {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
-  }
-  var transformRE$1 = /\b(transform|all)(,|$)/;
-  function getTransitionInfo$1(el, expectedType) {
-      var styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout$1(animationDelays, animationDurations);
-      var type;
-      var timeout = 0;
-      var propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION$1) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION$1;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION$1) {
-          if (animationTimeout > 0) {
-              type = ANIMATION$1;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION$1
-                      : ANIMATION$1
-                  : null;
-          propCount = type
-              ? type === TRANSITION$1
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
-      return {
-          type: type,
-          timeout: timeout,
-          propCount: propCount,
-          hasTransform: hasTransform,
-      };
-  }
-  function getTimeout$1(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map(function (d, i) {
-          return toMs$1(d) + toMs$1(delays[i]);
-      }));
-  }
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs$1(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-  }
-
-  function enter$1(vnode, toggleDisplay) {
-      var el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      var data = resolveTransition$1(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      var context = activeInstance;
-      var transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      var isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      var startClass = isAppear && appearClass ? appearClass : enterClass;
-      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      var enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      var enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration$1(explicitEnterDuration, 'enter', vnode);
-      }
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength$1(enterHook);
-      var cb = (el._enterCb = once(function () {
-          if (expectsCSS) {
-              removeTransitionClass$1(el, toClass);
-              removeTransitionClass$1(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass$1(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', function () {
-              var parent = el.parentNode;
-              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
-      if (expectsCSS) {
-          addTransitionClass$1(el, startClass);
-          addTransitionClass$1(el, activeClass);
-          nextFrame$1(function () {
-              removeTransitionClass$1(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass$1(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration$1(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds$1(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
-      }
-  }
-  function leave$1(vnode, rm) {
-      var el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
-      }
-      var data = resolveTransition$1(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
-      }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
-      }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength$1(leave);
-      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration$1(explicitLeaveDuration, 'leave', vnode);
-      }
-      var cb = (el._leaveCb = once(function () {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass$1(el, leaveToClass);
-              removeTransitionClass$1(el, leaveActiveClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass$1(el, leaveClass);
-              }
-              leaveCancelled && leaveCancelled(el);
-          }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
-      }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass$1(el, leaveClass);
-              addTransitionClass$1(el, leaveActiveClass);
-              nextFrame$1(function () {
-                  removeTransitionClass$1(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass$1(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration$1(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds$1(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
-      }
-  }
-  // only used in dev mode
-  function checkDuration$1(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn("<transition> explicit " + name + " duration is NaN - " +
-              'the duration expression might be incorrect.', vnode.context);
-      }
-  }
-  function isValidDuration$1(val) {
-      return typeof val === 'number' && !isNaN(val);
-  }
-  /**
-   * Normalize a transition hook's argument length. The hook may be:
-   * - a merged hook (invoker) with the original in .fns
-   * - a wrapped component method (check ._length)
-   * - a plain function (.length)
-   */
-  function getHookArgumentsLength$1(fn) {
-      if (isUndef(fn)) {
-          return false;
-      }
-      // @ts-expect-error
-      var invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-      }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
-      }
-  }
-  function _enter(_, vnode) {
-      if (vnode.data.show !== true) {
-          enter$1(vnode);
-      }
-  }
-  var transition = inBrowser
-      ? {
-          create: _enter,
-          activate: _enter,
-          remove: function remove(vnode, rm) {
-              /* istanbul ignore else */
-              if (vnode.data.show !== true) {
-                  // @ts-expect-error
-                  leave$1(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          },
-      }
-      : {};
-
-  var platformModules = [attrs, klass, events, domProps, style, transition];
-
-  // the directive module should be applied last, after all
-  // built-in modules have been applied.
-  var modules = platformModules.concat(baseModules);
-  var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
-
-  /**
-   * Not type checking this file because flow doesn't like attaching
-   * properties to Elements.
-   */
-  /* istanbul ignore if */
-  if (isIE9) {
-      // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', function () {
-          var el = document.activeElement;
-          // @ts-expect-error
-          if (el && el.vmodel) {
-              trigger(el, 'input');
-          }
-      });
-  }
-  var directive = {
-      inserted: function inserted(el, binding, vnode, oldVnode) {
-          if (vnode.tag === 'select') {
-              // #6903
-              if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', function () {
-                      directive.componentUpdated(el, binding, vnode);
-                  });
-              }
-              else {
-                  setSelected(el, binding, vnode.context);
-              }
-              el._vOptions = [].map.call(el.options, getValue);
-          }
-          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-              el._vModifiers = binding.modifiers;
-              if (!binding.modifiers.lazy) {
-                  el.addEventListener('compositionstart', onCompositionStart);
-                  el.addEventListener('compositionend', onCompositionEnd);
-                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                  // switching focus before confirming composition choice
-                  // this also fixes the issue where some browsers e.g. iOS Chrome
-                  // fires "change" instead of "input" on autocomplete.
-                  el.addEventListener('change', onCompositionEnd);
-                  /* istanbul ignore if */
-                  if (isIE9) {
-                      el.vmodel = true;
-                  }
-              }
-          }
-      },
-      componentUpdated: function componentUpdated(el, binding, vnode) {
-          if (vnode.tag === 'select') {
-              setSelected(el, binding, vnode.context);
-              // in case the options rendered by v-for have changed,
-              // it's possible that the value is out-of-sync with the rendered options.
-              // detect such cases and filter out values that no longer has a matching
-              // option in the DOM.
-              var prevOptions = el._vOptions;
-              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
-                  // trigger change event if
-                  // no matching option found for at least one value
-                  var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
-                      : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
-                  if (needReset) {
-                      trigger(el, 'change');
-                  }
-              }
-          }
-      },
-  };
-  function setSelected(el, binding, vm) {
-      actuallySetSelected(el, binding, vm);
-      /* istanbul ignore if */
-      if (isIE || isEdge) {
-          setTimeout(function () {
-              actuallySetSelected(el, binding, vm);
-          }, 0);
-      }
-  }
-  function actuallySetSelected(el, binding, vm) {
-      var value = binding.value;
-      var isMultiple = el.multiple;
-      if (isMultiple && !Array.isArray(value)) {
-          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                  "expects an Array value for its binding, but got " + (Object.prototype.toString
-                      .call(value)
-                      .slice(8, -1)), vm);
-          return;
-      }
-      var selected, option;
-      for (var i = 0, l = el.options.length; i < l; i++) {
-          option = el.options[i];
-          if (isMultiple) {
-              selected = looseIndexOf(value, getValue(option)) > -1;
-              if (option.selected !== selected) {
-                  option.selected = selected;
-              }
-          }
-          else {
-              if (looseEqual(getValue(option), value)) {
-                  if (el.selectedIndex !== i) {
-                      el.selectedIndex = i;
-                  }
-                  return;
-              }
-          }
-      }
-      if (!isMultiple) {
-          el.selectedIndex = -1;
-      }
-  }
-  function hasNoMatchingOption(value, options) {
-      return options.every(function (o) { return !looseEqual(o, value); });
-  }
-  function getValue(option) {
-      return '_value' in option ? option._value : option.value;
-  }
-  function onCompositionStart(e) {
-      e.target.composing = true;
-  }
-  function onCompositionEnd(e) {
-      // prevent triggering an input event for no reason
-      if (!e.target.composing)
-          { return; }
-      e.target.composing = false;
-      trigger(e.target, 'input');
-  }
-  function trigger(el, type) {
-      var e = document.createEvent('HTMLEvents');
-      e.initEvent(type, true, true);
-      el.dispatchEvent(e);
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+      el.style.setProperty(name, val);
+    } else if (importantRE.test(val)) {
+      el.style.setProperty(
+        hyphenate(name),
+        val.replace(importantRE, ""),
+        "important"
+      );
+    } else {
+      var normalizedName = normalize(name);
+      if (Array.isArray(val)) {
+        // Support values array created by autoprefixer, e.g.
+        // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+        // Set them one by one, and the browser will only set those it can recognize
+        for (var i = 0, len = val.length; i < len; i++) {
+          el.style[normalizedName] = val[i];
+        }
+      } else {
+        el.style[normalizedName] = val;
+      }
+    }
+  };
+  var vendorNames = ["Webkit", "Moz", "ms"];
+  var emptyStyle;
+  var normalize = cached(function (prop) {
+    emptyStyle = emptyStyle || document.createElement("div").style;
+    prop = camelize(prop);
+    if (prop !== "filter" && prop in emptyStyle) {
+      return prop;
+    }
+    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (var i = 0; i < vendorNames.length; i++) {
+      var name = vendorNames[i] + capName;
+      if (name in emptyStyle) {
+        return name;
+      }
+    }
+  });
+  function updateStyle(oldVnode, vnode) {
+    var data = vnode.data;
+    var oldData = oldVnode.data;
+    if (
+      isUndef(data.staticStyle) &&
+      isUndef(data.style) &&
+      isUndef(oldData.staticStyle) &&
+      isUndef(oldData.style)
+    ) {
+      return;
+    }
+    var cur, name;
+    var el = vnode.elm;
+    var oldStaticStyle = oldData.staticStyle;
+    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    var oldStyle = oldStaticStyle || oldStyleBinding;
+    var style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__)
+      ? extend({}, style)
+      : style;
+    var newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+      if (isUndef(newStyle[name])) {
+        setProp(el, name, "");
+      }
+    }
+    for (name in newStyle) {
+      cur = newStyle[name];
+      if (cur !== oldStyle[name]) {
+        // ie9 setting to null has no effect, must use empty string
+        setProp(el, name, cur == null ? "" : cur);
+      }
+    }
   }
+  var style = {
+    create: updateStyle,
+    update: updateStyle,
+  };
 
   var whitespaceRE = /\s+/;
   /**
@@ -6991,464 +6958,493 @@
    * SVG elements in IE
    */
   function addClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+      return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+      if (cls.indexOf(" ") > -1) {
+        cls.split(whitespaceRE).forEach(function (c) {
+          return el.classList.add(c);
+        });
+      } else {
+        el.classList.add(cls);
+      }
+    } else {
+      var cur = " " + (el.getAttribute("class") || "") + " ";
+      if (cur.indexOf(" " + cls + " ") < 0) {
+        el.setAttribute("class", (cur + cls).trim());
+      }
+    }
   }
   /**
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
   function removeClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          var tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+      return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+      if (cls.indexOf(" ") > -1) {
+        cls.split(whitespaceRE).forEach(function (c) {
+          return el.classList.remove(c);
+        });
+      } else {
+        el.classList.remove(cls);
+      }
+      if (!el.classList.length) {
+        el.removeAttribute("class");
+      }
+    } else {
+      var cur = " " + (el.getAttribute("class") || "") + " ";
+      var tar = " " + cls + " ";
+      while (cur.indexOf(tar) >= 0) {
+        cur = cur.replace(tar, " ");
+      }
+      cur = cur.trim();
+      if (cur) {
+        el.setAttribute("class", cur);
+      } else {
+        el.removeAttribute("class");
+      }
+    }
   }
 
   function resolveTransition(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          var res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition(def);
+    if (!def) {
+      return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === "object") {
+      var res = {};
+      if (def.css !== false) {
+        extend(res, autoCssTransition(def.name || "v"));
       }
+      extend(res, def);
+      return res;
+    } else if (typeof def === "string") {
+      return autoCssTransition(def);
+    }
   }
   var autoCssTransition = cached(function (name) {
-      return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
-      };
+    return {
+      enterClass: name + "-enter",
+      enterToClass: name + "-enter-to",
+      enterActiveClass: name + "-enter-active",
+      leaveClass: name + "-leave",
+      leaveToClass: name + "-leave-to",
+      leaveActiveClass: name + "-leave-active",
+    };
   });
   var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = 'transition';
-  var ANIMATION = 'animation';
+  var TRANSITION = "transition";
+  var ANIMATION = "animation";
   // Transition property/event sniffing
-  var transitionProp = 'transition';
-  var transitionEndEvent = 'transitionend';
-  var animationProp = 'animation';
-  var animationEndEvent = 'animationend';
+  var transitionProp = "transition";
+  var transitionEndEvent = "transitionend";
+  var animationProp = "animation";
+  var animationEndEvent = "animationend";
   if (hasTransition) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          // @ts-expect-error
-          window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          // @ts-expect-error
-          window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
-      }
+    /* istanbul ignore if */
+    if (
+      window.ontransitionend === undefined &&
+      // @ts-expect-error
+      window.onwebkittransitionend !== undefined
+    ) {
+      transitionProp = "WebkitTransition";
+      transitionEndEvent = "webkitTransitionEnd";
+    }
+    if (
+      window.onanimationend === undefined &&
+      // @ts-expect-error
+      window.onwebkitanimationend !== undefined
+    ) {
+      animationProp = "WebkitAnimation";
+      animationEndEvent = "webkitAnimationEnd";
+    }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
   var raf = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ function (fn) { return fn(); };
+    ? window.requestAnimationFrame
+      ? window.requestAnimationFrame.bind(window)
+      : setTimeout
+    : /* istanbul ignore next */ function (fn) {
+        return fn();
+      };
   function nextFrame(fn) {
-      raf(function () {
-          // @ts-expect-error
-          raf(fn);
-      });
+    raf(function () {
+      // @ts-expect-error
+      raf(fn);
+    });
   }
   function addTransitionClass(el, cls) {
-      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass(el, cls);
-      }
+    var transitionClasses =
+      el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+      transitionClasses.push(cls);
+      addClass(el, cls);
+    }
   }
   function removeTransitionClass(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass(el, cls);
+    if (el._transitionClasses) {
+      remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var ref = getTransitionInfo(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
-      if (!type)
-          { return cb(); }
-      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      var ended = 0;
-      var end = function () {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      var onEnd = function (e) {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(function () {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
+    var ref = getTransitionInfo(el, expectedType);
+    var type = ref.type;
+    var timeout = ref.timeout;
+    var propCount = ref.propCount;
+    if (!type) {
+      return cb();
+    }
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    var ended = 0;
+    var end = function () {
+      el.removeEventListener(event, onEnd);
+      cb();
+    };
+    var onEnd = function (e) {
+      if (e.target === el) {
+        if (++ended >= propCount) {
+          end();
+        }
+      }
+    };
+    setTimeout(function () {
+      if (ended < propCount) {
+        end();
+      }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
   }
   var transformRE = /\b(transform|all)(,|$)/;
   function getTransitionInfo(el, expectedType) {
-      var styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout(animationDelays, animationDurations);
-      var type;
-      var timeout = 0;
-      var propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION) {
-          if (animationTimeout > 0) {
-              type = ANIMATION;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
-                  : null;
-          propCount = type
-              ? type === TRANSITION
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-      return {
-          type: type,
-          timeout: timeout,
-          propCount: propCount,
-          hasTransform: hasTransform,
-      };
+    var styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    var transitionDelays = (styles[transitionProp + "Delay"] || "").split(", ");
+    var transitionDurations = (styles[transitionProp + "Duration"] || "").split(
+      ", "
+    );
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + "Delay"] || "").split(", ");
+    var animationDurations = (styles[animationProp + "Duration"] || "").split(
+      ", "
+    );
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
+    var type;
+    var timeout = 0;
+    var propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+      if (transitionTimeout > 0) {
+        type = TRANSITION;
+        timeout = transitionTimeout;
+        propCount = transitionDurations.length;
+      }
+    } else if (expectedType === ANIMATION) {
+      if (animationTimeout > 0) {
+        type = ANIMATION;
+        timeout = animationTimeout;
+        propCount = animationDurations.length;
+      }
+    } else {
+      timeout = Math.max(transitionTimeout, animationTimeout);
+      type =
+        timeout > 0
+          ? transitionTimeout > animationTimeout
+            ? TRANSITION
+            : ANIMATION
+          : null;
+      propCount = type
+        ? type === TRANSITION
+          ? transitionDurations.length
+          : animationDurations.length
+        : 0;
+    }
+    var hasTransform =
+      type === TRANSITION &&
+      transformRE.test(styles[transitionProp + "Property"]);
+    return {
+      type: type,
+      timeout: timeout,
+      propCount: propCount,
+      hasTransform: hasTransform,
+    };
   }
   function getTimeout(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map(function (d, i) {
-          return toMs(d) + toMs(delays[i]);
-      }));
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+      delays = delays.concat(delays);
+    }
+    return Math.max.apply(
+      null,
+      durations.map(function (d, i) {
+        return toMs(d) + toMs(delays[i]);
+      })
+    );
   }
   // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
   // in a locale-dependent way, using a comma instead of a dot.
   // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
   // as a floor function) causing unexpected behaviors
   function toMs(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+    return Number(s.slice(0, -1).replace(",", ".")) * 1000;
   }
 
   function enter(vnode, toggleDisplay) {
-      var el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      var data = resolveTransition(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      var context = activeInstance;
-      var transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      var isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      var startClass = isAppear && appearClass ? appearClass : enterClass;
-      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      var enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      var enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
-      }
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(enterHook);
-      var cb = (el._enterCb = once(function () {
-          if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', function () {
-              var parent = el.parentNode;
-              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
+    var el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+      el._leaveCb.cancelled = true;
+      el._leaveCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+      return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+      return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var enterClass = data.enterClass;
+    var enterToClass = data.enterToClass;
+    var enterActiveClass = data.enterActiveClass;
+    var appearClass = data.appearClass;
+    var appearToClass = data.appearToClass;
+    var appearActiveClass = data.appearActiveClass;
+    var beforeEnter = data.beforeEnter;
+    var enter = data.enter;
+    var afterEnter = data.afterEnter;
+    var enterCancelled = data.enterCancelled;
+    var beforeAppear = data.beforeAppear;
+    var appear = data.appear;
+    var afterAppear = data.afterAppear;
+    var appearCancelled = data.appearCancelled;
+    var duration = data.duration;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    var context = activeInstance;
+    var transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+      context = transitionNode.context;
+      transitionNode = transitionNode.parent;
+    }
+    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== "") {
+      return;
+    }
+    var startClass = isAppear && appearClass ? appearClass : enterClass;
+    var activeClass =
+      isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    var enterHook = isAppear
+      ? typeof appear === "function"
+        ? appear
+        : enter
+      : enter;
+    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    var enterCancelledHook = isAppear
+      ? appearCancelled || enterCancelled
+      : enterCancelled;
+    var explicitEnterDuration = toNumber(
+      isObject(duration) ? duration.enter : duration
+    );
+    if (explicitEnterDuration != null) {
+      checkDuration(explicitEnterDuration, "enter", vnode);
+    }
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(enterHook);
+    var cb = (el._enterCb = once(function () {
       if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(function () {
-              removeTransitionClass(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
+        removeTransitionClass(el, toClass);
+        removeTransitionClass(el, activeClass);
       }
+      // @ts-expect-error
+      if (cb.cancelled) {
+        if (expectsCSS) {
+          removeTransitionClass(el, startClass);
+        }
+        enterCancelledHook && enterCancelledHook(el);
+      } else {
+        afterEnterHook && afterEnterHook(el);
+      }
+      el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+      // remove pending leave element on enter by injecting an insert hook
+      mergeVNodeHook(vnode, "insert", function () {
+        var parent = el.parentNode;
+        var pendingNode =
+          parent && parent._pending && parent._pending[vnode.key];
+        if (
+          pendingNode &&
+          pendingNode.tag === vnode.tag &&
+          pendingNode.elm._leaveCb
+        ) {
+          pendingNode.elm._leaveCb();
+        }
+        enterHook && enterHook(el, cb);
+      });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+      addTransitionClass(el, startClass);
+      addTransitionClass(el, activeClass);
+      nextFrame(function () {
+        removeTransitionClass(el, startClass);
+        // @ts-expect-error
+        if (!cb.cancelled) {
+          addTransitionClass(el, toClass);
+          if (!userWantsControl) {
+            if (isValidDuration(explicitEnterDuration)) {
+              setTimeout(cb, explicitEnterDuration);
+            } else {
+              whenTransitionEnds(el, type, cb);
+            }
+          }
+        }
+      });
+    }
+    if (vnode.data.show) {
+      toggleDisplay && toggleDisplay();
+      enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+      cb();
+    }
   }
   function leave(vnode, rm) {
-      var el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
+    var el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+      el._enterCb.cancelled = true;
+      el._enterCb();
+    }
+    var data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+      return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+      return;
+    }
+    var css = data.css;
+    var type = data.type;
+    var leaveClass = data.leaveClass;
+    var leaveToClass = data.leaveToClass;
+    var leaveActiveClass = data.leaveActiveClass;
+    var beforeLeave = data.beforeLeave;
+    var leave = data.leave;
+    var afterLeave = data.afterLeave;
+    var leaveCancelled = data.leaveCancelled;
+    var delayLeave = data.delayLeave;
+    var duration = data.duration;
+    var expectsCSS = css !== false && !isIE9;
+    var userWantsControl = getHookArgumentsLength(leave);
+    var explicitLeaveDuration = toNumber(
+      isObject(duration) ? duration.leave : duration
+    );
+    if (isDef(explicitLeaveDuration)) {
+      checkDuration(explicitLeaveDuration, "leave", vnode);
+    }
+    var cb = (el._leaveCb = once(function () {
+      if (el.parentNode && el.parentNode._pending) {
+        el.parentNode._pending[vnode.key] = null;
+      }
+      if (expectsCSS) {
+        removeTransitionClass(el, leaveToClass);
+        removeTransitionClass(el, leaveActiveClass);
       }
-      var data = resolveTransition(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
+      // @ts-expect-error
+      if (cb.cancelled) {
+        if (expectsCSS) {
+          removeTransitionClass(el, leaveClass);
+        }
+        leaveCancelled && leaveCancelled(el);
+      } else {
+        rm();
+        afterLeave && afterLeave(el);
+      }
+      el._leaveCb = null;
+    }));
+    if (delayLeave) {
+      delayLeave(performLeave);
+    } else {
+      performLeave();
+    }
+    function performLeave() {
+      // the delayed leave may have already been cancelled
+      // @ts-expect-error
+      if (cb.cancelled) {
+        return;
       }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
+      // record leaving element
+      if (!vnode.data.show && el.parentNode) {
+        (el.parentNode._pending || (el.parentNode._pending = {}))[
+          vnode.key
+        ] = vnode;
       }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(leave);
-      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
-      }
-      var cb = (el._leaveCb = once(function () {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
-          }
+      beforeLeave && beforeLeave(el);
+      if (expectsCSS) {
+        addTransitionClass(el, leaveClass);
+        addTransitionClass(el, leaveActiveClass);
+        nextFrame(function () {
+          removeTransitionClass(el, leaveClass);
           // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
+          if (!cb.cancelled) {
+            addTransitionClass(el, leaveToClass);
+            if (!userWantsControl) {
+              if (isValidDuration(explicitLeaveDuration)) {
+                setTimeout(cb, explicitLeaveDuration);
+              } else {
+                whenTransitionEnds(el, type, cb);
               }
-              leaveCancelled && leaveCancelled(el);
+            }
           }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
+        });
       }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(function () {
-                  removeTransitionClass(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
+      leave && leave(el, cb);
+      if (!expectsCSS && !userWantsControl) {
+        cb();
       }
+    }
   }
   // only used in dev mode
   function checkDuration(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn("<transition> explicit " + name + " duration is NaN - " +
-              'the duration expression might be incorrect.', vnode.context);
-      }
+    if (typeof val !== "number") {
+      warn(
+        "<transition> explicit " +
+          name +
+          " duration is not a valid number - " +
+          "got " +
+          JSON.stringify(val) +
+          ".",
+        vnode.context
+      );
+    } else if (isNaN(val)) {
+      warn(
+        "<transition> explicit " +
+          name +
+          " duration is NaN - " +
+          "the duration expression might be incorrect.",
+        vnode.context
+      );
+    }
   }
   function isValidDuration(val) {
-      return typeof val === 'number' && !isNaN(val);
+    return typeof val === "number" && !isNaN(val);
   }
   /**
    * Normalize a transition hook's argument length. The hook may be:
@@ -7457,426 +7453,611 @@
    * - a plain function (.length)
    */
   function getHookArgumentsLength(fn) {
-      if (isUndef(fn)) {
-          return false;
+    if (isUndef(fn)) {
+      return false;
+    }
+    // @ts-expect-error
+    var invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+      // invoker
+      return getHookArgumentsLength(
+        Array.isArray(invokerFns) ? invokerFns[0] : invokerFns
+      );
+    } else {
+      // @ts-expect-error
+      return (fn._length || fn.length) > 1;
+    }
+  }
+  function _enter(_, vnode) {
+    if (vnode.data.show !== true) {
+      enter(vnode);
+    }
+  }
+  var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove: function remove(vnode, rm) {
+          /* istanbul ignore else */
+          if (vnode.data.show !== true) {
+            // @ts-expect-error
+            leave(vnode, rm);
+          } else {
+            rm();
+          }
+        },
       }
+    : {};
+
+  var platformModules = [attrs, klass, events, domProps, style, transition];
+
+  // the directive module should be applied last, after all
+  // built-in modules have been applied.
+  var modules = platformModules.concat(baseModules);
+  var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+
+  /**
+   * Not type checking this file because flow doesn't like attaching
+   * properties to Elements.
+   */
+  /* istanbul ignore if */
+  if (isIE9) {
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener("selectionchange", function () {
+      var el = document.activeElement;
       // @ts-expect-error
-      var invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      if (el && el.vmodel) {
+        trigger(el, "input");
       }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
+    });
+  }
+  var directive = {
+    inserted: function inserted(el, binding, vnode, oldVnode) {
+      if (vnode.tag === "select") {
+        // #6903
+        if (oldVnode.elm && !oldVnode.elm._vOptions) {
+          mergeVNodeHook(vnode, "postpatch", function () {
+            directive.componentUpdated(el, binding, vnode);
+          });
+        } else {
+          setSelected(el, binding, vnode.context);
+        }
+        el._vOptions = [].map.call(el.options, getValue);
+      } else if (vnode.tag === "textarea" || isTextInputType(el.type)) {
+        el._vModifiers = binding.modifiers;
+        if (!binding.modifiers.lazy) {
+          el.addEventListener("compositionstart", onCompositionStart);
+          el.addEventListener("compositionend", onCompositionEnd);
+          // Safari < 10.2 & UIWebView doesn't fire compositionend when
+          // switching focus before confirming composition choice
+          // this also fixes the issue where some browsers e.g. iOS Chrome
+          // fires "change" instead of "input" on autocomplete.
+          el.addEventListener("change", onCompositionEnd);
+          /* istanbul ignore if */
+          if (isIE9) {
+            el.vmodel = true;
+          }
+        }
+      }
+    },
+    componentUpdated: function componentUpdated(el, binding, vnode) {
+      if (vnode.tag === "select") {
+        setSelected(el, binding, vnode.context);
+        // in case the options rendered by v-for have changed,
+        // it's possible that the value is out-of-sync with the rendered options.
+        // detect such cases and filter out values that no longer has a matching
+        // option in the DOM.
+        var prevOptions = el._vOptions;
+        var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+        if (
+          curOptions.some(function (o, i) {
+            return !looseEqual(o, prevOptions[i]);
+          })
+        ) {
+          // trigger change event if
+          // no matching option found for at least one value
+          var needReset = el.multiple
+            ? binding.value.some(function (v) {
+                return hasNoMatchingOption(v, curOptions);
+              })
+            : binding.value !== binding.oldValue &&
+              hasNoMatchingOption(binding.value, curOptions);
+          if (needReset) {
+            trigger(el, "change");
+          }
+        }
+      }
+    },
+  };
+  function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+      setTimeout(function () {
+        actuallySetSelected(el, binding, vm);
+      }, 0);
+    }
+  }
+  function actuallySetSelected(el, binding, vm) {
+    var value = binding.value;
+    var isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+      warn(
+        '<select multiple v-model="' +
+          binding.expression +
+          '"> ' +
+          "expects an Array value for its binding, but got " +
+          Object.prototype.toString.call(value).slice(8, -1),
+        vm
+      );
+      return;
+    }
+    var selected, option;
+    for (var i = 0, l = el.options.length; i < l; i++) {
+      option = el.options[i];
+      if (isMultiple) {
+        selected = looseIndexOf(value, getValue(option)) > -1;
+        if (option.selected !== selected) {
+          option.selected = selected;
+        }
+      } else {
+        if (looseEqual(getValue(option), value)) {
+          if (el.selectedIndex !== i) {
+            el.selectedIndex = i;
+          }
+          return;
+        }
       }
+    }
+    if (!isMultiple) {
+      el.selectedIndex = -1;
+    }
+  }
+  function hasNoMatchingOption(value, options) {
+    return options.every(function (o) {
+      return !looseEqual(o, value);
+    });
+  }
+  function getValue(option) {
+    return "_value" in option ? option._value : option.value;
+  }
+  function onCompositionStart(e) {
+    e.target.composing = true;
+  }
+  function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing) {
+      return;
+    }
+    e.target.composing = false;
+    trigger(e.target, "input");
+  }
+  function trigger(el, type) {
+    var e = document.createEvent("HTMLEvents");
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
   }
 
   // recursively search for possible transition defined inside the component root
   function locateNode(vnode) {
-      // @ts-expect-error
-      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-          ? locateNode(vnode.componentInstance._vnode)
-          : vnode;
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+      ? locateNode(vnode.componentInstance._vnode)
+      : vnode;
   }
   var show = {
-      bind: function bind(el, ref, vnode) {
-          var value = ref.value;
+    bind: function bind(el, ref, vnode) {
+      var value = ref.value;
 
-          vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
-          var originalDisplay = (el.__vOriginalDisplay =
-              el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition) {
-              vnode.data.show = true;
-              enter(vnode, function () {
-                  el.style.display = originalDisplay;
-              });
-          }
-          else {
-              el.style.display = value ? originalDisplay : 'none';
-          }
-      },
-      update: function update(el, ref, vnode) {
-          var value = ref.value;
-          var oldValue = ref.oldValue;
+      vnode = locateNode(vnode);
+      var transition = vnode.data && vnode.data.transition;
+      var originalDisplay = (el.__vOriginalDisplay =
+        el.style.display === "none" ? "" : el.style.display);
+      if (value && transition) {
+        vnode.data.show = true;
+        enter(vnode, function () {
+          el.style.display = originalDisplay;
+        });
+      } else {
+        el.style.display = value ? originalDisplay : "none";
+      }
+    },
+    update: function update(el, ref, vnode) {
+      var value = ref.value;
+      var oldValue = ref.oldValue;
 
-          /* istanbul ignore if */
-          if (!value === !oldValue)
-              { return; }
-          vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
-          if (transition) {
-              vnode.data.show = true;
-              if (value) {
-                  enter(vnode, function () {
-                      el.style.display = el.__vOriginalDisplay;
-                  });
-              }
-              else {
-                  leave(vnode, function () {
-                      el.style.display = 'none';
-                  });
-              }
-          }
-          else {
-              el.style.display = value ? el.__vOriginalDisplay : 'none';
-          }
-      },
-      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
-          if (!isDestroy) {
-              el.style.display = el.__vOriginalDisplay;
-          }
-      },
+      /* istanbul ignore if */
+      if (!value === !oldValue) {
+        return;
+      }
+      vnode = locateNode(vnode);
+      var transition = vnode.data && vnode.data.transition;
+      if (transition) {
+        vnode.data.show = true;
+        if (value) {
+          enter(vnode, function () {
+            el.style.display = el.__vOriginalDisplay;
+          });
+        } else {
+          leave(vnode, function () {
+            el.style.display = "none";
+          });
+        }
+      } else {
+        el.style.display = value ? el.__vOriginalDisplay : "none";
+      }
+    },
+    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+      if (!isDestroy) {
+        el.style.display = el.__vOriginalDisplay;
+      }
+    },
   };
 
   var platformDirectives = {
-      model: directive,
-      show: show,
+    model: directive,
+    show: show,
   };
 
   // Provides transition support for a single element/component.
   var transitionProps = {
-      name: String,
-      appear: Boolean,
-      css: Boolean,
-      mode: String,
-      type: String,
-      enterClass: String,
-      leaveClass: String,
-      enterToClass: String,
-      leaveToClass: String,
-      enterActiveClass: String,
-      leaveActiveClass: String,
-      appearClass: String,
-      appearActiveClass: String,
-      appearToClass: String,
-      duration: [Number, String, Object],
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
   };
   // in case the child is also an abstract component, e.g. <keep-alive>
   // we want to recursively retrieve the real component to be rendered
   function getRealChild(vnode) {
-      var compOptions = vnode && vnode.componentOptions;
-      if (compOptions && compOptions.Ctor.options.abstract) {
-          return getRealChild(getFirstComponentChild(compOptions.children));
-      }
-      else {
-          return vnode;
-      }
+    var compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+      return getRealChild(getFirstComponentChild(compOptions.children));
+    } else {
+      return vnode;
+    }
   }
   function extractTransitionData(comp) {
-      var data = {};
-      var options = comp.$options;
-      // props
-      for (var key in options.propsData) {
-          data[key] = comp[key];
-      }
-      // events.
-      // extract listeners and pass them directly to the transition methods
-      var listeners = options._parentListeners;
-      for (var key$1 in listeners) {
-          data[camelize(key$1)] = listeners[key$1];
-      }
-      return data;
+    var data = {};
+    var options = comp.$options;
+    // props
+    for (var key in options.propsData) {
+      data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    var listeners = options._parentListeners;
+    for (var key$1 in listeners) {
+      data[camelize(key$1)] = listeners[key$1];
+    }
+    return data;
   }
   function placeholder(h, rawChild) {
-      // @ts-expect-error
-      if (/\d-keep-alive$/.test(rawChild.tag)) {
-          return h('keep-alive', {
-              props: rawChild.componentOptions.propsData,
-          });
-      }
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+      return h("keep-alive", {
+        props: rawChild.componentOptions.propsData,
+      });
+    }
   }
   function hasParentTransition(vnode) {
-      while ((vnode = vnode.parent)) {
-          if (vnode.data.transition) {
-              return true;
-          }
+    while ((vnode = vnode.parent)) {
+      if (vnode.data.transition) {
+        return true;
       }
+    }
   }
   function isSameChild(child, oldChild) {
-      return oldChild.key === child.key && oldChild.tag === child.tag;
+    return oldChild.key === child.key && oldChild.tag === child.tag;
   }
-  var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-  var isVShowDirective = function (d) { return d.name === 'show'; };
+  var isNotTextNode = function (c) {
+    return c.tag || isAsyncPlaceholder(c);
+  };
+  var isVShowDirective = function (d) {
+    return d.name === "show";
+  };
   var Transition = {
-      name: 'transition',
-      props: transitionProps,
-      abstract: true,
-      render: function render(h) {
-          var this$1 = this;
+    name: "transition",
+    props: transitionProps,
+    abstract: true,
+    render: function render(h) {
+      var this$1 = this;
 
-          var children = this.$slots.default;
-          if (!children) {
-              return;
-          }
-          // filter out text nodes (possible whitespaces)
-          children = children.filter(isNotTextNode);
-          /* istanbul ignore if */
-          if (!children.length) {
-              return;
-          }
-          // warn multiple elements
-          if (children.length > 1) {
-              warn('<transition> can only be used on a single element. Use ' +
-                  '<transition-group> for lists.', this.$parent);
-          }
-          var mode = this.mode;
-          // warn invalid mode
-          if (mode &&
-              mode !== 'in-out' &&
-              mode !== 'out-in') {
-              warn('invalid <transition> mode: ' + mode, this.$parent);
-          }
-          var rawChild = children[0];
-          // if this is a component root node and the component's
-          // parent container node also has transition, skip.
-          if (hasParentTransition(this.$vnode)) {
-              return rawChild;
-          }
-          // apply transition data to child
-          // use getRealChild() to ignore abstract components e.g. keep-alive
-          var child = getRealChild(rawChild);
-          /* istanbul ignore if */
-          if (!child) {
-              return rawChild;
-          }
-          if (this._leaving) {
-              return placeholder(h, rawChild);
-          }
-          // ensure a key that is unique to the vnode type and to this transition
-          // component instance. This key will be used to remove pending leaving nodes
-          // during entering.
-          var id = "__transition-" + (this._uid) + "-";
-          child.key =
-              child.key == null
-                  ? child.isComment
-                      ? id + 'comment'
-                      : id + child.tag
-                  : isPrimitive(child.key)
-                      ? String(child.key).indexOf(id) === 0
-                          ? child.key
-                          : id + child.key
-                      : child.key;
-          var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          var oldRawChild = this._vnode;
-          var oldChild = getRealChild(oldRawChild);
-          // mark v-show
-          // so that the transition module can hand over the control to the directive
-          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-              child.data.show = true;
-          }
-          if (oldChild &&
-              oldChild.data &&
-              !isSameChild(child, oldChild) &&
-              !isAsyncPlaceholder(oldChild) &&
-              // #6687 component root is a comment node
-              !(oldChild.componentInstance &&
-                  oldChild.componentInstance._vnode.isComment)) {
-              // replace old child transition data with fresh one
-              // important for dynamic transitions!
-              var oldData = (oldChild.data.transition = extend({}, data));
-              // handle transition mode
-              if (mode === 'out-in') {
-                  // return placeholder node and queue update when leave finishes
-                  this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', function () {
-                      this$1._leaving = false;
-                      this$1.$forceUpdate();
-                  });
-                  return placeholder(h, rawChild);
-              }
-              else if (mode === 'in-out') {
-                  if (isAsyncPlaceholder(child)) {
-                      return oldRawChild;
-                  }
-                  var delayedLeave;
-                  var performLeave = function () {
-                      delayedLeave();
-                  };
-                  mergeVNodeHook(data, 'afterEnter', performLeave);
-                  mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                      delayedLeave = leave;
-                  });
-              }
-          }
-          return rawChild;
-      },
+      var children = this.$slots.default;
+      if (!children) {
+        return;
+      }
+      // filter out text nodes (possible whitespaces)
+      children = children.filter(isNotTextNode);
+      /* istanbul ignore if */
+      if (!children.length) {
+        return;
+      }
+      // warn multiple elements
+      if (children.length > 1) {
+        warn(
+          "<transition> can only be used on a single element. Use " +
+            "<transition-group> for lists.",
+          this.$parent
+        );
+      }
+      var mode = this.mode;
+      // warn invalid mode
+      if (mode && mode !== "in-out" && mode !== "out-in") {
+        warn("invalid <transition> mode: " + mode, this.$parent);
+      }
+      var rawChild = children[0];
+      // if this is a component root node and the component's
+      // parent container node also has transition, skip.
+      if (hasParentTransition(this.$vnode)) {
+        return rawChild;
+      }
+      // apply transition data to child
+      // use getRealChild() to ignore abstract components e.g. keep-alive
+      var child = getRealChild(rawChild);
+      /* istanbul ignore if */
+      if (!child) {
+        return rawChild;
+      }
+      if (this._leaving) {
+        return placeholder(h, rawChild);
+      }
+      // ensure a key that is unique to the vnode type and to this transition
+      // component instance. This key will be used to remove pending leaving nodes
+      // during entering.
+      var id = "__transition-" + this._uid + "-";
+      child.key =
+        child.key == null
+          ? child.isComment
+            ? id + "comment"
+            : id + child.tag
+          : isPrimitive(child.key)
+          ? String(child.key).indexOf(id) === 0
+            ? child.key
+            : id + child.key
+          : child.key;
+      var data = ((
+        child.data || (child.data = {})
+      ).transition = extractTransitionData(this));
+      var oldRawChild = this._vnode;
+      var oldChild = getRealChild(oldRawChild);
+      // mark v-show
+      // so that the transition module can hand over the control to the directive
+      if (
+        child.data.directives &&
+        child.data.directives.some(isVShowDirective)
+      ) {
+        child.data.show = true;
+      }
+      if (
+        oldChild &&
+        oldChild.data &&
+        !isSameChild(child, oldChild) &&
+        !isAsyncPlaceholder(oldChild) &&
+        // #6687 component root is a comment node
+        !(
+          oldChild.componentInstance &&
+          oldChild.componentInstance._vnode.isComment
+        )
+      ) {
+        // replace old child transition data with fresh one
+        // important for dynamic transitions!
+        var oldData = (oldChild.data.transition = extend({}, data));
+        // handle transition mode
+        if (mode === "out-in") {
+          // return placeholder node and queue update when leave finishes
+          this._leaving = true;
+          mergeVNodeHook(oldData, "afterLeave", function () {
+            this$1._leaving = false;
+            this$1.$forceUpdate();
+          });
+          return placeholder(h, rawChild);
+        } else if (mode === "in-out") {
+          if (isAsyncPlaceholder(child)) {
+            return oldRawChild;
+          }
+          var delayedLeave;
+          var performLeave = function () {
+            delayedLeave();
+          };
+          mergeVNodeHook(data, "afterEnter", performLeave);
+          mergeVNodeHook(data, "enterCancelled", performLeave);
+          mergeVNodeHook(oldData, "delayLeave", function (leave) {
+            delayedLeave = leave;
+          });
+        }
+      }
+      return rawChild;
+    },
   };
 
   // Provides transition support for list items.
-  var props = extend({
+  var props = extend(
+    {
       tag: String,
       moveClass: String,
-  }, transitionProps);
+    },
+    transitionProps
+  );
   // @ts-ignore
   delete props.mode;
   var TransitionGroup = {
-      props: props,
-      beforeMount: function beforeMount() {
-          var this$1 = this;
+    props: props,
+    beforeMount: function beforeMount() {
+      var this$1 = this;
 
-          var update = this._update;
-          this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(this$1);
-              // force removing pass
-              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
-              true // removeOnly (!important, avoids unnecessary moves)
-              );
-              this$1._vnode = this$1.kept;
-              restoreActiveInstance();
-              update.call(this$1, vnode, hydrating);
-          };
-      },
-      render: function render(h) {
-          var tag = this.tag || this.$vnode.data.tag || 'span';
-          var map = Object.create(null);
-          var prevChildren = (this.prevChildren = this.children);
-          var rawChildren = this.$slots.default || [];
-          var children = (this.children = []);
-          var transitionData = extractTransitionData(this);
-          for (var i = 0; i < rawChildren.length; i++) {
-              var c = rawChildren[i];
-              if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-                      children.push(c);
-                      map[c.key] = c;
-                      (c.data || (c.data = {})).transition = transitionData;
-                  }
-                  else {
-                      var opts = c.componentOptions;
-                      var name = opts
-                          ? opts.Ctor.options.name || opts.tag || ''
-                          : c.tag;
-                      warn(("<transition-group> children must be keyed: <" + name + ">"));
-                  }
-              }
-          }
-          if (prevChildren) {
-              var kept = [];
-              var removed = [];
-              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                  var c$1 = prevChildren[i$1];
-                  c$1.data.transition = transitionData;
-                  // @ts-ignore
-                  c$1.data.pos = c$1.elm.getBoundingClientRect();
-                  // @ts-ignore
-                  if (map[c$1.key]) {
-                      kept.push(c$1);
-                  }
-                  else {
-                      removed.push(c$1);
-                  }
-              }
-              this.kept = h(tag, null, kept);
-              this.removed = removed;
-          }
-          return h(tag, null, children);
-      },
-      updated: function updated() {
-          var children = this.prevChildren;
-          var moveClass = this.moveClass || (this.name || 'v') + '-move';
-          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-              return;
-          }
-          // we divide the work into three loops to avoid mixing DOM reads and writes
-          // in each iteration - which helps prevent layout thrashing.
-          children.forEach(callPendingCbs);
-          children.forEach(recordPosition);
-          children.forEach(applyTranslation);
-          // force reflow to put everything in position
-          // assign to this to avoid being removed in tree-shaking
-          // $flow-disable-line
-          this._reflow = document.body.offsetHeight;
-          children.forEach(function (c) {
-              // @ts-ignore
-              if (c.data.moved) {
-                  var el = c.elm;
-                  var s = el.style;
-                  addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = '';
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
-                          return;
-                      }
-                      if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
-                      }
-                  }));
-              }
+      var update = this._update;
+      this._update = function (vnode, hydrating) {
+        var restoreActiveInstance = setActiveInstance(this$1);
+        // force removing pass
+        this$1.__patch__(
+          this$1._vnode,
+          this$1.kept,
+          false, // hydrating
+          true // removeOnly (!important, avoids unnecessary moves)
+        );
+        this$1._vnode = this$1.kept;
+        restoreActiveInstance();
+        update.call(this$1, vnode, hydrating);
+      };
+    },
+    render: function render(h) {
+      var tag = this.tag || this.$vnode.data.tag || "span";
+      var map = Object.create(null);
+      var prevChildren = (this.prevChildren = this.children);
+      var rawChildren = this.$slots.default || [];
+      var children = (this.children = []);
+      var transitionData = extractTransitionData(this);
+      for (var i = 0; i < rawChildren.length; i++) {
+        var c = rawChildren[i];
+        if (c.tag) {
+          if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+            children.push(c);
+            map[c.key] = c;
+            (c.data || (c.data = {})).transition = transitionData;
+          } else {
+            var opts = c.componentOptions;
+            var name = opts ? opts.Ctor.options.name || opts.tag || "" : c.tag;
+            warn("<transition-group> children must be keyed: <" + name + ">");
+          }
+        }
+      }
+      if (prevChildren) {
+        var kept = [];
+        var removed = [];
+        for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+          var c$1 = prevChildren[i$1];
+          c$1.data.transition = transitionData;
+          // @ts-ignore
+          c$1.data.pos = c$1.elm.getBoundingClientRect();
+          // @ts-ignore
+          if (map[c$1.key]) {
+            kept.push(c$1);
+          } else {
+            removed.push(c$1);
+          }
+        }
+        this.kept = h(tag, null, kept);
+        this.removed = removed;
+      }
+      return h(tag, null, children);
+    },
+    updated: function updated() {
+      var children = this.prevChildren;
+      var moveClass = this.moveClass || (this.name || "v") + "-move";
+      if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+        return;
+      }
+      // we divide the work into three loops to avoid mixing DOM reads and writes
+      // in each iteration - which helps prevent layout thrashing.
+      children.forEach(callPendingCbs);
+      children.forEach(recordPosition);
+      children.forEach(applyTranslation);
+      // force reflow to put everything in position
+      // assign to this to avoid being removed in tree-shaking
+      // $flow-disable-line
+      this._reflow = document.body.offsetHeight;
+      children.forEach(function (c) {
+        // @ts-ignore
+        if (c.data.moved) {
+          var el = c.elm;
+          var s = el.style;
+          addTransitionClass(el, moveClass);
+          s.transform = s.WebkitTransform = s.transitionDuration = "";
+          el.addEventListener(
+            transitionEndEvent,
+            (el._moveCb = function cb(e) {
+              if (e && e.target !== el) {
+                return;
+              }
+              if (!e || /transform$/.test(e.propertyName)) {
+                el.removeEventListener(transitionEndEvent, cb);
+                el._moveCb = null;
+                removeTransitionClass(el, moveClass);
+              }
+            })
+          );
+        }
+      });
+    },
+    methods: {
+      hasMove: function hasMove(el, moveClass) {
+        /* istanbul ignore if */
+        if (!hasTransition) {
+          return false;
+        }
+        /* istanbul ignore if */
+        if (this._hasMove) {
+          return this._hasMove;
+        }
+        // Detect whether an element with the move class applied has
+        // CSS transitions. Since the element may be inside an entering
+        // transition at this very moment, we make a clone of it and remove
+        // all other transition classes applied to ensure only the move class
+        // is applied.
+        var clone = el.cloneNode();
+        if (el._transitionClasses) {
+          el._transitionClasses.forEach(function (cls) {
+            removeClass(clone, cls);
           });
+        }
+        addClass(clone, moveClass);
+        clone.style.display = "none";
+        this.$el.appendChild(clone);
+        var info = getTransitionInfo(clone);
+        this.$el.removeChild(clone);
+        return (this._hasMove = info.hasTransform);
       },
-      methods: {
-          hasMove: function hasMove(el, moveClass) {
-              /* istanbul ignore if */
-              if (!hasTransition) {
-                  return false;
-              }
-              /* istanbul ignore if */
-              if (this._hasMove) {
-                  return this._hasMove;
-              }
-              // Detect whether an element with the move class applied has
-              // CSS transitions. Since the element may be inside an entering
-              // transition at this very moment, we make a clone of it and remove
-              // all other transition classes applied to ensure only the move class
-              // is applied.
-              var clone = el.cloneNode();
-              if (el._transitionClasses) {
-                  el._transitionClasses.forEach(function (cls) {
-                      removeClass(clone, cls);
-                  });
-              }
-              addClass(clone, moveClass);
-              clone.style.display = 'none';
-              this.$el.appendChild(clone);
-              var info = getTransitionInfo(clone);
-              this.$el.removeChild(clone);
-              return (this._hasMove = info.hasTransform);
-          },
-      },
+    },
   };
   function callPendingCbs(c) {
-      /* istanbul ignore if */
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._moveCb) {
       //@ts-ignore
-      if (c.elm._moveCb) {
-          //@ts-ignore
-          c.elm._moveCb();
-      }
-      /* istanbul ignore if */
+      c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    //@ts-ignore
+    if (c.elm._enterCb) {
       //@ts-ignore
-      if (c.elm._enterCb) {
-          //@ts-ignore
-          c.elm._enterCb();
-      }
+      c.elm._enterCb();
+    }
   }
   function recordPosition(c) {
-      //@ts-ignore
-      c.data.newPos = c.elm.getBoundingClientRect();
+    //@ts-ignore
+    c.data.newPos = c.elm.getBoundingClientRect();
   }
   function applyTranslation(c) {
+    //@ts-ignore
+    var oldPos = c.data.pos;
+    //@ts-ignore
+    var newPos = c.data.newPos;
+    var dx = oldPos.left - newPos.left;
+    var dy = oldPos.top - newPos.top;
+    if (dx || dy) {
       //@ts-ignore
-      var oldPos = c.data.pos;
+      c.data.moved = true;
       //@ts-ignore
-      var newPos = c.data.newPos;
-      var dx = oldPos.left - newPos.left;
-      var dy = oldPos.top - newPos.top;
-      if (dx || dy) {
-          //@ts-ignore
-          c.data.moved = true;
-          //@ts-ignore
-          var s = c.elm.style;
-          s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-          s.transitionDuration = '0s';
-      }
+      var s = c.elm.style;
+      s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+      s.transitionDuration = "0s";
+    }
   }
 
   var platformComponents = {
-      Transition: Transition,
-      TransitionGroup: TransitionGroup,
+    Transition: Transition,
+    TransitionGroup: TransitionGroup,
   };
 
   // install platform specific utils
@@ -7892,33 +8073,34 @@
   Vue.prototype.__patch__ = inBrowser ? patch : noop;
   // public mount method
   Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query(el) : undefined;
-      return mountComponent(this, el, hydrating);
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
   };
   // devtools global hook
   /* istanbul ignore next */
   if (inBrowser) {
-      setTimeout(function () {
-          if (config.devtools) {
-              if (devtools) {
-                  devtools.emit('init', Vue);
-              }
-              else {
-                  // @ts-expect-error
-                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                      'https://github.com/vuejs/vue-devtools');
-              }
-          }
-          if (config.productionTip !== false &&
-              typeof console !== 'undefined') {
-              // @ts-expect-error
-              console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                  "Make sure to turn on production mode when deploying for production.\n" +
-                  "See more tips at https://vuejs.org/guide/deployment.html");
-          }
-      }, 0);
+    setTimeout(function () {
+      if (config.devtools) {
+        if (devtools) {
+          devtools.emit("init", Vue);
+        } else {
+          // @ts-expect-error
+          console[console.info ? "info" : "log"](
+            "Download the Vue Devtools extension for a better development experience:\n" +
+              "https://github.com/vuejs/vue-devtools"
+          );
+        }
+      }
+      if (config.productionTip !== false && typeof console !== "undefined") {
+        // @ts-expect-error
+        console[console.info ? "info" : "log"](
+          "You are running Vue in development mode.\n" +
+            "Make sure to turn on production mode when deploying for production.\n" +
+            "See more tips at https://vuejs.org/guide/deployment.html"
+        );
+      }
+    }, 0);
   }
 
   return Vue;
-
-})));
+});
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
index 95374026c19..45d9b60378e 100644
--- a/dist/vue.runtime.min.js
+++ b/dist/vue.runtime.min.js
@@ -8,4 +8,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,w=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every((function(t,n){return E(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return E(t[n],e[n])}))}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:L};function M(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function F(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var R=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var U="__proto__"in{},V="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),z=V&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0;z&&z.indexOf("android");var X=z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===H;z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z);var G,Z=z&&z.match(/firefox\/(\d+)/),J={}.watch,Q=!1;if(V)try{var Y={};Object.defineProperty(Y,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,Y)}catch(t){}var tt=function(){return void 0===G&&(G=!V&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},et=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}var rt,ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);rt="undefined"!=typeof Set&&nt(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var it=O,at=0,st=function(){this.id=at++,this.subs=[]};st.prototype.addSub=function(t){this.subs.push(t)},st.prototype.removeSub=function(t){v(this.subs,t)},st.prototype.depend=function(){st.target&&st.target.addDep(this)},st.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},st.target=null;var ct=[];function ut(t){ct.push(t),st.target=t}function lt(){ct.pop(),st.target=ct[ct.length-1]}var ft=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},dt={child:{configurable:!0}};dt.child.get=function(){return this.componentInstance},Object.defineProperties(ft.prototype,dt);var pt=function(t){void 0===t&&(t="");var e=new ft;return e.text=t,e.isComment=!0,e};function vt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){var e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=mt[t];F(yt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i}))}));var gt=Object.getOwnPropertyNames(yt),_t=!0;function bt(t){_t=t}var Ct=function(t){this.value=t,this.dep=new st,this.vmCount=0,F(t,"__ob__",this),Array.isArray(t)?(U?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];F(t,i,e[i])}}(t,yt,gt),this.observeArray(t)):this.walk(t)};function wt(t,e){var n;if(i(t)&&!(t instanceof ft))return m(t,"__ob__")&&t.__ob__ instanceof Ct?n=t.__ob__:_t&&!tt()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new Ct(t)),e&&n&&n.vmCount++,n}function At(t,e,n,r,o){var i=new st,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&wt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return st.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&wt(e),i.notify())}})}}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(At(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function kt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}Ct.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)At(t,e[n])},Ct.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)wt(t[e])};var Ot=P.optionMergeStrategies;function St(t,e){if(!e)return t;for(var n,r,o,i=ot?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&St(r,o):$t(t,n,o));return t}function Tt(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?St(r,o):o}:e?t?function(){return St("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Et(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function jt(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}Ot.data=function(t,e,n){return n?Tt(t,e,n):e&&"function"!=typeof e?t:Tt(t,e)},L.forEach((function(t){Ot[t]=Et})),N.forEach((function(t){Ot[t+"s"]=jt})),Ot.watch=function(t,e,n,r){if(t===J&&(t=void 0),e===J&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},Ot.props=Ot.methods=Ot.inject=Ot.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},Ot.provide=Tt;var It=function(t,e){return void 0===e?t:e};function Dt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Dt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Dt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=Ot[r]||It;a[r]=o(t[r],e[r],n,r)}return a}function Nt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Lt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Rt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===w(t)){var c=Rt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Mt(e.type)?r.call(t):r}(r,o,t);var u=_t;bt(!0),wt(a),bt(u)}return a}var Pt=/^\s*function (\w+)/;function Mt(t){var e=t&&t.toString().match(Pt);return e?e[1]:""}function Ft(t,e){return Mt(t)===Mt(e)}function Rt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Ft(e[n],t))return n;return-1}function Ut(t,e,n){ut();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{lt()}}function Vt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch((function(t){return Ut(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(t){Ut(t,r,o)}return i}function Bt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!V&&!B||"undefined"==typeof console)throw t;console.error(t)}var zt,Wt=!1,qt=[],Kt=!1;function Xt(){Kt=!1;var t=qt.slice(0);qt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){var Gt=Promise.resolve();zt=function(){Gt.then(Xt),X&&setTimeout(O)},Wt=!0}else if(W||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())zt="undefined"!=typeof setImmediate&&nt(setImmediate)?function(){setImmediate(Xt)}:function(){setTimeout(Xt,0)};else{var Zt=1,Jt=new MutationObserver(Xt),Qt=document.createTextNode(String(Zt));Jt.observe(Qt,{characterData:!0}),zt=function(){Zt=(Zt+1)%2,Qt.data=String(Zt)},Wt=!0}function Yt(t,e){var n;if(qt.push((function(){if(t)try{t.call(e)}catch(t){Ut(t,e,"nextTick")}else n&&n(e)})),Kt||(Kt=!0,zt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var te=new rt;function ee(t){ne(t,te),te.clear()}function ne(t,e){var n,r,o=Array.isArray(t);if(!(!o&&!i(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(o)for(n=t.length;n--;)ne(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ne(t[r[n]],e)}}var re=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function oe(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Vt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Vt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ie(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=re(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=oe(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=re(c)).name,n[c],f.capture)}function ae(t,o,i){var a;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=oe([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=oe([s,c]),a.merged=!0,t[o]=a}function se(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ce(t){return o(t)?[vt(t)]:Array.isArray(t)?le(t):void 0}function ue(t){return n(t)&&n(t.text)&&!1===t.isComment}function le(t,i){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ue((s=le(s,(i||"")+"_"+a))[0])&&ue(u)&&(l[c]=vt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):o(s)?ue(u)?l[c]=vt(u.text+s):""!==s&&l.push(vt(s)):ue(s)&&ue(u)?l[c]=vt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(i)&&(s.key="__vlist"+i+"_"+a+"__"),l.push(s)));return l}function fe(t,e){if(t){for(var n=Object.create(null),r=ot?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function de(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(pe)&&delete n[u];return n}function pe(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ve(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=he(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=me(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),F(o,"$stable",a),F(o,"$key",s),F(o,"$hasNormal",i),o}function he(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ce(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function me(t,e){return function(){return t[e]}}function ye(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(ot&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ge(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function _e(t){return Nt(this.$options,"filters",t)||T}function be(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function Ce(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?be(o,r):i?be(i,t):r?w(r)!==e:void 0}function we(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=k(n));var s=function(i){if("class"===i||"style"===i||p(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=w(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function Ae(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||xe(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function $e(t,e,n){return xe(t,"__once__"+e+(n?"_"+n:""),!0),t}function xe(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&ke(t[r],e+"_"+r,n);else ke(t,e,n)}function ke(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Oe(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Se(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Se(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Te(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Ee(t,e){return"string"==typeof t?e+t:t}function je(t){t._o=$e,t._n=f,t._s=l,t._l=ye,t._t=ge,t._q=E,t._i=j,t._m=Ae,t._f=_e,t._k=Ce,t._b=we,t._v=vt,t._e=pt,t._u=Se,t._g=Oe,t._d=Te,t._p=Ee}function Ie(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=fe(u.inject,i),this.slots=function(){return c.$slots||ve(e.scopedSlots,c.$slots=de(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ve(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ve(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Re(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Re(s,t,e,n,r,f)}}function De(t,e,n,r,o){var i=ht(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ne(t,e){for(var n in e)t[_(n)]=e[n]}je(Ie.prototype);var Le={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Le.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ze)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){bt(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Lt(p,v,n,e)}bt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Ge(e,r,h),u&&(e.$slots=de(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,en(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,rn.push(e)):Ye(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?tn(e,!0):e.$destroy())}},Pe=Object.keys(Le);function Me(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var d;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I((function(e){t.resolved=He(e,o),c?s.length=0:d(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,d(!0))})),m=t(p,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=He(m.error,o)),n(m.loading)&&(t.loadingComp=He(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(d,a,s,c,l);a=a||{},$n(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var p=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=w(u);se(a,c,u,l,!0)||se(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Lt(l,u,r||t);else n(o.attrs)&&Ne(c,o.attrs),n(o.props)&&Ne(c,o.props);var f=new Ie(o,c,a,i,e),d=s.render.call(null,f._c,f);if(d instanceof ft)return De(d,o,f.parent,s);if(Array.isArray(d)){for(var p=ce(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=De(p[h],o,f.parent,s);return v}}(o,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Pe.length;n++){var r=Pe[n],o=e[r],i=Le[r];o===i||o&&o._merged||(e[r]=o?Fe(i,o):i)}}(a);var y=o.options.name||l;return new ft("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:p,listeners:h,tag:l,children:c},d)}}}function Fe(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Re(t,e,a,s,c,u){return(Array.isArray(a)||o(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,o,a){if(n(r)&&n(r.__ob__))return pt();n(r)&&n(r.is)&&(e=r.is);if(!e)return pt();Array.isArray(o)&&"function"==typeof o[0]&&((r=r||{}).scopedSlots={default:o[0]},o.length=0);2===a?o=ce(o):1===a&&(o=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(o));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||P.getTagNamespace(e),s=P.isReservedTag(e)?new ft(P.parsePlatformTagName(e),r,o,void 0,void 0,t):r&&r.pre||!n(u=Nt(t.$options,"components",e))?new ft(e,r,o,void 0,void 0,t):Me(u,r,t,o,e)}else s=Me(e,r,t,o);return Array.isArray(s)?s:n(s)?(n(c)&&Ue(s,c),n(r)&&function(t){i(t.style)&&ee(t.style);i(t.class)&&ee(t.class)}(r),s):pt()}(t,e,a,s,c)}function Ue(t,o,i){if(t.ns=o,"foreignObject"===t.tag&&(o=void 0,i=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(i)&&"svg"!==c.tag)&&Ue(c,o,i)}}var Ve,Be=null;function He(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function ze(t){return t.isComment&&t.asyncFactory}function We(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||ze(r)))return r}}function qe(t,e){Ve.$on(t,e)}function Ke(t,e){Ve.$off(t,e)}function Xe(t,e){var n=Ve;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function Ge(t,e,n){Ve=t,ie(e,n||{},qe,Ke,Xe,t),Ve=void 0}var Ze=null;function Je(t){var e=Ze;return Ze=t,function(){Ze=e}}function Qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ye(t,e){if(e){if(t._directInactive=!1,Qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);en(t,"activated")}}function tn(t,e){if(!(e&&(t._directInactive=!0,Qe(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)tn(t.$children[n]);en(t,"deactivated")}}function en(t,e){ut();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Vt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),lt()}var nn=[],rn=[],on={},an=!1,sn=!1,cn=0;var un=0,ln=Date.now;if(V&&!W){var fn=window.performance;fn&&"function"==typeof fn.now&&ln()>document.createEvent("Event").timeStamp&&(ln=function(){return fn.now()})}function dn(){var t,e;for(un=ln(),sn=!0,nn.sort((function(t,e){return t.id-e.id})),cn=0;cn<nn.length;cn++)(t=nn[cn]).before&&t.before(),e=t.id,on[e]=null,t.run();var n=rn.slice(),r=nn.slice();cn=nn.length=rn.length=0,on={},an=sn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ye(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&en(r,"updated")}}(r),et&&P.devtools&&et.emit("flush")}var pn=0,vn=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++pn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!R.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()};vn.prototype.get=function(){var t;ut(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ut(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&ee(t),lt(),this.cleanupDeps()}return t},vn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},vn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},vn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==on[e]){if(on[e]=!0,sn){for(var n=nn.length-1;n>cn&&nn[n].id>t.id;)n--;nn.splice(n+1,0,t)}else nn.push(t);an||(an=!0,Yt(dn))}}(this)},vn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ut(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},vn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},vn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},vn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var hn={enumerable:!0,configurable:!0,get:O,set:O};function mn(t,e,n){hn.get=function(){return this[e][n]},hn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,hn)}function yn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&bt(!1);var i=function(i){o.push(i);var a=Lt(i,e,n,t);At(r,i,a),i in t||mn(t,"_props",i)};for(var a in e)i(a);bt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Ut(t,e,"data()"),{}}finally{lt()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||M(i)||mn(t,"_data",i)}wt(e,!0)}(t):wt(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=tt();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new vn(t,a||O,O,gn)),o in t||_n(t,o,i)}}(t,e.computed),e.watch&&e.watch!==J&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)wn(t,n,r[o]);else wn(t,n,r)}}(t,e.watch)}var gn={lazy:!0};function _n(t,e,n){var r=!tt();"function"==typeof n?(hn.get=r?bn(e):Cn(n),hn.set=O):(hn.get=n.get?r&&!1!==n.cache?bn(e):Cn(n.get):O,hn.set=n.set||O),Object.defineProperty(t,e,hn)}function bn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),st.target&&e.depend(),e.value}}function Cn(t){return function(){return t.call(this,this)}}function wn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var An=0;function $n(t){var e=t.options;if(t.super){var n=$n(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Dt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function xn(t){this._init(t)}function kn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Dt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)mn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)_n(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function On(t){return t&&(t.Ctor.options.name||t.tag)}function Sn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function Tn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=On(a.componentOptions);s&&!e(s)&&En(n,i,r,o)}}}function En(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=An++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Dt($n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Ge(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=de(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Re(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Re(e,t,n,r,o,!0)};var i=r&&r.data;At(e,"$attrs",i&&i.attrs||t,null,!0),At(e,"$listeners",n._parentListeners||t,null,!0)}(n),en(n,"beforeCreate"),function(t){var e=fe(t.$options.inject,t);e&&(bt(!1),Object.keys(e).forEach((function(n){At(t,n,e[n])})),bt(!0))}(n),yn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),en(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(xn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return wn(r,t,e,n);(n=n||{}).user=!0;var o=new vn(r,t,e,n);if(n.immediate){ut();try{e.call(r,o.value)}catch(t){Ut(t,r,'callback for immediate watcher "'+o.expression+'"')}lt()}return function(){o.teardown()}}}(xn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?$(n):n;for(var r=$(arguments,1),o='event handler for "'+t+'"',i=0,a=n.length;i<a;i++)Vt(n[i],e,r,e,o)}return e}}(xn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Je(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){en(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),en(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(xn),function(t){je(t.prototype),t.prototype.$nextTick=function(t){return Yt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ve(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ut(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof ft||(t=pt()),t.parent=o,t}}(xn);var jn=[String,RegExp,Array],In={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)En(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){Tn(t,(function(t){return Sn(e,t)}))})),this.$watch("exclude",(function(e){Tn(t,(function(t){return!Sn(e,t)}))}))},render:function(){var t=this.$slots.default,e=We(t),n=e&&e.componentOptions;if(n){var r=On(n),o=this.include,i=this.exclude;if(o&&(!r||!Sn(o,r))||i&&r&&Sn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&En(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:it,extend:x,mergeOptions:Dt,defineReactive:At},t.set=$t,t.delete=xt,t.nextTick=Yt,t.observable=function(t){return wt(t),t},t.options=Object.create(null),N.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,In),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Dt(this.options,t),this}}(t),kn(t),function(t){N.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(xn),Object.defineProperty(xn.prototype,"$isServer",{get:tt}),Object.defineProperty(xn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(xn,"FunctionalRenderContext",{value:Ie}),xn.version="2.6.12";var Dn=d("style,class"),Nn=d("input,textarea,option,select,progress"),Ln=d("contenteditable,draggable,spellcheck"),Pn=d("events,caret,typing,plaintext-only"),Mn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Rn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Un=function(t){return Rn(t)?t.slice(6,t.length):""},Vn=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Hn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return zn(t,Wn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:zn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function zn(t,e){return t?e?t+" "+e:t:e||""}function Wn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Wn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var qn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Xn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(t){return Kn(t)||Xn(t)};var Zn=Object.create(null);var Jn=d("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(qn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Yn={create:function(t,e){tr(e)},update:function(t,e){t.data.ref!==e.data.ref&&(tr(t,!0),tr(e))},destroy:function(t){tr(t,!0)}};function tr(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var er=new ft("",{},[]),nr=["create","activate","update","remove","destroy"];function rr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Jn(o)&&Jn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function or(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var ir={create:ar,update:ar,destroy:function(t){ar(t,er)}};function ar(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===er,a=e===er,s=cr(t.data.directives,t.context),c=cr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,lr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(lr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)lr(u[n],"inserted",e,t)};i?ae(e,"insert",f):f()}l.length&&ae(e,"postpatch",(function(){for(var n=0;n<l.length;n++)lr(l[n],"componentUpdated",e,t)}));if(!i)for(n in s)c[n]||lr(s[n],"unbind",t,t,a)}(t,e)}var sr=Object.create(null);function cr(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=sr),o[ur(r)]=r,r.def=Nt(e.$options,"directives",r.name);return o}function ur(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function lr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ut(r,n.context,"directive "+t.name+" "+e+" hook")}}var fr=[Yn,ir];function dr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&pr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&pr(s,"value",u.value),c)e(u[i])&&(Rn(i)?s.removeAttributeNS(Fn,Un(i)):Ln(i)||s.removeAttribute(i))}}function pr(t,e,n,r){r||t.tagName.indexOf("-")>-1?vr(t,e,n):Mn(e)?Vn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Ln(e)?t.setAttribute(e,function(t,e){return Vn(e)||"false"===e?"false":"contenteditable"===t&&Pn(e)?e:"true"}(e,n)):Rn(e)?Vn(n)?t.removeAttributeNS(Fn,Un(e)):t.setAttributeNS(Fn,e,n):vr(t,e,n)}function vr(t,e,n){if(Vn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var hr={create:dr,update:dr};function mr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=o._transitionClasses;n(c)&&(s=zn(s,Wn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var yr,gr={create:mr,update:mr};function _r(t,e,n){var r=yr;return function o(){var i=e.apply(null,arguments);null!==i&&wr(t,o,n,r)}}var br=Wt&&!(Z&&Number(Z[1])<=53);function Cr(t,e,n,r){if(br){var o=un,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}yr.addEventListener(t,e,Q?{capture:n,passive:r}:n)}function wr(t,e,n,r){(r||yr).removeEventListener(t,e._wrapper||e,n)}function Ar(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};yr=r.elm,function(t){if(n(t.__r)){var e=W?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(o),ie(o,i,Cr,wr,_r,r.context),yr=void 0}}var $r,xr={create:Ar,update:Ar};function kr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Xn(a.tagName)&&e(a.innerHTML)){($r=$r||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=$r.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Sr={create:kr,update:kr},Tr=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?k(t):"string"==typeof t?Tr(t):t}var Ir,Dr=/^--/,Nr=/\s*!important$/,Lr=function(t,e,n){if(Dr.test(e))t.style.setProperty(e,n);else if(Nr.test(n))t.style.setProperty(w(e),n.replace(Nr,""),"important");else{var r=Mr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Mr=y((function(t){if(Ir=Ir||document.createElement("div").style,"filter"!==(t=_(t))&&t in Ir)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Ir)return r}}));function Fr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,d=jr(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Lr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Lr(c,s,null==a?"":a)}}var Rr={create:Fr,update:Fr},Ur=/\s+/;function Vr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Hr="transition",zr="animation",Wr="transition",qr="transitionend",Kr="animation",Xr="animationend";V&&!q&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Wr="WebkitTransition",qr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Kr="WebkitAnimation",Xr="webkitAnimationEnd"));var Gr=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Zr(t){Gr((function(){Gr(t)}))}function Jr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Qr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Yr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),o=(r[Wr+"Delay"]||"").split(", "),i=(r[Wr+"Duration"]||"").split(", "),a=eo(o,i),s=(r[Kr+"Delay"]||"").split(", "),c=(r[Kr+"Duration"]||"").split(", "),u=eo(s,c),l=0,f=0;e===Hr?a>0&&(n=Hr,l=a,f=i.length):e===zr?u>0&&(n=zr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?Hr:zr:null)?n===Hr?i.length:c.length:0;var d=n===Hr&&to.test(r[Wr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===Hr?qr:Xr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var to=/\b(transform|all)(,|$)/;function eo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return no(e)+no(t[n])})))}function no(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ro(t){return"number"==typeof t&&!isNaN(t)}function oo(t){if(e(t))return!1;var r=t.fns;return n(r)?oo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function io(t,r){!0!==r.data.show&&function(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Vr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ze,k=Ze.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!q,F=oo(D),R=o._enterCb=I((function(){M&&(Qr(o,E),Qr(o,T)),R.cancelled?(M&&Qr(o,S),L&&L(o)):N&&N(o),o._enterCb=null}));t.data.show||ae(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),j&&j(o),M&&(Jr(o,S),Jr(o,T),Zr((function(){Qr(o,S),R.cancelled||(Jr(o,E),F||(ro(P)?setTimeout(R,P):Yr(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}(r)}var ao=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<nr.length;++i)for(s[nr[i]]=[],a=0;a<c.length;++a)n(c[a][nr[i]])&&s[nr[i]].push(c[a][nr[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=ht(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){var i,a=t;for(;a.componentInstance;)if(n(i=(a=a.componentInstance._vnode).data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](er,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(tr(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](er,t);n(i=t.data.hook)&&(n(i.create)&&i.create(er,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ze)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&rr(t,a))return i}}function $(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=ht(o));var d=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?O(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var p,v=o.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(p=0;p<s.update.length;++p)s.update[p](t,o);n(p=v.hook)&&n(p=p.update)&&p(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:rr(h,g)?($(h,g,i,o,p),h=r[++d],g=o[++p]):rr(m,b)?($(m,b,i,o,y),m=r[--v],b=o[--y]):rr(h,b)?($(h,b,i,o,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=o[--y]):rr(m,g)?($(m,g,i,o,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++p]):(e(s)&&(s=or(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,i,t,h.elm,!1,o,p):rr(l=r[c],g)?($(l,g,i,o,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,p),g=o[++p]);d>v?_(t,e(o[y+1])?null:o[y+1].elm,o,p,y,i):p>y&&C(r,d,v)}(d,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==o.text&&u.setTextContent(d,o.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,o);break}!v&&c.class&&ee(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,d=[];if(e(t))l=!0,f(o,d);else{var p=n(t.nodeType);if(!p&&rr(t,o))$(t,o,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&O(t,o,d))return x(o,d,!0),t;c=t,t=new ft(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,d,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](er,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else tr(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,d,l),o.elm}n(t)&&b(t)}}({nodeOps:Qn,modules:[hr,gr,xr,Sr,Rr,V?{create:io,activate:io,remove:function(t,r){!0!==t.data.show?function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Vr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=oo(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Qr(o,l),Qr(o,d)),w.cancelled?(_&&Qr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Jr(o,u),Jr(o,d),Zr((function(){Qr(o,u),w.cancelled||(Jr(o,l),b||(ro(C)?setTimeout(w,C):Yr(o,c,w)))}))),v&&v(o,w),_||b||w())}}(t,r):r()}}:{}].concat(fr)});q&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&ho(t,"input")}));var so={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ae(n,"postpatch",(function(){so.componentUpdated(t,e,n)})):co(t,e,n.context),t._vOptions=[].map.call(t.options,fo)):("textarea"===n.tag||Jn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",po),t.addEventListener("compositionend",vo),t.addEventListener("change",vo),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){co(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,fo);if(o.some((function(t,e){return!E(t,r[e])})))(t.multiple?e.value.some((function(t){return lo(t,o)})):e.value!==e.oldValue&&lo(e.value,o))&&ho(t,"change")}}};function co(t,e,n){uo(t,e),(W||K)&&setTimeout((function(){uo(t,e)}),0)}function uo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=j(r,fo(a))>-1,a.selected!==i&&(a.selected=i);else if(E(fo(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function lo(t,e){return e.every((function(e){return!E(e,t)}))}function fo(t){return"_value"in t?t._value:t.value}function po(t){t.target.composing=!0}function vo(t){t.target.composing&&(t.target.composing=!1,ho(t.target,"input"))}function ho(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var mo=/\s+/;function yo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(mo).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function go(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(mo).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function _o(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,bo(t.name||"v")),x(e,t),e}return"string"==typeof t?bo(t):void 0}}var bo=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Co=V&&!q,wo="transition",Ao="animation",$o="transition",xo="transitionend",ko="animation",Oo="animationend";Co&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&($o="WebkitTransition",xo="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(ko="WebkitAnimation",Oo="webkitAnimationEnd"));var So=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function To(t){So((function(){So(t)}))}function Eo(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),yo(t,e))}function jo(t,e){t._transitionClasses&&v(t._transitionClasses,e),go(t,e)}function Io(t,e,n){var r=No(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===wo?xo:Oo,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var Do=/\b(transform|all)(,|$)/;function No(t,e){var n,r=window.getComputedStyle(t),o=(r[$o+"Delay"]||"").split(", "),i=(r[$o+"Duration"]||"").split(", "),a=Lo(o,i),s=(r[ko+"Delay"]||"").split(", "),c=(r[ko+"Duration"]||"").split(", "),u=Lo(s,c),l=0,f=0;return e===wo?a>0&&(n=wo,l=a,f=i.length):e===Ao?u>0&&(n=Ao,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?wo:Ao:null)?n===wo?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===wo&&Do.test(r[$o+"Property"])}}function Lo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return Po(e)+Po(t[n])})))}function Po(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Mo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=_o(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ze,k=Ze.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(i($)?$.enter:$),M=!1!==s&&!q,F=Ro(D),R=o._enterCb=I((function(){M&&(jo(o,E),jo(o,T)),R.cancelled?(M&&jo(o,S),L&&L(o)):N&&N(o),o._enterCb=null}));t.data.show||ae(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),j&&j(o),M&&(Eo(o,S),Eo(o,T),To((function(){jo(o,S),R.cancelled||(Eo(o,E),F||(Fo(P)?setTimeout(R,P):Io(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function Fo(t){return"number"==typeof t&&!isNaN(t)}function Ro(t){if(e(t))return!1;var r=t.fns;return n(r)?Ro(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Uo(t){return!t.componentInstance||t.data&&t.data.transition?t:Uo(t.componentInstance._vnode)}var Vo={model:so,show:{bind:function(t,e,n){var r=e.value,o=(n=Uo(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,Mo(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,r,o){var a=r.value;!a!=!r.oldValue&&((o=Uo(o)).data&&o.data.transition?(o.data.show=!0,a?Mo(o,(function(){t.style.display=t.__vOriginalDisplay})):function(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=_o(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=Ro(v),C=f(i(g)?g.leave:g),w=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(jo(o,l),jo(o,d)),w.cancelled?(_&&jo(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),p&&p(o),_&&(Eo(o,u),Eo(o,d),To((function(){jo(o,u),w.cancelled||(Eo(o,l),b||(Fo(C)?setTimeout(w,C):Io(o,c,w)))}))),v&&v(o,w),_||b||w())}}(o,(function(){t.style.display="none"}))):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Bo={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Ho(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Ho(We(e.children)):t}function zo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Wo(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var qo=function(t){return t.tag||ze(t)},Ko=function(t){return"show"===t.name},Xo={name:"transition",props:Bo,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(qo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=Ho(i);if(!a)return i;if(this._leaving)return Wo(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=zo(this),u=this._vnode,l=Ho(u);if(a.data.directives&&a.data.directives.some(Ko)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!ze(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ae(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Wo(t,i);if("in-out"===r){if(ze(a))return u;var d,p=function(){d()};ae(c,"afterEnter",p),ae(c,"enterCancelled",p),ae(f,"delayLeave",(function(t){d=t}))}}return i}}},Go=x({tag:String,moveClass:String},Bo);function Zo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Jo(t){t.data.newPos=t.elm.getBoundingClientRect()}function Qo(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete Go.mode;var Yo={Transition:Xo,TransitionGroup:{props:Go,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Je(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=zo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Zo),t.forEach(Jo),t.forEach(Qo),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;Eo(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(xo,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(xo,t),n._moveCb=null,jo(n,e))})}})))},methods:{hasMove:function(t,e){if(!Co)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){go(n,t)})),yo(n,e),n.style.display="none",this.$el.appendChild(n);var r=No(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return xn.config.mustUseProp=function(t,e,n){return"value"===n&&Nn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},xn.config.isReservedTag=Gn,xn.config.isReservedAttr=Dn,xn.config.getTagNamespace=function(t){return Xn(t)?"svg":"math"===t?"math":void 0},xn.config.isUnknownElement=function(t){if(!V)return!0;if(Gn(t))return!1;if(t=t.toLowerCase(),null!=Zn[t])return Zn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Zn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Zn[t]=/HTMLUnknownElement/.test(e.toString())},x(xn.options.directives,Vo),x(xn.options.components,Yo),xn.prototype.__patch__=V?ao:O,xn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),en(t,"beforeMount"),r=function(){t._update(t._render(),n)},new vn(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&en(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,en(t,"mounted")),t}(this,t=t&&V?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},V&&setTimeout((function(){P.devtools&&et&&et.emit("init",xn)}),0),xn}));
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,$=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every((function(t,n){return j(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return j(t[n],e[n])}))}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function F(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var R=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var U="__proto__"in{},V="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),z=V&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0;z&&z.indexOf("android");var X=z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===H;z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z);var G,Z=z&&z.match(/firefox\/(\d+)/),J={}.watch,Q=!1;if(V)try{var Y={};Object.defineProperty(Y,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,Y)}catch(t){}var tt=function(){return void 0===G&&(G=!V&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},et=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}var rt,ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);rt="undefined"!=typeof Set&&nt(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var it=k,at=0,st=function(){this.id=at++,this.subs=[]};st.prototype.addSub=function(t){this.subs.push(t)},st.prototype.removeSub=function(t){v(this.subs,t)},st.prototype.depend=function(){st.target&&st.target.addDep(this)},st.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},st.target=null;var ct=[];function ut(t){ct.push(t),st.target=t}function lt(){ct.pop(),st.target=ct[ct.length-1]}var ft=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},pt={child:{configurable:!0}};pt.child.get=function(){return this.componentInstance},Object.defineProperties(ft.prototype,pt);var dt=function(t){void 0===t&&(t="");var e=new ft;return e.text=t,e.isComment=!0,e};function vt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){var e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=mt[t];F(yt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i}))}));var gt=Object.getOwnPropertyNames(yt),_t=!0;function bt(t){_t=t}var Ct=function(t){this.value=t,this.dep=new st,this.vmCount=0,F(t,"__ob__",this),Array.isArray(t)?(U?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];F(t,i,e[i])}}(t,yt,gt),this.observeArray(t)):this.walk(t)};function $t(t,e){var n;if(i(t)&&!(t instanceof ft))return m(t,"__ob__")&&t.__ob__ instanceof Ct?n=t.__ob__:_t&&!tt()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new Ct(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,r,o){var i=new st,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&$t(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return st.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&Ot(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&$t(e),i.notify())}})}}function At(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(wt(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function Ot(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&Ot(e)}Ct.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)wt(t,e[n])},Ct.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)$t(t[e])};var kt=L.optionMergeStrategies;function St(t,e){if(!e)return t;for(var n,r,o,i=ot?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&St(r,o):At(t,n,o));return t}function Et(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?St(r,o):o}:e?t?function(){return St("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function jt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Tt(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}kt.data=function(t,e,n){return n?Et(t,e,n):e&&"function"!=typeof e?t:Et(t,e)},P.forEach((function(t){kt[t]=jt})),N.forEach((function(t){kt[t+"s"]=Tt})),kt.watch=function(t,e,n,r){if(t===J&&(t=void 0),e===J&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},kt.props=kt.methods=kt.inject=kt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},kt.provide=Et;var It=function(t,e){return void 0===e?t:e};function Dt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Dt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Dt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=kt[r]||It;a[r]=o(t[r],e[r],n,r)}return a}function Nt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Pt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Rt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Rt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Mt(e.type)?r.call(t):r}(r,o,t);var u=_t;bt(!0),$t(a),bt(u)}return a}var Lt=/^\s*function (\w+)/;function Mt(t){var e=t&&t.toString().match(Lt);return e?e[1]:""}function Ft(t,e){return Mt(t)===Mt(e)}function Rt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Ft(e[n],t))return n;return-1}function Ut(t,e,n){ut();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{lt()}}function Vt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch((function(t){return Ut(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(t){Ut(t,r,o)}return i}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!V&&!B||"undefined"==typeof console)throw t;console.error(t)}var zt,Wt=!1,qt=[],Kt=!1;function Xt(){Kt=!1;var t=qt.slice(0);qt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){var Gt=Promise.resolve();zt=function(){Gt.then(Xt),X&&setTimeout(k)},Wt=!0}else if(W||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())zt="undefined"!=typeof setImmediate&&nt(setImmediate)?function(){setImmediate(Xt)}:function(){setTimeout(Xt,0)};else{var Zt=1,Jt=new MutationObserver(Xt),Qt=document.createTextNode(String(Zt));Jt.observe(Qt,{characterData:!0}),zt=function(){Zt=(Zt+1)%2,Qt.data=String(Zt)},Wt=!0}function Yt(t,e){var n;if(qt.push((function(){if(t)try{t.call(e)}catch(t){Ut(t,e,"nextTick")}else n&&n(e)})),Kt||(Kt=!0,zt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var te=new rt;function ee(t){ne(t,te),te.clear()}function ne(t,e){var n,r,o=Array.isArray(t);if(!(!o&&!i(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(o)for(n=t.length;n--;)ne(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ne(t[r[n]],e)}}var re=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function oe(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Vt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Vt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ie(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=re(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=oe(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=re(c)).name,n[c],f.capture)}function ae(t,o,i){var a;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=oe([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=oe([s,c]),a.merged=!0,t[o]=a}function se(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ce(t){return o(t)?[vt(t)]:Array.isArray(t)?le(t):void 0}function ue(t){return n(t)&&n(t.text)&&!1===t.isComment}function le(t,i){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ue((s=le(s,(i||"")+"_"+a))[0])&&ue(u)&&(l[c]=vt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):o(s)?ue(u)?l[c]=vt(u.text+s):""!==s&&l.push(vt(s)):ue(s)&&ue(u)?l[c]=vt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(i)&&(s.key="__vlist"+i+"_"+a+"__"),l.push(s)));return l}function fe(t,e){if(t){for(var n=Object.create(null),r=ot?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function pe(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(de)&&delete n[u];return n}function de(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ve(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=he(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=me(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),F(o,"$stable",a),F(o,"$key",s),F(o,"$hasNormal",i),o}function he(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ce(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function me(t,e){return function(){return t[e]}}function ye(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(ot&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ge(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function _e(t){return Nt(this.$options,"filters",t)||E}function be(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function Ce(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?be(o,r):i?be(i,t):r?$(r)!==e:void 0}function $e(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function we(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||xe(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function Ae(t,e,n){return xe(t,"__once__"+e+(n?"_"+n:""),!0),t}function xe(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Oe(t[r],e+"_"+r,n);else Oe(t,e,n)}function Oe(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function ke(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Se(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Se(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ee(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function je(t,e){return"string"==typeof t?e+t:t}function Te(t){t._o=Ae,t._n=f,t._s=l,t._l=ye,t._t=ge,t._q=j,t._i=T,t._m=we,t._f=_e,t._k=Ce,t._b=$e,t._v=vt,t._e=dt,t._u=Se,t._g=ke,t._d=Ee,t._p=je}function Ie(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=fe(u.inject,i),this.slots=function(){return c.$slots||ve(e.scopedSlots,c.$slots=pe(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ve(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ve(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Re(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Re(s,t,e,n,r,f)}}function De(t,e,n,r,o){var i=ht(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ne(t,e){for(var n in e)t[_(n)]=e[n]}Te(Ie.prototype);var Pe={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Pe.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ze)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){bt(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Pt(d,v,n,e)}bt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Ge(e,r,h),u&&(e.$slots=pe(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,en(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,rn.push(e)):Ye(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?tn(e,!0):e.$destroy())}},Le=Object.keys(Pe);function Me(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I((function(e){t.resolved=He(e,o),c?s.length=0:p(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,p(!0))})),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=He(m.error,o)),n(m.loading)&&(t.loadingComp=He(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},An(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);se(a,c,u,l,!0)||se(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Pt(l,u,r||t);else n(o.attrs)&&Ne(c,o.attrs),n(o.props)&&Ne(c,o.props);var f=new Ie(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof ft)return De(p,o,f.parent,s);if(Array.isArray(p)){for(var d=ce(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=De(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Le.length;n++){var r=Le[n],o=e[r],i=Pe[r];o===i||o&&o._merged||(e[r]=o?Fe(i,o):i)}}(a);var y=o.options.name||l;return new ft("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function Fe(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Re(t,e,a,s,c,u){return(Array.isArray(a)||o(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,o,a){if(n(r)&&n(r.__ob__))return dt();n(r)&&n(r.is)&&(e=r.is);if(!e)return dt();Array.isArray(o)&&"function"==typeof o[0]&&((r=r||{}).scopedSlots={default:o[0]},o.length=0);2===a?o=ce(o):1===a&&(o=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(o));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),s=L.isReservedTag(e)?new ft(L.parsePlatformTagName(e),r,o,void 0,void 0,t):r&&r.pre||!n(u=Nt(t.$options,"components",e))?new ft(e,r,o,void 0,void 0,t):Me(u,r,t,o,e)}else s=Me(e,r,t,o);return Array.isArray(s)?s:n(s)?(n(c)&&Ue(s,c),n(r)&&function(t){i(t.style)&&ee(t.style);i(t.class)&&ee(t.class)}(r),s):dt()}(t,e,a,s,c)}function Ue(t,o,i){if(t.ns=o,"foreignObject"===t.tag&&(o=void 0,i=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(i)&&"svg"!==c.tag)&&Ue(c,o,i)}}var Ve,Be=null;function He(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function ze(t){return t.isComment&&t.asyncFactory}function We(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||ze(r)))return r}}function qe(t,e){Ve.$on(t,e)}function Ke(t,e){Ve.$off(t,e)}function Xe(t,e){var n=Ve;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function Ge(t,e,n){Ve=t,ie(e,n||{},qe,Ke,Xe,t),Ve=void 0}var Ze=null;function Je(t){var e=Ze;return Ze=t,function(){Ze=e}}function Qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ye(t,e){if(e){if(t._directInactive=!1,Qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);en(t,"activated")}}function tn(t,e){if(!(e&&(t._directInactive=!0,Qe(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)tn(t.$children[n]);en(t,"deactivated")}}function en(t,e){ut();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Vt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),lt()}var nn=[],rn=[],on={},an=!1,sn=!1,cn=0;var un=0,ln=Date.now;if(V&&!W){var fn=window.performance;fn&&"function"==typeof fn.now&&ln()>document.createEvent("Event").timeStamp&&(ln=function(){return fn.now()})}function pn(){var t,e;for(un=ln(),sn=!0,nn.sort((function(t,e){return t.id-e.id})),cn=0;cn<nn.length;cn++)(t=nn[cn]).before&&t.before(),e=t.id,on[e]=null,t.run();var n=rn.slice(),r=nn.slice();cn=nn.length=rn.length=0,on={},an=sn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ye(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&en(r,"updated")}}(r),et&&L.devtools&&et.emit("flush")}var dn=0,vn=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++dn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!R.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};vn.prototype.get=function(){var t;ut(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ut(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&ee(t),lt(),this.cleanupDeps()}return t},vn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},vn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},vn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==on[e]){if(on[e]=!0,sn){for(var n=nn.length-1;n>cn&&nn[n].id>t.id;)n--;nn.splice(n+1,0,t)}else nn.push(t);an||(an=!0,Yt(pn))}}(this)},vn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ut(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},vn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},vn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},vn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var hn={enumerable:!0,configurable:!0,get:k,set:k};function mn(t,e,n){hn.get=function(){return this[e][n]},hn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,hn)}function yn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&bt(!1);var i=function(i){o.push(i);var a=Pt(i,e,n,t);wt(r,i,a),i in t||mn(t,"_props",i)};for(var a in e)i(a);bt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Ut(t,e,"data()"),{}}finally{lt()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||M(i)||mn(t,"_data",i)}$t(e,!0)}(t):$t(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=tt();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new vn(t,a||k,k,gn)),o in t||_n(t,o,i)}}(t,e.computed),e.watch&&e.watch!==J&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)$n(t,n,r[o]);else $n(t,n,r)}}(t,e.watch)}var gn={lazy:!0};function _n(t,e,n){var r=!tt();"function"==typeof n?(hn.get=r?bn(e):Cn(n),hn.set=k):(hn.get=n.get?r&&!1!==n.cache?bn(e):Cn(n.get):k,hn.set=n.set||k),Object.defineProperty(t,e,hn)}function bn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),st.target&&e.depend(),e.value}}function Cn(t){return function(){return t.call(this,this)}}function $n(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var wn=0;function An(t){var e=t.options;if(t.super){var n=An(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Dt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function xn(t){this._init(t)}function On(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Dt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)mn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)_n(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function kn(t){return t&&(t.Ctor.options.name||t.tag)}function Sn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function En(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=kn(a.componentOptions);s&&!e(s)&&jn(n,i,r,o)}}}function jn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=wn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Dt(An(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Ge(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=pe(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Re(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Re(e,t,n,r,o,!0)};var i=r&&r.data;wt(e,"$attrs",i&&i.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),en(n,"beforeCreate"),function(t){var e=fe(t.$options.inject,t);e&&(bt(!1),Object.keys(e).forEach((function(n){wt(t,n,e[n])})),bt(!0))}(n),yn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),en(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(xn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=At,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return $n(r,t,e,n);(n=n||{}).user=!0;var o=new vn(r,t,e,n);if(n.immediate){ut();try{e.call(r,o.value)}catch(t){Ut(t,r,'callback for immediate watcher "'+o.expression+'"')}lt()}return function(){o.teardown()}}}(xn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),o='event handler for "'+t+'"',i=0,a=n.length;i<a;i++)Vt(n[i],e,r,e,o)}return e}}(xn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Je(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){en(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),en(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(xn),function(t){Te(t.prototype),t.prototype.$nextTick=function(t){return Yt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ve(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ut(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof ft||(t=dt()),t.parent=o,t}}(xn);var Tn=[String,RegExp,Array],In={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Tn,exclude:Tn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)jn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){En(t,(function(t){return Sn(e,t)}))})),this.$watch("exclude",(function(e){En(t,(function(t){return!Sn(e,t)}))}))},render:function(){var t=this.$slots.default,e=We(t),n=e&&e.componentOptions;if(n){var r=kn(n),o=this.include,i=this.exclude;if(o&&(!r||!Sn(o,r))||i&&r&&Sn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&jn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:it,extend:x,mergeOptions:Dt,defineReactive:wt},t.set=At,t.delete=xt,t.nextTick=Yt,t.observable=function(t){return $t(t),t},t.options=Object.create(null),N.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,In),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Dt(this.options,t),this}}(t),On(t),function(t){N.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(xn),Object.defineProperty(xn.prototype,"$isServer",{get:tt}),Object.defineProperty(xn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(xn,"FunctionalRenderContext",{value:Ie}),xn.version="2.6.12";var Dn=p("style,class"),Nn=p("input,textarea,option,select,progress"),Pn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Rn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Un=function(t){return Rn(t)?t.slice(6,t.length):""},Vn=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Hn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return zn(t,Wn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:zn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function zn(t,e){return t?e?t+" "+e:t:e||""}function Wn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Wn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var qn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Xn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(t){return Kn(t)||Xn(t)};var Zn=Object.create(null);var Jn=p("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(qn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Yn={create:function(t,e){tr(e)},update:function(t,e){t.data.ref!==e.data.ref&&(tr(t,!0),tr(e))},destroy:function(t){tr(t,!0)}};function tr(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var er=new ft("",{},[]),nr=["create","activate","update","remove","destroy"];function rr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Jn(o)&&Jn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function or(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var ir={create:ar,update:ar,destroy:function(t){ar(t,er)}};function ar(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===er,a=e===er,s=cr(t.data.directives,t.context),c=cr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,lr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(lr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)lr(u[n],"inserted",e,t)};i?ae(e,"insert",f):f()}l.length&&ae(e,"postpatch",(function(){for(var n=0;n<l.length;n++)lr(l[n],"componentUpdated",e,t)}));if(!i)for(n in s)c[n]||lr(s[n],"unbind",t,t,a)}(t,e)}var sr=Object.create(null);function cr(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=sr),o[ur(r)]=r,r.def=Nt(e.$options,"directives",r.name);return o}function ur(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function lr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ut(r,n.context,"directive "+t.name+" "+e+" hook")}}var fr=[Yn,ir];function pr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&dr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&dr(s,"value",u.value),c)e(u[i])&&(Rn(i)?s.removeAttributeNS(Fn,Un(i)):Pn(i)||s.removeAttribute(i))}}function dr(t,e,n,r){r||t.tagName.indexOf("-")>-1?vr(t,e,n):Mn(e)?Vn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Pn(e)?t.setAttribute(e,function(t,e){return Vn(e)||"false"===e?"false":"contenteditable"===t&&Ln(e)?e:"true"}(e,n)):Rn(e)?Vn(n)?t.removeAttributeNS(Fn,Un(e)):t.setAttributeNS(Fn,e,n):vr(t,e,n)}function vr(t,e,n){if(Vn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var hr={create:pr,update:pr};function mr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=o._transitionClasses;n(c)&&(s=zn(s,Wn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var yr,gr={create:mr,update:mr};function _r(t,e,n){var r=yr;return function o(){var i=e.apply(null,arguments);null!==i&&$r(t,o,n,r)}}var br=Wt&&!(Z&&Number(Z[1])<=53);function Cr(t,e,n,r){if(br){var o=un,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}yr.addEventListener(t,e,Q?{capture:n,passive:r}:n)}function $r(t,e,n,r){(r||yr).removeEventListener(t,e._wrapper||e,n)}function wr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};yr=r.elm,function(t){if(n(t.__r)){var e=W?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(o),ie(o,i,Cr,$r,_r,r.context),yr=void 0}}var Ar,xr={create:wr,update:wr};function Or(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);kr(a,u)&&(a.value=u)}else if("innerHTML"===o&&Xn(a.tagName)&&e(a.innerHTML)){(Ar=Ar||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=Ar.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function kr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Sr={create:Or,update:Or},Er=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function jr(t){var e=Tr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Tr(t){return Array.isArray(t)?O(t):"string"==typeof t?Er(t):t}var Ir,Dr=/^--/,Nr=/\s*!important$/,Pr=function(t,e,n){if(Dr.test(e))t.style.setProperty(e,n);else if(Nr.test(n))t.style.setProperty($(e),n.replace(Nr,""),"important");else{var r=Mr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Lr=["Webkit","Moz","ms"],Mr=y((function(t){if(Ir=Ir||document.createElement("div").style,"filter"!==(t=_(t))&&t in Ir)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Lr.length;n++){var r=Lr[n]+e;if(r in Ir)return r}}));function Fr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=Tr(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=jr(o.data))&&x(r,n);(n=jr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=jr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Pr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Pr(c,s,null==a?"":a)}}var Rr={create:Fr,update:Fr},Ur=/\s+/;function Vr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Br(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Hr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,zr(t.name||"v")),x(e,t),e}return"string"==typeof t?zr(t):void 0}}var zr=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Wr=V&&!q,qr="transition",Kr="animation",Xr="transition",Gr="transitionend",Zr="animation",Jr="animationend";Wr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xr="WebkitTransition",Gr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Zr="WebkitAnimation",Jr="webkitAnimationEnd"));var Qr=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Yr(t){Qr((function(){Qr(t)}))}function to(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Vr(t,e))}function eo(t,e){t._transitionClasses&&v(t._transitionClasses,e),Br(t,e)}function no(t,e,n){var r=oo(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===qr?Gr:Jr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var ro=/\b(transform|all)(,|$)/;function oo(t,e){var n,r=window.getComputedStyle(t),o=(r[Xr+"Delay"]||"").split(", "),i=(r[Xr+"Duration"]||"").split(", "),a=io(o,i),s=(r[Zr+"Delay"]||"").split(", "),c=(r[Zr+"Duration"]||"").split(", "),u=io(s,c),l=0,f=0;return e===qr?a>0&&(n=qr,l=a,f=i.length):e===Kr?u>0&&(n=Kr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?qr:Kr:null)?n===qr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===qr&&ro.test(r[Xr+"Property"])}}function io(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return ao(e)+ao(t[n])})))}function ao(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function so(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Hr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ze,O=Ze.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=lo(D),R=o._enterCb=I((function(){M&&(eo(o,j),eo(o,E)),R.cancelled?(M&&eo(o,S),P&&P(o)):N&&N(o),o._enterCb=null}));t.data.show||ae(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),T&&T(o),M&&(to(o,S),to(o,E),Yr((function(){eo(o,S),R.cancelled||(to(o,j),F||(uo(L)?setTimeout(R,L):no(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function co(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Hr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=lo(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(eo(o,l),eo(o,p)),$.cancelled?(_&&eo(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(to(o,u),to(o,p),Yr((function(){eo(o,u),$.cancelled||(to(o,l),b||(uo(C)?setTimeout($,C):no(o,c,$)))}))),v&&v(o,$),_||b||$())}}function uo(t){return"number"==typeof t&&!isNaN(t)}function lo(t){if(e(t))return!1;var r=t.fns;return n(r)?lo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function fo(t,e){!0!==e.data.show&&so(e)}var po=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<nr.length;++i)for(s[nr[i]]=[],a=0;a<c.length;++a)n(c[a][nr[i]])&&s[nr[i]].push(c[a][nr[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=ht(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){var i,a=t;for(;a.componentInstance;)if(n(i=(a=a.componentInstance._vnode).data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](er,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(tr(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](er,t);n(i=t.data.hook)&&(n(i.create)&&i.create(er,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ze)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&rr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=ht(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:rr(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):rr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):rr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):rr(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=or(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):rr(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&ee(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&rr(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new ft(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](er,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else tr(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Qn,modules:[hr,gr,xr,Sr,Rr,V?{create:fo,activate:fo,remove:function(t,e){!0!==t.data.show?co(t,e):e()}}:{}].concat(fr)});q&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&Co(t,"input")}));var vo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ae(n,"postpatch",(function(){vo.componentUpdated(t,e,n)})):ho(t,e,n.context),t._vOptions=[].map.call(t.options,go)):("textarea"===n.tag||Jn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",_o),t.addEventListener("compositionend",bo),t.addEventListener("change",bo),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ho(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,go);if(o.some((function(t,e){return!j(t,r[e])})))(t.multiple?e.value.some((function(t){return yo(t,o)})):e.value!==e.oldValue&&yo(e.value,o))&&Co(t,"change")}}};function ho(t,e,n){mo(t,e),(W||K)&&setTimeout((function(){mo(t,e)}),0)}function mo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,go(a))>-1,a.selected!==i&&(a.selected=i);else if(j(go(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function yo(t,e){return e.every((function(e){return!j(e,t)}))}function go(t){return"_value"in t?t._value:t.value}function _o(t){t.target.composing=!0}function bo(t){t.target.composing&&(t.target.composing=!1,Co(t.target,"input"))}function Co(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function $o(t){return!t.componentInstance||t.data&&t.data.transition?t:$o(t.componentInstance._vnode)}var wo={model:vo,show:{bind:function(t,e,n){var r=e.value,o=(n=$o(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,so(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=$o(n)).data&&n.data.transition?(n.data.show=!0,r?so(n,(function(){t.style.display=t.__vOriginalDisplay})):co(n,(function(){t.style.display="none"}))):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Ao={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function xo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?xo(We(e.children)):t}function Oo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function ko(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var So=function(t){return t.tag||ze(t)},Eo=function(t){return"show"===t.name},jo={name:"transition",props:Ao,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(So)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=xo(i);if(!a)return i;if(this._leaving)return ko(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Oo(this),u=this._vnode,l=xo(u);if(a.data.directives&&a.data.directives.some(Eo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!ze(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ae(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),ko(t,i);if("in-out"===r){if(ze(a))return u;var p,d=function(){p()};ae(c,"afterEnter",d),ae(c,"enterCancelled",d),ae(f,"delayLeave",(function(t){p=t}))}}return i}}},To=x({tag:String,moveClass:String},Ao);function Io(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Do(t){t.data.newPos=t.elm.getBoundingClientRect()}function No(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete To.mode;var Po={Transition:jo,TransitionGroup:{props:To,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Je(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Oo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Io),t.forEach(Do),t.forEach(No),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;to(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Gr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Gr,t),n._moveCb=null,eo(n,e))})}})))},methods:{hasMove:function(t,e){if(!Wr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){Br(n,t)})),Vr(n,e),n.style.display="none",this.$el.appendChild(n);var r=oo(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return xn.config.mustUseProp=function(t,e,n){return"value"===n&&Nn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},xn.config.isReservedTag=Gn,xn.config.isReservedAttr=Dn,xn.config.getTagNamespace=function(t){return Xn(t)?"svg":"math"===t?"math":void 0},xn.config.isUnknownElement=function(t){if(!V)return!0;if(Gn(t))return!1;if(t=t.toLowerCase(),null!=Zn[t])return Zn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Zn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Zn[t]=/HTMLUnknownElement/.test(e.toString())},x(xn.options.directives,wo),x(xn.options.components,Po),xn.prototype.__patch__=V?po:k,xn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),en(t,"beforeMount"),r=function(){t._update(t._render(),n)},new vn(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&en(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,en(t,"mounted")),t}(this,t=t&&V?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},V&&setTimeout((function(){L.devtools&&et&&et.emit("init",xn)}),0),xn}));
\ No newline at end of file
diff --git a/src/platforms/web/runtime/components/transition-group.ts b/src/platforms/web/runtime/components/transition-group.ts
index 312d6124095..3dd93090a5e 100644
--- a/src/platforms/web/runtime/components/transition-group.ts
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -10,7 +10,7 @@
 // nodes will remain where they should be.
 
 import { warn, extend } from 'core/util/index'
-import { addClass, removeClass } from '../class-util'
+import { addClass, removeClass } from 'web/runtime/class-util'
 import { transitionProps, extractTransitionData } from './transition'
 import { setActiveInstance } from 'core/instance/lifecycle'
 
@@ -20,7 +20,7 @@ import {
   transitionEndEvent,
   addTransitionClass,
   removeTransitionClass,
-} from '../transition-util'
+} from 'web/runtime/transition-util'
 import VNode from 'core/vdom/vnode'
 
 const props = extend(
diff --git a/src/platforms/web/runtime/directives/show.ts b/src/platforms/web/runtime/directives/show.ts
index f1219a9751d..bd59c79ee8c 100644
--- a/src/platforms/web/runtime/directives/show.ts
+++ b/src/platforms/web/runtime/directives/show.ts
@@ -1,7 +1,8 @@
 
 import VNode from 'core/vdom/vnode'
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
-import { enter, leave } from '../modules/transition'
+import { enter, leave } from 'web/runtime/modules/transition'
+
 
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode: VNode | VNodeWithData): VNodeWithData {
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index c91f3e185f4..ebed6480666 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -5,13 +5,13 @@ import { activeInstance } from 'core/instance/lifecycle'
 
 import { once, isDef, isUndef, isObject, toNumber } from 'shared/util'
 
-import {
+import { 
   nextFrame,
   resolveTransition,
   whenTransitionEnds,
   addTransitionClass,
-  removeTransitionClass,
-} from '../transition-util'
+  removeTransitionClass } from 'web/runtime/transition-util'
+
 import type { VNodeWithData } from 'typescript/vnode'
 import VNode from 'core/vdom/vnode'
 
diff --git a/src/platforms/web/runtime/transition-util.ts b/src/platforms/web/runtime/transition-util.ts
index 43211877420..f18090e4e10 100644
--- a/src/platforms/web/runtime/transition-util.ts
+++ b/src/platforms/web/runtime/transition-util.ts
@@ -1,5 +1,5 @@
 import { inBrowser, isIE9 } from 'core/util/index'
-import { addClass, removeClass } from './class-util'
+import { addClass, removeClass } from 'web/runtime/class-util'
 import { remove, extend, cached } from 'shared/util'
 
 export function resolveTransition(

From f22b2165f464e44767a30f15c791e072ac30c824 Mon Sep 17 00:00:00 2001
From: pikax <carlos@hypermob.co.uk>
Date: Tue, 13 Apr 2021 16:21:54 +0100
Subject: [PATCH 020/317] chore: improve some types and remove @ts-ignore

---
 dist/vue.common.dev.js                        |   658 +-
 dist/vue.common.prod.js                       |     2 +-
 dist/vue.esm.browser.js                       |   629 +-
 dist/vue.esm.browser.min.js                   |     2 +-
 dist/vue.esm.js                               |   658 +-
 dist/vue.js                                   |   658 +-
 dist/vue.min.js                               |     2 +-
 dist/vue.runtime.common.dev.js                |   657 +-
 dist/vue.runtime.common.prod.js               |     2 +-
 dist/vue.runtime.esm.js                       |   657 +-
 dist/vue.runtime.js                           | 12645 ++++++++--------
 packages/vue-server-renderer/basic.js         |     1 -
 packages/vue-server-renderer/build.dev.js     |     1 -
 packages/vue-template-compiler/browser.js     |     2 -
 packages/vue-template-compiler/build.js       |     2 -
 src/core/config.ts                            |     2 +-
 src/core/instance/index.ts                    |    43 +-
 src/core/instance/init.ts                     |     3 +-
 src/core/instance/inject.ts                   |     3 +-
 src/core/instance/lifecycle.ts                |   305 +-
 src/core/observer/index.ts                    |     8 +-
 src/core/util/debug.ts                        |    12 +-
 src/core/util/env.ts                          |    12 +-
 src/core/util/options.ts                      |     2 -
 src/core/util/props.ts                        |     3 +-
 src/core/vdom/helpers/extract-props.ts        |     2 +-
 src/core/vdom/modules/ref.ts                  |    48 +-
 src/core/vdom/vnode.ts                        |   141 +-
 src/global.d.ts                               |    15 +
 src/platforms/web/compiler/modules/class.ts   |     2 +-
 src/platforms/web/compiler/modules/model.ts   |     2 +-
 src/platforms/web/compiler/modules/style.ts   |     2 +-
 src/platforms/web/compiler/options.ts         |    14 +-
 .../runtime/components/transition-group.ts    |   193 +-
 src/platforms/weex/compiler/index.ts          |     3 +-
 src/platforms/weex/compiler/modules/append.ts |     2 +-
 src/platforms/weex/compiler/modules/class.ts  |     2 +-
 src/platforms/weex/compiler/modules/props.ts  |     2 +-
 .../compiler/modules/recycle-list/index.ts    |     2 +-
 .../compiler/modules/recycle-list/v-if.ts     |    52 +-
 src/platforms/weex/compiler/modules/style.ts  |     6 +-
 src/platforms/weex/entry-framework.ts         |     3 +-
 src/platforms/weex/runtime/index.ts           |     4 +-
 src/platforms/weex/types.d.ts                 |     7 +
 src/platforms/weex/util/element.ts            |    41 +-
 src/shared/util.ts                            |     3 +-
 tsconfig.json                                 |     3 +
 typescript/compiler.d.ts                      |    14 +-
 typescript/component.d.ts                     |    23 +-
 typescript/options.d.ts                       |     3 +
 typescript/vnode.d.ts                         |    24 +-
 51 files changed, 7009 insertions(+), 10573 deletions(-)
 create mode 100644 src/platforms/weex/types.d.ts

diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index 766f3a8b429..cc22c8131a7 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -6758,12 +6758,12 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$2 = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass$1(el, cls) {
+function addClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6771,7 +6771,7 @@ function addClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6788,7 +6788,7 @@ function addClass$1(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass$1(el, cls) {
+function removeClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6796,7 +6796,7 @@ function removeClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6821,7 +6821,7 @@ function removeClass$1(el, cls) {
     }
 }
 
-function resolveTransition$1(def) {
+function resolveTransition(def) {
     if (!def) {
         return;
     }
@@ -6829,16 +6829,16 @@ function resolveTransition$1(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition$1(def.name || 'v'));
+            extend(res, autoCssTransition(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition$1(def);
+        return autoCssTransition(def);
     }
 }
-var autoCssTransition$1 = cached(function (name) {
+var autoCssTransition = cached(function (name) {
     return {
         enterClass: (name + "-enter"),
         enterToClass: (name + "-enter-to"),
@@ -6848,62 +6848,62 @@ var autoCssTransition$1 = cached(function (name) {
         leaveActiveClass: (name + "-leave-active"),
     };
 });
-var hasTransition$1 = inBrowser && !isIE9;
-var TRANSITION$1 = 'transition';
-var ANIMATION$1 = 'animation';
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp$1 = 'transition';
-var transitionEndEvent$1 = 'transitionend';
-var animationProp$1 = 'animation';
-var animationEndEvent$1 = 'animationend';
-if (hasTransition$1) {
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp$1 = 'WebkitTransition';
-        transitionEndEvent$1 = 'webkitTransitionEnd';
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp$1 = 'WebkitAnimation';
-        animationEndEvent$1 = 'webkitAnimationEnd';
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf$1 = inBrowser
+var raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame$1(fn) {
-    raf$1(function () {
+function nextFrame(fn) {
+    raf(function () {
         // @ts-expect-error
-        raf$1(fn);
+        raf(fn);
     });
 }
-function addTransitionClass$1(el, cls) {
+function addTransitionClass(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass$1(el, cls);
+        addClass(el, cls);
     }
 }
-function removeTransitionClass$1(el, cls) {
+function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass$1(el, cls);
+    removeClass(el, cls);
 }
-function whenTransitionEnds$1(el, expectedType, cb) {
-    var ref = getTransitionInfo$1(el, expectedType);
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
     var type = ref.type;
     var timeout = ref.timeout;
     var propCount = ref.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -6923,30 +6923,30 @@ function whenTransitionEnds$1(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE$1 = /\b(transform|all)(,|$)/;
-function getTransitionInfo$1(el, expectedType) {
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION$1) {
+    if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
-            type = TRANSITION$1;
+            type = TRANSITION;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION$1) {
+    else if (expectedType === ANIMATION) {
         if (animationTimeout > 0) {
-            type = ANIMATION$1;
+            type = ANIMATION;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6956,16 +6956,16 @@ function getTransitionInfo$1(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION$1
-                    : ANIMATION$1
+                    ? TRANSITION
+                    : ANIMATION
                 : null;
         propCount = type
-            ? type === TRANSITION$1
+            ? type === TRANSITION
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -6973,31 +6973,31 @@ function getTransitionInfo$1(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout$1(delays, durations) {
+function getTimeout(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs$1(d) + toMs$1(delays[i]);
+        return toMs(d) + toMs(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs$1(s) {
+function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter$1(vnode, toggleDisplay) {
+function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7051,19 +7051,19 @@ function enter$1(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
-        checkDuration$1(explicitEnterDuration, 'enter', vnode);
+        checkDuration(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(enterHook);
+    var userWantsControl = getHookArgumentsLength(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass$1(el, toClass);
-            removeTransitionClass$1(el, activeClass);
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, startClass);
+                removeTransitionClass(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -7088,19 +7088,19 @@ function enter$1(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass$1(el, startClass);
-        addTransitionClass$1(el, activeClass);
-        nextFrame$1(function () {
-            removeTransitionClass$1(el, startClass);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass$1(el, toClass);
+                addTransitionClass(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration$1(explicitEnterDuration)) {
+                    if (isValidDuration(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds$1(el, type, cb);
+                        whenTransitionEnds(el, type, cb);
                     }
                 }
             }
@@ -7114,14 +7114,14 @@ function enter$1(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave$1(vnode, rm) {
+function leave(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7141,23 +7141,23 @@ function leave$1(vnode, rm) {
     var delayLeave = data.delayLeave;
     var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(leave);
+    var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
-        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass$1(el, leaveToClass);
-            removeTransitionClass$1(el, leaveActiveClass);
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, leaveClass);
+                removeTransitionClass(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -7185,19 +7185,19 @@ function leave$1(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass$1(el, leaveClass);
-            addTransitionClass$1(el, leaveActiveClass);
-            nextFrame$1(function () {
-                removeTransitionClass$1(el, leaveClass);
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass$1(el, leaveToClass);
+                    addTransitionClass(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration$1(explicitLeaveDuration)) {
+                        if (isValidDuration(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds$1(el, type, cb);
+                            whenTransitionEnds(el, type, cb);
                         }
                     }
                 }
@@ -7210,7 +7210,7 @@ function leave$1(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration$1(val, name, vnode) {
+function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
             "got " + (JSON.stringify(val)) + ".", vnode.context);
@@ -7220,7 +7220,7 @@ function checkDuration$1(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration$1(val) {
+function isValidDuration(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -7229,7 +7229,7 @@ function isValidDuration$1(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength$1(fn) {
+function getHookArgumentsLength(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -7237,7 +7237,7 @@ function getHookArgumentsLength$1(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -7246,7 +7246,7 @@ function getHookArgumentsLength$1(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter$1(vnode);
+        enter(vnode);
     }
 }
 var transition = inBrowser
@@ -7257,7 +7257,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave$1(vnode, rm);
+                leave(vnode, rm);
             }
             else {
                 rm();
@@ -7405,493 +7405,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-var whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        var res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-var autoCssTransition = cached(function (name) {
-    return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
-    };
-});
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
-// Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        // @ts-expect-error
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        // @ts-expect-error
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    var onEnd = function (e) {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(function () {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    var el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    var cb = (el._leaveCb = once(function () {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2("<transition> explicit " + name + " duration is NaN - " +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -8823,7 +8336,6 @@ function parseHTML(html, options) {
     }
 }
 
-// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
index a1acfb920e0..d3d9edb5dac 100644
--- a/dist/vue.common.prod.js
+++ b/dist/vue.common.prod.js
@@ -8,4 +8,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,C=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function A(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function k(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&k(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every((function(e,n){return E(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return E(e[n],t[n])}))}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M},F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+F.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,ae="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var oe=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ce.target=null;var le=[];function ue(e){le.push(e),ce.target=e}function fe(){le.pop(),ce.target=le[le.length-1]}var pe=function(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(pe.prototype,de);var ve=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function he(e){return new pe(void 0,void 0,void 0,String(e))}function me(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ye[e];R(ge,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,a=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&o.observeArray(i),o.dep.notify(),a}))}));var _e=Object.getOwnPropertyNames(ge),be=!0;function $e(e){be=e}var we=function(e){this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?function(e,t){e.__proto__=t}(e,ge):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];R(e,a,t[a])}}(e,ge,_e),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(a(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof we?n=e.__ob__:be&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new we(e)),t&&n&&n.vmCount++,n}function xe(e,t,n,r,i){var a=new ce,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&Oe(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&Ce(t),a.notify())}})}}function Ae(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(xe(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Oe(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Oe(t)}we.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)xe(e,t[n])},we.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Se=I.optionMergeStrategies;function Te(e,t){if(!t)return e;for(var n,r,i,a=ae?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Te(r,i):Ae(e,n,i));return e}function Ne(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Te(r,i):i}:t?e?function(){return Te("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ee(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function Le(e,t,n,r){var i=Object.create(e||null);return t?k(i,t):i}Se.data=function(e,t,n){return n?Ne(e,t,n):t&&"function"!=typeof t?e:Ne(e,t)},M.forEach((function(e){Se[e]=Ee})),D.forEach((function(e){Se[e+"s"]=Le})),Se.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in k(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Se.props=Se.methods=Se.inject=Se.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return k(i,e),t&&k(i,t),i},Se.provide=Ne;var je=function(e,t){return void 0===t?e:t};function De(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?k({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=De(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=De(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Se[r]||je;o[r]=i(e[r],t[r],n,r)}return o}function Me(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function Ie(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=He(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=He(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Pe(t.type)?r.call(e):r}(r,i,e);var l=be;$e(!0),Ce(o),$e(l)}return o}var Fe=/^\s*function (\w+)/;function Pe(e){var t=e&&e.toString().match(Fe);return t?t[1]:""}function Re(e,t){return Pe(e)===Pe(t)}function He(e,t){if(!Array.isArray(t))return Re(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Re(t[n],e))return n;return-1}function Be(e,t,n){ue();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){ze(e,r,"errorCaptured hook")}}ze(e,t,n)}finally{fe()}}function Ue(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch((function(e){return Be(e,r,i+" (Promise/async)")})),a._handled=!0)}catch(e){Be(e,r,i)}return a}function ze(e,t,n){if(I.errorHandler)try{return I.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ve(t)}Ve(e)}function Ve(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var Ke,qe=!1,Je=[],We=!1;function Ze(){We=!1;var e=Je.slice(0);Je.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var Ge=Promise.resolve();Ke=function(){Ge.then(Ze),Z&&setTimeout(S)},qe=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ke="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Ze)}:function(){setTimeout(Ze,0)};else{var Xe=1,Ye=new MutationObserver(Ze),Qe=document.createTextNode(String(Xe));Ye.observe(Qe,{characterData:!0}),Ke=function(){Xe=(Xe+1)%2,Qe.data=String(Xe)},qe=!0}function et(e,t){var n;if(Je.push((function(){if(e)try{e.call(t)}catch(e){Be(e,t,"nextTick")}else n&&n(t)})),We||(We=!0,Ke()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var tt=new ie;function nt(e){rt(e,tt),tt.clear()}function rt(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!a(e)||Object.isFrozen(e)||e instanceof pe)){if(e.__ob__){var o=e.__ob__.dep.id;if(t.has(o))return;t.add(o)}if(i)for(n=e.length;n--;)rt(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)rt(e[r[n]],t)}}var it=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function at(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return Ue(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)Ue(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function ot(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=it(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=at(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=it(c)).name,n[c],f.capture)}function st(e,i,a){var o;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=at([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=at([s,c]),o.merged=!0,e[i]=o}function ct(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function lt(e){return i(e)?[he(e)]:Array.isArray(e)?ft(e):void 0}function ut(e){return n(e)&&n(e.text)&&!1===e.isComment}function ft(e,a){var o,s,c,l,u=[];for(o=0;o<e.length;o++)t(s=e[o])||"boolean"==typeof s||(l=u[c=u.length-1],Array.isArray(s)?s.length>0&&(ut((s=ft(s,(a||"")+"_"+o))[0])&&ut(l)&&(u[c]=he(l.text+s[0].text),s.shift()),u.push.apply(u,s)):i(s)?ut(l)?u[c]=he(l.text+s):""!==s&&u.push(he(s)):ut(s)&&ut(l)?u[c]=he(l.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(a)&&(s.key="__vlist"+a+"_"+o+"__"),u.push(s)));return u}function pt(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function dt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(vt)&&delete n[l];return n}function vt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ht(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=mt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=yt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",o),R(i,"$key",s),R(i,"$hasNormal",a),i}function mt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:lt(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function yt(e,t){return function(){return e[t]}}function gt(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(ae&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function _t(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=k(k({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function bt(e){return Me(this.$options,"filters",e)||N}function $t(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function wt(e,t,n,r,i){var a=I.keyCodes[t]||n;return i&&r&&!I.keyCodes[t]?$t(i,r):a?$t(a,e):r?C(r)!==t:void 0}function Ct(e,t,n,r,i){if(n)if(a(n)){var o;Array.isArray(n)&&(n=O(n));var s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||I.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function xt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||kt(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function At(e,t,n){return kt(e,"__once__"+t+(n?"_"+n:""),!0),e}function kt(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ot(e[r],t+"_"+r,n);else Ot(e,t,n)}function Ot(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function St(e,t){if(t)if(s(t)){var n=e.on=e.on?k({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function Tt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?Tt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function Nt(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Et(e,t){return"string"==typeof e?t+e:e}function Lt(e){e._o=At,e._n=f,e._s=u,e._l=gt,e._t=_t,e._q=E,e._i=L,e._m=xt,e._f=bt,e._k=wt,e._b=Ct,e._v=he,e._e=ve,e._u=Tt,e._g=St,e._d=Nt,e._p=Et}function jt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=pt(l.inject,a),this.slots=function(){return c.$slots||ht(t.scopedSlots,c.$slots=dt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ht(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=ht(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Ht(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Ht(s,e,t,n,r,f)}}function Dt(e,t,n,r,i){var a=me(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function Mt(e,t){for(var n in t)e[b(n)]=t[n]}Lt(jt.prototype);var It={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;It.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Xt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){$e(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=Ie(d,v,n,t)}$e(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Gt(t,r,h),l&&(t.$slots=dt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,nn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,an.push(t)):en(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?tn(t,!0):t.$destroy())}},Ft=Object.keys(It);function Pt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=zt;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",(function(){return h(s,o)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j((function(t){e.resolved=Vt(t,i),c?s.length=0:p(!0)})),v=j((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Vt(m.error,i)),n(m.loading)&&(e.loadingComp=Vt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout((function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=ve();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},An(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);ct(o,c,l,u,!0)||ct(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=Ie(u,l,r||e);else n(i.attrs)&&Mt(c,i.attrs),n(i.props)&&Mt(c,i.props);var f=new jt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Dt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=lt(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Dt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Ft.length;n++){var r=Ft[n],i=t[r],a=It[r];i===a||i&&i._merged||(t[r]=i?Rt(a,i):a)}}(o);var y=i.options.name||u;return new pe("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Rt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Ht(e,t,o,s,c,l){return(Array.isArray(o)||i(o))&&(c=s,s=o,o=void 0),r(l)&&(c=2),function(e,t,r,i,o){if(n(r)&&n(r.__ob__))return ve();n(r)&&n(r.is)&&(t=r.is);if(!t)return ve();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===o?i=lt(i):1===o&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var l;c=e.$vnode&&e.$vnode.ns||I.getTagNamespace(t),s=I.isReservedTag(t)?new pe(I.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(l=Me(e.$options,"components",t))?new pe(t,r,i,void 0,void 0,e):Pt(l,r,e,i,t)}else s=Pt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Bt(s,c),n(r)&&function(e){a(e.style)&&nt(e.style);a(e.class)&&nt(e.class)}(r),s):ve()}(e,t,o,s,c)}function Bt(e,i,a){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,a=!0),n(e.children))for(var o=0,s=e.children.length;o<s;o++){var c=e.children[o];n(c.tag)&&(t(c.ns)||r(a)&&"svg"!==c.tag)&&Bt(c,i,a)}}var Ut,zt=null;function Vt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function Kt(e){return e.isComment&&e.asyncFactory}function qt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Kt(r)))return r}}function Jt(e,t){Ut.$on(e,t)}function Wt(e,t){Ut.$off(e,t)}function Zt(e,t){var n=Ut;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Gt(e,t,n){Ut=e,ot(t,n||{},Jt,Wt,Zt,e),Ut=void 0}var Xt=null;function Yt(e){var t=Xt;return Xt=e,function(){Xt=t}}function Qt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function en(e,t){if(t){if(e._directInactive=!1,Qt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)en(e.$children[n]);nn(e,"activated")}}function tn(e,t){if(!(t&&(e._directInactive=!0,Qt(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);nn(e,"deactivated")}}function nn(e,t){ue();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)Ue(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var rn=[],an=[],on={},sn=!1,cn=!1,ln=0;var un=0,fn=Date.now;if(U&&!q){var pn=window.performance;pn&&"function"==typeof pn.now&&fn()>document.createEvent("Event").timeStamp&&(fn=function(){return pn.now()})}function dn(){var e,t;for(un=fn(),cn=!0,rn.sort((function(e,t){return e.id-t.id})),ln=0;ln<rn.length;ln++)(e=rn[ln]).before&&e.before(),t=e.id,on[t]=null,e.run();var n=an.slice(),r=rn.slice();ln=rn.length=an.length=0,on={},sn=cn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,en(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&nn(r,"updated")}}(r),ne&&I.devtools&&ne.emit("flush")}var vn=0,hn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++vn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};hn.prototype.get=function(){var e;ue(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Be(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&nt(e),fe(),this.cleanupDeps()}return e},hn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},hn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},hn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==on[t]){if(on[t]=!0,cn){for(var n=rn.length-1;n>ln&&rn[n].id>e.id;)n--;rn.splice(n+1,0,e)}else rn.push(e);sn||(sn=!0,et(dn))}}(this)},hn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Be(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},hn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},hn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},hn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var mn={enumerable:!0,configurable:!0,get:S,set:S};function yn(e,t,n){mn.get=function(){return this[t][n]},mn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,mn)}function gn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var a=function(a){i.push(a);var o=Ie(a,t,n,e);xe(r,a,o),a in e||yn(e,"_props",a)};for(var o in t)a(o);$e(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){ue();try{return e.call(t,t)}catch(e){return Be(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||P(a)||yn(e,"_data",a)}Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new hn(e,o||S,S,_n)),i in e||bn(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(e,n,r[i]);else Cn(e,n,r)}}(e,t.watch)}var _n={lazy:!0};function bn(e,t,n){var r=!te();"function"==typeof n?(mn.get=r?$n(t):wn(n),mn.set=S):(mn.get=n.get?r&&!1!==n.cache?$n(t):wn(n.get):S,mn.set=n.set||S),Object.defineProperty(e,t,mn)}function $n(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function wn(e){return function(){return e.call(this,this)}}function Cn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var xn=0;function An(e){var t=e.options;if(e.super){var n=An(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&k(e.extendOptions,r),(t=e.options=De(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function kn(e){this._init(e)}function On(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=De(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)yn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)bn(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,D.forEach((function(e){o[e]=n[e]})),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=k({},o.options),i[r]=o,o}}function Sn(e){return e&&(e.Ctor.options.name||e.tag)}function Tn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function Nn(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=Sn(o.componentOptions);s&&!t(s)&&En(n,a,r,i)}}}function En(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=xn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=De(An(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Gt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=dt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Ht(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Ht(t,e,n,r,i,!0)};var a=r&&r.data;xe(t,"$attrs",a&&a.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),nn(n,"beforeCreate"),function(e){var t=pt(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach((function(n){xe(e,n,t[n])})),$e(!0))}(n),gn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),nn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(kn),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=Ae,e.prototype.$delete=ke,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return Cn(r,e,t,n);(n=n||{}).user=!0;var i=new hn(r,e,t,n);if(n.immediate){ue();try{t.call(r,i.value)}catch(e){Be(e,r,'callback for immediate watcher "'+i.expression+'"')}fe()}return function(){i.teardown()}}}(kn),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),i='event handler for "'+e+'"',a=0,o=n.length;a<o;a++)Ue(n[a],t,r,t,i)}return t}}(kn),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Yt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){nn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),nn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(kn),function(e){Lt(e.prototype),e.prototype.$nextTick=function(e){return et(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ht(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{zt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Be(n,t,"render"),e=t._vnode}finally{zt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=ve()),e.parent=i,e}}(kn);var Ln=[String,RegExp,Array],jn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Ln,exclude:Ln,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)En(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){Nn(e,(function(e){return Tn(t,e)}))})),this.$watch("exclude",(function(t){Nn(e,(function(e){return!Tn(t,e)}))}))},render:function(){var e=this.$slots.default,t=qt(e),n=t&&t.componentOptions;if(n){var r=Sn(n),i=this.include,a=this.exclude;if(i&&(!r||!Tn(i,r))||a&&r&&Tn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&En(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return I}};Object.defineProperty(e,"config",t),e.util={warn:oe,extend:k,mergeOptions:De,defineReactive:xe},e.set=Ae,e.delete=ke,e.nextTick=et,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),D.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,k(e.options.components,jn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=De(this.options,e),this}}(e),On(e),function(e){D.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(kn),Object.defineProperty(kn.prototype,"$isServer",{get:te}),Object.defineProperty(kn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(kn,"FunctionalRenderContext",{value:jt}),kn.version="2.6.12";var Dn=p("style,class"),Mn=p("input,textarea,option,select,progress"),In=p("contenteditable,draggable,spellcheck"),Fn=p("events,caret,typing,plaintext-only"),Pn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Rn="http://www.w3.org/1999/xlink",Hn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Bn=function(e){return Hn(e)?e.slice(6,e.length):""},Un=function(e){return null==e||!1===e};function zn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Vn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Vn(t,r.data));return function(e,t){if(n(e)||n(t))return Kn(e,qn(t));return""}(t.staticClass,t.class)}function Vn(e,t){return{staticClass:Kn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Kn(e,t){return e?t?e+" "+t:e:t||""}function qn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=qn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Jn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Wn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(e){return Wn(e)||Zn(e)};var Xn=Object.create(null);var Yn=p("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Jn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Yn(i)&&Yn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function ar(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var or={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===nr,o=t===nr,s=lr(e.data.directives,e.context),c=lr(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)fr(l[n],"inserted",t,e)};a?st(t,"insert",f):f()}u.length&&st(t,"postpatch",(function(){for(var n=0;n<u.length;n++)fr(u[n],"componentUpdated",t,e)}));if(!a)for(n in s)c[n]||fr(s[n],"unbind",e,e,o)}(e,t)}var cr=Object.create(null);function lr(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[ur(r)]=r,r.def=Me(t.$options,"directives",r.name);return i}function ur(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Be(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,or];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=k({},l)),l)o=l[a],c[a]!==o&&vr(s,a,o,r.data.pre);for(a in(q||W)&&l.value!==c.value&&vr(s,"value",l.value),c)t(l[a])&&(Hn(a)?s.removeAttributeNS(Rn,Bn(a)):In(a)||s.removeAttribute(a))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):Pn(t)?Un(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):In(t)?e.setAttribute(t,function(e,t){return Un(t)||"false"===t?"false":"contenteditable"===e&&Fn(t)?t:"true"}(t,n)):Hn(t)?Un(n)?e.removeAttributeNS(Rn,Bn(t)):e.setAttributeNS(Rn,t,n):hr(e,t,n)}function hr(e,t,n){if(Un(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=zn(r),c=i._transitionClasses;n(c)&&(s=Kn(s,qn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},Ar=/[\w).+\-_$\]]/;function kr(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&Ar.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=Or(i,a[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Er(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Lr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function jr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Dr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Dr("!",n,c)),i.once&&(delete i.once,n=Dr("~",n,c)),i.passive&&(delete i.passive,n=Dr("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Rr({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return kr(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,a="$$v",o=a;r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var s=Br(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?qr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))qr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function qr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var Jr;function Wr(e,t,n){var r=Jr;return function i(){var a=t.apply(null,arguments);null!==a&&Xr(e,i,n,r)}}var Zr=qe&&!(X&&Number(X[1])<=53);function Gr(e,t,n,r){if(Zr){var i=un,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Jr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Xr(e,t,n,r){(r||Jr).removeEventListener(e,t._wrapper||t,n)}function Yr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Jr=r.elm,function(e){if(n(e.__r)){var t=q?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),ot(i,a,Gr,Xr,Wr,r.context),Jr=void 0}}var Qr,ei={create:Yr,update:Yr};function ti(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=k({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ni(o,l)&&(o.value=l)}else if("innerHTML"===i&&Zn(o.tagName)&&t(o.innerHTML)){(Qr=Qr||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=Qr.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ni(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ri={create:ti,update:ti},ii=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function ai(e){var t=oi(e.style);return e.staticStyle?k(e.staticStyle,t):t}function oi(e){return Array.isArray(e)?O(e):"string"==typeof e?ii(e):e}var si,ci=/^--/,li=/\s*!important$/,ui=function(e,t,n){if(ci.test(t))e.style.setProperty(t,n);else if(li.test(n))e.style.setProperty(C(t),n.replace(li,""),"important");else{var r=pi(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},fi=["Webkit","Moz","ms"],pi=g((function(e){if(si=si||document.createElement("div").style,"filter"!==(e=b(e))&&e in si)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<fi.length;n++){var r=fi[n]+t;if(r in si)return r}}));function di(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=oi(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?k({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ai(i.data))&&k(r,n);(n=ai(e.data))&&k(r,n);for(var a=e;a=a.parent;)a.data&&(n=ai(a.data))&&k(r,n);return r}(r,!0);for(s in f)t(d[s])&&ui(c,s,"");for(s in d)(o=d[s])!==f[s]&&ui(c,s,null==o?"":o)}}var vi={create:di,update:di},hi=/\s+/;function mi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,yi(e.name||"v")),k(t,e),t}return"string"==typeof e?yi(e):void 0}}var yi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),gi="transition",_i="transitionend",bi="animation",$i="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(gi="WebkitTransition",_i="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(bi="WebkitAnimation",$i="webkitAnimationEnd"));var wi=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ci(e){wi((function(){wi(e)}))}function xi(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Ai(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function ki(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[gi+"Delay"]||"").split(", "),a=(r[gi+"Duration"]||"").split(", "),o=Si(i,a),s=(r[bi+"Delay"]||"").split(", "),c=(r[bi+"Duration"]||"").split(", "),l=Si(s,c),u=0,f=0;"transition"===t?o>0&&(n="transition",u=o,f=a.length):"animation"===t?l>0&&(n="animation",u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?"transition":"animation":null)?"transition"===n?a.length:c.length:0;var p="transition"===n&&Oi.test(r[gi+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s="transition"===i?_i:$i,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var Oi=/\b(transform|all)(,|$)/;function Si(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Ti(t)+Ti(e[n])})))}function Ti(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Ni(e){return"number"==typeof e&&!isNaN(e)}function Ei(e){if(t(e))return!1;var r=e.fns;return n(r)?Ei(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Li(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=mi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Xt,k=Xt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=Ei(L),R=i._enterCb=j((function(){F&&(Ai(i,N),Ai(i,T)),R.cancelled?(F&&Ai(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||st(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(xi(i,S),xi(i,T),Ci((function(){Ai(i,S),R.cancelled||(xi(i,N),P||(Ni(I)?setTimeout(R,I):ki(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var ji=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<rr.length;++a)for(s[rr[a]]=[],o=0;o<c.length;++o)n(c[o][rr[a]])&&s[rr[a]].push(c[o][rr[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=me(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){var a,o=e;for(;o.componentInstance;)if(n(a=(o=o.componentInstance._vnode).data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](nr,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(a=e.data.hook)&&(n(a.create)&&a.create(nr,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Xt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&ir(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=me(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=ar(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):ir(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function A(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var k=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(t,i);break}!v&&c.class&&nt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute("data-server-rendered")&&(e.removeAttribute("data-server-rendered"),a=!0),r(a)&&O(e,i,p))return A(i,p,!0),e;c=e,e=new pe(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var k=1;k<C.fns.length;k++)C.fns[k]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return A(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ei,ri,vi,U?{create:Li,activate:Li,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=mi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=Ei(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ai(i,u),Ai(i,p)),w.cancelled?(_&&Ai(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(xi(i,l),xi(i,p),Ci((function(){Ai(i,l),w.cancelled||(xi(i,u),b||(Ni($)?setTimeout(w,$):ki(i,c,w)))}))),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(pr)});J&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Bi(e,"input")}));var Di={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?st(n,"postpatch",(function(){Di.componentUpdated(e,t,n)})):Mi(e,t,n.context),e._vOptions=[].map.call(e.options,Pi)):("textarea"===n.tag||Yn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Ri),e.addEventListener("compositionend",Hi),e.addEventListener("change",Hi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Mi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Pi);if(i.some((function(e,t){return!E(e,r[t])})))(e.multiple?t.value.some((function(e){return Fi(e,i)})):t.value!==t.oldValue&&Fi(t.value,i))&&Bi(e,"change")}}};function Mi(e,t,n){Ii(e,t),(q||W)&&setTimeout((function(){Ii(e,t)}),0)}function Ii(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Pi(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Pi(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Fi(e,t){return t.every((function(t){return!E(t,e)}))}function Pi(e){return"_value"in e?e._value:e.value}function Ri(e){e.target.composing=!0}function Hi(e){e.target.composing&&(e.target.composing=!1,Bi(e.target,"input"))}function Bi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var Ui=/\s+/;function zi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ui).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Vi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ui).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function Ki(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,qi(e.name||"v")),k(t,e),t}return"string"==typeof e?qi(e):void 0}}var qi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),Ji=U&&!J,Wi="transition",Zi="transitionend",Gi="animation",Xi="animationend";Ji&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Wi="WebkitTransition",Zi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Gi="WebkitAnimation",Xi="webkitAnimationEnd"));var Yi=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Qi(e){Yi((function(){Yi(e)}))}function ea(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),zi(e,t))}function ta(e,t){e._transitionClasses&&h(e._transitionClasses,t),Vi(e,t)}function na(e,t,n){var r=ia(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s="transition"===i?Zi:Xi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var ra=/\b(transform|all)(,|$)/;function ia(e,t){var n,r=window.getComputedStyle(e),i=(r[Wi+"Delay"]||"").split(", "),a=(r[Wi+"Duration"]||"").split(", "),o=aa(i,a),s=(r[Gi+"Delay"]||"").split(", "),c=(r[Gi+"Duration"]||"").split(", "),l=aa(s,c),u=0,f=0;return"transition"===t?o>0&&(n="transition",u=o,f=a.length):"animation"===t?l>0&&(n="animation",u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?"transition":"animation":null)?"transition"===n?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:"transition"===n&&ra.test(r[Wi+"Property"])}}function aa(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return oa(t)+oa(e[n])})))}function oa(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function sa(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=Ki(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Xt,k=Xt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!J,P=la(L),R=i._enterCb=j((function(){F&&(ta(i,N),ta(i,T)),R.cancelled?(F&&ta(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||st(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(ea(i,S),ea(i,T),Qi((function(){ta(i,S),R.cancelled||(ea(i,N),P||(ca(I)?setTimeout(R,I):na(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function ca(e){return"number"==typeof e&&!isNaN(e)}function la(e){if(t(e))return!1;var r=e.fns;return n(r)?la(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ua(e){return!e.componentInstance||e.data&&e.data.transition?e:ua(e.componentInstance._vnode)}var fa={model:Di,show:{bind:function(e,t,n){var r=t.value,i=(n=ua(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,sa(n,(function(){e.style.display=a}))):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=ua(i)).data&&i.data.transition?(i.data.show=!0,o?sa(i,(function(){e.style.display=e.__vOriginalDisplay})):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=Ki(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!J,b=la(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(ta(i,u),ta(i,p)),w.cancelled?(_&&ta(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(ea(i,l),ea(i,p),Qi((function(){ta(i,l),w.cancelled||(ea(i,u),b||(ca($)?setTimeout(w,$):na(i,c,w)))}))),v&&v(i,w),_||b||w())}}(i,(function(){e.style.display="none"}))):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},pa={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function da(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?da(qt(t.children)):e}function va(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var a in i)t[b(a)]=i[a];return t}function ha(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var ma=function(e){return e.tag||Kt(e)},ya=function(e){return"show"===e.name},ga={name:"transition",props:pa,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(ma)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=da(a);if(!o)return a;if(this._leaving)return ha(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=va(this),l=this._vnode,u=da(l);if(o.data.directives&&o.data.directives.some(ya)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!Kt(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=k({},c);if("out-in"===r)return this._leaving=!0,st(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),ha(e,a);if("in-out"===r){if(Kt(o))return l;var p,d=function(){p()};st(c,"afterEnter",d),st(c,"enterCancelled",d),st(f,"delayLeave",(function(e){p=e}))}}return a}}},_a=k({tag:String,moveClass:String},pa);function ba(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function $a(e){e.data.newPos=e.elm.getBoundingClientRect()}function wa(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete _a.mode;var Ca={Transition:ga,TransitionGroup:{props:_a,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Yt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=va(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(a.push(c),n[c.key]=c,(c.data||(c.data={})).transition=o)}if(r){for(var l=[],u=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=o,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?l.push(p):u.push(p)}this.kept=e(t,null,l),this.removed=u}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(ba),e.forEach($a),e.forEach(wa),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;ea(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Zi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Zi,e),n._moveCb=null,ta(n,t))})}})))},methods:{hasMove:function(e,t){if(!Ji)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){Vi(n,e)})),zi(n,t),n.style.display="none",this.$el.appendChild(n);var r=ia(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};kn.config.mustUseProp=function(e,t,n){return"value"===n&&Mn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},kn.config.isReservedTag=Gn,kn.config.isReservedAttr=Dn,kn.config.getTagNamespace=function(e){return Zn(e)?"svg":"math"===e?"math":void 0},kn.config.isUnknownElement=function(e){if(!U)return!0;if(Gn(e))return!1;if(e=e.toLowerCase(),null!=Xn[e])return Xn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Xn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Xn[e]=/HTMLUnknownElement/.test(t.toString())},k(kn.options.directives,fa),k(kn.options.components,Ca),kn.prototype.__patch__=U?ji:S,kn.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),nn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new hn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&nn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,nn(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout((function(){I.devtools&&ne&&ne.emit("init",kn)}),0);var xa=p("input,textarea,option,select,progress"),Aa=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),ka=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function Oa(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var Sa=/\{\{((?:.|\r?\n)+?)\}\}/g,Ta=/[-.*+?^${}()|[\]\/\\]/g,Na=g((function(e){var t=e[0].replace(Ta,"\\$&"),n=e[1].replace(Ta,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var Ea={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var La,ja={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ii(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Da=function(e){return(La=La||document.createElement("div")).innerHTML=e,La.textContent},Ma=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ia=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Fa=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Pa="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+F.source+"]*",Ra="((?:"+Pa+"\\:)?"+Pa+")",Ha=new RegExp("^<"+Ra),Ba=/^\s*(\/?)>/,Ua=new RegExp("^<\\/"+Ra+"[^>]*>"),za=/^<!DOCTYPE [^>]+>/i,Va=/^<!\--/,Ka=/^<!\[/,qa=p("script,style,textarea",!0),Ja={},Wa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Za=/&(?:lt|gt|quot|amp|#39);/g,Ga=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Xa=p("pre,textarea",!0),Ya=function(e,t){return e&&Xa(e)&&"\n"===t[0]};function Qa(e,t){var n=t?Ga:Za;return e.replace(n,(function(e){return Wa[e]}))}var eo,to,no,ro,io,ao,oo,so,co=/^@|^v-on:/,lo=/^v-|^@|^:|^#/,uo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,fo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,po=/^\(|\)$/g,vo=/^\[.*\]$/,ho=/:(.*)$/,mo=/^:|^\.|^v-bind:/,yo=/\.[^.\]]+(?=[^\]]*$)/g,go=/^v-slot(:|$)|^#/,_o=/[\r\n]/,bo=/[ \f\t\r\n]+/g,$o=g(Da);function wo(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:To(t),rawAttrsMap:{},parent:n,children:[]}}function Co(e,t){eo=t.warn||Sr,ao=t.isPreTag||T,oo=t.mustUseProp||T,so=t.getTagNamespace||T,t.isReservedTag,no=Tr(t.modules,"transformNode"),ro=Tr(t.modules,"preTransformNode"),io=Tr(t.modules,"postTransformNode"),to=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=xo(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&ko(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&ko(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter((function(e){return!e.slotScope})),u(e),e.pre&&(s=!1),ao(e.tag)&&(c=!1);for(var f=0;f<io.length;f++)io[f](e,t)}function u(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&qa(r)){var l=0,u=r.toLowerCase(),f=Ja[u]||(Ja[u]=new RegExp("([\\s\\S]*?)(</"+u+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return l=r.length,qa(u)||"noscript"===u||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ya(u,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,k(u,c-l,c)}else{var d=e.indexOf("<");if(0===d){if(Va.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(Ka.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(za);if(m){C(m[0].length);continue}var y=e.match(Ua);if(y){var g=c;C(y[0].length),k(y[1],g,c);continue}var _=x();if(_){A(_),Ya(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Ua.test($)||Ha.test($)||Va.test($)||Ka.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Ha);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(Ba))&&(r=e.match(Fa)||e.match(Ia));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function A(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Ma(n)&&k(r),s(n)&&r===n&&k(n));for(var l=o(n)||!!c,u=e.attrs.length,f=new Array(u),p=0;p<u;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Qa(v,h)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,l,e.start,e.end)}function k(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}k()}(e,{warn:eo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||so(e);q&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];No.test(r.name)||(r.name=r.name.replace(Eo,""),t.push(r))}return t}(a));var d,v=wo(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<ro.length;h++)v=ro[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),ao(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Ao(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,ko(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l,u,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:$o(e):f.length?o?"condense"===o&&_o.test(e)?"":" ":a?" ":"":"")c||"condense"!==o||(e=e.replace(bo," ")),!s&&" "!==e&&(l=function(e,t){var n=t?Na(t):Sa;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=kr(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,to))?u={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(u={type:3,text:e}),u&&f.push(u)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function xo(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Er(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,go);if(r){var i=Oo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||"_empty_"}}else{var s=Pr(e,go);if(s){var c=e.scopedSlots||(e.scopedSlots={}),l=Oo(s),u=l.name,f=l.dynamic,p=c[u]=wo("template",[],e);p.slotTarget=u,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||"_empty_",e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<no.length;i++)e=no[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,lo.test(r))if(e.hasBindings=!0,(o=So(r.replace(lo,"")))&&(r=r.replace(yo,"")),mo.test(r))r=r.replace(mo,""),a=kr(a),(c=vo.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Br(a,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&oo(e.tag,e.attrsMap.type,r)?Nr(e,r,a,l[t],c):Er(e,r,a,l[t],c);else if(co.test(r))r=r.replace(co,""),(c=vo.test(r))&&(r=r.slice(1,-1)),Mr(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(lo,"")).match(ho),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),vo.test(f)&&(f=f.slice(1,-1),c=!0)),jr(e,r,i,a,f,c,o,l[t])}else Er(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&oo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",l[t])}(e),e}function Ao(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(uo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(po,""),i=r.match(fo);i?(n.alias=r.replace(fo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&k(e,n)}}function ko(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Oo(e){var t=e.name.replace(go,"");return t||"#"!==e.name[0]&&(t="default"),vo.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function So(e){var t=e.match(yo);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function To(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var No=/^xmlns:NS\d+/,Eo=/^NS\d+:/;function Lo(e){return wo(e.tag,e.attrsList.slice(),e.parent)}var jo=[Ea,ja,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Ir(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Fr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=Lo(e);Ao(c),Lr(c,"type","checkbox"),xo(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+a,ko(c,{exp:c.if,block:c});var l=Lo(e);Fr(l,"v-for",!0),Lr(l,"type","radio"),xo(l,t),ko(c,{exp:"("+n+")==='radio'"+a,block:l});var u=Lo(e);return Fr(u,"v-for",!0),Lr(u,":type",n),xo(u,t),ko(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}];var Do,Mo,Io={expectHTML:!0,modules:jo,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",a=Ir(e,"true-value")||"true",o=Ir(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?"__r":"input",u="$event.target.value";s&&(u="$event.target.value.trim()");o&&(u="_n("+u+")");var f=Br(t,u);c&&(f="if($event.target.composing)return;"+f);Nr(e,"value","("+t+")"),Mr(e,l,f,null,!0),(s||o)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!I.isReservedTag(a))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&xa(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Aa(e)||ka(e)},getTagNamespace:function(e){return ka(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(jo)},Fo=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function Po(e,t){e&&(Do=Fo(t.staticKeys||""),Mo=t.isReservedTag||T,Ro(e),Ho(e,!1))}function Ro(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Mo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Do)))}(e),1===e.type){if(!Mo(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Ro(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++){var o=e.ifConditions[i].block;Ro(o),o.static||(e.static=!1)}}}function Ho(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)Ho(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++)Ho(e.ifConditions[i].block,t)}}var Bo=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Uo=/\([^)]*?\);*$/,zo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Vo={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ko={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},qo=function(e){return"if("+e+")return null;"},Jo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:qo("$event.target !== $event.currentTarget"),ctrl:qo("!$event.ctrlKey"),shift:qo("!$event.shiftKey"),alt:qo("!$event.altKey"),meta:qo("!$event.metaKey"),left:qo("'button' in $event && $event.button !== 0"),middle:qo("'button' in $event && $event.button !== 1"),right:qo("'button' in $event && $event.button !== 2")};function Wo(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=Zo(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Zo(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return Zo(e)})).join(",")+"]";var t=zo.test(e.value),n=Bo.test(e.value),r=zo.test(e.value.replace(Uo,""));if(e.modifiers){var i="",a="",o=[];for(var s in e.modifiers)if(Jo[s])a+=Jo[s],Vo[s]&&o.push(s);else if("exact"===s){var c=e.modifiers;a+=qo(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else o.push(s);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Go).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Go(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Vo[e],r=Ko[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Xo={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Yo=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=k(k({},Xo),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Qo(e,t){var n=new Yo(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":es(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function es(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return ts(e,t);if(e.once&&!e.onceProcessed)return ns(e,t);if(e.for&&!e.forProcessed)return as(e,t);if(e.if&&!e.ifProcessed)return rs(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=ls(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?ps((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:ls(t,n,!0);return"_c("+e+","+os(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=os(e,t));var i=e.inlineTemplate?null:ls(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return ls(e,t)||"void 0"}function ts(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+es(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function ns(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return rs(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+es(e,t)+","+t.onceId+++","+n+")":es(e,t)}return ts(e,t)}function rs(e,t,n,r){return e.ifProcessed=!0,is(e.ifConditions.slice(),t,n,r)}function is(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+a(i.block)+":"+is(e,t,n,r):""+a(i.block);function a(e){return n?n(e,t):e.once?ns(e,t):es(e,t)}}function as(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||es)(e,t)+"})"}function os(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+ps(e.attrs)+","),e.props&&(n+="domProps:"+ps(e.props)+","),e.events&&(n+=Wo(e.events,!1)+","),e.nativeEvents&&(n+=Wo(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||ss(n)})),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&"_empty_"!==a.slotScope||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map((function(e){return cs(t[e],n)})).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Qo(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+ps(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function ss(e){return 1===e.type&&("slot"===e.tag||e.children.some(ss))}function cs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return rs(e,t,cs,"null");if(e.for&&!e.forProcessed)return as(e,t,cs);var r="_empty_"===e.slotScope?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(ls(e,t)||"undefined")+":undefined":ls(e,t)||"undefined":es(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function ls(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||es)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(us(i)||i.ifConditions&&i.ifConditions.some((function(e){return us(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||fs;return"["+a.map((function(e){return l(e,t)})).join(",")+"]"+(c?","+c:"")}}function us(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function fs(e,t){return 1===e.type?es(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:ds(JSON.stringify(e.text)))+")"}(e)}function ps(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=ds(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ds(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function vs(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function hs(e){var t=Object.create(null);return function(n,r,i){(r=k({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=vs(o.render,c),s.staticRenderFns=o.staticRenderFns.map((function(e){return vs(e,c)})),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ms,ys,gs=(ms=function(e,t){var n=Co(e.trim(),t);!1!==t.optimize&&Po(n,t);var r=Qo(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=k(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=ms(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:hs(t)}})(Io).compileToFunctions;function _s(e){return(ys=ys||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ys.innerHTML.indexOf("&#10;")>0}var bs=!!U&&_s(!1),$s=!!U&&_s(!0),ws=g((function(e){var t=Oa(e);return t&&t.innerHTML})),Cs=kn.prototype.$mount;kn.prototype.$mount=function(e,t){if((e=e&&Oa(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ws(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=gs(r,{outputSourceRange:!1,shouldDecodeNewlines:bs,shouldDecodeNewlinesForHref:$s,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return Cs.call(this,e,t)},kn.compile=gs,module.exports=kn;
\ No newline at end of file
+"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,C=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},E=function(e){return e};function N(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every((function(e,n){return N(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return N(e[n],t[n])}))}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(N(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:M},F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+F.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(pe.prototype,de);var ve=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function he(e){return new pe(void 0,void 0,void 0,String(e))}function me(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ye[e];R(ge,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var _e=Object.getOwnPropertyNames(ge),be=!0;function $e(e){be=e}var we=function(e){this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?function(e,t){e.__proto__=t}(e,ge):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ge,_e),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof we?n=e.__ob__:be&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new we(e)),t&&n&&n.vmCount++,n}function xe(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&Oe(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&Ce(t),o.notify())}})}}function ke(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(xe(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Ae(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Oe(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Oe(t)}we.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)xe(e,t[n])},we.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Se=I.optionMergeStrategies;function Te(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Te(r,i):ke(e,n,i));return e}function Ee(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Te(r,i):i}:t?e?function(){return Te("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ne(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function je(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Se.data=function(e,t,n){return n?Ee(e,t,n):t&&"function"!=typeof t?e:Ee(e,t)},M.forEach((function(e){Se[e]=Ne})),L.forEach((function(e){Se[e+"s"]=je})),Se.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Se.props=Se.methods=Se.inject=Se.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Se.provide=Ee;var De=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Se[r]||De;a[r]=i(e[r],t[r],n,r)}return a}function Me(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Ie(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=He(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=He(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Pe(t.type)?r.call(e):r}(r,i,e);var u=be;$e(!0),Ce(a),$e(u)}return a}var Fe=/^\s*function (\w+)/;function Pe(e){var t=e&&e.toString().match(Fe);return t?t[1]:""}function Re(e,t){return Pe(e)===Pe(t)}function He(e,t){if(!Array.isArray(t))return Re(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Re(t[n],e))return n;return-1}function Be(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){ze(e,r,"errorCaptured hook")}}ze(e,t,n)}finally{fe()}}function Ue(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch((function(e){return Be(e,r,i+" (Promise/async)")})),o._handled=!0)}catch(e){Be(e,r,i)}return o}function ze(e,t,n){if(I.errorHandler)try{return I.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ve(t)}Ve(e)}function Ve(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var Ke,qe=!1,Je=[],We=!1;function Ze(){We=!1;var e=Je.slice(0);Je.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var Ge=Promise.resolve();Ke=function(){Ge.then(Ze),Z&&setTimeout(S)},qe=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ke="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Ze)}:function(){setTimeout(Ze,0)};else{var Xe=1,Ye=new MutationObserver(Ze),Qe=document.createTextNode(String(Xe));Ye.observe(Qe,{characterData:!0}),Ke=function(){Xe=(Xe+1)%2,Qe.data=String(Xe)},qe=!0}function et(e,t){var n;if(Je.push((function(){if(e)try{e.call(t)}catch(e){Be(e,t,"nextTick")}else n&&n(t)})),We||(We=!0,Ke()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var tt=new ie;function nt(e){rt(e,tt),tt.clear()}function rt(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!o(e)||Object.isFrozen(e)||e instanceof pe)){if(e.__ob__){var a=e.__ob__.dep.id;if(t.has(a))return;t.add(a)}if(i)for(n=e.length;n--;)rt(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)rt(e[r[n]],t)}}var it=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function ot(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return Ue(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)Ue(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function at(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=it(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=ot(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=it(c)).name,n[c],f.capture)}function st(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=ot([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=ot([s,c]),a.merged=!0,e[i]=a}function ct(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function ut(e){return i(e)?[he(e)]:Array.isArray(e)?ft(e):void 0}function lt(e){return n(e)&&n(e.text)&&!1===e.isComment}function ft(e,o){var a,s,c,u,l=[];for(a=0;a<e.length;a++)t(s=e[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(lt((s=ft(s,(o||"")+"_"+a))[0])&&lt(u)&&(l[c]=he(u.text+s[0].text),s.shift()),l.push.apply(l,s)):i(s)?lt(u)?l[c]=he(u.text+s):""!==s&&l.push(he(s)):lt(s)&&lt(u)?l[c]=he(u.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(o)&&(s.key="__vlist"+o+"_"+a+"__"),l.push(s)));return l}function pt(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function dt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(vt)&&delete n[u];return n}function vt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ht(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=mt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=yt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function mt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ut(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function yt(e,t){return function(){return e[t]}}function gt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function _t(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function bt(e){return Me(this.$options,"filters",e)||E}function $t(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function wt(e,t,n,r,i){var o=I.keyCodes[t]||n;return i&&r&&!I.keyCodes[t]?$t(i,r):o?$t(o,e):r?C(r)!==t:void 0}function Ct(e,t,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||I.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function xt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||At(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function kt(e,t,n){return At(e,"__once__"+t+(n?"_"+n:""),!0),e}function At(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ot(e[r],t+"_"+r,n);else Ot(e,t,n)}function Ot(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function St(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function Tt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Tt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function Et(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Nt(e,t){return"string"==typeof e?t+e:e}function jt(e){e._o=kt,e._n=f,e._s=l,e._l=gt,e._t=_t,e._q=N,e._i=j,e._m=xt,e._f=bt,e._k=wt,e._b=Ct,e._v=he,e._e=ve,e._u=Tt,e._g=St,e._d=Et,e._p=Nt}function Dt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=pt(u.inject,o),this.slots=function(){return c.$slots||ht(t.scopedSlots,c.$slots=dt(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ht(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ht(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Ht(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Ht(s,e,t,n,r,f)}}function Lt(e,t,n,r,i){var o=me(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Mt(e,t){for(var n in t)e[b(n)]=t[n]}jt(Dt.prototype);var It={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;It.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Xt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){$e(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Ie(d,v,n,t)}$e(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Gt(t,r,h),u&&(t.$slots=dt(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,nn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,on.push(t)):en(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?tn(t,!0):t.$destroy())}},Ft=Object.keys(It);function Pt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=zt;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return h(s,a)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D((function(t){e.resolved=Vt(t,i),c?s.length=0:p(!0)})),v=D((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Vt(m.error,i)),n(m.loading)&&(e.loadingComp=Vt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout((function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=ve();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},kn(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ct(a,c,u,l,!0)||ct(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Ie(l,u,r||e);else n(i.attrs)&&Mt(c,i.attrs),n(i.props)&&Mt(c,i.props);var f=new Dt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Lt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ut(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Lt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Ft.length;n++){var r=Ft[n],i=t[r],o=It[r];i===o||i&&i._merged||(t[r]=i?Rt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Rt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Ht(e,t,a,s,c,u){return(Array.isArray(a)||i(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(e,t,r,i,a){if(n(r)&&n(r.__ob__))return ve();n(r)&&n(r.is)&&(t=r.is);if(!t)return ve();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===a?i=ut(i):1===a&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var u;c=e.$vnode&&e.$vnode.ns||I.getTagNamespace(t),s=I.isReservedTag(t)?new pe(I.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(u=Me(e.$options,"components",t))?new pe(t,r,i,void 0,void 0,e):Pt(u,r,e,i,t)}else s=Pt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Bt(s,c),n(r)&&function(e){o(e.style)&&nt(e.style);o(e.class)&&nt(e.class)}(r),s):ve()}(e,t,a,s,c)}function Bt(e,i,o){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,o=!0),n(e.children))for(var a=0,s=e.children.length;a<s;a++){var c=e.children[a];n(c.tag)&&(t(c.ns)||r(o)&&"svg"!==c.tag)&&Bt(c,i,o)}}var Ut,zt=null;function Vt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Kt(e){return e.isComment&&e.asyncFactory}function qt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Kt(r)))return r}}function Jt(e,t){Ut.$on(e,t)}function Wt(e,t){Ut.$off(e,t)}function Zt(e,t){var n=Ut;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Gt(e,t,n){Ut=e,at(t,n||{},Jt,Wt,Zt,e),Ut=void 0}var Xt=null;function Yt(e){var t=Xt;return Xt=e,function(){Xt=t}}function Qt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function en(e,t){if(t){if(e._directInactive=!1,Qt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)en(e.$children[n]);nn(e,"activated")}}function tn(e,t){if(!(t&&(e._directInactive=!0,Qt(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);nn(e,"deactivated")}}function nn(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)Ue(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var rn=[],on=[],an={},sn=!1,cn=!1,un=0;var ln=0,fn=Date.now;if(U&&!q){var pn=window.performance;pn&&"function"==typeof pn.now&&fn()>document.createEvent("Event").timeStamp&&(fn=function(){return pn.now()})}function dn(){var e,t;for(ln=fn(),cn=!0,rn.sort((function(e,t){return e.id-t.id})),un=0;un<rn.length;un++)(e=rn[un]).before&&e.before(),t=e.id,an[t]=null,e.run();var n=on.slice(),r=rn.slice();un=rn.length=on.length=0,an={},sn=cn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,en(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&nn(r,"updated")}}(r),ne&&I.devtools&&ne.emit("flush")}var vn=0,hn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++vn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};hn.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Be(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&nt(e),fe(),this.cleanupDeps()}return e},hn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},hn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},hn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==an[t]){if(an[t]=!0,cn){for(var n=rn.length-1;n>un&&rn[n].id>e.id;)n--;rn.splice(n+1,0,e)}else rn.push(e);sn||(sn=!0,et(dn))}}(this)},hn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Be(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},hn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},hn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},hn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var mn={enumerable:!0,configurable:!0,get:S,set:S};function yn(e,t,n){mn.get=function(){return this[t][n]},mn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,mn)}function gn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var o=function(o){i.push(o);var a=Ie(o,t,n,e);xe(r,o,a),o in e||yn(e,"_props",o)};for(var a in t)o(a);$e(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Be(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||P(o)||yn(e,"_data",o)}Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new hn(e,a||S,S,_n)),i in e||bn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(e,n,r[i]);else Cn(e,n,r)}}(e,t.watch)}var _n={lazy:!0};function bn(e,t,n){var r=!te();"function"==typeof n?(mn.get=r?$n(t):wn(n),mn.set=S):(mn.get=n.get?r&&!1!==n.cache?$n(t):wn(n.get):S,mn.set=n.set||S),Object.defineProperty(e,t,mn)}function $n(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function wn(e){return function(){return e.call(this,this)}}function Cn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var xn=0;function kn(e){var t=e.options;if(e.super){var n=kn(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function An(e){this._init(e)}function On(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=Le(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)yn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)bn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,L.forEach((function(e){a[e]=n[e]})),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function Sn(e){return e&&(e.Ctor.options.name||e.tag)}function Tn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function En(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=Sn(a.componentOptions);s&&!t(s)&&Nn(n,o,r,i)}}}function Nn(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=xn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le(kn(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Gt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=dt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Ht(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Ht(t,e,n,r,i,!0)};var o=r&&r.data;xe(t,"$attrs",o&&o.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),nn(n,"beforeCreate"),function(e){var t=pt(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach((function(n){xe(e,n,t[n])})),$e(!0))}(n),gn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),nn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(An),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Ae,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return Cn(r,e,t,n);(n=n||{}).user=!0;var i=new hn(r,e,t,n);if(n.immediate){le();try{t.call(r,i.value)}catch(e){Be(e,r,'callback for immediate watcher "'+i.expression+'"')}fe()}return function(){i.teardown()}}}(An),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?k(n):n;for(var r=k(arguments,1),i='event handler for "'+e+'"',o=0,a=n.length;o<a;o++)Ue(n[o],t,r,t,i)}return t}}(An),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Yt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){nn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),nn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(An),function(e){jt(e.prototype),e.prototype.$nextTick=function(e){return et(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ht(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{zt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Be(n,t,"render"),e=t._vnode}finally{zt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=ve()),e.parent=i,e}}(An);var jn=[String,RegExp,Array],Dn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)Nn(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){En(e,(function(e){return Tn(t,e)}))})),this.$watch("exclude",(function(t){En(e,(function(e){return!Tn(t,e)}))}))},render:function(){var e=this.$slots.default,t=qt(e),n=t&&t.componentOptions;if(n){var r=Sn(n),i=this.include,o=this.exclude;if(i&&(!r||!Tn(i,r))||o&&r&&Tn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&Nn(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return I}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:Le,defineReactive:xe},e.set=ke,e.delete=Ae,e.nextTick=et,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),L.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,A(e.options.components,Dn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),On(e),function(e){L.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(An),Object.defineProperty(An.prototype,"$isServer",{get:te}),Object.defineProperty(An.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(An,"FunctionalRenderContext",{value:Dt}),An.version="2.6.12";var Ln=p("style,class"),Mn=p("input,textarea,option,select,progress"),In=p("contenteditable,draggable,spellcheck"),Fn=p("events,caret,typing,plaintext-only"),Pn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Rn="http://www.w3.org/1999/xlink",Hn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Bn=function(e){return Hn(e)?e.slice(6,e.length):""},Un=function(e){return null==e||!1===e};function zn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Vn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Vn(t,r.data));return function(e,t){if(n(e)||n(t))return Kn(e,qn(t));return""}(t.staticClass,t.class)}function Vn(e,t){return{staticClass:Kn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Kn(e,t){return e?t?e+" "+t:e:t||""}function qn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=qn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Jn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Wn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(e){return Wn(e)||Zn(e)};var Xn=Object.create(null);var Yn=p("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Jn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Yn(i)&&Yn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?st(t,"insert",f):f()}l.length&&st(t,"postpatch",(function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)}));if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=Me(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Be(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(q||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Hn(o)?s.removeAttributeNS(Rn,Bn(o)):In(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):Pn(t)?Un(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):In(t)?e.setAttribute(t,function(e,t){return Un(t)||"false"===t?"false":"contenteditable"===e&&Fn(t)?t:"true"}(t,n)):Hn(t)?Un(n)?e.removeAttributeNS(Rn,Bn(t)):e.setAttributeNS(Rn,t,n):hr(e,t,n)}function hr(e,t,n){if(Un(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=zn(r),c=i._transitionClasses;n(c)&&(s=Kn(s,qn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Er(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Nr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v",a=o;r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var s=Br(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?qr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))qr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function qr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var Jr;function Wr(e,t,n){var r=Jr;return function i(){var o=t.apply(null,arguments);null!==o&&Xr(e,i,n,r)}}var Zr=qe&&!(X&&Number(X[1])<=53);function Gr(e,t,n,r){if(Zr){var i=ln,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Jr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Xr(e,t,n,r){(r||Jr).removeEventListener(e,t._wrapper||t,n)}function Yr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};Jr=r.elm,function(e){if(n(e.__r)){var t=q?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),at(i,o,Gr,Xr,Wr,r.context),Jr=void 0}}var Qr,ei={create:Yr,update:Yr};function ti(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ni(a,u)&&(a.value=u)}else if("innerHTML"===i&&Zn(a.tagName)&&t(a.innerHTML)){(Qr=Qr||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=Qr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ni(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ri={create:ti,update:ti},ii=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function oi(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ii(e):e}var si,ci=/^--/,ui=/\s*!important$/,li=function(e,t,n){if(ci.test(t))e.style.setProperty(t,n);else if(ui.test(n))e.style.setProperty(C(t),n.replace(ui,""),"important");else{var r=pi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},fi=["Webkit","Moz","ms"],pi=g((function(e){if(si=si||document.createElement("div").style,"filter"!==(e=b(e))&&e in si)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<fi.length;n++){var r=fi[n]+t;if(r in si)return r}}));function di(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=oi(i.data))&&A(r,n);(n=oi(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=oi(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(a=d[s])!==f[s]&&li(c,s,null==a?"":a)}}var vi={create:di,update:di},hi=/\s+/;function mi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function yi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function gi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,_i(e.name||"v")),A(t,e),t}return"string"==typeof e?_i(e):void 0}}var _i=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),bi=U&&!J,$i="transition",wi="transitionend",Ci="animation",xi="animationend";bi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&($i="WebkitTransition",wi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ci="WebkitAnimation",xi="webkitAnimationEnd"));var ki=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ai(e){ki((function(){ki(e)}))}function Oi(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),mi(e,t))}function Si(e,t){e._transitionClasses&&h(e._transitionClasses,t),yi(e,t)}function Ti(e,t,n){var r=Ni(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s="transition"===i?wi:xi,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),e.addEventListener(s,l)}var Ei=/\b(transform|all)(,|$)/;function Ni(e,t){var n,r=window.getComputedStyle(e),i=(r[$i+"Delay"]||"").split(", "),o=(r[$i+"Duration"]||"").split(", "),a=ji(i,o),s=(r[Ci+"Delay"]||"").split(", "),c=(r[Ci+"Duration"]||"").split(", "),u=ji(s,c),l=0,f=0;return"transition"===t?a>0&&(n="transition",l=a,f=o.length):"animation"===t?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:"transition"===n&&Ei.test(r[$i+"Property"])}}function ji(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Di(t)+Di(e[n])})))}function Di(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Li(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=gi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Xt,A=Xt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,E=O&&v?v:l,N=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!J,P=Fi(j),R=i._enterCb=D((function(){F&&(Si(i,E),Si(i,T)),R.cancelled?(F&&Si(i,S),M&&M(i)):L&&L(i),i._enterCb=null}));e.data.show||st(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)})),N&&N(i),F&&(Oi(i,S),Oi(i,T),Ai((function(){Si(i,S),R.cancelled||(Oi(i,E),P||(Ii(I)?setTimeout(R,I):Ti(i,c,R)))}))),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Mi(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=gi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!J,b=Fi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Si(i,l),Si(i,p)),w.cancelled?(_&&Si(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Oi(i,u),Oi(i,p),Ai((function(){Si(i,u),w.cancelled||(Oi(i,l),b||(Ii($)?setTimeout(w,$):Ti(i,c,w)))}))),v&&v(i,w),_||b||w())}}function Ii(e){return"number"==typeof e&&!isNaN(e)}function Fi(e){if(t(e))return!1;var r=e.fns;return n(r)?Fi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Pi(e,t){!0!==t.data.show&&Li(t)}var Ri=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=me(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){var o,a=e;for(;a.componentInstance;)if(n(o=(a=a.componentInstance._vnode).data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Xt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=me(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&nt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute("data-server-rendered")&&(e.removeAttribute("data-server-rendered"),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ei,ri,vi,U?{create:Pi,activate:Pi,remove:function(e,t){!0!==e.data.show?Mi(e,t):t()}}:{}].concat(pr)});J&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Ji(e,"input")}));var Hi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?st(n,"postpatch",(function(){Hi.componentUpdated(e,t,n)})):Bi(e,t,n.context),e._vOptions=[].map.call(e.options,Vi)):("textarea"===n.tag||Yn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Ki),e.addEventListener("compositionend",qi),e.addEventListener("change",qi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Bi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Vi);if(i.some((function(e,t){return!N(e,r[t])})))(e.multiple?t.value.some((function(e){return zi(e,i)})):t.value!==t.oldValue&&zi(t.value,i))&&Ji(e,"change")}}};function Bi(e,t,n){Ui(e,t),(q||W)&&setTimeout((function(){Ui(e,t)}),0)}function Ui(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Vi(a))>-1,a.selected!==o&&(a.selected=o);else if(N(Vi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function zi(e,t){return t.every((function(t){return!N(t,e)}))}function Vi(e){return"_value"in e?e._value:e.value}function Ki(e){e.target.composing=!0}function qi(e){e.target.composing&&(e.target.composing=!1,Ji(e.target,"input"))}function Ji(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Wi(e){return!e.componentInstance||e.data&&e.data.transition?e:Wi(e.componentInstance._vnode)}var Zi={model:Hi,show:{bind:function(e,t,n){var r=t.value,i=(n=Wi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Li(n,(function(){e.style.display=o}))):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Wi(n)).data&&n.data.transition?(n.data.show=!0,r?Li(n,(function(){e.style.display=e.__vOriginalDisplay})):Mi(n,(function(){e.style.display="none"}))):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},Gi={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Xi(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?Xi(qt(t.children)):e}function Yi(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function Qi(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var eo=function(e){return e.tag||Kt(e)},to=function(e){return"show"===e.name},no={name:"transition",props:Gi,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(eo)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=Xi(o);if(!a)return o;if(this._leaving)return Qi(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Yi(this),u=this._vnode,l=Xi(u);if(a.data.directives&&a.data.directives.some(to)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Kt(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,st(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),Qi(e,o);if("in-out"===r){if(Kt(a))return u;var p,d=function(){p()};st(c,"afterEnter",d),st(c,"enterCancelled",d),st(f,"delayLeave",(function(e){p=e}))}}return o}}},ro=A({tag:String,moveClass:String},Gi);function io(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function oo(e){e.data.newPos=e.elm.getBoundingClientRect()}function ao(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete ro.mode;var so={Transition:no,TransitionGroup:{props:ro,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Yt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=Yi(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=e(t,null,u),this.removed=l}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(io),e.forEach(oo),e.forEach(ao),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;Oi(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(wi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(wi,e),n._moveCb=null,Si(n,t))})}})))},methods:{hasMove:function(e,t){if(!bi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){yi(n,e)})),mi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Ni(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};An.config.mustUseProp=function(e,t,n){return"value"===n&&Mn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},An.config.isReservedTag=Gn,An.config.isReservedAttr=Ln,An.config.getTagNamespace=function(e){return Zn(e)?"svg":"math"===e?"math":void 0},An.config.isUnknownElement=function(e){if(!U)return!0;if(Gn(e))return!1;if(e=e.toLowerCase(),null!=Xn[e])return Xn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Xn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Xn[e]=/HTMLUnknownElement/.test(t.toString())},A(An.options.directives,Zi),A(An.options.components,so),An.prototype.__patch__=U?Ri:S,An.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),nn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new hn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&nn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,nn(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout((function(){I.devtools&&ne&&ne.emit("init",An)}),0);var co=p("input,textarea,option,select,progress"),uo=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),lo=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function fo(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g((function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo,go={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ii(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},_o=function(e){return(yo=yo||document.createElement("div")).innerHTML=e,yo.textContent},bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+F.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,Eo=/^<!\[/,No=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,(function(e){return Do[e]}))}var Ro,Ho,Bo,Uo,zo,Vo,Ko,qo,Jo=/^@|^v-on:/,Wo=/^v-|^@|^:|^#/,Zo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Go=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Xo=/^\(|\)$/g,Yo=/^\[.*\]$/,Qo=/:(.*)$/,ea=/^:|^\.|^v-bind:/,ta=/\.[^.\]]+(?=[^\]]*$)/g,na=/^v-slot(:|$)|^#/,ra=/[\r\n]/,ia=/[ \f\t\r\n]+/g,oa=g(_o);function aa(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:da(t),rawAttrsMap:{},parent:n,children:[]}}function sa(e,t){Ro=t.warn||Sr,Vo=t.isPreTag||T,Ko=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Bo=Tr(t.modules,"transformNode"),Uo=Tr(t.modules,"preTransformNode"),zo=Tr(t.modules,"postTransformNode"),Ho=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=ca(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&la(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&la(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter((function(e){return!e.slotScope})),l(e),e.pre&&(s=!1),Vo(e.tag)&&(c=!1);for(var f=0;f<zo.length;f++)zo[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&No(r)){var u=0,l=r.toLowerCase(),f=jo[l]||(jo[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return u=r.length,No(l)||"noscript"===l||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(To.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(Eo.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(So);if(m){C(m[0].length);continue}var y=e.match(Oo);if(y){var g=c;C(y[0].length),A(y[1],g,c);continue}var _=x();if(_){k(_),Fo(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Oo.test($)||ko.test($)||To.test($)||Eo.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(ko);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(Ao))&&(r=e.match(wo)||e.match($o));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Po(v,h)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,u,e.start,e.end)}function A(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Ro,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);q&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];va.test(r.name)||(r.name=r.name.replace(ha,""),t.push(r))}return t}(o));var d,v=aa(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<Uo.length;h++)v=Uo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Vo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(ua(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,la(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u,l,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:oa(e):f.length?a?"condense"===a&&ra.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(ia," ")),!s&&" "!==e&&(u=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Ho))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function ca(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Nr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,na);if(r){var i=fa(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||"_empty_"}}else{var s=Pr(e,na);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=fa(s),l=u.name,f=u.dynamic,p=c[l]=aa("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||"_empty_",e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Bo.length;i++)e=Bo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Wo.test(r))if(e.hasBindings=!0,(a=pa(r.replace(Wo,"")))&&(r=r.replace(ta,"")),ea.test(r))r=r.replace(ea,""),o=Ar(o),(c=Yo.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Ko(e.tag,e.attrsMap.type,r)?Er(e,r,o,u[t],c):Nr(e,r,o,u[t],c);else if(Jo.test(r))r=r.replace(Jo,""),(c=Yo.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Wo,"")).match(Qo),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),Yo.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Nr(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Ko(e.tag,e.attrsMap.type,r)&&Er(e,r,"true",u[t])}(e),e}function ua(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Zo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Xo,""),i=r.match(Go);i?(n.alias=r.replace(Go,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function la(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function fa(e){var t=e.name.replace(na,"");return t||"#"!==e.name[0]&&(t="default"),Yo.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function pa(e){var t=e.match(ta);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function da(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var va=/^xmlns:NS\d+/,ha=/^NS\d+:/;function ma(e){return aa(e.tag,e.attrsList.slice(),e.parent)}var ya=[mo,go,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Ir(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=ma(e);ua(c),jr(c,"type","checkbox"),ca(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,la(c,{exp:c.if,block:c});var u=ma(e);Fr(u,"v-for",!0),jr(u,"type","radio"),ca(u,t),la(c,{exp:"("+n+")==='radio'"+o,block:u});var l=ma(e);return Fr(l,"v-for",!0),jr(l,":type",n),ca(l,t),la(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var ga,_a,ba={expectHTML:!0,modules:ya,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Er(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?"__r":"input",l="$event.target.value";s&&(l="$event.target.value.trim()");a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f);Er(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!I.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&co(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return uo(e)||lo(e)},getTagNamespace:function(e){return lo(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(ya)},$a=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function wa(e,t){e&&(ga=$a(t.staticKeys||""),_a=t.isReservedTag||T,Ca(e),xa(e,!1))}function Ca(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!_a(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(ga)))}(e),1===e.type){if(!_a(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Ca(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++){var a=e.ifConditions[i].block;Ca(a),a.static||(e.static=!1)}}}function xa(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)xa(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++)xa(e.ifConditions[i].block,t)}}var ka=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Aa=/\([^)]*?\);*$/,Oa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Sa={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ta={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},Na={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function ja(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=Da(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Da(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return Da(e)})).join(",")+"]";var t=Oa.test(e.value),n=ka.test(e.value),r=Oa.test(e.value.replace(Aa,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(Na[s])o+=Na[s],Sa[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(La).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function La(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Sa[e],r=Ta[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ma={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Ia=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ma),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Fa(e,t){var n=new Ia(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Pa(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Pa(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ra(e,t);if(e.once&&!e.onceProcessed)return Ha(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ba(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=Ja(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:Ja(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:Ja(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return Ja(e,t)||"void 0"}function Ra(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Pa(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ha(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ba(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Pa(e,t)+","+t.onceId+++","+n+")":Pa(e,t)}return Ra(e,t)}function Ba(e,t,n,r){return e.ifProcessed=!0,Ua(e.ifConditions.slice(),t,n,r)}function Ua(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+o(i.block)+":"+Ua(e,t,n,r):""+o(i.block);function o(e){return n?n(e,t):e.once?Ha(e,t):Pa(e,t)}}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Pa)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=ja(e.events,!1)+","),e.nativeEvents&&(n+=ja(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)})),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&"_empty_"!==o.slotScope||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map((function(e){return qa(t[e],n)})).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Fa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function qa(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ba(e,t,qa,"null");if(e.for&&!e.forProcessed)return za(e,t,qa);var r="_empty_"===e.slotScope?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(Ja(e,t)||"undefined")+":undefined":Ja(e,t)||"undefined":Pa(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Ja(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Pa)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some((function(e){return Wa(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map((function(e){return u(e,t)})).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Pa(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:Xa(JSON.stringify(e.text)))+")"}(e)}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map((function(e){return Ya(e,c)})),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=sa(e.trim(),t);!1!==t.optimize&&wa(n,t);var r=Fa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(ba).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g((function(e){var t=fo(e);return t&&t.innerHTML})),ss=An.prototype.$mount;An.prototype.$mount=function(e,t){if((e=e&&fo(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},An.compile=ns,module.exports=An;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index 104cf11eceb..57933181b74 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -6727,12 +6727,12 @@ var style$1 = {
     update: updateStyle,
 };
 
-const whitespaceRE$2 = /\s+/;
+const whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass$1(el, cls) {
+function addClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6740,7 +6740,7 @@ function addClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach((c) => el.classList.add(c));
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
@@ -6757,7 +6757,7 @@ function addClass$1(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass$1(el, cls) {
+function removeClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6765,7 +6765,7 @@ function removeClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach((c) => el.classList.remove(c));
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -6790,7 +6790,7 @@ function removeClass$1(el, cls) {
     }
 }
 
-function resolveTransition$1(def) {
+function resolveTransition(def) {
     if (!def) {
         return;
     }
@@ -6798,16 +6798,16 @@ function resolveTransition$1(def) {
     if (typeof def === 'object') {
         const res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition$1(def.name || 'v'));
+            extend(res, autoCssTransition(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition$1(def);
+        return autoCssTransition(def);
     }
 }
-const autoCssTransition$1 = cached((name) => {
+const autoCssTransition = cached((name) => {
     return {
         enterClass: `${name}-enter`,
         enterToClass: `${name}-enter-to`,
@@ -6817,59 +6817,59 @@ const autoCssTransition$1 = cached((name) => {
         leaveActiveClass: `${name}-leave-active`,
     };
 });
-const hasTransition$1 = inBrowser && !isIE9;
-const TRANSITION$1 = 'transition';
-const ANIMATION$1 = 'animation';
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
 // Transition property/event sniffing
-let transitionProp$1 = 'transition';
-let transitionEndEvent$1 = 'transitionend';
-let animationProp$1 = 'animation';
-let animationEndEvent$1 = 'animationend';
-if (hasTransition$1) {
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
+if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp$1 = 'WebkitTransition';
-        transitionEndEvent$1 = 'webkitTransitionEnd';
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp$1 = 'WebkitAnimation';
-        animationEndEvent$1 = 'webkitAnimationEnd';
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-const raf$1 = inBrowser
+const raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ (fn) => fn();
-function nextFrame$1(fn) {
-    raf$1(() => {
+function nextFrame(fn) {
+    raf(() => {
         // @ts-expect-error
-        raf$1(fn);
+        raf(fn);
     });
 }
-function addTransitionClass$1(el, cls) {
+function addTransitionClass(el, cls) {
     const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass$1(el, cls);
+        addClass(el, cls);
     }
 }
-function removeTransitionClass$1(el, cls) {
+function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass$1(el, cls);
+    removeClass(el, cls);
 }
-function whenTransitionEnds$1(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo$1(el, expectedType);
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
     if (!type)
         return cb();
-    const event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
     let ended = 0;
     const end = () => {
         el.removeEventListener(event, onEnd);
@@ -6889,30 +6889,30 @@ function whenTransitionEnds$1(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-const transformRE$1 = /\b(transform|all)(,|$)/;
-function getTransitionInfo$1(el, expectedType) {
+const transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
     const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout$1(animationDelays, animationDurations);
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
     let type;
     let timeout = 0;
     let propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION$1) {
+    if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
-            type = TRANSITION$1;
+            type = TRANSITION;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION$1) {
+    else if (expectedType === ANIMATION) {
         if (animationTimeout > 0) {
-            type = ANIMATION$1;
+            type = ANIMATION;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6922,16 +6922,16 @@ function getTransitionInfo$1(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION$1
-                    : ANIMATION$1
+                    ? TRANSITION
+                    : ANIMATION
                 : null;
         propCount = type
-            ? type === TRANSITION$1
+            ? type === TRANSITION
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    const hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
         type,
         timeout,
@@ -6939,31 +6939,31 @@ function getTransitionInfo$1(el, expectedType) {
         hasTransform,
     };
 }
-function getTimeout$1(delays, durations) {
+function getTimeout(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map((d, i) => {
-        return toMs$1(d) + toMs$1(delays[i]);
+        return toMs(d) + toMs(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs$1(s) {
+function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter$1(vnode, toggleDisplay) {
+function enter(vnode, toggleDisplay) {
     const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    const data = resolveTransition$1(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7001,19 +7001,19 @@ function enter$1(vnode, toggleDisplay) {
         : enterCancelled;
     const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
-        checkDuration$1(explicitEnterDuration, 'enter', vnode);
+        checkDuration(explicitEnterDuration, 'enter', vnode);
     }
     const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength$1(enterHook);
+    const userWantsControl = getHookArgumentsLength(enterHook);
     const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
-            removeTransitionClass$1(el, toClass);
-            removeTransitionClass$1(el, activeClass);
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, startClass);
+                removeTransitionClass(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -7038,19 +7038,19 @@ function enter$1(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass$1(el, startClass);
-        addTransitionClass$1(el, activeClass);
-        nextFrame$1(() => {
-            removeTransitionClass$1(el, startClass);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass$1(el, toClass);
+                addTransitionClass(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration$1(explicitEnterDuration)) {
+                    if (isValidDuration(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds$1(el, type, cb);
+                        whenTransitionEnds(el, type, cb);
                     }
                 }
             }
@@ -7064,14 +7064,14 @@ function enter$1(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave$1(vnode, rm) {
+function leave(vnode, rm) {
     const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    const data = resolveTransition$1(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7081,23 +7081,23 @@ function leave$1(vnode, rm) {
     }
     const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
     const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength$1(leave);
+    const userWantsControl = getHookArgumentsLength(leave);
     const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
-        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
     const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass$1(el, leaveToClass);
-            removeTransitionClass$1(el, leaveActiveClass);
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, leaveClass);
+                removeTransitionClass(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -7125,19 +7125,19 @@ function leave$1(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass$1(el, leaveClass);
-            addTransitionClass$1(el, leaveActiveClass);
-            nextFrame$1(() => {
-                removeTransitionClass$1(el, leaveClass);
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass$1(el, leaveToClass);
+                    addTransitionClass(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration$1(explicitLeaveDuration)) {
+                        if (isValidDuration(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds$1(el, type, cb);
+                            whenTransitionEnds(el, type, cb);
                         }
                     }
                 }
@@ -7150,7 +7150,7 @@ function leave$1(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration$1(val, name, vnode) {
+function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
             `got ${JSON.stringify(val)}.`, vnode.context);
@@ -7160,7 +7160,7 @@ function checkDuration$1(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration$1(val) {
+function isValidDuration(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -7169,7 +7169,7 @@ function isValidDuration$1(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength$1(fn) {
+function getHookArgumentsLength(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -7177,7 +7177,7 @@ function getHookArgumentsLength$1(fn) {
     const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -7186,7 +7186,7 @@ function getHookArgumentsLength$1(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter$1(vnode);
+        enter(vnode);
     }
 }
 var transition = inBrowser
@@ -7197,7 +7197,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave$1(vnode, rm);
+                leave(vnode, rm);
             }
             else {
                 rm();
@@ -7345,464 +7345,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        // @ts-expect-error
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        // @ts-expect-error
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -8725,7 +8267,6 @@ function parseHTML(html, options) {
     }
 }
 
-// const he = require('he')
 const onRE = /^@|^v-on:/;
 const dirRE = /^v-|^@|^:|^#/;
 const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
index 6b28466b459..323ab982f91 100644
--- a/dist/vue.esm.browser.min.js
+++ b/dist/vue.esm.browser.min.js
@@ -8,4 +8,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}const s=Object.prototype.toString;function a(t){return"[object Object]"===s.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===s?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function k(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&k(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=i(t),o=i(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function L(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function j(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const D=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const G=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{constructor(){this.set=Object.create(null)}has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let it=S,st=0;class at{constructor(){this.id=st++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{constructor(t,e,n,o,r,i,s,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=s,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let i;switch(t){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&r.observeArray(i),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!i(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const i=new at,s=Object.getOwnPropertyDescriptor(t,e);if(s&&!1===s.configurable)return;const a=s&&s.get,c=s&&s.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(i.depend(),l&&(l.dep.depend(),Array.isArray(e)&&At(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),i.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function At(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&At(e)}const kt=I.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const i=ot?Reflect.ownKeys(e):Object.keys(e);for(let s=0;s<i.length;s++)n=i[s],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Nt(t,e,n,o){const r=Object.create(t||null);return e?k(r,e):r}kt.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{kt[t]=Tt})),D.forEach((function(t){kt[t+"s"]=Nt})),kt.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};k(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},kt.props=kt.methods=kt.inject=kt.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return k(r,t),e&&k(r,e),r},kt.provide=St;const Et=function(t,e){return void 0===e?t:e};function Lt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,i,s;if(Array.isArray(n))for(r=n.length;r--;)i=n[r],"string"==typeof i&&(s=_(i),o[s]={type:null});else if(a(n))for(const t in n)i=n[t],s=_(t),o[s]=a(i)?i:{type:i};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?k({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=Lt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=Lt(t,e.mixins[o],n);const o={};let r;for(r in t)i(r);for(r in e)g(t,r)||i(r);function i(r){const i=kt[r]||Et;o[r]=i(t[r],e[r],n,r)}return o}function jt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const i=_(n);if(g(r,i))return r[i];const s=b(i);if(g(r,s))return r[s];return r[n]||r[i]||r[s]}function Dt(t,e,n,o){const r=e[t],i=!g(n,t);let s=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(i&&!g(r,"default"))s=!1;else if(""===s||s===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(s=!0)}if(void 0===s){s=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==It(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(s),$t(e)}return s}const Mt=/^\s*function (\w+)/;function It(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return It(t)===It(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let i=0;i<r.length;i++)try{if(!1===r[i].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let i;try{i=n?t.apply(e,n):t.call(e),i&&!i._isVue&&l(i)&&!i._handled&&(i.catch((t=>Rt(t,o,r+" (Promise/async)"))),i._handled=!0)}catch(t){Rt(t,o,r)}return i}function Bt(t,e,n){if(I.errorHandler)try{return I.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,qt=!1;function Jt(){qt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(Jt),Z&&setTimeout(S)},zt=!0}else if(q||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(Jt)}:()=>{setTimeout(Jt,0)};else{let t=1;const e=new MutationObserver(Jt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Zt=new rt;function Gt(t){Xt(t,Zt),Zt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!i(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,i,s,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=s(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),i(f.name,n[c],f.capture))}function ee(t,r,i){let s;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){i.apply(this,arguments),m(s.fns,c)}e(a)?s=Qt([c]):n(a.fns)&&o(a.merged)?(s=a,s.fns.push(c)):s=Qt([a,c]),s.merged=!0,t[r]=s}function ne(t,e,o,r,i){if(n(e)){if(g(e,o))return t[o]=e[o],i||delete e[o],!0;if(g(e,r))return t[o]=e[r],i||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?ie(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function ie(t,i){const s=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=s.length-1,u=s[l],Array.isArray(c)?c.length>0&&(c=ie(c,`${i||""}_${a}`),re(c[0])&&re(u)&&(s[l]=pt(u.text+c[0].text),c.shift()),s.push.apply(s,c)):r(c)?re(u)?s[l]=pt(u.text+c):""!==c&&s.push(pt(c)):re(c)&&re(u)?s[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(i)&&(c.key=`__vlist${i}_${a}__`),s.push(c)));return s}function se(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const i=o[r];if("__ob__"===i)continue;const s=t[i].from;let a=e;for(;a;){if(a._provided&&g(a._provided,s)){n[i]=a._provided[s];break}a=a.$parent}if(!a&&"default"in t[i]){const o=t[i].default;n[i]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],i=r.data;if(i&&i.attrs&&i.attrs.slot&&delete i.attrs.slot,r.context!==e&&r.fnContext!==e||!i||null==i.slot)(n.default||(n.default=[])).push(r);else{const t=i.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,o){let r;const i=Object.keys(n).length>0,s=e?!!e.$stable:!i,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(s&&o&&o!==t&&a===o.$key&&!i&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ue(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=fe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",s),R(r,"$key",a),R(r,"$hasNormal",i),r}function ue(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});return t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t),t&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function fe(t,e){return()=>t[e]}function de(t,e){let o,r,s,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(i(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(s=Object.keys(t),c=new Array(s.length),o=0,r=s.length;o<r;o++)a=s[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,o){const r=this.$scopedSlots[t];let i;r?(n=n||{},o&&(n=k(k({},o),n)),i=r(n)||e):i=this.$slots[t]||e;const s=n&&n.slot;return s?this.$createElement("template",{slot:s},i):i}function he(t){return jt(this.$options,"filters",t)||N}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,o,r){const i=I.keyCodes[e]||n;return r&&o&&!I.keyCodes[e]?me(r,o):i?me(i,t):o?C(o)!==e:void 0}function ge(t,e,n,o,r){if(n)if(i(n)){let i;Array.isArray(n)&&(n=O(n));for(const s in n){if("class"===s||"style"===s||h(s))i=t;else{const n=t.attrs&&t.attrs.type;i=o||I.mustUseProp(e,n,s)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(s),c=C(s);if(!(a in i)&&!(c in i)&&(i[s]=n[s],r)){(t.on||(t.on={}))[`update:${s}`]=function(t){n[s]=t}}}}else;return t}function ve(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),_e(o,`__static__${t}`,!1)),o}function $e(t,e,n){return _e(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function _e(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&be(t[o],`${e}_${o}`,n);else be(t,e,n)}function be(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(a(e)){const n=t.on=t.on?k({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function Ce(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?Ce(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function xe(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=$e,t._n=f,t._s=u,t._l=de,t._t=pe,t._q=E,t._i=L,t._m=ve,t._f=he,t._k=ye,t._b=ge,t._v=pt,t._e=dt,t._u=Ce,t._g=we,t._d=xe,t._p=Ae}function Oe(e,n,r,i,s){const a=s.options;let c;g(i,"_uid")?(c=Object.create(i),c._original=i):(c=i,i=i._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=i,this.listeners=e.on||t,this.injections=se(a.inject,i),this.slots=()=>(this.$slots||le(e.scopedSlots,this.$slots=ae(r,i)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=De(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=i),r}:this._c=(t,e,n,o)=>De(c,t,e,n,o,u)}function Se(t,e,n,o,r){const i=ht(t);return i.fnContext=n,i.fnOptions=o,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Te(t,e){for(const n in e)t[_(n)]=e[n]}ke(Oe.prototype);const Ne={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ne.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,i){const s=r.data.scopedSlots,a=e.$scopedSlots,c=!!(s&&!s.$stable||a!==t&&!a.$stable||s&&e.$scopedSlots.$key!==s.$key),l=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=i,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const i=o[r],s=e.$options.props;t[i]=Dt(i,s,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(i,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ge(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ze(e,!0):e.$destroy())}},Ee=Object.keys(Ne);function Le(r,s,a,c,u){if(e(r))return;const f=a.$options._base;if(i(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,void 0===(r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const s=Fe;s&&n(t.owners)&&-1===t.owners.indexOf(s)&&t.owners.push(s);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(s&&!n(t.owners)){const o=t.owners=[s];let a=!0,c=null,u=null;s.$on("hook:destroyed",(()=>m(o,s)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=j((e=>{t.resolved=Pe(e,r),a?o.length=0:f(!0)})),p=j((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return i(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Pe(h.error,r)),n(h.loading)&&(t.loadingComp=Pe(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f))))return function(t,e,n,o,r){const i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:o,tag:r},i}(d,s,a,c,u);s=s||{},vn(r),n(s.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const i=e.on||(e.on={}),s=i[r],a=e.model.callback;n(s)?(Array.isArray(s)?-1===s.indexOf(a):s!==a)&&(i[r]=[a].concat(s)):i[r]=a}(r.options,s);const p=function(t,o,r){const i=o.options.props;if(e(i))return;const s={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in i){const e=C(t);ne(s,c,t,e,!0)||ne(s,a,t,e,!1)}return s}(s,r);if(o(r.options.functional))return function(e,o,r,i,s){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Dt(e,l,o||t);else n(r.attrs)&&Te(c,r.attrs),n(r.props)&&Te(c,r.props);const u=new Oe(r,c,s,i,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Se(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Se(t[n],r,u.parent,a);return e}}(r,p,s,a,c);const h=s.on;if(s.on=s.nativeOn,o(r.options.abstract)){const t=s.slot;s={},t&&(s.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Ee.length;t++){const n=Ee[t],o=e[n],r=Ne[n];o===r||o&&o._merged||(e[n]=o?je(r,o):r)}}(s);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,s,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function je(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function De(t,e,s,a,c,l){return(Array.isArray(s)||r(s))&&(c=a,a=s,s=void 0),o(l)&&(c=2),function(t,e,o,r,s){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===s?r=oe(r):1===s&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let i;c=t.$vnode&&t.$vnode.ns||I.getTagNamespace(e),a=I.isReservedTag(e)?new ft(I.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(i=jt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):Le(i,o,t,r,e)}else a=Le(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Me(a,c),n(o)&&function(t){i(t.style)&&Gt(t.style);i(t.class)&&Gt(t.class)}(o),a):dt()}(t,e,s,a,c)}function Me(t,r,i){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,i=!0),n(t.children))for(let s=0,a=t.children.length;s<a;s++){const a=t.children[s];n(a.tag)&&(e(a.ns)||o(i)&&"svg"!==a.tag)&&Me(a,r,i)}}let Ie,Fe=null;function Pe(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Re(t){return t.isComment&&t.asyncFactory}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||Re(o)))return o}}function Be(t,e){Ie.$on(t,e)}function Ue(t,e){Ie.$off(t,e)}function ze(t,e){const n=Ie;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Ie=t,te(e,n||{},Be,Ue,ze,t),Ie=void 0}let Ke=null;function qe(t){const e=Ke;return Ke=t,()=>{Ke=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ge(t,"activated")}}function Ze(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ze(t.$children[e]);Ge(t,"deactivated")}}function Ge(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!q){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ge(o,"updated")}}(o),et&&I.devtools&&et.emit("flush")}let an=0;class cn{constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Gt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||i(t)||this.deep){const e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const i in e){r.push(i);wt(o,i,Dt(i,e,n,t)),i in t||un(t,"_props",i)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const i=e[r],s="function"==typeof i?i:i.get;o||(n[r]=new cn(t,s||S,S,dn)),r in t||pn(t,r,i)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&k(t.extendOptions,o),e=t.options=Lt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const i=t.name||n.options.name,s=function(t){this._init(t)};return(s.prototype=Object.create(n.prototype)).constructor=s,s.cid=e++,s.options=Lt(n.options,t),s.super=n,s.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(s),s.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(s),s.extend=n.extend,s.mixin=n.mixin,s.use=n.use,D.forEach((function(t){s[t]=n[t]})),i&&(s.options.components[i]=s),s.superOptions=n.options,s.extendOptions=t,s.sealedOptions=k({},s.options),r[o]=s,s}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===s.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const i=n[t];if(i){const s=bn(i.componentOptions);s&&!e(s)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Lt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>De(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>De(e,t,n,o,r,!0);const i=o&&o.data;wt(e,"$attrs",i&&i.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ge(n,"beforeCreate"),function(t){const e=se(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ge(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){lt();try{e.call(o,r.value)}catch(t){Rt(t,o,`callback for immediate watcher "${r.expression}"`)}ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,i=o.length;for(;i--;)if(r=o[i],r===e||r.fn===e){o.splice(i,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?A(n):n;const o=A(arguments,1),r=`event handler for "${t}"`;for(let t=0,i=n.length;t<i;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,i=qe(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),i(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ge(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ge(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=le(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Fe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Fe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const An=[String,RegExp,Array];var kn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:An,exclude:An,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:i,keys:s}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;i[a]?(e.componentInstance=i[a].componentInstance,m(s,a),s.push(a)):(i[a]=e,s.push(a),this.max&&s.length>parseInt(this.max)&&xn(i,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>I};Object.defineProperty(t,"config",e),t.util={warn:it,extend:k,mergeOptions:Lt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),D.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,k(t.options.components,kn),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Lt(this.options,t),this}}(t),_n(t),function(t){D.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Oe}),$n.version="2.6.12";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=d("contenteditable,draggable,spellcheck"),Nn=d("events,caret,typing,plaintext-only"),En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Ln="http://www.w3.org/1999/xlink",jn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Dn=t=>jn(t)?t.slice(6,t.length):"",Mn=t=>null==t||!1===t;function In(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Fn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Fn(e,o.data));return function(t,e){if(n(t)||n(e))return Pn(t,Rn(e));return""}(e.staticClass,e.class)}function Fn(t,e){return{staticClass:Pn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Pn(t,e){return t?e?t+" "+e:t:e||""}function Rn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,i=t.length;r<i;r++)n(e=Rn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):i(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Bn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Un=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),zn=t=>Bn(t)||Un(t);const Vn=Object.create(null);const Kn=d("text,number,password,search,email,tel,url");var qn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Jn={create(t,e){Wn(e)},update(t,e){t.data.ref!==e.data.ref&&(Wn(t,!0),Wn(e))},destroy(t){Wn(t,!0)}};function Wn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,i=t.componentInstance||t.elm,s=r.$refs;e?Array.isArray(s[o])?m(s[o],i):s[o]===i&&(s[o]=void 0):t.data.refInFor?Array.isArray(s[o])?s[o].indexOf(i)<0&&s[o].push(i):s[o]=[i]:s[o]=i}const Zn=new ft("",{},[]),Gn=["create","activate","update","remove","destroy"];function Xn(t,r){return t.key===r.key&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,i=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===i||Kn(r)&&Kn(i)}(t,r)||o(t.isAsyncPlaceholder)&&t.asyncFactory===r.asyncFactory&&e(r.asyncFactory.error))}function Yn(t,e,o){let r,i;const s={};for(r=e;r<=o;++r)i=t[r].key,n(i)&&(s[i]=r);return s}var Qn={create:to,update:to,destroy:function(t){to(t,Zn)}};function to(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Zn,o=e===Zn,r=no(t.data.directives,t.context),i=no(e.data.directives,e.context),s=[],a=[];let c,l,u;for(c in i)l=r[c],u=i[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ro(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ro(u,"bind",e,t),u.def&&u.def.inserted&&s.push(u));if(s.length){const o=()=>{for(let n=0;n<s.length;n++)ro(s[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ro(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)i[c]||ro(r[c],"unbind",t,t,o)}(t,e)}const eo=Object.create(null);function no(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=eo),n[oo(r)]=r,r.def=jt(e.$options,"directives",r.name);return n}function oo(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ro(t,e,n,o,r){const i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var io=[Jn,Qn];function so(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let i,s,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(i in n(u.__ob__)&&(u=o.data.attrs=k({},u)),u)s=u[i],a=l[i],a!==s&&ao(c,i,s,o.data.pre);for(i in(q||W)&&u.value!==l.value&&ao(c,"value",u.value),l)e(u[i])&&(jn(i)?c.removeAttributeNS(Ln,Dn(i)):Tn(i)||c.removeAttribute(i))}function ao(t,e,n,o){o||t.tagName.indexOf("-")>-1?co(t,e,n):En(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,((t,e)=>Mn(e)||"false"===e?"false":"contenteditable"===t&&Nn(e)?e:"true")(e,n)):jn(e)?Mn(n)?t.removeAttributeNS(Ln,Dn(e)):t.setAttributeNS(Ln,e,n):co(t,e,n)}function co(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(q&&!J&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var lo={create:so,update:so};function uo(t,o){const r=o.elm,i=o.data,s=t.data;if(e(i.staticClass)&&e(i.class)&&(e(s)||e(s.staticClass)&&e(s.class)))return;let a=In(o);const c=r._transitionClasses;n(c)&&(a=Pn(a,Rn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var fo={create:uo,update:uo};const po=/[\w).+\-_$\]]/;function ho(t){let e,n,o,r,i,s=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),s)39===e&&92!==n&&(s=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:s=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&po.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(i||(i=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),i)for(o=0;o<i.length;o++)r=mo(r,i[o]);return r}function mo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function yo(t,e){console.error(`[Vue compiler]: ${t}`)}function go(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function vo(t,e,n,o,r){(t.props||(t.props=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function $o(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function _o(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(Oo({name:e,value:n},o))}function bo(t,e,n,o,r,i,s,a){(t.directives||(t.directives=[])).push(Oo({name:e,rawName:n,value:o,arg:r,isDynamicArg:i,modifiers:s},a)),t.plain=!1}function wo(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Co(e,n,o,r,i,s,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=wo("!",n,c)),r.once&&(delete r.once,n=wo("~",n,c)),r.passive&&(delete r.passive,n=wo("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=Oo({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?i?f.unshift(u):f.push(u):l[n]=f?i?[u,f]:[f,u]:u,e.plain=!1}function xo(t,e,n){const o=Ao(t,":"+e)||Ao(t,"v-bind:"+e);if(null!=o)return ho(o);if(!1!==n){const n=Ao(t,e);if(null!=n)return JSON.stringify(n)}}function Ao(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function ko(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function Oo(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function So(t,e,n){const{number:o,trim:r}=n||{},i="$$v";let s=i;r&&(s="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(s=`_n(${s})`);const a=To(e,s);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function To(t,e){const n=function(t){if(t=t.trim(),No=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<No-1)return jo=t.lastIndexOf("."),jo>-1?{exp:t.slice(0,jo),key:'"'+t.slice(jo+1)+'"'}:{exp:t,key:null};Eo=t,jo=Do=Mo=0;for(;!Fo();)Lo=Io(),Po(Lo)?Ho(Lo):91===Lo&&Ro(Lo);return{exp:t.slice(0,Do),key:t.slice(Do+1,Mo)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let No,Eo,Lo,jo,Do,Mo;function Io(){return Eo.charCodeAt(++jo)}function Fo(){return jo>=No}function Po(t){return 34===t||39===t}function Ro(t){let e=1;for(Do=jo;!Fo();)if(Po(t=Io()))Ho(t);else if(91===t&&e++,93===t&&e--,0===e){Mo=jo;break}}function Ho(t){const e=t;for(;!Fo()&&(t=Io())!==e;);}let Bo;function Uo(t,e,n){const o=Bo;return function r(){const i=e.apply(null,arguments);null!==i&&Ko(t,r,n,o)}}const zo=zt&&!(G&&Number(G[1])<=53);function Vo(t,e,n,o){if(zo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Bo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Ko(t,e,n,o){(o||Bo).removeEventListener(t,e._wrapper||e,n)}function qo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},i=t.data.on||{};Bo=o.elm,function(t){if(n(t.__r)){const e=q?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,i,Vo,Ko,Uo,o.context),Bo=void 0}var Jo={create:qo,update:qo};let Wo;function Zo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,i;const s=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=k({},c)),a)r in c||(s[r]="");for(r in c){if(i=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),i===a[r])continue;1===s.childNodes.length&&s.removeChild(s.childNodes[0])}if("value"===r&&"PROGRESS"!==s.tagName){s._value=i;const t=e(i)?"":String(i);Go(s,t)&&(s.value=t)}else if("innerHTML"===r&&Un(s.tagName)&&e(s.innerHTML)){Wo=Wo||document.createElement("div"),Wo.innerHTML=`<svg>${i}</svg>`;const t=Wo.firstChild;for(;s.firstChild;)s.removeChild(s.firstChild);for(;t.firstChild;)s.appendChild(t.firstChild)}else if(i!==a[r])try{s[r]=i}catch(t){}}}function Go(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var Xo={create:Zo,update:Zo};const Yo=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function Qo(t){const e=tr(t.style);return t.staticStyle?k(t.staticStyle,e):e}function tr(t){return Array.isArray(t)?O(t):"string"==typeof t?Yo(t):t}const er=/^--/,nr=/\s*!important$/,or=(t,e,n)=>{if(er.test(e))t.style.setProperty(e,n);else if(nr.test(n))t.style.setProperty(C(e),n.replace(nr,""),"important");else{const o=sr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},rr=["Webkit","Moz","ms"];let ir;const sr=v((function(t){if(ir=ir||document.createElement("div").style,"filter"!==(t=_(t))&&t in ir)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<rr.length;t++){const n=rr[t]+e;if(n in ir)return n}}));function ar(t,o){const r=o.data,i=t.data;if(e(r.staticStyle)&&e(r.style)&&e(i.staticStyle)&&e(i.style))return;let s,a;const c=o.elm,l=i.staticStyle,u=i.normalizedStyle||i.style||{},f=l||u,d=tr(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?k({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=Qo(e.data))&&k(n,o)}(o=Qo(t.data))&&k(n,o);let r=t;for(;r=r.parent;)r.data&&(o=Qo(r.data))&&k(n,o);return n}(o,!0);for(a in f)e(p[a])&&or(c,a,"");for(a in p)s=p[a],s!==f[a]&&or(c,a,null==s?"":s)}var cr={create:ar,update:ar};const lr=/\s+/;function ur(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&k(e,fr(t.name||"v")),k(e,t),e}return"string"==typeof t?fr(t):void 0}}const fr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`})));let dr="transition",pr="transitionend",hr="animation",mr="animationend";U&&!J&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(dr="WebkitTransition",pr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(hr="WebkitAnimation",mr="webkitAnimationEnd"));const yr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function gr(t){yr((()=>{yr(t)}))}function vr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function $r(t,e){t._transitionClasses&&m(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function _r(t,e,n){const{type:o,timeout:r,propCount:i}=function(t,e){const n=window.getComputedStyle(t),o=(n[dr+"Delay"]||"").split(", "),r=(n[dr+"Duration"]||"").split(", "),i=wr(o,r),s=(n[hr+"Delay"]||"").split(", "),a=(n[hr+"Duration"]||"").split(", "),c=wr(s,a);let l,u=0,f=0;"transition"===e?i>0&&(l="transition",u=i,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(i,c),l=u>0?i>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);const d="transition"===l&&br.test(n[dr+"Property"]);return{type:l,timeout:u,propCount:f,hasTransform:d}}(t,e);if(!o)return n();const s="transition"===o?pr:mr;let a=0;const c=()=>{t.removeEventListener(s,l),n()},l=e=>{e.target===t&&++a>=i&&c()};setTimeout((()=>{a<i&&c()}),r+1),t.addEventListener(s,l)}const br=/\b(transform|all)(,|$)/;function wr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Cr(e)+Cr(t[n]))))}function Cr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function xr(t){return"number"==typeof t&&!isNaN(t)}function Ar(t){if(e(t))return!1;const o=t.fns;return n(o)?Ar(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function kr(t,o){!0!==o.data.show&&function(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const s=ur(t.data.transition);if(e(s))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=s;let A=Ke,k=Ke.$vnode;for(;k&&k.parent;)A=k.context,k=k.parent;const O=!A._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,L=O&&"function"==typeof b?b:g,D=O&&w||v,M=O&&C||$,I=f(i(x)?x.enter:x),F=!1!==a&&!J,P=Ar(L),R=r._enterCb=j((()=>{F&&($r(r,N),$r(r,T)),R.cancelled?(F&&$r(r,S),M&&M(r)):D&&D(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(r,R)})),E&&E(r),F&&(vr(r,S),vr(r,T),gr((()=>{$r(r,S),R.cancelled||(vr(r,N),P||(xr(I)?setTimeout(R,I):_r(r,c,R)))}))),t.data.show&&(o&&o(),L&&L(r,R)),F||P||R()}(o)}const Or=function(t){let i,s;const a={},{modules:c,nodeOps:l}=t;for(i=0;i<Gn.length;++i)for(a[Gn[i]]=[],s=0;s<c.length;++s)n(c[s][Gn[i]])&&a[Gn[i]].push(c[s][Gn[i]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,i,s,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!s,function(t,e,r,i){let s=t.data;if(n(s)){const c=n(t.componentInstance)&&s.keepAlive;if(n(s=s.hook)&&n(s=s.init)&&s(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,i),o(c)&&function(t,e,o,r){let i,s=t;for(;s.componentInstance;)if(s=s.componentInstance._vnode,n(i=s.data)&&n(i=i.transition)){for(i=0;i<a.activate.length;++i)a.activate[i](Zn,s);e.push(s);break}h(o,t.elm,r)}(t,e,r,i),!0}}(t,e,r,i))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,i)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,i)):(t.elm=l.createTextNode(t.text),h(r,t.elm,i))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Wn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);i=t.data.hook,n(i)&&(n(i.create)&&i.create(Zn,t),n(i.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,i){for(;o<=r;++o)f(n[o],i,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let i=o;i<r;i++){const o=e[i];if(n(o)&&Xn(t,o))return i}}function x(t,r,i,s,c,u){if(t===r)return;n(r.elm)&&n(s)&&(r=s[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,i):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,i,s){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const A=!s;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:Xn(y,_)?(x(y,_,i,r,h),y=o[++p],_=r[++h]):Xn(g,w)?(x(g,w,i,r,v),g=o[--m],w=r[--v]):Xn(y,w)?(x(y,w,i,r,v),A&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):Xn(g,_)?(x(g,_,i,r,h),A&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=Yn(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,i,t,y.elm,!1,r,h):(u=o[c],Xn(u,_)?(x(u,_,i,r,h),o[c]=void 0,A&&l.insertBefore(t,u.elm,y.elm)):f(_,i,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,i)):h>v&&b(o,p,m)}(d,m,g,i,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,i)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function A(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,i){let s;const{tag:a,data:c,children:l}=e;if(i=i||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(s=c.hook)&&n(s=s.init)&&s(e,!0),n(s=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(s=c)&&n(s=s.domProps)&&n(s=s.innerHTML)){if(s!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,i)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!k(n)){t=!0,g(e,r);break}!t&&c.class&&Gt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,i,s){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Xn(t,r))x(t,r,u,null,null,s);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),i=!0),o(i)&&O(t,r,u))return A(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const s=t.elm,c=l.parentNode(s);if(f(r,u,s._leaveCb?null:c,l.nextSibling(s)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Wn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return A(r,u,c),r.elm}}({nodeOps:qn,modules:[lo,fo,Jo,Xo,cr,U?{create:kr,activate:kr,remove(t,o){!0!==t.data.show?function(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const s=ur(t.data.transition);if(e(s)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=s,$=!1!==a&&!J,_=Ar(h),b=f(i(v)?v.leave:v),w=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&($r(r,u),$r(r,d)),w.cancelled?($&&$r(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(vr(r,l),vr(r,d),gr((()=>{$r(r,l),w.cancelled||(vr(r,u),_||(xr(b)?setTimeout(w,b):_r(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}(t,o):o()}}:{}].concat(io)});J&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Mr(t,"input")}));const Sr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Sr.componentUpdated(t,e,n)})):Tr(t,e,n.context),t._vOptions=[].map.call(t.options,Lr)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",jr),t.addEventListener("compositionend",Dr),t.addEventListener("change",Dr),J&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Tr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Lr);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>Er(t,r))):e.value!==e.oldValue&&Er(e.value,r))&&Mr(t,"change")}}}};function Tr(t,e,n){Nr(t,e),(q||W)&&setTimeout((()=>{Nr(t,e)}),0)}function Nr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let i,s;for(let e=0,n=t.options.length;e<n;e++)if(s=t.options[e],r)i=L(o,Lr(s))>-1,s.selected!==i&&(s.selected=i);else if(E(Lr(s),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Er(t,e){return e.every((e=>!E(e,t)))}function Lr(t){return"_value"in t?t._value:t.value}function jr(t){t.target.composing=!0}function Dr(t){t.target.composing&&(t.target.composing=!1,Mr(t.target,"input"))}function Mr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}const Ir=/\s+/;function Fr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ir).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ir).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function Rr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&k(e,Hr(t.name||"v")),k(e,t),e}return"string"==typeof t?Hr(t):void 0}}const Hr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),Br=U&&!J;let Ur="transition",zr="transitionend",Vr="animation",Kr="animationend";Br&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ur="WebkitTransition",zr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Vr="WebkitAnimation",Kr="webkitAnimationEnd"));const qr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Jr(t){qr((()=>{qr(t)}))}function Wr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Fr(t,e))}function Zr(t,e){t._transitionClasses&&m(t._transitionClasses,e),Pr(t,e)}function Gr(t,e,n){const{type:o,timeout:r,propCount:i}=Yr(t,e);if(!o)return n();const s="transition"===o?zr:Kr;let a=0;const c=()=>{t.removeEventListener(s,l),n()},l=e=>{e.target===t&&++a>=i&&c()};setTimeout((()=>{a<i&&c()}),r+1),t.addEventListener(s,l)}const Xr=/\b(transform|all)(,|$)/;function Yr(t,e){const n=window.getComputedStyle(t),o=(n[Ur+"Delay"]||"").split(", "),r=(n[Ur+"Duration"]||"").split(", "),i=Qr(o,r),s=(n[Vr+"Delay"]||"").split(", "),a=(n[Vr+"Duration"]||"").split(", "),c=Qr(s,a);let l,u=0,f=0;"transition"===e?i>0&&(l="transition",u=i,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(i,c),l=u>0?i>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Xr.test(n[Ur+"Property"])}}function Qr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>ti(e)+ti(t[n]))))}function ti(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ei(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const s=Rr(t.data.transition);if(e(s))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=s;let A=Ke,k=Ke.$vnode;for(;k&&k.parent;)A=k.context,k=k.parent;const O=!A._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,L=O&&"function"==typeof b?b:g,D=O&&w||v,M=O&&C||$,I=f(i(x)?x.enter:x),F=!1!==a&&!J,P=oi(L),R=r._enterCb=j((()=>{F&&(Zr(r,N),Zr(r,T)),R.cancelled?(F&&Zr(r,S),M&&M(r)):D&&D(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(r,R)})),E&&E(r),F&&(Wr(r,S),Wr(r,T),Jr((()=>{Zr(r,S),R.cancelled||(Wr(r,N),P||(ni(I)?setTimeout(R,I):Gr(r,c,R)))}))),t.data.show&&(o&&o(),L&&L(r,R)),F||P||R()}function ni(t){return"number"==typeof t&&!isNaN(t)}function oi(t){if(e(t))return!1;const o=t.fns;return n(o)?oi(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function ri(t){return!t.componentInstance||t.data&&t.data.transition?t:ri(t.componentInstance._vnode)}var ii={model:Sr,show:{bind(t,{value:e},n){const o=(n=ri(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,ei(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:o,oldValue:r},s){if(!o==!r)return;(s=ri(s)).data&&s.data.transition?(s.data.show=!0,o?ei(s,(()=>{t.style.display=t.__vOriginalDisplay})):function(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const s=Rr(t.data.transition);if(e(s)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=s,$=!1!==a&&!J,_=oi(h),b=f(i(v)?v.leave:v),w=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(Zr(r,u),Zr(r,d)),w.cancelled?($&&Zr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(Wr(r,l),Wr(r,d),Jr((()=>{Zr(r,l),w.cancelled||(Wr(r,u),_||(ni(b)?setTimeout(w,b):Gr(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}(s,(()=>{t.style.display="none"}))):t.style.display=o?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}}};const si={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ai(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?ai(He(e.children)):t}function ci(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function li(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const ui=t=>t.tag||Re(t),fi=t=>"show"===t.name;var di={name:"transition",props:si,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(ui),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const i=ai(o);if(!i)return o;if(this._leaving)return li(t,o);const s=`__transition-${this._uid}-`;i.key=null==i.key?i.isComment?s+"comment":s+i.tag:r(i.key)?0===String(i.key).indexOf(s)?i.key:s+i.key:i.key;const a=(i.data||(i.data={})).transition=ci(this),c=this._vnode,l=ai(c);if(i.data.directives&&i.data.directives.some(fi)&&(i.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(i,l)&&!Re(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=k({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),li(t,o);if("in-out"===n){if(Re(i))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const pi=k({tag:String,moveClass:String},si);function hi(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function mi(t){t.data.newPos=t.elm.getBoundingClientRect()}function yi(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete pi.mode;var gi={Transition:di,TransitionGroup:{props:pi,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=qe(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],i=this.children=[],s=ci(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(i.push(e),n[e.key]=e,(e.data||(e.data={})).transition=s)}if(o){const r=[],i=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=s,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):i.push(e)}this.kept=t(e,null,r),this.removed=i}return t(e,null,i)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(hi),t.forEach(mi),t.forEach(yi),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Wr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(zr,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(zr,t),n._moveCb=null,Zr(n,e))})}})))},methods:{hasMove(t,e){if(!Br)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{Pr(n,t)})),Fr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Yr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,$n.config.isReservedTag=zn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=function(t){return Un(t)?"svg":"math"===t?"math":void 0},$n.config.isUnknownElement=function(t){if(!U)return!0;if(zn(t))return!1;if(t=t.toLowerCase(),null!=Vn[t])return Vn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Vn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Vn[t]=/HTMLUnknownElement/.test(e.toString())},k($n.options.directives,ii),k($n.options.components,gi),$n.prototype.__patch__=U?Or:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ge(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ge(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ge(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((()=>{I.devtools&&et&&et.emit("init",$n)}),0);const vi=d("input,textarea,option,select,progress"),$i=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),_i=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function bi(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}const wi=/\{\{((?:.|\r?\n)+?)\}\}/g,Ci=/[-.*+?^${}()|[\]\/\\]/g,xi=v((t=>{const e=t[0].replace(Ci,"\\$&"),n=t[1].replace(Ci,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var Ai={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=Ao(t,"class");n&&(t.staticClass=JSON.stringify(n));const o=xo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var ki={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=Ao(t,"style");n&&(t.staticStyle=JSON.stringify(Yo(n)));const o=xo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let Oi;var Si={decode:t=>(Oi=Oi||document.createElement("div"),Oi.innerHTML=t,Oi.textContent)};const Ti=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ni=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ei=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Li=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,ji=`((?:${Li}\\:)?${Li})`,Di=new RegExp(`^<${ji}`),Mi=/^\s*(\/?)>/,Ii=new RegExp(`^<\\/${ji}[^>]*>`),Fi=/^<!DOCTYPE [^>]+>/i,Pi=/^<!\--/,Ri=/^<!\[/,Hi=d("script,style,textarea",!0),Bi={},Ui={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},zi=/&(?:lt|gt|quot|amp|#39);/g,Vi=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ki=d("pre,textarea",!0),qi=(t,e)=>t&&Ki(t)&&"\n"===e[0];function Ji(t,e){const n=e?Vi:zi;return t.replace(n,(t=>Ui[t]))}const Wi=/^@|^v-on:/,Zi=/^v-|^@|^:|^#/,Gi=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Xi=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Yi=/^\(|\)$/g,Qi=/^\[.*\]$/,ts=/:(.*)$/,es=/^:|^\.|^v-bind:/,ns=/\.[^.\]]+(?=[^\]]*$)/g,os=/^v-slot(:|$)|^#/,rs=/[\r\n]/,is=/[ \f\t\r\n]+/g,ss=v(Si.decode);let as,cs,ls,us,fs,ds,ps,hs;function ms(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ws(e),rawAttrsMap:{},parent:n,children:[]}}function ys(t,e){as=e.warn||yo,ds=e.isPreTag||T,ps=e.mustUseProp||T,hs=e.getTagNamespace||T,e.isReservedTag,ls=go(e.modules,"transformNode"),us=go(e.modules,"preTransformNode"),fs=go(e.modules,"postTransformNode"),cs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let i,s,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=gs(t,e)),n.length||t===i||i.if&&(t.elseif||t.else)&&$s(i,{exp:t.elseif,block:t}),s&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&$s(n,{exp:t.elseif,block:t})}(t,s);else{if(t.slotScope){const e=t.slotTarget||'"default"';(s.scopedSlots||(s.scopedSlots={}))[e]=t}s.children.push(t),t.parent=s}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),ds(t.tag)&&(c=!1);for(let n=0;n<fs.length;n++)fs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,i=e.canBeLeftOpenTag||T;let s,a,c=0;for(;t;){if(s=t,a&&Hi(a)){let n=0;const o=a.toLowerCase(),r=Bi[o]||(Bi[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),i=t.replace(r,(function(t,r,i){return n=i.length,Hi(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),qi(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-i.length,t=i,d(o,c-n,c)}else{let n,o,r,i=t.indexOf("<");if(0===i){if(Pi.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(Ri.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Fi);if(n){l(n[0].length);continue}const o=t.match(Ii);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),qi(r.tagName,t)&&l(1);continue}}if(i>=0){for(o=t.slice(i);!(Ii.test(o)||Di.test(o)||Pi.test(o)||Ri.test(o)||(r=o.indexOf("<",1),r<0));)i+=r,o=t.slice(i);n=t.substring(0,i)}i<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===s){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(Di);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(Mi))&&(r=t.match(Ei)||t.match(Ni));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const s=t.tagName,c=t.unarySlash;o&&("p"===a&&Ti(s)&&d(a),i(s)&&a===s&&d(s));const l=r(s)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",i="a"===s&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ji(r,i)}}l||(n.push({tag:s,lowerCasedTag:s.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=s),e.start&&e.start(s,f,l,t.start,t.end)}function d(t,o,r){let i,s;if(null==o&&(o=c),null==r&&(r=c),t)for(s=t.toLowerCase(),i=n.length-1;i>=0&&n[i].lowerCasedTag!==s;i--);else i=0;if(i>=0){for(let t=n.length-1;t>=i;t--)e.end&&e.end(n[t].tag,o,r);n.length=i,a=i&&n[i-1].tag}else"br"===s?e.start&&e.start(t,[],!0,o,r):"p"===s&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:as,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=s&&s.ns||hs(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];Cs.test(o.name)||(o.name=o.name.replace(xs,""),e.push(o))}return e}(o));let p=ms(t,o,s);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<us.length;t++)p=us[t](p,e)||p;a||(!function(t){null!=Ao(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),ds(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(vs(p),function(t){const e=Ao(t,"v-if");if(e)t.if=e,$s(t,{exp:e,block:t});else{null!=Ao(t,"v-else")&&(t.else=!0);const e=Ao(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=Ao(t,"v-once")&&(t.once=!0)}(p)),i||(i=p),r?l(p):(s=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,s=n[n.length-1],l(r)},chars(t,e,n){if(!s)return;if(q&&"textarea"===s.tag&&s.attrsMap.placeholder===t)return;const i=s.children;var l;if(t=c||t.trim()?"script"===(l=s).tag||"style"===l.tag?t:ss(t):i.length?r?"condense"===r&&rs.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(is," ")),!a&&" "!==t&&(e=function(t,e){const n=e?xi(e):wi;if(!n.test(t))return;const o=[],r=[];let i,s,a,c=n.lastIndex=0;for(;i=n.exec(t);){s=i.index,s>c&&(r.push(a=t.slice(c,s)),o.push(JSON.stringify(a)));const e=ho(i[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=s+i[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,cs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&i.length&&" "===i[i.length-1].text||(n={type:3,text:t}),n&&i.push(n)}},comment(t,e,n){if(s){const e={type:3,text:t,isComment:!0};s.children.push(e)}}}),i}function gs(t,e){var n;!function(t){const e=xo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=xo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=Ao(t,"scope"),t.slotScope=e||Ao(t,"slot-scope")):(e=Ao(t,"slot-scope"))&&(t.slotScope=e);const n=xo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||$o(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=ko(t,os);if(e){const{name:n,dynamic:o}=_s(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=ko(t,os);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=_s(e),i=n[o]=ms("template",[],t);i.slotTarget=o,i.slotTargetDynamic=r,i.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=i,!0})),i.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=xo(n,"name")),function(t){let e;(e=xo(t,"is"))&&(t.component=e);null!=Ao(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<ls.length;n++)t=ls[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,i,s,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=i=e[n].name,s=e[n].value,Zi.test(r))if(t.hasBindings=!0,a=bs(r.replace(Zi,"")),a&&(r=r.replace(ns,"")),es.test(r))r=r.replace(es,""),s=ho(s),l=Qi.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=To(s,"$event"),l?Co(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Co(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Co(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&ps(t.tag,t.attrsMap.type,r)?vo(t,r,s,e[n],l):$o(t,r,s,e[n],l);else if(Wi.test(r))r=r.replace(Wi,""),l=Qi.test(r),l&&(r=r.slice(1,-1)),Co(t,r,s,a,!1,0,e[n],l);else{r=r.replace(Zi,"");const o=r.match(ts);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Qi.test(c)&&(c=c.slice(1,-1),l=!0)),bo(t,r,i,s,c,l,a,e[n])}else $o(t,r,JSON.stringify(s),e[n]),!t.component&&"muted"===r&&ps(t.tag,t.attrsMap.type,r)&&vo(t,r,"true",e[n])}(t),t}function vs(t){let e;if(e=Ao(t,"v-for")){const n=function(t){const e=t.match(Gi);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Yi,""),r=o.match(Xi);r?(n.alias=o.replace(Xi,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&k(t,n)}}function $s(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function _s(t){let e=t.name.replace(os,"");return e||"#"!==t.name[0]&&(e="default"),Qi.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function bs(t){const e=t.match(ns);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ws(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const Cs=/^xmlns:NS\d+/,xs=/^NS\d+:/;function As(t){return ms(t.tag,t.attrsList.slice(),t.parent)}var ks=[Ai,ki,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=xo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=Ao(t,"v-if",!0),r=n?`&&(${n})`:"",i=null!=Ao(t,"v-else",!0),s=Ao(t,"v-else-if",!0),a=As(t);vs(a),_o(a,"type","checkbox"),gs(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,$s(a,{exp:a.if,block:a});const c=As(t);Ao(c,"v-for",!0),_o(c,"type","radio"),gs(c,e),$s(a,{exp:`(${o})==='radio'`+r,block:c});const l=As(t);return Ao(l,"v-for",!0),_o(l,":type",o),gs(l,e),$s(a,{exp:n,block:l}),i?a.else=!0:s&&(a.elseif=s),a}}}}];const Os={expectHTML:!0,modules:ks,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,i=t.tag,s=t.attrsMap.type;if(t.component)return So(t,o,r),!1;if("select"===i)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${To(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Co(t,"change",r,null,!0)}(t,o,r);else if("input"===i&&"checkbox"===s)!function(t,e,n){const o=n&&n.number,r=xo(t,"value")||"null",i=xo(t,"true-value")||"true",s=xo(t,"false-value")||"false";vo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===i?`:(${e})`:`:_q(${e},${i})`)),Co(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${i}):(${s});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${To(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${To(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${To(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===i&&"radio"===s)!function(t,e,n){const o=n&&n.number;let r=xo(t,"value")||"null";r=o?`_n(${r})`:r,vo(t,"checked",`_q(${e},${r})`),Co(t,"change",To(e,r),null,!0)}(t,o,r);else if("input"===i||"textarea"===i)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:i,trim:s}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";s&&(l="$event.target.value.trim()");i&&(l=`_n(${l})`);let u=To(e,l);a&&(u=`if($event.target.composing)return;${u}`);vo(t,"value",`(${e})`),Co(t,c,u,null,!0),(s||i)&&Co(t,"blur","$forceUpdate()")}(t,o,r);else if(!I.isReservedTag(i))return So(t,o,r),!1;return!0},text:function(t,e){e.value&&vo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&vo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:(t,e,n)=>"value"===n&&vi(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,canBeLeftOpenTag:d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:t=>$i(t)||_i(t),getTagNamespace:function(t){return _i(t)?"svg":"math"===t?"math":void 0},staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(ks)};let Ss,Ts;const Ns=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function Es(t,e){t&&(Ss=Ns(e.staticKeys||""),Ts=e.isReservedTag||T,Ls(t),js(t,!1))}function Ls(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!Ts(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(Ss)))}(t),1===t.type){if(!Ts(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];Ls(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;Ls(n),n.static||(t.static=!1)}}}function js(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)js(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)js(t.ifConditions[n].block,e)}}const Ds=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ms=/\([^)]*?\);*$/,Is=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Fs={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ps={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Rs=t=>`if(${t})return null;`,Hs={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Rs("$event.target !== $event.currentTarget"),ctrl:Rs("!$event.ctrlKey"),shift:Rs("!$event.shiftKey"),alt:Rs("!$event.altKey"),meta:Rs("!$event.metaKey"),left:Rs("'button' in $event && $event.button !== 0"),middle:Rs("'button' in $event && $event.button !== 1"),right:Rs("'button' in $event && $event.button !== 2")};function Bs(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Us(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Us(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Us(t))).join(",")}]`;const e=Is.test(t.value),n=Ds.test(t.value),o=Is.test(t.value.replace(Ms,""));if(t.modifiers){let r="",i="";const s=[];for(const e in t.modifiers)if(Hs[e])i+=Hs[e],Fs[e]&&s.push(e);else if("exact"===e){const e=t.modifiers;i+=Rs(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else s.push(e);s.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(zs).join("&&")})return null;`}(s)),i&&(r+=i);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function zs(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Fs[t],o=Ps[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Vs={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ks{constructor(t){this.options=t,this.warn=t.warn||yo,this.transforms=go(t.modules,"transformCode"),this.dataGenFns=go(t.modules,"genData"),this.directives=k(k({},Vs),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function qs(t,e){const n=new Ks(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Js(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Js(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ws(t,e);if(t.once&&!t.onceProcessed)return Zs(t,e);if(t.for&&!t.forProcessed)return Ys(t,e);if(t.if&&!t.ifProcessed)return Gs(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=na(t,e);let r=`_t(${n}${o?`,${o}`:""}`;const i=t.attrs||t.dynamicAttrs?ia((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,s=t.attrsMap["v-bind"];!i&&!s||o||(r+=",null");i&&(r+=`,${i}`);s&&(r+=`${i?"":",null"},${s}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:na(e,n,!0);return`_c(${t},${Qs(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Qs(t,e));const r=t.inlineTemplate?null:na(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return na(t,e)||"void 0"}function Ws(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Js(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Zs(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Gs(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Js(t,e)},${e.onceId++},${n})`:Js(t,e)}return Ws(t,e)}function Gs(t,e,n,o){return t.ifProcessed=!0,Xs(t.ifConditions.slice(),e,n,o)}function Xs(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${i(r.block)}:${Xs(t,e,n,o)}`:`${i(r.block)}`;function i(t){return n?n(t,e):t.once?Zs(t,e):Js(t,e)}}function Ys(t,e,n,o){const r=t.for,i=t.alias,s=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${i}${s}${a}){return ${(n||Js)(t,e)}})`}function Qs(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,i,s,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){i=n[o],s=!0;const r=e.directives[i.name];r&&(s=!!r(t,i,e.warn)),s&&(c=!0,a+=`{name:"${i.name}",rawName:"${i.rawName}"${i.value?`,value:(${i.value}),expression:${JSON.stringify(i.value)}`:""}${i.arg?`,arg:${i.isDynamicArg?i.arg:`"${i.arg}"`}`:""}${i.modifiers?`,modifiers:${JSON.stringify(i.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${ia(t.attrs)},`),t.props&&(n+=`domProps:${ia(t.props)},`),t.events&&(n+=`${Bs(t.events,!1)},`),t.nativeEvents&&(n+=`${Bs(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||ta(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const i=Object.keys(e).map((t=>ea(e[t],n))).join(",");return`scopedSlots:_u([${i}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(i)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=qs(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${ia(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function ta(t){return 1===t.type&&("slot"===t.tag||t.children.some(ta))}function ea(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Gs(t,e,ea,"null");if(t.for&&!t.forProcessed)return Ys(t,e,ea);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${na(t,e)||"undefined"}:undefined`:na(t,e)||"undefined":Js(t,e)}}`,i=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${i}}`}function na(t,e,n,o,r){const i=t.children;if(i.length){const t=i[0];if(1===i.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Js)(t,e)}${r}`}const s=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(oa(r)||r.ifConditions&&r.ifConditions.some((t=>oa(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(i,e.maybeComponent):0,a=r||ra;return`[${i.map((t=>a(t,e))).join(",")}]${s?`,${s}`:""}`}}function oa(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function ra(t,e){return 1===t.type?Js(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:sa(JSON.stringify(t.text))})`}(t)}function ia(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],i=sa(r.value);r.dynamic?n+=`${r.name},${i},`:e+=`"${r.name}":${i},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function sa(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function aa(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function ca(t){const e=Object.create(null);return function(n,o,r){(o=k({},o)).warn,delete o.warn;const i=o.delimiters?String(o.delimiters)+n:n;if(e[i])return e[i];const s=t(n,o),a={},c=[];return a.render=aa(s.render,c),a.staticRenderFns=s.staticRenderFns.map((t=>aa(t,c))),e[i]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");const la=(ua=function(t,e){const n=ys(t.trim(),e);!1!==e.optimize&&Es(n,e);const o=qs(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],i=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=k(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?i:r).push(t)};const s=ua(e.trim(),o);return s.errors=r,s.tips=i,s}return{compile:e,compileToFunctions:ca(e)}});var ua;const{compile:fa,compileToFunctions:da}=la(Os);let pa;function ha(t){return pa=pa||document.createElement("div"),pa.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',pa.innerHTML.indexOf("&#10;")>0}const ma=!!U&&ha(!1),ya=!!U&&ha(!0),ga=v((t=>{const e=bi(t);return e&&e.innerHTML})),va=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&bi(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=ga(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=da(e,{outputSourceRange:!1,shouldDecodeNewlines:ma,shouldDecodeNewlinesForHref:ya,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return va.call(this,t,e)},$n.compile=da;export default $n;
\ No newline at end of file
+const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,E=t=>t;function N(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>N(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>N(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(N(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const L=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const G=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{constructor(){this.set=Object.create(null)}has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let st=S,it=0;class at{constructor(){this.id=it++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const s=new at,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function kt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}const At=I.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=ot?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{At[t]=Tt})),L.forEach((function(t){At[t+"s"]=Et})),At.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Nt=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Nt;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function Lt(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==It(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(i),$t(e)}return i}const Mt=/^\s*function (\w+)/;function It(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return It(t)===It(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Rt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Rt(t,o,r)}return s}function Bt(t,e,n){if(I.errorHandler)try{return I.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,qt=!1;function Jt(){qt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(Jt),Z&&setTimeout(S)},zt=!0}else if(q||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(Jt)}:()=>{setTimeout(Jt,0)};else{let t=1;const e=new MutationObserver(Jt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Zt=new rt;function Gt(t){Xt(t,Zt),Zt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),s(f.name,n[c],f.capture))}function ee(t,r,s){let i;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ne(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?se(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=se(c,`${s||""}_${a}`),re(c[0])&&re(u)&&(i[l]=pt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?re(u)?i[l]=pt(u.text+c):""!==c&&i.push(pt(c)):re(c)&&re(u)?i[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ie(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ue(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=fe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",i),R(r,"$key",a),R(r,"$hasNormal",s),r}function ue(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});return t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t),t&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function fe(t,e){return()=>t[e]}function de(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||e):s=this.$slots[t]||e;const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function he(t){return Dt(this.$options,"filters",t)||E}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,o,r){const s=I.keyCodes[e]||n;return r&&o&&!I.keyCodes[e]?me(r,o):s?me(s,t):o?C(o)!==e:void 0}function ge(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||I.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function ve(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),_e(o,`__static__${t}`,!1)),o}function $e(t,e,n){return _e(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function _e(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&be(t[o],`${e}_${o}`,n);else be(t,e,n)}function be(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function Ce(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?Ce(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function xe(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function ke(t,e){return"string"==typeof t?e+t:t}function Ae(t){t._o=$e,t._n=f,t._s=u,t._l=de,t._t=pe,t._q=N,t._i=j,t._m=ve,t._f=he,t._k=ye,t._b=ge,t._v=pt,t._e=dt,t._u=Ce,t._g=we,t._d=xe,t._p=ke}function Oe(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ie(a.inject,s),this.slots=()=>(this.$slots||le(e.scopedSlots,this.$slots=ae(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Le(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Le(c,t,e,n,o,u)}function Se(t,e,n,o,r){const s=ht(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Te(t,e){for(const n in e)t[_(n)]=e[n]}Ae(Oe.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Lt(s,i,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ge(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ze(e,!0):e.$destroy())}},Ne=Object.keys(Ee);function je(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,void 0===(r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Fe;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=Pe(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Pe(h.error,r)),n(h.loading)&&(t.loadingComp=Pe(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f))))return function(t,e,n,o,r){const s=dt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ne(i,c,t,e,!0)||ne(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Lt(e,l,o||t);else n(r.attrs)&&Te(c,r.attrs),n(r.props)&&Te(c,r.props);const u=new Oe(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Se(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Se(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Ne.length;t++){const n=Ne[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?De(r,o):r)}}(i);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function De(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Le(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=oe(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||I.getTagNamespace(e),a=I.isReservedTag(e)?new ft(I.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=Dt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):je(s,o,t,r,e)}else a=je(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Me(a,c),n(o)&&function(t){s(t.style)&&Gt(t.style);s(t.class)&&Gt(t.class)}(o),a):dt()}(t,e,i,a,c)}function Me(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Me(a,r,s)}}let Ie,Fe=null;function Pe(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Re(t){return t.isComment&&t.asyncFactory}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||Re(o)))return o}}function Be(t,e){Ie.$on(t,e)}function Ue(t,e){Ie.$off(t,e)}function ze(t,e){const n=Ie;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Ie=t,te(e,n||{},Be,Ue,ze,t),Ie=void 0}let Ke=null;function qe(t){const e=Ke;return Ke=t,()=>{Ke=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ge(t,"activated")}}function Ze(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ze(t.$children[e]);Ge(t,"deactivated")}}function Ge(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!q){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ge(o,"updated")}}(o),et&&I.devtools&&et.emit("flush")}let an=0;class cn{constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Gt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const s in e){r.push(s);wt(o,s,Lt(s,e,n,t)),s in t||un(t,"_props",s)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new cn(t,i||S,S,dn)),r in t||pn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=jt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,L.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=bn(s.componentOptions);i&&!e(i)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Le(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Le(e,t,n,o,r,!0);const s=o&&o.data;wt(e,"$attrs",s&&s.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ge(n,"beforeCreate"),function(t){const e=ie(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ge(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){lt();try{e.call(o,r.value)}catch(t){Rt(t,o,`callback for immediate watcher "${r.expression}"`)}ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=qe(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ge(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ge(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){Ae(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=le(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Fe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Fe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const kn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(s[a]=e,i.push(a),this.max&&i.length>parseInt(this.max)&&xn(s,i[0],i,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>I};Object.defineProperty(t,"config",e),t.util={warn:st,extend:A,mergeOptions:jt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),L.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),_n(t),function(t){L.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Oe}),$n.version="2.6.12";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=d("contenteditable,draggable,spellcheck"),En=d("events,caret,typing,plaintext-only"),Nn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),jn="http://www.w3.org/1999/xlink",Dn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Ln=t=>Dn(t)?t.slice(6,t.length):"",Mn=t=>null==t||!1===t;function In(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Fn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Fn(e,o.data));return function(t,e){if(n(t)||n(e))return Pn(t,Rn(e));return""}(e.staticClass,e.class)}function Fn(t,e){return{staticClass:Pn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Pn(t,e){return t?e?t+" "+e:t:e||""}function Rn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Rn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Bn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Un=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),zn=t=>Bn(t)||Un(t);const Vn=Object.create(null);const Kn=d("text,number,password,search,email,tel,url");var qn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Jn={create(t,e){Wn(e)},update(t,e){t.data.ref!==e.data.ref&&(Wn(t,!0),Wn(e))},destroy(t){Wn(t,!0)}};function Wn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs;e?Array.isArray(i[o])?m(i[o],s):i[o]===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(i[o])?i[o].indexOf(s)<0&&i[o].push(s):i[o]=[s]:i[o]=s}const Zn=new ft("",{},[]),Gn=["create","activate","update","remove","destroy"];function Xn(t,r){return t.key===r.key&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Kn(r)&&Kn(s)}(t,r)||o(t.isAsyncPlaceholder)&&t.asyncFactory===r.asyncFactory&&e(r.asyncFactory.error))}function Yn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var Qn={create:to,update:to,destroy:function(t){to(t,Zn)}};function to(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Zn,o=e===Zn,r=no(t.data.directives,t.context),s=no(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ro(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ro(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)ro(i[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ro(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||ro(r[c],"unbind",t,t,o)}(t,e)}const eo=Object.create(null);function no(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=eo),n[oo(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function oo(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ro(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var so=[Jn,Qn];function io(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&ao(c,s,i,o.data.pre);for(s in(q||W)&&u.value!==l.value&&ao(c,"value",u.value),l)e(u[s])&&(Dn(s)?c.removeAttributeNS(jn,Ln(s)):Tn(s)||c.removeAttribute(s))}function ao(t,e,n,o){o||t.tagName.indexOf("-")>-1?co(t,e,n):Nn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,((t,e)=>Mn(e)||"false"===e?"false":"contenteditable"===t&&En(e)?e:"true")(e,n)):Dn(e)?Mn(n)?t.removeAttributeNS(jn,Ln(e)):t.setAttributeNS(jn,e,n):co(t,e,n)}function co(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(q&&!J&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var lo={create:io,update:io};function uo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=In(o);const c=r._transitionClasses;n(c)&&(a=Pn(a,Rn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var fo={create:uo,update:uo};const po=/[\w).+\-_$\]]/;function ho(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&po.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=mo(r,s[o]);return r}function mo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function yo(t,e){console.error(`[Vue compiler]: ${t}`)}function go(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function vo(t,e,n,o,r){(t.props||(t.props=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function $o(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function _o(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(Oo({name:e,value:n},o))}function bo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(Oo({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function wo(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Co(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=wo("!",n,c)),r.once&&(delete r.once,n=wo("~",n,c)),r.passive&&(delete r.passive,n=wo("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=Oo({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function xo(t,e,n){const o=ko(t,":"+e)||ko(t,"v-bind:"+e);if(null!=o)return ho(o);if(!1!==n){const n=ko(t,e);if(null!=n)return JSON.stringify(n)}}function ko(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function Ao(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function Oo(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function So(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=To(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function To(t,e){const n=function(t){if(t=t.trim(),Eo=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Eo-1)return Do=t.lastIndexOf("."),Do>-1?{exp:t.slice(0,Do),key:'"'+t.slice(Do+1)+'"'}:{exp:t,key:null};No=t,Do=Lo=Mo=0;for(;!Fo();)jo=Io(),Po(jo)?Ho(jo):91===jo&&Ro(jo);return{exp:t.slice(0,Lo),key:t.slice(Lo+1,Mo)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Eo,No,jo,Do,Lo,Mo;function Io(){return No.charCodeAt(++Do)}function Fo(){return Do>=Eo}function Po(t){return 34===t||39===t}function Ro(t){let e=1;for(Lo=Do;!Fo();)if(Po(t=Io()))Ho(t);else if(91===t&&e++,93===t&&e--,0===e){Mo=Do;break}}function Ho(t){const e=t;for(;!Fo()&&(t=Io())!==e;);}let Bo;function Uo(t,e,n){const o=Bo;return function r(){const s=e.apply(null,arguments);null!==s&&Ko(t,r,n,o)}}const zo=zt&&!(G&&Number(G[1])<=53);function Vo(t,e,n,o){if(zo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Bo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Ko(t,e,n,o){(o||Bo).removeEventListener(t,e._wrapper||e,n)}function qo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Bo=o.elm,function(t){if(n(t.__r)){const e=q?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,s,Vo,Ko,Uo,o.context),Bo=void 0}var Jo={create:qo,update:qo};let Wo;function Zo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Go(i,t)&&(i.value=t)}else if("innerHTML"===r&&Un(i.tagName)&&e(i.innerHTML)){Wo=Wo||document.createElement("div"),Wo.innerHTML=`<svg>${s}</svg>`;const t=Wo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Go(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var Xo={create:Zo,update:Zo};const Yo=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function Qo(t){const e=tr(t.style);return t.staticStyle?A(t.staticStyle,e):e}function tr(t){return Array.isArray(t)?O(t):"string"==typeof t?Yo(t):t}const er=/^--/,nr=/\s*!important$/,or=(t,e,n)=>{if(er.test(e))t.style.setProperty(e,n);else if(nr.test(n))t.style.setProperty(C(e),n.replace(nr,""),"important");else{const o=ir(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},rr=["Webkit","Moz","ms"];let sr;const ir=v((function(t){if(sr=sr||document.createElement("div").style,"filter"!==(t=_(t))&&t in sr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<rr.length;t++){const n=rr[t]+e;if(n in sr)return n}}));function ar(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=tr(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=Qo(e.data))&&A(n,o)}(o=Qo(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=Qo(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&or(c,a,"");for(a in p)i=p[a],i!==f[a]&&or(c,a,null==i?"":i)}var cr={create:ar,update:ar};const lr=/\s+/;function ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function fr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function dr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,pr(t.name||"v")),A(e,t),e}return"string"==typeof t?pr(t):void 0}}const pr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),hr=U&&!J;let mr="transition",yr="transitionend",gr="animation",vr="animationend";hr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(mr="WebkitTransition",yr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(gr="WebkitAnimation",vr="webkitAnimationEnd"));const $r=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function _r(t){$r((()=>{$r(t)}))}function br(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),ur(t,e))}function wr(t,e){t._transitionClasses&&m(t._transitionClasses,e),fr(t,e)}function Cr(t,e,n){const{type:o,timeout:r,propCount:s}=kr(t,e);if(!o)return n();const i="transition"===o?yr:vr;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const xr=/\b(transform|all)(,|$)/;function kr(t,e){const n=window.getComputedStyle(t),o=(n[mr+"Delay"]||"").split(", "),r=(n[mr+"Duration"]||"").split(", "),s=Ar(o,r),i=(n[gr+"Delay"]||"").split(", "),a=(n[gr+"Duration"]||"").split(", "),c=Ar(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&xr.test(n[mr+"Property"])}}function Ar(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Or(e)+Or(t[n]))))}function Or(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Sr(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=dr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Ke,A=Ke.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,E=O&&h?h:u,N=O&&_||y,j=O&&"function"==typeof b?b:g,L=O&&w||v,M=O&&C||$,I=f(s(x)?x.enter:x),F=!1!==a&&!J,P=Nr(j),R=r._enterCb=D((()=>{F&&(wr(r,E),wr(r,T)),R.cancelled?(F&&wr(r,S),M&&M(r)):L&&L(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),N&&N(r),F&&(br(r,S),br(r,T),_r((()=>{wr(r,S),R.cancelled||(br(r,E),P||(Er(I)?setTimeout(R,I):Cr(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function Tr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=dr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!J,_=Nr(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(wr(r,u),wr(r,d)),w.cancelled?($&&wr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(br(r,l),br(r,d),_r((()=>{wr(r,l),w.cancelled||(br(r,u),_||(Er(b)?setTimeout(w,b):Cr(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Er(t){return"number"==typeof t&&!isNaN(t)}function Nr(t){if(e(t))return!1;const o=t.fns;return n(o)?Nr(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function jr(t,e){!0!==e.data.show&&Sr(e)}const Dr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Gn.length;++s)for(a[Gn[s]]=[],i=0;i<c.length;++i)n(c[i][Gn[s]])&&a[Gn[s]].push(c[i][Gn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Zn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Wn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Zn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Xn(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:Xn(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):Xn(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):Xn(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):Xn(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=Yn(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],Xn(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Gt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Xn(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Wn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:qn,modules:[lo,fo,Jo,Xo,cr,U?{create:jr,activate:jr,remove(t,e){!0!==t.data.show?Tr(t,e):e()}}:{}].concat(so)});J&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Br(t,"input")}));const Lr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Lr.componentUpdated(t,e,n)})):Mr(t,e,n.context),t._vOptions=[].map.call(t.options,Pr)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Rr),t.addEventListener("compositionend",Hr),t.addEventListener("change",Hr),J&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Mr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Pr);if(r.some(((t,e)=>!N(t,o[e])))){(t.multiple?e.value.some((t=>Fr(t,r))):e.value!==e.oldValue&&Fr(e.value,r))&&Br(t,"change")}}}};function Mr(t,e,n){Ir(t,e),(q||W)&&setTimeout((()=>{Ir(t,e)}),0)}function Ir(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Pr(i))>-1,i.selected!==s&&(i.selected=s);else if(N(Pr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Fr(t,e){return e.every((e=>!N(e,t)))}function Pr(t){return"_value"in t?t._value:t.value}function Rr(t){t.target.composing=!0}function Hr(t){t.target.composing&&(t.target.composing=!1,Br(t.target,"input"))}function Br(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Ur(t){return!t.componentInstance||t.data&&t.data.transition?t:Ur(t.componentInstance._vnode)}var zr={model:Lr,show:{bind(t,{value:e},n){const o=(n=Ur(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Sr(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Ur(o)).data&&o.data.transition?(o.data.show=!0,e?Sr(o,(()=>{t.style.display=t.__vOriginalDisplay})):Tr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}}};const Vr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Kr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Kr(He(e.children)):t}function qr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Jr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Wr=t=>t.tag||Re(t),Zr=t=>"show"===t.name;var Gr={name:"transition",props:Vr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Wr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Kr(o);if(!s)return o;if(this._leaving)return Jr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=qr(this),c=this._vnode,l=Kr(c);if(s.data.directives&&s.data.directives.some(Zr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!Re(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),Jr(t,o);if("in-out"===n){if(Re(s))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const Xr=A({tag:String,moveClass:String},Vr);function Yr(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Qr(t){t.data.newPos=t.elm.getBoundingClientRect()}function ts(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete Xr.mode;var es={Transition:Gr,TransitionGroup:{props:Xr,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=qe(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=qr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Yr),t.forEach(Qr),t.forEach(ts),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;br(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(yr,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(yr,t),n._moveCb=null,wr(n,e))})}})))},methods:{hasMove(t,e){if(!hr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{fr(n,t)})),ur(n,e),n.style.display="none",this.$el.appendChild(n);const o=kr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,$n.config.isReservedTag=zn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=function(t){return Un(t)?"svg":"math"===t?"math":void 0},$n.config.isUnknownElement=function(t){if(!U)return!0;if(zn(t))return!1;if(t=t.toLowerCase(),null!=Vn[t])return Vn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Vn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Vn[t]=/HTMLUnknownElement/.test(e.toString())},A($n.options.directives,zr),A($n.options.components,es),$n.prototype.__patch__=U?Dr:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ge(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ge(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ge(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((()=>{I.devtools&&et&&et.emit("init",$n)}),0);const ns=d("input,textarea,option,select,progress"),os=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),rs=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function ss(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}const is=/\{\{((?:.|\r?\n)+?)\}\}/g,as=/[-.*+?^${}()|[\]\/\\]/g,cs=v((t=>{const e=t[0].replace(as,"\\$&"),n=t[1].replace(as,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ls={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=ko(t,"class");n&&(t.staticClass=JSON.stringify(n));const o=xo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var us={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=ko(t,"style");n&&(t.staticStyle=JSON.stringify(Yo(n)));const o=xo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let fs;var ds={decode:t=>(fs=fs||document.createElement("div"),fs.innerHTML=t,fs.textContent)};const ps=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),hs=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ms=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ys=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,gs=`((?:${ys}\\:)?${ys})`,vs=new RegExp(`^<${gs}`),$s=/^\s*(\/?)>/,_s=new RegExp(`^<\\/${gs}[^>]*>`),bs=/^<!DOCTYPE [^>]+>/i,ws=/^<!\--/,Cs=/^<!\[/,xs=d("script,style,textarea",!0),ks={},As={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Os=/&(?:lt|gt|quot|amp|#39);/g,Ss=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ts=d("pre,textarea",!0),Es=(t,e)=>t&&Ts(t)&&"\n"===e[0];function Ns(t,e){const n=e?Ss:Os;return t.replace(n,(t=>As[t]))}const js=/^@|^v-on:/,Ds=/^v-|^@|^:|^#/,Ls=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Ms=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Is=/^\(|\)$/g,Fs=/^\[.*\]$/,Ps=/:(.*)$/,Rs=/^:|^\.|^v-bind:/,Hs=/\.[^.\]]+(?=[^\]]*$)/g,Bs=/^v-slot(:|$)|^#/,Us=/[\r\n]/,zs=/[ \f\t\r\n]+/g,Vs=v(ds.decode);let Ks,qs,Js,Ws,Zs,Gs,Xs,Ys;function Qs(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ii(e),rawAttrsMap:{},parent:n,children:[]}}function ti(t,e){Ks=e.warn||yo,Gs=e.isPreTag||T,Xs=e.mustUseProp||T,Ys=e.getTagNamespace||T,e.isReservedTag,Js=go(e.modules,"transformNode"),Ws=go(e.modules,"preTransformNode"),Zs=go(e.modules,"postTransformNode"),qs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=ei(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&oi(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&oi(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),Gs(t.tag)&&(c=!1);for(let n=0;n<Zs.length;n++)Zs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&xs(a)){let n=0;const o=a.toLowerCase(),r=ks[o]||(ks[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,xs(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Es(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(ws.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(Cs.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(bs);if(n){l(n[0].length);continue}const o=t.match(_s);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),Es(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(_s.test(o)||vs.test(o)||ws.test(o)||Cs.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(vs);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match($s))&&(r=t.match(ms)||t.match(hs));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ps(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ns(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:Ks,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||Ys(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];ai.test(o.name)||(o.name=o.name.replace(ci,""),e.push(o))}return e}(o));let p=Qs(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<Ws.length;t++)p=Ws[t](p,e)||p;a||(!function(t){null!=ko(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),Gs(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ni(p),function(t){const e=ko(t,"v-if");if(e)t.if=e,oi(t,{exp:e,block:t});else{null!=ko(t,"v-else")&&(t.else=!0);const e=ko(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=ko(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(q&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Vs(t):s.length?r?"condense"===r&&Us.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(zs," ")),!a&&" "!==t&&(e=function(t,e){const n=e?cs(e):is;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=ho(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,qs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function ei(t,e){var n;!function(t){const e=xo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=xo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=ko(t,"scope"),t.slotScope=e||ko(t,"slot-scope")):(e=ko(t,"slot-scope"))&&(t.slotScope=e);const n=xo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||$o(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=Ao(t,Bs);if(e){const{name:n,dynamic:o}=ri(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=Ao(t,Bs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ri(e),s=n[o]=Qs("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=xo(n,"name")),function(t){let e;(e=xo(t,"is"))&&(t.component=e);null!=ko(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Js.length;n++)t=Js[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Ds.test(r))if(t.hasBindings=!0,a=si(r.replace(Ds,"")),a&&(r=r.replace(Hs,"")),Rs.test(r))r=r.replace(Rs,""),i=ho(i),l=Fs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=To(i,"$event"),l?Co(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Co(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Co(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&Xs(t.tag,t.attrsMap.type,r)?vo(t,r,i,e[n],l):$o(t,r,i,e[n],l);else if(js.test(r))r=r.replace(js,""),l=Fs.test(r),l&&(r=r.slice(1,-1)),Co(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Ds,"");const o=r.match(Ps);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Fs.test(c)&&(c=c.slice(1,-1),l=!0)),bo(t,r,s,i,c,l,a,e[n])}else $o(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&Xs(t.tag,t.attrsMap.type,r)&&vo(t,r,"true",e[n])}(t),t}function ni(t){let e;if(e=ko(t,"v-for")){const n=function(t){const e=t.match(Ls);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Is,""),r=o.match(Ms);r?(n.alias=o.replace(Ms,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function oi(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ri(t){let e=t.name.replace(Bs,"");return e||"#"!==t.name[0]&&(e="default"),Fs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function si(t){const e=t.match(Hs);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ii(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const ai=/^xmlns:NS\d+/,ci=/^NS\d+:/;function li(t){return Qs(t.tag,t.attrsList.slice(),t.parent)}var ui=[ls,us,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=xo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=ko(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=ko(t,"v-else",!0),i=ko(t,"v-else-if",!0),a=li(t);ni(a),_o(a,"type","checkbox"),ei(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,oi(a,{exp:a.if,block:a});const c=li(t);ko(c,"v-for",!0),_o(c,"type","radio"),ei(c,e),oi(a,{exp:`(${o})==='radio'`+r,block:c});const l=li(t);return ko(l,"v-for",!0),_o(l,":type",o),ei(l,e),oi(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const fi={expectHTML:!0,modules:ui,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return So(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${To(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Co(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=xo(t,"value")||"null",s=xo(t,"true-value")||"true",i=xo(t,"false-value")||"false";vo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Co(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${To(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${To(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${To(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=xo(t,"value")||"null";r=o?`_n(${r})`:r,vo(t,"checked",`_q(${e},${r})`),Co(t,"change",To(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=To(e,l);a&&(u=`if($event.target.composing)return;${u}`);vo(t,"value",`(${e})`),Co(t,c,u,null,!0),(i||s)&&Co(t,"blur","$forceUpdate()")}(t,o,r);else if(!I.isReservedTag(s))return So(t,o,r),!1;return!0},text:function(t,e){e.value&&vo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&vo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:(t,e,n)=>"value"===n&&ns(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,canBeLeftOpenTag:d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:t=>os(t)||rs(t),getTagNamespace:function(t){return rs(t)?"svg":"math"===t?"math":void 0},staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(ui)};let di,pi;const hi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function mi(t,e){t&&(di=hi(e.staticKeys||""),pi=e.isReservedTag||T,yi(t),gi(t,!1))}function yi(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!pi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(di)))}(t),1===t.type){if(!pi(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];yi(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;yi(n),n.static||(t.static=!1)}}}function gi(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)gi(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)gi(t.ifConditions[n].block,e)}}const vi=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,$i=/\([^)]*?\);*$/,_i=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,bi={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},wi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ci=t=>`if(${t})return null;`,xi={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ci("$event.target !== $event.currentTarget"),ctrl:Ci("!$event.ctrlKey"),shift:Ci("!$event.shiftKey"),alt:Ci("!$event.altKey"),meta:Ci("!$event.metaKey"),left:Ci("'button' in $event && $event.button !== 0"),middle:Ci("'button' in $event && $event.button !== 1"),right:Ci("'button' in $event && $event.button !== 2")};function ki(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Ai(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Ai(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Ai(t))).join(",")}]`;const e=_i.test(t.value),n=vi.test(t.value),o=_i.test(t.value.replace($i,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(xi[e])s+=xi[e],bi[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=Ci(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Oi).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Oi(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=bi[t],o=wi[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Si={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ti{constructor(t){this.options=t,this.warn=t.warn||yo,this.transforms=go(t.modules,"transformCode"),this.dataGenFns=go(t.modules,"genData"),this.directives=A(A({},Si),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function Ei(t,e){const n=new Ti(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Ni(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Ni(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return ji(t,e);if(t.once&&!t.onceProcessed)return Di(t,e);if(t.for&&!t.forProcessed)return Ii(t,e);if(t.if&&!t.ifProcessed)return Li(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Hi(t,e);let r=`_t(${n}${o?`,${o}`:""}`;const s=t.attrs||t.dynamicAttrs?zi((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Hi(e,n,!0);return`_c(${t},${Fi(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Fi(t,e));const r=t.inlineTemplate?null:Hi(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Hi(t,e)||"void 0"}function ji(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Ni(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Di(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Li(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Ni(t,e)},${e.onceId++},${n})`:Ni(t,e)}return ji(t,e)}function Li(t,e,n,o){return t.ifProcessed=!0,Mi(t.ifConditions.slice(),e,n,o)}function Mi(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Mi(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Di(t,e):Ni(t,e)}}function Ii(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Ni)(t,e)}})`}function Fi(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${zi(t.attrs)},`),t.props&&(n+=`domProps:${zi(t.props)},`),t.events&&(n+=`${ki(t.events,!1)},`),t.nativeEvents&&(n+=`${ki(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Pi(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Ri(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=Ei(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${zi(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Pi(t){return 1===t.type&&("slot"===t.tag||t.children.some(Pi))}function Ri(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Li(t,e,Ri,"null");if(t.for&&!t.forProcessed)return Ii(t,e,Ri);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${Hi(t,e)||"undefined"}:undefined`:Hi(t,e)||"undefined":Ni(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Hi(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Ni)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(Bi(r)||r.ifConditions&&r.ifConditions.some((t=>Bi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Ui;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function Bi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Ui(t,e){return 1===t.type?Ni(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Vi(JSON.stringify(t.text))})`}(t)}function zi(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Vi(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Vi(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ki(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function qi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=Ki(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>Ki(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");const Ji=(Wi=function(t,e){const n=ti(t.trim(),e);!1!==e.optimize&&mi(n,e);const o=Ei(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=Wi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:qi(e)}});var Wi;const{compile:Zi,compileToFunctions:Gi}=Ji(fi);let Xi;function Yi(t){return Xi=Xi||document.createElement("div"),Xi.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Xi.innerHTML.indexOf("&#10;")>0}const Qi=!!U&&Yi(!1),ta=!!U&&Yi(!0),ea=v((t=>{const e=ss(t);return e&&e.innerHTML})),na=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&ss(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=ea(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Gi(e,{outputSourceRange:!1,shouldDecodeNewlines:Qi,shouldDecodeNewlinesForHref:ta,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return na.call(this,t,e)},$n.compile=Gi;export default $n;
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index 578ccf7f190..74a2b6188cc 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -6793,12 +6793,12 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$2 = /\s+/;
+var whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass$1(el, cls) {
+function addClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6806,7 +6806,7 @@ function addClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6823,7 +6823,7 @@ function addClass$1(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass$1(el, cls) {
+function removeClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6831,7 +6831,7 @@ function removeClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6856,7 +6856,7 @@ function removeClass$1(el, cls) {
     }
 }
 
-function resolveTransition$1(def) {
+function resolveTransition(def) {
     if (!def) {
         return;
     }
@@ -6864,16 +6864,16 @@ function resolveTransition$1(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition$1(def.name || 'v'));
+            extend(res, autoCssTransition(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition$1(def);
+        return autoCssTransition(def);
     }
 }
-var autoCssTransition$1 = cached(function (name) {
+var autoCssTransition = cached(function (name) {
     return {
         enterClass: (name + "-enter"),
         enterToClass: (name + "-enter-to"),
@@ -6883,62 +6883,62 @@ var autoCssTransition$1 = cached(function (name) {
         leaveActiveClass: (name + "-leave-active"),
     };
 });
-var hasTransition$1 = inBrowser && !isIE9;
-var TRANSITION$1 = 'transition';
-var ANIMATION$1 = 'animation';
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp$1 = 'transition';
-var transitionEndEvent$1 = 'transitionend';
-var animationProp$1 = 'animation';
-var animationEndEvent$1 = 'animationend';
-if (hasTransition$1) {
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp$1 = 'WebkitTransition';
-        transitionEndEvent$1 = 'webkitTransitionEnd';
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp$1 = 'WebkitAnimation';
-        animationEndEvent$1 = 'webkitAnimationEnd';
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf$1 = inBrowser
+var raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame$1(fn) {
-    raf$1(function () {
+function nextFrame(fn) {
+    raf(function () {
         // @ts-expect-error
-        raf$1(fn);
+        raf(fn);
     });
 }
-function addTransitionClass$1(el, cls) {
+function addTransitionClass(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass$1(el, cls);
+        addClass(el, cls);
     }
 }
-function removeTransitionClass$1(el, cls) {
+function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass$1(el, cls);
+    removeClass(el, cls);
 }
-function whenTransitionEnds$1(el, expectedType, cb) {
-    var ref = getTransitionInfo$1(el, expectedType);
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
     var type = ref.type;
     var timeout = ref.timeout;
     var propCount = ref.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -6958,30 +6958,30 @@ function whenTransitionEnds$1(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE$1 = /\b(transform|all)(,|$)/;
-function getTransitionInfo$1(el, expectedType) {
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION$1) {
+    if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
-            type = TRANSITION$1;
+            type = TRANSITION;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION$1) {
+    else if (expectedType === ANIMATION) {
         if (animationTimeout > 0) {
-            type = ANIMATION$1;
+            type = ANIMATION;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6991,16 +6991,16 @@ function getTransitionInfo$1(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION$1
-                    : ANIMATION$1
+                    ? TRANSITION
+                    : ANIMATION
                 : null;
         propCount = type
-            ? type === TRANSITION$1
+            ? type === TRANSITION
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -7008,31 +7008,31 @@ function getTransitionInfo$1(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout$1(delays, durations) {
+function getTimeout(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs$1(d) + toMs$1(delays[i]);
+        return toMs(d) + toMs(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs$1(s) {
+function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter$1(vnode, toggleDisplay) {
+function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7086,19 +7086,19 @@ function enter$1(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration$1(explicitEnterDuration, 'enter', vnode);
+        checkDuration(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(enterHook);
+    var userWantsControl = getHookArgumentsLength(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass$1(el, toClass);
-            removeTransitionClass$1(el, activeClass);
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, startClass);
+                removeTransitionClass(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -7123,19 +7123,19 @@ function enter$1(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass$1(el, startClass);
-        addTransitionClass$1(el, activeClass);
-        nextFrame$1(function () {
-            removeTransitionClass$1(el, startClass);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass$1(el, toClass);
+                addTransitionClass(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration$1(explicitEnterDuration)) {
+                    if (isValidDuration(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds$1(el, type, cb);
+                        whenTransitionEnds(el, type, cb);
                     }
                 }
             }
@@ -7149,14 +7149,14 @@ function enter$1(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave$1(vnode, rm) {
+function leave(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7176,23 +7176,23 @@ function leave$1(vnode, rm) {
     var delayLeave = data.delayLeave;
     var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(leave);
+    var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass$1(el, leaveToClass);
-            removeTransitionClass$1(el, leaveActiveClass);
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, leaveClass);
+                removeTransitionClass(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -7220,19 +7220,19 @@ function leave$1(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass$1(el, leaveClass);
-            addTransitionClass$1(el, leaveActiveClass);
-            nextFrame$1(function () {
-                removeTransitionClass$1(el, leaveClass);
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass$1(el, leaveToClass);
+                    addTransitionClass(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration$1(explicitLeaveDuration)) {
+                        if (isValidDuration(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds$1(el, type, cb);
+                            whenTransitionEnds(el, type, cb);
                         }
                     }
                 }
@@ -7245,7 +7245,7 @@ function leave$1(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration$1(val, name, vnode) {
+function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn$2("<transition> explicit " + name + " duration is not a valid number - " +
             "got " + (JSON.stringify(val)) + ".", vnode.context);
@@ -7255,7 +7255,7 @@ function checkDuration$1(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration$1(val) {
+function isValidDuration(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -7264,7 +7264,7 @@ function isValidDuration$1(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength$1(fn) {
+function getHookArgumentsLength(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -7272,7 +7272,7 @@ function getHookArgumentsLength$1(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -7281,7 +7281,7 @@ function getHookArgumentsLength$1(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter$1(vnode);
+        enter(vnode);
     }
 }
 var transition = inBrowser
@@ -7292,7 +7292,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave$1(vnode, rm);
+                leave(vnode, rm);
             }
             else {
                 rm();
@@ -7441,493 +7441,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-var whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        var res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-var autoCssTransition = cached(function (name) {
-    return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
-    };
-});
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
-// Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        // @ts-expect-error
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        // @ts-expect-error
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    var onEnd = function (e) {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(function () {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    var el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    var cb = (el._leaveCb = once(function () {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2("<transition> explicit " + name + " duration is NaN - " +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
@@ -8866,7 +8379,6 @@ function parseHTML(html, options) {
     }
 }
 
-// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/dist/vue.js b/dist/vue.js
index 3379d276c54..03795d7fe0e 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -6762,12 +6762,12 @@
       update: updateStyle,
   };
 
-  var whitespaceRE$2 = /\s+/;
+  var whitespaceRE$1 = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function addClass$1(el, cls) {
+  function addClass(el, cls) {
       /* istanbul ignore if */
       if (!cls || !(cls = cls.trim())) {
           return;
@@ -6775,7 +6775,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.add(c); });
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
           }
           else {
               el.classList.add(cls);
@@ -6792,7 +6792,7 @@
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
-  function removeClass$1(el, cls) {
+  function removeClass(el, cls) {
       /* istanbul ignore if */
       if (!cls || !(cls = cls.trim())) {
           return;
@@ -6800,7 +6800,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$2).forEach(function (c) { return el.classList.remove(c); });
+              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
           }
           else {
               el.classList.remove(cls);
@@ -6825,7 +6825,7 @@
       }
   }
 
-  function resolveTransition$1(def) {
+  function resolveTransition(def) {
       if (!def) {
           return;
       }
@@ -6833,16 +6833,16 @@
       if (typeof def === 'object') {
           var res = {};
           if (def.css !== false) {
-              extend(res, autoCssTransition$1(def.name || 'v'));
+              extend(res, autoCssTransition(def.name || 'v'));
           }
           extend(res, def);
           return res;
       }
       else if (typeof def === 'string') {
-          return autoCssTransition$1(def);
+          return autoCssTransition(def);
       }
   }
-  var autoCssTransition$1 = cached(function (name) {
+  var autoCssTransition = cached(function (name) {
       return {
           enterClass: (name + "-enter"),
           enterToClass: (name + "-enter-to"),
@@ -6852,62 +6852,62 @@
           leaveActiveClass: (name + "-leave-active"),
       };
   });
-  var hasTransition$1 = inBrowser && !isIE9;
-  var TRANSITION$1 = 'transition';
-  var ANIMATION$1 = 'animation';
+  var hasTransition = inBrowser && !isIE9;
+  var TRANSITION = 'transition';
+  var ANIMATION = 'animation';
   // Transition property/event sniffing
-  var transitionProp$1 = 'transition';
-  var transitionEndEvent$1 = 'transitionend';
-  var animationProp$1 = 'animation';
-  var animationEndEvent$1 = 'animationend';
-  if (hasTransition$1) {
+  var transitionProp = 'transition';
+  var transitionEndEvent = 'transitionend';
+  var animationProp = 'animation';
+  var animationEndEvent = 'animationend';
+  if (hasTransition) {
       /* istanbul ignore if */
       if (window.ontransitionend === undefined &&
           // @ts-expect-error
           window.onwebkittransitionend !== undefined) {
-          transitionProp$1 = 'WebkitTransition';
-          transitionEndEvent$1 = 'webkitTransitionEnd';
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
       }
       if (window.onanimationend === undefined &&
           // @ts-expect-error
           window.onwebkitanimationend !== undefined) {
-          animationProp$1 = 'WebkitAnimation';
-          animationEndEvent$1 = 'webkitAnimationEnd';
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
       }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf$1 = inBrowser
+  var raf = inBrowser
       ? window.requestAnimationFrame
           ? window.requestAnimationFrame.bind(window)
           : setTimeout
       : /* istanbul ignore next */ function (fn) { return fn(); };
-  function nextFrame$1(fn) {
-      raf$1(function () {
+  function nextFrame(fn) {
+      raf(function () {
           // @ts-expect-error
-          raf$1(fn);
+          raf(fn);
       });
   }
-  function addTransitionClass$1(el, cls) {
+  function addTransitionClass(el, cls) {
       var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
       if (transitionClasses.indexOf(cls) < 0) {
           transitionClasses.push(cls);
-          addClass$1(el, cls);
+          addClass(el, cls);
       }
   }
-  function removeTransitionClass$1(el, cls) {
+  function removeTransitionClass(el, cls) {
       if (el._transitionClasses) {
           remove$2(el._transitionClasses, cls);
       }
-      removeClass$1(el, cls);
+      removeClass(el, cls);
   }
-  function whenTransitionEnds$1(el, expectedType, cb) {
-      var ref = getTransitionInfo$1(el, expectedType);
+  function whenTransitionEnds(el, expectedType, cb) {
+      var ref = getTransitionInfo(el, expectedType);
       var type = ref.type;
       var timeout = ref.timeout;
       var propCount = ref.propCount;
       if (!type)
           { return cb(); }
-      var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
       var ended = 0;
       var end = function () {
           el.removeEventListener(event, onEnd);
@@ -6927,30 +6927,30 @@
       }, timeout + 1);
       el.addEventListener(event, onEnd);
   }
-  var transformRE$1 = /\b(transform|all)(,|$)/;
-  function getTransitionInfo$1(el, expectedType) {
+  var transformRE = /\b(transform|all)(,|$)/;
+  function getTransitionInfo(el, expectedType) {
       var styles = window.getComputedStyle(el);
       // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout$1(animationDelays, animationDurations);
+      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout(animationDelays, animationDurations);
       var type;
       var timeout = 0;
       var propCount = 0;
       /* istanbul ignore if */
-      if (expectedType === TRANSITION$1) {
+      if (expectedType === TRANSITION) {
           if (transitionTimeout > 0) {
-              type = TRANSITION$1;
+              type = TRANSITION;
               timeout = transitionTimeout;
               propCount = transitionDurations.length;
           }
       }
-      else if (expectedType === ANIMATION$1) {
+      else if (expectedType === ANIMATION) {
           if (animationTimeout > 0) {
-              type = ANIMATION$1;
+              type = ANIMATION;
               timeout = animationTimeout;
               propCount = animationDurations.length;
           }
@@ -6960,16 +6960,16 @@
           type =
               timeout > 0
                   ? transitionTimeout > animationTimeout
-                      ? TRANSITION$1
-                      : ANIMATION$1
+                      ? TRANSITION
+                      : ANIMATION
                   : null;
           propCount = type
-              ? type === TRANSITION$1
+              ? type === TRANSITION
                   ? transitionDurations.length
                   : animationDurations.length
               : 0;
       }
-      var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
       return {
           type: type,
           timeout: timeout,
@@ -6977,31 +6977,31 @@
           hasTransform: hasTransform,
       };
   }
-  function getTimeout$1(delays, durations) {
+  function getTimeout(delays, durations) {
       /* istanbul ignore next */
       while (delays.length < durations.length) {
           delays = delays.concat(delays);
       }
       return Math.max.apply(null, durations.map(function (d, i) {
-          return toMs$1(d) + toMs$1(delays[i]);
+          return toMs(d) + toMs(delays[i]);
       }));
   }
   // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
   // in a locale-dependent way, using a comma instead of a dot.
   // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
   // as a floor function) causing unexpected behaviors
-  function toMs$1(s) {
+  function toMs(s) {
       return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  function enter$1(vnode, toggleDisplay) {
+  function enter(vnode, toggleDisplay) {
       var el = vnode.elm;
       // call leave callback now
       if (isDef(el._leaveCb)) {
           el._leaveCb.cancelled = true;
           el._leaveCb();
       }
-      var data = resolveTransition$1(vnode.data.transition);
+      var data = resolveTransition(vnode.data.transition);
       if (isUndef(data)) {
           return;
       }
@@ -7055,19 +7055,19 @@
           : enterCancelled;
       var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
       if (explicitEnterDuration != null) {
-          checkDuration$1(explicitEnterDuration, 'enter', vnode);
+          checkDuration(explicitEnterDuration, 'enter', vnode);
       }
       var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength$1(enterHook);
+      var userWantsControl = getHookArgumentsLength(enterHook);
       var cb = (el._enterCb = once(function () {
           if (expectsCSS) {
-              removeTransitionClass$1(el, toClass);
-              removeTransitionClass$1(el, activeClass);
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
           }
           // @ts-expect-error
           if (cb.cancelled) {
               if (expectsCSS) {
-                  removeTransitionClass$1(el, startClass);
+                  removeTransitionClass(el, startClass);
               }
               enterCancelledHook && enterCancelledHook(el);
           }
@@ -7092,19 +7092,19 @@
       // start enter transition
       beforeEnterHook && beforeEnterHook(el);
       if (expectsCSS) {
-          addTransitionClass$1(el, startClass);
-          addTransitionClass$1(el, activeClass);
-          nextFrame$1(function () {
-              removeTransitionClass$1(el, startClass);
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(function () {
+              removeTransitionClass(el, startClass);
               // @ts-expect-error
               if (!cb.cancelled) {
-                  addTransitionClass$1(el, toClass);
+                  addTransitionClass(el, toClass);
                   if (!userWantsControl) {
-                      if (isValidDuration$1(explicitEnterDuration)) {
+                      if (isValidDuration(explicitEnterDuration)) {
                           setTimeout(cb, explicitEnterDuration);
                       }
                       else {
-                          whenTransitionEnds$1(el, type, cb);
+                          whenTransitionEnds(el, type, cb);
                       }
                   }
               }
@@ -7118,14 +7118,14 @@
           cb();
       }
   }
-  function leave$1(vnode, rm) {
+  function leave(vnode, rm) {
       var el = vnode.elm;
       // call enter callback now
       if (isDef(el._enterCb)) {
           el._enterCb.cancelled = true;
           el._enterCb();
       }
-      var data = resolveTransition$1(vnode.data.transition);
+      var data = resolveTransition(vnode.data.transition);
       if (isUndef(data) || el.nodeType !== 1) {
           return rm();
       }
@@ -7145,23 +7145,23 @@
       var delayLeave = data.delayLeave;
       var duration = data.duration;
       var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength$1(leave);
+      var userWantsControl = getHookArgumentsLength(leave);
       var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
       if (isDef(explicitLeaveDuration)) {
-          checkDuration$1(explicitLeaveDuration, 'leave', vnode);
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
       }
       var cb = (el._leaveCb = once(function () {
           if (el.parentNode && el.parentNode._pending) {
               el.parentNode._pending[vnode.key] = null;
           }
           if (expectsCSS) {
-              removeTransitionClass$1(el, leaveToClass);
-              removeTransitionClass$1(el, leaveActiveClass);
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
           }
           // @ts-expect-error
           if (cb.cancelled) {
               if (expectsCSS) {
-                  removeTransitionClass$1(el, leaveClass);
+                  removeTransitionClass(el, leaveClass);
               }
               leaveCancelled && leaveCancelled(el);
           }
@@ -7189,19 +7189,19 @@
           }
           beforeLeave && beforeLeave(el);
           if (expectsCSS) {
-              addTransitionClass$1(el, leaveClass);
-              addTransitionClass$1(el, leaveActiveClass);
-              nextFrame$1(function () {
-                  removeTransitionClass$1(el, leaveClass);
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(function () {
+                  removeTransitionClass(el, leaveClass);
                   // @ts-expect-error
                   if (!cb.cancelled) {
-                      addTransitionClass$1(el, leaveToClass);
+                      addTransitionClass(el, leaveToClass);
                       if (!userWantsControl) {
-                          if (isValidDuration$1(explicitLeaveDuration)) {
+                          if (isValidDuration(explicitLeaveDuration)) {
                               setTimeout(cb, explicitLeaveDuration);
                           }
                           else {
-                              whenTransitionEnds$1(el, type, cb);
+                              whenTransitionEnds(el, type, cb);
                           }
                       }
                   }
@@ -7214,7 +7214,7 @@
       }
   }
   // only used in dev mode
-  function checkDuration$1(val, name, vnode) {
+  function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
           warn$2("<transition> explicit " + name + " duration is not a valid number - " +
               "got " + (JSON.stringify(val)) + ".", vnode.context);
@@ -7224,7 +7224,7 @@
               'the duration expression might be incorrect.', vnode.context);
       }
   }
-  function isValidDuration$1(val) {
+  function isValidDuration(val) {
       return typeof val === 'number' && !isNaN(val);
   }
   /**
@@ -7233,7 +7233,7 @@
    * - a wrapped component method (check ._length)
    * - a plain function (.length)
    */
-  function getHookArgumentsLength$1(fn) {
+  function getHookArgumentsLength(fn) {
       if (isUndef(fn)) {
           return false;
       }
@@ -7241,7 +7241,7 @@
       var invokerFns = fn.fns;
       if (isDef(invokerFns)) {
           // invoker
-          return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
       }
       else {
           // @ts-expect-error
@@ -7250,7 +7250,7 @@
   }
   function _enter(_, vnode) {
       if (vnode.data.show !== true) {
-          enter$1(vnode);
+          enter(vnode);
       }
   }
   var transition = inBrowser
@@ -7261,7 +7261,7 @@
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
-                  leave$1(vnode, rm);
+                  leave(vnode, rm);
               }
               else {
                   rm();
@@ -7409,493 +7409,6 @@
       el.dispatchEvent(e);
   }
 
-  var whitespaceRE$1 = /\s+/;
-  /**
-   * Add class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function addClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
-  }
-  /**
-   * Remove class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function removeClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          var tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
-  }
-
-  function resolveTransition(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          var res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition(def);
-      }
-  }
-  var autoCssTransition = cached(function (name) {
-      return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
-      };
-  });
-  var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = 'transition';
-  var ANIMATION = 'animation';
-  // Transition property/event sniffing
-  var transitionProp = 'transition';
-  var transitionEndEvent = 'transitionend';
-  var animationProp = 'animation';
-  var animationEndEvent = 'animationend';
-  if (hasTransition) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          // @ts-expect-error
-          window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          // @ts-expect-error
-          window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
-      }
-  }
-  // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ function (fn) { return fn(); };
-  function nextFrame(fn) {
-      raf(function () {
-          // @ts-expect-error
-          raf(fn);
-      });
-  }
-  function addTransitionClass(el, cls) {
-      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass(el, cls);
-      }
-  }
-  function removeTransitionClass(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass(el, cls);
-  }
-  function whenTransitionEnds(el, expectedType, cb) {
-      var ref = getTransitionInfo(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
-      if (!type)
-          { return cb(); }
-      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      var ended = 0;
-      var end = function () {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      var onEnd = function (e) {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(function () {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
-  }
-  var transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
-      var styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout(animationDelays, animationDurations);
-      var type;
-      var timeout = 0;
-      var propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION) {
-          if (animationTimeout > 0) {
-              type = ANIMATION;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
-                  : null;
-          propCount = type
-              ? type === TRANSITION
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-      return {
-          type: type,
-          timeout: timeout,
-          propCount: propCount,
-          hasTransform: hasTransform,
-      };
-  }
-  function getTimeout(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map(function (d, i) {
-          return toMs(d) + toMs(delays[i]);
-      }));
-  }
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-  }
-
-  function enter(vnode, toggleDisplay) {
-      var el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      var data = resolveTransition(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      var context = activeInstance;
-      var transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      var isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      var startClass = isAppear && appearClass ? appearClass : enterClass;
-      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      var enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      var enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
-      }
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(enterHook);
-      var cb = (el._enterCb = once(function () {
-          if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', function () {
-              var parent = el.parentNode;
-              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
-      if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(function () {
-              removeTransitionClass(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
-      }
-  }
-  function leave(vnode, rm) {
-      var el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
-      }
-      var data = resolveTransition(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
-      }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
-      }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(leave);
-      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
-      }
-      var cb = (el._leaveCb = once(function () {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
-              }
-              leaveCancelled && leaveCancelled(el);
-          }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
-      }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(function () {
-                  removeTransitionClass(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
-      }
-  }
-  // only used in dev mode
-  function checkDuration(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn$2("<transition> explicit " + name + " duration is NaN - " +
-              'the duration expression might be incorrect.', vnode.context);
-      }
-  }
-  function isValidDuration(val) {
-      return typeof val === 'number' && !isNaN(val);
-  }
-  /**
-   * Normalize a transition hook's argument length. The hook may be:
-   * - a merged hook (invoker) with the original in .fns
-   * - a wrapped component method (check ._length)
-   * - a plain function (.length)
-   */
-  function getHookArgumentsLength(fn) {
-      if (isUndef(fn)) {
-          return false;
-      }
-      // @ts-expect-error
-      var invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-      }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
-      }
-  }
-
   // recursively search for possible transition defined inside the component root
   function locateNode(vnode) {
       // @ts-expect-error
@@ -8827,7 +8340,6 @@
       }
   }
 
-  // const he = require('he')
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/dist/vue.min.js b/dist/vue.min.js
index 0703699d85e..88776335394 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -8,4 +8,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,(function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}var o=Object.prototype.toString;function s(e){return"[object Object]"===o.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function l(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function u(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===o?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,C=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function A(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function k(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&k(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},N=function(e){return e};function E(e,t){if(e===t)return!0;var n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every((function(e,n){return E(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return E(e[n],t[n])}))}catch(e){return!1}}function L(e,t){for(var n=0;n<e.length;n++)if(E(e[n],t))return n;return-1}function j(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var D="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function H(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var B=new RegExp("[^"+P.source+".$_\\d]");var U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),q=z&&window.navigator.userAgent.toLowerCase(),J=q&&/msie|trident/.test(q),W=q&&q.indexOf("msie 9.0")>0,Z=q&&q.indexOf("edge/")>0;q&&q.indexOf("android");var G=q&&/iphone|ipad|ipod|ios/.test(q)||"ios"===K;q&&/chrome\/\d+/.test(q),q&&/phantomjs/.test(q);var X,Y=q&&q.match(/firefox\/(\d+)/),Q={}.watch,ee=!1;if(z)try{var te={};Object.defineProperty(te,"passive",{get:function(){ee=!0}}),window.addEventListener("test-passive",null,te)}catch(e){}var ne=function(){return void 0===X&&(X=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},re=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ie(e){return"function"==typeof e&&/native code/.test(e.toString())}var ae,oe="undefined"!=typeof Symbol&&ie(Symbol)&&"undefined"!=typeof Reflect&&ie(Reflect.ownKeys);ae="undefined"!=typeof Set&&ie(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var se=S,ce=0,le=function(){this.id=ce++,this.subs=[]};le.prototype.addSub=function(e){this.subs.push(e)},le.prototype.removeSub=function(e){h(this.subs,e)},le.prototype.depend=function(){le.target&&le.target.addDep(this)},le.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},le.target=null;var ue=[];function fe(e){ue.push(e),le.target=e}function pe(){ue.pop(),le.target=ue[ue.length-1]}var de=function(e,t,n,r,i,a,o,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=a,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=o,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ve={child:{configurable:!0}};ve.child.get=function(){return this.componentInstance},Object.defineProperties(de.prototype,ve);var he=function(e){void 0===e&&(e="");var t=new de;return t.text=e,t.isComment=!0,t};function me(e){return new de(void 0,void 0,void 0,String(e))}function ye(e){var t=new de(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ge=Array.prototype,_e=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ge[e];H(_e,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,a=t.apply(this,n),o=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&o.observeArray(i),o.dep.notify(),a}))}));var be=Object.getOwnPropertyNames(_e),$e=!0;function we(e){$e=e}var Ce=function(e){this.value=e,this.dep=new le,this.vmCount=0,H(e,"__ob__",this),Array.isArray(e)?(U?function(e,t){e.__proto__=t}(e,_e):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var a=n[r];H(e,a,t[a])}}(e,_e,be),this.observeArray(e)):this.walk(e)};function xe(e,t){var n;if(a(e)&&!(e instanceof de))return y(e,"__ob__")&&e.__ob__ instanceof Ce?n=e.__ob__:$e&&!ne()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new Ce(e)),t&&n&&n.vmCount++,n}function Ae(e,t,n,r,i){var a=new le,o=Object.getOwnPropertyDescriptor(e,t);if(!o||!1!==o.configurable){var s=o&&o.get,c=o&&o.set;s&&!c||2!==arguments.length||(n=e[t]);var l=!i&&xe(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return le.target&&(a.depend(),l&&(l.dep.depend(),Array.isArray(t)&&Se(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,l=!i&&xe(t),a.notify())}})}}function ke(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(Ae(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Oe(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Se(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Se(t)}Ce.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)Ae(e,t[n])},Ce.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)xe(e[t])};var Te=F.optionMergeStrategies;function Ne(e,t){if(!t)return e;for(var n,r,i,a=oe?Reflect.ownKeys(t):Object.keys(t),o=0;o<a.length;o++)"__ob__"!==(n=a[o])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Ne(r,i):ke(e,n,i));return e}function Ee(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Ne(r,i):i}:t?e?function(){return Ne("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Le(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function je(e,t,n,r){var i=Object.create(e||null);return t?k(i,t):i}Te.data=function(e,t,n){return n?Ee(e,t,n):t&&"function"!=typeof t?e:Ee(e,t)},I.forEach((function(e){Te[e]=Le})),M.forEach((function(e){Te[e+"s"]=je})),Te.watch=function(e,t,n,r){if(e===Q&&(e=void 0),t===Q&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var a in k(i,e),t){var o=i[a],s=t[a];o&&!Array.isArray(o)&&(o=[o]),i[a]=o?o.concat(s):Array.isArray(s)?s:[s]}return i},Te.props=Te.methods=Te.inject=Te.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return k(i,e),t&&k(i,t),i},Te.provide=Ee;var De=function(e,t){return void 0===t?e:t};function Me(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,a={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(a[b(i)]={type:null});else if(s(n))for(var o in n)i=n[o],a[b(o)]=s(i)?i:{type:i};e.props=a}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var a in n){var o=n[a];r[a]=s(o)?k({from:a},o):{from:o}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Me(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Me(e,t.mixins[r],n);var a,o={};for(a in e)c(a);for(a in t)y(e,a)||c(a);function c(r){var i=Te[r]||De;o[r]=i(e[r],t[r],n,r)}return o}function Ie(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var a=b(n);if(y(i,a))return i[a];var o=$(a);return y(i,o)?i[o]:i[n]||i[a]||i[o]}}function Fe(e,t,n,r){var i=t[e],a=!y(n,e),o=n[e],s=Be(Boolean,i.type);if(s>-1)if(a&&!y(i,"default"))o=!1;else if(""===o||o===C(e)){var c=Be(String,i.type);(c<0||s<c)&&(o=!0)}if(void 0===o){o=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Re(t.type)?r.call(e):r}(r,i,e);var l=$e;we(!0),xe(o),we(l)}return o}var Pe=/^\s*function (\w+)/;function Re(e){var t=e&&e.toString().match(Pe);return t?t[1]:""}function He(e,t){return Re(e)===Re(t)}function Be(e,t){if(!Array.isArray(t))return He(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(He(t[n],e))return n;return-1}function Ue(e,t,n){fe();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var a=0;a<i.length;a++)try{if(!1===i[a].call(r,e,t,n))return}catch(e){Ve(e,r,"errorCaptured hook")}}Ve(e,t,n)}finally{pe()}}function ze(e,t,n,r,i){var a;try{(a=n?e.apply(t,n):e.call(t))&&!a._isVue&&l(a)&&!a._handled&&(a.catch((function(e){return Ue(e,r,i+" (Promise/async)")})),a._handled=!0)}catch(e){Ue(e,r,i)}return a}function Ve(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ke(t)}Ke(e)}function Ke(e,t,n){if(!z&&!V||"undefined"==typeof console)throw e;console.error(e)}var qe,Je=!1,We=[],Ze=!1;function Ge(){Ze=!1;var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&ie(Promise)){var Xe=Promise.resolve();qe=function(){Xe.then(Ge),G&&setTimeout(S)},Je=!0}else if(J||"undefined"==typeof MutationObserver||!ie(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())qe="undefined"!=typeof setImmediate&&ie(setImmediate)?function(){setImmediate(Ge)}:function(){setTimeout(Ge,0)};else{var Ye=1,Qe=new MutationObserver(Ge),et=document.createTextNode(String(Ye));Qe.observe(et,{characterData:!0}),qe=function(){Ye=(Ye+1)%2,et.data=String(Ye)},Je=!0}function tt(e,t){var n;if(We.push((function(){if(e)try{e.call(t)}catch(e){Ue(e,t,"nextTick")}else n&&n(t)})),Ze||(Ze=!0,qe()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var nt=new ae;function rt(e){it(e,nt),nt.clear()}function it(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!a(e)||Object.isFrozen(e)||e instanceof de)){if(e.__ob__){var o=e.__ob__.dep.id;if(t.has(o))return;t.add(o)}if(i)for(n=e.length;n--;)it(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)it(e[r[n]],t)}}var at=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function ot(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return ze(r,null,arguments,t,"v-on handler");for(var i=r.slice(),a=0;a<i.length;a++)ze(i[a],null,e,t,"v-on handler")}return n.fns=e,n}function st(e,n,i,a,o,s){var c,l,u,f;for(c in e)l=e[c],u=n[c],f=at(c),t(l)||(t(u)?(t(l.fns)&&(l=e[c]=ot(l,s)),r(f.once)&&(l=e[c]=o(f.name,l,f.capture)),i(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[c]=u));for(c in n)t(e[c])&&a((f=at(c)).name,n[c],f.capture)}function ct(e,i,a){var o;e instanceof de&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){a.apply(this,arguments),h(o.fns,c)}t(s)?o=ot([c]):n(s.fns)&&r(s.merged)?(o=s).fns.push(c):o=ot([s,c]),o.merged=!0,e[i]=o}function lt(e,t,r,i,a){if(n(t)){if(y(t,r))return e[r]=t[r],a||delete t[r],!0;if(y(t,i))return e[r]=t[i],a||delete t[i],!0}return!1}function ut(e){return i(e)?[me(e)]:Array.isArray(e)?pt(e):void 0}function ft(e){return n(e)&&n(e.text)&&!1===e.isComment}function pt(e,a){var o,s,c,l,u=[];for(o=0;o<e.length;o++)t(s=e[o])||"boolean"==typeof s||(l=u[c=u.length-1],Array.isArray(s)?s.length>0&&(ft((s=pt(s,(a||"")+"_"+o))[0])&&ft(l)&&(u[c]=me(l.text+s[0].text),s.shift()),u.push.apply(u,s)):i(s)?ft(l)?u[c]=me(l.text+s):""!==s&&u.push(me(s)):ft(s)&&ft(l)?u[c]=me(l.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(a)&&(s.key="__vlist"+a+"_"+o+"__"),u.push(s)));return u}function dt(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var a=r[i];if("__ob__"!==a){for(var o=e[a].from,s=t;s;){if(s._provided&&y(s._provided,o)){n[a]=s._provided[o];break}s=s.$parent}if(!s&&"default"in e[a]){var c=e[a].default;n[a]="function"==typeof c?c.call(t):c}}}return n}}function vt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var a=e[r],o=a.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,a.context!==t&&a.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(a);else{var s=o.slot,c=n[s]||(n[s]=[]);"template"===a.tag?c.push.apply(c,a.children||[]):c.push(a)}}for(var l in n)n[l].every(ht)&&delete n[l];return n}function ht(e){return e.isComment&&!e.asyncFactory||" "===e.text}function mt(t,n,r){var i,a=Object.keys(n).length>0,o=t?!!t.$stable:!a,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(o&&r&&r!==e&&s===r.$key&&!a&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=yt(n,c,t[c]))}else i={};for(var l in n)l in i||(i[l]=gt(n,l));return t&&Object.isExtensible(t)&&(t._normalized=i),H(i,"$stable",o),H(i,"$key",s),H(i,"$hasNormal",a),i}function yt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ut(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function gt(e,t){return function(){return e[t]}}function _t(e,t){var r,i,o,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(a(e))if(oe&&e[Symbol.iterator]){c=[];for(var l=e[Symbol.iterator](),u=l.next();!u.done;)c.push(t(u.value,c.length)),u=l.next()}else for(o=Object.keys(e),c=new Array(o.length),r=0,i=o.length;r<i;r++)s=o[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function bt(e,t,n,r){var i,a=this.$scopedSlots[e];a?(n=n||{},r&&(n=k(k({},r),n)),i=a(n)||t):i=this.$slots[e]||t;var o=n&&n.slot;return o?this.$createElement("template",{slot:o},i):i}function $t(e){return Ie(this.$options,"filters",e)||N}function wt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function Ct(e,t,n,r,i){var a=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?wt(i,r):a?wt(a,e):r?C(r)!==t:void 0}function xt(e,t,n,r,i){if(n)if(a(n)){var o;Array.isArray(n)&&(n=O(n));var s=function(a){if("class"===a||"style"===a||v(a))o=e;else{var s=e.attrs&&e.attrs.type;o=r||F.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(a),l=C(a);c in o||l in o||(o[a]=n[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){n[a]=e}))};for(var c in n)s(c)}else;return e}function At(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||Ot(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function kt(e,t,n){return Ot(e,"__once__"+t+(n?"_"+n:""),!0),e}function Ot(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&St(e[r],t+"_"+r,n);else St(e,t,n)}function St(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function Tt(e,t){if(t)if(s(t)){var n=e.on=e.on?k({},e.on):{};for(var r in t){var i=n[r],a=t[r];n[r]=i?[].concat(i,a):a}}else;return e}function Nt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var a=e[i];Array.isArray(a)?Nt(a,t,n):a&&(a.proxy&&(a.fn.proxy=!0),t[a.key]=a.fn)}return r&&(t.$key=r),t}function Et(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Lt(e,t){return"string"==typeof e?t+e:e}function jt(e){e._o=kt,e._n=f,e._s=u,e._l=_t,e._t=bt,e._q=E,e._i=L,e._m=At,e._f=$t,e._k=Ct,e._b=xt,e._v=me,e._e=he,e._u=Nt,e._g=Tt,e._d=Et,e._p=Lt}function Dt(t,n,i,a,o){var s,c=this,l=o.options;y(a,"_uid")?(s=Object.create(a))._original=a:(s=a,a=a._original);var u=r(l._compiled),f=!u;this.data=t,this.props=n,this.children=i,this.parent=a,this.listeners=t.on||e,this.injections=dt(l.inject,a),this.slots=function(){return c.$slots||mt(t.scopedSlots,c.$slots=vt(i,a)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return mt(t.scopedSlots,this.slots())}}),u&&(this.$options=l,this.$slots=this.slots(),this.$scopedSlots=mt(t.scopedSlots,this.$slots)),l._scopeId?this._c=function(e,t,n,r){var i=Bt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=l._scopeId,i.fnContext=a),i}:this._c=function(e,t,n,r){return Bt(s,e,t,n,r,f)}}function Mt(e,t,n,r,i){var a=ye(e);return a.fnContext=n,a.fnOptions=r,t.slot&&((a.data||(a.data={})).slot=t.slot),a}function It(e,t){for(var n in t)e[b(n)]=t[n]}jt(Dt.prototype);var Ft={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ft.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Yt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,a){var o=i.data.scopedSlots,s=t.$scopedSlots,c=!!(o&&!o.$stable||s!==e&&!s.$stable||o&&t.$scopedSlots.$key!==o.$key),l=!!(a||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=a,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){we(!1);for(var u=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;u[d]=Fe(d,v,n,t)}we(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Xt(t,r,h),l&&(t.$slots=vt(a,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,rn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,on.push(t)):tn(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?nn(t,!0):t.$destroy())}},Pt=Object.keys(Ft);function Rt(i,o,s,c,u){if(!t(i)){var f=s.$options._base;if(a(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var o=Vt;o&&n(e.owners)&&-1===e.owners.indexOf(o)&&e.owners.push(o);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(o&&!n(e.owners)){var s=e.owners=[o],c=!0,u=null,f=null;o.$on("hook:destroyed",(function(){return h(s,o)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=j((function(t){e.resolved=Kt(t,i),c?s.length=0:p(!0)})),v=j((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return a(m)&&(l(m)?t(e.resolved)&&m.then(d,v):l(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Kt(m.error,i)),n(m.loading)&&(e.loadingComp=Kt(m.loading,i),0===m.delay?e.loading=!0:u=setTimeout((function(){u=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var a=he();return a.asyncFactory=e,a.asyncMeta={data:t,context:n,children:r,tag:i},a}(p,o,s,c,u);o=o||{},kn(i),n(o.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var a=t.on||(t.on={}),o=a[i],s=t.model.callback;n(o)?(Array.isArray(o)?-1===o.indexOf(s):o!==s)&&(a[i]=[s].concat(o)):a[i]=s}(i.options,o);var d=function(e,r,i){var a=r.options.props;if(!t(a)){var o={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var l in a){var u=C(l);lt(o,c,l,u,!0)||lt(o,s,l,u,!1)}return o}}(o,i);if(r(i.options.functional))return function(t,r,i,a,o){var s=t.options,c={},l=s.props;if(n(l))for(var u in l)c[u]=Fe(u,l,r||e);else n(i.attrs)&&It(c,i.attrs),n(i.props)&&It(c,i.props);var f=new Dt(i,c,o,a,t),p=s.render.call(null,f._c,f);if(p instanceof de)return Mt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ut(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Mt(d[h],i,f.parent,s);return v}}(i,d,o,s,c);var v=o.on;if(o.on=o.nativeOn,r(i.options.abstract)){var m=o.slot;o={},m&&(o.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Pt.length;n++){var r=Pt[n],i=t[r],a=Ft[r];i===a||i&&i._merged||(t[r]=i?Ht(a,i):a)}}(o);var y=i.options.name||u;return new de("vue-component-"+i.cid+(y?"-"+y:""),o,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:u,children:c},p)}}}function Ht(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Bt(e,t,o,s,c,l){return(Array.isArray(o)||i(o))&&(c=s,s=o,o=void 0),r(l)&&(c=2),function(e,t,r,i,o){if(n(r)&&n(r.__ob__))return he();n(r)&&n(r.is)&&(t=r.is);if(!t)return he();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===o?i=ut(i):1===o&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var l;c=e.$vnode&&e.$vnode.ns||F.getTagNamespace(t),s=F.isReservedTag(t)?new de(F.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(l=Ie(e.$options,"components",t))?new de(t,r,i,void 0,void 0,e):Rt(l,r,e,i,t)}else s=Rt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Ut(s,c),n(r)&&function(e){a(e.style)&&rt(e.style);a(e.class)&&rt(e.class)}(r),s):he()}(e,t,o,s,c)}function Ut(e,i,a){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,a=!0),n(e.children))for(var o=0,s=e.children.length;o<s;o++){var c=e.children[o];n(c.tag)&&(t(c.ns)||r(a)&&"svg"!==c.tag)&&Ut(c,i,a)}}var zt,Vt=null;function Kt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),a(e)?t.extend(e):e}function qt(e){return e.isComment&&e.asyncFactory}function Jt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||qt(r)))return r}}function Wt(e,t){zt.$on(e,t)}function Zt(e,t){zt.$off(e,t)}function Gt(e,t){var n=zt;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Xt(e,t,n){zt=e,st(t,n||{},Wt,Zt,Gt,e),zt=void 0}var Yt=null;function Qt(e){var t=Yt;return Yt=e,function(){Yt=t}}function en(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function tn(e,t){if(t){if(e._directInactive=!1,en(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);rn(e,"activated")}}function nn(e,t){if(!(t&&(e._directInactive=!0,en(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)nn(e.$children[n]);rn(e,"deactivated")}}function rn(e,t){fe();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,a=n.length;i<a;i++)ze(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),pe()}var an=[],on=[],sn={},cn=!1,ln=!1,un=0;var fn=0,pn=Date.now;if(z&&!J){var dn=window.performance;dn&&"function"==typeof dn.now&&pn()>document.createEvent("Event").timeStamp&&(pn=function(){return dn.now()})}function vn(){var e,t;for(fn=pn(),ln=!0,an.sort((function(e,t){return e.id-t.id})),un=0;un<an.length;un++)(e=an[un]).before&&e.before(),t=e.id,sn[t]=null,e.run();var n=on.slice(),r=an.slice();un=an.length=on.length=0,sn={},cn=ln=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,tn(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&rn(r,"updated")}}(r),re&&F.devtools&&re.emit("flush")}var hn=0,mn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++hn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ae,this.newDepIds=new ae,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!B.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};mn.prototype.get=function(){var e;fe(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Ue(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rt(e),pe(),this.cleanupDeps()}return e},mn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},mn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},mn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==sn[t]){if(sn[t]=!0,ln){for(var n=an.length-1;n>un&&an[n].id>e.id;)n--;an.splice(n+1,0,e)}else an.push(e);cn||(cn=!0,tt(vn))}}(this)},mn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||a(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Ue(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},mn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},mn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},mn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var yn={enumerable:!0,configurable:!0,get:S,set:S};function gn(e,t,n){yn.get=function(){return this[t][n]},yn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,yn)}function _n(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&we(!1);var a=function(a){i.push(a);var o=Fe(a,t,n,e);Ae(r,a,o),a in e||gn(e,"_props",a)};for(var o in t)a(o);we(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){fe();try{return e.call(t,t)}catch(e){return Ue(e,t,"data()"),{}}finally{pe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var a=n[i];r&&y(r,a)||R(a)||gn(e,"_data",a)}xe(t,!0)}(e):xe(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=ne();for(var i in t){var a=t[i],o="function"==typeof a?a:a.get;r||(n[i]=new mn(e,o||S,S,bn)),i in e||$n(e,i,a)}}(e,t.computed),t.watch&&t.watch!==Q&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)xn(e,n,r[i]);else xn(e,n,r)}}(e,t.watch)}var bn={lazy:!0};function $n(e,t,n){var r=!ne();"function"==typeof n?(yn.get=r?wn(t):Cn(n),yn.set=S):(yn.get=n.get?r&&!1!==n.cache?wn(t):Cn(n.get):S,yn.set=n.set||S),Object.defineProperty(e,t,yn)}function wn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),le.target&&t.depend(),t.value}}function Cn(e){return function(){return e.call(this,this)}}function xn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var An=0;function kn(e){var t=e.options;if(e.super){var n=kn(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&k(e.extendOptions,r),(t=e.options=Me(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function On(e){this._init(e)}function Sn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var a=e.name||n.options.name,o=function(e){this._init(e)};return(o.prototype=Object.create(n.prototype)).constructor=o,o.cid=t++,o.options=Me(n.options,e),o.super=n,o.options.props&&function(e){var t=e.options.props;for(var n in t)gn(e.prototype,"_props",n)}(o),o.options.computed&&function(e){var t=e.options.computed;for(var n in t)$n(e.prototype,n,t[n])}(o),o.extend=n.extend,o.mixin=n.mixin,o.use=n.use,M.forEach((function(e){o[e]=n[e]})),a&&(o.options.components[a]=o),o.superOptions=n.options,o.extendOptions=e,o.sealedOptions=k({},o.options),i[r]=o,o}}function Tn(e){return e&&(e.Ctor.options.name||e.tag)}function Nn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===o.call(n)&&e.test(t));var n}function En(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var a in n){var o=n[a];if(o){var s=Tn(o.componentOptions);s&&!t(s)&&Ln(n,a,r,i)}}}function Ln(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=An++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Me(kn(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Xt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=vt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Bt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Bt(t,e,n,r,i,!0)};var a=r&&r.data;Ae(t,"$attrs",a&&a.attrs||e,null,!0),Ae(t,"$listeners",n._parentListeners||e,null,!0)}(n),rn(n,"beforeCreate"),function(e){var t=dt(e.$options.inject,e);t&&(we(!1),Object.keys(t).forEach((function(n){Ae(e,n,t[n])})),we(!0))}(n),_n(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),rn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(On),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Oe,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return xn(r,e,t,n);(n=n||{}).user=!0;var i=new mn(r,e,t,n);if(n.immediate){fe();try{t.call(r,i.value)}catch(e){Ue(e,r,'callback for immediate watcher "'+i.expression+'"')}pe()}return function(){i.teardown()}}}(On),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,a=e.length;i<a;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var a,o=n._events[e];if(!o)return n;if(!t)return n._events[e]=null,n;for(var s=o.length;s--;)if((a=o[s])===t||a.fn===t){o.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),i='event handler for "'+e+'"',a=0,o=n.length;a<o;a++)ze(n[a],t,r,t,i)}return t}}(On),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,a=Qt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),a(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){rn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),rn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(On),function(e){jt(e.prototype),e.prototype.$nextTick=function(e){return tt(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=mt(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Vt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Ue(n,t,"render"),e=t._vnode}finally{Vt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof de||(e=he()),e.parent=i,e}}(On);var jn=[String,RegExp,Array],Dn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)Ln(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){En(e,(function(e){return Nn(t,e)}))})),this.$watch("exclude",(function(t){En(e,(function(e){return!Nn(t,e)}))}))},render:function(){var e=this.$slots.default,t=Jt(e),n=t&&t.componentOptions;if(n){var r=Tn(n),i=this.include,a=this.exclude;if(i&&(!r||!Nn(i,r))||a&&r&&Nn(a,r))return t;var o=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;o[c]?(t.componentInstance=o[c].componentInstance,h(s,c),s.push(c)):(o[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&Ln(o,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:se,extend:k,mergeOptions:Me,defineReactive:Ae},e.set=ke,e.delete=Oe,e.nextTick=tt,e.observable=function(e){return xe(e),e},e.options=Object.create(null),M.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,k(e.options.components,Dn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Me(this.options,e),this}}(e),Sn(e),function(e){M.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(On),Object.defineProperty(On.prototype,"$isServer",{get:ne}),Object.defineProperty(On.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(On,"FunctionalRenderContext",{value:Dt}),On.version="2.6.12";var Mn=p("style,class"),In=p("input,textarea,option,select,progress"),Fn=p("contenteditable,draggable,spellcheck"),Pn=p("events,caret,typing,plaintext-only"),Rn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Hn="http://www.w3.org/1999/xlink",Bn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Un=function(e){return Bn(e)?e.slice(6,e.length):""},zn=function(e){return null==e||!1===e};function Vn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Kn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Kn(t,r.data));return function(e,t){if(n(e)||n(t))return qn(e,Jn(t));return""}(t.staticClass,t.class)}function Kn(e,t){return{staticClass:qn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function qn(e,t){return e?t?e+" "+t:e:t||""}function Jn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,a=e.length;i<a;i++)n(t=Jn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):a(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Zn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Gn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(e){return Zn(e)||Gn(e)};var Yn=Object.create(null);var Qn=p("text,number,password,search,email,tel,url");var er=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Wn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),tr={create:function(e,t){nr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(nr(e,!0),nr(t))},destroy:function(e){nr(e,!0)}};function nr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,a=e.componentInstance||e.elm,o=i.$refs;t?Array.isArray(o[r])?h(o[r],a):o[r]===a&&(o[r]=void 0):e.data.refInFor?Array.isArray(o[r])?o[r].indexOf(a)<0&&o[r].push(a):o[r]=[a]:o[r]=a}}var rr=new de("",{},[]),ir=["create","activate","update","remove","destroy"];function ar(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,a=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===a||Qn(i)&&Qn(a)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,a,o={};for(i=t;i<=r;++i)n(a=e[i].key)&&(o[a]=i);return o}var sr={create:cr,update:cr,destroy:function(e){cr(e,rr)}};function cr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,a=e===rr,o=t===rr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),l=[],u=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,pr(i,"update",t,e),i.def&&i.def.componentUpdated&&u.push(i)):(pr(i,"bind",t,e),i.def&&i.def.inserted&&l.push(i));if(l.length){var f=function(){for(var n=0;n<l.length;n++)pr(l[n],"inserted",t,e)};a?ct(t,"insert",f):f()}u.length&&ct(t,"postpatch",(function(){for(var n=0;n<u.length;n++)pr(u[n],"componentUpdated",t,e)}));if(!a)for(n in s)c[n]||pr(s[n],"unbind",e,e,o)}(e,t)}var lr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=lr),i[fr(r)]=r,r.def=Ie(t.$options,"directives",r.name);return i}function fr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function pr(e,t,n,r,i){var a=e.def&&e.def[t];if(a)try{a(n.elm,e,n,r,i)}catch(r){Ue(r,n.context,"directive "+e.name+" "+t+" hook")}}var dr=[tr,sr];function vr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var a,o,s=r.elm,c=e.data.attrs||{},l=r.data.attrs||{};for(a in n(l.__ob__)&&(l=r.data.attrs=k({},l)),l)o=l[a],c[a]!==o&&hr(s,a,o,r.data.pre);for(a in(J||Z)&&l.value!==c.value&&hr(s,"value",l.value),c)t(l[a])&&(Bn(a)?s.removeAttributeNS(Hn,Un(a)):Fn(a)||s.removeAttribute(a))}}function hr(e,t,n,r){r||e.tagName.indexOf("-")>-1?mr(e,t,n):Rn(t)?zn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Fn(t)?e.setAttribute(t,function(e,t){return zn(t)||"false"===t?"false":"contenteditable"===e&&Pn(t)?t:"true"}(t,n)):Bn(t)?zn(n)?e.removeAttributeNS(Hn,Un(t)):e.setAttributeNS(Hn,t,n):mr(e,t,n)}function mr(e,t,n){if(zn(n))e.removeAttribute(t);else{if(J&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var yr={create:vr,update:vr};function gr(e,r){var i=r.elm,a=r.data,o=e.data;if(!(t(a.staticClass)&&t(a.class)&&(t(o)||t(o.staticClass)&&t(o.class)))){var s=Vn(r),c=i._transitionClasses;n(c)&&(s=qn(s,Jn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var _r,br,$r,wr,Cr,xr,Ar={create:gr,update:gr},kr=/[\w).+\-_$\]]/;function Or(e){var t,n,r,i,a,o=!1,s=!1,c=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),o)39===t&&92!==n&&(o=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:s=!0;break;case 39:o=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(l=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(a||(a=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),a)for(r=0;r<a.length;r++)i=Sr(i,a[r]);return i}function Sr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Tr(e,t){console.error("[Vue compiler]: "+e)}function Nr(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Er(e,t,n,r,i){(e.props||(e.props=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Lr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Hr({name:t,value:n},r))}function Dr(e,t,n,r,i,a,o,s){(e.directives||(e.directives=[])).push(Hr({name:t,rawName:n,value:r,arg:i,isDynamicArg:a,modifiers:o},s)),e.plain=!1}function Mr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Ir(t,n,r,i,a,o,s,c){var l;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Mr("!",n,c)),i.once&&(delete i.once,n=Mr("~",n,c)),i.passive&&(delete i.passive,n=Mr("&",n,c)),i.native?(delete i.native,l=t.nativeEvents||(t.nativeEvents={})):l=t.events||(t.events={});var u=Hr({value:r.trim(),dynamic:c},s);i!==e&&(u.modifiers=i);var f=l[n];Array.isArray(f)?a?f.unshift(u):f.push(u):l[n]=f?a?[u,f]:[f,u]:u,t.plain=!1}function Fr(e,t,n){var r=Pr(e,":"+t)||Pr(e,"v-bind:"+t);if(null!=r)return Or(r);if(!1!==n){var i=Pr(e,t);if(null!=i)return JSON.stringify(i)}}function Pr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,a=0,o=i.length;a<o;a++)if(i[a].name===t){i.splice(a,1);break}return n&&delete e.attrsMap[t],r}function Rr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var a=n[r];if(t.test(a.name))return n.splice(r,1),a}}function Hr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Br(e,t,n){var r=n||{},i=r.number,a="$$v",o=a;r.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var s=Ur(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Ur(e,t){var n=function(e){if(e=e.trim(),_r=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<_r-1)return(wr=e.lastIndexOf("."))>-1?{exp:e.slice(0,wr),key:'"'+e.slice(wr+1)+'"'}:{exp:e,key:null};br=e,wr=Cr=xr=0;for(;!Vr();)Kr($r=zr())?Jr($r):91===$r&&qr($r);return{exp:e.slice(0,Cr),key:e.slice(Cr+1,xr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function zr(){return br.charCodeAt(++wr)}function Vr(){return wr>=_r}function Kr(e){return 34===e||39===e}function qr(e){var t=1;for(Cr=wr;!Vr();)if(Kr(e=zr()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){xr=wr;break}}function Jr(e){for(var t=e;!Vr()&&(e=zr())!==t;);}var Wr;function Zr(e,t,n){var r=Wr;return function i(){var a=t.apply(null,arguments);null!==a&&Yr(e,i,n,r)}}var Gr=Je&&!(Y&&Number(Y[1])<=53);function Xr(e,t,n,r){if(Gr){var i=fn,a=t;t=a._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return a.apply(this,arguments)}}Wr.addEventListener(e,t,ee?{capture:n,passive:r}:n)}function Yr(e,t,n,r){(r||Wr).removeEventListener(e,t._wrapper||t,n)}function Qr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},a=e.data.on||{};Wr=r.elm,function(e){if(n(e.__r)){var t=J?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),st(i,a,Xr,Yr,Zr,r.context),Wr=void 0}}var ei,ti={create:Qr,update:Qr};function ni(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,a,o=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=k({},c)),s)i in c||(o[i]="");for(i in c){if(a=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),a===s[i])continue;1===o.childNodes.length&&o.removeChild(o.childNodes[0])}if("value"===i&&"PROGRESS"!==o.tagName){o._value=a;var l=t(a)?"":String(a);ri(o,l)&&(o.value=l)}else if("innerHTML"===i&&Gn(o.tagName)&&t(o.innerHTML)){(ei=ei||document.createElement("div")).innerHTML="<svg>"+a+"</svg>";for(var u=ei.firstChild;o.firstChild;)o.removeChild(o.firstChild);for(;u.firstChild;)o.appendChild(u.firstChild)}else if(a!==s[i])try{o[i]=a}catch(e){}}}}function ri(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ii={create:ni,update:ni},ai=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function oi(e){var t=si(e.style);return e.staticStyle?k(e.staticStyle,t):t}function si(e){return Array.isArray(e)?O(e):"string"==typeof e?ai(e):e}var ci,li=/^--/,ui=/\s*!important$/,fi=function(e,t,n){if(li.test(t))e.style.setProperty(t,n);else if(ui.test(n))e.style.setProperty(C(t),n.replace(ui,""),"important");else{var r=di(t);if(Array.isArray(n))for(var i=0,a=n.length;i<a;i++)e.style[r]=n[i];else e.style[r]=n}},pi=["Webkit","Moz","ms"],di=g((function(e){if(ci=ci||document.createElement("div").style,"filter"!==(e=b(e))&&e in ci)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<pi.length;n++){var r=pi[n]+t;if(r in ci)return r}}));function vi(e,r){var i=r.data,a=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(a.staticStyle)&&t(a.style))){var o,s,c=r.elm,l=a.staticStyle,u=a.normalizedStyle||a.style||{},f=l||u,p=si(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?k({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=oi(i.data))&&k(r,n);(n=oi(e.data))&&k(r,n);for(var a=e;a=a.parent;)a.data&&(n=oi(a.data))&&k(r,n);return r}(r,!0);for(s in f)t(d[s])&&fi(c,s,"");for(s in d)(o=d[s])!==f[s]&&fi(c,s,null==o?"":o)}}var hi={create:vi,update:vi},mi=/\s+/;function yi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,gi(e.name||"v")),k(t,e),t}return"string"==typeof e?gi(e):void 0}}var gi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),_i="transition",bi="animation",$i="transition",wi="transitionend",Ci="animation",xi="animationend";z&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&($i="WebkitTransition",wi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ci="WebkitAnimation",xi="webkitAnimationEnd"));var Ai=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function ki(e){Ai((function(){Ai(e)}))}function Oi(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}(e,t))}function Si(e,t){e._transitionClasses&&h(e._transitionClasses,t),function(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}(e,t)}function Ti(e,t,n){var r=function(e,t){var n,r=window.getComputedStyle(e),i=(r[$i+"Delay"]||"").split(", "),a=(r[$i+"Duration"]||"").split(", "),o=Ei(i,a),s=(r[Ci+"Delay"]||"").split(", "),c=(r[Ci+"Duration"]||"").split(", "),l=Ei(s,c),u=0,f=0;t===_i?o>0&&(n=_i,u=o,f=a.length):t===bi?l>0&&(n=bi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?_i:bi:null)?n===_i?a.length:c.length:0;var p=n===_i&&Ni.test(r[$i+"Property"]);return{type:n,timeout:u,propCount:f,hasTransform:p}}(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===_i?wi:xi,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var Ni=/\b(transform|all)(,|$)/;function Ei(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Li(t)+Li(e[n])})))}function Li(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function ji(e){return"number"==typeof e&&!isNaN(e)}function Di(e){if(t(e))return!1;var r=e.fns;return n(r)?Di(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Mi(e,r){!0!==r.data.show&&function(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=yi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Yt,k=Yt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!W,P=Di(L),R=i._enterCb=j((function(){F&&(Si(i,N),Si(i,T)),R.cancelled?(F&&Si(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||ct(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(Oi(i,S),Oi(i,T),ki((function(){Si(i,S),R.cancelled||(Oi(i,N),P||(ji(I)?setTimeout(R,I):Ti(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}(r)}var Ii=function(e){var a,o,s={},c=e.modules,l=e.nodeOps;for(a=0;a<ir.length;++a)for(s[ir[a]]=[],o=0;o<c.length;++o)n(c[o][ir[a]])&&s[ir[a]].push(c[o][ir[a]]);function u(e){var t=l.parentNode(e);n(t)&&l.removeChild(t,e)}function f(e,t,i,a,o,c,u){if(n(e.elm)&&n(c)&&(e=c[u]=ye(e)),e.isRootInsert=!o,!function(e,t,i,a){var o=e.data;if(n(o)){var c=n(e.componentInstance)&&o.keepAlive;if(n(o=o.hook)&&n(o=o.init)&&o(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,a),r(c)&&function(e,t,r,i){var a,o=e;for(;o.componentInstance;)if(n(a=(o=o.componentInstance._vnode).data)&&n(a=a.transition)){for(a=0;a<s.activate.length;++a)s.activate[a](rr,o);t.push(o);break}v(r,e.elm,i)}(e,t,i,a),!0}}(e,t,i,a)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?l.createElementNS(e.ns,m):l.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,a)):r(e.isComment)?(e.elm=l.createComment(e.text),v(i,e.elm,a)):(e.elm=l.createTextNode(e.text),v(i,e.elm,a))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(nr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?l.parentNode(r)===e&&l.insertBefore(e,t,r):l.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&l.appendChild(e.elm,l.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](rr,e);n(a=e.data.hook)&&(n(a.create)&&a.create(rr,e),n(a.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))l.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t),r=r.parent;n(t=Yt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&l.setStyleScope(e.elm,t)}function _(e,t,n,r,i,a){for(;r<=i;++r)f(n[r],a,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):u(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&u(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else u(e.elm)}function C(e,t,r,i){for(var a=r;a<i;a++){var o=t[a];if(n(o)&&ar(e,o))return a}}function x(e,i,a,o,c,u){if(e!==i){n(i.elm)&&n(o)&&(i=o[c]=ye(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,a):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,a,o){for(var s,c,u,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!o;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ar(h,g)?(x(h,g,a,i,d),h=r[++p],g=i[++d]):ar(m,b)?(x(m,b,a,i,y),m=r[--v],b=i[--y]):ar(h,b)?(x(h,b,a,i,y),w&&l.insertBefore(e,h.elm,l.nextSibling(m.elm)),h=r[++p],b=i[--y]):ar(m,g)?(x(m,g,a,i,d),w&&l.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,a,e,h.elm,!1,i,d):ar(u=r[c],g)?(x(u,g,a,i,d),r[c]=void 0,w&&l.insertBefore(e,u.elm,h.elm)):f(g,a,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,a):d>y&&$(r,p,v)}(p,h,y,a,u):n(y)?(n(e.text)&&l.setTextContent(p,""),_(p,null,y,0,y.length-1,a)):n(h)?$(h,0,h.length-1):n(e.text)&&l.setTextContent(p,""):e.text!==i.text&&l.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function A(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var a=0;a<t.length;++a)t[a].data.hook.insert(t[a])}var k=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,a){var o,s=t.tag,c=t.data,l=t.children;if(a=a||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(o=c.hook)&&n(o=o.init)&&o(t,!0),n(o=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(l))if(e.hasChildNodes())if(n(o=c)&&n(o=o.domProps)&&n(o=o.innerHTML)){if(o!==e.innerHTML)return!1}else{for(var u=!0,f=e.firstChild,p=0;p<l.length;p++){if(!f||!O(f,l[p],i,a)){u=!1;break}f=f.nextSibling}if(!u||f)return!1}else h(t,l,i);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(t,i);break}!v&&c.class&&rt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,a,o){if(!t(i)){var c,u=!1,p=[];if(t(e))u=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ar(e,i))x(e,i,p,null,null,o);else{if(d){if(1===e.nodeType&&e.hasAttribute(D)&&(e.removeAttribute(D),a=!0),r(a)&&O(e,i,p))return A(i,p,!0),e;c=e,e=new de(l.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=l.parentNode(v);if(f(i,p,v._leaveCb?null:h,l.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](rr,y);var C=y.data.hook.insert;if(C.merged)for(var k=1;k<C.fns.length;k++)C.fns[k]()}else nr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return A(i,p,u),i.elm}n(e)&&b(e)}}({nodeOps:er,modules:[yr,Ar,ti,ii,hi,z?{create:Mi,activate:Mi,remove:function(e,r){!0!==e.data.show?function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=yi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!W,b=Di(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Si(i,u),Si(i,p)),w.cancelled?(_&&Si(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Oi(i,l),Oi(i,p),ki((function(){Si(i,l),w.cancelled||(Oi(i,u),b||(ji($)?setTimeout(w,$):Ti(i,c,w)))}))),v&&v(i,w),_||b||w())}}(e,r):r()}}:{}].concat(dr)});W&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Vi(e,"input")}));var Fi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ct(n,"postpatch",(function(){Fi.componentUpdated(e,t,n)})):Pi(e,t,n.context),e._vOptions=[].map.call(e.options,Bi)):("textarea"===n.tag||Qn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Ui),e.addEventListener("compositionend",zi),e.addEventListener("change",zi),W&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Pi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Bi);if(i.some((function(e,t){return!E(e,r[t])})))(e.multiple?t.value.some((function(e){return Hi(e,i)})):t.value!==t.oldValue&&Hi(t.value,i))&&Vi(e,"change")}}};function Pi(e,t,n){Ri(e,t),(J||Z)&&setTimeout((function(){Ri(e,t)}),0)}function Ri(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var a,o,s=0,c=e.options.length;s<c;s++)if(o=e.options[s],i)a=L(r,Bi(o))>-1,o.selected!==a&&(o.selected=a);else if(E(Bi(o),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function Hi(e,t){return t.every((function(t){return!E(t,e)}))}function Bi(e){return"_value"in e?e._value:e.value}function Ui(e){e.target.composing=!0}function zi(e){e.target.composing&&(e.target.composing=!1,Vi(e.target,"input"))}function Vi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}var Ki=/\s+/;function qi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ki).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function Ji(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(Ki).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function Wi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&k(t,Zi(e.name||"v")),k(t,e),t}return"string"==typeof e?Zi(e):void 0}}var Zi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),Gi=z&&!W,Xi="transition",Yi="animation",Qi="transition",ea="transitionend",ta="animation",na="animationend";Gi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Qi="WebkitTransition",ea="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(ta="WebkitAnimation",na="webkitAnimationEnd"));var ra=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function ia(e){ra((function(){ra(e)}))}function aa(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),qi(e,t))}function oa(e,t){e._transitionClasses&&h(e._transitionClasses,t),Ji(e,t)}function sa(e,t,n){var r=la(e,t),i=r.type,a=r.timeout,o=r.propCount;if(!i)return n();var s=i===Xi?ea:na,c=0,l=function(){e.removeEventListener(s,u),n()},u=function(t){t.target===e&&++c>=o&&l()};setTimeout((function(){c<o&&l()}),a+1),e.addEventListener(s,u)}var ca=/\b(transform|all)(,|$)/;function la(e,t){var n,r=window.getComputedStyle(e),i=(r[Qi+"Delay"]||"").split(", "),a=(r[Qi+"Duration"]||"").split(", "),o=ua(i,a),s=(r[ta+"Delay"]||"").split(", "),c=(r[ta+"Duration"]||"").split(", "),l=ua(s,c),u=0,f=0;return t===Xi?o>0&&(n=Xi,u=o,f=a.length):t===Yi?l>0&&(n=Yi,u=l,f=c.length):f=(n=(u=Math.max(o,l))>0?o>l?Xi:Yi:null)?n===Xi?a.length:c.length:0,{type:n,timeout:u,propCount:f,hasTransform:n===Xi&&ca.test(r[Qi+"Property"])}}function ua(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return fa(t)+fa(e[n])})))}function fa(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function pa(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var o=Wi(e.data.transition);if(!t(o)&&!n(i._enterCb)&&1===i.nodeType){for(var s=o.css,c=o.type,l=o.enterClass,u=o.enterToClass,p=o.enterActiveClass,d=o.appearClass,v=o.appearToClass,h=o.appearActiveClass,m=o.beforeEnter,y=o.enter,g=o.afterEnter,_=o.enterCancelled,b=o.beforeAppear,$=o.appear,w=o.afterAppear,C=o.appearCancelled,x=o.duration,A=Yt,k=Yt.$vnode;k&&k.parent;)A=k.context,k=k.parent;var O=!A._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:l,T=O&&h?h:p,N=O&&v?v:u,E=O&&b||m,L=O&&"function"==typeof $?$:y,D=O&&w||g,M=O&&C||_,I=f(a(x)?x.enter:x),F=!1!==s&&!W,P=va(L),R=i._enterCb=j((function(){F&&(oa(i,N),oa(i,T)),R.cancelled?(F&&oa(i,S),M&&M(i)):D&&D(i),i._enterCb=null}));e.data.show||ct(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),L&&L(i,R)})),E&&E(i),F&&(aa(i,S),aa(i,T),ia((function(){oa(i,S),R.cancelled||(aa(i,N),P||(da(I)?setTimeout(R,I):sa(i,c,R)))}))),e.data.show&&(r&&r(),L&&L(i,R)),F||P||R()}}}function da(e){return"number"==typeof e&&!isNaN(e)}function va(e){if(t(e))return!1;var r=e.fns;return n(r)?va(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function ha(e){return!e.componentInstance||e.data&&e.data.transition?e:ha(e.componentInstance._vnode)}var ma={model:Fi,show:{bind:function(e,t,n){var r=t.value,i=(n=ha(n)).data&&n.data.transition,a=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,pa(n,(function(){e.style.display=a}))):e.style.display=r?a:"none"},update:function(e,r,i){var o=r.value;!o!=!r.oldValue&&((i=ha(i)).data&&i.data.transition?(i.data.show=!0,o?pa(i,(function(){e.style.display=e.__vOriginalDisplay})):function(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var o=Wi(e.data.transition);if(t(o)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=o.css,c=o.type,l=o.leaveClass,u=o.leaveToClass,p=o.leaveActiveClass,d=o.beforeLeave,v=o.leave,h=o.afterLeave,m=o.leaveCancelled,y=o.delayLeave,g=o.duration,_=!1!==s&&!W,b=va(v),$=f(a(g)?g.leave:g),w=i._leaveCb=j((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(oa(i,u),oa(i,p)),w.cancelled?(_&&oa(i,l),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(aa(i,l),aa(i,p),ia((function(){oa(i,l),w.cancelled||(aa(i,u),b||(da($)?setTimeout(w,$):sa(i,c,w)))}))),v&&v(i,w),_||b||w())}}(i,(function(){e.style.display="none"}))):e.style.display=o?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},ya={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function ga(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?ga(Jt(t.children)):e}function _a(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var a in i)t[b(a)]=i[a];return t}function ba(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var $a=function(e){return e.tag||qt(e)},wa=function(e){return"show"===e.name},Ca={name:"transition",props:ya,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter($a)).length){var r=this.mode,a=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return a;var o=ga(a);if(!o)return a;if(this._leaving)return ba(e,a);var s="__transition-"+this._uid+"-";o.key=null==o.key?o.isComment?s+"comment":s+o.tag:i(o.key)?0===String(o.key).indexOf(s)?o.key:s+o.key:o.key;var c=(o.data||(o.data={})).transition=_a(this),l=this._vnode,u=ga(l);if(o.data.directives&&o.data.directives.some(wa)&&(o.data.show=!0),u&&u.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(o,u)&&!qt(u)&&(!u.componentInstance||!u.componentInstance._vnode.isComment)){var f=u.data.transition=k({},c);if("out-in"===r)return this._leaving=!0,ct(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),ba(e,a);if("in-out"===r){if(qt(o))return l;var p,d=function(){p()};ct(c,"afterEnter",d),ct(c,"enterCancelled",d),ct(f,"delayLeave",(function(e){p=e}))}}return a}}},xa=k({tag:String,moveClass:String},ya);function Aa(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function ka(e){e.data.newPos=e.elm.getBoundingClientRect()}function Oa(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var a=e.elm.style;a.transform=a.WebkitTransform="translate("+r+"px,"+i+"px)",a.transitionDuration="0s"}}delete xa.mode;var Sa={Transition:Ca,TransitionGroup:{props:xa,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Qt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],a=this.children=[],o=_a(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(a.push(c),n[c.key]=c,(c.data||(c.data={})).transition=o)}if(r){for(var l=[],u=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=o,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?l.push(p):u.push(p)}this.kept=e(t,null,l),this.removed=u}return e(t,null,a)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(Aa),e.forEach(ka),e.forEach(Oa),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;aa(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(ea,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(ea,e),n._moveCb=null,oa(n,t))})}})))},methods:{hasMove:function(e,t){if(!Gi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){Ji(n,e)})),qi(n,t),n.style.display="none",this.$el.appendChild(n);var r=la(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};On.config.mustUseProp=function(e,t,n){return"value"===n&&In(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},On.config.isReservedTag=Xn,On.config.isReservedAttr=Mn,On.config.getTagNamespace=function(e){return Gn(e)?"svg":"math"===e?"math":void 0},On.config.isUnknownElement=function(e){if(!z)return!0;if(Xn(e))return!1;if(e=e.toLowerCase(),null!=Yn[e])return Yn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Yn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Yn[e]=/HTMLUnknownElement/.test(t.toString())},k(On.options.directives,ma),k(On.options.components,Sa),On.prototype.__patch__=z?Ii:S,On.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=he),rn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new mn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&rn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,rn(e,"mounted")),e}(this,e=e&&z?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},z&&setTimeout((function(){F.devtools&&re&&re.emit("init",On)}),0);var Ta=p("input,textarea,option,select,progress"),Na=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Ea=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function La(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var ja=/\{\{((?:.|\r?\n)+?)\}\}/g,Da=/[-.*+?^${}()|[\]\/\\]/g,Ma=g((function(e){var t=e[0].replace(Da,"\\$&"),n=e[1].replace(Da,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var Ia={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Pr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Fr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Fa,Pa={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Pr(e,"style");n&&(e.staticStyle=JSON.stringify(ai(n)));var r=Fr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Ra=function(e){return(Fa=Fa||document.createElement("div")).innerHTML=e,Fa.textContent},Ha=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Ba=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ua=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,za="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Va="((?:"+za+"\\:)?"+za+")",Ka=new RegExp("^<"+Va),qa=/^\s*(\/?)>/,Ja=new RegExp("^<\\/"+Va+"[^>]*>"),Wa=/^<!DOCTYPE [^>]+>/i,Za=/^<!\--/,Ga=/^<!\[/,Xa=p("script,style,textarea",!0),Ya={},Qa={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},eo=/&(?:lt|gt|quot|amp|#39);/g,to=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,no=p("pre,textarea",!0),ro=function(e,t){return e&&no(e)&&"\n"===t[0]};function io(e,t){var n=t?to:eo;return e.replace(n,(function(e){return Qa[e]}))}var ao,oo,so,co,lo,uo,fo,po,vo=/^@|^v-on:/,ho=/^v-|^@|^:|^#/,mo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,yo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,go=/^\(|\)$/g,_o=/^\[.*\]$/,bo=/:(.*)$/,$o=/^:|^\.|^v-bind:/,wo=/\.[^.\]]+(?=[^\]]*$)/g,Co=/^v-slot(:|$)|^#/,xo=/[\r\n]/,Ao=/[ \f\t\r\n]+/g,ko=g(Ra),Oo="_empty_";function So(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Mo(t),rawAttrsMap:{},parent:n,children:[]}}function To(e,t){ao=t.warn||Tr,uo=t.isPreTag||T,fo=t.mustUseProp||T,po=t.getTagNamespace||T,t.isReservedTag,so=Nr(t.modules,"transformNode"),co=Nr(t.modules,"preTransformNode"),lo=Nr(t.modules,"postTransformNode"),oo=t.delimiters;var n,r,i=[],a=!1!==t.preserveWhitespace,o=t.whitespace,s=!1,c=!1;function l(e){if(u(e),s||e.processed||(e=No(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&Lo(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)o=e,(l=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&l.if&&Lo(l,{exp:o.elseif,block:o});else{if(e.slotScope){var a=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[a]=e}r.children.push(e),e.parent=r}var o,l;e.children=e.children.filter((function(e){return!e.slotScope})),u(e),e.pre&&(s=!1),uo(e.tag)&&(c=!1);for(var f=0;f<lo.length;f++)lo[f](e,t)}function u(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],a=t.expectHTML,o=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&Xa(r)){var l=0,u=r.toLowerCase(),f=Ya[u]||(Ya[u]=new RegExp("([\\s\\S]*?)(</"+u+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return l=r.length,Xa(u)||"noscript"===u||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),ro(u,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,k(u,c-l,c)}else{var d=e.indexOf("<");if(0===d){if(Za.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(Ga.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(Wa);if(m){C(m[0].length);continue}var y=e.match(Ja);if(y){var g=c;C(y[0].length),k(y[1],g,c);continue}var _=x();if(_){A(_),ro(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Ja.test($)||Ka.test($)||Za.test($)||Ga.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(Ka);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(qa))&&(r=e.match(Ua)||e.match(Ba));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function A(e){var n=e.tagName,c=e.unarySlash;a&&("p"===r&&Ha(n)&&k(r),s(n)&&r===n&&k(n));for(var l=o(n)||!!c,u=e.attrs.length,f=new Array(u),p=0;p<u;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:io(v,h)}}l||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,l,e.start,e.end)}function k(e,n,a){var o,s;if(null==n&&(n=c),null==a&&(a=c),e)for(s=e.toLowerCase(),o=i.length-1;o>=0&&i[o].lowerCasedTag!==s;o--);else o=0;if(o>=0){for(var l=i.length-1;l>=o;l--)t.end&&t.end(i[l].tag,n,a);i.length=o,r=o&&i[o-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,a):"p"===s&&(t.start&&t.start(e,[],!1,n,a),t.end&&t.end(e,n,a))}k()}(e,{warn:ao,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,a,o,u,f){var p=r&&r.ns||po(e);J&&"svg"===p&&(a=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];Io.test(r.name)||(r.name=r.name.replace(Fo,""),t.push(r))}return t}(a));var d,v=So(e,a,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||ne()||(v.forbidden=!0);for(var h=0;h<co.length;h++)v=co[h](v,t)||v;s||(!function(e){null!=Pr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),uo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Eo(v),function(e){var t=Pr(e,"v-if");if(t)e.if=t,Lo(e,{exp:t,block:e});else{null!=Pr(e,"v-else")&&(e.else=!0);var n=Pr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Pr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),o?l(v):(r=v,i.push(v))},end:function(e,t,n){var a=i[i.length-1];i.length-=1,r=i[i.length-1],l(a)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,l,u,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ko(e):f.length?o?"condense"===o&&xo.test(e)?"":" ":a?" ":"":"")c||"condense"!==o||(e=e.replace(Ao," ")),!s&&" "!==e&&(l=function(e,t){var n=t?Ma(t):ja;if(n.test(e)){for(var r,i,a,o=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(a=e.slice(c,i)),o.push(JSON.stringify(a)));var l=Or(r[1].trim());o.push("_s("+l+")"),s.push({"@binding":l}),c=i+r[0].length}return c<e.length&&(s.push(a=e.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:s}}}(e,oo))?u={type:2,expression:l.expression,tokens:l.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(u={type:3,text:e}),u&&f.push(u)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function No(e,t){var n,r;(r=Fr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Fr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Pr(e,"scope"),e.slotScope=t||Pr(e,"slot-scope")):(t=Pr(e,"slot-scope"))&&(e.slotScope=t);var n=Fr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Lr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Rr(e,Co);if(r){var i=jo(r),a=i.name,o=i.dynamic;e.slotTarget=a,e.slotTargetDynamic=o,e.slotScope=r.value||Oo}}else{var s=Rr(e,Co);if(s){var c=e.scopedSlots||(e.scopedSlots={}),l=jo(s),u=l.name,f=l.dynamic,p=c[u]=So("template",[],e);p.slotTarget=u,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||Oo,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Fr(e,"name"))}(e),function(e){var t;(t=Fr(e,"is"))&&(e.component=t);null!=Pr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<so.length;i++)e=so[i](e,t)||e;return function(e){var t,n,r,i,a,o,s,c,l=e.attrsList;for(t=0,n=l.length;t<n;t++)if(r=i=l[t].name,a=l[t].value,ho.test(r))if(e.hasBindings=!0,(o=Do(r.replace(ho,"")))&&(r=r.replace(wo,"")),$o.test(r))r=r.replace($o,""),a=Or(a),(c=_o.test(r))&&(r=r.slice(1,-1)),o&&(o.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),o.camel&&!c&&(r=b(r)),o.sync&&(s=Ur(a,"$event"),c?Ir(e,'"update:"+('+r+")",s,null,!1,0,l[t],!0):(Ir(e,"update:"+b(r),s,null,!1,0,l[t]),C(r)!==b(r)&&Ir(e,"update:"+C(r),s,null,!1,0,l[t])))),o&&o.prop||!e.component&&fo(e.tag,e.attrsMap.type,r)?Er(e,r,a,l[t],c):Lr(e,r,a,l[t],c);else if(vo.test(r))r=r.replace(vo,""),(c=_o.test(r))&&(r=r.slice(1,-1)),Ir(e,r,a,o,!1,0,l[t],c);else{var u=(r=r.replace(ho,"")).match(bo),f=u&&u[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),_o.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,a,f,c,o,l[t])}else Lr(e,r,JSON.stringify(a),l[t]),!e.component&&"muted"===r&&fo(e.tag,e.attrsMap.type,r)&&Er(e,r,"true",l[t])}(e),e}function Eo(e){var t;if(t=Pr(e,"v-for")){var n=function(e){var t=e.match(mo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(go,""),i=r.match(yo);i?(n.alias=r.replace(yo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&k(e,n)}}function Lo(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function jo(e){var t=e.name.replace(Co,"");return t||"#"!==e.name[0]&&(t="default"),_o.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Do(e){var t=e.match(wo);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function Mo(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var Io=/^xmlns:NS\d+/,Fo=/^NS\d+:/;function Po(e){return So(e.tag,e.attrsList.slice(),e.parent)}var Ro=[Ia,Pa,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Fr(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Pr(e,"v-if",!0),a=i?"&&("+i+")":"",o=null!=Pr(e,"v-else",!0),s=Pr(e,"v-else-if",!0),c=Po(e);Eo(c),jr(c,"type","checkbox"),No(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+a,Lo(c,{exp:c.if,block:c});var l=Po(e);Pr(l,"v-for",!0),jr(l,"type","radio"),No(l,t),Lo(c,{exp:"("+n+")==='radio'"+a,block:l});var u=Po(e);return Pr(u,"v-for",!0),jr(u,":type",n),No(u,t),Lo(c,{exp:i,block:u}),o?c.else=!0:s&&(c.elseif=s),c}}}}];var Ho,Bo,Uo={expectHTML:!0,modules:Ro,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,a=e.tag,o=e.attrsMap.type;if(e.component)return Br(e,r,i),!1;if("select"===a)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Ur(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Ir(e,"change",r,null,!0)}(e,r,i);else if("input"===a&&"checkbox"===o)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null",a=Fr(e,"true-value")||"true",o=Fr(e,"false-value")||"false";Er(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===a?":("+t+")":":_q("+t+","+a+")")),Ir(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+a+"):("+o+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Ur(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Ur(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Ur(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===a&&"radio"===o)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Ir(e,"change",Ur(t,i),null,!0)}(e,r,i);else if("input"===a||"textarea"===a)!function(e,t,n){var r=e.attrsMap.type,i=n||{},a=i.lazy,o=i.number,s=i.trim,c=!a&&"range"!==r,l=a?"change":"range"===r?"__r":"input",u="$event.target.value";s&&(u="$event.target.value.trim()");o&&(u="_n("+u+")");var f=Ur(t,u);c&&(f="if($event.target.composing)return;"+f);Er(e,"value","("+t+")"),Ir(e,l,f,null,!0),(s||o)&&Ir(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(a))return Br(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&Ta(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return Na(e)||Ea(e)},getTagNamespace:function(e){return Ea(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(Ro)},zo=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function Vo(e,t){e&&(Ho=zo(t.staticKeys||""),Bo=t.isReservedTag||T,Ko(e),qo(e,!1))}function Ko(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!Bo(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(Ho)))}(e),1===e.type){if(!Bo(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Ko(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++){var o=e.ifConditions[i].block;Ko(o),o.static||(e.static=!1)}}}function qo(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)qo(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,a=e.ifConditions.length;i<a;i++)qo(e.ifConditions[i].block,t)}}var Jo=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Wo=/\([^)]*?\);*$/,Zo=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Go={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Xo={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Yo=function(e){return"if("+e+")return null;"},Qo={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Yo("$event.target !== $event.currentTarget"),ctrl:Yo("!$event.ctrlKey"),shift:Yo("!$event.shiftKey"),alt:Yo("!$event.altKey"),meta:Yo("!$event.metaKey"),left:Yo("'button' in $event && $event.button !== 0"),middle:Yo("'button' in $event && $event.button !== 1"),right:Yo("'button' in $event && $event.button !== 2")};function es(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var a in e){var o=ts(e[a]);e[a]&&e[a].dynamic?i+=a+","+o+",":r+='"'+a+'":'+o+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function ts(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return ts(e)})).join(",")+"]";var t=Zo.test(e.value),n=Jo.test(e.value),r=Zo.test(e.value.replace(Wo,""));if(e.modifiers){var i="",a="",o=[];for(var s in e.modifiers)if(Qo[s])a+=Qo[s],Go[s]&&o.push(s);else if("exact"===s){var c=e.modifiers;a+=Yo(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else o.push(s);return o.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(ns).join("&&")+")return null;"}(o)),a&&(i+=a),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function ns(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Go[e],r=Xo[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var rs={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},is=function(e){this.options=e,this.warn=e.warn||Tr,this.transforms=Nr(e.modules,"transformCode"),this.dataGenFns=Nr(e.modules,"genData"),this.directives=k(k({},rs),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function as(e,t){var n=new is(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":os(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function os(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return ss(e,t);if(e.once&&!e.onceProcessed)return cs(e,t);if(e.for&&!e.forProcessed)return fs(e,t);if(e.if&&!e.ifProcessed)return ls(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=hs(e,t),i="_t("+n+(r?","+r:""),a=e.attrs||e.dynamicAttrs?gs((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,o=e.attrsMap["v-bind"];!a&&!o||r||(i+=",null");a&&(i+=","+a);o&&(i+=(a?"":",null")+","+o);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:hs(t,n,!0);return"_c("+e+","+ps(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=ps(e,t));var i=e.inlineTemplate?null:hs(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var a=0;a<t.transforms.length;a++)n=t.transforms[a](e,n);return n}return hs(e,t)||"void 0"}function ss(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+os(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function cs(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ls(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+os(e,t)+","+t.onceId+++","+n+")":os(e,t)}return ss(e,t)}function ls(e,t,n,r){return e.ifProcessed=!0,us(e.ifConditions.slice(),t,n,r)}function us(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+a(i.block)+":"+us(e,t,n,r):""+a(i.block);function a(e){return n?n(e,t):e.once?cs(e,t):os(e,t)}}function fs(e,t,n,r){var i=e.for,a=e.alias,o=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+a+o+s+"){return "+(n||os)(e,t)+"})"}function ps(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,a,o,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){a=n[r],o=!0;var l=t.directives[a.name];l&&(o=!!l(e,a,t.warn)),o&&(c=!0,s+='{name:"'+a.name+'",rawName:"'+a.rawName+'"'+(a.value?",value:("+a.value+"),expression:"+JSON.stringify(a.value):"")+(a.arg?",arg:"+(a.isDynamicArg?a.arg:'"'+a.arg+'"'):"")+(a.modifiers?",modifiers:"+JSON.stringify(a.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+gs(e.attrs)+","),e.props&&(n+="domProps:"+gs(e.props)+","),e.events&&(n+=es(e.events,!1)+","),e.nativeEvents&&(n+=es(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||ds(n)})),i=!!e.if;if(!r)for(var a=e.parent;a;){if(a.slotScope&&a.slotScope!==Oo||a.for){r=!0;break}a.if&&(i=!0),a=a.parent}var o=Object.keys(t).map((function(e){return vs(t[e],n)})).join(",");return"scopedSlots:_u(["+o+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var a=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=as(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);a&&(n+=a+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+gs(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function ds(e){return 1===e.type&&("slot"===e.tag||e.children.some(ds))}function vs(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ls(e,t,vs,"null");if(e.for&&!e.forProcessed)return fs(e,t,vs);var r=e.slotScope===Oo?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(hs(e,t)||"undefined")+":undefined":hs(e,t)||"undefined":os(e,t))+"}",a=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+a+"}"}function hs(e,t,n,r,i){var a=e.children;if(a.length){var o=a[0];if(1===a.length&&o.for&&"template"!==o.tag&&"slot"!==o.tag){var s=n?t.maybeComponent(o)?",1":",0":"";return""+(r||os)(o,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(ms(i)||i.ifConditions&&i.ifConditions.some((function(e){return ms(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(a,t.maybeComponent):0,l=i||ys;return"["+a.map((function(e){return l(e,t)})).join(",")+"]"+(c?","+c:"")}}function ms(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function ys(e,t){return 1===e.type?os(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:_s(JSON.stringify(e.text)))+")"}(e)}function gs(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],a=_s(i.value);i.dynamic?n+=i.name+","+a+",":t+='"'+i.name+'":'+a+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function _s(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function bs(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function $s(e){var t=Object.create(null);return function(n,r,i){(r=k({},r)).warn,delete r.warn;var a=r.delimiters?String(r.delimiters)+n:n;if(t[a])return t[a];var o=e(n,r),s={},c=[];return s.render=bs(o.render,c),s.staticRenderFns=o.staticRenderFns.map((function(e){return bs(e,c)})),t[a]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var ws,Cs,xs=(ws=function(e,t){var n=To(e.trim(),t);!1!==t.optimize&&Vo(n,t);var r=as(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],a=[];if(n)for(var o in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=k(Object.create(e.directives||null),n.directives)),n)"modules"!==o&&"directives"!==o&&(r[o]=n[o]);r.warn=function(e,t,n){(n?a:i).push(e)};var s=ws(t.trim(),r);return s.errors=i,s.tips=a,s}return{compile:t,compileToFunctions:$s(t)}})(Uo).compileToFunctions;function As(e){return(Cs=Cs||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',Cs.innerHTML.indexOf("&#10;")>0}var ks=!!z&&As(!1),Os=!!z&&As(!0),Ss=g((function(e){var t=La(e);return t&&t.innerHTML})),Ts=On.prototype.$mount;return On.prototype.$mount=function(e,t){if((e=e&&La(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=Ss(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=xs(r,{outputSourceRange:!1,shouldDecodeNewlines:ks,shouldDecodeNewlinesForHref:Os,delimiters:n.delimiters,comments:n.comments},this),a=i.render,o=i.staticRenderFns;n.render=a,n.staticRenderFns=o}}return Ts.call(this,e,t)},On.compile=xs,On}));
\ No newline at end of file
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,(function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,x=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var C=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},E=function(e){return e};function N(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every((function(e,n){return N(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return N(e[n],t[n])}))}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(N(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function H(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var B=new RegExp("[^"+P.source+".$_\\d]");var U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),q=z&&window.navigator.userAgent.toLowerCase(),J=q&&/msie|trident/.test(q),W=q&&q.indexOf("msie 9.0")>0,Z=q&&q.indexOf("edge/")>0;q&&q.indexOf("android");var G=q&&/iphone|ipad|ipod|ios/.test(q)||"ios"===K;q&&/chrome\/\d+/.test(q),q&&/phantomjs/.test(q);var X,Y=q&&q.match(/firefox\/(\d+)/),Q={}.watch,ee=!1;if(z)try{var te={};Object.defineProperty(te,"passive",{get:function(){ee=!0}}),window.addEventListener("test-passive",null,te)}catch(e){}var ne=function(){return void 0===X&&(X=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},re=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ie(e){return"function"==typeof e&&/native code/.test(e.toString())}var oe,ae="undefined"!=typeof Symbol&&ie(Symbol)&&"undefined"!=typeof Reflect&&ie(Reflect.ownKeys);oe="undefined"!=typeof Set&&ie(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var se=S,ce=0,ue=function(){this.id=ce++,this.subs=[]};ue.prototype.addSub=function(e){this.subs.push(e)},ue.prototype.removeSub=function(e){h(this.subs,e)},ue.prototype.depend=function(){ue.target&&ue.target.addDep(this)},ue.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ue.target=null;var le=[];function fe(e){le.push(e),ue.target=e}function pe(){le.pop(),ue.target=le[le.length-1]}var de=function(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ve={child:{configurable:!0}};ve.child.get=function(){return this.componentInstance},Object.defineProperties(de.prototype,ve);var he=function(e){void 0===e&&(e="");var t=new de;return t.text=e,t.isComment=!0,t};function me(e){return new de(void 0,void 0,void 0,String(e))}function ye(e){var t=new de(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ge=Array.prototype,_e=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ge[e];H(_e,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var be=Object.getOwnPropertyNames(_e),$e=!0;function we(e){$e=e}var xe=function(e){this.value=e,this.dep=new ue,this.vmCount=0,H(e,"__ob__",this),Array.isArray(e)?(U?function(e,t){e.__proto__=t}(e,_e):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];H(e,o,t[o])}}(e,_e,be),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(o(e)&&!(e instanceof de))return y(e,"__ob__")&&e.__ob__ instanceof xe?n=e.__ob__:$e&&!ne()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new xe(e)),t&&n&&n.vmCount++,n}function ke(e,t,n,r,i){var o=new ue,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ue.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&Se(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&Ce(t),o.notify())}})}}function Ae(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(ke(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Oe(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Se(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Se(t)}xe.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)ke(e,t[n])},xe.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Te=F.optionMergeStrategies;function Ee(e,t){if(!t)return e;for(var n,r,i,o=ae?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Ee(r,i):Ae(e,n,i));return e}function Ne(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Ee(r,i):i}:t?e?function(){return Ee("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function je(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function De(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Te.data=function(e,t,n){return n?Ne(e,t,n):t&&"function"!=typeof t?e:Ne(e,t)},I.forEach((function(e){Te[e]=je})),M.forEach((function(e){Te[e+"s"]=De})),Te.watch=function(e,t,n,r){if(e===Q&&(e=void 0),t===Q&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Te.props=Te.methods=Te.inject=Te.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Te.provide=Ne;var Le=function(e,t){return void 0===t?e:t};function Me(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Me(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Me(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Te[r]||Le;a[r]=i(e[r],t[r],n,r)}return a}function Ie(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Fe(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Be(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===x(e)){var c=Be(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Re(t.type)?r.call(e):r}(r,i,e);var u=$e;we(!0),Ce(a),we(u)}return a}var Pe=/^\s*function (\w+)/;function Re(e){var t=e&&e.toString().match(Pe);return t?t[1]:""}function He(e,t){return Re(e)===Re(t)}function Be(e,t){if(!Array.isArray(t))return He(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(He(t[n],e))return n;return-1}function Ue(e,t,n){fe();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Ve(e,r,"errorCaptured hook")}}Ve(e,t,n)}finally{pe()}}function ze(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch((function(e){return Ue(e,r,i+" (Promise/async)")})),o._handled=!0)}catch(e){Ue(e,r,i)}return o}function Ve(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ke(t)}Ke(e)}function Ke(e,t,n){if(!z&&!V||"undefined"==typeof console)throw e;console.error(e)}var qe,Je=!1,We=[],Ze=!1;function Ge(){Ze=!1;var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&ie(Promise)){var Xe=Promise.resolve();qe=function(){Xe.then(Ge),G&&setTimeout(S)},Je=!0}else if(J||"undefined"==typeof MutationObserver||!ie(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())qe="undefined"!=typeof setImmediate&&ie(setImmediate)?function(){setImmediate(Ge)}:function(){setTimeout(Ge,0)};else{var Ye=1,Qe=new MutationObserver(Ge),et=document.createTextNode(String(Ye));Qe.observe(et,{characterData:!0}),qe=function(){Ye=(Ye+1)%2,et.data=String(Ye)},Je=!0}function tt(e,t){var n;if(We.push((function(){if(e)try{e.call(t)}catch(e){Ue(e,t,"nextTick")}else n&&n(t)})),Ze||(Ze=!0,qe()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var nt=new oe;function rt(e){it(e,nt),nt.clear()}function it(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!o(e)||Object.isFrozen(e)||e instanceof de)){if(e.__ob__){var a=e.__ob__.dep.id;if(t.has(a))return;t.add(a)}if(i)for(n=e.length;n--;)it(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)it(e[r[n]],t)}}var ot=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function at(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return ze(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)ze(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function st(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=ot(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=at(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=ot(c)).name,n[c],f.capture)}function ct(e,i,o){var a;e instanceof de&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=at([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=at([s,c]),a.merged=!0,e[i]=a}function ut(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function lt(e){return i(e)?[me(e)]:Array.isArray(e)?pt(e):void 0}function ft(e){return n(e)&&n(e.text)&&!1===e.isComment}function pt(e,o){var a,s,c,u,l=[];for(a=0;a<e.length;a++)t(s=e[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ft((s=pt(s,(o||"")+"_"+a))[0])&&ft(u)&&(l[c]=me(u.text+s[0].text),s.shift()),l.push.apply(l,s)):i(s)?ft(u)?l[c]=me(u.text+s):""!==s&&l.push(me(s)):ft(s)&&ft(u)?l[c]=me(u.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(o)&&(s.key="__vlist"+o+"_"+a+"__"),l.push(s)));return l}function dt(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function vt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(ht)&&delete n[u];return n}function ht(e){return e.isComment&&!e.asyncFactory||" "===e.text}function mt(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=yt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=gt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),H(i,"$stable",a),H(i,"$key",s),H(i,"$hasNormal",o),i}function yt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:lt(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function gt(e,t){return function(){return e[t]}}function _t(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(ae&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function bt(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function $t(e){return Ie(this.$options,"filters",e)||E}function wt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function xt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?wt(i,r):o?wt(o,e):r?x(r)!==t:void 0}function Ct(e,t,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=x(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function kt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||Ot(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function At(e,t,n){return Ot(e,"__once__"+t+(n?"_"+n:""),!0),e}function Ot(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&St(e[r],t+"_"+r,n);else St(e,t,n)}function St(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function Tt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function Et(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Et(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function Nt(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function jt(e,t){return"string"==typeof e?t+e:e}function Dt(e){e._o=At,e._n=f,e._s=l,e._l=_t,e._t=bt,e._q=N,e._i=j,e._m=kt,e._f=$t,e._k=xt,e._b=Ct,e._v=me,e._e=he,e._u=Et,e._g=Tt,e._d=Nt,e._p=jt}function Lt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=dt(u.inject,o),this.slots=function(){return c.$slots||mt(t.scopedSlots,c.$slots=vt(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return mt(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=mt(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Bt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Bt(s,e,t,n,r,f)}}function Mt(e,t,n,r,i){var o=ye(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function It(e,t){for(var n in t)e[b(n)]=t[n]}Dt(Lt.prototype);var Ft={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ft.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Yt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){we(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Fe(d,v,n,t)}we(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Xt(t,r,h),u&&(t.$slots=vt(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,rn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,an.push(t)):tn(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?nn(t,!0):t.$destroy())}},Pt=Object.keys(Ft);function Rt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Vt;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return h(s,a)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D((function(t){e.resolved=Kt(t,i),c?s.length=0:p(!0)})),v=D((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Kt(m.error,i)),n(m.loading)&&(e.loadingComp=Kt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout((function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=he();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},An(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=x(u);ut(a,c,u,l,!0)||ut(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Fe(l,u,r||e);else n(i.attrs)&&It(c,i.attrs),n(i.props)&&It(c,i.props);var f=new Lt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof de)return Mt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=lt(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Mt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Pt.length;n++){var r=Pt[n],i=t[r],o=Ft[r];i===o||i&&i._merged||(t[r]=i?Ht(o,i):o)}}(a);var y=i.options.name||l;return new de("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Ht(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Bt(e,t,a,s,c,u){return(Array.isArray(a)||i(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(e,t,r,i,a){if(n(r)&&n(r.__ob__))return he();n(r)&&n(r.is)&&(t=r.is);if(!t)return he();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===a?i=lt(i):1===a&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var u;c=e.$vnode&&e.$vnode.ns||F.getTagNamespace(t),s=F.isReservedTag(t)?new de(F.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(u=Ie(e.$options,"components",t))?new de(t,r,i,void 0,void 0,e):Rt(u,r,e,i,t)}else s=Rt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Ut(s,c),n(r)&&function(e){o(e.style)&&rt(e.style);o(e.class)&&rt(e.class)}(r),s):he()}(e,t,a,s,c)}function Ut(e,i,o){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,o=!0),n(e.children))for(var a=0,s=e.children.length;a<s;a++){var c=e.children[a];n(c.tag)&&(t(c.ns)||r(o)&&"svg"!==c.tag)&&Ut(c,i,o)}}var zt,Vt=null;function Kt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function qt(e){return e.isComment&&e.asyncFactory}function Jt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||qt(r)))return r}}function Wt(e,t){zt.$on(e,t)}function Zt(e,t){zt.$off(e,t)}function Gt(e,t){var n=zt;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Xt(e,t,n){zt=e,st(t,n||{},Wt,Zt,Gt,e),zt=void 0}var Yt=null;function Qt(e){var t=Yt;return Yt=e,function(){Yt=t}}function en(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function tn(e,t){if(t){if(e._directInactive=!1,en(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);rn(e,"activated")}}function nn(e,t){if(!(t&&(e._directInactive=!0,en(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)nn(e.$children[n]);rn(e,"deactivated")}}function rn(e,t){fe();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)ze(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),pe()}var on=[],an=[],sn={},cn=!1,un=!1,ln=0;var fn=0,pn=Date.now;if(z&&!J){var dn=window.performance;dn&&"function"==typeof dn.now&&pn()>document.createEvent("Event").timeStamp&&(pn=function(){return dn.now()})}function vn(){var e,t;for(fn=pn(),un=!0,on.sort((function(e,t){return e.id-t.id})),ln=0;ln<on.length;ln++)(e=on[ln]).before&&e.before(),t=e.id,sn[t]=null,e.run();var n=an.slice(),r=on.slice();ln=on.length=an.length=0,sn={},cn=un=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,tn(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&rn(r,"updated")}}(r),re&&F.devtools&&re.emit("flush")}var hn=0,mn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++hn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new oe,this.newDepIds=new oe,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!B.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};mn.prototype.get=function(){var e;fe(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Ue(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rt(e),pe(),this.cleanupDeps()}return e},mn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},mn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},mn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==sn[t]){if(sn[t]=!0,un){for(var n=on.length-1;n>ln&&on[n].id>e.id;)n--;on.splice(n+1,0,e)}else on.push(e);cn||(cn=!0,tt(vn))}}(this)},mn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Ue(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},mn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},mn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},mn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var yn={enumerable:!0,configurable:!0,get:S,set:S};function gn(e,t,n){yn.get=function(){return this[t][n]},yn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,yn)}function _n(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&we(!1);var o=function(o){i.push(o);var a=Fe(o,t,n,e);ke(r,o,a),o in e||gn(e,"_props",o)};for(var a in t)o(a);we(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:C(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){fe();try{return e.call(t,t)}catch(e){return Ue(e,t,"data()"),{}}finally{pe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||R(o)||gn(e,"_data",o)}Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=ne();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new mn(e,a||S,S,bn)),i in e||$n(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Q&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(e,n,r[i]);else Cn(e,n,r)}}(e,t.watch)}var bn={lazy:!0};function $n(e,t,n){var r=!ne();"function"==typeof n?(yn.get=r?wn(t):xn(n),yn.set=S):(yn.get=n.get?r&&!1!==n.cache?wn(t):xn(n.get):S,yn.set=n.set||S),Object.defineProperty(e,t,yn)}function wn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ue.target&&t.depend(),t.value}}function xn(e){return function(){return e.call(this,this)}}function Cn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var kn=0;function An(e){var t=e.options;if(e.super){var n=An(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Me(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function On(e){this._init(e)}function Sn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=Me(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)gn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)$n(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach((function(e){a[e]=n[e]})),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function Tn(e){return e&&(e.Ctor.options.name||e.tag)}function En(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function Nn(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=Tn(a.componentOptions);s&&!t(s)&&jn(n,o,r,i)}}}function jn(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=kn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Me(An(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Xt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=vt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Bt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Bt(t,e,n,r,i,!0)};var o=r&&r.data;ke(t,"$attrs",o&&o.attrs||e,null,!0),ke(t,"$listeners",n._parentListeners||e,null,!0)}(n),rn(n,"beforeCreate"),function(e){var t=dt(e.$options.inject,e);t&&(we(!1),Object.keys(t).forEach((function(n){ke(e,n,t[n])})),we(!0))}(n),_n(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),rn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(On),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=Ae,e.prototype.$delete=Oe,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return Cn(r,e,t,n);(n=n||{}).user=!0;var i=new mn(r,e,t,n);if(n.immediate){fe();try{t.call(r,i.value)}catch(e){Ue(e,r,'callback for immediate watcher "'+i.expression+'"')}pe()}return function(){i.teardown()}}}(On),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?k(n):n;for(var r=k(arguments,1),i='event handler for "'+e+'"',o=0,a=n.length;o<a;o++)ze(n[o],t,r,t,i)}return t}}(On),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Qt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){rn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),rn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(On),function(e){Dt(e.prototype),e.prototype.$nextTick=function(e){return tt(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=mt(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Vt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Ue(n,t,"render"),e=t._vnode}finally{Vt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof de||(e=he()),e.parent=i,e}}(On);var Dn=[String,RegExp,Array],Ln={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Dn,exclude:Dn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)jn(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){Nn(e,(function(e){return En(t,e)}))})),this.$watch("exclude",(function(t){Nn(e,(function(e){return!En(t,e)}))}))},render:function(){var e=this.$slots.default,t=Jt(e),n=t&&t.componentOptions;if(n){var r=Tn(n),i=this.include,o=this.exclude;if(i&&(!r||!En(i,r))||o&&r&&En(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&jn(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:se,extend:A,mergeOptions:Me,defineReactive:ke},e.set=Ae,e.delete=Oe,e.nextTick=tt,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),M.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,A(e.options.components,Ln),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Me(this.options,e),this}}(e),Sn(e),function(e){M.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(On),Object.defineProperty(On.prototype,"$isServer",{get:ne}),Object.defineProperty(On.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(On,"FunctionalRenderContext",{value:Lt}),On.version="2.6.12";var Mn=p("style,class"),In=p("input,textarea,option,select,progress"),Fn=p("contenteditable,draggable,spellcheck"),Pn=p("events,caret,typing,plaintext-only"),Rn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Hn="http://www.w3.org/1999/xlink",Bn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Un=function(e){return Bn(e)?e.slice(6,e.length):""},zn=function(e){return null==e||!1===e};function Vn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Kn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Kn(t,r.data));return function(e,t){if(n(e)||n(t))return qn(e,Jn(t));return""}(t.staticClass,t.class)}function Kn(e,t){return{staticClass:qn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function qn(e,t){return e?t?e+" "+t:e:t||""}function Jn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Jn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Zn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Gn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(e){return Zn(e)||Gn(e)};var Yn=Object.create(null);var Qn=p("text,number,password,search,email,tel,url");var er=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Wn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),tr={create:function(e,t){nr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(nr(e,!0),nr(t))},destroy:function(e){nr(e,!0)}};function nr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var rr=new de("",{},[]),ir=["create","activate","update","remove","destroy"];function or(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Qn(i)&&Qn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function ar(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var sr={create:cr,update:cr,destroy:function(e){cr(e,rr)}};function cr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===rr,a=t===rr,s=lr(e.data.directives,e.context),c=lr(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,pr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(pr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)pr(u[n],"inserted",t,e)};o?ct(t,"insert",f):f()}l.length&&ct(t,"postpatch",(function(){for(var n=0;n<l.length;n++)pr(l[n],"componentUpdated",t,e)}));if(!o)for(n in s)c[n]||pr(s[n],"unbind",e,e,a)}(e,t)}var ur=Object.create(null);function lr(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ur),i[fr(r)]=r,r.def=Ie(t.$options,"directives",r.name);return i}function fr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function pr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Ue(r,n.context,"directive "+e.name+" "+t+" hook")}}var dr=[tr,sr];function vr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&hr(s,o,a,r.data.pre);for(o in(J||Z)&&u.value!==c.value&&hr(s,"value",u.value),c)t(u[o])&&(Bn(o)?s.removeAttributeNS(Hn,Un(o)):Fn(o)||s.removeAttribute(o))}}function hr(e,t,n,r){r||e.tagName.indexOf("-")>-1?mr(e,t,n):Rn(t)?zn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Fn(t)?e.setAttribute(t,function(e,t){return zn(t)||"false"===t?"false":"contenteditable"===e&&Pn(t)?t:"true"}(t,n)):Bn(t)?zn(n)?e.removeAttributeNS(Hn,Un(t)):e.setAttributeNS(Hn,t,n):mr(e,t,n)}function mr(e,t,n){if(zn(n))e.removeAttribute(t);else{if(J&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var yr={create:vr,update:vr};function gr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Vn(r),c=i._transitionClasses;n(c)&&(s=qn(s,Jn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var _r,br,$r,wr,xr,Cr,kr={create:gr,update:gr},Ar=/[\w).+\-_$\]]/;function Or(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&Ar.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Sr(i,o[r]);return i}function Sr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Tr(e,t){console.error("[Vue compiler]: "+e)}function Er(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Dr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Hr({name:t,value:n},r))}function Lr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Hr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Mr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Ir(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Mr("!",n,c)),i.once&&(delete i.once,n=Mr("~",n,c)),i.passive&&(delete i.passive,n=Mr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Hr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Fr(e,t,n){var r=Pr(e,":"+t)||Pr(e,"v-bind:"+t);if(null!=r)return Or(r);if(!1!==n){var i=Pr(e,t);if(null!=i)return JSON.stringify(i)}}function Pr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Rr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Hr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Br(e,t,n){var r=n||{},i=r.number,o="$$v",a=o;r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var s=Ur(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Ur(e,t){var n=function(e){if(e=e.trim(),_r=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<_r-1)return(wr=e.lastIndexOf("."))>-1?{exp:e.slice(0,wr),key:'"'+e.slice(wr+1)+'"'}:{exp:e,key:null};br=e,wr=xr=Cr=0;for(;!Vr();)Kr($r=zr())?Jr($r):91===$r&&qr($r);return{exp:e.slice(0,xr),key:e.slice(xr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function zr(){return br.charCodeAt(++wr)}function Vr(){return wr>=_r}function Kr(e){return 34===e||39===e}function qr(e){var t=1;for(xr=wr;!Vr();)if(Kr(e=zr()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=wr;break}}function Jr(e){for(var t=e;!Vr()&&(e=zr())!==t;);}var Wr;function Zr(e,t,n){var r=Wr;return function i(){var o=t.apply(null,arguments);null!==o&&Yr(e,i,n,r)}}var Gr=Je&&!(Y&&Number(Y[1])<=53);function Xr(e,t,n,r){if(Gr){var i=fn,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Wr.addEventListener(e,t,ee?{capture:n,passive:r}:n)}function Yr(e,t,n,r){(r||Wr).removeEventListener(e,t._wrapper||t,n)}function Qr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};Wr=r.elm,function(e){if(n(e.__r)){var t=J?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),st(i,o,Xr,Yr,Zr,r.context),Wr=void 0}}var ei,ti={create:Qr,update:Qr};function ni(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ri(a,u)&&(a.value=u)}else if("innerHTML"===i&&Gn(a.tagName)&&t(a.innerHTML)){(ei=ei||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ei.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ri(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ii={create:ni,update:ni},oi=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function ai(e){var t=si(e.style);return e.staticStyle?A(e.staticStyle,t):t}function si(e){return Array.isArray(e)?O(e):"string"==typeof e?oi(e):e}var ci,ui=/^--/,li=/\s*!important$/,fi=function(e,t,n){if(ui.test(t))e.style.setProperty(t,n);else if(li.test(n))e.style.setProperty(x(t),n.replace(li,""),"important");else{var r=di(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},pi=["Webkit","Moz","ms"],di=g((function(e){if(ci=ci||document.createElement("div").style,"filter"!==(e=b(e))&&e in ci)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<pi.length;n++){var r=pi[n]+t;if(r in ci)return r}}));function vi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=si(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ai(i.data))&&A(r,n);(n=ai(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=ai(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&fi(c,s,"");for(s in d)(a=d[s])!==f[s]&&fi(c,s,null==a?"":a)}}var hi={create:vi,update:vi},mi=/\s+/;function yi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function _i(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,bi(e.name||"v")),A(t,e),t}return"string"==typeof e?bi(e):void 0}}var bi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),$i=z&&!W,wi="transition",xi="animation",Ci="transition",ki="transitionend",Ai="animation",Oi="animationend";$i&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ci="WebkitTransition",ki="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ai="WebkitAnimation",Oi="webkitAnimationEnd"));var Si=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ti(e){Si((function(){Si(e)}))}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),yi(e,t))}function Ni(e,t){e._transitionClasses&&h(e._transitionClasses,t),gi(e,t)}function ji(e,t,n){var r=Li(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===wi?ki:Oi,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),e.addEventListener(s,l)}var Di=/\b(transform|all)(,|$)/;function Li(e,t){var n,r=window.getComputedStyle(e),i=(r[Ci+"Delay"]||"").split(", "),o=(r[Ci+"Duration"]||"").split(", "),a=Mi(i,o),s=(r[Ai+"Delay"]||"").split(", "),c=(r[Ai+"Duration"]||"").split(", "),u=Mi(s,c),l=0,f=0;return t===wi?a>0&&(n=wi,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?wi:xi:null)?n===wi?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===wi&&Di.test(r[Ci+"Property"])}}function Mi(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Ii(t)+Ii(e[n])})))}function Ii(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Fi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=_i(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,x=a.appearCancelled,C=a.duration,k=Yt,A=Yt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,E=O&&v?v:l,N=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&x||_,I=f(o(C)?C.enter:C),F=!1!==s&&!W,P=Hi(j),R=i._enterCb=D((function(){F&&(Ni(i,E),Ni(i,T)),R.cancelled?(F&&Ni(i,S),M&&M(i)):L&&L(i),i._enterCb=null}));e.data.show||ct(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)})),N&&N(i),F&&(Ei(i,S),Ei(i,T),Ti((function(){Ni(i,S),R.cancelled||(Ei(i,E),P||(Ri(I)?setTimeout(R,I):ji(i,c,R)))}))),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Pi(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=_i(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Hi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ni(i,l),Ni(i,p)),w.cancelled?(_&&Ni(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(x):x()}function x(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ti((function(){Ni(i,u),w.cancelled||(Ei(i,l),b||(Ri($)?setTimeout(w,$):ji(i,c,w)))}))),v&&v(i,w),_||b||w())}}function Ri(e){return"number"==typeof e&&!isNaN(e)}function Hi(e){if(t(e))return!1;var r=e.fns;return n(r)?Hi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Bi(e,t){!0!==t.data.show&&Fi(t)}var Ui=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<ir.length;++o)for(s[ir[o]]=[],a=0;a<c.length;++a)n(c[a][ir[o]])&&s[ir[o]].push(c[a][ir[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=ye(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){var o,a=e;for(;a.componentInstance;)if(n(o=(a=a.componentInstance._vnode).data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](rr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(nr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](rr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(rr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Yt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function x(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&or(e,a))return o}}function C(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=ye(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:or(h,g)?(C(h,g,o,i,d),h=r[++p],g=i[++d]):or(m,b)?(C(m,b,o,i,y),m=r[--v],b=i[--y]):or(h,b)?(C(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):or(m,g)?(C(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=ar(r,p,v)),t(c=n(g.key)?s[g.key]:x(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):or(l=r[c],g)?(C(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&rt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&or(e,i))C(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new de(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](rr,y);var x=y.data.hook.insert;if(x.merged)for(var A=1;A<x.fns.length;A++)x.fns[A]()}else nr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:er,modules:[yr,kr,ti,ii,hi,z?{create:Bi,activate:Bi,remove:function(e,t){!0!==e.data.show?Pi(e,t):t()}}:{}].concat(dr)});W&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Gi(e,"input")}));var zi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ct(n,"postpatch",(function(){zi.componentUpdated(e,t,n)})):Vi(e,t,n.context),e._vOptions=[].map.call(e.options,Ji)):("textarea"===n.tag||Qn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Wi),e.addEventListener("compositionend",Zi),e.addEventListener("change",Zi),W&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Vi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ji);if(i.some((function(e,t){return!N(e,r[t])})))(e.multiple?t.value.some((function(e){return qi(e,i)})):t.value!==t.oldValue&&qi(t.value,i))&&Gi(e,"change")}}};function Vi(e,t,n){Ki(e,t),(J||Z)&&setTimeout((function(){Ki(e,t)}),0)}function Ki(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Ji(a))>-1,a.selected!==o&&(a.selected=o);else if(N(Ji(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every((function(t){return!N(t,e)}))}function Ji(e){return"_value"in e?e._value:e.value}function Wi(e){e.target.composing=!0}function Zi(e){e.target.composing&&(e.target.composing=!1,Gi(e.target,"input"))}function Gi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Xi(e){return!e.componentInstance||e.data&&e.data.transition?e:Xi(e.componentInstance._vnode)}var Yi={model:zi,show:{bind:function(e,t,n){var r=t.value,i=(n=Xi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Fi(n,(function(){e.style.display=o}))):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Xi(n)).data&&n.data.transition?(n.data.show=!0,r?Fi(n,(function(){e.style.display=e.__vOriginalDisplay})):Pi(n,(function(){e.style.display="none"}))):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},Qi={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function eo(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?eo(Jt(t.children)):e}function to(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function no(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var ro=function(e){return e.tag||qt(e)},io=function(e){return"show"===e.name},oo={name:"transition",props:Qi,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(ro)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=eo(o);if(!a)return o;if(this._leaving)return no(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=to(this),u=this._vnode,l=eo(u);if(a.data.directives&&a.data.directives.some(io)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!qt(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,ct(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),no(e,o);if("in-out"===r){if(qt(a))return u;var p,d=function(){p()};ct(c,"afterEnter",d),ct(c,"enterCancelled",d),ct(f,"delayLeave",(function(e){p=e}))}}return o}}},ao=A({tag:String,moveClass:String},Qi);function so(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function co(e){e.data.newPos=e.elm.getBoundingClientRect()}function uo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete ao.mode;var lo={Transition:oo,TransitionGroup:{props:ao,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Qt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=to(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=e(t,null,u),this.removed=l}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(so),e.forEach(co),e.forEach(uo),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(ki,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(ki,e),n._moveCb=null,Ni(n,t))})}})))},methods:{hasMove:function(e,t){if(!$i)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){gi(n,e)})),yi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Li(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};On.config.mustUseProp=function(e,t,n){return"value"===n&&In(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},On.config.isReservedTag=Xn,On.config.isReservedAttr=Mn,On.config.getTagNamespace=function(e){return Gn(e)?"svg":"math"===e?"math":void 0},On.config.isUnknownElement=function(e){if(!z)return!0;if(Xn(e))return!1;if(e=e.toLowerCase(),null!=Yn[e])return Yn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Yn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Yn[e]=/HTMLUnknownElement/.test(t.toString())},A(On.options.directives,Yi),A(On.options.components,lo),On.prototype.__patch__=z?Ui:S,On.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=he),rn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new mn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&rn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,rn(e,"mounted")),e}(this,e=e&&z?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},z&&setTimeout((function(){F.devtools&&re&&re.emit("init",On)}),0);var fo=p("input,textarea,option,select,progress"),po=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),vo=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function ho(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var mo=/\{\{((?:.|\r?\n)+?)\}\}/g,yo=/[-.*+?^${}()|[\]\/\\]/g,go=g((function(e){var t=e[0].replace(yo,"\\$&"),n=e[1].replace(yo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var _o={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Pr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Fr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var bo,$o={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Pr(e,"style");n&&(e.staticStyle=JSON.stringify(oi(n)));var r=Fr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},wo=function(e){return(bo=bo||document.createElement("div")).innerHTML=e,bo.textContent},xo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Co=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ko=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ao="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Oo="((?:"+Ao+"\\:)?"+Ao+")",So=new RegExp("^<"+Oo),To=/^\s*(\/?)>/,Eo=new RegExp("^<\\/"+Oo+"[^>]*>"),No=/^<!DOCTYPE [^>]+>/i,jo=/^<!\--/,Do=/^<!\[/,Lo=p("script,style,textarea",!0),Mo={},Io={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Fo=/&(?:lt|gt|quot|amp|#39);/g,Po=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ro=p("pre,textarea",!0),Ho=function(e,t){return e&&Ro(e)&&"\n"===t[0]};function Bo(e,t){var n=t?Po:Fo;return e.replace(n,(function(e){return Io[e]}))}var Uo,zo,Vo,Ko,qo,Jo,Wo,Zo,Go=/^@|^v-on:/,Xo=/^v-|^@|^:|^#/,Yo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Qo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,ea=/^\(|\)$/g,ta=/^\[.*\]$/,na=/:(.*)$/,ra=/^:|^\.|^v-bind:/,ia=/\.[^.\]]+(?=[^\]]*$)/g,oa=/^v-slot(:|$)|^#/,aa=/[\r\n]/,sa=/[ \f\t\r\n]+/g,ca=g(wo),ua="_empty_";function la(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ya(t),rawAttrsMap:{},parent:n,children:[]}}function fa(e,t){Uo=t.warn||Tr,Jo=t.isPreTag||T,Wo=t.mustUseProp||T,Zo=t.getTagNamespace||T,t.isReservedTag,Vo=Er(t.modules,"transformNode"),Ko=Er(t.modules,"preTransformNode"),qo=Er(t.modules,"postTransformNode"),zo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=pa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&va(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&va(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter((function(e){return!e.slotScope})),l(e),e.pre&&(s=!1),Jo(e.tag)&&(c=!1);for(var f=0;f<qo.length;f++)qo[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&Lo(r)){var u=0,l=r.toLowerCase(),f=Mo[l]||(Mo[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return u=r.length,Lo(l)||"noscript"===l||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ho(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(jo.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),x(v+3);continue}}if(Do.test(e)){var h=e.indexOf("]>");if(h>=0){x(h+2);continue}}var m=e.match(No);if(m){x(m[0].length);continue}var y=e.match(Eo);if(y){var g=c;x(y[0].length),A(y[1],g,c);continue}var _=C();if(_){k(_),Ho(_.tagName,e)&&x(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Eo.test($)||So.test($)||jo.test($)||Do.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&x(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function x(t){c+=t,e=e.substring(t)}function C(){var t=e.match(So);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(x(t[0].length);!(n=e.match(To))&&(r=e.match(ko)||e.match(Co));)r.start=c,x(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],x(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&xo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Bo(v,h)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,u,e.start,e.end)}function A(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Uo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||Zo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ga.test(r.name)||(r.name=r.name.replace(_a,""),t.push(r))}return t}(o));var d,v=la(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||ne()||(v.forbidden=!0);for(var h=0;h<Ko.length;h++)v=Ko[h](v,t)||v;s||(!function(e){null!=Pr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Jo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(da(v),function(e){var t=Pr(e,"v-if");if(t)e.if=t,va(e,{exp:t,block:e});else{null!=Pr(e,"v-else")&&(e.else=!0);var n=Pr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Pr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u,l,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ca(e):f.length?a?"condense"===a&&aa.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(sa," ")),!s&&" "!==e&&(u=function(e,t){var n=t?go(t):mo;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Or(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,zo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function pa(e,t){var n,r;(r=Fr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Fr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Pr(e,"scope"),e.slotScope=t||Pr(e,"slot-scope")):(t=Pr(e,"slot-scope"))&&(e.slotScope=t);var n=Fr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||jr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Rr(e,oa);if(r){var i=ha(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ua}}else{var s=Rr(e,oa);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=ha(s),l=u.name,f=u.dynamic,p=c[l]=la("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||ua,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Fr(e,"name"))}(e),function(e){var t;(t=Fr(e,"is"))&&(e.component=t);null!=Pr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Vo.length;i++)e=Vo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Xo.test(r))if(e.hasBindings=!0,(a=ma(r.replace(Xo,"")))&&(r=r.replace(ia,"")),ra.test(r))r=r.replace(ra,""),o=Or(o),(c=ta.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Ur(o,"$event"),c?Ir(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Ir(e,"update:"+b(r),s,null,!1,0,u[t]),x(r)!==b(r)&&Ir(e,"update:"+x(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Wo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):jr(e,r,o,u[t],c);else if(Go.test(r))r=r.replace(Go,""),(c=ta.test(r))&&(r=r.slice(1,-1)),Ir(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Xo,"")).match(na),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ta.test(f)&&(f=f.slice(1,-1),c=!0)),Lr(e,r,i,o,f,c,a,u[t])}else jr(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Wo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function da(e){var t;if(t=Pr(e,"v-for")){var n=function(e){var t=e.match(Yo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(ea,""),i=r.match(Qo);i?(n.alias=r.replace(Qo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function va(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function ha(e){var t=e.name.replace(oa,"");return t||"#"!==e.name[0]&&(t="default"),ta.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ma(e){var t=e.match(ia);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function ya(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ga=/^xmlns:NS\d+/,_a=/^NS\d+:/;function ba(e){return la(e.tag,e.attrsList.slice(),e.parent)}var $a=[_o,$o,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Fr(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Pr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Pr(e,"v-else",!0),s=Pr(e,"v-else-if",!0),c=ba(e);da(c),Dr(c,"type","checkbox"),pa(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,va(c,{exp:c.if,block:c});var u=ba(e);Pr(u,"v-for",!0),Dr(u,"type","radio"),pa(u,t),va(c,{exp:"("+n+")==='radio'"+o,block:u});var l=ba(e);return Pr(l,"v-for",!0),Dr(l,":type",n),pa(l,t),va(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var wa,xa,Ca={expectHTML:!0,modules:$a,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Br(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Ur(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Ir(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null",o=Fr(e,"true-value")||"true",a=Fr(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Ir(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Ur(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Ur(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Ur(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Ir(e,"change",Ur(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?"__r":"input",l="$event.target.value";s&&(l="$event.target.value.trim()");a&&(l="_n("+l+")");var f=Ur(t,l);c&&(f="if($event.target.composing)return;"+f);Nr(e,"value","("+t+")"),Ir(e,u,f,null,!0),(s||a)&&Ir(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Br(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&fo(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return po(e)||vo(e)},getTagNamespace:function(e){return vo(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}($a)},ka=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function Aa(e,t){e&&(wa=ka(t.staticKeys||""),xa=t.isReservedTag||T,Oa(e),Sa(e,!1))}function Oa(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!xa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(wa)))}(e),1===e.type){if(!xa(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Oa(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++){var a=e.ifConditions[i].block;Oa(a),a.static||(e.static=!1)}}}function Sa(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)Sa(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++)Sa(e.ifConditions[i].block,t)}}var Ta=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ea=/\([^)]*?\);*$/,Na=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,ja={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Da={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},La=function(e){return"if("+e+")return null;"},Ma={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:La("$event.target !== $event.currentTarget"),ctrl:La("!$event.ctrlKey"),shift:La("!$event.shiftKey"),alt:La("!$event.altKey"),meta:La("!$event.metaKey"),left:La("'button' in $event && $event.button !== 0"),middle:La("'button' in $event && $event.button !== 1"),right:La("'button' in $event && $event.button !== 2")};function Ia(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=Fa(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Fa(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return Fa(e)})).join(",")+"]";var t=Na.test(e.value),n=Ta.test(e.value),r=Na.test(e.value.replace(Ea,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(Ma[s])o+=Ma[s],ja[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=La(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Pa).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Pa(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=ja[e],r=Da[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ra={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Ha=function(e){this.options=e,this.warn=e.warn||Tr,this.transforms=Er(e.modules,"transformCode"),this.dataGenFns=Er(e.modules,"genData"),this.directives=A(A({},Ra),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Ba(e,t){var n=new Ha(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ua(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ua(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return za(e,t);if(e.once&&!e.onceProcessed)return Va(e,t);if(e.for&&!e.forProcessed)return Ja(e,t);if(e.if&&!e.ifProcessed)return Ka(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=Xa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?es((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:Xa(t,n,!0);return"_c("+e+","+Wa(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Wa(e,t));var i=e.inlineTemplate?null:Xa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return Xa(e,t)||"void 0"}function za(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ua(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Va(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ka(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ua(e,t)+","+t.onceId+++","+n+")":Ua(e,t)}return za(e,t)}function Ka(e,t,n,r){return e.ifProcessed=!0,qa(e.ifConditions.slice(),t,n,r)}function qa(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+o(i.block)+":"+qa(e,t,n,r):""+o(i.block);function o(e){return n?n(e,t):e.once?Va(e,t):Ua(e,t)}}function Ja(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ua)(e,t)+"})"}function Wa(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+es(e.attrs)+","),e.props&&(n+="domProps:"+es(e.props)+","),e.events&&(n+=Ia(e.events,!1)+","),e.nativeEvents&&(n+=Ia(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Za(n)})),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ua||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map((function(e){return Ga(t[e],n)})).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Ba(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+es(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Za(e){return 1===e.type&&("slot"===e.tag||e.children.some(Za))}function Ga(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ka(e,t,Ga,"null");if(e.for&&!e.forProcessed)return Ja(e,t,Ga);var r=e.slotScope===ua?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(Xa(e,t)||"undefined")+":undefined":Xa(e,t)||"undefined":Ua(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Xa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ua)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Ya(i)||i.ifConditions&&i.ifConditions.some((function(e){return Ya(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Qa;return"["+o.map((function(e){return u(e,t)})).join(",")+"]"+(c?","+c:"")}}function Ya(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Qa(e,t){return 1===e.type?Ua(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:ts(JSON.stringify(e.text)))+")"}(e)}function es(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=ts(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ts(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ns(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function rs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=ns(a.render,c),s.staticRenderFns=a.staticRenderFns.map((function(e){return ns(e,c)})),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var is,os,as=(is=function(e,t){var n=fa(e.trim(),t);!1!==t.optimize&&Aa(n,t);var r=Ba(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=is(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:rs(t)}})(Ca).compileToFunctions;function ss(e){return(os=os||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',os.innerHTML.indexOf("&#10;")>0}var cs=!!z&&ss(!1),us=!!z&&ss(!0),ls=g((function(e){var t=ho(e);return t&&t.innerHTML})),fs=On.prototype.$mount;return On.prototype.$mount=function(e,t){if((e=e&&ho(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ls(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=as(r,{outputSourceRange:!1,shouldDecodeNewlines:cs,shouldDecodeNewlinesForHref:us,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return fs.call(this,e,t)},On.compile=as,On}));
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index abf8b710ea3..40c045b5791 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -6334,12 +6334,12 @@ var style = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+var whitespaceRE = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass$1(el, cls) {
+function addClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6347,7 +6347,7 @@ function addClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6364,7 +6364,7 @@ function addClass$1(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass$1(el, cls) {
+function removeClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6372,7 +6372,7 @@ function removeClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6397,7 +6397,7 @@ function removeClass$1(el, cls) {
     }
 }
 
-function resolveTransition$1(def) {
+function resolveTransition(def) {
     if (!def) {
         return;
     }
@@ -6405,16 +6405,16 @@ function resolveTransition$1(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition$1(def.name || 'v'));
+            extend(res, autoCssTransition(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition$1(def);
+        return autoCssTransition(def);
     }
 }
-var autoCssTransition$1 = cached(function (name) {
+var autoCssTransition = cached(function (name) {
     return {
         enterClass: (name + "-enter"),
         enterToClass: (name + "-enter-to"),
@@ -6424,62 +6424,62 @@ var autoCssTransition$1 = cached(function (name) {
         leaveActiveClass: (name + "-leave-active"),
     };
 });
-var hasTransition$1 = inBrowser && !isIE9;
-var TRANSITION$1 = 'transition';
-var ANIMATION$1 = 'animation';
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp$1 = 'transition';
-var transitionEndEvent$1 = 'transitionend';
-var animationProp$1 = 'animation';
-var animationEndEvent$1 = 'animationend';
-if (hasTransition$1) {
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp$1 = 'WebkitTransition';
-        transitionEndEvent$1 = 'webkitTransitionEnd';
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp$1 = 'WebkitAnimation';
-        animationEndEvent$1 = 'webkitAnimationEnd';
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf$1 = inBrowser
+var raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame$1(fn) {
-    raf$1(function () {
+function nextFrame(fn) {
+    raf(function () {
         // @ts-expect-error
-        raf$1(fn);
+        raf(fn);
     });
 }
-function addTransitionClass$1(el, cls) {
+function addTransitionClass(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass$1(el, cls);
+        addClass(el, cls);
     }
 }
-function removeTransitionClass$1(el, cls) {
+function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass$1(el, cls);
+    removeClass(el, cls);
 }
-function whenTransitionEnds$1(el, expectedType, cb) {
-    var ref = getTransitionInfo$1(el, expectedType);
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
     var type = ref.type;
     var timeout = ref.timeout;
     var propCount = ref.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -6499,30 +6499,30 @@ function whenTransitionEnds$1(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE$1 = /\b(transform|all)(,|$)/;
-function getTransitionInfo$1(el, expectedType) {
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION$1) {
+    if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
-            type = TRANSITION$1;
+            type = TRANSITION;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION$1) {
+    else if (expectedType === ANIMATION) {
         if (animationTimeout > 0) {
-            type = ANIMATION$1;
+            type = ANIMATION;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6532,16 +6532,16 @@ function getTransitionInfo$1(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION$1
-                    : ANIMATION$1
+                    ? TRANSITION
+                    : ANIMATION
                 : null;
         propCount = type
-            ? type === TRANSITION$1
+            ? type === TRANSITION
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -6549,31 +6549,31 @@ function getTransitionInfo$1(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout$1(delays, durations) {
+function getTimeout(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs$1(d) + toMs$1(delays[i]);
+        return toMs(d) + toMs(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs$1(s) {
+function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter$1(vnode, toggleDisplay) {
+function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -6627,19 +6627,19 @@ function enter$1(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
-        checkDuration$1(explicitEnterDuration, 'enter', vnode);
+        checkDuration(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(enterHook);
+    var userWantsControl = getHookArgumentsLength(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass$1(el, toClass);
-            removeTransitionClass$1(el, activeClass);
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, startClass);
+                removeTransitionClass(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -6664,19 +6664,19 @@ function enter$1(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass$1(el, startClass);
-        addTransitionClass$1(el, activeClass);
-        nextFrame$1(function () {
-            removeTransitionClass$1(el, startClass);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass$1(el, toClass);
+                addTransitionClass(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration$1(explicitEnterDuration)) {
+                    if (isValidDuration(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds$1(el, type, cb);
+                        whenTransitionEnds(el, type, cb);
                     }
                 }
             }
@@ -6690,14 +6690,14 @@ function enter$1(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave$1(vnode, rm) {
+function leave(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -6717,23 +6717,23 @@ function leave$1(vnode, rm) {
     var delayLeave = data.delayLeave;
     var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(leave);
+    var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
-        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass$1(el, leaveToClass);
-            removeTransitionClass$1(el, leaveActiveClass);
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, leaveClass);
+                removeTransitionClass(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -6761,19 +6761,19 @@ function leave$1(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass$1(el, leaveClass);
-            addTransitionClass$1(el, leaveActiveClass);
-            nextFrame$1(function () {
-                removeTransitionClass$1(el, leaveClass);
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass$1(el, leaveToClass);
+                    addTransitionClass(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration$1(explicitLeaveDuration)) {
+                        if (isValidDuration(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds$1(el, type, cb);
+                            whenTransitionEnds(el, type, cb);
                         }
                     }
                 }
@@ -6786,7 +6786,7 @@ function leave$1(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration$1(val, name, vnode) {
+function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
             "got " + (JSON.stringify(val)) + ".", vnode.context);
@@ -6796,7 +6796,7 @@ function checkDuration$1(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration$1(val) {
+function isValidDuration(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -6805,7 +6805,7 @@ function isValidDuration$1(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength$1(fn) {
+function getHookArgumentsLength(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -6813,7 +6813,7 @@ function getHookArgumentsLength$1(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -6822,7 +6822,7 @@ function getHookArgumentsLength$1(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter$1(vnode);
+        enter(vnode);
     }
 }
 var transition = inBrowser
@@ -6833,7 +6833,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave$1(vnode, rm);
+                leave(vnode, rm);
             }
             else {
                 rm();
@@ -6981,493 +6981,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-var whitespaceRE = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        var res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-var autoCssTransition = cached(function (name) {
-    return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
-    };
-});
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
-// Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        // @ts-expect-error
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        // @ts-expect-error
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    var onEnd = function (e) {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(function () {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    var el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    var cb = (el._leaveCb = once(function () {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn("<transition> explicit " + name + " duration is NaN - " +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
index 8cde5e48a58..b5d208fc75d 100644
--- a/dist/vue.runtime.common.prod.js
+++ b/dist/vue.runtime.common.prod.js
@@ -8,4 +8,4 @@
  * (c) 2014-2021 Evan You
  * Released under the MIT License.
  */
-var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function i(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function o(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){for(var n=Object.create(null),r=t.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var p=d("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,w=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var A=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function $(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function k(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}var S=function(t,e,n){return!1},T=function(t){return t};function E(t,e){if(t===e)return!0;var n=o(t),r=o(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var i=Array.isArray(t),a=Array.isArray(e);if(i&&a)return t.length===e.length&&t.every((function(t,n){return E(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(i||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return E(t[n],e[n])}))}catch(t){return!1}}function j(t,e){for(var n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D=["component","directive","filter"],N=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:N};function P(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var it=O,ot=0,at=function(){this.id=ot++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,i,o,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var dt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function pt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=ht[t];M(mt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?function(t,e){t.__proto__=e}(t,mt):function(t,e,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];M(t,o,e[o])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(o(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,r,i){var o=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!i&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(e)&&xt(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!i&&Ct(e),o.notify())}})}}function At(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(wt(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function $t(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function xt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&xt(e)}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)wt(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var kt=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;for(var n,r,i,o=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=t[n],i=e[n],m(t,n)?r!==i&&s(r)&&s(i)&&Ot(r,i):At(t,n,i));return t}function St(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,i="function"==typeof t?t.call(n,n):t;return r?Ot(r,i):i}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,r){var i=Object.create(t||null);return e?x(i,e):i}kt.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},N.forEach((function(t){kt[t]=Tt})),D.forEach((function(t){kt[t+"s"]=Et})),kt.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var i={};for(var o in x(i,t),e){var a=i[o],s=e[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},kt.props=kt.methods=kt.inject=kt.computed=function(t,e,n,r){if(!t)return e;var i=Object.create(null);return x(i,t),e&&x(i,e),i},kt.provide=St;var jt=function(t,e){return void 0===e?t:e};function It(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[_(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[_(a)]=s(i)?i:{type:i};t.props=o}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?x({from:o},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=It(t,e.extends,n)),e.mixins))for(var r=0,i=e.mixins.length;r<i;r++)t=It(t,e.mixins[r],n);var o,a={};for(o in t)c(o);for(o in e)m(t,o)||c(o);function c(r){var i=kt[r]||jt;a[r]=i(t[r],e[r],n,r)}return a}function Dt(t,e,n,r){if("string"==typeof n){var i=t[e];if(m(i,n))return i[n];var o=_(n);if(m(i,o))return i[o];var a=b(o);return m(i,a)?i[a]:i[n]||i[o]||i[a]}}function Nt(t,e,n,r){var i=e[t],o=!m(n,t),a=n[t],s=Ft(Boolean,i.type);if(s>-1)if(o&&!m(i,"default"))a=!1;else if(""===a||a===w(t)){var c=Ft(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Pt(e.type)?r.call(t):r}(r,i,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Lt=/^\s*function (\w+)/;function Pt(t){var e=t&&t.toString().match(Lt);return e?e[1]:""}function Mt(t,e){return Pt(t)===Pt(e)}function Ft(t,e){if(!Array.isArray(e))return Mt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Mt(e[n],t))return n;return-1}function Rt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{ut()}}function Ut(t,e,n,r,i){var o;try{(o=n?t.apply(e,n):t.call(e))&&!o._isVue&&u(o)&&!o._handled&&(o.catch((function(t){return Rt(t,r,i+" (Promise/async)")})),o._handled=!0)}catch(t){Rt(t,r,i)}return o}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Vt,zt=!1,Wt=[],qt=!1;function Kt(){qt=!1;var t=Wt.slice(0);Wt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Xt=Promise.resolve();Vt=function(){Xt.then(Kt),K&&setTimeout(O)},zt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Kt)}:function(){setTimeout(Kt,0)};else{var Gt=1,Zt=new MutationObserver(Kt),Jt=document.createTextNode(String(Gt));Zt.observe(Jt,{characterData:!0}),Vt=function(){Gt=(Gt+1)%2,Jt.data=String(Gt)},zt=!0}function Qt(t,e){var n;if(Wt.push((function(){if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var Yt=new nt;function te(t){ee(t,Yt),Yt.clear()}function ee(t,e){var n,r,i=Array.isArray(t);if(!(!i&&!o(t)||Object.isFrozen(t)||t instanceof lt)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(i)for(n=t.length;n--;)ee(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ee(t[r[n]],e)}}var ne=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function re(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ut(r,null,arguments,e,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)Ut(i[o],null,t,e,"v-on handler")}return n.fns=t,n}function ie(t,n,i,o,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=ne(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=re(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&o((f=ne(c)).name,n[c],f.capture)}function oe(t,i,o){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[i];function c(){o.apply(this,arguments),v(a.fns,c)}e(s)?a=re([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=re([s,c]),a.merged=!0,t[i]=a}function ae(t,e,r,i,o){if(n(e)){if(m(e,r))return t[r]=e[r],o||delete e[r],!0;if(m(e,i))return t[r]=e[i],o||delete e[i],!0}return!1}function se(t){return i(t)?[pt(t)]:Array.isArray(t)?ue(t):void 0}function ce(t){return n(t)&&n(t.text)&&!1===t.isComment}function ue(t,o){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ce((s=ue(s,(o||"")+"_"+a))[0])&&ce(u)&&(l[c]=pt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):i(s)?ce(u)?l[c]=pt(u.text+s):""!==s&&l.push(pt(s)):ce(s)&&ce(u)?l[c]=pt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(o)&&(s.key="__vlist"+o+"_"+a+"__"),l.push(s)));return l}function le(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=t[o].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[o]){var c=t[o].default;n[o]="function"==typeof c?c.call(e):c}}}return n}}function fe(t,e){if(!t||!t.length)return{};for(var n={},r=0,i=t.length;r<i;r++){var o=t[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==e&&o.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(de)&&delete n[u];return n}function de(t){return t.isComment&&!t.asyncFactory||" "===t.text}function pe(e,n,r){var i,o=Object.keys(n).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=ve(n,c,e[c]))}else i={};for(var u in n)u in i||(i[u]=he(n,u));return e&&Object.isExtensible(e)&&(e._normalized=i),M(i,"$stable",a),M(i,"$key",s),M(i,"$hasNormal",o),i}function ve(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:se(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function he(t,e){return function(){return t[e]}}function me(t,e){var r,i,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,i=t.length;r<i;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(o(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ye(t,e,n,r){var i,o=this.$scopedSlots[t];o?(n=n||{},r&&(n=x(x({},r),n)),i=o(n)||e):i=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function ge(t){return Dt(this.$options,"filters",t)||T}function _e(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function be(t,e,n,r,i){var o=L.keyCodes[e]||n;return i&&r&&!L.keyCodes[e]?_e(i,r):o?_e(o,t):r?w(r)!==e:void 0}function Ce(t,e,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=k(n));var s=function(o){if("class"===o||"style"===o||p(o))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,o)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(o),u=w(o);c in a||u in a||(a[o]=n[o],i&&((t.on||(t.on={}))["update:"+o]=function(t){n[o]=t}))};for(var c in n)s(c)}else;return t}function we(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||$e(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function Ae(t,e,n){return $e(t,"__once__"+e+(n?"_"+n:""),!0),t}function $e(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&xe(t[r],e+"_"+r,n);else xe(t,e,n)}function xe(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function ke(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var i=n[r],o=e[r];n[r]=i?[].concat(i,o):o}}else;return t}function Oe(t,e,n,r){e=e||{$stable:!n};for(var i=0;i<t.length;i++){var o=t[i];Array.isArray(o)?Oe(o,e,n):o&&(o.proxy&&(o.fn.proxy=!0),e[o.key]=o.fn)}return r&&(e.$key=r),e}function Se(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Te(t,e){return"string"==typeof t?e+t:t}function Ee(t){t._o=Ae,t._n=f,t._s=l,t._l=me,t._t=ye,t._q=E,t._i=j,t._m=we,t._f=ge,t._k=be,t._b=Ce,t._v=pt,t._e=dt,t._u=Oe,t._g=ke,t._d=Se,t._p=Te}function je(e,n,i,o,a){var s,c=this,u=a.options;m(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=i,this.parent=o,this.listeners=e.on||t,this.injections=le(u.inject,o),this.slots=function(){return c.$slots||pe(e.scopedSlots,c.$slots=fe(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return pe(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=pe(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var i=Fe(s,t,e,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(t,e,n,r){return Fe(s,t,e,n,r,f)}}function Ie(t,e,n,r,i){var o=vt(t);return o.fnContext=n,o.fnOptions=r,e.slot&&((o.data||(o.data={})).slot=e.slot),o}function De(t,e){for(var n in e)t[_(n)]=e[n]}Ee(je.prototype);var Ne={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ne.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},i=t.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ge)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(o||e.$options._renderChildren||c);e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i);if(e.$options._renderChildren=o,e.$attrs=i.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],d=0;d<f.length;d++){var p=f[d],v=e.$options.props;l[p]=Nt(p,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Xe(e,r,h),u&&(e.$slots=fe(o,i.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,tn(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,nn.push(e)):Qe(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?Ye(e,!0):e.$destroy())}},Le=Object.keys(Ne);function Pe(i,a,s,c,l){if(!e(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var d;if(e(i.cid)&&void 0===(i=function(t,i){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var d=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},p=I((function(e){t.resolved=He(e,i),c?s.length=0:d(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,d(!0))})),m=t(p,h);return o(m)&&(u(m)?e(t.resolved)&&m.then(p,h):u(m.component)&&(m.component.then(p,h),n(m.error)&&(t.errorComp=He(m.error,i)),n(m.loading)&&(t.loadingComp=He(m.loading,i),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,d(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(d=i,f)))return function(t,e,n,r,i){var o=dt();return o.asyncFactory=t,o.asyncMeta={data:e,context:n,children:r,tag:i},o}(d,a,s,c,l);a=a||{},An(i),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",i=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var o=e.on||(e.on={}),a=o[i],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var p=function(t,r,i){var o=r.options.props;if(!e(o)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in o){var l=w(u);ae(a,c,u,l,!0)||ae(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(e,r,i,o,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Nt(l,u,r||t);else n(i.attrs)&&De(c,i.attrs),n(i.props)&&De(c,i.props);var f=new je(i,c,a,o,e),d=s.render.call(null,f._c,f);if(d instanceof lt)return Ie(d,i,f.parent,s);if(Array.isArray(d)){for(var p=se(d)||[],v=new Array(p.length),h=0;h<p.length;h++)v[h]=Ie(p[h],i,f.parent,s);return v}}(i,p,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Le.length;n++){var r=Le[n],i=e[r],o=Ne[r];i===o||i&&i._merged||(e[r]=i?Me(o,i):o)}}(a);var y=i.options.name||l;return new lt("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:p,listeners:h,tag:l,children:c},d)}}}function Me(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Fe(t,e,a,s,c,u){return(Array.isArray(a)||i(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,i,a){if(n(r)&&n(r.__ob__))return dt();n(r)&&n(r.is)&&(e=r.is);if(!e)return dt();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===a?i=se(i):1===a&&(i=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(i));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),s=L.isReservedTag(e)?new lt(L.parsePlatformTagName(e),r,i,void 0,void 0,t):r&&r.pre||!n(u=Dt(t.$options,"components",e))?new lt(e,r,i,void 0,void 0,t):Pe(u,r,t,i,e)}else s=Pe(e,r,t,i);return Array.isArray(s)?s:n(s)?(n(c)&&Re(s,c),n(r)&&function(t){o(t.style)&&te(t.style);o(t.class)&&te(t.class)}(r),s):dt()}(t,e,a,s,c)}function Re(t,i,o){if(t.ns=i,"foreignObject"===t.tag&&(i=void 0,o=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(o)&&"svg"!==c.tag)&&Re(c,i,o)}}var Ue,Be=null;function He(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),o(t)?e.extend(t):t}function Ve(t){return t.isComment&&t.asyncFactory}function ze(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ve(r)))return r}}function We(t,e){Ue.$on(t,e)}function qe(t,e){Ue.$off(t,e)}function Ke(t,e){var n=Ue;return function r(){var i=e.apply(null,arguments);null!==i&&n.$off(t,r)}}function Xe(t,e,n){Ue=t,ie(e,n||{},We,qe,Ke,t),Ue=void 0}var Ge=null;function Ze(t){var e=Ge;return Ge=t,function(){Ge=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Qe(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Qe(t.$children[n]);tn(t,"activated")}}function Ye(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);tn(t,"deactivated")}}function tn(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var i=0,o=n.length;i<o;i++)Ut(n[i],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var en=[],nn=[],rn={},on=!1,an=!1,sn=0;var cn=0,un=Date.now;if(U&&!z){var ln=window.performance;ln&&"function"==typeof ln.now&&un()>document.createEvent("Event").timeStamp&&(un=function(){return ln.now()})}function fn(){var t,e;for(cn=un(),an=!0,en.sort((function(t,e){return t.id-e.id})),sn=0;sn<en.length;sn++)(t=en[sn]).before&&t.before(),e=t.id,rn[e]=null,t.run();var n=nn.slice(),r=en.slice();sn=en.length=nn.length=0,rn={},on=an=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Qe(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&tn(r,"updated")}}(r),tt&&L.devtools&&tt.emit("flush")}var dn=0,pn=function(t,e,n,r,i){this.vm=t,i&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++dn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()};pn.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&te(t),ut(),this.cleanupDeps()}return t},pn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},pn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},pn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==rn[e]){if(rn[e]=!0,an){for(var n=en.length-1;n>sn&&en[n].id>t.id;)n--;en.splice(n+1,0,t)}else en.push(t);on||(on=!0,Qt(fn))}}(this)},pn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||o(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},pn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},pn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},pn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var vn={enumerable:!0,configurable:!0,get:O,set:O};function hn(t,e,n){vn.get=function(){return this[e][n]},vn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,vn)}function mn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},i=t.$options._propKeys=[];t.$parent&&_t(!1);var o=function(o){i.push(o);var a=Nt(o,e,n,t);wt(r,o,a),o in t||hn(t,"_props",o)};for(var a in e)o(a);_t(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?O:A(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&m(r,o)||P(o)||hn(t,"_data",o)}Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var i in e){var o=e[i],a="function"==typeof o?o:o.get;r||(n[i]=new pn(t,a||O,O,yn)),i in t||gn(t,i,o)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(t,n,r[i]);else Cn(t,n,r)}}(t,e.watch)}var yn={lazy:!0};function gn(t,e,n){var r=!Y();"function"==typeof n?(vn.get=r?_n(e):bn(n),vn.set=O):(vn.get=n.get?r&&!1!==n.cache?_n(e):bn(n.get):O,vn.set=n.set||O),Object.defineProperty(t,e,vn)}function _n(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function bn(t){return function(){return t.call(this,this)}}function Cn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var wn=0;function An(t){var e=t.options;if(t.super){var n=An(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var i in n)n[i]!==r[i]&&(e||(e={}),e[i]=n[i]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=It(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function xn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,i=t._Ctor||(t._Ctor={});if(i[r])return i[r];var o=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=It(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)hn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)gn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,D.forEach((function(t){a[t]=n[t]})),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),i[r]=a,a}}function kn(t){return t&&(t.Ctor.options.name||t.tag)}function On(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function Sn(t,e){var n=t.cache,r=t.keys,i=t._vnode;for(var o in n){var a=n[o];if(a){var s=kn(a.componentOptions);s&&!e(s)&&Tn(n,o,r,i)}}}function Tn(t,e,n,r){var i=t[e];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=wn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=It(An(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Xe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,i=r&&r.context;e.$slots=fe(n._renderChildren,i),e.$scopedSlots=t,e._c=function(t,n,r,i){return Fe(e,t,n,r,i,!1)},e.$createElement=function(t,n,r,i){return Fe(e,t,n,r,i,!0)};var o=r&&r.data;wt(e,"$attrs",o&&o.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),tn(n,"beforeCreate"),function(t){var e=le(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach((function(n){wt(t,n,e[n])})),_t(!0))}(n),mn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),tn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=At,t.prototype.$delete=$t,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return Cn(r,t,e,n);(n=n||{}).user=!0;var i=new pn(r,t,e,n);if(n.immediate){ct();try{e.call(r,i.value)}catch(t){Rt(t,r,'callback for immediate watcher "'+i.expression+'"')}ut()}return function(){i.teardown()}}}($n),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var i=0,o=t.length;i<o;i++)r.$on(t[i],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,i=t.length;r<i;r++)n.$off(t[r],e);return n}var o,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((o=a[s])===e||o.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?$(n):n;for(var r=$(arguments,1),i='event handler for "'+t+'"',o=0,a=n.length;o<a;o++)Ut(n[o],e,r,e,i)}return e}}($n),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,i=n._vnode,o=Ze(n);n._vnode=t,n.$el=i?n.__patch__(i,t):n.__patch__(n.$el,t,e,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){tn(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),tn(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}($n),function(t){Ee(t.prototype),t.prototype.$nextTick=function(t){return Qt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,i=n._parentVnode;i&&(e.$scopedSlots=pe(i.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=i;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Rt(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=dt()),t.parent=i,t}}($n);var En=[String,RegExp,Array],jn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:En,exclude:En,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)Tn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){Sn(t,(function(t){return On(e,t)}))})),this.$watch("exclude",(function(e){Sn(t,(function(t){return!On(e,t)}))}))},render:function(){var t=this.$slots.default,e=ze(t),n=e&&e.componentOptions;if(n){var r=kn(n),i=this.include,o=this.exclude;if(i&&(!r||!On(i,r))||o&&r&&On(o,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&Tn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:it,extend:x,mergeOptions:It,defineReactive:wt},t.set=At,t.delete=$t,t.nextTick=Qt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),D.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,jn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=$(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=It(this.options,t),this}}(t),xn(t),function(t){D.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:Y}),Object.defineProperty($n.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:je}),$n.version="2.6.12";var In=d("style,class"),Dn=d("input,textarea,option,select,progress"),Nn=d("contenteditable,draggable,spellcheck"),Ln=d("events,caret,typing,plaintext-only"),Pn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Mn="http://www.w3.org/1999/xlink",Fn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Rn=function(t){return Fn(t)?t.slice(6,t.length):""},Un=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,i=t;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(e=Hn(i.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return Vn(t,zn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:Vn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Vn(t,e){return t?e?t+" "+e:t:e||""}function zn(t){return Array.isArray(t)?function(t){for(var e,r="",i=0,o=t.length;i<o;i++)n(e=zn(t[i]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):o(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},qn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Kn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(t){return qn(t)||Kn(t)};var Gn=Object.create(null);var Zn=d("text,number,password,search,email,tel,url");var Jn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Wn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Qn={create:function(t,e){Yn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Yn(t,!0),Yn(e))},destroy:function(t){Yn(t,!0)}};function Yn(t,e){var r=t.data.ref;if(n(r)){var i=t.context,o=t.componentInstance||t.elm,a=i.$refs;e?Array.isArray(a[r])?v(a[r],o):a[r]===o&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var tr=new lt("",{},[]),er=["create","activate","update","remove","destroy"];function nr(t,i){return t.key===i.key&&(t.tag===i.tag&&t.isComment===i.isComment&&n(t.data)===n(i.data)&&function(t,e){if("input"!==t.tag)return!0;var r,i=n(r=t.data)&&n(r=r.attrs)&&r.type,o=n(r=e.data)&&n(r=r.attrs)&&r.type;return i===o||Zn(i)&&Zn(o)}(t,i)||r(t.isAsyncPlaceholder)&&t.asyncFactory===i.asyncFactory&&e(i.asyncFactory.error))}function rr(t,e,r){var i,o,a={};for(i=e;i<=r;++i)n(o=t[i].key)&&(a[o]=i);return a}var ir={create:or,update:or,destroy:function(t){or(t,tr)}};function or(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,i,o=t===tr,a=e===tr,s=sr(t.data.directives,t.context),c=sr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,ur(i,"update",e,t),i.def&&i.def.componentUpdated&&l.push(i)):(ur(i,"bind",e,t),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ur(u[n],"inserted",e,t)};o?oe(e,"insert",f):f()}l.length&&oe(e,"postpatch",(function(){for(var n=0;n<l.length;n++)ur(l[n],"componentUpdated",e,t)}));if(!o)for(n in s)c[n]||ur(s[n],"unbind",t,t,a)}(t,e)}var ar=Object.create(null);function sr(t,e){var n,r,i=Object.create(null);if(!t)return i;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=ar),i[cr(r)]=r,r.def=Dt(e.$options,"directives",r.name);return i}function cr(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ur(t,e,n,r,i){var o=t.def&&t.def[e];if(o)try{o(n.elm,t,n,r,i)}catch(r){Rt(r,n.context,"directive "+t.name+" "+e+" hook")}}var lr=[Qn,ir];function fr(t,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var o,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[o],c[o]!==a&&dr(s,o,a,r.data.pre);for(o in(z||q)&&u.value!==c.value&&dr(s,"value",u.value),c)e(u[o])&&(Fn(o)?s.removeAttributeNS(Mn,Rn(o)):Nn(o)||s.removeAttribute(o))}}function dr(t,e,n,r){r||t.tagName.indexOf("-")>-1?pr(t,e,n):Pn(e)?Un(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,function(t,e){return Un(e)||"false"===e?"false":"contenteditable"===t&&Ln(e)?e:"true"}(e,n)):Fn(e)?Un(n)?t.removeAttributeNS(Mn,Rn(e)):t.setAttributeNS(Mn,e,n):pr(t,e,n)}function pr(t,e,n){if(Un(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var vr={create:fr,update:fr};function hr(t,r){var i=r.elm,o=r.data,a=t.data;if(!(e(o.staticClass)&&e(o.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=i._transitionClasses;n(c)&&(s=Vn(s,zn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var mr,yr={create:hr,update:hr};function gr(t,e,n){var r=mr;return function i(){var o=e.apply(null,arguments);null!==o&&Cr(t,i,n,r)}}var _r=zt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var i=cn,o=e;e=o._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=i||t.timeStamp<=0||t.target.ownerDocument!==document)return o.apply(this,arguments)}}mr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||mr).removeEventListener(t,e._wrapper||e,n)}function wr(t,r){if(!e(t.data.on)||!e(r.data.on)){var i=r.data.on||{},o=t.data.on||{};mr=r.elm,function(t){if(n(t.__r)){var e=z?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(i),ie(i,o,br,Cr,gr,r.context),mr=void 0}}var Ar,$r={create:wr,update:wr};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var i,o,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=e(o)?"":String(o);kr(a,u)&&(a.value=u)}else if("innerHTML"===i&&Kn(a.tagName)&&e(a.innerHTML)){(Ar=Ar||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=Ar.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(t){}}}}function kr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,i=t._vModifiers;if(n(i)){if(i.number)return f(r)!==f(e);if(i.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Or={create:xr,update:xr},Sr=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function Tr(t){var e=Er(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Er(t){return Array.isArray(t)?k(t):"string"==typeof t?Sr(t):t}var jr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty(w(e),n.replace(Dr,""),"important");else{var r=Pr(e);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)t.style[r]=n[i];else t.style[r]=n}},Lr=["Webkit","Moz","ms"],Pr=y((function(t){if(jr=jr||document.createElement("div").style,"filter"!==(t=_(t))&&t in jr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Lr.length;n++){var r=Lr[n]+e;if(r in jr)return r}}));function Mr(t,r){var i=r.data,o=t.data;if(!(e(i.staticStyle)&&e(i.style)&&e(o.staticStyle)&&e(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,d=Er(r.data.style)||{};r.data.normalizedStyle=n(d.__ob__)?x({},d):d;var p=function(t,e){var n,r={};if(e)for(var i=t;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=Tr(i.data))&&x(r,n);(n=Tr(t.data))&&x(r,n);for(var o=t;o=o.parent;)o.data&&(n=Tr(o.data))&&x(r,n);return r}(r,!0);for(s in f)e(p[s])&&Nr(c,s,"");for(s in p)(a=p[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Br(t.name||"v")),x(e,t),e}return"string"==typeof t?Br(t):void 0}}var Br=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Hr="transition",Vr="transitionend",zr="animation",Wr="animationend";U&&!W&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Hr="WebkitTransition",Vr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(zr="WebkitAnimation",Wr="webkitAnimationEnd"));var qr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Kr(t){qr((function(){qr(t)}))}function Xr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}(t,e))}function Gr(t,e){t._transitionClasses&&v(t._transitionClasses,e),function(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}(t,e)}function Zr(t,e,n){var r=function(t,e){var n,r=window.getComputedStyle(t),i=(r[Hr+"Delay"]||"").split(", "),o=(r[Hr+"Duration"]||"").split(", "),a=Qr(i,o),s=(r[zr+"Delay"]||"").split(", "),c=(r[zr+"Duration"]||"").split(", "),u=Qr(s,c),l=0,f=0;"transition"===e?a>0&&(n="transition",l=a,f=o.length):"animation"===e?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?o.length:c.length:0;var d="transition"===n&&Jr.test(r[Hr+"Property"]);return{type:n,timeout:l,propCount:f,hasTransform:d}}(t,e),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s="transition"===i?Vr:Wr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),t.addEventListener(s,l)}var Jr=/\b(transform|all)(,|$)/;function Qr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return Yr(e)+Yr(t[n])})))}function Yr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ti(t){return"number"==typeof t&&!isNaN(t)}function ei(t){if(e(t))return!1;var r=t.fns;return n(r)?ei(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function ni(t,r){!0!==r.data.show&&function(t,r){var i=t.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=Ur(t.data.transition);if(!e(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ge,k=Ge.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(o($)?$.enter:$),M=!1!==s&&!W,F=ei(D),R=i._enterCb=I((function(){M&&(Gr(i,E),Gr(i,T)),R.cancelled?(M&&Gr(i,S),L&&L(i)):N&&N(i),i._enterCb=null}));t.data.show||oe(t,"insert",(function(){var e=i.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(i,R)})),j&&j(i),M&&(Xr(i,S),Xr(i,T),Kr((function(){Gr(i,S),R.cancelled||(Xr(i,E),F||(ti(P)?setTimeout(R,P):Zr(i,c,R)))}))),t.data.show&&(r&&r(),D&&D(i,R)),M||F||R()}}}(r)}var ri=function(t){var o,a,s={},c=t.modules,u=t.nodeOps;for(o=0;o<er.length;++o)for(s[er[o]]=[],a=0;a<c.length;++a)n(c[a][er[o]])&&s[er[o]].push(c[a][er[o]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,i,o,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,i,o){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return p(t,e),v(i,t.elm,o),r(c)&&function(t,e,r,i){var o,a=t;for(;a.componentInstance;)if(n(o=(a=a.componentInstance._vnode).data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](tr,a);e.push(a);break}v(r,t.elm,i)}(t,e,i,o),!0}}(t,e,i,o)){var f=t.data,d=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,d,e),n(f)&&y(t,e),v(i,t.elm,o)):r(t.isComment)?(t.elm=u.createComment(t.text),v(i,t.elm,o)):(t.elm=u.createTextNode(t.text),v(i,t.elm,o))}}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Yn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else i(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](tr,t);n(o=t.data.hook)&&(n(o.create)&&o.create(tr,t),n(o.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ge)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,i,o){for(;r<=i;++r)f(n[r],o,t,e,!1,n,r)}function b(t){var e,r,i=t.data;if(n(i))for(n(e=i.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var i=t[e];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(t,e){if(n(e)||n(t.data)){var r,i=s.remove.length+1;for(n(e)?e.listeners+=i:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,i),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function A(t,e,r,i){for(var o=r;o<i;o++){var a=e[o];if(n(a)&&nr(t,a))return o}}function $(t,i,o,a,c,l){if(t!==i){n(i.elm)&&n(a)&&(i=a[c]=vt(i));var d=i.elm=t.elm;if(r(t.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(t.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(t.isStatic)&&i.key===t.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=t.componentInstance;else{var p,v=i.data;n(v)&&n(p=v.hook)&&n(p=p.prepatch)&&p(t,i);var h=t.children,y=i.children;if(n(v)&&m(i)){for(p=0;p<s.update.length;++p)s.update[p](t,i);n(p=v.hook)&&n(p=p.update)&&p(t,i)}e(i.text)?n(h)&&n(y)?h!==y&&function(t,r,i,o,a){for(var s,c,l,d=0,p=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;d<=v&&p<=y;)e(h)?h=r[++d]:e(m)?m=r[--v]:nr(h,g)?($(h,g,o,i,p),h=r[++d],g=i[++p]):nr(m,b)?($(m,b,o,i,y),m=r[--v],b=i[--y]):nr(h,b)?($(h,b,o,i,y),w&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++d],b=i[--y]):nr(m,g)?($(m,g,o,i,p),w&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=i[++p]):(e(s)&&(s=rr(r,d,v)),e(c=n(g.key)?s[g.key]:A(g,r,d,v))?f(g,o,t,h.elm,!1,i,p):nr(l=r[c],g)?($(l,g,o,i,p),r[c]=void 0,w&&u.insertBefore(t,l.elm,h.elm)):f(g,o,t,h.elm,!1,i,p),g=i[++p]);d>v?_(t,e(i[y+1])?null:i[y+1].elm,i,p,y,o):p>y&&C(r,d,v)}(d,h,y,o,l):n(y)?(n(t.text)&&u.setTextContent(d,""),_(d,null,y,0,y.length-1,o)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(d,""):t.text!==i.text&&u.setTextContent(d,i.text),n(v)&&n(p=v.hook)&&n(p=p.postpatch)&&p(t,i)}}}function x(t,e,i){if(r(i)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var o=0;o<e.length;++o)e[o].data.hook.insert(e[o])}var k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,i,o){var a,s=e.tag,c=e.data,u=e.children;if(o=o||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return p(e,i),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,d=0;d<u.length;d++){if(!f||!O(f,u[d],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,i);if(n(c)){var v=!1;for(var m in c)if(!k(m)){v=!0,y(e,i);break}!v&&c.class&&te(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,i,o,a){if(!e(i)){var c,l=!1,d=[];if(e(t))l=!0,f(i,d);else{var p=n(t.nodeType);if(!p&&nr(t,i))$(t,i,d,null,null,a);else{if(p){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),o=!0),r(o)&&O(t,i,d))return x(i,d,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(i,d,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](tr,y);var A=y.data.hook.insert;if(A.merged)for(var k=1;k<A.fns.length;k++)A.fns[k]()}else Yn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(i,d,l),i.elm}n(t)&&b(t)}}({nodeOps:Jn,modules:[vr,yr,$r,Or,Fr,U?{create:ni,activate:ni,remove:function(t,r){!0!==t.data.show?function(t,r){var i=t.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=Ur(t.data.transition);if(e(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=ei(v),C=f(o(g)?g.leave:g),w=i._leaveCb=I((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[t.key]=null),_&&(Gr(i,l),Gr(i,d)),w.cancelled?(_&&Gr(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[t.key]=t),p&&p(i),_&&(Xr(i,u),Xr(i,d),Kr((function(){Gr(i,u),w.cancelled||(Xr(i,l),b||(ti(C)?setTimeout(w,C):Zr(i,c,w)))}))),v&&v(i,w),_||b||w())}}(t,r):r()}}:{}].concat(lr)});W&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&fi(t,"input")}));var ii={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?oe(n,"postpatch",(function(){ii.componentUpdated(t,e,n)})):oi(t,e,n.context),t._vOptions=[].map.call(t.options,ci)):("textarea"===n.tag||Zn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",ui),t.addEventListener("compositionend",li),t.addEventListener("change",li),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){oi(t,e,n.context);var r=t._vOptions,i=t._vOptions=[].map.call(t.options,ci);if(i.some((function(t,e){return!E(t,r[e])})))(t.multiple?e.value.some((function(t){return si(t,i)})):e.value!==e.oldValue&&si(e.value,i))&&fi(t,"change")}}};function oi(t,e,n){ai(t,e),(z||q)&&setTimeout((function(){ai(t,e)}),0)}function ai(t,e,n){var r=e.value,i=t.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],i)o=j(r,ci(a))>-1,a.selected!==o&&(a.selected=o);else if(E(ci(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));i||(t.selectedIndex=-1)}}function si(t,e){return e.every((function(e){return!E(e,t)}))}function ci(t){return"_value"in t?t._value:t.value}function ui(t){t.target.composing=!0}function li(t){t.target.composing&&(t.target.composing=!1,fi(t.target,"input"))}function fi(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}var di=/\s+/;function pi(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(di).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function vi(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(di).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function hi(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,mi(t.name||"v")),x(e,t),e}return"string"==typeof t?mi(t):void 0}}var mi=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),yi=U&&!W,gi="transition",_i="transitionend",bi="animation",Ci="animationend";yi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(gi="WebkitTransition",_i="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(bi="WebkitAnimation",Ci="webkitAnimationEnd"));var wi=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Ai(t){wi((function(){wi(t)}))}function $i(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pi(t,e))}function xi(t,e){t._transitionClasses&&v(t._transitionClasses,e),vi(t,e)}function ki(t,e,n){var r=Si(t,e),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s="transition"===i?_i:Ci,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),t.addEventListener(s,l)}var Oi=/\b(transform|all)(,|$)/;function Si(t,e){var n,r=window.getComputedStyle(t),i=(r[gi+"Delay"]||"").split(", "),o=(r[gi+"Duration"]||"").split(", "),a=Ti(i,o),s=(r[bi+"Delay"]||"").split(", "),c=(r[bi+"Duration"]||"").split(", "),u=Ti(s,c),l=0,f=0;return"transition"===e?a>0&&(n="transition",l=a,f=o.length):"animation"===e?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:"transition"===n&&Oi.test(r[gi+"Property"])}}function Ti(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return Ei(e)+Ei(t[n])})))}function Ei(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function ji(t,r){var i=t.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=hi(t.data.transition);if(!e(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,d=a.enterActiveClass,p=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,w=a.afterAppear,A=a.appearCancelled,$=a.duration,x=Ge,k=Ge.$vnode;k&&k.parent;)x=k.context,k=k.parent;var O=!x._isMounted||!t.isRootInsert;if(!O||C||""===C){var S=O&&p?p:u,T=O&&h?h:d,E=O&&v?v:l,j=O&&b||m,D=O&&"function"==typeof C?C:y,N=O&&w||g,L=O&&A||_,P=f(o($)?$.enter:$),M=!1!==s&&!W,F=Di(D),R=i._enterCb=I((function(){M&&(xi(i,E),xi(i,T)),R.cancelled?(M&&xi(i,S),L&&L(i)):N&&N(i),i._enterCb=null}));t.data.show||oe(t,"insert",(function(){var e=i.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(i,R)})),j&&j(i),M&&($i(i,S),$i(i,T),Ai((function(){xi(i,S),R.cancelled||($i(i,E),F||(Ii(P)?setTimeout(R,P):ki(i,c,R)))}))),t.data.show&&(r&&r(),D&&D(i,R)),M||F||R()}}}function Ii(t){return"number"==typeof t&&!isNaN(t)}function Di(t){if(e(t))return!1;var r=t.fns;return n(r)?Di(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function Ni(t){return!t.componentInstance||t.data&&t.data.transition?t:Ni(t.componentInstance._vnode)}var Li={model:ii,show:{bind:function(t,e,n){var r=e.value,i=(n=Ni(n)).data&&n.data.transition,o=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&i?(n.data.show=!0,ji(n,(function(){t.style.display=o}))):t.style.display=r?o:"none"},update:function(t,r,i){var a=r.value;!a!=!r.oldValue&&((i=Ni(i)).data&&i.data.transition?(i.data.show=!0,a?ji(i,(function(){t.style.display=t.__vOriginalDisplay})):function(t,r){var i=t.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=hi(t.data.transition);if(e(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,d=a.leaveActiveClass,p=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Di(v),C=f(o(g)?g.leave:g),w=i._leaveCb=I((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[t.key]=null),_&&(xi(i,l),xi(i,d)),w.cancelled?(_&&xi(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(A):A()}function A(){w.cancelled||(!t.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[t.key]=t),p&&p(i),_&&($i(i,u),$i(i,d),Ai((function(){xi(i,u),w.cancelled||($i(i,l),b||(Ii(C)?setTimeout(w,C):ki(i,c,w)))}))),v&&v(i,w),_||b||w())}}(i,(function(){t.style.display="none"}))):t.style.display=a?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,i){i||(t.style.display=t.__vOriginalDisplay)}}},Pi={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Mi(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Mi(ze(e.children)):t}function Fi(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var i=n._parentListeners;for(var o in i)e[_(o)]=i[o];return e}function Ri(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var Ui=function(t){return t.tag||Ve(t)},Bi=function(t){return"show"===t.name},Hi={name:"transition",props:Pi,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(Ui)).length){var r=this.mode,o=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;var a=Mi(o);if(!a)return o;if(this._leaving)return Ri(t,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Fi(this),u=this._vnode,l=Mi(u);if(a.data.directives&&a.data.directives.some(Bi)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ve(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,oe(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Ri(t,o);if("in-out"===r){if(Ve(a))return u;var d,p=function(){d()};oe(c,"afterEnter",p),oe(c,"enterCancelled",p),oe(f,"delayLeave",(function(t){d=t}))}}return o}}},Vi=x({tag:String,moveClass:String},Pi);function zi(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Wi(t){t.data.newPos=t.elm.getBoundingClientRect()}function qi(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,i=e.top-n.top;if(r||i){t.data.moved=!0;var o=t.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete Vi.mode;var Ki={Transition:Hi,TransitionGroup:{props:Vi,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var i=Ze(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,i(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=Fi(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var d=r[f];d.data.transition=a,d.data.pos=d.elm.getBoundingClientRect(),n[d.key]?u.push(d):l.push(d)}this.kept=t(e,null,u),this.removed=l}return t(e,null,o)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(zi),t.forEach(Wi),t.forEach(qi),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;$i(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(_i,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(_i,t),n._moveCb=null,xi(n,e))})}})))},methods:{hasMove:function(t,e){if(!yi)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){vi(n,t)})),pi(n,e),n.style.display="none",this.$el.appendChild(n);var r=Si(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};$n.config.mustUseProp=function(t,e,n){return"value"===n&&Dn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},$n.config.isReservedTag=Xn,$n.config.isReservedAttr=In,$n.config.getTagNamespace=function(t){return Kn(t)?"svg":"math"===t?"math":void 0},$n.config.isUnknownElement=function(t){if(!U)return!0;if(Xn(t))return!1;if(t=t.toLowerCase(),null!=Gn[t])return Gn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Gn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Gn[t]=/HTMLUnknownElement/.test(e.toString())},x($n.options.directives,Li),x($n.options.components,Ki),$n.prototype.__patch__=U?ri:O,$n.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),tn(t,"beforeMount"),r=function(){t._update(t._render(),n)},new pn(t,r,O,{before:function(){t._isMounted&&!t._isDestroyed&&tn(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,tn(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((function(){L.devtools&&tt&&tt.emit("init",$n)}),0),module.exports=$n;
\ No newline at end of file
+"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,$=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every((function(t,n){return j(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return j(t[n],e[n])}))}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D=["component","directive","filter"],N=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:N};function L(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var pt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=ht[t];M(mt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i}))}));var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?function(t,e){t.__proto__=e}(t,mt):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&xt(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function xt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&xt(e)}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var Ot=P.optionMergeStrategies;function kt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&kt(r,o):wt(t,n,o));return t}function St(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?kt(r,o):o}:e?t?function(){return kt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Et(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function jt(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}Ot.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},N.forEach((function(t){Ot[t]=Et})),D.forEach((function(t){Ot[t+"s"]=jt})),Ot.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},Ot.props=Ot.methods=Ot.inject=Ot.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},Ot.provide=St;var Tt=function(t,e){return void 0===e?t:e};function It(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=It(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=It(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=Ot[r]||Tt;a[r]=o(t[r],e[r],n,r)}return a}function Dt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Nt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Ft(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Ft(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Lt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Pt=/^\s*function (\w+)/;function Lt(t){var e=t&&t.toString().match(Pt);return e?e[1]:""}function Mt(t,e){return Lt(t)===Lt(e)}function Ft(t,e){if(!Array.isArray(e))return Mt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Mt(e[n],t))return n;return-1}function Rt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{ut()}}function Ut(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch((function(t){return Rt(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(t){Rt(t,r,o)}return i}function Bt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Vt,zt=!1,Wt=[],qt=!1;function Kt(){qt=!1;var t=Wt.slice(0);Wt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Xt=Promise.resolve();Vt=function(){Xt.then(Kt),K&&setTimeout(k)},zt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Kt)}:function(){setTimeout(Kt,0)};else{var Gt=1,Zt=new MutationObserver(Kt),Jt=document.createTextNode(String(Gt));Zt.observe(Jt,{characterData:!0}),Vt=function(){Gt=(Gt+1)%2,Jt.data=String(Gt)},zt=!0}function Qt(t,e){var n;if(Wt.push((function(){if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var Yt=new nt;function te(t){ee(t,Yt),Yt.clear()}function ee(t,e){var n,r,o=Array.isArray(t);if(!(!o&&!i(t)||Object.isFrozen(t)||t instanceof lt)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(o)for(n=t.length;n--;)ee(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ee(t[r[n]],e)}}var ne=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function re(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ut(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ut(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function oe(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=ne(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=re(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=ne(c)).name,n[c],f.capture)}function ie(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=re([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=re([s,c]),a.merged=!0,t[o]=a}function ae(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function se(t){return o(t)?[dt(t)]:Array.isArray(t)?ue(t):void 0}function ce(t){return n(t)&&n(t.text)&&!1===t.isComment}function ue(t,i){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ce((s=ue(s,(i||"")+"_"+a))[0])&&ce(u)&&(l[c]=dt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):o(s)?ce(u)?l[c]=dt(u.text+s):""!==s&&l.push(dt(s)):ce(s)&&ce(u)?l[c]=dt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(i)&&(s.key="__vlist"+i+"_"+a+"__"),l.push(s)));return l}function le(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function fe(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(pe)&&delete n[u];return n}function pe(t){return t.isComment&&!t.asyncFactory||" "===t.text}function de(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=ve(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=he(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function ve(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:se(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function he(t,e){return function(){return t[e]}}function me(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ye(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ge(t){return Dt(this.$options,"filters",t)||E}function _e(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function be(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?_e(o,r):i?_e(i,t):r?$(r)!==e:void 0}function Ce(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function $e(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||Ae(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function we(t,e,n){return Ae(t,"__once__"+e+(n?"_"+n:""),!0),t}function Ae(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&xe(t[r],e+"_"+r,n);else xe(t,e,n)}function xe(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Oe(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function ke(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?ke(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Se(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Ee(t,e){return"string"==typeof t?e+t:t}function je(t){t._o=we,t._n=f,t._s=l,t._l=me,t._t=ye,t._q=j,t._i=T,t._m=$e,t._f=ge,t._k=be,t._b=Ce,t._v=dt,t._e=pt,t._u=ke,t._g=Oe,t._d=Se,t._p=Ee}function Te(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=le(u.inject,i),this.slots=function(){return c.$slots||de(e.scopedSlots,c.$slots=fe(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return de(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=de(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Fe(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Fe(s,t,e,n,r,f)}}function Ie(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function De(t,e){for(var n in e)t[_(n)]=e[n]}je(Te.prototype);var Ne={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ne.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ge)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Nt(d,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Xe(e,r,h),u&&(e.$slots=fe(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,tn(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,nn.push(e)):Qe(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?Ye(e,!0):e.$destroy())}},Pe=Object.keys(Ne);function Le(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I((function(e){t.resolved=He(e,o),c?s.length=0:p(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,p(!0))})),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=He(m.error,o)),n(m.loading)&&(t.loadingComp=He(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},wn(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);ae(a,c,u,l,!0)||ae(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Nt(l,u,r||t);else n(o.attrs)&&De(c,o.attrs),n(o.props)&&De(c,o.props);var f=new Te(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Ie(p,o,f.parent,s);if(Array.isArray(p)){for(var d=se(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Ie(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Pe.length;n++){var r=Pe[n],o=e[r],i=Ne[r];o===i||o&&o._merged||(e[r]=o?Me(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function Me(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Fe(t,e,a,s,c,u){return(Array.isArray(a)||o(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,o,a){if(n(r)&&n(r.__ob__))return pt();n(r)&&n(r.is)&&(e=r.is);if(!e)return pt();Array.isArray(o)&&"function"==typeof o[0]&&((r=r||{}).scopedSlots={default:o[0]},o.length=0);2===a?o=se(o):1===a&&(o=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(o));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||P.getTagNamespace(e),s=P.isReservedTag(e)?new lt(P.parsePlatformTagName(e),r,o,void 0,void 0,t):r&&r.pre||!n(u=Dt(t.$options,"components",e))?new lt(e,r,o,void 0,void 0,t):Le(u,r,t,o,e)}else s=Le(e,r,t,o);return Array.isArray(s)?s:n(s)?(n(c)&&Re(s,c),n(r)&&function(t){i(t.style)&&te(t.style);i(t.class)&&te(t.class)}(r),s):pt()}(t,e,a,s,c)}function Re(t,o,i){if(t.ns=o,"foreignObject"===t.tag&&(o=void 0,i=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(i)&&"svg"!==c.tag)&&Re(c,o,i)}}var Ue,Be=null;function He(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ve(t){return t.isComment&&t.asyncFactory}function ze(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ve(r)))return r}}function We(t,e){Ue.$on(t,e)}function qe(t,e){Ue.$off(t,e)}function Ke(t,e){var n=Ue;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function Xe(t,e,n){Ue=t,oe(e,n||{},We,qe,Ke,t),Ue=void 0}var Ge=null;function Ze(t){var e=Ge;return Ge=t,function(){Ge=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Qe(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Qe(t.$children[n]);tn(t,"activated")}}function Ye(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);tn(t,"deactivated")}}function tn(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ut(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var en=[],nn=[],rn={},on=!1,an=!1,sn=0;var cn=0,un=Date.now;if(U&&!z){var ln=window.performance;ln&&"function"==typeof ln.now&&un()>document.createEvent("Event").timeStamp&&(un=function(){return ln.now()})}function fn(){var t,e;for(cn=un(),an=!0,en.sort((function(t,e){return t.id-e.id})),sn=0;sn<en.length;sn++)(t=en[sn]).before&&t.before(),e=t.id,rn[e]=null,t.run();var n=nn.slice(),r=en.slice();sn=en.length=nn.length=0,rn={},on=an=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Qe(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&tn(r,"updated")}}(r),tt&&P.devtools&&tt.emit("flush")}var pn=0,dn=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++pn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};dn.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&te(t),ut(),this.cleanupDeps()}return t},dn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},dn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},dn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==rn[e]){if(rn[e]=!0,an){for(var n=en.length-1;n>sn&&en[n].id>t.id;)n--;en.splice(n+1,0,t)}else en.push(t);on||(on=!0,Qt(fn))}}(this)},dn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},dn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},dn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},dn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var vn={enumerable:!0,configurable:!0,get:k,set:k};function hn(t,e,n){vn.get=function(){return this[e][n]},vn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,vn)}function mn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Nt(i,e,n,t);$t(r,i,a),i in t||hn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||L(i)||hn(t,"_data",i)}Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new dn(t,a||k,k,yn)),o in t||gn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)Cn(t,n,r[o]);else Cn(t,n,r)}}(t,e.watch)}var yn={lazy:!0};function gn(t,e,n){var r=!Y();"function"==typeof n?(vn.get=r?_n(e):bn(n),vn.set=k):(vn.get=n.get?r&&!1!==n.cache?_n(e):bn(n.get):k,vn.set=n.set||k),Object.defineProperty(t,e,vn)}function _n(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function bn(t){return function(){return t.call(this,this)}}function Cn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var $n=0;function wn(t){var e=t.options;if(t.super){var n=wn(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=It(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function An(t){this._init(t)}function xn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=It(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)hn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)gn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,D.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function On(t){return t&&(t.Ctor.options.name||t.tag)}function kn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function Sn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=On(a.componentOptions);s&&!e(s)&&En(n,i,r,o)}}}function En(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=$n++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=It(wn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Xe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=fe(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Fe(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Fe(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),tn(n,"beforeCreate"),function(t){var e=le(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach((function(n){$t(t,n,e[n])})),_t(!0))}(n),mn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),tn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(An),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return Cn(r,t,e,n);(n=n||{}).user=!0;var o=new dn(r,t,e,n);if(n.immediate){ct();try{e.call(r,o.value)}catch(t){Rt(t,r,'callback for immediate watcher "'+o.expression+'"')}ut()}return function(){o.teardown()}}}(An),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),o='event handler for "'+t+'"',i=0,a=n.length;i<a;i++)Ut(n[i],e,r,e,o)}return e}}(An),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ze(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){tn(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),tn(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(An),function(t){je(t.prototype),t.prototype.$nextTick=function(t){return Qt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=de(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Rt(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=pt()),t.parent=o,t}}(An);var jn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)En(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){Sn(t,(function(t){return kn(e,t)}))})),this.$watch("exclude",(function(e){Sn(t,(function(t){return!kn(e,t)}))}))},render:function(){var t=this.$slots.default,e=ze(t),n=e&&e.componentOptions;if(n){var r=On(n),o=this.include,i=this.exclude;if(o&&(!r||!kn(o,r))||i&&r&&kn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&En(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:It,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Qt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),D.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,Tn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=It(this.options,t),this}}(t),xn(t),function(t){D.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(An),Object.defineProperty(An.prototype,"$isServer",{get:Y}),Object.defineProperty(An.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(An,"FunctionalRenderContext",{value:Te}),An.version="2.6.12";var In=p("style,class"),Dn=p("input,textarea,option,select,progress"),Nn=p("contenteditable,draggable,spellcheck"),Pn=p("events,caret,typing,plaintext-only"),Ln=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Mn="http://www.w3.org/1999/xlink",Fn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Rn=function(t){return Fn(t)?t.slice(6,t.length):""},Un=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Hn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return Vn(t,zn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:Vn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Vn(t,e){return t?e?t+" "+e:t:e||""}function zn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=zn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},qn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Kn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(t){return qn(t)||Kn(t)};var Gn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Jn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Wn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Qn={create:function(t,e){Yn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Yn(t,!0),Yn(e))},destroy:function(t){Yn(t,!0)}};function Yn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var tr=new lt("",{},[]),er=["create","activate","update","remove","destroy"];function nr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Zn(o)&&Zn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function rr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var or={create:ir,update:ir,destroy:function(t){ir(t,tr)}};function ir(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===tr,a=e===tr,s=sr(t.data.directives,t.context),c=sr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ur(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ur(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ur(u[n],"inserted",e,t)};i?ie(e,"insert",f):f()}l.length&&ie(e,"postpatch",(function(){for(var n=0;n<l.length;n++)ur(l[n],"componentUpdated",e,t)}));if(!i)for(n in s)c[n]||ur(s[n],"unbind",t,t,a)}(t,e)}var ar=Object.create(null);function sr(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=ar),o[cr(r)]=r,r.def=Dt(e.$options,"directives",r.name);return o}function cr(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ur(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Rt(r,n.context,"directive "+t.name+" "+e+" hook")}}var lr=[Qn,or];function fr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&pr(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&pr(s,"value",u.value),c)e(u[i])&&(Fn(i)?s.removeAttributeNS(Mn,Rn(i)):Nn(i)||s.removeAttribute(i))}}function pr(t,e,n,r){r||t.tagName.indexOf("-")>-1?dr(t,e,n):Ln(e)?Un(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,function(t,e){return Un(e)||"false"===e?"false":"contenteditable"===t&&Pn(e)?e:"true"}(e,n)):Fn(e)?Un(n)?t.removeAttributeNS(Mn,Rn(e)):t.setAttributeNS(Mn,e,n):dr(t,e,n)}function dr(t,e,n){if(Un(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var vr={create:fr,update:fr};function hr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=o._transitionClasses;n(c)&&(s=Vn(s,zn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var mr,yr={create:hr,update:hr};function gr(t,e,n){var r=mr;return function o(){var i=e.apply(null,arguments);null!==i&&Cr(t,o,n,r)}}var _r=zt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var o=cn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}mr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||mr).removeEventListener(t,e._wrapper||e,n)}function $r(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};mr=r.elm,function(t){if(n(t.__r)){var e=z?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(o),oe(o,i,br,Cr,gr,r.context),mr=void 0}}var wr,Ar={create:$r,update:$r};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Kn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:xr,update:xr},Sr=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?O(t):"string"==typeof t?Sr(t):t}var Tr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty($(e),n.replace(Dr,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Lr=y((function(t){if(Tr=Tr||document.createElement("div").style,"filter"!==(t=_(t))&&t in Tr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Tr)return r}}));function Mr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=jr(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Nr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Br(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Hr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Vr(t.name||"v")),x(e,t),e}return"string"==typeof t?Vr(t):void 0}}var Vr=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),zr=U&&!W,Wr="transition",qr="transitionend",Kr="animation",Xr="animationend";zr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Wr="WebkitTransition",qr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Kr="WebkitAnimation",Xr="webkitAnimationEnd"));var Gr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Zr(t){Gr((function(){Gr(t)}))}function Jr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Ur(t,e))}function Qr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Br(t,e)}function Yr(t,e,n){var r=eo(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s="transition"===o?qr:Xr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var to=/\b(transform|all)(,|$)/;function eo(t,e){var n,r=window.getComputedStyle(t),o=(r[Wr+"Delay"]||"").split(", "),i=(r[Wr+"Duration"]||"").split(", "),a=no(o,i),s=(r[Kr+"Delay"]||"").split(", "),c=(r[Kr+"Duration"]||"").split(", "),u=no(s,c),l=0,f=0;return"transition"===e?a>0&&(n="transition",l=a,f=i.length):"animation"===e?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:"transition"===n&&to.test(r[Wr+"Property"])}}function no(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return ro(e)+ro(t[n])})))}function ro(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function oo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Hr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ge,O=Ge.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!W,F=so(D),R=o._enterCb=I((function(){M&&(Qr(o,j),Qr(o,E)),R.cancelled?(M&&Qr(o,S),P&&P(o)):N&&N(o),o._enterCb=null}));t.data.show||ie(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),T&&T(o),M&&(Jr(o,S),Jr(o,E),Zr((function(){Qr(o,S),R.cancelled||(Jr(o,j),F||(ao(L)?setTimeout(R,L):Yr(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function io(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Hr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=so(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Qr(o,l),Qr(o,p)),$.cancelled?(_&&Qr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Jr(o,u),Jr(o,p),Zr((function(){Qr(o,u),$.cancelled||(Jr(o,l),b||(ao(C)?setTimeout($,C):Yr(o,c,$)))}))),v&&v(o,$),_||b||$())}}function ao(t){return"number"==typeof t&&!isNaN(t)}function so(t){if(e(t))return!1;var r=t.fns;return n(r)?so(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function co(t,e){!0!==e.data.show&&oo(e)}var uo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<er.length;++i)for(s[er[i]]=[],a=0;a<c.length;++a)n(c[a][er[i]])&&s[er[i]].push(c[a][er[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){var i,a=t;for(;a.componentInstance;)if(n(i=(a=a.componentInstance._vnode).data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](tr,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Yn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](tr,t);n(i=t.data.hook)&&(n(i.create)&&i.create(tr,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ge)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&nr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:nr(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):nr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):nr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):nr(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=rr(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):nr(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&te(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&nr(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](tr,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Yn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Jn,modules:[vr,yr,Ar,kr,Fr,U?{create:co,activate:co,remove:function(t,e){!0!==t.data.show?io(t,e):e()}}:{}].concat(lr)});W&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&go(t,"input")}));var lo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ie(n,"postpatch",(function(){lo.componentUpdated(t,e,n)})):fo(t,e,n.context),t._vOptions=[].map.call(t.options,ho)):("textarea"===n.tag||Zn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",mo),t.addEventListener("compositionend",yo),t.addEventListener("change",yo),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){fo(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,ho);if(o.some((function(t,e){return!j(t,r[e])})))(t.multiple?e.value.some((function(t){return vo(t,o)})):e.value!==e.oldValue&&vo(e.value,o))&&go(t,"change")}}};function fo(t,e,n){po(t,e),(z||q)&&setTimeout((function(){po(t,e)}),0)}function po(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,ho(a))>-1,a.selected!==i&&(a.selected=i);else if(j(ho(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function vo(t,e){return e.every((function(e){return!j(e,t)}))}function ho(t){return"_value"in t?t._value:t.value}function mo(t){t.target.composing=!0}function yo(t){t.target.composing&&(t.target.composing=!1,go(t.target,"input"))}function go(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function _o(t){return!t.componentInstance||t.data&&t.data.transition?t:_o(t.componentInstance._vnode)}var bo={model:lo,show:{bind:function(t,e,n){var r=e.value,o=(n=_o(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,oo(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=_o(n)).data&&n.data.transition?(n.data.show=!0,r?oo(n,(function(){t.style.display=t.__vOriginalDisplay})):io(n,(function(){t.style.display="none"}))):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Co={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function $o(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?$o(ze(e.children)):t}function wo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Ao(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var xo=function(t){return t.tag||Ve(t)},Oo=function(t){return"show"===t.name},ko={name:"transition",props:Co,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(xo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=$o(i);if(!a)return i;if(this._leaving)return Ao(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=wo(this),u=this._vnode,l=$o(u);if(a.data.directives&&a.data.directives.some(Oo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ve(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ie(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Ao(t,i);if("in-out"===r){if(Ve(a))return u;var p,d=function(){p()};ie(c,"afterEnter",d),ie(c,"enterCancelled",d),ie(f,"delayLeave",(function(t){p=t}))}}return i}}},So=x({tag:String,moveClass:String},Co);function Eo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function jo(t){t.data.newPos=t.elm.getBoundingClientRect()}function To(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete So.mode;var Io={Transition:ko,TransitionGroup:{props:So,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ze(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=wo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Eo),t.forEach(jo),t.forEach(To),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;Jr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(qr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(qr,t),n._moveCb=null,Qr(n,e))})}})))},methods:{hasMove:function(t,e){if(!zr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){Br(n,t)})),Ur(n,e),n.style.display="none",this.$el.appendChild(n);var r=eo(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};An.config.mustUseProp=function(t,e,n){return"value"===n&&Dn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},An.config.isReservedTag=Xn,An.config.isReservedAttr=In,An.config.getTagNamespace=function(t){return Kn(t)?"svg":"math"===t?"math":void 0},An.config.isUnknownElement=function(t){if(!U)return!0;if(Xn(t))return!1;if(t=t.toLowerCase(),null!=Gn[t])return Gn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Gn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Gn[t]=/HTMLUnknownElement/.test(e.toString())},x(An.options.directives,bo),x(An.options.components,Io),An.prototype.__patch__=U?uo:k,An.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),tn(t,"beforeMount"),r=function(){t._update(t._render(),n)},new dn(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&tn(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,tn(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((function(){P.devtools&&tt&&tt.emit("init",An)}),0),module.exports=An;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index 28d97681d14..c902a0e4e80 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -6368,12 +6368,12 @@ var style = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+var whitespaceRE = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function addClass$1(el, cls) {
+function addClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6381,7 +6381,7 @@ function addClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
         }
         else {
             el.classList.add(cls);
@@ -6398,7 +6398,7 @@ function addClass$1(el, cls) {
  * Remove class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
  */
-function removeClass$1(el, cls) {
+function removeClass(el, cls) {
     /* istanbul ignore if */
     if (!cls || !(cls = cls.trim())) {
         return;
@@ -6406,7 +6406,7 @@ function removeClass$1(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
         }
         else {
             el.classList.remove(cls);
@@ -6431,7 +6431,7 @@ function removeClass$1(el, cls) {
     }
 }
 
-function resolveTransition$1(def) {
+function resolveTransition(def) {
     if (!def) {
         return;
     }
@@ -6439,16 +6439,16 @@ function resolveTransition$1(def) {
     if (typeof def === 'object') {
         var res = {};
         if (def.css !== false) {
-            extend(res, autoCssTransition$1(def.name || 'v'));
+            extend(res, autoCssTransition(def.name || 'v'));
         }
         extend(res, def);
         return res;
     }
     else if (typeof def === 'string') {
-        return autoCssTransition$1(def);
+        return autoCssTransition(def);
     }
 }
-var autoCssTransition$1 = cached(function (name) {
+var autoCssTransition = cached(function (name) {
     return {
         enterClass: (name + "-enter"),
         enterToClass: (name + "-enter-to"),
@@ -6458,62 +6458,62 @@ var autoCssTransition$1 = cached(function (name) {
         leaveActiveClass: (name + "-leave-active"),
     };
 });
-var hasTransition$1 = inBrowser && !isIE9;
-var TRANSITION$1 = 'transition';
-var ANIMATION$1 = 'animation';
+var hasTransition = inBrowser && !isIE9;
+var TRANSITION = 'transition';
+var ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp$1 = 'transition';
-var transitionEndEvent$1 = 'transitionend';
-var animationProp$1 = 'animation';
-var animationEndEvent$1 = 'animationend';
-if (hasTransition$1) {
+var transitionProp = 'transition';
+var transitionEndEvent = 'transitionend';
+var animationProp = 'animation';
+var animationEndEvent = 'animationend';
+if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
         // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
-        transitionProp$1 = 'WebkitTransition';
-        transitionEndEvent$1 = 'webkitTransitionEnd';
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
         // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
-        animationProp$1 = 'WebkitAnimation';
-        animationEndEvent$1 = 'webkitAnimationEnd';
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf$1 = inBrowser
+var raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
     : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame$1(fn) {
-    raf$1(function () {
+function nextFrame(fn) {
+    raf(function () {
         // @ts-expect-error
-        raf$1(fn);
+        raf(fn);
     });
 }
-function addTransitionClass$1(el, cls) {
+function addTransitionClass(el, cls) {
     var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
-        addClass$1(el, cls);
+        addClass(el, cls);
     }
 }
-function removeTransitionClass$1(el, cls) {
+function removeTransitionClass(el, cls) {
     if (el._transitionClasses) {
         remove$2(el._transitionClasses, cls);
     }
-    removeClass$1(el, cls);
+    removeClass(el, cls);
 }
-function whenTransitionEnds$1(el, expectedType, cb) {
-    var ref = getTransitionInfo$1(el, expectedType);
+function whenTransitionEnds(el, expectedType, cb) {
+    var ref = getTransitionInfo(el, expectedType);
     var type = ref.type;
     var timeout = ref.timeout;
     var propCount = ref.propCount;
     if (!type)
         { return cb(); }
-    var event = type === TRANSITION$1 ? transitionEndEvent$1 : animationEndEvent$1;
+    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
     var ended = 0;
     var end = function () {
         el.removeEventListener(event, onEnd);
@@ -6533,30 +6533,30 @@ function whenTransitionEnds$1(el, expectedType, cb) {
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE$1 = /\b(transform|all)(,|$)/;
-function getTransitionInfo$1(el, expectedType) {
+var transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
     var styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp$1 + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp$1 + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout$1(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp$1 + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp$1 + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout$1(animationDelays, animationDurations);
+    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    var animationTimeout = getTimeout(animationDelays, animationDurations);
     var type;
     var timeout = 0;
     var propCount = 0;
     /* istanbul ignore if */
-    if (expectedType === TRANSITION$1) {
+    if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
-            type = TRANSITION$1;
+            type = TRANSITION;
             timeout = transitionTimeout;
             propCount = transitionDurations.length;
         }
     }
-    else if (expectedType === ANIMATION$1) {
+    else if (expectedType === ANIMATION) {
         if (animationTimeout > 0) {
-            type = ANIMATION$1;
+            type = ANIMATION;
             timeout = animationTimeout;
             propCount = animationDurations.length;
         }
@@ -6566,16 +6566,16 @@ function getTransitionInfo$1(el, expectedType) {
         type =
             timeout > 0
                 ? transitionTimeout > animationTimeout
-                    ? TRANSITION$1
-                    : ANIMATION$1
+                    ? TRANSITION
+                    : ANIMATION
                 : null;
         propCount = type
-            ? type === TRANSITION$1
+            ? type === TRANSITION
                 ? transitionDurations.length
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION$1 && transformRE$1.test(styles[transitionProp$1 + 'Property']);
+    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
         type: type,
         timeout: timeout,
@@ -6583,31 +6583,31 @@ function getTransitionInfo$1(el, expectedType) {
         hasTransform: hasTransform,
     };
 }
-function getTimeout$1(delays, durations) {
+function getTimeout(delays, durations) {
     /* istanbul ignore next */
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
     return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs$1(d) + toMs$1(delays[i]);
+        return toMs(d) + toMs(delays[i]);
     }));
 }
 // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
 // in a locale-dependent way, using a comma instead of a dot.
 // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
 // as a floor function) causing unexpected behaviors
-function toMs$1(s) {
+function toMs(s) {
     return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter$1(vnode, toggleDisplay) {
+function enter(vnode, toggleDisplay) {
     var el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -6661,19 +6661,19 @@ function enter$1(vnode, toggleDisplay) {
         : enterCancelled;
     var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration$1(explicitEnterDuration, 'enter', vnode);
+        checkDuration(explicitEnterDuration, 'enter', vnode);
     }
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(enterHook);
+    var userWantsControl = getHookArgumentsLength(enterHook);
     var cb = (el._enterCb = once(function () {
         if (expectsCSS) {
-            removeTransitionClass$1(el, toClass);
-            removeTransitionClass$1(el, activeClass);
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, startClass);
+                removeTransitionClass(el, startClass);
             }
             enterCancelledHook && enterCancelledHook(el);
         }
@@ -6698,19 +6698,19 @@ function enter$1(vnode, toggleDisplay) {
     // start enter transition
     beforeEnterHook && beforeEnterHook(el);
     if (expectsCSS) {
-        addTransitionClass$1(el, startClass);
-        addTransitionClass$1(el, activeClass);
-        nextFrame$1(function () {
-            removeTransitionClass$1(el, startClass);
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(function () {
+            removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
-                addTransitionClass$1(el, toClass);
+                addTransitionClass(el, toClass);
                 if (!userWantsControl) {
-                    if (isValidDuration$1(explicitEnterDuration)) {
+                    if (isValidDuration(explicitEnterDuration)) {
                         setTimeout(cb, explicitEnterDuration);
                     }
                     else {
-                        whenTransitionEnds$1(el, type, cb);
+                        whenTransitionEnds(el, type, cb);
                     }
                 }
             }
@@ -6724,14 +6724,14 @@ function enter$1(vnode, toggleDisplay) {
         cb();
     }
 }
-function leave$1(vnode, rm) {
+function leave(vnode, rm) {
     var el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition$1(vnode.data.transition);
+    var data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -6751,23 +6751,23 @@ function leave$1(vnode, rm) {
     var delayLeave = data.delayLeave;
     var duration = data.duration;
     var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength$1(leave);
+    var userWantsControl = getHookArgumentsLength(leave);
     var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration$1(explicitLeaveDuration, 'leave', vnode);
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
     var cb = (el._leaveCb = once(function () {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
         if (expectsCSS) {
-            removeTransitionClass$1(el, leaveToClass);
-            removeTransitionClass$1(el, leaveActiveClass);
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
         }
         // @ts-expect-error
         if (cb.cancelled) {
             if (expectsCSS) {
-                removeTransitionClass$1(el, leaveClass);
+                removeTransitionClass(el, leaveClass);
             }
             leaveCancelled && leaveCancelled(el);
         }
@@ -6795,19 +6795,19 @@ function leave$1(vnode, rm) {
         }
         beforeLeave && beforeLeave(el);
         if (expectsCSS) {
-            addTransitionClass$1(el, leaveClass);
-            addTransitionClass$1(el, leaveActiveClass);
-            nextFrame$1(function () {
-                removeTransitionClass$1(el, leaveClass);
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(function () {
+                removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
-                    addTransitionClass$1(el, leaveToClass);
+                    addTransitionClass(el, leaveToClass);
                     if (!userWantsControl) {
-                        if (isValidDuration$1(explicitLeaveDuration)) {
+                        if (isValidDuration(explicitLeaveDuration)) {
                             setTimeout(cb, explicitLeaveDuration);
                         }
                         else {
-                            whenTransitionEnds$1(el, type, cb);
+                            whenTransitionEnds(el, type, cb);
                         }
                     }
                 }
@@ -6820,7 +6820,7 @@ function leave$1(vnode, rm) {
     }
 }
 // only used in dev mode
-function checkDuration$1(val, name, vnode) {
+function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
         warn("<transition> explicit " + name + " duration is not a valid number - " +
             "got " + (JSON.stringify(val)) + ".", vnode.context);
@@ -6830,7 +6830,7 @@ function checkDuration$1(val, name, vnode) {
             'the duration expression might be incorrect.', vnode.context);
     }
 }
-function isValidDuration$1(val) {
+function isValidDuration(val) {
     return typeof val === 'number' && !isNaN(val);
 }
 /**
@@ -6839,7 +6839,7 @@ function isValidDuration$1(val) {
  * - a wrapped component method (check ._length)
  * - a plain function (.length)
  */
-function getHookArgumentsLength$1(fn) {
+function getHookArgumentsLength(fn) {
     if (isUndef(fn)) {
         return false;
     }
@@ -6847,7 +6847,7 @@ function getHookArgumentsLength$1(fn) {
     var invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
-        return getHookArgumentsLength$1(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
     }
     else {
         // @ts-expect-error
@@ -6856,7 +6856,7 @@ function getHookArgumentsLength$1(fn) {
 }
 function _enter(_, vnode) {
     if (vnode.data.show !== true) {
-        enter$1(vnode);
+        enter(vnode);
     }
 }
 var transition = inBrowser
@@ -6867,7 +6867,7 @@ var transition = inBrowser
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
-                leave$1(vnode, rm);
+                leave(vnode, rm);
             }
             else {
                 rm();
@@ -7016,493 +7016,6 @@ function trigger(el, type) {
     el.dispatchEvent(e);
 }
 
-var whitespaceRE = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        var res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-var autoCssTransition = cached(function (name) {
-    return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
-    };
-});
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
-// Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        // @ts-expect-error
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        // @ts-expect-error
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-function nextFrame(fn) {
-    raf(function () {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    var onEnd = function (e) {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(function () {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-var transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(function () {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    var el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    var cb = (el._leaveCb = once(function () {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn("<transition> explicit " + name + " duration is NaN - " +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode) {
     // @ts-expect-error
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index f48a177d210..54df3a4afd2 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -4,42 +4,35 @@
  * Released under the MIT License.
  */
 (function (global, factory) {
-  typeof exports === "object" && typeof module !== "undefined"
-    ? (module.exports = factory())
-    : typeof define === "function" && define.amd
-    ? define(factory)
-    : ((global =
-        typeof globalThis !== "undefined" ? globalThis : global || self),
-      (global.Vue = factory()));
-})(this, function () {
-  "use strict";
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
+}(this, (function () { 'use strict';
 
   var emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
   function isUndef(v) {
-    return v === undefined || v === null;
+      return v === undefined || v === null;
   }
   function isDef(v) {
-    return v !== undefined && v !== null;
+      return v !== undefined && v !== null;
   }
   function isTrue(v) {
-    return v === true;
+      return v === true;
   }
   function isFalse(v) {
-    return v === false;
+      return v === false;
   }
   /**
    * Check if value is primitive.
    */
   function isPrimitive(value) {
-    return (
-      typeof value === "string" ||
-      typeof value === "number" ||
-      // $flow-disable-line
-      typeof value === "symbol" ||
-      typeof value === "boolean"
-    );
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
   }
   /**
    * Quick object check - this is primarily used to tell
@@ -47,132 +40,122 @@
    * is a JSON-compliant type.
    */
   function isObject(obj) {
-    return obj !== null && typeof obj === "object";
+      return obj !== null && typeof obj === 'object';
   }
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
   var _toString = Object.prototype.toString;
   function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
+      return _toString.call(value).slice(8, -1);
   }
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
   function isPlainObject(obj) {
-    return _toString.call(obj) === "[object Object]";
+      return _toString.call(obj) === '[object Object]';
   }
   function isRegExp(v) {
-    return _toString.call(v) === "[object RegExp]";
+      return _toString.call(v) === '[object RegExp]';
   }
   /**
    * Check if val is a valid array index.
    */
   function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
+      var n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
   function isPromise(val) {
-    return (
-      isDef(val) &&
-      typeof val.then === "function" &&
-      typeof val.catch === "function"
-    );
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
   }
   /**
    * Convert a value to a string that is actually rendered.
    */
   function toString(val) {
-    return val == null
-      ? ""
-      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val);
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
   }
   /**
    * Convert an input value to a number for persistence.
    * If the conversion fails, return original string.
    */
   function toNumber(val) {
-    var n = parseFloat(val);
-    return isNaN(n) ? val : n;
+      var n = parseFloat(val);
+      return isNaN(n) ? val : n;
   }
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
   function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(",");
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) {
-          return map[val.toLowerCase()];
-        }
-      : function (val) {
-          return map[val];
-        };
+      var map = Object.create(null);
+      var list = str.split(',');
+      for (var i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
   }
   /**
    * Check if a tag is a built-in tag.
    */
-  var isBuiltInTag = makeMap("slot,component", true);
+  var isBuiltInTag = makeMap('slot,component', true);
   /**
    * Check if an attribute is a reserved attribute.
    */
-  var isReservedAttribute = makeMap("key,ref,slot,slot-scope,is");
+  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
   /**
    * Remove an item from an array.
    */
   function remove$2(arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1);
+      if (arr.length) {
+          var index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
       }
-    }
   }
   /**
    * Check whether an object has the property.
    */
   var hasOwnProperty = Object.prototype.hasOwnProperty;
   function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
+      return hasOwnProperty.call(obj, key);
   }
   /**
    * Create a cached version of a pure function.
    */
   function cached(fn) {
-    var cache = Object.create(null);
-    return function cachedFn(str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str));
-    };
+      var cache = Object.create(null);
+      return function cachedFn(str) {
+          var hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
   }
   /**
    * Camelize a hyphen-delimited string.
    */
   var camelizeRE = /-(\w)/g;
   var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) {
-      return c ? c.toUpperCase() : "";
-    });
+      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
   });
   /**
    * Capitalize a string.
    */
   var capitalize = cached(function (str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
+      return str.charAt(0).toUpperCase() + str.slice(1);
   });
   /**
    * Hyphenate a camelCase string.
    */
   var hyphenateRE = /\B([A-Z])/g;
   var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, "-$1").toLowerCase();
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
   /**
    * Simple bind polyfill for environments that do not support it,
@@ -183,19 +166,19 @@
    */
   /* istanbul ignore next */
   function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
+      function boundFn(a) {
+          var l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
   }
   function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
+      return fn.bind(ctx);
   }
   // @ts-expect-error bind cannot be `undefined`
   var bind = Function.prototype.bind ? nativeBind : polyfillBind;
@@ -203,34 +186,34 @@
    * Convert an Array-like object to a real Array.
    */
   function toArray(list, start) {
-    start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
-    while (i--) {
-      ret[i] = list[i + start];
-    }
-    return ret;
+      start = start || 0;
+      var i = list.length - start;
+      var ret = new Array(i);
+      while (i--) {
+          ret[i] = list[i + start];
+      }
+      return ret;
   }
   /**
    * Mix properties into target object.
    */
   function extend(to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to;
+      for (var key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
   }
   /**
    * Merge an Array of Objects into a single Object.
    */
   function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-      if (arr[i]) {
-        extend(res, arr[i]);
+      var res = {};
+      for (var i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
       }
-    }
-    return res;
+      return res;
   }
   /* eslint-disable no-unused-vars */
   /**
@@ -238,65 +221,62 @@
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop(a, b, c) {}
+  function noop(a, b, c) { }
   /**
    * Always return false.
    */
-  var no = function (a, b, c) {
-    return false;
-  };
+  var no = function (a, b, c) { return false; };
   /* eslint-enable no-unused-vars */
   /**
    * Return the same value.
    */
-  var identity = function (_) {
-    return _;
-  };
+  var identity = function (_) { return _; };
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
   function looseEqual(a, b) {
-    if (a === b) {
-      return true;
-    }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-      try {
-        var isArrayA = Array.isArray(a);
-        var isArrayB = Array.isArray(b);
-        if (isArrayA && isArrayB) {
-          return (
-            a.length === b.length &&
-            a.every(function (e, i) {
-              return looseEqual(e, b[i]);
-            })
-          );
-        } else if (a instanceof Date && b instanceof Date) {
-          return a.getTime() === b.getTime();
-        } else if (!isArrayA && !isArrayB) {
-          var keysA = Object.keys(a);
-          var keysB = Object.keys(b);
-          return (
-            keysA.length === keysB.length &&
-            keysA.every(function (key) {
-              return looseEqual(a[key], b[key]);
-            })
-          );
-        } else {
-          /* istanbul ignore next */
+      if (a === b)
+          { return true; }
+      var isObjectA = isObject(a);
+      var isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              var isArrayA = Array.isArray(a);
+              var isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every(function (e, i) {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  var keysA = Object.keys(a);
+                  var keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every(function (key) {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
           return false;
-        }
-      } catch (e) {
-        /* istanbul ignore next */
-        return false;
-      }
-    } else if (!isObjectA && !isObjectB) {
-      return String(a) === String(b);
-    } else {
-      return false;
-    }
+      }
   }
   /**
    * Return the first index at which a loosely equal value can be
@@ -304,119 +284,117 @@
    * contain an object of the same shape), or -1 if it is not present.
    */
   function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
-      if (looseEqual(arr[i], val)) {
-        return i;
+      for (var i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              { return i; }
       }
-    }
-    return -1;
+      return -1;
   }
   /**
    * Ensure a function is called only once.
    */
   function once(fn) {
-    var called = false;
-    return function () {
-      if (!called) {
-        called = true;
-        fn.apply(this, arguments);
-      }
-    };
+      var called = false;
+      return function () {
+          if (!called) {
+              called = true;
+              fn.apply(this, arguments);
+          }
+      };
   }
 
-  var SSR_ATTR = "data-server-rendered";
-  var ASSET_TYPES = ["component", "directive", "filter"];
+  var SSR_ATTR = 'data-server-rendered';
+  var ASSET_TYPES = ['component', 'directive', 'filter'];
   var LIFECYCLE_HOOKS = [
-    "beforeCreate",
-    "created",
-    "beforeMount",
-    "mounted",
-    "beforeUpdate",
-    "updated",
-    "beforeDestroy",
-    "destroyed",
-    "activated",
-    "deactivated",
-    "errorCaptured",
-    "serverPrefetch",
-  ];
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch' ];
 
   var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== "production",
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== "production",
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
   /**
@@ -429,56 +407,55 @@
    * Check if a string starts with $ or _
    */
   function isReserved(str) {
-    var c = (str + "").charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
+      var c = (str + '').charCodeAt(0);
+      return c === 0x24 || c === 0x5f;
   }
   /**
    * Define a property.
    */
   function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true,
-    });
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
   }
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
+  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
   function parsePath(path) {
-    if (bailRE.test(path)) {
-      return;
-    }
-    var segments = path.split(".");
-    return function (obj) {
-      for (var i = 0; i < segments.length; i++) {
-        if (!obj) {
+      if (bailRE.test(path)) {
           return;
-        }
-        obj = obj[segments[i]];
       }
-      return obj;
-    };
+      var segments = path.split('.');
+      return function (obj) {
+          for (var i = 0; i < segments.length; i++) {
+              if (!obj)
+                  { return; }
+              obj = obj[segments[i]];
+          }
+          return obj;
+      };
   }
 
   // can we use __proto__?
-  var hasProto = "__proto__" in {};
+  var hasProto = '__proto__' in {};
   // Browser environment sniffing
-  var inBrowser = typeof window !== "undefined";
+  var inBrowser = typeof window !== 'undefined';
+  // @ts-ignore
+  var inWeex = 
   // @ts-ignore
-  var inWeex =
-    // @ts-ignore
-    typeof WXEnvironment !== "undefined" && !!WXEnvironment.platform;
+  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
   // @ts-ignore
   var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
   var UA = inBrowser && window.navigator.userAgent.toLowerCase();
   var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf("msie 9.0") > 0;
-  var isEdge = UA && UA.indexOf("edge/") > 0;
-  (UA && UA.indexOf("android") > 0) || weexPlatform === "android";
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === "ios";
+  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  var isEdge = UA && UA.indexOf('edge/') > 0;
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   UA && /chrome\/\d+/.test(UA) && !isEdge;
   UA && /phantomjs/.test(UA);
   var isFF = UA && UA.match(/firefox\/(\d+)/);
@@ -487,69 +464,71 @@
   var nativeWatch = {}.watch;
   var supportsPassive = false;
   if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, "passive", {
-        get: function get() {
-          /* istanbul ignore next */
-          supportsPassive = true;
-        },
-      }); // https://github.com/facebook/flow/issues/285
-      // @ts-ignore
-      window.addEventListener("test-passive", null, opts);
-    } catch (e) {}
+      try {
+          var opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get: function get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          // @ts-ignore
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
   }
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
   var _isServer;
   var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== "undefined") {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer =
-          global["process"] && global["process"].env.VUE_ENV === "server";
-      } else {
-        _isServer = false;
-      }
-    }
-    return _isServer;
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
   };
   // detect devtools
   // @ts-ignore TODO decalre this types
   var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
   /* istanbul ignore next */
   function isNative(Ctor) {
-    return typeof Ctor === "function" && /native code/.test(Ctor.toString());
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
   }
-  var hasSymbol =
-    typeof Symbol !== "undefined" &&
-    isNative(Symbol) &&
-    typeof Reflect !== "undefined" &&
-    isNative(Reflect.ownKeys);
+  var hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
   var _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== "undefined" && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/ (function () {
-      function Set() {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has(key) {
-        return this.set[key] === true;
-      };
-      Set.prototype.add = function add(key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear() {
-        this.set = Object.create(null);
-      };
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = /*@__PURE__*/(function () {
+          function Set() {
+              this.set = Object.create(null);
+          }
+          Set.prototype.has = function has (key) {
+              return this.set[key] === true;
+          };
+          Set.prototype.add = function add (key) {
+              this.set[key] = true;
+          };
+          Set.prototype.clear = function clear () {
+              this.set = Object.create(null);
+          };
 
-      return Set;
-    })();
+          return Set;
+      }());
   }
 
   var warn = noop;
@@ -557,108 +536,88 @@
   var generateComponentTrace; // work around flow check
   var formatComponentName;
   {
-    var hasConsole = typeof console !== "undefined";
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) {
-      return str
-        .replace(classifyRE, function (c) {
-          return c.toUpperCase();
-        })
-        .replace(/[-_]/g, "");
-    };
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : "";
-      if (config.warnHandler) {
-        config.warnHandler.call(null, msg, vm, trace);
-      } else if (hasConsole && !config.silent) {
-        console.error("[Vue warn]: " + msg + trace);
-      }
-    };
-    tip = function (msg, vm) {
-      if (hasConsole && !config.silent) {
-        console.warn(
-          "[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : "")
-        );
-      }
-    };
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return "<Root>";
-      }
-      var options =
-        // @ts-ignore
-        typeof vm === "function" && vm.cid != null
-          ? // @ts-ignore
-            vm.options
-          : vm._isVue
-          ? // @ts-ignore
-            vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-      return (
-        (name ? "<" + classify(name) + ">" : "<Anonymous>") +
-        (file && includeFile !== false ? " at " + file : "")
-      );
-    };
-    var repeat = function (str, n) {
-      var res = "";
-      while (n) {
-        if (n % 2 === 1) {
-          res += str;
-        }
-        if (n > 1) {
-          str += str;
-        }
-        n >>= 1;
-      }
-      return res;
-    };
-    generateComponentTrace = function (vm) {
-      // @ts-ignore
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue;
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
-          }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return (
-          "\n\nfound in\n\n" +
-          tree
-            .map(function (vm, i) {
-              return (
-                "" +
-                (i === 0 ? "---> " : repeat(" ", 5 + i * 2)) +
-                (Array.isArray(vm)
-                  ? formatComponentName(vm[0]) +
-                    "... (" +
-                    vm[1] +
-                    " recursive calls)"
-                  : formatComponentName(vm))
-              );
-            })
-            .join("\n")
-        );
-      } else {
-        return "\n\n(found in " + formatComponentName(vm) + ")";
-      }
-    };
+      var hasConsole = typeof console !== 'undefined';
+      var classifyRE = /(?:^|[-_])(\w)/g;
+      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
+      warn = function (msg, vm) {
+          var trace = vm ? generateComponentTrace(vm) : '';
+          if (config.warnHandler) {
+              config.warnHandler.call(null, msg, vm, trace);
+          }
+          else if (hasConsole && !config.silent) {
+              console.error(("[Vue warn]: " + msg + trace));
+          }
+      };
+      tip = function (msg, vm) {
+          if (hasConsole && !config.silent) {
+              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = function (vm, includeFile) {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          var options = 
+          // @ts-ignore
+          typeof vm === 'function' && vm.cid != null
+              ? // @ts-ignore
+                  vm.options
+              : vm._isVue
+                  ? // @ts-ignore
+                      vm.$options || vm.constructor.options
+                  : vm;
+          var name = options.name || options._componentTag;
+          var file = options.__file;
+          if (!name && file) {
+              var match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
+              (file && includeFile !== false ? (" at " + file) : ''));
+      };
+      var repeat = function (str, n) {
+          var res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  { res += str; }
+              if (n > 1)
+                  { str += str; }
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = function (vm) {
+          // @ts-ignore
+          if (vm._isVue && vm.$parent) {
+              var tree = [];
+              var currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      var last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
+                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
+                      : formatComponentName(vm))); })
+                      .join('\n'));
+          }
+          else {
+              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+          }
+      };
   }
 
   var uid$2 = 0;
@@ -667,34 +626,32 @@
    * directives subscribing to it.
    */
   var Dep = function Dep() {
-    this.id = uid$2++;
-    this.subs = [];
+      this.id = uid$2++;
+      this.subs = [];
   };
-  Dep.prototype.addSub = function addSub(sub) {
-    this.subs.push(sub);
+  Dep.prototype.addSub = function addSub (sub) {
+      this.subs.push(sub);
   };
-  Dep.prototype.removeSub = function removeSub(sub) {
-    remove$2(this.subs, sub);
+  Dep.prototype.removeSub = function removeSub (sub) {
+      remove$2(this.subs, sub);
   };
-  Dep.prototype.depend = function depend() {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
+  Dep.prototype.depend = function depend () {
+      if (Dep.target) {
+          Dep.target.addDep(this);
+      }
   };
-  Dep.prototype.notify = function notify() {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-      // subs aren't sorted in scheduler if not running async
-      // we need to sort them now to make sure they fire in correct
-      // order
-      subs.sort(function (a, b) {
-        return a.id - b.id;
-      });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
+  Dep.prototype.notify = function notify () {
+      // stabilize the subscriber list first
+      var subs = this.subs.slice();
+      if (!config.async) {
+          // subs aren't sorted in scheduler if not running async
+          // we need to sort them now to make sure they fire in correct
+          // order
+          subs.sort(function (a, b) { return a.id - b.id; });
+      }
+      for (var i = 0, l = subs.length; i < l; i++) {
+          subs[i].update();
+      }
   };
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
@@ -702,97 +659,81 @@
   Dep.target = null;
   var targetStack = [];
   function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
+      targetStack.push(target);
+      Dep.target = target;
   }
   function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = function VNode(
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+      this.tag = tag;
+      this.data = data;
+      this.children = children;
+      this.text = text;
+      this.elm = elm;
+      this.ns = undefined;
+      this.context = context;
+      this.fnContext = undefined;
+      this.fnOptions = undefined;
+      this.fnScopeId = undefined;
+      this.key = data && data.key;
+      this.componentOptions = componentOptions;
+      this.componentInstance = undefined;
+      this.parent = undefined;
+      this.raw = false;
+      this.isStatic = false;
+      this.isRootInsert = true;
+      this.isComment = false;
+      this.isCloned = false;
+      this.isOnce = false;
+      this.asyncFactory = asyncFactory;
+      this.asyncMeta = undefined;
+      this.isAsyncPlaceholder = false;
   };
 
   var prototypeAccessors = { child: { configurable: true } };
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   prototypeAccessors.child.get = function () {
-    return this.componentInstance;
+      return this.componentInstance;
   };
 
-  Object.defineProperties(VNode.prototype, prototypeAccessors);
+  Object.defineProperties( VNode.prototype, prototypeAccessors );
   var createEmptyVNode = function (text) {
-    if (text === void 0) text = "";
+      if ( text === void 0 ) text = '';
 
-    var node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
+      var node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
   };
   function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
+      return new VNode(undefined, undefined, undefined, String(val));
   }
   // optimized shallow clone
   // used for static nodes and slot nodes because they may be reused across
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
   function cloneVNode(vnode) {
-    var cloned = new VNode(
+      var cloned = new VNode(
       //@ts-expect-error void type not valid here
-      vnode.tag,
-      vnode.data,
+      vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
-      vnode.children && vnode.children.slice(),
-      vnode.text,
-      vnode.elm,
-      vnode.context,
-      vnode.componentOptions,
-      vnode.asyncFactory
-    );
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
   }
 
   /*
@@ -802,44 +743,41 @@
   var arrayProto = Array.prototype;
   var arrayMethods = Object.create(arrayProto);
   var methodsToPatch = [
-    "push",
-    "pop",
-    "shift",
-    "unshift",
-    "splice",
-    "sort",
-    "reverse",
-  ];
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse' ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-      var args = [],
-        len = arguments.length;
-      while (len--) args[len] = arguments[len];
+      // cache original method
+      var original = arrayProto[method];
+      def(arrayMethods, method, function mutator() {
+          var args = [], len = arguments.length;
+          while ( len-- ) args[ len ] = arguments[ len ];
 
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case "push":
-        case "unshift":
-          inserted = args;
-          break;
-        case "splice":
-          inserted = args.slice(2);
-          break;
-      }
-      if (inserted) {
-        ob.observeArray(inserted);
-      }
-      // notify change
-      ob.dep.notify();
-      return result;
-    });
+          var result = original.apply(this, args);
+          var ob = this.__ob__;
+          var inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              { ob.observeArray(inserted); }
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
@@ -849,7 +787,7 @@
    */
   var shouldObserve = true;
   function toggleObserving(value) {
-    shouldObserve = value;
+      shouldObserve = value;
   }
   /**
    * Observer class that is attached to each observed
@@ -858,39 +796,41 @@
    * collect dependencies and dispatch updates.
    */
   var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, "__ob__", this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
+      this.value = value;
+      this.dep = new Dep();
+      this.vmCount = 0;
+      def(value, '__ob__', this);
+      if (Array.isArray(value)) {
+          if (hasProto) {
+              protoAugment(value, arrayMethods);
+          }
+          else {
+              copyAugment(value, arrayMethods, arrayKeys);
+          }
+          this.observeArray(value);
+      }
+      else {
+          this.walk(value);
+      }
   };
   /**
    * Walk through all properties and convert them into
    * getter/setters. This method should only be called when
    * value type is Object.
    */
-  Observer.prototype.walk = function walk(obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive(obj, keys[i]);
-    }
+  Observer.prototype.walk = function walk (obj) {
+      var keys = Object.keys(obj);
+      for (var i = 0; i < keys.length; i++) {
+          defineReactive(obj, keys[i]);
+      }
   };
   /**
    * Observe a list of Array items.
    */
-  Observer.prototype.observeArray = function observeArray(items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
+  Observer.prototype.observeArray = function observeArray (items) {
+      for (var i = 0, l = items.length; i < l; i++) {
+          observe(items[i]);
+      }
   };
   // helpers
   /**
@@ -898,9 +838,9 @@
    * the prototype chain using __proto__
    */
   function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
   }
   /**
    * Augment a target Object or Array by defining
@@ -908,10 +848,10 @@
    */
   /* istanbul ignore next */
   function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
+      for (var i = 0, l = keys.length; i < l; i++) {
+          var key = keys[i];
+          def(target, key, src[key]);
+      }
   }
   /**
    * Attempt to create an observer instance for a value,
@@ -919,81 +859,80 @@
    * or the existing observer if the value already has one.
    */
   function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return;
-    }
-    var ob;
-    if (hasOwn(value, "__ob__") && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob;
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      var ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
   }
   /**
    * Define a reactive property on an Object.
    */
   function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return;
-    }
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter() {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value;
-      },
-      set: function reactiveSetter(newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
+      var dep = new Dep();
+      var property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
           return;
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) {
-          return;
-        }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      },
-    });
+      }
+      // cater for pre-defined getter/setters
+      var getter = property && property.get;
+      var setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      var childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              var value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              var value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  { return; }
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
   }
   /**
    * Set a property on an object. Adds the new property and
@@ -1001,82 +940,72 @@
    * already exist.
    */
   function set(target, key, val) {
-    if (isUndef(target) || isPrimitive(target)) {
-      warn(
-        "Cannot set reactive property on undefined, null, or primitive value: " +
-          target
-      );
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val;
-    }
-    var ob = target.__ob__;
-    // @ts-ignore
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        "Avoid adding reactive properties to a Vue instance or its root $data " +
-          "at runtime - declare it upfront in the data option."
-      );
-      return val;
-    }
-    if (!ob) {
-      target[key] = val;
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      var ob = target.__ob__;
+      // @ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive(ob.value, key, val);
+      ob.dep.notify();
       return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
   }
   /**
    * Delete a property and trigger change if necessary.
    */
   function del(target, key) {
-    if (isUndef(target) || isPrimitive(target)) {
-      warn(
-        "Cannot delete reactive property on undefined, null, or primitive value: " +
-          target
-      );
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.splice(key, 1);
-      return;
-    }
-    var ob = target.__ob__;
-    //@ts-ignore
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        "Avoid deleting properties on a Vue instance or its root $data " +
-          "- just set it to null."
-      );
-      return;
-    }
-    if (!hasOwn(target, key)) {
-      return;
-    }
-    delete target[key];
-    if (!ob) {
-      return;
-    }
-    ob.dep.notify();
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.splice(key, 1);
+          return;
+      }
+      var ob = target.__ob__;
+      //@ts-ignore
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                  '- just set it to null.');
+          return;
+      }
+      if (!hasOwn(target, key)) {
+          return;
+      }
+      delete target[key];
+      if (!ob) {
+          return;
+      }
+      ob.dep.notify();
   }
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
+      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
       }
-    }
   }
 
   /**
@@ -1089,128 +1018,117 @@
    * Options with restrictions
    */
   {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          'option "' +
-            key +
-            '" can only be used during instance ' +
-            "creation with the `new` keyword."
-        );
-      }
-      return defaultStrat(parent, child);
-    };
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn("option \"" + key + "\" can only be used during instance " +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
   }
   /**
    * Helper that recursively merges two data objects together.
    */
   function mergeData(to, from) {
-    if (!from) {
+      if (!from)
+          { return to; }
+      var key, toVal, fromVal;
+      var keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (var i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              { continue; }
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
       return to;
-    }
-    var key, toVal, fromVal;
-    var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === "__ob__") {
-        continue;
-      }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to;
   }
   /**
    * Data
    */
   function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal;
-      }
-      if (!parentVal) {
-        return childVal;
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn() {
-        return mergeData(
-          // @ts-ignore
-          typeof childVal === "function" ? childVal.call(this, this) : childVal,
-          // @ts-ignore
-          typeof parentVal === "function"
-            ? parentVal.call(this, this)
-            : parentVal
-        );
-      };
-    } else {
-      return function mergedInstanceDataFn() {
-        // instance merge
-        var instanceData =
-          typeof childVal === "function" ? childVal.call(vm, vm) : childVal;
-        var defaultData =
-          typeof parentVal === "function" ? parentVal.call(vm, vm) : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData);
-        } else {
-          return defaultData;
-        }
-      };
-    }
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(
+              // @ts-ignore
+              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
+              // @ts-ignore
+              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
   }
   strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-      if (childVal && typeof childVal !== "function") {
-        warn(
-          'The "data" option should be a function ' +
-            "that returns a per-instance value in component " +
-            "definitions.",
-          vm
-        );
-        return parentVal;
-      }
-      return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
   };
   /**
    * Hooks and props are merged as arrays.
    */
   function mergeHook$1(parentVal, childVal) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-      : parentVal;
-    return res ? dedupeHooks(res) : res;
+      var res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
   }
   function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
+      var res = [];
+      for (var i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
       }
-    }
-    return res;
+      return res;
   }
   LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook$1;
+      strats[hook] = mergeHook$1;
   });
   /**
    * Assets
@@ -1220,16 +1138,17 @@
    * options and parent options.
    */
   function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal);
-    } else {
-      return res;
-    }
+      var res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
   }
   ASSET_TYPES.forEach(function (type) {
-    strats[type + "s"] = mergeAssets;
+      strats[type + 's'] = mergeAssets;
   });
   /**
    * Watchers.
@@ -1238,239 +1157,206 @@
    * another, so we merge them as arrays.
    */
   strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch) {
-      parentVal = undefined;
-    }
-    //@ts-expect-error work around
-    if (childVal === nativeWatch) {
-      childVal = undefined;
-    }
-    /* istanbul ignore if */
-    if (!childVal) {
-      return Object.create(parentVal || null);
-    }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) {
-      return childVal;
-    }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child)
-        ? child
-        : [child];
-    }
-    return ret;
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          { parentVal = undefined; }
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          { childVal = undefined; }
+      /* istanbul ignore if */
+      if (!childVal)
+          { return Object.create(parentVal || null); }
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = {};
+      extend(ret, parentVal);
+      for (var key$1 in childVal) {
+          var parent = ret[key$1];
+          var child = childVal[key$1];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key$1] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
   };
   /**
    * Other object hashes.
    */
-  strats.props = strats.methods = strats.inject = strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== "production") {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) {
-      return childVal;
-    }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) {
-      extend(ret, childVal);
-    }
-    return ret;
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          { return childVal; }
+      var ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          { extend(ret, childVal); }
+      return ret;
   };
   strats.provide = mergeDataOrFn;
   /**
    * Default strategy.
    */
   var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
+      return childVal === undefined ? parentVal : childVal;
   };
   /**
    * Validate component names
    */
   function checkComponents(options) {
-    for (var key in options.components) {
-      validateComponentName(key);
-    }
+      for (var key in options.components) {
+          validateComponentName(key);
+      }
   }
   function validateComponentName(name) {
-    if (
-      !new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(
-        name
-      )
-    ) {
-      warn(
-        'Invalid component name: "' +
-          name +
-          '". Component names ' +
-          "should conform to valid custom element name in html5 specification."
-      );
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-      warn(
-        "Do not use built-in or reserved HTML elements as component " +
-          "id: " +
-          name
-      );
-    }
+      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+          warn('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
   }
   /**
    * Ensure all props option syntax are normalized into the
    * Object-based format.
    */
   function normalizeProps(options, vm) {
-    var props = options.props;
-    if (!props) {
-      return;
-    }
-    var res = {};
-    var i, val, name;
-    if (Array.isArray(props)) {
-      i = props.length;
-      while (i--) {
-        val = props[i];
-        if (typeof val === "string") {
-          name = camelize(val);
-          res[name] = { type: null };
-        } else {
-          warn("props must be strings when using array syntax.");
-        }
-      }
-    } else if (isPlainObject(props)) {
-      for (var key in props) {
-        val = props[key];
-        name = camelize(key);
-        res[name] = isPlainObject(val) ? val : { type: val };
-      }
-    } else {
-      warn(
-        'Invalid value for option "props": expected an Array or an Object, ' +
-          "but got " +
-          toRawType(props) +
-          ".",
-        vm
-      );
-    }
-    options.props = res;
+      var props = options.props;
+      if (!props)
+          { return; }
+      var res = {};
+      var i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (var key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"props\": expected an Array or an Object, " +
+              "but got " + (toRawType(props)) + ".", vm);
+      }
+      options.props = res;
   }
   /**
    * Normalize all injections into Object-based format
    */
   function normalizeInject(options, vm) {
-    var inject = options.inject;
-    if (!inject) {
-      return;
-    }
-    var normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-      for (var i = 0; i < inject.length; i++) {
-        normalized[inject[i]] = { from: inject[i] };
-      }
-    } else if (isPlainObject(inject)) {
-      for (var key in inject) {
-        var val = inject[key];
-        normalized[key] = isPlainObject(val)
-          ? extend({ from: key }, val)
-          : { from: val };
-      }
-    } else {
-      warn(
-        'Invalid value for option "inject": expected an Array or an Object, ' +
-          "but got " +
-          toRawType(inject) +
-          ".",
-        vm
-      );
-    }
+      var inject = options.inject;
+      if (!inject)
+          { return; }
+      var normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (var i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (var key in inject) {
+              var val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
+              "but got " + (toRawType(inject)) + ".", vm);
+      }
   }
   /**
    * Normalize raw function directives into object format.
    */
   function normalizeDirectives$1(options) {
-    var dirs = options.directives;
-    if (dirs) {
-      for (var key in dirs) {
-        var def = dirs[key];
-        if (typeof def === "function") {
-          dirs[key] = { bind: def, update: def };
-        }
+      var dirs = options.directives;
+      if (dirs) {
+          for (var key in dirs) {
+              var def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
+              }
+          }
       }
-    }
   }
   function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        'Invalid value for option "' +
-          name +
-          '": expected an Object, ' +
-          "but got " +
-          toRawType(value) +
-          ".",
-        vm
-      );
-    }
+      if (!isPlainObject(value)) {
+          warn("Invalid value for option \"" + name + "\": expected an Object, " +
+              "but got " + (toRawType(value)) + ".", vm);
+      }
   }
   /**
    * Merge two option objects into a new one.
    * Core utility used in both instantiation and inheritance.
    */
   function mergeOptions(parent, child, vm) {
-    {
-      checkComponents(child);
-    }
-    if (typeof child === "function") {
-      // @ts-expect-error
-      child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-      if (child.extends) {
-        parent = mergeOptions(parent, child.extends, vm);
-      }
-      if (child.mixins) {
-        for (var i = 0, l = child.mixins.length; i < l; i++) {
-          parent = mergeOptions(parent, child.mixins[i], vm);
-        }
-      }
-    }
-    var options = {};
-    var key;
-    for (key in parent) {
-      mergeField(key);
-    }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
-      }
-    }
-    function mergeField(key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives$1(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (var i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      var options = {};
+      var key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          var strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
   }
   /**
    * Resolve an asset.
@@ -1478,174 +1364,161 @@
    * to assets defined in its ancestor chain.
    */
   function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== "string") {
-      return;
-    }
-    var assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id)) {
-      return assets[id];
-    }
-    var camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId)) {
-      return assets[camelizedId];
-    }
-    var PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId)) {
-      return assets[PascalCaseId];
-    }
-    // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-      warn("Failed to resolve " + type.slice(0, -1) + ": " + id, options);
-    }
-    return res;
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      var assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          { return assets[id]; }
+      var camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          { return assets[camelizedId]; }
+      var PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          { return assets[PascalCaseId]; }
+      // fallback to prototype chain
+      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
   }
 
   function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
-    // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-      if (absent && !hasOwn(prop, "default")) {
-        value = false;
-      } else if (value === "" || value === hyphenate(key)) {
-        // only cast empty string / same name to boolean if
-        // boolean has higher priority
-        var stringIndex = getTypeIndex(String, prop.type);
-        if (stringIndex < 0 || booleanIndex < stringIndex) {
-          value = true;
-        }
-      }
-    }
-    // check default value
-    if (value === undefined) {
-      value = getPropDefaultValue(vm, prop, key);
-      // since the default value is a fresh copy,
-      // make sure to observe it.
-      var prevShouldObserve = shouldObserve;
-      toggleObserving(true);
-      observe(value);
-      toggleObserving(prevShouldObserve);
-    }
-    {
-      assertProp(prop, key, value, vm, absent);
-    }
-    return value;
+      var prop = propOptions[key];
+      var absent = !hasOwn(propsData, key);
+      var value = propsData[key];
+      // boolean casting
+      var booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              var stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          var prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
   }
   /**
    * Get the default value of a prop.
    */
   function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, "default")) {
-      return undefined;
-    }
-    var def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-      warn(
-        'Invalid default value for prop "' +
-          key +
-          '": ' +
-          "Props with type Object/Array must use a factory function " +
-          "to return the default value.",
-        vm
-      );
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (
-      vm &&
-      vm.$options.propsData &&
-      vm.$options.propsData[key] === undefined &&
-      vm._props[key] !== undefined
-    ) {
-      return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === "function" && getType(prop.type) !== "Function"
-      ? def.call(vm)
-      : def;
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      var def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
   }
   /**
    * Assert whether a prop is valid.
    */
   function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-      warn('Missing required prop: "' + name + '"', vm);
-      return;
-    }
-    if (value == null && !prop.required) {
-      return;
-    }
-    var type = prop.type;
-    // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
-    if (type) {
-      if (!Array.isArray(type)) {
-        type = [type];
-      }
-      for (var i = 0; i < type.length && !valid; i++) {
-        var assertedType = assertType(value, type[i], vm);
-        expectedTypes.push(assertedType.expectedType || "");
-        valid = assertedType.valid;
-      }
-    }
-    var haveExpectedTypes = expectedTypes.some(function (t) {
-      return t;
-    });
-    if (!valid && haveExpectedTypes) {
-      warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-      return;
-    }
-    var validator = prop.validator;
-    if (validator) {
-      if (!validator(value)) {
-        warn(
-          'Invalid prop: custom validator check failed for prop "' +
-            name +
-            '".',
-          vm
-        );
-      }
-    }
+      if (prop.required && absent) {
+          warn('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      var type = prop.type;
+      // @ts-ignore
+      var valid = !type || type === true;
+      var expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (var i = 0; i < type.length && !valid; i++) {
+              var assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+      if (!valid && haveExpectedTypes) {
+          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      var validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
   }
   var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
   function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-      var t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      // for primitive wrapper objects
-      if (!valid && t === "object") {
-        valid = value instanceof type;
-      }
-    } else if (expectedType === "Object") {
-      valid = isPlainObject(value);
-    } else if (expectedType === "Array") {
-      valid = Array.isArray(value);
-    } else {
-      try {
-        valid = value instanceof type;
-      } catch (e) {
-        warn(
-          'Invalid prop type: "' + String(type) + '" is not a constructor',
-          vm
-        );
-        valid = false;
-      }
-    }
-    return {
-      valid: valid,
-      expectedType: expectedType,
-    };
+      var valid;
+      var expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          var t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid: valid,
+          expectedType: expectedType,
+      };
   }
   var functionTypeCheckRE = /^\s*function (\w+)/;
   /**
@@ -1654,142 +1527,135 @@
    * across different vms / iframes.
    */
   function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : "";
+      var match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
   }
   function isSameType(a, b) {
-    return getType(a) === getType(b);
+      return getType(a) === getType(b);
   }
   function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-      return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
-      if (isSameType(expectedTypes[i], type)) {
-        return i;
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (var i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
+          }
       }
-    }
-    return -1;
+      return -1;
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message =
-      'Invalid prop: type check failed for prop "' +
-      name +
-      '".' +
-      " Expected " +
-      expectedTypes.map(capitalize).join(", ");
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (
-      expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      isExplicable(typeof value) &&
-      !isBoolean(expectedType, receivedType)
-    ) {
-      message += " with value " + styleValue(value, expectedType);
-    }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-      message += "with value " + styleValue(value, receivedType) + ".";
-    }
-    return message;
+      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
+          " Expected " + (expectedTypes.map(capitalize).join(', '));
+      var expectedType = expectedTypes[0];
+      var receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += " with value " + (styleValue(value, expectedType));
+      }
+      message += ", got " + receivedType + " ";
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += "with value " + (styleValue(value, receivedType)) + ".";
+      }
+      return message;
   }
   function styleValue(value, type) {
-    if (type === "String") {
-      return '"' + value + '"';
-    } else if (type === "Number") {
-      return "" + Number(value);
-    } else {
-      return "" + value;
-    }
-  }
-  var EXPLICABLE_TYPES = ["string", "number", "boolean"];
+      if (type === 'String') {
+          return ("\"" + value + "\"");
+      }
+      else if (type === 'Number') {
+          return ("" + (Number(value)));
+      }
+      else {
+          return ("" + value);
+      }
+  }
+  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
   function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) {
-      return value.toLowerCase() === elem;
-    });
+      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
   }
   function isBoolean() {
-    var args = [],
-      len = arguments.length;
-    while (len--) args[len] = arguments[len];
+      var args = [], len = arguments.length;
+      while ( len-- ) args[ len ] = arguments[ len ];
 
-    return args.some(function (elem) {
-      return elem.toLowerCase() === "boolean";
-    });
+      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
   }
 
   function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-      if (vm) {
-        var cur = vm;
-        while ((cur = cur.$parent)) {
-          var hooks = cur.$options.errorCaptured;
-          if (hooks) {
-            for (var i = 0; i < hooks.length; i++) {
-              try {
-                var capture = hooks[i].call(cur, err, vm, info) === false;
-                if (capture) {
-                  return;
-                }
-              } catch (e) {
-                globalHandleError(e, cur, "errorCaptured hook");
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              var cur = vm;
+              while ((cur = cur.$parent)) {
+                  var hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (var i = 0; i < hooks.length; i++) {
+                          try {
+                              var capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  { return; }
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
               }
-            }
           }
-        }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
       }
-      globalHandleError(err, vm, info);
-    } finally {
-      popTarget();
-    }
   }
   function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
-    try {
-      res = args ? handler.apply(context, args) : handler.call(context);
-      if (res && !res._isVue && isPromise(res) && !res._handled) {
-        res.catch(function (e) {
-          return handleError(e, vm, info + " (Promise/async)");
-        });
-        // issue #9511
-        // avoid catch triggering multiple times when nested calls
-        res._handled = true;
-      }
-    } catch (e) {
-      handleError(e, vm, info);
-    }
-    return res;
+      var res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
   }
   function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-      try {
-        return config.errorHandler.call(null, err, vm, info);
-      } catch (e) {
-        // if the user intentionally throws the original error in the handler,
-        // do not log it twice
-        if (e !== err) {
-          logError(e, null, "config.errorHandler");
-        }
+      if (config.errorHandler) {
+          try {
+              return config.errorHandler.call(null, err, vm, info);
+          }
+          catch (e) {
+              // if the user intentionally throws the original error in the handler,
+              // do not log it twice
+              if (e !== err) {
+                  logError(e, null, 'config.errorHandler');
+              }
+          }
       }
-    }
-    logError(err, vm, info);
+      logError(err, vm, info);
   }
   function logError(err, vm, info) {
-    {
-      warn("Error in " + info + ': "' + err.toString() + '"', vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== "undefined") {
-      console.error(err);
-    } else {
-      throw err;
-    }
+      {
+          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
   }
 
   /* globals MutationObserver */
@@ -1797,12 +1663,12 @@
   var callbacks = [];
   var pending = false;
   function flushCallbacks() {
-    pending = false;
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
+      pending = false;
+      var copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (var i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
   }
   // Here we have async deferring wrappers using microtasks.
   // In 2.5 we used (macro) tasks (in combination with microtasks).
@@ -1823,175 +1689,156 @@
   // completely stops working after triggering a few times... so, if native
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== "undefined" && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
-      p.then(flushCallbacks);
-      // In problematic UIWebViews, Promise.then doesn't completely break, but
-      // it can get stuck in a weird state where callbacks are pushed into the
-      // microtask queue but the queue isn't being flushed, until the browser
-      // needs to do some other work, e.g. handle a timer. Therefore we can
-      // "force" the microtask queue to be flushed by adding an empty timer.
-      if (isIOS) {
-        setTimeout(noop);
-      }
-    };
-    isUsingMicroTask = true;
-  } else if (
-    !isIE &&
-    typeof MutationObserver !== "undefined" &&
-    (isNative(MutationObserver) ||
-      // PhantomJS and iOS 7.x
-      MutationObserver.toString() === "[object MutationObserverConstructor]")
-  ) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true,
-    });
-    timerFunc = function () {
-      counter = (counter + 1) % 2;
-      textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-  } else if (typeof setImmediate !== "undefined" && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = function () {
-      setImmediate(flushCallbacks);
-    };
-  } else {
-    // Fallback to setTimeout.
-    timerFunc = function () {
-      setTimeout(flushCallbacks, 0);
-    };
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+      var p = Promise.resolve();
+      timerFunc = function () {
+          p.then(flushCallbacks);
+          // In problematic UIWebViews, Promise.then doesn't completely break, but
+          // it can get stuck in a weird state where callbacks are pushed into the
+          // microtask queue but the queue isn't being flushed, until the browser
+          // needs to do some other work, e.g. handle a timer. Therefore we can
+          // "force" the microtask queue to be flushed by adding an empty timer.
+          if (isIOS)
+              { setTimeout(noop); }
+      };
+      isUsingMicroTask = true;
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      var counter = 1;
+      var observer = new MutationObserver(flushCallbacks);
+      var textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+      timerFunc = function () {
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+      // Fallback to setImmediate.
+      // Technically it leverages the (macro) task queue,
+      // but it is still a better choice than setTimeout.
+      timerFunc = function () {
+          setImmediate(flushCallbacks);
+      };
+  }
+  else {
+      // Fallback to setTimeout.
+      timerFunc = function () {
+          setTimeout(flushCallbacks, 0);
+      };
   }
   function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
-      if (cb) {
-        try {
-          cb.call(ctx);
-        } catch (e) {
-          handleError(e, ctx, "nextTick");
-        }
-      } else if (_resolve) {
-        _resolve(ctx);
-      }
-    });
-    if (!pending) {
-      pending = true;
-      timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== "undefined") {
-      return new Promise(function (resolve) {
-        _resolve = resolve;
+      var _resolve;
+      callbacks.push(function () {
+          if (cb) {
+              try {
+                  cb.call(ctx);
+              }
+              catch (e) {
+                  handleError(e, ctx, 'nextTick');
+              }
+          }
+          else if (_resolve) {
+              _resolve(ctx);
+          }
       });
-    }
+      if (!pending) {
+          pending = true;
+          timerFunc();
+      }
+      // $flow-disable-line
+      if (!cb && typeof Promise !== 'undefined') {
+          return new Promise(function (resolve) {
+              _resolve = resolve;
+          });
+      }
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
   var initProxy;
   {
-    var allowedGlobals = makeMap(
-      "Infinity,undefined,NaN,isFinite,isNaN," +
-        "parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent," +
-        "Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt," +
-        "require" // for Webpack/Browserify
-    );
-    var warnNonPresent = function (target, key) {
-      warn(
-        'Property or method "' +
-          key +
-          '" is not defined on the instance but ' +
-          "referenced during render. Make sure that this property is reactive, " +
-          "either in the data option, or for class-based components, by " +
-          "initializing the property. " +
-          "See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.",
-        target
-      );
-    };
-    var warnReservedPrefix = function (target, key) {
-      warn(
-        'Property "' +
-          key +
-          '" must be accessed with "$data.' +
-          key +
-          '" because ' +
-          'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-          "prevent conflicts with Vue internals. " +
-          "See: https://vuejs.org/v2/api/#data",
-        target
+      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
       );
-    };
-    var hasProxy = typeof Proxy !== "undefined" && isNative(Proxy);
-    if (hasProxy) {
-      var isBuiltInModifier = makeMap(
-        "stop,prevent,self,ctrl,shift,alt,meta,exact"
-      );
-      config.keyCodes = new Proxy(config.keyCodes, {
-        set: function set(target, key, value) {
-          if (isBuiltInModifier(key)) {
-            warn(
-              "Avoid overwriting built-in modifier in config.keyCodes: ." + key
-            );
-            return false;
-          } else {
-            target[key] = value;
-            return true;
-          }
-        },
-      });
-    }
-    var hasHandler = {
-      has: function has(target, key) {
-        var has = key in target;
-        var isAllowed =
-          allowedGlobals(key) ||
-          (typeof key === "string" &&
-            key.charAt(0) === "_" &&
-            !(key in target.$data));
-        if (!has && !isAllowed) {
-          if (key in target.$data) {
-            warnReservedPrefix(target, key);
-          } else {
-            warnNonPresent(target, key);
-          }
-        }
-        return has || !isAllowed;
-      },
-    };
-    var getHandler = {
-      get: function get(target, key) {
-        if (typeof key === "string" && !(key in target)) {
-          if (key in target.$data) {
-            warnReservedPrefix(target, key);
-          } else {
-            warnNonPresent(target, key);
-          }
-        }
-        return target[key];
-      },
-    };
-    initProxy = function initProxy(vm) {
+      var warnNonPresent = function (target, key) {
+          warn("Property or method \"" + key + "\" is not defined on the instance but " +
+              'referenced during render. Make sure that this property is reactive, ' +
+              'either in the data option, or for class-based components, by ' +
+              'initializing the property. ' +
+              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+      };
+      var warnReservedPrefix = function (target, key) {
+          warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+              'prevent conflicts with Vue internals. ' +
+              'See: https://vuejs.org/v2/api/#data', target);
+      };
+      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
       if (hasProxy) {
-        // determine which proxy handler to use
-        var options = vm.$options;
-        var handlers =
-          options.render && options.render._withStripped
-            ? getHandler
-            : hasHandler;
-        vm._renderProxy = new Proxy(vm, handlers);
-      } else {
-        vm._renderProxy = vm;
-      }
-    };
+          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set: function set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
+      var hasHandler = {
+          has: function has(target, key) {
+              var has = key in target;
+              var isAllowed = allowedGlobals(key) ||
+                  (typeof key === 'string' &&
+                      key.charAt(0) === '_' &&
+                      !(key in target.$data));
+              if (!has && !isAllowed) {
+                  if (key in target.$data)
+                      { warnReservedPrefix(target, key); }
+                  else
+                      { warnNonPresent(target, key); }
+              }
+              return has || !isAllowed;
+          },
+      };
+      var getHandler = {
+          get: function get(target, key) {
+              if (typeof key === 'string' && !(key in target)) {
+                  if (key in target.$data)
+                      { warnReservedPrefix(target, key); }
+                  else
+                      { warnNonPresent(target, key); }
+              }
+              return target[key];
+          },
+      };
+      initProxy = function initProxy(vm) {
+          if (hasProxy) {
+              // determine which proxy handler to use
+              var options = vm.$options;
+              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              vm._renderProxy = new Proxy(vm, handlers);
+          }
+          else {
+              vm._renderProxy = vm;
+          }
+      };
   }
 
   var seenObjects = new _Set();
@@ -2001,236 +1848,204 @@
    * is collected as a "deep" dependency.
    */
   function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
+      _traverse(val, seenObjects);
+      seenObjects.clear();
   }
   function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
-    if (
-      (!isA && !isObject(val)) ||
-      Object.isFrozen(val) ||
-      val instanceof VNode
-    ) {
-      return;
-    }
-    if (val.__ob__) {
-      var depId = val.__ob__.dep.id;
-      if (seen.has(depId)) {
-        return;
-      }
-      seen.add(depId);
-    }
-    if (isA) {
-      i = val.length;
-      while (i--) {
-        _traverse(val[i], seen);
+      var i, keys;
+      var isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
       }
-    } else {
-      keys = Object.keys(val);
-      i = keys.length;
-      while (i--) {
-        _traverse(val[keys[i]], seen);
+      if (val.__ob__) {
+          var depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              { _traverse(val[i], seen); }
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              { _traverse(val[keys[i]], seen); }
       }
-    }
   }
 
   var mark;
   var measure;
   {
-    var perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (
-      perf &&
-      perf.mark &&
-      perf.measure &&
-      perf.clearMarks &&
-      perf.clearMeasures
-    ) {
-      mark = function (tag) {
-        return perf.mark(tag);
-      };
-      measure = function (name, startTag, endTag) {
-        perf.measure(name, startTag, endTag);
-        perf.clearMarks(startTag);
-        perf.clearMarks(endTag);
-        // perf.clearMeasures(name)
-      };
-    }
+      var perf = inBrowser && window.performance;
+      /* istanbul ignore if */
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = function (tag) { return perf.mark(tag); };
+          measure = function (name, startTag, endTag) {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+              // perf.clearMeasures(name)
+          };
+      }
   }
 
   var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === "&";
-    name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === "~"; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === "!";
-    name = capture ? name.slice(1) : name;
-    return {
-      name: name,
-      once: once,
-      capture: capture,
-      passive: passive,
-    };
+      var passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      var once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
+      var capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name: name,
+          once: once,
+          capture: capture,
+          passive: passive,
+      };
   });
   function createFnInvoker(fns, vm) {
-    function invoker() {
-      var arguments$1 = arguments;
+      function invoker() {
+          var arguments$1 = arguments;
 
-      var fns = invoker.fns;
-      if (Array.isArray(fns)) {
-        var cloned = fns.slice();
-        for (var i = 0; i < cloned.length; i++) {
-          invokeWithErrorHandling(
-            cloned[i],
-            null,
-            arguments$1,
-            vm,
-            "v-on handler"
-          );
-        }
-      } else {
-        // return handler return value for single handlers
-        return invokeWithErrorHandling(
-          fns,
-          null,
-          arguments,
-          vm,
-          "v-on handler"
-        );
-      }
-    }
-    invoker.fns = fns;
-    return invoker;
+          var fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              var cloned = fns.slice();
+              for (var i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
   }
   function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, cur, old, event;
-    for (name in on) {
-      cur = on[name];
-      old = oldOn[name];
-      event = normalizeEvent(name);
-      if (isUndef(cur)) {
-        warn(
-          'Invalid handler for event "' + event.name + '": got ' + String(cur),
-          vm
-        );
-      } else if (isUndef(old)) {
-        if (isUndef(cur.fns)) {
-          cur = on[name] = createFnInvoker(cur, vm);
-        }
-        if (isTrue(event.once)) {
-          cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-        }
-        add(event.name, cur, event.capture, event.passive, event.params);
-      } else if (cur !== old) {
-        old.fns = cur;
-        on[name] = old;
-      }
-    }
-    for (name in oldOn) {
-      if (isUndef(on[name])) {
-        event = normalizeEvent(name);
-        remove(event.name, oldOn[name], event.capture);
-      }
-    }
+      var name, cur, old, event;
+      for (name in on) {
+          cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove(event.name, oldOn[name], event.capture);
+          }
+      }
   }
 
   function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-      def = def.data.hook || (def.data.hook = {});
-    }
-    var invoker;
-    var oldHook = def[hookKey];
-    function wrappedHook() {
-      hook.apply(this, arguments);
-      // important: remove merged hook to ensure it's called only once
-      // and prevent memory leak
-      remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-      // no existing hook
-      invoker = createFnInvoker([wrappedHook]);
-    } else {
-      /* istanbul ignore if */
-      if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-        // already a merged invoker
-        invoker = oldHook;
-        invoker.fns.push(wrappedHook);
-      } else {
-        // existing plain hook
-        invoker = createFnInvoker([oldHook, wrappedHook]);
-      }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
+      if (def instanceof VNode) {
+          def = def.data.hook || (def.data.hook = {});
+      }
+      var invoker;
+      var oldHook = def[hookKey];
+      function wrappedHook() {
+          hook.apply(this, arguments);
+          // important: remove merged hook to ensure it's called only once
+          // and prevent memory leak
+          remove$2(invoker.fns, wrappedHook);
+      }
+      if (isUndef(oldHook)) {
+          // no existing hook
+          invoker = createFnInvoker([wrappedHook]);
+      }
+      else {
+          /* istanbul ignore if */
+          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+              // already a merged invoker
+              invoker = oldHook;
+              invoker.fns.push(wrappedHook);
+          }
+          else {
+              // existing plain hook
+              invoker = createFnInvoker([oldHook, wrappedHook]);
+          }
+      }
+      invoker.merged = true;
+      def[hookKey] = invoker;
   }
 
   function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    var propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-      return;
-    }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
-    if (isDef(attrs) || isDef(props)) {
-      for (var key in propOptions) {
-        var altKey = hyphenate(key);
-        {
-          var keyInLowerCase = key.toLowerCase();
-          if (
-            key !== keyInLowerCase &&
-            attrs &&
-            hasOwn(attrs, keyInLowerCase)
-          ) {
-            tip(
-              'Prop "' +
-                keyInLowerCase +
-                '" is passed to component ' +
-                formatComponentName(
-                  // @ts-ignore
-                  tag || Ctor
-                ) +
-                ", but the declared prop name is" +
-                ' "' +
-                key +
-                '". ' +
-                "Note that HTML attributes are case-insensitive and camelCased " +
-                "props need to use their kebab-case equivalents when using in-DOM " +
-                'templates. You should probably use "' +
-                altKey +
-                '" instead of "' +
-                key +
-                '".'
-            );
-          }
-        }
-        checkProp(res, props, key, altKey, true) ||
-          checkProp(res, attrs, key, altKey, false);
-      }
-    }
-    return res;
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      var propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      var res = {};
+      var attrs = data.attrs;
+      var props = data.props;
+      if (isDef(attrs) || isDef(props)) {
+          for (var key in propOptions) {
+              var altKey = hyphenate(key);
+              {
+                  var keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
+                          (formatComponentName(
+                          // @ts-ignore
+                          tag || Ctor)) + ", but the declared prop name is" +
+                          " \"" + key + "\". " +
+                          "Note that HTML attributes are case-insensitive and camelCased " +
+                          "props need to use their kebab-case equivalents when using in-DOM " +
+                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
   }
   function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-      if (hasOwn(hash, key)) {
-        res[key] = hash[key];
-        if (!preserve) {
-          delete hash[key];
-        }
-        return true;
-      } else if (hasOwn(hash, altKey)) {
-        res[key] = hash[altKey];
-        if (!preserve) {
-          delete hash[altKey];
-        }
-        return true;
-      }
-    }
-    return false;
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
   }
 
   // The template compiler attempts to minimize the need for normalization by
@@ -2245,1783 +2060,1609 @@
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
   function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
-      if (Array.isArray(children[i])) {
-        return Array.prototype.concat.apply([], children);
+      for (var i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
       }
-    }
-    return children;
+      return children;
   }
   // 2. When the children contains constructs that always generated nested Arrays,
   // e.g. <template>, <slot>, v-for, or when the children is provided by user
   // with hand-written render functions / JSX. In such cases a full normalization
   // is needed to cater to all possible types of children values.
   function normalizeChildren(children) {
-    return isPrimitive(children)
-      ? [createTextVNode(children)]
-      : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined;
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
   }
   function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
   }
   function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-      c = children[i];
-      if (isUndef(c) || typeof c === "boolean") {
-        continue;
-      }
-      lastIndex = res.length - 1;
-      last = res[lastIndex];
-      //  nested
-      if (Array.isArray(c)) {
-        if (c.length > 0) {
-          c = normalizeArrayChildren(c, (nestedIndex || "") + "_" + i);
-          // merge adjacent text nodes
-          if (isTextNode(c[0]) && isTextNode(last)) {
-            res[lastIndex] = createTextVNode(last.text + c[0].text);
-            c.shift();
-          }
-          res.push.apply(res, c);
-        }
-      } else if (isPrimitive(c)) {
-        if (isTextNode(last)) {
-          // merge adjacent text nodes
-          // this is necessary for SSR hydration because text nodes are
-          // essentially merged when rendered to HTML strings
-          res[lastIndex] = createTextVNode(last.text + c);
-        } else if (c !== "") {
-          // convert primitive to vnode
-          res.push(createTextVNode(c));
-        }
-      } else {
-        if (isTextNode(c) && isTextNode(last)) {
-          // merge adjacent text nodes
-          res[lastIndex] = createTextVNode(last.text + c.text);
-        } else {
-          // default key for nested array children (likely generated by v-for)
-          if (
-            isTrue(children._isVList) &&
-            isDef(c.tag) &&
-            isUndef(c.key) &&
-            isDef(nestedIndex)
-          ) {
-            c.key = "__vlist" + nestedIndex + "_" + i + "__";
-          }
-          res.push(c);
-        }
-      }
-    }
-    return res;
+      var res = [];
+      var i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              { continue; }
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
   }
 
   function initProvide(vm) {
-    var provide = vm.$options.provide;
-    if (provide) {
-      vm._provided =
-        typeof provide === "function"
-          ? // @ts-expect-error typing not correct
-            provide.call(vm)
-          : provide;
-    }
+      var provide = vm.$options.provide;
+      if (provide) {
+          vm._provided =
+              typeof provide === 'function'
+                  ? // @ts-expect-error typing not correct
+                      provide.call(vm)
+                  : provide;
+      }
   }
   function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-      toggleObserving(false);
-      Object.keys(result).forEach(function (key) {
-        /* istanbul ignore else */
-        {
-          defineReactive(vm, key, result[key], function () {
-            warn(
-              "Avoid mutating an injected value directly since the changes will be " +
-                "overwritten whenever the provided component re-renders. " +
-                'injection being mutated: "' +
-                key +
-                '"',
-              vm
-            );
+      var result = resolveInject(vm.$options.inject, vm);
+      if (result) {
+          toggleObserving(false);
+          Object.keys(result).forEach(function (key) {
+              /* istanbul ignore else */
+              {
+                  defineReactive(vm, key, result[key], function () {
+                      warn("Avoid mutating an injected value directly since the changes will be " +
+                          "overwritten whenever the provided component re-renders. " +
+                          "injection being mutated: \"" + key + "\"", vm);
+                  });
+              }
           });
-        }
-      });
-      toggleObserving(true);
-    }
+          toggleObserving(true);
+      }
   }
   function resolveInject(inject, vm) {
-    if (inject) {
-      // inject is :any because flow is not smart enough to figure out cached
-      var result = Object.create(null);
-      var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        // #6574 in case the inject object is observed...
-        if (key === "__ob__") {
-          continue;
-        }
-        var provideKey = inject[key].from;
-        var source = vm;
-        while (source) {
-          if (source._provided && hasOwn(source._provided, provideKey)) {
-            result[key] = source._provided[provideKey];
-            break;
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          var result = Object.create(null);
+          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (var i = 0; i < keys.length; i++) {
+              var key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  { continue; }
+              var provideKey = inject[key].from;
+              var source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      var provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      // @ts-ignore
+                      warn(("Injection \"" + key + "\" not found"), vm);
+                  }
+              }
           }
-          // @ts-expect-error
-          source = source.$parent;
-        }
-        if (!source) {
-          if ("default" in inject[key]) {
-            var provideDefault = inject[key].default;
-            result[key] =
-              typeof provideDefault === "function"
-                ? provideDefault.call(vm)
-                : provideDefault;
-          } else {
-            // @ts-ignore
-            warn('Injection "' + key + '" not found', vm);
-          }
-        }
-      }
-      return result;
-    }
+          return result;
+      }
   }
 
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
   function resolveSlots(children, context) {
-    if (!children || !children.length) {
-      return {};
-    }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-      var child = children[i];
-      var data = child.data;
-      // remove slot attribute if the node is resolved as a Vue slot node
-      if (data && data.attrs && data.attrs.slot) {
-        delete data.attrs.slot;
-      }
-      // named slots should only be respected if the vnode was rendered in the
-      // same context.
-      if (
-        (child.context === context || child.fnContext === context) &&
-        data &&
-        data.slot != null
-      ) {
-        var name = data.slot;
-        var slot = slots[name] || (slots[name] = []);
-        if (child.tag === "template") {
-          slot.push.apply(slot, child.children || []);
-        } else {
-          slot.push(child);
-        }
-      } else {
-        (slots.default || (slots.default = [])).push(child);
-      }
-    }
-    // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-      if (slots[name$1].every(isWhitespace)) {
-        delete slots[name$1];
-      }
-    }
-    return slots;
+      if (!children || !children.length) {
+          return {};
+      }
+      var slots = {};
+      for (var i = 0, l = children.length; i < l; i++) {
+          var child = children[i];
+          var data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              var name = data.slot;
+              var slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (var name$1 in slots) {
+          if (slots[name$1].every(isWhitespace)) {
+              delete slots[name$1];
+          }
+      }
+      return slots;
   }
   function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === " ";
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
-    if (!slots) {
-      res = {};
-    } else if (slots._normalized) {
-      // fast path 1: child component re-render only, parent did not change
-      return slots._normalized;
-    } else if (
-      isStable &&
-      prevSlots &&
-      prevSlots !== emptyObject &&
-      key === prevSlots.$key &&
-      !hasNormalSlots &&
-      !prevSlots.$hasNormal
-    ) {
-      // fast path 2: stable scoped slots w/ no normal slots to proxy,
-      // only need to normalize once
-      return prevSlots;
-    } else {
-      res = {};
-      for (var key$1 in slots) {
-        if (slots[key$1] && key$1[0] !== "$") {
-          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-        }
-      }
-    }
-    // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-      if (!(key$2 in res)) {
-        res[key$2] = proxyNormalSlot(normalSlots, key$2);
-      }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-      slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
+      var res;
+      var hasNormalSlots = Object.keys(normalSlots).length > 0;
+      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      var key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (var key$1 in slots) {
+              if (slots[key$1] && key$1[0] !== '$') {
+                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (var key$2 in normalSlots) {
+          if (!(key$2 in res)) {
+              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, '$stable', isStable);
+      def(res, '$key', key);
+      def(res, '$hasNormal', hasNormalSlots);
+      return res;
   }
   function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-      var res = arguments.length ? fn.apply(null, arguments) : fn({});
-      res =
-        res && typeof res === "object" && !Array.isArray(res)
-          ? [res] // single vnode
-          : normalizeChildren(res);
-      return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
-        ? undefined
-        : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-      Object.defineProperty(normalSlots, key, {
-        get: normalized,
-        enumerable: true,
-        configurable: true,
-      });
-    }
-    return normalized;
+      var normalized = function () {
+          var res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === 'object' && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
   }
   function proxyNormalSlot(slots, key) {
-    return function () {
-      return slots[key];
-    };
+      return function () { return slots[key]; };
   }
 
   /**
    * Runtime helper for rendering v-for lists.
    */
   function renderList(val, render) {
-    var ret = null,
-      i,
-      l,
-      keys,
-      key;
-    if (Array.isArray(val) || typeof val === "string") {
-      ret = new Array(val.length);
-      for (i = 0, l = val.length; i < l; i++) {
-        ret[i] = render(val[i], i);
-      }
-    } else if (typeof val === "number") {
-      ret = new Array(val);
-      for (i = 0; i < val; i++) {
-        ret[i] = render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      if (hasSymbol && val[Symbol.iterator]) {
-        ret = [];
-        var iterator = val[Symbol.iterator]();
-        var result = iterator.next();
-        while (!result.done) {
-          ret.push(render(result.value, ret.length));
-          result = iterator.next();
-        }
-      } else {
-        keys = Object.keys(val);
-        ret = new Array(keys.length);
-        for (i = 0, l = keys.length; i < l; i++) {
-          key = keys[i];
-          ret[i] = render(val[key], key, i);
-        }
+      var ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              var iterator = val[Symbol.iterator]();
+              var result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
       }
-    }
-    if (!isDef(ret)) {
-      ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+      ret._isVList = true;
+      return ret;
   }
 
   /**
    * Runtime helper for rendering <slot>
    */
   function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
-    if (scopedSlotFn) {
-      // scoped slot
-      props = props || {};
-      if (bindObject) {
-        if (!isObject(bindObject)) {
-          warn("slot v-bind without argument expects an Object", this);
-        }
-        props = extend(extend({}, bindObject), props);
-      }
-      nodes = scopedSlotFn(props) || fallback;
-    } else {
-      nodes = this.$slots[name] || fallback;
-    }
-    var target = props && props.slot;
-    if (target) {
-      return this.$createElement("template", { slot: target }, nodes);
-    } else {
-      return nodes;
-    }
+      var scopedSlotFn = this.$scopedSlots[name];
+      var nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn('slot v-bind without argument expects an Object', this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes = scopedSlotFn(props) || fallback;
+      }
+      else {
+          nodes = this.$slots[name] || fallback;
+      }
+      var target = props && props.slot;
+      if (target) {
+          return this.$createElement('template', { slot: target }, nodes);
+      }
+      else {
+          return nodes;
+      }
   }
 
   /**
    * Runtime helper for resolving filters
    */
   function resolveFilter(id) {
-    return resolveAsset(this.$options, "filters", id, true) || identity;
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
   function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-      return expect.indexOf(actual) === -1;
-    } else {
-      return expect !== actual;
-    }
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
   }
   /**
    * Runtime helper for checking keyCodes from config.
    * exposed as Vue.prototype._k
    * passing in eventKeyName as last argument separately for backwards compat
    */
-  function checkKeyCodes(
-    eventKeyCode,
-    key,
-    builtInKeyCode,
-    eventKeyName,
-    builtInKeyName
-  ) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-      return isKeyNotMatch(builtInKeyName, eventKeyName);
-    } else if (mappedKeyCode) {
-      return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    } else if (eventKeyName) {
-      return hyphenate(eventKeyName) !== key;
-    }
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
   }
 
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
   function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-      if (!isObject(value)) {
-        warn("v-bind without argument expects an Object or Array value", this);
-      } else {
-        if (Array.isArray(value)) {
-          value = toObject(value);
-        }
-        var hash;
-        var loop = function (key) {
-          if (key === "class" || key === "style" || isReservedAttribute(key)) {
-            hash = data;
-          } else {
-            var type = data.attrs && data.attrs.type;
-            hash =
-              asProp || config.mustUseProp(tag, type, key)
-                ? data.domProps || (data.domProps = {})
-                : data.attrs || (data.attrs = {});
-          }
-          var camelizedKey = camelize(key);
-          var hyphenatedKey = hyphenate(key);
-          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-            hash[key] = value[key];
-            if (isSync) {
-              var on = data.on || (data.on = {});
-              on["update:" + key] = function ($event) {
-                value[key] = $event;
-              };
-            }
+      if (value) {
+          if (!isObject(value)) {
+              warn('v-bind without argument expects an Object or Array value', this);
           }
-        };
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              var hash;
+              var loop = function ( key ) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      var type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  var camelizedKey = camelize(key);
+                  var hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          var on = data.on || (data.on = {});
+                          on[("update:" + key)] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              };
 
-        for (var key in value) loop(key);
+              for (var key in value) loop( key );
+          }
       }
-    }
-    return data;
+      return data;
   }
 
   /**
    * Runtime helper for rendering static trees.
    */
   function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
+      var cached = this._staticTrees || (this._staticTrees = []);
+      var tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, ("__static__" + index), false);
       return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(
-      this._renderProxy,
-      null,
-      this // for render fns generated for functional component templates
-    );
-    markStatic(tree, "__static__" + index, false);
-    return tree;
   }
   /**
    * Runtime helper for v-once.
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
-    return tree;
+      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      return tree;
   }
   function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-      for (var i = 0; i < tree.length; i++) {
-        if (tree[i] && typeof tree[i] !== "string") {
-          markStaticNode(tree[i], key + "_" + i, isOnce);
-        }
+      if (Array.isArray(tree)) {
+          for (var i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
       }
-    } else {
-      markStaticNode(tree, key, isOnce);
-    }
   }
   function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
   function bindObjectListeners(data, value) {
-    if (value) {
-      if (!isPlainObject(value)) {
-        warn("v-on without argument expects an Object value", this);
-      } else {
-        var on = (data.on = data.on ? extend({}, data.on) : {});
-        for (var key in value) {
-          var existing = on[key];
-          var ours = value[key];
-          on[key] = existing ? [].concat(existing, ours) : ours;
-        }
-      }
-    }
-    return data;
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn('v-on without argument expects an Object value', this);
+          }
+          else {
+              var on = (data.on = data.on ? extend({}, data.on) : {});
+              for (var key in value) {
+                  var existing = on[key];
+                  var ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
+      }
+      return data;
   }
 
-  function resolveScopedSlots(
-    fns,
-    res,
-    // the following are added in 2.6
-    hasDynamicKeys,
-    contentHashKey
-  ) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-      var slot = fns[i];
-      if (Array.isArray(slot)) {
-        resolveScopedSlots(slot, res, hasDynamicKeys);
-      } else if (slot) {
-        // marker for reverse proxying v-slot without scope on this.$slots
-        // @ts-expect-error
-        if (slot.proxy) {
-          // @ts-expect-error
-          slot.fn.proxy = true;
-        }
-        res[slot.key] = slot.fn;
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (var i = 0; i < fns.length; i++) {
+          var slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
       }
-    }
-    if (contentHashKey) {
-      res.$key = contentHashKey;
-    }
-    return res;
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
   // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-      var key = values[i];
-      if (typeof key === "string" && key) {
-        baseObj[values[i]] = values[i + 1];
-      } else if (key !== "" && key !== null) {
-        // null is a special value for explicitly removing a binding
-        warn(
-          "Invalid value for dynamic directive argument (expected string or null): " +
-            key,
-          this
-        );
-      }
-    }
-    return baseObj;
+      for (var i = 0; i < values.length; i += 2) {
+          var key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+          }
+      }
+      return baseObj;
   }
   // helper to dynamically append modifier runtime markers to event names.
   // ensure only append when value is already string, otherwise it will be cast
   // to string and cause the type check to miss.
   function prependModifier(value, symbol) {
-    return typeof value === "string" ? symbol + value : value;
+      return typeof value === 'string' ? symbol + value : value;
   }
 
   function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
+      var this$1 = this;
 
-    var options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
-    if (hasOwn(parent, "_uid")) {
-      contextVm = Object.create(parent);
-      // $flow-disable-line
-      contextVm._original = parent;
-    } else {
-      // the context vm passed in is a functional context as well.
-      // in this case we want to make sure we are able to get a hold to the
-      // real context instance.
-      contextVm = parent;
-      // $flow-disable-line
-      parent = parent._original;
-    }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-      if (!this$1.$slots) {
-        normalizeScopedSlots(
-          data.scopedSlots,
-          (this$1.$slots = resolveSlots(children, parent))
-        );
-      }
-      return this$1.$slots;
-    };
-    Object.defineProperty(this, "scopedSlots", {
-      enumerable: true,
-      get: function get() {
-        return normalizeScopedSlots(data.scopedSlots, this.slots());
-      },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-      // exposing $options for renderStatic()
-      this.$options = options;
-      // pre-resolve slots for renderSlot()
-      this.$slots = this.slots();
-      this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-      this._c = function (a, b, c, d) {
-        var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-        if (vnode && !Array.isArray(vnode)) {
-          vnode.fnScopeId = options._scopeId;
-          vnode.fnContext = parent;
-        }
-        return vnode;
-      };
-    } else {
-      this._c = function (a, b, c, d) {
-        return createElement$1(contextVm, a, b, c, d, needNormalization);
+      var options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      var contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      var isCompiled = isTrue(options._compiled);
+      var needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = function () {
+          if (!this$1.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+          }
+          return this$1.$slots;
       };
-    }
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get: function get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = function (a, b, c, d) {
+              var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+      }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(
-    Ctor,
-    propsData,
-    data,
-    contextVm,
-    children
-  ) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
-    if (isDef(propOptions)) {
-      for (var key in propOptions) {
-        props[key] = validateProp(key, propOptions, propsData || emptyObject);
-      }
-    } else {
-      if (isDef(data.attrs)) {
-        mergeProps(props, data.attrs);
-      }
-      if (isDef(data.props)) {
-        mergeProps(props, data.props);
-      }
-    }
-    var renderContext = new FunctionalRenderContext(
-      data,
-      props,
-      children,
-      contextVm,
-      Ctor
-    );
-    var vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-      return cloneAndMarkFunctionalResult(
-        vnode,
-        data,
-        renderContext.parent,
-        options,
-        renderContext
-      );
-    } else if (Array.isArray(vnode)) {
-      var vnodes = normalizeChildren(vnode) || [];
-      var res = new Array(vnodes.length);
-      for (var i = 0; i < vnodes.length; i++) {
-        res[i] = cloneAndMarkFunctionalResult(
-          vnodes[i],
-          data,
-          renderContext.parent,
-          options,
-          renderContext
-        );
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      var options = Ctor.options;
+      var props = {};
+      var propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (var key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
       }
-      return res;
-    }
-  }
-  function cloneAndMarkFunctionalResult(
-    vnode,
-    data,
-    contextVm,
-    options,
-    renderContext
-  ) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    var clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-      (clone.devtoolsMeta =
-        clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-      (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
+      else {
+          if (isDef(data.attrs))
+              { mergeProps(props, data.attrs); }
+          if (isDef(data.props))
+              { mergeProps(props, data.props); }
+      }
+      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      var vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          var vnodes = normalizeChildren(vnode) || [];
+          var res = new Array(vnodes.length);
+          for (var i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      var clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
   }
   function mergeProps(to, from) {
-    for (var key in from) {
-      to[camelize(key)] = from[key];
-    }
+      for (var key in from) {
+          to[camelize(key)] = from[key];
+      }
   }
 
   // inline hooks to be invoked on component VNodes during patch
   var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
-      if (
-        vnode.componentInstance &&
-        !vnode.componentInstance._isDestroyed &&
-        vnode.data.keepAlive
-      ) {
-        // kept-alive components, treat as a patch
-        var mountedNode = vnode; // work around flow
-        componentVNodeHooks.prepatch(mountedNode, mountedNode);
-      } else {
-        var child = (vnode.componentInstance = createComponentInstanceForVnode(
-          vnode,
-          activeInstance
-        ));
-        child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-      }
-    },
-    prepatch: function prepatch(oldVnode, vnode) {
-      var options = vnode.componentOptions;
-      var child = (vnode.componentInstance = oldVnode.componentInstance);
-      updateChildComponent(
-        child,
-        options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-      );
-    },
-    insert: function insert(vnode) {
-      var context = vnode.context;
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isMounted) {
-        componentInstance._isMounted = true;
-        callHook$1(componentInstance, "mounted");
-      }
-      if (vnode.data.keepAlive) {
-        if (context._isMounted) {
-          // vue-router#1212
-          // During updates, a kept-alive component's child components may
-          // change, so directly walking the tree here may call activated hooks
-          // on incorrect children. Instead we push them into a queue which will
-          // be processed after the whole patch process ended.
-          queueActivatedComponent(componentInstance);
-        } else {
-          activateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    },
-    destroy: function destroy(vnode) {
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isDestroyed) {
-        if (!vnode.data.keepAlive) {
-          componentInstance.$destroy();
-        } else {
-          deactivateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    },
+      init: function init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              var mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch: function prepatch(oldVnode, vnode) {
+          var options = vnode.componentOptions;
+          var child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert: function insert(vnode) {
+          var context = vnode.context;
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook$1(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy: function destroy(vnode) {
+          var componentInstance = vnode.componentInstance;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
   };
   var hooksToMerge = Object.keys(componentVNodeHooks);
   function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-      return;
-    }
-    var baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-      Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== "function") {
-      {
-        warn("Invalid Component definition: " + String(Ctor), context);
-      }
-      return;
-    }
-    // async component
-    var asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-      asyncFactory = Ctor;
-      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-      if (Ctor === undefined) {
-        // return a placeholder node for async component, which is rendered
-        // as a comment node but preserves all the raw information for the node.
-        // the information will be used for async server-rendering and hydration.
-        return createAsyncPlaceholder(
-          asyncFactory,
-          data,
-          context,
-          children,
-          tag
-        );
-      }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      var baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn(("Invalid Component definition: " + (String(Ctor))), context);
+          }
+          return;
+      }
+      // async component
+      var asyncFactory;
       // @ts-expect-error
-      transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-      return createFunctionalComponent(
-        Ctor,
-        propsData,
-        data,
-        context,
-        children
-      );
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    var listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-      // abstract components do not keep anything
-      // other than props & listeners & slot
-      // work around flow
-      var slot = data.slot;
-      data = {};
-      if (slot) {
-        data.slot = slot;
-      }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
       // @ts-expect-error
-      "vue-component-" + Ctor.cid + (name ? "-" + name : ""),
-      data,
-      undefined,
-      undefined,
-      undefined,
-      context,
+      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
       // @ts-expect-error
-      {
-        Ctor: Ctor,
-        propsData: propsData,
-        listeners: listeners,
-        tag: tag,
-        children: children,
-      },
-      asyncFactory
-    );
-    return vnode;
-  }
-  function createComponentInstanceForVnode(
-    // we know it's MountedComponentVNode but flow doesn't
-    vnode,
-    // activeInstance in lifecycle state
-    parent
-  ) {
-    var options = {
-      _isComponent: true,
-      _parentVnode: vnode,
-      parent: parent,
-    };
-    // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-      options.render = inlineTemplate.render;
-      options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-      var key = hooksToMerge[i];
-      var existing = hooks[key];
-      var toMerge = componentVNodeHooks[key];
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      var listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
       // @ts-expect-error
-      if (existing !== toMerge && !(existing && existing._merged)) {
-        hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          var slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      var name = Ctor.options.name || tag;
+      var vnode = new VNode(
+      // @ts-expect-error
+      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      var options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent: parent,
+      };
+      // check inline-template render functions
+      var inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      var hooks = data.hook || (data.hook = {});
+      for (var i = 0; i < hooksToMerge.length; i++) {
+          var key = hooksToMerge[i];
+          var existing = hooks[key];
+          var toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+          }
       }
-    }
   }
   function mergeHook(f1, f2) {
-    var merged = function (a, b) {
-      // flow complains about extra args which is why we use any
-      f1(a, b);
-      f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
+      var merged = function (a, b) {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
   }
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
   function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || "value";
-    var event = (options.model && options.model.event) || "input";
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
-    if (isDef(existing)) {
-      if (
-        Array.isArray(existing)
-          ? existing.indexOf(callback) === -1
-          : existing !== callback
-      ) {
-        on[event] = [callback].concat(existing);
-      }
-    } else {
-      on[event] = callback;
-    }
+      var prop = (options.model && options.model.prop) || 'value';
+      var event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      var on = data.on || (data.on = {});
+      var existing = on[event];
+      var callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
   }
 
   var SIMPLE_NORMALIZE = 1;
   var ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement$1(
-    context,
-    tag,
-    data,
-    children,
-    normalizationType,
-    alwaysNormalize
-  ) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-      normalizationType = children;
-      children = data;
-      data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-      normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
+  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
   }
   function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-      warn(
-        "Avoid using observed data object as vnode data: " +
-          JSON.stringify(data) +
-          "\n" +
-          "Always create fresh vnode data objects in each render!",
-        context
-      );
-      return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-      tag = data.is;
-    }
-    if (!tag) {
-      // in case of component :is set to falsy value
-      return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)) {
-      // @ts-expect-error
-      {
-        warn(
-          "Avoid using non-primitive value as key, " +
-            "use string/number value instead.",
-          context
-        );
-      }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === "function") {
-      data = data || {};
-      data.scopedSlots = { default: children[0] };
-      children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-      children = normalizeChildren(children);
-    } else if (normalizationType === SIMPLE_NORMALIZE) {
-      children = simpleNormalizeChildren(children);
-    }
-    var vnode, ns;
-    if (typeof tag === "string") {
-      var Ctor;
-      ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-      if (config.isReservedTag(tag)) {
-        // platform built-in elements
-        if (isDef(data) && isDef(data.nativeOn) && data.tag !== "component") {
-          warn(
-            "The .native modifier for v-on is only valid on components but it was used on <" +
-              tag +
-              ">.",
-            context
-          );
-        }
-        vnode = new VNode(
-          config.parsePlatformTagName(tag),
-          data,
-          children,
-          undefined,
-          undefined,
-          context
-        );
-      } else if (
-        (!data || !data.pre) &&
-        isDef((Ctor = resolveAsset(context.$options, "components", tag)))
-      ) {
-        // component
-        vnode = createComponent(Ctor, data, context, children, tag);
-      } else {
-        // unknown or unlisted namespaced elements
-        // check at runtime because it may get assigned a namespace when its
-        // parent normalizes children
-        vnode = new VNode(tag, data, children, undefined, undefined, context);
-      }
-    } else {
-      // direct component options / constructor
-      vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-      return vnode;
-    } else if (isDef(vnode)) {
-      if (isDef(ns)) {
-        applyNS(vnode, ns);
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      var vnode, ns;
+      if (typeof tag === 'string') {
+          var Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if (config.isReservedTag(tag)) {
+              // platform built-in elements
+              if (isDef(data) &&
+                  isDef(data.nativeOn) &&
+                  data.tag !== 'component') {
+                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+              }
+              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+          }
+          else if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
       }
-      if (isDef(data)) {
-        registerDeepBindings(data);
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              { applyNS(vnode, ns); }
+          if (isDef(data))
+              { registerDeepBindings(data); }
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
       }
-      return vnode;
-    } else {
-      return createEmptyVNode();
-    }
   }
   function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === "foreignObject") {
-      // use default namespace inside foreignObject
-      ns = undefined;
-      force = true;
-    }
-    if (isDef(vnode.children)) {
-      for (var i = 0, l = vnode.children.length; i < l; i++) {
-        var child = vnode.children[i];
-        if (
-          isDef(child.tag) &&
-          (isUndef(child.ns) || (isTrue(force) && child.tag !== "svg"))
-        ) {
-          applyNS(child, ns, force);
-        }
-      }
-    }
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (var i = 0, l = vnode.children.length; i < l; i++) {
+              var child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
   }
   // ref #5318
   // necessary to ensure parent re-render when deep bindings like :style and
   // :class are used on slot nodes
   function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-      traverse(data.style);
-    }
-    if (isObject(data.class)) {
-      traverse(data.class);
-    }
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
   }
 
   function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = function (a, b, c, d) {
-      return createElement$1(vm, a, b, c, d, false);
-    };
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) {
-      return createElement$1(vm, a, b, c, d, true);
-    };
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-      defineReactive(
-        vm,
-        "$attrs",
-        (parentData && parentData.attrs) || emptyObject,
-        function () {
-          !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-        },
-        true
-      );
-      defineReactive(
-        vm,
-        "$listeners",
-        options._parentListeners || emptyObject,
-        function () {
-          !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-        },
-        true
-      );
-    }
+      vm._vnode = null; // the root of the child tree
+      vm._staticTrees = null; // v-once cached trees
+      var options = vm.$options;
+      var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      var renderContext = parentVnode && parentVnode.context;
+      vm.$slots = resolveSlots(options._renderChildren, renderContext);
+      vm.$scopedSlots = emptyObject;
+      // bind the createElement fn to this instance
+      // so that we get proper render context inside it.
+      // args order: tag, data, children, normalizationType, alwaysNormalize
+      // internal version is used by render functions compiled from templates
+      // @ts-expect-error
+      vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+      // normalization is always applied for the public version, used in
+      // user-written render functions.
+      // @ts-expect-error
+      vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+      // $attrs & $listeners are exposed for easier HOC creation.
+      // they need to be reactive so that HOCs using them are always updated
+      var parentData = parentVnode && parentVnode.data;
+      /* istanbul ignore else */
+      {
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
+              !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+          }, true);
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
+              !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+          }, true);
+      }
   }
   var currentRenderingInstance = null;
   function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-      return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-      var vm = this;
-      var ref = vm.$options;
-      var render = ref.render;
-      var _parentVnode = ref._parentVnode;
-      if (_parentVnode) {
-        vm.$scopedSlots = normalizeScopedSlots(
-          _parentVnode.data.scopedSlots,
-          vm.$slots,
-          vm.$scopedSlots
-        );
-      }
-      // set parent vnode. this allows render functions to have access
-      // to the data on the placeholder node.
-      vm.$vnode = _parentVnode;
-      // render self
-      var vnode;
-      try {
-        // There's no need to maintain a stack because all render fns are called
-        // separately from one another. Nested component's render fns are called
-        // when parent component is patched.
-        currentRenderingInstance = vm;
-        vnode = render.call(vm._renderProxy, vm.$createElement);
-      } catch (e) {
-        handleError(e, vm, "render");
-        // return error render result,
-        // or previous vnode to prevent render error causing blank component
-        /* istanbul ignore else */
-        if (vm.$options.renderError) {
+      // install runtime convenience helpers
+      installRenderHelpers(Vue.prototype);
+      Vue.prototype.$nextTick = function (fn) {
+          return nextTick(fn, this);
+      };
+      Vue.prototype._render = function () {
+          var vm = this;
+          var ref = vm.$options;
+          var render = ref.render;
+          var _parentVnode = ref._parentVnode;
+          if (_parentVnode) {
+              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+          }
+          // set parent vnode. this allows render functions to have access
+          // to the data on the placeholder node.
+          vm.$vnode = _parentVnode;
+          // render self
+          var vnode;
           try {
-            vnode = vm.$options.renderError.call(
-              vm._renderProxy,
-              vm.$createElement,
-              e
-            );
-          } catch (e$1) {
-            handleError(e$1, vm, "renderError");
-            vnode = vm._vnode;
-          }
-        } else {
-          vnode = vm._vnode;
-        }
-      } finally {
-        currentRenderingInstance = null;
-      }
-      // if the returned array contains only a single node, allow it
-      if (Array.isArray(vnode) && vnode.length === 1) {
-        vnode = vnode[0];
-      }
-      // return empty vnode in case the render function errored out
-      if (!(vnode instanceof VNode)) {
-        if (Array.isArray(vnode)) {
-          warn(
-            "Multiple root nodes returned from render function. Render function " +
-              "should return a single root node.",
-            vm
-          );
-        }
-        vnode = createEmptyVNode();
-      }
-      // set parent
-      vnode.parent = _parentVnode;
-      return vnode;
-    };
+              // There's no need to maintain a stack because all render fns are called
+              // separately from one another. Nested component's render fns are called
+              // when parent component is patched.
+              currentRenderingInstance = vm;
+              vnode = render.call(vm._renderProxy, vm.$createElement);
+          }
+          catch (e) {
+              handleError(e, vm, "render");
+              // return error render result,
+              // or previous vnode to prevent render error causing blank component
+              /* istanbul ignore else */
+              if (vm.$options.renderError) {
+                  try {
+                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                  }
+                  catch (e$1) {
+                      handleError(e$1, vm, "renderError");
+                      vnode = vm._vnode;
+                  }
+              }
+              else {
+                  vnode = vm._vnode;
+              }
+          }
+          finally {
+              currentRenderingInstance = null;
+          }
+          // if the returned array contains only a single node, allow it
+          if (Array.isArray(vnode) && vnode.length === 1) {
+              vnode = vnode[0];
+          }
+          // return empty vnode in case the render function errored out
+          if (!(vnode instanceof VNode)) {
+              if (Array.isArray(vnode)) {
+                  warn('Multiple root nodes returned from render function. Render function ' +
+                      'should return a single root node.', vm);
+              }
+              vnode = createEmptyVNode();
+          }
+          // set parent
+          vnode.parent = _parentVnode;
+          return vnode;
+      };
   }
 
   function ensureCtor(comp, base) {
-    if (
-      comp.__esModule ||
-      (hasSymbol && comp[Symbol.toStringTag] === "Module")
-    ) {
-      comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
+      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+          comp = comp.default;
+      }
+      return isObject(comp) ? base.extend(comp) : comp;
   }
   function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = {
-      data: data,
-      context: context,
-      children: children,
-      tag: tag,
-    };
-    return node;
+      var node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+      return node;
   }
   function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-      return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-      return factory.resolved;
-    }
-    var owner = currentRenderingInstance;
-    if (
-      owner &&
-      isDef(factory.owners) &&
-      factory.owners.indexOf(owner) === -1
-    ) {
-      // already pending
-      factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-      return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-      var owners = (factory.owners = [owner]);
-      var sync = true;
-      var timerLoading = null;
-      var timerTimeout = null;
-      owner.$on("hook:destroyed", function () {
-        return remove$2(owners, owner);
-      });
-      var forceRender = function (renderCompleted) {
-        for (var i = 0, l = owners.length; i < l; i++) {
-          owners[i].$forceUpdate();
-        }
-        if (renderCompleted) {
-          owners.length = 0;
-          if (timerLoading !== null) {
-            clearTimeout(timerLoading);
-            timerLoading = null;
-          }
-          if (timerTimeout !== null) {
-            clearTimeout(timerTimeout);
-            timerTimeout = null;
-          }
-        }
-      };
-      var resolve = once(function (res) {
-        // cache resolved
-        factory.resolved = ensureCtor(res, baseCtor);
-        // invoke callbacks only if this is not a synchronous resolve
-        // (async resolves are shimmed as synchronous during SSR)
-        if (!sync) {
-          forceRender(true);
-        } else {
-          owners.length = 0;
-        }
-      });
-      var reject = once(function (reason) {
-        warn(
-          "Failed to resolve async component: " +
-            String(factory) +
-            (reason ? "\nReason: " + reason : "")
-        );
-        if (isDef(factory.errorComp)) {
-          factory.error = true;
-          forceRender(true);
-        }
-      });
-      var res = factory(resolve, reject);
-      if (isObject(res)) {
-        if (isPromise(res)) {
-          // () => Promise
-          if (isUndef(factory.resolved)) {
-            res.then(resolve, reject);
-          }
-        } else if (isPromise(res.component)) {
-          res.component.then(resolve, reject);
-          if (isDef(res.error)) {
-            factory.errorComp = ensureCtor(res.error, baseCtor);
-          }
-          if (isDef(res.loading)) {
-            factory.loadingComp = ensureCtor(res.loading, baseCtor);
-            if (res.delay === 0) {
-              factory.loading = true;
-            } else {
-              // @ts-expect-error NodeJS timeout type
-              timerLoading = setTimeout(function () {
-                timerLoading = null;
-                if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                  factory.loading = true;
-                  forceRender(false);
-                }
-              }, res.delay || 200);
-            }
-          }
-          if (isDef(res.timeout)) {
-            // @ts-expect-error NodeJS timeout type
-            timerTimeout = setTimeout(function () {
-              timerTimeout = null;
-              if (isUndef(factory.resolved)) {
-                reject("timeout (" + res.timeout + "ms)");
-              }
-            }, res.timeout);
-          }
-        }
-      }
-      sync = false;
-      // return in case resolved synchronously
-      return factory.loading ? factory.loadingComp : factory.resolved;
-    }
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      var owner = currentRenderingInstance;
+      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+          // already pending
+          factory.owners.push(owner);
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+      if (owner && !isDef(factory.owners)) {
+          var owners = (factory.owners = [owner]);
+          var sync = true;
+          var timerLoading = null;
+          var timerTimeout = null;
+          owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
+          var forceRender = function (renderCompleted) {
+              for (var i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
+              }
+              if (renderCompleted) {
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
+                  }
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
+                  }
+              }
+          };
+          var resolve = once(function (res) {
+              // cache resolved
+              factory.resolved = ensureCtor(res, baseCtor);
+              // invoke callbacks only if this is not a synchronous resolve
+              // (async resolves are shimmed as synchronous during SSR)
+              if (!sync) {
+                  forceRender(true);
+              }
+              else {
+                  owners.length = 0;
+              }
+          });
+          var reject = once(function (reason) {
+              warn("Failed to resolve async component: " + (String(factory)) +
+                      (reason ? ("\nReason: " + reason) : ''));
+              if (isDef(factory.errorComp)) {
+                  factory.error = true;
+                  forceRender(true);
+              }
+          });
+          var res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
+                  // () => Promise
+                  if (isUndef(factory.resolved)) {
+                      res.then(resolve, reject);
+                  }
+              }
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
+                  }
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
+                          factory.loading = true;
+                      }
+                      else {
+                          // @ts-expect-error NodeJS timeout type
+                          timerLoading = setTimeout(function () {
+                              timerLoading = null;
+                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                  factory.loading = true;
+                                  forceRender(false);
+                              }
+                          }, res.delay || 200);
+                      }
+                  }
+                  if (isDef(res.timeout)) {
+                      // @ts-expect-error NodeJS timeout type
+                      timerTimeout = setTimeout(function () {
+                          timerTimeout = null;
+                          if (isUndef(factory.resolved)) {
+                              reject(("timeout (" + (res.timeout) + "ms)")
+                                  );
+                          }
+                      }, res.timeout);
+                  }
+              }
+          }
+          sync = false;
+          // return in case resolved synchronously
+          return factory.loading ? factory.loadingComp : factory.resolved;
+      }
   }
 
   function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
   }
 
   function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-      for (var i = 0; i < children.length; i++) {
-        var c = children[i];
-        if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-          return c;
-        }
+      if (Array.isArray(children)) {
+          for (var i = 0; i < children.length; i++) {
+              var c = children[i];
+              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                  return c;
+              }
+          }
       }
-    }
   }
 
   function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    var listeners = vm.$options._parentListeners;
-    if (listeners) {
-      updateComponentListeners(vm, listeners);
-    }
+      vm._events = Object.create(null);
+      vm._hasHookEvent = false;
+      // init parent attached events
+      var listeners = vm.$options._parentListeners;
+      if (listeners) {
+          updateComponentListeners(vm, listeners);
+      }
   }
   var target$1;
   function add$1(event, fn) {
-    target$1.$on(event, fn);
+      target$1.$on(event, fn);
   }
   function remove$1(event, fn) {
-    target$1.$off(event, fn);
+      target$1.$off(event, fn);
   }
   function createOnceHandler$1(event, fn) {
-    var _target = target$1;
-    return function onceHandler() {
-      var res = fn.apply(null, arguments);
-      if (res !== null) {
-        _target.$off(event, onceHandler);
-      }
-    };
+      var _target = target$1;
+      return function onceHandler() {
+          var res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
   }
   function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(
-      listeners,
-      oldListeners || {},
-      add$1,
-      remove$1,
-      createOnceHandler$1,
-      vm
-    );
-    target$1 = undefined;
+      target$1 = vm;
+      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+      target$1 = undefined;
   }
   function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-      var vm = this;
-      if (Array.isArray(event)) {
-        for (var i = 0, l = event.length; i < l; i++) {
-          vm.$on(event[i], fn);
-        }
-      } else {
-        (vm._events[event] || (vm._events[event] = [])).push(fn);
-        // optimize hook:event cost by using a boolean flag marked at registration
-        // instead of a hash lookup
-        if (hookRE.test(event)) {
-          vm._hasHookEvent = true;
-        }
-      }
-      return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-      var vm = this;
-      function on() {
-        vm.$off(event, on);
-        fn.apply(vm, arguments);
-      }
-      on.fn = fn;
-      vm.$on(event, on);
-      return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-      var vm = this;
-      // all
-      if (!arguments.length) {
-        vm._events = Object.create(null);
-        return vm;
-      }
-      // array of events
-      if (Array.isArray(event)) {
-        for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-          vm.$off(event[i$1], fn);
-        }
-        return vm;
-      }
-      // specific event
-      var cbs = vm._events[event];
-      if (!cbs) {
-        return vm;
-      }
-      if (!fn) {
-        vm._events[event] = null;
-        return vm;
-      }
-      // specific handler
-      var cb;
-      var i = cbs.length;
-      while (i--) {
-        cb = cbs[i];
-        if (cb === fn || cb.fn === fn) {
-          cbs.splice(i, 1);
-          break;
-        }
-      }
-      return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-      var vm = this;
-      {
-        var lowerCaseEvent = event.toLowerCase();
-        if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-          tip(
-            'Event "' +
-              lowerCaseEvent +
-              '" is emitted in component ' +
-              formatComponentName(vm) +
-              ' but the handler is registered for "' +
-              event +
-              '". ' +
-              "Note that HTML attributes are case-insensitive and you cannot use " +
-              "v-on to listen to camelCase events when using in-DOM templates. " +
-              'You should probably use "' +
-              hyphenate(event) +
-              '" instead of "' +
-              event +
-              '".'
-          );
-        }
-      }
-      var cbs = vm._events[event];
-      if (cbs) {
-        cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-        var args = toArray(arguments, 1);
-        var info = 'event handler for "' + event + '"';
-        for (var i = 0, l = cbs.length; i < l; i++) {
-          invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-        }
-      }
-      return vm;
-    };
+      var hookRE = /^hook:/;
+      Vue.prototype.$on = function (event, fn) {
+          var vm = this;
+          if (Array.isArray(event)) {
+              for (var i = 0, l = event.length; i < l; i++) {
+                  vm.$on(event[i], fn);
+              }
+          }
+          else {
+              (vm._events[event] || (vm._events[event] = [])).push(fn);
+              // optimize hook:event cost by using a boolean flag marked at registration
+              // instead of a hash lookup
+              if (hookRE.test(event)) {
+                  vm._hasHookEvent = true;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$once = function (event, fn) {
+          var vm = this;
+          function on() {
+              vm.$off(event, on);
+              fn.apply(vm, arguments);
+          }
+          on.fn = fn;
+          vm.$on(event, on);
+          return vm;
+      };
+      Vue.prototype.$off = function (event, fn) {
+          var vm = this;
+          // all
+          if (!arguments.length) {
+              vm._events = Object.create(null);
+              return vm;
+          }
+          // array of events
+          if (Array.isArray(event)) {
+              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
+                  vm.$off(event[i$1], fn);
+              }
+              return vm;
+          }
+          // specific event
+          var cbs = vm._events[event];
+          if (!cbs) {
+              return vm;
+          }
+          if (!fn) {
+              vm._events[event] = null;
+              return vm;
+          }
+          // specific handler
+          var cb;
+          var i = cbs.length;
+          while (i--) {
+              cb = cbs[i];
+              if (cb === fn || cb.fn === fn) {
+                  cbs.splice(i, 1);
+                  break;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$emit = function (event) {
+          var vm = this;
+          {
+              var lowerCaseEvent = event.toLowerCase();
+              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                  tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
+                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
+                      "Note that HTML attributes are case-insensitive and you cannot use " +
+                      "v-on to listen to camelCase events when using in-DOM templates. " +
+                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+              }
+          }
+          var cbs = vm._events[event];
+          if (cbs) {
+              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+              var args = toArray(arguments, 1);
+              var info = "event handler for \"" + event + "\"";
+              for (var i = 0, l = cbs.length; i < l; i++) {
+                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+              }
+          }
+          return vm;
+      };
   }
 
   var activeInstance = null;
   var isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return function () {
-      activeInstance = prevActiveInstance;
-    };
+      var prevActiveInstance = activeInstance;
+      activeInstance = vm;
+      return function () {
+          activeInstance = prevActiveInstance;
+      };
   }
   function initLifecycle(vm) {
-    var options = vm.$options;
-    // locate first non-abstract parent
-    var parent = options.parent;
-    if (parent && !options.abstract) {
-      while (parent.$options.abstract && parent.$parent) {
-        parent = parent.$parent;
-      }
-      parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    // @ts-ignore
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
+      var options = vm.$options;
+      // locate first non-abstract parent
+      var parent = options.parent;
+      if (parent && !options.abstract) {
+          while (parent.$options.abstract && parent.$parent) {
+              parent = parent.$parent;
+          }
+          parent.$children.push(vm);
+      }
+      vm.$parent = parent;
+      vm.$root = parent ? parent.$root : vm;
+      vm.$children = [];
+      vm.$refs = {};
+      // @ts-ignore
+      vm._watcher = null;
+      vm._inactive = null;
+      vm._directInactive = false;
+      vm._isMounted = false;
+      vm._isDestroyed = false;
+      vm._isBeingDestroyed = false;
   }
   function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-      var vm = this;
-      var prevEl = vm.$el;
-      var prevVnode = vm._vnode;
-      var restoreActiveInstance = setActiveInstance(vm);
-      vm._vnode = vnode;
-      // Vue.prototype.__patch__ is injected in entry points
-      // based on the rendering backend used.
-      if (!prevVnode) {
-        // initial render
-        vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-      } else {
-        // updates
-        vm.$el = vm.__patch__(prevVnode, vnode);
-      }
-      restoreActiveInstance();
-      // update __vue__ reference
-      if (prevEl) {
-        prevEl.__vue__ = null;
-      }
-      if (vm.$el) {
-        vm.$el.__vue__ = vm;
-      }
-      // if parent is an HOC, update its $el as well
-      if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-        vm.$parent.$el = vm.$el;
-      }
-      // updated hook is called by the scheduler to ensure that children are
-      // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-      var vm = this;
-      if (vm._watcher) {
-        vm._watcher.update();
-      }
-    };
-    Vue.prototype.$destroy = function () {
-      var vm = this;
-      if (vm._isBeingDestroyed) {
-        return;
-      }
-      callHook$1(vm, "beforeDestroy");
-      vm._isBeingDestroyed = true;
-      // remove self from parent
-      var parent = vm.$parent;
-      // @ts-ignore
-      if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-        remove$2(parent.$children, vm);
+      Vue.prototype._update = function (vnode, hydrating) {
+          var vm = this;
+          var prevEl = vm.$el;
+          var prevVnode = vm._vnode;
+          var restoreActiveInstance = setActiveInstance(vm);
+          vm._vnode = vnode;
+          // Vue.prototype.__patch__ is injected in entry points
+          // based on the rendering backend used.
+          if (!prevVnode) {
+              // initial render
+              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+          }
+          else {
+              // updates
+              vm.$el = vm.__patch__(prevVnode, vnode);
+          }
+          restoreActiveInstance();
+          // update __vue__ reference
+          if (prevEl) {
+              prevEl.__vue__ = null;
+          }
+          if (vm.$el) {
+              vm.$el.__vue__ = vm;
+          }
+          // if parent is an HOC, update its $el as well
+          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+              vm.$parent.$el = vm.$el;
+          }
+          // updated hook is called by the scheduler to ensure that children are
+          // updated in a parent's updated hook.
+      };
+      Vue.prototype.$forceUpdate = function () {
+          var vm = this;
+          if (vm._watcher) {
+              vm._watcher.update();
+          }
+      };
+      Vue.prototype.$destroy = function () {
+          var vm = this;
+          if (vm._isBeingDestroyed) {
+              return;
+          }
+          callHook$1(vm, 'beforeDestroy');
+          vm._isBeingDestroyed = true;
+          // remove self from parent
+          var parent = vm.$parent;
+          // @ts-ignore
+          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+              remove$2(parent.$children, vm);
+          }
+          // teardown watchers
+          if (vm._watcher) {
+              vm._watcher.teardown();
+          }
+          var i = vm._watchers.length;
+          while (i--) {
+              vm._watchers[i].teardown();
+          }
+          // remove reference from data ob
+          // frozen object may not have observer.
+          if (vm._data.__ob__) {
+              vm._data.__ob__.vmCount--;
+          }
+          // call the last hook...
+          vm._isDestroyed = true;
+          // invoke destroy hooks on current rendered tree
+          vm.__patch__(vm._vnode, null);
+          // fire destroyed hook
+          callHook$1(vm, 'destroyed');
+          // turn off all instance listeners.
+          vm.$off();
+          // remove __vue__ reference
+          if (vm.$el) {
+              vm.$el.__vue__ = null;
+          }
+          // release circular reference (#6759)
+          if (vm.$vnode) {
+              // @ts-expect-error null is not undefined
+              vm.$vnode.parent = null;
+          }
+      };
+  }
+  function mountComponent(vm, el, hydrating) {
+      vm.$el = el;
+      if (!vm.$options.render) {
+          // @ts-expect-error invalid type
+          vm.$options.render = createEmptyVNode;
+          {
+              /* istanbul ignore if */
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+                  vm.$options.el ||
+                  el) {
+                  warn('You are using the runtime-only build of Vue where the template ' +
+                      'compiler is not available. Either pre-compile the templates into ' +
+                      'render functions, or use the compiler-included build.', vm);
+              }
+              else {
+                  warn('Failed to mount component: template or render function not defined.', vm);
+              }
+          }
+      }
+      callHook$1(vm, 'beforeMount');
+      var updateComponent;
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+          updateComponent = function () {
+              var name = vm._name;
+              var id = vm._uid;
+              var startTag = "vue-perf-start:" + id;
+              var endTag = "vue-perf-end:" + id;
+              mark(startTag);
+              var vnode = vm._render();
+              mark(endTag);
+              measure(("vue " + name + " render"), startTag, endTag);
+              mark(startTag);
+              vm._update(vnode, hydrating);
+              mark(endTag);
+              measure(("vue " + name + " patch"), startTag, endTag);
+          };
       }
-      // teardown watchers
-      if (vm._watcher) {
-        vm._watcher.teardown();
+      else {
+          updateComponent = function () {
+              vm._update(vm._render(), hydrating);
+          };
       }
-      var i = vm._watchers.length;
-      while (i--) {
-        vm._watchers[i].teardown();
-      }
-      // remove reference from data ob
-      // frozen object may not have observer.
-      if (vm._data.__ob__) {
-        vm._data.__ob__.vmCount--;
-      }
-      // call the last hook...
-      vm._isDestroyed = true;
-      // invoke destroy hooks on current rendered tree
-      vm.__patch__(vm._vnode, null);
-      // fire destroyed hook
-      callHook$1(vm, "destroyed");
-      // turn off all instance listeners.
-      vm.$off();
-      // remove __vue__ reference
-      if (vm.$el) {
-        vm.$el.__vue__ = null;
-      }
-      // release circular reference (#6759)
-      if (vm.$vnode) {
-        // @ts-expect-error null is not undefined
-        vm.$vnode.parent = null;
-      }
-    };
+      // we set this to vm._watcher inside the watcher's constructor
+      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+      // component's mounted hook), which relies on vm._watcher being already defined
+      new Watcher(vm, updateComponent, noop, {
+          before: function before() {
+              if (vm._isMounted && !vm._isDestroyed) {
+                  callHook$1(vm, 'beforeUpdate');
+              }
+          },
+      }, true /* isRenderWatcher */);
+      hydrating = false;
+      // manually mounted instance, call mounted on self
+      // mounted is called for render-created child components in its inserted hook
+      if (vm.$vnode == null) {
+          vm._isMounted = true;
+          callHook$1(vm, 'mounted');
+      }
+      return vm;
   }
-  function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-      // @ts-expect-error invalid type
-      vm.$options.render = createEmptyVNode;
-      {
-        /* istanbul ignore if */
-        if (
-          (vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-          vm.$options.el ||
-          el
-        ) {
-          warn(
-            "You are using the runtime-only build of Vue where the template " +
-              "compiler is not available. Either pre-compile the templates into " +
-              "render functions, or use the compiler-included build.",
-            vm
-          );
-        } else {
-          warn(
-            "Failed to mount component: template or render function not defined.",
-            vm
-          );
-        }
-      }
-    }
-    callHook$1(vm, "beforeMount");
-    var updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-      updateComponent = function () {
-        var name = vm._name;
-        var id = vm._uid;
-        var startTag = "vue-perf-start:" + id;
-        var endTag = "vue-perf-end:" + id;
-        mark(startTag);
-        var vnode = vm._render();
-        mark(endTag);
-        measure("vue " + name + " render", startTag, endTag);
-        mark(startTag);
-        vm._update(vnode, hydrating);
-        mark(endTag);
-        measure("vue " + name + " patch", startTag, endTag);
-      };
-    } else {
-      updateComponent = function () {
-        vm._update(vm._render(), hydrating);
-      };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(
-      vm,
-      updateComponent,
-      noop,
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
       {
-        before: function before() {
-          if (vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, "beforeUpdate");
-          }
-        },
-      },
-      true /* isRenderWatcher */
-    );
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-      vm._isMounted = true;
-      callHook$1(vm, "mounted");
-    }
-    return vm;
-  }
-  function updateChildComponent(
-    vm,
-    propsData,
-    listeners,
-    parentVnode,
-    renderChildren
-  ) {
-    {
-      isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!(
-      (newScopedSlots && !newScopedSlots.$stable) ||
-      (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-      (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-    );
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(
-      renderChildren || // has new static slots
-      vm.$options._renderChildren || // has old static slots
-      hasDynamicScopedSlot
-    );
-    // @ts-ignore
-    vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-      // update child tree's parent
+          isUpdatingChildComponent = true;
+      }
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      var newScopedSlots = parentVnode.data.scopedSlots;
+      var oldScopedSlots = vm.$scopedSlots;
+      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      var needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      // @ts-ignore
+      vm.$options._parentVnode = parentVnode;
       // @ts-ignore
-      vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-      toggleObserving(false);
-      var props = vm._props;
-      var propKeys = vm.$options._propKeys || [];
-      for (var i = 0; i < propKeys.length; i++) {
-        var key = propKeys[i];
-        var propOptions = vm.$options.props; // wtf flow?
-        props[key] = validateProp(key, propOptions, propsData, vm);
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          // @ts-ignore
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      // @ts-ignore
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          var props = vm._props;
+          var propKeys = vm.$options._propKeys || [];
+          for (var i = 0; i < propKeys.length; i++) {
+              var key = propKeys[i];
+              var propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      var oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+      {
+          isUpdatingChildComponent = false;
       }
-      toggleObserving(true);
-      // keep a copy of raw propsData
-      vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-      vm.$forceUpdate();
-    }
-    {
-      isUpdatingChildComponent = false;
-    }
   }
   function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-      if (vm._inactive) {
-        return true;
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              { return true; }
       }
-    }
-    return false;
+      return false;
   }
   function activateChildComponent(vm, direct) {
-    if (direct) {
-      vm._directInactive = false;
-      if (isInInactiveTree(vm)) {
-        return;
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
       }
-    } else if (vm._directInactive) {
-      return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-      vm._inactive = false;
-      for (var i = 0; i < vm.$children.length; i++) {
-        activateChildComponent(vm.$children[i]);
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (var i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook$1(vm, 'activated');
       }
-      callHook$1(vm, "activated");
-    }
   }
   function deactivateChildComponent(vm, direct) {
-    if (direct) {
-      vm._directInactive = true;
-      if (isInInactiveTree(vm)) {
-        return;
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
       }
-    }
-    if (!vm._inactive) {
-      vm._inactive = true;
-      for (var i = 0; i < vm.$children.length; i++) {
-        deactivateChildComponent(vm.$children[i]);
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (var i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook$1(vm, 'deactivated');
       }
-      callHook$1(vm, "deactivated");
-    }
   }
   function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
-    if (handlers) {
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-      }
-    }
-    if (vm._hasHookEvent) {
-      vm.$emit("hook:" + hook);
-    }
-    popTarget();
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      var handlers = vm.$options[hook];
+      var info = hook + " hook";
+      if (handlers) {
+          for (var i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit('hook:' + hook);
+      }
+      popTarget();
   }
 
   var MAX_UPDATE_COUNT = 100;
@@ -4036,12 +3677,12 @@
    * Reset the scheduler's state.
    */
   function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-      circular = {};
-    }
-    waiting = flushing = false;
+      index = queue.length = activatedChildren.length = 0;
+      has = {};
+      {
+          circular = {};
+      }
+      waiting = flushing = false;
   }
   // Async edge case #6566 requires saving the timestamp when event listeners are
   // attached. However, calling performance.now() has a perf overhead especially
@@ -4058,102 +3699,93 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (
-      performance &&
-      typeof performance.now === "function" &&
-      getNow() > document.createEvent("Event").timeStamp
-    ) {
-      // if the event timestamp, although evaluated AFTER the Date.now(), is
-      // smaller than it, it means the event is using a hi-res timestamp,
-      // and we need to use the hi-res version for event listener timestamps as
-      // well.
-      getNow = function () {
-        return performance.now();
-      };
-    }
+      var performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = function () { return performance.now(); };
+      }
   }
   /**
    * Flush both queues and run the watchers.
    */
   function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    var watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort(function (a, b) {
-      return a.id - b.id;
-    });
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-      watcher = queue[index];
-      if (watcher.before) {
-        watcher.before();
-      }
-      id = watcher.id;
-      has[id] = null;
-      watcher.run();
-      // in dev build, check and stop circular updates.
-      if (has[id] != null) {
-        circular[id] = (circular[id] || 0) + 1;
-        if (circular[id] > MAX_UPDATE_COUNT) {
-          warn(
-            "You may have an infinite update loop " +
-              (watcher.user
-                ? 'in watcher with expression "' + watcher.expression + '"'
-                : "in a component render function."),
-            watcher.vm
-          );
-          break;
-        }
-      }
-    }
-    // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-      devtools.emit("flush");
-    }
+      currentFlushTimestamp = getNow();
+      flushing = true;
+      var watcher, id;
+      // Sort queue before flush.
+      // This ensures that:
+      // 1. Components are updated from parent to child. (because parent is always
+      //    created before the child)
+      // 2. A component's user watchers are run before its render watcher (because
+      //    user watchers are created before the render watcher)
+      // 3. If a component is destroyed during a parent component's watcher run,
+      //    its watchers can be skipped.
+      queue.sort(function (a, b) { return a.id - b.id; });
+      // do not cache length because more watchers might be pushed
+      // as we run existing watchers
+      for (index = 0; index < queue.length; index++) {
+          watcher = queue[index];
+          if (watcher.before) {
+              watcher.before();
+          }
+          id = watcher.id;
+          has[id] = null;
+          watcher.run();
+          // in dev build, check and stop circular updates.
+          if (has[id] != null) {
+              circular[id] = (circular[id] || 0) + 1;
+              if (circular[id] > MAX_UPDATE_COUNT) {
+                  warn('You may have an infinite update loop ' +
+                      (watcher.user
+                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
+                          : "in a component render function."), watcher.vm);
+                  break;
+              }
+          }
+      }
+      // keep copies of post queues before resetting state
+      var activatedQueue = activatedChildren.slice();
+      var updatedQueue = queue.slice();
+      resetSchedulerState();
+      // call component updated and activated hooks
+      callActivatedHooks(activatedQueue);
+      callUpdatedHooks(updatedQueue);
+      // devtool hook
+      /* istanbul ignore if */
+      if (devtools && config.devtools) {
+          devtools.emit('flush');
+      }
   }
   function callUpdatedHooks(queue) {
-    var i = queue.length;
-    while (i--) {
-      var watcher = queue[i];
-      var vm = watcher.vm;
-      if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-        callHook$1(vm, "updated");
+      var i = queue.length;
+      while (i--) {
+          var watcher = queue[i];
+          var vm = watcher.vm;
+          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+              callHook$1(vm, 'updated');
+          }
       }
-    }
   }
   /**
    * Queue a kept-alive component that was activated during patch.
    * The queue will be processed after the entire tree has been patched.
    */
   function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+      activatedChildren.push(vm);
   }
   function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
-      queue[i]._inactive = true;
-      activateChildComponent(queue[i], true /* true */);
-    }
+      for (var i = 0; i < queue.length; i++) {
+          queue[i]._inactive = true;
+          activateChildComponent(queue[i], true /* true */);
+      }
   }
   /**
    * Push a watcher into the watcher queue.
@@ -4161,30 +3793,31 @@
    * pushed when the queue is being flushed.
    */
   function queueWatcher(watcher) {
-    var id = watcher.id;
-    if (has[id] == null) {
-      has[id] = true;
-      if (!flushing) {
-        queue.push(watcher);
-      } else {
-        // if already flushing, splice the watcher based on its id
-        // if already past its id, it will be run next immediately.
-        var i = queue.length - 1;
-        while (i > index && queue[i].id > watcher.id) {
-          i--;
-        }
-        queue.splice(i + 1, 0, watcher);
-      }
-      // queue the flush
-      if (!waiting) {
-        waiting = true;
-        if (!config.async) {
-          flushSchedulerQueue();
-          return;
-        }
-        nextTick(flushSchedulerQueue);
+      var id = watcher.id;
+      if (has[id] == null) {
+          has[id] = true;
+          if (!flushing) {
+              queue.push(watcher);
+          }
+          else {
+              // if already flushing, splice the watcher based on its id
+              // if already past its id, it will be run next immediately.
+              var i = queue.length - 1;
+              while (i > index && queue[i].id > watcher.id) {
+                  i--;
+              }
+              queue.splice(i + 1, 0, watcher);
+          }
+          // queue the flush
+          if (!waiting) {
+              waiting = true;
+              if (!config.async) {
+                  flushSchedulerQueue();
+                  return;
+              }
+              nextTick(flushSchedulerQueue);
+          }
       }
-    }
   }
 
   var uid$1 = 0;
@@ -4194,643 +3827,585 @@
    * This is used for both the $watch() api and directives.
    */
   var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-      vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-      this.deep = !!options.deep;
-      this.user = !!options.user;
-      this.lazy = !!options.lazy;
-      this.sync = !!options.sync;
-      this.before = options.before;
-    } else {
-      this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$1; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression = expOrFn.toString();
-    // parse expression for getter
-    if (typeof expOrFn === "function") {
-      this.getter = expOrFn;
-    } else {
-      this.getter = parsePath(expOrFn);
-      if (!this.getter) {
-        this.getter = noop;
-        warn(
-          'Failed watching path: "' +
-            expOrFn +
-            '" ' +
-            "Watcher only accepts simple dot-delimited paths. " +
-            "For full control, use a function instead.",
-          vm
-        );
-      }
-    }
-    this.value = this.lazy ? undefined : this.get();
+      this.vm = vm;
+      if (isRenderWatcher) {
+          vm._watcher = this;
+      }
+      vm._watchers.push(this);
+      // options
+      if (options) {
+          this.deep = !!options.deep;
+          this.user = !!options.user;
+          this.lazy = !!options.lazy;
+          this.sync = !!options.sync;
+          this.before = options.before;
+      }
+      else {
+          this.deep = this.user = this.lazy = this.sync = false;
+      }
+      this.cb = cb;
+      this.id = ++uid$1; // uid for batching
+      this.active = true;
+      this.dirty = this.lazy; // for lazy watchers
+      this.deps = [];
+      this.newDeps = [];
+      this.depIds = new _Set();
+      this.newDepIds = new _Set();
+      this.expression =
+          expOrFn.toString() ;
+      // parse expression for getter
+      if (typeof expOrFn === 'function') {
+          this.getter = expOrFn;
+      }
+      else {
+          this.getter = parsePath(expOrFn);
+          if (!this.getter) {
+              this.getter = noop;
+              warn("Failed watching path: \"" + expOrFn + "\" " +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
+          }
+      }
+      this.value = this.lazy ? undefined : this.get();
   };
   /**
    * Evaluate the getter, and re-collect dependencies.
    */
-  Watcher.prototype.get = function get() {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-      value = this.getter.call(vm, vm);
-    } catch (e) {
-      if (this.user) {
-        handleError(e, vm, 'getter for watcher "' + this.expression + '"');
-      } else {
-        throw e;
-      }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value);
+  Watcher.prototype.get = function get () {
+      pushTarget(this);
+      var value;
+      var vm = this.vm;
+      try {
+          value = this.getter.call(vm, vm);
       }
-      popTarget();
-      this.cleanupDeps();
-    }
-    return value;
+      catch (e) {
+          if (this.user) {
+              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+          }
+          else {
+              throw e;
+          }
+      }
+      finally {
+          // "touch" every property so they are all tracked as
+          // dependencies for deep watching
+          if (this.deep) {
+              traverse(value);
+          }
+          popTarget();
+          this.cleanupDeps();
+      }
+      return value;
   };
   /**
    * Add a dependency to this directive.
    */
-  Watcher.prototype.addDep = function addDep(dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-      this.newDepIds.add(id);
-      this.newDeps.push(dep);
-      if (!this.depIds.has(id)) {
-        dep.addSub(this);
-      }
-    }
+  Watcher.prototype.addDep = function addDep (dep) {
+      var id = dep.id;
+      if (!this.newDepIds.has(id)) {
+          this.newDepIds.add(id);
+          this.newDeps.push(dep);
+          if (!this.depIds.has(id)) {
+              dep.addSub(this);
+          }
+      }
   };
   /**
    * Clean up for dependency collection.
    */
-  Watcher.prototype.cleanupDeps = function cleanupDeps() {
-    var i = this.deps.length;
-    while (i--) {
-      var dep = this.deps[i];
-      if (!this.newDepIds.has(dep.id)) {
-        dep.removeSub(this);
-      }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
+  Watcher.prototype.cleanupDeps = function cleanupDeps () {
+      var i = this.deps.length;
+      while (i--) {
+          var dep = this.deps[i];
+          if (!this.newDepIds.has(dep.id)) {
+              dep.removeSub(this);
+          }
+      }
+      var tmp = this.depIds;
+      this.depIds = this.newDepIds;
+      this.newDepIds = tmp;
+      this.newDepIds.clear();
+      tmp = this.deps;
+      this.deps = this.newDeps;
+      this.newDeps = tmp;
+      this.newDeps.length = 0;
   };
   /**
    * Subscriber interface.
    * Will be called when a dependency changes.
    */
-  Watcher.prototype.update = function update() {
-    /* istanbul ignore else */
-    if (this.lazy) {
-      this.dirty = true;
-    } else if (this.sync) {
-      this.run();
-    } else {
-      queueWatcher(this);
-    }
+  Watcher.prototype.update = function update () {
+      /* istanbul ignore else */
+      if (this.lazy) {
+          this.dirty = true;
+      }
+      else if (this.sync) {
+          this.run();
+      }
+      else {
+          queueWatcher(this);
+      }
   };
   /**
    * Scheduler job interface.
    * Will be called by the scheduler.
    */
-  Watcher.prototype.run = function run() {
-    if (this.active) {
-      var value = this.get();
-      if (
-        value !== this.value ||
-        // Deep watchers and watchers on Object/Arrays should fire even
-        // when the value is the same, because the value may
-        // have mutated.
-        isObject(value) ||
-        this.deep
-      ) {
-        // set new value
-        var oldValue = this.value;
-        this.value = value;
-        if (this.user) {
-          try {
-            this.cb.call(this.vm, value, oldValue);
-          } catch (e) {
-            handleError(
-              e,
-              this.vm,
-              'callback for watcher "' + this.expression + '"'
-            );
-          }
-        } else {
-          this.cb.call(this.vm, value, oldValue);
-        }
-      }
-    }
+  Watcher.prototype.run = function run () {
+      if (this.active) {
+          var value = this.get();
+          if (value !== this.value ||
+              // Deep watchers and watchers on Object/Arrays should fire even
+              // when the value is the same, because the value may
+              // have mutated.
+              isObject(value) ||
+              this.deep) {
+              // set new value
+              var oldValue = this.value;
+              this.value = value;
+              if (this.user) {
+                  try {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+                  catch (e) {
+                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  }
+              }
+              else {
+                  this.cb.call(this.vm, value, oldValue);
+              }
+          }
+      }
   };
   /**
    * Evaluate the value of the watcher.
    * This only gets called for lazy watchers.
    */
-  Watcher.prototype.evaluate = function evaluate() {
-    this.value = this.get();
-    this.dirty = false;
+  Watcher.prototype.evaluate = function evaluate () {
+      this.value = this.get();
+      this.dirty = false;
   };
   /**
    * Depend on all deps collected by this watcher.
    */
-  Watcher.prototype.depend = function depend() {
-    var i = this.deps.length;
-    while (i--) {
-      this.deps[i].depend();
-    }
+  Watcher.prototype.depend = function depend () {
+      var i = this.deps.length;
+      while (i--) {
+          this.deps[i].depend();
+      }
   };
   /**
    * Remove self from all dependencies' subscriber list.
    */
-  Watcher.prototype.teardown = function teardown() {
-    if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed.
-      if (!this.vm._isBeingDestroyed) {
-        remove$2(this.vm._watchers, this);
+  Watcher.prototype.teardown = function teardown () {
+      if (this.active) {
+          // remove self from vm's watcher list
+          // this is a somewhat expensive operation so we skip it
+          // if the vm is being destroyed.
+          if (!this.vm._isBeingDestroyed) {
+              remove$2(this.vm._watchers, this);
+          }
+          var i = this.deps.length;
+          while (i--) {
+              this.deps[i].removeSub(this);
+          }
+          this.active = false;
       }
-      var i = this.deps.length;
-      while (i--) {
-        this.deps[i].removeSub(this);
-      }
-      this.active = false;
-    }
   };
 
   var sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
+      enumerable: true,
+      configurable: true,
+      get: noop,
+      set: noop,
   };
   function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-      return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-      this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
+      sharedPropertyDefinition.get = function proxyGetter() {
+          return this[sourceKey][key];
+      };
+      sharedPropertyDefinition.set = function proxySetter(val) {
+          this[sourceKey][key] = val;
+      };
+      Object.defineProperty(target, key, sharedPropertyDefinition);
   }
   function initState(vm) {
-    vm._watchers = [];
-    var opts = vm.$options;
-    if (opts.props) {
-      initProps$1(vm, opts.props);
-    }
-    if (opts.methods) {
-      initMethods(vm, opts.methods);
-    }
-    if (opts.data) {
-      initData(vm);
-    } else {
-      observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed) {
-      initComputed$1(vm, opts.computed);
-    }
-    if (opts.watch && opts.watch !== nativeWatch) {
-      initWatch(vm, opts.watch);
-    }
+      vm._watchers = [];
+      var opts = vm.$options;
+      if (opts.props)
+          { initProps$1(vm, opts.props); }
+      if (opts.methods)
+          { initMethods(vm, opts.methods); }
+      if (opts.data) {
+          initData(vm);
+      }
+      else {
+          observe((vm._data = {}), true /* asRootData */);
+      }
+      if (opts.computed)
+          { initComputed$1(vm, opts.computed); }
+      if (opts.watch && opts.watch !== nativeWatch) {
+          initWatch(vm, opts.watch);
+      }
   }
   function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-      toggleObserving(false);
-    }
-    var loop = function (key) {
-      keys.push(key);
-      var value = validateProp(key, propsOptions, propsData, vm);
-      /* istanbul ignore else */
-      {
-        var hyphenatedKey = hyphenate(key);
-        if (
-          isReservedAttribute(hyphenatedKey) ||
-          config.isReservedAttr(hyphenatedKey)
-        ) {
-          warn(
-            '"' +
-              hyphenatedKey +
-              '" is a reserved attribute and cannot be used as component prop.',
-            vm
-          );
-        }
-        defineReactive(props, key, value, function () {
-          if (!isRoot && !isUpdatingChildComponent) {
-            warn(
-              "Avoid mutating a prop directly since the value will be " +
-                "overwritten whenever the parent component re-renders. " +
-                "Instead, use a data or computed property based on the prop's " +
-                'value. Prop being mutated: "' +
-                key +
-                '"',
-              vm
-            );
-          }
-        });
-      }
-      // static props are already proxied on the component's prototype
-      // during Vue.extend(). We only need to proxy props defined at
-      // instantiation here.
-      if (!(key in vm)) {
-        proxy(vm, "_props", key);
-      }
-    };
+      var propsData = vm.$options.propsData || {};
+      var props = (vm._props = {});
+      // cache prop keys so that future props updates can iterate using Array
+      // instead of dynamic object key enumeration.
+      var keys = (vm.$options._propKeys = []);
+      var isRoot = !vm.$parent;
+      // root instance props should be converted
+      if (!isRoot) {
+          toggleObserving(false);
+      }
+      var loop = function ( key ) {
+          keys.push(key);
+          var value = validateProp(key, propsOptions, propsData, vm);
+          /* istanbul ignore else */
+          {
+              var hyphenatedKey = hyphenate(key);
+              if (isReservedAttribute(hyphenatedKey) ||
+                  config.isReservedAttr(hyphenatedKey)) {
+                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+              }
+              defineReactive(props, key, value, function () {
+                  if (!isRoot && !isUpdatingChildComponent) {
+                      warn("Avoid mutating a prop directly since the value will be " +
+                          "overwritten whenever the parent component re-renders. " +
+                          "Instead, use a data or computed property based on the prop's " +
+                          "value. Prop being mutated: \"" + key + "\"", vm);
+                  }
+              });
+          }
+          // static props are already proxied on the component's prototype
+          // during Vue.extend(). We only need to proxy props defined at
+          // instantiation here.
+          if (!(key in vm)) {
+              proxy(vm, "_props", key);
+          }
+      };
 
-    for (var key in propsOptions) loop(key);
-    toggleObserving(true);
+      for (var key in propsOptions) loop( key );
+      toggleObserving(true);
   }
   function initData(vm) {
-    var data = vm.$options.data;
-    data = vm._data =
-      typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-      data = {};
-      warn(
-        "data functions should return an object:\n" +
-          "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function",
-        vm
-      );
-    }
-    // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
-    while (i--) {
-      var key = keys[i];
-      {
-        if (methods && hasOwn(methods, key)) {
-          warn(
-            'Method "' + key + '" has already been defined as a data property.',
-            vm
-          );
-        }
-      }
-      if (props && hasOwn(props, key)) {
-        warn(
-          'The data property "' +
-            key +
-            '" is already declared as a prop. ' +
-            "Use prop default value instead.",
-          vm
-        );
-      } else if (!isReserved(key)) {
-        proxy(vm, "_data", key);
-      }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
+      var data = vm.$options.data;
+      data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+      if (!isPlainObject(data)) {
+          data = {};
+          warn('data functions should return an object:\n' +
+                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+      }
+      // proxy data on instance
+      var keys = Object.keys(data);
+      var props = vm.$options.props;
+      var methods = vm.$options.methods;
+      var i = keys.length;
+      while (i--) {
+          var key = keys[i];
+          {
+              if (methods && hasOwn(methods, key)) {
+                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+              }
+          }
+          if (props && hasOwn(props, key)) {
+              warn("The data property \"" + key + "\" is already declared as a prop. " +
+                      "Use prop default value instead.", vm);
+          }
+          else if (!isReserved(key)) {
+              proxy(vm, "_data", key);
+          }
+      }
+      // observe data
+      observe(data, true /* asRootData */);
   }
   function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-      return data.call(vm, vm);
-    } catch (e) {
-      handleError(e, vm, "data()");
-      return {};
-    } finally {
-      popTarget();
-    }
+      // #7573 disable dep collection when invoking data getters
+      pushTarget();
+      try {
+          return data.call(vm, vm);
+      }
+      catch (e) {
+          handleError(e, vm, "data()");
+          return {};
+      }
+      finally {
+          popTarget();
+      }
   }
   var computedWatcherOptions = { lazy: true };
   function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-      var userDef = computed[key];
-      var getter = typeof userDef === "function" ? userDef : userDef.get;
-      if (getter == null) {
-        warn('Getter is missing for computed property "' + key + '".', vm);
-      }
-      if (!isSSR) {
-        // create internal watcher for the computed property.
-        watchers[key] = new Watcher(
-          vm,
-          getter || noop,
-          noop,
-          computedWatcherOptions
-        );
-      }
-      // component-defined computed properties are already defined on the
-      // component prototype. We only need to define computed properties defined
-      // at instantiation here.
-      if (!(key in vm)) {
-        defineComputed(vm, key, userDef);
-      } else {
-        if (key in vm.$data) {
-          warn(
-            'The computed property "' + key + '" is already defined in data.',
-            vm
-          );
-        } else if (vm.$options.props && key in vm.$options.props) {
-          warn(
-            'The computed property "' + key + '" is already defined as a prop.',
-            vm
-          );
-        }
+      // $flow-disable-line
+      var watchers = (vm._computedWatchers = Object.create(null));
+      // computed properties are just getters during SSR
+      var isSSR = isServerRendering();
+      for (var key in computed) {
+          var userDef = computed[key];
+          var getter = typeof userDef === 'function' ? userDef : userDef.get;
+          if (getter == null) {
+              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+          }
+          if (!isSSR) {
+              // create internal watcher for the computed property.
+              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+          }
+          // component-defined computed properties are already defined on the
+          // component prototype. We only need to define computed properties defined
+          // at instantiation here.
+          if (!(key in vm)) {
+              defineComputed(vm, key, userDef);
+          }
+          else {
+              if (key in vm.$data) {
+                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+              }
+              else if (vm.$options.props && key in vm.$options.props) {
+                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+              }
+          }
       }
-    }
   }
   function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-      sharedPropertyDefinition.get = shouldCache
-        ? createComputedGetter(key)
-        : createGetterInvoker(userDef);
-      sharedPropertyDefinition.set = noop;
-    } else {
-      sharedPropertyDefinition.get = userDef.get
-        ? shouldCache && userDef.cache !== false
-          ? createComputedGetter(key)
-          : createGetterInvoker(userDef.get)
-        : noop;
-      sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-      sharedPropertyDefinition.set = function () {
-        warn(
-          'Computed property "' +
-            key +
-            '" was assigned to but it has no setter.',
-          this
-        );
-      };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
+      var shouldCache = !isServerRendering();
+      if (typeof userDef === 'function') {
+          sharedPropertyDefinition.get = shouldCache
+              ? createComputedGetter(key)
+              : createGetterInvoker(userDef);
+          sharedPropertyDefinition.set = noop;
+      }
+      else {
+          sharedPropertyDefinition.get = userDef.get
+              ? shouldCache && userDef.cache !== false
+                  ? createComputedGetter(key)
+                  : createGetterInvoker(userDef.get)
+              : noop;
+          sharedPropertyDefinition.set = userDef.set || noop;
+      }
+      if (sharedPropertyDefinition.set === noop) {
+          sharedPropertyDefinition.set = function () {
+              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+          };
+      }
+      Object.defineProperty(target, key, sharedPropertyDefinition);
   }
   function createComputedGetter(key) {
-    return function computedGetter() {
-      var watcher = this._computedWatchers && this._computedWatchers[key];
-      if (watcher) {
-        if (watcher.dirty) {
-          watcher.evaluate();
-        }
-        if (Dep.target) {
-          watcher.depend();
-        }
-        return watcher.value;
-      }
-    };
+      return function computedGetter() {
+          var watcher = this._computedWatchers && this._computedWatchers[key];
+          if (watcher) {
+              if (watcher.dirty) {
+                  watcher.evaluate();
+              }
+              if (Dep.target) {
+                  watcher.depend();
+              }
+              return watcher.value;
+          }
+      };
   }
   function createGetterInvoker(fn) {
-    return function computedGetter() {
-      return fn.call(this, this);
-    };
+      return function computedGetter() {
+          return fn.call(this, this);
+      };
   }
   function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
-      {
-        if (typeof methods[key] !== "function") {
-          warn(
-            'Method "' +
-              key +
-              '" has type "' +
-              typeof methods[key] +
-              '" in the component definition. ' +
-              "Did you reference the function correctly?",
-            vm
-          );
-        }
-        if (props && hasOwn(props, key)) {
-          warn('Method "' + key + '" has already been defined as a prop.', vm);
-        }
-        if (key in vm && isReserved(key)) {
-          warn(
-            'Method "' +
-              key +
-              '" conflicts with an existing Vue instance method. ' +
-              "Avoid defining component methods that start with _ or $."
-          );
-        }
+      var props = vm.$options.props;
+      for (var key in methods) {
+          {
+              if (typeof methods[key] !== 'function') {
+                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
+                      "Did you reference the function correctly?", vm);
+              }
+              if (props && hasOwn(props, key)) {
+                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+              }
+              if (key in vm && isReserved(key)) {
+                  warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
+                      "Avoid defining component methods that start with _ or $.");
+              }
+          }
+          vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
       }
-      vm[key] =
-        typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-    }
   }
   function initWatch(vm, watch) {
-    for (var key in watch) {
-      var handler = watch[key];
-      if (Array.isArray(handler)) {
-        for (var i = 0; i < handler.length; i++) {
-          createWatcher(vm, key, handler[i]);
-        }
-      } else {
-        createWatcher(vm, key, handler);
+      for (var key in watch) {
+          var handler = watch[key];
+          if (Array.isArray(handler)) {
+              for (var i = 0; i < handler.length; i++) {
+                  createWatcher(vm, key, handler[i]);
+              }
+          }
+          else {
+              createWatcher(vm, key, handler);
+          }
       }
-    }
   }
   function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-      options = handler;
-      handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-      handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
+      if (isPlainObject(handler)) {
+          options = handler;
+          handler = handler.handler;
+      }
+      if (typeof handler === 'string') {
+          handler = vm[handler];
+      }
+      return vm.$watch(expOrFn, handler, options);
   }
   function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    var dataDef = {};
-    dataDef.get = function () {
-      return this._data;
-    };
-    var propsDef = {};
-    propsDef.get = function () {
-      return this._props;
-    };
-    {
-      dataDef.set = function () {
-        warn(
-          "Avoid replacing instance root $data. " +
-            "Use nested data properties instead.",
-          this
-        );
+      // flow somehow has problems with directly declared definition object
+      // when using Object.defineProperty, so we have to procedurally build up
+      // the object here.
+      var dataDef = {};
+      dataDef.get = function () {
+          return this._data;
       };
-      propsDef.set = function () {
-        warn("$props is readonly.", this);
+      var propsDef = {};
+      propsDef.get = function () {
+          return this._props;
       };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-      var vm = this;
-      if (isPlainObject(cb)) {
-        return createWatcher(vm, expOrFn, cb, options);
-      }
-      options = options || {};
-      options.user = true;
-      var watcher = new Watcher(vm, expOrFn, cb, options);
-      if (options.immediate) {
-        pushTarget();
-        try {
-          cb.call(vm, watcher.value);
-        } catch (error) {
-          handleError(
-            error,
-            vm,
-            'callback for immediate watcher "' + watcher.expression + '"'
-          );
-        }
-        popTarget();
+      {
+          dataDef.set = function () {
+              warn('Avoid replacing instance root $data. ' +
+                  'Use nested data properties instead.', this);
+          };
+          propsDef.set = function () {
+              warn("$props is readonly.", this);
+          };
       }
-      return function unwatchFn() {
-        watcher.teardown();
+      Object.defineProperty(Vue.prototype, '$data', dataDef);
+      Object.defineProperty(Vue.prototype, '$props', propsDef);
+      Vue.prototype.$set = set;
+      Vue.prototype.$delete = del;
+      Vue.prototype.$watch = function (expOrFn, cb, options) {
+          var vm = this;
+          if (isPlainObject(cb)) {
+              return createWatcher(vm, expOrFn, cb, options);
+          }
+          options = options || {};
+          options.user = true;
+          var watcher = new Watcher(vm, expOrFn, cb, options);
+          if (options.immediate) {
+              pushTarget();
+              try {
+                  cb.call(vm, watcher.value);
+              }
+              catch (error) {
+                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
+              }
+              popTarget();
+          }
+          return function unwatchFn() {
+              watcher.teardown();
+          };
       };
-    };
   }
 
   var uid = 0;
   function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-      var vm = this;
-      // a uid
-      vm._uid = uid++;
-      var startTag, endTag;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        startTag = "vue-perf-start:" + vm._uid;
-        endTag = "vue-perf-end:" + vm._uid;
-        mark(startTag);
-      }
-      // a flag to avoid this being observed
-      vm._isVue = true;
-      // merge options
-      if (options && options._isComponent) {
-        // optimize internal component instantiation
-        // since dynamic options merging is pretty slow, and none of the
-        // internal component options needs special treatment.
-        initInternalComponent(vm, options);
-      } else {
-        vm.$options = mergeOptions(
-          resolveConstructorOptions(vm.constructor),
-          options || {},
-          vm
-        );
-      }
-      /* istanbul ignore else */
-      {
-        initProxy(vm);
-      }
-      // expose real self
-      vm._self = vm;
-      initLifecycle(vm);
-      initEvents(vm);
-      initRender(vm);
-      callHook$1(vm, "beforeCreate");
-      initInjections(vm); // resolve injections before data/props
-      initState(vm);
-      initProvide(vm); // resolve provide after data/props
-      callHook$1(vm, "created");
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-        vm._name = formatComponentName(vm, false);
-        mark(endTag);
-        measure("vue " + vm._name + " init", startTag, endTag);
-      }
-      if (vm.$options.el) {
-        vm.$mount(vm.$options.el);
-      }
-    };
+      Vue.prototype._init = function (options) {
+          var vm = this;
+          // a uid
+          vm._uid = uid++;
+          var startTag, endTag;
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              startTag = "vue-perf-start:" + (vm._uid);
+              endTag = "vue-perf-end:" + (vm._uid);
+              mark(startTag);
+          }
+          // a flag to avoid this being observed
+          vm._isVue = true;
+          // merge options
+          if (options && options._isComponent) {
+              // optimize internal component instantiation
+              // since dynamic options merging is pretty slow, and none of the
+              // internal component options needs special treatment.
+              initInternalComponent(vm, options);
+          }
+          else {
+              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+          }
+          /* istanbul ignore else */
+          {
+              initProxy(vm);
+          }
+          // expose real self
+          vm._self = vm;
+          initLifecycle(vm);
+          initEvents(vm);
+          initRender(vm);
+          callHook$1(vm, 'beforeCreate');
+          initInjections(vm); // resolve injections before data/props
+          initState(vm);
+          initProvide(vm); // resolve provide after data/props
+          callHook$1(vm, 'created');
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              vm._name = formatComponentName(vm, false);
+              mark(endTag);
+              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+          }
+          if (vm.$options.el) {
+              vm.$mount(vm.$options.el);
+          }
+      };
   }
   function initInternalComponent(vm, options) {
-    // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-      opts.render = options.render;
-      opts.staticRenderFns = options.staticRenderFns;
-    }
+      // @ts-ignore
+      var opts = (vm.$options = Object.create(vm.constructor.options));
+      // doing this because it's faster than dynamic enumeration.
+      var parentVnode = options._parentVnode;
+      opts.parent = options.parent;
+      opts._parentVnode = parentVnode;
+      var vnodeComponentOptions = parentVnode.componentOptions;
+      opts.propsData = vnodeComponentOptions.propsData;
+      opts._parentListeners = vnodeComponentOptions.listeners;
+      opts._renderChildren = vnodeComponentOptions.children;
+      opts._componentTag = vnodeComponentOptions.tag;
+      if (options.render) {
+          opts.render = options.render;
+          opts.staticRenderFns = options.staticRenderFns;
+      }
   }
   function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
-    if (Ctor.super) {
-      var superOptions = resolveConstructorOptions(Ctor.super);
-      var cachedSuperOptions = Ctor.superOptions;
-      if (superOptions !== cachedSuperOptions) {
-        // super option changed,
-        // need to resolve new options.
-        Ctor.superOptions = superOptions;
-        // check if there are any late-modified/attached options (#4976)
-        var modifiedOptions = resolveModifiedOptions(Ctor);
-        // update base extend options
-        if (modifiedOptions) {
-          extend(Ctor.extendOptions, modifiedOptions);
-        }
-        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-        if (options.name) {
-          options.components[options.name] = Ctor;
-        }
-      }
-    }
-    return options;
+      var options = Ctor.options;
+      if (Ctor.super) {
+          var superOptions = resolveConstructorOptions(Ctor.super);
+          var cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              var modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
   }
   function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
-      if (latest[key] !== sealed[key]) {
-        if (!modified) {
-          modified = {};
-        }
-        modified[key] = latest[key];
-      }
-    }
-    return modified;
+      var modified;
+      var latest = Ctor.options;
+      var sealed = Ctor.sealedOptions;
+      for (var key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  { modified = {}; }
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
   }
 
   function Vue(options) {
-    if (!(this instanceof Vue)) {
-      warn("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
+      if (!(this instanceof Vue)) {
+          warn('Vue is a constructor and should be called with the `new` keyword');
+      }
+      this._init(options);
   }
   //@ts-ignore
   initMixin$1(Vue);
@@ -4844,571 +4419,547 @@
   renderMixin(Vue);
 
   function initUse(Vue) {
-    Vue.use = function (plugin) {
-      var installedPlugins =
-        this._installedPlugins || (this._installedPlugins = []);
-      if (installedPlugins.indexOf(plugin) > -1) {
-        return this;
-      }
-      // additional parameters
-      var args = toArray(arguments, 1);
-      args.unshift(this);
-      if (typeof plugin.install === "function") {
-        plugin.install.apply(plugin, args);
-      } else if (typeof plugin === "function") {
-        plugin.apply(null, args);
-      }
-      installedPlugins.push(plugin);
-      return this;
-    };
+      Vue.use = function (plugin) {
+          var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          if (installedPlugins.indexOf(plugin) > -1) {
+              return this;
+          }
+          // additional parameters
+          var args = toArray(arguments, 1);
+          args.unshift(this);
+          if (typeof plugin.install === 'function') {
+              plugin.install.apply(plugin, args);
+          }
+          else if (typeof plugin === 'function') {
+              plugin.apply(null, args);
+          }
+          installedPlugins.push(plugin);
+          return this;
+      };
   }
 
   function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-      this.options = mergeOptions(this.options, mixin);
-      return this;
-    };
+      Vue.mixin = function (mixin) {
+          this.options = mergeOptions(this.options, mixin);
+          return this;
+      };
   }
 
   function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    var cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-      extendOptions = extendOptions || {};
-      var Super = this;
-      var SuperId = Super.cid;
-      var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-      if (cachedCtors[SuperId]) {
-        return cachedCtors[SuperId];
-      }
-      var name = extendOptions.name || Super.options.name;
-      if (name) {
-        validateComponentName(name);
-      }
-      var Sub = function VueComponent(options) {
-        this._init(options);
+      /**
+       * Each instance constructor, including Vue, has a unique
+       * cid. This enables us to create wrapped "child
+       * constructors" for prototypal inheritance and cache them.
+       */
+      Vue.cid = 0;
+      var cid = 1;
+      /**
+       * Class inheritance
+       */
+      Vue.extend = function (extendOptions) {
+          extendOptions = extendOptions || {};
+          var Super = this;
+          var SuperId = Super.cid;
+          var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          if (cachedCtors[SuperId]) {
+              return cachedCtors[SuperId];
+          }
+          var name = extendOptions.name || Super.options.name;
+          if (name) {
+              validateComponentName(name);
+          }
+          var Sub = function VueComponent(options) {
+              this._init(options);
+          };
+          Sub.prototype = Object.create(Super.prototype);
+          Sub.prototype.constructor = Sub;
+          Sub.cid = cid++;
+          Sub.options = mergeOptions(Super.options, extendOptions);
+          Sub['super'] = Super;
+          // For props and computed properties, we define the proxy getters on
+          // the Vue instances at extension time, on the extended prototype. This
+          // avoids Object.defineProperty calls for each instance created.
+          if (Sub.options.props) {
+              initProps(Sub);
+          }
+          if (Sub.options.computed) {
+              initComputed(Sub);
+          }
+          // allow further extension/mixin/plugin usage
+          Sub.extend = Super.extend;
+          Sub.mixin = Super.mixin;
+          Sub.use = Super.use;
+          // create asset registers, so extended classes
+          // can have their private assets too.
+          ASSET_TYPES.forEach(function (type) {
+              Sub[type] = Super[type];
+          });
+          // enable recursive self-lookup
+          if (name) {
+              Sub.options.components[name] = Sub;
+          }
+          // keep a reference to the super options at extension time.
+          // later at instantiation we can check if Super's options have
+          // been updated.
+          Sub.superOptions = Super.options;
+          Sub.extendOptions = extendOptions;
+          Sub.sealedOptions = extend({}, Sub.options);
+          // cache constructor
+          cachedCtors[SuperId] = Sub;
+          return Sub;
       };
-      Sub.prototype = Object.create(Super.prototype);
-      Sub.prototype.constructor = Sub;
-      Sub.cid = cid++;
-      Sub.options = mergeOptions(Super.options, extendOptions);
-      Sub["super"] = Super;
-      // For props and computed properties, we define the proxy getters on
-      // the Vue instances at extension time, on the extended prototype. This
-      // avoids Object.defineProperty calls for each instance created.
-      if (Sub.options.props) {
-        initProps(Sub);
-      }
-      if (Sub.options.computed) {
-        initComputed(Sub);
-      }
-      // allow further extension/mixin/plugin usage
-      Sub.extend = Super.extend;
-      Sub.mixin = Super.mixin;
-      Sub.use = Super.use;
-      // create asset registers, so extended classes
-      // can have their private assets too.
-      ASSET_TYPES.forEach(function (type) {
-        Sub[type] = Super[type];
-      });
-      // enable recursive self-lookup
-      if (name) {
-        Sub.options.components[name] = Sub;
-      }
-      // keep a reference to the super options at extension time.
-      // later at instantiation we can check if Super's options have
-      // been updated.
-      Sub.superOptions = Super.options;
-      Sub.extendOptions = extendOptions;
-      Sub.sealedOptions = extend({}, Sub.options);
-      // cache constructor
-      cachedCtors[SuperId] = Sub;
-      return Sub;
-    };
   }
   function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-      proxy(Comp.prototype, "_props", key);
-    }
+      var props = Comp.options.props;
+      for (var key in props) {
+          proxy(Comp.prototype, "_props", key);
+      }
   }
   function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
-      defineComputed(Comp.prototype, key, computed[key]);
-    }
+      var computed = Comp.options.computed;
+      for (var key in computed) {
+          defineComputed(Comp.prototype, key, computed[key]);
+      }
   }
 
   function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach(function (type) {
-      // @ts-expect-error function is not exact same type
-      Vue[type] = function (id, definition) {
-        if (!definition) {
-          return this.options[type + "s"][id];
-        } else {
-          /* istanbul ignore if */
-          if (type === "component") {
-            validateComponentName(id);
-          }
-          if (type === "component" && isPlainObject(definition)) {
-            // @ts-expect-error
-            definition.name = definition.name || id;
-            definition = this.options._base.extend(definition);
-          }
-          if (type === "directive" && typeof definition === "function") {
-            definition = { bind: definition, update: definition };
-          }
-          this.options[type + "s"][id] = definition;
-          return definition;
-        }
-      };
-    });
+      /**
+       * Create asset registration methods.
+       */
+      ASSET_TYPES.forEach(function (type) {
+          // @ts-expect-error function is not exact same type
+          Vue[type] = function (id, definition) {
+              if (!definition) {
+                  return this.options[type + 's'][id];
+              }
+              else {
+                  /* istanbul ignore if */
+                  if (type === 'component') {
+                      validateComponentName(id);
+                  }
+                  if (type === 'component' && isPlainObject(definition)) {
+                      // @ts-expect-error
+                      definition.name = definition.name || id;
+                      definition = this.options._base.extend(definition);
+                  }
+                  if (type === 'directive' && typeof definition === 'function') {
+                      definition = { bind: definition, update: definition };
+                  }
+                  this.options[type + 's'][id] = definition;
+                  return definition;
+              }
+          };
+      });
   }
 
   function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
+      return opts && (opts.Ctor.options.name || opts.tag);
   }
   function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-      return pattern.indexOf(name) > -1;
-    } else if (typeof pattern === "string") {
-      return pattern.split(",").indexOf(name) > -1;
-    } else if (isRegExp(pattern)) {
-      return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
+      if (Array.isArray(pattern)) {
+          return pattern.indexOf(name) > -1;
+      }
+      else if (typeof pattern === 'string') {
+          return pattern.split(',').indexOf(name) > -1;
+      }
+      else if (isRegExp(pattern)) {
+          return pattern.test(name);
+      }
+      /* istanbul ignore next */
+      return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-      var cachedNode = cache[key];
-      if (cachedNode) {
-        var name = getComponentName(cachedNode.componentOptions);
-        if (name && !filter(name)) {
-          pruneCacheEntry(cache, key, keys, _vnode);
-        }
-      }
-    }
+      var cache = keepAliveInstance.cache;
+      var keys = keepAliveInstance.keys;
+      var _vnode = keepAliveInstance._vnode;
+      for (var key in cache) {
+          var cachedNode = cache[key];
+          if (cachedNode) {
+              var name = getComponentName(cachedNode.componentOptions);
+              if (name && !filter(name)) {
+                  pruneCacheEntry(cache, key, keys, _vnode);
+              }
+          }
+      }
   }
   function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-      //@ts-expect-error has void type
-      cached.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
+      var cached = cache[key];
+      if (cached && (!current || cached.tag !== current.tag)) {
+          //@ts-expect-error has void type
+          cached.componentInstance.$destroy();
+      }
+      cache[key] = null;
+      remove$2(keys, key);
   }
   var patternTypes = [String, RegExp, Array];
   // TODO use defineComponent
   var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-      include: patternTypes,
-      exclude: patternTypes,
-      max: [String, Number],
-    },
-    created: function created() {
-      this.cache = Object.create(null);
-      this.keys = [];
-    },
-    destroyed: function destroyed() {
-      for (var key in this.cache) {
-        pruneCacheEntry(this.cache, key, this.keys);
-      }
-    },
-    mounted: function mounted() {
-      var this$1 = this;
+      name: 'keep-alive',
+      abstract: true,
+      props: {
+          include: patternTypes,
+          exclude: patternTypes,
+          max: [String, Number],
+      },
+      created: function created() {
+          this.cache = Object.create(null);
+          this.keys = [];
+      },
+      destroyed: function destroyed() {
+          for (var key in this.cache) {
+              pruneCacheEntry(this.cache, key, this.keys);
+          }
+      },
+      mounted: function mounted() {
+          var this$1 = this;
 
-      this.$watch("include", function (val) {
-        pruneCache(this$1, function (name) {
-          return matches(val, name);
-        });
-      });
-      this.$watch("exclude", function (val) {
-        pruneCache(this$1, function (name) {
-          return !matches(val, name);
-        });
-      });
-    },
-    render: function render() {
-      var slot = this.$slots.default;
-      var vnode = getFirstComponentChild(slot);
-      var componentOptions = vnode && vnode.componentOptions;
-      if (componentOptions) {
-        // check pattern
-        var name = getComponentName(componentOptions);
-        var ref = this;
-        var include = ref.include;
-        var exclude = ref.exclude;
-        if (
-          // not included
-          (include && (!name || !matches(include, name))) ||
-          // excluded
-          (exclude && name && matches(exclude, name))
-        ) {
-          return vnode;
-        }
-        var ref$1 = this;
-        var cache = ref$1.cache;
-        var keys = ref$1.keys;
-        var key =
-          vnode.key == null
-            ? // same constructor may get registered as different local components
-              // so cid alone is not enough (#3269)
-              componentOptions.Ctor.cid +
-              (componentOptions.tag ? "::" + componentOptions.tag : "")
-            : vnode.key;
-        if (cache[key]) {
-          vnode.componentInstance = cache[key].componentInstance;
-          // make current key freshest
-          remove$2(keys, key);
-          keys.push(key);
-        } else {
-          cache[key] = vnode;
-          keys.push(key);
-          // prune oldest entry
-          if (this.max && keys.length > parseInt(this.max)) {
-            pruneCacheEntry(cache, keys[0], keys, this._vnode);
+          this.$watch('include', function (val) {
+              pruneCache(this$1, function (name) { return matches(val, name); });
+          });
+          this.$watch('exclude', function (val) {
+              pruneCache(this$1, function (name) { return !matches(val, name); });
+          });
+      },
+      render: function render() {
+          var slot = this.$slots.default;
+          var vnode = getFirstComponentChild(slot);
+          var componentOptions = vnode && vnode.componentOptions;
+          if (componentOptions) {
+              // check pattern
+              var name = getComponentName(componentOptions);
+              var ref = this;
+              var include = ref.include;
+              var exclude = ref.exclude;
+              if (
+              // not included
+              (include && (!name || !matches(include, name))) ||
+                  // excluded
+                  (exclude && name && matches(exclude, name))) {
+                  return vnode;
+              }
+              var ref$1 = this;
+              var cache = ref$1.cache;
+              var keys = ref$1.keys;
+              var key = vnode.key == null
+                  ? // same constructor may get registered as different local components
+                      // so cid alone is not enough (#3269)
+                      componentOptions.Ctor.cid +
+                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                  : vnode.key;
+              if (cache[key]) {
+                  vnode.componentInstance = cache[key].componentInstance;
+                  // make current key freshest
+                  remove$2(keys, key);
+                  keys.push(key);
+              }
+              else {
+                  cache[key] = vnode;
+                  keys.push(key);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+              }
+              vnode.data.keepAlive = true;
           }
-        }
-        vnode.data.keepAlive = true;
-      }
-      return vnode || (slot && slot[0]);
-    },
+          return vnode || (slot && slot[0]);
+      },
   };
 
   var builtInComponents = {
-    KeepAlive: KeepAlive,
+      KeepAlive: KeepAlive,
   };
 
   function initGlobalAPI(Vue) {
-    // config
-    var configDef = {};
-    configDef.get = function () {
-      return config;
-    };
-    {
-      configDef.set = function () {
-        warn(
-          "Do not replace the Vue.config object, set individual fields instead."
-        );
+      // config
+      var configDef = {};
+      configDef.get = function () { return config; };
+      {
+          configDef.set = function () {
+              warn('Do not replace the Vue.config object, set individual fields instead.');
+          };
+      }
+      Object.defineProperty(Vue, 'config', configDef);
+      // exposed util methods.
+      // NOTE: these are not considered part of the public API - avoid relying on
+      // them unless you are aware of the risk.
+      Vue.util = {
+          warn: warn,
+          extend: extend,
+          mergeOptions: mergeOptions,
+          defineReactive: defineReactive,
       };
-    }
-    Object.defineProperty(Vue, "config", configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-      warn: warn,
-      extend: extend,
-      mergeOptions: mergeOptions,
-      defineReactive: defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = function (obj) {
-      observe(obj);
-      return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
-      Vue.options[type + "s"] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+      Vue.set = set;
+      Vue.delete = del;
+      Vue.nextTick = nextTick;
+      // 2.6 explicit observable API
+      Vue.observable = function (obj) {
+          observe(obj);
+          return obj;
+      };
+      Vue.options = Object.create(null);
+      ASSET_TYPES.forEach(function (type) {
+          Vue.options[type + 's'] = Object.create(null);
+      });
+      // this is used to identify the "base" constructor to extend all plain-object
+      // components with in Weex's multi-instance scenarios.
+      Vue.options._base = Vue;
+      extend(Vue.options.components, builtInComponents);
+      initUse(Vue);
+      initMixin(Vue);
+      initExtend(Vue);
+      initAssetRegisters(Vue);
   }
 
   initGlobalAPI(Vue);
-  Object.defineProperty(Vue.prototype, "$isServer", {
-    get: isServerRendering,
+  Object.defineProperty(Vue.prototype, '$isServer', {
+      get: isServerRendering,
   });
-  Object.defineProperty(Vue.prototype, "$ssrContext", {
-    get: function get() {
-      /* istanbul ignore next */
-      return this.$vnode && this.$vnode.ssrContext;
-    },
+  Object.defineProperty(Vue.prototype, '$ssrContext', {
+      get: function get() {
+          /* istanbul ignore next */
+          return this.$vnode && this.$vnode.ssrContext;
+      },
   });
   // expose FunctionalRenderContext for ssr runtime helper installation
-  Object.defineProperty(Vue, "FunctionalRenderContext", {
-    value: FunctionalRenderContext,
+  Object.defineProperty(Vue, 'FunctionalRenderContext', {
+      value: FunctionalRenderContext,
   });
-  Vue.version = "2.6.12";
+  Vue.version = '2.6.12';
 
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap("style,class");
+  var isReservedAttr = makeMap('style,class');
   // attributes that should be using props for binding
-  var acceptValue = makeMap("input,textarea,option,select,progress");
+  var acceptValue = makeMap('input,textarea,option,select,progress');
   var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === "value" && acceptValue(tag) && type !== "button") ||
-      (attr === "selected" && tag === "option") ||
-      (attr === "checked" && tag === "input") ||
-      (attr === "muted" && tag === "video")
-    );
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
   };
-  var isEnumeratedAttr = makeMap("contenteditable,draggable,spellcheck");
-  var isValidContentEditableValue = makeMap(
-    "events,caret,typing,plaintext-only"
-  );
+  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
   var convertEnumeratedValue = function (key, value) {
-    return isFalsyAttrValue(value) || value === "false"
-      ? "false"
-      : // allow arbitrary string value for contenteditable
-      key === "contenteditable" && isValidContentEditableValue(value)
-      ? value
-      : "true";
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
   };
-  var isBooleanAttr = makeMap(
-    "allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare," +
-      "default,defaultchecked,defaultmuted,defaultselected,defer,disabled," +
-      "enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple," +
-      "muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly," +
-      "required,reversed,scoped,seamless,selected,sortable," +
-      "truespeed,typemustmatch,visible"
-  );
-  var xlinkNS = "http://www.w3.org/1999/xlink";
+  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+  var xlinkNS = 'http://www.w3.org/1999/xlink';
   var isXlink = function (name) {
-    return name.charAt(5) === ":" && name.slice(0, 5) === "xlink";
+      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
   };
   var getXlinkProp = function (name) {
-    return isXlink(name) ? name.slice(6, name.length) : "";
+      return isXlink(name) ? name.slice(6, name.length) : '';
   };
   var isFalsyAttrValue = function (val) {
-    return val == null || val === false;
+      return val == null || val === false;
   };
 
   function genClassForVnode(vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-      childNode = childNode.componentInstance._vnode;
-      if (childNode && childNode.data) {
-        data = mergeClassData(childNode.data, data);
-      }
-    }
-    while (isDef((parentNode = parentNode.parent))) {
-      if (parentNode && parentNode.data) {
-        data = mergeClassData(data, parentNode.data);
-      }
-    }
-    return renderClass(data.staticClass, data.class);
+      var data = vnode.data;
+      var parentNode = vnode;
+      var childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass(data.staticClass, data.class);
   }
   function mergeClassData(child, parent) {
-    return {
-      staticClass: concat(child.staticClass, parent.staticClass),
-      class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
   }
   function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-      return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return "";
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
   }
   function concat(a, b) {
-    return a ? (b ? a + " " + b : a) : b || "";
+      return a ? (b ? a + ' ' + b : a) : b || '';
   }
   function stringifyClass(value) {
-    if (Array.isArray(value)) {
-      return stringifyArray(value);
-    }
-    if (isObject(value)) {
-      return stringifyObject(value);
-    }
-    if (typeof value === "string") {
-      return value;
-    }
-    /* istanbul ignore next */
-    return "";
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
   }
   function stringifyArray(value) {
-    var res = "";
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
-      if (
-        isDef((stringified = stringifyClass(value[i]))) &&
-        stringified !== ""
-      ) {
-        if (res) {
-          res += " ";
-        }
-        res += stringified;
-      }
-    }
-    return res;
+      var res = '';
+      var stringified;
+      for (var i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  { res += ' '; }
+              res += stringified;
+          }
+      }
+      return res;
   }
   function stringifyObject(value) {
-    var res = "";
-    for (var key in value) {
-      if (value[key]) {
-        if (res) {
-          res += " ";
-        }
-        res += key;
+      var res = '';
+      for (var key in value) {
+          if (value[key]) {
+              if (res)
+                  { res += ' '; }
+              res += key;
+          }
       }
-    }
-    return res;
+      return res;
   }
 
   var namespaceMap = {
-    svg: "http://www.w3.org/2000/svg",
-    math: "http://www.w3.org/1998/Math/MathML",
+      svg: 'http://www.w3.org/2000/svg',
+      math: 'http://www.w3.org/1998/Math/MathML',
   };
-  var isHTMLTag = makeMap(
-    "html,body,base,head,link,meta,style,title," +
-      "address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section," +
-      "div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul," +
-      "a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby," +
-      "s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video," +
-      "embed,object,param,source,canvas,script,noscript,del,ins," +
-      "caption,col,colgroup,table,thead,tbody,td,th,tr," +
-      "button,datalist,fieldset,form,input,label,legend,meter,optgroup,option," +
-      "output,progress,select,textarea," +
-      "details,dialog,menu,menuitem,summary," +
-      "content,element,shadow,template,blockquote,iframe,tfoot"
-  );
+  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap(
-    "svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face," +
-      "foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern," +
-      "polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",
-    true
-  );
+  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
   var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag);
+      return isHTMLTag(tag) || isSVG(tag);
   };
   function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-      return "svg";
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === "math") {
-      return "math";
-    }
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
   }
   var unknownElementCache = Object.create(null);
   function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-      return true;
-    }
-    if (isReservedTag(tag)) {
-      return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-      return unknownElementCache[tag];
-    }
-    var el = document.createElement(tag);
-    if (tag.indexOf("-") > -1) {
-      // http://stackoverflow.com/a/28210364/1070244
-      return (unknownElementCache[tag] =
-        el.constructor === window.HTMLUnknownElement ||
-        el.constructor === window.HTMLElement);
-    } else {
-      return (unknownElementCache[tag] = /HTMLUnknownElement/.test(
-        el.toString()
-      ));
-    }
-  }
-  var isTextInputType = makeMap("text,number,password,search,email,tel,url");
+      /* istanbul ignore if */
+      if (!inBrowser) {
+          return true;
+      }
+      if (isReservedTag(tag)) {
+          return false;
+      }
+      tag = tag.toLowerCase();
+      /* istanbul ignore if */
+      if (unknownElementCache[tag] != null) {
+          return unknownElementCache[tag];
+      }
+      var el = document.createElement(tag);
+      if (tag.indexOf('-') > -1) {
+          // http://stackoverflow.com/a/28210364/1070244
+          return (unknownElementCache[tag] =
+              el.constructor === window.HTMLUnknownElement ||
+                  el.constructor === window.HTMLElement);
+      }
+      else {
+          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+      }
+  }
+  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
   /**
    * Query an element selector if it's not an element already.
    */
   function query(el) {
-    if (typeof el === "string") {
-      var selected = document.querySelector(el);
-      if (!selected) {
-        warn("Cannot find element: " + el);
-        return document.createElement("div");
+      if (typeof el === 'string') {
+          var selected = document.querySelector(el);
+          if (!selected) {
+              warn('Cannot find element: ' + el);
+              return document.createElement('div');
+          }
+          return selected;
+      }
+      else {
+          return el;
       }
-      return selected;
-    } else {
-      return el;
-    }
   }
 
   function createElement(tagName, vnode) {
-    var elm = document.createElement(tagName);
-    if (tagName !== "select") {
+      var elm = document.createElement(tagName);
+      if (tagName !== 'select') {
+          return elm;
+      }
+      // false or null will remove the attribute but undefined will not
+      if (vnode.data &&
+          vnode.data.attrs &&
+          vnode.data.attrs.multiple !== undefined) {
+          elm.setAttribute('multiple', 'multiple');
+      }
       return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (
-      vnode.data &&
-      vnode.data.attrs &&
-      vnode.data.attrs.multiple !== undefined
-    ) {
-      elm.setAttribute("multiple", "multiple");
-    }
-    return elm;
   }
   function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
+      return document.createElementNS(namespaceMap[namespace], tagName);
   }
   function createTextNode(text) {
-    return document.createTextNode(text);
+      return document.createTextNode(text);
   }
   function createComment(text) {
-    return document.createComment(text);
+      return document.createComment(text);
   }
   function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
+      parentNode.insertBefore(newNode, referenceNode);
   }
   function removeChild(node, child) {
-    node.removeChild(child);
+      node.removeChild(child);
   }
   function appendChild(node, child) {
-    node.appendChild(child);
+      node.appendChild(child);
   }
   function parentNode(node) {
-    return node.parentNode;
+      return node.parentNode;
   }
   function nextSibling(node) {
-    return node.nextSibling;
+      return node.nextSibling;
   }
   function tagName(node) {
-    return node.tagName;
+      return node.tagName;
   }
   function setTextContent(node, text) {
-    node.textContent = text;
+      node.textContent = text;
   }
   function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, "");
+      node.setAttribute(scopeId, '');
   }
 
-  var nodeOps = /*#__PURE__*/ Object.freeze({
+  var nodeOps = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createElement: createElement,
     createElementNS: createElementNS,
@@ -5421,52 +4972,55 @@
     nextSibling: nextSibling,
     tagName: tagName,
     setTextContent: setTextContent,
-    setStyleScope: setStyleScope,
+    setStyleScope: setStyleScope
   });
 
   var ref = {
-    create: function create(_, vnode) {
-      registerRef(vnode);
-    },
-    update: function update(oldVnode, vnode) {
-      if (oldVnode.data.ref !== vnode.data.ref) {
-        registerRef(oldVnode, true);
-        registerRef(vnode);
-      }
-    },
-    destroy: function destroy(vnode) {
-      registerRef(vnode, true);
-    },
+      create: function create(_, vnode) {
+          registerRef(vnode);
+      },
+      update: function update(oldVnode, vnode) {
+          if (oldVnode.data.ref !== vnode.data.ref) {
+              registerRef(oldVnode, true);
+              registerRef(vnode);
+          }
+      },
+      destroy: function destroy(vnode) {
+          registerRef(vnode, true);
+      },
   };
   function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
-    if (!isDef(key)) {
-      return;
-    }
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
-    if (isRemoval) {
-      if (Array.isArray(refs[key])) {
-        // @ts-expect-error invalid typings
-        remove$2(refs[key], ref);
-      } else if (refs[key] === ref) {
-        refs[key] = undefined;
-      }
-    } else {
-      // @ts-expect-error invalid typings
-      if (vnode.data.refInFor) {
-        if (!Array.isArray(refs[key])) {
-          refs[key] = [ref];
-          // @ts-expect-error invalid typings
-        } else if (refs[key].indexOf(ref) < 0) {
+      var key = vnode.data.ref;
+      if (!isDef(key))
+          { return; }
+      var vm = vnode.context;
+      var ref = vnode.componentInstance || vnode.elm;
+      var refs = vm.$refs;
+      if (isRemoval) {
+          if (Array.isArray(refs[key])) {
+              // @ts-expect-error invalid typings
+              remove$2(refs[key], ref);
+          }
+          else if (refs[key] === ref) {
+              refs[key] = undefined;
+          }
+      }
+      else {
           // @ts-expect-error invalid typings
-          refs[key].push(ref);
-        }
-      } else {
-        refs[key] = ref;
+          if (vnode.data.refInFor) {
+              if (!Array.isArray(refs[key])) {
+                  refs[key] = [ref];
+                  // @ts-expect-error invalid typings
+              }
+              else if (refs[key].indexOf(ref) < 0) {
+                  // @ts-expect-error invalid typings
+                  refs[key].push(ref);
+              }
+          }
+          else {
+              refs[key] = ref;
+          }
       }
-    }
   }
 
   /**
@@ -5480,1476 +5034,1308 @@
    * Not type-checking this because this file is perf-critical and the cost
    * of making flow understand it is not worth it.
    */
-  var emptyNode = new VNode("", {}, []);
-  var hooks = ["create", "activate", "update", "remove", "destroy"];
+  var emptyNode = new VNode('', {}, []);
+  var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
   function sameVnode(a, b) {
-    return (
-      a.key === b.key &&
-      ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) ||
-        (isTrue(a.isAsyncPlaceholder) &&
-          a.asyncFactory === b.asyncFactory &&
-          isUndef(b.asyncFactory.error)))
-    );
+      return (a.key === b.key &&
+          ((a.tag === b.tag &&
+              a.isComment === b.isComment &&
+              isDef(a.data) === isDef(b.data) &&
+              sameInputType(a, b)) ||
+              (isTrue(a.isAsyncPlaceholder) &&
+                  a.asyncFactory === b.asyncFactory &&
+                  isUndef(b.asyncFactory.error))));
   }
   function sameInputType(a, b) {
-    if (a.tag !== "input") {
-      return true;
-    }
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return (
-      typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB))
-    );
+      if (a.tag !== 'input')
+          { return true; }
+      var i;
+      var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
   }
   function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-      key = children[i].key;
-      if (isDef(key)) {
-        map[key] = i;
+      var i, key;
+      var map = {};
+      for (i = beginIdx; i <= endIdx; ++i) {
+          key = children[i].key;
+          if (isDef(key))
+              { map[key] = i; }
       }
-    }
-    return map;
+      return map;
   }
   function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
-    for (i = 0; i < hooks.length; ++i) {
-      cbs[hooks[i]] = [];
-      for (j = 0; j < modules.length; ++j) {
-        if (isDef(modules[j][hooks[i]])) {
-          cbs[hooks[i]].push(modules[j][hooks[i]]);
-        }
-      }
-    }
-    function emptyNodeAt(elm) {
-      return new VNode(
-        nodeOps.tagName(elm).toLowerCase(),
-        {},
-        [],
-        undefined,
-        elm
-      );
-    }
-    function createRmCb(childElm, listeners) {
-      function remove() {
-        if (--remove.listeners === 0) {
-          removeNode(childElm);
-        }
-      }
-      remove.listeners = listeners;
-      return remove;
-    }
-    function removeNode(el) {
-      var parent = nodeOps.parentNode(el);
-      // element may have already been removed due to v-html / v-text
-      if (isDef(parent)) {
-        nodeOps.removeChild(parent, el);
-      }
-    }
-    function isUnknownElement(vnode, inVPre) {
-      return (
-        !inVPre &&
-        !vnode.ns &&
-        !(
-          config.ignoredElements.length &&
-          config.ignoredElements.some(function (ignore) {
-            return isRegExp(ignore)
-              ? ignore.test(vnode.tag)
-              : ignore === vnode.tag;
-          })
-        ) &&
-        config.isUnknownElement(vnode.tag)
-      );
-    }
-    var creatingElmInVPre = 0;
-    function createElm(
-      vnode,
-      insertedVnodeQueue,
-      parentElm,
-      refElm,
-      nested,
-      ownerArray,
-      index
-    ) {
-      if (isDef(vnode.elm) && isDef(ownerArray)) {
-        // This vnode was used in a previous render!
-        // now it's used as a new node, overwriting its elm would cause
-        // potential patch errors down the road when it's used as an insertion
-        // reference node. Instead, we clone the node on-demand before creating
-        // associated DOM element for it.
-        vnode = ownerArray[index] = cloneVNode(vnode);
-      }
-      vnode.isRootInsert = !nested; // for transition enter check
-      if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-        return;
+      var i, j;
+      var cbs = {};
+      var modules = backend.modules;
+      var nodeOps = backend.nodeOps;
+      for (i = 0; i < hooks.length; ++i) {
+          cbs[hooks[i]] = [];
+          for (j = 0; j < modules.length; ++j) {
+              if (isDef(modules[j][hooks[i]])) {
+                  cbs[hooks[i]].push(modules[j][hooks[i]]);
+              }
+          }
       }
-      var data = vnode.data;
-      var children = vnode.children;
-      var tag = vnode.tag;
-      if (isDef(tag)) {
-        {
-          if (data && data.pre) {
-            creatingElmInVPre++;
-          }
-          if (isUnknownElement(vnode, creatingElmInVPre)) {
-            warn(
-              "Unknown custom element: <" +
-                tag +
-                "> - did you " +
-                "register the component correctly? For recursive components, " +
-                'make sure to provide the "name" option.',
-              vnode.context
-            );
-          }
-        }
-        vnode.elm = vnode.ns
-          ? nodeOps.createElementNS(vnode.ns, tag)
-          : nodeOps.createElement(tag, vnode);
-        setScope(vnode);
-        /* istanbul ignore if */
-        {
-          createChildren(vnode, children, insertedVnodeQueue);
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
+      function emptyNodeAt(elm) {
+          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+      }
+      function createRmCb(childElm, listeners) {
+          function remove() {
+              if (--remove.listeners === 0) {
+                  removeNode(childElm);
+              }
           }
+          remove.listeners = listeners;
+          return remove;
+      }
+      function removeNode(el) {
+          var parent = nodeOps.parentNode(el);
+          // element may have already been removed due to v-html / v-text
+          if (isDef(parent)) {
+              nodeOps.removeChild(parent, el);
+          }
+      }
+      function isUnknownElement(vnode, inVPre) {
+          return (!inVPre &&
+              !vnode.ns &&
+              !(config.ignoredElements.length &&
+                  config.ignoredElements.some(function (ignore) {
+                      return isRegExp(ignore)
+                          ? ignore.test(vnode.tag)
+                          : ignore === vnode.tag;
+                  })) &&
+              config.isUnknownElement(vnode.tag));
+      }
+      var creatingElmInVPre = 0;
+      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // This vnode was used in a previous render!
+              // now it's used as a new node, overwriting its elm would cause
+              // potential patch errors down the road when it's used as an insertion
+              // reference node. Instead, we clone the node on-demand before creating
+              // associated DOM element for it.
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          vnode.isRootInsert = !nested; // for transition enter check
+          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+              return;
+          }
+          var data = vnode.data;
+          var children = vnode.children;
+          var tag = vnode.tag;
+          if (isDef(tag)) {
+              {
+                  if (data && data.pre) {
+                      creatingElmInVPre++;
+                  }
+                  if (isUnknownElement(vnode, creatingElmInVPre)) {
+                      warn('Unknown custom element: <' +
+                          tag +
+                          '> - did you ' +
+                          'register the component correctly? For recursive components, ' +
+                          'make sure to provide the "name" option.', vnode.context);
+                  }
+              }
+              vnode.elm = vnode.ns
+                  ? nodeOps.createElementNS(vnode.ns, tag)
+                  : nodeOps.createElement(tag, vnode);
+              setScope(vnode);
+              /* istanbul ignore if */
+              {
+                  createChildren(vnode, children, insertedVnodeQueue);
+                  if (isDef(data)) {
+                      invokeCreateHooks(vnode, insertedVnodeQueue);
+                  }
+                  insert(parentElm, vnode.elm, refElm);
+              }
+              if (data && data.pre) {
+                  creatingElmInVPre--;
+              }
+          }
+          else if (isTrue(vnode.isComment)) {
+              vnode.elm = nodeOps.createComment(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+          else {
+              vnode.elm = nodeOps.createTextNode(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+      }
+      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          var i = vnode.data;
+          if (isDef(i)) {
+              var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                  i(vnode, false /* hydrating */);
+              }
+              // after calling the init hook, if the vnode is a child component
+              // it should've created a child instance and mounted it. the child
+              // component also has set the placeholder vnode's elm.
+              // in that case we can just return the element and be done.
+              if (isDef(vnode.componentInstance)) {
+                  initComponent(vnode, insertedVnodeQueue);
+                  insert(parentElm, vnode.elm, refElm);
+                  if (isTrue(isReactivated)) {
+                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                  }
+                  return true;
+              }
+          }
+      }
+      function initComponent(vnode, insertedVnodeQueue) {
+          if (isDef(vnode.data.pendingInsert)) {
+              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+              vnode.data.pendingInsert = null;
+          }
+          vnode.elm = vnode.componentInstance.$el;
+          if (isPatchable(vnode)) {
+              invokeCreateHooks(vnode, insertedVnodeQueue);
+              setScope(vnode);
+          }
+          else {
+              // empty component root.
+              // skip all element-related modules except for ref (#3455)
+              registerRef(vnode);
+              // make sure to invoke the insert hook
+              insertedVnodeQueue.push(vnode);
+          }
+      }
+      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          var i;
+          // hack for #4339: a reactivated component with inner transition
+          // does not trigger because the inner node's created hooks are not called
+          // again. It's not ideal to involve module-specific logic in here but
+          // there doesn't seem to be a better way to do it.
+          var innerNode = vnode;
+          while (innerNode.componentInstance) {
+              innerNode = innerNode.componentInstance._vnode;
+              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                  for (i = 0; i < cbs.activate.length; ++i) {
+                      cbs.activate[i](emptyNode, innerNode);
+                  }
+                  insertedVnodeQueue.push(innerNode);
+                  break;
+              }
+          }
+          // unlike a newly created component,
+          // a reactivated keep-alive component doesn't insert itself
           insert(parentElm, vnode.elm, refElm);
-        }
-        if (data && data.pre) {
-          creatingElmInVPre--;
-        }
-      } else if (isTrue(vnode.isComment)) {
-        vnode.elm = nodeOps.createComment(vnode.text);
-        insert(parentElm, vnode.elm, refElm);
-      } else {
-        vnode.elm = nodeOps.createTextNode(vnode.text);
-        insert(parentElm, vnode.elm, refElm);
-      }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-      var i = vnode.data;
-      if (isDef(i)) {
-        var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-        if (isDef((i = i.hook)) && isDef((i = i.init))) {
-          i(vnode, false /* hydrating */);
-        }
-        // after calling the init hook, if the vnode is a child component
-        // it should've created a child instance and mounted it. the child
-        // component also has set the placeholder vnode's elm.
-        // in that case we can just return the element and be done.
-        if (isDef(vnode.componentInstance)) {
-          initComponent(vnode, insertedVnodeQueue);
-          insert(parentElm, vnode.elm, refElm);
-          if (isTrue(isReactivated)) {
-            reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+      }
+      function insert(parent, elm, ref) {
+          if (isDef(parent)) {
+              if (isDef(ref)) {
+                  if (nodeOps.parentNode(ref) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref);
+                  }
+              }
+              else {
+                  nodeOps.appendChild(parent, elm);
+              }
           }
-          return true;
-        }
-      }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-      if (isDef(vnode.data.pendingInsert)) {
-        insertedVnodeQueue.push.apply(
-          insertedVnodeQueue,
-          vnode.data.pendingInsert
-        );
-        vnode.data.pendingInsert = null;
-      }
-      vnode.elm = vnode.componentInstance.$el;
-      if (isPatchable(vnode)) {
-        invokeCreateHooks(vnode, insertedVnodeQueue);
-        setScope(vnode);
-      } else {
-        // empty component root.
-        // skip all element-related modules except for ref (#3455)
-        registerRef(vnode);
-        // make sure to invoke the insert hook
-        insertedVnodeQueue.push(vnode);
-      }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-      var i;
-      // hack for #4339: a reactivated component with inner transition
-      // does not trigger because the inner node's created hooks are not called
-      // again. It's not ideal to involve module-specific logic in here but
-      // there doesn't seem to be a better way to do it.
-      var innerNode = vnode;
-      while (innerNode.componentInstance) {
-        innerNode = innerNode.componentInstance._vnode;
-        if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-          for (i = 0; i < cbs.activate.length; ++i) {
-            cbs.activate[i](emptyNode, innerNode);
-          }
-          insertedVnodeQueue.push(innerNode);
-          break;
-        }
-      }
-      // unlike a newly created component,
-      // a reactivated keep-alive component doesn't insert itself
-      insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-      if (isDef(parent)) {
-        if (isDef(ref)) {
-          if (nodeOps.parentNode(ref) === parent) {
-            nodeOps.insertBefore(parent, elm, ref);
-          }
-        } else {
-          nodeOps.appendChild(parent, elm);
-        }
-      }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-      if (Array.isArray(children)) {
-        {
-          checkDuplicateKeys(children);
-        }
-        for (var i = 0; i < children.length; ++i) {
-          createElm(
-            children[i],
-            insertedVnodeQueue,
-            vnode.elm,
-            null,
-            true,
-            children,
-            i
-          );
-        }
-      } else if (isPrimitive(vnode.text)) {
-        nodeOps.appendChild(
-          vnode.elm,
-          nodeOps.createTextNode(String(vnode.text))
-        );
-      }
-    }
-    function isPatchable(vnode) {
-      while (vnode.componentInstance) {
-        vnode = vnode.componentInstance._vnode;
-      }
-      return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-      for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-        cbs.create[i$1](emptyNode, vnode);
-      }
-      i = vnode.data.hook; // Reuse variable
-      if (isDef(i)) {
-        if (isDef(i.create)) {
-          i.create(emptyNode, vnode);
-        }
-        if (isDef(i.insert)) {
-          insertedVnodeQueue.push(vnode);
-        }
-      }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-      var i;
-      if (isDef((i = vnode.fnScopeId))) {
-        nodeOps.setStyleScope(vnode.elm, i);
-      } else {
-        var ancestor = vnode;
-        while (ancestor) {
-          if (
-            isDef((i = ancestor.context)) &&
-            isDef((i = i.$options._scopeId))
-          ) {
-            nodeOps.setStyleScope(vnode.elm, i);
-          }
-          ancestor = ancestor.parent;
-        }
-      }
-      // for slot content they should also get the scopeId from the host instance.
-      if (
-        isDef((i = activeInstance)) &&
-        i !== vnode.context &&
-        i !== vnode.fnContext &&
-        isDef((i = i.$options._scopeId))
-      ) {
-        nodeOps.setStyleScope(vnode.elm, i);
-      }
-    }
-    function addVnodes(
-      parentElm,
-      refElm,
-      vnodes,
-      startIdx,
-      endIdx,
-      insertedVnodeQueue
-    ) {
-      for (; startIdx <= endIdx; ++startIdx) {
-        createElm(
-          vnodes[startIdx],
-          insertedVnodeQueue,
-          parentElm,
-          refElm,
-          false,
-          vnodes,
-          startIdx
-        );
-      }
-    }
-    function invokeDestroyHook(vnode) {
-      var i, j;
-      var data = vnode.data;
-      if (isDef(data)) {
-        if (isDef((i = data.hook)) && isDef((i = i.destroy))) {
-          i(vnode);
-        }
-        for (i = 0; i < cbs.destroy.length; ++i) {
-          cbs.destroy[i](vnode);
-        }
-      }
-      if (isDef((i = vnode.children))) {
-        for (j = 0; j < vnode.children.length; ++j) {
-          invokeDestroyHook(vnode.children[j]);
-        }
-      }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-      for (; startIdx <= endIdx; ++startIdx) {
-        var ch = vnodes[startIdx];
-        if (isDef(ch)) {
-          if (isDef(ch.tag)) {
-            removeAndInvokeRemoveHook(ch);
-            invokeDestroyHook(ch);
-          } else {
-            // Text node
-            removeNode(ch.elm);
-          }
-        }
-      }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-      if (isDef(rm) || isDef(vnode.data)) {
-        var i;
-        var listeners = cbs.remove.length + 1;
-        if (isDef(rm)) {
-          // we have a recursively passed down rm callback
-          // increase the listeners count
-          rm.listeners += listeners;
-        } else {
-          // directly removing
-          rm = createRmCb(vnode.elm, listeners);
-        }
-        // recursively invoke hooks on child component root node
-        if (
-          isDef((i = vnode.componentInstance)) &&
-          isDef((i = i._vnode)) &&
-          isDef(i.data)
-        ) {
-          removeAndInvokeRemoveHook(i, rm);
-        }
-        for (i = 0; i < cbs.remove.length; ++i) {
-          cbs.remove[i](vnode, rm);
-        }
-        if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-          i(vnode, rm);
-        } else {
-          rm();
-        }
-      } else {
-        removeNode(vnode.elm);
-      }
-    }
-    function updateChildren(
-      parentElm,
-      oldCh,
-      newCh,
-      insertedVnodeQueue,
-      removeOnly
-    ) {
-      var oldStartIdx = 0;
-      var newStartIdx = 0;
-      var oldEndIdx = oldCh.length - 1;
-      var oldStartVnode = oldCh[0];
-      var oldEndVnode = oldCh[oldEndIdx];
-      var newEndIdx = newCh.length - 1;
-      var newStartVnode = newCh[0];
-      var newEndVnode = newCh[newEndIdx];
-      var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-      // removeOnly is a special flag used only by <transition-group>
-      // to ensure removed elements stay in correct relative positions
-      // during leaving transitions
-      var canMove = !removeOnly;
-      {
-        checkDuplicateKeys(newCh);
-      }
-      while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-        if (isUndef(oldStartVnode)) {
-          oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-        } else if (isUndef(oldEndVnode)) {
-          oldEndVnode = oldCh[--oldEndIdx];
-        } else if (sameVnode(oldStartVnode, newStartVnode)) {
-          patchVnode(
-            oldStartVnode,
-            newStartVnode,
-            insertedVnodeQueue,
-            newCh,
-            newStartIdx
-          );
-          oldStartVnode = oldCh[++oldStartIdx];
-          newStartVnode = newCh[++newStartIdx];
-        } else if (sameVnode(oldEndVnode, newEndVnode)) {
-          patchVnode(
-            oldEndVnode,
-            newEndVnode,
-            insertedVnodeQueue,
-            newCh,
-            newEndIdx
-          );
-          oldEndVnode = oldCh[--oldEndIdx];
-          newEndVnode = newCh[--newEndIdx];
-        } else if (sameVnode(oldStartVnode, newEndVnode)) {
-          // Vnode moved right
-          patchVnode(
-            oldStartVnode,
-            newEndVnode,
-            insertedVnodeQueue,
-            newCh,
-            newEndIdx
-          );
-          canMove &&
-            nodeOps.insertBefore(
-              parentElm,
-              oldStartVnode.elm,
-              nodeOps.nextSibling(oldEndVnode.elm)
-            );
-          oldStartVnode = oldCh[++oldStartIdx];
-          newEndVnode = newCh[--newEndIdx];
-        } else if (sameVnode(oldEndVnode, newStartVnode)) {
-          // Vnode moved left
-          patchVnode(
-            oldEndVnode,
-            newStartVnode,
-            insertedVnodeQueue,
-            newCh,
-            newStartIdx
-          );
-          canMove &&
-            nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-          oldEndVnode = oldCh[--oldEndIdx];
-          newStartVnode = newCh[++newStartIdx];
-        } else {
-          if (isUndef(oldKeyToIdx)) {
-            oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-          }
-          idxInOld = isDef(newStartVnode.key)
-            ? oldKeyToIdx[newStartVnode.key]
-            : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-          if (isUndef(idxInOld)) {
-            // New element
-            createElm(
-              newStartVnode,
-              insertedVnodeQueue,
-              parentElm,
-              oldStartVnode.elm,
-              false,
-              newCh,
-              newStartIdx
-            );
-          } else {
-            vnodeToMove = oldCh[idxInOld];
-            if (sameVnode(vnodeToMove, newStartVnode)) {
-              patchVnode(
-                vnodeToMove,
-                newStartVnode,
-                insertedVnodeQueue,
-                newCh,
-                newStartIdx
-              );
-              oldCh[idxInOld] = undefined;
-              canMove &&
-                nodeOps.insertBefore(
-                  parentElm,
-                  vnodeToMove.elm,
-                  oldStartVnode.elm
-                );
-            } else {
-              // same key but different element. treat as new element
-              createElm(
-                newStartVnode,
-                insertedVnodeQueue,
-                parentElm,
-                oldStartVnode.elm,
-                false,
-                newCh,
-                newStartIdx
-              );
-            }
-          }
-          newStartVnode = newCh[++newStartIdx];
-        }
-      }
-      if (oldStartIdx > oldEndIdx) {
-        refElm = isUndef(newCh[newEndIdx + 1])
-          ? null
-          : newCh[newEndIdx + 1].elm;
-        addVnodes(
-          parentElm,
-          refElm,
-          newCh,
-          newStartIdx,
-          newEndIdx,
-          insertedVnodeQueue
-        );
-      } else if (newStartIdx > newEndIdx) {
-        removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-      }
-    }
-    function checkDuplicateKeys(children) {
-      var seenKeys = {};
-      for (var i = 0; i < children.length; i++) {
-        var vnode = children[i];
-        var key = vnode.key;
-        if (isDef(key)) {
-          if (seenKeys[key]) {
-            warn(
-              "Duplicate keys detected: '" +
-                key +
-                "'. This may cause an update error.",
-              vnode.context
-            );
-          } else {
-            seenKeys[key] = true;
-          }
-        }
-      }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-      for (var i = start; i < end; i++) {
-        var c = oldCh[i];
-        if (isDef(c) && sameVnode(node, c)) {
-          return i;
-        }
-      }
-    }
-    function patchVnode(
-      oldVnode,
-      vnode,
-      insertedVnodeQueue,
-      ownerArray,
-      index,
-      removeOnly
-    ) {
-      if (oldVnode === vnode) {
-        return;
-      }
-      if (isDef(vnode.elm) && isDef(ownerArray)) {
-        // clone reused vnode
-        vnode = ownerArray[index] = cloneVNode(vnode);
-      }
-      var elm = (vnode.elm = oldVnode.elm);
-      if (isTrue(oldVnode.isAsyncPlaceholder)) {
-        if (isDef(vnode.asyncFactory.resolved)) {
-          hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-        } else {
-          vnode.isAsyncPlaceholder = true;
-        }
-        return;
-      }
-      // reuse element for static trees.
-      // note we only do this if the vnode is cloned -
-      // if the new node is not cloned it means the render functions have been
-      // reset by the hot-reload-api and we need to do a proper re-render.
-      if (
-        isTrue(vnode.isStatic) &&
-        isTrue(oldVnode.isStatic) &&
-        vnode.key === oldVnode.key &&
-        (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
-      ) {
-        vnode.componentInstance = oldVnode.componentInstance;
-        return;
       }
-      var i;
-      var data = vnode.data;
-      if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-        i(oldVnode, vnode);
-      }
-      var oldCh = oldVnode.children;
-      var ch = vnode.children;
-      if (isDef(data) && isPatchable(vnode)) {
-        for (i = 0; i < cbs.update.length; ++i) {
-          cbs.update[i](oldVnode, vnode);
-        }
-        if (isDef((i = data.hook)) && isDef((i = i.update))) {
-          i(oldVnode, vnode);
-        }
-      }
-      if (isUndef(vnode.text)) {
-        if (isDef(oldCh) && isDef(ch)) {
-          if (oldCh !== ch) {
-            updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-          }
-        } else if (isDef(ch)) {
+      function createChildren(vnode, children, insertedVnodeQueue) {
+          if (Array.isArray(children)) {
+              {
+                  checkDuplicateKeys(children);
+              }
+              for (var i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              }
+          }
+          else if (isPrimitive(vnode.text)) {
+              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+          }
+      }
+      function isPatchable(vnode) {
+          while (vnode.componentInstance) {
+              vnode = vnode.componentInstance._vnode;
+          }
+          return isDef(vnode.tag);
+      }
+      function invokeCreateHooks(vnode, insertedVnodeQueue) {
+          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+              cbs.create[i$1](emptyNode, vnode);
+          }
+          i = vnode.data.hook; // Reuse variable
+          if (isDef(i)) {
+              if (isDef(i.create))
+                  { i.create(emptyNode, vnode); }
+              if (isDef(i.insert))
+                  { insertedVnodeQueue.push(vnode); }
+          }
+      }
+      // set scope id attribute for scoped CSS.
+      // this is implemented as a special case to avoid the overhead
+      // of going through the normal attribute patching process.
+      function setScope(vnode) {
+          var i;
+          if (isDef((i = vnode.fnScopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+          else {
+              var ancestor = vnode;
+              while (ancestor) {
+                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                      nodeOps.setStyleScope(vnode.elm, i);
+                  }
+                  ancestor = ancestor.parent;
+              }
+          }
+          // for slot content they should also get the scopeId from the host instance.
+          if (isDef((i = activeInstance)) &&
+              i !== vnode.context &&
+              i !== vnode.fnContext &&
+              isDef((i = i.$options._scopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+      }
+      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+          }
+      }
+      function invokeDestroyHook(vnode) {
+          var i, j;
+          var data = vnode.data;
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                  { i(vnode); }
+              for (i = 0; i < cbs.destroy.length; ++i)
+                  { cbs.destroy[i](vnode); }
+          }
+          if (isDef((i = vnode.children))) {
+              for (j = 0; j < vnode.children.length; ++j) {
+                  invokeDestroyHook(vnode.children[j]);
+              }
+          }
+      }
+      function removeVnodes(vnodes, startIdx, endIdx) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              var ch = vnodes[startIdx];
+              if (isDef(ch)) {
+                  if (isDef(ch.tag)) {
+                      removeAndInvokeRemoveHook(ch);
+                      invokeDestroyHook(ch);
+                  }
+                  else {
+                      // Text node
+                      removeNode(ch.elm);
+                  }
+              }
+          }
+      }
+      function removeAndInvokeRemoveHook(vnode, rm) {
+          if (isDef(rm) || isDef(vnode.data)) {
+              var i;
+              var listeners = cbs.remove.length + 1;
+              if (isDef(rm)) {
+                  // we have a recursively passed down rm callback
+                  // increase the listeners count
+                  rm.listeners += listeners;
+              }
+              else {
+                  // directly removing
+                  rm = createRmCb(vnode.elm, listeners);
+              }
+              // recursively invoke hooks on child component root node
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
+              }
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
+              }
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          }
+          else {
+              removeNode(vnode.elm);
+          }
+      }
+      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+          var oldStartIdx = 0;
+          var newStartIdx = 0;
+          var oldEndIdx = oldCh.length - 1;
+          var oldStartVnode = oldCh[0];
+          var oldEndVnode = oldCh[oldEndIdx];
+          var newEndIdx = newCh.length - 1;
+          var newStartVnode = newCh[0];
+          var newEndVnode = newCh[newEndIdx];
+          var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          // removeOnly is a special flag used only by <transition-group>
+          // to ensure removed elements stay in correct relative positions
+          // during leaving transitions
+          var canMove = !removeOnly;
           {
-            checkDuplicateKeys(ch);
-          }
-          if (isDef(oldVnode.text)) {
-            nodeOps.setTextContent(elm, "");
-          }
-          addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-        } else if (isDef(oldCh)) {
-          removeVnodes(oldCh, 0, oldCh.length - 1);
-        } else if (isDef(oldVnode.text)) {
-          nodeOps.setTextContent(elm, "");
-        }
-      } else if (oldVnode.text !== vnode.text) {
-        nodeOps.setTextContent(elm, vnode.text);
-      }
-      if (isDef(data)) {
-        if (isDef((i = data.hook)) && isDef((i = i.postpatch))) {
-          i(oldVnode, vnode);
-        }
-      }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-      // delay insert hooks for component root nodes, invoke them after the
-      // element is really inserted
-      if (isTrue(initial) && isDef(vnode.parent)) {
-        vnode.parent.data.pendingInsert = queue;
-      } else {
-        for (var i = 0; i < queue.length; ++i) {
-          queue[i].data.hook.insert(queue[i]);
-        }
-      }
-    }
-    var hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    var isRenderedModule = makeMap("attrs,class,staticClass,staticStyle,key");
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-      var i;
-      var tag = vnode.tag;
-      var data = vnode.data;
-      var children = vnode.children;
-      inVPre = inVPre || (data && data.pre);
-      vnode.elm = elm;
-      if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-        vnode.isAsyncPlaceholder = true;
-        return true;
-      }
-      // assert node match
-      {
-        if (!assertNodeMatch(elm, vnode, inVPre)) {
-          return false;
-        }
-      }
-      if (isDef(data)) {
-        if (isDef((i = data.hook)) && isDef((i = i.init))) {
-          i(vnode, true /* hydrating */);
-        }
-        if (isDef((i = vnode.componentInstance))) {
-          // child component. it should have hydrated its own tree.
-          initComponent(vnode, insertedVnodeQueue);
-          return true;
-        }
-      }
-      if (isDef(tag)) {
-        if (isDef(children)) {
-          // empty element, allow client to pick up and populate children
-          if (!elm.hasChildNodes()) {
-            createChildren(vnode, children, insertedVnodeQueue);
-          } else {
-            // v-html and domProps: innerHTML
-            if (
-              isDef((i = data)) &&
-              isDef((i = i.domProps)) &&
-              isDef((i = i.innerHTML))
-            ) {
-              if (i !== elm.innerHTML) {
-                /* istanbul ignore if */
-                if (typeof console !== "undefined" && !hydrationBailed) {
-                  hydrationBailed = true;
-                  console.warn("Parent: ", elm);
-                  console.warn("server innerHTML: ", i);
-                  console.warn("client innerHTML: ", elm.innerHTML);
-                }
-                return false;
-              }
-            } else {
-              // iterate and compare children lists
-              var childrenMatch = true;
-              var childNode = elm.firstChild;
-              for (var i$1 = 0; i$1 < children.length; i$1++) {
-                if (
-                  !childNode ||
-                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)
-                ) {
-                  childrenMatch = false;
-                  break;
-                }
-                childNode = childNode.nextSibling;
-              }
-              // if childNode is not null, it means the actual childNodes list is
-              // longer than the virtual children list.
-              if (!childrenMatch || childNode) {
-                /* istanbul ignore if */
-                if (typeof console !== "undefined" && !hydrationBailed) {
-                  hydrationBailed = true;
-                  console.warn("Parent: ", elm);
-                  console.warn(
-                    "Mismatching childNodes vs. VNodes: ",
-                    elm.childNodes,
-                    children
-                  );
-                }
-                return false;
-              }
-            }
-          }
-        }
-        if (isDef(data)) {
-          var fullInvoke = false;
-          for (var key in data) {
-            if (!isRenderedModule(key)) {
-              fullInvoke = true;
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              break;
-            }
-          }
-          if (!fullInvoke && data["class"]) {
-            // ensure collecting deps for deep class bindings for future updates
-            traverse(data["class"]);
-          }
-        }
-      } else if (elm.data !== vnode.text) {
-        elm.data = vnode.text;
-      }
-      return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-      if (isDef(vnode.tag)) {
-        return (
-          vnode.tag.indexOf("vue-component") === 0 ||
-          (!isUnknownElement(vnode, inVPre) &&
-            vnode.tag.toLowerCase() ===
-              (node.tagName && node.tagName.toLowerCase()))
-        );
-      } else {
-        return node.nodeType === (vnode.isComment ? 8 : 3);
-      }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-      if (isUndef(vnode)) {
-        if (isDef(oldVnode)) {
-          invokeDestroyHook(oldVnode);
-        }
-        return;
-      }
-      var isInitialPatch = false;
-      var insertedVnodeQueue = [];
-      if (isUndef(oldVnode)) {
-        // empty mount (likely as component), create new root element
-        isInitialPatch = true;
-        createElm(vnode, insertedVnodeQueue);
-      } else {
-        var isRealElement = isDef(oldVnode.nodeType);
-        if (!isRealElement && sameVnode(oldVnode, vnode)) {
-          // patch existing root node
-          patchVnode(
-            oldVnode,
-            vnode,
-            insertedVnodeQueue,
-            null,
-            null,
-            removeOnly
-          );
-        } else {
-          if (isRealElement) {
-            // mounting to a real element
-            // check if this is server-rendered content and if we can perform
-            // a successful hydration.
-            if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-              oldVnode.removeAttribute(SSR_ATTR);
-              hydrating = true;
-            }
-            if (isTrue(hydrating)) {
-              if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                invokeInsertHook(vnode, insertedVnodeQueue, true);
-                return oldVnode;
-              } else {
-                warn(
-                  "The client-side rendered virtual DOM tree is not matching " +
-                    "server-rendered content. This is likely caused by incorrect " +
-                    "HTML markup, for example nesting block-level elements inside " +
-                    "<p>, or missing <tbody>. Bailing hydration and performing " +
-                    "full client-side render."
-                );
-              }
-            }
-            // either not server-rendered, or hydration failed.
-            // create an empty node and replace it
-            oldVnode = emptyNodeAt(oldVnode);
-          }
-          // replacing existing element
-          var oldElm = oldVnode.elm;
-          var parentElm = nodeOps.parentNode(oldElm);
-          // create new node
-          createElm(
-            vnode,
-            insertedVnodeQueue,
-            // extremely rare edge case: do not insert if old element is in a
-            // leaving transition. Only happens when combining transition +
-            // keep-alive + HOCs. (#4590)
-            oldElm._leaveCb ? null : parentElm,
-            nodeOps.nextSibling(oldElm)
-          );
-          // update parent placeholder node element, recursively
-          if (isDef(vnode.parent)) {
-            var ancestor = vnode.parent;
-            var patchable = isPatchable(vnode);
-            while (ancestor) {
-              for (var i = 0; i < cbs.destroy.length; ++i) {
-                cbs.destroy[i](ancestor);
-              }
-              ancestor.elm = vnode.elm;
-              if (patchable) {
-                for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                  cbs.create[i$1](emptyNode, ancestor);
-                }
-                // #6513
-                // invoke insert hooks that may have been merged by create hooks.
-                // e.g. for directives that uses the "inserted" hook.
-                var insert = ancestor.data.hook.insert;
-                if (insert.merged) {
-                  // start at index 1 to avoid re-invoking component mounted hook
-                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                    insert.fns[i$2]();
+              checkDuplicateKeys(newCh);
+          }
+          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+              if (isUndef(oldStartVnode)) {
+                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+              }
+              else if (isUndef(oldEndVnode)) {
+                  oldEndVnode = oldCh[--oldEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newStartVnode)) {
+                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else if (sameVnode(oldEndVnode, newEndVnode)) {
+                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newEndVnode)) {
+                  // Vnode moved right
+                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldEndVnode, newStartVnode)) {
+                  // Vnode moved left
+                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else {
+                  if (isUndef(oldKeyToIdx))
+                      { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                  idxInOld = isDef(newStartVnode.key)
+                      ? oldKeyToIdx[newStartVnode.key]
+                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                  if (isUndef(idxInOld)) {
+                      // New element
+                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                  }
+                  else {
+                      vnodeToMove = oldCh[idxInOld];
+                      if (sameVnode(vnodeToMove, newStartVnode)) {
+                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                          oldCh[idxInOld] = undefined;
+                          canMove &&
+                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                      }
+                      else {
+                          // same key but different element. treat as new element
+                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                      }
+                  }
+                  newStartVnode = newCh[++newStartIdx];
+              }
+          }
+          if (oldStartIdx > oldEndIdx) {
+              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+          }
+          else if (newStartIdx > newEndIdx) {
+              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+          }
+      }
+      function checkDuplicateKeys(children) {
+          var seenKeys = {};
+          for (var i = 0; i < children.length; i++) {
+              var vnode = children[i];
+              var key = vnode.key;
+              if (isDef(key)) {
+                  if (seenKeys[key]) {
+                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                  }
+                  else {
+                      seenKeys[key] = true;
+                  }
+              }
+          }
+      }
+      function findIdxInOld(node, oldCh, start, end) {
+          for (var i = start; i < end; i++) {
+              var c = oldCh[i];
+              if (isDef(c) && sameVnode(node, c))
+                  { return i; }
+          }
+      }
+      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+          if (oldVnode === vnode) {
+              return;
+          }
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // clone reused vnode
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          var elm = (vnode.elm = oldVnode.elm);
+          if (isTrue(oldVnode.isAsyncPlaceholder)) {
+              if (isDef(vnode.asyncFactory.resolved)) {
+                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+              }
+              else {
+                  vnode.isAsyncPlaceholder = true;
+              }
+              return;
+          }
+          // reuse element for static trees.
+          // note we only do this if the vnode is cloned -
+          // if the new node is not cloned it means the render functions have been
+          // reset by the hot-reload-api and we need to do a proper re-render.
+          if (isTrue(vnode.isStatic) &&
+              isTrue(oldVnode.isStatic) &&
+              vnode.key === oldVnode.key &&
+              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+              vnode.componentInstance = oldVnode.componentInstance;
+              return;
+          }
+          var i;
+          var data = vnode.data;
+          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+              i(oldVnode, vnode);
+          }
+          var oldCh = oldVnode.children;
+          var ch = vnode.children;
+          if (isDef(data) && isPatchable(vnode)) {
+              for (i = 0; i < cbs.update.length; ++i)
+                  { cbs.update[i](oldVnode, vnode); }
+              if (isDef((i = data.hook)) && isDef((i = i.update)))
+                  { i(oldVnode, vnode); }
+          }
+          if (isUndef(vnode.text)) {
+              if (isDef(oldCh) && isDef(ch)) {
+                  if (oldCh !== ch)
+                      { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+              }
+              else if (isDef(ch)) {
+                  {
+                      checkDuplicateKeys(ch);
+                  }
+                  if (isDef(oldVnode.text))
+                      { nodeOps.setTextContent(elm, ''); }
+                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+              }
+              else if (isDef(oldCh)) {
+                  removeVnodes(oldCh, 0, oldCh.length - 1);
+              }
+              else if (isDef(oldVnode.text)) {
+                  nodeOps.setTextContent(elm, '');
+              }
+          }
+          else if (oldVnode.text !== vnode.text) {
+              nodeOps.setTextContent(elm, vnode.text);
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                  { i(oldVnode, vnode); }
+          }
+      }
+      function invokeInsertHook(vnode, queue, initial) {
+          // delay insert hooks for component root nodes, invoke them after the
+          // element is really inserted
+          if (isTrue(initial) && isDef(vnode.parent)) {
+              vnode.parent.data.pendingInsert = queue;
+          }
+          else {
+              for (var i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
+              }
+          }
+      }
+      var hydrationBailed = false;
+      // list of modules that can skip create hook during hydration because they
+      // are already rendered on the client or has no need for initialization
+      // Note: style is excluded because it relies on initial clone for future
+      // deep updates (#7063).
+      var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      // Note: this is a browser-only function so we can assume elms are DOM nodes.
+      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+          var i;
+          var tag = vnode.tag;
+          var data = vnode.data;
+          var children = vnode.children;
+          inVPre = inVPre || (data && data.pre);
+          vnode.elm = elm;
+          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+              vnode.isAsyncPlaceholder = true;
+              return true;
+          }
+          // assert node match
+          {
+              if (!assertNodeMatch(elm, vnode, inVPre)) {
+                  return false;
+              }
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.init)))
+                  { i(vnode, true /* hydrating */); }
+              if (isDef((i = vnode.componentInstance))) {
+                  // child component. it should have hydrated its own tree.
+                  initComponent(vnode, insertedVnodeQueue);
+                  return true;
+              }
+          }
+          if (isDef(tag)) {
+              if (isDef(children)) {
+                  // empty element, allow client to pick up and populate children
+                  if (!elm.hasChildNodes()) {
+                      createChildren(vnode, children, insertedVnodeQueue);
+                  }
+                  else {
+                      // v-html and domProps: innerHTML
+                      if (isDef((i = data)) &&
+                          isDef((i = i.domProps)) &&
+                          isDef((i = i.innerHTML))) {
+                          if (i !== elm.innerHTML) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('server innerHTML: ', i);
+                                  console.warn('client innerHTML: ', elm.innerHTML);
+                              }
+                              return false;
+                          }
+                      }
+                      else {
+                          // iterate and compare children lists
+                          var childrenMatch = true;
+                          var childNode = elm.firstChild;
+                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                              if (!childNode ||
+                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  childrenMatch = false;
+                                  break;
+                              }
+                              childNode = childNode.nextSibling;
+                          }
+                          // if childNode is not null, it means the actual childNodes list is
+                          // longer than the virtual children list.
+                          if (!childrenMatch || childNode) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                              }
+                              return false;
+                          }
+                      }
+                  }
+              }
+              if (isDef(data)) {
+                  var fullInvoke = false;
+                  for (var key in data) {
+                      if (!isRenderedModule(key)) {
+                          fullInvoke = true;
+                          invokeCreateHooks(vnode, insertedVnodeQueue);
+                          break;
+                      }
+                  }
+                  if (!fullInvoke && data['class']) {
+                      // ensure collecting deps for deep class bindings for future updates
+                      traverse(data['class']);
                   }
-                }
-              } else {
-                registerRef(ancestor);
               }
-              ancestor = ancestor.parent;
-            }
           }
-          // destroy old node
-          if (isDef(parentElm)) {
-            removeVnodes([oldVnode], 0, 0);
-          } else if (isDef(oldVnode.tag)) {
-            invokeDestroyHook(oldVnode);
+          else if (elm.data !== vnode.text) {
+              elm.data = vnode.text;
+          }
+          return true;
+      }
+      function assertNodeMatch(node, vnode, inVPre) {
+          if (isDef(vnode.tag)) {
+              return (vnode.tag.indexOf('vue-component') === 0 ||
+                  (!isUnknownElement(vnode, inVPre) &&
+                      vnode.tag.toLowerCase() ===
+                          (node.tagName && node.tagName.toLowerCase())));
+          }
+          else {
+              return node.nodeType === (vnode.isComment ? 8 : 3);
           }
-        }
       }
-      invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-      return vnode.elm;
-    };
+      return function patch(oldVnode, vnode, hydrating, removeOnly) {
+          if (isUndef(vnode)) {
+              if (isDef(oldVnode))
+                  { invokeDestroyHook(oldVnode); }
+              return;
+          }
+          var isInitialPatch = false;
+          var insertedVnodeQueue = [];
+          if (isUndef(oldVnode)) {
+              // empty mount (likely as component), create new root element
+              isInitialPatch = true;
+              createElm(vnode, insertedVnodeQueue);
+          }
+          else {
+              var isRealElement = isDef(oldVnode.nodeType);
+              if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                  // patch existing root node
+                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+              }
+              else {
+                  if (isRealElement) {
+                      // mounting to a real element
+                      // check if this is server-rendered content and if we can perform
+                      // a successful hydration.
+                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                          oldVnode.removeAttribute(SSR_ATTR);
+                          hydrating = true;
+                      }
+                      if (isTrue(hydrating)) {
+                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                              invokeInsertHook(vnode, insertedVnodeQueue, true);
+                              return oldVnode;
+                          }
+                          else {
+                              warn('The client-side rendered virtual DOM tree is not matching ' +
+                                  'server-rendered content. This is likely caused by incorrect ' +
+                                  'HTML markup, for example nesting block-level elements inside ' +
+                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                  'full client-side render.');
+                          }
+                      }
+                      // either not server-rendered, or hydration failed.
+                      // create an empty node and replace it
+                      oldVnode = emptyNodeAt(oldVnode);
+                  }
+                  // replacing existing element
+                  var oldElm = oldVnode.elm;
+                  var parentElm = nodeOps.parentNode(oldElm);
+                  // create new node
+                  createElm(vnode, insertedVnodeQueue, 
+                  // extremely rare edge case: do not insert if old element is in a
+                  // leaving transition. Only happens when combining transition +
+                  // keep-alive + HOCs. (#4590)
+                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                  // update parent placeholder node element, recursively
+                  if (isDef(vnode.parent)) {
+                      var ancestor = vnode.parent;
+                      var patchable = isPatchable(vnode);
+                      while (ancestor) {
+                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
+                          }
+                          ancestor.elm = vnode.elm;
+                          if (patchable) {
+                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
+                                  cbs.create[i$1](emptyNode, ancestor);
+                              }
+                              // #6513
+                              // invoke insert hooks that may have been merged by create hooks.
+                              // e.g. for directives that uses the "inserted" hook.
+                              var insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
+                                  // start at index 1 to avoid re-invoking component mounted hook
+                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
+                                      insert.fns[i$2]();
+                                  }
+                              }
+                          }
+                          else {
+                              registerRef(ancestor);
+                          }
+                          ancestor = ancestor.parent;
+                      }
+                  }
+                  // destroy old node
+                  if (isDef(parentElm)) {
+                      removeVnodes([oldVnode], 0, 0);
+                  }
+                  else if (isDef(oldVnode.tag)) {
+                      invokeDestroyHook(oldVnode);
+                  }
+              }
+          }
+          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+          return vnode.elm;
+      };
   }
 
   var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-      // @ts-expect-error emptyNode is not VNodeWithData
-      updateDirectives(vnode, emptyNode);
-    },
+      create: updateDirectives,
+      update: updateDirectives,
+      destroy: function unbindDirectives(vnode) {
+          // @ts-expect-error emptyNode is not VNodeWithData
+          updateDirectives(vnode, emptyNode);
+      },
   };
   function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-      _update(oldVnode, vnode);
-    }
+      if (oldVnode.data.directives || vnode.data.directives) {
+          _update(oldVnode, vnode);
+      }
   }
   function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(
-      oldVnode.data.directives,
-      oldVnode.context
-    );
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
-    for (key in newDirs) {
-      oldDir = oldDirs[key];
-      dir = newDirs[key];
-      if (!oldDir) {
-        // new directive, bind
-        callHook(dir, "bind", vnode, oldVnode);
-        if (dir.def && dir.def.inserted) {
-          dirsWithInsert.push(dir);
-        }
-      } else {
-        // existing directive, update
-        dir.oldValue = oldDir.value;
-        dir.oldArg = oldDir.arg;
-        callHook(dir, "update", vnode, oldVnode);
-        if (dir.def && dir.def.componentUpdated) {
-          dirsWithPostpatch.push(dir);
-        }
-      }
-    }
-    if (dirsWithInsert.length) {
-      var callInsert = function () {
-        for (var i = 0; i < dirsWithInsert.length; i++) {
-          callHook(dirsWithInsert[i], "inserted", vnode, oldVnode);
-        }
-      };
-      if (isCreate) {
-        mergeVNodeHook(vnode, "insert", callInsert);
-      } else {
-        callInsert();
-      }
-    }
-    if (dirsWithPostpatch.length) {
-      mergeVNodeHook(vnode, "postpatch", function () {
-        for (var i = 0; i < dirsWithPostpatch.length; i++) {
-          callHook(dirsWithPostpatch[i], "componentUpdated", vnode, oldVnode);
-        }
-      });
-    }
-    if (!isCreate) {
-      for (key in oldDirs) {
-        if (!newDirs[key]) {
-          // no longer present, unbind
-          callHook(oldDirs[key], "unbind", oldVnode, oldVnode, isDestroy);
-        }
+      var isCreate = oldVnode === emptyNode;
+      var isDestroy = vnode === emptyNode;
+      var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+      var dirsWithInsert = [];
+      var dirsWithPostpatch = [];
+      var key, oldDir, dir;
+      for (key in newDirs) {
+          oldDir = oldDirs[key];
+          dir = newDirs[key];
+          if (!oldDir) {
+              // new directive, bind
+              callHook(dir, 'bind', vnode, oldVnode);
+              if (dir.def && dir.def.inserted) {
+                  dirsWithInsert.push(dir);
+              }
+          }
+          else {
+              // existing directive, update
+              dir.oldValue = oldDir.value;
+              dir.oldArg = oldDir.arg;
+              callHook(dir, 'update', vnode, oldVnode);
+              if (dir.def && dir.def.componentUpdated) {
+                  dirsWithPostpatch.push(dir);
+              }
+          }
+      }
+      if (dirsWithInsert.length) {
+          var callInsert = function () {
+              for (var i = 0; i < dirsWithInsert.length; i++) {
+                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+              }
+          };
+          if (isCreate) {
+              mergeVNodeHook(vnode, 'insert', callInsert);
+          }
+          else {
+              callInsert();
+          }
+      }
+      if (dirsWithPostpatch.length) {
+          mergeVNodeHook(vnode, 'postpatch', function () {
+              for (var i = 0; i < dirsWithPostpatch.length; i++) {
+                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+              }
+          });
+      }
+      if (!isCreate) {
+          for (key in oldDirs) {
+              if (!newDirs[key]) {
+                  // no longer present, unbind
+                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+              }
+          }
       }
-    }
   }
   var emptyModifiers = Object.create(null);
   function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
-    if (!dirs) {
+      var res = Object.create(null);
+      if (!dirs) {
+          // $flow-disable-line
+          return res;
+      }
+      var i, dir;
+      for (i = 0; i < dirs.length; i++) {
+          dir = dirs[i];
+          if (!dir.modifiers) {
+              // $flow-disable-line
+              dir.modifiers = emptyModifiers;
+          }
+          res[getRawDirName(dir)] = dir;
+          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+      }
       // $flow-disable-line
       return res;
-    }
-    var i, dir;
-    for (i = 0; i < dirs.length; i++) {
-      dir = dirs[i];
-      if (!dir.modifiers) {
-        // $flow-disable-line
-        dir.modifiers = emptyModifiers;
-      }
-      res[getRawDirName(dir)] = dir;
-      dir.def = resolveAsset(vm.$options, "directives", dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
   }
   function getRawDirName(dir) {
-    return (
-      dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join(".")
-    );
+      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
   }
   function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
-    if (fn) {
-      try {
-        fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-      } catch (e) {
-        handleError(
-          e,
-          vnode.context,
-          "directive " + dir.name + " " + hook + " hook"
-        );
+      var fn = dir.def && dir.def[hook];
+      if (fn) {
+          try {
+              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+          }
+          catch (e) {
+              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+          }
       }
-    }
   }
 
   var baseModules = [ref, directives];
 
   function updateAttrs(oldVnode, vnode) {
-    var opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-      return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-      return;
-    }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-      attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-      cur = attrs[key];
-      old = oldAttrs[key];
-      if (old !== cur) {
-        setAttr(elm, key, cur, vnode.data.pre);
-      }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-      setAttr(elm, "value", attrs.value);
-    }
-    for (key in oldAttrs) {
-      if (isUndef(attrs[key])) {
-        if (isXlink(key)) {
-          elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        } else if (!isEnumeratedAttr(key)) {
-          elm.removeAttribute(key);
-        }
-      }
-    }
+      var opts = vnode.componentOptions;
+      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+          return;
+      }
+      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+          return;
+      }
+      var key, cur, old;
+      var elm = vnode.elm;
+      var oldAttrs = oldVnode.data.attrs || {};
+      var attrs = vnode.data.attrs || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(attrs.__ob__)) {
+          attrs = vnode.data.attrs = extend({}, attrs);
+      }
+      for (key in attrs) {
+          cur = attrs[key];
+          old = oldAttrs[key];
+          if (old !== cur) {
+              setAttr(elm, key, cur, vnode.data.pre);
+          }
+      }
+      // #4391: in IE9, setting type can reset value for input[type=radio]
+      // #6666: IE/Edge forces progress value down to 1 before setting a max
+      /* istanbul ignore if */
+      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+          setAttr(elm, 'value', attrs.value);
+      }
+      for (key in oldAttrs) {
+          if (isUndef(attrs[key])) {
+              if (isXlink(key)) {
+                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+              }
+              else if (!isEnumeratedAttr(key)) {
+                  elm.removeAttribute(key);
+              }
+          }
+      }
   }
   function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf("-") > -1) {
-      baseSetAttr(el, key, value);
-    } else if (isBooleanAttr(key)) {
-      // set attribute for blank value
-      // e.g. <option disabled>Select one</option>
-      if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-      } else {
-        // technically allowfullscreen is a boolean attribute for <iframe>,
-        // but Flash expects a value of "true" when used on <embed> tag
-        value =
-          key === "allowfullscreen" && el.tagName === "EMBED" ? "true" : key;
-        el.setAttribute(key, value);
-      }
-    } else if (isEnumeratedAttr(key)) {
-      el.setAttribute(key, convertEnumeratedValue(key, value));
-    } else if (isXlink(key)) {
-      if (isFalsyAttrValue(value)) {
-        el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-      } else {
-        el.setAttributeNS(xlinkNS, key, value);
+      if (isInPre || el.tagName.indexOf('-') > -1) {
+          baseSetAttr(el, key, value);
+      }
+      else if (isBooleanAttr(key)) {
+          // set attribute for blank value
+          // e.g. <option disabled>Select one</option>
+          if (isFalsyAttrValue(value)) {
+              el.removeAttribute(key);
+          }
+          else {
+              // technically allowfullscreen is a boolean attribute for <iframe>,
+              // but Flash expects a value of "true" when used on <embed> tag
+              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+              el.setAttribute(key, value);
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          el.setAttribute(key, convertEnumeratedValue(key, value));
+      }
+      else if (isXlink(key)) {
+          if (isFalsyAttrValue(value)) {
+              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+          }
+          else {
+              el.setAttributeNS(xlinkNS, key, value);
+          }
+      }
+      else {
+          baseSetAttr(el, key, value);
       }
-    } else {
-      baseSetAttr(el, key, value);
-    }
   }
   function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
-    } else {
-      // #7138: IE10 & 11 fires input event when setting placeholder on
-      // <textarea>... block the first input event and remove the blocker
-      // immediately.
-      /* istanbul ignore if */
-      if (
-        isIE &&
-        !isIE9 &&
-        el.tagName === "TEXTAREA" &&
-        key === "placeholder" &&
-        value !== "" &&
-        !el.__ieph
-      ) {
-        var blocker = function (e) {
-          e.stopImmediatePropagation();
-          el.removeEventListener("input", blocker);
-        };
-        el.addEventListener("input", blocker);
-        // $flow-disable-line
-        el.__ieph = true; /* IE placeholder patched */
-      }
-      el.setAttribute(key, value);
-    }
+      if (isFalsyAttrValue(value)) {
+          el.removeAttribute(key);
+      }
+      else {
+          // #7138: IE10 & 11 fires input event when setting placeholder on
+          // <textarea>... block the first input event and remove the blocker
+          // immediately.
+          /* istanbul ignore if */
+          if (isIE &&
+              !isIE9 &&
+              el.tagName === 'TEXTAREA' &&
+              key === 'placeholder' &&
+              value !== '' &&
+              !el.__ieph) {
+              var blocker = function (e) {
+                  e.stopImmediatePropagation();
+                  el.removeEventListener('input', blocker);
+              };
+              el.addEventListener('input', blocker);
+              // $flow-disable-line
+              el.__ieph = true; /* IE placeholder patched */
+          }
+          el.setAttribute(key, value);
+      }
   }
   var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
+      create: updateAttrs,
+      update: updateAttrs,
   };
 
   function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-    if (
-      isUndef(data.staticClass) &&
-      isUndef(data.class) &&
-      (isUndef(oldData) ||
-        (isUndef(oldData.staticClass) && isUndef(oldData.class)))
-    ) {
-      return;
-    }
-    var cls = genClassForVnode(vnode);
-    // handle transition classes
-    var transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-      cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-      el.setAttribute("class", cls);
-      el._prevClass = cls;
-    }
+      var el = vnode.elm;
+      var data = vnode.data;
+      var oldData = oldVnode.data;
+      if (isUndef(data.staticClass) &&
+          isUndef(data.class) &&
+          (isUndef(oldData) ||
+              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+          return;
+      }
+      var cls = genClassForVnode(vnode);
+      // handle transition classes
+      var transitionClass = el._transitionClasses;
+      if (isDef(transitionClass)) {
+          cls = concat(cls, stringifyClass(transitionClass));
+      }
+      // set the class
+      if (cls !== el._prevClass) {
+          el.setAttribute('class', cls);
+          el._prevClass = cls;
+      }
   }
   var klass = {
-    create: updateClass,
-    update: updateClass,
+      create: updateClass,
+      update: updateClass,
   };
 
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = "__r";
-  var CHECKBOX_RADIO_TOKEN = "__c";
+  var RANGE_TOKEN = '__r';
+  var CHECKBOX_RADIO_TOKEN = '__c';
 
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
   // the whole point is ensuring the v-model callback gets called before
   // user-attached handlers.
   function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-      // IE input[type=range] only supports `change` event
-      var event = isIE ? "change" : "input";
-      on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-      delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-      on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-      delete on[CHECKBOX_RADIO_TOKEN];
-    }
+      /* istanbul ignore if */
+      if (isDef(on[RANGE_TOKEN])) {
+          // IE input[type=range] only supports `change` event
+          var event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          delete on[RANGE_TOKEN];
+      }
+      // This was originally intended to fix #4521 but no longer necessary
+      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+      /* istanbul ignore if */
+      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+          delete on[CHECKBOX_RADIO_TOKEN];
+      }
   }
   var target;
   function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
-    return function onceHandler() {
-      var res = handler.apply(null, arguments);
-      if (res !== null) {
-        remove(event, onceHandler, capture, _target);
-      }
-    };
+      var _target = target; // save current target element in closure
+      return function onceHandler() {
+          var res = handler.apply(null, arguments);
+          if (res !== null) {
+              remove(event, onceHandler, capture, _target);
+          }
+      };
   }
   // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
   var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
   function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-      var attachedTimestamp = currentFlushTimestamp;
-      var original = handler;
-      //@ts-expect-error
-      handler = original._wrapper = function (e) {
-        if (
-          // no bubbling, should always fire.
-          // this is just a safety net in case event.timeStamp is unreliable in
-          // certain weird environments...
-          e.target === e.currentTarget ||
-          // event is fired after handler attachment
-          e.timeStamp >= attachedTimestamp ||
-          // bail for environments that have buggy event.timeStamp implementations
-          // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-          // #9681 QtWebEngine event.timeStamp is negative value
-          e.timeStamp <= 0 ||
-          // #9448 bail if event is fired in another document in a multi-page
-          // electron/nw.js app, since event.timeStamp will be using a different
-          // starting reference
-          e.target.ownerDocument !== document
-        ) {
-          return original.apply(this, arguments);
-        }
-      };
-    }
-    target.addEventListener(
-      name,
-      handler,
-      supportsPassive ? { capture: capture, passive: passive } : capture
-    );
+      // async edge case #6566: inner click event triggers patch, event handler
+      // attached to outer element during patch, and triggered again. This
+      // happens because browsers fire microtask ticks between event propagation.
+      // the solution is simple: we save the timestamp when a handler is attached,
+      // and the handler would only fire if the event passed to it was fired
+      // AFTER it was attached.
+      if (useMicrotaskFix) {
+          var attachedTimestamp = currentFlushTimestamp;
+          var original = handler;
+          //@ts-expect-error
+          handler = original._wrapper = function (e) {
+              if (
+              // no bubbling, should always fire.
+              // this is just a safety net in case event.timeStamp is unreliable in
+              // certain weird environments...
+              e.target === e.currentTarget ||
+                  // event is fired after handler attachment
+                  e.timeStamp >= attachedTimestamp ||
+                  // bail for environments that have buggy event.timeStamp implementations
+                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                  // #9681 QtWebEngine event.timeStamp is negative value
+                  e.timeStamp <= 0 ||
+                  // #9448 bail if event is fired in another document in a multi-page
+                  // electron/nw.js app, since event.timeStamp will be using a different
+                  // starting reference
+                  e.target.ownerDocument !== document) {
+                  return original.apply(this, arguments);
+              }
+          };
+      }
+      target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
   }
   function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(
-      name,
+      (_target || target).removeEventListener(name, 
       //@ts-expect-error
-      handler._wrapper || handler,
-      capture
-    );
+      handler._wrapper || handler, capture);
   }
   function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-      return;
-    }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
+      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+          return;
+      }
+      var on = vnode.data.on || {};
+      var oldOn = oldVnode.data.on || {};
+      target = vnode.elm;
+      normalizeEvents(on);
+      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+      target = undefined;
   }
   var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
+      create: updateDOMListeners,
+      update: updateDOMListeners,
   };
 
   var svgContainer;
   function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-      return;
-    }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-      props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-      if (!(key in props)) {
-        elm[key] = "";
-      }
-    }
-    for (key in props) {
-      cur = props[key];
-      // ignore children if the node has textContent or innerHTML,
-      // as these will throw away existing DOM nodes and cause removal errors
-      // on subsequent patches (#3360)
-      if (key === "textContent" || key === "innerHTML") {
-        if (vnode.children) {
-          vnode.children.length = 0;
-        }
-        if (cur === oldProps[key]) {
-          continue;
-        }
-        // #6601 work around Chrome version <= 55 bug where single textNode
-        // replaced by innerHTML/textContent retains its parentNode property
-        if (elm.childNodes.length === 1) {
-          elm.removeChild(elm.childNodes[0]);
-        }
-      }
-      if (key === "value" && elm.tagName !== "PROGRESS") {
-        // store value as _value as well since
-        // non-string values will be stringified
-        elm._value = cur;
-        // avoid resetting cursor position when value is the same
-        var strCur = isUndef(cur) ? "" : String(cur);
-        if (shouldUpdateValue(elm, strCur)) {
-          elm.value = strCur;
-        }
-      } else if (
-        key === "innerHTML" &&
-        isSVG(elm.tagName) &&
-        isUndef(elm.innerHTML)
-      ) {
-        // IE doesn't support innerHTML for SVG elements
-        svgContainer = svgContainer || document.createElement("div");
-        svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-        var svg = svgContainer.firstChild;
-        while (elm.firstChild) {
-          elm.removeChild(elm.firstChild);
-        }
-        while (svg.firstChild) {
-          elm.appendChild(svg.firstChild);
-        }
-      } else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]
-      ) {
-        // some property updates can throw
-        // e.g. `value` on <progress> w/ non-finite value
-        try {
-          elm[key] = cur;
-        } catch (e) {}
-      }
-    }
+      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+          return;
+      }
+      var key, cur;
+      var elm = vnode.elm;
+      var oldProps = oldVnode.data.domProps || {};
+      var props = vnode.data.domProps || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(props.__ob__)) {
+          props = vnode.data.domProps = extend({}, props);
+      }
+      for (key in oldProps) {
+          if (!(key in props)) {
+              elm[key] = '';
+          }
+      }
+      for (key in props) {
+          cur = props[key];
+          // ignore children if the node has textContent or innerHTML,
+          // as these will throw away existing DOM nodes and cause removal errors
+          // on subsequent patches (#3360)
+          if (key === 'textContent' || key === 'innerHTML') {
+              if (vnode.children)
+                  { vnode.children.length = 0; }
+              if (cur === oldProps[key])
+                  { continue; }
+              // #6601 work around Chrome version <= 55 bug where single textNode
+              // replaced by innerHTML/textContent retains its parentNode property
+              if (elm.childNodes.length === 1) {
+                  elm.removeChild(elm.childNodes[0]);
+              }
+          }
+          if (key === 'value' && elm.tagName !== 'PROGRESS') {
+              // store value as _value as well since
+              // non-string values will be stringified
+              elm._value = cur;
+              // avoid resetting cursor position when value is the same
+              var strCur = isUndef(cur) ? '' : String(cur);
+              if (shouldUpdateValue(elm, strCur)) {
+                  elm.value = strCur;
+              }
+          }
+          else if (key === 'innerHTML' &&
+              isSVG(elm.tagName) &&
+              isUndef(elm.innerHTML)) {
+              // IE doesn't support innerHTML for SVG elements
+              svgContainer = svgContainer || document.createElement('div');
+              svgContainer.innerHTML = "<svg>" + cur + "</svg>";
+              var svg = svgContainer.firstChild;
+              while (elm.firstChild) {
+                  elm.removeChild(elm.firstChild);
+              }
+              while (svg.firstChild) {
+                  elm.appendChild(svg.firstChild);
+              }
+          }
+          else if (
+          // skip the update if old and new VDOM state is the same.
+          // `value` is handled separately because the DOM value may be temporarily
+          // out of sync with VDOM state due to focus, composition and modifiers.
+          // This  #4521 by skipping the unnecessary `checked` update.
+          cur !== oldProps[key]) {
+              // some property updates can throw
+              // e.g. `value` on <progress> w/ non-finite value
+              try {
+                  elm[key] = cur;
+              }
+              catch (e) { }
+          }
+      }
   }
   function shouldUpdateValue(elm, checkVal) {
-    return (
+      return (
       //@ts-expect-error
       !elm.composing &&
-      (elm.tagName === "OPTION" ||
-        isNotInFocusAndDirty(elm, checkVal) ||
-        isDirtyWithModifiers(elm, checkVal))
-    );
+          (elm.tagName === 'OPTION' ||
+              isNotInFocusAndDirty(elm, checkVal) ||
+              isDirtyWithModifiers(elm, checkVal)));
   }
   function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    var notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-      notInFocus = document.activeElement !== elm;
-    } catch (e) {}
-    return notInFocus && elm.value !== checkVal;
+      // return true when textbox (.number and .trim) loses focus and its value is
+      // not equal to the updated value
+      var notInFocus = true;
+      // #6157
+      // work around IE bug when accessing document.activeElement in an iframe
+      try {
+          notInFocus = document.activeElement !== elm;
+      }
+      catch (e) { }
+      return notInFocus && elm.value !== checkVal;
   }
   function isDirtyWithModifiers(elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-      if (modifiers.number) {
-        return toNumber(value) !== toNumber(newVal);
-      }
-      if (modifiers.trim) {
-        return value.trim() !== newVal.trim();
+      var value = elm.value;
+      var modifiers = elm._vModifiers; // injected by v-model runtime
+      if (isDef(modifiers)) {
+          if (modifiers.number) {
+              return toNumber(value) !== toNumber(newVal);
+          }
+          if (modifiers.trim) {
+              return value.trim() !== newVal.trim();
+          }
       }
-    }
-    return value !== newVal;
+      return value !== newVal;
   }
   var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
+      create: updateDOMProps,
+      update: updateDOMProps,
   };
 
   var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res;
+      var res = {};
+      var listDelimiter = /;(?![^(]*\))/g;
+      var propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              var tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
   });
   // merge static and dynamic style data on the same vnode
   function normalizeStyleData(data) {
-    var style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
+      var style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
   }
   // normalize possible array / string values into Object
   function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-      return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === "string") {
-      return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
   }
   /**
    * parent component style should be after child's
    * so that parent component's style could override it
    */
   function getStyle(vnode, checkChild) {
-    var res = {};
-    var styleData;
-    if (checkChild) {
-      var childNode = vnode;
-      while (childNode.componentInstance) {
-        childNode = childNode.componentInstance._vnode;
-        if (
-          childNode &&
-          childNode.data &&
-          (styleData = normalizeStyleData(childNode.data))
-        ) {
+      var res = {};
+      var styleData;
+      if (checkChild) {
+          var childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
-        }
-      }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-      extend(res, styleData);
-    }
-    var parentNode = vnode;
-    while ((parentNode = parentNode.parent)) {
-      if (
-        parentNode.data &&
-        (styleData = normalizeStyleData(parentNode.data))
-      ) {
-        extend(res, styleData);
-      }
-    }
-    return res;
+      }
+      var parentNode = vnode;
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
+      }
+      return res;
   }
 
   var cssVarRE = /^--/;
   var importantRE = /\s*!important$/;
   var setProp = function (el, name, val) {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-      el.style.setProperty(name, val);
-    } else if (importantRE.test(val)) {
-      el.style.setProperty(
-        hyphenate(name),
-        val.replace(importantRE, ""),
-        "important"
-      );
-    } else {
-      var normalizedName = normalize(name);
-      if (Array.isArray(val)) {
-        // Support values array created by autoprefixer, e.g.
-        // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-        // Set them one by one, and the browser will only set those it can recognize
-        for (var i = 0, len = val.length; i < len; i++) {
-          el.style[normalizedName] = val[i];
-        }
-      } else {
-        el.style[normalizedName] = val;
-      }
-    }
+      /* istanbul ignore if */
+      if (cssVarRE.test(name)) {
+          el.style.setProperty(name, val);
+      }
+      else if (importantRE.test(val)) {
+          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+      }
+      else {
+          var normalizedName = normalize(name);
+          if (Array.isArray(val)) {
+              // Support values array created by autoprefixer, e.g.
+              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+              // Set them one by one, and the browser will only set those it can recognize
+              for (var i = 0, len = val.length; i < len; i++) {
+                  el.style[normalizedName] = val[i];
+              }
+          }
+          else {
+              el.style[normalizedName] = val;
+          }
+      }
   };
-  var vendorNames = ["Webkit", "Moz", "ms"];
+  var vendorNames = ['Webkit', 'Moz', 'ms'];
   var emptyStyle;
   var normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement("div").style;
-    prop = camelize(prop);
-    if (prop !== "filter" && prop in emptyStyle) {
-      return prop;
-    }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-      var name = vendorNames[i] + capName;
-      if (name in emptyStyle) {
-        return name;
-      }
-    }
+      emptyStyle = emptyStyle || document.createElement('div').style;
+      prop = camelize(prop);
+      if (prop !== 'filter' && prop in emptyStyle) {
+          return prop;
+      }
+      var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (var i = 0; i < vendorNames.length; i++) {
+          var name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
+          }
+      }
   });
   function updateStyle(oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-    if (
-      isUndef(data.staticStyle) &&
-      isUndef(data.style) &&
-      isUndef(oldData.staticStyle) &&
-      isUndef(oldData.style)
-    ) {
-      return;
-    }
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-    var style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__)
-      ? extend({}, style)
-      : style;
-    var newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-      if (isUndef(newStyle[name])) {
-        setProp(el, name, "");
-      }
-    }
-    for (name in newStyle) {
-      cur = newStyle[name];
-      if (cur !== oldStyle[name]) {
-        // ie9 setting to null has no effect, must use empty string
-        setProp(el, name, cur == null ? "" : cur);
-      }
-    }
+      var data = vnode.data;
+      var oldData = oldVnode.data;
+      if (isUndef(data.staticStyle) &&
+          isUndef(data.style) &&
+          isUndef(oldData.staticStyle) &&
+          isUndef(oldData.style)) {
+          return;
+      }
+      var cur, name;
+      var el = vnode.elm;
+      var oldStaticStyle = oldData.staticStyle;
+      var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+      var oldStyle = oldStaticStyle || oldStyleBinding;
+      var style = normalizeStyleBinding(vnode.data.style) || {};
+      // store normalized style under a different key for next diff
+      // make sure to clone it if it's reactive, since the user likely wants
+      // to mutate it.
+      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+      var newStyle = getStyle(vnode, true);
+      for (name in oldStyle) {
+          if (isUndef(newStyle[name])) {
+              setProp(el, name, '');
+          }
+      }
+      for (name in newStyle) {
+          cur = newStyle[name];
+          if (cur !== oldStyle[name]) {
+              // ie9 setting to null has no effect, must use empty string
+              setProp(el, name, cur == null ? '' : cur);
+          }
+      }
   }
   var style = {
-    create: updateStyle,
-    update: updateStyle,
+      create: updateStyle,
+      update: updateStyle,
   };
 
   var whitespaceRE = /\s+/;
@@ -6958,493 +6344,464 @@
    * SVG elements in IE
    */
   function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-      return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-      if (cls.indexOf(" ") > -1) {
-        cls.split(whitespaceRE).forEach(function (c) {
-          return el.classList.add(c);
-        });
-      } else {
-        el.classList.add(cls);
-      }
-    } else {
-      var cur = " " + (el.getAttribute("class") || "") + " ";
-      if (cur.indexOf(" " + cls + " ") < 0) {
-        el.setAttribute("class", (cur + cls).trim());
-      }
-    }
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+          }
+          else {
+              el.classList.add(cls);
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
+      }
   }
   /**
    * Remove class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
    */
   function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-      return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-      if (cls.indexOf(" ") > -1) {
-        cls.split(whitespaceRE).forEach(function (c) {
-          return el.classList.remove(c);
-        });
-      } else {
-        el.classList.remove(cls);
-      }
-      if (!el.classList.length) {
-        el.removeAttribute("class");
-      }
-    } else {
-      var cur = " " + (el.getAttribute("class") || "") + " ";
-      var tar = " " + cls + " ";
-      while (cur.indexOf(tar) >= 0) {
-        cur = cur.replace(tar, " ");
-      }
-      cur = cur.trim();
-      if (cur) {
-        el.setAttribute("class", cur);
-      } else {
-        el.removeAttribute("class");
-      }
-    }
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          var cur = " " + (el.getAttribute('class') || '') + " ";
+          var tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
+      }
   }
 
   function resolveTransition(def) {
-    if (!def) {
-      return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === "object") {
-      var res = {};
-      if (def.css !== false) {
-        extend(res, autoCssTransition(def.name || "v"));
+      if (!def) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def === 'object') {
+          var res = {};
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
+          }
+          extend(res, def);
+          return res;
+      }
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
       }
-      extend(res, def);
-      return res;
-    } else if (typeof def === "string") {
-      return autoCssTransition(def);
-    }
   }
   var autoCssTransition = cached(function (name) {
-    return {
-      enterClass: name + "-enter",
-      enterToClass: name + "-enter-to",
-      enterActiveClass: name + "-enter-active",
-      leaveClass: name + "-leave",
-      leaveToClass: name + "-leave-to",
-      leaveActiveClass: name + "-leave-active",
-    };
+      return {
+          enterClass: (name + "-enter"),
+          enterToClass: (name + "-enter-to"),
+          enterActiveClass: (name + "-enter-active"),
+          leaveClass: (name + "-leave"),
+          leaveToClass: (name + "-leave-to"),
+          leaveActiveClass: (name + "-leave-active"),
+      };
   });
   var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = "transition";
-  var ANIMATION = "animation";
+  var TRANSITION = 'transition';
+  var ANIMATION = 'animation';
   // Transition property/event sniffing
-  var transitionProp = "transition";
-  var transitionEndEvent = "transitionend";
-  var animationProp = "animation";
-  var animationEndEvent = "animationend";
+  var transitionProp = 'transition';
+  var transitionEndEvent = 'transitionend';
+  var animationProp = 'animation';
+  var animationEndEvent = 'animationend';
   if (hasTransition) {
-    /* istanbul ignore if */
-    if (
-      window.ontransitionend === undefined &&
-      // @ts-expect-error
-      window.onwebkittransitionend !== undefined
-    ) {
-      transitionProp = "WebkitTransition";
-      transitionEndEvent = "webkitTransitionEnd";
-    }
-    if (
-      window.onanimationend === undefined &&
-      // @ts-expect-error
-      window.onwebkitanimationend !== undefined
-    ) {
-      animationProp = "WebkitAnimation";
-      animationEndEvent = "webkitAnimationEnd";
-    }
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          // @ts-expect-error
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          // @ts-expect-error
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
   var raf = inBrowser
-    ? window.requestAnimationFrame
-      ? window.requestAnimationFrame.bind(window)
-      : setTimeout
-    : /* istanbul ignore next */ function (fn) {
-        return fn();
-      };
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ function (fn) { return fn(); };
   function nextFrame(fn) {
-    raf(function () {
-      // @ts-expect-error
-      raf(fn);
-    });
+      raf(function () {
+          // @ts-expect-error
+          raf(fn);
+      });
   }
   function addTransitionClass(el, cls) {
-    var transitionClasses =
-      el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-      transitionClasses.push(cls);
-      addClass(el, cls);
-    }
+      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
   }
   function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-      remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
+      if (el._transitionClasses) {
+          remove$2(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
-    if (!type) {
-      return cb();
-    }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
-      el.removeEventListener(event, onEnd);
-      cb();
-    };
-    var onEnd = function (e) {
-      if (e.target === el) {
-        if (++ended >= propCount) {
-          end();
-        }
-      }
-    };
-    setTimeout(function () {
-      if (ended < propCount) {
-        end();
-      }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
+      var ref = getTransitionInfo(el, expectedType);
+      var type = ref.type;
+      var timeout = ref.timeout;
+      var propCount = ref.propCount;
+      if (!type)
+          { return cb(); }
+      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      var ended = 0;
+      var end = function () {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      var onEnd = function (e) {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(function () {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
   }
   var transformRE = /\b(transform|all)(,|$)/;
   function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + "Delay"] || "").split(", ");
-    var transitionDurations = (styles[transitionProp + "Duration"] || "").split(
-      ", "
-    );
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + "Delay"] || "").split(", ");
-    var animationDurations = (styles[animationProp + "Duration"] || "").split(
-      ", "
-    );
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-      if (transitionTimeout > 0) {
-        type = TRANSITION;
-        timeout = transitionTimeout;
-        propCount = transitionDurations.length;
-      }
-    } else if (expectedType === ANIMATION) {
-      if (animationTimeout > 0) {
-        type = ANIMATION;
-        timeout = animationTimeout;
-        propCount = animationDurations.length;
-      }
-    } else {
-      timeout = Math.max(transitionTimeout, animationTimeout);
-      type =
-        timeout > 0
-          ? transitionTimeout > animationTimeout
-            ? TRANSITION
-            : ANIMATION
-          : null;
-      propCount = type
-        ? type === TRANSITION
-          ? transitionDurations.length
-          : animationDurations.length
-        : 0;
-    }
-    var hasTransform =
-      type === TRANSITION &&
-      transformRE.test(styles[transitionProp + "Property"]);
-    return {
-      type: type,
-      timeout: timeout,
-      propCount: propCount,
-      hasTransform: hasTransform,
-    };
+      var styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      var animationTimeout = getTimeout(animationDelays, animationDurations);
+      var type;
+      var timeout = 0;
+      var propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
+      }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type: type,
+          timeout: timeout,
+          propCount: propCount,
+          hasTransform: hasTransform,
+      };
   }
   function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-      delays = delays.concat(delays);
-    }
-    return Math.max.apply(
-      null,
-      durations.map(function (d, i) {
-        return toMs(d) + toMs(delays[i]);
-      })
-    );
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map(function (d, i) {
+          return toMs(d) + toMs(delays[i]);
+      }));
   }
   // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
   // in a locale-dependent way, using a comma instead of a dot.
   // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
   // as a floor function) causing unexpected behaviors
   function toMs(s) {
-    return Number(s.slice(0, -1).replace(",", ".")) * 1000;
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
   function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-      el._leaveCb.cancelled = true;
-      el._leaveCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-      return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-      return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-      context = transitionNode.context;
-      transitionNode = transitionNode.parent;
-    }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== "") {
-      return;
-    }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass =
-      isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
-      ? typeof appear === "function"
-        ? appear
-        : enter
-      : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
-      ? appearCancelled || enterCancelled
-      : enterCancelled;
-    var explicitEnterDuration = toNumber(
-      isObject(duration) ? duration.enter : duration
-    );
-    if (explicitEnterDuration != null) {
-      checkDuration(explicitEnterDuration, "enter", vnode);
-    }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
+      var el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
+      }
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
+      }
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      var css = data.css;
+      var type = data.type;
+      var enterClass = data.enterClass;
+      var enterToClass = data.enterToClass;
+      var enterActiveClass = data.enterActiveClass;
+      var appearClass = data.appearClass;
+      var appearToClass = data.appearToClass;
+      var appearActiveClass = data.appearActiveClass;
+      var beforeEnter = data.beforeEnter;
+      var enter = data.enter;
+      var afterEnter = data.afterEnter;
+      var enterCancelled = data.enterCancelled;
+      var beforeAppear = data.beforeAppear;
+      var appear = data.appear;
+      var afterAppear = data.afterAppear;
+      var appearCancelled = data.appearCancelled;
+      var duration = data.duration;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      var context = activeInstance;
+      var transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      var startClass = isAppear && appearClass ? appearClass : enterClass;
+      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      var enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      var enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(enterHook);
+      var cb = (el._enterCb = once(function () {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', function () {
+              var parent = el.parentNode;
+              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
+      }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
       if (expectsCSS) {
-        removeTransitionClass(el, toClass);
-        removeTransitionClass(el, activeClass);
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(function () {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
+      if (!expectsCSS && !userWantsControl) {
+          cb();
       }
-      // @ts-expect-error
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, startClass);
-        }
-        enterCancelledHook && enterCancelledHook(el);
-      } else {
-        afterEnterHook && afterEnterHook(el);
-      }
-      el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-      // remove pending leave element on enter by injecting an insert hook
-      mergeVNodeHook(vnode, "insert", function () {
-        var parent = el.parentNode;
-        var pendingNode =
-          parent && parent._pending && parent._pending[vnode.key];
-        if (
-          pendingNode &&
-          pendingNode.tag === vnode.tag &&
-          pendingNode.elm._leaveCb
-        ) {
-          pendingNode.elm._leaveCb();
-        }
-        enterHook && enterHook(el, cb);
-      });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-      addTransitionClass(el, startClass);
-      addTransitionClass(el, activeClass);
-      nextFrame(function () {
-        removeTransitionClass(el, startClass);
-        // @ts-expect-error
-        if (!cb.cancelled) {
-          addTransitionClass(el, toClass);
-          if (!userWantsControl) {
-            if (isValidDuration(explicitEnterDuration)) {
-              setTimeout(cb, explicitEnterDuration);
-            } else {
-              whenTransitionEnds(el, type, cb);
-            }
-          }
-        }
-      });
-    }
-    if (vnode.data.show) {
-      toggleDisplay && toggleDisplay();
-      enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-      cb();
-    }
   }
   function leave(vnode, rm) {
-    var el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-      el._enterCb.cancelled = true;
-      el._enterCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-      return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-      return;
-    }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(
-      isObject(duration) ? duration.leave : duration
-    );
-    if (isDef(explicitLeaveDuration)) {
-      checkDuration(explicitLeaveDuration, "leave", vnode);
-    }
-    var cb = (el._leaveCb = once(function () {
-      if (el.parentNode && el.parentNode._pending) {
-        el.parentNode._pending[vnode.key] = null;
-      }
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveToClass);
-        removeTransitionClass(el, leaveActiveClass);
+      var el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
       }
-      // @ts-expect-error
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, leaveClass);
-        }
-        leaveCancelled && leaveCancelled(el);
-      } else {
-        rm();
-        afterLeave && afterLeave(el);
-      }
-      el._leaveCb = null;
-    }));
-    if (delayLeave) {
-      delayLeave(performLeave);
-    } else {
-      performLeave();
-    }
-    function performLeave() {
-      // the delayed leave may have already been cancelled
-      // @ts-expect-error
-      if (cb.cancelled) {
-        return;
+      var data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
       }
-      // record leaving element
-      if (!vnode.data.show && el.parentNode) {
-        (el.parentNode._pending || (el.parentNode._pending = {}))[
-          vnode.key
-        ] = vnode;
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
       }
-      beforeLeave && beforeLeave(el);
-      if (expectsCSS) {
-        addTransitionClass(el, leaveClass);
-        addTransitionClass(el, leaveActiveClass);
-        nextFrame(function () {
-          removeTransitionClass(el, leaveClass);
+      var css = data.css;
+      var type = data.type;
+      var leaveClass = data.leaveClass;
+      var leaveToClass = data.leaveToClass;
+      var leaveActiveClass = data.leaveActiveClass;
+      var beforeLeave = data.beforeLeave;
+      var leave = data.leave;
+      var afterLeave = data.afterLeave;
+      var leaveCancelled = data.leaveCancelled;
+      var delayLeave = data.delayLeave;
+      var duration = data.duration;
+      var expectsCSS = css !== false && !isIE9;
+      var userWantsControl = getHookArgumentsLength(leave);
+      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      var cb = (el._leaveCb = once(function () {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
           // @ts-expect-error
-          if (!cb.cancelled) {
-            addTransitionClass(el, leaveToClass);
-            if (!userWantsControl) {
-              if (isValidDuration(explicitLeaveDuration)) {
-                setTimeout(cb, explicitLeaveDuration);
-              } else {
-                whenTransitionEnds(el, type, cb);
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
               }
-            }
+              leaveCancelled && leaveCancelled(el);
           }
-        });
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
       }
-      leave && leave(el, cb);
-      if (!expectsCSS && !userWantsControl) {
-        cb();
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(function () {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
       }
-    }
   }
   // only used in dev mode
   function checkDuration(val, name, vnode) {
-    if (typeof val !== "number") {
-      warn(
-        "<transition> explicit " +
-          name +
-          " duration is not a valid number - " +
-          "got " +
-          JSON.stringify(val) +
-          ".",
-        vnode.context
-      );
-    } else if (isNaN(val)) {
-      warn(
-        "<transition> explicit " +
-          name +
-          " duration is NaN - " +
-          "the duration expression might be incorrect.",
-        vnode.context
-      );
-    }
+      if (typeof val !== 'number') {
+          warn("<transition> explicit " + name + " duration is not a valid number - " +
+              "got " + (JSON.stringify(val)) + ".", vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn("<transition> explicit " + name + " duration is NaN - " +
+              'the duration expression might be incorrect.', vnode.context);
+      }
   }
   function isValidDuration(val) {
-    return typeof val === "number" && !isNaN(val);
+      return typeof val === 'number' && !isNaN(val);
   }
   /**
    * Normalize a transition hook's argument length. The hook may be:
@@ -7453,41 +6810,41 @@
    * - a plain function (.length)
    */
   function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-      return false;
-    }
-    // @ts-expect-error
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-      // invoker
-      return getHookArgumentsLength(
-        Array.isArray(invokerFns) ? invokerFns[0] : invokerFns
-      );
-    } else {
+      if (isUndef(fn)) {
+          return false;
+      }
       // @ts-expect-error
-      return (fn._length || fn.length) > 1;
-    }
+      var invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
   }
   function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-      enter(vnode);
-    }
+      if (vnode.data.show !== true) {
+          enter(vnode);
+      }
   }
   var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove: function remove(vnode, rm) {
-          /* istanbul ignore else */
-          if (vnode.data.show !== true) {
-            // @ts-expect-error
-            leave(vnode, rm);
-          } else {
-            rm();
-          }
-        },
+      ? {
+          create: _enter,
+          activate: _enter,
+          remove: function remove(vnode, rm) {
+              /* istanbul ignore else */
+              if (vnode.data.show !== true) {
+                  // @ts-expect-error
+                  leave(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          },
       }
-    : {};
+      : {};
 
   var platformModules = [attrs, klass, events, domProps, style, transition];
 
@@ -7502,562 +6859,537 @@
    */
   /* istanbul ignore if */
   if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener("selectionchange", function () {
-      var el = document.activeElement;
-      // @ts-expect-error
-      if (el && el.vmodel) {
-        trigger(el, "input");
-      }
-    });
+      // http://www.matts411.com/post/internet-explorer-9-oninput/
+      document.addEventListener('selectionchange', function () {
+          var el = document.activeElement;
+          // @ts-expect-error
+          if (el && el.vmodel) {
+              trigger(el, 'input');
+          }
+      });
   }
   var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
-      if (vnode.tag === "select") {
-        // #6903
-        if (oldVnode.elm && !oldVnode.elm._vOptions) {
-          mergeVNodeHook(vnode, "postpatch", function () {
-            directive.componentUpdated(el, binding, vnode);
-          });
-        } else {
-          setSelected(el, binding, vnode.context);
-        }
-        el._vOptions = [].map.call(el.options, getValue);
-      } else if (vnode.tag === "textarea" || isTextInputType(el.type)) {
-        el._vModifiers = binding.modifiers;
-        if (!binding.modifiers.lazy) {
-          el.addEventListener("compositionstart", onCompositionStart);
-          el.addEventListener("compositionend", onCompositionEnd);
-          // Safari < 10.2 & UIWebView doesn't fire compositionend when
-          // switching focus before confirming composition choice
-          // this also fixes the issue where some browsers e.g. iOS Chrome
-          // fires "change" instead of "input" on autocomplete.
-          el.addEventListener("change", onCompositionEnd);
-          /* istanbul ignore if */
-          if (isIE9) {
-            el.vmodel = true;
-          }
-        }
-      }
-    },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
-      if (vnode.tag === "select") {
-        setSelected(el, binding, vnode.context);
-        // in case the options rendered by v-for have changed,
-        // it's possible that the value is out-of-sync with the rendered options.
-        // detect such cases and filter out values that no longer has a matching
-        // option in the DOM.
-        var prevOptions = el._vOptions;
-        var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-        if (
-          curOptions.some(function (o, i) {
-            return !looseEqual(o, prevOptions[i]);
-          })
-        ) {
-          // trigger change event if
-          // no matching option found for at least one value
-          var needReset = el.multiple
-            ? binding.value.some(function (v) {
-                return hasNoMatchingOption(v, curOptions);
-              })
-            : binding.value !== binding.oldValue &&
-              hasNoMatchingOption(binding.value, curOptions);
-          if (needReset) {
-            trigger(el, "change");
-          }
-        }
-      }
-    },
+      inserted: function inserted(el, binding, vnode, oldVnode) {
+          if (vnode.tag === 'select') {
+              // #6903
+              if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                  mergeVNodeHook(vnode, 'postpatch', function () {
+                      directive.componentUpdated(el, binding, vnode);
+                  });
+              }
+              else {
+                  setSelected(el, binding, vnode.context);
+              }
+              el._vOptions = [].map.call(el.options, getValue);
+          }
+          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+              el._vModifiers = binding.modifiers;
+              if (!binding.modifiers.lazy) {
+                  el.addEventListener('compositionstart', onCompositionStart);
+                  el.addEventListener('compositionend', onCompositionEnd);
+                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                  // switching focus before confirming composition choice
+                  // this also fixes the issue where some browsers e.g. iOS Chrome
+                  // fires "change" instead of "input" on autocomplete.
+                  el.addEventListener('change', onCompositionEnd);
+                  /* istanbul ignore if */
+                  if (isIE9) {
+                      el.vmodel = true;
+                  }
+              }
+          }
+      },
+      componentUpdated: function componentUpdated(el, binding, vnode) {
+          if (vnode.tag === 'select') {
+              setSelected(el, binding, vnode.context);
+              // in case the options rendered by v-for have changed,
+              // it's possible that the value is out-of-sync with the rendered options.
+              // detect such cases and filter out values that no longer has a matching
+              // option in the DOM.
+              var prevOptions = el._vOptions;
+              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+                  // trigger change event if
+                  // no matching option found for at least one value
+                  var needReset = el.multiple
+                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                      : binding.value !== binding.oldValue &&
+                          hasNoMatchingOption(binding.value, curOptions);
+                  if (needReset) {
+                      trigger(el, 'change');
+                  }
+              }
+          }
+      },
   };
   function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-      setTimeout(function () {
-        actuallySetSelected(el, binding, vm);
-      }, 0);
-    }
+      actuallySetSelected(el, binding, vm);
+      /* istanbul ignore if */
+      if (isIE || isEdge) {
+          setTimeout(function () {
+              actuallySetSelected(el, binding, vm);
+          }, 0);
+      }
   }
   function actuallySetSelected(el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-      warn(
-        '<select multiple v-model="' +
-          binding.expression +
-          '"> ' +
-          "expects an Array value for its binding, but got " +
-          Object.prototype.toString.call(value).slice(8, -1),
-        vm
-      );
-      return;
-    }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
-      option = el.options[i];
-      if (isMultiple) {
-        selected = looseIndexOf(value, getValue(option)) > -1;
-        if (option.selected !== selected) {
-          option.selected = selected;
-        }
-      } else {
-        if (looseEqual(getValue(option), value)) {
-          if (el.selectedIndex !== i) {
-            el.selectedIndex = i;
-          }
+      var value = binding.value;
+      var isMultiple = el.multiple;
+      if (isMultiple && !Array.isArray(value)) {
+          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
+                  "expects an Array value for its binding, but got " + (Object.prototype.toString
+                      .call(value)
+                      .slice(8, -1)), vm);
           return;
-        }
       }
-    }
-    if (!isMultiple) {
-      el.selectedIndex = -1;
-    }
+      var selected, option;
+      for (var i = 0, l = el.options.length; i < l; i++) {
+          option = el.options[i];
+          if (isMultiple) {
+              selected = looseIndexOf(value, getValue(option)) > -1;
+              if (option.selected !== selected) {
+                  option.selected = selected;
+              }
+          }
+          else {
+              if (looseEqual(getValue(option), value)) {
+                  if (el.selectedIndex !== i) {
+                      el.selectedIndex = i;
+                  }
+                  return;
+              }
+          }
+      }
+      if (!isMultiple) {
+          el.selectedIndex = -1;
+      }
   }
   function hasNoMatchingOption(value, options) {
-    return options.every(function (o) {
-      return !looseEqual(o, value);
-    });
+      return options.every(function (o) { return !looseEqual(o, value); });
   }
   function getValue(option) {
-    return "_value" in option ? option._value : option.value;
+      return '_value' in option ? option._value : option.value;
   }
   function onCompositionStart(e) {
-    e.target.composing = true;
+      e.target.composing = true;
   }
   function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing) {
-      return;
-    }
-    e.target.composing = false;
-    trigger(e.target, "input");
+      // prevent triggering an input event for no reason
+      if (!e.target.composing)
+          { return; }
+      e.target.composing = false;
+      trigger(e.target, 'input');
   }
   function trigger(el, type) {
-    var e = document.createEvent("HTMLEvents");
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+      var e = document.createEvent('HTMLEvents');
+      e.initEvent(type, true, true);
+      el.dispatchEvent(e);
   }
 
   // recursively search for possible transition defined inside the component root
   function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-      ? locateNode(vnode.componentInstance._vnode)
-      : vnode;
+      // @ts-expect-error
+      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+          ? locateNode(vnode.componentInstance._vnode)
+          : vnode;
   }
   var show = {
-    bind: function bind(el, ref, vnode) {
-      var value = ref.value;
+      bind: function bind(el, ref, vnode) {
+          var value = ref.value;
 
-      vnode = locateNode(vnode);
-      var transition = vnode.data && vnode.data.transition;
-      var originalDisplay = (el.__vOriginalDisplay =
-        el.style.display === "none" ? "" : el.style.display);
-      if (value && transition) {
-        vnode.data.show = true;
-        enter(vnode, function () {
-          el.style.display = originalDisplay;
-        });
-      } else {
-        el.style.display = value ? originalDisplay : "none";
-      }
-    },
-    update: function update(el, ref, vnode) {
-      var value = ref.value;
-      var oldValue = ref.oldValue;
+          vnode = locateNode(vnode);
+          var transition = vnode.data && vnode.data.transition;
+          var originalDisplay = (el.__vOriginalDisplay =
+              el.style.display === 'none' ? '' : el.style.display);
+          if (value && transition) {
+              vnode.data.show = true;
+              enter(vnode, function () {
+                  el.style.display = originalDisplay;
+              });
+          }
+          else {
+              el.style.display = value ? originalDisplay : 'none';
+          }
+      },
+      update: function update(el, ref, vnode) {
+          var value = ref.value;
+          var oldValue = ref.oldValue;
 
-      /* istanbul ignore if */
-      if (!value === !oldValue) {
-        return;
-      }
-      vnode = locateNode(vnode);
-      var transition = vnode.data && vnode.data.transition;
-      if (transition) {
-        vnode.data.show = true;
-        if (value) {
-          enter(vnode, function () {
-            el.style.display = el.__vOriginalDisplay;
-          });
-        } else {
-          leave(vnode, function () {
-            el.style.display = "none";
-          });
-        }
-      } else {
-        el.style.display = value ? el.__vOriginalDisplay : "none";
-      }
-    },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
-      if (!isDestroy) {
-        el.style.display = el.__vOriginalDisplay;
-      }
-    },
+          /* istanbul ignore if */
+          if (!value === !oldValue)
+              { return; }
+          vnode = locateNode(vnode);
+          var transition = vnode.data && vnode.data.transition;
+          if (transition) {
+              vnode.data.show = true;
+              if (value) {
+                  enter(vnode, function () {
+                      el.style.display = el.__vOriginalDisplay;
+                  });
+              }
+              else {
+                  leave(vnode, function () {
+                      el.style.display = 'none';
+                  });
+              }
+          }
+          else {
+              el.style.display = value ? el.__vOriginalDisplay : 'none';
+          }
+      },
+      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+          if (!isDestroy) {
+              el.style.display = el.__vOriginalDisplay;
+          }
+      },
   };
 
   var platformDirectives = {
-    model: directive,
-    show: show,
+      model: directive,
+      show: show,
   };
 
   // Provides transition support for a single element/component.
   var transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
+      name: String,
+      appear: Boolean,
+      css: Boolean,
+      mode: String,
+      type: String,
+      enterClass: String,
+      leaveClass: String,
+      enterToClass: String,
+      leaveToClass: String,
+      enterActiveClass: String,
+      leaveActiveClass: String,
+      appearClass: String,
+      appearActiveClass: String,
+      appearToClass: String,
+      duration: [Number, String, Object],
   };
   // in case the child is also an abstract component, e.g. <keep-alive>
   // we want to recursively retrieve the real component to be rendered
   function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-      return getRealChild(getFirstComponentChild(compOptions.children));
-    } else {
-      return vnode;
-    }
+      var compOptions = vnode && vnode.componentOptions;
+      if (compOptions && compOptions.Ctor.options.abstract) {
+          return getRealChild(getFirstComponentChild(compOptions.children));
+      }
+      else {
+          return vnode;
+      }
   }
   function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
-    // props
-    for (var key in options.propsData) {
-      data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-      data[camelize(key$1)] = listeners[key$1];
-    }
-    return data;
+      var data = {};
+      var options = comp.$options;
+      // props
+      for (var key in options.propsData) {
+          data[key] = comp[key];
+      }
+      // events.
+      // extract listeners and pass them directly to the transition methods
+      var listeners = options._parentListeners;
+      for (var key$1 in listeners) {
+          data[camelize(key$1)] = listeners[key$1];
+      }
+      return data;
   }
   function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-      return h("keep-alive", {
-        props: rawChild.componentOptions.propsData,
-      });
-    }
+      // @ts-expect-error
+      if (/\d-keep-alive$/.test(rawChild.tag)) {
+          return h('keep-alive', {
+              props: rawChild.componentOptions.propsData,
+          });
+      }
   }
   function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-      if (vnode.data.transition) {
-        return true;
+      while ((vnode = vnode.parent)) {
+          if (vnode.data.transition) {
+              return true;
+          }
       }
-    }
   }
   function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
+      return oldChild.key === child.key && oldChild.tag === child.tag;
   }
-  var isNotTextNode = function (c) {
-    return c.tag || isAsyncPlaceholder(c);
-  };
-  var isVShowDirective = function (d) {
-    return d.name === "show";
-  };
+  var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
+  var isVShowDirective = function (d) { return d.name === 'show'; };
   var Transition = {
-    name: "transition",
-    props: transitionProps,
-    abstract: true,
-    render: function render(h) {
-      var this$1 = this;
+      name: 'transition',
+      props: transitionProps,
+      abstract: true,
+      render: function render(h) {
+          var this$1 = this;
 
-      var children = this.$slots.default;
-      if (!children) {
-        return;
-      }
-      // filter out text nodes (possible whitespaces)
-      children = children.filter(isNotTextNode);
-      /* istanbul ignore if */
-      if (!children.length) {
-        return;
-      }
-      // warn multiple elements
-      if (children.length > 1) {
-        warn(
-          "<transition> can only be used on a single element. Use " +
-            "<transition-group> for lists.",
-          this.$parent
-        );
-      }
-      var mode = this.mode;
-      // warn invalid mode
-      if (mode && mode !== "in-out" && mode !== "out-in") {
-        warn("invalid <transition> mode: " + mode, this.$parent);
-      }
-      var rawChild = children[0];
-      // if this is a component root node and the component's
-      // parent container node also has transition, skip.
-      if (hasParentTransition(this.$vnode)) {
-        return rawChild;
-      }
-      // apply transition data to child
-      // use getRealChild() to ignore abstract components e.g. keep-alive
-      var child = getRealChild(rawChild);
-      /* istanbul ignore if */
-      if (!child) {
-        return rawChild;
-      }
-      if (this._leaving) {
-        return placeholder(h, rawChild);
-      }
-      // ensure a key that is unique to the vnode type and to this transition
-      // component instance. This key will be used to remove pending leaving nodes
-      // during entering.
-      var id = "__transition-" + this._uid + "-";
-      child.key =
-        child.key == null
-          ? child.isComment
-            ? id + "comment"
-            : id + child.tag
-          : isPrimitive(child.key)
-          ? String(child.key).indexOf(id) === 0
-            ? child.key
-            : id + child.key
-          : child.key;
-      var data = ((
-        child.data || (child.data = {})
-      ).transition = extractTransitionData(this));
-      var oldRawChild = this._vnode;
-      var oldChild = getRealChild(oldRawChild);
-      // mark v-show
-      // so that the transition module can hand over the control to the directive
-      if (
-        child.data.directives &&
-        child.data.directives.some(isVShowDirective)
-      ) {
-        child.data.show = true;
-      }
-      if (
-        oldChild &&
-        oldChild.data &&
-        !isSameChild(child, oldChild) &&
-        !isAsyncPlaceholder(oldChild) &&
-        // #6687 component root is a comment node
-        !(
-          oldChild.componentInstance &&
-          oldChild.componentInstance._vnode.isComment
-        )
-      ) {
-        // replace old child transition data with fresh one
-        // important for dynamic transitions!
-        var oldData = (oldChild.data.transition = extend({}, data));
-        // handle transition mode
-        if (mode === "out-in") {
-          // return placeholder node and queue update when leave finishes
-          this._leaving = true;
-          mergeVNodeHook(oldData, "afterLeave", function () {
-            this$1._leaving = false;
-            this$1.$forceUpdate();
-          });
-          return placeholder(h, rawChild);
-        } else if (mode === "in-out") {
-          if (isAsyncPlaceholder(child)) {
-            return oldRawChild;
-          }
-          var delayedLeave;
-          var performLeave = function () {
-            delayedLeave();
-          };
-          mergeVNodeHook(data, "afterEnter", performLeave);
-          mergeVNodeHook(data, "enterCancelled", performLeave);
-          mergeVNodeHook(oldData, "delayLeave", function (leave) {
-            delayedLeave = leave;
-          });
-        }
-      }
-      return rawChild;
-    },
+          var children = this.$slots.default;
+          if (!children) {
+              return;
+          }
+          // filter out text nodes (possible whitespaces)
+          children = children.filter(isNotTextNode);
+          /* istanbul ignore if */
+          if (!children.length) {
+              return;
+          }
+          // warn multiple elements
+          if (children.length > 1) {
+              warn('<transition> can only be used on a single element. Use ' +
+                  '<transition-group> for lists.', this.$parent);
+          }
+          var mode = this.mode;
+          // warn invalid mode
+          if (mode &&
+              mode !== 'in-out' &&
+              mode !== 'out-in') {
+              warn('invalid <transition> mode: ' + mode, this.$parent);
+          }
+          var rawChild = children[0];
+          // if this is a component root node and the component's
+          // parent container node also has transition, skip.
+          if (hasParentTransition(this.$vnode)) {
+              return rawChild;
+          }
+          // apply transition data to child
+          // use getRealChild() to ignore abstract components e.g. keep-alive
+          var child = getRealChild(rawChild);
+          /* istanbul ignore if */
+          if (!child) {
+              return rawChild;
+          }
+          if (this._leaving) {
+              return placeholder(h, rawChild);
+          }
+          // ensure a key that is unique to the vnode type and to this transition
+          // component instance. This key will be used to remove pending leaving nodes
+          // during entering.
+          var id = "__transition-" + (this._uid) + "-";
+          child.key =
+              child.key == null
+                  ? child.isComment
+                      ? id + 'comment'
+                      : id + child.tag
+                  : isPrimitive(child.key)
+                      ? String(child.key).indexOf(id) === 0
+                          ? child.key
+                          : id + child.key
+                      : child.key;
+          var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          var oldRawChild = this._vnode;
+          var oldChild = getRealChild(oldRawChild);
+          // mark v-show
+          // so that the transition module can hand over the control to the directive
+          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+              child.data.show = true;
+          }
+          if (oldChild &&
+              oldChild.data &&
+              !isSameChild(child, oldChild) &&
+              !isAsyncPlaceholder(oldChild) &&
+              // #6687 component root is a comment node
+              !(oldChild.componentInstance &&
+                  oldChild.componentInstance._vnode.isComment)) {
+              // replace old child transition data with fresh one
+              // important for dynamic transitions!
+              var oldData = (oldChild.data.transition = extend({}, data));
+              // handle transition mode
+              if (mode === 'out-in') {
+                  // return placeholder node and queue update when leave finishes
+                  this._leaving = true;
+                  mergeVNodeHook(oldData, 'afterLeave', function () {
+                      this$1._leaving = false;
+                      this$1.$forceUpdate();
+                  });
+                  return placeholder(h, rawChild);
+              }
+              else if (mode === 'in-out') {
+                  if (isAsyncPlaceholder(child)) {
+                      return oldRawChild;
+                  }
+                  var delayedLeave;
+                  var performLeave = function () {
+                      delayedLeave();
+                  };
+                  mergeVNodeHook(data, 'afterEnter', performLeave);
+                  mergeVNodeHook(data, 'enterCancelled', performLeave);
+                  mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                      delayedLeave = leave;
+                  });
+              }
+          }
+          return rawChild;
+      },
   };
 
   // Provides transition support for list items.
-  var props = extend(
-    {
+  var props = extend({
       tag: String,
       moveClass: String,
-    },
-    transitionProps
-  );
+  }, transitionProps);
   // @ts-ignore
   delete props.mode;
   var TransitionGroup = {
-    props: props,
-    beforeMount: function beforeMount() {
-      var this$1 = this;
+      props: props,
+      beforeMount: function beforeMount() {
+          var this$1 = this;
 
-      var update = this._update;
-      this._update = function (vnode, hydrating) {
-        var restoreActiveInstance = setActiveInstance(this$1);
-        // force removing pass
-        this$1.__patch__(
-          this$1._vnode,
-          this$1.kept,
-          false, // hydrating
-          true // removeOnly (!important, avoids unnecessary moves)
-        );
-        this$1._vnode = this$1.kept;
-        restoreActiveInstance();
-        update.call(this$1, vnode, hydrating);
-      };
-    },
-    render: function render(h) {
-      var tag = this.tag || this.$vnode.data.tag || "span";
-      var map = Object.create(null);
-      var prevChildren = (this.prevChildren = this.children);
-      var rawChildren = this.$slots.default || [];
-      var children = (this.children = []);
-      var transitionData = extractTransitionData(this);
-      for (var i = 0; i < rawChildren.length; i++) {
-        var c = rawChildren[i];
-        if (c.tag) {
-          if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-            children.push(c);
-            map[c.key] = c;
-            (c.data || (c.data = {})).transition = transitionData;
-          } else {
-            var opts = c.componentOptions;
-            var name = opts ? opts.Ctor.options.name || opts.tag || "" : c.tag;
-            warn("<transition-group> children must be keyed: <" + name + ">");
-          }
-        }
-      }
-      if (prevChildren) {
-        var kept = [];
-        var removed = [];
-        for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-          var c$1 = prevChildren[i$1];
-          c$1.data.transition = transitionData;
-          // @ts-ignore
-          c$1.data.pos = c$1.elm.getBoundingClientRect();
-          // @ts-ignore
-          if (map[c$1.key]) {
-            kept.push(c$1);
-          } else {
-            removed.push(c$1);
-          }
-        }
-        this.kept = h(tag, null, kept);
-        this.removed = removed;
-      }
-      return h(tag, null, children);
-    },
-    updated: function updated() {
-      var children = this.prevChildren;
-      var moveClass = this.moveClass || (this.name || "v") + "-move";
-      if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-        return;
-      }
-      // we divide the work into three loops to avoid mixing DOM reads and writes
-      // in each iteration - which helps prevent layout thrashing.
-      children.forEach(callPendingCbs);
-      children.forEach(recordPosition);
-      children.forEach(applyTranslation);
-      // force reflow to put everything in position
-      // assign to this to avoid being removed in tree-shaking
-      // $flow-disable-line
-      this._reflow = document.body.offsetHeight;
-      children.forEach(function (c) {
-        // @ts-ignore
-        if (c.data.moved) {
-          var el = c.elm;
-          var s = el.style;
-          addTransitionClass(el, moveClass);
-          s.transform = s.WebkitTransform = s.transitionDuration = "";
-          el.addEventListener(
-            transitionEndEvent,
-            (el._moveCb = function cb(e) {
-              if (e && e.target !== el) {
-                return;
-              }
-              if (!e || /transform$/.test(e.propertyName)) {
-                el.removeEventListener(transitionEndEvent, cb);
-                el._moveCb = null;
-                removeTransitionClass(el, moveClass);
-              }
-            })
-          );
-        }
-      });
-    },
-    methods: {
-      hasMove: function hasMove(el, moveClass) {
-        /* istanbul ignore if */
-        if (!hasTransition) {
-          return false;
-        }
-        /* istanbul ignore if */
-        if (this._hasMove) {
-          return this._hasMove;
-        }
-        // Detect whether an element with the move class applied has
-        // CSS transitions. Since the element may be inside an entering
-        // transition at this very moment, we make a clone of it and remove
-        // all other transition classes applied to ensure only the move class
-        // is applied.
-        var clone = el.cloneNode();
-        if (el._transitionClasses) {
-          el._transitionClasses.forEach(function (cls) {
-            removeClass(clone, cls);
+          var update = this._update;
+          this._update = function (vnode, hydrating) {
+              var restoreActiveInstance = setActiveInstance(this$1);
+              // force removing pass
+              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              true // removeOnly (!important, avoids unnecessary moves)
+              );
+              this$1._vnode = this$1.kept;
+              restoreActiveInstance();
+              update.call(this$1, vnode, hydrating);
+          };
+      },
+      render: function render(h) {
+          var tag = this.tag || this.$vnode.data.tag || 'span';
+          var map = Object.create(null);
+          var prevChildren = (this.prevChildren = this.children);
+          var rawChildren = this.$slots.default || [];
+          var children = (this.children = []);
+          var transitionData = extractTransitionData(this);
+          for (var i = 0; i < rawChildren.length; i++) {
+              var c = rawChildren[i];
+              if (c.tag) {
+                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                      children.push(c);
+                      map[c.key] = c;
+                      (c.data || (c.data = {})).transition = transitionData;
+                  }
+                  else {
+                      var opts = c.componentOptions;
+                      var name = opts
+                          ? opts.Ctor.options.name || opts.tag || ''
+                          : c.tag;
+                      warn(("<transition-group> children must be keyed: <" + name + ">"));
+                  }
+              }
+          }
+          if (prevChildren) {
+              var kept = [];
+              var removed = [];
+              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
+                  var c$1 = prevChildren[i$1];
+                  c$1.data.transition = transitionData;
+                  // @ts-ignore
+                  c$1.data.pos = c$1.elm.getBoundingClientRect();
+                  // @ts-ignore
+                  if (map[c$1.key]) {
+                      kept.push(c$1);
+                  }
+                  else {
+                      removed.push(c$1);
+                  }
+              }
+              this.kept = h(tag, null, kept);
+              this.removed = removed;
+          }
+          return h(tag, null, children);
+      },
+      updated: function updated() {
+          var children = this.prevChildren;
+          var moveClass = this.moveClass || (this.name || 'v') + '-move';
+          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+              return;
+          }
+          // we divide the work into three loops to avoid mixing DOM reads and writes
+          // in each iteration - which helps prevent layout thrashing.
+          children.forEach(callPendingCbs);
+          children.forEach(recordPosition);
+          children.forEach(applyTranslation);
+          // force reflow to put everything in position
+          // assign to this to avoid being removed in tree-shaking
+          // $flow-disable-line
+          this._reflow = document.body.offsetHeight;
+          children.forEach(function (c) {
+              // @ts-ignore
+              if (c.data.moved) {
+                  var el = c.elm;
+                  var s = el.style;
+                  addTransitionClass(el, moveClass);
+                  s.transform = s.WebkitTransform = s.transitionDuration = '';
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
+                          return;
+                      }
+                      if (!e || /transform$/.test(e.propertyName)) {
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
+                      }
+                  }));
+              }
           });
-        }
-        addClass(clone, moveClass);
-        clone.style.display = "none";
-        this.$el.appendChild(clone);
-        var info = getTransitionInfo(clone);
-        this.$el.removeChild(clone);
-        return (this._hasMove = info.hasTransform);
       },
-    },
+      methods: {
+          hasMove: function hasMove(el, moveClass) {
+              /* istanbul ignore if */
+              if (!hasTransition) {
+                  return false;
+              }
+              /* istanbul ignore if */
+              if (this._hasMove) {
+                  return this._hasMove;
+              }
+              // Detect whether an element with the move class applied has
+              // CSS transitions. Since the element may be inside an entering
+              // transition at this very moment, we make a clone of it and remove
+              // all other transition classes applied to ensure only the move class
+              // is applied.
+              var clone = el.cloneNode();
+              if (el._transitionClasses) {
+                  el._transitionClasses.forEach(function (cls) {
+                      removeClass(clone, cls);
+                  });
+              }
+              addClass(clone, moveClass);
+              clone.style.display = 'none';
+              this.$el.appendChild(clone);
+              var info = getTransitionInfo(clone);
+              this.$el.removeChild(clone);
+              return (this._hasMove = info.hasTransform);
+          },
+      },
   };
   function callPendingCbs(c) {
-    /* istanbul ignore if */
-    //@ts-ignore
-    if (c.elm._moveCb) {
+      /* istanbul ignore if */
       //@ts-ignore
-      c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    //@ts-ignore
-    if (c.elm._enterCb) {
+      if (c.elm._moveCb) {
+          //@ts-ignore
+          c.elm._moveCb();
+      }
+      /* istanbul ignore if */
       //@ts-ignore
-      c.elm._enterCb();
-    }
+      if (c.elm._enterCb) {
+          //@ts-ignore
+          c.elm._enterCb();
+      }
   }
   function recordPosition(c) {
-    //@ts-ignore
-    c.data.newPos = c.elm.getBoundingClientRect();
+      //@ts-ignore
+      c.data.newPos = c.elm.getBoundingClientRect();
   }
   function applyTranslation(c) {
-    //@ts-ignore
-    var oldPos = c.data.pos;
-    //@ts-ignore
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
-    if (dx || dy) {
       //@ts-ignore
-      c.data.moved = true;
+      var oldPos = c.data.pos;
       //@ts-ignore
-      var s = c.elm.style;
-      s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-      s.transitionDuration = "0s";
-    }
+      var newPos = c.data.newPos;
+      var dx = oldPos.left - newPos.left;
+      var dy = oldPos.top - newPos.top;
+      if (dx || dy) {
+          //@ts-ignore
+          c.data.moved = true;
+          //@ts-ignore
+          var s = c.elm.style;
+          s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
+          s.transitionDuration = '0s';
+      }
   }
 
   var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
+      Transition: Transition,
+      TransitionGroup: TransitionGroup,
   };
 
   // install platform specific utils
@@ -8073,34 +7405,33 @@
   Vue.prototype.__patch__ = inBrowser ? patch : noop;
   // public mount method
   Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
+      el = el && inBrowser ? query(el) : undefined;
+      return mountComponent(this, el, hydrating);
   };
   // devtools global hook
   /* istanbul ignore next */
   if (inBrowser) {
-    setTimeout(function () {
-      if (config.devtools) {
-        if (devtools) {
-          devtools.emit("init", Vue);
-        } else {
-          // @ts-expect-error
-          console[console.info ? "info" : "log"](
-            "Download the Vue Devtools extension for a better development experience:\n" +
-              "https://github.com/vuejs/vue-devtools"
-          );
-        }
-      }
-      if (config.productionTip !== false && typeof console !== "undefined") {
-        // @ts-expect-error
-        console[console.info ? "info" : "log"](
-          "You are running Vue in development mode.\n" +
-            "Make sure to turn on production mode when deploying for production.\n" +
-            "See more tips at https://vuejs.org/guide/deployment.html"
-        );
-      }
-    }, 0);
+      setTimeout(function () {
+          if (config.devtools) {
+              if (devtools) {
+                  devtools.emit('init', Vue);
+              }
+              else {
+                  // @ts-expect-error
+                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                      'https://github.com/vuejs/vue-devtools');
+              }
+          }
+          if (config.productionTip !== false &&
+              typeof console !== 'undefined') {
+              // @ts-expect-error
+              console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
+                  "Make sure to turn on production mode when deploying for production.\n" +
+                  "See more tips at https://vuejs.org/guide/deployment.html");
+          }
+      }, 0);
   }
 
   return Vue;
-});
+
+})));
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 891ef1e1d51..1562a13c085 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -3431,7 +3431,6 @@
       }
   }
 
-  // const he = require('he')
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index 089eda75243..cc6832211a5 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -3174,7 +3174,6 @@ function parseString(chr) {
     }
 }
 
-// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index aa82fa502be..e3c27ca6f77 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -591,7 +591,6 @@
               currentBlock.end = start;
               var text = content.slice(currentBlock.start, currentBlock.end);
               if (options.deindent !== false) {
-                  //@ts-expect-error
                   text = deIndent(text);
               }
               // pad content so that linters and pre-processors can output correct
@@ -2354,7 +2353,6 @@
       }
   }
 
-  // const he = require('he')
   var onRE = /^@|^v-on:/;
   var dirRE = /^v-|^@|^:|^#/;
   var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index 1f66663903e..af126cf6ceb 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -553,7 +553,6 @@ function parseComponent(content, options) {
             currentBlock.end = start;
             var text = content.slice(currentBlock.start, currentBlock.end);
             if (options.deindent !== false) {
-                //@ts-expect-error
                 text = deindent__default['default'](text);
             }
             // pad content so that linters and pre-processors can output correct
@@ -1978,7 +1977,6 @@ function parseString(chr) {
     }
 }
 
-// const he = require('he')
 var onRE = /^@|^v-on:/;
 var dirRE = /^v-|^@|^:|^#/;
 var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
diff --git a/src/core/config.ts b/src/core/config.ts
index eb202b2cb3c..20ef40c234f 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -4,7 +4,7 @@ import { no, noop, identity } from 'shared/util'
 import { LIFECYCLE_HOOKS } from 'shared/constants'
 import type { Component } from 'typescript/component'
 
-export type Config = {
+export interface Config {
   // user
   optionMergeStrategies: { [key: string]: Function }
   silent: boolean
diff --git a/src/core/instance/index.ts b/src/core/instance/index.ts
index b17d6955011..03151ae5880 100644
--- a/src/core/instance/index.ts
+++ b/src/core/instance/index.ts
@@ -1,28 +1,27 @@
-
-import { initMixin } from './init'
-import { stateMixin } from './state'
-import { renderMixin } from './render'
-import { eventsMixin } from './events'
-import { lifecycleMixin } from './lifecycle'
-import { warn } from '../util/index'
-import type { GlobalAPI } from 'typescript/global-api'
+import { initMixin } from "./init";
+import { stateMixin } from "./state";
+import { renderMixin } from "./render";
+import { eventsMixin } from "./events";
+import { lifecycleMixin } from "./lifecycle";
+import { warn } from "../util/index";
+import type { GlobalAPI } from "typescript/global-api";
 
 function Vue(options) {
-  if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
-    warn('Vue is a constructor and should be called with the `new` keyword')
+  if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
+    warn("Vue is a constructor and should be called with the `new` keyword");
   }
-  this._init(options)
+  this._init(options);
 }
 
-//@ts-ignore
-initMixin(Vue)
-//@ts-ignore
-stateMixin(Vue)
-//@ts-ignore
-eventsMixin(Vue)
-//@ts-ignore
-lifecycleMixin(Vue)
-//@ts-ignore
-renderMixin(Vue)
+//@ts-expect-error Vue has function type
+initMixin(Vue);
+//@ts-expect-error Vue has function type
+stateMixin(Vue);
+//@ts-expect-error Vue has function type
+eventsMixin(Vue);
+//@ts-expect-error Vue has function type
+lifecycleMixin(Vue);
+//@ts-expect-error Vue has function type
+renderMixin(Vue);
 
-export default Vue as unknown as GlobalAPI
+export default (Vue as unknown) as GlobalAPI;
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index c03083a4a13..e1a314cf741 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -76,8 +76,7 @@ export function initInternalComponent(
   vm: Component,
   options: InternalComponentOptions
 ) {
-  // @ts-ignore
-  const opts = (vm.$options = Object.create(vm.constructor.options))
+  const opts = (vm.$options = Object.create((vm.constructor as any).options))
   // doing this because it's faster than dynamic enumeration.
   const parentVnode = options._parentVnode
   opts.parent = options.parent
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 466e50033b0..8ade3154bd3 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -69,8 +69,7 @@ export function resolveInject(
               ? provideDefault.call(vm)
               : provideDefault
         } else if (process.env.NODE_ENV !== 'production') {
-          // @ts-ignore
-          warn(`Injection "${key}" not found`, vm)
+          warn(`Injection "${key as string}" not found`, vm)
         }
       }
     }
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 744c5d4574b..89c36c147ba 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -1,12 +1,11 @@
-
-import config from '../config'
-import Watcher from '../observer/watcher'
-import { mark, measure } from '../util/perf'
-import VNode, { createEmptyVNode } from '../vdom/vnode'
-import { updateComponentListeners } from './events'
-import { resolveSlots } from './render-helpers/resolve-slots'
-import { toggleObserving } from '../observer/index'
-import { pushTarget, popTarget } from '../observer/dep'
+import config from "../config";
+import Watcher from "../observer/watcher";
+import { mark, measure } from "../util/perf";
+import VNode, { createEmptyVNode } from "../vdom/vnode";
+import { updateComponentListeners } from "./events";
+import { resolveSlots } from "./render-helpers/resolve-slots";
+import { toggleObserving } from "../observer/index";
+import { pushTarget, popTarget } from "../observer/dep";
 
 import {
   warn,
@@ -15,131 +14,129 @@ import {
   emptyObject,
   validateProp,
   invokeWithErrorHandling,
-} from '../util/index'
-import type { Component } from 'typescript/component'
-import type { MountedComponentVNode } from 'typescript/vnode'
+} from "../util/index";
+import type { Component } from "typescript/component";
+import type { MountedComponentVNode } from "typescript/vnode";
 
-export let activeInstance: any = null
-export let isUpdatingChildComponent: boolean = false
+export let activeInstance: any = null;
+export let isUpdatingChildComponent: boolean = false;
 
 export function setActiveInstance(vm: Component) {
-  const prevActiveInstance = activeInstance
-  activeInstance = vm
+  const prevActiveInstance = activeInstance;
+  activeInstance = vm;
   return () => {
-    activeInstance = prevActiveInstance
-  }
+    activeInstance = prevActiveInstance;
+  };
 }
 
 export function initLifecycle(vm: Component) {
-  const options: any = vm.$options
+  const options: any = vm.$options;
 
   // locate first non-abstract parent
-  let parent = options.parent
+  let parent = options.parent;
   if (parent && !options.abstract) {
     while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent
+      parent = parent.$parent;
     }
-    parent.$children.push(vm)
+    parent.$children.push(vm);
   }
 
-  vm.$parent = parent
-  vm.$root = parent ? parent.$root : vm
+  vm.$parent = parent;
+  vm.$root = parent ? parent.$root : vm;
 
-  vm.$children = []
-  vm.$refs = {}
+  vm.$children = [];
+  vm.$refs = {};
 
-  // @ts-ignore
-  vm._watcher = null
-  vm._inactive = null
-  vm._directInactive = false
-  vm._isMounted = false
-  vm._isDestroyed = false
-  vm._isBeingDestroyed = false
+  vm._watcher = null;
+  vm._inactive = null;
+  vm._directInactive = false;
+  vm._isMounted = false;
+  vm._isDestroyed = false;
+  vm._isBeingDestroyed = false;
 }
 
 export function lifecycleMixin(Vue: Component) {
   Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
-    const vm: Component = this
-    const prevEl = vm.$el
-    const prevVnode = vm._vnode
-    const restoreActiveInstance = setActiveInstance(vm)
-    vm._vnode = vnode
+    const vm: Component = this;
+    const prevEl = vm.$el;
+    const prevVnode = vm._vnode;
+    const restoreActiveInstance = setActiveInstance(vm);
+    vm._vnode = vnode;
     // Vue.prototype.__patch__ is injected in entry points
     // based on the rendering backend used.
     if (!prevVnode) {
       // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
+      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
     } else {
       // updates
-      vm.$el = vm.__patch__(prevVnode, vnode)
+      vm.$el = vm.__patch__(prevVnode, vnode);
     }
-    restoreActiveInstance()
+    restoreActiveInstance();
     // update __vue__ reference
     if (prevEl) {
-      prevEl.__vue__ = null
+      prevEl.__vue__ = null;
     }
     if (vm.$el) {
-      vm.$el.__vue__ = vm
+      vm.$el.__vue__ = vm;
     }
     // if parent is an HOC, update its $el as well
     if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el
+      vm.$parent.$el = vm.$el;
     }
     // updated hook is called by the scheduler to ensure that children are
     // updated in a parent's updated hook.
-  }
+  };
 
   Vue.prototype.$forceUpdate = function () {
-    const vm: Component = this
+    const vm: Component = this;
     if (vm._watcher) {
-      vm._watcher.update()
+      vm._watcher.update();
     }
-  }
+  };
 
   Vue.prototype.$destroy = function () {
-    const vm: Component = this
+    const vm: Component = this;
     if (vm._isBeingDestroyed) {
-      return
+      return;
     }
-    callHook(vm, 'beforeDestroy')
-    vm._isBeingDestroyed = true
+    callHook(vm, "beforeDestroy");
+    vm._isBeingDestroyed = true;
     // remove self from parent
-    const parent = vm.$parent
-    // @ts-ignore
+    const parent = vm.$parent;
     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm)
+      remove(parent.$children, vm);
     }
     // teardown watchers
     if (vm._watcher) {
-      vm._watcher.teardown()
+      vm._watcher.teardown();
     }
-    let i = vm._watchers.length
+    let i = vm._watchers.length;
     while (i--) {
-      vm._watchers[i].teardown()
+      vm._watchers[i].teardown();
     }
     // remove reference from data ob
     // frozen object may not have observer.
     if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--
+      vm._data.__ob__.vmCount--;
     }
     // call the last hook...
-    vm._isDestroyed = true
+    vm._isDestroyed = true;
     // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode!, null)
+    vm.__patch__(vm._vnode!, null);
     // fire destroyed hook
-    callHook(vm, 'destroyed')
+    callHook(vm, "destroyed");
     // turn off all instance listeners.
-    vm.$off()
+    vm.$off();
     // remove __vue__ reference
     if (vm.$el) {
-      vm.$el.__vue__ = null
+      vm.$el.__vue__ = null;
     }
     // release circular reference (#6759)
     if (vm.$vnode) {
       // @ts-expect-error null is not undefined
-      vm.$vnode.parent = null
+      vm.$vnode.parent = null;
     }
-  }
+  };
 }
 
 export function mountComponent(
@@ -147,56 +144,56 @@ export function mountComponent(
   el: Element | null | undefined,
   hydrating?: boolean
 ): Component {
-  vm.$el = el
+  vm.$el = el;
   if (!vm.$options.render) {
     // @ts-expect-error invalid type
-    vm.$options.render = createEmptyVNode
-    if (process.env.NODE_ENV !== 'production') {
+    vm.$options.render = createEmptyVNode;
+    if (process.env.NODE_ENV !== "production") {
       /* istanbul ignore if */
       if (
-        (vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+        (vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
         vm.$options.el ||
         el
       ) {
         warn(
-          'You are using the runtime-only build of Vue where the template ' +
-            'compiler is not available. Either pre-compile the templates into ' +
-            'render functions, or use the compiler-included build.',
+          "You are using the runtime-only build of Vue where the template " +
+            "compiler is not available. Either pre-compile the templates into " +
+            "render functions, or use the compiler-included build.",
           vm
-        )
+        );
       } else {
         warn(
-          'Failed to mount component: template or render function not defined.',
+          "Failed to mount component: template or render function not defined.",
           vm
-        )
+        );
       }
     }
   }
-  callHook(vm, 'beforeMount')
+  callHook(vm, "beforeMount");
 
-  let updateComponent
+  let updateComponent;
   /* istanbul ignore if */
-  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+  if (process.env.NODE_ENV !== "production" && config.performance && mark) {
     updateComponent = () => {
-      const name = vm._name
-      const id = vm._uid
-      const startTag = `vue-perf-start:${id}`
-      const endTag = `vue-perf-end:${id}`
-
-      mark(startTag)
-      const vnode = vm._render()
-      mark(endTag)
-      measure(`vue ${name} render`, startTag, endTag)
-
-      mark(startTag)
-      vm._update(vnode, hydrating)
-      mark(endTag)
-      measure(`vue ${name} patch`, startTag, endTag)
-    }
+      const name = vm._name;
+      const id = vm._uid;
+      const startTag = `vue-perf-start:${id}`;
+      const endTag = `vue-perf-end:${id}`;
+
+      mark(startTag);
+      const vnode = vm._render();
+      mark(endTag);
+      measure(`vue ${name} render`, startTag, endTag);
+
+      mark(startTag);
+      vm._update(vnode, hydrating);
+      mark(endTag);
+      measure(`vue ${name} patch`, startTag, endTag);
+    };
   } else {
     updateComponent = () => {
-      vm._update(vm._render(), hydrating)
-    }
+      vm._update(vm._render(), hydrating);
+    };
   }
 
   // we set this to vm._watcher inside the watcher's constructor
@@ -209,32 +206,32 @@ export function mountComponent(
     {
       before() {
         if (vm._isMounted && !vm._isDestroyed) {
-          callHook(vm, 'beforeUpdate')
+          callHook(vm, "beforeUpdate");
         }
       },
     },
     true /* isRenderWatcher */
-  )
-  hydrating = false
+  );
+  hydrating = false;
 
   // manually mounted instance, call mounted on self
   // mounted is called for render-created child components in its inserted hook
   if (vm.$vnode == null) {
-    vm._isMounted = true
-    callHook(vm, 'mounted')
+    vm._isMounted = true;
+    callHook(vm, "mounted");
   }
-  return vm
+  return vm;
 }
 
 export function updateChildComponent(
   vm: Component,
-  propsData?: Object | null,
-  listeners?: Object | null,
-  parentVnode?: MountedComponentVNode,
+  propsData: Record<string, any> | null | undefined,
+  listeners: Record<string, Function | Array<Function>> | undefined,
+  parentVnode: MountedComponentVNode,
   renderChildren?: Array<VNode> | null
 ) {
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = true
+  if (process.env.NODE_ENV !== "production") {
+    isUpdatingChildComponent = true;
   }
 
   // determine whether component has slot children
@@ -243,13 +240,13 @@ export function updateChildComponent(
   // check if there are dynamic scopedSlots (hand-written or compiled but with
   // dynamic slot names). Static scoped slots compiled from template has the
   // "$stable" marker.
-  const newScopedSlots = parentVnode!.data.scopedSlots
-  const oldScopedSlots = vm.$scopedSlots
+  const newScopedSlots = parentVnode!.data.scopedSlots;
+  const oldScopedSlots = vm.$scopedSlots;
   const hasDynamicScopedSlot = !!(
     (newScopedSlots && !newScopedSlots.$stable) ||
     (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
     (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)
-  )
+  );
 
   // Any static slot children from the parent may have changed during parent's
   // update. Dynamic scoped slots may also have changed. In such cases, a forced
@@ -258,113 +255,109 @@ export function updateChildComponent(
     renderChildren || // has new static slots
     vm.$options._renderChildren || // has old static slots
     hasDynamicScopedSlot
-  )
+  );
 
-  // @ts-ignore
-  vm.$options._parentVnode = parentVnode
+  vm.$options._parentVnode = parentVnode;
 
-  // @ts-ignore
-  vm.$vnode = parentVnode // update vm's placeholder node without re-render
+  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
 
   if (vm._vnode) {
     // update child tree's parent
-    // @ts-ignore
-    vm._vnode.parent = parentVnode
+    vm._vnode.parent = parentVnode;
   }
-  vm.$options._renderChildren = renderChildren
+  vm.$options._renderChildren = renderChildren;
 
   // update $attrs and $listeners hash
   // these are also reactive so they may trigger child update if the child
   // used them during render
-  vm.$attrs = parentVnode!.data.attrs || emptyObject
-  // @ts-ignore
-  vm.$listeners = listeners || emptyObject
+  vm.$attrs = parentVnode!.data.attrs || emptyObject;
+  vm.$listeners = listeners || emptyObject;
 
   // update props
   if (propsData && vm.$options.props) {
-    toggleObserving(false)
-    const props = vm._props
-    const propKeys = vm.$options._propKeys || []
+    toggleObserving(false);
+    const props = vm._props;
+    const propKeys = vm.$options._propKeys || [];
     for (let i = 0; i < propKeys.length; i++) {
-      const key = propKeys[i]
-      const propOptions: any = vm.$options.props // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm)
+      const key = propKeys[i];
+      const propOptions: any = vm.$options.props; // wtf flow?
+      props[key] = validateProp(key, propOptions, propsData, vm);
     }
-    toggleObserving(true)
+    toggleObserving(true);
     // keep a copy of raw propsData
-    vm.$options.propsData = propsData
+    vm.$options.propsData = propsData;
   }
 
   // update listeners
-  listeners = listeners || emptyObject
-  const oldListeners = vm.$options._parentListeners
-  vm.$options._parentListeners = listeners
-  updateComponentListeners(vm, listeners, oldListeners)
+  listeners = listeners || emptyObject;
+  const oldListeners = vm.$options._parentListeners;
+  vm.$options._parentListeners = listeners;
+  updateComponentListeners(vm, listeners, oldListeners);
 
   // resolve slots + force update if has children
   if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode!.context)
-    vm.$forceUpdate()
+    vm.$slots = resolveSlots(renderChildren, parentVnode!.context);
+    vm.$forceUpdate();
   }
 
-  if (process.env.NODE_ENV !== 'production') {
-    isUpdatingChildComponent = false
+  if (process.env.NODE_ENV !== "production") {
+    isUpdatingChildComponent = false;
   }
 }
 
 function isInInactiveTree(vm) {
   while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) return true
+    if (vm._inactive) return true;
   }
-  return false
+  return false;
 }
 
 export function activateChildComponent(vm: Component, direct?: boolean) {
   if (direct) {
-    vm._directInactive = false
+    vm._directInactive = false;
     if (isInInactiveTree(vm)) {
-      return
+      return;
     }
   } else if (vm._directInactive) {
-    return
+    return;
   }
   if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false
+    vm._inactive = false;
     for (let i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i])
+      activateChildComponent(vm.$children[i]);
     }
-    callHook(vm, 'activated')
+    callHook(vm, "activated");
   }
 }
 
 export function deactivateChildComponent(vm: Component, direct?: boolean) {
   if (direct) {
-    vm._directInactive = true
+    vm._directInactive = true;
     if (isInInactiveTree(vm)) {
-      return
+      return;
     }
   }
   if (!vm._inactive) {
-    vm._inactive = true
+    vm._inactive = true;
     for (let i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i])
+      deactivateChildComponent(vm.$children[i]);
     }
-    callHook(vm, 'deactivated')
+    callHook(vm, "deactivated");
   }
 }
 
 export function callHook(vm: Component, hook: string) {
   // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget()
-  const handlers = vm.$options[hook]
-  const info = `${hook} hook`
+  pushTarget();
+  const handlers = vm.$options[hook];
+  const info = `${hook} hook`;
   if (handlers) {
     for (let i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info)
+      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
     }
   }
   if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook)
+    vm.$emit("hook:" + hook);
   }
-  popTarget()
+  popTarget();
 }
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index f02f7d45762..fca48d1ac74 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -196,7 +196,7 @@ export function defineReactive(
  * triggers change notification if the property doesn't
  * already exist.
  */
-export function set(target: Array<any> | Object, key: any, val: any): any {
+export function set(target: Array<any> | Record<string,any>, key: any, val: any): any {
   if (
     process.env.NODE_ENV !== 'production' &&
     (isUndef(target) || isPrimitive(target))
@@ -215,8 +215,7 @@ export function set(target: Array<any> | Object, key: any, val: any): any {
     return val
   }
   const ob = (target as any).__ob__
-  // @ts-ignore
-  if (target._isVue || (ob && ob.vmCount)) {
+  if ((target as any)._isVue || (ob && ob.vmCount)) {
     process.env.NODE_ENV !== 'production' &&
       warn(
         'Avoid adding reactive properties to a Vue instance or its root $data ' +
@@ -250,8 +249,7 @@ export function del(target: Array<any> | Object, key: any) {
     return
   }
   const ob = (target as any).__ob__
-  //@ts-ignore
-  if (target._isVue || (ob && ob.vmCount)) {
+  if ((target as any)._isVue || (ob && ob.vmCount)) {
     process.env.NODE_ENV !== 'production' &&
       warn(
         'Avoid deleting properties on a Vue instance or its root $data ' +
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index ea607b0607e..ec42241abd2 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -35,13 +35,10 @@ if (process.env.NODE_ENV !== 'production') {
       return '<Root>'
     }
     const options =
-      // @ts-ignore
-      typeof vm === 'function' && vm.cid != null
-        ? // @ts-ignore
-          vm.options
+      typeof vm === 'function' && (vm as any).cid != null
+        ? (vm as any).options
         : vm._isVue
-        ? // @ts-ignore
-          vm.$options || vm.constructor.options
+        ? vm.$options || (vm.constructor as any).options
         : vm
     let name = options.name || options._componentTag
     const file = options.__file
@@ -67,8 +64,7 @@ if (process.env.NODE_ENV !== 'production') {
   }
 
   generateComponentTrace = (vm: Component | undefined) => {
-    // @ts-ignore
-    if (vm._isVue && vm.$parent) {
+    if ((vm as any)._isVue && vm!.$parent) {
       const tree: any[] = []
       let currentRecursiveSequence = 0
       while (vm) {
diff --git a/src/core/util/env.ts b/src/core/util/env.ts
index bc7fd82bc5c..49c08f13d47 100644
--- a/src/core/util/env.ts
+++ b/src/core/util/env.ts
@@ -4,11 +4,7 @@ export const hasProto = '__proto__' in {}
 
 // Browser environment sniffing
 export const inBrowser = typeof window !== 'undefined'
-// @ts-ignore
-export const inWeex =
-  // @ts-ignore
-  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
-// @ts-ignore
+export const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
 export const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
 export const UA = inBrowser && window.navigator.userAgent.toLowerCase()
 export const isIE = UA && /msie|trident/.test(UA)
@@ -23,7 +19,7 @@ export const isPhantomJS = UA && /phantomjs/.test(UA)
 export const isFF = UA && UA.match(/firefox\/(\d+)/)
 
 // Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
+// @ts-expect-error firebox support
 export const nativeWatch = {}.watch
 
 export let supportsPassive = false
@@ -36,8 +32,7 @@ if (inBrowser) {
         supportsPassive = true
       },
     } as object) // https://github.com/facebook/flow/issues/285
-    // @ts-ignore
-    window.addEventListener('test-passive', null, opts)
+    window.addEventListener('test-passive', null as any, opts)
   } catch (e) {}
 }
 
@@ -60,7 +55,6 @@ export const isServerRendering = () => {
 }
 
 // detect devtools
-// @ts-ignore TODO decalre this types
 export const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__
 
 /* istanbul ignore next */
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index af279c4b0b2..aeb2eaf2bbe 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -102,9 +102,7 @@ export function mergeDataOrFn(
     // it has to be a function to pass previous merges.
     return function mergedDataFn() {
       return mergeData(
-        // @ts-ignore
         typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        // @ts-ignore
         typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
       )
     }
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index 04a19b685ca..9fe0a40c8b0 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -120,8 +120,7 @@ function assertProp(
     return
   }
   let type = prop.type
-  // @ts-ignore
-  let valid = !type || type === true
+  let valid = !type || (type as any) === true
   const expectedTypes: string[] = []
   if (type) {
     if (!Array.isArray(type)) {
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index 26e456e6da5..6a03bc4b73c 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -33,7 +33,7 @@ export function extractPropsFromVNodeData(
           tip(
             `Prop "${keyInLowerCase}" is passed to component ` +
               `${formatComponentName(
-                // @ts-ignore
+                // @ts-expect-error tag is string
                 tag || Ctor
               )}, but the declared prop name is` +
               ` "${key}". ` +
diff --git a/src/core/vdom/modules/ref.ts b/src/core/vdom/modules/ref.ts
index 662c5c46550..f6651b905fc 100644
--- a/src/core/vdom/modules/ref.ts
+++ b/src/core/vdom/modules/ref.ts
@@ -1,48 +1,44 @@
-
-import { remove, isDef } from 'shared/util'
-import type { VNodeWithData } from 'typescript/vnode'
+import { remove, isDef } from "shared/util";
+import type { VNodeWithData } from "typescript/vnode";
 
 export default {
   create(_: any, vnode: VNodeWithData) {
-    registerRef(vnode)
+    registerRef(vnode);
   },
   update(oldVnode: VNodeWithData, vnode: VNodeWithData) {
     if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true)
-      registerRef(vnode)
+      registerRef(oldVnode, true);
+      registerRef(vnode);
     }
   },
   destroy(vnode: VNodeWithData) {
-    registerRef(vnode, true)
+    registerRef(vnode, true);
   },
-}
+};
 
 export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
-  const key = vnode.data.ref
-  if (!isDef(key)) return
+  const key = vnode.data.ref;
+  if (!isDef(key)) return;
 
-  const vm = vnode.context
-  const ref = vnode.componentInstance || vnode.elm
-  const refs = vm.$refs
+  const vm = vnode.context;
+  const ref = vnode.componentInstance || vnode.elm;
+  const refs = vm.$refs;
+  const obj = refs[key];
   if (isRemoval) {
-    if (Array.isArray(refs[key])) {
-      // @ts-expect-error invalid typings
-      remove(refs[key], ref)
-    } else if (refs[key] === ref) {
-      refs[key] = undefined
+    if (Array.isArray(obj)) {
+      remove(obj, ref);
+    } else if (obj === ref) {
+      refs[key] = undefined;
     }
   } else {
-    // @ts-expect-error invalid typings
     if (vnode.data.refInFor) {
-      if (!Array.isArray(refs[key])) {
-        refs[key] = [ref]
-        // @ts-expect-error invalid typings
-      } else if (refs[key].indexOf(ref) < 0) {
-        // @ts-expect-error invalid typings
-        refs[key].push(ref)
+      if (!Array.isArray(obj)) {
+        refs[key] = [ref];
+      } else if (obj.indexOf(ref) < 0) {
+        obj.push(ref);
       }
     } else {
-      refs[key] = ref
+      refs[key] = ref;
     }
   }
 }
diff --git a/src/core/vdom/vnode.ts b/src/core/vdom/vnode.ts
index a8e5ce8f3f4..3e8c40e248c 100644
--- a/src/core/vdom/vnode.ts
+++ b/src/core/vdom/vnode.ts
@@ -1,35 +1,35 @@
-import type { Component } from 'typescript/component'
-import type { ComponentOptions } from 'typescript/options'
-import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
+import type { Component } from "typescript/component";
+import type { ComponentOptions } from "typescript/options";
+import type { VNodeComponentOptions, VNodeData } from "typescript/vnode";
 
 export default class VNode {
-  tag: string | void
-  data: VNodeData | undefined
-  children?: Array<VNode> | null
-  text: string | void
-  elm: Node | void
-  ns: string | void
-  context: Component | void // rendered in this component's scope
-  key: string | number | void
-  componentOptions: VNodeComponentOptions | undefined
-  componentInstance: Component | void // component instance
-  parent: VNode | undefined // component placeholder node
+  tag?: string;
+  data: VNodeData | undefined;
+  children?: Array<VNode> | null;
+  text?: string;
+  elm: Node | undefined;
+  ns?: string;
+  context?: Component; // rendered in this component's scope
+  key: string | number | undefined;
+  componentOptions?: VNodeComponentOptions;
+  componentInstance?: Component; // component instance
+  parent: VNode | undefined; // component placeholder node
 
   // strictly internal
-  raw: boolean // contains raw HTML? (server only)
-  isStatic: boolean // hoisted static node
-  isRootInsert: boolean // necessary for enter transition check
-  isComment: boolean // empty comment placeholder?
-  isCloned: boolean // is a cloned node?
-  isOnce: boolean // is a v-once node?
-  asyncFactory: Function | void // async component factory function
-  asyncMeta: Object | void
-  isAsyncPlaceholder: boolean
-  ssrContext?: Object | void
-  fnContext: Component | void // real context vm for functional nodes
-  fnOptions?: ComponentOptions | null // for SSR caching
-  devtoolsMeta?: Object | null // used to store functional render context for devtools
-  fnScopeId?: string | null // functional scope id support
+  raw: boolean; // contains raw HTML? (server only)
+  isStatic: boolean; // hoisted static node
+  isRootInsert: boolean; // necessary for enter transition check
+  isComment: boolean; // empty comment placeholder?
+  isCloned: boolean; // is a cloned node?
+  isOnce: boolean; // is a v-once node?
+  asyncFactory?: Function; // async component factory function
+  asyncMeta: Object | void;
+  isAsyncPlaceholder: boolean;
+  ssrContext?: Object | void;
+  fnContext: Component | void; // real context vm for functional nodes
+  fnOptions?: ComponentOptions | null; // for SSR caching
+  devtoolsMeta?: Object | null; // used to store functional render context for devtools
+  fnScopeId?: string | null; // functional scope id support
 
   constructor(
     tag?: string,
@@ -41,47 +41,47 @@ export default class VNode {
     componentOptions?: VNodeComponentOptions,
     asyncFactory?: Function
   ) {
-    this.tag = tag
-    this.data = data
-    this.children = children
-    this.text = text
-    this.elm = elm
-    this.ns = undefined
-    this.context = context
-    this.fnContext = undefined
-    this.fnOptions = undefined
-    this.fnScopeId = undefined
-    this.key = data && data.key
-    this.componentOptions = componentOptions
-    this.componentInstance = undefined
-    this.parent = undefined
-    this.raw = false
-    this.isStatic = false
-    this.isRootInsert = true
-    this.isComment = false
-    this.isCloned = false
-    this.isOnce = false
-    this.asyncFactory = asyncFactory
-    this.asyncMeta = undefined
-    this.isAsyncPlaceholder = false
+    this.tag = tag;
+    this.data = data;
+    this.children = children;
+    this.text = text;
+    this.elm = elm;
+    this.ns = undefined;
+    this.context = context;
+    this.fnContext = undefined;
+    this.fnOptions = undefined;
+    this.fnScopeId = undefined;
+    this.key = data && data.key;
+    this.componentOptions = componentOptions;
+    this.componentInstance = undefined;
+    this.parent = undefined;
+    this.raw = false;
+    this.isStatic = false;
+    this.isRootInsert = true;
+    this.isComment = false;
+    this.isCloned = false;
+    this.isOnce = false;
+    this.asyncFactory = asyncFactory;
+    this.asyncMeta = undefined;
+    this.isAsyncPlaceholder = false;
   }
 
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   get child(): Component | void {
-    return this.componentInstance
+    return this.componentInstance;
   }
 }
 
-export const createEmptyVNode = (text: string = '') => {
-  const node = new VNode()
-  node.text = text
-  node.isComment = true
-  return node
-}
+export const createEmptyVNode = (text: string = "") => {
+  const node = new VNode();
+  node.text = text;
+  node.isComment = true;
+  return node;
+};
 
 export function createTextVNode(val: string | number) {
-  return new VNode(undefined, undefined, undefined, String(val))
+  return new VNode(undefined, undefined, undefined, String(val));
 }
 
 // optimized shallow clone
@@ -90,7 +90,6 @@ export function createTextVNode(val: string | number) {
 // on their elm reference.
 export function cloneVNode(vnode: VNode): VNode {
   const cloned = new VNode(
-    //@ts-expect-error void type not valid here
     vnode.tag,
     vnode.data,
     // #7975
@@ -102,15 +101,15 @@ export function cloneVNode(vnode: VNode): VNode {
     vnode.context,
     vnode.componentOptions,
     vnode.asyncFactory
-  )
-  cloned.ns = vnode.ns
-  cloned.isStatic = vnode.isStatic
-  cloned.key = vnode.key
-  cloned.isComment = vnode.isComment
-  cloned.fnContext = vnode.fnContext
-  cloned.fnOptions = vnode.fnOptions
-  cloned.fnScopeId = vnode.fnScopeId
-  cloned.asyncMeta = vnode.asyncMeta
-  cloned.isCloned = true
-  return cloned
+  );
+  cloned.ns = vnode.ns;
+  cloned.isStatic = vnode.isStatic;
+  cloned.key = vnode.key;
+  cloned.isComment = vnode.isComment;
+  cloned.fnContext = vnode.fnContext;
+  cloned.fnOptions = vnode.fnOptions;
+  cloned.fnScopeId = vnode.fnScopeId;
+  cloned.asyncMeta = vnode.asyncMeta;
+  cloned.isCloned = true;
+  return cloned;
 }
diff --git a/src/global.d.ts b/src/global.d.ts
index fe43838c759..f51385c7da0 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -20,3 +20,18 @@ declare type WeexEnvironment = {
   rem?: number;
 };
 declare let WXEnvironment: WeexEnvironment;
+
+interface Window {
+  __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook;
+}
+
+
+// from https://github.com/vuejs/vue-devtools/blob/bc719c95a744614f5c3693460b64dc21dfa339a8/packages/app-backend-api/src/global-hook.ts#L3
+interface DevtoolsHook {
+  emit: (event: string, ...payload: any[]) => void
+  on: (event: string, handler: Function) => void
+  once: (event: string, handler: Function) => void
+  off: (event?: string, handler?: Function) => void
+  Vue?: any
+  // apps: AppRecordOptions[]
+}
\ No newline at end of file
diff --git a/src/platforms/web/compiler/modules/class.ts b/src/platforms/web/compiler/modules/class.ts
index 81a02947577..1fed3b8428f 100644
--- a/src/platforms/web/compiler/modules/class.ts
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -41,4 +41,4 @@ export default {
   staticKeys: ['staticClass'],
   transformNode,
   genData,
-}
+} as ModuleOptions
diff --git a/src/platforms/web/compiler/modules/model.ts b/src/platforms/web/compiler/modules/model.ts
index 955fbb7df63..d55d08b5fcc 100644
--- a/src/platforms/web/compiler/modules/model.ts
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -86,4 +86,4 @@ function cloneASTElement(el) {
 
 export default {
   preTransformNode,
-}
+} as ModuleOptions
diff --git a/src/platforms/web/compiler/modules/style.ts b/src/platforms/web/compiler/modules/style.ts
index bb5eb4869c9..833a40d3d5c 100644
--- a/src/platforms/web/compiler/modules/style.ts
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -44,4 +44,4 @@ export default {
   staticKeys: ['staticStyle'],
   transformNode,
   genData,
-}
+} as ModuleOptions
diff --git a/src/platforms/web/compiler/options.ts b/src/platforms/web/compiler/options.ts
index d8e3d467c21..edbc1fdac34 100644
--- a/src/platforms/web/compiler/options.ts
+++ b/src/platforms/web/compiler/options.ts
@@ -1,15 +1,14 @@
-
 import {
   isPreTag,
   mustUseProp,
   isReservedTag,
   getTagNamespace,
-} from '../util/index'
+} from "../util/index";
 
-import modules from './modules/index'
-import directives from './directives/index'
-import { genStaticKeys } from 'shared/util'
-import { isUnaryTag, canBeLeftOpenTag } from './util'
+import modules from "./modules/index";
+import directives from "./directives/index";
+import { genStaticKeys } from "shared/util";
+import { isUnaryTag, canBeLeftOpenTag } from "./util";
 
 export const baseOptions: CompilerOptions = {
   expectHTML: true,
@@ -21,6 +20,5 @@ export const baseOptions: CompilerOptions = {
   canBeLeftOpenTag,
   isReservedTag,
   getTagNamespace,
-  // @ts-ignore
   staticKeys: genStaticKeys(modules),
-} as any
+};
diff --git a/src/platforms/web/runtime/components/transition-group.ts b/src/platforms/web/runtime/components/transition-group.ts
index 3dd93090a5e..d62318ed2fb 100644
--- a/src/platforms/web/runtime/components/transition-group.ts
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -9,10 +9,10 @@
 // into the final desired state. This way in the second pass removed
 // nodes will remain where they should be.
 
-import { warn, extend } from 'core/util/index'
-import { addClass, removeClass } from 'web/runtime/class-util'
-import { transitionProps, extractTransitionData } from './transition'
-import { setActiveInstance } from 'core/instance/lifecycle'
+import { warn, extend } from "core/util/index";
+import { addClass, removeClass } from "web/runtime/class-util";
+import { transitionProps, extractTransitionData } from "./transition";
+import { setActiveInstance } from "core/instance/lifecycle";
 
 import {
   hasTransition,
@@ -20,8 +20,9 @@ import {
   transitionEndEvent,
   addTransitionClass,
   removeTransitionClass,
-} from 'web/runtime/transition-util'
-import VNode from 'core/vdom/vnode'
+} from "web/runtime/transition-util";
+import VNode from "core/vdom/vnode";
+import { VNodeWithData } from "typescript/vnode";
 
 const props = extend(
   {
@@ -29,184 +30,174 @@ const props = extend(
     moveClass: String,
   },
   transitionProps
-)
+);
 
-// @ts-ignore
-delete props.mode
+delete props.mode;
 
 export default {
   props,
 
   beforeMount() {
-    const update = this._update
+    const update = this._update;
     this._update = (vnode, hydrating) => {
-      const restoreActiveInstance = setActiveInstance(this)
+      const restoreActiveInstance = setActiveInstance(this);
       // force removing pass
       this.__patch__(
         this._vnode,
         this.kept,
         false, // hydrating
         true // removeOnly (!important, avoids unnecessary moves)
-      )
-      this._vnode = this.kept
-      restoreActiveInstance()
-      update.call(this, vnode, hydrating)
-    }
+      );
+      this._vnode = this.kept;
+      restoreActiveInstance();
+      update.call(this, vnode, hydrating);
+    };
   },
 
   render(h: Function) {
-    const tag: string = this.tag || this.$vnode.data.tag || 'span'
-    const map: Object = Object.create(null)
-    const prevChildren: Array<VNode> = (this.prevChildren = this.children)
-    const rawChildren: Array<VNode> = this.$slots.default || []
-    const children: Array<VNode> = (this.children = [])
-    const transitionData: Object = extractTransitionData(this)
+    const tag: string = this.tag || this.$vnode.data.tag || "span";
+    const map: Record<string, any> = Object.create(null);
+    const prevChildren: Array<VNode> = (this.prevChildren = this.children);
+    const rawChildren: Array<VNode> = this.$slots.default || [];
+    const children: Array<VNode> = (this.children = []);
+    const transitionData = extractTransitionData(this);
 
     for (let i = 0; i < rawChildren.length; i++) {
-      const c: VNode = rawChildren[i]
+      const c: VNode = rawChildren[i];
       if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c)
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData
-        } else if (process.env.NODE_ENV !== 'production') {
-          const opts = c.componentOptions
+        if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+          children.push(c);
+          map[c.key] = c;
+          (c.data || (c.data = {})).transition = transitionData;
+        } else if (process.env.NODE_ENV !== "production") {
+          const opts = c.componentOptions;
           const name: string = opts
-            ? opts.Ctor.options.name || opts.tag || ''
-            : c.tag
-          warn(`<transition-group> children must be keyed: <${name}>`)
+            ? opts.Ctor.options.name || opts.tag || ""
+            : c.tag;
+          warn(`<transition-group> children must be keyed: <${name}>`);
         }
       }
     }
 
     if (prevChildren) {
-      const kept: Array<VNode> = []
-      const removed: Array<VNode> = []
+      const kept: Array<VNode> = [];
+      const removed: Array<VNode> = [];
       for (let i = 0; i < prevChildren.length; i++) {
-        const c: VNode = prevChildren[i]
-        c.data!.transition = transitionData
-        // @ts-ignore
-        c.data.pos = c.elm.getBoundingClientRect()
-        // @ts-ignore
-        if (map[c.key]) {
-          kept.push(c)
+        const c: VNode = prevChildren[i];
+        c.data!.transition = transitionData;
+        // @ts-expect-error .getBoundingClientRect is not typed in Node
+        c.data!.pos = c.elm.getBoundingClientRect();
+        if (map[c.key!]) {
+          kept.push(c);
         } else {
-          removed.push(c)
+          removed.push(c);
         }
       }
-      this.kept = h(tag, null, kept)
-      this.removed = removed
+      this.kept = h(tag, null, kept);
+      this.removed = removed;
     }
 
-    return h(tag, null, children)
+    return h(tag, null, children);
   },
 
   updated() {
-    const children: Array<VNode> = this.prevChildren
-    const moveClass: string = this.moveClass || (this.name || 'v') + '-move'
+    const children: Array<VNodeWithData> = this.prevChildren;
+    const moveClass: string = this.moveClass || (this.name || "v") + "-move";
     if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return
+      return;
     }
 
     // we divide the work into three loops to avoid mixing DOM reads and writes
     // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs)
-    children.forEach(recordPosition)
-    children.forEach(applyTranslation)
+    children.forEach(callPendingCbs);
+    children.forEach(recordPosition);
+    children.forEach(applyTranslation);
 
     // force reflow to put everything in position
     // assign to this to avoid being removed in tree-shaking
     // $flow-disable-line
-    this._reflow = document.body.offsetHeight
+    this._reflow = document.body.offsetHeight;
 
     children.forEach((c: VNode) => {
-      // @ts-ignore
-      if (c.data.moved) {
-        const el: any = c.elm
-        const s: any = el.style
-        addTransitionClass(el, moveClass)
-        s.transform = s.WebkitTransform = s.transitionDuration = ''
+      if (c.data!.moved) {
+        const el: any = c.elm;
+        const s: any = el.style;
+        addTransitionClass(el, moveClass);
+        s.transform = s.WebkitTransform = s.transitionDuration = "";
         el.addEventListener(
           transitionEndEvent,
           (el._moveCb = function cb(e) {
             if (e && e.target !== el) {
-              return
+              return;
             }
             if (!e || /transform$/.test(e.propertyName)) {
-              el.removeEventListener(transitionEndEvent, cb)
-              el._moveCb = null
-              removeTransitionClass(el, moveClass)
+              el.removeEventListener(transitionEndEvent, cb);
+              el._moveCb = null;
+              removeTransitionClass(el, moveClass);
             }
           })
-        )
+        );
       }
-    })
+    });
   },
 
   methods: {
     hasMove(el: any, moveClass: string): boolean {
       /* istanbul ignore if */
       if (!hasTransition) {
-        return false
+        return false;
       }
       /* istanbul ignore if */
       if (this._hasMove) {
-        return this._hasMove
+        return this._hasMove;
       }
       // Detect whether an element with the move class applied has
       // CSS transitions. Since the element may be inside an entering
       // transition at this very moment, we make a clone of it and remove
       // all other transition classes applied to ensure only the move class
       // is applied.
-      const clone: HTMLElement = el.cloneNode()
+      const clone: HTMLElement = el.cloneNode();
       if (el._transitionClasses) {
         el._transitionClasses.forEach((cls: string) => {
-          removeClass(clone, cls)
-        })
+          removeClass(clone, cls);
+        });
       }
-      addClass(clone, moveClass)
-      clone.style.display = 'none'
-      this.$el.appendChild(clone)
-      const info: any = getTransitionInfo(clone)
-      this.$el.removeChild(clone)
-      return (this._hasMove = info.hasTransform)
+      addClass(clone, moveClass);
+      clone.style.display = "none";
+      this.$el.appendChild(clone);
+      const info: any = getTransitionInfo(clone);
+      this.$el.removeChild(clone);
+      return (this._hasMove = info.hasTransform);
     },
   },
-}
+};
 
-function callPendingCbs(c: VNode) {
+function callPendingCbs(
+  c: VNodeWithData & { elm?: { _moveCb?: Function; _enterCb?: Function } }
+) {
   /* istanbul ignore if */
-  //@ts-ignore
-  if (c.elm._moveCb) {
-    //@ts-ignore
-    c.elm._moveCb()
+  if (c.elm!._moveCb) {
+    c.elm!._moveCb();
   }
   /* istanbul ignore if */
-  //@ts-ignore
-  if (c.elm._enterCb) {
-    //@ts-ignore
-    c.elm._enterCb()
+  if (c.elm!._enterCb) {
+    c.elm!._enterCb();
   }
 }
 
-function recordPosition(c: VNode) {
-  //@ts-ignore
-  c.data.newPos = c.elm.getBoundingClientRect()
+function recordPosition(c: VNodeWithData) {
+  c.data!.newPos = c.elm.getBoundingClientRect();
 }
 
-function applyTranslation(c: VNode) {
-  //@ts-ignore
-  const oldPos = c.data.pos
-  //@ts-ignore
-  const newPos = c.data.newPos
-  const dx = oldPos.left - newPos.left
-  const dy = oldPos.top - newPos.top
+function applyTranslation(c: VNodeWithData) {
+  const oldPos = c.data.pos;
+  const newPos = c.data.newPos;
+  const dx = oldPos.left - newPos.left;
+  const dy = oldPos.top - newPos.top;
   if (dx || dy) {
-    //@ts-ignore
-    c.data.moved = true
-    //@ts-ignore
-    const s = c.elm.style
-    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`
-    s.transitionDuration = '0s'
+    c.data.moved = true;
+    const s = c.elm.style;
+    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+    s.transitionDuration = "0s";
   }
 }
diff --git a/src/platforms/weex/compiler/index.ts b/src/platforms/weex/compiler/index.ts
index fb6de3bbfe7..37782b99f25 100644
--- a/src/platforms/weex/compiler/index.ts
+++ b/src/platforms/weex/compiler/index.ts
@@ -24,9 +24,8 @@ export const baseOptions: WeexCompilerOptions = {
   getTagNamespace,
   preserveWhitespace: false,
   recyclable: false,
-  // @ts-ignore
   staticKeys: genStaticKeys(modules),
-} as any
+}
 
 const compiler = createCompiler(baseOptions)
 
diff --git a/src/platforms/weex/compiler/modules/append.ts b/src/platforms/weex/compiler/modules/append.ts
index 644b21a0763..90555041332 100644
--- a/src/platforms/weex/compiler/modules/append.ts
+++ b/src/platforms/weex/compiler/modules/append.ts
@@ -26,4 +26,4 @@ export default {
   staticKeys: ['appendAsTree'],
   preTransformNode,
   genData,
-}
+} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/class.ts b/src/platforms/weex/compiler/modules/class.ts
index 602101487d0..99c6d771cba 100644
--- a/src/platforms/weex/compiler/modules/class.ts
+++ b/src/platforms/weex/compiler/modules/class.ts
@@ -72,4 +72,4 @@ export default {
   staticKeys: ['staticClass'],
   transformNode,
   genData,
-}
+} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/props.ts b/src/platforms/weex/compiler/modules/props.ts
index 1bf89d08c54..08b358ed09c 100644
--- a/src/platforms/weex/compiler/modules/props.ts
+++ b/src/platforms/weex/compiler/modules/props.ts
@@ -33,4 +33,4 @@ function transformNode(el: ASTElement) {
 }
 export default {
   transformNode,
-}
+} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/recycle-list/index.ts b/src/platforms/weex/compiler/modules/recycle-list/index.ts
index 2fdeab16008..89b25e7b306 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/index.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/index.ts
@@ -56,4 +56,4 @@ export default {
   preTransformNode,
   transformNode,
   postTransformNode,
-}
+} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
index d8aaed20886..a8a22347c4d 100644
--- a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
+++ b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
@@ -1,63 +1,61 @@
-
-import { addIfCondition } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-import type { WeexCompilerOptions } from 'typescript/weex'
+import { addIfCondition } from "compiler/parser/index";
+import { getAndRemoveAttr, addRawAttr } from "compiler/helpers";
+import type { WeexCompilerOptions } from "typescript/weex";
 
 function hasConditionDirective(el: ASTElement): boolean {
   for (const attr in el.attrsMap) {
     if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
-      return true
+      return true;
     }
   }
-  return false
+  return false;
 }
 
 function getPreviousConditions(el: ASTElement): Array<string> {
-  const conditions: any[] = []
+  const conditions: any[] = [];
   if (el.parent && el.parent.children) {
     for (let c = 0, n = el.parent.children.length; c < n; ++c) {
-      // @ts-ignore
-      const ifConditions = el.parent.children[c].ifConditions
+      const ifConditions = (el.parent.children[c] as ASTElement).ifConditions;
       if (ifConditions) {
         for (let i = 0, l = ifConditions.length; i < l; ++i) {
-          const condition = ifConditions[i]
+          const condition = ifConditions[i];
           if (condition && condition.exp) {
-            conditions.push(condition.exp)
+            conditions.push(condition.exp);
           }
         }
       }
     }
   }
-  return conditions
+  return conditions;
 }
 
 export function preTransformVIf(el: ASTElement, options: WeexCompilerOptions) {
   if (hasConditionDirective(el)) {
-    let exp
-    const ifExp = getAndRemoveAttr(el, 'v-if', true /* remove from attrsMap */)
-    const elseifExp = getAndRemoveAttr(el, 'v-else-if', true)
+    let exp;
+    const ifExp = getAndRemoveAttr(el, "v-if", true /* remove from attrsMap */);
+    const elseifExp = getAndRemoveAttr(el, "v-else-if", true);
     // don't need the value, but remove it to avoid being generated as a
     // custom directive
-    getAndRemoveAttr(el, 'v-else', true)
+    getAndRemoveAttr(el, "v-else", true);
     if (ifExp) {
-      exp = ifExp
-      addIfCondition(el, { exp: ifExp, block: el })
+      exp = ifExp;
+      addIfCondition(el, { exp: ifExp, block: el });
     } else {
-      elseifExp && addIfCondition(el, { exp: elseifExp, block: el })
-      const prevConditions = getPreviousConditions(el)
+      elseifExp && addIfCondition(el, { exp: elseifExp, block: el });
+      const prevConditions = getPreviousConditions(el);
       if (prevConditions.length) {
-        const prevMatch = prevConditions.join(' || ')
+        const prevMatch = prevConditions.join(" || ");
         exp = elseifExp
           ? `!(${prevMatch}) && (${elseifExp})` // v-else-if
-          : `!(${prevMatch})` // v-else
-      } else if (process.env.NODE_ENV !== 'production' && options.warn) {
+          : `!(${prevMatch})`; // v-else
+      } else if (process.env.NODE_ENV !== "production" && options.warn) {
         options.warn(
-          `v-${elseifExp ? 'else-if="' + elseifExp + '"' : 'else'} ` +
+          `v-${elseifExp ? 'else-if="' + elseifExp + '"' : "else"} ` +
             `used on element <${el.tag}> without corresponding v-if.`
-        )
-        return
+        );
+        return;
       }
     }
-    addRawAttr(el, '[[match]]', exp)
+    addRawAttr(el, "[[match]]", exp);
   }
 }
diff --git a/src/platforms/weex/compiler/modules/style.ts b/src/platforms/weex/compiler/modules/style.ts
index 9eda4e83a64..67ba48e2fe4 100644
--- a/src/platforms/weex/compiler/modules/style.ts
+++ b/src/platforms/weex/compiler/modules/style.ts
@@ -5,7 +5,7 @@ import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 
 type StaticStyleResult = {
   dynamic: boolean
-  styleResult: string | Record<string, any> | void
+  styleResult: string 
 }
 
 const normalize = cached(camelize)
@@ -23,14 +23,12 @@ function transformNode(el: ASTElement, options: CompilerOptions) {
     )
   }
   if (!dynamic && styleResult) {
-    // @ts-ignore
     el.staticStyle = styleResult
   }
   const styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
   if (styleBinding) {
     el.styleBinding = styleBinding
   } else if (dynamic) {
-    // @ts-ignore
     el.styleBinding = styleResult
   }
 }
@@ -86,4 +84,4 @@ export default {
   staticKeys: ['staticStyle'],
   transformNode,
   genData,
-}
+} as ModuleOptions
diff --git a/src/platforms/weex/entry-framework.ts b/src/platforms/weex/entry-framework.ts
index 6dc4622f49c..d434dbbefcb 100644
--- a/src/platforms/weex/entry-framework.ts
+++ b/src/platforms/weex/entry-framework.ts
@@ -1,5 +1,5 @@
 
-import { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'typescript/global-api'
 import type {
   Weex,
   WeexInstanceContext,
@@ -8,7 +8,6 @@ import type {
 } from 'typescript/weex'
 
 // this will be preserved during build
-// $flow-disable-line
 const VueFactory = require('./factory')
 
 const instanceOptions: { [key: string]: WeexInstanceOption } = {}
diff --git a/src/platforms/weex/runtime/index.ts b/src/platforms/weex/runtime/index.ts
index c2b2788d9d6..a310677d2bf 100644
--- a/src/platforms/weex/runtime/index.ts
+++ b/src/platforms/weex/runtime/index.ts
@@ -1,5 +1,3 @@
-//@ts-nocheck
-
 import Vue from 'core/index'
 import { patch } from 'weex/runtime/patch'
 import { mountComponent } from 'core/instance/lifecycle'
@@ -14,6 +12,8 @@ import {
   isUnknownElement,
 } from 'weex/util/element'
 
+import { Component} from 'typescript/component'
+
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp
 Vue.config.isReservedTag = isReservedTag
diff --git a/src/platforms/weex/types.d.ts b/src/platforms/weex/types.d.ts
new file mode 100644
index 00000000000..0871a9c18f2
--- /dev/null
+++ b/src/platforms/weex/types.d.ts
@@ -0,0 +1,7 @@
+import "core/config";
+
+declare module "core/config" {
+  interface Config {
+    isRuntimeComponent: (key: string) => true | undefined;
+  }
+}
diff --git a/src/platforms/weex/util/element.ts b/src/platforms/weex/util/element.ts
index b521f39412a..44fdfe4db6e 100644
--- a/src/platforms/weex/util/element.ts
+++ b/src/platforms/weex/util/element.ts
@@ -1,47 +1,48 @@
-
 // These util functions are split into its own file because Rollup cannot drop
 // makeMap() due to potential side effects, so these variables end up
 // bloating the web builds.
 
-import { makeMap, noop } from 'shared/util'
+import { makeMap, noop } from "shared/util";
 
 export const isReservedTag = makeMap(
-  'template,script,style,element,content,slot,link,meta,svg,view,' +
-    'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-    'slider,slider-neighbor,indicator,canvas,' +
-    'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-    'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
+  "template,script,style,element,content,slot,link,meta,svg,view," +
+    "a,div,img,image,text,span,input,switch,textarea,spinner,select," +
+    "slider,slider-neighbor,indicator,canvas," +
+    "list,cell,header,loading,loading-indicator,refresh,scrollable,scroller," +
+    "video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown",
   true
-)
+);
 
 // Elements that you can, intentionally, leave open (and which close themselves)
 // more flexible than web
 export const canBeLeftOpenTag = makeMap(
-  'web,spinner,switch,video,textarea,canvas,' + 'indicator,marquee,countdown',
+  "web,spinner,switch,video,textarea,canvas," + "indicator,marquee,countdown",
   true
-)
+);
 
 export const isRuntimeComponent = makeMap(
-  'richtext,transition,transition-group',
+  "richtext,transition,transition-group",
   true
-)
+);
 
-export const isUnaryTag = makeMap('embed,img,image,input,link,meta', true)
+export const isUnaryTag = makeMap("embed,img,image,input,link,meta", true);
 
 export function mustUseProp(): boolean {
-  return false
+  return false;
 }
 
-export function getTagNamespace(): void {}
+export function getTagNamespace() {
+  return undefined;
+}
 
 export function isUnknownElement(): boolean {
-  return false
+  return false;
 }
 
 export function query(el: string | Element, document: any) {
   // document is injected by weex factory wrapper
-  const placeholder = document.createComment('root')
-  placeholder.hasAttribute = placeholder.removeAttribute = noop // hack for patch
-  document.documentElement.appendChild(placeholder)
-  return placeholder
+  const placeholder = document.createComment("root");
+  placeholder.hasAttribute = placeholder.removeAttribute = noop; // hack for patch
+  document.documentElement.appendChild(placeholder);
+  return placeholder;
 }
diff --git a/src/shared/util.ts b/src/shared/util.ts
index bd6f04ee7fe..f2e201e6a95 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -1,5 +1,5 @@
 
-export const emptyObject = Object.freeze({})
+export const emptyObject: Record<string, any> = Object.freeze({})
 
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
@@ -98,6 +98,7 @@ export function toNumber(val: string): number | string {
   return isNaN(n) ? val : n
 }
 
+
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
diff --git a/tsconfig.json b/tsconfig.json
index dc0f692a514..38ad99633d5 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -8,8 +8,10 @@
     "moduleResolution": "node",
     "allowJs": true,
     "strict": true,
+    
     "noImplicitAny": false,
     "noImplicitThis": false,
+
     "noUnusedLocals": true,
     "experimentalDecorators": true,
     "resolveJsonModule": true,
@@ -21,6 +23,7 @@
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
+
       "server/*": ["src/server/*"],
       "sfc/*": ["src/sfc/*"],
       "shared/*": ["src/shared/*"],
diff --git a/typescript/compiler.d.ts b/typescript/compiler.d.ts
index b4e2eb72be7..5d2356dbe39 100644
--- a/typescript/compiler.d.ts
+++ b/typescript/compiler.d.ts
@@ -3,21 +3,17 @@ declare type CompilerOptions = {
   modules?: Array<ModuleOptions>; // platform specific modules; e.g. style; class
   directives?: { [key: string]: Function }; // platform specific directives
   staticKeys?: string; // a list of AST properties to be considered static; for optimization
-  isUnaryTag?: (tag: string) => boolean | null; // check if a tag is unary for the platform
-  canBeLeftOpenTag?: (tag: string) => boolean | null; // check if a tag can be left opened
-  isReservedTag?: (tag: string) => boolean | null; // check if a tag is a native for the platform
+  isUnaryTag?: (tag: string) => boolean | undefined; // check if a tag is unary for the platform
+  canBeLeftOpenTag?: (tag: string) => boolean | undefined; // check if a tag can be left opened
+  isReservedTag?: (tag: string) => boolean | undefined; // check if a tag is a native for the platform
   preserveWhitespace?: boolean; // preserve whitespace between elements? (Deprecated)
   whitespace?: "preserve" | "condense"; // whitespace handling strategy
   optimize?: boolean; // optimize static content?
 
   // web specific
-  mustUseProp?: (
-    tag: string,
-    type: string | null,
-    name: string
-  ) => boolean; // check if an attribute should be bound as a property
+  mustUseProp?: (tag: string, type: string | null, name: string) => boolean; // check if an attribute should be bound as a property
   isPreTag?: (attr: string) => boolean | null; // check if a tag needs to preserve whitespace
-  getTagNamespace?: (tag: string) => string | null; // check the namespace for a tag
+  getTagNamespace?: (tag: string) => string | undefined; // check the namespace for a tag
   expectHTML?: boolean; // only false for non-web builds
   isFromDOM?: boolean;
   shouldDecodeTags?: boolean;
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index db14beeda20..62d9e0cbb2c 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -1,9 +1,10 @@
-import type { Config } from "../src/core/config";
 import type VNode from "../src/core/vdom/vnode";
 import type Watcher from "../src/core/observer/watcher";
 import { ComponentOptions } from "./options";
 import { ScopedSlotsData, VNodeChildren, VNodeData } from "./vnode";
 
+// TODO this should be using the same as /component/
+
 declare class Component {
   // constructor information
   static cid: number;
@@ -19,7 +20,10 @@ declare class Component {
     id: string,
     def?: Function | Record<string, any>
   ) => Function | Record<string, any> | void;
-  static component: (id: string, def?: Component | Record<string, any>) => Component;
+  static component: (
+    id: string,
+    def?: Component | Record<string, any>
+  ) => Component;
   static filter: (id: string, def?: Function) => Function | void;
   // functional context constructor
   static FunctionalRenderContext: Function;
@@ -39,15 +43,22 @@ declare class Component {
   $scopedSlots: { [key: string]: () => VNodeChildren };
   $vnode: VNode; // the placeholder node for the component in parent's render tree
   $attrs: { [key: string]: string };
-  $listeners: { [key: string]: Function | Array<Function> };
+  $listeners: Record<string, Function | Array<Function>>;
   $isServer: boolean;
 
   // public methods
   $mount: (el?: Element | string, hydrating?: boolean) => Component;
   $forceUpdate: () => void;
   $destroy: () => void;
-  $set: <T>(target: Record<string, any> | Array<T>, key: string | number, val: T) => T;
-  $delete: <T>(target: Record<string, any> | Array<T>, key: string | number) => void;
+  $set: <T>(
+    target: Record<string, any> | Array<T>,
+    key: string | number,
+    val: T
+  ) => T;
+  $delete: <T>(
+    target: Record<string, any> | Array<T>,
+    key: string | number
+  ) => void;
   $watch: (
     expOrFn: string | Function,
     cb: Function,
@@ -71,7 +82,7 @@ declare class Component {
   _self: Component;
   _renderProxy: Component;
   _renderContext?: Component;
-  _watcher: Watcher;
+  _watcher: Watcher | null;
   _watchers: Array<Watcher>;
   _computedWatchers: { [key: string]: Watcher };
   _data: Record<string, any>;
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
index 02c88cec834..c06aa595454 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.d.ts
@@ -78,6 +78,9 @@ declare type ComponentOptions = {
   comments?: boolean;
   inheritAttrs?: boolean;
 
+  // Class API
+  abstract?: any
+
   // private
   _isComponent?: true;
   _propKeys?: Array<string>;
diff --git a/typescript/vnode.d.ts b/typescript/vnode.d.ts
index ca45d5fd3e9..1dd467cc22c 100644
--- a/typescript/vnode.d.ts
+++ b/typescript/vnode.d.ts
@@ -8,12 +8,12 @@ declare type VNodeChildren =
 declare type VNodeComponentOptions = {
   Ctor: Component;
   propsData?: Object;
-  listeners?: Object;
+  listeners?: Record<string, Function | Function[]>;
   children?: Array<VNode>;
   tag?: string;
 };
 
-declare type MountedComponentVNode = {
+declare type MountedComponentVNode = VNode & {
   context: Component;
   componentOptions: VNodeComponentOptions;
   componentInstance: Component;
@@ -22,7 +22,7 @@ declare type MountedComponentVNode = {
 };
 
 // interface for vnodes in update modules
-declare type VNodeWithData = {
+declare type VNodeWithData = VNode & {
   tag: string;
   data: VNodeData;
   children: Array<VNode>;
@@ -37,6 +37,22 @@ declare type VNodeWithData = {
   isRootInsert: boolean;
 };
 
+// // interface for vnodes in update modules
+// declare type VNodeWithData = {
+//   tag: string;
+//   data: VNodeData;
+//   children: Array<VNode>;
+//   text: void;
+//   elm: any;
+//   ns: string | void;
+//   context: Component;
+//   key: string | number | undefined;
+//   parent?: VNodeWithData;
+//   componentOptions?: VNodeComponentOptions;
+//   componentInstance?: Component;
+//   isRootInsert: boolean;
+// };
+
 declare interface VNodeData {
   key?: string | number;
   slot?: string;
@@ -68,6 +84,8 @@ declare interface VNodeData {
     value: any;
     callback: Function;
   };
+
+  [key: string]: any;
 }
 
 declare type VNodeDirective = {

From 0a52a37e6851cc563c695e3869ce753bd98e116b Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Thu, 28 Apr 2022 16:47:36 -0600
Subject: [PATCH 021/317] chore: support building on a Mac M1

---
 package.json |    5 +-
 yarn.lock    | 3210 +++++++++++++++++++++++++++-----------------------
 2 files changed, 1738 insertions(+), 1477 deletions(-)

diff --git a/package.json b/package.json
index c94b91a2949..bcce02f706f 100644
--- a/package.json
+++ b/package.json
@@ -75,6 +75,7 @@
     "@babel/plugin-transform-flow-strip-types": "^7.13.0",
     "@babel/preset-env": "^7.13.12",
     "@babel/register": "^7.13.14",
+    "@mapbox/node-pre-gyp": "1.0.9",
     "@rollup/plugin-alias": "^3.1.2",
     "@rollup/plugin-buble": "^0.21.3",
     "@rollup/plugin-commonjs": "^18.0.0",
@@ -94,7 +95,8 @@
     "babel-preset-flow-vue": "^1.0.0",
     "buble": "^0.20.0",
     "chalk": "^2.3.0",
-    "chromedriver": "^2.45.0",
+    "chokidar": "^3.5.3",
+    "chromedriver": "^90.0",
     "codecov": "^3.0.0",
     "commitizen": "^2.9.6",
     "conventional-changelog": "^1.1.3",
@@ -108,6 +110,7 @@
     "eslint-plugin-jasmine": "^2.8.4",
     "file-loader": "^3.0.1",
     "flow-bin": "^0.61.0",
+    "fsevents": "2.3.2",
     "hash-sum": "^1.0.2",
     "he": "^1.1.1",
     "http-server": "^0.12.3",
diff --git a/yarn.lock b/yarn.lock
index 3879354d438..a291595b13c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4,33 +4,33 @@
 
 "@babel/code-frame@7.12.11":
   version "7.12.11"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.11.tgz#f4ad435aa263db935b8f10f2c552d23fb716a63f"
+  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.11.tgz"
   integrity sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw==
   dependencies:
     "@babel/highlight" "^7.10.4"
 
 "@babel/code-frame@^7.0.0":
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.0.0.tgz#06e2ab19bdb535385559aabb5ba59729482800f8"
+  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0.tgz"
   integrity sha512-OfC2uemaknXr87bdLUkWog7nYuliM9Ij5HUcajsVcMCpQrcLmtxRbVFTIqmcSkSeYRBFBRxs2FiUqFJDLdiebA==
   dependencies:
     "@babel/highlight" "^7.0.0"
 
 "@babel/code-frame@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.13.tgz#dcfc826beef65e75c50e21d3837d7d95798dd658"
+  resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz"
   integrity sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==
   dependencies:
     "@babel/highlight" "^7.12.13"
 
 "@babel/compat-data@^7.13.0", "@babel/compat-data@^7.13.12", "@babel/compat-data@^7.13.8":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.13.12.tgz#a8a5ccac19c200f9dd49624cac6e19d7be1236a1"
+  resolved "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.13.12.tgz"
   integrity sha512-3eJJ841uKxeV8dcN/2yGEUy+RfgQspPEgQat85umsE1rotuquQ2AbIub4S6j7c50a2d+4myc+zSlnXeIHrOnhQ==
 
 "@babel/core@^7.13.14":
   version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.13.14.tgz#8e46ebbaca460a63497c797e574038ab04ae6d06"
+  resolved "https://registry.npmjs.org/@babel/core/-/core-7.13.14.tgz"
   integrity sha512-wZso/vyF4ki0l0znlgM4inxbdrUvCb+cVz8grxDq+6C9k6qbqoIJteQOKicaKjCipU3ISV+XedCqpL2RJJVehA==
   dependencies:
     "@babel/code-frame" "^7.12.13"
@@ -51,7 +51,7 @@
 
 "@babel/generator@^7.0.0", "@babel/generator@^7.2.2":
   version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.2.2.tgz#18c816c70962640eab42fe8cae5f3947a5c65ccc"
+  resolved "https://registry.npmjs.org/@babel/generator/-/generator-7.2.2.tgz"
   integrity sha512-I4o675J/iS8k+P38dvJ3IBGqObLXyQLTxtrR4u9cSUJOURvafeEWb/pFMOTwtNrmq73mJzyF6ueTbO1BtN0Zeg==
   dependencies:
     "@babel/types" "^7.2.2"
@@ -62,7 +62,7 @@
 
 "@babel/generator@^7.13.9":
   version "7.13.9"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.13.9.tgz#3a7aa96f9efb8e2be42d38d80e2ceb4c64d8de39"
+  resolved "https://registry.npmjs.org/@babel/generator/-/generator-7.13.9.tgz"
   integrity sha512-mHOOmY0Axl/JCTkxTU6Lf5sWOg/v8nUa+Xkt4zMTftX0wqmb6Sh7J8gvcehBw7q0AhrhAR+FDacKjCZ2X8K+Sw==
   dependencies:
     "@babel/types" "^7.13.0"
@@ -71,14 +71,14 @@
 
 "@babel/helper-annotate-as-pure@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz#0f58e86dfc4bb3b1fcd7db806570e177d439b6ab"
+  resolved "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz"
   integrity sha512-7YXfX5wQ5aYM/BOlbSccHDbuXXFPxeoUmfWtz8le2yTkTZc+BxsiEnENFoi2SlmA8ewDkG2LgIMIVzzn2h8kfw==
   dependencies:
     "@babel/types" "^7.12.13"
 
 "@babel/helper-builder-binary-assignment-operator-visitor@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.12.13.tgz#6bc20361c88b0a74d05137a65cac8d3cbf6f61fc"
+  resolved "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.12.13.tgz"
   integrity sha512-CZOv9tGphhDRlVjVkAgm8Nhklm9RzSmWpX2my+t7Ua/KT616pEzXsQCjinzvkRvHWJ9itO4f296efroX23XCMA==
   dependencies:
     "@babel/helper-explode-assignable-expression" "^7.12.13"
@@ -86,7 +86,7 @@
 
 "@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.10", "@babel/helper-compilation-targets@^7.13.13", "@babel/helper-compilation-targets@^7.13.8":
   version "7.13.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.13.tgz#2b2972a0926474853f41e4adbc69338f520600e5"
+  resolved "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.13.tgz"
   integrity sha512-q1kcdHNZehBwD9jYPh3WyXcsFERi39X4I59I3NadciWtNDyZ6x+GboOxncFK0kXlKIv6BJm5acncehXWUjWQMQ==
   dependencies:
     "@babel/compat-data" "^7.13.12"
@@ -96,7 +96,7 @@
 
 "@babel/helper-create-class-features-plugin@^7.13.0":
   version "7.13.11"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.11.tgz#30d30a005bca2c953f5653fc25091a492177f4f6"
+  resolved "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.11.tgz"
   integrity sha512-ays0I7XYq9xbjCSvT+EvysLgfc3tOkwCULHjrnscGT3A9qD4sk3wXnJ3of0MAWsWGjdinFvajHU2smYuqXKMrw==
   dependencies:
     "@babel/helper-function-name" "^7.12.13"
@@ -107,7 +107,7 @@
 
 "@babel/helper-create-regexp-features-plugin@^7.12.13":
   version "7.12.17"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.12.17.tgz#a2ac87e9e319269ac655b8d4415e94d38d663cb7"
+  resolved "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.12.17.tgz"
   integrity sha512-p2VGmBu9oefLZ2nQpgnEnG0ZlRPvL8gAGvPUMQwUdaE8k49rOMuZpOwdQoy5qJf6K8jL3bcAMhVUlHAjIgJHUg==
   dependencies:
     "@babel/helper-annotate-as-pure" "^7.12.13"
@@ -115,7 +115,7 @@
 
 "@babel/helper-define-polyfill-provider@^0.1.5":
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.1.5.tgz#3c2f91b7971b9fc11fe779c945c014065dea340e"
+  resolved "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.1.5.tgz"
   integrity sha512-nXuzCSwlJ/WKr8qxzW816gwyT6VZgiJG17zR40fou70yfAcqjoNyTLl/DQ+FExw5Hx5KNqshmN8Ldl/r2N7cTg==
   dependencies:
     "@babel/helper-compilation-targets" "^7.13.0"
@@ -129,14 +129,14 @@
 
 "@babel/helper-explode-assignable-expression@^7.12.13":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.13.0.tgz#17b5c59ff473d9f956f40ef570cf3a76ca12657f"
+  resolved "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.13.0.tgz"
   integrity sha512-qS0peLTDP8kOisG1blKbaoBg/o9OSa1qoumMjTK5pM+KDTtpxpsiubnCGP34vK8BXGcb2M9eigwgvoJryrzwWA==
   dependencies:
     "@babel/types" "^7.13.0"
 
 "@babel/helper-function-name@^7.1.0":
   version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.1.0.tgz#a0ceb01685f73355d4360c1247f582bfafc8ff53"
+  resolved "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.1.0.tgz"
   integrity sha512-A95XEoCpb3TO+KZzJ4S/5uW5fNe26DjBGqf1o9ucyLyCmi1dXq/B3c8iaWTfBk3VvetUxl16e8tIrd5teOCfGw==
   dependencies:
     "@babel/helper-get-function-arity" "^7.0.0"
@@ -145,7 +145,7 @@
 
 "@babel/helper-function-name@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz#93ad656db3c3c2232559fd7b2c3dbdcbe0eb377a"
+  resolved "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz"
   integrity sha512-TZvmPn0UOqmvi5G4vvw0qZTpVptGkB1GL61R6lKvrSdIxGm5Pky7Q3fpKiIkQCAtRCBUwB0PaThlx9vebCDSwA==
   dependencies:
     "@babel/helper-get-function-arity" "^7.12.13"
@@ -154,21 +154,21 @@
 
 "@babel/helper-get-function-arity@^7.0.0":
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0.tgz#83572d4320e2a4657263734113c42868b64e49c3"
+  resolved "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0.tgz"
   integrity sha512-r2DbJeg4svYvt3HOS74U4eWKsUAMRH01Z1ds1zx8KNTPtpTL5JAsdFv8BNyOpVqdFhHkkRDIg5B4AsxmkjAlmQ==
   dependencies:
     "@babel/types" "^7.0.0"
 
 "@babel/helper-get-function-arity@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz#bc63451d403a3b3082b97e1d8b3fe5bd4091e583"
+  resolved "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz"
   integrity sha512-DjEVzQNz5LICkzN0REdpD5prGoidvbdYk1BVgRUOINaWJP2t6avB27X1guXK1kXNrX0WMfsrm1A/ZBthYuIMQg==
   dependencies:
     "@babel/types" "^7.12.13"
 
 "@babel/helper-hoist-variables@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.0.tgz#5d5882e855b5c5eda91e0cadc26c6e7a2c8593d8"
+  resolved "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.0.tgz"
   integrity sha512-0kBzvXiIKfsCA0y6cFEIJf4OdzfpRuNk4+YTeHZpGGc666SATFKTz6sRncwFnQk7/ugJ4dSrCj6iJuvW4Qwr2g==
   dependencies:
     "@babel/traverse" "^7.13.0"
@@ -176,21 +176,21 @@
 
 "@babel/helper-member-expression-to-functions@^7.13.0", "@babel/helper-member-expression-to-functions@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.12.tgz#dfe368f26d426a07299d8d6513821768216e6d72"
+  resolved "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.12.tgz"
   integrity sha512-48ql1CLL59aKbU94Y88Xgb2VFy7a95ykGRbJJaaVv+LX5U8wFpLfiGXJJGUozsmA1oEh/o5Bp60Voq7ACyA/Sw==
   dependencies:
     "@babel/types" "^7.13.12"
 
 "@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz#c6a369a6f3621cb25da014078684da9196b61977"
+  resolved "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz"
   integrity sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==
   dependencies:
     "@babel/types" "^7.13.12"
 
 "@babel/helper-module-transforms@^7.13.0", "@babel/helper-module-transforms@^7.13.14":
   version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.13.14.tgz#e600652ba48ccb1641775413cb32cfa4e8b495ef"
+  resolved "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.13.14.tgz"
   integrity sha512-QuU/OJ0iAOSIatyVZmfqB0lbkVP0kDRiKj34xy+QNsnVZi/PA6BoSoreeqnxxa9EHFAIL0R9XOaAR/G9WlIy5g==
   dependencies:
     "@babel/helper-module-imports" "^7.13.12"
@@ -204,19 +204,19 @@
 
 "@babel/helper-optimise-call-expression@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz#5c02d171b4c8615b1e7163f888c1c81c30a2aaea"
+  resolved "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz"
   integrity sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==
   dependencies:
     "@babel/types" "^7.12.13"
 
 "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz#806526ce125aed03373bc416a828321e3a6a33af"
+  resolved "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz"
   integrity sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==
 
 "@babel/helper-remap-async-to-generator@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.13.0.tgz#376a760d9f7b4b2077a9dd05aa9c3927cadb2209"
+  resolved "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.13.0.tgz"
   integrity sha512-pUQpFBE9JvC9lrQbpX0TmeNIy5s7GnZjna2lhhcHC7DzgBs6fWn722Y5cfwgrtrqc7NAJwMvOa0mKhq6XaE4jg==
   dependencies:
     "@babel/helper-annotate-as-pure" "^7.12.13"
@@ -225,7 +225,7 @@
 
 "@babel/helper-replace-supers@^7.12.13", "@babel/helper-replace-supers@^7.13.0", "@babel/helper-replace-supers@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.13.12.tgz#6442f4c1ad912502481a564a7386de0c77ff3804"
+  resolved "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.13.12.tgz"
   integrity sha512-Gz1eiX+4yDO8mT+heB94aLVNCL+rbuT2xy4YfyNqu8F+OI6vMvJK891qGBTqL9Uc8wxEvRW92Id6G7sDen3fFw==
   dependencies:
     "@babel/helper-member-expression-to-functions" "^7.13.12"
@@ -235,45 +235,45 @@
 
 "@babel/helper-simple-access@^7.12.13", "@babel/helper-simple-access@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz#dd6c538afb61819d205a012c31792a39c7a5eaf6"
+  resolved "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz"
   integrity sha512-7FEjbrx5SL9cWvXioDbnlYTppcZGuCY6ow3/D5vMggb2Ywgu4dMrpTJX0JdQAIcRRUElOIxF3yEooa9gUb9ZbA==
   dependencies:
     "@babel/types" "^7.13.12"
 
 "@babel/helper-skip-transparent-expression-wrappers@^7.12.1":
   version "7.12.1"
-  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz#462dc63a7e435ade8468385c63d2b84cce4b3cbf"
+  resolved "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz"
   integrity sha512-Mf5AUuhG1/OCChOJ/HcADmvcHM42WJockombn8ATJG3OnyiSxBK/Mm5x78BQWvmtXZKHgbjdGL2kin/HOLlZGA==
   dependencies:
     "@babel/types" "^7.12.1"
 
 "@babel/helper-split-export-declaration@^7.0.0":
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0.tgz#3aae285c0311c2ab095d997b8c9a94cad547d813"
+  resolved "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0.tgz"
   integrity sha512-MXkOJqva62dfC0w85mEf/LucPPS/1+04nmmRMPEBUB++hiiThQ2zPtX/mEWQ3mtzCEjIJvPY8nuwxXtQeQwUag==
   dependencies:
     "@babel/types" "^7.0.0"
 
 "@babel/helper-split-export-declaration@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz#e9430be00baf3e88b0e13e6f9d4eaf2136372b05"
+  resolved "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz"
   integrity sha512-tCJDltF83htUtXx5NLcaDqRmknv652ZWCHyoTETf1CXYJdPC7nohZohjUgieXhv0hTJdRf2FjDueFehdNucpzg==
   dependencies:
     "@babel/types" "^7.12.13"
 
 "@babel/helper-validator-identifier@^7.12.11":
   version "7.12.11"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz#c9a1f021917dcb5ccf0d4e453e399022981fc9ed"
+  resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz"
   integrity sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==
 
 "@babel/helper-validator-option@^7.12.17":
   version "7.12.17"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz#d1fbf012e1a79b7eebbfdc6d270baaf8d9eb9831"
+  resolved "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz"
   integrity sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==
 
 "@babel/helper-wrap-function@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.13.0.tgz#bdb5c66fda8526ec235ab894ad53a1235c79fcc4"
+  resolved "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.13.0.tgz"
   integrity sha512-1UX9F7K3BS42fI6qd2A4BjKzgGjToscyZTdp1DjknHLCIvpgne6918io+aL5LXFcER/8QWiwpoY902pVEqgTXA==
   dependencies:
     "@babel/helper-function-name" "^7.12.13"
@@ -283,7 +283,7 @@
 
 "@babel/helpers@^7.13.10":
   version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.13.10.tgz#fd8e2ba7488533cdeac45cc158e9ebca5e3c7df8"
+  resolved "https://registry.npmjs.org/@babel/helpers/-/helpers-7.13.10.tgz"
   integrity sha512-4VO883+MWPDUVRF3PhiLBUFHoX/bsLTGFpFK/HqvvfBZz2D57u9XzPVNFVBTc0PW/CWR9BXTOKt8NF4DInUHcQ==
   dependencies:
     "@babel/template" "^7.12.13"
@@ -292,7 +292,7 @@
 
 "@babel/highlight@^7.0.0":
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.0.0.tgz#f710c38c8d458e6dd9a201afb637fcb781ce99e4"
+  resolved "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0.tgz"
   integrity sha512-UFMC4ZeFC48Tpvj7C8UgLvtkaUuovQX+5xNWrsIoMG8o2z+XFKjKaN9iVmS84dPwVN00W4wPmqvYoZF3EGAsfw==
   dependencies:
     chalk "^2.0.0"
@@ -301,7 +301,7 @@
 
 "@babel/highlight@^7.10.4", "@babel/highlight@^7.12.13":
   version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.13.10.tgz#a8b2a66148f5b27d666b15d81774347a731d52d1"
+  resolved "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.10.tgz"
   integrity sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==
   dependencies:
     "@babel/helper-validator-identifier" "^7.12.11"
@@ -310,17 +310,17 @@
 
 "@babel/parser@^7.0.0", "@babel/parser@^7.2.2", "@babel/parser@^7.2.3":
   version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.2.3.tgz#32f5df65744b70888d17872ec106b02434ba1489"
+  resolved "https://registry.npmjs.org/@babel/parser/-/parser-7.2.3.tgz"
   integrity sha512-0LyEcVlfCoFmci8mXx8A5oIkpkOgyo8dRHtxBnK9RRBwxO2+JZPNsqtVEZQ7mJFPxnXF9lfmU24mHOPI0qnlkA==
 
 "@babel/parser@^7.12.13", "@babel/parser@^7.13.13":
   version "7.13.13"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.13.tgz#42f03862f4aed50461e543270916b47dd501f0df"
+  resolved "https://registry.npmjs.org/@babel/parser/-/parser-7.13.13.tgz"
   integrity sha512-OhsyMrqygfk5v8HmWwOzlYjJrtLaFhF34MrfG/Z73DgYCI6ojNUTUp2TYbtnjo8PegeJp12eamsNettCQjKjVw==
 
 "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.13.12.tgz#a3484d84d0b549f3fc916b99ee4783f26fabad2a"
+  resolved "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.13.12.tgz"
   integrity sha512-d0u3zWKcoZf379fOeJdr1a5WPDny4aOFZ6hlfKivgK0LY7ZxNfoaHL2fWwdGtHyVvra38FC+HVYkO+byfSA8AQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -329,7 +329,7 @@
 
 "@babel/plugin-proposal-async-generator-functions@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.13.8.tgz#87aacb574b3bc4b5603f6fe41458d72a5a2ec4b1"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.13.8.tgz"
   integrity sha512-rPBnhj+WgoSmgq+4gQUtXx/vOcU+UYtjy1AA/aeD61Hwj410fwYyqfUcRP3lR8ucgliVJL/G7sXcNUecC75IXA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -338,7 +338,7 @@
 
 "@babel/plugin-proposal-class-properties@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz#146376000b94efd001e57a40a88a525afaab9f37"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz"
   integrity sha512-KnTDjFNC1g+45ka0myZNvSBFLhNCLN+GeGYLDEA8Oq7MZ6yMgfLoIRh86GRT0FjtJhZw8JyUskP9uvj5pHM9Zg==
   dependencies:
     "@babel/helper-create-class-features-plugin" "^7.13.0"
@@ -346,7 +346,7 @@
 
 "@babel/plugin-proposal-dynamic-import@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.13.8.tgz#876a1f6966e1dec332e8c9451afda3bebcdf2e1d"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.13.8.tgz"
   integrity sha512-ONWKj0H6+wIRCkZi9zSbZtE/r73uOhMVHh256ys0UzfM7I3d4n+spZNWjOnJv2gzopumP2Wxi186vI8N0Y2JyQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -354,7 +354,7 @@
 
 "@babel/plugin-proposal-export-namespace-from@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.12.13.tgz#393be47a4acd03fa2af6e3cde9b06e33de1b446d"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.12.13.tgz"
   integrity sha512-INAgtFo4OnLN3Y/j0VwAgw3HDXcDtX+C/erMvWzuV9v71r7urb6iyMXu7eM9IgLr1ElLlOkaHjJ0SbCmdOQ3Iw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
@@ -362,7 +362,7 @@
 
 "@babel/plugin-proposal-json-strings@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.13.8.tgz#bf1fb362547075afda3634ed31571c5901afef7b"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.13.8.tgz"
   integrity sha512-w4zOPKUFPX1mgvTmL/fcEqy34hrQ1CRcGxdphBc6snDnnqJ47EZDIyop6IwXzAC8G916hsIuXB2ZMBCExC5k7Q==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -370,7 +370,7 @@
 
 "@babel/plugin-proposal-logical-assignment-operators@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.13.8.tgz#93fa78d63857c40ce3c8c3315220fd00bfbb4e1a"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.13.8.tgz"
   integrity sha512-aul6znYB4N4HGweImqKn59Su9RS8lbUIqxtXTOcAGtNIDczoEFv+l1EhmX8rUBp3G1jMjKJm8m0jXVp63ZpS4A==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -378,7 +378,7 @@
 
 "@babel/plugin-proposal-nullish-coalescing-operator@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.13.8.tgz#3730a31dafd3c10d8ccd10648ed80a2ac5472ef3"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.13.8.tgz"
   integrity sha512-iePlDPBn//UhxExyS9KyeYU7RM9WScAG+D3Hhno0PLJebAEpDZMocbDe64eqynhNAnwz/vZoL/q/QB2T1OH39A==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -386,7 +386,7 @@
 
 "@babel/plugin-proposal-numeric-separator@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.12.13.tgz#bd9da3188e787b5120b4f9d465a8261ce67ed1db"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.12.13.tgz"
   integrity sha512-O1jFia9R8BUCl3ZGB7eitaAPu62TXJRHn7rh+ojNERCFyqRwJMTmhz+tJ+k0CwI6CLjX/ee4qW74FSqlq9I35w==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
@@ -394,7 +394,7 @@
 
 "@babel/plugin-proposal-object-rest-spread@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz#5d210a4d727d6ce3b18f9de82cc99a3964eed60a"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz"
   integrity sha512-DhB2EuB1Ih7S3/IRX5AFVgZ16k3EzfRbq97CxAVI1KSYcW+lexV8VZb7G7L8zuPVSdQMRn0kiBpf/Yzu9ZKH0g==
   dependencies:
     "@babel/compat-data" "^7.13.8"
@@ -405,7 +405,7 @@
 
 "@babel/plugin-proposal-optional-catch-binding@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.13.8.tgz#3ad6bd5901506ea996fc31bdcf3ccfa2bed71107"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.13.8.tgz"
   integrity sha512-0wS/4DUF1CuTmGo+NiaHfHcVSeSLj5S3e6RivPTg/2k3wOv3jO35tZ6/ZWsQhQMvdgI7CwphjQa/ccarLymHVA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -413,7 +413,7 @@
 
 "@babel/plugin-proposal-optional-chaining@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.13.12.tgz#ba9feb601d422e0adea6760c2bd6bbb7bfec4866"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.13.12.tgz"
   integrity sha512-fcEdKOkIB7Tf4IxrgEVeFC4zeJSTr78no9wTdBuZZbqF64kzllU0ybo2zrzm7gUQfxGhBgq4E39oRs8Zx/RMYQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -422,7 +422,7 @@
 
 "@babel/plugin-proposal-private-methods@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.13.0.tgz#04bd4c6d40f6e6bbfa2f57e2d8094bad900ef787"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.13.0.tgz"
   integrity sha512-MXyyKQd9inhx1kDYPkFRVOBXQ20ES8Pto3T7UZ92xj2mY0EVD8oAVzeyYuVfy/mxAdTSIayOvg+aVzcHV2bn6Q==
   dependencies:
     "@babel/helper-create-class-features-plugin" "^7.13.0"
@@ -430,7 +430,7 @@
 
 "@babel/plugin-proposal-unicode-property-regex@^7.12.13", "@babel/plugin-proposal-unicode-property-regex@^7.4.4":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.12.13.tgz#bebde51339be829c17aaaaced18641deb62b39ba"
+  resolved "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.12.13.tgz"
   integrity sha512-XyJmZidNfofEkqFV5VC/bLabGmO5QzenPO/YOfGuEbgU+2sSwMmio3YLb4WtBgcmmdwZHyVyv8on77IUjQ5Gvg==
   dependencies:
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
@@ -438,112 +438,112 @@
 
 "@babel/plugin-syntax-async-generators@^7.8.4":
   version "7.8.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz"
   integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-class-properties@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz"
   integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-syntax-dynamic-import@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz#62bf98b2da3cd21d626154fc96ee5b3cb68eacb3"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz"
   integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-export-namespace-from@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz#028964a9ba80dbc094c915c487ad7c4e7a66465a"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz"
   integrity sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.3"
 
 "@babel/plugin-syntax-flow@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.12.13.tgz#5df9962503c0a9c918381c929d51d4d6949e7e86"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.12.13.tgz"
   integrity sha512-J/RYxnlSLXZLVR7wTRsozxKT8qbsx1mNKJzXEEjQ0Kjx1ZACcyHgbanNWNCFtc36IzuWhYWPpvJFFoexoOWFmA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-syntax-json-strings@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz"
   integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-jsx@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.13.tgz#044fb81ebad6698fe62c478875575bcbb9b70f15"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.13.tgz"
   integrity sha512-d4HM23Q1K7oq/SLNmG6mRt85l2csmQ0cHRaxRXjKW0YFdEXqlZ5kzFQKH5Uc3rDJECgu+yCRgPkG04Mm98R/1g==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-syntax-logical-assignment-operators@^7.10.4":
   version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz"
   integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==
   dependencies:
     "@babel/helper-plugin-utils" "^7.10.4"
 
 "@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz"
   integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-numeric-separator@^7.10.4":
   version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz"
   integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==
   dependencies:
     "@babel/helper-plugin-utils" "^7.10.4"
 
 "@babel/plugin-syntax-object-rest-spread@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz"
   integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-optional-catch-binding@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz"
   integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-optional-chaining@^7.8.3":
   version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz"
   integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
 "@babel/plugin-syntax-top-level-await@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz#c5f0fa6e249f5b739727f923540cf7a806130178"
+  resolved "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz"
   integrity sha512-A81F9pDwyS7yM//KwbCSDqy3Uj4NMIurtplxphWxoYtNPov7cJsDkAFNNyVlIZ3jwGycVsurZ+LtOA8gZ376iQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-arrow-functions@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz#10a59bebad52d637a027afa692e8d5ceff5e3dae"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz"
   integrity sha512-96lgJagobeVmazXFaDrbmCLQxBysKu7U6Do3mLsx27gf5Dk85ezysrs2BZUpXD703U/Su1xTBDxxar2oa4jAGg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-async-to-generator@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.13.0.tgz#8e112bf6771b82bf1e974e5e26806c5c99aa516f"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.13.0.tgz"
   integrity sha512-3j6E004Dx0K3eGmhxVJxwwI89CTJrce7lg3UrtFuDAVQ/2+SJ/h/aSFOeE6/n0WB1GsOffsJp6MnPQNQ8nmwhg==
   dependencies:
     "@babel/helper-module-imports" "^7.12.13"
@@ -552,21 +552,21 @@
 
 "@babel/plugin-transform-block-scoped-functions@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz#a9bf1836f2a39b4eb6cf09967739de29ea4bf4c4"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz"
   integrity sha512-zNyFqbc3kI/fVpqwfqkg6RvBgFpC4J18aKKMmv7KdQ/1GgREapSJAykLMVNwfRGO3BtHj3YQZl8kxCXPcVMVeg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-block-scoping@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.12.13.tgz#f36e55076d06f41dfd78557ea039c1b581642e61"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.12.13.tgz"
   integrity sha512-Pxwe0iqWJX4fOOM2kEZeUuAxHMWb9nK+9oh5d11bsLoB0xMg+mkDpt0eYuDZB7ETrY9bbcVlKUGTOGWy7BHsMQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-classes@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz#0265155075c42918bf4d3a4053134176ad9b533b"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz"
   integrity sha512-9BtHCPUARyVH1oXGcSJD3YpsqRLROJx5ZNP6tN5vnk17N0SVf9WCtf8Nuh1CFmgByKKAIMstitKduoCmsaDK5g==
   dependencies:
     "@babel/helper-annotate-as-pure" "^7.12.13"
@@ -579,21 +579,21 @@
 
 "@babel/plugin-transform-computed-properties@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz#845c6e8b9bb55376b1fa0b92ef0bdc8ea06644ed"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz"
   integrity sha512-RRqTYTeZkZAz8WbieLTvKUEUxZlUTdmL5KGMyZj7FnMfLNKV4+r5549aORG/mgojRmFlQMJDUupwAMiF2Q7OUg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-destructuring@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.0.tgz#c5dce270014d4e1ebb1d806116694c12b7028963"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.0.tgz"
   integrity sha512-zym5em7tePoNT9s964c0/KU3JPPnuq7VhIxPRefJ4/s82cD+q1mgKfuGRDMCPL0HTyKz4dISuQlCusfgCJ86HA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-dotall-regex@^7.12.13", "@babel/plugin-transform-dotall-regex@^7.4.4":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.12.13.tgz#3f1601cc29905bfcb67f53910f197aeafebb25ad"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.12.13.tgz"
   integrity sha512-foDrozE65ZFdUC2OfgeOCrEPTxdB3yjqxpXh8CH+ipd9CHd4s/iq81kcUpyH8ACGNEPdFqbtzfgzbT/ZGlbDeQ==
   dependencies:
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
@@ -601,14 +601,14 @@
 
 "@babel/plugin-transform-duplicate-keys@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.12.13.tgz#6f06b87a8b803fd928e54b81c258f0a0033904de"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.12.13.tgz"
   integrity sha512-NfADJiiHdhLBW3pulJlJI2NB0t4cci4WTZ8FtdIuNc2+8pslXdPtRRAEWqUY+m9kNOk2eRYbTAOipAxlrOcwwQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-exponentiation-operator@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.12.13.tgz#4d52390b9a273e651e4aba6aee49ef40e80cd0a1"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.12.13.tgz"
   integrity sha512-fbUelkM1apvqez/yYx1/oICVnGo2KM5s63mhGylrmXUxK/IAXSIf87QIxVfZldWf4QsOafY6vV3bX8aMHSvNrA==
   dependencies:
     "@babel/helper-builder-binary-assignment-operator-visitor" "^7.12.13"
@@ -616,7 +616,7 @@
 
 "@babel/plugin-transform-flow-strip-types@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.13.0.tgz#58177a48c209971e8234e99906cb6bd1122addd3"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.13.0.tgz"
   integrity sha512-EXAGFMJgSX8gxWD7PZtW/P6M+z74jpx3wm/+9pn+c2dOawPpBkUX7BrfyPvo6ZpXbgRIEuwgwDb/MGlKvu2pOg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -624,14 +624,14 @@
 
 "@babel/plugin-transform-for-of@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz#c799f881a8091ac26b54867a845c3e97d2696062"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz"
   integrity sha512-IHKT00mwUVYE0zzbkDgNRP6SRzvfGCYsOxIRz8KsiaaHCcT9BWIkO+H9QRJseHBLOGBZkHUdHiqj6r0POsdytg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-function-name@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz#bb024452f9aaed861d374c8e7a24252ce3a50051"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz"
   integrity sha512-6K7gZycG0cmIwwF7uMK/ZqeCikCGVBdyP2J5SKNCXO5EOHcqi+z7Jwf8AmyDNcBgxET8DrEtCt/mPKPyAzXyqQ==
   dependencies:
     "@babel/helper-function-name" "^7.12.13"
@@ -639,21 +639,21 @@
 
 "@babel/plugin-transform-literals@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz#2ca45bafe4a820197cf315794a4d26560fe4bdb9"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz"
   integrity sha512-FW+WPjSR7hiUxMcKqyNjP05tQ2kmBCdpEpZHY1ARm96tGQCCBvXKnpjILtDplUnJ/eHZ0lALLM+d2lMFSpYJrQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-member-expression-literals@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz#5ffa66cd59b9e191314c9f1f803b938e8c081e40"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz"
   integrity sha512-kxLkOsg8yir4YeEPHLuO2tXP9R/gTjpuTOjshqSpELUN3ZAg2jfDnKUvzzJxObun38sw3wm4Uu69sX/zA7iRvg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-modules-amd@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.13.0.tgz#19f511d60e3d8753cc5a6d4e775d3a5184866cc3"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.13.0.tgz"
   integrity sha512-EKy/E2NHhY/6Vw5d1k3rgoobftcNUmp9fGjb9XZwQLtTctsRBOTRO7RHHxfIky1ogMN5BxN7p9uMA3SzPfotMQ==
   dependencies:
     "@babel/helper-module-transforms" "^7.13.0"
@@ -662,7 +662,7 @@
 
 "@babel/plugin-transform-modules-commonjs@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz#7b01ad7c2dcf2275b06fa1781e00d13d420b3e1b"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz"
   integrity sha512-9QiOx4MEGglfYZ4XOnU79OHr6vIWUakIj9b4mioN8eQIoEh+pf5p/zEB36JpDFWA12nNMiRf7bfoRvl9Rn79Bw==
   dependencies:
     "@babel/helper-module-transforms" "^7.13.0"
@@ -672,7 +672,7 @@
 
 "@babel/plugin-transform-modules-systemjs@^7.13.8":
   version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.13.8.tgz#6d066ee2bff3c7b3d60bf28dec169ad993831ae3"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.13.8.tgz"
   integrity sha512-hwqctPYjhM6cWvVIlOIe27jCIBgHCsdH2xCJVAYQm7V5yTMoilbVMi9f6wKg0rpQAOn6ZG4AOyvCqFF/hUh6+A==
   dependencies:
     "@babel/helper-hoist-variables" "^7.13.0"
@@ -683,7 +683,7 @@
 
 "@babel/plugin-transform-modules-umd@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.13.0.tgz#8a3d96a97d199705b9fd021580082af81c06e70b"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.13.0.tgz"
   integrity sha512-D/ILzAh6uyvkWjKKyFE/W0FzWwasv6vPTSqPcjxFqn6QpX3u8DjRVliq4F2BamO2Wee/om06Vyy+vPkNrd4wxw==
   dependencies:
     "@babel/helper-module-transforms" "^7.13.0"
@@ -691,21 +691,21 @@
 
 "@babel/plugin-transform-named-capturing-groups-regex@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.12.13.tgz#2213725a5f5bbbe364b50c3ba5998c9599c5c9d9"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.12.13.tgz"
   integrity sha512-Xsm8P2hr5hAxyYblrfACXpQKdQbx4m2df9/ZZSQ8MAhsadw06+jW7s9zsSw6he+mJZXRlVMyEnVktJo4zjk1WA==
   dependencies:
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
 
 "@babel/plugin-transform-new-target@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.12.13.tgz#e22d8c3af24b150dd528cbd6e685e799bf1c351c"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.12.13.tgz"
   integrity sha512-/KY2hbLxrG5GTQ9zzZSc3xWiOy379pIETEhbtzwZcw9rvuaVV4Fqy7BYGYOWZnaoXIQYbbJ0ziXLa/sKcGCYEQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-object-super@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz#b4416a2d63b8f7be314f3d349bd55a9c1b5171f7"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz"
   integrity sha512-JzYIcj3XtYspZDV8j9ulnoMPZZnF/Cj0LUxPOjR89BdBVx+zYJI9MdMIlUZjbXDX+6YVeS6I3e8op+qQ3BYBoQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
@@ -713,42 +713,42 @@
 
 "@babel/plugin-transform-parameters@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz#8fa7603e3097f9c0b7ca1a4821bc2fb52e9e5007"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz"
   integrity sha512-Jt8k/h/mIwE2JFEOb3lURoY5C85ETcYPnbuAJ96zRBzh1XHtQZfs62ChZ6EP22QlC8c7Xqr9q+e1SU5qttwwjw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-property-literals@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz#4e6a9e37864d8f1b3bc0e2dce7bf8857db8b1a81"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz"
   integrity sha512-nqVigwVan+lR+g8Fj8Exl0UQX2kymtjcWfMOYM1vTYEKujeyv2SkMgazf2qNcK7l4SDiKyTA/nHCPqL4e2zo1A==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-regenerator@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.12.13.tgz#b628bcc9c85260ac1aeb05b45bde25210194a2f5"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.12.13.tgz"
   integrity sha512-lxb2ZAvSLyJ2PEe47hoGWPmW22v7CtSl9jW8mingV4H2sEX/JOcrAj2nPuGWi56ERUm2bUpjKzONAuT6HCn2EA==
   dependencies:
     regenerator-transform "^0.14.2"
 
 "@babel/plugin-transform-reserved-words@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.12.13.tgz#7d9988d4f06e0fe697ea1d9803188aa18b472695"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.12.13.tgz"
   integrity sha512-xhUPzDXxZN1QfiOy/I5tyye+TRz6lA7z6xaT4CLOjPRMVg1ldRf0LHw0TDBpYL4vG78556WuHdyO9oi5UmzZBg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-shorthand-properties@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz#db755732b70c539d504c6390d9ce90fe64aff7ad"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz"
   integrity sha512-xpL49pqPnLtf0tVluuqvzWIgLEhuPpZzvs2yabUHSKRNlN7ScYU7aMlmavOeyXJZKgZKQRBlh8rHbKiJDraTSw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-spread@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz#84887710e273c1815ace7ae459f6f42a5d31d5fd"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz"
   integrity sha512-V6vkiXijjzYeFmQTr3dBxPtZYLPcUfY34DebOU27jIl2M/Y8Egm52Hw82CSjjPqd54GTlJs5x+CR7HeNr24ckg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
@@ -756,35 +756,35 @@
 
 "@babel/plugin-transform-sticky-regex@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.12.13.tgz#760ffd936face73f860ae646fb86ee82f3d06d1f"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.12.13.tgz"
   integrity sha512-Jc3JSaaWT8+fr7GRvQP02fKDsYk4K/lYwWq38r/UGfaxo89ajud321NH28KRQ7xy1Ybc0VUE5Pz8psjNNDUglg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-template-literals@^7.13.0":
   version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz#a36049127977ad94438dee7443598d1cefdf409d"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz"
   integrity sha512-d67umW6nlfmr1iehCcBv69eSUSySk1EsIS8aTDX4Xo9qajAh6mYtcl4kJrBkGXuxZPEgVr7RVfAvNW6YQkd4Mw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.13.0"
 
 "@babel/plugin-transform-typeof-symbol@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.12.13.tgz#785dd67a1f2ea579d9c2be722de8c84cb85f5a7f"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.12.13.tgz"
   integrity sha512-eKv/LmUJpMnu4npgfvs3LiHhJua5fo/CysENxa45YCQXZwKnGCQKAg87bvoqSW1fFT+HA32l03Qxsm8ouTY3ZQ==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-unicode-escapes@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.12.13.tgz#840ced3b816d3b5127dd1d12dcedc5dead1a5e74"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.12.13.tgz"
   integrity sha512-0bHEkdwJ/sN/ikBHfSmOXPypN/beiGqjo+o4/5K+vxEFNPRPdImhviPakMKG4x96l85emoa0Z6cDflsdBusZbw==
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
 "@babel/plugin-transform-unicode-regex@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.12.13.tgz#b52521685804e155b1202e83fc188d34bb70f5ac"
+  resolved "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.12.13.tgz"
   integrity sha512-mDRzSNY7/zopwisPZ5kM9XKCfhchqIYwAKRERtEnhYscZB79VRekuRSoYbN0+KVe3y8+q1h6A4svXtP7N+UoCA==
   dependencies:
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
@@ -792,7 +792,7 @@
 
 "@babel/preset-env@^7.13.12":
   version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.13.12.tgz#6dff470478290582ac282fb77780eadf32480237"
+  resolved "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.13.12.tgz"
   integrity sha512-JzElc6jk3Ko6zuZgBtjOd01pf9yYDEIH8BcqVuYIuOkzOwDesoa/Nz4gIo4lBG6K861KTV9TvIgmFuT6ytOaAA==
   dependencies:
     "@babel/compat-data" "^7.13.12"
@@ -867,7 +867,7 @@
 
 "@babel/preset-modules@^0.1.4":
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.4.tgz#362f2b68c662842970fdb5e254ffc8fc1c2e415e"
+  resolved "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.4.tgz"
   integrity sha512-J36NhwnfdzpmH41M1DrnkkgAqhZaqr/NBdPfQ677mLzlaXo+oDiv1deyCDtgAhz8p328otdob0Du7+xgHGZbKg==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
@@ -878,7 +878,7 @@
 
 "@babel/register@^7.13.14":
   version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.13.14.tgz#bbfa8f4f027c2ebc432e8e69e078b632605f2d9b"
+  resolved "https://registry.npmjs.org/@babel/register/-/register-7.13.14.tgz"
   integrity sha512-iyw0hUwjh/fzN8qklVqZodbyWjEBOG0KdDnBOpv3zzIgK3NmuRXBmIXH39ZBdspkn8LTHvSboN+oYb4MT43+9Q==
   dependencies:
     find-cache-dir "^2.0.0"
@@ -889,14 +889,14 @@
 
 "@babel/runtime@^7.8.4":
   version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.13.10.tgz#47d42a57b6095f4468da440388fdbad8bebf0d7d"
+  resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.13.10.tgz"
   integrity sha512-4QPkjJq6Ns3V/RgpEahRk+AGfL0eO6RHHtTWoNNr5mO49G6B5+X6d6THgWEAvTrznU5xYpbAlVKRYcsCgh/Akw==
   dependencies:
     regenerator-runtime "^0.13.4"
 
 "@babel/template@^7.0.0", "@babel/template@^7.1.0":
   version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.2.2.tgz#005b3fdf0ed96e88041330379e0da9a708eb2907"
+  resolved "https://registry.npmjs.org/@babel/template/-/template-7.2.2.tgz"
   integrity sha512-zRL0IMM02AUDwghf5LMSSDEz7sBCO2YnNmpg3uWTZj/v1rcG2BmQUvaGU8GhU8BvfMh1k2KIAYZ7Ji9KXPUg7g==
   dependencies:
     "@babel/code-frame" "^7.0.0"
@@ -905,7 +905,7 @@
 
 "@babel/template@^7.12.13":
   version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.12.13.tgz#530265be8a2589dbb37523844c5bcb55947fb327"
+  resolved "https://registry.npmjs.org/@babel/template/-/template-7.12.13.tgz"
   integrity sha512-/7xxiGA57xMo/P2GVvdEumr8ONhFOhfgq2ihK3h1e6THqzTAkHbkXgB0xI9yeTfIUoH3+oAeHhqm/I43OTbbjA==
   dependencies:
     "@babel/code-frame" "^7.12.13"
@@ -914,7 +914,7 @@
 
 "@babel/traverse@^7.0.0":
   version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.2.3.tgz#7ff50cefa9c7c0bd2d81231fdac122f3957748d8"
+  resolved "https://registry.npmjs.org/@babel/traverse/-/traverse-7.2.3.tgz"
   integrity sha512-Z31oUD/fJvEWVR0lNZtfgvVt512ForCTNKYcJBGbPb1QZfve4WGH8Wsy7+Mev33/45fhP/hwQtvgusNdcCMgSw==
   dependencies:
     "@babel/code-frame" "^7.0.0"
@@ -929,7 +929,7 @@
 
 "@babel/traverse@^7.13.0", "@babel/traverse@^7.13.13":
   version "7.13.13"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.13.13.tgz#39aa9c21aab69f74d948a486dd28a2dbdbf5114d"
+  resolved "https://registry.npmjs.org/@babel/traverse/-/traverse-7.13.13.tgz"
   integrity sha512-CblEcwmXKR6eP43oQGG++0QMTtCjAsa3frUuzHoiIJWpaIIi8dwMyEFUJoXRLxagGqCK+jALRwIO+o3R9p/uUg==
   dependencies:
     "@babel/code-frame" "^7.12.13"
@@ -943,7 +943,7 @@
 
 "@babel/types@^7.0.0", "@babel/types@^7.2.2":
   version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.2.2.tgz#44e10fc24e33af524488b716cdaee5360ea8ed1e"
+  resolved "https://registry.npmjs.org/@babel/types/-/types-7.2.2.tgz"
   integrity sha512-fKCuD6UFUMkR541eDWL+2ih/xFZBXPOg/7EQFeTluMDebfqR4jrpaCjLhkWlQS4hT6nRa2PMEgXKbRB5/H2fpg==
   dependencies:
     esutils "^2.0.2"
@@ -952,7 +952,7 @@
 
 "@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.13.13", "@babel/types@^7.13.14", "@babel/types@^7.4.4":
   version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.14.tgz#c35a4abb15c7cd45a2746d78ab328e362cbace0d"
+  resolved "https://registry.npmjs.org/@babel/types/-/types-7.13.14.tgz"
   integrity sha512-A2aa3QTkWoyqsZZFl56MLUsfmh7O0gN41IPvXAE/++8ojpbz12SszD7JEGYVdn4f9Kt4amIei07swF1h4AqmmQ==
   dependencies:
     "@babel/helper-validator-identifier" "^7.12.11"
@@ -961,7 +961,7 @@
 
 "@eslint/eslintrc@^0.4.0":
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.0.tgz#99cc0a0584d72f1df38b900fb062ba995f395547"
+  resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-0.4.0.tgz"
   integrity sha512-2ZPCc+uNbjV5ERJr+aKSPRwZgKd2z11x0EgLvb1PURmUrn9QNRXFqje0Ldq454PfAVyaJYyrDvvIKSFP4NnBog==
   dependencies:
     ajv "^6.12.4"
@@ -976,7 +976,7 @@
 
 "@iamstarkov/listr-update-renderer@0.4.1":
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/@iamstarkov/listr-update-renderer/-/listr-update-renderer-0.4.1.tgz#d7c48092a2dcf90fd672b6c8b458649cb350c77e"
+  resolved "https://registry.npmjs.org/@iamstarkov/listr-update-renderer/-/listr-update-renderer-0.4.1.tgz"
   integrity sha512-IJyxQWsYDEkf8C8QthBn5N8tIUR9V9je6j3sMIpAkonaadjbvxmRC6RAhpa3RKxndhNnU2M6iNbtJwd7usQYIA==
   dependencies:
     chalk "^1.1.3"
@@ -988,9 +988,24 @@
     log-update "^2.3.0"
     strip-ansi "^3.0.1"
 
+"@mapbox/node-pre-gyp@1.0.9":
+  version "1.0.9"
+  resolved "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.9.tgz"
+  integrity sha512-aDF3S3rK9Q2gey/WAttUlISduDItz5BU3306M9Eyv6/oS40aMprnopshtlKTykxRNIBEZuRMaZAnbrQ4QtKGyw==
+  dependencies:
+    detect-libc "^2.0.0"
+    https-proxy-agent "^5.0.0"
+    make-dir "^3.1.0"
+    node-fetch "^2.6.7"
+    nopt "^5.0.0"
+    npmlog "^5.0.1"
+    rimraf "^3.0.2"
+    semver "^7.3.5"
+    tar "^6.1.11"
+
 "@nodelib/fs.scandir@2.1.4":
   version "2.1.4"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69"
+  resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz"
   integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==
   dependencies:
     "@nodelib/fs.stat" "2.0.4"
@@ -998,12 +1013,12 @@
 
 "@nodelib/fs.stat@2.0.4", "@nodelib/fs.stat@^2.0.2":
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz#a3f2dd61bab43b8db8fa108a121cfffe4c676655"
+  resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.4.tgz"
   integrity sha512-IYlHJA0clt2+Vg7bccq+TzRdJvv19c2INqBSsoOLp1je7xjtr7J26+WXR72MCdvU9q1qTzIWDfhMf+DRvQJK4Q==
 
 "@nodelib/fs.walk@^1.2.3":
   version "1.2.6"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz#cce9396b30aa5afe9e3756608f5831adcb53d063"
+  resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.6.tgz"
   integrity sha512-8Broas6vTtW4GIXTAHDoE32hnN2M5ykgCpWGbuXHQ15vEMqr23pB76e/GZcYsZCHALv50ktd24qhEyKr6wBtow==
   dependencies:
     "@nodelib/fs.scandir" "2.1.4"
@@ -1011,14 +1026,14 @@
 
 "@rollup/plugin-alias@^3.1.2":
   version "3.1.2"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-3.1.2.tgz#c585b05be4a7782d269c69d13def56f44e417772"
+  resolved "https://registry.npmjs.org/@rollup/plugin-alias/-/plugin-alias-3.1.2.tgz"
   integrity sha512-wzDnQ6v7CcoRzS0qVwFPrFdYA4Qlr+ookA217Y2Z3DPZE1R8jrFNM3jvGgOf6o6DMjbnQIn5lCIJgHPe1Bt3uw==
   dependencies:
     slash "^3.0.0"
 
 "@rollup/plugin-buble@^0.21.3":
   version "0.21.3"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-buble/-/plugin-buble-0.21.3.tgz#1649a915b1d051a4f430d40e7734a7f67a69b33e"
+  resolved "https://registry.npmjs.org/@rollup/plugin-buble/-/plugin-buble-0.21.3.tgz"
   integrity sha512-Iv8cCuFPnMdqV4pcyU+OrfjOfagPArRQ1PyQjx5KgHk3dARedI+8PNTLSMpJts0lQJr8yF2pAU4GxpxCBJ9HYw==
   dependencies:
     "@rollup/pluginutils" "^3.0.8"
@@ -1027,7 +1042,7 @@
 
 "@rollup/plugin-commonjs@^18.0.0":
   version "18.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-18.0.0.tgz#50dc7518b5aa9e66a270e529ea85115d269825c4"
+  resolved "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-18.0.0.tgz"
   integrity sha512-fj92shhg8luw7XbA0HowAqz90oo7qtLGwqTKbyZ8pmOyH8ui5e+u0wPEgeHLH3djcVma6gUCUrjY6w5R2o1u6g==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
@@ -1040,7 +1055,7 @@
 
 "@rollup/plugin-node-resolve@^11.2.1":
   version "11.2.1"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz#82aa59397a29cd4e13248b106e6a4a1880362a60"
+  resolved "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz"
   integrity sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
@@ -1052,7 +1067,7 @@
 
 "@rollup/plugin-replace@^2.4.2":
   version "2.4.2"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-replace/-/plugin-replace-2.4.2.tgz#a2d539314fbc77c244858faa523012825068510a"
+  resolved "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-2.4.2.tgz"
   integrity sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
@@ -1060,7 +1075,7 @@
 
 "@rollup/pluginutils@^3.0.8", "@rollup/pluginutils@^3.1.0":
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-3.1.0.tgz#706b4524ee6dc8b103b3c995533e5ad680c02b9b"
+  resolved "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz"
   integrity sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==
   dependencies:
     "@types/estree" "0.0.39"
@@ -1069,7 +1084,7 @@
 
 "@rollup/pluginutils@^4.1.0":
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.1.0.tgz#0dcc61c780e39257554feb7f77207dceca13c838"
+  resolved "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-4.1.0.tgz"
   integrity sha512-TrBhfJkFxA+ER+ew2U2/fHbebhLT/l/2pRk0hfj9KusXUuRXd2v0R58AfaZK9VXDQ4TogOSEmICVrQAA3zFnHQ==
   dependencies:
     estree-walker "^2.0.1"
@@ -1077,75 +1092,80 @@
 
 "@samverschueren/stream-to-observable@^0.3.0":
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz#ecdf48d532c58ea477acfcab80348424f8d0662f"
+  resolved "https://registry.npmjs.org/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz"
   integrity sha512-MI4Xx6LHs4Webyvi6EbspgyAb4D2Q2VtnCQ1blOJcoLS6mVa8lNN2rkIy1CVxfTUpoyIbCTkXES1rLXztFD1lg==
   dependencies:
     any-observable "^0.3.0"
 
+"@testim/chrome-version@^1.0.7":
+  version "1.1.2"
+  resolved "https://registry.npmjs.org/@testim/chrome-version/-/chrome-version-1.1.2.tgz"
+  integrity sha512-1c4ZOETSRpI0iBfIFUqU4KqwBAB2lHUAlBjZz/YqOHqwM9dTTzjV6Km0ZkiEiSCx/tLr1BtESIKyWWMww+RUqw==
+
 "@types/anymatch@*":
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/@types/anymatch/-/anymatch-1.3.0.tgz#d1d55958d1fccc5527d4aba29fc9c4b942f563ff"
+  resolved "https://registry.npmjs.org/@types/anymatch/-/anymatch-1.3.0.tgz"
   integrity sha512-7WcbyctkE8GTzogDb0ulRAEw7v8oIS54ft9mQTU7PfM0hp5e+8kpa+HeQ7IQrFbKtJXBKcZ4bh+Em9dTw5L6AQ==
 
 "@types/buble@^0.19.2":
   version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@types/buble/-/buble-0.19.2.tgz#a4289d20b175b3c206aaad80caabdabe3ecdfdd1"
+  resolved "https://registry.npmjs.org/@types/buble/-/buble-0.19.2.tgz"
   integrity sha512-uUD8zIfXMKThmFkahTXDGI3CthFH1kMg2dOm3KLi4GlC5cbARA64bEcUMbbWdWdE73eoc/iBB9PiTMqH0dNS2Q==
   dependencies:
     magic-string "^0.25.0"
 
 "@types/estree@*":
   version "0.0.47"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.47.tgz#d7a51db20f0650efec24cd04994f523d93172ed4"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-0.0.47.tgz"
   integrity sha512-c5ciR06jK8u9BstrmJyO97m+klJrrhCf9u3rLu3DEAJBirxRqSCvDQoYKmxuYwQI5SZChAWu+tq9oVlGRuzPAg==
 
 "@types/estree@0.0.39":
   version "0.0.39"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
+  resolved "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz"
   integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
 
 "@types/he@^1.1.1":
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/@types/he/-/he-1.1.1.tgz#19e14033c4ee8f1a702c74dcc6182664839ac2b7"
+  resolved "https://registry.npmjs.org/@types/he/-/he-1.1.1.tgz"
   integrity sha512-jpzrsR1ns0n3kyWt92QfOUQhIuJGQ9+QGa7M62rO6toe98woQjnsnzjdMtsQXCdvjjmqjS2ZBCC7xKw0cdzU+Q==
 
 "@types/json-schema@^7.0.3":
   version "7.0.7"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"
+  resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.7.tgz"
   integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==
 
 "@types/node@*":
   version "14.14.37"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.37.tgz#a3dd8da4eb84a996c36e331df98d82abd76b516e"
+  resolved "https://registry.npmjs.org/@types/node/-/node-14.14.37.tgz"
   integrity sha512-XYmBiy+ohOR4Lh5jE379fV2IU+6Jn4g5qASinhitfyO71b/sCo6MKsMLF5tc7Zf2CE8hViVQyYSobJNke8OvUw==
 
 "@types/node@^12.12.0":
   version "12.12.0"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-12.12.0.tgz#ff3201972d6dc851a9275308a17b9b5094e68057"
+  resolved "https://registry.npmjs.org/@types/node/-/node-12.12.0.tgz"
   integrity sha512-6N8Sa5AaENRtJnpKXZgvc119PKxT1Lk9VPy4kfT8JF23tIe1qDfaGkBR2DRKJFIA7NptMz+fps//C6aLi1Uoug==
 
 "@types/resolve@1.17.1":
   version "1.17.1"
-  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.17.1.tgz#3afd6ad8967c77e4376c598a82ddd58f46ec45d6"
+  resolved "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz"
   integrity sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==
   dependencies:
     "@types/node" "*"
 
 "@types/tapable@*":
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/@types/tapable/-/tapable-1.0.4.tgz#b4ffc7dc97b498c969b360a41eee247f82616370"
+  resolved "https://registry.npmjs.org/@types/tapable/-/tapable-1.0.4.tgz"
   integrity sha512-78AdXtlhpCHT0K3EytMpn4JNxaf5tbqbLcbIRoQIHzpTIyjpxLQKRoxU55ujBXAtg3Nl2h/XWvfDa9dsMOd0pQ==
 
 "@types/uglify-js@*":
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/@types/uglify-js/-/uglify-js-3.0.4.tgz#96beae23df6f561862a830b4288a49e86baac082"
+  resolved "https://registry.npmjs.org/@types/uglify-js/-/uglify-js-3.0.4.tgz"
   integrity sha512-SudIN9TRJ+v8g5pTG8RRCqfqTMNqgWCKKd3vtynhGzkIIjxaicNAMuY5TRadJ6tzDu3Dotf3ngaMILtmOdmWEQ==
   dependencies:
     source-map "^0.6.1"
 
 "@types/webpack@^4.4.22":
   version "4.4.22"
-  resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-4.4.22.tgz#c4a5ea8b74a31b579537515bcfe86d2b2a34382c"
+  resolved "https://registry.npmjs.org/@types/webpack/-/webpack-4.4.22.tgz"
   integrity sha512-PxAAzli3krZX9rCeONSR5Z9v4CR/2HPsKsiVRFNDo9OZefN+dTemteMHZnYkddOu4bqoYqJTJ724gLy0ZySXOw==
   dependencies:
     "@types/anymatch" "*"
@@ -1154,9 +1174,16 @@
     "@types/uglify-js" "*"
     source-map "^0.6.0"
 
+"@types/yauzl@^2.9.1":
+  version "2.10.0"
+  resolved "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.0.tgz"
+  integrity sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==
+  dependencies:
+    "@types/node" "*"
+
 "@typescript-eslint/eslint-plugin@^4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.21.0.tgz#3fce2bfa76d95c00ac4f33dff369cb593aab8878"
+  resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.21.0.tgz"
   integrity sha512-FPUyCPKZbVGexmbCFI3EQHzCZdy2/5f+jv6k2EDljGdXSRc0cKvbndd2nHZkSLqCNOPk0jB6lGzwIkglXcYVsQ==
   dependencies:
     "@typescript-eslint/experimental-utils" "4.21.0"
@@ -1170,7 +1197,7 @@
 
 "@typescript-eslint/experimental-utils@4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.21.0.tgz#0b0bb7c15d379140a660c003bdbafa71ae9134b6"
+  resolved "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-4.21.0.tgz"
   integrity sha512-cEbgosW/tUFvKmkg3cU7LBoZhvUs+ZPVM9alb25XvR0dal4qHL3SiUqHNrzoWSxaXA9gsifrYrS1xdDV6w/gIA==
   dependencies:
     "@types/json-schema" "^7.0.3"
@@ -1182,7 +1209,7 @@
 
 "@typescript-eslint/parser@^4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.21.0.tgz#a227fc2af4001668c3e3f7415d4feee5093894c1"
+  resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-4.21.0.tgz"
   integrity sha512-eyNf7QmE5O/l1smaQgN0Lj2M/1jOuNg2NrBm1dqqQN0sVngTLyw8tdCbih96ixlhbF1oINoN8fDCyEH9SjLeIA==
   dependencies:
     "@typescript-eslint/scope-manager" "4.21.0"
@@ -1192,7 +1219,7 @@
 
 "@typescript-eslint/scope-manager@4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.21.0.tgz#c81b661c4b8af1ec0c010d847a8f9ab76ab95b4d"
+  resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-4.21.0.tgz"
   integrity sha512-kfOjF0w1Ix7+a5T1knOw00f7uAP9Gx44+OEsNQi0PvvTPLYeXJlsCJ4tYnDj5PQEYfpcgOH5yBlw7K+UEI9Agw==
   dependencies:
     "@typescript-eslint/types" "4.21.0"
@@ -1200,12 +1227,12 @@
 
 "@typescript-eslint/types@4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.21.0.tgz#abdc3463bda5d31156984fa5bc316789c960edef"
+  resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-4.21.0.tgz"
   integrity sha512-+OQaupjGVVc8iXbt6M1oZMwyKQNehAfLYJJ3SdvnofK2qcjfor9pEM62rVjBknhowTkh+2HF+/KdRAc/wGBN2w==
 
 "@typescript-eslint/typescript-estree@4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.21.0.tgz#3817bd91857beeaeff90f69f1f112ea58d350b0a"
+  resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-4.21.0.tgz"
   integrity sha512-ZD3M7yLaVGVYLw4nkkoGKumb7Rog7QID9YOWobFDMQKNl+vPxqVIW/uDk+MDeGc+OHcoG2nJ2HphwiPNajKw3w==
   dependencies:
     "@typescript-eslint/types" "4.21.0"
@@ -1218,7 +1245,7 @@
 
 "@typescript-eslint/visitor-keys@4.21.0":
   version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.21.0.tgz#990a9acdc124331f5863c2cf21c88ba65233cd8d"
+  resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-4.21.0.tgz"
   integrity sha512-dH22dROWGi5Z6p+Igc8bLVLmwy7vEe8r+8c+raPQU0LxgogPUrRAtRGtvBWmlr9waTu3n+QLt/qrS/hWzk1x5w==
   dependencies:
     "@typescript-eslint/types" "4.21.0"
@@ -1226,7 +1253,7 @@
 
 "@webassemblyjs/ast@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.7.11.tgz#b988582cafbb2b095e8b556526f30c90d057cace"
+  resolved "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.7.11.tgz"
   integrity sha512-ZEzy4vjvTzScC+SH8RBssQUawpaInUdMTYwYYLh54/s8TuT0gBLuyUnppKsVyZEi876VmmStKsUs28UxPgdvrA==
   dependencies:
     "@webassemblyjs/helper-module-context" "1.7.11"
@@ -1235,44 +1262,44 @@
 
 "@webassemblyjs/floating-point-hex-parser@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.7.11.tgz#a69f0af6502eb9a3c045555b1a6129d3d3f2e313"
+  resolved "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.7.11.tgz"
   integrity sha512-zY8dSNyYcgzNRNT666/zOoAyImshm3ycKdoLsyDw/Bwo6+/uktb7p4xyApuef1dwEBo/U/SYQzbGBvV+nru2Xg==
 
 "@webassemblyjs/helper-api-error@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.7.11.tgz#c7b6bb8105f84039511a2b39ce494f193818a32a"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.7.11.tgz"
   integrity sha512-7r1qXLmiglC+wPNkGuXCvkmalyEstKVwcueZRP2GNC2PAvxbLYwLLPr14rcdJaE4UtHxQKfFkuDFuv91ipqvXg==
 
 "@webassemblyjs/helper-buffer@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.7.11.tgz#3122d48dcc6c9456ed982debe16c8f37101df39b"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.7.11.tgz"
   integrity sha512-MynuervdylPPh3ix+mKZloTcL06P8tenNH3sx6s0qE8SLR6DdwnfgA7Hc9NSYeob2jrW5Vql6GVlsQzKQCa13w==
 
 "@webassemblyjs/helper-code-frame@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-code-frame/-/helper-code-frame-1.7.11.tgz#cf8f106e746662a0da29bdef635fcd3d1248364b"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-code-frame/-/helper-code-frame-1.7.11.tgz"
   integrity sha512-T8ESC9KMXFTXA5urJcyor5cn6qWeZ4/zLPyWeEXZ03hj/x9weSokGNkVCdnhSabKGYWxElSdgJ+sFa9G/RdHNw==
   dependencies:
     "@webassemblyjs/wast-printer" "1.7.11"
 
 "@webassemblyjs/helper-fsm@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-fsm/-/helper-fsm-1.7.11.tgz#df38882a624080d03f7503f93e3f17ac5ac01181"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-fsm/-/helper-fsm-1.7.11.tgz"
   integrity sha512-nsAQWNP1+8Z6tkzdYlXT0kxfa2Z1tRTARd8wYnc/e3Zv3VydVVnaeePgqUzFrpkGUyhUUxOl5ML7f1NuT+gC0A==
 
 "@webassemblyjs/helper-module-context@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-module-context/-/helper-module-context-1.7.11.tgz#d874d722e51e62ac202476935d649c802fa0e209"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-module-context/-/helper-module-context-1.7.11.tgz"
   integrity sha512-JxfD5DX8Ygq4PvXDucq0M+sbUFA7BJAv/GGl9ITovqE+idGX+J3QSzJYz+LwQmL7fC3Rs+utvWoJxDb6pmC0qg==
 
 "@webassemblyjs/helper-wasm-bytecode@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.7.11.tgz#dd9a1e817f1c2eb105b4cf1013093cb9f3c9cb06"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.7.11.tgz"
   integrity sha512-cMXeVS9rhoXsI9LLL4tJxBgVD/KMOKXuFqYb5oCJ/opScWpkCMEz9EJtkonaNcnLv2R3K5jIeS4TRj/drde1JQ==
 
 "@webassemblyjs/helper-wasm-section@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.7.11.tgz#9c9ac41ecf9fbcfffc96f6d2675e2de33811e68a"
+  resolved "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.7.11.tgz"
   integrity sha512-8ZRY5iZbZdtNFE5UFunB8mmBEAbSI3guwbrsCl4fWdfRiAcvqQpeqd5KHhSWLL5wuxo53zcaGZDBU64qgn4I4Q==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1282,26 +1309,26 @@
 
 "@webassemblyjs/ieee754@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.7.11.tgz#c95839eb63757a31880aaec7b6512d4191ac640b"
+  resolved "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.7.11.tgz"
   integrity sha512-Mmqx/cS68K1tSrvRLtaV/Lp3NZWzXtOHUW2IvDvl2sihAwJh4ACE0eL6A8FvMyDG9abes3saB6dMimLOs+HMoQ==
   dependencies:
     "@xtuc/ieee754" "^1.2.0"
 
 "@webassemblyjs/leb128@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.7.11.tgz#d7267a1ee9c4594fd3f7e37298818ec65687db63"
+  resolved "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.7.11.tgz"
   integrity sha512-vuGmgZjjp3zjcerQg+JA+tGOncOnJLWVkt8Aze5eWQLwTQGNgVLcyOTqgSCxWTR4J42ijHbBxnuRaL1Rv7XMdw==
   dependencies:
     "@xtuc/long" "4.2.1"
 
 "@webassemblyjs/utf8@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.7.11.tgz#06d7218ea9fdc94a6793aa92208160db3d26ee82"
+  resolved "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.7.11.tgz"
   integrity sha512-C6GFkc7aErQIAH+BMrIdVSmW+6HSe20wg57HEC1uqJP8E/xpMjXqQUxkQw07MhNDSDcGpxI9G5JSNOQCqJk4sA==
 
 "@webassemblyjs/wasm-edit@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.7.11.tgz#8c74ca474d4f951d01dbae9bd70814ee22a82005"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.7.11.tgz"
   integrity sha512-FUd97guNGsCZQgeTPKdgxJhBXkUbMTY6hFPf2Y4OedXd48H97J+sOY2Ltaq6WGVpIH8o/TGOVNiVz/SbpEMJGg==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1315,7 +1342,7 @@
 
 "@webassemblyjs/wasm-gen@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.7.11.tgz#9bbba942f22375686a6fb759afcd7ac9c45da1a8"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.7.11.tgz"
   integrity sha512-U/KDYp7fgAZX5KPfq4NOupK/BmhDc5Kjy2GIqstMhvvdJRcER/kUsMThpWeRP8BMn4LXaKhSTggIJPOeYHwISA==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1326,7 +1353,7 @@
 
 "@webassemblyjs/wasm-opt@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.7.11.tgz#b331e8e7cef8f8e2f007d42c3a36a0580a7d6ca7"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.7.11.tgz"
   integrity sha512-XynkOwQyiRidh0GLua7SkeHvAPXQV/RxsUeERILmAInZegApOUAIJfRuPYe2F7RcjOC9tW3Cb9juPvAC/sCqvg==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1336,7 +1363,7 @@
 
 "@webassemblyjs/wasm-parser@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.7.11.tgz#6e3d20fa6a3519f6b084ef9391ad58211efb0a1a"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.7.11.tgz"
   integrity sha512-6lmXRTrrZjYD8Ng8xRyvyXQJYUQKYSXhJqXOBLw24rdiXsHAOlvw5PhesjdcaMadU/pyPQOJ5dHreMjBxwnQKg==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1348,7 +1375,7 @@
 
 "@webassemblyjs/wast-parser@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-parser/-/wast-parser-1.7.11.tgz#25bd117562ca8c002720ff8116ef9072d9ca869c"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wast-parser/-/wast-parser-1.7.11.tgz"
   integrity sha512-lEyVCg2np15tS+dm7+JJTNhNWq9yTZvi3qEhAIIOaofcYlUp0UR5/tVqOwa/gXYr3gjwSZqw+/lS9dscyLelbQ==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1360,7 +1387,7 @@
 
 "@webassemblyjs/wast-printer@1.7.11":
   version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.7.11.tgz#c4245b6de242cb50a2cc950174fdbf65c78d7813"
+  resolved "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.7.11.tgz"
   integrity sha512-m5vkAsuJ32QpkdkDOUPGSltrg8Cuk3KBx4YrmAGQwCZPRdUHXxG4phIOuuycLemHFr74sWL9Wthqss4fzdzSwg==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -1369,17 +1396,17 @@
 
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
+  resolved "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz"
   integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
 
 "@xtuc/long@4.2.1":
   version "4.2.1"
-  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.1.tgz#5c85d662f76fa1d34575766c5dcd6615abcd30d8"
+  resolved "https://registry.npmjs.org/@xtuc/long/-/long-4.2.1.tgz"
   integrity sha512-FZdkNBDqBRHKQ2MEbSC17xnPFOhZxeJ2YGSfr2BKf3sujG49Qe3bB+rGCwQfIaA7WHnGeGkSijX4FuBCdrzW/g==
 
 JSONStream@^1.0.4:
   version "1.3.5"
-  resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
+  resolved "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz"
   integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
   dependencies:
     jsonparse "^1.2.0"
@@ -1387,17 +1414,17 @@ JSONStream@^1.0.4:
 
 abbrev@1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
+  resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz"
   integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
 
 abbrev@1.0.x:
   version "1.0.9"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.0.9.tgz#91b4792588a7738c25f35dd6f63752a2f8776135"
+  resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz"
   integrity sha1-kbR5JYinc4wl813W9jdSovh3YTU=
 
 accepts@~1.3.4:
   version "1.3.5"
-  resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.5.tgz#eb777df6011723a3b14e8a72c0805c8e86746bd2"
+  resolved "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz"
   integrity sha1-63d99gEXI6OxTopywIBcjoZ0a9I=
   dependencies:
     mime-types "~2.1.18"
@@ -1405,84 +1432,99 @@ accepts@~1.3.4:
 
 acorn-dynamic-import@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz#901ceee4c7faaef7e07ad2a47e890675da50a278"
+  resolved "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz"
   integrity sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==
   dependencies:
     acorn "^5.0.0"
 
 acorn-dynamic-import@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz#482210140582a36b83c3e342e1cfebcaa9240948"
+  resolved "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz"
   integrity sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==
 
 acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
   version "5.3.1"
-  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
+  resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.1.tgz"
   integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==
 
 acorn-walk@^8.0.2:
   version "8.0.2"
-  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.0.2.tgz#d4632bfc63fd93d0f15fd05ea0e984ffd3f5a8c3"
+  resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.0.2.tgz"
   integrity sha512-+bpA9MJsHdZ4bgfDcpk0ozQyhhVct7rzOmO0s1IIr0AGGgKBljss8n2zp11rRP2wid5VGeh04CgeKzgat5/25A==
 
 acorn@^5.0.0, acorn@^5.6.2:
   version "5.7.3"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.3.tgz#67aa231bf8812974b85235a96771eb6bd07ea279"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-5.7.3.tgz"
   integrity sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==
 
 acorn@^6.4.1:
   version "6.4.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-6.4.2.tgz"
   integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
 
 acorn@^7.4.0:
   version "7.4.1"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz"
   integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
 
 acorn@^8.1.0:
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.1.0.tgz#52311fd7037ae119cbb134309e901aa46295b3fe"
+  resolved "https://registry.npmjs.org/acorn/-/acorn-8.1.0.tgz"
   integrity sha512-LWCF/Wn0nfHOmJ9rzQApGnxnvgfROzGilS8936rqN/lfcYkY9MYZzdMqN+2NJ4SlTc+m5HiSa+kNfDtI64dwUA==
 
 adm-zip@~0.4.3:
   version "0.4.13"
-  resolved "https://registry.yarnpkg.com/adm-zip/-/adm-zip-0.4.13.tgz#597e2f8cc3672151e1307d3e95cddbc75672314a"
+  resolved "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.13.tgz"
   integrity sha512-fERNJX8sOXfel6qCBCMPvZLzENBEhZTzKqg6vrOW5pvoEaQuJhRU4ndTAh6lHOxn1I6jnz2NHra56ZODM751uw==
 
 after@0.8.2:
   version "0.8.2"
-  resolved "https://registry.yarnpkg.com/after/-/after-0.8.2.tgz#fedb394f9f0e02aa9768e702bda23b505fae7e1f"
+  resolved "https://registry.npmjs.org/after/-/after-0.8.2.tgz"
   integrity sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8=
 
 agent-base@2:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-2.1.1.tgz#d6de10d5af6132d5bd692427d46fc538539094c7"
+  resolved "https://registry.npmjs.org/agent-base/-/agent-base-2.1.1.tgz"
   integrity sha1-1t4Q1a9hMtW9aSQn1G/FOFOQlMc=
   dependencies:
     extend "~3.0.0"
     semver "~5.0.1"
 
+agent-base@6:
+  version "6.0.2"
+  resolved "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz"
+  integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==
+  dependencies:
+    debug "4"
+
 agent-base@^4.1.0:
   version "4.2.1"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-4.2.1.tgz#d89e5999f797875674c07d87f260fc41e83e8ca9"
+  resolved "https://registry.npmjs.org/agent-base/-/agent-base-4.2.1.tgz"
   integrity sha512-JVwXMr9nHYTUXsBFKUqhJwvlcYU/blreOEUkhNR2eXZIvwd+c+o5V4MgDPKWnMS/56awN3TRzIP+KoPn+roQtg==
   dependencies:
     es6-promisify "^5.0.0"
 
+aggregate-error@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz"
+  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
+  dependencies:
+    clean-stack "^2.0.0"
+    indent-string "^4.0.0"
+
 ajv-errors@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ajv-errors/-/ajv-errors-1.0.1.tgz#f35986aceb91afadec4102fbd85014950cefa64d"
+  resolved "https://registry.npmjs.org/ajv-errors/-/ajv-errors-1.0.1.tgz"
   integrity sha512-DCRfO/4nQ+89p/RK43i8Ezd41EqdGIU4ld7nGF8OQ14oc/we5rEntLCUa7+jrn3nn83BosfwZA0wb4pon2o8iQ==
 
 ajv-keywords@^3.1.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.2.0.tgz#e86b819c602cf8821ad637413698f1dec021847a"
+  resolved "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.2.0.tgz"
   integrity sha1-6GuBnGAs+IIa1jdBNpjx3sAhhHo=
 
 ajv@^6.1.0, ajv@^6.5.5:
   version "6.6.2"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.6.2.tgz#caceccf474bf3fc3ce3b147443711a24063cc30d"
+  resolved "https://registry.npmjs.org/ajv/-/ajv-6.6.2.tgz"
   integrity sha512-FBHEW6Jf5TB9MGBgUUA9XHkTbjXYfAUjY43ACMfmdMRHniyoMHjHjzD50OK8LGDWQwp4rWEsIq5kEqq7rvIM1g==
   dependencies:
     fast-deep-equal "^2.0.1"
@@ -1492,7 +1534,7 @@ ajv@^6.1.0, ajv@^6.5.5:
 
 ajv@^6.10.0, ajv@^6.12.4:
   version "6.12.6"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
+  resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
   dependencies:
     fast-deep-equal "^3.1.1"
@@ -1502,7 +1544,7 @@ ajv@^6.10.0, ajv@^6.12.4:
 
 ajv@^8.0.1:
   version "8.0.5"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.0.5.tgz#f07d6fdeffcdbb80485570ce3f1bc845fcc812b9"
+  resolved "https://registry.npmjs.org/ajv/-/ajv-8.0.5.tgz"
   integrity sha512-RkiLa/AeJx7+9OvniQ/qeWu0w74A8DiPPBclQ6ji3ZQkv5KamO+QGpqmi7O4JIw3rHGUXZ6CoP9tsAkn3gyazg==
   dependencies:
     fast-deep-equal "^3.1.1"
@@ -1512,183 +1554,201 @@ ajv@^8.0.1:
 
 amdefine@>=0.0.4:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
+  resolved "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz"
   integrity sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=
 
 ansi-colors@^3.0.0:
   version "3.2.3"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.3.tgz#57d35b8686e851e2cc04c403f1c00203976a1813"
+  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz"
   integrity sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==
 
 ansi-colors@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
+  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz"
   integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
 
 ansi-escapes@^1.1.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-1.4.0.tgz#d3a8a83b319aa67793662b13e761c7911422306e"
+  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-1.4.0.tgz"
   integrity sha1-06ioOzGapneTZisT52HHkRQiMG4=
 
 ansi-escapes@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.1.0.tgz#f73207bb81207d75fd6c83f125af26eea378ca30"
+  resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.1.0.tgz"
   integrity sha512-UgAb8H9D41AQnu/PbWlCofQVcnV4Gs2bBJi9eZPxfU/hgglFh3SMDMENRIqdr7H6XFnXdoknctFByVsCOotTVw==
 
 ansi-regex@^2.0.0:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz"
   integrity sha1-w7M6te42DYbg5ijwRorn7yfWVN8=
 
 ansi-regex@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz"
   integrity sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=
 
 ansi-regex@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz"
   integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==
 
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
 ansi-styles@^2.2.1:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz"
   integrity sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=
 
 ansi-styles@^3.2.0, ansi-styles@^3.2.1:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz"
   integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
   dependencies:
     color-convert "^1.9.0"
 
 ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+  resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz"
   integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
   dependencies:
     color-convert "^2.0.1"
 
 any-observable@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/any-observable/-/any-observable-0.3.0.tgz#af933475e5806a67d0d7df090dd5e8bef65d119b"
+  resolved "https://registry.npmjs.org/any-observable/-/any-observable-0.3.0.tgz"
   integrity sha512-/FQM1EDkTsf63Ub2C6O7GuYFDsSXUwsaZDurV0np41ocwq0jthUAYCmhBX9f+KwlaCgIuWyr/4WlUQUBfKfZog==
 
 anymatch@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
+  resolved "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz"
   integrity sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==
   dependencies:
     micromatch "^3.1.4"
     normalize-path "^2.1.1"
 
-aproba@^1.0.3, aproba@^1.1.1:
+anymatch@~3.1.2:
+  version "3.1.2"
+  resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz"
+  integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==
+  dependencies:
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
+
+"aproba@^1.0.3 || ^2.0.0":
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz"
+  integrity sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==
+
+aproba@^1.1.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.2.0.tgz#6802e6264efd18c790a1b0d517f0f2627bf2c94a"
+  resolved "https://registry.npmjs.org/aproba/-/aproba-1.2.0.tgz"
   integrity sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==
 
-are-we-there-yet@~1.1.2:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz#4b35c2944f062a8bfcda66410760350fe9ddfc21"
-  integrity sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==
+are-we-there-yet@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz"
+  integrity sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==
   dependencies:
     delegates "^1.0.0"
-    readable-stream "^2.0.6"
+    readable-stream "^3.6.0"
 
 arg@^4.1.0:
   version "4.1.3"
-  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
+  resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz"
   integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
 
 argparse@^1.0.7:
   version "1.0.10"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
+  resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz"
   integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
   dependencies:
     sprintf-js "~1.0.2"
 
 argv@^0.0.2:
   version "0.0.2"
-  resolved "https://registry.yarnpkg.com/argv/-/argv-0.0.2.tgz#ecbd16f8949b157183711b1bda334f37840185ab"
+  resolved "https://registry.npmjs.org/argv/-/argv-0.0.2.tgz"
   integrity sha1-7L0W+JSbFXGDcRsb2jNPN4QBhas=
 
 arr-diff@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf"
+  resolved "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz"
   integrity sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=
   dependencies:
     arr-flatten "^1.0.1"
 
 arr-diff@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
+  resolved "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz"
   integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=
 
 arr-flatten@^1.0.1, arr-flatten@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
+  resolved "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz"
   integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
 
 arr-union@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
+  resolved "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz"
   integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
 
 array-find-index@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1"
+  resolved "https://registry.npmjs.org/array-find-index/-/array-find-index-1.0.2.tgz"
   integrity sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=
 
 array-ify@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
+  resolved "https://registry.npmjs.org/array-ify/-/array-ify-1.0.0.tgz"
   integrity sha1-nlKHYrSpBmrRY6aWKjZEGOlibs4=
 
 array-slice@^0.2.3:
   version "0.2.3"
-  resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-0.2.3.tgz#dd3cfb80ed7973a75117cdac69b0b99ec86186f5"
+  resolved "https://registry.npmjs.org/array-slice/-/array-slice-0.2.3.tgz"
   integrity sha1-3Tz7gO15c6dRF82sabC5nshhhvU=
 
 array-union@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
+  resolved "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz"
   integrity sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=
   dependencies:
     array-uniq "^1.0.1"
 
 array-union@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
+  resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz"
   integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
 
 array-uniq@^1.0.1:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
+  resolved "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz"
   integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=
 
 array-unique@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53"
+  resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz"
   integrity sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=
 
 array-unique@^0.3.2:
   version "0.3.2"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
+  resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz"
   integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
 
 arraybuffer.slice@~0.0.7:
   version "0.0.7"
-  resolved "https://registry.yarnpkg.com/arraybuffer.slice/-/arraybuffer.slice-0.0.7.tgz#3bbc4275dd584cc1b10809b89d4e8b63a69e7675"
+  resolved "https://registry.npmjs.org/arraybuffer.slice/-/arraybuffer.slice-0.0.7.tgz"
   integrity sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog==
 
 arrify@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
+  resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz"
   integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=
 
 asn1.js@^4.0.0:
   version "4.10.1"
-  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-4.10.1.tgz#b9c2bf5805f1e64aadeed6df3a2bfafb5a73f5a0"
+  resolved "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz"
   integrity sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==
   dependencies:
     bn.js "^4.0.0"
@@ -1697,95 +1757,102 @@ asn1.js@^4.0.0:
 
 asn1@~0.2.3:
   version "0.2.4"
-  resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136"
+  resolved "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz"
   integrity sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==
   dependencies:
     safer-buffer "~2.1.0"
 
 assert-plus@1.0.0, assert-plus@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
+  resolved "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz"
   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 
 assert@^1.1.1:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/assert/-/assert-1.4.1.tgz#99912d591836b5a6f5b345c0f07eefc08fc65d91"
+  resolved "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz"
   integrity sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=
   dependencies:
     util "0.10.3"
 
 assertion-error@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.0.0.tgz#c7f85438fdd466bc7ca16ab90c81513797a5d23b"
+  resolved "https://registry.npmjs.org/assertion-error/-/assertion-error-1.0.0.tgz"
   integrity sha1-x/hUOP3UZrx8oWq5DIFRN5el0js=
 
 assign-symbols@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
+  resolved "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz"
   integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=
 
 ast-types@0.x.x:
   version "0.11.7"
-  resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.11.7.tgz#f318bf44e339db6a320be0009ded64ec1471f46c"
+  resolved "https://registry.npmjs.org/ast-types/-/ast-types-0.11.7.tgz"
   integrity sha512-2mP3TwtkY/aTv5X3ZsMpNAbOnyoC/aMJwJSoaELPkHId0nSQgFcnU4dRW3isxiz7+zBexk0ym3WNVjMiQBnJSw==
 
 astral-regex@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
+  resolved "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz"
   integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
 
 async-each@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.1.tgz#19d386a1d9edc6e7c1c85d388aedbcc56d33602d"
+  resolved "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz"
   integrity sha1-GdOGodntxufByF04iu28xW0zYC0=
 
 async-limiter@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/async-limiter/-/async-limiter-1.0.0.tgz#78faed8c3d074ab81f22b4e985d79e8738f720f8"
+  resolved "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz"
   integrity sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg==
 
 async@1.x:
   version "1.5.2"
-  resolved "https://registry.yarnpkg.com/async/-/async-1.5.2.tgz#ec6a61ae56480c0c3cb241c95618e20892f9672a"
+  resolved "https://registry.npmjs.org/async/-/async-1.5.2.tgz"
   integrity sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=
 
 async@^2.0.0, async@^2.1.2:
   version "2.6.1"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.1.tgz#b245a23ca71930044ec53fa46aa00a3e87c6a610"
+  resolved "https://registry.npmjs.org/async/-/async-2.6.1.tgz"
   integrity sha512-fNEiL2+AZt6AlAw/29Cr0UDe4sRAHCpEHh54WMz+Bb7QfNcFw4h3loofyJpLeQs4Yx7yuqu/2dLgM5hKOs6HlQ==
   dependencies:
     lodash "^4.17.10"
 
 async@^2.6.2:
   version "2.6.3"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.3.tgz#d72625e2344a3656e3a3ad4fa749fa83299d82ff"
+  resolved "https://registry.npmjs.org/async/-/async-2.6.3.tgz"
   integrity sha512-zflvls11DCy+dQWzTW2dzuilv8Z5X/pjfmZOWba6TNIVDm+2UDaJmXSOXlasHKfNBs8oo3M0aT50fDEWfKZjXg==
   dependencies:
     lodash "^4.17.14"
 
 asynckit@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
+  resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz"
   integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
 
 atob@^2.1.1:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
+  resolved "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 
 aws-sign2@~0.7.0:
   version "0.7.0"
-  resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
+  resolved "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz"
   integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=
 
 aws4@^1.8.0:
   version "1.8.0"
-  resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.8.0.tgz#f0e003d9ca9e7f59c7a508945d7b2ef9a04a542f"
+  resolved "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz"
   integrity sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==
 
+axios@^0.21.1:
+  version "0.21.4"
+  resolved "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz"
+  integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==
+  dependencies:
+    follow-redirects "^1.14.0"
+
 babel-code-frame@^6.26.0:
   version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
+  resolved "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz"
   integrity sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=
   dependencies:
     chalk "^1.1.3"
@@ -1794,7 +1861,7 @@ babel-code-frame@^6.26.0:
 
 babel-eslint@^10.0.1:
   version "10.0.1"
-  resolved "https://registry.yarnpkg.com/babel-eslint/-/babel-eslint-10.0.1.tgz#919681dc099614cd7d31d45c8908695092a1faed"
+  resolved "https://registry.npmjs.org/babel-eslint/-/babel-eslint-10.0.1.tgz"
   integrity sha512-z7OT1iNV+TjOwHNLLyJk+HN+YVWX+CLE6fPD2SymJZOZQBs+QIexFjhm4keGTm8MW9xr4EC9Q0PbaLB24V5GoQ==
   dependencies:
     "@babel/code-frame" "^7.0.0"
@@ -1806,7 +1873,7 @@ babel-eslint@^10.0.1:
 
 babel-helper-function-name@^6.24.1:
   version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz#d3475b8c03ed98242a25b48351ab18399d3580a9"
+  resolved "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz"
   integrity sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=
   dependencies:
     babel-helper-get-function-arity "^6.24.1"
@@ -1817,7 +1884,7 @@ babel-helper-function-name@^6.24.1:
 
 babel-helper-get-function-arity@^6.24.1:
   version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz#8f7782aa93407c41d3aa50908f89b031b1b6853d"
+  resolved "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz"
   integrity sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=
   dependencies:
     babel-runtime "^6.22.0"
@@ -1825,12 +1892,12 @@ babel-helper-get-function-arity@^6.24.1:
 
 babel-helper-vue-jsx-merge-props@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/babel-helper-vue-jsx-merge-props/-/babel-helper-vue-jsx-merge-props-2.0.3.tgz#22aebd3b33902328e513293a8e4992b384f9f1b6"
+  resolved "https://registry.npmjs.org/babel-helper-vue-jsx-merge-props/-/babel-helper-vue-jsx-merge-props-2.0.3.tgz"
   integrity sha512-gsLiKK7Qrb7zYJNgiXKpXblxbV5ffSwR0f5whkPAaBAR4fhi6bwRZxX9wBlIc5M/v8CCkXUbXZL4N/nSE97cqg==
 
 babel-loader@^8.0.4:
   version "8.0.5"
-  resolved "https://registry.yarnpkg.com/babel-loader/-/babel-loader-8.0.5.tgz#225322d7509c2157655840bba52e46b6c2f2fe33"
+  resolved "https://registry.npmjs.org/babel-loader/-/babel-loader-8.0.5.tgz"
   integrity sha512-NTnHnVRd2JnRqPC0vW+iOQWU5pchDbYXsG2E6DMXEpMfUcQKclF9gmf3G3ZMhzG7IG9ji4coL0cm+FxeWxDpnw==
   dependencies:
     find-cache-dir "^2.0.0"
@@ -1840,21 +1907,21 @@ babel-loader@^8.0.4:
 
 babel-messages@^6.23.0:
   version "6.23.0"
-  resolved "https://registry.yarnpkg.com/babel-messages/-/babel-messages-6.23.0.tgz#f3cdf4703858035b2a2951c6ec5edf6c62f2630e"
+  resolved "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz"
   integrity sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=
   dependencies:
     babel-runtime "^6.22.0"
 
 babel-plugin-dynamic-import-node@^2.3.3:
   version "2.3.3"
-  resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz#84fda19c976ec5c6defef57f9427b3def66e17a3"
+  resolved "https://registry.npmjs.org/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz"
   integrity sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==
   dependencies:
     object.assign "^4.1.0"
 
 babel-plugin-istanbul@^5.1.0:
   version "5.1.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-5.1.0.tgz#6892f529eff65a3e2d33d87dc5888ffa2ecd4a30"
+  resolved "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-5.1.0.tgz"
   integrity sha512-CLoXPRSUWiR8yao8bShqZUIC6qLfZVVY3X1wj+QPNXu0wfmrRRfarh1LYy+dYMVI+bDj0ghy3tuqFFRFZmL1Nw==
   dependencies:
     find-up "^3.0.0"
@@ -1863,7 +1930,7 @@ babel-plugin-istanbul@^5.1.0:
 
 babel-plugin-polyfill-corejs2@^0.1.4:
   version "0.1.10"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.1.10.tgz#a2c5c245f56c0cac3dbddbf0726a46b24f0f81d1"
+  resolved "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.1.10.tgz"
   integrity sha512-DO95wD4g0A8KRaHKi0D51NdGXzvpqVLnLu5BTvDlpqUEpTmeEtypgC1xqesORaWmiUOQI14UHKlzNd9iZ2G3ZA==
   dependencies:
     "@babel/compat-data" "^7.13.0"
@@ -1872,7 +1939,7 @@ babel-plugin-polyfill-corejs2@^0.1.4:
 
 babel-plugin-polyfill-corejs3@^0.1.3:
   version "0.1.7"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.1.7.tgz#80449d9d6f2274912e05d9e182b54816904befd0"
+  resolved "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.1.7.tgz"
   integrity sha512-u+gbS9bbPhZWEeyy1oR/YaaSpod/KDT07arZHb80aTpl8H5ZBq+uN1nN9/xtX7jQyfLdPfoqI4Rue/MQSWJquw==
   dependencies:
     "@babel/helper-define-polyfill-provider" "^0.1.5"
@@ -1880,24 +1947,24 @@ babel-plugin-polyfill-corejs3@^0.1.3:
 
 babel-plugin-polyfill-regenerator@^0.1.2:
   version "0.1.6"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.1.6.tgz#0fe06a026fe0faa628ccc8ba3302da0a6ce02f3f"
+  resolved "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.1.6.tgz"
   integrity sha512-OUrYG9iKPKz8NxswXbRAdSwF0GhRdIEMTloQATJi4bDuFqrXaXcCUT/VGNrr8pBcjMh1RxZ7Xt9cytVJTJfvMg==
   dependencies:
     "@babel/helper-define-polyfill-provider" "^0.1.5"
 
 babel-plugin-syntax-class-properties@^6.8.0:
   version "6.13.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-syntax-class-properties/-/babel-plugin-syntax-class-properties-6.13.0.tgz#d7eb23b79a317f8543962c505b827c7d6cac27de"
+  resolved "https://registry.npmjs.org/babel-plugin-syntax-class-properties/-/babel-plugin-syntax-class-properties-6.13.0.tgz"
   integrity sha1-1+sjt5oxf4VDlixQW4J8fWysJ94=
 
 babel-plugin-syntax-flow@^6.18.0, babel-plugin-syntax-flow@^6.8.0:
   version "6.18.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz#4c3ab20a2af26aa20cd25995c398c4eb70310c8d"
+  resolved "https://registry.npmjs.org/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz"
   integrity sha1-TDqyCiryaqIM0lmVw5jE63AxDI0=
 
 babel-plugin-transform-class-properties@^6.8.0:
   version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-class-properties/-/babel-plugin-transform-class-properties-6.24.1.tgz#6a79763ea61d33d36f37b611aa9def81a81b46ac"
+  resolved "https://registry.npmjs.org/babel-plugin-transform-class-properties/-/babel-plugin-transform-class-properties-6.24.1.tgz"
   integrity sha1-anl2PqYdM9NvN7YRqp3vgagbRqw=
   dependencies:
     babel-helper-function-name "^6.24.1"
@@ -1907,7 +1974,7 @@ babel-plugin-transform-class-properties@^6.8.0:
 
 babel-plugin-transform-flow-strip-types@^6.8.0:
   version "6.22.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz#84cb672935d43714fdc32bce84568d87441cf7cf"
+  resolved "https://registry.npmjs.org/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz"
   integrity sha1-hMtnKTXUNxT9wyvOhFaNh0Qc988=
   dependencies:
     babel-plugin-syntax-flow "^6.18.0"
@@ -1915,14 +1982,14 @@ babel-plugin-transform-flow-strip-types@^6.8.0:
 
 babel-plugin-transform-vue-jsx@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-vue-jsx/-/babel-plugin-transform-vue-jsx-4.0.1.tgz#2c8bddce87a6ef09eaa59869ff1bfbeeafc5f88d"
+  resolved "https://registry.npmjs.org/babel-plugin-transform-vue-jsx/-/babel-plugin-transform-vue-jsx-4.0.1.tgz"
   integrity sha512-wbOz7ITB5cloLSjKUU1hWn8zhR+Dwah/RZiTiJY/CQliCwhowmzu6m7NEF+y5EJX/blDzGjRtZvC10Vdb3Q7vw==
   dependencies:
     esutils "^2.0.2"
 
 babel-polyfill@6.23.0:
   version "6.23.0"
-  resolved "https://registry.yarnpkg.com/babel-polyfill/-/babel-polyfill-6.23.0.tgz#8364ca62df8eafb830499f699177466c3b03499d"
+  resolved "https://registry.npmjs.org/babel-polyfill/-/babel-polyfill-6.23.0.tgz"
   integrity sha1-g2TKYt+Or7gwSZ9pkXdGbDsDSZ0=
   dependencies:
     babel-runtime "^6.22.0"
@@ -1931,7 +1998,7 @@ babel-polyfill@6.23.0:
 
 babel-preset-flow-vue@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/babel-preset-flow-vue/-/babel-preset-flow-vue-1.0.0.tgz#bd28eb64b53d65f9c47262b32ce6c6033fe70671"
+  resolved "https://registry.npmjs.org/babel-preset-flow-vue/-/babel-preset-flow-vue-1.0.0.tgz"
   integrity sha1-vSjrZLU9ZfnEcmKzLObGAz/nBnE=
   dependencies:
     babel-plugin-syntax-flow "^6.8.0"
@@ -1940,7 +2007,7 @@ babel-preset-flow-vue@^1.0.0:
 
 babel-runtime@^6.22.0, babel-runtime@^6.26.0:
   version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.26.0.tgz#965c7058668e82b55d7bfe04ff2337bc8b5647fe"
+  resolved "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz"
   integrity sha1-llxwWGaOgrVde/4E/yM3vItWR/4=
   dependencies:
     core-js "^2.4.0"
@@ -1948,7 +2015,7 @@ babel-runtime@^6.22.0, babel-runtime@^6.26.0:
 
 babel-template@^6.24.1:
   version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-template/-/babel-template-6.26.0.tgz#de03e2d16396b069f46dd9fff8521fb1a0e35e02"
+  resolved "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz"
   integrity sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=
   dependencies:
     babel-runtime "^6.26.0"
@@ -1959,7 +2026,7 @@ babel-template@^6.24.1:
 
 babel-traverse@^6.24.1, babel-traverse@^6.26.0:
   version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-traverse/-/babel-traverse-6.26.0.tgz#46a9cbd7edcc62c8e5c064e2d2d8d0f4035766ee"
+  resolved "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz"
   integrity sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=
   dependencies:
     babel-code-frame "^6.26.0"
@@ -1974,7 +2041,7 @@ babel-traverse@^6.24.1, babel-traverse@^6.26.0:
 
 babel-types@^6.24.1, babel-types@^6.26.0:
   version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-types/-/babel-types-6.26.0.tgz#a3b073f94ab49eb6fa55cd65227a334380632497"
+  resolved "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz"
   integrity sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=
   dependencies:
     babel-runtime "^6.26.0"
@@ -1984,37 +2051,37 @@ babel-types@^6.24.1, babel-types@^6.26.0:
 
 babylon@^6.18.0:
   version "6.18.0"
-  resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3"
+  resolved "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz"
   integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==
 
 backo2@1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/backo2/-/backo2-1.0.2.tgz#31ab1ac8b129363463e35b3ebb69f4dfcfba7947"
+  resolved "https://registry.npmjs.org/backo2/-/backo2-1.0.2.tgz"
   integrity sha1-MasayLEpNjRj41s+u2n038+6eUc=
 
 balanced-match@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
+  resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz"
   integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c=
 
 base64-arraybuffer@0.1.5:
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz#73926771923b5a19747ad666aa5cd4bf9c6e9ce8"
+  resolved "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz"
   integrity sha1-c5JncZI7Whl0etZmqlzUv5xunOg=
 
 base64-js@^1.0.2:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.3.0.tgz#cab1e6118f051095e58b5281aea8c1cd22bfc0e3"
+  resolved "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz"
   integrity sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==
 
 base64id@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/base64id/-/base64id-1.0.0.tgz#47688cb99bb6804f0e06d3e763b1c32e57d8e6b6"
+  resolved "https://registry.npmjs.org/base64id/-/base64id-1.0.0.tgz"
   integrity sha1-R2iMuZu2gE8OBtPnY7HDLlfY5rY=
 
 base@^0.11.1:
   version "0.11.2"
-  resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
+  resolved "https://registry.npmjs.org/base/-/base-0.11.2.tgz"
   integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==
   dependencies:
     cache-base "^1.0.1"
@@ -2027,51 +2094,63 @@ base@^0.11.1:
 
 basic-auth@^1.0.3:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/basic-auth/-/basic-auth-1.1.0.tgz#45221ee429f7ee1e5035be3f51533f1cdfd29884"
+  resolved "https://registry.npmjs.org/basic-auth/-/basic-auth-1.1.0.tgz"
   integrity sha1-RSIe5Cn37h5QNb4/UVM/HN/SmIQ=
 
 bcrypt-pbkdf@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e"
+  resolved "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz"
   integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=
   dependencies:
     tweetnacl "^0.14.3"
 
 better-assert@~1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/better-assert/-/better-assert-1.0.2.tgz#40866b9e1b9e0b55b481894311e68faffaebc522"
+  resolved "https://registry.npmjs.org/better-assert/-/better-assert-1.0.2.tgz"
   integrity sha1-QIZrnhueC1W0gYlDEeaPr/rrxSI=
   dependencies:
     callsite "1.0.0"
 
 big.js@^5.2.2:
   version "5.2.2"
-  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
+  resolved "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz"
   integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
 
 binary-extensions@^1.0.0:
   version "1.12.0"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.12.0.tgz#c2d780f53d45bba8317a8902d4ceeaf3a6385b14"
+  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.12.0.tgz"
   integrity sha512-DYWGk01lDcxeS/K9IHPGWfT8PsJmbXRtRd2Sx72Tnb8pcYZQFF1oSDb8hJtS1vhp212q1Rzi5dUf9+nq0o9UIg==
 
+binary-extensions@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz"
+  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
+
+bindings@^1.5.0:
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
+  integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==
+  dependencies:
+    file-uri-to-path "1.0.0"
+
 blob@0.0.5:
   version "0.0.5"
-  resolved "https://registry.yarnpkg.com/blob/-/blob-0.0.5.tgz#d680eeef25f8cd91ad533f5b01eed48e64caf683"
+  resolved "https://registry.npmjs.org/blob/-/blob-0.0.5.tgz"
   integrity sha512-gaqbzQPqOoamawKg0LGVd7SzLgXS+JH61oWprSLH+P+abTczqJbhTR8CmJ2u9/bUYNmHTGJx/UEmn6doAvvuig==
 
 bluebird@^3.3.0, bluebird@^3.5.3:
   version "3.5.3"
-  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.5.3.tgz#7d01c6f9616c9a51ab0f8c549a79dfe6ec33efa7"
+  resolved "https://registry.npmjs.org/bluebird/-/bluebird-3.5.3.tgz"
   integrity sha512-/qKPUQlaW1OyR51WeCPBvRnAlnZFUJkCSG5HzGnuIqhgyJtF+T94lFnn33eiazjRm2LAHVy2guNnaq48X9SJuw==
 
 bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.1.1, bn.js@^4.11.9:
   version "4.12.0"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
+  resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz"
   integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
 
 body-parser@^1.16.1:
   version "1.18.3"
-  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.18.3.tgz#5b292198ffdd553b3a0f20ded0592b956955c8b4"
+  resolved "https://registry.npmjs.org/body-parser/-/body-parser-1.18.3.tgz"
   integrity sha1-WykhmP/dVTs6DyDe0FkrlWlVyLQ=
   dependencies:
     bytes "3.0.0"
@@ -2087,7 +2166,7 @@ body-parser@^1.16.1:
 
 brace-expansion@^1.0.0, brace-expansion@^1.1.7:
   version "1.1.11"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
+  resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz"
   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
   dependencies:
     balanced-match "^1.0.0"
@@ -2095,14 +2174,14 @@ brace-expansion@^1.0.0, brace-expansion@^1.1.7:
 
 braces@^0.1.2:
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-0.1.5.tgz#c085711085291d8b75fdd74eab0f8597280711e6"
+  resolved "https://registry.npmjs.org/braces/-/braces-0.1.5.tgz"
   integrity sha1-wIVxEIUpHYt1/ddOqw+FlygHEeY=
   dependencies:
     expand-range "^0.1.0"
 
 braces@^1.8.2:
   version "1.8.5"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7"
+  resolved "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz"
   integrity sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=
   dependencies:
     expand-range "^1.8.1"
@@ -2111,7 +2190,7 @@ braces@^1.8.2:
 
 braces@^2.3.0, braces@^2.3.1:
   version "2.3.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
+  resolved "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz"
   integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==
   dependencies:
     arr-flatten "^1.1.0"
@@ -2125,26 +2204,26 @@ braces@^2.3.0, braces@^2.3.1:
     split-string "^3.0.2"
     to-regex "^3.0.1"
 
-braces@^3.0.1:
+braces@^3.0.1, braces@~3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
+  resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz"
   integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
   dependencies:
     fill-range "^7.0.1"
 
 brorand@^1.0.1, brorand@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
+  resolved "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz"
   integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
 
 browser-stdout@1.3.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.0.tgz#f351d32969d32fa5d7a5567154263d928ae3bd1f"
+  resolved "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.0.tgz"
   integrity sha1-81HTKWnTL6XXpVZxVCY9korjvR8=
 
 browserify-aes@^1.0.0, browserify-aes@^1.0.4:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
+  resolved "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz"
   integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
   dependencies:
     buffer-xor "^1.0.3"
@@ -2156,7 +2235,7 @@ browserify-aes@^1.0.0, browserify-aes@^1.0.4:
 
 browserify-cipher@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.1.tgz#8d6474c1b870bfdabcd3bcfcc1934a10e94f15f0"
+  resolved "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz"
   integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==
   dependencies:
     browserify-aes "^1.0.4"
@@ -2165,7 +2244,7 @@ browserify-cipher@^1.0.0:
 
 browserify-des@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.2.tgz#3af4f1f59839403572f1c66204375f7a7f703e9c"
+  resolved "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz"
   integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==
   dependencies:
     cipher-base "^1.0.1"
@@ -2175,7 +2254,7 @@ browserify-des@^1.0.0:
 
 browserify-rsa@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.0.1.tgz#21e0abfaf6f2029cf2fafb133567a701d4135524"
+  resolved "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz"
   integrity sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=
   dependencies:
     bn.js "^4.1.0"
@@ -2183,7 +2262,7 @@ browserify-rsa@^4.0.0:
 
 browserify-sign@^4.0.0:
   version "4.0.4"
-  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.0.4.tgz#aa4eb68e5d7b658baa6bf6a57e630cbd7a93d298"
+  resolved "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz"
   integrity sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=
   dependencies:
     bn.js "^4.1.1"
@@ -2196,14 +2275,14 @@ browserify-sign@^4.0.0:
 
 browserify-zlib@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f"
+  resolved "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz"
   integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==
   dependencies:
     pako "~1.0.5"
 
 browserslist@^4.14.5, browserslist@^4.16.3:
   version "4.16.3"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.3.tgz#340aa46940d7db878748567c5dea24a48ddf3717"
+  resolved "https://registry.npmjs.org/browserslist/-/browserslist-4.16.3.tgz"
   integrity sha512-vIyhWmIkULaq04Gt93txdh+j02yX/JzlyhLYbV3YQCn/zvES3JnY7TifHHvvr1w5hTDluNKMkV05cs4vy8Q7sw==
   dependencies:
     caniuse-lite "^1.0.30001181"
@@ -2214,7 +2293,7 @@ browserslist@^4.14.5, browserslist@^4.16.3:
 
 buble@^0.20.0:
   version "0.20.0"
-  resolved "https://registry.yarnpkg.com/buble/-/buble-0.20.0.tgz#a143979a8d968b7f76b57f38f2e7ce7cfe938d1f"
+  resolved "https://registry.npmjs.org/buble/-/buble-0.20.0.tgz"
   integrity sha512-/1gnaMQE8xvd5qsNBl+iTuyjJ9XxeaVxAMF86dQ4EyxFJOZtsgOS8Ra+7WHgZTam5IFDtt4BguN0sH0tVTKrOw==
   dependencies:
     acorn "^6.4.1"
@@ -2227,35 +2306,40 @@ buble@^0.20.0:
 
 buffer-alloc-unsafe@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz#bd7dc26ae2972d0eda253be061dba992349c19f0"
+  resolved "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz"
   integrity sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==
 
 buffer-alloc@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/buffer-alloc/-/buffer-alloc-1.2.0.tgz#890dd90d923a873e08e10e5fd51a57e5b7cce0ec"
+  resolved "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz"
   integrity sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==
   dependencies:
     buffer-alloc-unsafe "^1.1.0"
     buffer-fill "^1.0.0"
 
+buffer-crc32@~0.2.3:
+  version "0.2.13"
+  resolved "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz"
+  integrity sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=
+
 buffer-fill@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/buffer-fill/-/buffer-fill-1.0.0.tgz#f8f78b76789888ef39f205cd637f68e702122b2c"
+  resolved "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz"
   integrity sha1-+PeLdniYiO858gXNY39o5wISKyw=
 
 buffer-from@^1.0.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
+  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz"
   integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
 
 buffer-xor@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
+  resolved "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz"
   integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=
 
 buffer@^4.3.0:
   version "4.9.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.1.tgz#6d1bb601b07a4efced97094132093027c95bc298"
+  resolved "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz"
   integrity sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=
   dependencies:
     base64-js "^1.0.2"
@@ -2264,27 +2348,27 @@ buffer@^4.3.0:
 
 builtin-modules@^1.0.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f"
+  resolved "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz"
   integrity sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=
 
 builtin-modules@^3.1.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
+  resolved "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.2.0.tgz"
   integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
 
 builtin-status-codes@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
+  resolved "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz"
   integrity sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=
 
 bytes@3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.0.0.tgz#d32815404d689699f85a4ea4fa8755dd13a96048"
+  resolved "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz"
   integrity sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=
 
 cacache@^11.0.2:
   version "11.3.2"
-  resolved "https://registry.yarnpkg.com/cacache/-/cacache-11.3.2.tgz#2d81e308e3d258ca38125b676b98b2ac9ce69bfa"
+  resolved "https://registry.npmjs.org/cacache/-/cacache-11.3.2.tgz"
   integrity sha512-E0zP4EPGDOaT2chM08Als91eYnf8Z+eH1awwwVsngUmgppfM5jjJ8l3z5vO5p5w/I3LsiXawb1sW0VY65pQABg==
   dependencies:
     bluebird "^3.5.3"
@@ -2304,7 +2388,7 @@ cacache@^11.0.2:
 
 cache-base@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
+  resolved "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz"
   integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==
   dependencies:
     collection-visit "^1.0.0"
@@ -2319,14 +2403,14 @@ cache-base@^1.0.1:
 
 cachedir@^1.1.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-1.3.0.tgz#5e01928bf2d95b5edd94b0942188246740e0dbc4"
+  resolved "https://registry.npmjs.org/cachedir/-/cachedir-1.3.0.tgz"
   integrity sha512-O1ji32oyON9laVPJL1IZ5bmwd2cB46VfpxkDequezH+15FDzzVddEyrGEeX4WusDSqKxdyFdDQDEG1yo1GoWkg==
   dependencies:
     os-homedir "^1.0.1"
 
 call-bind@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
+  resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz"
   integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
   dependencies:
     function-bind "^1.1.1"
@@ -2334,17 +2418,17 @@ call-bind@^1.0.0:
 
 callsite@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/callsite/-/callsite-1.0.0.tgz#280398e5d664bd74038b6f0905153e6e8af1bc20"
+  resolved "https://registry.npmjs.org/callsite/-/callsite-1.0.0.tgz"
   integrity sha1-KAOY5dZkvXQDi28JBRU+borxvCA=
 
 callsites@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.0.0.tgz#fb7eb569b72ad7a45812f93fd9430a3e410b3dd3"
+  resolved "https://registry.npmjs.org/callsites/-/callsites-3.0.0.tgz"
   integrity sha512-tWnkwu9YEq2uzlBDI4RcLn8jrFvF9AOi8PxDNU3hZZjJcjkcRAq3vCI+vZcg1SuxISDYe86k9VZFwAxDiJGoAw==
 
 camelcase-keys@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-2.1.0.tgz#308beeaffdf28119051efa1d932213c91b8f92e7"
+  resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz"
   integrity sha1-MIvur/3ygRkFHvodkyITyRuPkuc=
   dependencies:
     camelcase "^2.0.0"
@@ -2352,7 +2436,7 @@ camelcase-keys@^2.0.0:
 
 camelcase-keys@^4.0.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-4.2.0.tgz#a2aa5fb1af688758259c32c141426d78923b9b77"
+  resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-4.2.0.tgz"
   integrity sha1-oqpfsa9oh1glnDLBQUJteJI7m3c=
   dependencies:
     camelcase "^4.1.0"
@@ -2361,27 +2445,27 @@ camelcase-keys@^4.0.0:
 
 camelcase@^2.0.0:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f"
+  resolved "https://registry.npmjs.org/camelcase/-/camelcase-2.1.1.tgz"
   integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=
 
 camelcase@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd"
+  resolved "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz"
   integrity sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=
 
 caniuse-lite@^1.0.30001181:
   version "1.0.30001207"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001207.tgz#364d47d35a3007e528f69adb6fecb07c2bb2cc50"
+  resolved "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001207.tgz"
   integrity sha512-UPQZdmAsyp2qfCTiMU/zqGSWOYaY9F9LL61V8f+8MrubsaDGpaHD9HRV/EWZGULZn0Hxu48SKzI5DgFwTvHuYw==
 
 caseless@~0.12.0:
   version "0.12.0"
-  resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
+  resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz"
   integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
 
 chai-nightwatch@~0.1.x:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/chai-nightwatch/-/chai-nightwatch-0.1.1.tgz#1ca56de768d3c0868fe7fc2f4d32c2fe894e6be9"
+  resolved "https://registry.npmjs.org/chai-nightwatch/-/chai-nightwatch-0.1.1.tgz"
   integrity sha1-HKVt52jTwIaP5/wvTTLC/olOa+k=
   dependencies:
     assertion-error "1.0.0"
@@ -2389,7 +2473,7 @@ chai-nightwatch@~0.1.x:
 
 chalk@1.1.3, chalk@^1.0.0, chalk@^1.1.3:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz"
   integrity sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=
   dependencies:
     ansi-styles "^2.2.1"
@@ -2400,7 +2484,7 @@ chalk@1.1.3, chalk@^1.0.0, chalk@^1.1.3:
 
 chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4.1, chalk@^2.4.2:
   version "2.4.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
   dependencies:
     ansi-styles "^3.2.1"
@@ -2409,7 +2493,7 @@ chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4
 
 chalk@^4.0.0, chalk@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a"
+  resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz"
   integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A==
   dependencies:
     ansi-styles "^4.1.0"
@@ -2417,12 +2501,12 @@ chalk@^4.0.0, chalk@^4.1.0:
 
 chardet@^0.4.0:
   version "0.4.2"
-  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
+  resolved "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz"
   integrity sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=
 
 chokidar@^2.0.2, chokidar@^2.0.3:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.0.4.tgz#356ff4e2b0e8e43e322d18a372460bbcf3accd26"
+  resolved "https://registry.npmjs.org/chokidar/-/chokidar-2.0.4.tgz"
   integrity sha512-z9n7yt9rOvIJrMhvDtDictKrkFHeihkNl6uWMmZlmL6tJtX9Cs+87oK+teBx+JIgzvbX3yZHT3eF8vpbDxHJXQ==
   dependencies:
     anymatch "^2.0.0"
@@ -2440,37 +2524,59 @@ chokidar@^2.0.2, chokidar@^2.0.3:
   optionalDependencies:
     fsevents "^1.2.2"
 
+chokidar@^3.5.3:
+  version "3.5.3"
+  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz"
+  integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
+  dependencies:
+    anymatch "~3.1.2"
+    braces "~3.0.2"
+    glob-parent "~5.1.2"
+    is-binary-path "~2.1.0"
+    is-glob "~4.0.1"
+    normalize-path "~3.0.0"
+    readdirp "~3.6.0"
+  optionalDependencies:
+    fsevents "~2.3.2"
+
 chownr@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.1.tgz#54726b8b8fff4df053c42187e801fb4412df1494"
+  resolved "https://registry.npmjs.org/chownr/-/chownr-1.1.1.tgz"
   integrity sha512-j38EvO5+LHX84jlo6h4UzmOwi0UgW61WRyPtJz4qaadK5eY3BTS5TY/S1Stc3Uk2lIM6TPevAlULiEJwie860g==
 
+chownr@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz"
+  integrity sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==
+
 chrome-trace-event@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.0.tgz#45a91bd2c20c9411f0963b5aaeb9a1b95e09cc48"
+  resolved "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.0.tgz"
   integrity sha512-xDbVgyfDTT2piup/h8dK/y4QZfJRSa73bw1WZ8b4XM1o7fsFubUVGYcE+1ANtOzJJELGpYoG2961z0Z6OAld9A==
   dependencies:
     tslib "^1.9.0"
 
-chromedriver@^2.45.0:
-  version "2.45.0"
-  resolved "https://registry.yarnpkg.com/chromedriver/-/chromedriver-2.45.0.tgz#8c1b158adbbd3e0ca3f7af19d459082245554378"
-  integrity sha512-Qwmcr+2mU3INeR6mVsQ8gO00vZpL8ZeTJLclX44C0dcs88jrSDgckPqbG+qkVX+m2L/aOPnF0lYgPdOiOiLt5w==
-  dependencies:
-    del "^3.0.0"
-    extract-zip "^1.6.7"
-    mkdirp "^0.5.1"
-    request "^2.88.0"
+chromedriver@^90.0:
+  version "90.0.1"
+  resolved "https://registry.npmjs.org/chromedriver/-/chromedriver-90.0.1.tgz"
+  integrity sha512-jvyhin0I/Bacxfet7eg29B1j+5mKR35XwWGbgcCOUALeE3mqcCKJY8xUW9cVrqVqTK9/iUOq8/kar7qrTVshPA==
+  dependencies:
+    "@testim/chrome-version" "^1.0.7"
+    axios "^0.21.1"
+    del "^6.0.0"
+    extract-zip "^2.0.1"
+    https-proxy-agent "^5.0.0"
+    proxy-from-env "^1.1.0"
     tcp-port-used "^1.0.1"
 
 ci-info@^1.5.0:
   version "1.6.0"
-  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"
+  resolved "https://registry.npmjs.org/ci-info/-/ci-info-1.6.0.tgz"
   integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==
 
 cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
+  resolved "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz"
   integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
   dependencies:
     inherits "^2.0.1"
@@ -2478,12 +2584,12 @@ cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
 
 circular-json@^0.5.5:
   version "0.5.9"
-  resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.5.9.tgz#932763ae88f4f7dead7a0d09c8a51a4743a53b1d"
+  resolved "https://registry.npmjs.org/circular-json/-/circular-json-0.5.9.tgz"
   integrity sha512-4ivwqHpIFJZBuhN3g/pEcdbnGUywkBblloGbkglyloVjjR3uT6tieI89MVOfbP2tHX5sgb01FuLgAOzebNlJNQ==
 
 class-utils@^0.3.5:
   version "0.3.6"
-  resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
+  resolved "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz"
   integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==
   dependencies:
     arr-union "^3.1.0"
@@ -2491,23 +2597,28 @@ class-utils@^0.3.5:
     isobject "^3.0.0"
     static-extend "^0.1.1"
 
+clean-stack@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz"
+  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
+
 cli-cursor@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-1.0.2.tgz#64da3f7d56a54412e59794bd62dc35295e8f2987"
+  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-1.0.2.tgz"
   integrity sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=
   dependencies:
     restore-cursor "^1.0.1"
 
 cli-cursor@^2.0.0, cli-cursor@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
+  resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz"
   integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
   dependencies:
     restore-cursor "^2.0.0"
 
 cli-truncate@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-0.2.1.tgz#9f15cfbb0705005369216c626ac7d05ab90dd574"
+  resolved "https://registry.npmjs.org/cli-truncate/-/cli-truncate-0.2.1.tgz"
   integrity sha1-nxXPuwcFAFNpIWxiasfQWrkN1XQ=
   dependencies:
     slice-ansi "0.0.4"
@@ -2515,12 +2626,12 @@ cli-truncate@^0.2.1:
 
 cli-width@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.0.tgz#ff19ede8a9a5e579324147b0c11f0fbcbabed639"
+  resolved "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz"
   integrity sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=
 
 cliui@^7.0.2:
   version "7.0.4"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
+  resolved "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz"
   integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
   dependencies:
     string-width "^4.2.0"
@@ -2529,17 +2640,17 @@ cliui@^7.0.2:
 
 co@~3.0.6:
   version "3.0.6"
-  resolved "https://registry.yarnpkg.com/co/-/co-3.0.6.tgz#1445f226c5eb956138e68c9ac30167ea7d2e6bda"
+  resolved "https://registry.npmjs.org/co/-/co-3.0.6.tgz"
   integrity sha1-FEXyJsXrlWE45oyawwFn6n0ua9o=
 
 code-point-at@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
+  resolved "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz"
   integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
 
 codecov@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/codecov/-/codecov-3.1.0.tgz#340bd968d361f256976b5af782dd8ba9f82bc849"
+  resolved "https://registry.npmjs.org/codecov/-/codecov-3.1.0.tgz"
   integrity sha512-aWQc/rtHbcWEQLka6WmBAOpV58J2TwyXqlpAQGhQaSiEUoigTTUk6lLd2vB3kXkhnDyzyH74RXfmV4dq2txmdA==
   dependencies:
     argv "^0.0.2"
@@ -2550,7 +2661,7 @@ codecov@^3.0.0:
 
 collection-visit@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
+  resolved "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz"
   integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=
   dependencies:
     map-visit "^1.0.0"
@@ -2558,82 +2669,87 @@ collection-visit@^1.0.0:
 
 color-convert@^1.9.0:
   version "1.9.3"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz"
   integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
   dependencies:
     color-name "1.1.3"
 
 color-convert@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+  resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz"
   integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
   dependencies:
     color-name "~1.1.4"
 
 color-name@1.1.3:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz"
   integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
 
 color-name@~1.1.4:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
+  resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz"
   integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
 
+color-support@^1.1.2:
+  version "1.1.3"
+  resolved "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz"
+  integrity sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==
+
 colorette@^1.2.1:
   version "1.2.2"
-  resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
+  resolved "https://registry.npmjs.org/colorette/-/colorette-1.2.2.tgz"
   integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
 
 colors@^1.1.0:
   version "1.3.3"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.3.tgz#39e005d546afe01e01f9c4ca8fa50f686a01205d"
+  resolved "https://registry.npmjs.org/colors/-/colors-1.3.3.tgz"
   integrity sha512-mmGt/1pZqYRjMxB1axhTo16/snVZ5krrKkcmMeVKxzECMMXoCgnvTPp10QgHfcbQZw8Dq2jMNG6je4JlWU0gWg==
 
 colors@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78"
+  resolved "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz"
   integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==
 
 combine-lists@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/combine-lists/-/combine-lists-1.0.1.tgz#458c07e09e0d900fc28b70a3fec2dacd1d2cb7f6"
+  resolved "https://registry.npmjs.org/combine-lists/-/combine-lists-1.0.1.tgz"
   integrity sha1-RYwH4J4NkA/Ci3Cj/sLazR0st/Y=
   dependencies:
     lodash "^4.5.0"
 
 combined-stream@^1.0.6, combined-stream@~1.0.6:
   version "1.0.7"
-  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.7.tgz#2d1d24317afb8abe95d6d2c0b07b57813539d828"
+  resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.7.tgz"
   integrity sha512-brWl9y6vOB1xYPZcpZde3N9zDByXTosAeMDo4p1wzo6UMOX4vumB+TP1RZ76sfE6Md68Q0NJSrE/gbezd4Ul+w==
   dependencies:
     delayed-stream "~1.0.0"
 
 commander@2.9.0:
   version "2.9.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.9.0.tgz#9c99094176e12240cb22d6c5146098400fe0f7d4"
+  resolved "https://registry.npmjs.org/commander/-/commander-2.9.0.tgz"
   integrity sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=
   dependencies:
     graceful-readlink ">= 1.0.0"
 
 commander@^2.14.1, commander@^2.9.0:
   version "2.19.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.19.0.tgz#f6198aa84e5b83c46054b94ddedbfed5ee9ff12a"
+  resolved "https://registry.npmjs.org/commander/-/commander-2.19.0.tgz"
   integrity sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==
 
 commander@^2.20.0:
   version "2.20.3"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
+  resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
 
 commander@~2.17.1:
   version "2.17.1"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"
+  resolved "https://registry.npmjs.org/commander/-/commander-2.17.1.tgz"
   integrity sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==
 
 commitizen@^2.9.6:
   version "2.10.1"
-  resolved "https://registry.yarnpkg.com/commitizen/-/commitizen-2.10.1.tgz#8c395def34a895f4e94952c2efc3c9eb4c3683bd"
+  resolved "https://registry.npmjs.org/commitizen/-/commitizen-2.10.1.tgz"
   integrity sha1-jDld7zSolfTpSVLC78PJ60w2g70=
   dependencies:
     cachedir "^1.1.0"
@@ -2655,12 +2771,12 @@ commitizen@^2.9.6:
 
 commondir@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
+  resolved "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz"
   integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=
 
 compare-func@^1.3.1:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-1.3.2.tgz#99dd0ba457e1f9bc722b12c08ec33eeab31fa648"
+  resolved "https://registry.npmjs.org/compare-func/-/compare-func-1.3.2.tgz"
   integrity sha1-md0LpFfh+bxyKxLAjsM+6rMfpkg=
   dependencies:
     array-ify "^1.0.0"
@@ -2668,27 +2784,27 @@ compare-func@^1.3.1:
 
 component-bind@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/component-bind/-/component-bind-1.0.0.tgz#00c608ab7dcd93897c0009651b1d3a8e1e73bbd1"
+  resolved "https://registry.npmjs.org/component-bind/-/component-bind-1.0.0.tgz"
   integrity sha1-AMYIq33Nk4l8AAllGx06jh5zu9E=
 
 component-emitter@1.2.1, component-emitter@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.2.1.tgz#137918d6d78283f7df7a6b7c5a63e140e69425e6"
+  resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz"
   integrity sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=
 
 component-inherit@0.0.3:
   version "0.0.3"
-  resolved "https://registry.yarnpkg.com/component-inherit/-/component-inherit-0.0.3.tgz#645fc4adf58b72b649d5cae65135619db26ff143"
+  resolved "https://registry.npmjs.org/component-inherit/-/component-inherit-0.0.3.tgz"
   integrity sha1-ZF/ErfWLcrZJ1crmUTVhnbJv8UM=
 
 concat-map@0.0.1:
   version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+  resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
 concat-stream@1.6.2, concat-stream@^1.4.7, concat-stream@^1.5.0:
   version "1.6.2"
-  resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
+  resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz"
   integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
   dependencies:
     buffer-from "^1.0.0"
@@ -2698,7 +2814,7 @@ concat-stream@1.6.2, concat-stream@^1.4.7, concat-stream@^1.5.0:
 
 connect@^3.6.0:
   version "3.6.6"
-  resolved "https://registry.yarnpkg.com/connect/-/connect-3.6.6.tgz#09eff6c55af7236e137135a72574858b6786f524"
+  resolved "https://registry.npmjs.org/connect/-/connect-3.6.6.tgz"
   integrity sha1-Ce/2xVr3I24TcTWnJXSFi2eG9SQ=
   dependencies:
     debug "2.6.9"
@@ -2708,29 +2824,29 @@ connect@^3.6.0:
 
 console-browserify@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.1.0.tgz#f0241c45730a9fc6323b206dbf38edc741d0bb10"
+  resolved "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz"
   integrity sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=
   dependencies:
     date-now "^0.1.4"
 
-console-control-strings@^1.0.0, console-control-strings@~1.1.0:
+console-control-strings@^1.0.0, console-control-strings@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
+  resolved "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz"
   integrity sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=
 
 constants-browserify@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
+  resolved "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz"
   integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=
 
 content-type@~1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.4.tgz#e138cc75e040c727b1966fe5e5f8c9aee256fe3b"
+  resolved "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz"
   integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==
 
 conventional-changelog-angular@^1.6.6:
   version "1.6.6"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-1.6.6.tgz#b27f2b315c16d0a1f23eb181309d0e6a4698ea0f"
+  resolved "https://registry.npmjs.org/conventional-changelog-angular/-/conventional-changelog-angular-1.6.6.tgz"
   integrity sha512-suQnFSqCxRwyBxY68pYTsFkG0taIdinHLNEAX5ivtw8bCRnIgnpvcHmlR/yjUyZIrNPYAoXlY1WiEKWgSE4BNg==
   dependencies:
     compare-func "^1.3.1"
@@ -2738,21 +2854,21 @@ conventional-changelog-angular@^1.6.6:
 
 conventional-changelog-atom@^0.2.8:
   version "0.2.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-atom/-/conventional-changelog-atom-0.2.8.tgz#8037693455990e3256f297320a45fa47ee553a14"
+  resolved "https://registry.npmjs.org/conventional-changelog-atom/-/conventional-changelog-atom-0.2.8.tgz"
   integrity sha512-8pPZqhMbrnltNBizjoDCb/Sz85KyUXNDQxuAEYAU5V/eHn0okMBVjqc8aHWYpHrytyZWvMGbayOlDv7i8kEf6g==
   dependencies:
     q "^1.5.1"
 
 conventional-changelog-codemirror@^0.3.8:
   version "0.3.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-codemirror/-/conventional-changelog-codemirror-0.3.8.tgz#a1982c8291f4ee4d6f2f62817c6b2ecd2c4b7b47"
+  resolved "https://registry.npmjs.org/conventional-changelog-codemirror/-/conventional-changelog-codemirror-0.3.8.tgz"
   integrity sha512-3HFZKtBXTaUCHvz7ai6nk2+psRIkldDoNzCsom0egDtVmPsvvHZkzjynhdQyULfacRSsBTaiQ0ol6nBOL4dDiQ==
   dependencies:
     q "^1.5.1"
 
 conventional-changelog-core@^2.0.11:
   version "2.0.11"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-core/-/conventional-changelog-core-2.0.11.tgz#19b5fbd55a9697773ed6661f4e32030ed7e30287"
+  resolved "https://registry.npmjs.org/conventional-changelog-core/-/conventional-changelog-core-2.0.11.tgz"
   integrity sha512-HvTE6RlqeEZ/NFPtQeFLsIDOLrGP3bXYr7lFLMhCVsbduF1MXIe8OODkwMFyo1i9ku9NWBwVnVn0jDmIFXjDRg==
   dependencies:
     conventional-changelog-writer "^3.0.9"
@@ -2771,42 +2887,42 @@ conventional-changelog-core@^2.0.11:
 
 conventional-changelog-ember@^0.3.12:
   version "0.3.12"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-ember/-/conventional-changelog-ember-0.3.12.tgz#b7d31851756d0fcb49b031dffeb6afa93b202400"
+  resolved "https://registry.npmjs.org/conventional-changelog-ember/-/conventional-changelog-ember-0.3.12.tgz"
   integrity sha512-mmJzA7uzbrOqeF89dMMi6z17O07ORTXlTMArnLG9ZTX4oLaKNolUlxFUFlFm9JUoVWajVpaHQWjxH1EOQ+ARoQ==
   dependencies:
     q "^1.5.1"
 
 conventional-changelog-eslint@^1.0.9:
   version "1.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-eslint/-/conventional-changelog-eslint-1.0.9.tgz#b13cc7e4b472c819450ede031ff1a75c0e3d07d3"
+  resolved "https://registry.npmjs.org/conventional-changelog-eslint/-/conventional-changelog-eslint-1.0.9.tgz"
   integrity sha512-h87nfVh2fdk9fJIvz26wCBsbDC/KxqCc5wSlNMZbXcARtbgNbNDIF7Y7ctokFdnxkzVdaHsbINkh548T9eBA7Q==
   dependencies:
     q "^1.5.1"
 
 conventional-changelog-express@^0.3.6:
   version "0.3.6"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-express/-/conventional-changelog-express-0.3.6.tgz#4a6295cb11785059fb09202180d0e59c358b9c2c"
+  resolved "https://registry.npmjs.org/conventional-changelog-express/-/conventional-changelog-express-0.3.6.tgz"
   integrity sha512-3iWVtBJZ9RnRnZveNDzOD8QRn6g6vUif0qVTWWyi5nUIAbuN1FfPVyKdAlJJfp5Im+dE8Kiy/d2SpaX/0X678Q==
   dependencies:
     q "^1.5.1"
 
 conventional-changelog-jquery@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jquery/-/conventional-changelog-jquery-0.1.0.tgz#0208397162e3846986e71273b6c79c5b5f80f510"
+  resolved "https://registry.npmjs.org/conventional-changelog-jquery/-/conventional-changelog-jquery-0.1.0.tgz"
   integrity sha1-Agg5cWLjhGmG5xJztsecW1+A9RA=
   dependencies:
     q "^1.4.1"
 
 conventional-changelog-jscs@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jscs/-/conventional-changelog-jscs-0.1.0.tgz#0479eb443cc7d72c58bf0bcf0ef1d444a92f0e5c"
+  resolved "https://registry.npmjs.org/conventional-changelog-jscs/-/conventional-changelog-jscs-0.1.0.tgz"
   integrity sha1-BHnrRDzH1yxYvwvPDvHURKkvDlw=
   dependencies:
     q "^1.4.1"
 
 conventional-changelog-jshint@^0.3.8:
   version "0.3.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jshint/-/conventional-changelog-jshint-0.3.8.tgz#9051c1ac0767abaf62a31f74d2fe8790e8acc6c8"
+  resolved "https://registry.npmjs.org/conventional-changelog-jshint/-/conventional-changelog-jshint-0.3.8.tgz"
   integrity sha512-hn9QU4ZI/5V50wKPJNPGT4gEWgiBFpV6adieILW4MaUFynuDYOvQ71EMSj3EznJyKi/KzuXpc9dGmX8njZMjig==
   dependencies:
     compare-func "^1.3.1"
@@ -2814,12 +2930,12 @@ conventional-changelog-jshint@^0.3.8:
 
 conventional-changelog-preset-loader@^1.1.8:
   version "1.1.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-1.1.8.tgz#40bb0f142cd27d16839ec6c74ee8db418099b373"
+  resolved "https://registry.npmjs.org/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-1.1.8.tgz"
   integrity sha512-MkksM4G4YdrMlT2MbTsV2F6LXu/hZR0Tc/yenRrDIKRwBl/SP7ER4ZDlglqJsCzLJi4UonBc52Bkm5hzrOVCcw==
 
 conventional-changelog-writer@^3.0.9:
   version "3.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-writer/-/conventional-changelog-writer-3.0.9.tgz#4aecdfef33ff2a53bb0cf3b8071ce21f0e994634"
+  resolved "https://registry.npmjs.org/conventional-changelog-writer/-/conventional-changelog-writer-3.0.9.tgz"
   integrity sha512-n9KbsxlJxRQsUnK6wIBRnARacvNnN4C/nxnxCkH+B/R1JS2Fa+DiP1dU4I59mEDEjgnFaN2+9wr1P1s7GYB5/Q==
   dependencies:
     compare-func "^1.3.1"
@@ -2835,7 +2951,7 @@ conventional-changelog-writer@^3.0.9:
 
 conventional-changelog@^1.1.3:
   version "1.1.24"
-  resolved "https://registry.yarnpkg.com/conventional-changelog/-/conventional-changelog-1.1.24.tgz#3d94c29c960f5261c002678315b756cdd3d7d1f0"
+  resolved "https://registry.npmjs.org/conventional-changelog/-/conventional-changelog-1.1.24.tgz"
   integrity sha512-2WcSUst4Y3Z4hHvoMTWXMJr/DmgVdLiMOVY1Kak2LfFz+GIz2KDp5naqbFesYbfXPmaZ5p491dO0FWZIJoJw1Q==
   dependencies:
     conventional-changelog-angular "^1.6.6"
@@ -2852,12 +2968,12 @@ conventional-changelog@^1.1.3:
 
 conventional-commit-types@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/conventional-commit-types/-/conventional-commit-types-2.2.0.tgz#5db95739d6c212acbe7b6f656a11b940baa68946"
+  resolved "https://registry.npmjs.org/conventional-commit-types/-/conventional-commit-types-2.2.0.tgz"
   integrity sha1-XblXOdbCEqy+e29lahG5QLqmiUY=
 
 conventional-commits-filter@^1.1.6:
   version "1.1.6"
-  resolved "https://registry.yarnpkg.com/conventional-commits-filter/-/conventional-commits-filter-1.1.6.tgz#4389cd8e58fe89750c0b5fb58f1d7f0cc8ad3831"
+  resolved "https://registry.npmjs.org/conventional-commits-filter/-/conventional-commits-filter-1.1.6.tgz"
   integrity sha512-KcDgtCRKJCQhyk6VLT7zR+ZOyCnerfemE/CsR3iQpzRRFbLEs0Y6rwk3mpDvtOh04X223z+1xyJ582Stfct/0Q==
   dependencies:
     is-subset "^0.1.1"
@@ -2865,7 +2981,7 @@ conventional-commits-filter@^1.1.6:
 
 conventional-commits-parser@^2.1.7:
   version "2.1.7"
-  resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-2.1.7.tgz#eca45ed6140d72ba9722ee4132674d639e644e8e"
+  resolved "https://registry.npmjs.org/conventional-commits-parser/-/conventional-commits-parser-2.1.7.tgz"
   integrity sha512-BoMaddIEJ6B4QVMSDu9IkVImlGOSGA1I2BQyOZHeLQ6qVOJLcLKn97+fL6dGbzWEiqDzfH4OkcveULmeq2MHFQ==
   dependencies:
     JSONStream "^1.0.4"
@@ -2878,19 +2994,19 @@ conventional-commits-parser@^2.1.7:
 
 convert-source-map@^1.7.0:
   version "1.7.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442"
+  resolved "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz"
   integrity sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==
   dependencies:
     safe-buffer "~5.1.1"
 
 cookie@0.3.1:
   version "0.3.1"
-  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.3.1.tgz#e7e0a1f9ef43b4c8ba925c5c5a96e806d16873bb"
+  resolved "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz"
   integrity sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=
 
 copy-concurrently@^1.0.0:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/copy-concurrently/-/copy-concurrently-1.0.5.tgz#92297398cae34937fcafd6ec8139c18051f0b5e0"
+  resolved "https://registry.npmjs.org/copy-concurrently/-/copy-concurrently-1.0.5.tgz"
   integrity sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==
   dependencies:
     aproba "^1.1.1"
@@ -2902,12 +3018,12 @@ copy-concurrently@^1.0.0:
 
 copy-descriptor@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
+  resolved "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz"
   integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
 
 core-js-compat@^3.8.1, core-js-compat@^3.9.0:
   version "3.10.0"
-  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.10.0.tgz#3600dc72869673c110215ee7a005a8609dea0fe1"
+  resolved "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.10.0.tgz"
   integrity sha512-9yVewub2MXNYyGvuLnMHcN1k9RkvB7/ofktpeKTIaASyB88YYqGzUnu0ywMMhJrDHOMiTjSHWGzR+i7Wb9Z1kQ==
   dependencies:
     browserslist "^4.16.3"
@@ -2915,27 +3031,27 @@ core-js-compat@^3.8.1, core-js-compat@^3.9.0:
 
 core-js@^2.2.0, core-js@^2.4.0:
   version "2.6.1"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.1.tgz#87416ae817de957a3f249b3b5ca475d4aaed6042"
+  resolved "https://registry.npmjs.org/core-js/-/core-js-2.6.1.tgz"
   integrity sha512-L72mmmEayPJBejKIWe2pYtGis5r0tQ5NaJekdhyXgeMQTpJoBsH0NL4ElY2LfSoV15xeQWKQ+XTTOZdyero5Xg==
 
 core-js@~2.3.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.3.0.tgz#fab83fbb0b2d8dc85fa636c4b9d34c75420c6d65"
+  resolved "https://registry.npmjs.org/core-js/-/core-js-2.3.0.tgz"
   integrity sha1-+rg/uwstjchfpjbEudNMdUIMbWU=
 
 core-util-is@1.0.2, core-util-is@~1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
+  resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz"
   integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
 
 corser@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/corser/-/corser-2.0.1.tgz#8eda252ecaab5840dcd975ceb90d9370c819ff87"
+  resolved "https://registry.npmjs.org/corser/-/corser-2.0.1.tgz"
   integrity sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=
 
 cosmiconfig@5.0.6:
   version "5.0.6"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-5.0.6.tgz#dca6cf680a0bd03589aff684700858c81abeeb39"
+  resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-5.0.6.tgz"
   integrity sha512-6DWfizHriCrFWURP1/qyhsiFvYdlJzbCzmtFWh744+KyWsJo5+kPzUZZaMRSSItoYc0pxFX7gEO7ZC1/gN/7AQ==
   dependencies:
     is-directory "^0.3.1"
@@ -2944,7 +3060,7 @@ cosmiconfig@5.0.6:
 
 create-ecdh@^4.0.0:
   version "4.0.3"
-  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.3.tgz#c9111b6f33045c4697f144787f9254cdc77c45ff"
+  resolved "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz"
   integrity sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==
   dependencies:
     bn.js "^4.1.0"
@@ -2952,7 +3068,7 @@ create-ecdh@^4.0.0:
 
 create-hash@^1.1.0, create-hash@^1.1.2:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
+  resolved "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz"
   integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
   dependencies:
     cipher-base "^1.0.1"
@@ -2963,7 +3079,7 @@ create-hash@^1.1.0, create-hash@^1.1.2:
 
 create-hmac@^1.1.0, create-hmac@^1.1.2, create-hmac@^1.1.4:
   version "1.1.7"
-  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff"
+  resolved "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz"
   integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
   dependencies:
     cipher-base "^1.0.3"
@@ -2975,12 +3091,12 @@ create-hmac@^1.1.0, create-hmac@^1.1.2, create-hmac@^1.1.4:
 
 create-require@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
+  resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz"
   integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
 
 cross-spawn@^5.0.1:
   version "5.1.0"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-5.1.0.tgz#e8bd0efee58fcff6f8f94510a0a554bbfa235449"
+  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz"
   integrity sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=
   dependencies:
     lru-cache "^4.0.1"
@@ -2989,7 +3105,7 @@ cross-spawn@^5.0.1:
 
 cross-spawn@^6.0.0, cross-spawn@^6.0.5:
   version "6.0.5"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
+  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz"
   integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
   dependencies:
     nice-try "^1.0.4"
@@ -3000,7 +3116,7 @@ cross-spawn@^6.0.0, cross-spawn@^6.0.5:
 
 cross-spawn@^7.0.2:
   version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz"
   integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
   dependencies:
     path-key "^3.1.0"
@@ -3009,7 +3125,7 @@ cross-spawn@^7.0.2:
 
 crypto-browserify@^3.11.0:
   version "3.12.0"
-  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
+  resolved "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz"
   integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
   dependencies:
     browserify-cipher "^1.0.0"
@@ -3026,7 +3142,7 @@ crypto-browserify@^3.11.0:
 
 css@~2.2.1:
   version "2.2.4"
-  resolved "https://registry.yarnpkg.com/css/-/css-2.2.4.tgz#c646755c73971f2bba6a601e2cf2fd71b1298929"
+  resolved "https://registry.npmjs.org/css/-/css-2.2.4.tgz"
   integrity sha512-oUnjmWpy0niI3x/mPL8dVEI1l7MnG3+HHyRPHf+YFSbK+svOhXpmSOcDURUh2aOCgl2grzrOPt1nHLuCVFULLw==
   dependencies:
     inherits "^2.0.3"
@@ -3036,24 +3152,24 @@ css@~2.2.1:
 
 currently-unhandled@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/currently-unhandled/-/currently-unhandled-0.4.1.tgz#988df33feab191ef799a61369dd76c17adf957ea"
+  resolved "https://registry.npmjs.org/currently-unhandled/-/currently-unhandled-0.4.1.tgz"
   integrity sha1-mI3zP+qxke95mmE2nddsF635V+o=
   dependencies:
     array-find-index "^1.0.1"
 
 custom-event@~1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/custom-event/-/custom-event-1.0.1.tgz#5d02a46850adf1b4a317946a3928fccb5bfd0425"
+  resolved "https://registry.npmjs.org/custom-event/-/custom-event-1.0.1.tgz"
   integrity sha1-XQKkaFCt8bSjF5RqOSj8y1v9BCU=
 
 cyclist@~0.2.2:
   version "0.2.2"
-  resolved "https://registry.yarnpkg.com/cyclist/-/cyclist-0.2.2.tgz#1b33792e11e914a2fd6d6ed6447464444e5fa640"
+  resolved "https://registry.npmjs.org/cyclist/-/cyclist-0.2.2.tgz"
   integrity sha1-GzN5LhHpFKL9bW7WRHRkRE5fpkA=
 
 cz-conventional-changelog@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-2.0.0.tgz#55a979afdfe95e7024879d2a0f5924630170b533"
+  resolved "https://registry.npmjs.org/cz-conventional-changelog/-/cz-conventional-changelog-2.0.0.tgz"
   integrity sha1-Val5r9/pXnAkh50qD1kkYwFwtTM=
   dependencies:
     conventional-commit-types "^2.0.0"
@@ -3065,7 +3181,7 @@ cz-conventional-changelog@2.0.0:
 
 cz-conventional-changelog@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-2.1.0.tgz#2f4bc7390e3244e4df293e6ba351e4c740a7c764"
+  resolved "https://registry.npmjs.org/cz-conventional-changelog/-/cz-conventional-changelog-2.1.0.tgz"
   integrity sha1-L0vHOQ4yROTfKT5ro1Hkx0Cnx2Q=
   dependencies:
     conventional-commit-types "^2.0.0"
@@ -3076,41 +3192,41 @@ cz-conventional-changelog@^2.0.0:
 
 dargs@^4.0.1:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/dargs/-/dargs-4.1.0.tgz#03a9dbb4b5c2f139bf14ae53f0b8a2a6a86f4e17"
+  resolved "https://registry.npmjs.org/dargs/-/dargs-4.1.0.tgz"
   integrity sha1-A6nbtLXC8Tm/FK5T8LiipqhvThc=
   dependencies:
     number-is-nan "^1.0.0"
 
 dashdash@^1.12.0:
   version "1.14.1"
-  resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
+  resolved "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz"
   integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=
   dependencies:
     assert-plus "^1.0.0"
 
 data-uri-to-buffer@1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/data-uri-to-buffer/-/data-uri-to-buffer-1.2.0.tgz#77163ea9c20d8641b4707e8f18abdf9a78f34835"
+  resolved "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-1.2.0.tgz"
   integrity sha512-vKQ9DTQPN1FLYiiEEOQ6IBGFqvjCa5rSK3cWMy/Nespm5d/x3dGFT9UBZnkLxCwua/IXBi2TYnwTEpsOvhC4UQ==
 
 date-fns@^1.27.2:
   version "1.30.1"
-  resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-1.30.1.tgz#2e71bf0b119153dbb4cc4e88d9ea5acfb50dc05c"
+  resolved "https://registry.npmjs.org/date-fns/-/date-fns-1.30.1.tgz"
   integrity sha512-hBSVCvSmWC+QypYObzwGOd9wqdDpOt+0wl0KbU+R+uuZBS1jN8VsD1ss3irQDknRj5NvxiTF6oj/nDRnN/UQNw==
 
 date-format@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/date-format/-/date-format-1.2.0.tgz#615e828e233dd1ab9bb9ae0950e0ceccfa6ecad8"
+  resolved "https://registry.npmjs.org/date-format/-/date-format-1.2.0.tgz"
   integrity sha1-YV6CjiM90aubua4JUODOzPpuytg=
 
 date-now@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/date-now/-/date-now-0.1.4.tgz#eaf439fd4d4848ad74e5cc7dbef200672b9e345b"
+  resolved "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz"
   integrity sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=
 
 dateformat@^1.0.6:
   version "1.0.12"
-  resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-1.0.12.tgz#9f124b67594c937ff706932e4a642cca8dbbfee9"
+  resolved "https://registry.npmjs.org/dateformat/-/dateformat-1.0.12.tgz"
   integrity sha1-nxJLZ1lMk3/3BpMuSmQsyo27/uk=
   dependencies:
     get-stdin "^4.0.1"
@@ -3118,73 +3234,80 @@ dateformat@^1.0.6:
 
 dateformat@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae"
+  resolved "https://registry.npmjs.org/dateformat/-/dateformat-3.0.3.tgz"
   integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==
 
 de-indent@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/de-indent/-/de-indent-1.0.2.tgz#b2038e846dc33baa5796128d0804b455b8c1e21d"
+  resolved "https://registry.npmjs.org/de-indent/-/de-indent-1.0.2.tgz"
   integrity sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=
 
-debug@2, debug@2.6.9, debug@^2.1.2, debug@^2.2.0, debug@^2.3.3, debug@^2.6.8:
+debug@2, debug@2.6.9, debug@^2.2.0, debug@^2.3.3, debug@^2.6.8:
   version "2.6.9"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
+  resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
 debug@2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.2.0.tgz#f87057e995b1a1f6ae6a4960664137bc56f039da"
+  resolved "https://registry.npmjs.org/debug/-/debug-2.2.0.tgz"
   integrity sha1-+HBX6ZWxofauaklgZkE3vFbwOdo=
   dependencies:
     ms "0.7.1"
 
+debug@4:
+  version "4.3.4"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz"
+  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
+  dependencies:
+    ms "2.1.2"
+
 debug@4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.0.tgz#373687bffa678b38b1cd91f861b63850035ddc87"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.1.0.tgz"
   integrity sha512-heNPJUJIqC+xB6ayLAMHaIrmN9HKa7aQO8MGqKpvCA+uJYVcvR6l5kgdrhRuwPFHU7P5/A1w0BjByPHwpfTDKg==
   dependencies:
     ms "^2.1.1"
 
 debug@^3.1.0:
   version "3.2.6"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.6.tgz#e83d17de16d8a7efb7717edbe5fb10135eee629b"
+  resolved "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz"
   integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==
   dependencies:
     ms "^2.1.1"
 
 debug@^3.1.1:
   version "3.2.7"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
+  resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz"
   integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
   dependencies:
     ms "^2.1.1"
 
 debug@^4.0.1:
   version "4.1.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.1.1.tgz"
   integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==
   dependencies:
     ms "^2.1.1"
 
 debug@^4.1.0, debug@^4.1.1:
   version "4.3.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
+  resolved "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz"
   integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
   dependencies:
     ms "2.1.2"
 
 debug@~3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
+  resolved "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz"
   integrity sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==
   dependencies:
     ms "2.0.0"
 
 decamelize-keys@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9"
+  resolved "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.0.tgz"
   integrity sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=
   dependencies:
     decamelize "^1.1.0"
@@ -3192,70 +3315,65 @@ decamelize-keys@^1.0.0:
 
 decamelize@^1.1.0, decamelize@^1.1.2:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
+  resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz"
   integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
 
 decode-uri-component@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
+  resolved "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz"
   integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
 
 dedent@0.6.0:
   version "0.6.0"
-  resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.6.0.tgz#0e6da8f0ce52838ef5cec5c8f9396b0c1b64a3cb"
+  resolved "https://registry.npmjs.org/dedent/-/dedent-0.6.0.tgz"
   integrity sha1-Dm2o8M5Sg471zsXI+TlrDBtko8s=
 
 dedent@^0.7.0:
   version "0.7.0"
-  resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
+  resolved "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz"
   integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=
 
 deep-eql@0.1.3:
   version "0.1.3"
-  resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-0.1.3.tgz#ef558acab8de25206cd713906d74e56930eb69f2"
+  resolved "https://registry.npmjs.org/deep-eql/-/deep-eql-0.1.3.tgz"
   integrity sha1-71WKyrjeJSBs1xOQbXTlaTDrafI=
   dependencies:
     type-detect "0.1.1"
 
-deep-extend@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
-  integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
-
 deep-is@^0.1.3, deep-is@~0.1.3:
   version "0.1.3"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
+  resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz"
   integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
 
 deepmerge@^4.2.2:
   version "4.2.2"
-  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955"
+  resolved "https://registry.npmjs.org/deepmerge/-/deepmerge-4.2.2.tgz"
   integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==
 
 define-properties@^1.1.2, define-properties@^1.1.3:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
+  resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz"
   integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==
   dependencies:
     object-keys "^1.0.12"
 
 define-property@^0.2.5:
   version "0.2.5"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
+  resolved "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz"
   integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=
   dependencies:
     is-descriptor "^0.1.0"
 
 define-property@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
+  resolved "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz"
   integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY=
   dependencies:
     is-descriptor "^1.0.0"
 
 define-property@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
+  resolved "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz"
   integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==
   dependencies:
     is-descriptor "^1.0.2"
@@ -3263,7 +3381,7 @@ define-property@^2.0.2:
 
 degenerator@~1.0.2:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/degenerator/-/degenerator-1.0.4.tgz#fcf490a37ece266464d9cc431ab98c5819ced095"
+  resolved "https://registry.npmjs.org/degenerator/-/degenerator-1.0.4.tgz"
   integrity sha1-/PSQo37OJmRk2cxDGrmMWBnO0JU=
   dependencies:
     ast-types "0.x.x"
@@ -3272,7 +3390,7 @@ degenerator@~1.0.2:
 
 del@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/del/-/del-3.0.0.tgz#53ecf699ffcbcb39637691ab13baf160819766e5"
+  resolved "https://registry.npmjs.org/del/-/del-3.0.0.tgz"
   integrity sha1-U+z2mf/LyzljdpGrE7rxYIGXZuU=
   dependencies:
     globby "^6.1.0"
@@ -3282,24 +3400,38 @@ del@^3.0.0:
     pify "^3.0.0"
     rimraf "^2.2.8"
 
+del@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.npmjs.org/del/-/del-6.0.0.tgz"
+  integrity sha512-1shh9DQ23L16oXSZKB2JxpL7iMy2E0S9d517ptA1P8iw0alkPtQcrKH7ru31rYtKwF499HkTu+DRzq3TCKDFRQ==
+  dependencies:
+    globby "^11.0.1"
+    graceful-fs "^4.2.4"
+    is-glob "^4.0.1"
+    is-path-cwd "^2.2.0"
+    is-path-inside "^3.0.2"
+    p-map "^4.0.0"
+    rimraf "^3.0.2"
+    slash "^3.0.0"
+
 delayed-stream@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
+  resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz"
   integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
 
 delegates@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
+  resolved "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz"
   integrity sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=
 
 depd@~1.1.2:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9"
+  resolved "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz"
   integrity sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=
 
 des.js@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.0.tgz#c074d2e2aa6a8a9a07dbd61f9a15c2cd83ec8ecc"
+  resolved "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz"
   integrity sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=
   dependencies:
     inherits "^2.0.1"
@@ -3307,41 +3439,41 @@ des.js@^1.0.0:
 
 detect-file@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-0.1.0.tgz#4935dedfd9488648e006b0129566e9386711ea63"
+  resolved "https://registry.npmjs.org/detect-file/-/detect-file-0.1.0.tgz"
   integrity sha1-STXe39lIhkjgBrASlWbpOGcR6mM=
   dependencies:
     fs-exists-sync "^0.1.0"
 
 detect-indent@4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-4.0.0.tgz#f76d064352cdf43a1cb6ce619c4ee3a9475de208"
+  resolved "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz"
   integrity sha1-920GQ1LN9Docts5hnE7jqUdd4gg=
   dependencies:
     repeating "^2.0.0"
 
-detect-libc@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-1.0.3.tgz#fa137c4bd698edf55cd5cd02ac559f91a4c4ba9b"
-  integrity sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=
+detect-libc@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.1.tgz"
+  integrity sha512-463v3ZeIrcWtdgIg6vI6XUncguvr2TnGl4SzDXinkt9mSLpBJKXT3mW6xT3VQdDN11+WVs29pgvivTc4Lp8v+w==
 
 di@^0.0.1:
   version "0.0.1"
-  resolved "https://registry.yarnpkg.com/di/-/di-0.0.1.tgz#806649326ceaa7caa3306d75d985ea2748ba913c"
+  resolved "https://registry.npmjs.org/di/-/di-0.0.1.tgz"
   integrity sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=
 
 diff@1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-1.4.0.tgz#7f28d2eb9ee7b15a97efd89ce63dcfdaa3ccbabf"
+  resolved "https://registry.npmjs.org/diff/-/diff-1.4.0.tgz"
   integrity sha1-fyjS657nsVqX79ic5j3P2qPMur8=
 
 diff@^4.0.1:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
+  resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz"
   integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
 
 diffie-hellman@^5.0.0:
   version "5.0.3"
-  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
+  resolved "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz"
   integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==
   dependencies:
     bn.js "^4.1.0"
@@ -3350,21 +3482,21 @@ diffie-hellman@^5.0.0:
 
 dir-glob@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
+  resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz"
   integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
   dependencies:
     path-type "^4.0.0"
 
 doctrine@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
+  resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz"
   integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
   dependencies:
     esutils "^2.0.2"
 
 dom-serialize@^2.2.0:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/dom-serialize/-/dom-serialize-2.2.1.tgz#562ae8999f44be5ea3076f5419dcd59eb43ac95b"
+  resolved "https://registry.npmjs.org/dom-serialize/-/dom-serialize-2.2.1.tgz"
   integrity sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=
   dependencies:
     custom-event "~1.0.0"
@@ -3374,19 +3506,19 @@ dom-serialize@^2.2.0:
 
 domain-browser@^1.1.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-1.2.0.tgz#3d31f50191a6749dd1375a7f522e823d42e54eda"
+  resolved "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz"
   integrity sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==
 
 dot-prop@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-3.0.0.tgz#1b708af094a49c9a0e7dbcad790aba539dac1177"
+  resolved "https://registry.npmjs.org/dot-prop/-/dot-prop-3.0.0.tgz"
   integrity sha1-G3CK8JSknJoOfbyteQq6U52sEXc=
   dependencies:
     is-obj "^1.0.0"
 
 duplexify@^3.4.2, duplexify@^3.6.0:
   version "3.6.1"
-  resolved "https://registry.yarnpkg.com/duplexify/-/duplexify-3.6.1.tgz#b1a7a29c4abfd639585efaecce80d666b1e34125"
+  resolved "https://registry.npmjs.org/duplexify/-/duplexify-3.6.1.tgz"
   integrity sha512-vM58DwdnKmty+FSPzT14K9JXb90H+j5emaR4KYbr2KTIz00WHGbWOe5ghQTx233ZCLZtrGDALzKwcjEtSt35mA==
   dependencies:
     end-of-stream "^1.0.0"
@@ -3396,7 +3528,7 @@ duplexify@^3.4.2, duplexify@^3.6.0:
 
 ecc-jsbn@~0.1.1:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
+  resolved "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz"
   integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=
   dependencies:
     jsbn "~0.1.0"
@@ -3404,7 +3536,7 @@ ecc-jsbn@~0.1.1:
 
 ecstatic@^3.3.2:
   version "3.3.2"
-  resolved "https://registry.yarnpkg.com/ecstatic/-/ecstatic-3.3.2.tgz#6d1dd49814d00594682c652adb66076a69d46c48"
+  resolved "https://registry.npmjs.org/ecstatic/-/ecstatic-3.3.2.tgz"
   integrity sha512-fLf9l1hnwrHI2xn9mEDT7KIi22UDqA2jaCwyCbSUJh9a1V+LEUSL/JO/6TIz/QyuBURWUHrFL5Kg2TtO1bkkog==
   dependencies:
     he "^1.1.1"
@@ -3414,27 +3546,27 @@ ecstatic@^3.3.2:
 
 ee-first@1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
+  resolved "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz"
   integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
 
 ejs@2.5.7:
   version "2.5.7"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-2.5.7.tgz#cc872c168880ae3c7189762fd5ffc00896c9518a"
+  resolved "https://registry.npmjs.org/ejs/-/ejs-2.5.7.tgz"
   integrity sha1-zIcsFoiArjxxiXYv1f/ACJbJUYo=
 
 electron-to-chromium@^1.3.649:
   version "1.3.709"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.709.tgz#d7be0b5686a2fdfe8bad898faa3a428d04d8f656"
+  resolved "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.709.tgz"
   integrity sha512-LolItk2/ikSGQ7SN8UkuKVNMBZp3RG7Itgaxj1npsHRzQobj9JjMneZOZfLhtwlYBe5fCJ75k+cVCiDFUs23oA==
 
 elegant-spinner@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/elegant-spinner/-/elegant-spinner-1.0.1.tgz#db043521c95d7e303fd8f345bedc3349cfb0729e"
+  resolved "https://registry.npmjs.org/elegant-spinner/-/elegant-spinner-1.0.1.tgz"
   integrity sha1-2wQ1IcldfjA/2PNFvtwzSc+wcp4=
 
 elliptic@^6.0.0:
   version "6.5.4"
-  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
+  resolved "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz"
   integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
   dependencies:
     bn.js "^4.11.9"
@@ -3447,41 +3579,41 @@ elliptic@^6.0.0:
 
 emoji-regex@^8.0.0:
   version "8.0.0"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
+  resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
 emojis-list@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-2.1.0.tgz#4daa4d9db00f9819880c79fa457ae5b09a1fd389"
+  resolved "https://registry.npmjs.org/emojis-list/-/emojis-list-2.1.0.tgz"
   integrity sha1-TapNnbAPmBmIDHn6RXrlsJof04k=
 
 emojis-list@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
+  resolved "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz"
   integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
 
 encodeurl@~1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
+  resolved "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz"
   integrity sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=
 
 encoding@^0.1.11:
   version "0.1.12"
-  resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.12.tgz#538b66f3ee62cd1ab51ec323829d1f9480c74beb"
+  resolved "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz"
   integrity sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=
   dependencies:
     iconv-lite "~0.4.13"
 
 end-of-stream@^1.0.0, end-of-stream@^1.1.0:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.1.tgz#ed29634d19baba463b6ce6b80a37213eab71ec43"
+  resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz"
   integrity sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==
   dependencies:
     once "^1.4.0"
 
 engine.io-client@~3.2.0:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/engine.io-client/-/engine.io-client-3.2.1.tgz#6f54c0475de487158a1a7c77d10178708b6add36"
+  resolved "https://registry.npmjs.org/engine.io-client/-/engine.io-client-3.2.1.tgz"
   integrity sha512-y5AbkytWeM4jQr7m/koQLc5AxpRKC1hEVUb/s1FUAWEJq5AzJJ4NLvzuKPuxtDi5Mq755WuDvZ6Iv2rXj4PTzw==
   dependencies:
     component-emitter "1.2.1"
@@ -3498,7 +3630,7 @@ engine.io-client@~3.2.0:
 
 engine.io-parser@~2.1.0, engine.io-parser@~2.1.1:
   version "2.1.3"
-  resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-2.1.3.tgz#757ab970fbf2dfb32c7b74b033216d5739ef79a6"
+  resolved "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-2.1.3.tgz"
   integrity sha512-6HXPre2O4Houl7c4g7Ic/XzPnHBvaEmN90vtRO9uLmwtRqQmTOw0QMevL1TOfL2Cpu1VzsaTmMotQgMdkzGkVA==
   dependencies:
     after "0.8.2"
@@ -3509,7 +3641,7 @@ engine.io-parser@~2.1.0, engine.io-parser@~2.1.1:
 
 engine.io@~3.2.0:
   version "3.2.1"
-  resolved "https://registry.yarnpkg.com/engine.io/-/engine.io-3.2.1.tgz#b60281c35484a70ee0351ea0ebff83ec8c9522a2"
+  resolved "https://registry.npmjs.org/engine.io/-/engine.io-3.2.1.tgz"
   integrity sha512-+VlKzHzMhaU+GsCIg4AoXF1UdDFjHHwMmMKqMJNDNLlUlejz58FCy4LBqB2YVJskHGYl06BatYWKP2TVdVXE5w==
   dependencies:
     accepts "~1.3.4"
@@ -3521,7 +3653,7 @@ engine.io@~3.2.0:
 
 enhanced-resolve@^4.0.0:
   version "4.5.0"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec"
+  resolved "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz"
   integrity sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==
   dependencies:
     graceful-fs "^4.1.2"
@@ -3530,7 +3662,7 @@ enhanced-resolve@^4.0.0:
 
 enhanced-resolve@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.1.0.tgz#41c7e0bfdfe74ac1ffe1e57ad6a5c6c9f3742a7f"
+  resolved "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-4.1.0.tgz"
   integrity sha512-F/7vkyTtyc/llOIn8oWclcB25KdRaiPBpZYDgJHgh/UHtpgT2p2eldQgtQnLtUvfMKPKxbRaQM/hHkvLHt1Vng==
   dependencies:
     graceful-fs "^4.1.2"
@@ -3539,33 +3671,33 @@ enhanced-resolve@^4.1.0:
 
 enquirer@^2.3.5:
   version "2.3.6"
-  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
+  resolved "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz"
   integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
   dependencies:
     ansi-colors "^4.1.1"
 
 ent@~2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/ent/-/ent-2.2.0.tgz#e964219325a21d05f44466a2f686ed6ce5f5dd1d"
+  resolved "https://registry.npmjs.org/ent/-/ent-2.2.0.tgz"
   integrity sha1-6WQhkyWiHQX0RGai9obtbOX13R0=
 
 errno@^0.1.3, errno@~0.1.7:
   version "0.1.7"
-  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.7.tgz#4684d71779ad39af177e3f007996f7c67c852618"
+  resolved "https://registry.npmjs.org/errno/-/errno-0.1.7.tgz"
   integrity sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==
   dependencies:
     prr "~1.0.1"
 
 error-ex@^1.2.0, error-ex@^1.3.1:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
+  resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz"
   integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
   dependencies:
     is-arrayish "^0.2.1"
 
 es-abstract@^1.5.1:
   version "1.13.0"
-  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.13.0.tgz#ac86145fdd5099d8dd49558ccba2eaf9b88e24e9"
+  resolved "https://registry.npmjs.org/es-abstract/-/es-abstract-1.13.0.tgz"
   integrity sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==
   dependencies:
     es-to-primitive "^1.2.0"
@@ -3577,7 +3709,7 @@ es-abstract@^1.5.1:
 
 es-to-primitive@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.0.tgz#edf72478033456e8dda8ef09e00ad9650707f377"
+  resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.0.tgz"
   integrity sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==
   dependencies:
     is-callable "^1.1.4"
@@ -3586,39 +3718,39 @@ es-to-primitive@^1.2.0:
 
 es6-promise@^4.0.3, es6-promise@^4.1.0:
   version "4.2.5"
-  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.5.tgz#da6d0d5692efb461e082c14817fe2427d8f5d054"
+  resolved "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.5.tgz"
   integrity sha512-n6wvpdE43VFtJq+lUDYDBFUwV8TZbuGXLV4D6wKafg13ldznKsyEvatubnmUe31zcvelSzOHF+XbaT+Bl9ObDg==
 
 es6-promise@~3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-3.0.2.tgz#010d5858423a5f118979665f46486a95c6ee2bb6"
+  resolved "https://registry.npmjs.org/es6-promise/-/es6-promise-3.0.2.tgz"
   integrity sha1-AQ1YWEI6XxGJeWZfRkhqlcbuK7Y=
 
 es6-promisify@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-5.0.0.tgz#5109d62f3e56ea967c4b63505aef08291c8a5203"
+  resolved "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz"
   integrity sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=
   dependencies:
     es6-promise "^4.0.3"
 
 escalade@^3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
+  resolved "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz"
   integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
 
 escape-html@~1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
+  resolved "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz"
   integrity sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=
 
 escape-string-regexp@1.0.5, escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.4, escape-string-regexp@^1.0.5:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
+  resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz"
   integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
 
 escodegen@1.8.x:
   version "1.8.1"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.8.1.tgz#5a5b53af4693110bebb0867aa3430dd3b70a1018"
+  resolved "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz"
   integrity sha1-WltTr0aTEQvrsIZ6o0MN07cKEBg=
   dependencies:
     esprima "^2.7.1"
@@ -3630,7 +3762,7 @@ escodegen@1.8.x:
 
 escodegen@1.x.x, escodegen@^1.8.1:
   version "1.11.0"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.11.0.tgz#b27a9389481d5bfd5bec76f7bb1eb3f8f4556589"
+  resolved "https://registry.npmjs.org/escodegen/-/escodegen-1.11.0.tgz"
   integrity sha512-IeMV45ReixHS53K/OmfKAIztN/igDHzTJUhZM3k1jMhIZWjk45SMwAtBsEXiJp3vSPmTcu6CXn7mDvFHRN66fw==
   dependencies:
     esprima "^3.1.3"
@@ -3642,19 +3774,19 @@ escodegen@1.x.x, escodegen@^1.8.1:
 
 eslint-plugin-flowtype@^2.34.0:
   version "2.50.3"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-flowtype/-/eslint-plugin-flowtype-2.50.3.tgz#61379d6dce1d010370acd6681740fd913d68175f"
+  resolved "https://registry.npmjs.org/eslint-plugin-flowtype/-/eslint-plugin-flowtype-2.50.3.tgz"
   integrity sha512-X+AoKVOr7Re0ko/yEXyM5SSZ0tazc6ffdIOocp2fFUlWoDt7DV0Bz99mngOkAFLOAWjqRA5jPwqUCbrx13XoxQ==
   dependencies:
     lodash "^4.17.10"
 
 eslint-plugin-jasmine@^2.8.4:
   version "2.10.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-jasmine/-/eslint-plugin-jasmine-2.10.1.tgz#5733b709e751f4bc40e31e1c16989bd2cdfbec97"
+  resolved "https://registry.npmjs.org/eslint-plugin-jasmine/-/eslint-plugin-jasmine-2.10.1.tgz"
   integrity sha1-VzO3CedR9LxA4x4cFpib0s377Jc=
 
 eslint-scope@3.7.1:
   version "3.7.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-3.7.1.tgz#3d63c3edfda02e06e01a452ad88caacc7cdcb6e8"
+  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.1.tgz"
   integrity sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=
   dependencies:
     esrecurse "^4.1.0"
@@ -3662,7 +3794,7 @@ eslint-scope@3.7.1:
 
 eslint-scope@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-4.0.0.tgz#50bf3071e9338bcdc43331794a0cb533f0136172"
+  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.0.tgz"
   integrity sha512-1G6UTDi7Jc1ELFwnR58HV4fK9OQK4S6N985f166xqXxpjU6plxFISJa2Ba9KCQuFa8RCnj/lSFJbHo7UFDBnUA==
   dependencies:
     esrecurse "^4.1.0"
@@ -3670,7 +3802,7 @@ eslint-scope@^4.0.0:
 
 eslint-scope@^5.0.0, eslint-scope@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
+  resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz"
   integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
   dependencies:
     esrecurse "^4.3.0"
@@ -3678,29 +3810,29 @@ eslint-scope@^5.0.0, eslint-scope@^5.1.1:
 
 eslint-utils@^2.0.0, eslint-utils@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-2.1.0.tgz#d2de5e03424e707dc10c74068ddedae708741b27"
+  resolved "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz"
   integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==
   dependencies:
     eslint-visitor-keys "^1.1.0"
 
 eslint-visitor-keys@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz#e2a82cea84ff246ad6fb57f9bde5b46621459ec2"
+  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz"
   integrity sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==
 
 eslint-visitor-keys@^1.1.0, eslint-visitor-keys@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e"
+  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz"
   integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==
 
 eslint-visitor-keys@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz#21fdc8fbcd9c795cc0321f0563702095751511a8"
+  resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz"
   integrity sha512-QudtT6av5WXels9WjIM7qz1XD1cWGvX4gGXvp/zBn9nXG02D0utdU3Em2m/QjTnrsk6bBjmCygl3rmj118msQQ==
 
 eslint@^7.23.0:
   version "7.23.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.23.0.tgz#8d029d252f6e8cf45894b4bee08f5493f8e94325"
+  resolved "https://registry.npmjs.org/eslint/-/eslint-7.23.0.tgz"
   integrity sha512-kqvNVbdkjzpFy0XOszNwjkKzZ+6TcwCQ/h+ozlcIWwaimBBuhlQ4nN6kbiM2L+OjDcznkTJxzYfRFH92sx4a0Q==
   dependencies:
     "@babel/code-frame" "7.12.11"
@@ -3743,7 +3875,7 @@ eslint@^7.23.0:
 
 espree@^7.3.0, espree@^7.3.1:
   version "7.3.1"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-7.3.1.tgz#f2df330b752c6f55019f8bd89b7660039c1bbbb6"
+  resolved "https://registry.npmjs.org/espree/-/espree-7.3.1.tgz"
   integrity sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g==
   dependencies:
     acorn "^7.4.0"
@@ -3752,83 +3884,83 @@ espree@^7.3.0, espree@^7.3.1:
 
 esprima@2.7.x, esprima@^2.7.1:
   version "2.7.3"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-2.7.3.tgz#96e3b70d5779f6ad49cd032673d1c312767ba581"
+  resolved "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz"
   integrity sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=
 
 esprima@3.x.x, esprima@^3.1.3:
   version "3.1.3"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-3.1.3.tgz#fdca51cee6133895e3c88d535ce49dbff62a4633"
+  resolved "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz"
   integrity sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=
 
 esprima@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
+  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
 esquery@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5"
+  resolved "https://registry.npmjs.org/esquery/-/esquery-1.4.0.tgz"
   integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==
   dependencies:
     estraverse "^5.1.0"
 
 esrecurse@^4.1.0:
   version "4.2.1"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.2.1.tgz#007a3b9fdbc2b3bb87e4879ea19c92fdbd3942cf"
+  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.1.tgz"
   integrity sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==
   dependencies:
     estraverse "^4.1.0"
 
 esrecurse@^4.3.0:
   version "4.3.0"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
+  resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz"
   integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
   dependencies:
     estraverse "^5.2.0"
 
 estraverse@^1.9.1:
   version "1.9.3"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-1.9.3.tgz#af67f2dc922582415950926091a4005d29c9bb44"
+  resolved "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz"
   integrity sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=
 
 estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
+  resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz"
   integrity sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=
 
 estraverse@^5.1.0, estraverse@^5.2.0:
   version "5.2.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.2.0.tgz#307df42547e6cc7324d3cf03c155d5cdb8c53880"
+  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz"
   integrity sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==
 
 estree-walker@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-1.0.1.tgz#31bc5d612c96b704106b477e6dd5d8aa138cb700"
+  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz"
   integrity sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==
 
 estree-walker@^2.0.1:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
+  resolved "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz"
   integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
 
 esutils@^2.0.2:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
+  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
 eventemitter3@^4.0.0:
   version "4.0.7"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
+  resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz"
   integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
 
 events@^1.0.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/events/-/events-1.1.1.tgz#9ebdb7635ad099c70dcc4c2a1f5004288e8bd924"
+  resolved "https://registry.npmjs.org/events/-/events-1.1.1.tgz"
   integrity sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=
 
 evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
+  resolved "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz"
   integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
   dependencies:
     md5.js "^1.3.4"
@@ -3836,7 +3968,7 @@ evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
 
 execa@^0.8.0:
   version "0.8.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-0.8.0.tgz#d8d76bbc1b55217ed190fd6dd49d3c774ecfc8da"
+  resolved "https://registry.npmjs.org/execa/-/execa-0.8.0.tgz"
   integrity sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=
   dependencies:
     cross-spawn "^5.0.1"
@@ -3849,7 +3981,7 @@ execa@^0.8.0:
 
 execa@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-1.0.0.tgz#c6236a5bb4df6d6f15e88e7f017798216749ddd8"
+  resolved "https://registry.npmjs.org/execa/-/execa-1.0.0.tgz"
   integrity sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==
   dependencies:
     cross-spawn "^6.0.0"
@@ -3862,17 +3994,17 @@ execa@^1.0.0:
 
 exit-hook@^1.0.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/exit-hook/-/exit-hook-1.1.1.tgz#f05ca233b48c05d54fff07765df8507e95c02ff8"
+  resolved "https://registry.npmjs.org/exit-hook/-/exit-hook-1.1.1.tgz"
   integrity sha1-8FyiM7SMBdVP/wd2XfhQfpXAL/g=
 
 exit@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
+  resolved "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz"
   integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=
 
 expand-braces@^0.1.1:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/expand-braces/-/expand-braces-0.1.2.tgz#488b1d1d2451cb3d3a6b192cfc030f44c5855fea"
+  resolved "https://registry.npmjs.org/expand-braces/-/expand-braces-0.1.2.tgz"
   integrity sha1-SIsdHSRRyz06axks/AMPRMWFX+o=
   dependencies:
     array-slice "^0.2.3"
@@ -3881,14 +4013,14 @@ expand-braces@^0.1.1:
 
 expand-brackets@^0.1.4:
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b"
+  resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz"
   integrity sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=
   dependencies:
     is-posix-bracket "^0.1.0"
 
 expand-brackets@^2.1.4:
   version "2.1.4"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
+  resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz"
   integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI=
   dependencies:
     debug "^2.3.3"
@@ -3901,7 +4033,7 @@ expand-brackets@^2.1.4:
 
 expand-range@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-0.1.1.tgz#4cb8eda0993ca56fa4f41fc42f3cbb4ccadff044"
+  resolved "https://registry.npmjs.org/expand-range/-/expand-range-0.1.1.tgz"
   integrity sha1-TLjtoJk8pW+k9B/ELzy7TMrf8EQ=
   dependencies:
     is-number "^0.1.1"
@@ -3909,28 +4041,28 @@ expand-range@^0.1.0:
 
 expand-range@^1.8.1:
   version "1.8.2"
-  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337"
+  resolved "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz"
   integrity sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=
   dependencies:
     fill-range "^2.1.0"
 
 expand-tilde@^1.2.2:
   version "1.2.2"
-  resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-1.2.2.tgz#0b81eba897e5a3d31d1c3d102f8f01441e559449"
+  resolved "https://registry.npmjs.org/expand-tilde/-/expand-tilde-1.2.2.tgz"
   integrity sha1-C4HrqJflo9MdHD0QL48BRB5VlEk=
   dependencies:
     os-homedir "^1.0.1"
 
 extend-shallow@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
+  resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz"
   integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=
   dependencies:
     is-extendable "^0.1.0"
 
 extend-shallow@^3.0.0, extend-shallow@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
+  resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz"
   integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=
   dependencies:
     assign-symbols "^1.0.0"
@@ -3938,12 +4070,12 @@ extend-shallow@^3.0.0, extend-shallow@^3.0.2:
 
 extend@3, extend@^3.0.0, extend@~3.0.0, extend@~3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
+  resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
 external-editor@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-1.1.1.tgz#12d7b0db850f7ff7e7081baf4005700060c4600b"
+  resolved "https://registry.npmjs.org/external-editor/-/external-editor-1.1.1.tgz"
   integrity sha1-Etew24UPf/fnCBuvQAVwAGDEYAs=
   dependencies:
     extend "^3.0.0"
@@ -3952,7 +4084,7 @@ external-editor@^1.1.0:
 
 external-editor@^2.0.1:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-2.2.0.tgz#045511cfd8d133f3846673d1047c154e214ad3d5"
+  resolved "https://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz"
   integrity sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==
   dependencies:
     chardet "^0.4.0"
@@ -3961,14 +4093,14 @@ external-editor@^2.0.1:
 
 extglob@^0.3.1:
   version "0.3.2"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1"
+  resolved "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz"
   integrity sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=
   dependencies:
     is-extglob "^1.0.0"
 
 extglob@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
+  resolved "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz"
   integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==
   dependencies:
     array-unique "^0.3.2"
@@ -3980,9 +4112,9 @@ extglob@^2.0.4:
     snapdragon "^0.8.1"
     to-regex "^3.0.1"
 
-extract-zip@^1.6.5, extract-zip@^1.6.6, extract-zip@^1.6.7:
+extract-zip@^1.6.5, extract-zip@^1.6.6:
   version "1.6.7"
-  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-1.6.7.tgz#a840b4b8af6403264c8db57f4f1a74333ef81fe9"
+  resolved "https://registry.npmjs.org/extract-zip/-/extract-zip-1.6.7.tgz"
   integrity sha1-qEC0uK9kAyZMjbV/Txp0Mz74H+k=
   dependencies:
     concat-stream "1.6.2"
@@ -3990,29 +4122,40 @@ extract-zip@^1.6.5, extract-zip@^1.6.6, extract-zip@^1.6.7:
     mkdirp "0.5.1"
     yauzl "2.4.1"
 
+extract-zip@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz"
+  integrity sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==
+  dependencies:
+    debug "^4.1.1"
+    get-stream "^5.1.0"
+    yauzl "^2.10.0"
+  optionalDependencies:
+    "@types/yauzl" "^2.9.1"
+
 extsprintf@1.3.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
+  resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz"
   integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=
 
 extsprintf@^1.2.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.0.tgz#e2689f8f356fad62cca65a3a91c5df5f9551692f"
+  resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.0.tgz"
   integrity sha1-4mifjzVvrWLMplo6kcXfX5VRaS8=
 
 fast-deep-equal@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz#7b05218ddf9667bf7f370bf7fdb2cb15fdd0aa49"
+  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz"
   integrity sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=
 
 fast-deep-equal@^3.1.1:
   version "3.1.3"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
+  resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz"
   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
 
 fast-glob@^3.1.1:
   version "3.2.5"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.5.tgz#7939af2a656de79a4f1901903ee8adcaa7cb9661"
+  resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.5.tgz"
   integrity sha512-2DtFcgT68wiTTiwZ2hNdJfcHNke9XOfnwmBRWXhmeKM8rF0TGwmC/Qto3S7RoZKp5cilZbxzO5iTNTQsJ+EeDg==
   dependencies:
     "@nodelib/fs.stat" "^2.0.2"
@@ -4024,36 +4167,43 @@ fast-glob@^3.1.1:
 
 fast-json-stable-stringify@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz#d5142c0caee6b1189f87d3a76111064f86c8bbf2"
+  resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz"
   integrity sha1-1RQsDK7msRifh9OnYREGT4bIu/I=
 
 fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.4:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
+  resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz"
   integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
 
 fastq@^1.6.0:
   version "1.11.0"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.11.0.tgz#bb9fb955a07130a918eb63c1f5161cc32a5d0858"
+  resolved "https://registry.npmjs.org/fastq/-/fastq-1.11.0.tgz"
   integrity sha512-7Eczs8gIPDrVzT+EksYBcupqMyxSHXXrHOLRRxU2/DicV8789MRBRR8+Hc2uWzUupOs4YS4JzBmBxjjCVBxD/g==
   dependencies:
     reusify "^1.0.4"
 
 fd-slicer@~1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.0.1.tgz#8b5bcbd9ec327c5041bf9ab023fd6750f1177e65"
+  resolved "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.0.1.tgz"
   integrity sha1-i1vL2ewyfFBBv5qwI/1nUPEXfmU=
   dependencies:
     pend "~1.2.0"
 
+fd-slicer@~1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz"
+  integrity sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=
+  dependencies:
+    pend "~1.2.0"
+
 figgy-pudding@^3.5.1:
   version "3.5.1"
-  resolved "https://registry.yarnpkg.com/figgy-pudding/-/figgy-pudding-3.5.1.tgz#862470112901c727a0e495a80744bd5baa1d6790"
+  resolved "https://registry.npmjs.org/figgy-pudding/-/figgy-pudding-3.5.1.tgz"
   integrity sha512-vNKxJHTEKNThjfrdJwHc7brvM6eVevuO5nTj6ez8ZQ1qbXTvGthucRF7S4vf2cr71QVnT70V34v0S1DyQsti0w==
 
 figures@^1.3.5, figures@^1.7.0:
   version "1.7.0"
-  resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e"
+  resolved "https://registry.npmjs.org/figures/-/figures-1.7.0.tgz"
   integrity sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=
   dependencies:
     escape-string-regexp "^1.0.5"
@@ -4061,39 +4211,39 @@ figures@^1.3.5, figures@^1.7.0:
 
 figures@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
+  resolved "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz"
   integrity sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=
   dependencies:
     escape-string-regexp "^1.0.5"
 
 file-entry-cache@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
+  resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz"
   integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
   dependencies:
     flat-cache "^3.0.4"
 
 file-loader@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-3.0.1.tgz#f8e0ba0b599918b51adfe45d66d1e771ad560faa"
+  resolved "https://registry.npmjs.org/file-loader/-/file-loader-3.0.1.tgz"
   integrity sha512-4sNIOXgtH/9WZq4NvlfU3Opn5ynUsqBwSLyM+I7UOwdGigTBYfVVQEwe/msZNX/j4pCJTIM14Fsw66Svo1oVrw==
   dependencies:
     loader-utils "^1.0.2"
     schema-utils "^1.0.0"
 
-file-uri-to-path@1:
+file-uri-to-path@1, file-uri-to-path@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
   integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
 
 filename-regex@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.1.tgz#c1c4b9bee3e09725ddb106b75c1e301fe2f18b26"
+  resolved "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz"
   integrity sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=
 
 fill-range@^2.1.0:
   version "2.2.4"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.4.tgz#eb1e773abb056dcd8df2bfdf6af59b8b3a936565"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz"
   integrity sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==
   dependencies:
     is-number "^2.1.0"
@@ -4104,7 +4254,7 @@ fill-range@^2.1.0:
 
 fill-range@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz"
   integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=
   dependencies:
     extend-shallow "^2.0.1"
@@ -4114,14 +4264,14 @@ fill-range@^4.0.0:
 
 fill-range@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
+  resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz"
   integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
   dependencies:
     to-regex-range "^5.0.1"
 
 finalhandler@1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.1.0.tgz#ce0b6855b45853e791b2fcc680046d88253dd7f5"
+  resolved "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.0.tgz"
   integrity sha1-zgtoVbRYU+eRsvzGgARtiCU91/U=
   dependencies:
     debug "2.6.9"
@@ -4134,7 +4284,7 @@ finalhandler@1.1.0:
 
 find-cache-dir@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-2.0.0.tgz#4c1faed59f45184530fb9d7fa123a4d04a98472d"
+  resolved "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-2.0.0.tgz"
   integrity sha512-LDUY6V1Xs5eFskUVYtIwatojt6+9xC9Chnlk/jYOOvn3FAFfSaWddxahDGyNHh0b2dMXa6YW2m0tk8TdVaXHlA==
   dependencies:
     commondir "^1.0.1"
@@ -4143,7 +4293,7 @@ find-cache-dir@^2.0.0:
 
 find-cache-dir@^3.3.1:
   version "3.3.1"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.1.tgz#89b33fad4a4670daa94f855f7fbe31d6d84fe880"
+  resolved "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.1.tgz"
   integrity sha512-t2GDMt3oGC/v+BMwzmllWDuJF/xcDtE5j/fCGbqDD7OLuJkj0cfh1YSA5VKPvwMeLFLNDBkwOKZ2X85jGLVftQ==
   dependencies:
     commondir "^1.0.1"
@@ -4152,7 +4302,7 @@ find-cache-dir@^3.3.1:
 
 find-node-modules@1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/find-node-modules/-/find-node-modules-1.0.4.tgz#b6deb3cccb699c87037677bcede2c5f5862b2550"
+  resolved "https://registry.npmjs.org/find-node-modules/-/find-node-modules-1.0.4.tgz"
   integrity sha1-tt6zzMtpnIcDdne87eLF9YYrJVA=
   dependencies:
     findup-sync "0.4.2"
@@ -4160,17 +4310,17 @@ find-node-modules@1.0.4:
 
 find-parent-dir@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/find-parent-dir/-/find-parent-dir-0.3.0.tgz#33c44b429ab2b2f0646299c5f9f718f376ff8d54"
+  resolved "https://registry.npmjs.org/find-parent-dir/-/find-parent-dir-0.3.0.tgz"
   integrity sha1-M8RLQpqysvBkYpnF+fcY83b/jVQ=
 
 find-root@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/find-root/-/find-root-1.0.0.tgz#962ff211aab25c6520feeeb8d6287f8f6e95807a"
+  resolved "https://registry.npmjs.org/find-root/-/find-root-1.0.0.tgz"
   integrity sha1-li/yEaqyXGUg/u641ih/j26VgHo=
 
 find-up@^1.0.0:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz"
   integrity sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=
   dependencies:
     path-exists "^2.0.0"
@@ -4178,21 +4328,21 @@ find-up@^1.0.0:
 
 find-up@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz"
   integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c=
   dependencies:
     locate-path "^2.0.0"
 
 find-up@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz"
   integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
   dependencies:
     locate-path "^3.0.0"
 
 find-up@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
+  resolved "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz"
   integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
   dependencies:
     locate-path "^5.0.0"
@@ -4200,7 +4350,7 @@ find-up@^4.0.0:
 
 findup-sync@0.4.2:
   version "0.4.2"
-  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-0.4.2.tgz#a8117d0f73124f5a4546839579fe52d7129fb5e5"
+  resolved "https://registry.npmjs.org/findup-sync/-/findup-sync-0.4.2.tgz"
   integrity sha1-qBF9D3MST1pFRoOVef5S1xKfteU=
   dependencies:
     detect-file "^0.1.0"
@@ -4210,7 +4360,7 @@ findup-sync@0.4.2:
 
 flat-cache@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
+  resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz"
   integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
   dependencies:
     flatted "^3.1.0"
@@ -4218,22 +4368,22 @@ flat-cache@^3.0.4:
 
 flatted@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-2.0.0.tgz#55122b6536ea496b4b44893ee2608141d10d9916"
+  resolved "https://registry.npmjs.org/flatted/-/flatted-2.0.0.tgz"
   integrity sha512-R+H8IZclI8AAkSBRQJLVOsxwAoHd6WC40b4QTNWIjzAa6BXOBfQcM587MXDTVPeYaopFNWHUFLx7eNmHDSxMWg==
 
 flatted@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.1.1.tgz#c4b489e80096d9df1dfc97c79871aea7c617c469"
+  resolved "https://registry.npmjs.org/flatted/-/flatted-3.1.1.tgz"
   integrity sha512-zAoAQiudy+r5SvnSw3KJy5os/oRJYHzrzja/tBDqrZtNhUw8bt6y8OBzMWcjWr+8liV8Eb6yOhw8WZ7VFZ5ZzA==
 
 flow-bin@^0.61.0:
   version "0.61.0"
-  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.61.0.tgz#d0473a8c35dbbf4de573823f4932124397d32d35"
+  resolved "https://registry.npmjs.org/flow-bin/-/flow-bin-0.61.0.tgz"
   integrity sha512-w6SGi5CDfKLNGzYssRhW6N37qKclDXijsxDQ5M8c3WbivRYta0Horv22bwakegfKBVDnyeS0lRW3OqBC74eq2g==
 
 flush-write-stream@^1.0.0:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/flush-write-stream/-/flush-write-stream-1.0.3.tgz#c5d586ef38af6097650b49bc41b55fabb19f35bd"
+  resolved "https://registry.npmjs.org/flush-write-stream/-/flush-write-stream-1.0.3.tgz"
   integrity sha512-calZMC10u0FMUqoiunI2AiGIIUtUIvifNwkHhNupZH4cbNnW1Itkoh/Nf5HFYmDrwWPjrUxpkZT0KhuCq0jmGw==
   dependencies:
     inherits "^2.0.1"
@@ -4241,29 +4391,34 @@ flush-write-stream@^1.0.0:
 
 follow-redirects@^1.0.0:
   version "1.13.0"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.13.0.tgz#b42e8d93a2a7eea5ed88633676d6597bc8e384db"
+  resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.13.0.tgz"
   integrity sha512-aq6gF1BEKje4a9i9+5jimNFIpq4Q1WiwBToeRK5NvZBd/TRsmW8BsJfOEGkr76TbOyPVD3OVDN910EcUNtRYEA==
 
+follow-redirects@^1.14.0:
+  version "1.14.9"
+  resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz"
+  integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==
+
 for-in@^1.0.1, for-in@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
+  resolved "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz"
   integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
 
 for-own@^0.1.4:
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce"
+  resolved "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz"
   integrity sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=
   dependencies:
     for-in "^1.0.1"
 
 forever-agent@~0.6.1:
   version "0.6.1"
-  resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
+  resolved "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz"
   integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=
 
 form-data@~2.3.2:
   version "2.3.3"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
+  resolved "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz"
   integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
   dependencies:
     asynckit "^0.4.0"
@@ -4272,14 +4427,14 @@ form-data@~2.3.2:
 
 fragment-cache@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
+  resolved "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz"
   integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=
   dependencies:
     map-cache "^0.2.2"
 
 from2@^2.1.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/from2/-/from2-2.3.0.tgz#8bfb5502bde4a4d36cfdeea007fcca21d7e382af"
+  resolved "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz"
   integrity sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=
   dependencies:
     inherits "^2.0.1"
@@ -4287,19 +4442,19 @@ from2@^2.1.0:
 
 fs-access@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/fs-access/-/fs-access-1.0.1.tgz#d6a87f262271cefebec30c553407fb995da8777a"
+  resolved "https://registry.npmjs.org/fs-access/-/fs-access-1.0.1.tgz"
   integrity sha1-1qh/JiJxzv6+wwxVNAf7mV2od3o=
   dependencies:
     null-check "^1.0.0"
 
 fs-exists-sync@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/fs-exists-sync/-/fs-exists-sync-0.1.0.tgz#982d6893af918e72d08dec9e8673ff2b5a8d6add"
+  resolved "https://registry.npmjs.org/fs-exists-sync/-/fs-exists-sync-0.1.0.tgz"
   integrity sha1-mC1ok6+RjnLQjeyehnP/K1qNat0=
 
 fs-extra@8.1.0:
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0"
+  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz"
   integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
   dependencies:
     graceful-fs "^4.2.0"
@@ -4308,23 +4463,23 @@ fs-extra@8.1.0:
 
 fs-extra@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-1.0.0.tgz#cd3ce5f7e7cb6145883fcae3191e9877f8587950"
+  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-1.0.0.tgz"
   integrity sha1-zTzl9+fLYUWIP8rjGR6Yd/hYeVA=
   dependencies:
     graceful-fs "^4.1.2"
     jsonfile "^2.1.0"
     klaw "^1.0.0"
 
-fs-minipass@^1.2.5:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.5.tgz#06c277218454ec288df77ada54a03b8702aacb9d"
-  integrity sha512-JhBl0skXjUPCFH7x6x61gQxrKyXsxB5gcgePLZCwfyCGGsTISMoIeObbrvVeP6Xmyaudw4TT43qV2Gz+iyd2oQ==
+fs-minipass@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz"
+  integrity sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==
   dependencies:
-    minipass "^2.2.1"
+    minipass "^3.0.0"
 
 fs-write-stream-atomic@^1.0.8:
   version "1.0.10"
-  resolved "https://registry.yarnpkg.com/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz#b47df53493ef911df75731e70a9ded0189db40c9"
+  resolved "https://registry.npmjs.org/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz"
   integrity sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=
   dependencies:
     graceful-fs "^4.1.2"
@@ -4334,25 +4489,25 @@ fs-write-stream-atomic@^1.0.8:
 
 fs.realpath@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+  resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz"
   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
 
-fsevents@^1.2.2:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.2.4.tgz#f41dcb1af2582af3692da36fc55cbd8e1041c426"
-  integrity sha512-z8H8/diyk76B7q5wg+Ud0+CqzcAF3mBBI/bA5ne5zrRUUIvNkJY//D3BqyH571KuAC4Nr7Rw7CjWX4r0y9DvNg==
-  dependencies:
-    nan "^2.9.2"
-    node-pre-gyp "^0.10.0"
-
-fsevents@~2.3.1:
+fsevents@2.3.2, fsevents@~2.3.1, fsevents@~2.3.2:
   version "2.3.2"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
+  resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz"
   integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
 
+fsevents@^1.2.2:
+  version "1.2.13"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.2.13.tgz#f325cb0455592428bcf11b383370ef70e3bfcc38"
+  integrity sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==
+  dependencies:
+    bindings "^1.5.0"
+    nan "^2.12.1"
+
 ftp@~0.3.10:
   version "0.3.10"
-  resolved "https://registry.yarnpkg.com/ftp/-/ftp-0.3.10.tgz#9197d861ad8142f3e63d5a83bfe4c59f7330885d"
+  resolved "https://registry.npmjs.org/ftp/-/ftp-0.3.10.tgz"
   integrity sha1-kZfYYa2BQvPmPVqDv+TFn3MwiF0=
   dependencies:
     readable-stream "1.1.x"
@@ -4360,50 +4515,51 @@ ftp@~0.3.10:
 
 function-bind@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+  resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz"
   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 
 functional-red-black-tree@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
+  resolved "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz"
   integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=
 
 g-status@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/g-status/-/g-status-2.0.2.tgz#270fd32119e8fc9496f066fe5fe88e0a6bc78b97"
+  resolved "https://registry.npmjs.org/g-status/-/g-status-2.0.2.tgz"
   integrity sha512-kQoE9qH+T1AHKgSSD0Hkv98bobE90ILQcXAF4wvGgsr7uFqNvwmh8j+Lq3l0RVt3E3HjSbv2B9biEGcEtpHLCA==
   dependencies:
     arrify "^1.0.1"
     matcher "^1.0.0"
     simple-git "^1.85.0"
 
-gauge@~2.7.3:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
-  integrity sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=
+gauge@^3.0.0:
+  version "3.0.2"
+  resolved "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz"
+  integrity sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==
   dependencies:
-    aproba "^1.0.3"
+    aproba "^1.0.3 || ^2.0.0"
+    color-support "^1.1.2"
     console-control-strings "^1.0.0"
-    has-unicode "^2.0.0"
-    object-assign "^4.1.0"
+    has-unicode "^2.0.1"
+    object-assign "^4.1.1"
     signal-exit "^3.0.0"
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wide-align "^1.1.0"
+    string-width "^4.2.3"
+    strip-ansi "^6.0.1"
+    wide-align "^1.1.2"
 
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
-  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
+  resolved "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz"
   integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
 
 get-caller-file@^2.0.5:
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
+  resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
 get-intrinsic@^1.0.2:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
+  resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz"
   integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==
   dependencies:
     function-bind "^1.1.1"
@@ -4412,12 +4568,12 @@ get-intrinsic@^1.0.2:
 
 get-own-enumerable-property-symbols@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.0.tgz#b877b49a5c16aefac3655f2ed2ea5b684df8d203"
+  resolved "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.0.tgz"
   integrity sha512-CIJYJC4GGF06TakLg8z4GQKvDsx9EMspVxOYih7LerEL/WosUnFIww45CGfxfeKHqlg3twgUrYRT1O3WQqjGCg==
 
 get-pkg-repo@^1.0.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/get-pkg-repo/-/get-pkg-repo-1.4.0.tgz#c73b489c06d80cc5536c2c853f9e05232056972d"
+  resolved "https://registry.npmjs.org/get-pkg-repo/-/get-pkg-repo-1.4.0.tgz"
   integrity sha1-xztInAbYDMVTbCyFP54FIyBWly0=
   dependencies:
     hosted-git-info "^2.1.4"
@@ -4428,24 +4584,31 @@ get-pkg-repo@^1.0.0:
 
 get-stdin@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
+  resolved "https://registry.npmjs.org/get-stdin/-/get-stdin-4.0.1.tgz"
   integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=
 
 get-stream@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"
+  resolved "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz"
   integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=
 
 get-stream@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
+  resolved "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz"
   integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
   dependencies:
     pump "^3.0.0"
 
+get-stream@^5.1.0:
+  version "5.2.0"
+  resolved "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz"
+  integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==
+  dependencies:
+    pump "^3.0.0"
+
 get-uri@2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/get-uri/-/get-uri-2.0.2.tgz#5c795e71326f6ca1286f2fc82575cd2bab2af578"
+  resolved "https://registry.npmjs.org/get-uri/-/get-uri-2.0.2.tgz"
   integrity sha512-ZD325dMZOgerGqF/rF6vZXyFGTAay62svjQIT+X/oU2PtxYpFxvSkbsdi+oxIrsNxlZVd4y8wUDqkaExWTI/Cw==
   dependencies:
     data-uri-to-buffer "1"
@@ -4457,19 +4620,19 @@ get-uri@2:
 
 get-value@^2.0.3, get-value@^2.0.6:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
+  resolved "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz"
   integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=
 
 getpass@^0.1.1:
   version "0.1.7"
-  resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
+  resolved "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz"
   integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=
   dependencies:
     assert-plus "^1.0.0"
 
 git-raw-commits@^1.3.6:
   version "1.3.6"
-  resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-1.3.6.tgz#27c35a32a67777c1ecd412a239a6c19d71b95aff"
+  resolved "https://registry.npmjs.org/git-raw-commits/-/git-raw-commits-1.3.6.tgz"
   integrity sha512-svsK26tQ8vEKnMshTDatSIQSMDdz8CxIIqKsvPqbtV23Etmw6VNaFAitu8zwZ0VrOne7FztwPyRLxK7/DIUTQg==
   dependencies:
     dargs "^4.0.1"
@@ -4480,7 +4643,7 @@ git-raw-commits@^1.3.6:
 
 git-remote-origin-url@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz#5282659dae2107145a11126112ad3216ec5fa65f"
+  resolved "https://registry.npmjs.org/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz"
   integrity sha1-UoJlna4hBxRaERJhEq0yFuxfpl8=
   dependencies:
     gitconfiglocal "^1.0.0"
@@ -4488,7 +4651,7 @@ git-remote-origin-url@^2.0.0:
 
 git-semver-tags@^1.3.6:
   version "1.3.6"
-  resolved "https://registry.yarnpkg.com/git-semver-tags/-/git-semver-tags-1.3.6.tgz#357ea01f7280794fe0927f2806bee6414d2caba5"
+  resolved "https://registry.npmjs.org/git-semver-tags/-/git-semver-tags-1.3.6.tgz"
   integrity sha512-2jHlJnln4D/ECk9FxGEBh3k44wgYdWjWDtMmJPaecjoRmxKo3Y1Lh8GMYuOPu04CHw86NTAODchYjC5pnpMQig==
   dependencies:
     meow "^4.0.0"
@@ -4496,14 +4659,14 @@ git-semver-tags@^1.3.6:
 
 gitconfiglocal@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz#41d045f3851a5ea88f03f24ca1c6178114464b9b"
+  resolved "https://registry.npmjs.org/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz"
   integrity sha1-QdBF84UaXqiPA/JMocYXgRRGS5s=
   dependencies:
     ini "^1.3.2"
 
 glob-base@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4"
+  resolved "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz"
   integrity sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=
   dependencies:
     glob-parent "^2.0.0"
@@ -4511,29 +4674,29 @@ glob-base@^0.3.0:
 
 glob-parent@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz"
   integrity sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=
   dependencies:
     is-glob "^2.0.0"
 
 glob-parent@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-3.1.0.tgz"
   integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=
   dependencies:
     is-glob "^3.1.0"
     path-dirname "^1.0.0"
 
-glob-parent@^5.0.0, glob-parent@^5.1.0:
+glob-parent@^5.0.0, glob-parent@^5.1.0, glob-parent@~5.1.2:
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
+  resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz"
   integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
   dependencies:
     is-glob "^4.0.1"
 
 glob@7.0.5:
   version "7.0.5"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.0.5.tgz#b4202a69099bbb4d292a7c1b95b6682b67ebdc95"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.0.5.tgz"
   integrity sha1-tCAqaQmbu00pKnwblbZoK2fr3JU=
   dependencies:
     fs.realpath "^1.0.0"
@@ -4545,7 +4708,7 @@ glob@7.0.5:
 
 glob@7.1.1:
   version "7.1.1"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.1.1.tgz"
   integrity sha1-gFIR3wT6rxxjo2ADBs31reULLsg=
   dependencies:
     fs.realpath "^1.0.0"
@@ -4557,7 +4720,7 @@ glob@7.1.1:
 
 glob@^5.0.15:
   version "5.0.15"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-5.0.15.tgz#1bc936b9e02f4a603fcc222ecf7633d30b8b93b1"
+  resolved "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz"
   integrity sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=
   dependencies:
     inflight "^1.0.4"
@@ -4568,7 +4731,7 @@ glob@^5.0.15:
 
 glob@^7.0.0, glob@^7.0.3, glob@^7.0.6, glob@^7.1.1, glob@^7.1.3:
   version "7.1.3"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.3.tgz#3960832d3f1574108342dafd3a67b332c0969df1"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz"
   integrity sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==
   dependencies:
     fs.realpath "^1.0.0"
@@ -4580,7 +4743,7 @@ glob@^7.0.0, glob@^7.0.3, glob@^7.0.6, glob@^7.1.1, glob@^7.1.3:
 
 glob@^7.1.6:
   version "7.1.6"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
+  resolved "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz"
   integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
   dependencies:
     fs.realpath "^1.0.0"
@@ -4592,7 +4755,7 @@ glob@^7.1.6:
 
 global-modules@^0.2.3:
   version "0.2.3"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-0.2.3.tgz#ea5a3bed42c6d6ce995a4f8a1269b5dae223828d"
+  resolved "https://registry.npmjs.org/global-modules/-/global-modules-0.2.3.tgz"
   integrity sha1-6lo77ULG1s6ZWk+KEmm12uIjgo0=
   dependencies:
     global-prefix "^0.1.4"
@@ -4600,7 +4763,7 @@ global-modules@^0.2.3:
 
 global-prefix@^0.1.4:
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-0.1.5.tgz#8d3bc6b8da3ca8112a160d8d496ff0462bfef78f"
+  resolved "https://registry.npmjs.org/global-prefix/-/global-prefix-0.1.5.tgz"
   integrity sha1-jTvGuNo8qBEqFg2NSW/wRiv+948=
   dependencies:
     homedir-polyfill "^1.0.0"
@@ -4610,31 +4773,31 @@ global-prefix@^0.1.4:
 
 globals@^11.1.0:
   version "11.12.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
+  resolved "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz"
   integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
 
 globals@^12.1.0:
   version "12.4.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-12.4.0.tgz#a18813576a41b00a24a97e7f815918c2e19925f8"
+  resolved "https://registry.npmjs.org/globals/-/globals-12.4.0.tgz"
   integrity sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==
   dependencies:
     type-fest "^0.8.1"
 
 globals@^13.6.0:
   version "13.7.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-13.7.0.tgz#aed3bcefd80ad3ec0f0be2cf0c895110c0591795"
+  resolved "https://registry.npmjs.org/globals/-/globals-13.7.0.tgz"
   integrity sha512-Aipsz6ZKRxa/xQkZhNg0qIWXT6x6rD46f6x/PCnBomlttdIyAPak4YD9jTmKpZ72uROSMU87qJtcgpgHaVchiA==
   dependencies:
     type-fest "^0.20.2"
 
 globals@^9.18.0:
   version "9.18.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a"
+  resolved "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz"
   integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==
 
 globby@^11.0.1:
   version "11.0.3"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.3.tgz#9b1f0cb523e171dd1ad8c7b2a9fb4b644b9593cb"
+  resolved "https://registry.npmjs.org/globby/-/globby-11.0.3.tgz"
   integrity sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg==
   dependencies:
     array-union "^2.1.0"
@@ -4646,7 +4809,7 @@ globby@^11.0.1:
 
 globby@^6.1.0:
   version "6.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-6.1.0.tgz#f5a6d70e8395e21c858fb0489d64df02424d506c"
+  resolved "https://registry.npmjs.org/globby/-/globby-6.1.0.tgz"
   integrity sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=
   dependencies:
     array-union "^1.0.1"
@@ -4657,27 +4820,32 @@ globby@^6.1.0:
 
 graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.1.9:
   version "4.1.15"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.15.tgz#ffb703e1066e8a0eeaa4c8b80ba9253eeefbfb00"
+  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.15.tgz"
   integrity sha512-6uHUhOPEBgQ24HM+r6b/QwWfZq+yiFcipKFrOFiBEnWdy5sdzYoi+pJeQaPI5qOLRFqWmAXUPQNsielzdLoecA==
 
 graceful-fs@^4.2.0:
   version "4.2.6"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
+  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.6.tgz"
   integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
 
+graceful-fs@^4.2.4:
+  version "4.2.10"
+  resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz"
+  integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
+
 "graceful-readlink@>= 1.0.0":
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
+  resolved "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz"
   integrity sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=
 
 growl@1.9.2:
   version "1.9.2"
-  resolved "https://registry.yarnpkg.com/growl/-/growl-1.9.2.tgz#0ea7743715db8d8de2c5ede1775e1b45ac85c02f"
+  resolved "https://registry.npmjs.org/growl/-/growl-1.9.2.tgz"
   integrity sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=
 
 handlebars@^4.0.1, handlebars@^4.0.2:
   version "4.7.7"
-  resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.7.tgz#9ce33416aad02dbd6c8fafa8240d5d98004945a1"
+  resolved "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz"
   integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==
   dependencies:
     minimist "^1.2.5"
@@ -4689,12 +4857,12 @@ handlebars@^4.0.1, handlebars@^4.0.2:
 
 har-schema@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92"
+  resolved "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz"
   integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=
 
 har-validator@~5.1.0:
   version "5.1.3"
-  resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.3.tgz#1ef89ebd3e4996557675eed9893110dc350fa080"
+  resolved "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz"
   integrity sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==
   dependencies:
     ajv "^6.5.5"
@@ -4702,56 +4870,56 @@ har-validator@~5.1.0:
 
 has-ansi@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
+  resolved "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz"
   integrity sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=
   dependencies:
     ansi-regex "^2.0.0"
 
 has-binary2@~1.0.2:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has-binary2/-/has-binary2-1.0.3.tgz#7776ac627f3ea77250cfc332dab7ddf5e4f5d11d"
+  resolved "https://registry.npmjs.org/has-binary2/-/has-binary2-1.0.3.tgz"
   integrity sha512-G1LWKhDSvhGeAQ8mPVQlqNcOB2sJdwATtZKl2pDKKHfpf/rYj24lkinxf69blJbnsvtqqNU+L3SL50vzZhXOnw==
   dependencies:
     isarray "2.0.1"
 
 has-cors@1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/has-cors/-/has-cors-1.1.0.tgz#5e474793f7ea9843d1bb99c23eef49ff126fff39"
+  resolved "https://registry.npmjs.org/has-cors/-/has-cors-1.1.0.tgz"
   integrity sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk=
 
 has-flag@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-1.0.0.tgz#9d9e793165ce017a00f00418c43f942a7b1d11fa"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz"
   integrity sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=
 
 has-flag@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz"
   integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
 
 has-flag@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
+  resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
 has-symbols@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.0.tgz#ba1a8f1af2a0fc39650f5c850367704122063b44"
+  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.0.tgz"
   integrity sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=
 
 has-symbols@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423"
+  resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz"
   integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==
 
-has-unicode@^2.0.0:
+has-unicode@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
+  resolved "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz"
   integrity sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=
 
 has-value@^0.3.1:
   version "0.3.1"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
+  resolved "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz"
   integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=
   dependencies:
     get-value "^2.0.3"
@@ -4760,7 +4928,7 @@ has-value@^0.3.1:
 
 has-value@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
+  resolved "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz"
   integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=
   dependencies:
     get-value "^2.0.6"
@@ -4769,12 +4937,12 @@ has-value@^1.0.0:
 
 has-values@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
+  resolved "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz"
   integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E=
 
 has-values@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
+  resolved "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz"
   integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=
   dependencies:
     is-number "^3.0.0"
@@ -4782,14 +4950,14 @@ has-values@^1.0.0:
 
 has@^1.0.1, has@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
+  resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz"
   integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
   dependencies:
     function-bind "^1.1.1"
 
 hash-base@^3.0.0:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.0.4.tgz#5fc8686847ecd73499403319a6b0a3f3f6ae4918"
+  resolved "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz"
   integrity sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=
   dependencies:
     inherits "^2.0.1"
@@ -4797,12 +4965,12 @@ hash-base@^3.0.0:
 
 hash-sum@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/hash-sum/-/hash-sum-1.0.2.tgz#33b40777754c6432573c120cc3808bbd10d47f04"
+  resolved "https://registry.npmjs.org/hash-sum/-/hash-sum-1.0.2.tgz"
   integrity sha1-M7QHd3VMZDJXPBIMw4CLvRDUfwQ=
 
 hash.js@^1.0.0, hash.js@^1.0.3:
   version "1.1.7"
-  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
+  resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz"
   integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
   dependencies:
     inherits "^2.0.3"
@@ -4810,7 +4978,7 @@ hash.js@^1.0.0, hash.js@^1.0.3:
 
 hasha@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/hasha/-/hasha-2.2.0.tgz#78d7cbfc1e6d66303fe79837365984517b2f6ee1"
+  resolved "https://registry.npmjs.org/hasha/-/hasha-2.2.0.tgz"
   integrity sha1-eNfL/B5tZjA/55g3NlmEUXsvbuE=
   dependencies:
     is-stream "^1.0.1"
@@ -4818,12 +4986,12 @@ hasha@^2.2.0:
 
 he@^1.1.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
+  resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz"
   integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
 
 hmac-drbg@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
+  resolved "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz"
   integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
   dependencies:
     hash.js "^1.0.3"
@@ -4832,19 +5000,19 @@ hmac-drbg@^1.0.1:
 
 homedir-polyfill@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz#4c2bbc8a758998feebf5ed68580f76d46768b4bc"
+  resolved "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz"
   integrity sha1-TCu8inWJmP7r9e1oWA921GdotLw=
   dependencies:
     parse-passwd "^1.0.0"
 
 hosted-git-info@^2.1.4:
   version "2.7.1"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.7.1.tgz#97f236977bd6e125408930ff6de3eec6281ec047"
+  resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.7.1.tgz"
   integrity sha512-7T/BxH19zbcCTa8XkMlbK5lTo1WtgkFi3GvdWEyNuc4Vex7/9Dqbnpsf4JMydcfj9HCg4zUWFTL3Za6lapg5/w==
 
 http-errors@1.6.3, http-errors@~1.6.3:
   version "1.6.3"
-  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.6.3.tgz#8b55680bb4be283a0b5bf4ea2e38580be1d9320d"
+  resolved "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz"
   integrity sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=
   dependencies:
     depd "~1.1.2"
@@ -4854,7 +5022,7 @@ http-errors@1.6.3, http-errors@~1.6.3:
 
 http-proxy-agent@1:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-1.0.0.tgz#cc1ce38e453bf984a0f7702d2dd59c73d081284a"
+  resolved "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-1.0.0.tgz"
   integrity sha1-zBzjjkU7+YSg93AtLdWcc9CBKEo=
   dependencies:
     agent-base "2"
@@ -4863,7 +5031,7 @@ http-proxy-agent@1:
 
 http-proxy@^1.13.0, http-proxy@^1.18.0:
   version "1.18.1"
-  resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz#401541f0534884bbf95260334e72f88ee3976549"
+  resolved "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz"
   integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
   dependencies:
     eventemitter3 "^4.0.0"
@@ -4872,7 +5040,7 @@ http-proxy@^1.13.0, http-proxy@^1.18.0:
 
 http-server@^0.12.3:
   version "0.12.3"
-  resolved "https://registry.yarnpkg.com/http-server/-/http-server-0.12.3.tgz#ba0471d0ecc425886616cb35c4faf279140a0d37"
+  resolved "https://registry.npmjs.org/http-server/-/http-server-0.12.3.tgz"
   integrity sha512-be0dKG6pni92bRjq0kvExtj/NrrAd28/8fCXkaI/4piTwQMSDSLMhWyW0NI1V+DBI3aa1HMlQu46/HjVLfmugA==
   dependencies:
     basic-auth "^1.0.3"
@@ -4888,7 +5056,7 @@ http-server@^0.12.3:
 
 http-signature@~1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1"
+  resolved "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz"
   integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=
   dependencies:
     assert-plus "^1.0.0"
@@ -4897,12 +5065,12 @@ http-signature@~1.2.0:
 
 https-browserify@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73"
+  resolved "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz"
   integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=
 
 https-proxy-agent@1:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-1.0.0.tgz#35f7da6c48ce4ddbfa264891ac593ee5ff8671e6"
+  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-1.0.0.tgz"
   integrity sha1-NffabEjOTdv6JkiRrFk+5f+GceY=
   dependencies:
     agent-base "2"
@@ -4911,61 +5079,69 @@ https-proxy-agent@1:
 
 https-proxy-agent@^2.2.1:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-2.2.1.tgz#51552970fa04d723e04c56d04178c3f92592bbc0"
+  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-2.2.1.tgz"
   integrity sha512-HPCTS1LW51bcyMYbxUIOO4HEOlQ1/1qRaFWcyxvwaqUS9TY88aoEuHUY33kuAh1YhVVaDQhLZsnPd+XNARWZlQ==
   dependencies:
     agent-base "^4.1.0"
     debug "^3.1.0"
 
+https-proxy-agent@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz"
+  integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==
+  dependencies:
+    agent-base "6"
+    debug "4"
+
 iconv-lite@0.4.23:
   version "0.4.23"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.23.tgz#297871f63be507adcfbfca715d0cd0eed84e9a63"
+  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.23.tgz"
   integrity sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
-iconv-lite@^0.4.17, iconv-lite@^0.4.4, iconv-lite@~0.4.13:
+iconv-lite@^0.4.17, iconv-lite@~0.4.13:
   version "0.4.24"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
+  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
 ieee754@^1.1.4:
   version "1.1.12"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.1.12.tgz#50bf24e5b9c8bb98af4964c941cdb0918da7b60b"
+  resolved "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz"
   integrity sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==
 
 iferr@^0.1.5:
   version "0.1.5"
-  resolved "https://registry.yarnpkg.com/iferr/-/iferr-0.1.5.tgz#c60eed69e6d8fdb6b3104a1fcbca1c192dc5b501"
+  resolved "https://registry.npmjs.org/iferr/-/iferr-0.1.5.tgz"
   integrity sha1-xg7taebY/bazEEofy8ocGS3FtQE=
 
 ignore-walk@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-3.0.1.tgz#a83e62e7d272ac0e3b551aaa82831a19b69f82f8"
+  resolved "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.1.tgz"
   integrity sha512-DTVlMx3IYPe0/JJcYP7Gxg7ttZZu3IInhuEhbchuqneY9wWe5Ojy2mXLBaQFUQmo0AW2r3qG7m1mg86js+gnlQ==
   dependencies:
     minimatch "^3.0.4"
 
 ignore@^4.0.6:
   version "4.0.6"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
+  resolved "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz"
   integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==
 
 ignore@^5.1.4:
   version "5.1.8"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.8.tgz#f150a8b50a34289b33e22f5889abd4d8016f0e57"
+  resolved "https://registry.npmjs.org/ignore/-/ignore-5.1.8.tgz"
   integrity sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==
 
 immediate@~3.0.5:
   version "3.0.6"
-  resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.0.6.tgz#9db1dbd0faf8de6fbe0f5dd5e56bb606280de69b"
+  resolved "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz"
   integrity sha1-nbHb0Pr43m++D13V5Wu2BigN5ps=
 
 import-fresh@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.0.0.tgz#a3d897f420cab0e671236897f75bc14b4885c390"
+  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.0.0.tgz"
   integrity sha512-pOnA9tfM3Uwics+SaBLCNyZZZbK+4PTu0OPZtLlMIrv17EdBoC15S9Kn8ckJ9TZTyKb3ywNE5y1yeDxxGA7nTQ==
   dependencies:
     parent-module "^1.0.0"
@@ -4973,7 +5149,7 @@ import-fresh@^3.0.0:
 
 import-fresh@^3.2.1:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
+  resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz"
   integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
   dependencies:
     parent-module "^1.0.0"
@@ -4981,29 +5157,34 @@ import-fresh@^3.2.1:
 
 imurmurhash@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
+  resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz"
   integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
 
 indent-string@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-2.1.0.tgz#8e2d48348742121b4a8218b7a137e9a52049dc80"
+  resolved "https://registry.npmjs.org/indent-string/-/indent-string-2.1.0.tgz"
   integrity sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=
   dependencies:
     repeating "^2.0.0"
 
 indent-string@^3.0.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-3.2.0.tgz#4a5fd6d27cc332f37e5419a504dbb837105c9289"
+  resolved "https://registry.npmjs.org/indent-string/-/indent-string-3.2.0.tgz"
   integrity sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=
 
+indent-string@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz"
+  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
+
 indexof@0.0.1:
   version "0.0.1"
-  resolved "https://registry.yarnpkg.com/indexof/-/indexof-0.0.1.tgz#82dc336d232b9062179d05ab3293a66059fd435d"
+  resolved "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz"
   integrity sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=
 
 inflight@^1.0.4:
   version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz"
   integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=
   dependencies:
     once "^1.3.0"
@@ -5011,27 +5192,27 @@ inflight@^1.0.4:
 
 inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
 inherits@2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.1.tgz#b17d08d326b4423e568eff719f91b0b1cbdf69f1"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
   integrity sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=
 
 inherits@2.0.3:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
+  resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz"
   integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
 
-ini@^1.3.2, ini@^1.3.4, ini@~1.3.0:
+ini@^1.3.2, ini@^1.3.4:
   version "1.3.8"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
+  resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
 inquirer@1.2.3:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-1.2.3.tgz#4dec6f32f37ef7bb0b2ed3f1d1a5c3f545074918"
+  resolved "https://registry.npmjs.org/inquirer/-/inquirer-1.2.3.tgz"
   integrity sha1-TexvMvN+97sLLtPx0aXD9UUHSRg=
   dependencies:
     ansi-escapes "^1.1.0"
@@ -5051,7 +5232,7 @@ inquirer@1.2.3:
 
 inquirer@3.0.6:
   version "3.0.6"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-3.0.6.tgz#e04aaa9d05b7a3cb9b0f407d04375f0447190347"
+  resolved "https://registry.npmjs.org/inquirer/-/inquirer-3.0.6.tgz"
   integrity sha1-4EqqnQW3o8ubD0B9BDdfBEcZA0c=
   dependencies:
     ansi-escapes "^1.1.0"
@@ -5070,117 +5251,124 @@ inquirer@3.0.6:
 
 interpret@^1.0.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.2.0.tgz#d5061a6224be58e8083985f5014d844359576296"
+  resolved "https://registry.npmjs.org/interpret/-/interpret-1.2.0.tgz"
   integrity sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==
 
 invariant@^2.2.2:
   version "2.2.4"
-  resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6"
+  resolved "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz"
   integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==
   dependencies:
     loose-envify "^1.0.0"
 
 ip-regex@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9"
+  resolved "https://registry.npmjs.org/ip-regex/-/ip-regex-2.1.0.tgz"
   integrity sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=
 
 ip@1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-1.0.1.tgz#c7e356cdea225ae71b36d70f2e71a92ba4e42590"
+  resolved "https://registry.npmjs.org/ip/-/ip-1.0.1.tgz"
   integrity sha1-x+NWzeoiWucbNtcPLnGpK6TkJZA=
 
 ip@^1.1.4:
   version "1.1.5"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-1.1.5.tgz#bdded70114290828c0a039e72ef25f5aaec4354a"
+  resolved "https://registry.npmjs.org/ip/-/ip-1.1.5.tgz"
   integrity sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo=
 
 is-accessor-descriptor@^0.1.6:
   version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
+  resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz"
   integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=
   dependencies:
     kind-of "^3.0.2"
 
 is-accessor-descriptor@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
+  resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz"
   integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==
   dependencies:
     kind-of "^6.0.0"
 
 is-arrayish@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
+  resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz"
   integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=
 
 is-binary-path@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
+  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz"
   integrity sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=
   dependencies:
     binary-extensions "^1.0.0"
 
+is-binary-path@~2.1.0:
+  version "2.1.0"
+  resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz"
+  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
+  dependencies:
+    binary-extensions "^2.0.0"
+
 is-boolean-object@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.0.tgz#e2aaad3a3a8fca34c28f6eee135b156ed2587ff0"
+  resolved "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.0.tgz"
   integrity sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==
   dependencies:
     call-bind "^1.0.0"
 
 is-buffer@^1.1.5:
   version "1.1.6"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
+  resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz"
   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
 
 is-builtin-module@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-1.0.0.tgz#540572d34f7ac3119f8f76c30cbc1b1e037affbe"
+  resolved "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz"
   integrity sha1-VAVy0096wxGfj3bDDLwbHgN6/74=
   dependencies:
     builtin-modules "^1.0.0"
 
 is-callable@^1.1.4:
   version "1.1.4"
-  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.4.tgz#1e1adf219e1eeb684d691f9d6a05ff0d30a24d75"
+  resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz"
   integrity sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==
 
 is-ci@^1.0.10:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.2.1.tgz#e3779c8ee17fccf428488f6e281187f2e632841c"
+  resolved "https://registry.npmjs.org/is-ci/-/is-ci-1.2.1.tgz"
   integrity sha512-s6tfsaQaQi3JNciBH6shVqEDvhGut0SUXr31ag8Pd8BBbVVlcGfWhpPmEOoM6RJ5TFhbypvf5yyRw/VXW1IiWg==
   dependencies:
     ci-info "^1.5.0"
 
 is-core-module@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
+  resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.2.0.tgz"
   integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
   dependencies:
     has "^1.0.3"
 
 is-data-descriptor@^0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
+  resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz"
   integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=
   dependencies:
     kind-of "^3.0.2"
 
 is-data-descriptor@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
+  resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz"
   integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==
   dependencies:
     kind-of "^6.0.0"
 
 is-date-object@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
+  resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz"
   integrity sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=
 
 is-descriptor@^0.1.0:
   version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
+  resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz"
   integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==
   dependencies:
     is-accessor-descriptor "^0.1.6"
@@ -5189,7 +5377,7 @@ is-descriptor@^0.1.0:
 
 is-descriptor@^1.0.0, is-descriptor@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
+  resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz"
   integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==
   dependencies:
     is-accessor-descriptor "^1.0.0"
@@ -5198,268 +5386,285 @@ is-descriptor@^1.0.0, is-descriptor@^1.0.2:
 
 is-directory@^0.3.1:
   version "0.3.1"
-  resolved "https://registry.yarnpkg.com/is-directory/-/is-directory-0.3.1.tgz#61339b6f2475fc772fd9c9d83f5c8575dc154ae1"
+  resolved "https://registry.npmjs.org/is-directory/-/is-directory-0.3.1.tgz"
   integrity sha1-YTObbyR1/Hcv2cnYP1yFddwVSuE=
 
 is-dotfile@^1.0.0:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.3.tgz#a6a2f32ffd2dfb04f5ca25ecd0f6b83cf798a1e1"
+  resolved "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz"
   integrity sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=
 
 is-equal-shallow@^0.1.3:
   version "0.1.3"
-  resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534"
+  resolved "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz"
   integrity sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=
   dependencies:
     is-primitive "^2.0.0"
 
 is-extendable@^0.1.0, is-extendable@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
+  resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz"
   integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
 
 is-extendable@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
+  resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz"
   integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
   dependencies:
     is-plain-object "^2.0.4"
 
 is-extglob@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"
+  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz"
   integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=
 
 is-extglob@^2.1.0, is-extglob@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
+  resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz"
   integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
 
 is-finite@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa"
+  resolved "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz"
   integrity sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=
   dependencies:
     number-is-nan "^1.0.0"
 
 is-fullwidth-code-point@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz"
   integrity sha1-754xOG8DGn8NZDr4L95QxFfvAMs=
   dependencies:
     number-is-nan "^1.0.0"
 
 is-fullwidth-code-point@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz"
   integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=
 
 is-fullwidth-code-point@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
+  resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz"
   integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
 
 is-glob@^2.0.0, is-glob@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz"
   integrity sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=
   dependencies:
     is-extglob "^1.0.0"
 
 is-glob@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz"
   integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
   dependencies:
     is-extglob "^2.1.0"
 
 is-glob@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.0.tgz#9521c76845cc2610a85203ddf080a958c2ffabc0"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.0.tgz"
   integrity sha1-lSHHaEXMJhCoUgPd8ICpWML/q8A=
   dependencies:
     is-extglob "^2.1.1"
 
 is-glob@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz"
   integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
   dependencies:
     is-extglob "^2.1.1"
 
+is-glob@~4.0.1:
+  version "4.0.3"
+  resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz"
+  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
+  dependencies:
+    is-extglob "^2.1.1"
+
 is-module@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
+  resolved "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz"
   integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=
 
 is-number-object@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.4.tgz#36ac95e741cf18b283fc1ddf5e83da798e3ec197"
+  resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.4.tgz"
   integrity sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==
 
 is-number@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-0.1.1.tgz#69a7af116963d47206ec9bd9b48a14216f1e3806"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-0.1.1.tgz"
   integrity sha1-aaevEWlj1HIG7JvZtIoUIW8eOAY=
 
 is-number@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz"
   integrity sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=
   dependencies:
     kind-of "^3.0.2"
 
 is-number@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz"
   integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=
   dependencies:
     kind-of "^3.0.2"
 
 is-number@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz"
   integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
 
 is-number@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
+  resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
 is-obj@^1.0.0, is-obj@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
+  resolved "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz"
   integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=
 
 is-observable@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-observable/-/is-observable-1.1.0.tgz#b3e986c8f44de950867cab5403f5a3465005975e"
+  resolved "https://registry.npmjs.org/is-observable/-/is-observable-1.1.0.tgz"
   integrity sha512-NqCa4Sa2d+u7BWc6CukaObG3Fh+CU9bvixbpcXYhy2VvYS7vVGIdAgnIS5Ks3A/cqk4rebLJ9s8zBstT2aKnIA==
   dependencies:
     symbol-observable "^1.1.0"
 
 is-path-cwd@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d"
+  resolved "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz"
   integrity sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=
 
+is-path-cwd@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-2.2.0.tgz"
+  integrity sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==
+
 is-path-in-cwd@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz#5ac48b345ef675339bd6c7a48a912110b241cf52"
+  resolved "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz"
   integrity sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==
   dependencies:
     is-path-inside "^1.0.0"
 
 is-path-inside@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.1.tgz#8ef5b7de50437a3fdca6b4e865ef7aa55cb48036"
+  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.1.tgz"
   integrity sha1-jvW33lBDej/cprToZe96pVy0gDY=
   dependencies:
     path-is-inside "^1.0.1"
 
+is-path-inside@^3.0.2:
+  version "3.0.3"
+  resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz"
+  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
+
 is-plain-obj@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
+  resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz"
   integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4=
 
 is-plain-object@^2.0.1, is-plain-object@^2.0.3, is-plain-object@^2.0.4:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
+  resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz"
   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
   dependencies:
     isobject "^3.0.1"
 
 is-posix-bracket@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4"
+  resolved "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz"
   integrity sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=
 
 is-primitive@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
+  resolved "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz"
   integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=
 
 is-promise@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
+  resolved "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz"
   integrity sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=
 
 is-reference@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/is-reference/-/is-reference-1.2.1.tgz#8b2dac0b371f4bc994fdeaba9eb542d03002d0b7"
+  resolved "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz"
   integrity sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==
   dependencies:
     "@types/estree" "*"
 
 is-regex@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
+  resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz"
   integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=
   dependencies:
     has "^1.0.1"
 
 is-regexp@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz#fd2d883545c46bac5a633e7b9a09e87fa2cb5069"
+  resolved "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz"
   integrity sha1-/S2INUXEa6xaYz57mgnof6LLUGk=
 
 is-stream@^1.0.1, is-stream@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
+  resolved "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz"
   integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
 
 is-string@^1.0.5:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.5.tgz#40493ed198ef3ff477b8c7f92f644ec82a5cd3a6"
+  resolved "https://registry.npmjs.org/is-string/-/is-string-1.0.5.tgz"
   integrity sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==
 
 is-subset@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-subset/-/is-subset-0.1.1.tgz#8a59117d932de1de00f245fcdd39ce43f1e939a6"
+  resolved "https://registry.npmjs.org/is-subset/-/is-subset-0.1.1.tgz"
   integrity sha1-ilkRfZMt4d4A8kX83TnOQ/HpOaY=
 
 is-symbol@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.2.tgz#a055f6ae57192caee329e7a860118b497a950f38"
+  resolved "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz"
   integrity sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==
   dependencies:
     has-symbols "^1.0.0"
 
 is-text-path@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
+  resolved "https://registry.npmjs.org/is-text-path/-/is-text-path-1.0.1.tgz"
   integrity sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4=
   dependencies:
     text-extensions "^1.0.0"
 
 is-typedarray@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
+  resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz"
   integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
 
 is-url@^1.2.2:
   version "1.2.4"
-  resolved "https://registry.yarnpkg.com/is-url/-/is-url-1.2.4.tgz#04a4df46d28c4cff3d73d01ff06abeb318a1aa52"
+  resolved "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz"
   integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==
 
 is-utf8@^0.2.0:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
+  resolved "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz"
   integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
 
 is-windows@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-0.2.0.tgz#de1aa6d63ea29dd248737b69f1ff8b8002d2108c"
+  resolved "https://registry.npmjs.org/is-windows/-/is-windows-0.2.0.tgz"
   integrity sha1-3hqm1j6indJIc3tp8f+LgALSEIw=
 
 is-windows@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
+  resolved "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz"
   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
 
 is2@2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is2/-/is2-2.0.1.tgz#8ac355644840921ce435d94f05d3a94634d3481a"
+  resolved "https://registry.npmjs.org/is2/-/is2-2.0.1.tgz"
   integrity sha512-+WaJvnaA7aJySz2q/8sLjMb2Mw14KTplHmSwcSpZ/fWJPkUmqw3YTzSWbPJ7OAwRvdYTWF2Wg+yYJ1AdP5Z8CA==
   dependencies:
     deep-is "^0.1.3"
@@ -5468,56 +5673,56 @@ is2@2.0.1:
 
 isarray@0.0.1:
   version "0.0.1"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
   integrity sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=
 
 isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz"
   integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
 
 isarray@2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-2.0.1.tgz#a37d94ed9cda2d59865c9f76fe596ee1f338741e"
+  resolved "https://registry.npmjs.org/isarray/-/isarray-2.0.1.tgz"
   integrity sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4=
 
 isbinaryfile@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/isbinaryfile/-/isbinaryfile-3.0.3.tgz#5d6def3edebf6e8ca8cae9c30183a804b5f8be80"
+  resolved "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-3.0.3.tgz"
   integrity sha512-8cJBL5tTd2OS0dM4jz07wQd5g0dCCqIhUxPIGtZfa5L6hWlvV5MHTITy/DBAsF+Oe2LS1X3krBUhNwaGUWpWxw==
   dependencies:
     buffer-alloc "^1.2.0"
 
 isexe@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
+  resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz"
   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
 
 isobject@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
+  resolved "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz"
   integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
   dependencies:
     isarray "1.0.0"
 
 isobject@^3.0.0, isobject@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
+  resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz"
   integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
 
 isstream@~0.1.2:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
+  resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz"
   integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=
 
 istanbul-lib-coverage@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz#2aee0e073ad8c5f6a0b00e0dfbf52b4667472eda"
+  resolved "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz"
   integrity sha512-nPvSZsVlbG9aLhZYaC3Oi1gT/tpyo3Yt5fNyf6NmcKIayz4VV/txxJFFKAK/gU4dcNn8ehsanBbVHVl0+amOLA==
 
 istanbul-lib-instrument@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-3.0.0.tgz#b5f066b2a161f75788be17a9d556f40a0cf2afc9"
+  resolved "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-3.0.0.tgz"
   integrity sha512-eQY9vN9elYjdgN9Iv6NS/00bptm02EBBk70lRMaVjeA6QYocQgenVrSgC28TJurdnZa80AGO3ASdFN+w/njGiQ==
   dependencies:
     "@babel/generator" "^7.0.0"
@@ -5530,7 +5735,7 @@ istanbul-lib-instrument@^3.0.0:
 
 istanbul@^0.4.0:
   version "0.4.5"
-  resolved "https://registry.yarnpkg.com/istanbul/-/istanbul-0.4.5.tgz#65c7d73d4c4da84d4f3ac310b918fb0b8033733b"
+  resolved "https://registry.npmjs.org/istanbul/-/istanbul-0.4.5.tgz"
   integrity sha1-ZcfXPUxNqE1POsMQuRj7C4Azczs=
   dependencies:
     abbrev "1.0.x"
@@ -5550,19 +5755,19 @@ istanbul@^0.4.0:
 
 jasmine-core@^2.99.0, jasmine-core@~2.99.0:
   version "2.99.1"
-  resolved "https://registry.yarnpkg.com/jasmine-core/-/jasmine-core-2.99.1.tgz#e6400df1e6b56e130b61c4bcd093daa7f6e8ca15"
+  resolved "https://registry.npmjs.org/jasmine-core/-/jasmine-core-2.99.1.tgz"
   integrity sha1-5kAN8ea1bhMLYcS80JPap/boyhU=
 
 jasmine-ts@^0.3.2:
   version "0.3.2"
-  resolved "https://registry.yarnpkg.com/jasmine-ts/-/jasmine-ts-0.3.2.tgz#831cad901a070f7fe919c91e2c87b61f9ee7cb95"
+  resolved "https://registry.npmjs.org/jasmine-ts/-/jasmine-ts-0.3.2.tgz"
   integrity sha512-ze8IxVX2E6j4ux4W0m8tBwbVds6XYWA0CMER50dV0lp83dF2UoONdbzE+aJLeu5n7Bi2IKTzcGHWGt7n/Yo6sw==
   dependencies:
     yargs "^16.2.0"
 
 jasmine@^2.99.0:
   version "2.99.0"
-  resolved "https://registry.yarnpkg.com/jasmine/-/jasmine-2.99.0.tgz#8ca72d102e639b867c6489856e0e18a9c7aa42b7"
+  resolved "https://registry.npmjs.org/jasmine/-/jasmine-2.99.0.tgz"
   integrity sha1-jKctEC5jm4Z8ZImFbg4YqceqQrc=
   dependencies:
     exit "^0.1.2"
@@ -5571,12 +5776,12 @@ jasmine@^2.99.0:
 
 jest-get-type@^22.1.0:
   version "22.4.3"
-  resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-22.4.3.tgz#e3a8504d8479342dd4420236b322869f18900ce4"
+  resolved "https://registry.npmjs.org/jest-get-type/-/jest-get-type-22.4.3.tgz"
   integrity sha512-/jsz0Y+V29w1chdXVygEKSz2nBoHoYqNShPe+QgxSNjAuP1i8+k4LbQNrfoliKej0P45sivkSCh7yiD6ubHS3w==
 
 jest-validate@^23.5.0:
   version "23.6.0"
-  resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-23.6.0.tgz#36761f99d1ed33fcd425b4e4c5595d62b6597474"
+  resolved "https://registry.npmjs.org/jest-validate/-/jest-validate-23.6.0.tgz"
   integrity sha512-OFKapYxe72yz7agrDAWi8v2WL8GIfVqcbKRCLbRG9PAxtzF9b1SEDdTpytNDN12z2fJynoBwpMpvj2R39plI2A==
   dependencies:
     chalk "^2.0.1"
@@ -5586,17 +5791,17 @@ jest-validate@^23.5.0:
 
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
+  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
 js-tokens@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b"
+  resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz"
   integrity sha1-mGbfOVECEw449/mWvOtlRDIJwls=
 
 js-yaml@3.x, js-yaml@^3.12.0, js-yaml@^3.9.0:
   version "3.13.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847"
+  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz"
   integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==
   dependencies:
     argparse "^1.0.7"
@@ -5604,7 +5809,7 @@ js-yaml@3.x, js-yaml@^3.12.0, js-yaml@^3.9.0:
 
 js-yaml@^3.13.1:
   version "3.14.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
+  resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz"
   integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
   dependencies:
     argparse "^1.0.7"
@@ -5612,90 +5817,90 @@ js-yaml@^3.13.1:
 
 jsbn@~0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
+  resolved "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz"
   integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM=
 
 jsesc@^2.5.1:
   version "2.5.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
+  resolved "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz"
   integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
 
 jsesc@~0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
+  resolved "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz"
   integrity sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=
 
 json-parse-better-errors@^1.0.1, json-parse-better-errors@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
+  resolved "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz"
   integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==
 
 json-schema-traverse@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
+  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
 json-schema-traverse@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
+  resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz"
   integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
 
 json-schema@0.2.3:
   version "0.2.3"
-  resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
+  resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz"
   integrity sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=
 
 json-stable-stringify-without-jsonify@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
+  resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz"
   integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=
 
 json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
+  resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz"
   integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
 
 json3@3.3.2:
   version "3.3.2"
-  resolved "https://registry.yarnpkg.com/json3/-/json3-3.3.2.tgz#3c0434743df93e2f5c42aee7b19bcb483575f4e1"
+  resolved "https://registry.npmjs.org/json3/-/json3-3.3.2.tgz"
   integrity sha1-PAQ0dD35Pi9cQq7nsZvLSDV19OE=
 
 json5@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-1.0.1.tgz#779fb0018604fa854eacbf6252180d83543e3dbe"
+  resolved "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz"
   integrity sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==
   dependencies:
     minimist "^1.2.0"
 
 json5@^2.1.2:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
+  resolved "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz"
   integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==
   dependencies:
     minimist "^1.2.5"
 
 jsonfile@^2.1.0:
   version "2.4.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-2.4.0.tgz#3736a2b428b87bbda0cc83b53fa3d633a35c2ae8"
+  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz"
   integrity sha1-NzaitCi4e72gzIO1P6PWM6NcKug=
   optionalDependencies:
     graceful-fs "^4.1.6"
 
 jsonfile@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
+  resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz"
   integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
   optionalDependencies:
     graceful-fs "^4.1.6"
 
 jsonparse@^1.2.0:
   version "1.3.1"
-  resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
+  resolved "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz"
   integrity sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=
 
 jsprim@^1.2.2:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2"
+  resolved "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz"
   integrity sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=
   dependencies:
     assert-plus "1.0.0"
@@ -5705,7 +5910,7 @@ jsprim@^1.2.2:
 
 jszip@^3.1.3:
   version "3.1.5"
-  resolved "https://registry.yarnpkg.com/jszip/-/jszip-3.1.5.tgz#e3c2a6c6d706ac6e603314036d43cd40beefdf37"
+  resolved "https://registry.npmjs.org/jszip/-/jszip-3.1.5.tgz"
   integrity sha512-5W8NUaFRFRqTOL7ZDDrx5qWHJyBXy6velVudIzQUSoqAAYqzSh2Z7/m0Rf1QbmQJccegD0r+YZxBjzqoBiEeJQ==
   dependencies:
     core-js "~2.3.0"
@@ -5716,7 +5921,7 @@ jszip@^3.1.3:
 
 karma-chrome-launcher@^2.1.1:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/karma-chrome-launcher/-/karma-chrome-launcher-2.2.0.tgz#cf1b9d07136cc18fe239327d24654c3dbc368acf"
+  resolved "https://registry.npmjs.org/karma-chrome-launcher/-/karma-chrome-launcher-2.2.0.tgz"
   integrity sha512-uf/ZVpAabDBPvdPdveyk1EPgbnloPvFFGgmRhYLTDH7gEB4nZdSBk8yTU47w1g/drLSx5uMOkjKk7IWKfWg/+w==
   dependencies:
     fs-access "^1.0.0"
@@ -5724,7 +5929,7 @@ karma-chrome-launcher@^2.1.1:
 
 karma-coverage@^1.1.1:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/karma-coverage/-/karma-coverage-1.1.2.tgz#cc09dceb589a83101aca5fe70c287645ef387689"
+  resolved "https://registry.npmjs.org/karma-coverage/-/karma-coverage-1.1.2.tgz"
   integrity sha512-eQawj4Cl3z/CjxslYy9ariU4uDh7cCNFZHNWXWRpl0pNeblY/4wHR7M7boTYXWrn9bY0z2pZmr11eKje/S/hIw==
   dependencies:
     dateformat "^1.0.6"
@@ -5735,17 +5940,17 @@ karma-coverage@^1.1.1:
 
 karma-firefox-launcher@^1.0.1:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/karma-firefox-launcher/-/karma-firefox-launcher-1.1.0.tgz#2c47030452f04531eb7d13d4fc7669630bb93339"
+  resolved "https://registry.npmjs.org/karma-firefox-launcher/-/karma-firefox-launcher-1.1.0.tgz"
   integrity sha512-LbZ5/XlIXLeQ3cqnCbYLn+rOVhuMIK9aZwlP6eOLGzWdo1UVp7t6CN3DP4SafiRLjexKwHeKHDm0c38Mtd3VxA==
 
 karma-jasmine@^1.1.0:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/karma-jasmine/-/karma-jasmine-1.1.2.tgz#394f2b25ffb4a644b9ada6f22d443e2fd08886c3"
+  resolved "https://registry.npmjs.org/karma-jasmine/-/karma-jasmine-1.1.2.tgz"
   integrity sha1-OU8rJf+0pkS5rabyLUQ+L9CIhsM=
 
 karma-mocha-reporter@^2.2.3:
   version "2.2.5"
-  resolved "https://registry.yarnpkg.com/karma-mocha-reporter/-/karma-mocha-reporter-2.2.5.tgz#15120095e8ed819186e47a0b012f3cd741895560"
+  resolved "https://registry.npmjs.org/karma-mocha-reporter/-/karma-mocha-reporter-2.2.5.tgz"
   integrity sha1-FRIAlejtgZGG5HoLAS8810GJVWA=
   dependencies:
     chalk "^2.1.0"
@@ -5754,7 +5959,7 @@ karma-mocha-reporter@^2.2.3:
 
 karma-phantomjs-launcher@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/karma-phantomjs-launcher/-/karma-phantomjs-launcher-1.0.4.tgz#d23ca34801bda9863ad318e3bb4bd4062b13acd2"
+  resolved "https://registry.npmjs.org/karma-phantomjs-launcher/-/karma-phantomjs-launcher-1.0.4.tgz"
   integrity sha1-0jyjSAG9qYY60xjju0vUBisTrNI=
   dependencies:
     lodash "^4.0.1"
@@ -5762,12 +5967,12 @@ karma-phantomjs-launcher@^1.0.4:
 
 karma-safari-launcher@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/karma-safari-launcher/-/karma-safari-launcher-1.0.0.tgz#96982a2cc47d066aae71c553babb28319115a2ce"
+  resolved "https://registry.npmjs.org/karma-safari-launcher/-/karma-safari-launcher-1.0.0.tgz"
   integrity sha1-lpgqLMR9BmquccVTursoMZEVos4=
 
 karma-sauce-launcher@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/karma-sauce-launcher/-/karma-sauce-launcher-2.0.2.tgz#dbf98e70d86bf287b03a537cf637eb7aefa975c3"
+  resolved "https://registry.npmjs.org/karma-sauce-launcher/-/karma-sauce-launcher-2.0.2.tgz"
   integrity sha512-jLUFaJhHMcKpxFWUesyWYihzM5FvQiJsDwGcCtKeOy2lsWhkVw0V0Byqb1d+wU6myU1mribBtsIcub23HS4kWA==
   dependencies:
     sauce-connect-launcher "^1.2.4"
@@ -5776,14 +5981,14 @@ karma-sauce-launcher@^2.0.2:
 
 karma-sourcemap-loader@^0.3.7:
   version "0.3.7"
-  resolved "https://registry.yarnpkg.com/karma-sourcemap-loader/-/karma-sourcemap-loader-0.3.7.tgz#91322c77f8f13d46fed062b042e1009d4c4505d8"
+  resolved "https://registry.npmjs.org/karma-sourcemap-loader/-/karma-sourcemap-loader-0.3.7.tgz"
   integrity sha1-kTIsd/jxPUb+0GKwQuEAnUxFBdg=
   dependencies:
     graceful-fs "^4.1.2"
 
 karma-webpack@^4.0.0-rc.2:
   version "4.0.0-rc.5"
-  resolved "https://registry.yarnpkg.com/karma-webpack/-/karma-webpack-4.0.0-rc.5.tgz#7282945c9af56d9fc6e0bb053df9afc73dae1b15"
+  resolved "https://registry.npmjs.org/karma-webpack/-/karma-webpack-4.0.0-rc.5.tgz"
   integrity sha512-JCFLWIpX1Yx/pX086/2K+c1QdsPQI3K4HVcCo4QzYPWvu7rHOHMV2d3YYVMqL1mZd7iqFlcU8vBO8xKH4CpTyg==
   dependencies:
     async "^2.0.0"
@@ -5793,7 +5998,7 @@ karma-webpack@^4.0.0-rc.2:
 
 karma@^3.1.1:
   version "3.1.4"
-  resolved "https://registry.yarnpkg.com/karma/-/karma-3.1.4.tgz#3890ca9722b10d1d14b726e1335931455788499e"
+  resolved "https://registry.npmjs.org/karma/-/karma-3.1.4.tgz"
   integrity sha512-31Vo8Qr5glN+dZEVIpnPCxEGleqE0EY6CtC2X9TagRV3rRQ3SNrvfhddICkJgUK3AgqpeKSZau03QumTGhGoSw==
   dependencies:
     bluebird "^3.3.0"
@@ -5827,48 +6032,48 @@ karma@^3.1.1:
 
 kew@^0.7.0:
   version "0.7.0"
-  resolved "https://registry.yarnpkg.com/kew/-/kew-0.7.0.tgz#79d93d2d33363d6fdd2970b335d9141ad591d79b"
+  resolved "https://registry.npmjs.org/kew/-/kew-0.7.0.tgz"
   integrity sha1-edk9LTM2PW/dKXCzNdkUGtWR15s=
 
 kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
   version "3.2.2"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz"
   integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
   dependencies:
     is-buffer "^1.1.5"
 
 kind-of@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz"
   integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc=
   dependencies:
     is-buffer "^1.1.5"
 
 kind-of@^5.0.0:
   version "5.1.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz"
   integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==
 
 kind-of@^6.0.0, kind-of@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.2.tgz#01146b36a6218e64e58f3a8d66de5d7fc6f6d051"
+  resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz"
   integrity sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==
 
 klaw@^1.0.0:
   version "1.3.1"
-  resolved "https://registry.yarnpkg.com/klaw/-/klaw-1.3.1.tgz#4088433b46b3b1ba259d78785d8e96f73ba02439"
+  resolved "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz"
   integrity sha1-QIhDO0azsbolnXh4XY6W9zugJDk=
   optionalDependencies:
     graceful-fs "^4.1.9"
 
 leven@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/leven/-/leven-2.1.0.tgz#c2e7a9f772094dee9d34202ae8acce4687875580"
+  resolved "https://registry.npmjs.org/leven/-/leven-2.1.0.tgz"
   integrity sha1-wuep93IJTe6dNCAq6KzORoeHVYA=
 
 levn@^0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
+  resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz"
   integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
   dependencies:
     prelude-ls "^1.2.1"
@@ -5876,7 +6081,7 @@ levn@^0.4.1:
 
 levn@~0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
+  resolved "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz"
   integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=
   dependencies:
     prelude-ls "~1.1.2"
@@ -5884,14 +6089,14 @@ levn@~0.3.0:
 
 lie@~3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/lie/-/lie-3.1.1.tgz#9a436b2cc7746ca59de7a41fa469b3efb76bd87e"
+  resolved "https://registry.npmjs.org/lie/-/lie-3.1.1.tgz"
   integrity sha1-mkNrLMd0bKWd56QfpGmz77dr2H4=
   dependencies:
     immediate "~3.0.5"
 
 lint-staged@^8.0.0:
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-8.1.0.tgz#dbc3ae2565366d8f20efb9f9799d076da64863f2"
+  resolved "https://registry.npmjs.org/lint-staged/-/lint-staged-8.1.0.tgz"
   integrity sha512-yfSkyJy7EuVsaoxtUSEhrD81spdJOe/gMTGea3XaV7HyoRhTb9Gdlp6/JppRZERvKSEYXP9bjcmq6CA5oL2lYQ==
   dependencies:
     "@iamstarkov/listr-update-renderer" "0.4.1"
@@ -5922,12 +6127,12 @@ lint-staged@^8.0.0:
 
 listr-silent-renderer@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz#924b5a3757153770bf1a8e3fbf74b8bbf3f9242e"
+  resolved "https://registry.npmjs.org/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz"
   integrity sha1-kktaN1cVN3C/Go4/v3S4u/P5JC4=
 
 listr-update-renderer@^0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/listr-update-renderer/-/listr-update-renderer-0.5.0.tgz#4ea8368548a7b8aecb7e06d8c95cb45ae2ede6a2"
+  resolved "https://registry.npmjs.org/listr-update-renderer/-/listr-update-renderer-0.5.0.tgz"
   integrity sha512-tKRsZpKz8GSGqoI/+caPmfrypiaq+OQCbd+CovEC24uk1h952lVj5sC7SqyFUm+OaJ5HN/a1YLt5cit2FMNsFA==
   dependencies:
     chalk "^1.1.3"
@@ -5941,7 +6146,7 @@ listr-update-renderer@^0.5.0:
 
 listr-verbose-renderer@^0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/listr-verbose-renderer/-/listr-verbose-renderer-0.5.0.tgz#f1132167535ea4c1261102b9f28dac7cba1e03db"
+  resolved "https://registry.npmjs.org/listr-verbose-renderer/-/listr-verbose-renderer-0.5.0.tgz"
   integrity sha512-04PDPqSlsqIOaaaGZ+41vq5FejI9auqTInicFRndCBgE3bXG8D6W1I+mWhk+1nqbHmyhla/6BUrd5OSiHwKRXw==
   dependencies:
     chalk "^2.4.1"
@@ -5951,7 +6156,7 @@ listr-verbose-renderer@^0.5.0:
 
 listr@^0.14.2:
   version "0.14.3"
-  resolved "https://registry.yarnpkg.com/listr/-/listr-0.14.3.tgz#2fea909604e434be464c50bddba0d496928fa586"
+  resolved "https://registry.npmjs.org/listr/-/listr-0.14.3.tgz"
   integrity sha512-RmAl7su35BFd/xoMamRjpIE4j3v+L28o8CT5YhAXQJm1fD+1l9ngXY8JAQRJ+tFK2i5njvi0iRUKV09vPwA0iA==
   dependencies:
     "@samverschueren/stream-to-observable" "^0.3.0"
@@ -5966,7 +6171,7 @@ listr@^0.14.2:
 
 load-json-file@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
+  resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz"
   integrity sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=
   dependencies:
     graceful-fs "^4.1.2"
@@ -5977,7 +6182,7 @@ load-json-file@^1.0.0:
 
 load-json-file@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b"
+  resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-4.0.0.tgz"
   integrity sha1-L19Fq5HjMhYjT9U62rZo607AmTs=
   dependencies:
     graceful-fs "^4.1.2"
@@ -5987,12 +6192,12 @@ load-json-file@^4.0.0:
 
 loader-runner@^2.3.0:
   version "2.3.1"
-  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-2.3.1.tgz#026f12fe7c3115992896ac02ba022ba92971b979"
+  resolved "https://registry.npmjs.org/loader-runner/-/loader-runner-2.3.1.tgz"
   integrity sha512-By6ZFY7ETWOc9RFaAIb23IjJVcM4dvJC/N57nmdz9RSkMXvAXGI7SyVlAw3v8vjtDRlqThgVDVmTnr9fqMlxkw==
 
 loader-utils@^1.0.2, loader-utils@^1.1.0:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-1.2.3.tgz#1ff5dc6911c9f0a062531a4c04b609406108c2c7"
+  resolved "https://registry.npmjs.org/loader-utils/-/loader-utils-1.2.3.tgz"
   integrity sha512-fkpz8ejdnEMG3s37wGL07iSBDg99O9D5yflE9RGNH3hRdx9SOwYfnGYdZOUIZitN8E+E2vkq3MUMYMvPYl5ZZA==
   dependencies:
     big.js "^5.2.2"
@@ -6001,7 +6206,7 @@ loader-utils@^1.0.2, loader-utils@^1.1.0:
 
 loader-utils@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.0.tgz#e4cace5b816d425a166b5f097e10cd12b36064b0"
+  resolved "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.0.tgz"
   integrity sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==
   dependencies:
     big.js "^5.2.2"
@@ -6010,7 +6215,7 @@ loader-utils@^2.0.0:
 
 locate-path@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz"
   integrity sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=
   dependencies:
     p-locate "^2.0.0"
@@ -6018,7 +6223,7 @@ locate-path@^2.0.0:
 
 locate-path@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz"
   integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
   dependencies:
     p-locate "^3.0.0"
@@ -6026,24 +6231,24 @@ locate-path@^3.0.0:
 
 locate-path@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
+  resolved "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz"
   integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
   dependencies:
     p-locate "^4.1.0"
 
 lodash._arraycopy@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._arraycopy/-/lodash._arraycopy-3.0.0.tgz#76e7b7c1f1fb92547374878a562ed06a3e50f6e1"
+  resolved "https://registry.npmjs.org/lodash._arraycopy/-/lodash._arraycopy-3.0.0.tgz"
   integrity sha1-due3wfH7klRzdIeKVi7Qaj5Q9uE=
 
 lodash._arrayeach@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._arrayeach/-/lodash._arrayeach-3.0.0.tgz#bab156b2a90d3f1bbd5c653403349e5e5933ef9e"
+  resolved "https://registry.npmjs.org/lodash._arrayeach/-/lodash._arrayeach-3.0.0.tgz"
   integrity sha1-urFWsqkNPxu9XGU0AzSeXlkz754=
 
 lodash._baseassign@^3.0.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz#8c38a099500f215ad09e59f1722fd0c52bfe0a4e"
+  resolved "https://registry.npmjs.org/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz"
   integrity sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=
   dependencies:
     lodash._basecopy "^3.0.0"
@@ -6051,7 +6256,7 @@ lodash._baseassign@^3.0.0:
 
 lodash._baseclone@^3.0.0:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/lodash._baseclone/-/lodash._baseclone-3.3.0.tgz#303519bf6393fe7e42f34d8b630ef7794e3542b7"
+  resolved "https://registry.npmjs.org/lodash._baseclone/-/lodash._baseclone-3.3.0.tgz"
   integrity sha1-MDUZv2OT/n5C802LYw73eU41Qrc=
   dependencies:
     lodash._arraycopy "^3.0.0"
@@ -6063,52 +6268,52 @@ lodash._baseclone@^3.0.0:
 
 lodash._baseclone@^4.0.0:
   version "4.5.7"
-  resolved "https://registry.yarnpkg.com/lodash._baseclone/-/lodash._baseclone-4.5.7.tgz#ce42ade08384ef5d62fa77c30f61a46e686f8434"
+  resolved "https://registry.npmjs.org/lodash._baseclone/-/lodash._baseclone-4.5.7.tgz"
   integrity sha1-zkKt4IOE711i+nfDD2GkbmhvhDQ=
 
 lodash._basecopy@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz#8da0e6a876cf344c0ad8a54882111dd3c5c7ca36"
+  resolved "https://registry.npmjs.org/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz"
   integrity sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=
 
 lodash._basecreate@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/lodash._basecreate/-/lodash._basecreate-3.0.3.tgz#1bc661614daa7fc311b7d03bf16806a0213cf821"
+  resolved "https://registry.npmjs.org/lodash._basecreate/-/lodash._basecreate-3.0.3.tgz"
   integrity sha1-G8ZhYU2qf8MRt9A78WgGoCE8+CE=
 
 lodash._basefor@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/lodash._basefor/-/lodash._basefor-3.0.3.tgz#7550b4e9218ef09fad24343b612021c79b4c20c2"
+  resolved "https://registry.npmjs.org/lodash._basefor/-/lodash._basefor-3.0.3.tgz"
   integrity sha1-dVC06SGO8J+tJDQ7YSAhx5tMIMI=
 
 lodash._bindcallback@^3.0.0:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/lodash._bindcallback/-/lodash._bindcallback-3.0.1.tgz#e531c27644cf8b57a99e17ed95b35c748789392e"
+  resolved "https://registry.npmjs.org/lodash._bindcallback/-/lodash._bindcallback-3.0.1.tgz"
   integrity sha1-5THCdkTPi1epnhftlbNcdIeJOS4=
 
 lodash._getnative@^3.0.0:
   version "3.9.1"
-  resolved "https://registry.yarnpkg.com/lodash._getnative/-/lodash._getnative-3.9.1.tgz#570bc7dede46d61cdcde687d65d3eecbaa3aaff5"
+  resolved "https://registry.npmjs.org/lodash._getnative/-/lodash._getnative-3.9.1.tgz"
   integrity sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=
 
 lodash._isiterateecall@^3.0.0:
   version "3.0.9"
-  resolved "https://registry.yarnpkg.com/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz#5203ad7ba425fae842460e696db9cf3e6aac057c"
+  resolved "https://registry.npmjs.org/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz"
   integrity sha1-UgOte6Ql+uhCRg5pbbnPPmqsBXw=
 
 lodash._reinterpolate@^3.0.0, lodash._reinterpolate@~3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d"
+  resolved "https://registry.npmjs.org/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz"
   integrity sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=
 
 lodash._stack@^4.0.0:
   version "4.1.3"
-  resolved "https://registry.yarnpkg.com/lodash._stack/-/lodash._stack-4.1.3.tgz#751aa76c1b964b047e76d14fc72a093fcb5e2dd0"
+  resolved "https://registry.npmjs.org/lodash._stack/-/lodash._stack-4.1.3.tgz"
   integrity sha1-dRqnbBuWSwR+dtFPxyoJP8teLdA=
 
 lodash.clone@3.0.3:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/lodash.clone/-/lodash.clone-3.0.3.tgz#84688c73d32b5a90ca25616963f189252a997043"
+  resolved "https://registry.npmjs.org/lodash.clone/-/lodash.clone-3.0.3.tgz"
   integrity sha1-hGiMc9MrWpDKJWFpY/GJJSqZcEM=
   dependencies:
     lodash._baseclone "^3.0.0"
@@ -6117,12 +6322,12 @@ lodash.clone@3.0.3:
 
 lodash.clonedeep@^4.5.0:
   version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
+  resolved "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz"
   integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
 
 lodash.create@3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/lodash.create/-/lodash.create-3.1.1.tgz#d7f2849f0dbda7e04682bb8cd72ab022461debe7"
+  resolved "https://registry.npmjs.org/lodash.create/-/lodash.create-3.1.1.tgz"
   integrity sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=
   dependencies:
     lodash._baseassign "^3.0.0"
@@ -6131,12 +6336,12 @@ lodash.create@3.1.1:
 
 lodash.debounce@^4.0.8:
   version "4.0.8"
-  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
+  resolved "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz"
   integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168=
 
 lodash.defaultsdeep@4.3.2:
   version "4.3.2"
-  resolved "https://registry.yarnpkg.com/lodash.defaultsdeep/-/lodash.defaultsdeep-4.3.2.tgz#6c1a586e6c5647b0e64e2d798141b8836158be8a"
+  resolved "https://registry.npmjs.org/lodash.defaultsdeep/-/lodash.defaultsdeep-4.3.2.tgz"
   integrity sha1-bBpYbmxWR7DmTi15gUG4g2FYvoo=
   dependencies:
     lodash._baseclone "^4.0.0"
@@ -6148,27 +6353,27 @@ lodash.defaultsdeep@4.3.2:
 
 lodash.flatten@^4.4.0:
   version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
+  resolved "https://registry.npmjs.org/lodash.flatten/-/lodash.flatten-4.4.0.tgz"
   integrity sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=
 
 lodash.isarguments@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz#2f573d85c6a24289ff00663b491c1d338ff3458a"
+  resolved "https://registry.npmjs.org/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz"
   integrity sha1-L1c9hcaiQon/AGY7SRwdM4/zRYo=
 
 lodash.isarray@^3.0.0:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/lodash.isarray/-/lodash.isarray-3.0.4.tgz#79e4eb88c36a8122af86f844aa9bcd851b5fbb55"
+  resolved "https://registry.npmjs.org/lodash.isarray/-/lodash.isarray-3.0.4.tgz"
   integrity sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=
 
 lodash.isplainobject@^4.0.0:
   version "4.0.6"
-  resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb"
+  resolved "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz"
   integrity sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=
 
 lodash.keys@^3.0.0:
   version "3.1.2"
-  resolved "https://registry.yarnpkg.com/lodash.keys/-/lodash.keys-3.1.2.tgz#4dbc0472b156be50a0b286855d1bd0b0c656098a"
+  resolved "https://registry.npmjs.org/lodash.keys/-/lodash.keys-3.1.2.tgz"
   integrity sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=
   dependencies:
     lodash._getnative "^3.0.0"
@@ -6177,27 +6382,27 @@ lodash.keys@^3.0.0:
 
 lodash.keysin@^4.0.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.keysin/-/lodash.keysin-4.2.0.tgz#8cc3fb35c2d94acc443a1863e02fa40799ea6f28"
+  resolved "https://registry.npmjs.org/lodash.keysin/-/lodash.keysin-4.2.0.tgz"
   integrity sha1-jMP7NcLZSsxEOhhj4C+kB5nqbyg=
 
 lodash.map@^4.5.1:
   version "4.6.0"
-  resolved "https://registry.yarnpkg.com/lodash.map/-/lodash.map-4.6.0.tgz#771ec7839e3473d9c4cde28b19394c3562f4f6d3"
+  resolved "https://registry.npmjs.org/lodash.map/-/lodash.map-4.6.0.tgz"
   integrity sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=
 
 lodash.mergewith@^4.0.0:
   version "4.6.1"
-  resolved "https://registry.yarnpkg.com/lodash.mergewith/-/lodash.mergewith-4.6.1.tgz#639057e726c3afbdb3e7d42741caa8d6e4335927"
+  resolved "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.1.tgz"
   integrity sha512-eWw5r+PYICtEBgrBE5hhlT6aAa75f411bgDz/ZL2KZqYV03USvucsxcHUIlGTDTECs1eunpI7HOV7U+WLDvNdQ==
 
 lodash.rest@^4.0.0:
   version "4.0.5"
-  resolved "https://registry.yarnpkg.com/lodash.rest/-/lodash.rest-4.0.5.tgz#954ef75049262038c96d1fc98b28fdaf9f0772aa"
+  resolved "https://registry.npmjs.org/lodash.rest/-/lodash.rest-4.0.5.tgz"
   integrity sha1-lU73UEkmIDjJbR/Jiyj9r58Hcqo=
 
 lodash.template@^4.0.2, lodash.template@^4.4.0:
   version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.template/-/lodash.template-4.5.0.tgz#f976195cf3f347d0d5f52483569fe8031ccce8ab"
+  resolved "https://registry.npmjs.org/lodash.template/-/lodash.template-4.5.0.tgz"
   integrity sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==
   dependencies:
     lodash._reinterpolate "^3.0.0"
@@ -6205,58 +6410,58 @@ lodash.template@^4.0.2, lodash.template@^4.4.0:
 
 lodash.templatesettings@^4.0.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/lodash.templatesettings/-/lodash.templatesettings-4.1.0.tgz#2b4d4e95ba440d915ff08bc899e4553666713316"
+  resolved "https://registry.npmjs.org/lodash.templatesettings/-/lodash.templatesettings-4.1.0.tgz"
   integrity sha1-K01OlbpEDZFf8IvImeRVNmZxMxY=
   dependencies:
     lodash._reinterpolate "~3.0.0"
 
 lodash.truncate@^4.4.2:
   version "4.4.2"
-  resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193"
+  resolved "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz"
   integrity sha1-WjUNoLERO4N+z//VgSy+WNbq4ZM=
 
 lodash.uniq@^4.5.0:
   version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
+  resolved "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz"
   integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
 
 lodash@4.17.5:
   version "4.17.5"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.5.tgz#99a92d65c0272debe8c96b6057bc8fbfa3bed511"
+  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.5.tgz"
   integrity sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==
 
 lodash@^4.0.1, lodash@^4.16.6, lodash@^4.17.0, lodash@^4.17.10, lodash@^4.17.14, lodash@^4.17.5, lodash@^4.2.1, lodash@^4.3.0, lodash@^4.5.0:
   version "4.17.20"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52"
+  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz"
   integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==
 
 lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.21:
   version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
+  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
 
 lodash@^4.17.4:
   version "4.17.19"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.19.tgz#e48ddedbe30b3321783c5b4301fbd353bc1e4a4b"
+  resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.19.tgz"
   integrity sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ==
 
 log-symbols@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-1.0.2.tgz#376ff7b58ea3086a0f09facc74617eca501e1a18"
+  resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-1.0.2.tgz"
   integrity sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=
   dependencies:
     chalk "^1.0.0"
 
 log-symbols@^2.1.0, log-symbols@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-2.2.0.tgz#5740e1c5d6f0dfda4ad9323b5332107ef6b4c40a"
+  resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-2.2.0.tgz"
   integrity sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==
   dependencies:
     chalk "^2.0.1"
 
 log-update@^2.3.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/log-update/-/log-update-2.3.0.tgz#88328fd7d1ce7938b29283746f0b1bc126b24708"
+  resolved "https://registry.npmjs.org/log-update/-/log-update-2.3.0.tgz"
   integrity sha1-iDKP19HOeTiykoN0bwsbwSayRwg=
   dependencies:
     ansi-escapes "^3.0.0"
@@ -6265,7 +6470,7 @@ log-update@^2.3.0:
 
 log4js@^3.0.0:
   version "3.0.6"
-  resolved "https://registry.yarnpkg.com/log4js/-/log4js-3.0.6.tgz#e6caced94967eeeb9ce399f9f8682a4b2b28c8ff"
+  resolved "https://registry.npmjs.org/log4js/-/log4js-3.0.6.tgz"
   integrity sha512-ezXZk6oPJCWL483zj64pNkMuY/NcRX5MPiB0zE6tjZM137aeusrOnW1ecxgF9cmwMWkBMhjteQxBPoZBh9FDxQ==
   dependencies:
     circular-json "^0.5.5"
@@ -6276,19 +6481,19 @@ log4js@^3.0.0:
 
 longest@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097"
+  resolved "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz"
   integrity sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=
 
 loose-envify@^1.0.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
+  resolved "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz"
   integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
 loud-rejection@^1.0.0:
   version "1.6.0"
-  resolved "https://registry.yarnpkg.com/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f"
+  resolved "https://registry.npmjs.org/loud-rejection/-/loud-rejection-1.6.0.tgz"
   integrity sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=
   dependencies:
     currently-unhandled "^0.4.1"
@@ -6296,7 +6501,7 @@ loud-rejection@^1.0.0:
 
 lru-cache@4.1.x, lru-cache@^4.0.1:
   version "4.1.5"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-4.1.5.tgz#8bbe50ea85bed59bc9e33dcab8235ee9bcf443cd"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz"
   integrity sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==
   dependencies:
     pseudomap "^1.0.2"
@@ -6304,94 +6509,94 @@ lru-cache@4.1.x, lru-cache@^4.0.1:
 
 lru-cache@^5.1.1:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz"
   integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
   dependencies:
     yallist "^3.0.2"
 
 lru-cache@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
   integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
   dependencies:
     yallist "^4.0.0"
 
 lru-cache@~2.6.5:
   version "2.6.5"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-2.6.5.tgz#e56d6354148ede8d7707b58d143220fd08df0fd5"
+  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-2.6.5.tgz"
   integrity sha1-5W1jVBSO3o13B7WNFDIg/QjfD9U=
 
 magic-string@^0.25.0, magic-string@^0.25.7:
   version "0.25.7"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051"
+  resolved "https://registry.npmjs.org/magic-string/-/magic-string-0.25.7.tgz"
   integrity sha512-4CrMT5DOHTDk4HYDlzmwu4FVCcIYI8gauveasrdCu2IKIFOJ3f0v/8MDGJCDL9oD2ppz/Av1b0Nj345H9M+XIA==
   dependencies:
     sourcemap-codec "^1.4.4"
 
 make-dir@^1.0.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-1.3.0.tgz#79c1033b80515bd6d24ec9933e860ca75ee27f0c"
+  resolved "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz"
   integrity sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==
   dependencies:
     pify "^3.0.0"
 
 make-dir@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
+  resolved "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz"
   integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
   dependencies:
     pify "^4.0.1"
     semver "^5.6.0"
 
-make-dir@^3.0.2:
+make-dir@^3.0.2, make-dir@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
+  resolved "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz"
   integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
   dependencies:
     semver "^6.0.0"
 
 make-error@^1.1.1:
   version "1.3.6"
-  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
+  resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz"
   integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
 
 map-cache@^0.2.2:
   version "0.2.2"
-  resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
+  resolved "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz"
   integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=
 
 map-obj@^1.0.0, map-obj@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
+  resolved "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz"
   integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=
 
 map-obj@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-2.0.0.tgz#a65cd29087a92598b8791257a523e021222ac1f9"
+  resolved "https://registry.npmjs.org/map-obj/-/map-obj-2.0.0.tgz"
   integrity sha1-plzSkIepJZi4eRJXpSPgISIqwfk=
 
 map-visit@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
+  resolved "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz"
   integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=
   dependencies:
     object-visit "^1.0.0"
 
 matcher@^1.0.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/matcher/-/matcher-1.1.1.tgz#51d8301e138f840982b338b116bb0c09af62c1c2"
+  resolved "https://registry.npmjs.org/matcher/-/matcher-1.1.1.tgz"
   integrity sha512-+BmqxWIubKTRKNWx/ahnCkk3mG8m7OturVlqq6HiojGJTd5hVYbgZm6WzcYPCoB+KBT4Vd6R7WSRG2OADNaCjg==
   dependencies:
     escape-string-regexp "^1.0.4"
 
 math-random@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.1.tgz#8b3aac588b8a66e4975e3cdea67f7bb329601fac"
+  resolved "https://registry.npmjs.org/math-random/-/math-random-1.0.1.tgz"
   integrity sha1-izqsWIuKZuSXXjzepn97sylgH6w=
 
 md5.js@^1.3.4:
   version "1.3.5"
-  resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
+  resolved "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz"
   integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
   dependencies:
     hash-base "^3.0.0"
@@ -6400,12 +6605,12 @@ md5.js@^1.3.4:
 
 media-typer@0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
+  resolved "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz"
   integrity sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=
 
 memory-fs@^0.4.0, memory-fs@~0.4.1:
   version "0.4.1"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.4.1.tgz#3a9a20b8462523e447cfbc7e8bb80ed667bfc552"
+  resolved "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz"
   integrity sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=
   dependencies:
     errno "^0.1.3"
@@ -6413,7 +6618,7 @@ memory-fs@^0.4.0, memory-fs@~0.4.1:
 
 memory-fs@^0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
+  resolved "https://registry.npmjs.org/memory-fs/-/memory-fs-0.5.0.tgz"
   integrity sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==
   dependencies:
     errno "^0.1.3"
@@ -6421,7 +6626,7 @@ memory-fs@^0.5.0:
 
 meow@^3.3.0:
   version "3.7.0"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-3.7.0.tgz#72cb668b425228290abbfa856892587308a801fb"
+  resolved "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz"
   integrity sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=
   dependencies:
     camelcase-keys "^2.0.0"
@@ -6437,7 +6642,7 @@ meow@^3.3.0:
 
 meow@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-4.0.1.tgz#d48598f6f4b1472f35bf6317a95945ace347f975"
+  resolved "https://registry.npmjs.org/meow/-/meow-4.0.1.tgz"
   integrity sha512-xcSBHD5Z86zaOc+781KrupuHAzeGXSLtiAOmBsiLDiPSaYSB6hdew2ng9EBAnZ62jagG9MHAOdxpDi/lWBFJ/A==
   dependencies:
     camelcase-keys "^4.0.0"
@@ -6452,17 +6657,17 @@ meow@^4.0.0:
 
 merge2@^1.3.0:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
+  resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
 merge@^1.2.0:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/merge/-/merge-1.2.1.tgz#38bebf80c3220a8a487b6fcfb3941bb11720c145"
+  resolved "https://registry.npmjs.org/merge/-/merge-1.2.1.tgz"
   integrity sha512-VjFo4P5Whtj4vsLzsYBu5ayHhoHJ0UqNm7ibvShmbmoz7tGi0vXaoJbGdB+GmDMLUdg8DpQXEIeVDAe8MaABvQ==
 
 micromatch@^2.3.7:
   version "2.3.11"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565"
+  resolved "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz"
   integrity sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=
   dependencies:
     arr-diff "^2.0.0"
@@ -6481,7 +6686,7 @@ micromatch@^2.3.7:
 
 micromatch@^3.1.10, micromatch@^3.1.4, micromatch@^3.1.8:
   version "3.1.10"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
+  resolved "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz"
   integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
   dependencies:
     arr-diff "^4.0.0"
@@ -6500,7 +6705,7 @@ micromatch@^3.1.10, micromatch@^3.1.4, micromatch@^3.1.8:
 
 micromatch@^4.0.0, micromatch@^4.0.2:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.2.tgz#4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259"
+  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.2.tgz"
   integrity sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==
   dependencies:
     braces "^3.0.1"
@@ -6508,7 +6713,7 @@ micromatch@^4.0.0, micromatch@^4.0.2:
 
 miller-rabin@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
+  resolved "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz"
   integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==
   dependencies:
     bn.js "^4.0.0"
@@ -6516,58 +6721,58 @@ miller-rabin@^4.0.0:
 
 mime-db@~1.37.0:
   version "1.37.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.37.0.tgz#0b6a0ce6fdbe9576e25f1f2d2fde8830dc0ad0d8"
+  resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.37.0.tgz"
   integrity sha512-R3C4db6bgQhlIhPU48fUtdVmKnflq+hRdad7IyKhtFj06VPNVdk2RhiYL3UjQIlso8L+YxAtFkobT0VK+S/ybg==
 
 mime-types@^2.1.12, mime-types@~2.1.18, mime-types@~2.1.19:
   version "2.1.21"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.21.tgz#28995aa1ecb770742fe6ae7e58f9181c744b3f96"
+  resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.21.tgz"
   integrity sha512-3iL6DbwpyLzjR3xHSFNFeb9Nz/M8WDkX33t1GFQnFOllWk8pOrh/LSrB5OXlnlW5P9LH73X6loW/eogc+F5lJg==
   dependencies:
     mime-db "~1.37.0"
 
 mime@^1.6.0:
   version "1.6.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
+  resolved "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz"
   integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
 
 mime@^2.0.3, mime@^2.3.1:
   version "2.4.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-2.4.0.tgz#e051fd881358585f3279df333fe694da0bcffdd6"
+  resolved "https://registry.npmjs.org/mime/-/mime-2.4.0.tgz"
   integrity sha512-ikBcWwyqXQSHKtciCcctu9YfPbFYZ4+gbHEmE0Q8jzcTYQg5dHCr3g2wwAZjPoJfQVXZq6KXAjpXOTf5/cjT7w==
 
 mimic-fn@^1.0.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
+  resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz"
   integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==
 
 minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
+  resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz"
   integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
 
 minimalistic-crypto-utils@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
+  resolved "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz"
   integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
 
 "minimatch@2 || 3", minimatch@^3.0.0, minimatch@^3.0.2, minimatch@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz"
   integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
   dependencies:
     brace-expansion "^1.1.7"
 
 minimatch@3.0.3:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774"
+  resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.0.3.tgz"
   integrity sha1-Kk5AkLlrLbBqnX3wEFWmKnfJt3Q=
   dependencies:
     brace-expansion "^1.0.0"
 
 minimist-options@^3.0.1:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-3.0.2.tgz#fba4c8191339e13ecf4d61beb03f070103f3d954"
+  resolved "https://registry.npmjs.org/minimist-options/-/minimist-options-3.0.2.tgz"
   integrity sha512-FyBrT/d0d4+uiZRbqznPXqw3IpZZG3gl3wKWiX784FycUKVwBt0uLBFkQrtE4tZOrgo78nZp2jnKz3L65T5LdQ==
   dependencies:
     arrify "^1.0.1"
@@ -6575,42 +6780,42 @@ minimist-options@^3.0.1:
 
 minimist@0.0.8:
   version "0.0.8"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
+  resolved "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz"
   integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=
 
 minimist@1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
+  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz"
   integrity sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=
 
 minimist@^1.1.0, minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5:
   version "1.2.5"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
+  resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz"
   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
 
 minimist@~0.0.1:
   version "0.0.10"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.10.tgz#de3f98543dbf96082be48ad1a0c7cda836301dcf"
+  resolved "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz"
   integrity sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=
 
-minipass@^2.2.1, minipass@^2.3.4:
-  version "2.3.5"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-2.3.5.tgz#cacebe492022497f656b0f0f51e2682a9ed2d848"
-  integrity sha512-Gi1W4k059gyRbyVUZQ4mEqLm0YIUiGYfvxhF6SIlk3ui1WVxMTGfGdQ2SInh3PDrRTVvPKgULkpJtT4RH10+VA==
+minipass@^3.0.0:
+  version "3.1.6"
+  resolved "https://registry.npmjs.org/minipass/-/minipass-3.1.6.tgz"
+  integrity sha512-rty5kpw9/z8SX9dmxblFA6edItUmwJgMeYDZRrwlIVN27i8gysGbznJwUggw2V/FVqFSDdWy040ZPS811DYAqQ==
   dependencies:
-    safe-buffer "^5.1.2"
-    yallist "^3.0.0"
+    yallist "^4.0.0"
 
-minizlib@^1.1.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-1.2.1.tgz#dd27ea6136243c7c880684e8672bb3a45fd9b614"
-  integrity sha512-7+4oTUOWKg7AuL3vloEWekXY2/D20cevzsrNT2kGWm+39J9hGTCBv8VI5Pm5lXZ/o3/mdR4f8rflAPhnQb8mPA==
+minizlib@^2.1.1:
+  version "2.1.2"
+  resolved "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz"
+  integrity sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==
   dependencies:
-    minipass "^2.2.1"
+    minipass "^3.0.0"
+    yallist "^4.0.0"
 
 mississippi@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/mississippi/-/mississippi-3.0.0.tgz#ea0a3291f97e0b5e8776b363d5f0a12d94c67022"
+  resolved "https://registry.npmjs.org/mississippi/-/mississippi-3.0.0.tgz"
   integrity sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==
   dependencies:
     concat-stream "^1.5.0"
@@ -6626,34 +6831,39 @@ mississippi@^3.0.0:
 
 mixin-deep@^1.2.0:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
+  resolved "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz"
   integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==
   dependencies:
     for-in "^1.0.2"
     is-extendable "^1.0.1"
 
-mkdirp@0.5.1, mkdirp@0.5.x, mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@~0.5.0:
+mkdirp@0.5.1, mkdirp@0.5.x, mkdirp@^0.5.1, mkdirp@~0.5.0:
   version "0.5.1"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
+  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz"
   integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=
   dependencies:
     minimist "0.0.8"
 
 mkdirp@^0.5.5:
   version "0.5.5"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
+  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz"
   integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
   dependencies:
     minimist "^1.2.5"
 
+mkdirp@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz"
+  integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
+
 mkpath@1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/mkpath/-/mkpath-1.0.0.tgz#ebb3a977e7af1c683ae6fda12b545a6ba6c5853d"
+  resolved "https://registry.npmjs.org/mkpath/-/mkpath-1.0.0.tgz"
   integrity sha1-67Opd+evHGg65v2hK1Raa6bFhT0=
 
 mocha-nightwatch@3.2.2:
   version "3.2.2"
-  resolved "https://registry.yarnpkg.com/mocha-nightwatch/-/mocha-nightwatch-3.2.2.tgz#91bcb9b3bde057dd7677c78125e491e58d66647c"
+  resolved "https://registry.npmjs.org/mocha-nightwatch/-/mocha-nightwatch-3.2.2.tgz"
   integrity sha1-kby5s73gV912d8eBJeSR5Y1mZHw=
   dependencies:
     browser-stdout "1.3.0"
@@ -6670,12 +6880,12 @@ mocha-nightwatch@3.2.2:
 
 modify-values@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022"
+  resolved "https://registry.npmjs.org/modify-values/-/modify-values-1.0.1.tgz"
   integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
 
 move-concurrently@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/move-concurrently/-/move-concurrently-1.0.1.tgz#be2c005fda32e0b29af1f05d7c4b33214c701f92"
+  resolved "https://registry.npmjs.org/move-concurrently/-/move-concurrently-1.0.1.tgz"
   integrity sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=
   dependencies:
     aproba "^1.1.1"
@@ -6687,42 +6897,42 @@ move-concurrently@^1.0.1:
 
 ms@0.7.1:
   version "0.7.1"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-0.7.1.tgz#9cd13c03adbff25b65effde7ce864ee952017098"
+  resolved "https://registry.npmjs.org/ms/-/ms-0.7.1.tgz"
   integrity sha1-nNE8A62/8ltl7/3nzoZO6VIBcJg=
 
 ms@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz"
   integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
 
 ms@2.1.2:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz"
   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
 
 ms@^2.1.1:
   version "2.1.3"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
+  resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
 mute-stream@0.0.6:
   version "0.0.6"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.6.tgz#48962b19e169fd1dfc240b3f1e7317627bbc47db"
+  resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.6.tgz"
   integrity sha1-SJYrGeFp/R38JAs/HnMXYnu8R9s=
 
 mute-stream@0.0.7:
   version "0.0.7"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
+  resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz"
   integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=
 
-nan@^2.9.2:
-  version "2.12.1"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.12.1.tgz#7b1aa193e9aa86057e3c7bbd0ac448e770925552"
-  integrity sha512-JY7V6lRkStKcKTvHO5NVSQRv+RV+FIL5pvDoLiAtSL9pKlC5x9PKQcZDsq7m4FO4d57mkhC6Z+QhAh3Jdk5JFw==
+nan@^2.12.1:
+  version "2.15.0"
+  resolved "https://registry.yarnpkg.com/nan/-/nan-2.15.0.tgz#3f34a473ff18e15c1b5626b62903b5ad6e665fee"
+  integrity sha512-8ZtvEnA2c5aYCZYd1cvgdnU6cqwixRoYg70xPLWUws5ORTa/lnw+u4amixRS/Ac5U5mQVgp9pnlSUnbNWFaWZQ==
 
 nanomatch@^1.2.9:
   version "1.2.13"
-  resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
+  resolved "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz"
   integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==
   dependencies:
     arr-diff "^4.0.0"
@@ -6739,46 +6949,37 @@ nanomatch@^1.2.9:
 
 natural-compare@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
+  resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz"
   integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=
 
-needle@^2.2.1:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/needle/-/needle-2.2.4.tgz#51931bff82533b1928b7d1d69e01f1b00ffd2a4e"
-  integrity sha512-HyoqEb4wr/rsoaIDfTH2aVL9nWtQqba2/HvMv+++m8u0dz808MaagKILxtfeSN7QU7nvbQ79zk3vYOJp9zsNEA==
-  dependencies:
-    debug "^2.1.2"
-    iconv-lite "^0.4.4"
-    sax "^1.2.4"
-
 negotiator@0.6.1:
   version "0.6.1"
-  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.1.tgz#2b327184e8992101177b28563fb5e7102acd0ca9"
+  resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz"
   integrity sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=
 
 neo-async@^2.5.0, neo-async@^2.6.0:
   version "2.6.2"
-  resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
+  resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
 
 netmask@~1.0.4:
   version "1.0.6"
-  resolved "https://registry.yarnpkg.com/netmask/-/netmask-1.0.6.tgz#20297e89d86f6f6400f250d9f4f6b4c1945fcd35"
+  resolved "https://registry.npmjs.org/netmask/-/netmask-1.0.6.tgz"
   integrity sha1-ICl+idhvb2QA8lDZ9Pa0wZRfzTU=
 
 nice-try@^1.0.4:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
+  resolved "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz"
   integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
 
 nightwatch-helpers@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/nightwatch-helpers/-/nightwatch-helpers-1.2.0.tgz#cdefeb7635074a141825a7b6d1b955b6d7810a0f"
+  resolved "https://registry.npmjs.org/nightwatch-helpers/-/nightwatch-helpers-1.2.0.tgz"
   integrity sha1-ze/rdjUHShQYJae20blVtteBCg8=
 
 nightwatch@^0.9.16:
   version "0.9.21"
-  resolved "https://registry.yarnpkg.com/nightwatch/-/nightwatch-0.9.21.tgz#9e794a7514b4fd5f46602d368e50515232ab9e90"
+  resolved "https://registry.npmjs.org/nightwatch/-/nightwatch-0.9.21.tgz"
   integrity sha1-nnlKdRS0/V9GYC02jlBRUjKrnpA=
   dependencies:
     chai-nightwatch "~0.1.x"
@@ -6794,15 +6995,22 @@ nightwatch@^0.9.16:
 
 node-fetch@1.6.3:
   version "1.6.3"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-1.6.3.tgz#dc234edd6489982d58e8f0db4f695029abcd8c04"
+  resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-1.6.3.tgz"
   integrity sha1-3CNO3WSJmC1Y6PDbT2lQKavNjAQ=
   dependencies:
     encoding "^0.1.11"
     is-stream "^1.0.1"
 
+node-fetch@^2.6.7:
+  version "2.6.7"
+  resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.7.tgz"
+  integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==
+  dependencies:
+    whatwg-url "^5.0.0"
+
 node-libs-browser@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/node-libs-browser/-/node-libs-browser-2.1.0.tgz#5f94263d404f6e44767d726901fff05478d600df"
+  resolved "https://registry.npmjs.org/node-libs-browser/-/node-libs-browser-2.1.0.tgz"
   integrity sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==
   dependencies:
     assert "^1.1.1"
@@ -6831,48 +7039,31 @@ node-libs-browser@^2.0.0:
 
 node-modules-regexp@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz#8d9dbe28964a4ac5712e9131642107c71e90ec40"
+  resolved "https://registry.npmjs.org/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz"
   integrity sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA=
 
-node-pre-gyp@^0.10.0:
-  version "0.10.3"
-  resolved "https://registry.yarnpkg.com/node-pre-gyp/-/node-pre-gyp-0.10.3.tgz#3070040716afdc778747b61b6887bf78880b80fc"
-  integrity sha512-d1xFs+C/IPS8Id0qPTZ4bUT8wWryfR/OzzAFxweG+uLN85oPzyo2Iw6bVlLQ/JOdgNonXLCoRyqDzDWq4iw72A==
-  dependencies:
-    detect-libc "^1.0.2"
-    mkdirp "^0.5.1"
-    needle "^2.2.1"
-    nopt "^4.0.1"
-    npm-packlist "^1.1.6"
-    npmlog "^4.0.2"
-    rc "^1.2.7"
-    rimraf "^2.6.1"
-    semver "^5.3.0"
-    tar "^4"
-
 node-releases@^1.1.70:
   version "1.1.71"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.71.tgz#cb1334b179896b1c89ecfdd4b725fb7bbdfc7dbb"
+  resolved "https://registry.npmjs.org/node-releases/-/node-releases-1.1.71.tgz"
   integrity sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==
 
 nopt@3.x:
   version "3.0.6"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-3.0.6.tgz#c6465dbf08abcd4db359317f79ac68a646b28ff9"
+  resolved "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz"
   integrity sha1-xkZdvwirzU2zWTF/eaxopkayj/k=
   dependencies:
     abbrev "1"
 
-nopt@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.1.tgz#d0d4685afd5415193c8c7505602d0d17cd64474d"
-  integrity sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=
+nopt@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz"
+  integrity sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==
   dependencies:
     abbrev "1"
-    osenv "^0.1.4"
 
 normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package-data@^2.3.4, normalize-package-data@^2.3.5:
   version "2.4.0"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.4.0.tgz#12f95a307d58352075a04907b84ac8be98ac012f"
+  resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz"
   integrity sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==
   dependencies:
     hosted-git-info "^2.1.4"
@@ -6882,90 +7073,82 @@ normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package-
 
 normalize-path@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-1.0.0.tgz#32d0e472f91ff345701c15a8311018d3b0a90379"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-1.0.0.tgz"
   integrity sha1-MtDkcvkf80VwHBWoMRAY07CpA3k=
 
 normalize-path@^2.0.1, normalize-path@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz"
   integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=
   dependencies:
     remove-trailing-separator "^1.0.1"
 
-npm-bundled@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-1.0.5.tgz#3c1732b7ba936b3a10325aef616467c0ccbcc979"
-  integrity sha512-m/e6jgWu8/v5niCUKQi9qQl8QdeEduFA96xHDDzFGqly0OOjI7c+60KM/2sppfnUU9JJagf+zs+yGhqSOFj71g==
-
-npm-packlist@^1.1.6:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-1.2.0.tgz#55a60e793e272f00862c7089274439a4cc31fc7f"
-  integrity sha512-7Mni4Z8Xkx0/oegoqlcao/JpPCPEMtUvsmB0q7mgvlMinykJLSRTYuFqoQLYgGY8biuxIeiHO+QNJKbCfljewQ==
-  dependencies:
-    ignore-walk "^3.0.1"
-    npm-bundled "^1.0.1"
+normalize-path@^3.0.0, normalize-path@~3.0.0:
+  version "3.0.0"
+  resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz"
+  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
 npm-path@^2.0.2:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/npm-path/-/npm-path-2.0.4.tgz#c641347a5ff9d6a09e4d9bce5580c4f505278e64"
+  resolved "https://registry.npmjs.org/npm-path/-/npm-path-2.0.4.tgz"
   integrity sha512-IFsj0R9C7ZdR5cP+ET342q77uSRdtWOlWpih5eC+lu29tIDbNEgDbzgVJ5UFvYHWhxDZ5TFkJafFioO0pPQjCw==
   dependencies:
     which "^1.2.10"
 
 npm-run-path@^2.0.0:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f"
+  resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz"
   integrity sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=
   dependencies:
     path-key "^2.0.0"
 
 npm-which@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/npm-which/-/npm-which-3.0.1.tgz#9225f26ec3a285c209cae67c3b11a6b4ab7140aa"
+  resolved "https://registry.npmjs.org/npm-which/-/npm-which-3.0.1.tgz"
   integrity sha1-kiXybsOihcIJyuZ8OxGmtKtxQKo=
   dependencies:
     commander "^2.9.0"
     npm-path "^2.0.2"
     which "^1.2.10"
 
-npmlog@^4.0.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"
-  integrity sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==
+npmlog@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz"
+  integrity sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==
   dependencies:
-    are-we-there-yet "~1.1.2"
-    console-control-strings "~1.1.0"
-    gauge "~2.7.3"
-    set-blocking "~2.0.0"
+    are-we-there-yet "^2.0.0"
+    console-control-strings "^1.1.0"
+    gauge "^3.0.0"
+    set-blocking "^2.0.0"
 
 null-check@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/null-check/-/null-check-1.0.0.tgz#977dffd7176012b9ec30d2a39db5cf72a0439edd"
+  resolved "https://registry.npmjs.org/null-check/-/null-check-1.0.0.tgz"
   integrity sha1-l33/1xdgErnsMNKjnbXPcqBDnt0=
 
 number-is-nan@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
+  resolved "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz"
   integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=
 
 oauth-sign@~0.9.0:
   version "0.9.0"
-  resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
+  resolved "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz"
   integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
 
-object-assign@^4.0.1, object-assign@^4.1.0:
+object-assign@^4.0.1, object-assign@^4.1.0, object-assign@^4.1.1:
   version "4.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
+  resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz"
   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
 
 object-component@0.0.3:
   version "0.0.3"
-  resolved "https://registry.yarnpkg.com/object-component/-/object-component-0.0.3.tgz#f0c69aa50efc95b866c186f400a33769cb2f1291"
+  resolved "https://registry.npmjs.org/object-component/-/object-component-0.0.3.tgz"
   integrity sha1-8MaapQ78lbhmwYb0AKM3acsvEpE=
 
 object-copy@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
+  resolved "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz"
   integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw=
   dependencies:
     copy-descriptor "^0.1.0"
@@ -6974,19 +7157,19 @@ object-copy@^0.1.0:
 
 object-keys@^1.0.12, object-keys@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
+  resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
 object-visit@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
+  resolved "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz"
   integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=
   dependencies:
     isobject "^3.0.0"
 
 object.assign@^4.1.0:
   version "4.1.2"
-  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
+  resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz"
   integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==
   dependencies:
     call-bind "^1.0.0"
@@ -6996,7 +7179,7 @@ object.assign@^4.1.0:
 
 object.getownpropertydescriptors@^2.0.3:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz#8758c846f5b407adab0f236e0986f14b051caa16"
+  resolved "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz"
   integrity sha1-h1jIRvW0B62rDyNuCYbxSwUcqhY=
   dependencies:
     define-properties "^1.1.2"
@@ -7004,7 +7187,7 @@ object.getownpropertydescriptors@^2.0.3:
 
 object.omit@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"
+  resolved "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz"
   integrity sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=
   dependencies:
     for-own "^0.1.4"
@@ -7012,40 +7195,40 @@ object.omit@^2.0.0:
 
 object.pick@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
+  resolved "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz"
   integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=
   dependencies:
     isobject "^3.0.1"
 
 on-finished@~2.3.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.3.0.tgz#20f1336481b083cd75337992a16971aa2d906947"
+  resolved "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz"
   integrity sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=
   dependencies:
     ee-first "1.1.1"
 
 once@1.x, once@^1.3.0, once@^1.3.1, once@^1.4.0:
   version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz"
   integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
   dependencies:
     wrappy "1"
 
 onetime@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-1.1.0.tgz#a1f7838f8314c516f05ecefcbc4ccfe04b4ed789"
+  resolved "https://registry.npmjs.org/onetime/-/onetime-1.1.0.tgz"
   integrity sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=
 
 onetime@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
+  resolved "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz"
   integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=
   dependencies:
     mimic-fn "^1.0.0"
 
 opencollective@1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/opencollective/-/opencollective-1.0.3.tgz#aee6372bc28144583690c3ca8daecfc120dd0ef1"
+  resolved "https://registry.npmjs.org/opencollective/-/opencollective-1.0.3.tgz"
   integrity sha1-ruY3K8KBRFg2kMPKja7PwSDdDvE=
   dependencies:
     babel-polyfill "6.23.0"
@@ -7057,12 +7240,12 @@ opencollective@1.0.3:
 
 opener@^1.5.1:
   version "1.5.2"
-  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
+  resolved "https://registry.npmjs.org/opener/-/opener-1.5.2.tgz"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
 opn@4.0.2:
   version "4.0.2"
-  resolved "https://registry.yarnpkg.com/opn/-/opn-4.0.2.tgz#7abc22e644dff63b0a96d5ab7f2790c0f01abc95"
+  resolved "https://registry.npmjs.org/opn/-/opn-4.0.2.tgz"
   integrity sha1-erwi5kTf9jsKltWrfyeQwPAavJU=
   dependencies:
     object-assign "^4.0.1"
@@ -7070,7 +7253,7 @@ opn@4.0.2:
 
 optimist@0.6.1, optimist@^0.6.1:
   version "0.6.1"
-  resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"
+  resolved "https://registry.npmjs.org/optimist/-/optimist-0.6.1.tgz"
   integrity sha1-2j6nRob6IaGaERwybpDrFaAZZoY=
   dependencies:
     minimist "~0.0.1"
@@ -7078,7 +7261,7 @@ optimist@0.6.1, optimist@^0.6.1:
 
 optionator@^0.8.1:
   version "0.8.2"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
+  resolved "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz"
   integrity sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=
   dependencies:
     deep-is "~0.1.3"
@@ -7090,7 +7273,7 @@ optionator@^0.8.1:
 
 optionator@^0.9.1:
   version "0.9.1"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499"
+  resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz"
   integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
   dependencies:
     deep-is "^0.1.3"
@@ -7102,102 +7285,101 @@ optionator@^0.9.1:
 
 os-browserify@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
+  resolved "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz"
   integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=
 
-os-homedir@^1.0.0, os-homedir@^1.0.1:
+os-homedir@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
+  resolved "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz"
   integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
 
 os-shim@^0.1.2:
   version "0.1.3"
-  resolved "https://registry.yarnpkg.com/os-shim/-/os-shim-0.1.3.tgz#6b62c3791cf7909ea35ed46e17658bb417cb3917"
+  resolved "https://registry.npmjs.org/os-shim/-/os-shim-0.1.3.tgz"
   integrity sha1-a2LDeRz3kJ6jXtRuF2WLtBfLORc=
 
-os-tmpdir@^1.0.0, os-tmpdir@~1.0.1, os-tmpdir@~1.0.2:
+os-tmpdir@~1.0.1, os-tmpdir@~1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
+  resolved "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz"
   integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
 
-osenv@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
-  integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
-  dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.0"
-
 p-finally@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
+  resolved "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz"
   integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=
 
 p-limit@^1.1.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz"
   integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==
   dependencies:
     p-try "^1.0.0"
 
 p-limit@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.1.0.tgz#1d5a0d20fb12707c758a655f6bbc4386b5930d68"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.1.0.tgz"
   integrity sha512-NhURkNcrVB+8hNfLuysU8enY5xn2KXphsHBaC2YmRNTZRc7RWusw6apSpdEj3jo4CMb6W9nrF6tTnsJsJeyu6g==
   dependencies:
     p-try "^2.0.0"
 
 p-limit@^2.2.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
+  resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz"
   integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
   dependencies:
     p-try "^2.0.0"
 
 p-locate@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz"
   integrity sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=
   dependencies:
     p-limit "^1.1.0"
 
 p-locate@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz"
   integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
   dependencies:
     p-limit "^2.0.0"
 
 p-locate@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
+  resolved "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz"
   integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
   dependencies:
     p-limit "^2.2.0"
 
 p-map@^1.1.1:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-1.2.0.tgz#e4e94f311eabbc8633a1e79908165fca26241b6b"
+  resolved "https://registry.npmjs.org/p-map/-/p-map-1.2.0.tgz"
   integrity sha512-r6zKACMNhjPJMTl8KcFH4li//gkrXWfbD6feV8l6doRHlzljFWGJ2AP6iKaCJXyZmAUMOPtvbW7EXkbWO/pLEA==
 
 p-map@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-2.0.0.tgz#be18c5a5adeb8e156460651421aceca56c213a50"
+  resolved "https://registry.npmjs.org/p-map/-/p-map-2.0.0.tgz"
   integrity sha512-GO107XdrSUmtHxVoi60qc9tUl/KkNKm+X2CF4P9amalpGxv5YqVPJNfSb0wcA+syCopkZvYYIzW8OVTQW59x/w==
 
+p-map@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz"
+  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
+  dependencies:
+    aggregate-error "^3.0.0"
+
 p-try@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
+  resolved "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz"
   integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=
 
 p-try@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.0.0.tgz#85080bb87c64688fa47996fe8f7dfbe8211760b1"
+  resolved "https://registry.npmjs.org/p-try/-/p-try-2.0.0.tgz"
   integrity sha512-hMp0onDKIajHfIkdRk3P4CdCmErkYAxxDtP3Wx/4nZ3aGlau2VKh3mZpcuFkH27WQkL/3WBCPOktzA9ZOAnMQQ==
 
 pac-proxy-agent@1:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/pac-proxy-agent/-/pac-proxy-agent-1.1.0.tgz#34a385dfdf61d2f0ecace08858c745d3e791fd4d"
+  resolved "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-1.1.0.tgz"
   integrity sha512-QBELCWyLYPgE2Gj+4wUEiMscHrQ8nRPBzYItQNOHWavwBt25ohZHQC4qnd5IszdVVrFbLsQ+dPkm6eqdjJAmwQ==
   dependencies:
     agent-base "2"
@@ -7212,7 +7394,7 @@ pac-proxy-agent@1:
 
 pac-resolver@~2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/pac-resolver/-/pac-resolver-2.0.0.tgz#99b88d2f193fbdeefc1c9a529c1f3260ab5277cd"
+  resolved "https://registry.npmjs.org/pac-resolver/-/pac-resolver-2.0.0.tgz"
   integrity sha1-mbiNLxk/ve78HJpSnB8yYKtSd80=
   dependencies:
     co "~3.0.6"
@@ -7223,19 +7405,19 @@ pac-resolver@~2.0.0:
 
 pad-right@^0.2.2:
   version "0.2.2"
-  resolved "https://registry.yarnpkg.com/pad-right/-/pad-right-0.2.2.tgz#6fbc924045d244f2a2a244503060d3bfc6009774"
+  resolved "https://registry.npmjs.org/pad-right/-/pad-right-0.2.2.tgz"
   integrity sha1-b7ySQEXSRPKiokRQMGDTv8YAl3Q=
   dependencies:
     repeat-string "^1.5.2"
 
 pako@~1.0.2, pako@~1.0.5:
   version "1.0.7"
-  resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.7.tgz#2473439021b57f1516c82f58be7275ad8ef1bb27"
+  resolved "https://registry.npmjs.org/pako/-/pako-1.0.7.tgz"
   integrity sha512-3HNK5tW4x8o5mO8RuHZp3Ydw9icZXx0RANAOMzlMzx7LVXhMJ4mo3MOBpzyd7r/+RUu8BmndP47LXT+vzjtWcQ==
 
 parallel-transform@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/parallel-transform/-/parallel-transform-1.1.0.tgz#d410f065b05da23081fcd10f28854c29bda33b06"
+  resolved "https://registry.npmjs.org/parallel-transform/-/parallel-transform-1.1.0.tgz"
   integrity sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=
   dependencies:
     cyclist "~0.2.2"
@@ -7244,14 +7426,14 @@ parallel-transform@^1.1.0:
 
 parent-module@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.0.tgz#df250bdc5391f4a085fb589dad761f5ad6b865b5"
+  resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.0.tgz"
   integrity sha512-8Mf5juOMmiE4FcmzYc4IaiS9L3+9paz2KOiXzkRviCP6aDmN49Hz6EMWz0lGNp9pX80GvvAuLADtyGfW/Em3TA==
   dependencies:
     callsites "^3.0.0"
 
 parse-asn1@^5.0.0:
   version "5.1.1"
-  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.1.tgz#f6bf293818332bd0dab54efb16087724745e6ca8"
+  resolved "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz"
   integrity sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==
   dependencies:
     asn1.js "^4.0.0"
@@ -7262,12 +7444,12 @@ parse-asn1@^5.0.0:
 
 parse-github-repo-url@^1.3.0:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/parse-github-repo-url/-/parse-github-repo-url-1.4.1.tgz#9e7d8bb252a6cb6ba42595060b7bf6df3dbc1f50"
+  resolved "https://registry.npmjs.org/parse-github-repo-url/-/parse-github-repo-url-1.4.1.tgz"
   integrity sha1-nn2LslKmy2ukJZUGC3v23z28H1A=
 
 parse-glob@^3.0.4:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"
+  resolved "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz"
   integrity sha1-ssN2z7EfNVE7rdFz7wu246OIORw=
   dependencies:
     glob-base "^0.3.0"
@@ -7277,14 +7459,14 @@ parse-glob@^3.0.4:
 
 parse-json@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
+  resolved "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz"
   integrity sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=
   dependencies:
     error-ex "^1.2.0"
 
 parse-json@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
+  resolved "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz"
   integrity sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=
   dependencies:
     error-ex "^1.3.1"
@@ -7292,88 +7474,88 @@ parse-json@^4.0.0:
 
 parse-passwd@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
+  resolved "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz"
   integrity sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=
 
 parseqs@0.0.5:
   version "0.0.5"
-  resolved "https://registry.yarnpkg.com/parseqs/-/parseqs-0.0.5.tgz#d5208a3738e46766e291ba2ea173684921a8b89d"
+  resolved "https://registry.npmjs.org/parseqs/-/parseqs-0.0.5.tgz"
   integrity sha1-1SCKNzjkZ2bikbouoXNoSSGouJ0=
   dependencies:
     better-assert "~1.0.0"
 
 parseuri@0.0.5:
   version "0.0.5"
-  resolved "https://registry.yarnpkg.com/parseuri/-/parseuri-0.0.5.tgz#80204a50d4dbb779bfdc6ebe2778d90e4bce320a"
+  resolved "https://registry.npmjs.org/parseuri/-/parseuri-0.0.5.tgz"
   integrity sha1-gCBKUNTbt3m/3G6+J3jZDkvOMgo=
   dependencies:
     better-assert "~1.0.0"
 
 parseurl@~1.3.2:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.2.tgz#fc289d4ed8993119460c156253262cdc8de65bf3"
+  resolved "https://registry.npmjs.org/parseurl/-/parseurl-1.3.2.tgz"
   integrity sha1-/CidTtiZMRlGDBViUyYs3I3mW/M=
 
 pascalcase@^0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
+  resolved "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz"
   integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=
 
 path-browserify@0.0.0:
   version "0.0.0"
-  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.0.tgz#a0b870729aae214005b7d5032ec2cbbb0fb4451a"
+  resolved "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz"
   integrity sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=
 
 path-dirname@^1.0.0:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
+  resolved "https://registry.npmjs.org/path-dirname/-/path-dirname-1.0.2.tgz"
   integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=
 
 path-exists@2.1.0, path-exists@^2.0.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz"
   integrity sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=
   dependencies:
     pinkie-promise "^2.0.0"
 
 path-exists@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz"
   integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=
 
 path-exists@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
+  resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz"
   integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
 
 path-is-absolute@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+  resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz"
   integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
 
 path-is-inside@^1.0.1, path-is-inside@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
+  resolved "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz"
   integrity sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=
 
 path-key@^2.0.0, path-key@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
+  resolved "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz"
   integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=
 
 path-key@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
+  resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
 path-parse@^1.0.6:
   version "1.0.6"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
+  resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz"
   integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==
 
 path-type@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
+  resolved "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz"
   integrity sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=
   dependencies:
     graceful-fs "^4.1.2"
@@ -7382,19 +7564,19 @@ path-type@^1.0.0:
 
 path-type@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-3.0.0.tgz#cef31dc8e0a1a3bb0d105c0cd97cf3bf47f4e36f"
+  resolved "https://registry.npmjs.org/path-type/-/path-type-3.0.0.tgz"
   integrity sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==
   dependencies:
     pify "^3.0.0"
 
 path-type@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
+  resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
 pbkdf2@^3.0.3:
   version "3.0.17"
-  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.0.17.tgz#976c206530617b14ebb32114239f7b09336e93a6"
+  resolved "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz"
   integrity sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==
   dependencies:
     create-hash "^1.1.2"
@@ -7405,17 +7587,17 @@ pbkdf2@^3.0.3:
 
 pend@~1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
+  resolved "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz"
   integrity sha1-elfrVQpng/kRUzH89GY9XI4AelA=
 
 performance-now@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
+  resolved "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz"
   integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=
 
 phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
   version "2.1.16"
-  resolved "https://registry.yarnpkg.com/phantomjs-prebuilt/-/phantomjs-prebuilt-2.1.16.tgz#efd212a4a3966d3647684ea8ba788549be2aefef"
+  resolved "https://registry.npmjs.org/phantomjs-prebuilt/-/phantomjs-prebuilt-2.1.16.tgz"
   integrity sha1-79ISpKOWbTZHaE6ouniFSb4q7+8=
   dependencies:
     es6-promise "^4.0.3"
@@ -7428,69 +7610,74 @@ phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
     request-progress "^2.0.1"
     which "^1.2.10"
 
+picomatch@^2.0.4:
+  version "2.3.1"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
+  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
+
 picomatch@^2.0.5, picomatch@^2.2.1, picomatch@^2.2.2:
   version "2.2.2"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
+  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz"
   integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
 
 pify@^2.0.0, pify@^2.3.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
+  resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz"
   integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw=
 
 pify@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176"
+  resolved "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz"
   integrity sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=
 
 pify@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
+  resolved "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz"
   integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
 
 pinkie-promise@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
+  resolved "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz"
   integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o=
   dependencies:
     pinkie "^2.0.0"
 
 pinkie@^2.0.0:
   version "2.0.4"
-  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
+  resolved "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz"
   integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
 
 pirates@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.0.tgz#850b18781b4ac6ec58a43c9ed9ec5fe6796addbd"
+  resolved "https://registry.npmjs.org/pirates/-/pirates-4.0.0.tgz"
   integrity sha512-8t5BsXy1LUIjn3WWOlOuFDuKswhQb/tkak641lvBgmPOBUQHXveORtlMCp6OdPV1dtuTaEahKA8VNz6uLfKBtA==
   dependencies:
     node-modules-regexp "^1.0.0"
 
 pkg-dir@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
+  resolved "https://registry.npmjs.org/pkg-dir/-/pkg-dir-3.0.0.tgz"
   integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
   dependencies:
     find-up "^3.0.0"
 
 pkg-dir@^4.1.0:
   version "4.2.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
+  resolved "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz"
   integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
   dependencies:
     find-up "^4.0.0"
 
 please-upgrade-node@^3.0.2:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/please-upgrade-node/-/please-upgrade-node-3.1.1.tgz#ed320051dfcc5024fae696712c8288993595e8ac"
+  resolved "https://registry.npmjs.org/please-upgrade-node/-/please-upgrade-node-3.1.1.tgz"
   integrity sha512-KY1uHnQ2NlQHqIJQpnh/i54rKkuxCEBx+voJIS/Mvb+L2iYd2NMotwduhKTMjfC1uKoX3VXOxLjIYG66dfJTVQ==
   dependencies:
     semver-compare "^1.0.0"
 
 portfinder@^1.0.25:
   version "1.0.28"
-  resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.28.tgz#67c4622852bd5374dd1dd900f779f53462fac778"
+  resolved "https://registry.npmjs.org/portfinder/-/portfinder-1.0.28.tgz"
   integrity sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==
   dependencies:
     async "^2.6.2"
@@ -7499,27 +7686,27 @@ portfinder@^1.0.25:
 
 posix-character-classes@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
+  resolved "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz"
   integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=
 
 prelude-ls@^1.2.1:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
+  resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz"
   integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
 
 prelude-ls@~1.1.2:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
+  resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz"
   integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=
 
 preserve@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
+  resolved "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz"
   integrity sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=
 
 pretty-format@^23.6.0:
   version "23.6.0"
-  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-23.6.0.tgz#5eaac8eeb6b33b987b7fe6097ea6a8a146ab5760"
+  resolved "https://registry.npmjs.org/pretty-format/-/pretty-format-23.6.0.tgz"
   integrity sha512-zf9NV1NSlDLDjycnwm6hpFATCGl/K1lt0R/GdkAK2O5LN/rwJoB+Mh93gGJjut4YbmecbfgLWVGSTCr0Ewvvbw==
   dependencies:
     ansi-regex "^3.0.0"
@@ -7527,37 +7714,37 @@ pretty-format@^23.6.0:
 
 process-nextick-args@~1.0.6:
   version "1.0.7"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3"
+  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz"
   integrity sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=
 
 process-nextick-args@~2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.0.tgz#a37d732f4271b4ab1ad070d35508e8290788ffaa"
+  resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz"
   integrity sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==
 
 process@^0.11.10:
   version "0.11.10"
-  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
+  resolved "https://registry.npmjs.org/process/-/process-0.11.10.tgz"
   integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
 
 progress@^1.1.8:
   version "1.1.8"
-  resolved "https://registry.yarnpkg.com/progress/-/progress-1.1.8.tgz#e260c78f6161cdd9b0e56cc3e0a85de17c7a57be"
+  resolved "https://registry.npmjs.org/progress/-/progress-1.1.8.tgz"
   integrity sha1-4mDHj2Fhzdmw5WzD4Khd4Xx6V74=
 
 progress@^2.0.0, progress@^2.0.1:
   version "2.0.3"
-  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
+  resolved "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz"
   integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
 
 promise-inflight@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/promise-inflight/-/promise-inflight-1.0.1.tgz#98472870bf228132fcbdd868129bad12c3c029e3"
+  resolved "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz"
   integrity sha1-mEcocL8igTL8vdhoEputEsPAKeM=
 
 proxy-agent@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/proxy-agent/-/proxy-agent-2.0.0.tgz#57eb5347aa805d74ec681cb25649dba39c933499"
+  resolved "https://registry.npmjs.org/proxy-agent/-/proxy-agent-2.0.0.tgz"
   integrity sha1-V+tTR6qAXXTsaByyVknbo5yTNJk=
   dependencies:
     agent-base "2"
@@ -7571,27 +7758,32 @@ proxy-agent@2.0.0:
 
 proxy-from-env@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.0.0.tgz#33c50398f70ea7eb96d21f7b817630a55791c7ee"
+  resolved "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.0.0.tgz"
   integrity sha1-M8UDmPcOp+uW0h97gXYwpVeRx+4=
 
+proxy-from-env@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz"
+  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
+
 prr@~1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
+  resolved "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz"
   integrity sha1-0/wRS6BplaRexok/SEzrHXj19HY=
 
 pseudomap@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"
+  resolved "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz"
   integrity sha1-8FKijacOYYkX7wqKw0wa5aaChrM=
 
 psl@^1.1.24:
   version "1.1.31"
-  resolved "https://registry.yarnpkg.com/psl/-/psl-1.1.31.tgz#e9aa86d0101b5b105cbe93ac6b784cd547276184"
+  resolved "https://registry.npmjs.org/psl/-/psl-1.1.31.tgz"
   integrity sha512-/6pt4+C+T+wZUieKR620OpzN/LlnNKuWjy1iFLQ/UG35JqHlR/89MP1d96dUfkf6Dne3TuLQzOYEYshJ+Hx8mw==
 
 public-encrypt@^4.0.0:
   version "4.0.3"
-  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.3.tgz#4fcc9d77a07e48ba7527e7cbe0de33d0701331e0"
+  resolved "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz"
   integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==
   dependencies:
     bn.js "^4.1.0"
@@ -7603,7 +7795,7 @@ public-encrypt@^4.0.0:
 
 pump@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
+  resolved "https://registry.npmjs.org/pump/-/pump-2.0.1.tgz"
   integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==
   dependencies:
     end-of-stream "^1.1.0"
@@ -7611,7 +7803,7 @@ pump@^2.0.0:
 
 pump@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
+  resolved "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz"
   integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
   dependencies:
     end-of-stream "^1.1.0"
@@ -7619,7 +7811,7 @@ pump@^3.0.0:
 
 pumpify@^1.3.3:
   version "1.5.1"
-  resolved "https://registry.yarnpkg.com/pumpify/-/pumpify-1.5.1.tgz#36513be246ab27570b1a374a5ce278bfd74370ce"
+  resolved "https://registry.npmjs.org/pumpify/-/pumpify-1.5.1.tgz"
   integrity sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==
   dependencies:
     duplexify "^3.6.0"
@@ -7628,22 +7820,22 @@ pumpify@^1.3.3:
 
 punycode@1.3.2:
   version "1.3.2"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz"
   integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=
 
 punycode@^1.2.4, punycode@^1.4.1:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz"
   integrity sha1-wNWmOycYgArY4esPpSachN1BhF4=
 
 punycode@^2.1.0:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
+  resolved "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz"
   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
 
 puppeteer@^1.11.0:
   version "1.11.0"
-  resolved "https://registry.yarnpkg.com/puppeteer/-/puppeteer-1.11.0.tgz#63cdbe12b07275cd6e0b94bce41f3fcb20305770"
+  resolved "https://registry.npmjs.org/puppeteer/-/puppeteer-1.11.0.tgz"
   integrity sha512-iG4iMOHixc2EpzqRV+pv7o3GgmU2dNYEMkvKwSaQO/vMZURakwSOn/EYJ6OIRFYOque1qorzIBvrytPIQB3YzQ==
   dependencies:
     debug "^4.1.0"
@@ -7657,52 +7849,52 @@ puppeteer@^1.11.0:
 
 q@1.4.1:
   version "1.4.1"
-  resolved "https://registry.yarnpkg.com/q/-/q-1.4.1.tgz#55705bcd93c5f3673530c2c2cbc0c2b3addc286e"
+  resolved "https://registry.npmjs.org/q/-/q-1.4.1.tgz"
   integrity sha1-VXBbzZPF82c1MMLCy8DCs63cKG4=
 
 q@^1.4.1, q@^1.5.1:
   version "1.5.1"
-  resolved "https://registry.yarnpkg.com/q/-/q-1.5.1.tgz#7e32f75b41381291d04611f1bf14109ac00651d7"
+  resolved "https://registry.npmjs.org/q/-/q-1.5.1.tgz"
   integrity sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=
 
 qjobs@^1.1.4:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/qjobs/-/qjobs-1.2.0.tgz#c45e9c61800bd087ef88d7e256423bdd49e5d071"
+  resolved "https://registry.npmjs.org/qjobs/-/qjobs-1.2.0.tgz"
   integrity sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==
 
 qs@6.5.2, qs@~6.5.2:
   version "6.5.2"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
+  resolved "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz"
   integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
 
 qs@^6.4.0:
   version "6.9.4"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.4.tgz#9090b290d1f91728d3c22e54843ca44aea5ab687"
+  resolved "https://registry.npmjs.org/qs/-/qs-6.9.4.tgz"
   integrity sha512-A1kFqHekCTM7cz0udomYUoYNWjBebHm/5wzU/XqrBRBNWectVH0QIiN+NEcZ0Dte5hvzHwbr8+XQmguPhJ6WdQ==
 
 querystring-es3@^0.2.0:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
+  resolved "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz"
   integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=
 
 querystring@0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
+  resolved "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz"
   integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
 
 queue-microtask@^1.2.2:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
+  resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
 quick-lru@^1.0.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8"
+  resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-1.1.0.tgz"
   integrity sha1-Q2CxfGETatOAeDl/8RQW4Ybc+7g=
 
 randomatic@^3.0.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed"
+  resolved "https://registry.npmjs.org/randomatic/-/randomatic-3.1.1.tgz"
   integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==
   dependencies:
     is-number "^4.0.0"
@@ -7711,21 +7903,21 @@ randomatic@^3.0.0:
 
 randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.0.6.tgz#d302c522948588848a8d300c932b44c24231da80"
+  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz"
   integrity sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==
   dependencies:
     safe-buffer "^5.1.0"
 
 randombytes@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
+  resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz"
   integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
   dependencies:
     safe-buffer "^5.1.0"
 
 randomfill@^1.0.3:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/randomfill/-/randomfill-1.0.4.tgz#c92196fc86ab42be983f1bf31778224931d61458"
+  resolved "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz"
   integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==
   dependencies:
     randombytes "^2.0.5"
@@ -7733,12 +7925,12 @@ randomfill@^1.0.3:
 
 range-parser@^1.0.3, range-parser@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.0.tgz#f49be6b487894ddc40dcc94a322f611092e00d5e"
+  resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz"
   integrity sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=
 
 raw-body@2, raw-body@2.3.3:
   version "2.3.3"
-  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.3.3.tgz#1b324ece6b5706e153855bc1148c65bb7f6ea0c3"
+  resolved "https://registry.npmjs.org/raw-body/-/raw-body-2.3.3.tgz"
   integrity sha512-9esiElv1BrZoI3rCDuOuKCBRbuApGGaDPQfjSflGxdy4oyzqghxu6klEkkVIvBje+FF0BX9coEv8KqW6X/7njw==
   dependencies:
     bytes "3.0.0"
@@ -7746,19 +7938,9 @@ raw-body@2, raw-body@2.3.3:
     iconv-lite "0.4.23"
     unpipe "1.0.0"
 
-rc@^1.2.7:
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed"
-  integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
-  dependencies:
-    deep-extend "^0.6.0"
-    ini "~1.3.0"
-    minimist "^1.2.0"
-    strip-json-comments "~2.0.1"
-
 read-pkg-up@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
+  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz"
   integrity sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=
   dependencies:
     find-up "^1.0.0"
@@ -7766,7 +7948,7 @@ read-pkg-up@^1.0.1:
 
 read-pkg-up@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
+  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-3.0.0.tgz"
   integrity sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=
   dependencies:
     find-up "^2.0.0"
@@ -7774,7 +7956,7 @@ read-pkg-up@^3.0.0:
 
 read-pkg-up@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-4.0.0.tgz#1b221c6088ba7799601c808f91161c66e58f8978"
+  resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-4.0.0.tgz"
   integrity sha512-6etQSH7nJGsK0RbG/2TeDzZFa8shjQ1um+SwQQ5cwKy0dhSXdOncEhb1CPpvQG4h7FyOV6EB6YlV0yJvZQNAkA==
   dependencies:
     find-up "^3.0.0"
@@ -7782,7 +7964,7 @@ read-pkg-up@^4.0.0:
 
 read-pkg@^1.0.0, read-pkg@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
+  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz"
   integrity sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=
   dependencies:
     load-json-file "^1.0.0"
@@ -7791,16 +7973,16 @@ read-pkg@^1.0.0, read-pkg@^1.1.0:
 
 read-pkg@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-3.0.0.tgz#9cbc686978fee65d16c00e2b19c237fcf6e38389"
+  resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-3.0.0.tgz"
   integrity sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=
   dependencies:
     load-json-file "^4.0.0"
     normalize-package-data "^2.3.2"
     path-type "^3.0.0"
 
-"readable-stream@1 || 2", readable-stream@2, readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.4, readable-stream@^2.0.6, readable-stream@^2.1.5, readable-stream@^2.2.2, readable-stream@^2.3.0, readable-stream@^2.3.3, readable-stream@^2.3.6, readable-stream@~2.3.6:
+"readable-stream@1 || 2", readable-stream@2, readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.4, readable-stream@^2.1.5, readable-stream@^2.2.2, readable-stream@^2.3.0, readable-stream@^2.3.3, readable-stream@^2.3.6, readable-stream@~2.3.6:
   version "2.3.6"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.6.tgz#b11c27d88b8ff1fbe070643cf94b0c79ae1b0aaf"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz"
   integrity sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==
   dependencies:
     core-util-is "~1.0.0"
@@ -7813,7 +7995,7 @@ read-pkg@^3.0.0:
 
 readable-stream@1.1.x:
   version "1.1.14"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.14.tgz#7cf4c54ef648e3813084c636dd2079e166c081d9"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz"
   integrity sha1-fPTFTvZI44EwhMY23SB54WbAgdk=
   dependencies:
     core-util-is "~1.0.0"
@@ -7821,9 +8003,18 @@ readable-stream@1.1.x:
     isarray "0.0.1"
     string_decoder "~0.10.x"
 
+readable-stream@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz"
+  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
+  dependencies:
+    inherits "^2.0.3"
+    string_decoder "^1.1.1"
+    util-deprecate "^1.0.1"
+
 readable-stream@~2.0.6:
   version "2.0.6"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.0.6.tgz#8f90341e68a53ccc928788dacfcd11b36eb9b78e"
+  resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz"
   integrity sha1-j5A0HmilPMySh4jaz80Rs265t44=
   dependencies:
     core-util-is "~1.0.0"
@@ -7835,23 +8026,30 @@ readable-stream@~2.0.6:
 
 readdirp@^2.0.0:
   version "2.2.1"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.2.1.tgz#0e87622a3325aa33e892285caf8b4e846529a525"
+  resolved "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz"
   integrity sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==
   dependencies:
     graceful-fs "^4.1.11"
     micromatch "^3.1.10"
     readable-stream "^2.0.2"
 
+readdirp@~3.6.0:
+  version "3.6.0"
+  resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz"
+  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
+  dependencies:
+    picomatch "^2.2.1"
+
 rechoir@^0.6.2:
   version "0.6.2"
-  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
+  resolved "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz"
   integrity sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=
   dependencies:
     resolve "^1.1.6"
 
 redent@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-1.0.0.tgz#cf916ab1fd5f1f16dfb20822dd6ec7f730c2afde"
+  resolved "https://registry.npmjs.org/redent/-/redent-1.0.0.tgz"
   integrity sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=
   dependencies:
     indent-string "^2.1.0"
@@ -7859,7 +8057,7 @@ redent@^1.0.0:
 
 redent@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-2.0.0.tgz#c1b2007b42d57eb1389079b3c8333639d5e1ccaa"
+  resolved "https://registry.npmjs.org/redent/-/redent-2.0.0.tgz"
   integrity sha1-wbIAe0LVfrE4kHmzyDM2OdXhzKo=
   dependencies:
     indent-string "^3.0.0"
@@ -7867,48 +8065,48 @@ redent@^2.0.0:
 
 regenerate-unicode-properties@^8.0.2, regenerate-unicode-properties@^8.2.0:
   version "8.2.0"
-  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz#e5de7111d655e7ba60c057dbe9ff37c87e65cdec"
+  resolved "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz"
   integrity sha512-F9DjY1vKLo/tPePDycuH3dn9H1OTPIkVD9Kz4LODu+F2C75mgjAJ7x/gwy6ZcSNRAAkhNlJSOHRe8k3p+K9WhA==
   dependencies:
     regenerate "^1.4.0"
 
 regenerate@^1.4.0:
   version "1.4.2"
-  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
+  resolved "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz"
   integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
 regenerator-runtime@^0.10.0:
   version "0.10.5"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz#336c3efc1220adcedda2c9fab67b5a7955a33658"
+  resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz"
   integrity sha1-M2w+/BIgrc7dosn6tntaeVWjNlg=
 
 regenerator-runtime@^0.11.0:
   version "0.11.1"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
+  resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz"
   integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==
 
 regenerator-runtime@^0.13.4:
   version "0.13.7"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz#cac2dacc8a1ea675feaabaeb8ae833898ae46f55"
+  resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz"
   integrity sha512-a54FxoJDIr27pgf7IgeQGxmqUNYrcV338lf/6gH456HZ/PhX+5BcwHXG9ajESmwe6WRO0tAzRUrRmNONWgkrew==
 
 regenerator-transform@^0.14.2:
   version "0.14.5"
-  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.14.5.tgz#c98da154683671c9c4dcb16ece736517e1b7feb4"
+  resolved "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.14.5.tgz"
   integrity sha512-eOf6vka5IO151Jfsw2NO9WpGX58W6wWmefK3I1zEGr0lOD0u8rwPaNqQL1aRxUaxLeKO3ArNh3VYg1KbaD+FFw==
   dependencies:
     "@babel/runtime" "^7.8.4"
 
 regex-cache@^0.4.2:
   version "0.4.4"
-  resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.4.tgz#75bdc58a2a1496cec48a12835bc54c8d562336dd"
+  resolved "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz"
   integrity sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==
   dependencies:
     is-equal-shallow "^0.1.3"
 
 regex-not@^1.0.0, regex-not@^1.0.2:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
+  resolved "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz"
   integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==
   dependencies:
     extend-shallow "^3.0.2"
@@ -7916,12 +8114,12 @@ regex-not@^1.0.0, regex-not@^1.0.2:
 
 regexpp@^3.0.0, regexpp@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.1.0.tgz#206d0ad0a5648cffbdb8ae46438f3dc51c9f78e2"
+  resolved "https://registry.npmjs.org/regexpp/-/regexpp-3.1.0.tgz"
   integrity sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q==
 
 regexpu-core@4.5.4:
   version "4.5.4"
-  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.5.4.tgz#080d9d02289aa87fe1667a4f5136bc98a6aebaae"
+  resolved "https://registry.npmjs.org/regexpu-core/-/regexpu-core-4.5.4.tgz"
   integrity sha512-BtizvGtFQKGPUcTy56o3nk1bGRp4SZOTYrDtGNlqCQufptV5IkkLN6Emw+yunAJjzf+C9FQFtvq7IoA3+oMYHQ==
   dependencies:
     regenerate "^1.4.0"
@@ -7933,7 +8131,7 @@ regexpu-core@4.5.4:
 
 regexpu-core@^4.7.1:
   version "4.7.1"
-  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.7.1.tgz#2dea5a9a07233298fbf0db91fa9abc4c6e0f8ad6"
+  resolved "https://registry.npmjs.org/regexpu-core/-/regexpu-core-4.7.1.tgz"
   integrity sha512-ywH2VUraA44DZQuRKzARmw6S66mr48pQVva4LBeRhcOltJ6hExvWly5ZjFLYo67xbIxb6W1q4bAGtgfEl20zfQ==
   dependencies:
     regenerate "^1.4.0"
@@ -7945,65 +8143,65 @@ regexpu-core@^4.7.1:
 
 regjsgen@^0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.0.tgz#a7634dc08f89209c2049adda3525711fb97265dd"
+  resolved "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.0.tgz"
   integrity sha512-RnIrLhrXCX5ow/E5/Mh2O4e/oa1/jW0eaBKTSy3LaCj+M3Bqvm97GWDp2yUtzIs4LEn65zR2yiYGFqb2ApnzDA==
 
 regjsgen@^0.5.1:
   version "0.5.2"
-  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.2.tgz#92ff295fb1deecbf6ecdab2543d207e91aa33733"
+  resolved "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz"
   integrity sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==
 
 regjsparser@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.0.tgz#f1e6ae8b7da2bae96c99399b868cd6c933a2ba9c"
+  resolved "https://registry.npmjs.org/regjsparser/-/regjsparser-0.6.0.tgz"
   integrity sha512-RQ7YyokLiQBomUJuUG8iGVvkgOLxwyZM8k6d3q5SAXpg4r5TZJZigKFvC6PpD+qQ98bCDC5YelPeA3EucDoNeQ==
   dependencies:
     jsesc "~0.5.0"
 
 regjsparser@^0.6.4:
   version "0.6.9"
-  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.9.tgz#b489eef7c9a2ce43727627011429cf833a7183e6"
+  resolved "https://registry.npmjs.org/regjsparser/-/regjsparser-0.6.9.tgz"
   integrity sha512-ZqbNRz1SNjLAiYuwY0zoXW8Ne675IX5q+YHioAGbCw4X96Mjl2+dcX9B2ciaeyYjViDAfvIjFpQjJgLttTEERQ==
   dependencies:
     jsesc "~0.5.0"
 
 remove-trailing-separator@^1.0.1:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
+  resolved "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz"
   integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8=
 
 repeat-element@^1.1.2:
   version "1.1.3"
-  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce"
+  resolved "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.3.tgz"
   integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==
 
 repeat-string@^0.2.2:
   version "0.2.2"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-0.2.2.tgz#c7a8d3236068362059a7e4651fc6884e8b1fb4ae"
+  resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-0.2.2.tgz"
   integrity sha1-x6jTI2BoNiBZp+RlH8aITosftK4=
 
 repeat-string@^1.5.2, repeat-string@^1.6.1:
   version "1.6.1"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
+  resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz"
   integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
 
 repeating@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda"
+  resolved "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz"
   integrity sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=
   dependencies:
     is-finite "^1.0.0"
 
 request-progress@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/request-progress/-/request-progress-2.0.1.tgz#5d36bb57961c673aa5b788dbc8141fdf23b44e08"
+  resolved "https://registry.npmjs.org/request-progress/-/request-progress-2.0.1.tgz"
   integrity sha1-XTa7V5YcZzqlt4jbyBQf3yO0Tgg=
   dependencies:
     throttleit "^1.0.0"
 
-request@^2.81.0, request@^2.87.0, request@^2.88.0:
+request@^2.81.0, request@^2.87.0:
   version "2.88.0"
-  resolved "https://registry.yarnpkg.com/request/-/request-2.88.0.tgz#9c2fca4f7d35b592efe57c7f0a55e81052124fef"
+  resolved "https://registry.npmjs.org/request/-/request-2.88.0.tgz"
   integrity sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==
   dependencies:
     aws-sign2 "~0.7.0"
@@ -8029,27 +8227,27 @@ request@^2.81.0, request@^2.87.0, request@^2.88.0:
 
 require-directory@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
+  resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz"
   integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
 
 require-from-string@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
+  resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz"
   integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
 
 require-main-filename@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
+  resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz"
   integrity sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=
 
 requires-port@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
+  resolved "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz"
   integrity sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=
 
 resolve-dir@^0.1.0:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-0.1.1.tgz#b219259a5602fac5c5c496ad894a6e8cc430261e"
+  resolved "https://registry.npmjs.org/resolve-dir/-/resolve-dir-0.1.1.tgz"
   integrity sha1-shklmlYC+sXFxJatiUpujMQwJh4=
   dependencies:
     expand-tilde "^1.2.2"
@@ -8057,22 +8255,22 @@ resolve-dir@^0.1.0:
 
 resolve-from@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
+  resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
 resolve-url@^0.2.1:
   version "0.2.1"
-  resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
+  resolved "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz"
   integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
 
 resolve@1.1.x:
   version "1.1.7"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz"
   integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=
 
 resolve@1.20.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0:
   version "1.20.0"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz"
   integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
   dependencies:
     is-core-module "^2.2.0"
@@ -8080,14 +8278,14 @@ resolve@1.20.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0:
 
 resolve@^1.1.6, resolve@^1.3.3:
   version "1.9.0"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.9.0.tgz#a14c6fdfa8f92a7df1d996cb7105fa744658ea06"
+  resolved "https://registry.npmjs.org/resolve/-/resolve-1.9.0.tgz"
   integrity sha512-TZNye00tI67lwYvzxCxHGjwTNlUV70io54/Ed4j6PscB8xVfuBJpRenI/o6dVk0cY0PYTY27AgCoGGxRnYuItQ==
   dependencies:
     path-parse "^1.0.6"
 
 restore-cursor@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541"
+  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-1.0.1.tgz"
   integrity sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=
   dependencies:
     exit-hook "^1.0.0"
@@ -8095,7 +8293,7 @@ restore-cursor@^1.0.1:
 
 restore-cursor@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
+  resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz"
   integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368=
   dependencies:
     onetime "^2.0.0"
@@ -8103,41 +8301,41 @@ restore-cursor@^2.0.0:
 
 ret@~0.1.10:
   version "0.1.15"
-  resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
+  resolved "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz"
   integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
 
 reusify@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
+  resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz"
   integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
 
 rfdc@^1.1.2:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.1.2.tgz#e6e72d74f5dc39de8f538f65e00c36c18018e349"
+  resolved "https://registry.npmjs.org/rfdc/-/rfdc-1.1.2.tgz"
   integrity sha512-92ktAgvZhBzYTIK0Mja9uen5q5J3NRVMoDkJL2VMwq6SXjVCgqvQeVP2XAaUY6HT+XpQYeLSjb3UoitBryKmdA==
 
 right-pad@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/right-pad/-/right-pad-1.0.1.tgz#8ca08c2cbb5b55e74dafa96bf7fd1a27d568c8d0"
+  resolved "https://registry.npmjs.org/right-pad/-/right-pad-1.0.1.tgz"
   integrity sha1-jKCMLLtbVedNr6lr9/0aJ9VoyNA=
 
 rimraf@^2.2.8, rimraf@^2.5.4, rimraf@^2.6.0, rimraf@^2.6.1, rimraf@^2.6.2:
   version "2.6.3"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
+  resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz"
   integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
   dependencies:
     glob "^7.1.3"
 
 rimraf@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
+  resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz"
   integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
   dependencies:
     glob "^7.1.3"
 
 ripemd160@^2.0.0, ripemd160@^2.0.1:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
+  resolved "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz"
   integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
   dependencies:
     hash-base "^3.0.0"
@@ -8145,7 +8343,7 @@ ripemd160@^2.0.0, ripemd160@^2.0.1:
 
 rollup-plugin-typescript2@^0.30.0:
   version "0.30.0"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.30.0.tgz#1cc99ac2309bf4b9d0a3ebdbc2002aecd56083d3"
+  resolved "https://registry.npmjs.org/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.30.0.tgz"
   integrity sha512-NUFszIQyhgDdhRS9ya/VEmsnpTe+GERDMmFo0Y+kf8ds51Xy57nPNGglJY+W6x1vcouA7Au7nsTgsLFj2I0PxQ==
   dependencies:
     "@rollup/pluginutils" "^4.1.0"
@@ -8156,64 +8354,69 @@ rollup-plugin-typescript2@^0.30.0:
 
 rollup@^2.44.0:
   version "2.44.0"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.44.0.tgz#8da324d1c4fd12beef9ae6e12f4068265b6d95eb"
+  resolved "https://registry.npmjs.org/rollup/-/rollup-2.44.0.tgz"
   integrity sha512-rGSF4pLwvuaH/x4nAS+zP6UNn5YUDWf/TeEU5IoXSZKBbKRNTCI3qMnYXKZgrC0D2KzS2baiOZt1OlqhMu5rnQ==
   optionalDependencies:
     fsevents "~2.3.1"
 
 run-async@^2.2.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.3.0.tgz#0371ab4ae0bdd720d4166d7dfda64ff7a445a6c0"
+  resolved "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz"
   integrity sha1-A3GrSuC91yDUFm19/aZP96RFpsA=
   dependencies:
     is-promise "^2.1.0"
 
 run-parallel@^1.1.9:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
+  resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz"
   integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
   dependencies:
     queue-microtask "^1.2.2"
 
 run-queue@^1.0.0, run-queue@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/run-queue/-/run-queue-1.0.3.tgz#e848396f057d223f24386924618e25694161ec47"
+  resolved "https://registry.npmjs.org/run-queue/-/run-queue-1.0.3.tgz"
   integrity sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=
   dependencies:
     aproba "^1.1.1"
 
 rx@^4.1.0:
   version "4.1.0"
-  resolved "https://registry.yarnpkg.com/rx/-/rx-4.1.0.tgz#a5f13ff79ef3b740fe30aa803fb09f98805d4782"
+  resolved "https://registry.npmjs.org/rx/-/rx-4.1.0.tgz"
   integrity sha1-pfE/957zt0D+MKqAP7CfmIBdR4I=
 
 rxjs@^6.3.3:
   version "6.3.3"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.3.3.tgz#3c6a7fa420e844a81390fb1158a9ec614f4bad55"
+  resolved "https://registry.npmjs.org/rxjs/-/rxjs-6.3.3.tgz"
   integrity sha512-JTWmoY9tWCs7zvIk/CvRjhjGaOd+OVBM987mxFo+OW66cGpdKjZcpmc74ES1sB//7Kl/PAe8+wEakuhG4pcgOw==
   dependencies:
     tslib "^1.9.0"
 
 safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
+safe-buffer@~5.2.0:
+  version "5.2.1"
+  resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
 safe-regex@^1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
+  resolved "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz"
   integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4=
   dependencies:
     ret "~0.1.10"
 
 "safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
+  resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
 sauce-connect-launcher@^1.2.4:
   version "1.2.4"
-  resolved "https://registry.yarnpkg.com/sauce-connect-launcher/-/sauce-connect-launcher-1.2.4.tgz#8d38f85242a9fbede1b2303b559f7e20c5609a1c"
+  resolved "https://registry.npmjs.org/sauce-connect-launcher/-/sauce-connect-launcher-1.2.4.tgz"
   integrity sha512-X2vfwulR6brUGiicXKxPm1GJ7dBEeP1II450Uv4bHGrcGOapZNgzJvn9aioea5IC5BPp/7qjKdE3xbbTBIVXMA==
   dependencies:
     adm-zip "~0.4.3"
@@ -8224,19 +8427,19 @@ sauce-connect-launcher@^1.2.4:
 
 saucelabs@^1.5.0:
   version "1.5.0"
-  resolved "https://registry.yarnpkg.com/saucelabs/-/saucelabs-1.5.0.tgz#9405a73c360d449b232839919a86c396d379fd9d"
+  resolved "https://registry.npmjs.org/saucelabs/-/saucelabs-1.5.0.tgz"
   integrity sha512-jlX3FGdWvYf4Q3LFfFWS1QvPg3IGCGWxIc8QBFdPTbpTJnt/v17FHXYVAn7C8sHf1yUXo2c7yIM0isDryfYtHQ==
   dependencies:
     https-proxy-agent "^2.2.1"
 
-sax@>=0.6.0, sax@^1.2.4:
+sax@>=0.6.0:
   version "1.2.4"
-  resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
+  resolved "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz"
   integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
 
 schema-utils@^0.4.4:
   version "0.4.7"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-0.4.7.tgz#ba74f597d2be2ea880131746ee17d0a093c68187"
+  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-0.4.7.tgz"
   integrity sha512-v/iwU6wvwGK8HbU9yi3/nhGzP0yGSuhQMzL6ySiec1FSrZZDkhm4noOSWzrNFo/jEc+SJY6jRTwuwbSXJPDUnQ==
   dependencies:
     ajv "^6.1.0"
@@ -8244,7 +8447,7 @@ schema-utils@^0.4.4:
 
 schema-utils@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-1.0.0.tgz#0b79a93204d7b600d4b2850d1f66c2a34951c770"
+  resolved "https://registry.npmjs.org/schema-utils/-/schema-utils-1.0.0.tgz"
   integrity sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==
   dependencies:
     ajv "^6.1.0"
@@ -8253,17 +8456,17 @@ schema-utils@^1.0.0:
 
 secure-compare@3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/secure-compare/-/secure-compare-3.0.1.tgz#f1a0329b308b221fae37b9974f3d578d0ca999e3"
+  resolved "https://registry.npmjs.org/secure-compare/-/secure-compare-3.0.1.tgz"
   integrity sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=
 
 selenium-server@^2.53.1:
   version "2.53.1"
-  resolved "https://registry.yarnpkg.com/selenium-server/-/selenium-server-2.53.1.tgz#d681528812f3c2e0531a6b7e613e23bb02cce8a6"
+  resolved "https://registry.npmjs.org/selenium-server/-/selenium-server-2.53.1.tgz"
   integrity sha1-1oFSiBLzwuBTGmt+YT4juwLM6KY=
 
 selenium-webdriver@^4.0.0-alpha.1:
   version "4.0.0-alpha.1"
-  resolved "https://registry.yarnpkg.com/selenium-webdriver/-/selenium-webdriver-4.0.0-alpha.1.tgz#cc93415e21d2dc1dfd85dfc5f6b55f3ac53933b1"
+  resolved "https://registry.npmjs.org/selenium-webdriver/-/selenium-webdriver-4.0.0-alpha.1.tgz"
   integrity sha512-z88rdjHAv3jmTZ7KSGUkTvo4rGzcDGMq0oXWHNIDK96Gs31JKVdu9+FMtT4KBrVoibg8dUicJDok6GnqqttO5Q==
   dependencies:
     jszip "^3.1.3"
@@ -8273,61 +8476,68 @@ selenium-webdriver@^4.0.0-alpha.1:
 
 semver-compare@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/semver-compare/-/semver-compare-1.0.0.tgz#0dee216a1c941ab37e9efb1788f6afc5ff5537fc"
+  resolved "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz"
   integrity sha1-De4hahyUGrN+nvsXiPavxf9VN/w=
 
-"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0:
+"semver@2 || 3 || 4 || 5", semver@^5.5.0:
   version "5.6.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.6.0.tgz#7e74256fbaa49c75aa7c7a205cc22799cac80004"
+  resolved "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz"
   integrity sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==
 
 semver@7.0.0:
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.0.0.tgz#5f3ca35761e47e05b206c6daff2cf814f0316b8e"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.0.0.tgz"
   integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==
 
 semver@^5.6.0:
   version "5.7.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
+  resolved "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz"
   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
 
 semver@^6.0.0, semver@^6.1.1, semver@^6.1.2, semver@^6.3.0:
   version "6.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
+  resolved "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
 semver@^7.2.1, semver@^7.3.2, semver@^7.3.4:
   version "7.3.5"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz"
   integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
   dependencies:
     lru-cache "^6.0.0"
 
+semver@^7.3.5:
+  version "7.3.7"
+  resolved "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz"
+  integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==
+  dependencies:
+    lru-cache "^6.0.0"
+
 semver@~5.0.1:
   version "5.0.3"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.0.3.tgz#77466de589cd5d3c95f138aa78bc569a3cb5d27a"
+  resolved "https://registry.npmjs.org/semver/-/semver-5.0.3.tgz"
   integrity sha1-d0Zt5YnNXTyV8TiqeLxWmjy10no=
 
 serialize-javascript@^1.4.0:
   version "1.6.1"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-1.6.1.tgz#4d1f697ec49429a847ca6f442a2a755126c4d879"
+  resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-1.6.1.tgz"
   integrity sha512-A5MOagrPFga4YaKQSWHryl7AXvbQkEqpw4NNYMTNYUNV51bA8ABHgYFpqKx+YFFrw59xMV1qGH1R4AgoNIVgCw==
 
 serialize-javascript@^3.1.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-3.1.0.tgz#8bf3a9170712664ef2561b44b691eafe399214ea"
+  resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-3.1.0.tgz"
   integrity sha512-JIJT1DGiWmIKhzRsG91aS6Ze4sFUrYbltlkg2onR5OrnNM02Kl/hnY/T4FN2omvyeBbQmMJv+K4cPOpGzOTFBg==
   dependencies:
     randombytes "^2.1.0"
 
-set-blocking@~2.0.0:
+set-blocking@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
+  resolved "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz"
   integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
 
 set-value@^0.4.3:
   version "0.4.3"
-  resolved "https://registry.yarnpkg.com/set-value/-/set-value-0.4.3.tgz#7db08f9d3d22dc7f78e53af3c3bf4666ecdfccf1"
+  resolved "https://registry.npmjs.org/set-value/-/set-value-0.4.3.tgz"
   integrity sha1-fbCPnT0i3H945Trzw79GZuzfzPE=
   dependencies:
     extend-shallow "^2.0.1"
@@ -8337,7 +8547,7 @@ set-value@^0.4.3:
 
 set-value@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.0.tgz#71ae4a88f0feefbbf52d1ea604f3fb315ebb6274"
+  resolved "https://registry.npmjs.org/set-value/-/set-value-2.0.0.tgz"
   integrity sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==
   dependencies:
     extend-shallow "^2.0.1"
@@ -8347,17 +8557,17 @@ set-value@^2.0.0:
 
 setimmediate@^1.0.4:
   version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
+  resolved "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz"
   integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
 
 setprototypeof@1.1.0:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.1.0.tgz#d0bd85536887b6fe7c0d818cb962d9d91c54e656"
+  resolved "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz"
   integrity sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==
 
 sha.js@^2.4.0, sha.js@^2.4.8:
   version "2.4.11"
-  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
+  resolved "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz"
   integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
   dependencies:
     inherits "^2.0.1"
@@ -8365,31 +8575,31 @@ sha.js@^2.4.0, sha.js@^2.4.8:
 
 shebang-command@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
+  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz"
   integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=
   dependencies:
     shebang-regex "^1.0.0"
 
 shebang-command@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
+  resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz"
   integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
   dependencies:
     shebang-regex "^3.0.0"
 
 shebang-regex@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
+  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz"
   integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=
 
 shebang-regex@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
+  resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
 shelljs@0.7.6:
   version "0.7.6"
-  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.7.6.tgz#379cccfb56b91c8601e4793356eb5382924de9ad"
+  resolved "https://registry.npmjs.org/shelljs/-/shelljs-0.7.6.tgz"
   integrity sha1-N5zM+1a5HIYB5HkzVutTgpJN6a0=
   dependencies:
     glob "^7.0.0"
@@ -8398,7 +8608,7 @@ shelljs@0.7.6:
 
 shelljs@^0.8.1:
   version "0.8.3"
-  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.3.tgz#a7f3319520ebf09ee81275b2368adb286659b097"
+  resolved "https://registry.npmjs.org/shelljs/-/shelljs-0.8.3.tgz"
   integrity sha512-fc0BKlAWiLpwZljmOvAOTE/gXawtCoNrP5oaY7KIaQbbyHeQVg01pSEuEGvGh3HEdBU4baCD7wQBwADmM/7f7A==
   dependencies:
     glob "^7.0.0"
@@ -8407,29 +8617,29 @@ shelljs@^0.8.1:
 
 signal-exit@^3.0.0, signal-exit@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
+  resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz"
   integrity sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=
 
 simple-git@^1.85.0:
   version "1.107.0"
-  resolved "https://registry.yarnpkg.com/simple-git/-/simple-git-1.107.0.tgz#12cffaf261c14d6f450f7fdb86c21ccee968b383"
+  resolved "https://registry.npmjs.org/simple-git/-/simple-git-1.107.0.tgz"
   integrity sha512-t4OK1JRlp4ayKRfcW6owrWcRVLyHRUlhGd0uN6ZZTqfDq8a5XpcUdOKiGRNobHEuMtNqzp0vcJNvhYWwh5PsQA==
   dependencies:
     debug "^4.0.1"
 
 slash@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
+  resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
 slice-ansi@0.0.4:
   version "0.0.4"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35"
+  resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-0.0.4.tgz"
   integrity sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=
 
 slice-ansi@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
+  resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz"
   integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
   dependencies:
     ansi-styles "^4.0.0"
@@ -8438,12 +8648,12 @@ slice-ansi@^4.0.0:
 
 smart-buffer@^1.0.13:
   version "1.1.15"
-  resolved "https://registry.yarnpkg.com/smart-buffer/-/smart-buffer-1.1.15.tgz#7f114b5b65fab3e2a35aa775bb12f0d1c649bf16"
+  resolved "https://registry.npmjs.org/smart-buffer/-/smart-buffer-1.1.15.tgz"
   integrity sha1-fxFLW2X6s+KjWqd1uxLw0cZJvxY=
 
 snapdragon-node@^2.0.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
+  resolved "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz"
   integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==
   dependencies:
     define-property "^1.0.0"
@@ -8452,14 +8662,14 @@ snapdragon-node@^2.0.1:
 
 snapdragon-util@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
+  resolved "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz"
   integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==
   dependencies:
     kind-of "^3.2.0"
 
 snapdragon@^0.8.1:
   version "0.8.2"
-  resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
+  resolved "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz"
   integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==
   dependencies:
     base "^0.11.1"
@@ -8473,12 +8683,12 @@ snapdragon@^0.8.1:
 
 socket.io-adapter@~1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/socket.io-adapter/-/socket.io-adapter-1.1.1.tgz#2a805e8a14d6372124dd9159ad4502f8cb07f06b"
+  resolved "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-1.1.1.tgz"
   integrity sha1-KoBeihTWNyEk3ZFZrUUC+MsH8Gs=
 
 socket.io-client@2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/socket.io-client/-/socket.io-client-2.1.1.tgz#dcb38103436ab4578ddb026638ae2f21b623671f"
+  resolved "https://registry.npmjs.org/socket.io-client/-/socket.io-client-2.1.1.tgz"
   integrity sha512-jxnFyhAuFxYfjqIgduQlhzqTcOEQSn+OHKVfAxWaNWa7ecP7xSNk2Dx/3UEsDcY7NcFafxvNvKPmmO7HTwTxGQ==
   dependencies:
     backo2 "1.0.2"
@@ -8498,7 +8708,7 @@ socket.io-client@2.1.1:
 
 socket.io-parser@~3.2.0:
   version "3.2.0"
-  resolved "https://registry.yarnpkg.com/socket.io-parser/-/socket.io-parser-3.2.0.tgz#e7c6228b6aa1f814e6148aea325b51aa9499e077"
+  resolved "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.2.0.tgz"
   integrity sha512-FYiBx7rc/KORMJlgsXysflWx/RIvtqZbyGLlHZvjfmPTPeuD/I8MaW7cfFrj5tRltICJdgwflhfZ3NVVbVLFQA==
   dependencies:
     component-emitter "1.2.1"
@@ -8507,7 +8717,7 @@ socket.io-parser@~3.2.0:
 
 socket.io@2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/socket.io/-/socket.io-2.1.1.tgz#a069c5feabee3e6b214a75b40ce0652e1cfb9980"
+  resolved "https://registry.npmjs.org/socket.io/-/socket.io-2.1.1.tgz"
   integrity sha512-rORqq9c+7W0DAK3cleWNSyfv/qKXV99hV4tZe+gGLfBECw3XEhBy7x85F3wypA9688LKjtwO9pX9L33/xQI8yA==
   dependencies:
     debug "~3.1.0"
@@ -8519,7 +8729,7 @@ socket.io@2.1.1:
 
 socks-proxy-agent@2:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/socks-proxy-agent/-/socks-proxy-agent-2.1.1.tgz#86ebb07193258637870e13b7bd99f26c663df3d3"
+  resolved "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-2.1.1.tgz"
   integrity sha512-sFtmYqdUK5dAMh85H0LEVFUCO7OhJJe1/z2x/Z6mxp3s7/QPf1RkZmpZy+BpuU0bEjcV9npqKjq9Y3kwFUjnxw==
   dependencies:
     agent-base "2"
@@ -8528,7 +8738,7 @@ socks-proxy-agent@2:
 
 socks@~1.1.5:
   version "1.1.10"
-  resolved "https://registry.yarnpkg.com/socks/-/socks-1.1.10.tgz#5b8b7fc7c8f341c53ed056e929b7bf4de8ba7b5a"
+  resolved "https://registry.npmjs.org/socks/-/socks-1.1.10.tgz"
   integrity sha1-W4t/x8jzQcU+0FbpKbe/Tei6e1o=
   dependencies:
     ip "^1.1.4"
@@ -8536,12 +8746,12 @@ socks@~1.1.5:
 
 source-list-map@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/source-list-map/-/source-list-map-2.0.1.tgz#3993bd873bfc48479cca9ea3a547835c7c154b34"
+  resolved "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.1.tgz"
   integrity sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==
 
 source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
   version "0.5.2"
-  resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.2.tgz#72e2cc34095543e43b2c62b2c4c10d4a9054f259"
+  resolved "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz"
   integrity sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==
   dependencies:
     atob "^2.1.1"
@@ -8552,7 +8762,7 @@ source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
 
 source-map-support@^0.5.16, source-map-support@^0.5.17, source-map-support@~0.5.19:
   version "0.5.19"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
+  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz"
   integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
   dependencies:
     buffer-from "^1.0.0"
@@ -8560,7 +8770,7 @@ source-map-support@^0.5.16, source-map-support@^0.5.17, source-map-support@~0.5.
 
 source-map-support@~0.5.6:
   version "0.5.9"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.9.tgz#41bc953b2534267ea2d605bccfa7bfa3111ced5f"
+  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.9.tgz"
   integrity sha512-gR6Rw4MvUlYy83vP0vxoVNzM6t8MUXqNuRsuBmBHQDu1Fh6X015FrLdgoDKcNdkwGubozq0P4N0Q37UyFVr1EA==
   dependencies:
     buffer-from "^1.0.0"
@@ -8568,39 +8778,39 @@ source-map-support@~0.5.6:
 
 source-map-url@^0.4.0:
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"
+  resolved "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.0.tgz"
   integrity sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=
 
 source-map@^0.5.0, source-map@^0.5.1, source-map@^0.5.6:
   version "0.5.7"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz"
   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
 
 source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
   version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
 source-map@~0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.2.0.tgz#dab73fbcfc2ba819b4de03bd6f6eaa48164b3f9d"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz"
   integrity sha1-2rc/vPwrqBm03gO9b26qSBZLP50=
   dependencies:
     amdefine ">=0.0.4"
 
 source-map@~0.7.2:
   version "0.7.3"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
+  resolved "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz"
   integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
 
 sourcemap-codec@^1.4.4:
   version "1.4.8"
-  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
+  resolved "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz"
   integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
 
 spawn-sync@^1.0.15:
   version "1.0.15"
-  resolved "https://registry.yarnpkg.com/spawn-sync/-/spawn-sync-1.0.15.tgz#b00799557eb7fb0c8376c29d44e8a1ea67e57476"
+  resolved "https://registry.npmjs.org/spawn-sync/-/spawn-sync-1.0.15.tgz"
   integrity sha1-sAeZVX63+wyDdsKdROih6mfldHY=
   dependencies:
     concat-stream "^1.4.7"
@@ -8608,7 +8818,7 @@ spawn-sync@^1.0.15:
 
 spdx-correct@^3.0.0:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.0.tgz#fb83e504445268f154b074e218c87c003cd31df4"
+  resolved "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz"
   integrity sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==
   dependencies:
     spdx-expression-parse "^3.0.0"
@@ -8616,12 +8826,12 @@ spdx-correct@^3.0.0:
 
 spdx-exceptions@^2.1.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz#2ea450aee74f2a89bfb94519c07fcd6f41322977"
+  resolved "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.2.0.tgz"
   integrity sha512-2XQACfElKi9SlVb1CYadKDXvoajPgBVPn/gOQLrTvHdElaVhr7ZEbqJaRnJLVNeaI4cMEAgVCeBMKF6MWRDCRA==
 
 spdx-expression-parse@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz#99e119b7a5da00e05491c9fa338b7904823b41d0"
+  resolved "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz"
   integrity sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==
   dependencies:
     spdx-exceptions "^2.1.0"
@@ -8629,38 +8839,38 @@ spdx-expression-parse@^3.0.0:
 
 spdx-license-ids@^3.0.0:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.3.tgz#81c0ce8f21474756148bbb5f3bfc0f36bf15d76e"
+  resolved "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.3.tgz"
   integrity sha512-uBIcIl3Ih6Phe3XHK1NqboJLdGfwr1UN3k6wSD1dZpmPsIkb8AGNbZYJ1fOBk834+Gxy8rpfDxrS6XLEMZMY2g==
 
 split-string@^3.0.1, split-string@^3.0.2:
   version "3.1.0"
-  resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
+  resolved "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz"
   integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==
   dependencies:
     extend-shallow "^3.0.0"
 
 split2@^2.0.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/split2/-/split2-2.2.0.tgz#186b2575bcf83e85b7d18465756238ee4ee42493"
+  resolved "https://registry.npmjs.org/split2/-/split2-2.2.0.tgz"
   integrity sha512-RAb22TG39LhI31MbreBgIuKiIKhVsawfTgEGqKHTK87aG+ul/PB8Sqoi3I7kVdRWiCfrKxK3uo4/YUkpNvhPbw==
   dependencies:
     through2 "^2.0.2"
 
 split@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9"
+  resolved "https://registry.npmjs.org/split/-/split-1.0.1.tgz"
   integrity sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==
   dependencies:
     through "2"
 
 sprintf-js@~1.0.2:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
+  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz"
   integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=
 
 sshpk@^1.7.0:
   version "1.16.0"
-  resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.16.0.tgz#1d4963a2fbffe58050aa9084ca20be81741c07de"
+  resolved "https://registry.npmjs.org/sshpk/-/sshpk-1.16.0.tgz"
   integrity sha512-Zhev35/y7hRMcID/upReIvRse+I9SVhyVre/KTJSJQWMz3C3+G+HpO7m1wK/yckEtujKZ7dS4hkVxAnmHaIGVQ==
   dependencies:
     asn1 "~0.2.3"
@@ -8675,19 +8885,19 @@ sshpk@^1.7.0:
 
 ssri@^6.0.1:
   version "6.0.1"
-  resolved "https://registry.yarnpkg.com/ssri/-/ssri-6.0.1.tgz#2a3c41b28dd45b62b63676ecb74001265ae9edd8"
+  resolved "https://registry.npmjs.org/ssri/-/ssri-6.0.1.tgz"
   integrity sha512-3Wge10hNcT1Kur4PDFwEieXSCMCJs/7WvSACcrMYrNp+b8kDL1/0wJch5Ni2WrtwEa2IO8OsVfeKIciKCDx/QA==
   dependencies:
     figgy-pudding "^3.5.1"
 
 staged-git-files@1.1.2:
   version "1.1.2"
-  resolved "https://registry.yarnpkg.com/staged-git-files/-/staged-git-files-1.1.2.tgz#4326d33886dc9ecfa29a6193bf511ba90a46454b"
+  resolved "https://registry.npmjs.org/staged-git-files/-/staged-git-files-1.1.2.tgz"
   integrity sha512-0Eyrk6uXW6tg9PYkhi/V/J4zHp33aNyi2hOCmhFLqLTIhbgqWn5jlSzI+IU0VqrZq6+DbHcabQl/WP6P3BG0QA==
 
 static-extend@^0.1.1:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
+  resolved "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz"
   integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=
   dependencies:
     define-property "^0.2.5"
@@ -8695,17 +8905,17 @@ static-extend@^0.1.1:
 
 "statuses@>= 1.4.0 < 2":
   version "1.5.0"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
+  resolved "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz"
   integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=
 
 statuses@~1.3.1:
   version "1.3.1"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.3.1.tgz#faf51b9eb74aaef3b3acf4ad5f61abf24cb7b93e"
+  resolved "https://registry.npmjs.org/statuses/-/statuses-1.3.1.tgz"
   integrity sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=
 
 stream-browserify@^2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-2.0.1.tgz#66266ee5f9bdb9940a4e4514cafb43bb71e5c9db"
+  resolved "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz"
   integrity sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=
   dependencies:
     inherits "~2.0.1"
@@ -8713,7 +8923,7 @@ stream-browserify@^2.0.1:
 
 stream-each@^1.1.0:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/stream-each/-/stream-each-1.2.3.tgz#ebe27a0c389b04fbcc233642952e10731afa9bae"
+  resolved "https://registry.npmjs.org/stream-each/-/stream-each-1.2.3.tgz"
   integrity sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==
   dependencies:
     end-of-stream "^1.1.0"
@@ -8721,7 +8931,7 @@ stream-each@^1.1.0:
 
 stream-http@^2.7.2:
   version "2.8.3"
-  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-2.8.3.tgz#b2d242469288a5a27ec4fe8933acf623de6514fc"
+  resolved "https://registry.npmjs.org/stream-http/-/stream-http-2.8.3.tgz"
   integrity sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==
   dependencies:
     builtin-status-codes "^3.0.0"
@@ -8732,12 +8942,12 @@ stream-http@^2.7.2:
 
 stream-shift@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/stream-shift/-/stream-shift-1.0.0.tgz#d5c752825e5367e786f78e18e445ea223a155952"
+  resolved "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz"
   integrity sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=
 
 streamroller@0.7.0:
   version "0.7.0"
-  resolved "https://registry.yarnpkg.com/streamroller/-/streamroller-0.7.0.tgz#a1d1b7cf83d39afb0d63049a5acbf93493bdf64b"
+  resolved "https://registry.npmjs.org/streamroller/-/streamroller-0.7.0.tgz"
   integrity sha512-WREzfy0r0zUqp3lGO096wRuUp7ho1X6uo/7DJfTlEi0Iv/4gT7YHqXDjKC2ioVGBZtE8QzsQD9nx1nIuoZ57jQ==
   dependencies:
     date-format "^1.2.0"
@@ -8747,21 +8957,30 @@ streamroller@0.7.0:
 
 string-argv@^0.0.2:
   version "0.0.2"
-  resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.0.2.tgz#dac30408690c21f3c3630a3ff3a05877bdcbd736"
+  resolved "https://registry.npmjs.org/string-argv/-/string-argv-0.0.2.tgz"
   integrity sha1-2sMECGkMIfPDYwo/86BYd73L1zY=
 
 string-width@^1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz"
   integrity sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=
   dependencies:
     code-point-at "^1.0.0"
     is-fullwidth-code-point "^1.0.0"
     strip-ansi "^3.0.0"
 
-"string-width@^1.0.2 || 2", string-width@^2.0.0, string-width@^2.1.1:
+"string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.2.3:
+  version "4.2.3"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
+string-width@^2.0.0, string-width@^2.1.1:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz"
   integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
   dependencies:
     is-fullwidth-code-point "^2.0.0"
@@ -8769,7 +8988,7 @@ string-width@^1.0.1:
 
 string-width@^4.1.0, string-width@^4.2.0:
   version "4.2.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5"
+  resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz"
   integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==
   dependencies:
     emoji-regex "^8.0.0"
@@ -8778,26 +8997,33 @@ string-width@^4.1.0, string-width@^4.2.0:
 
 string_decoder@^1.0.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.2.0.tgz#fe86e738b19544afe70469243b2a1ee9240eae8d"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.2.0.tgz"
   integrity sha512-6YqyX6ZWEYguAxgZzHGL7SsCeGx3V2TtOTqZz1xSTSWnqsbWwbptafNyvf/ACquZUXV3DANr5BDIwNYe1mN42w==
   dependencies:
     safe-buffer "~5.1.0"
 
+string_decoder@^1.1.1:
+  version "1.3.0"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz"
+  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
+  dependencies:
+    safe-buffer "~5.2.0"
+
 string_decoder@~0.10.x:
   version "0.10.31"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz"
   integrity sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=
 
 string_decoder@~1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
+  resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz"
   integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
   dependencies:
     safe-buffer "~5.1.0"
 
 stringify-object@^3.2.2:
   version "3.3.0"
-  resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629"
+  resolved "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz"
   integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==
   dependencies:
     get-own-enumerable-property-symbols "^3.0.0"
@@ -8806,105 +9032,112 @@ stringify-object@^3.2.2:
 
 strip-ansi@^3.0.0, strip-ansi@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz"
   integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=
   dependencies:
     ansi-regex "^2.0.0"
 
 strip-ansi@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz"
   integrity sha1-qEeQIusaw2iocTibY1JixQXuNo8=
   dependencies:
     ansi-regex "^3.0.0"
 
 strip-ansi@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.0.tgz#0b1571dd7669ccd4f3e06e14ef1eed26225ae532"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz"
   integrity sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==
   dependencies:
     ansi-regex "^5.0.0"
 
+strip-ansi@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
+  dependencies:
+    ansi-regex "^5.0.1"
+
 strip-bom@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
+  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz"
   integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=
   dependencies:
     is-utf8 "^0.2.0"
 
 strip-bom@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
+  resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz"
   integrity sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=
 
 strip-eof@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf"
+  resolved "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz"
   integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=
 
 strip-indent@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-1.0.1.tgz#0c7962a6adefa7bbd4ac366460a638552ae1a0a2"
+  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-1.0.1.tgz"
   integrity sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=
   dependencies:
     get-stdin "^4.0.1"
 
 strip-indent@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
+  resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-2.0.0.tgz"
   integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
 
-strip-json-comments@2.0.1, strip-json-comments@~2.0.1:
+strip-json-comments@2.0.1:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
+  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz"
   integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
 
 strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
+  resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
 supports-color@3.1.2:
   version "3.1.2"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.1.2.tgz#72a262894d9d408b956ca05ff37b2ed8a6e2a2d5"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-3.1.2.tgz"
   integrity sha1-cqJiiU2dQIuVbKBf83su2KbiotU=
   dependencies:
     has-flag "^1.0.0"
 
 supports-color@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz"
   integrity sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=
 
 supports-color@^3.1.0:
   version "3.2.3"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.2.3.tgz#65ac0504b3954171d8a64946b2ae3cbb8a5f54f6"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz"
   integrity sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=
   dependencies:
     has-flag "^1.0.0"
 
 supports-color@^5.3.0:
   version "5.5.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz"
   integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
   dependencies:
     has-flag "^3.0.0"
 
 supports-color@^7.1.0:
   version "7.2.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
+  resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz"
   integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
   dependencies:
     has-flag "^4.0.0"
 
 symbol-observable@^1.1.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.2.0.tgz#c22688aed4eab3cdc2dfeacbb561660560a00804"
+  resolved "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.2.0.tgz"
   integrity sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==
 
 table@^6.0.4:
   version "6.0.9"
-  resolved "https://registry.yarnpkg.com/table/-/table-6.0.9.tgz#790a12bf1e09b87b30e60419bafd6a1fd85536fb"
+  resolved "https://registry.npmjs.org/table/-/table-6.0.9.tgz"
   integrity sha512-F3cLs9a3hL1Z7N4+EkSscsel3z55XT950AvB05bwayrNg5T1/gykXtigioTAjbltvbMSJvvhFCbnf6mX+ntnJQ==
   dependencies:
     ajv "^8.0.1"
@@ -8919,25 +9152,24 @@ table@^6.0.4:
 
 tapable@^1.0.0, tapable@^1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/tapable/-/tapable-1.1.1.tgz#4d297923c5a72a42360de2ab52dadfaaec00018e"
+  resolved "https://registry.npmjs.org/tapable/-/tapable-1.1.1.tgz"
   integrity sha512-9I2ydhj8Z9veORCw5PRm4u9uebCn0mcCa6scWoNcbZ6dAtoo2618u9UUzxgmsCOreJpqDDuv61LvwofW7hLcBA==
 
-tar@^4:
-  version "4.4.8"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-4.4.8.tgz#b19eec3fde2a96e64666df9fdb40c5ca1bc3747d"
-  integrity sha512-LzHF64s5chPQQS0IYBn9IN5h3i98c12bo4NCO7e0sGM2llXQ3p2FGC5sdENN4cTW48O915Sh+x+EXx7XW96xYQ==
+tar@^6.1.11:
+  version "6.1.11"
+  resolved "https://registry.npmjs.org/tar/-/tar-6.1.11.tgz"
+  integrity sha512-an/KZQzQUkZCkuoAA64hM92X0Urb6VpRhAFllDzz44U2mcD5scmT3zBc4VgVpkugF580+DQn8eAFSyoQt0tznA==
   dependencies:
-    chownr "^1.1.1"
-    fs-minipass "^1.2.5"
-    minipass "^2.3.4"
-    minizlib "^1.1.1"
-    mkdirp "^0.5.0"
-    safe-buffer "^5.1.2"
-    yallist "^3.0.2"
+    chownr "^2.0.0"
+    fs-minipass "^2.0.0"
+    minipass "^3.0.0"
+    minizlib "^2.1.1"
+    mkdirp "^1.0.3"
+    yallist "^4.0.0"
 
 tcp-port-used@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/tcp-port-used/-/tcp-port-used-1.0.1.tgz#46061078e2d38c73979a2c2c12b5a674e6689d70"
+  resolved "https://registry.npmjs.org/tcp-port-used/-/tcp-port-used-1.0.1.tgz"
   integrity sha512-rwi5xJeU6utXoEIiMvVBMc9eJ2/ofzB+7nLOdnZuFTmNCLqRiQh2sMG9MqCxHU/69VC/Fwp5dV9306Qd54ll1Q==
   dependencies:
     debug "4.1.0"
@@ -8945,7 +9177,7 @@ tcp-port-used@^1.0.1:
 
 terser-webpack-plugin@^1.1.0:
   version "1.2.1"
-  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-1.2.1.tgz#7545da9ae5f4f9ae6a0ac961eb46f5e7c845cc26"
+  resolved "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-1.2.1.tgz"
   integrity sha512-GGSt+gbT0oKcMDmPx4SRSfJPE1XaN3kQRWG4ghxKQw9cn5G9x6aCKSsgYdvyM0na9NJ4Drv0RG6jbBByZ5CMjw==
   dependencies:
     cacache "^11.0.2"
@@ -8959,7 +9191,7 @@ terser-webpack-plugin@^1.1.0:
 
 terser@^3.8.1:
   version "3.14.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-3.14.1.tgz#cc4764014af570bc79c79742358bd46926018a32"
+  resolved "https://registry.npmjs.org/terser/-/terser-3.14.1.tgz"
   integrity sha512-NSo3E99QDbYSMeJaEk9YW2lTg3qS9V0aKGlb+PlOrei1X02r1wSBHCNX/O+yeTRFSWPKPIGj6MqvvdqV4rnVGw==
   dependencies:
     commander "~2.17.1"
@@ -8968,7 +9200,7 @@ terser@^3.8.1:
 
 terser@^5.6.1:
   version "5.6.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-5.6.1.tgz#a48eeac5300c0a09b36854bf90d9c26fb201973c"
+  resolved "https://registry.npmjs.org/terser/-/terser-5.6.1.tgz"
   integrity sha512-yv9YLFQQ+3ZqgWCUk+pvNJwgUTdlIxUk1WTN+RnaFJe2L7ipG2csPT0ra2XRm7Cs8cxN7QXmK1rFzEwYEQkzXw==
   dependencies:
     commander "^2.20.0"
@@ -8977,7 +9209,7 @@ terser@^5.6.1:
 
 test-exclude@^5.0.0:
   version "5.0.0"
-  resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-5.0.0.tgz#cdce7cece785e0e829cd5c2b27baf18bc583cfb7"
+  resolved "https://registry.npmjs.org/test-exclude/-/test-exclude-5.0.0.tgz"
   integrity sha512-bO3Lj5+qFa9YLfYW2ZcXMOV1pmQvw+KS/DpjqhyX6Y6UZ8zstpZJ+mA2ERkXfpOqhxsJlQiLeVXD3Smsrs6oLw==
   dependencies:
     arrify "^1.0.1"
@@ -8987,22 +9219,22 @@ test-exclude@^5.0.0:
 
 text-extensions@^1.0.0:
   version "1.9.0"
-  resolved "https://registry.yarnpkg.com/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26"
+  resolved "https://registry.npmjs.org/text-extensions/-/text-extensions-1.9.0.tgz"
   integrity sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==
 
 text-table@^0.2.0:
   version "0.2.0"
-  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
+  resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz"
   integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=
 
 throttleit@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/throttleit/-/throttleit-1.0.0.tgz#9e785836daf46743145a5984b6268d828528ac6c"
+  resolved "https://registry.npmjs.org/throttleit/-/throttleit-1.0.0.tgz"
   integrity sha1-nnhYNtr0Z0MUWlmEtiaNgoUorGw=
 
 through2@^2.0.0, through2@^2.0.2:
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
+  resolved "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz"
   integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
   dependencies:
     readable-stream "~2.3.6"
@@ -9010,72 +9242,72 @@ through2@^2.0.0, through2@^2.0.2:
 
 through@2, "through@>=2.2.7 <3", through@^2.3.6:
   version "2.3.8"
-  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
+  resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz"
   integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=
 
 thunkify@~2.1.1:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/thunkify/-/thunkify-2.1.2.tgz#faa0e9d230c51acc95ca13a361ac05ca7e04553d"
+  resolved "https://registry.npmjs.org/thunkify/-/thunkify-2.1.2.tgz"
   integrity sha1-+qDp0jDFGsyVyhOjYawFyn4EVT0=
 
 timers-browserify@^2.0.4:
   version "2.0.10"
-  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.10.tgz#1d28e3d2aadf1d5a5996c4e9f95601cd053480ae"
+  resolved "https://registry.npmjs.org/timers-browserify/-/timers-browserify-2.0.10.tgz"
   integrity sha512-YvC1SV1XdOUaL6gx5CoGroT3Gu49pK9+TZ38ErPldOWW4j49GI1HKs9DV+KGq/w6y+LZ72W1c8cKz2vzY+qpzg==
   dependencies:
     setimmediate "^1.0.4"
 
 tmp@0.0.30:
   version "0.0.30"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.30.tgz#72419d4a8be7d6ce75148fd8b324e593a711c2ed"
+  resolved "https://registry.npmjs.org/tmp/-/tmp-0.0.30.tgz"
   integrity sha1-ckGdSovn1s51FI/YsyTlk6cRwu0=
   dependencies:
     os-tmpdir "~1.0.1"
 
 tmp@0.0.33, tmp@0.0.x, tmp@^0.0.33:
   version "0.0.33"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
+  resolved "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz"
   integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
   dependencies:
     os-tmpdir "~1.0.2"
 
 tmp@^0.0.29:
   version "0.0.29"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.29.tgz#f25125ff0dd9da3ccb0c2dd371ee1288bb9128c0"
+  resolved "https://registry.npmjs.org/tmp/-/tmp-0.0.29.tgz"
   integrity sha1-8lEl/w3Z2jzLDC3Tce4SiLuRKMA=
   dependencies:
     os-tmpdir "~1.0.1"
 
 to-array@0.1.4:
   version "0.1.4"
-  resolved "https://registry.yarnpkg.com/to-array/-/to-array-0.1.4.tgz#17e6c11f73dd4f3d74cda7a4ff3238e9ad9bf890"
+  resolved "https://registry.npmjs.org/to-array/-/to-array-0.1.4.tgz"
   integrity sha1-F+bBH3PdTz10zaek/zI46a2b+JA=
 
 to-arraybuffer@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz#7d229b1fcc637e466ca081180836a7aabff83f43"
+  resolved "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz"
   integrity sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=
 
 to-fast-properties@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-1.0.3.tgz#b83571fa4d8c25b82e231b06e3a3055de4ca1a47"
+  resolved "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz"
   integrity sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=
 
 to-fast-properties@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
+  resolved "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz"
   integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=
 
 to-object-path@^0.3.0:
   version "0.3.0"
-  resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
+  resolved "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz"
   integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=
   dependencies:
     kind-of "^3.0.2"
 
 to-regex-range@^2.1.0:
   version "2.1.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
+  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz"
   integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=
   dependencies:
     is-number "^3.0.0"
@@ -9083,14 +9315,14 @@ to-regex-range@^2.1.0:
 
 to-regex-range@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
+  resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz"
   integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
   dependencies:
     is-number "^7.0.0"
 
 to-regex@^3.0.1, to-regex@^3.0.2:
   version "3.0.2"
-  resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
+  resolved "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz"
   integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==
   dependencies:
     define-property "^2.0.2"
@@ -9100,35 +9332,40 @@ to-regex@^3.0.1, to-regex@^3.0.2:
 
 tough-cookie@~2.4.3:
   version "2.4.3"
-  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.4.3.tgz#53f36da3f47783b0925afa06ff9f3b165280f781"
+  resolved "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz"
   integrity sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==
   dependencies:
     psl "^1.1.24"
     punycode "^1.4.1"
 
+tr46@~0.0.3:
+  version "0.0.3"
+  resolved "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz"
+  integrity sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=
+
 trim-newlines@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-1.0.0.tgz#5887966bb582a4503a41eb524f7d35011815a613"
+  resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-1.0.0.tgz"
   integrity sha1-WIeWa7WCpFA6QetST301ARgVphM=
 
 trim-newlines@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-2.0.0.tgz#b403d0b91be50c331dfc4b82eeceb22c3de16d20"
+  resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-2.0.0.tgz"
   integrity sha1-tAPQuRvlDDMd/EuC7s6yLD3hbSA=
 
 trim-off-newlines@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz#9f9ba9d9efa8764c387698bcbfeb2c848f11adb3"
+  resolved "https://registry.npmjs.org/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz"
   integrity sha1-n5up2e+odkw4dpi8v+sshI8RrbM=
 
 trim-right@^1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003"
+  resolved "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz"
   integrity sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=
 
 ts-loader@^8.1.0:
   version "8.1.0"
-  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-8.1.0.tgz#d6292487df279c7cc79b6d3b70bb9d31682b693e"
+  resolved "https://registry.npmjs.org/ts-loader/-/ts-loader-8.1.0.tgz"
   integrity sha512-YiQipGGAFj2zBfqLhp28yUvPP9jUGqHxRzrGYuc82Z2wM27YIHbElXiaZDc93c3x0mz4zvBmS6q/DgExpdj37A==
   dependencies:
     chalk "^4.1.0"
@@ -9139,7 +9376,7 @@ ts-loader@^8.1.0:
 
 ts-node@^9.1.1:
   version "9.1.1"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-9.1.1.tgz#51a9a450a3e959401bda5f004a72d54b936d376d"
+  resolved "https://registry.npmjs.org/ts-node/-/ts-node-9.1.1.tgz"
   integrity sha512-hPlt7ZACERQGf03M253ytLY3dHbGNGrAq9qIHWUY9XHYl1z7wYngSr3OQ5xmui8o2AaxsONxIzjafLUiWBo1Fg==
   dependencies:
     arg "^4.1.0"
@@ -9151,80 +9388,80 @@ ts-node@^9.1.1:
 
 tslib@2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.1.0.tgz"
   integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
 
 tslib@^1.8.1:
   version "1.14.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz"
   integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
 
 tslib@^1.9.0:
   version "1.9.3"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz"
   integrity sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==
 
 tslib@^2.2.0:
   version "2.2.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c"
+  resolved "https://registry.npmjs.org/tslib/-/tslib-2.2.0.tgz"
   integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==
 
 tsutils@^3.17.1:
   version "3.21.0"
-  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
+  resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz"
   integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
   dependencies:
     tslib "^1.8.1"
 
 tty-browserify@0.0.0:
   version "0.0.0"
-  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6"
+  resolved "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz"
   integrity sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=
 
 tunnel-agent@^0.6.0:
   version "0.6.0"
-  resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
+  resolved "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz"
   integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=
   dependencies:
     safe-buffer "^5.0.1"
 
 tweetnacl@^0.14.3, tweetnacl@~0.14.0:
   version "0.14.5"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
+  resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz"
   integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=
 
 type-check@^0.4.0, type-check@~0.4.0:
   version "0.4.0"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
+  resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz"
   integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
   dependencies:
     prelude-ls "^1.2.1"
 
 type-check@~0.3.2:
   version "0.3.2"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
+  resolved "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz"
   integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=
   dependencies:
     prelude-ls "~1.1.2"
 
 type-detect@0.1.1:
   version "0.1.1"
-  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-0.1.1.tgz#0ba5ec2a885640e470ea4e8505971900dac58822"
+  resolved "https://registry.npmjs.org/type-detect/-/type-detect-0.1.1.tgz"
   integrity sha1-C6XsKohWQORw6k6FBZcZANrFiCI=
 
 type-fest@^0.20.2:
   version "0.20.2"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz"
   integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
 
 type-fest@^0.8.1:
   version "0.8.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
+  resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz"
   integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
 
 type-is@~1.6.16:
   version "1.6.16"
-  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.16.tgz#f89ce341541c672b25ee7ae3c73dee3b2be50194"
+  resolved "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz"
   integrity sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==
   dependencies:
     media-typer "0.3.0"
@@ -9232,32 +9469,32 @@ type-is@~1.6.16:
 
 typedarray@^0.0.6:
   version "0.0.6"
-  resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
+  resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
 typescript@^4.2.2:
   version "4.2.3"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.3.tgz#39062d8019912d43726298f09493d598048c1ce3"
+  resolved "https://registry.npmjs.org/typescript/-/typescript-4.2.3.tgz"
   integrity sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==
 
 uglify-js@^3.1.4:
   version "3.13.0"
-  resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.13.0.tgz#66ed69f7241f33f13531d3d51d5bcebf00df7f69"
+  resolved "https://registry.npmjs.org/uglify-js/-/uglify-js-3.13.0.tgz"
   integrity sha512-TWYSWa9T2pPN4DIJYbU9oAjQx+5qdV5RUDxwARg8fmJZrD/V27Zj0JngW5xg1DFz42G0uDYl2XhzF6alSzD62w==
 
 ultron@~1.1.0:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/ultron/-/ultron-1.1.1.tgz#9fe1536a10a664a65266a1e3ccf85fd36302bc9c"
+  resolved "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz"
   integrity sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==
 
 unicode-canonical-property-names-ecmascript@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-1.0.4.tgz#2619800c4c825800efdd8343af7dd9933cbe2818"
+  resolved "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-1.0.4.tgz"
   integrity sha512-jDrNnXWHd4oHiTZnx/ZG7gtUTVp+gCcTTKr8L0HjlwphROEW3+Him+IpvC+xcJEFegapiMZyZe02CyuOnRmbnQ==
 
 unicode-match-property-ecmascript@^1.0.4:
   version "1.0.4"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-1.0.4.tgz#8ed2a32569961bce9227d09cd3ffbb8fed5f020c"
+  resolved "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-1.0.4.tgz"
   integrity sha512-L4Qoh15vTfntsn4P1zqnHulG0LdXgjSO035fEpdtp6YxXhMT51Q6vgM5lYdG/5X3MjS+k/Y9Xw4SFCY9IkR0rg==
   dependencies:
     unicode-canonical-property-names-ecmascript "^1.0.4"
@@ -9265,17 +9502,17 @@ unicode-match-property-ecmascript@^1.0.4:
 
 unicode-match-property-value-ecmascript@^1.1.0, unicode-match-property-value-ecmascript@^1.2.0:
   version "1.2.0"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz#0d91f600eeeb3096aa962b1d6fc88876e64ea531"
+  resolved "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz"
   integrity sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==
 
 unicode-property-aliases-ecmascript@^1.0.4:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz#dd57a99f6207bedff4628abefb94c50db941c8f4"
+  resolved "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz"
   integrity sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==
 
 union-value@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.0.tgz#5c71c34cb5bad5dcebe3ea0cd08207ba5aa1aea4"
+  resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.0.tgz"
   integrity sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=
   dependencies:
     arr-union "^3.1.0"
@@ -9285,38 +9522,38 @@ union-value@^1.0.0:
 
 union@~0.5.0:
   version "0.5.0"
-  resolved "https://registry.yarnpkg.com/union/-/union-0.5.0.tgz#b2c11be84f60538537b846edb9ba266ba0090075"
+  resolved "https://registry.npmjs.org/union/-/union-0.5.0.tgz"
   integrity sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==
   dependencies:
     qs "^6.4.0"
 
 unique-filename@^1.1.1:
   version "1.1.1"
-  resolved "https://registry.yarnpkg.com/unique-filename/-/unique-filename-1.1.1.tgz#1d69769369ada0583103a1e6ae87681b56573230"
+  resolved "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.1.tgz"
   integrity sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==
   dependencies:
     unique-slug "^2.0.0"
 
 unique-slug@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/unique-slug/-/unique-slug-2.0.1.tgz#5e9edc6d1ce8fb264db18a507ef9bd8544451ca6"
+  resolved "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.1.tgz"
   integrity sha512-n9cU6+gITaVu7VGj1Z8feKMmfAjEAQGhwD9fE3zvpRRa0wEIx8ODYkVGfSc94M2OX00tUFV8wH3zYbm1I8mxFg==
   dependencies:
     imurmurhash "^0.1.4"
 
 universalify@^0.1.0:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
+  resolved "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz"
   integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
 
 unpipe@1.0.0, unpipe@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
+  resolved "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz"
   integrity sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=
 
 unset-value@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
+  resolved "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz"
   integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=
   dependencies:
     has-value "^0.3.1"
@@ -9324,29 +9561,29 @@ unset-value@^1.0.0:
 
 upath@^1.0.5:
   version "1.1.0"
-  resolved "https://registry.yarnpkg.com/upath/-/upath-1.1.0.tgz#35256597e46a581db4793d0ce47fa9aebfc9fabd"
+  resolved "https://registry.npmjs.org/upath/-/upath-1.1.0.tgz"
   integrity sha512-bzpH/oBhoS/QI/YtbkqCg6VEiPYjSZtrHQM6/QnJS6OL9pKUFLqb3aFh4Scvwm45+7iAgiMkLhSbaZxUqmrprw==
 
 uri-js@^4.2.2:
   version "4.2.2"
-  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.2.2.tgz#94c540e1ff772956e2299507c010aea6c8838eb0"
+  resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz"
   integrity sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==
   dependencies:
     punycode "^2.1.0"
 
 urix@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
+  resolved "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz"
   integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
 
 url-join@^2.0.5:
   version "2.0.5"
-  resolved "https://registry.yarnpkg.com/url-join/-/url-join-2.0.5.tgz#5af22f18c052a000a48d7b82c5e9c2e2feeda728"
+  resolved "https://registry.npmjs.org/url-join/-/url-join-2.0.5.tgz"
   integrity sha1-WvIvGMBSoACkjXuCxenC4v7tpyg=
 
 url@^0.11.0:
   version "0.11.0"
-  resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
+  resolved "https://registry.npmjs.org/url/-/url-0.11.0.tgz"
   integrity sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=
   dependencies:
     punycode "1.3.2"
@@ -9354,30 +9591,30 @@ url@^0.11.0:
 
 urlgrey@^0.4.4:
   version "0.4.4"
-  resolved "https://registry.yarnpkg.com/urlgrey/-/urlgrey-0.4.4.tgz#892fe95960805e85519f1cd4389f2cb4cbb7652f"
+  resolved "https://registry.npmjs.org/urlgrey/-/urlgrey-0.4.4.tgz"
   integrity sha1-iS/pWWCAXoVRnxzUOJ8stMu3ZS8=
 
 use@^3.1.0:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
+  resolved "https://registry.npmjs.org/use/-/use-3.1.1.tgz"
   integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
 
 useragent@2.3.0:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/useragent/-/useragent-2.3.0.tgz#217f943ad540cb2128658ab23fc960f6a88c9972"
+  resolved "https://registry.npmjs.org/useragent/-/useragent-2.3.0.tgz"
   integrity sha512-4AoH4pxuSvHCjqLO04sU6U/uE65BYza8l/KKBS0b0hnUPWi+cQ2BpeTEwejCSx9SPV5/U03nniDTrWx5NrmKdw==
   dependencies:
     lru-cache "4.1.x"
     tmp "0.0.x"
 
-util-deprecate@~1.0.1:
+util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
+  resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz"
   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
 
 util.promisify@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/util.promisify/-/util.promisify-1.0.0.tgz#440f7165a459c9a16dc145eb8e72f35687097030"
+  resolved "https://registry.npmjs.org/util.promisify/-/util.promisify-1.0.0.tgz"
   integrity sha512-i+6qA2MPhvoKLuxnJNpXAGhg7HphQOSUq2LKMZD0m15EiskXUkMvKdF4Uui0WYeCUGea+o2cw/ZuwehtfsrNkA==
   dependencies:
     define-properties "^1.1.2"
@@ -9385,36 +9622,36 @@ util.promisify@^1.0.0:
 
 util@0.10.3:
   version "0.10.3"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.10.3.tgz#7afb1afe50805246489e3db7fe0ed379336ac0f9"
+  resolved "https://registry.npmjs.org/util/-/util-0.10.3.tgz"
   integrity sha1-evsa/lCAUkZInj23/g7TeTNqwPk=
   dependencies:
     inherits "2.0.1"
 
 util@^0.10.3:
   version "0.10.4"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.10.4.tgz#3aa0125bfe668a4672de58857d3ace27ecb76901"
+  resolved "https://registry.npmjs.org/util/-/util-0.10.4.tgz"
   integrity sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==
   dependencies:
     inherits "2.0.3"
 
 utils-merge@1.0.1:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
+  resolved "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz"
   integrity sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=
 
 uuid@^3.3.2:
   version "3.3.2"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.3.2.tgz#1b4af4955eb3077c501c23872fc6513811587131"
+  resolved "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz"
   integrity sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==
 
 v8-compile-cache@^2.0.3:
   version "2.3.0"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
+  resolved "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz"
   integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
 
 validate-npm-package-license@^3.0.1:
   version "3.0.4"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
+  resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz"
   integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
   dependencies:
     spdx-correct "^3.0.0"
@@ -9422,7 +9659,7 @@ validate-npm-package-license@^3.0.1:
 
 verror@1.10.0:
   version "1.10.0"
-  resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
+  resolved "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz"
   integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=
   dependencies:
     assert-plus "^1.0.0"
@@ -9431,28 +9668,33 @@ verror@1.10.0:
 
 vm-browserify@0.0.4:
   version "0.0.4"
-  resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-0.0.4.tgz#5d7ea45bbef9e4a6ff65f95438e0a87c357d5a73"
+  resolved "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz"
   integrity sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=
   dependencies:
     indexof "0.0.1"
 
 void-elements@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.yarnpkg.com/void-elements/-/void-elements-2.0.1.tgz#c066afb582bb1cb4128d60ea92392e94d5e9dbec"
+  resolved "https://registry.npmjs.org/void-elements/-/void-elements-2.0.1.tgz"
   integrity sha1-wGavtYK7HLQSjWDqkjkulNXp2+w=
 
 watchpack@^1.5.0:
   version "1.6.0"
-  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-1.6.0.tgz#4bc12c2ebe8aa277a71f1d3f14d685c7b446cd00"
+  resolved "https://registry.npmjs.org/watchpack/-/watchpack-1.6.0.tgz"
   integrity sha512-i6dHe3EyLjMmDlU1/bGQpEw25XSjkJULPuAVKCbNRefQVq48yXKUpwg538F7AZTf9kyr57zj++pQFltUa5H7yA==
   dependencies:
     chokidar "^2.0.2"
     graceful-fs "^4.1.2"
     neo-async "^2.5.0"
 
+webidl-conversions@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz"
+  integrity sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=
+
 webpack-dev-middleware@^3.2.0:
   version "3.5.0"
-  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-3.5.0.tgz#fff0a07b0461314fb6ca82df3642c2423f768429"
+  resolved "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-3.5.0.tgz"
   integrity sha512-1Zie7+dMr4Vv3nGyhr8mxGQkzTQK1PTS8K3yJ4yB1mfRGwO1DzQibgmNfUqbEfQY6eEtEEUzC+o7vhpm/Sfn5w==
   dependencies:
     memory-fs "~0.4.1"
@@ -9462,7 +9704,7 @@ webpack-dev-middleware@^3.2.0:
 
 webpack-log@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/webpack-log/-/webpack-log-2.0.0.tgz#5b7928e0637593f119d32f6227c1e0ac31e1b47f"
+  resolved "https://registry.npmjs.org/webpack-log/-/webpack-log-2.0.0.tgz"
   integrity sha512-cX8G2vR/85UYG59FgkoMamwHUIkSSlV3bBMRsbxVXVUk2j6NleCKjQ/WE9eYg9WY4w25O9w8wKP4rzNZFmUcUg==
   dependencies:
     ansi-colors "^3.0.0"
@@ -9470,7 +9712,7 @@ webpack-log@^2.0.0:
 
 webpack-sources@^1.1.0, webpack-sources@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-1.3.0.tgz#2a28dcb9f1f45fe960d8f1493252b5ee6530fa85"
+  resolved "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.3.0.tgz"
   integrity sha512-OiVgSrbGu7NEnEvQJJgdSFPl2qWKkWq5lHMhgiToIiN9w34EBnjYzSYs+VbL5KoYiLNtFFa7BZIKxRED3I32pA==
   dependencies:
     source-list-map "^2.0.0"
@@ -9478,7 +9720,7 @@ webpack-sources@^1.1.0, webpack-sources@^1.3.0:
 
 webpack@~4.28.4:
   version "4.28.4"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-4.28.4.tgz#1ddae6c89887d7efb752adf0c3cd32b9b07eacd0"
+  resolved "https://registry.npmjs.org/webpack/-/webpack-4.28.4.tgz"
   integrity sha512-NxjD61WsK/a3JIdwWjtIpimmvE6UrRi3yG54/74Hk9rwNj5FPkA4DJCf1z4ByDWLkvZhTZE+P3C/eh6UD5lDcw==
   dependencies:
     "@webassemblyjs/ast" "1.7.11"
@@ -9508,62 +9750,70 @@ webpack@~4.28.4:
 
 weex-js-runtime@^0.23.6:
   version "0.23.7"
-  resolved "https://registry.yarnpkg.com/weex-js-runtime/-/weex-js-runtime-0.23.7.tgz#c9d3427f2debf1d638ab4e41bb4f0e539a51915c"
+  resolved "https://registry.npmjs.org/weex-js-runtime/-/weex-js-runtime-0.23.7.tgz"
   integrity sha512-3BFd5GXTo0X/GWh0KjzXDpIcPJuSwYuc9fE9llgez35IfVHs/nUmfkFBjifzxOJS2YLhtKf0Cy8eTQ00CJDWZA==
 
 weex-styler@^0.3.0:
   version "0.3.1"
-  resolved "https://registry.yarnpkg.com/weex-styler/-/weex-styler-0.3.1.tgz#47d0188cc70aff97ccaa3a63b98733d549848680"
+  resolved "https://registry.npmjs.org/weex-styler/-/weex-styler-0.3.1.tgz"
   integrity sha512-xkX5/wS/QLiJXKwbdpeytbLN0kHviQwj9CLdvBxqu+RRZABZpTniKZr1oxjh9Q0+n/aRC+smwFpQpUKvXh9V1g==
   dependencies:
     css "~2.2.1"
 
+whatwg-url@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz"
+  integrity sha1-lmRU6HZUYuN2RNNib2dCzotwll0=
+  dependencies:
+    tr46 "~0.0.3"
+    webidl-conversions "^3.0.0"
+
 which@^1.1.1, which@^1.2.1, which@^1.2.10, which@^1.2.12, which@^1.2.9:
   version "1.3.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
+  resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz"
   integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
   dependencies:
     isexe "^2.0.0"
 
 which@^2.0.1:
   version "2.0.2"
-  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
+  resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz"
   integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
   dependencies:
     isexe "^2.0.0"
 
-wide-align@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
-  integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==
+wide-align@^1.1.2:
+  version "1.1.5"
+  resolved "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz"
+  integrity sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==
   dependencies:
-    string-width "^1.0.2 || 2"
+    string-width "^1.0.2 || 2 || 3 || 4"
 
 word-wrap@^1.0.3, word-wrap@^1.2.3:
   version "1.2.3"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
+  resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz"
   integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
 
 wordwrap@^1.0.0, wordwrap@~1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
+  resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz"
   integrity sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=
 
 wordwrap@~0.0.2:
   version "0.0.3"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
+  resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.3.tgz"
   integrity sha1-o9XabNXAvAAI03I0u68b7WMFkQc=
 
 worker-farm@^1.5.2:
   version "1.6.0"
-  resolved "https://registry.yarnpkg.com/worker-farm/-/worker-farm-1.6.0.tgz#aecc405976fab5a95526180846f0dba288f3a4a0"
+  resolved "https://registry.npmjs.org/worker-farm/-/worker-farm-1.6.0.tgz"
   integrity sha512-6w+3tHbM87WnSWnENBUvA2pxJPLhQUg5LKwUQHq3r+XPhIM+Gh2R5ycbwPCyuGbNg+lPgdcnQUhuC02kJCvffQ==
   dependencies:
     errno "~0.1.7"
 
 wrap-ansi@^3.0.1:
   version "3.0.1"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-3.0.1.tgz#288a04d87eda5c286e060dfe8f135ce8d007f8ba"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-3.0.1.tgz"
   integrity sha1-KIoE2H7aXChuBg3+jxNc6NAH+Lo=
   dependencies:
     string-width "^2.1.1"
@@ -9571,7 +9821,7 @@ wrap-ansi@^3.0.1:
 
 wrap-ansi@^7.0.0:
   version "7.0.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
+  resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
   dependencies:
     ansi-styles "^4.0.0"
@@ -9580,19 +9830,19 @@ wrap-ansi@^7.0.0:
 
 wrappy@1:
   version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
+  resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz"
   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
 
 ws@^6.1.0:
   version "6.1.2"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-6.1.2.tgz#3cc7462e98792f0ac679424148903ded3b9c3ad8"
+  resolved "https://registry.npmjs.org/ws/-/ws-6.1.2.tgz"
   integrity sha512-rfUqzvz0WxmSXtJpPMX2EeASXabOrSMk1ruMOV3JBTBjo4ac2lDjGGsbQSyxj8Odhw5fBib8ZKEjDNvgouNKYw==
   dependencies:
     async-limiter "~1.0.0"
 
 ws@~3.3.1:
   version "3.3.3"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-3.3.3.tgz#f1cf84fe2d5e901ebce94efaece785f187a228f2"
+  resolved "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz"
   integrity sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==
   dependencies:
     async-limiter "~1.0.0"
@@ -9601,7 +9851,7 @@ ws@~3.3.1:
 
 xml2js@^0.4.17:
   version "0.4.19"
-  resolved "https://registry.yarnpkg.com/xml2js/-/xml2js-0.4.19.tgz#686c20f213209e94abf0d1bcf1efaa291c7827a7"
+  resolved "https://registry.npmjs.org/xml2js/-/xml2js-0.4.19.tgz"
   integrity sha512-esZnJZJOiJR9wWKMyuvSE1y6Dq5LCuJanqhxslH2bxM6duahNZ+HMpCLhBQGZkbX6xRf8x1Y2eJlgt2q3qo49Q==
   dependencies:
     sax ">=0.6.0"
@@ -9609,57 +9859,57 @@ xml2js@^0.4.17:
 
 xmlbuilder@~9.0.1:
   version "9.0.7"
-  resolved "https://registry.yarnpkg.com/xmlbuilder/-/xmlbuilder-9.0.7.tgz#132ee63d2ec5565c557e20f4c22df9aca686b10d"
+  resolved "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.7.tgz"
   integrity sha1-Ey7mPS7FVlxVfiD0wi35rKaGsQ0=
 
 xmlhttprequest-ssl@~1.5.4:
   version "1.5.5"
-  resolved "https://registry.yarnpkg.com/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.5.tgz#c2876b06168aadc40e57d97e81191ac8f4398b3e"
+  resolved "https://registry.npmjs.org/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.5.tgz"
   integrity sha1-wodrBhaKrcQOV9l+gRkayPQ5iz4=
 
 xregexp@2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/xregexp/-/xregexp-2.0.0.tgz#52a63e56ca0b84a7f3a5f3d61872f126ad7a5943"
+  resolved "https://registry.npmjs.org/xregexp/-/xregexp-2.0.0.tgz"
   integrity sha1-UqY+VsoLhKfzpfPWGHLxJq16WUM=
 
 xtend@^4.0.0, xtend@~4.0.1:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af"
+  resolved "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz"
   integrity sha1-pcbVMr5lbiPbgg77lDofBJmNY68=
 
 y18n@^4.0.0:
   version "4.0.1"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.1.tgz#8db2b83c31c5d75099bb890b23f3094891e247d4"
+  resolved "https://registry.npmjs.org/y18n/-/y18n-4.0.1.tgz"
   integrity sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==
 
 y18n@^5.0.5:
   version "5.0.7"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.7.tgz#0c514aba53fc40e2db911aeb8b51566a3374efe7"
+  resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.7.tgz"
   integrity sha512-oOhslryvNcA1lB9WYr+M6TMyLkLg81Dgmyb48ZDU0lvR+5bmNDTMz7iobM1QXooaLhbbrcHrlNaABhI6Vo6StQ==
 
 yallist@^2.1.2:
   version "2.1.2"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52"
+  resolved "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz"
   integrity sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=
 
-yallist@^3.0.0, yallist@^3.0.2:
+yallist@^3.0.2:
   version "3.0.3"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.0.3.tgz#b4b049e314be545e3ce802236d6cd22cd91c3de9"
+  resolved "https://registry.npmjs.org/yallist/-/yallist-3.0.3.tgz"
   integrity sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A==
 
 yallist@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
+  resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
 yargs-parser@^20.2.2:
   version "20.2.7"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.7.tgz#61df85c113edfb5a7a4e36eb8aa60ef423cbc90a"
+  resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.7.tgz"
   integrity sha512-FiNkvbeHzB/syOjIUxFDCnhSfzAL8R5vs40MgLFBorXACCOAEaWu0gRZl14vG8MR9AOJIZbmkjhusqBYZ3HTHw==
 
 yargs@^16.2.0:
   version "16.2.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
+  resolved "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz"
   integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
   dependencies:
     cliui "^7.0.2"
@@ -9672,24 +9922,32 @@ yargs@^16.2.0:
 
 yauzl@2.4.1:
   version "2.4.1"
-  resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.4.1.tgz#9528f442dab1b2284e58b4379bb194e22e0c4005"
+  resolved "https://registry.npmjs.org/yauzl/-/yauzl-2.4.1.tgz"
   integrity sha1-lSj0QtqxsihOWLQ3m7GU4i4MQAU=
   dependencies:
     fd-slicer "~1.0.1"
 
+yauzl@^2.10.0:
+  version "2.10.0"
+  resolved "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz"
+  integrity sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=
+  dependencies:
+    buffer-crc32 "~0.2.3"
+    fd-slicer "~1.1.0"
+
 yeast@0.1.2:
   version "0.1.2"
-  resolved "https://registry.yarnpkg.com/yeast/-/yeast-0.1.2.tgz#008e06d8094320c372dbc2f8ed76a0ca6c8ac419"
+  resolved "https://registry.npmjs.org/yeast/-/yeast-0.1.2.tgz"
   integrity sha1-AI4G2AlDIMNy28L47XagymyKxBk=
 
 yn@3.1.1:
   version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+  resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz"
   integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
 
 yorkie@^2.0.0:
   version "2.0.0"
-  resolved "https://registry.yarnpkg.com/yorkie/-/yorkie-2.0.0.tgz#92411912d435214e12c51c2ae1093e54b6bb83d9"
+  resolved "https://registry.npmjs.org/yorkie/-/yorkie-2.0.0.tgz"
   integrity sha512-jcKpkthap6x63MB4TxwCyuIGkV0oYP/YRyuQU5UO0Yz/E/ZAu+653/uov+phdmO54n6BcvFRyyt0RRrWdN2mpw==
   dependencies:
     execa "^0.8.0"

From 8e047df75adaca168a69edfdbcbe89ff63a4f910 Mon Sep 17 00:00:00 2001
From: Carlos Rodrigues <carlos@hypermob.co.uk>
Date: Fri, 29 Apr 2022 19:54:08 +0100
Subject: [PATCH 022/317] update deps and other code -- still need to fix some
 issues with testing - basically dependencies issues

---
 dist/vue.common.dev.js                        |  4888 +++--
 dist/vue.common.prod.js                       |    10 +-
 dist/vue.esm.browser.js                       |   831 +-
 dist/vue.esm.browser.min.js                   |    10 +-
 dist/vue.esm.js                               |  4925 +++--
 dist/vue.js                                   |  4900 +++--
 dist/vue.min.js                               |    10 +-
 dist/vue.runtime.common.dev.js                |  3187 ++-
 dist/vue.runtime.common.prod.js               |    10 +-
 dist/vue.runtime.esm.js                       |  3223 ++--
 dist/vue.runtime.js                           |  3193 ++--
 dist/vue.runtime.min.js                       |    10 +-
 package.json                                  |   128 +-
 packages/vue-server-renderer/basic.js         | 15095 +++++++--------
 packages/vue-server-renderer/build.dev.js     | 15956 +++++++---------
 packages/vue-server-renderer/build.prod.js    |     2 +-
 packages/vue-server-renderer/client-plugin.js |   225 +-
 packages/vue-server-renderer/server-plugin.js |   238 +-
 .../vue-server-renderer/types/plugin.d.ts     |     6 +-
 packages/vue-template-compiler/browser.js     | 10708 +++++------
 packages/vue-template-compiler/build.js       |  8883 ++++-----
 scripts/config.js                             |     6 +-
 src/compiler/error-detector.ts                |     4 +-
 src/compiler/to-function.ts                   |     2 +-
 src/core/instance/render.ts                   |     4 +-
 src/core/observer/watcher.ts                  |     1 +
 src/core/util/env.ts                          |     6 +-
 src/core/util/error.ts                        |     3 +-
 src/core/util/next-tick.ts                    |     1 +
 .../vdom/helpers/normalize-scoped-slots.ts    |     2 +-
 src/core/vdom/modules/directives.ts           |     1 +
 src/platforms/web/runtime/transition-util.ts  |     2 -
 src/platforms/web/util/class.ts               |     1 +
 src/platforms/web/util/style.ts               |     1 +
 src/platforms/weex/entry-framework.ts         |     2 +-
 .../recycle-list/render-component-template.ts |     2 +-
 yarn.lock                                     | 10376 +++++-----
 37 files changed, 40786 insertions(+), 46066 deletions(-)

diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index cc22c8131a7..fdbed175c5c 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 'use strict';
 
-var emptyObject = Object.freeze({});
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 function isUndef(v) {
@@ -32,7 +32,7 @@ function isPrimitive(value) {
 }
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
 function isObject(obj) {
@@ -41,7 +41,7 @@ function isObject(obj) {
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
+const _toString = Object.prototype.toString;
 function toRawType(value) {
     return _toString.call(value).slice(8, -1);
 }
@@ -59,7 +59,7 @@ function isRegExp(v) {
  * Check if val is a valid array index.
  */
 function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
+    const n = parseFloat(String(val));
     return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
 function isPromise(val) {
@@ -82,7 +82,7 @@ function toString(val) {
  * If the conversion fails, return original string.
  */
 function toNumber(val) {
-    var n = parseFloat(val);
+    const n = parseFloat(val);
     return isNaN(n) ? val : n;
 }
 /**
@@ -90,27 +90,27 @@ function toNumber(val) {
  * is in that map.
  */
 function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
         map[list[i]] = true;
     }
-    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
 function remove$2(arr, item) {
     if (arr.length) {
-        var index = arr.indexOf(item);
+        const index = arr.indexOf(item);
         if (index > -1) {
             return arr.splice(index, 1);
         }
@@ -119,7 +119,7 @@ function remove$2(arr, item) {
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
 }
@@ -127,30 +127,30 @@ function hasOwn(obj, key) {
  * Create a cached version of a pure function.
  */
 function cached(fn) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function cachedFn(str) {
-        var hit = cache[str];
+        const hit = cache[str];
         return hit || (cache[str] = fn(str));
     };
 }
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
 /**
  * Capitalize a string.
  */
-var capitalize = cached(function (str) {
+const capitalize = cached((str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
 /**
@@ -163,7 +163,7 @@ var hyphenate = cached(function (str) {
 /* istanbul ignore next */
 function polyfillBind(fn, ctx) {
     function boundFn(a) {
-        var l = arguments.length;
+        const l = arguments.length;
         return l
             ? l > 1
                 ? fn.apply(ctx, arguments)
@@ -177,14 +177,14 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
 function toArray(list, start) {
     start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
+    let i = list.length - start;
+    const ret = new Array(i);
     while (i--) {
         ret[i] = list[i + start];
     }
@@ -194,7 +194,7 @@ function toArray(list, start) {
  * Mix properties into target object.
  */
 function extend(to, _from) {
-    for (var key in _from) {
+    for (const key in _from) {
         to[key] = _from[key];
     }
     return to;
@@ -203,8 +203,8 @@ function extend(to, _from) {
  * Merge an Array of Objects into a single Object.
  */
 function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
         if (arr[i]) {
             extend(res, arr[i]);
         }
@@ -221,18 +221,18 @@ function noop(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
+const identity = (_) => _;
 /**
  * Generate a string containing static keys from compiler modules.
  */
 function genStaticKeys$1(modules) {
     return modules
-        .reduce(function (keys, m) {
+        .reduce((keys, m) => {
         return keys.concat(m.staticKeys || []);
     }, [])
         .join(',');
@@ -243,16 +243,16 @@ function genStaticKeys$1(modules) {
  */
 function looseEqual(a, b) {
     if (a === b)
-        { return true; }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
     if (isObjectA && isObjectB) {
         try {
-            var isArrayA = Array.isArray(a);
-            var isArrayB = Array.isArray(b);
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
             if (isArrayA && isArrayB) {
                 return (a.length === b.length &&
-                    a.every(function (e, i) {
+                    a.every((e, i) => {
                         return looseEqual(e, b[i]);
                     }));
             }
@@ -260,10 +260,10 @@ function looseEqual(a, b) {
                 return a.getTime() === b.getTime();
             }
             else if (!isArrayA && !isArrayB) {
-                var keysA = Object.keys(a);
-                var keysB = Object.keys(b);
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
                 return (keysA.length === keysB.length &&
-                    keysA.every(function (key) {
+                    keysA.every((key) => {
                         return looseEqual(a[key], b[key]);
                     }));
             }
@@ -290,9 +290,9 @@ function looseEqual(a, b) {
  * contain an object of the same shape), or -1 if it is not present.
  */
 function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
+    for (let i = 0; i < arr.length; i++) {
         if (looseEqual(arr[i], val))
-            { return i; }
+            return i;
     }
     return -1;
 }
@@ -300,7 +300,7 @@ function looseIndexOf(arr, val) {
  * Ensure a function is called only once.
  */
 function once(fn) {
-    var called = false;
+    let called = false;
     return function () {
         if (!called) {
             called = true;
@@ -309,9 +309,9 @@ function once(fn) {
     };
 }
 
-var SSR_ATTR = 'data-server-rendered';
-var ASSET_TYPES = ['component', 'directive', 'filter'];
-var LIFECYCLE_HOOKS = [
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
     'beforeCreate',
     'created',
     'beforeMount',
@@ -323,7 +323,8 @@ var LIFECYCLE_HOOKS = [
     'activated',
     'deactivated',
     'errorCaptured',
-    'serverPrefetch' ];
+    'serverPrefetch',
+];
 
 var config = {
     /**
@@ -408,12 +409,12 @@ var config = {
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Check if a string starts with $ or _
  */
 function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
+    const c = (str + '').charCodeAt(0);
     return c === 0x24 || c === 0x5f;
 }
 /**
@@ -430,16 +431,16 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
     }
-    var segments = path.split('.');
+    const segments = path.split('.');
     return function (obj) {
-        for (var i = 0; i < segments.length; i++) {
+        for (let i = 0; i < segments.length; i++) {
             if (!obj)
-                { return; }
+                return;
             obj = obj[segments[i]];
         }
         return obj;
@@ -447,46 +448,41 @@ function parsePath(path) {
 }
 
 // can we use __proto__?
-var hasProto = '__proto__' in {};
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-// @ts-ignore
-var inWeex = 
-// @ts-ignore
-typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-// @ts-ignore
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
 (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 UA && /chrome\/\d+/.test(UA) && !isEdge;
 UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
-var nativeWatch = {}.watch;
-var supportsPassive = false;
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
     try {
-        var opts = {};
+        const opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
-        // @ts-ignore
         window.addEventListener('test-passive', null, opts);
     }
     catch (e) { }
 }
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
+let _isServer;
+const isServerRendering = () => {
     if (_isServer === undefined) {
         /* istanbul ignore if */
         if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -502,104 +498,94 @@ var isServerRendering = function () {
     return _isServer;
 };
 // detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
 }
-var hasSymbol = typeof Symbol !== 'undefined' &&
+const hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
+let _Set; // $flow-disable-line
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
     // use native Set when available.
     _Set = Set;
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-        function Set() {
-            this.set = Object.create(null);
-        }
-        Set.prototype.has = function has (key) {
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
             return this.set[key] === true;
-        };
-        Set.prototype.add = function add (key) {
+        }
+        add(key) {
             this.set[key] = true;
-        };
-        Set.prototype.clear = function clear () {
+        }
+        clear() {
             this.set = Object.create(null);
-        };
-
-        return Set;
-    }());
+        }
+    };
 }
 
-var warn$2 = noop;
-var tip = noop;
-var generateComponentTrace; // work around flow check
-var formatComponentName;
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn$2 = function (msg, vm) {
-        var trace = vm ? generateComponentTrace(vm) : '';
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
         else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+            console.error(`[Vue warn]: ${msg}${trace}`);
         }
     };
-    tip = function (msg, vm) {
+    tip = (msg, vm) => {
         if (hasConsole && !config.silent) {
-            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
         }
     };
-    formatComponentName = function (vm, includeFile) {
+    formatComponentName = (vm, includeFile) => {
         if (vm.$root === vm) {
             return '<Root>';
         }
-        var options = 
-        // @ts-ignore
-        typeof vm === 'function' && vm.cid != null
-            ? // @ts-ignore
-                vm.options
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
             : vm._isVue
-                ? // @ts-ignore
-                    vm.$options || vm.constructor.options
+                ? vm.$options || vm.constructor.options
                 : vm;
-        var name = options.name || options._componentTag;
-        var file = options.__file;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
         if (!name && file) {
-            var match = file.match(/([^/\\]+)\.vue$/);
+            const match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
     };
-    var repeat$1 = function (str, n) {
-        var res = '';
+    const repeat = (str, n) => {
+        let res = '';
         while (n) {
             if (n % 2 === 1)
-                { res += str; }
+                res += str;
             if (n > 1)
-                { str += str; }
+                str += str;
             n >>= 1;
         }
         return res;
     };
-    generateComponentTrace = function (vm) {
-        // @ts-ignore
+    generateComponentTrace = (vm) => {
         if (vm._isVue && vm.$parent) {
-            var tree = [];
-            var currentRecursiveSequence = 0;
+            const tree = [];
+            let currentRecursiveSequence = 0;
             while (vm) {
                 if (tree.length > 0) {
-                    var last = tree[tree.length - 1];
+                    const last = tree[tree.length - 1];
                     if (last.constructor === vm.constructor) {
                         currentRecursiveSequence++;
                         vm = vm.$parent;
@@ -615,55 +601,60 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return `\n\n(found in ${formatComponentName(vm)})`;
         }
     };
 }
 
-var uid$2 = 0;
+let uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid$2++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove$2(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+    addSub(sub) {
+        this.subs.push(sub);
     }
-};
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-var targetStack = [];
+const targetStack = [];
 function pushTarget(target) {
     targetStack.push(target);
     Dep.target = target;
@@ -673,44 +664,66 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
-    var node = new VNode();
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
     node.text = text;
     node.isComment = true;
     return node;
@@ -723,9 +736,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    var cloned = new VNode(
-    //@ts-expect-error void type not valid here
-    vnode.tag, vnode.data, 
+    const cloned = new VNode(vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
@@ -746,29 +757,27 @@ function cloneVNode(vnode) {
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-var methodsToPatch = [
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
     'push',
     'pop',
     'shift',
     'unshift',
     'splice',
     'sort',
-    'reverse' ];
+    'reverse',
+];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
     // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
-
-        var result = original.apply(this, args);
-        var ob = this.__ob__;
-        var inserted;
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
         switch (method) {
             case 'push':
             case 'unshift':
@@ -779,19 +788,19 @@ methodsToPatch.forEach(function (method) {
                 break;
         }
         if (inserted)
-            { ob.observeArray(inserted); }
+            ob.observeArray(inserted);
         // notify change
         ob.dep.notify();
         return result;
     });
 });
 
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-var shouldObserve = true;
+let shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
@@ -801,43 +810,48 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
     }
-    else {
-        this.walk(value);
-    }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive(obj, keys[i]);
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
     }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
     }
-};
+}
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -854,8 +868,8 @@ function protoAugment(target, src) {
  */
 /* istanbul ignore next */
 function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-        var key = keys[i];
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
         def(target, key, src[key]);
     }
 }
@@ -868,7 +882,7 @@ function observe(value, asRootData) {
     if (!isObject(value) || value instanceof VNode) {
         return;
     }
-    var ob;
+    let ob;
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
@@ -888,23 +902,23 @@ function observe(value, asRootData) {
  * Define a reactive property on an Object.
  */
 function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
         return;
     }
     // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
+    const getter = property && property.get;
+    const setter = property && property.set;
     if ((!getter || setter) && arguments.length === 2) {
         val = obj[key];
     }
-    var childOb = !shallow && observe(val);
+    let childOb = !shallow && observe(val);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
         get: function reactiveGetter() {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             if (Dep.target) {
                 dep.depend();
                 if (childOb) {
@@ -917,7 +931,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             return value;
         },
         set: function reactiveSetter(newVal) {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             /* eslint-disable no-self-compare */
             if (newVal === value || (newVal !== newVal && value !== value)) {
                 return;
@@ -928,7 +942,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             }
             // #7981: for accessor properties without setter
             if (getter && !setter)
-                { return; }
+                return;
             if (setter) {
                 setter.call(obj, newVal);
             }
@@ -947,7 +961,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
  */
 function set(target, key, val) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -958,8 +972,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    var ob = target.__ob__;
-    // @ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
@@ -978,14 +991,13 @@ function set(target, key, val) {
  */
 function del(target, key) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
         return;
     }
-    var ob = target.__ob__;
-    //@ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                 '- just set it to null.');
@@ -1005,7 +1017,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1019,14 +1031,14 @@ function dependArray(value) {
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn$2("option \"" + key + "\" can only be used during instance " +
+            warn$2(`option "${key}" can only be used during instance ` +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1037,16 +1049,16 @@ var strats = config.optionMergeStrategies;
  */
 function mergeData(to, from) {
     if (!from)
-        { return to; }
-    var key, toVal, fromVal;
-    var keys = hasSymbol
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
         ? Reflect.ownKeys(from)
         : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
+    for (let i = 0; i < keys.length; i++) {
         key = keys[i];
         // in case the object is already observed...
         if (key === '__ob__')
-            { continue; }
+            continue;
         toVal = to[key];
         fromVal = from[key];
         if (!hasOwn(to, key)) {
@@ -1078,18 +1090,14 @@ function mergeDataOrFn(parentVal, childVal, vm) {
         // check if parentVal is a function here because
         // it has to be a function to pass previous merges.
         return function mergedDataFn() {
-            return mergeData(
-            // @ts-ignore
-            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-            // @ts-ignore
-            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
         };
     }
     else {
         return function mergedInstanceDataFn() {
             // instance merge
-            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
             if (instanceData) {
                 return mergeData(instanceData, defaultData);
             }
@@ -1115,7 +1123,7 @@ strats.data = function (parentVal, childVal, vm) {
  * Hooks and props are merged as arrays.
  */
 function mergeHook$1(parentVal, childVal) {
-    var res = childVal
+    const res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : Array.isArray(childVal)
@@ -1125,15 +1133,15 @@ function mergeHook$1(parentVal, childVal) {
     return res ? dedupeHooks(res) : res;
 }
 function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
         if (res.indexOf(hooks[i]) === -1) {
             res.push(hooks[i]);
         }
     }
     return res;
 }
-LIFECYCLE_HOOKS.forEach(function (hook) {
+LIFECYCLE_HOOKS.forEach((hook) => {
     strats[hook] = mergeHook$1;
 });
 /**
@@ -1144,7 +1152,7 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * options and parent options.
  */
 function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
+    const res = Object.create(parentVal || null);
     if (childVal) {
         assertObjectType(key, childVal, vm);
         return extend(res, childVal);
@@ -1166,27 +1174,27 @@ strats.watch = function (parentVal, childVal, vm, key) {
     // work around Firefox's Object.prototype.watch...
     //@ts-expect-error work around
     if (parentVal === nativeWatch)
-        { parentVal = undefined; }
+        parentVal = undefined;
     //@ts-expect-error work around
     if (childVal === nativeWatch)
-        { childVal = undefined; }
+        childVal = undefined;
     /* istanbul ignore if */
     if (!childVal)
-        { return Object.create(parentVal || null); }
+        return Object.create(parentVal || null);
     {
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = {};
+        return childVal;
+    const ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
         if (parent && !Array.isArray(parent)) {
             parent = [parent];
         }
-        ret[key$1] = parent
+        ret[key] = parent
             ? parent.concat(child)
             : Array.isArray(child)
                 ? child
@@ -1202,30 +1210,30 @@ strats.props = strats.methods = strats.inject = strats.computed = function (pare
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = Object.create(null);
+        return childVal;
+    const ret = Object.create(null);
     extend(ret, parentVal);
     if (childVal)
-        { extend(ret, childVal); }
+        extend(ret, childVal);
     return ret;
 };
 strats.provide = mergeDataOrFn;
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
+const defaultStrat = function (parentVal, childVal) {
     return childVal === undefined ? parentVal : childVal;
 };
 /**
  * Validate component names
  */
 function checkComponents(options) {
-    for (var key in options.components) {
+    for (const key in options.components) {
         validateComponentName(key);
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
         warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1242,11 +1250,11 @@ function validateComponentName(name) {
  * Object-based format.
  */
 function normalizeProps(options, vm) {
-    var props = options.props;
+    const props = options.props;
     if (!props)
-        { return; }
-    var res = {};
-    var i, val, name;
+        return;
+    const res = {};
+    let i, val, name;
     if (Array.isArray(props)) {
         i = props.length;
         while (i--) {
@@ -1261,15 +1269,15 @@ function normalizeProps(options, vm) {
         }
     }
     else if (isPlainObject(props)) {
-        for (var key in props) {
+        for (const key in props) {
             val = props[key];
             name = camelize(key);
             res[name] = isPlainObject(val) ? val : { type: val };
         }
     }
     else {
-        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
     }
     options.props = res;
 }
@@ -1277,36 +1285,36 @@ function normalizeProps(options, vm) {
  * Normalize all injections into Object-based format
  */
 function normalizeInject(options, vm) {
-    var inject = options.inject;
+    const inject = options.inject;
     if (!inject)
-        { return; }
-    var normalized = (options.inject = {});
+        return;
+    const normalized = (options.inject = {});
     if (Array.isArray(inject)) {
-        for (var i = 0; i < inject.length; i++) {
+        for (let i = 0; i < inject.length; i++) {
             normalized[inject[i]] = { from: inject[i] };
         }
     }
     else if (isPlainObject(inject)) {
-        for (var key in inject) {
-            var val = inject[key];
+        for (const key in inject) {
+            const val = inject[key];
             normalized[key] = isPlainObject(val)
                 ? extend({ from: key }, val)
                 : { from: val };
         }
     }
     else {
-        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
 function normalizeDirectives$1(options) {
-    var dirs = options.directives;
+    const dirs = options.directives;
     if (dirs) {
-        for (var key in dirs) {
-            var def = dirs[key];
+        for (const key in dirs) {
+            const def = dirs[key];
             if (typeof def === 'function') {
                 dirs[key] = { bind: def, update: def };
             }
@@ -1315,8 +1323,8 @@ function normalizeDirectives$1(options) {
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
     }
 }
 /**
@@ -1343,13 +1351,13 @@ function mergeOptions(parent, child, vm) {
             parent = mergeOptions(parent, child.extends, vm);
         }
         if (child.mixins) {
-            for (var i = 0, l = child.mixins.length; i < l; i++) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
                 parent = mergeOptions(parent, child.mixins[i], vm);
             }
         }
     }
-    var options = {};
-    var key;
+    const options = {};
+    let key;
     for (key in parent) {
         mergeField(key);
     }
@@ -1359,7 +1367,7 @@ function mergeOptions(parent, child, vm) {
         }
     }
     function mergeField(key) {
-        var strat = strats[key] || defaultStrat;
+        const strat = strats[key] || defaultStrat;
         options[key] = strat(parent[key], child[key], vm, key);
     }
     return options;
@@ -1374,18 +1382,18 @@ function resolveAsset(options, type, id, warnMissing) {
     if (typeof id !== 'string') {
         return;
     }
-    var assets = options[type];
+    const assets = options[type];
     // check local registration variations first
     if (hasOwn(assets, id))
-        { return assets[id]; }
-    var camelizedId = camelize(id);
+        return assets[id];
+    const camelizedId = camelize(id);
     if (hasOwn(assets, camelizedId))
-        { return assets[camelizedId]; }
-    var PascalCaseId = capitalize(camelizedId);
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
     if (hasOwn(assets, PascalCaseId))
-        { return assets[PascalCaseId]; }
+        return assets[PascalCaseId];
     // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (warnMissing && !res) {
         warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
@@ -1393,11 +1401,11 @@ function resolveAsset(options, type, id, warnMissing) {
 }
 
 function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
     // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
     if (booleanIndex > -1) {
         if (absent && !hasOwn(prop, 'default')) {
             value = false;
@@ -1405,7 +1413,7 @@ function validateProp(key, propOptions, propsData, vm) {
         else if (value === '' || value === hyphenate(key)) {
             // only cast empty string / same name to boolean if
             // boolean has higher priority
-            var stringIndex = getTypeIndex(String, prop.type);
+            const stringIndex = getTypeIndex(String, prop.type);
             if (stringIndex < 0 || booleanIndex < stringIndex) {
                 value = true;
             }
@@ -1416,7 +1424,7 @@ function validateProp(key, propOptions, propsData, vm) {
         value = getPropDefaultValue(vm, prop, key);
         // since the default value is a fresh copy,
         // make sure to observe it.
-        var prevShouldObserve = shouldObserve;
+        const prevShouldObserve = shouldObserve;
         toggleObserving(true);
         observe(value);
         toggleObserving(prevShouldObserve);
@@ -1434,7 +1442,7 @@ function getPropDefaultValue(vm, prop, key) {
     if (!hasOwn(prop, 'default')) {
         return undefined;
     }
-    var def = prop.default;
+    const def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (isObject(def)) {
         warn$2('Invalid default value for prop "' +
@@ -1468,38 +1476,37 @@ function assertProp(prop, name, value, vm, absent) {
     if (value == null && !prop.required) {
         return;
     }
-    var type = prop.type;
-    // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
     if (type) {
         if (!Array.isArray(type)) {
             type = [type];
         }
-        for (var i = 0; i < type.length && !valid; i++) {
-            var assertedType = assertType(value, type[i], vm);
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
             expectedTypes.push(assertedType.expectedType || '');
             valid = assertedType.valid;
         }
     }
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    const haveExpectedTypes = expectedTypes.some((t) => t);
     if (!valid && haveExpectedTypes) {
         warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
-    var validator = prop.validator;
+    const validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
             warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
 function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
+    let valid;
+    const expectedType = getType(type);
     if (simpleCheckRE.test(expectedType)) {
-        var t = typeof value;
+        const t = typeof value;
         valid = t === expectedType.toLowerCase();
         // for primitive wrapper objects
         if (!valid && t === 'object') {
@@ -1522,18 +1529,18 @@ function assertType(value, type, vm) {
         }
     }
     return {
-        valid: valid,
-        expectedType: expectedType,
+        valid,
+        expectedType,
     };
 }
-var functionTypeCheckRE = /^\s*function (\w+)/;
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
 function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
+    const match = fn && fn.toString().match(functionTypeCheckRE);
     return match ? match[1] : '';
 }
 function isSameType(a, b) {
@@ -1543,7 +1550,7 @@ function getTypeIndex(type, expectedTypes) {
     if (!Array.isArray(expectedTypes)) {
         return isSameType(expectedTypes, type) ? 0 : -1;
     }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
         if (isSameType(expectedTypes[i], type)) {
             return i;
         }
@@ -1551,44 +1558,41 @@ function getTypeIndex(type, expectedTypes) {
     return -1;
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
     // check if we need to specify expected value
     if (expectedTypes.length === 1 &&
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += ` with value ${styleValue(value, expectedType)}`;
     }
-    message += ", got " + receivedType + " ";
+    message += `, got ${receivedType} `;
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += `with value ${styleValue(value, receivedType)}.`;
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return `"${value}"`;
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return `${Number(value)}`;
     }
     else {
-        return ("" + value);
+        return `${value}`;
     }
 }
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
 function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
 }
-function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
 function handleError(err, vm, info) {
@@ -1597,15 +1601,15 @@ function handleError(err, vm, info) {
     pushTarget();
     try {
         if (vm) {
-            var cur = vm;
+            let cur = vm;
             while ((cur = cur.$parent)) {
-                var hooks = cur.$options.errorCaptured;
+                const hooks = cur.$options.errorCaptured;
                 if (hooks) {
-                    for (var i = 0; i < hooks.length; i++) {
+                    for (let i = 0; i < hooks.length; i++) {
                         try {
-                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
                             if (capture)
-                                { return; }
+                                return;
                         }
                         catch (e) {
                             globalHandleError(e, cur, 'errorCaptured hook');
@@ -1621,17 +1625,18 @@ function handleError(err, vm, info) {
     }
 }
 function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
+    let res;
     try {
         res = args ? handler.apply(context, args) : handler.call(context);
         if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
             // issue #9511
             // avoid catch triggering multiple times when nested calls
             res._handled = true;
         }
     }
     catch (e) {
+        // @ts-expect-error should it be any?
         handleError(e, vm, info);
     }
     return res;
@@ -1653,7 +1658,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1665,14 +1670,14 @@ function logError(err, vm, info) {
 }
 
 /* globals MutationObserver */
-var isUsingMicroTask = false;
-var callbacks = [];
-var pending = false;
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
 function flushCallbacks() {
     pending = false;
-    var copies = callbacks.slice(0);
+    const copies = callbacks.slice(0);
     callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
+    for (let i = 0; i < copies.length; i++) {
         copies[i]();
     }
 }
@@ -1687,7 +1692,7 @@ function flushCallbacks() {
 // where microtasks have too high a priority and fire in between supposedly
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
-var timerFunc;
+let timerFunc;
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1696,8 +1701,8 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
+    const p = Promise.resolve();
+    timerFunc = () => {
         p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
@@ -1705,7 +1710,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
         // needs to do some other work, e.g. handle a timer. Therefore we can
         // "force" the microtask queue to be flushed by adding an empty timer.
         if (isIOS)
-            { setTimeout(noop); }
+            setTimeout(noop);
     };
     isUsingMicroTask = true;
 }
@@ -1717,13 +1722,13 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
     observer.observe(textNode, {
         characterData: true,
     });
-    timerFunc = function () {
+    timerFunc = () => {
         counter = (counter + 1) % 2;
         textNode.data = String(counter);
     };
@@ -1733,24 +1738,25 @@ else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
     // Fallback to setImmediate.
     // Technically it leverages the (macro) task queue,
     // but it is still a better choice than setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setImmediate(flushCallbacks);
     };
 }
 else {
     // Fallback to setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setTimeout(flushCallbacks, 0);
     };
 }
 function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
+    let _resolve;
+    callbacks.push(() => {
         if (cb) {
             try {
                 cb.call(ctx);
             }
             catch (e) {
+                // @ts-expect-error should it be any?
                 handleError(e, ctx, 'nextTick');
             }
         }
@@ -1764,24 +1770,24 @@ function nextTick(cb, ctx) {
     }
     // $flow-disable-line
     if (!cb && typeof Promise !== 'undefined') {
-        return new Promise(function (resolve) {
+        return new Promise((resolve) => {
             _resolve = resolve;
         });
     }
 }
 
-var mark;
-var measure;
+let mark;
+let measure;
 {
-    var perf = inBrowser && window.performance;
+    const perf = inBrowser && window.performance;
     /* istanbul ignore if */
     if (perf &&
         perf.mark &&
         perf.measure &&
         perf.clearMarks &&
         perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
-        measure = function (name, startTag, endTag) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
             perf.measure(name, startTag, endTag);
             perf.clearMarks(startTag);
             perf.clearMarks(endTag);
@@ -1791,33 +1797,33 @@ var measure;
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-var initProxy;
+let initProxy;
 {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
-        warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
+    const warnNonPresent = (target, key) => {
+        warn$2(`Property or method "${key}" is not defined on the instance but ` +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
-        warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    const warnReservedPrefix = (target, key) => {
+        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
+            set(target, key, value) {
                 if (isBuiltInModifier(key)) {
-                    warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                     return false;
                 }
                 else {
@@ -1827,29 +1833,29 @@ var initProxy;
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
-            var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    const getHandler = {
+        get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return target[key];
         },
@@ -1857,8 +1863,8 @@ var initProxy;
     initProxy = function initProxy(vm) {
         if (hasProxy) {
             // determine which proxy handler to use
-            var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1867,7 +1873,7 @@ var initProxy;
     };
 }
 
-var seenObjects = new _Set();
+const seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
@@ -1878,15 +1884,15 @@ function traverse(val) {
     seenObjects.clear();
 }
 function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
+    let i, keys;
+    const isA = Array.isArray(val);
     if ((!isA && !isObject(val)) ||
         Object.isFrozen(val) ||
         val instanceof VNode) {
         return;
     }
     if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
+        const depId = val.__ob__.dep.id;
         if (seen.has(depId)) {
             return;
         }
@@ -1895,57 +1901,55 @@ function _traverse(val, seen) {
     if (isA) {
         i = val.length;
         while (i--)
-            { _traverse(val[i], seen); }
+            _traverse(val[i], seen);
     }
     else {
         keys = Object.keys(val);
         i = keys.length;
         while (i--)
-            { _traverse(val[keys[i]], seen); }
+            _traverse(val[keys[i]], seen);
     }
 }
 
-var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
     name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
+    const capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
-        name: name,
-        once: once,
-        capture: capture,
-        passive: passive,
+        name,
+        once,
+        capture,
+        passive,
     };
 });
 function createFnInvoker(fns, vm) {
     function invoker() {
-        var arguments$1 = arguments;
-
-        var fns = invoker.fns;
+        const fns = invoker.fns;
         if (Array.isArray(fns)) {
-            var cloned = fns.slice();
-            for (var i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
             }
         }
         else {
             // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
         }
     }
     invoker.fns = fns;
     return invoker;
 }
 function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, cur, old, event;
+    let name, cur, old, event;
     for (name in on) {
         cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1973,8 +1977,8 @@ function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
     }
-    var invoker;
-    var oldHook = def[hookKey];
+    let invoker;
+    const oldHook = def[hookKey];
     function wrappedHook() {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
@@ -2005,27 +2009,26 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
     // component itself.
-    var propOptions = Ctor.options.props;
+    const propOptions = Ctor.options.props;
     if (isUndef(propOptions)) {
         return;
     }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    const res = {};
+    const { attrs, props } = data;
     if (isDef(attrs) || isDef(props)) {
-        for (var key in propOptions) {
-            var altKey = hyphenate(key);
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
             {
-                var keyInLowerCase = key.toLowerCase();
+                const keyInLowerCase = key.toLowerCase();
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                        (formatComponentName(
-                        // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
-                        "Note that HTML attributes are case-insensitive and camelCased " +
-                        "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2066,7 +2069,7 @@ function checkProp(res, hash, key, altKey, preserve) {
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
 function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
+    for (let i = 0; i < children.length; i++) {
         if (Array.isArray(children[i])) {
             return Array.prototype.concat.apply([], children);
         }
@@ -2088,18 +2091,18 @@ function isTextNode(node) {
     return isDef(node) && isDef(node.text) && isFalse(node.isComment);
 }
 function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
+    const res = [];
+    let i, c, lastIndex, last;
     for (i = 0; i < children.length; i++) {
         c = children[i];
         if (isUndef(c) || typeof c === 'boolean')
-            { continue; }
+            continue;
         lastIndex = res.length - 1;
         last = res[lastIndex];
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2131,7 +2134,7 @@ function normalizeArrayChildren(children, nestedIndex) {
                     isDef(c.tag) &&
                     isUndef(c.key) &&
                     isDef(nestedIndex)) {
-                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                    c.key = `__vlist${nestedIndex}_${i}__`;
                 }
                 res.push(c);
             }
@@ -2141,7 +2144,7 @@ function normalizeArrayChildren(children, nestedIndex) {
 }
 
 function initProvide(vm) {
-    var provide = vm.$options.provide;
+    const provide = vm.$options.provide;
     if (provide) {
         vm._provided =
             typeof provide === 'function'
@@ -2151,16 +2154,16 @@ function initProvide(vm) {
     }
 }
 function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
+    const result = resolveInject(vm.$options.inject, vm);
     if (result) {
         toggleObserving(false);
-        Object.keys(result).forEach(function (key) {
+        Object.keys(result).forEach((key) => {
             /* istanbul ignore else */
             {
-                defineReactive(vm, key, result[key], function () {
-                    warn$2("Avoid mutating an injected value directly since the changes will be " +
-                        "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                defineReactive(vm, key, result[key], () => {
+                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
                 });
             }
         });
@@ -2170,15 +2173,15 @@ function initInjections(vm) {
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
-        var result = Object.create(null);
-        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (var i = 0; i < keys.length; i++) {
-            var key = keys[i];
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             // #6574 in case the inject object is observed...
             if (key === '__ob__')
-                { continue; }
-            var provideKey = inject[key].from;
-            var source = vm;
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
             while (source) {
                 if (source._provided && hasOwn(source._provided, provideKey)) {
                     result[key] = source._provided[provideKey];
@@ -2189,15 +2192,14 @@ function resolveInject(inject, vm) {
             }
             if (!source) {
                 if ('default' in inject[key]) {
-                    var provideDefault = inject[key].default;
+                    const provideDefault = inject[key].default;
                     result[key] =
                         typeof provideDefault === 'function'
                             ? provideDefault.call(vm)
                             : provideDefault;
                 }
                 else {
-                    // @ts-ignore
-                    warn$2(("Injection \"" + key + "\" not found"), vm);
+                    warn$2(`Injection "${key}" not found`, vm);
                 }
             }
         }
@@ -2212,10 +2214,10 @@ function resolveSlots(children, context) {
     if (!children || !children.length) {
         return {};
     }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var data = child.data;
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
         // remove slot attribute if the node is resolved as a Vue slot node
         if (data && data.attrs && data.attrs.slot) {
             delete data.attrs.slot;
@@ -2225,8 +2227,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2239,9 +2241,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
         }
     }
     return slots;
@@ -2250,11 +2252,16 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
+}
+
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
     if (!slots) {
         res = {};
     }
@@ -2274,16 +2281,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2291,19 +2298,22 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     if (slots && Object.isExtensible(slots)) {
         slots._normalized = res;
     }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
-            res && typeof res === 'object' && !Array.isArray(res)
+            res && typeof res === "object" && !Array.isArray(res)
                 ? [res] // single vnode
                 : normalizeChildren(res);
-        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
             ? undefined
             : res;
     };
@@ -2320,14 +2330,14 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     return normalized;
 }
 function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; };
+    return () => slots[key];
 }
 
 /**
  * Runtime helper for rendering v-for lists.
  */
 function renderList(val, render) {
-    var ret = null, i, l, keys, key;
+    let ret = null, i, l, keys, key;
     if (Array.isArray(val) || typeof val === 'string') {
         ret = new Array(val.length);
         for (i = 0, l = val.length; i < l; i++) {
@@ -2343,8 +2353,8 @@ function renderList(val, render) {
     else if (isObject(val)) {
         if (hasSymbol && val[Symbol.iterator]) {
             ret = [];
-            var iterator = val[Symbol.iterator]();
-            var result = iterator.next();
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
             while (!result.done) {
                 ret.push(render(result.value, ret.length));
                 result = iterator.next();
@@ -2369,26 +2379,34 @@ function renderList(val, render) {
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
     if (scopedSlotFn) {
         // scoped slot
         props = props || {};
         if (bindObject) {
             if (!isObject(bindObject)) {
-                warn$2('slot v-bind without argument expects an Object', this);
+                warn$2("slot v-bind without argument expects an Object", this);
             }
             props = extend(extend({}, bindObject), props);
         }
-        nodes = scopedSlotFn(props) || fallback;
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
     else {
-        nodes = this.$slots[name] || fallback;
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
-    var target = props && props.slot;
+    const target = props && props.slot;
     if (target) {
-        return this.$createElement('template', { slot: target }, nodes);
+        return this.$createElement("template", { slot: target }, nodes);
     }
     else {
         return nodes;
@@ -2416,7 +2434,7 @@ function isKeyNotMatch(expect, actual) {
  * passing in eventKeyName as last argument separately for backwards compat
  */
 function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
     if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
         return isKeyNotMatch(builtInKeyName, eventKeyName);
     }
@@ -2426,6 +2444,7 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     else if (eventKeyName) {
         return hyphenate(eventKeyName) !== key;
     }
+    return eventKeyCode === undefined;
 }
 
 /**
@@ -2440,32 +2459,30 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            let hash;
+            for (const key in value) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
                 else {
-                    var type = data.attrs && data.attrs.type;
+                    const type = data.attrs && data.attrs.type;
                     hash =
                         asProp || config.mustUseProp(tag, type, key)
                             ? data.domProps || (data.domProps = {})
                             : data.attrs || (data.attrs = {});
                 }
-                var camelizedKey = camelize(key);
-                var hyphenatedKey = hyphenate(key);
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
                 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                     hash[key] = value[key];
                     if (isSync) {
-                        var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
-            };
-
-            for (var key in value) loop( key );
+            }
         }
     }
     return data;
@@ -2475,8 +2492,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
  * Runtime helper for rendering static trees.
  */
 function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
     // if has already-rendered static tree and not inside v-for,
     // we can reuse the same tree.
     if (tree && !isInFor) {
@@ -2485,7 +2502,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic$1(tree, ("__static__" + index), false);
+    markStatic$1(tree, `__static__${index}`, false);
     return tree;
 }
 /**
@@ -2493,14 +2510,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic$1(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
     return tree;
 }
 function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
-        for (var i = 0; i < tree.length; i++) {
+        for (let i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
             }
         }
     }
@@ -2520,10 +2537,10 @@ function bindObjectListeners(data, value) {
             warn$2('v-on without argument expects an Object value', this);
         }
         else {
-            var on = (data.on = data.on ? extend({}, data.on) : {});
-            for (var key in value) {
-                var existing = on[key];
-                var ours = value[key];
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
                 on[key] = existing ? [].concat(existing, ours) : ours;
             }
         }
@@ -2535,8 +2552,8 @@ function resolveScopedSlots(fns, res,
 // the following are added in 2.6
 hasDynamicKeys, contentHashKey) {
     res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-        var slot = fns[i];
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
         if (Array.isArray(slot)) {
             resolveScopedSlots(slot, res, hasDynamicKeys);
         }
@@ -2558,15 +2575,15 @@ hasDynamicKeys, contentHashKey) {
 
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-        var key = values[i];
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
         if (typeof key === 'string' && key) {
             baseObj[values[i]] = values[i + 1];
         }
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
         }
     }
     return baseObj;
@@ -2599,12 +2616,10 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
-    var options = Ctor.options;
+    const options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
+    let contextVm;
     if (hasOwn(parent, '_uid')) {
         contextVm = Object.create(parent);
         // $flow-disable-line
@@ -2618,23 +2633,23 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         // $flow-disable-line
         parent = parent._original;
     }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
     this.data = data;
     this.props = props;
     this.children = children;
     this.parent = parent;
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2647,8 +2662,8 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
     }
     if (options._scopeId) {
-        this._c = function (a, b, c, d) {
-            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2657,34 +2672,34 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
 function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
     if (isDef(propOptions)) {
-        for (var key in propOptions) {
+        for (const key in propOptions) {
             props[key] = validateProp(key, propOptions, propsData || emptyObject);
         }
     }
     else {
         if (isDef(data.attrs))
-            { mergeProps(props, data.attrs); }
+            mergeProps(props, data.attrs);
         if (isDef(data.props))
-            { mergeProps(props, data.props); }
+            mergeProps(props, data.props);
     }
-    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    var vnode = options.render.call(null, renderContext._c, renderContext);
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
     if (vnode instanceof VNode) {
         return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
     }
     else if (Array.isArray(vnode)) {
-        var vnodes = normalizeChildren(vnode) || [];
-        var res = new Array(vnodes.length);
-        for (var i = 0; i < vnodes.length; i++) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
             res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
         }
         return res;
@@ -2694,7 +2709,7 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     // #7817 clone node before setting fnContext, otherwise if the node is reused
     // (e.g. it was from a cached normal slot) the fnContext causes named slots
     // that should not be matched to match.
-    var clone = cloneVNode(vnode);
+    const clone = cloneVNode(vnode);
     clone.fnContext = contextVm;
     clone.fnOptions = options;
     {
@@ -2706,38 +2721,37 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     return clone;
 }
 function mergeProps(to, from) {
-    for (var key in from) {
+    for (const key in from) {
         to[camelize(key)] = from[key];
     }
 }
 
 // inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
             // kept-alive components, treat as a patch
-            var mountedNode = vnode; // work around flow
+            const mountedNode = vnode; // work around flow
             componentVNodeHooks.prepatch(mountedNode, mountedNode);
         }
         else {
-            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
-        var options = vnode.componentOptions;
-        var child = (vnode.componentInstance = oldVnode.componentInstance);
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
         options.listeners, // updated listeners
         vnode, // new parent vnode
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2756,8 +2770,8 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
-        var componentInstance = vnode.componentInstance;
+    destroy(vnode) {
+        const { componentInstance } = vnode;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
                 componentInstance.$destroy();
@@ -2768,12 +2782,12 @@ var componentVNodeHooks = {
         }
     },
 };
-var hooksToMerge = Object.keys(componentVNodeHooks);
+const hooksToMerge = Object.keys(componentVNodeHooks);
 function createComponent(Ctor, data, context, children, tag) {
     if (isUndef(Ctor)) {
         return;
     }
-    var baseCtor = context.$options._base;
+    const baseCtor = context.$options._base;
     // plain options object: turn it into a constructor
     if (isObject(Ctor)) {
         Ctor = baseCtor.extend(Ctor);
@@ -2782,12 +2796,12 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn$2(("Invalid Component definition: " + (String(Ctor))), context);
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
         }
         return;
     }
     // async component
-    var asyncFactory;
+    let asyncFactory;
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
@@ -2810,7 +2824,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract props
     // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
     // functional component
     // @ts-expect-error
     if (isTrue(Ctor.options.functional)) {
@@ -2818,7 +2832,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract listeners, since these needs to be treated as
     // child component listeners instead of DOM listeners
-    var listeners = data.on;
+    const listeners = data.on;
     // replace with listeners with .native modifier
     // so it gets processed during parent component patch.
     data.on = data.nativeOn;
@@ -2827,7 +2841,7 @@ function createComponent(Ctor, data, context, children, tag) {
         // abstract components do not keep anything
         // other than props & listeners & slot
         // work around flow
-        var slot = data.slot;
+        const slot = data.slot;
         data = {};
         if (slot) {
             data.slot = slot;
@@ -2837,12 +2851,12 @@ function createComponent(Ctor, data, context, children, tag) {
     installComponentHooks(data);
     // return a placeholder vnode
     // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
     // @ts-expect-error
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
     return vnode;
 }
 function createComponentInstanceForVnode(
@@ -2850,13 +2864,13 @@ function createComponentInstanceForVnode(
 vnode, 
 // activeInstance in lifecycle state
 parent) {
-    var options = {
+    const options = {
         _isComponent: true,
         _parentVnode: vnode,
-        parent: parent,
+        parent,
     };
     // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
+    const inlineTemplate = vnode.data.inlineTemplate;
     if (isDef(inlineTemplate)) {
         options.render = inlineTemplate.render;
         options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2864,11 +2878,11 @@ parent) {
     return new vnode.componentOptions.Ctor(options);
 }
 function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-        var key = hooksToMerge[i];
-        var existing = hooks[key];
-        var toMerge = componentVNodeHooks[key];
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
             hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2876,7 +2890,7 @@ function installComponentHooks(data) {
     }
 }
 function mergeHook(f1, f2) {
-    var merged = function (a, b) {
+    const merged = (a, b) => {
         // flow complains about extra args which is why we use any
         f1(a, b);
         f2(a, b);
@@ -2887,12 +2901,12 @@ function mergeHook(f1, f2) {
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
 function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input';
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
     (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
     if (isDef(existing)) {
         if (Array.isArray(existing)
             ? existing.indexOf(callback) === -1
@@ -2905,8 +2919,8 @@ function transformModel(options, data) {
     }
 }
 
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
 function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2922,7 +2936,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2955,16 +2969,16 @@ function _createElement(context, tag, data, children, normalizationType) {
     else if (normalizationType === SIMPLE_NORMALIZE) {
         children = simpleNormalizeChildren(children);
     }
-    var vnode, ns;
+    let vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        let Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn$2(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -2989,9 +3003,9 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     else if (isDef(vnode)) {
         if (isDef(ns))
-            { applyNS(vnode, ns); }
+            applyNS(vnode, ns);
         if (isDef(data))
-            { registerDeepBindings(data); }
+            registerDeepBindings(data);
         return vnode;
     }
     else {
@@ -3006,8 +3020,8 @@ function applyNS(vnode, ns, force) {
         force = true;
     }
     if (isDef(vnode.children)) {
-        for (var i = 0, l = vnode.children.length; i < l; i++) {
-            var child = vnode.children[i];
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
             if (isDef(child.tag) &&
                 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                 applyNS(child, ns, force);
@@ -3030,9 +3044,9 @@ function registerDeepBindings(data) {
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
     vm.$slots = resolveSlots(options._renderChildren, renderContext);
     vm.$scopedSlots = emptyObject;
     // bind the createElement fn to this instance
@@ -3040,25 +3054,25 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
+    const parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
         }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
         }, true);
     }
 }
-var currentRenderingInstance = null;
+let currentRenderingInstance = null;
 function renderMixin(Vue) {
     // install runtime convenience helpers
     installRenderHelpers(Vue.prototype);
@@ -3066,10 +3080,8 @@ function renderMixin(Vue) {
         return nextTick(fn, this);
     };
     Vue.prototype._render = function () {
-        var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3077,7 +3089,7 @@ function renderMixin(Vue) {
         // to the data on the placeholder node.
         vm.$vnode = _parentVnode;
         // render self
-        var vnode;
+        let vnode;
         try {
             // There's no need to maintain a stack because all render fns are called
             // separately from one another. Nested component's render fns are called
@@ -3086,7 +3098,7 @@ function renderMixin(Vue) {
             vnode = render.call(vm._renderProxy, vm.$createElement);
         }
         catch (e) {
-            handleError(e, vm, "render");
+            handleError(e, vm, `render`);
             // return error render result,
             // or previous vnode to prevent render error causing blank component
             /* istanbul ignore else */
@@ -3094,8 +3106,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e$1) {
-                    handleError(e$1, vm, "renderError");
+                catch (e) {
+                    handleError(e, vm, `renderError`);
                     vnode = vm._vnode;
                 }
             }
@@ -3131,9 +3143,9 @@ function ensureCtor(comp, base) {
     return isObject(comp) ? base.extend(comp) : comp;
 }
 function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
+    const node = createEmptyVNode();
     node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    node.asyncMeta = { data, context, children, tag };
     return node;
 }
 function resolveAsyncComponent(factory, baseCtor) {
@@ -3143,7 +3155,7 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    var owner = currentRenderingInstance;
+    const owner = currentRenderingInstance;
     if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
         // already pending
         factory.owners.push(owner);
@@ -3152,13 +3164,13 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
                 owners[i].$forceUpdate();
             }
             if (renderCompleted) {
@@ -3173,7 +3185,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
             }
         };
-        var resolve = once(function (res) {
+        const resolve = once((res) => {
             // cache resolved
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
@@ -3185,15 +3197,15 @@ function resolveAsyncComponent(factory, baseCtor) {
                 owners.length = 0;
             }
         });
-        var reject = once(function (reason) {
-            warn$2("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+        const reject = once((reason) => {
+            warn$2(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
                 forceRender(true);
             }
         });
-        var res = factory(resolve, reject);
+        const res = factory(resolve, reject);
         if (isObject(res)) {
             if (isPromise(res)) {
                 // () => Promise
@@ -3213,7 +3225,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
+                        timerLoading = setTimeout(() => {
                             timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
@@ -3224,10 +3236,10 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
                 if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
+                    timerTimeout = setTimeout(() => {
                         timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject(("timeout (" + (res.timeout) + "ms)")
+                            reject(`timeout (${res.timeout}ms)`
                                 );
                         }
                     }, res.timeout);
@@ -3240,15 +3252,10 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-            var c = children[i];
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
             if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                 return c;
             }
@@ -3260,12 +3267,12 @@ function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
     // init parent attached events
-    var listeners = vm.$options._parentListeners;
+    const listeners = vm.$options._parentListeners;
     if (listeners) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target$1;
+let target$1;
 function add$1(event, fn) {
     target$1.$on(event, fn);
 }
@@ -3273,9 +3280,9 @@ function remove$1(event, fn) {
     target$1.$off(event, fn);
 }
 function createOnceHandler$1(event, fn) {
-    var _target = target$1;
+    const _target = target$1;
     return function onceHandler() {
-        var res = fn.apply(null, arguments);
+        const res = fn.apply(null, arguments);
         if (res !== null) {
             _target.$off(event, onceHandler);
         }
@@ -3287,11 +3294,11 @@ function updateComponentListeners(vm, listeners, oldListeners) {
     target$1 = undefined;
 }
 function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
+    const hookRE = /^hook:/;
     Vue.prototype.$on = function (event, fn) {
-        var vm = this;
+        const vm = this;
         if (Array.isArray(event)) {
-            for (var i = 0, l = event.length; i < l; i++) {
+            for (let i = 0, l = event.length; i < l; i++) {
                 vm.$on(event[i], fn);
             }
         }
@@ -3306,7 +3313,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$once = function (event, fn) {
-        var vm = this;
+        const vm = this;
         function on() {
             vm.$off(event, on);
             fn.apply(vm, arguments);
@@ -3316,7 +3323,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$off = function (event, fn) {
-        var vm = this;
+        const vm = this;
         // all
         if (!arguments.length) {
             vm._events = Object.create(null);
@@ -3324,13 +3331,13 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
             }
             return vm;
         }
         // specific event
-        var cbs = vm._events[event];
+        const cbs = vm._events[event];
         if (!cbs) {
             return vm;
         }
@@ -3339,8 +3346,8 @@ function eventsMixin(Vue) {
             return vm;
         }
         // specific handler
-        var cb;
-        var i = cbs.length;
+        let cb;
+        let i = cbs.length;
         while (i--) {
             cb = cbs[i];
             if (cb === fn || cb.fn === fn) {
@@ -3351,23 +3358,23 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$emit = function (event) {
-        var vm = this;
+        const vm = this;
         {
-            var lowerCaseEvent = event.toLowerCase();
+            const lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                    "Note that HTML attributes are case-insensitive and you cannot use " +
-                    "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
             }
         }
-        var cbs = vm._events[event];
+        let cbs = vm._events[event];
         if (cbs) {
             cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            var args = toArray(arguments, 1);
-            var info = "event handler for \"" + event + "\"";
-            for (var i = 0, l = cbs.length; i < l; i++) {
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
                 invokeWithErrorHandling(cbs[i], vm, args, vm, info);
             }
         }
@@ -3375,19 +3382,19 @@ function eventsMixin(Vue) {
     };
 }
 
-var activeInstance = null;
-var isUpdatingChildComponent = false;
+let activeInstance = null;
+let isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
+    const prevActiveInstance = activeInstance;
     activeInstance = vm;
-    return function () {
+    return () => {
         activeInstance = prevActiveInstance;
     };
 }
 function initLifecycle(vm) {
-    var options = vm.$options;
+    const options = vm.$options;
     // locate first non-abstract parent
-    var parent = options.parent;
+    let parent = options.parent;
     if (parent && !options.abstract) {
         while (parent.$options.abstract && parent.$parent) {
             parent = parent.$parent;
@@ -3398,7 +3405,6 @@ function initLifecycle(vm) {
     vm.$root = parent ? parent.$root : vm;
     vm.$children = [];
     vm.$refs = {};
-    // @ts-ignore
     vm._watcher = null;
     vm._inactive = null;
     vm._directInactive = false;
@@ -3408,10 +3414,10 @@ function initLifecycle(vm) {
 }
 function lifecycleMixin(Vue) {
     Vue.prototype._update = function (vnode, hydrating) {
-        var vm = this;
-        var prevEl = vm.$el;
-        var prevVnode = vm._vnode;
-        var restoreActiveInstance = setActiveInstance(vm);
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
         vm._vnode = vnode;
         // Vue.prototype.__patch__ is injected in entry points
         // based on the rendering backend used.
@@ -3439,21 +3445,20 @@ function lifecycleMixin(Vue) {
         // updated in a parent's updated hook.
     };
     Vue.prototype.$forceUpdate = function () {
-        var vm = this;
+        const vm = this;
         if (vm._watcher) {
             vm._watcher.update();
         }
     };
     Vue.prototype.$destroy = function () {
-        var vm = this;
+        const vm = this;
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook$1(vm, 'beforeDestroy');
+        callHook$1(vm, "beforeDestroy");
         vm._isBeingDestroyed = true;
         // remove self from parent
-        var parent = vm.$parent;
-        // @ts-ignore
+        const parent = vm.$parent;
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
             remove$2(parent.$children, vm);
         }
@@ -3461,7 +3466,7 @@ function lifecycleMixin(Vue) {
         if (vm._watcher) {
             vm._watcher.teardown();
         }
-        var i = vm._watchers.length;
+        let i = vm._watchers.length;
         while (i--) {
             vm._watchers[i].teardown();
         }
@@ -3475,7 +3480,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook$1(vm, 'destroyed');
+        callHook$1(vm, "destroyed");
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3484,7 +3489,6 @@ function lifecycleMixin(Vue) {
         }
         // release circular reference (#6759)
         if (vm.$vnode) {
-            // @ts-expect-error null is not undefined
             vm.$vnode.parent = null;
         }
     };
@@ -3496,39 +3500,39 @@ function mountComponent(vm, el, hydrating) {
         vm.$options.render = createEmptyVNode;
         {
             /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                 vm.$options.el ||
                 el) {
-                warn$2('You are using the runtime-only build of Vue where the template ' +
-                    'compiler is not available. Either pre-compile the templates into ' +
-                    'render functions, or use the compiler-included build.', vm);
+                warn$2("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
             }
             else {
-                warn$2('Failed to mount component: template or render function not defined.', vm);
+                warn$2("Failed to mount component: template or render function not defined.", vm);
             }
         }
     }
-    callHook$1(vm, 'beforeMount');
-    var updateComponent;
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
-        updateComponent = function () {
-            var name = vm._name;
-            var id = vm._uid;
-            var startTag = "vue-perf-start:" + id;
-            var endTag = "vue-perf-end:" + id;
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
             mark(startTag);
-            var vnode = vm._render();
+            const vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure(`vue ${name} render`, startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
         };
     }
     else {
-        updateComponent = function () {
+        updateComponent = () => {
             vm._update(vm._render(), hydrating);
         };
     }
@@ -3536,9 +3540,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before() {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, 'beforeUpdate');
+                callHook$1(vm, "beforeUpdate");
             }
         },
     }, true /* isRenderWatcher */);
@@ -3547,7 +3551,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook$1(vm, 'mounted');
+        callHook$1(vm, "mounted");
     }
     return vm;
 }
@@ -3560,24 +3564,22 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // check if there are dynamic scopedSlots (hand-written or compiled but with
     // dynamic slot names). Static scoped slots compiled from template has the
     // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(renderChildren || // has new static slots
+    const needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
-    // @ts-ignore
     vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
     vm.$vnode = parentVnode; // update vm's placeholder node without re-render
     if (vm._vnode) {
         // update child tree's parent
-        // @ts-ignore
         vm._vnode.parent = parentVnode;
     }
     vm.$options._renderChildren = renderChildren;
@@ -3585,16 +3587,15 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // these are also reactive so they may trigger child update if the child
     // used them during render
     vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
     vm.$listeners = listeners || emptyObject;
     // update props
     if (propsData && vm.$options.props) {
         toggleObserving(false);
-        var props = vm._props;
-        var propKeys = vm.$options._propKeys || [];
-        for (var i = 0; i < propKeys.length; i++) {
-            var key = propKeys[i];
-            var propOptions = vm.$options.props; // wtf flow?
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
             props[key] = validateProp(key, propOptions, propsData, vm);
         }
         toggleObserving(true);
@@ -3603,7 +3604,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     }
     // update listeners
     listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
+    const oldListeners = vm.$options._parentListeners;
     vm.$options._parentListeners = listeners;
     updateComponentListeners(vm, listeners, oldListeners);
     // resolve slots + force update if has children
@@ -3618,7 +3619,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
 function isInInactiveTree(vm) {
     while (vm && (vm = vm.$parent)) {
         if (vm._inactive)
-            { return true; }
+            return true;
     }
     return false;
 }
@@ -3634,10 +3635,10 @@ function activateChildComponent(vm, direct) {
     }
     if (vm._inactive || vm._inactive === null) {
         vm._inactive = false;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'activated');
+        callHook$1(vm, "activated");
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3649,36 +3650,36 @@ function deactivateChildComponent(vm, direct) {
     }
     if (!vm._inactive) {
         vm._inactive = true;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'deactivated');
+        callHook$1(vm, "deactivated");
     }
 }
 function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
     if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
             invokeWithErrorHandling(handlers[i], vm, null, vm, info);
         }
     }
     if (vm._hasHookEvent) {
-        vm.$emit('hook:' + hook);
+        vm.$emit("hook:" + hook);
     }
     popTarget();
 }
 
-var MAX_UPDATE_COUNT = 100;
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index$1 = 0;
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index$1 = 0;
 /**
  * Reset the scheduler's state.
  */
@@ -3695,9 +3696,9 @@ function resetSchedulerState() {
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
-var currentFlushTimestamp = 0;
+let currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
+let getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3705,7 +3706,7 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
+    const performance = window.performance;
     if (performance &&
         typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
@@ -3713,7 +3714,7 @@ if (inBrowser && !isIE) {
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = () => performance.now();
     }
 }
 /**
@@ -3722,7 +3723,7 @@ if (inBrowser && !isIE) {
 function flushSchedulerQueue() {
     currentFlushTimestamp = getNow();
     flushing = true;
-    var watcher, id;
+    let watcher, id;
     // Sort queue before flush.
     // This ensures that:
     // 1. Components are updated from parent to child. (because parent is always
@@ -3731,7 +3732,7 @@ function flushSchedulerQueue() {
     //    user watchers are created before the render watcher)
     // 3. If a component is destroyed during a parent component's watcher run,
     //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
+    queue.sort((a, b) => a.id - b.id);
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
     for (index$1 = 0; index$1 < queue.length; index$1++) {
@@ -3748,15 +3749,15 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                        : "in a component render function."), watcher.vm);
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
                 break;
             }
         }
     }
     // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
     resetSchedulerState();
     // call component updated and activated hooks
     callActivatedHooks(activatedQueue);
@@ -3768,10 +3769,10 @@ function flushSchedulerQueue() {
     }
 }
 function callUpdatedHooks(queue) {
-    var i = queue.length;
+    let i = queue.length;
     while (i--) {
-        var watcher = queue[i];
-        var vm = watcher.vm;
+        const watcher = queue[i];
+        const vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
             callHook$1(vm, 'updated');
         }
@@ -3788,7 +3789,7 @@ function queueActivatedComponent(vm) {
     activatedChildren.push(vm);
 }
 function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
+    for (let i = 0; i < queue.length; i++) {
         queue[i]._inactive = true;
         activateChildComponent(queue[i], true /* true */);
     }
@@ -3799,7 +3800,7 @@ function callActivatedHooks(queue) {
  * pushed when the queue is being flushed.
  */
 function queueWatcher(watcher) {
-    var id = watcher.id;
+    const id = watcher.id;
     if (has[id] == null) {
         has[id] = true;
         if (!flushing) {
@@ -3808,7 +3809,7 @@ function queueWatcher(watcher) {
         else {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
-            var i = queue.length - 1;
+            let i = queue.length - 1;
             while (i > index$1 && queue[i].id > watcher.id) {
                 i--;
             }
@@ -3826,199 +3827,217 @@ function queueWatcher(watcher) {
     }
 }
 
-var uid$1 = 0;
+let uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$1; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        expOrFn.toString() ;
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            warn$2("Failed watching path: \"" + expOrFn + "\" " +
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = expOrFn.toString()
+            ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn$2(`Failed watching path: "${expOrFn}" ` +
                     'Watcher only accepts simple dot-delimited paths. ' +
                     'For full control, use a function instead.', vm);
+            }
         }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
     }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-        else {
-            throw e;
+        catch (e) {
+            if (this.user) {
+                // @ts-expect-error e is unknown, should we cast or any?
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
         }
-        popTarget();
-        this.cleanupDeps();
+        return value;
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
         }
     }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
     }
-    else {
-        queueWatcher(this);
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
     }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
-            if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                 }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                else {
+                    this.cb.call(this.vm, value, oldValue);
                 }
             }
-            else {
-                this.cb.call(this.vm, value, oldValue);
-            }
         }
     }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
     }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove$2(this.vm._watchers, this);
-        }
-        var i = this.deps.length;
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            this.deps[i].depend();
         }
-        this.active = false;
     }
-};
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
+}
 
-var sharedPropertyDefinition = {
+const sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
     get: noop,
@@ -4035,11 +4054,11 @@ function proxy(target, sourceKey, key) {
 }
 function initState(vm) {
     vm._watchers = [];
-    var opts = vm.$options;
+    const opts = vm.$options;
     if (opts.props)
-        { initProps$1(vm, opts.props); }
+        initProps$1(vm, opts.props);
     if (opts.methods)
-        { initMethods(vm, opts.methods); }
+        initMethods(vm, opts.methods);
     if (opts.data) {
         initData(vm);
     }
@@ -4047,38 +4066,38 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed$1(vm, opts.computed); }
+        initComputed$1(vm, opts.computed);
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
 function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
     // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
     // root instance props should be converted
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    for (const key in propsOptions) {
         keys.push(key);
-        var value = validateProp(key, propsOptions, propsData, vm);
+        const value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
         {
-            var hyphenatedKey = hyphenate(key);
+            const hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn$2(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
             }
-            defineReactive(props, key, value, function () {
+            defineReactive(props, key, value, () => {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2("Avoid mutating a prop directly since the value will be " +
-                        "overwritten whenever the parent component re-renders. " +
-                        "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                    warn$2(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
                 }
             });
         }
@@ -4086,39 +4105,37 @@ function initProps$1(vm, propsOptions) {
         // during Vue.extend(). We only need to proxy props defined at
         // instantiation here.
         if (!(key in vm)) {
-            proxy(vm, "_props", key);
+            proxy(vm, `_props`, key);
         }
-    };
-
-    for (var key in propsOptions) loop( key );
+    }
     toggleObserving(true);
 }
 function initData(vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        warn$2('data functions should return an object:\n' +
-                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+        warn$2("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
     }
     // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
     while (i--) {
-        var key = keys[i];
+        const key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn$2(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            warn$2("The data property \"" + key + "\" is already declared as a prop. " +
-                    "Use prop default value instead.", vm);
+            warn$2(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
         }
         else if (!isReserved(key)) {
-            proxy(vm, "_data", key);
+            proxy(vm, `_data`, key);
         }
     }
     // observe data
@@ -4131,24 +4148,24 @@ function getData(data, vm) {
         return data.call(vm, vm);
     }
     catch (e) {
-        handleError(e, vm, "data()");
+        handleError(e, vm, `data()`);
         return {};
     }
     finally {
         popTarget();
     }
 }
-var computedWatcherOptions = { lazy: true };
+const computedWatcherOptions = { lazy: true };
 function initComputed$1(vm, computed) {
     // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
+    const watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-        var userDef = computed[key];
-        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
         if (getter == null) {
-            warn$2(("Getter is missing for computed property \"" + key + "\"."), vm);
+            warn$2(`Getter is missing for computed property "${key}".`, vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4162,17 +4179,20 @@ function initComputed$1(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn$2(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn$2(`The computed property "${key}" is already defined in data.`, vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
             }
         }
     }
 }
 function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
             : createGetterInvoker(userDef);
@@ -4188,14 +4208,14 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn$2(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
 }
 function createComputedGetter(key) {
     return function computedGetter() {
-        var watcher = this._computedWatchers && this._computedWatchers[key];
+        const watcher = this._computedWatchers && this._computedWatchers[key];
         if (watcher) {
             if (watcher.dirty) {
                 watcher.evaluate();
@@ -4213,29 +4233,30 @@ function createGetterInvoker(fn) {
     };
 }
 function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
         {
-            if (typeof methods[key] !== 'function') {
-                warn$2("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                    "Did you reference the function correctly?", vm);
+            if (typeof methods[key] !== "function") {
+                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
             }
             if (props && hasOwn(props, key)) {
-                warn$2(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
             }
             if (key in vm && isReserved(key)) {
-                warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                    "Avoid defining component methods that start with _ or $.");
+                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
-    for (var key in watch) {
-        var handler = watch[key];
+    for (const key in watch) {
+        const handler = watch[key];
         if (Array.isArray(handler)) {
-            for (var i = 0; i < handler.length; i++) {
+            for (let i = 0; i < handler.length; i++) {
                 createWatcher(vm, key, handler[i]);
             }
         }
@@ -4249,7 +4270,7 @@ function createWatcher(vm, expOrFn, handler, options) {
         options = handler;
         handler = handler.handler;
     }
-    if (typeof handler === 'string') {
+    if (typeof handler === "string") {
         handler = vm[handler];
     }
     return vm.$watch(expOrFn, handler, options);
@@ -4258,43 +4279,39 @@ function stateMixin(Vue) {
     // flow somehow has problems with directly declared definition object
     // when using Object.defineProperty, so we have to procedurally build up
     // the object here.
-    var dataDef = {};
+    const dataDef = {};
     dataDef.get = function () {
         return this._data;
     };
-    var propsDef = {};
+    const propsDef = {};
     propsDef.get = function () {
         return this._props;
     };
     {
         dataDef.set = function () {
-            warn$2('Avoid replacing instance root $data. ' +
-                'Use nested data properties instead.', this);
+            warn$2("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
         };
         propsDef.set = function () {
-            warn$2("$props is readonly.", this);
+            warn$2(`$props is readonly.`, this);
         };
     }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
-        var vm = this;
+        const vm = this;
         if (isPlainObject(cb)) {
             return createWatcher(vm, expOrFn, cb, options);
         }
         options = options || {};
         options.user = true;
-        var watcher = new Watcher(vm, expOrFn, cb, options);
+        const watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
             pushTarget();
-            try {
-                cb.call(vm, watcher.value);
-            }
-            catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-            }
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
             popTarget();
         }
         return function unwatchFn() {
@@ -4303,17 +4320,17 @@ function stateMixin(Vue) {
     };
 }
 
-var uid = 0;
+let uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
-        var vm = this;
+        const vm = this;
         // a uid
         vm._uid = uid++;
-        var startTag, endTag;
+        let startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4346,7 +4363,7 @@ function initMixin$1(Vue) {
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4354,13 +4371,12 @@ function initMixin$1(Vue) {
     };
 }
 function initInternalComponent(vm, options) {
-    // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
+    const opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
+    const parentVnode = options._parentVnode;
     opts.parent = options.parent;
     opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
+    const vnodeComponentOptions = parentVnode.componentOptions;
     opts.propsData = vnodeComponentOptions.propsData;
     opts._parentListeners = vnodeComponentOptions.listeners;
     opts._renderChildren = vnodeComponentOptions.children;
@@ -4371,16 +4387,16 @@ function initInternalComponent(vm, options) {
     }
 }
 function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
+    let options = Ctor.options;
     if (Ctor.super) {
-        var superOptions = resolveConstructorOptions(Ctor.super);
-        var cachedSuperOptions = Ctor.superOptions;
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
         if (superOptions !== cachedSuperOptions) {
             // super option changed,
             // need to resolve new options.
             Ctor.superOptions = superOptions;
             // check if there are any late-modified/attached options (#4976)
-            var modifiedOptions = resolveModifiedOptions(Ctor);
+            const modifiedOptions = resolveModifiedOptions(Ctor);
             // update base extend options
             if (modifiedOptions) {
                 extend(Ctor.extendOptions, modifiedOptions);
@@ -4394,13 +4410,13 @@ function resolveConstructorOptions(Ctor) {
     return options;
 }
 function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
         if (latest[key] !== sealed[key]) {
             if (!modified)
-                { modified = {}; }
+                modified = {};
             modified[key] = latest[key];
         }
     }
@@ -4409,29 +4425,29 @@ function resolveModifiedOptions(Ctor) {
 
 function Vue(options) {
     if (!(this instanceof Vue)) {
-        warn$2('Vue is a constructor and should be called with the `new` keyword');
+        warn$2("Vue is a constructor and should be called with the `new` keyword");
     }
     this._init(options);
 }
-//@ts-ignore
+//@ts-expect-error Vue has function type
 initMixin$1(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 stateMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 eventsMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 lifecycleMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
 function initUse(Vue) {
     Vue.use = function (plugin) {
-        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
         if (installedPlugins.indexOf(plugin) > -1) {
             return this;
         }
         // additional parameters
-        var args = toArray(arguments, 1);
+        const args = toArray(arguments, 1);
         args.unshift(this);
         if (typeof plugin.install === 'function') {
             plugin.install.apply(plugin, args);
@@ -4458,23 +4474,23 @@ function initExtend(Vue) {
      * constructors" for prototypal inheritance and cache them.
      */
     Vue.cid = 0;
-    var cid = 1;
+    let cid = 1;
     /**
      * Class inheritance
      */
     Vue.extend = function (extendOptions) {
         extendOptions = extendOptions || {};
-        var Super = this;
-        var SuperId = Super.cid;
-        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
         if (cachedCtors[SuperId]) {
             return cachedCtors[SuperId];
         }
-        var name = extendOptions.name || Super.options.name;
+        const name = extendOptions.name || Super.options.name;
         if (name) {
             validateComponentName(name);
         }
-        var Sub = function VueComponent(options) {
+        const Sub = function VueComponent(options) {
             this._init(options);
         };
         Sub.prototype = Object.create(Super.prototype);
@@ -4516,14 +4532,14 @@ function initExtend(Vue) {
     };
 }
 function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-        proxy(Comp.prototype, "_props", key);
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
     }
 }
 function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
     }
 }
@@ -4532,7 +4548,7 @@ function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
      */
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         // @ts-expect-error function is not exact same type
         Vue[type] = function (id, definition) {
             if (!definition) {
@@ -4558,6 +4574,7 @@ function initAssetRegisters(Vue) {
     });
 }
 
+/* @flow */
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4565,8 +4582,8 @@ function matches(pattern, name) {
     if (Array.isArray(pattern)) {
         return pattern.indexOf(name) > -1;
     }
-    else if (typeof pattern === 'string') {
-        return pattern.split(',').indexOf(name) > -1;
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
     }
     else if (isRegExp(pattern)) {
         return pattern.test(name);
@@ -4575,13 +4592,11 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-        var cachedNode = cache[key];
-        if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
             if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
@@ -4589,53 +4604,72 @@ function pruneCache(keepAliveInstance, filter) {
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-        //@ts-expect-error has void type
-        cached.componentInstance.$destroy();
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
     }
     cache[key] = null;
     remove$2(keys, key);
 }
-var patternTypes = [String, RegExp, Array];
-// TODO use defineComponent
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
 var KeepAlive = {
-    name: 'keep-alive',
+    name: "keep-alive",
     abstract: true,
     props: {
         include: patternTypes,
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
-        for (var key in this.cache) {
+    destroyed() {
+        for (const key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
-        this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
         });
-        this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
         });
     },
-    render: function render() {
-        var slot = this.$slots.default;
-        var vnode = getFirstComponentChild(slot);
-        var componentOptions = vnode && vnode.componentOptions;
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
             if (
             // not included
             (include && (!name || !matches(include, name))) ||
@@ -4643,14 +4677,12 @@ var KeepAlive = {
                 (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
-            var key = vnode.key == null
+            const { cache, keys } = this;
+            const key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4659,13 +4691,11 @@ var KeepAlive = {
                 keys.push(key);
             }
             else {
-                cache[key] = vnode;
-                keys.push(key);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
             }
+            // @ts-expect-error can vnode.data can be undefined
             vnode.data.keepAlive = true;
         }
         return vnode || (slot && slot[0]);
@@ -4673,15 +4703,15 @@ var KeepAlive = {
 };
 
 var builtInComponents = {
-    KeepAlive: KeepAlive,
+    KeepAlive,
 };
 
 function initGlobalAPI(Vue) {
     // config
-    var configDef = {};
-    configDef.get = function () { return config; };
+    const configDef = {};
+    configDef.get = () => config;
     {
-        configDef.set = function () {
+        configDef.set = () => {
             warn$2('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
@@ -4691,20 +4721,20 @@ function initGlobalAPI(Vue) {
     // them unless you are aware of the risk.
     Vue.util = {
         warn: warn$2,
-        extend: extend,
-        mergeOptions: mergeOptions,
-        defineReactive: defineReactive,
+        extend,
+        mergeOptions,
+        defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
     Vue.nextTick = nextTick;
     // 2.6 explicit observable API
-    Vue.observable = function (obj) {
+    Vue.observable = (obj) => {
         observe(obj);
         return obj;
     };
     Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         Vue.options[type + 's'] = Object.create(null);
     });
     // this is used to identify the "base" constructor to extend all plain-object
@@ -4722,7 +4752,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4731,22 +4761,22 @@ Object.defineProperty(Vue.prototype, '$ssrContext', {
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
     value: FunctionalRenderContext,
 });
-Vue.version = '2.6.12';
+Vue.version = '2.6.14';
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+const isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue$1 = makeMap('input,textarea,option,select,progress');
-var mustUseProp$1 = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-var convertEnumeratedValue = function (key, value) {
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
     return isFalsyAttrValue(value) || value === 'false'
         ? 'false'
         : // allow arbitrary string value for contenteditable
@@ -4754,33 +4784,34 @@ var convertEnumeratedValue = function (key, value) {
                 ? value
                 : 'true';
 };
-var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
-var xlinkNS = 'http://www.w3.org/1999/xlink';
-var isXlink = function (name) {
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
     return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-var getXlinkProp = function (name) {
+const getXlinkProp = (name) => {
     return isXlink(name) ? name.slice(6, name.length) : '';
 };
-var isFalsyAttrValue = function (val) {
+const isFalsyAttrValue = (val) => {
     return val == null || val === false;
 };
 
 function genClassForVnode(vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
     while (isDef(childNode.componentInstance)) {
         childNode = childNode.componentInstance._vnode;
         if (childNode && childNode.data) {
             data = mergeClassData(childNode.data, data);
         }
     }
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while (isDef((parentNode = parentNode.parent))) {
         if (parentNode && parentNode.data) {
             data = mergeClassData(data, parentNode.data);
@@ -4818,34 +4849,34 @@ function stringifyClass(value) {
     return '';
 }
 function stringifyArray(value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
         if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += stringified;
         }
     }
     return res;
 }
 function stringifyObject(value) {
-    var res = '';
-    for (var key in value) {
+    let res = '';
+    for (const key in value) {
         if (value[key]) {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += key;
         }
     }
     return res;
 }
 
-var namespaceMap = {
+const namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4858,14 +4889,15 @@ var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isReservedTag$1 = function (tag) {
-    return isHTMLTag$1(tag) || isSVG$1(tag);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
 };
-function getTagNamespace$1(tag) {
-    if (isSVG$1(tag)) {
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
         return 'svg';
     }
     // basic support for MathML
@@ -4874,13 +4906,13 @@ function getTagNamespace$1(tag) {
         return 'math';
     }
 }
-var unknownElementCache = Object.create(null);
+const unknownElementCache = Object.create(null);
 function isUnknownElement(tag) {
     /* istanbul ignore if */
     if (!inBrowser) {
         return true;
     }
-    if (isReservedTag$1(tag)) {
+    if (isReservedTag(tag)) {
         return false;
     }
     tag = tag.toLowerCase();
@@ -4888,7 +4920,7 @@ function isUnknownElement(tag) {
     if (unknownElementCache[tag] != null) {
         return unknownElementCache[tag];
     }
-    var el = document.createElement(tag);
+    const el = document.createElement(tag);
     if (tag.indexOf('-') > -1) {
         // http://stackoverflow.com/a/28210364/1070244
         return (unknownElementCache[tag] =
@@ -4899,14 +4931,14 @@ function isUnknownElement(tag) {
         return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /**
  * Query an element selector if it's not an element already.
  */
-function query$1(el) {
+function query(el) {
     if (typeof el === 'string') {
-        var selected = document.querySelector(el);
+        const selected = document.querySelector(el);
         if (!selected) {
             warn$2('Cannot find element: ' + el);
             return document.createElement('div');
@@ -4919,7 +4951,7 @@ function query$1(el) {
 }
 
 function createElement(tagName, vnode) {
-    var elm = document.createElement(tagName);
+    const elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
     }
@@ -4981,46 +5013,43 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref$1 = {
-    create: function create(_, vnode) {
+var ref = {
+    create(_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy(vnode) {
         registerRef(vnode, true);
     },
 };
 function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
+    const key = vnode.data.ref;
     if (!isDef(key))
-        { return; }
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
     if (isRemoval) {
-        if (Array.isArray(refs[key])) {
-            // @ts-expect-error invalid typings
-            remove$2(refs[key], ref);
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
         }
-        else if (refs[key] === ref) {
+        else if (obj === ref) {
             refs[key] = undefined;
         }
     }
     else {
-        // @ts-expect-error invalid typings
         if (vnode.data.refInFor) {
-            if (!Array.isArray(refs[key])) {
+            if (!Array.isArray(obj)) {
                 refs[key] = [ref];
-                // @ts-expect-error invalid typings
             }
-            else if (refs[key].indexOf(ref) < 0) {
-                // @ts-expect-error invalid typings
-                refs[key].push(ref);
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
             }
         }
         else {
@@ -5040,41 +5069,38 @@ function registerRef(vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-var emptyNode = new VNode('', {}, []);
-var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
-        ((a.tag === b.tag &&
-            a.isComment === b.isComment &&
-            isDef(a.data) === isDef(b.data) &&
-            sameInputType(a, b)) ||
-            (isTrue(a.isAsyncPlaceholder) &&
-                a.asyncFactory === b.asyncFactory &&
-                isUndef(b.asyncFactory.error))));
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
 }
 function sameInputType(a, b) {
     if (a.tag !== 'input')
-        { return true; }
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
     return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
 function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
+    let i, key;
+    const map = {};
     for (i = beginIdx; i <= endIdx; ++i) {
         key = children[i].key;
         if (isDef(key))
-            { map[key] = i; }
+            map[key] = i;
     }
     return map;
 }
 function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5096,7 +5122,7 @@ function createPatchFunction(backend) {
         return remove;
     }
     function removeNode(el) {
-        var parent = nodeOps.parentNode(el);
+        const parent = nodeOps.parentNode(el);
         // element may have already been removed due to v-html / v-text
         if (isDef(parent)) {
             nodeOps.removeChild(parent, el);
@@ -5106,14 +5132,14 @@ function createPatchFunction(backend) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
-                config.ignoredElements.some(function (ignore) {
+                config.ignoredElements.some((ignore) => {
                     return isRegExp(ignore)
                         ? ignore.test(vnode.tag)
                         : ignore === vnode.tag;
                 })) &&
             config.isUnknownElement(vnode.tag));
     }
-    var creatingElmInVPre = 0;
+    let creatingElmInVPre = 0;
     function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
         if (isDef(vnode.elm) && isDef(ownerArray)) {
             // This vnode was used in a previous render!
@@ -5127,9 +5153,9 @@ function createPatchFunction(backend) {
         if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
             return;
         }
-        var data = vnode.data;
-        var children = vnode.children;
-        var tag = vnode.tag;
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
         if (isDef(tag)) {
             {
                 if (data && data.pre) {
@@ -5169,9 +5195,9 @@ function createPatchFunction(backend) {
         }
     }
     function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i = vnode.data;
+        let i = vnode.data;
         if (isDef(i)) {
-            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
             if (isDef((i = i.hook)) && isDef((i = i.init))) {
                 i(vnode, false /* hydrating */);
             }
@@ -5208,12 +5234,12 @@ function createPatchFunction(backend) {
         }
     }
     function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i;
+        let i;
         // hack for #4339: a reactivated component with inner transition
         // does not trigger because the inner node's created hooks are not called
         // again. It's not ideal to involve module-specific logic in here but
         // there doesn't seem to be a better way to do it.
-        var innerNode = vnode;
+        let innerNode = vnode;
         while (innerNode.componentInstance) {
             innerNode = innerNode.componentInstance._vnode;
             if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5245,7 +5271,7 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
+            for (let i = 0; i < children.length; ++i) {
                 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
@@ -5260,27 +5286,27 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
             if (isDef(i.create))
-                { i.create(emptyNode, vnode); }
+                i.create(emptyNode, vnode);
             if (isDef(i.insert))
-                { insertedVnodeQueue.push(vnode); }
+                insertedVnodeQueue.push(vnode);
         }
     }
     // set scope id attribute for scoped CSS.
     // this is implemented as a special case to avoid the overhead
     // of going through the normal attribute patching process.
     function setScope(vnode) {
-        var i;
+        let i;
         if (isDef((i = vnode.fnScopeId))) {
             nodeOps.setStyleScope(vnode.elm, i);
         }
         else {
-            var ancestor = vnode;
+            let ancestor = vnode;
             while (ancestor) {
                 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                     nodeOps.setStyleScope(vnode.elm, i);
@@ -5302,13 +5328,13 @@ function createPatchFunction(backend) {
         }
     }
     function invokeDestroyHook(vnode) {
-        var i, j;
-        var data = vnode.data;
+        let i, j;
+        const data = vnode.data;
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                { i(vnode); }
+                i(vnode);
             for (i = 0; i < cbs.destroy.length; ++i)
-                { cbs.destroy[i](vnode); }
+                cbs.destroy[i](vnode);
         }
         if (isDef((i = vnode.children))) {
             for (j = 0; j < vnode.children.length; ++j) {
@@ -5318,7 +5344,7 @@ function createPatchFunction(backend) {
     }
     function removeVnodes(vnodes, startIdx, endIdx) {
         for (; startIdx <= endIdx; ++startIdx) {
-            var ch = vnodes[startIdx];
+            const ch = vnodes[startIdx];
             if (isDef(ch)) {
                 if (isDef(ch.tag)) {
                     removeAndInvokeRemoveHook(ch);
@@ -5333,8 +5359,8 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
-            var listeners = cbs.remove.length + 1;
+            let i;
+            const listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
                 // increase the listeners count
@@ -5365,19 +5391,19 @@ function createPatchFunction(backend) {
         }
     }
     function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        var oldStartIdx = 0;
-        var newStartIdx = 0;
-        var oldEndIdx = oldCh.length - 1;
-        var oldStartVnode = oldCh[0];
-        var oldEndVnode = oldCh[oldEndIdx];
-        var newEndIdx = newCh.length - 1;
-        var newStartVnode = newCh[0];
-        var newEndVnode = newCh[newEndIdx];
-        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
         // removeOnly is a special flag used only by <transition-group>
         // to ensure removed elements stay in correct relative positions
         // during leaving transitions
-        var canMove = !removeOnly;
+        const canMove = !removeOnly;
         {
             checkDuplicateKeys(newCh);
         }
@@ -5416,7 +5442,7 @@ function createPatchFunction(backend) {
             }
             else {
                 if (isUndef(oldKeyToIdx))
-                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
                 idxInOld = isDef(newStartVnode.key)
                     ? oldKeyToIdx[newStartVnode.key]
                     : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
@@ -5449,13 +5475,13 @@ function createPatchFunction(backend) {
         }
     }
     function checkDuplicateKeys(children) {
-        var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
-            var key = vnode.key;
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn$2(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5464,10 +5490,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                return i;
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5478,7 +5504,7 @@ function createPatchFunction(backend) {
             // clone reused vnode
             vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        var elm = (vnode.elm = oldVnode.elm);
+        const elm = (vnode.elm = oldVnode.elm);
         if (isTrue(oldVnode.isAsyncPlaceholder)) {
             if (isDef(vnode.asyncFactory.resolved)) {
                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5499,30 +5525,30 @@ function createPatchFunction(backend) {
             vnode.componentInstance = oldVnode.componentInstance;
             return;
         }
-        var i;
-        var data = vnode.data;
+        let i;
+        const data = vnode.data;
         if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
             i(oldVnode, vnode);
         }
-        var oldCh = oldVnode.children;
-        var ch = vnode.children;
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
         if (isDef(data) && isPatchable(vnode)) {
             for (i = 0; i < cbs.update.length; ++i)
-                { cbs.update[i](oldVnode, vnode); }
+                cbs.update[i](oldVnode, vnode);
             if (isDef((i = data.hook)) && isDef((i = i.update)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
         if (isUndef(vnode.text)) {
             if (isDef(oldCh) && isDef(ch)) {
                 if (oldCh !== ch)
-                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
             }
             else if (isDef(ch)) {
                 {
                     checkDuplicateKeys(ch);
                 }
                 if (isDef(oldVnode.text))
-                    { nodeOps.setTextContent(elm, ''); }
+                    nodeOps.setTextContent(elm, '');
                 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
             }
             else if (isDef(oldCh)) {
@@ -5537,7 +5563,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
     }
     function invokeInsertHook(vnode, queue, initial) {
@@ -5547,23 +5573,21 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
+            for (let i = 0; i < queue.length; ++i) {
                 queue[i].data.hook.insert(queue[i]);
             }
         }
     }
-    var hydrationBailed = false;
+    let hydrationBailed = false;
     // list of modules that can skip create hook during hydration because they
     // are already rendered on the client or has no need for initialization
     // Note: style is excluded because it relies on initial clone for future
     // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        let i;
+        const { tag, data, children } = vnode;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5578,7 +5602,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.init)))
-                { i(vnode, true /* hydrating */); }
+                i(vnode, true /* hydrating */);
             if (isDef((i = vnode.componentInstance))) {
                 // child component. it should have hydrated its own tree.
                 initComponent(vnode, insertedVnodeQueue);
@@ -5610,11 +5634,11 @@ function createPatchFunction(backend) {
                     }
                     else {
                         // iterate and compare children lists
-                        var childrenMatch = true;
-                        var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5636,8 +5660,8 @@ function createPatchFunction(backend) {
                 }
             }
             if (isDef(data)) {
-                var fullInvoke = false;
-                for (var key in data) {
+                let fullInvoke = false;
+                for (const key in data) {
                     if (!isRenderedModule(key)) {
                         fullInvoke = true;
                         invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5669,18 +5693,18 @@ function createPatchFunction(backend) {
     return function patch(oldVnode, vnode, hydrating, removeOnly) {
         if (isUndef(vnode)) {
             if (isDef(oldVnode))
-                { invokeDestroyHook(oldVnode); }
+                invokeDestroyHook(oldVnode);
             return;
         }
-        var isInitialPatch = false;
-        var insertedVnodeQueue = [];
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
         if (isUndef(oldVnode)) {
             // empty mount (likely as component), create new root element
             isInitialPatch = true;
             createElm(vnode, insertedVnodeQueue);
         }
         else {
-            var isRealElement = isDef(oldVnode.nodeType);
+            const isRealElement = isDef(oldVnode.nodeType);
             if (!isRealElement && sameVnode(oldVnode, vnode)) {
                 // patch existing root node
                 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5712,8 +5736,8 @@ function createPatchFunction(backend) {
                     oldVnode = emptyNodeAt(oldVnode);
                 }
                 // replacing existing element
-                var oldElm = oldVnode.elm;
-                var parentElm = nodeOps.parentNode(oldElm);
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
                 // create new node
                 createElm(vnode, insertedVnodeQueue, 
                 // extremely rare edge case: do not insert if old element is in a
@@ -5722,25 +5746,25 @@ function createPatchFunction(backend) {
                 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                 // update parent placeholder node element, recursively
                 if (isDef(vnode.parent)) {
-                    var ancestor = vnode.parent;
-                    var patchable = isPatchable(vnode);
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
                             cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
+                            const insert = ancestor.data.hook.insert;
                             if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
                                 }
                             }
                         }
@@ -5778,13 +5802,13 @@ function updateDirectives(oldVnode, vnode) {
     }
 }
 function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
     for (key in newDirs) {
         oldDir = oldDirs[key];
         dir = newDirs[key];
@@ -5806,8 +5830,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithInsert.length) {
-        var callInsert = function () {
-            for (var i = 0; i < dirsWithInsert.length; i++) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
                 callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
@@ -5819,8 +5843,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
                 callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
@@ -5834,14 +5858,14 @@ function _update(oldVnode, vnode) {
         }
     }
 }
-var emptyModifiers = Object.create(null);
+const emptyModifiers = Object.create(null);
 function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
+    const res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
         return res;
     }
-    var i, dir;
+    let i, dir;
     for (i = 0; i < dirs.length; i++) {
         dir = dirs[i];
         if (!dir.modifiers) {
@@ -5855,34 +5879,35 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
+    const fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            // @ts-expect-error should it be any?
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
         }
     }
 }
 
-var baseModules = [ref$1, directives$1];
+var baseModules = [ref, directives$1];
 
 function updateAttrs(oldVnode, vnode) {
-    var opts = vnode.componentOptions;
+    const opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
         return;
     }
     if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
         return;
     }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(attrs.__ob__)) {
         attrs = vnode.data.attrs = extend({}, attrs);
@@ -5958,7 +5983,7 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            const blocker = (e) => {
                 e.stopImmediatePropagation();
                 el.removeEventListener('input', blocker);
             };
@@ -5975,18 +6000,18 @@ var attrs = {
 };
 
 function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticClass) &&
         isUndef(data.class) &&
         (isUndef(oldData) ||
             (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
         return;
     }
-    var cls = genClassForVnode(vnode);
+    let cls = genClassForVnode(vnode);
     // handle transition classes
-    var transitionClass = el._transitionClasses;
+    const transitionClass = el._transitionClasses;
     if (isDef(transitionClass)) {
         cls = concat(cls, stringifyClass(transitionClass));
     }
@@ -6001,35 +6026,35 @@ var klass$1 = {
     update: updateClass,
 };
 
-var validDivisionCharRE = /[\w).+\-_$\]]/;
+const validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
     for (i = 0; i < exp.length; i++) {
         prev = c;
         c = exp.charCodeAt(i);
         if (inSingle) {
             if (c === 0x27 && prev !== 0x5c)
-                { inSingle = false; }
+                inSingle = false;
         }
         else if (inDouble) {
             if (c === 0x22 && prev !== 0x5c)
-                { inDouble = false; }
+                inDouble = false;
         }
         else if (inTemplateString) {
             if (c === 0x60 && prev !== 0x5c)
-                { inTemplateString = false; }
+                inTemplateString = false;
         }
         else if (inRegex) {
             if (c === 0x2f && prev !== 0x5c)
-                { inRegex = false; }
+                inRegex = false;
         }
         else if (c === 0x7c && // pipe
             exp.charCodeAt(i + 1) !== 0x7c &&
@@ -6078,13 +6103,13 @@ function parseFilters(exp) {
             }
             if (c === 0x2f) {
                 // /
-                var j = i - 1;
-                var p = (void 0);
+                let j = i - 1;
+                let p;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
                     if (p !== ' ')
-                        { break; }
+                        break;
                 }
                 if (!p || !validDivisionCharRE.test(p)) {
                     inRegex = true;
@@ -6110,55 +6135,55 @@ function parseFilters(exp) {
     return expression;
 }
 function wrapFilter(exp, filter) {
-    var i = filter.indexOf('(');
+    const i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return ("_f(\"" + filter + "\")(" + exp + ")");
+        return `_f("${filter}")(${exp})`;
     }
     else {
-        var name = filter.slice(0, i);
-        var args = filter.slice(i + 1);
-        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
     }
 }
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+    console.error(`[Vue compiler]: ${msg}`);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
-    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
 }
 function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
     el.plain = false;
 }
 function addAttr(el, name, value, range, dynamic) {
-    var attrs = dynamic
+    const attrs = dynamic
         ? el.dynamicAttrs || (el.dynamicAttrs = [])
         : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
     el.plain = false;
 }
 // add a raw attr (use this in preTransforms)
 function addRawAttr(el, name, value, range) {
     el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+    el.attrsList.push(rangeSetItem({ name, value }, range));
 }
 function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
     (el.directives || (el.directives = [])).push(rangeSetItem({
-        name: name,
-        rawName: rawName,
-        value: value,
-        arg: arg,
-        isDynamicArg: isDynamicArg,
-        modifiers: modifiers,
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
     }, range));
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6175,7 +6200,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     // the only target envs that have right/middle clicks.
     if (modifiers.right) {
         if (dynamic) {
-            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+            name = `(${name})==='click'?'contextmenu':(${name})`;
         }
         else if (name === 'click') {
             name = 'contextmenu';
@@ -6184,7 +6209,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     }
     else if (modifiers.middle) {
         if (dynamic) {
-            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+            name = `(${name})==='click'?'mouseup':(${name})`;
         }
         else if (name === 'click') {
             name = 'mouseup';
@@ -6204,7 +6229,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
         delete modifiers.passive;
         name = prependModifierMarker('&', name, dynamic);
     }
-    var events;
+    let events;
     if (modifiers.native) {
         delete modifiers.native;
         events = el.nativeEvents || (el.nativeEvents = {});
@@ -6212,11 +6237,11 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     else {
         events = el.events || (el.events = {});
     }
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
     if (modifiers !== emptyObject) {
         newHandler.modifiers = modifiers;
     }
-    var handlers = events[name];
+    const handlers = events[name];
     /* istanbul ignore if */
     if (Array.isArray(handlers)) {
         important ? handlers.unshift(newHandler) : handlers.push(newHandler);
@@ -6235,12 +6260,12 @@ function getRawBindingAttr(el, name) {
         el.rawAttrsMap[name]);
 }
 function getBindingAttr(el, name, getStatic) {
-    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
     if (dynamicValue != null) {
         return parseFilters(dynamicValue);
     }
     else if (getStatic !== false) {
-        var staticValue = getAndRemoveAttr(el, name);
+        const staticValue = getAndRemoveAttr(el, name);
         if (staticValue != null) {
             return JSON.stringify(staticValue);
         }
@@ -6251,10 +6276,10 @@ function getBindingAttr(el, name, getStatic) {
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
 function getAndRemoveAttr(el, name, removeFromMap) {
-    var val;
+    let val;
     if ((val = el.attrsMap[name]) != null) {
-        var list = el.attrsList;
-        for (var i = 0, l = list.length; i < l; i++) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
             if (list[i].name === name) {
                 list.splice(i, 1);
                 break;
@@ -6267,9 +6292,9 @@ function getAndRemoveAttr(el, name, removeFromMap) {
     return val;
 }
 function getAndRemoveAttrByRegex(el, name) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-        var attr = list[i];
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
         if (name.test(attr.name)) {
             list.splice(i, 1);
             return attr;
@@ -6292,37 +6317,35 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
-            "(typeof " + baseValueExpression + " === 'string'" +
-                "? " + baseValueExpression + ".trim()" +
-                ": " + baseValueExpression + ")";
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
     }
     if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
+        valueExpression = `_n(${valueExpression})`;
     }
-    var assignment = genAssignmentCode(value, valueExpression);
+    const assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: ("(" + value + ")"),
+        value: `(${value})`,
         expression: JSON.stringify(value),
-        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
     };
 }
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
 function genAssignmentCode(value, assignment) {
-    var res = parseModel(value);
+    const res = parseModel(value);
     if (res.key === null) {
-        return (value + "=" + assignment);
+        return `${value}=${assignment}`;
     }
     else {
-        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
     }
 }
 /**
@@ -6339,7 +6362,7 @@ function genAssignmentCode(value, assignment) {
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-var len, str, chr, index, expressionPos, expressionEndPos;
+let len, str, chr, index, expressionPos, expressionEndPos;
 function parseModel(val) {
     // Fix https://github.com/vuejs/vue/pull/7730
     // allow v-model="obj.val " (trailing whitespace)
@@ -6387,7 +6410,7 @@ function isStringStart(chr) {
     return chr === 0x22 || chr === 0x27;
 }
 function parseBracket(chr) {
-    var inBracket = 1;
+    let inBracket = 1;
     expressionPos = index;
     while (!eof()) {
         chr = next();
@@ -6396,9 +6419,9 @@ function parseBracket(chr) {
             continue;
         }
         if (chr === 0x5b)
-            { inBracket++; }
+            inBracket++;
         if (chr === 0x5d)
-            { inBracket--; }
+            inBracket--;
         if (inBracket === 0) {
             expressionEndPos = index;
             break;
@@ -6406,7 +6429,7 @@ function parseBracket(chr) {
     }
 }
 function parseString(chr) {
-    var stringQuote = chr;
+    const stringQuote = chr;
     while (!eof()) {
         chr = next();
         if (chr === stringQuote) {
@@ -6415,10 +6438,127 @@ function parseString(chr) {
     }
 }
 
+let warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN$1 = '__r';
-var CHECKBOX_RADIO_TOKEN = '__c';
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6426,11 +6566,11 @@ var CHECKBOX_RADIO_TOKEN = '__c';
 // user-attached handlers.
 function normalizeEvents(on) {
     /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN$1])) {
+    if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
-        delete on[RANGE_TOKEN$1];
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
     // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6440,11 +6580,11 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target;
+let target;
 function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
+    const _target = target; // save current target element in closure
     return function onceHandler() {
-        var res = handler.apply(null, arguments);
+        const res = handler.apply(null, arguments);
         if (res !== null) {
             remove(event, onceHandler, capture, _target);
         }
@@ -6453,7 +6593,7 @@ function createOnceHandler(event, handler, capture) {
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
-var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
 function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
@@ -6462,9 +6602,9 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
-        //@ts-expect-error
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
         handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
@@ -6485,7 +6625,7 @@ function add(name, handler, capture, passive) {
             }
         };
     }
-    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
 }
 function remove(name, handler, capture, _target) {
     (_target || target).removeEventListener(name, 
@@ -6496,9 +6636,11 @@ function updateDOMListeners(oldVnode, vnode) {
     if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
         return;
     }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
     normalizeEvents(on);
     updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
     target = undefined;
@@ -6506,17 +6648,19 @@ function updateDOMListeners(oldVnode, vnode) {
 var events = {
     create: updateDOMListeners,
     update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-var svgContainer;
+let svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
         return;
     }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(props.__ob__)) {
         props = vnode.data.domProps = extend({}, props);
@@ -6533,9 +6677,9 @@ function updateDOMProps(oldVnode, vnode) {
         // on subsequent patches (#3360)
         if (key === 'textContent' || key === 'innerHTML') {
             if (vnode.children)
-                { vnode.children.length = 0; }
+                vnode.children.length = 0;
             if (cur === oldProps[key])
-                { continue; }
+                continue;
             // #6601 work around Chrome version <= 55 bug where single textNode
             // replaced by innerHTML/textContent retains its parentNode property
             if (elm.childNodes.length === 1) {
@@ -6547,18 +6691,18 @@ function updateDOMProps(oldVnode, vnode) {
             // non-string values will be stringified
             elm._value = cur;
             // avoid resetting cursor position when value is the same
-            var strCur = isUndef(cur) ? '' : String(cur);
+            const strCur = isUndef(cur) ? '' : String(cur);
             if (shouldUpdateValue(elm, strCur)) {
                 elm.value = strCur;
             }
         }
         else if (key === 'innerHTML' &&
-            isSVG$1(elm.tagName) &&
+            isSVG(elm.tagName) &&
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-            var svg = svgContainer.firstChild;
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
             while (elm.firstChild) {
                 elm.removeChild(elm.firstChild);
             }
@@ -6592,7 +6736,7 @@ function shouldUpdateValue(elm, checkVal) {
 function isNotInFocusAndDirty(elm, checkVal) {
     // return true when textbox (.number and .trim) loses focus and its value is
     // not equal to the updated value
-    var notInFocus = true;
+    let notInFocus = true;
     // #6157
     // work around IE bug when accessing document.activeElement in an iframe
     try {
@@ -6602,8 +6746,8 @@ function isNotInFocusAndDirty(elm, checkVal) {
     return notInFocus && elm.value !== checkVal;
 }
 function isDirtyWithModifiers(elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
     if (isDef(modifiers)) {
         if (modifiers.number) {
             return toNumber(value) !== toNumber(newVal);
@@ -6619,13 +6763,13 @@ var domProps = {
     update: updateDOMProps,
 };
 
-var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
     cssText.split(listDelimiter).forEach(function (item) {
         if (item) {
-            var tmp = item.split(propertyDelimiter);
+            const tmp = item.split(propertyDelimiter);
             tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
         }
     });
@@ -6633,7 +6777,7 @@ var parseStyleText = cached(function (cssText) {
 });
 // merge static and dynamic style data on the same vnode
 function normalizeStyleData(data) {
-    var style = normalizeStyleBinding(data.style);
+    const style = normalizeStyleBinding(data.style);
     // static style is pre-processed into an object during compilation
     // and is always a fresh object, so it's safe to merge into it
     return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6653,10 +6797,10 @@ function normalizeStyleBinding(bindingStyle) {
  * so that parent component's style could override it
  */
 function getStyle(vnode, checkChild) {
-    var res = {};
-    var styleData;
+    const res = {};
+    let styleData;
     if (checkChild) {
-        var childNode = vnode;
+        let childNode = vnode;
         while (childNode.componentInstance) {
             childNode = childNode.componentInstance._vnode;
             if (childNode &&
@@ -6669,7 +6813,8 @@ function getStyle(vnode, checkChild) {
     if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
     }
-    var parentNode = vnode;
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6678,9 +6823,9 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-var cssVarRE = /^--/;
-var importantRE = /\s*!important$/;
-var setProp = function (el, name, val) {
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
     /* istanbul ignore if */
     if (cssVarRE.test(name)) {
         el.style.setProperty(name, val);
@@ -6689,12 +6834,12 @@ var setProp = function (el, name, val) {
         el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
     }
     else {
-        var normalizedName = normalize(name);
+        const normalizedName = normalize(name);
         if (Array.isArray(val)) {
             // Support values array created by autoprefixer, e.g.
             // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
             // Set them one by one, and the browser will only set those it can recognize
-            for (var i = 0, len = val.length; i < len; i++) {
+            for (let i = 0, len = val.length; i < len; i++) {
                 el.style[normalizedName] = val[i];
             }
         }
@@ -6703,43 +6848,43 @@ var setProp = function (el, name, val) {
         }
     }
 };
-var vendorNames = ['Webkit', 'Moz', 'ms'];
-var emptyStyle;
-var normalize = cached(function (prop) {
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
     emptyStyle = emptyStyle || document.createElement('div').style;
     prop = camelize(prop);
     if (prop !== 'filter' && prop in emptyStyle) {
         return prop;
     }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
         if (name in emptyStyle) {
             return name;
         }
     }
 });
 function updateStyle(oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticStyle) &&
         isUndef(data.style) &&
         isUndef(oldData.staticStyle) &&
         isUndef(oldData.style)) {
         return;
     }
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
     // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-    var style = normalizeStyleBinding(vnode.data.style) || {};
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
     // store normalized style under a different key for next diff
     // make sure to clone it if it's reactive, since the user likely wants
     // to mutate it.
     vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    var newStyle = getStyle(vnode, true);
+    const newStyle = getStyle(vnode, true);
     for (name in oldStyle) {
         if (isUndef(newStyle[name])) {
             setProp(el, name, '');
@@ -6758,7 +6903,7 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+const whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6771,14 +6916,14 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
+        const cur = ` ${el.getAttribute('class') || ''} `;
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -6796,7 +6941,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -6806,8 +6951,8 @@ function removeClass(el, cls) {
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -6827,7 +6972,7 @@ function resolveTransition(def) {
     }
     /* istanbul ignore else */
     if (typeof def === 'object') {
-        var res = {};
+        const res = {};
         if (def.css !== false) {
             extend(res, autoCssTransition(def.name || 'v'));
         }
@@ -6838,53 +6983,51 @@ function resolveTransition(def) {
         return autoCssTransition(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+const autoCssTransition = cached((name) => {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
-        // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
         transitionProp = 'WebkitTransition';
         transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
-        // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
         animationProp = 'WebkitAnimation';
         animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+const raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
+    : /* istanbul ignore next */ (fn) => fn();
 function nextFrame(fn) {
-    raf(function () {
+    raf(() => {
         // @ts-expect-error
         raf(fn);
     });
 }
 function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass(el, cls);
@@ -6897,45 +7040,42 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
     if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    var onEnd = function (e) {
+    const onEnd = (e) => {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(function () {
+    setTimeout(() => {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
+const transformRE = /\b(transform|all)(,|$)/;
 function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
+    const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
@@ -6965,12 +7105,12 @@ function getTransitionInfo(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
+        type,
+        timeout,
+        propCount,
+        hasTransform,
     };
 }
 function getTimeout(delays, durations) {
@@ -6978,7 +7118,7 @@ function getTimeout(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map(function (d, i) {
+    return Math.max.apply(null, durations.map((d, i) => {
         return toMs(d) + toMs(delays[i]);
     }));
 }
@@ -6991,13 +7131,13 @@ function toMs(s) {
 }
 
 function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7005,57 +7145,41 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
         checkDuration(explicitEnterDuration, 'enter', vnode);
     }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
             removeTransitionClass(el, toClass);
             removeTransitionClass(el, activeClass);
@@ -7074,9 +7198,9 @@ function enter(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -7090,7 +7214,7 @@ function enter(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass(el, startClass);
         addTransitionClass(el, activeClass);
-        nextFrame(function () {
+        nextFrame(() => {
             removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -7115,13 +7239,13 @@ function enter(vnode, toggleDisplay) {
     }
 }
 function leave(vnode, rm) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7129,24 +7253,14 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
         checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
-    var cb = (el._leaveCb = once(function () {
+    const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -7187,7 +7301,7 @@ function leave(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass(el, leaveClass);
             addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
+            nextFrame(() => {
                 removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -7212,11 +7326,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
     }
     else if (isNaN(val)) {
-        warn$2("<transition> explicit " + name + " duration is NaN - " +
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7234,7 +7348,7 @@ function getHookArgumentsLength(fn) {
         return false;
     }
     // @ts-expect-error
-    var invokerFns = fn.fns;
+    const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -7253,7 +7367,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove(vnode, rm) {
+        remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7270,8 +7384,8 @@ var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules$1 = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
+const modules$1 = platformModules.concat(baseModules);
+const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -7280,20 +7394,20 @@ var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 /* istanbul ignore if */
 if (isIE9) {
     // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-        var el = document.activeElement;
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
         // @ts-expect-error
         if (el && el.vmodel) {
             trigger(el, 'input');
         }
     });
 }
-var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', function () {
+                mergeVNodeHook(vnode, 'postpatch', () => {
                     directive.componentUpdated(el, binding, vnode);
                 });
             }
@@ -7319,20 +7433,20 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                 // trigger change event if
                 // no matching option found for at least one value
-                var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                     : binding.value !== binding.oldValue &&
                         hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
@@ -7346,23 +7460,23 @@ function setSelected(el, binding, vm) {
     actuallySetSelected(el, binding, vm);
     /* istanbul ignore if */
     if (isIE || isEdge) {
-        setTimeout(function () {
+        setTimeout(() => {
             actuallySetSelected(el, binding, vm);
         }, 0);
     }
 }
 function actuallySetSelected(el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
+    const value = binding.value;
+    const isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn$2("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+        warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
                     .call(value)
-                    .slice(8, -1)), vm);
+                    .slice(8, -1)}`, vm);
         return;
     }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
         option = el.options[i];
         if (isMultiple) {
             selected = looseIndexOf(value, getValue(option)) > -1;
@@ -7384,7 +7498,7 @@ function actuallySetSelected(el, binding, vm) {
     }
 }
 function hasNoMatchingOption(value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); });
+    return options.every((o) => !looseEqual(o, value));
 }
 function getValue(option) {
     return '_value' in option ? option._value : option.value;
@@ -7395,12 +7509,12 @@ function onCompositionStart(e) {
 function onCompositionEnd(e) {
     // prevent triggering an input event for no reason
     if (!e.target.composing)
-        { return; }
+        return;
     e.target.composing = false;
     trigger(e.target, 'input');
 }
 function trigger(el, type) {
-    var e = document.createEvent('HTMLEvents');
+    const e = document.createEvent('HTMLEvents');
     e.initEvent(type, true, true);
     el.dispatchEvent(e);
 }
@@ -7413,16 +7527,14 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind(el, { value }, vnode) {
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
         if (value && transition) {
             vnode.data.show = true;
-            enter(vnode, function () {
+            enter(vnode, () => {
                 el.style.display = originalDisplay;
             });
         }
@@ -7430,24 +7542,21 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update(el, { value, oldValue }, vnode) {
         /* istanbul ignore if */
         if (!value === !oldValue)
-            { return; }
+            return;
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
+        const transition = vnode.data && vnode.data.transition;
         if (transition) {
             vnode.data.show = true;
             if (value) {
-                enter(vnode, function () {
+                enter(vnode, () => {
                     el.style.display = el.__vOriginalDisplay;
                 });
             }
             else {
-                leave(vnode, function () {
+                leave(vnode, () => {
                     el.style.display = 'none';
                 });
             }
@@ -7456,7 +7565,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7465,11 +7574,11 @@ var show = {
 
 var platformDirectives = {
     model: directive,
-    show: show,
+    show,
 };
 
 // Provides transition support for a single element/component.
-var transitionProps = {
+const transitionProps = {
     name: String,
     appear: Boolean,
     css: Boolean,
@@ -7489,7 +7598,7 @@ var transitionProps = {
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
 function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
+    const compOptions = vnode && vnode.componentOptions;
     if (compOptions && compOptions.Ctor.options.abstract) {
         return getRealChild(getFirstComponentChild(compOptions.children));
     }
@@ -7498,17 +7607,17 @@ function getRealChild(vnode) {
     }
 }
 function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
+    const data = {};
+    const options = comp.$options;
     // props
-    for (var key in options.propsData) {
+    for (const key in options.propsData) {
         data[key] = comp[key];
     }
     // events.
     // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7530,16 +7639,14 @@ function hasParentTransition(vnode) {
 function isSameChild(child, oldChild) {
     return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-var isVShowDirective = function (d) { return d.name === 'show'; };
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
 var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
-        var children = this.$slots.default;
+    render(h) {
+        let children = this.$slots.default;
         if (!children) {
             return;
         }
@@ -7554,14 +7661,14 @@ var Transition = {
             warn$2('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
-        var mode = this.mode;
+        const mode = this.mode;
         // warn invalid mode
         if (mode &&
             mode !== 'in-out' &&
             mode !== 'out-in') {
             warn$2('invalid <transition> mode: ' + mode, this.$parent);
         }
-        var rawChild = children[0];
+        const rawChild = children[0];
         // if this is a component root node and the component's
         // parent container node also has transition, skip.
         if (hasParentTransition(this.$vnode)) {
@@ -7569,7 +7676,7 @@ var Transition = {
         }
         // apply transition data to child
         // use getRealChild() to ignore abstract components e.g. keep-alive
-        var child = getRealChild(rawChild);
+        const child = getRealChild(rawChild);
         /* istanbul ignore if */
         if (!child) {
             return rawChild;
@@ -7580,7 +7687,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        const id = `__transition-${this._uid}-`;
         child.key =
             child.key == null
                 ? child.isComment
@@ -7591,9 +7698,9 @@ var Transition = {
                         ? child.key
                         : id + child.key
                     : child.key;
-        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        var oldRawChild = this._vnode;
-        var oldChild = getRealChild(oldRawChild);
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
         // mark v-show
         // so that the transition module can hand over the control to the directive
         if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7608,14 +7715,14 @@ var Transition = {
                 oldChild.componentInstance._vnode.isComment)) {
             // replace old child transition data with fresh one
             // important for dynamic transitions!
-            var oldData = (oldChild.data.transition = extend({}, data));
+            const oldData = (oldChild.data.transition = extend({}, data));
             // handle transition mode
             if (mode === 'out-in') {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7623,13 +7730,13 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
-                var performLeave = function () {
+                let delayedLeave;
+                const performLeave = () => {
                     delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
                     delayedLeave = leave;
                 });
             }
@@ -7639,67 +7746,63 @@ var Transition = {
 };
 
 // Provides transition support for list items.
-var props = extend({
+const props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
-// @ts-ignore
 delete props.mode;
 var TransitionGroup = {
-    props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
-        var update = this._update;
-        this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            this.__patch__(this._vnode, this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            this._vnode = this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(this, vnode, hydrating);
         };
     },
-    render: function render(h) {
-        var tag = this.tag || this.$vnode.data.tag || 'span';
-        var map = Object.create(null);
-        var prevChildren = (this.prevChildren = this.children);
-        var rawChildren = this.$slots.default || [];
-        var children = (this.children = []);
-        var transitionData = extractTransitionData(this);
-        for (var i = 0; i < rawChildren.length; i++) {
-            var c = rawChildren[i];
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
             if (c.tag) {
-                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                     children.push(c);
                     map[c.key] = c;
                     (c.data || (c.data = {})).transition = transitionData;
                 }
                 else {
-                    var opts = c.componentOptions;
-                    var name = opts
-                        ? opts.Ctor.options.name || opts.tag || ''
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
                         : c.tag;
-                    warn$2(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn$2(`<transition-group> children must be keyed: <${name}>`);
                 }
             }
         }
         if (prevChildren) {
-            var kept = [];
-            var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
-                // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
-                // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7707,9 +7810,9 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
-        var children = this.prevChildren;
-        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -7722,13 +7825,12 @@ var TransitionGroup = {
         // assign to this to avoid being removed in tree-shaking
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
-        children.forEach(function (c) {
-            // @ts-ignore
+        children.forEach((c) => {
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
+                const el = c.elm;
+                const s = el.style;
                 addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
                 el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                     if (e && e.target !== el) {
                         return;
@@ -7743,7 +7845,7 @@ var TransitionGroup = {
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -7757,16 +7859,16 @@ var TransitionGroup = {
             // transition at this very moment, we make a clone of it and remove
             // all other transition classes applied to ensure only the move class
             // is applied.
-            var clone = el.cloneNode();
+            const clone = el.cloneNode();
             if (el._transitionClasses) {
-                el._transitionClasses.forEach(function (cls) {
+                el._transitionClasses.forEach((cls) => {
                     removeClass(clone, cls);
                 });
             }
             addClass(clone, moveClass);
-            clone.style.display = 'none';
+            clone.style.display = "none";
             this.$el.appendChild(clone);
-            var info = getTransitionInfo(clone);
+            const info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
             return (this._hasMove = info.hasTransform);
         },
@@ -7774,49 +7876,40 @@ var TransitionGroup = {
 };
 function callPendingCbs(c) {
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._moveCb) {
-        //@ts-ignore
         c.elm._moveCb();
     }
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._enterCb) {
-        //@ts-ignore
         c.elm._enterCb();
     }
 }
 function recordPosition(c) {
-    //@ts-ignore
     c.data.newPos = c.elm.getBoundingClientRect();
 }
 function applyTranslation(c) {
-    //@ts-ignore
-    var oldPos = c.data.pos;
-    //@ts-ignore
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
     if (dx || dy) {
-        //@ts-ignore
         c.data.moved = true;
-        //@ts-ignore
-        var s = c.elm.style;
-        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-        s.transitionDuration = '0s';
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
     }
 }
 
 var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
+    Transition,
+    TransitionGroup,
 };
 
 // install platform specific utils
-Vue.config.mustUseProp = mustUseProp$1;
-Vue.config.isReservedTag = isReservedTag$1;
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace$1;
+Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
@@ -7825,13 +7918,13 @@ extend(Vue.options.components, platformComponents);
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
 // public mount method
 Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query$1(el) : undefined;
+    el = el && inBrowser ? query(el) : undefined;
     return mountComponent(this, el, hydrating);
 };
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-    setTimeout(function () {
+    setTimeout(() => {
         if (config.devtools) {
             if (devtools) {
                 devtools.emit('init', Vue);
@@ -7845,99 +7938,30 @@ if (inBrowser) {
         if (config.productionTip !== false &&
             typeof console !== 'undefined') {
             // @ts-expect-error
-            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                "Make sure to turn on production mode when deploying for production.\n" +
-                "See more tips at https://vuejs.org/guide/deployment.html");
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
         }
     }, 0);
 }
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-makeMap('contenteditable,draggable,spellcheck');
-makeMap('events,caret,typing,plaintext-only');
-makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isPreTag = function (tag) { return tag === 'pre'; };
-var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        var selected = document.querySelector(el);
-        if (!selected) {
-            warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
     return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
 function parseText(text, delimiters) {
     //@ts-expect-error
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
     if (!tagRE.test(text)) {
         return;
     }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = (tagRE.lastIndex = 0);
-    var match, index, tokenValue;
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
     while ((match = tagRE.exec(text))) {
         index = match.index;
         // push text token
@@ -7946,8 +7970,8 @@ function parseText(text, delimiters) {
             tokens.push(JSON.stringify(tokenValue));
         }
         // tag token
-        var exp = parseFilters(match[1].trim());
-        tokens.push(("_s(" + exp + ")"));
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -7962,32 +7986,32 @@ function parseText(text, delimiters) {
 }
 
 function transformNode$1(el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
     if (staticClass) {
-        var res = parseText(staticClass, options.delimiters);
+        const res = parseText(staticClass, options.delimiters);
         if (res) {
-            warn("class=\"" + staticClass + "\": " +
+            warn(`class="${staticClass}": ` +
                 'Interpolation inside attributes has been removed. ' +
                 'Use v-bind or the colon shorthand instead. For example, ' +
                 'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
         }
     }
     if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass);
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
     }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
     if (classBinding) {
         el.classBinding = classBinding;
     }
 }
 function genData$2(el) {
-    var data = '';
+    let data = '';
     if (el.staticClass) {
-        data += "staticClass:" + (el.staticClass) + ",";
+        data += `staticClass:${el.staticClass},`;
     }
     if (el.classBinding) {
-        data += "class:" + (el.classBinding) + ",";
+        data += `class:${el.classBinding},`;
     }
     return data;
 }
@@ -7998,14 +8022,14 @@ var klass = {
 };
 
 function transformNode(el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
         /* istanbul ignore if */
         {
-            var res = parseText(staticStyle, options.delimiters);
+            const res = parseText(staticStyle, options.delimiters);
             if (res) {
-                warn("style=\"" + staticStyle + "\": " +
+                warn(`style="${staticStyle}": ` +
                     'Interpolation inside attributes has been removed. ' +
                     'Use v-bind or the colon shorthand instead. For example, ' +
                     'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
@@ -8013,44 +8037,44 @@ function transformNode(el, options) {
         }
         el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
     }
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
     if (styleBinding) {
         el.styleBinding = styleBinding;
     }
 }
 function genData$1(el) {
-    var data = '';
+    let data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + (el.staticStyle) + ",";
+        data += `staticStyle:${el.staticStyle},`;
     }
     if (el.styleBinding) {
-        data += "style:(" + (el.styleBinding) + "),";
+        data += `style:(${el.styleBinding}),`;
     }
     return data;
 }
 var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode,
+    transformNode,
     genData: genData$1,
 };
 
-var decoder;
+let decoder;
 var he = {
-    decode: function decode(html) {
+    decode(html) {
         decoder = decoder || document.createElement('div');
         decoder.innerHTML = html;
         return decoder.textContent;
     },
 };
 
-makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
     'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -8060,21 +8084,21 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
  * Not type-checking this file because it's mostly vendor code.
  */
 // Regular Expressions for parsing tags and attributes
-var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
-var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-var doctype = /^<!DOCTYPE [^>]+>/i;
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/;
-var conditionalComment = /^<!\[/;
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
 // Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true);
-var reCache = {};
-var decodingMap = {
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
     '&lt;': '<',
     '&gt;': '>',
     '&quot;': '"',
@@ -8083,31 +8107,31 @@ var decodingMap = {
     '&#9;': '\t',
     '&#39;': "'",
 };
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
 function decodeAttr(value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; });
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
 }
 function parseHTML(html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag = options.isUnaryTag || no;
-    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
     while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
-            var textEnd = html.indexOf('<');
+            let textEnd = html.indexOf('<');
             if (textEnd === 0) {
                 // Comment:
                 if (comment.test(html)) {
-                    var commentEnd = html.indexOf('-->');
+                    const commentEnd = html.indexOf('-->');
                     if (commentEnd >= 0) {
                         if (options.shouldKeepComment) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
@@ -8118,28 +8142,28 @@ function parseHTML(html, options) {
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
                 if (conditionalComment.test(html)) {
-                    var conditionalEnd = html.indexOf(']>');
+                    const conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
                         continue;
                     }
                 }
                 // Doctype:
-                var doctypeMatch = html.match(doctype);
+                const doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
                     continue;
                 }
                 // End tag:
-                var endTagMatch = html.match(endTag);
+                const endTagMatch = html.match(endTag);
                 if (endTagMatch) {
-                    var curIndex = index;
+                    const curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
                     continue;
                 }
                 // Start tag:
-                var startTagMatch = parseStartTag();
+                const startTagMatch = parseStartTag();
                 if (startTagMatch) {
                     handleStartTag(startTagMatch);
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
@@ -8148,7 +8172,7 @@ function parseHTML(html, options) {
                     continue;
                 }
             }
-            var text = (void 0), rest = (void 0), next = (void 0);
+            let text, rest, next;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8158,7 +8182,7 @@ function parseHTML(html, options) {
                     // < in plain text, be forgiving and treat it as text
                     next = rest.indexOf('<', 1);
                     if (next < 0)
-                        { break; }
+                        break;
                     textEnd += next;
                     rest = html.slice(textEnd);
                 }
@@ -8175,11 +8199,11 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength = 0;
-            var stackedTag = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag] ||
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
                 (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
                 endTagLength = endTag.length;
                 if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
@@ -8194,15 +8218,15 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest$1.length;
-            html = rest$1;
+            index += html.length - rest.length;
+            html = rest;
             parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
             options.chars && options.chars(html);
             if (!stack.length &&
                 options.warn) {
-                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
                     start: index + html.length,
                 });
             }
@@ -8216,15 +8240,15 @@ function parseHTML(html, options) {
         html = html.substring(n);
     }
     function parseStartTag() {
-        var start = html.match(startTagOpen);
+        const start = html.match(startTagOpen);
         if (start) {
-            var match = {
+            const match = {
                 tagName: start[1],
                 attrs: [],
                 start: index,
             };
             advance(start[0].length);
-            var end, attr;
+            let end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8241,8 +8265,8 @@ function parseHTML(html, options) {
         }
     }
     function handleStartTag(match) {
-        var tagName = match.tagName;
-        var unarySlash = match.unarySlash;
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
         if (expectHTML) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
@@ -8251,13 +8275,13 @@ function parseHTML(html, options) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag(tagName) || !!unarySlash;
-        var l = match.attrs.length;
-        var attrs = new Array(l);
-        for (var i = 0; i < l; i++) {
-            var args = match.attrs[i];
-            var value = args[3] || args[4] || args[5] || '';
-            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
                 ? options.shouldDecodeNewlinesForHref
                 : options.shouldDecodeNewlines;
             attrs[i] = {
@@ -8284,11 +8308,11 @@ function parseHTML(html, options) {
         }
     }
     function parseEndTag(tagName, start, end) {
-        var pos, lowerCasedTagName;
+        let pos, lowerCasedTagName;
         if (start == null)
-            { start = index; }
+            start = index;
         if (end == null)
-            { end = index; }
+            end = index;
         // Find the closest opened tag of the same type
         if (tagName) {
             lowerCasedTagName = tagName.toLowerCase();
@@ -8304,10 +8328,10 @@ function parseHTML(html, options) {
         }
         if (pos >= 0) {
             // Close all the open elements, up the stack
-            for (var i = stack.length - 1; i >= pos; i--) {
+            for (let i = stack.length - 1; i >= pos; i--) {
                 if ((i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8336,39 +8360,39 @@ function parseHTML(html, options) {
     }
 }
 
-var onRE = /^@|^v-on:/;
-var dirRE = /^v-|^@|^:|^#/;
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-var stripParensRE = /^\(|\)$/g;
-var dynamicArgRE = /^\[.*\]$/;
-var argRE = /:(.*)$/;
-var bindRE = /^:|^\.|^v-bind:/;
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-var slotRE = /^v-slot(:|$)|^#/;
-var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /[ \f\t\r\n]+/g;
-var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(he.decode);
-var emptySlotScopeToken = "_empty_";
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he.decode);
+const emptySlotScopeToken = `_empty_`;
 // configurable state
-var warn$1;
-var delimiters;
-var transforms;
-var preTransforms;
-var postTransforms;
-var platformIsPreTag;
-var platformMustUseProp;
-var platformGetTagNamespace;
-var maybeComponent;
+let warn;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
 function createASTElement(tag, attrs, parent) {
     return {
         type: 1,
-        tag: tag,
+        tag,
         attrsList: attrs,
         attrsMap: makeAttrsMap(attrs),
         rawAttrsMap: {},
-        parent: parent,
+        parent,
         children: [],
     };
 }
@@ -8376,31 +8400,31 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
+    warn = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!(el.component ||
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
         el.attrsMap[':is'] ||
         el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
     delimiters = options.delimiters;
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn$1(msg, range);
+            warn(msg, range);
         }
     }
     function closeElement(element) {
@@ -8421,9 +8445,9 @@ function parse(template, options) {
                 });
             }
             else {
-                warnOnce("Component template should contain exactly one root element. " +
-                    "If you are using v-if on multiple elements, " +
-                    "use v-else-if to chain them instead.", { start: element.start });
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
             }
         }
         if (currentParent && !element.forbidden) {
@@ -8435,7 +8459,7 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name = element.slotTarget || '"default"';
+                    const name = element.slotTarget || '"default"';
                     (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
@@ -8444,7 +8468,7 @@ function parse(template, options) {
         }
         // final children cleanup
         // filter out scoped slots
-        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        element.children = element.children.filter((c) => !c.slotScope);
         // remove trailing whitespace node again
         trimEndingWhitespace(element);
         // check pre state
@@ -8455,14 +8479,14 @@ function parse(template, options) {
             inPre = false;
         }
         // apply post-transforms
-        for (var i = 0; i < postTransforms.length; i++) {
+        for (let i = 0; i < postTransforms.length; i++) {
             postTransforms[i](element, options);
         }
     }
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode;
+            let lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8472,7 +8496,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8481,7 +8505,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn$1,
+        warn,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8489,33 +8513,33 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function start(tag, attrs, unary, start$1, end) {
+        start(tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
-            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
             // handle IE svg bug
             /* istanbul ignore if */
             if (isIE && ns === 'svg') {
                 attrs = guardIESVGBug(attrs);
             }
-            var element = createASTElement(tag, attrs, currentParent);
+            let element = createASTElement(tag, attrs, currentParent);
             if (ns) {
                 element.ns = ns;
             }
             {
                 if (options.outputSourceRange) {
-                    element.start = start$1;
+                    element.start = start;
                     element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
                         cumulated[attr.name] = attr;
                         return cumulated;
                     }, {});
                 }
-                attrs.forEach(function (attr) {
+                attrs.forEach((attr) => {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
-                            "spaces, quotes, <, >, / or =.", {
-                            start: attr.start + attr.name.indexOf("["),
+                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
                             end: attr.start + attr.name.length,
                         });
                     }
@@ -8523,13 +8547,13 @@ function parse(template, options) {
             }
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
-                warn$1('Templates should only be responsible for mapping the state to the ' +
+                warn('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        "<" + tag + ">" +
+                        `<${tag}>` +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
-            for (var i = 0; i < preTransforms.length; i++) {
+            for (let i = 0; i < preTransforms.length; i++) {
                 element = preTransforms[i](element, options) || element;
             }
             if (!inVPre) {
@@ -8564,25 +8588,25 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function end(tag, start, end$1) {
-            var element = stack[stack.length - 1];
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (options.outputSourceRange) {
-                element.end = end$1;
+                element.end = end;
             }
             closeElement(element);
         },
-        chars: function chars(text, start, end) {
+        chars(text, start, end) {
             if (!currentParent) {
                 {
                     if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
-                            start: start,
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
                         });
                     }
                 }
@@ -8595,7 +8619,7 @@ function parse(template, options) {
                 currentParent.attrsMap.placeholder === text) {
                 return;
             }
-            var children = currentParent.children;
+            const children = currentParent.children;
             if (inPre || text.trim()) {
                 text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
             }
@@ -8621,14 +8645,14 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res;
-                var child;
+                let res;
+                let child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
                         expression: res.expression,
                         tokens: res.tokens,
-                        text: text,
+                        text,
                     };
                 }
                 else if (text !== ' ' ||
@@ -8636,7 +8660,7 @@ function parse(template, options) {
                     children[children.length - 1].text !== ' ') {
                     child = {
                         type: 3,
-                        text: text,
+                        text,
                     };
                 }
                 if (child) {
@@ -8648,13 +8672,13 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function comment(text, start, end) {
+        comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
-                var child = {
+                const child = {
                     type: 3,
-                    text: text,
+                    text,
                     isComment: true,
                 };
                 if (options.outputSourceRange) {
@@ -8673,11 +8697,11 @@ function processPre(el) {
     }
 }
 function processRawAttrs(el) {
-    var list = el.attrsList;
-    var len = list.length;
+    const list = el.attrsList;
+    const len = list.length;
     if (len) {
-        var attrs = (el.attrs = new Array(len));
-        for (var i = 0; i < len; i++) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
             attrs[i] = {
                 name: list[i].name,
                 value: JSON.stringify(list[i].value),
@@ -8703,28 +8727,28 @@ function processElement(element, options) {
     processSlotContent(element);
     processSlotOutlet(element);
     processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
+    for (let i = 0; i < transforms.length; i++) {
         element = transforms[i](element, options) || element;
     }
     processAttrs(element);
     return element;
 }
 function processKey(el) {
-    var exp = getBindingAttr(el, 'key');
+    const exp = getBindingAttr(el, 'key');
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
-                var iterator = el.iterator2 || el.iterator1;
-                var parent = el.parent;
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
                     parent &&
                     parent.tag === 'transition-group') {
-                    warn$1("Do not use v-for index as key on <transition-group> children, " +
-                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                    warn(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
         }
@@ -8732,32 +8756,32 @@ function processKey(el) {
     }
 }
 function processRef(el) {
-    var ref = getBindingAttr(el, 'ref');
+    const ref = getBindingAttr(el, 'ref');
     if (ref) {
         el.ref = ref;
         el.refInFor = checkInFor(el);
     }
 }
 function processFor(el) {
-    var exp;
+    let exp;
     if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        var res = parseFor(exp);
+        const res = parseFor(exp);
         if (res) {
             extend(el, res);
         }
         else {
-            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
         }
     }
 }
 function parseFor(exp) {
-    var inMatch = exp.match(forAliasRE);
+    const inMatch = exp.match(forAliasRE);
     if (!inMatch)
-        { return; }
-    var res = {};
+        return;
+    const res = {};
     res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
     if (iteratorMatch) {
         res.alias = alias.replace(forIteratorRE, '').trim();
         res.iterator1 = iteratorMatch[1].trim();
@@ -8771,7 +8795,7 @@ function parseFor(exp) {
     return res;
 }
 function processIf(el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
+    const exp = getAndRemoveAttr(el, 'v-if');
     if (exp) {
         el.if = exp;
         addIfCondition(el, {
@@ -8783,14 +8807,14 @@ function processIf(el) {
         if (getAndRemoveAttr(el, 'v-else') != null) {
             el.else = true;
         }
-        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
         if (elseif) {
             el.elseif = elseif;
         }
     }
 }
 function processIfConditions(el, parent) {
-    var prev = findPrevElement(parent.children);
+    const prev = findPrevElement(parent.children);
     if (prev && prev.if) {
         addIfCondition(prev, {
             exp: el.elseif,
@@ -8798,20 +8822,20 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
-    var i = children.length;
+    let i = children.length;
     while (i--) {
         if (children[i].type === 1) {
             return children[i];
         }
         else {
             if (children[i].text !== ' ') {
-                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-                    "will be ignored.", children[i]);
+                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
             }
             children.pop();
         }
@@ -8824,7 +8848,7 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once = getAndRemoveAttr(el, 'v-once');
+    const once = getAndRemoveAttr(el, 'v-once');
     if (once != null) {
         el.once = true;
     }
@@ -8832,29 +8856,29 @@ function processOnce(el) {
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
 function processSlotContent(el) {
-    var slotScope;
+    let slotScope;
     if (el.tag === 'template') {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
-                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-                "can also be used on plain elements in addition to <template> to " +
-                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
         }
         el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
     }
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-                "(v-for takes higher priority). Use a wrapper <template> for the " +
-                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
         }
         el.slotScope = slotScope;
     }
     // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
+    const slotTarget = getBindingAttr(el, 'slot');
     if (slotTarget) {
         el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
         el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
@@ -8868,20 +8892,18 @@ function processSlotContent(el) {
     {
         if (el.tag === 'template') {
             // v-slot on <template>
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1("<template v-slot> can only appear at the root level inside " +
-                            "the receiving component", el);
+                        warn(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
                     }
                 }
-                var ref = getSlotName(slotBinding);
-                var name = ref.name;
-                var dynamic = ref.dynamic;
+                const { name, dynamic } = getSlotName(slotBinding);
                 el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
@@ -8889,35 +8911,33 @@ function processSlotContent(el) {
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding$1) {
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.scopedSlots) {
-                        warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding$1);
+                        warn(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
                     }
                 }
                 // add the component's children to its default slot
-                var slots = el.scopedSlots || (el.scopedSlots = {});
-                var ref$1 = getSlotName(slotBinding$1);
-                var name$1 = ref$1.name;
-                var dynamic$1 = ref$1.dynamic;
-                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name$1;
-                slotContainer.slotTargetDynamic = dynamic$1;
-                slotContainer.children = el.children.filter(function (c) {
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
                     if (!c.slotScope) {
                         c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -8927,34 +8947,34 @@ function processSlotContent(el) {
     }
 }
 function getSlotName(binding) {
-    var name = binding.name.replace(slotRE, '');
+    let name = binding.name.replace(slotRE, '');
     if (!name) {
         if (binding.name[0] !== '#') {
             name = 'default';
         }
         else {
-            warn$1("v-slot shorthand syntax requires a slot name.", binding);
+            warn(`v-slot shorthand syntax requires a slot name.`, binding);
         }
     }
     return dynamicArgRE.test(name)
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: ("\"" + name + "\""), dynamic: false };
+            { name: `"${name}"`, dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
-                "and can possibly expand into multiple elements. " +
-                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
         }
     }
 }
 function processComponent(el) {
-    var binding;
+    let binding;
     if ((binding = getBindingAttr(el, 'is'))) {
         el.component = binding;
     }
@@ -8963,8 +8983,8 @@ function processComponent(el) {
     }
 }
 function processAttrs(el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
     for (i = 0, l = list.length; i < l; i++) {
         name = rawName = list[i].name;
         value = list[i].value;
@@ -8986,28 +9006,28 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
                         name = camelize(name);
                         if (name === 'innerHtml')
-                            { name = 'innerHTML'; }
+                            name = 'innerHTML';
                     }
                     if (modifiers.camel && !isDynamic) {
                         name = camelize(name);
                     }
                     if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, "$event");
+                        syncGen = genAssignmentCode(value, `$event`);
                         if (!isDynamic) {
-                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
                             );
                         }
                     }
@@ -9027,14 +9047,14 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
             }
             else {
                 // normal directives
                 name = name.replace(dirRE, '');
                 // parse arg
-                var argMatch = name.match(argRE);
-                var arg = argMatch && argMatch[1];
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
                 isDynamic = false;
                 if (arg) {
                     name = name.slice(0, -(arg.length + 1));
@@ -9052,9 +9072,9 @@ function processAttrs(el) {
         else {
             // literal attribute
             {
-                var res = parseText(value, delimiters);
+                const res = parseText(value, delimiters);
                 if (res) {
-                    warn$1(name + "=\"" + value + "\": " +
+                    warn(`${name}="${value}": ` +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9072,7 +9092,7 @@ function processAttrs(el) {
     }
 }
 function checkInFor(el) {
-    var parent = el;
+    let parent = el;
     while (parent) {
         if (parent.for !== undefined) {
             return true;
@@ -9082,22 +9102,22 @@ function checkInFor(el) {
     return false;
 }
 function parseModifiers(name) {
-    var match = name.match(modifierRE);
+    const match = name.match(modifierRE);
     if (match) {
-        var ret = {};
-        match.forEach(function (m) {
+        const ret = {};
+        match.forEach((m) => {
             ret[m.slice(1)] = true;
         });
         return ret;
     }
 }
 function makeAttrsMap(attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9112,13 +9132,13 @@ function isForbiddenTag(el) {
         (el.tag === 'script' &&
             (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-var ieNSBug = /^xmlns:NS\d+/;
-var ieNSPrefix = /^NS\d+:/;
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
 /* istanbul ignore next */
 function guardIESVGBug(attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-        var attr = attrs[i];
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
         if (!ieNSBug.test(attr.name)) {
             attr.name = attr.name.replace(ieNSPrefix, '');
             res.push(attr);
@@ -9127,14 +9147,14 @@ function guardIESVGBug(attrs) {
     return res;
 }
 function checkForAliasModel(el, value) {
-    var _el = el;
+    let _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-                "You are binding v-model directly to a v-for iteration alias. " +
-                "This will not be able to modify the v-for source array because " +
-                "writing to the alias is like modifying a function local variable. " +
-                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+            warn(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
         }
         _el = _el.parent;
     }
@@ -9151,45 +9171,45 @@ function checkForAliasModel(el, value) {
  */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
-        var map = el.attrsMap;
+        const map = el.attrsMap;
         if (!map['v-model']) {
             return;
         }
-        var typeBinding;
+        let typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + (map['v-bind']) + ").type";
+            typeBinding = `(${map['v-bind']}).type`;
         }
         if (typeBinding) {
-            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
-            var branch0 = cloneASTElement(el);
+            const branch0 = cloneASTElement(el);
             // process for on the main node
             processFor(branch0);
             addRawAttr(branch0, 'type', 'checkbox');
             processElement(branch0, options);
             branch0.processed = true; // prevent it from double-processed
-            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
             addIfCondition(branch0, {
                 exp: branch0.if,
                 block: branch0,
             });
             // 2. add radio else-if condition
-            var branch1 = cloneASTElement(el);
+            const branch1 = cloneASTElement(el);
             getAndRemoveAttr(branch1, 'v-for', true);
             addRawAttr(branch1, 'type', 'radio');
             processElement(branch1, options);
             addIfCondition(branch0, {
-                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
                 block: branch1,
             });
             // 3. other
-            var branch2 = cloneASTElement(el);
+            const branch2 = cloneASTElement(el);
             getAndRemoveAttr(branch2, 'v-for', true);
             addRawAttr(branch2, ':type', typeBinding);
             processElement(branch2, options);
@@ -9210,184 +9230,46 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model$1 = {
-    preTransformNode: preTransformNode,
+var model = {
+    preTransformNode,
 };
 
-var modules = [klass, style, model$1];
-
-var warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        "?_i(" + value + "," + valueBinding + ")>-1" +
-        (trueValueBinding === 'true'
-            ? (":(" + value + ")")
-            : (":_q(" + value + "," + trueValueBinding + ")")));
-    addHandler(el, 'change', "var $$a=" + value + "," +
-        '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-        'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-        '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-        ".call($event.target.options,function(o){return o.selected})" +
-        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        "return " + (number ? '_n(val)' : 'val') + "})";
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value$1 && !typeBinding) {
-            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    var valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
-    }
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = "if($event.target.composing)return;" + code;
-    }
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
+var modules = [klass, style, model];
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
     }
 }
 
 var directives = {
-    model: model,
-    text: text,
-    html: html,
+    model: model$1,
+    text,
+    html,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-var baseOptions = {
+const baseOptions = {
     expectHTML: true,
-    modules: modules,
-    directives: directives,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    // @ts-ignore
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
     staticKeys: genStaticKeys$1(modules),
 };
 
-var isStaticKey;
-var isPlatformReservedTag;
-var genStaticKeysCached = cached(genStaticKeys);
+let isStaticKey;
+let isPlatformReservedTag;
+const genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -9401,7 +9283,7 @@ var genStaticKeysCached = cached(genStaticKeys);
  */
 function optimize(root, options) {
     if (!root)
-        { return; }
+        return;
     isStaticKey = genStaticKeysCached(options.staticKeys || '');
     isPlatformReservedTag = options.isReservedTag || no;
     // first pass: mark all non-static nodes.
@@ -9424,16 +9306,16 @@ function markStatic(node) {
             node.attrsMap['inline-template'] == null) {
             return;
         }
-        for (var i = 0, l = node.children.length; i < l; i++) {
-            var child = node.children[i];
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
             markStatic(child);
             if (!child.static) {
                 node.static = false;
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -9460,13 +9342,13 @@ function markStaticRoots(node, isInFor) {
             node.staticRoot = false;
         }
         if (node.children) {
-            for (var i = 0, l = node.children.length; i < l; i++) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
                 markStaticRoots(node.children[i], isInFor || !!node.for);
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
     }
@@ -9502,11 +9384,11 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-var fnInvokeRE = /\([^)]*?\);*$/;
-var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
 // KeyboardEvent.keyCode aliases
-var keyCodes = {
+const keyCodes = {
     esc: 27,
     tab: 9,
     enter: 13,
@@ -9518,7 +9400,7 @@ var keyCodes = {
     delete: [8, 46],
 };
 // KeyboardEvent.key aliases
-var keyNames = {
+const keyNames = {
     // #7880: IE11 and Edge use `Esc` for Escape key name.
     esc: ['Esc', 'Escape'],
     tab: 'Tab',
@@ -9536,36 +9418,36 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-var modifierCode = {
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2"),
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
 };
 function genHandlers(events, isNative) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-        var handlerCode = genHandler(events[name]);
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
         //@ts-expect-error
         if (events[name] && events[name].dynamic) {
-            dynamicHandlers += name + "," + handlerCode + ",";
+            dynamicHandlers += `${name},${handlerCode},`;
         }
         else {
-            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+            staticHandlers += `"${name}":${handlerCode},`;
         }
     }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
     if (dynamicHandlers) {
-        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
     }
     else {
         return prefix + staticHandlers;
@@ -9576,22 +9458,22 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
     }
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
     if (!handler.modifiers) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
     }
     else {
-        var code = '';
-        var genModifierCode = '';
-        var keys = [];
-        for (var key in handler.modifiers) {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -9600,10 +9482,10 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers = handler.modifiers;
+                const modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
                     .join('||'));
             }
             else {
@@ -9617,14 +9499,14 @@ function genHandler(handler) {
         if (genModifierCode) {
             code += genModifierCode;
         }
-        var handlerCode = isMethodPath
-            ? ("return " + (handler.value) + ".apply(null, arguments)")
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
             : isFunctionExpression
-                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                ? `return (${handler.value}).apply(null, arguments)`
                 : isFunctionInvocation
-                    ? ("return " + (handler.value))
+                    ? `return ${handler.value}`
                     : handler.value;
-        return ("function($event){" + code + handlerCode + "}");
+        return `function($event){${code}${handlerCode}}`;
     }
 }
 function genKeyFilter(keys) {
@@ -9632,66 +9514,77 @@ function genKeyFilter(keys) {
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&')) + ")return null;");
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
 }
 function genFilterCode(key) {
-    var keyVal = parseInt(key, 10);
+    const keyVal = parseInt(key, 10);
     if (keyVal) {
-        return ("$event.keyCode!==" + keyVal);
+        return `$event.keyCode!==${keyVal}`;
     }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return ("_k($event.keyCode," +
-        (JSON.stringify(key)) + "," +
-        (JSON.stringify(keyCode)) + "," +
-        "$event.key," +
-        "" + (JSON.stringify(keyName)) +
-        ")");
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
 function on(el, dir) {
     if (dir.modifiers) {
-        warn$2("v-on without argument does not support modifiers.");
+        warn$2(`v-on without argument does not support modifiers.`);
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
 function bind(el, dir) {
-    el.wrapData = function (code) {
-        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
     };
 }
 
 var baseDirectives = {
-    on: on,
-    bind: bind,
+    on,
+    bind,
     cloak: noop,
 };
 
-var CodegenState = function CodegenState(options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-};
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
 function generate(ast, options) {
-    var state = new CodegenState(options);
+    const state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
-    var code = ast
+    const code = ast
         ? ast.tag === 'script'
             ? 'null'
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: `with(this){return ${code}}`,
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -9719,20 +9612,22 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code;
+        let code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data;
+            let data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
-            var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
         }
         // module transforms
-        for (var i = 0; i < state.transforms.length; i++) {
+        for (let i = 0; i < state.transforms.length; i++) {
             code = state.transforms[i](el, code);
         }
         return code;
@@ -9744,13 +9639,13 @@ function genStatic(el, state) {
     // Some elements (templates) need to behave differently inside of a v-pre
     // node.  All pre nodes are static roots, so we can use this as a location to
     // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
+    const originalPreState = state.pre;
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
     state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
 }
 // v-once
 function genOnce(el, state) {
@@ -9759,8 +9654,8 @@ function genOnce(el, state) {
         return genIf(el, state);
     }
     else if (el.staticInFor) {
-        var key = '';
-        var parent = el.parent;
+        let key = '';
+        let parent = el.parent;
         while (parent) {
             if (parent.for) {
                 key = parent.key;
@@ -9769,10 +9664,10 @@ function genOnce(el, state) {
             parent = parent.parent;
         }
         if (!key) {
-            state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
     }
     else {
         return genStatic(el, state);
@@ -9786,12 +9681,12 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     if (!conditions.length) {
         return altEmpty || '_e()';
     }
-    var condition = conditions.shift();
+    const condition = conditions.shift();
     if (condition.exp) {
-        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
     }
     else {
-        return ("" + (genTernaryExp(condition.block)));
+        return `${genTernaryExp(condition.block)}`;
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -9803,87 +9698,87 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
 }
 function genFor(el, state, altGen, altHelper) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
     if (state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-            "v-for should have explicit keys. " +
-            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
-    return ((altHelper || '_l') + "((" + exp + ")," +
-        "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
         '})');
 }
 function genData(el, state) {
-    var data = '{';
+    let data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
+    const dirs = genDirectives(el, state);
     if (dirs)
-        { data += dirs + ','; }
+        data += dirs + ',';
     // key
     if (el.key) {
-        data += "key:" + (el.key) + ",";
+        data += `key:${el.key},`;
     }
     // ref
     if (el.ref) {
-        data += "ref:" + (el.ref) + ",";
+        data += `ref:${el.ref},`;
     }
     if (el.refInFor) {
-        data += "refInFor:true,";
+        data += `refInFor:true,`;
     }
     // pre
     if (el.pre) {
-        data += "pre:true,";
+        data += `pre:true,`;
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + (el.tag) + "\",";
+        data += `tag:"${el.tag}",`;
     }
     // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
+    for (let i = 0; i < state.dataGenFns.length; i++) {
         data += state.dataGenFns[i](el);
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + (genProps(el.attrs)) + ",";
+        data += `attrs:${genProps(el.attrs)},`;
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + (genProps(el.props)) + ",";
+        data += `domProps:${genProps(el.props)},`;
     }
     // event handlers
     if (el.events) {
-        data += (genHandlers(el.events, false)) + ",";
+        data += `${genHandlers(el.events, false)},`;
     }
     if (el.nativeEvents) {
-        data += (genHandlers(el.nativeEvents, true)) + ",";
+        data += `${genHandlers(el.nativeEvents, true)},`;
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + (el.slotTarget) + ",";
+        data += `slot:${el.slotTarget},`;
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
     }
     // inline-template
     if (el.inlineTemplate) {
-        var inlineTemplate = genInlineTemplate(el, state);
+        const inlineTemplate = genInlineTemplate(el, state);
         if (inlineTemplate) {
-            data += inlineTemplate + ",";
+            data += `${inlineTemplate},`;
         }
     }
     data = data.replace(/,$/, '') + '}';
@@ -9891,7 +9786,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -9904,16 +9799,16 @@ function genData(el, state) {
     return data;
 }
 function genDirectives(el, state) {
-    var dirs = el.directives;
+    const dirs = el.directives;
     if (!dirs)
-        { return; }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
     for (i = 0, l = dirs.length; i < l; i++) {
         dir = dirs[i];
         needRuntime = true;
-        var gen = state.directives[dir.name];
+        const gen = state.directives[dir.name];
         if (gen) {
             // compile-time directive that manipulates AST.
             // returns true if it also needs a runtime counterpart.
@@ -9921,9 +9816,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
         }
     }
     if (hasRuntime) {
@@ -9931,15 +9826,15 @@ function genDirectives(el, state) {
     }
 }
 function genInlineTemplate(el, state) {
-    var ast = el.children[0];
+    const ast = el.children[0];
     if ((el.children.length !== 1 || ast.type !== 1)) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
-        var inlineRenderFns = generate(ast, state.options);
-        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-            .map(function (code) { return ("function(){" + code + "}"); })
-            .join(',')) + "]}");
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -9947,9 +9842,9 @@ function genScopedSlots(el, slots, state) {
     // components with only scoped slots to skip forced updates from parent.
     // but in some cases we have to bail-out of this optimization
     // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for ||
-        Object.keys(slots).some(function (key) {
-            var slot = slots[key];
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
             return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
             );
         });
@@ -9957,14 +9852,14 @@ function genScopedSlots(el, slots, state) {
     // it's possible for the same component to be reused but with different
     // compiled slot content. To avoid that, we generate a unique key based on
     // the generated code of all the slot contents.
-    var needsKey = !!el.if;
+    let needsKey = !!el.if;
     // OR when it is inside another scoped slot or v-for (the reactivity may be
     // disconnected due to the intermediate scope variable)
     // #9438, #9506
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent = el.parent;
+        let parent = el.parent;
         while (parent) {
             if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
                 parent.for) {
@@ -9977,14 +9872,14 @@ function genScopedSlots(el, slots, state) {
             parent = parent.parent;
         }
     }
-    var generatedSlots = Object.keys(slots)
-        .map(function (key) { return genScopedSlot(slots[key], state); })
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
         .join(',');
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
 }
 function hash(str) {
-    var hash = 5381;
-    var i = str.length;
+    let hash = 5381;
+    let i = str.length;
     while (i) {
         hash = (hash * 33) ^ str.charCodeAt(--i);
     }
@@ -10000,45 +9895,45 @@ function containsSlotChild(el) {
     return false;
 }
 function genScopedSlot(el, state) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
+    const isLegacySyntax = el.attrsMap['slot-scope'];
     if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, "null");
+        return genIf(el, state, genScopedSlot, `null`);
     }
     if (el.for && !el.forProcessed) {
         return genFor(el, state, genScopedSlot);
     }
-    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-        "return " + (el.tag === 'template'
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}";
+            : genElement(el, state)}}`;
     // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    var children = el.children;
+    const children = el.children;
     if (children.length) {
-        var el$1 = children[0];
+        const el = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el$1.for &&
-            el$1.tag !== 'template' &&
-            el$1.tag !== 'slot') {
-            var normalizationType = checkSkip
-                ? state.maybeComponent(el$1)
-                    ? ",1"
-                    : ",0"
-                : "";
-            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
-        }
-        var normalizationType$1 = checkSkip
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen = altGenNode || genNode;
-        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
     }
 }
 // determine the normalization needed for the children array.
@@ -10046,20 +9941,20 @@ function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
 function getNormalizationType(children, maybeComponent) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-        var el = children[i];
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
         if (el.type !== 1) {
             continue;
         }
         if (needsNormalization(el) ||
             (el.ifConditions &&
-                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
             res = 2;
             break;
         }
         if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
             res = 1;
         }
     }
@@ -10080,58 +9975,58 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return ("_v(" + (text.type === 2
+    return `_v(${text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
 }
 function genComment(comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+    return `_e(${JSON.stringify(comment.text)})`;
 }
 function genSlot(el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
-    var attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
             // slot props are camelized
             name: camelize(attr.name),
             value: attr.value,
-            dynamic: attr.dynamic,
-        }); }))
+            dynamic: attr.dynamic
+        })))
         : null;
-    var bind = el.attrsMap['v-bind'];
+    const bind = el.attrsMap['v-bind'];
     if ((attrs || bind) && !children) {
-        res += ",null";
+        res += `,null`;
     }
     if (attrs) {
-        res += "," + attrs;
+        res += `,${attrs}`;
     }
     if (bind) {
-        res += (attrs ? '' : ',null') + "," + bind;
+        res += `${attrs ? '' : ',null'},${bind}`;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
 }
 function genProps(props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-        var prop = props[i];
-        var value = transformSpecialNewlines(prop.value);
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += (prop.name) + "," + value + ",";
+            dynamicProps += `${prop.name},${value},`;
         }
         else {
-            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+            staticProps += `"${prop.name}":${value},`;
         }
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    staticProps = `{${staticProps.slice(0, -1)}}`;
     if (dynamicProps) {
-        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
     }
     else {
         return staticProps;
@@ -10144,7 +10039,7 @@ function transformSpecialNewlines(text) {
 
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' +
+const prohibitedKeywordRE = new RegExp('\\b' +
     ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
         'super,throw,while,yield,delete,export,import,return,switch,default,' +
         'extends,finally,continue,debugger,function,arguments')
@@ -10152,11 +10047,11 @@ var prohibitedKeywordRE = new RegExp('\\b' +
         .join('\\b|\\b') +
     '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' +
+const unaryOperatorsRE = new RegExp('\\b' +
     'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
     '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
-var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
 // detect problematic expressions in a template
 function detectErrors(ast, warn) {
     if (ast) {
@@ -10165,28 +10060,28 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name in node.attrsMap) {
+        for (const name in node.attrsMap) {
             if (dirRE.test(name)) {
-                var value = node.attrsMap[name];
+                const value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name];
+                    const range = node.rawAttrsMap[name];
                     if (name === 'v-for') {
-                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                        checkFor(node, `v-for="${value}"`, warn, range);
                     }
                     else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
                     }
                     else if (onRE.test(name)) {
-                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                        checkEvent(value, `${name}="${value}"`, warn, range);
                     }
                     else {
-                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkExpression(value, `${name}="${value}"`, warn, range);
                     }
                 }
             }
         }
         if (node.children) {
-            for (var i = 0; i < node.children.length; i++) {
+            for (let i = 0; i < node.children.length; i++) {
                 checkNode(node.children[i], warn);
             }
         }
@@ -10196,11 +10091,11 @@ function checkNode(node, warn) {
     }
 }
 function checkEvent(exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn("avoid using JavaScript unary operator as property name: " +
-            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10213,29 +10108,29 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(("var " + ident + "=_"));
+            new Function(`var ${ident}=_`);
         }
         catch (e) {
-            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(("return " + exp));
+        new Function(`return ${exp}`);
     }
     catch (e) {
-        var keywordMatch = exp
+        const keywordMatch = exp
             .replace(stripStringRE, '')
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
-            warn("avoid using JavaScript keyword as property name: " +
-                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
         }
         else {
-            warn("invalid expression: " + (e.message) + " in\n\n" +
-                "    " + exp + "\n\n" +
-                "  Raw expression: " + (text.trim()) + "\n", range);
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
         }
     }
 }
@@ -10244,38 +10139,35 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-            "    " + exp + "\n\n" +
-            "  Raw expression: " + (text.trim()) + "\n", range);
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
     }
 }
 
-var range = 2;
-function generateCodeFrame(source, start, end) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
         count += lines[i].length + 1;
         if (count >= start) {
-            for (var j = i - range; j <= i + range || end > count; j++) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
-                    { continue; }
-                res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-                var lineLength = lines[j].length;
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
-                    var pad = start - (count - lineLength) + 1;
-                    var length = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length));
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length$1 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length$1));
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
                     }
                     count += lineLength + 1;
                 }
@@ -10286,16 +10178,16 @@ function generateCodeFrame(source, start, end) {
     return res.join('\n');
 }
 function repeat(str, n) {
-    var result = '';
+    let result = '';
     if (n > 0) {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
-                { result += str; }
+                result += str;
             n >>>= 1;
             if (n <= 0)
-                { break; }
+                break;
             str += str;
         }
     }
@@ -10307,15 +10199,15 @@ function createFunction(code, errors) {
         return new Function(code);
     }
     catch (err) {
-        errors.push({ err: err, code: code });
+        errors.push({ err, code });
         return noop;
     }
 }
 function createCompileToFunctionFn(compile) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn = options.warn || warn$2;
+        const warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         {
@@ -10334,43 +10226,43 @@ function createCompileToFunctionFn(compile) {
             }
         }
         // check cache
-        var key = options.delimiters
+        const key = options.delimiters
             ? String(options.delimiters) + template
             : template;
         if (cache[key]) {
             return cache[key];
         }
         // compile
-        var compiled = compile(template, options);
+        const compiled = compile(template, options);
         // check compilation errors/tips
         {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
-                    compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
                         '\n', vm);
                 }
             }
             if (compiled.tips && compiled.tips.length) {
                 if (options.outputSourceRange) {
-                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
                 }
                 else {
-                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                    compiled.tips.forEach((msg) => tip(msg, vm));
                 }
             }
         }
         // turn code into functions
-        var res = {};
-        var fnGenErrors = [];
+        const res = {};
+        const fnGenErrors = [];
         res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
             return createFunction(code, fnGenErrors);
         });
         // check function generation errors.
@@ -10379,14 +10271,9 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn("Failed to generate render function:\n\n" +
+                warn(`Failed to generate render function:\n\n` +
                     fnGenErrors
-                        .map(function (ref) {
-                            var err = ref.err;
-                            var code = ref.code;
-
-                            return ((err.toString()) + " in\n\n" + code + "\n");
-                })
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
                         .join('\n'), vm);
             }
         }
@@ -10397,18 +10284,18 @@ function createCompileToFunctionFn(compile) {
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
-            var finalOptions = Object.create(baseOptions);
-            var errors = [];
-            var tips = [];
-            var warn = function (msg, range, tip) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
                 (tip ? tips : errors).push(msg);
             };
             if (options) {
                 if (options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = function (msg, range, tip) {
-                        var data = { msg: msg };
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
                         if (range) {
                             if (range.start != null) {
                                 data.start = range.start + leadingSpaceLength;
@@ -10429,14 +10316,14 @@ function createCompilerCreator(baseCompile) {
                     finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
                 }
                 // copy other options
-                for (var key in options) {
+                for (const key in options) {
                     if (key !== 'modules' && key !== 'directives') {
                         finalOptions[key] = options[key];
                     }
                 }
             }
             finalOptions.warn = warn;
-            var compiled = baseCompile(template.trim(), finalOptions);
+            const compiled = baseCompile(template.trim(), finalOptions);
             {
                 detectErrors(compiled.ast, warn);
             }
@@ -10445,7 +10332,7 @@ function createCompilerCreator(baseCompile) {
             return compiled;
         }
         return {
-            compile: compile,
+            compile,
             compileToFunctions: createCompileToFunctionFn(compile),
         };
     };
@@ -10454,59 +10341,58 @@ function createCompilerCreator(baseCompile) {
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    var ast = parse(template.trim(), options);
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
     if (options.optimize !== false) {
         optimize(ast, options);
     }
-    var code = generate(ast, options);
+    const code = generate(ast, options);
     return {
-        ast: ast,
+        ast,
         render: code.render,
         staticRenderFns: code.staticRenderFns,
     };
 });
 
-var ref = createCompiler(baseOptions);
-var compileToFunctions = ref.compileToFunctions;
+const { compile, compileToFunctions } = createCompiler(baseOptions);
 
 // check whether current browser encodes a char inside attribute values
-var div;
+let div;
 function getShouldDecode(href) {
     div = div || document.createElement('div');
-    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
     return div.innerHTML.indexOf('&#10;') > 0;
 }
 // #3663: IE encodes newlines inside attribute values while other browsers don't
-var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-var shouldDecodeNewlinesForHref = inBrowser
+const shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
-var idToTemplate = cached(function (id) {
-    var el = query(id);
+const idToTemplate = cached((id) => {
+    const el = query(id);
     return el && el.innerHTML;
 });
-var mount = Vue.prototype.$mount;
+const mount = Vue.prototype.$mount;
 Vue.prototype.$mount = function (el, hydrating) {
     el = el && query(el);
     /* istanbul ignore if */
     if (el === document.body || el === document.documentElement) {
-        warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
         return this;
     }
-    var options = this.$options;
+    const options = this.$options;
     // resolve template/el and convert to render function
     if (!options.render) {
-        var template = options.template;
+        let template = options.template;
         if (template) {
             if (typeof template === 'string') {
                 if (template.charAt(0) === '#') {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (!template) {
-                        warn$2(("Template element not found or is empty: " + (options.template)), this);
+                        warn$2(`Template element not found or is empty: ${options.template}`, this);
                     }
                 }
             }
@@ -10529,21 +10415,19 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (config.performance && mark) {
                 mark('compile');
             }
-            var ref = compileToFunctions(template, {
+            const { render, staticRenderFns } = compileToFunctions(template, {
                 outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines: shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
             }, this);
-            var render = ref.render;
-            var staticRenderFns = ref.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (config.performance && mark) {
                 mark('compile end');
-                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
             }
         }
     }
@@ -10558,7 +10442,7 @@ function getOuterHTML(el) {
         return el.outerHTML;
     }
     else {
-        var container = document.createElement('div');
+        const container = document.createElement('div');
         container.appendChild(el.cloneNode(true));
         return container.innerHTML;
     }
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
index d3d9edb5dac..d0d8ad0320e 100644
--- a/dist/vue.common.prod.js
+++ b/dist/vue.common.prod.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,C=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var x=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},E=function(e){return e};function N(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every((function(e,n){return N(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return N(e[n],t[n])}))}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(N(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:M},F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function R(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var H=new RegExp("[^"+F.source+".$_\\d]");var B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");var Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);var G,X=K&&K.match(/firefox\/(\d+)/),Y={}.watch,Q=!1;if(U)try{var ee={};Object.defineProperty(ee,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,ee)}catch(e){}var te=function(){return void 0===G&&(G=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},ne=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function re(e){return"function"==typeof e&&/native code/.test(e.toString())}var ie,oe="undefined"!=typeof Symbol&&re(Symbol)&&"undefined"!=typeof Reflect&&re(Reflect.ownKeys);ie="undefined"!=typeof Set&&re(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var ae=S,se=0,ce=function(){this.id=se++,this.subs=[]};ce.prototype.addSub=function(e){this.subs.push(e)},ce.prototype.removeSub=function(e){h(this.subs,e)},ce.prototype.depend=function(){ce.target&&ce.target.addDep(this)},ce.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ce.target=null;var ue=[];function le(e){ue.push(e),ce.target=e}function fe(){ue.pop(),ce.target=ue[ue.length-1]}var pe=function(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},de={child:{configurable:!0}};de.child.get=function(){return this.componentInstance},Object.defineProperties(pe.prototype,de);var ve=function(e){void 0===e&&(e="");var t=new pe;return t.text=e,t.isComment=!0,t};function he(e){return new pe(void 0,void 0,void 0,String(e))}function me(e){var t=new pe(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ye[e];R(ge,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var _e=Object.getOwnPropertyNames(ge),be=!0;function $e(e){be=e}var we=function(e){this.value=e,this.dep=new ce,this.vmCount=0,R(e,"__ob__",this),Array.isArray(e)?(B?function(e,t){e.__proto__=t}(e,ge):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];R(e,o,t[o])}}(e,ge,_e),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(o(e)&&!(e instanceof pe))return y(e,"__ob__")&&e.__ob__ instanceof we?n=e.__ob__:be&&!te()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new we(e)),t&&n&&n.vmCount++,n}function xe(e,t,n,r,i){var o=new ce,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ce.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&Oe(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&Ce(t),o.notify())}})}}function ke(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(xe(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Ae(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Oe(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Oe(t)}we.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)xe(e,t[n])},we.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Se=I.optionMergeStrategies;function Te(e,t){if(!t)return e;for(var n,r,i,o=oe?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Te(r,i):ke(e,n,i));return e}function Ee(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Te(r,i):i}:t?e?function(){return Te("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ne(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function je(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Se.data=function(e,t,n){return n?Ee(e,t,n):t&&"function"!=typeof t?e:Ee(e,t)},M.forEach((function(e){Se[e]=Ne})),L.forEach((function(e){Se[e+"s"]=je})),Se.watch=function(e,t,n,r){if(e===Y&&(e=void 0),t===Y&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Se.props=Se.methods=Se.inject=Se.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Se.provide=Ee;var De=function(e,t){return void 0===t?e:t};function Le(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Le(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Le(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Se[r]||De;a[r]=i(e[r],t[r],n,r)}return a}function Me(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Ie(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=He(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===C(e)){var c=He(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Pe(t.type)?r.call(e):r}(r,i,e);var u=be;$e(!0),Ce(a),$e(u)}return a}var Fe=/^\s*function (\w+)/;function Pe(e){var t=e&&e.toString().match(Fe);return t?t[1]:""}function Re(e,t){return Pe(e)===Pe(t)}function He(e,t){if(!Array.isArray(t))return Re(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(Re(t[n],e))return n;return-1}function Be(e,t,n){le();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){ze(e,r,"errorCaptured hook")}}ze(e,t,n)}finally{fe()}}function Ue(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch((function(e){return Be(e,r,i+" (Promise/async)")})),o._handled=!0)}catch(e){Be(e,r,i)}return o}function ze(e,t,n){if(I.errorHandler)try{return I.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ve(t)}Ve(e)}function Ve(e,t,n){if(!U&&!z||"undefined"==typeof console)throw e;console.error(e)}var Ke,qe=!1,Je=[],We=!1;function Ze(){We=!1;var e=Je.slice(0);Je.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&re(Promise)){var Ge=Promise.resolve();Ke=function(){Ge.then(Ze),Z&&setTimeout(S)},qe=!0}else if(q||"undefined"==typeof MutationObserver||!re(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ke="undefined"!=typeof setImmediate&&re(setImmediate)?function(){setImmediate(Ze)}:function(){setTimeout(Ze,0)};else{var Xe=1,Ye=new MutationObserver(Ze),Qe=document.createTextNode(String(Xe));Ye.observe(Qe,{characterData:!0}),Ke=function(){Xe=(Xe+1)%2,Qe.data=String(Xe)},qe=!0}function et(e,t){var n;if(Je.push((function(){if(e)try{e.call(t)}catch(e){Be(e,t,"nextTick")}else n&&n(t)})),We||(We=!0,Ke()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var tt=new ie;function nt(e){rt(e,tt),tt.clear()}function rt(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!o(e)||Object.isFrozen(e)||e instanceof pe)){if(e.__ob__){var a=e.__ob__.dep.id;if(t.has(a))return;t.add(a)}if(i)for(n=e.length;n--;)rt(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)rt(e[r[n]],t)}}var it=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function ot(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return Ue(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)Ue(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function at(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=it(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=ot(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=it(c)).name,n[c],f.capture)}function st(e,i,o){var a;e instanceof pe&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=ot([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=ot([s,c]),a.merged=!0,e[i]=a}function ct(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function ut(e){return i(e)?[he(e)]:Array.isArray(e)?ft(e):void 0}function lt(e){return n(e)&&n(e.text)&&!1===e.isComment}function ft(e,o){var a,s,c,u,l=[];for(a=0;a<e.length;a++)t(s=e[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(lt((s=ft(s,(o||"")+"_"+a))[0])&&lt(u)&&(l[c]=he(u.text+s[0].text),s.shift()),l.push.apply(l,s)):i(s)?lt(u)?l[c]=he(u.text+s):""!==s&&l.push(he(s)):lt(s)&&lt(u)?l[c]=he(u.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(o)&&(s.key="__vlist"+o+"_"+a+"__"),l.push(s)));return l}function pt(e,t){if(e){for(var n=Object.create(null),r=oe?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function dt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(vt)&&delete n[u];return n}function vt(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ht(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=mt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=yt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),R(i,"$stable",a),R(i,"$key",s),R(i,"$hasNormal",o),i}function mt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:ut(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function yt(e,t){return function(){return e[t]}}function gt(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(oe&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function _t(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function bt(e){return Me(this.$options,"filters",e)||E}function $t(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function wt(e,t,n,r,i){var o=I.keyCodes[t]||n;return i&&r&&!I.keyCodes[t]?$t(i,r):o?$t(o,e):r?C(r)!==t:void 0}function Ct(e,t,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||I.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=C(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function xt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||At(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function kt(e,t,n){return At(e,"__once__"+t+(n?"_"+n:""),!0),e}function At(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&Ot(e[r],t+"_"+r,n);else Ot(e,t,n)}function Ot(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function St(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function Tt(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Tt(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function Et(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function Nt(e,t){return"string"==typeof e?t+e:e}function jt(e){e._o=kt,e._n=f,e._s=l,e._l=gt,e._t=_t,e._q=N,e._i=j,e._m=xt,e._f=bt,e._k=wt,e._b=Ct,e._v=he,e._e=ve,e._u=Tt,e._g=St,e._d=Et,e._p=Nt}function Dt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=pt(u.inject,o),this.slots=function(){return c.$slots||ht(t.scopedSlots,c.$slots=dt(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ht(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ht(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Ht(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Ht(s,e,t,n,r,f)}}function Lt(e,t,n,r,i){var o=me(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Mt(e,t){for(var n in t)e[b(n)]=t[n]}jt(Dt.prototype);var It={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;It.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Xt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){$e(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Ie(d,v,n,t)}$e(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Gt(t,r,h),u&&(t.$slots=dt(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,nn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,on.push(t)):en(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?tn(t,!0):t.$destroy())}},Ft=Object.keys(It);function Pt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=zt;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return h(s,a)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D((function(t){e.resolved=Vt(t,i),c?s.length=0:p(!0)})),v=D((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Vt(m.error,i)),n(m.loading)&&(e.loadingComp=Vt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout((function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=ve();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},kn(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=C(u);ct(a,c,u,l,!0)||ct(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Ie(l,u,r||e);else n(i.attrs)&&Mt(c,i.attrs),n(i.props)&&Mt(c,i.props);var f=new Dt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof pe)return Lt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=ut(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Lt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Ft.length;n++){var r=Ft[n],i=t[r],o=It[r];i===o||i&&i._merged||(t[r]=i?Rt(o,i):o)}}(a);var y=i.options.name||l;return new pe("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Rt(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Ht(e,t,a,s,c,u){return(Array.isArray(a)||i(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(e,t,r,i,a){if(n(r)&&n(r.__ob__))return ve();n(r)&&n(r.is)&&(t=r.is);if(!t)return ve();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===a?i=ut(i):1===a&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var u;c=e.$vnode&&e.$vnode.ns||I.getTagNamespace(t),s=I.isReservedTag(t)?new pe(I.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(u=Me(e.$options,"components",t))?new pe(t,r,i,void 0,void 0,e):Pt(u,r,e,i,t)}else s=Pt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Bt(s,c),n(r)&&function(e){o(e.style)&&nt(e.style);o(e.class)&&nt(e.class)}(r),s):ve()}(e,t,a,s,c)}function Bt(e,i,o){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,o=!0),n(e.children))for(var a=0,s=e.children.length;a<s;a++){var c=e.children[a];n(c.tag)&&(t(c.ns)||r(o)&&"svg"!==c.tag)&&Bt(c,i,o)}}var Ut,zt=null;function Vt(e,t){return(e.__esModule||oe&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function Kt(e){return e.isComment&&e.asyncFactory}function qt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||Kt(r)))return r}}function Jt(e,t){Ut.$on(e,t)}function Wt(e,t){Ut.$off(e,t)}function Zt(e,t){var n=Ut;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Gt(e,t,n){Ut=e,at(t,n||{},Jt,Wt,Zt,e),Ut=void 0}var Xt=null;function Yt(e){var t=Xt;return Xt=e,function(){Xt=t}}function Qt(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function en(e,t){if(t){if(e._directInactive=!1,Qt(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)en(e.$children[n]);nn(e,"activated")}}function tn(e,t){if(!(t&&(e._directInactive=!0,Qt(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);nn(e,"deactivated")}}function nn(e,t){le();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)Ue(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),fe()}var rn=[],on=[],an={},sn=!1,cn=!1,un=0;var ln=0,fn=Date.now;if(U&&!q){var pn=window.performance;pn&&"function"==typeof pn.now&&fn()>document.createEvent("Event").timeStamp&&(fn=function(){return pn.now()})}function dn(){var e,t;for(ln=fn(),cn=!0,rn.sort((function(e,t){return e.id-t.id})),un=0;un<rn.length;un++)(e=rn[un]).before&&e.before(),t=e.id,an[t]=null,e.run();var n=on.slice(),r=rn.slice();un=rn.length=on.length=0,an={},sn=cn=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,en(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&nn(r,"updated")}}(r),ne&&I.devtools&&ne.emit("flush")}var vn=0,hn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++vn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ie,this.newDepIds=new ie,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!H.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};hn.prototype.get=function(){var e;le(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Be(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&nt(e),fe(),this.cleanupDeps()}return e},hn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},hn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},hn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==an[t]){if(an[t]=!0,cn){for(var n=rn.length-1;n>un&&rn[n].id>e.id;)n--;rn.splice(n+1,0,e)}else rn.push(e);sn||(sn=!0,et(dn))}}(this)},hn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Be(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},hn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},hn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},hn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var mn={enumerable:!0,configurable:!0,get:S,set:S};function yn(e,t,n){mn.get=function(){return this[t][n]},mn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,mn)}function gn(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&$e(!1);var o=function(o){i.push(o);var a=Ie(o,t,n,e);xe(r,o,a),o in e||yn(e,"_props",o)};for(var a in t)o(a);$e(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:x(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){le();try{return e.call(t,t)}catch(e){return Be(e,t,"data()"),{}}finally{fe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||P(o)||yn(e,"_data",o)}Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=te();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new hn(e,a||S,S,_n)),i in e||bn(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Y&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(e,n,r[i]);else Cn(e,n,r)}}(e,t.watch)}var _n={lazy:!0};function bn(e,t,n){var r=!te();"function"==typeof n?(mn.get=r?$n(t):wn(n),mn.set=S):(mn.get=n.get?r&&!1!==n.cache?$n(t):wn(n.get):S,mn.set=n.set||S),Object.defineProperty(e,t,mn)}function $n(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ce.target&&t.depend(),t.value}}function wn(e){return function(){return e.call(this,this)}}function Cn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var xn=0;function kn(e){var t=e.options;if(e.super){var n=kn(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Le(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function An(e){this._init(e)}function On(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=Le(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)yn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)bn(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,L.forEach((function(e){a[e]=n[e]})),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function Sn(e){return e&&(e.Ctor.options.name||e.tag)}function Tn(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function En(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=Sn(a.componentOptions);s&&!t(s)&&Nn(n,o,r,i)}}}function Nn(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=xn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Le(kn(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Gt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=dt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Ht(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Ht(t,e,n,r,i,!0)};var o=r&&r.data;xe(t,"$attrs",o&&o.attrs||e,null,!0),xe(t,"$listeners",n._parentListeners||e,null,!0)}(n),nn(n,"beforeCreate"),function(e){var t=pt(e.$options.inject,e);t&&($e(!1),Object.keys(t).forEach((function(n){xe(e,n,t[n])})),$e(!0))}(n),gn(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),nn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(An),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=ke,e.prototype.$delete=Ae,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return Cn(r,e,t,n);(n=n||{}).user=!0;var i=new hn(r,e,t,n);if(n.immediate){le();try{t.call(r,i.value)}catch(e){Be(e,r,'callback for immediate watcher "'+i.expression+'"')}fe()}return function(){i.teardown()}}}(An),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?k(n):n;for(var r=k(arguments,1),i='event handler for "'+e+'"',o=0,a=n.length;o<a;o++)Ue(n[o],t,r,t,i)}return t}}(An),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Yt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){nn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),nn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(An),function(e){jt(e.prototype),e.prototype.$nextTick=function(e){return et(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=ht(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{zt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Be(n,t,"render"),e=t._vnode}finally{zt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof pe||(e=ve()),e.parent=i,e}}(An);var jn=[String,RegExp,Array],Dn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)Nn(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){En(e,(function(e){return Tn(t,e)}))})),this.$watch("exclude",(function(t){En(e,(function(e){return!Tn(t,e)}))}))},render:function(){var e=this.$slots.default,t=qt(e),n=t&&t.componentOptions;if(n){var r=Sn(n),i=this.include,o=this.exclude;if(i&&(!r||!Tn(i,r))||o&&r&&Tn(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&Nn(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return I}};Object.defineProperty(e,"config",t),e.util={warn:ae,extend:A,mergeOptions:Le,defineReactive:xe},e.set=ke,e.delete=Ae,e.nextTick=et,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),L.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,A(e.options.components,Dn),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Le(this.options,e),this}}(e),On(e),function(e){L.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(An),Object.defineProperty(An.prototype,"$isServer",{get:te}),Object.defineProperty(An.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(An,"FunctionalRenderContext",{value:Dt}),An.version="2.6.12";var Ln=p("style,class"),Mn=p("input,textarea,option,select,progress"),In=p("contenteditable,draggable,spellcheck"),Fn=p("events,caret,typing,plaintext-only"),Pn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Rn="http://www.w3.org/1999/xlink",Hn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Bn=function(e){return Hn(e)?e.slice(6,e.length):""},Un=function(e){return null==e||!1===e};function zn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Vn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Vn(t,r.data));return function(e,t){if(n(e)||n(t))return Kn(e,qn(t));return""}(t.staticClass,t.class)}function Vn(e,t){return{staticClass:Kn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function Kn(e,t){return e?t?e+" "+t:e:t||""}function qn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=qn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Jn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Wn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Zn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(e){return Wn(e)||Zn(e)};var Xn=Object.create(null);var Yn=p("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Jn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),er={create:function(e,t){tr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(tr(e,!0),tr(t))},destroy:function(e){tr(e,!0)}};function tr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var nr=new pe("",{},[]),rr=["create","activate","update","remove","destroy"];function ir(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Yn(i)&&Yn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function or(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var ar={create:sr,update:sr,destroy:function(e){sr(e,nr)}};function sr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===nr,a=t===nr,s=ur(e.data.directives,e.context),c=ur(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,fr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(fr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)fr(u[n],"inserted",t,e)};o?st(t,"insert",f):f()}l.length&&st(t,"postpatch",(function(){for(var n=0;n<l.length;n++)fr(l[n],"componentUpdated",t,e)}));if(!o)for(n in s)c[n]||fr(s[n],"unbind",e,e,a)}(e,t)}var cr=Object.create(null);function ur(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=cr),i[lr(r)]=r,r.def=Me(t.$options,"directives",r.name);return i}function lr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function fr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Be(r,n.context,"directive "+e.name+" "+t+" hook")}}var pr=[er,ar];function dr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&vr(s,o,a,r.data.pre);for(o in(q||W)&&u.value!==c.value&&vr(s,"value",u.value),c)t(u[o])&&(Hn(o)?s.removeAttributeNS(Rn,Bn(o)):In(o)||s.removeAttribute(o))}}function vr(e,t,n,r){r||e.tagName.indexOf("-")>-1?hr(e,t,n):Pn(t)?Un(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):In(t)?e.setAttribute(t,function(e,t){return Un(t)||"false"===t?"false":"contenteditable"===e&&Fn(t)?t:"true"}(t,n)):Hn(t)?Un(n)?e.removeAttributeNS(Rn,Bn(t)):e.setAttributeNS(Rn,t,n):hr(e,t,n)}function hr(e,t,n){if(Un(n))e.removeAttribute(t);else{if(q&&!J&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var mr={create:dr,update:dr};function yr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=zn(r),c=i._transitionClasses;n(c)&&(s=Kn(s,qn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var gr,_r,br,$r,wr,Cr,xr={create:yr,update:yr},kr=/[\w).+\-_$\]]/;function Ar(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&kr.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Or(i,o[r]);return i}function Or(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Sr(e,t){console.error("[Vue compiler]: "+e)}function Tr(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Er(e,t,n,r,i){(e.props||(e.props=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Nr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Rr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Rr({name:t,value:n},r))}function Dr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Rr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Mr(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Lr("!",n,c)),i.once&&(delete i.once,n=Lr("~",n,c)),i.passive&&(delete i.passive,n=Lr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Rr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Ir(e,t,n){var r=Fr(e,":"+t)||Fr(e,"v-bind:"+t);if(null!=r)return Ar(r);if(!1!==n){var i=Fr(e,t);if(null!=i)return JSON.stringify(i)}}function Fr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Pr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Rr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Hr(e,t,n){var r=n||{},i=r.number,o="$$v",a=o;r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var s=Br(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Br(e,t){var n=function(e){if(e=e.trim(),gr=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<gr-1)return($r=e.lastIndexOf("."))>-1?{exp:e.slice(0,$r),key:'"'+e.slice($r+1)+'"'}:{exp:e,key:null};_r=e,$r=wr=Cr=0;for(;!zr();)Vr(br=Ur())?qr(br):91===br&&Kr(br);return{exp:e.slice(0,wr),key:e.slice(wr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function Ur(){return _r.charCodeAt(++$r)}function zr(){return $r>=gr}function Vr(e){return 34===e||39===e}function Kr(e){var t=1;for(wr=$r;!zr();)if(Vr(e=Ur()))qr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=$r;break}}function qr(e){for(var t=e;!zr()&&(e=Ur())!==t;);}var Jr;function Wr(e,t,n){var r=Jr;return function i(){var o=t.apply(null,arguments);null!==o&&Xr(e,i,n,r)}}var Zr=qe&&!(X&&Number(X[1])<=53);function Gr(e,t,n,r){if(Zr){var i=ln,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Jr.addEventListener(e,t,Q?{capture:n,passive:r}:n)}function Xr(e,t,n,r){(r||Jr).removeEventListener(e,t._wrapper||t,n)}function Yr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};Jr=r.elm,function(e){if(n(e.__r)){var t=q?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),at(i,o,Gr,Xr,Wr,r.context),Jr=void 0}}var Qr,ei={create:Yr,update:Yr};function ti(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ni(a,u)&&(a.value=u)}else if("innerHTML"===i&&Zn(a.tagName)&&t(a.innerHTML)){(Qr=Qr||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=Qr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ni(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ri={create:ti,update:ti},ii=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function oi(e){var t=ai(e.style);return e.staticStyle?A(e.staticStyle,t):t}function ai(e){return Array.isArray(e)?O(e):"string"==typeof e?ii(e):e}var si,ci=/^--/,ui=/\s*!important$/,li=function(e,t,n){if(ci.test(t))e.style.setProperty(t,n);else if(ui.test(n))e.style.setProperty(C(t),n.replace(ui,""),"important");else{var r=pi(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},fi=["Webkit","Moz","ms"],pi=g((function(e){if(si=si||document.createElement("div").style,"filter"!==(e=b(e))&&e in si)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<fi.length;n++){var r=fi[n]+t;if(r in si)return r}}));function di(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=ai(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=oi(i.data))&&A(r,n);(n=oi(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=oi(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&li(c,s,"");for(s in d)(a=d[s])!==f[s]&&li(c,s,null==a?"":a)}}var vi={create:di,update:di},hi=/\s+/;function mi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function yi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(hi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function gi(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,_i(e.name||"v")),A(t,e),t}return"string"==typeof e?_i(e):void 0}}var _i=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),bi=U&&!J,$i="transition",wi="transitionend",Ci="animation",xi="animationend";bi&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&($i="WebkitTransition",wi="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ci="WebkitAnimation",xi="webkitAnimationEnd"));var ki=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ai(e){ki((function(){ki(e)}))}function Oi(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),mi(e,t))}function Si(e,t){e._transitionClasses&&h(e._transitionClasses,t),yi(e,t)}function Ti(e,t,n){var r=Ni(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s="transition"===i?wi:xi,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),e.addEventListener(s,l)}var Ei=/\b(transform|all)(,|$)/;function Ni(e,t){var n,r=window.getComputedStyle(e),i=(r[$i+"Delay"]||"").split(", "),o=(r[$i+"Duration"]||"").split(", "),a=ji(i,o),s=(r[Ci+"Delay"]||"").split(", "),c=(r[Ci+"Duration"]||"").split(", "),u=ji(s,c),l=0,f=0;return"transition"===t?a>0&&(n="transition",l=a,f=o.length):"animation"===t?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:"transition"===n&&Ei.test(r[$i+"Property"])}}function ji(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Di(t)+Di(e[n])})))}function Di(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Li(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=gi(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,C=a.appearCancelled,x=a.duration,k=Xt,A=Xt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,E=O&&v?v:l,N=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&C||_,I=f(o(x)?x.enter:x),F=!1!==s&&!J,P=Fi(j),R=i._enterCb=D((function(){F&&(Si(i,E),Si(i,T)),R.cancelled?(F&&Si(i,S),M&&M(i)):L&&L(i),i._enterCb=null}));e.data.show||st(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)})),N&&N(i),F&&(Oi(i,S),Oi(i,T),Ai((function(){Si(i,S),R.cancelled||(Oi(i,E),P||(Ii(I)?setTimeout(R,I):Ti(i,c,R)))}))),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Mi(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=gi(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!J,b=Fi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Si(i,l),Si(i,p)),w.cancelled?(_&&Si(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(C):C()}function C(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Oi(i,u),Oi(i,p),Ai((function(){Si(i,u),w.cancelled||(Oi(i,l),b||(Ii($)?setTimeout(w,$):Ti(i,c,w)))}))),v&&v(i,w),_||b||w())}}function Ii(e){return"number"==typeof e&&!isNaN(e)}function Fi(e){if(t(e))return!1;var r=e.fns;return n(r)?Fi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Pi(e,t){!0!==t.data.show&&Li(t)}var Ri=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<rr.length;++o)for(s[rr[o]]=[],a=0;a<c.length;++a)n(c[a][rr[o]])&&s[rr[o]].push(c[a][rr[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=me(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){var o,a=e;for(;a.componentInstance;)if(n(o=(a=a.componentInstance._vnode).data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](nr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(tr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](nr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(nr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Xt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function C(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&ir(e,a))return o}}function x(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=me(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:ir(h,g)?(x(h,g,o,i,d),h=r[++p],g=i[++d]):ir(m,b)?(x(m,b,o,i,y),m=r[--v],b=i[--y]):ir(h,b)?(x(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):ir(m,g)?(x(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=or(r,p,v)),t(c=n(g.key)?s[g.key]:C(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):ir(l=r[c],g)?(x(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&nt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&ir(e,i))x(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute("data-server-rendered")&&(e.removeAttribute("data-server-rendered"),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new pe(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](nr,y);var C=y.data.hook.insert;if(C.merged)for(var A=1;A<C.fns.length;A++)C.fns[A]()}else tr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:Qn,modules:[mr,xr,ei,ri,vi,U?{create:Pi,activate:Pi,remove:function(e,t){!0!==e.data.show?Mi(e,t):t()}}:{}].concat(pr)});J&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Ji(e,"input")}));var Hi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?st(n,"postpatch",(function(){Hi.componentUpdated(e,t,n)})):Bi(e,t,n.context),e._vOptions=[].map.call(e.options,Vi)):("textarea"===n.tag||Yn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Ki),e.addEventListener("compositionend",qi),e.addEventListener("change",qi),J&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Bi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Vi);if(i.some((function(e,t){return!N(e,r[t])})))(e.multiple?t.value.some((function(e){return zi(e,i)})):t.value!==t.oldValue&&zi(t.value,i))&&Ji(e,"change")}}};function Bi(e,t,n){Ui(e,t),(q||W)&&setTimeout((function(){Ui(e,t)}),0)}function Ui(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Vi(a))>-1,a.selected!==o&&(a.selected=o);else if(N(Vi(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function zi(e,t){return t.every((function(t){return!N(t,e)}))}function Vi(e){return"_value"in e?e._value:e.value}function Ki(e){e.target.composing=!0}function qi(e){e.target.composing&&(e.target.composing=!1,Ji(e.target,"input"))}function Ji(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Wi(e){return!e.componentInstance||e.data&&e.data.transition?e:Wi(e.componentInstance._vnode)}var Zi={model:Hi,show:{bind:function(e,t,n){var r=t.value,i=(n=Wi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Li(n,(function(){e.style.display=o}))):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Wi(n)).data&&n.data.transition?(n.data.show=!0,r?Li(n,(function(){e.style.display=e.__vOriginalDisplay})):Mi(n,(function(){e.style.display="none"}))):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},Gi={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Xi(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?Xi(qt(t.children)):e}function Yi(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function Qi(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var eo=function(e){return e.tag||Kt(e)},to=function(e){return"show"===e.name},no={name:"transition",props:Gi,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(eo)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=Xi(o);if(!a)return o;if(this._leaving)return Qi(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Yi(this),u=this._vnode,l=Xi(u);if(a.data.directives&&a.data.directives.some(to)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!Kt(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,st(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),Qi(e,o);if("in-out"===r){if(Kt(a))return u;var p,d=function(){p()};st(c,"afterEnter",d),st(c,"enterCancelled",d),st(f,"delayLeave",(function(e){p=e}))}}return o}}},ro=A({tag:String,moveClass:String},Gi);function io(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function oo(e){e.data.newPos=e.elm.getBoundingClientRect()}function ao(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete ro.mode;var so={Transition:no,TransitionGroup:{props:ro,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Yt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=Yi(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=e(t,null,u),this.removed=l}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(io),e.forEach(oo),e.forEach(ao),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;Oi(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(wi,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(wi,e),n._moveCb=null,Si(n,t))})}})))},methods:{hasMove:function(e,t){if(!bi)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){yi(n,e)})),mi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Ni(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};An.config.mustUseProp=function(e,t,n){return"value"===n&&Mn(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},An.config.isReservedTag=Gn,An.config.isReservedAttr=Ln,An.config.getTagNamespace=function(e){return Zn(e)?"svg":"math"===e?"math":void 0},An.config.isUnknownElement=function(e){if(!U)return!0;if(Gn(e))return!1;if(e=e.toLowerCase(),null!=Xn[e])return Xn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Xn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Xn[e]=/HTMLUnknownElement/.test(t.toString())},A(An.options.directives,Zi),A(An.options.components,so),An.prototype.__patch__=U?Ri:S,An.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=ve),nn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new hn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&nn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,nn(e,"mounted")),e}(this,e=e&&U?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},U&&setTimeout((function(){I.devtools&&ne&&ne.emit("init",An)}),0);var co=p("input,textarea,option,select,progress"),uo=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),lo=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function fo(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var po=/\{\{((?:.|\r?\n)+?)\}\}/g,vo=/[-.*+?^${}()|[\]\/\\]/g,ho=g((function(e){var t=e[0].replace(vo,"\\$&"),n=e[1].replace(vo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var mo={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Fr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Ir(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var yo,go={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Fr(e,"style");n&&(e.staticStyle=JSON.stringify(ii(n)));var r=Ir(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},_o=function(e){return(yo=yo||document.createElement("div")).innerHTML=e,yo.textContent},bo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),$o=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,wo=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Co="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+F.source+"]*",xo="((?:"+Co+"\\:)?"+Co+")",ko=new RegExp("^<"+xo),Ao=/^\s*(\/?)>/,Oo=new RegExp("^<\\/"+xo+"[^>]*>"),So=/^<!DOCTYPE [^>]+>/i,To=/^<!\--/,Eo=/^<!\[/,No=p("script,style,textarea",!0),jo={},Do={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Lo=/&(?:lt|gt|quot|amp|#39);/g,Mo=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Io=p("pre,textarea",!0),Fo=function(e,t){return e&&Io(e)&&"\n"===t[0]};function Po(e,t){var n=t?Mo:Lo;return e.replace(n,(function(e){return Do[e]}))}var Ro,Ho,Bo,Uo,zo,Vo,Ko,qo,Jo=/^@|^v-on:/,Wo=/^v-|^@|^:|^#/,Zo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Go=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Xo=/^\(|\)$/g,Yo=/^\[.*\]$/,Qo=/:(.*)$/,ea=/^:|^\.|^v-bind:/,ta=/\.[^.\]]+(?=[^\]]*$)/g,na=/^v-slot(:|$)|^#/,ra=/[\r\n]/,ia=/[ \f\t\r\n]+/g,oa=g(_o);function aa(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:da(t),rawAttrsMap:{},parent:n,children:[]}}function sa(e,t){Ro=t.warn||Sr,Vo=t.isPreTag||T,Ko=t.mustUseProp||T,qo=t.getTagNamespace||T,t.isReservedTag,Bo=Tr(t.modules,"transformNode"),Uo=Tr(t.modules,"preTransformNode"),zo=Tr(t.modules,"postTransformNode"),Ho=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=ca(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&la(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&la(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter((function(e){return!e.slotScope})),l(e),e.pre&&(s=!1),Vo(e.tag)&&(c=!1);for(var f=0;f<zo.length;f++)zo[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&No(r)){var u=0,l=r.toLowerCase(),f=jo[l]||(jo[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return u=r.length,No(l)||"noscript"===l||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Fo(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(To.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),C(v+3);continue}}if(Eo.test(e)){var h=e.indexOf("]>");if(h>=0){C(h+2);continue}}var m=e.match(So);if(m){C(m[0].length);continue}var y=e.match(Oo);if(y){var g=c;C(y[0].length),A(y[1],g,c);continue}var _=x();if(_){k(_),Fo(_.tagName,e)&&C(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Oo.test($)||ko.test($)||To.test($)||Eo.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&C(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function C(t){c+=t,e=e.substring(t)}function x(){var t=e.match(ko);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(C(t[0].length);!(n=e.match(Ao))&&(r=e.match(wo)||e.match($o));)r.start=c,C(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],C(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&bo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Po(v,h)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,u,e.start,e.end)}function A(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Ro,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||qo(e);q&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];va.test(r.name)||(r.name=r.name.replace(ha,""),t.push(r))}return t}(o));var d,v=aa(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||te()||(v.forbidden=!0);for(var h=0;h<Uo.length;h++)v=Uo[h](v,t)||v;s||(!function(e){null!=Fr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Vo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(ua(v),function(e){var t=Fr(e,"v-if");if(t)e.if=t,la(e,{exp:t,block:e});else{null!=Fr(e,"v-else")&&(e.else=!0);var n=Fr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Fr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!q||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u,l,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:oa(e):f.length?a?"condense"===a&&ra.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(ia," ")),!s&&" "!==e&&(u=function(e,t){var n=t?ho(t):po;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Ar(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,Ho))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function ca(e,t){var n,r;(r=Ir(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Ir(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Fr(e,"scope"),e.slotScope=t||Fr(e,"slot-scope")):(t=Fr(e,"slot-scope"))&&(e.slotScope=t);var n=Ir(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Nr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Pr(e,na);if(r){var i=fa(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||"_empty_"}}else{var s=Pr(e,na);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=fa(s),l=u.name,f=u.dynamic,p=c[l]=aa("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||"_empty_",e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Ir(e,"name"))}(e),function(e){var t;(t=Ir(e,"is"))&&(e.component=t);null!=Fr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Bo.length;i++)e=Bo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Wo.test(r))if(e.hasBindings=!0,(a=pa(r.replace(Wo,"")))&&(r=r.replace(ta,"")),ea.test(r))r=r.replace(ea,""),o=Ar(o),(c=Yo.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Br(o,"$event"),c?Mr(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Mr(e,"update:"+b(r),s,null,!1,0,u[t]),C(r)!==b(r)&&Mr(e,"update:"+C(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Ko(e.tag,e.attrsMap.type,r)?Er(e,r,o,u[t],c):Nr(e,r,o,u[t],c);else if(Jo.test(r))r=r.replace(Jo,""),(c=Yo.test(r))&&(r=r.slice(1,-1)),Mr(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Wo,"")).match(Qo),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),Yo.test(f)&&(f=f.slice(1,-1),c=!0)),Dr(e,r,i,o,f,c,a,u[t])}else Nr(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Ko(e.tag,e.attrsMap.type,r)&&Er(e,r,"true",u[t])}(e),e}function ua(e){var t;if(t=Fr(e,"v-for")){var n=function(e){var t=e.match(Zo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(Xo,""),i=r.match(Go);i?(n.alias=r.replace(Go,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function la(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function fa(e){var t=e.name.replace(na,"");return t||"#"!==e.name[0]&&(t="default"),Yo.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function pa(e){var t=e.match(ta);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function da(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var va=/^xmlns:NS\d+/,ha=/^NS\d+:/;function ma(e){return aa(e.tag,e.attrsList.slice(),e.parent)}var ya=[mo,go,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Ir(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Fr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Fr(e,"v-else",!0),s=Fr(e,"v-else-if",!0),c=ma(e);ua(c),jr(c,"type","checkbox"),ca(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,la(c,{exp:c.if,block:c});var u=ma(e);Fr(u,"v-for",!0),jr(u,"type","radio"),ca(u,t),la(c,{exp:"("+n+")==='radio'"+o,block:u});var l=ma(e);return Fr(l,"v-for",!0),jr(l,":type",n),ca(l,t),la(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var ga,_a,ba={expectHTML:!0,modules:ya,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Hr(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Br(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Mr(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null",o=Ir(e,"true-value")||"true",a=Ir(e,"false-value")||"false";Er(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Mr(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Br(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Br(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Br(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Ir(e,"value")||"null";Er(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Mr(e,"change",Br(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?"__r":"input",l="$event.target.value";s&&(l="$event.target.value.trim()");a&&(l="_n("+l+")");var f=Br(t,l);c&&(f="if($event.target.composing)return;"+f);Er(e,"value","("+t+")"),Mr(e,u,f,null,!0),(s||a)&&Mr(e,"blur","$forceUpdate()")}(e,r,i);else if(!I.isReservedTag(o))return Hr(e,r,i),!1;return!0},text:function(e,t){t.value&&Er(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Er(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&co(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return uo(e)||lo(e)},getTagNamespace:function(e){return lo(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}(ya)},$a=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function wa(e,t){e&&(ga=$a(t.staticKeys||""),_a=t.isReservedTag||T,Ca(e),xa(e,!1))}function Ca(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!_a(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(ga)))}(e),1===e.type){if(!_a(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Ca(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++){var a=e.ifConditions[i].block;Ca(a),a.static||(e.static=!1)}}}function xa(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)xa(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++)xa(e.ifConditions[i].block,t)}}var ka=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Aa=/\([^)]*?\);*$/,Oa=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Sa={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ta={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ea=function(e){return"if("+e+")return null;"},Na={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ea("$event.target !== $event.currentTarget"),ctrl:Ea("!$event.ctrlKey"),shift:Ea("!$event.shiftKey"),alt:Ea("!$event.altKey"),meta:Ea("!$event.metaKey"),left:Ea("'button' in $event && $event.button !== 0"),middle:Ea("'button' in $event && $event.button !== 1"),right:Ea("'button' in $event && $event.button !== 2")};function ja(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=Da(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Da(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return Da(e)})).join(",")+"]";var t=Oa.test(e.value),n=ka.test(e.value),r=Oa.test(e.value.replace(Aa,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(Na[s])o+=Na[s],Sa[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=Ea(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(La).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function La(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=Sa[e],r=Ta[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ma={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Ia=function(e){this.options=e,this.warn=e.warn||Sr,this.transforms=Tr(e.modules,"transformCode"),this.dataGenFns=Tr(e.modules,"genData"),this.directives=A(A({},Ma),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Fa(e,t){var n=new Ia(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Pa(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Pa(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return Ra(e,t);if(e.once&&!e.onceProcessed)return Ha(e,t);if(e.for&&!e.forProcessed)return za(e,t);if(e.if&&!e.ifProcessed)return Ba(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=Ja(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?Ga((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:Ja(t,n,!0);return"_c("+e+","+Va(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Va(e,t));var i=e.inlineTemplate?null:Ja(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return Ja(e,t)||"void 0"}function Ra(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Pa(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Ha(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ba(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Pa(e,t)+","+t.onceId+++","+n+")":Pa(e,t)}return Ra(e,t)}function Ba(e,t,n,r){return e.ifProcessed=!0,Ua(e.ifConditions.slice(),t,n,r)}function Ua(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+o(i.block)+":"+Ua(e,t,n,r):""+o(i.block);function o(e){return n?n(e,t):e.once?Ha(e,t):Pa(e,t)}}function za(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Pa)(e,t)+"})"}function Va(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+Ga(e.attrs)+","),e.props&&(n+="domProps:"+Ga(e.props)+","),e.events&&(n+=ja(e.events,!1)+","),e.nativeEvents&&(n+=ja(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Ka(n)})),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&"_empty_"!==o.slotScope||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map((function(e){return qa(t[e],n)})).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Fa(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+Ga(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Ka(e){return 1===e.type&&("slot"===e.tag||e.children.some(Ka))}function qa(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ba(e,t,qa,"null");if(e.for&&!e.forProcessed)return za(e,t,qa);var r="_empty_"===e.slotScope?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(Ja(e,t)||"undefined")+":undefined":Ja(e,t)||"undefined":Pa(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Ja(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Pa)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Wa(i)||i.ifConditions&&i.ifConditions.some((function(e){return Wa(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Za;return"["+o.map((function(e){return u(e,t)})).join(",")+"]"+(c?","+c:"")}}function Wa(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Za(e,t){return 1===e.type?Pa(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:Xa(JSON.stringify(e.text)))+")"}(e)}function Ga(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=Xa(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function Xa(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ya(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function Qa(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=Ya(a.render,c),s.staticRenderFns=a.staticRenderFns.map((function(e){return Ya(e,c)})),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var es,ts,ns=(es=function(e,t){var n=sa(e.trim(),t);!1!==t.optimize&&wa(n,t);var r=Fa(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=es(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Qa(t)}})(ba).compileToFunctions;function rs(e){return(ts=ts||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',ts.innerHTML.indexOf("&#10;")>0}var is=!!U&&rs(!1),os=!!U&&rs(!0),as=g((function(e){var t=fo(e);return t&&t.innerHTML})),ss=An.prototype.$mount;An.prototype.$mount=function(e,t){if((e=e&&fo(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=as(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=ns(r,{outputSourceRange:!1,shouldDecodeNewlines:is,shouldDecodeNewlinesForHref:os,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return ss.call(this,e,t)},An.compile=ns,module.exports=An;
\ No newline at end of file
+"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const I=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const G=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const Z=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let st=S,it=0;class at{static target;id;subs;constructor(){this.id=it++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{value;dep;vmCount;constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const s=new at,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function kt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}const At=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=ot?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Nt(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{At[t]=Tt})),I.forEach((function(t){At[t+"s"]=Nt})),At.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function It(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Lt(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(i),$t(e)}return i}const Mt=/^\s*function (\w+)/;function Lt(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return Lt(t)===Lt(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Rt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Rt(t,o,r)}return s}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,Jt=!1;function qt(){Jt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(qt),G&&setTimeout(S)},zt=!0}else if(J||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(qt)}:()=>{setTimeout(qt,0)};else{let t=1;const e=new MutationObserver(qt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),Jt||(Jt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Gt=new rt;function Zt(t){Xt(t,Gt),Gt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),s(f.name,n[c],f.capture))}function ee(t,r,s){let i;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ne(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?se(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=se(c,`${s||""}_${a}`),re(c[0])&&re(u)&&(i[l]=pt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?re(u)?i[l]=pt(u.text+c):""!==c&&i.push(pt(c)):re(c)&&re(u)?i[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ie(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(t){return t.isComment&&t.asyncFactory}function ue(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=fe(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=de(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",i),R(r,"$key",a),R(r,"$hasNormal",s),r}function fe(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!le(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function de(t,e){return()=>t[e]}function pe(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function he(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function me(t){return Dt(this.$options,"filters",t)||N}function ye(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ge(t,e,n,o,r){const s=L.keyCodes[e]||n;return r&&o&&!L.keyCodes[e]?ye(r,o):s?ye(s,t):o?C(o)!==e:void 0===t}function ve(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||L.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function $e(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),be(o,`__static__${t}`,!1)),o}function _e(t,e,n){return be(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function be(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&we(t[o],`${e}_${o}`,n);else we(t,e,n)}function we(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Ce(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function xe(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?xe(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function ke(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=u,t._l=pe,t._t=he,t._q=E,t._i=j,t._m=$e,t._f=me,t._k=ge,t._b=ve,t._v=pt,t._e=dt,t._u=xe,t._g=Ce,t._d=ke,t._p=Ae}function Se(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ie(a.inject,s),this.slots=()=>(this.$slots||ue(e.scopedSlots,this.$slots=ae(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Me(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Me(c,t,e,n,o,u)}function Te(t,e,n,o,r){const s=ht(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ne(t,e){for(const n in e)t[_(n)]=e[n]}Oe(Se.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=It(s,i,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ze(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ge(e,!0):e.$destroy())}},je=Object.keys(Ee);function De(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Pe;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=Re(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Re(h.error,r)),n(h.loading)&&(t.loadingComp=Re(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=dt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ne(i,c,t,e,!0)||ne(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=It(e,l,o||t);else n(r.attrs)&&Ne(c,r.attrs),n(r.props)&&Ne(c,r.props);const u=new Se(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Te(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Te(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<je.length;t++){const n=je[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?Ie(r,o):r)}}(i);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Ie(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Me(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=oe(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),a=L.isReservedTag(e)?new ft(L.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=Dt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):De(s,o,t,r,e)}else a=De(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Le(a,c),n(o)&&function(t){s(t.style)&&Zt(t.style);s(t.class)&&Zt(t.class)}(o),a):dt()}(t,e,i,a,c)}function Le(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Le(a,r,s)}}let Fe,Pe=null;function Re(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||le(o)))return o}}function Be(t,e){Fe.$on(t,e)}function Ue(t,e){Fe.$off(t,e)}function ze(t,e){const n=Fe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Fe=t,te(e,n||{},Be,Ue,ze,t),Fe=void 0}let Ke=null;function Je(t){const e=Ke;return Ke=t,()=>{Ke=e}}function qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ze(t,"activated")}}function Ge(t,e){if(!(e&&(t._directInactive=!0,qe(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ge(t.$children[e]);Ze(t,"deactivated")}}function Ze(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!J){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ze(o,"updated")}}(o),et&&L.devtools&&et.emit("flush")}let an=0;class cn{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Zt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Ht(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const s in e){r.push(s);wt(o,s,It(s,e,n,t)),s in t||un(t,"_props",s)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new cn(t,i||S,S,dn)),r in t||pn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=jt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,I.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Me(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Me(e,t,n,o,r,!0);const s=o&&o.data;wt(e,"$attrs",s&&s.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){const e=ie(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;lt(),Ht(e,o,[r.value],o,t),ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=Je(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ue(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Pe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Pe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const kn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:bn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&xn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>L};Object.defineProperty(t,"config",e),t.util={warn:st,extend:A,mergeOptions:jt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),I.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),_n(t),function(t){I.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Se}),$n.version="2.6.14";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,Nn=d("contenteditable,draggable,spellcheck"),En=d("events,caret,typing,plaintext-only"),jn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Dn="http://www.w3.org/1999/xlink",In=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Mn=t=>In(t)?t.slice(6,t.length):"",Ln=t=>null==t||!1===t;function Fn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Pn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Pn(e,o.data));return function(t,e){if(n(t)||n(e))return Rn(t,Hn(e));return""}(e.staticClass,e.class)}function Pn(t,e){return{staticClass:Rn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Rn(t,e){return t?e?t+" "+e:t:e||""}function Hn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Hn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Un=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Vn=t=>Un(t)||zn(t);function Kn(t){return zn(t)?"svg":"math"===t?"math":void 0}const Jn=Object.create(null);const qn=d("text,number,password,search,email,tel,url");function Wn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var Gn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create(t,e){Xn(e)},update(t,e){t.data.ref!==e.data.ref&&(Xn(t,!0),Xn(e))},destroy(t){Xn(t,!0)}};function Xn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?m(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Yn=new ft("",{},[]),Qn=["create","activate","update","remove","destroy"];function to(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||qn(r)&&qn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function eo(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var no={create:oo,update:oo,destroy:function(t){oo(t,Yn)}};function oo(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Yn,o=e===Yn,r=so(t.data.directives,t.context),s=so(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ao(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ao(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)ao(i[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ao(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||ao(r[c],"unbind",t,t,o)}(t,e)}const ro=Object.create(null);function so(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=ro),n[io(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function io(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ao(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var co=[Zn,no];function lo(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&uo(c,s,i,o.data.pre);for(s in(J||W)&&u.value!==l.value&&uo(c,"value",u.value),l)e(u[s])&&(In(s)?c.removeAttributeNS(Dn,Mn(s)):Nn(s)||c.removeAttribute(s))}function uo(t,e,n,o){o||t.tagName.indexOf("-")>-1?fo(t,e,n):jn(e)?Ln(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,((t,e)=>Ln(e)||"false"===e?"false":"contenteditable"===t&&En(e)?e:"true")(e,n)):In(e)?Ln(n)?t.removeAttributeNS(Dn,Mn(e)):t.setAttributeNS(Dn,e,n):fo(t,e,n)}function fo(t,e,n){if(Ln(n))t.removeAttribute(e);else{if(J&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var po={create:lo,update:lo};function ho(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Fn(o);const c=r._transitionClasses;n(c)&&(a=Rn(a,Hn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var mo={create:ho,update:ho};const yo=/[\w).+\-_$\]]/;function go(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&yo.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=vo(r,s[o]);return r}function vo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function $o(t,e){console.error(`[Vue compiler]: ${t}`)}function _o(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function bo(t,e,n,o,r){(t.props||(t.props=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function wo(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function Co(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(No({name:e,value:n},o))}function xo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(No({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function ko(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Ao(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=ko("!",n,c)),r.once&&(delete r.once,n=ko("~",n,c)),r.passive&&(delete r.passive,n=ko("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=No({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function Oo(t,e,n){const o=So(t,":"+e)||So(t,"v-bind:"+e);if(null!=o)return go(o);if(!1!==n){const n=So(t,e);if(null!=n)return JSON.stringify(n)}}function So(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function To(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function No(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function Eo(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=jo(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function jo(t,e){const n=function(t){if(t=t.trim(),Do=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Do-1)return Lo=t.lastIndexOf("."),Lo>-1?{exp:t.slice(0,Lo),key:'"'+t.slice(Lo+1)+'"'}:{exp:t,key:null};Io=t,Lo=Fo=Po=0;for(;!Ho();)Mo=Ro(),Bo(Mo)?zo(Mo):91===Mo&&Uo(Mo);return{exp:t.slice(0,Fo),key:t.slice(Fo+1,Po)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Do,Io,Mo,Lo,Fo,Po;function Ro(){return Io.charCodeAt(++Lo)}function Ho(){return Lo>=Do}function Bo(t){return 34===t||39===t}function Uo(t){let e=1;for(Fo=Lo;!Ho();)if(Bo(t=Ro()))zo(t);else if(91===t&&e++,93===t&&e--,0===e){Po=Lo;break}}function zo(t){const e=t;for(;!Ho()&&(t=Ro())!==e;);}let Vo;function Ko(t,e,n){const o=Vo;return function r(){const s=e.apply(null,arguments);null!==s&&Wo(t,r,n,o)}}const Jo=zt&&!(Z&&Number(Z[1])<=53);function qo(t,e,n,o){if(Jo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Vo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Wo(t,e,n,o){(o||Vo).removeEventListener(t,e._wrapper||e,n)}function Go(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Vo=o.elm||t.elm,function(t){if(n(t.__r)){const e=J?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,s,qo,Wo,Ko,o.context),Vo=void 0}var Zo={create:Go,update:Go,destroy:t=>Go(t,Yn)};let Xo;function Yo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Qo(i,t)&&(i.value=t)}else if("innerHTML"===r&&zn(i.tagName)&&e(i.innerHTML)){Xo=Xo||document.createElement("div"),Xo.innerHTML=`<svg>${s}</svg>`;const t=Xo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Qo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var tr={create:Yo,update:Yo};const er=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function nr(t){const e=or(t.style);return t.staticStyle?A(t.staticStyle,e):e}function or(t){return Array.isArray(t)?O(t):"string"==typeof t?er(t):t}const rr=/^--/,sr=/\s*!important$/,ir=(t,e,n)=>{if(rr.test(e))t.style.setProperty(e,n);else if(sr.test(n))t.style.setProperty(C(e),n.replace(sr,""),"important");else{const o=lr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},ar=["Webkit","Moz","ms"];let cr;const lr=v((function(t){if(cr=cr||document.createElement("div").style,"filter"!==(t=_(t))&&t in cr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<ar.length;t++){const n=ar[t]+e;if(n in cr)return n}}));function ur(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=or(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=nr(e.data))&&A(n,o)}(o=nr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=nr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&ir(c,a,"");for(a in p)i=p[a],i!==f[a]&&ir(c,a,null==i?"":i)}var fr={create:ur,update:ur};const dr=/\s+/;function pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function mr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,yr(t.name||"v")),A(e,t),e}return"string"==typeof t?yr(t):void 0}}const yr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),gr=U&&!q;let vr="transition",$r="transitionend",_r="animation",br="animationend";gr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(vr="WebkitTransition",$r="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(_r="WebkitAnimation",br="webkitAnimationEnd"));const wr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Cr(t){wr((()=>{wr(t)}))}function xr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pr(t,e))}function kr(t,e){t._transitionClasses&&m(t._transitionClasses,e),hr(t,e)}function Ar(t,e,n){const{type:o,timeout:r,propCount:s}=Sr(t,e);if(!o)return n();const i="transition"===o?$r:br;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Or=/\b(transform|all)(,|$)/;function Sr(t,e){const n=window.getComputedStyle(t),o=(n[vr+"Delay"]||"").split(", "),r=(n[vr+"Duration"]||"").split(", "),s=Tr(o,r),i=(n[_r+"Delay"]||"").split(", "),a=(n[_r+"Duration"]||"").split(", "),c=Tr(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Or.test(n[vr+"Property"])}}function Tr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Nr(e)+Nr(t[n]))))}function Nr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Er(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=mr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Ke,A=Ke.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,j=O&&"function"==typeof b?b:g,I=O&&w||v,M=O&&C||$,L=f(s(x)?x.enter:x),F=!1!==a&&!q,P=Ir(j),R=r._enterCb=D((()=>{F&&(kr(r,N),kr(r,T)),R.cancelled?(F&&kr(r,S),M&&M(r)):I&&I(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),E&&E(r),F&&(xr(r,S),xr(r,T),Cr((()=>{kr(r,S),R.cancelled||(xr(r,N),P||(Dr(L)?setTimeout(R,L):Ar(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function jr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=mr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!q,_=Ir(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(kr(r,u),kr(r,d)),w.cancelled?($&&kr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(xr(r,l),xr(r,d),Cr((()=>{kr(r,l),w.cancelled||(xr(r,u),_||(Dr(b)?setTimeout(w,b):Ar(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Dr(t){return"number"==typeof t&&!isNaN(t)}function Ir(t){if(e(t))return!1;const o=t.fns;return n(o)?Ir(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Mr(t,e){!0!==e.data.show&&Er(e)}const Lr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Qn.length;++s)for(a[Qn[s]]=[],i=0;i<c.length;++i)n(c[i][Qn[s]])&&a[Qn[s]].push(c[i][Qn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Yn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Xn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Yn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&to(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:to(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):to(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):to(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):to(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=eo(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],to(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Zt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&to(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Xn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:Gn,modules:[po,mo,Zo,tr,fr,U?{create:Mr,activate:Mr,remove(t,e){!0!==t.data.show?jr(t,e):e()}}:{}].concat(co)});q&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Vr(t,"input")}));const Fr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Fr.componentUpdated(t,e,n)})):Pr(t,e,n.context),t._vOptions=[].map.call(t.options,Br)):("textarea"===n.tag||qn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Ur),t.addEventListener("compositionend",zr),t.addEventListener("change",zr),q&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Pr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Br);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>Hr(t,r))):e.value!==e.oldValue&&Hr(e.value,r))&&Vr(t,"change")}}}};function Pr(t,e,n){Rr(t,e),(J||W)&&setTimeout((()=>{Rr(t,e)}),0)}function Rr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Br(i))>-1,i.selected!==s&&(i.selected=s);else if(E(Br(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Hr(t,e){return e.every((e=>!E(e,t)))}function Br(t){return"_value"in t?t._value:t.value}function Ur(t){t.target.composing=!0}function zr(t){t.target.composing&&(t.target.composing=!1,Vr(t.target,"input"))}function Vr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Kr(t){return!t.componentInstance||t.data&&t.data.transition?t:Kr(t.componentInstance._vnode)}var Jr={bind(t,{value:e},n){const o=(n=Kr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Er(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Kr(o)).data&&o.data.transition?(o.data.show=!0,e?Er(o,(()=>{t.style.display=t.__vOriginalDisplay})):jr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},qr={model:Fr,show:Jr};const Wr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Gr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Gr(He(e.children)):t}function Zr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Xr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Yr=t=>t.tag||le(t),Qr=t=>"show"===t.name;var ts={name:"transition",props:Wr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Yr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Gr(o);if(!s)return o;if(this._leaving)return Xr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=Zr(this),c=this._vnode,l=Gr(c);if(s.data.directives&&s.data.directives.some(Qr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!le(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),Xr(t,o);if("in-out"===n){if(le(s))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const es=A({tag:String,moveClass:String},Wr);function ns(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function os(t){t.data.newPos=t.elm.getBoundingClientRect()}function rs(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete es.mode;var ss={Transition:ts,TransitionGroup:{props:es,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=Je(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=Zr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(ns),t.forEach(os),t.forEach(rs),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;xr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener($r,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener($r,t),n._moveCb=null,kr(n,e))})}})))},methods:{hasMove(t,e){if(!gr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{hr(n,t)})),pr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Sr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=Tn,$n.config.isReservedTag=Vn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=Kn,$n.config.isUnknownElement=function(t){if(!U)return!0;if(Vn(t))return!1;if(t=t.toLowerCase(),null!=Jn[t])return Jn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Jn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Jn[t]=/HTMLUnknownElement/.test(e.toString())},A($n.options.directives,qr),A($n.options.components,ss),$n.prototype.__patch__=U?Lr:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ze(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?Wn(t):void 0,e)},U&&setTimeout((()=>{L.devtools&&et&&et.emit("init",$n)}),0);const is=/\{\{((?:.|\r?\n)+?)\}\}/g,as=/[-.*+?^${}()|[\]\/\\]/g,cs=v((t=>{const e=t[0].replace(as,"\\$&"),n=t[1].replace(as,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ls={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=So(t,"class");n&&(t.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const o=Oo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var us={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=So(t,"style");n&&(t.staticStyle=JSON.stringify(er(n)));const o=Oo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let fs;var ds={decode:t=>(fs=fs||document.createElement("div"),fs.innerHTML=t,fs.textContent)};const ps=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),hs=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ms=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ys=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,gs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,vs=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,$s=`((?:${vs}\\:)?${vs})`,_s=new RegExp(`^<${$s}`),bs=/^\s*(\/?)>/,ws=new RegExp(`^<\\/${$s}[^>]*>`),Cs=/^<!DOCTYPE [^>]+>/i,xs=/^<!\--/,ks=/^<!\[/,As=d("script,style,textarea",!0),Os={},Ss={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ts=/&(?:lt|gt|quot|amp|#39);/g,Ns=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Es=d("pre,textarea",!0),js=(t,e)=>t&&Es(t)&&"\n"===e[0];function Ds(t,e){const n=e?Ns:Ts;return t.replace(n,(t=>Ss[t]))}const Is=/^@|^v-on:/,Ms=/^v-|^@|^:|^#/,Ls=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Ps=/^\(|\)$/g,Rs=/^\[.*\]$/,Hs=/:(.*)$/,Bs=/^:|^\.|^v-bind:/,Us=/\.[^.\]]+(?=[^\]]*$)/g,zs=/^v-slot(:|$)|^#/,Vs=/[\r\n]/,Ks=/[ \f\t\r\n]+/g,Js=v(ds.decode);let qs,Ws,Gs,Zs,Xs,Ys,Qs,ti;function ei(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ci(e),rawAttrsMap:{},parent:n,children:[]}}function ni(t,e){qs=e.warn||$o,Ys=e.isPreTag||T,Qs=e.mustUseProp||T,ti=e.getTagNamespace||T,e.isReservedTag,Gs=_o(e.modules,"transformNode"),Zs=_o(e.modules,"preTransformNode"),Xs=_o(e.modules,"postTransformNode"),Ws=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=oi(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&si(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&si(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),Ys(t.tag)&&(c=!1);for(let n=0;n<Xs.length;n++)Xs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&As(a)){let n=0;const o=a.toLowerCase(),r=Os[o]||(Os[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,As(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),js(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(xs.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(ks.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Cs);if(n){l(n[0].length);continue}const o=t.match(ws);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),js(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(ws.test(o)||_s.test(o)||xs.test(o)||ks.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(_s);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(bs))&&(r=t.match(gs)||t.match(ys));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ms(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ds(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:qs,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||ti(t);J&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];li.test(o.name)||(o.name=o.name.replace(ui,""),e.push(o))}return e}(o));let p=ei(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<Zs.length;t++)p=Zs[t](p,e)||p;a||(!function(t){null!=So(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),Ys(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ri(p),function(t){const e=So(t,"v-if");if(e)t.if=e,si(t,{exp:e,block:t});else{null!=So(t,"v-else")&&(t.else=!0);const e=So(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=So(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(J&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Js(t):s.length?r?"condense"===r&&Vs.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Ks," ")),!a&&" "!==t&&(e=function(t,e){const n=e?cs(e):is;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=go(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Ws))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function oi(t,e){var n;!function(t){const e=Oo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=Oo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=So(t,"scope"),t.slotScope=e||So(t,"slot-scope")):(e=So(t,"slot-scope"))&&(t.slotScope=e);const n=Oo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||wo(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=To(t,zs);if(e){const{name:n,dynamic:o}=ii(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=To(t,zs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ii(e),s=n[o]=ei("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=Oo(n,"name")),function(t){let e;(e=Oo(t,"is"))&&(t.component=e);null!=So(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Gs.length;n++)t=Gs[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Ms.test(r))if(t.hasBindings=!0,a=ai(r.replace(Ms,"")),a&&(r=r.replace(Us,"")),Bs.test(r))r=r.replace(Bs,""),i=go(i),l=Rs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=jo(i,"$event"),l?Ao(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Ao(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Ao(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&Qs(t.tag,t.attrsMap.type,r)?bo(t,r,i,e[n],l):wo(t,r,i,e[n],l);else if(Is.test(r))r=r.replace(Is,""),l=Rs.test(r),l&&(r=r.slice(1,-1)),Ao(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Ms,"");const o=r.match(Hs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Rs.test(c)&&(c=c.slice(1,-1),l=!0)),xo(t,r,s,i,c,l,a,e[n])}else wo(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&Qs(t.tag,t.attrsMap.type,r)&&bo(t,r,"true",e[n])}(t),t}function ri(t){let e;if(e=So(t,"v-for")){const n=function(t){const e=t.match(Ls);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Ps,""),r=o.match(Fs);r?(n.alias=o.replace(Fs,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function si(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ii(t){let e=t.name.replace(zs,"");return e||"#"!==t.name[0]&&(e="default"),Rs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function ai(t){const e=t.match(Us);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ci(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const li=/^xmlns:NS\d+/,ui=/^NS\d+:/;function fi(t){return ei(t.tag,t.attrsList.slice(),t.parent)}var di=[ls,us,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=Oo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=So(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=So(t,"v-else",!0),i=So(t,"v-else-if",!0),a=fi(t);ri(a),Co(a,"type","checkbox"),oi(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,si(a,{exp:a.if,block:a});const c=fi(t);So(c,"v-for",!0),Co(c,"type","radio"),oi(c,e),si(a,{exp:`(${o})==='radio'`+r,block:c});const l=fi(t);return So(l,"v-for",!0),Co(l,":type",o),oi(l,e),si(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const pi={expectHTML:!0,modules:di,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return Eo(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${jo(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Ao(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=Oo(t,"value")||"null",s=Oo(t,"true-value")||"true",i=Oo(t,"false-value")||"false";bo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Ao(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${jo(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${jo(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${jo(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=Oo(t,"value")||"null";r=o?`_n(${r})`:r,bo(t,"checked",`_q(${e},${r})`),Ao(t,"change",jo(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=jo(e,l);a&&(u=`if($event.target.composing)return;${u}`);bo(t,"value",`(${e})`),Ao(t,c,u,null,!0),(i||s)&&Ao(t,"blur","$forceUpdate()")}(t,o,r);else if(!L.isReservedTag(s))return Eo(t,o,r),!1;return!0},text:function(t,e){e.value&&bo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&bo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:ps,mustUseProp:Tn,canBeLeftOpenTag:hs,isReservedTag:Vn,getTagNamespace:Kn,staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(di)};let hi,mi;const yi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function gi(t,e){t&&(hi=yi(e.staticKeys||""),mi=e.isReservedTag||T,vi(t),$i(t,!1))}function vi(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!mi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(hi)))}(t),1===t.type){if(!mi(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];vi(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;vi(n),n.static||(t.static=!1)}}}function $i(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)$i(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)$i(t.ifConditions[n].block,e)}}const _i=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,bi=/\([^)]*?\);*$/,wi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},ki=t=>`if(${t})return null;`,Ai={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:ki("$event.target !== $event.currentTarget"),ctrl:ki("!$event.ctrlKey"),shift:ki("!$event.shiftKey"),alt:ki("!$event.altKey"),meta:ki("!$event.metaKey"),left:ki("'button' in $event && $event.button !== 0"),middle:ki("'button' in $event && $event.button !== 1"),right:ki("'button' in $event && $event.button !== 2")};function Oi(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Si(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Si(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Si(t))).join(",")}]`;const e=wi.test(t.value),n=_i.test(t.value),o=wi.test(t.value.replace(bi,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ai[e])s+=Ai[e],Ci[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=ki(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Ti).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ti(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Ci[t],o=xi[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Ni={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ei{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(t){this.options=t,this.warn=t.warn||$o,this.transforms=_o(t.modules,"transformCode"),this.dataGenFns=_o(t.modules,"genData"),this.directives=A(A({},Ni),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function ji(t,e){const n=new Ei(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Di(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Di(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ii(t,e);if(t.once&&!t.onceProcessed)return Mi(t,e);if(t.for&&!t.forProcessed)return Pi(t,e);if(t.if&&!t.ifProcessed)return Li(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Ui(t,e);let r=`_t(${n}${o?`,function(){return ${o}}`:""}`;const s=t.attrs||t.dynamicAttrs?Ki((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Ui(e,n,!0);return`_c(${t},${Ri(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Ri(t,e));const r=t.inlineTemplate?null:Ui(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Ui(t,e)||"void 0"}function Ii(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Di(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Mi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Li(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Di(t,e)},${e.onceId++},${n})`:Di(t,e)}return Ii(t,e)}function Li(t,e,n,o){return t.ifProcessed=!0,Fi(t.ifConditions.slice(),e,n,o)}function Fi(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Fi(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Mi(t,e):Di(t,e)}}function Pi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Di)(t,e)}})`}function Ri(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Ki(t.attrs)},`),t.props&&(n+=`domProps:${Ki(t.props)},`),t.events&&(n+=`${Oi(t.events,!1)},`),t.nativeEvents&&(n+=`${Oi(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Hi(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Bi(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=ji(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Ki(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Hi(t){return 1===t.type&&("slot"===t.tag||t.children.some(Hi))}function Bi(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Li(t,e,Bi,"null");if(t.for&&!t.forProcessed)return Pi(t,e,Bi);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${Ui(t,e)||"undefined"}:undefined`:Ui(t,e)||"undefined":Di(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Ui(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Di)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(zi(r)||r.ifConditions&&r.ifConditions.some((t=>zi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Vi;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function zi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Vi(t,e){return 1===t.type?Di(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Ji(JSON.stringify(t.text))})`}(t)}function Ki(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Ji(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Ji(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function qi(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function Wi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=qi(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>qi(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const Gi=(Zi=function(t,e){const n=ni(t.trim(),e);!1!==e.optimize&&gi(n,e);const o=ji(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=Zi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:Wi(e)}});var Zi;const{compile:Xi,compileToFunctions:Yi}=Gi(pi);let Qi;function ta(t){return Qi=Qi||document.createElement("div"),Qi.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Qi.innerHTML.indexOf("&#10;")>0}const ea=!!U&&ta(!1),na=!!U&&ta(!0),oa=v((t=>{const e=Wn(t);return e&&e.innerHTML})),ra=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&Wn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=oa(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Yi(e,{outputSourceRange:!1,shouldDecodeNewlines:ea,shouldDecodeNewlinesForHref:na,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return ra.call(this,t,e)},$n.compile=Yi,module.exports=$n;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index 57933181b74..8ceec70714b 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -1,6 +1,6 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 const emptyObject = Object.freeze({});
@@ -30,7 +30,7 @@ function isPrimitive(value) {
 }
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
 function isObject(obj) {
@@ -449,11 +449,7 @@ function parsePath(path) {
 const hasProto = '__proto__' in {};
 // Browser environment sniffing
 const inBrowser = typeof window !== 'undefined';
-// @ts-ignore
-const inWeex = 
-// @ts-ignore
-typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-// @ts-ignore
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
 const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
 const UA = inBrowser && window.navigator.userAgent.toLowerCase();
 const isIE = UA && /msie|trident/.test(UA);
@@ -465,7 +461,7 @@ UA && /chrome\/\d+/.test(UA) && !isEdge;
 UA && /phantomjs/.test(UA);
 const isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
+// @ts-expect-error firebox support
 const nativeWatch = {}.watch;
 let supportsPassive = false;
 if (inBrowser) {
@@ -477,7 +473,6 @@ if (inBrowser) {
                 supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
-        // @ts-ignore
         window.addEventListener('test-passive', null, opts);
     }
     catch (e) { }
@@ -501,7 +496,6 @@ const isServerRendering = () => {
     return _isServer;
 };
 // detect devtools
-// @ts-ignore TODO decalre this types
 const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
@@ -519,9 +513,7 @@ let _Set; // $flow-disable-line
 else {
     // a non-standard Set polyfill that only works with primitive keys.
     _Set = class Set {
-        constructor() {
-            this.set = Object.create(null);
-        }
+        set = Object.create(null);
         has(key) {
             return this.set[key] === true;
         }
@@ -560,14 +552,10 @@ let formatComponentName;
         if (vm.$root === vm) {
             return '<Root>';
         }
-        const options = 
-        // @ts-ignore
-        typeof vm === 'function' && vm.cid != null
-            ? // @ts-ignore
-                vm.options
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
             : vm._isVue
-                ? // @ts-ignore
-                    vm.$options || vm.constructor.options
+                ? vm.$options || vm.constructor.options
                 : vm;
         let name = options.name || options._componentTag;
         const file = options.__file;
@@ -590,7 +578,6 @@ let formatComponentName;
         return res;
     };
     generateComponentTrace = (vm) => {
-        // @ts-ignore
         if (vm._isVue && vm.$parent) {
             const tree = [];
             let currentRecursiveSequence = 0;
@@ -629,6 +616,9 @@ let uid$2 = 0;
  * directives subscribing to it.
  */
 class Dep {
+    static target;
+    id;
+    subs;
     constructor() {
         this.id = uid$2++;
         this.subs = [];
@@ -673,6 +663,32 @@ function popTarget() {
 }
 
 class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
     constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
         this.tag = tag;
         this.data = data;
@@ -704,7 +720,7 @@ class VNode {
         return this.componentInstance;
     }
 }
-const createEmptyVNode = (text = '') => {
+const createEmptyVNode = (text = "") => {
     const node = new VNode();
     node.text = text;
     node.isComment = true;
@@ -718,9 +734,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    const cloned = new VNode(
-    //@ts-expect-error void type not valid here
-    vnode.tag, vnode.data, 
+    const cloned = new VNode(vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
@@ -795,6 +809,9 @@ function toggleObserving(value) {
  * collect dependencies and dispatch updates.
  */
 class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
     constructor(value) {
         this.value = value;
         this.dep = new Dep();
@@ -954,7 +971,6 @@ function set(target, key, val) {
         return val;
     }
     const ob = target.__ob__;
-    // @ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
@@ -980,7 +996,6 @@ function del(target, key) {
         return;
     }
     const ob = target.__ob__;
-    //@ts-ignore
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                 '- just set it to null.');
@@ -1073,11 +1088,7 @@ function mergeDataOrFn(parentVal, childVal, vm) {
         // check if parentVal is a function here because
         // it has to be a function to pass previous merges.
         return function mergedDataFn() {
-            return mergeData(
-            // @ts-ignore
-            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-            // @ts-ignore
-            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
         };
     }
     else {
@@ -1464,7 +1475,6 @@ function assertProp(prop, name, value, vm, absent) {
         return;
     }
     let type = prop.type;
-    // @ts-ignore
     let valid = !type || type === true;
     const expectedTypes = [];
     if (type) {
@@ -1624,6 +1634,7 @@ function invokeWithErrorHandling(handler, context, args, vm, info) {
         }
     }
     catch (e) {
+        // @ts-expect-error should it be any?
         handleError(e, vm, info);
     }
     return res;
@@ -1743,6 +1754,7 @@ function nextTick(cb, ctx) {
                 cb.call(ctx);
             }
             catch (e) {
+                // @ts-expect-error should it be any?
                 handleError(e, ctx, 'nextTick');
             }
         }
@@ -2009,7 +2021,7 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
                     tip(`Prop "${keyInLowerCase}" is passed to component ` +
                         `${formatComponentName(
-                        // @ts-ignore
+                        // @ts-expect-error tag is string
                         tag || Ctor)}, but the declared prop name is` +
                         ` "${key}". ` +
                         `Note that HTML attributes are case-insensitive and camelCased ` +
@@ -2185,7 +2197,6 @@ function resolveInject(inject, vm) {
                             : provideDefault;
                 }
                 else {
-                    // @ts-ignore
                     warn$2(`Injection "${key}" not found`, vm);
                 }
             }
@@ -2239,6 +2250,11 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
+}
+
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     let res;
     const hasNormalSlots = Object.keys(normalSlots).length > 0;
@@ -2264,7 +2280,7 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     else {
         res = {};
         for (const key in slots) {
-            if (slots[key] && key[0] !== '$') {
+            if (slots[key] && key[0] !== "$") {
                 res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
             }
         }
@@ -2280,19 +2296,22 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     if (slots && Object.isExtensible(slots)) {
         slots._normalized = res;
     }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
     const normalized = function () {
         let res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
-            res && typeof res === 'object' && !Array.isArray(res)
+            res && typeof res === "object" && !Array.isArray(res)
                 ? [res] // single vnode
                 : normalizeChildren(res);
-        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
             ? undefined
             : res;
     };
@@ -2358,7 +2377,7 @@ function renderList(val, render) {
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot(name, fallback, props, bindObject) {
+function renderSlot(name, fallbackRender, props, bindObject) {
     const scopedSlotFn = this.$scopedSlots[name];
     let nodes;
     if (scopedSlotFn) {
@@ -2366,18 +2385,26 @@ function renderSlot(name, fallback, props, bindObject) {
         props = props || {};
         if (bindObject) {
             if (!isObject(bindObject)) {
-                warn$2('slot v-bind without argument expects an Object', this);
+                warn$2("slot v-bind without argument expects an Object", this);
             }
             props = extend(extend({}, bindObject), props);
         }
-        nodes = scopedSlotFn(props) || fallback;
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
     else {
-        nodes = this.$slots[name] || fallback;
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
     const target = props && props.slot;
     if (target) {
-        return this.$createElement('template', { slot: target }, nodes);
+        return this.$createElement("template", { slot: target }, nodes);
     }
     else {
         return nodes;
@@ -2415,6 +2442,7 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     else if (eventKeyName) {
         return hyphenate(eventKeyName) !== key;
     }
+    return eventKeyCode === undefined;
 }
 
 /**
@@ -3222,11 +3250,6 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
         for (let i = 0; i < children.length; i++) {
@@ -3380,7 +3403,6 @@ function initLifecycle(vm) {
     vm.$root = parent ? parent.$root : vm;
     vm.$children = [];
     vm.$refs = {};
-    // @ts-ignore
     vm._watcher = null;
     vm._inactive = null;
     vm._directInactive = false;
@@ -3431,11 +3453,10 @@ function lifecycleMixin(Vue) {
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook$1(vm, 'beforeDestroy');
+        callHook$1(vm, "beforeDestroy");
         vm._isBeingDestroyed = true;
         // remove self from parent
         const parent = vm.$parent;
-        // @ts-ignore
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
             remove$2(parent.$children, vm);
         }
@@ -3457,7 +3478,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook$1(vm, 'destroyed');
+        callHook$1(vm, "destroyed");
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3466,7 +3487,6 @@ function lifecycleMixin(Vue) {
         }
         // release circular reference (#6759)
         if (vm.$vnode) {
-            // @ts-expect-error null is not undefined
             vm.$vnode.parent = null;
         }
     };
@@ -3478,19 +3498,19 @@ function mountComponent(vm, el, hydrating) {
         vm.$options.render = createEmptyVNode;
         {
             /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                 vm.$options.el ||
                 el) {
-                warn$2('You are using the runtime-only build of Vue where the template ' +
-                    'compiler is not available. Either pre-compile the templates into ' +
-                    'render functions, or use the compiler-included build.', vm);
+                warn$2("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
             }
             else {
-                warn$2('Failed to mount component: template or render function not defined.', vm);
+                warn$2("Failed to mount component: template or render function not defined.", vm);
             }
         }
     }
-    callHook$1(vm, 'beforeMount');
+    callHook$1(vm, "beforeMount");
     let updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
@@ -3520,7 +3540,7 @@ function mountComponent(vm, el, hydrating) {
     new Watcher(vm, updateComponent, noop, {
         before() {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, 'beforeUpdate');
+                callHook$1(vm, "beforeUpdate");
             }
         },
     }, true /* isRenderWatcher */);
@@ -3529,7 +3549,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook$1(vm, 'mounted');
+        callHook$1(vm, "mounted");
     }
     return vm;
 }
@@ -3546,20 +3566,18 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     const oldScopedSlots = vm.$scopedSlots;
     const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
     const needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
-    // @ts-ignore
     vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
     vm.$vnode = parentVnode; // update vm's placeholder node without re-render
     if (vm._vnode) {
         // update child tree's parent
-        // @ts-ignore
         vm._vnode.parent = parentVnode;
     }
     vm.$options._renderChildren = renderChildren;
@@ -3567,7 +3585,6 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // these are also reactive so they may trigger child update if the child
     // used them during render
     vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
     vm.$listeners = listeners || emptyObject;
     // update props
     if (propsData && vm.$options.props) {
@@ -3619,7 +3636,7 @@ function activateChildComponent(vm, direct) {
         for (let i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'activated');
+        callHook$1(vm, "activated");
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3634,7 +3651,7 @@ function deactivateChildComponent(vm, direct) {
         for (let i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'deactivated');
+        callHook$1(vm, "deactivated");
     }
 }
 function callHook$1(vm, hook) {
@@ -3648,7 +3665,7 @@ function callHook$1(vm, hook) {
         }
     }
     if (vm._hasHookEvent) {
-        vm.$emit('hook:' + hook);
+        vm.$emit("hook:" + hook);
     }
     popTarget();
 }
@@ -3815,6 +3832,23 @@ let uid$1 = 0;
  * This is used for both the $watch() api and directives.
  */
 class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
     constructor(vm, expOrFn, cb, options, isRenderWatcher) {
         this.vm = vm;
         if (isRenderWatcher) {
@@ -3840,8 +3874,8 @@ class Watcher {
         this.newDeps = [];
         this.depIds = new _Set();
         this.newDepIds = new _Set();
-        this.expression =
-            expOrFn.toString() ;
+        this.expression = expOrFn.toString()
+            ;
         // parse expression for getter
         if (typeof expOrFn === 'function') {
             this.getter = expOrFn;
@@ -3851,11 +3885,13 @@ class Watcher {
             if (!this.getter) {
                 this.getter = noop;
                 warn$2(`Failed watching path: "${expOrFn}" ` +
-                        'Watcher only accepts simple dot-delimited paths. ' +
-                        'For full control, use a function instead.', vm);
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
             }
         }
-        this.value = this.lazy ? undefined : this.get();
+        this.value = this.lazy
+            ? undefined
+            : this.get();
     }
     /**
      * Evaluate the getter, and re-collect dependencies.
@@ -3869,6 +3905,7 @@ class Watcher {
         }
         catch (e) {
             if (this.user) {
+                // @ts-expect-error e is unknown, should we cast or any?
                 handleError(e, vm, `getter for watcher "${this.expression}"`);
             }
             else {
@@ -3952,12 +3989,8 @@ class Watcher {
                 const oldValue = this.value;
                 this.value = value;
                 if (this.user) {
-                    try {
-                        this.cb.call(this.vm, value, oldValue);
-                    }
-                    catch (e) {
-                        handleError(e, this.vm, `callback for watcher "${this.expression}"`);
-                    }
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                 }
                 else {
                     this.cb.call(this.vm, value, oldValue);
@@ -4077,11 +4110,11 @@ function initProps$1(vm, propsOptions) {
 }
 function initData(vm) {
     let data = vm.$options.data;
-    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        warn$2('data functions should return an object:\n' +
-                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+        warn$2("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
     }
     // proxy data on instance
     const keys = Object.keys(data);
@@ -4128,7 +4161,7 @@ function initComputed$1(vm, computed) {
     const isSSR = isServerRendering();
     for (const key in computed) {
         const userDef = computed[key];
-        const getter = typeof userDef === 'function' ? userDef : userDef.get;
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
         if (getter == null) {
             warn$2(`Getter is missing for computed property "${key}".`, vm);
         }
@@ -4149,12 +4182,15 @@ function initComputed$1(vm, computed) {
             else if (vm.$options.props && key in vm.$options.props) {
                 warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
             }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
+            }
         }
     }
 }
 function defineComputed(target, key, userDef) {
     const shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
+    if (typeof userDef === "function") {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
             : createGetterInvoker(userDef);
@@ -4198,7 +4234,7 @@ function initMethods(vm, methods) {
     const props = vm.$options.props;
     for (const key in methods) {
         {
-            if (typeof methods[key] !== 'function') {
+            if (typeof methods[key] !== "function") {
                 warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
                     `Did you reference the function correctly?`, vm);
             }
@@ -4210,7 +4246,8 @@ function initMethods(vm, methods) {
                     `Avoid defining component methods that start with _ or $.`);
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
@@ -4231,7 +4268,7 @@ function createWatcher(vm, expOrFn, handler, options) {
         options = handler;
         handler = handler.handler;
     }
-    if (typeof handler === 'string') {
+    if (typeof handler === "string") {
         handler = vm[handler];
     }
     return vm.$watch(expOrFn, handler, options);
@@ -4250,15 +4287,15 @@ function stateMixin(Vue) {
     };
     {
         dataDef.set = function () {
-            warn$2('Avoid replacing instance root $data. ' +
-                'Use nested data properties instead.', this);
+            warn$2("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
         };
         propsDef.set = function () {
             warn$2(`$props is readonly.`, this);
         };
     }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
@@ -4270,13 +4307,9 @@ function stateMixin(Vue) {
         options.user = true;
         const watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
             pushTarget();
-            try {
-                cb.call(vm, watcher.value);
-            }
-            catch (error) {
-                handleError(error, vm, `callback for immediate watcher "${watcher.expression}"`);
-            }
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
             popTarget();
         }
         return function unwatchFn() {
@@ -4336,7 +4369,6 @@ function initMixin$1(Vue) {
     };
 }
 function initInternalComponent(vm, options) {
-    // @ts-ignore
     const opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
     const parentVnode = options._parentVnode;
@@ -4391,19 +4423,19 @@ function resolveModifiedOptions(Ctor) {
 
 function Vue(options) {
     if (!(this instanceof Vue)) {
-        warn$2('Vue is a constructor and should be called with the `new` keyword');
+        warn$2("Vue is a constructor and should be called with the `new` keyword");
     }
     this._init(options);
 }
-//@ts-ignore
+//@ts-expect-error Vue has function type
 initMixin$1(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 stateMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 eventsMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 lifecycleMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
 function initUse(Vue) {
@@ -4540,6 +4572,7 @@ function initAssetRegisters(Vue) {
     });
 }
 
+/* @flow */
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4547,8 +4580,8 @@ function matches(pattern, name) {
     if (Array.isArray(pattern)) {
         return pattern.indexOf(name) > -1;
     }
-    else if (typeof pattern === 'string') {
-        return pattern.split(',').indexOf(name) > -1;
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
     }
     else if (isRegExp(pattern)) {
         return pattern.test(name);
@@ -4559,9 +4592,9 @@ function matches(pattern, name) {
 function pruneCache(keepAliveInstance, filter) {
     const { cache, keys, _vnode } = keepAliveInstance;
     for (const key in cache) {
-        const cachedNode = cache[key];
-        if (cachedNode) {
-            const name = getComponentName(cachedNode.componentOptions);
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
             if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
@@ -4569,24 +4602,43 @@ function pruneCache(keepAliveInstance, filter) {
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    const cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-        //@ts-expect-error has void type
-        cached.componentInstance.$destroy();
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
     }
     cache[key] = null;
     remove$2(keys, key);
 }
 const patternTypes = [String, RegExp, Array];
-// TODO use defineComponent
+// TODO defineComponent
 var KeepAlive = {
-    name: 'keep-alive',
+    name: "keep-alive",
     abstract: true,
     props: {
         include: patternTypes,
         exclude: patternTypes,
         max: [String, Number],
     },
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
     created() {
         this.cache = Object.create(null);
         this.keys = [];
@@ -4597,13 +4649,17 @@ var KeepAlive = {
         }
     },
     mounted() {
-        this.$watch('include', (val) => {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
             pruneCache(this, (name) => matches(val, name));
         });
-        this.$watch('exclude', (val) => {
+        this.$watch("exclude", (val) => {
             pruneCache(this, (name) => !matches(val, name));
         });
     },
+    updated() {
+        this.cacheVNode();
+    },
     render() {
         const slot = this.$slots.default;
         const vnode = getFirstComponentChild(slot);
@@ -4624,7 +4680,7 @@ var KeepAlive = {
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : '')
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4633,13 +4689,11 @@ var KeepAlive = {
                 keys.push(key);
             }
             else {
-                cache[key] = vnode;
-                keys.push(key);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
             }
+            // @ts-expect-error can vnode.data can be undefined
             vnode.data.keepAlive = true;
         }
         return vnode || (slot && slot[0]);
@@ -4705,15 +4759,15 @@ Object.defineProperty(Vue.prototype, '$ssrContext', {
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
     value: FunctionalRenderContext,
 });
-Vue.version = '2.6.12';
+Vue.version = '2.6.14';
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
 const isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-const acceptValue$1 = makeMap('input,textarea,option,select,progress');
-const mustUseProp$1 = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
@@ -4755,6 +4809,7 @@ function genClassForVnode(vnode) {
             data = mergeClassData(childNode.data, data);
         }
     }
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while (isDef((parentNode = parentNode.parent))) {
         if (parentNode && parentNode.data) {
             data = mergeClassData(data, parentNode.data);
@@ -4819,7 +4874,7 @@ const namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-const isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4832,14 +4887,15 @@ const isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-const isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isReservedTag$1 = (tag) => {
-    return isHTMLTag$1(tag) || isSVG$1(tag);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
 };
-function getTagNamespace$1(tag) {
-    if (isSVG$1(tag)) {
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
         return 'svg';
     }
     // basic support for MathML
@@ -4854,7 +4910,7 @@ function isUnknownElement(tag) {
     if (!inBrowser) {
         return true;
     }
-    if (isReservedTag$1(tag)) {
+    if (isReservedTag(tag)) {
         return false;
     }
     tag = tag.toLowerCase();
@@ -4878,7 +4934,7 @@ const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 /**
  * Query an element selector if it's not an element already.
  */
-function query$1(el) {
+function query(el) {
     if (typeof el === 'string') {
         const selected = document.querySelector(el);
         if (!selected) {
@@ -4976,25 +5032,22 @@ function registerRef(vnode, isRemoval) {
     const vm = vnode.context;
     const ref = vnode.componentInstance || vnode.elm;
     const refs = vm.$refs;
+    const obj = refs[key];
     if (isRemoval) {
-        if (Array.isArray(refs[key])) {
-            // @ts-expect-error invalid typings
-            remove$2(refs[key], ref);
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
         }
-        else if (refs[key] === ref) {
+        else if (obj === ref) {
             refs[key] = undefined;
         }
     }
     else {
-        // @ts-expect-error invalid typings
         if (vnode.data.refInFor) {
-            if (!Array.isArray(refs[key])) {
+            if (!Array.isArray(obj)) {
                 refs[key] = [ref];
-                // @ts-expect-error invalid typings
             }
-            else if (refs[key].indexOf(ref) < 0) {
-                // @ts-expect-error invalid typings
-                refs[key].push(ref);
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
             }
         }
         else {
@@ -5018,13 +5071,11 @@ const emptyNode = new VNode('', {}, []);
 const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
-        ((a.tag === b.tag &&
-            a.isComment === b.isComment &&
-            isDef(a.data) === isDef(b.data) &&
-            sameInputType(a, b)) ||
-            (isTrue(a.isAsyncPlaceholder) &&
-                a.asyncFactory === b.asyncFactory &&
-                isUndef(b.asyncFactory.error))));
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
 }
 function sameInputType(a, b) {
     if (a.tag !== 'input')
@@ -5835,6 +5886,7 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
+            // @ts-expect-error should it be any?
             handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
         }
     }
@@ -6384,10 +6436,127 @@ function parseString(chr) {
     }
 }
 
+let warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-const RANGE_TOKEN$1 = '__r';
+const RANGE_TOKEN = '__r';
 const CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6395,11 +6564,11 @@ const CHECKBOX_RADIO_TOKEN = '__c';
 // user-attached handlers.
 function normalizeEvents(on) {
     /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN$1])) {
+    if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
         const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
-        delete on[RANGE_TOKEN$1];
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
     // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6433,7 +6602,7 @@ function add(name, handler, capture, passive) {
     if (useMicrotaskFix) {
         const attachedTimestamp = currentFlushTimestamp;
         const original = handler;
-        //@ts-expect-error
+        //@ts-expect-error 
         handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
@@ -6467,7 +6636,9 @@ function updateDOMListeners(oldVnode, vnode) {
     }
     const on = vnode.data.on || {};
     const oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
     normalizeEvents(on);
     updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
     target = undefined;
@@ -6475,6 +6646,8 @@ function updateDOMListeners(oldVnode, vnode) {
 var events = {
     create: updateDOMListeners,
     update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
 let svgContainer;
@@ -6522,7 +6695,7 @@ function updateDOMProps(oldVnode, vnode) {
             }
         }
         else if (key === 'innerHTML' &&
-            isSVG$1(elm.tagName) &&
+            isSVG(elm.tagName) &&
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
@@ -6639,6 +6812,7 @@ function getStyle(vnode, checkChild) {
         extend(res, styleData);
     }
     let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6828,13 +7002,11 @@ let animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
-        // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
         transitionProp = 'WebkitTransition';
         transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
-        // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
         animationProp = 'WebkitAnimation';
         animationEndEvent = 'webkitAnimationEnd';
@@ -7576,7 +7748,6 @@ const props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
-// @ts-ignore
 delete props.mode;
 var TransitionGroup = {
     props,
@@ -7594,7 +7765,7 @@ var TransitionGroup = {
         };
     },
     render(h) {
-        const tag = this.tag || this.$vnode.data.tag || 'span';
+        const tag = this.tag || this.$vnode.data.tag || "span";
         const map = Object.create(null);
         const prevChildren = (this.prevChildren = this.children);
         const rawChildren = this.$slots.default || [];
@@ -7603,7 +7774,7 @@ var TransitionGroup = {
         for (let i = 0; i < rawChildren.length; i++) {
             const c = rawChildren[i];
             if (c.tag) {
-                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                     children.push(c);
                     map[c.key] = c;
                     (c.data || (c.data = {})).transition = transitionData;
@@ -7611,7 +7782,7 @@ var TransitionGroup = {
                 else {
                     const opts = c.componentOptions;
                     const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ''
+                        ? opts.Ctor.options.name || opts.tag || ""
                         : c.tag;
                     warn$2(`<transition-group> children must be keyed: <${name}>`);
                 }
@@ -7623,9 +7794,8 @@ var TransitionGroup = {
             for (let i = 0; i < prevChildren.length; i++) {
                 const c = prevChildren[i];
                 c.data.transition = transitionData;
-                // @ts-ignore
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
                 c.data.pos = c.elm.getBoundingClientRect();
-                // @ts-ignore
                 if (map[c.key]) {
                     kept.push(c);
                 }
@@ -7640,7 +7810,7 @@ var TransitionGroup = {
     },
     updated() {
         const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || 'v') + '-move';
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -7654,12 +7824,11 @@ var TransitionGroup = {
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
         children.forEach((c) => {
-            // @ts-ignore
             if (c.data.moved) {
                 const el = c.elm;
                 const s = el.style;
                 addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
                 el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                     if (e && e.target !== el) {
                         return;
@@ -7695,7 +7864,7 @@ var TransitionGroup = {
                 });
             }
             addClass(clone, moveClass);
-            clone.style.display = 'none';
+            clone.style.display = "none";
             this.$el.appendChild(clone);
             const info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
@@ -7705,36 +7874,27 @@ var TransitionGroup = {
 };
 function callPendingCbs(c) {
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._moveCb) {
-        //@ts-ignore
         c.elm._moveCb();
     }
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._enterCb) {
-        //@ts-ignore
         c.elm._enterCb();
     }
 }
 function recordPosition(c) {
-    //@ts-ignore
     c.data.newPos = c.elm.getBoundingClientRect();
 }
 function applyTranslation(c) {
-    //@ts-ignore
     const oldPos = c.data.pos;
-    //@ts-ignore
     const newPos = c.data.newPos;
     const dx = oldPos.left - newPos.left;
     const dy = oldPos.top - newPos.top;
     if (dx || dy) {
-        //@ts-ignore
         c.data.moved = true;
-        //@ts-ignore
         const s = c.elm.style;
         s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = '0s';
+        s.transitionDuration = "0s";
     }
 }
 
@@ -7744,10 +7904,10 @@ var platformComponents = {
 };
 
 // install platform specific utils
-Vue.config.mustUseProp = mustUseProp$1;
-Vue.config.isReservedTag = isReservedTag$1;
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace$1;
+Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
@@ -7756,7 +7916,7 @@ extend(Vue.options.components, platformComponents);
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
 // public mount method
 Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query$1(el) : undefined;
+    el = el && inBrowser ? query(el) : undefined;
     return mountComponent(this, el, hydrating);
 };
 // devtools global hook
@@ -7783,75 +7943,6 @@ if (inBrowser) {
     }, 0);
 }
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-makeMap('contenteditable,draggable,spellcheck');
-makeMap('events,caret,typing,plaintext-only');
-makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
 const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
 const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
 const buildRegex = cached((delimiters) => {
@@ -7905,7 +7996,7 @@ function transformNode$1(el, options) {
         }
     }
     if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass);
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
     }
     const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
     if (classBinding) {
@@ -7974,11 +8065,11 @@ var he = {
     },
 };
 
-makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
@@ -8283,7 +8374,7 @@ const invalidAttributeRE = /[\s"'<>\/=]/;
 const decodeHTMLCached = cached(he.decode);
 const emptySlotScopeToken = `_empty_`;
 // configurable state
-let warn$1;
+let warn;
 let delimiters;
 let transforms;
 let preTransforms;
@@ -8307,7 +8398,7 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
+    warn = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
@@ -8331,7 +8422,7 @@ function parse(template, options) {
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn$1(msg, range);
+            warn(msg, range);
         }
     }
     function closeElement(element) {
@@ -8412,7 +8503,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn$1,
+        warn,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8444,7 +8535,7 @@ function parse(template, options) {
                 }
                 attrs.forEach((attr) => {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
                             `spaces, quotes, <, >, / or =.`, {
                             start: attr.start + attr.name.indexOf(`[`),
                             end: attr.start + attr.name.length,
@@ -8454,7 +8545,7 @@ function parse(template, options) {
             }
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
-                warn$1('Templates should only be responsible for mapping the state to the ' +
+                warn('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
                         `<${tag}>` +
                         ', as they will not be parsed.', { start: element.start });
@@ -8645,7 +8736,7 @@ function processKey(el) {
     if (exp) {
         {
             if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
                 const iterator = el.iterator2 || el.iterator1;
@@ -8654,7 +8745,7 @@ function processKey(el) {
                     iterator === exp &&
                     parent &&
                     parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                    warn(`Do not use v-for index as key on <transition-group> children, ` +
                         `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
@@ -8677,7 +8768,7 @@ function processFor(el) {
             extend(el, res);
         }
         else {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
         }
     }
 }
@@ -8729,7 +8820,7 @@ function processIfConditions(el, parent) {
         });
     }
     else {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
             `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
@@ -8741,7 +8832,7 @@ function findPrevElement(children) {
         }
         else {
             if (children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
                     `will be ignored.`, children[i]);
             }
             children.pop();
@@ -8768,7 +8859,7 @@ function processSlotContent(el) {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
                 `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
                 `can also be used on plain elements in addition to <template> to ` +
                 `denote scoped slots.`, el.rawAttrsMap['scope'], true);
@@ -8778,7 +8869,7 @@ function processSlotContent(el) {
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
                 `(v-for takes higher priority). Use a wrapper <template> for the ` +
                 `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
         }
@@ -8803,10 +8894,10 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                        warn(`<template v-slot> can only appear at the root level inside ` +
                             `the receiving component`, el);
                     }
                 }
@@ -8822,13 +8913,13 @@ function processSlotContent(el) {
             if (slotBinding) {
                 {
                     if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                        warn(`To avoid scope ambiguity, the default slot should also use ` +
                             `<template> syntax when there are other named slots.`, slotBinding);
                     }
                 }
@@ -8860,7 +8951,7 @@ function getSlotName(binding) {
             name = 'default';
         }
         else {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+            warn(`v-slot shorthand syntax requires a slot name.`, binding);
         }
     }
     return dynamicArgRE.test(name)
@@ -8874,7 +8965,7 @@ function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
                 `and can possibly expand into multiple elements. ` +
                 `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
         }
@@ -8913,7 +9004,7 @@ function processAttrs(el) {
                     name = name.slice(1, -1);
                 }
                 if (value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
@@ -8927,14 +9018,14 @@ function processAttrs(el) {
                     if (modifiers.sync) {
                         syncGen = genAssignmentCode(value, `$event`);
                         if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
                             );
                         }
                     }
@@ -8954,7 +9045,7 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
             }
             else {
                 // normal directives
@@ -8981,7 +9072,7 @@ function processAttrs(el) {
             {
                 const res = parseText(value, delimiters);
                 if (res) {
-                    warn$1(`${name}="${value}": ` +
+                    warn(`${name}="${value}": ` +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9024,7 +9115,7 @@ function makeAttrsMap(attrs) {
         if (map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9057,7 +9148,7 @@ function checkForAliasModel(el, value) {
     let _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
+            warn(`<${el.tag} v-model="${value}">: ` +
                 `You are binding v-model directly to a v-for iteration alias. ` +
                 `This will not be able to modify the v-for source array because ` +
                 `writing to the alias is like modifying a function local variable. ` +
@@ -9137,132 +9228,11 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model$1 = {
+var model = {
     preTransformNode,
 };
 
-var modules = [klass, style, model$1];
-
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
+var modules = [klass, style, model];
 
 function text(el, dir) {
     if (dir.value) {
@@ -9277,24 +9247,11 @@ function html(el, dir) {
 }
 
 var directives = {
-    model,
+    model: model$1,
     text,
     html,
 };
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
 const baseOptions = {
     expectHTML: true,
     modules,
@@ -9305,7 +9262,6 @@ const baseOptions = {
     canBeLeftOpenTag,
     isReservedTag,
     getTagNamespace,
-    // @ts-ignore
     staticKeys: genStaticKeys$1(modules),
 };
 
@@ -9594,6 +9550,15 @@ var baseDirectives = {
 };
 
 class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
     constructor(options) {
         this.options = options;
         this.warn = options.warn || baseWarn;
@@ -10018,13 +9983,13 @@ function genComment(comment) {
 function genSlot(el, state) {
     const slotName = el.slotName || '"default"';
     const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,${children}` : ''}`;
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
     const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
             // slot props are camelized
             name: camelize(attr.name),
             value: attr.value,
-            dynamic: attr.dynamic,
+            dynamic: attr.dynamic
         })))
         : null;
     const bind = el.attrsMap['v-bind'];
@@ -10482,4 +10447,4 @@ function getOuterHTML(el) {
 }
 Vue.compile = compileToFunctions;
 
-export default Vue;
+export { Vue as default };
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
index 323ab982f91..552fbd0e84b 100644
--- a/dist/vue.esm.browser.min.js
+++ b/dist/vue.esm.browser.min.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,E=t=>t;function N(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>N(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>N(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(N(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const L=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var I={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),q=K&&/msie|trident/.test(K),J=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const Z=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const G=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{constructor(){this.set=Object.create(null)}has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let st=S,it=0;class at{constructor(){this.id=it++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const s=new at,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function kt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}const At=I.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=ot?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{At[t]=Tt})),L.forEach((function(t){At[t+"s"]=Et})),At.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Nt=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Nt;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function Lt(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==It(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(i),$t(e)}return i}const Mt=/^\s*function (\w+)/;function It(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return It(t)===It(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Rt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Rt(t,o,r)}return s}function Bt(t,e,n){if(I.errorHandler)try{return I.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,qt=!1;function Jt(){qt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(Jt),Z&&setTimeout(S)},zt=!0}else if(q||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(Jt)}:()=>{setTimeout(Jt,0)};else{let t=1;const e=new MutationObserver(Jt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Zt=new rt;function Gt(t){Xt(t,Zt),Zt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),s(f.name,n[c],f.capture))}function ee(t,r,s){let i;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ne(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?se(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=se(c,`${s||""}_${a}`),re(c[0])&&re(u)&&(i[l]=pt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?re(u)?i[l]=pt(u.text+c):""!==c&&i.push(pt(c)):re(c)&&re(u)?i[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ie(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ue(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=fe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",i),R(r,"$key",a),R(r,"$hasNormal",s),r}function ue(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});return t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t),t&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function fe(t,e){return()=>t[e]}function de(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||e):s=this.$slots[t]||e;const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function he(t){return Dt(this.$options,"filters",t)||E}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,o,r){const s=I.keyCodes[e]||n;return r&&o&&!I.keyCodes[e]?me(r,o):s?me(s,t):o?C(o)!==e:void 0}function ge(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||I.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function ve(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),_e(o,`__static__${t}`,!1)),o}function $e(t,e,n){return _e(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function _e(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&be(t[o],`${e}_${o}`,n);else be(t,e,n)}function be(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function we(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function Ce(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?Ce(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function xe(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function ke(t,e){return"string"==typeof t?e+t:t}function Ae(t){t._o=$e,t._n=f,t._s=u,t._l=de,t._t=pe,t._q=N,t._i=j,t._m=ve,t._f=he,t._k=ye,t._b=ge,t._v=pt,t._e=dt,t._u=Ce,t._g=we,t._d=xe,t._p=ke}function Oe(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ie(a.inject,s),this.slots=()=>(this.$slots||le(e.scopedSlots,this.$slots=ae(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Le(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Le(c,t,e,n,o,u)}function Se(t,e,n,o,r){const s=ht(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Te(t,e){for(const n in e)t[_(n)]=e[n]}Ae(Oe.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Lt(s,i,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ge(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ze(e,!0):e.$destroy())}},Ne=Object.keys(Ee);function je(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,void 0===(r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Fe;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=Pe(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Pe(h.error,r)),n(h.loading)&&(t.loadingComp=Pe(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f))))return function(t,e,n,o,r){const s=dt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ne(i,c,t,e,!0)||ne(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Lt(e,l,o||t);else n(r.attrs)&&Te(c,r.attrs),n(r.props)&&Te(c,r.props);const u=new Oe(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Se(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Se(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Ne.length;t++){const n=Ne[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?De(r,o):r)}}(i);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function De(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Le(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=oe(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||I.getTagNamespace(e),a=I.isReservedTag(e)?new ft(I.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=Dt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):je(s,o,t,r,e)}else a=je(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Me(a,c),n(o)&&function(t){s(t.style)&&Gt(t.style);s(t.class)&&Gt(t.class)}(o),a):dt()}(t,e,i,a,c)}function Me(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Me(a,r,s)}}let Ie,Fe=null;function Pe(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Re(t){return t.isComment&&t.asyncFactory}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||Re(o)))return o}}function Be(t,e){Ie.$on(t,e)}function Ue(t,e){Ie.$off(t,e)}function ze(t,e){const n=Ie;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Ie=t,te(e,n||{},Be,Ue,ze,t),Ie=void 0}let Ke=null;function qe(t){const e=Ke;return Ke=t,()=>{Ke=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ge(t,"activated")}}function Ze(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ze(t.$children[e]);Ge(t,"deactivated")}}function Ge(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!q){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ge(o,"updated")}}(o),et&&I.devtools&&et.emit("flush")}let an=0;class cn{constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Gt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,`callback for watcher "${this.expression}"`)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const s in e){r.push(s);wt(o,s,Lt(s,e,n,t)),s in t||un(t,"_props",s)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new cn(t,i||S,S,dn)),r in t||pn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=jt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,L.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=bn(s.componentOptions);i&&!e(i)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Le(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Le(e,t,n,o,r,!0);const s=o&&o.data;wt(e,"$attrs",s&&s.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ge(n,"beforeCreate"),function(t){const e=ie(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ge(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){lt();try{e.call(o,r.value)}catch(t){Rt(t,o,`callback for immediate watcher "${r.expression}"`)}ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=qe(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ge(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ge(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){Ae(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=le(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Fe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Fe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const kn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(s[a]=e,i.push(a),this.max&&i.length>parseInt(this.max)&&xn(s,i[0],i,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>I};Object.defineProperty(t,"config",e),t.util={warn:st,extend:A,mergeOptions:jt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),L.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),_n(t),function(t){L.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Oe}),$n.version="2.6.12";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=d("contenteditable,draggable,spellcheck"),En=d("events,caret,typing,plaintext-only"),Nn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),jn="http://www.w3.org/1999/xlink",Dn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Ln=t=>Dn(t)?t.slice(6,t.length):"",Mn=t=>null==t||!1===t;function In(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Fn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Fn(e,o.data));return function(t,e){if(n(t)||n(e))return Pn(t,Rn(e));return""}(e.staticClass,e.class)}function Fn(t,e){return{staticClass:Pn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Pn(t,e){return t?e?t+" "+e:t:e||""}function Rn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Rn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Hn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Bn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Un=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),zn=t=>Bn(t)||Un(t);const Vn=Object.create(null);const Kn=d("text,number,password,search,email,tel,url");var qn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Hn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Jn={create(t,e){Wn(e)},update(t,e){t.data.ref!==e.data.ref&&(Wn(t,!0),Wn(e))},destroy(t){Wn(t,!0)}};function Wn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs;e?Array.isArray(i[o])?m(i[o],s):i[o]===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(i[o])?i[o].indexOf(s)<0&&i[o].push(s):i[o]=[s]:i[o]=s}const Zn=new ft("",{},[]),Gn=["create","activate","update","remove","destroy"];function Xn(t,r){return t.key===r.key&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Kn(r)&&Kn(s)}(t,r)||o(t.isAsyncPlaceholder)&&t.asyncFactory===r.asyncFactory&&e(r.asyncFactory.error))}function Yn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var Qn={create:to,update:to,destroy:function(t){to(t,Zn)}};function to(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Zn,o=e===Zn,r=no(t.data.directives,t.context),s=no(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ro(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ro(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)ro(i[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ro(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||ro(r[c],"unbind",t,t,o)}(t,e)}const eo=Object.create(null);function no(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=eo),n[oo(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function oo(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ro(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var so=[Jn,Qn];function io(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&ao(c,s,i,o.data.pre);for(s in(q||W)&&u.value!==l.value&&ao(c,"value",u.value),l)e(u[s])&&(Dn(s)?c.removeAttributeNS(jn,Ln(s)):Tn(s)||c.removeAttribute(s))}function ao(t,e,n,o){o||t.tagName.indexOf("-")>-1?co(t,e,n):Nn(e)?Mn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Tn(e)?t.setAttribute(e,((t,e)=>Mn(e)||"false"===e?"false":"contenteditable"===t&&En(e)?e:"true")(e,n)):Dn(e)?Mn(n)?t.removeAttributeNS(jn,Ln(e)):t.setAttributeNS(jn,e,n):co(t,e,n)}function co(t,e,n){if(Mn(n))t.removeAttribute(e);else{if(q&&!J&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var lo={create:io,update:io};function uo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=In(o);const c=r._transitionClasses;n(c)&&(a=Pn(a,Rn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var fo={create:uo,update:uo};const po=/[\w).+\-_$\]]/;function ho(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&po.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=mo(r,s[o]);return r}function mo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function yo(t,e){console.error(`[Vue compiler]: ${t}`)}function go(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function vo(t,e,n,o,r){(t.props||(t.props=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function $o(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(Oo({name:e,value:n,dynamic:r},o)),t.plain=!1}function _o(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(Oo({name:e,value:n},o))}function bo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(Oo({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function wo(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Co(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=wo("!",n,c)),r.once&&(delete r.once,n=wo("~",n,c)),r.passive&&(delete r.passive,n=wo("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=Oo({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function xo(t,e,n){const o=ko(t,":"+e)||ko(t,"v-bind:"+e);if(null!=o)return ho(o);if(!1!==n){const n=ko(t,e);if(null!=n)return JSON.stringify(n)}}function ko(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function Ao(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function Oo(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function So(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=To(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function To(t,e){const n=function(t){if(t=t.trim(),Eo=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Eo-1)return Do=t.lastIndexOf("."),Do>-1?{exp:t.slice(0,Do),key:'"'+t.slice(Do+1)+'"'}:{exp:t,key:null};No=t,Do=Lo=Mo=0;for(;!Fo();)jo=Io(),Po(jo)?Ho(jo):91===jo&&Ro(jo);return{exp:t.slice(0,Lo),key:t.slice(Lo+1,Mo)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Eo,No,jo,Do,Lo,Mo;function Io(){return No.charCodeAt(++Do)}function Fo(){return Do>=Eo}function Po(t){return 34===t||39===t}function Ro(t){let e=1;for(Lo=Do;!Fo();)if(Po(t=Io()))Ho(t);else if(91===t&&e++,93===t&&e--,0===e){Mo=Do;break}}function Ho(t){const e=t;for(;!Fo()&&(t=Io())!==e;);}let Bo;function Uo(t,e,n){const o=Bo;return function r(){const s=e.apply(null,arguments);null!==s&&Ko(t,r,n,o)}}const zo=zt&&!(G&&Number(G[1])<=53);function Vo(t,e,n,o){if(zo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Bo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Ko(t,e,n,o){(o||Bo).removeEventListener(t,e._wrapper||e,n)}function qo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Bo=o.elm,function(t){if(n(t.__r)){const e=q?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,s,Vo,Ko,Uo,o.context),Bo=void 0}var Jo={create:qo,update:qo};let Wo;function Zo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Go(i,t)&&(i.value=t)}else if("innerHTML"===r&&Un(i.tagName)&&e(i.innerHTML)){Wo=Wo||document.createElement("div"),Wo.innerHTML=`<svg>${s}</svg>`;const t=Wo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Go(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var Xo={create:Zo,update:Zo};const Yo=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function Qo(t){const e=tr(t.style);return t.staticStyle?A(t.staticStyle,e):e}function tr(t){return Array.isArray(t)?O(t):"string"==typeof t?Yo(t):t}const er=/^--/,nr=/\s*!important$/,or=(t,e,n)=>{if(er.test(e))t.style.setProperty(e,n);else if(nr.test(n))t.style.setProperty(C(e),n.replace(nr,""),"important");else{const o=ir(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},rr=["Webkit","Moz","ms"];let sr;const ir=v((function(t){if(sr=sr||document.createElement("div").style,"filter"!==(t=_(t))&&t in sr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<rr.length;t++){const n=rr[t]+e;if(n in sr)return n}}));function ar(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=tr(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=Qo(e.data))&&A(n,o)}(o=Qo(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=Qo(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&or(c,a,"");for(a in p)i=p[a],i!==f[a]&&or(c,a,null==i?"":i)}var cr={create:ar,update:ar};const lr=/\s+/;function ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function fr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(lr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function dr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,pr(t.name||"v")),A(e,t),e}return"string"==typeof t?pr(t):void 0}}const pr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),hr=U&&!J;let mr="transition",yr="transitionend",gr="animation",vr="animationend";hr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(mr="WebkitTransition",yr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(gr="WebkitAnimation",vr="webkitAnimationEnd"));const $r=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function _r(t){$r((()=>{$r(t)}))}function br(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),ur(t,e))}function wr(t,e){t._transitionClasses&&m(t._transitionClasses,e),fr(t,e)}function Cr(t,e,n){const{type:o,timeout:r,propCount:s}=kr(t,e);if(!o)return n();const i="transition"===o?yr:vr;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const xr=/\b(transform|all)(,|$)/;function kr(t,e){const n=window.getComputedStyle(t),o=(n[mr+"Delay"]||"").split(", "),r=(n[mr+"Duration"]||"").split(", "),s=Ar(o,r),i=(n[gr+"Delay"]||"").split(", "),a=(n[gr+"Duration"]||"").split(", "),c=Ar(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&xr.test(n[mr+"Property"])}}function Ar(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Or(e)+Or(t[n]))))}function Or(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Sr(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=dr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Ke,A=Ke.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,E=O&&h?h:u,N=O&&_||y,j=O&&"function"==typeof b?b:g,L=O&&w||v,M=O&&C||$,I=f(s(x)?x.enter:x),F=!1!==a&&!J,P=Nr(j),R=r._enterCb=D((()=>{F&&(wr(r,E),wr(r,T)),R.cancelled?(F&&wr(r,S),M&&M(r)):L&&L(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),N&&N(r),F&&(br(r,S),br(r,T),_r((()=>{wr(r,S),R.cancelled||(br(r,E),P||(Er(I)?setTimeout(R,I):Cr(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function Tr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=dr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!J,_=Nr(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(wr(r,u),wr(r,d)),w.cancelled?($&&wr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(br(r,l),br(r,d),_r((()=>{wr(r,l),w.cancelled||(br(r,u),_||(Er(b)?setTimeout(w,b):Cr(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Er(t){return"number"==typeof t&&!isNaN(t)}function Nr(t){if(e(t))return!1;const o=t.fns;return n(o)?Nr(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function jr(t,e){!0!==e.data.show&&Sr(e)}const Dr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Gn.length;++s)for(a[Gn[s]]=[],i=0;i<c.length;++i)n(c[i][Gn[s]])&&a[Gn[s]].push(c[i][Gn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Zn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Wn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Zn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Xn(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:Xn(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):Xn(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):Xn(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):Xn(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=Yn(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],Xn(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Gt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Xn(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Zn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Wn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:qn,modules:[lo,fo,Jo,Xo,cr,U?{create:jr,activate:jr,remove(t,e){!0!==t.data.show?Tr(t,e):e()}}:{}].concat(so)});J&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Br(t,"input")}));const Lr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Lr.componentUpdated(t,e,n)})):Mr(t,e,n.context),t._vOptions=[].map.call(t.options,Pr)):("textarea"===n.tag||Kn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Rr),t.addEventListener("compositionend",Hr),t.addEventListener("change",Hr),J&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Mr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Pr);if(r.some(((t,e)=>!N(t,o[e])))){(t.multiple?e.value.some((t=>Fr(t,r))):e.value!==e.oldValue&&Fr(e.value,r))&&Br(t,"change")}}}};function Mr(t,e,n){Ir(t,e),(q||W)&&setTimeout((()=>{Ir(t,e)}),0)}function Ir(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Pr(i))>-1,i.selected!==s&&(i.selected=s);else if(N(Pr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Fr(t,e){return e.every((e=>!N(e,t)))}function Pr(t){return"_value"in t?t._value:t.value}function Rr(t){t.target.composing=!0}function Hr(t){t.target.composing&&(t.target.composing=!1,Br(t.target,"input"))}function Br(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Ur(t){return!t.componentInstance||t.data&&t.data.transition?t:Ur(t.componentInstance._vnode)}var zr={model:Lr,show:{bind(t,{value:e},n){const o=(n=Ur(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Sr(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Ur(o)).data&&o.data.transition?(o.data.show=!0,e?Sr(o,(()=>{t.style.display=t.__vOriginalDisplay})):Tr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}}};const Vr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Kr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Kr(He(e.children)):t}function qr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Jr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Wr=t=>t.tag||Re(t),Zr=t=>"show"===t.name;var Gr={name:"transition",props:Vr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Wr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Kr(o);if(!s)return o;if(this._leaving)return Jr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=qr(this),c=this._vnode,l=Kr(c);if(s.data.directives&&s.data.directives.some(Zr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!Re(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),Jr(t,o);if("in-out"===n){if(Re(s))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const Xr=A({tag:String,moveClass:String},Vr);function Yr(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Qr(t){t.data.newPos=t.elm.getBoundingClientRect()}function ts(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete Xr.mode;var es={Transition:Gr,TransitionGroup:{props:Xr,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=qe(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=qr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Yr),t.forEach(Qr),t.forEach(ts),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;br(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(yr,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(yr,t),n._moveCb=null,wr(n,e))})}})))},methods:{hasMove(t,e){if(!hr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{fr(n,t)})),ur(n,e),n.style.display="none",this.$el.appendChild(n);const o=kr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,$n.config.isReservedTag=zn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=function(t){return Un(t)?"svg":"math"===t?"math":void 0},$n.config.isUnknownElement=function(t){if(!U)return!0;if(zn(t))return!1;if(t=t.toLowerCase(),null!=Vn[t])return Vn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Vn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Vn[t]=/HTMLUnknownElement/.test(e.toString())},A($n.options.directives,zr),A($n.options.components,es),$n.prototype.__patch__=U?Dr:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ge(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ge(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ge(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((()=>{I.devtools&&et&&et.emit("init",$n)}),0);const ns=d("input,textarea,option,select,progress"),os=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),rs=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function ss(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}const is=/\{\{((?:.|\r?\n)+?)\}\}/g,as=/[-.*+?^${}()|[\]\/\\]/g,cs=v((t=>{const e=t[0].replace(as,"\\$&"),n=t[1].replace(as,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ls={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=ko(t,"class");n&&(t.staticClass=JSON.stringify(n));const o=xo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var us={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=ko(t,"style");n&&(t.staticStyle=JSON.stringify(Yo(n)));const o=xo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let fs;var ds={decode:t=>(fs=fs||document.createElement("div"),fs.innerHTML=t,fs.textContent)};const ps=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),hs=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ms=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ys=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,gs=`((?:${ys}\\:)?${ys})`,vs=new RegExp(`^<${gs}`),$s=/^\s*(\/?)>/,_s=new RegExp(`^<\\/${gs}[^>]*>`),bs=/^<!DOCTYPE [^>]+>/i,ws=/^<!\--/,Cs=/^<!\[/,xs=d("script,style,textarea",!0),ks={},As={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Os=/&(?:lt|gt|quot|amp|#39);/g,Ss=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ts=d("pre,textarea",!0),Es=(t,e)=>t&&Ts(t)&&"\n"===e[0];function Ns(t,e){const n=e?Ss:Os;return t.replace(n,(t=>As[t]))}const js=/^@|^v-on:/,Ds=/^v-|^@|^:|^#/,Ls=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Ms=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Is=/^\(|\)$/g,Fs=/^\[.*\]$/,Ps=/:(.*)$/,Rs=/^:|^\.|^v-bind:/,Hs=/\.[^.\]]+(?=[^\]]*$)/g,Bs=/^v-slot(:|$)|^#/,Us=/[\r\n]/,zs=/[ \f\t\r\n]+/g,Vs=v(ds.decode);let Ks,qs,Js,Ws,Zs,Gs,Xs,Ys;function Qs(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ii(e),rawAttrsMap:{},parent:n,children:[]}}function ti(t,e){Ks=e.warn||yo,Gs=e.isPreTag||T,Xs=e.mustUseProp||T,Ys=e.getTagNamespace||T,e.isReservedTag,Js=go(e.modules,"transformNode"),Ws=go(e.modules,"preTransformNode"),Zs=go(e.modules,"postTransformNode"),qs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=ei(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&oi(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&oi(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),Gs(t.tag)&&(c=!1);for(let n=0;n<Zs.length;n++)Zs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&xs(a)){let n=0;const o=a.toLowerCase(),r=ks[o]||(ks[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,xs(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Es(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(ws.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(Cs.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(bs);if(n){l(n[0].length);continue}const o=t.match(_s);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),Es(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(_s.test(o)||vs.test(o)||ws.test(o)||Cs.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(vs);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match($s))&&(r=t.match(ms)||t.match(hs));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ps(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ns(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:Ks,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||Ys(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];ai.test(o.name)||(o.name=o.name.replace(ci,""),e.push(o))}return e}(o));let p=Qs(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<Ws.length;t++)p=Ws[t](p,e)||p;a||(!function(t){null!=ko(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),Gs(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ni(p),function(t){const e=ko(t,"v-if");if(e)t.if=e,oi(t,{exp:e,block:t});else{null!=ko(t,"v-else")&&(t.else=!0);const e=ko(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=ko(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(q&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Vs(t):s.length?r?"condense"===r&&Us.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(zs," ")),!a&&" "!==t&&(e=function(t,e){const n=e?cs(e):is;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=ho(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,qs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function ei(t,e){var n;!function(t){const e=xo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=xo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=ko(t,"scope"),t.slotScope=e||ko(t,"slot-scope")):(e=ko(t,"slot-scope"))&&(t.slotScope=e);const n=xo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||$o(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=Ao(t,Bs);if(e){const{name:n,dynamic:o}=ri(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=Ao(t,Bs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ri(e),s=n[o]=Qs("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=xo(n,"name")),function(t){let e;(e=xo(t,"is"))&&(t.component=e);null!=ko(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Js.length;n++)t=Js[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Ds.test(r))if(t.hasBindings=!0,a=si(r.replace(Ds,"")),a&&(r=r.replace(Hs,"")),Rs.test(r))r=r.replace(Rs,""),i=ho(i),l=Fs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=To(i,"$event"),l?Co(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Co(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Co(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&Xs(t.tag,t.attrsMap.type,r)?vo(t,r,i,e[n],l):$o(t,r,i,e[n],l);else if(js.test(r))r=r.replace(js,""),l=Fs.test(r),l&&(r=r.slice(1,-1)),Co(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Ds,"");const o=r.match(Ps);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Fs.test(c)&&(c=c.slice(1,-1),l=!0)),bo(t,r,s,i,c,l,a,e[n])}else $o(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&Xs(t.tag,t.attrsMap.type,r)&&vo(t,r,"true",e[n])}(t),t}function ni(t){let e;if(e=ko(t,"v-for")){const n=function(t){const e=t.match(Ls);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Is,""),r=o.match(Ms);r?(n.alias=o.replace(Ms,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function oi(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ri(t){let e=t.name.replace(Bs,"");return e||"#"!==t.name[0]&&(e="default"),Fs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function si(t){const e=t.match(Hs);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ii(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const ai=/^xmlns:NS\d+/,ci=/^NS\d+:/;function li(t){return Qs(t.tag,t.attrsList.slice(),t.parent)}var ui=[ls,us,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=xo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=ko(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=ko(t,"v-else",!0),i=ko(t,"v-else-if",!0),a=li(t);ni(a),_o(a,"type","checkbox"),ei(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,oi(a,{exp:a.if,block:a});const c=li(t);ko(c,"v-for",!0),_o(c,"type","radio"),ei(c,e),oi(a,{exp:`(${o})==='radio'`+r,block:c});const l=li(t);return ko(l,"v-for",!0),_o(l,":type",o),ei(l,e),oi(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const fi={expectHTML:!0,modules:ui,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return So(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${To(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Co(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=xo(t,"value")||"null",s=xo(t,"true-value")||"true",i=xo(t,"false-value")||"false";vo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Co(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${To(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${To(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${To(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=xo(t,"value")||"null";r=o?`_n(${r})`:r,vo(t,"checked",`_q(${e},${r})`),Co(t,"change",To(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=To(e,l);a&&(u=`if($event.target.composing)return;${u}`);vo(t,"value",`(${e})`),Co(t,c,u,null,!0),(i||s)&&Co(t,"blur","$forceUpdate()")}(t,o,r);else if(!I.isReservedTag(s))return So(t,o,r),!1;return!0},text:function(t,e){e.value&&vo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&vo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:(t,e,n)=>"value"===n&&ns(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,canBeLeftOpenTag:d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:t=>os(t)||rs(t),getTagNamespace:function(t){return rs(t)?"svg":"math"===t?"math":void 0},staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(ui)};let di,pi;const hi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function mi(t,e){t&&(di=hi(e.staticKeys||""),pi=e.isReservedTag||T,yi(t),gi(t,!1))}function yi(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!pi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(di)))}(t),1===t.type){if(!pi(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];yi(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;yi(n),n.static||(t.static=!1)}}}function gi(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)gi(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)gi(t.ifConditions[n].block,e)}}const vi=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,$i=/\([^)]*?\);*$/,_i=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,bi={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},wi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ci=t=>`if(${t})return null;`,xi={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ci("$event.target !== $event.currentTarget"),ctrl:Ci("!$event.ctrlKey"),shift:Ci("!$event.shiftKey"),alt:Ci("!$event.altKey"),meta:Ci("!$event.metaKey"),left:Ci("'button' in $event && $event.button !== 0"),middle:Ci("'button' in $event && $event.button !== 1"),right:Ci("'button' in $event && $event.button !== 2")};function ki(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Ai(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Ai(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Ai(t))).join(",")}]`;const e=_i.test(t.value),n=vi.test(t.value),o=_i.test(t.value.replace($i,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(xi[e])s+=xi[e],bi[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=Ci(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Oi).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Oi(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=bi[t],o=wi[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Si={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ti{constructor(t){this.options=t,this.warn=t.warn||yo,this.transforms=go(t.modules,"transformCode"),this.dataGenFns=go(t.modules,"genData"),this.directives=A(A({},Si),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function Ei(t,e){const n=new Ti(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Ni(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Ni(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return ji(t,e);if(t.once&&!t.onceProcessed)return Di(t,e);if(t.for&&!t.forProcessed)return Ii(t,e);if(t.if&&!t.ifProcessed)return Li(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Hi(t,e);let r=`_t(${n}${o?`,${o}`:""}`;const s=t.attrs||t.dynamicAttrs?zi((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Hi(e,n,!0);return`_c(${t},${Fi(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Fi(t,e));const r=t.inlineTemplate?null:Hi(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Hi(t,e)||"void 0"}function ji(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Ni(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Di(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Li(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Ni(t,e)},${e.onceId++},${n})`:Ni(t,e)}return ji(t,e)}function Li(t,e,n,o){return t.ifProcessed=!0,Mi(t.ifConditions.slice(),e,n,o)}function Mi(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Mi(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Di(t,e):Ni(t,e)}}function Ii(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Ni)(t,e)}})`}function Fi(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${zi(t.attrs)},`),t.props&&(n+=`domProps:${zi(t.props)},`),t.events&&(n+=`${ki(t.events,!1)},`),t.nativeEvents&&(n+=`${ki(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Pi(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Ri(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=Ei(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${zi(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Pi(t){return 1===t.type&&("slot"===t.tag||t.children.some(Pi))}function Ri(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Li(t,e,Ri,"null");if(t.for&&!t.forProcessed)return Ii(t,e,Ri);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${Hi(t,e)||"undefined"}:undefined`:Hi(t,e)||"undefined":Ni(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Hi(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Ni)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(Bi(r)||r.ifConditions&&r.ifConditions.some((t=>Bi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Ui;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function Bi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Ui(t,e){return 1===t.type?Ni(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Vi(JSON.stringify(t.text))})`}(t)}function zi(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Vi(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Vi(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Ki(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function qi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=Ki(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>Ki(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");const Ji=(Wi=function(t,e){const n=ti(t.trim(),e);!1!==e.optimize&&mi(n,e);const o=Ei(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=Wi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:qi(e)}});var Wi;const{compile:Zi,compileToFunctions:Gi}=Ji(fi);let Xi;function Yi(t){return Xi=Xi||document.createElement("div"),Xi.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Xi.innerHTML.indexOf("&#10;")>0}const Qi=!!U&&Yi(!1),ta=!!U&&Yi(!0),ea=v((t=>{const e=ss(t);return e&&e.innerHTML})),na=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&ss(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=ea(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Gi(e,{outputSourceRange:!1,shouldDecodeNewlines:Qi,shouldDecodeNewlinesForHref:ta,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return na.call(this,t,e)},$n.compile=Gi;export default $n;
\ No newline at end of file
+const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const I=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const G=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const Z=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let st=S,it=0;class at{static target;id;subs;constructor(){this.id=it++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{value;dep;vmCount;constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const s=new at,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function kt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}const At=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=ot?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Nt(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{At[t]=Tt})),I.forEach((function(t){At[t+"s"]=Nt})),At.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function It(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Lt(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(i),$t(e)}return i}const Mt=/^\s*function (\w+)/;function Lt(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return Lt(t)===Lt(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Rt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Rt(t,o,r)}return s}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,Jt=!1;function qt(){Jt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(qt),G&&setTimeout(S)},zt=!0}else if(J||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(qt)}:()=>{setTimeout(qt,0)};else{let t=1;const e=new MutationObserver(qt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),Jt||(Jt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Gt=new rt;function Zt(t){Xt(t,Gt),Gt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),s(f.name,n[c],f.capture))}function ee(t,r,s){let i;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ne(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?se(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=se(c,`${s||""}_${a}`),re(c[0])&&re(u)&&(i[l]=pt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?re(u)?i[l]=pt(u.text+c):""!==c&&i.push(pt(c)):re(c)&&re(u)?i[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ie(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(t){return t.isComment&&t.asyncFactory}function ue(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=fe(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=de(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",i),R(r,"$key",a),R(r,"$hasNormal",s),r}function fe(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!le(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function de(t,e){return()=>t[e]}function pe(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function he(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function me(t){return Dt(this.$options,"filters",t)||N}function ye(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ge(t,e,n,o,r){const s=L.keyCodes[e]||n;return r&&o&&!L.keyCodes[e]?ye(r,o):s?ye(s,t):o?C(o)!==e:void 0===t}function ve(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||L.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function $e(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),be(o,`__static__${t}`,!1)),o}function _e(t,e,n){return be(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function be(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&we(t[o],`${e}_${o}`,n);else we(t,e,n)}function we(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Ce(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function xe(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?xe(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function ke(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=u,t._l=pe,t._t=he,t._q=E,t._i=j,t._m=$e,t._f=me,t._k=ge,t._b=ve,t._v=pt,t._e=dt,t._u=xe,t._g=Ce,t._d=ke,t._p=Ae}function Se(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ie(a.inject,s),this.slots=()=>(this.$slots||ue(e.scopedSlots,this.$slots=ae(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Me(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Me(c,t,e,n,o,u)}function Te(t,e,n,o,r){const s=ht(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ne(t,e){for(const n in e)t[_(n)]=e[n]}Oe(Se.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=It(s,i,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ze(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ge(e,!0):e.$destroy())}},je=Object.keys(Ee);function De(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Pe;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=Re(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Re(h.error,r)),n(h.loading)&&(t.loadingComp=Re(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=dt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ne(i,c,t,e,!0)||ne(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=It(e,l,o||t);else n(r.attrs)&&Ne(c,r.attrs),n(r.props)&&Ne(c,r.props);const u=new Se(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Te(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Te(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<je.length;t++){const n=je[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?Ie(r,o):r)}}(i);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Ie(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Me(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=oe(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),a=L.isReservedTag(e)?new ft(L.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=Dt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):De(s,o,t,r,e)}else a=De(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Le(a,c),n(o)&&function(t){s(t.style)&&Zt(t.style);s(t.class)&&Zt(t.class)}(o),a):dt()}(t,e,i,a,c)}function Le(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Le(a,r,s)}}let Fe,Pe=null;function Re(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||le(o)))return o}}function Be(t,e){Fe.$on(t,e)}function Ue(t,e){Fe.$off(t,e)}function ze(t,e){const n=Fe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Fe=t,te(e,n||{},Be,Ue,ze,t),Fe=void 0}let Ke=null;function Je(t){const e=Ke;return Ke=t,()=>{Ke=e}}function qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ze(t,"activated")}}function Ge(t,e){if(!(e&&(t._directInactive=!0,qe(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ge(t.$children[e]);Ze(t,"deactivated")}}function Ze(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!J){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ze(o,"updated")}}(o),et&&L.devtools&&et.emit("flush")}let an=0;class cn{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Zt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Ht(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const s in e){r.push(s);wt(o,s,It(s,e,n,t)),s in t||un(t,"_props",s)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new cn(t,i||S,S,dn)),r in t||pn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=jt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,I.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Me(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Me(e,t,n,o,r,!0);const s=o&&o.data;wt(e,"$attrs",s&&s.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){const e=ie(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;lt(),Ht(e,o,[r.value],o,t),ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=Je(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ue(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Pe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Pe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const kn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:bn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&xn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>L};Object.defineProperty(t,"config",e),t.util={warn:st,extend:A,mergeOptions:jt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),I.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),_n(t),function(t){I.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Se}),$n.version="2.6.14";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,Nn=d("contenteditable,draggable,spellcheck"),En=d("events,caret,typing,plaintext-only"),jn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Dn="http://www.w3.org/1999/xlink",In=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Mn=t=>In(t)?t.slice(6,t.length):"",Ln=t=>null==t||!1===t;function Fn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Pn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Pn(e,o.data));return function(t,e){if(n(t)||n(e))return Rn(t,Hn(e));return""}(e.staticClass,e.class)}function Pn(t,e){return{staticClass:Rn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Rn(t,e){return t?e?t+" "+e:t:e||""}function Hn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Hn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Un=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Vn=t=>Un(t)||zn(t);function Kn(t){return zn(t)?"svg":"math"===t?"math":void 0}const Jn=Object.create(null);const qn=d("text,number,password,search,email,tel,url");function Wn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var Gn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create(t,e){Xn(e)},update(t,e){t.data.ref!==e.data.ref&&(Xn(t,!0),Xn(e))},destroy(t){Xn(t,!0)}};function Xn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?m(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Yn=new ft("",{},[]),Qn=["create","activate","update","remove","destroy"];function to(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||qn(r)&&qn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function eo(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var no={create:oo,update:oo,destroy:function(t){oo(t,Yn)}};function oo(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Yn,o=e===Yn,r=so(t.data.directives,t.context),s=so(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ao(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ao(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)ao(i[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ao(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||ao(r[c],"unbind",t,t,o)}(t,e)}const ro=Object.create(null);function so(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=ro),n[io(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function io(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ao(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var co=[Zn,no];function lo(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&uo(c,s,i,o.data.pre);for(s in(J||W)&&u.value!==l.value&&uo(c,"value",u.value),l)e(u[s])&&(In(s)?c.removeAttributeNS(Dn,Mn(s)):Nn(s)||c.removeAttribute(s))}function uo(t,e,n,o){o||t.tagName.indexOf("-")>-1?fo(t,e,n):jn(e)?Ln(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,((t,e)=>Ln(e)||"false"===e?"false":"contenteditable"===t&&En(e)?e:"true")(e,n)):In(e)?Ln(n)?t.removeAttributeNS(Dn,Mn(e)):t.setAttributeNS(Dn,e,n):fo(t,e,n)}function fo(t,e,n){if(Ln(n))t.removeAttribute(e);else{if(J&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var po={create:lo,update:lo};function ho(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Fn(o);const c=r._transitionClasses;n(c)&&(a=Rn(a,Hn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var mo={create:ho,update:ho};const yo=/[\w).+\-_$\]]/;function go(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&yo.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=vo(r,s[o]);return r}function vo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function $o(t,e){console.error(`[Vue compiler]: ${t}`)}function _o(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function bo(t,e,n,o,r){(t.props||(t.props=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function wo(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function Co(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(No({name:e,value:n},o))}function xo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(No({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function ko(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Ao(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=ko("!",n,c)),r.once&&(delete r.once,n=ko("~",n,c)),r.passive&&(delete r.passive,n=ko("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=No({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function Oo(t,e,n){const o=So(t,":"+e)||So(t,"v-bind:"+e);if(null!=o)return go(o);if(!1!==n){const n=So(t,e);if(null!=n)return JSON.stringify(n)}}function So(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function To(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function No(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function Eo(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=jo(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function jo(t,e){const n=function(t){if(t=t.trim(),Do=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Do-1)return Lo=t.lastIndexOf("."),Lo>-1?{exp:t.slice(0,Lo),key:'"'+t.slice(Lo+1)+'"'}:{exp:t,key:null};Io=t,Lo=Fo=Po=0;for(;!Ho();)Mo=Ro(),Bo(Mo)?zo(Mo):91===Mo&&Uo(Mo);return{exp:t.slice(0,Fo),key:t.slice(Fo+1,Po)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Do,Io,Mo,Lo,Fo,Po;function Ro(){return Io.charCodeAt(++Lo)}function Ho(){return Lo>=Do}function Bo(t){return 34===t||39===t}function Uo(t){let e=1;for(Fo=Lo;!Ho();)if(Bo(t=Ro()))zo(t);else if(91===t&&e++,93===t&&e--,0===e){Po=Lo;break}}function zo(t){const e=t;for(;!Ho()&&(t=Ro())!==e;);}let Vo;function Ko(t,e,n){const o=Vo;return function r(){const s=e.apply(null,arguments);null!==s&&Wo(t,r,n,o)}}const Jo=zt&&!(Z&&Number(Z[1])<=53);function qo(t,e,n,o){if(Jo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Vo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Wo(t,e,n,o){(o||Vo).removeEventListener(t,e._wrapper||e,n)}function Go(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Vo=o.elm||t.elm,function(t){if(n(t.__r)){const e=J?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,s,qo,Wo,Ko,o.context),Vo=void 0}var Zo={create:Go,update:Go,destroy:t=>Go(t,Yn)};let Xo;function Yo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Qo(i,t)&&(i.value=t)}else if("innerHTML"===r&&zn(i.tagName)&&e(i.innerHTML)){Xo=Xo||document.createElement("div"),Xo.innerHTML=`<svg>${s}</svg>`;const t=Xo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Qo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var tr={create:Yo,update:Yo};const er=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function nr(t){const e=or(t.style);return t.staticStyle?A(t.staticStyle,e):e}function or(t){return Array.isArray(t)?O(t):"string"==typeof t?er(t):t}const rr=/^--/,sr=/\s*!important$/,ir=(t,e,n)=>{if(rr.test(e))t.style.setProperty(e,n);else if(sr.test(n))t.style.setProperty(C(e),n.replace(sr,""),"important");else{const o=lr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},ar=["Webkit","Moz","ms"];let cr;const lr=v((function(t){if(cr=cr||document.createElement("div").style,"filter"!==(t=_(t))&&t in cr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<ar.length;t++){const n=ar[t]+e;if(n in cr)return n}}));function ur(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=or(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=nr(e.data))&&A(n,o)}(o=nr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=nr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&ir(c,a,"");for(a in p)i=p[a],i!==f[a]&&ir(c,a,null==i?"":i)}var fr={create:ur,update:ur};const dr=/\s+/;function pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function mr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,yr(t.name||"v")),A(e,t),e}return"string"==typeof t?yr(t):void 0}}const yr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),gr=U&&!q;let vr="transition",$r="transitionend",_r="animation",br="animationend";gr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(vr="WebkitTransition",$r="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(_r="WebkitAnimation",br="webkitAnimationEnd"));const wr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Cr(t){wr((()=>{wr(t)}))}function xr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pr(t,e))}function kr(t,e){t._transitionClasses&&m(t._transitionClasses,e),hr(t,e)}function Ar(t,e,n){const{type:o,timeout:r,propCount:s}=Sr(t,e);if(!o)return n();const i="transition"===o?$r:br;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Or=/\b(transform|all)(,|$)/;function Sr(t,e){const n=window.getComputedStyle(t),o=(n[vr+"Delay"]||"").split(", "),r=(n[vr+"Duration"]||"").split(", "),s=Tr(o,r),i=(n[_r+"Delay"]||"").split(", "),a=(n[_r+"Duration"]||"").split(", "),c=Tr(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Or.test(n[vr+"Property"])}}function Tr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Nr(e)+Nr(t[n]))))}function Nr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Er(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=mr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Ke,A=Ke.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,j=O&&"function"==typeof b?b:g,I=O&&w||v,M=O&&C||$,L=f(s(x)?x.enter:x),F=!1!==a&&!q,P=Ir(j),R=r._enterCb=D((()=>{F&&(kr(r,N),kr(r,T)),R.cancelled?(F&&kr(r,S),M&&M(r)):I&&I(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),E&&E(r),F&&(xr(r,S),xr(r,T),Cr((()=>{kr(r,S),R.cancelled||(xr(r,N),P||(Dr(L)?setTimeout(R,L):Ar(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function jr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=mr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!q,_=Ir(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(kr(r,u),kr(r,d)),w.cancelled?($&&kr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(xr(r,l),xr(r,d),Cr((()=>{kr(r,l),w.cancelled||(xr(r,u),_||(Dr(b)?setTimeout(w,b):Ar(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Dr(t){return"number"==typeof t&&!isNaN(t)}function Ir(t){if(e(t))return!1;const o=t.fns;return n(o)?Ir(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Mr(t,e){!0!==e.data.show&&Er(e)}const Lr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Qn.length;++s)for(a[Qn[s]]=[],i=0;i<c.length;++i)n(c[i][Qn[s]])&&a[Qn[s]].push(c[i][Qn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Yn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Xn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Yn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&to(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:to(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):to(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):to(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):to(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=eo(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],to(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Zt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&to(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Xn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:Gn,modules:[po,mo,Zo,tr,fr,U?{create:Mr,activate:Mr,remove(t,e){!0!==t.data.show?jr(t,e):e()}}:{}].concat(co)});q&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Vr(t,"input")}));const Fr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Fr.componentUpdated(t,e,n)})):Pr(t,e,n.context),t._vOptions=[].map.call(t.options,Br)):("textarea"===n.tag||qn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Ur),t.addEventListener("compositionend",zr),t.addEventListener("change",zr),q&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Pr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Br);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>Hr(t,r))):e.value!==e.oldValue&&Hr(e.value,r))&&Vr(t,"change")}}}};function Pr(t,e,n){Rr(t,e),(J||W)&&setTimeout((()=>{Rr(t,e)}),0)}function Rr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Br(i))>-1,i.selected!==s&&(i.selected=s);else if(E(Br(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Hr(t,e){return e.every((e=>!E(e,t)))}function Br(t){return"_value"in t?t._value:t.value}function Ur(t){t.target.composing=!0}function zr(t){t.target.composing&&(t.target.composing=!1,Vr(t.target,"input"))}function Vr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Kr(t){return!t.componentInstance||t.data&&t.data.transition?t:Kr(t.componentInstance._vnode)}var Jr={bind(t,{value:e},n){const o=(n=Kr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Er(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Kr(o)).data&&o.data.transition?(o.data.show=!0,e?Er(o,(()=>{t.style.display=t.__vOriginalDisplay})):jr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},qr={model:Fr,show:Jr};const Wr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Gr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Gr(He(e.children)):t}function Zr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Xr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Yr=t=>t.tag||le(t),Qr=t=>"show"===t.name;var ts={name:"transition",props:Wr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Yr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Gr(o);if(!s)return o;if(this._leaving)return Xr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=Zr(this),c=this._vnode,l=Gr(c);if(s.data.directives&&s.data.directives.some(Qr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!le(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),Xr(t,o);if("in-out"===n){if(le(s))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const es=A({tag:String,moveClass:String},Wr);function ns(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function os(t){t.data.newPos=t.elm.getBoundingClientRect()}function rs(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete es.mode;var ss={Transition:ts,TransitionGroup:{props:es,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=Je(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=Zr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(ns),t.forEach(os),t.forEach(rs),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;xr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener($r,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener($r,t),n._moveCb=null,kr(n,e))})}})))},methods:{hasMove(t,e){if(!gr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{hr(n,t)})),pr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Sr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=Tn,$n.config.isReservedTag=Vn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=Kn,$n.config.isUnknownElement=function(t){if(!U)return!0;if(Vn(t))return!1;if(t=t.toLowerCase(),null!=Jn[t])return Jn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Jn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Jn[t]=/HTMLUnknownElement/.test(e.toString())},A($n.options.directives,qr),A($n.options.components,ss),$n.prototype.__patch__=U?Lr:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ze(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?Wn(t):void 0,e)},U&&setTimeout((()=>{L.devtools&&et&&et.emit("init",$n)}),0);const is=/\{\{((?:.|\r?\n)+?)\}\}/g,as=/[-.*+?^${}()|[\]\/\\]/g,cs=v((t=>{const e=t[0].replace(as,"\\$&"),n=t[1].replace(as,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ls={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=So(t,"class");n&&(t.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const o=Oo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var us={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=So(t,"style");n&&(t.staticStyle=JSON.stringify(er(n)));const o=Oo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let fs;var ds={decode:t=>(fs=fs||document.createElement("div"),fs.innerHTML=t,fs.textContent)};const ps=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),hs=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ms=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ys=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,gs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,vs=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,$s=`((?:${vs}\\:)?${vs})`,_s=new RegExp(`^<${$s}`),bs=/^\s*(\/?)>/,ws=new RegExp(`^<\\/${$s}[^>]*>`),Cs=/^<!DOCTYPE [^>]+>/i,xs=/^<!\--/,ks=/^<!\[/,As=d("script,style,textarea",!0),Os={},Ss={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ts=/&(?:lt|gt|quot|amp|#39);/g,Ns=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Es=d("pre,textarea",!0),js=(t,e)=>t&&Es(t)&&"\n"===e[0];function Ds(t,e){const n=e?Ns:Ts;return t.replace(n,(t=>Ss[t]))}const Is=/^@|^v-on:/,Ms=/^v-|^@|^:|^#/,Ls=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Ps=/^\(|\)$/g,Rs=/^\[.*\]$/,Hs=/:(.*)$/,Bs=/^:|^\.|^v-bind:/,Us=/\.[^.\]]+(?=[^\]]*$)/g,zs=/^v-slot(:|$)|^#/,Vs=/[\r\n]/,Ks=/[ \f\t\r\n]+/g,Js=v(ds.decode);let qs,Ws,Gs,Zs,Xs,Ys,Qs,ti;function ei(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ci(e),rawAttrsMap:{},parent:n,children:[]}}function ni(t,e){qs=e.warn||$o,Ys=e.isPreTag||T,Qs=e.mustUseProp||T,ti=e.getTagNamespace||T,e.isReservedTag,Gs=_o(e.modules,"transformNode"),Zs=_o(e.modules,"preTransformNode"),Xs=_o(e.modules,"postTransformNode"),Ws=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=oi(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&si(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&si(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),Ys(t.tag)&&(c=!1);for(let n=0;n<Xs.length;n++)Xs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&As(a)){let n=0;const o=a.toLowerCase(),r=Os[o]||(Os[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,As(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),js(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(xs.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(ks.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Cs);if(n){l(n[0].length);continue}const o=t.match(ws);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),js(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(ws.test(o)||_s.test(o)||xs.test(o)||ks.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(_s);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(bs))&&(r=t.match(gs)||t.match(ys));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ms(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ds(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:qs,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||ti(t);J&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];li.test(o.name)||(o.name=o.name.replace(ui,""),e.push(o))}return e}(o));let p=ei(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<Zs.length;t++)p=Zs[t](p,e)||p;a||(!function(t){null!=So(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),Ys(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ri(p),function(t){const e=So(t,"v-if");if(e)t.if=e,si(t,{exp:e,block:t});else{null!=So(t,"v-else")&&(t.else=!0);const e=So(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=So(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(J&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Js(t):s.length?r?"condense"===r&&Vs.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Ks," ")),!a&&" "!==t&&(e=function(t,e){const n=e?cs(e):is;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=go(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Ws))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function oi(t,e){var n;!function(t){const e=Oo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=Oo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=So(t,"scope"),t.slotScope=e||So(t,"slot-scope")):(e=So(t,"slot-scope"))&&(t.slotScope=e);const n=Oo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||wo(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=To(t,zs);if(e){const{name:n,dynamic:o}=ii(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=To(t,zs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ii(e),s=n[o]=ei("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=Oo(n,"name")),function(t){let e;(e=Oo(t,"is"))&&(t.component=e);null!=So(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Gs.length;n++)t=Gs[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Ms.test(r))if(t.hasBindings=!0,a=ai(r.replace(Ms,"")),a&&(r=r.replace(Us,"")),Bs.test(r))r=r.replace(Bs,""),i=go(i),l=Rs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=jo(i,"$event"),l?Ao(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Ao(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Ao(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&Qs(t.tag,t.attrsMap.type,r)?bo(t,r,i,e[n],l):wo(t,r,i,e[n],l);else if(Is.test(r))r=r.replace(Is,""),l=Rs.test(r),l&&(r=r.slice(1,-1)),Ao(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Ms,"");const o=r.match(Hs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Rs.test(c)&&(c=c.slice(1,-1),l=!0)),xo(t,r,s,i,c,l,a,e[n])}else wo(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&Qs(t.tag,t.attrsMap.type,r)&&bo(t,r,"true",e[n])}(t),t}function ri(t){let e;if(e=So(t,"v-for")){const n=function(t){const e=t.match(Ls);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Ps,""),r=o.match(Fs);r?(n.alias=o.replace(Fs,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function si(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ii(t){let e=t.name.replace(zs,"");return e||"#"!==t.name[0]&&(e="default"),Rs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function ai(t){const e=t.match(Us);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ci(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const li=/^xmlns:NS\d+/,ui=/^NS\d+:/;function fi(t){return ei(t.tag,t.attrsList.slice(),t.parent)}var di=[ls,us,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=Oo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=So(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=So(t,"v-else",!0),i=So(t,"v-else-if",!0),a=fi(t);ri(a),Co(a,"type","checkbox"),oi(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,si(a,{exp:a.if,block:a});const c=fi(t);So(c,"v-for",!0),Co(c,"type","radio"),oi(c,e),si(a,{exp:`(${o})==='radio'`+r,block:c});const l=fi(t);return So(l,"v-for",!0),Co(l,":type",o),oi(l,e),si(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const pi={expectHTML:!0,modules:di,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return Eo(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${jo(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Ao(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=Oo(t,"value")||"null",s=Oo(t,"true-value")||"true",i=Oo(t,"false-value")||"false";bo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Ao(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${jo(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${jo(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${jo(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=Oo(t,"value")||"null";r=o?`_n(${r})`:r,bo(t,"checked",`_q(${e},${r})`),Ao(t,"change",jo(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=jo(e,l);a&&(u=`if($event.target.composing)return;${u}`);bo(t,"value",`(${e})`),Ao(t,c,u,null,!0),(i||s)&&Ao(t,"blur","$forceUpdate()")}(t,o,r);else if(!L.isReservedTag(s))return Eo(t,o,r),!1;return!0},text:function(t,e){e.value&&bo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&bo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:ps,mustUseProp:Tn,canBeLeftOpenTag:hs,isReservedTag:Vn,getTagNamespace:Kn,staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(di)};let hi,mi;const yi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function gi(t,e){t&&(hi=yi(e.staticKeys||""),mi=e.isReservedTag||T,vi(t),$i(t,!1))}function vi(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!mi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(hi)))}(t),1===t.type){if(!mi(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];vi(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;vi(n),n.static||(t.static=!1)}}}function $i(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)$i(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)$i(t.ifConditions[n].block,e)}}const _i=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,bi=/\([^)]*?\);*$/,wi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},ki=t=>`if(${t})return null;`,Ai={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:ki("$event.target !== $event.currentTarget"),ctrl:ki("!$event.ctrlKey"),shift:ki("!$event.shiftKey"),alt:ki("!$event.altKey"),meta:ki("!$event.metaKey"),left:ki("'button' in $event && $event.button !== 0"),middle:ki("'button' in $event && $event.button !== 1"),right:ki("'button' in $event && $event.button !== 2")};function Oi(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Si(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Si(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Si(t))).join(",")}]`;const e=wi.test(t.value),n=_i.test(t.value),o=wi.test(t.value.replace(bi,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ai[e])s+=Ai[e],Ci[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=ki(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Ti).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ti(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Ci[t],o=xi[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Ni={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ei{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(t){this.options=t,this.warn=t.warn||$o,this.transforms=_o(t.modules,"transformCode"),this.dataGenFns=_o(t.modules,"genData"),this.directives=A(A({},Ni),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function ji(t,e){const n=new Ei(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Di(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Di(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ii(t,e);if(t.once&&!t.onceProcessed)return Mi(t,e);if(t.for&&!t.forProcessed)return Pi(t,e);if(t.if&&!t.ifProcessed)return Li(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Ui(t,e);let r=`_t(${n}${o?`,function(){return ${o}}`:""}`;const s=t.attrs||t.dynamicAttrs?Ki((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Ui(e,n,!0);return`_c(${t},${Ri(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Ri(t,e));const r=t.inlineTemplate?null:Ui(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Ui(t,e)||"void 0"}function Ii(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Di(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Mi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Li(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Di(t,e)},${e.onceId++},${n})`:Di(t,e)}return Ii(t,e)}function Li(t,e,n,o){return t.ifProcessed=!0,Fi(t.ifConditions.slice(),e,n,o)}function Fi(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Fi(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Mi(t,e):Di(t,e)}}function Pi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Di)(t,e)}})`}function Ri(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Ki(t.attrs)},`),t.props&&(n+=`domProps:${Ki(t.props)},`),t.events&&(n+=`${Oi(t.events,!1)},`),t.nativeEvents&&(n+=`${Oi(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Hi(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Bi(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=ji(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Ki(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Hi(t){return 1===t.type&&("slot"===t.tag||t.children.some(Hi))}function Bi(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Li(t,e,Bi,"null");if(t.for&&!t.forProcessed)return Pi(t,e,Bi);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${Ui(t,e)||"undefined"}:undefined`:Ui(t,e)||"undefined":Di(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Ui(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Di)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(zi(r)||r.ifConditions&&r.ifConditions.some((t=>zi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Vi;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function zi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Vi(t,e){return 1===t.type?Di(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Ji(JSON.stringify(t.text))})`}(t)}function Ki(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Ji(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Ji(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function qi(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function Wi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=qi(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>qi(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const Gi=(Zi=function(t,e){const n=ni(t.trim(),e);!1!==e.optimize&&gi(n,e);const o=ji(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=Zi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:Wi(e)}});var Zi;const{compile:Xi,compileToFunctions:Yi}=Gi(pi);let Qi;function ta(t){return Qi=Qi||document.createElement("div"),Qi.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Qi.innerHTML.indexOf("&#10;")>0}const ea=!!U&&ta(!1),na=!!U&&ta(!0),oa=v((t=>{const e=Wn(t);return e&&e.innerHTML})),ra=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&Wn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=oa(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Yi(e,{outputSourceRange:!1,shouldDecodeNewlines:ea,shouldDecodeNewlinesForHref:na,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return ra.call(this,t,e)},$n.compile=Yi;export{$n as default};
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index 74a2b6188cc..4671d375b3f 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -1,9 +1,9 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-var emptyObject = Object.freeze({});
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 function isUndef(v) {
@@ -30,7 +30,7 @@ function isPrimitive(value) {
 }
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
 function isObject(obj) {
@@ -39,7 +39,7 @@ function isObject(obj) {
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
+const _toString = Object.prototype.toString;
 function toRawType(value) {
     return _toString.call(value).slice(8, -1);
 }
@@ -57,7 +57,7 @@ function isRegExp(v) {
  * Check if val is a valid array index.
  */
 function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
+    const n = parseFloat(String(val));
     return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
 function isPromise(val) {
@@ -80,7 +80,7 @@ function toString(val) {
  * If the conversion fails, return original string.
  */
 function toNumber(val) {
-    var n = parseFloat(val);
+    const n = parseFloat(val);
     return isNaN(n) ? val : n;
 }
 /**
@@ -88,27 +88,27 @@ function toNumber(val) {
  * is in that map.
  */
 function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
         map[list[i]] = true;
     }
-    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
 function remove$2(arr, item) {
     if (arr.length) {
-        var index = arr.indexOf(item);
+        const index = arr.indexOf(item);
         if (index > -1) {
             return arr.splice(index, 1);
         }
@@ -117,7 +117,7 @@ function remove$2(arr, item) {
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
 }
@@ -125,30 +125,30 @@ function hasOwn(obj, key) {
  * Create a cached version of a pure function.
  */
 function cached(fn) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function cachedFn(str) {
-        var hit = cache[str];
+        const hit = cache[str];
         return hit || (cache[str] = fn(str));
     };
 }
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
 /**
  * Capitalize a string.
  */
-var capitalize = cached(function (str) {
+const capitalize = cached((str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
 /**
@@ -161,7 +161,7 @@ var hyphenate = cached(function (str) {
 /* istanbul ignore next */
 function polyfillBind(fn, ctx) {
     function boundFn(a) {
-        var l = arguments.length;
+        const l = arguments.length;
         return l
             ? l > 1
                 ? fn.apply(ctx, arguments)
@@ -175,14 +175,14 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
 function toArray(list, start) {
     start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
+    let i = list.length - start;
+    const ret = new Array(i);
     while (i--) {
         ret[i] = list[i + start];
     }
@@ -192,7 +192,7 @@ function toArray(list, start) {
  * Mix properties into target object.
  */
 function extend(to, _from) {
-    for (var key in _from) {
+    for (const key in _from) {
         to[key] = _from[key];
     }
     return to;
@@ -201,8 +201,8 @@ function extend(to, _from) {
  * Merge an Array of Objects into a single Object.
  */
 function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
         if (arr[i]) {
             extend(res, arr[i]);
         }
@@ -219,18 +219,18 @@ function noop(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
+const identity = (_) => _;
 /**
  * Generate a string containing static keys from compiler modules.
  */
 function genStaticKeys$1(modules) {
     return modules
-        .reduce(function (keys, m) {
+        .reduce((keys, m) => {
         return keys.concat(m.staticKeys || []);
     }, [])
         .join(',');
@@ -241,16 +241,16 @@ function genStaticKeys$1(modules) {
  */
 function looseEqual(a, b) {
     if (a === b)
-        { return true; }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
     if (isObjectA && isObjectB) {
         try {
-            var isArrayA = Array.isArray(a);
-            var isArrayB = Array.isArray(b);
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
             if (isArrayA && isArrayB) {
                 return (a.length === b.length &&
-                    a.every(function (e, i) {
+                    a.every((e, i) => {
                         return looseEqual(e, b[i]);
                     }));
             }
@@ -258,10 +258,10 @@ function looseEqual(a, b) {
                 return a.getTime() === b.getTime();
             }
             else if (!isArrayA && !isArrayB) {
-                var keysA = Object.keys(a);
-                var keysB = Object.keys(b);
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
                 return (keysA.length === keysB.length &&
-                    keysA.every(function (key) {
+                    keysA.every((key) => {
                         return looseEqual(a[key], b[key]);
                     }));
             }
@@ -288,9 +288,9 @@ function looseEqual(a, b) {
  * contain an object of the same shape), or -1 if it is not present.
  */
 function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
+    for (let i = 0; i < arr.length; i++) {
         if (looseEqual(arr[i], val))
-            { return i; }
+            return i;
     }
     return -1;
 }
@@ -298,7 +298,7 @@ function looseIndexOf(arr, val) {
  * Ensure a function is called only once.
  */
 function once(fn) {
-    var called = false;
+    let called = false;
     return function () {
         if (!called) {
             called = true;
@@ -307,9 +307,9 @@ function once(fn) {
     };
 }
 
-var SSR_ATTR = 'data-server-rendered';
-var ASSET_TYPES = ['component', 'directive', 'filter'];
-var LIFECYCLE_HOOKS = [
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
     'beforeCreate',
     'created',
     'beforeMount',
@@ -321,7 +321,8 @@ var LIFECYCLE_HOOKS = [
     'activated',
     'deactivated',
     'errorCaptured',
-    'serverPrefetch' ];
+    'serverPrefetch',
+];
 
 var config = {
     /**
@@ -406,12 +407,12 @@ var config = {
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Check if a string starts with $ or _
  */
 function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
+    const c = (str + '').charCodeAt(0);
     return c === 0x24 || c === 0x5f;
 }
 /**
@@ -428,16 +429,16 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
     }
-    var segments = path.split('.');
+    const segments = path.split('.');
     return function (obj) {
-        for (var i = 0; i < segments.length; i++) {
+        for (let i = 0; i < segments.length; i++) {
             if (!obj)
-                { return; }
+                return;
             obj = obj[segments[i]];
         }
         return obj;
@@ -445,46 +446,41 @@ function parsePath(path) {
 }
 
 // can we use __proto__?
-var hasProto = '__proto__' in {};
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-// @ts-ignore
-var inWeex = 
-// @ts-ignore
-typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-// @ts-ignore
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
 (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 UA && /chrome\/\d+/.test(UA) && !isEdge;
 UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
-var nativeWatch = {}.watch;
-var supportsPassive = false;
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
     try {
-        var opts = {};
+        const opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
-        // @ts-ignore
         window.addEventListener('test-passive', null, opts);
     }
     catch (e) { }
 }
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
+let _isServer;
+const isServerRendering = () => {
     if (_isServer === undefined) {
         /* istanbul ignore if */
         if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -500,104 +496,94 @@ var isServerRendering = function () {
     return _isServer;
 };
 // detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
 }
-var hasSymbol = typeof Symbol !== 'undefined' &&
+const hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
+let _Set; // $flow-disable-line
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
     // use native Set when available.
     _Set = Set;
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-        function Set() {
-            this.set = Object.create(null);
-        }
-        Set.prototype.has = function has (key) {
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
             return this.set[key] === true;
-        };
-        Set.prototype.add = function add (key) {
+        }
+        add(key) {
             this.set[key] = true;
-        };
-        Set.prototype.clear = function clear () {
+        }
+        clear() {
             this.set = Object.create(null);
-        };
-
-        return Set;
-    }());
+        }
+    };
 }
 
-var warn$2 = noop;
-var tip = noop;
-var generateComponentTrace; // work around flow check
-var formatComponentName;
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn$2 = function (msg, vm) {
-        var trace = vm ? generateComponentTrace(vm) : '';
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
         else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+            console.error(`[Vue warn]: ${msg}${trace}`);
         }
     };
-    tip = function (msg, vm) {
+    tip = (msg, vm) => {
         if (hasConsole && !config.silent) {
-            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
         }
     };
-    formatComponentName = function (vm, includeFile) {
+    formatComponentName = (vm, includeFile) => {
         if (vm.$root === vm) {
             return '<Root>';
         }
-        var options = 
-        // @ts-ignore
-        typeof vm === 'function' && vm.cid != null
-            ? // @ts-ignore
-                vm.options
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
             : vm._isVue
-                ? // @ts-ignore
-                    vm.$options || vm.constructor.options
+                ? vm.$options || vm.constructor.options
                 : vm;
-        var name = options.name || options._componentTag;
-        var file = options.__file;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
         if (!name && file) {
-            var match = file.match(/([^/\\]+)\.vue$/);
+            const match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
     };
-    var repeat$1 = function (str, n) {
-        var res = '';
+    const repeat = (str, n) => {
+        let res = '';
         while (n) {
             if (n % 2 === 1)
-                { res += str; }
+                res += str;
             if (n > 1)
-                { str += str; }
+                str += str;
             n >>= 1;
         }
         return res;
     };
-    generateComponentTrace = function (vm) {
-        // @ts-ignore
+    generateComponentTrace = (vm) => {
         if (vm._isVue && vm.$parent) {
-            var tree = [];
-            var currentRecursiveSequence = 0;
+            const tree = [];
+            let currentRecursiveSequence = 0;
             while (vm) {
                 if (tree.length > 0) {
-                    var last = tree[tree.length - 1];
+                    const last = tree[tree.length - 1];
                     if (last.constructor === vm.constructor) {
                         currentRecursiveSequence++;
                         vm = vm.$parent;
@@ -613,55 +599,60 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return `\n\n(found in ${formatComponentName(vm)})`;
         }
     };
 }
 
-var uid$2 = 0;
+let uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid$2++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove$2(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+    addSub(sub) {
+        this.subs.push(sub);
     }
-};
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-var targetStack = [];
+const targetStack = [];
 function pushTarget(target) {
     targetStack.push(target);
     Dep.target = target;
@@ -671,44 +662,66 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
-    var node = new VNode();
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
     node.text = text;
     node.isComment = true;
     return node;
@@ -721,9 +734,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    var cloned = new VNode(
-    //@ts-expect-error void type not valid here
-    vnode.tag, vnode.data, 
+    const cloned = new VNode(vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
@@ -744,29 +755,27 @@ function cloneVNode(vnode) {
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-var methodsToPatch = [
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
     'push',
     'pop',
     'shift',
     'unshift',
     'splice',
     'sort',
-    'reverse' ];
+    'reverse',
+];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
     // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
-
-        var result = original.apply(this, args);
-        var ob = this.__ob__;
-        var inserted;
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
         switch (method) {
             case 'push':
             case 'unshift':
@@ -777,19 +786,19 @@ methodsToPatch.forEach(function (method) {
                 break;
         }
         if (inserted)
-            { ob.observeArray(inserted); }
+            ob.observeArray(inserted);
         // notify change
         ob.dep.notify();
         return result;
     });
 });
 
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-var shouldObserve = true;
+let shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
@@ -799,43 +808,48 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
     }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive(obj, keys[i]);
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
     }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
     }
-};
+}
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -852,8 +866,8 @@ function protoAugment(target, src) {
  */
 /* istanbul ignore next */
 function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-        var key = keys[i];
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
         def(target, key, src[key]);
     }
 }
@@ -866,7 +880,7 @@ function observe(value, asRootData) {
     if (!isObject(value) || value instanceof VNode) {
         return;
     }
-    var ob;
+    let ob;
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
@@ -886,23 +900,23 @@ function observe(value, asRootData) {
  * Define a reactive property on an Object.
  */
 function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
         return;
     }
     // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
+    const getter = property && property.get;
+    const setter = property && property.set;
     if ((!getter || setter) && arguments.length === 2) {
         val = obj[key];
     }
-    var childOb = !shallow && observe(val);
+    let childOb = !shallow && observe(val);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
         get: function reactiveGetter() {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             if (Dep.target) {
                 dep.depend();
                 if (childOb) {
@@ -915,7 +929,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             return value;
         },
         set: function reactiveSetter(newVal) {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             /* eslint-disable no-self-compare */
             if (newVal === value || (newVal !== newVal && value !== value)) {
                 return;
@@ -926,7 +940,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             }
             // #7981: for accessor properties without setter
             if (getter && !setter)
-                { return; }
+                return;
             if (setter) {
                 setter.call(obj, newVal);
             }
@@ -946,7 +960,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -957,8 +971,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    var ob = target.__ob__;
-    // @ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
             warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
@@ -979,14 +992,13 @@ function set(target, key, val) {
 function del(target, key) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn$2(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
         return;
     }
-    var ob = target.__ob__;
-    //@ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
             warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
@@ -1007,7 +1019,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1021,14 +1033,14 @@ function dependArray(value) {
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn$2("option \"" + key + "\" can only be used during instance " +
+            warn$2(`option "${key}" can only be used during instance ` +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1039,16 +1051,16 @@ if (process.env.NODE_ENV !== 'production') {
  */
 function mergeData(to, from) {
     if (!from)
-        { return to; }
-    var key, toVal, fromVal;
-    var keys = hasSymbol
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
         ? Reflect.ownKeys(from)
         : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
+    for (let i = 0; i < keys.length; i++) {
         key = keys[i];
         // in case the object is already observed...
         if (key === '__ob__')
-            { continue; }
+            continue;
         toVal = to[key];
         fromVal = from[key];
         if (!hasOwn(to, key)) {
@@ -1080,18 +1092,14 @@ function mergeDataOrFn(parentVal, childVal, vm) {
         // check if parentVal is a function here because
         // it has to be a function to pass previous merges.
         return function mergedDataFn() {
-            return mergeData(
-            // @ts-ignore
-            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-            // @ts-ignore
-            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
         };
     }
     else {
         return function mergedInstanceDataFn() {
             // instance merge
-            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
             if (instanceData) {
                 return mergeData(instanceData, defaultData);
             }
@@ -1118,7 +1126,7 @@ strats.data = function (parentVal, childVal, vm) {
  * Hooks and props are merged as arrays.
  */
 function mergeHook$1(parentVal, childVal) {
-    var res = childVal
+    const res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : Array.isArray(childVal)
@@ -1128,15 +1136,15 @@ function mergeHook$1(parentVal, childVal) {
     return res ? dedupeHooks(res) : res;
 }
 function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
         if (res.indexOf(hooks[i]) === -1) {
             res.push(hooks[i]);
         }
     }
     return res;
 }
-LIFECYCLE_HOOKS.forEach(function (hook) {
+LIFECYCLE_HOOKS.forEach((hook) => {
     strats[hook] = mergeHook$1;
 });
 /**
@@ -1147,7 +1155,7 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * options and parent options.
  */
 function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
+    const res = Object.create(parentVal || null);
     if (childVal) {
         process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
         return extend(res, childVal);
@@ -1169,27 +1177,27 @@ strats.watch = function (parentVal, childVal, vm, key) {
     // work around Firefox's Object.prototype.watch...
     //@ts-expect-error work around
     if (parentVal === nativeWatch)
-        { parentVal = undefined; }
+        parentVal = undefined;
     //@ts-expect-error work around
     if (childVal === nativeWatch)
-        { childVal = undefined; }
+        childVal = undefined;
     /* istanbul ignore if */
     if (!childVal)
-        { return Object.create(parentVal || null); }
+        return Object.create(parentVal || null);
     if (process.env.NODE_ENV !== 'production') {
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = {};
+        return childVal;
+    const ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
         if (parent && !Array.isArray(parent)) {
             parent = [parent];
         }
-        ret[key$1] = parent
+        ret[key] = parent
             ? parent.concat(child)
             : Array.isArray(child)
                 ? child
@@ -1205,30 +1213,30 @@ strats.props = strats.methods = strats.inject = strats.computed = function (pare
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = Object.create(null);
+        return childVal;
+    const ret = Object.create(null);
     extend(ret, parentVal);
     if (childVal)
-        { extend(ret, childVal); }
+        extend(ret, childVal);
     return ret;
 };
 strats.provide = mergeDataOrFn;
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
+const defaultStrat = function (parentVal, childVal) {
     return childVal === undefined ? parentVal : childVal;
 };
 /**
  * Validate component names
  */
 function checkComponents(options) {
-    for (var key in options.components) {
+    for (const key in options.components) {
         validateComponentName(key);
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
         warn$2('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1245,11 +1253,11 @@ function validateComponentName(name) {
  * Object-based format.
  */
 function normalizeProps(options, vm) {
-    var props = options.props;
+    const props = options.props;
     if (!props)
-        { return; }
-    var res = {};
-    var i, val, name;
+        return;
+    const res = {};
+    let i, val, name;
     if (Array.isArray(props)) {
         i = props.length;
         while (i--) {
@@ -1264,15 +1272,15 @@ function normalizeProps(options, vm) {
         }
     }
     else if (isPlainObject(props)) {
-        for (var key in props) {
+        for (const key in props) {
             val = props[key];
             name = camelize(key);
             res[name] = isPlainObject(val) ? val : { type: val };
         }
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
     }
     options.props = res;
 }
@@ -1280,36 +1288,36 @@ function normalizeProps(options, vm) {
  * Normalize all injections into Object-based format
  */
 function normalizeInject(options, vm) {
-    var inject = options.inject;
+    const inject = options.inject;
     if (!inject)
-        { return; }
-    var normalized = (options.inject = {});
+        return;
+    const normalized = (options.inject = {});
     if (Array.isArray(inject)) {
-        for (var i = 0; i < inject.length; i++) {
+        for (let i = 0; i < inject.length; i++) {
             normalized[inject[i]] = { from: inject[i] };
         }
     }
     else if (isPlainObject(inject)) {
-        for (var key in inject) {
-            var val = inject[key];
+        for (const key in inject) {
+            const val = inject[key];
             normalized[key] = isPlainObject(val)
                 ? extend({ from: key }, val)
                 : { from: val };
         }
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
 function normalizeDirectives$1(options) {
-    var dirs = options.directives;
+    const dirs = options.directives;
     if (dirs) {
-        for (var key in dirs) {
-            var def = dirs[key];
+        for (const key in dirs) {
+            const def = dirs[key];
             if (typeof def === 'function') {
                 dirs[key] = { bind: def, update: def };
             }
@@ -1318,8 +1326,8 @@ function normalizeDirectives$1(options) {
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
     }
 }
 /**
@@ -1346,13 +1354,13 @@ function mergeOptions(parent, child, vm) {
             parent = mergeOptions(parent, child.extends, vm);
         }
         if (child.mixins) {
-            for (var i = 0, l = child.mixins.length; i < l; i++) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
                 parent = mergeOptions(parent, child.mixins[i], vm);
             }
         }
     }
-    var options = {};
-    var key;
+    const options = {};
+    let key;
     for (key in parent) {
         mergeField(key);
     }
@@ -1362,7 +1370,7 @@ function mergeOptions(parent, child, vm) {
         }
     }
     function mergeField(key) {
-        var strat = strats[key] || defaultStrat;
+        const strat = strats[key] || defaultStrat;
         options[key] = strat(parent[key], child[key], vm, key);
     }
     return options;
@@ -1377,18 +1385,18 @@ function resolveAsset(options, type, id, warnMissing) {
     if (typeof id !== 'string') {
         return;
     }
-    var assets = options[type];
+    const assets = options[type];
     // check local registration variations first
     if (hasOwn(assets, id))
-        { return assets[id]; }
-    var camelizedId = camelize(id);
+        return assets[id];
+    const camelizedId = camelize(id);
     if (hasOwn(assets, camelizedId))
-        { return assets[camelizedId]; }
-    var PascalCaseId = capitalize(camelizedId);
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
     if (hasOwn(assets, PascalCaseId))
-        { return assets[PascalCaseId]; }
+        return assets[PascalCaseId];
     // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
         warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
@@ -1396,11 +1404,11 @@ function resolveAsset(options, type, id, warnMissing) {
 }
 
 function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
     // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
     if (booleanIndex > -1) {
         if (absent && !hasOwn(prop, 'default')) {
             value = false;
@@ -1408,7 +1416,7 @@ function validateProp(key, propOptions, propsData, vm) {
         else if (value === '' || value === hyphenate(key)) {
             // only cast empty string / same name to boolean if
             // boolean has higher priority
-            var stringIndex = getTypeIndex(String, prop.type);
+            const stringIndex = getTypeIndex(String, prop.type);
             if (stringIndex < 0 || booleanIndex < stringIndex) {
                 value = true;
             }
@@ -1419,7 +1427,7 @@ function validateProp(key, propOptions, propsData, vm) {
         value = getPropDefaultValue(vm, prop, key);
         // since the default value is a fresh copy,
         // make sure to observe it.
-        var prevShouldObserve = shouldObserve;
+        const prevShouldObserve = shouldObserve;
         toggleObserving(true);
         observe(value);
         toggleObserving(prevShouldObserve);
@@ -1439,7 +1447,7 @@ function getPropDefaultValue(vm, prop, key) {
     if (!hasOwn(prop, 'default')) {
         return undefined;
     }
-    var def = prop.default;
+    const def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (process.env.NODE_ENV !== 'production' && isObject(def)) {
         warn$2('Invalid default value for prop "' +
@@ -1473,38 +1481,37 @@ function assertProp(prop, name, value, vm, absent) {
     if (value == null && !prop.required) {
         return;
     }
-    var type = prop.type;
-    // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
     if (type) {
         if (!Array.isArray(type)) {
             type = [type];
         }
-        for (var i = 0; i < type.length && !valid; i++) {
-            var assertedType = assertType(value, type[i], vm);
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
             expectedTypes.push(assertedType.expectedType || '');
             valid = assertedType.valid;
         }
     }
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    const haveExpectedTypes = expectedTypes.some((t) => t);
     if (!valid && haveExpectedTypes) {
         warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
-    var validator = prop.validator;
+    const validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
             warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
 function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
+    let valid;
+    const expectedType = getType(type);
     if (simpleCheckRE.test(expectedType)) {
-        var t = typeof value;
+        const t = typeof value;
         valid = t === expectedType.toLowerCase();
         // for primitive wrapper objects
         if (!valid && t === 'object') {
@@ -1527,18 +1534,18 @@ function assertType(value, type, vm) {
         }
     }
     return {
-        valid: valid,
-        expectedType: expectedType,
+        valid,
+        expectedType,
     };
 }
-var functionTypeCheckRE = /^\s*function (\w+)/;
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
 function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
+    const match = fn && fn.toString().match(functionTypeCheckRE);
     return match ? match[1] : '';
 }
 function isSameType(a, b) {
@@ -1548,7 +1555,7 @@ function getTypeIndex(type, expectedTypes) {
     if (!Array.isArray(expectedTypes)) {
         return isSameType(expectedTypes, type) ? 0 : -1;
     }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
         if (isSameType(expectedTypes[i], type)) {
             return i;
         }
@@ -1556,44 +1563,41 @@ function getTypeIndex(type, expectedTypes) {
     return -1;
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
     // check if we need to specify expected value
     if (expectedTypes.length === 1 &&
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += ` with value ${styleValue(value, expectedType)}`;
     }
-    message += ", got " + receivedType + " ";
+    message += `, got ${receivedType} `;
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += `with value ${styleValue(value, receivedType)}.`;
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return `"${value}"`;
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return `${Number(value)}`;
     }
     else {
-        return ("" + value);
+        return `${value}`;
     }
 }
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
 function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
 }
-function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
 function handleError(err, vm, info) {
@@ -1602,15 +1606,15 @@ function handleError(err, vm, info) {
     pushTarget();
     try {
         if (vm) {
-            var cur = vm;
+            let cur = vm;
             while ((cur = cur.$parent)) {
-                var hooks = cur.$options.errorCaptured;
+                const hooks = cur.$options.errorCaptured;
                 if (hooks) {
-                    for (var i = 0; i < hooks.length; i++) {
+                    for (let i = 0; i < hooks.length; i++) {
                         try {
-                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
                             if (capture)
-                                { return; }
+                                return;
                         }
                         catch (e) {
                             globalHandleError(e, cur, 'errorCaptured hook');
@@ -1626,17 +1630,18 @@ function handleError(err, vm, info) {
     }
 }
 function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
+    let res;
     try {
         res = args ? handler.apply(context, args) : handler.call(context);
         if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
             // issue #9511
             // avoid catch triggering multiple times when nested calls
             res._handled = true;
         }
     }
     catch (e) {
+        // @ts-expect-error should it be any?
         handleError(e, vm, info);
     }
     return res;
@@ -1658,7 +1663,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     if (process.env.NODE_ENV !== 'production') {
-        warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1670,14 +1675,14 @@ function logError(err, vm, info) {
 }
 
 /* globals MutationObserver */
-var isUsingMicroTask = false;
-var callbacks = [];
-var pending = false;
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
 function flushCallbacks() {
     pending = false;
-    var copies = callbacks.slice(0);
+    const copies = callbacks.slice(0);
     callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
+    for (let i = 0; i < copies.length; i++) {
         copies[i]();
     }
 }
@@ -1692,7 +1697,7 @@ function flushCallbacks() {
 // where microtasks have too high a priority and fire in between supposedly
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
-var timerFunc;
+let timerFunc;
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1701,8 +1706,8 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
+    const p = Promise.resolve();
+    timerFunc = () => {
         p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
@@ -1710,7 +1715,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
         // needs to do some other work, e.g. handle a timer. Therefore we can
         // "force" the microtask queue to be flushed by adding an empty timer.
         if (isIOS)
-            { setTimeout(noop); }
+            setTimeout(noop);
     };
     isUsingMicroTask = true;
 }
@@ -1722,13 +1727,13 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
     observer.observe(textNode, {
         characterData: true,
     });
-    timerFunc = function () {
+    timerFunc = () => {
         counter = (counter + 1) % 2;
         textNode.data = String(counter);
     };
@@ -1738,24 +1743,25 @@ else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
     // Fallback to setImmediate.
     // Technically it leverages the (macro) task queue,
     // but it is still a better choice than setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setImmediate(flushCallbacks);
     };
 }
 else {
     // Fallback to setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setTimeout(flushCallbacks, 0);
     };
 }
 function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
+    let _resolve;
+    callbacks.push(() => {
         if (cb) {
             try {
                 cb.call(ctx);
             }
             catch (e) {
+                // @ts-expect-error should it be any?
                 handleError(e, ctx, 'nextTick');
             }
         }
@@ -1769,24 +1775,24 @@ function nextTick(cb, ctx) {
     }
     // $flow-disable-line
     if (!cb && typeof Promise !== 'undefined') {
-        return new Promise(function (resolve) {
+        return new Promise((resolve) => {
             _resolve = resolve;
         });
     }
 }
 
-var mark;
-var measure;
+let mark;
+let measure;
 if (process.env.NODE_ENV !== 'production') {
-    var perf = inBrowser && window.performance;
+    const perf = inBrowser && window.performance;
     /* istanbul ignore if */
     if (perf &&
         perf.mark &&
         perf.measure &&
         perf.clearMarks &&
         perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
-        measure = function (name, startTag, endTag) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
             perf.measure(name, startTag, endTag);
             perf.clearMarks(startTag);
             perf.clearMarks(endTag);
@@ -1796,33 +1802,33 @@ if (process.env.NODE_ENV !== 'production') {
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-var initProxy;
+let initProxy;
 if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
-        warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
+    const warnNonPresent = (target, key) => {
+        warn$2(`Property or method "${key}" is not defined on the instance but ` +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
-        warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    const warnReservedPrefix = (target, key) => {
+        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
+            set(target, key, value) {
                 if (isBuiltInModifier(key)) {
-                    warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                     return false;
                 }
                 else {
@@ -1832,29 +1838,29 @@ if (process.env.NODE_ENV !== 'production') {
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
-            var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    const getHandler = {
+        get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return target[key];
         },
@@ -1862,8 +1868,8 @@ if (process.env.NODE_ENV !== 'production') {
     initProxy = function initProxy(vm) {
         if (hasProxy) {
             // determine which proxy handler to use
-            var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1872,7 +1878,7 @@ if (process.env.NODE_ENV !== 'production') {
     };
 }
 
-var seenObjects = new _Set();
+const seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
@@ -1883,15 +1889,15 @@ function traverse(val) {
     seenObjects.clear();
 }
 function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
+    let i, keys;
+    const isA = Array.isArray(val);
     if ((!isA && !isObject(val)) ||
         Object.isFrozen(val) ||
         val instanceof VNode) {
         return;
     }
     if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
+        const depId = val.__ob__.dep.id;
         if (seen.has(depId)) {
             return;
         }
@@ -1900,58 +1906,56 @@ function _traverse(val, seen) {
     if (isA) {
         i = val.length;
         while (i--)
-            { _traverse(val[i], seen); }
+            _traverse(val[i], seen);
     }
     else {
         keys = Object.keys(val);
         i = keys.length;
         while (i--)
-            { _traverse(val[keys[i]], seen); }
+            _traverse(val[keys[i]], seen);
     }
 }
 
-var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
     name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
+    const capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
-        name: name,
-        once: once,
-        capture: capture,
-        passive: passive,
+        name,
+        once,
+        capture,
+        passive,
     };
 });
 function createFnInvoker(fns, vm) {
     function invoker() {
-        var arguments$1 = arguments;
-
-        var fns = invoker.fns;
+        const fns = invoker.fns;
         if (Array.isArray(fns)) {
-            var cloned = fns.slice();
-            for (var i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
             }
         }
         else {
             // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
         }
     }
     invoker.fns = fns;
     return invoker;
 }
 function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, cur, old, event;
+    let name, cur, old, event;
     for (name in on) {
         cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
             process.env.NODE_ENV !== 'production' &&
-                warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+                warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1979,8 +1983,8 @@ function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
     }
-    var invoker;
-    var oldHook = def[hookKey];
+    let invoker;
+    const oldHook = def[hookKey];
     function wrappedHook() {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
@@ -2011,27 +2015,26 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
     // component itself.
-    var propOptions = Ctor.options.props;
+    const propOptions = Ctor.options.props;
     if (isUndef(propOptions)) {
         return;
     }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    const res = {};
+    const { attrs, props } = data;
     if (isDef(attrs) || isDef(props)) {
-        for (var key in propOptions) {
-            var altKey = hyphenate(key);
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
             if (process.env.NODE_ENV !== 'production') {
-                var keyInLowerCase = key.toLowerCase();
+                const keyInLowerCase = key.toLowerCase();
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                        (formatComponentName(
-                        // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
-                        "Note that HTML attributes are case-insensitive and camelCased " +
-                        "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2072,7 +2075,7 @@ function checkProp(res, hash, key, altKey, preserve) {
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
 function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
+    for (let i = 0; i < children.length; i++) {
         if (Array.isArray(children[i])) {
             return Array.prototype.concat.apply([], children);
         }
@@ -2094,18 +2097,18 @@ function isTextNode(node) {
     return isDef(node) && isDef(node.text) && isFalse(node.isComment);
 }
 function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
+    const res = [];
+    let i, c, lastIndex, last;
     for (i = 0; i < children.length; i++) {
         c = children[i];
         if (isUndef(c) || typeof c === 'boolean')
-            { continue; }
+            continue;
         lastIndex = res.length - 1;
         last = res[lastIndex];
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2137,7 +2140,7 @@ function normalizeArrayChildren(children, nestedIndex) {
                     isDef(c.tag) &&
                     isUndef(c.key) &&
                     isDef(nestedIndex)) {
-                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                    c.key = `__vlist${nestedIndex}_${i}__`;
                 }
                 res.push(c);
             }
@@ -2147,7 +2150,7 @@ function normalizeArrayChildren(children, nestedIndex) {
 }
 
 function initProvide(vm) {
-    var provide = vm.$options.provide;
+    const provide = vm.$options.provide;
     if (provide) {
         vm._provided =
             typeof provide === 'function'
@@ -2157,16 +2160,16 @@ function initProvide(vm) {
     }
 }
 function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
+    const result = resolveInject(vm.$options.inject, vm);
     if (result) {
         toggleObserving(false);
-        Object.keys(result).forEach(function (key) {
+        Object.keys(result).forEach((key) => {
             /* istanbul ignore else */
             if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], function () {
-                    warn$2("Avoid mutating an injected value directly since the changes will be " +
-                        "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                defineReactive(vm, key, result[key], () => {
+                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
                 });
             }
             else {
@@ -2179,15 +2182,15 @@ function initInjections(vm) {
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
-        var result = Object.create(null);
-        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (var i = 0; i < keys.length; i++) {
-            var key = keys[i];
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             // #6574 in case the inject object is observed...
             if (key === '__ob__')
-                { continue; }
-            var provideKey = inject[key].from;
-            var source = vm;
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
             while (source) {
                 if (source._provided && hasOwn(source._provided, provideKey)) {
                     result[key] = source._provided[provideKey];
@@ -2198,15 +2201,14 @@ function resolveInject(inject, vm) {
             }
             if (!source) {
                 if ('default' in inject[key]) {
-                    var provideDefault = inject[key].default;
+                    const provideDefault = inject[key].default;
                     result[key] =
                         typeof provideDefault === 'function'
                             ? provideDefault.call(vm)
                             : provideDefault;
                 }
                 else if (process.env.NODE_ENV !== 'production') {
-                    // @ts-ignore
-                    warn$2(("Injection \"" + key + "\" not found"), vm);
+                    warn$2(`Injection "${key}" not found`, vm);
                 }
             }
         }
@@ -2221,10 +2223,10 @@ function resolveSlots(children, context) {
     if (!children || !children.length) {
         return {};
     }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var data = child.data;
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
         // remove slot attribute if the node is resolved as a Vue slot node
         if (data && data.attrs && data.attrs.slot) {
             delete data.attrs.slot;
@@ -2234,8 +2236,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2248,9 +2250,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
         }
     }
     return slots;
@@ -2259,11 +2261,16 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
+}
+
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
     if (!slots) {
         res = {};
     }
@@ -2283,16 +2290,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2300,19 +2307,22 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     if (slots && Object.isExtensible(slots)) {
         slots._normalized = res;
     }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
-            res && typeof res === 'object' && !Array.isArray(res)
+            res && typeof res === "object" && !Array.isArray(res)
                 ? [res] // single vnode
                 : normalizeChildren(res);
-        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
             ? undefined
             : res;
     };
@@ -2329,14 +2339,14 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     return normalized;
 }
 function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; };
+    return () => slots[key];
 }
 
 /**
  * Runtime helper for rendering v-for lists.
  */
 function renderList(val, render) {
-    var ret = null, i, l, keys, key;
+    let ret = null, i, l, keys, key;
     if (Array.isArray(val) || typeof val === 'string') {
         ret = new Array(val.length);
         for (i = 0, l = val.length; i < l; i++) {
@@ -2352,8 +2362,8 @@ function renderList(val, render) {
     else if (isObject(val)) {
         if (hasSymbol && val[Symbol.iterator]) {
             ret = [];
-            var iterator = val[Symbol.iterator]();
-            var result = iterator.next();
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
             while (!result.done) {
                 ret.push(render(result.value, ret.length));
                 result = iterator.next();
@@ -2378,26 +2388,34 @@ function renderList(val, render) {
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
     if (scopedSlotFn) {
         // scoped slot
         props = props || {};
         if (bindObject) {
-            if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-                warn$2('slot v-bind without argument expects an Object', this);
+            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
             }
             props = extend(extend({}, bindObject), props);
         }
-        nodes = scopedSlotFn(props) || fallback;
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
     else {
-        nodes = this.$slots[name] || fallback;
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
-    var target = props && props.slot;
+    const target = props && props.slot;
     if (target) {
-        return this.$createElement('template', { slot: target }, nodes);
+        return this.$createElement("template", { slot: target }, nodes);
     }
     else {
         return nodes;
@@ -2425,7 +2443,7 @@ function isKeyNotMatch(expect, actual) {
  * passing in eventKeyName as last argument separately for backwards compat
  */
 function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
     if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
         return isKeyNotMatch(builtInKeyName, eventKeyName);
     }
@@ -2435,6 +2453,7 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     else if (eventKeyName) {
         return hyphenate(eventKeyName) !== key;
     }
+    return eventKeyCode === undefined;
 }
 
 /**
@@ -2450,32 +2469,30 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            let hash;
+            for (const key in value) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
                 else {
-                    var type = data.attrs && data.attrs.type;
+                    const type = data.attrs && data.attrs.type;
                     hash =
                         asProp || config.mustUseProp(tag, type, key)
                             ? data.domProps || (data.domProps = {})
                             : data.attrs || (data.attrs = {});
                 }
-                var camelizedKey = camelize(key);
-                var hyphenatedKey = hyphenate(key);
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
                 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                     hash[key] = value[key];
                     if (isSync) {
-                        var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
-            };
-
-            for (var key in value) loop( key );
+            }
         }
     }
     return data;
@@ -2485,8 +2502,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
  * Runtime helper for rendering static trees.
  */
 function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
     // if has already-rendered static tree and not inside v-for,
     // we can reuse the same tree.
     if (tree && !isInFor) {
@@ -2495,7 +2512,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic$1(tree, ("__static__" + index), false);
+    markStatic$1(tree, `__static__${index}`, false);
     return tree;
 }
 /**
@@ -2503,14 +2520,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic$1(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
     return tree;
 }
 function markStatic$1(tree, key, isOnce) {
     if (Array.isArray(tree)) {
-        for (var i = 0; i < tree.length; i++) {
+        for (let i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
             }
         }
     }
@@ -2531,10 +2548,10 @@ function bindObjectListeners(data, value) {
                 warn$2('v-on without argument expects an Object value', this);
         }
         else {
-            var on = (data.on = data.on ? extend({}, data.on) : {});
-            for (var key in value) {
-                var existing = on[key];
-                var ours = value[key];
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
                 on[key] = existing ? [].concat(existing, ours) : ours;
             }
         }
@@ -2546,8 +2563,8 @@ function resolveScopedSlots(fns, res,
 // the following are added in 2.6
 hasDynamicKeys, contentHashKey) {
     res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-        var slot = fns[i];
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
         if (Array.isArray(slot)) {
             resolveScopedSlots(slot, res, hasDynamicKeys);
         }
@@ -2569,8 +2586,8 @@ hasDynamicKeys, contentHashKey) {
 
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-        var key = values[i];
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
         if (typeof key === 'string' && key) {
             baseObj[values[i]] = values[i + 1];
         }
@@ -2578,7 +2595,7 @@ function bindDynamicKeys(baseObj, values) {
             key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
         }
     }
     return baseObj;
@@ -2611,12 +2628,10 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
-    var options = Ctor.options;
+    const options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
+    let contextVm;
     if (hasOwn(parent, '_uid')) {
         contextVm = Object.create(parent);
         // $flow-disable-line
@@ -2630,23 +2645,23 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         // $flow-disable-line
         parent = parent._original;
     }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
     this.data = data;
     this.props = props;
     this.children = children;
     this.parent = parent;
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2659,8 +2674,8 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
     }
     if (options._scopeId) {
-        this._c = function (a, b, c, d) {
-            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2669,34 +2684,34 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
 function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
     if (isDef(propOptions)) {
-        for (var key in propOptions) {
+        for (const key in propOptions) {
             props[key] = validateProp(key, propOptions, propsData || emptyObject);
         }
     }
     else {
         if (isDef(data.attrs))
-            { mergeProps(props, data.attrs); }
+            mergeProps(props, data.attrs);
         if (isDef(data.props))
-            { mergeProps(props, data.props); }
+            mergeProps(props, data.props);
     }
-    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    var vnode = options.render.call(null, renderContext._c, renderContext);
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
     if (vnode instanceof VNode) {
         return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
     }
     else if (Array.isArray(vnode)) {
-        var vnodes = normalizeChildren(vnode) || [];
-        var res = new Array(vnodes.length);
-        for (var i = 0; i < vnodes.length; i++) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
             res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
         }
         return res;
@@ -2706,7 +2721,7 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     // #7817 clone node before setting fnContext, otherwise if the node is reused
     // (e.g. it was from a cached normal slot) the fnContext causes named slots
     // that should not be matched to match.
-    var clone = cloneVNode(vnode);
+    const clone = cloneVNode(vnode);
     clone.fnContext = contextVm;
     clone.fnOptions = options;
     if (process.env.NODE_ENV !== 'production') {
@@ -2718,38 +2733,37 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     return clone;
 }
 function mergeProps(to, from) {
-    for (var key in from) {
+    for (const key in from) {
         to[camelize(key)] = from[key];
     }
 }
 
 // inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
             // kept-alive components, treat as a patch
-            var mountedNode = vnode; // work around flow
+            const mountedNode = vnode; // work around flow
             componentVNodeHooks.prepatch(mountedNode, mountedNode);
         }
         else {
-            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
-        var options = vnode.componentOptions;
-        var child = (vnode.componentInstance = oldVnode.componentInstance);
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
         options.listeners, // updated listeners
         vnode, // new parent vnode
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2768,8 +2782,8 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
-        var componentInstance = vnode.componentInstance;
+    destroy(vnode) {
+        const { componentInstance } = vnode;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
                 componentInstance.$destroy();
@@ -2780,12 +2794,12 @@ var componentVNodeHooks = {
         }
     },
 };
-var hooksToMerge = Object.keys(componentVNodeHooks);
+const hooksToMerge = Object.keys(componentVNodeHooks);
 function createComponent(Ctor, data, context, children, tag) {
     if (isUndef(Ctor)) {
         return;
     }
-    var baseCtor = context.$options._base;
+    const baseCtor = context.$options._base;
     // plain options object: turn it into a constructor
     if (isObject(Ctor)) {
         Ctor = baseCtor.extend(Ctor);
@@ -2794,12 +2808,12 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         if (process.env.NODE_ENV !== 'production') {
-            warn$2(("Invalid Component definition: " + (String(Ctor))), context);
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
         }
         return;
     }
     // async component
-    var asyncFactory;
+    let asyncFactory;
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
@@ -2822,7 +2836,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract props
     // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
     // functional component
     // @ts-expect-error
     if (isTrue(Ctor.options.functional)) {
@@ -2830,7 +2844,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract listeners, since these needs to be treated as
     // child component listeners instead of DOM listeners
-    var listeners = data.on;
+    const listeners = data.on;
     // replace with listeners with .native modifier
     // so it gets processed during parent component patch.
     data.on = data.nativeOn;
@@ -2839,7 +2853,7 @@ function createComponent(Ctor, data, context, children, tag) {
         // abstract components do not keep anything
         // other than props & listeners & slot
         // work around flow
-        var slot = data.slot;
+        const slot = data.slot;
         data = {};
         if (slot) {
             data.slot = slot;
@@ -2849,12 +2863,12 @@ function createComponent(Ctor, data, context, children, tag) {
     installComponentHooks(data);
     // return a placeholder vnode
     // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
     // @ts-expect-error
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
     return vnode;
 }
 function createComponentInstanceForVnode(
@@ -2862,13 +2876,13 @@ function createComponentInstanceForVnode(
 vnode, 
 // activeInstance in lifecycle state
 parent) {
-    var options = {
+    const options = {
         _isComponent: true,
         _parentVnode: vnode,
-        parent: parent,
+        parent,
     };
     // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
+    const inlineTemplate = vnode.data.inlineTemplate;
     if (isDef(inlineTemplate)) {
         options.render = inlineTemplate.render;
         options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2876,11 +2890,11 @@ parent) {
     return new vnode.componentOptions.Ctor(options);
 }
 function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-        var key = hooksToMerge[i];
-        var existing = hooks[key];
-        var toMerge = componentVNodeHooks[key];
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
             hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2888,7 +2902,7 @@ function installComponentHooks(data) {
     }
 }
 function mergeHook(f1, f2) {
-    var merged = function (a, b) {
+    const merged = (a, b) => {
         // flow complains about extra args which is why we use any
         f1(a, b);
         f2(a, b);
@@ -2899,12 +2913,12 @@ function mergeHook(f1, f2) {
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
 function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input';
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
     (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
     if (isDef(existing)) {
         if (Array.isArray(existing)
             ? existing.indexOf(callback) === -1
@@ -2917,8 +2931,8 @@ function transformModel(options, data) {
     }
 }
 
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
 function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2935,7 +2949,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
         process.env.NODE_ENV !== 'production' &&
-            warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+            warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2969,9 +2983,9 @@ function _createElement(context, tag, data, children, normalizationType) {
     else if (normalizationType === SIMPLE_NORMALIZE) {
         children = simpleNormalizeChildren(children);
     }
-    var vnode, ns;
+    let vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        let Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
@@ -2979,7 +2993,7 @@ function _createElement(context, tag, data, children, normalizationType) {
                 isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn$2(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -3004,9 +3018,9 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     else if (isDef(vnode)) {
         if (isDef(ns))
-            { applyNS(vnode, ns); }
+            applyNS(vnode, ns);
         if (isDef(data))
-            { registerDeepBindings(data); }
+            registerDeepBindings(data);
         return vnode;
     }
     else {
@@ -3021,8 +3035,8 @@ function applyNS(vnode, ns, force) {
         force = true;
     }
     if (isDef(vnode.children)) {
-        for (var i = 0, l = vnode.children.length; i < l; i++) {
-            var child = vnode.children[i];
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
             if (isDef(child.tag) &&
                 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                 applyNS(child, ns, force);
@@ -3045,9 +3059,9 @@ function registerDeepBindings(data) {
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
     vm.$slots = resolveSlots(options._renderChildren, renderContext);
     vm.$scopedSlots = emptyObject;
     // bind the createElement fn to this instance
@@ -3055,21 +3069,21 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
+    const parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
         }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
         }, true);
     }
     else {
@@ -3077,7 +3091,7 @@ function initRender(vm) {
         defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
     }
 }
-var currentRenderingInstance = null;
+let currentRenderingInstance = null;
 function renderMixin(Vue) {
     // install runtime convenience helpers
     installRenderHelpers(Vue.prototype);
@@ -3085,10 +3099,8 @@ function renderMixin(Vue) {
         return nextTick(fn, this);
     };
     Vue.prototype._render = function () {
-        var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3096,7 +3108,7 @@ function renderMixin(Vue) {
         // to the data on the placeholder node.
         vm.$vnode = _parentVnode;
         // render self
-        var vnode;
+        let vnode;
         try {
             // There's no need to maintain a stack because all render fns are called
             // separately from one another. Nested component's render fns are called
@@ -3105,7 +3117,7 @@ function renderMixin(Vue) {
             vnode = render.call(vm._renderProxy, vm.$createElement);
         }
         catch (e) {
-            handleError(e, vm, "render");
+            handleError(e, vm, `render`);
             // return error render result,
             // or previous vnode to prevent render error causing blank component
             /* istanbul ignore else */
@@ -3113,8 +3125,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e$1) {
-                    handleError(e$1, vm, "renderError");
+                catch (e) {
+                    handleError(e, vm, `renderError`);
                     vnode = vm._vnode;
                 }
             }
@@ -3150,9 +3162,9 @@ function ensureCtor(comp, base) {
     return isObject(comp) ? base.extend(comp) : comp;
 }
 function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
+    const node = createEmptyVNode();
     node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    node.asyncMeta = { data, context, children, tag };
     return node;
 }
 function resolveAsyncComponent(factory, baseCtor) {
@@ -3162,7 +3174,7 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    var owner = currentRenderingInstance;
+    const owner = currentRenderingInstance;
     if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
         // already pending
         factory.owners.push(owner);
@@ -3171,13 +3183,13 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
                 owners[i].$forceUpdate();
             }
             if (renderCompleted) {
@@ -3192,7 +3204,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
             }
         };
-        var resolve = once(function (res) {
+        const resolve = once((res) => {
             // cache resolved
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
@@ -3204,16 +3216,16 @@ function resolveAsyncComponent(factory, baseCtor) {
                 owners.length = 0;
             }
         });
-        var reject = once(function (reason) {
+        const reject = once((reason) => {
             process.env.NODE_ENV !== 'production' &&
-                warn$2("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+                warn$2(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
                 forceRender(true);
             }
         });
-        var res = factory(resolve, reject);
+        const res = factory(resolve, reject);
         if (isObject(res)) {
             if (isPromise(res)) {
                 // () => Promise
@@ -3233,7 +3245,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
+                        timerLoading = setTimeout(() => {
                             timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
@@ -3244,11 +3256,11 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
                 if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
+                    timerTimeout = setTimeout(() => {
                         timerTimeout = null;
                         if (isUndef(factory.resolved)) {
                             reject(process.env.NODE_ENV !== 'production'
-                                ? ("timeout (" + (res.timeout) + "ms)")
+                                ? `timeout (${res.timeout}ms)`
                                 : null);
                         }
                     }, res.timeout);
@@ -3261,15 +3273,10 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-            var c = children[i];
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
             if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                 return c;
             }
@@ -3281,12 +3288,12 @@ function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
     // init parent attached events
-    var listeners = vm.$options._parentListeners;
+    const listeners = vm.$options._parentListeners;
     if (listeners) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target$1;
+let target$1;
 function add$1(event, fn) {
     target$1.$on(event, fn);
 }
@@ -3294,9 +3301,9 @@ function remove$1(event, fn) {
     target$1.$off(event, fn);
 }
 function createOnceHandler$1(event, fn) {
-    var _target = target$1;
+    const _target = target$1;
     return function onceHandler() {
-        var res = fn.apply(null, arguments);
+        const res = fn.apply(null, arguments);
         if (res !== null) {
             _target.$off(event, onceHandler);
         }
@@ -3308,11 +3315,11 @@ function updateComponentListeners(vm, listeners, oldListeners) {
     target$1 = undefined;
 }
 function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
+    const hookRE = /^hook:/;
     Vue.prototype.$on = function (event, fn) {
-        var vm = this;
+        const vm = this;
         if (Array.isArray(event)) {
-            for (var i = 0, l = event.length; i < l; i++) {
+            for (let i = 0, l = event.length; i < l; i++) {
                 vm.$on(event[i], fn);
             }
         }
@@ -3327,7 +3334,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$once = function (event, fn) {
-        var vm = this;
+        const vm = this;
         function on() {
             vm.$off(event, on);
             fn.apply(vm, arguments);
@@ -3337,7 +3344,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$off = function (event, fn) {
-        var vm = this;
+        const vm = this;
         // all
         if (!arguments.length) {
             vm._events = Object.create(null);
@@ -3345,13 +3352,13 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
             }
             return vm;
         }
         // specific event
-        var cbs = vm._events[event];
+        const cbs = vm._events[event];
         if (!cbs) {
             return vm;
         }
@@ -3360,8 +3367,8 @@ function eventsMixin(Vue) {
             return vm;
         }
         // specific handler
-        var cb;
-        var i = cbs.length;
+        let cb;
+        let i = cbs.length;
         while (i--) {
             cb = cbs[i];
             if (cb === fn || cb.fn === fn) {
@@ -3372,23 +3379,23 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$emit = function (event) {
-        var vm = this;
+        const vm = this;
         if (process.env.NODE_ENV !== 'production') {
-            var lowerCaseEvent = event.toLowerCase();
+            const lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                    "Note that HTML attributes are case-insensitive and you cannot use " +
-                    "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
             }
         }
-        var cbs = vm._events[event];
+        let cbs = vm._events[event];
         if (cbs) {
             cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            var args = toArray(arguments, 1);
-            var info = "event handler for \"" + event + "\"";
-            for (var i = 0, l = cbs.length; i < l; i++) {
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
                 invokeWithErrorHandling(cbs[i], vm, args, vm, info);
             }
         }
@@ -3396,19 +3403,19 @@ function eventsMixin(Vue) {
     };
 }
 
-var activeInstance = null;
-var isUpdatingChildComponent = false;
+let activeInstance = null;
+let isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
+    const prevActiveInstance = activeInstance;
     activeInstance = vm;
-    return function () {
+    return () => {
         activeInstance = prevActiveInstance;
     };
 }
 function initLifecycle(vm) {
-    var options = vm.$options;
+    const options = vm.$options;
     // locate first non-abstract parent
-    var parent = options.parent;
+    let parent = options.parent;
     if (parent && !options.abstract) {
         while (parent.$options.abstract && parent.$parent) {
             parent = parent.$parent;
@@ -3419,7 +3426,6 @@ function initLifecycle(vm) {
     vm.$root = parent ? parent.$root : vm;
     vm.$children = [];
     vm.$refs = {};
-    // @ts-ignore
     vm._watcher = null;
     vm._inactive = null;
     vm._directInactive = false;
@@ -3429,10 +3435,10 @@ function initLifecycle(vm) {
 }
 function lifecycleMixin(Vue) {
     Vue.prototype._update = function (vnode, hydrating) {
-        var vm = this;
-        var prevEl = vm.$el;
-        var prevVnode = vm._vnode;
-        var restoreActiveInstance = setActiveInstance(vm);
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
         vm._vnode = vnode;
         // Vue.prototype.__patch__ is injected in entry points
         // based on the rendering backend used.
@@ -3460,21 +3466,20 @@ function lifecycleMixin(Vue) {
         // updated in a parent's updated hook.
     };
     Vue.prototype.$forceUpdate = function () {
-        var vm = this;
+        const vm = this;
         if (vm._watcher) {
             vm._watcher.update();
         }
     };
     Vue.prototype.$destroy = function () {
-        var vm = this;
+        const vm = this;
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook$1(vm, 'beforeDestroy');
+        callHook$1(vm, "beforeDestroy");
         vm._isBeingDestroyed = true;
         // remove self from parent
-        var parent = vm.$parent;
-        // @ts-ignore
+        const parent = vm.$parent;
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
             remove$2(parent.$children, vm);
         }
@@ -3482,7 +3487,7 @@ function lifecycleMixin(Vue) {
         if (vm._watcher) {
             vm._watcher.teardown();
         }
-        var i = vm._watchers.length;
+        let i = vm._watchers.length;
         while (i--) {
             vm._watchers[i].teardown();
         }
@@ -3496,7 +3501,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook$1(vm, 'destroyed');
+        callHook$1(vm, "destroyed");
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3505,7 +3510,6 @@ function lifecycleMixin(Vue) {
         }
         // release circular reference (#6759)
         if (vm.$vnode) {
-            // @ts-expect-error null is not undefined
             vm.$vnode.parent = null;
         }
     };
@@ -3515,41 +3519,41 @@ function mountComponent(vm, el, hydrating) {
     if (!vm.$options.render) {
         // @ts-expect-error invalid type
         vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== 'production') {
+        if (process.env.NODE_ENV !== "production") {
             /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                 vm.$options.el ||
                 el) {
-                warn$2('You are using the runtime-only build of Vue where the template ' +
-                    'compiler is not available. Either pre-compile the templates into ' +
-                    'render functions, or use the compiler-included build.', vm);
+                warn$2("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
             }
             else {
-                warn$2('Failed to mount component: template or render function not defined.', vm);
+                warn$2("Failed to mount component: template or render function not defined.", vm);
             }
         }
     }
-    callHook$1(vm, 'beforeMount');
-    var updateComponent;
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        updateComponent = function () {
-            var name = vm._name;
-            var id = vm._uid;
-            var startTag = "vue-perf-start:" + id;
-            var endTag = "vue-perf-end:" + id;
+    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
             mark(startTag);
-            var vnode = vm._render();
+            const vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure(`vue ${name} render`, startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
         };
     }
     else {
-        updateComponent = function () {
+        updateComponent = () => {
             vm._update(vm._render(), hydrating);
         };
     }
@@ -3557,9 +3561,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before() {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, 'beforeUpdate');
+                callHook$1(vm, "beforeUpdate");
             }
         },
     }, true /* isRenderWatcher */);
@@ -3568,12 +3572,12 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook$1(vm, 'mounted');
+        callHook$1(vm, "mounted");
     }
     return vm;
 }
 function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
         isUpdatingChildComponent = true;
     }
     // determine whether component has slot children
@@ -3581,24 +3585,22 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // check if there are dynamic scopedSlots (hand-written or compiled but with
     // dynamic slot names). Static scoped slots compiled from template has the
     // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(renderChildren || // has new static slots
+    const needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
-    // @ts-ignore
     vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
     vm.$vnode = parentVnode; // update vm's placeholder node without re-render
     if (vm._vnode) {
         // update child tree's parent
-        // @ts-ignore
         vm._vnode.parent = parentVnode;
     }
     vm.$options._renderChildren = renderChildren;
@@ -3606,16 +3608,15 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // these are also reactive so they may trigger child update if the child
     // used them during render
     vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
     vm.$listeners = listeners || emptyObject;
     // update props
     if (propsData && vm.$options.props) {
         toggleObserving(false);
-        var props = vm._props;
-        var propKeys = vm.$options._propKeys || [];
-        for (var i = 0; i < propKeys.length; i++) {
-            var key = propKeys[i];
-            var propOptions = vm.$options.props; // wtf flow?
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
             props[key] = validateProp(key, propOptions, propsData, vm);
         }
         toggleObserving(true);
@@ -3624,7 +3625,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     }
     // update listeners
     listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
+    const oldListeners = vm.$options._parentListeners;
     vm.$options._parentListeners = listeners;
     updateComponentListeners(vm, listeners, oldListeners);
     // resolve slots + force update if has children
@@ -3632,14 +3633,14 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
         vm.$slots = resolveSlots(renderChildren, parentVnode.context);
         vm.$forceUpdate();
     }
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
         isUpdatingChildComponent = false;
     }
 }
 function isInInactiveTree(vm) {
     while (vm && (vm = vm.$parent)) {
         if (vm._inactive)
-            { return true; }
+            return true;
     }
     return false;
 }
@@ -3655,10 +3656,10 @@ function activateChildComponent(vm, direct) {
     }
     if (vm._inactive || vm._inactive === null) {
         vm._inactive = false;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'activated');
+        callHook$1(vm, "activated");
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3670,36 +3671,36 @@ function deactivateChildComponent(vm, direct) {
     }
     if (!vm._inactive) {
         vm._inactive = true;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'deactivated');
+        callHook$1(vm, "deactivated");
     }
 }
 function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
     if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
             invokeWithErrorHandling(handlers[i], vm, null, vm, info);
         }
     }
     if (vm._hasHookEvent) {
-        vm.$emit('hook:' + hook);
+        vm.$emit("hook:" + hook);
     }
     popTarget();
 }
 
-var MAX_UPDATE_COUNT = 100;
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index$1 = 0;
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index$1 = 0;
 /**
  * Reset the scheduler's state.
  */
@@ -3716,9 +3717,9 @@ function resetSchedulerState() {
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
-var currentFlushTimestamp = 0;
+let currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
+let getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3726,7 +3727,7 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
+    const performance = window.performance;
     if (performance &&
         typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
@@ -3734,7 +3735,7 @@ if (inBrowser && !isIE) {
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = () => performance.now();
     }
 }
 /**
@@ -3743,7 +3744,7 @@ if (inBrowser && !isIE) {
 function flushSchedulerQueue() {
     currentFlushTimestamp = getNow();
     flushing = true;
-    var watcher, id;
+    let watcher, id;
     // Sort queue before flush.
     // This ensures that:
     // 1. Components are updated from parent to child. (because parent is always
@@ -3752,7 +3753,7 @@ function flushSchedulerQueue() {
     //    user watchers are created before the render watcher)
     // 3. If a component is destroyed during a parent component's watcher run,
     //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
+    queue.sort((a, b) => a.id - b.id);
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
     for (index$1 = 0; index$1 < queue.length; index$1++) {
@@ -3769,15 +3770,15 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn$2('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                        : "in a component render function."), watcher.vm);
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
                 break;
             }
         }
     }
     // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
     resetSchedulerState();
     // call component updated and activated hooks
     callActivatedHooks(activatedQueue);
@@ -3789,10 +3790,10 @@ function flushSchedulerQueue() {
     }
 }
 function callUpdatedHooks(queue) {
-    var i = queue.length;
+    let i = queue.length;
     while (i--) {
-        var watcher = queue[i];
-        var vm = watcher.vm;
+        const watcher = queue[i];
+        const vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
             callHook$1(vm, 'updated');
         }
@@ -3809,7 +3810,7 @@ function queueActivatedComponent(vm) {
     activatedChildren.push(vm);
 }
 function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
+    for (let i = 0; i < queue.length; i++) {
         queue[i]._inactive = true;
         activateChildComponent(queue[i], true /* true */);
     }
@@ -3820,7 +3821,7 @@ function callActivatedHooks(queue) {
  * pushed when the queue is being flushed.
  */
 function queueWatcher(watcher) {
-    var id = watcher.id;
+    const id = watcher.id;
     if (has[id] == null) {
         has[id] = true;
         if (!flushing) {
@@ -3829,7 +3830,7 @@ function queueWatcher(watcher) {
         else {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
-            var i = queue.length - 1;
+            let i = queue.length - 1;
             while (i > index$1 && queue[i].id > watcher.id) {
                 i--;
             }
@@ -3847,200 +3848,218 @@ function queueWatcher(watcher) {
     }
 }
 
-var uid$1 = 0;
+let uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$1; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            process.env.NODE_ENV !== 'production' &&
-                warn$2("Failed watching path: \"" + expOrFn + "\" " +
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = process.env.NODE_ENV !== 'production'
+            ? expOrFn.toString()
+            : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' && warn$2(`Failed watching path: "${expOrFn}" ` +
                     'Watcher only accepts simple dot-delimited paths. ' +
                     'For full control, use a function instead.', vm);
+            }
         }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
     }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-        else {
-            throw e;
+        catch (e) {
+            if (this.user) {
+                // @ts-expect-error e is unknown, should we cast or any?
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
         }
-        popTarget();
-        this.cleanupDeps();
+        return value;
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
         }
     }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
     }
-    else {
-        queueWatcher(this);
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
     }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
-            if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                 }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                else {
+                    this.cb.call(this.vm, value, oldValue);
                 }
             }
-            else {
-                this.cb.call(this.vm, value, oldValue);
-            }
         }
     }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
     }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove$2(this.vm._watchers, this);
-        }
-        var i = this.deps.length;
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            this.deps[i].depend();
         }
-        this.active = false;
     }
-};
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
+}
 
-var sharedPropertyDefinition = {
+const sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
     get: noop,
@@ -4057,11 +4076,11 @@ function proxy(target, sourceKey, key) {
 }
 function initState(vm) {
     vm._watchers = [];
-    var opts = vm.$options;
+    const opts = vm.$options;
     if (opts.props)
-        { initProps$1(vm, opts.props); }
+        initProps$1(vm, opts.props);
     if (opts.methods)
-        { initMethods(vm, opts.methods); }
+        initMethods(vm, opts.methods);
     if (opts.data) {
         initData(vm);
     }
@@ -4069,38 +4088,38 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed$1(vm, opts.computed); }
+        initComputed$1(vm, opts.computed);
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
 function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
     // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
     // root instance props should be converted
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    for (const key in propsOptions) {
         keys.push(key);
-        var value = validateProp(key, propsOptions, propsData, vm);
+        const value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            var hyphenatedKey = hyphenate(key);
+        if (process.env.NODE_ENV !== "production") {
+            const hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn$2(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
             }
-            defineReactive(props, key, value, function () {
+            defineReactive(props, key, value, () => {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2("Avoid mutating a prop directly since the value will be " +
-                        "overwritten whenever the parent component re-renders. " +
-                        "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                    warn$2(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
                 }
             });
         }
@@ -4111,41 +4130,39 @@ function initProps$1(vm, propsOptions) {
         // during Vue.extend(). We only need to proxy props defined at
         // instantiation here.
         if (!(key in vm)) {
-            proxy(vm, "_props", key);
+            proxy(vm, `_props`, key);
         }
-    };
-
-    for (var key in propsOptions) loop( key );
+    }
     toggleObserving(true);
 }
 function initData(vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('data functions should return an object:\n' +
-                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+        process.env.NODE_ENV !== "production" &&
+            warn$2("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
     }
     // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
     while (i--) {
-        var key = keys[i];
-        if (process.env.NODE_ENV !== 'production') {
+        const key = keys[i];
+        if (process.env.NODE_ENV !== "production") {
             if (methods && hasOwn(methods, key)) {
-                warn$2(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2("The data property \"" + key + "\" is already declared as a prop. " +
-                    "Use prop default value instead.", vm);
+            process.env.NODE_ENV !== "production" &&
+                warn$2(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
         }
         else if (!isReserved(key)) {
-            proxy(vm, "_data", key);
+            proxy(vm, `_data`, key);
         }
     }
     // observe data
@@ -4158,24 +4175,24 @@ function getData(data, vm) {
         return data.call(vm, vm);
     }
     catch (e) {
-        handleError(e, vm, "data()");
+        handleError(e, vm, `data()`);
         return {};
     }
     finally {
         popTarget();
     }
 }
-var computedWatcherOptions = { lazy: true };
+const computedWatcherOptions = { lazy: true };
 function initComputed$1(vm, computed) {
     // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
+    const watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-        var userDef = computed[key];
-        var getter = typeof userDef === 'function' ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn$2(("Getter is missing for computed property \"" + key + "\"."), vm);
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== "production" && getter == null) {
+            warn$2(`Getter is missing for computed property "${key}".`, vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4187,19 +4204,22 @@ function initComputed$1(vm, computed) {
         if (!(key in vm)) {
             defineComputed(vm, key, userDef);
         }
-        else if (process.env.NODE_ENV !== 'production') {
+        else if (process.env.NODE_ENV !== "production") {
             if (key in vm.$data) {
-                warn$2(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn$2(`The computed property "${key}" is already defined in data.`, vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
             }
         }
     }
 }
 function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
             : createGetterInvoker(userDef);
@@ -4213,17 +4233,17 @@ function defineComputed(target, key, userDef) {
             : noop;
         sharedPropertyDefinition.set = userDef.set || noop;
     }
-    if (process.env.NODE_ENV !== 'production' &&
+    if (process.env.NODE_ENV !== "production" &&
         sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn$2(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
 }
 function createComputedGetter(key) {
     return function computedGetter() {
-        var watcher = this._computedWatchers && this._computedWatchers[key];
+        const watcher = this._computedWatchers && this._computedWatchers[key];
         if (watcher) {
             if (watcher.dirty) {
                 watcher.evaluate();
@@ -4241,29 +4261,30 @@ function createGetterInvoker(fn) {
     };
 }
 function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (typeof methods[key] !== 'function') {
-                warn$2("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                    "Did you reference the function correctly?", vm);
+    const props = vm.$options.props;
+    for (const key in methods) {
+        if (process.env.NODE_ENV !== "production") {
+            if (typeof methods[key] !== "function") {
+                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
             }
             if (props && hasOwn(props, key)) {
-                warn$2(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
             }
             if (key in vm && isReserved(key)) {
-                warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                    "Avoid defining component methods that start with _ or $.");
+                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
-    for (var key in watch) {
-        var handler = watch[key];
+    for (const key in watch) {
+        const handler = watch[key];
         if (Array.isArray(handler)) {
-            for (var i = 0; i < handler.length; i++) {
+            for (let i = 0; i < handler.length; i++) {
                 createWatcher(vm, key, handler[i]);
             }
         }
@@ -4277,7 +4298,7 @@ function createWatcher(vm, expOrFn, handler, options) {
         options = handler;
         handler = handler.handler;
     }
-    if (typeof handler === 'string') {
+    if (typeof handler === "string") {
         handler = vm[handler];
     }
     return vm.$watch(expOrFn, handler, options);
@@ -4286,43 +4307,39 @@ function stateMixin(Vue) {
     // flow somehow has problems with directly declared definition object
     // when using Object.defineProperty, so we have to procedurally build up
     // the object here.
-    var dataDef = {};
+    const dataDef = {};
     dataDef.get = function () {
         return this._data;
     };
-    var propsDef = {};
+    const propsDef = {};
     propsDef.get = function () {
         return this._props;
     };
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
         dataDef.set = function () {
-            warn$2('Avoid replacing instance root $data. ' +
-                'Use nested data properties instead.', this);
+            warn$2("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
         };
         propsDef.set = function () {
-            warn$2("$props is readonly.", this);
+            warn$2(`$props is readonly.`, this);
         };
     }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
-        var vm = this;
+        const vm = this;
         if (isPlainObject(cb)) {
             return createWatcher(vm, expOrFn, cb, options);
         }
         options = options || {};
         options.user = true;
-        var watcher = new Watcher(vm, expOrFn, cb, options);
+        const watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
             pushTarget();
-            try {
-                cb.call(vm, watcher.value);
-            }
-            catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-            }
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
             popTarget();
         }
         return function unwatchFn() {
@@ -4331,17 +4348,17 @@ function stateMixin(Vue) {
     };
 }
 
-var uid = 0;
+let uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
-        var vm = this;
+        const vm = this;
         // a uid
         vm._uid = uid++;
-        var startTag, endTag;
+        let startTag, endTag;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4377,7 +4394,7 @@ function initMixin$1(Vue) {
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4385,13 +4402,12 @@ function initMixin$1(Vue) {
     };
 }
 function initInternalComponent(vm, options) {
-    // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
+    const opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
+    const parentVnode = options._parentVnode;
     opts.parent = options.parent;
     opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
+    const vnodeComponentOptions = parentVnode.componentOptions;
     opts.propsData = vnodeComponentOptions.propsData;
     opts._parentListeners = vnodeComponentOptions.listeners;
     opts._renderChildren = vnodeComponentOptions.children;
@@ -4402,16 +4418,16 @@ function initInternalComponent(vm, options) {
     }
 }
 function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
+    let options = Ctor.options;
     if (Ctor.super) {
-        var superOptions = resolveConstructorOptions(Ctor.super);
-        var cachedSuperOptions = Ctor.superOptions;
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
         if (superOptions !== cachedSuperOptions) {
             // super option changed,
             // need to resolve new options.
             Ctor.superOptions = superOptions;
             // check if there are any late-modified/attached options (#4976)
-            var modifiedOptions = resolveModifiedOptions(Ctor);
+            const modifiedOptions = resolveModifiedOptions(Ctor);
             // update base extend options
             if (modifiedOptions) {
                 extend(Ctor.extendOptions, modifiedOptions);
@@ -4425,13 +4441,13 @@ function resolveConstructorOptions(Ctor) {
     return options;
 }
 function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
         if (latest[key] !== sealed[key]) {
             if (!modified)
-                { modified = {}; }
+                modified = {};
             modified[key] = latest[key];
         }
     }
@@ -4439,30 +4455,30 @@ function resolveModifiedOptions(Ctor) {
 }
 
 function Vue(options) {
-    if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
-        warn$2('Vue is a constructor and should be called with the `new` keyword');
+    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
+        warn$2("Vue is a constructor and should be called with the `new` keyword");
     }
     this._init(options);
 }
-//@ts-ignore
+//@ts-expect-error Vue has function type
 initMixin$1(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 stateMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 eventsMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 lifecycleMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
 function initUse(Vue) {
     Vue.use = function (plugin) {
-        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
         if (installedPlugins.indexOf(plugin) > -1) {
             return this;
         }
         // additional parameters
-        var args = toArray(arguments, 1);
+        const args = toArray(arguments, 1);
         args.unshift(this);
         if (typeof plugin.install === 'function') {
             plugin.install.apply(plugin, args);
@@ -4489,23 +4505,23 @@ function initExtend(Vue) {
      * constructors" for prototypal inheritance and cache them.
      */
     Vue.cid = 0;
-    var cid = 1;
+    let cid = 1;
     /**
      * Class inheritance
      */
     Vue.extend = function (extendOptions) {
         extendOptions = extendOptions || {};
-        var Super = this;
-        var SuperId = Super.cid;
-        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
         if (cachedCtors[SuperId]) {
             return cachedCtors[SuperId];
         }
-        var name = extendOptions.name || Super.options.name;
+        const name = extendOptions.name || Super.options.name;
         if (process.env.NODE_ENV !== 'production' && name) {
             validateComponentName(name);
         }
-        var Sub = function VueComponent(options) {
+        const Sub = function VueComponent(options) {
             this._init(options);
         };
         Sub.prototype = Object.create(Super.prototype);
@@ -4547,14 +4563,14 @@ function initExtend(Vue) {
     };
 }
 function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-        proxy(Comp.prototype, "_props", key);
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
     }
 }
 function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
     }
 }
@@ -4563,7 +4579,7 @@ function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
      */
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         // @ts-expect-error function is not exact same type
         Vue[type] = function (id, definition) {
             if (!definition) {
@@ -4589,6 +4605,7 @@ function initAssetRegisters(Vue) {
     });
 }
 
+/* @flow */
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4596,8 +4613,8 @@ function matches(pattern, name) {
     if (Array.isArray(pattern)) {
         return pattern.indexOf(name) > -1;
     }
-    else if (typeof pattern === 'string') {
-        return pattern.split(',').indexOf(name) > -1;
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
     }
     else if (isRegExp(pattern)) {
         return pattern.test(name);
@@ -4606,13 +4623,11 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-        var cachedNode = cache[key];
-        if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
             if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
@@ -4620,53 +4635,72 @@ function pruneCache(keepAliveInstance, filter) {
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-        //@ts-expect-error has void type
-        cached.componentInstance.$destroy();
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
     }
     cache[key] = null;
     remove$2(keys, key);
 }
-var patternTypes = [String, RegExp, Array];
-// TODO use defineComponent
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
 var KeepAlive = {
-    name: 'keep-alive',
+    name: "keep-alive",
     abstract: true,
     props: {
         include: patternTypes,
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
-        for (var key in this.cache) {
+    destroyed() {
+        for (const key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
-        this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
         });
-        this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
         });
     },
-    render: function render() {
-        var slot = this.$slots.default;
-        var vnode = getFirstComponentChild(slot);
-        var componentOptions = vnode && vnode.componentOptions;
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
             if (
             // not included
             (include && (!name || !matches(include, name))) ||
@@ -4674,14 +4708,12 @@ var KeepAlive = {
                 (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
-            var key = vnode.key == null
+            const { cache, keys } = this;
+            const key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4690,13 +4722,11 @@ var KeepAlive = {
                 keys.push(key);
             }
             else {
-                cache[key] = vnode;
-                keys.push(key);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
             }
+            // @ts-expect-error can vnode.data can be undefined
             vnode.data.keepAlive = true;
         }
         return vnode || (slot && slot[0]);
@@ -4704,15 +4734,15 @@ var KeepAlive = {
 };
 
 var builtInComponents = {
-    KeepAlive: KeepAlive,
+    KeepAlive,
 };
 
 function initGlobalAPI(Vue) {
     // config
-    var configDef = {};
-    configDef.get = function () { return config; };
+    const configDef = {};
+    configDef.get = () => config;
     if (process.env.NODE_ENV !== 'production') {
-        configDef.set = function () {
+        configDef.set = () => {
             warn$2('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
@@ -4722,20 +4752,20 @@ function initGlobalAPI(Vue) {
     // them unless you are aware of the risk.
     Vue.util = {
         warn: warn$2,
-        extend: extend,
-        mergeOptions: mergeOptions,
-        defineReactive: defineReactive,
+        extend,
+        mergeOptions,
+        defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
     Vue.nextTick = nextTick;
     // 2.6 explicit observable API
-    Vue.observable = function (obj) {
+    Vue.observable = (obj) => {
         observe(obj);
         return obj;
     };
     Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         Vue.options[type + 's'] = Object.create(null);
     });
     // this is used to identify the "base" constructor to extend all plain-object
@@ -4753,7 +4783,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4762,22 +4792,22 @@ Object.defineProperty(Vue.prototype, '$ssrContext', {
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
     value: FunctionalRenderContext,
 });
-Vue.version = '2.6.12';
+Vue.version = '2.6.14';
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+const isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue$1 = makeMap('input,textarea,option,select,progress');
-var mustUseProp$1 = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-var convertEnumeratedValue = function (key, value) {
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
     return isFalsyAttrValue(value) || value === 'false'
         ? 'false'
         : // allow arbitrary string value for contenteditable
@@ -4785,33 +4815,34 @@ var convertEnumeratedValue = function (key, value) {
                 ? value
                 : 'true';
 };
-var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
-var xlinkNS = 'http://www.w3.org/1999/xlink';
-var isXlink = function (name) {
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
     return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-var getXlinkProp = function (name) {
+const getXlinkProp = (name) => {
     return isXlink(name) ? name.slice(6, name.length) : '';
 };
-var isFalsyAttrValue = function (val) {
+const isFalsyAttrValue = (val) => {
     return val == null || val === false;
 };
 
 function genClassForVnode(vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
     while (isDef(childNode.componentInstance)) {
         childNode = childNode.componentInstance._vnode;
         if (childNode && childNode.data) {
             data = mergeClassData(childNode.data, data);
         }
     }
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while (isDef((parentNode = parentNode.parent))) {
         if (parentNode && parentNode.data) {
             data = mergeClassData(data, parentNode.data);
@@ -4849,34 +4880,34 @@ function stringifyClass(value) {
     return '';
 }
 function stringifyArray(value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
         if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += stringified;
         }
     }
     return res;
 }
 function stringifyObject(value) {
-    var res = '';
-    for (var key in value) {
+    let res = '';
+    for (const key in value) {
         if (value[key]) {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += key;
         }
     }
     return res;
 }
 
-var namespaceMap = {
+const namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4889,14 +4920,15 @@ var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isReservedTag$1 = function (tag) {
-    return isHTMLTag$1(tag) || isSVG$1(tag);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
 };
-function getTagNamespace$1(tag) {
-    if (isSVG$1(tag)) {
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
         return 'svg';
     }
     // basic support for MathML
@@ -4905,13 +4937,13 @@ function getTagNamespace$1(tag) {
         return 'math';
     }
 }
-var unknownElementCache = Object.create(null);
+const unknownElementCache = Object.create(null);
 function isUnknownElement(tag) {
     /* istanbul ignore if */
     if (!inBrowser) {
         return true;
     }
-    if (isReservedTag$1(tag)) {
+    if (isReservedTag(tag)) {
         return false;
     }
     tag = tag.toLowerCase();
@@ -4919,7 +4951,7 @@ function isUnknownElement(tag) {
     if (unknownElementCache[tag] != null) {
         return unknownElementCache[tag];
     }
-    var el = document.createElement(tag);
+    const el = document.createElement(tag);
     if (tag.indexOf('-') > -1) {
         // http://stackoverflow.com/a/28210364/1070244
         return (unknownElementCache[tag] =
@@ -4930,14 +4962,14 @@ function isUnknownElement(tag) {
         return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /**
  * Query an element selector if it's not an element already.
  */
-function query$1(el) {
+function query(el) {
     if (typeof el === 'string') {
-        var selected = document.querySelector(el);
+        const selected = document.querySelector(el);
         if (!selected) {
             process.env.NODE_ENV !== 'production' &&
                 warn$2('Cannot find element: ' + el);
@@ -4951,7 +4983,7 @@ function query$1(el) {
 }
 
 function createElement(tagName, vnode) {
-    var elm = document.createElement(tagName);
+    const elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
     }
@@ -5013,46 +5045,43 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref$1 = {
-    create: function create(_, vnode) {
+var ref = {
+    create(_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy(vnode) {
         registerRef(vnode, true);
     },
 };
 function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
+    const key = vnode.data.ref;
     if (!isDef(key))
-        { return; }
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
     if (isRemoval) {
-        if (Array.isArray(refs[key])) {
-            // @ts-expect-error invalid typings
-            remove$2(refs[key], ref);
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
         }
-        else if (refs[key] === ref) {
+        else if (obj === ref) {
             refs[key] = undefined;
         }
     }
     else {
-        // @ts-expect-error invalid typings
         if (vnode.data.refInFor) {
-            if (!Array.isArray(refs[key])) {
+            if (!Array.isArray(obj)) {
                 refs[key] = [ref];
-                // @ts-expect-error invalid typings
             }
-            else if (refs[key].indexOf(ref) < 0) {
-                // @ts-expect-error invalid typings
-                refs[key].push(ref);
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
             }
         }
         else {
@@ -5072,41 +5101,38 @@ function registerRef(vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-var emptyNode = new VNode('', {}, []);
-var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
-        ((a.tag === b.tag &&
-            a.isComment === b.isComment &&
-            isDef(a.data) === isDef(b.data) &&
-            sameInputType(a, b)) ||
-            (isTrue(a.isAsyncPlaceholder) &&
-                a.asyncFactory === b.asyncFactory &&
-                isUndef(b.asyncFactory.error))));
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
 }
 function sameInputType(a, b) {
     if (a.tag !== 'input')
-        { return true; }
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
     return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
 function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
+    let i, key;
+    const map = {};
     for (i = beginIdx; i <= endIdx; ++i) {
         key = children[i].key;
         if (isDef(key))
-            { map[key] = i; }
+            map[key] = i;
     }
     return map;
 }
 function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5128,7 +5154,7 @@ function createPatchFunction(backend) {
         return remove;
     }
     function removeNode(el) {
-        var parent = nodeOps.parentNode(el);
+        const parent = nodeOps.parentNode(el);
         // element may have already been removed due to v-html / v-text
         if (isDef(parent)) {
             nodeOps.removeChild(parent, el);
@@ -5138,14 +5164,14 @@ function createPatchFunction(backend) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
-                config.ignoredElements.some(function (ignore) {
+                config.ignoredElements.some((ignore) => {
                     return isRegExp(ignore)
                         ? ignore.test(vnode.tag)
                         : ignore === vnode.tag;
                 })) &&
             config.isUnknownElement(vnode.tag));
     }
-    var creatingElmInVPre = 0;
+    let creatingElmInVPre = 0;
     function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
         if (isDef(vnode.elm) && isDef(ownerArray)) {
             // This vnode was used in a previous render!
@@ -5159,9 +5185,9 @@ function createPatchFunction(backend) {
         if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
             return;
         }
-        var data = vnode.data;
-        var children = vnode.children;
-        var tag = vnode.tag;
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
         if (isDef(tag)) {
             if (process.env.NODE_ENV !== 'production') {
                 if (data && data.pre) {
@@ -5201,9 +5227,9 @@ function createPatchFunction(backend) {
         }
     }
     function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i = vnode.data;
+        let i = vnode.data;
         if (isDef(i)) {
-            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
             if (isDef((i = i.hook)) && isDef((i = i.init))) {
                 i(vnode, false /* hydrating */);
             }
@@ -5240,12 +5266,12 @@ function createPatchFunction(backend) {
         }
     }
     function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i;
+        let i;
         // hack for #4339: a reactivated component with inner transition
         // does not trigger because the inner node's created hooks are not called
         // again. It's not ideal to involve module-specific logic in here but
         // there doesn't seem to be a better way to do it.
-        var innerNode = vnode;
+        let innerNode = vnode;
         while (innerNode.componentInstance) {
             innerNode = innerNode.componentInstance._vnode;
             if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5277,7 +5303,7 @@ function createPatchFunction(backend) {
             if (process.env.NODE_ENV !== 'production') {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
+            for (let i = 0; i < children.length; ++i) {
                 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
@@ -5292,27 +5318,27 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
             if (isDef(i.create))
-                { i.create(emptyNode, vnode); }
+                i.create(emptyNode, vnode);
             if (isDef(i.insert))
-                { insertedVnodeQueue.push(vnode); }
+                insertedVnodeQueue.push(vnode);
         }
     }
     // set scope id attribute for scoped CSS.
     // this is implemented as a special case to avoid the overhead
     // of going through the normal attribute patching process.
     function setScope(vnode) {
-        var i;
+        let i;
         if (isDef((i = vnode.fnScopeId))) {
             nodeOps.setStyleScope(vnode.elm, i);
         }
         else {
-            var ancestor = vnode;
+            let ancestor = vnode;
             while (ancestor) {
                 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                     nodeOps.setStyleScope(vnode.elm, i);
@@ -5334,13 +5360,13 @@ function createPatchFunction(backend) {
         }
     }
     function invokeDestroyHook(vnode) {
-        var i, j;
-        var data = vnode.data;
+        let i, j;
+        const data = vnode.data;
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                { i(vnode); }
+                i(vnode);
             for (i = 0; i < cbs.destroy.length; ++i)
-                { cbs.destroy[i](vnode); }
+                cbs.destroy[i](vnode);
         }
         if (isDef((i = vnode.children))) {
             for (j = 0; j < vnode.children.length; ++j) {
@@ -5350,7 +5376,7 @@ function createPatchFunction(backend) {
     }
     function removeVnodes(vnodes, startIdx, endIdx) {
         for (; startIdx <= endIdx; ++startIdx) {
-            var ch = vnodes[startIdx];
+            const ch = vnodes[startIdx];
             if (isDef(ch)) {
                 if (isDef(ch.tag)) {
                     removeAndInvokeRemoveHook(ch);
@@ -5365,8 +5391,8 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
-            var listeners = cbs.remove.length + 1;
+            let i;
+            const listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
                 // increase the listeners count
@@ -5397,19 +5423,19 @@ function createPatchFunction(backend) {
         }
     }
     function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        var oldStartIdx = 0;
-        var newStartIdx = 0;
-        var oldEndIdx = oldCh.length - 1;
-        var oldStartVnode = oldCh[0];
-        var oldEndVnode = oldCh[oldEndIdx];
-        var newEndIdx = newCh.length - 1;
-        var newStartVnode = newCh[0];
-        var newEndVnode = newCh[newEndIdx];
-        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
         // removeOnly is a special flag used only by <transition-group>
         // to ensure removed elements stay in correct relative positions
         // during leaving transitions
-        var canMove = !removeOnly;
+        const canMove = !removeOnly;
         if (process.env.NODE_ENV !== 'production') {
             checkDuplicateKeys(newCh);
         }
@@ -5448,7 +5474,7 @@ function createPatchFunction(backend) {
             }
             else {
                 if (isUndef(oldKeyToIdx))
-                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
                 idxInOld = isDef(newStartVnode.key)
                     ? oldKeyToIdx[newStartVnode.key]
                     : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
@@ -5481,13 +5507,13 @@ function createPatchFunction(backend) {
         }
     }
     function checkDuplicateKeys(children) {
-        var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
-            var key = vnode.key;
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn$2(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5496,10 +5522,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                return i;
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5510,7 +5536,7 @@ function createPatchFunction(backend) {
             // clone reused vnode
             vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        var elm = (vnode.elm = oldVnode.elm);
+        const elm = (vnode.elm = oldVnode.elm);
         if (isTrue(oldVnode.isAsyncPlaceholder)) {
             if (isDef(vnode.asyncFactory.resolved)) {
                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5531,30 +5557,30 @@ function createPatchFunction(backend) {
             vnode.componentInstance = oldVnode.componentInstance;
             return;
         }
-        var i;
-        var data = vnode.data;
+        let i;
+        const data = vnode.data;
         if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
             i(oldVnode, vnode);
         }
-        var oldCh = oldVnode.children;
-        var ch = vnode.children;
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
         if (isDef(data) && isPatchable(vnode)) {
             for (i = 0; i < cbs.update.length; ++i)
-                { cbs.update[i](oldVnode, vnode); }
+                cbs.update[i](oldVnode, vnode);
             if (isDef((i = data.hook)) && isDef((i = i.update)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
         if (isUndef(vnode.text)) {
             if (isDef(oldCh) && isDef(ch)) {
                 if (oldCh !== ch)
-                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
             }
             else if (isDef(ch)) {
                 if (process.env.NODE_ENV !== 'production') {
                     checkDuplicateKeys(ch);
                 }
                 if (isDef(oldVnode.text))
-                    { nodeOps.setTextContent(elm, ''); }
+                    nodeOps.setTextContent(elm, '');
                 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
             }
             else if (isDef(oldCh)) {
@@ -5569,7 +5595,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
     }
     function invokeInsertHook(vnode, queue, initial) {
@@ -5579,23 +5605,21 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
+            for (let i = 0; i < queue.length; ++i) {
                 queue[i].data.hook.insert(queue[i]);
             }
         }
     }
-    var hydrationBailed = false;
+    let hydrationBailed = false;
     // list of modules that can skip create hook during hydration because they
     // are already rendered on the client or has no need for initialization
     // Note: style is excluded because it relies on initial clone for future
     // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        let i;
+        const { tag, data, children } = vnode;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5610,7 +5634,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.init)))
-                { i(vnode, true /* hydrating */); }
+                i(vnode, true /* hydrating */);
             if (isDef((i = vnode.componentInstance))) {
                 // child component. it should have hydrated its own tree.
                 initComponent(vnode, insertedVnodeQueue);
@@ -5643,11 +5667,11 @@ function createPatchFunction(backend) {
                     }
                     else {
                         // iterate and compare children lists
-                        var childrenMatch = true;
-                        var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5670,8 +5694,8 @@ function createPatchFunction(backend) {
                 }
             }
             if (isDef(data)) {
-                var fullInvoke = false;
-                for (var key in data) {
+                let fullInvoke = false;
+                for (const key in data) {
                     if (!isRenderedModule(key)) {
                         fullInvoke = true;
                         invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5703,18 +5727,18 @@ function createPatchFunction(backend) {
     return function patch(oldVnode, vnode, hydrating, removeOnly) {
         if (isUndef(vnode)) {
             if (isDef(oldVnode))
-                { invokeDestroyHook(oldVnode); }
+                invokeDestroyHook(oldVnode);
             return;
         }
-        var isInitialPatch = false;
-        var insertedVnodeQueue = [];
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
         if (isUndef(oldVnode)) {
             // empty mount (likely as component), create new root element
             isInitialPatch = true;
             createElm(vnode, insertedVnodeQueue);
         }
         else {
-            var isRealElement = isDef(oldVnode.nodeType);
+            const isRealElement = isDef(oldVnode.nodeType);
             if (!isRealElement && sameVnode(oldVnode, vnode)) {
                 // patch existing root node
                 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5746,8 +5770,8 @@ function createPatchFunction(backend) {
                     oldVnode = emptyNodeAt(oldVnode);
                 }
                 // replacing existing element
-                var oldElm = oldVnode.elm;
-                var parentElm = nodeOps.parentNode(oldElm);
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
                 // create new node
                 createElm(vnode, insertedVnodeQueue, 
                 // extremely rare edge case: do not insert if old element is in a
@@ -5756,25 +5780,25 @@ function createPatchFunction(backend) {
                 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                 // update parent placeholder node element, recursively
                 if (isDef(vnode.parent)) {
-                    var ancestor = vnode.parent;
-                    var patchable = isPatchable(vnode);
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
                             cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
+                            const insert = ancestor.data.hook.insert;
                             if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
                                 }
                             }
                         }
@@ -5812,13 +5836,13 @@ function updateDirectives(oldVnode, vnode) {
     }
 }
 function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
     for (key in newDirs) {
         oldDir = oldDirs[key];
         dir = newDirs[key];
@@ -5840,8 +5864,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithInsert.length) {
-        var callInsert = function () {
-            for (var i = 0; i < dirsWithInsert.length; i++) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
                 callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
@@ -5853,8 +5877,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
                 callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
@@ -5868,14 +5892,14 @@ function _update(oldVnode, vnode) {
         }
     }
 }
-var emptyModifiers = Object.create(null);
+const emptyModifiers = Object.create(null);
 function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
+    const res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
         return res;
     }
-    var i, dir;
+    let i, dir;
     for (i = 0; i < dirs.length; i++) {
         dir = dirs[i];
         if (!dir.modifiers) {
@@ -5889,34 +5913,35 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
+    const fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            // @ts-expect-error should it be any?
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
         }
     }
 }
 
-var baseModules = [ref$1, directives$1];
+var baseModules = [ref, directives$1];
 
 function updateAttrs(oldVnode, vnode) {
-    var opts = vnode.componentOptions;
+    const opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
         return;
     }
     if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
         return;
     }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(attrs.__ob__)) {
         attrs = vnode.data.attrs = extend({}, attrs);
@@ -5992,7 +6017,7 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            const blocker = (e) => {
                 e.stopImmediatePropagation();
                 el.removeEventListener('input', blocker);
             };
@@ -6009,18 +6034,18 @@ var attrs = {
 };
 
 function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticClass) &&
         isUndef(data.class) &&
         (isUndef(oldData) ||
             (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
         return;
     }
-    var cls = genClassForVnode(vnode);
+    let cls = genClassForVnode(vnode);
     // handle transition classes
-    var transitionClass = el._transitionClasses;
+    const transitionClass = el._transitionClasses;
     if (isDef(transitionClass)) {
         cls = concat(cls, stringifyClass(transitionClass));
     }
@@ -6035,35 +6060,35 @@ var klass$1 = {
     update: updateClass,
 };
 
-var validDivisionCharRE = /[\w).+\-_$\]]/;
+const validDivisionCharRE = /[\w).+\-_$\]]/;
 function parseFilters(exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
     for (i = 0; i < exp.length; i++) {
         prev = c;
         c = exp.charCodeAt(i);
         if (inSingle) {
             if (c === 0x27 && prev !== 0x5c)
-                { inSingle = false; }
+                inSingle = false;
         }
         else if (inDouble) {
             if (c === 0x22 && prev !== 0x5c)
-                { inDouble = false; }
+                inDouble = false;
         }
         else if (inTemplateString) {
             if (c === 0x60 && prev !== 0x5c)
-                { inTemplateString = false; }
+                inTemplateString = false;
         }
         else if (inRegex) {
             if (c === 0x2f && prev !== 0x5c)
-                { inRegex = false; }
+                inRegex = false;
         }
         else if (c === 0x7c && // pipe
             exp.charCodeAt(i + 1) !== 0x7c &&
@@ -6112,13 +6137,13 @@ function parseFilters(exp) {
             }
             if (c === 0x2f) {
                 // /
-                var j = i - 1;
-                var p = (void 0);
+                let j = i - 1;
+                let p;
                 // find first non-whitespace prev char
                 for (; j >= 0; j--) {
                     p = exp.charAt(j);
                     if (p !== ' ')
-                        { break; }
+                        break;
                 }
                 if (!p || !validDivisionCharRE.test(p)) {
                     inRegex = true;
@@ -6144,55 +6169,55 @@ function parseFilters(exp) {
     return expression;
 }
 function wrapFilter(exp, filter) {
-    var i = filter.indexOf('(');
+    const i = filter.indexOf('(');
     if (i < 0) {
         // _f: resolveFilter
-        return ("_f(\"" + filter + "\")(" + exp + ")");
+        return `_f("${filter}")(${exp})`;
     }
     else {
-        var name = filter.slice(0, i);
-        var args = filter.slice(i + 1);
-        return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
     }
 }
 
 /* eslint-disable no-unused-vars */
 function baseWarn(msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+    console.error(`[Vue compiler]: ${msg}`);
 }
 /* eslint-enable no-unused-vars */
 function pluckModuleFunction(modules, key) {
-    return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
 }
 function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
     el.plain = false;
 }
 function addAttr(el, name, value, range, dynamic) {
-    var attrs = dynamic
+    const attrs = dynamic
         ? el.dynamicAttrs || (el.dynamicAttrs = [])
         : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
     el.plain = false;
 }
 // add a raw attr (use this in preTransforms)
 function addRawAttr(el, name, value, range) {
     el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+    el.attrsList.push(rangeSetItem({ name, value }, range));
 }
 function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
     (el.directives || (el.directives = [])).push(rangeSetItem({
-        name: name,
-        rawName: rawName,
-        value: value,
-        arg: arg,
-        isDynamicArg: isDynamicArg,
-        modifiers: modifiers,
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
     }, range));
     el.plain = false;
 }
 function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
 }
 function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
     modifiers = modifiers || emptyObject;
@@ -6210,7 +6235,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     // the only target envs that have right/middle clicks.
     if (modifiers.right) {
         if (dynamic) {
-            name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+            name = `(${name})==='click'?'contextmenu':(${name})`;
         }
         else if (name === 'click') {
             name = 'contextmenu';
@@ -6219,7 +6244,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     }
     else if (modifiers.middle) {
         if (dynamic) {
-            name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+            name = `(${name})==='click'?'mouseup':(${name})`;
         }
         else if (name === 'click') {
             name = 'mouseup';
@@ -6239,7 +6264,7 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
         delete modifiers.passive;
         name = prependModifierMarker('&', name, dynamic);
     }
-    var events;
+    let events;
     if (modifiers.native) {
         delete modifiers.native;
         events = el.nativeEvents || (el.nativeEvents = {});
@@ -6247,11 +6272,11 @@ function addHandler(el, name, value, modifiers, important, warn, range, dynamic)
     else {
         events = el.events || (el.events = {});
     }
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
     if (modifiers !== emptyObject) {
         newHandler.modifiers = modifiers;
     }
-    var handlers = events[name];
+    const handlers = events[name];
     /* istanbul ignore if */
     if (Array.isArray(handlers)) {
         important ? handlers.unshift(newHandler) : handlers.push(newHandler);
@@ -6270,12 +6295,12 @@ function getRawBindingAttr(el, name) {
         el.rawAttrsMap[name]);
 }
 function getBindingAttr(el, name, getStatic) {
-    var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
     if (dynamicValue != null) {
         return parseFilters(dynamicValue);
     }
     else if (getStatic !== false) {
-        var staticValue = getAndRemoveAttr(el, name);
+        const staticValue = getAndRemoveAttr(el, name);
         if (staticValue != null) {
             return JSON.stringify(staticValue);
         }
@@ -6286,10 +6311,10 @@ function getBindingAttr(el, name, getStatic) {
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
 function getAndRemoveAttr(el, name, removeFromMap) {
-    var val;
+    let val;
     if ((val = el.attrsMap[name]) != null) {
-        var list = el.attrsList;
-        for (var i = 0, l = list.length; i < l; i++) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
             if (list[i].name === name) {
                 list.splice(i, 1);
                 break;
@@ -6302,9 +6327,9 @@ function getAndRemoveAttr(el, name, removeFromMap) {
     return val;
 }
 function getAndRemoveAttrByRegex(el, name) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-        var attr = list[i];
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
         if (name.test(attr.name)) {
             list.splice(i, 1);
             return attr;
@@ -6327,37 +6352,35 @@ function rangeSetItem(item, range) {
  * Cross-platform code generation for component v-model
  */
 function genComponentModel(el, value, modifiers) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
     if (trim) {
         valueExpression =
-            "(typeof " + baseValueExpression + " === 'string'" +
-                "? " + baseValueExpression + ".trim()" +
-                ": " + baseValueExpression + ")";
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
     }
     if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
+        valueExpression = `_n(${valueExpression})`;
     }
-    var assignment = genAssignmentCode(value, valueExpression);
+    const assignment = genAssignmentCode(value, valueExpression);
     el.model = {
-        value: ("(" + value + ")"),
+        value: `(${value})`,
         expression: JSON.stringify(value),
-        callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
     };
 }
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
 function genAssignmentCode(value, assignment) {
-    var res = parseModel(value);
+    const res = parseModel(value);
     if (res.key === null) {
-        return (value + "=" + assignment);
+        return `${value}=${assignment}`;
     }
     else {
-        return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
     }
 }
 /**
@@ -6374,7 +6397,7 @@ function genAssignmentCode(value, assignment) {
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-var len, str, chr, index, expressionPos, expressionEndPos;
+let len, str, chr, index, expressionPos, expressionEndPos;
 function parseModel(val) {
     // Fix https://github.com/vuejs/vue/pull/7730
     // allow v-model="obj.val " (trailing whitespace)
@@ -6422,7 +6445,7 @@ function isStringStart(chr) {
     return chr === 0x22 || chr === 0x27;
 }
 function parseBracket(chr) {
-    var inBracket = 1;
+    let inBracket = 1;
     expressionPos = index;
     while (!eof()) {
         chr = next();
@@ -6431,9 +6454,9 @@ function parseBracket(chr) {
             continue;
         }
         if (chr === 0x5b)
-            { inBracket++; }
+            inBracket++;
         if (chr === 0x5d)
-            { inBracket--; }
+            inBracket--;
         if (inBracket === 0) {
             expressionEndPos = index;
             break;
@@ -6441,7 +6464,7 @@ function parseBracket(chr) {
     }
 }
 function parseString(chr) {
-    var stringQuote = chr;
+    const stringQuote = chr;
     while (!eof()) {
         chr = next();
         if (chr === stringQuote) {
@@ -6450,10 +6473,127 @@ function parseString(chr) {
     }
 }
 
+let warn$1;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN$1 = '__r';
-var CHECKBOX_RADIO_TOKEN = '__c';
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6461,11 +6601,11 @@ var CHECKBOX_RADIO_TOKEN = '__c';
 // user-attached handlers.
 function normalizeEvents(on) {
     /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN$1])) {
+    if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
-        delete on[RANGE_TOKEN$1];
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
     }
     // This was originally intended to fix #4521 but no longer necessary
     // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6475,11 +6615,11 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target;
+let target;
 function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
+    const _target = target; // save current target element in closure
     return function onceHandler() {
-        var res = handler.apply(null, arguments);
+        const res = handler.apply(null, arguments);
         if (res !== null) {
             remove(event, onceHandler, capture, _target);
         }
@@ -6488,7 +6628,7 @@ function createOnceHandler(event, handler, capture) {
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
-var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
 function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
@@ -6497,9 +6637,9 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
-        //@ts-expect-error
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
         handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
@@ -6520,7 +6660,7 @@ function add(name, handler, capture, passive) {
             }
         };
     }
-    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
 }
 function remove(name, handler, capture, _target) {
     (_target || target).removeEventListener(name, 
@@ -6531,9 +6671,11 @@ function updateDOMListeners(oldVnode, vnode) {
     if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
         return;
     }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
     normalizeEvents(on);
     updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
     target = undefined;
@@ -6541,17 +6683,19 @@ function updateDOMListeners(oldVnode, vnode) {
 var events = {
     create: updateDOMListeners,
     update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-var svgContainer;
+let svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
         return;
     }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(props.__ob__)) {
         props = vnode.data.domProps = extend({}, props);
@@ -6568,9 +6712,9 @@ function updateDOMProps(oldVnode, vnode) {
         // on subsequent patches (#3360)
         if (key === 'textContent' || key === 'innerHTML') {
             if (vnode.children)
-                { vnode.children.length = 0; }
+                vnode.children.length = 0;
             if (cur === oldProps[key])
-                { continue; }
+                continue;
             // #6601 work around Chrome version <= 55 bug where single textNode
             // replaced by innerHTML/textContent retains its parentNode property
             if (elm.childNodes.length === 1) {
@@ -6582,18 +6726,18 @@ function updateDOMProps(oldVnode, vnode) {
             // non-string values will be stringified
             elm._value = cur;
             // avoid resetting cursor position when value is the same
-            var strCur = isUndef(cur) ? '' : String(cur);
+            const strCur = isUndef(cur) ? '' : String(cur);
             if (shouldUpdateValue(elm, strCur)) {
                 elm.value = strCur;
             }
         }
         else if (key === 'innerHTML' &&
-            isSVG$1(elm.tagName) &&
+            isSVG(elm.tagName) &&
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-            var svg = svgContainer.firstChild;
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
             while (elm.firstChild) {
                 elm.removeChild(elm.firstChild);
             }
@@ -6627,7 +6771,7 @@ function shouldUpdateValue(elm, checkVal) {
 function isNotInFocusAndDirty(elm, checkVal) {
     // return true when textbox (.number and .trim) loses focus and its value is
     // not equal to the updated value
-    var notInFocus = true;
+    let notInFocus = true;
     // #6157
     // work around IE bug when accessing document.activeElement in an iframe
     try {
@@ -6637,8 +6781,8 @@ function isNotInFocusAndDirty(elm, checkVal) {
     return notInFocus && elm.value !== checkVal;
 }
 function isDirtyWithModifiers(elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
     if (isDef(modifiers)) {
         if (modifiers.number) {
             return toNumber(value) !== toNumber(newVal);
@@ -6654,13 +6798,13 @@ var domProps = {
     update: updateDOMProps,
 };
 
-var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
     cssText.split(listDelimiter).forEach(function (item) {
         if (item) {
-            var tmp = item.split(propertyDelimiter);
+            const tmp = item.split(propertyDelimiter);
             tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
         }
     });
@@ -6668,7 +6812,7 @@ var parseStyleText = cached(function (cssText) {
 });
 // merge static and dynamic style data on the same vnode
 function normalizeStyleData(data) {
-    var style = normalizeStyleBinding(data.style);
+    const style = normalizeStyleBinding(data.style);
     // static style is pre-processed into an object during compilation
     // and is always a fresh object, so it's safe to merge into it
     return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6688,10 +6832,10 @@ function normalizeStyleBinding(bindingStyle) {
  * so that parent component's style could override it
  */
 function getStyle(vnode, checkChild) {
-    var res = {};
-    var styleData;
+    const res = {};
+    let styleData;
     if (checkChild) {
-        var childNode = vnode;
+        let childNode = vnode;
         while (childNode.componentInstance) {
             childNode = childNode.componentInstance._vnode;
             if (childNode &&
@@ -6704,7 +6848,8 @@ function getStyle(vnode, checkChild) {
     if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
     }
-    var parentNode = vnode;
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6713,9 +6858,9 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-var cssVarRE = /^--/;
-var importantRE = /\s*!important$/;
-var setProp = function (el, name, val) {
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
     /* istanbul ignore if */
     if (cssVarRE.test(name)) {
         el.style.setProperty(name, val);
@@ -6724,12 +6869,12 @@ var setProp = function (el, name, val) {
         el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
     }
     else {
-        var normalizedName = normalize(name);
+        const normalizedName = normalize(name);
         if (Array.isArray(val)) {
             // Support values array created by autoprefixer, e.g.
             // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
             // Set them one by one, and the browser will only set those it can recognize
-            for (var i = 0, len = val.length; i < len; i++) {
+            for (let i = 0, len = val.length; i < len; i++) {
                 el.style[normalizedName] = val[i];
             }
         }
@@ -6738,43 +6883,43 @@ var setProp = function (el, name, val) {
         }
     }
 };
-var vendorNames = ['Webkit', 'Moz', 'ms'];
-var emptyStyle;
-var normalize = cached(function (prop) {
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
     emptyStyle = emptyStyle || document.createElement('div').style;
     prop = camelize(prop);
     if (prop !== 'filter' && prop in emptyStyle) {
         return prop;
     }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
         if (name in emptyStyle) {
             return name;
         }
     }
 });
 function updateStyle(oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticStyle) &&
         isUndef(data.style) &&
         isUndef(oldData.staticStyle) &&
         isUndef(oldData.style)) {
         return;
     }
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
     // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-    var style = normalizeStyleBinding(vnode.data.style) || {};
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
     // store normalized style under a different key for next diff
     // make sure to clone it if it's reactive, since the user likely wants
     // to mutate it.
     vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    var newStyle = getStyle(vnode, true);
+    const newStyle = getStyle(vnode, true);
     for (name in oldStyle) {
         if (isUndef(newStyle[name])) {
             setProp(el, name, '');
@@ -6793,7 +6938,7 @@ var style$1 = {
     update: updateStyle,
 };
 
-var whitespaceRE$1 = /\s+/;
+const whitespaceRE$1 = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6806,14 +6951,14 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
+        const cur = ` ${el.getAttribute('class') || ''} `;
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -6831,7 +6976,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -6841,8 +6986,8 @@ function removeClass(el, cls) {
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -6862,7 +7007,7 @@ function resolveTransition(def) {
     }
     /* istanbul ignore else */
     if (typeof def === 'object') {
-        var res = {};
+        const res = {};
         if (def.css !== false) {
             extend(res, autoCssTransition(def.name || 'v'));
         }
@@ -6873,53 +7018,51 @@ function resolveTransition(def) {
         return autoCssTransition(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+const autoCssTransition = cached((name) => {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
-        // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
         transitionProp = 'WebkitTransition';
         transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
-        // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
         animationProp = 'WebkitAnimation';
         animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+const raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
+    : /* istanbul ignore next */ (fn) => fn();
 function nextFrame(fn) {
-    raf(function () {
+    raf(() => {
         // @ts-expect-error
         raf(fn);
     });
 }
 function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass(el, cls);
@@ -6932,45 +7075,42 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
     if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    var onEnd = function (e) {
+    const onEnd = (e) => {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(function () {
+    setTimeout(() => {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
+const transformRE = /\b(transform|all)(,|$)/;
 function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
+    const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
@@ -7000,12 +7140,12 @@ function getTransitionInfo(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
+        type,
+        timeout,
+        propCount,
+        hasTransform,
     };
 }
 function getTimeout(delays, durations) {
@@ -7013,7 +7153,7 @@ function getTimeout(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map(function (d, i) {
+    return Math.max.apply(null, durations.map((d, i) => {
         return toMs(d) + toMs(delays[i]);
     }));
 }
@@ -7026,13 +7166,13 @@ function toMs(s) {
 }
 
 function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -7040,57 +7180,41 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
         checkDuration(explicitEnterDuration, 'enter', vnode);
     }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
             removeTransitionClass(el, toClass);
             removeTransitionClass(el, activeClass);
@@ -7109,9 +7233,9 @@ function enter(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -7125,7 +7249,7 @@ function enter(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass(el, startClass);
         addTransitionClass(el, activeClass);
-        nextFrame(function () {
+        nextFrame(() => {
             removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -7150,13 +7274,13 @@ function enter(vnode, toggleDisplay) {
     }
 }
 function leave(vnode, rm) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -7164,24 +7288,14 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
         checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
-    var cb = (el._leaveCb = once(function () {
+    const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -7222,7 +7336,7 @@ function leave(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass(el, leaveClass);
             addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
+            nextFrame(() => {
                 removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -7247,11 +7361,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
     }
     else if (isNaN(val)) {
-        warn$2("<transition> explicit " + name + " duration is NaN - " +
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -7269,7 +7383,7 @@ function getHookArgumentsLength(fn) {
         return false;
     }
     // @ts-expect-error
-    var invokerFns = fn.fns;
+    const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -7288,7 +7402,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove(vnode, rm) {
+        remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -7305,8 +7419,8 @@ var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules$1 = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
+const modules$1 = platformModules.concat(baseModules);
+const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -7315,20 +7429,20 @@ var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
 /* istanbul ignore if */
 if (isIE9) {
     // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-        var el = document.activeElement;
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
         // @ts-expect-error
         if (el && el.vmodel) {
             trigger(el, 'input');
         }
     });
 }
-var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', function () {
+                mergeVNodeHook(vnode, 'postpatch', () => {
                     directive.componentUpdated(el, binding, vnode);
                 });
             }
@@ -7354,20 +7468,20 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                 // trigger change event if
                 // no matching option found for at least one value
-                var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                     : binding.value !== binding.oldValue &&
                         hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
@@ -7381,24 +7495,24 @@ function setSelected(el, binding, vm) {
     actuallySetSelected(el, binding, vm);
     /* istanbul ignore if */
     if (isIE || isEdge) {
-        setTimeout(function () {
+        setTimeout(() => {
             actuallySetSelected(el, binding, vm);
         }, 0);
     }
 }
 function actuallySetSelected(el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
+    const value = binding.value;
+    const isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
         process.env.NODE_ENV !== 'production' &&
-            warn$2("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+            warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
                     .call(value)
-                    .slice(8, -1)), vm);
+                    .slice(8, -1)}`, vm);
         return;
     }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
         option = el.options[i];
         if (isMultiple) {
             selected = looseIndexOf(value, getValue(option)) > -1;
@@ -7420,7 +7534,7 @@ function actuallySetSelected(el, binding, vm) {
     }
 }
 function hasNoMatchingOption(value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); });
+    return options.every((o) => !looseEqual(o, value));
 }
 function getValue(option) {
     return '_value' in option ? option._value : option.value;
@@ -7431,12 +7545,12 @@ function onCompositionStart(e) {
 function onCompositionEnd(e) {
     // prevent triggering an input event for no reason
     if (!e.target.composing)
-        { return; }
+        return;
     e.target.composing = false;
     trigger(e.target, 'input');
 }
 function trigger(el, type) {
-    var e = document.createEvent('HTMLEvents');
+    const e = document.createEvent('HTMLEvents');
     e.initEvent(type, true, true);
     el.dispatchEvent(e);
 }
@@ -7449,16 +7563,14 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind(el, { value }, vnode) {
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
         if (value && transition) {
             vnode.data.show = true;
-            enter(vnode, function () {
+            enter(vnode, () => {
                 el.style.display = originalDisplay;
             });
         }
@@ -7466,24 +7578,21 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update(el, { value, oldValue }, vnode) {
         /* istanbul ignore if */
         if (!value === !oldValue)
-            { return; }
+            return;
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
+        const transition = vnode.data && vnode.data.transition;
         if (transition) {
             vnode.data.show = true;
             if (value) {
-                enter(vnode, function () {
+                enter(vnode, () => {
                     el.style.display = el.__vOriginalDisplay;
                 });
             }
             else {
-                leave(vnode, function () {
+                leave(vnode, () => {
                     el.style.display = 'none';
                 });
             }
@@ -7492,7 +7601,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7501,11 +7610,11 @@ var show = {
 
 var platformDirectives = {
     model: directive,
-    show: show,
+    show,
 };
 
 // Provides transition support for a single element/component.
-var transitionProps = {
+const transitionProps = {
     name: String,
     appear: Boolean,
     css: Boolean,
@@ -7525,7 +7634,7 @@ var transitionProps = {
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
 function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
+    const compOptions = vnode && vnode.componentOptions;
     if (compOptions && compOptions.Ctor.options.abstract) {
         return getRealChild(getFirstComponentChild(compOptions.children));
     }
@@ -7534,17 +7643,17 @@ function getRealChild(vnode) {
     }
 }
 function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
+    const data = {};
+    const options = comp.$options;
     // props
-    for (var key in options.propsData) {
+    for (const key in options.propsData) {
         data[key] = comp[key];
     }
     // events.
     // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7566,16 +7675,14 @@ function hasParentTransition(vnode) {
 function isSameChild(child, oldChild) {
     return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-var isVShowDirective = function (d) { return d.name === 'show'; };
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
 var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
-        var children = this.$slots.default;
+    render(h) {
+        let children = this.$slots.default;
         if (!children) {
             return;
         }
@@ -7590,7 +7697,7 @@ var Transition = {
             warn$2('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
-        var mode = this.mode;
+        const mode = this.mode;
         // warn invalid mode
         if (process.env.NODE_ENV !== 'production' &&
             mode &&
@@ -7598,7 +7705,7 @@ var Transition = {
             mode !== 'out-in') {
             warn$2('invalid <transition> mode: ' + mode, this.$parent);
         }
-        var rawChild = children[0];
+        const rawChild = children[0];
         // if this is a component root node and the component's
         // parent container node also has transition, skip.
         if (hasParentTransition(this.$vnode)) {
@@ -7606,7 +7713,7 @@ var Transition = {
         }
         // apply transition data to child
         // use getRealChild() to ignore abstract components e.g. keep-alive
-        var child = getRealChild(rawChild);
+        const child = getRealChild(rawChild);
         /* istanbul ignore if */
         if (!child) {
             return rawChild;
@@ -7617,7 +7724,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        const id = `__transition-${this._uid}-`;
         child.key =
             child.key == null
                 ? child.isComment
@@ -7628,9 +7735,9 @@ var Transition = {
                         ? child.key
                         : id + child.key
                     : child.key;
-        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        var oldRawChild = this._vnode;
-        var oldChild = getRealChild(oldRawChild);
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
         // mark v-show
         // so that the transition module can hand over the control to the directive
         if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7645,14 +7752,14 @@ var Transition = {
                 oldChild.componentInstance._vnode.isComment)) {
             // replace old child transition data with fresh one
             // important for dynamic transitions!
-            var oldData = (oldChild.data.transition = extend({}, data));
+            const oldData = (oldChild.data.transition = extend({}, data));
             // handle transition mode
             if (mode === 'out-in') {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7660,13 +7767,13 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
-                var performLeave = function () {
+                let delayedLeave;
+                const performLeave = () => {
                     delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
                     delayedLeave = leave;
                 });
             }
@@ -7676,67 +7783,63 @@ var Transition = {
 };
 
 // Provides transition support for list items.
-var props = extend({
+const props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
-// @ts-ignore
 delete props.mode;
 var TransitionGroup = {
-    props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
-        var update = this._update;
-        this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            this.__patch__(this._vnode, this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            this._vnode = this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(this, vnode, hydrating);
         };
     },
-    render: function render(h) {
-        var tag = this.tag || this.$vnode.data.tag || 'span';
-        var map = Object.create(null);
-        var prevChildren = (this.prevChildren = this.children);
-        var rawChildren = this.$slots.default || [];
-        var children = (this.children = []);
-        var transitionData = extractTransitionData(this);
-        for (var i = 0; i < rawChildren.length; i++) {
-            var c = rawChildren[i];
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
             if (c.tag) {
-                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                     children.push(c);
                     map[c.key] = c;
                     (c.data || (c.data = {})).transition = transitionData;
                 }
-                else if (process.env.NODE_ENV !== 'production') {
-                    var opts = c.componentOptions;
-                    var name = opts
-                        ? opts.Ctor.options.name || opts.tag || ''
+                else if (process.env.NODE_ENV !== "production") {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
                         : c.tag;
-                    warn$2(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn$2(`<transition-group> children must be keyed: <${name}>`);
                 }
             }
         }
         if (prevChildren) {
-            var kept = [];
-            var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
-                // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
-                // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7744,9 +7847,9 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
-        var children = this.prevChildren;
-        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -7759,13 +7862,12 @@ var TransitionGroup = {
         // assign to this to avoid being removed in tree-shaking
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
-        children.forEach(function (c) {
-            // @ts-ignore
+        children.forEach((c) => {
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
+                const el = c.elm;
+                const s = el.style;
                 addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
                 el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                     if (e && e.target !== el) {
                         return;
@@ -7780,7 +7882,7 @@ var TransitionGroup = {
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -7794,16 +7896,16 @@ var TransitionGroup = {
             // transition at this very moment, we make a clone of it and remove
             // all other transition classes applied to ensure only the move class
             // is applied.
-            var clone = el.cloneNode();
+            const clone = el.cloneNode();
             if (el._transitionClasses) {
-                el._transitionClasses.forEach(function (cls) {
+                el._transitionClasses.forEach((cls) => {
                     removeClass(clone, cls);
                 });
             }
             addClass(clone, moveClass);
-            clone.style.display = 'none';
+            clone.style.display = "none";
             this.$el.appendChild(clone);
-            var info = getTransitionInfo(clone);
+            const info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
             return (this._hasMove = info.hasTransform);
         },
@@ -7811,49 +7913,40 @@ var TransitionGroup = {
 };
 function callPendingCbs(c) {
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._moveCb) {
-        //@ts-ignore
         c.elm._moveCb();
     }
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._enterCb) {
-        //@ts-ignore
         c.elm._enterCb();
     }
 }
 function recordPosition(c) {
-    //@ts-ignore
     c.data.newPos = c.elm.getBoundingClientRect();
 }
 function applyTranslation(c) {
-    //@ts-ignore
-    var oldPos = c.data.pos;
-    //@ts-ignore
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
     if (dx || dy) {
-        //@ts-ignore
         c.data.moved = true;
-        //@ts-ignore
-        var s = c.elm.style;
-        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-        s.transitionDuration = '0s';
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
     }
 }
 
 var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
+    Transition,
+    TransitionGroup,
 };
 
 // install platform specific utils
-Vue.config.mustUseProp = mustUseProp$1;
-Vue.config.isReservedTag = isReservedTag$1;
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
 Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace$1;
+Vue.config.getTagNamespace = getTagNamespace;
 Vue.config.isUnknownElement = isUnknownElement;
 // install platform runtime directives & components
 extend(Vue.options.directives, platformDirectives);
@@ -7862,13 +7955,13 @@ extend(Vue.options.components, platformComponents);
 Vue.prototype.__patch__ = inBrowser ? patch : noop;
 // public mount method
 Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query$1(el) : undefined;
+    el = el && inBrowser ? query(el) : undefined;
     return mountComponent(this, el, hydrating);
 };
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-    setTimeout(function () {
+    setTimeout(() => {
         if (config.devtools) {
             if (devtools) {
                 devtools.emit('init', Vue);
@@ -7885,100 +7978,30 @@ if (inBrowser) {
             config.productionTip !== false &&
             typeof console !== 'undefined') {
             // @ts-expect-error
-            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                "Make sure to turn on production mode when deploying for production.\n" +
-                "See more tips at https://vuejs.org/guide/deployment.html");
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
         }
     }, 0);
 }
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-makeMap('contenteditable,draggable,spellcheck');
-makeMap('events,caret,typing,plaintext-only');
-makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isPreTag = function (tag) { return tag === 'pre'; };
-var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        var selected = document.querySelector(el);
-        if (!selected) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
     return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
 function parseText(text, delimiters) {
     //@ts-expect-error
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
     if (!tagRE.test(text)) {
         return;
     }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = (tagRE.lastIndex = 0);
-    var match, index, tokenValue;
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
     while ((match = tagRE.exec(text))) {
         index = match.index;
         // push text token
@@ -7987,8 +8010,8 @@ function parseText(text, delimiters) {
             tokens.push(JSON.stringify(tokenValue));
         }
         // tag token
-        var exp = parseFilters(match[1].trim());
-        tokens.push(("_s(" + exp + ")"));
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
         rawTokens.push({ '@binding': exp });
         lastIndex = index + match[0].length;
     }
@@ -8003,32 +8026,32 @@ function parseText(text, delimiters) {
 }
 
 function transformNode$1(el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
     if (process.env.NODE_ENV !== 'production' && staticClass) {
-        var res = parseText(staticClass, options.delimiters);
+        const res = parseText(staticClass, options.delimiters);
         if (res) {
-            warn("class=\"" + staticClass + "\": " +
+            warn(`class="${staticClass}": ` +
                 'Interpolation inside attributes has been removed. ' +
                 'Use v-bind or the colon shorthand instead. For example, ' +
                 'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
         }
     }
     if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass);
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
     }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
     if (classBinding) {
         el.classBinding = classBinding;
     }
 }
 function genData$2(el) {
-    var data = '';
+    let data = '';
     if (el.staticClass) {
-        data += "staticClass:" + (el.staticClass) + ",";
+        data += `staticClass:${el.staticClass},`;
     }
     if (el.classBinding) {
-        data += "class:" + (el.classBinding) + ",";
+        data += `class:${el.classBinding},`;
     }
     return data;
 }
@@ -8039,14 +8062,14 @@ var klass = {
 };
 
 function transformNode(el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
     if (staticStyle) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
-            var res = parseText(staticStyle, options.delimiters);
+            const res = parseText(staticStyle, options.delimiters);
             if (res) {
-                warn("style=\"" + staticStyle + "\": " +
+                warn(`style="${staticStyle}": ` +
                     'Interpolation inside attributes has been removed. ' +
                     'Use v-bind or the colon shorthand instead. For example, ' +
                     'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
@@ -8054,44 +8077,44 @@ function transformNode(el, options) {
         }
         el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
     }
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
     if (styleBinding) {
         el.styleBinding = styleBinding;
     }
 }
 function genData$1(el) {
-    var data = '';
+    let data = '';
     if (el.staticStyle) {
-        data += "staticStyle:" + (el.staticStyle) + ",";
+        data += `staticStyle:${el.staticStyle},`;
     }
     if (el.styleBinding) {
-        data += "style:(" + (el.styleBinding) + "),";
+        data += `style:(${el.styleBinding}),`;
     }
     return data;
 }
 var style = {
     staticKeys: ['staticStyle'],
-    transformNode: transformNode,
+    transformNode,
     genData: genData$1,
 };
 
-var decoder;
+let decoder;
 var he = {
-    decode: function decode(html) {
+    decode(html) {
         decoder = decoder || document.createElement('div');
         decoder.innerHTML = html;
         return decoder.textContent;
     },
 };
 
-makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
     'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
     'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
     'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
     'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -8101,21 +8124,21 @@ var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,capti
  * Not type-checking this file because it's mostly vendor code.
  */
 // Regular Expressions for parsing tags and attributes
-var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
-var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-var doctype = /^<!DOCTYPE [^>]+>/i;
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/;
-var conditionalComment = /^<!\[/;
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
 // Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true);
-var reCache = {};
-var decodingMap = {
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
     '&lt;': '<',
     '&gt;': '>',
     '&quot;': '"',
@@ -8124,31 +8147,31 @@ var decodingMap = {
     '&#9;': '\t',
     '&#39;': "'",
 };
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
 function decodeAttr(value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; });
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
 }
 function parseHTML(html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag = options.isUnaryTag || no;
-    var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
     while (html) {
         last = html;
         // Make sure we're not in a plaintext content element like script/style
         if (!lastTag || !isPlainTextElement(lastTag)) {
-            var textEnd = html.indexOf('<');
+            let textEnd = html.indexOf('<');
             if (textEnd === 0) {
                 // Comment:
                 if (comment.test(html)) {
-                    var commentEnd = html.indexOf('-->');
+                    const commentEnd = html.indexOf('-->');
                     if (commentEnd >= 0) {
                         if (options.shouldKeepComment) {
                             options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
@@ -8159,28 +8182,28 @@ function parseHTML(html, options) {
                 }
                 // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
                 if (conditionalComment.test(html)) {
-                    var conditionalEnd = html.indexOf(']>');
+                    const conditionalEnd = html.indexOf(']>');
                     if (conditionalEnd >= 0) {
                         advance(conditionalEnd + 2);
                         continue;
                     }
                 }
                 // Doctype:
-                var doctypeMatch = html.match(doctype);
+                const doctypeMatch = html.match(doctype);
                 if (doctypeMatch) {
                     advance(doctypeMatch[0].length);
                     continue;
                 }
                 // End tag:
-                var endTagMatch = html.match(endTag);
+                const endTagMatch = html.match(endTag);
                 if (endTagMatch) {
-                    var curIndex = index;
+                    const curIndex = index;
                     advance(endTagMatch[0].length);
                     parseEndTag(endTagMatch[1], curIndex, index);
                     continue;
                 }
                 // Start tag:
-                var startTagMatch = parseStartTag();
+                const startTagMatch = parseStartTag();
                 if (startTagMatch) {
                     handleStartTag(startTagMatch);
                     if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
@@ -8189,7 +8212,7 @@ function parseHTML(html, options) {
                     continue;
                 }
             }
-            var text = (void 0), rest = (void 0), next = (void 0);
+            let text, rest, next;
             if (textEnd >= 0) {
                 rest = html.slice(textEnd);
                 while (!endTag.test(rest) &&
@@ -8199,7 +8222,7 @@ function parseHTML(html, options) {
                     // < in plain text, be forgiving and treat it as text
                     next = rest.indexOf('<', 1);
                     if (next < 0)
-                        { break; }
+                        break;
                     textEnd += next;
                     rest = html.slice(textEnd);
                 }
@@ -8216,11 +8239,11 @@ function parseHTML(html, options) {
             }
         }
         else {
-            var endTagLength = 0;
-            var stackedTag = lastTag.toLowerCase();
-            var reStackedTag = reCache[stackedTag] ||
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
                 (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
                 endTagLength = endTag.length;
                 if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                     text = text
@@ -8235,8 +8258,8 @@ function parseHTML(html, options) {
                 }
                 return '';
             });
-            index += html.length - rest$1.length;
-            html = rest$1;
+            index += html.length - rest.length;
+            html = rest;
             parseEndTag(stackedTag, index - endTagLength, index);
         }
         if (html === last) {
@@ -8244,7 +8267,7 @@ function parseHTML(html, options) {
             if (process.env.NODE_ENV !== 'production' &&
                 !stack.length &&
                 options.warn) {
-                options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
                     start: index + html.length,
                 });
             }
@@ -8258,15 +8281,15 @@ function parseHTML(html, options) {
         html = html.substring(n);
     }
     function parseStartTag() {
-        var start = html.match(startTagOpen);
+        const start = html.match(startTagOpen);
         if (start) {
-            var match = {
+            const match = {
                 tagName: start[1],
                 attrs: [],
                 start: index,
             };
             advance(start[0].length);
-            var end, attr;
+            let end, attr;
             while (!(end = html.match(startTagClose)) &&
                 (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                 attr.start = index;
@@ -8283,8 +8306,8 @@ function parseHTML(html, options) {
         }
     }
     function handleStartTag(match) {
-        var tagName = match.tagName;
-        var unarySlash = match.unarySlash;
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
         if (expectHTML) {
             if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                 parseEndTag(lastTag);
@@ -8293,13 +8316,13 @@ function parseHTML(html, options) {
                 parseEndTag(tagName);
             }
         }
-        var unary = isUnaryTag(tagName) || !!unarySlash;
-        var l = match.attrs.length;
-        var attrs = new Array(l);
-        for (var i = 0; i < l; i++) {
-            var args = match.attrs[i];
-            var value = args[3] || args[4] || args[5] || '';
-            var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
                 ? options.shouldDecodeNewlinesForHref
                 : options.shouldDecodeNewlines;
             attrs[i] = {
@@ -8326,11 +8349,11 @@ function parseHTML(html, options) {
         }
     }
     function parseEndTag(tagName, start, end) {
-        var pos, lowerCasedTagName;
+        let pos, lowerCasedTagName;
         if (start == null)
-            { start = index; }
+            start = index;
         if (end == null)
-            { end = index; }
+            end = index;
         // Find the closest opened tag of the same type
         if (tagName) {
             lowerCasedTagName = tagName.toLowerCase();
@@ -8346,11 +8369,11 @@ function parseHTML(html, options) {
         }
         if (pos >= 0) {
             // Close all the open elements, up the stack
-            for (var i = stack.length - 1; i >= pos; i--) {
+            for (let i = stack.length - 1; i >= pos; i--) {
                 if (process.env.NODE_ENV !== 'production' &&
                     (i > pos || !tagName) &&
                     options.warn) {
-                    options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
                         start: stack[i].start,
                         end: stack[i].end,
                     });
@@ -8379,39 +8402,39 @@ function parseHTML(html, options) {
     }
 }
 
-var onRE = /^@|^v-on:/;
-var dirRE = /^v-|^@|^:|^#/;
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-var stripParensRE = /^\(|\)$/g;
-var dynamicArgRE = /^\[.*\]$/;
-var argRE = /:(.*)$/;
-var bindRE = /^:|^\.|^v-bind:/;
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-var slotRE = /^v-slot(:|$)|^#/;
-var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /[ \f\t\r\n]+/g;
-var invalidAttributeRE = /[\s"'<>\/=]/;
-var decodeHTMLCached = cached(he.decode);
-var emptySlotScopeToken = "_empty_";
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he.decode);
+const emptySlotScopeToken = `_empty_`;
 // configurable state
-var warn$1;
-var delimiters;
-var transforms;
-var preTransforms;
-var postTransforms;
-var platformIsPreTag;
-var platformMustUseProp;
-var platformGetTagNamespace;
-var maybeComponent;
+let warn;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
 function createASTElement(tag, attrs, parent) {
     return {
         type: 1,
-        tag: tag,
+        tag,
         attrsList: attrs,
         attrsMap: makeAttrsMap(attrs),
         rawAttrsMap: {},
-        parent: parent,
+        parent,
         children: [],
     };
 }
@@ -8419,31 +8442,31 @@ function createASTElement(tag, attrs, parent) {
  * Convert HTML string to AST.
  */
 function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
+    warn = options.warn || baseWarn;
     platformIsPreTag = options.isPreTag || no;
     platformMustUseProp = options.mustUseProp || no;
     platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!(el.component ||
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
         el.attrsMap[':is'] ||
         el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
     transforms = pluckModuleFunction(options.modules, 'transformNode');
     preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
     postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
     delimiters = options.delimiters;
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
     function warnOnce(msg, range) {
         if (!warned) {
             warned = true;
-            warn$1(msg, range);
+            warn(msg, range);
         }
     }
     function closeElement(element) {
@@ -8464,9 +8487,9 @@ function parse(template, options) {
                 });
             }
             else if (process.env.NODE_ENV !== 'production') {
-                warnOnce("Component template should contain exactly one root element. " +
-                    "If you are using v-if on multiple elements, " +
-                    "use v-else-if to chain them instead.", { start: element.start });
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
             }
         }
         if (currentParent && !element.forbidden) {
@@ -8478,7 +8501,7 @@ function parse(template, options) {
                     // scoped slot
                     // keep it in the children list so that v-else(-if) conditions can
                     // find it as the prev node.
-                    var name = element.slotTarget || '"default"';
+                    const name = element.slotTarget || '"default"';
                     (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                 }
                 currentParent.children.push(element);
@@ -8487,7 +8510,7 @@ function parse(template, options) {
         }
         // final children cleanup
         // filter out scoped slots
-        element.children = element.children.filter(function (c) { return !c.slotScope; });
+        element.children = element.children.filter((c) => !c.slotScope);
         // remove trailing whitespace node again
         trimEndingWhitespace(element);
         // check pre state
@@ -8498,14 +8521,14 @@ function parse(template, options) {
             inPre = false;
         }
         // apply post-transforms
-        for (var i = 0; i < postTransforms.length; i++) {
+        for (let i = 0; i < postTransforms.length; i++) {
             postTransforms[i](element, options);
         }
     }
     function trimEndingWhitespace(el) {
         // remove trailing whitespace node
         if (!inPre) {
-            var lastNode;
+            let lastNode;
             while ((lastNode = el.children[el.children.length - 1]) &&
                 lastNode.type === 3 &&
                 lastNode.text === ' ') {
@@ -8515,7 +8538,7 @@ function parse(template, options) {
     }
     function checkRootConstraints(el) {
         if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
                 'contain multiple nodes.', { start: el.start });
         }
         if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8524,7 +8547,7 @@ function parse(template, options) {
         }
     }
     parseHTML(template, {
-        warn: warn$1,
+        warn,
         expectHTML: options.expectHTML,
         isUnaryTag: options.isUnaryTag,
         canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8532,33 +8555,33 @@ function parse(template, options) {
         shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
         shouldKeepComment: options.comments,
         outputSourceRange: options.outputSourceRange,
-        start: function start(tag, attrs, unary, start$1, end) {
+        start(tag, attrs, unary, start, end) {
             // check namespace.
             // inherit parent ns if there is one
-            var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
             // handle IE svg bug
             /* istanbul ignore if */
             if (isIE && ns === 'svg') {
                 attrs = guardIESVGBug(attrs);
             }
-            var element = createASTElement(tag, attrs, currentParent);
+            let element = createASTElement(tag, attrs, currentParent);
             if (ns) {
                 element.ns = ns;
             }
             if (process.env.NODE_ENV !== 'production') {
                 if (options.outputSourceRange) {
-                    element.start = start$1;
+                    element.start = start;
                     element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
                         cumulated[attr.name] = attr;
                         return cumulated;
                     }, {});
                 }
-                attrs.forEach(function (attr) {
+                attrs.forEach((attr) => {
                     if (invalidAttributeRE.test(attr.name)) {
-                        warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
-                            "spaces, quotes, <, >, / or =.", {
-                            start: attr.start + attr.name.indexOf("["),
+                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
                             end: attr.start + attr.name.length,
                         });
                     }
@@ -8567,13 +8590,13 @@ function parse(template, options) {
             if (isForbiddenTag(element) && !isServerRendering()) {
                 element.forbidden = true;
                 process.env.NODE_ENV !== 'production' &&
-                    warn$1('Templates should only be responsible for mapping the state to the ' +
+                    warn('Templates should only be responsible for mapping the state to the ' +
                         'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        "<" + tag + ">" +
+                        `<${tag}>` +
                         ', as they will not be parsed.', { start: element.start });
             }
             // apply pre-transforms
-            for (var i = 0; i < preTransforms.length; i++) {
+            for (let i = 0; i < preTransforms.length; i++) {
                 element = preTransforms[i](element, options) || element;
             }
             if (!inVPre) {
@@ -8608,25 +8631,25 @@ function parse(template, options) {
                 closeElement(element);
             }
         },
-        end: function end(tag, start, end$1) {
-            var element = stack[stack.length - 1];
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
             // pop stack
             stack.length -= 1;
             currentParent = stack[stack.length - 1];
             if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end$1;
+                element.end = end;
             }
             closeElement(element);
         },
-        chars: function chars(text, start, end) {
+        chars(text, start, end) {
             if (!currentParent) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
                     }
                     else if ((text = text.trim())) {
-                        warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
-                            start: start,
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
                         });
                     }
                 }
@@ -8639,7 +8662,7 @@ function parse(template, options) {
                 currentParent.attrsMap.placeholder === text) {
                 return;
             }
-            var children = currentParent.children;
+            const children = currentParent.children;
             if (inPre || text.trim()) {
                 text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
             }
@@ -8665,14 +8688,14 @@ function parse(template, options) {
                     // condense consecutive whitespaces into single space
                     text = text.replace(whitespaceRE, ' ');
                 }
-                var res;
-                var child;
+                let res;
+                let child;
                 if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                     child = {
                         type: 2,
                         expression: res.expression,
                         tokens: res.tokens,
-                        text: text,
+                        text,
                     };
                 }
                 else if (text !== ' ' ||
@@ -8680,7 +8703,7 @@ function parse(template, options) {
                     children[children.length - 1].text !== ' ') {
                     child = {
                         type: 3,
-                        text: text,
+                        text,
                     };
                 }
                 if (child) {
@@ -8693,13 +8716,13 @@ function parse(template, options) {
                 }
             }
         },
-        comment: function comment(text, start, end) {
+        comment(text, start, end) {
             // adding anything as a sibling to the root node is forbidden
             // comments should still be allowed, but ignored
             if (currentParent) {
-                var child = {
+                const child = {
                     type: 3,
-                    text: text,
+                    text,
                     isComment: true,
                 };
                 if (process.env.NODE_ENV !== 'production' &&
@@ -8719,11 +8742,11 @@ function processPre(el) {
     }
 }
 function processRawAttrs(el) {
-    var list = el.attrsList;
-    var len = list.length;
+    const list = el.attrsList;
+    const len = list.length;
     if (len) {
-        var attrs = (el.attrs = new Array(len));
-        for (var i = 0; i < len; i++) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
             attrs[i] = {
                 name: list[i].name,
                 value: JSON.stringify(list[i].value),
@@ -8749,28 +8772,28 @@ function processElement(element, options) {
     processSlotContent(element);
     processSlotOutlet(element);
     processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
+    for (let i = 0; i < transforms.length; i++) {
         element = transforms[i](element, options) || element;
     }
     processAttrs(element);
     return element;
 }
 function processKey(el) {
-    var exp = getBindingAttr(el, 'key');
+    const exp = getBindingAttr(el, 'key');
     if (exp) {
         if (process.env.NODE_ENV !== 'production') {
             if (el.tag === 'template') {
-                warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
             }
             if (el.for) {
-                var iterator = el.iterator2 || el.iterator1;
-                var parent = el.parent;
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
                 if (iterator &&
                     iterator === exp &&
                     parent &&
                     parent.tag === 'transition-group') {
-                    warn$1("Do not use v-for index as key on <transition-group> children, " +
-                        "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                    warn(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
                 }
             }
         }
@@ -8778,32 +8801,32 @@ function processKey(el) {
     }
 }
 function processRef(el) {
-    var ref = getBindingAttr(el, 'ref');
+    const ref = getBindingAttr(el, 'ref');
     if (ref) {
         el.ref = ref;
         el.refInFor = checkInFor(el);
     }
 }
 function processFor(el) {
-    var exp;
+    let exp;
     if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        var res = parseFor(exp);
+        const res = parseFor(exp);
         if (res) {
             extend(el, res);
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
         }
     }
 }
 function parseFor(exp) {
-    var inMatch = exp.match(forAliasRE);
+    const inMatch = exp.match(forAliasRE);
     if (!inMatch)
-        { return; }
-    var res = {};
+        return;
+    const res = {};
     res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
     if (iteratorMatch) {
         res.alias = alias.replace(forIteratorRE, '').trim();
         res.iterator1 = iteratorMatch[1].trim();
@@ -8817,7 +8840,7 @@ function parseFor(exp) {
     return res;
 }
 function processIf(el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
+    const exp = getAndRemoveAttr(el, 'v-if');
     if (exp) {
         el.if = exp;
         addIfCondition(el, {
@@ -8829,14 +8852,14 @@ function processIf(el) {
         if (getAndRemoveAttr(el, 'v-else') != null) {
             el.else = true;
         }
-        var elseif = getAndRemoveAttr(el, 'v-else-if');
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
         if (elseif) {
             el.elseif = elseif;
         }
     }
 }
 function processIfConditions(el, parent) {
-    var prev = findPrevElement(parent.children);
+    const prev = findPrevElement(parent.children);
     if (prev && prev.if) {
         addIfCondition(prev, {
             exp: el.elseif,
@@ -8844,20 +8867,20 @@ function processIfConditions(el, parent) {
         });
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-            "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
     }
 }
 function findPrevElement(children) {
-    var i = children.length;
+    let i = children.length;
     while (i--) {
         if (children[i].type === 1) {
             return children[i];
         }
         else {
             if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-                    "will be ignored.", children[i]);
+                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
             }
             children.pop();
         }
@@ -8870,7 +8893,7 @@ function addIfCondition(el, condition) {
     el.ifConditions.push(condition);
 }
 function processOnce(el) {
-    var once = getAndRemoveAttr(el, 'v-once');
+    const once = getAndRemoveAttr(el, 'v-once');
     if (once != null) {
         el.once = true;
     }
@@ -8878,29 +8901,29 @@ function processOnce(el) {
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
 function processSlotContent(el) {
-    var slotScope;
+    let slotScope;
     if (el.tag === 'template') {
         slotScope = getAndRemoveAttr(el, 'scope');
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
-                "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-                "can also be used on plain elements in addition to <template> to " +
-                "denote scoped slots.", el.rawAttrsMap['scope'], true);
+            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
         }
         el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
     }
     else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-                "(v-for takes higher priority). Use a wrapper <template> for the " +
-                "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
         }
         el.slotScope = slotScope;
     }
     // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
+    const slotTarget = getBindingAttr(el, 'slot');
     if (slotTarget) {
         el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
         el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
@@ -8914,20 +8937,18 @@ function processSlotContent(el) {
     {
         if (el.tag === 'template') {
             // v-slot on <template>
-            var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
             if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (el.slotTarget || el.slotScope) {
-                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1("<template v-slot> can only appear at the root level inside " +
-                            "the receiving component", el);
+                        warn(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
                     }
                 }
-                var ref = getSlotName(slotBinding);
-                var name = ref.name;
-                var dynamic = ref.dynamic;
+                const { name, dynamic } = getSlotName(slotBinding);
                 el.slotTarget = name;
                 el.slotTargetDynamic = dynamic;
                 el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
@@ -8935,35 +8956,33 @@ function processSlotContent(el) {
         }
         else {
             // v-slot on component, denotes default slot
-            var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding$1) {
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
                 if (process.env.NODE_ENV !== 'production') {
                     if (!maybeComponent(el)) {
-                        warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
                     }
                     if (el.slotScope || el.slotTarget) {
-                        warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                     }
                     if (el.scopedSlots) {
-                        warn$1("To avoid scope ambiguity, the default slot should also use " +
-                            "<template> syntax when there are other named slots.", slotBinding$1);
+                        warn(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
                     }
                 }
                 // add the component's children to its default slot
-                var slots = el.scopedSlots || (el.scopedSlots = {});
-                var ref$1 = getSlotName(slotBinding$1);
-                var name$1 = ref$1.name;
-                var dynamic$1 = ref$1.dynamic;
-                var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name$1;
-                slotContainer.slotTargetDynamic = dynamic$1;
-                slotContainer.children = el.children.filter(function (c) {
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
                     if (!c.slotScope) {
                         c.parent = slotContainer;
                         return true;
                     }
                 });
-                slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
                 // remove children as they are returned from scopedSlots now
                 el.children = [];
                 // mark el non-plain so data gets generated
@@ -8973,34 +8992,34 @@ function processSlotContent(el) {
     }
 }
 function getSlotName(binding) {
-    var name = binding.name.replace(slotRE, '');
+    let name = binding.name.replace(slotRE, '');
     if (!name) {
         if (binding.name[0] !== '#') {
             name = 'default';
         }
         else if (process.env.NODE_ENV !== 'production') {
-            warn$1("v-slot shorthand syntax requires a slot name.", binding);
+            warn(`v-slot shorthand syntax requires a slot name.`, binding);
         }
     }
     return dynamicArgRE.test(name)
         ? // dynamic [name]
             { name: name.slice(1, -1), dynamic: true }
         : // static name
-            { name: ("\"" + name + "\""), dynamic: false };
+            { name: `"${name}"`, dynamic: false };
 }
 // handle <slot/> outlets
 function processSlotOutlet(el) {
     if (el.tag === 'slot') {
         el.slotName = getBindingAttr(el, 'name');
         if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn$1("`key` does not work on <slot> because slots are abstract outlets " +
-                "and can possibly expand into multiple elements. " +
-                "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
         }
     }
 }
 function processComponent(el) {
-    var binding;
+    let binding;
     if ((binding = getBindingAttr(el, 'is'))) {
         el.component = binding;
     }
@@ -9009,8 +9028,8 @@ function processComponent(el) {
     }
 }
 function processAttrs(el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
     for (i = 0, l = list.length; i < l; i++) {
         name = rawName = list[i].name;
         value = list[i].value;
@@ -9033,28 +9052,28 @@ function processAttrs(el) {
                 }
                 if (process.env.NODE_ENV !== 'production' &&
                     value.trim().length === 0) {
-                    warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
                 }
                 if (modifiers) {
                     if (modifiers.prop && !isDynamic) {
                         name = camelize(name);
                         if (name === 'innerHtml')
-                            { name = 'innerHTML'; }
+                            name = 'innerHTML';
                     }
                     if (modifiers.camel && !isDynamic) {
                         name = camelize(name);
                     }
                     if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, "$event");
+                        syncGen = genAssignmentCode(value, `$event`);
                         if (!isDynamic) {
-                            addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
                             if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
                             }
                         }
                         else {
                             // handler w/ dynamic event name
-                            addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
                             );
                         }
                     }
@@ -9074,14 +9093,14 @@ function processAttrs(el) {
                 if (isDynamic) {
                     name = name.slice(1, -1);
                 }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
             }
             else {
                 // normal directives
                 name = name.replace(dirRE, '');
                 // parse arg
-                var argMatch = name.match(argRE);
-                var arg = argMatch && argMatch[1];
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
                 isDynamic = false;
                 if (arg) {
                     name = name.slice(0, -(arg.length + 1));
@@ -9099,9 +9118,9 @@ function processAttrs(el) {
         else {
             // literal attribute
             if (process.env.NODE_ENV !== 'production') {
-                var res = parseText(value, delimiters);
+                const res = parseText(value, delimiters);
                 if (res) {
-                    warn$1(name + "=\"" + value + "\": " +
+                    warn(`${name}="${value}": ` +
                         'Interpolation inside attributes has been removed. ' +
                         'Use v-bind or the colon shorthand instead. For example, ' +
                         'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9119,7 +9138,7 @@ function processAttrs(el) {
     }
 }
 function checkInFor(el) {
-    var parent = el;
+    let parent = el;
     while (parent) {
         if (parent.for !== undefined) {
             return true;
@@ -9129,23 +9148,23 @@ function checkInFor(el) {
     return false;
 }
 function parseModifiers(name) {
-    var match = name.match(modifierRE);
+    const match = name.match(modifierRE);
     if (match) {
-        var ret = {};
-        match.forEach(function (m) {
+        const ret = {};
+        match.forEach((m) => {
             ret[m.slice(1)] = true;
         });
         return ret;
     }
 }
 function makeAttrsMap(attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
         if (process.env.NODE_ENV !== 'production' &&
             map[attrs[i].name] &&
             !isIE &&
             !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
         }
         map[attrs[i].name] = attrs[i].value;
     }
@@ -9160,13 +9179,13 @@ function isForbiddenTag(el) {
         (el.tag === 'script' &&
             (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-var ieNSBug = /^xmlns:NS\d+/;
-var ieNSPrefix = /^NS\d+:/;
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
 /* istanbul ignore next */
 function guardIESVGBug(attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-        var attr = attrs[i];
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
         if (!ieNSBug.test(attr.name)) {
             attr.name = attr.name.replace(ieNSPrefix, '');
             res.push(attr);
@@ -9175,14 +9194,14 @@ function guardIESVGBug(attrs) {
     return res;
 }
 function checkForAliasModel(el, value) {
-    var _el = el;
+    let _el = el;
     while (_el) {
         if (_el.for && _el.alias === value) {
-            warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-                "You are binding v-model directly to a v-for iteration alias. " +
-                "This will not be able to modify the v-for source array because " +
-                "writing to the alias is like modifying a function local variable. " +
-                "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+            warn(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
         }
         _el = _el.parent;
     }
@@ -9199,45 +9218,45 @@ function checkForAliasModel(el, value) {
  */
 function preTransformNode(el, options) {
     if (el.tag === 'input') {
-        var map = el.attrsMap;
+        const map = el.attrsMap;
         if (!map['v-model']) {
             return;
         }
-        var typeBinding;
+        let typeBinding;
         if (map[':type'] || map['v-bind:type']) {
             typeBinding = getBindingAttr(el, 'type');
         }
         if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = "(" + (map['v-bind']) + ").type";
+            typeBinding = `(${map['v-bind']}).type`;
         }
         if (typeBinding) {
-            var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-            var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
             // 1. checkbox
-            var branch0 = cloneASTElement(el);
+            const branch0 = cloneASTElement(el);
             // process for on the main node
             processFor(branch0);
             addRawAttr(branch0, 'type', 'checkbox');
             processElement(branch0, options);
             branch0.processed = true; // prevent it from double-processed
-            branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
             addIfCondition(branch0, {
                 exp: branch0.if,
                 block: branch0,
             });
             // 2. add radio else-if condition
-            var branch1 = cloneASTElement(el);
+            const branch1 = cloneASTElement(el);
             getAndRemoveAttr(branch1, 'v-for', true);
             addRawAttr(branch1, 'type', 'radio');
             processElement(branch1, options);
             addIfCondition(branch0, {
-                exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
                 block: branch1,
             });
             // 3. other
-            var branch2 = cloneASTElement(el);
+            const branch2 = cloneASTElement(el);
             getAndRemoveAttr(branch2, 'v-for', true);
             addRawAttr(branch2, ':type', typeBinding);
             processElement(branch2, options);
@@ -9258,184 +9277,46 @@ function preTransformNode(el, options) {
 function cloneASTElement(el) {
     return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-var model$1 = {
-    preTransformNode: preTransformNode,
+var model = {
+    preTransformNode,
 };
 
-var modules = [klass, style, model$1];
-
-var warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-            "v-model is not supported on this element type. " +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', "Array.isArray(" + value + ")" +
-        "?_i(" + value + "," + valueBinding + ")>-1" +
-        (trueValueBinding === 'true'
-            ? (":(" + value + ")")
-            : (":_q(" + value + "," + trueValueBinding + ")")));
-    addHandler(el, 'change', "var $$a=" + value + "," +
-        '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-        'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-        '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-        "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-        ".call($event.target.options,function(o){return o.selected})" +
-        ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-        "return " + (number ? '_n(val)' : 'val') + "})";
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value$1 && !typeBinding) {
-            var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    var valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-        valueExpression = "_n(" + valueExpression + ")";
-    }
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = "if($event.target.composing)return;" + code;
-    }
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
+var modules = [klass, style, model];
 
 function text(el, dir) {
     if (dir.value) {
-        addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
     }
 }
 
 function html(el, dir) {
     if (dir.value) {
-        addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
     }
 }
 
 var directives = {
-    model: model,
-    text: text,
-    html: html,
+    model: model$1,
+    text,
+    html,
 };
 
-var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-var baseOptions = {
+const baseOptions = {
     expectHTML: true,
-    modules: modules,
-    directives: directives,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    // @ts-ignore
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
     staticKeys: genStaticKeys$1(modules),
 };
 
-var isStaticKey;
-var isPlatformReservedTag;
-var genStaticKeysCached = cached(genStaticKeys);
+let isStaticKey;
+let isPlatformReservedTag;
+const genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -9449,7 +9330,7 @@ var genStaticKeysCached = cached(genStaticKeys);
  */
 function optimize(root, options) {
     if (!root)
-        { return; }
+        return;
     isStaticKey = genStaticKeysCached(options.staticKeys || '');
     isPlatformReservedTag = options.isReservedTag || no;
     // first pass: mark all non-static nodes.
@@ -9472,16 +9353,16 @@ function markStatic(node) {
             node.attrsMap['inline-template'] == null) {
             return;
         }
-        for (var i = 0, l = node.children.length; i < l; i++) {
-            var child = node.children[i];
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
             markStatic(child);
             if (!child.static) {
                 node.static = false;
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                var block = node.ifConditions[i$1].block;
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
                 markStatic(block);
                 if (!block.static) {
                     node.static = false;
@@ -9508,13 +9389,13 @@ function markStaticRoots(node, isInFor) {
             node.staticRoot = false;
         }
         if (node.children) {
-            for (var i = 0, l = node.children.length; i < l; i++) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
                 markStaticRoots(node.children[i], isInFor || !!node.for);
             }
         }
         if (node.ifConditions) {
-            for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                markStaticRoots(node.ifConditions[i$1].block, isInFor);
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
             }
         }
     }
@@ -9550,11 +9431,11 @@ function isDirectChildOfTemplateFor(node) {
     return false;
 }
 
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-var fnInvokeRE = /\([^)]*?\);*$/;
-var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
 // KeyboardEvent.keyCode aliases
-var keyCodes = {
+const keyCodes = {
     esc: 27,
     tab: 9,
     enter: 13,
@@ -9566,7 +9447,7 @@ var keyCodes = {
     delete: [8, 46],
 };
 // KeyboardEvent.key aliases
-var keyNames = {
+const keyNames = {
     // #7880: IE11 and Edge use `Esc` for Escape key name.
     esc: ['Esc', 'Escape'],
     tab: 'Tab',
@@ -9584,36 +9465,36 @@ var keyNames = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-var modifierCode = {
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
     stop: '$event.stopPropagation();',
     prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2"),
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
 };
 function genHandlers(events, isNative) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-        var handlerCode = genHandler(events[name]);
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
         //@ts-expect-error
         if (events[name] && events[name].dynamic) {
-            dynamicHandlers += name + "," + handlerCode + ",";
+            dynamicHandlers += `${name},${handlerCode},`;
         }
         else {
-            staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+            staticHandlers += `"${name}":${handlerCode},`;
         }
     }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
     if (dynamicHandlers) {
-        return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
     }
     else {
         return prefix + staticHandlers;
@@ -9624,22 +9505,22 @@ function genHandler(handler) {
         return 'function(){}';
     }
     if (Array.isArray(handler)) {
-        return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
     }
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
     if (!handler.modifiers) {
         if (isMethodPath || isFunctionExpression) {
             return handler.value;
         }
-        return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
     }
     else {
-        var code = '';
-        var genModifierCode = '';
-        var keys = [];
-        for (var key in handler.modifiers) {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
             if (modifierCode[key]) {
                 genModifierCode += modifierCode[key];
                 // left/right
@@ -9648,10 +9529,10 @@ function genHandler(handler) {
                 }
             }
             else if (key === 'exact') {
-                var modifiers = handler.modifiers;
+                const modifiers = handler.modifiers;
                 genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                    .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
                     .join('||'));
             }
             else {
@@ -9665,14 +9546,14 @@ function genHandler(handler) {
         if (genModifierCode) {
             code += genModifierCode;
         }
-        var handlerCode = isMethodPath
-            ? ("return " + (handler.value) + ".apply(null, arguments)")
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
             : isFunctionExpression
-                ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                ? `return (${handler.value}).apply(null, arguments)`
                 : isFunctionInvocation
-                    ? ("return " + (handler.value))
+                    ? `return ${handler.value}`
                     : handler.value;
-        return ("function($event){" + code + handlerCode + "}");
+        return `function($event){${code}${handlerCode}}`;
     }
 }
 function genKeyFilter(keys) {
@@ -9680,66 +9561,77 @@ function genKeyFilter(keys) {
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-        (keys.map(genFilterCode).join('&&')) + ")return null;");
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
 }
 function genFilterCode(key) {
-    var keyVal = parseInt(key, 10);
+    const keyVal = parseInt(key, 10);
     if (keyVal) {
-        return ("$event.keyCode!==" + keyVal);
+        return `$event.keyCode!==${keyVal}`;
     }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return ("_k($event.keyCode," +
-        (JSON.stringify(key)) + "," +
-        (JSON.stringify(keyCode)) + "," +
-        "$event.key," +
-        "" + (JSON.stringify(keyName)) +
-        ")");
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
 function on(el, dir) {
     if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn$2("v-on without argument does not support modifiers.");
+        warn$2(`v-on without argument does not support modifiers.`);
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
 function bind(el, dir) {
-    el.wrapData = function (code) {
-        return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
     };
 }
 
 var baseDirectives = {
-    on: on,
-    bind: bind,
+    on,
+    bind,
     cloak: noop,
 };
 
-var CodegenState = function CodegenState(options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-};
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
 function generate(ast, options) {
-    var state = new CodegenState(options);
+    const state = new CodegenState(options);
     // fix #11483, Root level <script> tags should not be rendered.
-    var code = ast
+    const code = ast
         ? ast.tag === 'script'
             ? 'null'
             : genElement(ast, state)
         : '_c("div")';
     return {
-        render: ("with(this){return " + code + "}"),
+        render: `with(this){return ${code}}`,
         staticRenderFns: state.staticRenderFns,
     };
 }
@@ -9767,20 +9659,22 @@ function genElement(el, state) {
     }
     else {
         // component or element
-        var code;
+        let code;
         if (el.component) {
             code = genComponent(el.component, el, state);
         }
         else {
-            var data;
+            let data;
             if (!el.plain || (el.pre && state.maybeComponent(el))) {
                 data = genData(el, state);
             }
-            var children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
         }
         // module transforms
-        for (var i = 0; i < state.transforms.length; i++) {
+        for (let i = 0; i < state.transforms.length; i++) {
             code = state.transforms[i](el, code);
         }
         return code;
@@ -9792,13 +9686,13 @@ function genStatic(el, state) {
     // Some elements (templates) need to behave differently inside of a v-pre
     // node.  All pre nodes are static roots, so we can use this as a location to
     // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
+    const originalPreState = state.pre;
     if (el.pre) {
         state.pre = el.pre;
     }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
     state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
 }
 // v-once
 function genOnce(el, state) {
@@ -9807,8 +9701,8 @@ function genOnce(el, state) {
         return genIf(el, state);
     }
     else if (el.staticInFor) {
-        var key = '';
-        var parent = el.parent;
+        let key = '';
+        let parent = el.parent;
         while (parent) {
             if (parent.for) {
                 key = parent.key;
@@ -9818,10 +9712,10 @@ function genOnce(el, state) {
         }
         if (!key) {
             process.env.NODE_ENV !== 'production' &&
-                state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
             return genElement(el, state);
         }
-        return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
     }
     else {
         return genStatic(el, state);
@@ -9835,12 +9729,12 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     if (!conditions.length) {
         return altEmpty || '_e()';
     }
-    var condition = conditions.shift();
+    const condition = conditions.shift();
     if (condition.exp) {
-        return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
     }
     else {
-        return ("" + (genTernaryExp(condition.block)));
+        return `${genTernaryExp(condition.block)}`;
     }
     // v-if with v-once should generate code like (a)?_m(0):_m(1)
     function genTernaryExp(el) {
@@ -9852,88 +9746,88 @@ function genIfConditions(conditions, state, altGen, altEmpty) {
     }
 }
 function genFor(el, state, altGen, altHelper) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
     if (process.env.NODE_ENV !== 'production' &&
         state.maybeComponent(el) &&
         el.tag !== 'slot' &&
         el.tag !== 'template' &&
         !el.key) {
-        state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-            "v-for should have explicit keys. " +
-            "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
     }
     el.forProcessed = true; // avoid recursion
-    return ((altHelper || '_l') + "((" + exp + ")," +
-        "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
         '})');
 }
 function genData(el, state) {
-    var data = '{';
+    let data = '{';
     // directives first.
     // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
+    const dirs = genDirectives(el, state);
     if (dirs)
-        { data += dirs + ','; }
+        data += dirs + ',';
     // key
     if (el.key) {
-        data += "key:" + (el.key) + ",";
+        data += `key:${el.key},`;
     }
     // ref
     if (el.ref) {
-        data += "ref:" + (el.ref) + ",";
+        data += `ref:${el.ref},`;
     }
     if (el.refInFor) {
-        data += "refInFor:true,";
+        data += `refInFor:true,`;
     }
     // pre
     if (el.pre) {
-        data += "pre:true,";
+        data += `pre:true,`;
     }
     // record original tag name for components using "is" attribute
     if (el.component) {
-        data += "tag:\"" + (el.tag) + "\",";
+        data += `tag:"${el.tag}",`;
     }
     // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
+    for (let i = 0; i < state.dataGenFns.length; i++) {
         data += state.dataGenFns[i](el);
     }
     // attributes
     if (el.attrs) {
-        data += "attrs:" + (genProps(el.attrs)) + ",";
+        data += `attrs:${genProps(el.attrs)},`;
     }
     // DOM props
     if (el.props) {
-        data += "domProps:" + (genProps(el.props)) + ",";
+        data += `domProps:${genProps(el.props)},`;
     }
     // event handlers
     if (el.events) {
-        data += (genHandlers(el.events, false)) + ",";
+        data += `${genHandlers(el.events, false)},`;
     }
     if (el.nativeEvents) {
-        data += (genHandlers(el.nativeEvents, true)) + ",";
+        data += `${genHandlers(el.nativeEvents, true)},`;
     }
     // slot target
     // only for non-scoped slots
     if (el.slotTarget && !el.slotScope) {
-        data += "slot:" + (el.slotTarget) + ",";
+        data += `slot:${el.slotTarget},`;
     }
     // scoped slots
     if (el.scopedSlots) {
-        data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
     }
     // component v-model
     if (el.model) {
-        data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
     }
     // inline-template
     if (el.inlineTemplate) {
-        var inlineTemplate = genInlineTemplate(el, state);
+        const inlineTemplate = genInlineTemplate(el, state);
         if (inlineTemplate) {
-            data += inlineTemplate + ",";
+            data += `${inlineTemplate},`;
         }
     }
     data = data.replace(/,$/, '') + '}';
@@ -9941,7 +9835,7 @@ function genData(el, state) {
     // v-bind with dynamic arguments must be applied using the same v-bind object
     // merge helper so that class/style/mustUseProp attrs are handled correctly.
     if (el.dynamicAttrs) {
-        data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
     }
     // v-bind data wrap
     if (el.wrapData) {
@@ -9954,16 +9848,16 @@ function genData(el, state) {
     return data;
 }
 function genDirectives(el, state) {
-    var dirs = el.directives;
+    const dirs = el.directives;
     if (!dirs)
-        { return; }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
     for (i = 0, l = dirs.length; i < l; i++) {
         dir = dirs[i];
         needRuntime = true;
-        var gen = state.directives[dir.name];
+        const gen = state.directives[dir.name];
         if (gen) {
             // compile-time directive that manipulates AST.
             // returns true if it also needs a runtime counterpart.
@@ -9971,9 +9865,9 @@ function genDirectives(el, state) {
         }
         if (needRuntime) {
             hasRuntime = true;
-            res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
         }
     }
     if (hasRuntime) {
@@ -9981,16 +9875,16 @@ function genDirectives(el, state) {
     }
 }
 function genInlineTemplate(el, state) {
-    var ast = el.children[0];
+    const ast = el.children[0];
     if (process.env.NODE_ENV !== 'production' &&
         (el.children.length !== 1 || ast.type !== 1)) {
         state.warn('Inline-template components must have exactly one child element.', { start: el.start });
     }
     if (ast && ast.type === 1) {
-        var inlineRenderFns = generate(ast, state.options);
-        return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-            .map(function (code) { return ("function(){" + code + "}"); })
-            .join(',')) + "]}");
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
     }
 }
 function genScopedSlots(el, slots, state) {
@@ -9998,9 +9892,9 @@ function genScopedSlots(el, slots, state) {
     // components with only scoped slots to skip forced updates from parent.
     // but in some cases we have to bail-out of this optimization
     // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for ||
-        Object.keys(slots).some(function (key) {
-            var slot = slots[key];
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
             return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
             );
         });
@@ -10008,14 +9902,14 @@ function genScopedSlots(el, slots, state) {
     // it's possible for the same component to be reused but with different
     // compiled slot content. To avoid that, we generate a unique key based on
     // the generated code of all the slot contents.
-    var needsKey = !!el.if;
+    let needsKey = !!el.if;
     // OR when it is inside another scoped slot or v-for (the reactivity may be
     // disconnected due to the intermediate scope variable)
     // #9438, #9506
     // TODO: this can be further optimized by properly analyzing in-scope bindings
     // and skip force updating ones that do not actually use scope variables.
     if (!needsForceUpdate) {
-        var parent = el.parent;
+        let parent = el.parent;
         while (parent) {
             if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
                 parent.for) {
@@ -10028,14 +9922,14 @@ function genScopedSlots(el, slots, state) {
             parent = parent.parent;
         }
     }
-    var generatedSlots = Object.keys(slots)
-        .map(function (key) { return genScopedSlot(slots[key], state); })
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
         .join(',');
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
 }
 function hash(str) {
-    var hash = 5381;
-    var i = str.length;
+    let hash = 5381;
+    let i = str.length;
     while (i) {
         hash = (hash * 33) ^ str.charCodeAt(--i);
     }
@@ -10051,45 +9945,45 @@ function containsSlotChild(el) {
     return false;
 }
 function genScopedSlot(el, state) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
+    const isLegacySyntax = el.attrsMap['slot-scope'];
     if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, "null");
+        return genIf(el, state, genScopedSlot, `null`);
     }
     if (el.for && !el.forProcessed) {
         return genFor(el, state, genScopedSlot);
     }
-    var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-        "return " + (el.tag === 'template'
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
             ? el.if && isLegacySyntax
-                ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
                 : genChildren(el, state) || 'undefined'
-            : genElement(el, state)) + "}";
+            : genElement(el, state)}}`;
     // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
 }
 function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    var children = el.children;
+    const children = el.children;
     if (children.length) {
-        var el$1 = children[0];
+        const el = children[0];
         // optimize single v-for
         if (children.length === 1 &&
-            el$1.for &&
-            el$1.tag !== 'template' &&
-            el$1.tag !== 'slot') {
-            var normalizationType = checkSkip
-                ? state.maybeComponent(el$1)
-                    ? ",1"
-                    : ",0"
-                : "";
-            return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
-        }
-        var normalizationType$1 = checkSkip
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
             ? getNormalizationType(children, state.maybeComponent)
             : 0;
-        var gen = altGenNode || genNode;
-        return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
     }
 }
 // determine the normalization needed for the children array.
@@ -10097,20 +9991,20 @@ function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
 function getNormalizationType(children, maybeComponent) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-        var el = children[i];
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
         if (el.type !== 1) {
             continue;
         }
         if (needsNormalization(el) ||
             (el.ifConditions &&
-                el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
             res = 2;
             break;
         }
         if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
             res = 1;
         }
     }
@@ -10131,58 +10025,58 @@ function genNode(node, state) {
     }
 }
 function genText(text) {
-    return ("_v(" + (text.type === 2
+    return `_v(${text.type === 2
         ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
 }
 function genComment(comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")");
+    return `_e(${JSON.stringify(comment.text)})`;
 }
 function genSlot(el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? ("," + children) : '');
-    var attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
             // slot props are camelized
             name: camelize(attr.name),
             value: attr.value,
-            dynamic: attr.dynamic,
-        }); }))
+            dynamic: attr.dynamic
+        })))
         : null;
-    var bind = el.attrsMap['v-bind'];
+    const bind = el.attrsMap['v-bind'];
     if ((attrs || bind) && !children) {
-        res += ",null";
+        res += `,null`;
     }
     if (attrs) {
-        res += "," + attrs;
+        res += `,${attrs}`;
     }
     if (bind) {
-        res += (attrs ? '' : ',null') + "," + bind;
+        res += `${attrs ? '' : ',null'},${bind}`;
     }
     return res + ')';
 }
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
 function genComponent(componentName, el, state) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
 }
 function genProps(props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-        var prop = props[i];
-        var value = transformSpecialNewlines(prop.value);
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
         if (prop.dynamic) {
-            dynamicProps += (prop.name) + "," + value + ",";
+            dynamicProps += `${prop.name},${value},`;
         }
         else {
-            staticProps += "\"" + (prop.name) + "\":" + value + ",";
+            staticProps += `"${prop.name}":${value},`;
         }
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+    staticProps = `{${staticProps.slice(0, -1)}}`;
     if (dynamicProps) {
-        return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
     }
     else {
         return staticProps;
@@ -10195,7 +10089,7 @@ function transformSpecialNewlines(text) {
 
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' +
+const prohibitedKeywordRE = new RegExp('\\b' +
     ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
         'super,throw,while,yield,delete,export,import,return,switch,default,' +
         'extends,finally,continue,debugger,function,arguments')
@@ -10203,11 +10097,11 @@ var prohibitedKeywordRE = new RegExp('\\b' +
         .join('\\b|\\b') +
     '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' +
+const unaryOperatorsRE = new RegExp('\\b' +
     'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
     '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
-var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
 // detect problematic expressions in a template
 function detectErrors(ast, warn) {
     if (ast) {
@@ -10216,28 +10110,28 @@ function detectErrors(ast, warn) {
 }
 function checkNode(node, warn) {
     if (node.type === 1) {
-        for (var name in node.attrsMap) {
+        for (const name in node.attrsMap) {
             if (dirRE.test(name)) {
-                var value = node.attrsMap[name];
+                const value = node.attrsMap[name];
                 if (value) {
-                    var range = node.rawAttrsMap[name];
+                    const range = node.rawAttrsMap[name];
                     if (name === 'v-for') {
-                        checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                        checkFor(node, `v-for="${value}"`, warn, range);
                     }
                     else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
                     }
                     else if (onRE.test(name)) {
-                        checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                        checkEvent(value, `${name}="${value}"`, warn, range);
                     }
                     else {
-                        checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                        checkExpression(value, `${name}="${value}"`, warn, range);
                     }
                 }
             }
         }
         if (node.children) {
-            for (var i = 0; i < node.children.length; i++) {
+            for (let i = 0; i < node.children.length; i++) {
                 checkNode(node.children[i], warn);
             }
         }
@@ -10247,11 +10141,11 @@ function checkNode(node, warn) {
     }
 }
 function checkEvent(exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
     if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn("avoid using JavaScript unary operator as property name: " +
-            "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
     }
     checkExpression(exp, text, warn, range);
 }
@@ -10264,29 +10158,29 @@ function checkFor(node, text, warn, range) {
 function checkIdentifier(ident, type, text, warn, range) {
     if (typeof ident === 'string') {
         try {
-            new Function(("var " + ident + "=_"));
+            new Function(`var ${ident}=_`);
         }
         catch (e) {
-            warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
         }
     }
 }
 function checkExpression(exp, text, warn, range) {
     try {
-        new Function(("return " + exp));
+        new Function(`return ${exp}`);
     }
     catch (e) {
-        var keywordMatch = exp
+        const keywordMatch = exp
             .replace(stripStringRE, '')
             .match(prohibitedKeywordRE);
         if (keywordMatch) {
-            warn("avoid using JavaScript keyword as property name: " +
-                "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
         }
         else {
-            warn("invalid expression: " + (e.message) + " in\n\n" +
-                "    " + exp + "\n\n" +
-                "  Raw expression: " + (text.trim()) + "\n", range);
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
         }
     }
 }
@@ -10295,38 +10189,35 @@ function checkFunctionParameterExpression(exp, text, warn, range) {
         new Function(exp, '');
     }
     catch (e) {
-        warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-            "    " + exp + "\n\n" +
-            "  Raw expression: " + (text.trim()) + "\n", range);
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
     }
 }
 
-var range = 2;
-function generateCodeFrame(source, start, end) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
         count += lines[i].length + 1;
         if (count >= start) {
-            for (var j = i - range; j <= i + range || end > count; j++) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
                 if (j < 0 || j >= lines.length)
-                    { continue; }
-                res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-                var lineLength = lines[j].length;
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
                 if (j === i) {
                     // push underline
-                    var pad = start - (count - lineLength) + 1;
-                    var length = end > count ? lineLength - pad : end - start;
-                    res.push("   |  " + repeat(" ", pad) + repeat("^", length));
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
                 }
                 else if (j > i) {
                     if (end > count) {
-                        var length$1 = Math.min(end - count, lineLength);
-                        res.push("   |  " + repeat("^", length$1));
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
                     }
                     count += lineLength + 1;
                 }
@@ -10337,16 +10228,16 @@ function generateCodeFrame(source, start, end) {
     return res.join('\n');
 }
 function repeat(str, n) {
-    var result = '';
+    let result = '';
     if (n > 0) {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             // eslint-disable-line
             if (n & 1)
-                { result += str; }
+                result += str;
             n >>>= 1;
             if (n <= 0)
-                { break; }
+                break;
             str += str;
         }
     }
@@ -10358,15 +10249,15 @@ function createFunction(code, errors) {
         return new Function(code);
     }
     catch (err) {
-        errors.push({ err: err, code: code });
+        errors.push({ err, code });
         return noop;
     }
 }
 function createCompileToFunctionFn(compile) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function compileToFunctions(template, options, vm) {
         options = extend({}, options);
-        var warn = options.warn || warn$2;
+        const warn = options.warn || warn$2;
         delete options.warn;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
@@ -10385,43 +10276,43 @@ function createCompileToFunctionFn(compile) {
             }
         }
         // check cache
-        var key = options.delimiters
+        const key = options.delimiters
             ? String(options.delimiters) + template
             : template;
         if (cache[key]) {
             return cache[key];
         }
         // compile
-        var compiled = compile(template, options);
+        const compiled = compile(template, options);
         // check compilation errors/tips
         if (process.env.NODE_ENV !== 'production') {
             if (compiled.errors && compiled.errors.length) {
                 if (options.outputSourceRange) {
-                    compiled.errors.forEach(function (e) {
-                        warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
                             generateCodeFrame(template, e.start, e.end), vm);
                     });
                 }
                 else {
-                    warn("Error compiling template:\n\n" + template + "\n\n" +
-                        compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
                         '\n', vm);
                 }
             }
             if (compiled.tips && compiled.tips.length) {
                 if (options.outputSourceRange) {
-                    compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
                 }
                 else {
-                    compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                    compiled.tips.forEach((msg) => tip(msg, vm));
                 }
             }
         }
         // turn code into functions
-        var res = {};
-        var fnGenErrors = [];
+        const res = {};
+        const fnGenErrors = [];
         res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
             return createFunction(code, fnGenErrors);
         });
         // check function generation errors.
@@ -10430,14 +10321,9 @@ function createCompileToFunctionFn(compile) {
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production') {
             if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn("Failed to generate render function:\n\n" +
+                warn(`Failed to generate render function:\n\n` +
                     fnGenErrors
-                        .map(function (ref) {
-                            var err = ref.err;
-                            var code = ref.code;
-
-                            return ((err.toString()) + " in\n\n" + code + "\n");
-                })
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
                         .join('\n'), vm);
             }
         }
@@ -10448,19 +10334,19 @@ function createCompileToFunctionFn(compile) {
 function createCompilerCreator(baseCompile) {
     return function createCompiler(baseOptions) {
         function compile(template, options) {
-            var finalOptions = Object.create(baseOptions);
-            var errors = [];
-            var tips = [];
-            var warn = function (msg, range, tip) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
                 (tip ? tips : errors).push(msg);
             };
             if (options) {
                 if (process.env.NODE_ENV !== 'production' &&
                     options.outputSourceRange) {
                     // $flow-disable-line
-                    var leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = function (msg, range, tip) {
-                        var data = { msg: msg };
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
                         if (range) {
                             if (range.start != null) {
                                 data.start = range.start + leadingSpaceLength;
@@ -10481,14 +10367,14 @@ function createCompilerCreator(baseCompile) {
                     finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
                 }
                 // copy other options
-                for (var key in options) {
+                for (const key in options) {
                     if (key !== 'modules' && key !== 'directives') {
                         finalOptions[key] = options[key];
                     }
                 }
             }
             finalOptions.warn = warn;
-            var compiled = baseCompile(template.trim(), finalOptions);
+            const compiled = baseCompile(template.trim(), finalOptions);
             if (process.env.NODE_ENV !== 'production') {
                 detectErrors(compiled.ast, warn);
             }
@@ -10497,7 +10383,7 @@ function createCompilerCreator(baseCompile) {
             return compiled;
         }
         return {
-            compile: compile,
+            compile,
             compileToFunctions: createCompileToFunctionFn(compile),
         };
     };
@@ -10506,60 +10392,59 @@ function createCompilerCreator(baseCompile) {
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    var ast = parse(template.trim(), options);
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
     if (options.optimize !== false) {
         optimize(ast, options);
     }
-    var code = generate(ast, options);
+    const code = generate(ast, options);
     return {
-        ast: ast,
+        ast,
         render: code.render,
         staticRenderFns: code.staticRenderFns,
     };
 });
 
-var ref = createCompiler(baseOptions);
-var compileToFunctions = ref.compileToFunctions;
+const { compile, compileToFunctions } = createCompiler(baseOptions);
 
 // check whether current browser encodes a char inside attribute values
-var div;
+let div;
 function getShouldDecode(href) {
     div = div || document.createElement('div');
-    div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
     return div.innerHTML.indexOf('&#10;') > 0;
 }
 // #3663: IE encodes newlines inside attribute values while other browsers don't
-var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
 // #6828: chrome encodes content in a[href]
-var shouldDecodeNewlinesForHref = inBrowser
+const shouldDecodeNewlinesForHref = inBrowser
     ? getShouldDecode(true)
     : false;
 
-var idToTemplate = cached(function (id) {
-    var el = query(id);
+const idToTemplate = cached((id) => {
+    const el = query(id);
     return el && el.innerHTML;
 });
-var mount = Vue.prototype.$mount;
+const mount = Vue.prototype.$mount;
 Vue.prototype.$mount = function (el, hydrating) {
     el = el && query(el);
     /* istanbul ignore if */
     if (el === document.body || el === document.documentElement) {
         process.env.NODE_ENV !== 'production' &&
-            warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+            warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
         return this;
     }
-    var options = this.$options;
+    const options = this.$options;
     // resolve template/el and convert to render function
     if (!options.render) {
-        var template = options.template;
+        let template = options.template;
         if (template) {
             if (typeof template === 'string') {
                 if (template.charAt(0) === '#') {
                     template = idToTemplate(template);
                     /* istanbul ignore if */
                     if (process.env.NODE_ENV !== 'production' && !template) {
-                        warn$2(("Template element not found or is empty: " + (options.template)), this);
+                        warn$2(`Template element not found or is empty: ${options.template}`, this);
                     }
                 }
             }
@@ -10582,21 +10467,19 @@ Vue.prototype.$mount = function (el, hydrating) {
             if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
                 mark('compile');
             }
-            var ref = compileToFunctions(template, {
+            const { render, staticRenderFns } = compileToFunctions(template, {
                 outputSourceRange: process.env.NODE_ENV !== 'production',
-                shouldDecodeNewlines: shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
                 delimiters: options.delimiters,
                 comments: options.comments,
             }, this);
-            var render = ref.render;
-            var staticRenderFns = ref.staticRenderFns;
             options.render = render;
             options.staticRenderFns = staticRenderFns;
             /* istanbul ignore if */
             if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
                 mark('compile end');
-                measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
             }
         }
     }
@@ -10611,11 +10494,11 @@ function getOuterHTML(el) {
         return el.outerHTML;
     }
     else {
-        var container = document.createElement('div');
+        const container = document.createElement('div');
         container.appendChild(el.cloneNode(true));
         return container.innerHTML;
     }
 }
 Vue.compile = compileToFunctions;
 
-export default Vue;
+export { Vue as default };
diff --git a/dist/vue.js b/dist/vue.js
index 03795d7fe0e..2582d0352dd 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -1,15 +1,15 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
-}(this, (function () { 'use strict';
+})(this, (function () { 'use strict';
 
-  var emptyObject = Object.freeze({});
+  const emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
   function isUndef(v) {
@@ -36,7 +36,7 @@
   }
   /**
    * Quick object check - this is primarily used to tell
-   * Objects from primitive values when we know the value
+   * objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
   function isObject(obj) {
@@ -45,7 +45,7 @@
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
-  var _toString = Object.prototype.toString;
+  const _toString = Object.prototype.toString;
   function toRawType(value) {
       return _toString.call(value).slice(8, -1);
   }
@@ -63,7 +63,7 @@
    * Check if val is a valid array index.
    */
   function isValidArrayIndex(val) {
-      var n = parseFloat(String(val));
+      const n = parseFloat(String(val));
       return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
   function isPromise(val) {
@@ -86,7 +86,7 @@
    * If the conversion fails, return original string.
    */
   function toNumber(val) {
-      var n = parseFloat(val);
+      const n = parseFloat(val);
       return isNaN(n) ? val : n;
   }
   /**
@@ -94,27 +94,27 @@
    * is in that map.
    */
   function makeMap(str, expectsLowerCase) {
-      var map = Object.create(null);
-      var list = str.split(',');
-      for (var i = 0; i < list.length; i++) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
           map[list[i]] = true;
       }
-      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
   }
   /**
    * Check if a tag is a built-in tag.
    */
-  var isBuiltInTag = makeMap('slot,component', true);
+  const isBuiltInTag = makeMap('slot,component', true);
   /**
    * Check if an attribute is a reserved attribute.
    */
-  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
   /**
    * Remove an item from an array.
    */
   function remove$2(arr, item) {
       if (arr.length) {
-          var index = arr.indexOf(item);
+          const index = arr.indexOf(item);
           if (index > -1) {
               return arr.splice(index, 1);
           }
@@ -123,7 +123,7 @@
   /**
    * Check whether an object has the property.
    */
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
   function hasOwn(obj, key) {
       return hasOwnProperty.call(obj, key);
   }
@@ -131,30 +131,30 @@
    * Create a cached version of a pure function.
    */
   function cached(fn) {
-      var cache = Object.create(null);
+      const cache = Object.create(null);
       return function cachedFn(str) {
-          var hit = cache[str];
+          const hit = cache[str];
           return hit || (cache[str] = fn(str));
       };
   }
   /**
    * Camelize a hyphen-delimited string.
    */
-  var camelizeRE = /-(\w)/g;
-  var camelize = cached(function (str) {
-      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
   });
   /**
    * Capitalize a string.
    */
-  var capitalize = cached(function (str) {
+  const capitalize = cached((str) => {
       return str.charAt(0).toUpperCase() + str.slice(1);
   });
   /**
    * Hyphenate a camelCase string.
    */
-  var hyphenateRE = /\B([A-Z])/g;
-  var hyphenate = cached(function (str) {
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
       return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
   /**
@@ -167,7 +167,7 @@
   /* istanbul ignore next */
   function polyfillBind(fn, ctx) {
       function boundFn(a) {
-          var l = arguments.length;
+          const l = arguments.length;
           return l
               ? l > 1
                   ? fn.apply(ctx, arguments)
@@ -181,14 +181,14 @@
       return fn.bind(ctx);
   }
   // @ts-expect-error bind cannot be `undefined`
-  var bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+  const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Convert an Array-like object to a real Array.
    */
   function toArray(list, start) {
       start = start || 0;
-      var i = list.length - start;
-      var ret = new Array(i);
+      let i = list.length - start;
+      const ret = new Array(i);
       while (i--) {
           ret[i] = list[i + start];
       }
@@ -198,7 +198,7 @@
    * Mix properties into target object.
    */
   function extend(to, _from) {
-      for (var key in _from) {
+      for (const key in _from) {
           to[key] = _from[key];
       }
       return to;
@@ -207,8 +207,8 @@
    * Merge an Array of Objects into a single Object.
    */
   function toObject(arr) {
-      var res = {};
-      for (var i = 0; i < arr.length; i++) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
           if (arr[i]) {
               extend(res, arr[i]);
           }
@@ -225,18 +225,18 @@
   /**
    * Always return false.
    */
-  var no = function (a, b, c) { return false; };
+  const no = (a, b, c) => false;
   /* eslint-enable no-unused-vars */
   /**
    * Return the same value.
    */
-  var identity = function (_) { return _; };
+  const identity = (_) => _;
   /**
    * Generate a string containing static keys from compiler modules.
    */
   function genStaticKeys$1(modules) {
       return modules
-          .reduce(function (keys, m) {
+          .reduce((keys, m) => {
           return keys.concat(m.staticKeys || []);
       }, [])
           .join(',');
@@ -247,16 +247,16 @@
    */
   function looseEqual(a, b) {
       if (a === b)
-          { return true; }
-      var isObjectA = isObject(a);
-      var isObjectB = isObject(b);
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
       if (isObjectA && isObjectB) {
           try {
-              var isArrayA = Array.isArray(a);
-              var isArrayB = Array.isArray(b);
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
               if (isArrayA && isArrayB) {
                   return (a.length === b.length &&
-                      a.every(function (e, i) {
+                      a.every((e, i) => {
                           return looseEqual(e, b[i]);
                       }));
               }
@@ -264,10 +264,10 @@
                   return a.getTime() === b.getTime();
               }
               else if (!isArrayA && !isArrayB) {
-                  var keysA = Object.keys(a);
-                  var keysB = Object.keys(b);
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
                   return (keysA.length === keysB.length &&
-                      keysA.every(function (key) {
+                      keysA.every((key) => {
                           return looseEqual(a[key], b[key]);
                       }));
               }
@@ -294,9 +294,9 @@
    * contain an object of the same shape), or -1 if it is not present.
    */
   function looseIndexOf(arr, val) {
-      for (var i = 0; i < arr.length; i++) {
+      for (let i = 0; i < arr.length; i++) {
           if (looseEqual(arr[i], val))
-              { return i; }
+              return i;
       }
       return -1;
   }
@@ -304,7 +304,7 @@
    * Ensure a function is called only once.
    */
   function once(fn) {
-      var called = false;
+      let called = false;
       return function () {
           if (!called) {
               called = true;
@@ -313,9 +313,9 @@
       };
   }
 
-  var SSR_ATTR = 'data-server-rendered';
-  var ASSET_TYPES = ['component', 'directive', 'filter'];
-  var LIFECYCLE_HOOKS = [
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
       'beforeCreate',
       'created',
       'beforeMount',
@@ -327,7 +327,8 @@
       'activated',
       'deactivated',
       'errorCaptured',
-      'serverPrefetch' ];
+      'serverPrefetch',
+  ];
 
   var config = {
       /**
@@ -412,12 +413,12 @@
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
-  var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
   /**
    * Check if a string starts with $ or _
    */
   function isReserved(str) {
-      var c = (str + '').charCodeAt(0);
+      const c = (str + '').charCodeAt(0);
       return c === 0x24 || c === 0x5f;
   }
   /**
@@ -434,16 +435,16 @@
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
   function parsePath(path) {
       if (bailRE.test(path)) {
           return;
       }
-      var segments = path.split('.');
+      const segments = path.split('.');
       return function (obj) {
-          for (var i = 0; i < segments.length; i++) {
+          for (let i = 0; i < segments.length; i++) {
               if (!obj)
-                  { return; }
+                  return;
               obj = obj[segments[i]];
           }
           return obj;
@@ -451,46 +452,41 @@
   }
 
   // can we use __proto__?
-  var hasProto = '__proto__' in {};
+  const hasProto = '__proto__' in {};
   // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined';
-  // @ts-ignore
-  var inWeex = 
-  // @ts-ignore
-  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  // @ts-ignore
-  var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  var isEdge = UA && UA.indexOf('edge/') > 0;
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
   (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   UA && /chrome\/\d+/.test(UA) && !isEdge;
   UA && /phantomjs/.test(UA);
-  var isFF = UA && UA.match(/firefox\/(\d+)/);
+  const isFF = UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
-  // @ts-ignore
-  var nativeWatch = {}.watch;
-  var supportsPassive = false;
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
   if (inBrowser) {
       try {
-          var opts = {};
+          const opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function get() {
+              get() {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
           }); // https://github.com/facebook/flow/issues/285
-          // @ts-ignore
           window.addEventListener('test-passive', null, opts);
       }
       catch (e) { }
   }
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
-  var _isServer;
-  var isServerRendering = function () {
+  let _isServer;
+  const isServerRendering = () => {
       if (_isServer === undefined) {
           /* istanbul ignore if */
           if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -506,104 +502,94 @@
       return _isServer;
   };
   // detect devtools
-  // @ts-ignore TODO decalre this types
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
   /* istanbul ignore next */
   function isNative(Ctor) {
       return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
   }
-  var hasSymbol = typeof Symbol !== 'undefined' &&
+  const hasSymbol = typeof Symbol !== 'undefined' &&
       isNative(Symbol) &&
       typeof Reflect !== 'undefined' &&
       isNative(Reflect.ownKeys);
-  var _Set; // $flow-disable-line
+  let _Set; // $flow-disable-line
   /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
       // use native Set when available.
       _Set = Set;
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
-          function Set() {
-              this.set = Object.create(null);
-          }
-          Set.prototype.has = function has (key) {
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
               return this.set[key] === true;
-          };
-          Set.prototype.add = function add (key) {
+          }
+          add(key) {
               this.set[key] = true;
-          };
-          Set.prototype.clear = function clear () {
+          }
+          clear() {
               this.set = Object.create(null);
-          };
-
-          return Set;
-      }());
+          }
+      };
   }
 
-  var warn$2 = noop;
-  var tip = noop;
-  var generateComponentTrace; // work around flow check
-  var formatComponentName;
+  let warn$2 = noop;
+  let tip = noop;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-      warn$2 = function (msg, vm) {
-          var trace = vm ? generateComponentTrace(vm) : '';
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn$2 = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
           if (config.warnHandler) {
               config.warnHandler.call(null, msg, vm, trace);
           }
           else if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
+              console.error(`[Vue warn]: ${msg}${trace}`);
           }
       };
-      tip = function (msg, vm) {
+      tip = (msg, vm) => {
           if (hasConsole && !config.silent) {
-              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
           }
       };
-      formatComponentName = function (vm, includeFile) {
+      formatComponentName = (vm, includeFile) => {
           if (vm.$root === vm) {
               return '<Root>';
           }
-          var options = 
-          // @ts-ignore
-          typeof vm === 'function' && vm.cid != null
-              ? // @ts-ignore
-                  vm.options
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
               : vm._isVue
-                  ? // @ts-ignore
-                      vm.$options || vm.constructor.options
+                  ? vm.$options || vm.constructor.options
                   : vm;
-          var name = options.name || options._componentTag;
-          var file = options.__file;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
           if (!name && file) {
-              var match = file.match(/([^/\\]+)\.vue$/);
+              const match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
       };
-      var repeat$1 = function (str, n) {
-          var res = '';
+      const repeat = (str, n) => {
+          let res = '';
           while (n) {
               if (n % 2 === 1)
-                  { res += str; }
+                  res += str;
               if (n > 1)
-                  { str += str; }
+                  str += str;
               n >>= 1;
           }
           return res;
       };
-      generateComponentTrace = function (vm) {
-          // @ts-ignore
+      generateComponentTrace = (vm) => {
           if (vm._isVue && vm.$parent) {
-              var tree = [];
-              var currentRecursiveSequence = 0;
+              const tree = [];
+              let currentRecursiveSequence = 0;
               while (vm) {
                   if (tree.length > 0) {
-                      var last = tree[tree.length - 1];
+                      const last = tree[tree.length - 1];
                       if (last.constructor === vm.constructor) {
                           currentRecursiveSequence++;
                           vm = vm.$parent;
@@ -619,55 +605,60 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat$1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                       .join('\n'));
           }
           else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+              return `\n\n(found in ${formatComponentName(vm)})`;
           }
       };
   }
 
-  var uid$2 = 0;
+  let uid$2 = 0;
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep() {
-      this.id = uid$2++;
-      this.subs = [];
-  };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
-  };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove$2(this.subs, sub);
-  };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid$2++;
+          this.subs = [];
       }
-  };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      if (!config.async) {
-          // subs aren't sorted in scheduler if not running async
-          // we need to sort them now to make sure they fire in correct
-          // order
-          subs.sort(function (a, b) { return a.id - b.id; });
-      }
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
+      addSub(sub) {
+          this.subs.push(sub);
       }
-  };
+      removeSub(sub) {
+          remove$2(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          if (!config.async) {
+              // subs aren't sorted in scheduler if not running async
+              // we need to sort them now to make sure they fire in correct
+              // order
+              subs.sort((a, b) => a.id - b.id);
+          }
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
-  var targetStack = [];
+  const targetStack = [];
   function pushTarget(target) {
       targetStack.push(target);
       Dep.target = target;
@@ -677,44 +668,66 @@
       Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-      return this.componentInstance;
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
-  var createEmptyVNode = function (text) {
-      if ( text === void 0 ) text = '';
-
-      var node = new VNode();
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
       node.text = text;
       node.isComment = true;
       return node;
@@ -727,9 +740,7 @@
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
   function cloneVNode(vnode) {
-      var cloned = new VNode(
-      //@ts-expect-error void type not valid here
-      vnode.tag, vnode.data, 
+      const cloned = new VNode(vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
@@ -750,29 +761,27 @@
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-  var arrayProto = Array.prototype;
-  var arrayMethods = Object.create(arrayProto);
-  var methodsToPatch = [
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
       'push',
       'pop',
       'shift',
       'unshift',
       'splice',
       'sort',
-      'reverse' ];
+      'reverse',
+  ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
       // cache original method
-      var original = arrayProto[method];
-      def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
-
-          var result = original.apply(this, args);
-          var ob = this.__ob__;
-          var inserted;
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
           switch (method) {
               case 'push':
               case 'unshift':
@@ -783,19 +792,19 @@
                   break;
           }
           if (inserted)
-              { ob.observeArray(inserted); }
+              ob.observeArray(inserted);
           // notify change
           ob.dep.notify();
           return result;
       });
   });
 
-  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
-  var shouldObserve = true;
+  let shouldObserve = true;
   function toggleObserving(value) {
       shouldObserve = value;
   }
@@ -805,43 +814,48 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
           }
           else {
-              copyAugment(value, arrayMethods, arrayKeys);
+              this.walk(value);
           }
-          this.observeArray(value);
       }
-      else {
-          this.walk(value);
-      }
-  };
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive(obj, keys[i]);
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
       }
-  };
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
       }
-  };
+  }
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -858,8 +872,8 @@
    */
   /* istanbul ignore next */
   function copyAugment(target, src, keys) {
-      for (var i = 0, l = keys.length; i < l; i++) {
-          var key = keys[i];
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
           def(target, key, src[key]);
       }
   }
@@ -872,7 +886,7 @@
       if (!isObject(value) || value instanceof VNode) {
           return;
       }
-      var ob;
+      let ob;
       if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
           ob = value.__ob__;
       }
@@ -892,23 +906,23 @@
    * Define a reactive property on an Object.
    */
   function defineReactive(obj, key, val, customSetter, shallow) {
-      var dep = new Dep();
-      var property = Object.getOwnPropertyDescriptor(obj, key);
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
           return;
       }
       // cater for pre-defined getter/setters
-      var getter = property && property.get;
-      var setter = property && property.set;
+      const getter = property && property.get;
+      const setter = property && property.set;
       if ((!getter || setter) && arguments.length === 2) {
           val = obj[key];
       }
-      var childOb = !shallow && observe(val);
+      let childOb = !shallow && observe(val);
       Object.defineProperty(obj, key, {
           enumerable: true,
           configurable: true,
           get: function reactiveGetter() {
-              var value = getter ? getter.call(obj) : val;
+              const value = getter ? getter.call(obj) : val;
               if (Dep.target) {
                   dep.depend();
                   if (childOb) {
@@ -921,7 +935,7 @@
               return value;
           },
           set: function reactiveSetter(newVal) {
-              var value = getter ? getter.call(obj) : val;
+              const value = getter ? getter.call(obj) : val;
               /* eslint-disable no-self-compare */
               if (newVal === value || (newVal !== newVal && value !== value)) {
                   return;
@@ -932,7 +946,7 @@
               }
               // #7981: for accessor properties without setter
               if (getter && !setter)
-                  { return; }
+                  return;
               if (setter) {
                   setter.call(obj, newVal);
               }
@@ -951,7 +965,7 @@
    */
   function set(target, key, val) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -962,8 +976,7 @@
           target[key] = val;
           return val;
       }
-      var ob = target.__ob__;
-      // @ts-ignore
+      const ob = target.__ob__;
       if (target._isVue || (ob && ob.vmCount)) {
           warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                   'at runtime - declare it upfront in the data option.');
@@ -982,14 +995,13 @@
    */
   function del(target, key) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+          warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.splice(key, 1);
           return;
       }
-      var ob = target.__ob__;
-      //@ts-ignore
+      const ob = target.__ob__;
       if (target._isVue || (ob && ob.vmCount)) {
           warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
                   '- just set it to null.');
@@ -1009,7 +1021,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1023,14 +1035,14 @@
    * how to merge a parent option value and a child option
    * value into the final value.
    */
-  var strats = config.optionMergeStrategies;
+  const strats = config.optionMergeStrategies;
   /**
    * Options with restrictions
    */
   {
       strats.el = strats.propsData = function (parent, child, vm, key) {
           if (!vm) {
-              warn$2("option \"" + key + "\" can only be used during instance " +
+              warn$2(`option "${key}" can only be used during instance ` +
                   'creation with the `new` keyword.');
           }
           return defaultStrat(parent, child);
@@ -1041,16 +1053,16 @@
    */
   function mergeData(to, from) {
       if (!from)
-          { return to; }
-      var key, toVal, fromVal;
-      var keys = hasSymbol
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
           ? Reflect.ownKeys(from)
           : Object.keys(from);
-      for (var i = 0; i < keys.length; i++) {
+      for (let i = 0; i < keys.length; i++) {
           key = keys[i];
           // in case the object is already observed...
           if (key === '__ob__')
-              { continue; }
+              continue;
           toVal = to[key];
           fromVal = from[key];
           if (!hasOwn(to, key)) {
@@ -1082,18 +1094,14 @@
           // check if parentVal is a function here because
           // it has to be a function to pass previous merges.
           return function mergedDataFn() {
-              return mergeData(
-              // @ts-ignore
-              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-              // @ts-ignore
-              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
           };
       }
       else {
           return function mergedInstanceDataFn() {
               // instance merge
-              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
               if (instanceData) {
                   return mergeData(instanceData, defaultData);
               }
@@ -1119,7 +1127,7 @@
    * Hooks and props are merged as arrays.
    */
   function mergeHook$1(parentVal, childVal) {
-      var res = childVal
+      const res = childVal
           ? parentVal
               ? parentVal.concat(childVal)
               : Array.isArray(childVal)
@@ -1129,15 +1137,15 @@
       return res ? dedupeHooks(res) : res;
   }
   function dedupeHooks(hooks) {
-      var res = [];
-      for (var i = 0; i < hooks.length; i++) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
           if (res.indexOf(hooks[i]) === -1) {
               res.push(hooks[i]);
           }
       }
       return res;
   }
-  LIFECYCLE_HOOKS.forEach(function (hook) {
+  LIFECYCLE_HOOKS.forEach((hook) => {
       strats[hook] = mergeHook$1;
   });
   /**
@@ -1148,7 +1156,7 @@
    * options and parent options.
    */
   function mergeAssets(parentVal, childVal, vm, key) {
-      var res = Object.create(parentVal || null);
+      const res = Object.create(parentVal || null);
       if (childVal) {
           assertObjectType(key, childVal, vm);
           return extend(res, childVal);
@@ -1170,27 +1178,27 @@
       // work around Firefox's Object.prototype.watch...
       //@ts-expect-error work around
       if (parentVal === nativeWatch)
-          { parentVal = undefined; }
+          parentVal = undefined;
       //@ts-expect-error work around
       if (childVal === nativeWatch)
-          { childVal = undefined; }
+          childVal = undefined;
       /* istanbul ignore if */
       if (!childVal)
-          { return Object.create(parentVal || null); }
+          return Object.create(parentVal || null);
       {
           assertObjectType(key, childVal, vm);
       }
       if (!parentVal)
-          { return childVal; }
-      var ret = {};
+          return childVal;
+      const ret = {};
       extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
           if (parent && !Array.isArray(parent)) {
               parent = [parent];
           }
-          ret[key$1] = parent
+          ret[key] = parent
               ? parent.concat(child)
               : Array.isArray(child)
                   ? child
@@ -1206,30 +1214,30 @@
           assertObjectType(key, childVal, vm);
       }
       if (!parentVal)
-          { return childVal; }
-      var ret = Object.create(null);
+          return childVal;
+      const ret = Object.create(null);
       extend(ret, parentVal);
       if (childVal)
-          { extend(ret, childVal); }
+          extend(ret, childVal);
       return ret;
   };
   strats.provide = mergeDataOrFn;
   /**
    * Default strategy.
    */
-  var defaultStrat = function (parentVal, childVal) {
+  const defaultStrat = function (parentVal, childVal) {
       return childVal === undefined ? parentVal : childVal;
   };
   /**
    * Validate component names
    */
   function checkComponents(options) {
-      for (var key in options.components) {
+      for (const key in options.components) {
           validateComponentName(key);
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
           warn$2('Invalid component name: "' +
               name +
               '". Component names ' +
@@ -1246,11 +1254,11 @@
    * Object-based format.
    */
   function normalizeProps(options, vm) {
-      var props = options.props;
+      const props = options.props;
       if (!props)
-          { return; }
-      var res = {};
-      var i, val, name;
+          return;
+      const res = {};
+      let i, val, name;
       if (Array.isArray(props)) {
           i = props.length;
           while (i--) {
@@ -1265,15 +1273,15 @@
           }
       }
       else if (isPlainObject(props)) {
-          for (var key in props) {
+          for (const key in props) {
               val = props[key];
               name = camelize(key);
               res[name] = isPlainObject(val) ? val : { type: val };
           }
       }
       else {
-          warn$2("Invalid value for option \"props\": expected an Array or an Object, " +
-              "but got " + (toRawType(props)) + ".", vm);
+          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
       }
       options.props = res;
   }
@@ -1281,36 +1289,36 @@
    * Normalize all injections into Object-based format
    */
   function normalizeInject(options, vm) {
-      var inject = options.inject;
+      const inject = options.inject;
       if (!inject)
-          { return; }
-      var normalized = (options.inject = {});
+          return;
+      const normalized = (options.inject = {});
       if (Array.isArray(inject)) {
-          for (var i = 0; i < inject.length; i++) {
+          for (let i = 0; i < inject.length; i++) {
               normalized[inject[i]] = { from: inject[i] };
           }
       }
       else if (isPlainObject(inject)) {
-          for (var key in inject) {
-              var val = inject[key];
+          for (const key in inject) {
+              const val = inject[key];
               normalized[key] = isPlainObject(val)
                   ? extend({ from: key }, val)
                   : { from: val };
           }
       }
       else {
-          warn$2("Invalid value for option \"inject\": expected an Array or an Object, " +
-              "but got " + (toRawType(inject)) + ".", vm);
+          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
       }
   }
   /**
    * Normalize raw function directives into object format.
    */
   function normalizeDirectives$1(options) {
-      var dirs = options.directives;
+      const dirs = options.directives;
       if (dirs) {
-          for (var key in dirs) {
-              var def = dirs[key];
+          for (const key in dirs) {
+              const def = dirs[key];
               if (typeof def === 'function') {
                   dirs[key] = { bind: def, update: def };
               }
@@ -1319,8 +1327,8 @@
   }
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
-          warn$2("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
+          warn$2(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
       }
   }
   /**
@@ -1347,13 +1355,13 @@
               parent = mergeOptions(parent, child.extends, vm);
           }
           if (child.mixins) {
-              for (var i = 0, l = child.mixins.length; i < l; i++) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
                   parent = mergeOptions(parent, child.mixins[i], vm);
               }
           }
       }
-      var options = {};
-      var key;
+      const options = {};
+      let key;
       for (key in parent) {
           mergeField(key);
       }
@@ -1363,7 +1371,7 @@
           }
       }
       function mergeField(key) {
-          var strat = strats[key] || defaultStrat;
+          const strat = strats[key] || defaultStrat;
           options[key] = strat(parent[key], child[key], vm, key);
       }
       return options;
@@ -1378,18 +1386,18 @@
       if (typeof id !== 'string') {
           return;
       }
-      var assets = options[type];
+      const assets = options[type];
       // check local registration variations first
       if (hasOwn(assets, id))
-          { return assets[id]; }
-      var camelizedId = camelize(id);
+          return assets[id];
+      const camelizedId = camelize(id);
       if (hasOwn(assets, camelizedId))
-          { return assets[camelizedId]; }
-      var PascalCaseId = capitalize(camelizedId);
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
       if (hasOwn(assets, PascalCaseId))
-          { return assets[PascalCaseId]; }
+          return assets[PascalCaseId];
       // fallback to prototype chain
-      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
       if (warnMissing && !res) {
           warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
       }
@@ -1397,11 +1405,11 @@
   }
 
   function validateProp(key, propOptions, propsData, vm) {
-      var prop = propOptions[key];
-      var absent = !hasOwn(propsData, key);
-      var value = propsData[key];
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
       // boolean casting
-      var booleanIndex = getTypeIndex(Boolean, prop.type);
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
       if (booleanIndex > -1) {
           if (absent && !hasOwn(prop, 'default')) {
               value = false;
@@ -1409,7 +1417,7 @@
           else if (value === '' || value === hyphenate(key)) {
               // only cast empty string / same name to boolean if
               // boolean has higher priority
-              var stringIndex = getTypeIndex(String, prop.type);
+              const stringIndex = getTypeIndex(String, prop.type);
               if (stringIndex < 0 || booleanIndex < stringIndex) {
                   value = true;
               }
@@ -1420,7 +1428,7 @@
           value = getPropDefaultValue(vm, prop, key);
           // since the default value is a fresh copy,
           // make sure to observe it.
-          var prevShouldObserve = shouldObserve;
+          const prevShouldObserve = shouldObserve;
           toggleObserving(true);
           observe(value);
           toggleObserving(prevShouldObserve);
@@ -1438,7 +1446,7 @@
       if (!hasOwn(prop, 'default')) {
           return undefined;
       }
-      var def = prop.default;
+      const def = prop.default;
       // warn against non-factory defaults for Object & Array
       if (isObject(def)) {
           warn$2('Invalid default value for prop "' +
@@ -1472,38 +1480,37 @@
       if (value == null && !prop.required) {
           return;
       }
-      var type = prop.type;
-      // @ts-ignore
-      var valid = !type || type === true;
-      var expectedTypes = [];
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
       if (type) {
           if (!Array.isArray(type)) {
               type = [type];
           }
-          for (var i = 0; i < type.length && !valid; i++) {
-              var assertedType = assertType(value, type[i], vm);
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
               expectedTypes.push(assertedType.expectedType || '');
               valid = assertedType.valid;
           }
       }
-      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+      const haveExpectedTypes = expectedTypes.some((t) => t);
       if (!valid && haveExpectedTypes) {
           warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
           return;
       }
-      var validator = prop.validator;
+      const validator = prop.validator;
       if (validator) {
           if (!validator(value)) {
               warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
           }
       }
   }
-  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
   function assertType(value, type, vm) {
-      var valid;
-      var expectedType = getType(type);
+      let valid;
+      const expectedType = getType(type);
       if (simpleCheckRE.test(expectedType)) {
-          var t = typeof value;
+          const t = typeof value;
           valid = t === expectedType.toLowerCase();
           // for primitive wrapper objects
           if (!valid && t === 'object') {
@@ -1526,18 +1533,18 @@
           }
       }
       return {
-          valid: valid,
-          expectedType: expectedType,
+          valid,
+          expectedType,
       };
   }
-  var functionTypeCheckRE = /^\s*function (\w+)/;
+  const functionTypeCheckRE = /^\s*function (\w+)/;
   /**
    * Use function string name to check built-in types,
    * because a simple equality check will fail when running
    * across different vms / iframes.
    */
   function getType(fn) {
-      var match = fn && fn.toString().match(functionTypeCheckRE);
+      const match = fn && fn.toString().match(functionTypeCheckRE);
       return match ? match[1] : '';
   }
   function isSameType(a, b) {
@@ -1547,7 +1554,7 @@
       if (!Array.isArray(expectedTypes)) {
           return isSameType(expectedTypes, type) ? 0 : -1;
       }
-      for (var i = 0, len = expectedTypes.length; i < len; i++) {
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
           if (isSameType(expectedTypes[i], type)) {
               return i;
           }
@@ -1555,44 +1562,41 @@
       return -1;
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
-      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          " Expected " + (expectedTypes.map(capitalize).join(', '));
-      var expectedType = expectedTypes[0];
-      var receivedType = toRawType(value);
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
       // check if we need to specify expected value
       if (expectedTypes.length === 1 &&
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + (styleValue(value, expectedType));
+          message += ` with value ${styleValue(value, expectedType)}`;
       }
-      message += ", got " + receivedType + " ";
+      message += `, got ${receivedType} `;
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + (styleValue(value, receivedType)) + ".";
+          message += `with value ${styleValue(value, receivedType)}.`;
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return ("\"" + value + "\"");
+          return `"${value}"`;
       }
       else if (type === 'Number') {
-          return ("" + (Number(value)));
+          return `${Number(value)}`;
       }
       else {
-          return ("" + value);
+          return `${value}`;
       }
   }
-  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
   function isExplicable(value) {
-      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
   }
-  function isBoolean() {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
   }
 
   function handleError(err, vm, info) {
@@ -1601,15 +1605,15 @@
       pushTarget();
       try {
           if (vm) {
-              var cur = vm;
+              let cur = vm;
               while ((cur = cur.$parent)) {
-                  var hooks = cur.$options.errorCaptured;
+                  const hooks = cur.$options.errorCaptured;
                   if (hooks) {
-                      for (var i = 0; i < hooks.length; i++) {
+                      for (let i = 0; i < hooks.length; i++) {
                           try {
-                              var capture = hooks[i].call(cur, err, vm, info) === false;
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
                               if (capture)
-                                  { return; }
+                                  return;
                           }
                           catch (e) {
                               globalHandleError(e, cur, 'errorCaptured hook');
@@ -1625,17 +1629,18 @@
       }
   }
   function invokeWithErrorHandling(handler, context, args, vm, info) {
-      var res;
+      let res;
       try {
           res = args ? handler.apply(context, args) : handler.call(context);
           if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
               // issue #9511
               // avoid catch triggering multiple times when nested calls
               res._handled = true;
           }
       }
       catch (e) {
+          // @ts-expect-error should it be any?
           handleError(e, vm, info);
       }
       return res;
@@ -1657,7 +1662,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn$2(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1669,14 +1674,14 @@
   }
 
   /* globals MutationObserver */
-  var isUsingMicroTask = false;
-  var callbacks = [];
-  var pending = false;
+  let isUsingMicroTask = false;
+  const callbacks = [];
+  let pending = false;
   function flushCallbacks() {
       pending = false;
-      var copies = callbacks.slice(0);
+      const copies = callbacks.slice(0);
       callbacks.length = 0;
-      for (var i = 0; i < copies.length; i++) {
+      for (let i = 0; i < copies.length; i++) {
           copies[i]();
       }
   }
@@ -1691,7 +1696,7 @@
   // where microtasks have too high a priority and fire in between supposedly
   // sequential events (e.g. #4521, #6690, which have workarounds)
   // or even between bubbling of the same event (#6566).
-  var timerFunc;
+  let timerFunc;
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -1700,8 +1705,8 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p = Promise.resolve();
-      timerFunc = function () {
+      const p = Promise.resolve();
+      timerFunc = () => {
           p.then(flushCallbacks);
           // In problematic UIWebViews, Promise.then doesn't completely break, but
           // it can get stuck in a weird state where callbacks are pushed into the
@@ -1709,7 +1714,7 @@
           // needs to do some other work, e.g. handle a timer. Therefore we can
           // "force" the microtask queue to be flushed by adding an empty timer.
           if (isIOS)
-              { setTimeout(noop); }
+              setTimeout(noop);
       };
       isUsingMicroTask = true;
   }
@@ -1721,13 +1726,13 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
-      var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
       observer.observe(textNode, {
           characterData: true,
       });
-      timerFunc = function () {
+      timerFunc = () => {
           counter = (counter + 1) % 2;
           textNode.data = String(counter);
       };
@@ -1737,24 +1742,25 @@
       // Fallback to setImmediate.
       // Technically it leverages the (macro) task queue,
       // but it is still a better choice than setTimeout.
-      timerFunc = function () {
+      timerFunc = () => {
           setImmediate(flushCallbacks);
       };
   }
   else {
       // Fallback to setTimeout.
-      timerFunc = function () {
+      timerFunc = () => {
           setTimeout(flushCallbacks, 0);
       };
   }
   function nextTick(cb, ctx) {
-      var _resolve;
-      callbacks.push(function () {
+      let _resolve;
+      callbacks.push(() => {
           if (cb) {
               try {
                   cb.call(ctx);
               }
               catch (e) {
+                  // @ts-expect-error should it be any?
                   handleError(e, ctx, 'nextTick');
               }
           }
@@ -1768,24 +1774,24 @@
       }
       // $flow-disable-line
       if (!cb && typeof Promise !== 'undefined') {
-          return new Promise(function (resolve) {
+          return new Promise((resolve) => {
               _resolve = resolve;
           });
       }
   }
 
-  var mark;
-  var measure;
+  let mark;
+  let measure;
   {
-      var perf = inBrowser && window.performance;
+      const perf = inBrowser && window.performance;
       /* istanbul ignore if */
       if (perf &&
           perf.mark &&
           perf.measure &&
           perf.clearMarks &&
           perf.clearMeasures) {
-          mark = function (tag) { return perf.mark(tag); };
-          measure = function (name, startTag, endTag) {
+          mark = (tag) => perf.mark(tag);
+          measure = (name, startTag, endTag) => {
               perf.measure(name, startTag, endTag);
               perf.clearMarks(startTag);
               perf.clearMarks(endTag);
@@ -1795,33 +1801,33 @@
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
-  var initProxy;
+  let initProxy;
   {
-      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var warnNonPresent = function (target, key) {
-          warn$2("Property or method \"" + key + "\" is not defined on the instance but " +
+      const warnNonPresent = (target, key) => {
+          warn$2(`Property or method "${key}" is not defined on the instance but ` +
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
               'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
-      var warnReservedPrefix = function (target, key) {
-          warn$2("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+      const warnReservedPrefix = (target, key) => {
+          warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
               'See: https://vuejs.org/v2/api/#data', target);
       };
-      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
       if (hasProxy) {
-          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function set(target, key, value) {
+              set(target, key, value) {
                   if (isBuiltInModifier(key)) {
-                      warn$2(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                       return false;
                   }
                   else {
@@ -1831,29 +1837,29 @@
               },
           });
       }
-      var hasHandler = {
-          has: function has(target, key) {
-              var has = key in target;
-              var isAllowed = allowedGlobals(key) ||
+      const hasHandler = {
+          has(target, key) {
+              const has = key in target;
+              const isAllowed = allowedGlobals(key) ||
                   (typeof key === 'string' &&
                       key.charAt(0) === '_' &&
                       !(key in target.$data));
               if (!has && !isAllowed) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      warnReservedPrefix(target, key);
                   else
-                      { warnNonPresent(target, key); }
+                      warnNonPresent(target, key);
               }
               return has || !isAllowed;
           },
       };
-      var getHandler = {
-          get: function get(target, key) {
+      const getHandler = {
+          get(target, key) {
               if (typeof key === 'string' && !(key in target)) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      warnReservedPrefix(target, key);
                   else
-                      { warnNonPresent(target, key); }
+                      warnNonPresent(target, key);
               }
               return target[key];
           },
@@ -1861,8 +1867,8 @@
       initProxy = function initProxy(vm) {
           if (hasProxy) {
               // determine which proxy handler to use
-              var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              const options = vm.$options;
+              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
               vm._renderProxy = new Proxy(vm, handlers);
           }
           else {
@@ -1871,7 +1877,7 @@
       };
   }
 
-  var seenObjects = new _Set();
+  const seenObjects = new _Set();
   /**
    * Recursively traverse an object to evoke all converted
    * getters, so that every nested property inside the object
@@ -1882,15 +1888,15 @@
       seenObjects.clear();
   }
   function _traverse(val, seen) {
-      var i, keys;
-      var isA = Array.isArray(val);
+      let i, keys;
+      const isA = Array.isArray(val);
       if ((!isA && !isObject(val)) ||
           Object.isFrozen(val) ||
           val instanceof VNode) {
           return;
       }
       if (val.__ob__) {
-          var depId = val.__ob__.dep.id;
+          const depId = val.__ob__.dep.id;
           if (seen.has(depId)) {
               return;
           }
@@ -1899,57 +1905,55 @@
       if (isA) {
           i = val.length;
           while (i--)
-              { _traverse(val[i], seen); }
+              _traverse(val[i], seen);
       }
       else {
           keys = Object.keys(val);
           i = keys.length;
           while (i--)
-              { _traverse(val[keys[i]], seen); }
+              _traverse(val[keys[i]], seen);
       }
   }
 
-  var normalizeEvent = cached(function (name) {
-      var passive = name.charAt(0) === '&';
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
       name = passive ? name.slice(1) : name;
-      var once = name.charAt(0) === '~'; // Prefixed last, checked first
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
       name = once ? name.slice(1) : name;
-      var capture = name.charAt(0) === '!';
+      const capture = name.charAt(0) === '!';
       name = capture ? name.slice(1) : name;
       return {
-          name: name,
-          once: once,
-          capture: capture,
-          passive: passive,
+          name,
+          once,
+          capture,
+          passive,
       };
   });
   function createFnInvoker(fns, vm) {
       function invoker() {
-          var arguments$1 = arguments;
-
-          var fns = invoker.fns;
+          const fns = invoker.fns;
           if (Array.isArray(fns)) {
-              var cloned = fns.slice();
-              for (var i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
               }
           }
           else {
               // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
           }
       }
       invoker.fns = fns;
       return invoker;
   }
   function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      var name, cur, old, event;
+      let name, cur, old, event;
       for (name in on) {
           cur = on[name];
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn$2("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -1977,8 +1981,8 @@
       if (def instanceof VNode) {
           def = def.data.hook || (def.data.hook = {});
       }
-      var invoker;
-      var oldHook = def[hookKey];
+      let invoker;
+      const oldHook = def[hookKey];
       function wrappedHook() {
           hook.apply(this, arguments);
           // important: remove merged hook to ensure it's called only once
@@ -2009,27 +2013,26 @@
       // we are only extracting raw values here.
       // validation and default values are handled in the child
       // component itself.
-      var propOptions = Ctor.options.props;
+      const propOptions = Ctor.options.props;
       if (isUndef(propOptions)) {
           return;
       }
-      var res = {};
-      var attrs = data.attrs;
-      var props = data.props;
+      const res = {};
+      const { attrs, props } = data;
       if (isDef(attrs) || isDef(props)) {
-          for (var key in propOptions) {
-              var altKey = hyphenate(key);
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
               {
-                  var keyInLowerCase = key.toLowerCase();
+                  const keyInLowerCase = key.toLowerCase();
                   if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                          (formatComponentName(
-                          // @ts-ignore
-                          tag || Ctor)) + ", but the declared prop name is" +
-                          " \"" + key + "\". " +
-                          "Note that HTML attributes are case-insensitive and camelCased " +
-                          "props need to use their kebab-case equivalents when using in-DOM " +
-                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -2070,7 +2073,7 @@
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
   function simpleNormalizeChildren(children) {
-      for (var i = 0; i < children.length; i++) {
+      for (let i = 0; i < children.length; i++) {
           if (Array.isArray(children[i])) {
               return Array.prototype.concat.apply([], children);
           }
@@ -2092,18 +2095,18 @@
       return isDef(node) && isDef(node.text) && isFalse(node.isComment);
   }
   function normalizeArrayChildren(children, nestedIndex) {
-      var res = [];
-      var i, c, lastIndex, last;
+      const res = [];
+      let i, c, lastIndex, last;
       for (i = 0; i < children.length; i++) {
           c = children[i];
           if (isUndef(c) || typeof c === 'boolean')
-              { continue; }
+              continue;
           lastIndex = res.length - 1;
           last = res[lastIndex];
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2135,7 +2138,7 @@
                       isDef(c.tag) &&
                       isUndef(c.key) &&
                       isDef(nestedIndex)) {
-                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                      c.key = `__vlist${nestedIndex}_${i}__`;
                   }
                   res.push(c);
               }
@@ -2145,7 +2148,7 @@
   }
 
   function initProvide(vm) {
-      var provide = vm.$options.provide;
+      const provide = vm.$options.provide;
       if (provide) {
           vm._provided =
               typeof provide === 'function'
@@ -2155,16 +2158,16 @@
       }
   }
   function initInjections(vm) {
-      var result = resolveInject(vm.$options.inject, vm);
+      const result = resolveInject(vm.$options.inject, vm);
       if (result) {
           toggleObserving(false);
-          Object.keys(result).forEach(function (key) {
+          Object.keys(result).forEach((key) => {
               /* istanbul ignore else */
               {
-                  defineReactive(vm, key, result[key], function () {
-                      warn$2("Avoid mutating an injected value directly since the changes will be " +
-                          "overwritten whenever the provided component re-renders. " +
-                          "injection being mutated: \"" + key + "\"", vm);
+                  defineReactive(vm, key, result[key], () => {
+                      warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                          `overwritten whenever the provided component re-renders. ` +
+                          `injection being mutated: "${key}"`, vm);
                   });
               }
           });
@@ -2174,15 +2177,15 @@
   function resolveInject(inject, vm) {
       if (inject) {
           // inject is :any because flow is not smart enough to figure out cached
-          var result = Object.create(null);
-          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (var i = 0; i < keys.length; i++) {
-              var key = keys[i];
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
               // #6574 in case the inject object is observed...
               if (key === '__ob__')
-                  { continue; }
-              var provideKey = inject[key].from;
-              var source = vm;
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
               while (source) {
                   if (source._provided && hasOwn(source._provided, provideKey)) {
                       result[key] = source._provided[provideKey];
@@ -2193,15 +2196,14 @@
               }
               if (!source) {
                   if ('default' in inject[key]) {
-                      var provideDefault = inject[key].default;
+                      const provideDefault = inject[key].default;
                       result[key] =
                           typeof provideDefault === 'function'
                               ? provideDefault.call(vm)
                               : provideDefault;
                   }
                   else {
-                      // @ts-ignore
-                      warn$2(("Injection \"" + key + "\" not found"), vm);
+                      warn$2(`Injection "${key}" not found`, vm);
                   }
               }
           }
@@ -2216,10 +2218,10 @@
       if (!children || !children.length) {
           return {};
       }
-      var slots = {};
-      for (var i = 0, l = children.length; i < l; i++) {
-          var child = children[i];
-          var data = child.data;
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
           // remove slot attribute if the node is resolved as a Vue slot node
           if (data && data.attrs && data.attrs.slot) {
               delete data.attrs.slot;
@@ -2229,8 +2231,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name = data.slot;
-              var slot = slots[name] || (slots[name] = []);
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -2243,9 +2245,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name$1 in slots) {
-          if (slots[name$1].every(isWhitespace)) {
-              delete slots[name$1];
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
           }
       }
       return slots;
@@ -2254,11 +2256,16 @@
       return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
+  }
+
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      var res;
-      var hasNormalSlots = Object.keys(normalSlots).length > 0;
-      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      var key = slots && slots.$key;
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
       if (!slots) {
           res = {};
       }
@@ -2278,16 +2285,16 @@
       }
       else {
           res = {};
-          for (var key$1 in slots) {
-              if (slots[key$1] && key$1[0] !== '$') {
-                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key$2 in normalSlots) {
-          if (!(key$2 in res)) {
-              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2295,19 +2302,22 @@
       if (slots && Object.isExtensible(slots)) {
           slots._normalized = res;
       }
-      def(res, '$stable', isStable);
-      def(res, '$key', key);
-      def(res, '$hasNormal', hasNormalSlots);
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
       return res;
   }
   function normalizeScopedSlot(normalSlots, key, fn) {
-      var normalized = function () {
-          var res = arguments.length ? fn.apply(null, arguments) : fn({});
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
           res =
-              res && typeof res === 'object' && !Array.isArray(res)
+              res && typeof res === "object" && !Array.isArray(res)
                   ? [res] // single vnode
                   : normalizeChildren(res);
-          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
               ? undefined
               : res;
       };
@@ -2324,14 +2334,14 @@
       return normalized;
   }
   function proxyNormalSlot(slots, key) {
-      return function () { return slots[key]; };
+      return () => slots[key];
   }
 
   /**
    * Runtime helper for rendering v-for lists.
    */
   function renderList(val, render) {
-      var ret = null, i, l, keys, key;
+      let ret = null, i, l, keys, key;
       if (Array.isArray(val) || typeof val === 'string') {
           ret = new Array(val.length);
           for (i = 0, l = val.length; i < l; i++) {
@@ -2347,8 +2357,8 @@
       else if (isObject(val)) {
           if (hasSymbol && val[Symbol.iterator]) {
               ret = [];
-              var iterator = val[Symbol.iterator]();
-              var result = iterator.next();
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
               while (!result.done) {
                   ret.push(render(result.value, ret.length));
                   result = iterator.next();
@@ -2373,26 +2383,34 @@
   /**
    * Runtime helper for rendering <slot>
    */
-  function renderSlot(name, fallback, props, bindObject) {
-      var scopedSlotFn = this.$scopedSlots[name];
-      var nodes;
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
       if (scopedSlotFn) {
           // scoped slot
           props = props || {};
           if (bindObject) {
               if (!isObject(bindObject)) {
-                  warn$2('slot v-bind without argument expects an Object', this);
+                  warn$2("slot v-bind without argument expects an Object", this);
               }
               props = extend(extend({}, bindObject), props);
           }
-          nodes = scopedSlotFn(props) || fallback;
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
       }
       else {
-          nodes = this.$slots[name] || fallback;
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
       }
-      var target = props && props.slot;
+      const target = props && props.slot;
       if (target) {
-          return this.$createElement('template', { slot: target }, nodes);
+          return this.$createElement("template", { slot: target }, nodes);
       }
       else {
           return nodes;
@@ -2420,7 +2438,7 @@
    * passing in eventKeyName as last argument separately for backwards compat
    */
   function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
       if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
           return isKeyNotMatch(builtInKeyName, eventKeyName);
       }
@@ -2430,6 +2448,7 @@
       else if (eventKeyName) {
           return hyphenate(eventKeyName) !== key;
       }
+      return eventKeyCode === undefined;
   }
 
   /**
@@ -2444,32 +2463,30 @@
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash;
-              var loop = function ( key ) {
+              let hash;
+              for (const key in value) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
                   else {
-                      var type = data.attrs && data.attrs.type;
+                      const type = data.attrs && data.attrs.type;
                       hash =
                           asProp || config.mustUseProp(tag, type, key)
                               ? data.domProps || (data.domProps = {})
                               : data.attrs || (data.attrs = {});
                   }
-                  var camelizedKey = camelize(key);
-                  var hyphenatedKey = hyphenate(key);
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
                   if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                       hash[key] = value[key];
                       if (isSync) {
-                          var on = data.on || (data.on = {});
-                          on[("update:" + key)] = function ($event) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
-              };
-
-              for (var key in value) loop( key );
+              }
           }
       }
       return data;
@@ -2479,8 +2496,8 @@
    * Runtime helper for rendering static trees.
    */
   function renderStatic(index, isInFor) {
-      var cached = this._staticTrees || (this._staticTrees = []);
-      var tree = cached[index];
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
       // if has already-rendered static tree and not inside v-for,
       // we can reuse the same tree.
       if (tree && !isInFor) {
@@ -2489,7 +2506,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic$1(tree, ("__static__" + index), false);
+      markStatic$1(tree, `__static__${index}`, false);
       return tree;
   }
   /**
@@ -2497,14 +2514,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic$1(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
       return tree;
   }
   function markStatic$1(tree, key, isOnce) {
       if (Array.isArray(tree)) {
-          for (var i = 0; i < tree.length; i++) {
+          for (let i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
               }
           }
       }
@@ -2524,10 +2541,10 @@
               warn$2('v-on without argument expects an Object value', this);
           }
           else {
-              var on = (data.on = data.on ? extend({}, data.on) : {});
-              for (var key in value) {
-                  var existing = on[key];
-                  var ours = value[key];
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
                   on[key] = existing ? [].concat(existing, ours) : ours;
               }
           }
@@ -2539,8 +2556,8 @@
   // the following are added in 2.6
   hasDynamicKeys, contentHashKey) {
       res = res || { $stable: !hasDynamicKeys };
-      for (var i = 0; i < fns.length; i++) {
-          var slot = fns[i];
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
           if (Array.isArray(slot)) {
               resolveScopedSlots(slot, res, hasDynamicKeys);
           }
@@ -2562,15 +2579,15 @@
 
   // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
-      for (var i = 0; i < values.length; i += 2) {
-          var key = values[i];
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
           if (typeof key === 'string' && key) {
               baseObj[values[i]] = values[i + 1];
           }
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn$2(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
           }
       }
       return baseObj;
@@ -2603,12 +2620,10 @@
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var this$1 = this;
-
-      var options = Ctor.options;
+      const options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
-      var contextVm;
+      let contextVm;
       if (hasOwn(parent, '_uid')) {
           contextVm = Object.create(parent);
           // $flow-disable-line
@@ -2622,23 +2637,23 @@
           // $flow-disable-line
           parent = parent._original;
       }
-      var isCompiled = isTrue(options._compiled);
-      var needNormalization = !isCompiled;
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
       this.data = data;
       this.props = props;
       this.children = children;
       this.parent = parent;
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
-      this.slots = function () {
-          if (!this$1.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
           }
-          return this$1.$slots;
+          return this.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function get() {
+          get() {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -2651,8 +2666,8 @@
           this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
       }
       if (options._scopeId) {
-          this._c = function (a, b, c, d) {
-              var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+          this._c = (a, b, c, d) => {
+              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
               if (vnode && !Array.isArray(vnode)) {
                   vnode.fnScopeId = options._scopeId;
                   vnode.fnContext = parent;
@@ -2661,34 +2676,34 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
   function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      var options = Ctor.options;
-      var props = {};
-      var propOptions = options.props;
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
       if (isDef(propOptions)) {
-          for (var key in propOptions) {
+          for (const key in propOptions) {
               props[key] = validateProp(key, propOptions, propsData || emptyObject);
           }
       }
       else {
           if (isDef(data.attrs))
-              { mergeProps(props, data.attrs); }
+              mergeProps(props, data.attrs);
           if (isDef(data.props))
-              { mergeProps(props, data.props); }
+              mergeProps(props, data.props);
       }
-      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      var vnode = options.render.call(null, renderContext._c, renderContext);
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
       if (vnode instanceof VNode) {
           return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
       }
       else if (Array.isArray(vnode)) {
-          var vnodes = normalizeChildren(vnode) || [];
-          var res = new Array(vnodes.length);
-          for (var i = 0; i < vnodes.length; i++) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
               res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
           }
           return res;
@@ -2698,7 +2713,7 @@
       // #7817 clone node before setting fnContext, otherwise if the node is reused
       // (e.g. it was from a cached normal slot) the fnContext causes named slots
       // that should not be matched to match.
-      var clone = cloneVNode(vnode);
+      const clone = cloneVNode(vnode);
       clone.fnContext = contextVm;
       clone.fnOptions = options;
       {
@@ -2710,38 +2725,37 @@
       return clone;
   }
   function mergeProps(to, from) {
-      for (var key in from) {
+      for (const key in from) {
           to[camelize(key)] = from[key];
       }
   }
 
   // inline hooks to be invoked on component VNodes during patch
-  var componentVNodeHooks = {
-      init: function init(vnode, hydrating) {
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
               // kept-alive components, treat as a patch
-              var mountedNode = vnode; // work around flow
+              const mountedNode = vnode; // work around flow
               componentVNodeHooks.prepatch(mountedNode, mountedNode);
           }
           else {
-              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function prepatch(oldVnode, vnode) {
-          var options = vnode.componentOptions;
-          var child = (vnode.componentInstance = oldVnode.componentInstance);
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
           options.listeners, // updated listeners
           vnode, // new parent vnode
           options.children // new children
           );
       },
-      insert: function insert(vnode) {
-          var context = vnode.context;
-          var componentInstance = vnode.componentInstance;
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
               callHook$1(componentInstance, 'mounted');
@@ -2760,8 +2774,8 @@
               }
           }
       },
-      destroy: function destroy(vnode) {
-          var componentInstance = vnode.componentInstance;
+      destroy(vnode) {
+          const { componentInstance } = vnode;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
                   componentInstance.$destroy();
@@ -2772,12 +2786,12 @@
           }
       },
   };
-  var hooksToMerge = Object.keys(componentVNodeHooks);
+  const hooksToMerge = Object.keys(componentVNodeHooks);
   function createComponent(Ctor, data, context, children, tag) {
       if (isUndef(Ctor)) {
           return;
       }
-      var baseCtor = context.$options._base;
+      const baseCtor = context.$options._base;
       // plain options object: turn it into a constructor
       if (isObject(Ctor)) {
           Ctor = baseCtor.extend(Ctor);
@@ -2786,12 +2800,12 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn$2(("Invalid Component definition: " + (String(Ctor))), context);
+              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
           }
           return;
       }
       // async component
-      var asyncFactory;
+      let asyncFactory;
       // @ts-expect-error
       if (isUndef(Ctor.cid)) {
           asyncFactory = Ctor;
@@ -2814,7 +2828,7 @@
       }
       // extract props
       // @ts-expect-error
-      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
       // functional component
       // @ts-expect-error
       if (isTrue(Ctor.options.functional)) {
@@ -2822,7 +2836,7 @@
       }
       // extract listeners, since these needs to be treated as
       // child component listeners instead of DOM listeners
-      var listeners = data.on;
+      const listeners = data.on;
       // replace with listeners with .native modifier
       // so it gets processed during parent component patch.
       data.on = data.nativeOn;
@@ -2831,7 +2845,7 @@
           // abstract components do not keep anything
           // other than props & listeners & slot
           // work around flow
-          var slot = data.slot;
+          const slot = data.slot;
           data = {};
           if (slot) {
               data.slot = slot;
@@ -2841,12 +2855,12 @@
       installComponentHooks(data);
       // return a placeholder vnode
       // @ts-expect-error
-      var name = Ctor.options.name || tag;
-      var vnode = new VNode(
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
       // @ts-expect-error
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
       // @ts-expect-error
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
       return vnode;
   }
   function createComponentInstanceForVnode(
@@ -2854,13 +2868,13 @@
   vnode, 
   // activeInstance in lifecycle state
   parent) {
-      var options = {
+      const options = {
           _isComponent: true,
           _parentVnode: vnode,
-          parent: parent,
+          parent,
       };
       // check inline-template render functions
-      var inlineTemplate = vnode.data.inlineTemplate;
+      const inlineTemplate = vnode.data.inlineTemplate;
       if (isDef(inlineTemplate)) {
           options.render = inlineTemplate.render;
           options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2868,11 +2882,11 @@
       return new vnode.componentOptions.Ctor(options);
   }
   function installComponentHooks(data) {
-      var hooks = data.hook || (data.hook = {});
-      for (var i = 0; i < hooksToMerge.length; i++) {
-          var key = hooksToMerge[i];
-          var existing = hooks[key];
-          var toMerge = componentVNodeHooks[key];
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
           // @ts-expect-error
           if (existing !== toMerge && !(existing && existing._merged)) {
               hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2880,7 +2894,7 @@
       }
   }
   function mergeHook(f1, f2) {
-      var merged = function (a, b) {
+      const merged = (a, b) => {
           // flow complains about extra args which is why we use any
           f1(a, b);
           f2(a, b);
@@ -2891,12 +2905,12 @@
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
   function transformModel(options, data) {
-      var prop = (options.model && options.model.prop) || 'value';
-      var event = (options.model && options.model.event) || 'input';
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
       (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      var on = data.on || (data.on = {});
-      var existing = on[event];
-      var callback = data.model.callback;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
       if (isDef(existing)) {
           if (Array.isArray(existing)
               ? existing.indexOf(callback) === -1
@@ -2909,8 +2923,8 @@
       }
   }
 
-  var SIMPLE_NORMALIZE = 1;
-  var ALWAYS_NORMALIZE = 2;
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
   function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2926,7 +2940,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn$2("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -2959,16 +2973,16 @@
       else if (normalizationType === SIMPLE_NORMALIZE) {
           children = simpleNormalizeChildren(children);
       }
-      var vnode, ns;
+      let vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor;
+          let Ctor;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if (config.isReservedTag(tag)) {
               // platform built-in elements
               if (isDef(data) &&
                   isDef(data.nativeOn) &&
                   data.tag !== 'component') {
-                  warn$2(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                  warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
               }
               vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
           }
@@ -2993,9 +3007,9 @@
       }
       else if (isDef(vnode)) {
           if (isDef(ns))
-              { applyNS(vnode, ns); }
+              applyNS(vnode, ns);
           if (isDef(data))
-              { registerDeepBindings(data); }
+              registerDeepBindings(data);
           return vnode;
       }
       else {
@@ -3010,8 +3024,8 @@
           force = true;
       }
       if (isDef(vnode.children)) {
-          for (var i = 0, l = vnode.children.length; i < l; i++) {
-              var child = vnode.children[i];
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
               if (isDef(child.tag) &&
                   (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                   applyNS(child, ns, force);
@@ -3034,9 +3048,9 @@
   function initRender(vm) {
       vm._vnode = null; // the root of the child tree
       vm._staticTrees = null; // v-once cached trees
-      var options = vm.$options;
-      var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      var renderContext = parentVnode && parentVnode.context;
+      const options = vm.$options;
+      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      const renderContext = parentVnode && parentVnode.context;
       vm.$slots = resolveSlots(options._renderChildren, renderContext);
       vm.$scopedSlots = emptyObject;
       // bind the createElement fn to this instance
@@ -3044,25 +3058,25 @@
       // args order: tag, data, children, normalizationType, alwaysNormalize
       // internal version is used by render functions compiled from templates
       // @ts-expect-error
-      vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
       // normalization is always applied for the public version, used in
       // user-written render functions.
       // @ts-expect-error
-      vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
       // $attrs & $listeners are exposed for easier HOC creation.
       // they need to be reactive so that HOCs using them are always updated
-      var parentData = parentVnode && parentVnode.data;
+      const parentData = parentVnode && parentVnode.data;
       /* istanbul ignore else */
       {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-              !isUpdatingChildComponent && warn$2("$attrs is readonly.", vm);
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+              !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
           }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-              !isUpdatingChildComponent && warn$2("$listeners is readonly.", vm);
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+              !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
           }, true);
       }
   }
-  var currentRenderingInstance = null;
+  let currentRenderingInstance = null;
   function renderMixin(Vue) {
       // install runtime convenience helpers
       installRenderHelpers(Vue.prototype);
@@ -3070,10 +3084,8 @@
           return nextTick(fn, this);
       };
       Vue.prototype._render = function () {
-          var vm = this;
-          var ref = vm.$options;
-          var render = ref.render;
-          var _parentVnode = ref._parentVnode;
+          const vm = this;
+          const { render, _parentVnode } = vm.$options;
           if (_parentVnode) {
               vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
@@ -3081,7 +3093,7 @@
           // to the data on the placeholder node.
           vm.$vnode = _parentVnode;
           // render self
-          var vnode;
+          let vnode;
           try {
               // There's no need to maintain a stack because all render fns are called
               // separately from one another. Nested component's render fns are called
@@ -3090,7 +3102,7 @@
               vnode = render.call(vm._renderProxy, vm.$createElement);
           }
           catch (e) {
-              handleError(e, vm, "render");
+              handleError(e, vm, `render`);
               // return error render result,
               // or previous vnode to prevent render error causing blank component
               /* istanbul ignore else */
@@ -3098,8 +3110,8 @@
                   try {
                       vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                   }
-                  catch (e$1) {
-                      handleError(e$1, vm, "renderError");
+                  catch (e) {
+                      handleError(e, vm, `renderError`);
                       vnode = vm._vnode;
                   }
               }
@@ -3135,9 +3147,9 @@
       return isObject(comp) ? base.extend(comp) : comp;
   }
   function createAsyncPlaceholder(factory, data, context, children, tag) {
-      var node = createEmptyVNode();
+      const node = createEmptyVNode();
       node.asyncFactory = factory;
-      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+      node.asyncMeta = { data, context, children, tag };
       return node;
   }
   function resolveAsyncComponent(factory, baseCtor) {
@@ -3147,7 +3159,7 @@
       if (isDef(factory.resolved)) {
           return factory.resolved;
       }
-      var owner = currentRenderingInstance;
+      const owner = currentRenderingInstance;
       if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
           // already pending
           factory.owners.push(owner);
@@ -3156,13 +3168,13 @@
           return factory.loadingComp;
       }
       if (owner && !isDef(factory.owners)) {
-          var owners = (factory.owners = [owner]);
-          var sync = true;
-          var timerLoading = null;
-          var timerTimeout = null;
-          owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-          var forceRender = function (renderCompleted) {
-              for (var i = 0, l = owners.length; i < l; i++) {
+          const owners = (factory.owners = [owner]);
+          let sync = true;
+          let timerLoading = null;
+          let timerTimeout = null;
+          owner.$on('hook:destroyed', () => remove$2(owners, owner));
+          const forceRender = (renderCompleted) => {
+              for (let i = 0, l = owners.length; i < l; i++) {
                   owners[i].$forceUpdate();
               }
               if (renderCompleted) {
@@ -3177,7 +3189,7 @@
                   }
               }
           };
-          var resolve = once(function (res) {
+          const resolve = once((res) => {
               // cache resolved
               factory.resolved = ensureCtor(res, baseCtor);
               // invoke callbacks only if this is not a synchronous resolve
@@ -3189,15 +3201,15 @@
                   owners.length = 0;
               }
           });
-          var reject = once(function (reason) {
-              warn$2("Failed to resolve async component: " + (String(factory)) +
-                      (reason ? ("\nReason: " + reason) : ''));
+          const reject = once((reason) => {
+              warn$2(`Failed to resolve async component: ${String(factory)}` +
+                      (reason ? `\nReason: ${reason}` : ''));
               if (isDef(factory.errorComp)) {
                   factory.error = true;
                   forceRender(true);
               }
           });
-          var res = factory(resolve, reject);
+          const res = factory(resolve, reject);
           if (isObject(res)) {
               if (isPromise(res)) {
                   // () => Promise
@@ -3217,7 +3229,7 @@
                       }
                       else {
                           // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(function () {
+                          timerLoading = setTimeout(() => {
                               timerLoading = null;
                               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                   factory.loading = true;
@@ -3228,10 +3240,10 @@
                   }
                   if (isDef(res.timeout)) {
                       // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(function () {
+                      timerTimeout = setTimeout(() => {
                           timerTimeout = null;
                           if (isUndef(factory.resolved)) {
-                              reject(("timeout (" + (res.timeout) + "ms)")
+                              reject(`timeout (${res.timeout}ms)`
                                   );
                           }
                       }, res.timeout);
@@ -3244,15 +3256,10 @@
       }
   }
 
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
   function getFirstComponentChild(children) {
       if (Array.isArray(children)) {
-          for (var i = 0; i < children.length; i++) {
-              var c = children[i];
+          for (let i = 0; i < children.length; i++) {
+              const c = children[i];
               if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                   return c;
               }
@@ -3264,12 +3271,12 @@
       vm._events = Object.create(null);
       vm._hasHookEvent = false;
       // init parent attached events
-      var listeners = vm.$options._parentListeners;
+      const listeners = vm.$options._parentListeners;
       if (listeners) {
           updateComponentListeners(vm, listeners);
       }
   }
-  var target$1;
+  let target$1;
   function add$1(event, fn) {
       target$1.$on(event, fn);
   }
@@ -3277,9 +3284,9 @@
       target$1.$off(event, fn);
   }
   function createOnceHandler$1(event, fn) {
-      var _target = target$1;
+      const _target = target$1;
       return function onceHandler() {
-          var res = fn.apply(null, arguments);
+          const res = fn.apply(null, arguments);
           if (res !== null) {
               _target.$off(event, onceHandler);
           }
@@ -3291,11 +3298,11 @@
       target$1 = undefined;
   }
   function eventsMixin(Vue) {
-      var hookRE = /^hook:/;
+      const hookRE = /^hook:/;
       Vue.prototype.$on = function (event, fn) {
-          var vm = this;
+          const vm = this;
           if (Array.isArray(event)) {
-              for (var i = 0, l = event.length; i < l; i++) {
+              for (let i = 0, l = event.length; i < l; i++) {
                   vm.$on(event[i], fn);
               }
           }
@@ -3310,7 +3317,7 @@
           return vm;
       };
       Vue.prototype.$once = function (event, fn) {
-          var vm = this;
+          const vm = this;
           function on() {
               vm.$off(event, on);
               fn.apply(vm, arguments);
@@ -3320,7 +3327,7 @@
           return vm;
       };
       Vue.prototype.$off = function (event, fn) {
-          var vm = this;
+          const vm = this;
           // all
           if (!arguments.length) {
               vm._events = Object.create(null);
@@ -3328,13 +3335,13 @@
           }
           // array of events
           if (Array.isArray(event)) {
-              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                  vm.$off(event[i$1], fn);
+              for (let i = 0, l = event.length; i < l; i++) {
+                  vm.$off(event[i], fn);
               }
               return vm;
           }
           // specific event
-          var cbs = vm._events[event];
+          const cbs = vm._events[event];
           if (!cbs) {
               return vm;
           }
@@ -3343,8 +3350,8 @@
               return vm;
           }
           // specific handler
-          var cb;
-          var i = cbs.length;
+          let cb;
+          let i = cbs.length;
           while (i--) {
               cb = cbs[i];
               if (cb === fn || cb.fn === fn) {
@@ -3355,23 +3362,23 @@
           return vm;
       };
       Vue.prototype.$emit = function (event) {
-          var vm = this;
+          const vm = this;
           {
-              var lowerCaseEvent = event.toLowerCase();
+              const lowerCaseEvent = event.toLowerCase();
               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                      "Note that HTML attributes are case-insensitive and you cannot use " +
-                      "v-on to listen to camelCase events when using in-DOM templates. " +
-                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                      `Note that HTML attributes are case-insensitive and you cannot use ` +
+                      `v-on to listen to camelCase events when using in-DOM templates. ` +
+                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
               }
           }
-          var cbs = vm._events[event];
+          let cbs = vm._events[event];
           if (cbs) {
               cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              var args = toArray(arguments, 1);
-              var info = "event handler for \"" + event + "\"";
-              for (var i = 0, l = cbs.length; i < l; i++) {
+              const args = toArray(arguments, 1);
+              const info = `event handler for "${event}"`;
+              for (let i = 0, l = cbs.length; i < l; i++) {
                   invokeWithErrorHandling(cbs[i], vm, args, vm, info);
               }
           }
@@ -3379,19 +3386,19 @@
       };
   }
 
-  var activeInstance = null;
-  var isUpdatingChildComponent = false;
+  let activeInstance = null;
+  let isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
-      var prevActiveInstance = activeInstance;
+      const prevActiveInstance = activeInstance;
       activeInstance = vm;
-      return function () {
+      return () => {
           activeInstance = prevActiveInstance;
       };
   }
   function initLifecycle(vm) {
-      var options = vm.$options;
+      const options = vm.$options;
       // locate first non-abstract parent
-      var parent = options.parent;
+      let parent = options.parent;
       if (parent && !options.abstract) {
           while (parent.$options.abstract && parent.$parent) {
               parent = parent.$parent;
@@ -3402,7 +3409,6 @@
       vm.$root = parent ? parent.$root : vm;
       vm.$children = [];
       vm.$refs = {};
-      // @ts-ignore
       vm._watcher = null;
       vm._inactive = null;
       vm._directInactive = false;
@@ -3412,10 +3418,10 @@
   }
   function lifecycleMixin(Vue) {
       Vue.prototype._update = function (vnode, hydrating) {
-          var vm = this;
-          var prevEl = vm.$el;
-          var prevVnode = vm._vnode;
-          var restoreActiveInstance = setActiveInstance(vm);
+          const vm = this;
+          const prevEl = vm.$el;
+          const prevVnode = vm._vnode;
+          const restoreActiveInstance = setActiveInstance(vm);
           vm._vnode = vnode;
           // Vue.prototype.__patch__ is injected in entry points
           // based on the rendering backend used.
@@ -3443,21 +3449,20 @@
           // updated in a parent's updated hook.
       };
       Vue.prototype.$forceUpdate = function () {
-          var vm = this;
+          const vm = this;
           if (vm._watcher) {
               vm._watcher.update();
           }
       };
       Vue.prototype.$destroy = function () {
-          var vm = this;
+          const vm = this;
           if (vm._isBeingDestroyed) {
               return;
           }
-          callHook$1(vm, 'beforeDestroy');
+          callHook$1(vm, "beforeDestroy");
           vm._isBeingDestroyed = true;
           // remove self from parent
-          var parent = vm.$parent;
-          // @ts-ignore
+          const parent = vm.$parent;
           if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
               remove$2(parent.$children, vm);
           }
@@ -3465,7 +3470,7 @@
           if (vm._watcher) {
               vm._watcher.teardown();
           }
-          var i = vm._watchers.length;
+          let i = vm._watchers.length;
           while (i--) {
               vm._watchers[i].teardown();
           }
@@ -3479,7 +3484,7 @@
           // invoke destroy hooks on current rendered tree
           vm.__patch__(vm._vnode, null);
           // fire destroyed hook
-          callHook$1(vm, 'destroyed');
+          callHook$1(vm, "destroyed");
           // turn off all instance listeners.
           vm.$off();
           // remove __vue__ reference
@@ -3488,7 +3493,6 @@
           }
           // release circular reference (#6759)
           if (vm.$vnode) {
-              // @ts-expect-error null is not undefined
               vm.$vnode.parent = null;
           }
       };
@@ -3500,39 +3504,39 @@
           vm.$options.render = createEmptyVNode;
           {
               /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                   vm.$options.el ||
                   el) {
-                  warn$2('You are using the runtime-only build of Vue where the template ' +
-                      'compiler is not available. Either pre-compile the templates into ' +
-                      'render functions, or use the compiler-included build.', vm);
+                  warn$2("You are using the runtime-only build of Vue where the template " +
+                      "compiler is not available. Either pre-compile the templates into " +
+                      "render functions, or use the compiler-included build.", vm);
               }
               else {
-                  warn$2('Failed to mount component: template or render function not defined.', vm);
+                  warn$2("Failed to mount component: template or render function not defined.", vm);
               }
           }
       }
-      callHook$1(vm, 'beforeMount');
-      var updateComponent;
+      callHook$1(vm, "beforeMount");
+      let updateComponent;
       /* istanbul ignore if */
       if (config.performance && mark) {
-          updateComponent = function () {
-              var name = vm._name;
-              var id = vm._uid;
-              var startTag = "vue-perf-start:" + id;
-              var endTag = "vue-perf-end:" + id;
+          updateComponent = () => {
+              const name = vm._name;
+              const id = vm._uid;
+              const startTag = `vue-perf-start:${id}`;
+              const endTag = `vue-perf-end:${id}`;
               mark(startTag);
-              var vnode = vm._render();
+              const vnode = vm._render();
               mark(endTag);
-              measure(("vue " + name + " render"), startTag, endTag);
+              measure(`vue ${name} render`, startTag, endTag);
               mark(startTag);
               vm._update(vnode, hydrating);
               mark(endTag);
-              measure(("vue " + name + " patch"), startTag, endTag);
+              measure(`vue ${name} patch`, startTag, endTag);
           };
       }
       else {
-          updateComponent = function () {
+          updateComponent = () => {
               vm._update(vm._render(), hydrating);
           };
       }
@@ -3540,9 +3544,9 @@
       // since the watcher's initial patch may call $forceUpdate (e.g. inside child
       // component's mounted hook), which relies on vm._watcher being already defined
       new Watcher(vm, updateComponent, noop, {
-          before: function before() {
+          before() {
               if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, 'beforeUpdate');
+                  callHook$1(vm, "beforeUpdate");
               }
           },
       }, true /* isRenderWatcher */);
@@ -3551,7 +3555,7 @@
       // mounted is called for render-created child components in its inserted hook
       if (vm.$vnode == null) {
           vm._isMounted = true;
-          callHook$1(vm, 'mounted');
+          callHook$1(vm, "mounted");
       }
       return vm;
   }
@@ -3564,24 +3568,22 @@
       // check if there are dynamic scopedSlots (hand-written or compiled but with
       // dynamic slot names). Static scoped slots compiled from template has the
       // "$stable" marker.
-      var newScopedSlots = parentVnode.data.scopedSlots;
-      var oldScopedSlots = vm.$scopedSlots;
-      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
           (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
       // Any static slot children from the parent may have changed during parent's
       // update. Dynamic scoped slots may also have changed. In such cases, a forced
       // update is necessary to ensure correctness.
-      var needsForceUpdate = !!(renderChildren || // has new static slots
+      const needsForceUpdate = !!(renderChildren || // has new static slots
           vm.$options._renderChildren || // has old static slots
           hasDynamicScopedSlot);
-      // @ts-ignore
       vm.$options._parentVnode = parentVnode;
-      // @ts-ignore
       vm.$vnode = parentVnode; // update vm's placeholder node without re-render
       if (vm._vnode) {
           // update child tree's parent
-          // @ts-ignore
           vm._vnode.parent = parentVnode;
       }
       vm.$options._renderChildren = renderChildren;
@@ -3589,16 +3591,15 @@
       // these are also reactive so they may trigger child update if the child
       // used them during render
       vm.$attrs = parentVnode.data.attrs || emptyObject;
-      // @ts-ignore
       vm.$listeners = listeners || emptyObject;
       // update props
       if (propsData && vm.$options.props) {
           toggleObserving(false);
-          var props = vm._props;
-          var propKeys = vm.$options._propKeys || [];
-          for (var i = 0; i < propKeys.length; i++) {
-              var key = propKeys[i];
-              var propOptions = vm.$options.props; // wtf flow?
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
               props[key] = validateProp(key, propOptions, propsData, vm);
           }
           toggleObserving(true);
@@ -3607,7 +3608,7 @@
       }
       // update listeners
       listeners = listeners || emptyObject;
-      var oldListeners = vm.$options._parentListeners;
+      const oldListeners = vm.$options._parentListeners;
       vm.$options._parentListeners = listeners;
       updateComponentListeners(vm, listeners, oldListeners);
       // resolve slots + force update if has children
@@ -3622,7 +3623,7 @@
   function isInInactiveTree(vm) {
       while (vm && (vm = vm.$parent)) {
           if (vm._inactive)
-              { return true; }
+              return true;
       }
       return false;
   }
@@ -3638,10 +3639,10 @@
       }
       if (vm._inactive || vm._inactive === null) {
           vm._inactive = false;
-          for (var i = 0; i < vm.$children.length; i++) {
+          for (let i = 0; i < vm.$children.length; i++) {
               activateChildComponent(vm.$children[i]);
           }
-          callHook$1(vm, 'activated');
+          callHook$1(vm, "activated");
       }
   }
   function deactivateChildComponent(vm, direct) {
@@ -3653,36 +3654,36 @@
       }
       if (!vm._inactive) {
           vm._inactive = true;
-          for (var i = 0; i < vm.$children.length; i++) {
+          for (let i = 0; i < vm.$children.length; i++) {
               deactivateChildComponent(vm.$children[i]);
           }
-          callHook$1(vm, 'deactivated');
+          callHook$1(vm, "deactivated");
       }
   }
   function callHook$1(vm, hook) {
       // #7573 disable dep collection when invoking lifecycle hooks
       pushTarget();
-      var handlers = vm.$options[hook];
-      var info = hook + " hook";
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
       if (handlers) {
-          for (var i = 0, j = handlers.length; i < j; i++) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
               invokeWithErrorHandling(handlers[i], vm, null, vm, info);
           }
       }
       if (vm._hasHookEvent) {
-          vm.$emit('hook:' + hook);
+          vm.$emit("hook:" + hook);
       }
       popTarget();
   }
 
-  var MAX_UPDATE_COUNT = 100;
-  var queue = [];
-  var activatedChildren = [];
-  var has = {};
-  var circular = {};
-  var waiting = false;
-  var flushing = false;
-  var index$1 = 0;
+  const MAX_UPDATE_COUNT = 100;
+  const queue = [];
+  const activatedChildren = [];
+  let has = {};
+  let circular = {};
+  let waiting = false;
+  let flushing = false;
+  let index$1 = 0;
   /**
    * Reset the scheduler's state.
    */
@@ -3699,9 +3700,9 @@
   // if the page has thousands of event listeners. Instead, we take a timestamp
   // every time the scheduler flushes and use that for all event listeners
   // attached during that flush.
-  var currentFlushTimestamp = 0;
+  let currentFlushTimestamp = 0;
   // Async edge case fix requires storing an event listener's attach timestamp.
-  var getNow = Date.now;
+  let getNow = Date.now;
   // Determine what event timestamp the browser is using. Annoyingly, the
   // timestamp can either be hi-res (relative to page load) or low-res
   // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3709,7 +3710,7 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance = window.performance;
+      const performance = window.performance;
       if (performance &&
           typeof performance.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
@@ -3717,7 +3718,7 @@
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance.now(); };
+          getNow = () => performance.now();
       }
   }
   /**
@@ -3726,7 +3727,7 @@
   function flushSchedulerQueue() {
       currentFlushTimestamp = getNow();
       flushing = true;
-      var watcher, id;
+      let watcher, id;
       // Sort queue before flush.
       // This ensures that:
       // 1. Components are updated from parent to child. (because parent is always
@@ -3735,7 +3736,7 @@
       //    user watchers are created before the render watcher)
       // 3. If a component is destroyed during a parent component's watcher run,
       //    its watchers can be skipped.
-      queue.sort(function (a, b) { return a.id - b.id; });
+      queue.sort((a, b) => a.id - b.id);
       // do not cache length because more watchers might be pushed
       // as we run existing watchers
       for (index$1 = 0; index$1 < queue.length; index$1++) {
@@ -3752,15 +3753,15 @@
               if (circular[id] > MAX_UPDATE_COUNT) {
                   warn$2('You may have an infinite update loop ' +
                       (watcher.user
-                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                          : "in a component render function."), watcher.vm);
+                          ? `in watcher with expression "${watcher.expression}"`
+                          : `in a component render function.`), watcher.vm);
                   break;
               }
           }
       }
       // keep copies of post queues before resetting state
-      var activatedQueue = activatedChildren.slice();
-      var updatedQueue = queue.slice();
+      const activatedQueue = activatedChildren.slice();
+      const updatedQueue = queue.slice();
       resetSchedulerState();
       // call component updated and activated hooks
       callActivatedHooks(activatedQueue);
@@ -3772,10 +3773,10 @@
       }
   }
   function callUpdatedHooks(queue) {
-      var i = queue.length;
+      let i = queue.length;
       while (i--) {
-          var watcher = queue[i];
-          var vm = watcher.vm;
+          const watcher = queue[i];
+          const vm = watcher.vm;
           if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
               callHook$1(vm, 'updated');
           }
@@ -3792,7 +3793,7 @@
       activatedChildren.push(vm);
   }
   function callActivatedHooks(queue) {
-      for (var i = 0; i < queue.length; i++) {
+      for (let i = 0; i < queue.length; i++) {
           queue[i]._inactive = true;
           activateChildComponent(queue[i], true /* true */);
       }
@@ -3803,7 +3804,7 @@
    * pushed when the queue is being flushed.
    */
   function queueWatcher(watcher) {
-      var id = watcher.id;
+      const id = watcher.id;
       if (has[id] == null) {
           has[id] = true;
           if (!flushing) {
@@ -3812,7 +3813,7 @@
           else {
               // if already flushing, splice the watcher based on its id
               // if already past its id, it will be run next immediately.
-              var i = queue.length - 1;
+              let i = queue.length - 1;
               while (i > index$1 && queue[i].id > watcher.id) {
                   i--;
               }
@@ -3830,199 +3831,217 @@
       }
   }
 
-  var uid$1 = 0;
+  let uid$1 = 0;
   /**
    * A watcher parses an expression, collects dependencies,
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-      this.vm = vm;
-      if (isRenderWatcher) {
-          vm._watcher = this;
-      }
-      vm._watchers.push(this);
-      // options
-      if (options) {
-          this.deep = !!options.deep;
-          this.user = !!options.user;
-          this.lazy = !!options.lazy;
-          this.sync = !!options.sync;
-          this.before = options.before;
-      }
-      else {
-          this.deep = this.user = this.lazy = this.sync = false;
-      }
-      this.cb = cb;
-      this.id = ++uid$1; // uid for batching
-      this.active = true;
-      this.dirty = this.lazy; // for lazy watchers
-      this.deps = [];
-      this.newDeps = [];
-      this.depIds = new _Set();
-      this.newDepIds = new _Set();
-      this.expression =
-          expOrFn.toString() ;
-      // parse expression for getter
-      if (typeof expOrFn === 'function') {
-          this.getter = expOrFn;
-      }
-      else {
-          this.getter = parsePath(expOrFn);
-          if (!this.getter) {
-              this.getter = noop;
-              warn$2("Failed watching path: \"" + expOrFn + "\" " +
+  class Watcher {
+      vm;
+      expression;
+      cb;
+      id;
+      deep;
+      user;
+      lazy;
+      sync;
+      dirty;
+      active;
+      deps;
+      newDeps;
+      depIds;
+      newDepIds;
+      before;
+      getter;
+      value;
+      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+          this.vm = vm;
+          if (isRenderWatcher) {
+              vm._watcher = this;
+          }
+          vm._watchers.push(this);
+          // options
+          if (options) {
+              this.deep = !!options.deep;
+              this.user = !!options.user;
+              this.lazy = !!options.lazy;
+              this.sync = !!options.sync;
+              this.before = options.before;
+          }
+          else {
+              this.deep = this.user = this.lazy = this.sync = false;
+          }
+          this.cb = cb;
+          this.id = ++uid$1; // uid for batching
+          this.active = true;
+          this.dirty = this.lazy; // for lazy watchers
+          this.deps = [];
+          this.newDeps = [];
+          this.depIds = new _Set();
+          this.newDepIds = new _Set();
+          this.expression = expOrFn.toString()
+              ;
+          // parse expression for getter
+          if (typeof expOrFn === 'function') {
+              this.getter = expOrFn;
+          }
+          else {
+              this.getter = parsePath(expOrFn);
+              if (!this.getter) {
+                  this.getter = noop;
+                  warn$2(`Failed watching path: "${expOrFn}" ` +
                       'Watcher only accepts simple dot-delimited paths. ' +
                       'For full control, use a function instead.', vm);
+              }
           }
+          this.value = this.lazy
+              ? undefined
+              : this.get();
       }
-      this.value = this.lazy ? undefined : this.get();
-  };
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  Watcher.prototype.get = function get () {
-      pushTarget(this);
-      var value;
-      var vm = this.vm;
-      try {
-          value = this.getter.call(vm, vm);
-      }
-      catch (e) {
-          if (this.user) {
-              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+      /**
+       * Evaluate the getter, and re-collect dependencies.
+       */
+      get() {
+          pushTarget(this);
+          let value;
+          const vm = this.vm;
+          try {
+              value = this.getter.call(vm, vm);
           }
-          else {
-              throw e;
+          catch (e) {
+              if (this.user) {
+                  // @ts-expect-error e is unknown, should we cast or any?
+                  handleError(e, vm, `getter for watcher "${this.expression}"`);
+              }
+              else {
+                  throw e;
+              }
           }
-      }
-      finally {
-          // "touch" every property so they are all tracked as
-          // dependencies for deep watching
-          if (this.deep) {
-              traverse(value);
+          finally {
+              // "touch" every property so they are all tracked as
+              // dependencies for deep watching
+              if (this.deep) {
+                  traverse(value);
+              }
+              popTarget();
+              this.cleanupDeps();
           }
-          popTarget();
-          this.cleanupDeps();
+          return value;
       }
-      return value;
-  };
-  /**
-   * Add a dependency to this directive.
-   */
-  Watcher.prototype.addDep = function addDep (dep) {
-      var id = dep.id;
-      if (!this.newDepIds.has(id)) {
-          this.newDepIds.add(id);
-          this.newDeps.push(dep);
-          if (!this.depIds.has(id)) {
-              dep.addSub(this);
+      /**
+       * Add a dependency to this directive.
+       */
+      addDep(dep) {
+          const id = dep.id;
+          if (!this.newDepIds.has(id)) {
+              this.newDepIds.add(id);
+              this.newDeps.push(dep);
+              if (!this.depIds.has(id)) {
+                  dep.addSub(this);
+              }
           }
       }
-  };
-  /**
-   * Clean up for dependency collection.
-   */
-  Watcher.prototype.cleanupDeps = function cleanupDeps () {
-      var i = this.deps.length;
-      while (i--) {
-          var dep = this.deps[i];
-          if (!this.newDepIds.has(dep.id)) {
-              dep.removeSub(this);
-          }
-      }
-      var tmp = this.depIds;
-      this.depIds = this.newDepIds;
-      this.newDepIds = tmp;
-      this.newDepIds.clear();
-      tmp = this.deps;
-      this.deps = this.newDeps;
-      this.newDeps = tmp;
-      this.newDeps.length = 0;
-  };
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  Watcher.prototype.update = function update () {
-      /* istanbul ignore else */
-      if (this.lazy) {
-          this.dirty = true;
-      }
-      else if (this.sync) {
-          this.run();
+      /**
+       * Clean up for dependency collection.
+       */
+      cleanupDeps() {
+          let i = this.deps.length;
+          while (i--) {
+              const dep = this.deps[i];
+              if (!this.newDepIds.has(dep.id)) {
+                  dep.removeSub(this);
+              }
+          }
+          let tmp = this.depIds;
+          this.depIds = this.newDepIds;
+          this.newDepIds = tmp;
+          this.newDepIds.clear();
+          tmp = this.deps;
+          this.deps = this.newDeps;
+          this.newDeps = tmp;
+          this.newDeps.length = 0;
       }
-      else {
-          queueWatcher(this);
+      /**
+       * Subscriber interface.
+       * Will be called when a dependency changes.
+       */
+      update() {
+          /* istanbul ignore else */
+          if (this.lazy) {
+              this.dirty = true;
+          }
+          else if (this.sync) {
+              this.run();
+          }
+          else {
+              queueWatcher(this);
+          }
       }
-  };
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  Watcher.prototype.run = function run () {
-      if (this.active) {
-          var value = this.get();
-          if (value !== this.value ||
-              // Deep watchers and watchers on Object/Arrays should fire even
-              // when the value is the same, because the value may
-              // have mutated.
-              isObject(value) ||
-              this.deep) {
-              // set new value
-              var oldValue = this.value;
-              this.value = value;
-              if (this.user) {
-                  try {
-                      this.cb.call(this.vm, value, oldValue);
+      /**
+       * Scheduler job interface.
+       * Will be called by the scheduler.
+       */
+      run() {
+          if (this.active) {
+              const value = this.get();
+              if (value !== this.value ||
+                  // Deep watchers and watchers on Object/Arrays should fire even
+                  // when the value is the same, because the value may
+                  // have mutated.
+                  isObject(value) ||
+                  this.deep) {
+                  // set new value
+                  const oldValue = this.value;
+                  this.value = value;
+                  if (this.user) {
+                      const info = `callback for watcher "${this.expression}"`;
+                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                   }
-                  catch (e) {
-                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  else {
+                      this.cb.call(this.vm, value, oldValue);
                   }
               }
-              else {
-                  this.cb.call(this.vm, value, oldValue);
-              }
           }
       }
-  };
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  Watcher.prototype.evaluate = function evaluate () {
-      this.value = this.get();
-      this.dirty = false;
-  };
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  Watcher.prototype.depend = function depend () {
-      var i = this.deps.length;
-      while (i--) {
-          this.deps[i].depend();
+      /**
+       * Evaluate the value of the watcher.
+       * This only gets called for lazy watchers.
+       */
+      evaluate() {
+          this.value = this.get();
+          this.dirty = false;
       }
-  };
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  Watcher.prototype.teardown = function teardown () {
-      if (this.active) {
-          // remove self from vm's watcher list
-          // this is a somewhat expensive operation so we skip it
-          // if the vm is being destroyed.
-          if (!this.vm._isBeingDestroyed) {
-              remove$2(this.vm._watchers, this);
-          }
-          var i = this.deps.length;
+      /**
+       * Depend on all deps collected by this watcher.
+       */
+      depend() {
+          let i = this.deps.length;
           while (i--) {
-              this.deps[i].removeSub(this);
+              this.deps[i].depend();
           }
-          this.active = false;
       }
-  };
+      /**
+       * Remove self from all dependencies' subscriber list.
+       */
+      teardown() {
+          if (this.active) {
+              // remove self from vm's watcher list
+              // this is a somewhat expensive operation so we skip it
+              // if the vm is being destroyed.
+              if (!this.vm._isBeingDestroyed) {
+                  remove$2(this.vm._watchers, this);
+              }
+              let i = this.deps.length;
+              while (i--) {
+                  this.deps[i].removeSub(this);
+              }
+              this.active = false;
+          }
+      }
+  }
 
-  var sharedPropertyDefinition = {
+  const sharedPropertyDefinition = {
       enumerable: true,
       configurable: true,
       get: noop,
@@ -4039,11 +4058,11 @@
   }
   function initState(vm) {
       vm._watchers = [];
-      var opts = vm.$options;
+      const opts = vm.$options;
       if (opts.props)
-          { initProps$1(vm, opts.props); }
+          initProps$1(vm, opts.props);
       if (opts.methods)
-          { initMethods(vm, opts.methods); }
+          initMethods(vm, opts.methods);
       if (opts.data) {
           initData(vm);
       }
@@ -4051,38 +4070,38 @@
           observe((vm._data = {}), true /* asRootData */);
       }
       if (opts.computed)
-          { initComputed$1(vm, opts.computed); }
+          initComputed$1(vm, opts.computed);
       if (opts.watch && opts.watch !== nativeWatch) {
           initWatch(vm, opts.watch);
       }
   }
   function initProps$1(vm, propsOptions) {
-      var propsData = vm.$options.propsData || {};
-      var props = (vm._props = {});
+      const propsData = vm.$options.propsData || {};
+      const props = (vm._props = {});
       // cache prop keys so that future props updates can iterate using Array
       // instead of dynamic object key enumeration.
-      var keys = (vm.$options._propKeys = []);
-      var isRoot = !vm.$parent;
+      const keys = (vm.$options._propKeys = []);
+      const isRoot = !vm.$parent;
       // root instance props should be converted
       if (!isRoot) {
           toggleObserving(false);
       }
-      var loop = function ( key ) {
+      for (const key in propsOptions) {
           keys.push(key);
-          var value = validateProp(key, propsOptions, propsData, vm);
+          const value = validateProp(key, propsOptions, propsData, vm);
           /* istanbul ignore else */
           {
-              var hyphenatedKey = hyphenate(key);
+              const hyphenatedKey = hyphenate(key);
               if (isReservedAttribute(hyphenatedKey) ||
                   config.isReservedAttr(hyphenatedKey)) {
-                  warn$2(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                  warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
               }
-              defineReactive(props, key, value, function () {
+              defineReactive(props, key, value, () => {
                   if (!isRoot && !isUpdatingChildComponent) {
-                      warn$2("Avoid mutating a prop directly since the value will be " +
-                          "overwritten whenever the parent component re-renders. " +
-                          "Instead, use a data or computed property based on the prop's " +
-                          "value. Prop being mutated: \"" + key + "\"", vm);
+                      warn$2(`Avoid mutating a prop directly since the value will be ` +
+                          `overwritten whenever the parent component re-renders. ` +
+                          `Instead, use a data or computed property based on the prop's ` +
+                          `value. Prop being mutated: "${key}"`, vm);
                   }
               });
           }
@@ -4090,39 +4109,37 @@
           // during Vue.extend(). We only need to proxy props defined at
           // instantiation here.
           if (!(key in vm)) {
-              proxy(vm, "_props", key);
+              proxy(vm, `_props`, key);
           }
-      };
-
-      for (var key in propsOptions) loop( key );
+      }
       toggleObserving(true);
   }
   function initData(vm) {
-      var data = vm.$options.data;
-      data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+      let data = vm.$options.data;
+      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
       if (!isPlainObject(data)) {
           data = {};
-          warn$2('data functions should return an object:\n' +
-                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+          warn$2("data functions should return an object:\n" +
+                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
       }
       // proxy data on instance
-      var keys = Object.keys(data);
-      var props = vm.$options.props;
-      var methods = vm.$options.methods;
-      var i = keys.length;
+      const keys = Object.keys(data);
+      const props = vm.$options.props;
+      const methods = vm.$options.methods;
+      let i = keys.length;
       while (i--) {
-          var key = keys[i];
+          const key = keys[i];
           {
               if (methods && hasOwn(methods, key)) {
-                  warn$2(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                  warn$2(`Method "${key}" has already been defined as a data property.`, vm);
               }
           }
           if (props && hasOwn(props, key)) {
-              warn$2("The data property \"" + key + "\" is already declared as a prop. " +
-                      "Use prop default value instead.", vm);
+              warn$2(`The data property "${key}" is already declared as a prop. ` +
+                      `Use prop default value instead.`, vm);
           }
           else if (!isReserved(key)) {
-              proxy(vm, "_data", key);
+              proxy(vm, `_data`, key);
           }
       }
       // observe data
@@ -4135,24 +4152,24 @@
           return data.call(vm, vm);
       }
       catch (e) {
-          handleError(e, vm, "data()");
+          handleError(e, vm, `data()`);
           return {};
       }
       finally {
           popTarget();
       }
   }
-  var computedWatcherOptions = { lazy: true };
+  const computedWatcherOptions = { lazy: true };
   function initComputed$1(vm, computed) {
       // $flow-disable-line
-      var watchers = (vm._computedWatchers = Object.create(null));
+      const watchers = (vm._computedWatchers = Object.create(null));
       // computed properties are just getters during SSR
-      var isSSR = isServerRendering();
-      for (var key in computed) {
-          var userDef = computed[key];
-          var getter = typeof userDef === 'function' ? userDef : userDef.get;
+      const isSSR = isServerRendering();
+      for (const key in computed) {
+          const userDef = computed[key];
+          const getter = typeof userDef === "function" ? userDef : userDef.get;
           if (getter == null) {
-              warn$2(("Getter is missing for computed property \"" + key + "\"."), vm);
+              warn$2(`Getter is missing for computed property "${key}".`, vm);
           }
           if (!isSSR) {
               // create internal watcher for the computed property.
@@ -4166,17 +4183,20 @@
           }
           else {
               if (key in vm.$data) {
-                  warn$2(("The computed property \"" + key + "\" is already defined in data."), vm);
+                  warn$2(`The computed property "${key}" is already defined in data.`, vm);
               }
               else if (vm.$options.props && key in vm.$options.props) {
-                  warn$2(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                  warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+              }
+              else if (vm.$options.methods && key in vm.$options.methods) {
+                  warn$2(`The computed property "${key}" is already defined as a method.`, vm);
               }
           }
       }
   }
   function defineComputed(target, key, userDef) {
-      var shouldCache = !isServerRendering();
-      if (typeof userDef === 'function') {
+      const shouldCache = !isServerRendering();
+      if (typeof userDef === "function") {
           sharedPropertyDefinition.get = shouldCache
               ? createComputedGetter(key)
               : createGetterInvoker(userDef);
@@ -4192,14 +4212,14 @@
       }
       if (sharedPropertyDefinition.set === noop) {
           sharedPropertyDefinition.set = function () {
-              warn$2(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+              warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
           };
       }
       Object.defineProperty(target, key, sharedPropertyDefinition);
   }
   function createComputedGetter(key) {
       return function computedGetter() {
-          var watcher = this._computedWatchers && this._computedWatchers[key];
+          const watcher = this._computedWatchers && this._computedWatchers[key];
           if (watcher) {
               if (watcher.dirty) {
                   watcher.evaluate();
@@ -4217,29 +4237,30 @@
       };
   }
   function initMethods(vm, methods) {
-      var props = vm.$options.props;
-      for (var key in methods) {
+      const props = vm.$options.props;
+      for (const key in methods) {
           {
-              if (typeof methods[key] !== 'function') {
-                  warn$2("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                      "Did you reference the function correctly?", vm);
+              if (typeof methods[key] !== "function") {
+                  warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                      `Did you reference the function correctly?`, vm);
               }
               if (props && hasOwn(props, key)) {
-                  warn$2(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                  warn$2(`Method "${key}" has already been defined as a prop.`, vm);
               }
               if (key in vm && isReserved(key)) {
-                  warn$2("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                      "Avoid defining component methods that start with _ or $.");
+                  warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                      `Avoid defining component methods that start with _ or $.`);
               }
           }
-          vm[key] = typeof methods[key] !== 'function' ? noop : bind$1(methods[key], vm);
+          vm[key] =
+              typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
       }
   }
   function initWatch(vm, watch) {
-      for (var key in watch) {
-          var handler = watch[key];
+      for (const key in watch) {
+          const handler = watch[key];
           if (Array.isArray(handler)) {
-              for (var i = 0; i < handler.length; i++) {
+              for (let i = 0; i < handler.length; i++) {
                   createWatcher(vm, key, handler[i]);
               }
           }
@@ -4253,7 +4274,7 @@
           options = handler;
           handler = handler.handler;
       }
-      if (typeof handler === 'string') {
+      if (typeof handler === "string") {
           handler = vm[handler];
       }
       return vm.$watch(expOrFn, handler, options);
@@ -4262,43 +4283,39 @@
       // flow somehow has problems with directly declared definition object
       // when using Object.defineProperty, so we have to procedurally build up
       // the object here.
-      var dataDef = {};
+      const dataDef = {};
       dataDef.get = function () {
           return this._data;
       };
-      var propsDef = {};
+      const propsDef = {};
       propsDef.get = function () {
           return this._props;
       };
       {
           dataDef.set = function () {
-              warn$2('Avoid replacing instance root $data. ' +
-                  'Use nested data properties instead.', this);
+              warn$2("Avoid replacing instance root $data. " +
+                  "Use nested data properties instead.", this);
           };
           propsDef.set = function () {
-              warn$2("$props is readonly.", this);
+              warn$2(`$props is readonly.`, this);
           };
       }
-      Object.defineProperty(Vue.prototype, '$data', dataDef);
-      Object.defineProperty(Vue.prototype, '$props', propsDef);
+      Object.defineProperty(Vue.prototype, "$data", dataDef);
+      Object.defineProperty(Vue.prototype, "$props", propsDef);
       Vue.prototype.$set = set;
       Vue.prototype.$delete = del;
       Vue.prototype.$watch = function (expOrFn, cb, options) {
-          var vm = this;
+          const vm = this;
           if (isPlainObject(cb)) {
               return createWatcher(vm, expOrFn, cb, options);
           }
           options = options || {};
           options.user = true;
-          var watcher = new Watcher(vm, expOrFn, cb, options);
+          const watcher = new Watcher(vm, expOrFn, cb, options);
           if (options.immediate) {
+              const info = `callback for immediate watcher "${watcher.expression}"`;
               pushTarget();
-              try {
-                  cb.call(vm, watcher.value);
-              }
-              catch (error) {
-                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-              }
+              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
               popTarget();
           }
           return function unwatchFn() {
@@ -4307,17 +4324,17 @@
       };
   }
 
-  var uid = 0;
+  let uid = 0;
   function initMixin$1(Vue) {
       Vue.prototype._init = function (options) {
-          var vm = this;
+          const vm = this;
           // a uid
           vm._uid = uid++;
-          var startTag, endTag;
+          let startTag, endTag;
           /* istanbul ignore if */
           if (config.performance && mark) {
-              startTag = "vue-perf-start:" + (vm._uid);
-              endTag = "vue-perf-end:" + (vm._uid);
+              startTag = `vue-perf-start:${vm._uid}`;
+              endTag = `vue-perf-end:${vm._uid}`;
               mark(startTag);
           }
           // a flag to avoid this being observed
@@ -4350,7 +4367,7 @@
           if (config.performance && mark) {
               vm._name = formatComponentName(vm, false);
               mark(endTag);
-              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+              measure(`vue ${vm._name} init`, startTag, endTag);
           }
           if (vm.$options.el) {
               vm.$mount(vm.$options.el);
@@ -4358,13 +4375,12 @@
       };
   }
   function initInternalComponent(vm, options) {
-      // @ts-ignore
-      var opts = (vm.$options = Object.create(vm.constructor.options));
+      const opts = (vm.$options = Object.create(vm.constructor.options));
       // doing this because it's faster than dynamic enumeration.
-      var parentVnode = options._parentVnode;
+      const parentVnode = options._parentVnode;
       opts.parent = options.parent;
       opts._parentVnode = parentVnode;
-      var vnodeComponentOptions = parentVnode.componentOptions;
+      const vnodeComponentOptions = parentVnode.componentOptions;
       opts.propsData = vnodeComponentOptions.propsData;
       opts._parentListeners = vnodeComponentOptions.listeners;
       opts._renderChildren = vnodeComponentOptions.children;
@@ -4375,16 +4391,16 @@
       }
   }
   function resolveConstructorOptions(Ctor) {
-      var options = Ctor.options;
+      let options = Ctor.options;
       if (Ctor.super) {
-          var superOptions = resolveConstructorOptions(Ctor.super);
-          var cachedSuperOptions = Ctor.superOptions;
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
           if (superOptions !== cachedSuperOptions) {
               // super option changed,
               // need to resolve new options.
               Ctor.superOptions = superOptions;
               // check if there are any late-modified/attached options (#4976)
-              var modifiedOptions = resolveModifiedOptions(Ctor);
+              const modifiedOptions = resolveModifiedOptions(Ctor);
               // update base extend options
               if (modifiedOptions) {
                   extend(Ctor.extendOptions, modifiedOptions);
@@ -4398,13 +4414,13 @@
       return options;
   }
   function resolveModifiedOptions(Ctor) {
-      var modified;
-      var latest = Ctor.options;
-      var sealed = Ctor.sealedOptions;
-      for (var key in latest) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
           if (latest[key] !== sealed[key]) {
               if (!modified)
-                  { modified = {}; }
+                  modified = {};
               modified[key] = latest[key];
           }
       }
@@ -4413,29 +4429,29 @@
 
   function Vue(options) {
       if (!(this instanceof Vue)) {
-          warn$2('Vue is a constructor and should be called with the `new` keyword');
+          warn$2("Vue is a constructor and should be called with the `new` keyword");
       }
       this._init(options);
   }
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   initMixin$1(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   stateMixin(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   eventsMixin(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   lifecycleMixin(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   renderMixin(Vue);
 
   function initUse(Vue) {
       Vue.use = function (plugin) {
-          var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
           if (installedPlugins.indexOf(plugin) > -1) {
               return this;
           }
           // additional parameters
-          var args = toArray(arguments, 1);
+          const args = toArray(arguments, 1);
           args.unshift(this);
           if (typeof plugin.install === 'function') {
               plugin.install.apply(plugin, args);
@@ -4462,23 +4478,23 @@
        * constructors" for prototypal inheritance and cache them.
        */
       Vue.cid = 0;
-      var cid = 1;
+      let cid = 1;
       /**
        * Class inheritance
        */
       Vue.extend = function (extendOptions) {
           extendOptions = extendOptions || {};
-          var Super = this;
-          var SuperId = Super.cid;
-          var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          const Super = this;
+          const SuperId = Super.cid;
+          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
           if (cachedCtors[SuperId]) {
               return cachedCtors[SuperId];
           }
-          var name = extendOptions.name || Super.options.name;
+          const name = extendOptions.name || Super.options.name;
           if (name) {
               validateComponentName(name);
           }
-          var Sub = function VueComponent(options) {
+          const Sub = function VueComponent(options) {
               this._init(options);
           };
           Sub.prototype = Object.create(Super.prototype);
@@ -4520,14 +4536,14 @@
       };
   }
   function initProps(Comp) {
-      var props = Comp.options.props;
-      for (var key in props) {
-          proxy(Comp.prototype, "_props", key);
+      const props = Comp.options.props;
+      for (const key in props) {
+          proxy(Comp.prototype, `_props`, key);
       }
   }
   function initComputed(Comp) {
-      var computed = Comp.options.computed;
-      for (var key in computed) {
+      const computed = Comp.options.computed;
+      for (const key in computed) {
           defineComputed(Comp.prototype, key, computed[key]);
       }
   }
@@ -4536,7 +4552,7 @@
       /**
        * Create asset registration methods.
        */
-      ASSET_TYPES.forEach(function (type) {
+      ASSET_TYPES.forEach((type) => {
           // @ts-expect-error function is not exact same type
           Vue[type] = function (id, definition) {
               if (!definition) {
@@ -4562,6 +4578,7 @@
       });
   }
 
+  /* @flow */
   function getComponentName(opts) {
       return opts && (opts.Ctor.options.name || opts.tag);
   }
@@ -4569,8 +4586,8 @@
       if (Array.isArray(pattern)) {
           return pattern.indexOf(name) > -1;
       }
-      else if (typeof pattern === 'string') {
-          return pattern.split(',').indexOf(name) > -1;
+      else if (typeof pattern === "string") {
+          return pattern.split(",").indexOf(name) > -1;
       }
       else if (isRegExp(pattern)) {
           return pattern.test(name);
@@ -4579,13 +4596,11 @@
       return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache;
-      var keys = keepAliveInstance.keys;
-      var _vnode = keepAliveInstance._vnode;
-      for (var key in cache) {
-          var cachedNode = cache[key];
-          if (cachedNode) {
-              var name = getComponentName(cachedNode.componentOptions);
+      const { cache, keys, _vnode } = keepAliveInstance;
+      for (const key in cache) {
+          const entry = cache[key];
+          if (entry) {
+              const name = entry.name;
               if (name && !filter(name)) {
                   pruneCacheEntry(cache, key, keys, _vnode);
               }
@@ -4593,53 +4608,72 @@
       }
   }
   function pruneCacheEntry(cache, key, keys, current) {
-      var cached = cache[key];
-      if (cached && (!current || cached.tag !== current.tag)) {
-          //@ts-expect-error has void type
-          cached.componentInstance.$destroy();
+      const entry = cache[key];
+      if (entry && (!current || entry.tag !== current.tag)) {
+          // @ts-expect-error can be undefined
+          entry.componentInstance.$destroy();
       }
       cache[key] = null;
       remove$2(keys, key);
   }
-  var patternTypes = [String, RegExp, Array];
-  // TODO use defineComponent
+  const patternTypes = [String, RegExp, Array];
+  // TODO defineComponent
   var KeepAlive = {
-      name: 'keep-alive',
+      name: "keep-alive",
       abstract: true,
       props: {
           include: patternTypes,
           exclude: patternTypes,
           max: [String, Number],
       },
-      created: function created() {
+      methods: {
+          cacheVNode() {
+              const { cache, keys, vnodeToCache, keyToCache } = this;
+              if (vnodeToCache) {
+                  const { tag, componentInstance, componentOptions } = vnodeToCache;
+                  cache[keyToCache] = {
+                      name: getComponentName(componentOptions),
+                      tag,
+                      componentInstance,
+                  };
+                  keys.push(keyToCache);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+                  this.vnodeToCache = null;
+              }
+          },
+      },
+      created() {
           this.cache = Object.create(null);
           this.keys = [];
       },
-      destroyed: function destroyed() {
-          for (var key in this.cache) {
+      destroyed() {
+          for (const key in this.cache) {
               pruneCacheEntry(this.cache, key, this.keys);
           }
       },
-      mounted: function mounted() {
-          var this$1 = this;
-
-          this.$watch('include', function (val) {
-              pruneCache(this$1, function (name) { return matches(val, name); });
+      mounted() {
+          this.cacheVNode();
+          this.$watch("include", (val) => {
+              pruneCache(this, (name) => matches(val, name));
           });
-          this.$watch('exclude', function (val) {
-              pruneCache(this$1, function (name) { return !matches(val, name); });
+          this.$watch("exclude", (val) => {
+              pruneCache(this, (name) => !matches(val, name));
           });
       },
-      render: function render() {
-          var slot = this.$slots.default;
-          var vnode = getFirstComponentChild(slot);
-          var componentOptions = vnode && vnode.componentOptions;
+      updated() {
+          this.cacheVNode();
+      },
+      render() {
+          const slot = this.$slots.default;
+          const vnode = getFirstComponentChild(slot);
+          const componentOptions = vnode && vnode.componentOptions;
           if (componentOptions) {
               // check pattern
-              var name = getComponentName(componentOptions);
-              var ref = this;
-              var include = ref.include;
-              var exclude = ref.exclude;
+              const name = getComponentName(componentOptions);
+              const { include, exclude } = this;
               if (
               // not included
               (include && (!name || !matches(include, name))) ||
@@ -4647,14 +4681,12 @@
                   (exclude && name && matches(exclude, name))) {
                   return vnode;
               }
-              var ref$1 = this;
-              var cache = ref$1.cache;
-              var keys = ref$1.keys;
-              var key = vnode.key == null
+              const { cache, keys } = this;
+              const key = vnode.key == null
                   ? // same constructor may get registered as different local components
                       // so cid alone is not enough (#3269)
                       componentOptions.Ctor.cid +
-                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
                   : vnode.key;
               if (cache[key]) {
                   vnode.componentInstance = cache[key].componentInstance;
@@ -4663,13 +4695,11 @@
                   keys.push(key);
               }
               else {
-                  cache[key] = vnode;
-                  keys.push(key);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
+                  // delay setting the cache until update
+                  this.vnodeToCache = vnode;
+                  this.keyToCache = key;
               }
+              // @ts-expect-error can vnode.data can be undefined
               vnode.data.keepAlive = true;
           }
           return vnode || (slot && slot[0]);
@@ -4677,15 +4707,15 @@
   };
 
   var builtInComponents = {
-      KeepAlive: KeepAlive,
+      KeepAlive,
   };
 
   function initGlobalAPI(Vue) {
       // config
-      var configDef = {};
-      configDef.get = function () { return config; };
+      const configDef = {};
+      configDef.get = () => config;
       {
-          configDef.set = function () {
+          configDef.set = () => {
               warn$2('Do not replace the Vue.config object, set individual fields instead.');
           };
       }
@@ -4695,20 +4725,20 @@
       // them unless you are aware of the risk.
       Vue.util = {
           warn: warn$2,
-          extend: extend,
-          mergeOptions: mergeOptions,
-          defineReactive: defineReactive,
+          extend,
+          mergeOptions,
+          defineReactive,
       };
       Vue.set = set;
       Vue.delete = del;
       Vue.nextTick = nextTick;
       // 2.6 explicit observable API
-      Vue.observable = function (obj) {
+      Vue.observable = (obj) => {
           observe(obj);
           return obj;
       };
       Vue.options = Object.create(null);
-      ASSET_TYPES.forEach(function (type) {
+      ASSET_TYPES.forEach((type) => {
           Vue.options[type + 's'] = Object.create(null);
       });
       // this is used to identify the "base" constructor to extend all plain-object
@@ -4726,7 +4756,7 @@
       get: isServerRendering,
   });
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function get() {
+      get() {
           /* istanbul ignore next */
           return this.$vnode && this.$vnode.ssrContext;
       },
@@ -4735,22 +4765,22 @@
   Object.defineProperty(Vue, 'FunctionalRenderContext', {
       value: FunctionalRenderContext,
   });
-  Vue.version = '2.6.12';
+  Vue.version = '2.6.14';
 
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap('style,class');
+  const isReservedAttr = makeMap('style,class');
   // attributes that should be using props for binding
-  var acceptValue$1 = makeMap('input,textarea,option,select,progress');
-  var mustUseProp$1 = function (tag, type, attr) {
-      return ((attr === 'value' && acceptValue$1(tag) && type !== 'button') ||
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
           (attr === 'selected' && tag === 'option') ||
           (attr === 'checked' && tag === 'input') ||
           (attr === 'muted' && tag === 'video'));
   };
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  var convertEnumeratedValue = function (key, value) {
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
       return isFalsyAttrValue(value) || value === 'false'
           ? 'false'
           : // allow arbitrary string value for contenteditable
@@ -4758,33 +4788,34 @@
                   ? value
                   : 'true';
   };
-  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
       'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
       'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
       'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
       'required,reversed,scoped,seamless,selected,sortable,' +
       'truespeed,typemustmatch,visible');
-  var xlinkNS = 'http://www.w3.org/1999/xlink';
-  var isXlink = function (name) {
+  const xlinkNS = 'http://www.w3.org/1999/xlink';
+  const isXlink = (name) => {
       return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
   };
-  var getXlinkProp = function (name) {
+  const getXlinkProp = (name) => {
       return isXlink(name) ? name.slice(6, name.length) : '';
   };
-  var isFalsyAttrValue = function (val) {
+  const isFalsyAttrValue = (val) => {
       return val == null || val === false;
   };
 
   function genClassForVnode(vnode) {
-      var data = vnode.data;
-      var parentNode = vnode;
-      var childNode = vnode;
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
       while (isDef(childNode.componentInstance)) {
           childNode = childNode.componentInstance._vnode;
           if (childNode && childNode.data) {
               data = mergeClassData(childNode.data, data);
           }
       }
+      // @ts-expect-error parentNode.parent not VNodeWithData
       while (isDef((parentNode = parentNode.parent))) {
           if (parentNode && parentNode.data) {
               data = mergeClassData(data, parentNode.data);
@@ -4822,34 +4853,34 @@
       return '';
   }
   function stringifyArray(value) {
-      var res = '';
-      var stringified;
-      for (var i = 0, l = value.length; i < l; i++) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
           if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
               if (res)
-                  { res += ' '; }
+                  res += ' ';
               res += stringified;
           }
       }
       return res;
   }
   function stringifyObject(value) {
-      var res = '';
-      for (var key in value) {
+      let res = '';
+      for (const key in value) {
           if (value[key]) {
               if (res)
-                  { res += ' '; }
+                  res += ' ';
               res += key;
           }
       }
       return res;
   }
 
-  var namespaceMap = {
+  const namespaceMap = {
       svg: 'http://www.w3.org/2000/svg',
       math: 'http://www.w3.org/1998/Math/MathML',
   };
-  var isHTMLTag$1 = makeMap('html,body,base,head,link,meta,style,title,' +
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
       'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
       'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4862,14 +4893,15 @@
       'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG$1 = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
       'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
       'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  var isReservedTag$1 = function (tag) {
-      return isHTMLTag$1(tag) || isSVG$1(tag);
+  const isPreTag = (tag) => tag === 'pre';
+  const isReservedTag = (tag) => {
+      return isHTMLTag(tag) || isSVG(tag);
   };
-  function getTagNamespace$1(tag) {
-      if (isSVG$1(tag)) {
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
           return 'svg';
       }
       // basic support for MathML
@@ -4878,13 +4910,13 @@
           return 'math';
       }
   }
-  var unknownElementCache = Object.create(null);
+  const unknownElementCache = Object.create(null);
   function isUnknownElement(tag) {
       /* istanbul ignore if */
       if (!inBrowser) {
           return true;
       }
-      if (isReservedTag$1(tag)) {
+      if (isReservedTag(tag)) {
           return false;
       }
       tag = tag.toLowerCase();
@@ -4892,7 +4924,7 @@
       if (unknownElementCache[tag] != null) {
           return unknownElementCache[tag];
       }
-      var el = document.createElement(tag);
+      const el = document.createElement(tag);
       if (tag.indexOf('-') > -1) {
           // http://stackoverflow.com/a/28210364/1070244
           return (unknownElementCache[tag] =
@@ -4903,14 +4935,14 @@
           return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
       }
   }
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+  const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
   /**
    * Query an element selector if it's not an element already.
    */
-  function query$1(el) {
+  function query(el) {
       if (typeof el === 'string') {
-          var selected = document.querySelector(el);
+          const selected = document.querySelector(el);
           if (!selected) {
               warn$2('Cannot find element: ' + el);
               return document.createElement('div');
@@ -4923,7 +4955,7 @@
   }
 
   function createElement(tagName, vnode) {
-      var elm = document.createElement(tagName);
+      const elm = document.createElement(tagName);
       if (tagName !== 'select') {
           return elm;
       }
@@ -4985,46 +5017,43 @@
     setStyleScope: setStyleScope
   });
 
-  var ref$1 = {
-      create: function create(_, vnode) {
+  var ref = {
+      create(_, vnode) {
           registerRef(vnode);
       },
-      update: function update(oldVnode, vnode) {
+      update(oldVnode, vnode) {
           if (oldVnode.data.ref !== vnode.data.ref) {
               registerRef(oldVnode, true);
               registerRef(vnode);
           }
       },
-      destroy: function destroy(vnode) {
+      destroy(vnode) {
           registerRef(vnode, true);
       },
   };
   function registerRef(vnode, isRemoval) {
-      var key = vnode.data.ref;
+      const key = vnode.data.ref;
       if (!isDef(key))
-          { return; }
-      var vm = vnode.context;
-      var ref = vnode.componentInstance || vnode.elm;
-      var refs = vm.$refs;
+          return;
+      const vm = vnode.context;
+      const ref = vnode.componentInstance || vnode.elm;
+      const refs = vm.$refs;
+      const obj = refs[key];
       if (isRemoval) {
-          if (Array.isArray(refs[key])) {
-              // @ts-expect-error invalid typings
-              remove$2(refs[key], ref);
+          if (Array.isArray(obj)) {
+              remove$2(obj, ref);
           }
-          else if (refs[key] === ref) {
+          else if (obj === ref) {
               refs[key] = undefined;
           }
       }
       else {
-          // @ts-expect-error invalid typings
           if (vnode.data.refInFor) {
-              if (!Array.isArray(refs[key])) {
+              if (!Array.isArray(obj)) {
                   refs[key] = [ref];
-                  // @ts-expect-error invalid typings
               }
-              else if (refs[key].indexOf(ref) < 0) {
-                  // @ts-expect-error invalid typings
-                  refs[key].push(ref);
+              else if (obj.indexOf(ref) < 0) {
+                  obj.push(ref);
               }
           }
           else {
@@ -5044,41 +5073,38 @@
    * Not type-checking this because this file is perf-critical and the cost
    * of making flow understand it is not worth it.
    */
-  var emptyNode = new VNode('', {}, []);
-  var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+  const emptyNode = new VNode('', {}, []);
+  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
   function sameVnode(a, b) {
       return (a.key === b.key &&
-          ((a.tag === b.tag &&
-              a.isComment === b.isComment &&
-              isDef(a.data) === isDef(b.data) &&
-              sameInputType(a, b)) ||
-              (isTrue(a.isAsyncPlaceholder) &&
-                  a.asyncFactory === b.asyncFactory &&
-                  isUndef(b.asyncFactory.error))));
+          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+          a.isComment === b.isComment &&
+          isDef(a.data) === isDef(b.data) &&
+          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+          isUndef(b.asyncFactory.error))));
   }
   function sameInputType(a, b) {
       if (a.tag !== 'input')
-          { return true; }
-      var i;
-      var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+          return true;
+      let i;
+      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
       return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
   }
   function createKeyToOldIdx(children, beginIdx, endIdx) {
-      var i, key;
-      var map = {};
+      let i, key;
+      const map = {};
       for (i = beginIdx; i <= endIdx; ++i) {
           key = children[i].key;
           if (isDef(key))
-              { map[key] = i; }
+              map[key] = i;
       }
       return map;
   }
   function createPatchFunction(backend) {
-      var i, j;
-      var cbs = {};
-      var modules = backend.modules;
-      var nodeOps = backend.nodeOps;
+      let i, j;
+      const cbs = {};
+      const { modules, nodeOps } = backend;
       for (i = 0; i < hooks.length; ++i) {
           cbs[hooks[i]] = [];
           for (j = 0; j < modules.length; ++j) {
@@ -5100,7 +5126,7 @@
           return remove;
       }
       function removeNode(el) {
-          var parent = nodeOps.parentNode(el);
+          const parent = nodeOps.parentNode(el);
           // element may have already been removed due to v-html / v-text
           if (isDef(parent)) {
               nodeOps.removeChild(parent, el);
@@ -5110,14 +5136,14 @@
           return (!inVPre &&
               !vnode.ns &&
               !(config.ignoredElements.length &&
-                  config.ignoredElements.some(function (ignore) {
+                  config.ignoredElements.some((ignore) => {
                       return isRegExp(ignore)
                           ? ignore.test(vnode.tag)
                           : ignore === vnode.tag;
                   })) &&
               config.isUnknownElement(vnode.tag));
       }
-      var creatingElmInVPre = 0;
+      let creatingElmInVPre = 0;
       function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
           if (isDef(vnode.elm) && isDef(ownerArray)) {
               // This vnode was used in a previous render!
@@ -5131,9 +5157,9 @@
           if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
               return;
           }
-          var data = vnode.data;
-          var children = vnode.children;
-          var tag = vnode.tag;
+          const data = vnode.data;
+          const children = vnode.children;
+          const tag = vnode.tag;
           if (isDef(tag)) {
               {
                   if (data && data.pre) {
@@ -5173,9 +5199,9 @@
           }
       }
       function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          var i = vnode.data;
+          let i = vnode.data;
           if (isDef(i)) {
-              var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
               if (isDef((i = i.hook)) && isDef((i = i.init))) {
                   i(vnode, false /* hydrating */);
               }
@@ -5212,12 +5238,12 @@
           }
       }
       function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          var i;
+          let i;
           // hack for #4339: a reactivated component with inner transition
           // does not trigger because the inner node's created hooks are not called
           // again. It's not ideal to involve module-specific logic in here but
           // there doesn't seem to be a better way to do it.
-          var innerNode = vnode;
+          let innerNode = vnode;
           while (innerNode.componentInstance) {
               innerNode = innerNode.componentInstance._vnode;
               if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5249,7 +5275,7 @@
               {
                   checkDuplicateKeys(children);
               }
-              for (var i = 0; i < children.length; ++i) {
+              for (let i = 0; i < children.length; ++i) {
                   createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
               }
           }
@@ -5264,27 +5290,27 @@
           return isDef(vnode.tag);
       }
       function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-              cbs.create[i$1](emptyNode, vnode);
+          for (let i = 0; i < cbs.create.length; ++i) {
+              cbs.create[i](emptyNode, vnode);
           }
           i = vnode.data.hook; // Reuse variable
           if (isDef(i)) {
               if (isDef(i.create))
-                  { i.create(emptyNode, vnode); }
+                  i.create(emptyNode, vnode);
               if (isDef(i.insert))
-                  { insertedVnodeQueue.push(vnode); }
+                  insertedVnodeQueue.push(vnode);
           }
       }
       // set scope id attribute for scoped CSS.
       // this is implemented as a special case to avoid the overhead
       // of going through the normal attribute patching process.
       function setScope(vnode) {
-          var i;
+          let i;
           if (isDef((i = vnode.fnScopeId))) {
               nodeOps.setStyleScope(vnode.elm, i);
           }
           else {
-              var ancestor = vnode;
+              let ancestor = vnode;
               while (ancestor) {
                   if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                       nodeOps.setStyleScope(vnode.elm, i);
@@ -5306,13 +5332,13 @@
           }
       }
       function invokeDestroyHook(vnode) {
-          var i, j;
-          var data = vnode.data;
+          let i, j;
+          const data = vnode.data;
           if (isDef(data)) {
               if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  { i(vnode); }
+                  i(vnode);
               for (i = 0; i < cbs.destroy.length; ++i)
-                  { cbs.destroy[i](vnode); }
+                  cbs.destroy[i](vnode);
           }
           if (isDef((i = vnode.children))) {
               for (j = 0; j < vnode.children.length; ++j) {
@@ -5322,7 +5348,7 @@
       }
       function removeVnodes(vnodes, startIdx, endIdx) {
           for (; startIdx <= endIdx; ++startIdx) {
-              var ch = vnodes[startIdx];
+              const ch = vnodes[startIdx];
               if (isDef(ch)) {
                   if (isDef(ch.tag)) {
                       removeAndInvokeRemoveHook(ch);
@@ -5337,8 +5363,8 @@
       }
       function removeAndInvokeRemoveHook(vnode, rm) {
           if (isDef(rm) || isDef(vnode.data)) {
-              var i;
-              var listeners = cbs.remove.length + 1;
+              let i;
+              const listeners = cbs.remove.length + 1;
               if (isDef(rm)) {
                   // we have a recursively passed down rm callback
                   // increase the listeners count
@@ -5369,19 +5395,19 @@
           }
       }
       function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          var oldStartIdx = 0;
-          var newStartIdx = 0;
-          var oldEndIdx = oldCh.length - 1;
-          var oldStartVnode = oldCh[0];
-          var oldEndVnode = oldCh[oldEndIdx];
-          var newEndIdx = newCh.length - 1;
-          var newStartVnode = newCh[0];
-          var newEndVnode = newCh[newEndIdx];
-          var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          let oldStartIdx = 0;
+          let newStartIdx = 0;
+          let oldEndIdx = oldCh.length - 1;
+          let oldStartVnode = oldCh[0];
+          let oldEndVnode = oldCh[oldEndIdx];
+          let newEndIdx = newCh.length - 1;
+          let newStartVnode = newCh[0];
+          let newEndVnode = newCh[newEndIdx];
+          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
           // removeOnly is a special flag used only by <transition-group>
           // to ensure removed elements stay in correct relative positions
           // during leaving transitions
-          var canMove = !removeOnly;
+          const canMove = !removeOnly;
           {
               checkDuplicateKeys(newCh);
           }
@@ -5420,7 +5446,7 @@
               }
               else {
                   if (isUndef(oldKeyToIdx))
-                      { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
                   idxInOld = isDef(newStartVnode.key)
                       ? oldKeyToIdx[newStartVnode.key]
                       : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
@@ -5453,13 +5479,13 @@
           }
       }
       function checkDuplicateKeys(children) {
-          var seenKeys = {};
-          for (var i = 0; i < children.length; i++) {
-              var vnode = children[i];
-              var key = vnode.key;
+          const seenKeys = {};
+          for (let i = 0; i < children.length; i++) {
+              const vnode = children[i];
+              const key = vnode.key;
               if (isDef(key)) {
                   if (seenKeys[key]) {
-                      warn$2(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                      warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                   }
                   else {
                       seenKeys[key] = true;
@@ -5468,10 +5494,10 @@
           }
       }
       function findIdxInOld(node, oldCh, start, end) {
-          for (var i = start; i < end; i++) {
-              var c = oldCh[i];
+          for (let i = start; i < end; i++) {
+              const c = oldCh[i];
               if (isDef(c) && sameVnode(node, c))
-                  { return i; }
+                  return i;
           }
       }
       function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5482,7 +5508,7 @@
               // clone reused vnode
               vnode = ownerArray[index] = cloneVNode(vnode);
           }
-          var elm = (vnode.elm = oldVnode.elm);
+          const elm = (vnode.elm = oldVnode.elm);
           if (isTrue(oldVnode.isAsyncPlaceholder)) {
               if (isDef(vnode.asyncFactory.resolved)) {
                   hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5503,30 +5529,30 @@
               vnode.componentInstance = oldVnode.componentInstance;
               return;
           }
-          var i;
-          var data = vnode.data;
+          let i;
+          const data = vnode.data;
           if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
               i(oldVnode, vnode);
           }
-          var oldCh = oldVnode.children;
-          var ch = vnode.children;
+          const oldCh = oldVnode.children;
+          const ch = vnode.children;
           if (isDef(data) && isPatchable(vnode)) {
               for (i = 0; i < cbs.update.length; ++i)
-                  { cbs.update[i](oldVnode, vnode); }
+                  cbs.update[i](oldVnode, vnode);
               if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  { i(oldVnode, vnode); }
+                  i(oldVnode, vnode);
           }
           if (isUndef(vnode.text)) {
               if (isDef(oldCh) && isDef(ch)) {
                   if (oldCh !== ch)
-                      { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
               }
               else if (isDef(ch)) {
                   {
                       checkDuplicateKeys(ch);
                   }
                   if (isDef(oldVnode.text))
-                      { nodeOps.setTextContent(elm, ''); }
+                      nodeOps.setTextContent(elm, '');
                   addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
               }
               else if (isDef(oldCh)) {
@@ -5541,7 +5567,7 @@
           }
           if (isDef(data)) {
               if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  { i(oldVnode, vnode); }
+                  i(oldVnode, vnode);
           }
       }
       function invokeInsertHook(vnode, queue, initial) {
@@ -5551,23 +5577,21 @@
               vnode.parent.data.pendingInsert = queue;
           }
           else {
-              for (var i = 0; i < queue.length; ++i) {
+              for (let i = 0; i < queue.length; ++i) {
                   queue[i].data.hook.insert(queue[i]);
               }
           }
       }
-      var hydrationBailed = false;
+      let hydrationBailed = false;
       // list of modules that can skip create hook during hydration because they
       // are already rendered on the client or has no need for initialization
       // Note: style is excluded because it relies on initial clone for future
       // deep updates (#7063).
-      var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
       // Note: this is a browser-only function so we can assume elms are DOM nodes.
       function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          var i;
-          var tag = vnode.tag;
-          var data = vnode.data;
-          var children = vnode.children;
+          let i;
+          const { tag, data, children } = vnode;
           inVPre = inVPre || (data && data.pre);
           vnode.elm = elm;
           if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5582,7 +5606,7 @@
           }
           if (isDef(data)) {
               if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  { i(vnode, true /* hydrating */); }
+                  i(vnode, true /* hydrating */);
               if (isDef((i = vnode.componentInstance))) {
                   // child component. it should have hydrated its own tree.
                   initComponent(vnode, insertedVnodeQueue);
@@ -5614,11 +5638,11 @@
                       }
                       else {
                           // iterate and compare children lists
-                          var childrenMatch = true;
-                          var childNode = elm.firstChild;
-                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                          let childrenMatch = true;
+                          let childNode = elm.firstChild;
+                          for (let i = 0; i < children.length; i++) {
                               if (!childNode ||
-                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                   childrenMatch = false;
                                   break;
                               }
@@ -5640,8 +5664,8 @@
                   }
               }
               if (isDef(data)) {
-                  var fullInvoke = false;
-                  for (var key in data) {
+                  let fullInvoke = false;
+                  for (const key in data) {
                       if (!isRenderedModule(key)) {
                           fullInvoke = true;
                           invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5673,18 +5697,18 @@
       return function patch(oldVnode, vnode, hydrating, removeOnly) {
           if (isUndef(vnode)) {
               if (isDef(oldVnode))
-                  { invokeDestroyHook(oldVnode); }
+                  invokeDestroyHook(oldVnode);
               return;
           }
-          var isInitialPatch = false;
-          var insertedVnodeQueue = [];
+          let isInitialPatch = false;
+          const insertedVnodeQueue = [];
           if (isUndef(oldVnode)) {
               // empty mount (likely as component), create new root element
               isInitialPatch = true;
               createElm(vnode, insertedVnodeQueue);
           }
           else {
-              var isRealElement = isDef(oldVnode.nodeType);
+              const isRealElement = isDef(oldVnode.nodeType);
               if (!isRealElement && sameVnode(oldVnode, vnode)) {
                   // patch existing root node
                   patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5716,8 +5740,8 @@
                       oldVnode = emptyNodeAt(oldVnode);
                   }
                   // replacing existing element
-                  var oldElm = oldVnode.elm;
-                  var parentElm = nodeOps.parentNode(oldElm);
+                  const oldElm = oldVnode.elm;
+                  const parentElm = nodeOps.parentNode(oldElm);
                   // create new node
                   createElm(vnode, insertedVnodeQueue, 
                   // extremely rare edge case: do not insert if old element is in a
@@ -5726,25 +5750,25 @@
                   oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                   // update parent placeholder node element, recursively
                   if (isDef(vnode.parent)) {
-                      var ancestor = vnode.parent;
-                      var patchable = isPatchable(vnode);
+                      let ancestor = vnode.parent;
+                      const patchable = isPatchable(vnode);
                       while (ancestor) {
-                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                          for (let i = 0; i < cbs.destroy.length; ++i) {
                               cbs.destroy[i](ancestor);
                           }
                           ancestor.elm = vnode.elm;
                           if (patchable) {
-                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                  cbs.create[i$1](emptyNode, ancestor);
+                              for (let i = 0; i < cbs.create.length; ++i) {
+                                  cbs.create[i](emptyNode, ancestor);
                               }
                               // #6513
                               // invoke insert hooks that may have been merged by create hooks.
                               // e.g. for directives that uses the "inserted" hook.
-                              var insert = ancestor.data.hook.insert;
+                              const insert = ancestor.data.hook.insert;
                               if (insert.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                      insert.fns[i$2]();
+                                  for (let i = 1; i < insert.fns.length; i++) {
+                                      insert.fns[i]();
                                   }
                               }
                           }
@@ -5782,13 +5806,13 @@
       }
   }
   function _update(oldVnode, vnode) {
-      var isCreate = oldVnode === emptyNode;
-      var isDestroy = vnode === emptyNode;
-      var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      var dirsWithInsert = [];
-      var dirsWithPostpatch = [];
-      var key, oldDir, dir;
+      const isCreate = oldVnode === emptyNode;
+      const isDestroy = vnode === emptyNode;
+      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+      const dirsWithInsert = [];
+      const dirsWithPostpatch = [];
+      let key, oldDir, dir;
       for (key in newDirs) {
           oldDir = oldDirs[key];
           dir = newDirs[key];
@@ -5810,8 +5834,8 @@
           }
       }
       if (dirsWithInsert.length) {
-          var callInsert = function () {
-              for (var i = 0; i < dirsWithInsert.length; i++) {
+          const callInsert = () => {
+              for (let i = 0; i < dirsWithInsert.length; i++) {
                   callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
               }
           };
@@ -5823,8 +5847,8 @@
           }
       }
       if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', function () {
-              for (var i = 0; i < dirsWithPostpatch.length; i++) {
+          mergeVNodeHook(vnode, 'postpatch', () => {
+              for (let i = 0; i < dirsWithPostpatch.length; i++) {
                   callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
               }
           });
@@ -5838,14 +5862,14 @@
           }
       }
   }
-  var emptyModifiers = Object.create(null);
+  const emptyModifiers = Object.create(null);
   function normalizeDirectives(dirs, vm) {
-      var res = Object.create(null);
+      const res = Object.create(null);
       if (!dirs) {
           // $flow-disable-line
           return res;
       }
-      var i, dir;
+      let i, dir;
       for (i = 0; i < dirs.length; i++) {
           dir = dirs[i];
           if (!dir.modifiers) {
@@ -5859,34 +5883,35 @@
       return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
   }
   function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      var fn = dir.def && dir.def[hook];
+      const fn = dir.def && dir.def[hook];
       if (fn) {
           try {
               fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
           }
           catch (e) {
-              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+              // @ts-expect-error should it be any?
+              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
           }
       }
   }
 
-  var baseModules = [ref$1, directives$1];
+  var baseModules = [ref, directives$1];
 
   function updateAttrs(oldVnode, vnode) {
-      var opts = vnode.componentOptions;
+      const opts = vnode.componentOptions;
       if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
           return;
       }
       if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
           return;
       }
-      var key, cur, old;
-      var elm = vnode.elm;
-      var oldAttrs = oldVnode.data.attrs || {};
-      var attrs = vnode.data.attrs || {};
+      let key, cur, old;
+      const elm = vnode.elm;
+      const oldAttrs = oldVnode.data.attrs || {};
+      let attrs = vnode.data.attrs || {};
       // clone observed objects, as the user probably wants to mutate it
       if (isDef(attrs.__ob__)) {
           attrs = vnode.data.attrs = extend({}, attrs);
@@ -5962,7 +5987,7 @@
               key === 'placeholder' &&
               value !== '' &&
               !el.__ieph) {
-              var blocker = function (e) {
+              const blocker = (e) => {
                   e.stopImmediatePropagation();
                   el.removeEventListener('input', blocker);
               };
@@ -5979,18 +6004,18 @@
   };
 
   function updateClass(oldVnode, vnode) {
-      var el = vnode.elm;
-      var data = vnode.data;
-      var oldData = oldVnode.data;
+      const el = vnode.elm;
+      const data = vnode.data;
+      const oldData = oldVnode.data;
       if (isUndef(data.staticClass) &&
           isUndef(data.class) &&
           (isUndef(oldData) ||
               (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
           return;
       }
-      var cls = genClassForVnode(vnode);
+      let cls = genClassForVnode(vnode);
       // handle transition classes
-      var transitionClass = el._transitionClasses;
+      const transitionClass = el._transitionClasses;
       if (isDef(transitionClass)) {
           cls = concat(cls, stringifyClass(transitionClass));
       }
@@ -6005,35 +6030,35 @@
       update: updateClass,
   };
 
-  var validDivisionCharRE = /[\w).+\-_$\]]/;
+  const validDivisionCharRE = /[\w).+\-_$\]]/;
   function parseFilters(exp) {
-      var inSingle = false;
-      var inDouble = false;
-      var inTemplateString = false;
-      var inRegex = false;
-      var curly = 0;
-      var square = 0;
-      var paren = 0;
-      var lastFilterIndex = 0;
-      var c, prev, i, expression, filters;
+      let inSingle = false;
+      let inDouble = false;
+      let inTemplateString = false;
+      let inRegex = false;
+      let curly = 0;
+      let square = 0;
+      let paren = 0;
+      let lastFilterIndex = 0;
+      let c, prev, i, expression, filters;
       for (i = 0; i < exp.length; i++) {
           prev = c;
           c = exp.charCodeAt(i);
           if (inSingle) {
               if (c === 0x27 && prev !== 0x5c)
-                  { inSingle = false; }
+                  inSingle = false;
           }
           else if (inDouble) {
               if (c === 0x22 && prev !== 0x5c)
-                  { inDouble = false; }
+                  inDouble = false;
           }
           else if (inTemplateString) {
               if (c === 0x60 && prev !== 0x5c)
-                  { inTemplateString = false; }
+                  inTemplateString = false;
           }
           else if (inRegex) {
               if (c === 0x2f && prev !== 0x5c)
-                  { inRegex = false; }
+                  inRegex = false;
           }
           else if (c === 0x7c && // pipe
               exp.charCodeAt(i + 1) !== 0x7c &&
@@ -6082,13 +6107,13 @@
               }
               if (c === 0x2f) {
                   // /
-                  var j = i - 1;
-                  var p = (void 0);
+                  let j = i - 1;
+                  let p;
                   // find first non-whitespace prev char
                   for (; j >= 0; j--) {
                       p = exp.charAt(j);
                       if (p !== ' ')
-                          { break; }
+                          break;
                   }
                   if (!p || !validDivisionCharRE.test(p)) {
                       inRegex = true;
@@ -6114,55 +6139,55 @@
       return expression;
   }
   function wrapFilter(exp, filter) {
-      var i = filter.indexOf('(');
+      const i = filter.indexOf('(');
       if (i < 0) {
           // _f: resolveFilter
-          return ("_f(\"" + filter + "\")(" + exp + ")");
+          return `_f("${filter}")(${exp})`;
       }
       else {
-          var name = filter.slice(0, i);
-          var args = filter.slice(i + 1);
-          return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args));
+          const name = filter.slice(0, i);
+          const args = filter.slice(i + 1);
+          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
       }
   }
 
   /* eslint-disable no-unused-vars */
   function baseWarn(msg, range) {
-      console.error(("[Vue compiler]: " + msg));
+      console.error(`[Vue compiler]: ${msg}`);
   }
   /* eslint-enable no-unused-vars */
   function pluckModuleFunction(modules, key) {
-      return modules ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; }) : [];
+      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
   }
   function addProp(el, name, value, range, dynamic) {
-      (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
       el.plain = false;
   }
   function addAttr(el, name, value, range, dynamic) {
-      var attrs = dynamic
+      const attrs = dynamic
           ? el.dynamicAttrs || (el.dynamicAttrs = [])
           : el.attrs || (el.attrs = []);
-      attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
+      attrs.push(rangeSetItem({ name, value, dynamic }, range));
       el.plain = false;
   }
   // add a raw attr (use this in preTransforms)
   function addRawAttr(el, name, value, range) {
       el.attrsMap[name] = value;
-      el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
+      el.attrsList.push(rangeSetItem({ name, value }, range));
   }
   function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
       (el.directives || (el.directives = [])).push(rangeSetItem({
-          name: name,
-          rawName: rawName,
-          value: value,
-          arg: arg,
-          isDynamicArg: isDynamicArg,
-          modifiers: modifiers,
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamicArg,
+          modifiers,
       }, range));
       el.plain = false;
   }
   function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? ("_p(" + name + ",\"" + symbol + "\")") : symbol + name; // mark the event as captured
+      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
   }
   function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
       modifiers = modifiers || emptyObject;
@@ -6179,7 +6204,7 @@
       // the only target envs that have right/middle clicks.
       if (modifiers.right) {
           if (dynamic) {
-              name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
+              name = `(${name})==='click'?'contextmenu':(${name})`;
           }
           else if (name === 'click') {
               name = 'contextmenu';
@@ -6188,7 +6213,7 @@
       }
       else if (modifiers.middle) {
           if (dynamic) {
-              name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
+              name = `(${name})==='click'?'mouseup':(${name})`;
           }
           else if (name === 'click') {
               name = 'mouseup';
@@ -6208,7 +6233,7 @@
           delete modifiers.passive;
           name = prependModifierMarker('&', name, dynamic);
       }
-      var events;
+      let events;
       if (modifiers.native) {
           delete modifiers.native;
           events = el.nativeEvents || (el.nativeEvents = {});
@@ -6216,11 +6241,11 @@
       else {
           events = el.events || (el.events = {});
       }
-      var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
+      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
       if (modifiers !== emptyObject) {
           newHandler.modifiers = modifiers;
       }
-      var handlers = events[name];
+      const handlers = events[name];
       /* istanbul ignore if */
       if (Array.isArray(handlers)) {
           important ? handlers.unshift(newHandler) : handlers.push(newHandler);
@@ -6239,12 +6264,12 @@
           el.rawAttrsMap[name]);
   }
   function getBindingAttr(el, name, getStatic) {
-      var dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
       if (dynamicValue != null) {
           return parseFilters(dynamicValue);
       }
       else if (getStatic !== false) {
-          var staticValue = getAndRemoveAttr(el, name);
+          const staticValue = getAndRemoveAttr(el, name);
           if (staticValue != null) {
               return JSON.stringify(staticValue);
           }
@@ -6255,10 +6280,10 @@
   // By default it does NOT remove it from the map (attrsMap) because the map is
   // needed during codegen.
   function getAndRemoveAttr(el, name, removeFromMap) {
-      var val;
+      let val;
       if ((val = el.attrsMap[name]) != null) {
-          var list = el.attrsList;
-          for (var i = 0, l = list.length; i < l; i++) {
+          const list = el.attrsList;
+          for (let i = 0, l = list.length; i < l; i++) {
               if (list[i].name === name) {
                   list.splice(i, 1);
                   break;
@@ -6271,9 +6296,9 @@
       return val;
   }
   function getAndRemoveAttrByRegex(el, name) {
-      var list = el.attrsList;
-      for (var i = 0, l = list.length; i < l; i++) {
-          var attr = list[i];
+      const list = el.attrsList;
+      for (let i = 0, l = list.length; i < l; i++) {
+          const attr = list[i];
           if (name.test(attr.name)) {
               list.splice(i, 1);
               return attr;
@@ -6296,37 +6321,35 @@
    * Cross-platform code generation for component v-model
    */
   function genComponentModel(el, value, modifiers) {
-      var ref = modifiers || {};
-      var number = ref.number;
-      var trim = ref.trim;
-      var baseValueExpression = '$$v';
-      var valueExpression = baseValueExpression;
+      const { number, trim } = modifiers || {};
+      const baseValueExpression = '$$v';
+      let valueExpression = baseValueExpression;
       if (trim) {
           valueExpression =
-              "(typeof " + baseValueExpression + " === 'string'" +
-                  "? " + baseValueExpression + ".trim()" +
-                  ": " + baseValueExpression + ")";
+              `(typeof ${baseValueExpression} === 'string'` +
+                  `? ${baseValueExpression}.trim()` +
+                  `: ${baseValueExpression})`;
       }
       if (number) {
-          valueExpression = "_n(" + valueExpression + ")";
+          valueExpression = `_n(${valueExpression})`;
       }
-      var assignment = genAssignmentCode(value, valueExpression);
+      const assignment = genAssignmentCode(value, valueExpression);
       el.model = {
-          value: ("(" + value + ")"),
+          value: `(${value})`,
           expression: JSON.stringify(value),
-          callback: ("function (" + baseValueExpression + ") {" + assignment + "}"),
+          callback: `function (${baseValueExpression}) {${assignment}}`,
       };
   }
   /**
    * Cross-platform codegen helper for generating v-model value assignment code.
    */
   function genAssignmentCode(value, assignment) {
-      var res = parseModel(value);
+      const res = parseModel(value);
       if (res.key === null) {
-          return (value + "=" + assignment);
+          return `${value}=${assignment}`;
       }
       else {
-          return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")");
+          return `$set(${res.exp}, ${res.key}, ${assignment})`;
       }
   }
   /**
@@ -6343,7 +6366,7 @@
    * - test.xxx.a["asa"][test1[key]]
    *
    */
-  var len, str, chr, index, expressionPos, expressionEndPos;
+  let len, str, chr, index, expressionPos, expressionEndPos;
   function parseModel(val) {
       // Fix https://github.com/vuejs/vue/pull/7730
       // allow v-model="obj.val " (trailing whitespace)
@@ -6391,7 +6414,7 @@
       return chr === 0x22 || chr === 0x27;
   }
   function parseBracket(chr) {
-      var inBracket = 1;
+      let inBracket = 1;
       expressionPos = index;
       while (!eof()) {
           chr = next();
@@ -6400,9 +6423,9 @@
               continue;
           }
           if (chr === 0x5b)
-              { inBracket++; }
+              inBracket++;
           if (chr === 0x5d)
-              { inBracket--; }
+              inBracket--;
           if (inBracket === 0) {
               expressionEndPos = index;
               break;
@@ -6410,7 +6433,7 @@
       }
   }
   function parseString(chr) {
-      var stringQuote = chr;
+      const stringQuote = chr;
       while (!eof()) {
           chr = next();
           if (chr === stringQuote) {
@@ -6419,10 +6442,127 @@
       }
   }
 
+  let warn$1;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
-  var RANGE_TOKEN$1 = '__r';
-  var CHECKBOX_RADIO_TOKEN = '__c';
+  const RANGE_TOKEN = '__r';
+  const CHECKBOX_RADIO_TOKEN = '__c';
+  function model$1(el, dir, _warn) {
+      warn$1 = _warn;
+      const value = dir.value;
+      const modifiers = dir.modifiers;
+      const tag = el.tag;
+      const type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else if (!config.isReservedTag(tag)) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else {
+          warn$1(`<${el.tag} v-model="${value}">: ` +
+              `v-model is not supported on this element type. ` +
+              "If you are working with contenteditable, it's recommended to " +
+              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const valueBinding = getBindingAttr(el, 'value') || 'null';
+      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', `Array.isArray(${value})` +
+          `?_i(${value},${valueBinding})>-1` +
+          (trueValueBinding === 'true'
+              ? `:(${value})`
+              : `:_q(${value},${trueValueBinding})`));
+      addHandler(el, 'change', `var $$a=${value},` +
+          '$$el=$event.target,' +
+          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+          'if(Array.isArray($$a)){' +
+          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+          '$$i=_i($$a,$$v);' +
+          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      let valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+      addProp(el, 'checked', `_q(${value},${valueBinding})`);
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const selectedVal = `Array.prototype.filter` +
+          `.call($event.target.options,function(o){return o.selected})` +
+          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+          `return ${number ? '_n(val)' : 'val'}})`;
+      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      let code = `var $$selectedVal = ${selectedVal};`;
+      code = `${code} ${genAssignmentCode(value, assignment)}`;
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      const type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value && !typeBinding) {
+              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      const { lazy, number, trim } = modifiers || {};
+      const needCompositionGuard = !lazy && type !== 'range';
+      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      let valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = `$event.target.value.trim()`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      let code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = `if($event.target.composing)return;${code}`;
+      }
+      addProp(el, 'value', `(${value})`);
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
+  }
 
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
@@ -6430,11 +6570,11 @@
   // user-attached handlers.
   function normalizeEvents(on) {
       /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN$1])) {
+      if (isDef(on[RANGE_TOKEN])) {
           // IE input[type=range] only supports `change` event
-          var event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN$1], on[event] || []);
-          delete on[RANGE_TOKEN$1];
+          const event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          delete on[RANGE_TOKEN];
       }
       // This was originally intended to fix #4521 but no longer necessary
       // after 2.5. Keeping it for backwards compat with generated code from < 2.4
@@ -6444,11 +6584,11 @@
           delete on[CHECKBOX_RADIO_TOKEN];
       }
   }
-  var target;
+  let target;
   function createOnceHandler(event, handler, capture) {
-      var _target = target; // save current target element in closure
+      const _target = target; // save current target element in closure
       return function onceHandler() {
-          var res = handler.apply(null, arguments);
+          const res = handler.apply(null, arguments);
           if (res !== null) {
               remove(event, onceHandler, capture, _target);
           }
@@ -6457,7 +6597,7 @@
   // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
-  var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
   function add(name, handler, capture, passive) {
       // async edge case #6566: inner click event triggers patch, event handler
       // attached to outer element during patch, and triggered again. This
@@ -6466,9 +6606,9 @@
       // and the handler would only fire if the event passed to it was fired
       // AFTER it was attached.
       if (useMicrotaskFix) {
-          var attachedTimestamp = currentFlushTimestamp;
-          var original = handler;
-          //@ts-expect-error
+          const attachedTimestamp = currentFlushTimestamp;
+          const original = handler;
+          //@ts-expect-error 
           handler = original._wrapper = function (e) {
               if (
               // no bubbling, should always fire.
@@ -6489,7 +6629,7 @@
               }
           };
       }
-      target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
   }
   function remove(name, handler, capture, _target) {
       (_target || target).removeEventListener(name, 
@@ -6500,9 +6640,11 @@
       if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
           return;
       }
-      var on = vnode.data.on || {};
-      var oldOn = oldVnode.data.on || {};
-      target = vnode.elm;
+      const on = vnode.data.on || {};
+      const oldOn = oldVnode.data.on || {};
+      // vnode is empty when removing all listeners,
+      // and use old vnode dom element
+      target = vnode.elm || oldVnode.elm;
       normalizeEvents(on);
       updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
       target = undefined;
@@ -6510,17 +6652,19 @@
   var events = {
       create: updateDOMListeners,
       update: updateDOMListeners,
+      // @ts-expect-error emptyNode has actually data
+      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
   };
 
-  var svgContainer;
+  let svgContainer;
   function updateDOMProps(oldVnode, vnode) {
       if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
           return;
       }
-      var key, cur;
-      var elm = vnode.elm;
-      var oldProps = oldVnode.data.domProps || {};
-      var props = vnode.data.domProps || {};
+      let key, cur;
+      const elm = vnode.elm;
+      const oldProps = oldVnode.data.domProps || {};
+      let props = vnode.data.domProps || {};
       // clone observed objects, as the user probably wants to mutate it
       if (isDef(props.__ob__)) {
           props = vnode.data.domProps = extend({}, props);
@@ -6537,9 +6681,9 @@
           // on subsequent patches (#3360)
           if (key === 'textContent' || key === 'innerHTML') {
               if (vnode.children)
-                  { vnode.children.length = 0; }
+                  vnode.children.length = 0;
               if (cur === oldProps[key])
-                  { continue; }
+                  continue;
               // #6601 work around Chrome version <= 55 bug where single textNode
               // replaced by innerHTML/textContent retains its parentNode property
               if (elm.childNodes.length === 1) {
@@ -6551,18 +6695,18 @@
               // non-string values will be stringified
               elm._value = cur;
               // avoid resetting cursor position when value is the same
-              var strCur = isUndef(cur) ? '' : String(cur);
+              const strCur = isUndef(cur) ? '' : String(cur);
               if (shouldUpdateValue(elm, strCur)) {
                   elm.value = strCur;
               }
           }
           else if (key === 'innerHTML' &&
-              isSVG$1(elm.tagName) &&
+              isSVG(elm.tagName) &&
               isUndef(elm.innerHTML)) {
               // IE doesn't support innerHTML for SVG elements
               svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-              var svg = svgContainer.firstChild;
+              svgContainer.innerHTML = `<svg>${cur}</svg>`;
+              const svg = svgContainer.firstChild;
               while (elm.firstChild) {
                   elm.removeChild(elm.firstChild);
               }
@@ -6596,7 +6740,7 @@
   function isNotInFocusAndDirty(elm, checkVal) {
       // return true when textbox (.number and .trim) loses focus and its value is
       // not equal to the updated value
-      var notInFocus = true;
+      let notInFocus = true;
       // #6157
       // work around IE bug when accessing document.activeElement in an iframe
       try {
@@ -6606,8 +6750,8 @@
       return notInFocus && elm.value !== checkVal;
   }
   function isDirtyWithModifiers(elm, newVal) {
-      var value = elm.value;
-      var modifiers = elm._vModifiers; // injected by v-model runtime
+      const value = elm.value;
+      const modifiers = elm._vModifiers; // injected by v-model runtime
       if (isDef(modifiers)) {
           if (modifiers.number) {
               return toNumber(value) !== toNumber(newVal);
@@ -6623,13 +6767,13 @@
       update: updateDOMProps,
   };
 
-  var parseStyleText = cached(function (cssText) {
-      var res = {};
-      var listDelimiter = /;(?![^(]*\))/g;
-      var propertyDelimiter = /:(.+)/;
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
       cssText.split(listDelimiter).forEach(function (item) {
           if (item) {
-              var tmp = item.split(propertyDelimiter);
+              const tmp = item.split(propertyDelimiter);
               tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
           }
       });
@@ -6637,7 +6781,7 @@
   });
   // merge static and dynamic style data on the same vnode
   function normalizeStyleData(data) {
-      var style = normalizeStyleBinding(data.style);
+      const style = normalizeStyleBinding(data.style);
       // static style is pre-processed into an object during compilation
       // and is always a fresh object, so it's safe to merge into it
       return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6657,10 +6801,10 @@
    * so that parent component's style could override it
    */
   function getStyle(vnode, checkChild) {
-      var res = {};
-      var styleData;
+      const res = {};
+      let styleData;
       if (checkChild) {
-          var childNode = vnode;
+          let childNode = vnode;
           while (childNode.componentInstance) {
               childNode = childNode.componentInstance._vnode;
               if (childNode &&
@@ -6673,7 +6817,8 @@
       if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
       }
-      var parentNode = vnode;
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
       while ((parentNode = parentNode.parent)) {
           if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
               extend(res, styleData);
@@ -6682,9 +6827,9 @@
       return res;
   }
 
-  var cssVarRE = /^--/;
-  var importantRE = /\s*!important$/;
-  var setProp = function (el, name, val) {
+  const cssVarRE = /^--/;
+  const importantRE = /\s*!important$/;
+  const setProp = (el, name, val) => {
       /* istanbul ignore if */
       if (cssVarRE.test(name)) {
           el.style.setProperty(name, val);
@@ -6693,12 +6838,12 @@
           el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
       }
       else {
-          var normalizedName = normalize(name);
+          const normalizedName = normalize(name);
           if (Array.isArray(val)) {
               // Support values array created by autoprefixer, e.g.
               // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
               // Set them one by one, and the browser will only set those it can recognize
-              for (var i = 0, len = val.length; i < len; i++) {
+              for (let i = 0, len = val.length; i < len; i++) {
                   el.style[normalizedName] = val[i];
               }
           }
@@ -6707,43 +6852,43 @@
           }
       }
   };
-  var vendorNames = ['Webkit', 'Moz', 'ms'];
-  var emptyStyle;
-  var normalize = cached(function (prop) {
+  const vendorNames = ['Webkit', 'Moz', 'ms'];
+  let emptyStyle;
+  const normalize = cached(function (prop) {
       emptyStyle = emptyStyle || document.createElement('div').style;
       prop = camelize(prop);
       if (prop !== 'filter' && prop in emptyStyle) {
           return prop;
       }
-      var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (var i = 0; i < vendorNames.length; i++) {
-          var name = vendorNames[i] + capName;
+      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (let i = 0; i < vendorNames.length; i++) {
+          const name = vendorNames[i] + capName;
           if (name in emptyStyle) {
               return name;
           }
       }
   });
   function updateStyle(oldVnode, vnode) {
-      var data = vnode.data;
-      var oldData = oldVnode.data;
+      const data = vnode.data;
+      const oldData = oldVnode.data;
       if (isUndef(data.staticStyle) &&
           isUndef(data.style) &&
           isUndef(oldData.staticStyle) &&
           isUndef(oldData.style)) {
           return;
       }
-      var cur, name;
-      var el = vnode.elm;
-      var oldStaticStyle = oldData.staticStyle;
-      var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      let cur, name;
+      const el = vnode.elm;
+      const oldStaticStyle = oldData.staticStyle;
+      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
       // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      var oldStyle = oldStaticStyle || oldStyleBinding;
-      var style = normalizeStyleBinding(vnode.data.style) || {};
+      const oldStyle = oldStaticStyle || oldStyleBinding;
+      const style = normalizeStyleBinding(vnode.data.style) || {};
       // store normalized style under a different key for next diff
       // make sure to clone it if it's reactive, since the user likely wants
       // to mutate it.
       vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      var newStyle = getStyle(vnode, true);
+      const newStyle = getStyle(vnode, true);
       for (name in oldStyle) {
           if (isUndef(newStyle[name])) {
               setProp(el, name, '');
@@ -6762,7 +6907,7 @@
       update: updateStyle,
   };
 
-  var whitespaceRE$1 = /\s+/;
+  const whitespaceRE$1 = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
@@ -6775,14 +6920,14 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.add(c); });
+              cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
           }
           else {
               el.classList.add(cls);
           }
       }
       else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
+          const cur = ` ${el.getAttribute('class') || ''} `;
           if (cur.indexOf(' ' + cls + ' ') < 0) {
               el.setAttribute('class', (cur + cls).trim());
           }
@@ -6800,7 +6945,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach(function (c) { return el.classList.remove(c); });
+              cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
           }
           else {
               el.classList.remove(cls);
@@ -6810,8 +6955,8 @@
           }
       }
       else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          var tar = ' ' + cls + ' ';
+          let cur = ` ${el.getAttribute('class') || ''} `;
+          const tar = ' ' + cls + ' ';
           while (cur.indexOf(tar) >= 0) {
               cur = cur.replace(tar, ' ');
           }
@@ -6831,7 +6976,7 @@
       }
       /* istanbul ignore else */
       if (typeof def === 'object') {
-          var res = {};
+          const res = {};
           if (def.css !== false) {
               extend(res, autoCssTransition(def.name || 'v'));
           }
@@ -6842,53 +6987,51 @@
           return autoCssTransition(def);
       }
   }
-  var autoCssTransition = cached(function (name) {
+  const autoCssTransition = cached((name) => {
       return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
+          enterClass: `${name}-enter`,
+          enterToClass: `${name}-enter-to`,
+          enterActiveClass: `${name}-enter-active`,
+          leaveClass: `${name}-leave`,
+          leaveToClass: `${name}-leave-to`,
+          leaveActiveClass: `${name}-leave-active`,
       };
   });
-  var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = 'transition';
-  var ANIMATION = 'animation';
+  const hasTransition = inBrowser && !isIE9;
+  const TRANSITION = 'transition';
+  const ANIMATION = 'animation';
   // Transition property/event sniffing
-  var transitionProp = 'transition';
-  var transitionEndEvent = 'transitionend';
-  var animationProp = 'animation';
-  var animationEndEvent = 'animationend';
+  let transitionProp = 'transition';
+  let transitionEndEvent = 'transitionend';
+  let animationProp = 'animation';
+  let animationEndEvent = 'animationend';
   if (hasTransition) {
       /* istanbul ignore if */
       if (window.ontransitionend === undefined &&
-          // @ts-expect-error
           window.onwebkittransitionend !== undefined) {
           transitionProp = 'WebkitTransition';
           transitionEndEvent = 'webkitTransitionEnd';
       }
       if (window.onanimationend === undefined &&
-          // @ts-expect-error
           window.onwebkitanimationend !== undefined) {
           animationProp = 'WebkitAnimation';
           animationEndEvent = 'webkitAnimationEnd';
       }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf = inBrowser
+  const raf = inBrowser
       ? window.requestAnimationFrame
           ? window.requestAnimationFrame.bind(window)
           : setTimeout
-      : /* istanbul ignore next */ function (fn) { return fn(); };
+      : /* istanbul ignore next */ (fn) => fn();
   function nextFrame(fn) {
-      raf(function () {
+      raf(() => {
           // @ts-expect-error
           raf(fn);
       });
   }
   function addTransitionClass(el, cls) {
-      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
       if (transitionClasses.indexOf(cls) < 0) {
           transitionClasses.push(cls);
           addClass(el, cls);
@@ -6901,45 +7044,42 @@
       removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var ref = getTransitionInfo(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
+      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
       if (!type)
-          { return cb(); }
-      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      var ended = 0;
-      var end = function () {
+          return cb();
+      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      let ended = 0;
+      const end = () => {
           el.removeEventListener(event, onEnd);
           cb();
       };
-      var onEnd = function (e) {
+      const onEnd = (e) => {
           if (e.target === el) {
               if (++ended >= propCount) {
                   end();
               }
           }
       };
-      setTimeout(function () {
+      setTimeout(() => {
           if (ended < propCount) {
               end();
           }
       }, timeout + 1);
       el.addEventListener(event, onEnd);
   }
-  var transformRE = /\b(transform|all)(,|$)/;
+  const transformRE = /\b(transform|all)(,|$)/;
   function getTransitionInfo(el, expectedType) {
-      var styles = window.getComputedStyle(el);
+      const styles = window.getComputedStyle(el);
       // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout(animationDelays, animationDurations);
-      var type;
-      var timeout = 0;
-      var propCount = 0;
+      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      const animationTimeout = getTimeout(animationDelays, animationDurations);
+      let type;
+      let timeout = 0;
+      let propCount = 0;
       /* istanbul ignore if */
       if (expectedType === TRANSITION) {
           if (transitionTimeout > 0) {
@@ -6969,12 +7109,12 @@
                   : animationDurations.length
               : 0;
       }
-      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
       return {
-          type: type,
-          timeout: timeout,
-          propCount: propCount,
-          hasTransform: hasTransform,
+          type,
+          timeout,
+          propCount,
+          hasTransform,
       };
   }
   function getTimeout(delays, durations) {
@@ -6982,7 +7122,7 @@
       while (delays.length < durations.length) {
           delays = delays.concat(delays);
       }
-      return Math.max.apply(null, durations.map(function (d, i) {
+      return Math.max.apply(null, durations.map((d, i) => {
           return toMs(d) + toMs(delays[i]);
       }));
   }
@@ -6995,13 +7135,13 @@
   }
 
   function enter(vnode, toggleDisplay) {
-      var el = vnode.elm;
+      const el = vnode.elm;
       // call leave callback now
       if (isDef(el._leaveCb)) {
           el._leaveCb.cancelled = true;
           el._leaveCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      const data = resolveTransition(vnode.data.transition);
       if (isUndef(data)) {
           return;
       }
@@ -7009,57 +7149,41 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
+      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
       // <transition>'s parent for appear check.
-      var context = activeInstance;
-      var transitionNode = activeInstance.$vnode;
+      let context = activeInstance;
+      let transitionNode = activeInstance.$vnode;
       while (transitionNode && transitionNode.parent) {
           context = transitionNode.context;
           transitionNode = transitionNode.parent;
       }
-      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      const isAppear = !context._isMounted || !vnode.isRootInsert;
       if (isAppear && !appear && appear !== '') {
           return;
       }
-      var startClass = isAppear && appearClass ? appearClass : enterClass;
-      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      var enterHook = isAppear
+      const startClass = isAppear && appearClass ? appearClass : enterClass;
+      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      const enterHook = isAppear
           ? typeof appear === 'function'
               ? appear
               : enter
           : enter;
-      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      var enterCancelledHook = isAppear
+      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      const enterCancelledHook = isAppear
           ? appearCancelled || enterCancelled
           : enterCancelled;
-      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
       if (explicitEnterDuration != null) {
           checkDuration(explicitEnterDuration, 'enter', vnode);
       }
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(enterHook);
-      var cb = (el._enterCb = once(function () {
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(enterHook);
+      const cb = (el._enterCb = once(() => {
           if (expectsCSS) {
               removeTransitionClass(el, toClass);
               removeTransitionClass(el, activeClass);
@@ -7078,9 +7202,9 @@
       }));
       if (!vnode.data.show) {
           // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', function () {
-              var parent = el.parentNode;
-              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+          mergeVNodeHook(vnode, 'insert', () => {
+              const parent = el.parentNode;
+              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
               if (pendingNode &&
                   pendingNode.tag === vnode.tag &&
                   pendingNode.elm._leaveCb) {
@@ -7094,7 +7218,7 @@
       if (expectsCSS) {
           addTransitionClass(el, startClass);
           addTransitionClass(el, activeClass);
-          nextFrame(function () {
+          nextFrame(() => {
               removeTransitionClass(el, startClass);
               // @ts-expect-error
               if (!cb.cancelled) {
@@ -7119,13 +7243,13 @@
       }
   }
   function leave(vnode, rm) {
-      var el = vnode.elm;
+      const el = vnode.elm;
       // call enter callback now
       if (isDef(el._enterCb)) {
           el._enterCb.cancelled = true;
           el._enterCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      const data = resolveTransition(vnode.data.transition);
       if (isUndef(data) || el.nodeType !== 1) {
           return rm();
       }
@@ -7133,24 +7257,14 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(leave);
-      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(leave);
+      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
       if (isDef(explicitLeaveDuration)) {
           checkDuration(explicitLeaveDuration, 'leave', vnode);
       }
-      var cb = (el._leaveCb = once(function () {
+      const cb = (el._leaveCb = once(() => {
           if (el.parentNode && el.parentNode._pending) {
               el.parentNode._pending[vnode.key] = null;
           }
@@ -7191,7 +7305,7 @@
           if (expectsCSS) {
               addTransitionClass(el, leaveClass);
               addTransitionClass(el, leaveActiveClass);
-              nextFrame(function () {
+              nextFrame(() => {
                   removeTransitionClass(el, leaveClass);
                   // @ts-expect-error
                   if (!cb.cancelled) {
@@ -7216,11 +7330,11 @@
   // only used in dev mode
   function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
-          warn$2("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
+          warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+              `got ${JSON.stringify(val)}.`, vnode.context);
       }
       else if (isNaN(val)) {
-          warn$2("<transition> explicit " + name + " duration is NaN - " +
+          warn$2(`<transition> explicit ${name} duration is NaN - ` +
               'the duration expression might be incorrect.', vnode.context);
       }
   }
@@ -7238,7 +7352,7 @@
           return false;
       }
       // @ts-expect-error
-      var invokerFns = fn.fns;
+      const invokerFns = fn.fns;
       if (isDef(invokerFns)) {
           // invoker
           return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -7257,7 +7371,7 @@
       ? {
           create: _enter,
           activate: _enter,
-          remove: function remove(vnode, rm) {
+          remove(vnode, rm) {
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
@@ -7274,8 +7388,8 @@
 
   // the directive module should be applied last, after all
   // built-in modules have been applied.
-  var modules$1 = platformModules.concat(baseModules);
-  var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules$1 });
+  const modules$1 = platformModules.concat(baseModules);
+  const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
   /**
    * Not type checking this file because flow doesn't like attaching
@@ -7284,20 +7398,20 @@
   /* istanbul ignore if */
   if (isIE9) {
       // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', function () {
-          var el = document.activeElement;
+      document.addEventListener('selectionchange', () => {
+          const el = document.activeElement;
           // @ts-expect-error
           if (el && el.vmodel) {
               trigger(el, 'input');
           }
       });
   }
-  var directive = {
-      inserted: function inserted(el, binding, vnode, oldVnode) {
+  const directive = {
+      inserted(el, binding, vnode, oldVnode) {
           if (vnode.tag === 'select') {
               // #6903
               if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', function () {
+                  mergeVNodeHook(vnode, 'postpatch', () => {
                       directive.componentUpdated(el, binding, vnode);
                   });
               }
@@ -7323,20 +7437,20 @@
               }
           }
       },
-      componentUpdated: function componentUpdated(el, binding, vnode) {
+      componentUpdated(el, binding, vnode) {
           if (vnode.tag === 'select') {
               setSelected(el, binding, vnode.context);
               // in case the options rendered by v-for have changed,
               // it's possible that the value is out-of-sync with the rendered options.
               // detect such cases and filter out values that no longer has a matching
               // option in the DOM.
-              var prevOptions = el._vOptions;
-              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+              const prevOptions = el._vOptions;
+              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                   // trigger change event if
                   // no matching option found for at least one value
-                  var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                  const needReset = el.multiple
+                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                       : binding.value !== binding.oldValue &&
                           hasNoMatchingOption(binding.value, curOptions);
                   if (needReset) {
@@ -7350,23 +7464,23 @@
       actuallySetSelected(el, binding, vm);
       /* istanbul ignore if */
       if (isIE || isEdge) {
-          setTimeout(function () {
+          setTimeout(() => {
               actuallySetSelected(el, binding, vm);
           }, 0);
       }
   }
   function actuallySetSelected(el, binding, vm) {
-      var value = binding.value;
-      var isMultiple = el.multiple;
+      const value = binding.value;
+      const isMultiple = el.multiple;
       if (isMultiple && !Array.isArray(value)) {
-          warn$2("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                  "expects an Array value for its binding, but got " + (Object.prototype.toString
-                      .call(value)
-                      .slice(8, -1)), vm);
+          warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                  `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
           return;
       }
-      var selected, option;
-      for (var i = 0, l = el.options.length; i < l; i++) {
+      let selected, option;
+      for (let i = 0, l = el.options.length; i < l; i++) {
           option = el.options[i];
           if (isMultiple) {
               selected = looseIndexOf(value, getValue(option)) > -1;
@@ -7388,7 +7502,7 @@
       }
   }
   function hasNoMatchingOption(value, options) {
-      return options.every(function (o) { return !looseEqual(o, value); });
+      return options.every((o) => !looseEqual(o, value));
   }
   function getValue(option) {
       return '_value' in option ? option._value : option.value;
@@ -7399,12 +7513,12 @@
   function onCompositionEnd(e) {
       // prevent triggering an input event for no reason
       if (!e.target.composing)
-          { return; }
+          return;
       e.target.composing = false;
       trigger(e.target, 'input');
   }
   function trigger(el, type) {
-      var e = document.createEvent('HTMLEvents');
+      const e = document.createEvent('HTMLEvents');
       e.initEvent(type, true, true);
       el.dispatchEvent(e);
   }
@@ -7417,16 +7531,14 @@
           : vnode;
   }
   var show = {
-      bind: function bind(el, ref, vnode) {
-          var value = ref.value;
-
+      bind(el, { value }, vnode) {
           vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
-          var originalDisplay = (el.__vOriginalDisplay =
+          const transition = vnode.data && vnode.data.transition;
+          const originalDisplay = (el.__vOriginalDisplay =
               el.style.display === 'none' ? '' : el.style.display);
           if (value && transition) {
               vnode.data.show = true;
-              enter(vnode, function () {
+              enter(vnode, () => {
                   el.style.display = originalDisplay;
               });
           }
@@ -7434,24 +7546,21 @@
               el.style.display = value ? originalDisplay : 'none';
           }
       },
-      update: function update(el, ref, vnode) {
-          var value = ref.value;
-          var oldValue = ref.oldValue;
-
+      update(el, { value, oldValue }, vnode) {
           /* istanbul ignore if */
           if (!value === !oldValue)
-              { return; }
+              return;
           vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
+          const transition = vnode.data && vnode.data.transition;
           if (transition) {
               vnode.data.show = true;
               if (value) {
-                  enter(vnode, function () {
+                  enter(vnode, () => {
                       el.style.display = el.__vOriginalDisplay;
                   });
               }
               else {
-                  leave(vnode, function () {
+                  leave(vnode, () => {
                       el.style.display = 'none';
                   });
               }
@@ -7460,7 +7569,7 @@
               el.style.display = value ? el.__vOriginalDisplay : 'none';
           }
       },
-      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+      unbind(el, binding, vnode, oldVnode, isDestroy) {
           if (!isDestroy) {
               el.style.display = el.__vOriginalDisplay;
           }
@@ -7469,11 +7578,11 @@
 
   var platformDirectives = {
       model: directive,
-      show: show,
+      show,
   };
 
   // Provides transition support for a single element/component.
-  var transitionProps = {
+  const transitionProps = {
       name: String,
       appear: Boolean,
       css: Boolean,
@@ -7493,7 +7602,7 @@
   // in case the child is also an abstract component, e.g. <keep-alive>
   // we want to recursively retrieve the real component to be rendered
   function getRealChild(vnode) {
-      var compOptions = vnode && vnode.componentOptions;
+      const compOptions = vnode && vnode.componentOptions;
       if (compOptions && compOptions.Ctor.options.abstract) {
           return getRealChild(getFirstComponentChild(compOptions.children));
       }
@@ -7502,17 +7611,17 @@
       }
   }
   function extractTransitionData(comp) {
-      var data = {};
-      var options = comp.$options;
+      const data = {};
+      const options = comp.$options;
       // props
-      for (var key in options.propsData) {
+      for (const key in options.propsData) {
           data[key] = comp[key];
       }
       // events.
       // extract listeners and pass them directly to the transition methods
-      var listeners = options._parentListeners;
-      for (var key$1 in listeners) {
-          data[camelize(key$1)] = listeners[key$1];
+      const listeners = options._parentListeners;
+      for (const key in listeners) {
+          data[camelize(key)] = listeners[key];
       }
       return data;
   }
@@ -7534,16 +7643,14 @@
   function isSameChild(child, oldChild) {
       return oldChild.key === child.key && oldChild.tag === child.tag;
   }
-  var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-  var isVShowDirective = function (d) { return d.name === 'show'; };
+  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+  const isVShowDirective = (d) => d.name === 'show';
   var Transition = {
       name: 'transition',
       props: transitionProps,
       abstract: true,
-      render: function render(h) {
-          var this$1 = this;
-
-          var children = this.$slots.default;
+      render(h) {
+          let children = this.$slots.default;
           if (!children) {
               return;
           }
@@ -7558,14 +7665,14 @@
               warn$2('<transition> can only be used on a single element. Use ' +
                   '<transition-group> for lists.', this.$parent);
           }
-          var mode = this.mode;
+          const mode = this.mode;
           // warn invalid mode
           if (mode &&
               mode !== 'in-out' &&
               mode !== 'out-in') {
               warn$2('invalid <transition> mode: ' + mode, this.$parent);
           }
-          var rawChild = children[0];
+          const rawChild = children[0];
           // if this is a component root node and the component's
           // parent container node also has transition, skip.
           if (hasParentTransition(this.$vnode)) {
@@ -7573,7 +7680,7 @@
           }
           // apply transition data to child
           // use getRealChild() to ignore abstract components e.g. keep-alive
-          var child = getRealChild(rawChild);
+          const child = getRealChild(rawChild);
           /* istanbul ignore if */
           if (!child) {
               return rawChild;
@@ -7584,7 +7691,7 @@
           // ensure a key that is unique to the vnode type and to this transition
           // component instance. This key will be used to remove pending leaving nodes
           // during entering.
-          var id = "__transition-" + (this._uid) + "-";
+          const id = `__transition-${this._uid}-`;
           child.key =
               child.key == null
                   ? child.isComment
@@ -7595,9 +7702,9 @@
                           ? child.key
                           : id + child.key
                       : child.key;
-          var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          var oldRawChild = this._vnode;
-          var oldChild = getRealChild(oldRawChild);
+          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          const oldRawChild = this._vnode;
+          const oldChild = getRealChild(oldRawChild);
           // mark v-show
           // so that the transition module can hand over the control to the directive
           if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7612,14 +7719,14 @@
                   oldChild.componentInstance._vnode.isComment)) {
               // replace old child transition data with fresh one
               // important for dynamic transitions!
-              var oldData = (oldChild.data.transition = extend({}, data));
+              const oldData = (oldChild.data.transition = extend({}, data));
               // handle transition mode
               if (mode === 'out-in') {
                   // return placeholder node and queue update when leave finishes
                   this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', function () {
-                      this$1._leaving = false;
-                      this$1.$forceUpdate();
+                  mergeVNodeHook(oldData, 'afterLeave', () => {
+                      this._leaving = false;
+                      this.$forceUpdate();
                   });
                   return placeholder(h, rawChild);
               }
@@ -7627,13 +7734,13 @@
                   if (isAsyncPlaceholder(child)) {
                       return oldRawChild;
                   }
-                  var delayedLeave;
-                  var performLeave = function () {
+                  let delayedLeave;
+                  const performLeave = () => {
                       delayedLeave();
                   };
                   mergeVNodeHook(data, 'afterEnter', performLeave);
                   mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
                       delayedLeave = leave;
                   });
               }
@@ -7643,67 +7750,63 @@
   };
 
   // Provides transition support for list items.
-  var props = extend({
+  const props = extend({
       tag: String,
       moveClass: String,
   }, transitionProps);
-  // @ts-ignore
   delete props.mode;
   var TransitionGroup = {
-      props: props,
-      beforeMount: function beforeMount() {
-          var this$1 = this;
-
-          var update = this._update;
-          this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(this$1);
+      props,
+      beforeMount() {
+          const update = this._update;
+          this._update = (vnode, hydrating) => {
+              const restoreActiveInstance = setActiveInstance(this);
               // force removing pass
-              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              this.__patch__(this._vnode, this.kept, false, // hydrating
               true // removeOnly (!important, avoids unnecessary moves)
               );
-              this$1._vnode = this$1.kept;
+              this._vnode = this.kept;
               restoreActiveInstance();
-              update.call(this$1, vnode, hydrating);
+              update.call(this, vnode, hydrating);
           };
       },
-      render: function render(h) {
-          var tag = this.tag || this.$vnode.data.tag || 'span';
-          var map = Object.create(null);
-          var prevChildren = (this.prevChildren = this.children);
-          var rawChildren = this.$slots.default || [];
-          var children = (this.children = []);
-          var transitionData = extractTransitionData(this);
-          for (var i = 0; i < rawChildren.length; i++) {
-              var c = rawChildren[i];
+      render(h) {
+          const tag = this.tag || this.$vnode.data.tag || "span";
+          const map = Object.create(null);
+          const prevChildren = (this.prevChildren = this.children);
+          const rawChildren = this.$slots.default || [];
+          const children = (this.children = []);
+          const transitionData = extractTransitionData(this);
+          for (let i = 0; i < rawChildren.length; i++) {
+              const c = rawChildren[i];
               if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                       children.push(c);
                       map[c.key] = c;
                       (c.data || (c.data = {})).transition = transitionData;
                   }
                   else {
-                      var opts = c.componentOptions;
-                      var name = opts
-                          ? opts.Ctor.options.name || opts.tag || ''
+                      const opts = c.componentOptions;
+                      const name = opts
+                          ? opts.Ctor.options.name || opts.tag || ""
                           : c.tag;
-                      warn$2(("<transition-group> children must be keyed: <" + name + ">"));
+                      warn$2(`<transition-group> children must be keyed: <${name}>`);
                   }
               }
           }
           if (prevChildren) {
-              var kept = [];
-              var removed = [];
-              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                  var c$1 = prevChildren[i$1];
-                  c$1.data.transition = transitionData;
-                  // @ts-ignore
-                  c$1.data.pos = c$1.elm.getBoundingClientRect();
-                  // @ts-ignore
-                  if (map[c$1.key]) {
-                      kept.push(c$1);
+              const kept = [];
+              const removed = [];
+              for (let i = 0; i < prevChildren.length; i++) {
+                  const c = prevChildren[i];
+                  c.data.transition = transitionData;
+                  // @ts-expect-error .getBoundingClientRect is not typed in Node
+                  c.data.pos = c.elm.getBoundingClientRect();
+                  if (map[c.key]) {
+                      kept.push(c);
                   }
                   else {
-                      removed.push(c$1);
+                      removed.push(c);
                   }
               }
               this.kept = h(tag, null, kept);
@@ -7711,9 +7814,9 @@
           }
           return h(tag, null, children);
       },
-      updated: function updated() {
-          var children = this.prevChildren;
-          var moveClass = this.moveClass || (this.name || 'v') + '-move';
+      updated() {
+          const children = this.prevChildren;
+          const moveClass = this.moveClass || (this.name || "v") + "-move";
           if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
               return;
           }
@@ -7726,13 +7829,12 @@
           // assign to this to avoid being removed in tree-shaking
           // $flow-disable-line
           this._reflow = document.body.offsetHeight;
-          children.forEach(function (c) {
-              // @ts-ignore
+          children.forEach((c) => {
               if (c.data.moved) {
-                  var el = c.elm;
-                  var s = el.style;
+                  const el = c.elm;
+                  const s = el.style;
                   addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = '';
+                  s.transform = s.WebkitTransform = s.transitionDuration = "";
                   el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                       if (e && e.target !== el) {
                           return;
@@ -7747,7 +7849,7 @@
           });
       },
       methods: {
-          hasMove: function hasMove(el, moveClass) {
+          hasMove(el, moveClass) {
               /* istanbul ignore if */
               if (!hasTransition) {
                   return false;
@@ -7761,16 +7863,16 @@
               // transition at this very moment, we make a clone of it and remove
               // all other transition classes applied to ensure only the move class
               // is applied.
-              var clone = el.cloneNode();
+              const clone = el.cloneNode();
               if (el._transitionClasses) {
-                  el._transitionClasses.forEach(function (cls) {
+                  el._transitionClasses.forEach((cls) => {
                       removeClass(clone, cls);
                   });
               }
               addClass(clone, moveClass);
-              clone.style.display = 'none';
+              clone.style.display = "none";
               this.$el.appendChild(clone);
-              var info = getTransitionInfo(clone);
+              const info = getTransitionInfo(clone);
               this.$el.removeChild(clone);
               return (this._hasMove = info.hasTransform);
           },
@@ -7778,49 +7880,40 @@
   };
   function callPendingCbs(c) {
       /* istanbul ignore if */
-      //@ts-ignore
       if (c.elm._moveCb) {
-          //@ts-ignore
           c.elm._moveCb();
       }
       /* istanbul ignore if */
-      //@ts-ignore
       if (c.elm._enterCb) {
-          //@ts-ignore
           c.elm._enterCb();
       }
   }
   function recordPosition(c) {
-      //@ts-ignore
       c.data.newPos = c.elm.getBoundingClientRect();
   }
   function applyTranslation(c) {
-      //@ts-ignore
-      var oldPos = c.data.pos;
-      //@ts-ignore
-      var newPos = c.data.newPos;
-      var dx = oldPos.left - newPos.left;
-      var dy = oldPos.top - newPos.top;
+      const oldPos = c.data.pos;
+      const newPos = c.data.newPos;
+      const dx = oldPos.left - newPos.left;
+      const dy = oldPos.top - newPos.top;
       if (dx || dy) {
-          //@ts-ignore
           c.data.moved = true;
-          //@ts-ignore
-          var s = c.elm.style;
-          s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-          s.transitionDuration = '0s';
+          const s = c.elm.style;
+          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+          s.transitionDuration = "0s";
       }
   }
 
   var platformComponents = {
-      Transition: Transition,
-      TransitionGroup: TransitionGroup,
+      Transition,
+      TransitionGroup,
   };
 
   // install platform specific utils
-  Vue.config.mustUseProp = mustUseProp$1;
-  Vue.config.isReservedTag = isReservedTag$1;
+  Vue.config.mustUseProp = mustUseProp;
+  Vue.config.isReservedTag = isReservedTag;
   Vue.config.isReservedAttr = isReservedAttr;
-  Vue.config.getTagNamespace = getTagNamespace$1;
+  Vue.config.getTagNamespace = getTagNamespace;
   Vue.config.isUnknownElement = isUnknownElement;
   // install platform runtime directives & components
   extend(Vue.options.directives, platformDirectives);
@@ -7829,13 +7922,13 @@
   Vue.prototype.__patch__ = inBrowser ? patch : noop;
   // public mount method
   Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query$1(el) : undefined;
+      el = el && inBrowser ? query(el) : undefined;
       return mountComponent(this, el, hydrating);
   };
   // devtools global hook
   /* istanbul ignore next */
   if (inBrowser) {
-      setTimeout(function () {
+      setTimeout(() => {
           if (config.devtools) {
               if (devtools) {
                   devtools.emit('init', Vue);
@@ -7849,99 +7942,30 @@
           if (config.productionTip !== false &&
               typeof console !== 'undefined') {
               // @ts-expect-error
-              console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                  "Make sure to turn on production mode when deploying for production.\n" +
-                  "See more tips at https://vuejs.org/guide/deployment.html");
+              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                  `Make sure to turn on production mode when deploying for production.\n` +
+                  `See more tips at https://vuejs.org/guide/deployment.html`);
           }
       }, 0);
   }
 
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  makeMap('style,class');
-  // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress');
-  var mustUseProp = function (tag, type, attr) {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  makeMap('contenteditable,draggable,spellcheck');
-  makeMap('events,caret,typing,plaintext-only');
-  makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-
-  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  var isPreTag = function (tag) { return tag === 'pre'; };
-  var isReservedTag = function (tag) {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
-  makeMap('text,number,password,search,email,tel,url');
-
-  /**
-   * Query an element selector if it's not an element already.
-   */
-  function query(el) {
-      if (typeof el === 'string') {
-          var selected = document.querySelector(el);
-          if (!selected) {
-              warn$2('Cannot find element: ' + el);
-              return document.createElement('div');
-          }
-          return selected;
-      }
-      else {
-          return el;
-      }
-  }
-
-  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  var buildRegex = cached(function (delimiters) {
-      var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-      var close = delimiters[1].replace(regexEscapeRE, '\\$&');
+  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+  const buildRegex = cached((delimiters) => {
+      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
       return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
   });
   function parseText(text, delimiters) {
       //@ts-expect-error
-      var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
       if (!tagRE.test(text)) {
           return;
       }
-      var tokens = [];
-      var rawTokens = [];
-      var lastIndex = (tagRE.lastIndex = 0);
-      var match, index, tokenValue;
+      const tokens = [];
+      const rawTokens = [];
+      let lastIndex = (tagRE.lastIndex = 0);
+      let match, index, tokenValue;
       while ((match = tagRE.exec(text))) {
           index = match.index;
           // push text token
@@ -7950,8 +7974,8 @@
               tokens.push(JSON.stringify(tokenValue));
           }
           // tag token
-          var exp = parseFilters(match[1].trim());
-          tokens.push(("_s(" + exp + ")"));
+          const exp = parseFilters(match[1].trim());
+          tokens.push(`_s(${exp})`);
           rawTokens.push({ '@binding': exp });
           lastIndex = index + match[0].length;
       }
@@ -7966,32 +7990,32 @@
   }
 
   function transformNode$1(el, options) {
-      var warn = options.warn || baseWarn;
-      var staticClass = getAndRemoveAttr(el, 'class');
+      const warn = options.warn || baseWarn;
+      const staticClass = getAndRemoveAttr(el, 'class');
       if (staticClass) {
-          var res = parseText(staticClass, options.delimiters);
+          const res = parseText(staticClass, options.delimiters);
           if (res) {
-              warn("class=\"" + staticClass + "\": " +
+              warn(`class="${staticClass}": ` +
                   'Interpolation inside attributes has been removed. ' +
                   'Use v-bind or the colon shorthand instead. For example, ' +
                   'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
           }
       }
       if (staticClass) {
-          el.staticClass = JSON.stringify(staticClass);
+          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
       }
-      var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
       if (classBinding) {
           el.classBinding = classBinding;
       }
   }
   function genData$2(el) {
-      var data = '';
+      let data = '';
       if (el.staticClass) {
-          data += "staticClass:" + (el.staticClass) + ",";
+          data += `staticClass:${el.staticClass},`;
       }
       if (el.classBinding) {
-          data += "class:" + (el.classBinding) + ",";
+          data += `class:${el.classBinding},`;
       }
       return data;
   }
@@ -8002,14 +8026,14 @@
   };
 
   function transformNode(el, options) {
-      var warn = options.warn || baseWarn;
-      var staticStyle = getAndRemoveAttr(el, 'style');
+      const warn = options.warn || baseWarn;
+      const staticStyle = getAndRemoveAttr(el, 'style');
       if (staticStyle) {
           /* istanbul ignore if */
           {
-              var res = parseText(staticStyle, options.delimiters);
+              const res = parseText(staticStyle, options.delimiters);
               if (res) {
-                  warn("style=\"" + staticStyle + "\": " +
+                  warn(`style="${staticStyle}": ` +
                       'Interpolation inside attributes has been removed. ' +
                       'Use v-bind or the colon shorthand instead. For example, ' +
                       'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
@@ -8017,44 +8041,44 @@
           }
           el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
       }
-      var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
       if (styleBinding) {
           el.styleBinding = styleBinding;
       }
   }
   function genData$1(el) {
-      var data = '';
+      let data = '';
       if (el.staticStyle) {
-          data += "staticStyle:" + (el.staticStyle) + ",";
+          data += `staticStyle:${el.staticStyle},`;
       }
       if (el.styleBinding) {
-          data += "style:(" + (el.styleBinding) + "),";
+          data += `style:(${el.styleBinding}),`;
       }
       return data;
   }
   var style = {
       staticKeys: ['staticStyle'],
-      transformNode: transformNode,
+      transformNode,
       genData: genData$1,
   };
 
-  var decoder;
+  let decoder;
   var he = {
-      decode: function decode(html) {
+      decode(html) {
           decoder = decoder || document.createElement('div');
           decoder.innerHTML = html;
           return decoder.textContent;
       },
   };
 
-  makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
       'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
       'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
       'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
       'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
@@ -8064,21 +8088,21 @@
    * Not type-checking this file because it's mostly vendor code.
    */
   // Regular Expressions for parsing tags and attributes
-  var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-  var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp(("^<" + qnameCapture));
-  var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-  var doctype = /^<!DOCTYPE [^>]+>/i;
+  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+  const startTagOpen = new RegExp(`^<${qnameCapture}`);
+  const startTagClose = /^\s*(\/?)>/;
+  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+  const doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  var comment = /^<!\--/;
-  var conditionalComment = /^<!\[/;
+  const comment = /^<!\--/;
+  const conditionalComment = /^<!\[/;
   // Special Elements (can contain anything)
-  var isPlainTextElement = makeMap('script,style,textarea', true);
-  var reCache = {};
-  var decodingMap = {
+  const isPlainTextElement = makeMap('script,style,textarea', true);
+  const reCache = {};
+  const decodingMap = {
       '&lt;': '<',
       '&gt;': '>',
       '&quot;': '"',
@@ -8087,31 +8111,31 @@
       '&#9;': '\t',
       '&#39;': "'",
   };
-  var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
-  var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
+  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
   function decodeAttr(value, shouldDecodeNewlines) {
-      var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-      return value.replace(re, function (match) { return decodingMap[match]; });
+      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, (match) => decodingMap[match]);
   }
   function parseHTML(html, options) {
-      var stack = [];
-      var expectHTML = options.expectHTML;
-      var isUnaryTag = options.isUnaryTag || no;
-      var canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-      var index = 0;
-      var last, lastTag;
+      const stack = [];
+      const expectHTML = options.expectHTML;
+      const isUnaryTag = options.isUnaryTag || no;
+      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+      let index = 0;
+      let last, lastTag;
       while (html) {
           last = html;
           // Make sure we're not in a plaintext content element like script/style
           if (!lastTag || !isPlainTextElement(lastTag)) {
-              var textEnd = html.indexOf('<');
+              let textEnd = html.indexOf('<');
               if (textEnd === 0) {
                   // Comment:
                   if (comment.test(html)) {
-                      var commentEnd = html.indexOf('-->');
+                      const commentEnd = html.indexOf('-->');
                       if (commentEnd >= 0) {
                           if (options.shouldKeepComment) {
                               options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
@@ -8122,28 +8146,28 @@
                   }
                   // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
                   if (conditionalComment.test(html)) {
-                      var conditionalEnd = html.indexOf(']>');
+                      const conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
                           advance(conditionalEnd + 2);
                           continue;
                       }
                   }
                   // Doctype:
-                  var doctypeMatch = html.match(doctype);
+                  const doctypeMatch = html.match(doctype);
                   if (doctypeMatch) {
                       advance(doctypeMatch[0].length);
                       continue;
                   }
                   // End tag:
-                  var endTagMatch = html.match(endTag);
+                  const endTagMatch = html.match(endTag);
                   if (endTagMatch) {
-                      var curIndex = index;
+                      const curIndex = index;
                       advance(endTagMatch[0].length);
                       parseEndTag(endTagMatch[1], curIndex, index);
                       continue;
                   }
                   // Start tag:
-                  var startTagMatch = parseStartTag();
+                  const startTagMatch = parseStartTag();
                   if (startTagMatch) {
                       handleStartTag(startTagMatch);
                       if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
@@ -8152,7 +8176,7 @@
                       continue;
                   }
               }
-              var text = (void 0), rest = (void 0), next = (void 0);
+              let text, rest, next;
               if (textEnd >= 0) {
                   rest = html.slice(textEnd);
                   while (!endTag.test(rest) &&
@@ -8162,7 +8186,7 @@
                       // < in plain text, be forgiving and treat it as text
                       next = rest.indexOf('<', 1);
                       if (next < 0)
-                          { break; }
+                          break;
                       textEnd += next;
                       rest = html.slice(textEnd);
                   }
@@ -8179,11 +8203,11 @@
               }
           }
           else {
-              var endTagLength = 0;
-              var stackedTag = lastTag.toLowerCase();
-              var reStackedTag = reCache[stackedTag] ||
+              let endTagLength = 0;
+              const stackedTag = lastTag.toLowerCase();
+              const reStackedTag = reCache[stackedTag] ||
                   (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
+              const rest = html.replace(reStackedTag, function (all, text, endTag) {
                   endTagLength = endTag.length;
                   if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
                       text = text
@@ -8198,15 +8222,15 @@
                   }
                   return '';
               });
-              index += html.length - rest$1.length;
-              html = rest$1;
+              index += html.length - rest.length;
+              html = rest;
               parseEndTag(stackedTag, index - endTagLength, index);
           }
           if (html === last) {
               options.chars && options.chars(html);
               if (!stack.length &&
                   options.warn) {
-                  options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), {
+                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
                       start: index + html.length,
                   });
               }
@@ -8220,15 +8244,15 @@
           html = html.substring(n);
       }
       function parseStartTag() {
-          var start = html.match(startTagOpen);
+          const start = html.match(startTagOpen);
           if (start) {
-              var match = {
+              const match = {
                   tagName: start[1],
                   attrs: [],
                   start: index,
               };
               advance(start[0].length);
-              var end, attr;
+              let end, attr;
               while (!(end = html.match(startTagClose)) &&
                   (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
                   attr.start = index;
@@ -8245,8 +8269,8 @@
           }
       }
       function handleStartTag(match) {
-          var tagName = match.tagName;
-          var unarySlash = match.unarySlash;
+          const tagName = match.tagName;
+          const unarySlash = match.unarySlash;
           if (expectHTML) {
               if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
                   parseEndTag(lastTag);
@@ -8255,13 +8279,13 @@
                   parseEndTag(tagName);
               }
           }
-          var unary = isUnaryTag(tagName) || !!unarySlash;
-          var l = match.attrs.length;
-          var attrs = new Array(l);
-          for (var i = 0; i < l; i++) {
-              var args = match.attrs[i];
-              var value = args[3] || args[4] || args[5] || '';
-              var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+          const unary = isUnaryTag(tagName) || !!unarySlash;
+          const l = match.attrs.length;
+          const attrs = new Array(l);
+          for (let i = 0; i < l; i++) {
+              const args = match.attrs[i];
+              const value = args[3] || args[4] || args[5] || '';
+              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
                   ? options.shouldDecodeNewlinesForHref
                   : options.shouldDecodeNewlines;
               attrs[i] = {
@@ -8288,11 +8312,11 @@
           }
       }
       function parseEndTag(tagName, start, end) {
-          var pos, lowerCasedTagName;
+          let pos, lowerCasedTagName;
           if (start == null)
-              { start = index; }
+              start = index;
           if (end == null)
-              { end = index; }
+              end = index;
           // Find the closest opened tag of the same type
           if (tagName) {
               lowerCasedTagName = tagName.toLowerCase();
@@ -8308,10 +8332,10 @@
           }
           if (pos >= 0) {
               // Close all the open elements, up the stack
-              for (var i = stack.length - 1; i >= pos; i--) {
+              for (let i = stack.length - 1; i >= pos; i--) {
                   if ((i > pos || !tagName) &&
                       options.warn) {
-                      options.warn(("tag <" + (stack[i].tag) + "> has no matching end tag."), {
+                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
                           start: stack[i].start,
                           end: stack[i].end,
                       });
@@ -8340,39 +8364,39 @@
       }
   }
 
-  var onRE = /^@|^v-on:/;
-  var dirRE = /^v-|^@|^:|^#/;
-  var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  var stripParensRE = /^\(|\)$/g;
-  var dynamicArgRE = /^\[.*\]$/;
-  var argRE = /:(.*)$/;
-  var bindRE = /^:|^\.|^v-bind:/;
-  var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-  var slotRE = /^v-slot(:|$)|^#/;
-  var lineBreakRE = /[\r\n]/;
-  var whitespaceRE = /[ \f\t\r\n]+/g;
-  var invalidAttributeRE = /[\s"'<>\/=]/;
-  var decodeHTMLCached = cached(he.decode);
-  var emptySlotScopeToken = "_empty_";
+  const onRE = /^@|^v-on:/;
+  const dirRE = /^v-|^@|^:|^#/;
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  const dynamicArgRE = /^\[.*\]$/;
+  const argRE = /:(.*)$/;
+  const bindRE = /^:|^\.|^v-bind:/;
+  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+  const slotRE = /^v-slot(:|$)|^#/;
+  const lineBreakRE = /[\r\n]/;
+  const whitespaceRE = /[ \f\t\r\n]+/g;
+  const invalidAttributeRE = /[\s"'<>\/=]/;
+  const decodeHTMLCached = cached(he.decode);
+  const emptySlotScopeToken = `_empty_`;
   // configurable state
-  var warn$1;
-  var delimiters;
-  var transforms;
-  var preTransforms;
-  var postTransforms;
-  var platformIsPreTag;
-  var platformMustUseProp;
-  var platformGetTagNamespace;
-  var maybeComponent;
+  let warn;
+  let delimiters;
+  let transforms;
+  let preTransforms;
+  let postTransforms;
+  let platformIsPreTag;
+  let platformMustUseProp;
+  let platformGetTagNamespace;
+  let maybeComponent;
   function createASTElement(tag, attrs, parent) {
       return {
           type: 1,
-          tag: tag,
+          tag,
           attrsList: attrs,
           attrsMap: makeAttrsMap(attrs),
           rawAttrsMap: {},
-          parent: parent,
+          parent,
           children: [],
       };
   }
@@ -8380,31 +8404,31 @@
    * Convert HTML string to AST.
    */
   function parse(template, options) {
-      warn$1 = options.warn || baseWarn;
+      warn = options.warn || baseWarn;
       platformIsPreTag = options.isPreTag || no;
       platformMustUseProp = options.mustUseProp || no;
       platformGetTagNamespace = options.getTagNamespace || no;
-      var isReservedTag = options.isReservedTag || no;
-      maybeComponent = function (el) { return !!(el.component ||
+      const isReservedTag = options.isReservedTag || no;
+      maybeComponent = (el) => !!(el.component ||
           el.attrsMap[':is'] ||
           el.attrsMap['v-bind:is'] ||
-          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))); };
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
       transforms = pluckModuleFunction(options.modules, 'transformNode');
       preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
       postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
       delimiters = options.delimiters;
-      var stack = [];
-      var preserveWhitespace = options.preserveWhitespace !== false;
-      var whitespaceOption = options.whitespace;
-      var root;
-      var currentParent;
-      var inVPre = false;
-      var inPre = false;
-      var warned = false;
+      const stack = [];
+      const preserveWhitespace = options.preserveWhitespace !== false;
+      const whitespaceOption = options.whitespace;
+      let root;
+      let currentParent;
+      let inVPre = false;
+      let inPre = false;
+      let warned = false;
       function warnOnce(msg, range) {
           if (!warned) {
               warned = true;
-              warn$1(msg, range);
+              warn(msg, range);
           }
       }
       function closeElement(element) {
@@ -8425,9 +8449,9 @@
                   });
               }
               else {
-                  warnOnce("Component template should contain exactly one root element. " +
-                      "If you are using v-if on multiple elements, " +
-                      "use v-else-if to chain them instead.", { start: element.start });
+                  warnOnce(`Component template should contain exactly one root element. ` +
+                      `If you are using v-if on multiple elements, ` +
+                      `use v-else-if to chain them instead.`, { start: element.start });
               }
           }
           if (currentParent && !element.forbidden) {
@@ -8439,7 +8463,7 @@
                       // scoped slot
                       // keep it in the children list so that v-else(-if) conditions can
                       // find it as the prev node.
-                      var name = element.slotTarget || '"default"';
+                      const name = element.slotTarget || '"default"';
                       (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
                   }
                   currentParent.children.push(element);
@@ -8448,7 +8472,7 @@
           }
           // final children cleanup
           // filter out scoped slots
-          element.children = element.children.filter(function (c) { return !c.slotScope; });
+          element.children = element.children.filter((c) => !c.slotScope);
           // remove trailing whitespace node again
           trimEndingWhitespace(element);
           // check pre state
@@ -8459,14 +8483,14 @@
               inPre = false;
           }
           // apply post-transforms
-          for (var i = 0; i < postTransforms.length; i++) {
+          for (let i = 0; i < postTransforms.length; i++) {
               postTransforms[i](element, options);
           }
       }
       function trimEndingWhitespace(el) {
           // remove trailing whitespace node
           if (!inPre) {
-              var lastNode;
+              let lastNode;
               while ((lastNode = el.children[el.children.length - 1]) &&
                   lastNode.type === 3 &&
                   lastNode.text === ' ') {
@@ -8476,7 +8500,7 @@
       }
       function checkRootConstraints(el) {
           if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce("Cannot use <" + (el.tag) + "> as component root element because it may " +
+              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
                   'contain multiple nodes.', { start: el.start });
           }
           if (el.attrsMap.hasOwnProperty('v-for')) {
@@ -8485,7 +8509,7 @@
           }
       }
       parseHTML(template, {
-          warn: warn$1,
+          warn,
           expectHTML: options.expectHTML,
           isUnaryTag: options.isUnaryTag,
           canBeLeftOpenTag: options.canBeLeftOpenTag,
@@ -8493,33 +8517,33 @@
           shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
           shouldKeepComment: options.comments,
           outputSourceRange: options.outputSourceRange,
-          start: function start(tag, attrs, unary, start$1, end) {
+          start(tag, attrs, unary, start, end) {
               // check namespace.
               // inherit parent ns if there is one
-              var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
               // handle IE svg bug
               /* istanbul ignore if */
               if (isIE && ns === 'svg') {
                   attrs = guardIESVGBug(attrs);
               }
-              var element = createASTElement(tag, attrs, currentParent);
+              let element = createASTElement(tag, attrs, currentParent);
               if (ns) {
                   element.ns = ns;
               }
               {
                   if (options.outputSourceRange) {
-                      element.start = start$1;
+                      element.start = start;
                       element.end = end;
-                      element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
+                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
                           cumulated[attr.name] = attr;
                           return cumulated;
                       }, {});
                   }
-                  attrs.forEach(function (attr) {
+                  attrs.forEach((attr) => {
                       if (invalidAttributeRE.test(attr.name)) {
-                          warn$1("Invalid dynamic argument expression: attribute names cannot contain " +
-                              "spaces, quotes, <, >, / or =.", {
-                              start: attr.start + attr.name.indexOf("["),
+                          warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                              `spaces, quotes, <, >, / or =.`, {
+                              start: attr.start + attr.name.indexOf(`[`),
                               end: attr.start + attr.name.length,
                           });
                       }
@@ -8527,13 +8551,13 @@
               }
               if (isForbiddenTag(element) && !isServerRendering()) {
                   element.forbidden = true;
-                  warn$1('Templates should only be responsible for mapping the state to the ' +
+                  warn('Templates should only be responsible for mapping the state to the ' +
                           'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          "<" + tag + ">" +
+                          `<${tag}>` +
                           ', as they will not be parsed.', { start: element.start });
               }
               // apply pre-transforms
-              for (var i = 0; i < preTransforms.length; i++) {
+              for (let i = 0; i < preTransforms.length; i++) {
                   element = preTransforms[i](element, options) || element;
               }
               if (!inVPre) {
@@ -8568,25 +8592,25 @@
                   closeElement(element);
               }
           },
-          end: function end(tag, start, end$1) {
-              var element = stack[stack.length - 1];
+          end(tag, start, end) {
+              const element = stack[stack.length - 1];
               // pop stack
               stack.length -= 1;
               currentParent = stack[stack.length - 1];
               if (options.outputSourceRange) {
-                  element.end = end$1;
+                  element.end = end;
               }
               closeElement(element);
           },
-          chars: function chars(text, start, end) {
+          chars(text, start, end) {
               if (!currentParent) {
                   {
                       if (text === template) {
-                          warnOnce('Component template requires a root element, rather than just text.', { start: start });
+                          warnOnce('Component template requires a root element, rather than just text.', { start });
                       }
                       else if ((text = text.trim())) {
-                          warnOnce(("text \"" + text + "\" outside root element will be ignored."), {
-                              start: start,
+                          warnOnce(`text "${text}" outside root element will be ignored.`, {
+                              start,
                           });
                       }
                   }
@@ -8599,7 +8623,7 @@
                   currentParent.attrsMap.placeholder === text) {
                   return;
               }
-              var children = currentParent.children;
+              const children = currentParent.children;
               if (inPre || text.trim()) {
                   text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
               }
@@ -8625,14 +8649,14 @@
                       // condense consecutive whitespaces into single space
                       text = text.replace(whitespaceRE, ' ');
                   }
-                  var res;
-                  var child;
+                  let res;
+                  let child;
                   if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
                       child = {
                           type: 2,
                           expression: res.expression,
                           tokens: res.tokens,
-                          text: text,
+                          text,
                       };
                   }
                   else if (text !== ' ' ||
@@ -8640,7 +8664,7 @@
                       children[children.length - 1].text !== ' ') {
                       child = {
                           type: 3,
-                          text: text,
+                          text,
                       };
                   }
                   if (child) {
@@ -8652,13 +8676,13 @@
                   }
               }
           },
-          comment: function comment(text, start, end) {
+          comment(text, start, end) {
               // adding anything as a sibling to the root node is forbidden
               // comments should still be allowed, but ignored
               if (currentParent) {
-                  var child = {
+                  const child = {
                       type: 3,
-                      text: text,
+                      text,
                       isComment: true,
                   };
                   if (options.outputSourceRange) {
@@ -8677,11 +8701,11 @@
       }
   }
   function processRawAttrs(el) {
-      var list = el.attrsList;
-      var len = list.length;
+      const list = el.attrsList;
+      const len = list.length;
       if (len) {
-          var attrs = (el.attrs = new Array(len));
-          for (var i = 0; i < len; i++) {
+          const attrs = (el.attrs = new Array(len));
+          for (let i = 0; i < len; i++) {
               attrs[i] = {
                   name: list[i].name,
                   value: JSON.stringify(list[i].value),
@@ -8707,28 +8731,28 @@
       processSlotContent(element);
       processSlotOutlet(element);
       processComponent(element);
-      for (var i = 0; i < transforms.length; i++) {
+      for (let i = 0; i < transforms.length; i++) {
           element = transforms[i](element, options) || element;
       }
       processAttrs(element);
       return element;
   }
   function processKey(el) {
-      var exp = getBindingAttr(el, 'key');
+      const exp = getBindingAttr(el, 'key');
       if (exp) {
           {
               if (el.tag === 'template') {
-                  warn$1("<template> cannot be keyed. Place the key on real elements instead.", getRawBindingAttr(el, 'key'));
+                  warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
               }
               if (el.for) {
-                  var iterator = el.iterator2 || el.iterator1;
-                  var parent = el.parent;
+                  const iterator = el.iterator2 || el.iterator1;
+                  const parent = el.parent;
                   if (iterator &&
                       iterator === exp &&
                       parent &&
                       parent.tag === 'transition-group') {
-                      warn$1("Do not use v-for index as key on <transition-group> children, " +
-                          "this is the same as not using keys.", getRawBindingAttr(el, 'key'), true /* tip */);
+                      warn(`Do not use v-for index as key on <transition-group> children, ` +
+                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
                   }
               }
           }
@@ -8736,32 +8760,32 @@
       }
   }
   function processRef(el) {
-      var ref = getBindingAttr(el, 'ref');
+      const ref = getBindingAttr(el, 'ref');
       if (ref) {
           el.ref = ref;
           el.refInFor = checkInFor(el);
       }
   }
   function processFor(el) {
-      var exp;
+      let exp;
       if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-          var res = parseFor(exp);
+          const res = parseFor(exp);
           if (res) {
               extend(el, res);
           }
           else {
-              warn$1(("Invalid v-for expression: " + exp), el.rawAttrsMap['v-for']);
+              warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
           }
       }
   }
   function parseFor(exp) {
-      var inMatch = exp.match(forAliasRE);
+      const inMatch = exp.match(forAliasRE);
       if (!inMatch)
-          { return; }
-      var res = {};
+          return;
+      const res = {};
       res.for = inMatch[2].trim();
-      var alias = inMatch[1].trim().replace(stripParensRE, '');
-      var iteratorMatch = alias.match(forIteratorRE);
+      const alias = inMatch[1].trim().replace(stripParensRE, '');
+      const iteratorMatch = alias.match(forIteratorRE);
       if (iteratorMatch) {
           res.alias = alias.replace(forIteratorRE, '').trim();
           res.iterator1 = iteratorMatch[1].trim();
@@ -8775,7 +8799,7 @@
       return res;
   }
   function processIf(el) {
-      var exp = getAndRemoveAttr(el, 'v-if');
+      const exp = getAndRemoveAttr(el, 'v-if');
       if (exp) {
           el.if = exp;
           addIfCondition(el, {
@@ -8787,14 +8811,14 @@
           if (getAndRemoveAttr(el, 'v-else') != null) {
               el.else = true;
           }
-          var elseif = getAndRemoveAttr(el, 'v-else-if');
+          const elseif = getAndRemoveAttr(el, 'v-else-if');
           if (elseif) {
               el.elseif = elseif;
           }
       }
   }
   function processIfConditions(el, parent) {
-      var prev = findPrevElement(parent.children);
+      const prev = findPrevElement(parent.children);
       if (prev && prev.if) {
           addIfCondition(prev, {
               exp: el.elseif,
@@ -8802,20 +8826,20 @@
           });
       }
       else {
-          warn$1("v-" + (el.elseif ? 'else-if="' + el.elseif + '"' : 'else') + " " +
-              "used on element <" + (el.tag) + "> without corresponding v-if.", el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+          warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
       }
   }
   function findPrevElement(children) {
-      var i = children.length;
+      let i = children.length;
       while (i--) {
           if (children[i].type === 1) {
               return children[i];
           }
           else {
               if (children[i].text !== ' ') {
-                  warn$1("text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-                      "will be ignored.", children[i]);
+                  warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                      `will be ignored.`, children[i]);
               }
               children.pop();
           }
@@ -8828,7 +8852,7 @@
       el.ifConditions.push(condition);
   }
   function processOnce(el) {
-      var once = getAndRemoveAttr(el, 'v-once');
+      const once = getAndRemoveAttr(el, 'v-once');
       if (once != null) {
           el.once = true;
       }
@@ -8836,29 +8860,29 @@
   // handle content being passed to a component as slot,
   // e.g. <template slot="xxx">, <div slot-scope="xxx">
   function processSlotContent(el) {
-      var slotScope;
+      let slotScope;
       if (el.tag === 'template') {
           slotScope = getAndRemoveAttr(el, 'scope');
           /* istanbul ignore if */
           if (slotScope) {
-              warn$1("the \"scope\" attribute for scoped slots have been deprecated and " +
-                  "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-                  "can also be used on plain elements in addition to <template> to " +
-                  "denote scoped slots.", el.rawAttrsMap['scope'], true);
+              warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                  `can also be used on plain elements in addition to <template> to ` +
+                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
           }
           el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
       }
       else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
           /* istanbul ignore if */
           if (el.attrsMap['v-for']) {
-              warn$1("Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-                  "(v-for takes higher priority). Use a wrapper <template> for the " +
-                  "scoped slot to make it clearer.", el.rawAttrsMap['slot-scope'], true);
+              warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
           }
           el.slotScope = slotScope;
       }
       // slot="xxx"
-      var slotTarget = getBindingAttr(el, 'slot');
+      const slotTarget = getBindingAttr(el, 'slot');
       if (slotTarget) {
           el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
           el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
@@ -8872,20 +8896,18 @@
       {
           if (el.tag === 'template') {
               // v-slot on <template>
-              var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
               if (slotBinding) {
                   {
                       if (el.slotTarget || el.slotScope) {
-                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                       }
                       if (el.parent && !maybeComponent(el.parent)) {
-                          warn$1("<template v-slot> can only appear at the root level inside " +
-                              "the receiving component", el);
+                          warn(`<template v-slot> can only appear at the root level inside ` +
+                              `the receiving component`, el);
                       }
                   }
-                  var ref = getSlotName(slotBinding);
-                  var name = ref.name;
-                  var dynamic = ref.dynamic;
+                  const { name, dynamic } = getSlotName(slotBinding);
                   el.slotTarget = name;
                   el.slotTargetDynamic = dynamic;
                   el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
@@ -8893,35 +8915,33 @@
           }
           else {
               // v-slot on component, denotes default slot
-              var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding$1) {
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
                   {
                       if (!maybeComponent(el)) {
-                          warn$1("v-slot can only be used on components or <template>.", slotBinding$1);
+                          warn(`v-slot can only be used on components or <template>.`, slotBinding);
                       }
                       if (el.slotScope || el.slotTarget) {
-                          warn$1("Unexpected mixed usage of different slot syntaxes.", el);
+                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
                       }
                       if (el.scopedSlots) {
-                          warn$1("To avoid scope ambiguity, the default slot should also use " +
-                              "<template> syntax when there are other named slots.", slotBinding$1);
+                          warn(`To avoid scope ambiguity, the default slot should also use ` +
+                              `<template> syntax when there are other named slots.`, slotBinding);
                       }
                   }
                   // add the component's children to its default slot
-                  var slots = el.scopedSlots || (el.scopedSlots = {});
-                  var ref$1 = getSlotName(slotBinding$1);
-                  var name$1 = ref$1.name;
-                  var dynamic$1 = ref$1.dynamic;
-                  var slotContainer = (slots[name$1] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name$1;
-                  slotContainer.slotTargetDynamic = dynamic$1;
-                  slotContainer.children = el.children.filter(function (c) {
+                  const slots = el.scopedSlots || (el.scopedSlots = {});
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  const slotContainer = (slots[name] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name;
+                  slotContainer.slotTargetDynamic = dynamic;
+                  slotContainer.children = el.children.filter((c) => {
                       if (!c.slotScope) {
                           c.parent = slotContainer;
                           return true;
                       }
                   });
-                  slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
+                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
                   // remove children as they are returned from scopedSlots now
                   el.children = [];
                   // mark el non-plain so data gets generated
@@ -8931,34 +8951,34 @@
       }
   }
   function getSlotName(binding) {
-      var name = binding.name.replace(slotRE, '');
+      let name = binding.name.replace(slotRE, '');
       if (!name) {
           if (binding.name[0] !== '#') {
               name = 'default';
           }
           else {
-              warn$1("v-slot shorthand syntax requires a slot name.", binding);
+              warn(`v-slot shorthand syntax requires a slot name.`, binding);
           }
       }
       return dynamicArgRE.test(name)
           ? // dynamic [name]
               { name: name.slice(1, -1), dynamic: true }
           : // static name
-              { name: ("\"" + name + "\""), dynamic: false };
+              { name: `"${name}"`, dynamic: false };
   }
   // handle <slot/> outlets
   function processSlotOutlet(el) {
       if (el.tag === 'slot') {
           el.slotName = getBindingAttr(el, 'name');
           if (el.key) {
-              warn$1("`key` does not work on <slot> because slots are abstract outlets " +
-                  "and can possibly expand into multiple elements. " +
-                  "Use the key on a wrapping element instead.", getRawBindingAttr(el, 'key'));
+              warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                  `and can possibly expand into multiple elements. ` +
+                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
           }
       }
   }
   function processComponent(el) {
-      var binding;
+      let binding;
       if ((binding = getBindingAttr(el, 'is'))) {
           el.component = binding;
       }
@@ -8967,8 +8987,8 @@
       }
   }
   function processAttrs(el) {
-      var list = el.attrsList;
-      var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      const list = el.attrsList;
+      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
       for (i = 0, l = list.length; i < l; i++) {
           name = rawName = list[i].name;
           value = list[i].value;
@@ -8990,28 +9010,28 @@
                       name = name.slice(1, -1);
                   }
                   if (value.trim().length === 0) {
-                      warn$1(("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\""));
+                      warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
                   }
                   if (modifiers) {
                       if (modifiers.prop && !isDynamic) {
                           name = camelize(name);
                           if (name === 'innerHtml')
-                              { name = 'innerHTML'; }
+                              name = 'innerHTML';
                       }
                       if (modifiers.camel && !isDynamic) {
                           name = camelize(name);
                       }
                       if (modifiers.sync) {
-                          syncGen = genAssignmentCode(value, "$event");
+                          syncGen = genAssignmentCode(value, `$event`);
                           if (!isDynamic) {
-                              addHandler(el, ("update:" + (camelize(name))), syncGen, null, false, warn$1, list[i]);
+                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
                               if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, ("update:" + (hyphenate(name))), syncGen, null, false, warn$1, list[i]);
+                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
                               }
                           }
                           else {
                               // handler w/ dynamic event name
-                              addHandler(el, ("\"update:\"+(" + name + ")"), syncGen, null, false, warn$1, list[i], true // dynamic
+                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
                               );
                           }
                       }
@@ -9031,14 +9051,14 @@
                   if (isDynamic) {
                       name = name.slice(1, -1);
                   }
-                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+                  addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
               }
               else {
                   // normal directives
                   name = name.replace(dirRE, '');
                   // parse arg
-                  var argMatch = name.match(argRE);
-                  var arg = argMatch && argMatch[1];
+                  const argMatch = name.match(argRE);
+                  let arg = argMatch && argMatch[1];
                   isDynamic = false;
                   if (arg) {
                       name = name.slice(0, -(arg.length + 1));
@@ -9056,9 +9076,9 @@
           else {
               // literal attribute
               {
-                  var res = parseText(value, delimiters);
+                  const res = parseText(value, delimiters);
                   if (res) {
-                      warn$1(name + "=\"" + value + "\": " +
+                      warn(`${name}="${value}": ` +
                           'Interpolation inside attributes has been removed. ' +
                           'Use v-bind or the colon shorthand instead. For example, ' +
                           'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
@@ -9076,7 +9096,7 @@
       }
   }
   function checkInFor(el) {
-      var parent = el;
+      let parent = el;
       while (parent) {
           if (parent.for !== undefined) {
               return true;
@@ -9086,22 +9106,22 @@
       return false;
   }
   function parseModifiers(name) {
-      var match = name.match(modifierRE);
+      const match = name.match(modifierRE);
       if (match) {
-          var ret = {};
-          match.forEach(function (m) {
+          const ret = {};
+          match.forEach((m) => {
               ret[m.slice(1)] = true;
           });
           return ret;
       }
   }
   function makeAttrsMap(attrs) {
-      var map = {};
-      for (var i = 0, l = attrs.length; i < l; i++) {
+      const map = {};
+      for (let i = 0, l = attrs.length; i < l; i++) {
           if (map[attrs[i].name] &&
               !isIE &&
               !isEdge) {
-              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+              warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
           }
           map[attrs[i].name] = attrs[i].value;
       }
@@ -9116,13 +9136,13 @@
           (el.tag === 'script' &&
               (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
   }
-  var ieNSBug = /^xmlns:NS\d+/;
-  var ieNSPrefix = /^NS\d+:/;
+  const ieNSBug = /^xmlns:NS\d+/;
+  const ieNSPrefix = /^NS\d+:/;
   /* istanbul ignore next */
   function guardIESVGBug(attrs) {
-      var res = [];
-      for (var i = 0; i < attrs.length; i++) {
-          var attr = attrs[i];
+      const res = [];
+      for (let i = 0; i < attrs.length; i++) {
+          const attr = attrs[i];
           if (!ieNSBug.test(attr.name)) {
               attr.name = attr.name.replace(ieNSPrefix, '');
               res.push(attr);
@@ -9131,14 +9151,14 @@
       return res;
   }
   function checkForAliasModel(el, value) {
-      var _el = el;
+      let _el = el;
       while (_el) {
           if (_el.for && _el.alias === value) {
-              warn$1("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-                  "You are binding v-model directly to a v-for iteration alias. " +
-                  "This will not be able to modify the v-for source array because " +
-                  "writing to the alias is like modifying a function local variable. " +
-                  "Consider using an array of objects and use v-model on an object property instead.", el.rawAttrsMap['v-model']);
+              warn(`<${el.tag} v-model="${value}">: ` +
+                  `You are binding v-model directly to a v-for iteration alias. ` +
+                  `This will not be able to modify the v-for source array because ` +
+                  `writing to the alias is like modifying a function local variable. ` +
+                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
           }
           _el = _el.parent;
       }
@@ -9155,45 +9175,45 @@
    */
   function preTransformNode(el, options) {
       if (el.tag === 'input') {
-          var map = el.attrsMap;
+          const map = el.attrsMap;
           if (!map['v-model']) {
               return;
           }
-          var typeBinding;
+          let typeBinding;
           if (map[':type'] || map['v-bind:type']) {
               typeBinding = getBindingAttr(el, 'type');
           }
           if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = "(" + (map['v-bind']) + ").type";
+              typeBinding = `(${map['v-bind']}).type`;
           }
           if (typeBinding) {
-              var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-              var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-              var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
               // 1. checkbox
-              var branch0 = cloneASTElement(el);
+              const branch0 = cloneASTElement(el);
               // process for on the main node
               processFor(branch0);
               addRawAttr(branch0, 'type', 'checkbox');
               processElement(branch0, options);
               branch0.processed = true; // prevent it from double-processed
-              branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
+              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
               addIfCondition(branch0, {
                   exp: branch0.if,
                   block: branch0,
               });
               // 2. add radio else-if condition
-              var branch1 = cloneASTElement(el);
+              const branch1 = cloneASTElement(el);
               getAndRemoveAttr(branch1, 'v-for', true);
               addRawAttr(branch1, 'type', 'radio');
               processElement(branch1, options);
               addIfCondition(branch0, {
-                  exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
+                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
                   block: branch1,
               });
               // 3. other
-              var branch2 = cloneASTElement(el);
+              const branch2 = cloneASTElement(el);
               getAndRemoveAttr(branch2, 'v-for', true);
               addRawAttr(branch2, ':type', typeBinding);
               processElement(branch2, options);
@@ -9214,184 +9234,46 @@
   function cloneASTElement(el) {
       return createASTElement(el.tag, el.attrsList.slice(), el.parent);
   }
-  var model$1 = {
-      preTransformNode: preTransformNode,
+  var model = {
+      preTransformNode,
   };
 
-  var modules = [klass, style, model$1];
-
-  var warn;
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r';
-  function model(el, dir, _warn) {
-      warn = _warn;
-      var value = dir.value;
-      var modifiers = dir.modifiers;
-      var tag = el.tag;
-      var type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn("<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-                  "File inputs are read only. Use a v-on:change listener instead.", el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else if (!config.isReservedTag(tag)) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else {
-          warn("<" + (el.tag) + " v-model=\"" + value + "\">: " +
-              "v-model is not supported on this element type. " +
-              "If you are working with contenteditable, it's recommended to " +
-              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      var number = modifiers && modifiers.number;
-      var valueBinding = getBindingAttr(el, 'value') || 'null';
-      var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', "Array.isArray(" + value + ")" +
-          "?_i(" + value + "," + valueBinding + ")>-1" +
-          (trueValueBinding === 'true'
-              ? (":(" + value + ")")
-              : (":_q(" + value + "," + trueValueBinding + ")")));
-      addHandler(el, 'change', "var $$a=" + value + "," +
-          '$$el=$event.target,' +
-          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-          'if(Array.isArray($$a)){' +
-          "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-          "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-          "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-          "}else{" + (genAssignmentCode(value, '$$c')) + "}", null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      var number = modifiers && modifiers.number;
-      var valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-      addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      var number = modifiers && modifiers.number;
-      var selectedVal = "Array.prototype.filter" +
-          ".call($event.target.options,function(o){return o.selected})" +
-          ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-          "return " + (number ? '_n(val)' : 'val') + "})";
-      var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      var code = "var $$selectedVal = " + selectedVal + ";";
-      code = code + " " + (genAssignmentCode(value, assignment));
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      var type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value$1 && !typeBinding) {
-              var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      var ref = modifiers || {};
-      var lazy = ref.lazy;
-      var number = ref.number;
-      var trim = ref.trim;
-      var needCompositionGuard = !lazy && type !== 'range';
-      var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      var valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = "$event.target.value.trim()";
-      }
-      if (number) {
-          valueExpression = "_n(" + valueExpression + ")";
-      }
-      var code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = "if($event.target.composing)return;" + code;
-      }
-      addProp(el, 'value', ("(" + value + ")"));
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
-  }
+  var modules = [klass, style, model];
 
   function text(el, dir) {
       if (dir.value) {
-          addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'textContent', `_s(${dir.value})`, dir);
       }
   }
 
   function html(el, dir) {
       if (dir.value) {
-          addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
       }
   }
 
   var directives = {
-      model: model,
-      text: text,
-      html: html,
+      model: model$1,
+      text,
+      html,
   };
 
-  var isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr');
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  var canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-      'title,tr,track');
-
-  var baseOptions = {
+  const baseOptions = {
       expectHTML: true,
-      modules: modules,
-      directives: directives,
-      isPreTag: isPreTag,
-      isUnaryTag: isUnaryTag,
-      mustUseProp: mustUseProp,
-      canBeLeftOpenTag: canBeLeftOpenTag,
-      isReservedTag: isReservedTag,
-      getTagNamespace: getTagNamespace,
-      // @ts-ignore
+      modules,
+      directives,
+      isPreTag,
+      isUnaryTag,
+      mustUseProp,
+      canBeLeftOpenTag,
+      isReservedTag,
+      getTagNamespace,
       staticKeys: genStaticKeys$1(modules),
   };
 
-  var isStaticKey;
-  var isPlatformReservedTag;
-  var genStaticKeysCached = cached(genStaticKeys);
+  let isStaticKey;
+  let isPlatformReservedTag;
+  const genStaticKeysCached = cached(genStaticKeys);
   /**
    * Goal of the optimizer: walk the generated template AST tree
    * and detect sub-trees that are purely static, i.e. parts of
@@ -9405,7 +9287,7 @@
    */
   function optimize(root, options) {
       if (!root)
-          { return; }
+          return;
       isStaticKey = genStaticKeysCached(options.staticKeys || '');
       isPlatformReservedTag = options.isReservedTag || no;
       // first pass: mark all non-static nodes.
@@ -9428,16 +9310,16 @@
               node.attrsMap['inline-template'] == null) {
               return;
           }
-          for (var i = 0, l = node.children.length; i < l; i++) {
-              var child = node.children[i];
+          for (let i = 0, l = node.children.length; i < l; i++) {
+              const child = node.children[i];
               markStatic(child);
               if (!child.static) {
                   node.static = false;
               }
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  var block = node.ifConditions[i$1].block;
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  const block = node.ifConditions[i].block;
                   markStatic(block);
                   if (!block.static) {
                       node.static = false;
@@ -9464,13 +9346,13 @@
               node.staticRoot = false;
           }
           if (node.children) {
-              for (var i = 0, l = node.children.length; i < l; i++) {
+              for (let i = 0, l = node.children.length; i < l; i++) {
                   markStaticRoots(node.children[i], isInFor || !!node.for);
               }
           }
           if (node.ifConditions) {
-              for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-                  markStaticRoots(node.ifConditions[i$1].block, isInFor);
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  markStaticRoots(node.ifConditions[i].block, isInFor);
               }
           }
       }
@@ -9506,11 +9388,11 @@
       return false;
   }
 
-  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  var fnInvokeRE = /\([^)]*?\);*$/;
-  var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+  const fnInvokeRE = /\([^)]*?\);*$/;
+  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
   // KeyboardEvent.keyCode aliases
-  var keyCodes = {
+  const keyCodes = {
       esc: 27,
       tab: 9,
       enter: 13,
@@ -9522,7 +9404,7 @@
       delete: [8, 46],
   };
   // KeyboardEvent.key aliases
-  var keyNames = {
+  const keyNames = {
       // #7880: IE11 and Edge use `Esc` for Escape key name.
       esc: ['Esc', 'Escape'],
       tab: 'Tab',
@@ -9540,36 +9422,36 @@
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-  var modifierCode = {
+  const genGuard = (condition) => `if(${condition})return null;`;
+  const modifierCode = {
       stop: '$event.stopPropagation();',
       prevent: '$event.preventDefault();',
-      self: genGuard("$event.target !== $event.currentTarget"),
-      ctrl: genGuard("!$event.ctrlKey"),
-      shift: genGuard("!$event.shiftKey"),
-      alt: genGuard("!$event.altKey"),
-      meta: genGuard("!$event.metaKey"),
-      left: genGuard("'button' in $event && $event.button !== 0"),
-      middle: genGuard("'button' in $event && $event.button !== 1"),
-      right: genGuard("'button' in $event && $event.button !== 2"),
+      self: genGuard(`$event.target !== $event.currentTarget`),
+      ctrl: genGuard(`!$event.ctrlKey`),
+      shift: genGuard(`!$event.shiftKey`),
+      alt: genGuard(`!$event.altKey`),
+      meta: genGuard(`!$event.metaKey`),
+      left: genGuard(`'button' in $event && $event.button !== 0`),
+      middle: genGuard(`'button' in $event && $event.button !== 1`),
+      right: genGuard(`'button' in $event && $event.button !== 2`),
   };
   function genHandlers(events, isNative) {
-      var prefix = isNative ? 'nativeOn:' : 'on:';
-      var staticHandlers = "";
-      var dynamicHandlers = "";
-      for (var name in events) {
-          var handlerCode = genHandler(events[name]);
+      const prefix = isNative ? 'nativeOn:' : 'on:';
+      let staticHandlers = ``;
+      let dynamicHandlers = ``;
+      for (const name in events) {
+          const handlerCode = genHandler(events[name]);
           //@ts-expect-error
           if (events[name] && events[name].dynamic) {
-              dynamicHandlers += name + "," + handlerCode + ",";
+              dynamicHandlers += `${name},${handlerCode},`;
           }
           else {
-              staticHandlers += "\"" + name + "\":" + handlerCode + ",";
+              staticHandlers += `"${name}":${handlerCode},`;
           }
       }
-      staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
+      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
       if (dynamicHandlers) {
-          return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])";
+          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
       }
       else {
           return prefix + staticHandlers;
@@ -9580,22 +9462,22 @@
           return 'function(){}';
       }
       if (Array.isArray(handler)) {
-          return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]");
+          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
       }
-      var isMethodPath = simplePathRE.test(handler.value);
-      var isFunctionExpression = fnExpRE.test(handler.value);
-      var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      const isMethodPath = simplePathRE.test(handler.value);
+      const isFunctionExpression = fnExpRE.test(handler.value);
+      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
       if (!handler.modifiers) {
           if (isMethodPath || isFunctionExpression) {
               return handler.value;
           }
-          return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}"); // inline statement
+          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
       }
       else {
-          var code = '';
-          var genModifierCode = '';
-          var keys = [];
-          for (var key in handler.modifiers) {
+          let code = '';
+          let genModifierCode = '';
+          const keys = [];
+          for (const key in handler.modifiers) {
               if (modifierCode[key]) {
                   genModifierCode += modifierCode[key];
                   // left/right
@@ -9604,10 +9486,10 @@
                   }
               }
               else if (key === 'exact') {
-                  var modifiers = handler.modifiers;
+                  const modifiers = handler.modifiers;
                   genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-                      .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
+                      .filter((keyModifier) => !modifiers[keyModifier])
+                      .map((keyModifier) => `$event.${keyModifier}Key`)
                       .join('||'));
               }
               else {
@@ -9621,14 +9503,14 @@
           if (genModifierCode) {
               code += genModifierCode;
           }
-          var handlerCode = isMethodPath
-              ? ("return " + (handler.value) + ".apply(null, arguments)")
+          const handlerCode = isMethodPath
+              ? `return ${handler.value}.apply(null, arguments)`
               : isFunctionExpression
-                  ? ("return (" + (handler.value) + ").apply(null, arguments)")
+                  ? `return (${handler.value}).apply(null, arguments)`
                   : isFunctionInvocation
-                      ? ("return " + (handler.value))
+                      ? `return ${handler.value}`
                       : handler.value;
-          return ("function($event){" + code + handlerCode + "}");
+          return `function($event){${code}${handlerCode}}`;
       }
   }
   function genKeyFilter(keys) {
@@ -9636,66 +9518,77 @@
       // make sure the key filters only apply to KeyboardEvents
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
-      "if(!$event.type.indexOf('key')&&" +
-          (keys.map(genFilterCode).join('&&')) + ")return null;");
+      `if(!$event.type.indexOf('key')&&` +
+          `${keys.map(genFilterCode).join('&&')})return null;`);
   }
   function genFilterCode(key) {
-      var keyVal = parseInt(key, 10);
+      const keyVal = parseInt(key, 10);
       if (keyVal) {
-          return ("$event.keyCode!==" + keyVal);
+          return `$event.keyCode!==${keyVal}`;
       }
-      var keyCode = keyCodes[key];
-      var keyName = keyNames[key];
-      return ("_k($event.keyCode," +
-          (JSON.stringify(key)) + "," +
-          (JSON.stringify(keyCode)) + "," +
-          "$event.key," +
-          "" + (JSON.stringify(keyName)) +
-          ")");
+      const keyCode = keyCodes[key];
+      const keyName = keyNames[key];
+      return (`_k($event.keyCode,` +
+          `${JSON.stringify(key)},` +
+          `${JSON.stringify(keyCode)},` +
+          `$event.key,` +
+          `${JSON.stringify(keyName)}` +
+          `)`);
   }
 
   function on(el, dir) {
       if (dir.modifiers) {
-          warn$2("v-on without argument does not support modifiers.");
+          warn$2(`v-on without argument does not support modifiers.`);
       }
-      el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
   }
 
   function bind(el, dir) {
-      el.wrapData = function (code) {
-          return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")");
+      el.wrapData = (code) => {
+          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
       };
   }
 
   var baseDirectives = {
-      on: on,
-      bind: bind,
+      on,
+      bind,
       cloak: noop,
   };
 
-  var CodegenState = function CodegenState(options) {
-      this.options = options;
-      this.warn = options.warn || baseWarn;
-      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-      this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-      this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-      this.directives = extend(extend({}, baseDirectives), options.directives);
-      var isReservedTag = options.isReservedTag || no;
-      this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-      this.onceId = 0;
-      this.staticRenderFns = [];
-      this.pre = false;
-  };
+  class CodegenState {
+      options;
+      warn;
+      transforms;
+      dataGenFns;
+      directives;
+      maybeComponent;
+      onceId;
+      staticRenderFns;
+      pre;
+      constructor(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          const isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+  }
   function generate(ast, options) {
-      var state = new CodegenState(options);
+      const state = new CodegenState(options);
       // fix #11483, Root level <script> tags should not be rendered.
-      var code = ast
+      const code = ast
           ? ast.tag === 'script'
               ? 'null'
               : genElement(ast, state)
           : '_c("div")';
       return {
-          render: ("with(this){return " + code + "}"),
+          render: `with(this){return ${code}}`,
           staticRenderFns: state.staticRenderFns,
       };
   }
@@ -9723,20 +9616,22 @@
       }
       else {
           // component or element
-          var code;
+          let code;
           if (el.component) {
               code = genComponent(el.component, el, state);
           }
           else {
-              var data;
+              let data;
               if (!el.plain || (el.pre && state.maybeComponent(el))) {
                   data = genData(el, state);
               }
-              var children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+              const children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
           }
           // module transforms
-          for (var i = 0; i < state.transforms.length; i++) {
+          for (let i = 0; i < state.transforms.length; i++) {
               code = state.transforms[i](el, code);
           }
           return code;
@@ -9748,13 +9643,13 @@
       // Some elements (templates) need to behave differently inside of a v-pre
       // node.  All pre nodes are static roots, so we can use this as a location to
       // wrap a state change and reset it upon exiting the pre node.
-      var originalPreState = state.pre;
+      const originalPreState = state.pre;
       if (el.pre) {
           state.pre = el.pre;
       }
-      state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
+      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
       state.pre = originalPreState;
-      return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")");
+      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
   }
   // v-once
   function genOnce(el, state) {
@@ -9763,8 +9658,8 @@
           return genIf(el, state);
       }
       else if (el.staticInFor) {
-          var key = '';
-          var parent = el.parent;
+          let key = '';
+          let parent = el.parent;
           while (parent) {
               if (parent.for) {
                   key = parent.key;
@@ -9773,10 +9668,10 @@
               parent = parent.parent;
           }
           if (!key) {
-              state.warn("v-once can only be used inside v-for that is keyed. ", el.rawAttrsMap['v-once']);
+              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
               return genElement(el, state);
           }
-          return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")");
+          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
       }
       else {
           return genStatic(el, state);
@@ -9790,12 +9685,12 @@
       if (!conditions.length) {
           return altEmpty || '_e()';
       }
-      var condition = conditions.shift();
+      const condition = conditions.shift();
       if (condition.exp) {
-          return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)));
+          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
       }
       else {
-          return ("" + (genTernaryExp(condition.block)));
+          return `${genTernaryExp(condition.block)}`;
       }
       // v-if with v-once should generate code like (a)?_m(0):_m(1)
       function genTernaryExp(el) {
@@ -9807,87 +9702,87 @@
       }
   }
   function genFor(el, state, altGen, altHelper) {
-      var exp = el.for;
-      var alias = el.alias;
-      var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-      var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
+      const exp = el.for;
+      const alias = el.alias;
+      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
       if (state.maybeComponent(el) &&
           el.tag !== 'slot' &&
           el.tag !== 'template' &&
           !el.key) {
-          state.warn("<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-              "v-for should have explicit keys. " +
-              "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+              `v-for should have explicit keys. ` +
+              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
-      return ((altHelper || '_l') + "((" + exp + ")," +
-          "function(" + alias + iterator1 + iterator2 + "){" +
-          "return " + ((altGen || genElement)(el, state)) +
+      return (`${altHelper || '_l'}((${exp}),` +
+          `function(${alias}${iterator1}${iterator2}){` +
+          `return ${(altGen || genElement)(el, state)}` +
           '})');
   }
   function genData(el, state) {
-      var data = '{';
+      let data = '{';
       // directives first.
       // directives may mutate the el's other properties before they are generated.
-      var dirs = genDirectives(el, state);
+      const dirs = genDirectives(el, state);
       if (dirs)
-          { data += dirs + ','; }
+          data += dirs + ',';
       // key
       if (el.key) {
-          data += "key:" + (el.key) + ",";
+          data += `key:${el.key},`;
       }
       // ref
       if (el.ref) {
-          data += "ref:" + (el.ref) + ",";
+          data += `ref:${el.ref},`;
       }
       if (el.refInFor) {
-          data += "refInFor:true,";
+          data += `refInFor:true,`;
       }
       // pre
       if (el.pre) {
-          data += "pre:true,";
+          data += `pre:true,`;
       }
       // record original tag name for components using "is" attribute
       if (el.component) {
-          data += "tag:\"" + (el.tag) + "\",";
+          data += `tag:"${el.tag}",`;
       }
       // module data generation functions
-      for (var i = 0; i < state.dataGenFns.length; i++) {
+      for (let i = 0; i < state.dataGenFns.length; i++) {
           data += state.dataGenFns[i](el);
       }
       // attributes
       if (el.attrs) {
-          data += "attrs:" + (genProps(el.attrs)) + ",";
+          data += `attrs:${genProps(el.attrs)},`;
       }
       // DOM props
       if (el.props) {
-          data += "domProps:" + (genProps(el.props)) + ",";
+          data += `domProps:${genProps(el.props)},`;
       }
       // event handlers
       if (el.events) {
-          data += (genHandlers(el.events, false)) + ",";
+          data += `${genHandlers(el.events, false)},`;
       }
       if (el.nativeEvents) {
-          data += (genHandlers(el.nativeEvents, true)) + ",";
+          data += `${genHandlers(el.nativeEvents, true)},`;
       }
       // slot target
       // only for non-scoped slots
       if (el.slotTarget && !el.slotScope) {
-          data += "slot:" + (el.slotTarget) + ",";
+          data += `slot:${el.slotTarget},`;
       }
       // scoped slots
       if (el.scopedSlots) {
-          data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
+          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
       }
       // component v-model
       if (el.model) {
-          data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
+          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
       }
       // inline-template
       if (el.inlineTemplate) {
-          var inlineTemplate = genInlineTemplate(el, state);
+          const inlineTemplate = genInlineTemplate(el, state);
           if (inlineTemplate) {
-              data += inlineTemplate + ",";
+              data += `${inlineTemplate},`;
           }
       }
       data = data.replace(/,$/, '') + '}';
@@ -9895,7 +9790,7 @@
       // v-bind with dynamic arguments must be applied using the same v-bind object
       // merge helper so that class/style/mustUseProp attrs are handled correctly.
       if (el.dynamicAttrs) {
-          data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
+          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
       }
       // v-bind data wrap
       if (el.wrapData) {
@@ -9908,16 +9803,16 @@
       return data;
   }
   function genDirectives(el, state) {
-      var dirs = el.directives;
+      const dirs = el.directives;
       if (!dirs)
-          { return; }
-      var res = 'directives:[';
-      var hasRuntime = false;
-      var i, l, dir, needRuntime;
+          return;
+      let res = 'directives:[';
+      let hasRuntime = false;
+      let i, l, dir, needRuntime;
       for (i = 0, l = dirs.length; i < l; i++) {
           dir = dirs[i];
           needRuntime = true;
-          var gen = state.directives[dir.name];
+          const gen = state.directives[dir.name];
           if (gen) {
               // compile-time directive that manipulates AST.
               // returns true if it also needs a runtime counterpart.
@@ -9925,9 +9820,9 @@
           }
           if (needRuntime) {
               hasRuntime = true;
-              res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value
-                  ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value)))
-                  : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
+              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
           }
       }
       if (hasRuntime) {
@@ -9935,15 +9830,15 @@
       }
   }
   function genInlineTemplate(el, state) {
-      var ast = el.children[0];
+      const ast = el.children[0];
       if ((el.children.length !== 1 || ast.type !== 1)) {
           state.warn('Inline-template components must have exactly one child element.', { start: el.start });
       }
       if (ast && ast.type === 1) {
-          var inlineRenderFns = generate(ast, state.options);
-          return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns
-              .map(function (code) { return ("function(){" + code + "}"); })
-              .join(',')) + "]}");
+          const inlineRenderFns = generate(ast, state.options);
+          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
       }
   }
   function genScopedSlots(el, slots, state) {
@@ -9951,9 +9846,9 @@
       // components with only scoped slots to skip forced updates from parent.
       // but in some cases we have to bail-out of this optimization
       // for example if the slot contains dynamic names, has v-if or v-for on them...
-      var needsForceUpdate = el.for ||
-          Object.keys(slots).some(function (key) {
-              var slot = slots[key];
+      let needsForceUpdate = el.for ||
+          Object.keys(slots).some((key) => {
+              const slot = slots[key];
               return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
               );
           });
@@ -9961,14 +9856,14 @@
       // it's possible for the same component to be reused but with different
       // compiled slot content. To avoid that, we generate a unique key based on
       // the generated code of all the slot contents.
-      var needsKey = !!el.if;
+      let needsKey = !!el.if;
       // OR when it is inside another scoped slot or v-for (the reactivity may be
       // disconnected due to the intermediate scope variable)
       // #9438, #9506
       // TODO: this can be further optimized by properly analyzing in-scope bindings
       // and skip force updating ones that do not actually use scope variables.
       if (!needsForceUpdate) {
-          var parent = el.parent;
+          let parent = el.parent;
           while (parent) {
               if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
                   parent.for) {
@@ -9981,14 +9876,14 @@
               parent = parent.parent;
           }
       }
-      var generatedSlots = Object.keys(slots)
-          .map(function (key) { return genScopedSlot(slots[key], state); })
+      const generatedSlots = Object.keys(slots)
+          .map((key) => genScopedSlot(slots[key], state))
           .join(',');
-      return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")");
+      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
   }
   function hash(str) {
-      var hash = 5381;
-      var i = str.length;
+      let hash = 5381;
+      let i = str.length;
       while (i) {
           hash = (hash * 33) ^ str.charCodeAt(--i);
       }
@@ -10004,45 +9899,45 @@
       return false;
   }
   function genScopedSlot(el, state) {
-      var isLegacySyntax = el.attrsMap['slot-scope'];
+      const isLegacySyntax = el.attrsMap['slot-scope'];
       if (el.if && !el.ifProcessed && !isLegacySyntax) {
-          return genIf(el, state, genScopedSlot, "null");
+          return genIf(el, state, genScopedSlot, `null`);
       }
       if (el.for && !el.forProcessed) {
           return genFor(el, state, genScopedSlot);
       }
-      var slotScope = el.slotScope === emptySlotScopeToken ? "" : String(el.slotScope);
-      var fn = "function(" + slotScope + "){" +
-          "return " + (el.tag === 'template'
-              ? el.if && isLegacySyntax
-                  ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-                  : genChildren(el, state) || 'undefined'
-              : genElement(el, state)) + "}";
+      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+      const fn = `function(${slotScope}){` +
+          `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
       // reverse proxy v-slot without scope on this.$slots
-      var reverseProxy = slotScope ? "" : ",proxy:true";
-      return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}");
+      const reverseProxy = slotScope ? `` : `,proxy:true`;
+      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
   }
   function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-      var children = el.children;
+      const children = el.children;
       if (children.length) {
-          var el$1 = children[0];
+          const el = children[0];
           // optimize single v-for
           if (children.length === 1 &&
-              el$1.for &&
-              el$1.tag !== 'template' &&
-              el$1.tag !== 'slot') {
-              var normalizationType = checkSkip
-                  ? state.maybeComponent(el$1)
-                      ? ",1"
-                      : ",0"
-                  : "";
-              return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType);
-          }
-          var normalizationType$1 = checkSkip
+              el.for &&
+              el.tag !== 'template' &&
+              el.tag !== 'slot') {
+              const normalizationType = checkSkip
+                  ? state.maybeComponent(el)
+                      ? `,1`
+                      : `,0`
+                  : ``;
+              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+          }
+          const normalizationType = checkSkip
               ? getNormalizationType(children, state.maybeComponent)
               : 0;
-          var gen = altGenNode || genNode;
-          return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''));
+          const gen = altGenNode || genNode;
+          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
       }
   }
   // determine the normalization needed for the children array.
@@ -10050,20 +9945,20 @@
   // 1: simple normalization needed (possible 1-level deep nested array)
   // 2: full normalization needed
   function getNormalizationType(children, maybeComponent) {
-      var res = 0;
-      for (var i = 0; i < children.length; i++) {
-          var el = children[i];
+      let res = 0;
+      for (let i = 0; i < children.length; i++) {
+          const el = children[i];
           if (el.type !== 1) {
               continue;
           }
           if (needsNormalization(el) ||
               (el.ifConditions &&
-                  el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
+                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
               res = 2;
               break;
           }
           if (maybeComponent(el) ||
-              (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
+              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
               res = 1;
           }
       }
@@ -10084,58 +9979,58 @@
       }
   }
   function genText(text) {
-      return ("_v(" + (text.type === 2
-          ? text.expression // no need for () because already wrapped in _s()
-          : transformSpecialNewlines(JSON.stringify(text.text))) + ")");
+      return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
   }
   function genComment(comment) {
-      return ("_e(" + (JSON.stringify(comment.text)) + ")");
+      return `_e(${JSON.stringify(comment.text)})`;
   }
   function genSlot(el, state) {
-      var slotName = el.slotName || '"default"';
-      var children = genChildren(el, state);
-      var res = "_t(" + slotName + (children ? ("," + children) : '');
-      var attrs = el.attrs || el.dynamicAttrs
-          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
+      const slotName = el.slotName || '"default"';
+      const children = genChildren(el, state);
+      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+      const attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
               // slot props are camelized
               name: camelize(attr.name),
               value: attr.value,
-              dynamic: attr.dynamic,
-          }); }))
+              dynamic: attr.dynamic
+          })))
           : null;
-      var bind = el.attrsMap['v-bind'];
+      const bind = el.attrsMap['v-bind'];
       if ((attrs || bind) && !children) {
-          res += ",null";
+          res += `,null`;
       }
       if (attrs) {
-          res += "," + attrs;
+          res += `,${attrs}`;
       }
       if (bind) {
-          res += (attrs ? '' : ',null') + "," + bind;
+          res += `${attrs ? '' : ',null'},${bind}`;
       }
       return res + ')';
   }
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
   function genComponent(componentName, el, state) {
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")");
+      const children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
   }
   function genProps(props) {
-      var staticProps = "";
-      var dynamicProps = "";
-      for (var i = 0; i < props.length; i++) {
-          var prop = props[i];
-          var value = transformSpecialNewlines(prop.value);
+      let staticProps = ``;
+      let dynamicProps = ``;
+      for (let i = 0; i < props.length; i++) {
+          const prop = props[i];
+          const value = transformSpecialNewlines(prop.value);
           if (prop.dynamic) {
-              dynamicProps += (prop.name) + "," + value + ",";
+              dynamicProps += `${prop.name},${value},`;
           }
           else {
-              staticProps += "\"" + (prop.name) + "\":" + value + ",";
+              staticProps += `"${prop.name}":${value},`;
           }
       }
-      staticProps = "{" + (staticProps.slice(0, -1)) + "}";
+      staticProps = `{${staticProps.slice(0, -1)}}`;
       if (dynamicProps) {
-          return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])");
+          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
       }
       else {
           return staticProps;
@@ -10148,7 +10043,7 @@
 
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp('\\b' +
+  const prohibitedKeywordRE = new RegExp('\\b' +
       ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
           'super,throw,while,yield,delete,export,import,return,switch,default,' +
           'extends,finally,continue,debugger,function,arguments')
@@ -10156,11 +10051,11 @@
           .join('\\b|\\b') +
       '\\b');
   // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp('\\b' +
+  const unaryOperatorsRE = new RegExp('\\b' +
       'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
       '\\s*\\([^\\)]*\\)');
   // strip strings in expressions
-  var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
   // detect problematic expressions in a template
   function detectErrors(ast, warn) {
       if (ast) {
@@ -10169,28 +10064,28 @@
   }
   function checkNode(node, warn) {
       if (node.type === 1) {
-          for (var name in node.attrsMap) {
+          for (const name in node.attrsMap) {
               if (dirRE.test(name)) {
-                  var value = node.attrsMap[name];
+                  const value = node.attrsMap[name];
                   if (value) {
-                      var range = node.rawAttrsMap[name];
+                      const range = node.rawAttrsMap[name];
                       if (name === 'v-for') {
-                          checkFor(node, ("v-for=\"" + value + "\""), warn, range);
+                          checkFor(node, `v-for="${value}"`, warn, range);
                       }
                       else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
+                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
                       }
                       else if (onRE.test(name)) {
-                          checkEvent(value, (name + "=\"" + value + "\""), warn, range);
+                          checkEvent(value, `${name}="${value}"`, warn, range);
                       }
                       else {
-                          checkExpression(value, (name + "=\"" + value + "\""), warn, range);
+                          checkExpression(value, `${name}="${value}"`, warn, range);
                       }
                   }
               }
           }
           if (node.children) {
-              for (var i = 0; i < node.children.length; i++) {
+              for (let i = 0; i < node.children.length; i++) {
                   checkNode(node.children[i], warn);
               }
           }
@@ -10200,11 +10095,11 @@
       }
   }
   function checkEvent(exp, text, warn, range) {
-      var stripped = exp.replace(stripStringRE, '');
-      var keywordMatch = stripped.match(unaryOperatorsRE);
+      const stripped = exp.replace(stripStringRE, '');
+      const keywordMatch = stripped.match(unaryOperatorsRE);
       if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-          warn("avoid using JavaScript unary operator as property name: " +
-              "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()), range);
+          warn(`avoid using JavaScript unary operator as property name: ` +
+              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
       }
       checkExpression(exp, text, warn, range);
   }
@@ -10217,29 +10112,29 @@
   function checkIdentifier(ident, type, text, warn, range) {
       if (typeof ident === 'string') {
           try {
-              new Function(("var " + ident + "=_"));
+              new Function(`var ${ident}=_`);
           }
           catch (e) {
-              warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
           }
       }
   }
   function checkExpression(exp, text, warn, range) {
       try {
-          new Function(("return " + exp));
+          new Function(`return ${exp}`);
       }
       catch (e) {
-          var keywordMatch = exp
+          const keywordMatch = exp
               .replace(stripStringRE, '')
               .match(prohibitedKeywordRE);
           if (keywordMatch) {
-              warn("avoid using JavaScript keyword as property name: " +
-                  "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()), range);
+              warn(`avoid using JavaScript keyword as property name: ` +
+                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
           }
           else {
-              warn("invalid expression: " + (e.message) + " in\n\n" +
-                  "    " + exp + "\n\n" +
-                  "  Raw expression: " + (text.trim()) + "\n", range);
+              warn(`invalid expression: ${e.message} in\n\n` +
+                  `    ${exp}\n\n` +
+                  `  Raw expression: ${text.trim()}\n`, range);
           }
       }
   }
@@ -10248,38 +10143,35 @@
           new Function(exp, '');
       }
       catch (e) {
-          warn("invalid function parameter expression: " + (e.message) + " in\n\n" +
-              "    " + exp + "\n\n" +
-              "  Raw expression: " + (text.trim()) + "\n", range);
+          warn(`invalid function parameter expression: ${e.message} in\n\n` +
+              `    ${exp}\n\n` +
+              `  Raw expression: ${text.trim()}\n`, range);
       }
   }
 
-  var range = 2;
-  function generateCodeFrame(source, start, end) {
-      if ( start === void 0 ) start = 0;
-      if ( end === void 0 ) end = source.length;
-
-      var lines = source.split(/\r?\n/);
-      var count = 0;
-      var res = [];
-      for (var i = 0; i < lines.length; i++) {
+  const range = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
           count += lines[i].length + 1;
           if (count >= start) {
-              for (var j = i - range; j <= i + range || end > count; j++) {
+              for (let j = i - range; j <= i + range || end > count; j++) {
                   if (j < 0 || j >= lines.length)
-                      { continue; }
-                  res.push(("" + (j + 1) + (repeat(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-                  var lineLength = lines[j].length;
+                      continue;
+                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
                   if (j === i) {
                       // push underline
-                      var pad = start - (count - lineLength) + 1;
-                      var length = end > count ? lineLength - pad : end - start;
-                      res.push("   |  " + repeat(" ", pad) + repeat("^", length));
+                      const pad = start - (count - lineLength) + 1;
+                      const length = end > count ? lineLength - pad : end - start;
+                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
                   }
                   else if (j > i) {
                       if (end > count) {
-                          var length$1 = Math.min(end - count, lineLength);
-                          res.push("   |  " + repeat("^", length$1));
+                          const length = Math.min(end - count, lineLength);
+                          res.push(`   |  ` + repeat(`^`, length));
                       }
                       count += lineLength + 1;
                   }
@@ -10290,16 +10182,16 @@
       return res.join('\n');
   }
   function repeat(str, n) {
-      var result = '';
+      let result = '';
       if (n > 0) {
           // eslint-disable-next-line no-constant-condition
           while (true) {
               // eslint-disable-line
               if (n & 1)
-                  { result += str; }
+                  result += str;
               n >>>= 1;
               if (n <= 0)
-                  { break; }
+                  break;
               str += str;
           }
       }
@@ -10311,15 +10203,15 @@
           return new Function(code);
       }
       catch (err) {
-          errors.push({ err: err, code: code });
+          errors.push({ err, code });
           return noop;
       }
   }
   function createCompileToFunctionFn(compile) {
-      var cache = Object.create(null);
+      const cache = Object.create(null);
       return function compileToFunctions(template, options, vm) {
           options = extend({}, options);
-          var warn = options.warn || warn$2;
+          const warn = options.warn || warn$2;
           delete options.warn;
           /* istanbul ignore if */
           {
@@ -10338,43 +10230,43 @@
               }
           }
           // check cache
-          var key = options.delimiters
+          const key = options.delimiters
               ? String(options.delimiters) + template
               : template;
           if (cache[key]) {
               return cache[key];
           }
           // compile
-          var compiled = compile(template, options);
+          const compiled = compile(template, options);
           // check compilation errors/tips
           {
               if (compiled.errors && compiled.errors.length) {
                   if (options.outputSourceRange) {
-                      compiled.errors.forEach(function (e) {
-                          warn("Error compiling template:\n\n" + (e.msg) + "\n\n" +
+                      compiled.errors.forEach((e) => {
+                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
                               generateCodeFrame(template, e.start, e.end), vm);
                       });
                   }
                   else {
-                      warn("Error compiling template:\n\n" + template + "\n\n" +
-                          compiled.errors.map(function (e) { return ("- " + e); }).join('\n') +
+                      warn(`Error compiling template:\n\n${template}\n\n` +
+                          compiled.errors.map((e) => `- ${e}`).join('\n') +
                           '\n', vm);
                   }
               }
               if (compiled.tips && compiled.tips.length) {
                   if (options.outputSourceRange) {
-                      compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+                      compiled.tips.forEach((e) => tip(e.msg, vm));
                   }
                   else {
-                      compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+                      compiled.tips.forEach((msg) => tip(msg, vm));
                   }
               }
           }
           // turn code into functions
-          var res = {};
-          var fnGenErrors = [];
+          const res = {};
+          const fnGenErrors = [];
           res.render = createFunction(compiled.render, fnGenErrors);
-          res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
               return createFunction(code, fnGenErrors);
           });
           // check function generation errors.
@@ -10383,14 +10275,9 @@
           /* istanbul ignore if */
           {
               if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn("Failed to generate render function:\n\n" +
+                  warn(`Failed to generate render function:\n\n` +
                       fnGenErrors
-                          .map(function (ref) {
-                              var err = ref.err;
-                              var code = ref.code;
-
-                              return ((err.toString()) + " in\n\n" + code + "\n");
-                  })
+                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
                           .join('\n'), vm);
               }
           }
@@ -10401,18 +10288,18 @@
   function createCompilerCreator(baseCompile) {
       return function createCompiler(baseOptions) {
           function compile(template, options) {
-              var finalOptions = Object.create(baseOptions);
-              var errors = [];
-              var tips = [];
-              var warn = function (msg, range, tip) {
+              const finalOptions = Object.create(baseOptions);
+              const errors = [];
+              const tips = [];
+              let warn = (msg, range, tip) => {
                   (tip ? tips : errors).push(msg);
               };
               if (options) {
                   if (options.outputSourceRange) {
                       // $flow-disable-line
-                      var leadingSpaceLength = template.match(/^\s*/)[0].length;
-                      warn = function (msg, range, tip) {
-                          var data = { msg: msg };
+                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = (msg, range, tip) => {
+                          const data = { msg };
                           if (range) {
                               if (range.start != null) {
                                   data.start = range.start + leadingSpaceLength;
@@ -10433,14 +10320,14 @@
                       finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
                   }
                   // copy other options
-                  for (var key in options) {
+                  for (const key in options) {
                       if (key !== 'modules' && key !== 'directives') {
                           finalOptions[key] = options[key];
                       }
                   }
               }
               finalOptions.warn = warn;
-              var compiled = baseCompile(template.trim(), finalOptions);
+              const compiled = baseCompile(template.trim(), finalOptions);
               {
                   detectErrors(compiled.ast, warn);
               }
@@ -10449,7 +10336,7 @@
               return compiled;
           }
           return {
-              compile: compile,
+              compile,
               compileToFunctions: createCompileToFunctionFn(compile),
           };
       };
@@ -10458,59 +10345,58 @@
   // `createCompilerCreator` allows creating compilers that use alternative
   // parser/optimizer/codegen, e.g the SSR optimizing compiler.
   // Here we just export a default compiler using the default parts.
-  var createCompiler = createCompilerCreator(function baseCompile(template, options) {
-      var ast = parse(template.trim(), options);
+  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      const ast = parse(template.trim(), options);
       if (options.optimize !== false) {
           optimize(ast, options);
       }
-      var code = generate(ast, options);
+      const code = generate(ast, options);
       return {
-          ast: ast,
+          ast,
           render: code.render,
           staticRenderFns: code.staticRenderFns,
       };
   });
 
-  var ref = createCompiler(baseOptions);
-  var compileToFunctions = ref.compileToFunctions;
+  const { compile, compileToFunctions } = createCompiler(baseOptions);
 
   // check whether current browser encodes a char inside attribute values
-  var div;
+  let div;
   function getShouldDecode(href) {
       div = div || document.createElement('div');
-      div.innerHTML = href ? "<a href=\"\n\"/>" : "<div a=\"\n\"/>";
+      div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
       return div.innerHTML.indexOf('&#10;') > 0;
   }
   // #3663: IE encodes newlines inside attribute values while other browsers don't
-  var shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+  const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
   // #6828: chrome encodes content in a[href]
-  var shouldDecodeNewlinesForHref = inBrowser
+  const shouldDecodeNewlinesForHref = inBrowser
       ? getShouldDecode(true)
       : false;
 
-  var idToTemplate = cached(function (id) {
-      var el = query(id);
+  const idToTemplate = cached((id) => {
+      const el = query(id);
       return el && el.innerHTML;
   });
-  var mount = Vue.prototype.$mount;
+  const mount = Vue.prototype.$mount;
   Vue.prototype.$mount = function (el, hydrating) {
       el = el && query(el);
       /* istanbul ignore if */
       if (el === document.body || el === document.documentElement) {
-          warn$2("Do not mount Vue to <html> or <body> - mount to normal elements instead.");
+          warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
           return this;
       }
-      var options = this.$options;
+      const options = this.$options;
       // resolve template/el and convert to render function
       if (!options.render) {
-          var template = options.template;
+          let template = options.template;
           if (template) {
               if (typeof template === 'string') {
                   if (template.charAt(0) === '#') {
                       template = idToTemplate(template);
                       /* istanbul ignore if */
                       if (!template) {
-                          warn$2(("Template element not found or is empty: " + (options.template)), this);
+                          warn$2(`Template element not found or is empty: ${options.template}`, this);
                       }
                   }
               }
@@ -10533,21 +10419,19 @@
               if (config.performance && mark) {
                   mark('compile');
               }
-              var ref = compileToFunctions(template, {
+              const { render, staticRenderFns } = compileToFunctions(template, {
                   outputSourceRange: "development" !== 'production',
-                  shouldDecodeNewlines: shouldDecodeNewlines,
-                  shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,
+                  shouldDecodeNewlines,
+                  shouldDecodeNewlinesForHref,
                   delimiters: options.delimiters,
                   comments: options.comments,
               }, this);
-              var render = ref.render;
-              var staticRenderFns = ref.staticRenderFns;
               options.render = render;
               options.staticRenderFns = staticRenderFns;
               /* istanbul ignore if */
               if (config.performance && mark) {
                   mark('compile end');
-                  measure(("vue " + (this._name) + " compile"), 'compile', 'compile end');
+                  measure(`vue ${this._name} compile`, 'compile', 'compile end');
               }
           }
       }
@@ -10562,7 +10446,7 @@
           return el.outerHTML;
       }
       else {
-          var container = document.createElement('div');
+          const container = document.createElement('div');
           container.appendChild(el.cloneNode(true));
           return container.innerHTML;
       }
@@ -10571,4 +10455,4 @@
 
   return Vue;
 
-})));
+}));
diff --git a/dist/vue.min.js b/dist/vue.min.js
index 88776335394..97b782345a9 100644
--- a/dist/vue.min.js
+++ b/dist/vue.min.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).Vue=t()}(this,(function(){"use strict";var e=Object.freeze({});function t(e){return null==e}function n(e){return null!=e}function r(e){return!0===e}function i(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function o(e){return null!==e&&"object"==typeof e}var a=Object.prototype.toString;function s(e){return"[object Object]"===a.call(e)}function c(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}function u(e){return n(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function l(e){return null==e?"":Array.isArray(e)||s(e)&&e.toString===a?JSON.stringify(e,null,2):String(e)}function f(e){var t=parseFloat(e);return isNaN(t)?e:t}function p(e,t){for(var n=Object.create(null),r=e.split(","),i=0;i<r.length;i++)n[r[i]]=!0;return t?function(e){return n[e.toLowerCase()]}:function(e){return n[e]}}var d=p("slot,component",!0),v=p("key,ref,slot,slot-scope,is");function h(e,t){if(e.length){var n=e.indexOf(t);if(n>-1)return e.splice(n,1)}}var m=Object.prototype.hasOwnProperty;function y(e,t){return m.call(e,t)}function g(e){var t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}var _=/-(\w)/g,b=g((function(e){return e.replace(_,(function(e,t){return t?t.toUpperCase():""}))})),$=g((function(e){return e.charAt(0).toUpperCase()+e.slice(1)})),w=/\B([A-Z])/g,x=g((function(e){return e.replace(w,"-$1").toLowerCase()}));var C=Function.prototype.bind?function(e,t){return e.bind(t)}:function(e,t){function n(n){var r=arguments.length;return r?r>1?e.apply(t,arguments):e.call(t,n):e.call(t)}return n._length=e.length,n};function k(e,t){t=t||0;for(var n=e.length-t,r=new Array(n);n--;)r[n]=e[n+t];return r}function A(e,t){for(var n in t)e[n]=t[n];return e}function O(e){for(var t={},n=0;n<e.length;n++)e[n]&&A(t,e[n]);return t}function S(e,t,n){}var T=function(e,t,n){return!1},E=function(e){return e};function N(e,t){if(e===t)return!0;var n=o(e),r=o(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{var i=Array.isArray(e),a=Array.isArray(t);if(i&&a)return e.length===t.length&&e.every((function(e,n){return N(e,t[n])}));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||a)return!1;var s=Object.keys(e),c=Object.keys(t);return s.length===c.length&&s.every((function(n){return N(e[n],t[n])}))}catch(e){return!1}}function j(e,t){for(var n=0;n<e.length;n++)if(N(e[n],t))return n;return-1}function D(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var L="data-server-rendered",M=["component","directive","filter"],I=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:E,mustUseProp:T,async:!0,_lifecycleHooks:I},P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(e){var t=(e+"").charCodeAt(0);return 36===t||95===t}function H(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var B=new RegExp("[^"+P.source+".$_\\d]");var U="__proto__"in{},z="undefined"!=typeof window,V="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=V&&WXEnvironment.platform.toLowerCase(),q=z&&window.navigator.userAgent.toLowerCase(),J=q&&/msie|trident/.test(q),W=q&&q.indexOf("msie 9.0")>0,Z=q&&q.indexOf("edge/")>0;q&&q.indexOf("android");var G=q&&/iphone|ipad|ipod|ios/.test(q)||"ios"===K;q&&/chrome\/\d+/.test(q),q&&/phantomjs/.test(q);var X,Y=q&&q.match(/firefox\/(\d+)/),Q={}.watch,ee=!1;if(z)try{var te={};Object.defineProperty(te,"passive",{get:function(){ee=!0}}),window.addEventListener("test-passive",null,te)}catch(e){}var ne=function(){return void 0===X&&(X=!z&&!V&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},re=z&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ie(e){return"function"==typeof e&&/native code/.test(e.toString())}var oe,ae="undefined"!=typeof Symbol&&ie(Symbol)&&"undefined"!=typeof Reflect&&ie(Reflect.ownKeys);oe="undefined"!=typeof Set&&ie(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var se=S,ce=0,ue=function(){this.id=ce++,this.subs=[]};ue.prototype.addSub=function(e){this.subs.push(e)},ue.prototype.removeSub=function(e){h(this.subs,e)},ue.prototype.depend=function(){ue.target&&ue.target.addDep(this)},ue.prototype.notify=function(){for(var e=this.subs.slice(),t=0,n=e.length;t<n;t++)e[t].update()},ue.target=null;var le=[];function fe(e){le.push(e),ue.target=e}function pe(){le.pop(),ue.target=le[le.length-1]}var de=function(e,t,n,r,i,o,a,s){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ve={child:{configurable:!0}};ve.child.get=function(){return this.componentInstance},Object.defineProperties(de.prototype,ve);var he=function(e){void 0===e&&(e="");var t=new de;return t.text=e,t.isComment=!0,t};function me(e){return new de(void 0,void 0,void 0,String(e))}function ye(e){var t=new de(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}var ge=Array.prototype,_e=Object.create(ge);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){var t=ge[e];H(_e,e,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var i,o=t.apply(this,n),a=this.__ob__;switch(e){case"push":case"unshift":i=n;break;case"splice":i=n.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o}))}));var be=Object.getOwnPropertyNames(_e),$e=!0;function we(e){$e=e}var xe=function(e){this.value=e,this.dep=new ue,this.vmCount=0,H(e,"__ob__",this),Array.isArray(e)?(U?function(e,t){e.__proto__=t}(e,_e):function(e,t,n){for(var r=0,i=n.length;r<i;r++){var o=n[r];H(e,o,t[o])}}(e,_e,be),this.observeArray(e)):this.walk(e)};function Ce(e,t){var n;if(o(e)&&!(e instanceof de))return y(e,"__ob__")&&e.__ob__ instanceof xe?n=e.__ob__:$e&&!ne()&&(Array.isArray(e)||s(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new xe(e)),t&&n&&n.vmCount++,n}function ke(e,t,n,r,i){var o=new ue,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=e[t]);var u=!i&&Ce(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):n;return ue.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&Se(t))),t},set:function(t){var r=s?s.call(e):n;t===r||t!=t&&r!=r||s&&!c||(c?c.call(e,t):n=t,u=!i&&Ce(t),o.notify())}})}}function Ae(e,t,n){if(Array.isArray(e)&&c(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;var r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(ke(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function Oe(e,t){if(Array.isArray(e)&&c(t))e.splice(t,1);else{var n=e.__ob__;e._isVue||n&&n.vmCount||y(e,t)&&(delete e[t],n&&n.dep.notify())}}function Se(e){for(var t=void 0,n=0,r=e.length;n<r;n++)(t=e[n])&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&Se(t)}xe.prototype.walk=function(e){for(var t=Object.keys(e),n=0;n<t.length;n++)ke(e,t[n])},xe.prototype.observeArray=function(e){for(var t=0,n=e.length;t<n;t++)Ce(e[t])};var Te=F.optionMergeStrategies;function Ee(e,t){if(!t)return e;for(var n,r,i,o=ae?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(n=o[a])&&(r=e[n],i=t[n],y(e,n)?r!==i&&s(r)&&s(i)&&Ee(r,i):Ae(e,n,i));return e}function Ne(e,t,n){return n?function(){var r="function"==typeof t?t.call(n,n):t,i="function"==typeof e?e.call(n,n):e;return r?Ee(r,i):i}:t?e?function(){return Ee("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function je(e,t){var n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){for(var t=[],n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function De(e,t,n,r){var i=Object.create(e||null);return t?A(i,t):i}Te.data=function(e,t,n){return n?Ne(e,t,n):t&&"function"!=typeof t?e:Ne(e,t)},I.forEach((function(e){Te[e]=je})),M.forEach((function(e){Te[e+"s"]=De})),Te.watch=function(e,t,n,r){if(e===Q&&(e=void 0),t===Q&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Te.props=Te.methods=Te.inject=Te.computed=function(e,t,n,r){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Te.provide=Ne;var Le=function(e,t){return void 0===t?e:t};function Me(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){var n=e.props;if(n){var r,i,o={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(i=n[r])&&(o[b(i)]={type:null});else if(s(n))for(var a in n)i=n[a],o[b(a)]=s(i)?i:{type:i};e.props=o}}(t),function(e,t){var n=e.inject;if(n){var r=e.inject={};if(Array.isArray(n))for(var i=0;i<n.length;i++)r[n[i]]={from:n[i]};else if(s(n))for(var o in n){var a=n[o];r[o]=s(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var n in t){var r=t[n];"function"==typeof r&&(t[n]={bind:r,update:r})}}(t),!t._base&&(t.extends&&(e=Me(e,t.extends,n)),t.mixins))for(var r=0,i=t.mixins.length;r<i;r++)e=Me(e,t.mixins[r],n);var o,a={};for(o in e)c(o);for(o in t)y(e,o)||c(o);function c(r){var i=Te[r]||Le;a[r]=i(e[r],t[r],n,r)}return a}function Ie(e,t,n,r){if("string"==typeof n){var i=e[t];if(y(i,n))return i[n];var o=b(n);if(y(i,o))return i[o];var a=$(o);return y(i,a)?i[a]:i[n]||i[o]||i[a]}}function Fe(e,t,n,r){var i=t[e],o=!y(n,e),a=n[e],s=Be(Boolean,i.type);if(s>-1)if(o&&!y(i,"default"))a=!1;else if(""===a||a===x(e)){var c=Be(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,n){if(!y(t,"default"))return;var r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Re(t.type)?r.call(e):r}(r,i,e);var u=$e;we(!0),Ce(a),we(u)}return a}var Pe=/^\s*function (\w+)/;function Re(e){var t=e&&e.toString().match(Pe);return t?t[1]:""}function He(e,t){return Re(e)===Re(t)}function Be(e,t){if(!Array.isArray(t))return He(t,e)?0:-1;for(var n=0,r=t.length;n<r;n++)if(He(t[n],e))return n;return-1}function Ue(e,t,n){fe();try{if(t)for(var r=t;r=r.$parent;){var i=r.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(r,e,t,n))return}catch(e){Ve(e,r,"errorCaptured hook")}}Ve(e,t,n)}finally{pe()}}function ze(e,t,n,r,i){var o;try{(o=n?e.apply(t,n):e.call(t))&&!o._isVue&&u(o)&&!o._handled&&(o.catch((function(e){return Ue(e,r,i+" (Promise/async)")})),o._handled=!0)}catch(e){Ue(e,r,i)}return o}function Ve(e,t,n){if(F.errorHandler)try{return F.errorHandler.call(null,e,t,n)}catch(t){t!==e&&Ke(t)}Ke(e)}function Ke(e,t,n){if(!z&&!V||"undefined"==typeof console)throw e;console.error(e)}var qe,Je=!1,We=[],Ze=!1;function Ge(){Ze=!1;var e=We.slice(0);We.length=0;for(var t=0;t<e.length;t++)e[t]()}if("undefined"!=typeof Promise&&ie(Promise)){var Xe=Promise.resolve();qe=function(){Xe.then(Ge),G&&setTimeout(S)},Je=!0}else if(J||"undefined"==typeof MutationObserver||!ie(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())qe="undefined"!=typeof setImmediate&&ie(setImmediate)?function(){setImmediate(Ge)}:function(){setTimeout(Ge,0)};else{var Ye=1,Qe=new MutationObserver(Ge),et=document.createTextNode(String(Ye));Qe.observe(et,{characterData:!0}),qe=function(){Ye=(Ye+1)%2,et.data=String(Ye)},Je=!0}function tt(e,t){var n;if(We.push((function(){if(e)try{e.call(t)}catch(e){Ue(e,t,"nextTick")}else n&&n(t)})),Ze||(Ze=!0,qe()),!e&&"undefined"!=typeof Promise)return new Promise((function(e){n=e}))}var nt=new oe;function rt(e){it(e,nt),nt.clear()}function it(e,t){var n,r,i=Array.isArray(e);if(!(!i&&!o(e)||Object.isFrozen(e)||e instanceof de)){if(e.__ob__){var a=e.__ob__.dep.id;if(t.has(a))return;t.add(a)}if(i)for(n=e.length;n--;)it(e[n],t);else for(n=(r=Object.keys(e)).length;n--;)it(e[r[n]],t)}}var ot=g((function(e){var t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function at(e,t){function n(){var e=arguments,r=n.fns;if(!Array.isArray(r))return ze(r,null,arguments,t,"v-on handler");for(var i=r.slice(),o=0;o<i.length;o++)ze(i[o],null,e,t,"v-on handler")}return n.fns=e,n}function st(e,n,i,o,a,s){var c,u,l,f;for(c in e)u=e[c],l=n[c],f=ot(c),t(u)||(t(l)?(t(u.fns)&&(u=e[c]=at(u,s)),r(f.once)&&(u=e[c]=a(f.name,u,f.capture)),i(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in n)t(e[c])&&o((f=ot(c)).name,n[c],f.capture)}function ct(e,i,o){var a;e instanceof de&&(e=e.data.hook||(e.data.hook={}));var s=e[i];function c(){o.apply(this,arguments),h(a.fns,c)}t(s)?a=at([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=at([s,c]),a.merged=!0,e[i]=a}function ut(e,t,r,i,o){if(n(t)){if(y(t,r))return e[r]=t[r],o||delete t[r],!0;if(y(t,i))return e[r]=t[i],o||delete t[i],!0}return!1}function lt(e){return i(e)?[me(e)]:Array.isArray(e)?pt(e):void 0}function ft(e){return n(e)&&n(e.text)&&!1===e.isComment}function pt(e,o){var a,s,c,u,l=[];for(a=0;a<e.length;a++)t(s=e[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ft((s=pt(s,(o||"")+"_"+a))[0])&&ft(u)&&(l[c]=me(u.text+s[0].text),s.shift()),l.push.apply(l,s)):i(s)?ft(u)?l[c]=me(u.text+s):""!==s&&l.push(me(s)):ft(s)&&ft(u)?l[c]=me(u.text+s.text):(r(e._isVList)&&n(s.tag)&&t(s.key)&&n(o)&&(s.key="__vlist"+o+"_"+a+"__"),l.push(s)));return l}function dt(e,t){if(e){for(var n=Object.create(null),r=ae?Reflect.ownKeys(e):Object.keys(e),i=0;i<r.length;i++){var o=r[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&y(s._provided,a)){n[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;n[o]="function"==typeof c?c.call(t):c}}}return n}}function vt(e,t){if(!e||!e.length)return{};for(var n={},r=0,i=e.length;r<i;r++){var o=e[r],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(n.default||(n.default=[])).push(o);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in n)n[u].every(ht)&&delete n[u];return n}function ht(e){return e.isComment&&!e.asyncFactory||" "===e.text}function mt(t,n,r){var i,o=Object.keys(n).length>0,a=t?!!t.$stable:!o,s=t&&t.$key;if(t){if(t._normalized)return t._normalized;if(a&&r&&r!==e&&s===r.$key&&!o&&!r.$hasNormal)return r;for(var c in i={},t)t[c]&&"$"!==c[0]&&(i[c]=yt(n,c,t[c]))}else i={};for(var u in n)u in i||(i[u]=gt(n,u));return t&&Object.isExtensible(t)&&(t._normalized=i),H(i,"$stable",a),H(i,"$key",s),H(i,"$hasNormal",o),i}function yt(e,t,n){var r=function(){var e=arguments.length?n.apply(null,arguments):n({});return(e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:lt(e))&&(0===e.length||1===e.length&&e[0].isComment)?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function gt(e,t){return function(){return e[t]}}function _t(e,t){var r,i,a,s,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),r=0,i=e.length;r<i;r++)c[r]=t(e[r],r);else if("number"==typeof e)for(c=new Array(e),r=0;r<e;r++)c[r]=t(r+1,r);else if(o(e))if(ae&&e[Symbol.iterator]){c=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)c.push(t(l.value,c.length)),l=u.next()}else for(a=Object.keys(e),c=new Array(a.length),r=0,i=a.length;r<i;r++)s=a[r],c[r]=t(e[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function bt(e,t,n,r){var i,o=this.$scopedSlots[e];o?(n=n||{},r&&(n=A(A({},r),n)),i=o(n)||t):i=this.$slots[e]||t;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},i):i}function $t(e){return Ie(this.$options,"filters",e)||E}function wt(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function xt(e,t,n,r,i){var o=F.keyCodes[t]||n;return i&&r&&!F.keyCodes[t]?wt(i,r):o?wt(o,e):r?x(r)!==t:void 0}function Ct(e,t,n,r,i){if(n)if(o(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(o){if("class"===o||"style"===o||v(o))a=e;else{var s=e.attrs&&e.attrs.type;a=r||F.mustUseProp(t,s,o)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=b(o),u=x(o);c in a||u in a||(a[o]=n[o],i&&((e.on||(e.on={}))["update:"+o]=function(e){n[o]=e}))};for(var c in n)s(c)}else;return e}function kt(e,t){var n=this._staticTrees||(this._staticTrees=[]),r=n[e];return r&&!t||Ot(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),r}function At(e,t,n){return Ot(e,"__once__"+t+(n?"_"+n:""),!0),e}function Ot(e,t,n){if(Array.isArray(e))for(var r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&St(e[r],t+"_"+r,n);else St(e,t,n)}function St(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function Tt(e,t){if(t)if(s(t)){var n=e.on=e.on?A({},e.on):{};for(var r in t){var i=n[r],o=t[r];n[r]=i?[].concat(i,o):o}}else;return e}function Et(e,t,n,r){t=t||{$stable:!n};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Et(o,t,n):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return r&&(t.$key=r),t}function Nt(e,t){for(var n=0;n<t.length;n+=2){var r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function jt(e,t){return"string"==typeof e?t+e:e}function Dt(e){e._o=At,e._n=f,e._s=l,e._l=_t,e._t=bt,e._q=N,e._i=j,e._m=kt,e._f=$t,e._k=xt,e._b=Ct,e._v=me,e._e=he,e._u=Et,e._g=Tt,e._d=Nt,e._p=jt}function Lt(t,n,i,o,a){var s,c=this,u=a.options;y(o,"_uid")?(s=Object.create(o))._original=o:(s=o,o=o._original);var l=r(u._compiled),f=!l;this.data=t,this.props=n,this.children=i,this.parent=o,this.listeners=t.on||e,this.injections=dt(u.inject,o),this.slots=function(){return c.$slots||mt(t.scopedSlots,c.$slots=vt(i,o)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return mt(t.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=mt(t.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,n,r){var i=Bt(s,e,t,n,r,f);return i&&!Array.isArray(i)&&(i.fnScopeId=u._scopeId,i.fnContext=o),i}:this._c=function(e,t,n,r){return Bt(s,e,t,n,r,f)}}function Mt(e,t,n,r,i){var o=ye(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function It(e,t){for(var n in t)e[b(n)]=t[n]}Dt(Lt.prototype);var Ft={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Ft.prepatch(r,r)}else{(e.componentInstance=function(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},i=e.data.inlineTemplate;n(i)&&(r.render=i.render,r.staticRenderFns=i.staticRenderFns);return new e.componentOptions.Ctor(r)}(e,Yt)).$mount(t?e.elm:void 0,t)}},prepatch:function(t,n){var r=n.componentOptions;!function(t,n,r,i,o){var a=i.data.scopedSlots,s=t.$scopedSlots,c=!!(a&&!a.$stable||s!==e&&!s.$stable||a&&t.$scopedSlots.$key!==a.$key),u=!!(o||t.$options._renderChildren||c);t.$options._parentVnode=i,t.$vnode=i,t._vnode&&(t._vnode.parent=i);if(t.$options._renderChildren=o,t.$attrs=i.data.attrs||e,t.$listeners=r||e,n&&t.$options.props){we(!1);for(var l=t._props,f=t.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=t.$options.props;l[d]=Fe(d,v,n,t)}we(!0),t.$options.propsData=n}r=r||e;var h=t.$options._parentListeners;t.$options._parentListeners=r,Xt(t,r,h),u&&(t.$slots=vt(o,i.context),t.$forceUpdate())}(n.componentInstance=t.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(e){var t,n=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,rn(r,"mounted")),e.data.keepAlive&&(n._isMounted?((t=r)._inactive=!1,an.push(t)):tn(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?nn(t,!0):t.$destroy())}},Pt=Object.keys(Ft);function Rt(i,a,s,c,l){if(!t(i)){var f=s.$options._base;if(o(i)&&(i=f.extend(i)),"function"==typeof i){var p;if(t(i.cid)&&void 0===(i=function(e,i){if(r(e.error)&&n(e.errorComp))return e.errorComp;if(n(e.resolved))return e.resolved;var a=Vt;a&&n(e.owners)&&-1===e.owners.indexOf(a)&&e.owners.push(a);if(r(e.loading)&&n(e.loadingComp))return e.loadingComp;if(a&&!n(e.owners)){var s=e.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return h(s,a)}));var p=function(e){for(var t=0,n=s.length;t<n;t++)s[t].$forceUpdate();e&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=D((function(t){e.resolved=Kt(t,i),c?s.length=0:p(!0)})),v=D((function(t){n(e.errorComp)&&(e.error=!0,p(!0))})),m=e(d,v);return o(m)&&(u(m)?t(e.resolved)&&m.then(d,v):u(m.component)&&(m.component.then(d,v),n(m.error)&&(e.errorComp=Kt(m.error,i)),n(m.loading)&&(e.loadingComp=Kt(m.loading,i),0===m.delay?e.loading=!0:l=setTimeout((function(){l=null,t(e.resolved)&&t(e.error)&&(e.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,t(e.resolved)&&v(null)}),m.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=i,f)))return function(e,t,n,r,i){var o=he();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:i},o}(p,a,s,c,l);a=a||{},An(i),n(a.model)&&function(e,t){var r=e.model&&e.model.prop||"value",i=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[i],s=t.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[i]=[s].concat(a)):o[i]=s}(i.options,a);var d=function(e,r,i){var o=r.options.props;if(!t(o)){var a={},s=e.attrs,c=e.props;if(n(s)||n(c))for(var u in o){var l=x(u);ut(a,c,u,l,!0)||ut(a,s,u,l,!1)}return a}}(a,i);if(r(i.options.functional))return function(t,r,i,o,a){var s=t.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Fe(l,u,r||e);else n(i.attrs)&&It(c,i.attrs),n(i.props)&&It(c,i.props);var f=new Lt(i,c,a,o,t),p=s.render.call(null,f._c,f);if(p instanceof de)return Mt(p,i,f.parent,s);if(Array.isArray(p)){for(var d=lt(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Mt(d[h],i,f.parent,s);return v}}(i,d,a,s,c);var v=a.on;if(a.on=a.nativeOn,r(i.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(e){for(var t=e.hook||(e.hook={}),n=0;n<Pt.length;n++){var r=Pt[n],i=t[r],o=Ft[r];i===o||i&&i._merged||(t[r]=i?Ht(o,i):o)}}(a);var y=i.options.name||l;return new de("vue-component-"+i.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:i,propsData:d,listeners:v,tag:l,children:c},p)}}}function Ht(e,t){var n=function(n,r){e(n,r),t(n,r)};return n._merged=!0,n}function Bt(e,t,a,s,c,u){return(Array.isArray(a)||i(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(e,t,r,i,a){if(n(r)&&n(r.__ob__))return he();n(r)&&n(r.is)&&(t=r.is);if(!t)return he();Array.isArray(i)&&"function"==typeof i[0]&&((r=r||{}).scopedSlots={default:i[0]},i.length=0);2===a?i=lt(i):1===a&&(i=function(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}(i));var s,c;if("string"==typeof t){var u;c=e.$vnode&&e.$vnode.ns||F.getTagNamespace(t),s=F.isReservedTag(t)?new de(F.parsePlatformTagName(t),r,i,void 0,void 0,e):r&&r.pre||!n(u=Ie(e.$options,"components",t))?new de(t,r,i,void 0,void 0,e):Rt(u,r,e,i,t)}else s=Rt(t,r,e,i);return Array.isArray(s)?s:n(s)?(n(c)&&Ut(s,c),n(r)&&function(e){o(e.style)&&rt(e.style);o(e.class)&&rt(e.class)}(r),s):he()}(e,t,a,s,c)}function Ut(e,i,o){if(e.ns=i,"foreignObject"===e.tag&&(i=void 0,o=!0),n(e.children))for(var a=0,s=e.children.length;a<s;a++){var c=e.children[a];n(c.tag)&&(t(c.ns)||r(o)&&"svg"!==c.tag)&&Ut(c,i,o)}}var zt,Vt=null;function Kt(e,t){return(e.__esModule||ae&&"Module"===e[Symbol.toStringTag])&&(e=e.default),o(e)?t.extend(e):e}function qt(e){return e.isComment&&e.asyncFactory}function Jt(e){if(Array.isArray(e))for(var t=0;t<e.length;t++){var r=e[t];if(n(r)&&(n(r.componentOptions)||qt(r)))return r}}function Wt(e,t){zt.$on(e,t)}function Zt(e,t){zt.$off(e,t)}function Gt(e,t){var n=zt;return function r(){var i=t.apply(null,arguments);null!==i&&n.$off(e,r)}}function Xt(e,t,n){zt=e,st(t,n||{},Wt,Zt,Gt,e),zt=void 0}var Yt=null;function Qt(e){var t=Yt;return Yt=e,function(){Yt=t}}function en(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function tn(e,t){if(t){if(e._directInactive=!1,en(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(var n=0;n<e.$children.length;n++)tn(e.$children[n]);rn(e,"activated")}}function nn(e,t){if(!(t&&(e._directInactive=!0,en(e))||e._inactive)){e._inactive=!0;for(var n=0;n<e.$children.length;n++)nn(e.$children[n]);rn(e,"deactivated")}}function rn(e,t){fe();var n=e.$options[t],r=t+" hook";if(n)for(var i=0,o=n.length;i<o;i++)ze(n[i],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),pe()}var on=[],an=[],sn={},cn=!1,un=!1,ln=0;var fn=0,pn=Date.now;if(z&&!J){var dn=window.performance;dn&&"function"==typeof dn.now&&pn()>document.createEvent("Event").timeStamp&&(pn=function(){return dn.now()})}function vn(){var e,t;for(fn=pn(),un=!0,on.sort((function(e,t){return e.id-t.id})),ln=0;ln<on.length;ln++)(e=on[ln]).before&&e.before(),t=e.id,sn[t]=null,e.run();var n=an.slice(),r=on.slice();ln=on.length=an.length=0,sn={},cn=un=!1,function(e){for(var t=0;t<e.length;t++)e[t]._inactive=!0,tn(e[t],!0)}(n),function(e){var t=e.length;for(;t--;){var n=e[t],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&rn(r,"updated")}}(r),re&&F.devtools&&re.emit("flush")}var hn=0,mn=function(e,t,n,r,i){this.vm=e,i&&(e._watcher=this),e._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++hn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new oe,this.newDepIds=new oe,this.expression="","function"==typeof t?this.getter=t:(this.getter=function(e){if(!B.test(e)){var t=e.split(".");return function(e){for(var n=0;n<t.length;n++){if(!e)return;e=e[t[n]]}return e}}}(t),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()};mn.prototype.get=function(){var e;fe(this);var t=this.vm;try{e=this.getter.call(t,t)}catch(e){if(!this.user)throw e;Ue(e,t,'getter for watcher "'+this.expression+'"')}finally{this.deep&&rt(e),pe(),this.cleanupDeps()}return e},mn.prototype.addDep=function(e){var t=e.id;this.newDepIds.has(t)||(this.newDepIds.add(t),this.newDeps.push(e),this.depIds.has(t)||e.addSub(this))},mn.prototype.cleanupDeps=function(){for(var e=this.deps.length;e--;){var t=this.deps[e];this.newDepIds.has(t.id)||t.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},mn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(e){var t=e.id;if(null==sn[t]){if(sn[t]=!0,un){for(var n=on.length-1;n>ln&&on[n].id>e.id;)n--;on.splice(n+1,0,e)}else on.push(e);cn||(cn=!0,tt(vn))}}(this)},mn.prototype.run=function(){if(this.active){var e=this.get();if(e!==this.value||o(e)||this.deep){var t=this.value;if(this.value=e,this.user)try{this.cb.call(this.vm,e,t)}catch(e){Ue(e,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,e,t)}}},mn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},mn.prototype.depend=function(){for(var e=this.deps.length;e--;)this.deps[e].depend()},mn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);for(var e=this.deps.length;e--;)this.deps[e].removeSub(this);this.active=!1}};var yn={enumerable:!0,configurable:!0,get:S,set:S};function gn(e,t,n){yn.get=function(){return this[t][n]},yn.set=function(e){this[t][n]=e},Object.defineProperty(e,n,yn)}function _n(e){e._watchers=[];var t=e.$options;t.props&&function(e,t){var n=e.$options.propsData||{},r=e._props={},i=e.$options._propKeys=[];e.$parent&&we(!1);var o=function(o){i.push(o);var a=Fe(o,t,n,e);ke(r,o,a),o in e||gn(e,"_props",o)};for(var a in t)o(a);we(!0)}(e,t.props),t.methods&&function(e,t){for(var n in e.$options.props,t)e[n]="function"!=typeof t[n]?S:C(t[n],e)}(e,t.methods),t.data?function(e){var t=e.$options.data;s(t=e._data="function"==typeof t?function(e,t){fe();try{return e.call(t,t)}catch(e){return Ue(e,t,"data()"),{}}finally{pe()}}(t,e):t||{})||(t={});var n=Object.keys(t),r=e.$options.props;e.$options.methods;var i=n.length;for(;i--;){var o=n[i];r&&y(r,o)||R(o)||gn(e,"_data",o)}Ce(t,!0)}(e):Ce(e._data={},!0),t.computed&&function(e,t){var n=e._computedWatchers=Object.create(null),r=ne();for(var i in t){var o=t[i],a="function"==typeof o?o:o.get;r||(n[i]=new mn(e,a||S,S,bn)),i in e||$n(e,i,o)}}(e,t.computed),t.watch&&t.watch!==Q&&function(e,t){for(var n in t){var r=t[n];if(Array.isArray(r))for(var i=0;i<r.length;i++)Cn(e,n,r[i]);else Cn(e,n,r)}}(e,t.watch)}var bn={lazy:!0};function $n(e,t,n){var r=!ne();"function"==typeof n?(yn.get=r?wn(t):xn(n),yn.set=S):(yn.get=n.get?r&&!1!==n.cache?wn(t):xn(n.get):S,yn.set=n.set||S),Object.defineProperty(e,t,yn)}function wn(e){return function(){var t=this._computedWatchers&&this._computedWatchers[e];if(t)return t.dirty&&t.evaluate(),ue.target&&t.depend(),t.value}}function xn(e){return function(){return e.call(this,this)}}function Cn(e,t,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=e[n]),e.$watch(t,n,r)}var kn=0;function An(e){var t=e.options;if(e.super){var n=An(e.super);if(n!==e.superOptions){e.superOptions=n;var r=function(e){var t,n=e.options,r=e.sealedOptions;for(var i in n)n[i]!==r[i]&&(t||(t={}),t[i]=n[i]);return t}(e);r&&A(e.extendOptions,r),(t=e.options=Me(n,e.extendOptions)).name&&(t.components[t.name]=e)}}return t}function On(e){this._init(e)}function Sn(e){e.cid=0;var t=1;e.extend=function(e){e=e||{};var n=this,r=n.cid,i=e._Ctor||(e._Ctor={});if(i[r])return i[r];var o=e.name||n.options.name,a=function(e){this._init(e)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=t++,a.options=Me(n.options,e),a.super=n,a.options.props&&function(e){var t=e.options.props;for(var n in t)gn(e.prototype,"_props",n)}(a),a.options.computed&&function(e){var t=e.options.computed;for(var n in t)$n(e.prototype,n,t[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,M.forEach((function(e){a[e]=n[e]})),o&&(a.options.components[o]=a),a.superOptions=n.options,a.extendOptions=e,a.sealedOptions=A({},a.options),i[r]=a,a}}function Tn(e){return e&&(e.Ctor.options.name||e.tag)}function En(e,t){return Array.isArray(e)?e.indexOf(t)>-1:"string"==typeof e?e.split(",").indexOf(t)>-1:(n=e,"[object RegExp]"===a.call(n)&&e.test(t));var n}function Nn(e,t){var n=e.cache,r=e.keys,i=e._vnode;for(var o in n){var a=n[o];if(a){var s=Tn(a.componentOptions);s&&!t(s)&&jn(n,o,r,i)}}}function jn(e,t,n,r){var i=e[t];!i||r&&i.tag===r.tag||i.componentInstance.$destroy(),e[t]=null,h(n,t)}!function(t){t.prototype._init=function(t){var n=this;n._uid=kn++,n._isVue=!0,t&&t._isComponent?function(e,t){var n=e.$options=Object.create(e.constructor.options),r=t._parentVnode;n.parent=t.parent,n._parentVnode=r;var i=r.componentOptions;n.propsData=i.propsData,n._parentListeners=i.listeners,n._renderChildren=i.children,n._componentTag=i.tag,t.render&&(n.render=t.render,n.staticRenderFns=t.staticRenderFns)}(n,t):n.$options=Me(An(n.constructor),t||{},n),n._renderProxy=n,n._self=n,function(e){var t=e.$options,n=t.parent;if(n&&!t.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(e)}e.$parent=n,e.$root=n?n.$root:e,e.$children=[],e.$refs={},e._watcher=null,e._inactive=null,e._directInactive=!1,e._isMounted=!1,e._isDestroyed=!1,e._isBeingDestroyed=!1}(n),function(e){e._events=Object.create(null),e._hasHookEvent=!1;var t=e.$options._parentListeners;t&&Xt(e,t)}(n),function(t){t._vnode=null,t._staticTrees=null;var n=t.$options,r=t.$vnode=n._parentVnode,i=r&&r.context;t.$slots=vt(n._renderChildren,i),t.$scopedSlots=e,t._c=function(e,n,r,i){return Bt(t,e,n,r,i,!1)},t.$createElement=function(e,n,r,i){return Bt(t,e,n,r,i,!0)};var o=r&&r.data;ke(t,"$attrs",o&&o.attrs||e,null,!0),ke(t,"$listeners",n._parentListeners||e,null,!0)}(n),rn(n,"beforeCreate"),function(e){var t=dt(e.$options.inject,e);t&&(we(!1),Object.keys(t).forEach((function(n){ke(e,n,t[n])})),we(!0))}(n),_n(n),function(e){var t=e.$options.provide;t&&(e._provided="function"==typeof t?t.call(e):t)}(n),rn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(On),function(e){var t={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(e.prototype,"$data",t),Object.defineProperty(e.prototype,"$props",n),e.prototype.$set=Ae,e.prototype.$delete=Oe,e.prototype.$watch=function(e,t,n){var r=this;if(s(t))return Cn(r,e,t,n);(n=n||{}).user=!0;var i=new mn(r,e,t,n);if(n.immediate){fe();try{t.call(r,i.value)}catch(e){Ue(e,r,'callback for immediate watcher "'+i.expression+'"')}pe()}return function(){i.teardown()}}}(On),function(e){var t=/^hook:/;e.prototype.$on=function(e,n){var r=this;if(Array.isArray(e))for(var i=0,o=e.length;i<o;i++)r.$on(e[i],n);else(r._events[e]||(r._events[e]=[])).push(n),t.test(e)&&(r._hasHookEvent=!0);return r},e.prototype.$once=function(e,t){var n=this;function r(){n.$off(e,r),t.apply(n,arguments)}return r.fn=t,n.$on(e,r),n},e.prototype.$off=function(e,t){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(e)){for(var r=0,i=e.length;r<i;r++)n.$off(e[r],t);return n}var o,a=n._events[e];if(!a)return n;if(!t)return n._events[e]=null,n;for(var s=a.length;s--;)if((o=a[s])===t||o.fn===t){a.splice(s,1);break}return n},e.prototype.$emit=function(e){var t=this,n=t._events[e];if(n){n=n.length>1?k(n):n;for(var r=k(arguments,1),i='event handler for "'+e+'"',o=0,a=n.length;o<a;o++)ze(n[o],t,r,t,i)}return t}}(On),function(e){e.prototype._update=function(e,t){var n=this,r=n.$el,i=n._vnode,o=Qt(n);n._vnode=e,n.$el=i?n.__patch__(i,e):n.__patch__(n.$el,e,t,!1),o(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},e.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},e.prototype.$destroy=function(){var e=this;if(!e._isBeingDestroyed){rn(e,"beforeDestroy"),e._isBeingDestroyed=!0;var t=e.$parent;!t||t._isBeingDestroyed||e.$options.abstract||h(t.$children,e),e._watcher&&e._watcher.teardown();for(var n=e._watchers.length;n--;)e._watchers[n].teardown();e._data.__ob__&&e._data.__ob__.vmCount--,e._isDestroyed=!0,e.__patch__(e._vnode,null),rn(e,"destroyed"),e.$off(),e.$el&&(e.$el.__vue__=null),e.$vnode&&(e.$vnode.parent=null)}}}(On),function(e){Dt(e.prototype),e.prototype.$nextTick=function(e){return tt(e,this)},e.prototype._render=function(){var e,t=this,n=t.$options,r=n.render,i=n._parentVnode;i&&(t.$scopedSlots=mt(i.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=i;try{Vt=t,e=r.call(t._renderProxy,t.$createElement)}catch(n){Ue(n,t,"render"),e=t._vnode}finally{Vt=null}return Array.isArray(e)&&1===e.length&&(e=e[0]),e instanceof de||(e=he()),e.parent=i,e}}(On);var Dn=[String,RegExp,Array],Ln={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Dn,exclude:Dn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var e in this.cache)jn(this.cache,e,this.keys)},mounted:function(){var e=this;this.$watch("include",(function(t){Nn(e,(function(e){return En(t,e)}))})),this.$watch("exclude",(function(t){Nn(e,(function(e){return!En(t,e)}))}))},render:function(){var e=this.$slots.default,t=Jt(e),n=t&&t.componentOptions;if(n){var r=Tn(n),i=this.include,o=this.exclude;if(i&&(!r||!En(i,r))||o&&r&&En(o,r))return t;var a=this.cache,s=this.keys,c=null==t.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):t.key;a[c]?(t.componentInstance=a[c].componentInstance,h(s,c),s.push(c)):(a[c]=t,s.push(c),this.max&&s.length>parseInt(this.max)&&jn(a,s[0],s,this._vnode)),t.data.keepAlive=!0}return t||e&&e[0]}}};!function(e){var t={get:function(){return F}};Object.defineProperty(e,"config",t),e.util={warn:se,extend:A,mergeOptions:Me,defineReactive:ke},e.set=Ae,e.delete=Oe,e.nextTick=tt,e.observable=function(e){return Ce(e),e},e.options=Object.create(null),M.forEach((function(t){e.options[t+"s"]=Object.create(null)})),e.options._base=e,A(e.options.components,Ln),function(e){e.use=function(e){var t=this._installedPlugins||(this._installedPlugins=[]);if(t.indexOf(e)>-1)return this;var n=k(arguments,1);return n.unshift(this),"function"==typeof e.install?e.install.apply(e,n):"function"==typeof e&&e.apply(null,n),t.push(e),this}}(e),function(e){e.mixin=function(e){return this.options=Me(this.options,e),this}}(e),Sn(e),function(e){M.forEach((function(t){e[t]=function(e,n){return n?("component"===t&&s(n)&&(n.name=n.name||e,n=this.options._base.extend(n)),"directive"===t&&"function"==typeof n&&(n={bind:n,update:n}),this.options[t+"s"][e]=n,n):this.options[t+"s"][e]}}))}(e)}(On),Object.defineProperty(On.prototype,"$isServer",{get:ne}),Object.defineProperty(On.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(On,"FunctionalRenderContext",{value:Lt}),On.version="2.6.12";var Mn=p("style,class"),In=p("input,textarea,option,select,progress"),Fn=p("contenteditable,draggable,spellcheck"),Pn=p("events,caret,typing,plaintext-only"),Rn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Hn="http://www.w3.org/1999/xlink",Bn=function(e){return":"===e.charAt(5)&&"xlink"===e.slice(0,5)},Un=function(e){return Bn(e)?e.slice(6,e.length):""},zn=function(e){return null==e||!1===e};function Vn(e){for(var t=e.data,r=e,i=e;n(i.componentInstance);)(i=i.componentInstance._vnode)&&i.data&&(t=Kn(i.data,t));for(;n(r=r.parent);)r&&r.data&&(t=Kn(t,r.data));return function(e,t){if(n(e)||n(t))return qn(e,Jn(t));return""}(t.staticClass,t.class)}function Kn(e,t){return{staticClass:qn(e.staticClass,t.staticClass),class:n(e.class)?[e.class,t.class]:t.class}}function qn(e,t){return e?t?e+" "+t:e:t||""}function Jn(e){return Array.isArray(e)?function(e){for(var t,r="",i=0,o=e.length;i<o;i++)n(t=Jn(e[i]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):o(e)?function(e){var t="";for(var n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Zn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Gn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(e){return Zn(e)||Gn(e)};var Yn=Object.create(null);var Qn=p("text,number,password,search,email,tel,url");var er=Object.freeze({__proto__:null,createElement:function(e,t){var n=document.createElement(e);return"select"!==e||t.data&&t.data.attrs&&void 0!==t.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(e,t){return document.createElementNS(Wn[e],t)},createTextNode:function(e){return document.createTextNode(e)},createComment:function(e){return document.createComment(e)},insertBefore:function(e,t,n){e.insertBefore(t,n)},removeChild:function(e,t){e.removeChild(t)},appendChild:function(e,t){e.appendChild(t)},parentNode:function(e){return e.parentNode},nextSibling:function(e){return e.nextSibling},tagName:function(e){return e.tagName},setTextContent:function(e,t){e.textContent=t},setStyleScope:function(e,t){e.setAttribute(t,"")}}),tr={create:function(e,t){nr(t)},update:function(e,t){e.data.ref!==t.data.ref&&(nr(e,!0),nr(t))},destroy:function(e){nr(e,!0)}};function nr(e,t){var r=e.data.ref;if(n(r)){var i=e.context,o=e.componentInstance||e.elm,a=i.$refs;t?Array.isArray(a[r])?h(a[r],o):a[r]===o&&(a[r]=void 0):e.data.refInFor?Array.isArray(a[r])?a[r].indexOf(o)<0&&a[r].push(o):a[r]=[o]:a[r]=o}}var rr=new de("",{},[]),ir=["create","activate","update","remove","destroy"];function or(e,i){return e.key===i.key&&(e.tag===i.tag&&e.isComment===i.isComment&&n(e.data)===n(i.data)&&function(e,t){if("input"!==e.tag)return!0;var r,i=n(r=e.data)&&n(r=r.attrs)&&r.type,o=n(r=t.data)&&n(r=r.attrs)&&r.type;return i===o||Qn(i)&&Qn(o)}(e,i)||r(e.isAsyncPlaceholder)&&e.asyncFactory===i.asyncFactory&&t(i.asyncFactory.error))}function ar(e,t,r){var i,o,a={};for(i=t;i<=r;++i)n(o=e[i].key)&&(a[o]=i);return a}var sr={create:cr,update:cr,destroy:function(e){cr(e,rr)}};function cr(e,t){(e.data.directives||t.data.directives)&&function(e,t){var n,r,i,o=e===rr,a=t===rr,s=lr(e.data.directives,e.context),c=lr(t.data.directives,t.context),u=[],l=[];for(n in c)r=s[n],i=c[n],r?(i.oldValue=r.value,i.oldArg=r.arg,pr(i,"update",t,e),i.def&&i.def.componentUpdated&&l.push(i)):(pr(i,"bind",t,e),i.def&&i.def.inserted&&u.push(i));if(u.length){var f=function(){for(var n=0;n<u.length;n++)pr(u[n],"inserted",t,e)};o?ct(t,"insert",f):f()}l.length&&ct(t,"postpatch",(function(){for(var n=0;n<l.length;n++)pr(l[n],"componentUpdated",t,e)}));if(!o)for(n in s)c[n]||pr(s[n],"unbind",e,e,a)}(e,t)}var ur=Object.create(null);function lr(e,t){var n,r,i=Object.create(null);if(!e)return i;for(n=0;n<e.length;n++)(r=e[n]).modifiers||(r.modifiers=ur),i[fr(r)]=r,r.def=Ie(t.$options,"directives",r.name);return i}function fr(e){return e.rawName||e.name+"."+Object.keys(e.modifiers||{}).join(".")}function pr(e,t,n,r,i){var o=e.def&&e.def[t];if(o)try{o(n.elm,e,n,r,i)}catch(r){Ue(r,n.context,"directive "+e.name+" "+t+" hook")}}var dr=[tr,sr];function vr(e,r){var i=r.componentOptions;if(!(n(i)&&!1===i.Ctor.options.inheritAttrs||t(e.data.attrs)&&t(r.data.attrs))){var o,a,s=r.elm,c=e.data.attrs||{},u=r.data.attrs||{};for(o in n(u.__ob__)&&(u=r.data.attrs=A({},u)),u)a=u[o],c[o]!==a&&hr(s,o,a,r.data.pre);for(o in(J||Z)&&u.value!==c.value&&hr(s,"value",u.value),c)t(u[o])&&(Bn(o)?s.removeAttributeNS(Hn,Un(o)):Fn(o)||s.removeAttribute(o))}}function hr(e,t,n,r){r||e.tagName.indexOf("-")>-1?mr(e,t,n):Rn(t)?zn(n)?e.removeAttribute(t):(n="allowfullscreen"===t&&"EMBED"===e.tagName?"true":t,e.setAttribute(t,n)):Fn(t)?e.setAttribute(t,function(e,t){return zn(t)||"false"===t?"false":"contenteditable"===e&&Pn(t)?t:"true"}(t,n)):Bn(t)?zn(n)?e.removeAttributeNS(Hn,Un(t)):e.setAttributeNS(Hn,t,n):mr(e,t,n)}function mr(e,t,n){if(zn(n))e.removeAttribute(t);else{if(J&&!W&&"TEXTAREA"===e.tagName&&"placeholder"===t&&""!==n&&!e.__ieph){var r=function(t){t.stopImmediatePropagation(),e.removeEventListener("input",r)};e.addEventListener("input",r),e.__ieph=!0}e.setAttribute(t,n)}}var yr={create:vr,update:vr};function gr(e,r){var i=r.elm,o=r.data,a=e.data;if(!(t(o.staticClass)&&t(o.class)&&(t(a)||t(a.staticClass)&&t(a.class)))){var s=Vn(r),c=i._transitionClasses;n(c)&&(s=qn(s,Jn(c))),s!==i._prevClass&&(i.setAttribute("class",s),i._prevClass=s)}}var _r,br,$r,wr,xr,Cr,kr={create:gr,update:gr},Ar=/[\w).+\-_$\]]/;function Or(e){var t,n,r,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),a)39===t&&92!==n&&(a=!1);else if(s)34===t&&92!==n&&(s=!1);else if(c)96===t&&92!==n&&(c=!1);else if(u)47===t&&92!==n&&(u=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=r-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&Ar.test(h)||(u=!0)}}else void 0===i?(d=r+1,i=e.slice(0,r).trim()):m();function m(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===i?i=e.slice(0,r).trim():0!==d&&m(),o)for(r=0;r<o.length;r++)i=Sr(i,o[r]);return i}function Sr(e,t){var n=t.indexOf("(");if(n<0)return'_f("'+t+'")('+e+")";var r=t.slice(0,n),i=t.slice(n+1);return'_f("'+r+'")('+e+(")"!==i?","+i:i)}function Tr(e,t){console.error("[Vue compiler]: "+e)}function Er(e,t){return e?e.map((function(e){return e[t]})).filter((function(e){return e})):[]}function Nr(e,t,n,r,i){(e.props||(e.props=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function jr(e,t,n,r,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Hr({name:t,value:n,dynamic:i},r)),e.plain=!1}function Dr(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(Hr({name:t,value:n},r))}function Lr(e,t,n,r,i,o,a,s){(e.directives||(e.directives=[])).push(Hr({name:t,rawName:n,value:r,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Mr(e,t,n){return n?"_p("+t+',"'+e+'")':e+t}function Ir(t,n,r,i,o,a,s,c){var u;(i=i||e).right?c?n="("+n+")==='click'?'contextmenu':("+n+")":"click"===n&&(n="contextmenu",delete i.right):i.middle&&(c?n="("+n+")==='click'?'mouseup':("+n+")":"click"===n&&(n="mouseup")),i.capture&&(delete i.capture,n=Mr("!",n,c)),i.once&&(delete i.once,n=Mr("~",n,c)),i.passive&&(delete i.passive,n=Mr("&",n,c)),i.native?(delete i.native,u=t.nativeEvents||(t.nativeEvents={})):u=t.events||(t.events={});var l=Hr({value:r.trim(),dynamic:c},s);i!==e&&(l.modifiers=i);var f=u[n];Array.isArray(f)?o?f.unshift(l):f.push(l):u[n]=f?o?[l,f]:[f,l]:l,t.plain=!1}function Fr(e,t,n){var r=Pr(e,":"+t)||Pr(e,"v-bind:"+t);if(null!=r)return Or(r);if(!1!==n){var i=Pr(e,t);if(null!=i)return JSON.stringify(i)}}function Pr(e,t,n){var r;if(null!=(r=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return n&&delete e.attrsMap[t],r}function Rr(e,t){for(var n=e.attrsList,r=0,i=n.length;r<i;r++){var o=n[r];if(t.test(o.name))return n.splice(r,1),o}}function Hr(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}function Br(e,t,n){var r=n||{},i=r.number,o="$$v",a=o;r.trim&&(a="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(a="_n("+a+")");var s=Ur(t,a);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+s+"}"}}function Ur(e,t){var n=function(e){if(e=e.trim(),_r=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<_r-1)return(wr=e.lastIndexOf("."))>-1?{exp:e.slice(0,wr),key:'"'+e.slice(wr+1)+'"'}:{exp:e,key:null};br=e,wr=xr=Cr=0;for(;!Vr();)Kr($r=zr())?Jr($r):91===$r&&qr($r);return{exp:e.slice(0,xr),key:e.slice(xr+1,Cr)}}(e);return null===n.key?e+"="+t:"$set("+n.exp+", "+n.key+", "+t+")"}function zr(){return br.charCodeAt(++wr)}function Vr(){return wr>=_r}function Kr(e){return 34===e||39===e}function qr(e){var t=1;for(xr=wr;!Vr();)if(Kr(e=zr()))Jr(e);else if(91===e&&t++,93===e&&t--,0===t){Cr=wr;break}}function Jr(e){for(var t=e;!Vr()&&(e=zr())!==t;);}var Wr;function Zr(e,t,n){var r=Wr;return function i(){var o=t.apply(null,arguments);null!==o&&Yr(e,i,n,r)}}var Gr=Je&&!(Y&&Number(Y[1])<=53);function Xr(e,t,n,r){if(Gr){var i=fn,o=t;t=o._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=i||e.timeStamp<=0||e.target.ownerDocument!==document)return o.apply(this,arguments)}}Wr.addEventListener(e,t,ee?{capture:n,passive:r}:n)}function Yr(e,t,n,r){(r||Wr).removeEventListener(e,t._wrapper||t,n)}function Qr(e,r){if(!t(e.data.on)||!t(r.data.on)){var i=r.data.on||{},o=e.data.on||{};Wr=r.elm,function(e){if(n(e.__r)){var t=J?"change":"input";e[t]=[].concat(e.__r,e[t]||[]),delete e.__r}n(e.__c)&&(e.change=[].concat(e.__c,e.change||[]),delete e.__c)}(i),st(i,o,Xr,Yr,Zr,r.context),Wr=void 0}}var ei,ti={create:Qr,update:Qr};function ni(e,r){if(!t(e.data.domProps)||!t(r.data.domProps)){var i,o,a=r.elm,s=e.data.domProps||{},c=r.data.domProps||{};for(i in n(c.__ob__)&&(c=r.data.domProps=A({},c)),s)i in c||(a[i]="");for(i in c){if(o=c[i],"textContent"===i||"innerHTML"===i){if(r.children&&(r.children.length=0),o===s[i])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===i&&"PROGRESS"!==a.tagName){a._value=o;var u=t(o)?"":String(o);ri(a,u)&&(a.value=u)}else if("innerHTML"===i&&Gn(a.tagName)&&t(a.innerHTML)){(ei=ei||document.createElement("div")).innerHTML="<svg>"+o+"</svg>";for(var l=ei.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(o!==s[i])try{a[i]=o}catch(e){}}}}function ri(e,t){return!e.composing&&("OPTION"===e.tagName||function(e,t){var n=!0;try{n=document.activeElement!==e}catch(e){}return n&&e.value!==t}(e,t)||function(e,t){var r=e.value,i=e._vModifiers;if(n(i)){if(i.number)return f(r)!==f(t);if(i.trim)return r.trim()!==t.trim()}return r!==t}(e,t))}var ii={create:ni,update:ni},oi=g((function(e){var t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){var r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function ai(e){var t=si(e.style);return e.staticStyle?A(e.staticStyle,t):t}function si(e){return Array.isArray(e)?O(e):"string"==typeof e?oi(e):e}var ci,ui=/^--/,li=/\s*!important$/,fi=function(e,t,n){if(ui.test(t))e.style.setProperty(t,n);else if(li.test(n))e.style.setProperty(x(t),n.replace(li,""),"important");else{var r=di(t);if(Array.isArray(n))for(var i=0,o=n.length;i<o;i++)e.style[r]=n[i];else e.style[r]=n}},pi=["Webkit","Moz","ms"],di=g((function(e){if(ci=ci||document.createElement("div").style,"filter"!==(e=b(e))&&e in ci)return e;for(var t=e.charAt(0).toUpperCase()+e.slice(1),n=0;n<pi.length;n++){var r=pi[n]+t;if(r in ci)return r}}));function vi(e,r){var i=r.data,o=e.data;if(!(t(i.staticStyle)&&t(i.style)&&t(o.staticStyle)&&t(o.style))){var a,s,c=r.elm,u=o.staticStyle,l=o.normalizedStyle||o.style||{},f=u||l,p=si(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?A({},p):p;var d=function(e,t){var n,r={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(n=ai(i.data))&&A(r,n);(n=ai(e.data))&&A(r,n);for(var o=e;o=o.parent;)o.data&&(n=ai(o.data))&&A(r,n);return r}(r,!0);for(s in f)t(d[s])&&fi(c,s,"");for(s in d)(a=d[s])!==f[s]&&fi(c,s,null==a?"":a)}}var hi={create:vi,update:vi},mi=/\s+/;function yi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.add(t)})):e.classList.add(t);else{var n=" "+(e.getAttribute("class")||"")+" ";n.indexOf(" "+t+" ")<0&&e.setAttribute("class",(n+t).trim())}}function gi(e,t){if(t&&(t=t.trim()))if(e.classList)t.indexOf(" ")>-1?t.split(mi).forEach((function(t){return e.classList.remove(t)})):e.classList.remove(t),e.classList.length||e.removeAttribute("class");else{for(var n=" "+(e.getAttribute("class")||"")+" ",r=" "+t+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?e.setAttribute("class",n):e.removeAttribute("class")}}function _i(e){if(e){if("object"==typeof e){var t={};return!1!==e.css&&A(t,bi(e.name||"v")),A(t,e),t}return"string"==typeof e?bi(e):void 0}}var bi=g((function(e){return{enterClass:e+"-enter",enterToClass:e+"-enter-to",enterActiveClass:e+"-enter-active",leaveClass:e+"-leave",leaveToClass:e+"-leave-to",leaveActiveClass:e+"-leave-active"}})),$i=z&&!W,wi="transition",xi="animation",Ci="transition",ki="transitionend",Ai="animation",Oi="animationend";$i&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ci="WebkitTransition",ki="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ai="WebkitAnimation",Oi="webkitAnimationEnd"));var Si=z?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(e){return e()};function Ti(e){Si((function(){Si(e)}))}function Ei(e,t){var n=e._transitionClasses||(e._transitionClasses=[]);n.indexOf(t)<0&&(n.push(t),yi(e,t))}function Ni(e,t){e._transitionClasses&&h(e._transitionClasses,t),gi(e,t)}function ji(e,t,n){var r=Li(e,t),i=r.type,o=r.timeout,a=r.propCount;if(!i)return n();var s=i===wi?ki:Oi,c=0,u=function(){e.removeEventListener(s,l),n()},l=function(t){t.target===e&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),o+1),e.addEventListener(s,l)}var Di=/\b(transform|all)(,|$)/;function Li(e,t){var n,r=window.getComputedStyle(e),i=(r[Ci+"Delay"]||"").split(", "),o=(r[Ci+"Duration"]||"").split(", "),a=Mi(i,o),s=(r[Ai+"Delay"]||"").split(", "),c=(r[Ai+"Duration"]||"").split(", "),u=Mi(s,c),l=0,f=0;return t===wi?a>0&&(n=wi,l=a,f=o.length):t===xi?u>0&&(n=xi,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?wi:xi:null)?n===wi?o.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===wi&&Di.test(r[Ci+"Property"])}}function Mi(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max.apply(null,t.map((function(t,n){return Ii(t)+Ii(e[n])})))}function Ii(e){return 1e3*Number(e.slice(0,-1).replace(",","."))}function Fi(e,r){var i=e.elm;n(i._leaveCb)&&(i._leaveCb.cancelled=!0,i._leaveCb());var a=_i(e.data.transition);if(!t(a)&&!n(i._enterCb)&&1===i.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,$=a.appear,w=a.afterAppear,x=a.appearCancelled,C=a.duration,k=Yt,A=Yt.$vnode;A&&A.parent;)k=A.context,A=A.parent;var O=!k._isMounted||!e.isRootInsert;if(!O||$||""===$){var S=O&&d?d:u,T=O&&h?h:p,E=O&&v?v:l,N=O&&b||m,j=O&&"function"==typeof $?$:y,L=O&&w||g,M=O&&x||_,I=f(o(C)?C.enter:C),F=!1!==s&&!W,P=Hi(j),R=i._enterCb=D((function(){F&&(Ni(i,E),Ni(i,T)),R.cancelled?(F&&Ni(i,S),M&&M(i)):L&&L(i),i._enterCb=null}));e.data.show||ct(e,"insert",(function(){var t=i.parentNode,n=t&&t._pending&&t._pending[e.key];n&&n.tag===e.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(i,R)})),N&&N(i),F&&(Ei(i,S),Ei(i,T),Ti((function(){Ni(i,S),R.cancelled||(Ei(i,E),P||(Ri(I)?setTimeout(R,I):ji(i,c,R)))}))),e.data.show&&(r&&r(),j&&j(i,R)),F||P||R()}}}function Pi(e,r){var i=e.elm;n(i._enterCb)&&(i._enterCb.cancelled=!0,i._enterCb());var a=_i(e.data.transition);if(t(a)||1!==i.nodeType)return r();if(!n(i._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=Hi(v),$=f(o(g)?g.leave:g),w=i._leaveCb=D((function(){i.parentNode&&i.parentNode._pending&&(i.parentNode._pending[e.key]=null),_&&(Ni(i,l),Ni(i,p)),w.cancelled?(_&&Ni(i,u),m&&m(i)):(r(),h&&h(i)),i._leaveCb=null}));y?y(x):x()}function x(){w.cancelled||(!e.data.show&&i.parentNode&&((i.parentNode._pending||(i.parentNode._pending={}))[e.key]=e),d&&d(i),_&&(Ei(i,u),Ei(i,p),Ti((function(){Ni(i,u),w.cancelled||(Ei(i,l),b||(Ri($)?setTimeout(w,$):ji(i,c,w)))}))),v&&v(i,w),_||b||w())}}function Ri(e){return"number"==typeof e&&!isNaN(e)}function Hi(e){if(t(e))return!1;var r=e.fns;return n(r)?Hi(Array.isArray(r)?r[0]:r):(e._length||e.length)>1}function Bi(e,t){!0!==t.data.show&&Fi(t)}var Ui=function(e){var o,a,s={},c=e.modules,u=e.nodeOps;for(o=0;o<ir.length;++o)for(s[ir[o]]=[],a=0;a<c.length;++a)n(c[a][ir[o]])&&s[ir[o]].push(c[a][ir[o]]);function l(e){var t=u.parentNode(e);n(t)&&u.removeChild(t,e)}function f(e,t,i,o,a,c,l){if(n(e.elm)&&n(c)&&(e=c[l]=ye(e)),e.isRootInsert=!a,!function(e,t,i,o){var a=e.data;if(n(a)){var c=n(e.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(e,!1),n(e.componentInstance))return d(e,t),v(i,e.elm,o),r(c)&&function(e,t,r,i){var o,a=e;for(;a.componentInstance;)if(n(o=(a=a.componentInstance._vnode).data)&&n(o=o.transition)){for(o=0;o<s.activate.length;++o)s.activate[o](rr,a);t.push(a);break}v(r,e.elm,i)}(e,t,i,o),!0}}(e,t,i,o)){var f=e.data,p=e.children,m=e.tag;n(m)?(e.elm=e.ns?u.createElementNS(e.ns,m):u.createElement(m,e),g(e),h(e,p,t),n(f)&&y(e,t),v(i,e.elm,o)):r(e.isComment)?(e.elm=u.createComment(e.text),v(i,e.elm,o)):(e.elm=u.createTextNode(e.text),v(i,e.elm,o))}}function d(e,t){n(e.data.pendingInsert)&&(t.push.apply(t,e.data.pendingInsert),e.data.pendingInsert=null),e.elm=e.componentInstance.$el,m(e)?(y(e,t),g(e)):(nr(e),t.push(e))}function v(e,t,r){n(e)&&(n(r)?u.parentNode(r)===e&&u.insertBefore(e,t,r):u.appendChild(e,t))}function h(e,t,n){if(Array.isArray(t))for(var r=0;r<t.length;++r)f(t[r],n,e.elm,null,!0,t,r);else i(e.text)&&u.appendChild(e.elm,u.createTextNode(String(e.text)))}function m(e){for(;e.componentInstance;)e=e.componentInstance._vnode;return n(e.tag)}function y(e,t){for(var r=0;r<s.create.length;++r)s.create[r](rr,e);n(o=e.data.hook)&&(n(o.create)&&o.create(rr,e),n(o.insert)&&t.push(e))}function g(e){var t;if(n(t=e.fnScopeId))u.setStyleScope(e.elm,t);else for(var r=e;r;)n(t=r.context)&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t),r=r.parent;n(t=Yt)&&t!==e.context&&t!==e.fnContext&&n(t=t.$options._scopeId)&&u.setStyleScope(e.elm,t)}function _(e,t,n,r,i,o){for(;r<=i;++r)f(n[r],o,e,t,!1,n,r)}function b(e){var t,r,i=e.data;if(n(i))for(n(t=i.hook)&&n(t=t.destroy)&&t(e),t=0;t<s.destroy.length;++t)s.destroy[t](e);if(n(t=e.children))for(r=0;r<e.children.length;++r)b(e.children[r])}function $(e,t,r){for(;t<=r;++t){var i=e[t];n(i)&&(n(i.tag)?(w(i),b(i)):l(i.elm))}}function w(e,t){if(n(t)||n(e.data)){var r,i=s.remove.length+1;for(n(t)?t.listeners+=i:t=function(e,t){function n(){0==--n.listeners&&l(e)}return n.listeners=t,n}(e.elm,i),n(r=e.componentInstance)&&n(r=r._vnode)&&n(r.data)&&w(r,t),r=0;r<s.remove.length;++r)s.remove[r](e,t);n(r=e.data.hook)&&n(r=r.remove)?r(e,t):t()}else l(e.elm)}function x(e,t,r,i){for(var o=r;o<i;o++){var a=t[o];if(n(a)&&or(e,a))return o}}function C(e,i,o,a,c,l){if(e!==i){n(i.elm)&&n(a)&&(i=a[c]=ye(i));var p=i.elm=e.elm;if(r(e.isAsyncPlaceholder))n(i.asyncFactory.resolved)?O(e.elm,i,o):i.isAsyncPlaceholder=!0;else if(r(i.isStatic)&&r(e.isStatic)&&i.key===e.key&&(r(i.isCloned)||r(i.isOnce)))i.componentInstance=e.componentInstance;else{var d,v=i.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(e,i);var h=e.children,y=i.children;if(n(v)&&m(i)){for(d=0;d<s.update.length;++d)s.update[d](e,i);n(d=v.hook)&&n(d=d.update)&&d(e,i)}t(i.text)?n(h)&&n(y)?h!==y&&function(e,r,i,o,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=i.length-1,g=i[0],b=i[y],w=!a;p<=v&&d<=y;)t(h)?h=r[++p]:t(m)?m=r[--v]:or(h,g)?(C(h,g,o,i,d),h=r[++p],g=i[++d]):or(m,b)?(C(m,b,o,i,y),m=r[--v],b=i[--y]):or(h,b)?(C(h,b,o,i,y),w&&u.insertBefore(e,h.elm,u.nextSibling(m.elm)),h=r[++p],b=i[--y]):or(m,g)?(C(m,g,o,i,d),w&&u.insertBefore(e,m.elm,h.elm),m=r[--v],g=i[++d]):(t(s)&&(s=ar(r,p,v)),t(c=n(g.key)?s[g.key]:x(g,r,p,v))?f(g,o,e,h.elm,!1,i,d):or(l=r[c],g)?(C(l,g,o,i,d),r[c]=void 0,w&&u.insertBefore(e,l.elm,h.elm)):f(g,o,e,h.elm,!1,i,d),g=i[++d]);p>v?_(e,t(i[y+1])?null:i[y+1].elm,i,d,y,o):d>y&&$(r,p,v)}(p,h,y,o,l):n(y)?(n(e.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,o)):n(h)?$(h,0,h.length-1):n(e.text)&&u.setTextContent(p,""):e.text!==i.text&&u.setTextContent(p,i.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(e,i)}}}function k(e,t,i){if(r(i)&&n(e.parent))e.parent.data.pendingInsert=t;else for(var o=0;o<t.length;++o)t[o].data.hook.insert(t[o])}var A=p("attrs,class,staticClass,staticStyle,key");function O(e,t,i,o){var a,s=t.tag,c=t.data,u=t.children;if(o=o||c&&c.pre,t.elm=e,r(t.isComment)&&n(t.asyncFactory))return t.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(t,!0),n(a=t.componentInstance)))return d(t,i),!0;if(n(s)){if(n(u))if(e.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==e.innerHTML)return!1}else{for(var l=!0,f=e.firstChild,p=0;p<u.length;p++){if(!f||!O(f,u[p],i,o)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(t,u,i);if(n(c)){var v=!1;for(var m in c)if(!A(m)){v=!0,y(t,i);break}!v&&c.class&&rt(c.class)}}else e.data!==t.text&&(e.data=t.text);return!0}return function(e,i,o,a){if(!t(i)){var c,l=!1,p=[];if(t(e))l=!0,f(i,p);else{var d=n(e.nodeType);if(!d&&or(e,i))C(e,i,p,null,null,a);else{if(d){if(1===e.nodeType&&e.hasAttribute(L)&&(e.removeAttribute(L),o=!0),r(o)&&O(e,i,p))return k(i,p,!0),e;c=e,e=new de(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=e.elm,h=u.parentNode(v);if(f(i,p,v._leaveCb?null:h,u.nextSibling(v)),n(i.parent))for(var y=i.parent,g=m(i);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=i.elm,g){for(var w=0;w<s.create.length;++w)s.create[w](rr,y);var x=y.data.hook.insert;if(x.merged)for(var A=1;A<x.fns.length;A++)x.fns[A]()}else nr(y);y=y.parent}n(h)?$([e],0,0):n(e.tag)&&b(e)}}return k(i,p,l),i.elm}n(e)&&b(e)}}({nodeOps:er,modules:[yr,kr,ti,ii,hi,z?{create:Bi,activate:Bi,remove:function(e,t){!0!==e.data.show?Pi(e,t):t()}}:{}].concat(dr)});W&&document.addEventListener("selectionchange",(function(){var e=document.activeElement;e&&e.vmodel&&Gi(e,"input")}));var zi={inserted:function(e,t,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ct(n,"postpatch",(function(){zi.componentUpdated(e,t,n)})):Vi(e,t,n.context),e._vOptions=[].map.call(e.options,Ji)):("textarea"===n.tag||Qn(e.type))&&(e._vModifiers=t.modifiers,t.modifiers.lazy||(e.addEventListener("compositionstart",Wi),e.addEventListener("compositionend",Zi),e.addEventListener("change",Zi),W&&(e.vmodel=!0)))},componentUpdated:function(e,t,n){if("select"===n.tag){Vi(e,t,n.context);var r=e._vOptions,i=e._vOptions=[].map.call(e.options,Ji);if(i.some((function(e,t){return!N(e,r[t])})))(e.multiple?t.value.some((function(e){return qi(e,i)})):t.value!==t.oldValue&&qi(t.value,i))&&Gi(e,"change")}}};function Vi(e,t,n){Ki(e,t),(J||Z)&&setTimeout((function(){Ki(e,t)}),0)}function Ki(e,t,n){var r=t.value,i=e.multiple;if(!i||Array.isArray(r)){for(var o,a,s=0,c=e.options.length;s<c;s++)if(a=e.options[s],i)o=j(r,Ji(a))>-1,a.selected!==o&&(a.selected=o);else if(N(Ji(a),r))return void(e.selectedIndex!==s&&(e.selectedIndex=s));i||(e.selectedIndex=-1)}}function qi(e,t){return t.every((function(t){return!N(t,e)}))}function Ji(e){return"_value"in e?e._value:e.value}function Wi(e){e.target.composing=!0}function Zi(e){e.target.composing&&(e.target.composing=!1,Gi(e.target,"input"))}function Gi(e,t){var n=document.createEvent("HTMLEvents");n.initEvent(t,!0,!0),e.dispatchEvent(n)}function Xi(e){return!e.componentInstance||e.data&&e.data.transition?e:Xi(e.componentInstance._vnode)}var Yi={model:zi,show:{bind:function(e,t,n){var r=t.value,i=(n=Xi(n)).data&&n.data.transition,o=e.__vOriginalDisplay="none"===e.style.display?"":e.style.display;r&&i?(n.data.show=!0,Fi(n,(function(){e.style.display=o}))):e.style.display=r?o:"none"},update:function(e,t,n){var r=t.value;!r!=!t.oldValue&&((n=Xi(n)).data&&n.data.transition?(n.data.show=!0,r?Fi(n,(function(){e.style.display=e.__vOriginalDisplay})):Pi(n,(function(){e.style.display="none"}))):e.style.display=r?e.__vOriginalDisplay:"none")},unbind:function(e,t,n,r,i){i||(e.style.display=e.__vOriginalDisplay)}}},Qi={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function eo(e){var t=e&&e.componentOptions;return t&&t.Ctor.options.abstract?eo(Jt(t.children)):e}function to(e){var t={},n=e.$options;for(var r in n.propsData)t[r]=e[r];var i=n._parentListeners;for(var o in i)t[b(o)]=i[o];return t}function no(e,t){if(/\d-keep-alive$/.test(t.tag))return e("keep-alive",{props:t.componentOptions.propsData})}var ro=function(e){return e.tag||qt(e)},io=function(e){return"show"===e.name},oo={name:"transition",props:Qi,abstract:!0,render:function(e){var t=this,n=this.$slots.default;if(n&&(n=n.filter(ro)).length){var r=this.mode,o=n[0];if(function(e){for(;e=e.parent;)if(e.data.transition)return!0}(this.$vnode))return o;var a=eo(o);if(!a)return o;if(this._leaving)return no(e,o);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:i(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=to(this),u=this._vnode,l=eo(u);if(a.data.directives&&a.data.directives.some(io)&&(a.data.show=!0),l&&l.data&&!function(e,t){return t.key===e.key&&t.tag===e.tag}(a,l)&&!qt(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=A({},c);if("out-in"===r)return this._leaving=!0,ct(f,"afterLeave",(function(){t._leaving=!1,t.$forceUpdate()})),no(e,o);if("in-out"===r){if(qt(a))return u;var p,d=function(){p()};ct(c,"afterEnter",d),ct(c,"enterCancelled",d),ct(f,"delayLeave",(function(e){p=e}))}}return o}}},ao=A({tag:String,moveClass:String},Qi);function so(e){e.elm._moveCb&&e.elm._moveCb(),e.elm._enterCb&&e.elm._enterCb()}function co(e){e.data.newPos=e.elm.getBoundingClientRect()}function uo(e){var t=e.data.pos,n=e.data.newPos,r=t.left-n.left,i=t.top-n.top;if(r||i){e.data.moved=!0;var o=e.elm.style;o.transform=o.WebkitTransform="translate("+r+"px,"+i+"px)",o.transitionDuration="0s"}}delete ao.mode;var lo={Transition:oo,TransitionGroup:{props:ao,beforeMount:function(){var e=this,t=this._update;this._update=function(n,r){var i=Qt(e);e.__patch__(e._vnode,e.kept,!1,!0),e._vnode=e.kept,i(),t.call(e,n,r)}},render:function(e){for(var t=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,i=this.$slots.default||[],o=this.children=[],a=to(this),s=0;s<i.length;s++){var c=i[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(o.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=e(t,null,u),this.removed=l}return e(t,null,o)},updated:function(){var e=this.prevChildren,t=this.moveClass||(this.name||"v")+"-move";e.length&&this.hasMove(e[0].elm,t)&&(e.forEach(so),e.forEach(co),e.forEach(uo),this._reflow=document.body.offsetHeight,e.forEach((function(e){if(e.data.moved){var n=e.elm,r=n.style;Ei(n,t),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(ki,n._moveCb=function e(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(ki,e),n._moveCb=null,Ni(n,t))})}})))},methods:{hasMove:function(e,t){if(!$i)return!1;if(this._hasMove)return this._hasMove;var n=e.cloneNode();e._transitionClasses&&e._transitionClasses.forEach((function(e){gi(n,e)})),yi(n,t),n.style.display="none",this.$el.appendChild(n);var r=Li(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};On.config.mustUseProp=function(e,t,n){return"value"===n&&In(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},On.config.isReservedTag=Xn,On.config.isReservedAttr=Mn,On.config.getTagNamespace=function(e){return Gn(e)?"svg":"math"===e?"math":void 0},On.config.isUnknownElement=function(e){if(!z)return!0;if(Xn(e))return!1;if(e=e.toLowerCase(),null!=Yn[e])return Yn[e];var t=document.createElement(e);return e.indexOf("-")>-1?Yn[e]=t.constructor===window.HTMLUnknownElement||t.constructor===window.HTMLElement:Yn[e]=/HTMLUnknownElement/.test(t.toString())},A(On.options.directives,Yi),A(On.options.components,lo),On.prototype.__patch__=z?Ui:S,On.prototype.$mount=function(e,t){return function(e,t,n){var r;return e.$el=t,e.$options.render||(e.$options.render=he),rn(e,"beforeMount"),r=function(){e._update(e._render(),n)},new mn(e,r,S,{before:function(){e._isMounted&&!e._isDestroyed&&rn(e,"beforeUpdate")}},!0),n=!1,null==e.$vnode&&(e._isMounted=!0,rn(e,"mounted")),e}(this,e=e&&z?function(e){if("string"==typeof e){return document.querySelector(e)||document.createElement("div")}return e}(e):void 0,t)},z&&setTimeout((function(){F.devtools&&re&&re.emit("init",On)}),0);var fo=p("input,textarea,option,select,progress"),po=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),vo=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);function ho(e){if("string"==typeof e){var t=document.querySelector(e);return t||document.createElement("div")}return e}var mo=/\{\{((?:.|\r?\n)+?)\}\}/g,yo=/[-.*+?^${}()|[\]\/\\]/g,go=g((function(e){var t=e[0].replace(yo,"\\$&"),n=e[1].replace(yo,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));var _o={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var n=Pr(e,"class");n&&(e.staticClass=JSON.stringify(n));var r=Fr(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var bo,$o={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var n=Pr(e,"style");n&&(e.staticStyle=JSON.stringify(oi(n)));var r=Fr(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},wo=function(e){return(bo=bo||document.createElement("div")).innerHTML=e,bo.textContent},xo=p("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),Co=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ko=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Ao="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+P.source+"]*",Oo="((?:"+Ao+"\\:)?"+Ao+")",So=new RegExp("^<"+Oo),To=/^\s*(\/?)>/,Eo=new RegExp("^<\\/"+Oo+"[^>]*>"),No=/^<!DOCTYPE [^>]+>/i,jo=/^<!\--/,Do=/^<!\[/,Lo=p("script,style,textarea",!0),Mo={},Io={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Fo=/&(?:lt|gt|quot|amp|#39);/g,Po=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ro=p("pre,textarea",!0),Ho=function(e,t){return e&&Ro(e)&&"\n"===t[0]};function Bo(e,t){var n=t?Po:Fo;return e.replace(n,(function(e){return Io[e]}))}var Uo,zo,Vo,Ko,qo,Jo,Wo,Zo,Go=/^@|^v-on:/,Xo=/^v-|^@|^:|^#/,Yo=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Qo=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,ea=/^\(|\)$/g,ta=/^\[.*\]$/,na=/:(.*)$/,ra=/^:|^\.|^v-bind:/,ia=/\.[^.\]]+(?=[^\]]*$)/g,oa=/^v-slot(:|$)|^#/,aa=/[\r\n]/,sa=/[ \f\t\r\n]+/g,ca=g(wo),ua="_empty_";function la(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:ya(t),rawAttrsMap:{},parent:n,children:[]}}function fa(e,t){Uo=t.warn||Tr,Jo=t.isPreTag||T,Wo=t.mustUseProp||T,Zo=t.getTagNamespace||T,t.isReservedTag,Vo=Er(t.modules,"transformNode"),Ko=Er(t.modules,"preTransformNode"),qo=Er(t.modules,"postTransformNode"),zo=t.delimiters;var n,r,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=pa(e,t)),i.length||e===n||n.if&&(e.elseif||e.else)&&va(n,{exp:e.elseif,block:e}),r&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){for(var t=e.length;t--;){if(1===e[t].type)return e[t];e.pop()}}(r.children))&&u.if&&va(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(r.scopedSlots||(r.scopedSlots={}))[o]=e}r.children.push(e),e.parent=r}var a,u;e.children=e.children.filter((function(e){return!e.slotScope})),l(e),e.pre&&(s=!1),Jo(e.tag)&&(c=!1);for(var f=0;f<qo.length;f++)qo[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var n,r,i=[],o=t.expectHTML,a=t.isUnaryTag||T,s=t.canBeLeftOpenTag||T,c=0;e;){if(n=e,r&&Lo(r)){var u=0,l=r.toLowerCase(),f=Mo[l]||(Mo[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,(function(e,n,r){return u=r.length,Lo(l)||"noscript"===l||(n=n.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ho(l,n)&&(n=n.slice(1)),t.chars&&t.chars(n),""}));c+=e.length-p.length,e=p,A(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(jo.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),x(v+3);continue}}if(Do.test(e)){var h=e.indexOf("]>");if(h>=0){x(h+2);continue}}var m=e.match(No);if(m){x(m[0].length);continue}var y=e.match(Eo);if(y){var g=c;x(y[0].length),A(y[1],g,c);continue}var _=C();if(_){k(_),Ho(_.tagName,e)&&x(1);continue}}var b=void 0,$=void 0,w=void 0;if(d>=0){for($=e.slice(d);!(Eo.test($)||So.test($)||jo.test($)||Do.test($)||(w=$.indexOf("<",1))<0);)d+=w,$=e.slice(d);b=e.substring(0,d)}d<0&&(b=e),b&&x(b.length),t.chars&&b&&t.chars(b,c-b.length,c)}if(e===n){t.chars&&t.chars(e);break}}function x(t){c+=t,e=e.substring(t)}function C(){var t=e.match(So);if(t){var n,r,i={tagName:t[1],attrs:[],start:c};for(x(t[0].length);!(n=e.match(To))&&(r=e.match(ko)||e.match(Co));)r.start=c,x(r[0].length),r.end=c,i.attrs.push(r);if(n)return i.unarySlash=n[1],x(n[0].length),i.end=c,i}}function k(e){var n=e.tagName,c=e.unarySlash;o&&("p"===r&&xo(n)&&A(r),s(n)&&r===n&&A(n));for(var u=a(n)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===n&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:Bo(v,h)}}u||(i.push({tag:n,lowerCasedTag:n.toLowerCase(),attrs:f,start:e.start,end:e.end}),r=n),t.start&&t.start(n,f,u,e.start,e.end)}function A(e,n,o){var a,s;if(null==n&&(n=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,n,o);i.length=a,r=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,n,o):"p"===s&&(t.start&&t.start(e,[],!1,n,o),t.end&&t.end(e,n,o))}A()}(e,{warn:Uo,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=r&&r.ns||Zo(e);J&&"svg"===p&&(o=function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n];ga.test(r.name)||(r.name=r.name.replace(_a,""),t.push(r))}return t}(o));var d,v=la(e,o,r);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||ne()||(v.forbidden=!0);for(var h=0;h<Ko.length;h++)v=Ko[h](v,t)||v;s||(!function(e){null!=Pr(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Jo(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,n=t.length;if(n)for(var r=e.attrs=new Array(n),i=0;i<n;i++)r[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(r[i].start=t[i].start,r[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(da(v),function(e){var t=Pr(e,"v-if");if(t)e.if=t,va(e,{exp:t,block:e});else{null!=Pr(e,"v-else")&&(e.else=!0);var n=Pr(e,"v-else-if");n&&(e.elseif=n)}}(v),function(e){null!=Pr(e,"v-once")&&(e.once=!0)}(v)),n||(n=v),a?u(v):(r=v,i.push(v))},end:function(e,t,n){var o=i[i.length-1];i.length-=1,r=i[i.length-1],u(o)},chars:function(e,t,n){if(r&&(!J||"textarea"!==r.tag||r.attrsMap.placeholder!==e)){var i,u,l,f=r.children;if(e=c||e.trim()?"script"===(i=r).tag||"style"===i.tag?e:ca(e):f.length?a?"condense"===a&&aa.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(sa," ")),!s&&" "!==e&&(u=function(e,t){var n=t?go(t):mo;if(n.test(e)){for(var r,i,o,a=[],s=[],c=n.lastIndex=0;r=n.exec(e);){(i=r.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=Or(r[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+r[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,zo))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,n){if(r){var i={type:3,text:e,isComment:!0};r.children.push(i)}}}),n}function pa(e,t){var n,r;(r=Fr(n=e,"key"))&&(n.key=r),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Fr(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Pr(e,"scope"),e.slotScope=t||Pr(e,"slot-scope")):(t=Pr(e,"slot-scope"))&&(e.slotScope=t);var n=Fr(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||jr(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var r=Rr(e,oa);if(r){var i=ha(r),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=r.value||ua}}else{var s=Rr(e,oa);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=ha(s),l=u.name,f=u.dynamic,p=c[l]=la("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter((function(e){if(!e.slotScope)return e.parent=p,!0})),p.slotScope=s.value||ua,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Fr(e,"name"))}(e),function(e){var t;(t=Fr(e,"is"))&&(e.component=t);null!=Pr(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<Vo.length;i++)e=Vo[i](e,t)||e;return function(e){var t,n,r,i,o,a,s,c,u=e.attrsList;for(t=0,n=u.length;t<n;t++)if(r=i=u[t].name,o=u[t].value,Xo.test(r))if(e.hasBindings=!0,(a=ma(r.replace(Xo,"")))&&(r=r.replace(ia,"")),ra.test(r))r=r.replace(ra,""),o=Or(o),(c=ta.test(r))&&(r=r.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(r=b(r))&&(r="innerHTML"),a.camel&&!c&&(r=b(r)),a.sync&&(s=Ur(o,"$event"),c?Ir(e,'"update:"+('+r+")",s,null,!1,0,u[t],!0):(Ir(e,"update:"+b(r),s,null,!1,0,u[t]),x(r)!==b(r)&&Ir(e,"update:"+x(r),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Wo(e.tag,e.attrsMap.type,r)?Nr(e,r,o,u[t],c):jr(e,r,o,u[t],c);else if(Go.test(r))r=r.replace(Go,""),(c=ta.test(r))&&(r=r.slice(1,-1)),Ir(e,r,o,a,!1,0,u[t],c);else{var l=(r=r.replace(Xo,"")).match(na),f=l&&l[1];c=!1,f&&(r=r.slice(0,-(f.length+1)),ta.test(f)&&(f=f.slice(1,-1),c=!0)),Lr(e,r,i,o,f,c,a,u[t])}else jr(e,r,JSON.stringify(o),u[t]),!e.component&&"muted"===r&&Wo(e.tag,e.attrsMap.type,r)&&Nr(e,r,"true",u[t])}(e),e}function da(e){var t;if(t=Pr(e,"v-for")){var n=function(e){var t=e.match(Yo);if(!t)return;var n={};n.for=t[2].trim();var r=t[1].trim().replace(ea,""),i=r.match(Qo);i?(n.alias=r.replace(Qo,"").trim(),n.iterator1=i[1].trim(),i[2]&&(n.iterator2=i[2].trim())):n.alias=r;return n}(t);n&&A(e,n)}}function va(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function ha(e){var t=e.name.replace(oa,"");return t||"#"!==e.name[0]&&(t="default"),ta.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function ma(e){var t=e.match(ia);if(t){var n={};return t.forEach((function(e){n[e.slice(1)]=!0})),n}}function ya(e){for(var t={},n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}var ga=/^xmlns:NS\d+/,_a=/^NS\d+:/;function ba(e){return la(e.tag,e.attrsList.slice(),e.parent)}var $a=[_o,$o,{preTransformNode:function(e,t){if("input"===e.tag){var n,r=e.attrsMap;if(!r["v-model"])return;if((r[":type"]||r["v-bind:type"])&&(n=Fr(e,"type")),r.type||n||!r["v-bind"]||(n="("+r["v-bind"]+").type"),n){var i=Pr(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Pr(e,"v-else",!0),s=Pr(e,"v-else-if",!0),c=ba(e);da(c),Dr(c,"type","checkbox"),pa(c,t),c.processed=!0,c.if="("+n+")==='checkbox'"+o,va(c,{exp:c.if,block:c});var u=ba(e);Pr(u,"v-for",!0),Dr(u,"type","radio"),pa(u,t),va(c,{exp:"("+n+")==='radio'"+o,block:u});var l=ba(e);return Pr(l,"v-for",!0),Dr(l,":type",n),pa(l,t),va(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}];var wa,xa,Ca={expectHTML:!0,modules:$a,directives:{model:function(e,t,n){var r=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return Br(e,r,i),!1;if("select"===o)!function(e,t,n){var r='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(n&&n.number?"_n(val)":"val")+"});";r=r+" "+Ur(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),Ir(e,"change",r,null,!0)}(e,r,i);else if("input"===o&&"checkbox"===a)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null",o=Fr(e,"true-value")||"true",a=Fr(e,"false-value")||"false";Nr(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),Ir(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(r?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+Ur(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+Ur(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+Ur(t,"$$c")+"}",null,!0)}(e,r,i);else if("input"===o&&"radio"===a)!function(e,t,n){var r=n&&n.number,i=Fr(e,"value")||"null";Nr(e,"checked","_q("+t+","+(i=r?"_n("+i+")":i)+")"),Ir(e,"change",Ur(t,i),null,!0)}(e,r,i);else if("input"===o||"textarea"===o)!function(e,t,n){var r=e.attrsMap.type,i=n||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==r,u=o?"change":"range"===r?"__r":"input",l="$event.target.value";s&&(l="$event.target.value.trim()");a&&(l="_n("+l+")");var f=Ur(t,l);c&&(f="if($event.target.composing)return;"+f);Nr(e,"value","("+t+")"),Ir(e,u,f,null,!0),(s||a)&&Ir(e,"blur","$forceUpdate()")}(e,r,i);else if(!F.isReservedTag(o))return Br(e,r,i),!1;return!0},text:function(e,t){t.value&&Nr(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&Nr(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:p("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),mustUseProp:function(e,t,n){return"value"===n&&fo(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e},canBeLeftOpenTag:p("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),isReservedTag:function(e){return po(e)||vo(e)},getTagNamespace:function(e){return vo(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce((function(e,t){return e.concat(t.staticKeys||[])}),[]).join(",")}($a)},ka=g((function(e){return p("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(e?","+e:""))}));function Aa(e,t){e&&(wa=ka(t.staticKeys||""),xa=t.isReservedTag||T,Oa(e),Sa(e,!1))}function Oa(e){if(e.static=function(e){if(2===e.type)return!1;if(3===e.type)return!0;return!(!e.pre&&(e.hasBindings||e.if||e.for||d(e.tag)||!xa(e.tag)||function(e){for(;e.parent;){if("template"!==(e=e.parent).tag)return!1;if(e.for)return!0}return!1}(e)||!Object.keys(e).every(wa)))}(e),1===e.type){if(!xa(e.tag)&&"slot"!==e.tag&&null==e.attrsMap["inline-template"])return;for(var t=0,n=e.children.length;t<n;t++){var r=e.children[t];Oa(r),r.static||(e.static=!1)}if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++){var a=e.ifConditions[i].block;Oa(a),a.static||(e.static=!1)}}}function Sa(e,t){if(1===e.type){if((e.static||e.once)&&(e.staticInFor=t),e.static&&e.children.length&&(1!==e.children.length||3!==e.children[0].type))return void(e.staticRoot=!0);if(e.staticRoot=!1,e.children)for(var n=0,r=e.children.length;n<r;n++)Sa(e.children[n],t||!!e.for);if(e.ifConditions)for(var i=1,o=e.ifConditions.length;i<o;i++)Sa(e.ifConditions[i].block,t)}}var Ta=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ea=/\([^)]*?\);*$/,Na=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,ja={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Da={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},La=function(e){return"if("+e+")return null;"},Ma={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:La("$event.target !== $event.currentTarget"),ctrl:La("!$event.ctrlKey"),shift:La("!$event.shiftKey"),alt:La("!$event.altKey"),meta:La("!$event.metaKey"),left:La("'button' in $event && $event.button !== 0"),middle:La("'button' in $event && $event.button !== 1"),right:La("'button' in $event && $event.button !== 2")};function Ia(e,t){var n=t?"nativeOn:":"on:",r="",i="";for(var o in e){var a=Fa(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":r+='"'+o+'":'+a+","}return r="{"+r.slice(0,-1)+"}",i?n+"_d("+r+",["+i.slice(0,-1)+"])":n+r}function Fa(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map((function(e){return Fa(e)})).join(",")+"]";var t=Na.test(e.value),n=Ta.test(e.value),r=Na.test(e.value.replace(Ea,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(Ma[s])o+=Ma[s],ja[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=La(["ctrl","shift","alt","meta"].filter((function(e){return!c[e]})).map((function(e){return"$event."+e+"Key"})).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(Pa).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":n?"return ("+e.value+").apply(null, arguments)":r?"return "+e.value:e.value)+"}"}return t||n?e.value:"function($event){"+(r?"return "+e.value:e.value)+"}"}function Pa(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var n=ja[e],r=Da[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(n)+",$event.key,"+JSON.stringify(r)+")"}var Ra={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(n){return"_b("+n+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:S},Ha=function(e){this.options=e,this.warn=e.warn||Tr,this.transforms=Er(e.modules,"transformCode"),this.dataGenFns=Er(e.modules,"genData"),this.directives=A(A({},Ra),e.directives);var t=e.isReservedTag||T;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function Ba(e,t){var n=new Ha(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":Ua(e,n):'_c("div")')+"}",staticRenderFns:n.staticRenderFns}}function Ua(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return za(e,t);if(e.once&&!e.onceProcessed)return Va(e,t);if(e.for&&!e.forProcessed)return Ja(e,t);if(e.if&&!e.ifProcessed)return Ka(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var n=e.slotName||'"default"',r=Xa(e,t),i="_t("+n+(r?","+r:""),o=e.attrs||e.dynamicAttrs?es((e.attrs||[]).concat(e.dynamicAttrs||[]).map((function(e){return{name:b(e.name),value:e.value,dynamic:e.dynamic}}))):null,a=e.attrsMap["v-bind"];!o&&!a||r||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var n;if(e.component)n=function(e,t,n){var r=t.inlineTemplate?null:Xa(t,n,!0);return"_c("+e+","+Wa(t,n)+(r?","+r:"")+")"}(e.component,e,t);else{var r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=Wa(e,t));var i=e.inlineTemplate?null:Xa(e,t,!0);n="_c('"+e.tag+"'"+(r?","+r:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)n=t.transforms[o](e,n);return n}return Xa(e,t)||"void 0"}function za(e,t){e.staticProcessed=!0;var n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+Ua(e,t)+"}"),t.pre=n,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function Va(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return Ka(e,t);if(e.staticInFor){for(var n="",r=e.parent;r;){if(r.for){n=r.key;break}r=r.parent}return n?"_o("+Ua(e,t)+","+t.onceId+++","+n+")":Ua(e,t)}return za(e,t)}function Ka(e,t,n,r){return e.ifProcessed=!0,qa(e.ifConditions.slice(),t,n,r)}function qa(e,t,n,r){if(!e.length)return r||"_e()";var i=e.shift();return i.exp?"("+i.exp+")?"+o(i.block)+":"+qa(e,t,n,r):""+o(i.block);function o(e){return n?n(e,t):e.once?Va(e,t):Ua(e,t)}}function Ja(e,t,n,r){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(r||"_l")+"(("+i+"),function("+o+a+s+"){return "+(n||Ua)(e,t)+"})"}function Wa(e,t){var n="{",r=function(e,t){var n=e.directives;if(!n)return;var r,i,o,a,s="directives:[",c=!1;for(r=0,i=n.length;r<i;r++){o=n[r],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+="key:"+e.key+","),e.ref&&(n+="ref:"+e.ref+","),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)n+=t.dataGenFns[i](e);if(e.attrs&&(n+="attrs:"+es(e.attrs)+","),e.props&&(n+="domProps:"+es(e.props)+","),e.events&&(n+=Ia(e.events,!1)+","),e.nativeEvents&&(n+=Ia(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(n+="slot:"+e.slotTarget+","),e.scopedSlots&&(n+=function(e,t,n){var r=e.for||Object.keys(t).some((function(e){var n=t[e];return n.slotTargetDynamic||n.if||n.for||Za(n)})),i=!!e.if;if(!r)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==ua||o.for){r=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map((function(e){return Ga(t[e],n)})).join(",");return"scopedSlots:_u(["+a+"]"+(r?",null,true":"")+(!r&&i?",null,false,"+function(e){var t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(n+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var n=e.children[0];if(n&&1===n.type){var r=Ba(n,t.options);return"inlineTemplate:{render:function(){"+r.render+"},staticRenderFns:["+r.staticRenderFns.map((function(e){return"function(){"+e+"}"})).join(",")+"]}"}}(e,t);o&&(n+=o+",")}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n="_b("+n+',"'+e.tag+'",'+es(e.dynamicAttrs)+")"),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function Za(e){return 1===e.type&&("slot"===e.tag||e.children.some(Za))}function Ga(e,t){var n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return Ka(e,t,Ga,"null");if(e.for&&!e.forProcessed)return Ja(e,t,Ga);var r=e.slotScope===ua?"":String(e.slotScope),i="function("+r+"){return "+("template"===e.tag?e.if&&n?"("+e.if+")?"+(Xa(e,t)||"undefined")+":undefined":Xa(e,t)||"undefined":Ua(e,t))+"}",o=r?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Xa(e,t,n,r,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=n?t.maybeComponent(a)?",1":",0":"";return""+(r||Ua)(a,t)+s}var c=n?function(e,t){for(var n=0,r=0;r<e.length;r++){var i=e[r];if(1===i.type){if(Ya(i)||i.ifConditions&&i.ifConditions.some((function(e){return Ya(e.block)}))){n=2;break}(t(i)||i.ifConditions&&i.ifConditions.some((function(e){return t(e.block)})))&&(n=1)}}return n}(o,t.maybeComponent):0,u=i||Qa;return"["+o.map((function(e){return u(e,t)})).join(",")+"]"+(c?","+c:"")}}function Ya(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function Qa(e,t){return 1===e.type?Ua(e,t):3===e.type&&e.isComment?function(e){return"_e("+JSON.stringify(e.text)+")"}(e):function(e){return"_v("+(2===e.type?e.expression:ts(JSON.stringify(e.text)))+")"}(e)}function es(e){for(var t="",n="",r=0;r<e.length;r++){var i=e[r],o=ts(i.value);i.dynamic?n+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",n?"_d("+t+",["+n.slice(0,-1)+"])":t}function ts(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function ns(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),S}}function rs(e){var t=Object.create(null);return function(n,r,i){(r=A({},r)).warn,delete r.warn;var o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];var a=e(n,r),s={},c=[];return s.render=ns(a.render,c),s.staticRenderFns=a.staticRenderFns.map((function(e){return ns(e,c)})),t[o]=s}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");var is,os,as=(is=function(e,t){var n=fa(e.trim(),t);!1!==t.optimize&&Aa(n,t);var r=Ba(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){var r=Object.create(e),i=[],o=[];if(n)for(var a in n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=A(Object.create(e.directives||null),n.directives)),n)"modules"!==a&&"directives"!==a&&(r[a]=n[a]);r.warn=function(e,t,n){(n?o:i).push(e)};var s=is(t.trim(),r);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:rs(t)}})(Ca).compileToFunctions;function ss(e){return(os=os||document.createElement("div")).innerHTML=e?'<a href="\n"/>':'<div a="\n"/>',os.innerHTML.indexOf("&#10;")>0}var cs=!!z&&ss(!1),us=!!z&&ss(!0),ls=g((function(e){var t=ho(e);return t&&t.innerHTML})),fs=On.prototype.$mount;return On.prototype.$mount=function(e,t){if((e=e&&ho(e))===document.body||e===document.documentElement)return this;var n=this.$options;if(!n.render){var r=n.template;if(r)if("string"==typeof r)"#"===r.charAt(0)&&(r=ls(r));else{if(!r.nodeType)return this;r=r.innerHTML}else e&&(r=function(e){if(e.outerHTML)return e.outerHTML;var t=document.createElement("div");return t.appendChild(e.cloneNode(!0)),t.innerHTML}(e));if(r){var i=as(r,{outputSourceRange:!1,shouldDecodeNewlines:cs,shouldDecodeNewlinesForHref:us,delimiters:n.delimiters,comments:n.comments},this),o=i.render,a=i.staticRenderFns;n.render=o,n.staticRenderFns=a}}return fs.call(this,e,t)},On.compile=as,On}));
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const I="data-server-rendered",M=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:L};const P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function H(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const B=new RegExp(`[^${P.source}.$_\\d]`);const U="__proto__"in{},V="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=z&&WXEnvironment.platform.toLowerCase(),J=V&&window.navigator.userAgent.toLowerCase(),q=J&&/msie|trident/.test(J),W=J&&J.indexOf("msie 9.0")>0,G=J&&J.indexOf("edge/")>0;J&&J.indexOf("android");const Z=J&&/iphone|ipad|ipod|ios/.test(J)||"ios"===K;J&&/chrome\/\d+/.test(J),J&&/phantomjs/.test(J);const X=J&&J.match(/firefox\/(\d+)/),Y={}.watch;let Q,tt=!1;if(V)try{const t={};Object.defineProperty(t,"passive",{get(){tt=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const et=()=>(void 0===Q&&(Q=!V&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Q),nt=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ot(t){return"function"==typeof t&&/native code/.test(t.toString())}const rt="undefined"!=typeof Symbol&&ot(Symbol)&&"undefined"!=typeof Reflect&&ot(Reflect.ownKeys);let st;st="undefined"!=typeof Set&&ot(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let it=S,at=0;class ct{static target;id;subs;constructor(){this.id=at++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){ct.target&&ct.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}ct.target=null;const lt=[];function ut(t){lt.push(t),ct.target=t}function ft(){lt.pop(),ct.target=lt[lt.length-1]}class dt{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const pt=(t="")=>{const e=new dt;return e.text=t,e.isComment=!0,e};function ht(t){return new dt(void 0,void 0,void 0,String(t))}function mt(t){const e=new dt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const yt=Array.prototype,gt=Object.create(yt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=yt[t];H(gt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const vt=Object.getOwnPropertyNames(gt);let $t=!0;function _t(t){$t=t}class bt{value;dep;vmCount;constructor(t){this.value=t,this.dep=new ct,this.vmCount=0,H(t,"__ob__",this),Array.isArray(t)?(U?function(t,e){t.__proto__=e}(t,gt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];H(t,r,e[r])}}(t,gt,vt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)Ct(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)wt(t[e])}}function wt(t,e){if(!s(t)||t instanceof dt)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:$t&&!et()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,o,r){const s=new ct,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&wt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return ct.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&At(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&wt(e),s.notify())}})}function xt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(Ct(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function kt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function At(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&At(e)}const Ot=F.optionMergeStrategies;function St(t,e){if(!e)return t;let n,o,r;const s=rt?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&St(o,r):xt(t,n,r));return t}function Tt(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?St(o,r):r}:e?t?function(){return St("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Nt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}Ot.data=function(t,e,n){return n?Tt(t,e,n):e&&"function"!=typeof e?t:Tt(t,e)},L.forEach((t=>{Ot[t]=Nt})),M.forEach((function(t){Ot[t+"s"]=Et})),Ot.watch=function(t,e,n,o){if(t===Y&&(t=void 0),e===Y&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},Ot.props=Ot.methods=Ot.inject=Ot.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},Ot.provide=Tt;const jt=function(t,e){return void 0===e?t:e};function Dt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=Dt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=Dt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=Ot[r]||jt;o[r]=s(t[r],e[r],n,r)}return o}function It(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function Mt(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Rt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Rt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Ft(e.type)?o.call(t):o}(o,r,t);const e=$t;_t(!0),wt(i),_t(e)}return i}const Lt=/^\s*function (\w+)/;function Ft(t){const e=t&&t.toString().match(Lt);return e?e[1]:""}function Pt(t,e){return Ft(t)===Ft(e)}function Rt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Pt(e[n],t))return n;return-1}function Ht(t,e,n){ut();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Ut(t,o,"errorCaptured hook")}}}Ut(t,e,n)}finally{ft()}}function Bt(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Ht(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Ht(t,o,r)}return s}function Ut(t,e,n){if(F.errorHandler)try{return F.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Vt(e)}Vt(t)}function Vt(t,e,n){if(!V&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Kt=[];let Jt,qt=!1;function Wt(){qt=!1;const t=Kt.slice(0);Kt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&ot(Promise)){const t=Promise.resolve();Jt=()=>{t.then(Wt),Z&&setTimeout(S)},zt=!0}else if(q||"undefined"==typeof MutationObserver||!ot(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Jt="undefined"!=typeof setImmediate&&ot(setImmediate)?()=>{setImmediate(Wt)}:()=>{setTimeout(Wt,0)};else{let t=1;const e=new MutationObserver(Wt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Jt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Gt(t,e){let n;if(Kt.push((()=>{if(t)try{t.call(e)}catch(t){Ht(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Jt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Zt=new st;function Xt(t){Yt(t,Zt),Zt.clear()}function Yt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof dt)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Yt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Yt(t[o[n]],e)}}const Qt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function te(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Bt(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Bt(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function ee(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Qt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=te(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Qt(c),s(f.name,n[c],f.capture))}function ne(t,r,s){let i;t instanceof dt&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=te([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=te([a,c]),i.merged=!0,t[r]=i}function oe(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function re(t){return r(t)?[ht(t)]:Array.isArray(t)?ie(t):void 0}function se(t){return n(t)&&n(t.text)&&!1===t.isComment}function ie(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=ie(c,`${s||""}_${a}`),se(c[0])&&se(u)&&(i[l]=ht(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?se(u)?i[l]=ht(u.text+c):""!==c&&i.push(ht(c)):se(c)&&se(u)?i[l]=ht(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ae(t,e){if(t){const n=Object.create(null),o=rt?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ce(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(le)&&delete n[t];return n}function le(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(t){return t.isComment&&t.asyncFactory}function fe(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=de(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=pe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),H(r,"$stable",i),H(r,"$key",a),H(r,"$hasNormal",s),r}function de(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:re(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!ue(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function pe(t,e){return()=>t[e]}function he(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(rt&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function me(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function ye(t){return It(this.$options,"filters",t)||N}function ge(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ve(t,e,n,o,r){const s=F.keyCodes[e]||n;return r&&o&&!F.keyCodes[e]?ge(r,o):s?ge(s,t):o?C(o)!==e:void 0===t}function $e(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||F.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function _e(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),we(o,`__static__${t}`,!1)),o}function be(t,e,n){return we(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function we(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&Ce(t[o],`${e}_${o}`,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function xe(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function ke(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?ke(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function Ae(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Oe(t,e){return"string"==typeof t?e+t:t}function Se(t){t._o=be,t._n=f,t._s=u,t._l=he,t._t=me,t._q=E,t._i=j,t._m=_e,t._f=ye,t._k=ve,t._b=$e,t._v=ht,t._e=pt,t._u=ke,t._g=xe,t._d=Ae,t._p=Oe}function Te(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ae(a.inject,s),this.slots=()=>(this.$slots||fe(e.scopedSlots,this.$slots=ce(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return fe(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=fe(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Le(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Le(c,t,e,n,o,u)}function Ne(t,e,n,o,r){const s=mt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ee(t,e){for(const n in e)t[_(n)]=e[n]}Se(Te.prototype);const je={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;je.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Je)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){_t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Mt(s,i,n,e)}_t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ke(e,o,u),l&&(e.$slots=ce(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Xe(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Qe.push(o)):Ge(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ze(e,!0):e.$destroy())}},De=Object.keys(je);function Ie(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Re;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=He(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=He(h.error,r)),n(h.loading)&&(t.loadingComp=He(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=pt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},$n(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);oe(i,c,t,e,!0)||oe(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Mt(e,l,o||t);else n(r.attrs)&&Ee(c,r.attrs),n(r.props)&&Ee(c,r.props);const u=new Te(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof dt)return Ne(f,r,u.parent,a);if(Array.isArray(f)){const t=re(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Ne(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<De.length;t++){const n=De[t],o=e[n],r=je[n];o===r||o&&o._merged||(e[n]=o?Me(r,o):r)}}(i);const y=r.options.name||u;return new dt(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Me(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Le(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return pt();n(o)&&n(o.is)&&(e=o.is);if(!e)return pt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=re(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||F.getTagNamespace(e),a=F.isReservedTag(e)?new dt(F.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=It(t.$options,"components",e))?new dt(e,o,r,void 0,void 0,t):Ie(s,o,t,r,e)}else a=Ie(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Fe(a,c),n(o)&&function(t){s(t.style)&&Xt(t.style);s(t.class)&&Xt(t.class)}(o),a):pt()}(t,e,i,a,c)}function Fe(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Fe(a,r,s)}}let Pe,Re=null;function He(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Be(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||ue(o)))return o}}function Ue(t,e){Pe.$on(t,e)}function Ve(t,e){Pe.$off(t,e)}function ze(t,e){const n=Pe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ke(t,e,n){Pe=t,ee(e,n||{},Ue,Ve,ze,t),Pe=void 0}let Je=null;function qe(t){const e=Je;return Je=t,()=>{Je=e}}function We(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,We(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)Ge(t.$children[e]);Xe(t,"activated")}}function Ze(t,e){if(!(e&&(t._directInactive=!0,We(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ze(t.$children[e]);Xe(t,"deactivated")}}function Xe(t,e){ut();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Bt(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ft()}const Ye=[],Qe=[];let tn={},en=!1,nn=!1,on=0;let rn=0,sn=Date.now;if(V&&!q){const t=window.performance;t&&"function"==typeof t.now&&sn()>document.createEvent("Event").timeStamp&&(sn=()=>t.now())}function an(){let t,e;for(rn=sn(),nn=!0,Ye.sort(((t,e)=>t.id-e.id)),on=0;on<Ye.length;on++)t=Ye[on],t.before&&t.before(),e=t.id,tn[e]=null,t.run();const n=Qe.slice(),o=Ye.slice();on=Ye.length=Qe.length=0,tn={},en=nn=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Xe(o,"updated")}}(o),nt&&F.devtools&&nt.emit("flush")}let cn=0;class ln{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new st,this.newDepIds=new st,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(B.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;ut(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ht(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Xt(t),ft(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==tn[e]){if(tn[e]=!0,nn){let e=Ye.length-1;for(;e>on&&Ye[e].id>t.id;)e--;Ye.splice(e+1,0,t)}else Ye.push(t);en||(en=!0,Gt(an))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Bt(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const un={enumerable:!0,configurable:!0,get:S,set:S};function fn(t,e,n){un.get=function(){return this[e][n]},un.set=function(t){this[e][n]=t},Object.defineProperty(t,n,un)}function dn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&_t(!1);for(const s in e){r.push(s);Ct(o,s,Mt(s,e,n,t)),s in t||fn(t,"_props",s)}_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Ht(t,e,"data()"),{}}finally{ft()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||R(e)||fn(t,"_data",e)}wt(e,!0)}(t):wt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=et();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new ln(t,i||S,S,pn)),r in t||hn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==Y&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)gn(t,n,o[e]);else gn(t,n,o)}}(t,e.watch)}const pn={lazy:!0};function hn(t,e,n){const o=!et();"function"==typeof n?(un.get=o?mn(e):yn(n),un.set=S):(un.get=n.get?o&&!1!==n.cache?mn(e):yn(n.get):S,un.set=n.set||S),Object.defineProperty(t,e,un)}function mn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),ct.target&&e.depend(),e.value}}function yn(t){return function(){return t.call(this,this)}}function gn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let vn=0;function $n(t){let e=t.options;if(t.super){const n=$n(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=Dt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function _n(t){this._init(t)}function bn(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=Dt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)fn(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)hn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,M.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function Cn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function xn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&kn(n,t,o,r)}}}function kn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=vn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Dt($n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ke(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ce(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Le(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Le(e,t,n,o,r,!0);const s=o&&o.data;Ct(e,"$attrs",s&&s.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Xe(n,"beforeCreate"),function(t){const e=ae(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach((n=>{Ct(t,n,e[n])})),_t(!0))}(n),dn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Xe(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(_n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=xt,t.prototype.$delete=kt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return gn(o,t,e,n);(n=n||{}).user=!0;const r=new ln(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;ut(),Bt(e,o,[r.value],o,t),ft()}return function(){r.teardown()}}}(_n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Bt(n[t],e,o,e,r)}return e}}(_n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=qe(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Xe(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Xe(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(_n),function(t){Se(t.prototype),t.prototype.$nextTick=function(t){return Gt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=fe(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Re=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Ht(e,t,"render"),o=t._vnode}finally{Re=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof dt||(o=pt()),o.parent=n,o}}(_n);const An=[String,RegExp,Array];var On={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:An,exclude:An,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:wn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&kn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)kn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{xn(this,(e=>Cn(t,e)))})),this.$watch("exclude",(t=>{xn(this,(e=>!Cn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){const t=wn(n),{include:o,exclude:r}=this;if(o&&(!t||!Cn(o,t))||r&&t&&Cn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>F};Object.defineProperty(t,"config",e),t.util={warn:it,extend:A,mergeOptions:Dt,defineReactive:Ct},t.set=xt,t.delete=kt,t.nextTick=Gt,t.observable=t=>(wt(t),t),t.options=Object.create(null),M.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,On),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Dt(this.options,t),this}}(t),bn(t),function(t){M.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(_n),Object.defineProperty(_n.prototype,"$isServer",{get:et}),Object.defineProperty(_n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(_n,"FunctionalRenderContext",{value:Te}),_n.version="2.6.14";const Sn=d("style,class"),Tn=d("input,textarea,option,select,progress"),Nn=(t,e,n)=>"value"===n&&Tn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,En=d("contenteditable,draggable,spellcheck"),jn=d("events,caret,typing,plaintext-only"),Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Mn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Ln=t=>Mn(t)?t.slice(6,t.length):"",Fn=t=>null==t||!1===t;function Pn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Rn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Rn(e,o.data));return function(t,e){if(n(t)||n(e))return Hn(t,Bn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Hn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Hn(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Bn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Un={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Kn=t=>Vn(t)||zn(t);function Jn(t){return zn(t)?"svg":"math"===t?"math":void 0}const qn=Object.create(null);const Wn=d("text,number,password,search,email,tel,url");function Gn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var Zn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Un[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Xn={create(t,e){Yn(e)},update(t,e){t.data.ref!==e.data.ref&&(Yn(t,!0),Yn(e))},destroy(t){Yn(t,!0)}};function Yn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?m(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Qn=new dt("",{},[]),to=["create","activate","update","remove","destroy"];function eo(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Wn(r)&&Wn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function no(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var oo={create:ro,update:ro,destroy:function(t){ro(t,Qn)}};function ro(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Qn,o=e===Qn,r=io(t.data.directives,t.context),s=io(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,co(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(co(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)co(i[n],"inserted",e,t)};n?ne(e,"insert",o):o()}a.length&&ne(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)co(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||co(r[c],"unbind",t,t,o)}(t,e)}const so=Object.create(null);function io(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=so),n[ao(r)]=r,r.def=It(e.$options,"directives",r.name);return n}function ao(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function co(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Ht(o,n.context,`directive ${t.name} ${e} hook`)}}var lo=[Xn,oo];function uo(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&fo(c,s,i,o.data.pre);for(s in(q||G)&&u.value!==l.value&&fo(c,"value",u.value),l)e(u[s])&&(Mn(s)?c.removeAttributeNS(In,Ln(s)):En(s)||c.removeAttribute(s))}function fo(t,e,n,o){o||t.tagName.indexOf("-")>-1?po(t,e,n):Dn(e)?Fn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):En(e)?t.setAttribute(e,((t,e)=>Fn(e)||"false"===e?"false":"contenteditable"===t&&jn(e)?e:"true")(e,n)):Mn(e)?Fn(n)?t.removeAttributeNS(In,Ln(e)):t.setAttributeNS(In,e,n):po(t,e,n)}function po(t,e,n){if(Fn(n))t.removeAttribute(e);else{if(q&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var ho={create:uo,update:uo};function mo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Pn(o);const c=r._transitionClasses;n(c)&&(a=Hn(a,Bn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var yo={create:mo,update:mo};const go=/[\w).+\-_$\]]/;function vo(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&go.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=$o(r,s[o]);return r}function $o(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function _o(t,e){console.error(`[Vue compiler]: ${t}`)}function bo(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function wo(t,e,n,o,r){(t.props||(t.props=[])).push(Eo({name:e,value:n,dynamic:r},o)),t.plain=!1}function Co(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(Eo({name:e,value:n,dynamic:r},o)),t.plain=!1}function xo(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(Eo({name:e,value:n},o))}function ko(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(Eo({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function Ao(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Oo(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=Ao("!",n,c)),r.once&&(delete r.once,n=Ao("~",n,c)),r.passive&&(delete r.passive,n=Ao("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=Eo({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function So(t,e,n){const o=To(t,":"+e)||To(t,"v-bind:"+e);if(null!=o)return vo(o);if(!1!==n){const n=To(t,e);if(null!=n)return JSON.stringify(n)}}function To(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function No(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function Eo(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function jo(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=Do(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function Do(t,e){const n=function(t){if(t=t.trim(),Io=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Io-1)return Fo=t.lastIndexOf("."),Fo>-1?{exp:t.slice(0,Fo),key:'"'+t.slice(Fo+1)+'"'}:{exp:t,key:null};Mo=t,Fo=Po=Ro=0;for(;!Bo();)Lo=Ho(),Uo(Lo)?zo(Lo):91===Lo&&Vo(Lo);return{exp:t.slice(0,Po),key:t.slice(Po+1,Ro)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Io,Mo,Lo,Fo,Po,Ro;function Ho(){return Mo.charCodeAt(++Fo)}function Bo(){return Fo>=Io}function Uo(t){return 34===t||39===t}function Vo(t){let e=1;for(Po=Fo;!Bo();)if(Uo(t=Ho()))zo(t);else if(91===t&&e++,93===t&&e--,0===e){Ro=Fo;break}}function zo(t){const e=t;for(;!Bo()&&(t=Ho())!==e;);}const Ko="__r";let Jo;function qo(t,e,n){const o=Jo;return function r(){const s=e.apply(null,arguments);null!==s&&Zo(t,r,n,o)}}const Wo=zt&&!(X&&Number(X[1])<=53);function Go(t,e,n,o){if(Wo){const t=rn,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Jo.addEventListener(t,e,tt?{capture:n,passive:o}:n)}function Zo(t,e,n,o){(o||Jo).removeEventListener(t,e._wrapper||e,n)}function Xo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Jo=o.elm||t.elm,function(t){if(n(t.__r)){const e=q?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),ee(r,s,Go,Zo,qo,o.context),Jo=void 0}var Yo={create:Xo,update:Xo,destroy:t=>Xo(t,Qn)};let Qo;function tr(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);er(i,t)&&(i.value=t)}else if("innerHTML"===r&&zn(i.tagName)&&e(i.innerHTML)){Qo=Qo||document.createElement("div"),Qo.innerHTML=`<svg>${s}</svg>`;const t=Qo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function er(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var nr={create:tr,update:tr};const or=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function rr(t){const e=sr(t.style);return t.staticStyle?A(t.staticStyle,e):e}function sr(t){return Array.isArray(t)?O(t):"string"==typeof t?or(t):t}const ir=/^--/,ar=/\s*!important$/,cr=(t,e,n)=>{if(ir.test(e))t.style.setProperty(e,n);else if(ar.test(n))t.style.setProperty(C(e),n.replace(ar,""),"important");else{const o=fr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},lr=["Webkit","Moz","ms"];let ur;const fr=v((function(t){if(ur=ur||document.createElement("div").style,"filter"!==(t=_(t))&&t in ur)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<lr.length;t++){const n=lr[t]+e;if(n in ur)return n}}));function dr(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=sr(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=rr(e.data))&&A(n,o)}(o=rr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=rr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&cr(c,a,"");for(a in p)i=p[a],i!==f[a]&&cr(c,a,null==i?"":i)}var pr={create:dr,update:dr};const hr=/\s+/;function mr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(hr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function yr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(hr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function gr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,vr(t.name||"v")),A(e,t),e}return"string"==typeof t?vr(t):void 0}}const vr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),$r=V&&!W,_r="transition",br="animation";let wr="transition",Cr="transitionend",xr="animation",kr="animationend";$r&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(wr="WebkitTransition",Cr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(xr="WebkitAnimation",kr="webkitAnimationEnd"));const Ar=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Or(t){Ar((()=>{Ar(t)}))}function Sr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),mr(t,e))}function Tr(t,e){t._transitionClasses&&m(t._transitionClasses,e),yr(t,e)}function Nr(t,e,n){const{type:o,timeout:r,propCount:s}=jr(t,e);if(!o)return n();const i=o===_r?Cr:kr;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Er=/\b(transform|all)(,|$)/;function jr(t,e){const n=window.getComputedStyle(t),o=(n[wr+"Delay"]||"").split(", "),r=(n[wr+"Duration"]||"").split(", "),s=Dr(o,r),i=(n[xr+"Delay"]||"").split(", "),a=(n[xr+"Duration"]||"").split(", "),c=Dr(i,a);let l,u=0,f=0;e===_r?s>0&&(l=_r,u=s,f=r.length):e===br?c>0&&(l=br,u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?_r:br:null,f=l?l===_r?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:l===_r&&Er.test(n[wr+"Property"])}}function Dr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Ir(e)+Ir(t[n]))))}function Ir(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Mr(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=gr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Je,A=Je.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,j=O&&"function"==typeof b?b:g,I=O&&w||v,M=O&&C||$,L=f(s(x)?x.enter:x),F=!1!==a&&!W,P=Pr(j),R=r._enterCb=D((()=>{F&&(Tr(r,N),Tr(r,T)),R.cancelled?(F&&Tr(r,S),M&&M(r)):I&&I(r),r._enterCb=null}));t.data.show||ne(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),E&&E(r),F&&(Sr(r,S),Sr(r,T),Or((()=>{Tr(r,S),R.cancelled||(Sr(r,N),P||(Fr(L)?setTimeout(R,L):Nr(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function Lr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=gr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!W,_=Pr(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(Tr(r,u),Tr(r,d)),w.cancelled?($&&Tr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(Sr(r,l),Sr(r,d),Or((()=>{Tr(r,l),w.cancelled||(Sr(r,u),_||(Fr(b)?setTimeout(w,b):Nr(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Fr(t){return"number"==typeof t&&!isNaN(t)}function Pr(t){if(e(t))return!1;const o=t.fns;return n(o)?Pr(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Rr(t,e){!0!==e.data.show&&Mr(e)}const Hr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<to.length;++s)for(a[to[s]]=[],i=0;i<c.length;++i)n(c[i][to[s]])&&a[to[s]].push(c[i][to[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=mt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Qn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Yn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Qn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Qn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Je)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&eo(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=mt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:eo(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):eo(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):eo(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):eo(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=no(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],eo(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Xt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&eo(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute(I)&&(t.removeAttribute(I),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new dt(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Qn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Yn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:Zn,modules:[ho,yo,Yo,nr,pr,V?{create:Rr,activate:Rr,remove(t,e){!0!==t.data.show?Lr(t,e):e()}}:{}].concat(lo)});W&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Wr(t,"input")}));const Br={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ne(n,"postpatch",(()=>{Br.componentUpdated(t,e,n)})):Ur(t,e,n.context),t._vOptions=[].map.call(t.options,Kr)):("textarea"===n.tag||Wn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Jr),t.addEventListener("compositionend",qr),t.addEventListener("change",qr),W&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Ur(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Kr);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>zr(t,r))):e.value!==e.oldValue&&zr(e.value,r))&&Wr(t,"change")}}}};function Ur(t,e,n){Vr(t,e),(q||G)&&setTimeout((()=>{Vr(t,e)}),0)}function Vr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Kr(i))>-1,i.selected!==s&&(i.selected=s);else if(E(Kr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function zr(t,e){return e.every((e=>!E(e,t)))}function Kr(t){return"_value"in t?t._value:t.value}function Jr(t){t.target.composing=!0}function qr(t){t.target.composing&&(t.target.composing=!1,Wr(t.target,"input"))}function Wr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Gr(t){return!t.componentInstance||t.data&&t.data.transition?t:Gr(t.componentInstance._vnode)}var Zr={bind(t,{value:e},n){const o=(n=Gr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Mr(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Gr(o)).data&&o.data.transition?(o.data.show=!0,e?Mr(o,(()=>{t.style.display=t.__vOriginalDisplay})):Lr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},Xr={model:Br,show:Zr};const Yr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Qr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Qr(Be(e.children)):t}function ts(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function es(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const ns=t=>t.tag||ue(t),os=t=>"show"===t.name;var rs={name:"transition",props:Yr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(ns),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Qr(o);if(!s)return o;if(this._leaving)return es(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=ts(this),c=this._vnode,l=Qr(c);if(s.data.directives&&s.data.directives.some(os)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ne(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),es(t,o);if("in-out"===n){if(ue(s))return c;let t;const n=()=>{t()};ne(a,"afterEnter",n),ne(a,"enterCancelled",n),ne(e,"delayLeave",(e=>{t=e}))}}return o}};const ss=A({tag:String,moveClass:String},Yr);function is(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function as(t){t.data.newPos=t.elm.getBoundingClientRect()}function cs(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete ss.mode;var ls={Transition:rs,TransitionGroup:{props:ss,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=qe(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=ts(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(is),t.forEach(as),t.forEach(cs),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Sr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(Cr,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(Cr,t),n._moveCb=null,Tr(n,e))})}})))},methods:{hasMove(t,e){if(!$r)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{yr(n,t)})),mr(n,e),n.style.display="none",this.$el.appendChild(n);const o=jr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};_n.config.mustUseProp=Nn,_n.config.isReservedTag=Kn,_n.config.isReservedAttr=Sn,_n.config.getTagNamespace=Jn,_n.config.isUnknownElement=function(t){if(!V)return!0;if(Kn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];const e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},A(_n.options.directives,Xr),A(_n.options.components,ls),_n.prototype.__patch__=V?Hr:S,_n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=pt),Xe(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new ln(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Xe(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Xe(t,"mounted")),t}(this,t=t&&V?Gn(t):void 0,e)},V&&setTimeout((()=>{F.devtools&&nt&&nt.emit("init",_n)}),0);const us=/\{\{((?:.|\r?\n)+?)\}\}/g,fs=/[-.*+?^${}()|[\]\/\\]/g,ds=v((t=>{const e=t[0].replace(fs,"\\$&"),n=t[1].replace(fs,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ps={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=To(t,"class");n&&(t.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const o=So(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var hs={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=To(t,"style");n&&(t.staticStyle=JSON.stringify(or(n)));const o=So(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let ms;var ys={decode:t=>(ms=ms||document.createElement("div"),ms.innerHTML=t,ms.textContent)};const gs=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),vs=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),$s=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),_s=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,bs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ws=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${P.source}]*`,Cs=`((?:${ws}\\:)?${ws})`,xs=new RegExp(`^<${Cs}`),ks=/^\s*(\/?)>/,As=new RegExp(`^<\\/${Cs}[^>]*>`),Os=/^<!DOCTYPE [^>]+>/i,Ss=/^<!\--/,Ts=/^<!\[/,Ns=d("script,style,textarea",!0),Es={},js={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ds=/&(?:lt|gt|quot|amp|#39);/g,Is=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ms=d("pre,textarea",!0),Ls=(t,e)=>t&&Ms(t)&&"\n"===e[0];function Fs(t,e){const n=e?Is:Ds;return t.replace(n,(t=>js[t]))}const Ps=/^@|^v-on:/,Rs=/^v-|^@|^:|^#/,Hs=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Bs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Us=/^\(|\)$/g,Vs=/^\[.*\]$/,zs=/:(.*)$/,Ks=/^:|^\.|^v-bind:/,Js=/\.[^.\]]+(?=[^\]]*$)/g,qs=/^v-slot(:|$)|^#/,Ws=/[\r\n]/,Gs=/[ \f\t\r\n]+/g,Zs=v(ys.decode),Xs="_empty_";let Ys,Qs,ti,ei,ni,oi,ri,si;function ii(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:pi(e),rawAttrsMap:{},parent:n,children:[]}}function ai(t,e){Ys=e.warn||_o,oi=e.isPreTag||T,ri=e.mustUseProp||T,si=e.getTagNamespace||T,e.isReservedTag,ti=bo(e.modules,"transformNode"),ei=bo(e.modules,"preTransformNode"),ni=bo(e.modules,"postTransformNode"),Qs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=ci(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&ui(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&ui(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),oi(t.tag)&&(c=!1);for(let n=0;n<ni.length;n++)ni[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&Ns(a)){let n=0;const o=a.toLowerCase(),r=Es[o]||(Es[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,Ns(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ls(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(Ss.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(Ts.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Os);if(n){l(n[0].length);continue}const o=t.match(As);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),Ls(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(As.test(o)||xs.test(o)||Ss.test(o)||Ts.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(xs);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(ks))&&(r=t.match(bs)||t.match(_s));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&$s(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Fs(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:Ys,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||si(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];hi.test(o.name)||(o.name=o.name.replace(mi,""),e.push(o))}return e}(o));let p=ii(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||et()||(p.forbidden=!0);for(let t=0;t<ei.length;t++)p=ei[t](p,e)||p;a||(!function(t){null!=To(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),oi(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(li(p),function(t){const e=To(t,"v-if");if(e)t.if=e,ui(t,{exp:e,block:t});else{null!=To(t,"v-else")&&(t.else=!0);const e=To(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=To(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(q&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Zs(t):s.length?r?"condense"===r&&Ws.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Gs," ")),!a&&" "!==t&&(e=function(t,e){const n=e?ds(e):us;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=vo(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Qs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function ci(t,e){var n;!function(t){const e=So(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=So(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=To(t,"scope"),t.slotScope=e||To(t,"slot-scope")):(e=To(t,"slot-scope"))&&(t.slotScope=e);const n=So(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||Co(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=No(t,qs);if(e){const{name:n,dynamic:o}=fi(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||Xs}}else{const e=No(t,qs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=fi(e),s=n[o]=ii("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||Xs,t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=So(n,"name")),function(t){let e;(e=So(t,"is"))&&(t.component=e);null!=To(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<ti.length;n++)t=ti[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Rs.test(r))if(t.hasBindings=!0,a=di(r.replace(Rs,"")),a&&(r=r.replace(Js,"")),Ks.test(r))r=r.replace(Ks,""),i=vo(i),l=Vs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=Do(i,"$event"),l?Oo(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Oo(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Oo(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&ri(t.tag,t.attrsMap.type,r)?wo(t,r,i,e[n],l):Co(t,r,i,e[n],l);else if(Ps.test(r))r=r.replace(Ps,""),l=Vs.test(r),l&&(r=r.slice(1,-1)),Oo(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Rs,"");const o=r.match(zs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Vs.test(c)&&(c=c.slice(1,-1),l=!0)),ko(t,r,s,i,c,l,a,e[n])}else Co(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&ri(t.tag,t.attrsMap.type,r)&&wo(t,r,"true",e[n])}(t),t}function li(t){let e;if(e=To(t,"v-for")){const n=function(t){const e=t.match(Hs);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Us,""),r=o.match(Bs);r?(n.alias=o.replace(Bs,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function ui(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function fi(t){let e=t.name.replace(qs,"");return e||"#"!==t.name[0]&&(e="default"),Vs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function di(t){const e=t.match(Js);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function pi(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const hi=/^xmlns:NS\d+/,mi=/^NS\d+:/;function yi(t){return ii(t.tag,t.attrsList.slice(),t.parent)}var gi=[ps,hs,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=So(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=To(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=To(t,"v-else",!0),i=To(t,"v-else-if",!0),a=yi(t);li(a),xo(a,"type","checkbox"),ci(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,ui(a,{exp:a.if,block:a});const c=yi(t);To(c,"v-for",!0),xo(c,"type","radio"),ci(c,e),ui(a,{exp:`(${o})==='radio'`+r,block:c});const l=yi(t);return To(l,"v-for",!0),xo(l,":type",o),ci(l,e),ui(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const vi={expectHTML:!0,modules:gi,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return jo(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${Do(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Oo(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=So(t,"value")||"null",s=So(t,"true-value")||"true",i=So(t,"false-value")||"false";wo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Oo(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${Do(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${Do(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${Do(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=So(t,"value")||"null";r=o?`_n(${r})`:r,wo(t,"checked",`_q(${e},${r})`),Oo(t,"change",Do(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?Ko:"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=Do(e,l);a&&(u=`if($event.target.composing)return;${u}`);wo(t,"value",`(${e})`),Oo(t,c,u,null,!0),(i||s)&&Oo(t,"blur","$forceUpdate()")}(t,o,r);else if(!F.isReservedTag(s))return jo(t,o,r),!1;return!0},text:function(t,e){e.value&&wo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&wo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:gs,mustUseProp:Nn,canBeLeftOpenTag:vs,isReservedTag:Kn,getTagNamespace:Jn,staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(gi)};let $i,_i;const bi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function wi(t,e){t&&($i=bi(e.staticKeys||""),_i=e.isReservedTag||T,Ci(t),xi(t,!1))}function Ci(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!_i(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every($i)))}(t),1===t.type){if(!_i(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];Ci(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;Ci(n),n.static||(t.static=!1)}}}function xi(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)xi(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)xi(t.ifConditions[n].block,e)}}const ki=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ai=/\([^)]*?\);*$/,Oi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Si={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ti={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ni=t=>`if(${t})return null;`,Ei={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ni("$event.target !== $event.currentTarget"),ctrl:Ni("!$event.ctrlKey"),shift:Ni("!$event.shiftKey"),alt:Ni("!$event.altKey"),meta:Ni("!$event.metaKey"),left:Ni("'button' in $event && $event.button !== 0"),middle:Ni("'button' in $event && $event.button !== 1"),right:Ni("'button' in $event && $event.button !== 2")};function ji(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Di(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Di(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Di(t))).join(",")}]`;const e=Oi.test(t.value),n=ki.test(t.value),o=Oi.test(t.value.replace(Ai,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ei[e])s+=Ei[e],Si[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=Ni(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Ii).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ii(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Si[t],o=Ti[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Mi={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Li{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(t){this.options=t,this.warn=t.warn||_o,this.transforms=bo(t.modules,"transformCode"),this.dataGenFns=bo(t.modules,"genData"),this.directives=A(A({},Mi),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function Fi(t,e){const n=new Li(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Pi(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Pi(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ri(t,e);if(t.once&&!t.onceProcessed)return Hi(t,e);if(t.for&&!t.forProcessed)return Vi(t,e);if(t.if&&!t.ifProcessed)return Bi(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=qi(t,e);let r=`_t(${n}${o?`,function(){return ${o}}`:""}`;const s=t.attrs||t.dynamicAttrs?Zi((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:qi(e,n,!0);return`_c(${t},${zi(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=zi(t,e));const r=t.inlineTemplate?null:qi(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return qi(t,e)||"void 0"}function Ri(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Pi(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Hi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Bi(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Pi(t,e)},${e.onceId++},${n})`:Pi(t,e)}return Ri(t,e)}function Bi(t,e,n,o){return t.ifProcessed=!0,Ui(t.ifConditions.slice(),e,n,o)}function Ui(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Ui(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Hi(t,e):Pi(t,e)}}function Vi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Pi)(t,e)}})`}function zi(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Zi(t.attrs)},`),t.props&&(n+=`domProps:${Zi(t.props)},`),t.events&&(n+=`${ji(t.events,!1)},`),t.nativeEvents&&(n+=`${ji(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Ki(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&e.slotScope!==Xs||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Ji(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=Fi(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Zi(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Ki(t){return 1===t.type&&("slot"===t.tag||t.children.some(Ki))}function Ji(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Bi(t,e,Ji,"null");if(t.for&&!t.forProcessed)return Vi(t,e,Ji);const o=t.slotScope===Xs?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${qi(t,e)||"undefined"}:undefined`:qi(t,e)||"undefined":Pi(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function qi(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Pi)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(Wi(r)||r.ifConditions&&r.ifConditions.some((t=>Wi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Gi;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function Wi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Gi(t,e){return 1===t.type?Pi(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Xi(JSON.stringify(t.text))})`}(t)}function Zi(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Xi(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Xi(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Yi(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function Qi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=Yi(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>Yi(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const ta=(ea=function(t,e){const n=ai(t.trim(),e);!1!==e.optimize&&wi(n,e);const o=Fi(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=ea(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:Qi(e)}});var ea;const{compile:na,compileToFunctions:oa}=ta(vi);let ra;function sa(t){return ra=ra||document.createElement("div"),ra.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',ra.innerHTML.indexOf("&#10;")>0}const ia=!!V&&sa(!1),aa=!!V&&sa(!0),ca=v((t=>{const e=Gn(t);return e&&e.innerHTML})),la=_n.prototype.$mount;return _n.prototype.$mount=function(t,e){if((t=t&&Gn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=ca(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=oa(e,{outputSourceRange:!1,shouldDecodeNewlines:ia,shouldDecodeNewlinesForHref:aa,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return la.call(this,t,e)},_n.compile=oa,_n}));
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index 40c045b5791..a203036f2bf 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 'use strict';
 
-var emptyObject = Object.freeze({});
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 function isUndef(v) {
@@ -32,7 +32,7 @@ function isPrimitive(value) {
 }
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
 function isObject(obj) {
@@ -41,7 +41,7 @@ function isObject(obj) {
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
+const _toString = Object.prototype.toString;
 function toRawType(value) {
     return _toString.call(value).slice(8, -1);
 }
@@ -59,7 +59,7 @@ function isRegExp(v) {
  * Check if val is a valid array index.
  */
 function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
+    const n = parseFloat(String(val));
     return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
 function isPromise(val) {
@@ -82,7 +82,7 @@ function toString(val) {
  * If the conversion fails, return original string.
  */
 function toNumber(val) {
-    var n = parseFloat(val);
+    const n = parseFloat(val);
     return isNaN(n) ? val : n;
 }
 /**
@@ -90,27 +90,27 @@ function toNumber(val) {
  * is in that map.
  */
 function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
         map[list[i]] = true;
     }
-    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
 function remove$2(arr, item) {
     if (arr.length) {
-        var index = arr.indexOf(item);
+        const index = arr.indexOf(item);
         if (index > -1) {
             return arr.splice(index, 1);
         }
@@ -119,7 +119,7 @@ function remove$2(arr, item) {
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
 }
@@ -127,30 +127,30 @@ function hasOwn(obj, key) {
  * Create a cached version of a pure function.
  */
 function cached(fn) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function cachedFn(str) {
-        var hit = cache[str];
+        const hit = cache[str];
         return hit || (cache[str] = fn(str));
     };
 }
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
 /**
  * Capitalize a string.
  */
-var capitalize = cached(function (str) {
+const capitalize = cached((str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
 /**
@@ -163,7 +163,7 @@ var hyphenate = cached(function (str) {
 /* istanbul ignore next */
 function polyfillBind(fn, ctx) {
     function boundFn(a) {
-        var l = arguments.length;
+        const l = arguments.length;
         return l
             ? l > 1
                 ? fn.apply(ctx, arguments)
@@ -177,14 +177,14 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
+const bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
 function toArray(list, start) {
     start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
+    let i = list.length - start;
+    const ret = new Array(i);
     while (i--) {
         ret[i] = list[i + start];
     }
@@ -194,7 +194,7 @@ function toArray(list, start) {
  * Mix properties into target object.
  */
 function extend(to, _from) {
-    for (var key in _from) {
+    for (const key in _from) {
         to[key] = _from[key];
     }
     return to;
@@ -203,8 +203,8 @@ function extend(to, _from) {
  * Merge an Array of Objects into a single Object.
  */
 function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
         if (arr[i]) {
             extend(res, arr[i]);
         }
@@ -221,28 +221,28 @@ function noop(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
+const identity = (_) => _;
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
 function looseEqual(a, b) {
     if (a === b)
-        { return true; }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
     if (isObjectA && isObjectB) {
         try {
-            var isArrayA = Array.isArray(a);
-            var isArrayB = Array.isArray(b);
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
             if (isArrayA && isArrayB) {
                 return (a.length === b.length &&
-                    a.every(function (e, i) {
+                    a.every((e, i) => {
                         return looseEqual(e, b[i]);
                     }));
             }
@@ -250,10 +250,10 @@ function looseEqual(a, b) {
                 return a.getTime() === b.getTime();
             }
             else if (!isArrayA && !isArrayB) {
-                var keysA = Object.keys(a);
-                var keysB = Object.keys(b);
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
                 return (keysA.length === keysB.length &&
-                    keysA.every(function (key) {
+                    keysA.every((key) => {
                         return looseEqual(a[key], b[key]);
                     }));
             }
@@ -280,9 +280,9 @@ function looseEqual(a, b) {
  * contain an object of the same shape), or -1 if it is not present.
  */
 function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
+    for (let i = 0; i < arr.length; i++) {
         if (looseEqual(arr[i], val))
-            { return i; }
+            return i;
     }
     return -1;
 }
@@ -290,7 +290,7 @@ function looseIndexOf(arr, val) {
  * Ensure a function is called only once.
  */
 function once(fn) {
-    var called = false;
+    let called = false;
     return function () {
         if (!called) {
             called = true;
@@ -299,9 +299,9 @@ function once(fn) {
     };
 }
 
-var SSR_ATTR = 'data-server-rendered';
-var ASSET_TYPES = ['component', 'directive', 'filter'];
-var LIFECYCLE_HOOKS = [
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
     'beforeCreate',
     'created',
     'beforeMount',
@@ -313,7 +313,8 @@ var LIFECYCLE_HOOKS = [
     'activated',
     'deactivated',
     'errorCaptured',
-    'serverPrefetch' ];
+    'serverPrefetch',
+];
 
 var config = {
     /**
@@ -398,12 +399,12 @@ var config = {
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Check if a string starts with $ or _
  */
 function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
+    const c = (str + '').charCodeAt(0);
     return c === 0x24 || c === 0x5f;
 }
 /**
@@ -420,16 +421,16 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
     }
-    var segments = path.split('.');
+    const segments = path.split('.');
     return function (obj) {
-        for (var i = 0; i < segments.length; i++) {
+        for (let i = 0; i < segments.length; i++) {
             if (!obj)
-                { return; }
+                return;
             obj = obj[segments[i]];
         }
         return obj;
@@ -437,46 +438,41 @@ function parsePath(path) {
 }
 
 // can we use __proto__?
-var hasProto = '__proto__' in {};
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-// @ts-ignore
-var inWeex = 
-// @ts-ignore
-typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-// @ts-ignore
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
 (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 UA && /chrome\/\d+/.test(UA) && !isEdge;
 UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
-var nativeWatch = {}.watch;
-var supportsPassive = false;
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
     try {
-        var opts = {};
+        const opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
-        // @ts-ignore
         window.addEventListener('test-passive', null, opts);
     }
     catch (e) { }
 }
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
+let _isServer;
+const isServerRendering = () => {
     if (_isServer === undefined) {
         /* istanbul ignore if */
         if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -492,104 +488,94 @@ var isServerRendering = function () {
     return _isServer;
 };
 // detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
 }
-var hasSymbol = typeof Symbol !== 'undefined' &&
+const hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
+let _Set; // $flow-disable-line
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
     // use native Set when available.
     _Set = Set;
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-        function Set() {
-            this.set = Object.create(null);
-        }
-        Set.prototype.has = function has (key) {
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
             return this.set[key] === true;
-        };
-        Set.prototype.add = function add (key) {
+        }
+        add(key) {
             this.set[key] = true;
-        };
-        Set.prototype.clear = function clear () {
+        }
+        clear() {
             this.set = Object.create(null);
-        };
-
-        return Set;
-    }());
+        }
+    };
 }
 
-var warn = noop;
-var tip = noop;
-var generateComponentTrace; // work around flow check
-var formatComponentName;
+let warn = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn = function (msg, vm) {
-        var trace = vm ? generateComponentTrace(vm) : '';
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
         else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+            console.error(`[Vue warn]: ${msg}${trace}`);
         }
     };
-    tip = function (msg, vm) {
+    tip = (msg, vm) => {
         if (hasConsole && !config.silent) {
-            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
         }
     };
-    formatComponentName = function (vm, includeFile) {
+    formatComponentName = (vm, includeFile) => {
         if (vm.$root === vm) {
             return '<Root>';
         }
-        var options = 
-        // @ts-ignore
-        typeof vm === 'function' && vm.cid != null
-            ? // @ts-ignore
-                vm.options
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
             : vm._isVue
-                ? // @ts-ignore
-                    vm.$options || vm.constructor.options
+                ? vm.$options || vm.constructor.options
                 : vm;
-        var name = options.name || options._componentTag;
-        var file = options.__file;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
         if (!name && file) {
-            var match = file.match(/([^/\\]+)\.vue$/);
+            const match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
     };
-    var repeat = function (str, n) {
-        var res = '';
+    const repeat = (str, n) => {
+        let res = '';
         while (n) {
             if (n % 2 === 1)
-                { res += str; }
+                res += str;
             if (n > 1)
-                { str += str; }
+                str += str;
             n >>= 1;
         }
         return res;
     };
-    generateComponentTrace = function (vm) {
-        // @ts-ignore
+    generateComponentTrace = (vm) => {
         if (vm._isVue && vm.$parent) {
-            var tree = [];
-            var currentRecursiveSequence = 0;
+            const tree = [];
+            let currentRecursiveSequence = 0;
             while (vm) {
                 if (tree.length > 0) {
-                    var last = tree[tree.length - 1];
+                    const last = tree[tree.length - 1];
                     if (last.constructor === vm.constructor) {
                         currentRecursiveSequence++;
                         vm = vm.$parent;
@@ -605,55 +591,60 @@ var formatComponentName;
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return `\n\n(found in ${formatComponentName(vm)})`;
         }
     };
 }
 
-var uid$2 = 0;
+let uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid$2++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove$2(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (!config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+    addSub(sub) {
+        this.subs.push(sub);
     }
-};
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-var targetStack = [];
+const targetStack = [];
 function pushTarget(target) {
     targetStack.push(target);
     Dep.target = target;
@@ -663,44 +654,66 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
-    var node = new VNode();
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
     node.text = text;
     node.isComment = true;
     return node;
@@ -713,9 +726,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    var cloned = new VNode(
-    //@ts-expect-error void type not valid here
-    vnode.tag, vnode.data, 
+    const cloned = new VNode(vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
@@ -736,29 +747,27 @@ function cloneVNode(vnode) {
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-var methodsToPatch = [
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
     'push',
     'pop',
     'shift',
     'unshift',
     'splice',
     'sort',
-    'reverse' ];
+    'reverse',
+];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
     // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
-
-        var result = original.apply(this, args);
-        var ob = this.__ob__;
-        var inserted;
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
         switch (method) {
             case 'push':
             case 'unshift':
@@ -769,19 +778,19 @@ methodsToPatch.forEach(function (method) {
                 break;
         }
         if (inserted)
-            { ob.observeArray(inserted); }
+            ob.observeArray(inserted);
         // notify change
         ob.dep.notify();
         return result;
     });
 });
 
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-var shouldObserve = true;
+let shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
@@ -791,43 +800,48 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
-    }
-    else {
-        this.walk(value);
     }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive(obj, keys[i]);
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
     }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
     }
-};
+}
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -844,8 +858,8 @@ function protoAugment(target, src) {
  */
 /* istanbul ignore next */
 function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-        var key = keys[i];
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
         def(target, key, src[key]);
     }
 }
@@ -858,7 +872,7 @@ function observe(value, asRootData) {
     if (!isObject(value) || value instanceof VNode) {
         return;
     }
-    var ob;
+    let ob;
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
@@ -878,23 +892,23 @@ function observe(value, asRootData) {
  * Define a reactive property on an Object.
  */
 function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
         return;
     }
     // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
+    const getter = property && property.get;
+    const setter = property && property.set;
     if ((!getter || setter) && arguments.length === 2) {
         val = obj[key];
     }
-    var childOb = !shallow && observe(val);
+    let childOb = !shallow && observe(val);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
         get: function reactiveGetter() {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             if (Dep.target) {
                 dep.depend();
                 if (childOb) {
@@ -907,7 +921,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             return value;
         },
         set: function reactiveSetter(newVal) {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             /* eslint-disable no-self-compare */
             if (newVal === value || (newVal !== newVal && value !== value)) {
                 return;
@@ -918,7 +932,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             }
             // #7981: for accessor properties without setter
             if (getter && !setter)
-                { return; }
+                return;
             if (setter) {
                 setter.call(obj, newVal);
             }
@@ -937,7 +951,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
  */
 function set(target, key, val) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -948,8 +962,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    var ob = target.__ob__;
-    // @ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
@@ -968,14 +981,13 @@ function set(target, key, val) {
  */
 function del(target, key) {
     if ((isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
         return;
     }
-    var ob = target.__ob__;
-    //@ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         warn('Avoid deleting properties on a Vue instance or its root $data ' +
                 '- just set it to null.');
@@ -995,7 +1007,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1009,14 +1021,14 @@ function dependArray(value) {
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
+            warn(`option "${key}" can only be used during instance ` +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1027,16 +1039,16 @@ var strats = config.optionMergeStrategies;
  */
 function mergeData(to, from) {
     if (!from)
-        { return to; }
-    var key, toVal, fromVal;
-    var keys = hasSymbol
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
         ? Reflect.ownKeys(from)
         : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
+    for (let i = 0; i < keys.length; i++) {
         key = keys[i];
         // in case the object is already observed...
         if (key === '__ob__')
-            { continue; }
+            continue;
         toVal = to[key];
         fromVal = from[key];
         if (!hasOwn(to, key)) {
@@ -1068,18 +1080,14 @@ function mergeDataOrFn(parentVal, childVal, vm) {
         // check if parentVal is a function here because
         // it has to be a function to pass previous merges.
         return function mergedDataFn() {
-            return mergeData(
-            // @ts-ignore
-            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-            // @ts-ignore
-            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
         };
     }
     else {
         return function mergedInstanceDataFn() {
             // instance merge
-            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
             if (instanceData) {
                 return mergeData(instanceData, defaultData);
             }
@@ -1105,7 +1113,7 @@ strats.data = function (parentVal, childVal, vm) {
  * Hooks and props are merged as arrays.
  */
 function mergeHook$1(parentVal, childVal) {
-    var res = childVal
+    const res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : Array.isArray(childVal)
@@ -1115,15 +1123,15 @@ function mergeHook$1(parentVal, childVal) {
     return res ? dedupeHooks(res) : res;
 }
 function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
         if (res.indexOf(hooks[i]) === -1) {
             res.push(hooks[i]);
         }
     }
     return res;
 }
-LIFECYCLE_HOOKS.forEach(function (hook) {
+LIFECYCLE_HOOKS.forEach((hook) => {
     strats[hook] = mergeHook$1;
 });
 /**
@@ -1134,7 +1142,7 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * options and parent options.
  */
 function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
+    const res = Object.create(parentVal || null);
     if (childVal) {
         assertObjectType(key, childVal, vm);
         return extend(res, childVal);
@@ -1156,27 +1164,27 @@ strats.watch = function (parentVal, childVal, vm, key) {
     // work around Firefox's Object.prototype.watch...
     //@ts-expect-error work around
     if (parentVal === nativeWatch)
-        { parentVal = undefined; }
+        parentVal = undefined;
     //@ts-expect-error work around
     if (childVal === nativeWatch)
-        { childVal = undefined; }
+        childVal = undefined;
     /* istanbul ignore if */
     if (!childVal)
-        { return Object.create(parentVal || null); }
+        return Object.create(parentVal || null);
     {
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = {};
+        return childVal;
+    const ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
         if (parent && !Array.isArray(parent)) {
             parent = [parent];
         }
-        ret[key$1] = parent
+        ret[key] = parent
             ? parent.concat(child)
             : Array.isArray(child)
                 ? child
@@ -1192,30 +1200,30 @@ strats.props = strats.methods = strats.inject = strats.computed = function (pare
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = Object.create(null);
+        return childVal;
+    const ret = Object.create(null);
     extend(ret, parentVal);
     if (childVal)
-        { extend(ret, childVal); }
+        extend(ret, childVal);
     return ret;
 };
 strats.provide = mergeDataOrFn;
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
+const defaultStrat = function (parentVal, childVal) {
     return childVal === undefined ? parentVal : childVal;
 };
 /**
  * Validate component names
  */
 function checkComponents(options) {
-    for (var key in options.components) {
+    for (const key in options.components) {
         validateComponentName(key);
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
         warn('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1232,11 +1240,11 @@ function validateComponentName(name) {
  * Object-based format.
  */
 function normalizeProps(options, vm) {
-    var props = options.props;
+    const props = options.props;
     if (!props)
-        { return; }
-    var res = {};
-    var i, val, name;
+        return;
+    const res = {};
+    let i, val, name;
     if (Array.isArray(props)) {
         i = props.length;
         while (i--) {
@@ -1251,15 +1259,15 @@ function normalizeProps(options, vm) {
         }
     }
     else if (isPlainObject(props)) {
-        for (var key in props) {
+        for (const key in props) {
             val = props[key];
             name = camelize(key);
             res[name] = isPlainObject(val) ? val : { type: val };
         }
     }
     else {
-        warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
     }
     options.props = res;
 }
@@ -1267,36 +1275,36 @@ function normalizeProps(options, vm) {
  * Normalize all injections into Object-based format
  */
 function normalizeInject(options, vm) {
-    var inject = options.inject;
+    const inject = options.inject;
     if (!inject)
-        { return; }
-    var normalized = (options.inject = {});
+        return;
+    const normalized = (options.inject = {});
     if (Array.isArray(inject)) {
-        for (var i = 0; i < inject.length; i++) {
+        for (let i = 0; i < inject.length; i++) {
             normalized[inject[i]] = { from: inject[i] };
         }
     }
     else if (isPlainObject(inject)) {
-        for (var key in inject) {
-            var val = inject[key];
+        for (const key in inject) {
+            const val = inject[key];
             normalized[key] = isPlainObject(val)
                 ? extend({ from: key }, val)
                 : { from: val };
         }
     }
     else {
-        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
 function normalizeDirectives$1(options) {
-    var dirs = options.directives;
+    const dirs = options.directives;
     if (dirs) {
-        for (var key in dirs) {
-            var def = dirs[key];
+        for (const key in dirs) {
+            const def = dirs[key];
             if (typeof def === 'function') {
                 dirs[key] = { bind: def, update: def };
             }
@@ -1305,8 +1313,8 @@ function normalizeDirectives$1(options) {
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
     }
 }
 /**
@@ -1333,13 +1341,13 @@ function mergeOptions(parent, child, vm) {
             parent = mergeOptions(parent, child.extends, vm);
         }
         if (child.mixins) {
-            for (var i = 0, l = child.mixins.length; i < l; i++) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
                 parent = mergeOptions(parent, child.mixins[i], vm);
             }
         }
     }
-    var options = {};
-    var key;
+    const options = {};
+    let key;
     for (key in parent) {
         mergeField(key);
     }
@@ -1349,7 +1357,7 @@ function mergeOptions(parent, child, vm) {
         }
     }
     function mergeField(key) {
-        var strat = strats[key] || defaultStrat;
+        const strat = strats[key] || defaultStrat;
         options[key] = strat(parent[key], child[key], vm, key);
     }
     return options;
@@ -1364,18 +1372,18 @@ function resolveAsset(options, type, id, warnMissing) {
     if (typeof id !== 'string') {
         return;
     }
-    var assets = options[type];
+    const assets = options[type];
     // check local registration variations first
     if (hasOwn(assets, id))
-        { return assets[id]; }
-    var camelizedId = camelize(id);
+        return assets[id];
+    const camelizedId = camelize(id);
     if (hasOwn(assets, camelizedId))
-        { return assets[camelizedId]; }
-    var PascalCaseId = capitalize(camelizedId);
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
     if (hasOwn(assets, PascalCaseId))
-        { return assets[PascalCaseId]; }
+        return assets[PascalCaseId];
     // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (warnMissing && !res) {
         warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
@@ -1383,11 +1391,11 @@ function resolveAsset(options, type, id, warnMissing) {
 }
 
 function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
     // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
     if (booleanIndex > -1) {
         if (absent && !hasOwn(prop, 'default')) {
             value = false;
@@ -1395,7 +1403,7 @@ function validateProp(key, propOptions, propsData, vm) {
         else if (value === '' || value === hyphenate(key)) {
             // only cast empty string / same name to boolean if
             // boolean has higher priority
-            var stringIndex = getTypeIndex(String, prop.type);
+            const stringIndex = getTypeIndex(String, prop.type);
             if (stringIndex < 0 || booleanIndex < stringIndex) {
                 value = true;
             }
@@ -1406,7 +1414,7 @@ function validateProp(key, propOptions, propsData, vm) {
         value = getPropDefaultValue(vm, prop, key);
         // since the default value is a fresh copy,
         // make sure to observe it.
-        var prevShouldObserve = shouldObserve;
+        const prevShouldObserve = shouldObserve;
         toggleObserving(true);
         observe(value);
         toggleObserving(prevShouldObserve);
@@ -1424,7 +1432,7 @@ function getPropDefaultValue(vm, prop, key) {
     if (!hasOwn(prop, 'default')) {
         return undefined;
     }
-    var def = prop.default;
+    const def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (isObject(def)) {
         warn('Invalid default value for prop "' +
@@ -1458,38 +1466,37 @@ function assertProp(prop, name, value, vm, absent) {
     if (value == null && !prop.required) {
         return;
     }
-    var type = prop.type;
-    // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
     if (type) {
         if (!Array.isArray(type)) {
             type = [type];
         }
-        for (var i = 0; i < type.length && !valid; i++) {
-            var assertedType = assertType(value, type[i], vm);
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
             expectedTypes.push(assertedType.expectedType || '');
             valid = assertedType.valid;
         }
     }
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    const haveExpectedTypes = expectedTypes.some((t) => t);
     if (!valid && haveExpectedTypes) {
         warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
-    var validator = prop.validator;
+    const validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
             warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
 function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
+    let valid;
+    const expectedType = getType(type);
     if (simpleCheckRE.test(expectedType)) {
-        var t = typeof value;
+        const t = typeof value;
         valid = t === expectedType.toLowerCase();
         // for primitive wrapper objects
         if (!valid && t === 'object') {
@@ -1512,18 +1519,18 @@ function assertType(value, type, vm) {
         }
     }
     return {
-        valid: valid,
-        expectedType: expectedType,
+        valid,
+        expectedType,
     };
 }
-var functionTypeCheckRE = /^\s*function (\w+)/;
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
 function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
+    const match = fn && fn.toString().match(functionTypeCheckRE);
     return match ? match[1] : '';
 }
 function isSameType(a, b) {
@@ -1533,7 +1540,7 @@ function getTypeIndex(type, expectedTypes) {
     if (!Array.isArray(expectedTypes)) {
         return isSameType(expectedTypes, type) ? 0 : -1;
     }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
         if (isSameType(expectedTypes[i], type)) {
             return i;
         }
@@ -1541,44 +1548,41 @@ function getTypeIndex(type, expectedTypes) {
     return -1;
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
     // check if we need to specify expected value
     if (expectedTypes.length === 1 &&
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += ` with value ${styleValue(value, expectedType)}`;
     }
-    message += ", got " + receivedType + " ";
+    message += `, got ${receivedType} `;
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += `with value ${styleValue(value, receivedType)}.`;
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return `"${value}"`;
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return `${Number(value)}`;
     }
     else {
-        return ("" + value);
+        return `${value}`;
     }
 }
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
 function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
 }
-function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
 function handleError(err, vm, info) {
@@ -1587,15 +1591,15 @@ function handleError(err, vm, info) {
     pushTarget();
     try {
         if (vm) {
-            var cur = vm;
+            let cur = vm;
             while ((cur = cur.$parent)) {
-                var hooks = cur.$options.errorCaptured;
+                const hooks = cur.$options.errorCaptured;
                 if (hooks) {
-                    for (var i = 0; i < hooks.length; i++) {
+                    for (let i = 0; i < hooks.length; i++) {
                         try {
-                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
                             if (capture)
-                                { return; }
+                                return;
                         }
                         catch (e) {
                             globalHandleError(e, cur, 'errorCaptured hook');
@@ -1611,17 +1615,18 @@ function handleError(err, vm, info) {
     }
 }
 function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
+    let res;
     try {
         res = args ? handler.apply(context, args) : handler.call(context);
         if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
             // issue #9511
             // avoid catch triggering multiple times when nested calls
             res._handled = true;
         }
     }
     catch (e) {
+        // @ts-expect-error should it be any?
         handleError(e, vm, info);
     }
     return res;
@@ -1643,7 +1648,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn(`Error in ${info}: "${err.toString()}"`, vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1655,14 +1660,14 @@ function logError(err, vm, info) {
 }
 
 /* globals MutationObserver */
-var isUsingMicroTask = false;
-var callbacks = [];
-var pending = false;
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
 function flushCallbacks() {
     pending = false;
-    var copies = callbacks.slice(0);
+    const copies = callbacks.slice(0);
     callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
+    for (let i = 0; i < copies.length; i++) {
         copies[i]();
     }
 }
@@ -1677,7 +1682,7 @@ function flushCallbacks() {
 // where microtasks have too high a priority and fire in between supposedly
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
-var timerFunc;
+let timerFunc;
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1686,8 +1691,8 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
+    const p = Promise.resolve();
+    timerFunc = () => {
         p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
@@ -1695,7 +1700,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
         // needs to do some other work, e.g. handle a timer. Therefore we can
         // "force" the microtask queue to be flushed by adding an empty timer.
         if (isIOS)
-            { setTimeout(noop); }
+            setTimeout(noop);
     };
     isUsingMicroTask = true;
 }
@@ -1707,13 +1712,13 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
     observer.observe(textNode, {
         characterData: true,
     });
-    timerFunc = function () {
+    timerFunc = () => {
         counter = (counter + 1) % 2;
         textNode.data = String(counter);
     };
@@ -1723,24 +1728,25 @@ else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
     // Fallback to setImmediate.
     // Technically it leverages the (macro) task queue,
     // but it is still a better choice than setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setImmediate(flushCallbacks);
     };
 }
 else {
     // Fallback to setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setTimeout(flushCallbacks, 0);
     };
 }
 function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
+    let _resolve;
+    callbacks.push(() => {
         if (cb) {
             try {
                 cb.call(ctx);
             }
             catch (e) {
+                // @ts-expect-error should it be any?
                 handleError(e, ctx, 'nextTick');
             }
         }
@@ -1754,40 +1760,40 @@ function nextTick(cb, ctx) {
     }
     // $flow-disable-line
     if (!cb && typeof Promise !== 'undefined') {
-        return new Promise(function (resolve) {
+        return new Promise((resolve) => {
             _resolve = resolve;
         });
     }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-var initProxy;
+let initProxy;
 {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
-        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+    const warnNonPresent = (target, key) => {
+        warn(`Property or method "${key}" is not defined on the instance but ` +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
-        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    const warnReservedPrefix = (target, key) => {
+        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
+            set(target, key, value) {
                 if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                     return false;
                 }
                 else {
@@ -1797,29 +1803,29 @@ var initProxy;
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
-            var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    const getHandler = {
+        get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return target[key];
         },
@@ -1827,8 +1833,8 @@ var initProxy;
     initProxy = function initProxy(vm) {
         if (hasProxy) {
             // determine which proxy handler to use
-            var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1837,7 +1843,7 @@ var initProxy;
     };
 }
 
-var seenObjects = new _Set();
+const seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
@@ -1848,15 +1854,15 @@ function traverse(val) {
     seenObjects.clear();
 }
 function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
+    let i, keys;
+    const isA = Array.isArray(val);
     if ((!isA && !isObject(val)) ||
         Object.isFrozen(val) ||
         val instanceof VNode) {
         return;
     }
     if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
+        const depId = val.__ob__.dep.id;
         if (seen.has(depId)) {
             return;
         }
@@ -1865,28 +1871,28 @@ function _traverse(val, seen) {
     if (isA) {
         i = val.length;
         while (i--)
-            { _traverse(val[i], seen); }
+            _traverse(val[i], seen);
     }
     else {
         keys = Object.keys(val);
         i = keys.length;
         while (i--)
-            { _traverse(val[keys[i]], seen); }
+            _traverse(val[keys[i]], seen);
     }
 }
 
-var mark;
-var measure;
+let mark;
+let measure;
 {
-    var perf = inBrowser && window.performance;
+    const perf = inBrowser && window.performance;
     /* istanbul ignore if */
     if (perf &&
         perf.mark &&
         perf.measure &&
         perf.clearMarks &&
         perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
-        measure = function (name, startTag, endTag) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
             perf.measure(name, startTag, endTag);
             perf.clearMarks(startTag);
             perf.clearMarks(endTag);
@@ -1895,47 +1901,45 @@ var measure;
     }
 }
 
-var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
     name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
+    const capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
-        name: name,
-        once: once,
-        capture: capture,
-        passive: passive,
+        name,
+        once,
+        capture,
+        passive,
     };
 });
 function createFnInvoker(fns, vm) {
     function invoker() {
-        var arguments$1 = arguments;
-
-        var fns = invoker.fns;
+        const fns = invoker.fns;
         if (Array.isArray(fns)) {
-            var cloned = fns.slice();
-            for (var i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
             }
         }
         else {
             // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
         }
     }
     invoker.fns = fns;
     return invoker;
 }
 function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, cur, old, event;
+    let name, cur, old, event;
     for (name in on) {
         cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
-            warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+            warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1963,8 +1967,8 @@ function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
     }
-    var invoker;
-    var oldHook = def[hookKey];
+    let invoker;
+    const oldHook = def[hookKey];
     function wrappedHook() {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
@@ -1995,27 +1999,26 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
     // component itself.
-    var propOptions = Ctor.options.props;
+    const propOptions = Ctor.options.props;
     if (isUndef(propOptions)) {
         return;
     }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    const res = {};
+    const { attrs, props } = data;
     if (isDef(attrs) || isDef(props)) {
-        for (var key in propOptions) {
-            var altKey = hyphenate(key);
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
             {
-                var keyInLowerCase = key.toLowerCase();
+                const keyInLowerCase = key.toLowerCase();
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                        (formatComponentName(
-                        // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
-                        "Note that HTML attributes are case-insensitive and camelCased " +
-                        "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2056,7 +2059,7 @@ function checkProp(res, hash, key, altKey, preserve) {
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
 function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
+    for (let i = 0; i < children.length; i++) {
         if (Array.isArray(children[i])) {
             return Array.prototype.concat.apply([], children);
         }
@@ -2078,18 +2081,18 @@ function isTextNode(node) {
     return isDef(node) && isDef(node.text) && isFalse(node.isComment);
 }
 function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
+    const res = [];
+    let i, c, lastIndex, last;
     for (i = 0; i < children.length; i++) {
         c = children[i];
         if (isUndef(c) || typeof c === 'boolean')
-            { continue; }
+            continue;
         lastIndex = res.length - 1;
         last = res[lastIndex];
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2121,7 +2124,7 @@ function normalizeArrayChildren(children, nestedIndex) {
                     isDef(c.tag) &&
                     isUndef(c.key) &&
                     isDef(nestedIndex)) {
-                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                    c.key = `__vlist${nestedIndex}_${i}__`;
                 }
                 res.push(c);
             }
@@ -2131,7 +2134,7 @@ function normalizeArrayChildren(children, nestedIndex) {
 }
 
 function initProvide(vm) {
-    var provide = vm.$options.provide;
+    const provide = vm.$options.provide;
     if (provide) {
         vm._provided =
             typeof provide === 'function'
@@ -2141,16 +2144,16 @@ function initProvide(vm) {
     }
 }
 function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
+    const result = resolveInject(vm.$options.inject, vm);
     if (result) {
         toggleObserving(false);
-        Object.keys(result).forEach(function (key) {
+        Object.keys(result).forEach((key) => {
             /* istanbul ignore else */
             {
-                defineReactive(vm, key, result[key], function () {
-                    warn("Avoid mutating an injected value directly since the changes will be " +
-                        "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                defineReactive(vm, key, result[key], () => {
+                    warn(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
                 });
             }
         });
@@ -2160,15 +2163,15 @@ function initInjections(vm) {
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
-        var result = Object.create(null);
-        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (var i = 0; i < keys.length; i++) {
-            var key = keys[i];
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             // #6574 in case the inject object is observed...
             if (key === '__ob__')
-                { continue; }
-            var provideKey = inject[key].from;
-            var source = vm;
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
             while (source) {
                 if (source._provided && hasOwn(source._provided, provideKey)) {
                     result[key] = source._provided[provideKey];
@@ -2179,15 +2182,14 @@ function resolveInject(inject, vm) {
             }
             if (!source) {
                 if ('default' in inject[key]) {
-                    var provideDefault = inject[key].default;
+                    const provideDefault = inject[key].default;
                     result[key] =
                         typeof provideDefault === 'function'
                             ? provideDefault.call(vm)
                             : provideDefault;
                 }
                 else {
-                    // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn(`Injection "${key}" not found`, vm);
                 }
             }
         }
@@ -2202,10 +2204,10 @@ function resolveSlots(children, context) {
     if (!children || !children.length) {
         return {};
     }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var data = child.data;
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
         // remove slot attribute if the node is resolved as a Vue slot node
         if (data && data.attrs && data.attrs.slot) {
             delete data.attrs.slot;
@@ -2215,8 +2217,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2229,9 +2231,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
         }
     }
     return slots;
@@ -2240,11 +2242,16 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
+}
+
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
     if (!slots) {
         res = {};
     }
@@ -2264,16 +2271,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2281,19 +2288,22 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     if (slots && Object.isExtensible(slots)) {
         slots._normalized = res;
     }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
-            res && typeof res === 'object' && !Array.isArray(res)
+            res && typeof res === "object" && !Array.isArray(res)
                 ? [res] // single vnode
                 : normalizeChildren(res);
-        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
             ? undefined
             : res;
     };
@@ -2310,14 +2320,14 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     return normalized;
 }
 function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; };
+    return () => slots[key];
 }
 
 /**
  * Runtime helper for rendering v-for lists.
  */
 function renderList(val, render) {
-    var ret = null, i, l, keys, key;
+    let ret = null, i, l, keys, key;
     if (Array.isArray(val) || typeof val === 'string') {
         ret = new Array(val.length);
         for (i = 0, l = val.length; i < l; i++) {
@@ -2333,8 +2343,8 @@ function renderList(val, render) {
     else if (isObject(val)) {
         if (hasSymbol && val[Symbol.iterator]) {
             ret = [];
-            var iterator = val[Symbol.iterator]();
-            var result = iterator.next();
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
             while (!result.done) {
                 ret.push(render(result.value, ret.length));
                 result = iterator.next();
@@ -2359,26 +2369,34 @@ function renderList(val, render) {
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
     if (scopedSlotFn) {
         // scoped slot
         props = props || {};
         if (bindObject) {
             if (!isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
+                warn("slot v-bind without argument expects an Object", this);
             }
             props = extend(extend({}, bindObject), props);
         }
-        nodes = scopedSlotFn(props) || fallback;
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
     else {
-        nodes = this.$slots[name] || fallback;
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
-    var target = props && props.slot;
+    const target = props && props.slot;
     if (target) {
-        return this.$createElement('template', { slot: target }, nodes);
+        return this.$createElement("template", { slot: target }, nodes);
     }
     else {
         return nodes;
@@ -2406,7 +2424,7 @@ function isKeyNotMatch(expect, actual) {
  * passing in eventKeyName as last argument separately for backwards compat
  */
 function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
     if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
         return isKeyNotMatch(builtInKeyName, eventKeyName);
     }
@@ -2416,6 +2434,7 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     else if (eventKeyName) {
         return hyphenate(eventKeyName) !== key;
     }
+    return eventKeyCode === undefined;
 }
 
 /**
@@ -2430,32 +2449,30 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            let hash;
+            for (const key in value) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
                 else {
-                    var type = data.attrs && data.attrs.type;
+                    const type = data.attrs && data.attrs.type;
                     hash =
                         asProp || config.mustUseProp(tag, type, key)
                             ? data.domProps || (data.domProps = {})
                             : data.attrs || (data.attrs = {});
                 }
-                var camelizedKey = camelize(key);
-                var hyphenatedKey = hyphenate(key);
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
                 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                     hash[key] = value[key];
                     if (isSync) {
-                        var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
-            };
-
-            for (var key in value) loop( key );
+            }
         }
     }
     return data;
@@ -2465,8 +2482,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
  * Runtime helper for rendering static trees.
  */
 function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
     // if has already-rendered static tree and not inside v-for,
     // we can reuse the same tree.
     if (tree && !isInFor) {
@@ -2475,7 +2492,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic(tree, `__static__${index}`, false);
     return tree;
 }
 /**
@@ -2483,14 +2500,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
-        for (var i = 0; i < tree.length; i++) {
+        for (let i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
             }
         }
     }
@@ -2510,10 +2527,10 @@ function bindObjectListeners(data, value) {
             warn('v-on without argument expects an Object value', this);
         }
         else {
-            var on = (data.on = data.on ? extend({}, data.on) : {});
-            for (var key in value) {
-                var existing = on[key];
-                var ours = value[key];
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
                 on[key] = existing ? [].concat(existing, ours) : ours;
             }
         }
@@ -2525,8 +2542,8 @@ function resolveScopedSlots(fns, res,
 // the following are added in 2.6
 hasDynamicKeys, contentHashKey) {
     res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-        var slot = fns[i];
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
         if (Array.isArray(slot)) {
             resolveScopedSlots(slot, res, hasDynamicKeys);
         }
@@ -2548,15 +2565,15 @@ hasDynamicKeys, contentHashKey) {
 
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-        var key = values[i];
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
         if (typeof key === 'string' && key) {
             baseObj[values[i]] = values[i + 1];
         }
         else if (key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
         }
     }
     return baseObj;
@@ -2589,12 +2606,10 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
-    var options = Ctor.options;
+    const options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
+    let contextVm;
     if (hasOwn(parent, '_uid')) {
         contextVm = Object.create(parent);
         // $flow-disable-line
@@ -2608,23 +2623,23 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         // $flow-disable-line
         parent = parent._original;
     }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
     this.data = data;
     this.props = props;
     this.children = children;
     this.parent = parent;
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2637,8 +2652,8 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
     }
     if (options._scopeId) {
-        this._c = function (a, b, c, d) {
-            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2647,34 +2662,34 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
 function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
     if (isDef(propOptions)) {
-        for (var key in propOptions) {
+        for (const key in propOptions) {
             props[key] = validateProp(key, propOptions, propsData || emptyObject);
         }
     }
     else {
         if (isDef(data.attrs))
-            { mergeProps(props, data.attrs); }
+            mergeProps(props, data.attrs);
         if (isDef(data.props))
-            { mergeProps(props, data.props); }
+            mergeProps(props, data.props);
     }
-    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    var vnode = options.render.call(null, renderContext._c, renderContext);
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
     if (vnode instanceof VNode) {
         return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
     }
     else if (Array.isArray(vnode)) {
-        var vnodes = normalizeChildren(vnode) || [];
-        var res = new Array(vnodes.length);
-        for (var i = 0; i < vnodes.length; i++) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
             res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
         }
         return res;
@@ -2684,7 +2699,7 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     // #7817 clone node before setting fnContext, otherwise if the node is reused
     // (e.g. it was from a cached normal slot) the fnContext causes named slots
     // that should not be matched to match.
-    var clone = cloneVNode(vnode);
+    const clone = cloneVNode(vnode);
     clone.fnContext = contextVm;
     clone.fnOptions = options;
     {
@@ -2696,38 +2711,37 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     return clone;
 }
 function mergeProps(to, from) {
-    for (var key in from) {
+    for (const key in from) {
         to[camelize(key)] = from[key];
     }
 }
 
 // inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
             // kept-alive components, treat as a patch
-            var mountedNode = vnode; // work around flow
+            const mountedNode = vnode; // work around flow
             componentVNodeHooks.prepatch(mountedNode, mountedNode);
         }
         else {
-            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
-        var options = vnode.componentOptions;
-        var child = (vnode.componentInstance = oldVnode.componentInstance);
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
         options.listeners, // updated listeners
         vnode, // new parent vnode
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2746,8 +2760,8 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
-        var componentInstance = vnode.componentInstance;
+    destroy(vnode) {
+        const { componentInstance } = vnode;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
                 componentInstance.$destroy();
@@ -2758,12 +2772,12 @@ var componentVNodeHooks = {
         }
     },
 };
-var hooksToMerge = Object.keys(componentVNodeHooks);
+const hooksToMerge = Object.keys(componentVNodeHooks);
 function createComponent(Ctor, data, context, children, tag) {
     if (isUndef(Ctor)) {
         return;
     }
-    var baseCtor = context.$options._base;
+    const baseCtor = context.$options._base;
     // plain options object: turn it into a constructor
     if (isObject(Ctor)) {
         Ctor = baseCtor.extend(Ctor);
@@ -2772,12 +2786,12 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn(`Invalid Component definition: ${String(Ctor)}`, context);
         }
         return;
     }
     // async component
-    var asyncFactory;
+    let asyncFactory;
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
@@ -2800,7 +2814,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract props
     // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
     // functional component
     // @ts-expect-error
     if (isTrue(Ctor.options.functional)) {
@@ -2808,7 +2822,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract listeners, since these needs to be treated as
     // child component listeners instead of DOM listeners
-    var listeners = data.on;
+    const listeners = data.on;
     // replace with listeners with .native modifier
     // so it gets processed during parent component patch.
     data.on = data.nativeOn;
@@ -2817,7 +2831,7 @@ function createComponent(Ctor, data, context, children, tag) {
         // abstract components do not keep anything
         // other than props & listeners & slot
         // work around flow
-        var slot = data.slot;
+        const slot = data.slot;
         data = {};
         if (slot) {
             data.slot = slot;
@@ -2827,12 +2841,12 @@ function createComponent(Ctor, data, context, children, tag) {
     installComponentHooks(data);
     // return a placeholder vnode
     // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
     // @ts-expect-error
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
     return vnode;
 }
 function createComponentInstanceForVnode(
@@ -2840,13 +2854,13 @@ function createComponentInstanceForVnode(
 vnode, 
 // activeInstance in lifecycle state
 parent) {
-    var options = {
+    const options = {
         _isComponent: true,
         _parentVnode: vnode,
-        parent: parent,
+        parent,
     };
     // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
+    const inlineTemplate = vnode.data.inlineTemplate;
     if (isDef(inlineTemplate)) {
         options.render = inlineTemplate.render;
         options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2854,11 +2868,11 @@ parent) {
     return new vnode.componentOptions.Ctor(options);
 }
 function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-        var key = hooksToMerge[i];
-        var existing = hooks[key];
-        var toMerge = componentVNodeHooks[key];
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
             hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2866,7 +2880,7 @@ function installComponentHooks(data) {
     }
 }
 function mergeHook(f1, f2) {
-    var merged = function (a, b) {
+    const merged = (a, b) => {
         // flow complains about extra args which is why we use any
         f1(a, b);
         f2(a, b);
@@ -2877,12 +2891,12 @@ function mergeHook(f1, f2) {
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
 function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input';
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
     (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
     if (isDef(existing)) {
         if (Array.isArray(existing)
             ? existing.indexOf(callback) === -1
@@ -2895,8 +2909,8 @@ function transformModel(options, data) {
     }
 }
 
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
 function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2912,7 +2926,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 }
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
-        warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+        warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2945,16 +2959,16 @@ function _createElement(context, tag, data, children, normalizationType) {
     else if (normalizationType === SIMPLE_NORMALIZE) {
         children = simpleNormalizeChildren(children);
     }
-    var vnode, ns;
+    let vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        let Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
             if (isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -2979,9 +2993,9 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     else if (isDef(vnode)) {
         if (isDef(ns))
-            { applyNS(vnode, ns); }
+            applyNS(vnode, ns);
         if (isDef(data))
-            { registerDeepBindings(data); }
+            registerDeepBindings(data);
         return vnode;
     }
     else {
@@ -2996,8 +3010,8 @@ function applyNS(vnode, ns, force) {
         force = true;
     }
     if (isDef(vnode.children)) {
-        for (var i = 0, l = vnode.children.length; i < l; i++) {
-            var child = vnode.children[i];
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
             if (isDef(child.tag) &&
                 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                 applyNS(child, ns, force);
@@ -3020,9 +3034,9 @@ function registerDeepBindings(data) {
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
     vm.$slots = resolveSlots(options._renderChildren, renderContext);
     vm.$scopedSlots = emptyObject;
     // bind the createElement fn to this instance
@@ -3030,25 +3044,25 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
+    const parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
         }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
         }, true);
     }
 }
-var currentRenderingInstance = null;
+let currentRenderingInstance = null;
 function renderMixin(Vue) {
     // install runtime convenience helpers
     installRenderHelpers(Vue.prototype);
@@ -3056,10 +3070,8 @@ function renderMixin(Vue) {
         return nextTick(fn, this);
     };
     Vue.prototype._render = function () {
-        var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3067,7 +3079,7 @@ function renderMixin(Vue) {
         // to the data on the placeholder node.
         vm.$vnode = _parentVnode;
         // render self
-        var vnode;
+        let vnode;
         try {
             // There's no need to maintain a stack because all render fns are called
             // separately from one another. Nested component's render fns are called
@@ -3076,7 +3088,7 @@ function renderMixin(Vue) {
             vnode = render.call(vm._renderProxy, vm.$createElement);
         }
         catch (e) {
-            handleError(e, vm, "render");
+            handleError(e, vm, `render`);
             // return error render result,
             // or previous vnode to prevent render error causing blank component
             /* istanbul ignore else */
@@ -3084,8 +3096,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e$1) {
-                    handleError(e$1, vm, "renderError");
+                catch (e) {
+                    handleError(e, vm, `renderError`);
                     vnode = vm._vnode;
                 }
             }
@@ -3121,9 +3133,9 @@ function ensureCtor(comp, base) {
     return isObject(comp) ? base.extend(comp) : comp;
 }
 function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
+    const node = createEmptyVNode();
     node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    node.asyncMeta = { data, context, children, tag };
     return node;
 }
 function resolveAsyncComponent(factory, baseCtor) {
@@ -3133,7 +3145,7 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    var owner = currentRenderingInstance;
+    const owner = currentRenderingInstance;
     if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
         // already pending
         factory.owners.push(owner);
@@ -3142,13 +3154,13 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
                 owners[i].$forceUpdate();
             }
             if (renderCompleted) {
@@ -3163,7 +3175,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
             }
         };
-        var resolve = once(function (res) {
+        const resolve = once((res) => {
             // cache resolved
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
@@ -3175,15 +3187,15 @@ function resolveAsyncComponent(factory, baseCtor) {
                 owners.length = 0;
             }
         });
-        var reject = once(function (reason) {
-            warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+        const reject = once((reason) => {
+            warn(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
                 forceRender(true);
             }
         });
-        var res = factory(resolve, reject);
+        const res = factory(resolve, reject);
         if (isObject(res)) {
             if (isPromise(res)) {
                 // () => Promise
@@ -3203,7 +3215,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
+                        timerLoading = setTimeout(() => {
                             timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
@@ -3214,10 +3226,10 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
                 if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
+                    timerTimeout = setTimeout(() => {
                         timerTimeout = null;
                         if (isUndef(factory.resolved)) {
-                            reject(("timeout (" + (res.timeout) + "ms)")
+                            reject(`timeout (${res.timeout}ms)`
                                 );
                         }
                     }, res.timeout);
@@ -3230,15 +3242,10 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-            var c = children[i];
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
             if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                 return c;
             }
@@ -3250,12 +3257,12 @@ function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
     // init parent attached events
-    var listeners = vm.$options._parentListeners;
+    const listeners = vm.$options._parentListeners;
     if (listeners) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target$1;
+let target$1;
 function add$1(event, fn) {
     target$1.$on(event, fn);
 }
@@ -3263,9 +3270,9 @@ function remove$1(event, fn) {
     target$1.$off(event, fn);
 }
 function createOnceHandler$1(event, fn) {
-    var _target = target$1;
+    const _target = target$1;
     return function onceHandler() {
-        var res = fn.apply(null, arguments);
+        const res = fn.apply(null, arguments);
         if (res !== null) {
             _target.$off(event, onceHandler);
         }
@@ -3277,11 +3284,11 @@ function updateComponentListeners(vm, listeners, oldListeners) {
     target$1 = undefined;
 }
 function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
+    const hookRE = /^hook:/;
     Vue.prototype.$on = function (event, fn) {
-        var vm = this;
+        const vm = this;
         if (Array.isArray(event)) {
-            for (var i = 0, l = event.length; i < l; i++) {
+            for (let i = 0, l = event.length; i < l; i++) {
                 vm.$on(event[i], fn);
             }
         }
@@ -3296,7 +3303,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$once = function (event, fn) {
-        var vm = this;
+        const vm = this;
         function on() {
             vm.$off(event, on);
             fn.apply(vm, arguments);
@@ -3306,7 +3313,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$off = function (event, fn) {
-        var vm = this;
+        const vm = this;
         // all
         if (!arguments.length) {
             vm._events = Object.create(null);
@@ -3314,13 +3321,13 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
             }
             return vm;
         }
         // specific event
-        var cbs = vm._events[event];
+        const cbs = vm._events[event];
         if (!cbs) {
             return vm;
         }
@@ -3329,8 +3336,8 @@ function eventsMixin(Vue) {
             return vm;
         }
         // specific handler
-        var cb;
-        var i = cbs.length;
+        let cb;
+        let i = cbs.length;
         while (i--) {
             cb = cbs[i];
             if (cb === fn || cb.fn === fn) {
@@ -3341,23 +3348,23 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$emit = function (event) {
-        var vm = this;
+        const vm = this;
         {
-            var lowerCaseEvent = event.toLowerCase();
+            const lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                    "Note that HTML attributes are case-insensitive and you cannot use " +
-                    "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
             }
         }
-        var cbs = vm._events[event];
+        let cbs = vm._events[event];
         if (cbs) {
             cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            var args = toArray(arguments, 1);
-            var info = "event handler for \"" + event + "\"";
-            for (var i = 0, l = cbs.length; i < l; i++) {
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
                 invokeWithErrorHandling(cbs[i], vm, args, vm, info);
             }
         }
@@ -3365,19 +3372,19 @@ function eventsMixin(Vue) {
     };
 }
 
-var activeInstance = null;
-var isUpdatingChildComponent = false;
+let activeInstance = null;
+let isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
+    const prevActiveInstance = activeInstance;
     activeInstance = vm;
-    return function () {
+    return () => {
         activeInstance = prevActiveInstance;
     };
 }
 function initLifecycle(vm) {
-    var options = vm.$options;
+    const options = vm.$options;
     // locate first non-abstract parent
-    var parent = options.parent;
+    let parent = options.parent;
     if (parent && !options.abstract) {
         while (parent.$options.abstract && parent.$parent) {
             parent = parent.$parent;
@@ -3388,7 +3395,6 @@ function initLifecycle(vm) {
     vm.$root = parent ? parent.$root : vm;
     vm.$children = [];
     vm.$refs = {};
-    // @ts-ignore
     vm._watcher = null;
     vm._inactive = null;
     vm._directInactive = false;
@@ -3398,10 +3404,10 @@ function initLifecycle(vm) {
 }
 function lifecycleMixin(Vue) {
     Vue.prototype._update = function (vnode, hydrating) {
-        var vm = this;
-        var prevEl = vm.$el;
-        var prevVnode = vm._vnode;
-        var restoreActiveInstance = setActiveInstance(vm);
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
         vm._vnode = vnode;
         // Vue.prototype.__patch__ is injected in entry points
         // based on the rendering backend used.
@@ -3429,21 +3435,20 @@ function lifecycleMixin(Vue) {
         // updated in a parent's updated hook.
     };
     Vue.prototype.$forceUpdate = function () {
-        var vm = this;
+        const vm = this;
         if (vm._watcher) {
             vm._watcher.update();
         }
     };
     Vue.prototype.$destroy = function () {
-        var vm = this;
+        const vm = this;
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook$1(vm, 'beforeDestroy');
+        callHook$1(vm, "beforeDestroy");
         vm._isBeingDestroyed = true;
         // remove self from parent
-        var parent = vm.$parent;
-        // @ts-ignore
+        const parent = vm.$parent;
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
             remove$2(parent.$children, vm);
         }
@@ -3451,7 +3456,7 @@ function lifecycleMixin(Vue) {
         if (vm._watcher) {
             vm._watcher.teardown();
         }
-        var i = vm._watchers.length;
+        let i = vm._watchers.length;
         while (i--) {
             vm._watchers[i].teardown();
         }
@@ -3465,7 +3470,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook$1(vm, 'destroyed');
+        callHook$1(vm, "destroyed");
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3474,7 +3479,6 @@ function lifecycleMixin(Vue) {
         }
         // release circular reference (#6759)
         if (vm.$vnode) {
-            // @ts-expect-error null is not undefined
             vm.$vnode.parent = null;
         }
     };
@@ -3486,39 +3490,39 @@ function mountComponent(vm, el, hydrating) {
         vm.$options.render = createEmptyVNode;
         {
             /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                 vm.$options.el ||
                 el) {
-                warn('You are using the runtime-only build of Vue where the template ' +
-                    'compiler is not available. Either pre-compile the templates into ' +
-                    'render functions, or use the compiler-included build.', vm);
+                warn("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
             }
             else {
-                warn('Failed to mount component: template or render function not defined.', vm);
+                warn("Failed to mount component: template or render function not defined.", vm);
             }
         }
     }
-    callHook$1(vm, 'beforeMount');
-    var updateComponent;
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
     /* istanbul ignore if */
     if (config.performance && mark) {
-        updateComponent = function () {
-            var name = vm._name;
-            var id = vm._uid;
-            var startTag = "vue-perf-start:" + id;
-            var endTag = "vue-perf-end:" + id;
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
             mark(startTag);
-            var vnode = vm._render();
+            const vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure(`vue ${name} render`, startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
         };
     }
     else {
-        updateComponent = function () {
+        updateComponent = () => {
             vm._update(vm._render(), hydrating);
         };
     }
@@ -3526,9 +3530,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before() {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, 'beforeUpdate');
+                callHook$1(vm, "beforeUpdate");
             }
         },
     }, true /* isRenderWatcher */);
@@ -3537,7 +3541,7 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook$1(vm, 'mounted');
+        callHook$1(vm, "mounted");
     }
     return vm;
 }
@@ -3550,24 +3554,22 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // check if there are dynamic scopedSlots (hand-written or compiled but with
     // dynamic slot names). Static scoped slots compiled from template has the
     // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(renderChildren || // has new static slots
+    const needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
-    // @ts-ignore
     vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
     vm.$vnode = parentVnode; // update vm's placeholder node without re-render
     if (vm._vnode) {
         // update child tree's parent
-        // @ts-ignore
         vm._vnode.parent = parentVnode;
     }
     vm.$options._renderChildren = renderChildren;
@@ -3575,16 +3577,15 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // these are also reactive so they may trigger child update if the child
     // used them during render
     vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
     vm.$listeners = listeners || emptyObject;
     // update props
     if (propsData && vm.$options.props) {
         toggleObserving(false);
-        var props = vm._props;
-        var propKeys = vm.$options._propKeys || [];
-        for (var i = 0; i < propKeys.length; i++) {
-            var key = propKeys[i];
-            var propOptions = vm.$options.props; // wtf flow?
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
             props[key] = validateProp(key, propOptions, propsData, vm);
         }
         toggleObserving(true);
@@ -3593,7 +3594,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     }
     // update listeners
     listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
+    const oldListeners = vm.$options._parentListeners;
     vm.$options._parentListeners = listeners;
     updateComponentListeners(vm, listeners, oldListeners);
     // resolve slots + force update if has children
@@ -3608,7 +3609,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
 function isInInactiveTree(vm) {
     while (vm && (vm = vm.$parent)) {
         if (vm._inactive)
-            { return true; }
+            return true;
     }
     return false;
 }
@@ -3624,10 +3625,10 @@ function activateChildComponent(vm, direct) {
     }
     if (vm._inactive || vm._inactive === null) {
         vm._inactive = false;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'activated');
+        callHook$1(vm, "activated");
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3639,36 +3640,36 @@ function deactivateChildComponent(vm, direct) {
     }
     if (!vm._inactive) {
         vm._inactive = true;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'deactivated');
+        callHook$1(vm, "deactivated");
     }
 }
 function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
     if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
             invokeWithErrorHandling(handlers[i], vm, null, vm, info);
         }
     }
     if (vm._hasHookEvent) {
-        vm.$emit('hook:' + hook);
+        vm.$emit("hook:" + hook);
     }
     popTarget();
 }
 
-var MAX_UPDATE_COUNT = 100;
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index = 0;
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index = 0;
 /**
  * Reset the scheduler's state.
  */
@@ -3685,9 +3686,9 @@ function resetSchedulerState() {
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
-var currentFlushTimestamp = 0;
+let currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
+let getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3695,7 +3696,7 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
+    const performance = window.performance;
     if (performance &&
         typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
@@ -3703,7 +3704,7 @@ if (inBrowser && !isIE) {
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = () => performance.now();
     }
 }
 /**
@@ -3712,7 +3713,7 @@ if (inBrowser && !isIE) {
 function flushSchedulerQueue() {
     currentFlushTimestamp = getNow();
     flushing = true;
-    var watcher, id;
+    let watcher, id;
     // Sort queue before flush.
     // This ensures that:
     // 1. Components are updated from parent to child. (because parent is always
@@ -3721,7 +3722,7 @@ function flushSchedulerQueue() {
     //    user watchers are created before the render watcher)
     // 3. If a component is destroyed during a parent component's watcher run,
     //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
+    queue.sort((a, b) => a.id - b.id);
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
     for (index = 0; index < queue.length; index++) {
@@ -3738,15 +3739,15 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                        : "in a component render function."), watcher.vm);
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
                 break;
             }
         }
     }
     // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
     resetSchedulerState();
     // call component updated and activated hooks
     callActivatedHooks(activatedQueue);
@@ -3758,10 +3759,10 @@ function flushSchedulerQueue() {
     }
 }
 function callUpdatedHooks(queue) {
-    var i = queue.length;
+    let i = queue.length;
     while (i--) {
-        var watcher = queue[i];
-        var vm = watcher.vm;
+        const watcher = queue[i];
+        const vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
             callHook$1(vm, 'updated');
         }
@@ -3778,7 +3779,7 @@ function queueActivatedComponent(vm) {
     activatedChildren.push(vm);
 }
 function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
+    for (let i = 0; i < queue.length; i++) {
         queue[i]._inactive = true;
         activateChildComponent(queue[i], true /* true */);
     }
@@ -3789,7 +3790,7 @@ function callActivatedHooks(queue) {
  * pushed when the queue is being flushed.
  */
 function queueWatcher(watcher) {
-    var id = watcher.id;
+    const id = watcher.id;
     if (has[id] == null) {
         has[id] = true;
         if (!flushing) {
@@ -3798,7 +3799,7 @@ function queueWatcher(watcher) {
         else {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
-            var i = queue.length - 1;
+            let i = queue.length - 1;
             while (i > index && queue[i].id > watcher.id) {
                 i--;
             }
@@ -3816,199 +3817,217 @@ function queueWatcher(watcher) {
     }
 }
 
-var uid$1 = 0;
+let uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$1; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        expOrFn.toString() ;
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            warn("Failed watching path: \"" + expOrFn + "\" " +
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = expOrFn.toString()
+            ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn(`Failed watching path: "${expOrFn}" ` +
                     'Watcher only accepts simple dot-delimited paths. ' +
                     'For full control, use a function instead.', vm);
+            }
         }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
     }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-        else {
-            throw e;
+        catch (e) {
+            if (this.user) {
+                // @ts-expect-error e is unknown, should we cast or any?
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
         }
-        popTarget();
-        this.cleanupDeps();
+        return value;
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
         }
     }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
     }
-    else {
-        queueWatcher(this);
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
     }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
-            if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                 }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                else {
+                    this.cb.call(this.vm, value, oldValue);
                 }
             }
-            else {
-                this.cb.call(this.vm, value, oldValue);
-            }
         }
     }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
     }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove$2(this.vm._watchers, this);
-        }
-        var i = this.deps.length;
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            this.deps[i].depend();
         }
-        this.active = false;
     }
-};
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
+}
 
-var sharedPropertyDefinition = {
+const sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
     get: noop,
@@ -4025,11 +4044,11 @@ function proxy(target, sourceKey, key) {
 }
 function initState(vm) {
     vm._watchers = [];
-    var opts = vm.$options;
+    const opts = vm.$options;
     if (opts.props)
-        { initProps$1(vm, opts.props); }
+        initProps$1(vm, opts.props);
     if (opts.methods)
-        { initMethods(vm, opts.methods); }
+        initMethods(vm, opts.methods);
     if (opts.data) {
         initData(vm);
     }
@@ -4037,38 +4056,38 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed$1(vm, opts.computed); }
+        initComputed$1(vm, opts.computed);
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
 function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
     // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
     // root instance props should be converted
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    for (const key in propsOptions) {
         keys.push(key);
-        var value = validateProp(key, propsOptions, propsData, vm);
+        const value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
         {
-            var hyphenatedKey = hyphenate(key);
+            const hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
             }
-            defineReactive(props, key, value, function () {
+            defineReactive(props, key, value, () => {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn("Avoid mutating a prop directly since the value will be " +
-                        "overwritten whenever the parent component re-renders. " +
-                        "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                    warn(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
                 }
             });
         }
@@ -4076,39 +4095,37 @@ function initProps$1(vm, propsOptions) {
         // during Vue.extend(). We only need to proxy props defined at
         // instantiation here.
         if (!(key in vm)) {
-            proxy(vm, "_props", key);
+            proxy(vm, `_props`, key);
         }
-    };
-
-    for (var key in propsOptions) loop( key );
+    }
     toggleObserving(true);
 }
 function initData(vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        warn('data functions should return an object:\n' +
-                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+        warn("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
     }
     // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
     while (i--) {
-        var key = keys[i];
+        const key = keys[i];
         {
             if (methods && hasOwn(methods, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn(`Method "${key}" has already been defined as a data property.`, vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            warn("The data property \"" + key + "\" is already declared as a prop. " +
-                    "Use prop default value instead.", vm);
+            warn(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
         }
         else if (!isReserved(key)) {
-            proxy(vm, "_data", key);
+            proxy(vm, `_data`, key);
         }
     }
     // observe data
@@ -4121,24 +4138,24 @@ function getData(data, vm) {
         return data.call(vm, vm);
     }
     catch (e) {
-        handleError(e, vm, "data()");
+        handleError(e, vm, `data()`);
         return {};
     }
     finally {
         popTarget();
     }
 }
-var computedWatcherOptions = { lazy: true };
+const computedWatcherOptions = { lazy: true };
 function initComputed$1(vm, computed) {
     // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
+    const watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-        var userDef = computed[key];
-        var getter = typeof userDef === 'function' ? userDef : userDef.get;
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
         if (getter == null) {
-            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+            warn(`Getter is missing for computed property "${key}".`, vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4152,17 +4169,20 @@ function initComputed$1(vm, computed) {
         }
         else {
             if (key in vm.$data) {
-                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn(`The computed property "${key}" is already defined in data.`, vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn(`The computed property "${key}" is already defined as a method.`, vm);
             }
         }
     }
 }
 function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
             : createGetterInvoker(userDef);
@@ -4178,14 +4198,14 @@ function defineComputed(target, key, userDef) {
     }
     if (sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
 }
 function createComputedGetter(key) {
     return function computedGetter() {
-        var watcher = this._computedWatchers && this._computedWatchers[key];
+        const watcher = this._computedWatchers && this._computedWatchers[key];
         if (watcher) {
             if (watcher.dirty) {
                 watcher.evaluate();
@@ -4203,29 +4223,30 @@ function createGetterInvoker(fn) {
     };
 }
 function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
         {
-            if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                    "Did you reference the function correctly?", vm);
+            if (typeof methods[key] !== "function") {
+                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn(`Method "${key}" has already been defined as a prop.`, vm);
             }
             if (key in vm && isReserved(key)) {
-                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                    "Avoid defining component methods that start with _ or $.");
+                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
-    for (var key in watch) {
-        var handler = watch[key];
+    for (const key in watch) {
+        const handler = watch[key];
         if (Array.isArray(handler)) {
-            for (var i = 0; i < handler.length; i++) {
+            for (let i = 0; i < handler.length; i++) {
                 createWatcher(vm, key, handler[i]);
             }
         }
@@ -4239,7 +4260,7 @@ function createWatcher(vm, expOrFn, handler, options) {
         options = handler;
         handler = handler.handler;
     }
-    if (typeof handler === 'string') {
+    if (typeof handler === "string") {
         handler = vm[handler];
     }
     return vm.$watch(expOrFn, handler, options);
@@ -4248,43 +4269,39 @@ function stateMixin(Vue) {
     // flow somehow has problems with directly declared definition object
     // when using Object.defineProperty, so we have to procedurally build up
     // the object here.
-    var dataDef = {};
+    const dataDef = {};
     dataDef.get = function () {
         return this._data;
     };
-    var propsDef = {};
+    const propsDef = {};
     propsDef.get = function () {
         return this._props;
     };
     {
         dataDef.set = function () {
-            warn('Avoid replacing instance root $data. ' +
-                'Use nested data properties instead.', this);
+            warn("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
         };
         propsDef.set = function () {
-            warn("$props is readonly.", this);
+            warn(`$props is readonly.`, this);
         };
     }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
-        var vm = this;
+        const vm = this;
         if (isPlainObject(cb)) {
             return createWatcher(vm, expOrFn, cb, options);
         }
         options = options || {};
         options.user = true;
-        var watcher = new Watcher(vm, expOrFn, cb, options);
+        const watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
             pushTarget();
-            try {
-                cb.call(vm, watcher.value);
-            }
-            catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-            }
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
             popTarget();
         }
         return function unwatchFn() {
@@ -4293,17 +4310,17 @@ function stateMixin(Vue) {
     };
 }
 
-var uid = 0;
+let uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
-        var vm = this;
+        const vm = this;
         // a uid
         vm._uid = uid++;
-        var startTag, endTag;
+        let startTag, endTag;
         /* istanbul ignore if */
         if (config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4336,7 +4353,7 @@ function initMixin$1(Vue) {
         if (config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4344,13 +4361,12 @@ function initMixin$1(Vue) {
     };
 }
 function initInternalComponent(vm, options) {
-    // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
+    const opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
+    const parentVnode = options._parentVnode;
     opts.parent = options.parent;
     opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
+    const vnodeComponentOptions = parentVnode.componentOptions;
     opts.propsData = vnodeComponentOptions.propsData;
     opts._parentListeners = vnodeComponentOptions.listeners;
     opts._renderChildren = vnodeComponentOptions.children;
@@ -4361,16 +4377,16 @@ function initInternalComponent(vm, options) {
     }
 }
 function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
+    let options = Ctor.options;
     if (Ctor.super) {
-        var superOptions = resolveConstructorOptions(Ctor.super);
-        var cachedSuperOptions = Ctor.superOptions;
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
         if (superOptions !== cachedSuperOptions) {
             // super option changed,
             // need to resolve new options.
             Ctor.superOptions = superOptions;
             // check if there are any late-modified/attached options (#4976)
-            var modifiedOptions = resolveModifiedOptions(Ctor);
+            const modifiedOptions = resolveModifiedOptions(Ctor);
             // update base extend options
             if (modifiedOptions) {
                 extend(Ctor.extendOptions, modifiedOptions);
@@ -4384,13 +4400,13 @@ function resolveConstructorOptions(Ctor) {
     return options;
 }
 function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
         if (latest[key] !== sealed[key]) {
             if (!modified)
-                { modified = {}; }
+                modified = {};
             modified[key] = latest[key];
         }
     }
@@ -4399,29 +4415,29 @@ function resolveModifiedOptions(Ctor) {
 
 function Vue(options) {
     if (!(this instanceof Vue)) {
-        warn('Vue is a constructor and should be called with the `new` keyword');
+        warn("Vue is a constructor and should be called with the `new` keyword");
     }
     this._init(options);
 }
-//@ts-ignore
+//@ts-expect-error Vue has function type
 initMixin$1(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 stateMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 eventsMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 lifecycleMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
 function initUse(Vue) {
     Vue.use = function (plugin) {
-        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
         if (installedPlugins.indexOf(plugin) > -1) {
             return this;
         }
         // additional parameters
-        var args = toArray(arguments, 1);
+        const args = toArray(arguments, 1);
         args.unshift(this);
         if (typeof plugin.install === 'function') {
             plugin.install.apply(plugin, args);
@@ -4448,23 +4464,23 @@ function initExtend(Vue) {
      * constructors" for prototypal inheritance and cache them.
      */
     Vue.cid = 0;
-    var cid = 1;
+    let cid = 1;
     /**
      * Class inheritance
      */
     Vue.extend = function (extendOptions) {
         extendOptions = extendOptions || {};
-        var Super = this;
-        var SuperId = Super.cid;
-        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
         if (cachedCtors[SuperId]) {
             return cachedCtors[SuperId];
         }
-        var name = extendOptions.name || Super.options.name;
+        const name = extendOptions.name || Super.options.name;
         if (name) {
             validateComponentName(name);
         }
-        var Sub = function VueComponent(options) {
+        const Sub = function VueComponent(options) {
             this._init(options);
         };
         Sub.prototype = Object.create(Super.prototype);
@@ -4506,14 +4522,14 @@ function initExtend(Vue) {
     };
 }
 function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-        proxy(Comp.prototype, "_props", key);
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
     }
 }
 function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
     }
 }
@@ -4522,7 +4538,7 @@ function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
      */
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         // @ts-expect-error function is not exact same type
         Vue[type] = function (id, definition) {
             if (!definition) {
@@ -4548,6 +4564,7 @@ function initAssetRegisters(Vue) {
     });
 }
 
+/* @flow */
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4555,8 +4572,8 @@ function matches(pattern, name) {
     if (Array.isArray(pattern)) {
         return pattern.indexOf(name) > -1;
     }
-    else if (typeof pattern === 'string') {
-        return pattern.split(',').indexOf(name) > -1;
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
     }
     else if (isRegExp(pattern)) {
         return pattern.test(name);
@@ -4565,13 +4582,11 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-        var cachedNode = cache[key];
-        if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
             if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
@@ -4579,53 +4594,72 @@ function pruneCache(keepAliveInstance, filter) {
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-        //@ts-expect-error has void type
-        cached.componentInstance.$destroy();
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
     }
     cache[key] = null;
     remove$2(keys, key);
 }
-var patternTypes = [String, RegExp, Array];
-// TODO use defineComponent
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
 var KeepAlive = {
-    name: 'keep-alive',
+    name: "keep-alive",
     abstract: true,
     props: {
         include: patternTypes,
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
-        for (var key in this.cache) {
+    destroyed() {
+        for (const key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
-        this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
         });
-        this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
         });
     },
-    render: function render() {
-        var slot = this.$slots.default;
-        var vnode = getFirstComponentChild(slot);
-        var componentOptions = vnode && vnode.componentOptions;
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
             if (
             // not included
             (include && (!name || !matches(include, name))) ||
@@ -4633,14 +4667,12 @@ var KeepAlive = {
                 (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
-            var key = vnode.key == null
+            const { cache, keys } = this;
+            const key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4649,13 +4681,11 @@ var KeepAlive = {
                 keys.push(key);
             }
             else {
-                cache[key] = vnode;
-                keys.push(key);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
             }
+            // @ts-expect-error can vnode.data can be undefined
             vnode.data.keepAlive = true;
         }
         return vnode || (slot && slot[0]);
@@ -4663,15 +4693,15 @@ var KeepAlive = {
 };
 
 var builtInComponents = {
-    KeepAlive: KeepAlive,
+    KeepAlive,
 };
 
 function initGlobalAPI(Vue) {
     // config
-    var configDef = {};
-    configDef.get = function () { return config; };
+    const configDef = {};
+    configDef.get = () => config;
     {
-        configDef.set = function () {
+        configDef.set = () => {
             warn('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
@@ -4680,21 +4710,21 @@ function initGlobalAPI(Vue) {
     // NOTE: these are not considered part of the public API - avoid relying on
     // them unless you are aware of the risk.
     Vue.util = {
-        warn: warn,
-        extend: extend,
-        mergeOptions: mergeOptions,
-        defineReactive: defineReactive,
+        warn,
+        extend,
+        mergeOptions,
+        defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
     Vue.nextTick = nextTick;
     // 2.6 explicit observable API
-    Vue.observable = function (obj) {
+    Vue.observable = (obj) => {
         observe(obj);
         return obj;
     };
     Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         Vue.options[type + 's'] = Object.create(null);
     });
     // this is used to identify the "base" constructor to extend all plain-object
@@ -4712,7 +4742,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4721,22 +4751,22 @@ Object.defineProperty(Vue.prototype, '$ssrContext', {
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
     value: FunctionalRenderContext,
 });
-Vue.version = '2.6.12';
+Vue.version = '2.6.14';
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+const isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
     return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-var convertEnumeratedValue = function (key, value) {
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
     return isFalsyAttrValue(value) || value === 'false'
         ? 'false'
         : // allow arbitrary string value for contenteditable
@@ -4744,33 +4774,34 @@ var convertEnumeratedValue = function (key, value) {
                 ? value
                 : 'true';
 };
-var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
-var xlinkNS = 'http://www.w3.org/1999/xlink';
-var isXlink = function (name) {
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
     return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-var getXlinkProp = function (name) {
+const getXlinkProp = (name) => {
     return isXlink(name) ? name.slice(6, name.length) : '';
 };
-var isFalsyAttrValue = function (val) {
+const isFalsyAttrValue = (val) => {
     return val == null || val === false;
 };
 
 function genClassForVnode(vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
     while (isDef(childNode.componentInstance)) {
         childNode = childNode.componentInstance._vnode;
         if (childNode && childNode.data) {
             data = mergeClassData(childNode.data, data);
         }
     }
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while (isDef((parentNode = parentNode.parent))) {
         if (parentNode && parentNode.data) {
             data = mergeClassData(data, parentNode.data);
@@ -4808,34 +4839,34 @@ function stringifyClass(value) {
     return '';
 }
 function stringifyArray(value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
         if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += stringified;
         }
     }
     return res;
 }
 function stringifyObject(value) {
-    var res = '';
-    for (var key in value) {
+    let res = '';
+    for (const key in value) {
         if (value[key]) {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += key;
         }
     }
     return res;
 }
 
-var namespaceMap = {
+const namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4848,10 +4879,10 @@ var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isReservedTag = function (tag) {
+const isReservedTag = (tag) => {
     return isHTMLTag(tag) || isSVG(tag);
 };
 function getTagNamespace(tag) {
@@ -4864,7 +4895,7 @@ function getTagNamespace(tag) {
         return 'math';
     }
 }
-var unknownElementCache = Object.create(null);
+const unknownElementCache = Object.create(null);
 function isUnknownElement(tag) {
     /* istanbul ignore if */
     if (!inBrowser) {
@@ -4878,7 +4909,7 @@ function isUnknownElement(tag) {
     if (unknownElementCache[tag] != null) {
         return unknownElementCache[tag];
     }
-    var el = document.createElement(tag);
+    const el = document.createElement(tag);
     if (tag.indexOf('-') > -1) {
         // http://stackoverflow.com/a/28210364/1070244
         return (unknownElementCache[tag] =
@@ -4889,14 +4920,14 @@ function isUnknownElement(tag) {
         return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /**
  * Query an element selector if it's not an element already.
  */
 function query(el) {
     if (typeof el === 'string') {
-        var selected = document.querySelector(el);
+        const selected = document.querySelector(el);
         if (!selected) {
             warn('Cannot find element: ' + el);
             return document.createElement('div');
@@ -4909,7 +4940,7 @@ function query(el) {
 }
 
 function createElement(tagName, vnode) {
-    var elm = document.createElement(tagName);
+    const elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
     }
@@ -4972,45 +5003,42 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 });
 
 var ref = {
-    create: function create(_, vnode) {
+    create(_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy(vnode) {
         registerRef(vnode, true);
     },
 };
 function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
+    const key = vnode.data.ref;
     if (!isDef(key))
-        { return; }
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
     if (isRemoval) {
-        if (Array.isArray(refs[key])) {
-            // @ts-expect-error invalid typings
-            remove$2(refs[key], ref);
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
         }
-        else if (refs[key] === ref) {
+        else if (obj === ref) {
             refs[key] = undefined;
         }
     }
     else {
-        // @ts-expect-error invalid typings
         if (vnode.data.refInFor) {
-            if (!Array.isArray(refs[key])) {
+            if (!Array.isArray(obj)) {
                 refs[key] = [ref];
-                // @ts-expect-error invalid typings
             }
-            else if (refs[key].indexOf(ref) < 0) {
-                // @ts-expect-error invalid typings
-                refs[key].push(ref);
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
             }
         }
         else {
@@ -5030,41 +5058,38 @@ function registerRef(vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-var emptyNode = new VNode('', {}, []);
-var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
-        ((a.tag === b.tag &&
-            a.isComment === b.isComment &&
-            isDef(a.data) === isDef(b.data) &&
-            sameInputType(a, b)) ||
-            (isTrue(a.isAsyncPlaceholder) &&
-                a.asyncFactory === b.asyncFactory &&
-                isUndef(b.asyncFactory.error))));
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
 }
 function sameInputType(a, b) {
     if (a.tag !== 'input')
-        { return true; }
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
     return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
 function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
+    let i, key;
+    const map = {};
     for (i = beginIdx; i <= endIdx; ++i) {
         key = children[i].key;
         if (isDef(key))
-            { map[key] = i; }
+            map[key] = i;
     }
     return map;
 }
 function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5086,7 +5111,7 @@ function createPatchFunction(backend) {
         return remove;
     }
     function removeNode(el) {
-        var parent = nodeOps.parentNode(el);
+        const parent = nodeOps.parentNode(el);
         // element may have already been removed due to v-html / v-text
         if (isDef(parent)) {
             nodeOps.removeChild(parent, el);
@@ -5096,14 +5121,14 @@ function createPatchFunction(backend) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
-                config.ignoredElements.some(function (ignore) {
+                config.ignoredElements.some((ignore) => {
                     return isRegExp(ignore)
                         ? ignore.test(vnode.tag)
                         : ignore === vnode.tag;
                 })) &&
             config.isUnknownElement(vnode.tag));
     }
-    var creatingElmInVPre = 0;
+    let creatingElmInVPre = 0;
     function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
         if (isDef(vnode.elm) && isDef(ownerArray)) {
             // This vnode was used in a previous render!
@@ -5117,9 +5142,9 @@ function createPatchFunction(backend) {
         if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
             return;
         }
-        var data = vnode.data;
-        var children = vnode.children;
-        var tag = vnode.tag;
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
         if (isDef(tag)) {
             {
                 if (data && data.pre) {
@@ -5159,9 +5184,9 @@ function createPatchFunction(backend) {
         }
     }
     function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i = vnode.data;
+        let i = vnode.data;
         if (isDef(i)) {
-            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
             if (isDef((i = i.hook)) && isDef((i = i.init))) {
                 i(vnode, false /* hydrating */);
             }
@@ -5198,12 +5223,12 @@ function createPatchFunction(backend) {
         }
     }
     function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i;
+        let i;
         // hack for #4339: a reactivated component with inner transition
         // does not trigger because the inner node's created hooks are not called
         // again. It's not ideal to involve module-specific logic in here but
         // there doesn't seem to be a better way to do it.
-        var innerNode = vnode;
+        let innerNode = vnode;
         while (innerNode.componentInstance) {
             innerNode = innerNode.componentInstance._vnode;
             if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5235,7 +5260,7 @@ function createPatchFunction(backend) {
             {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
+            for (let i = 0; i < children.length; ++i) {
                 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
@@ -5250,27 +5275,27 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
             if (isDef(i.create))
-                { i.create(emptyNode, vnode); }
+                i.create(emptyNode, vnode);
             if (isDef(i.insert))
-                { insertedVnodeQueue.push(vnode); }
+                insertedVnodeQueue.push(vnode);
         }
     }
     // set scope id attribute for scoped CSS.
     // this is implemented as a special case to avoid the overhead
     // of going through the normal attribute patching process.
     function setScope(vnode) {
-        var i;
+        let i;
         if (isDef((i = vnode.fnScopeId))) {
             nodeOps.setStyleScope(vnode.elm, i);
         }
         else {
-            var ancestor = vnode;
+            let ancestor = vnode;
             while (ancestor) {
                 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                     nodeOps.setStyleScope(vnode.elm, i);
@@ -5292,13 +5317,13 @@ function createPatchFunction(backend) {
         }
     }
     function invokeDestroyHook(vnode) {
-        var i, j;
-        var data = vnode.data;
+        let i, j;
+        const data = vnode.data;
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                { i(vnode); }
+                i(vnode);
             for (i = 0; i < cbs.destroy.length; ++i)
-                { cbs.destroy[i](vnode); }
+                cbs.destroy[i](vnode);
         }
         if (isDef((i = vnode.children))) {
             for (j = 0; j < vnode.children.length; ++j) {
@@ -5308,7 +5333,7 @@ function createPatchFunction(backend) {
     }
     function removeVnodes(vnodes, startIdx, endIdx) {
         for (; startIdx <= endIdx; ++startIdx) {
-            var ch = vnodes[startIdx];
+            const ch = vnodes[startIdx];
             if (isDef(ch)) {
                 if (isDef(ch.tag)) {
                     removeAndInvokeRemoveHook(ch);
@@ -5323,8 +5348,8 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
-            var listeners = cbs.remove.length + 1;
+            let i;
+            const listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
                 // increase the listeners count
@@ -5355,19 +5380,19 @@ function createPatchFunction(backend) {
         }
     }
     function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        var oldStartIdx = 0;
-        var newStartIdx = 0;
-        var oldEndIdx = oldCh.length - 1;
-        var oldStartVnode = oldCh[0];
-        var oldEndVnode = oldCh[oldEndIdx];
-        var newEndIdx = newCh.length - 1;
-        var newStartVnode = newCh[0];
-        var newEndVnode = newCh[newEndIdx];
-        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
         // removeOnly is a special flag used only by <transition-group>
         // to ensure removed elements stay in correct relative positions
         // during leaving transitions
-        var canMove = !removeOnly;
+        const canMove = !removeOnly;
         {
             checkDuplicateKeys(newCh);
         }
@@ -5406,7 +5431,7 @@ function createPatchFunction(backend) {
             }
             else {
                 if (isUndef(oldKeyToIdx))
-                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
                 idxInOld = isDef(newStartVnode.key)
                     ? oldKeyToIdx[newStartVnode.key]
                     : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
@@ -5439,13 +5464,13 @@ function createPatchFunction(backend) {
         }
     }
     function checkDuplicateKeys(children) {
-        var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
-            var key = vnode.key;
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5454,10 +5479,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                return i;
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5468,7 +5493,7 @@ function createPatchFunction(backend) {
             // clone reused vnode
             vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        var elm = (vnode.elm = oldVnode.elm);
+        const elm = (vnode.elm = oldVnode.elm);
         if (isTrue(oldVnode.isAsyncPlaceholder)) {
             if (isDef(vnode.asyncFactory.resolved)) {
                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5489,30 +5514,30 @@ function createPatchFunction(backend) {
             vnode.componentInstance = oldVnode.componentInstance;
             return;
         }
-        var i;
-        var data = vnode.data;
+        let i;
+        const data = vnode.data;
         if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
             i(oldVnode, vnode);
         }
-        var oldCh = oldVnode.children;
-        var ch = vnode.children;
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
         if (isDef(data) && isPatchable(vnode)) {
             for (i = 0; i < cbs.update.length; ++i)
-                { cbs.update[i](oldVnode, vnode); }
+                cbs.update[i](oldVnode, vnode);
             if (isDef((i = data.hook)) && isDef((i = i.update)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
         if (isUndef(vnode.text)) {
             if (isDef(oldCh) && isDef(ch)) {
                 if (oldCh !== ch)
-                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
             }
             else if (isDef(ch)) {
                 {
                     checkDuplicateKeys(ch);
                 }
                 if (isDef(oldVnode.text))
-                    { nodeOps.setTextContent(elm, ''); }
+                    nodeOps.setTextContent(elm, '');
                 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
             }
             else if (isDef(oldCh)) {
@@ -5527,7 +5552,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
     }
     function invokeInsertHook(vnode, queue, initial) {
@@ -5537,23 +5562,21 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
+            for (let i = 0; i < queue.length; ++i) {
                 queue[i].data.hook.insert(queue[i]);
             }
         }
     }
-    var hydrationBailed = false;
+    let hydrationBailed = false;
     // list of modules that can skip create hook during hydration because they
     // are already rendered on the client or has no need for initialization
     // Note: style is excluded because it relies on initial clone for future
     // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        let i;
+        const { tag, data, children } = vnode;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5568,7 +5591,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.init)))
-                { i(vnode, true /* hydrating */); }
+                i(vnode, true /* hydrating */);
             if (isDef((i = vnode.componentInstance))) {
                 // child component. it should have hydrated its own tree.
                 initComponent(vnode, insertedVnodeQueue);
@@ -5600,11 +5623,11 @@ function createPatchFunction(backend) {
                     }
                     else {
                         // iterate and compare children lists
-                        var childrenMatch = true;
-                        var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5626,8 +5649,8 @@ function createPatchFunction(backend) {
                 }
             }
             if (isDef(data)) {
-                var fullInvoke = false;
-                for (var key in data) {
+                let fullInvoke = false;
+                for (const key in data) {
                     if (!isRenderedModule(key)) {
                         fullInvoke = true;
                         invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5659,18 +5682,18 @@ function createPatchFunction(backend) {
     return function patch(oldVnode, vnode, hydrating, removeOnly) {
         if (isUndef(vnode)) {
             if (isDef(oldVnode))
-                { invokeDestroyHook(oldVnode); }
+                invokeDestroyHook(oldVnode);
             return;
         }
-        var isInitialPatch = false;
-        var insertedVnodeQueue = [];
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
         if (isUndef(oldVnode)) {
             // empty mount (likely as component), create new root element
             isInitialPatch = true;
             createElm(vnode, insertedVnodeQueue);
         }
         else {
-            var isRealElement = isDef(oldVnode.nodeType);
+            const isRealElement = isDef(oldVnode.nodeType);
             if (!isRealElement && sameVnode(oldVnode, vnode)) {
                 // patch existing root node
                 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5702,8 +5725,8 @@ function createPatchFunction(backend) {
                     oldVnode = emptyNodeAt(oldVnode);
                 }
                 // replacing existing element
-                var oldElm = oldVnode.elm;
-                var parentElm = nodeOps.parentNode(oldElm);
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
                 // create new node
                 createElm(vnode, insertedVnodeQueue, 
                 // extremely rare edge case: do not insert if old element is in a
@@ -5712,25 +5735,25 @@ function createPatchFunction(backend) {
                 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                 // update parent placeholder node element, recursively
                 if (isDef(vnode.parent)) {
-                    var ancestor = vnode.parent;
-                    var patchable = isPatchable(vnode);
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
                             cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
+                            const insert = ancestor.data.hook.insert;
                             if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
                                 }
                             }
                         }
@@ -5768,13 +5791,13 @@ function updateDirectives(oldVnode, vnode) {
     }
 }
 function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
     for (key in newDirs) {
         oldDir = oldDirs[key];
         dir = newDirs[key];
@@ -5796,8 +5819,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithInsert.length) {
-        var callInsert = function () {
-            for (var i = 0; i < dirsWithInsert.length; i++) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
                 callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
@@ -5809,8 +5832,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
                 callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
@@ -5824,14 +5847,14 @@ function _update(oldVnode, vnode) {
         }
     }
 }
-var emptyModifiers = Object.create(null);
+const emptyModifiers = Object.create(null);
 function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
+    const res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
         return res;
     }
-    var i, dir;
+    let i, dir;
     for (i = 0; i < dirs.length; i++) {
         dir = dirs[i];
         if (!dir.modifiers) {
@@ -5845,16 +5868,17 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
+    const fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            // @ts-expect-error should it be any?
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
         }
     }
 }
@@ -5862,17 +5886,17 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 var baseModules = [ref, directives];
 
 function updateAttrs(oldVnode, vnode) {
-    var opts = vnode.componentOptions;
+    const opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
         return;
     }
     if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
         return;
     }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(attrs.__ob__)) {
         attrs = vnode.data.attrs = extend({}, attrs);
@@ -5948,7 +5972,7 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            const blocker = (e) => {
                 e.stopImmediatePropagation();
                 el.removeEventListener('input', blocker);
             };
@@ -5965,18 +5989,18 @@ var attrs = {
 };
 
 function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticClass) &&
         isUndef(data.class) &&
         (isUndef(oldData) ||
             (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
         return;
     }
-    var cls = genClassForVnode(vnode);
+    let cls = genClassForVnode(vnode);
     // handle transition classes
-    var transitionClass = el._transitionClasses;
+    const transitionClass = el._transitionClasses;
     if (isDef(transitionClass)) {
         cls = concat(cls, stringifyClass(transitionClass));
     }
@@ -5993,8 +6017,8 @@ var klass = {
 
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
-var CHECKBOX_RADIO_TOKEN = '__c';
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6004,7 +6028,7 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
+        const event = isIE ? 'change' : 'input';
         on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
         delete on[RANGE_TOKEN];
     }
@@ -6016,11 +6040,11 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target;
+let target;
 function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
+    const _target = target; // save current target element in closure
     return function onceHandler() {
-        var res = handler.apply(null, arguments);
+        const res = handler.apply(null, arguments);
         if (res !== null) {
             remove(event, onceHandler, capture, _target);
         }
@@ -6029,7 +6053,7 @@ function createOnceHandler(event, handler, capture) {
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
-var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
 function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
@@ -6038,9 +6062,9 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
-        //@ts-expect-error
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
         handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
@@ -6061,7 +6085,7 @@ function add(name, handler, capture, passive) {
             }
         };
     }
-    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
 }
 function remove(name, handler, capture, _target) {
     (_target || target).removeEventListener(name, 
@@ -6072,9 +6096,11 @@ function updateDOMListeners(oldVnode, vnode) {
     if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
         return;
     }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
     normalizeEvents(on);
     updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
     target = undefined;
@@ -6082,17 +6108,19 @@ function updateDOMListeners(oldVnode, vnode) {
 var events = {
     create: updateDOMListeners,
     update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-var svgContainer;
+let svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
         return;
     }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(props.__ob__)) {
         props = vnode.data.domProps = extend({}, props);
@@ -6109,9 +6137,9 @@ function updateDOMProps(oldVnode, vnode) {
         // on subsequent patches (#3360)
         if (key === 'textContent' || key === 'innerHTML') {
             if (vnode.children)
-                { vnode.children.length = 0; }
+                vnode.children.length = 0;
             if (cur === oldProps[key])
-                { continue; }
+                continue;
             // #6601 work around Chrome version <= 55 bug where single textNode
             // replaced by innerHTML/textContent retains its parentNode property
             if (elm.childNodes.length === 1) {
@@ -6123,7 +6151,7 @@ function updateDOMProps(oldVnode, vnode) {
             // non-string values will be stringified
             elm._value = cur;
             // avoid resetting cursor position when value is the same
-            var strCur = isUndef(cur) ? '' : String(cur);
+            const strCur = isUndef(cur) ? '' : String(cur);
             if (shouldUpdateValue(elm, strCur)) {
                 elm.value = strCur;
             }
@@ -6133,8 +6161,8 @@ function updateDOMProps(oldVnode, vnode) {
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-            var svg = svgContainer.firstChild;
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
             while (elm.firstChild) {
                 elm.removeChild(elm.firstChild);
             }
@@ -6168,7 +6196,7 @@ function shouldUpdateValue(elm, checkVal) {
 function isNotInFocusAndDirty(elm, checkVal) {
     // return true when textbox (.number and .trim) loses focus and its value is
     // not equal to the updated value
-    var notInFocus = true;
+    let notInFocus = true;
     // #6157
     // work around IE bug when accessing document.activeElement in an iframe
     try {
@@ -6178,8 +6206,8 @@ function isNotInFocusAndDirty(elm, checkVal) {
     return notInFocus && elm.value !== checkVal;
 }
 function isDirtyWithModifiers(elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
     if (isDef(modifiers)) {
         if (modifiers.number) {
             return toNumber(value) !== toNumber(newVal);
@@ -6195,13 +6223,13 @@ var domProps = {
     update: updateDOMProps,
 };
 
-var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
     cssText.split(listDelimiter).forEach(function (item) {
         if (item) {
-            var tmp = item.split(propertyDelimiter);
+            const tmp = item.split(propertyDelimiter);
             tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
         }
     });
@@ -6209,7 +6237,7 @@ var parseStyleText = cached(function (cssText) {
 });
 // merge static and dynamic style data on the same vnode
 function normalizeStyleData(data) {
-    var style = normalizeStyleBinding(data.style);
+    const style = normalizeStyleBinding(data.style);
     // static style is pre-processed into an object during compilation
     // and is always a fresh object, so it's safe to merge into it
     return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6229,10 +6257,10 @@ function normalizeStyleBinding(bindingStyle) {
  * so that parent component's style could override it
  */
 function getStyle(vnode, checkChild) {
-    var res = {};
-    var styleData;
+    const res = {};
+    let styleData;
     if (checkChild) {
-        var childNode = vnode;
+        let childNode = vnode;
         while (childNode.componentInstance) {
             childNode = childNode.componentInstance._vnode;
             if (childNode &&
@@ -6245,7 +6273,8 @@ function getStyle(vnode, checkChild) {
     if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
     }
-    var parentNode = vnode;
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6254,9 +6283,9 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-var cssVarRE = /^--/;
-var importantRE = /\s*!important$/;
-var setProp = function (el, name, val) {
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
     /* istanbul ignore if */
     if (cssVarRE.test(name)) {
         el.style.setProperty(name, val);
@@ -6265,12 +6294,12 @@ var setProp = function (el, name, val) {
         el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
     }
     else {
-        var normalizedName = normalize(name);
+        const normalizedName = normalize(name);
         if (Array.isArray(val)) {
             // Support values array created by autoprefixer, e.g.
             // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
             // Set them one by one, and the browser will only set those it can recognize
-            for (var i = 0, len = val.length; i < len; i++) {
+            for (let i = 0, len = val.length; i < len; i++) {
                 el.style[normalizedName] = val[i];
             }
         }
@@ -6279,43 +6308,43 @@ var setProp = function (el, name, val) {
         }
     }
 };
-var vendorNames = ['Webkit', 'Moz', 'ms'];
-var emptyStyle;
-var normalize = cached(function (prop) {
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
     emptyStyle = emptyStyle || document.createElement('div').style;
     prop = camelize(prop);
     if (prop !== 'filter' && prop in emptyStyle) {
         return prop;
     }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
         if (name in emptyStyle) {
             return name;
         }
     }
 });
 function updateStyle(oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticStyle) &&
         isUndef(data.style) &&
         isUndef(oldData.staticStyle) &&
         isUndef(oldData.style)) {
         return;
     }
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
     // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-    var style = normalizeStyleBinding(vnode.data.style) || {};
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
     // store normalized style under a different key for next diff
     // make sure to clone it if it's reactive, since the user likely wants
     // to mutate it.
     vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    var newStyle = getStyle(vnode, true);
+    const newStyle = getStyle(vnode, true);
     for (name in oldStyle) {
         if (isUndef(newStyle[name])) {
             setProp(el, name, '');
@@ -6334,7 +6363,7 @@ var style = {
     update: updateStyle,
 };
 
-var whitespaceRE = /\s+/;
+const whitespaceRE = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6347,14 +6376,14 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
+        const cur = ` ${el.getAttribute('class') || ''} `;
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -6372,7 +6401,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -6382,8 +6411,8 @@ function removeClass(el, cls) {
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -6403,7 +6432,7 @@ function resolveTransition(def) {
     }
     /* istanbul ignore else */
     if (typeof def === 'object') {
-        var res = {};
+        const res = {};
         if (def.css !== false) {
             extend(res, autoCssTransition(def.name || 'v'));
         }
@@ -6414,53 +6443,51 @@ function resolveTransition(def) {
         return autoCssTransition(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+const autoCssTransition = cached((name) => {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
-        // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
         transitionProp = 'WebkitTransition';
         transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
-        // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
         animationProp = 'WebkitAnimation';
         animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+const raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
+    : /* istanbul ignore next */ (fn) => fn();
 function nextFrame(fn) {
-    raf(function () {
+    raf(() => {
         // @ts-expect-error
         raf(fn);
     });
 }
 function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass(el, cls);
@@ -6473,45 +6500,42 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
     if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    var onEnd = function (e) {
+    const onEnd = (e) => {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(function () {
+    setTimeout(() => {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
+const transformRE = /\b(transform|all)(,|$)/;
 function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
+    const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
@@ -6541,12 +6565,12 @@ function getTransitionInfo(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
+        type,
+        timeout,
+        propCount,
+        hasTransform,
     };
 }
 function getTimeout(delays, durations) {
@@ -6554,7 +6578,7 @@ function getTimeout(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map(function (d, i) {
+    return Math.max.apply(null, durations.map((d, i) => {
         return toMs(d) + toMs(delays[i]);
     }));
 }
@@ -6567,13 +6591,13 @@ function toMs(s) {
 }
 
 function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -6581,57 +6605,41 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (explicitEnterDuration != null) {
         checkDuration(explicitEnterDuration, 'enter', vnode);
     }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
             removeTransitionClass(el, toClass);
             removeTransitionClass(el, activeClass);
@@ -6650,9 +6658,9 @@ function enter(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -6666,7 +6674,7 @@ function enter(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass(el, startClass);
         addTransitionClass(el, activeClass);
-        nextFrame(function () {
+        nextFrame(() => {
             removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -6691,13 +6699,13 @@ function enter(vnode, toggleDisplay) {
     }
 }
 function leave(vnode, rm) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -6705,24 +6713,14 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (isDef(explicitLeaveDuration)) {
         checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
-    var cb = (el._leaveCb = once(function () {
+    const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -6763,7 +6761,7 @@ function leave(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass(el, leaveClass);
             addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
+            nextFrame(() => {
                 removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -6788,11 +6786,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+        warn(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
     }
     else if (isNaN(val)) {
-        warn("<transition> explicit " + name + " duration is NaN - " +
+        warn(`<transition> explicit ${name} duration is NaN - ` +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -6810,7 +6808,7 @@ function getHookArgumentsLength(fn) {
         return false;
     }
     // @ts-expect-error
-    var invokerFns = fn.fns;
+    const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -6829,7 +6827,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove(vnode, rm) {
+        remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -6846,8 +6844,8 @@ var platformModules = [attrs, klass, events, domProps, style, transition];
 
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+const modules = platformModules.concat(baseModules);
+const patch = createPatchFunction({ nodeOps, modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -6856,20 +6854,20 @@ var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 /* istanbul ignore if */
 if (isIE9) {
     // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-        var el = document.activeElement;
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
         // @ts-expect-error
         if (el && el.vmodel) {
             trigger(el, 'input');
         }
     });
 }
-var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', function () {
+                mergeVNodeHook(vnode, 'postpatch', () => {
                     directive.componentUpdated(el, binding, vnode);
                 });
             }
@@ -6895,20 +6893,20 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                 // trigger change event if
                 // no matching option found for at least one value
-                var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                     : binding.value !== binding.oldValue &&
                         hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
@@ -6922,23 +6920,23 @@ function setSelected(el, binding, vm) {
     actuallySetSelected(el, binding, vm);
     /* istanbul ignore if */
     if (isIE || isEdge) {
-        setTimeout(function () {
+        setTimeout(() => {
             actuallySetSelected(el, binding, vm);
         }, 0);
     }
 }
 function actuallySetSelected(el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
+    const value = binding.value;
+    const isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
-        warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+        warn(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
                     .call(value)
-                    .slice(8, -1)), vm);
+                    .slice(8, -1)}`, vm);
         return;
     }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
         option = el.options[i];
         if (isMultiple) {
             selected = looseIndexOf(value, getValue(option)) > -1;
@@ -6960,7 +6958,7 @@ function actuallySetSelected(el, binding, vm) {
     }
 }
 function hasNoMatchingOption(value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); });
+    return options.every((o) => !looseEqual(o, value));
 }
 function getValue(option) {
     return '_value' in option ? option._value : option.value;
@@ -6971,12 +6969,12 @@ function onCompositionStart(e) {
 function onCompositionEnd(e) {
     // prevent triggering an input event for no reason
     if (!e.target.composing)
-        { return; }
+        return;
     e.target.composing = false;
     trigger(e.target, 'input');
 }
 function trigger(el, type) {
-    var e = document.createEvent('HTMLEvents');
+    const e = document.createEvent('HTMLEvents');
     e.initEvent(type, true, true);
     el.dispatchEvent(e);
 }
@@ -6989,16 +6987,14 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind(el, { value }, vnode) {
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
         if (value && transition) {
             vnode.data.show = true;
-            enter(vnode, function () {
+            enter(vnode, () => {
                 el.style.display = originalDisplay;
             });
         }
@@ -7006,24 +7002,21 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update(el, { value, oldValue }, vnode) {
         /* istanbul ignore if */
         if (!value === !oldValue)
-            { return; }
+            return;
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
+        const transition = vnode.data && vnode.data.transition;
         if (transition) {
             vnode.data.show = true;
             if (value) {
-                enter(vnode, function () {
+                enter(vnode, () => {
                     el.style.display = el.__vOriginalDisplay;
                 });
             }
             else {
-                leave(vnode, function () {
+                leave(vnode, () => {
                     el.style.display = 'none';
                 });
             }
@@ -7032,7 +7025,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7041,11 +7034,11 @@ var show = {
 
 var platformDirectives = {
     model: directive,
-    show: show,
+    show,
 };
 
 // Provides transition support for a single element/component.
-var transitionProps = {
+const transitionProps = {
     name: String,
     appear: Boolean,
     css: Boolean,
@@ -7065,7 +7058,7 @@ var transitionProps = {
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
 function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
+    const compOptions = vnode && vnode.componentOptions;
     if (compOptions && compOptions.Ctor.options.abstract) {
         return getRealChild(getFirstComponentChild(compOptions.children));
     }
@@ -7074,17 +7067,17 @@ function getRealChild(vnode) {
     }
 }
 function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
+    const data = {};
+    const options = comp.$options;
     // props
-    for (var key in options.propsData) {
+    for (const key in options.propsData) {
         data[key] = comp[key];
     }
     // events.
     // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7106,16 +7099,14 @@ function hasParentTransition(vnode) {
 function isSameChild(child, oldChild) {
     return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-var isVShowDirective = function (d) { return d.name === 'show'; };
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
 var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
-        var children = this.$slots.default;
+    render(h) {
+        let children = this.$slots.default;
         if (!children) {
             return;
         }
@@ -7130,14 +7121,14 @@ var Transition = {
             warn('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
-        var mode = this.mode;
+        const mode = this.mode;
         // warn invalid mode
         if (mode &&
             mode !== 'in-out' &&
             mode !== 'out-in') {
             warn('invalid <transition> mode: ' + mode, this.$parent);
         }
-        var rawChild = children[0];
+        const rawChild = children[0];
         // if this is a component root node and the component's
         // parent container node also has transition, skip.
         if (hasParentTransition(this.$vnode)) {
@@ -7145,7 +7136,7 @@ var Transition = {
         }
         // apply transition data to child
         // use getRealChild() to ignore abstract components e.g. keep-alive
-        var child = getRealChild(rawChild);
+        const child = getRealChild(rawChild);
         /* istanbul ignore if */
         if (!child) {
             return rawChild;
@@ -7156,7 +7147,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        const id = `__transition-${this._uid}-`;
         child.key =
             child.key == null
                 ? child.isComment
@@ -7167,9 +7158,9 @@ var Transition = {
                         ? child.key
                         : id + child.key
                     : child.key;
-        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        var oldRawChild = this._vnode;
-        var oldChild = getRealChild(oldRawChild);
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
         // mark v-show
         // so that the transition module can hand over the control to the directive
         if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7184,14 +7175,14 @@ var Transition = {
                 oldChild.componentInstance._vnode.isComment)) {
             // replace old child transition data with fresh one
             // important for dynamic transitions!
-            var oldData = (oldChild.data.transition = extend({}, data));
+            const oldData = (oldChild.data.transition = extend({}, data));
             // handle transition mode
             if (mode === 'out-in') {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7199,13 +7190,13 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
-                var performLeave = function () {
+                let delayedLeave;
+                const performLeave = () => {
                     delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
                     delayedLeave = leave;
                 });
             }
@@ -7215,67 +7206,63 @@ var Transition = {
 };
 
 // Provides transition support for list items.
-var props = extend({
+const props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
-// @ts-ignore
 delete props.mode;
 var TransitionGroup = {
-    props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
-        var update = this._update;
-        this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            this.__patch__(this._vnode, this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            this._vnode = this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(this, vnode, hydrating);
         };
     },
-    render: function render(h) {
-        var tag = this.tag || this.$vnode.data.tag || 'span';
-        var map = Object.create(null);
-        var prevChildren = (this.prevChildren = this.children);
-        var rawChildren = this.$slots.default || [];
-        var children = (this.children = []);
-        var transitionData = extractTransitionData(this);
-        for (var i = 0; i < rawChildren.length; i++) {
-            var c = rawChildren[i];
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
             if (c.tag) {
-                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                     children.push(c);
                     map[c.key] = c;
                     (c.data || (c.data = {})).transition = transitionData;
                 }
                 else {
-                    var opts = c.componentOptions;
-                    var name = opts
-                        ? opts.Ctor.options.name || opts.tag || ''
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
                         : c.tag;
-                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn(`<transition-group> children must be keyed: <${name}>`);
                 }
             }
         }
         if (prevChildren) {
-            var kept = [];
-            var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
-                // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
-                // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7283,9 +7270,9 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
-        var children = this.prevChildren;
-        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -7298,13 +7285,12 @@ var TransitionGroup = {
         // assign to this to avoid being removed in tree-shaking
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
-        children.forEach(function (c) {
-            // @ts-ignore
+        children.forEach((c) => {
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
+                const el = c.elm;
+                const s = el.style;
                 addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
                 el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                     if (e && e.target !== el) {
                         return;
@@ -7319,7 +7305,7 @@ var TransitionGroup = {
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -7333,16 +7319,16 @@ var TransitionGroup = {
             // transition at this very moment, we make a clone of it and remove
             // all other transition classes applied to ensure only the move class
             // is applied.
-            var clone = el.cloneNode();
+            const clone = el.cloneNode();
             if (el._transitionClasses) {
-                el._transitionClasses.forEach(function (cls) {
+                el._transitionClasses.forEach((cls) => {
                     removeClass(clone, cls);
                 });
             }
             addClass(clone, moveClass);
-            clone.style.display = 'none';
+            clone.style.display = "none";
             this.$el.appendChild(clone);
-            var info = getTransitionInfo(clone);
+            const info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
             return (this._hasMove = info.hasTransform);
         },
@@ -7350,42 +7336,33 @@ var TransitionGroup = {
 };
 function callPendingCbs(c) {
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._moveCb) {
-        //@ts-ignore
         c.elm._moveCb();
     }
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._enterCb) {
-        //@ts-ignore
         c.elm._enterCb();
     }
 }
 function recordPosition(c) {
-    //@ts-ignore
     c.data.newPos = c.elm.getBoundingClientRect();
 }
 function applyTranslation(c) {
-    //@ts-ignore
-    var oldPos = c.data.pos;
-    //@ts-ignore
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
     if (dx || dy) {
-        //@ts-ignore
         c.data.moved = true;
-        //@ts-ignore
-        var s = c.elm.style;
-        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-        s.transitionDuration = '0s';
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
     }
 }
 
 var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
+    Transition,
+    TransitionGroup,
 };
 
 // install platform specific utils
@@ -7407,7 +7384,7 @@ Vue.prototype.$mount = function (el, hydrating) {
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-    setTimeout(function () {
+    setTimeout(() => {
         if (config.devtools) {
             if (devtools) {
                 devtools.emit('init', Vue);
@@ -7421,9 +7398,9 @@ if (inBrowser) {
         if (config.productionTip !== false &&
             typeof console !== 'undefined') {
             // @ts-expect-error
-            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                "Make sure to turn on production mode when deploying for production.\n" +
-                "See more tips at https://vuejs.org/guide/deployment.html");
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
         }
     }, 0);
 }
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
index b5d208fc75d..4f83392cd33 100644
--- a/dist/vue.runtime.common.prod.js
+++ b/dist/vue.runtime.common.prod.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,$=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every((function(t,n){return j(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return j(t[n],e[n])}))}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D=["component","directive","filter"],N=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:N};function L(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function M(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var F=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var R="__proto__"in{},U="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),V=U&&window.navigator.userAgent.toLowerCase(),z=V&&/msie|trident/.test(V),W=V&&V.indexOf("msie 9.0")>0,q=V&&V.indexOf("edge/")>0;V&&V.indexOf("android");var K=V&&/iphone|ipad|ipod|ios/.test(V)||"ios"===H;V&&/chrome\/\d+/.test(V),V&&/phantomjs/.test(V);var X,G=V&&V.match(/firefox\/(\d+)/),Z={}.watch,J=!1;if(U)try{var Q={};Object.defineProperty(Q,"passive",{get:function(){J=!0}}),window.addEventListener("test-passive",null,Q)}catch(t){}var Y=function(){return void 0===X&&(X=!U&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),X},tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}var nt,rt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);nt="undefined"!=typeof Set&&et(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var ot=k,it=0,at=function(){this.id=it++,this.subs=[]};at.prototype.addSub=function(t){this.subs.push(t)},at.prototype.removeSub=function(t){v(this.subs,t)},at.prototype.depend=function(){at.target&&at.target.addDep(this)},at.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},at.target=null;var st=[];function ct(t){st.push(t),at.target=t}function ut(){st.pop(),at.target=st[st.length-1]}var lt=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},ft={child:{configurable:!0}};ft.child.get=function(){return this.componentInstance},Object.defineProperties(lt.prototype,ft);var pt=function(t){void 0===t&&(t="");var e=new lt;return e.text=t,e.isComment=!0,e};function dt(t){return new lt(void 0,void 0,void 0,String(t))}function vt(t){var e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=ht[t];M(mt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i}))}));var yt=Object.getOwnPropertyNames(mt),gt=!0;function _t(t){gt=t}var bt=function(t){this.value=t,this.dep=new at,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?function(t,e){t.__proto__=e}(t,mt):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];M(t,i,e[i])}}(t,mt,yt),this.observeArray(t)):this.walk(t)};function Ct(t,e){var n;if(i(t)&&!(t instanceof lt))return m(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:gt&&!Y()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,r,o){var i=new at,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&Ct(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return at.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&xt(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&Ct(e),i.notify())}})}}function wt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?($t(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function At(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function xt(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&xt(e)}bt.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)$t(t,e[n])},bt.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)Ct(t[e])};var Ot=P.optionMergeStrategies;function kt(t,e){if(!e)return t;for(var n,r,o,i=rt?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&kt(r,o):wt(t,n,o));return t}function St(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?kt(r,o):o}:e?t?function(){return kt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Et(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function jt(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}Ot.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},N.forEach((function(t){Ot[t]=Et})),D.forEach((function(t){Ot[t+"s"]=jt})),Ot.watch=function(t,e,n,r){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},Ot.props=Ot.methods=Ot.inject=Ot.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},Ot.provide=St;var Tt=function(t,e){return void 0===e?t:e};function It(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=It(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=It(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=Ot[r]||Tt;a[r]=o(t[r],e[r],n,r)}return a}function Dt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Nt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Ft(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Ft(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Lt(e.type)?r.call(t):r}(r,o,t);var u=gt;_t(!0),Ct(a),_t(u)}return a}var Pt=/^\s*function (\w+)/;function Lt(t){var e=t&&t.toString().match(Pt);return e?e[1]:""}function Mt(t,e){return Lt(t)===Lt(e)}function Ft(t,e){if(!Array.isArray(e))return Mt(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Mt(e[n],t))return n;return-1}function Rt(t,e,n){ct();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{ut()}}function Ut(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch((function(t){return Rt(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(t){Rt(t,r,o)}return i}function Bt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!U&&!B||"undefined"==typeof console)throw t;console.error(t)}var Vt,zt=!1,Wt=[],qt=!1;function Kt(){qt=!1;var t=Wt.slice(0);Wt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){var Xt=Promise.resolve();Vt=function(){Xt.then(Kt),K&&setTimeout(k)},zt=!0}else if(z||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Vt="undefined"!=typeof setImmediate&&et(setImmediate)?function(){setImmediate(Kt)}:function(){setTimeout(Kt,0)};else{var Gt=1,Zt=new MutationObserver(Kt),Jt=document.createTextNode(String(Gt));Zt.observe(Jt,{characterData:!0}),Vt=function(){Gt=(Gt+1)%2,Jt.data=String(Gt)},zt=!0}function Qt(t,e){var n;if(Wt.push((function(){if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Vt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var Yt=new nt;function te(t){ee(t,Yt),Yt.clear()}function ee(t,e){var n,r,o=Array.isArray(t);if(!(!o&&!i(t)||Object.isFrozen(t)||t instanceof lt)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(o)for(n=t.length;n--;)ee(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ee(t[r[n]],e)}}var ne=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function re(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Ut(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Ut(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function oe(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=ne(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=re(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=ne(c)).name,n[c],f.capture)}function ie(t,o,i){var a;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=re([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=re([s,c]),a.merged=!0,t[o]=a}function ae(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function se(t){return o(t)?[dt(t)]:Array.isArray(t)?ue(t):void 0}function ce(t){return n(t)&&n(t.text)&&!1===t.isComment}function ue(t,i){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ce((s=ue(s,(i||"")+"_"+a))[0])&&ce(u)&&(l[c]=dt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):o(s)?ce(u)?l[c]=dt(u.text+s):""!==s&&l.push(dt(s)):ce(s)&&ce(u)?l[c]=dt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(i)&&(s.key="__vlist"+i+"_"+a+"__"),l.push(s)));return l}function le(t,e){if(t){for(var n=Object.create(null),r=rt?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function fe(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(pe)&&delete n[u];return n}function pe(t){return t.isComment&&!t.asyncFactory||" "===t.text}function de(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=ve(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=he(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),M(o,"$stable",a),M(o,"$key",s),M(o,"$hasNormal",i),o}function ve(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:se(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function he(t,e){return function(){return t[e]}}function me(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(rt&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ye(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function ge(t){return Dt(this.$options,"filters",t)||E}function _e(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function be(t,e,n,r,o){var i=P.keyCodes[e]||n;return o&&r&&!P.keyCodes[e]?_e(o,r):i?_e(i,t):r?$(r)!==e:void 0}function Ce(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||P.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function $e(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||Ae(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function we(t,e,n){return Ae(t,"__once__"+e+(n?"_"+n:""),!0),t}function Ae(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&xe(t[r],e+"_"+r,n);else xe(t,e,n)}function xe(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Oe(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function ke(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?ke(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Se(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function Ee(t,e){return"string"==typeof t?e+t:t}function je(t){t._o=we,t._n=f,t._s=l,t._l=me,t._t=ye,t._q=j,t._i=T,t._m=$e,t._f=ge,t._k=be,t._b=Ce,t._v=dt,t._e=pt,t._u=ke,t._g=Oe,t._d=Se,t._p=Ee}function Te(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=le(u.inject,i),this.slots=function(){return c.$slots||de(e.scopedSlots,c.$slots=fe(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return de(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=de(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Fe(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Fe(s,t,e,n,r,f)}}function Ie(t,e,n,r,o){var i=vt(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function De(t,e){for(var n in e)t[_(n)]=e[n]}je(Te.prototype);var Ne={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Ne.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ge)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){_t(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Nt(d,v,n,e)}_t(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Xe(e,r,h),u&&(e.$slots=fe(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,tn(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,nn.push(e)):Qe(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?Ye(e,!0):e.$destroy())}},Pe=Object.keys(Ne);function Le(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I((function(e){t.resolved=He(e,o),c?s.length=0:p(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,p(!0))})),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=He(m.error,o)),n(m.loading)&&(t.loadingComp=He(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=pt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},wn(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);ae(a,c,u,l,!0)||ae(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Nt(l,u,r||t);else n(o.attrs)&&De(c,o.attrs),n(o.props)&&De(c,o.props);var f=new Te(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof lt)return Ie(p,o,f.parent,s);if(Array.isArray(p)){for(var d=se(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=Ie(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Pe.length;n++){var r=Pe[n],o=e[r],i=Ne[r];o===i||o&&o._merged||(e[r]=o?Me(i,o):i)}}(a);var y=o.options.name||l;return new lt("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function Me(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Fe(t,e,a,s,c,u){return(Array.isArray(a)||o(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,o,a){if(n(r)&&n(r.__ob__))return pt();n(r)&&n(r.is)&&(e=r.is);if(!e)return pt();Array.isArray(o)&&"function"==typeof o[0]&&((r=r||{}).scopedSlots={default:o[0]},o.length=0);2===a?o=se(o):1===a&&(o=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(o));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||P.getTagNamespace(e),s=P.isReservedTag(e)?new lt(P.parsePlatformTagName(e),r,o,void 0,void 0,t):r&&r.pre||!n(u=Dt(t.$options,"components",e))?new lt(e,r,o,void 0,void 0,t):Le(u,r,t,o,e)}else s=Le(e,r,t,o);return Array.isArray(s)?s:n(s)?(n(c)&&Re(s,c),n(r)&&function(t){i(t.style)&&te(t.style);i(t.class)&&te(t.class)}(r),s):pt()}(t,e,a,s,c)}function Re(t,o,i){if(t.ns=o,"foreignObject"===t.tag&&(o=void 0,i=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(i)&&"svg"!==c.tag)&&Re(c,o,i)}}var Ue,Be=null;function He(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function Ve(t){return t.isComment&&t.asyncFactory}function ze(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||Ve(r)))return r}}function We(t,e){Ue.$on(t,e)}function qe(t,e){Ue.$off(t,e)}function Ke(t,e){var n=Ue;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function Xe(t,e,n){Ue=t,oe(e,n||{},We,qe,Ke,t),Ue=void 0}var Ge=null;function Ze(t){var e=Ge;return Ge=t,function(){Ge=e}}function Je(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Qe(t,e){if(e){if(t._directInactive=!1,Je(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Qe(t.$children[n]);tn(t,"activated")}}function Ye(t,e){if(!(e&&(t._directInactive=!0,Je(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);tn(t,"deactivated")}}function tn(t,e){ct();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Ut(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),ut()}var en=[],nn=[],rn={},on=!1,an=!1,sn=0;var cn=0,un=Date.now;if(U&&!z){var ln=window.performance;ln&&"function"==typeof ln.now&&un()>document.createEvent("Event").timeStamp&&(un=function(){return ln.now()})}function fn(){var t,e;for(cn=un(),an=!0,en.sort((function(t,e){return t.id-e.id})),sn=0;sn<en.length;sn++)(t=en[sn]).before&&t.before(),e=t.id,rn[e]=null,t.run();var n=nn.slice(),r=en.slice();sn=en.length=nn.length=0,rn={},on=an=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Qe(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&tn(r,"updated")}}(r),tt&&P.devtools&&tt.emit("flush")}var pn=0,dn=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++pn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!F.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};dn.prototype.get=function(){var t;ct(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&te(t),ut(),this.cleanupDeps()}return t},dn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},dn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},dn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==rn[e]){if(rn[e]=!0,an){for(var n=en.length-1;n>sn&&en[n].id>t.id;)n--;en.splice(n+1,0,t)}else en.push(t);on||(on=!0,Qt(fn))}}(this)},dn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Rt(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},dn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},dn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},dn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var vn={enumerable:!0,configurable:!0,get:k,set:k};function hn(t,e,n){vn.get=function(){return this[e][n]},vn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,vn)}function mn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&_t(!1);var i=function(i){o.push(i);var a=Nt(i,e,n,t);$t(r,i,a),i in t||hn(t,"_props",i)};for(var a in e)i(a);_t(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||L(i)||hn(t,"_data",i)}Ct(e,!0)}(t):Ct(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=Y();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new dn(t,a||k,k,yn)),o in t||gn(t,o,i)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)Cn(t,n,r[o]);else Cn(t,n,r)}}(t,e.watch)}var yn={lazy:!0};function gn(t,e,n){var r=!Y();"function"==typeof n?(vn.get=r?_n(e):bn(n),vn.set=k):(vn.get=n.get?r&&!1!==n.cache?_n(e):bn(n.get):k,vn.set=n.set||k),Object.defineProperty(t,e,vn)}function _n(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function bn(t){return function(){return t.call(this,this)}}function Cn(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var $n=0;function wn(t){var e=t.options;if(t.super){var n=wn(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=It(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function An(t){this._init(t)}function xn(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=It(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)hn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)gn(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,D.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function On(t){return t&&(t.Ctor.options.name||t.tag)}function kn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function Sn(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=On(a.componentOptions);s&&!e(s)&&En(n,i,r,o)}}}function En(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=$n++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=It(wn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Xe(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=fe(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Fe(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Fe(e,t,n,r,o,!0)};var i=r&&r.data;$t(e,"$attrs",i&&i.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),tn(n,"beforeCreate"),function(t){var e=le(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach((function(n){$t(t,n,e[n])})),_t(!0))}(n),mn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),tn(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(An),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=wt,t.prototype.$delete=At,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return Cn(r,t,e,n);(n=n||{}).user=!0;var o=new dn(r,t,e,n);if(n.immediate){ct();try{e.call(r,o.value)}catch(t){Rt(t,r,'callback for immediate watcher "'+o.expression+'"')}ut()}return function(){o.teardown()}}}(An),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),o='event handler for "'+t+'"',i=0,a=n.length;i<a;i++)Ut(n[i],e,r,e,o)}return e}}(An),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Ze(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){tn(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),tn(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(An),function(t){je(t.prototype),t.prototype.$nextTick=function(t){return Qt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=de(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Rt(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof lt||(t=pt()),t.parent=o,t}}(An);var jn=[String,RegExp,Array],Tn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:jn,exclude:jn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)En(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){Sn(t,(function(t){return kn(e,t)}))})),this.$watch("exclude",(function(e){Sn(t,(function(t){return!kn(e,t)}))}))},render:function(){var t=this.$slots.default,e=ze(t),n=e&&e.componentOptions;if(n){var r=On(n),o=this.include,i=this.exclude;if(o&&(!r||!kn(o,r))||i&&r&&kn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&En(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return P}};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:It,defineReactive:$t},t.set=wt,t.delete=At,t.nextTick=Qt,t.observable=function(t){return Ct(t),t},t.options=Object.create(null),D.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,Tn),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=It(this.options,t),this}}(t),xn(t),function(t){D.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(An),Object.defineProperty(An.prototype,"$isServer",{get:Y}),Object.defineProperty(An.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(An,"FunctionalRenderContext",{value:Te}),An.version="2.6.12";var In=p("style,class"),Dn=p("input,textarea,option,select,progress"),Nn=p("contenteditable,draggable,spellcheck"),Pn=p("events,caret,typing,plaintext-only"),Ln=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Mn="http://www.w3.org/1999/xlink",Fn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Rn=function(t){return Fn(t)?t.slice(6,t.length):""},Un=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Hn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return Vn(t,zn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:Vn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Vn(t,e){return t?e?t+" "+e:t:e||""}function zn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=zn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var Wn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},qn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Kn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Xn=function(t){return qn(t)||Kn(t)};var Gn=Object.create(null);var Zn=p("text,number,password,search,email,tel,url");var Jn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Wn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Qn={create:function(t,e){Yn(e)},update:function(t,e){t.data.ref!==e.data.ref&&(Yn(t,!0),Yn(e))},destroy:function(t){Yn(t,!0)}};function Yn(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var tr=new lt("",{},[]),er=["create","activate","update","remove","destroy"];function nr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Zn(o)&&Zn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function rr(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var or={create:ir,update:ir,destroy:function(t){ir(t,tr)}};function ir(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===tr,a=e===tr,s=sr(t.data.directives,t.context),c=sr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,ur(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(ur(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)ur(u[n],"inserted",e,t)};i?ie(e,"insert",f):f()}l.length&&ie(e,"postpatch",(function(){for(var n=0;n<l.length;n++)ur(l[n],"componentUpdated",e,t)}));if(!i)for(n in s)c[n]||ur(s[n],"unbind",t,t,a)}(t,e)}var ar=Object.create(null);function sr(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=ar),o[cr(r)]=r,r.def=Dt(e.$options,"directives",r.name);return o}function cr(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function ur(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Rt(r,n.context,"directive "+t.name+" "+e+" hook")}}var lr=[Qn,or];function fr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&pr(s,i,a,r.data.pre);for(i in(z||q)&&u.value!==c.value&&pr(s,"value",u.value),c)e(u[i])&&(Fn(i)?s.removeAttributeNS(Mn,Rn(i)):Nn(i)||s.removeAttribute(i))}}function pr(t,e,n,r){r||t.tagName.indexOf("-")>-1?dr(t,e,n):Ln(e)?Un(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,function(t,e){return Un(e)||"false"===e?"false":"contenteditable"===t&&Pn(e)?e:"true"}(e,n)):Fn(e)?Un(n)?t.removeAttributeNS(Mn,Rn(e)):t.setAttributeNS(Mn,e,n):dr(t,e,n)}function dr(t,e,n){if(Un(n))t.removeAttribute(e);else{if(z&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var vr={create:fr,update:fr};function hr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=o._transitionClasses;n(c)&&(s=Vn(s,zn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var mr,yr={create:hr,update:hr};function gr(t,e,n){var r=mr;return function o(){var i=e.apply(null,arguments);null!==i&&Cr(t,o,n,r)}}var _r=zt&&!(G&&Number(G[1])<=53);function br(t,e,n,r){if(_r){var o=cn,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}mr.addEventListener(t,e,J?{capture:n,passive:r}:n)}function Cr(t,e,n,r){(r||mr).removeEventListener(t,e._wrapper||e,n)}function $r(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};mr=r.elm,function(t){if(n(t.__r)){var e=z?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(o),oe(o,i,br,Cr,gr,r.context),mr=void 0}}var wr,Ar={create:$r,update:$r};function xr(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);Or(a,u)&&(a.value=u)}else if("innerHTML"===o&&Kn(a.tagName)&&e(a.innerHTML)){(wr=wr||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=wr.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function Or(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var kr={create:xr,update:xr},Sr=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function Er(t){var e=jr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function jr(t){return Array.isArray(t)?O(t):"string"==typeof t?Sr(t):t}var Tr,Ir=/^--/,Dr=/\s*!important$/,Nr=function(t,e,n){if(Ir.test(e))t.style.setProperty(e,n);else if(Dr.test(n))t.style.setProperty($(e),n.replace(Dr,""),"important");else{var r=Lr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Pr=["Webkit","Moz","ms"],Lr=y((function(t){if(Tr=Tr||document.createElement("div").style,"filter"!==(t=_(t))&&t in Tr)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Pr.length;n++){var r=Pr[n]+e;if(r in Tr)return r}}));function Mr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=jr(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=Er(o.data))&&x(r,n);(n=Er(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=Er(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Nr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Nr(c,s,null==a?"":a)}}var Fr={create:Mr,update:Mr},Rr=/\s+/;function Ur(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Br(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Rr).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Hr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,Vr(t.name||"v")),x(e,t),e}return"string"==typeof t?Vr(t):void 0}}var Vr=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),zr=U&&!W,Wr="transition",qr="transitionend",Kr="animation",Xr="animationend";zr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Wr="WebkitTransition",qr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Kr="WebkitAnimation",Xr="webkitAnimationEnd"));var Gr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Zr(t){Gr((function(){Gr(t)}))}function Jr(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Ur(t,e))}function Qr(t,e){t._transitionClasses&&v(t._transitionClasses,e),Br(t,e)}function Yr(t,e,n){var r=eo(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s="transition"===o?qr:Xr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var to=/\b(transform|all)(,|$)/;function eo(t,e){var n,r=window.getComputedStyle(t),o=(r[Wr+"Delay"]||"").split(", "),i=(r[Wr+"Duration"]||"").split(", "),a=no(o,i),s=(r[Kr+"Delay"]||"").split(", "),c=(r[Kr+"Duration"]||"").split(", "),u=no(s,c),l=0,f=0;return"transition"===e?a>0&&(n="transition",l=a,f=i.length):"animation"===e?u>0&&(n="animation",l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?"transition":"animation":null)?"transition"===n?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:"transition"===n&&to.test(r[Wr+"Property"])}}function no(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return ro(e)+ro(t[n])})))}function ro(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function oo(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Hr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ge,O=Ge.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!W,F=so(D),R=o._enterCb=I((function(){M&&(Qr(o,j),Qr(o,E)),R.cancelled?(M&&Qr(o,S),P&&P(o)):N&&N(o),o._enterCb=null}));t.data.show||ie(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),T&&T(o),M&&(Jr(o,S),Jr(o,E),Zr((function(){Qr(o,S),R.cancelled||(Jr(o,j),F||(ao(L)?setTimeout(R,L):Yr(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function io(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Hr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!W,b=so(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(Qr(o,l),Qr(o,p)),$.cancelled?(_&&Qr(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(Jr(o,u),Jr(o,p),Zr((function(){Qr(o,u),$.cancelled||(Jr(o,l),b||(ao(C)?setTimeout($,C):Yr(o,c,$)))}))),v&&v(o,$),_||b||$())}}function ao(t){return"number"==typeof t&&!isNaN(t)}function so(t){if(e(t))return!1;var r=t.fns;return n(r)?so(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function co(t,e){!0!==e.data.show&&oo(e)}var uo=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<er.length;++i)for(s[er[i]]=[],a=0;a<c.length;++a)n(c[a][er[i]])&&s[er[i]].push(c[a][er[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=vt(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){var i,a=t;for(;a.componentInstance;)if(n(i=(a=a.componentInstance._vnode).data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](tr,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(Yn(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](tr,t);n(i=t.data.hook)&&(n(i.create)&&i.create(tr,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ge)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&nr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=vt(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:nr(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):nr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):nr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):nr(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=rr(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):nr(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&te(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&nr(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new lt(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](tr,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else Yn(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Jn,modules:[vr,yr,Ar,kr,Fr,U?{create:co,activate:co,remove:function(t,e){!0!==t.data.show?io(t,e):e()}}:{}].concat(lr)});W&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&go(t,"input")}));var lo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ie(n,"postpatch",(function(){lo.componentUpdated(t,e,n)})):fo(t,e,n.context),t._vOptions=[].map.call(t.options,ho)):("textarea"===n.tag||Zn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",mo),t.addEventListener("compositionend",yo),t.addEventListener("change",yo),W&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){fo(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,ho);if(o.some((function(t,e){return!j(t,r[e])})))(t.multiple?e.value.some((function(t){return vo(t,o)})):e.value!==e.oldValue&&vo(e.value,o))&&go(t,"change")}}};function fo(t,e,n){po(t,e),(z||q)&&setTimeout((function(){po(t,e)}),0)}function po(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,ho(a))>-1,a.selected!==i&&(a.selected=i);else if(j(ho(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function vo(t,e){return e.every((function(e){return!j(e,t)}))}function ho(t){return"_value"in t?t._value:t.value}function mo(t){t.target.composing=!0}function yo(t){t.target.composing&&(t.target.composing=!1,go(t.target,"input"))}function go(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function _o(t){return!t.componentInstance||t.data&&t.data.transition?t:_o(t.componentInstance._vnode)}var bo={model:lo,show:{bind:function(t,e,n){var r=e.value,o=(n=_o(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,oo(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=_o(n)).data&&n.data.transition?(n.data.show=!0,r?oo(n,(function(){t.style.display=t.__vOriginalDisplay})):io(n,(function(){t.style.display="none"}))):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Co={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function $o(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?$o(ze(e.children)):t}function wo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function Ao(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var xo=function(t){return t.tag||Ve(t)},Oo=function(t){return"show"===t.name},ko={name:"transition",props:Co,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(xo)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=$o(i);if(!a)return i;if(this._leaving)return Ao(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=wo(this),u=this._vnode,l=$o(u);if(a.data.directives&&a.data.directives.some(Oo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!Ve(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ie(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),Ao(t,i);if("in-out"===r){if(Ve(a))return u;var p,d=function(){p()};ie(c,"afterEnter",d),ie(c,"enterCancelled",d),ie(f,"delayLeave",(function(t){p=t}))}}return i}}},So=x({tag:String,moveClass:String},Co);function Eo(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function jo(t){t.data.newPos=t.elm.getBoundingClientRect()}function To(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete So.mode;var Io={Transition:ko,TransitionGroup:{props:So,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Ze(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=wo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Eo),t.forEach(jo),t.forEach(To),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;Jr(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(qr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(qr,t),n._moveCb=null,Qr(n,e))})}})))},methods:{hasMove:function(t,e){if(!zr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){Br(n,t)})),Ur(n,e),n.style.display="none",this.$el.appendChild(n);var r=eo(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};An.config.mustUseProp=function(t,e,n){return"value"===n&&Dn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},An.config.isReservedTag=Xn,An.config.isReservedAttr=In,An.config.getTagNamespace=function(t){return Kn(t)?"svg":"math"===t?"math":void 0},An.config.isUnknownElement=function(t){if(!U)return!0;if(Xn(t))return!1;if(t=t.toLowerCase(),null!=Gn[t])return Gn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Gn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Gn[t]=/HTMLUnknownElement/.test(e.toString())},x(An.options.directives,bo),x(An.options.components,Io),An.prototype.__patch__=U?uo:k,An.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=pt),tn(t,"beforeMount"),r=function(){t._update(t._render(),n)},new dn(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&tn(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,tn(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((function(){P.devtools&&tt&&tt.emit("init",An)}),0),module.exports=An;
\ No newline at end of file
+"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("key,ref,slot,slot-scope,is");function h(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const m=Object.prototype.hasOwnProperty;function y(t,e){return m.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const g=/-(\w)/g,_=v((t=>t.replace(g,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),$=/\B([A-Z])/g,C=v((t=>t.replace($,"-$1").toLowerCase()));const w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function x(t,e){for(const n in e)t[n]=e[n];return t}function k(t){const e={};for(let n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}const S=(t,e,n)=>!1,E=t=>t;function T(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>T(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>T(t[n],e[n])))}}catch(t){return!1}}function I(t,e){for(let n=0;n<t.length;n++)if(T(t[n],e))return n;return-1}function j(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const D=["component","directive","filter"],N=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:N};function L(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function M(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const F=new RegExp(`[^${/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source}.$_\\d]`);const R="__proto__"in{},V="undefined"!=typeof window,U="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,z=U&&WXEnvironment.platform.toLowerCase(),B=V&&window.navigator.userAgent.toLowerCase(),H=B&&/msie|trident/.test(B),W=B&&B.indexOf("msie 9.0")>0,q=B&&B.indexOf("edge/")>0;B&&B.indexOf("android");const K=B&&/iphone|ipad|ipod|ios/.test(B)||"ios"===z;B&&/chrome\/\d+/.test(B),B&&/phantomjs/.test(B);const X=B&&B.match(/firefox\/(\d+)/),G={}.watch;let Z,J=!1;if(V)try{const t={};Object.defineProperty(t,"passive",{get(){J=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const Q=()=>(void 0===Z&&(Z=!V&&!U&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Z),Y=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function tt(t){return"function"==typeof t&&/native code/.test(t.toString())}const et="undefined"!=typeof Symbol&&tt(Symbol)&&"undefined"!=typeof Reflect&&tt(Reflect.ownKeys);let nt;nt="undefined"!=typeof Set&&tt(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let ot=O,rt=0;class st{static target;id;subs;constructor(){this.id=rt++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){h(this.subs,t)}depend(){st.target&&st.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}st.target=null;const it=[];function at(t){it.push(t),st.target=t}function ct(){it.pop(),st.target=it[it.length-1]}class lt{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const ut=(t="")=>{const e=new lt;return e.text=t,e.isComment=!0,e};function ft(t){return new lt(void 0,void 0,void 0,String(t))}function dt(t){const e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const pt=Array.prototype,ht=Object.create(pt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=pt[t];M(ht,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const mt=Object.getOwnPropertyNames(ht);let yt=!0;function vt(t){yt=t}class gt{value;dep;vmCount;constructor(t){this.value=t,this.dep=new st,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?function(t,e){t.__proto__=e}(t,ht):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];M(t,r,e[r])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)bt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)_t(t[e])}}function _t(t,e){if(!s(t)||t instanceof lt)return;let n;return y(t,"__ob__")&&t.__ob__ instanceof gt?n=t.__ob__:yt&&!Q()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new gt(t)),e&&n&&n.vmCount++,n}function bt(t,e,n,o,r){const s=new st,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&_t(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return st.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&wt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&_t(e),s.notify())}})}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(bt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function Ct(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||y(t,e)&&(delete t[e],n&&n.dep.notify())}function wt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&wt(e)}const At=P.optionMergeStrategies;function xt(t,e){if(!e)return t;let n,o,r;const s=et?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],y(t,n)?o!==r&&a(o)&&a(r)&&xt(o,r):$t(t,n,r));return t}function kt(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?xt(o,r):r}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Ot(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,o){const r=Object.create(t||null);return e?x(r,e):r}At.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},N.forEach((t=>{At[t]=Ot})),D.forEach((function(t){At[t+"s"]=St})),At.watch=function(t,e,n,o){if(t===G&&(t=void 0),e===G&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};x(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return x(r,t),e&&x(r,e),r},At.provide=kt;const Et=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?x({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=Tt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)y(t,r)||s(r);function s(r){const s=At[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function It(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(y(r,n))return r[n];const s=_(n);if(y(r,s))return r[s];const i=b(s);if(y(r,i))return r[i];return r[n]||r[s]||r[i]}function jt(t,e,n,o){const r=e[t],s=!y(n,t);let i=n[t];const a=Lt(Boolean,r.type);if(a>-1)if(s&&!y(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Lt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!y(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Nt(e.type)?o.call(t):o}(o,r,t);const e=yt;vt(!0),_t(i),vt(e)}return i}const Dt=/^\s*function (\w+)/;function Nt(t){const e=t&&t.toString().match(Dt);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){at();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Rt(t,o,"errorCaptured hook")}}}Rt(t,e,n)}finally{ct()}}function Ft(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Mt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Mt(t,o,r)}return s}function Rt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Vt(e)}Vt(t)}function Vt(t,e,n){if(!V&&!U||"undefined"==typeof console)throw t;console.error(t)}let Ut=!1;const zt=[];let Bt,Ht=!1;function Wt(){Ht=!1;const t=zt.slice(0);zt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&tt(Promise)){const t=Promise.resolve();Bt=()=>{t.then(Wt),K&&setTimeout(O)},Ut=!0}else if(H||"undefined"==typeof MutationObserver||!tt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&tt(setImmediate)?()=>{setImmediate(Wt)}:()=>{setTimeout(Wt,0)};else{let t=1;const e=new MutationObserver(Wt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Bt=()=>{t=(t+1)%2,n.data=String(t)},Ut=!0}function qt(t,e){let n;if(zt.push((()=>{if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)})),Ht||(Ht=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Kt=new nt;function Xt(t){Gt(t,Kt),Kt.clear()}function Gt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof lt)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Gt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Gt(t[o[n]],e)}}const Zt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Jt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ft(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ft(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function Qt(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Zt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Jt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Zt(c),s(f.name,n[c],f.capture))}function Yt(t,r,s){let i;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),h(i.fns,c)}e(a)?i=Jt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Jt([a,c]),i.merged=!0,t[r]=i}function te(t,e,o,r,s){if(n(e)){if(y(e,o))return t[o]=e[o],s||delete e[o],!0;if(y(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function ee(t){return r(t)?[ft(t)]:Array.isArray(t)?oe(t):void 0}function ne(t){return n(t)&&n(t.text)&&!1===t.isComment}function oe(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=oe(c,`${s||""}_${a}`),ne(c[0])&&ne(u)&&(i[l]=ft(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?ne(u)?i[l]=ft(u.text+c):""!==c&&i.push(ft(c)):ne(c)&&ne(u)?i[l]=ft(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function re(t,e){if(t){const n=Object.create(null),o=et?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&y(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function se(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ie)&&delete n[t];return n}function ie(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ae(t){return t.isComment&&t.asyncFactory}function ce(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=le(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=ue(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),M(r,"$stable",i),M(r,"$key",a),M(r,"$hasNormal",s),r}function le(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ee(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!ae(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function ue(t,e){return()=>t[e]}function fe(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(et&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function de(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=x(x({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function pe(t){return It(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,o,r){const s=P.keyCodes[e]||n;return r&&o&&!P.keyCodes[e]?he(r,o):s?he(s,t):o?C(o)!==e:void 0===t}function ye(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=k(n));for(const i in n){if("class"===i||"style"===i||p(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||P.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function ve(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),_e(o,`__static__${t}`,!1)),o}function ge(t,e,n){return _e(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function _e(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&be(t[o],`${e}_${o}`,n);else be(t,e,n)}function be(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(a(e)){const n=t.on=t.on?x({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function Ce(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?Ce(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function we(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function xe(t){t._o=ge,t._n=f,t._s=u,t._l=fe,t._t=de,t._q=T,t._i=I,t._m=ve,t._f=pe,t._k=me,t._b=ye,t._v=ft,t._e=ut,t._u=Ce,t._g=$e,t._d=we,t._p=Ae}function ke(e,n,r,s,i){const a=i.options;let c;y(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=re(a.inject,s),this.slots=()=>(this.$slots||ce(e.scopedSlots,this.$slots=se(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ce(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ce(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=De(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>De(c,t,e,n,o,u)}function Oe(t,e,n,o,r){const s=dt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Se(t,e){for(const n in e)t[_(n)]=e[n]}xe(ke.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Be)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){vt(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=jt(s,i,n,e)}vt(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,ze(e,o,u),l&&(e.$slots=se(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Xe(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ze.push(o)):qe(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ke(e,!0):e.$destroy())}},Te=Object.keys(Ee);function Ie(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Le;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>h(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=j((e=>{t.resolved=Me(e,r),a?o.length=0:f(!0)})),p=j((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),m=t(d,p);return s(m)&&(l(m)?e(t.resolved)&&m.then(d,p):l(m.component)&&(m.component.then(d,p),n(m.error)&&(t.errorComp=Me(m.error,r)),n(m.loading)&&(t.loadingComp=Me(m.loading,r),0===m.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),m.delay||200)),n(m.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),m.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=ut();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},yn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);te(i,c,t,e,!0)||te(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=jt(e,l,o||t);else n(r.attrs)&&Se(c,r.attrs),n(r.props)&&Se(c,r.props);const u=new ke(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof lt)return Oe(f,r,u.parent,a);if(Array.isArray(f)){const t=ee(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Oe(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const m=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Te.length;t++){const n=Te[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?je(r,o):r)}}(i);const y=r.options.name||u;return new lt(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:m,tag:u,children:c},d)}function je(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function De(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return ut();n(o)&&n(o.is)&&(e=o.is);if(!e)return ut();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=ee(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||P.getTagNamespace(e),a=P.isReservedTag(e)?new lt(P.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=It(t.$options,"components",e))?new lt(e,o,r,void 0,void 0,t):Ie(s,o,t,r,e)}else a=Ie(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Ne(a,c),n(o)&&function(t){s(t.style)&&Xt(t.style);s(t.class)&&Xt(t.class)}(o),a):ut()}(t,e,i,a,c)}function Ne(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Ne(a,r,s)}}let Pe,Le=null;function Me(t,e){return(t.__esModule||et&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Fe(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||ae(o)))return o}}function Re(t,e){Pe.$on(t,e)}function Ve(t,e){Pe.$off(t,e)}function Ue(t,e){const n=Pe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function ze(t,e,n){Pe=t,Qt(e,n||{},Re,Ve,Ue,t),Pe=void 0}let Be=null;function He(t){const e=Be;return Be=t,()=>{Be=e}}function We(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function qe(t,e){if(e){if(t._directInactive=!1,We(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)qe(t.$children[e]);Xe(t,"activated")}}function Ke(t,e){if(!(e&&(t._directInactive=!0,We(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ke(t.$children[e]);Xe(t,"deactivated")}}function Xe(t,e){at();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ft(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ct()}const Ge=[],Ze=[];let Je={},Qe=!1,Ye=!1,tn=0;let en=0,nn=Date.now;if(V&&!H){const t=window.performance;t&&"function"==typeof t.now&&nn()>document.createEvent("Event").timeStamp&&(nn=()=>t.now())}function on(){let t,e;for(en=nn(),Ye=!0,Ge.sort(((t,e)=>t.id-e.id)),tn=0;tn<Ge.length;tn++)t=Ge[tn],t.before&&t.before(),e=t.id,Je[e]=null,t.run();const n=Ze.slice(),o=Ge.slice();tn=Ge.length=Ze.length=0,Je={},Qe=Ye=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,qe(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Xe(o,"updated")}}(o),Y&&P.devtools&&Y.emit("flush")}let rn=0;class sn{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++rn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(F.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}get(){let t;at(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Xt(t),ct(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Je[e]){if(Je[e]=!0,Ye){let e=Ge.length-1;for(;e>tn&&Ge[e].id>t.id;)e--;Ge.splice(e+1,0,t)}else Ge.push(t);Qe||(Qe=!0,qt(on))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Ft(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const an={enumerable:!0,configurable:!0,get:O,set:O};function cn(t,e,n){an.get=function(){return this[e][n]},an.set=function(t){this[e][n]=t},Object.defineProperty(t,n,an)}function ln(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&vt(!1);for(const s in e){r.push(s);bt(o,s,jt(s,e,n,t)),s in t||cn(t,"_props",s)}vt(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?O:w(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){at();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ct()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&y(o,e)||L(e)||cn(t,"_data",e)}_t(e,!0)}(t):_t(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=Q();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new sn(t,i||O,O,un)),r in t||fn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==G&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)hn(t,n,o[e]);else hn(t,n,o)}}(t,e.watch)}const un={lazy:!0};function fn(t,e,n){const o=!Q();"function"==typeof n?(an.get=o?dn(e):pn(n),an.set=O):(an.get=n.get?o&&!1!==n.cache?dn(e):pn(n.get):O,an.set=n.set||O),Object.defineProperty(t,e,an)}function dn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),st.target&&e.depend(),e.value}}function pn(t){return function(){return t.call(this,this)}}function hn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let mn=0;function yn(t){let e=t.options;if(t.super){const n=yn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&x(t.extendOptions,o),e=t.options=Tt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function vn(t){this._init(t)}function gn(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=Tt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)cn(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)fn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,D.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=x({},i.options),r[o]=i,i}}function _n(t){return t&&(t.Ctor.options.name||t.tag)}function bn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function $n(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&Cn(n,t,o,r)}}}function Cn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,h(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=mn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(yn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&ze(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=se(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>De(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>De(e,t,n,o,r,!0);const s=o&&o.data;bt(e,"$attrs",s&&s.attrs||t,null,!0),bt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Xe(n,"beforeCreate"),function(t){const e=re(t.$options.inject,t);e&&(vt(!1),Object.keys(e).forEach((n=>{bt(t,n,e[n])})),vt(!0))}(n),ln(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Xe(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(vn),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=Ct,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return hn(o,t,e,n);(n=n||{}).user=!0;const r=new sn(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;at(),Ft(e,o,[r.value],o,t),ct()}return function(){r.teardown()}}}(vn),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?A(n):n;const o=A(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ft(n[t],e,o,e,r)}return e}}(vn),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=He(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Xe(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||h(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Xe(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(vn),function(t){xe(t.prototype),t.prototype.$nextTick=function(t){return qt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ce(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Le=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Mt(e,t,"render"),o=t._vnode}finally{Le=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof lt||(o=ut()),o.parent=n,o}}(vn);const wn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:wn,exclude:wn,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:_n(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&Cn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)Cn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{$n(this,(e=>bn(t,e)))})),this.$watch("exclude",(t=>{$n(this,(e=>!bn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=Fe(t),n=e&&e.componentOptions;if(n){const t=_n(n),{include:o,exclude:r}=this;if(o&&(!t||!bn(o,t))||r&&t&&bn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,h(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>P};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:bt},t.set=$t,t.delete=Ct,t.nextTick=qt,t.observable=t=>(_t(t),t),t.options=Object.create(null),D.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),gn(t),function(t){D.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(vn),Object.defineProperty(vn.prototype,"$isServer",{get:Q}),Object.defineProperty(vn.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(vn,"FunctionalRenderContext",{value:ke}),vn.version="2.6.14";const xn=d("style,class"),kn=d("input,textarea,option,select,progress"),On=d("contenteditable,draggable,spellcheck"),Sn=d("events,caret,typing,plaintext-only"),En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Tn="http://www.w3.org/1999/xlink",In=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),jn=t=>In(t)?t.slice(6,t.length):"",Dn=t=>null==t||!1===t;function Nn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Pn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Pn(e,o.data));return function(t,e){if(n(t)||n(e))return Ln(t,Mn(e));return""}(e.staticClass,e.class)}function Pn(t,e){return{staticClass:Ln(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Ln(t,e){return t?e?t+" "+e:t:e||""}function Mn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Mn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Fn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Rn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Vn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Un=t=>Rn(t)||Vn(t);const zn=Object.create(null);const Bn=d("text,number,password,search,email,tel,url");var Hn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Fn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Wn={create(t,e){qn(e)},update(t,e){t.data.ref!==e.data.ref&&(qn(t,!0),qn(e))},destroy(t){qn(t,!0)}};function qn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?h(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Kn=new lt("",{},[]),Xn=["create","activate","update","remove","destroy"];function Gn(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Bn(r)&&Bn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function Zn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var Jn={create:Qn,update:Qn,destroy:function(t){Qn(t,Kn)}};function Qn(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Kn,o=e===Kn,r=to(t.data.directives,t.context),s=to(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,no(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(no(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)no(i[n],"inserted",e,t)};n?Yt(e,"insert",o):o()}a.length&&Yt(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)no(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||no(r[c],"unbind",t,t,o)}(t,e)}const Yn=Object.create(null);function to(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=Yn),n[eo(r)]=r,r.def=It(e.$options,"directives",r.name);return n}function eo(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function no(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Mt(o,n.context,`directive ${t.name} ${e} hook`)}}var oo=[Wn,Jn];function ro(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=x({},u)),u)i=u[s],a=l[s],a!==i&&so(c,s,i,o.data.pre);for(s in(H||q)&&u.value!==l.value&&so(c,"value",u.value),l)e(u[s])&&(In(s)?c.removeAttributeNS(Tn,jn(s)):On(s)||c.removeAttribute(s))}function so(t,e,n,o){o||t.tagName.indexOf("-")>-1?io(t,e,n):En(e)?Dn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):On(e)?t.setAttribute(e,((t,e)=>Dn(e)||"false"===e?"false":"contenteditable"===t&&Sn(e)?e:"true")(e,n)):In(e)?Dn(n)?t.removeAttributeNS(Tn,jn(e)):t.setAttributeNS(Tn,e,n):io(t,e,n)}function io(t,e,n){if(Dn(n))t.removeAttribute(e);else{if(H&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var ao={create:ro,update:ro};function co(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Nn(o);const c=r._transitionClasses;n(c)&&(a=Ln(a,Mn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var lo={create:co,update:co};let uo;function fo(t,e,n){const o=uo;return function r(){const s=e.apply(null,arguments);null!==s&&mo(t,r,n,o)}}const po=Ut&&!(X&&Number(X[1])<=53);function ho(t,e,n,o){if(po){const t=en,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}uo.addEventListener(t,e,J?{capture:n,passive:o}:n)}function mo(t,e,n,o){(o||uo).removeEventListener(t,e._wrapper||e,n)}function yo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};uo=o.elm||t.elm,function(t){if(n(t.__r)){const e=H?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),Qt(r,s,ho,mo,fo,o.context),uo=void 0}var vo={create:yo,update:yo,destroy:t=>yo(t,Kn)};let go;function _o(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=x({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);bo(i,t)&&(i.value=t)}else if("innerHTML"===r&&Vn(i.tagName)&&e(i.innerHTML)){go=go||document.createElement("div"),go.innerHTML=`<svg>${s}</svg>`;const t=go.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function bo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var $o={create:_o,update:_o};const Co=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function wo(t){const e=Ao(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Ao(t){return Array.isArray(t)?k(t):"string"==typeof t?Co(t):t}const xo=/^--/,ko=/\s*!important$/,Oo=(t,e,n)=>{if(xo.test(e))t.style.setProperty(e,n);else if(ko.test(n))t.style.setProperty(C(e),n.replace(ko,""),"important");else{const o=To(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},So=["Webkit","Moz","ms"];let Eo;const To=v((function(t){if(Eo=Eo||document.createElement("div").style,"filter"!==(t=_(t))&&t in Eo)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<So.length;t++){const n=So[t]+e;if(n in Eo)return n}}));function Io(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=Ao(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?x({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=wo(e.data))&&x(n,o)}(o=wo(t.data))&&x(n,o);let r=t;for(;r=r.parent;)r.data&&(o=wo(r.data))&&x(n,o);return n}(o,!0);for(a in f)e(p[a])&&Oo(c,a,"");for(a in p)i=p[a],i!==f[a]&&Oo(c,a,null==i?"":i)}var jo={create:Io,update:Io};const Do=/\s+/;function No(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Do).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Po(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Do).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function Lo(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&x(e,Mo(t.name||"v")),x(e,t),e}return"string"==typeof t?Mo(t):void 0}}const Mo=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),Fo=V&&!W;let Ro="transition",Vo="transitionend",Uo="animation",zo="animationend";Fo&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ro="WebkitTransition",Vo="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Uo="WebkitAnimation",zo="webkitAnimationEnd"));const Bo=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Ho(t){Bo((()=>{Bo(t)}))}function Wo(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),No(t,e))}function qo(t,e){t._transitionClasses&&h(t._transitionClasses,e),Po(t,e)}function Ko(t,e,n){const{type:o,timeout:r,propCount:s}=Go(t,e);if(!o)return n();const i="transition"===o?Vo:zo;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Xo=/\b(transform|all)(,|$)/;function Go(t,e){const n=window.getComputedStyle(t),o=(n[Ro+"Delay"]||"").split(", "),r=(n[Ro+"Duration"]||"").split(", "),s=Zo(o,r),i=(n[Uo+"Delay"]||"").split(", "),a=(n[Uo+"Duration"]||"").split(", "),c=Zo(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Xo.test(n[Ro+"Property"])}}function Zo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Jo(e)+Jo(t[n]))))}function Jo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Qo(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=Lo(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:v,afterEnter:g,enterCancelled:_,beforeAppear:b,appear:$,afterAppear:C,appearCancelled:w,duration:A}=i;let x=Be,k=Be.$vnode;for(;k&&k.parent;)x=k.context,k=k.parent;const O=!x._isMounted||!t.isRootInsert;if(O&&!$&&""!==$)return;const S=O&&p?p:l,E=O&&m?m:d,T=O&&h?h:u,I=O&&b||y,D=O&&"function"==typeof $?$:v,N=O&&C||g,P=O&&w||_,L=f(s(A)?A.enter:A),M=!1!==a&&!W,F=er(D),R=r._enterCb=j((()=>{M&&(qo(r,T),qo(r,E)),R.cancelled?(M&&qo(r,S),P&&P(r)):N&&N(r),r._enterCb=null}));t.data.show||Yt(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(r,R)})),I&&I(r),M&&(Wo(r,S),Wo(r,E),Ho((()=>{qo(r,S),R.cancelled||(Wo(r,T),F||(tr(L)?setTimeout(R,L):Ko(r,c,R)))}))),t.data.show&&(o&&o(),D&&D(r,R)),M||F||R()}function Yo(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=Lo(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:v,duration:g}=i,_=!1!==a&&!W,b=er(h),$=f(s(g)?g.leave:g),C=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),_&&(qo(r,u),qo(r,d)),C.cancelled?(_&&qo(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function w(){C.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),_&&(Wo(r,l),Wo(r,d),Ho((()=>{qo(r,l),C.cancelled||(Wo(r,u),b||(tr($)?setTimeout(C,$):Ko(r,c,C)))}))),h&&h(r,C),_||b||C())}v?v(w):w()}function tr(t){return"number"==typeof t&&!isNaN(t)}function er(t){if(e(t))return!1;const o=t.fns;return n(o)?er(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function nr(t,e){!0!==e.data.show&&Qo(e)}const or=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Xn.length;++s)for(a[Xn[s]]=[],i=0;i<c.length;++i)n(c[i][Xn[s]])&&a[Xn[s]].push(c[i][Xn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=dt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Kn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),g(t),m(t,d,e),n(f)&&v(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(v(t,e),g(t)):(qn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function v(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Kn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Kn,t),n(s.insert)&&e.push(t))}function g(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Be)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function _(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function b(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)b(t.children[o])}function $(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(C(o),b(o)):u(o.elm))}}function C(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&C(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function w(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Gn(t,o))return s}}function A(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=dt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,v=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(v)?m!==v&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],v=o[m],g=r.length-1,b=r[0],C=r[g];const x=!i;for(;p<=m&&h<=g;)e(y)?y=o[++p]:e(v)?v=o[--m]:Gn(y,b)?(A(y,b,s,r,h),y=o[++p],b=r[++h]):Gn(v,C)?(A(v,C,s,r,g),v=o[--m],C=r[--g]):Gn(y,C)?(A(y,C,s,r,g),x&&l.insertBefore(t,y.elm,l.nextSibling(v.elm)),y=o[++p],C=r[--g]):Gn(v,b)?(A(v,b,s,r,h),x&&l.insertBefore(t,v.elm,y.elm),v=o[--m],b=r[++h]):(e(a)&&(a=Zn(o,p,m)),c=n(b.key)?a[b.key]:w(b,o,p,m),e(c)?f(b,s,t,y.elm,!1,r,h):(u=o[c],Gn(u,b)?(A(u,b,s,r,h),o[c]=void 0,x&&l.insertBefore(t,u.elm,y.elm)):f(b,s,t,y.elm,!1,r,h)),b=r[++h]);p>m?(d=e(r[g+1])?null:r[g+1].elm,_(t,d,r,h,g,s)):h>g&&$(o,p,m)}(d,m,v,s,u):n(v)?(n(t.text)&&l.setTextContent(d,""),_(d,null,v,0,v.length-1,s)):n(m)?$(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function x(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!k(n)){t=!0,v(e,r);break}!t&&c.class&&Xt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&b(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Gn(t,r))A(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return x(r,u,!0),t;d=t,t=new lt(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Kn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else qn(t);t=t.parent}}n(c)?$([t],0,0):n(t.tag)&&b(t)}}var d;return x(r,u,c),r.elm}}({nodeOps:Hn,modules:[ao,lo,vo,$o,jo,V?{create:nr,activate:nr,remove(t,e){!0!==t.data.show?Yo(t,e):e()}}:{}].concat(oo)});W&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&fr(t,"input")}));const rr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?Yt(n,"postpatch",(()=>{rr.componentUpdated(t,e,n)})):sr(t,e,n.context),t._vOptions=[].map.call(t.options,cr)):("textarea"===n.tag||Bn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",lr),t.addEventListener("compositionend",ur),t.addEventListener("change",ur),W&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){sr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,cr);if(r.some(((t,e)=>!T(t,o[e])))){(t.multiple?e.value.some((t=>ar(t,r))):e.value!==e.oldValue&&ar(e.value,r))&&fr(t,"change")}}}};function sr(t,e,n){ir(t,e),(H||q)&&setTimeout((()=>{ir(t,e)}),0)}function ir(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=I(o,cr(i))>-1,i.selected!==s&&(i.selected=s);else if(T(cr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function ar(t,e){return e.every((e=>!T(e,t)))}function cr(t){return"_value"in t?t._value:t.value}function lr(t){t.target.composing=!0}function ur(t){t.target.composing&&(t.target.composing=!1,fr(t.target,"input"))}function fr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function dr(t){return!t.componentInstance||t.data&&t.data.transition?t:dr(t.componentInstance._vnode)}var pr={bind(t,{value:e},n){const o=(n=dr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Qo(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=dr(o)).data&&o.data.transition?(o.data.show=!0,e?Qo(o,(()=>{t.style.display=t.__vOriginalDisplay})):Yo(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},hr={model:rr,show:pr};const mr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function yr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?yr(Fe(e.children)):t}function vr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function gr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const _r=t=>t.tag||ae(t),br=t=>"show"===t.name;var $r={name:"transition",props:mr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(_r),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=yr(o);if(!s)return o;if(this._leaving)return gr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=vr(this),c=this._vnode,l=yr(c);if(s.data.directives&&s.data.directives.some(br)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!ae(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=x({},a);if("out-in"===n)return this._leaving=!0,Yt(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),gr(t,o);if("in-out"===n){if(ae(s))return c;let t;const n=()=>{t()};Yt(a,"afterEnter",n),Yt(a,"enterCancelled",n),Yt(e,"delayLeave",(e=>{t=e}))}}return o}};const Cr=x({tag:String,moveClass:String},mr);function wr(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Ar(t){t.data.newPos=t.elm.getBoundingClientRect()}function xr(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete Cr.mode;var kr={Transition:$r,TransitionGroup:{props:Cr,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=He(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=vr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(wr),t.forEach(Ar),t.forEach(xr),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Wo(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(Vo,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(Vo,t),n._moveCb=null,qo(n,e))})}})))},methods:{hasMove(t,e){if(!Fo)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{Po(n,t)})),No(n,e),n.style.display="none",this.$el.appendChild(n);const o=Go(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};vn.config.mustUseProp=(t,e,n)=>"value"===n&&kn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,vn.config.isReservedTag=Un,vn.config.isReservedAttr=xn,vn.config.getTagNamespace=function(t){return Vn(t)?"svg":"math"===t?"math":void 0},vn.config.isUnknownElement=function(t){if(!V)return!0;if(Un(t))return!1;if(t=t.toLowerCase(),null!=zn[t])return zn[t];const e=document.createElement(t);return t.indexOf("-")>-1?zn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:zn[t]=/HTMLUnknownElement/.test(e.toString())},x(vn.options.directives,hr),x(vn.options.components,kr),vn.prototype.__patch__=V?or:O,vn.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=ut),Xe(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new sn(t,o,O,{before(){t._isMounted&&!t._isDestroyed&&Xe(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Xe(t,"mounted")),t}(this,t=t&&V?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},V&&setTimeout((()=>{P.devtools&&Y&&Y.emit("init",vn)}),0),module.exports=vn;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index c902a0e4e80..a6fb79b350a 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -1,9 +1,9 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-var emptyObject = Object.freeze({});
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 function isUndef(v) {
@@ -30,7 +30,7 @@ function isPrimitive(value) {
 }
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
 function isObject(obj) {
@@ -39,7 +39,7 @@ function isObject(obj) {
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
+const _toString = Object.prototype.toString;
 function toRawType(value) {
     return _toString.call(value).slice(8, -1);
 }
@@ -57,7 +57,7 @@ function isRegExp(v) {
  * Check if val is a valid array index.
  */
 function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
+    const n = parseFloat(String(val));
     return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
 function isPromise(val) {
@@ -80,7 +80,7 @@ function toString(val) {
  * If the conversion fails, return original string.
  */
 function toNumber(val) {
-    var n = parseFloat(val);
+    const n = parseFloat(val);
     return isNaN(n) ? val : n;
 }
 /**
@@ -88,27 +88,27 @@ function toNumber(val) {
  * is in that map.
  */
 function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
         map[list[i]] = true;
     }
-    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
 function remove$2(arr, item) {
     if (arr.length) {
-        var index = arr.indexOf(item);
+        const index = arr.indexOf(item);
         if (index > -1) {
             return arr.splice(index, 1);
         }
@@ -117,7 +117,7 @@ function remove$2(arr, item) {
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
 }
@@ -125,30 +125,30 @@ function hasOwn(obj, key) {
  * Create a cached version of a pure function.
  */
 function cached(fn) {
-    var cache = Object.create(null);
+    const cache = Object.create(null);
     return function cachedFn(str) {
-        var hit = cache[str];
+        const hit = cache[str];
         return hit || (cache[str] = fn(str));
     };
 }
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
 /**
  * Capitalize a string.
  */
-var capitalize = cached(function (str) {
+const capitalize = cached((str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 });
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
     return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
 /**
@@ -161,7 +161,7 @@ var hyphenate = cached(function (str) {
 /* istanbul ignore next */
 function polyfillBind(fn, ctx) {
     function boundFn(a) {
-        var l = arguments.length;
+        const l = arguments.length;
         return l
             ? l > 1
                 ? fn.apply(ctx, arguments)
@@ -175,14 +175,14 @@ function nativeBind(fn, ctx) {
     return fn.bind(ctx);
 }
 // @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
+const bind = Function.prototype.bind ? nativeBind : polyfillBind;
 /**
  * Convert an Array-like object to a real Array.
  */
 function toArray(list, start) {
     start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
+    let i = list.length - start;
+    const ret = new Array(i);
     while (i--) {
         ret[i] = list[i + start];
     }
@@ -192,7 +192,7 @@ function toArray(list, start) {
  * Mix properties into target object.
  */
 function extend(to, _from) {
-    for (var key in _from) {
+    for (const key in _from) {
         to[key] = _from[key];
     }
     return to;
@@ -201,8 +201,8 @@ function extend(to, _from) {
  * Merge an Array of Objects into a single Object.
  */
 function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
         if (arr[i]) {
             extend(res, arr[i]);
         }
@@ -219,28 +219,28 @@ function noop(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
+const identity = (_) => _;
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
 function looseEqual(a, b) {
     if (a === b)
-        { return true; }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
     if (isObjectA && isObjectB) {
         try {
-            var isArrayA = Array.isArray(a);
-            var isArrayB = Array.isArray(b);
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
             if (isArrayA && isArrayB) {
                 return (a.length === b.length &&
-                    a.every(function (e, i) {
+                    a.every((e, i) => {
                         return looseEqual(e, b[i]);
                     }));
             }
@@ -248,10 +248,10 @@ function looseEqual(a, b) {
                 return a.getTime() === b.getTime();
             }
             else if (!isArrayA && !isArrayB) {
-                var keysA = Object.keys(a);
-                var keysB = Object.keys(b);
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
                 return (keysA.length === keysB.length &&
-                    keysA.every(function (key) {
+                    keysA.every((key) => {
                         return looseEqual(a[key], b[key]);
                     }));
             }
@@ -278,9 +278,9 @@ function looseEqual(a, b) {
  * contain an object of the same shape), or -1 if it is not present.
  */
 function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
+    for (let i = 0; i < arr.length; i++) {
         if (looseEqual(arr[i], val))
-            { return i; }
+            return i;
     }
     return -1;
 }
@@ -288,7 +288,7 @@ function looseIndexOf(arr, val) {
  * Ensure a function is called only once.
  */
 function once(fn) {
-    var called = false;
+    let called = false;
     return function () {
         if (!called) {
             called = true;
@@ -297,9 +297,9 @@ function once(fn) {
     };
 }
 
-var SSR_ATTR = 'data-server-rendered';
-var ASSET_TYPES = ['component', 'directive', 'filter'];
-var LIFECYCLE_HOOKS = [
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
     'beforeCreate',
     'created',
     'beforeMount',
@@ -311,7 +311,8 @@ var LIFECYCLE_HOOKS = [
     'activated',
     'deactivated',
     'errorCaptured',
-    'serverPrefetch' ];
+    'serverPrefetch',
+];
 
 var config = {
     /**
@@ -396,12 +397,12 @@ var config = {
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Check if a string starts with $ or _
  */
 function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
+    const c = (str + '').charCodeAt(0);
     return c === 0x24 || c === 0x5f;
 }
 /**
@@ -418,16 +419,16 @@ function def(obj, key, val, enumerable) {
 /**
  * Parse simple path.
  */
-var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
 function parsePath(path) {
     if (bailRE.test(path)) {
         return;
     }
-    var segments = path.split('.');
+    const segments = path.split('.');
     return function (obj) {
-        for (var i = 0; i < segments.length; i++) {
+        for (let i = 0; i < segments.length; i++) {
             if (!obj)
-                { return; }
+                return;
             obj = obj[segments[i]];
         }
         return obj;
@@ -435,46 +436,41 @@ function parsePath(path) {
 }
 
 // can we use __proto__?
-var hasProto = '__proto__' in {};
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-// @ts-ignore
-var inWeex = 
-// @ts-ignore
-typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-// @ts-ignore
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
 (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
 UA && /chrome\/\d+/.test(UA) && !isEdge;
 UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
-var nativeWatch = {}.watch;
-var supportsPassive = false;
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
     try {
-        var opts = {};
+        const opts = {};
         Object.defineProperty(opts, 'passive', {
-            get: function get() {
+            get() {
                 /* istanbul ignore next */
                 supportsPassive = true;
             },
         }); // https://github.com/facebook/flow/issues/285
-        // @ts-ignore
         window.addEventListener('test-passive', null, opts);
     }
     catch (e) { }
 }
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
+let _isServer;
+const isServerRendering = () => {
     if (_isServer === undefined) {
         /* istanbul ignore if */
         if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -490,104 +486,94 @@ var isServerRendering = function () {
     return _isServer;
 };
 // detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
 /* istanbul ignore next */
 function isNative(Ctor) {
     return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
 }
-var hasSymbol = typeof Symbol !== 'undefined' &&
+const hasSymbol = typeof Symbol !== 'undefined' &&
     isNative(Symbol) &&
     typeof Reflect !== 'undefined' &&
     isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
+let _Set; // $flow-disable-line
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
     // use native Set when available.
     _Set = Set;
 }
 else {
     // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-        function Set() {
-            this.set = Object.create(null);
-        }
-        Set.prototype.has = function has (key) {
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
             return this.set[key] === true;
-        };
-        Set.prototype.add = function add (key) {
+        }
+        add(key) {
             this.set[key] = true;
-        };
-        Set.prototype.clear = function clear () {
+        }
+        clear() {
             this.set = Object.create(null);
-        };
-
-        return Set;
-    }());
+        }
+    };
 }
 
-var warn = noop;
-var tip = noop;
-var generateComponentTrace; // work around flow check
-var formatComponentName;
+let warn = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 if (process.env.NODE_ENV !== 'production') {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-    warn = function (msg, vm) {
-        var trace = vm ? generateComponentTrace(vm) : '';
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
         if (config.warnHandler) {
             config.warnHandler.call(null, msg, vm, trace);
         }
         else if (hasConsole && !config.silent) {
-            console.error(("[Vue warn]: " + msg + trace));
+            console.error(`[Vue warn]: ${msg}${trace}`);
         }
     };
-    tip = function (msg, vm) {
+    tip = (msg, vm) => {
         if (hasConsole && !config.silent) {
-            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
         }
     };
-    formatComponentName = function (vm, includeFile) {
+    formatComponentName = (vm, includeFile) => {
         if (vm.$root === vm) {
             return '<Root>';
         }
-        var options = 
-        // @ts-ignore
-        typeof vm === 'function' && vm.cid != null
-            ? // @ts-ignore
-                vm.options
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
             : vm._isVue
-                ? // @ts-ignore
-                    vm.$options || vm.constructor.options
+                ? vm.$options || vm.constructor.options
                 : vm;
-        var name = options.name || options._componentTag;
-        var file = options.__file;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
         if (!name && file) {
-            var match = file.match(/([^/\\]+)\.vue$/);
+            const match = file.match(/([^/\\]+)\.vue$/);
             name = match && match[1];
         }
-        return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-            (file && includeFile !== false ? (" at " + file) : ''));
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
     };
-    var repeat = function (str, n) {
-        var res = '';
+    const repeat = (str, n) => {
+        let res = '';
         while (n) {
             if (n % 2 === 1)
-                { res += str; }
+                res += str;
             if (n > 1)
-                { str += str; }
+                str += str;
             n >>= 1;
         }
         return res;
     };
-    generateComponentTrace = function (vm) {
-        // @ts-ignore
+    generateComponentTrace = (vm) => {
         if (vm._isVue && vm.$parent) {
-            var tree = [];
-            var currentRecursiveSequence = 0;
+            const tree = [];
+            let currentRecursiveSequence = 0;
             while (vm) {
                 if (tree.length > 0) {
-                    var last = tree[tree.length - 1];
+                    const last = tree[tree.length - 1];
                     if (last.constructor === vm.constructor) {
                         currentRecursiveSequence++;
                         vm = vm.$parent;
@@ -603,55 +589,60 @@ if (process.env.NODE_ENV !== 'production') {
             }
             return ('\n\nfound in\n\n' +
                 tree
-                    .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                    ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                    : formatComponentName(vm))); })
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                     .join('\n'));
         }
         else {
-            return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+            return `\n\n(found in ${formatComponentName(vm)})`;
         }
     };
 }
 
-var uid$2 = 0;
+let uid$2 = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep() {
-    this.id = uid$2++;
-    this.subs = [];
-};
-Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-};
-Dep.prototype.removeSub = function removeSub (sub) {
-    remove$2(this.subs, sub);
-};
-Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-        Dep.target.addDep(this);
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
     }
-};
-Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-        // subs aren't sorted in scheduler if not running async
-        // we need to sort them now to make sure they fire in correct
-        // order
-        subs.sort(function (a, b) { return a.id - b.id; });
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update();
+    addSub(sub) {
+        this.subs.push(sub);
     }
-};
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-var targetStack = [];
+const targetStack = [];
 function pushTarget(target) {
     targetStack.push(target);
     Dep.target = target;
@@ -661,44 +652,66 @@ function popTarget() {
     Dep.target = targetStack[targetStack.length - 1];
 }
 
-var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-    return this.componentInstance;
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
-    var node = new VNode();
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
     node.text = text;
     node.isComment = true;
     return node;
@@ -711,9 +724,7 @@ function createTextVNode(val) {
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
 function cloneVNode(vnode) {
-    var cloned = new VNode(
-    //@ts-expect-error void type not valid here
-    vnode.tag, vnode.data, 
+    const cloned = new VNode(vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
@@ -734,29 +745,27 @@ function cloneVNode(vnode) {
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-var methodsToPatch = [
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
     'push',
     'pop',
     'shift',
     'unshift',
     'splice',
     'sort',
-    'reverse' ];
+    'reverse',
+];
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
     // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-        var args = [], len = arguments.length;
-        while ( len-- ) args[ len ] = arguments[ len ];
-
-        var result = original.apply(this, args);
-        var ob = this.__ob__;
-        var inserted;
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
         switch (method) {
             case 'push':
             case 'unshift':
@@ -767,19 +776,19 @@ methodsToPatch.forEach(function (method) {
                 break;
         }
         if (inserted)
-            { ob.observeArray(inserted); }
+            ob.observeArray(inserted);
         // notify change
         ob.dep.notify();
         return result;
     });
 });
 
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-var shouldObserve = true;
+let shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
@@ -789,43 +798,48 @@ function toggleObserving(value) {
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer(value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-        if (hasProto) {
-            protoAugment(value, arrayMethods);
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
         }
         else {
-            copyAugment(value, arrayMethods, arrayKeys);
+            this.walk(value);
         }
-        this.observeArray(value);
     }
-    else {
-        this.walk(value);
-    }
-};
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-        defineReactive(obj, keys[i]);
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
     }
-};
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i]);
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
     }
-};
+}
 // helpers
 /**
  * Augment a target Object or Array by intercepting
@@ -842,8 +856,8 @@ function protoAugment(target, src) {
  */
 /* istanbul ignore next */
 function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-        var key = keys[i];
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
         def(target, key, src[key]);
     }
 }
@@ -856,7 +870,7 @@ function observe(value, asRootData) {
     if (!isObject(value) || value instanceof VNode) {
         return;
     }
-    var ob;
+    let ob;
     if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
         ob = value.__ob__;
     }
@@ -876,23 +890,23 @@ function observe(value, asRootData) {
  * Define a reactive property on an Object.
  */
 function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
         return;
     }
     // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
+    const getter = property && property.get;
+    const setter = property && property.set;
     if ((!getter || setter) && arguments.length === 2) {
         val = obj[key];
     }
-    var childOb = !shallow && observe(val);
+    let childOb = !shallow && observe(val);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
         get: function reactiveGetter() {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             if (Dep.target) {
                 dep.depend();
                 if (childOb) {
@@ -905,7 +919,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             return value;
         },
         set: function reactiveSetter(newVal) {
-            var value = getter ? getter.call(obj) : val;
+            const value = getter ? getter.call(obj) : val;
             /* eslint-disable no-self-compare */
             if (newVal === value || (newVal !== newVal && value !== value)) {
                 return;
@@ -916,7 +930,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             }
             // #7981: for accessor properties without setter
             if (getter && !setter)
-                { return; }
+                return;
             if (setter) {
                 setter.call(obj, newVal);
             }
@@ -936,7 +950,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
 function set(target, key, val) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.length = Math.max(target.length, key);
@@ -947,8 +961,7 @@ function set(target, key, val) {
         target[key] = val;
         return val;
     }
-    var ob = target.__ob__;
-    // @ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
             warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
@@ -969,14 +982,13 @@ function set(target, key, val) {
 function del(target, key) {
     if (process.env.NODE_ENV !== 'production' &&
         (isUndef(target) || isPrimitive(target))) {
-        warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
     }
     if (Array.isArray(target) && isValidArrayIndex(key)) {
         target.splice(key, 1);
         return;
     }
-    var ob = target.__ob__;
-    //@ts-ignore
+    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         process.env.NODE_ENV !== 'production' &&
             warn('Avoid deleting properties on a Vue instance or its root $data ' +
@@ -997,7 +1009,7 @@ function del(target, key) {
  * we cannot intercept array element access like property getters.
  */
 function dependArray(value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
         e = value[i];
         e && e.__ob__ && e.__ob__.dep.depend();
         if (Array.isArray(e)) {
@@ -1011,14 +1023,14 @@ function dependArray(value) {
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
     strats.el = strats.propsData = function (parent, child, vm, key) {
         if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
+            warn(`option "${key}" can only be used during instance ` +
                 'creation with the `new` keyword.');
         }
         return defaultStrat(parent, child);
@@ -1029,16 +1041,16 @@ if (process.env.NODE_ENV !== 'production') {
  */
 function mergeData(to, from) {
     if (!from)
-        { return to; }
-    var key, toVal, fromVal;
-    var keys = hasSymbol
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
         ? Reflect.ownKeys(from)
         : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
+    for (let i = 0; i < keys.length; i++) {
         key = keys[i];
         // in case the object is already observed...
         if (key === '__ob__')
-            { continue; }
+            continue;
         toVal = to[key];
         fromVal = from[key];
         if (!hasOwn(to, key)) {
@@ -1070,18 +1082,14 @@ function mergeDataOrFn(parentVal, childVal, vm) {
         // check if parentVal is a function here because
         // it has to be a function to pass previous merges.
         return function mergedDataFn() {
-            return mergeData(
-            // @ts-ignore
-            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-            // @ts-ignore
-            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
         };
     }
     else {
         return function mergedInstanceDataFn() {
             // instance merge
-            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
             if (instanceData) {
                 return mergeData(instanceData, defaultData);
             }
@@ -1108,7 +1116,7 @@ strats.data = function (parentVal, childVal, vm) {
  * Hooks and props are merged as arrays.
  */
 function mergeHook$1(parentVal, childVal) {
-    var res = childVal
+    const res = childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : Array.isArray(childVal)
@@ -1118,15 +1126,15 @@ function mergeHook$1(parentVal, childVal) {
     return res ? dedupeHooks(res) : res;
 }
 function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
         if (res.indexOf(hooks[i]) === -1) {
             res.push(hooks[i]);
         }
     }
     return res;
 }
-LIFECYCLE_HOOKS.forEach(function (hook) {
+LIFECYCLE_HOOKS.forEach((hook) => {
     strats[hook] = mergeHook$1;
 });
 /**
@@ -1137,7 +1145,7 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * options and parent options.
  */
 function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
+    const res = Object.create(parentVal || null);
     if (childVal) {
         process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
         return extend(res, childVal);
@@ -1159,27 +1167,27 @@ strats.watch = function (parentVal, childVal, vm, key) {
     // work around Firefox's Object.prototype.watch...
     //@ts-expect-error work around
     if (parentVal === nativeWatch)
-        { parentVal = undefined; }
+        parentVal = undefined;
     //@ts-expect-error work around
     if (childVal === nativeWatch)
-        { childVal = undefined; }
+        childVal = undefined;
     /* istanbul ignore if */
     if (!childVal)
-        { return Object.create(parentVal || null); }
+        return Object.create(parentVal || null);
     if (process.env.NODE_ENV !== 'production') {
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = {};
+        return childVal;
+    const ret = {};
     extend(ret, parentVal);
-    for (var key$1 in childVal) {
-        var parent = ret[key$1];
-        var child = childVal[key$1];
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
         if (parent && !Array.isArray(parent)) {
             parent = [parent];
         }
-        ret[key$1] = parent
+        ret[key] = parent
             ? parent.concat(child)
             : Array.isArray(child)
                 ? child
@@ -1195,30 +1203,30 @@ strats.props = strats.methods = strats.inject = strats.computed = function (pare
         assertObjectType(key, childVal, vm);
     }
     if (!parentVal)
-        { return childVal; }
-    var ret = Object.create(null);
+        return childVal;
+    const ret = Object.create(null);
     extend(ret, parentVal);
     if (childVal)
-        { extend(ret, childVal); }
+        extend(ret, childVal);
     return ret;
 };
 strats.provide = mergeDataOrFn;
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
+const defaultStrat = function (parentVal, childVal) {
     return childVal === undefined ? parentVal : childVal;
 };
 /**
  * Validate component names
  */
 function checkComponents(options) {
-    for (var key in options.components) {
+    for (const key in options.components) {
         validateComponentName(key);
     }
 }
 function validateComponentName(name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
         warn('Invalid component name: "' +
             name +
             '". Component names ' +
@@ -1235,11 +1243,11 @@ function validateComponentName(name) {
  * Object-based format.
  */
 function normalizeProps(options, vm) {
-    var props = options.props;
+    const props = options.props;
     if (!props)
-        { return; }
-    var res = {};
-    var i, val, name;
+        return;
+    const res = {};
+    let i, val, name;
     if (Array.isArray(props)) {
         i = props.length;
         while (i--) {
@@ -1254,15 +1262,15 @@ function normalizeProps(options, vm) {
         }
     }
     else if (isPlainObject(props)) {
-        for (var key in props) {
+        for (const key in props) {
             val = props[key];
             name = camelize(key);
             res[name] = isPlainObject(val) ? val : { type: val };
         }
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            "but got " + (toRawType(props)) + ".", vm);
+        warn(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
     }
     options.props = res;
 }
@@ -1270,36 +1278,36 @@ function normalizeProps(options, vm) {
  * Normalize all injections into Object-based format
  */
 function normalizeInject(options, vm) {
-    var inject = options.inject;
+    const inject = options.inject;
     if (!inject)
-        { return; }
-    var normalized = (options.inject = {});
+        return;
+    const normalized = (options.inject = {});
     if (Array.isArray(inject)) {
-        for (var i = 0; i < inject.length; i++) {
+        for (let i = 0; i < inject.length; i++) {
             normalized[inject[i]] = { from: inject[i] };
         }
     }
     else if (isPlainObject(inject)) {
-        for (var key in inject) {
-            var val = inject[key];
+        for (const key in inject) {
+            const val = inject[key];
             normalized[key] = isPlainObject(val)
                 ? extend({ from: key }, val)
                 : { from: val };
         }
     }
     else if (process.env.NODE_ENV !== 'production') {
-        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            "but got " + (toRawType(inject)) + ".", vm);
+        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
     }
 }
 /**
  * Normalize raw function directives into object format.
  */
 function normalizeDirectives$1(options) {
-    var dirs = options.directives;
+    const dirs = options.directives;
     if (dirs) {
-        for (var key in dirs) {
-            var def = dirs[key];
+        for (const key in dirs) {
+            const def = dirs[key];
             if (typeof def === 'function') {
                 dirs[key] = { bind: def, update: def };
             }
@@ -1308,8 +1316,8 @@ function normalizeDirectives$1(options) {
 }
 function assertObjectType(name, value, vm) {
     if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            "but got " + (toRawType(value)) + ".", vm);
+        warn(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
     }
 }
 /**
@@ -1336,13 +1344,13 @@ function mergeOptions(parent, child, vm) {
             parent = mergeOptions(parent, child.extends, vm);
         }
         if (child.mixins) {
-            for (var i = 0, l = child.mixins.length; i < l; i++) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
                 parent = mergeOptions(parent, child.mixins[i], vm);
             }
         }
     }
-    var options = {};
-    var key;
+    const options = {};
+    let key;
     for (key in parent) {
         mergeField(key);
     }
@@ -1352,7 +1360,7 @@ function mergeOptions(parent, child, vm) {
         }
     }
     function mergeField(key) {
-        var strat = strats[key] || defaultStrat;
+        const strat = strats[key] || defaultStrat;
         options[key] = strat(parent[key], child[key], vm, key);
     }
     return options;
@@ -1367,18 +1375,18 @@ function resolveAsset(options, type, id, warnMissing) {
     if (typeof id !== 'string') {
         return;
     }
-    var assets = options[type];
+    const assets = options[type];
     // check local registration variations first
     if (hasOwn(assets, id))
-        { return assets[id]; }
-    var camelizedId = camelize(id);
+        return assets[id];
+    const camelizedId = camelize(id);
     if (hasOwn(assets, camelizedId))
-        { return assets[camelizedId]; }
-    var PascalCaseId = capitalize(camelizedId);
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
     if (hasOwn(assets, PascalCaseId))
-        { return assets[PascalCaseId]; }
+        return assets[PascalCaseId];
     // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
     if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
         warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
     }
@@ -1386,11 +1394,11 @@ function resolveAsset(options, type, id, warnMissing) {
 }
 
 function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
     // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
     if (booleanIndex > -1) {
         if (absent && !hasOwn(prop, 'default')) {
             value = false;
@@ -1398,7 +1406,7 @@ function validateProp(key, propOptions, propsData, vm) {
         else if (value === '' || value === hyphenate(key)) {
             // only cast empty string / same name to boolean if
             // boolean has higher priority
-            var stringIndex = getTypeIndex(String, prop.type);
+            const stringIndex = getTypeIndex(String, prop.type);
             if (stringIndex < 0 || booleanIndex < stringIndex) {
                 value = true;
             }
@@ -1409,7 +1417,7 @@ function validateProp(key, propOptions, propsData, vm) {
         value = getPropDefaultValue(vm, prop, key);
         // since the default value is a fresh copy,
         // make sure to observe it.
-        var prevShouldObserve = shouldObserve;
+        const prevShouldObserve = shouldObserve;
         toggleObserving(true);
         observe(value);
         toggleObserving(prevShouldObserve);
@@ -1429,7 +1437,7 @@ function getPropDefaultValue(vm, prop, key) {
     if (!hasOwn(prop, 'default')) {
         return undefined;
     }
-    var def = prop.default;
+    const def = prop.default;
     // warn against non-factory defaults for Object & Array
     if (process.env.NODE_ENV !== 'production' && isObject(def)) {
         warn('Invalid default value for prop "' +
@@ -1463,38 +1471,37 @@ function assertProp(prop, name, value, vm, absent) {
     if (value == null && !prop.required) {
         return;
     }
-    var type = prop.type;
-    // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
     if (type) {
         if (!Array.isArray(type)) {
             type = [type];
         }
-        for (var i = 0; i < type.length && !valid; i++) {
-            var assertedType = assertType(value, type[i], vm);
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
             expectedTypes.push(assertedType.expectedType || '');
             valid = assertedType.valid;
         }
     }
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+    const haveExpectedTypes = expectedTypes.some((t) => t);
     if (!valid && haveExpectedTypes) {
         warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
         return;
     }
-    var validator = prop.validator;
+    const validator = prop.validator;
     if (validator) {
         if (!validator(value)) {
             warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
         }
     }
 }
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
 function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
+    let valid;
+    const expectedType = getType(type);
     if (simpleCheckRE.test(expectedType)) {
-        var t = typeof value;
+        const t = typeof value;
         valid = t === expectedType.toLowerCase();
         // for primitive wrapper objects
         if (!valid && t === 'object') {
@@ -1517,18 +1524,18 @@ function assertType(value, type, vm) {
         }
     }
     return {
-        valid: valid,
-        expectedType: expectedType,
+        valid,
+        expectedType,
     };
 }
-var functionTypeCheckRE = /^\s*function (\w+)/;
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
 function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
+    const match = fn && fn.toString().match(functionTypeCheckRE);
     return match ? match[1] : '';
 }
 function isSameType(a, b) {
@@ -1538,7 +1545,7 @@ function getTypeIndex(type, expectedTypes) {
     if (!Array.isArray(expectedTypes)) {
         return isSameType(expectedTypes, type) ? 0 : -1;
     }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
         if (isSameType(expectedTypes[i], type)) {
             return i;
         }
@@ -1546,44 +1553,41 @@ function getTypeIndex(type, expectedTypes) {
     return -1;
 }
 function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
     // check if we need to specify expected value
     if (expectedTypes.length === 1 &&
         isExplicable(expectedType) &&
         isExplicable(typeof value) &&
         !isBoolean(expectedType, receivedType)) {
-        message += " with value " + (styleValue(value, expectedType));
+        message += ` with value ${styleValue(value, expectedType)}`;
     }
-    message += ", got " + receivedType + " ";
+    message += `, got ${receivedType} `;
     // check if we need to specify received value
     if (isExplicable(receivedType)) {
-        message += "with value " + (styleValue(value, receivedType)) + ".";
+        message += `with value ${styleValue(value, receivedType)}.`;
     }
     return message;
 }
 function styleValue(value, type) {
     if (type === 'String') {
-        return ("\"" + value + "\"");
+        return `"${value}"`;
     }
     else if (type === 'Number') {
-        return ("" + (Number(value)));
+        return `${Number(value)}`;
     }
     else {
-        return ("" + value);
+        return `${value}`;
     }
 }
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
 function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
 }
-function isBoolean() {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
 function handleError(err, vm, info) {
@@ -1592,15 +1596,15 @@ function handleError(err, vm, info) {
     pushTarget();
     try {
         if (vm) {
-            var cur = vm;
+            let cur = vm;
             while ((cur = cur.$parent)) {
-                var hooks = cur.$options.errorCaptured;
+                const hooks = cur.$options.errorCaptured;
                 if (hooks) {
-                    for (var i = 0; i < hooks.length; i++) {
+                    for (let i = 0; i < hooks.length; i++) {
                         try {
-                            var capture = hooks[i].call(cur, err, vm, info) === false;
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
                             if (capture)
-                                { return; }
+                                return;
                         }
                         catch (e) {
                             globalHandleError(e, cur, 'errorCaptured hook');
@@ -1616,17 +1620,18 @@ function handleError(err, vm, info) {
     }
 }
 function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
+    let res;
     try {
         res = args ? handler.apply(context, args) : handler.call(context);
         if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
             // issue #9511
             // avoid catch triggering multiple times when nested calls
             res._handled = true;
         }
     }
     catch (e) {
+        // @ts-expect-error should it be any?
         handleError(e, vm, info);
     }
     return res;
@@ -1648,7 +1653,7 @@ function globalHandleError(err, vm, info) {
 }
 function logError(err, vm, info) {
     if (process.env.NODE_ENV !== 'production') {
-        warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+        warn(`Error in ${info}: "${err.toString()}"`, vm);
     }
     /* istanbul ignore else */
     if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1660,14 +1665,14 @@ function logError(err, vm, info) {
 }
 
 /* globals MutationObserver */
-var isUsingMicroTask = false;
-var callbacks = [];
-var pending = false;
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
 function flushCallbacks() {
     pending = false;
-    var copies = callbacks.slice(0);
+    const copies = callbacks.slice(0);
     callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
+    for (let i = 0; i < copies.length; i++) {
         copies[i]();
     }
 }
@@ -1682,7 +1687,7 @@ function flushCallbacks() {
 // where microtasks have too high a priority and fire in between supposedly
 // sequential events (e.g. #4521, #6690, which have workarounds)
 // or even between bubbling of the same event (#6566).
-var timerFunc;
+let timerFunc;
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1691,8 +1696,8 @@ var timerFunc;
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
 if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p = Promise.resolve();
-    timerFunc = function () {
+    const p = Promise.resolve();
+    timerFunc = () => {
         p.then(flushCallbacks);
         // In problematic UIWebViews, Promise.then doesn't completely break, but
         // it can get stuck in a weird state where callbacks are pushed into the
@@ -1700,7 +1705,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
         // needs to do some other work, e.g. handle a timer. Therefore we can
         // "force" the microtask queue to be flushed by adding an empty timer.
         if (isIOS)
-            { setTimeout(noop); }
+            setTimeout(noop);
     };
     isUsingMicroTask = true;
 }
@@ -1712,13 +1717,13 @@ else if (!isIE &&
     // Use MutationObserver where native Promise is not available,
     // e.g. PhantomJS, iOS7, Android 4.4
     // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
     observer.observe(textNode, {
         characterData: true,
     });
-    timerFunc = function () {
+    timerFunc = () => {
         counter = (counter + 1) % 2;
         textNode.data = String(counter);
     };
@@ -1728,24 +1733,25 @@ else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
     // Fallback to setImmediate.
     // Technically it leverages the (macro) task queue,
     // but it is still a better choice than setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setImmediate(flushCallbacks);
     };
 }
 else {
     // Fallback to setTimeout.
-    timerFunc = function () {
+    timerFunc = () => {
         setTimeout(flushCallbacks, 0);
     };
 }
 function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
+    let _resolve;
+    callbacks.push(() => {
         if (cb) {
             try {
                 cb.call(ctx);
             }
             catch (e) {
+                // @ts-expect-error should it be any?
                 handleError(e, ctx, 'nextTick');
             }
         }
@@ -1759,40 +1765,40 @@ function nextTick(cb, ctx) {
     }
     // $flow-disable-line
     if (!cb && typeof Promise !== 'undefined') {
-        return new Promise(function (resolve) {
+        return new Promise((resolve) => {
             _resolve = resolve;
         });
     }
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-var initProxy;
+let initProxy;
 if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
         'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
         'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
         'require' // for Webpack/Browserify
     );
-    var warnNonPresent = function (target, key) {
-        warn("Property or method \"" + key + "\" is not defined on the instance but " +
+    const warnNonPresent = (target, key) => {
+        warn(`Property or method "${key}" is not defined on the instance but ` +
             'referenced during render. Make sure that this property is reactive, ' +
             'either in the data option, or for class-based components, by ' +
             'initializing the property. ' +
             'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
     };
-    var warnReservedPrefix = function (target, key) {
-        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+    const warnReservedPrefix = (target, key) => {
+        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
             'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
             'prevent conflicts with Vue internals. ' +
             'See: https://vuejs.org/v2/api/#data', target);
     };
-    var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
     if (hasProxy) {
-        var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
         config.keyCodes = new Proxy(config.keyCodes, {
-            set: function set(target, key, value) {
+            set(target, key, value) {
                 if (isBuiltInModifier(key)) {
-                    warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                     return false;
                 }
                 else {
@@ -1802,29 +1808,29 @@ if (process.env.NODE_ENV !== 'production') {
             },
         });
     }
-    var hasHandler = {
-        has: function has(target, key) {
-            var has = key in target;
-            var isAllowed = allowedGlobals(key) ||
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
                 (typeof key === 'string' &&
                     key.charAt(0) === '_' &&
                     !(key in target.$data));
             if (!has && !isAllowed) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return has || !isAllowed;
         },
     };
-    var getHandler = {
-        get: function get(target, key) {
+    const getHandler = {
+        get(target, key) {
             if (typeof key === 'string' && !(key in target)) {
                 if (key in target.$data)
-                    { warnReservedPrefix(target, key); }
+                    warnReservedPrefix(target, key);
                 else
-                    { warnNonPresent(target, key); }
+                    warnNonPresent(target, key);
             }
             return target[key];
         },
@@ -1832,8 +1838,8 @@ if (process.env.NODE_ENV !== 'production') {
     initProxy = function initProxy(vm) {
         if (hasProxy) {
             // determine which proxy handler to use
-            var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
             vm._renderProxy = new Proxy(vm, handlers);
         }
         else {
@@ -1842,7 +1848,7 @@ if (process.env.NODE_ENV !== 'production') {
     };
 }
 
-var seenObjects = new _Set();
+const seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
@@ -1853,15 +1859,15 @@ function traverse(val) {
     seenObjects.clear();
 }
 function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
+    let i, keys;
+    const isA = Array.isArray(val);
     if ((!isA && !isObject(val)) ||
         Object.isFrozen(val) ||
         val instanceof VNode) {
         return;
     }
     if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
+        const depId = val.__ob__.dep.id;
         if (seen.has(depId)) {
             return;
         }
@@ -1870,28 +1876,28 @@ function _traverse(val, seen) {
     if (isA) {
         i = val.length;
         while (i--)
-            { _traverse(val[i], seen); }
+            _traverse(val[i], seen);
     }
     else {
         keys = Object.keys(val);
         i = keys.length;
         while (i--)
-            { _traverse(val[keys[i]], seen); }
+            _traverse(val[keys[i]], seen);
     }
 }
 
-var mark;
-var measure;
+let mark;
+let measure;
 if (process.env.NODE_ENV !== 'production') {
-    var perf = inBrowser && window.performance;
+    const perf = inBrowser && window.performance;
     /* istanbul ignore if */
     if (perf &&
         perf.mark &&
         perf.measure &&
         perf.clearMarks &&
         perf.clearMeasures) {
-        mark = function (tag) { return perf.mark(tag); };
-        measure = function (name, startTag, endTag) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
             perf.measure(name, startTag, endTag);
             perf.clearMarks(startTag);
             perf.clearMarks(endTag);
@@ -1900,48 +1906,46 @@ if (process.env.NODE_ENV !== 'production') {
     }
 }
 
-var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
     name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === '~'; // Prefixed last, checked first
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
     name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
+    const capture = name.charAt(0) === '!';
     name = capture ? name.slice(1) : name;
     return {
-        name: name,
-        once: once,
-        capture: capture,
-        passive: passive,
+        name,
+        once,
+        capture,
+        passive,
     };
 });
 function createFnInvoker(fns, vm) {
     function invoker() {
-        var arguments$1 = arguments;
-
-        var fns = invoker.fns;
+        const fns = invoker.fns;
         if (Array.isArray(fns)) {
-            var cloned = fns.slice();
-            for (var i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
             }
         }
         else {
             // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
         }
     }
     invoker.fns = fns;
     return invoker;
 }
 function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, cur, old, event;
+    let name, cur, old, event;
     for (name in on) {
         cur = on[name];
         old = oldOn[name];
         event = normalizeEvent(name);
         if (isUndef(cur)) {
             process.env.NODE_ENV !== 'production' &&
-                warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+                warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
         }
         else if (isUndef(old)) {
             if (isUndef(cur.fns)) {
@@ -1969,8 +1973,8 @@ function mergeVNodeHook(def, hookKey, hook) {
     if (def instanceof VNode) {
         def = def.data.hook || (def.data.hook = {});
     }
-    var invoker;
-    var oldHook = def[hookKey];
+    let invoker;
+    const oldHook = def[hookKey];
     function wrappedHook() {
         hook.apply(this, arguments);
         // important: remove merged hook to ensure it's called only once
@@ -2001,27 +2005,26 @@ function extractPropsFromVNodeData(data, Ctor, tag) {
     // we are only extracting raw values here.
     // validation and default values are handled in the child
     // component itself.
-    var propOptions = Ctor.options.props;
+    const propOptions = Ctor.options.props;
     if (isUndef(propOptions)) {
         return;
     }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
+    const res = {};
+    const { attrs, props } = data;
     if (isDef(attrs) || isDef(props)) {
-        for (var key in propOptions) {
-            var altKey = hyphenate(key);
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
             if (process.env.NODE_ENV !== 'production') {
-                var keyInLowerCase = key.toLowerCase();
+                const keyInLowerCase = key.toLowerCase();
                 if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                        (formatComponentName(
-                        // @ts-ignore
-                        tag || Ctor)) + ", but the declared prop name is" +
-                        " \"" + key + "\". " +
-                        "Note that HTML attributes are case-insensitive and camelCased " +
-                        "props need to use their kebab-case equivalents when using in-DOM " +
-                        "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
                 }
             }
             checkProp(res, props, key, altKey, true) ||
@@ -2062,7 +2065,7 @@ function checkProp(res, hash, key, altKey, preserve) {
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
 function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
+    for (let i = 0; i < children.length; i++) {
         if (Array.isArray(children[i])) {
             return Array.prototype.concat.apply([], children);
         }
@@ -2084,18 +2087,18 @@ function isTextNode(node) {
     return isDef(node) && isDef(node.text) && isFalse(node.isComment);
 }
 function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
+    const res = [];
+    let i, c, lastIndex, last;
     for (i = 0; i < children.length; i++) {
         c = children[i];
         if (isUndef(c) || typeof c === 'boolean')
-            { continue; }
+            continue;
         lastIndex = res.length - 1;
         last = res[lastIndex];
         //  nested
         if (Array.isArray(c)) {
             if (c.length > 0) {
-                c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                 // merge adjacent text nodes
                 if (isTextNode(c[0]) && isTextNode(last)) {
                     res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2127,7 +2130,7 @@ function normalizeArrayChildren(children, nestedIndex) {
                     isDef(c.tag) &&
                     isUndef(c.key) &&
                     isDef(nestedIndex)) {
-                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                    c.key = `__vlist${nestedIndex}_${i}__`;
                 }
                 res.push(c);
             }
@@ -2137,7 +2140,7 @@ function normalizeArrayChildren(children, nestedIndex) {
 }
 
 function initProvide(vm) {
-    var provide = vm.$options.provide;
+    const provide = vm.$options.provide;
     if (provide) {
         vm._provided =
             typeof provide === 'function'
@@ -2147,16 +2150,16 @@ function initProvide(vm) {
     }
 }
 function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
+    const result = resolveInject(vm.$options.inject, vm);
     if (result) {
         toggleObserving(false);
-        Object.keys(result).forEach(function (key) {
+        Object.keys(result).forEach((key) => {
             /* istanbul ignore else */
             if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], function () {
-                    warn("Avoid mutating an injected value directly since the changes will be " +
-                        "overwritten whenever the provided component re-renders. " +
-                        "injection being mutated: \"" + key + "\"", vm);
+                defineReactive(vm, key, result[key], () => {
+                    warn(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
                 });
             }
             else {
@@ -2169,15 +2172,15 @@ function initInjections(vm) {
 function resolveInject(inject, vm) {
     if (inject) {
         // inject is :any because flow is not smart enough to figure out cached
-        var result = Object.create(null);
-        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (var i = 0; i < keys.length; i++) {
-            var key = keys[i];
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
             // #6574 in case the inject object is observed...
             if (key === '__ob__')
-                { continue; }
-            var provideKey = inject[key].from;
-            var source = vm;
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
             while (source) {
                 if (source._provided && hasOwn(source._provided, provideKey)) {
                     result[key] = source._provided[provideKey];
@@ -2188,15 +2191,14 @@ function resolveInject(inject, vm) {
             }
             if (!source) {
                 if ('default' in inject[key]) {
-                    var provideDefault = inject[key].default;
+                    const provideDefault = inject[key].default;
                     result[key] =
                         typeof provideDefault === 'function'
                             ? provideDefault.call(vm)
                             : provideDefault;
                 }
                 else if (process.env.NODE_ENV !== 'production') {
-                    // @ts-ignore
-                    warn(("Injection \"" + key + "\" not found"), vm);
+                    warn(`Injection "${key}" not found`, vm);
                 }
             }
         }
@@ -2211,10 +2213,10 @@ function resolveSlots(children, context) {
     if (!children || !children.length) {
         return {};
     }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var data = child.data;
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
         // remove slot attribute if the node is resolved as a Vue slot node
         if (data && data.attrs && data.attrs.slot) {
             delete data.attrs.slot;
@@ -2224,8 +2226,8 @@ function resolveSlots(children, context) {
         if ((child.context === context || child.fnContext === context) &&
             data &&
             data.slot != null) {
-            var name = data.slot;
-            var slot = slots[name] || (slots[name] = []);
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
             if (child.tag === 'template') {
                 slot.push.apply(slot, child.children || []);
             }
@@ -2238,9 +2240,9 @@ function resolveSlots(children, context) {
         }
     }
     // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-        if (slots[name$1].every(isWhitespace)) {
-            delete slots[name$1];
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
         }
     }
     return slots;
@@ -2249,11 +2251,16 @@ function isWhitespace(node) {
     return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
+}
+
 function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
     if (!slots) {
         res = {};
     }
@@ -2273,16 +2280,16 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     }
     else {
         res = {};
-        for (var key$1 in slots) {
-            if (slots[key$1] && key$1[0] !== '$') {
-                res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
             }
         }
     }
     // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-        if (!(key$2 in res)) {
-            res[key$2] = proxyNormalSlot(normalSlots, key$2);
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
         }
     }
     // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2290,19 +2297,22 @@ function normalizeScopedSlots(slots, normalSlots, prevSlots) {
     if (slots && Object.isExtensible(slots)) {
         slots._normalized = res;
     }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
     return res;
 }
 function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-        var res = arguments.length ? fn.apply(null, arguments) : fn({});
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
         res =
-            res && typeof res === 'object' && !Array.isArray(res)
+            res && typeof res === "object" && !Array.isArray(res)
                 ? [res] // single vnode
                 : normalizeChildren(res);
-        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
             ? undefined
             : res;
     };
@@ -2319,14 +2329,14 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     return normalized;
 }
 function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; };
+    return () => slots[key];
 }
 
 /**
  * Runtime helper for rendering v-for lists.
  */
 function renderList(val, render) {
-    var ret = null, i, l, keys, key;
+    let ret = null, i, l, keys, key;
     if (Array.isArray(val) || typeof val === 'string') {
         ret = new Array(val.length);
         for (i = 0, l = val.length; i < l; i++) {
@@ -2342,8 +2352,8 @@ function renderList(val, render) {
     else if (isObject(val)) {
         if (hasSymbol && val[Symbol.iterator]) {
             ret = [];
-            var iterator = val[Symbol.iterator]();
-            var result = iterator.next();
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
             while (!result.done) {
                 ret.push(render(result.value, ret.length));
                 result = iterator.next();
@@ -2368,26 +2378,34 @@ function renderList(val, render) {
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
     if (scopedSlotFn) {
         // scoped slot
         props = props || {};
         if (bindObject) {
-            if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
+            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
+                warn("slot v-bind without argument expects an Object", this);
             }
             props = extend(extend({}, bindObject), props);
         }
-        nodes = scopedSlotFn(props) || fallback;
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
     else {
-        nodes = this.$slots[name] || fallback;
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
     }
-    var target = props && props.slot;
+    const target = props && props.slot;
     if (target) {
-        return this.$createElement('template', { slot: target }, nodes);
+        return this.$createElement("template", { slot: target }, nodes);
     }
     else {
         return nodes;
@@ -2415,7 +2433,7 @@ function isKeyNotMatch(expect, actual) {
  * passing in eventKeyName as last argument separately for backwards compat
  */
 function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
     if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
         return isKeyNotMatch(builtInKeyName, eventKeyName);
     }
@@ -2425,6 +2443,7 @@ function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInK
     else if (eventKeyName) {
         return hyphenate(eventKeyName) !== key;
     }
+    return eventKeyCode === undefined;
 }
 
 /**
@@ -2440,32 +2459,30 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
             if (Array.isArray(value)) {
                 value = toObject(value);
             }
-            var hash;
-            var loop = function ( key ) {
+            let hash;
+            for (const key in value) {
                 if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                     hash = data;
                 }
                 else {
-                    var type = data.attrs && data.attrs.type;
+                    const type = data.attrs && data.attrs.type;
                     hash =
                         asProp || config.mustUseProp(tag, type, key)
                             ? data.domProps || (data.domProps = {})
                             : data.attrs || (data.attrs = {});
                 }
-                var camelizedKey = camelize(key);
-                var hyphenatedKey = hyphenate(key);
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
                 if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                     hash[key] = value[key];
                     if (isSync) {
-                        var on = data.on || (data.on = {});
-                        on[("update:" + key)] = function ($event) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
                             value[key] = $event;
                         };
                     }
                 }
-            };
-
-            for (var key in value) loop( key );
+            }
         }
     }
     return data;
@@ -2475,8 +2492,8 @@ function bindObjectProps(data, tag, value, asProp, isSync) {
  * Runtime helper for rendering static trees.
  */
 function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
     // if has already-rendered static tree and not inside v-for,
     // we can reuse the same tree.
     if (tree && !isInFor) {
@@ -2485,7 +2502,7 @@ function renderStatic(index, isInFor) {
     // otherwise, render a fresh tree.
     tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
     );
-    markStatic(tree, ("__static__" + index), false);
+    markStatic(tree, `__static__${index}`, false);
     return tree;
 }
 /**
@@ -2493,14 +2510,14 @@ function renderStatic(index, isInFor) {
  * Effectively it means marking the node as static with a unique key.
  */
 function markOnce(tree, index, key) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
     return tree;
 }
 function markStatic(tree, key, isOnce) {
     if (Array.isArray(tree)) {
-        for (var i = 0; i < tree.length; i++) {
+        for (let i = 0; i < tree.length; i++) {
             if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], (key + "_" + i), isOnce);
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
             }
         }
     }
@@ -2521,10 +2538,10 @@ function bindObjectListeners(data, value) {
                 warn('v-on without argument expects an Object value', this);
         }
         else {
-            var on = (data.on = data.on ? extend({}, data.on) : {});
-            for (var key in value) {
-                var existing = on[key];
-                var ours = value[key];
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
                 on[key] = existing ? [].concat(existing, ours) : ours;
             }
         }
@@ -2536,8 +2553,8 @@ function resolveScopedSlots(fns, res,
 // the following are added in 2.6
 hasDynamicKeys, contentHashKey) {
     res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-        var slot = fns[i];
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
         if (Array.isArray(slot)) {
             resolveScopedSlots(slot, res, hasDynamicKeys);
         }
@@ -2559,8 +2576,8 @@ hasDynamicKeys, contentHashKey) {
 
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-        var key = values[i];
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
         if (typeof key === 'string' && key) {
             baseObj[values[i]] = values[i + 1];
         }
@@ -2568,7 +2585,7 @@ function bindDynamicKeys(baseObj, values) {
             key !== '' &&
             key !== null) {
             // null is a special value for explicitly removing a binding
-            warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
         }
     }
     return baseObj;
@@ -2601,12 +2618,10 @@ function installRenderHelpers(target) {
 }
 
 function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var this$1 = this;
-
-    var options = Ctor.options;
+    const options = Ctor.options;
     // ensure the createElement function in functional components
     // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
+    let contextVm;
     if (hasOwn(parent, '_uid')) {
         contextVm = Object.create(parent);
         // $flow-disable-line
@@ -2620,23 +2635,23 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         // $flow-disable-line
         parent = parent._original;
     }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
     this.data = data;
     this.props = props;
     this.children = children;
     this.parent = parent;
     this.listeners = data.on || emptyObject;
     this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-        if (!this$1.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
         }
-        return this$1.$slots;
+        return this.$slots;
     };
     Object.defineProperty(this, 'scopedSlots', {
         enumerable: true,
-        get: function get() {
+        get() {
             return normalizeScopedSlots(data.scopedSlots, this.slots());
         },
     });
@@ -2649,8 +2664,8 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
     }
     if (options._scopeId) {
-        this._c = function (a, b, c, d) {
-            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
             if (vnode && !Array.isArray(vnode)) {
                 vnode.fnScopeId = options._scopeId;
                 vnode.fnContext = parent;
@@ -2659,34 +2674,34 @@ function FunctionalRenderContext(data, props, children, parent, Ctor) {
         };
     }
     else {
-        this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
     }
 }
 installRenderHelpers(FunctionalRenderContext.prototype);
 function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
     if (isDef(propOptions)) {
-        for (var key in propOptions) {
+        for (const key in propOptions) {
             props[key] = validateProp(key, propOptions, propsData || emptyObject);
         }
     }
     else {
         if (isDef(data.attrs))
-            { mergeProps(props, data.attrs); }
+            mergeProps(props, data.attrs);
         if (isDef(data.props))
-            { mergeProps(props, data.props); }
+            mergeProps(props, data.props);
     }
-    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    var vnode = options.render.call(null, renderContext._c, renderContext);
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
     if (vnode instanceof VNode) {
         return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
     }
     else if (Array.isArray(vnode)) {
-        var vnodes = normalizeChildren(vnode) || [];
-        var res = new Array(vnodes.length);
-        for (var i = 0; i < vnodes.length; i++) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
             res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
         }
         return res;
@@ -2696,7 +2711,7 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     // #7817 clone node before setting fnContext, otherwise if the node is reused
     // (e.g. it was from a cached normal slot) the fnContext causes named slots
     // that should not be matched to match.
-    var clone = cloneVNode(vnode);
+    const clone = cloneVNode(vnode);
     clone.fnContext = contextVm;
     clone.fnOptions = options;
     if (process.env.NODE_ENV !== 'production') {
@@ -2708,38 +2723,37 @@ function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderCon
     return clone;
 }
 function mergeProps(to, from) {
-    for (var key in from) {
+    for (const key in from) {
         to[camelize(key)] = from[key];
     }
 }
 
 // inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-    init: function init(vnode, hydrating) {
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
         if (vnode.componentInstance &&
             !vnode.componentInstance._isDestroyed &&
             vnode.data.keepAlive) {
             // kept-alive components, treat as a patch
-            var mountedNode = vnode; // work around flow
+            const mountedNode = vnode; // work around flow
             componentVNodeHooks.prepatch(mountedNode, mountedNode);
         }
         else {
-            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
             child.$mount(hydrating ? vnode.elm : undefined, hydrating);
         }
     },
-    prepatch: function prepatch(oldVnode, vnode) {
-        var options = vnode.componentOptions;
-        var child = (vnode.componentInstance = oldVnode.componentInstance);
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
         updateChildComponent(child, options.propsData, // updated props
         options.listeners, // updated listeners
         vnode, // new parent vnode
         options.children // new children
         );
     },
-    insert: function insert(vnode) {
-        var context = vnode.context;
-        var componentInstance = vnode.componentInstance;
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
         if (!componentInstance._isMounted) {
             componentInstance._isMounted = true;
             callHook$1(componentInstance, 'mounted');
@@ -2758,8 +2772,8 @@ var componentVNodeHooks = {
             }
         }
     },
-    destroy: function destroy(vnode) {
-        var componentInstance = vnode.componentInstance;
+    destroy(vnode) {
+        const { componentInstance } = vnode;
         if (!componentInstance._isDestroyed) {
             if (!vnode.data.keepAlive) {
                 componentInstance.$destroy();
@@ -2770,12 +2784,12 @@ var componentVNodeHooks = {
         }
     },
 };
-var hooksToMerge = Object.keys(componentVNodeHooks);
+const hooksToMerge = Object.keys(componentVNodeHooks);
 function createComponent(Ctor, data, context, children, tag) {
     if (isUndef(Ctor)) {
         return;
     }
-    var baseCtor = context.$options._base;
+    const baseCtor = context.$options._base;
     // plain options object: turn it into a constructor
     if (isObject(Ctor)) {
         Ctor = baseCtor.extend(Ctor);
@@ -2784,12 +2798,12 @@ function createComponent(Ctor, data, context, children, tag) {
     // reject.
     if (typeof Ctor !== 'function') {
         if (process.env.NODE_ENV !== 'production') {
-            warn(("Invalid Component definition: " + (String(Ctor))), context);
+            warn(`Invalid Component definition: ${String(Ctor)}`, context);
         }
         return;
     }
     // async component
-    var asyncFactory;
+    let asyncFactory;
     // @ts-expect-error
     if (isUndef(Ctor.cid)) {
         asyncFactory = Ctor;
@@ -2812,7 +2826,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract props
     // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
     // functional component
     // @ts-expect-error
     if (isTrue(Ctor.options.functional)) {
@@ -2820,7 +2834,7 @@ function createComponent(Ctor, data, context, children, tag) {
     }
     // extract listeners, since these needs to be treated as
     // child component listeners instead of DOM listeners
-    var listeners = data.on;
+    const listeners = data.on;
     // replace with listeners with .native modifier
     // so it gets processed during parent component patch.
     data.on = data.nativeOn;
@@ -2829,7 +2843,7 @@ function createComponent(Ctor, data, context, children, tag) {
         // abstract components do not keep anything
         // other than props & listeners & slot
         // work around flow
-        var slot = data.slot;
+        const slot = data.slot;
         data = {};
         if (slot) {
             data.slot = slot;
@@ -2839,12 +2853,12 @@ function createComponent(Ctor, data, context, children, tag) {
     installComponentHooks(data);
     // return a placeholder vnode
     // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
     // @ts-expect-error
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
     // @ts-expect-error
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
     return vnode;
 }
 function createComponentInstanceForVnode(
@@ -2852,13 +2866,13 @@ function createComponentInstanceForVnode(
 vnode, 
 // activeInstance in lifecycle state
 parent) {
-    var options = {
+    const options = {
         _isComponent: true,
         _parentVnode: vnode,
-        parent: parent,
+        parent,
     };
     // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
+    const inlineTemplate = vnode.data.inlineTemplate;
     if (isDef(inlineTemplate)) {
         options.render = inlineTemplate.render;
         options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2866,11 +2880,11 @@ parent) {
     return new vnode.componentOptions.Ctor(options);
 }
 function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-        var key = hooksToMerge[i];
-        var existing = hooks[key];
-        var toMerge = componentVNodeHooks[key];
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
         // @ts-expect-error
         if (existing !== toMerge && !(existing && existing._merged)) {
             hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2878,7 +2892,7 @@ function installComponentHooks(data) {
     }
 }
 function mergeHook(f1, f2) {
-    var merged = function (a, b) {
+    const merged = (a, b) => {
         // flow complains about extra args which is why we use any
         f1(a, b);
         f2(a, b);
@@ -2889,12 +2903,12 @@ function mergeHook(f1, f2) {
 // transform component v-model info (value and callback) into
 // prop and event handler respectively.
 function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input';
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
     (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
     if (isDef(existing)) {
         if (Array.isArray(existing)
             ? existing.indexOf(callback) === -1
@@ -2907,8 +2921,8 @@ function transformModel(options, data) {
     }
 }
 
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
 function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2925,7 +2939,7 @@ function createElement$1(context, tag, data, children, normalizationType, always
 function _createElement(context, tag, data, children, normalizationType) {
     if (isDef(data) && isDef(data.__ob__)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+            warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
         return createEmptyVNode();
     }
     // object syntax in v-bind
@@ -2959,9 +2973,9 @@ function _createElement(context, tag, data, children, normalizationType) {
     else if (normalizationType === SIMPLE_NORMALIZE) {
         children = simpleNormalizeChildren(children);
     }
-    var vnode, ns;
+    let vnode, ns;
     if (typeof tag === 'string') {
-        var Ctor;
+        let Ctor;
         ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
         if (config.isReservedTag(tag)) {
             // platform built-in elements
@@ -2969,7 +2983,7 @@ function _createElement(context, tag, data, children, normalizationType) {
                 isDef(data) &&
                 isDef(data.nativeOn) &&
                 data.tag !== 'component') {
-                warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
             }
             vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
         }
@@ -2994,9 +3008,9 @@ function _createElement(context, tag, data, children, normalizationType) {
     }
     else if (isDef(vnode)) {
         if (isDef(ns))
-            { applyNS(vnode, ns); }
+            applyNS(vnode, ns);
         if (isDef(data))
-            { registerDeepBindings(data); }
+            registerDeepBindings(data);
         return vnode;
     }
     else {
@@ -3011,8 +3025,8 @@ function applyNS(vnode, ns, force) {
         force = true;
     }
     if (isDef(vnode.children)) {
-        for (var i = 0, l = vnode.children.length; i < l; i++) {
-            var child = vnode.children[i];
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
             if (isDef(child.tag) &&
                 (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                 applyNS(child, ns, force);
@@ -3035,9 +3049,9 @@ function registerDeepBindings(data) {
 function initRender(vm) {
     vm._vnode = null; // the root of the child tree
     vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
     vm.$slots = resolveSlots(options._renderChildren, renderContext);
     vm.$scopedSlots = emptyObject;
     // bind the createElement fn to this instance
@@ -3045,21 +3059,21 @@ function initRender(vm) {
     // args order: tag, data, children, normalizationType, alwaysNormalize
     // internal version is used by render functions compiled from templates
     // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
     // normalization is always applied for the public version, used in
     // user-written render functions.
     // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
     // $attrs & $listeners are exposed for easier HOC creation.
     // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
+    const parentData = parentVnode && parentVnode.data;
     /* istanbul ignore else */
     if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
         }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
         }, true);
     }
     else {
@@ -3067,7 +3081,7 @@ function initRender(vm) {
         defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
     }
 }
-var currentRenderingInstance = null;
+let currentRenderingInstance = null;
 function renderMixin(Vue) {
     // install runtime convenience helpers
     installRenderHelpers(Vue.prototype);
@@ -3075,10 +3089,8 @@ function renderMixin(Vue) {
         return nextTick(fn, this);
     };
     Vue.prototype._render = function () {
-        var vm = this;
-        var ref = vm.$options;
-        var render = ref.render;
-        var _parentVnode = ref._parentVnode;
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
         if (_parentVnode) {
             vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
         }
@@ -3086,7 +3098,7 @@ function renderMixin(Vue) {
         // to the data on the placeholder node.
         vm.$vnode = _parentVnode;
         // render self
-        var vnode;
+        let vnode;
         try {
             // There's no need to maintain a stack because all render fns are called
             // separately from one another. Nested component's render fns are called
@@ -3095,7 +3107,7 @@ function renderMixin(Vue) {
             vnode = render.call(vm._renderProxy, vm.$createElement);
         }
         catch (e) {
-            handleError(e, vm, "render");
+            handleError(e, vm, `render`);
             // return error render result,
             // or previous vnode to prevent render error causing blank component
             /* istanbul ignore else */
@@ -3103,8 +3115,8 @@ function renderMixin(Vue) {
                 try {
                     vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                 }
-                catch (e$1) {
-                    handleError(e$1, vm, "renderError");
+                catch (e) {
+                    handleError(e, vm, `renderError`);
                     vnode = vm._vnode;
                 }
             }
@@ -3140,9 +3152,9 @@ function ensureCtor(comp, base) {
     return isObject(comp) ? base.extend(comp) : comp;
 }
 function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
+    const node = createEmptyVNode();
     node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+    node.asyncMeta = { data, context, children, tag };
     return node;
 }
 function resolveAsyncComponent(factory, baseCtor) {
@@ -3152,7 +3164,7 @@ function resolveAsyncComponent(factory, baseCtor) {
     if (isDef(factory.resolved)) {
         return factory.resolved;
     }
-    var owner = currentRenderingInstance;
+    const owner = currentRenderingInstance;
     if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
         // already pending
         factory.owners.push(owner);
@@ -3161,13 +3173,13 @@ function resolveAsyncComponent(factory, baseCtor) {
         return factory.loadingComp;
     }
     if (owner && !isDef(factory.owners)) {
-        var owners = (factory.owners = [owner]);
-        var sync = true;
-        var timerLoading = null;
-        var timerTimeout = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-        var forceRender = function (renderCompleted) {
-            for (var i = 0, l = owners.length; i < l; i++) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
                 owners[i].$forceUpdate();
             }
             if (renderCompleted) {
@@ -3182,7 +3194,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
             }
         };
-        var resolve = once(function (res) {
+        const resolve = once((res) => {
             // cache resolved
             factory.resolved = ensureCtor(res, baseCtor);
             // invoke callbacks only if this is not a synchronous resolve
@@ -3194,16 +3206,16 @@ function resolveAsyncComponent(factory, baseCtor) {
                 owners.length = 0;
             }
         });
-        var reject = once(function (reason) {
+        const reject = once((reason) => {
             process.env.NODE_ENV !== 'production' &&
-                warn("Failed to resolve async component: " + (String(factory)) +
-                    (reason ? ("\nReason: " + reason) : ''));
+                warn(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
             if (isDef(factory.errorComp)) {
                 factory.error = true;
                 forceRender(true);
             }
         });
-        var res = factory(resolve, reject);
+        const res = factory(resolve, reject);
         if (isObject(res)) {
             if (isPromise(res)) {
                 // () => Promise
@@ -3223,7 +3235,7 @@ function resolveAsyncComponent(factory, baseCtor) {
                     }
                     else {
                         // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(function () {
+                        timerLoading = setTimeout(() => {
                             timerLoading = null;
                             if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                 factory.loading = true;
@@ -3234,11 +3246,11 @@ function resolveAsyncComponent(factory, baseCtor) {
                 }
                 if (isDef(res.timeout)) {
                     // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(function () {
+                    timerTimeout = setTimeout(() => {
                         timerTimeout = null;
                         if (isUndef(factory.resolved)) {
                             reject(process.env.NODE_ENV !== 'production'
-                                ? ("timeout (" + (res.timeout) + "ms)")
+                                ? `timeout (${res.timeout}ms)`
                                 : null);
                         }
                     }, res.timeout);
@@ -3251,15 +3263,10 @@ function resolveAsyncComponent(factory, baseCtor) {
     }
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
 function getFirstComponentChild(children) {
     if (Array.isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-            var c = children[i];
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
             if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                 return c;
             }
@@ -3271,12 +3278,12 @@ function initEvents(vm) {
     vm._events = Object.create(null);
     vm._hasHookEvent = false;
     // init parent attached events
-    var listeners = vm.$options._parentListeners;
+    const listeners = vm.$options._parentListeners;
     if (listeners) {
         updateComponentListeners(vm, listeners);
     }
 }
-var target$1;
+let target$1;
 function add$1(event, fn) {
     target$1.$on(event, fn);
 }
@@ -3284,9 +3291,9 @@ function remove$1(event, fn) {
     target$1.$off(event, fn);
 }
 function createOnceHandler$1(event, fn) {
-    var _target = target$1;
+    const _target = target$1;
     return function onceHandler() {
-        var res = fn.apply(null, arguments);
+        const res = fn.apply(null, arguments);
         if (res !== null) {
             _target.$off(event, onceHandler);
         }
@@ -3298,11 +3305,11 @@ function updateComponentListeners(vm, listeners, oldListeners) {
     target$1 = undefined;
 }
 function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
+    const hookRE = /^hook:/;
     Vue.prototype.$on = function (event, fn) {
-        var vm = this;
+        const vm = this;
         if (Array.isArray(event)) {
-            for (var i = 0, l = event.length; i < l; i++) {
+            for (let i = 0, l = event.length; i < l; i++) {
                 vm.$on(event[i], fn);
             }
         }
@@ -3317,7 +3324,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$once = function (event, fn) {
-        var vm = this;
+        const vm = this;
         function on() {
             vm.$off(event, on);
             fn.apply(vm, arguments);
@@ -3327,7 +3334,7 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$off = function (event, fn) {
-        var vm = this;
+        const vm = this;
         // all
         if (!arguments.length) {
             vm._events = Object.create(null);
@@ -3335,13 +3342,13 @@ function eventsMixin(Vue) {
         }
         // array of events
         if (Array.isArray(event)) {
-            for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                vm.$off(event[i$1], fn);
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
             }
             return vm;
         }
         // specific event
-        var cbs = vm._events[event];
+        const cbs = vm._events[event];
         if (!cbs) {
             return vm;
         }
@@ -3350,8 +3357,8 @@ function eventsMixin(Vue) {
             return vm;
         }
         // specific handler
-        var cb;
-        var i = cbs.length;
+        let cb;
+        let i = cbs.length;
         while (i--) {
             cb = cbs[i];
             if (cb === fn || cb.fn === fn) {
@@ -3362,23 +3369,23 @@ function eventsMixin(Vue) {
         return vm;
     };
     Vue.prototype.$emit = function (event) {
-        var vm = this;
+        const vm = this;
         if (process.env.NODE_ENV !== 'production') {
-            var lowerCaseEvent = event.toLowerCase();
+            const lowerCaseEvent = event.toLowerCase();
             if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                    "Note that HTML attributes are case-insensitive and you cannot use " +
-                    "v-on to listen to camelCase events when using in-DOM templates. " +
-                    "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
             }
         }
-        var cbs = vm._events[event];
+        let cbs = vm._events[event];
         if (cbs) {
             cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            var args = toArray(arguments, 1);
-            var info = "event handler for \"" + event + "\"";
-            for (var i = 0, l = cbs.length; i < l; i++) {
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
                 invokeWithErrorHandling(cbs[i], vm, args, vm, info);
             }
         }
@@ -3386,19 +3393,19 @@ function eventsMixin(Vue) {
     };
 }
 
-var activeInstance = null;
-var isUpdatingChildComponent = false;
+let activeInstance = null;
+let isUpdatingChildComponent = false;
 function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
+    const prevActiveInstance = activeInstance;
     activeInstance = vm;
-    return function () {
+    return () => {
         activeInstance = prevActiveInstance;
     };
 }
 function initLifecycle(vm) {
-    var options = vm.$options;
+    const options = vm.$options;
     // locate first non-abstract parent
-    var parent = options.parent;
+    let parent = options.parent;
     if (parent && !options.abstract) {
         while (parent.$options.abstract && parent.$parent) {
             parent = parent.$parent;
@@ -3409,7 +3416,6 @@ function initLifecycle(vm) {
     vm.$root = parent ? parent.$root : vm;
     vm.$children = [];
     vm.$refs = {};
-    // @ts-ignore
     vm._watcher = null;
     vm._inactive = null;
     vm._directInactive = false;
@@ -3419,10 +3425,10 @@ function initLifecycle(vm) {
 }
 function lifecycleMixin(Vue) {
     Vue.prototype._update = function (vnode, hydrating) {
-        var vm = this;
-        var prevEl = vm.$el;
-        var prevVnode = vm._vnode;
-        var restoreActiveInstance = setActiveInstance(vm);
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
         vm._vnode = vnode;
         // Vue.prototype.__patch__ is injected in entry points
         // based on the rendering backend used.
@@ -3450,21 +3456,20 @@ function lifecycleMixin(Vue) {
         // updated in a parent's updated hook.
     };
     Vue.prototype.$forceUpdate = function () {
-        var vm = this;
+        const vm = this;
         if (vm._watcher) {
             vm._watcher.update();
         }
     };
     Vue.prototype.$destroy = function () {
-        var vm = this;
+        const vm = this;
         if (vm._isBeingDestroyed) {
             return;
         }
-        callHook$1(vm, 'beforeDestroy');
+        callHook$1(vm, "beforeDestroy");
         vm._isBeingDestroyed = true;
         // remove self from parent
-        var parent = vm.$parent;
-        // @ts-ignore
+        const parent = vm.$parent;
         if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
             remove$2(parent.$children, vm);
         }
@@ -3472,7 +3477,7 @@ function lifecycleMixin(Vue) {
         if (vm._watcher) {
             vm._watcher.teardown();
         }
-        var i = vm._watchers.length;
+        let i = vm._watchers.length;
         while (i--) {
             vm._watchers[i].teardown();
         }
@@ -3486,7 +3491,7 @@ function lifecycleMixin(Vue) {
         // invoke destroy hooks on current rendered tree
         vm.__patch__(vm._vnode, null);
         // fire destroyed hook
-        callHook$1(vm, 'destroyed');
+        callHook$1(vm, "destroyed");
         // turn off all instance listeners.
         vm.$off();
         // remove __vue__ reference
@@ -3495,7 +3500,6 @@ function lifecycleMixin(Vue) {
         }
         // release circular reference (#6759)
         if (vm.$vnode) {
-            // @ts-expect-error null is not undefined
             vm.$vnode.parent = null;
         }
     };
@@ -3505,41 +3509,41 @@ function mountComponent(vm, el, hydrating) {
     if (!vm.$options.render) {
         // @ts-expect-error invalid type
         vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== 'production') {
+        if (process.env.NODE_ENV !== "production") {
             /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                 vm.$options.el ||
                 el) {
-                warn('You are using the runtime-only build of Vue where the template ' +
-                    'compiler is not available. Either pre-compile the templates into ' +
-                    'render functions, or use the compiler-included build.', vm);
+                warn("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
             }
             else {
-                warn('Failed to mount component: template or render function not defined.', vm);
+                warn("Failed to mount component: template or render function not defined.", vm);
             }
         }
     }
-    callHook$1(vm, 'beforeMount');
-    var updateComponent;
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        updateComponent = function () {
-            var name = vm._name;
-            var id = vm._uid;
-            var startTag = "vue-perf-start:" + id;
-            var endTag = "vue-perf-end:" + id;
+    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
             mark(startTag);
-            var vnode = vm._render();
+            const vnode = vm._render();
             mark(endTag);
-            measure(("vue " + name + " render"), startTag, endTag);
+            measure(`vue ${name} render`, startTag, endTag);
             mark(startTag);
             vm._update(vnode, hydrating);
             mark(endTag);
-            measure(("vue " + name + " patch"), startTag, endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
         };
     }
     else {
-        updateComponent = function () {
+        updateComponent = () => {
             vm._update(vm._render(), hydrating);
         };
     }
@@ -3547,9 +3551,9 @@ function mountComponent(vm, el, hydrating) {
     // since the watcher's initial patch may call $forceUpdate (e.g. inside child
     // component's mounted hook), which relies on vm._watcher being already defined
     new Watcher(vm, updateComponent, noop, {
-        before: function before() {
+        before() {
             if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, 'beforeUpdate');
+                callHook$1(vm, "beforeUpdate");
             }
         },
     }, true /* isRenderWatcher */);
@@ -3558,12 +3562,12 @@ function mountComponent(vm, el, hydrating) {
     // mounted is called for render-created child components in its inserted hook
     if (vm.$vnode == null) {
         vm._isMounted = true;
-        callHook$1(vm, 'mounted');
+        callHook$1(vm, "mounted");
     }
     return vm;
 }
 function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
         isUpdatingChildComponent = true;
     }
     // determine whether component has slot children
@@ -3571,24 +3575,22 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // check if there are dynamic scopedSlots (hand-written or compiled but with
     // dynamic slot names). Static scoped slots compiled from template has the
     // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
         (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
     // Any static slot children from the parent may have changed during parent's
     // update. Dynamic scoped slots may also have changed. In such cases, a forced
     // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(renderChildren || // has new static slots
+    const needsForceUpdate = !!(renderChildren || // has new static slots
         vm.$options._renderChildren || // has old static slots
         hasDynamicScopedSlot);
-    // @ts-ignore
     vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
     vm.$vnode = parentVnode; // update vm's placeholder node without re-render
     if (vm._vnode) {
         // update child tree's parent
-        // @ts-ignore
         vm._vnode.parent = parentVnode;
     }
     vm.$options._renderChildren = renderChildren;
@@ -3596,16 +3598,15 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     // these are also reactive so they may trigger child update if the child
     // used them during render
     vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
     vm.$listeners = listeners || emptyObject;
     // update props
     if (propsData && vm.$options.props) {
         toggleObserving(false);
-        var props = vm._props;
-        var propKeys = vm.$options._propKeys || [];
-        for (var i = 0; i < propKeys.length; i++) {
-            var key = propKeys[i];
-            var propOptions = vm.$options.props; // wtf flow?
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
             props[key] = validateProp(key, propOptions, propsData, vm);
         }
         toggleObserving(true);
@@ -3614,7 +3615,7 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
     }
     // update listeners
     listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
+    const oldListeners = vm.$options._parentListeners;
     vm.$options._parentListeners = listeners;
     updateComponentListeners(vm, listeners, oldListeners);
     // resolve slots + force update if has children
@@ -3622,14 +3623,14 @@ function updateChildComponent(vm, propsData, listeners, parentVnode, renderChild
         vm.$slots = resolveSlots(renderChildren, parentVnode.context);
         vm.$forceUpdate();
     }
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
         isUpdatingChildComponent = false;
     }
 }
 function isInInactiveTree(vm) {
     while (vm && (vm = vm.$parent)) {
         if (vm._inactive)
-            { return true; }
+            return true;
     }
     return false;
 }
@@ -3645,10 +3646,10 @@ function activateChildComponent(vm, direct) {
     }
     if (vm._inactive || vm._inactive === null) {
         vm._inactive = false;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             activateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'activated');
+        callHook$1(vm, "activated");
     }
 }
 function deactivateChildComponent(vm, direct) {
@@ -3660,36 +3661,36 @@ function deactivateChildComponent(vm, direct) {
     }
     if (!vm._inactive) {
         vm._inactive = true;
-        for (var i = 0; i < vm.$children.length; i++) {
+        for (let i = 0; i < vm.$children.length; i++) {
             deactivateChildComponent(vm.$children[i]);
         }
-        callHook$1(vm, 'deactivated');
+        callHook$1(vm, "deactivated");
     }
 }
 function callHook$1(vm, hook) {
     // #7573 disable dep collection when invoking lifecycle hooks
     pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
     if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
             invokeWithErrorHandling(handlers[i], vm, null, vm, info);
         }
     }
     if (vm._hasHookEvent) {
-        vm.$emit('hook:' + hook);
+        vm.$emit("hook:" + hook);
     }
     popTarget();
 }
 
-var MAX_UPDATE_COUNT = 100;
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index = 0;
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index = 0;
 /**
  * Reset the scheduler's state.
  */
@@ -3706,9 +3707,9 @@ function resetSchedulerState() {
 // if the page has thousands of event listeners. Instead, we take a timestamp
 // every time the scheduler flushes and use that for all event listeners
 // attached during that flush.
-var currentFlushTimestamp = 0;
+let currentFlushTimestamp = 0;
 // Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
+let getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3716,7 +3717,7 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-    var performance = window.performance;
+    const performance = window.performance;
     if (performance &&
         typeof performance.now === 'function' &&
         getNow() > document.createEvent('Event').timeStamp) {
@@ -3724,7 +3725,7 @@ if (inBrowser && !isIE) {
         // smaller than it, it means the event is using a hi-res timestamp,
         // and we need to use the hi-res version for event listener timestamps as
         // well.
-        getNow = function () { return performance.now(); };
+        getNow = () => performance.now();
     }
 }
 /**
@@ -3733,7 +3734,7 @@ if (inBrowser && !isIE) {
 function flushSchedulerQueue() {
     currentFlushTimestamp = getNow();
     flushing = true;
-    var watcher, id;
+    let watcher, id;
     // Sort queue before flush.
     // This ensures that:
     // 1. Components are updated from parent to child. (because parent is always
@@ -3742,7 +3743,7 @@ function flushSchedulerQueue() {
     //    user watchers are created before the render watcher)
     // 3. If a component is destroyed during a parent component's watcher run,
     //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
+    queue.sort((a, b) => a.id - b.id);
     // do not cache length because more watchers might be pushed
     // as we run existing watchers
     for (index = 0; index < queue.length; index++) {
@@ -3759,15 +3760,15 @@ function flushSchedulerQueue() {
             if (circular[id] > MAX_UPDATE_COUNT) {
                 warn('You may have an infinite update loop ' +
                     (watcher.user
-                        ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                        : "in a component render function."), watcher.vm);
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
                 break;
             }
         }
     }
     // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
     resetSchedulerState();
     // call component updated and activated hooks
     callActivatedHooks(activatedQueue);
@@ -3779,10 +3780,10 @@ function flushSchedulerQueue() {
     }
 }
 function callUpdatedHooks(queue) {
-    var i = queue.length;
+    let i = queue.length;
     while (i--) {
-        var watcher = queue[i];
-        var vm = watcher.vm;
+        const watcher = queue[i];
+        const vm = watcher.vm;
         if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
             callHook$1(vm, 'updated');
         }
@@ -3799,7 +3800,7 @@ function queueActivatedComponent(vm) {
     activatedChildren.push(vm);
 }
 function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
+    for (let i = 0; i < queue.length; i++) {
         queue[i]._inactive = true;
         activateChildComponent(queue[i], true /* true */);
     }
@@ -3810,7 +3811,7 @@ function callActivatedHooks(queue) {
  * pushed when the queue is being flushed.
  */
 function queueWatcher(watcher) {
-    var id = watcher.id;
+    const id = watcher.id;
     if (has[id] == null) {
         has[id] = true;
         if (!flushing) {
@@ -3819,7 +3820,7 @@ function queueWatcher(watcher) {
         else {
             // if already flushing, splice the watcher based on its id
             // if already past its id, it will be run next immediately.
-            var i = queue.length - 1;
+            let i = queue.length - 1;
             while (i > index && queue[i].id > watcher.id) {
                 i--;
             }
@@ -3837,200 +3838,218 @@ function queueWatcher(watcher) {
     }
 }
 
-var uid$1 = 0;
+let uid$1 = 0;
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-    this.vm = vm;
-    if (isRenderWatcher) {
-        vm._watcher = this;
-    }
-    vm._watchers.push(this);
-    // options
-    if (options) {
-        this.deep = !!options.deep;
-        this.user = !!options.user;
-        this.lazy = !!options.lazy;
-        this.sync = !!options.sync;
-        this.before = options.before;
-    }
-    else {
-        this.deep = this.user = this.lazy = this.sync = false;
-    }
-    this.cb = cb;
-    this.id = ++uid$1; // uid for batching
-    this.active = true;
-    this.dirty = this.lazy; // for lazy watchers
-    this.deps = [];
-    this.newDeps = [];
-    this.depIds = new _Set();
-    this.newDepIds = new _Set();
-    this.expression =
-        process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-    // parse expression for getter
-    if (typeof expOrFn === 'function') {
-        this.getter = expOrFn;
-    }
-    else {
-        this.getter = parsePath(expOrFn);
-        if (!this.getter) {
-            this.getter = noop;
-            process.env.NODE_ENV !== 'production' &&
-                warn("Failed watching path: \"" + expOrFn + "\" " +
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = process.env.NODE_ENV !== 'production'
+            ? expOrFn.toString()
+            : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' && warn(`Failed watching path: "${expOrFn}" ` +
                     'Watcher only accepts simple dot-delimited paths. ' +
                     'For full control, use a function instead.', vm);
+            }
         }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
     }
-    this.value = this.lazy ? undefined : this.get();
-};
-/**
- * Evaluate the getter, and re-collect dependencies.
- */
-Watcher.prototype.get = function get () {
-    pushTarget(this);
-    var value;
-    var vm = this.vm;
-    try {
-        value = this.getter.call(vm, vm);
-    }
-    catch (e) {
-        if (this.user) {
-            handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
         }
-        else {
-            throw e;
+        catch (e) {
+            if (this.user) {
+                // @ts-expect-error e is unknown, should we cast or any?
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
         }
-    }
-    finally {
-        // "touch" every property so they are all tracked as
-        // dependencies for deep watching
-        if (this.deep) {
-            traverse(value);
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
         }
-        popTarget();
-        this.cleanupDeps();
+        return value;
     }
-    return value;
-};
-/**
- * Add a dependency to this directive.
- */
-Watcher.prototype.addDep = function addDep (dep) {
-    var id = dep.id;
-    if (!this.newDepIds.has(id)) {
-        this.newDepIds.add(id);
-        this.newDeps.push(dep);
-        if (!this.depIds.has(id)) {
-            dep.addSub(this);
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
         }
     }
-};
-/**
- * Clean up for dependency collection.
- */
-Watcher.prototype.cleanupDeps = function cleanupDeps () {
-    var i = this.deps.length;
-    while (i--) {
-        var dep = this.deps[i];
-        if (!this.newDepIds.has(dep.id)) {
-            dep.removeSub(this);
-        }
-    }
-    var tmp = this.depIds;
-    this.depIds = this.newDepIds;
-    this.newDepIds = tmp;
-    this.newDepIds.clear();
-    tmp = this.deps;
-    this.deps = this.newDeps;
-    this.newDeps = tmp;
-    this.newDeps.length = 0;
-};
-/**
- * Subscriber interface.
- * Will be called when a dependency changes.
- */
-Watcher.prototype.update = function update () {
-    /* istanbul ignore else */
-    if (this.lazy) {
-        this.dirty = true;
-    }
-    else if (this.sync) {
-        this.run();
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
     }
-    else {
-        queueWatcher(this);
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
     }
-};
-/**
- * Scheduler job interface.
- * Will be called by the scheduler.
- */
-Watcher.prototype.run = function run () {
-    if (this.active) {
-        var value = this.get();
-        if (value !== this.value ||
-            // Deep watchers and watchers on Object/Arrays should fire even
-            // when the value is the same, because the value may
-            // have mutated.
-            isObject(value) ||
-            this.deep) {
-            // set new value
-            var oldValue = this.value;
-            this.value = value;
-            if (this.user) {
-                try {
-                    this.cb.call(this.vm, value, oldValue);
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                 }
-                catch (e) {
-                    handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                else {
+                    this.cb.call(this.vm, value, oldValue);
                 }
             }
-            else {
-                this.cb.call(this.vm, value, oldValue);
-            }
         }
     }
-};
-/**
- * Evaluate the value of the watcher.
- * This only gets called for lazy watchers.
- */
-Watcher.prototype.evaluate = function evaluate () {
-    this.value = this.get();
-    this.dirty = false;
-};
-/**
- * Depend on all deps collected by this watcher.
- */
-Watcher.prototype.depend = function depend () {
-    var i = this.deps.length;
-    while (i--) {
-        this.deps[i].depend();
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
     }
-};
-/**
- * Remove self from all dependencies' subscriber list.
- */
-Watcher.prototype.teardown = function teardown () {
-    if (this.active) {
-        // remove self from vm's watcher list
-        // this is a somewhat expensive operation so we skip it
-        // if the vm is being destroyed.
-        if (!this.vm._isBeingDestroyed) {
-            remove$2(this.vm._watchers, this);
-        }
-        var i = this.deps.length;
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
         while (i--) {
-            this.deps[i].removeSub(this);
+            this.deps[i].depend();
         }
-        this.active = false;
     }
-};
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
+}
 
-var sharedPropertyDefinition = {
+const sharedPropertyDefinition = {
     enumerable: true,
     configurable: true,
     get: noop,
@@ -4047,11 +4066,11 @@ function proxy(target, sourceKey, key) {
 }
 function initState(vm) {
     vm._watchers = [];
-    var opts = vm.$options;
+    const opts = vm.$options;
     if (opts.props)
-        { initProps$1(vm, opts.props); }
+        initProps$1(vm, opts.props);
     if (opts.methods)
-        { initMethods(vm, opts.methods); }
+        initMethods(vm, opts.methods);
     if (opts.data) {
         initData(vm);
     }
@@ -4059,38 +4078,38 @@ function initState(vm) {
         observe((vm._data = {}), true /* asRootData */);
     }
     if (opts.computed)
-        { initComputed$1(vm, opts.computed); }
+        initComputed$1(vm, opts.computed);
     if (opts.watch && opts.watch !== nativeWatch) {
         initWatch(vm, opts.watch);
     }
 }
 function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
     // cache prop keys so that future props updates can iterate using Array
     // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
     // root instance props should be converted
     if (!isRoot) {
         toggleObserving(false);
     }
-    var loop = function ( key ) {
+    for (const key in propsOptions) {
         keys.push(key);
-        var value = validateProp(key, propsOptions, propsData, vm);
+        const value = validateProp(key, propsOptions, propsData, vm);
         /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            var hyphenatedKey = hyphenate(key);
+        if (process.env.NODE_ENV !== "production") {
+            const hyphenatedKey = hyphenate(key);
             if (isReservedAttribute(hyphenatedKey) ||
                 config.isReservedAttr(hyphenatedKey)) {
-                warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
             }
-            defineReactive(props, key, value, function () {
+            defineReactive(props, key, value, () => {
                 if (!isRoot && !isUpdatingChildComponent) {
-                    warn("Avoid mutating a prop directly since the value will be " +
-                        "overwritten whenever the parent component re-renders. " +
-                        "Instead, use a data or computed property based on the prop's " +
-                        "value. Prop being mutated: \"" + key + "\"", vm);
+                    warn(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
                 }
             });
         }
@@ -4101,41 +4120,39 @@ function initProps$1(vm, propsOptions) {
         // during Vue.extend(). We only need to proxy props defined at
         // instantiation here.
         if (!(key in vm)) {
-            proxy(vm, "_props", key);
+            proxy(vm, `_props`, key);
         }
-    };
-
-    for (var key in propsOptions) loop( key );
+    }
     toggleObserving(true);
 }
 function initData(vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
     if (!isPlainObject(data)) {
         data = {};
-        process.env.NODE_ENV !== 'production' &&
-            warn('data functions should return an object:\n' +
-                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+        process.env.NODE_ENV !== "production" &&
+            warn("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
     }
     // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
     while (i--) {
-        var key = keys[i];
-        if (process.env.NODE_ENV !== 'production') {
+        const key = keys[i];
+        if (process.env.NODE_ENV !== "production") {
             if (methods && hasOwn(methods, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                warn(`Method "${key}" has already been defined as a data property.`, vm);
             }
         }
         if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn("The data property \"" + key + "\" is already declared as a prop. " +
-                    "Use prop default value instead.", vm);
+            process.env.NODE_ENV !== "production" &&
+                warn(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
         }
         else if (!isReserved(key)) {
-            proxy(vm, "_data", key);
+            proxy(vm, `_data`, key);
         }
     }
     // observe data
@@ -4148,24 +4165,24 @@ function getData(data, vm) {
         return data.call(vm, vm);
     }
     catch (e) {
-        handleError(e, vm, "data()");
+        handleError(e, vm, `data()`);
         return {};
     }
     finally {
         popTarget();
     }
 }
-var computedWatcherOptions = { lazy: true };
+const computedWatcherOptions = { lazy: true };
 function initComputed$1(vm, computed) {
     // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
+    const watchers = (vm._computedWatchers = Object.create(null));
     // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-        var userDef = computed[key];
-        var getter = typeof userDef === 'function' ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== "production" && getter == null) {
+            warn(`Getter is missing for computed property "${key}".`, vm);
         }
         if (!isSSR) {
             // create internal watcher for the computed property.
@@ -4177,19 +4194,22 @@ function initComputed$1(vm, computed) {
         if (!(key in vm)) {
             defineComputed(vm, key, userDef);
         }
-        else if (process.env.NODE_ENV !== 'production') {
+        else if (process.env.NODE_ENV !== "production") {
             if (key in vm.$data) {
-                warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                warn(`The computed property "${key}" is already defined in data.`, vm);
             }
             else if (vm.$options.props && key in vm.$options.props) {
-                warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                warn(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn(`The computed property "${key}" is already defined as a method.`, vm);
             }
         }
     }
 }
 function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
         sharedPropertyDefinition.get = shouldCache
             ? createComputedGetter(key)
             : createGetterInvoker(userDef);
@@ -4203,17 +4223,17 @@ function defineComputed(target, key, userDef) {
             : noop;
         sharedPropertyDefinition.set = userDef.set || noop;
     }
-    if (process.env.NODE_ENV !== 'production' &&
+    if (process.env.NODE_ENV !== "production" &&
         sharedPropertyDefinition.set === noop) {
         sharedPropertyDefinition.set = function () {
-            warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
         };
     }
     Object.defineProperty(target, key, sharedPropertyDefinition);
 }
 function createComputedGetter(key) {
     return function computedGetter() {
-        var watcher = this._computedWatchers && this._computedWatchers[key];
+        const watcher = this._computedWatchers && this._computedWatchers[key];
         if (watcher) {
             if (watcher.dirty) {
                 watcher.evaluate();
@@ -4231,29 +4251,30 @@ function createGetterInvoker(fn) {
     };
 }
 function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                    "Did you reference the function correctly?", vm);
+    const props = vm.$options.props;
+    for (const key in methods) {
+        if (process.env.NODE_ENV !== "production") {
+            if (typeof methods[key] !== "function") {
+                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
             }
             if (props && hasOwn(props, key)) {
-                warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                warn(`Method "${key}" has already been defined as a prop.`, vm);
             }
             if (key in vm && isReserved(key)) {
-                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                    "Avoid defining component methods that start with _ or $.");
+                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
             }
         }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
     }
 }
 function initWatch(vm, watch) {
-    for (var key in watch) {
-        var handler = watch[key];
+    for (const key in watch) {
+        const handler = watch[key];
         if (Array.isArray(handler)) {
-            for (var i = 0; i < handler.length; i++) {
+            for (let i = 0; i < handler.length; i++) {
                 createWatcher(vm, key, handler[i]);
             }
         }
@@ -4267,7 +4288,7 @@ function createWatcher(vm, expOrFn, handler, options) {
         options = handler;
         handler = handler.handler;
     }
-    if (typeof handler === 'string') {
+    if (typeof handler === "string") {
         handler = vm[handler];
     }
     return vm.$watch(expOrFn, handler, options);
@@ -4276,43 +4297,39 @@ function stateMixin(Vue) {
     // flow somehow has problems with directly declared definition object
     // when using Object.defineProperty, so we have to procedurally build up
     // the object here.
-    var dataDef = {};
+    const dataDef = {};
     dataDef.get = function () {
         return this._data;
     };
-    var propsDef = {};
+    const propsDef = {};
     propsDef.get = function () {
         return this._props;
     };
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.NODE_ENV !== "production") {
         dataDef.set = function () {
-            warn('Avoid replacing instance root $data. ' +
-                'Use nested data properties instead.', this);
+            warn("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
         };
         propsDef.set = function () {
-            warn("$props is readonly.", this);
+            warn(`$props is readonly.`, this);
         };
     }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
     Vue.prototype.$set = set;
     Vue.prototype.$delete = del;
     Vue.prototype.$watch = function (expOrFn, cb, options) {
-        var vm = this;
+        const vm = this;
         if (isPlainObject(cb)) {
             return createWatcher(vm, expOrFn, cb, options);
         }
         options = options || {};
         options.user = true;
-        var watcher = new Watcher(vm, expOrFn, cb, options);
+        const watcher = new Watcher(vm, expOrFn, cb, options);
         if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
             pushTarget();
-            try {
-                cb.call(vm, watcher.value);
-            }
-            catch (error) {
-                handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-            }
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
             popTarget();
         }
         return function unwatchFn() {
@@ -4321,17 +4338,17 @@ function stateMixin(Vue) {
     };
 }
 
-var uid = 0;
+let uid = 0;
 function initMixin$1(Vue) {
     Vue.prototype._init = function (options) {
-        var vm = this;
+        const vm = this;
         // a uid
         vm._uid = uid++;
-        var startTag, endTag;
+        let startTag, endTag;
         /* istanbul ignore if */
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + (vm._uid);
-            endTag = "vue-perf-end:" + (vm._uid);
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
             mark(startTag);
         }
         // a flag to avoid this being observed
@@ -4367,7 +4384,7 @@ function initMixin$1(Vue) {
         if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
             vm._name = formatComponentName(vm, false);
             mark(endTag);
-            measure(("vue " + (vm._name) + " init"), startTag, endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
         }
         if (vm.$options.el) {
             vm.$mount(vm.$options.el);
@@ -4375,13 +4392,12 @@ function initMixin$1(Vue) {
     };
 }
 function initInternalComponent(vm, options) {
-    // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
+    const opts = (vm.$options = Object.create(vm.constructor.options));
     // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
+    const parentVnode = options._parentVnode;
     opts.parent = options.parent;
     opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
+    const vnodeComponentOptions = parentVnode.componentOptions;
     opts.propsData = vnodeComponentOptions.propsData;
     opts._parentListeners = vnodeComponentOptions.listeners;
     opts._renderChildren = vnodeComponentOptions.children;
@@ -4392,16 +4408,16 @@ function initInternalComponent(vm, options) {
     }
 }
 function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
+    let options = Ctor.options;
     if (Ctor.super) {
-        var superOptions = resolveConstructorOptions(Ctor.super);
-        var cachedSuperOptions = Ctor.superOptions;
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
         if (superOptions !== cachedSuperOptions) {
             // super option changed,
             // need to resolve new options.
             Ctor.superOptions = superOptions;
             // check if there are any late-modified/attached options (#4976)
-            var modifiedOptions = resolveModifiedOptions(Ctor);
+            const modifiedOptions = resolveModifiedOptions(Ctor);
             // update base extend options
             if (modifiedOptions) {
                 extend(Ctor.extendOptions, modifiedOptions);
@@ -4415,13 +4431,13 @@ function resolveConstructorOptions(Ctor) {
     return options;
 }
 function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
         if (latest[key] !== sealed[key]) {
             if (!modified)
-                { modified = {}; }
+                modified = {};
             modified[key] = latest[key];
         }
     }
@@ -4429,30 +4445,30 @@ function resolveModifiedOptions(Ctor) {
 }
 
 function Vue(options) {
-    if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
-        warn('Vue is a constructor and should be called with the `new` keyword');
+    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
+        warn("Vue is a constructor and should be called with the `new` keyword");
     }
     this._init(options);
 }
-//@ts-ignore
+//@ts-expect-error Vue has function type
 initMixin$1(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 stateMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 eventsMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 lifecycleMixin(Vue);
-//@ts-ignore
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
 function initUse(Vue) {
     Vue.use = function (plugin) {
-        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
         if (installedPlugins.indexOf(plugin) > -1) {
             return this;
         }
         // additional parameters
-        var args = toArray(arguments, 1);
+        const args = toArray(arguments, 1);
         args.unshift(this);
         if (typeof plugin.install === 'function') {
             plugin.install.apply(plugin, args);
@@ -4479,23 +4495,23 @@ function initExtend(Vue) {
      * constructors" for prototypal inheritance and cache them.
      */
     Vue.cid = 0;
-    var cid = 1;
+    let cid = 1;
     /**
      * Class inheritance
      */
     Vue.extend = function (extendOptions) {
         extendOptions = extendOptions || {};
-        var Super = this;
-        var SuperId = Super.cid;
-        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
         if (cachedCtors[SuperId]) {
             return cachedCtors[SuperId];
         }
-        var name = extendOptions.name || Super.options.name;
+        const name = extendOptions.name || Super.options.name;
         if (process.env.NODE_ENV !== 'production' && name) {
             validateComponentName(name);
         }
-        var Sub = function VueComponent(options) {
+        const Sub = function VueComponent(options) {
             this._init(options);
         };
         Sub.prototype = Object.create(Super.prototype);
@@ -4537,14 +4553,14 @@ function initExtend(Vue) {
     };
 }
 function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-        proxy(Comp.prototype, "_props", key);
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
     }
 }
 function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
         defineComputed(Comp.prototype, key, computed[key]);
     }
 }
@@ -4553,7 +4569,7 @@ function initAssetRegisters(Vue) {
     /**
      * Create asset registration methods.
      */
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         // @ts-expect-error function is not exact same type
         Vue[type] = function (id, definition) {
             if (!definition) {
@@ -4579,6 +4595,7 @@ function initAssetRegisters(Vue) {
     });
 }
 
+/* @flow */
 function getComponentName(opts) {
     return opts && (opts.Ctor.options.name || opts.tag);
 }
@@ -4586,8 +4603,8 @@ function matches(pattern, name) {
     if (Array.isArray(pattern)) {
         return pattern.indexOf(name) > -1;
     }
-    else if (typeof pattern === 'string') {
-        return pattern.split(',').indexOf(name) > -1;
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
     }
     else if (isRegExp(pattern)) {
         return pattern.test(name);
@@ -4596,13 +4613,11 @@ function matches(pattern, name) {
     return false;
 }
 function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache;
-    var keys = keepAliveInstance.keys;
-    var _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-        var cachedNode = cache[key];
-        if (cachedNode) {
-            var name = getComponentName(cachedNode.componentOptions);
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
             if (name && !filter(name)) {
                 pruneCacheEntry(cache, key, keys, _vnode);
             }
@@ -4610,53 +4625,72 @@ function pruneCache(keepAliveInstance, filter) {
     }
 }
 function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-        //@ts-expect-error has void type
-        cached.componentInstance.$destroy();
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
     }
     cache[key] = null;
     remove$2(keys, key);
 }
-var patternTypes = [String, RegExp, Array];
-// TODO use defineComponent
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
 var KeepAlive = {
-    name: 'keep-alive',
+    name: "keep-alive",
     abstract: true,
     props: {
         include: patternTypes,
         exclude: patternTypes,
         max: [String, Number],
     },
-    created: function created() {
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
         this.cache = Object.create(null);
         this.keys = [];
     },
-    destroyed: function destroyed() {
-        for (var key in this.cache) {
+    destroyed() {
+        for (const key in this.cache) {
             pruneCacheEntry(this.cache, key, this.keys);
         }
     },
-    mounted: function mounted() {
-        var this$1 = this;
-
-        this.$watch('include', function (val) {
-            pruneCache(this$1, function (name) { return matches(val, name); });
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
         });
-        this.$watch('exclude', function (val) {
-            pruneCache(this$1, function (name) { return !matches(val, name); });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
         });
     },
-    render: function render() {
-        var slot = this.$slots.default;
-        var vnode = getFirstComponentChild(slot);
-        var componentOptions = vnode && vnode.componentOptions;
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
         if (componentOptions) {
             // check pattern
-            var name = getComponentName(componentOptions);
-            var ref = this;
-            var include = ref.include;
-            var exclude = ref.exclude;
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
             if (
             // not included
             (include && (!name || !matches(include, name))) ||
@@ -4664,14 +4698,12 @@ var KeepAlive = {
                 (exclude && name && matches(exclude, name))) {
                 return vnode;
             }
-            var ref$1 = this;
-            var cache = ref$1.cache;
-            var keys = ref$1.keys;
-            var key = vnode.key == null
+            const { cache, keys } = this;
+            const key = vnode.key == null
                 ? // same constructor may get registered as different local components
                     // so cid alone is not enough (#3269)
                     componentOptions.Ctor.cid +
-                        (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
                 : vnode.key;
             if (cache[key]) {
                 vnode.componentInstance = cache[key].componentInstance;
@@ -4680,13 +4712,11 @@ var KeepAlive = {
                 keys.push(key);
             }
             else {
-                cache[key] = vnode;
-                keys.push(key);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
             }
+            // @ts-expect-error can vnode.data can be undefined
             vnode.data.keepAlive = true;
         }
         return vnode || (slot && slot[0]);
@@ -4694,15 +4724,15 @@ var KeepAlive = {
 };
 
 var builtInComponents = {
-    KeepAlive: KeepAlive,
+    KeepAlive,
 };
 
 function initGlobalAPI(Vue) {
     // config
-    var configDef = {};
-    configDef.get = function () { return config; };
+    const configDef = {};
+    configDef.get = () => config;
     if (process.env.NODE_ENV !== 'production') {
-        configDef.set = function () {
+        configDef.set = () => {
             warn('Do not replace the Vue.config object, set individual fields instead.');
         };
     }
@@ -4711,21 +4741,21 @@ function initGlobalAPI(Vue) {
     // NOTE: these are not considered part of the public API - avoid relying on
     // them unless you are aware of the risk.
     Vue.util = {
-        warn: warn,
-        extend: extend,
-        mergeOptions: mergeOptions,
-        defineReactive: defineReactive,
+        warn,
+        extend,
+        mergeOptions,
+        defineReactive,
     };
     Vue.set = set;
     Vue.delete = del;
     Vue.nextTick = nextTick;
     // 2.6 explicit observable API
-    Vue.observable = function (obj) {
+    Vue.observable = (obj) => {
         observe(obj);
         return obj;
     };
     Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
+    ASSET_TYPES.forEach((type) => {
         Vue.options[type + 's'] = Object.create(null);
     });
     // this is used to identify the "base" constructor to extend all plain-object
@@ -4743,7 +4773,7 @@ Object.defineProperty(Vue.prototype, '$isServer', {
     get: isServerRendering,
 });
 Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function get() {
+    get() {
         /* istanbul ignore next */
         return this.$vnode && this.$vnode.ssrContext;
     },
@@ -4752,22 +4782,22 @@ Object.defineProperty(Vue.prototype, '$ssrContext', {
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
     value: FunctionalRenderContext,
 });
-Vue.version = '2.6.12';
+Vue.version = '2.6.14';
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
+const isReservedAttr = makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
     return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
         (attr === 'selected' && tag === 'option') ||
         (attr === 'checked' && tag === 'input') ||
         (attr === 'muted' && tag === 'video'));
 };
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-var convertEnumeratedValue = function (key, value) {
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
     return isFalsyAttrValue(value) || value === 'false'
         ? 'false'
         : // allow arbitrary string value for contenteditable
@@ -4775,33 +4805,34 @@ var convertEnumeratedValue = function (key, value) {
                 ? value
                 : 'true';
 };
-var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
     'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
     'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
     'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
     'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
-var xlinkNS = 'http://www.w3.org/1999/xlink';
-var isXlink = function (name) {
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
     return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
 };
-var getXlinkProp = function (name) {
+const getXlinkProp = (name) => {
     return isXlink(name) ? name.slice(6, name.length) : '';
 };
-var isFalsyAttrValue = function (val) {
+const isFalsyAttrValue = (val) => {
     return val == null || val === false;
 };
 
 function genClassForVnode(vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
     while (isDef(childNode.componentInstance)) {
         childNode = childNode.componentInstance._vnode;
         if (childNode && childNode.data) {
             data = mergeClassData(childNode.data, data);
         }
     }
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while (isDef((parentNode = parentNode.parent))) {
         if (parentNode && parentNode.data) {
             data = mergeClassData(data, parentNode.data);
@@ -4839,34 +4870,34 @@ function stringifyClass(value) {
     return '';
 }
 function stringifyArray(value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
         if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += stringified;
         }
     }
     return res;
 }
 function stringifyObject(value) {
-    var res = '';
-    for (var key in value) {
+    let res = '';
+    for (const key in value) {
         if (value[key]) {
             if (res)
-                { res += ' '; }
+                res += ' ';
             res += key;
         }
     }
     return res;
 }
 
-var namespaceMap = {
+const namespaceMap = {
     svg: 'http://www.w3.org/2000/svg',
     math: 'http://www.w3.org/1998/Math/MathML',
 };
-var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
     'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
     'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4879,10 +4910,10 @@ var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
     'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
     'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
     'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isReservedTag = function (tag) {
+const isReservedTag = (tag) => {
     return isHTMLTag(tag) || isSVG(tag);
 };
 function getTagNamespace(tag) {
@@ -4895,7 +4926,7 @@ function getTagNamespace(tag) {
         return 'math';
     }
 }
-var unknownElementCache = Object.create(null);
+const unknownElementCache = Object.create(null);
 function isUnknownElement(tag) {
     /* istanbul ignore if */
     if (!inBrowser) {
@@ -4909,7 +4940,7 @@ function isUnknownElement(tag) {
     if (unknownElementCache[tag] != null) {
         return unknownElementCache[tag];
     }
-    var el = document.createElement(tag);
+    const el = document.createElement(tag);
     if (tag.indexOf('-') > -1) {
         // http://stackoverflow.com/a/28210364/1070244
         return (unknownElementCache[tag] =
@@ -4920,14 +4951,14 @@ function isUnknownElement(tag) {
         return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
     }
 }
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
 /**
  * Query an element selector if it's not an element already.
  */
 function query(el) {
     if (typeof el === 'string') {
-        var selected = document.querySelector(el);
+        const selected = document.querySelector(el);
         if (!selected) {
             process.env.NODE_ENV !== 'production' &&
                 warn('Cannot find element: ' + el);
@@ -4941,7 +4972,7 @@ function query(el) {
 }
 
 function createElement(tagName, vnode) {
-    var elm = document.createElement(tagName);
+    const elm = document.createElement(tagName);
     if (tagName !== 'select') {
         return elm;
     }
@@ -5004,45 +5035,42 @@ var nodeOps = /*#__PURE__*/Object.freeze({
 });
 
 var ref = {
-    create: function create(_, vnode) {
+    create(_, vnode) {
         registerRef(vnode);
     },
-    update: function update(oldVnode, vnode) {
+    update(oldVnode, vnode) {
         if (oldVnode.data.ref !== vnode.data.ref) {
             registerRef(oldVnode, true);
             registerRef(vnode);
         }
     },
-    destroy: function destroy(vnode) {
+    destroy(vnode) {
         registerRef(vnode, true);
     },
 };
 function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
+    const key = vnode.data.ref;
     if (!isDef(key))
-        { return; }
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
     if (isRemoval) {
-        if (Array.isArray(refs[key])) {
-            // @ts-expect-error invalid typings
-            remove$2(refs[key], ref);
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
         }
-        else if (refs[key] === ref) {
+        else if (obj === ref) {
             refs[key] = undefined;
         }
     }
     else {
-        // @ts-expect-error invalid typings
         if (vnode.data.refInFor) {
-            if (!Array.isArray(refs[key])) {
+            if (!Array.isArray(obj)) {
                 refs[key] = [ref];
-                // @ts-expect-error invalid typings
             }
-            else if (refs[key].indexOf(ref) < 0) {
-                // @ts-expect-error invalid typings
-                refs[key].push(ref);
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
             }
         }
         else {
@@ -5062,41 +5090,38 @@ function registerRef(vnode, isRemoval) {
  * Not type-checking this because this file is perf-critical and the cost
  * of making flow understand it is not worth it.
  */
-var emptyNode = new VNode('', {}, []);
-var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
 function sameVnode(a, b) {
     return (a.key === b.key &&
-        ((a.tag === b.tag &&
-            a.isComment === b.isComment &&
-            isDef(a.data) === isDef(b.data) &&
-            sameInputType(a, b)) ||
-            (isTrue(a.isAsyncPlaceholder) &&
-                a.asyncFactory === b.asyncFactory &&
-                isUndef(b.asyncFactory.error))));
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
 }
 function sameInputType(a, b) {
     if (a.tag !== 'input')
-        { return true; }
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
     return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
 }
 function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
+    let i, key;
+    const map = {};
     for (i = beginIdx; i <= endIdx; ++i) {
         key = children[i].key;
         if (isDef(key))
-            { map[key] = i; }
+            map[key] = i;
     }
     return map;
 }
 function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules;
-    var nodeOps = backend.nodeOps;
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
     for (i = 0; i < hooks.length; ++i) {
         cbs[hooks[i]] = [];
         for (j = 0; j < modules.length; ++j) {
@@ -5118,7 +5143,7 @@ function createPatchFunction(backend) {
         return remove;
     }
     function removeNode(el) {
-        var parent = nodeOps.parentNode(el);
+        const parent = nodeOps.parentNode(el);
         // element may have already been removed due to v-html / v-text
         if (isDef(parent)) {
             nodeOps.removeChild(parent, el);
@@ -5128,14 +5153,14 @@ function createPatchFunction(backend) {
         return (!inVPre &&
             !vnode.ns &&
             !(config.ignoredElements.length &&
-                config.ignoredElements.some(function (ignore) {
+                config.ignoredElements.some((ignore) => {
                     return isRegExp(ignore)
                         ? ignore.test(vnode.tag)
                         : ignore === vnode.tag;
                 })) &&
             config.isUnknownElement(vnode.tag));
     }
-    var creatingElmInVPre = 0;
+    let creatingElmInVPre = 0;
     function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
         if (isDef(vnode.elm) && isDef(ownerArray)) {
             // This vnode was used in a previous render!
@@ -5149,9 +5174,9 @@ function createPatchFunction(backend) {
         if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
             return;
         }
-        var data = vnode.data;
-        var children = vnode.children;
-        var tag = vnode.tag;
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
         if (isDef(tag)) {
             if (process.env.NODE_ENV !== 'production') {
                 if (data && data.pre) {
@@ -5191,9 +5216,9 @@ function createPatchFunction(backend) {
         }
     }
     function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i = vnode.data;
+        let i = vnode.data;
         if (isDef(i)) {
-            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
             if (isDef((i = i.hook)) && isDef((i = i.init))) {
                 i(vnode, false /* hydrating */);
             }
@@ -5230,12 +5255,12 @@ function createPatchFunction(backend) {
         }
     }
     function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i;
+        let i;
         // hack for #4339: a reactivated component with inner transition
         // does not trigger because the inner node's created hooks are not called
         // again. It's not ideal to involve module-specific logic in here but
         // there doesn't seem to be a better way to do it.
-        var innerNode = vnode;
+        let innerNode = vnode;
         while (innerNode.componentInstance) {
             innerNode = innerNode.componentInstance._vnode;
             if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5267,7 +5292,7 @@ function createPatchFunction(backend) {
             if (process.env.NODE_ENV !== 'production') {
                 checkDuplicateKeys(children);
             }
-            for (var i = 0; i < children.length; ++i) {
+            for (let i = 0; i < children.length; ++i) {
                 createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
             }
         }
@@ -5282,27 +5307,27 @@ function createPatchFunction(backend) {
         return isDef(vnode.tag);
     }
     function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-            cbs.create[i$1](emptyNode, vnode);
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
         }
         i = vnode.data.hook; // Reuse variable
         if (isDef(i)) {
             if (isDef(i.create))
-                { i.create(emptyNode, vnode); }
+                i.create(emptyNode, vnode);
             if (isDef(i.insert))
-                { insertedVnodeQueue.push(vnode); }
+                insertedVnodeQueue.push(vnode);
         }
     }
     // set scope id attribute for scoped CSS.
     // this is implemented as a special case to avoid the overhead
     // of going through the normal attribute patching process.
     function setScope(vnode) {
-        var i;
+        let i;
         if (isDef((i = vnode.fnScopeId))) {
             nodeOps.setStyleScope(vnode.elm, i);
         }
         else {
-            var ancestor = vnode;
+            let ancestor = vnode;
             while (ancestor) {
                 if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                     nodeOps.setStyleScope(vnode.elm, i);
@@ -5324,13 +5349,13 @@ function createPatchFunction(backend) {
         }
     }
     function invokeDestroyHook(vnode) {
-        var i, j;
-        var data = vnode.data;
+        let i, j;
+        const data = vnode.data;
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                { i(vnode); }
+                i(vnode);
             for (i = 0; i < cbs.destroy.length; ++i)
-                { cbs.destroy[i](vnode); }
+                cbs.destroy[i](vnode);
         }
         if (isDef((i = vnode.children))) {
             for (j = 0; j < vnode.children.length; ++j) {
@@ -5340,7 +5365,7 @@ function createPatchFunction(backend) {
     }
     function removeVnodes(vnodes, startIdx, endIdx) {
         for (; startIdx <= endIdx; ++startIdx) {
-            var ch = vnodes[startIdx];
+            const ch = vnodes[startIdx];
             if (isDef(ch)) {
                 if (isDef(ch.tag)) {
                     removeAndInvokeRemoveHook(ch);
@@ -5355,8 +5380,8 @@ function createPatchFunction(backend) {
     }
     function removeAndInvokeRemoveHook(vnode, rm) {
         if (isDef(rm) || isDef(vnode.data)) {
-            var i;
-            var listeners = cbs.remove.length + 1;
+            let i;
+            const listeners = cbs.remove.length + 1;
             if (isDef(rm)) {
                 // we have a recursively passed down rm callback
                 // increase the listeners count
@@ -5387,19 +5412,19 @@ function createPatchFunction(backend) {
         }
     }
     function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        var oldStartIdx = 0;
-        var newStartIdx = 0;
-        var oldEndIdx = oldCh.length - 1;
-        var oldStartVnode = oldCh[0];
-        var oldEndVnode = oldCh[oldEndIdx];
-        var newEndIdx = newCh.length - 1;
-        var newStartVnode = newCh[0];
-        var newEndVnode = newCh[newEndIdx];
-        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
         // removeOnly is a special flag used only by <transition-group>
         // to ensure removed elements stay in correct relative positions
         // during leaving transitions
-        var canMove = !removeOnly;
+        const canMove = !removeOnly;
         if (process.env.NODE_ENV !== 'production') {
             checkDuplicateKeys(newCh);
         }
@@ -5438,7 +5463,7 @@ function createPatchFunction(backend) {
             }
             else {
                 if (isUndef(oldKeyToIdx))
-                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
                 idxInOld = isDef(newStartVnode.key)
                     ? oldKeyToIdx[newStartVnode.key]
                     : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
@@ -5471,13 +5496,13 @@ function createPatchFunction(backend) {
         }
     }
     function checkDuplicateKeys(children) {
-        var seenKeys = {};
-        for (var i = 0; i < children.length; i++) {
-            var vnode = children[i];
-            var key = vnode.key;
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
             if (isDef(key)) {
                 if (seenKeys[key]) {
-                    warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                 }
                 else {
                     seenKeys[key] = true;
@@ -5486,10 +5511,10 @@ function createPatchFunction(backend) {
         }
     }
     function findIdxInOld(node, oldCh, start, end) {
-        for (var i = start; i < end; i++) {
-            var c = oldCh[i];
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
             if (isDef(c) && sameVnode(node, c))
-                { return i; }
+                return i;
         }
     }
     function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5500,7 +5525,7 @@ function createPatchFunction(backend) {
             // clone reused vnode
             vnode = ownerArray[index] = cloneVNode(vnode);
         }
-        var elm = (vnode.elm = oldVnode.elm);
+        const elm = (vnode.elm = oldVnode.elm);
         if (isTrue(oldVnode.isAsyncPlaceholder)) {
             if (isDef(vnode.asyncFactory.resolved)) {
                 hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5521,30 +5546,30 @@ function createPatchFunction(backend) {
             vnode.componentInstance = oldVnode.componentInstance;
             return;
         }
-        var i;
-        var data = vnode.data;
+        let i;
+        const data = vnode.data;
         if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
             i(oldVnode, vnode);
         }
-        var oldCh = oldVnode.children;
-        var ch = vnode.children;
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
         if (isDef(data) && isPatchable(vnode)) {
             for (i = 0; i < cbs.update.length; ++i)
-                { cbs.update[i](oldVnode, vnode); }
+                cbs.update[i](oldVnode, vnode);
             if (isDef((i = data.hook)) && isDef((i = i.update)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
         if (isUndef(vnode.text)) {
             if (isDef(oldCh) && isDef(ch)) {
                 if (oldCh !== ch)
-                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
             }
             else if (isDef(ch)) {
                 if (process.env.NODE_ENV !== 'production') {
                     checkDuplicateKeys(ch);
                 }
                 if (isDef(oldVnode.text))
-                    { nodeOps.setTextContent(elm, ''); }
+                    nodeOps.setTextContent(elm, '');
                 addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
             }
             else if (isDef(oldCh)) {
@@ -5559,7 +5584,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                { i(oldVnode, vnode); }
+                i(oldVnode, vnode);
         }
     }
     function invokeInsertHook(vnode, queue, initial) {
@@ -5569,23 +5594,21 @@ function createPatchFunction(backend) {
             vnode.parent.data.pendingInsert = queue;
         }
         else {
-            for (var i = 0; i < queue.length; ++i) {
+            for (let i = 0; i < queue.length; ++i) {
                 queue[i].data.hook.insert(queue[i]);
             }
         }
     }
-    var hydrationBailed = false;
+    let hydrationBailed = false;
     // list of modules that can skip create hook during hydration because they
     // are already rendered on the client or has no need for initialization
     // Note: style is excluded because it relies on initial clone for future
     // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
     // Note: this is a browser-only function so we can assume elms are DOM nodes.
     function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        var i;
-        var tag = vnode.tag;
-        var data = vnode.data;
-        var children = vnode.children;
+        let i;
+        const { tag, data, children } = vnode;
         inVPre = inVPre || (data && data.pre);
         vnode.elm = elm;
         if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5600,7 +5623,7 @@ function createPatchFunction(backend) {
         }
         if (isDef(data)) {
             if (isDef((i = data.hook)) && isDef((i = i.init)))
-                { i(vnode, true /* hydrating */); }
+                i(vnode, true /* hydrating */);
             if (isDef((i = vnode.componentInstance))) {
                 // child component. it should have hydrated its own tree.
                 initComponent(vnode, insertedVnodeQueue);
@@ -5633,11 +5656,11 @@ function createPatchFunction(backend) {
                     }
                     else {
                         // iterate and compare children lists
-                        var childrenMatch = true;
-                        var childNode = elm.firstChild;
-                        for (var i$1 = 0; i$1 < children.length; i$1++) {
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
                             if (!childNode ||
-                                !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                 childrenMatch = false;
                                 break;
                             }
@@ -5660,8 +5683,8 @@ function createPatchFunction(backend) {
                 }
             }
             if (isDef(data)) {
-                var fullInvoke = false;
-                for (var key in data) {
+                let fullInvoke = false;
+                for (const key in data) {
                     if (!isRenderedModule(key)) {
                         fullInvoke = true;
                         invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5693,18 +5716,18 @@ function createPatchFunction(backend) {
     return function patch(oldVnode, vnode, hydrating, removeOnly) {
         if (isUndef(vnode)) {
             if (isDef(oldVnode))
-                { invokeDestroyHook(oldVnode); }
+                invokeDestroyHook(oldVnode);
             return;
         }
-        var isInitialPatch = false;
-        var insertedVnodeQueue = [];
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
         if (isUndef(oldVnode)) {
             // empty mount (likely as component), create new root element
             isInitialPatch = true;
             createElm(vnode, insertedVnodeQueue);
         }
         else {
-            var isRealElement = isDef(oldVnode.nodeType);
+            const isRealElement = isDef(oldVnode.nodeType);
             if (!isRealElement && sameVnode(oldVnode, vnode)) {
                 // patch existing root node
                 patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5736,8 +5759,8 @@ function createPatchFunction(backend) {
                     oldVnode = emptyNodeAt(oldVnode);
                 }
                 // replacing existing element
-                var oldElm = oldVnode.elm;
-                var parentElm = nodeOps.parentNode(oldElm);
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
                 // create new node
                 createElm(vnode, insertedVnodeQueue, 
                 // extremely rare edge case: do not insert if old element is in a
@@ -5746,25 +5769,25 @@ function createPatchFunction(backend) {
                 oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                 // update parent placeholder node element, recursively
                 if (isDef(vnode.parent)) {
-                    var ancestor = vnode.parent;
-                    var patchable = isPatchable(vnode);
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
                     while (ancestor) {
-                        for (var i = 0; i < cbs.destroy.length; ++i) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
                             cbs.destroy[i](ancestor);
                         }
                         ancestor.elm = vnode.elm;
                         if (patchable) {
-                            for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                cbs.create[i$1](emptyNode, ancestor);
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
                             }
                             // #6513
                             // invoke insert hooks that may have been merged by create hooks.
                             // e.g. for directives that uses the "inserted" hook.
-                            var insert = ancestor.data.hook.insert;
+                            const insert = ancestor.data.hook.insert;
                             if (insert.merged) {
                                 // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                    insert.fns[i$2]();
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
                                 }
                             }
                         }
@@ -5802,13 +5825,13 @@ function updateDirectives(oldVnode, vnode) {
     }
 }
 function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
     for (key in newDirs) {
         oldDir = oldDirs[key];
         dir = newDirs[key];
@@ -5830,8 +5853,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithInsert.length) {
-        var callInsert = function () {
-            for (var i = 0; i < dirsWithInsert.length; i++) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
                 callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
             }
         };
@@ -5843,8 +5866,8 @@ function _update(oldVnode, vnode) {
         }
     }
     if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-            for (var i = 0; i < dirsWithPostpatch.length; i++) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
                 callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
             }
         });
@@ -5858,14 +5881,14 @@ function _update(oldVnode, vnode) {
         }
     }
 }
-var emptyModifiers = Object.create(null);
+const emptyModifiers = Object.create(null);
 function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
+    const res = Object.create(null);
     if (!dirs) {
         // $flow-disable-line
         return res;
     }
-    var i, dir;
+    let i, dir;
     for (i = 0; i < dirs.length; i++) {
         dir = dirs[i];
         if (!dir.modifiers) {
@@ -5879,16 +5902,17 @@ function normalizeDirectives(dirs, vm) {
     return res;
 }
 function getRawDirName(dir) {
-    return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
 }
 function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
+    const fn = dir.def && dir.def[hook];
     if (fn) {
         try {
             fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
         }
         catch (e) {
-            handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+            // @ts-expect-error should it be any?
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
         }
     }
 }
@@ -5896,17 +5920,17 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy) {
 var baseModules = [ref, directives];
 
 function updateAttrs(oldVnode, vnode) {
-    var opts = vnode.componentOptions;
+    const opts = vnode.componentOptions;
     if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
         return;
     }
     if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
         return;
     }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(attrs.__ob__)) {
         attrs = vnode.data.attrs = extend({}, attrs);
@@ -5982,7 +6006,7 @@ function baseSetAttr(el, key, value) {
             key === 'placeholder' &&
             value !== '' &&
             !el.__ieph) {
-            var blocker = function (e) {
+            const blocker = (e) => {
                 e.stopImmediatePropagation();
                 el.removeEventListener('input', blocker);
             };
@@ -5999,18 +6023,18 @@ var attrs = {
 };
 
 function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticClass) &&
         isUndef(data.class) &&
         (isUndef(oldData) ||
             (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
         return;
     }
-    var cls = genClassForVnode(vnode);
+    let cls = genClassForVnode(vnode);
     // handle transition classes
-    var transitionClass = el._transitionClasses;
+    const transitionClass = el._transitionClasses;
     if (isDef(transitionClass)) {
         cls = concat(cls, stringifyClass(transitionClass));
     }
@@ -6027,8 +6051,8 @@ var klass = {
 
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
-var CHECKBOX_RADIO_TOKEN = '__c';
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
@@ -6038,7 +6062,7 @@ function normalizeEvents(on) {
     /* istanbul ignore if */
     if (isDef(on[RANGE_TOKEN])) {
         // IE input[type=range] only supports `change` event
-        var event = isIE ? 'change' : 'input';
+        const event = isIE ? 'change' : 'input';
         on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
         delete on[RANGE_TOKEN];
     }
@@ -6050,11 +6074,11 @@ function normalizeEvents(on) {
         delete on[CHECKBOX_RADIO_TOKEN];
     }
 }
-var target;
+let target;
 function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
+    const _target = target; // save current target element in closure
     return function onceHandler() {
-        var res = handler.apply(null, arguments);
+        const res = handler.apply(null, arguments);
         if (res !== null) {
             remove(event, onceHandler, capture, _target);
         }
@@ -6063,7 +6087,7 @@ function createOnceHandler(event, handler, capture) {
 // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
 // implementation and does not fire microtasks in between event propagation, so
 // safe to exclude.
-var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
 function add(name, handler, capture, passive) {
     // async edge case #6566: inner click event triggers patch, event handler
     // attached to outer element during patch, and triggered again. This
@@ -6072,9 +6096,9 @@ function add(name, handler, capture, passive) {
     // and the handler would only fire if the event passed to it was fired
     // AFTER it was attached.
     if (useMicrotaskFix) {
-        var attachedTimestamp = currentFlushTimestamp;
-        var original = handler;
-        //@ts-expect-error
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
         handler = original._wrapper = function (e) {
             if (
             // no bubbling, should always fire.
@@ -6095,7 +6119,7 @@ function add(name, handler, capture, passive) {
             }
         };
     }
-    target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
 }
 function remove(name, handler, capture, _target) {
     (_target || target).removeEventListener(name, 
@@ -6106,9 +6130,11 @@ function updateDOMListeners(oldVnode, vnode) {
     if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
         return;
     }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
     normalizeEvents(on);
     updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
     target = undefined;
@@ -6116,17 +6142,19 @@ function updateDOMListeners(oldVnode, vnode) {
 var events = {
     create: updateDOMListeners,
     update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-var svgContainer;
+let svgContainer;
 function updateDOMProps(oldVnode, vnode) {
     if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
         return;
     }
-    var key, cur;
-    var elm = vnode.elm;
-    var oldProps = oldVnode.data.domProps || {};
-    var props = vnode.data.domProps || {};
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
     // clone observed objects, as the user probably wants to mutate it
     if (isDef(props.__ob__)) {
         props = vnode.data.domProps = extend({}, props);
@@ -6143,9 +6171,9 @@ function updateDOMProps(oldVnode, vnode) {
         // on subsequent patches (#3360)
         if (key === 'textContent' || key === 'innerHTML') {
             if (vnode.children)
-                { vnode.children.length = 0; }
+                vnode.children.length = 0;
             if (cur === oldProps[key])
-                { continue; }
+                continue;
             // #6601 work around Chrome version <= 55 bug where single textNode
             // replaced by innerHTML/textContent retains its parentNode property
             if (elm.childNodes.length === 1) {
@@ -6157,7 +6185,7 @@ function updateDOMProps(oldVnode, vnode) {
             // non-string values will be stringified
             elm._value = cur;
             // avoid resetting cursor position when value is the same
-            var strCur = isUndef(cur) ? '' : String(cur);
+            const strCur = isUndef(cur) ? '' : String(cur);
             if (shouldUpdateValue(elm, strCur)) {
                 elm.value = strCur;
             }
@@ -6167,8 +6195,8 @@ function updateDOMProps(oldVnode, vnode) {
             isUndef(elm.innerHTML)) {
             // IE doesn't support innerHTML for SVG elements
             svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-            var svg = svgContainer.firstChild;
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
             while (elm.firstChild) {
                 elm.removeChild(elm.firstChild);
             }
@@ -6202,7 +6230,7 @@ function shouldUpdateValue(elm, checkVal) {
 function isNotInFocusAndDirty(elm, checkVal) {
     // return true when textbox (.number and .trim) loses focus and its value is
     // not equal to the updated value
-    var notInFocus = true;
+    let notInFocus = true;
     // #6157
     // work around IE bug when accessing document.activeElement in an iframe
     try {
@@ -6212,8 +6240,8 @@ function isNotInFocusAndDirty(elm, checkVal) {
     return notInFocus && elm.value !== checkVal;
 }
 function isDirtyWithModifiers(elm, newVal) {
-    var value = elm.value;
-    var modifiers = elm._vModifiers; // injected by v-model runtime
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
     if (isDef(modifiers)) {
         if (modifiers.number) {
             return toNumber(value) !== toNumber(newVal);
@@ -6229,13 +6257,13 @@ var domProps = {
     update: updateDOMProps,
 };
 
-var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
     cssText.split(listDelimiter).forEach(function (item) {
         if (item) {
-            var tmp = item.split(propertyDelimiter);
+            const tmp = item.split(propertyDelimiter);
             tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
         }
     });
@@ -6243,7 +6271,7 @@ var parseStyleText = cached(function (cssText) {
 });
 // merge static and dynamic style data on the same vnode
 function normalizeStyleData(data) {
-    var style = normalizeStyleBinding(data.style);
+    const style = normalizeStyleBinding(data.style);
     // static style is pre-processed into an object during compilation
     // and is always a fresh object, so it's safe to merge into it
     return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6263,10 +6291,10 @@ function normalizeStyleBinding(bindingStyle) {
  * so that parent component's style could override it
  */
 function getStyle(vnode, checkChild) {
-    var res = {};
-    var styleData;
+    const res = {};
+    let styleData;
     if (checkChild) {
-        var childNode = vnode;
+        let childNode = vnode;
         while (childNode.componentInstance) {
             childNode = childNode.componentInstance._vnode;
             if (childNode &&
@@ -6279,7 +6307,8 @@ function getStyle(vnode, checkChild) {
     if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
     }
-    var parentNode = vnode;
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
     while ((parentNode = parentNode.parent)) {
         if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
             extend(res, styleData);
@@ -6288,9 +6317,9 @@ function getStyle(vnode, checkChild) {
     return res;
 }
 
-var cssVarRE = /^--/;
-var importantRE = /\s*!important$/;
-var setProp = function (el, name, val) {
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
     /* istanbul ignore if */
     if (cssVarRE.test(name)) {
         el.style.setProperty(name, val);
@@ -6299,12 +6328,12 @@ var setProp = function (el, name, val) {
         el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
     }
     else {
-        var normalizedName = normalize(name);
+        const normalizedName = normalize(name);
         if (Array.isArray(val)) {
             // Support values array created by autoprefixer, e.g.
             // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
             // Set them one by one, and the browser will only set those it can recognize
-            for (var i = 0, len = val.length; i < len; i++) {
+            for (let i = 0, len = val.length; i < len; i++) {
                 el.style[normalizedName] = val[i];
             }
         }
@@ -6313,43 +6342,43 @@ var setProp = function (el, name, val) {
         }
     }
 };
-var vendorNames = ['Webkit', 'Moz', 'ms'];
-var emptyStyle;
-var normalize = cached(function (prop) {
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
     emptyStyle = emptyStyle || document.createElement('div').style;
     prop = camelize(prop);
     if (prop !== 'filter' && prop in emptyStyle) {
         return prop;
     }
-    var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (var i = 0; i < vendorNames.length; i++) {
-        var name = vendorNames[i] + capName;
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
         if (name in emptyStyle) {
             return name;
         }
     }
 });
 function updateStyle(oldVnode, vnode) {
-    var data = vnode.data;
-    var oldData = oldVnode.data;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
     if (isUndef(data.staticStyle) &&
         isUndef(data.style) &&
         isUndef(oldData.staticStyle) &&
         isUndef(oldData.style)) {
         return;
     }
-    var cur, name;
-    var el = vnode.elm;
-    var oldStaticStyle = oldData.staticStyle;
-    var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
     // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    var oldStyle = oldStaticStyle || oldStyleBinding;
-    var style = normalizeStyleBinding(vnode.data.style) || {};
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
     // store normalized style under a different key for next diff
     // make sure to clone it if it's reactive, since the user likely wants
     // to mutate it.
     vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    var newStyle = getStyle(vnode, true);
+    const newStyle = getStyle(vnode, true);
     for (name in oldStyle) {
         if (isUndef(newStyle[name])) {
             setProp(el, name, '');
@@ -6368,7 +6397,7 @@ var style = {
     update: updateStyle,
 };
 
-var whitespaceRE = /\s+/;
+const whitespaceRE = /\s+/;
 /**
  * Add class with compatibility for SVG since classList is not supported on
  * SVG elements in IE
@@ -6381,14 +6410,14 @@ function addClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
         }
         else {
             el.classList.add(cls);
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
+        const cur = ` ${el.getAttribute('class') || ''} `;
         if (cur.indexOf(' ' + cls + ' ') < 0) {
             el.setAttribute('class', (cur + cls).trim());
         }
@@ -6406,7 +6435,7 @@ function removeClass(el, cls) {
     /* istanbul ignore else */
     if (el.classList) {
         if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
         }
         else {
             el.classList.remove(cls);
@@ -6416,8 +6445,8 @@ function removeClass(el, cls) {
         }
     }
     else {
-        var cur = " " + (el.getAttribute('class') || '') + " ";
-        var tar = ' ' + cls + ' ';
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
         while (cur.indexOf(tar) >= 0) {
             cur = cur.replace(tar, ' ');
         }
@@ -6437,7 +6466,7 @@ function resolveTransition(def) {
     }
     /* istanbul ignore else */
     if (typeof def === 'object') {
-        var res = {};
+        const res = {};
         if (def.css !== false) {
             extend(res, autoCssTransition(def.name || 'v'));
         }
@@ -6448,53 +6477,51 @@ function resolveTransition(def) {
         return autoCssTransition(def);
     }
 }
-var autoCssTransition = cached(function (name) {
+const autoCssTransition = cached((name) => {
     return {
-        enterClass: (name + "-enter"),
-        enterToClass: (name + "-enter-to"),
-        enterActiveClass: (name + "-enter-active"),
-        leaveClass: (name + "-leave"),
-        leaveToClass: (name + "-leave-to"),
-        leaveActiveClass: (name + "-leave-active"),
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
     };
 });
-var hasTransition = inBrowser && !isIE9;
-var TRANSITION = 'transition';
-var ANIMATION = 'animation';
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
 // Transition property/event sniffing
-var transitionProp = 'transition';
-var transitionEndEvent = 'transitionend';
-var animationProp = 'animation';
-var animationEndEvent = 'animationend';
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
 if (hasTransition) {
     /* istanbul ignore if */
     if (window.ontransitionend === undefined &&
-        // @ts-expect-error
         window.onwebkittransitionend !== undefined) {
         transitionProp = 'WebkitTransition';
         transitionEndEvent = 'webkitTransitionEnd';
     }
     if (window.onanimationend === undefined &&
-        // @ts-expect-error
         window.onwebkitanimationend !== undefined) {
         animationProp = 'WebkitAnimation';
         animationEndEvent = 'webkitAnimationEnd';
     }
 }
 // binding to window is necessary to make hot reload work in IE in strict mode
-var raf = inBrowser
+const raf = inBrowser
     ? window.requestAnimationFrame
         ? window.requestAnimationFrame.bind(window)
         : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
+    : /* istanbul ignore next */ (fn) => fn();
 function nextFrame(fn) {
-    raf(function () {
+    raf(() => {
         // @ts-expect-error
         raf(fn);
     });
 }
 function addTransitionClass(el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
     if (transitionClasses.indexOf(cls) < 0) {
         transitionClasses.push(cls);
         addClass(el, cls);
@@ -6507,45 +6534,42 @@ function removeTransitionClass(el, cls) {
     removeClass(el, cls);
 }
 function whenTransitionEnds(el, expectedType, cb) {
-    var ref = getTransitionInfo(el, expectedType);
-    var type = ref.type;
-    var timeout = ref.timeout;
-    var propCount = ref.propCount;
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
     if (!type)
-        { return cb(); }
-    var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    var ended = 0;
-    var end = function () {
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
         el.removeEventListener(event, onEnd);
         cb();
     };
-    var onEnd = function (e) {
+    const onEnd = (e) => {
         if (e.target === el) {
             if (++ended >= propCount) {
                 end();
             }
         }
     };
-    setTimeout(function () {
+    setTimeout(() => {
         if (ended < propCount) {
             end();
         }
     }, timeout + 1);
     el.addEventListener(event, onEnd);
 }
-var transformRE = /\b(transform|all)(,|$)/;
+const transformRE = /\b(transform|all)(,|$)/;
 function getTransitionInfo(el, expectedType) {
-    var styles = window.getComputedStyle(el);
+    const styles = window.getComputedStyle(el);
     // JSDOM may return undefined for transition properties
-    var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    var animationTimeout = getTimeout(animationDelays, animationDurations);
-    var type;
-    var timeout = 0;
-    var propCount = 0;
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
     /* istanbul ignore if */
     if (expectedType === TRANSITION) {
         if (transitionTimeout > 0) {
@@ -6575,12 +6599,12 @@ function getTransitionInfo(el, expectedType) {
                 : animationDurations.length
             : 0;
     }
-    var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
     return {
-        type: type,
-        timeout: timeout,
-        propCount: propCount,
-        hasTransform: hasTransform,
+        type,
+        timeout,
+        propCount,
+        hasTransform,
     };
 }
 function getTimeout(delays, durations) {
@@ -6588,7 +6612,7 @@ function getTimeout(delays, durations) {
     while (delays.length < durations.length) {
         delays = delays.concat(delays);
     }
-    return Math.max.apply(null, durations.map(function (d, i) {
+    return Math.max.apply(null, durations.map((d, i) => {
         return toMs(d) + toMs(delays[i]);
     }));
 }
@@ -6601,13 +6625,13 @@ function toMs(s) {
 }
 
 function enter(vnode, toggleDisplay) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call leave callback now
     if (isDef(el._leaveCb)) {
         el._leaveCb.cancelled = true;
         el._leaveCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data)) {
         return;
     }
@@ -6615,57 +6639,41 @@ function enter(vnode, toggleDisplay) {
     if (isDef(el._enterCb) || el.nodeType !== 1) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var enterClass = data.enterClass;
-    var enterToClass = data.enterToClass;
-    var enterActiveClass = data.enterActiveClass;
-    var appearClass = data.appearClass;
-    var appearToClass = data.appearToClass;
-    var appearActiveClass = data.appearActiveClass;
-    var beforeEnter = data.beforeEnter;
-    var enter = data.enter;
-    var afterEnter = data.afterEnter;
-    var enterCancelled = data.enterCancelled;
-    var beforeAppear = data.beforeAppear;
-    var appear = data.appear;
-    var afterAppear = data.afterAppear;
-    var appearCancelled = data.appearCancelled;
-    var duration = data.duration;
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
     // activeInstance will always be the <transition> component managing this
     // transition. One edge case to check is when the <transition> is placed
     // as the root node of a child component. In that case we need to check
     // <transition>'s parent for appear check.
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
     while (transitionNode && transitionNode.parent) {
         context = transitionNode.context;
         transitionNode = transitionNode.parent;
     }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
     if (isAppear && !appear && appear !== '') {
         return;
     }
-    var startClass = isAppear && appearClass ? appearClass : enterClass;
-    var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
         ? typeof appear === 'function'
             ? appear
             : enter
         : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
         ? appearCancelled || enterCancelled
         : enterCancelled;
-    var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
     if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
         checkDuration(explicitEnterDuration, 'enter', vnode);
     }
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-    var cb = (el._enterCb = once(function () {
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
         if (expectsCSS) {
             removeTransitionClass(el, toClass);
             removeTransitionClass(el, activeClass);
@@ -6684,9 +6692,9 @@ function enter(vnode, toggleDisplay) {
     }));
     if (!vnode.data.show) {
         // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', function () {
-            var parent = el.parentNode;
-            var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
             if (pendingNode &&
                 pendingNode.tag === vnode.tag &&
                 pendingNode.elm._leaveCb) {
@@ -6700,7 +6708,7 @@ function enter(vnode, toggleDisplay) {
     if (expectsCSS) {
         addTransitionClass(el, startClass);
         addTransitionClass(el, activeClass);
-        nextFrame(function () {
+        nextFrame(() => {
             removeTransitionClass(el, startClass);
             // @ts-expect-error
             if (!cb.cancelled) {
@@ -6725,13 +6733,13 @@ function enter(vnode, toggleDisplay) {
     }
 }
 function leave(vnode, rm) {
-    var el = vnode.elm;
+    const el = vnode.elm;
     // call enter callback now
     if (isDef(el._enterCb)) {
         el._enterCb.cancelled = true;
         el._enterCb();
     }
-    var data = resolveTransition(vnode.data.transition);
+    const data = resolveTransition(vnode.data.transition);
     if (isUndef(data) || el.nodeType !== 1) {
         return rm();
     }
@@ -6739,24 +6747,14 @@ function leave(vnode, rm) {
     if (isDef(el._leaveCb)) {
         return;
     }
-    var css = data.css;
-    var type = data.type;
-    var leaveClass = data.leaveClass;
-    var leaveToClass = data.leaveToClass;
-    var leaveActiveClass = data.leaveActiveClass;
-    var beforeLeave = data.beforeLeave;
-    var leave = data.leave;
-    var afterLeave = data.afterLeave;
-    var leaveCancelled = data.leaveCancelled;
-    var delayLeave = data.delayLeave;
-    var duration = data.duration;
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(leave);
-    var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
     if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
         checkDuration(explicitLeaveDuration, 'leave', vnode);
     }
-    var cb = (el._leaveCb = once(function () {
+    const cb = (el._leaveCb = once(() => {
         if (el.parentNode && el.parentNode._pending) {
             el.parentNode._pending[vnode.key] = null;
         }
@@ -6797,7 +6795,7 @@ function leave(vnode, rm) {
         if (expectsCSS) {
             addTransitionClass(el, leaveClass);
             addTransitionClass(el, leaveActiveClass);
-            nextFrame(function () {
+            nextFrame(() => {
                 removeTransitionClass(el, leaveClass);
                 // @ts-expect-error
                 if (!cb.cancelled) {
@@ -6822,11 +6820,11 @@ function leave(vnode, rm) {
 // only used in dev mode
 function checkDuration(val, name, vnode) {
     if (typeof val !== 'number') {
-        warn("<transition> explicit " + name + " duration is not a valid number - " +
-            "got " + (JSON.stringify(val)) + ".", vnode.context);
+        warn(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
     }
     else if (isNaN(val)) {
-        warn("<transition> explicit " + name + " duration is NaN - " +
+        warn(`<transition> explicit ${name} duration is NaN - ` +
             'the duration expression might be incorrect.', vnode.context);
     }
 }
@@ -6844,7 +6842,7 @@ function getHookArgumentsLength(fn) {
         return false;
     }
     // @ts-expect-error
-    var invokerFns = fn.fns;
+    const invokerFns = fn.fns;
     if (isDef(invokerFns)) {
         // invoker
         return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -6863,7 +6861,7 @@ var transition = inBrowser
     ? {
         create: _enter,
         activate: _enter,
-        remove: function remove(vnode, rm) {
+        remove(vnode, rm) {
             /* istanbul ignore else */
             if (vnode.data.show !== true) {
                 // @ts-expect-error
@@ -6880,8 +6878,8 @@ var platformModules = [attrs, klass, events, domProps, style, transition];
 
 // the directive module should be applied last, after all
 // built-in modules have been applied.
-var modules = platformModules.concat(baseModules);
-var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+const modules = platformModules.concat(baseModules);
+const patch = createPatchFunction({ nodeOps, modules });
 
 /**
  * Not type checking this file because flow doesn't like attaching
@@ -6890,20 +6888,20 @@ var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
 /* istanbul ignore if */
 if (isIE9) {
     // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', function () {
-        var el = document.activeElement;
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
         // @ts-expect-error
         if (el && el.vmodel) {
             trigger(el, 'input');
         }
     });
 }
-var directive = {
-    inserted: function inserted(el, binding, vnode, oldVnode) {
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
         if (vnode.tag === 'select') {
             // #6903
             if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', function () {
+                mergeVNodeHook(vnode, 'postpatch', () => {
                     directive.componentUpdated(el, binding, vnode);
                 });
             }
@@ -6929,20 +6927,20 @@ var directive = {
             }
         }
     },
-    componentUpdated: function componentUpdated(el, binding, vnode) {
+    componentUpdated(el, binding, vnode) {
         if (vnode.tag === 'select') {
             setSelected(el, binding, vnode.context);
             // in case the options rendered by v-for have changed,
             // it's possible that the value is out-of-sync with the rendered options.
             // detect such cases and filter out values that no longer has a matching
             // option in the DOM.
-            var prevOptions = el._vOptions;
-            var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                 // trigger change event if
                 // no matching option found for at least one value
-                var needReset = el.multiple
-                    ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                     : binding.value !== binding.oldValue &&
                         hasNoMatchingOption(binding.value, curOptions);
                 if (needReset) {
@@ -6956,24 +6954,24 @@ function setSelected(el, binding, vm) {
     actuallySetSelected(el, binding, vm);
     /* istanbul ignore if */
     if (isIE || isEdge) {
-        setTimeout(function () {
+        setTimeout(() => {
             actuallySetSelected(el, binding, vm);
         }, 0);
     }
 }
 function actuallySetSelected(el, binding, vm) {
-    var value = binding.value;
-    var isMultiple = el.multiple;
+    const value = binding.value;
+    const isMultiple = el.multiple;
     if (isMultiple && !Array.isArray(value)) {
         process.env.NODE_ENV !== 'production' &&
-            warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                "expects an Array value for its binding, but got " + (Object.prototype.toString
+            warn(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
                     .call(value)
-                    .slice(8, -1)), vm);
+                    .slice(8, -1)}`, vm);
         return;
     }
-    var selected, option;
-    for (var i = 0, l = el.options.length; i < l; i++) {
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
         option = el.options[i];
         if (isMultiple) {
             selected = looseIndexOf(value, getValue(option)) > -1;
@@ -6995,7 +6993,7 @@ function actuallySetSelected(el, binding, vm) {
     }
 }
 function hasNoMatchingOption(value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); });
+    return options.every((o) => !looseEqual(o, value));
 }
 function getValue(option) {
     return '_value' in option ? option._value : option.value;
@@ -7006,12 +7004,12 @@ function onCompositionStart(e) {
 function onCompositionEnd(e) {
     // prevent triggering an input event for no reason
     if (!e.target.composing)
-        { return; }
+        return;
     e.target.composing = false;
     trigger(e.target, 'input');
 }
 function trigger(el, type) {
-    var e = document.createEvent('HTMLEvents');
+    const e = document.createEvent('HTMLEvents');
     e.initEvent(type, true, true);
     el.dispatchEvent(e);
 }
@@ -7024,16 +7022,14 @@ function locateNode(vnode) {
         : vnode;
 }
 var show = {
-    bind: function bind(el, ref, vnode) {
-        var value = ref.value;
-
+    bind(el, { value }, vnode) {
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
-        var originalDisplay = (el.__vOriginalDisplay =
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
             el.style.display === 'none' ? '' : el.style.display);
         if (value && transition) {
             vnode.data.show = true;
-            enter(vnode, function () {
+            enter(vnode, () => {
                 el.style.display = originalDisplay;
             });
         }
@@ -7041,24 +7037,21 @@ var show = {
             el.style.display = value ? originalDisplay : 'none';
         }
     },
-    update: function update(el, ref, vnode) {
-        var value = ref.value;
-        var oldValue = ref.oldValue;
-
+    update(el, { value, oldValue }, vnode) {
         /* istanbul ignore if */
         if (!value === !oldValue)
-            { return; }
+            return;
         vnode = locateNode(vnode);
-        var transition = vnode.data && vnode.data.transition;
+        const transition = vnode.data && vnode.data.transition;
         if (transition) {
             vnode.data.show = true;
             if (value) {
-                enter(vnode, function () {
+                enter(vnode, () => {
                     el.style.display = el.__vOriginalDisplay;
                 });
             }
             else {
-                leave(vnode, function () {
+                leave(vnode, () => {
                     el.style.display = 'none';
                 });
             }
@@ -7067,7 +7060,7 @@ var show = {
             el.style.display = value ? el.__vOriginalDisplay : 'none';
         }
     },
-    unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
         if (!isDestroy) {
             el.style.display = el.__vOriginalDisplay;
         }
@@ -7076,11 +7069,11 @@ var show = {
 
 var platformDirectives = {
     model: directive,
-    show: show,
+    show,
 };
 
 // Provides transition support for a single element/component.
-var transitionProps = {
+const transitionProps = {
     name: String,
     appear: Boolean,
     css: Boolean,
@@ -7100,7 +7093,7 @@ var transitionProps = {
 // in case the child is also an abstract component, e.g. <keep-alive>
 // we want to recursively retrieve the real component to be rendered
 function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
+    const compOptions = vnode && vnode.componentOptions;
     if (compOptions && compOptions.Ctor.options.abstract) {
         return getRealChild(getFirstComponentChild(compOptions.children));
     }
@@ -7109,17 +7102,17 @@ function getRealChild(vnode) {
     }
 }
 function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
+    const data = {};
+    const options = comp.$options;
     // props
-    for (var key in options.propsData) {
+    for (const key in options.propsData) {
         data[key] = comp[key];
     }
     // events.
     // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key$1 in listeners) {
-        data[camelize(key$1)] = listeners[key$1];
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
     }
     return data;
 }
@@ -7141,16 +7134,14 @@ function hasParentTransition(vnode) {
 function isSameChild(child, oldChild) {
     return oldChild.key === child.key && oldChild.tag === child.tag;
 }
-var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-var isVShowDirective = function (d) { return d.name === 'show'; };
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
 var Transition = {
     name: 'transition',
     props: transitionProps,
     abstract: true,
-    render: function render(h) {
-        var this$1 = this;
-
-        var children = this.$slots.default;
+    render(h) {
+        let children = this.$slots.default;
         if (!children) {
             return;
         }
@@ -7165,7 +7156,7 @@ var Transition = {
             warn('<transition> can only be used on a single element. Use ' +
                 '<transition-group> for lists.', this.$parent);
         }
-        var mode = this.mode;
+        const mode = this.mode;
         // warn invalid mode
         if (process.env.NODE_ENV !== 'production' &&
             mode &&
@@ -7173,7 +7164,7 @@ var Transition = {
             mode !== 'out-in') {
             warn('invalid <transition> mode: ' + mode, this.$parent);
         }
-        var rawChild = children[0];
+        const rawChild = children[0];
         // if this is a component root node and the component's
         // parent container node also has transition, skip.
         if (hasParentTransition(this.$vnode)) {
@@ -7181,7 +7172,7 @@ var Transition = {
         }
         // apply transition data to child
         // use getRealChild() to ignore abstract components e.g. keep-alive
-        var child = getRealChild(rawChild);
+        const child = getRealChild(rawChild);
         /* istanbul ignore if */
         if (!child) {
             return rawChild;
@@ -7192,7 +7183,7 @@ var Transition = {
         // ensure a key that is unique to the vnode type and to this transition
         // component instance. This key will be used to remove pending leaving nodes
         // during entering.
-        var id = "__transition-" + (this._uid) + "-";
+        const id = `__transition-${this._uid}-`;
         child.key =
             child.key == null
                 ? child.isComment
@@ -7203,9 +7194,9 @@ var Transition = {
                         ? child.key
                         : id + child.key
                     : child.key;
-        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        var oldRawChild = this._vnode;
-        var oldChild = getRealChild(oldRawChild);
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
         // mark v-show
         // so that the transition module can hand over the control to the directive
         if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7220,14 +7211,14 @@ var Transition = {
                 oldChild.componentInstance._vnode.isComment)) {
             // replace old child transition data with fresh one
             // important for dynamic transitions!
-            var oldData = (oldChild.data.transition = extend({}, data));
+            const oldData = (oldChild.data.transition = extend({}, data));
             // handle transition mode
             if (mode === 'out-in') {
                 // return placeholder node and queue update when leave finishes
                 this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', function () {
-                    this$1._leaving = false;
-                    this$1.$forceUpdate();
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
                 });
                 return placeholder(h, rawChild);
             }
@@ -7235,13 +7226,13 @@ var Transition = {
                 if (isAsyncPlaceholder(child)) {
                     return oldRawChild;
                 }
-                var delayedLeave;
-                var performLeave = function () {
+                let delayedLeave;
+                const performLeave = () => {
                     delayedLeave();
                 };
                 mergeVNodeHook(data, 'afterEnter', performLeave);
                 mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
                     delayedLeave = leave;
                 });
             }
@@ -7251,67 +7242,63 @@ var Transition = {
 };
 
 // Provides transition support for list items.
-var props = extend({
+const props = extend({
     tag: String,
     moveClass: String,
 }, transitionProps);
-// @ts-ignore
 delete props.mode;
 var TransitionGroup = {
-    props: props,
-    beforeMount: function beforeMount() {
-        var this$1 = this;
-
-        var update = this._update;
-        this._update = function (vnode, hydrating) {
-            var restoreActiveInstance = setActiveInstance(this$1);
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
             // force removing pass
-            this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+            this.__patch__(this._vnode, this.kept, false, // hydrating
             true // removeOnly (!important, avoids unnecessary moves)
             );
-            this$1._vnode = this$1.kept;
+            this._vnode = this.kept;
             restoreActiveInstance();
-            update.call(this$1, vnode, hydrating);
+            update.call(this, vnode, hydrating);
         };
     },
-    render: function render(h) {
-        var tag = this.tag || this.$vnode.data.tag || 'span';
-        var map = Object.create(null);
-        var prevChildren = (this.prevChildren = this.children);
-        var rawChildren = this.$slots.default || [];
-        var children = (this.children = []);
-        var transitionData = extractTransitionData(this);
-        for (var i = 0; i < rawChildren.length; i++) {
-            var c = rawChildren[i];
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
             if (c.tag) {
-                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                     children.push(c);
                     map[c.key] = c;
                     (c.data || (c.data = {})).transition = transitionData;
                 }
-                else if (process.env.NODE_ENV !== 'production') {
-                    var opts = c.componentOptions;
-                    var name = opts
-                        ? opts.Ctor.options.name || opts.tag || ''
+                else if (process.env.NODE_ENV !== "production") {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
                         : c.tag;
-                    warn(("<transition-group> children must be keyed: <" + name + ">"));
+                    warn(`<transition-group> children must be keyed: <${name}>`);
                 }
             }
         }
         if (prevChildren) {
-            var kept = [];
-            var removed = [];
-            for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                var c$1 = prevChildren[i$1];
-                c$1.data.transition = transitionData;
-                // @ts-ignore
-                c$1.data.pos = c$1.elm.getBoundingClientRect();
-                // @ts-ignore
-                if (map[c$1.key]) {
-                    kept.push(c$1);
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
                 }
                 else {
-                    removed.push(c$1);
+                    removed.push(c);
                 }
             }
             this.kept = h(tag, null, kept);
@@ -7319,9 +7306,9 @@ var TransitionGroup = {
         }
         return h(tag, null, children);
     },
-    updated: function updated() {
-        var children = this.prevChildren;
-        var moveClass = this.moveClass || (this.name || 'v') + '-move';
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
         if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
             return;
         }
@@ -7334,13 +7321,12 @@ var TransitionGroup = {
         // assign to this to avoid being removed in tree-shaking
         // $flow-disable-line
         this._reflow = document.body.offsetHeight;
-        children.forEach(function (c) {
-            // @ts-ignore
+        children.forEach((c) => {
             if (c.data.moved) {
-                var el = c.elm;
-                var s = el.style;
+                const el = c.elm;
+                const s = el.style;
                 addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = '';
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
                 el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                     if (e && e.target !== el) {
                         return;
@@ -7355,7 +7341,7 @@ var TransitionGroup = {
         });
     },
     methods: {
-        hasMove: function hasMove(el, moveClass) {
+        hasMove(el, moveClass) {
             /* istanbul ignore if */
             if (!hasTransition) {
                 return false;
@@ -7369,16 +7355,16 @@ var TransitionGroup = {
             // transition at this very moment, we make a clone of it and remove
             // all other transition classes applied to ensure only the move class
             // is applied.
-            var clone = el.cloneNode();
+            const clone = el.cloneNode();
             if (el._transitionClasses) {
-                el._transitionClasses.forEach(function (cls) {
+                el._transitionClasses.forEach((cls) => {
                     removeClass(clone, cls);
                 });
             }
             addClass(clone, moveClass);
-            clone.style.display = 'none';
+            clone.style.display = "none";
             this.$el.appendChild(clone);
-            var info = getTransitionInfo(clone);
+            const info = getTransitionInfo(clone);
             this.$el.removeChild(clone);
             return (this._hasMove = info.hasTransform);
         },
@@ -7386,42 +7372,33 @@ var TransitionGroup = {
 };
 function callPendingCbs(c) {
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._moveCb) {
-        //@ts-ignore
         c.elm._moveCb();
     }
     /* istanbul ignore if */
-    //@ts-ignore
     if (c.elm._enterCb) {
-        //@ts-ignore
         c.elm._enterCb();
     }
 }
 function recordPosition(c) {
-    //@ts-ignore
     c.data.newPos = c.elm.getBoundingClientRect();
 }
 function applyTranslation(c) {
-    //@ts-ignore
-    var oldPos = c.data.pos;
-    //@ts-ignore
-    var newPos = c.data.newPos;
-    var dx = oldPos.left - newPos.left;
-    var dy = oldPos.top - newPos.top;
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
     if (dx || dy) {
-        //@ts-ignore
         c.data.moved = true;
-        //@ts-ignore
-        var s = c.elm.style;
-        s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-        s.transitionDuration = '0s';
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
     }
 }
 
 var platformComponents = {
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
+    Transition,
+    TransitionGroup,
 };
 
 // install platform specific utils
@@ -7443,7 +7420,7 @@ Vue.prototype.$mount = function (el, hydrating) {
 // devtools global hook
 /* istanbul ignore next */
 if (inBrowser) {
-    setTimeout(function () {
+    setTimeout(() => {
         if (config.devtools) {
             if (devtools) {
                 devtools.emit('init', Vue);
@@ -7460,11 +7437,11 @@ if (inBrowser) {
             config.productionTip !== false &&
             typeof console !== 'undefined') {
             // @ts-expect-error
-            console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                "Make sure to turn on production mode when deploying for production.\n" +
-                "See more tips at https://vuejs.org/guide/deployment.html");
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
         }
     }, 0);
 }
 
-export default Vue;
+export { Vue as default };
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 54df3a4afd2..0fd13ae54ed 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -1,15 +1,15 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
-}(this, (function () { 'use strict';
+})(this, (function () { 'use strict';
 
-  var emptyObject = Object.freeze({});
+  const emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
   function isUndef(v) {
@@ -36,7 +36,7 @@
   }
   /**
    * Quick object check - this is primarily used to tell
-   * Objects from primitive values when we know the value
+   * objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
   function isObject(obj) {
@@ -45,7 +45,7 @@
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
-  var _toString = Object.prototype.toString;
+  const _toString = Object.prototype.toString;
   function toRawType(value) {
       return _toString.call(value).slice(8, -1);
   }
@@ -63,7 +63,7 @@
    * Check if val is a valid array index.
    */
   function isValidArrayIndex(val) {
-      var n = parseFloat(String(val));
+      const n = parseFloat(String(val));
       return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
   function isPromise(val) {
@@ -86,7 +86,7 @@
    * If the conversion fails, return original string.
    */
   function toNumber(val) {
-      var n = parseFloat(val);
+      const n = parseFloat(val);
       return isNaN(n) ? val : n;
   }
   /**
@@ -94,27 +94,27 @@
    * is in that map.
    */
   function makeMap(str, expectsLowerCase) {
-      var map = Object.create(null);
-      var list = str.split(',');
-      for (var i = 0; i < list.length; i++) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
           map[list[i]] = true;
       }
-      return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
   }
   /**
    * Check if a tag is a built-in tag.
    */
-  var isBuiltInTag = makeMap('slot,component', true);
+  const isBuiltInTag = makeMap('slot,component', true);
   /**
    * Check if an attribute is a reserved attribute.
    */
-  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
   /**
    * Remove an item from an array.
    */
   function remove$2(arr, item) {
       if (arr.length) {
-          var index = arr.indexOf(item);
+          const index = arr.indexOf(item);
           if (index > -1) {
               return arr.splice(index, 1);
           }
@@ -123,7 +123,7 @@
   /**
    * Check whether an object has the property.
    */
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
   function hasOwn(obj, key) {
       return hasOwnProperty.call(obj, key);
   }
@@ -131,30 +131,30 @@
    * Create a cached version of a pure function.
    */
   function cached(fn) {
-      var cache = Object.create(null);
+      const cache = Object.create(null);
       return function cachedFn(str) {
-          var hit = cache[str];
+          const hit = cache[str];
           return hit || (cache[str] = fn(str));
       };
   }
   /**
    * Camelize a hyphen-delimited string.
    */
-  var camelizeRE = /-(\w)/g;
-  var camelize = cached(function (str) {
-      return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
   });
   /**
    * Capitalize a string.
    */
-  var capitalize = cached(function (str) {
+  const capitalize = cached((str) => {
       return str.charAt(0).toUpperCase() + str.slice(1);
   });
   /**
    * Hyphenate a camelCase string.
    */
-  var hyphenateRE = /\B([A-Z])/g;
-  var hyphenate = cached(function (str) {
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
       return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
   /**
@@ -167,7 +167,7 @@
   /* istanbul ignore next */
   function polyfillBind(fn, ctx) {
       function boundFn(a) {
-          var l = arguments.length;
+          const l = arguments.length;
           return l
               ? l > 1
                   ? fn.apply(ctx, arguments)
@@ -181,14 +181,14 @@
       return fn.bind(ctx);
   }
   // @ts-expect-error bind cannot be `undefined`
-  var bind = Function.prototype.bind ? nativeBind : polyfillBind;
+  const bind = Function.prototype.bind ? nativeBind : polyfillBind;
   /**
    * Convert an Array-like object to a real Array.
    */
   function toArray(list, start) {
       start = start || 0;
-      var i = list.length - start;
-      var ret = new Array(i);
+      let i = list.length - start;
+      const ret = new Array(i);
       while (i--) {
           ret[i] = list[i + start];
       }
@@ -198,7 +198,7 @@
    * Mix properties into target object.
    */
   function extend(to, _from) {
-      for (var key in _from) {
+      for (const key in _from) {
           to[key] = _from[key];
       }
       return to;
@@ -207,8 +207,8 @@
    * Merge an Array of Objects into a single Object.
    */
   function toObject(arr) {
-      var res = {};
-      for (var i = 0; i < arr.length; i++) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
           if (arr[i]) {
               extend(res, arr[i]);
           }
@@ -225,28 +225,28 @@
   /**
    * Always return false.
    */
-  var no = function (a, b, c) { return false; };
+  const no = (a, b, c) => false;
   /* eslint-enable no-unused-vars */
   /**
    * Return the same value.
    */
-  var identity = function (_) { return _; };
+  const identity = (_) => _;
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
   function looseEqual(a, b) {
       if (a === b)
-          { return true; }
-      var isObjectA = isObject(a);
-      var isObjectB = isObject(b);
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
       if (isObjectA && isObjectB) {
           try {
-              var isArrayA = Array.isArray(a);
-              var isArrayB = Array.isArray(b);
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
               if (isArrayA && isArrayB) {
                   return (a.length === b.length &&
-                      a.every(function (e, i) {
+                      a.every((e, i) => {
                           return looseEqual(e, b[i]);
                       }));
               }
@@ -254,10 +254,10 @@
                   return a.getTime() === b.getTime();
               }
               else if (!isArrayA && !isArrayB) {
-                  var keysA = Object.keys(a);
-                  var keysB = Object.keys(b);
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
                   return (keysA.length === keysB.length &&
-                      keysA.every(function (key) {
+                      keysA.every((key) => {
                           return looseEqual(a[key], b[key]);
                       }));
               }
@@ -284,9 +284,9 @@
    * contain an object of the same shape), or -1 if it is not present.
    */
   function looseIndexOf(arr, val) {
-      for (var i = 0; i < arr.length; i++) {
+      for (let i = 0; i < arr.length; i++) {
           if (looseEqual(arr[i], val))
-              { return i; }
+              return i;
       }
       return -1;
   }
@@ -294,7 +294,7 @@
    * Ensure a function is called only once.
    */
   function once(fn) {
-      var called = false;
+      let called = false;
       return function () {
           if (!called) {
               called = true;
@@ -303,9 +303,9 @@
       };
   }
 
-  var SSR_ATTR = 'data-server-rendered';
-  var ASSET_TYPES = ['component', 'directive', 'filter'];
-  var LIFECYCLE_HOOKS = [
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
       'beforeCreate',
       'created',
       'beforeMount',
@@ -317,7 +317,8 @@
       'activated',
       'deactivated',
       'errorCaptured',
-      'serverPrefetch' ];
+      'serverPrefetch',
+  ];
 
   var config = {
       /**
@@ -402,12 +403,12 @@
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
-  var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
   /**
    * Check if a string starts with $ or _
    */
   function isReserved(str) {
-      var c = (str + '').charCodeAt(0);
+      const c = (str + '').charCodeAt(0);
       return c === 0x24 || c === 0x5f;
   }
   /**
@@ -424,16 +425,16 @@
   /**
    * Parse simple path.
    */
-  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
+  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
   function parsePath(path) {
       if (bailRE.test(path)) {
           return;
       }
-      var segments = path.split('.');
+      const segments = path.split('.');
       return function (obj) {
-          for (var i = 0; i < segments.length; i++) {
+          for (let i = 0; i < segments.length; i++) {
               if (!obj)
-                  { return; }
+                  return;
               obj = obj[segments[i]];
           }
           return obj;
@@ -441,46 +442,41 @@
   }
 
   // can we use __proto__?
-  var hasProto = '__proto__' in {};
+  const hasProto = '__proto__' in {};
   // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined';
-  // @ts-ignore
-  var inWeex = 
-  // @ts-ignore
-  typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  // @ts-ignore
-  var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  var isEdge = UA && UA.indexOf('edge/') > 0;
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
   (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
   UA && /chrome\/\d+/.test(UA) && !isEdge;
   UA && /phantomjs/.test(UA);
-  var isFF = UA && UA.match(/firefox\/(\d+)/);
+  const isFF = UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
-  // @ts-ignore
-  var nativeWatch = {}.watch;
-  var supportsPassive = false;
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
   if (inBrowser) {
       try {
-          var opts = {};
+          const opts = {};
           Object.defineProperty(opts, 'passive', {
-              get: function get() {
+              get() {
                   /* istanbul ignore next */
                   supportsPassive = true;
               },
           }); // https://github.com/facebook/flow/issues/285
-          // @ts-ignore
           window.addEventListener('test-passive', null, opts);
       }
       catch (e) { }
   }
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
-  var _isServer;
-  var isServerRendering = function () {
+  let _isServer;
+  const isServerRendering = () => {
       if (_isServer === undefined) {
           /* istanbul ignore if */
           if (!inBrowser && !inWeex && typeof global !== 'undefined') {
@@ -496,104 +492,94 @@
       return _isServer;
   };
   // detect devtools
-  // @ts-ignore TODO decalre this types
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
   /* istanbul ignore next */
   function isNative(Ctor) {
       return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
   }
-  var hasSymbol = typeof Symbol !== 'undefined' &&
+  const hasSymbol = typeof Symbol !== 'undefined' &&
       isNative(Symbol) &&
       typeof Reflect !== 'undefined' &&
       isNative(Reflect.ownKeys);
-  var _Set; // $flow-disable-line
+  let _Set; // $flow-disable-line
   /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
       // use native Set when available.
       _Set = Set;
   }
   else {
       // a non-standard Set polyfill that only works with primitive keys.
-      _Set = /*@__PURE__*/(function () {
-          function Set() {
-              this.set = Object.create(null);
-          }
-          Set.prototype.has = function has (key) {
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
               return this.set[key] === true;
-          };
-          Set.prototype.add = function add (key) {
+          }
+          add(key) {
               this.set[key] = true;
-          };
-          Set.prototype.clear = function clear () {
+          }
+          clear() {
               this.set = Object.create(null);
-          };
-
-          return Set;
-      }());
+          }
+      };
   }
 
-  var warn = noop;
-  var tip = noop;
-  var generateComponentTrace; // work around flow check
-  var formatComponentName;
+  let warn = noop;
+  let tip = noop;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
   {
-      var hasConsole = typeof console !== 'undefined';
-      var classifyRE = /(?:^|[-_])(\w)/g;
-      var classify = function (str) { return str.replace(classifyRE, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, ''); };
-      warn = function (msg, vm) {
-          var trace = vm ? generateComponentTrace(vm) : '';
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
           if (config.warnHandler) {
               config.warnHandler.call(null, msg, vm, trace);
           }
           else if (hasConsole && !config.silent) {
-              console.error(("[Vue warn]: " + msg + trace));
+              console.error(`[Vue warn]: ${msg}${trace}`);
           }
       };
-      tip = function (msg, vm) {
+      tip = (msg, vm) => {
           if (hasConsole && !config.silent) {
-              console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
           }
       };
-      formatComponentName = function (vm, includeFile) {
+      formatComponentName = (vm, includeFile) => {
           if (vm.$root === vm) {
               return '<Root>';
           }
-          var options = 
-          // @ts-ignore
-          typeof vm === 'function' && vm.cid != null
-              ? // @ts-ignore
-                  vm.options
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
               : vm._isVue
-                  ? // @ts-ignore
-                      vm.$options || vm.constructor.options
+                  ? vm.$options || vm.constructor.options
                   : vm;
-          var name = options.name || options._componentTag;
-          var file = options.__file;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
           if (!name && file) {
-              var match = file.match(/([^/\\]+)\.vue$/);
+              const match = file.match(/([^/\\]+)\.vue$/);
               name = match && match[1];
           }
-          return ((name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-              (file && includeFile !== false ? (" at " + file) : ''));
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
       };
-      var repeat = function (str, n) {
-          var res = '';
+      const repeat = (str, n) => {
+          let res = '';
           while (n) {
               if (n % 2 === 1)
-                  { res += str; }
+                  res += str;
               if (n > 1)
-                  { str += str; }
+                  str += str;
               n >>= 1;
           }
           return res;
       };
-      generateComponentTrace = function (vm) {
-          // @ts-ignore
+      generateComponentTrace = (vm) => {
           if (vm._isVue && vm.$parent) {
-              var tree = [];
-              var currentRecursiveSequence = 0;
+              const tree = [];
+              let currentRecursiveSequence = 0;
               while (vm) {
                   if (tree.length > 0) {
-                      var last = tree[tree.length - 1];
+                      const last = tree[tree.length - 1];
                       if (last.constructor === vm.constructor) {
                           currentRecursiveSequence++;
                           vm = vm.$parent;
@@ -609,55 +595,60 @@
               }
               return ('\n\nfound in\n\n' +
                   tree
-                      .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-                      ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-                      : formatComponentName(vm))); })
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
                       .join('\n'));
           }
           else {
-              return ("\n\n(found in " + (formatComponentName(vm)) + ")");
+              return `\n\n(found in ${formatComponentName(vm)})`;
           }
       };
   }
 
-  var uid$2 = 0;
+  let uid$2 = 0;
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep() {
-      this.id = uid$2++;
-      this.subs = [];
-  };
-  Dep.prototype.addSub = function addSub (sub) {
-      this.subs.push(sub);
-  };
-  Dep.prototype.removeSub = function removeSub (sub) {
-      remove$2(this.subs, sub);
-  };
-  Dep.prototype.depend = function depend () {
-      if (Dep.target) {
-          Dep.target.addDep(this);
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid$2++;
+          this.subs = [];
       }
-  };
-  Dep.prototype.notify = function notify () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice();
-      if (!config.async) {
-          // subs aren't sorted in scheduler if not running async
-          // we need to sort them now to make sure they fire in correct
-          // order
-          subs.sort(function (a, b) { return a.id - b.id; });
-      }
-      for (var i = 0, l = subs.length; i < l; i++) {
-          subs[i].update();
+      addSub(sub) {
+          this.subs.push(sub);
       }
-  };
+      removeSub(sub) {
+          remove$2(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          if (!config.async) {
+              // subs aren't sorted in scheduler if not running async
+              // we need to sort them now to make sure they fire in correct
+              // order
+              subs.sort((a, b) => a.id - b.id);
+          }
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
-  var targetStack = [];
+  const targetStack = [];
   function pushTarget(target) {
       targetStack.push(target);
       Dep.target = target;
@@ -667,44 +658,66 @@
       Dep.target = targetStack[targetStack.length - 1];
   }
 
-  var VNode = function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-      this.tag = tag;
-      this.data = data;
-      this.children = children;
-      this.text = text;
-      this.elm = elm;
-      this.ns = undefined;
-      this.context = context;
-      this.fnContext = undefined;
-      this.fnOptions = undefined;
-      this.fnScopeId = undefined;
-      this.key = data && data.key;
-      this.componentOptions = componentOptions;
-      this.componentInstance = undefined;
-      this.parent = undefined;
-      this.raw = false;
-      this.isStatic = false;
-      this.isRootInsert = true;
-      this.isComment = false;
-      this.isCloned = false;
-      this.isOnce = false;
-      this.asyncFactory = asyncFactory;
-      this.asyncMeta = undefined;
-      this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-      return this.componentInstance;
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
-  var createEmptyVNode = function (text) {
-      if ( text === void 0 ) text = '';
-
-      var node = new VNode();
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
       node.text = text;
       node.isComment = true;
       return node;
@@ -717,9 +730,7 @@
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
   function cloneVNode(vnode) {
-      var cloned = new VNode(
-      //@ts-expect-error void type not valid here
-      vnode.tag, vnode.data, 
+      const cloned = new VNode(vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
@@ -740,29 +751,27 @@
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-  var arrayProto = Array.prototype;
-  var arrayMethods = Object.create(arrayProto);
-  var methodsToPatch = [
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
       'push',
       'pop',
       'shift',
       'unshift',
       'splice',
       'sort',
-      'reverse' ];
+      'reverse',
+  ];
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
       // cache original method
-      var original = arrayProto[method];
-      def(arrayMethods, method, function mutator() {
-          var args = [], len = arguments.length;
-          while ( len-- ) args[ len ] = arguments[ len ];
-
-          var result = original.apply(this, args);
-          var ob = this.__ob__;
-          var inserted;
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
           switch (method) {
               case 'push':
               case 'unshift':
@@ -773,19 +782,19 @@
                   break;
           }
           if (inserted)
-              { ob.observeArray(inserted); }
+              ob.observeArray(inserted);
           // notify change
           ob.dep.notify();
           return result;
       });
   });
 
-  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
-  var shouldObserve = true;
+  let shouldObserve = true;
   function toggleObserving(value) {
       shouldObserve = value;
   }
@@ -795,43 +804,48 @@
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer(value) {
-      this.value = value;
-      this.dep = new Dep();
-      this.vmCount = 0;
-      def(value, '__ob__', this);
-      if (Array.isArray(value)) {
-          if (hasProto) {
-              protoAugment(value, arrayMethods);
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
           }
           else {
-              copyAugment(value, arrayMethods, arrayKeys);
+              this.walk(value);
           }
-          this.observeArray(value);
-      }
-      else {
-          this.walk(value);
       }
-  };
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-      var keys = Object.keys(obj);
-      for (var i = 0; i < keys.length; i++) {
-          defineReactive(obj, keys[i]);
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
       }
-  };
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-          observe(items[i]);
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
       }
-  };
+  }
   // helpers
   /**
    * Augment a target Object or Array by intercepting
@@ -848,8 +862,8 @@
    */
   /* istanbul ignore next */
   function copyAugment(target, src, keys) {
-      for (var i = 0, l = keys.length; i < l; i++) {
-          var key = keys[i];
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
           def(target, key, src[key]);
       }
   }
@@ -862,7 +876,7 @@
       if (!isObject(value) || value instanceof VNode) {
           return;
       }
-      var ob;
+      let ob;
       if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
           ob = value.__ob__;
       }
@@ -882,23 +896,23 @@
    * Define a reactive property on an Object.
    */
   function defineReactive(obj, key, val, customSetter, shallow) {
-      var dep = new Dep();
-      var property = Object.getOwnPropertyDescriptor(obj, key);
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
           return;
       }
       // cater for pre-defined getter/setters
-      var getter = property && property.get;
-      var setter = property && property.set;
+      const getter = property && property.get;
+      const setter = property && property.set;
       if ((!getter || setter) && arguments.length === 2) {
           val = obj[key];
       }
-      var childOb = !shallow && observe(val);
+      let childOb = !shallow && observe(val);
       Object.defineProperty(obj, key, {
           enumerable: true,
           configurable: true,
           get: function reactiveGetter() {
-              var value = getter ? getter.call(obj) : val;
+              const value = getter ? getter.call(obj) : val;
               if (Dep.target) {
                   dep.depend();
                   if (childOb) {
@@ -911,7 +925,7 @@
               return value;
           },
           set: function reactiveSetter(newVal) {
-              var value = getter ? getter.call(obj) : val;
+              const value = getter ? getter.call(obj) : val;
               /* eslint-disable no-self-compare */
               if (newVal === value || (newVal !== newVal && value !== value)) {
                   return;
@@ -922,7 +936,7 @@
               }
               // #7981: for accessor properties without setter
               if (getter && !setter)
-                  { return; }
+                  return;
               if (setter) {
                   setter.call(obj, newVal);
               }
@@ -941,7 +955,7 @@
    */
   function set(target, key, val) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn(("Cannot set reactive property on undefined, null, or primitive value: " + target));
+          warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
@@ -952,8 +966,7 @@
           target[key] = val;
           return val;
       }
-      var ob = target.__ob__;
-      // @ts-ignore
+      const ob = target.__ob__;
       if (target._isVue || (ob && ob.vmCount)) {
           warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
                   'at runtime - declare it upfront in the data option.');
@@ -972,14 +985,13 @@
    */
   function del(target, key) {
       if ((isUndef(target) || isPrimitive(target))) {
-          warn(("Cannot delete reactive property on undefined, null, or primitive value: " + target));
+          warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
       }
       if (Array.isArray(target) && isValidArrayIndex(key)) {
           target.splice(key, 1);
           return;
       }
-      var ob = target.__ob__;
-      //@ts-ignore
+      const ob = target.__ob__;
       if (target._isVue || (ob && ob.vmCount)) {
           warn('Avoid deleting properties on a Vue instance or its root $data ' +
                   '- just set it to null.');
@@ -999,7 +1011,7 @@
    * we cannot intercept array element access like property getters.
    */
   function dependArray(value) {
-      for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
           e = value[i];
           e && e.__ob__ && e.__ob__.dep.depend();
           if (Array.isArray(e)) {
@@ -1013,14 +1025,14 @@
    * how to merge a parent option value and a child option
    * value into the final value.
    */
-  var strats = config.optionMergeStrategies;
+  const strats = config.optionMergeStrategies;
   /**
    * Options with restrictions
    */
   {
       strats.el = strats.propsData = function (parent, child, vm, key) {
           if (!vm) {
-              warn("option \"" + key + "\" can only be used during instance " +
+              warn(`option "${key}" can only be used during instance ` +
                   'creation with the `new` keyword.');
           }
           return defaultStrat(parent, child);
@@ -1031,16 +1043,16 @@
    */
   function mergeData(to, from) {
       if (!from)
-          { return to; }
-      var key, toVal, fromVal;
-      var keys = hasSymbol
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
           ? Reflect.ownKeys(from)
           : Object.keys(from);
-      for (var i = 0; i < keys.length; i++) {
+      for (let i = 0; i < keys.length; i++) {
           key = keys[i];
           // in case the object is already observed...
           if (key === '__ob__')
-              { continue; }
+              continue;
           toVal = to[key];
           fromVal = from[key];
           if (!hasOwn(to, key)) {
@@ -1072,18 +1084,14 @@
           // check if parentVal is a function here because
           // it has to be a function to pass previous merges.
           return function mergedDataFn() {
-              return mergeData(
-              // @ts-ignore
-              typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-              // @ts-ignore
-              typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
           };
       }
       else {
           return function mergedInstanceDataFn() {
               // instance merge
-              var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
               if (instanceData) {
                   return mergeData(instanceData, defaultData);
               }
@@ -1109,7 +1117,7 @@
    * Hooks and props are merged as arrays.
    */
   function mergeHook$1(parentVal, childVal) {
-      var res = childVal
+      const res = childVal
           ? parentVal
               ? parentVal.concat(childVal)
               : Array.isArray(childVal)
@@ -1119,15 +1127,15 @@
       return res ? dedupeHooks(res) : res;
   }
   function dedupeHooks(hooks) {
-      var res = [];
-      for (var i = 0; i < hooks.length; i++) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
           if (res.indexOf(hooks[i]) === -1) {
               res.push(hooks[i]);
           }
       }
       return res;
   }
-  LIFECYCLE_HOOKS.forEach(function (hook) {
+  LIFECYCLE_HOOKS.forEach((hook) => {
       strats[hook] = mergeHook$1;
   });
   /**
@@ -1138,7 +1146,7 @@
    * options and parent options.
    */
   function mergeAssets(parentVal, childVal, vm, key) {
-      var res = Object.create(parentVal || null);
+      const res = Object.create(parentVal || null);
       if (childVal) {
           assertObjectType(key, childVal, vm);
           return extend(res, childVal);
@@ -1160,27 +1168,27 @@
       // work around Firefox's Object.prototype.watch...
       //@ts-expect-error work around
       if (parentVal === nativeWatch)
-          { parentVal = undefined; }
+          parentVal = undefined;
       //@ts-expect-error work around
       if (childVal === nativeWatch)
-          { childVal = undefined; }
+          childVal = undefined;
       /* istanbul ignore if */
       if (!childVal)
-          { return Object.create(parentVal || null); }
+          return Object.create(parentVal || null);
       {
           assertObjectType(key, childVal, vm);
       }
       if (!parentVal)
-          { return childVal; }
-      var ret = {};
+          return childVal;
+      const ret = {};
       extend(ret, parentVal);
-      for (var key$1 in childVal) {
-          var parent = ret[key$1];
-          var child = childVal[key$1];
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
           if (parent && !Array.isArray(parent)) {
               parent = [parent];
           }
-          ret[key$1] = parent
+          ret[key] = parent
               ? parent.concat(child)
               : Array.isArray(child)
                   ? child
@@ -1196,30 +1204,30 @@
           assertObjectType(key, childVal, vm);
       }
       if (!parentVal)
-          { return childVal; }
-      var ret = Object.create(null);
+          return childVal;
+      const ret = Object.create(null);
       extend(ret, parentVal);
       if (childVal)
-          { extend(ret, childVal); }
+          extend(ret, childVal);
       return ret;
   };
   strats.provide = mergeDataOrFn;
   /**
    * Default strategy.
    */
-  var defaultStrat = function (parentVal, childVal) {
+  const defaultStrat = function (parentVal, childVal) {
       return childVal === undefined ? parentVal : childVal;
   };
   /**
    * Validate component names
    */
   function checkComponents(options) {
-      for (var key in options.components) {
+      for (const key in options.components) {
           validateComponentName(key);
       }
   }
   function validateComponentName(name) {
-      if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
           warn('Invalid component name: "' +
               name +
               '". Component names ' +
@@ -1236,11 +1244,11 @@
    * Object-based format.
    */
   function normalizeProps(options, vm) {
-      var props = options.props;
+      const props = options.props;
       if (!props)
-          { return; }
-      var res = {};
-      var i, val, name;
+          return;
+      const res = {};
+      let i, val, name;
       if (Array.isArray(props)) {
           i = props.length;
           while (i--) {
@@ -1255,15 +1263,15 @@
           }
       }
       else if (isPlainObject(props)) {
-          for (var key in props) {
+          for (const key in props) {
               val = props[key];
               name = camelize(key);
               res[name] = isPlainObject(val) ? val : { type: val };
           }
       }
       else {
-          warn("Invalid value for option \"props\": expected an Array or an Object, " +
-              "but got " + (toRawType(props)) + ".", vm);
+          warn(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
       }
       options.props = res;
   }
@@ -1271,36 +1279,36 @@
    * Normalize all injections into Object-based format
    */
   function normalizeInject(options, vm) {
-      var inject = options.inject;
+      const inject = options.inject;
       if (!inject)
-          { return; }
-      var normalized = (options.inject = {});
+          return;
+      const normalized = (options.inject = {});
       if (Array.isArray(inject)) {
-          for (var i = 0; i < inject.length; i++) {
+          for (let i = 0; i < inject.length; i++) {
               normalized[inject[i]] = { from: inject[i] };
           }
       }
       else if (isPlainObject(inject)) {
-          for (var key in inject) {
-              var val = inject[key];
+          for (const key in inject) {
+              const val = inject[key];
               normalized[key] = isPlainObject(val)
                   ? extend({ from: key }, val)
                   : { from: val };
           }
       }
       else {
-          warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-              "but got " + (toRawType(inject)) + ".", vm);
+          warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
       }
   }
   /**
    * Normalize raw function directives into object format.
    */
   function normalizeDirectives$1(options) {
-      var dirs = options.directives;
+      const dirs = options.directives;
       if (dirs) {
-          for (var key in dirs) {
-              var def = dirs[key];
+          for (const key in dirs) {
+              const def = dirs[key];
               if (typeof def === 'function') {
                   dirs[key] = { bind: def, update: def };
               }
@@ -1309,8 +1317,8 @@
   }
   function assertObjectType(name, value, vm) {
       if (!isPlainObject(value)) {
-          warn("Invalid value for option \"" + name + "\": expected an Object, " +
-              "but got " + (toRawType(value)) + ".", vm);
+          warn(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
       }
   }
   /**
@@ -1337,13 +1345,13 @@
               parent = mergeOptions(parent, child.extends, vm);
           }
           if (child.mixins) {
-              for (var i = 0, l = child.mixins.length; i < l; i++) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
                   parent = mergeOptions(parent, child.mixins[i], vm);
               }
           }
       }
-      var options = {};
-      var key;
+      const options = {};
+      let key;
       for (key in parent) {
           mergeField(key);
       }
@@ -1353,7 +1361,7 @@
           }
       }
       function mergeField(key) {
-          var strat = strats[key] || defaultStrat;
+          const strat = strats[key] || defaultStrat;
           options[key] = strat(parent[key], child[key], vm, key);
       }
       return options;
@@ -1368,18 +1376,18 @@
       if (typeof id !== 'string') {
           return;
       }
-      var assets = options[type];
+      const assets = options[type];
       // check local registration variations first
       if (hasOwn(assets, id))
-          { return assets[id]; }
-      var camelizedId = camelize(id);
+          return assets[id];
+      const camelizedId = camelize(id);
       if (hasOwn(assets, camelizedId))
-          { return assets[camelizedId]; }
-      var PascalCaseId = capitalize(camelizedId);
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
       if (hasOwn(assets, PascalCaseId))
-          { return assets[PascalCaseId]; }
+          return assets[PascalCaseId];
       // fallback to prototype chain
-      var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
       if (warnMissing && !res) {
           warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
       }
@@ -1387,11 +1395,11 @@
   }
 
   function validateProp(key, propOptions, propsData, vm) {
-      var prop = propOptions[key];
-      var absent = !hasOwn(propsData, key);
-      var value = propsData[key];
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
       // boolean casting
-      var booleanIndex = getTypeIndex(Boolean, prop.type);
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
       if (booleanIndex > -1) {
           if (absent && !hasOwn(prop, 'default')) {
               value = false;
@@ -1399,7 +1407,7 @@
           else if (value === '' || value === hyphenate(key)) {
               // only cast empty string / same name to boolean if
               // boolean has higher priority
-              var stringIndex = getTypeIndex(String, prop.type);
+              const stringIndex = getTypeIndex(String, prop.type);
               if (stringIndex < 0 || booleanIndex < stringIndex) {
                   value = true;
               }
@@ -1410,7 +1418,7 @@
           value = getPropDefaultValue(vm, prop, key);
           // since the default value is a fresh copy,
           // make sure to observe it.
-          var prevShouldObserve = shouldObserve;
+          const prevShouldObserve = shouldObserve;
           toggleObserving(true);
           observe(value);
           toggleObserving(prevShouldObserve);
@@ -1428,7 +1436,7 @@
       if (!hasOwn(prop, 'default')) {
           return undefined;
       }
-      var def = prop.default;
+      const def = prop.default;
       // warn against non-factory defaults for Object & Array
       if (isObject(def)) {
           warn('Invalid default value for prop "' +
@@ -1462,38 +1470,37 @@
       if (value == null && !prop.required) {
           return;
       }
-      var type = prop.type;
-      // @ts-ignore
-      var valid = !type || type === true;
-      var expectedTypes = [];
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
       if (type) {
           if (!Array.isArray(type)) {
               type = [type];
           }
-          for (var i = 0; i < type.length && !valid; i++) {
-              var assertedType = assertType(value, type[i], vm);
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
               expectedTypes.push(assertedType.expectedType || '');
               valid = assertedType.valid;
           }
       }
-      var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
+      const haveExpectedTypes = expectedTypes.some((t) => t);
       if (!valid && haveExpectedTypes) {
           warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
           return;
       }
-      var validator = prop.validator;
+      const validator = prop.validator;
       if (validator) {
           if (!validator(value)) {
               warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
           }
       }
   }
-  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
   function assertType(value, type, vm) {
-      var valid;
-      var expectedType = getType(type);
+      let valid;
+      const expectedType = getType(type);
       if (simpleCheckRE.test(expectedType)) {
-          var t = typeof value;
+          const t = typeof value;
           valid = t === expectedType.toLowerCase();
           // for primitive wrapper objects
           if (!valid && t === 'object') {
@@ -1516,18 +1523,18 @@
           }
       }
       return {
-          valid: valid,
-          expectedType: expectedType,
+          valid,
+          expectedType,
       };
   }
-  var functionTypeCheckRE = /^\s*function (\w+)/;
+  const functionTypeCheckRE = /^\s*function (\w+)/;
   /**
    * Use function string name to check built-in types,
    * because a simple equality check will fail when running
    * across different vms / iframes.
    */
   function getType(fn) {
-      var match = fn && fn.toString().match(functionTypeCheckRE);
+      const match = fn && fn.toString().match(functionTypeCheckRE);
       return match ? match[1] : '';
   }
   function isSameType(a, b) {
@@ -1537,7 +1544,7 @@
       if (!Array.isArray(expectedTypes)) {
           return isSameType(expectedTypes, type) ? 0 : -1;
       }
-      for (var i = 0, len = expectedTypes.length; i < len; i++) {
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
           if (isSameType(expectedTypes[i], type)) {
               return i;
           }
@@ -1545,44 +1552,41 @@
       return -1;
   }
   function getInvalidTypeMessage(name, value, expectedTypes) {
-      var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-          " Expected " + (expectedTypes.map(capitalize).join(', '));
-      var expectedType = expectedTypes[0];
-      var receivedType = toRawType(value);
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
       // check if we need to specify expected value
       if (expectedTypes.length === 1 &&
           isExplicable(expectedType) &&
           isExplicable(typeof value) &&
           !isBoolean(expectedType, receivedType)) {
-          message += " with value " + (styleValue(value, expectedType));
+          message += ` with value ${styleValue(value, expectedType)}`;
       }
-      message += ", got " + receivedType + " ";
+      message += `, got ${receivedType} `;
       // check if we need to specify received value
       if (isExplicable(receivedType)) {
-          message += "with value " + (styleValue(value, receivedType)) + ".";
+          message += `with value ${styleValue(value, receivedType)}.`;
       }
       return message;
   }
   function styleValue(value, type) {
       if (type === 'String') {
-          return ("\"" + value + "\"");
+          return `"${value}"`;
       }
       else if (type === 'Number') {
-          return ("" + (Number(value)));
+          return `${Number(value)}`;
       }
       else {
-          return ("" + value);
+          return `${value}`;
       }
   }
-  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
   function isExplicable(value) {
-      return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
   }
-  function isBoolean() {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
   }
 
   function handleError(err, vm, info) {
@@ -1591,15 +1595,15 @@
       pushTarget();
       try {
           if (vm) {
-              var cur = vm;
+              let cur = vm;
               while ((cur = cur.$parent)) {
-                  var hooks = cur.$options.errorCaptured;
+                  const hooks = cur.$options.errorCaptured;
                   if (hooks) {
-                      for (var i = 0; i < hooks.length; i++) {
+                      for (let i = 0; i < hooks.length; i++) {
                           try {
-                              var capture = hooks[i].call(cur, err, vm, info) === false;
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
                               if (capture)
-                                  { return; }
+                                  return;
                           }
                           catch (e) {
                               globalHandleError(e, cur, 'errorCaptured hook');
@@ -1615,17 +1619,18 @@
       }
   }
   function invokeWithErrorHandling(handler, context, args, vm, info) {
-      var res;
+      let res;
       try {
           res = args ? handler.apply(context, args) : handler.call(context);
           if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
               // issue #9511
               // avoid catch triggering multiple times when nested calls
               res._handled = true;
           }
       }
       catch (e) {
+          // @ts-expect-error should it be any?
           handleError(e, vm, info);
       }
       return res;
@@ -1647,7 +1652,7 @@
   }
   function logError(err, vm, info) {
       {
-          warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
+          warn(`Error in ${info}: "${err.toString()}"`, vm);
       }
       /* istanbul ignore else */
       if ((inBrowser || inWeex) && typeof console !== 'undefined') {
@@ -1659,14 +1664,14 @@
   }
 
   /* globals MutationObserver */
-  var isUsingMicroTask = false;
-  var callbacks = [];
-  var pending = false;
+  let isUsingMicroTask = false;
+  const callbacks = [];
+  let pending = false;
   function flushCallbacks() {
       pending = false;
-      var copies = callbacks.slice(0);
+      const copies = callbacks.slice(0);
       callbacks.length = 0;
-      for (var i = 0; i < copies.length; i++) {
+      for (let i = 0; i < copies.length; i++) {
           copies[i]();
       }
   }
@@ -1681,7 +1686,7 @@
   // where microtasks have too high a priority and fire in between supposedly
   // sequential events (e.g. #4521, #6690, which have workarounds)
   // or even between bubbling of the same event (#6566).
-  var timerFunc;
+  let timerFunc;
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -1690,8 +1695,8 @@
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
   if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      var p = Promise.resolve();
-      timerFunc = function () {
+      const p = Promise.resolve();
+      timerFunc = () => {
           p.then(flushCallbacks);
           // In problematic UIWebViews, Promise.then doesn't completely break, but
           // it can get stuck in a weird state where callbacks are pushed into the
@@ -1699,7 +1704,7 @@
           // needs to do some other work, e.g. handle a timer. Therefore we can
           // "force" the microtask queue to be flushed by adding an empty timer.
           if (isIOS)
-              { setTimeout(noop); }
+              setTimeout(noop);
       };
       isUsingMicroTask = true;
   }
@@ -1711,13 +1716,13 @@
       // Use MutationObserver where native Promise is not available,
       // e.g. PhantomJS, iOS7, Android 4.4
       // (#6466 MutationObserver is unreliable in IE11)
-      var counter = 1;
-      var observer = new MutationObserver(flushCallbacks);
-      var textNode = document.createTextNode(String(counter));
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
       observer.observe(textNode, {
           characterData: true,
       });
-      timerFunc = function () {
+      timerFunc = () => {
           counter = (counter + 1) % 2;
           textNode.data = String(counter);
       };
@@ -1727,24 +1732,25 @@
       // Fallback to setImmediate.
       // Technically it leverages the (macro) task queue,
       // but it is still a better choice than setTimeout.
-      timerFunc = function () {
+      timerFunc = () => {
           setImmediate(flushCallbacks);
       };
   }
   else {
       // Fallback to setTimeout.
-      timerFunc = function () {
+      timerFunc = () => {
           setTimeout(flushCallbacks, 0);
       };
   }
   function nextTick(cb, ctx) {
-      var _resolve;
-      callbacks.push(function () {
+      let _resolve;
+      callbacks.push(() => {
           if (cb) {
               try {
                   cb.call(ctx);
               }
               catch (e) {
+                  // @ts-expect-error should it be any?
                   handleError(e, ctx, 'nextTick');
               }
           }
@@ -1758,40 +1764,40 @@
       }
       // $flow-disable-line
       if (!cb && typeof Promise !== 'undefined') {
-          return new Promise(function (resolve) {
+          return new Promise((resolve) => {
               _resolve = resolve;
           });
       }
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
-  var initProxy;
+  let initProxy;
   {
-      var allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
           'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
           'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
           'require' // for Webpack/Browserify
       );
-      var warnNonPresent = function (target, key) {
-          warn("Property or method \"" + key + "\" is not defined on the instance but " +
+      const warnNonPresent = (target, key) => {
+          warn(`Property or method "${key}" is not defined on the instance but ` +
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
               'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
-      var warnReservedPrefix = function (target, key) {
-          warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
+      const warnReservedPrefix = (target, key) => {
+          warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
               'See: https://vuejs.org/v2/api/#data', target);
       };
-      var hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
       if (hasProxy) {
-          var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
           config.keyCodes = new Proxy(config.keyCodes, {
-              set: function set(target, key, value) {
+              set(target, key, value) {
                   if (isBuiltInModifier(key)) {
-                      warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
+                      warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
                       return false;
                   }
                   else {
@@ -1801,29 +1807,29 @@
               },
           });
       }
-      var hasHandler = {
-          has: function has(target, key) {
-              var has = key in target;
-              var isAllowed = allowedGlobals(key) ||
+      const hasHandler = {
+          has(target, key) {
+              const has = key in target;
+              const isAllowed = allowedGlobals(key) ||
                   (typeof key === 'string' &&
                       key.charAt(0) === '_' &&
                       !(key in target.$data));
               if (!has && !isAllowed) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      warnReservedPrefix(target, key);
                   else
-                      { warnNonPresent(target, key); }
+                      warnNonPresent(target, key);
               }
               return has || !isAllowed;
           },
       };
-      var getHandler = {
-          get: function get(target, key) {
+      const getHandler = {
+          get(target, key) {
               if (typeof key === 'string' && !(key in target)) {
                   if (key in target.$data)
-                      { warnReservedPrefix(target, key); }
+                      warnReservedPrefix(target, key);
                   else
-                      { warnNonPresent(target, key); }
+                      warnNonPresent(target, key);
               }
               return target[key];
           },
@@ -1831,8 +1837,8 @@
       initProxy = function initProxy(vm) {
           if (hasProxy) {
               // determine which proxy handler to use
-              var options = vm.$options;
-              var handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              const options = vm.$options;
+              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
               vm._renderProxy = new Proxy(vm, handlers);
           }
           else {
@@ -1841,7 +1847,7 @@
       };
   }
 
-  var seenObjects = new _Set();
+  const seenObjects = new _Set();
   /**
    * Recursively traverse an object to evoke all converted
    * getters, so that every nested property inside the object
@@ -1852,15 +1858,15 @@
       seenObjects.clear();
   }
   function _traverse(val, seen) {
-      var i, keys;
-      var isA = Array.isArray(val);
+      let i, keys;
+      const isA = Array.isArray(val);
       if ((!isA && !isObject(val)) ||
           Object.isFrozen(val) ||
           val instanceof VNode) {
           return;
       }
       if (val.__ob__) {
-          var depId = val.__ob__.dep.id;
+          const depId = val.__ob__.dep.id;
           if (seen.has(depId)) {
               return;
           }
@@ -1869,28 +1875,28 @@
       if (isA) {
           i = val.length;
           while (i--)
-              { _traverse(val[i], seen); }
+              _traverse(val[i], seen);
       }
       else {
           keys = Object.keys(val);
           i = keys.length;
           while (i--)
-              { _traverse(val[keys[i]], seen); }
+              _traverse(val[keys[i]], seen);
       }
   }
 
-  var mark;
-  var measure;
+  let mark;
+  let measure;
   {
-      var perf = inBrowser && window.performance;
+      const perf = inBrowser && window.performance;
       /* istanbul ignore if */
       if (perf &&
           perf.mark &&
           perf.measure &&
           perf.clearMarks &&
           perf.clearMeasures) {
-          mark = function (tag) { return perf.mark(tag); };
-          measure = function (name, startTag, endTag) {
+          mark = (tag) => perf.mark(tag);
+          measure = (name, startTag, endTag) => {
               perf.measure(name, startTag, endTag);
               perf.clearMarks(startTag);
               perf.clearMarks(endTag);
@@ -1899,47 +1905,45 @@
       }
   }
 
-  var normalizeEvent = cached(function (name) {
-      var passive = name.charAt(0) === '&';
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
       name = passive ? name.slice(1) : name;
-      var once = name.charAt(0) === '~'; // Prefixed last, checked first
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
       name = once ? name.slice(1) : name;
-      var capture = name.charAt(0) === '!';
+      const capture = name.charAt(0) === '!';
       name = capture ? name.slice(1) : name;
       return {
-          name: name,
-          once: once,
-          capture: capture,
-          passive: passive,
+          name,
+          once,
+          capture,
+          passive,
       };
   });
   function createFnInvoker(fns, vm) {
       function invoker() {
-          var arguments$1 = arguments;
-
-          var fns = invoker.fns;
+          const fns = invoker.fns;
           if (Array.isArray(fns)) {
-              var cloned = fns.slice();
-              for (var i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
               }
           }
           else {
               // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
           }
       }
       invoker.fns = fns;
       return invoker;
   }
   function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      var name, cur, old, event;
+      let name, cur, old, event;
       for (name in on) {
           cur = on[name];
           old = oldOn[name];
           event = normalizeEvent(name);
           if (isUndef(cur)) {
-              warn("Invalid handler for event \"" + (event.name) + "\": got " + String(cur), vm);
+              warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
           }
           else if (isUndef(old)) {
               if (isUndef(cur.fns)) {
@@ -1967,8 +1971,8 @@
       if (def instanceof VNode) {
           def = def.data.hook || (def.data.hook = {});
       }
-      var invoker;
-      var oldHook = def[hookKey];
+      let invoker;
+      const oldHook = def[hookKey];
       function wrappedHook() {
           hook.apply(this, arguments);
           // important: remove merged hook to ensure it's called only once
@@ -1999,27 +2003,26 @@
       // we are only extracting raw values here.
       // validation and default values are handled in the child
       // component itself.
-      var propOptions = Ctor.options.props;
+      const propOptions = Ctor.options.props;
       if (isUndef(propOptions)) {
           return;
       }
-      var res = {};
-      var attrs = data.attrs;
-      var props = data.props;
+      const res = {};
+      const { attrs, props } = data;
       if (isDef(attrs) || isDef(props)) {
-          for (var key in propOptions) {
-              var altKey = hyphenate(key);
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
               {
-                  var keyInLowerCase = key.toLowerCase();
+                  const keyInLowerCase = key.toLowerCase();
                   if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                          (formatComponentName(
-                          // @ts-ignore
-                          tag || Ctor)) + ", but the declared prop name is" +
-                          " \"" + key + "\". " +
-                          "Note that HTML attributes are case-insensitive and camelCased " +
-                          "props need to use their kebab-case equivalents when using in-DOM " +
-                          "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\".");
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
                   }
               }
               checkProp(res, props, key, altKey, true) ||
@@ -2060,7 +2063,7 @@
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
   function simpleNormalizeChildren(children) {
-      for (var i = 0; i < children.length; i++) {
+      for (let i = 0; i < children.length; i++) {
           if (Array.isArray(children[i])) {
               return Array.prototype.concat.apply([], children);
           }
@@ -2082,18 +2085,18 @@
       return isDef(node) && isDef(node.text) && isFalse(node.isComment);
   }
   function normalizeArrayChildren(children, nestedIndex) {
-      var res = [];
-      var i, c, lastIndex, last;
+      const res = [];
+      let i, c, lastIndex, last;
       for (i = 0; i < children.length; i++) {
           c = children[i];
           if (isUndef(c) || typeof c === 'boolean')
-              { continue; }
+              continue;
           lastIndex = res.length - 1;
           last = res[lastIndex];
           //  nested
           if (Array.isArray(c)) {
               if (c.length > 0) {
-                  c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
                   // merge adjacent text nodes
                   if (isTextNode(c[0]) && isTextNode(last)) {
                       res[lastIndex] = createTextVNode(last.text + c[0].text);
@@ -2125,7 +2128,7 @@
                       isDef(c.tag) &&
                       isUndef(c.key) &&
                       isDef(nestedIndex)) {
-                      c.key = "__vlist" + nestedIndex + "_" + i + "__";
+                      c.key = `__vlist${nestedIndex}_${i}__`;
                   }
                   res.push(c);
               }
@@ -2135,7 +2138,7 @@
   }
 
   function initProvide(vm) {
-      var provide = vm.$options.provide;
+      const provide = vm.$options.provide;
       if (provide) {
           vm._provided =
               typeof provide === 'function'
@@ -2145,16 +2148,16 @@
       }
   }
   function initInjections(vm) {
-      var result = resolveInject(vm.$options.inject, vm);
+      const result = resolveInject(vm.$options.inject, vm);
       if (result) {
           toggleObserving(false);
-          Object.keys(result).forEach(function (key) {
+          Object.keys(result).forEach((key) => {
               /* istanbul ignore else */
               {
-                  defineReactive(vm, key, result[key], function () {
-                      warn("Avoid mutating an injected value directly since the changes will be " +
-                          "overwritten whenever the provided component re-renders. " +
-                          "injection being mutated: \"" + key + "\"", vm);
+                  defineReactive(vm, key, result[key], () => {
+                      warn(`Avoid mutating an injected value directly since the changes will be ` +
+                          `overwritten whenever the provided component re-renders. ` +
+                          `injection being mutated: "${key}"`, vm);
                   });
               }
           });
@@ -2164,15 +2167,15 @@
   function resolveInject(inject, vm) {
       if (inject) {
           // inject is :any because flow is not smart enough to figure out cached
-          var result = Object.create(null);
-          var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (var i = 0; i < keys.length; i++) {
-              var key = keys[i];
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
               // #6574 in case the inject object is observed...
               if (key === '__ob__')
-                  { continue; }
-              var provideKey = inject[key].from;
-              var source = vm;
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
               while (source) {
                   if (source._provided && hasOwn(source._provided, provideKey)) {
                       result[key] = source._provided[provideKey];
@@ -2183,15 +2186,14 @@
               }
               if (!source) {
                   if ('default' in inject[key]) {
-                      var provideDefault = inject[key].default;
+                      const provideDefault = inject[key].default;
                       result[key] =
                           typeof provideDefault === 'function'
                               ? provideDefault.call(vm)
                               : provideDefault;
                   }
                   else {
-                      // @ts-ignore
-                      warn(("Injection \"" + key + "\" not found"), vm);
+                      warn(`Injection "${key}" not found`, vm);
                   }
               }
           }
@@ -2206,10 +2208,10 @@
       if (!children || !children.length) {
           return {};
       }
-      var slots = {};
-      for (var i = 0, l = children.length; i < l; i++) {
-          var child = children[i];
-          var data = child.data;
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
           // remove slot attribute if the node is resolved as a Vue slot node
           if (data && data.attrs && data.attrs.slot) {
               delete data.attrs.slot;
@@ -2219,8 +2221,8 @@
           if ((child.context === context || child.fnContext === context) &&
               data &&
               data.slot != null) {
-              var name = data.slot;
-              var slot = slots[name] || (slots[name] = []);
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
               if (child.tag === 'template') {
                   slot.push.apply(slot, child.children || []);
               }
@@ -2233,9 +2235,9 @@
           }
       }
       // ignore slots that contains only whitespace
-      for (var name$1 in slots) {
-          if (slots[name$1].every(isWhitespace)) {
-              delete slots[name$1];
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
           }
       }
       return slots;
@@ -2244,11 +2246,16 @@
       return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
+  }
+
   function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      var res;
-      var hasNormalSlots = Object.keys(normalSlots).length > 0;
-      var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      var key = slots && slots.$key;
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
       if (!slots) {
           res = {};
       }
@@ -2268,16 +2275,16 @@
       }
       else {
           res = {};
-          for (var key$1 in slots) {
-              if (slots[key$1] && key$1[0] !== '$') {
-                  res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
               }
           }
       }
       // expose normal slots on scopedSlots
-      for (var key$2 in normalSlots) {
-          if (!(key$2 in res)) {
-              res[key$2] = proxyNormalSlot(normalSlots, key$2);
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
           }
       }
       // avoriaz seems to mock a non-extensible $scopedSlots object
@@ -2285,19 +2292,22 @@
       if (slots && Object.isExtensible(slots)) {
           slots._normalized = res;
       }
-      def(res, '$stable', isStable);
-      def(res, '$key', key);
-      def(res, '$hasNormal', hasNormalSlots);
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
       return res;
   }
   function normalizeScopedSlot(normalSlots, key, fn) {
-      var normalized = function () {
-          var res = arguments.length ? fn.apply(null, arguments) : fn({});
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
           res =
-              res && typeof res === 'object' && !Array.isArray(res)
+              res && typeof res === "object" && !Array.isArray(res)
                   ? [res] // single vnode
                   : normalizeChildren(res);
-          return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
               ? undefined
               : res;
       };
@@ -2314,14 +2324,14 @@
       return normalized;
   }
   function proxyNormalSlot(slots, key) {
-      return function () { return slots[key]; };
+      return () => slots[key];
   }
 
   /**
    * Runtime helper for rendering v-for lists.
    */
   function renderList(val, render) {
-      var ret = null, i, l, keys, key;
+      let ret = null, i, l, keys, key;
       if (Array.isArray(val) || typeof val === 'string') {
           ret = new Array(val.length);
           for (i = 0, l = val.length; i < l; i++) {
@@ -2337,8 +2347,8 @@
       else if (isObject(val)) {
           if (hasSymbol && val[Symbol.iterator]) {
               ret = [];
-              var iterator = val[Symbol.iterator]();
-              var result = iterator.next();
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
               while (!result.done) {
                   ret.push(render(result.value, ret.length));
                   result = iterator.next();
@@ -2363,26 +2373,34 @@
   /**
    * Runtime helper for rendering <slot>
    */
-  function renderSlot(name, fallback, props, bindObject) {
-      var scopedSlotFn = this.$scopedSlots[name];
-      var nodes;
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
       if (scopedSlotFn) {
           // scoped slot
           props = props || {};
           if (bindObject) {
               if (!isObject(bindObject)) {
-                  warn('slot v-bind without argument expects an Object', this);
+                  warn("slot v-bind without argument expects an Object", this);
               }
               props = extend(extend({}, bindObject), props);
           }
-          nodes = scopedSlotFn(props) || fallback;
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
       }
       else {
-          nodes = this.$slots[name] || fallback;
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
       }
-      var target = props && props.slot;
+      const target = props && props.slot;
       if (target) {
-          return this.$createElement('template', { slot: target }, nodes);
+          return this.$createElement("template", { slot: target }, nodes);
       }
       else {
           return nodes;
@@ -2410,7 +2428,7 @@
    * passing in eventKeyName as last argument separately for backwards compat
    */
   function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
       if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
           return isKeyNotMatch(builtInKeyName, eventKeyName);
       }
@@ -2420,6 +2438,7 @@
       else if (eventKeyName) {
           return hyphenate(eventKeyName) !== key;
       }
+      return eventKeyCode === undefined;
   }
 
   /**
@@ -2434,32 +2453,30 @@
               if (Array.isArray(value)) {
                   value = toObject(value);
               }
-              var hash;
-              var loop = function ( key ) {
+              let hash;
+              for (const key in value) {
                   if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
                       hash = data;
                   }
                   else {
-                      var type = data.attrs && data.attrs.type;
+                      const type = data.attrs && data.attrs.type;
                       hash =
                           asProp || config.mustUseProp(tag, type, key)
                               ? data.domProps || (data.domProps = {})
                               : data.attrs || (data.attrs = {});
                   }
-                  var camelizedKey = camelize(key);
-                  var hyphenatedKey = hyphenate(key);
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
                   if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
                       hash[key] = value[key];
                       if (isSync) {
-                          var on = data.on || (data.on = {});
-                          on[("update:" + key)] = function ($event) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
                               value[key] = $event;
                           };
                       }
                   }
-              };
-
-              for (var key in value) loop( key );
+              }
           }
       }
       return data;
@@ -2469,8 +2486,8 @@
    * Runtime helper for rendering static trees.
    */
   function renderStatic(index, isInFor) {
-      var cached = this._staticTrees || (this._staticTrees = []);
-      var tree = cached[index];
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
       // if has already-rendered static tree and not inside v-for,
       // we can reuse the same tree.
       if (tree && !isInFor) {
@@ -2479,7 +2496,7 @@
       // otherwise, render a fresh tree.
       tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
       );
-      markStatic(tree, ("__static__" + index), false);
+      markStatic(tree, `__static__${index}`, false);
       return tree;
   }
   /**
@@ -2487,14 +2504,14 @@
    * Effectively it means marking the node as static with a unique key.
    */
   function markOnce(tree, index, key) {
-      markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
+      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
       return tree;
   }
   function markStatic(tree, key, isOnce) {
       if (Array.isArray(tree)) {
-          for (var i = 0; i < tree.length; i++) {
+          for (let i = 0; i < tree.length; i++) {
               if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], (key + "_" + i), isOnce);
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
               }
           }
       }
@@ -2514,10 +2531,10 @@
               warn('v-on without argument expects an Object value', this);
           }
           else {
-              var on = (data.on = data.on ? extend({}, data.on) : {});
-              for (var key in value) {
-                  var existing = on[key];
-                  var ours = value[key];
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
                   on[key] = existing ? [].concat(existing, ours) : ours;
               }
           }
@@ -2529,8 +2546,8 @@
   // the following are added in 2.6
   hasDynamicKeys, contentHashKey) {
       res = res || { $stable: !hasDynamicKeys };
-      for (var i = 0; i < fns.length; i++) {
-          var slot = fns[i];
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
           if (Array.isArray(slot)) {
               resolveScopedSlots(slot, res, hasDynamicKeys);
           }
@@ -2552,15 +2569,15 @@
 
   // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
   function bindDynamicKeys(baseObj, values) {
-      for (var i = 0; i < values.length; i += 2) {
-          var key = values[i];
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
           if (typeof key === 'string' && key) {
               baseObj[values[i]] = values[i + 1];
           }
           else if (key !== '' &&
               key !== null) {
               // null is a special value for explicitly removing a binding
-              warn(("Invalid value for dynamic directive argument (expected string or null): " + key), this);
+              warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
           }
       }
       return baseObj;
@@ -2593,12 +2610,10 @@
   }
 
   function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      var this$1 = this;
-
-      var options = Ctor.options;
+      const options = Ctor.options;
       // ensure the createElement function in functional components
       // gets a unique context - this is necessary for correct named slot check
-      var contextVm;
+      let contextVm;
       if (hasOwn(parent, '_uid')) {
           contextVm = Object.create(parent);
           // $flow-disable-line
@@ -2612,23 +2627,23 @@
           // $flow-disable-line
           parent = parent._original;
       }
-      var isCompiled = isTrue(options._compiled);
-      var needNormalization = !isCompiled;
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
       this.data = data;
       this.props = props;
       this.children = children;
       this.parent = parent;
       this.listeners = data.on || emptyObject;
       this.injections = resolveInject(options.inject, parent);
-      this.slots = function () {
-          if (!this$1.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this$1.$slots = resolveSlots(children, parent)));
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
           }
-          return this$1.$slots;
+          return this.$slots;
       };
       Object.defineProperty(this, 'scopedSlots', {
           enumerable: true,
-          get: function get() {
+          get() {
               return normalizeScopedSlots(data.scopedSlots, this.slots());
           },
       });
@@ -2641,8 +2656,8 @@
           this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
       }
       if (options._scopeId) {
-          this._c = function (a, b, c, d) {
-              var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+          this._c = (a, b, c, d) => {
+              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
               if (vnode && !Array.isArray(vnode)) {
                   vnode.fnScopeId = options._scopeId;
                   vnode.fnContext = parent;
@@ -2651,34 +2666,34 @@
           };
       }
       else {
-          this._c = function (a, b, c, d) { return createElement$1(contextVm, a, b, c, d, needNormalization); };
+          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
       }
   }
   installRenderHelpers(FunctionalRenderContext.prototype);
   function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      var options = Ctor.options;
-      var props = {};
-      var propOptions = options.props;
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
       if (isDef(propOptions)) {
-          for (var key in propOptions) {
+          for (const key in propOptions) {
               props[key] = validateProp(key, propOptions, propsData || emptyObject);
           }
       }
       else {
           if (isDef(data.attrs))
-              { mergeProps(props, data.attrs); }
+              mergeProps(props, data.attrs);
           if (isDef(data.props))
-              { mergeProps(props, data.props); }
+              mergeProps(props, data.props);
       }
-      var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      var vnode = options.render.call(null, renderContext._c, renderContext);
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
       if (vnode instanceof VNode) {
           return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
       }
       else if (Array.isArray(vnode)) {
-          var vnodes = normalizeChildren(vnode) || [];
-          var res = new Array(vnodes.length);
-          for (var i = 0; i < vnodes.length; i++) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
               res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
           }
           return res;
@@ -2688,7 +2703,7 @@
       // #7817 clone node before setting fnContext, otherwise if the node is reused
       // (e.g. it was from a cached normal slot) the fnContext causes named slots
       // that should not be matched to match.
-      var clone = cloneVNode(vnode);
+      const clone = cloneVNode(vnode);
       clone.fnContext = contextVm;
       clone.fnOptions = options;
       {
@@ -2700,38 +2715,37 @@
       return clone;
   }
   function mergeProps(to, from) {
-      for (var key in from) {
+      for (const key in from) {
           to[camelize(key)] = from[key];
       }
   }
 
   // inline hooks to be invoked on component VNodes during patch
-  var componentVNodeHooks = {
-      init: function init(vnode, hydrating) {
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
           if (vnode.componentInstance &&
               !vnode.componentInstance._isDestroyed &&
               vnode.data.keepAlive) {
               // kept-alive components, treat as a patch
-              var mountedNode = vnode; // work around flow
+              const mountedNode = vnode; // work around flow
               componentVNodeHooks.prepatch(mountedNode, mountedNode);
           }
           else {
-              var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
               child.$mount(hydrating ? vnode.elm : undefined, hydrating);
           }
       },
-      prepatch: function prepatch(oldVnode, vnode) {
-          var options = vnode.componentOptions;
-          var child = (vnode.componentInstance = oldVnode.componentInstance);
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
           updateChildComponent(child, options.propsData, // updated props
           options.listeners, // updated listeners
           vnode, // new parent vnode
           options.children // new children
           );
       },
-      insert: function insert(vnode) {
-          var context = vnode.context;
-          var componentInstance = vnode.componentInstance;
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
           if (!componentInstance._isMounted) {
               componentInstance._isMounted = true;
               callHook$1(componentInstance, 'mounted');
@@ -2750,8 +2764,8 @@
               }
           }
       },
-      destroy: function destroy(vnode) {
-          var componentInstance = vnode.componentInstance;
+      destroy(vnode) {
+          const { componentInstance } = vnode;
           if (!componentInstance._isDestroyed) {
               if (!vnode.data.keepAlive) {
                   componentInstance.$destroy();
@@ -2762,12 +2776,12 @@
           }
       },
   };
-  var hooksToMerge = Object.keys(componentVNodeHooks);
+  const hooksToMerge = Object.keys(componentVNodeHooks);
   function createComponent(Ctor, data, context, children, tag) {
       if (isUndef(Ctor)) {
           return;
       }
-      var baseCtor = context.$options._base;
+      const baseCtor = context.$options._base;
       // plain options object: turn it into a constructor
       if (isObject(Ctor)) {
           Ctor = baseCtor.extend(Ctor);
@@ -2776,12 +2790,12 @@
       // reject.
       if (typeof Ctor !== 'function') {
           {
-              warn(("Invalid Component definition: " + (String(Ctor))), context);
+              warn(`Invalid Component definition: ${String(Ctor)}`, context);
           }
           return;
       }
       // async component
-      var asyncFactory;
+      let asyncFactory;
       // @ts-expect-error
       if (isUndef(Ctor.cid)) {
           asyncFactory = Ctor;
@@ -2804,7 +2818,7 @@
       }
       // extract props
       // @ts-expect-error
-      var propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
       // functional component
       // @ts-expect-error
       if (isTrue(Ctor.options.functional)) {
@@ -2812,7 +2826,7 @@
       }
       // extract listeners, since these needs to be treated as
       // child component listeners instead of DOM listeners
-      var listeners = data.on;
+      const listeners = data.on;
       // replace with listeners with .native modifier
       // so it gets processed during parent component patch.
       data.on = data.nativeOn;
@@ -2821,7 +2835,7 @@
           // abstract components do not keep anything
           // other than props & listeners & slot
           // work around flow
-          var slot = data.slot;
+          const slot = data.slot;
           data = {};
           if (slot) {
               data.slot = slot;
@@ -2831,12 +2845,12 @@
       installComponentHooks(data);
       // return a placeholder vnode
       // @ts-expect-error
-      var name = Ctor.options.name || tag;
-      var vnode = new VNode(
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
       // @ts-expect-error
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')), data, undefined, undefined, undefined, context, 
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
       // @ts-expect-error
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
       return vnode;
   }
   function createComponentInstanceForVnode(
@@ -2844,13 +2858,13 @@
   vnode, 
   // activeInstance in lifecycle state
   parent) {
-      var options = {
+      const options = {
           _isComponent: true,
           _parentVnode: vnode,
-          parent: parent,
+          parent,
       };
       // check inline-template render functions
-      var inlineTemplate = vnode.data.inlineTemplate;
+      const inlineTemplate = vnode.data.inlineTemplate;
       if (isDef(inlineTemplate)) {
           options.render = inlineTemplate.render;
           options.staticRenderFns = inlineTemplate.staticRenderFns;
@@ -2858,11 +2872,11 @@
       return new vnode.componentOptions.Ctor(options);
   }
   function installComponentHooks(data) {
-      var hooks = data.hook || (data.hook = {});
-      for (var i = 0; i < hooksToMerge.length; i++) {
-          var key = hooksToMerge[i];
-          var existing = hooks[key];
-          var toMerge = componentVNodeHooks[key];
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
           // @ts-expect-error
           if (existing !== toMerge && !(existing && existing._merged)) {
               hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
@@ -2870,7 +2884,7 @@
       }
   }
   function mergeHook(f1, f2) {
-      var merged = function (a, b) {
+      const merged = (a, b) => {
           // flow complains about extra args which is why we use any
           f1(a, b);
           f2(a, b);
@@ -2881,12 +2895,12 @@
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
   function transformModel(options, data) {
-      var prop = (options.model && options.model.prop) || 'value';
-      var event = (options.model && options.model.event) || 'input';
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
       (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      var on = data.on || (data.on = {});
-      var existing = on[event];
-      var callback = data.model.callback;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
       if (isDef(existing)) {
           if (Array.isArray(existing)
               ? existing.indexOf(callback) === -1
@@ -2899,8 +2913,8 @@
       }
   }
 
-  var SIMPLE_NORMALIZE = 1;
-  var ALWAYS_NORMALIZE = 2;
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
   function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
@@ -2916,7 +2930,7 @@
   }
   function _createElement(context, tag, data, children, normalizationType) {
       if (isDef(data) && isDef(data.__ob__)) {
-          warn("Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" + 'Always create fresh vnode data objects in each render!', context);
+          warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
           return createEmptyVNode();
       }
       // object syntax in v-bind
@@ -2949,16 +2963,16 @@
       else if (normalizationType === SIMPLE_NORMALIZE) {
           children = simpleNormalizeChildren(children);
       }
-      var vnode, ns;
+      let vnode, ns;
       if (typeof tag === 'string') {
-          var Ctor;
+          let Ctor;
           ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
           if (config.isReservedTag(tag)) {
               // platform built-in elements
               if (isDef(data) &&
                   isDef(data.nativeOn) &&
                   data.tag !== 'component') {
-                  warn(("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."), context);
+                  warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
               }
               vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
           }
@@ -2983,9 +2997,9 @@
       }
       else if (isDef(vnode)) {
           if (isDef(ns))
-              { applyNS(vnode, ns); }
+              applyNS(vnode, ns);
           if (isDef(data))
-              { registerDeepBindings(data); }
+              registerDeepBindings(data);
           return vnode;
       }
       else {
@@ -3000,8 +3014,8 @@
           force = true;
       }
       if (isDef(vnode.children)) {
-          for (var i = 0, l = vnode.children.length; i < l; i++) {
-              var child = vnode.children[i];
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
               if (isDef(child.tag) &&
                   (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
                   applyNS(child, ns, force);
@@ -3024,9 +3038,9 @@
   function initRender(vm) {
       vm._vnode = null; // the root of the child tree
       vm._staticTrees = null; // v-once cached trees
-      var options = vm.$options;
-      var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      var renderContext = parentVnode && parentVnode.context;
+      const options = vm.$options;
+      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      const renderContext = parentVnode && parentVnode.context;
       vm.$slots = resolveSlots(options._renderChildren, renderContext);
       vm.$scopedSlots = emptyObject;
       // bind the createElement fn to this instance
@@ -3034,25 +3048,25 @@
       // args order: tag, data, children, normalizationType, alwaysNormalize
       // internal version is used by render functions compiled from templates
       // @ts-expect-error
-      vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
+      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
       // normalization is always applied for the public version, used in
       // user-written render functions.
       // @ts-expect-error
-      vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
+      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
       // $attrs & $listeners are exposed for easier HOC creation.
       // they need to be reactive so that HOCs using them are always updated
-      var parentData = parentVnode && parentVnode.data;
+      const parentData = parentVnode && parentVnode.data;
       /* istanbul ignore else */
       {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-              !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+              !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
           }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-              !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+              !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
           }, true);
       }
   }
-  var currentRenderingInstance = null;
+  let currentRenderingInstance = null;
   function renderMixin(Vue) {
       // install runtime convenience helpers
       installRenderHelpers(Vue.prototype);
@@ -3060,10 +3074,8 @@
           return nextTick(fn, this);
       };
       Vue.prototype._render = function () {
-          var vm = this;
-          var ref = vm.$options;
-          var render = ref.render;
-          var _parentVnode = ref._parentVnode;
+          const vm = this;
+          const { render, _parentVnode } = vm.$options;
           if (_parentVnode) {
               vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
           }
@@ -3071,7 +3083,7 @@
           // to the data on the placeholder node.
           vm.$vnode = _parentVnode;
           // render self
-          var vnode;
+          let vnode;
           try {
               // There's no need to maintain a stack because all render fns are called
               // separately from one another. Nested component's render fns are called
@@ -3080,7 +3092,7 @@
               vnode = render.call(vm._renderProxy, vm.$createElement);
           }
           catch (e) {
-              handleError(e, vm, "render");
+              handleError(e, vm, `render`);
               // return error render result,
               // or previous vnode to prevent render error causing blank component
               /* istanbul ignore else */
@@ -3088,8 +3100,8 @@
                   try {
                       vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
                   }
-                  catch (e$1) {
-                      handleError(e$1, vm, "renderError");
+                  catch (e) {
+                      handleError(e, vm, `renderError`);
                       vnode = vm._vnode;
                   }
               }
@@ -3125,9 +3137,9 @@
       return isObject(comp) ? base.extend(comp) : comp;
   }
   function createAsyncPlaceholder(factory, data, context, children, tag) {
-      var node = createEmptyVNode();
+      const node = createEmptyVNode();
       node.asyncFactory = factory;
-      node.asyncMeta = { data: data, context: context, children: children, tag: tag };
+      node.asyncMeta = { data, context, children, tag };
       return node;
   }
   function resolveAsyncComponent(factory, baseCtor) {
@@ -3137,7 +3149,7 @@
       if (isDef(factory.resolved)) {
           return factory.resolved;
       }
-      var owner = currentRenderingInstance;
+      const owner = currentRenderingInstance;
       if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
           // already pending
           factory.owners.push(owner);
@@ -3146,13 +3158,13 @@
           return factory.loadingComp;
       }
       if (owner && !isDef(factory.owners)) {
-          var owners = (factory.owners = [owner]);
-          var sync = true;
-          var timerLoading = null;
-          var timerTimeout = null;
-          owner.$on('hook:destroyed', function () { return remove$2(owners, owner); });
-          var forceRender = function (renderCompleted) {
-              for (var i = 0, l = owners.length; i < l; i++) {
+          const owners = (factory.owners = [owner]);
+          let sync = true;
+          let timerLoading = null;
+          let timerTimeout = null;
+          owner.$on('hook:destroyed', () => remove$2(owners, owner));
+          const forceRender = (renderCompleted) => {
+              for (let i = 0, l = owners.length; i < l; i++) {
                   owners[i].$forceUpdate();
               }
               if (renderCompleted) {
@@ -3167,7 +3179,7 @@
                   }
               }
           };
-          var resolve = once(function (res) {
+          const resolve = once((res) => {
               // cache resolved
               factory.resolved = ensureCtor(res, baseCtor);
               // invoke callbacks only if this is not a synchronous resolve
@@ -3179,15 +3191,15 @@
                   owners.length = 0;
               }
           });
-          var reject = once(function (reason) {
-              warn("Failed to resolve async component: " + (String(factory)) +
-                      (reason ? ("\nReason: " + reason) : ''));
+          const reject = once((reason) => {
+              warn(`Failed to resolve async component: ${String(factory)}` +
+                      (reason ? `\nReason: ${reason}` : ''));
               if (isDef(factory.errorComp)) {
                   factory.error = true;
                   forceRender(true);
               }
           });
-          var res = factory(resolve, reject);
+          const res = factory(resolve, reject);
           if (isObject(res)) {
               if (isPromise(res)) {
                   // () => Promise
@@ -3207,7 +3219,7 @@
                       }
                       else {
                           // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(function () {
+                          timerLoading = setTimeout(() => {
                               timerLoading = null;
                               if (isUndef(factory.resolved) && isUndef(factory.error)) {
                                   factory.loading = true;
@@ -3218,10 +3230,10 @@
                   }
                   if (isDef(res.timeout)) {
                       // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(function () {
+                      timerTimeout = setTimeout(() => {
                           timerTimeout = null;
                           if (isUndef(factory.resolved)) {
-                              reject(("timeout (" + (res.timeout) + "ms)")
+                              reject(`timeout (${res.timeout}ms)`
                                   );
                           }
                       }, res.timeout);
@@ -3234,15 +3246,10 @@
       }
   }
 
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
   function getFirstComponentChild(children) {
       if (Array.isArray(children)) {
-          for (var i = 0; i < children.length; i++) {
-              var c = children[i];
+          for (let i = 0; i < children.length; i++) {
+              const c = children[i];
               if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                   return c;
               }
@@ -3254,12 +3261,12 @@
       vm._events = Object.create(null);
       vm._hasHookEvent = false;
       // init parent attached events
-      var listeners = vm.$options._parentListeners;
+      const listeners = vm.$options._parentListeners;
       if (listeners) {
           updateComponentListeners(vm, listeners);
       }
   }
-  var target$1;
+  let target$1;
   function add$1(event, fn) {
       target$1.$on(event, fn);
   }
@@ -3267,9 +3274,9 @@
       target$1.$off(event, fn);
   }
   function createOnceHandler$1(event, fn) {
-      var _target = target$1;
+      const _target = target$1;
       return function onceHandler() {
-          var res = fn.apply(null, arguments);
+          const res = fn.apply(null, arguments);
           if (res !== null) {
               _target.$off(event, onceHandler);
           }
@@ -3281,11 +3288,11 @@
       target$1 = undefined;
   }
   function eventsMixin(Vue) {
-      var hookRE = /^hook:/;
+      const hookRE = /^hook:/;
       Vue.prototype.$on = function (event, fn) {
-          var vm = this;
+          const vm = this;
           if (Array.isArray(event)) {
-              for (var i = 0, l = event.length; i < l; i++) {
+              for (let i = 0, l = event.length; i < l; i++) {
                   vm.$on(event[i], fn);
               }
           }
@@ -3300,7 +3307,7 @@
           return vm;
       };
       Vue.prototype.$once = function (event, fn) {
-          var vm = this;
+          const vm = this;
           function on() {
               vm.$off(event, on);
               fn.apply(vm, arguments);
@@ -3310,7 +3317,7 @@
           return vm;
       };
       Vue.prototype.$off = function (event, fn) {
-          var vm = this;
+          const vm = this;
           // all
           if (!arguments.length) {
               vm._events = Object.create(null);
@@ -3318,13 +3325,13 @@
           }
           // array of events
           if (Array.isArray(event)) {
-              for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
-                  vm.$off(event[i$1], fn);
+              for (let i = 0, l = event.length; i < l; i++) {
+                  vm.$off(event[i], fn);
               }
               return vm;
           }
           // specific event
-          var cbs = vm._events[event];
+          const cbs = vm._events[event];
           if (!cbs) {
               return vm;
           }
@@ -3333,8 +3340,8 @@
               return vm;
           }
           // specific handler
-          var cb;
-          var i = cbs.length;
+          let cb;
+          let i = cbs.length;
           while (i--) {
               cb = cbs[i];
               if (cb === fn || cb.fn === fn) {
@@ -3345,23 +3352,23 @@
           return vm;
       };
       Vue.prototype.$emit = function (event) {
-          var vm = this;
+          const vm = this;
           {
-              var lowerCaseEvent = event.toLowerCase();
+              const lowerCaseEvent = event.toLowerCase();
               if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                      (formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
-                      "Note that HTML attributes are case-insensitive and you cannot use " +
-                      "v-on to listen to camelCase events when using in-DOM templates. " +
-                      "You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\".");
+                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                      `Note that HTML attributes are case-insensitive and you cannot use ` +
+                      `v-on to listen to camelCase events when using in-DOM templates. ` +
+                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
               }
           }
-          var cbs = vm._events[event];
+          let cbs = vm._events[event];
           if (cbs) {
               cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              var args = toArray(arguments, 1);
-              var info = "event handler for \"" + event + "\"";
-              for (var i = 0, l = cbs.length; i < l; i++) {
+              const args = toArray(arguments, 1);
+              const info = `event handler for "${event}"`;
+              for (let i = 0, l = cbs.length; i < l; i++) {
                   invokeWithErrorHandling(cbs[i], vm, args, vm, info);
               }
           }
@@ -3369,19 +3376,19 @@
       };
   }
 
-  var activeInstance = null;
-  var isUpdatingChildComponent = false;
+  let activeInstance = null;
+  let isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
-      var prevActiveInstance = activeInstance;
+      const prevActiveInstance = activeInstance;
       activeInstance = vm;
-      return function () {
+      return () => {
           activeInstance = prevActiveInstance;
       };
   }
   function initLifecycle(vm) {
-      var options = vm.$options;
+      const options = vm.$options;
       // locate first non-abstract parent
-      var parent = options.parent;
+      let parent = options.parent;
       if (parent && !options.abstract) {
           while (parent.$options.abstract && parent.$parent) {
               parent = parent.$parent;
@@ -3392,7 +3399,6 @@
       vm.$root = parent ? parent.$root : vm;
       vm.$children = [];
       vm.$refs = {};
-      // @ts-ignore
       vm._watcher = null;
       vm._inactive = null;
       vm._directInactive = false;
@@ -3402,10 +3408,10 @@
   }
   function lifecycleMixin(Vue) {
       Vue.prototype._update = function (vnode, hydrating) {
-          var vm = this;
-          var prevEl = vm.$el;
-          var prevVnode = vm._vnode;
-          var restoreActiveInstance = setActiveInstance(vm);
+          const vm = this;
+          const prevEl = vm.$el;
+          const prevVnode = vm._vnode;
+          const restoreActiveInstance = setActiveInstance(vm);
           vm._vnode = vnode;
           // Vue.prototype.__patch__ is injected in entry points
           // based on the rendering backend used.
@@ -3433,21 +3439,20 @@
           // updated in a parent's updated hook.
       };
       Vue.prototype.$forceUpdate = function () {
-          var vm = this;
+          const vm = this;
           if (vm._watcher) {
               vm._watcher.update();
           }
       };
       Vue.prototype.$destroy = function () {
-          var vm = this;
+          const vm = this;
           if (vm._isBeingDestroyed) {
               return;
           }
-          callHook$1(vm, 'beforeDestroy');
+          callHook$1(vm, "beforeDestroy");
           vm._isBeingDestroyed = true;
           // remove self from parent
-          var parent = vm.$parent;
-          // @ts-ignore
+          const parent = vm.$parent;
           if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
               remove$2(parent.$children, vm);
           }
@@ -3455,7 +3460,7 @@
           if (vm._watcher) {
               vm._watcher.teardown();
           }
-          var i = vm._watchers.length;
+          let i = vm._watchers.length;
           while (i--) {
               vm._watchers[i].teardown();
           }
@@ -3469,7 +3474,7 @@
           // invoke destroy hooks on current rendered tree
           vm.__patch__(vm._vnode, null);
           // fire destroyed hook
-          callHook$1(vm, 'destroyed');
+          callHook$1(vm, "destroyed");
           // turn off all instance listeners.
           vm.$off();
           // remove __vue__ reference
@@ -3478,7 +3483,6 @@
           }
           // release circular reference (#6759)
           if (vm.$vnode) {
-              // @ts-expect-error null is not undefined
               vm.$vnode.parent = null;
           }
       };
@@ -3490,39 +3494,39 @@
           vm.$options.render = createEmptyVNode;
           {
               /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
                   vm.$options.el ||
                   el) {
-                  warn('You are using the runtime-only build of Vue where the template ' +
-                      'compiler is not available. Either pre-compile the templates into ' +
-                      'render functions, or use the compiler-included build.', vm);
+                  warn("You are using the runtime-only build of Vue where the template " +
+                      "compiler is not available. Either pre-compile the templates into " +
+                      "render functions, or use the compiler-included build.", vm);
               }
               else {
-                  warn('Failed to mount component: template or render function not defined.', vm);
+                  warn("Failed to mount component: template or render function not defined.", vm);
               }
           }
       }
-      callHook$1(vm, 'beforeMount');
-      var updateComponent;
+      callHook$1(vm, "beforeMount");
+      let updateComponent;
       /* istanbul ignore if */
       if (config.performance && mark) {
-          updateComponent = function () {
-              var name = vm._name;
-              var id = vm._uid;
-              var startTag = "vue-perf-start:" + id;
-              var endTag = "vue-perf-end:" + id;
+          updateComponent = () => {
+              const name = vm._name;
+              const id = vm._uid;
+              const startTag = `vue-perf-start:${id}`;
+              const endTag = `vue-perf-end:${id}`;
               mark(startTag);
-              var vnode = vm._render();
+              const vnode = vm._render();
               mark(endTag);
-              measure(("vue " + name + " render"), startTag, endTag);
+              measure(`vue ${name} render`, startTag, endTag);
               mark(startTag);
               vm._update(vnode, hydrating);
               mark(endTag);
-              measure(("vue " + name + " patch"), startTag, endTag);
+              measure(`vue ${name} patch`, startTag, endTag);
           };
       }
       else {
-          updateComponent = function () {
+          updateComponent = () => {
               vm._update(vm._render(), hydrating);
           };
       }
@@ -3530,9 +3534,9 @@
       // since the watcher's initial patch may call $forceUpdate (e.g. inside child
       // component's mounted hook), which relies on vm._watcher being already defined
       new Watcher(vm, updateComponent, noop, {
-          before: function before() {
+          before() {
               if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, 'beforeUpdate');
+                  callHook$1(vm, "beforeUpdate");
               }
           },
       }, true /* isRenderWatcher */);
@@ -3541,7 +3545,7 @@
       // mounted is called for render-created child components in its inserted hook
       if (vm.$vnode == null) {
           vm._isMounted = true;
-          callHook$1(vm, 'mounted');
+          callHook$1(vm, "mounted");
       }
       return vm;
   }
@@ -3554,24 +3558,22 @@
       // check if there are dynamic scopedSlots (hand-written or compiled but with
       // dynamic slot names). Static scoped slots compiled from template has the
       // "$stable" marker.
-      var newScopedSlots = parentVnode.data.scopedSlots;
-      var oldScopedSlots = vm.$scopedSlots;
-      var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
           (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
       // Any static slot children from the parent may have changed during parent's
       // update. Dynamic scoped slots may also have changed. In such cases, a forced
       // update is necessary to ensure correctness.
-      var needsForceUpdate = !!(renderChildren || // has new static slots
+      const needsForceUpdate = !!(renderChildren || // has new static slots
           vm.$options._renderChildren || // has old static slots
           hasDynamicScopedSlot);
-      // @ts-ignore
       vm.$options._parentVnode = parentVnode;
-      // @ts-ignore
       vm.$vnode = parentVnode; // update vm's placeholder node without re-render
       if (vm._vnode) {
           // update child tree's parent
-          // @ts-ignore
           vm._vnode.parent = parentVnode;
       }
       vm.$options._renderChildren = renderChildren;
@@ -3579,16 +3581,15 @@
       // these are also reactive so they may trigger child update if the child
       // used them during render
       vm.$attrs = parentVnode.data.attrs || emptyObject;
-      // @ts-ignore
       vm.$listeners = listeners || emptyObject;
       // update props
       if (propsData && vm.$options.props) {
           toggleObserving(false);
-          var props = vm._props;
-          var propKeys = vm.$options._propKeys || [];
-          for (var i = 0; i < propKeys.length; i++) {
-              var key = propKeys[i];
-              var propOptions = vm.$options.props; // wtf flow?
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
               props[key] = validateProp(key, propOptions, propsData, vm);
           }
           toggleObserving(true);
@@ -3597,7 +3598,7 @@
       }
       // update listeners
       listeners = listeners || emptyObject;
-      var oldListeners = vm.$options._parentListeners;
+      const oldListeners = vm.$options._parentListeners;
       vm.$options._parentListeners = listeners;
       updateComponentListeners(vm, listeners, oldListeners);
       // resolve slots + force update if has children
@@ -3612,7 +3613,7 @@
   function isInInactiveTree(vm) {
       while (vm && (vm = vm.$parent)) {
           if (vm._inactive)
-              { return true; }
+              return true;
       }
       return false;
   }
@@ -3628,10 +3629,10 @@
       }
       if (vm._inactive || vm._inactive === null) {
           vm._inactive = false;
-          for (var i = 0; i < vm.$children.length; i++) {
+          for (let i = 0; i < vm.$children.length; i++) {
               activateChildComponent(vm.$children[i]);
           }
-          callHook$1(vm, 'activated');
+          callHook$1(vm, "activated");
       }
   }
   function deactivateChildComponent(vm, direct) {
@@ -3643,36 +3644,36 @@
       }
       if (!vm._inactive) {
           vm._inactive = true;
-          for (var i = 0; i < vm.$children.length; i++) {
+          for (let i = 0; i < vm.$children.length; i++) {
               deactivateChildComponent(vm.$children[i]);
           }
-          callHook$1(vm, 'deactivated');
+          callHook$1(vm, "deactivated");
       }
   }
   function callHook$1(vm, hook) {
       // #7573 disable dep collection when invoking lifecycle hooks
       pushTarget();
-      var handlers = vm.$options[hook];
-      var info = hook + " hook";
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
       if (handlers) {
-          for (var i = 0, j = handlers.length; i < j; i++) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
               invokeWithErrorHandling(handlers[i], vm, null, vm, info);
           }
       }
       if (vm._hasHookEvent) {
-          vm.$emit('hook:' + hook);
+          vm.$emit("hook:" + hook);
       }
       popTarget();
   }
 
-  var MAX_UPDATE_COUNT = 100;
-  var queue = [];
-  var activatedChildren = [];
-  var has = {};
-  var circular = {};
-  var waiting = false;
-  var flushing = false;
-  var index = 0;
+  const MAX_UPDATE_COUNT = 100;
+  const queue = [];
+  const activatedChildren = [];
+  let has = {};
+  let circular = {};
+  let waiting = false;
+  let flushing = false;
+  let index = 0;
   /**
    * Reset the scheduler's state.
    */
@@ -3689,9 +3690,9 @@
   // if the page has thousands of event listeners. Instead, we take a timestamp
   // every time the scheduler flushes and use that for all event listeners
   // attached during that flush.
-  var currentFlushTimestamp = 0;
+  let currentFlushTimestamp = 0;
   // Async edge case fix requires storing an event listener's attach timestamp.
-  var getNow = Date.now;
+  let getNow = Date.now;
   // Determine what event timestamp the browser is using. Annoyingly, the
   // timestamp can either be hi-res (relative to page load) or low-res
   // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -3699,7 +3700,7 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-      var performance = window.performance;
+      const performance = window.performance;
       if (performance &&
           typeof performance.now === 'function' &&
           getNow() > document.createEvent('Event').timeStamp) {
@@ -3707,7 +3708,7 @@
           // smaller than it, it means the event is using a hi-res timestamp,
           // and we need to use the hi-res version for event listener timestamps as
           // well.
-          getNow = function () { return performance.now(); };
+          getNow = () => performance.now();
       }
   }
   /**
@@ -3716,7 +3717,7 @@
   function flushSchedulerQueue() {
       currentFlushTimestamp = getNow();
       flushing = true;
-      var watcher, id;
+      let watcher, id;
       // Sort queue before flush.
       // This ensures that:
       // 1. Components are updated from parent to child. (because parent is always
@@ -3725,7 +3726,7 @@
       //    user watchers are created before the render watcher)
       // 3. If a component is destroyed during a parent component's watcher run,
       //    its watchers can be skipped.
-      queue.sort(function (a, b) { return a.id - b.id; });
+      queue.sort((a, b) => a.id - b.id);
       // do not cache length because more watchers might be pushed
       // as we run existing watchers
       for (index = 0; index < queue.length; index++) {
@@ -3742,15 +3743,15 @@
               if (circular[id] > MAX_UPDATE_COUNT) {
                   warn('You may have an infinite update loop ' +
                       (watcher.user
-                          ? ("in watcher with expression \"" + (watcher.expression) + "\"")
-                          : "in a component render function."), watcher.vm);
+                          ? `in watcher with expression "${watcher.expression}"`
+                          : `in a component render function.`), watcher.vm);
                   break;
               }
           }
       }
       // keep copies of post queues before resetting state
-      var activatedQueue = activatedChildren.slice();
-      var updatedQueue = queue.slice();
+      const activatedQueue = activatedChildren.slice();
+      const updatedQueue = queue.slice();
       resetSchedulerState();
       // call component updated and activated hooks
       callActivatedHooks(activatedQueue);
@@ -3762,10 +3763,10 @@
       }
   }
   function callUpdatedHooks(queue) {
-      var i = queue.length;
+      let i = queue.length;
       while (i--) {
-          var watcher = queue[i];
-          var vm = watcher.vm;
+          const watcher = queue[i];
+          const vm = watcher.vm;
           if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
               callHook$1(vm, 'updated');
           }
@@ -3782,7 +3783,7 @@
       activatedChildren.push(vm);
   }
   function callActivatedHooks(queue) {
-      for (var i = 0; i < queue.length; i++) {
+      for (let i = 0; i < queue.length; i++) {
           queue[i]._inactive = true;
           activateChildComponent(queue[i], true /* true */);
       }
@@ -3793,7 +3794,7 @@
    * pushed when the queue is being flushed.
    */
   function queueWatcher(watcher) {
-      var id = watcher.id;
+      const id = watcher.id;
       if (has[id] == null) {
           has[id] = true;
           if (!flushing) {
@@ -3802,7 +3803,7 @@
           else {
               // if already flushing, splice the watcher based on its id
               // if already past its id, it will be run next immediately.
-              var i = queue.length - 1;
+              let i = queue.length - 1;
               while (i > index && queue[i].id > watcher.id) {
                   i--;
               }
@@ -3820,199 +3821,217 @@
       }
   }
 
-  var uid$1 = 0;
+  let uid$1 = 0;
   /**
    * A watcher parses an expression, collects dependencies,
    * and fires callback when the expression value changes.
    * This is used for both the $watch() api and directives.
    */
-  var Watcher = function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-      this.vm = vm;
-      if (isRenderWatcher) {
-          vm._watcher = this;
-      }
-      vm._watchers.push(this);
-      // options
-      if (options) {
-          this.deep = !!options.deep;
-          this.user = !!options.user;
-          this.lazy = !!options.lazy;
-          this.sync = !!options.sync;
-          this.before = options.before;
-      }
-      else {
-          this.deep = this.user = this.lazy = this.sync = false;
-      }
-      this.cb = cb;
-      this.id = ++uid$1; // uid for batching
-      this.active = true;
-      this.dirty = this.lazy; // for lazy watchers
-      this.deps = [];
-      this.newDeps = [];
-      this.depIds = new _Set();
-      this.newDepIds = new _Set();
-      this.expression =
-          expOrFn.toString() ;
-      // parse expression for getter
-      if (typeof expOrFn === 'function') {
-          this.getter = expOrFn;
-      }
-      else {
-          this.getter = parsePath(expOrFn);
-          if (!this.getter) {
-              this.getter = noop;
-              warn("Failed watching path: \"" + expOrFn + "\" " +
+  class Watcher {
+      vm;
+      expression;
+      cb;
+      id;
+      deep;
+      user;
+      lazy;
+      sync;
+      dirty;
+      active;
+      deps;
+      newDeps;
+      depIds;
+      newDepIds;
+      before;
+      getter;
+      value;
+      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+          this.vm = vm;
+          if (isRenderWatcher) {
+              vm._watcher = this;
+          }
+          vm._watchers.push(this);
+          // options
+          if (options) {
+              this.deep = !!options.deep;
+              this.user = !!options.user;
+              this.lazy = !!options.lazy;
+              this.sync = !!options.sync;
+              this.before = options.before;
+          }
+          else {
+              this.deep = this.user = this.lazy = this.sync = false;
+          }
+          this.cb = cb;
+          this.id = ++uid$1; // uid for batching
+          this.active = true;
+          this.dirty = this.lazy; // for lazy watchers
+          this.deps = [];
+          this.newDeps = [];
+          this.depIds = new _Set();
+          this.newDepIds = new _Set();
+          this.expression = expOrFn.toString()
+              ;
+          // parse expression for getter
+          if (typeof expOrFn === 'function') {
+              this.getter = expOrFn;
+          }
+          else {
+              this.getter = parsePath(expOrFn);
+              if (!this.getter) {
+                  this.getter = noop;
+                  warn(`Failed watching path: "${expOrFn}" ` +
                       'Watcher only accepts simple dot-delimited paths. ' +
                       'For full control, use a function instead.', vm);
+              }
           }
+          this.value = this.lazy
+              ? undefined
+              : this.get();
       }
-      this.value = this.lazy ? undefined : this.get();
-  };
-  /**
-   * Evaluate the getter, and re-collect dependencies.
-   */
-  Watcher.prototype.get = function get () {
-      pushTarget(this);
-      var value;
-      var vm = this.vm;
-      try {
-          value = this.getter.call(vm, vm);
-      }
-      catch (e) {
-          if (this.user) {
-              handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
+      /**
+       * Evaluate the getter, and re-collect dependencies.
+       */
+      get() {
+          pushTarget(this);
+          let value;
+          const vm = this.vm;
+          try {
+              value = this.getter.call(vm, vm);
           }
-          else {
-              throw e;
+          catch (e) {
+              if (this.user) {
+                  // @ts-expect-error e is unknown, should we cast or any?
+                  handleError(e, vm, `getter for watcher "${this.expression}"`);
+              }
+              else {
+                  throw e;
+              }
           }
-      }
-      finally {
-          // "touch" every property so they are all tracked as
-          // dependencies for deep watching
-          if (this.deep) {
-              traverse(value);
+          finally {
+              // "touch" every property so they are all tracked as
+              // dependencies for deep watching
+              if (this.deep) {
+                  traverse(value);
+              }
+              popTarget();
+              this.cleanupDeps();
           }
-          popTarget();
-          this.cleanupDeps();
+          return value;
       }
-      return value;
-  };
-  /**
-   * Add a dependency to this directive.
-   */
-  Watcher.prototype.addDep = function addDep (dep) {
-      var id = dep.id;
-      if (!this.newDepIds.has(id)) {
-          this.newDepIds.add(id);
-          this.newDeps.push(dep);
-          if (!this.depIds.has(id)) {
-              dep.addSub(this);
+      /**
+       * Add a dependency to this directive.
+       */
+      addDep(dep) {
+          const id = dep.id;
+          if (!this.newDepIds.has(id)) {
+              this.newDepIds.add(id);
+              this.newDeps.push(dep);
+              if (!this.depIds.has(id)) {
+                  dep.addSub(this);
+              }
           }
       }
-  };
-  /**
-   * Clean up for dependency collection.
-   */
-  Watcher.prototype.cleanupDeps = function cleanupDeps () {
-      var i = this.deps.length;
-      while (i--) {
-          var dep = this.deps[i];
-          if (!this.newDepIds.has(dep.id)) {
-              dep.removeSub(this);
-          }
-      }
-      var tmp = this.depIds;
-      this.depIds = this.newDepIds;
-      this.newDepIds = tmp;
-      this.newDepIds.clear();
-      tmp = this.deps;
-      this.deps = this.newDeps;
-      this.newDeps = tmp;
-      this.newDeps.length = 0;
-  };
-  /**
-   * Subscriber interface.
-   * Will be called when a dependency changes.
-   */
-  Watcher.prototype.update = function update () {
-      /* istanbul ignore else */
-      if (this.lazy) {
-          this.dirty = true;
-      }
-      else if (this.sync) {
-          this.run();
+      /**
+       * Clean up for dependency collection.
+       */
+      cleanupDeps() {
+          let i = this.deps.length;
+          while (i--) {
+              const dep = this.deps[i];
+              if (!this.newDepIds.has(dep.id)) {
+                  dep.removeSub(this);
+              }
+          }
+          let tmp = this.depIds;
+          this.depIds = this.newDepIds;
+          this.newDepIds = tmp;
+          this.newDepIds.clear();
+          tmp = this.deps;
+          this.deps = this.newDeps;
+          this.newDeps = tmp;
+          this.newDeps.length = 0;
       }
-      else {
-          queueWatcher(this);
+      /**
+       * Subscriber interface.
+       * Will be called when a dependency changes.
+       */
+      update() {
+          /* istanbul ignore else */
+          if (this.lazy) {
+              this.dirty = true;
+          }
+          else if (this.sync) {
+              this.run();
+          }
+          else {
+              queueWatcher(this);
+          }
       }
-  };
-  /**
-   * Scheduler job interface.
-   * Will be called by the scheduler.
-   */
-  Watcher.prototype.run = function run () {
-      if (this.active) {
-          var value = this.get();
-          if (value !== this.value ||
-              // Deep watchers and watchers on Object/Arrays should fire even
-              // when the value is the same, because the value may
-              // have mutated.
-              isObject(value) ||
-              this.deep) {
-              // set new value
-              var oldValue = this.value;
-              this.value = value;
-              if (this.user) {
-                  try {
-                      this.cb.call(this.vm, value, oldValue);
+      /**
+       * Scheduler job interface.
+       * Will be called by the scheduler.
+       */
+      run() {
+          if (this.active) {
+              const value = this.get();
+              if (value !== this.value ||
+                  // Deep watchers and watchers on Object/Arrays should fire even
+                  // when the value is the same, because the value may
+                  // have mutated.
+                  isObject(value) ||
+                  this.deep) {
+                  // set new value
+                  const oldValue = this.value;
+                  this.value = value;
+                  if (this.user) {
+                      const info = `callback for watcher "${this.expression}"`;
+                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
                   }
-                  catch (e) {
-                      handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+                  else {
+                      this.cb.call(this.vm, value, oldValue);
                   }
               }
-              else {
-                  this.cb.call(this.vm, value, oldValue);
-              }
           }
       }
-  };
-  /**
-   * Evaluate the value of the watcher.
-   * This only gets called for lazy watchers.
-   */
-  Watcher.prototype.evaluate = function evaluate () {
-      this.value = this.get();
-      this.dirty = false;
-  };
-  /**
-   * Depend on all deps collected by this watcher.
-   */
-  Watcher.prototype.depend = function depend () {
-      var i = this.deps.length;
-      while (i--) {
-          this.deps[i].depend();
+      /**
+       * Evaluate the value of the watcher.
+       * This only gets called for lazy watchers.
+       */
+      evaluate() {
+          this.value = this.get();
+          this.dirty = false;
       }
-  };
-  /**
-   * Remove self from all dependencies' subscriber list.
-   */
-  Watcher.prototype.teardown = function teardown () {
-      if (this.active) {
-          // remove self from vm's watcher list
-          // this is a somewhat expensive operation so we skip it
-          // if the vm is being destroyed.
-          if (!this.vm._isBeingDestroyed) {
-              remove$2(this.vm._watchers, this);
-          }
-          var i = this.deps.length;
+      /**
+       * Depend on all deps collected by this watcher.
+       */
+      depend() {
+          let i = this.deps.length;
           while (i--) {
-              this.deps[i].removeSub(this);
+              this.deps[i].depend();
           }
-          this.active = false;
       }
-  };
+      /**
+       * Remove self from all dependencies' subscriber list.
+       */
+      teardown() {
+          if (this.active) {
+              // remove self from vm's watcher list
+              // this is a somewhat expensive operation so we skip it
+              // if the vm is being destroyed.
+              if (!this.vm._isBeingDestroyed) {
+                  remove$2(this.vm._watchers, this);
+              }
+              let i = this.deps.length;
+              while (i--) {
+                  this.deps[i].removeSub(this);
+              }
+              this.active = false;
+          }
+      }
+  }
 
-  var sharedPropertyDefinition = {
+  const sharedPropertyDefinition = {
       enumerable: true,
       configurable: true,
       get: noop,
@@ -4029,11 +4048,11 @@
   }
   function initState(vm) {
       vm._watchers = [];
-      var opts = vm.$options;
+      const opts = vm.$options;
       if (opts.props)
-          { initProps$1(vm, opts.props); }
+          initProps$1(vm, opts.props);
       if (opts.methods)
-          { initMethods(vm, opts.methods); }
+          initMethods(vm, opts.methods);
       if (opts.data) {
           initData(vm);
       }
@@ -4041,38 +4060,38 @@
           observe((vm._data = {}), true /* asRootData */);
       }
       if (opts.computed)
-          { initComputed$1(vm, opts.computed); }
+          initComputed$1(vm, opts.computed);
       if (opts.watch && opts.watch !== nativeWatch) {
           initWatch(vm, opts.watch);
       }
   }
   function initProps$1(vm, propsOptions) {
-      var propsData = vm.$options.propsData || {};
-      var props = (vm._props = {});
+      const propsData = vm.$options.propsData || {};
+      const props = (vm._props = {});
       // cache prop keys so that future props updates can iterate using Array
       // instead of dynamic object key enumeration.
-      var keys = (vm.$options._propKeys = []);
-      var isRoot = !vm.$parent;
+      const keys = (vm.$options._propKeys = []);
+      const isRoot = !vm.$parent;
       // root instance props should be converted
       if (!isRoot) {
           toggleObserving(false);
       }
-      var loop = function ( key ) {
+      for (const key in propsOptions) {
           keys.push(key);
-          var value = validateProp(key, propsOptions, propsData, vm);
+          const value = validateProp(key, propsOptions, propsData, vm);
           /* istanbul ignore else */
           {
-              var hyphenatedKey = hyphenate(key);
+              const hyphenatedKey = hyphenate(key);
               if (isReservedAttribute(hyphenatedKey) ||
                   config.isReservedAttr(hyphenatedKey)) {
-                  warn(("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop."), vm);
+                  warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
               }
-              defineReactive(props, key, value, function () {
+              defineReactive(props, key, value, () => {
                   if (!isRoot && !isUpdatingChildComponent) {
-                      warn("Avoid mutating a prop directly since the value will be " +
-                          "overwritten whenever the parent component re-renders. " +
-                          "Instead, use a data or computed property based on the prop's " +
-                          "value. Prop being mutated: \"" + key + "\"", vm);
+                      warn(`Avoid mutating a prop directly since the value will be ` +
+                          `overwritten whenever the parent component re-renders. ` +
+                          `Instead, use a data or computed property based on the prop's ` +
+                          `value. Prop being mutated: "${key}"`, vm);
                   }
               });
           }
@@ -4080,39 +4099,37 @@
           // during Vue.extend(). We only need to proxy props defined at
           // instantiation here.
           if (!(key in vm)) {
-              proxy(vm, "_props", key);
+              proxy(vm, `_props`, key);
           }
-      };
-
-      for (var key in propsOptions) loop( key );
+      }
       toggleObserving(true);
   }
   function initData(vm) {
-      var data = vm.$options.data;
-      data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
+      let data = vm.$options.data;
+      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
       if (!isPlainObject(data)) {
           data = {};
-          warn('data functions should return an object:\n' +
-                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+          warn("data functions should return an object:\n" +
+                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
       }
       // proxy data on instance
-      var keys = Object.keys(data);
-      var props = vm.$options.props;
-      var methods = vm.$options.methods;
-      var i = keys.length;
+      const keys = Object.keys(data);
+      const props = vm.$options.props;
+      const methods = vm.$options.methods;
+      let i = keys.length;
       while (i--) {
-          var key = keys[i];
+          const key = keys[i];
           {
               if (methods && hasOwn(methods, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a data property."), vm);
+                  warn(`Method "${key}" has already been defined as a data property.`, vm);
               }
           }
           if (props && hasOwn(props, key)) {
-              warn("The data property \"" + key + "\" is already declared as a prop. " +
-                      "Use prop default value instead.", vm);
+              warn(`The data property "${key}" is already declared as a prop. ` +
+                      `Use prop default value instead.`, vm);
           }
           else if (!isReserved(key)) {
-              proxy(vm, "_data", key);
+              proxy(vm, `_data`, key);
           }
       }
       // observe data
@@ -4125,24 +4142,24 @@
           return data.call(vm, vm);
       }
       catch (e) {
-          handleError(e, vm, "data()");
+          handleError(e, vm, `data()`);
           return {};
       }
       finally {
           popTarget();
       }
   }
-  var computedWatcherOptions = { lazy: true };
+  const computedWatcherOptions = { lazy: true };
   function initComputed$1(vm, computed) {
       // $flow-disable-line
-      var watchers = (vm._computedWatchers = Object.create(null));
+      const watchers = (vm._computedWatchers = Object.create(null));
       // computed properties are just getters during SSR
-      var isSSR = isServerRendering();
-      for (var key in computed) {
-          var userDef = computed[key];
-          var getter = typeof userDef === 'function' ? userDef : userDef.get;
+      const isSSR = isServerRendering();
+      for (const key in computed) {
+          const userDef = computed[key];
+          const getter = typeof userDef === "function" ? userDef : userDef.get;
           if (getter == null) {
-              warn(("Getter is missing for computed property \"" + key + "\"."), vm);
+              warn(`Getter is missing for computed property "${key}".`, vm);
           }
           if (!isSSR) {
               // create internal watcher for the computed property.
@@ -4156,17 +4173,20 @@
           }
           else {
               if (key in vm.$data) {
-                  warn(("The computed property \"" + key + "\" is already defined in data."), vm);
+                  warn(`The computed property "${key}" is already defined in data.`, vm);
               }
               else if (vm.$options.props && key in vm.$options.props) {
-                  warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
+                  warn(`The computed property "${key}" is already defined as a prop.`, vm);
+              }
+              else if (vm.$options.methods && key in vm.$options.methods) {
+                  warn(`The computed property "${key}" is already defined as a method.`, vm);
               }
           }
       }
   }
   function defineComputed(target, key, userDef) {
-      var shouldCache = !isServerRendering();
-      if (typeof userDef === 'function') {
+      const shouldCache = !isServerRendering();
+      if (typeof userDef === "function") {
           sharedPropertyDefinition.get = shouldCache
               ? createComputedGetter(key)
               : createGetterInvoker(userDef);
@@ -4182,14 +4202,14 @@
       }
       if (sharedPropertyDefinition.set === noop) {
           sharedPropertyDefinition.set = function () {
-              warn(("Computed property \"" + key + "\" was assigned to but it has no setter."), this);
+              warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
           };
       }
       Object.defineProperty(target, key, sharedPropertyDefinition);
   }
   function createComputedGetter(key) {
       return function computedGetter() {
-          var watcher = this._computedWatchers && this._computedWatchers[key];
+          const watcher = this._computedWatchers && this._computedWatchers[key];
           if (watcher) {
               if (watcher.dirty) {
                   watcher.evaluate();
@@ -4207,29 +4227,30 @@
       };
   }
   function initMethods(vm, methods) {
-      var props = vm.$options.props;
-      for (var key in methods) {
+      const props = vm.$options.props;
+      for (const key in methods) {
           {
-              if (typeof methods[key] !== 'function') {
-                  warn("Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-                      "Did you reference the function correctly?", vm);
+              if (typeof methods[key] !== "function") {
+                  warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                      `Did you reference the function correctly?`, vm);
               }
               if (props && hasOwn(props, key)) {
-                  warn(("Method \"" + key + "\" has already been defined as a prop."), vm);
+                  warn(`Method "${key}" has already been defined as a prop.`, vm);
               }
               if (key in vm && isReserved(key)) {
-                  warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                      "Avoid defining component methods that start with _ or $.");
+                  warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                      `Avoid defining component methods that start with _ or $.`);
               }
           }
-          vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
+          vm[key] =
+              typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
       }
   }
   function initWatch(vm, watch) {
-      for (var key in watch) {
-          var handler = watch[key];
+      for (const key in watch) {
+          const handler = watch[key];
           if (Array.isArray(handler)) {
-              for (var i = 0; i < handler.length; i++) {
+              for (let i = 0; i < handler.length; i++) {
                   createWatcher(vm, key, handler[i]);
               }
           }
@@ -4243,7 +4264,7 @@
           options = handler;
           handler = handler.handler;
       }
-      if (typeof handler === 'string') {
+      if (typeof handler === "string") {
           handler = vm[handler];
       }
       return vm.$watch(expOrFn, handler, options);
@@ -4252,43 +4273,39 @@
       // flow somehow has problems with directly declared definition object
       // when using Object.defineProperty, so we have to procedurally build up
       // the object here.
-      var dataDef = {};
+      const dataDef = {};
       dataDef.get = function () {
           return this._data;
       };
-      var propsDef = {};
+      const propsDef = {};
       propsDef.get = function () {
           return this._props;
       };
       {
           dataDef.set = function () {
-              warn('Avoid replacing instance root $data. ' +
-                  'Use nested data properties instead.', this);
+              warn("Avoid replacing instance root $data. " +
+                  "Use nested data properties instead.", this);
           };
           propsDef.set = function () {
-              warn("$props is readonly.", this);
+              warn(`$props is readonly.`, this);
           };
       }
-      Object.defineProperty(Vue.prototype, '$data', dataDef);
-      Object.defineProperty(Vue.prototype, '$props', propsDef);
+      Object.defineProperty(Vue.prototype, "$data", dataDef);
+      Object.defineProperty(Vue.prototype, "$props", propsDef);
       Vue.prototype.$set = set;
       Vue.prototype.$delete = del;
       Vue.prototype.$watch = function (expOrFn, cb, options) {
-          var vm = this;
+          const vm = this;
           if (isPlainObject(cb)) {
               return createWatcher(vm, expOrFn, cb, options);
           }
           options = options || {};
           options.user = true;
-          var watcher = new Watcher(vm, expOrFn, cb, options);
+          const watcher = new Watcher(vm, expOrFn, cb, options);
           if (options.immediate) {
+              const info = `callback for immediate watcher "${watcher.expression}"`;
               pushTarget();
-              try {
-                  cb.call(vm, watcher.value);
-              }
-              catch (error) {
-                  handleError(error, vm, ("callback for immediate watcher \"" + (watcher.expression) + "\""));
-              }
+              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
               popTarget();
           }
           return function unwatchFn() {
@@ -4297,17 +4314,17 @@
       };
   }
 
-  var uid = 0;
+  let uid = 0;
   function initMixin$1(Vue) {
       Vue.prototype._init = function (options) {
-          var vm = this;
+          const vm = this;
           // a uid
           vm._uid = uid++;
-          var startTag, endTag;
+          let startTag, endTag;
           /* istanbul ignore if */
           if (config.performance && mark) {
-              startTag = "vue-perf-start:" + (vm._uid);
-              endTag = "vue-perf-end:" + (vm._uid);
+              startTag = `vue-perf-start:${vm._uid}`;
+              endTag = `vue-perf-end:${vm._uid}`;
               mark(startTag);
           }
           // a flag to avoid this being observed
@@ -4340,7 +4357,7 @@
           if (config.performance && mark) {
               vm._name = formatComponentName(vm, false);
               mark(endTag);
-              measure(("vue " + (vm._name) + " init"), startTag, endTag);
+              measure(`vue ${vm._name} init`, startTag, endTag);
           }
           if (vm.$options.el) {
               vm.$mount(vm.$options.el);
@@ -4348,13 +4365,12 @@
       };
   }
   function initInternalComponent(vm, options) {
-      // @ts-ignore
-      var opts = (vm.$options = Object.create(vm.constructor.options));
+      const opts = (vm.$options = Object.create(vm.constructor.options));
       // doing this because it's faster than dynamic enumeration.
-      var parentVnode = options._parentVnode;
+      const parentVnode = options._parentVnode;
       opts.parent = options.parent;
       opts._parentVnode = parentVnode;
-      var vnodeComponentOptions = parentVnode.componentOptions;
+      const vnodeComponentOptions = parentVnode.componentOptions;
       opts.propsData = vnodeComponentOptions.propsData;
       opts._parentListeners = vnodeComponentOptions.listeners;
       opts._renderChildren = vnodeComponentOptions.children;
@@ -4365,16 +4381,16 @@
       }
   }
   function resolveConstructorOptions(Ctor) {
-      var options = Ctor.options;
+      let options = Ctor.options;
       if (Ctor.super) {
-          var superOptions = resolveConstructorOptions(Ctor.super);
-          var cachedSuperOptions = Ctor.superOptions;
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
           if (superOptions !== cachedSuperOptions) {
               // super option changed,
               // need to resolve new options.
               Ctor.superOptions = superOptions;
               // check if there are any late-modified/attached options (#4976)
-              var modifiedOptions = resolveModifiedOptions(Ctor);
+              const modifiedOptions = resolveModifiedOptions(Ctor);
               // update base extend options
               if (modifiedOptions) {
                   extend(Ctor.extendOptions, modifiedOptions);
@@ -4388,13 +4404,13 @@
       return options;
   }
   function resolveModifiedOptions(Ctor) {
-      var modified;
-      var latest = Ctor.options;
-      var sealed = Ctor.sealedOptions;
-      for (var key in latest) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
           if (latest[key] !== sealed[key]) {
               if (!modified)
-                  { modified = {}; }
+                  modified = {};
               modified[key] = latest[key];
           }
       }
@@ -4403,29 +4419,29 @@
 
   function Vue(options) {
       if (!(this instanceof Vue)) {
-          warn('Vue is a constructor and should be called with the `new` keyword');
+          warn("Vue is a constructor and should be called with the `new` keyword");
       }
       this._init(options);
   }
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   initMixin$1(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   stateMixin(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   eventsMixin(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   lifecycleMixin(Vue);
-  //@ts-ignore
+  //@ts-expect-error Vue has function type
   renderMixin(Vue);
 
   function initUse(Vue) {
       Vue.use = function (plugin) {
-          var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
           if (installedPlugins.indexOf(plugin) > -1) {
               return this;
           }
           // additional parameters
-          var args = toArray(arguments, 1);
+          const args = toArray(arguments, 1);
           args.unshift(this);
           if (typeof plugin.install === 'function') {
               plugin.install.apply(plugin, args);
@@ -4452,23 +4468,23 @@
        * constructors" for prototypal inheritance and cache them.
        */
       Vue.cid = 0;
-      var cid = 1;
+      let cid = 1;
       /**
        * Class inheritance
        */
       Vue.extend = function (extendOptions) {
           extendOptions = extendOptions || {};
-          var Super = this;
-          var SuperId = Super.cid;
-          var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          const Super = this;
+          const SuperId = Super.cid;
+          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
           if (cachedCtors[SuperId]) {
               return cachedCtors[SuperId];
           }
-          var name = extendOptions.name || Super.options.name;
+          const name = extendOptions.name || Super.options.name;
           if (name) {
               validateComponentName(name);
           }
-          var Sub = function VueComponent(options) {
+          const Sub = function VueComponent(options) {
               this._init(options);
           };
           Sub.prototype = Object.create(Super.prototype);
@@ -4510,14 +4526,14 @@
       };
   }
   function initProps(Comp) {
-      var props = Comp.options.props;
-      for (var key in props) {
-          proxy(Comp.prototype, "_props", key);
+      const props = Comp.options.props;
+      for (const key in props) {
+          proxy(Comp.prototype, `_props`, key);
       }
   }
   function initComputed(Comp) {
-      var computed = Comp.options.computed;
-      for (var key in computed) {
+      const computed = Comp.options.computed;
+      for (const key in computed) {
           defineComputed(Comp.prototype, key, computed[key]);
       }
   }
@@ -4526,7 +4542,7 @@
       /**
        * Create asset registration methods.
        */
-      ASSET_TYPES.forEach(function (type) {
+      ASSET_TYPES.forEach((type) => {
           // @ts-expect-error function is not exact same type
           Vue[type] = function (id, definition) {
               if (!definition) {
@@ -4552,6 +4568,7 @@
       });
   }
 
+  /* @flow */
   function getComponentName(opts) {
       return opts && (opts.Ctor.options.name || opts.tag);
   }
@@ -4559,8 +4576,8 @@
       if (Array.isArray(pattern)) {
           return pattern.indexOf(name) > -1;
       }
-      else if (typeof pattern === 'string') {
-          return pattern.split(',').indexOf(name) > -1;
+      else if (typeof pattern === "string") {
+          return pattern.split(",").indexOf(name) > -1;
       }
       else if (isRegExp(pattern)) {
           return pattern.test(name);
@@ -4569,13 +4586,11 @@
       return false;
   }
   function pruneCache(keepAliveInstance, filter) {
-      var cache = keepAliveInstance.cache;
-      var keys = keepAliveInstance.keys;
-      var _vnode = keepAliveInstance._vnode;
-      for (var key in cache) {
-          var cachedNode = cache[key];
-          if (cachedNode) {
-              var name = getComponentName(cachedNode.componentOptions);
+      const { cache, keys, _vnode } = keepAliveInstance;
+      for (const key in cache) {
+          const entry = cache[key];
+          if (entry) {
+              const name = entry.name;
               if (name && !filter(name)) {
                   pruneCacheEntry(cache, key, keys, _vnode);
               }
@@ -4583,53 +4598,72 @@
       }
   }
   function pruneCacheEntry(cache, key, keys, current) {
-      var cached = cache[key];
-      if (cached && (!current || cached.tag !== current.tag)) {
-          //@ts-expect-error has void type
-          cached.componentInstance.$destroy();
+      const entry = cache[key];
+      if (entry && (!current || entry.tag !== current.tag)) {
+          // @ts-expect-error can be undefined
+          entry.componentInstance.$destroy();
       }
       cache[key] = null;
       remove$2(keys, key);
   }
-  var patternTypes = [String, RegExp, Array];
-  // TODO use defineComponent
+  const patternTypes = [String, RegExp, Array];
+  // TODO defineComponent
   var KeepAlive = {
-      name: 'keep-alive',
+      name: "keep-alive",
       abstract: true,
       props: {
           include: patternTypes,
           exclude: patternTypes,
           max: [String, Number],
       },
-      created: function created() {
+      methods: {
+          cacheVNode() {
+              const { cache, keys, vnodeToCache, keyToCache } = this;
+              if (vnodeToCache) {
+                  const { tag, componentInstance, componentOptions } = vnodeToCache;
+                  cache[keyToCache] = {
+                      name: getComponentName(componentOptions),
+                      tag,
+                      componentInstance,
+                  };
+                  keys.push(keyToCache);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+                  this.vnodeToCache = null;
+              }
+          },
+      },
+      created() {
           this.cache = Object.create(null);
           this.keys = [];
       },
-      destroyed: function destroyed() {
-          for (var key in this.cache) {
+      destroyed() {
+          for (const key in this.cache) {
               pruneCacheEntry(this.cache, key, this.keys);
           }
       },
-      mounted: function mounted() {
-          var this$1 = this;
-
-          this.$watch('include', function (val) {
-              pruneCache(this$1, function (name) { return matches(val, name); });
+      mounted() {
+          this.cacheVNode();
+          this.$watch("include", (val) => {
+              pruneCache(this, (name) => matches(val, name));
           });
-          this.$watch('exclude', function (val) {
-              pruneCache(this$1, function (name) { return !matches(val, name); });
+          this.$watch("exclude", (val) => {
+              pruneCache(this, (name) => !matches(val, name));
           });
       },
-      render: function render() {
-          var slot = this.$slots.default;
-          var vnode = getFirstComponentChild(slot);
-          var componentOptions = vnode && vnode.componentOptions;
+      updated() {
+          this.cacheVNode();
+      },
+      render() {
+          const slot = this.$slots.default;
+          const vnode = getFirstComponentChild(slot);
+          const componentOptions = vnode && vnode.componentOptions;
           if (componentOptions) {
               // check pattern
-              var name = getComponentName(componentOptions);
-              var ref = this;
-              var include = ref.include;
-              var exclude = ref.exclude;
+              const name = getComponentName(componentOptions);
+              const { include, exclude } = this;
               if (
               // not included
               (include && (!name || !matches(include, name))) ||
@@ -4637,14 +4671,12 @@
                   (exclude && name && matches(exclude, name))) {
                   return vnode;
               }
-              var ref$1 = this;
-              var cache = ref$1.cache;
-              var keys = ref$1.keys;
-              var key = vnode.key == null
+              const { cache, keys } = this;
+              const key = vnode.key == null
                   ? // same constructor may get registered as different local components
                       // so cid alone is not enough (#3269)
                       componentOptions.Ctor.cid +
-                          (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
+                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
                   : vnode.key;
               if (cache[key]) {
                   vnode.componentInstance = cache[key].componentInstance;
@@ -4653,13 +4685,11 @@
                   keys.push(key);
               }
               else {
-                  cache[key] = vnode;
-                  keys.push(key);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
+                  // delay setting the cache until update
+                  this.vnodeToCache = vnode;
+                  this.keyToCache = key;
               }
+              // @ts-expect-error can vnode.data can be undefined
               vnode.data.keepAlive = true;
           }
           return vnode || (slot && slot[0]);
@@ -4667,15 +4697,15 @@
   };
 
   var builtInComponents = {
-      KeepAlive: KeepAlive,
+      KeepAlive,
   };
 
   function initGlobalAPI(Vue) {
       // config
-      var configDef = {};
-      configDef.get = function () { return config; };
+      const configDef = {};
+      configDef.get = () => config;
       {
-          configDef.set = function () {
+          configDef.set = () => {
               warn('Do not replace the Vue.config object, set individual fields instead.');
           };
       }
@@ -4684,21 +4714,21 @@
       // NOTE: these are not considered part of the public API - avoid relying on
       // them unless you are aware of the risk.
       Vue.util = {
-          warn: warn,
-          extend: extend,
-          mergeOptions: mergeOptions,
-          defineReactive: defineReactive,
+          warn,
+          extend,
+          mergeOptions,
+          defineReactive,
       };
       Vue.set = set;
       Vue.delete = del;
       Vue.nextTick = nextTick;
       // 2.6 explicit observable API
-      Vue.observable = function (obj) {
+      Vue.observable = (obj) => {
           observe(obj);
           return obj;
       };
       Vue.options = Object.create(null);
-      ASSET_TYPES.forEach(function (type) {
+      ASSET_TYPES.forEach((type) => {
           Vue.options[type + 's'] = Object.create(null);
       });
       // this is used to identify the "base" constructor to extend all plain-object
@@ -4716,7 +4746,7 @@
       get: isServerRendering,
   });
   Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get: function get() {
+      get() {
           /* istanbul ignore next */
           return this.$vnode && this.$vnode.ssrContext;
       },
@@ -4725,22 +4755,22 @@
   Object.defineProperty(Vue, 'FunctionalRenderContext', {
       value: FunctionalRenderContext,
   });
-  Vue.version = '2.6.12';
+  Vue.version = '2.6.14';
 
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap('style,class');
+  const isReservedAttr = makeMap('style,class');
   // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress');
-  var mustUseProp = function (tag, type, attr) {
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
       return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
           (attr === 'selected' && tag === 'option') ||
           (attr === 'checked' && tag === 'input') ||
           (attr === 'muted' && tag === 'video'));
   };
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  var convertEnumeratedValue = function (key, value) {
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
       return isFalsyAttrValue(value) || value === 'false'
           ? 'false'
           : // allow arbitrary string value for contenteditable
@@ -4748,33 +4778,34 @@
                   ? value
                   : 'true';
   };
-  var isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
       'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
       'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
       'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
       'required,reversed,scoped,seamless,selected,sortable,' +
       'truespeed,typemustmatch,visible');
-  var xlinkNS = 'http://www.w3.org/1999/xlink';
-  var isXlink = function (name) {
+  const xlinkNS = 'http://www.w3.org/1999/xlink';
+  const isXlink = (name) => {
       return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
   };
-  var getXlinkProp = function (name) {
+  const getXlinkProp = (name) => {
       return isXlink(name) ? name.slice(6, name.length) : '';
   };
-  var isFalsyAttrValue = function (val) {
+  const isFalsyAttrValue = (val) => {
       return val == null || val === false;
   };
 
   function genClassForVnode(vnode) {
-      var data = vnode.data;
-      var parentNode = vnode;
-      var childNode = vnode;
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
       while (isDef(childNode.componentInstance)) {
           childNode = childNode.componentInstance._vnode;
           if (childNode && childNode.data) {
               data = mergeClassData(childNode.data, data);
           }
       }
+      // @ts-expect-error parentNode.parent not VNodeWithData
       while (isDef((parentNode = parentNode.parent))) {
           if (parentNode && parentNode.data) {
               data = mergeClassData(data, parentNode.data);
@@ -4812,34 +4843,34 @@
       return '';
   }
   function stringifyArray(value) {
-      var res = '';
-      var stringified;
-      for (var i = 0, l = value.length; i < l; i++) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
           if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
               if (res)
-                  { res += ' '; }
+                  res += ' ';
               res += stringified;
           }
       }
       return res;
   }
   function stringifyObject(value) {
-      var res = '';
-      for (var key in value) {
+      let res = '';
+      for (const key in value) {
           if (value[key]) {
               if (res)
-                  { res += ' '; }
+                  res += ' ';
               res += key;
           }
       }
       return res;
   }
 
-  var namespaceMap = {
+  const namespaceMap = {
       svg: 'http://www.w3.org/2000/svg',
       math: 'http://www.w3.org/1998/Math/MathML',
   };
-  var isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
       'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
       'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
       'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
@@ -4852,10 +4883,10 @@
       'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
       'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
       'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  var isReservedTag = function (tag) {
+  const isReservedTag = (tag) => {
       return isHTMLTag(tag) || isSVG(tag);
   };
   function getTagNamespace(tag) {
@@ -4868,7 +4899,7 @@
           return 'math';
       }
   }
-  var unknownElementCache = Object.create(null);
+  const unknownElementCache = Object.create(null);
   function isUnknownElement(tag) {
       /* istanbul ignore if */
       if (!inBrowser) {
@@ -4882,7 +4913,7 @@
       if (unknownElementCache[tag] != null) {
           return unknownElementCache[tag];
       }
-      var el = document.createElement(tag);
+      const el = document.createElement(tag);
       if (tag.indexOf('-') > -1) {
           // http://stackoverflow.com/a/28210364/1070244
           return (unknownElementCache[tag] =
@@ -4893,14 +4924,14 @@
           return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
       }
   }
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
+  const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
   /**
    * Query an element selector if it's not an element already.
    */
   function query(el) {
       if (typeof el === 'string') {
-          var selected = document.querySelector(el);
+          const selected = document.querySelector(el);
           if (!selected) {
               warn('Cannot find element: ' + el);
               return document.createElement('div');
@@ -4913,7 +4944,7 @@
   }
 
   function createElement(tagName, vnode) {
-      var elm = document.createElement(tagName);
+      const elm = document.createElement(tagName);
       if (tagName !== 'select') {
           return elm;
       }
@@ -4976,45 +5007,42 @@
   });
 
   var ref = {
-      create: function create(_, vnode) {
+      create(_, vnode) {
           registerRef(vnode);
       },
-      update: function update(oldVnode, vnode) {
+      update(oldVnode, vnode) {
           if (oldVnode.data.ref !== vnode.data.ref) {
               registerRef(oldVnode, true);
               registerRef(vnode);
           }
       },
-      destroy: function destroy(vnode) {
+      destroy(vnode) {
           registerRef(vnode, true);
       },
   };
   function registerRef(vnode, isRemoval) {
-      var key = vnode.data.ref;
+      const key = vnode.data.ref;
       if (!isDef(key))
-          { return; }
-      var vm = vnode.context;
-      var ref = vnode.componentInstance || vnode.elm;
-      var refs = vm.$refs;
+          return;
+      const vm = vnode.context;
+      const ref = vnode.componentInstance || vnode.elm;
+      const refs = vm.$refs;
+      const obj = refs[key];
       if (isRemoval) {
-          if (Array.isArray(refs[key])) {
-              // @ts-expect-error invalid typings
-              remove$2(refs[key], ref);
+          if (Array.isArray(obj)) {
+              remove$2(obj, ref);
           }
-          else if (refs[key] === ref) {
+          else if (obj === ref) {
               refs[key] = undefined;
           }
       }
       else {
-          // @ts-expect-error invalid typings
           if (vnode.data.refInFor) {
-              if (!Array.isArray(refs[key])) {
+              if (!Array.isArray(obj)) {
                   refs[key] = [ref];
-                  // @ts-expect-error invalid typings
               }
-              else if (refs[key].indexOf(ref) < 0) {
-                  // @ts-expect-error invalid typings
-                  refs[key].push(ref);
+              else if (obj.indexOf(ref) < 0) {
+                  obj.push(ref);
               }
           }
           else {
@@ -5034,41 +5062,38 @@
    * Not type-checking this because this file is perf-critical and the cost
    * of making flow understand it is not worth it.
    */
-  var emptyNode = new VNode('', {}, []);
-  var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+  const emptyNode = new VNode('', {}, []);
+  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
   function sameVnode(a, b) {
       return (a.key === b.key &&
-          ((a.tag === b.tag &&
-              a.isComment === b.isComment &&
-              isDef(a.data) === isDef(b.data) &&
-              sameInputType(a, b)) ||
-              (isTrue(a.isAsyncPlaceholder) &&
-                  a.asyncFactory === b.asyncFactory &&
-                  isUndef(b.asyncFactory.error))));
+          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+          a.isComment === b.isComment &&
+          isDef(a.data) === isDef(b.data) &&
+          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+          isUndef(b.asyncFactory.error))));
   }
   function sameInputType(a, b) {
       if (a.tag !== 'input')
-          { return true; }
-      var i;
-      var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+          return true;
+      let i;
+      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
       return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
   }
   function createKeyToOldIdx(children, beginIdx, endIdx) {
-      var i, key;
-      var map = {};
+      let i, key;
+      const map = {};
       for (i = beginIdx; i <= endIdx; ++i) {
           key = children[i].key;
           if (isDef(key))
-              { map[key] = i; }
+              map[key] = i;
       }
       return map;
   }
   function createPatchFunction(backend) {
-      var i, j;
-      var cbs = {};
-      var modules = backend.modules;
-      var nodeOps = backend.nodeOps;
+      let i, j;
+      const cbs = {};
+      const { modules, nodeOps } = backend;
       for (i = 0; i < hooks.length; ++i) {
           cbs[hooks[i]] = [];
           for (j = 0; j < modules.length; ++j) {
@@ -5090,7 +5115,7 @@
           return remove;
       }
       function removeNode(el) {
-          var parent = nodeOps.parentNode(el);
+          const parent = nodeOps.parentNode(el);
           // element may have already been removed due to v-html / v-text
           if (isDef(parent)) {
               nodeOps.removeChild(parent, el);
@@ -5100,14 +5125,14 @@
           return (!inVPre &&
               !vnode.ns &&
               !(config.ignoredElements.length &&
-                  config.ignoredElements.some(function (ignore) {
+                  config.ignoredElements.some((ignore) => {
                       return isRegExp(ignore)
                           ? ignore.test(vnode.tag)
                           : ignore === vnode.tag;
                   })) &&
               config.isUnknownElement(vnode.tag));
       }
-      var creatingElmInVPre = 0;
+      let creatingElmInVPre = 0;
       function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
           if (isDef(vnode.elm) && isDef(ownerArray)) {
               // This vnode was used in a previous render!
@@ -5121,9 +5146,9 @@
           if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
               return;
           }
-          var data = vnode.data;
-          var children = vnode.children;
-          var tag = vnode.tag;
+          const data = vnode.data;
+          const children = vnode.children;
+          const tag = vnode.tag;
           if (isDef(tag)) {
               {
                   if (data && data.pre) {
@@ -5163,9 +5188,9 @@
           }
       }
       function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          var i = vnode.data;
+          let i = vnode.data;
           if (isDef(i)) {
-              var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
               if (isDef((i = i.hook)) && isDef((i = i.init))) {
                   i(vnode, false /* hydrating */);
               }
@@ -5202,12 +5227,12 @@
           }
       }
       function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          var i;
+          let i;
           // hack for #4339: a reactivated component with inner transition
           // does not trigger because the inner node's created hooks are not called
           // again. It's not ideal to involve module-specific logic in here but
           // there doesn't seem to be a better way to do it.
-          var innerNode = vnode;
+          let innerNode = vnode;
           while (innerNode.componentInstance) {
               innerNode = innerNode.componentInstance._vnode;
               if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
@@ -5239,7 +5264,7 @@
               {
                   checkDuplicateKeys(children);
               }
-              for (var i = 0; i < children.length; ++i) {
+              for (let i = 0; i < children.length; ++i) {
                   createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
               }
           }
@@ -5254,27 +5279,27 @@
           return isDef(vnode.tag);
       }
       function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-              cbs.create[i$1](emptyNode, vnode);
+          for (let i = 0; i < cbs.create.length; ++i) {
+              cbs.create[i](emptyNode, vnode);
           }
           i = vnode.data.hook; // Reuse variable
           if (isDef(i)) {
               if (isDef(i.create))
-                  { i.create(emptyNode, vnode); }
+                  i.create(emptyNode, vnode);
               if (isDef(i.insert))
-                  { insertedVnodeQueue.push(vnode); }
+                  insertedVnodeQueue.push(vnode);
           }
       }
       // set scope id attribute for scoped CSS.
       // this is implemented as a special case to avoid the overhead
       // of going through the normal attribute patching process.
       function setScope(vnode) {
-          var i;
+          let i;
           if (isDef((i = vnode.fnScopeId))) {
               nodeOps.setStyleScope(vnode.elm, i);
           }
           else {
-              var ancestor = vnode;
+              let ancestor = vnode;
               while (ancestor) {
                   if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
                       nodeOps.setStyleScope(vnode.elm, i);
@@ -5296,13 +5321,13 @@
           }
       }
       function invokeDestroyHook(vnode) {
-          var i, j;
-          var data = vnode.data;
+          let i, j;
+          const data = vnode.data;
           if (isDef(data)) {
               if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  { i(vnode); }
+                  i(vnode);
               for (i = 0; i < cbs.destroy.length; ++i)
-                  { cbs.destroy[i](vnode); }
+                  cbs.destroy[i](vnode);
           }
           if (isDef((i = vnode.children))) {
               for (j = 0; j < vnode.children.length; ++j) {
@@ -5312,7 +5337,7 @@
       }
       function removeVnodes(vnodes, startIdx, endIdx) {
           for (; startIdx <= endIdx; ++startIdx) {
-              var ch = vnodes[startIdx];
+              const ch = vnodes[startIdx];
               if (isDef(ch)) {
                   if (isDef(ch.tag)) {
                       removeAndInvokeRemoveHook(ch);
@@ -5327,8 +5352,8 @@
       }
       function removeAndInvokeRemoveHook(vnode, rm) {
           if (isDef(rm) || isDef(vnode.data)) {
-              var i;
-              var listeners = cbs.remove.length + 1;
+              let i;
+              const listeners = cbs.remove.length + 1;
               if (isDef(rm)) {
                   // we have a recursively passed down rm callback
                   // increase the listeners count
@@ -5359,19 +5384,19 @@
           }
       }
       function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          var oldStartIdx = 0;
-          var newStartIdx = 0;
-          var oldEndIdx = oldCh.length - 1;
-          var oldStartVnode = oldCh[0];
-          var oldEndVnode = oldCh[oldEndIdx];
-          var newEndIdx = newCh.length - 1;
-          var newStartVnode = newCh[0];
-          var newEndVnode = newCh[newEndIdx];
-          var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          let oldStartIdx = 0;
+          let newStartIdx = 0;
+          let oldEndIdx = oldCh.length - 1;
+          let oldStartVnode = oldCh[0];
+          let oldEndVnode = oldCh[oldEndIdx];
+          let newEndIdx = newCh.length - 1;
+          let newStartVnode = newCh[0];
+          let newEndVnode = newCh[newEndIdx];
+          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
           // removeOnly is a special flag used only by <transition-group>
           // to ensure removed elements stay in correct relative positions
           // during leaving transitions
-          var canMove = !removeOnly;
+          const canMove = !removeOnly;
           {
               checkDuplicateKeys(newCh);
           }
@@ -5410,7 +5435,7 @@
               }
               else {
                   if (isUndef(oldKeyToIdx))
-                      { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
+                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
                   idxInOld = isDef(newStartVnode.key)
                       ? oldKeyToIdx[newStartVnode.key]
                       : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
@@ -5443,13 +5468,13 @@
           }
       }
       function checkDuplicateKeys(children) {
-          var seenKeys = {};
-          for (var i = 0; i < children.length; i++) {
-              var vnode = children[i];
-              var key = vnode.key;
+          const seenKeys = {};
+          for (let i = 0; i < children.length; i++) {
+              const vnode = children[i];
+              const key = vnode.key;
               if (isDef(key)) {
                   if (seenKeys[key]) {
-                      warn(("Duplicate keys detected: '" + key + "'. This may cause an update error."), vnode.context);
+                      warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
                   }
                   else {
                       seenKeys[key] = true;
@@ -5458,10 +5483,10 @@
           }
       }
       function findIdxInOld(node, oldCh, start, end) {
-          for (var i = start; i < end; i++) {
-              var c = oldCh[i];
+          for (let i = start; i < end; i++) {
+              const c = oldCh[i];
               if (isDef(c) && sameVnode(node, c))
-                  { return i; }
+                  return i;
           }
       }
       function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
@@ -5472,7 +5497,7 @@
               // clone reused vnode
               vnode = ownerArray[index] = cloneVNode(vnode);
           }
-          var elm = (vnode.elm = oldVnode.elm);
+          const elm = (vnode.elm = oldVnode.elm);
           if (isTrue(oldVnode.isAsyncPlaceholder)) {
               if (isDef(vnode.asyncFactory.resolved)) {
                   hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
@@ -5493,30 +5518,30 @@
               vnode.componentInstance = oldVnode.componentInstance;
               return;
           }
-          var i;
-          var data = vnode.data;
+          let i;
+          const data = vnode.data;
           if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
               i(oldVnode, vnode);
           }
-          var oldCh = oldVnode.children;
-          var ch = vnode.children;
+          const oldCh = oldVnode.children;
+          const ch = vnode.children;
           if (isDef(data) && isPatchable(vnode)) {
               for (i = 0; i < cbs.update.length; ++i)
-                  { cbs.update[i](oldVnode, vnode); }
+                  cbs.update[i](oldVnode, vnode);
               if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  { i(oldVnode, vnode); }
+                  i(oldVnode, vnode);
           }
           if (isUndef(vnode.text)) {
               if (isDef(oldCh) && isDef(ch)) {
                   if (oldCh !== ch)
-                      { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
+                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
               }
               else if (isDef(ch)) {
                   {
                       checkDuplicateKeys(ch);
                   }
                   if (isDef(oldVnode.text))
-                      { nodeOps.setTextContent(elm, ''); }
+                      nodeOps.setTextContent(elm, '');
                   addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
               }
               else if (isDef(oldCh)) {
@@ -5531,7 +5556,7 @@
           }
           if (isDef(data)) {
               if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  { i(oldVnode, vnode); }
+                  i(oldVnode, vnode);
           }
       }
       function invokeInsertHook(vnode, queue, initial) {
@@ -5541,23 +5566,21 @@
               vnode.parent.data.pendingInsert = queue;
           }
           else {
-              for (var i = 0; i < queue.length; ++i) {
+              for (let i = 0; i < queue.length; ++i) {
                   queue[i].data.hook.insert(queue[i]);
               }
           }
       }
-      var hydrationBailed = false;
+      let hydrationBailed = false;
       // list of modules that can skip create hook during hydration because they
       // are already rendered on the client or has no need for initialization
       // Note: style is excluded because it relies on initial clone for future
       // deep updates (#7063).
-      var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
       // Note: this is a browser-only function so we can assume elms are DOM nodes.
       function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          var i;
-          var tag = vnode.tag;
-          var data = vnode.data;
-          var children = vnode.children;
+          let i;
+          const { tag, data, children } = vnode;
           inVPre = inVPre || (data && data.pre);
           vnode.elm = elm;
           if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
@@ -5572,7 +5595,7 @@
           }
           if (isDef(data)) {
               if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  { i(vnode, true /* hydrating */); }
+                  i(vnode, true /* hydrating */);
               if (isDef((i = vnode.componentInstance))) {
                   // child component. it should have hydrated its own tree.
                   initComponent(vnode, insertedVnodeQueue);
@@ -5604,11 +5627,11 @@
                       }
                       else {
                           // iterate and compare children lists
-                          var childrenMatch = true;
-                          var childNode = elm.firstChild;
-                          for (var i$1 = 0; i$1 < children.length; i$1++) {
+                          let childrenMatch = true;
+                          let childNode = elm.firstChild;
+                          for (let i = 0; i < children.length; i++) {
                               if (!childNode ||
-                                  !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
+                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
                                   childrenMatch = false;
                                   break;
                               }
@@ -5630,8 +5653,8 @@
                   }
               }
               if (isDef(data)) {
-                  var fullInvoke = false;
-                  for (var key in data) {
+                  let fullInvoke = false;
+                  for (const key in data) {
                       if (!isRenderedModule(key)) {
                           fullInvoke = true;
                           invokeCreateHooks(vnode, insertedVnodeQueue);
@@ -5663,18 +5686,18 @@
       return function patch(oldVnode, vnode, hydrating, removeOnly) {
           if (isUndef(vnode)) {
               if (isDef(oldVnode))
-                  { invokeDestroyHook(oldVnode); }
+                  invokeDestroyHook(oldVnode);
               return;
           }
-          var isInitialPatch = false;
-          var insertedVnodeQueue = [];
+          let isInitialPatch = false;
+          const insertedVnodeQueue = [];
           if (isUndef(oldVnode)) {
               // empty mount (likely as component), create new root element
               isInitialPatch = true;
               createElm(vnode, insertedVnodeQueue);
           }
           else {
-              var isRealElement = isDef(oldVnode.nodeType);
+              const isRealElement = isDef(oldVnode.nodeType);
               if (!isRealElement && sameVnode(oldVnode, vnode)) {
                   // patch existing root node
                   patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
@@ -5706,8 +5729,8 @@
                       oldVnode = emptyNodeAt(oldVnode);
                   }
                   // replacing existing element
-                  var oldElm = oldVnode.elm;
-                  var parentElm = nodeOps.parentNode(oldElm);
+                  const oldElm = oldVnode.elm;
+                  const parentElm = nodeOps.parentNode(oldElm);
                   // create new node
                   createElm(vnode, insertedVnodeQueue, 
                   // extremely rare edge case: do not insert if old element is in a
@@ -5716,25 +5739,25 @@
                   oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
                   // update parent placeholder node element, recursively
                   if (isDef(vnode.parent)) {
-                      var ancestor = vnode.parent;
-                      var patchable = isPatchable(vnode);
+                      let ancestor = vnode.parent;
+                      const patchable = isPatchable(vnode);
                       while (ancestor) {
-                          for (var i = 0; i < cbs.destroy.length; ++i) {
+                          for (let i = 0; i < cbs.destroy.length; ++i) {
                               cbs.destroy[i](ancestor);
                           }
                           ancestor.elm = vnode.elm;
                           if (patchable) {
-                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
-                                  cbs.create[i$1](emptyNode, ancestor);
+                              for (let i = 0; i < cbs.create.length; ++i) {
+                                  cbs.create[i](emptyNode, ancestor);
                               }
                               // #6513
                               // invoke insert hooks that may have been merged by create hooks.
                               // e.g. for directives that uses the "inserted" hook.
-                              var insert = ancestor.data.hook.insert;
+                              const insert = ancestor.data.hook.insert;
                               if (insert.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
-                                      insert.fns[i$2]();
+                                  for (let i = 1; i < insert.fns.length; i++) {
+                                      insert.fns[i]();
                                   }
                               }
                           }
@@ -5772,13 +5795,13 @@
       }
   }
   function _update(oldVnode, vnode) {
-      var isCreate = oldVnode === emptyNode;
-      var isDestroy = vnode === emptyNode;
-      var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      var dirsWithInsert = [];
-      var dirsWithPostpatch = [];
-      var key, oldDir, dir;
+      const isCreate = oldVnode === emptyNode;
+      const isDestroy = vnode === emptyNode;
+      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+      const dirsWithInsert = [];
+      const dirsWithPostpatch = [];
+      let key, oldDir, dir;
       for (key in newDirs) {
           oldDir = oldDirs[key];
           dir = newDirs[key];
@@ -5800,8 +5823,8 @@
           }
       }
       if (dirsWithInsert.length) {
-          var callInsert = function () {
-              for (var i = 0; i < dirsWithInsert.length; i++) {
+          const callInsert = () => {
+              for (let i = 0; i < dirsWithInsert.length; i++) {
                   callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
               }
           };
@@ -5813,8 +5836,8 @@
           }
       }
       if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', function () {
-              for (var i = 0; i < dirsWithPostpatch.length; i++) {
+          mergeVNodeHook(vnode, 'postpatch', () => {
+              for (let i = 0; i < dirsWithPostpatch.length; i++) {
                   callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
               }
           });
@@ -5828,14 +5851,14 @@
           }
       }
   }
-  var emptyModifiers = Object.create(null);
+  const emptyModifiers = Object.create(null);
   function normalizeDirectives(dirs, vm) {
-      var res = Object.create(null);
+      const res = Object.create(null);
       if (!dirs) {
           // $flow-disable-line
           return res;
       }
-      var i, dir;
+      let i, dir;
       for (i = 0; i < dirs.length; i++) {
           dir = dirs[i];
           if (!dir.modifiers) {
@@ -5849,16 +5872,17 @@
       return res;
   }
   function getRawDirName(dir) {
-      return (dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.'))));
+      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
   }
   function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      var fn = dir.def && dir.def[hook];
+      const fn = dir.def && dir.def[hook];
       if (fn) {
           try {
               fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
           }
           catch (e) {
-              handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
+              // @ts-expect-error should it be any?
+              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
           }
       }
   }
@@ -5866,17 +5890,17 @@
   var baseModules = [ref, directives];
 
   function updateAttrs(oldVnode, vnode) {
-      var opts = vnode.componentOptions;
+      const opts = vnode.componentOptions;
       if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
           return;
       }
       if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
           return;
       }
-      var key, cur, old;
-      var elm = vnode.elm;
-      var oldAttrs = oldVnode.data.attrs || {};
-      var attrs = vnode.data.attrs || {};
+      let key, cur, old;
+      const elm = vnode.elm;
+      const oldAttrs = oldVnode.data.attrs || {};
+      let attrs = vnode.data.attrs || {};
       // clone observed objects, as the user probably wants to mutate it
       if (isDef(attrs.__ob__)) {
           attrs = vnode.data.attrs = extend({}, attrs);
@@ -5952,7 +5976,7 @@
               key === 'placeholder' &&
               value !== '' &&
               !el.__ieph) {
-              var blocker = function (e) {
+              const blocker = (e) => {
                   e.stopImmediatePropagation();
                   el.removeEventListener('input', blocker);
               };
@@ -5969,18 +5993,18 @@
   };
 
   function updateClass(oldVnode, vnode) {
-      var el = vnode.elm;
-      var data = vnode.data;
-      var oldData = oldVnode.data;
+      const el = vnode.elm;
+      const data = vnode.data;
+      const oldData = oldVnode.data;
       if (isUndef(data.staticClass) &&
           isUndef(data.class) &&
           (isUndef(oldData) ||
               (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
           return;
       }
-      var cls = genClassForVnode(vnode);
+      let cls = genClassForVnode(vnode);
       // handle transition classes
-      var transitionClass = el._transitionClasses;
+      const transitionClass = el._transitionClasses;
       if (isDef(transitionClass)) {
           cls = concat(cls, stringifyClass(transitionClass));
       }
@@ -5997,8 +6021,8 @@
 
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r';
-  var CHECKBOX_RADIO_TOKEN = '__c';
+  const RANGE_TOKEN = '__r';
+  const CHECKBOX_RADIO_TOKEN = '__c';
 
   // normalize v-model event tokens that can only be determined at runtime.
   // it's important to place the event as the first in the array because
@@ -6008,7 +6032,7 @@
       /* istanbul ignore if */
       if (isDef(on[RANGE_TOKEN])) {
           // IE input[type=range] only supports `change` event
-          var event = isIE ? 'change' : 'input';
+          const event = isIE ? 'change' : 'input';
           on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
           delete on[RANGE_TOKEN];
       }
@@ -6020,11 +6044,11 @@
           delete on[CHECKBOX_RADIO_TOKEN];
       }
   }
-  var target;
+  let target;
   function createOnceHandler(event, handler, capture) {
-      var _target = target; // save current target element in closure
+      const _target = target; // save current target element in closure
       return function onceHandler() {
-          var res = handler.apply(null, arguments);
+          const res = handler.apply(null, arguments);
           if (res !== null) {
               remove(event, onceHandler, capture, _target);
           }
@@ -6033,7 +6057,7 @@
   // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
   // implementation and does not fire microtasks in between event propagation, so
   // safe to exclude.
-  var useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
   function add(name, handler, capture, passive) {
       // async edge case #6566: inner click event triggers patch, event handler
       // attached to outer element during patch, and triggered again. This
@@ -6042,9 +6066,9 @@
       // and the handler would only fire if the event passed to it was fired
       // AFTER it was attached.
       if (useMicrotaskFix) {
-          var attachedTimestamp = currentFlushTimestamp;
-          var original = handler;
-          //@ts-expect-error
+          const attachedTimestamp = currentFlushTimestamp;
+          const original = handler;
+          //@ts-expect-error 
           handler = original._wrapper = function (e) {
               if (
               // no bubbling, should always fire.
@@ -6065,7 +6089,7 @@
               }
           };
       }
-      target.addEventListener(name, handler, supportsPassive ? { capture: capture, passive: passive } : capture);
+      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
   }
   function remove(name, handler, capture, _target) {
       (_target || target).removeEventListener(name, 
@@ -6076,9 +6100,11 @@
       if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
           return;
       }
-      var on = vnode.data.on || {};
-      var oldOn = oldVnode.data.on || {};
-      target = vnode.elm;
+      const on = vnode.data.on || {};
+      const oldOn = oldVnode.data.on || {};
+      // vnode is empty when removing all listeners,
+      // and use old vnode dom element
+      target = vnode.elm || oldVnode.elm;
       normalizeEvents(on);
       updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
       target = undefined;
@@ -6086,17 +6112,19 @@
   var events = {
       create: updateDOMListeners,
       update: updateDOMListeners,
+      // @ts-expect-error emptyNode has actually data
+      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
   };
 
-  var svgContainer;
+  let svgContainer;
   function updateDOMProps(oldVnode, vnode) {
       if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
           return;
       }
-      var key, cur;
-      var elm = vnode.elm;
-      var oldProps = oldVnode.data.domProps || {};
-      var props = vnode.data.domProps || {};
+      let key, cur;
+      const elm = vnode.elm;
+      const oldProps = oldVnode.data.domProps || {};
+      let props = vnode.data.domProps || {};
       // clone observed objects, as the user probably wants to mutate it
       if (isDef(props.__ob__)) {
           props = vnode.data.domProps = extend({}, props);
@@ -6113,9 +6141,9 @@
           // on subsequent patches (#3360)
           if (key === 'textContent' || key === 'innerHTML') {
               if (vnode.children)
-                  { vnode.children.length = 0; }
+                  vnode.children.length = 0;
               if (cur === oldProps[key])
-                  { continue; }
+                  continue;
               // #6601 work around Chrome version <= 55 bug where single textNode
               // replaced by innerHTML/textContent retains its parentNode property
               if (elm.childNodes.length === 1) {
@@ -6127,7 +6155,7 @@
               // non-string values will be stringified
               elm._value = cur;
               // avoid resetting cursor position when value is the same
-              var strCur = isUndef(cur) ? '' : String(cur);
+              const strCur = isUndef(cur) ? '' : String(cur);
               if (shouldUpdateValue(elm, strCur)) {
                   elm.value = strCur;
               }
@@ -6137,8 +6165,8 @@
               isUndef(elm.innerHTML)) {
               // IE doesn't support innerHTML for SVG elements
               svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = "<svg>" + cur + "</svg>";
-              var svg = svgContainer.firstChild;
+              svgContainer.innerHTML = `<svg>${cur}</svg>`;
+              const svg = svgContainer.firstChild;
               while (elm.firstChild) {
                   elm.removeChild(elm.firstChild);
               }
@@ -6172,7 +6200,7 @@
   function isNotInFocusAndDirty(elm, checkVal) {
       // return true when textbox (.number and .trim) loses focus and its value is
       // not equal to the updated value
-      var notInFocus = true;
+      let notInFocus = true;
       // #6157
       // work around IE bug when accessing document.activeElement in an iframe
       try {
@@ -6182,8 +6210,8 @@
       return notInFocus && elm.value !== checkVal;
   }
   function isDirtyWithModifiers(elm, newVal) {
-      var value = elm.value;
-      var modifiers = elm._vModifiers; // injected by v-model runtime
+      const value = elm.value;
+      const modifiers = elm._vModifiers; // injected by v-model runtime
       if (isDef(modifiers)) {
           if (modifiers.number) {
               return toNumber(value) !== toNumber(newVal);
@@ -6199,13 +6227,13 @@
       update: updateDOMProps,
   };
 
-  var parseStyleText = cached(function (cssText) {
-      var res = {};
-      var listDelimiter = /;(?![^(]*\))/g;
-      var propertyDelimiter = /:(.+)/;
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
       cssText.split(listDelimiter).forEach(function (item) {
           if (item) {
-              var tmp = item.split(propertyDelimiter);
+              const tmp = item.split(propertyDelimiter);
               tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
           }
       });
@@ -6213,7 +6241,7 @@
   });
   // merge static and dynamic style data on the same vnode
   function normalizeStyleData(data) {
-      var style = normalizeStyleBinding(data.style);
+      const style = normalizeStyleBinding(data.style);
       // static style is pre-processed into an object during compilation
       // and is always a fresh object, so it's safe to merge into it
       return data.staticStyle ? extend(data.staticStyle, style) : style;
@@ -6233,10 +6261,10 @@
    * so that parent component's style could override it
    */
   function getStyle(vnode, checkChild) {
-      var res = {};
-      var styleData;
+      const res = {};
+      let styleData;
       if (checkChild) {
-          var childNode = vnode;
+          let childNode = vnode;
           while (childNode.componentInstance) {
               childNode = childNode.componentInstance._vnode;
               if (childNode &&
@@ -6249,7 +6277,8 @@
       if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
       }
-      var parentNode = vnode;
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
       while ((parentNode = parentNode.parent)) {
           if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
               extend(res, styleData);
@@ -6258,9 +6287,9 @@
       return res;
   }
 
-  var cssVarRE = /^--/;
-  var importantRE = /\s*!important$/;
-  var setProp = function (el, name, val) {
+  const cssVarRE = /^--/;
+  const importantRE = /\s*!important$/;
+  const setProp = (el, name, val) => {
       /* istanbul ignore if */
       if (cssVarRE.test(name)) {
           el.style.setProperty(name, val);
@@ -6269,12 +6298,12 @@
           el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
       }
       else {
-          var normalizedName = normalize(name);
+          const normalizedName = normalize(name);
           if (Array.isArray(val)) {
               // Support values array created by autoprefixer, e.g.
               // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
               // Set them one by one, and the browser will only set those it can recognize
-              for (var i = 0, len = val.length; i < len; i++) {
+              for (let i = 0, len = val.length; i < len; i++) {
                   el.style[normalizedName] = val[i];
               }
           }
@@ -6283,43 +6312,43 @@
           }
       }
   };
-  var vendorNames = ['Webkit', 'Moz', 'ms'];
-  var emptyStyle;
-  var normalize = cached(function (prop) {
+  const vendorNames = ['Webkit', 'Moz', 'ms'];
+  let emptyStyle;
+  const normalize = cached(function (prop) {
       emptyStyle = emptyStyle || document.createElement('div').style;
       prop = camelize(prop);
       if (prop !== 'filter' && prop in emptyStyle) {
           return prop;
       }
-      var capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (var i = 0; i < vendorNames.length; i++) {
-          var name = vendorNames[i] + capName;
+      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (let i = 0; i < vendorNames.length; i++) {
+          const name = vendorNames[i] + capName;
           if (name in emptyStyle) {
               return name;
           }
       }
   });
   function updateStyle(oldVnode, vnode) {
-      var data = vnode.data;
-      var oldData = oldVnode.data;
+      const data = vnode.data;
+      const oldData = oldVnode.data;
       if (isUndef(data.staticStyle) &&
           isUndef(data.style) &&
           isUndef(oldData.staticStyle) &&
           isUndef(oldData.style)) {
           return;
       }
-      var cur, name;
-      var el = vnode.elm;
-      var oldStaticStyle = oldData.staticStyle;
-      var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      let cur, name;
+      const el = vnode.elm;
+      const oldStaticStyle = oldData.staticStyle;
+      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
       // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      var oldStyle = oldStaticStyle || oldStyleBinding;
-      var style = normalizeStyleBinding(vnode.data.style) || {};
+      const oldStyle = oldStaticStyle || oldStyleBinding;
+      const style = normalizeStyleBinding(vnode.data.style) || {};
       // store normalized style under a different key for next diff
       // make sure to clone it if it's reactive, since the user likely wants
       // to mutate it.
       vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      var newStyle = getStyle(vnode, true);
+      const newStyle = getStyle(vnode, true);
       for (name in oldStyle) {
           if (isUndef(newStyle[name])) {
               setProp(el, name, '');
@@ -6338,7 +6367,7 @@
       update: updateStyle,
   };
 
-  var whitespaceRE = /\s+/;
+  const whitespaceRE = /\s+/;
   /**
    * Add class with compatibility for SVG since classList is not supported on
    * SVG elements in IE
@@ -6351,14 +6380,14 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });
+              cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
           }
           else {
               el.classList.add(cls);
           }
       }
       else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
+          const cur = ` ${el.getAttribute('class') || ''} `;
           if (cur.indexOf(' ' + cls + ' ') < 0) {
               el.setAttribute('class', (cur + cls).trim());
           }
@@ -6376,7 +6405,7 @@
       /* istanbul ignore else */
       if (el.classList) {
           if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });
+              cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
           }
           else {
               el.classList.remove(cls);
@@ -6386,8 +6415,8 @@
           }
       }
       else {
-          var cur = " " + (el.getAttribute('class') || '') + " ";
-          var tar = ' ' + cls + ' ';
+          let cur = ` ${el.getAttribute('class') || ''} `;
+          const tar = ' ' + cls + ' ';
           while (cur.indexOf(tar) >= 0) {
               cur = cur.replace(tar, ' ');
           }
@@ -6407,7 +6436,7 @@
       }
       /* istanbul ignore else */
       if (typeof def === 'object') {
-          var res = {};
+          const res = {};
           if (def.css !== false) {
               extend(res, autoCssTransition(def.name || 'v'));
           }
@@ -6418,53 +6447,51 @@
           return autoCssTransition(def);
       }
   }
-  var autoCssTransition = cached(function (name) {
+  const autoCssTransition = cached((name) => {
       return {
-          enterClass: (name + "-enter"),
-          enterToClass: (name + "-enter-to"),
-          enterActiveClass: (name + "-enter-active"),
-          leaveClass: (name + "-leave"),
-          leaveToClass: (name + "-leave-to"),
-          leaveActiveClass: (name + "-leave-active"),
+          enterClass: `${name}-enter`,
+          enterToClass: `${name}-enter-to`,
+          enterActiveClass: `${name}-enter-active`,
+          leaveClass: `${name}-leave`,
+          leaveToClass: `${name}-leave-to`,
+          leaveActiveClass: `${name}-leave-active`,
       };
   });
-  var hasTransition = inBrowser && !isIE9;
-  var TRANSITION = 'transition';
-  var ANIMATION = 'animation';
+  const hasTransition = inBrowser && !isIE9;
+  const TRANSITION = 'transition';
+  const ANIMATION = 'animation';
   // Transition property/event sniffing
-  var transitionProp = 'transition';
-  var transitionEndEvent = 'transitionend';
-  var animationProp = 'animation';
-  var animationEndEvent = 'animationend';
+  let transitionProp = 'transition';
+  let transitionEndEvent = 'transitionend';
+  let animationProp = 'animation';
+  let animationEndEvent = 'animationend';
   if (hasTransition) {
       /* istanbul ignore if */
       if (window.ontransitionend === undefined &&
-          // @ts-expect-error
           window.onwebkittransitionend !== undefined) {
           transitionProp = 'WebkitTransition';
           transitionEndEvent = 'webkitTransitionEnd';
       }
       if (window.onanimationend === undefined &&
-          // @ts-expect-error
           window.onwebkitanimationend !== undefined) {
           animationProp = 'WebkitAnimation';
           animationEndEvent = 'webkitAnimationEnd';
       }
   }
   // binding to window is necessary to make hot reload work in IE in strict mode
-  var raf = inBrowser
+  const raf = inBrowser
       ? window.requestAnimationFrame
           ? window.requestAnimationFrame.bind(window)
           : setTimeout
-      : /* istanbul ignore next */ function (fn) { return fn(); };
+      : /* istanbul ignore next */ (fn) => fn();
   function nextFrame(fn) {
-      raf(function () {
+      raf(() => {
           // @ts-expect-error
           raf(fn);
       });
   }
   function addTransitionClass(el, cls) {
-      var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
       if (transitionClasses.indexOf(cls) < 0) {
           transitionClasses.push(cls);
           addClass(el, cls);
@@ -6477,45 +6504,42 @@
       removeClass(el, cls);
   }
   function whenTransitionEnds(el, expectedType, cb) {
-      var ref = getTransitionInfo(el, expectedType);
-      var type = ref.type;
-      var timeout = ref.timeout;
-      var propCount = ref.propCount;
+      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
       if (!type)
-          { return cb(); }
-      var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      var ended = 0;
-      var end = function () {
+          return cb();
+      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      let ended = 0;
+      const end = () => {
           el.removeEventListener(event, onEnd);
           cb();
       };
-      var onEnd = function (e) {
+      const onEnd = (e) => {
           if (e.target === el) {
               if (++ended >= propCount) {
                   end();
               }
           }
       };
-      setTimeout(function () {
+      setTimeout(() => {
           if (ended < propCount) {
               end();
           }
       }, timeout + 1);
       el.addEventListener(event, onEnd);
   }
-  var transformRE = /\b(transform|all)(,|$)/;
+  const transformRE = /\b(transform|all)(,|$)/;
   function getTransitionInfo(el, expectedType) {
-      var styles = window.getComputedStyle(el);
+      const styles = window.getComputedStyle(el);
       // JSDOM may return undefined for transition properties
-      var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      var transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      var animationTimeout = getTimeout(animationDelays, animationDurations);
-      var type;
-      var timeout = 0;
-      var propCount = 0;
+      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      const animationTimeout = getTimeout(animationDelays, animationDurations);
+      let type;
+      let timeout = 0;
+      let propCount = 0;
       /* istanbul ignore if */
       if (expectedType === TRANSITION) {
           if (transitionTimeout > 0) {
@@ -6545,12 +6569,12 @@
                   : animationDurations.length
               : 0;
       }
-      var hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
       return {
-          type: type,
-          timeout: timeout,
-          propCount: propCount,
-          hasTransform: hasTransform,
+          type,
+          timeout,
+          propCount,
+          hasTransform,
       };
   }
   function getTimeout(delays, durations) {
@@ -6558,7 +6582,7 @@
       while (delays.length < durations.length) {
           delays = delays.concat(delays);
       }
-      return Math.max.apply(null, durations.map(function (d, i) {
+      return Math.max.apply(null, durations.map((d, i) => {
           return toMs(d) + toMs(delays[i]);
       }));
   }
@@ -6571,13 +6595,13 @@
   }
 
   function enter(vnode, toggleDisplay) {
-      var el = vnode.elm;
+      const el = vnode.elm;
       // call leave callback now
       if (isDef(el._leaveCb)) {
           el._leaveCb.cancelled = true;
           el._leaveCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      const data = resolveTransition(vnode.data.transition);
       if (isUndef(data)) {
           return;
       }
@@ -6585,57 +6609,41 @@
       if (isDef(el._enterCb) || el.nodeType !== 1) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var enterClass = data.enterClass;
-      var enterToClass = data.enterToClass;
-      var enterActiveClass = data.enterActiveClass;
-      var appearClass = data.appearClass;
-      var appearToClass = data.appearToClass;
-      var appearActiveClass = data.appearActiveClass;
-      var beforeEnter = data.beforeEnter;
-      var enter = data.enter;
-      var afterEnter = data.afterEnter;
-      var enterCancelled = data.enterCancelled;
-      var beforeAppear = data.beforeAppear;
-      var appear = data.appear;
-      var afterAppear = data.afterAppear;
-      var appearCancelled = data.appearCancelled;
-      var duration = data.duration;
+      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
       // activeInstance will always be the <transition> component managing this
       // transition. One edge case to check is when the <transition> is placed
       // as the root node of a child component. In that case we need to check
       // <transition>'s parent for appear check.
-      var context = activeInstance;
-      var transitionNode = activeInstance.$vnode;
+      let context = activeInstance;
+      let transitionNode = activeInstance.$vnode;
       while (transitionNode && transitionNode.parent) {
           context = transitionNode.context;
           transitionNode = transitionNode.parent;
       }
-      var isAppear = !context._isMounted || !vnode.isRootInsert;
+      const isAppear = !context._isMounted || !vnode.isRootInsert;
       if (isAppear && !appear && appear !== '') {
           return;
       }
-      var startClass = isAppear && appearClass ? appearClass : enterClass;
-      var activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      var toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      var enterHook = isAppear
+      const startClass = isAppear && appearClass ? appearClass : enterClass;
+      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      const enterHook = isAppear
           ? typeof appear === 'function'
               ? appear
               : enter
           : enter;
-      var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      var enterCancelledHook = isAppear
+      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      const enterCancelledHook = isAppear
           ? appearCancelled || enterCancelled
           : enterCancelled;
-      var explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
       if (explicitEnterDuration != null) {
           checkDuration(explicitEnterDuration, 'enter', vnode);
       }
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(enterHook);
-      var cb = (el._enterCb = once(function () {
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(enterHook);
+      const cb = (el._enterCb = once(() => {
           if (expectsCSS) {
               removeTransitionClass(el, toClass);
               removeTransitionClass(el, activeClass);
@@ -6654,9 +6662,9 @@
       }));
       if (!vnode.data.show) {
           // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', function () {
-              var parent = el.parentNode;
-              var pendingNode = parent && parent._pending && parent._pending[vnode.key];
+          mergeVNodeHook(vnode, 'insert', () => {
+              const parent = el.parentNode;
+              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
               if (pendingNode &&
                   pendingNode.tag === vnode.tag &&
                   pendingNode.elm._leaveCb) {
@@ -6670,7 +6678,7 @@
       if (expectsCSS) {
           addTransitionClass(el, startClass);
           addTransitionClass(el, activeClass);
-          nextFrame(function () {
+          nextFrame(() => {
               removeTransitionClass(el, startClass);
               // @ts-expect-error
               if (!cb.cancelled) {
@@ -6695,13 +6703,13 @@
       }
   }
   function leave(vnode, rm) {
-      var el = vnode.elm;
+      const el = vnode.elm;
       // call enter callback now
       if (isDef(el._enterCb)) {
           el._enterCb.cancelled = true;
           el._enterCb();
       }
-      var data = resolveTransition(vnode.data.transition);
+      const data = resolveTransition(vnode.data.transition);
       if (isUndef(data) || el.nodeType !== 1) {
           return rm();
       }
@@ -6709,24 +6717,14 @@
       if (isDef(el._leaveCb)) {
           return;
       }
-      var css = data.css;
-      var type = data.type;
-      var leaveClass = data.leaveClass;
-      var leaveToClass = data.leaveToClass;
-      var leaveActiveClass = data.leaveActiveClass;
-      var beforeLeave = data.beforeLeave;
-      var leave = data.leave;
-      var afterLeave = data.afterLeave;
-      var leaveCancelled = data.leaveCancelled;
-      var delayLeave = data.delayLeave;
-      var duration = data.duration;
-      var expectsCSS = css !== false && !isIE9;
-      var userWantsControl = getHookArgumentsLength(leave);
-      var explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(leave);
+      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
       if (isDef(explicitLeaveDuration)) {
           checkDuration(explicitLeaveDuration, 'leave', vnode);
       }
-      var cb = (el._leaveCb = once(function () {
+      const cb = (el._leaveCb = once(() => {
           if (el.parentNode && el.parentNode._pending) {
               el.parentNode._pending[vnode.key] = null;
           }
@@ -6767,7 +6765,7 @@
           if (expectsCSS) {
               addTransitionClass(el, leaveClass);
               addTransitionClass(el, leaveActiveClass);
-              nextFrame(function () {
+              nextFrame(() => {
                   removeTransitionClass(el, leaveClass);
                   // @ts-expect-error
                   if (!cb.cancelled) {
@@ -6792,11 +6790,11 @@
   // only used in dev mode
   function checkDuration(val, name, vnode) {
       if (typeof val !== 'number') {
-          warn("<transition> explicit " + name + " duration is not a valid number - " +
-              "got " + (JSON.stringify(val)) + ".", vnode.context);
+          warn(`<transition> explicit ${name} duration is not a valid number - ` +
+              `got ${JSON.stringify(val)}.`, vnode.context);
       }
       else if (isNaN(val)) {
-          warn("<transition> explicit " + name + " duration is NaN - " +
+          warn(`<transition> explicit ${name} duration is NaN - ` +
               'the duration expression might be incorrect.', vnode.context);
       }
   }
@@ -6814,7 +6812,7 @@
           return false;
       }
       // @ts-expect-error
-      var invokerFns = fn.fns;
+      const invokerFns = fn.fns;
       if (isDef(invokerFns)) {
           // invoker
           return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
@@ -6833,7 +6831,7 @@
       ? {
           create: _enter,
           activate: _enter,
-          remove: function remove(vnode, rm) {
+          remove(vnode, rm) {
               /* istanbul ignore else */
               if (vnode.data.show !== true) {
                   // @ts-expect-error
@@ -6850,8 +6848,8 @@
 
   // the directive module should be applied last, after all
   // built-in modules have been applied.
-  var modules = platformModules.concat(baseModules);
-  var patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });
+  const modules = platformModules.concat(baseModules);
+  const patch = createPatchFunction({ nodeOps, modules });
 
   /**
    * Not type checking this file because flow doesn't like attaching
@@ -6860,20 +6858,20 @@
   /* istanbul ignore if */
   if (isIE9) {
       // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', function () {
-          var el = document.activeElement;
+      document.addEventListener('selectionchange', () => {
+          const el = document.activeElement;
           // @ts-expect-error
           if (el && el.vmodel) {
               trigger(el, 'input');
           }
       });
   }
-  var directive = {
-      inserted: function inserted(el, binding, vnode, oldVnode) {
+  const directive = {
+      inserted(el, binding, vnode, oldVnode) {
           if (vnode.tag === 'select') {
               // #6903
               if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', function () {
+                  mergeVNodeHook(vnode, 'postpatch', () => {
                       directive.componentUpdated(el, binding, vnode);
                   });
               }
@@ -6899,20 +6897,20 @@
               }
           }
       },
-      componentUpdated: function componentUpdated(el, binding, vnode) {
+      componentUpdated(el, binding, vnode) {
           if (vnode.tag === 'select') {
               setSelected(el, binding, vnode.context);
               // in case the options rendered by v-for have changed,
               // it's possible that the value is out-of-sync with the rendered options.
               // detect such cases and filter out values that no longer has a matching
               // option in the DOM.
-              var prevOptions = el._vOptions;
-              var curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {
+              const prevOptions = el._vOptions;
+              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
                   // trigger change event if
                   // no matching option found for at least one value
-                  var needReset = el.multiple
-                      ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })
+                  const needReset = el.multiple
+                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
                       : binding.value !== binding.oldValue &&
                           hasNoMatchingOption(binding.value, curOptions);
                   if (needReset) {
@@ -6926,23 +6924,23 @@
       actuallySetSelected(el, binding, vm);
       /* istanbul ignore if */
       if (isIE || isEdge) {
-          setTimeout(function () {
+          setTimeout(() => {
               actuallySetSelected(el, binding, vm);
           }, 0);
       }
   }
   function actuallySetSelected(el, binding, vm) {
-      var value = binding.value;
-      var isMultiple = el.multiple;
+      const value = binding.value;
+      const isMultiple = el.multiple;
       if (isMultiple && !Array.isArray(value)) {
-          warn("<select multiple v-model=\"" + (binding.expression) + "\"> " +
-                  "expects an Array value for its binding, but got " + (Object.prototype.toString
-                      .call(value)
-                      .slice(8, -1)), vm);
+          warn(`<select multiple v-model="${binding.expression}"> ` +
+                  `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
           return;
       }
-      var selected, option;
-      for (var i = 0, l = el.options.length; i < l; i++) {
+      let selected, option;
+      for (let i = 0, l = el.options.length; i < l; i++) {
           option = el.options[i];
           if (isMultiple) {
               selected = looseIndexOf(value, getValue(option)) > -1;
@@ -6964,7 +6962,7 @@
       }
   }
   function hasNoMatchingOption(value, options) {
-      return options.every(function (o) { return !looseEqual(o, value); });
+      return options.every((o) => !looseEqual(o, value));
   }
   function getValue(option) {
       return '_value' in option ? option._value : option.value;
@@ -6975,12 +6973,12 @@
   function onCompositionEnd(e) {
       // prevent triggering an input event for no reason
       if (!e.target.composing)
-          { return; }
+          return;
       e.target.composing = false;
       trigger(e.target, 'input');
   }
   function trigger(el, type) {
-      var e = document.createEvent('HTMLEvents');
+      const e = document.createEvent('HTMLEvents');
       e.initEvent(type, true, true);
       el.dispatchEvent(e);
   }
@@ -6993,16 +6991,14 @@
           : vnode;
   }
   var show = {
-      bind: function bind(el, ref, vnode) {
-          var value = ref.value;
-
+      bind(el, { value }, vnode) {
           vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
-          var originalDisplay = (el.__vOriginalDisplay =
+          const transition = vnode.data && vnode.data.transition;
+          const originalDisplay = (el.__vOriginalDisplay =
               el.style.display === 'none' ? '' : el.style.display);
           if (value && transition) {
               vnode.data.show = true;
-              enter(vnode, function () {
+              enter(vnode, () => {
                   el.style.display = originalDisplay;
               });
           }
@@ -7010,24 +7006,21 @@
               el.style.display = value ? originalDisplay : 'none';
           }
       },
-      update: function update(el, ref, vnode) {
-          var value = ref.value;
-          var oldValue = ref.oldValue;
-
+      update(el, { value, oldValue }, vnode) {
           /* istanbul ignore if */
           if (!value === !oldValue)
-              { return; }
+              return;
           vnode = locateNode(vnode);
-          var transition = vnode.data && vnode.data.transition;
+          const transition = vnode.data && vnode.data.transition;
           if (transition) {
               vnode.data.show = true;
               if (value) {
-                  enter(vnode, function () {
+                  enter(vnode, () => {
                       el.style.display = el.__vOriginalDisplay;
                   });
               }
               else {
-                  leave(vnode, function () {
+                  leave(vnode, () => {
                       el.style.display = 'none';
                   });
               }
@@ -7036,7 +7029,7 @@
               el.style.display = value ? el.__vOriginalDisplay : 'none';
           }
       },
-      unbind: function unbind(el, binding, vnode, oldVnode, isDestroy) {
+      unbind(el, binding, vnode, oldVnode, isDestroy) {
           if (!isDestroy) {
               el.style.display = el.__vOriginalDisplay;
           }
@@ -7045,11 +7038,11 @@
 
   var platformDirectives = {
       model: directive,
-      show: show,
+      show,
   };
 
   // Provides transition support for a single element/component.
-  var transitionProps = {
+  const transitionProps = {
       name: String,
       appear: Boolean,
       css: Boolean,
@@ -7069,7 +7062,7 @@
   // in case the child is also an abstract component, e.g. <keep-alive>
   // we want to recursively retrieve the real component to be rendered
   function getRealChild(vnode) {
-      var compOptions = vnode && vnode.componentOptions;
+      const compOptions = vnode && vnode.componentOptions;
       if (compOptions && compOptions.Ctor.options.abstract) {
           return getRealChild(getFirstComponentChild(compOptions.children));
       }
@@ -7078,17 +7071,17 @@
       }
   }
   function extractTransitionData(comp) {
-      var data = {};
-      var options = comp.$options;
+      const data = {};
+      const options = comp.$options;
       // props
-      for (var key in options.propsData) {
+      for (const key in options.propsData) {
           data[key] = comp[key];
       }
       // events.
       // extract listeners and pass them directly to the transition methods
-      var listeners = options._parentListeners;
-      for (var key$1 in listeners) {
-          data[camelize(key$1)] = listeners[key$1];
+      const listeners = options._parentListeners;
+      for (const key in listeners) {
+          data[camelize(key)] = listeners[key];
       }
       return data;
   }
@@ -7110,16 +7103,14 @@
   function isSameChild(child, oldChild) {
       return oldChild.key === child.key && oldChild.tag === child.tag;
   }
-  var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-  var isVShowDirective = function (d) { return d.name === 'show'; };
+  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+  const isVShowDirective = (d) => d.name === 'show';
   var Transition = {
       name: 'transition',
       props: transitionProps,
       abstract: true,
-      render: function render(h) {
-          var this$1 = this;
-
-          var children = this.$slots.default;
+      render(h) {
+          let children = this.$slots.default;
           if (!children) {
               return;
           }
@@ -7134,14 +7125,14 @@
               warn('<transition> can only be used on a single element. Use ' +
                   '<transition-group> for lists.', this.$parent);
           }
-          var mode = this.mode;
+          const mode = this.mode;
           // warn invalid mode
           if (mode &&
               mode !== 'in-out' &&
               mode !== 'out-in') {
               warn('invalid <transition> mode: ' + mode, this.$parent);
           }
-          var rawChild = children[0];
+          const rawChild = children[0];
           // if this is a component root node and the component's
           // parent container node also has transition, skip.
           if (hasParentTransition(this.$vnode)) {
@@ -7149,7 +7140,7 @@
           }
           // apply transition data to child
           // use getRealChild() to ignore abstract components e.g. keep-alive
-          var child = getRealChild(rawChild);
+          const child = getRealChild(rawChild);
           /* istanbul ignore if */
           if (!child) {
               return rawChild;
@@ -7160,7 +7151,7 @@
           // ensure a key that is unique to the vnode type and to this transition
           // component instance. This key will be used to remove pending leaving nodes
           // during entering.
-          var id = "__transition-" + (this._uid) + "-";
+          const id = `__transition-${this._uid}-`;
           child.key =
               child.key == null
                   ? child.isComment
@@ -7171,9 +7162,9 @@
                           ? child.key
                           : id + child.key
                       : child.key;
-          var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          var oldRawChild = this._vnode;
-          var oldChild = getRealChild(oldRawChild);
+          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          const oldRawChild = this._vnode;
+          const oldChild = getRealChild(oldRawChild);
           // mark v-show
           // so that the transition module can hand over the control to the directive
           if (child.data.directives && child.data.directives.some(isVShowDirective)) {
@@ -7188,14 +7179,14 @@
                   oldChild.componentInstance._vnode.isComment)) {
               // replace old child transition data with fresh one
               // important for dynamic transitions!
-              var oldData = (oldChild.data.transition = extend({}, data));
+              const oldData = (oldChild.data.transition = extend({}, data));
               // handle transition mode
               if (mode === 'out-in') {
                   // return placeholder node and queue update when leave finishes
                   this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', function () {
-                      this$1._leaving = false;
-                      this$1.$forceUpdate();
+                  mergeVNodeHook(oldData, 'afterLeave', () => {
+                      this._leaving = false;
+                      this.$forceUpdate();
                   });
                   return placeholder(h, rawChild);
               }
@@ -7203,13 +7194,13 @@
                   if (isAsyncPlaceholder(child)) {
                       return oldRawChild;
                   }
-                  var delayedLeave;
-                  var performLeave = function () {
+                  let delayedLeave;
+                  const performLeave = () => {
                       delayedLeave();
                   };
                   mergeVNodeHook(data, 'afterEnter', performLeave);
                   mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', function (leave) {
+                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
                       delayedLeave = leave;
                   });
               }
@@ -7219,67 +7210,63 @@
   };
 
   // Provides transition support for list items.
-  var props = extend({
+  const props = extend({
       tag: String,
       moveClass: String,
   }, transitionProps);
-  // @ts-ignore
   delete props.mode;
   var TransitionGroup = {
-      props: props,
-      beforeMount: function beforeMount() {
-          var this$1 = this;
-
-          var update = this._update;
-          this._update = function (vnode, hydrating) {
-              var restoreActiveInstance = setActiveInstance(this$1);
+      props,
+      beforeMount() {
+          const update = this._update;
+          this._update = (vnode, hydrating) => {
+              const restoreActiveInstance = setActiveInstance(this);
               // force removing pass
-              this$1.__patch__(this$1._vnode, this$1.kept, false, // hydrating
+              this.__patch__(this._vnode, this.kept, false, // hydrating
               true // removeOnly (!important, avoids unnecessary moves)
               );
-              this$1._vnode = this$1.kept;
+              this._vnode = this.kept;
               restoreActiveInstance();
-              update.call(this$1, vnode, hydrating);
+              update.call(this, vnode, hydrating);
           };
       },
-      render: function render(h) {
-          var tag = this.tag || this.$vnode.data.tag || 'span';
-          var map = Object.create(null);
-          var prevChildren = (this.prevChildren = this.children);
-          var rawChildren = this.$slots.default || [];
-          var children = (this.children = []);
-          var transitionData = extractTransitionData(this);
-          for (var i = 0; i < rawChildren.length; i++) {
-              var c = rawChildren[i];
+      render(h) {
+          const tag = this.tag || this.$vnode.data.tag || "span";
+          const map = Object.create(null);
+          const prevChildren = (this.prevChildren = this.children);
+          const rawChildren = this.$slots.default || [];
+          const children = (this.children = []);
+          const transitionData = extractTransitionData(this);
+          for (let i = 0; i < rawChildren.length; i++) {
+              const c = rawChildren[i];
               if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
                       children.push(c);
                       map[c.key] = c;
                       (c.data || (c.data = {})).transition = transitionData;
                   }
                   else {
-                      var opts = c.componentOptions;
-                      var name = opts
-                          ? opts.Ctor.options.name || opts.tag || ''
+                      const opts = c.componentOptions;
+                      const name = opts
+                          ? opts.Ctor.options.name || opts.tag || ""
                           : c.tag;
-                      warn(("<transition-group> children must be keyed: <" + name + ">"));
+                      warn(`<transition-group> children must be keyed: <${name}>`);
                   }
               }
           }
           if (prevChildren) {
-              var kept = [];
-              var removed = [];
-              for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {
-                  var c$1 = prevChildren[i$1];
-                  c$1.data.transition = transitionData;
-                  // @ts-ignore
-                  c$1.data.pos = c$1.elm.getBoundingClientRect();
-                  // @ts-ignore
-                  if (map[c$1.key]) {
-                      kept.push(c$1);
+              const kept = [];
+              const removed = [];
+              for (let i = 0; i < prevChildren.length; i++) {
+                  const c = prevChildren[i];
+                  c.data.transition = transitionData;
+                  // @ts-expect-error .getBoundingClientRect is not typed in Node
+                  c.data.pos = c.elm.getBoundingClientRect();
+                  if (map[c.key]) {
+                      kept.push(c);
                   }
                   else {
-                      removed.push(c$1);
+                      removed.push(c);
                   }
               }
               this.kept = h(tag, null, kept);
@@ -7287,9 +7274,9 @@
           }
           return h(tag, null, children);
       },
-      updated: function updated() {
-          var children = this.prevChildren;
-          var moveClass = this.moveClass || (this.name || 'v') + '-move';
+      updated() {
+          const children = this.prevChildren;
+          const moveClass = this.moveClass || (this.name || "v") + "-move";
           if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
               return;
           }
@@ -7302,13 +7289,12 @@
           // assign to this to avoid being removed in tree-shaking
           // $flow-disable-line
           this._reflow = document.body.offsetHeight;
-          children.forEach(function (c) {
-              // @ts-ignore
+          children.forEach((c) => {
               if (c.data.moved) {
-                  var el = c.elm;
-                  var s = el.style;
+                  const el = c.elm;
+                  const s = el.style;
                   addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = '';
+                  s.transform = s.WebkitTransform = s.transitionDuration = "";
                   el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
                       if (e && e.target !== el) {
                           return;
@@ -7323,7 +7309,7 @@
           });
       },
       methods: {
-          hasMove: function hasMove(el, moveClass) {
+          hasMove(el, moveClass) {
               /* istanbul ignore if */
               if (!hasTransition) {
                   return false;
@@ -7337,16 +7323,16 @@
               // transition at this very moment, we make a clone of it and remove
               // all other transition classes applied to ensure only the move class
               // is applied.
-              var clone = el.cloneNode();
+              const clone = el.cloneNode();
               if (el._transitionClasses) {
-                  el._transitionClasses.forEach(function (cls) {
+                  el._transitionClasses.forEach((cls) => {
                       removeClass(clone, cls);
                   });
               }
               addClass(clone, moveClass);
-              clone.style.display = 'none';
+              clone.style.display = "none";
               this.$el.appendChild(clone);
-              var info = getTransitionInfo(clone);
+              const info = getTransitionInfo(clone);
               this.$el.removeChild(clone);
               return (this._hasMove = info.hasTransform);
           },
@@ -7354,42 +7340,33 @@
   };
   function callPendingCbs(c) {
       /* istanbul ignore if */
-      //@ts-ignore
       if (c.elm._moveCb) {
-          //@ts-ignore
           c.elm._moveCb();
       }
       /* istanbul ignore if */
-      //@ts-ignore
       if (c.elm._enterCb) {
-          //@ts-ignore
           c.elm._enterCb();
       }
   }
   function recordPosition(c) {
-      //@ts-ignore
       c.data.newPos = c.elm.getBoundingClientRect();
   }
   function applyTranslation(c) {
-      //@ts-ignore
-      var oldPos = c.data.pos;
-      //@ts-ignore
-      var newPos = c.data.newPos;
-      var dx = oldPos.left - newPos.left;
-      var dy = oldPos.top - newPos.top;
+      const oldPos = c.data.pos;
+      const newPos = c.data.newPos;
+      const dx = oldPos.left - newPos.left;
+      const dy = oldPos.top - newPos.top;
       if (dx || dy) {
-          //@ts-ignore
           c.data.moved = true;
-          //@ts-ignore
-          var s = c.elm.style;
-          s.transform = s.WebkitTransform = "translate(" + dx + "px," + dy + "px)";
-          s.transitionDuration = '0s';
+          const s = c.elm.style;
+          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+          s.transitionDuration = "0s";
       }
   }
 
   var platformComponents = {
-      Transition: Transition,
-      TransitionGroup: TransitionGroup,
+      Transition,
+      TransitionGroup,
   };
 
   // install platform specific utils
@@ -7411,7 +7388,7 @@
   // devtools global hook
   /* istanbul ignore next */
   if (inBrowser) {
-      setTimeout(function () {
+      setTimeout(() => {
           if (config.devtools) {
               if (devtools) {
                   devtools.emit('init', Vue);
@@ -7425,13 +7402,13 @@
           if (config.productionTip !== false &&
               typeof console !== 'undefined') {
               // @ts-expect-error
-              console[console.info ? 'info' : 'log']("You are running Vue in development mode.\n" +
-                  "Make sure to turn on production mode when deploying for production.\n" +
-                  "See more tips at https://vuejs.org/guide/deployment.html");
+              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                  `Make sure to turn on production mode when deploying for production.\n` +
+                  `See more tips at https://vuejs.org/guide/deployment.html`);
           }
       }, 0);
   }
 
   return Vue;
 
-})));
+}));
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
index 45d9b60378e..308dc809ffc 100644
--- a/dist/vue.runtime.min.js
+++ b/dist/vue.runtime.min.js
@@ -1,11 +1,11 @@
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
 /*!
- * Vue.js v2.6.12
- * (c) 2014-2021 Evan You
+ * Vue.js v2.6.14
+ * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){"use strict";var t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function r(t){return!0===t}function o(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function i(t){return null!==t&&"object"==typeof t}var a=Object.prototype.toString;function s(t){return"[object Object]"===a.call(t)}function c(t){var e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function u(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function l(t){return null==t?"":Array.isArray(t)||s(t)&&t.toString===a?JSON.stringify(t,null,2):String(t)}function f(t){var e=parseFloat(t);return isNaN(e)?t:e}function p(t,e){for(var n=Object.create(null),r=t.split(","),o=0;o<r.length;o++)n[r[o]]=!0;return e?function(t){return n[t.toLowerCase()]}:function(t){return n[t]}}var d=p("key,ref,slot,slot-scope,is");function v(t,e){if(t.length){var n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}var h=Object.prototype.hasOwnProperty;function m(t,e){return h.call(t,e)}function y(t){var e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}var g=/-(\w)/g,_=y((function(t){return t.replace(g,(function(t,e){return e?e.toUpperCase():""}))})),b=y((function(t){return t.charAt(0).toUpperCase()+t.slice(1)})),C=/\B([A-Z])/g,$=y((function(t){return t.replace(C,"-$1").toLowerCase()}));var w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){var r=arguments.length;return r?r>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;for(var n=t.length-e,r=new Array(n);n--;)r[n]=t[n+e];return r}function x(t,e){for(var n in e)t[n]=e[n];return t}function O(t){for(var e={},n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function k(t,e,n){}var S=function(t,e,n){return!1},E=function(t){return t};function j(t,e){if(t===e)return!0;var n=i(t),r=i(e);if(!n||!r)return!n&&!r&&String(t)===String(e);try{var o=Array.isArray(t),a=Array.isArray(e);if(o&&a)return t.length===e.length&&t.every((function(t,n){return j(t,e[n])}));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(o||a)return!1;var s=Object.keys(t),c=Object.keys(e);return s.length===c.length&&s.every((function(n){return j(t[n],e[n])}))}catch(t){return!1}}function T(t,e){for(var n=0;n<t.length;n++)if(j(t[n],e))return n;return-1}function I(t){var e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}var D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:k,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t){var e=(t+"").charCodeAt(0);return 36===e||95===e}function F(t,e,n,r){Object.defineProperty(t,e,{value:n,enumerable:!!r,writable:!0,configurable:!0})}var R=new RegExp("[^"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+".$_\\d]");var U="__proto__"in{},V="undefined"!=typeof window,B="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,H=B&&WXEnvironment.platform.toLowerCase(),z=V&&window.navigator.userAgent.toLowerCase(),W=z&&/msie|trident/.test(z),q=z&&z.indexOf("msie 9.0")>0,K=z&&z.indexOf("edge/")>0;z&&z.indexOf("android");var X=z&&/iphone|ipad|ipod|ios/.test(z)||"ios"===H;z&&/chrome\/\d+/.test(z),z&&/phantomjs/.test(z);var G,Z=z&&z.match(/firefox\/(\d+)/),J={}.watch,Q=!1;if(V)try{var Y={};Object.defineProperty(Y,"passive",{get:function(){Q=!0}}),window.addEventListener("test-passive",null,Y)}catch(t){}var tt=function(){return void 0===G&&(G=!V&&!B&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),G},et=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}var rt,ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);rt="undefined"!=typeof Set&&nt(Set)?Set:function(){function t(){this.set=Object.create(null)}return t.prototype.has=function(t){return!0===this.set[t]},t.prototype.add=function(t){this.set[t]=!0},t.prototype.clear=function(){this.set=Object.create(null)},t}();var it=k,at=0,st=function(){this.id=at++,this.subs=[]};st.prototype.addSub=function(t){this.subs.push(t)},st.prototype.removeSub=function(t){v(this.subs,t)},st.prototype.depend=function(){st.target&&st.target.addDep(this)},st.prototype.notify=function(){for(var t=this.subs.slice(),e=0,n=t.length;e<n;e++)t[e].update()},st.target=null;var ct=[];function ut(t){ct.push(t),st.target=t}function lt(){ct.pop(),st.target=ct[ct.length-1]}var ft=function(t,e,n,r,o,i,a,s){this.tag=t,this.data=e,this.children=n,this.text=r,this.elm=o,this.ns=void 0,this.context=i,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},pt={child:{configurable:!0}};pt.child.get=function(){return this.componentInstance},Object.defineProperties(ft.prototype,pt);var dt=function(t){void 0===t&&(t="");var e=new ft;return e.text=t,e.isComment=!0,e};function vt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){var e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}var mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){var e=mt[t];F(yt,t,(function(){for(var n=[],r=arguments.length;r--;)n[r]=arguments[r];var o,i=e.apply(this,n),a=this.__ob__;switch(t){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&a.observeArray(o),a.dep.notify(),i}))}));var gt=Object.getOwnPropertyNames(yt),_t=!0;function bt(t){_t=t}var Ct=function(t){this.value=t,this.dep=new st,this.vmCount=0,F(t,"__ob__",this),Array.isArray(t)?(U?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(var r=0,o=n.length;r<o;r++){var i=n[r];F(t,i,e[i])}}(t,yt,gt),this.observeArray(t)):this.walk(t)};function $t(t,e){var n;if(i(t)&&!(t instanceof ft))return m(t,"__ob__")&&t.__ob__ instanceof Ct?n=t.__ob__:_t&&!tt()&&(Array.isArray(t)||s(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new Ct(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,r,o){var i=new st,a=Object.getOwnPropertyDescriptor(t,e);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(n=t[e]);var u=!o&&$t(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){var e=s?s.call(t):n;return st.target&&(i.depend(),u&&(u.dep.depend(),Array.isArray(e)&&Ot(e))),e},set:function(e){var r=s?s.call(t):n;e===r||e!=e&&r!=r||s&&!c||(c?c.call(t,e):n=e,u=!o&&$t(e),i.notify())}})}}function At(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;var r=t.__ob__;return t._isVue||r&&r.vmCount?n:r?(wt(r.value,e,n),r.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))t.splice(e,1);else{var n=t.__ob__;t._isVue||n&&n.vmCount||m(t,e)&&(delete t[e],n&&n.dep.notify())}}function Ot(t){for(var e=void 0,n=0,r=t.length;n<r;n++)(e=t[n])&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&Ot(e)}Ct.prototype.walk=function(t){for(var e=Object.keys(t),n=0;n<e.length;n++)wt(t,e[n])},Ct.prototype.observeArray=function(t){for(var e=0,n=t.length;e<n;e++)$t(t[e])};var kt=L.optionMergeStrategies;function St(t,e){if(!e)return t;for(var n,r,o,i=ot?Reflect.ownKeys(e):Object.keys(e),a=0;a<i.length;a++)"__ob__"!==(n=i[a])&&(r=t[n],o=e[n],m(t,n)?r!==o&&s(r)&&s(o)&&St(r,o):At(t,n,o));return t}function Et(t,e,n){return n?function(){var r="function"==typeof e?e.call(n,n):e,o="function"==typeof t?t.call(n,n):t;return r?St(r,o):o}:e?t?function(){return St("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function jt(t,e){var n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){for(var e=[],n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Tt(t,e,n,r){var o=Object.create(t||null);return e?x(o,e):o}kt.data=function(t,e,n){return n?Et(t,e,n):e&&"function"!=typeof e?t:Et(t,e)},P.forEach((function(t){kt[t]=jt})),N.forEach((function(t){kt[t+"s"]=Tt})),kt.watch=function(t,e,n,r){if(t===J&&(t=void 0),e===J&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;var o={};for(var i in x(o,t),e){var a=o[i],s=e[i];a&&!Array.isArray(a)&&(a=[a]),o[i]=a?a.concat(s):Array.isArray(s)?s:[s]}return o},kt.props=kt.methods=kt.inject=kt.computed=function(t,e,n,r){if(!t)return e;var o=Object.create(null);return x(o,t),e&&x(o,e),o},kt.provide=Et;var It=function(t,e){return void 0===e?t:e};function Dt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){var n=t.props;if(n){var r,o,i={};if(Array.isArray(n))for(r=n.length;r--;)"string"==typeof(o=n[r])&&(i[_(o)]={type:null});else if(s(n))for(var a in n)o=n[a],i[_(a)]=s(o)?o:{type:o};t.props=i}}(e),function(t,e){var n=t.inject;if(n){var r=t.inject={};if(Array.isArray(n))for(var o=0;o<n.length;o++)r[n[o]]={from:n[o]};else if(s(n))for(var i in n){var a=n[i];r[i]=s(a)?x({from:i},a):{from:a}}}}(e),function(t){var e=t.directives;if(e)for(var n in e){var r=e[n];"function"==typeof r&&(e[n]={bind:r,update:r})}}(e),!e._base&&(e.extends&&(t=Dt(t,e.extends,n)),e.mixins))for(var r=0,o=e.mixins.length;r<o;r++)t=Dt(t,e.mixins[r],n);var i,a={};for(i in t)c(i);for(i in e)m(t,i)||c(i);function c(r){var o=kt[r]||It;a[r]=o(t[r],e[r],n,r)}return a}function Nt(t,e,n,r){if("string"==typeof n){var o=t[e];if(m(o,n))return o[n];var i=_(n);if(m(o,i))return o[i];var a=b(i);return m(o,a)?o[a]:o[n]||o[i]||o[a]}}function Pt(t,e,n,r){var o=e[t],i=!m(n,t),a=n[t],s=Rt(Boolean,o.type);if(s>-1)if(i&&!m(o,"default"))a=!1;else if(""===a||a===$(t)){var c=Rt(String,o.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(t,e,n){if(!m(e,"default"))return;var r=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof r&&"Function"!==Mt(e.type)?r.call(t):r}(r,o,t);var u=_t;bt(!0),$t(a),bt(u)}return a}var Lt=/^\s*function (\w+)/;function Mt(t){var e=t&&t.toString().match(Lt);return e?e[1]:""}function Ft(t,e){return Mt(t)===Mt(e)}function Rt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(var n=0,r=e.length;n<r;n++)if(Ft(e[n],t))return n;return-1}function Ut(t,e,n){ut();try{if(e)for(var r=e;r=r.$parent;){var o=r.$options.errorCaptured;if(o)for(var i=0;i<o.length;i++)try{if(!1===o[i].call(r,t,e,n))return}catch(t){Bt(t,r,"errorCaptured hook")}}Bt(t,e,n)}finally{lt()}}function Vt(t,e,n,r,o){var i;try{(i=n?t.apply(e,n):t.call(e))&&!i._isVue&&u(i)&&!i._handled&&(i.catch((function(t){return Ut(t,r,o+" (Promise/async)")})),i._handled=!0)}catch(t){Ut(t,r,o)}return i}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ht(e)}Ht(t)}function Ht(t,e,n){if(!V&&!B||"undefined"==typeof console)throw t;console.error(t)}var zt,Wt=!1,qt=[],Kt=!1;function Xt(){Kt=!1;var t=qt.slice(0);qt.length=0;for(var e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){var Gt=Promise.resolve();zt=function(){Gt.then(Xt),X&&setTimeout(k)},Wt=!0}else if(W||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())zt="undefined"!=typeof setImmediate&&nt(setImmediate)?function(){setImmediate(Xt)}:function(){setTimeout(Xt,0)};else{var Zt=1,Jt=new MutationObserver(Xt),Qt=document.createTextNode(String(Zt));Jt.observe(Qt,{characterData:!0}),zt=function(){Zt=(Zt+1)%2,Qt.data=String(Zt)},Wt=!0}function Yt(t,e){var n;if(qt.push((function(){if(t)try{t.call(e)}catch(t){Ut(t,e,"nextTick")}else n&&n(e)})),Kt||(Kt=!0,zt()),!t&&"undefined"!=typeof Promise)return new Promise((function(t){n=t}))}var te=new rt;function ee(t){ne(t,te),te.clear()}function ne(t,e){var n,r,o=Array.isArray(t);if(!(!o&&!i(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){var a=t.__ob__.dep.id;if(e.has(a))return;e.add(a)}if(o)for(n=t.length;n--;)ne(t[n],e);else for(n=(r=Object.keys(t)).length;n--;)ne(t[r[n]],e)}}var re=y((function(t){var e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),r="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=r?t.slice(1):t,once:n,capture:r,passive:e}}));function oe(t,e){function n(){var t=arguments,r=n.fns;if(!Array.isArray(r))return Vt(r,null,arguments,e,"v-on handler");for(var o=r.slice(),i=0;i<o.length;i++)Vt(o[i],null,t,e,"v-on handler")}return n.fns=t,n}function ie(t,n,o,i,a,s){var c,u,l,f;for(c in t)u=t[c],l=n[c],f=re(c),e(u)||(e(l)?(e(u.fns)&&(u=t[c]=oe(u,s)),r(f.once)&&(u=t[c]=a(f.name,u,f.capture)),o(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,t[c]=l));for(c in n)e(t[c])&&i((f=re(c)).name,n[c],f.capture)}function ae(t,o,i){var a;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));var s=t[o];function c(){i.apply(this,arguments),v(a.fns,c)}e(s)?a=oe([c]):n(s.fns)&&r(s.merged)?(a=s).fns.push(c):a=oe([s,c]),a.merged=!0,t[o]=a}function se(t,e,r,o,i){if(n(e)){if(m(e,r))return t[r]=e[r],i||delete e[r],!0;if(m(e,o))return t[r]=e[o],i||delete e[o],!0}return!1}function ce(t){return o(t)?[vt(t)]:Array.isArray(t)?le(t):void 0}function ue(t){return n(t)&&n(t.text)&&!1===t.isComment}function le(t,i){var a,s,c,u,l=[];for(a=0;a<t.length;a++)e(s=t[a])||"boolean"==typeof s||(u=l[c=l.length-1],Array.isArray(s)?s.length>0&&(ue((s=le(s,(i||"")+"_"+a))[0])&&ue(u)&&(l[c]=vt(u.text+s[0].text),s.shift()),l.push.apply(l,s)):o(s)?ue(u)?l[c]=vt(u.text+s):""!==s&&l.push(vt(s)):ue(s)&&ue(u)?l[c]=vt(u.text+s.text):(r(t._isVList)&&n(s.tag)&&e(s.key)&&n(i)&&(s.key="__vlist"+i+"_"+a+"__"),l.push(s)));return l}function fe(t,e){if(t){for(var n=Object.create(null),r=ot?Reflect.ownKeys(t):Object.keys(t),o=0;o<r.length;o++){var i=r[o];if("__ob__"!==i){for(var a=t[i].from,s=e;s;){if(s._provided&&m(s._provided,a)){n[i]=s._provided[a];break}s=s.$parent}if(!s&&"default"in t[i]){var c=t[i].default;n[i]="function"==typeof c?c.call(e):c}}}return n}}function pe(t,e){if(!t||!t.length)return{};for(var n={},r=0,o=t.length;r<o;r++){var i=t[r],a=i.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,i.context!==e&&i.fnContext!==e||!a||null==a.slot)(n.default||(n.default=[])).push(i);else{var s=a.slot,c=n[s]||(n[s]=[]);"template"===i.tag?c.push.apply(c,i.children||[]):c.push(i)}}for(var u in n)n[u].every(de)&&delete n[u];return n}function de(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ve(e,n,r){var o,i=Object.keys(n).length>0,a=e?!!e.$stable:!i,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&r&&r!==t&&s===r.$key&&!i&&!r.$hasNormal)return r;for(var c in o={},e)e[c]&&"$"!==c[0]&&(o[c]=he(n,c,e[c]))}else o={};for(var u in n)u in o||(o[u]=me(n,u));return e&&Object.isExtensible(e)&&(e._normalized=o),F(o,"$stable",a),F(o,"$key",s),F(o,"$hasNormal",i),o}function he(t,e,n){var r=function(){var t=arguments.length?n.apply(null,arguments):n({});return(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ce(t))&&(0===t.length||1===t.length&&t[0].isComment)?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:r,enumerable:!0,configurable:!0}),r}function me(t,e){return function(){return t[e]}}function ye(t,e){var r,o,a,s,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),r=0,o=t.length;r<o;r++)c[r]=e(t[r],r);else if("number"==typeof t)for(c=new Array(t),r=0;r<t;r++)c[r]=e(r+1,r);else if(i(t))if(ot&&t[Symbol.iterator]){c=[];for(var u=t[Symbol.iterator](),l=u.next();!l.done;)c.push(e(l.value,c.length)),l=u.next()}else for(a=Object.keys(t),c=new Array(a.length),r=0,o=a.length;r<o;r++)s=a[r],c[r]=e(t[s],s,r);return n(c)||(c=[]),c._isVList=!0,c}function ge(t,e,n,r){var o,i=this.$scopedSlots[t];i?(n=n||{},r&&(n=x(x({},r),n)),o=i(n)||e):o=this.$slots[t]||e;var a=n&&n.slot;return a?this.$createElement("template",{slot:a},o):o}function _e(t){return Nt(this.$options,"filters",t)||E}function be(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function Ce(t,e,n,r,o){var i=L.keyCodes[e]||n;return o&&r&&!L.keyCodes[e]?be(o,r):i?be(i,t):r?$(r)!==e:void 0}function $e(t,e,n,r,o){if(n)if(i(n)){var a;Array.isArray(n)&&(n=O(n));var s=function(i){if("class"===i||"style"===i||d(i))a=t;else{var s=t.attrs&&t.attrs.type;a=r||L.mustUseProp(e,s,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}var c=_(i),u=$(i);c in a||u in a||(a[i]=n[i],o&&((t.on||(t.on={}))["update:"+i]=function(t){n[i]=t}))};for(var c in n)s(c)}else;return t}function we(t,e){var n=this._staticTrees||(this._staticTrees=[]),r=n[t];return r&&!e||xe(r=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),"__static__"+t,!1),r}function Ae(t,e,n){return xe(t,"__once__"+e+(n?"_"+n:""),!0),t}function xe(t,e,n){if(Array.isArray(t))for(var r=0;r<t.length;r++)t[r]&&"string"!=typeof t[r]&&Oe(t[r],e+"_"+r,n);else Oe(t,e,n)}function Oe(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function ke(t,e){if(e)if(s(e)){var n=t.on=t.on?x({},t.on):{};for(var r in e){var o=n[r],i=e[r];n[r]=o?[].concat(o,i):i}}else;return t}function Se(t,e,n,r){e=e||{$stable:!n};for(var o=0;o<t.length;o++){var i=t[o];Array.isArray(i)?Se(i,e,n):i&&(i.proxy&&(i.fn.proxy=!0),e[i.key]=i.fn)}return r&&(e.$key=r),e}function Ee(t,e){for(var n=0;n<e.length;n+=2){var r=e[n];"string"==typeof r&&r&&(t[e[n]]=e[n+1])}return t}function je(t,e){return"string"==typeof t?e+t:t}function Te(t){t._o=Ae,t._n=f,t._s=l,t._l=ye,t._t=ge,t._q=j,t._i=T,t._m=we,t._f=_e,t._k=Ce,t._b=$e,t._v=vt,t._e=dt,t._u=Se,t._g=ke,t._d=Ee,t._p=je}function Ie(e,n,o,i,a){var s,c=this,u=a.options;m(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=r(u._compiled),f=!l;this.data=e,this.props=n,this.children=o,this.parent=i,this.listeners=e.on||t,this.injections=fe(u.inject,i),this.slots=function(){return c.$slots||ve(e.scopedSlots,c.$slots=pe(o,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return ve(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=ve(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(t,e,n,r){var o=Re(s,t,e,n,r,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(t,e,n,r){return Re(s,t,e,n,r,f)}}function De(t,e,n,r,o){var i=ht(t);return i.fnContext=n,i.fnOptions=r,e.slot&&((i.data||(i.data={})).slot=e.slot),i}function Ne(t,e){for(var n in e)t[_(n)]=e[n]}Te(Ie.prototype);var Pe={init:function(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){var r=t;Pe.prepatch(r,r)}else{(t.componentInstance=function(t,e){var r={_isComponent:!0,_parentVnode:t,parent:e},o=t.data.inlineTemplate;n(o)&&(r.render=o.render,r.staticRenderFns=o.staticRenderFns);return new t.componentOptions.Ctor(r)}(t,Ze)).$mount(e?t.elm:void 0,e)}},prepatch:function(e,n){var r=n.componentOptions;!function(e,n,r,o,i){var a=o.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==t&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key),u=!!(i||e.$options._renderChildren||c);e.$options._parentVnode=o,e.$vnode=o,e._vnode&&(e._vnode.parent=o);if(e.$options._renderChildren=i,e.$attrs=o.data.attrs||t,e.$listeners=r||t,n&&e.$options.props){bt(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=Pt(d,v,n,e)}bt(!0),e.$options.propsData=n}r=r||t;var h=e.$options._parentListeners;e.$options._parentListeners=r,Ge(e,r,h),u&&(e.$slots=pe(i,o.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,r.propsData,r.listeners,n,r.children)},insert:function(t){var e,n=t.context,r=t.componentInstance;r._isMounted||(r._isMounted=!0,en(r,"mounted")),t.data.keepAlive&&(n._isMounted?((e=r)._inactive=!1,rn.push(e)):Ye(r,!0))},destroy:function(t){var e=t.componentInstance;e._isDestroyed||(t.data.keepAlive?tn(e,!0):e.$destroy())}},Le=Object.keys(Pe);function Me(o,a,s,c,l){if(!e(o)){var f=s.$options._base;if(i(o)&&(o=f.extend(o)),"function"==typeof o){var p;if(e(o.cid)&&void 0===(o=function(t,o){if(r(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;var a=Be;a&&n(t.owners)&&-1===t.owners.indexOf(a)&&t.owners.push(a);if(r(t.loading)&&n(t.loadingComp))return t.loadingComp;if(a&&!n(t.owners)){var s=t.owners=[a],c=!0,l=null,f=null;a.$on("hook:destroyed",(function(){return v(s,a)}));var p=function(t){for(var e=0,n=s.length;e<n;e++)s[e].$forceUpdate();t&&(s.length=0,null!==l&&(clearTimeout(l),l=null),null!==f&&(clearTimeout(f),f=null))},d=I((function(e){t.resolved=He(e,o),c?s.length=0:p(!0)})),h=I((function(e){n(t.errorComp)&&(t.error=!0,p(!0))})),m=t(d,h);return i(m)&&(u(m)?e(t.resolved)&&m.then(d,h):u(m.component)&&(m.component.then(d,h),n(m.error)&&(t.errorComp=He(m.error,o)),n(m.loading)&&(t.loadingComp=He(m.loading,o),0===m.delay?t.loading=!0:l=setTimeout((function(){l=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,p(!1))}),m.delay||200)),n(m.timeout)&&(f=setTimeout((function(){f=null,e(t.resolved)&&h(null)}),m.timeout)))),c=!1,t.loading?t.loadingComp:t.resolved}}(p=o,f)))return function(t,e,n,r,o){var i=dt();return i.asyncFactory=t,i.asyncMeta={data:e,context:n,children:r,tag:o},i}(p,a,s,c,l);a=a||{},An(o),n(a.model)&&function(t,e){var r=t.model&&t.model.prop||"value",o=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[r]=e.model.value;var i=e.on||(e.on={}),a=i[o],s=e.model.callback;n(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(i[o]=[s].concat(a)):i[o]=s}(o.options,a);var d=function(t,r,o){var i=r.options.props;if(!e(i)){var a={},s=t.attrs,c=t.props;if(n(s)||n(c))for(var u in i){var l=$(u);se(a,c,u,l,!0)||se(a,s,u,l,!1)}return a}}(a,o);if(r(o.options.functional))return function(e,r,o,i,a){var s=e.options,c={},u=s.props;if(n(u))for(var l in u)c[l]=Pt(l,u,r||t);else n(o.attrs)&&Ne(c,o.attrs),n(o.props)&&Ne(c,o.props);var f=new Ie(o,c,a,i,e),p=s.render.call(null,f._c,f);if(p instanceof ft)return De(p,o,f.parent,s);if(Array.isArray(p)){for(var d=ce(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=De(d[h],o,f.parent,s);return v}}(o,d,a,s,c);var h=a.on;if(a.on=a.nativeOn,r(o.options.abstract)){var m=a.slot;a={},m&&(a.slot=m)}!function(t){for(var e=t.hook||(t.hook={}),n=0;n<Le.length;n++){var r=Le[n],o=e[r],i=Pe[r];o===i||o&&o._merged||(e[r]=o?Fe(i,o):i)}}(a);var y=o.options.name||l;return new ft("vue-component-"+o.cid+(y?"-"+y:""),a,void 0,void 0,void 0,s,{Ctor:o,propsData:d,listeners:h,tag:l,children:c},p)}}}function Fe(t,e){var n=function(n,r){t(n,r),e(n,r)};return n._merged=!0,n}function Re(t,e,a,s,c,u){return(Array.isArray(a)||o(a))&&(c=s,s=a,a=void 0),r(u)&&(c=2),function(t,e,r,o,a){if(n(r)&&n(r.__ob__))return dt();n(r)&&n(r.is)&&(e=r.is);if(!e)return dt();Array.isArray(o)&&"function"==typeof o[0]&&((r=r||{}).scopedSlots={default:o[0]},o.length=0);2===a?o=ce(o):1===a&&(o=function(t){for(var e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(o));var s,c;if("string"==typeof e){var u;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),s=L.isReservedTag(e)?new ft(L.parsePlatformTagName(e),r,o,void 0,void 0,t):r&&r.pre||!n(u=Nt(t.$options,"components",e))?new ft(e,r,o,void 0,void 0,t):Me(u,r,t,o,e)}else s=Me(e,r,t,o);return Array.isArray(s)?s:n(s)?(n(c)&&Ue(s,c),n(r)&&function(t){i(t.style)&&ee(t.style);i(t.class)&&ee(t.class)}(r),s):dt()}(t,e,a,s,c)}function Ue(t,o,i){if(t.ns=o,"foreignObject"===t.tag&&(o=void 0,i=!0),n(t.children))for(var a=0,s=t.children.length;a<s;a++){var c=t.children[a];n(c.tag)&&(e(c.ns)||r(i)&&"svg"!==c.tag)&&Ue(c,o,i)}}var Ve,Be=null;function He(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),i(t)?e.extend(t):t}function ze(t){return t.isComment&&t.asyncFactory}function We(t){if(Array.isArray(t))for(var e=0;e<t.length;e++){var r=t[e];if(n(r)&&(n(r.componentOptions)||ze(r)))return r}}function qe(t,e){Ve.$on(t,e)}function Ke(t,e){Ve.$off(t,e)}function Xe(t,e){var n=Ve;return function r(){var o=e.apply(null,arguments);null!==o&&n.$off(t,r)}}function Ge(t,e,n){Ve=t,ie(e,n||{},qe,Ke,Xe,t),Ve=void 0}var Ze=null;function Je(t){var e=Ze;return Ze=t,function(){Ze=e}}function Qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ye(t,e){if(e){if(t._directInactive=!1,Qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)Ye(t.$children[n]);en(t,"activated")}}function tn(t,e){if(!(e&&(t._directInactive=!0,Qe(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)tn(t.$children[n]);en(t,"deactivated")}}function en(t,e){ut();var n=t.$options[e],r=e+" hook";if(n)for(var o=0,i=n.length;o<i;o++)Vt(n[o],t,null,t,r);t._hasHookEvent&&t.$emit("hook:"+e),lt()}var nn=[],rn=[],on={},an=!1,sn=!1,cn=0;var un=0,ln=Date.now;if(V&&!W){var fn=window.performance;fn&&"function"==typeof fn.now&&ln()>document.createEvent("Event").timeStamp&&(ln=function(){return fn.now()})}function pn(){var t,e;for(un=ln(),sn=!0,nn.sort((function(t,e){return t.id-e.id})),cn=0;cn<nn.length;cn++)(t=nn[cn]).before&&t.before(),e=t.id,on[e]=null,t.run();var n=rn.slice(),r=nn.slice();cn=nn.length=rn.length=0,on={},an=sn=!1,function(t){for(var e=0;e<t.length;e++)t[e]._inactive=!0,Ye(t[e],!0)}(n),function(t){var e=t.length;for(;e--;){var n=t[e],r=n.vm;r._watcher===n&&r._isMounted&&!r._isDestroyed&&en(r,"updated")}}(r),et&&L.devtools&&et.emit("flush")}var dn=0,vn=function(t,e,n,r,o){this.vm=t,o&&(t._watcher=this),t._watchers.push(this),r?(this.deep=!!r.deep,this.user=!!r.user,this.lazy=!!r.lazy,this.sync=!!r.sync,this.before=r.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++dn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(!R.test(t)){var e=t.split(".");return function(t){for(var n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}}(e),this.getter||(this.getter=k)),this.value=this.lazy?void 0:this.get()};vn.prototype.get=function(){var t;ut(this);var e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ut(t,e,'getter for watcher "'+this.expression+'"')}finally{this.deep&&ee(t),lt(),this.cleanupDeps()}return t},vn.prototype.addDep=function(t){var e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))},vn.prototype.cleanupDeps=function(){for(var t=this.deps.length;t--;){var e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}var n=this.depIds;this.depIds=this.newDepIds,this.newDepIds=n,this.newDepIds.clear(),n=this.deps,this.deps=this.newDeps,this.newDeps=n,this.newDeps.length=0},vn.prototype.update=function(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){var e=t.id;if(null==on[e]){if(on[e]=!0,sn){for(var n=nn.length-1;n>cn&&nn[n].id>t.id;)n--;nn.splice(n+1,0,t)}else nn.push(t);an||(an=!0,Yt(pn))}}(this)},vn.prototype.run=function(){if(this.active){var t=this.get();if(t!==this.value||i(t)||this.deep){var e=this.value;if(this.value=t,this.user)try{this.cb.call(this.vm,t,e)}catch(t){Ut(t,this.vm,'callback for watcher "'+this.expression+'"')}else this.cb.call(this.vm,t,e)}}},vn.prototype.evaluate=function(){this.value=this.get(),this.dirty=!1},vn.prototype.depend=function(){for(var t=this.deps.length;t--;)this.deps[t].depend()},vn.prototype.teardown=function(){if(this.active){this.vm._isBeingDestroyed||v(this.vm._watchers,this);for(var t=this.deps.length;t--;)this.deps[t].removeSub(this);this.active=!1}};var hn={enumerable:!0,configurable:!0,get:k,set:k};function mn(t,e,n){hn.get=function(){return this[e][n]},hn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,hn)}function yn(t){t._watchers=[];var e=t.$options;e.props&&function(t,e){var n=t.$options.propsData||{},r=t._props={},o=t.$options._propKeys=[];t.$parent&&bt(!1);var i=function(i){o.push(i);var a=Pt(i,e,n,t);wt(r,i,a),i in t||mn(t,"_props",i)};for(var a in e)i(a);bt(!0)}(t,e.props),e.methods&&function(t,e){for(var n in t.$options.props,e)t[n]="function"!=typeof e[n]?k:w(e[n],t)}(t,e.methods),e.data?function(t){var e=t.$options.data;s(e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Ut(t,e,"data()"),{}}finally{lt()}}(e,t):e||{})||(e={});var n=Object.keys(e),r=t.$options.props;t.$options.methods;var o=n.length;for(;o--;){var i=n[o];r&&m(r,i)||M(i)||mn(t,"_data",i)}$t(e,!0)}(t):$t(t._data={},!0),e.computed&&function(t,e){var n=t._computedWatchers=Object.create(null),r=tt();for(var o in e){var i=e[o],a="function"==typeof i?i:i.get;r||(n[o]=new vn(t,a||k,k,gn)),o in t||_n(t,o,i)}}(t,e.computed),e.watch&&e.watch!==J&&function(t,e){for(var n in e){var r=e[n];if(Array.isArray(r))for(var o=0;o<r.length;o++)$n(t,n,r[o]);else $n(t,n,r)}}(t,e.watch)}var gn={lazy:!0};function _n(t,e,n){var r=!tt();"function"==typeof n?(hn.get=r?bn(e):Cn(n),hn.set=k):(hn.get=n.get?r&&!1!==n.cache?bn(e):Cn(n.get):k,hn.set=n.set||k),Object.defineProperty(t,e,hn)}function bn(t){return function(){var e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),st.target&&e.depend(),e.value}}function Cn(t){return function(){return t.call(this,this)}}function $n(t,e,n,r){return s(n)&&(r=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,r)}var wn=0;function An(t){var e=t.options;if(t.super){var n=An(t.super);if(n!==t.superOptions){t.superOptions=n;var r=function(t){var e,n=t.options,r=t.sealedOptions;for(var o in n)n[o]!==r[o]&&(e||(e={}),e[o]=n[o]);return e}(t);r&&x(t.extendOptions,r),(e=t.options=Dt(n,t.extendOptions)).name&&(e.components[e.name]=t)}}return e}function xn(t){this._init(t)}function On(t){t.cid=0;var e=1;t.extend=function(t){t=t||{};var n=this,r=n.cid,o=t._Ctor||(t._Ctor={});if(o[r])return o[r];var i=t.name||n.options.name,a=function(t){this._init(t)};return(a.prototype=Object.create(n.prototype)).constructor=a,a.cid=e++,a.options=Dt(n.options,t),a.super=n,a.options.props&&function(t){var e=t.options.props;for(var n in e)mn(t.prototype,"_props",n)}(a),a.options.computed&&function(t){var e=t.options.computed;for(var n in e)_n(t.prototype,n,e[n])}(a),a.extend=n.extend,a.mixin=n.mixin,a.use=n.use,N.forEach((function(t){a[t]=n[t]})),i&&(a.options.components[i]=a),a.superOptions=n.options,a.extendOptions=t,a.sealedOptions=x({},a.options),o[r]=a,a}}function kn(t){return t&&(t.Ctor.options.name||t.tag)}function Sn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===a.call(n)&&t.test(e));var n}function En(t,e){var n=t.cache,r=t.keys,o=t._vnode;for(var i in n){var a=n[i];if(a){var s=kn(a.componentOptions);s&&!e(s)&&jn(n,i,r,o)}}}function jn(t,e,n,r){var o=t[e];!o||r&&o.tag===r.tag||o.componentInstance.$destroy(),t[e]=null,v(n,e)}!function(e){e.prototype._init=function(e){var n=this;n._uid=wn++,n._isVue=!0,e&&e._isComponent?function(t,e){var n=t.$options=Object.create(t.constructor.options),r=e._parentVnode;n.parent=e.parent,n._parentVnode=r;var o=r.componentOptions;n.propsData=o.propsData,n._parentListeners=o.listeners,n._renderChildren=o.children,n._componentTag=o.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Dt(An(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){var e=t.$options,n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;var e=t.$options._parentListeners;e&&Ge(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;var n=e.$options,r=e.$vnode=n._parentVnode,o=r&&r.context;e.$slots=pe(n._renderChildren,o),e.$scopedSlots=t,e._c=function(t,n,r,o){return Re(e,t,n,r,o,!1)},e.$createElement=function(t,n,r,o){return Re(e,t,n,r,o,!0)};var i=r&&r.data;wt(e,"$attrs",i&&i.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),en(n,"beforeCreate"),function(t){var e=fe(t.$options.inject,t);e&&(bt(!1),Object.keys(e).forEach((function(n){wt(t,n,e[n])})),bt(!0))}(n),yn(n),function(t){var e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),en(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(xn),function(t){var e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=At,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){var r=this;if(s(e))return $n(r,t,e,n);(n=n||{}).user=!0;var o=new vn(r,t,e,n);if(n.immediate){ut();try{e.call(r,o.value)}catch(t){Ut(t,r,'callback for immediate watcher "'+o.expression+'"')}lt()}return function(){o.teardown()}}}(xn),function(t){var e=/^hook:/;t.prototype.$on=function(t,n){var r=this;if(Array.isArray(t))for(var o=0,i=t.length;o<i;o++)r.$on(t[o],n);else(r._events[t]||(r._events[t]=[])).push(n),e.test(t)&&(r._hasHookEvent=!0);return r},t.prototype.$once=function(t,e){var n=this;function r(){n.$off(t,r),e.apply(n,arguments)}return r.fn=e,n.$on(t,r),n},t.prototype.$off=function(t,e){var n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(var r=0,o=t.length;r<o;r++)n.$off(t[r],e);return n}var i,a=n._events[t];if(!a)return n;if(!e)return n._events[t]=null,n;for(var s=a.length;s--;)if((i=a[s])===e||i.fn===e){a.splice(s,1);break}return n},t.prototype.$emit=function(t){var e=this,n=e._events[t];if(n){n=n.length>1?A(n):n;for(var r=A(arguments,1),o='event handler for "'+t+'"',i=0,a=n.length;i<a;i++)Vt(n[i],e,r,e,o)}return e}}(xn),function(t){t.prototype._update=function(t,e){var n=this,r=n.$el,o=n._vnode,i=Je(n);n._vnode=t,n.$el=o?n.__patch__(o,t):n.__patch__(n.$el,t,e,!1),i(),r&&(r.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){this._watcher&&this._watcher.update()},t.prototype.$destroy=function(){var t=this;if(!t._isBeingDestroyed){en(t,"beforeDestroy"),t._isBeingDestroyed=!0;var e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||v(e.$children,t),t._watcher&&t._watcher.teardown();for(var n=t._watchers.length;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),en(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}}(xn),function(t){Te(t.prototype),t.prototype.$nextTick=function(t){return Yt(t,this)},t.prototype._render=function(){var t,e=this,n=e.$options,r=n.render,o=n._parentVnode;o&&(e.$scopedSlots=ve(o.data.scopedSlots,e.$slots,e.$scopedSlots)),e.$vnode=o;try{Be=e,t=r.call(e._renderProxy,e.$createElement)}catch(n){Ut(n,e,"render"),t=e._vnode}finally{Be=null}return Array.isArray(t)&&1===t.length&&(t=t[0]),t instanceof ft||(t=dt()),t.parent=o,t}}(xn);var Tn=[String,RegExp,Array],In={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:Tn,exclude:Tn,max:[String,Number]},created:function(){this.cache=Object.create(null),this.keys=[]},destroyed:function(){for(var t in this.cache)jn(this.cache,t,this.keys)},mounted:function(){var t=this;this.$watch("include",(function(e){En(t,(function(t){return Sn(e,t)}))})),this.$watch("exclude",(function(e){En(t,(function(t){return!Sn(e,t)}))}))},render:function(){var t=this.$slots.default,e=We(t),n=e&&e.componentOptions;if(n){var r=kn(n),o=this.include,i=this.exclude;if(o&&(!r||!Sn(o,r))||i&&r&&Sn(i,r))return e;var a=this.cache,s=this.keys,c=null==e.key?n.Ctor.cid+(n.tag?"::"+n.tag:""):e.key;a[c]?(e.componentInstance=a[c].componentInstance,v(s,c),s.push(c)):(a[c]=e,s.push(c),this.max&&s.length>parseInt(this.max)&&jn(a,s[0],s,this._vnode)),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){var e={get:function(){return L}};Object.defineProperty(t,"config",e),t.util={warn:it,extend:x,mergeOptions:Dt,defineReactive:wt},t.set=At,t.delete=xt,t.nextTick=Yt,t.observable=function(t){return $t(t),t},t.options=Object.create(null),N.forEach((function(e){t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,In),function(t){t.use=function(t){var e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;var n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Dt(this.options,t),this}}(t),On(t),function(t){N.forEach((function(e){t[e]=function(t,n){return n?("component"===e&&s(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(xn),Object.defineProperty(xn.prototype,"$isServer",{get:tt}),Object.defineProperty(xn.prototype,"$ssrContext",{get:function(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(xn,"FunctionalRenderContext",{value:Ie}),xn.version="2.6.12";var Dn=p("style,class"),Nn=p("input,textarea,option,select,progress"),Pn=p("contenteditable,draggable,spellcheck"),Ln=p("events,caret,typing,plaintext-only"),Mn=p("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Fn="http://www.w3.org/1999/xlink",Rn=function(t){return":"===t.charAt(5)&&"xlink"===t.slice(0,5)},Un=function(t){return Rn(t)?t.slice(6,t.length):""},Vn=function(t){return null==t||!1===t};function Bn(t){for(var e=t.data,r=t,o=t;n(o.componentInstance);)(o=o.componentInstance._vnode)&&o.data&&(e=Hn(o.data,e));for(;n(r=r.parent);)r&&r.data&&(e=Hn(e,r.data));return function(t,e){if(n(t)||n(e))return zn(t,Wn(e));return""}(e.staticClass,e.class)}function Hn(t,e){return{staticClass:zn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function zn(t,e){return t?e?t+" "+e:t:e||""}function Wn(t){return Array.isArray(t)?function(t){for(var e,r="",o=0,i=t.length;o<i;o++)n(e=Wn(t[o]))&&""!==e&&(r&&(r+=" "),r+=e);return r}(t):i(t)?function(t){var e="";for(var n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}var qn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Kn=p("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Xn=p("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Gn=function(t){return Kn(t)||Xn(t)};var Zn=Object.create(null);var Jn=p("text,number,password,search,email,tel,url");var Qn=Object.freeze({__proto__:null,createElement:function(t,e){var n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(qn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Yn={create:function(t,e){tr(e)},update:function(t,e){t.data.ref!==e.data.ref&&(tr(t,!0),tr(e))},destroy:function(t){tr(t,!0)}};function tr(t,e){var r=t.data.ref;if(n(r)){var o=t.context,i=t.componentInstance||t.elm,a=o.$refs;e?Array.isArray(a[r])?v(a[r],i):a[r]===i&&(a[r]=void 0):t.data.refInFor?Array.isArray(a[r])?a[r].indexOf(i)<0&&a[r].push(i):a[r]=[i]:a[r]=i}}var er=new ft("",{},[]),nr=["create","activate","update","remove","destroy"];function rr(t,o){return t.key===o.key&&(t.tag===o.tag&&t.isComment===o.isComment&&n(t.data)===n(o.data)&&function(t,e){if("input"!==t.tag)return!0;var r,o=n(r=t.data)&&n(r=r.attrs)&&r.type,i=n(r=e.data)&&n(r=r.attrs)&&r.type;return o===i||Jn(o)&&Jn(i)}(t,o)||r(t.isAsyncPlaceholder)&&t.asyncFactory===o.asyncFactory&&e(o.asyncFactory.error))}function or(t,e,r){var o,i,a={};for(o=e;o<=r;++o)n(i=t[o].key)&&(a[i]=o);return a}var ir={create:ar,update:ar,destroy:function(t){ar(t,er)}};function ar(t,e){(t.data.directives||e.data.directives)&&function(t,e){var n,r,o,i=t===er,a=e===er,s=cr(t.data.directives,t.context),c=cr(e.data.directives,e.context),u=[],l=[];for(n in c)r=s[n],o=c[n],r?(o.oldValue=r.value,o.oldArg=r.arg,lr(o,"update",e,t),o.def&&o.def.componentUpdated&&l.push(o)):(lr(o,"bind",e,t),o.def&&o.def.inserted&&u.push(o));if(u.length){var f=function(){for(var n=0;n<u.length;n++)lr(u[n],"inserted",e,t)};i?ae(e,"insert",f):f()}l.length&&ae(e,"postpatch",(function(){for(var n=0;n<l.length;n++)lr(l[n],"componentUpdated",e,t)}));if(!i)for(n in s)c[n]||lr(s[n],"unbind",t,t,a)}(t,e)}var sr=Object.create(null);function cr(t,e){var n,r,o=Object.create(null);if(!t)return o;for(n=0;n<t.length;n++)(r=t[n]).modifiers||(r.modifiers=sr),o[ur(r)]=r,r.def=Nt(e.$options,"directives",r.name);return o}function ur(t){return t.rawName||t.name+"."+Object.keys(t.modifiers||{}).join(".")}function lr(t,e,n,r,o){var i=t.def&&t.def[e];if(i)try{i(n.elm,t,n,r,o)}catch(r){Ut(r,n.context,"directive "+t.name+" "+e+" hook")}}var fr=[Yn,ir];function pr(t,r){var o=r.componentOptions;if(!(n(o)&&!1===o.Ctor.options.inheritAttrs||e(t.data.attrs)&&e(r.data.attrs))){var i,a,s=r.elm,c=t.data.attrs||{},u=r.data.attrs||{};for(i in n(u.__ob__)&&(u=r.data.attrs=x({},u)),u)a=u[i],c[i]!==a&&dr(s,i,a,r.data.pre);for(i in(W||K)&&u.value!==c.value&&dr(s,"value",u.value),c)e(u[i])&&(Rn(i)?s.removeAttributeNS(Fn,Un(i)):Pn(i)||s.removeAttribute(i))}}function dr(t,e,n,r){r||t.tagName.indexOf("-")>-1?vr(t,e,n):Mn(e)?Vn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Pn(e)?t.setAttribute(e,function(t,e){return Vn(e)||"false"===e?"false":"contenteditable"===t&&Ln(e)?e:"true"}(e,n)):Rn(e)?Vn(n)?t.removeAttributeNS(Fn,Un(e)):t.setAttributeNS(Fn,e,n):vr(t,e,n)}function vr(t,e,n){if(Vn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){var r=function(e){e.stopImmediatePropagation(),t.removeEventListener("input",r)};t.addEventListener("input",r),t.__ieph=!0}t.setAttribute(e,n)}}var hr={create:pr,update:pr};function mr(t,r){var o=r.elm,i=r.data,a=t.data;if(!(e(i.staticClass)&&e(i.class)&&(e(a)||e(a.staticClass)&&e(a.class)))){var s=Bn(r),c=o._transitionClasses;n(c)&&(s=zn(s,Wn(c))),s!==o._prevClass&&(o.setAttribute("class",s),o._prevClass=s)}}var yr,gr={create:mr,update:mr};function _r(t,e,n){var r=yr;return function o(){var i=e.apply(null,arguments);null!==i&&$r(t,o,n,r)}}var br=Wt&&!(Z&&Number(Z[1])<=53);function Cr(t,e,n,r){if(br){var o=un,i=e;e=i._wrapper=function(t){if(t.target===t.currentTarget||t.timeStamp>=o||t.timeStamp<=0||t.target.ownerDocument!==document)return i.apply(this,arguments)}}yr.addEventListener(t,e,Q?{capture:n,passive:r}:n)}function $r(t,e,n,r){(r||yr).removeEventListener(t,e._wrapper||e,n)}function wr(t,r){if(!e(t.data.on)||!e(r.data.on)){var o=r.data.on||{},i=t.data.on||{};yr=r.elm,function(t){if(n(t.__r)){var e=W?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(o),ie(o,i,Cr,$r,_r,r.context),yr=void 0}}var Ar,xr={create:wr,update:wr};function Or(t,r){if(!e(t.data.domProps)||!e(r.data.domProps)){var o,i,a=r.elm,s=t.data.domProps||{},c=r.data.domProps||{};for(o in n(c.__ob__)&&(c=r.data.domProps=x({},c)),s)o in c||(a[o]="");for(o in c){if(i=c[o],"textContent"===o||"innerHTML"===o){if(r.children&&(r.children.length=0),i===s[o])continue;1===a.childNodes.length&&a.removeChild(a.childNodes[0])}if("value"===o&&"PROGRESS"!==a.tagName){a._value=i;var u=e(i)?"":String(i);kr(a,u)&&(a.value=u)}else if("innerHTML"===o&&Xn(a.tagName)&&e(a.innerHTML)){(Ar=Ar||document.createElement("div")).innerHTML="<svg>"+i+"</svg>";for(var l=Ar.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;l.firstChild;)a.appendChild(l.firstChild)}else if(i!==s[o])try{a[o]=i}catch(t){}}}}function kr(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){var n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){var r=t.value,o=t._vModifiers;if(n(o)){if(o.number)return f(r)!==f(e);if(o.trim)return r.trim()!==e.trim()}return r!==e}(t,e))}var Sr={create:Or,update:Or},Er=y((function(t){var e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){var r=t.split(n);r.length>1&&(e[r[0].trim()]=r[1].trim())}})),e}));function jr(t){var e=Tr(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Tr(t){return Array.isArray(t)?O(t):"string"==typeof t?Er(t):t}var Ir,Dr=/^--/,Nr=/\s*!important$/,Pr=function(t,e,n){if(Dr.test(e))t.style.setProperty(e,n);else if(Nr.test(n))t.style.setProperty($(e),n.replace(Nr,""),"important");else{var r=Mr(e);if(Array.isArray(n))for(var o=0,i=n.length;o<i;o++)t.style[r]=n[o];else t.style[r]=n}},Lr=["Webkit","Moz","ms"],Mr=y((function(t){if(Ir=Ir||document.createElement("div").style,"filter"!==(t=_(t))&&t in Ir)return t;for(var e=t.charAt(0).toUpperCase()+t.slice(1),n=0;n<Lr.length;n++){var r=Lr[n]+e;if(r in Ir)return r}}));function Fr(t,r){var o=r.data,i=t.data;if(!(e(o.staticStyle)&&e(o.style)&&e(i.staticStyle)&&e(i.style))){var a,s,c=r.elm,u=i.staticStyle,l=i.normalizedStyle||i.style||{},f=u||l,p=Tr(r.data.style)||{};r.data.normalizedStyle=n(p.__ob__)?x({},p):p;var d=function(t,e){var n,r={};if(e)for(var o=t;o.componentInstance;)(o=o.componentInstance._vnode)&&o.data&&(n=jr(o.data))&&x(r,n);(n=jr(t.data))&&x(r,n);for(var i=t;i=i.parent;)i.data&&(n=jr(i.data))&&x(r,n);return r}(r,!0);for(s in f)e(d[s])&&Pr(c,s,"");for(s in d)(a=d[s])!==f[s]&&Pr(c,s,null==a?"":a)}}var Rr={create:Fr,update:Fr},Ur=/\s+/;function Vr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.add(e)})):t.classList.add(e);else{var n=" "+(t.getAttribute("class")||"")+" ";n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Br(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Ur).forEach((function(e){return t.classList.remove(e)})):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{for(var n=" "+(t.getAttribute("class")||"")+" ",r=" "+e+" ";n.indexOf(r)>=0;)n=n.replace(r," ");(n=n.trim())?t.setAttribute("class",n):t.removeAttribute("class")}}function Hr(t){if(t){if("object"==typeof t){var e={};return!1!==t.css&&x(e,zr(t.name||"v")),x(e,t),e}return"string"==typeof t?zr(t):void 0}}var zr=y((function(t){return{enterClass:t+"-enter",enterToClass:t+"-enter-to",enterActiveClass:t+"-enter-active",leaveClass:t+"-leave",leaveToClass:t+"-leave-to",leaveActiveClass:t+"-leave-active"}})),Wr=V&&!q,qr="transition",Kr="animation",Xr="transition",Gr="transitionend",Zr="animation",Jr="animationend";Wr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Xr="WebkitTransition",Gr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Zr="WebkitAnimation",Jr="webkitAnimationEnd"));var Qr=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:function(t){return t()};function Yr(t){Qr((function(){Qr(t)}))}function to(t,e){var n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Vr(t,e))}function eo(t,e){t._transitionClasses&&v(t._transitionClasses,e),Br(t,e)}function no(t,e,n){var r=oo(t,e),o=r.type,i=r.timeout,a=r.propCount;if(!o)return n();var s=o===qr?Gr:Jr,c=0,u=function(){t.removeEventListener(s,l),n()},l=function(e){e.target===t&&++c>=a&&u()};setTimeout((function(){c<a&&u()}),i+1),t.addEventListener(s,l)}var ro=/\b(transform|all)(,|$)/;function oo(t,e){var n,r=window.getComputedStyle(t),o=(r[Xr+"Delay"]||"").split(", "),i=(r[Xr+"Duration"]||"").split(", "),a=io(o,i),s=(r[Zr+"Delay"]||"").split(", "),c=(r[Zr+"Duration"]||"").split(", "),u=io(s,c),l=0,f=0;return e===qr?a>0&&(n=qr,l=a,f=i.length):e===Kr?u>0&&(n=Kr,l=u,f=c.length):f=(n=(l=Math.max(a,u))>0?a>u?qr:Kr:null)?n===qr?i.length:c.length:0,{type:n,timeout:l,propCount:f,hasTransform:n===qr&&ro.test(r[Xr+"Property"])}}function io(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map((function(e,n){return ao(e)+ao(t[n])})))}function ao(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function so(t,r){var o=t.elm;n(o._leaveCb)&&(o._leaveCb.cancelled=!0,o._leaveCb());var a=Hr(t.data.transition);if(!e(a)&&!n(o._enterCb)&&1===o.nodeType){for(var s=a.css,c=a.type,u=a.enterClass,l=a.enterToClass,p=a.enterActiveClass,d=a.appearClass,v=a.appearToClass,h=a.appearActiveClass,m=a.beforeEnter,y=a.enter,g=a.afterEnter,_=a.enterCancelled,b=a.beforeAppear,C=a.appear,$=a.afterAppear,w=a.appearCancelled,A=a.duration,x=Ze,O=Ze.$vnode;O&&O.parent;)x=O.context,O=O.parent;var k=!x._isMounted||!t.isRootInsert;if(!k||C||""===C){var S=k&&d?d:u,E=k&&h?h:p,j=k&&v?v:l,T=k&&b||m,D=k&&"function"==typeof C?C:y,N=k&&$||g,P=k&&w||_,L=f(i(A)?A.enter:A),M=!1!==s&&!q,F=lo(D),R=o._enterCb=I((function(){M&&(eo(o,j),eo(o,E)),R.cancelled?(M&&eo(o,S),P&&P(o)):N&&N(o),o._enterCb=null}));t.data.show||ae(t,"insert",(function(){var e=o.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(o,R)})),T&&T(o),M&&(to(o,S),to(o,E),Yr((function(){eo(o,S),R.cancelled||(to(o,j),F||(uo(L)?setTimeout(R,L):no(o,c,R)))}))),t.data.show&&(r&&r(),D&&D(o,R)),M||F||R()}}}function co(t,r){var o=t.elm;n(o._enterCb)&&(o._enterCb.cancelled=!0,o._enterCb());var a=Hr(t.data.transition);if(e(a)||1!==o.nodeType)return r();if(!n(o._leaveCb)){var s=a.css,c=a.type,u=a.leaveClass,l=a.leaveToClass,p=a.leaveActiveClass,d=a.beforeLeave,v=a.leave,h=a.afterLeave,m=a.leaveCancelled,y=a.delayLeave,g=a.duration,_=!1!==s&&!q,b=lo(v),C=f(i(g)?g.leave:g),$=o._leaveCb=I((function(){o.parentNode&&o.parentNode._pending&&(o.parentNode._pending[t.key]=null),_&&(eo(o,l),eo(o,p)),$.cancelled?(_&&eo(o,u),m&&m(o)):(r(),h&&h(o)),o._leaveCb=null}));y?y(w):w()}function w(){$.cancelled||(!t.data.show&&o.parentNode&&((o.parentNode._pending||(o.parentNode._pending={}))[t.key]=t),d&&d(o),_&&(to(o,u),to(o,p),Yr((function(){eo(o,u),$.cancelled||(to(o,l),b||(uo(C)?setTimeout($,C):no(o,c,$)))}))),v&&v(o,$),_||b||$())}}function uo(t){return"number"==typeof t&&!isNaN(t)}function lo(t){if(e(t))return!1;var r=t.fns;return n(r)?lo(Array.isArray(r)?r[0]:r):(t._length||t.length)>1}function fo(t,e){!0!==e.data.show&&so(e)}var po=function(t){var i,a,s={},c=t.modules,u=t.nodeOps;for(i=0;i<nr.length;++i)for(s[nr[i]]=[],a=0;a<c.length;++a)n(c[a][nr[i]])&&s[nr[i]].push(c[a][nr[i]]);function l(t){var e=u.parentNode(t);n(e)&&u.removeChild(e,t)}function f(t,e,o,i,a,c,l){if(n(t.elm)&&n(c)&&(t=c[l]=ht(t)),t.isRootInsert=!a,!function(t,e,o,i){var a=t.data;if(n(a)){var c=n(t.componentInstance)&&a.keepAlive;if(n(a=a.hook)&&n(a=a.init)&&a(t,!1),n(t.componentInstance))return d(t,e),v(o,t.elm,i),r(c)&&function(t,e,r,o){var i,a=t;for(;a.componentInstance;)if(n(i=(a=a.componentInstance._vnode).data)&&n(i=i.transition)){for(i=0;i<s.activate.length;++i)s.activate[i](er,a);e.push(a);break}v(r,t.elm,o)}(t,e,o,i),!0}}(t,e,o,i)){var f=t.data,p=t.children,m=t.tag;n(m)?(t.elm=t.ns?u.createElementNS(t.ns,m):u.createElement(m,t),g(t),h(t,p,e),n(f)&&y(t,e),v(o,t.elm,i)):r(t.isComment)?(t.elm=u.createComment(t.text),v(o,t.elm,i)):(t.elm=u.createTextNode(t.text),v(o,t.elm,i))}}function d(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,m(t)?(y(t,e),g(t)):(tr(t),e.push(t))}function v(t,e,r){n(t)&&(n(r)?u.parentNode(r)===t&&u.insertBefore(t,e,r):u.appendChild(t,e))}function h(t,e,n){if(Array.isArray(e))for(var r=0;r<e.length;++r)f(e[r],n,t.elm,null,!0,e,r);else o(t.text)&&u.appendChild(t.elm,u.createTextNode(String(t.text)))}function m(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function y(t,e){for(var r=0;r<s.create.length;++r)s.create[r](er,t);n(i=t.data.hook)&&(n(i.create)&&i.create(er,t),n(i.insert)&&e.push(t))}function g(t){var e;if(n(e=t.fnScopeId))u.setStyleScope(t.elm,e);else for(var r=t;r;)n(e=r.context)&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e),r=r.parent;n(e=Ze)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&u.setStyleScope(t.elm,e)}function _(t,e,n,r,o,i){for(;r<=o;++r)f(n[r],i,t,e,!1,n,r)}function b(t){var e,r,o=t.data;if(n(o))for(n(e=o.hook)&&n(e=e.destroy)&&e(t),e=0;e<s.destroy.length;++e)s.destroy[e](t);if(n(e=t.children))for(r=0;r<t.children.length;++r)b(t.children[r])}function C(t,e,r){for(;e<=r;++e){var o=t[e];n(o)&&(n(o.tag)?($(o),b(o)):l(o.elm))}}function $(t,e){if(n(e)||n(t.data)){var r,o=s.remove.length+1;for(n(e)?e.listeners+=o:e=function(t,e){function n(){0==--n.listeners&&l(t)}return n.listeners=e,n}(t.elm,o),n(r=t.componentInstance)&&n(r=r._vnode)&&n(r.data)&&$(r,e),r=0;r<s.remove.length;++r)s.remove[r](t,e);n(r=t.data.hook)&&n(r=r.remove)?r(t,e):e()}else l(t.elm)}function w(t,e,r,o){for(var i=r;i<o;i++){var a=e[i];if(n(a)&&rr(t,a))return i}}function A(t,o,i,a,c,l){if(t!==o){n(o.elm)&&n(a)&&(o=a[c]=ht(o));var p=o.elm=t.elm;if(r(t.isAsyncPlaceholder))n(o.asyncFactory.resolved)?k(t.elm,o,i):o.isAsyncPlaceholder=!0;else if(r(o.isStatic)&&r(t.isStatic)&&o.key===t.key&&(r(o.isCloned)||r(o.isOnce)))o.componentInstance=t.componentInstance;else{var d,v=o.data;n(v)&&n(d=v.hook)&&n(d=d.prepatch)&&d(t,o);var h=t.children,y=o.children;if(n(v)&&m(o)){for(d=0;d<s.update.length;++d)s.update[d](t,o);n(d=v.hook)&&n(d=d.update)&&d(t,o)}e(o.text)?n(h)&&n(y)?h!==y&&function(t,r,o,i,a){for(var s,c,l,p=0,d=0,v=r.length-1,h=r[0],m=r[v],y=o.length-1,g=o[0],b=o[y],$=!a;p<=v&&d<=y;)e(h)?h=r[++p]:e(m)?m=r[--v]:rr(h,g)?(A(h,g,i,o,d),h=r[++p],g=o[++d]):rr(m,b)?(A(m,b,i,o,y),m=r[--v],b=o[--y]):rr(h,b)?(A(h,b,i,o,y),$&&u.insertBefore(t,h.elm,u.nextSibling(m.elm)),h=r[++p],b=o[--y]):rr(m,g)?(A(m,g,i,o,d),$&&u.insertBefore(t,m.elm,h.elm),m=r[--v],g=o[++d]):(e(s)&&(s=or(r,p,v)),e(c=n(g.key)?s[g.key]:w(g,r,p,v))?f(g,i,t,h.elm,!1,o,d):rr(l=r[c],g)?(A(l,g,i,o,d),r[c]=void 0,$&&u.insertBefore(t,l.elm,h.elm)):f(g,i,t,h.elm,!1,o,d),g=o[++d]);p>v?_(t,e(o[y+1])?null:o[y+1].elm,o,d,y,i):d>y&&C(r,p,v)}(p,h,y,i,l):n(y)?(n(t.text)&&u.setTextContent(p,""),_(p,null,y,0,y.length-1,i)):n(h)?C(h,0,h.length-1):n(t.text)&&u.setTextContent(p,""):t.text!==o.text&&u.setTextContent(p,o.text),n(v)&&n(d=v.hook)&&n(d=d.postpatch)&&d(t,o)}}}function x(t,e,o){if(r(o)&&n(t.parent))t.parent.data.pendingInsert=e;else for(var i=0;i<e.length;++i)e[i].data.hook.insert(e[i])}var O=p("attrs,class,staticClass,staticStyle,key");function k(t,e,o,i){var a,s=e.tag,c=e.data,u=e.children;if(i=i||c&&c.pre,e.elm=t,r(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(a=c.hook)&&n(a=a.init)&&a(e,!0),n(a=e.componentInstance)))return d(e,o),!0;if(n(s)){if(n(u))if(t.hasChildNodes())if(n(a=c)&&n(a=a.domProps)&&n(a=a.innerHTML)){if(a!==t.innerHTML)return!1}else{for(var l=!0,f=t.firstChild,p=0;p<u.length;p++){if(!f||!k(f,u[p],o,i)){l=!1;break}f=f.nextSibling}if(!l||f)return!1}else h(e,u,o);if(n(c)){var v=!1;for(var m in c)if(!O(m)){v=!0,y(e,o);break}!v&&c.class&&ee(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,o,i,a){if(!e(o)){var c,l=!1,p=[];if(e(t))l=!0,f(o,p);else{var d=n(t.nodeType);if(!d&&rr(t,o))A(t,o,p,null,null,a);else{if(d){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),i=!0),r(i)&&k(t,o,p))return x(o,p,!0),t;c=t,t=new ft(u.tagName(c).toLowerCase(),{},[],void 0,c)}var v=t.elm,h=u.parentNode(v);if(f(o,p,v._leaveCb?null:h,u.nextSibling(v)),n(o.parent))for(var y=o.parent,g=m(o);y;){for(var _=0;_<s.destroy.length;++_)s.destroy[_](y);if(y.elm=o.elm,g){for(var $=0;$<s.create.length;++$)s.create[$](er,y);var w=y.data.hook.insert;if(w.merged)for(var O=1;O<w.fns.length;O++)w.fns[O]()}else tr(y);y=y.parent}n(h)?C([t],0,0):n(t.tag)&&b(t)}}return x(o,p,l),o.elm}n(t)&&b(t)}}({nodeOps:Qn,modules:[hr,gr,xr,Sr,Rr,V?{create:fo,activate:fo,remove:function(t,e){!0!==t.data.show?co(t,e):e()}}:{}].concat(fr)});q&&document.addEventListener("selectionchange",(function(){var t=document.activeElement;t&&t.vmodel&&Co(t,"input")}));var vo={inserted:function(t,e,n,r){"select"===n.tag?(r.elm&&!r.elm._vOptions?ae(n,"postpatch",(function(){vo.componentUpdated(t,e,n)})):ho(t,e,n.context),t._vOptions=[].map.call(t.options,go)):("textarea"===n.tag||Jn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",_o),t.addEventListener("compositionend",bo),t.addEventListener("change",bo),q&&(t.vmodel=!0)))},componentUpdated:function(t,e,n){if("select"===n.tag){ho(t,e,n.context);var r=t._vOptions,o=t._vOptions=[].map.call(t.options,go);if(o.some((function(t,e){return!j(t,r[e])})))(t.multiple?e.value.some((function(t){return yo(t,o)})):e.value!==e.oldValue&&yo(e.value,o))&&Co(t,"change")}}};function ho(t,e,n){mo(t,e),(W||K)&&setTimeout((function(){mo(t,e)}),0)}function mo(t,e,n){var r=e.value,o=t.multiple;if(!o||Array.isArray(r)){for(var i,a,s=0,c=t.options.length;s<c;s++)if(a=t.options[s],o)i=T(r,go(a))>-1,a.selected!==i&&(a.selected=i);else if(j(go(a),r))return void(t.selectedIndex!==s&&(t.selectedIndex=s));o||(t.selectedIndex=-1)}}function yo(t,e){return e.every((function(e){return!j(e,t)}))}function go(t){return"_value"in t?t._value:t.value}function _o(t){t.target.composing=!0}function bo(t){t.target.composing&&(t.target.composing=!1,Co(t.target,"input"))}function Co(t,e){var n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function $o(t){return!t.componentInstance||t.data&&t.data.transition?t:$o(t.componentInstance._vnode)}var wo={model:vo,show:{bind:function(t,e,n){var r=e.value,o=(n=$o(n)).data&&n.data.transition,i=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;r&&o?(n.data.show=!0,so(n,(function(){t.style.display=i}))):t.style.display=r?i:"none"},update:function(t,e,n){var r=e.value;!r!=!e.oldValue&&((n=$o(n)).data&&n.data.transition?(n.data.show=!0,r?so(n,(function(){t.style.display=t.__vOriginalDisplay})):co(n,(function(){t.style.display="none"}))):t.style.display=r?t.__vOriginalDisplay:"none")},unbind:function(t,e,n,r,o){o||(t.style.display=t.__vOriginalDisplay)}}},Ao={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function xo(t){var e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?xo(We(e.children)):t}function Oo(t){var e={},n=t.$options;for(var r in n.propsData)e[r]=t[r];var o=n._parentListeners;for(var i in o)e[_(i)]=o[i];return e}function ko(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}var So=function(t){return t.tag||ze(t)},Eo=function(t){return"show"===t.name},jo={name:"transition",props:Ao,abstract:!0,render:function(t){var e=this,n=this.$slots.default;if(n&&(n=n.filter(So)).length){var r=this.mode,i=n[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return i;var a=xo(i);if(!a)return i;if(this._leaving)return ko(t,i);var s="__transition-"+this._uid+"-";a.key=null==a.key?a.isComment?s+"comment":s+a.tag:o(a.key)?0===String(a.key).indexOf(s)?a.key:s+a.key:a.key;var c=(a.data||(a.data={})).transition=Oo(this),u=this._vnode,l=xo(u);if(a.data.directives&&a.data.directives.some(Eo)&&(a.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(a,l)&&!ze(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){var f=l.data.transition=x({},c);if("out-in"===r)return this._leaving=!0,ae(f,"afterLeave",(function(){e._leaving=!1,e.$forceUpdate()})),ko(t,i);if("in-out"===r){if(ze(a))return u;var p,d=function(){p()};ae(c,"afterEnter",d),ae(c,"enterCancelled",d),ae(f,"delayLeave",(function(t){p=t}))}}return i}}},To=x({tag:String,moveClass:String},Ao);function Io(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Do(t){t.data.newPos=t.elm.getBoundingClientRect()}function No(t){var e=t.data.pos,n=t.data.newPos,r=e.left-n.left,o=e.top-n.top;if(r||o){t.data.moved=!0;var i=t.elm.style;i.transform=i.WebkitTransform="translate("+r+"px,"+o+"px)",i.transitionDuration="0s"}}delete To.mode;var Po={Transition:jo,TransitionGroup:{props:To,beforeMount:function(){var t=this,e=this._update;this._update=function(n,r){var o=Je(t);t.__patch__(t._vnode,t.kept,!1,!0),t._vnode=t.kept,o(),e.call(t,n,r)}},render:function(t){for(var e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),r=this.prevChildren=this.children,o=this.$slots.default||[],i=this.children=[],a=Oo(this),s=0;s<o.length;s++){var c=o[s];c.tag&&null!=c.key&&0!==String(c.key).indexOf("__vlist")&&(i.push(c),n[c.key]=c,(c.data||(c.data={})).transition=a)}if(r){for(var u=[],l=[],f=0;f<r.length;f++){var p=r[f];p.data.transition=a,p.data.pos=p.elm.getBoundingClientRect(),n[p.key]?u.push(p):l.push(p)}this.kept=t(e,null,u),this.removed=l}return t(e,null,i)},updated:function(){var t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(Io),t.forEach(Do),t.forEach(No),this._reflow=document.body.offsetHeight,t.forEach((function(t){if(t.data.moved){var n=t.elm,r=n.style;to(n,e),r.transform=r.WebkitTransform=r.transitionDuration="",n.addEventListener(Gr,n._moveCb=function t(r){r&&r.target!==n||r&&!/transform$/.test(r.propertyName)||(n.removeEventListener(Gr,t),n._moveCb=null,eo(n,e))})}})))},methods:{hasMove:function(t,e){if(!Wr)return!1;if(this._hasMove)return this._hasMove;var n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((function(t){Br(n,t)})),Vr(n,e),n.style.display="none",this.$el.appendChild(n);var r=oo(n);return this.$el.removeChild(n),this._hasMove=r.hasTransform}}}};return xn.config.mustUseProp=function(t,e,n){return"value"===n&&Nn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t},xn.config.isReservedTag=Gn,xn.config.isReservedAttr=Dn,xn.config.getTagNamespace=function(t){return Xn(t)?"svg":"math"===t?"math":void 0},xn.config.isUnknownElement=function(t){if(!V)return!0;if(Gn(t))return!1;if(t=t.toLowerCase(),null!=Zn[t])return Zn[t];var e=document.createElement(t);return t.indexOf("-")>-1?Zn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Zn[t]=/HTMLUnknownElement/.test(e.toString())},x(xn.options.directives,wo),x(xn.options.components,Po),xn.prototype.__patch__=V?po:k,xn.prototype.$mount=function(t,e){return function(t,e,n){var r;return t.$el=e,t.$options.render||(t.$options.render=dt),en(t,"beforeMount"),r=function(){t._update(t._render(),n)},new vn(t,r,k,{before:function(){t._isMounted&&!t._isDestroyed&&en(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,en(t,"mounted")),t}(this,t=t&&V?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},V&&setTimeout((function(){L.devtools&&et&&et.emit("init",xn)}),0),xn}));
\ No newline at end of file
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("key,ref,slot,slot-scope,is");function h(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const m=Object.prototype.hasOwnProperty;function y(t,e){return m.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const g=/-(\w)/g,_=v((t=>t.replace(g,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),$=/\B([A-Z])/g,C=v((t=>t.replace($,"-$1").toLowerCase()));const w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function x(t,e){for(const n in e)t[n]=e[n];return t}function k(t){const e={};for(let n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}const S=(t,e,n)=>!1,T=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function I(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function j(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function F(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const R=new RegExp(`[^${/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source}.$_\\d]`);const V="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=z&&WXEnvironment.platform.toLowerCase(),H=U&&window.navigator.userAgent.toLowerCase(),W=H&&/msie|trident/.test(H),q=H&&H.indexOf("msie 9.0")>0,K=H&&H.indexOf("edge/")>0;H&&H.indexOf("android");const X=H&&/iphone|ipad|ipod|ios/.test(H)||"ios"===B;H&&/chrome\/\d+/.test(H),H&&/phantomjs/.test(H);const G=H&&H.match(/firefox\/(\d+)/),Z={}.watch;let J,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const Y=()=>(void 0===J&&(J=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),J),tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}const nt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);let ot;ot="undefined"!=typeof Set&&et(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let rt=O,st=0;class it{static target;id;subs;constructor(){this.id=st++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){h(this.subs,t)}depend(){it.target&&it.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}it.target=null;const at=[];function ct(t){at.push(t),it.target=t}function lt(){at.pop(),it.target=at[at.length-1]}class ut{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const ft=(t="")=>{const e=new ut;return e.text=t,e.isComment=!0,e};function dt(t){return new ut(void 0,void 0,void 0,String(t))}function pt(t){const e=new ut(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=ht[t];F(mt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const yt=Object.getOwnPropertyNames(mt);let vt=!0;function gt(t){vt=t}class _t{value;dep;vmCount;constructor(t){this.value=t,this.dep=new it,this.vmCount=0,F(t,"__ob__",this),Array.isArray(t)?(V?function(t,e){t.__proto__=e}(t,mt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];F(t,r,e[r])}}(t,mt,yt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)$t(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ut)return;let n;return y(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!Y()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,o,r){const s=new it,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return it.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&At(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?($t(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function wt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||y(t,e)&&(delete t[e],n&&n.dep.notify())}function At(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&At(e)}const xt=L.optionMergeStrategies;function kt(t,e){if(!e)return t;let n,o,r;const s=nt?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],y(t,n)?o!==r&&a(o)&&a(r)&&kt(o,r):Ct(t,n,r));return t}function Ot(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?kt(o,r):r}:e?t?function(){return kt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Tt(t,e,n,o){const r=Object.create(t||null);return e?x(r,e):r}xt.data=function(t,e,n){return n?Ot(t,e,n):e&&"function"!=typeof e?t:Ot(t,e)},P.forEach((t=>{xt[t]=St})),N.forEach((function(t){xt[t+"s"]=Tt})),xt.watch=function(t,e,n,o){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};x(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return x(r,t),e&&x(r,e),r},xt.provide=Ot;const Et=function(t,e){return void 0===e?t:e};function It(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?x({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=It(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=It(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)y(t,r)||s(r);function s(r){const s=xt[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function jt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(y(r,n))return r[n];const s=_(n);if(y(r,s))return r[s];const i=b(s);if(y(r,i))return r[i];return r[n]||r[s]||r[i]}function Dt(t,e,n,o){const r=e[t],s=!y(n,t);let i=n[t];const a=Mt(Boolean,r.type);if(a>-1)if(s&&!y(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Mt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!y(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Pt(e.type)?o.call(t):o}(o,r,t);const e=vt;gt(!0),bt(i),gt(e)}return i}const Nt=/^\s*function (\w+)/;function Pt(t){const e=t&&t.toString().match(Nt);return e?e[1]:""}function Lt(t,e){return Pt(t)===Pt(e)}function Mt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Lt(e[n],t))return n;return-1}function Ft(t,e,n){ct();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Vt(t,o,"errorCaptured hook")}}}Vt(t,e,n)}finally{lt()}}function Rt(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Ft(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Ft(t,o,r)}return s}function Vt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Bt=[];let Ht,Wt=!1;function qt(){Wt=!1;const t=Bt.slice(0);Bt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){const t=Promise.resolve();Ht=()=>{t.then(qt),X&&setTimeout(O)},zt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ht="undefined"!=typeof setImmediate&&et(setImmediate)?()=>{setImmediate(qt)}:()=>{setTimeout(qt,0)};else{let t=1;const e=new MutationObserver(qt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Ht=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Kt(t,e){let n;if(Bt.push((()=>{if(t)try{t.call(e)}catch(t){Ft(t,e,"nextTick")}else n&&n(e)})),Wt||(Wt=!0,Ht()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Xt=new ot;function Gt(t){Zt(t,Xt),Xt.clear()}function Zt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ut)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Zt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Zt(t[o[n]],e)}}const Jt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Rt(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Rt(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function Yt(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Jt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Jt(c),s(f.name,n[c],f.capture))}function te(t,r,s){let i;t instanceof ut&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),h(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ee(t,e,o,r,s){if(n(e)){if(y(e,o))return t[o]=e[o],s||delete e[o],!0;if(y(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function ne(t){return r(t)?[dt(t)]:Array.isArray(t)?re(t):void 0}function oe(t){return n(t)&&n(t.text)&&!1===t.isComment}function re(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=re(c,`${s||""}_${a}`),oe(c[0])&&oe(u)&&(i[l]=dt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?oe(u)?i[l]=dt(u.text+c):""!==c&&i.push(dt(c)):oe(c)&&oe(u)?i[l]=dt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function se(t,e){if(t){const n=Object.create(null),o=nt?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&y(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ie(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ae)&&delete n[t];return n}function ae(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ce(t){return t.isComment&&t.asyncFactory}function le(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ue(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=fe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),F(r,"$stable",i),F(r,"$key",a),F(r,"$hasNormal",s),r}function ue(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ne(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!ce(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function fe(t,e){return()=>t[e]}function de(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(nt&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=x(x({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function he(t){return jt(this.$options,"filters",t)||T}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,o,r){const s=L.keyCodes[e]||n;return r&&o&&!L.keyCodes[e]?me(r,o):s?me(s,t):o?C(o)!==e:void 0===t}function ve(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=k(n));for(const i in n){if("class"===i||"style"===i||p(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||L.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function ge(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),be(o,`__static__${t}`,!1)),o}function _e(t,e,n){return be(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function be(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&$e(t[o],`${e}_${o}`,n);else $e(t,e,n)}function $e(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Ce(t,e){if(e)if(a(e)){const n=t.on=t.on?x({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function we(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?we(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function Ae(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=_e,t._n=f,t._s=u,t._l=de,t._t=pe,t._q=E,t._i=I,t._m=ge,t._f=he,t._k=ye,t._b=ve,t._v=dt,t._e=ft,t._u=we,t._g=Ce,t._d=Ae,t._p=xe}function Oe(e,n,r,s,i){const a=i.options;let c;y(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=se(a.inject,s),this.slots=()=>(this.$slots||le(e.scopedSlots,this.$slots=ie(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Ne(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Ne(c,t,e,n,o,u)}function Se(t,e,n,o,r){const s=pt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Te(t,e){for(const n in e)t[_(n)]=e[n]}ke(Oe.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,He)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){gt(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Dt(s,i,n,e)}gt(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Be(e,o,u),l&&(e.$slots=ie(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ge(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Je.push(o)):Ke(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Xe(e,!0):e.$destroy())}},Ie=Object.keys(Ee);function je(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Me;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>h(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=j((e=>{t.resolved=Fe(e,r),a?o.length=0:f(!0)})),p=j((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),m=t(d,p);return s(m)&&(l(m)?e(t.resolved)&&m.then(d,p):l(m.component)&&(m.component.then(d,p),n(m.error)&&(t.errorComp=Fe(m.error,r)),n(m.loading)&&(t.loadingComp=Fe(m.loading,r),0===m.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),m.delay||200)),n(m.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),m.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=ft();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ee(i,c,t,e,!0)||ee(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Dt(e,l,o||t);else n(r.attrs)&&Te(c,r.attrs),n(r.props)&&Te(c,r.props);const u=new Oe(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ut)return Se(f,r,u.parent,a);if(Array.isArray(f)){const t=ne(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Se(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const m=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Ie.length;t++){const n=Ie[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?De(r,o):r)}}(i);const y=r.options.name||u;return new ut(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:m,tag:u,children:c},d)}function De(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Ne(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return ft();n(o)&&n(o.is)&&(e=o.is);if(!e)return ft();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=ne(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),a=L.isReservedTag(e)?new ut(L.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=jt(t.$options,"components",e))?new ut(e,o,r,void 0,void 0,t):je(s,o,t,r,e)}else a=je(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Pe(a,c),n(o)&&function(t){s(t.style)&&Gt(t.style);s(t.class)&&Gt(t.class)}(o),a):ft()}(t,e,i,a,c)}function Pe(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Pe(a,r,s)}}let Le,Me=null;function Fe(t,e){return(t.__esModule||nt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Re(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||ce(o)))return o}}function Ve(t,e){Le.$on(t,e)}function Ue(t,e){Le.$off(t,e)}function ze(t,e){const n=Le;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Be(t,e,n){Le=t,Yt(e,n||{},Ve,Ue,ze,t),Le=void 0}let He=null;function We(t){const e=He;return He=t,()=>{He=e}}function qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ke(t,e){if(e){if(t._directInactive=!1,qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)Ke(t.$children[e]);Ge(t,"activated")}}function Xe(t,e){if(!(e&&(t._directInactive=!0,qe(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Xe(t.$children[e]);Ge(t,"deactivated")}}function Ge(t,e){ct();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Rt(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),lt()}const Ze=[],Je=[];let Qe={},Ye=!1,tn=!1,en=0;let nn=0,on=Date.now;if(U&&!W){const t=window.performance;t&&"function"==typeof t.now&&on()>document.createEvent("Event").timeStamp&&(on=()=>t.now())}function rn(){let t,e;for(nn=on(),tn=!0,Ze.sort(((t,e)=>t.id-e.id)),en=0;en<Ze.length;en++)t=Ze[en],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Je.slice(),o=Ze.slice();en=Ze.length=Je.length=0,Qe={},Ye=tn=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,Ke(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ge(o,"updated")}}(o),tt&&L.devtools&&tt.emit("flush")}let sn=0;class an{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++sn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ot,this.newDepIds=new ot,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(R.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}get(){let t;ct(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ft(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Gt(t),lt(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,tn){let e=Ze.length-1;for(;e>en&&Ze[e].id>t.id;)e--;Ze.splice(e+1,0,t)}else Ze.push(t);Ye||(Ye=!0,Kt(rn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Rt(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const cn={enumerable:!0,configurable:!0,get:O,set:O};function ln(t,e,n){cn.get=function(){return this[e][n]},cn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,cn)}function un(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&gt(!1);for(const s in e){r.push(s);$t(o,s,Dt(s,e,n,t)),s in t||ln(t,"_props",s)}gt(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?O:w(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Ft(t,e,"data()"),{}}finally{lt()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&y(o,e)||M(e)||ln(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=Y();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new an(t,i||O,O,fn)),r in t||dn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)mn(t,n,o[e]);else mn(t,n,o)}}(t,e.watch)}const fn={lazy:!0};function dn(t,e,n){const o=!Y();"function"==typeof n?(cn.get=o?pn(e):hn(n),cn.set=O):(cn.get=n.get?o&&!1!==n.cache?pn(e):hn(n.get):O,cn.set=n.set||O),Object.defineProperty(t,e,cn)}function pn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),it.target&&e.depend(),e.value}}function hn(t){return function(){return t.call(this,this)}}function mn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let yn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&x(t.extendOptions,o),e=t.options=It(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function gn(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=It(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)ln(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)dn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,N.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=x({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function $n(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&wn(n,t,o,r)}}}function wn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,h(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=yn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=It(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Be(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ie(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Ne(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Ne(e,t,n,o,r,!0);const s=o&&o.data;$t(e,"$attrs",s&&s.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ge(n,"beforeCreate"),function(t){const e=se(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach((n=>{$t(t,n,e[n])})),gt(!0))}(n),un(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ge(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(gn),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=wt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return mn(o,t,e,n);(n=n||{}).user=!0;const r=new an(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;ct(),Rt(e,o,[r.value],o,t),lt()}return function(){r.teardown()}}}(gn),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?A(n):n;const o=A(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Rt(n[t],e,o,e,r)}return e}}(gn),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=We(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ge(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||h(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ge(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(gn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Kt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=le(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Me=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Ft(e,t,"render"),o=t._vnode}finally{Me=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ut||(o=ft()),o.parent=n,o}}(gn);const An=[String,RegExp,Array];var xn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:An,exclude:An,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:bn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&wn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)wn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{Cn(this,(e=>$n(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!$n(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=Re(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!$n(o,t))||r&&t&&$n(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,h(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>L};Object.defineProperty(t,"config",e),t.util={warn:rt,extend:x,mergeOptions:It,defineReactive:$t},t.set=Ct,t.delete=wt,t.nextTick=Kt,t.observable=t=>(bt(t),t),t.options=Object.create(null),N.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,xn),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=It(this.options,t),this}}(t),_n(t),function(t){N.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(gn),Object.defineProperty(gn.prototype,"$isServer",{get:Y}),Object.defineProperty(gn.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(gn,"FunctionalRenderContext",{value:Oe}),gn.version="2.6.14";const kn=d("style,class"),On=d("input,textarea,option,select,progress"),Sn=d("contenteditable,draggable,spellcheck"),Tn=d("events,caret,typing,plaintext-only"),En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",jn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Dn=t=>jn(t)?t.slice(6,t.length):"",Nn=t=>null==t||!1===t;function Pn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Ln(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Ln(e,o.data));return function(t,e){if(n(t)||n(e))return Mn(t,Fn(e));return""}(e.staticClass,e.class)}function Ln(t,e){return{staticClass:Mn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Mn(t,e){return t?e?t+" "+e:t:e||""}function Fn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Fn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Rn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Un=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),zn=t=>Vn(t)||Un(t);const Bn=Object.create(null);const Hn=d("text,number,password,search,email,tel,url");var Wn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Rn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),qn={create(t,e){Kn(e)},update(t,e){t.data.ref!==e.data.ref&&(Kn(t,!0),Kn(e))},destroy(t){Kn(t,!0)}};function Kn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?h(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Xn=new ut("",{},[]),Gn=["create","activate","update","remove","destroy"];function Zn(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Hn(r)&&Hn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function Jn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var Qn={create:Yn,update:Yn,destroy:function(t){Yn(t,Xn)}};function Yn(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Xn,o=e===Xn,r=eo(t.data.directives,t.context),s=eo(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,oo(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(oo(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)oo(i[n],"inserted",e,t)};n?te(e,"insert",o):o()}a.length&&te(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)oo(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||oo(r[c],"unbind",t,t,o)}(t,e)}const to=Object.create(null);function eo(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=to),n[no(r)]=r,r.def=jt(e.$options,"directives",r.name);return n}function no(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function oo(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Ft(o,n.context,`directive ${t.name} ${e} hook`)}}var ro=[qn,Qn];function so(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=x({},u)),u)i=u[s],a=l[s],a!==i&&io(c,s,i,o.data.pre);for(s in(W||K)&&u.value!==l.value&&io(c,"value",u.value),l)e(u[s])&&(jn(s)?c.removeAttributeNS(In,Dn(s)):Sn(s)||c.removeAttribute(s))}function io(t,e,n,o){o||t.tagName.indexOf("-")>-1?ao(t,e,n):En(e)?Nn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Sn(e)?t.setAttribute(e,((t,e)=>Nn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true")(e,n)):jn(e)?Nn(n)?t.removeAttributeNS(In,Dn(e)):t.setAttributeNS(In,e,n):ao(t,e,n)}function ao(t,e,n){if(Nn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var co={create:so,update:so};function lo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Pn(o);const c=r._transitionClasses;n(c)&&(a=Mn(a,Fn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var uo={create:lo,update:lo};let fo;function po(t,e,n){const o=fo;return function r(){const s=e.apply(null,arguments);null!==s&&yo(t,r,n,o)}}const ho=zt&&!(G&&Number(G[1])<=53);function mo(t,e,n,o){if(ho){const t=nn,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}fo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function yo(t,e,n,o){(o||fo).removeEventListener(t,e._wrapper||e,n)}function vo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};fo=o.elm||t.elm,function(t){if(n(t.__r)){const e=W?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),Yt(r,s,mo,yo,po,o.context),fo=void 0}var go={create:vo,update:vo,destroy:t=>vo(t,Xn)};let _o;function bo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=x({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);$o(i,t)&&(i.value=t)}else if("innerHTML"===r&&Un(i.tagName)&&e(i.innerHTML)){_o=_o||document.createElement("div"),_o.innerHTML=`<svg>${s}</svg>`;const t=_o.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function $o(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var Co={create:bo,update:bo};const wo=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function Ao(t){const e=xo(t.style);return t.staticStyle?x(t.staticStyle,e):e}function xo(t){return Array.isArray(t)?k(t):"string"==typeof t?wo(t):t}const ko=/^--/,Oo=/\s*!important$/,So=(t,e,n)=>{if(ko.test(e))t.style.setProperty(e,n);else if(Oo.test(n))t.style.setProperty(C(e),n.replace(Oo,""),"important");else{const o=Io(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},To=["Webkit","Moz","ms"];let Eo;const Io=v((function(t){if(Eo=Eo||document.createElement("div").style,"filter"!==(t=_(t))&&t in Eo)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<To.length;t++){const n=To[t]+e;if(n in Eo)return n}}));function jo(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=xo(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?x({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=Ao(e.data))&&x(n,o)}(o=Ao(t.data))&&x(n,o);let r=t;for(;r=r.parent;)r.data&&(o=Ao(r.data))&&x(n,o);return n}(o,!0);for(a in f)e(p[a])&&So(c,a,"");for(a in p)i=p[a],i!==f[a]&&So(c,a,null==i?"":i)}var Do={create:jo,update:jo};const No=/\s+/;function Po(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(No).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Lo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(No).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function Mo(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&x(e,Fo(t.name||"v")),x(e,t),e}return"string"==typeof t?Fo(t):void 0}}const Fo=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),Ro=U&&!q,Vo="transition",Uo="animation";let zo="transition",Bo="transitionend",Ho="animation",Wo="animationend";Ro&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(zo="WebkitTransition",Bo="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ho="WebkitAnimation",Wo="webkitAnimationEnd"));const qo=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Ko(t){qo((()=>{qo(t)}))}function Xo(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Po(t,e))}function Go(t,e){t._transitionClasses&&h(t._transitionClasses,e),Lo(t,e)}function Zo(t,e,n){const{type:o,timeout:r,propCount:s}=Qo(t,e);if(!o)return n();const i=o===Vo?Bo:Wo;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Jo=/\b(transform|all)(,|$)/;function Qo(t,e){const n=window.getComputedStyle(t),o=(n[zo+"Delay"]||"").split(", "),r=(n[zo+"Duration"]||"").split(", "),s=Yo(o,r),i=(n[Ho+"Delay"]||"").split(", "),a=(n[Ho+"Duration"]||"").split(", "),c=Yo(i,a);let l,u=0,f=0;e===Vo?s>0&&(l=Vo,u=s,f=r.length):e===Uo?c>0&&(l=Uo,u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?Vo:Uo:null,f=l?l===Vo?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:l===Vo&&Jo.test(n[zo+"Property"])}}function Yo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>tr(e)+tr(t[n]))))}function tr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function er(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=Mo(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:v,afterEnter:g,enterCancelled:_,beforeAppear:b,appear:$,afterAppear:C,appearCancelled:w,duration:A}=i;let x=He,k=He.$vnode;for(;k&&k.parent;)x=k.context,k=k.parent;const O=!x._isMounted||!t.isRootInsert;if(O&&!$&&""!==$)return;const S=O&&p?p:l,T=O&&m?m:d,E=O&&h?h:u,I=O&&b||y,D=O&&"function"==typeof $?$:v,N=O&&C||g,P=O&&w||_,L=f(s(A)?A.enter:A),M=!1!==a&&!q,F=rr(D),R=r._enterCb=j((()=>{M&&(Go(r,E),Go(r,T)),R.cancelled?(M&&Go(r,S),P&&P(r)):N&&N(r),r._enterCb=null}));t.data.show||te(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(r,R)})),I&&I(r),M&&(Xo(r,S),Xo(r,T),Ko((()=>{Go(r,S),R.cancelled||(Xo(r,E),F||(or(L)?setTimeout(R,L):Zo(r,c,R)))}))),t.data.show&&(o&&o(),D&&D(r,R)),M||F||R()}function nr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=Mo(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:v,duration:g}=i,_=!1!==a&&!q,b=rr(h),$=f(s(g)?g.leave:g),C=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),_&&(Go(r,u),Go(r,d)),C.cancelled?(_&&Go(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function w(){C.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),_&&(Xo(r,l),Xo(r,d),Ko((()=>{Go(r,l),C.cancelled||(Xo(r,u),b||(or($)?setTimeout(C,$):Zo(r,c,C)))}))),h&&h(r,C),_||b||C())}v?v(w):w()}function or(t){return"number"==typeof t&&!isNaN(t)}function rr(t){if(e(t))return!1;const o=t.fns;return n(o)?rr(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function sr(t,e){!0!==e.data.show&&er(e)}const ir=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Gn.length;++s)for(a[Gn[s]]=[],i=0;i<c.length;++i)n(c[i][Gn[s]])&&a[Gn[s]].push(c[i][Gn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=pt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Xn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),g(t),m(t,d,e),n(f)&&v(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(v(t,e),g(t)):(Kn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function v(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Xn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Xn,t),n(s.insert)&&e.push(t))}function g(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=He)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function _(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function b(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)b(t.children[o])}function $(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(C(o),b(o)):u(o.elm))}}function C(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&C(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function w(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Zn(t,o))return s}}function A(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=pt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,v=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(v)?m!==v&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],v=o[m],g=r.length-1,b=r[0],C=r[g];const x=!i;for(;p<=m&&h<=g;)e(y)?y=o[++p]:e(v)?v=o[--m]:Zn(y,b)?(A(y,b,s,r,h),y=o[++p],b=r[++h]):Zn(v,C)?(A(v,C,s,r,g),v=o[--m],C=r[--g]):Zn(y,C)?(A(y,C,s,r,g),x&&l.insertBefore(t,y.elm,l.nextSibling(v.elm)),y=o[++p],C=r[--g]):Zn(v,b)?(A(v,b,s,r,h),x&&l.insertBefore(t,v.elm,y.elm),v=o[--m],b=r[++h]):(e(a)&&(a=Jn(o,p,m)),c=n(b.key)?a[b.key]:w(b,o,p,m),e(c)?f(b,s,t,y.elm,!1,r,h):(u=o[c],Zn(u,b)?(A(u,b,s,r,h),o[c]=void 0,x&&l.insertBefore(t,u.elm,y.elm)):f(b,s,t,y.elm,!1,r,h)),b=r[++h]);p>m?(d=e(r[g+1])?null:r[g+1].elm,_(t,d,r,h,g,s)):h>g&&$(o,p,m)}(d,m,v,s,u):n(v)?(n(t.text)&&l.setTextContent(d,""),_(d,null,v,0,v.length-1,s)):n(m)?$(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function x(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!k(n)){t=!0,v(e,r);break}!t&&c.class&&Gt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&b(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Zn(t,r))A(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),s=!0),o(s)&&O(t,r,u))return x(r,u,!0),t;d=t,t=new ut(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Xn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Kn(t);t=t.parent}}n(c)?$([t],0,0):n(t.tag)&&b(t)}}var d;return x(r,u,c),r.elm}}({nodeOps:Wn,modules:[co,uo,go,Co,Do,U?{create:sr,activate:sr,remove(t,e){!0!==t.data.show?nr(t,e):e()}}:{}].concat(ro)});q&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&hr(t,"input")}));const ar={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?te(n,"postpatch",(()=>{ar.componentUpdated(t,e,n)})):cr(t,e,n.context),t._vOptions=[].map.call(t.options,fr)):("textarea"===n.tag||Hn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",dr),t.addEventListener("compositionend",pr),t.addEventListener("change",pr),q&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){cr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,fr);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>ur(t,r))):e.value!==e.oldValue&&ur(e.value,r))&&hr(t,"change")}}}};function cr(t,e,n){lr(t,e),(W||K)&&setTimeout((()=>{lr(t,e)}),0)}function lr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=I(o,fr(i))>-1,i.selected!==s&&(i.selected=s);else if(E(fr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function ur(t,e){return e.every((e=>!E(e,t)))}function fr(t){return"_value"in t?t._value:t.value}function dr(t){t.target.composing=!0}function pr(t){t.target.composing&&(t.target.composing=!1,hr(t.target,"input"))}function hr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function mr(t){return!t.componentInstance||t.data&&t.data.transition?t:mr(t.componentInstance._vnode)}var yr={bind(t,{value:e},n){const o=(n=mr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,er(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=mr(o)).data&&o.data.transition?(o.data.show=!0,e?er(o,(()=>{t.style.display=t.__vOriginalDisplay})):nr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},vr={model:ar,show:yr};const gr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function _r(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?_r(Re(e.children)):t}function br(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function $r(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Cr=t=>t.tag||ce(t),wr=t=>"show"===t.name;var Ar={name:"transition",props:gr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Cr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=_r(o);if(!s)return o;if(this._leaving)return $r(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=br(this),c=this._vnode,l=_r(c);if(s.data.directives&&s.data.directives.some(wr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!ce(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=x({},a);if("out-in"===n)return this._leaving=!0,te(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),$r(t,o);if("in-out"===n){if(ce(s))return c;let t;const n=()=>{t()};te(a,"afterEnter",n),te(a,"enterCancelled",n),te(e,"delayLeave",(e=>{t=e}))}}return o}};const xr=x({tag:String,moveClass:String},gr);function kr(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Or(t){t.data.newPos=t.elm.getBoundingClientRect()}function Sr(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete xr.mode;var Tr={Transition:Ar,TransitionGroup:{props:xr,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=We(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=br(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(kr),t.forEach(Or),t.forEach(Sr),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Xo(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(Bo,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(Bo,t),n._moveCb=null,Go(n,e))})}})))},methods:{hasMove(t,e){if(!Ro)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{Lo(n,t)})),Po(n,e),n.style.display="none",this.$el.appendChild(n);const o=Qo(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};return gn.config.mustUseProp=(t,e,n)=>"value"===n&&On(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,gn.config.isReservedTag=zn,gn.config.isReservedAttr=kn,gn.config.getTagNamespace=function(t){return Un(t)?"svg":"math"===t?"math":void 0},gn.config.isUnknownElement=function(t){if(!U)return!0;if(zn(t))return!1;if(t=t.toLowerCase(),null!=Bn[t])return Bn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Bn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Bn[t]=/HTMLUnknownElement/.test(e.toString())},x(gn.options.directives,vr),x(gn.options.components,Tr),gn.prototype.__patch__=U?ir:O,gn.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=ft),Ge(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new an(t,o,O,{before(){t._isMounted&&!t._isDestroyed&&Ge(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ge(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((()=>{L.devtools&&tt&&tt.emit("init",gn)}),0),gn}));
\ No newline at end of file
diff --git a/package.json b/package.json
index 80fbf42e0b5..c786eeab9a1 100644
--- a/package.json
+++ b/package.json
@@ -68,84 +68,84 @@
   },
   "homepage": "https://github.com/vuejs/vue#readme",
   "devDependencies": {
-    "@babel/core": "^7.13.14",
-    "@babel/plugin-proposal-class-properties": "^7.13.0",
+    "@babel/core": "^7.17.10",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
     "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-syntax-jsx": "^7.12.13",
-    "@babel/plugin-transform-flow-strip-types": "^7.13.0",
-    "@babel/preset-env": "^7.13.12",
-    "@babel/register": "^7.13.14",
-    "@rollup/plugin-alias": "^3.1.2",
+    "@babel/plugin-syntax-jsx": "^7.16.7",
+    "@babel/plugin-transform-flow-strip-types": "^7.16.7",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/register": "^7.17.7",
+    "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-buble": "^0.21.3",
-    "@rollup/plugin-commonjs": "^18.0.0",
-    "@rollup/plugin-node-resolve": "^11.2.1",
-    "@rollup/plugin-replace": "^2.4.2",
-    "@types/node": "^12.12.0",
-    "@types/webpack": "^4.4.22",
-    "@typescript-eslint/eslint-plugin": "^4.21.0",
-    "@typescript-eslint/parser": "^4.21.0",
-    "acorn": "^8.1.0",
-    "acorn-walk": "^8.0.2",
-    "babel-eslint": "^10.0.1",
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@rollup/plugin-node-resolve": "^13.2.1",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@types/node": "^17.0.30",
+    "@types/webpack": "^5.28.0",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
+    "acorn": "^8.7.1",
+    "acorn-walk": "^8.2.0",
+    "babel-eslint": "^10.1.0",
     "babel-helper-vue-jsx-merge-props": "^2.0.3",
-    "babel-loader": "^8.0.4",
-    "babel-plugin-istanbul": "^5.1.0",
+    "babel-loader": "^8.2.5",
+    "babel-plugin-istanbul": "^6.1.1",
     "babel-plugin-transform-vue-jsx": "^4.0.1",
     "babel-preset-flow-vue": "^1.0.0",
     "buble": "^0.20.0",
-    "chalk": "^2.3.0",
-    "chromedriver": "^2.45.0",
-    "codecov": "^3.0.0",
-    "commitizen": "^2.9.6",
-    "conventional-changelog": "^1.1.3",
-    "cross-spawn": "^6.0.5",
-    "cz-conventional-changelog": "^2.0.0",
+    "chalk": "^5.0.1",
+    "chromedriver": "^100.0.0",
+    "codecov": "^3.8.3",
+    "commitizen": "^4.2.4",
+    "conventional-changelog": "^3.1.25",
+    "cross-spawn": "^7.0.3",
+    "cz-conventional-changelog": "^3.3.0",
     "de-indent": "^1.0.2",
-    "es6-promise": "^4.1.0",
-    "escodegen": "^1.8.1",
-    "eslint": "^7.23.0",
-    "eslint-plugin-flowtype": "^2.34.0",
-    "eslint-plugin-jasmine": "^2.8.4",
-    "file-loader": "^3.0.1",
-    "flow-bin": "^0.61.0",
-    "hash-sum": "^1.0.2",
+    "es6-promise": "^4.2.8",
+    "escodegen": "^2.0.0",
+    "eslint": "^8.14.0",
+    "eslint-plugin-flowtype": "^8.0.3",
+    "eslint-plugin-jasmine": "^4.1.3",
+    "file-loader": "^6.2.0",
+    "flow-bin": "^0.176.3",
+    "hash-sum": "^2.0.0",
     "he": "^1.1.1",
-    "http-server": "^0.12.3",
-    "jasmine": "^2.99.0",
-    "jasmine-core": "^2.99.0",
-    "jasmine-ts": "^0.3.2",
-    "karma": "^3.1.1",
-    "karma-chrome-launcher": "^2.1.1",
-    "karma-coverage": "^1.1.1",
-    "karma-firefox-launcher": "^1.0.1",
-    "karma-jasmine": "^1.1.0",
+    "http-server": "^14.1.0",
+    "jasmine": "^4.1.0",
+    "jasmine-core": "^4.1.0",
+    "jasmine-ts": "^0.4.0",
+    "karma": "^6.3.19",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-coverage": "^2.2.0",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-jasmine": "^5.0.0",
     "karma-mocha-reporter": "^2.2.3",
     "karma-phantomjs-launcher": "^1.0.4",
     "karma-safari-launcher": "^1.0.0",
-    "karma-sauce-launcher": "^2.0.2",
-    "karma-sourcemap-loader": "^0.3.7",
-    "karma-webpack": "^4.0.0-rc.2",
-    "lint-staged": "^8.0.0",
-    "lodash": "^4.17.4",
+    "karma-sauce-launcher": "^4.3.6",
+    "karma-sourcemap-loader": "^0.3.8",
+    "karma-webpack": "^5.0.0",
+    "lint-staged": "^12.4.1",
+    "lodash": "^4.17.21",
     "lodash.template": "^4.4.0",
     "lodash.uniq": "^4.5.0",
-    "lru-cache": "^5.1.1",
-    "nightwatch": "^0.9.16",
+    "lru-cache": "^7.8.1",
+    "nightwatch": "^2.1.3",
     "nightwatch-helpers": "^1.2.0",
     "phantomjs-prebuilt": "^2.1.14",
-    "puppeteer": "^1.11.0",
-    "resolve": "^1.3.3",
-    "rollup": "^2.44.0",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "selenium-server": "^2.53.1",
-    "serialize-javascript": "^3.1.0",
-    "shelljs": "^0.8.1",
-    "terser": "^5.6.1",
-    "ts-loader": "^8.1.0",
-    "ts-node": "^9.1.1",
-    "tslib": "^2.2.0",
-    "typescript": "^4.2.2",
-    "webpack": "~4.28.4",
+    "puppeteer": "^13.7.0",
+    "resolve": "^1.22.0",
+    "rollup": "^2.70.2",
+    "rollup-plugin-typescript2": "^0.31.2",
+    "selenium-server": "^3.141.59",
+    "serialize-javascript": "^6.0.0",
+    "shelljs": "^0.8.5",
+    "terser": "^5.13.1",
+    "ts-loader": "^9.2.9",
+    "ts-node": "^10.7.0",
+    "tslib": "^2.4.0",
+    "typescript": "^4.6.4",
+    "webpack": "~5.72.0",
     "weex-js-runtime": "^0.23.6",
     "weex-styler": "^0.3.0",
     "yorkie": "^2.0.0"
@@ -156,6 +156,6 @@
     }
   },
   "dependencies": {
-    "@types/he": "^1.1.1"
+    "@types/he": "^1.1.2"
   }
 }
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index cd1221a5121..96c1dceb156 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -1,1460 +1,1239 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
-  (global = global || self, global.renderVueComponentToString = factory());
-}(this, function () { 'use strict';
-
-  /*  */
-
-  var emptyObject = Object.freeze({});
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.renderVueComponentToString = factory());
+})(this, (function () { 'use strict';
 
+  const emptyObject = Object.freeze({});
   // These helpers produce better VM code in JS engines due to their
   // explicitness and function inlining.
-  function isUndef (v) {
-    return v === undefined || v === null
+  function isUndef(v) {
+      return v === undefined || v === null;
   }
-
-  function isDef (v) {
-    return v !== undefined && v !== null
+  function isDef(v) {
+      return v !== undefined && v !== null;
   }
-
-  function isTrue (v) {
-    return v === true
+  function isTrue(v) {
+      return v === true;
   }
-
-  function isFalse (v) {
-    return v === false
+  function isFalse(v) {
+      return v === false;
   }
-
   /**
    * Check if value is primitive.
    */
-  function isPrimitive (value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
   }
-
   /**
    * Quick object check - this is primarily used to tell
-   * Objects from primitive values when we know the value
+   * objects from primitive values when we know the value
    * is a JSON-compliant type.
    */
-  function isObject (obj) {
-    return obj !== null && typeof obj === 'object'
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
   }
-
   /**
    * Get the raw type string of a value, e.g., [object Object].
    */
-  var _toString = Object.prototype.toString;
-
-  function toRawType (value) {
-    return _toString.call(value).slice(8, -1)
+  const _toString = Object.prototype.toString;
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
   }
-
   /**
    * Strict object type check. Only returns true
    * for plain JavaScript objects.
    */
-  function isPlainObject (obj) {
-    return _toString.call(obj) === '[object Object]'
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
   }
-
   /**
    * Check if val is a valid array index.
    */
-  function isValidArrayIndex (val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
+  function isValidArrayIndex(val) {
+      const n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
   }
-
-  function isPromise (val) {
-    return (
-      isDef(val) &&
-      typeof val.then === 'function' &&
-      typeof val.catch === 'function'
-    )
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
   }
-
   /**
    * Convert a value to a string that is actually rendered.
    */
-  function toString (val) {
-    return val == null
-      ? ''
-      : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-        ? JSON.stringify(val, null, 2)
-        : String(val)
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
   }
-
   /**
    * Convert an input value to a number for persistence.
    * If the conversion fails, return original string.
    */
-  function toNumber (val) {
-    var n = parseFloat(val);
-    return isNaN(n) ? val : n
+  function toNumber(val) {
+      const n = parseFloat(val);
+      return isNaN(n) ? val : n;
   }
-
   /**
    * Make a map and return a function for checking if a key
    * is in that map.
    */
-  function makeMap (
-    str,
-    expectsLowerCase
-  ) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) { return map[val.toLowerCase()]; }
-      : function (val) { return map[val]; }
+  function makeMap(str, expectsLowerCase) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
   }
-
   /**
    * Check if a tag is a built-in tag.
    */
-  var isBuiltInTag = makeMap('slot,component', true);
-
+  const isBuiltInTag = makeMap('slot,component', true);
   /**
    * Check if an attribute is a reserved attribute.
    */
-  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
   /**
    * Remove an item from an array.
    */
-  function remove (arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1)
+  function remove$1(arr, item) {
+      if (arr.length) {
+          const index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
       }
-    }
   }
-
   /**
    * Check whether an object has the property.
    */
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn (obj, key) {
-    return hasOwnProperty.call(obj, key)
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
   }
-
   /**
    * Create a cached version of a pure function.
    */
-  function cached (fn) {
-    var cache = Object.create(null);
-    return (function cachedFn (str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str))
-    })
+  function cached(fn) {
+      const cache = Object.create(null);
+      return function cachedFn(str) {
+          const hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
   }
-
   /**
    * Camelize a hyphen-delimited string.
    */
-  var camelizeRE = /-(\w)/g;
-  var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
   });
-
   /**
    * Capitalize a string.
    */
-  var capitalize = cached(function (str) {
-    return str.charAt(0).toUpperCase() + str.slice(1)
+  const capitalize = cached((str) => {
+      return str.charAt(0).toUpperCase() + str.slice(1);
   });
-
   /**
    * Hyphenate a camelCase string.
    */
-  var hyphenateRE = /\B([A-Z])/g;
-  var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
   });
-
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-
-  /* istanbul ignore next */
-  function polyfillBind (fn, ctx) {
-    function boundFn (a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx)
-    }
-
-    boundFn._length = fn.length;
-    return boundFn
-  }
-
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
-
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
-
   /**
    * Mix properties into target object.
    */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to
+  function extend(to, _from) {
+      for (const key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
   }
-
   /**
    * Merge an Array of Objects into a single Object.
    */
-  function toObject (arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-      if (arr[i]) {
-        extend(res, arr[i]);
+  function toObject(arr) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
       }
-    }
-    return res
+      return res;
   }
-
   /* eslint-disable no-unused-vars */
-
   /**
    * Perform no operation.
    * Stubbing args to make Flow happy without leaving useless transpiled code
    * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
    */
-  function noop (a, b, c) {}
-
+  function noop$1(a, b, c) { }
   /**
    * Always return false.
    */
-  var no = function (a, b, c) { return false; };
-
+  const no = (a, b, c) => false;
   /* eslint-enable no-unused-vars */
-
   /**
    * Return the same value.
    */
-  var identity = function (_) { return _; };
-
+  const identity = (_) => _;
   /**
    * Generate a string containing static keys from compiler modules.
    */
-  function genStaticKeys (modules) {
-    return modules.reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, []).join(',')
+  function genStaticKeys(modules) {
+      return modules
+          .reduce((keys, m) => {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
   }
-
   /**
    * Check if two values are loosely equal - that is,
    * if they are plain objects, do they have the same shape?
    */
-  function looseEqual (a, b) {
-    if (a === b) { return true }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-      try {
-        var isArrayA = Array.isArray(a);
-        var isArrayB = Array.isArray(b);
-        if (isArrayA && isArrayB) {
-          return a.length === b.length && a.every(function (e, i) {
-            return looseEqual(e, b[i])
-          })
-        } else if (a instanceof Date && b instanceof Date) {
-          return a.getTime() === b.getTime()
-        } else if (!isArrayA && !isArrayB) {
-          var keysA = Object.keys(a);
-          var keysB = Object.keys(b);
-          return keysA.length === keysB.length && keysA.every(function (key) {
-            return looseEqual(a[key], b[key])
-          })
-        } else {
-          /* istanbul ignore next */
-          return false
-        }
-      } catch (e) {
-        /* istanbul ignore next */
-        return false
-      }
-    } else if (!isObjectA && !isObjectB) {
-      return String(a) === String(b)
-    } else {
-      return false
-    }
+  function looseEqual(a, b) {
+      if (a === b)
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every((e, i) => {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every((key) => {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
   }
-
   /**
    * Return the first index at which a loosely equal value can be
    * found in the array (if value is a plain object, the array must
    * contain an object of the same shape), or -1 if it is not present.
    */
-  function looseIndexOf (arr, val) {
-    for (var i = 0; i < arr.length; i++) {
-      if (looseEqual(arr[i], val)) { return i }
-    }
-    return -1
-  }
-
-  /**
-   * Ensure a function is called only once.
-   */
-  function once (fn) {
-    var called = false;
-    return function () {
-      if (!called) {
-        called = true;
-        fn.apply(this, arguments);
-      }
-    }
-  }
-
-  /*  */
-
-  var isAttr = makeMap(
-    'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap'
-  );
-
-  var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-  var isSSRUnsafeAttr = function (name) {
-    return unsafeAttrCharRE.test(name)
+  function looseIndexOf(arr, val) {
+      for (let i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              return i;
+      }
+      return -1;
+  }
+
+  const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap');
+  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+  const isSSRUnsafeAttr = (name) => {
+      return unsafeAttrCharRE.test(name);
   };
-
   /* istanbul ignore next */
-  var isRenderableAttr = function (name) {
-    return (
-      isAttr(name) ||
-      name.indexOf('data-') === 0 ||
-      name.indexOf('aria-') === 0
-    )
+  const isRenderableAttr = (name) => {
+      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
   };
-
-  var propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv'
+  const propsToAttrMap = {
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv',
   };
-
-  var ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;'
+  const ESC = {
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;',
   };
-
-  function escape (s) {
-    return s.replace(/[<>"&]/g, escapeChar)
-  }
-
-  function escapeChar (a) {
-    return ESC[a] || a
-  }
-
-  var noUnitNumericStyleProps = {
-    "animation-iteration-count": true,
-    "border-image-outset": true,
-    "border-image-slice": true,
-    "border-image-width": true,
-    "box-flex": true,
-    "box-flex-group": true,
-    "box-ordinal-group": true,
-    "column-count": true,
-    "columns": true,
-    "flex": true,
-    "flex-grow": true,
-    "flex-positive": true,
-    "flex-shrink": true,
-    "flex-negative": true,
-    "flex-order": true,
-    "grid-row": true,
-    "grid-row-end": true,
-    "grid-row-span": true,
-    "grid-row-start": true,
-    "grid-column": true,
-    "grid-column-end": true,
-    "grid-column-span": true,
-    "grid-column-start": true,
-    "font-weight": true,
-    "line-clamp": true,
-    "line-height": true,
-    "opacity": true,
-    "order": true,
-    "orphans": true,
-    "tab-size": true,
-    "widows": true,
-    "z-index": true,
-    "zoom": true,
-    // SVG
-    "fill-opacity": true,
-    "flood-opacity": true,
-    "stop-opacity": true,
-    "stroke-dasharray": true,
-    "stroke-dashoffset": true,
-    "stroke-miterlimit": true,
-    "stroke-opacity": true,
-    "stroke-width": true
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
+  }
+  function escapeChar(a) {
+      return ESC[a] || a;
+  }
+  const noUnitNumericStyleProps = {
+      'animation-iteration-count': true,
+      'border-image-outset': true,
+      'border-image-slice': true,
+      'border-image-width': true,
+      'box-flex': true,
+      'box-flex-group': true,
+      'box-ordinal-group': true,
+      'column-count': true,
+      columns: true,
+      flex: true,
+      'flex-grow': true,
+      'flex-positive': true,
+      'flex-shrink': true,
+      'flex-negative': true,
+      'flex-order': true,
+      'grid-row': true,
+      'grid-row-end': true,
+      'grid-row-span': true,
+      'grid-row-start': true,
+      'grid-column': true,
+      'grid-column-end': true,
+      'grid-column-span': true,
+      'grid-column-start': true,
+      'font-weight': true,
+      'line-clamp': true,
+      'line-height': true,
+      opacity: true,
+      order: true,
+      orphans: true,
+      'tab-size': true,
+      widows: true,
+      'z-index': true,
+      zoom: true,
+      // SVG
+      'fill-opacity': true,
+      'flood-opacity': true,
+      'stop-opacity': true,
+      'stroke-dasharray': true,
+      'stroke-dashoffset': true,
+      'stroke-miterlimit': true,
+      'stroke-opacity': true,
+      'stroke-width': true,
   };
 
-  /*  */
-
   // these are reserved for web because they are directly compiled away
   // during template compilation
-  var isReservedAttr = makeMap('style,class');
-
+  makeMap('style,class');
   // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress');
-  var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
-  };
-
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
-  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
-  var convertEnumeratedValue = function (key, value) {
-    return isFalsyAttrValue(value) || value === 'false'
-      ? 'false'
-      // allow arbitrary string value for contenteditable
-      : key === 'contenteditable' && isValidContentEditableValue(value)
-        ? value
-        : 'true'
-  };
-
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible'
-  );
-
-  var isFalsyAttrValue = function (val) {
-    return val == null || val === false
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
   };
-
-  /*  */
-
-  function renderAttrs (node) {
-    var attrs = node.data.attrs;
-    var res = '';
-
-    var opts = node.parent && node.parent.componentOptions;
-    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-      var parent = node.parent;
-      while (isDef(parent)) {
-        // Stop fallthrough in case parent has inheritAttrs option set to false
-        if (parent.componentOptions && parent.componentOptions.Ctor.options.inheritAttrs === false) {
-          break;
-        }
-        if (isDef(parent.data) && isDef(parent.data.attrs)) {
-          attrs = extend(extend({}, attrs), parent.data.attrs);
-        }
-        parent = parent.parent;
-      }
-    }
-
-    if (isUndef(attrs)) {
-      return res
-    }
-
-    for (var key in attrs) {
-      if (isSSRUnsafeAttr(key)) {
-        continue
-      }
-      if (key === 'style') {
-        // leave it to the style module
-        continue
-      }
-      res += renderAttr(key, attrs[key]);
-    }
-    return res
-  }
-
-  function renderAttr (key, value) {
-    if (isBooleanAttr(key)) {
-      if (!isFalsyAttrValue(value)) {
-        return (" " + key + "=\"" + key + "\"")
-      }
-    } else if (isEnumeratedAttr(key)) {
-      return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"")
-    } else if (!isFalsyAttrValue(value)) {
-      return (" " + key + "=\"" + (escape(String(value))) + "\"")
-    }
-    return ''
-  }
-
-  /*  */
-
-  var VNode = function VNode (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
   };
-
-  var prototypeAccessors = { child: { configurable: true } };
-
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-    return this.componentInstance
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+  const isFalsyAttrValue = (val) => {
+      return val == null || val === false;
   };
 
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
-
-  var createEmptyVNode = function (text) {
-    if ( text === void 0 ) text = '';
-
-    var node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node
+  function renderAttrs$1(node) {
+      let attrs = node.data.attrs;
+      let res = '';
+      const opts = node.parent && node.parent.componentOptions;
+      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+          let parent = node.parent;
+          while (isDef(parent)) {
+              // Stop fallthrough in case parent has inheritAttrs option set to false
+              if (parent.componentOptions &&
+                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                  break;
+              }
+              if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                  attrs = extend(extend({}, attrs), parent.data.attrs);
+              }
+              parent = parent.parent;
+          }
+      }
+      if (isUndef(attrs)) {
+          return res;
+      }
+      for (const key in attrs) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          if (key === 'style') {
+              // leave it to the style module
+              continue;
+          }
+          res += renderAttr(key, attrs[key]);
+      }
+      return res;
+  }
+  function renderAttr(key, value) {
+      if (isBooleanAttr(key)) {
+          if (!isFalsyAttrValue(value)) {
+              return ` ${key}="${key}"`;
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
+      }
+      else if (!isFalsyAttrValue(value)) {
+          return ` ${key}="${escape(String(value))}"`;
+      }
+      return '';
+  }
+
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
   };
-
-  function createTextVNode (val) {
-    return new VNode(undefined, undefined, undefined, String(val))
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
   }
-
   // optimized shallow clone
   // used for static nodes and slot nodes because they may be reused across
   // multiple renders, cloning them avoids errors when DOM manipulations rely
   // on their elm reference.
-  function cloneVNode (vnode) {
-    var cloned = new VNode(
-      vnode.tag,
-      vnode.data,
+  function cloneVNode(vnode) {
+      const cloned = new VNode(vnode.tag, vnode.data, 
       // #7975
       // clone children array to avoid mutating original in case of cloning
       // a child.
-      vnode.children && vnode.children.slice(),
-      vnode.text,
-      vnode.elm,
-      vnode.context,
-      vnode.componentOptions,
-      vnode.asyncFactory
-    );
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned
-  }
-
-  /*  */
-
-  function renderDOMProps (node) {
-    var props = node.data.domProps;
-    var res = '';
-
-    var parent = node.parent;
-    while (isDef(parent)) {
-      if (parent.data && parent.data.domProps) {
-        props = extend(extend({}, props), parent.data.domProps);
-      }
-      parent = parent.parent;
-    }
-
-    if (isUndef(props)) {
-      return res
-    }
-
-    var attrs = node.data.attrs;
-    for (var key in props) {
-      if (key === 'innerHTML') {
-        setText(node, props[key], true);
-      } else if (key === 'textContent') {
-        setText(node, props[key], false);
-      } else if (key === 'value' && node.tag === 'textarea') {
-        setText(node, toString(props[key]), false);
-      } else {
-        // $flow-disable-line (WTF?)
-        var attr = propsToAttrMap[key] || key.toLowerCase();
-        if (isRenderableAttr(attr) &&
-          // avoid rendering double-bound props/attrs twice
-          !(isDef(attrs) && isDef(attrs[attr]))
-        ) {
-          res += renderAttr(attr, props[key]);
-        }
-      }
-    }
-    return res
-  }
-
-  function setText (node, text, raw) {
-    var child = new VNode(undefined, undefined, undefined, text);
-    child.raw = raw;
-    node.children = [child];
-  }
-
-  /*  */
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
+  }
+
+  function renderDOMProps$1(node) {
+      let props = node.data.domProps;
+      let res = '';
+      let parent = node.parent;
+      while (isDef(parent)) {
+          if (parent.data && parent.data.domProps) {
+              props = extend(extend({}, props), parent.data.domProps);
+          }
+          parent = parent.parent;
+      }
+      if (isUndef(props)) {
+          return res;
+      }
+      const attrs = node.data.attrs;
+      for (const key in props) {
+          if (key === 'innerHTML') {
+              setText(node, props[key], true);
+          }
+          else if (key === 'textContent') {
+              setText(node, props[key], false);
+          }
+          else if (key === 'value' && node.tag === 'textarea') {
+              setText(node, toString(props[key]), false);
+          }
+          else {
+              // $flow-disable-line (WTF?)
+              const attr = propsToAttrMap[key] || key.toLowerCase();
+              if (isRenderableAttr(attr) &&
+                  // avoid rendering double-bound props/attrs twice
+                  !(isDef(attrs) && isDef(attrs[attr]))) {
+                  res += renderAttr(attr, props[key]);
+              }
+          }
+      }
+      return res;
+  }
+  function setText(node, text, raw) {
+      const child = new VNode(undefined, undefined, undefined, text);
+      child.raw = raw;
+      node.children = [child];
+  }
 
   /**
    * unicode letters used for parsing html tags, component names and property paths.
    * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
    * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
    */
-  var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
   /**
    * Define a property.
    */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
   }
 
-  /*  */
-
   // can we use __proto__?
-  var hasProto = '__proto__' in {};
-
+  const hasProto = '__proto__' in {};
   // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined';
-  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-  var isPhantomJS = UA && /phantomjs/.test(UA);
-  var isFF = UA && UA.match(/firefox\/(\d+)/);
-
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  UA && UA.match(/firefox\/(\d+)/);
   // Firefox has a "watch" function on Object.prototype...
-  var nativeWatch = ({}).watch;
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
   if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, 'passive', ({
-        get: function get () {
-        }
-      })); // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts);
-    } catch (e) {}
+      try {
+          const opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
   }
-
   // this needs to be lazy-evaled because vue may be required before
   // vue-server-renderer can set VUE_ENV
-  var _isServer;
-  var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-      } else {
-        _isServer = false;
-      }
-    }
-    return _isServer
+  let _isServer;
+  const isServerRendering = () => {
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
   };
-
-  // detect devtools
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
   /* istanbul ignore next */
-  function isNative (Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-
-  var hasSymbol =
-    typeof Symbol !== 'undefined' && isNative(Symbol) &&
-    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-  var _Set;
-  /* istanbul ignore if */ // $flow-disable-line
-  if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-      function Set () {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has (key) {
-        return this.set[key] === true
-      };
-      Set.prototype.add = function add (key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear () {
-        this.set = Object.create(null);
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  const hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  let _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
+              return this.set[key] === true;
+          }
+          add(key) {
+              this.set[key] = true;
+          }
+          clear() {
+              this.set = Object.create(null);
+          }
       };
-
-      return Set;
-    }());
   }
 
-  var SSR_ATTR = 'data-server-rendered';
-
-  var ASSET_TYPES = [
-    'component',
-    'directive',
-    'filter'
-  ];
-
-  var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch',
   ];
 
-  /*  */
-
-
-
-  var config = ({
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  });
-
-  /*  */
-
-  var warn = noop;
-  var tip = noop;
-  var generateComponentTrace = (noop); // work around flow check
-  var formatComponentName = (noop);
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop$1,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
+  };
 
+  let warn$2 = noop$1;
+  let tip = noop$1;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
   {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str
-      .replace(classifyRE, function (c) { return c.toUpperCase(); })
-      .replace(/[-_]/g, ''); };
-
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : '';
-
-      if (hasConsole && (!config.silent)) {
-        console.error(("[Vue warn]: " + msg + trace));
-      }
-    };
-
-    tip = function (msg, vm) {
-      if (hasConsole && (!config.silent)) {
-        console.warn("[Vue tip]: " + msg + (
-          vm ? generateComponentTrace(vm) : ''
-        ));
-      }
-    };
-
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options = typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-
-      return (
-        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-        (file && includeFile !== false ? (" at " + file) : '')
-      )
-    };
-
-    var repeat = function (str, n) {
-      var res = '';
-      while (n) {
-        if (n % 2 === 1) { res += str; }
-        if (n > 1) { str += str; }
-        n >>= 1;
-      }
-      return res
-    };
-
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
-          }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return '\n\nfound in\n\n' + tree
-          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-              : formatComponentName(vm))); })
-          .join('\n')
-      } else {
-        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-      }
-    };
-  }
-
-  /*  */
-
-  var uid = 0;
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn$2 = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
+          if (hasConsole && !config.silent) {
+              console.error(`[Vue warn]: ${msg}${trace}`);
+          }
+      };
+      tip = (msg, vm) => {
+          if (hasConsole && !config.silent) {
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = (vm, includeFile) => {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
+              : vm._isVue
+                  ? vm.$options || vm.constructor.options
+                  : vm;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
+          if (!name && file) {
+              const match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
+      };
+      const repeat = (str, n) => {
+          let res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  res += str;
+              if (n > 1)
+                  str += str;
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = (vm) => {
+          if (vm._isVue && vm.$parent) {
+              const tree = [];
+              let currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      const last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                      .join('\n'));
+          }
+          else {
+              return `\n\n(found in ${formatComponentName(vm)})`;
+          }
+      };
+  }
 
+  let uid = 0;
   /**
    * A dep is an observable that can have multiple
    * directives subscribing to it.
    */
-  var Dep = function Dep () {
-    this.id = uid++;
-    this.subs = [];
-  };
-
-  Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-  };
-
-  Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-  };
-
-  Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
-  };
-
-  Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
-  };
-
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid++;
+          this.subs = [];
+      }
+      addSub(sub) {
+          this.subs.push(sub);
+      }
+      removeSub(sub) {
+          remove$1(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
   // The current target watcher being evaluated.
   // This is globally unique because only one watcher
   // can be evaluated at a time.
   Dep.target = null;
-  var targetStack = [];
-
-  function pushTarget (target) {
-    targetStack.push(target);
-    Dep.target = target;
+  const targetStack = [];
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
   }
-
-  function popTarget () {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
   }
 
   /*
    * not type checking this file because flow doesn't play well with
    * dynamically accessing methods on Array prototype
    */
-
-  var arrayProto = Array.prototype;
-  var arrayMethods = Object.create(arrayProto);
-
-  var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse',
   ];
-
   /**
    * Intercept mutating methods and emit events
    */
   methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args;
-          break
-        case 'splice':
-          inserted = args.slice(2);
-          break
-      }
-      if (inserted) { ob.observeArray(inserted); }
-      // notify change
-      ob.dep.notify();
-      return result
-    });
+      // cache original method
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              ob.observeArray(inserted);
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  /*  */
-
-  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
    */
-  var shouldObserve = true;
-
-  function toggleObserving (value) {
-    shouldObserve = value;
+  let shouldObserve = true;
+  function toggleObserving(value) {
+      shouldObserve = value;
   }
-
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
    * object's property keys into getter/setters that
    * collect dependencies and dispatch updates.
    */
-  var Observer = function Observer (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
-  };
-
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
-    }
-  };
-
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
-  };
-
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
+          }
+          else {
+              this.walk(value);
+          }
+      }
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      }
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      }
+  }
   // helpers
-
   /**
    * Augment a target Object or Array by intercepting
    * the prototype chain using __proto__
    */
-  function protoAugment (target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
   }
-
   /**
    * Augment a target Object or Array by defining
    * hidden properties.
    */
   /* istanbul ignore next */
-  function copyAugment (target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
+  function copyAugment(target, src, keys) {
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
+          def(target, key, src[key]);
+      }
   }
-
   /**
    * Attempt to create an observer instance for a value,
    * returns the new observer if successfully observed,
    * or the existing observer if the value already has one.
    */
-  function observe (value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      let ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
   }
-
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive$$1 (
-    obj,
-    key,
-    val,
-    customSetter,
-    shallow
-  ) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter () {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter (newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) { return }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      }
-    });
+  function defineReactive(obj, key, val, customSetter, shallow) {
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      const getter = property && property.get;
+      const setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      let childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              const value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              const value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  return;
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
   }
-
   /**
    * Set a property on an object. Adds the new property and
    * triggers change notification if the property doesn't
    * already exist.
    */
-  function set (target, key, val) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-        'at runtime - declare it upfront in the data option.'
-      );
-      return val
-    }
-    if (!ob) {
-      target[key] = val;
-      return val
-    }
-    defineReactive$$1(ob.value, key, val);
-    ob.dep.notify();
-    return val
+  function set(target, key, val) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive(ob.value, key, val);
+      ob.dep.notify();
+      return val;
   }
-
   /**
    * Collect dependencies on array elements when the array is touched, since
    * we cannot intercept array element access like property getters.
    */
-  function dependArray (value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
+  function dependArray(value) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
       }
-    }
   }
 
-  /*  */
-
   /**
    * Option overwriting strategies are functions that handle
    * how to merge a parent option value and a child option
    * value into the final value.
    */
-  var strats = config.optionMergeStrategies;
-
+  const strats = config.optionMergeStrategies;
   /**
    * Options with restrictions
    */
   {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          "option \"" + key + "\" can only be used during instance " +
-          'creation with the `new` keyword.'
-        );
-      }
-      return defaultStrat(parent, child)
-    };
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn$2(`option "${key}" can only be used during instance ` +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
   }
-
   /**
    * Helper that recursively merges two data objects together.
    */
-  function mergeData (to, from) {
-    if (!from) { return to }
-    var key, toVal, fromVal;
-
-    var keys = hasSymbol
-      ? Reflect.ownKeys(from)
-      : Object.keys(from);
-
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === '__ob__') { continue }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to
+  function mergeData(to, from) {
+      if (!from)
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (let i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              continue;
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
   }
-
   /**
    * Data
    */
-  function mergeDataOrFn (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn () {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn () {
-        // instance merge
-        var instanceData = typeof childVal === 'function'
-          ? childVal.call(vm, vm)
-          : childVal;
-        var defaultData = typeof parentVal === 'function'
-          ? parentVal.call(vm, vm)
-          : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
-      }
-    }
-  }
-
-  strats.data = function (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn(
-          'The "data" option should be a function ' +
-          'that returns a per-instance value in component ' +
-          'definitions.',
-          vm
-        );
-
-        return parentVal
-      }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-
-    return mergeDataOrFn(parentVal, childVal, vm)
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn$2('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
   };
-
   /**
    * Hooks and props are merged as arrays.
    */
-  function mergeHook (
-    parentVal,
-    childVal
-  ) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-          ? childVal
-          : [childVal]
-      : parentVal;
-    return res
-      ? dedupeHooks(res)
-      : res
-  }
-
-  function dedupeHooks (hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
-      }
-    }
-    return res
-  }
-
-  LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
+  function mergeHook$1(parentVal, childVal) {
+      const res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
+  }
+  LIFECYCLE_HOOKS.forEach((hook) => {
+      strats[hook] = mergeHook$1;
   });
-
   /**
    * Assets
    *
@@ -1462,603 +1241,521 @@
    * a three-way merge between constructor options, instance
    * options and parent options.
    */
-  function mergeAssets (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal)
-    } else {
-      return res
-    }
+  function mergeAssets(parentVal, childVal, vm, key) {
+      const res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
   }
-
   ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
+      strats[type + 's'] = mergeAssets;
   });
-
   /**
    * Watchers.
    *
    * Watchers hashes should not overwrite one
    * another, so we merge them as arrays.
    */
-  strats.watch = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    // work around Firefox's Object.prototype.watch...
-    if (parentVal === nativeWatch) { parentVal = undefined; }
-    if (childVal === nativeWatch) { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal) { return Object.create(parentVal || null) }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child) ? child : [child];
-    }
-    return ret
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          parentVal = undefined;
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          childVal = undefined;
+      /* istanbul ignore if */
+      if (!childVal)
+          return Object.create(parentVal || null);
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = {};
+      extend(ret, parentVal);
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
   };
-
   /**
    * Other object hashes.
    */
-  strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== 'production') {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) { extend(ret, childVal); }
-    return ret
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          extend(ret, childVal);
+      return ret;
   };
   strats.provide = mergeDataOrFn;
-
   /**
    * Default strategy.
    */
-  var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined
-      ? parentVal
-      : childVal
+  const defaultStrat = function (parentVal, childVal) {
+      return childVal === undefined ? parentVal : childVal;
   };
-
   /**
    * Validate component names
    */
-  function checkComponents (options) {
-    for (var key in options.components) {
-      validateComponentName(key);
-    }
+  function checkComponents(options) {
+      for (const key in options.components) {
+          validateComponentName(key);
+      }
   }
-
-  function validateComponentName (name) {
-    if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-      warn(
-        'Invalid component name: "' + name + '". Component names ' +
-        'should conform to valid custom element name in html5 specification.'
-      );
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-      warn(
-        'Do not use built-in or reserved HTML elements as component ' +
-        'id: ' + name
-      );
-    }
+  function validateComponentName(name) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+          warn$2('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn$2('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
   }
-
   /**
    * Ensure all props option syntax are normalized into the
    * Object-based format.
    */
-  function normalizeProps (options, vm) {
-    var props = options.props;
-    if (!props) { return }
-    var res = {};
-    var i, val, name;
-    if (Array.isArray(props)) {
-      i = props.length;
-      while (i--) {
-        val = props[i];
-        if (typeof val === 'string') {
-          name = camelize(val);
-          res[name] = { type: null };
-        } else {
-          warn('props must be strings when using array syntax.');
-        }
-      }
-    } else if (isPlainObject(props)) {
-      for (var key in props) {
-        val = props[key];
-        name = camelize(key);
-        res[name] = isPlainObject(val)
-          ? val
-          : { type: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"props\": expected an Array or an Object, " +
-        "but got " + (toRawType(props)) + ".",
-        vm
-      );
-    }
-    options.props = res;
+  function normalizeProps(options, vm) {
+      const props = options.props;
+      if (!props)
+          return;
+      const res = {};
+      let i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn$2('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (const key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
+      }
+      options.props = res;
   }
-
   /**
    * Normalize all injections into Object-based format
    */
-  function normalizeInject (options, vm) {
-    var inject = options.inject;
-    if (!inject) { return }
-    var normalized = options.inject = {};
-    if (Array.isArray(inject)) {
-      for (var i = 0; i < inject.length; i++) {
-        normalized[inject[i]] = { from: inject[i] };
-      }
-    } else if (isPlainObject(inject)) {
-      for (var key in inject) {
-        var val = inject[key];
-        normalized[key] = isPlainObject(val)
-          ? extend({ from: key }, val)
-          : { from: val };
-      }
-    } else {
-      warn(
-        "Invalid value for option \"inject\": expected an Array or an Object, " +
-        "but got " + (toRawType(inject)) + ".",
-        vm
-      );
-    }
+  function normalizeInject(options, vm) {
+      const inject = options.inject;
+      if (!inject)
+          return;
+      const normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (let i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (const key in inject) {
+              const val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
+      }
   }
-
   /**
    * Normalize raw function directives into object format.
    */
-  function normalizeDirectives (options) {
-    var dirs = options.directives;
-    if (dirs) {
-      for (var key in dirs) {
-        var def$$1 = dirs[key];
-        if (typeof def$$1 === 'function') {
-          dirs[key] = { bind: def$$1, update: def$$1 };
-        }
-      }
-    }
-  }
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
-      );
-    }
+  function normalizeDirectives(options) {
+      const dirs = options.directives;
+      if (dirs) {
+          for (const key in dirs) {
+              const def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn$2(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
+      }
   }
-
   /**
    * Merge two option objects into a new one.
    * Core utility used in both instantiation and inheritance.
    */
-  function mergeOptions (
-    parent,
-    child,
-    vm
-  ) {
-    {
-      checkComponents(child);
-    }
-
-    if (typeof child === 'function') {
-      child = child.options;
-    }
-
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-      if (child.extends) {
-        parent = mergeOptions(parent, child.extends, vm);
-      }
-      if (child.mixins) {
-        for (var i = 0, l = child.mixins.length; i < l; i++) {
-          parent = mergeOptions(parent, child.mixins[i], vm);
-        }
-      }
-    }
-
-    var options = {};
-    var key;
-    for (key in parent) {
-      mergeField(key);
-    }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
-      }
-    }
-    function mergeField (key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      const options = {};
+      let key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          const strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
   }
-
   /**
    * Resolve an asset.
    * This function is used because child instances need access
    * to assets defined in its ancestor chain.
    */
-  function resolveAsset (
-    options,
-    type,
-    id,
-    warnMissing
-  ) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-      return
-    }
-    var assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id)) { return assets[id] }
-    var camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-    var PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-    // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-      warn(
-        'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-        options
-      );
-    }
-    return res
-  }
-
-  /*  */
-
-
-
-  function validateProp (
-    key,
-    propOptions,
-    propsData,
-    vm
-  ) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
-    // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-      if (absent && !hasOwn(prop, 'default')) {
-        value = false;
-      } else if (value === '' || value === hyphenate(key)) {
-        // only cast empty string / same name to boolean if
-        // boolean has higher priority
-        var stringIndex = getTypeIndex(String, prop.type);
-        if (stringIndex < 0 || booleanIndex < stringIndex) {
-          value = true;
-        }
-      }
-    }
-    // check default value
-    if (value === undefined) {
-      value = getPropDefaultValue(vm, prop, key);
-      // since the default value is a fresh copy,
-      // make sure to observe it.
-      var prevShouldObserve = shouldObserve;
-      toggleObserving(true);
-      observe(value);
-      toggleObserving(prevShouldObserve);
-    }
-    {
-      assertProp(prop, key, value, vm, absent);
-    }
-    return value
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      const assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          return assets[id];
+      const camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          return assets[PascalCaseId];
+      // fallback to prototype chain
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
+  }
+
+  function validateProp(key, propOptions, propsData, vm) {
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
+      // boolean casting
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              const stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          const prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
   }
-
   /**
    * Get the default value of a prop.
    */
-  function getPropDefaultValue (vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-      return undefined
-    }
-    var def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-      warn(
-        'Invalid default value for prop "' + key + '": ' +
-        'Props with type Object/Array must use a factory function ' +
-        'to return the default value.',
-        vm
-      );
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm && vm.$options.propsData &&
-      vm.$options.propsData[key] === undefined &&
-      vm._props[key] !== undefined
-    ) {
-      return vm._props[key]
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-      ? def.call(vm)
-      : def
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      const def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn$2('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
   }
-
   /**
    * Assert whether a prop is valid.
    */
-  function assertProp (
-    prop,
-    name,
-    value,
-    vm,
-    absent
-  ) {
-    if (prop.required && absent) {
-      warn(
-        'Missing required prop: "' + name + '"',
-        vm
-      );
-      return
-    }
-    if (value == null && !prop.required) {
-      return
-    }
-    var type = prop.type;
-    var valid = !type || type === true;
-    var expectedTypes = [];
-    if (type) {
-      if (!Array.isArray(type)) {
-        type = [type];
-      }
-      for (var i = 0; i < type.length && !valid; i++) {
-        var assertedType = assertType(value, type[i], vm);
-        expectedTypes.push(assertedType.expectedType || '');
-        valid = assertedType.valid;
-      }
-    }
-
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
-    if (!valid && haveExpectedTypes) {
-      warn(
-        getInvalidTypeMessage(name, value, expectedTypes),
-        vm
-      );
-      return
-    }
-    var validator = prop.validator;
-    if (validator) {
-      if (!validator(value)) {
-        warn(
-          'Invalid prop: custom validator check failed for prop "' + name + '".',
-          vm
-        );
-      }
-    }
-  }
-
-  var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-
-  function assertType (value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-      var t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      // for primitive wrapper objects
-      if (!valid && t === 'object') {
-        valid = value instanceof type;
-      }
-    } else if (expectedType === 'Object') {
-      valid = isPlainObject(value);
-    } else if (expectedType === 'Array') {
-      valid = Array.isArray(value);
-    } else {
-      try {
-        valid = value instanceof type;
-      } catch (e) {
-        warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-        valid = false;
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn$2('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      const haveExpectedTypes = expectedTypes.some((t) => t);
+      if (!valid && haveExpectedTypes) {
+          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      const validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
       }
-    }
-    return {
-      valid: valid,
-      expectedType: expectedType
-    }
   }
-
-  var functionTypeCheckRE = /^\s*function (\w+)/;
-
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      let valid;
+      const expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          const t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid,
+          expectedType,
+      };
+  }
+  const functionTypeCheckRE = /^\s*function (\w+)/;
   /**
    * Use function string name to check built-in types,
    * because a simple equality check will fail when running
    * across different vms / iframes.
    */
-  function getType (fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : ''
-  }
-
-  function isSameType (a, b) {
-    return getType(a) === getType(b)
-  }
-
-  function getTypeIndex (type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-      return isSameType(expectedTypes, type) ? 0 : -1
-    }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
-      if (isSameType(expectedTypes[i], type)) {
-        return i
-      }
-    }
-    return -1
-  }
-
-  function getInvalidTypeMessage (name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-      " Expected " + (expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (
-      expectedTypes.length === 1 &&
-      isExplicable(expectedType) &&
-      isExplicable(typeof value) &&
-      !isBoolean(expectedType, receivedType)
-    ) {
-      message += " with value " + (styleValue(value, expectedType));
-    }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-      message += "with value " + (styleValue(value, receivedType)) + ".";
-    }
-    return message
-  }
-
-  function styleValue (value, type) {
-    if (type === 'String') {
-      return ("\"" + value + "\"")
-    } else if (type === 'Number') {
-      return ("" + (Number(value)))
-    } else {
-      return ("" + value)
-    }
-  }
-
-  var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable (value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; })
-  }
-
-  function isBoolean () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
-  }
-
-  /*  */
-
-  function handleError (err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-      if (vm) {
-        var cur = vm;
-        while ((cur = cur.$parent)) {
-          var hooks = cur.$options.errorCaptured;
-          if (hooks) {
-            for (var i = 0; i < hooks.length; i++) {
-              try {
-                var capture = hooks[i].call(cur, err, vm, info) === false;
-                if (capture) { return }
-              } catch (e) {
-                globalHandleError(e, cur, 'errorCaptured hook');
-              }
-            }
+  function getType(fn) {
+      const match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
           }
-        }
       }
-      globalHandleError(err, vm, info);
-    } finally {
-      popTarget();
-    }
+      return -1;
   }
-
-  function invokeWithErrorHandling (
-    handler,
-    context,
-    args,
-    vm,
-    info
-  ) {
-    var res;
-    try {
-      res = args ? handler.apply(context, args) : handler.call(context);
-      if (res && !res._isVue && isPromise(res) && !res._handled) {
-        res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-        // issue #9511
-        // avoid catch triggering multiple times when nested calls
-        res._handled = true;
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += ` with value ${styleValue(value, expectedType)}`;
+      }
+      message += `, got ${receivedType} `;
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += `with value ${styleValue(value, receivedType)}.`;
       }
-    } catch (e) {
-      handleError(e, vm, info);
-    }
-    return res
+      return message;
   }
-
-  function globalHandleError (err, vm, info) {
-    logError(err, vm, info);
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return `"${value}"`;
+      }
+      else if (type === 'Number') {
+          return `${Number(value)}`;
+      }
+      else {
+          return `${value}`;
+      }
   }
-
-  function logError (err, vm, info) {
-    {
-      warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-      console.error(err);
-    } else {
-      throw err
-    }
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
   }
 
-  /*  */
-
-  var callbacks = [];
-
-  function flushCallbacks () {
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              let cur = vm;
+              while ((cur = cur.$parent)) {
+                  const hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (let i = 0; i < hooks.length; i++) {
+                          try {
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  return;
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      let res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          // @ts-expect-error should it be any?
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
   }
 
+  /* globals MutationObserver */
+  const callbacks = [];
+  function flushCallbacks() {
+      const copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (let i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
+  }
   // The nextTick behavior leverages the microtask queue, which can be accessed
   // via either native Promise.then or MutationObserver.
   // MutationObserver has wider support, however it is seriously bugged in
@@ -2066,1657 +1763,1511 @@
   // completely stops working after triggering a few times... so, if native
   // Promise is available, we will use it:
   /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-    isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]'
-  )) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true
-    });
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-  /*  */
-
-  /*  */
-
-  function genClassForVnode (vnode) {
-    var data = vnode.data;
-    var parentNode = vnode;
-    var childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-      childNode = childNode.componentInstance._vnode;
-      if (childNode && childNode.data) {
-        data = mergeClassData(childNode.data, data);
-      }
-    }
-    while (isDef(parentNode = parentNode.parent)) {
-      if (parentNode && parentNode.data) {
-        data = mergeClassData(data, parentNode.data);
-      }
-    }
-    return renderClass(data.staticClass, data.class)
-  }
-
-  function mergeClassData (child, parent) {
-    return {
-      staticClass: concat(child.staticClass, parent.staticClass),
-      class: isDef(child.class)
-        ? [child.class, parent.class]
-        : parent.class
-    }
-  }
-
-  function renderClass (
-    staticClass,
-    dynamicClass
-  ) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-      return concat(staticClass, stringifyClass(dynamicClass))
-    }
-    /* istanbul ignore next */
-    return ''
-  }
-
-  function concat (a, b) {
-    return a ? b ? (a + ' ' + b) : a : (b || '')
-  }
-
-  function stringifyClass (value) {
-    if (Array.isArray(value)) {
-      return stringifyArray(value)
-    }
-    if (isObject(value)) {
-      return stringifyObject(value)
-    }
-    if (typeof value === 'string') {
-      return value
-    }
-    /* istanbul ignore next */
-    return ''
-  }
-
-  function stringifyArray (value) {
-    var res = '';
-    var stringified;
-    for (var i = 0, l = value.length; i < l; i++) {
-      if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-        if (res) { res += ' '; }
-        res += stringified;
-      }
-    }
-    return res
-  }
-
-  function stringifyObject (value) {
-    var res = '';
-    for (var key in value) {
-      if (value[key]) {
-        if (res) { res += ' '; }
-        res += key;
-      }
-    }
-    return res
-  }
-
-  /*  */
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-  );
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+      Promise.resolve();
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+  else ;
+
+  function genClassForVnode(vnode) {
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass$1(data.staticClass, data.class);
+  }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
+  }
+  function renderClass$1(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
+  }
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function stringifyArray(value) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  res += ' ';
+              res += stringified;
+          }
+      }
+      return res;
+  }
+  function stringifyObject(value) {
+      let res = '';
+      for (const key in value) {
+          if (value[key]) {
+              if (res)
+                  res += ' ';
+              res += key;
+          }
+      }
+      return res;
+  }
 
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
   // this map is intentionally selective, only covering SVG elements that may
   // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  );
-
-  var isPreTag = function (tag) { return tag === 'pre'; };
-
-  var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  const isPreTag = (tag) => tag === 'pre';
+  const isReservedTag = (tag) => {
+      return isHTMLTag(tag) || isSVG(tag);
   };
-
-  function getTagNamespace (tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
   }
+  makeMap('text,number,password,search,email,tel,url');
 
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-  /*  */
-
-  /*  */
-
-  function renderClass$1 (node) {
-    var classList = genClassForVnode(node);
-    if (classList !== '') {
-      return (" class=\"" + (escape(classList)) + "\"")
-    }
+  function renderClass(node) {
+      const classList = genClassForVnode(node);
+      if (classList !== '') {
+          return ` class="${escape(classList)}"`;
+      }
   }
 
-  /*  */
-
-  var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              const tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
   });
-
   // merge static and dynamic style data on the same vnode
-  function normalizeStyleData (data) {
-    var style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle
-      ? extend(data.staticStyle, style)
-      : style
+  function normalizeStyleData(data) {
+      const style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
   }
-
   // normalize possible array / string values into Object
-  function normalizeStyleBinding (bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-      return toObject(bindingStyle)
-    }
-    if (typeof bindingStyle === 'string') {
-      return parseStyleText(bindingStyle)
-    }
-    return bindingStyle
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
   }
-
   /**
    * parent component style should be after child's
    * so that parent component's style could override it
    */
-  function getStyle (vnode, checkChild) {
-    var res = {};
-    var styleData;
-
-    if (checkChild) {
-      var childNode = vnode;
-      while (childNode.componentInstance) {
-        childNode = childNode.componentInstance._vnode;
-        if (
-          childNode && childNode.data &&
-          (styleData = normalizeStyleData(childNode.data))
-        ) {
+  function getStyle(vnode, checkChild) {
+      const res = {};
+      let styleData;
+      if (checkChild) {
+          let childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
           extend(res, styleData);
-        }
       }
-    }
-
-    if ((styleData = normalizeStyleData(vnode.data))) {
-      extend(res, styleData);
-    }
-
-    var parentNode = vnode;
-    while ((parentNode = parentNode.parent)) {
-      if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-        extend(res, styleData);
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
       }
-    }
-    return res
+      return res;
   }
 
-  /*  */
-
-  function genStyle (style) {
-    var styleText = '';
-    for (var key in style) {
-      var value = style[key];
-      var hyphenatedKey = hyphenate(key);
-      if (Array.isArray(value)) {
-        for (var i = 0, len = value.length; i < len; i++) {
-          styleText += normalizeValue(hyphenatedKey, value[i]);
-        }
-      } else {
-        styleText += normalizeValue(hyphenatedKey, value);
+  function genStyle(style) {
+      let styleText = '';
+      for (const key in style) {
+          const value = style[key];
+          const hyphenatedKey = hyphenate(key);
+          if (Array.isArray(value)) {
+              for (let i = 0, len = value.length; i < len; i++) {
+                  styleText += normalizeValue(hyphenatedKey, value[i]);
+              }
+          }
+          else {
+              styleText += normalizeValue(hyphenatedKey, value);
+          }
       }
-    }
-    return styleText
+      return styleText;
   }
-
   function normalizeValue(key, value) {
-    if (
-      typeof value === 'string' ||
-      (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-      value === 0
-    ) {
-      return (key + ":" + value + ";")
-    } else {
-      // invalid values
-      return ""
-    }
-  }
-
-  function renderStyle (vnode) {
-    var styleText = genStyle(getStyle(vnode, false));
-    if (styleText !== '') {
-      return (" style=" + (JSON.stringify(escape(styleText))))
-    }
-  }
-
-  var modules = [
-    renderAttrs,
-    renderDOMProps,
-    renderClass$1,
-    renderStyle
-  ];
+      if (typeof value === 'string' ||
+          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+          value === 0) {
+          return `${key}:${value};`;
+      }
+      else {
+          // invalid values
+          return ``;
+      }
+  }
+  function renderStyle(vnode) {
+      const styleText = genStyle(getStyle(vnode, false));
+      if (styleText !== '') {
+          return ` style=${JSON.stringify(escape(styleText))}`;
+      }
+  }
 
-  /*  */
+  var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-  function show (node, dir) {
-    if (!dir.value) {
-      var style = node.data.style || (node.data.style = {});
-      if (Array.isArray(style)) {
-        style.push({ display: 'none' });
-      } else {
-        style.display = 'none';
+  function show(node, dir) {
+      if (!dir.value) {
+          const style = node.data.style || (node.data.style = {});
+          if (Array.isArray(style)) {
+              style.push({ display: 'none' });
+          }
+          else {
+              style.display = 'none';
+          }
       }
-    }
   }
 
-  /*  */
-
   // this is only applied for <select v-model> because it is the only edge case
   // that must be done at runtime instead of compile time.
-  function model (node, dir) {
-    if (!node.children) { return }
-    var value = dir.value;
-    var isMultiple = node.data.attrs && node.data.attrs.multiple;
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var option = node.children[i];
-      if (option.tag === 'option') {
-        if (isMultiple) {
-          var selected =
-            Array.isArray(value) &&
-            (looseIndexOf(value, getValue(option)) > -1);
-          if (selected) {
-            setSelected(option);
-          }
-        } else {
-          if (looseEqual(value, getValue(option))) {
-            setSelected(option);
-            return
+  function model$2(node, dir) {
+      if (!node.children)
+          return;
+      const value = dir.value;
+      const isMultiple = node.data.attrs && node.data.attrs.multiple;
+      for (let i = 0, l = node.children.length; i < l; i++) {
+          const option = node.children[i];
+          if (option.tag === 'option') {
+              if (isMultiple) {
+                  const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                  if (selected) {
+                      setSelected(option);
+                  }
+              }
+              else {
+                  if (looseEqual(value, getValue(option))) {
+                      setSelected(option);
+                      return;
+                  }
+              }
           }
-        }
       }
-    }
   }
-
-  function getValue (option) {
-    var data = option.data || {};
-    return (
-      (data.attrs && data.attrs.value) ||
-      (data.domProps && data.domProps.value) ||
-      (option.children && option.children[0] && option.children[0].text)
-    )
+  function getValue(option) {
+      const data = option.data || {};
+      return ((data.attrs && data.attrs.value) ||
+          (data.domProps && data.domProps.value) ||
+          (option.children && option.children[0] && option.children[0].text));
   }
-
-  function setSelected (option) {
-    var data = option.data || (option.data = {});
-    var attrs = data.attrs || (data.attrs = {});
-    attrs.selected = '';
+  function setSelected(option) {
+      const data = option.data || (option.data = {});
+      const attrs = data.attrs || (data.attrs = {});
+      attrs.selected = '';
   }
 
-  var directives = {
-    show: show,
-    model: model
+  var directives$1 = {
+      show,
+      model: model$2,
   };
 
-  /*  */
-
-  var isUnaryTag = makeMap(
-    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr'
-  );
-
+  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
   // Elements that you can, intentionally, leave open
   // (and which close themselves)
-  var canBeLeftOpenTag = makeMap(
-    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-  );
-
+  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
   // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
   // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap(
-    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track'
-  );
-
-  /*  */
-
-  var MAX_STACK_DEPTH = 800;
-  var noop$1 = function (_) { return _; };
-
-  var defer = typeof process !== 'undefined' && process.nextTick
-    ? process.nextTick
-    : typeof Promise !== 'undefined'
-      ? function (fn) { return Promise.resolve().then(fn); }
-      : typeof setTimeout !== 'undefined'
-        ? setTimeout
-        : noop$1;
-
-  if (defer === noop$1) {
-    throw new Error(
-      'Your JavaScript runtime does not support any asynchronous primitives ' +
-      'that are required by vue-server-renderer. Please use a polyfill for ' +
-      'either Promise or setTimeout.'
-    )
-  }
-
-  function createWriteFunction (
-    write,
-    onError
-  ) {
-    var stackDepth = 0;
-    var cachedWrite = function (text, next) {
-      if (text && cachedWrite.caching) {
-        cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-      }
-      var waitForNext = write(text, next);
-      if (waitForNext !== true) {
-        if (stackDepth >= MAX_STACK_DEPTH) {
-          defer(function () {
-            try { next(); } catch (e) {
-              onError(e);
-            }
-          });
-        } else {
-          stackDepth++;
-          next();
-          stackDepth--;
-        }
+  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track');
+
+  const MAX_STACK_DEPTH = 800;
+  const noop = (_) => _;
+  const defer = typeof process !== 'undefined' && process.nextTick
+      ? process.nextTick
+      : typeof Promise !== 'undefined'
+          ? (fn) => Promise.resolve().then(fn)
+          : typeof setTimeout !== 'undefined'
+              ? setTimeout
+              : noop;
+  if (defer === noop) {
+      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+          'that are required by vue-server-renderer. Please use a polyfill for ' +
+          'either Promise or setTimeout.');
+  }
+  function createWriteFunction(write, onError) {
+      let stackDepth = 0;
+      const cachedWrite = (text, next) => {
+          if (text && cachedWrite.caching) {
+              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+          }
+          const waitForNext = write(text, next);
+          if (waitForNext !== true) {
+              if (stackDepth >= MAX_STACK_DEPTH) {
+                  defer(() => {
+                      try {
+                          next();
+                      }
+                      catch (e) {
+                          onError(e);
+                      }
+                  });
+              }
+              else {
+                  stackDepth++;
+                  next();
+                  stackDepth--;
+              }
+          }
+      };
+      cachedWrite.caching = false;
+      cachedWrite.cacheBuffer = [];
+      cachedWrite.componentBuffer = [];
+      return cachedWrite;
+  }
+
+  class RenderContext {
+      userContext;
+      activeInstance;
+      renderStates;
+      write;
+      renderNode;
+      //@ts-expect-error
+      next;
+      done;
+      modules;
+      directives;
+      isUnaryTag;
+      cache;
+      get;
+      has;
+      constructor(options) {
+          this.userContext = options.userContext;
+          this.activeInstance = options.activeInstance;
+          this.renderStates = [];
+          this.write = options.write;
+          this.done = options.done;
+          this.renderNode = options.renderNode;
+          this.isUnaryTag = options.isUnaryTag;
+          this.modules = options.modules;
+          this.directives = options.directives;
+          const cache = options.cache;
+          if (cache && (!cache.get || !cache.set)) {
+              throw new Error('renderer cache must implement at least get & set.');
+          }
+          this.cache = cache;
+          this.get = cache && normalizeAsync(cache, 'get');
+          this.has = cache && normalizeAsync(cache, 'has');
+          //@ts-expect-error
+          this.next = this.next.bind(this);
+      }
+      //@ts-expect-error
+      next() {
+          // eslint-disable-next-line
+          while (true) {
+              const lastState = this.renderStates[this.renderStates.length - 1];
+              if (isUndef(lastState)) {
+                  return this.done();
+              }
+              /* eslint-disable no-case-declarations */
+              switch (lastState.type) {
+                  case 'Element':
+                  case 'Fragment':
+                      const { children, total } = lastState;
+                      const rendered = lastState.rendered++;
+                      if (rendered < total) {
+                          return this.renderNode(children[rendered], false, this);
+                      }
+                      else {
+                          this.renderStates.pop();
+                          if (lastState.type === 'Element') {
+                              return this.write(lastState.endTag, this.next);
+                          }
+                      }
+                      break;
+                  case 'Component':
+                      this.renderStates.pop();
+                      this.activeInstance = lastState.prevActive;
+                      break;
+                  case 'ComponentWithCache':
+                      this.renderStates.pop();
+                      const { buffer, bufferIndex, componentBuffer, key } = lastState;
+                      const result = {
+                          html: buffer[bufferIndex],
+                          components: componentBuffer[bufferIndex],
+                      };
+                      this.cache.set(key, result);
+                      if (bufferIndex === 0) {
+                          // this is a top-level cached component,
+                          // exit caching mode.
+                          //@ts-expect-error
+                          this.write.caching = false;
+                      }
+                      else {
+                          // parent component is also being cached,
+                          // merge self into parent's result
+                          buffer[bufferIndex - 1] += result.html;
+                          const prev = componentBuffer[bufferIndex - 1];
+                          result.components.forEach((c) => prev.add(c));
+                      }
+                      buffer.length = bufferIndex;
+                      componentBuffer.length = bufferIndex;
+                      break;
+              }
+          }
       }
-    };
-    cachedWrite.caching = false;
-    cachedWrite.cacheBuffer = [];
-    cachedWrite.componentBuffer = [];
-    return cachedWrite
   }
-
-  /*  */
-
-
-
-  var RenderContext = function RenderContext (options) {
-    this.userContext = options.userContext;
-    this.activeInstance = options.activeInstance;
-    this.renderStates = [];
-
-    this.write = options.write;
-    this.done = options.done;
-    this.renderNode = options.renderNode;
-
-    this.isUnaryTag = options.isUnaryTag;
-    this.modules = options.modules;
-    this.directives = options.directives;
-
-    var cache = options.cache;
-    if (cache && (!cache.get || !cache.set)) {
-      throw new Error('renderer cache must implement at least get & set.')
-    }
-    this.cache = cache;
-    this.get = cache && normalizeAsync(cache, 'get');
-    this.has = cache && normalizeAsync(cache, 'has');
-
-    this.next = this.next.bind(this);
-  };
-
-  RenderContext.prototype.next = function next () {
-    // eslint-disable-next-line
-    while (true) {
-      var lastState = this.renderStates[this.renderStates.length - 1];
-      if (isUndef(lastState)) {
-        return this.done()
-      }
-      /* eslint-disable no-case-declarations */
-      switch (lastState.type) {
-        case 'Element':
-        case 'Fragment':
-          var children = lastState.children;
-        var total = lastState.total;
-          var rendered = lastState.rendered++;
-          if (rendered < total) {
-            return this.renderNode(children[rendered], false, this)
-          } else {
-            this.renderStates.pop();
-            if (lastState.type === 'Element') {
-              return this.write(lastState.endTag, this.next)
-            }
-          }
-          break
-        case 'Component':
-          this.renderStates.pop();
-          this.activeInstance = lastState.prevActive;
-          break
-        case 'ComponentWithCache':
-          this.renderStates.pop();
-          var buffer = lastState.buffer;
-        var bufferIndex = lastState.bufferIndex;
-        var componentBuffer = lastState.componentBuffer;
-        var key = lastState.key;
-          var result = {
-            html: buffer[bufferIndex],
-            components: componentBuffer[bufferIndex]
-          };
-          this.cache.set(key, result);
-          if (bufferIndex === 0) {
-            // this is a top-level cached component,
-            // exit caching mode.
-            this.write.caching = false;
-          } else {
-            // parent component is also being cached,
-            // merge self into parent's result
-            buffer[bufferIndex - 1] += result.html;
-            var prev = componentBuffer[bufferIndex - 1];
-            result.components.forEach(function (c) { return prev.add(c); });
-          }
-          buffer.length = bufferIndex;
-          componentBuffer.length = bufferIndex;
-          break
-      }
-    }
-  };
-
-  function normalizeAsync (cache, method) {
-    var fn = cache[method];
-    if (isUndef(fn)) {
-      return
-    } else if (fn.length > 1) {
-      return function (key, cb) { return fn.call(cache, key, cb); }
-    } else {
-      return function (key, cb) { return cb(fn.call(cache, key)); }
-    }
-  }
-
-  /*  */
-
-  var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-  function parseFilters (exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
-
-    for (i = 0; i < exp.length; i++) {
-      prev = c;
-      c = exp.charCodeAt(i);
-      if (inSingle) {
-        if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-      } else if (inDouble) {
-        if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-      } else if (inTemplateString) {
-        if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-      } else if (inRegex) {
-        if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-      } else if (
-        c === 0x7C && // pipe
-        exp.charCodeAt(i + 1) !== 0x7C &&
-        exp.charCodeAt(i - 1) !== 0x7C &&
-        !curly && !square && !paren
-      ) {
-        if (expression === undefined) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1;
+  function normalizeAsync(cache, method) {
+      const fn = cache[method];
+      if (isUndef(fn)) {
+          return;
+      }
+      else if (fn.length > 1) {
+          return (key, cb) => fn.call(cache, key, cb);
+      }
+      else {
+          return (key, cb) => cb(fn.call(cache, key));
+      }
+  }
+
+  const validDivisionCharRE = /[\w).+\-_$\]]/;
+  function parseFilters(exp) {
+      let inSingle = false;
+      let inDouble = false;
+      let inTemplateString = false;
+      let inRegex = false;
+      let curly = 0;
+      let square = 0;
+      let paren = 0;
+      let lastFilterIndex = 0;
+      let c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  inSingle = false;
+          }
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  inDouble = false;
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  inTemplateString = false;
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  inRegex = false;
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  let j = i - 1;
+                  let p;
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          break;
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
+          }
+      }
+      if (expression === undefined) {
           expression = exp.slice(0, i).trim();
-        } else {
+      }
+      else if (lastFilterIndex !== 0) {
           pushFilter();
-        }
-      } else {
-        switch (c) {
-          case 0x22: inDouble = true; break         // "
-          case 0x27: inSingle = true; break         // '
-          case 0x60: inTemplateString = true; break // `
-          case 0x28: paren++; break                 // (
-          case 0x29: paren--; break                 // )
-          case 0x5B: square++; break                // [
-          case 0x5D: square--; break                // ]
-          case 0x7B: curly++; break                 // {
-          case 0x7D: curly--; break                 // }
-        }
-        if (c === 0x2f) { // /
-          var j = i - 1;
-          var p = (void 0);
-          // find first non-whitespace prev char
-          for (; j >= 0; j--) {
-            p = exp.charAt(j);
-            if (p !== ' ') { break }
-          }
-          if (!p || !validDivisionCharRE.test(p)) {
-            inRegex = true;
-          }
-        }
-      }
-    }
-
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
-    }
-
-    function pushFilter () {
-      (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-      lastFilterIndex = i + 1;
-    }
-
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i]);
-      }
-    }
-
-    return expression
-  }
-
-  function wrapFilter (exp, filter) {
-    var i = filter.indexOf('(');
-    if (i < 0) {
-      // _f: resolveFilter
-      return ("_f(\"" + filter + "\")(" + exp + ")")
-    } else {
-      var name = filter.slice(0, i);
-      var args = filter.slice(i + 1);
-      return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-    }
-  }
-
-  /*  */
-
-  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
-  var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-  });
-
-
-
-  function parseText (
-    text,
-    delimiters
-  ) {
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-      return
-    }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = tagRE.lastIndex = 0;
-    var match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-      index = match.index;
-      // push text token
-      if (index > lastIndex) {
-        rawTokens.push(tokenValue = text.slice(lastIndex, index));
-        tokens.push(JSON.stringify(tokenValue));
-      }
-      // tag token
-      var exp = parseFilters(match[1].trim());
-      tokens.push(("_s(" + exp + ")"));
-      rawTokens.push({ '@binding': exp });
-      lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      rawTokens.push(tokenValue = text.slice(lastIndex));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
-    }
-  }
-
-  /*  */
-
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
+  }
+  function wrapFilter(exp, filter) {
+      const i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return `_f("${filter}")(${exp})`;
+      }
+      else {
+          const name = filter.slice(0, i);
+          const args = filter.slice(i + 1);
+          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+      }
+  }
 
+  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+  const buildRegex = cached((delimiters) => {
+      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+  });
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      const tokens = [];
+      const rawTokens = [];
+      let lastIndex = (tagRE.lastIndex = 0);
+      let match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          const exp = parseFilters(match[1].trim());
+          tokens.push(`_s(${exp})`);
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
+  }
 
   /* eslint-disable no-unused-vars */
-  function baseWarn (msg, range) {
-    console.error(("[Vue compiler]: " + msg));
+  function baseWarn(msg, range) {
+      console.error(`[Vue compiler]: ${msg}`);
   }
   /* eslint-enable no-unused-vars */
-
-  function pluckModuleFunction (
-    modules,
-    key
-  ) {
-    return modules
-      ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-      : []
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
   }
-
-  function addProp (el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
   }
-
-  function addAttr (el, name, value, range, dynamic) {
-    var attrs = dynamic
-      ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-      : (el.attrs || (el.attrs = []));
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
+  function addAttr(el, name, value, range, dynamic) {
+      const attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
   }
-
   // add a raw attr (use this in preTransforms)
-  function addRawAttr (el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-  }
-
-  function addDirective (
-    el,
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers,
-    range
-  ) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-      name: name,
-      rawName: rawName,
-      value: value,
-      arg: arg,
-      isDynamicArg: isDynamicArg,
-      modifiers: modifiers
-    }, range));
-    el.plain = false;
-  }
-
-  function prependModifierMarker (symbol, name, dynamic) {
-    return dynamic
-      ? ("_p(" + name + ",\"" + symbol + "\")")
-      : symbol + name // mark the event as captured
-  }
-
-  function addHandler (
-    el,
-    name,
-    value,
-    modifiers,
-    important,
-    warn,
-    range,
-    dynamic
-  ) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (
-      warn &&
-      modifiers.prevent && modifiers.passive
-    ) {
-      warn(
-        'passive and prevent can\'t be used together. ' +
-        'Passive handler can\'t prevent default event.',
-        range
-      );
-    }
-
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'contextmenu';
-        delete modifiers.right;
-      }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'mouseup';
-      }
-    }
-
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture;
-      name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-      delete modifiers.once;
-      name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive;
-      name = prependModifierMarker('&', name, dynamic);
-    }
-
-    var events;
-    if (modifiers.native) {
-      delete modifiers.native;
-      events = el.nativeEvents || (el.nativeEvents = {});
-    } else {
-      events = el.events || (el.events = {});
-    }
-
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers;
-    }
-
-    var handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-      important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    } else if (handlers) {
-      events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    } else {
-      events[name] = newHandler;
-    }
-
-    el.plain = false;
-  }
-
-  function getRawBindingAttr (
-    el,
-    name
-  ) {
-    return el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
-  }
-
-  function getBindingAttr (
-    el,
-    name,
-    getStatic
-  ) {
-    var dynamicValue =
-      getAndRemoveAttr(el, ':' + name) ||
-      getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-      return parseFilters(dynamicValue)
-    } else if (getStatic !== false) {
-      var staticValue = getAndRemoveAttr(el, name);
-      if (staticValue != null) {
-        return JSON.stringify(staticValue)
-      }
-    }
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name, value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamicArg,
+          modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = `(${name})==='click'?'contextmenu':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = `(${name})==='click'?'mouseup':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      let events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      const handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
+  }
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
+  }
+  function getBindingAttr(el, name, getStatic) {
+      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          const staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
   }
-
   // note: this only removes the attr from the Array (attrsList) so that it
   // doesn't get processed by processAttrs.
   // By default it does NOT remove it from the map (attrsMap) because the map is
   // needed during codegen.
-  function getAndRemoveAttr (
-    el,
-    name,
-    removeFromMap
-  ) {
-    var val;
-    if ((val = el.attrsMap[name]) != null) {
-      var list = el.attrsList;
-      for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i].name === name) {
-          list.splice(i, 1);
-          break
-        }
-      }
-    }
-    if (removeFromMap) {
-      delete el.attrsMap[name];
-    }
-    return val
-  }
-
-  function getAndRemoveAttrByRegex (
-    el,
-    name
-  ) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      var attr = list[i];
-      if (name.test(attr.name)) {
-        list.splice(i, 1);
-        return attr
-      }
-    }
-  }
-
-  function rangeSetItem (
-    item,
-    range
-  ) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start;
-      }
-      if (range.end != null) {
-        item.end = range.end;
-      }
-    }
-    return item
-  }
-
-  /*  */
-
-  function transformNode (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-      var res = parseText(staticClass, options.delimiters);
-      if (res) {
-        warn(
-          "class=\"" + staticClass + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div class="{{ val }}">, use <div :class="val">.',
-          el.rawAttrsMap['class']
-        );
-      }
-    }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass);
-    }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-      el.classBinding = classBinding;
-    }
-  }
-
-  function genData (el) {
-    var data = '';
-    if (el.staticClass) {
-      data += "staticClass:" + (el.staticClass) + ",";
-    }
-    if (el.classBinding) {
-      data += "class:" + (el.classBinding) + ",";
-    }
-    return data
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      let val;
+      if ((val = el.attrsMap[name]) != null) {
+          const list = el.attrsList;
+          for (let i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
+      }
+      if (removeFromMap) {
+          delete el.attrsMap[name];
+      }
+      return val;
+  }
+  function getAndRemoveAttrByRegex(el, name) {
+      const list = el.attrsList;
+      for (let i = 0, l = list.length; i < l; i++) {
+          const attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
+      }
+  }
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
+      }
+      return item;
   }
 
+  function transformNode$1(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          const res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn(`class="${staticClass}": ` +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
+      }
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+      }
+      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
+      }
+  }
+  function genData$2(el) {
+      let data = '';
+      if (el.staticClass) {
+          data += `staticClass:${el.staticClass},`;
+      }
+      if (el.classBinding) {
+          data += `class:${el.classBinding},`;
+      }
+      return data;
+  }
   var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData
+      staticKeys: ['staticClass'],
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
-  /*  */
-
-  function transformNode$1 (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-      /* istanbul ignore if */
-      {
-        var res = parseText(staticStyle, options.delimiters);
-        if (res) {
-          warn(
-            "style=\"" + staticStyle + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div style="{{ val }}">, use <div :style="val">.',
-            el.rawAttrsMap['style']
-          );
-        }
+  function transformNode(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              const res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn(`style="${staticStyle}": ` +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
       }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-      el.styleBinding = styleBinding;
-    }
   }
-
-  function genData$1 (el) {
-    var data = '';
-    if (el.staticStyle) {
-      data += "staticStyle:" + (el.staticStyle) + ",";
-    }
-    if (el.styleBinding) {
-      data += "style:(" + (el.styleBinding) + "),";
-    }
-    return data
+  function genData$1(el) {
+      let data = '';
+      if (el.staticStyle) {
+          data += `staticStyle:${el.staticStyle},`;
+      }
+      if (el.styleBinding) {
+          data += `style:(${el.styleBinding}),`;
+      }
+      return data;
   }
-
   var style = {
-    staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
-    genData: genData$1
+      staticKeys: ['staticStyle'],
+      transformNode,
+      genData: genData$1,
   };
 
-  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-  function createCommonjsModule(fn, module) {
-  	return module = { exports: {} }, fn(module, module.exports), module.exports;
-  }
+  var he$1 = {exports: {}};
 
-  var he = createCommonjsModule(function (module, exports) {
+  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+
+  (function (module, exports) {
   (function(root) {
 
-  	// Detect free variables `exports`.
-  	var freeExports = exports;
-
-  	// Detect free variable `module`.
-  	var freeModule = module &&
-  		module.exports == freeExports && module;
-
-  	// Detect free variable `global`, from Node.js or Browserified code,
-  	// and use it as `root`.
-  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-  		root = freeGlobal;
-  	}
-
-  	/*--------------------------------------------------------------------------*/
-
-  	// All astral symbols.
-  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  	// All ASCII symbols (not just printable ASCII) except those listed in the
-  	// first column of the overrides table.
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-  	// code points listed in the first column of the overrides table on
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-  	var regexEscape = /["&'<>`]/g;
-  	var escapeMap = {
-  		'"': '&quot;',
-  		'&': '&amp;',
-  		'\'': '&#x27;',
-  		'<': '&lt;',
-  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-  		// following is not strictly necessary unless it’s part of a tag or an
-  		// unquoted attribute value. We’re only escaping it to support those
-  		// situations, and for XML support.
-  		'>': '&gt;',
-  		// In Internet Explorer ≤ 8, the backtick character can be used
-  		// to break out of (un)quoted attribute values or HTML comments.
-  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-  		// http://html5sec.org/#133.
-  		'`': '&#x60;'
-  	};
-
-  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var stringFromCharCode = String.fromCharCode;
-
-  	var object = {};
-  	var hasOwnProperty = object.hasOwnProperty;
-  	var has = function(object, propertyName) {
-  		return hasOwnProperty.call(object, propertyName);
-  	};
-
-  	var contains = function(array, value) {
-  		var index = -1;
-  		var length = array.length;
-  		while (++index < length) {
-  			if (array[index] == value) {
-  				return true;
-  			}
-  		}
-  		return false;
-  	};
+  		// Detect free variables `exports`.
+  		var freeExports = exports;
 
-  	var merge = function(options, defaults) {
-  		if (!options) {
-  			return defaults;
-  		}
-  		var result = {};
-  		var key;
-  		for (key in defaults) {
-  			// A `hasOwnProperty` check is not needed here, since only recognized
-  			// option names are used anyway. Any others are ignored.
-  			result[key] = has(options, key) ? options[key] : defaults[key];
-  		}
-  		return result;
-  	};
-
-  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-  	var codePointToSymbol = function(codePoint, strict) {
-  		var output = '';
-  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-  			// See issue #4:
-  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-  			// REPLACEMENT CHARACTER.”
-  			if (strict) {
-  				parseError('character reference outside the permissible Unicode range');
-  			}
-  			return '\uFFFD';
-  		}
-  		if (has(decodeMapNumeric, codePoint)) {
-  			if (strict) {
-  				parseError('disallowed character reference');
-  			}
-  			return decodeMapNumeric[codePoint];
-  		}
-  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-  			parseError('disallowed character reference');
-  		}
-  		if (codePoint > 0xFFFF) {
-  			codePoint -= 0x10000;
-  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-  			codePoint = 0xDC00 | codePoint & 0x3FF;
+  		// Detect free variable `module`.
+  		var freeModule = module &&
+  			module.exports == freeExports && module;
+
+  		// Detect free variable `global`, from Node.js or Browserified code,
+  		// and use it as `root`.
+  		var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+  		if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+  			root = freeGlobal;
   		}
-  		output += stringFromCharCode(codePoint);
-  		return output;
-  	};
 
-  	var hexEscape = function(codePoint) {
-  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-  	};
+  		/*--------------------------------------------------------------------------*/
+
+  		// All astral symbols.
+  		var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  		// All ASCII symbols (not just printable ASCII) except those listed in the
+  		// first column of the overrides table.
+  		// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+  		var regexAsciiWhitelist = /[\x01-\x7F]/g;
+  		// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+  		// code points listed in the first column of the overrides table on
+  		// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+  		var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+  		var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+  		var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+  		var regexEscape = /["&'<>`]/g;
+  		var escapeMap = {
+  			'"': '&quot;',
+  			'&': '&amp;',
+  			'\'': '&#x27;',
+  			'<': '&lt;',
+  			// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+  			// following is not strictly necessary unless it’s part of a tag or an
+  			// unquoted attribute value. We’re only escaping it to support those
+  			// situations, and for XML support.
+  			'>': '&gt;',
+  			// In Internet Explorer ≤ 8, the backtick character can be used
+  			// to break out of (un)quoted attribute values or HTML comments.
+  			// See http://html5sec.org/#102, http://html5sec.org/#108, and
+  			// http://html5sec.org/#133.
+  			'`': '&#x60;'
+  		};
 
-  	var decEscape = function(codePoint) {
-  		return '&#' + codePoint + ';';
-  	};
+  		var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+  		var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+  		var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+  		var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+  		var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+  		var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+  		var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
 
-  	var parseError = function(message) {
-  		throw Error('Parse error: ' + message);
-  	};
+  		/*--------------------------------------------------------------------------*/
 
-  	/*--------------------------------------------------------------------------*/
+  		var stringFromCharCode = String.fromCharCode;
 
-  	var encode = function(string, options) {
-  		options = merge(options, encode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidRawCodePoint.test(string)) {
-  			parseError('forbidden code point');
-  		}
-  		var encodeEverything = options.encodeEverything;
-  		var useNamedReferences = options.useNamedReferences;
-  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+  		var object = {};
+  		var hasOwnProperty = object.hasOwnProperty;
+  		var has = function(object, propertyName) {
+  			return hasOwnProperty.call(object, propertyName);
+  		};
+
+  		var contains = function(array, value) {
+  			var index = -1;
+  			var length = array.length;
+  			while (++index < length) {
+  				if (array[index] == value) {
+  					return true;
+  				}
+  			}
+  			return false;
+  		};
 
-  		var escapeBmpSymbol = function(symbol) {
-  			return escapeCodePoint(symbol.charCodeAt(0));
+  		var merge = function(options, defaults) {
+  			if (!options) {
+  				return defaults;
+  			}
+  			var result = {};
+  			var key;
+  			for (key in defaults) {
+  				// A `hasOwnProperty` check is not needed here, since only recognized
+  				// option names are used anyway. Any others are ignored.
+  				result[key] = has(options, key) ? options[key] : defaults[key];
+  			}
+  			return result;
   		};
 
-  		if (encodeEverything) {
-  			// Encode ASCII symbols.
-  			string = string.replace(regexAsciiWhitelist, function(symbol) {
-  				// Use named references if requested & possible.
-  				if (useNamedReferences && has(encodeMap, symbol)) {
-  					return '&' + encodeMap[symbol] + ';';
+  		// Modified version of `ucs2encode`; see https://mths.be/punycode.
+  		var codePointToSymbol = function(codePoint, strict) {
+  			var output = '';
+  			if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+  				// See issue #4:
+  				// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+  				// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+  				// REPLACEMENT CHARACTER.”
+  				if (strict) {
+  					parseError('character reference outside the permissible Unicode range');
   				}
-  				return escapeBmpSymbol(symbol);
-  			});
-  			// Shorten a few escapes that represent two symbols, of which at least one
-  			// is within the ASCII range.
-  			if (useNamedReferences) {
+  				return '\uFFFD';
+  			}
+  			if (has(decodeMapNumeric, codePoint)) {
+  				if (strict) {
+  					parseError('disallowed character reference');
+  				}
+  				return decodeMapNumeric[codePoint];
+  			}
+  			if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+  				parseError('disallowed character reference');
+  			}
+  			if (codePoint > 0xFFFF) {
+  				codePoint -= 0x10000;
+  				output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+  				codePoint = 0xDC00 | codePoint & 0x3FF;
+  			}
+  			output += stringFromCharCode(codePoint);
+  			return output;
+  		};
+
+  		var hexEscape = function(codePoint) {
+  			return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+  		};
+
+  		var decEscape = function(codePoint) {
+  			return '&#' + codePoint + ';';
+  		};
+
+  		var parseError = function(message) {
+  			throw Error('Parse error: ' + message);
+  		};
+
+  		/*--------------------------------------------------------------------------*/
+
+  		var encode = function(string, options) {
+  			options = merge(options, encode.options);
+  			var strict = options.strict;
+  			if (strict && regexInvalidRawCodePoint.test(string)) {
+  				parseError('forbidden code point');
+  			}
+  			var encodeEverything = options.encodeEverything;
+  			var useNamedReferences = options.useNamedReferences;
+  			var allowUnsafeSymbols = options.allowUnsafeSymbols;
+  			var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+  			var escapeBmpSymbol = function(symbol) {
+  				return escapeCodePoint(symbol.charCodeAt(0));
+  			};
+
+  			if (encodeEverything) {
+  				// Encode ASCII symbols.
+  				string = string.replace(regexAsciiWhitelist, function(symbol) {
+  					// Use named references if requested & possible.
+  					if (useNamedReferences && has(encodeMap, symbol)) {
+  						return '&' + encodeMap[symbol] + ';';
+  					}
+  					return escapeBmpSymbol(symbol);
+  				});
+  				// Shorten a few escapes that represent two symbols, of which at least one
+  				// is within the ASCII range.
+  				if (useNamedReferences) {
+  					string = string
+  						.replace(/&gt;\u20D2/g, '&nvgt;')
+  						.replace(/&lt;\u20D2/g, '&nvlt;')
+  						.replace(/&#x66;&#x6A;/g, '&fjlig;');
+  				}
+  				// Encode non-ASCII symbols.
+  				if (useNamedReferences) {
+  					// Encode non-ASCII symbols that can be replaced with a named reference.
+  					string = string.replace(regexEncodeNonAscii, function(string) {
+  						// Note: there is no need to check `has(encodeMap, string)` here.
+  						return '&' + encodeMap[string] + ';';
+  					});
+  				}
+  				// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+  			} else if (useNamedReferences) {
+  				// Apply named character references.
+  				// Encode `<>"'&` using named character references.
+  				if (!allowUnsafeSymbols) {
+  					string = string.replace(regexEscape, function(string) {
+  						return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+  					});
+  				}
+  				// Shorten escapes that represent two symbols, of which at least one is
+  				// `<>"'&`.
   				string = string
   					.replace(/&gt;\u20D2/g, '&nvgt;')
-  					.replace(/&lt;\u20D2/g, '&nvlt;')
-  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-  			}
-  			// Encode non-ASCII symbols.
-  			if (useNamedReferences) {
+  					.replace(/&lt;\u20D2/g, '&nvlt;');
   				// Encode non-ASCII symbols that can be replaced with a named reference.
   				string = string.replace(regexEncodeNonAscii, function(string) {
   					// Note: there is no need to check `has(encodeMap, string)` here.
   					return '&' + encodeMap[string] + ';';
   				});
+  			} else if (!allowUnsafeSymbols) {
+  				// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+  				// using named character references.
+  				string = string.replace(regexEscape, escapeBmpSymbol);
   			}
-  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-  		} else if (useNamedReferences) {
-  			// Apply named character references.
-  			// Encode `<>"'&` using named character references.
-  			if (!allowUnsafeSymbols) {
-  				string = string.replace(regexEscape, function(string) {
-  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-  				});
-  			}
-  			// Shorten escapes that represent two symbols, of which at least one is
-  			// `<>"'&`.
-  			string = string
-  				.replace(/&gt;\u20D2/g, '&nvgt;')
-  				.replace(/&lt;\u20D2/g, '&nvlt;');
-  			// Encode non-ASCII symbols that can be replaced with a named reference.
-  			string = string.replace(regexEncodeNonAscii, function(string) {
-  				// Note: there is no need to check `has(encodeMap, string)` here.
-  				return '&' + encodeMap[string] + ';';
-  			});
-  		} else if (!allowUnsafeSymbols) {
-  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-  			// using named character references.
-  			string = string.replace(regexEscape, escapeBmpSymbol);
-  		}
-  		return string
-  			// Encode astral symbols.
-  			.replace(regexAstralSymbols, function($0) {
-  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-  				var high = $0.charCodeAt(0);
-  				var low = $0.charCodeAt(1);
-  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-  				return escapeCodePoint(codePoint);
-  			})
-  			// Encode any remaining BMP symbols that are not printable ASCII symbols
-  			// using a hexadecimal escape.
-  			.replace(regexBmpWhitelist, escapeBmpSymbol);
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	encode.options = {
-  		'allowUnsafeSymbols': false,
-  		'encodeEverything': false,
-  		'strict': false,
-  		'useNamedReferences': false,
-  		'decimal' : false
-  	};
-
-  	var decode = function(html, options) {
-  		options = merge(options, decode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidEntity.test(html)) {
-  			parseError('malformed character reference');
-  		}
-  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  			var codePoint;
-  			var semicolon;
-  			var decDigits;
-  			var hexDigits;
-  			var reference;
-  			var next;
-
-  			if ($1) {
-  				reference = $1;
-  				// Note: there is no need to check `has(decodeMap, reference)`.
-  				return decodeMap[reference];
+  			return string
+  				// Encode astral symbols.
+  				.replace(regexAstralSymbols, function($0) {
+  					// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+  					var high = $0.charCodeAt(0);
+  					var low = $0.charCodeAt(1);
+  					var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+  					return escapeCodePoint(codePoint);
+  				})
+  				// Encode any remaining BMP symbols that are not printable ASCII symbols
+  				// using a hexadecimal escape.
+  				.replace(regexBmpWhitelist, escapeBmpSymbol);
+  		};
+  		// Expose default options (so they can be overridden globally).
+  		encode.options = {
+  			'allowUnsafeSymbols': false,
+  			'encodeEverything': false,
+  			'strict': false,
+  			'useNamedReferences': false,
+  			'decimal' : false
+  		};
+
+  		var decode = function(html, options) {
+  			options = merge(options, decode.options);
+  			var strict = options.strict;
+  			if (strict && regexInvalidEntity.test(html)) {
+  				parseError('malformed character reference');
   			}
+  			return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+  				var codePoint;
+  				var semicolon;
+  				var decDigits;
+  				var hexDigits;
+  				var reference;
+  				var next;
+
+  				if ($1) {
+  					reference = $1;
+  					// Note: there is no need to check `has(decodeMap, reference)`.
+  					return decodeMap[reference];
+  				}
 
-  			if ($2) {
-  				// Decode named character references without trailing `;`, e.g. `&amp`.
-  				// This is only a parse error if it gets converted to `&`, or if it is
-  				// followed by `=` in an attribute context.
-  				reference = $2;
-  				next = $3;
-  				if (next && options.isAttributeValue) {
-  					if (strict && next == '=') {
-  						parseError('`&` did not start a character reference');
+  				if ($2) {
+  					// Decode named character references without trailing `;`, e.g. `&amp`.
+  					// This is only a parse error if it gets converted to `&`, or if it is
+  					// followed by `=` in an attribute context.
+  					reference = $2;
+  					next = $3;
+  					if (next && options.isAttributeValue) {
+  						if (strict && next == '=') {
+  							parseError('`&` did not start a character reference');
+  						}
+  						return $0;
+  					} else {
+  						if (strict) {
+  							parseError(
+  								'named character reference was not terminated by a semicolon'
+  							);
+  						}
+  						// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+  						return decodeMapLegacy[reference] + (next || '');
   					}
-  					return $0;
-  				} else {
-  					if (strict) {
-  						parseError(
-  							'named character reference was not terminated by a semicolon'
-  						);
+  				}
+
+  				if ($4) {
+  					// Decode decimal escapes, e.g. `&#119558;`.
+  					decDigits = $4;
+  					semicolon = $5;
+  					if (strict && !semicolon) {
+  						parseError('character reference was not terminated by a semicolon');
   					}
-  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-  					return decodeMapLegacy[reference] + (next || '');
+  					codePoint = parseInt(decDigits, 10);
+  					return codePointToSymbol(codePoint, strict);
   				}
-  			}
 
-  			if ($4) {
-  				// Decode decimal escapes, e.g. `&#119558;`.
-  				decDigits = $4;
-  				semicolon = $5;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
+  				if ($6) {
+  					// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+  					hexDigits = $6;
+  					semicolon = $7;
+  					if (strict && !semicolon) {
+  						parseError('character reference was not terminated by a semicolon');
+  					}
+  					codePoint = parseInt(hexDigits, 16);
+  					return codePointToSymbol(codePoint, strict);
   				}
-  				codePoint = parseInt(decDigits, 10);
-  				return codePointToSymbol(codePoint, strict);
-  			}
 
-  			if ($6) {
-  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-  				hexDigits = $6;
-  				semicolon = $7;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
+  				// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+  				// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+  				if (strict) {
+  					parseError(
+  						'named character reference was not terminated by a semicolon'
+  					);
   				}
-  				codePoint = parseInt(hexDigits, 16);
-  				return codePointToSymbol(codePoint, strict);
-  			}
+  				return $0;
+  			});
+  		};
+  		// Expose default options (so they can be overridden globally).
+  		decode.options = {
+  			'isAttributeValue': false,
+  			'strict': false
+  		};
 
-  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-  			if (strict) {
-  				parseError(
-  					'named character reference was not terminated by a semicolon'
-  				);
-  			}
-  			return $0;
-  		});
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	decode.options = {
-  		'isAttributeValue': false,
-  		'strict': false
-  	};
-
-  	var escape = function(string) {
-  		return string.replace(regexEscape, function($0) {
-  			// Note: there is no need to check `has(escapeMap, $0)` here.
-  			return escapeMap[$0];
-  		});
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var he = {
-  		'version': '1.2.0',
-  		'encode': encode,
-  		'decode': decode,
-  		'escape': escape,
-  		'unescape': decode
-  	};
-
-  	// Some AMD build optimizers, like r.js, check for specific condition patterns
-  	// like the following:
-  	if (freeExports && !freeExports.nodeType) {
-  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-  			freeModule.exports = he;
-  		} else { // in Narwhal or RingoJS v0.7.0-
-  			for (var key in he) {
-  				has(he, key) && (freeExports[key] = he[key]);
+  		var escape = function(string) {
+  			return string.replace(regexEscape, function($0) {
+  				// Note: there is no need to check `has(escapeMap, $0)` here.
+  				return escapeMap[$0];
+  			});
+  		};
+
+  		/*--------------------------------------------------------------------------*/
+
+  		var he = {
+  			'version': '1.2.0',
+  			'encode': encode,
+  			'decode': decode,
+  			'escape': escape,
+  			'unescape': decode
+  		};
+
+  		// Some AMD build optimizers, like r.js, check for specific condition patterns
+  		// like the following:
+  		if (freeExports && !freeExports.nodeType) {
+  			if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+  				freeModule.exports = he;
+  			} else { // in Narwhal or RingoJS v0.7.0-
+  				for (var key in he) {
+  					has(he, key) && (freeExports[key] = he[key]);
+  				}
   			}
+  		} else { // in Rhino or a web browser
+  			root.he = he;
   		}
-  	} else { // in Rhino or a web browser
-  		root.he = he;
-  	}
 
-  }(commonjsGlobal));
-  });
+  	}(commonjsGlobal));
+  } (he$1, he$1.exports));
+
+  var he = he$1.exports;
 
   /**
    * Not type-checking this file because it's mostly vendor code.
    */
-
   // Regular Expressions for parsing tags and attributes
-  var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-  var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp(("^<" + qnameCapture));
-  var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-  var doctype = /^<!DOCTYPE [^>]+>/i;
+  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+  const startTagOpen = new RegExp(`^<${qnameCapture}`);
+  const startTagClose = /^\s*(\/?)>/;
+  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+  const doctype = /^<!DOCTYPE [^>]+>/i;
   // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  var comment = /^<!\--/;
-  var conditionalComment = /^<!\[/;
-
+  const comment = /^<!\--/;
+  const conditionalComment = /^<!\[/;
   // Special Elements (can contain anything)
-  var isPlainTextElement = makeMap('script,style,textarea', true);
-  var reCache = {};
-
-  var decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'"
+  const isPlainTextElement = makeMap('script,style,textarea', true);
+  const reCache = {};
+  const decodingMap = {
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
   };
-  var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
+  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
   // #5992
-  var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-  function decodeAttr (value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; })
-  }
-
-  function parseHTML (html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
-    while (html) {
-      last = html;
-      // Make sure we're not in a plaintext content element like script/style
-      if (!lastTag || !isPlainTextElement(lastTag)) {
-        var textEnd = html.indexOf('<');
-        if (textEnd === 0) {
-          // Comment:
-          if (comment.test(html)) {
-            var commentEnd = html.indexOf('-->');
-
-            if (commentEnd >= 0) {
-              if (options.shouldKeepComment) {
-                options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-              }
-              advance(commentEnd + 3);
-              continue
-            }
-          }
-
-          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (conditionalComment.test(html)) {
-            var conditionalEnd = html.indexOf(']>');
-
-            if (conditionalEnd >= 0) {
-              advance(conditionalEnd + 2);
-              continue
-            }
-          }
-
-          // Doctype:
-          var doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length);
-            continue
-          }
-
-          // End tag:
-          var endTagMatch = html.match(endTag);
-          if (endTagMatch) {
-            var curIndex = index;
-            advance(endTagMatch[0].length);
-            parseEndTag(endTagMatch[1], curIndex, index);
-            continue
-          }
-
-          // Start tag:
-          var startTagMatch = parseStartTag();
-          if (startTagMatch) {
-            handleStartTag(startTagMatch);
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1);
-            }
-            continue
-          }
-        }
-
-        var text = (void 0), rest = (void 0), next = (void 0);
-        if (textEnd >= 0) {
-          rest = html.slice(textEnd);
-          while (
-            !endTag.test(rest) &&
-            !startTagOpen.test(rest) &&
-            !comment.test(rest) &&
-            !conditionalComment.test(rest)
-          ) {
-            // < in plain text, be forgiving and treat it as text
-            next = rest.indexOf('<', 1);
-            if (next < 0) { break }
-            textEnd += next;
-            rest = html.slice(textEnd);
-          }
-          text = html.substring(0, textEnd);
-        }
-
-        if (textEnd < 0) {
-          text = html;
-        }
-
-        if (text) {
-          advance(text.length);
-        }
-
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index);
-        }
-      } else {
-        var endTagLength = 0;
-        var stackedTag = lastTag.toLowerCase();
-        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-        var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-          endTagLength = endTag.length;
-          if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-            text = text
-              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-          }
-          if (shouldIgnoreFirstNewline(stackedTag, text)) {
-            text = text.slice(1);
-          }
-          if (options.chars) {
-            options.chars(text);
-          }
-          return ''
-        });
-        index += html.length - rest$1.length;
-        html = rest$1;
-        parseEndTag(stackedTag, index - endTagLength, index);
-      }
-
-      if (html === last) {
-        options.chars && options.chars(html);
-        if (!stack.length && options.warn) {
-          options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-        }
-        break
-      }
-    }
-
-    // Clean up any remaining tags
-    parseEndTag();
-
-    function advance (n) {
-      index += n;
-      html = html.substring(n);
-    }
-
-    function parseStartTag () {
-      var start = html.match(startTagOpen);
-      if (start) {
-        var match = {
-          tagName: start[1],
-          attrs: [],
-          start: index
-        };
-        advance(start[0].length);
-        var end, attr;
-        while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-          attr.start = index;
-          advance(attr[0].length);
-          attr.end = index;
-          match.attrs.push(attr);
-        }
-        if (end) {
-          match.unarySlash = end[1];
-          advance(end[0].length);
-          match.end = index;
-          return match
-        }
-      }
-    }
-
-    function handleStartTag (match) {
-      var tagName = match.tagName;
-      var unarySlash = match.unarySlash;
-
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag);
-        }
-        if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-          parseEndTag(tagName);
-        }
-      }
-
-      var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-      var l = match.attrs.length;
-      var attrs = new Array(l);
-      for (var i = 0; i < l; i++) {
-        var args = match.attrs[i];
-        var value = args[3] || args[4] || args[5] || '';
-        var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-          ? options.shouldDecodeNewlinesForHref
-          : options.shouldDecodeNewlines;
-        attrs[i] = {
-          name: args[1],
-          value: decodeAttr(value, shouldDecodeNewlines)
-        };
-        if (options.outputSourceRange) {
-          attrs[i].start = args.start + args[0].match(/^\s*/).length;
-          attrs[i].end = args.end;
-        }
-      }
-
-      if (!unary) {
-        stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-        lastTag = tagName;
-      }
-
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end);
-      }
-    }
-
-    function parseEndTag (tagName, start, end) {
-      var pos, lowerCasedTagName;
-      if (start == null) { start = index; }
-      if (end == null) { end = index; }
-
-      // Find the closest opened tag of the same type
-      if (tagName) {
-        lowerCasedTagName = tagName.toLowerCase();
-        for (pos = stack.length - 1; pos >= 0; pos--) {
-          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-            break
-          }
-        }
-      } else {
-        // If no tag name is provided, clean shop
-        pos = 0;
-      }
-
-      if (pos >= 0) {
-        // Close all the open elements, up the stack
-        for (var i = stack.length - 1; i >= pos; i--) {
-          if (i > pos || !tagName &&
-            options.warn
-          ) {
-            options.warn(
-              ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-              { start: stack[i].start, end: stack[i].end }
-            );
-          }
-          if (options.end) {
-            options.end(stack[i].tag, start, end);
-          }
-        }
-
-        // Remove the open elements from the stack
-        stack.length = pos;
-        lastTag = pos && stack[pos - 1].tag;
-      } else if (lowerCasedTagName === 'br') {
-        if (options.start) {
-          options.start(tagName, [], true, start, end);
-        }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end);
-        }
-        if (options.end) {
-          options.end(tagName, start, end);
-        }
-      }
-    }
-  }
-
-  /*  */
+  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  function decodeAttr(value, shouldDecodeNewlines) {
+      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, (match) => decodingMap[match]);
+  }
+  function parseHTML(html, options) {
+      const stack = [];
+      const expectHTML = options.expectHTML;
+      const isUnaryTag = options.isUnaryTag || no;
+      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+      let index = 0;
+      let last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              let textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      const commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      const conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  const doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  const endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      const curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  const startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              let text, rest, next;
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          break;
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
+              }
+          }
+          else {
+              let endTagLength = 0;
+              const stackedTag = lastTag.toLowerCase();
+              const reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag, index - endTagLength, index);
+          }
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                      start: index + html.length,
+                  });
+              }
+              break;
+          }
+      }
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          const start = html.match(startTagOpen);
+          if (start) {
+              const match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              let end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
+      }
+      function handleStartTag(match) {
+          const tagName = match.tagName;
+          const unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          const unary = isUnaryTag(tagName) || !!unarySlash;
+          const l = match.attrs.length;
+          const attrs = new Array(l);
+          for (let i = 0; i < l; i++) {
+              const args = match.attrs[i];
+              const value = args[3] || args[4] || args[5] || '';
+              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
+          }
+      }
+      function parseEndTag(tagName, start, end) {
+          let pos, lowerCasedTagName;
+          if (start == null)
+              start = index;
+          if (end == null)
+              end = index;
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (let i = stack.length - 1; i >= pos; i--) {
+                  if ((i > pos || !tagName) &&
+                      options.warn) {
+                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
+          }
+      }
+  }
 
   /**
    * Cross-platform code generation for component v-model
    */
-  function genComponentModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
-    if (trim) {
-      valueExpression =
-        "(typeof " + baseValueExpression + " === 'string'" +
-        "? " + baseValueExpression + ".trim()" +
-        ": " + baseValueExpression + ")";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-    var assignment = genAssignmentCode(value, valueExpression);
-
-    el.model = {
-      value: ("(" + value + ")"),
-      expression: JSON.stringify(value),
-      callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-    };
+  function genComponentModel(el, value, modifiers) {
+      const { number, trim } = modifiers || {};
+      const baseValueExpression = '$$v';
+      let valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              `(typeof ${baseValueExpression} === 'string'` +
+                  `? ${baseValueExpression}.trim()` +
+                  `: ${baseValueExpression})`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      const assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: `(${value})`,
+          expression: JSON.stringify(value),
+          callback: `function (${baseValueExpression}) {${assignment}}`,
+      };
   }
-
   /**
    * Cross-platform codegen helper for generating v-model value assignment code.
    */
-  function genAssignmentCode (
-    value,
-    assignment
-  ) {
-    var res = parseModel(value);
-    if (res.key === null) {
-      return (value + "=" + assignment)
-    } else {
-      return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-    }
+  function genAssignmentCode(value, assignment) {
+      const res = parseModel(value);
+      if (res.key === null) {
+          return `${value}=${assignment}`;
+      }
+      else {
+          return `$set(${res.exp}, ${res.key}, ${assignment})`;
+      }
   }
-
   /**
    * Parse a v-model expression into a base path and a final key segment.
    * Handles both dot-path and possible square brackets.
@@ -3731,2918 +3282,2478 @@
    * - test.xxx.a["asa"][test1[key]]
    *
    */
-
-  var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-  function parseModel (val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-      index = val.lastIndexOf('.');
-      if (index > -1) {
-        return {
-          exp: val.slice(0, index),
-          key: '"' + val.slice(index + 1) + '"'
-        }
-      } else {
-        return {
-          exp: val,
-          key: null
-        }
+  let len, str, chr, index, expressionPos, expressionEndPos;
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
+              return {
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
       }
-    }
-
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-
-    while (!eof()) {
-      chr = next();
-      /* istanbul ignore if */
-      if (isStringStart(chr)) {
-        parseString(chr);
-      } else if (chr === 0x5B) {
-        parseBracket(chr);
+      str = val;
+      index = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
       }
-    }
-
-    return {
-      exp: val.slice(0, expressionPos),
-      key: val.slice(expressionPos + 1, expressionEndPos)
-    }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
   }
-
-  function next () {
-    return str.charCodeAt(++index)
+  function next() {
+      return str.charCodeAt(++index);
   }
-
-  function eof () {
-    return index >= len
+  function eof() {
+      return index >= len;
   }
-
-  function isStringStart (chr) {
-    return chr === 0x22 || chr === 0x27
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
   }
-
-  function parseBracket (chr) {
-    var inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-      chr = next();
-      if (isStringStart(chr)) {
-        parseString(chr);
-        continue
-      }
-      if (chr === 0x5B) { inBracket++; }
-      if (chr === 0x5D) { inBracket--; }
-      if (inBracket === 0) {
-        expressionEndPos = index;
-        break
+  function parseBracket(chr) {
+      let inBracket = 1;
+      expressionPos = index;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              inBracket++;
+          if (chr === 0x5d)
+              inBracket--;
+          if (inBracket === 0) {
+              expressionEndPos = index;
+              break;
+          }
       }
-    }
   }
-
-  function parseString (chr) {
-    var stringQuote = chr;
-    while (!eof()) {
-      chr = next();
-      if (chr === stringQuote) {
-        break
+  function parseString(chr) {
+      const stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
       }
-    }
   }
 
-  /*  */
-
-  var onRE = /^@|^v-on:/;
-  var dirRE = /^v-|^@|^:|^#/;
-  var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  var stripParensRE = /^\(|\)$/g;
-  var dynamicArgRE = /^\[.*\]$/;
-
-  var argRE = /:(.*)$/;
-  var bindRE = /^:|^\.|^v-bind:/;
-  var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
-  var slotRE = /^v-slot(:|$)|^#/;
-
-  var lineBreakRE = /[\r\n]/;
-  var whitespaceRE = /[ \f\t\r\n]+/g;
-
-  var invalidAttributeRE = /[\s"'<>\/=]/;
-
-  var decodeHTMLCached = cached(he.decode);
-
-  var emptySlotScopeToken = "_empty_";
-
+  const onRE = /^@|^v-on:/;
+  const dirRE = /^v-|^@|^:|^#/;
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  const dynamicArgRE = /^\[.*\]$/;
+  const argRE = /:(.*)$/;
+  const bindRE = /^:|^\.|^v-bind:/;
+  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+  const slotRE = /^v-slot(:|$)|^#/;
+  const lineBreakRE = /[\r\n]/;
+  const whitespaceRE = /[ \f\t\r\n]+/g;
+  const invalidAttributeRE = /[\s"'<>\/=]/;
+  const decodeHTMLCached = cached(he.decode);
+  const emptySlotScopeToken = `_empty_`;
   // configurable state
-  var warn$1;
-  var delimiters;
-  var transforms;
-  var preTransforms;
-  var postTransforms;
-  var platformIsPreTag;
-  var platformMustUseProp;
-  var platformGetTagNamespace;
-  var maybeComponent;
-
-  function createASTElement (
-    tag,
-    attrs,
-    parent
-  ) {
-    return {
-      type: 1,
-      tag: tag,
-      attrsList: attrs,
-      attrsMap: makeAttrsMap(attrs),
-      rawAttrsMap: {},
-      parent: parent,
-      children: []
-    }
+  let warn$1;
+  let delimiters;
+  let transforms;
+  let preTransforms;
+  let postTransforms;
+  let platformIsPreTag;
+  let platformMustUseProp;
+  let platformGetTagNamespace;
+  let maybeComponent;
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent,
+          children: [],
+      };
   }
-
   /**
    * Convert HTML string to AST.
    */
-  function parse (
-    template,
-    options
-  ) {
-    warn$1 = options.warn || baseWarn;
-
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!(
-      el.component ||
-      el.attrsMap[':is'] ||
-      el.attrsMap['v-bind:is'] ||
-      !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
-    ); };
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-    delimiters = options.delimiters;
-
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
-
-    function warnOnce (msg, range) {
-      if (!warned) {
-        warned = true;
-        warn$1(msg, range);
-      }
-    }
-
-    function closeElement (element) {
-      trimEndingWhitespace(element);
-      if (!inVPre && !element.processed) {
-        element = processElement(element, options);
-      }
-      // tree management
-      if (!stack.length && element !== root) {
-        // allow root elements with v-if, v-else-if and v-else
-        if (root.if && (element.elseif || element.else)) {
-          {
-            checkRootConstraints(element);
+  function parse(template, options) {
+      warn$1 = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      const isReservedTag = options.isReservedTag || no;
+      maybeComponent = (el) => !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      const stack = [];
+      const preserveWhitespace = options.preserveWhitespace !== false;
+      const whitespaceOption = options.whitespace;
+      let root;
+      let currentParent;
+      let inVPre = false;
+      let inPre = false;
+      let warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn$1(msg, range);
           }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          });
-        } else {
-          warnOnce(
-            "Component template should contain exactly one root element. " +
-            "If you are using v-if on multiple elements, " +
-            "use v-else-if to chain them instead.",
-            { start: element.start }
-          );
-        }
-      }
-      if (currentParent && !element.forbidden) {
-        if (element.elseif || element.else) {
-          processIfConditions(element, currentParent);
-        } else {
-          if (element.slotScope) {
-            // scoped slot
-            // keep it in the children list so that v-else(-if) conditions can
-            // find it as the prev node.
-            var name = element.slotTarget || '"default"'
-            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-          }
-          currentParent.children.push(element);
-          element.parent = currentParent;
-        }
-      }
-
-      // final children cleanup
-      // filter out scoped slots
-      element.children = element.children.filter(function (c) { return !(c).slotScope; });
-      // remove trailing whitespace node again
-      trimEndingWhitespace(element);
-
-      // check pre state
-      if (element.pre) {
-        inVPre = false;
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false;
-      }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options);
-      }
-    }
-
-    function trimEndingWhitespace (el) {
-      // remove trailing whitespace node
-      if (!inPre) {
-        var lastNode;
-        while (
-          (lastNode = el.children[el.children.length - 1]) &&
-          lastNode.type === 3 &&
-          lastNode.text === ' '
-        ) {
-          el.children.pop();
-        }
-      }
-    }
-
-    function checkRootConstraints (el) {
-      if (el.tag === 'slot' || el.tag === 'template') {
-        warnOnce(
-          "Cannot use <" + (el.tag) + "> as component root element because it may " +
-          'contain multiple nodes.',
-          { start: el.start }
-        );
-      }
-      if (el.attrsMap.hasOwnProperty('v-for')) {
-        warnOnce(
-          'Cannot use v-for on stateful component root element because ' +
-          'it renders multiple elements.',
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-
-    parseHTML(template, {
-      warn: warn$1,
-      expectHTML: options.expectHTML,
-      isUnaryTag: options.isUnaryTag,
-      canBeLeftOpenTag: options.canBeLeftOpenTag,
-      shouldDecodeNewlines: options.shouldDecodeNewlines,
-      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-      shouldKeepComment: options.comments,
-      outputSourceRange: options.outputSourceRange,
-      start: function start (tag, attrs, unary, start$1, end) {
-        // check namespace.
-        // inherit parent ns if there is one
-        var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-        // handle IE svg bug
-        /* istanbul ignore if */
-        if (isIE && ns === 'svg') {
-          attrs = guardIESVGBug(attrs);
-        }
-
-        var element = createASTElement(tag, attrs, currentParent);
-        if (ns) {
-          element.ns = ns;
-        }
-
-        {
-          if (options.outputSourceRange) {
-            element.start = start$1;
-            element.end = end;
-            element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-              cumulated[attr.name] = attr;
-              return cumulated
-            }, {});
-          }
-          attrs.forEach(function (attr) {
-            if (invalidAttributeRE.test(attr.name)) {
-              warn$1(
-                "Invalid dynamic argument expression: attribute names cannot contain " +
-                "spaces, quotes, <, >, / or =.",
-                {
-                  start: attr.start + attr.name.indexOf("["),
-                  end: attr.start + attr.name.length
-                }
-              );
-            }
-          });
-        }
-
-        if (isForbiddenTag(element) && !isServerRendering()) {
-          element.forbidden = true;
-          warn$1(
-            'Templates should only be responsible for mapping the state to the ' +
-            'UI. Avoid placing tags with side-effects in your templates, such as ' +
-            "<" + tag + ">" + ', as they will not be parsed.',
-            { start: element.start }
-          );
-        }
-
-        // apply pre-transforms
-        for (var i = 0; i < preTransforms.length; i++) {
-          element = preTransforms[i](element, options) || element;
-        }
-
-        if (!inVPre) {
-          processPre(element);
+      }
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce(`Component template should contain exactly one root element. ` +
+                      `If you are using v-if on multiple elements, ` +
+                      `use v-else-if to chain them instead.`, { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      const name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter((c) => !c.slotScope);
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
           if (element.pre) {
-            inVPre = true;
-          }
-        }
-        if (platformIsPreTag(element.tag)) {
-          inPre = true;
-        }
-        if (inVPre) {
-          processRawAttrs(element);
-        } else if (!element.processed) {
-          // structural directives
-          processFor(element);
-          processIf(element);
-          processOnce(element);
-        }
-
-        if (!root) {
-          root = element;
-          {
-            checkRootConstraints(root);
+              inVPre = false;
+          }
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
+          }
+          // apply post-transforms
+          for (let i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
           }
-        }
-
-        if (!unary) {
-          currentParent = element;
-          stack.push(element);
-        } else {
-          closeElement(element);
-        }
-      },
-
-      end: function end (tag, start, end$1) {
-        var element = stack[stack.length - 1];
-        // pop stack
-        stack.length -= 1;
-        currentParent = stack[stack.length - 1];
-        if (options.outputSourceRange) {
-          element.end = end$1;
-        }
-        closeElement(element);
-      },
-
-      chars: function chars (text, start, end) {
-        if (!currentParent) {
-          {
-            if (text === template) {
-              warnOnce(
-                'Component template requires a root element, rather than just text.',
-                { start: start }
-              );
-            } else if ((text = text.trim())) {
-              warnOnce(
-                ("text \"" + text + "\" outside root element will be ignored."),
-                { start: start }
-              );
-            }
-          }
-          return
-        }
-        // IE textarea placeholder bug
-        /* istanbul ignore if */
-        if (isIE &&
-          currentParent.tag === 'textarea' &&
-          currentParent.attrsMap.placeholder === text
-        ) {
-          return
-        }
-        var children = currentParent.children;
-        if (inPre || text.trim()) {
-          text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-        } else if (!children.length) {
-          // remove the whitespace-only node right after an opening tag
-          text = '';
-        } else if (whitespaceOption) {
-          if (whitespaceOption === 'condense') {
-            // in condense mode, remove the whitespace node if it contains
-            // line break, otherwise condense to a single space
-            text = lineBreakRE.test(text) ? '' : ' ';
-          } else {
-            text = ' ';
-          }
-        } else {
-          text = preserveWhitespace ? ' ' : '';
-        }
-        if (text) {
-          if (!inPre && whitespaceOption === 'condense') {
-            // condense consecutive whitespaces into single space
-            text = text.replace(whitespaceRE, ' ');
-          }
-          var res;
-          var child;
-          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-            child = {
-              type: 2,
-              expression: res.expression,
-              tokens: res.tokens,
-              text: text
-            };
-          } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-            child = {
-              type: 3,
-              text: text
-            };
-          }
-          if (child) {
-            if (options.outputSourceRange) {
-              child.start = start;
-              child.end = end;
-            }
-            children.push(child);
-          }
-        }
-      },
-      comment: function comment (text, start, end) {
-        // adding anything as a sibling to the root node is forbidden
-        // comments should still be allowed, but ignored
-        if (currentParent) {
-          var child = {
-            type: 3,
-            text: text,
-            isComment: true
-          };
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          currentParent.children.push(child);
-        }
-      }
-    });
-    return root
-  }
-
-  function processPre (el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true;
-    }
-  }
-
-  function processRawAttrs (el) {
-    var list = el.attrsList;
-    var len = list.length;
-    if (len) {
-      var attrs = el.attrs = new Array(len);
-      for (var i = 0; i < len; i++) {
-        attrs[i] = {
-          name: list[i].name,
-          value: JSON.stringify(list[i].value)
-        };
-        if (list[i].start != null) {
-          attrs[i].start = list[i].start;
-          attrs[i].end = list[i].end;
-        }
-      }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true;
-    }
-  }
-
-  function processElement (
-    element,
-    options
-  ) {
-    processKey(element);
-
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain = (
-      !element.key &&
-      !element.scopedSlots &&
-      !element.attrsList.length
-    );
-
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element
-  }
-
-  function processKey (el) {
-    var exp = getBindingAttr(el, 'key');
-    if (exp) {
-      {
-        if (el.tag === 'template') {
-          warn$1(
-            "<template> cannot be keyed. Place the key on real elements instead.",
-            getRawBindingAttr(el, 'key')
-          );
-        }
-        if (el.for) {
-          var iterator = el.iterator2 || el.iterator1;
-          var parent = el.parent;
-          if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-            warn$1(
-              "Do not use v-for index as key on <transition-group> children, " +
-              "this is the same as not using keys.",
-              getRawBindingAttr(el, 'key'),
-              true /* tip */
-            );
-          }
-        }
-      }
-      el.key = exp;
-    }
-  }
-
-  function processRef (el) {
-    var ref = getBindingAttr(el, 'ref');
-    if (ref) {
-      el.ref = ref;
-      el.refInFor = checkInFor(el);
-    }
-  }
-
-  function processFor (el) {
-    var exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp);
-      if (res) {
-        extend(el, res);
-      } else {
-        warn$1(
-          ("Invalid v-for expression: " + exp),
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-  }
-
-
-
-  function parseFor (exp) {
-    var inMatch = exp.match(forAliasRE);
-    if (!inMatch) { return }
-    var res = {};
-    res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-      res.alias = alias.replace(forIteratorRE, '').trim();
-      res.iterator1 = iteratorMatch[1].trim();
-      if (iteratorMatch[2]) {
-        res.iterator2 = iteratorMatch[2].trim();
-      }
-    } else {
-      res.alias = alias;
-    }
-    return res
-  }
-
-  function processIf (el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-      el.if = exp;
-      addIfCondition(el, {
-        exp: exp,
-        block: el
-      });
-    } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true;
       }
-      var elseif = getAndRemoveAttr(el, 'v-else-if');
-      if (elseif) {
-        el.elseif = elseif;
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              let lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
+          }
       }
-    }
-  }
-
-  function processIfConditions (el, parent) {
-    var prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-      addIfCondition(prev, {
-        exp: el.elseif,
-        block: el
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                  'contain multiple nodes.', { start: el.start });
+          }
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
+          }
+      }
+      parseHTML(template, {
+          warn: warn$1,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start(tag, attrs, unary, start, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              let element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach((attr) => {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                              `spaces, quotes, <, >, / or =.`, {
+                              start: attr.start + attr.name.indexOf(`[`),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn$1('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          `<${tag}>` +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (let i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end(tag, start, end) {
+              const element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end;
+              }
+              closeElement(element);
+          },
+          chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(`text "${text}" outside root element will be ignored.`, {
+                              start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              const children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE, ' ');
+                  }
+                  let res;
+                  let child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  const child = {
+                      type: 3,
+                      text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
       });
-    } else {
-      warn$1(
-        "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-        "used on element <" + (el.tag) + "> without corresponding v-if.",
-        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-      );
-    }
-  }
-
-  function findPrevElement (children) {
-    var i = children.length;
-    while (i--) {
-      if (children[i].type === 1) {
-        return children[i]
-      } else {
-        if (children[i].text !== ' ') {
-          warn$1(
-            "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-            "will be ignored.",
-            children[i]
-          );
-        }
-        children.pop();
+      return root;
+  }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
+  }
+  function processRawAttrs(el) {
+      const list = el.attrsList;
+      const len = list.length;
+      if (len) {
+          const attrs = (el.attrs = new Array(len));
+          for (let i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
+      }
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (let i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      const exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  const iterator = el.iterator2 || el.iterator1;
+                  const parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
       }
-    }
   }
-
-  function addIfCondition (el, condition) {
-    if (!el.ifConditions) {
-      el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
+  function processRef(el) {
+      const ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
+      }
   }
-
-  function processOnce (el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
-      el.once = true;
-    }
+  function processFor(el) {
+      let exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          const res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+          }
+      }
+  }
+  function parseFor(exp) {
+      const inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          return;
+      const res = {};
+      res.for = inMatch[2].trim();
+      const alias = inMatch[1].trim().replace(stripParensRE, '');
+      const iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
+          }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
+  }
+  function processIf(el) {
+      const exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          const elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
+      }
+  }
+  function processIfConditions(el, parent) {
+      const prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
+          });
+      }
+      else {
+          warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+      }
+  }
+  function findPrevElement(children) {
+      let i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                      `will be ignored.`, children[i]);
+              }
+              children.pop();
+          }
+      }
+  }
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
+  }
+  function processOnce(el) {
+      const once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
+          el.once = true;
+      }
   }
-
   // handle content being passed to a component as slot,
   // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent (el) {
-    var slotScope;
-    if (el.tag === 'template') {
-      slotScope = getAndRemoveAttr(el, 'scope');
-      /* istanbul ignore if */
-      if (slotScope) {
-        warn$1(
-          "the \"scope\" attribute for scoped slots have been deprecated and " +
-          "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-          "can also be used on plain elements in addition to <template> to " +
-          "denote scoped slots.",
-          el.rawAttrsMap['scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-      /* istanbul ignore if */
-      if (el.attrsMap['v-for']) {
-        warn$1(
-          "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-          "(v-for takes higher priority). Use a wrapper <template> for the " +
-          "scoped slot to make it clearer.",
-          el.rawAttrsMap['slot-scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope;
-    }
-
-    // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-      el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-      // preserve slot as an attribute for native shadow DOM compat
-      // only for non-scoped slots.
-      if (el.tag !== 'template' && !el.slotScope) {
-        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-      }
-    }
-
-    // 2.6 v-slot syntax
-    {
+  function processSlotContent(el) {
+      let slotScope;
       if (el.tag === 'template') {
-        // v-slot on <template>
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding) {
-          {
-            if (el.slotTarget || el.slotScope) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.parent && !maybeComponent(el.parent)) {
-              warn$1(
-                "<template v-slot> can only appear at the root level inside " +
-                "the receiving component",
-                el
-              );
-            }
-          }
-          var ref = getSlotName(slotBinding);
-          var name = ref.name;
-          var dynamic = ref.dynamic;
-          el.slotTarget = name;
-          el.slotTargetDynamic = dynamic;
-          el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-        }
-      } else {
-        // v-slot on component, denotes default slot
-        var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding$1) {
-          {
-            if (!maybeComponent(el)) {
-              warn$1(
-                "v-slot can only be used on components or <template>.",
-                slotBinding$1
-              );
-            }
-            if (el.slotScope || el.slotTarget) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.scopedSlots) {
-              warn$1(
-                "To avoid scope ambiguity, the default slot should also use " +
-                "<template> syntax when there are other named slots.",
-                slotBinding$1
-              );
-            }
-          }
-          // add the component's children to its default slot
-          var slots = el.scopedSlots || (el.scopedSlots = {});
-          var ref$1 = getSlotName(slotBinding$1);
-          var name$1 = ref$1.name;
-          var dynamic$1 = ref$1.dynamic;
-          var slotContainer = slots[name$1] = createASTElement('template', [], el);
-          slotContainer.slotTarget = name$1;
-          slotContainer.slotTargetDynamic = dynamic$1;
-          slotContainer.children = el.children.filter(function (c) {
-            if (!c.slotScope) {
-              c.parent = slotContainer;
-              return true
-            }
-          });
-          slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-          // remove children as they are returned from scopedSlots now
-          el.children = [];
-          // mark el non-plain so data gets generated
-          el.plain = false;
-        }
-      }
-    }
-  }
-
-  function getSlotName (binding) {
-    var name = binding.name.replace(slotRE, '');
-    if (!name) {
-      if (binding.name[0] !== '#') {
-        name = 'default';
-      } else {
-        warn$1(
-          "v-slot shorthand syntax requires a slot name.",
-          binding
-        );
-      }
-    }
-    return dynamicArgRE.test(name)
-      // dynamic [name]
-      ? { name: name.slice(1, -1), dynamic: true }
-      // static name
-      : { name: ("\"" + name + "\""), dynamic: false }
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                  `can also be used on plain elements in addition to <template> to ` +
+                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+          }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      const slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn$1(`<template v-slot> can only appear at the root level inside ` +
+                              `the receiving component`, el);
+                      }
+                  }
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.scopedSlots) {
+                          warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                              `<template> syntax when there are other named slots.`, slotBinding);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  const slots = el.scopedSlots || (el.scopedSlots = {});
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  const slotContainer = (slots[name] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name;
+                  slotContainer.slotTargetDynamic = dynamic;
+                  slotContainer.children = el.children.filter((c) => {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
+          }
+      }
+  }
+  function getSlotName(binding) {
+      let name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+          }
+      }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: `"${name}"`, dynamic: false };
   }
-
   // handle <slot/> outlets
-  function processSlotOutlet (el) {
-    if (el.tag === 'slot') {
-      el.slotName = getBindingAttr(el, 'name');
-      if (el.key) {
-        warn$1(
-          "`key` does not work on <slot> because slots are abstract outlets " +
-          "and can possibly expand into multiple elements. " +
-          "Use the key on a wrapping element instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-    }
-  }
-
-  function processComponent (el) {
-    var binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true;
-    }
-  }
-
-  function processAttrs (el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-      name = rawName = list[i].name;
-      value = list[i].value;
-      if (dirRE.test(name)) {
-        // mark element as dynamic
-        el.hasBindings = true;
-        // modifiers
-        modifiers = parseModifiers(name.replace(dirRE, ''));
-        // support .foo shorthand syntax for the .prop modifier
-        if (modifiers) {
-          name = name.replace(modifierRE, '');
-        }
-        if (bindRE.test(name)) { // v-bind
-          name = name.replace(bindRE, '');
-          value = parseFilters(value);
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          if (
-            value.trim().length === 0
-          ) {
-            warn$1(
-              ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-            );
-          }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name);
-              if (name === 'innerHtml') { name = 'innerHTML'; }
-            }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name);
-            }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, "$event");
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  ("update:" + (camelize(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-                if (hyphenate(name) !== camelize(name)) {
-                  addHandler(
-                    el,
-                    ("update:" + (hyphenate(name))),
-                    syncGen,
-                    null,
-                    false,
-                    warn$1,
-                    list[i]
-                  );
-                }
-              } else {
-                // handler w/ dynamic event name
-                addHandler(
-                  el,
-                  ("\"update:\"+(" + name + ")"),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i],
-                  true // dynamic
-                );
-              }
-            }
-          }
-          if ((modifiers && modifiers.prop) || (
-            !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-          )) {
-            addProp(el, name, value, list[i], isDynamic);
-          } else {
-            addAttr(el, name, value, list[i], isDynamic);
-          }
-        } else if (onRE.test(name)) { // v-on
-          name = name.replace(onRE, '');
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-        } else { // normal directives
-          name = name.replace(dirRE, '');
-          // parse arg
-          var argMatch = name.match(argRE);
-          var arg = argMatch && argMatch[1];
-          isDynamic = false;
-          if (arg) {
-            name = name.slice(0, -(arg.length + 1));
-            if (dynamicArgRE.test(arg)) {
-              arg = arg.slice(1, -1);
-              isDynamic = true;
-            }
-          }
-          addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-          if (name === 'model') {
-            checkForAliasModel(el, value);
-          }
-        }
-      } else {
-        // literal attribute
-        {
-          var res = parseText(value, delimiters);
-          if (res) {
-            warn$1(
-              name + "=\"" + value + "\": " +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div id="{{ val }}">, use <div :id="val">.',
-              list[i]
-            );
-          }
-        }
-        addAttr(el, name, JSON.stringify(value), list[i]);
-        // #6887 firefox doesn't update muted state if set via attribute
-        // even immediately after element creation
-        if (!el.component &&
-            name === 'muted' &&
-            platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-          addProp(el, name, 'true', list[i]);
-        }
-      }
-    }
-  }
-
-  function checkInFor (el) {
-    var parent = el;
-    while (parent) {
-      if (parent.for !== undefined) {
-        return true
-      }
-      parent = parent.parent;
-    }
-    return false
-  }
-
-  function parseModifiers (name) {
-    var match = name.match(modifierRE);
-    if (match) {
-      var ret = {};
-      match.forEach(function (m) { ret[m.slice(1)] = true; });
-      return ret
-    }
-  }
-
-  function makeAttrsMap (attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
-      if (
-        map[attrs[i].name] && !isIE && !isEdge
-      ) {
-        warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-      }
-      map[attrs[i].name] = attrs[i].value;
-    }
-    return map
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                  `and can possibly expand into multiple elements. ` +
+                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+          }
+      }
+  }
+  function processComponent(el) {
+      let binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
+      }
+  }
+  function processAttrs(el) {
+      const list = el.attrsList;
+      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              name = 'innerHTML';
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, `$event`);
+                          if (!isDynamic) {
+                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  const argMatch = name.match(argRE);
+                  let arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
+              }
+          }
+          else {
+              // literal attribute
+              {
+                  const res = parseText(value, delimiters);
+                  if (res) {
+                      warn$1(`${name}="${value}": ` +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
+          }
+      }
+  }
+  function checkInFor(el) {
+      let parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
+      }
+      return false;
+  }
+  function parseModifiers(name) {
+      const match = name.match(modifierRE);
+      if (match) {
+          const ret = {};
+          match.forEach((m) => {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
+  }
+  function makeAttrsMap(attrs) {
+      const map = {};
+      for (let i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
   }
-
   // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag (el) {
-    return el.tag === 'script' || el.tag === 'style'
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
   }
-
-  function isForbiddenTag (el) {
-    return (
-      el.tag === 'style' ||
-      (el.tag === 'script' && (
-        !el.attrsMap.type ||
-        el.attrsMap.type === 'text/javascript'
-      ))
-    )
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
   }
-
-  var ieNSBug = /^xmlns:NS\d+/;
-  var ieNSPrefix = /^NS\d+:/;
-
+  const ieNSBug = /^xmlns:NS\d+/;
+  const ieNSPrefix = /^NS\d+:/;
   /* istanbul ignore next */
-  function guardIESVGBug (attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (!ieNSBug.test(attr.name)) {
-        attr.name = attr.name.replace(ieNSPrefix, '');
-        res.push(attr);
-      }
-    }
-    return res
-  }
-
-  function checkForAliasModel (el, value) {
-    var _el = el;
-    while (_el) {
-      if (_el.for && _el.alias === value) {
-        warn$1(
-          "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-          "You are binding v-model directly to a v-for iteration alias. " +
-          "This will not be able to modify the v-for source array because " +
-          "writing to the alias is like modifying a function local variable. " +
-          "Consider using an array of objects and use v-model on an object property instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-      _el = _el.parent;
-    }
-  }
-
-  /*  */
-
-  function preTransformNode (el, options) {
-    if (el.tag === 'input') {
-      var map = el.attrsMap;
-      if (!map['v-model']) {
-        return
-      }
-
-      var typeBinding;
-      if (map[':type'] || map['v-bind:type']) {
-        typeBinding = getBindingAttr(el, 'type');
-      }
-      if (!map.type && !typeBinding && map['v-bind']) {
-        typeBinding = "(" + (map['v-bind']) + ").type";
-      }
-
-      if (typeBinding) {
-        var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-        var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-        // 1. checkbox
-        var branch0 = cloneASTElement(el);
-        // process for on the main node
-        processFor(branch0);
-        addRawAttr(branch0, 'type', 'checkbox');
-        processElement(branch0, options);
-        branch0.processed = true; // prevent it from double-processed
-        branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-        addIfCondition(branch0, {
-          exp: branch0.if,
-          block: branch0
-        });
-        // 2. add radio else-if condition
-        var branch1 = cloneASTElement(el);
-        getAndRemoveAttr(branch1, 'v-for', true);
-        addRawAttr(branch1, 'type', 'radio');
-        processElement(branch1, options);
-        addIfCondition(branch0, {
-          exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-          block: branch1
-        });
-        // 3. other
-        var branch2 = cloneASTElement(el);
-        getAndRemoveAttr(branch2, 'v-for', true);
-        addRawAttr(branch2, ':type', typeBinding);
-        processElement(branch2, options);
-        addIfCondition(branch0, {
-          exp: ifCondition,
-          block: branch2
-        });
-
-        if (hasElse) {
-          branch0.else = true;
-        } else if (elseIfCondition) {
-          branch0.elseif = elseIfCondition;
-        }
-
-        return branch0
-      }
-    }
-  }
-
-  function cloneASTElement (el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+  function guardIESVGBug(attrs) {
+      const res = [];
+      for (let i = 0; i < attrs.length; i++) {
+          const attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
+      }
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      let _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn$1(`<${el.tag} v-model="${value}">: ` +
+                  `You are binding v-model directly to a v-for iteration alias. ` +
+                  `This will not be able to modify the v-for source array because ` +
+                  `writing to the alias is like modifying a function local variable. ` +
+                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
+      }
   }
 
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          const map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          let typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = `(${map['v-bind']}).type`;
+          }
+          if (typeBinding) {
+              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              const branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              const branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              const branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
+      }
+  }
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+  }
   var model$1 = {
-    preTransformNode: preTransformNode
+      preTransformNode,
   };
 
-  var modules$1 = [
-    klass,
-    style,
-    model$1
-  ];
-
-  /*  */
-
-  var warn$2;
+  var modules = [klass, style, model$1];
 
+  let warn;
   // in some cases, the event used has to be determined at runtime
   // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r';
-
-  function model$2 (
-    el,
-    dir,
-    _warn
-  ) {
-    warn$2 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-
-    {
-      // inputs with type="file" are read only and setting the input's
-      // value will throw an error.
-      if (tag === 'input' && type === 'file') {
-        warn$2(
-          "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-          "File inputs are read only. Use a v-on:change listener instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-    }
-
-    if (el.component) {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    } else if (tag === 'select') {
-      genSelect(el, value, modifiers);
-    } else if (tag === 'input' && type === 'checkbox') {
-      genCheckboxModel(el, value, modifiers);
-    } else if (tag === 'input' && type === 'radio') {
-      genRadioModel(el, value, modifiers);
-    } else if (tag === 'input' || tag === 'textarea') {
-      genDefaultModel(el, value, modifiers);
-    } else {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    }
-
-    // ensure runtime directive metadata
-    return true
-  }
-
-  function genCheckboxModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked',
-      "Array.isArray(" + value + ")" +
-      "?_i(" + value + "," + valueBinding + ")>-1" + (
-        trueValueBinding === 'true'
-          ? (":(" + value + ")")
-          : (":_q(" + value + "," + trueValueBinding + ")")
-      )
-    );
-    addHandler(el, 'change',
-      "var $$a=" + value + "," +
+  const RANGE_TOKEN = '__r';
+  function model(el, dir, _warn) {
+      warn = _warn;
+      const value = dir.value;
+      const modifiers = dir.modifiers;
+      const tag = el.tag;
+      const type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const valueBinding = getBindingAttr(el, 'value') || 'null';
+      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', `Array.isArray(${value})` +
+          `?_i(${value},${valueBinding})>-1` +
+          (trueValueBinding === 'true'
+              ? `:(${value})`
+              : `:_q(${value},${trueValueBinding})`));
+      addHandler(el, 'change', `var $$a=${value},` +
           '$$el=$event.target,' +
-          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-      'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-            '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-      "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-      null, true
-    );
-  }
-
-  function genRadioModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-
-  function genSelect (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-      ".call($event.target.options,function(o){return o.selected})" +
-      ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-      "return " + (number ? '_n(val)' : 'val') + "})";
-
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-  }
-
-  function genDefaultModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var type = el.attrsMap.type;
-
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-      var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-      if (value$1 && !typeBinding) {
-        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-        warn$2(
-          binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-          'because the latter already expands to a value binding internally',
-          el.rawAttrsMap[binding]
-        );
-      }
-    }
-
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy
-      ? 'change'
-      : type === 'range'
-        ? RANGE_TOKEN
-        : 'input';
-
-    var valueExpression = '$event.target.value';
-    if (trim) {
-      valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-      code = "if($event.target.composing)return;" + code;
-    }
-
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()');
-    }
-  }
-
-  /*  */
-
-  function text (el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-    }
-  }
-
-  /*  */
-
-  function html (el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-    }
+          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+          'if(Array.isArray($$a)){' +
+          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+          '$$i=_i($$a,$$v);' +
+          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      let valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+      addProp(el, 'checked', `_q(${value},${valueBinding})`);
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const selectedVal = `Array.prototype.filter` +
+          `.call($event.target.options,function(o){return o.selected})` +
+          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+          `return ${number ? '_n(val)' : 'val'}})`;
+      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      let code = `var $$selectedVal = ${selectedVal};`;
+      code = `${code} ${genAssignmentCode(value, assignment)}`;
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      const type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value && !typeBinding) {
+              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      const { lazy, number, trim } = modifiers || {};
+      const needCompositionGuard = !lazy && type !== 'range';
+      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      let valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = `$event.target.value.trim()`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      let code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = `if($event.target.composing)return;${code}`;
+      }
+      addProp(el, 'value', `(${value})`);
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
   }
 
-  var directives$1 = {
-    model: model$2,
-    text: text,
-    html: html
-  };
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', `_s(${dir.value})`, dir);
+      }
+  }
 
-  /*  */
-
-  var baseOptions = {
-    expectHTML: true,
-    modules: modules$1,
-    directives: directives$1,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    staticKeys: genStaticKeys(modules$1)
-  };
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+      }
+  }
 
-  /*  */
+  var directives = {
+      model,
+      text,
+      html,
+  };
 
-  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  var fnInvokeRE = /\([^)]*?\);*$/;
-  var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+  const baseOptions = {
+      expectHTML: true,
+      modules,
+      directives,
+      isPreTag,
+      isUnaryTag,
+      mustUseProp,
+      canBeLeftOpenTag,
+      isReservedTag,
+      getTagNamespace,
+      staticKeys: genStaticKeys(modules),
+  };
 
+  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+  const fnInvokeRE = /\([^)]*?\);*$/;
+  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
   // KeyboardEvent.keyCode aliases
-  var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    'delete': [8, 46]
+  const keyCodes = {
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
   };
-
   // KeyboardEvent.key aliases
-  var keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    'delete': ['Backspace', 'Delete', 'Del']
+  const keyNames = {
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
   };
-
   // #4868: modifiers that prevent the execution of the listener
   // need to explicitly return null so that we can determine whether to remove
   // the listener for .once
-  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
-  var modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2")
+  const genGuard = (condition) => `if(${condition})return null;`;
+  const modifierCode = {
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard(`$event.target !== $event.currentTarget`),
+      ctrl: genGuard(`!$event.ctrlKey`),
+      shift: genGuard(`!$event.shiftKey`),
+      alt: genGuard(`!$event.altKey`),
+      meta: genGuard(`!$event.metaKey`),
+      left: genGuard(`'button' in $event && $event.button !== 0`),
+      middle: genGuard(`'button' in $event && $event.button !== 1`),
+      right: genGuard(`'button' in $event && $event.button !== 2`),
   };
-
-  function genHandlers (
-    events,
-    isNative
-  ) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-      var handlerCode = genHandler(events[name]);
-      if (events[name] && events[name].dynamic) {
-        dynamicHandlers += name + "," + handlerCode + ",";
-      } else {
-        staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-      }
-    }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-    if (dynamicHandlers) {
-      return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-    } else {
-      return prefix + staticHandlers
-    }
-  }
-
-  function genHandler (handler) {
-    if (!handler) {
-      return 'function(){}'
-    }
-
-    if (Array.isArray(handler)) {
-      return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-    }
-
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-    if (!handler.modifiers) {
-      if (isMethodPath || isFunctionExpression) {
-        return handler.value
-      }
-      return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-    } else {
-      var code = '';
-      var genModifierCode = '';
-      var keys = [];
-      for (var key in handler.modifiers) {
-        if (modifierCode[key]) {
-          genModifierCode += modifierCode[key];
-          // left/right
-          if (keyCodes[key]) {
-            keys.push(key);
-          }
-        } else if (key === 'exact') {
-          var modifiers = (handler.modifiers);
-          genModifierCode += genGuard(
-            ['ctrl', 'shift', 'alt', 'meta']
-              .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-              .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-              .join('||')
-          );
-        } else {
-          keys.push(key);
-        }
-      }
-      if (keys.length) {
-        code += genKeyFilter(keys);
-      }
-      // Make sure modifiers like prevent and stop get executed after key filtering
-      if (genModifierCode) {
-        code += genModifierCode;
-      }
-      var handlerCode = isMethodPath
-        ? ("return " + (handler.value) + ".apply(null, arguments)")
-        : isFunctionExpression
-          ? ("return (" + (handler.value) + ").apply(null, arguments)")
-          : isFunctionInvocation
-            ? ("return " + (handler.value))
-            : handler.value;
-      return ("function($event){" + code + handlerCode + "}")
-    }
-  }
-
-  function genKeyFilter (keys) {
-    return (
+  function genHandlers(events, isNative) {
+      const prefix = isNative ? 'nativeOn:' : 'on:';
+      let staticHandlers = ``;
+      let dynamicHandlers = ``;
+      for (const name in events) {
+          const handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += `${name},${handlerCode},`;
+          }
+          else {
+              staticHandlers += `"${name}":${handlerCode},`;
+          }
+      }
+      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+      if (dynamicHandlers) {
+          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+      }
+      else {
+          return prefix + staticHandlers;
+      }
+  }
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+      }
+      const isMethodPath = simplePathRE.test(handler.value);
+      const isFunctionExpression = fnExpRE.test(handler.value);
+      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+      }
+      else {
+          let code = '';
+          let genModifierCode = '';
+          const keys = [];
+          for (const key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  const modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter((keyModifier) => !modifiers[keyModifier])
+                      .map((keyModifier) => `$event.${keyModifier}Key`)
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          const handlerCode = isMethodPath
+              ? `return ${handler.value}.apply(null, arguments)`
+              : isFunctionExpression
+                  ? `return (${handler.value}).apply(null, arguments)`
+                  : isFunctionInvocation
+                      ? `return ${handler.value}`
+                      : handler.value;
+          return `function($event){${code}${handlerCode}}`;
+      }
+  }
+  function genKeyFilter(keys) {
+      return (
       // make sure the key filters only apply to KeyboardEvents
       // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
       // key events that do not have keyCode property...
-      "if(!$event.type.indexOf('key')&&" +
-      (keys.map(genFilterCode).join('&&')) + ")return null;"
-    )
+      `if(!$event.type.indexOf('key')&&` +
+          `${keys.map(genFilterCode).join('&&')})return null;`);
   }
-
-  function genFilterCode (key) {
-    var keyVal = parseInt(key, 10);
-    if (keyVal) {
-      return ("$event.keyCode!==" + keyVal)
-    }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return (
-      "_k($event.keyCode," +
-      (JSON.stringify(key)) + "," +
-      (JSON.stringify(keyCode)) + "," +
-      "$event.key," +
-      "" + (JSON.stringify(keyName)) +
-      ")"
-    )
+  function genFilterCode(key) {
+      const keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return `$event.keyCode!==${keyVal}`;
+      }
+      const keyCode = keyCodes[key];
+      const keyName = keyNames[key];
+      return (`_k($event.keyCode,` +
+          `${JSON.stringify(key)},` +
+          `${JSON.stringify(keyCode)},` +
+          `$event.key,` +
+          `${JSON.stringify(keyName)}` +
+          `)`);
   }
 
-  /*  */
-
-  function on (el, dir) {
-    if (dir.modifiers) {
-      warn("v-on without argument does not support modifiers.");
-    }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn$2(`v-on without argument does not support modifiers.`);
+      }
+      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
   }
 
-  /*  */
-
-  function bind$1 (el, dir) {
-    el.wrapData = function (code) {
-      return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-    };
+  function bind(el, dir) {
+      el.wrapData = (code) => {
+          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+      };
   }
 
-  /*  */
-
   var baseDirectives = {
-    on: on,
-    bind: bind$1,
-    cloak: noop
+      on,
+      bind,
+      cloak: noop$1,
   };
 
-  /*  */
-
-
-
-
-
-  var CodegenState = function CodegenState (options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-  };
-
-
-
-  function generate (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    var code = ast ? (ast.tag === 'script' ? 'null' : genElement(ast, state)) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genElement (el, state) {
-    if (el.parent) {
-      el.pre = el.pre || el.parent.pre;
-    }
-
-    if (el.staticRoot && !el.staticProcessed) {
-      return genStatic(el, state)
-    } else if (el.once && !el.onceProcessed) {
-      return genOnce(el, state)
-    } else if (el.for && !el.forProcessed) {
-      return genFor(el, state)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-      return genChildren(el, state) || 'void 0'
-    } else if (el.tag === 'slot') {
-      return genSlot(el, state)
-    } else {
-      // component or element
-      var code;
-      if (el.component) {
-        code = genComponent(el.component, el, state);
-      } else {
-        var data;
-        if (!el.plain || (el.pre && state.maybeComponent(el))) {
-          data = genData$2(el, state);
-        }
-
-        var children = el.inlineTemplate ? null : genChildren(el, state, true);
-        code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+  class CodegenState {
+      options;
+      warn;
+      transforms;
+      dataGenFns;
+      directives;
+      maybeComponent;
+      onceId;
+      staticRenderFns;
+      pre;
+      constructor(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          const isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+  }
+  function generate$1(ast, options) {
+      const state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      const code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
+      }
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
       }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code);
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
+      }
+      else {
+          // component or element
+          let code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              let data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData(el, state);
+              }
+              const children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+          }
+          // module transforms
+          for (let i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
       }
-      return code
-    }
   }
-
   // hoist static sub-trees out
-  function genStatic (el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
-    if (el.pre) {
-      state.pre = el.pre;
-    }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-    state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      const originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+      state.pre = originalPreState;
+      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
   }
-
   // v-once
-  function genOnce (el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.staticInFor) {
-      var key = '';
-      var parent = el.parent;
-      while (parent) {
-        if (parent.for) {
-          key = parent.key;
-          break
-        }
-        parent = parent.parent;
-      }
-      if (!key) {
-        state.warn(
-          "v-once can only be used inside v-for that is keyed. ",
-          el.rawAttrsMap['v-once']
-        );
-        return genElement(el, state)
-      }
-      return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-    } else {
-      return genStatic(el, state)
-    }
-  }
-
-  function genIf (
-    el,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-  }
-
-  function genIfConditions (
-    conditions,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    if (!conditions.length) {
-      return altEmpty || '_e()'
-    }
-
-    var condition = conditions.shift();
-    if (condition.exp) {
-      return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-    } else {
-      return ("" + (genTernaryExp(condition.block)))
-    }
-
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp (el) {
-      return altGen
-        ? altGen(el, state)
-        : el.once
-          ? genOnce(el, state)
-          : genElement(el, state)
-    }
-  }
-
-  function genFor (
-    el,
-    state,
-    altGen,
-    altHelper
-  ) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-    if (state.maybeComponent(el) &&
-      el.tag !== 'slot' &&
-      el.tag !== 'template' &&
-      !el.key
-    ) {
-      state.warn(
-        "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-        "v-for should have explicit keys. " +
-        "See https://vuejs.org/guide/list.html#key for more info.",
-        el.rawAttrsMap['v-for'],
-        true /* tip */
-      );
-    }
-
-    el.forProcessed = true; // avoid recursion
-    return (altHelper || '_l') + "((" + exp + ")," +
-      "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
-      '})'
-  }
-
-  function genData$2 (el, state) {
-    var data = '{';
-
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
-    if (dirs) { data += dirs + ','; }
-
-    // key
-    if (el.key) {
-      data += "key:" + (el.key) + ",";
-    }
-    // ref
-    if (el.ref) {
-      data += "ref:" + (el.ref) + ",";
-    }
-    if (el.refInFor) {
-      data += "refInFor:true,";
-    }
-    // pre
-    if (el.pre) {
-      data += "pre:true,";
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-      data += "tag:\"" + (el.tag) + "\",";
-    }
-    // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
-      data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-      data += "attrs:" + (genProps(el.attrs)) + ",";
-    }
-    // DOM props
-    if (el.props) {
-      data += "domProps:" + (genProps(el.props)) + ",";
-    }
-    // event handlers
-    if (el.events) {
-      data += (genHandlers(el.events, false)) + ",";
-    }
-    if (el.nativeEvents) {
-      data += (genHandlers(el.nativeEvents, true)) + ",";
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-      data += "slot:" + (el.slotTarget) + ",";
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-      data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-    }
-    // component v-model
-    if (el.model) {
-      data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-      var inlineTemplate = genInlineTemplate(el, state);
-      if (inlineTemplate) {
-        data += inlineTemplate + ",";
-      }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-      data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data);
-    }
-    return data
-  }
-
-  function genDirectives (el, state) {
-    var dirs = el.directives;
-    if (!dirs) { return }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-      dir = dirs[i];
-      needRuntime = true;
-      var gen = state.directives[dir.name];
-      if (gen) {
-        // compile-time directive that manipulates AST.
-        // returns true if it also needs a runtime counterpart.
-        needRuntime = !!gen(el, dir, state.warn);
-      }
-      if (needRuntime) {
-        hasRuntime = true;
-        res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-      }
-    }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
-  }
-
-  function genInlineTemplate (el, state) {
-    var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
-      state.warn(
-        'Inline-template components must have exactly one child element.',
-        { start: el.start }
-      );
-    }
-    if (ast && ast.type === 1) {
-      var inlineRenderFns = generate(ast, state.options);
-      return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-    }
-  }
-
-  function genScopedSlots (
-    el,
-    slots,
-    state
-  ) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-      var slot = slots[key];
-      return (
-        slot.slotTargetDynamic ||
-        slot.if ||
-        slot.for ||
-        containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-      )
-    });
-
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    var needsKey = !!el.if;
-
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-      var parent = el.parent;
-      while (parent) {
-        if (
-          (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-          parent.for
-        ) {
-          needsForceUpdate = true;
-          break
-        }
-        if (parent.if) {
-          needsKey = true;
-        }
-        parent = parent.parent;
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.staticInFor) {
+          let key = '';
+          let parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      const condition = conditions.shift();
+      if (condition.exp) {
+          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+      }
+      else {
+          return `${genTernaryExp(condition.block)}`;
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      const exp = el.for;
+      const alias = el.alias;
+      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+              `v-for should have explicit keys. ` +
+              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return (`${altHelper || '_l'}((${exp}),` +
+          `function(${alias}${iterator1}${iterator2}){` +
+          `return ${(altGen || genElement)(el, state)}` +
+          '})');
+  }
+  function genData(el, state) {
+      let data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      const dirs = genDirectives(el, state);
+      if (dirs)
+          data += dirs + ',';
+      // key
+      if (el.key) {
+          data += `key:${el.key},`;
+      }
+      // ref
+      if (el.ref) {
+          data += `ref:${el.ref},`;
+      }
+      if (el.refInFor) {
+          data += `refInFor:true,`;
+      }
+      // pre
+      if (el.pre) {
+          data += `pre:true,`;
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += `tag:"${el.tag}",`;
+      }
+      // module data generation functions
+      for (let i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += `attrs:${genProps(el.attrs)},`;
+      }
+      // DOM props
+      if (el.props) {
+          data += `domProps:${genProps(el.props)},`;
+      }
+      // event handlers
+      if (el.events) {
+          data += `${genHandlers(el.events, false)},`;
+      }
+      if (el.nativeEvents) {
+          data += `${genHandlers(el.nativeEvents, true)},`;
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += `slot:${el.slotTarget},`;
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+      }
+      // component v-model
+      if (el.model) {
+          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          const inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += `${inlineTemplate},`;
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      const dirs = el.directives;
+      if (!dirs)
+          return;
+      let res = 'directives:[';
+      let hasRuntime = false;
+      let i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          const gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
       }
-    }
-
-    var generatedSlots = Object.keys(slots)
-      .map(function (key) { return genScopedSlot(slots[key], state); })
-      .join(',');
-
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
   }
-
+  function genInlineTemplate(el, state) {
+      const ast = el.children[0];
+      if ((el.children.length !== 1 || ast.type !== 1)) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          const inlineRenderFns = generate$1(ast, state.options);
+          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+      }
+  }
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      let needsForceUpdate = el.for ||
+          Object.keys(slots).some((key) => {
+              const slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      let needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          let parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
+      }
+      const generatedSlots = Object.keys(slots)
+          .map((key) => genScopedSlot(slots[key], state))
+          .join(',');
+      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+  }
   function hash(str) {
-    var hash = 5381;
-    var i = str.length;
-    while(i) {
-      hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0
+      let hash = 5381;
+      let i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
+      }
+      return hash >>> 0;
   }
-
-  function containsSlotChild (el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
-      }
-      return el.children.some(containsSlotChild)
-    }
-    return false
-  }
-
-  function genScopedSlot (
-    el,
-    state
-  ) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-      return genIf(el, state, genScopedSlot, "null")
-    }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
-    }
-    var slotScope = el.slotScope === emptySlotScopeToken
-      ? ""
-      : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-      "return " + (el.tag === 'template'
-        ? el.if && isLegacySyntax
-          ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-          : genChildren(el, state) || 'undefined'
-        : genElement(el, state)) + "}";
-    // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-  }
-
-  function genChildren (
-    el,
-    state,
-    checkSkip,
-    altGenElement,
-    altGenNode
-  ) {
-    var children = el.children;
-    if (children.length) {
-      var el$1 = children[0];
-      // optimize single v-for
-      if (children.length === 1 &&
-        el$1.for &&
-        el$1.tag !== 'template' &&
-        el$1.tag !== 'slot'
-      ) {
-        var normalizationType = checkSkip
-          ? state.maybeComponent(el$1) ? ",1" : ",0"
-          : "";
-        return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-      }
-      var normalizationType$1 = checkSkip
-        ? getNormalizationType(children, state.maybeComponent)
-        : 0;
-      var gen = altGenNode || genNode;
-      return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-    }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      const isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, `null`);
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+      const fn = `function(${slotScope}){` +
+          `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+      // reverse proxy v-slot without scope on this.$slots
+      const reverseProxy = slotScope ? `` : `,proxy:true`;
+      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      const children = el.children;
+      if (children.length) {
+          const el = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el.for &&
+              el.tag !== 'template' &&
+              el.tag !== 'slot') {
+              const normalizationType = checkSkip
+                  ? state.maybeComponent(el)
+                      ? `,1`
+                      : `,0`
+                  : ``;
+              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+          }
+          const normalizationType = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          const gen = altGenNode || genNode;
+          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+      }
   }
-
   // determine the normalization needed for the children array.
   // 0: no normalization needed
   // 1: simple normalization needed (possible 1-level deep nested array)
   // 2: full normalization needed
-  function getNormalizationType (
-    children,
-    maybeComponent
-  ) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-      var el = children[i];
-      if (el.type !== 1) {
-        continue
-      }
-      if (needsNormalization(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-        res = 2;
-        break
-      }
-      if (maybeComponent(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-        res = 1;
-      }
-    }
-    return res
-  }
-
-  function needsNormalization (el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-  }
-
-  function genNode (node, state) {
-    if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
-    }
-  }
-
-  function genText (text) {
-    return ("_v(" + (text.type === 2
-      ? text.expression // no need for () because already wrapped in _s()
-      : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-  }
-
-  function genComment (comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")")
-  }
-
-  function genSlot (el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? (",function(){return " + children + "}") : '');
-    var attrs = el.attrs || el.dynamicAttrs
-      ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-          // slot props are camelized
-          name: camelize(attr.name),
-          value: attr.value,
-          dynamic: attr.dynamic
-        }); }))
-      : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
-      res += ",null";
-    }
-    if (attrs) {
-      res += "," + attrs;
-    }
-    if (bind$$1) {
-      res += (attrs ? '' : ',null') + "," + bind$$1;
-    }
-    return res + ')'
+  function getNormalizationType(children, maybeComponent) {
+      let res = 0;
+      for (let i = 0; i < children.length; i++) {
+          const el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+              res = 1;
+          }
+      }
+      return res;
+  }
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+  }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
+  }
+  function genText(text) {
+      return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+  }
+  function genComment(comment) {
+      return `_e(${JSON.stringify(comment.text)})`;
+  }
+  function genSlot(el, state) {
+      const slotName = el.slotName || '"default"';
+      const children = genChildren(el, state);
+      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+      const attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic
+          })))
+          : null;
+      const bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
+          res += `,null`;
+      }
+      if (attrs) {
+          res += `,${attrs}`;
+      }
+      if (bind) {
+          res += `${attrs ? '' : ',null'},${bind}`;
+      }
+      return res + ')';
   }
-
   // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent (
-    componentName,
-    el,
-    state
-  ) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-  }
-
-  function genProps (props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      var value = transformSpecialNewlines(prop.value);
-      if (prop.dynamic) {
-        dynamicProps += (prop.name) + "," + value + ",";
-      } else {
-        staticProps += "\"" + (prop.name) + "\":" + value + ",";
-      }
-    }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-    if (dynamicProps) {
-      return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-    } else {
-      return staticProps
-    }
+  function genComponent(componentName, el, state) {
+      const children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+  }
+  function genProps(props) {
+      let staticProps = ``;
+      let dynamicProps = ``;
+      for (let i = 0; i < props.length; i++) {
+          const prop = props[i];
+          const value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += `${prop.name},${value},`;
+          }
+          else {
+              staticProps += `"${prop.name}":${value},`;
+          }
+      }
+      staticProps = `{${staticProps.slice(0, -1)}}`;
+      if (dynamicProps) {
+          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+      }
+      else {
+          return staticProps;
+      }
+  }
+  // #3895, #4268
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+  }
+
+  const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+  // let the model AST transform translate v-model into appropriate
+  // props bindings
+  function applyModelTransform(el, state) {
+      if (el.directives) {
+          for (let i = 0; i < el.directives.length; i++) {
+              const dir = el.directives[i];
+              if (dir.name === 'model') {
+                  state.directives.model(el, dir, state.warn);
+                  // remove value for textarea as its converted to text
+                  if (el.tag === 'textarea' && el.props) {
+                      el.props = el.props.filter((p) => p.name !== 'value');
+                  }
+                  break;
+              }
+          }
+      }
+  }
+  function genAttrSegments(attrs) {
+      return attrs.map(({ name, value }) => genAttrSegment(name, value));
+  }
+  function genDOMPropSegments(props, attrs) {
+      const segments = [];
+      props.forEach(({ name, value }) => {
+          name = propsToAttrMap[name] || name.toLowerCase();
+          if (isRenderableAttr(name) &&
+              !(attrs && attrs.some((a) => a.name === name))) {
+              segments.push(genAttrSegment(name, value));
+          }
+      });
+      return segments;
+  }
+  function genAttrSegment(name, value) {
+      if (plainStringRE.test(value)) {
+          // force double quote
+          value = value.replace(/^'|'$/g, '"');
+          // force enumerated attr to "true"
+          if (isEnumeratedAttr(name) && value !== `"false"`) {
+              value = `"true"`;
+          }
+          return {
+              type: RAW,
+              value: isBooleanAttr(name)
+                  ? ` ${name}="${name}"`
+                  : value === '""'
+                      ? ` ${name}`
+                      : ` ${name}="${JSON.parse(value)}"`,
+          };
+      }
+      else {
+          return {
+              type: EXPRESSION,
+              value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+          };
+      }
   }
-
-  // #3895, #4268
-  function transformSpecialNewlines (text) {
-    return text
-      .replace(/\u2028/g, '\\u2028')
-      .replace(/\u2029/g, '\\u2029')
+  function genClassSegments(staticClass, classBinding) {
+      if (staticClass && !classBinding) {
+          return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+              },
+          ];
+      }
   }
-
-  /*  */
-
-
-
-
-  var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
-  // let the model AST transform translate v-model into appropriate
-  // props bindings
-  function applyModelTransform (el, state) {
-    if (el.directives) {
-      for (var i = 0; i < el.directives.length; i++) {
-        var dir = el.directives[i];
-        if (dir.name === 'model') {
-          state.directives.model(el, dir, state.warn);
-          // remove value for textarea as its converted to text
-          if (el.tag === 'textarea' && el.props) {
-            el.props = el.props.filter(function (p) { return p.name !== 'value'; });
-          }
-          break
-        }
-      }
-    }
-  }
-
-  function genAttrSegments (
-    attrs
-  ) {
-    return attrs.map(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      return genAttrSegment(name, value);
-    })
-  }
-
-  function genDOMPropSegments (
-    props,
-    attrs
-  ) {
-    var segments = [];
-    props.forEach(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      name = propsToAttrMap[name] || name.toLowerCase();
-      if (isRenderableAttr(name) &&
-        !(attrs && attrs.some(function (a) { return a.name === name; }))
-      ) {
-        segments.push(genAttrSegment(name, value));
-      }
-    });
-    return segments
-  }
-
-  function genAttrSegment (name, value) {
-    if (plainStringRE.test(value)) {
-      // force double quote
-      value = value.replace(/^'|'$/g, '"');
-      // force enumerated attr to "true"
-      if (isEnumeratedAttr(name) && value !== "\"false\"") {
-        value = "\"true\"";
+  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+      if (staticStyle && !styleBinding && !vShowExpression) {
+          return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
       }
-      return {
-        type: RAW,
-        value: isBooleanAttr(name)
-          ? (" " + name + "=\"" + name + "\"")
-          : value === '""'
-            ? (" " + name)
-            : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-      }
-    } else {
-      return {
-        type: EXPRESSION,
-        value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
-      }
-    }
-  }
-
-  function genClassSegments (
-    staticClass,
-    classBinding
-  ) {
-    if (staticClass && !classBinding) {
-      return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-      }]
-    }
-  }
-
-  function genStyleSegments (
-    staticStyle,
-    parsedStaticStyle,
-    styleBinding,
-    vShowExpression
-  ) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-      return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-            ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-            : 'null') + ")")
-      }]
-    }
-  }
-
-  /*  */
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+              },
+          ];
+      }
+  }
 
+  /**
+   * In SSR, the vdom tree is generated only once and never patched, so
+   * we can optimize most element / trees into plain string render functions.
+   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+   *
+   * The criteria for SSR optimizability is quite a bit looser than static tree
+   * detection (which is designed for client re-render). In SSR we bail only for
+   * components/slots/custom directives.
+   */
   // optimizability constants
-  var optimizability = {
-    FALSE: 0,    // whole sub tree un-optimizable
-    FULL: 1,     // whole sub tree optimizable
-    SELF: 2,     // self optimizable but has some un-optimizable children
-    CHILDREN: 3, // self un-optimizable but have fully optimizable children
-    PARTIAL: 4   // self un-optimizable with some un-optimizable children
+  const optimizability = {
+      FALSE: 0,
+      FULL: 1,
+      SELF: 2,
+      CHILDREN: 3,
+      PARTIAL: 4, // self un-optimizable with some un-optimizable children
   };
-
-  var isPlatformReservedTag;
-
-  function optimize (root, options) {
-    if (!root) { return }
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-  }
-
-  function walk (node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-      node.ssrOptimizability = optimizability.FALSE;
-      return
-    }
-    // root node or nodes with custom directives should always be a VNode
-    var selfUnoptimizable = isRoot || hasCustomDirective(node);
-    var check = function (child) {
-      if (child.ssrOptimizability !== optimizability.FULL) {
-        node.ssrOptimizability = selfUnoptimizable
-          ? optimizability.PARTIAL
-          : optimizability.SELF;
-      }
-    };
-    if (selfUnoptimizable) {
-      node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        walk(child);
-        check(child);
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          walk(block, isRoot);
-          check(block);
-        }
-      }
-      if (node.ssrOptimizability == null ||
-        (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-      ) {
-        node.ssrOptimizability = optimizability.FULL;
-      } else {
-        node.children = optimizeSiblings(node);
-      }
-    } else {
-      node.ssrOptimizability = optimizability.FULL;
-    }
-  }
-
-  function optimizeSiblings (el) {
-    var children = el.children;
-    var optimizedChildren = [];
-
-    var currentOptimizableGroup = [];
-    var pushGroup = function () {
-      if (currentOptimizableGroup.length) {
-        optimizedChildren.push({
-          type: 1,
-          parent: el,
-          tag: 'template',
-          attrsList: [],
-          attrsMap: {},
-          rawAttrsMap: {},
-          children: currentOptimizableGroup,
-          ssrOptimizability: optimizability.FULL
-        });
-      }
-      currentOptimizableGroup = [];
-    };
-
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.ssrOptimizability === optimizability.FULL) {
-        currentOptimizableGroup.push(c);
-      } else {
-        // wrap fully-optimizable adjacent siblings inside a template tag
-        // so that they can be optimized into a single ssrNode by codegen
-        pushGroup();
-        optimizedChildren.push(c);
-      }
-    }
-    pushGroup();
-    return optimizedChildren
-  }
-
-  function isUnOptimizableTree (node) {
-    if (node.type === 2 || node.type === 3) { // text or expression
-      return false
-    }
-    return (
-      isBuiltInTag(node.tag) || // built-in (slot, component)
-      !isPlatformReservedTag(node.tag) || // custom component
-      !!node.component || // "is" component
-      isSelectWithModel(node) // <select v-model> requires runtime inspection
-    )
-  }
-
-  var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-  function hasCustomDirective (node) {
-    return (
-      node.type === 1 &&
-      node.directives &&
-      node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-    )
+  let isPlatformReservedTag;
+  function optimize(root, options) {
+      if (!root)
+          return;
+      isPlatformReservedTag = options.isReservedTag || no;
+      walk(root, true);
+  }
+  function walk(node, isRoot) {
+      if (isUnOptimizableTree(node)) {
+          node.ssrOptimizability = optimizability.FALSE;
+          return;
+      }
+      // root node or nodes with custom directives should always be a VNode
+      const selfUnoptimizable = isRoot || hasCustomDirective(node);
+      const check = (child) => {
+          if (child.ssrOptimizability !== optimizability.FULL) {
+              node.ssrOptimizability = selfUnoptimizable
+                  ? optimizability.PARTIAL
+                  : optimizability.SELF;
+          }
+      };
+      if (selfUnoptimizable) {
+          node.ssrOptimizability = optimizability.CHILDREN;
+      }
+      if (node.type === 1) {
+          for (let i = 0, l = node.children.length; i < l; i++) {
+              const child = node.children[i];
+              walk(child);
+              check(child);
+          }
+          if (node.ifConditions) {
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  const block = node.ifConditions[i].block;
+                  walk(block, isRoot);
+                  check(block);
+              }
+          }
+          if (node.ssrOptimizability == null ||
+              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+              node.ssrOptimizability = optimizability.FULL;
+          }
+          else {
+              node.children = optimizeSiblings(node);
+          }
+      }
+      else {
+          node.ssrOptimizability = optimizability.FULL;
+      }
+  }
+  function optimizeSiblings(el) {
+      const children = el.children;
+      const optimizedChildren = [];
+      let currentOptimizableGroup = [];
+      const pushGroup = () => {
+          if (currentOptimizableGroup.length) {
+              optimizedChildren.push({
+                  type: 1,
+                  parent: el,
+                  tag: 'template',
+                  attrsList: [],
+                  attrsMap: {},
+                  rawAttrsMap: {},
+                  children: currentOptimizableGroup,
+                  ssrOptimizability: optimizability.FULL,
+              });
+          }
+          currentOptimizableGroup = [];
+      };
+      for (let i = 0; i < children.length; i++) {
+          const c = children[i];
+          if (c.ssrOptimizability === optimizability.FULL) {
+              currentOptimizableGroup.push(c);
+          }
+          else {
+              // wrap fully-optimizable adjacent siblings inside a template tag
+              // so that they can be optimized into a single ssrNode by codegen
+              pushGroup();
+              optimizedChildren.push(c);
+          }
+      }
+      pushGroup();
+      return optimizedChildren;
+  }
+  function isUnOptimizableTree(node) {
+      if (node.type === 2 || node.type === 3) {
+          // text or expression
+          return false;
+      }
+      return (isBuiltInTag(node.tag) || // built-in (slot, component)
+          !isPlatformReservedTag(node.tag) || // custom component
+          !!node.component || // "is" component
+          isSelectWithModel(node) // <select v-model> requires runtime inspection
+      );
+  }
+  const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+  function hasCustomDirective(node) {
+      return (node.type === 1 &&
+          node.directives &&
+          node.directives.some((d) => !isBuiltInDir(d.name)));
   }
-
   // <select v-model> cannot be optimized because it requires a runtime check
   // to determine proper selected option
-  function isSelectWithModel (node) {
-    return (
-      node.type === 1 &&
-      node.tag === 'select' &&
-      node.directives != null &&
-      node.directives.some(function (d) { return d.name === 'model'; })
-    )
+  function isSelectWithModel(node) {
+      return (node.type === 1 &&
+          node.tag === 'select' &&
+          node.directives != null &&
+          node.directives.some((d) => d.name === 'model'));
   }
 
-  /*  */
-
-
-
-
+  // The SSR codegen is essentially extending the default codegen to handle
   // segment types
-  var RAW = 0;
-  var INTERPOLATION = 1;
-  var EXPRESSION = 2;
-
-  function generate$1 (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genSSRElement (el, state) {
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genSSRElement)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state, genSSRElement)
-    } else if (el.tag === 'template' && !el.slotTarget) {
-      return el.ssrOptimizability === optimizability.FULL
-        ? genChildrenAsStringNode(el, state)
-        : genSSRChildren(el, state) || 'void 0'
-    }
-
-    switch (el.ssrOptimizability) {
-      case optimizability.FULL:
-        // stringify whole tree
-        return genStringElement(el, state)
-      case optimizability.SELF:
-        // stringify self and check children
-        return genStringElementWithChildren(el, state)
-      case optimizability.CHILDREN:
-        // generate self as VNode and stringify children
-        return genNormalElement(el, state, true)
-      case optimizability.PARTIAL:
-        // generate self as VNode and check children
-        return genNormalElement(el, state, false)
-      default:
-        // bail whole tree
-        return genElement(el, state)
-    }
-  }
-
-  function genNormalElement (el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData$2(el, state);
-    var children = stringifyChildren
-      ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-      : genSSRChildren(el, state, true);
-    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-  }
-
-  function genSSRChildren (el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-  }
-
-  function genSSRNode (el, state) {
-    return el.type === 1
-      ? genSSRElement(el, state)
-      : genText(el)
-  }
-
-  function genChildrenAsStringNode (el, state) {
-    return el.children.length
-      ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-      : ''
-  }
-
-  function genStringElement (el, state) {
-    return ("_ssrNode(" + (elementToString(el, state)) + ")")
-  }
-
-  function genStringElementWithChildren (el, state) {
-    var children = genSSRChildren(el, state, true);
-    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-  }
-
-  function elementToString (el, state) {
-    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-  }
-
-  function elementToSegments (el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-      el.forProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genFor(el, state, elementToString, '_ssrList')
-      }]
-    } else if (el.if && !el.ifProcessed) {
-      el.ifProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genIf(el, state, elementToString, '"<!---->"')
-      }]
-    } else if (el.tag === 'template') {
-      return childrenToSegments(el, state)
-    }
-
-    var openSegments = elementToOpenTagSegments(el, state);
-    var childrenSegments = childrenToSegments(el, state);
-    var ref = state.options;
-    var isUnaryTag = ref.isUnaryTag;
-    var close = (isUnaryTag && isUnaryTag(el.tag))
-      ? []
-      : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-    return openSegments.concat(childrenSegments, close)
-  }
-
-  function elementToOpenTagSegments (el, state) {
-    applyModelTransform(el, state);
-    var binding;
-    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-    // attrs
-    if (el.attrs) {
-      segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-      segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-      segments.push.apply(
-        segments,
-        genClassSegments(el.staticClass, el.classBinding)
-      );
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-      segments.push.apply(
-        segments,
-        genStyleSegments(
-          el.attrsMap.style,
-          el.staticStyle,
-          el.styleBinding,
-          el.attrsMap['v-show']
-        )
-      );
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-      segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-    }
-    segments.push({ type: RAW, value: ">" });
-    return segments
-  }
-
-  function childrenToSegments (el, state) {
-    var binding;
-    if ((binding = el.attrsMap['v-html'])) {
-      return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    return el.children
-      ? nodesToSegments(el.children, state)
-      : []
-  }
-
-  function nodesToSegments (
-    children,
-    state
-  ) {
-    var segments = [];
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.type === 1) {
-        segments.push.apply(segments, elementToSegments(c, state));
-      } else if (c.type === 2) {
-        segments.push({ type: INTERPOLATION, value: c.expression });
-      } else if (c.type === 3) {
-        var text = escape(c.text);
-        if (c.isComment) {
-          text = '<!--' + text + '-->';
-        }
-        segments.push({ type: RAW, value: text });
-      }
-    }
-    return segments
-  }
-
-  function flattenSegments (segments) {
-    var mergedSegments = [];
-    var textBuffer = '';
-
-    var pushBuffer = function () {
-      if (textBuffer) {
-        mergedSegments.push(JSON.stringify(textBuffer));
-        textBuffer = '';
-      }
-    };
-
-    for (var i = 0; i < segments.length; i++) {
-      var s = segments[i];
-      if (s.type === RAW) {
-        textBuffer += s.value;
-      } else if (s.type === INTERPOLATION) {
-        pushBuffer();
-        mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-      } else if (s.type === EXPRESSION) {
-        pushBuffer();
-        mergedSegments.push(("(" + (s.value) + ")"));
-      }
-    }
-    pushBuffer();
-
-    return mergedSegments.join('+')
-  }
-
-  /*  */
-
-
+  const RAW = 0;
+  const INTERPOLATION = 1;
+  const EXPRESSION = 2;
+  function generate(ast, options) {
+      const state = new CodegenState(options);
+      const code = ast ? genSSRElement(ast, state) : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genSSRElement(el, state) {
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genSSRElement);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state, genSSRElement);
+      }
+      else if (el.tag === 'template' && !el.slotTarget) {
+          return el.ssrOptimizability === optimizability.FULL
+              ? genChildrenAsStringNode(el, state)
+              : genSSRChildren(el, state) || 'void 0';
+      }
+      switch (el.ssrOptimizability) {
+          case optimizability.FULL:
+              // stringify whole tree
+              return genStringElement(el, state);
+          case optimizability.SELF:
+              // stringify self and check children
+              return genStringElementWithChildren(el, state);
+          case optimizability.CHILDREN:
+              // generate self as VNode and stringify children
+              return genNormalElement(el, state, true);
+          case optimizability.PARTIAL:
+              // generate self as VNode and check children
+              return genNormalElement(el, state, false);
+          default:
+              // bail whole tree
+              return genElement(el, state);
+      }
+  }
+  function genNormalElement(el, state, stringifyChildren) {
+      const data = el.plain ? undefined : genData(el, state);
+      const children = stringifyChildren
+          ? `[${genChildrenAsStringNode(el, state)}]`
+          : genSSRChildren(el, state, true);
+      return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+  }
+  function genSSRChildren(el, state, checkSkip) {
+      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+  }
+  function genSSRNode(el, state) {
+      return el.type === 1 ? genSSRElement(el, state) : genText(el);
+  }
+  function genChildrenAsStringNode(el, state) {
+      return el.children.length
+          ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+          : '';
+  }
+  function genStringElement(el, state) {
+      return `_ssrNode(${elementToString(el, state)})`;
+  }
+  function genStringElementWithChildren(el, state) {
+      const children = genSSRChildren(el, state, true);
+      return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+  }
+  function elementToString(el, state) {
+      return `(${flattenSegments(elementToSegments(el, state))})`;
+  }
+  function elementToSegments(el, state) {
+      // v-for / v-if
+      if (el.for && !el.forProcessed) {
+          el.forProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genFor(el, state, elementToString, '_ssrList'),
+              },
+          ];
+      }
+      else if (el.if && !el.ifProcessed) {
+          el.ifProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genIf(el, state, elementToString, '"<!---->"'),
+              },
+          ];
+      }
+      else if (el.tag === 'template') {
+          return childrenToSegments(el, state);
+      }
+      const openSegments = elementToOpenTagSegments(el, state);
+      const childrenSegments = childrenToSegments(el, state);
+      const { isUnaryTag } = state.options;
+      const close = isUnaryTag && isUnaryTag(el.tag)
+          ? []
+          : [{ type: RAW, value: `</${el.tag}>` }];
+      return openSegments.concat(childrenSegments, close);
+  }
+  function elementToOpenTagSegments(el, state) {
+      applyModelTransform(el, state);
+      let binding;
+      const segments = [{ type: RAW, value: `<${el.tag}` }];
+      // attrs
+      if (el.attrs) {
+          segments.push.apply(segments, genAttrSegments(el.attrs));
+      }
+      // domProps
+      if (el.props) {
+          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+      }
+      // v-bind="object"
+      if ((binding = el.attrsMap['v-bind'])) {
+          segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+      }
+      // v-bind.prop="object"
+      if ((binding = el.attrsMap['v-bind.prop'])) {
+          segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+      }
+      // class
+      if (el.staticClass || el.classBinding) {
+          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+      }
+      // style & v-show
+      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+      }
+      // _scopedId
+      if (state.options.scopeId) {
+          segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+      }
+      segments.push({ type: RAW, value: `>` });
+      return segments;
+  }
+  function childrenToSegments(el, state) {
+      let binding;
+      if ((binding = el.attrsMap['v-html'])) {
+          return [{ type: EXPRESSION, value: `_s(${binding})` }];
+      }
+      if ((binding = el.attrsMap['v-text'])) {
+          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+      }
+      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+      }
+      return el.children ? nodesToSegments(el.children, state) : [];
+  }
+  function nodesToSegments(children, state) {
+      const segments = [];
+      for (let i = 0; i < children.length; i++) {
+          const c = children[i];
+          if (c.type === 1) {
+              segments.push.apply(segments, elementToSegments(c, state));
+          }
+          else if (c.type === 2) {
+              segments.push({ type: INTERPOLATION, value: c.expression });
+          }
+          else if (c.type === 3) {
+              let text = escape(c.text);
+              if (c.isComment) {
+                  text = '<!--' + text + '-->';
+              }
+              segments.push({ type: RAW, value: text });
+          }
+      }
+      return segments;
+  }
+  function flattenSegments(segments) {
+      const mergedSegments = [];
+      let textBuffer = '';
+      const pushBuffer = () => {
+          if (textBuffer) {
+              mergedSegments.push(JSON.stringify(textBuffer));
+              textBuffer = '';
+          }
+      };
+      for (let i = 0; i < segments.length; i++) {
+          const s = segments[i];
+          if (s.type === RAW) {
+              textBuffer += s.value;
+          }
+          else if (s.type === INTERPOLATION) {
+              pushBuffer();
+              mergedSegments.push(`_ssrEscape(${s.value})`);
+          }
+          else if (s.type === EXPRESSION) {
+              pushBuffer();
+              mergedSegments.push(`(${s.value})`);
+          }
+      }
+      pushBuffer();
+      return mergedSegments.join('+');
+  }
 
   // these keywords should not appear inside expressions, but operators like
   // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp('\\b' + (
-    'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-    'super,throw,while,yield,delete,export,import,return,switch,default,' +
-    'extends,finally,continue,debugger,function,arguments'
-  ).split(',').join('\\b|\\b') + '\\b');
-
+  const prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
   // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp('\\b' + (
-    'delete,typeof,void'
-  ).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+  const unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
   // strip strings in expressions
-  var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
+  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
   // detect problematic expressions in a template
-  function detectErrors (ast, warn) {
-    if (ast) {
-      checkNode(ast, warn);
-    }
-  }
-
-  function checkNode (node, warn) {
-    if (node.type === 1) {
-      for (var name in node.attrsMap) {
-        if (dirRE.test(name)) {
-          var value = node.attrsMap[name];
-          if (value) {
-            var range = node.rawAttrsMap[name];
-            if (name === 'v-for') {
-              checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-            } else if (name === 'v-slot' || name[0] === '#') {
-              checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-            } else if (onRE.test(name)) {
-              checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-            } else {
-              checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-            }
-          }
-        }
-      }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn);
-        }
-      }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node);
-    }
-  }
-
-  function checkEvent (exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        "avoid using JavaScript unary operator as property name: " +
-        "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-        range
-      );
-    }
-    checkExpression(exp, text, warn, range);
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (const name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  const value = node.attrsMap[name];
+                  if (value) {
+                      const range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, `v-for="${value}"`, warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, `${name}="${value}"`, warn, range);
+                      }
+                      else {
+                          checkExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (let i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
+          }
+      }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
+      }
   }
-
-  function checkFor (node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  function checkEvent(exp, text, warn, range) {
+      const stripped = exp.replace(stripStringRE, '');
+      const keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn(`avoid using JavaScript unary operator as property name: ` +
+              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+      }
+      checkExpression(exp, text, warn, range);
   }
-
-  function checkIdentifier (
-    ident,
-    type,
-    text,
-    warn,
-    range
-  ) {
-    if (typeof ident === 'string') {
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(`var ${ident}=_`);
+          }
+          catch (e) {
+              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+          }
+      }
+  }
+  function checkExpression(exp, text, warn, range) {
       try {
-        new Function(("var " + ident + "=_"));
-      } catch (e) {
-        warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-      }
-    }
-  }
-
-  function checkExpression (exp, text, warn, range) {
-    try {
-      new Function(("return " + exp));
-    } catch (e) {
-      var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-      if (keywordMatch) {
-        warn(
-          "avoid using JavaScript keyword as property name: " +
-          "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-          range
-        );
-      } else {
-        warn(
-          "invalid expression: " + (e.message) + " in\n\n" +
-          "    " + exp + "\n\n" +
-          "  Raw expression: " + (text.trim()) + "\n",
-          range
-        );
-      }
-    }
-  }
-
-  function checkFunctionParameterExpression (exp, text, warn, range) {
-    try {
-      new Function(exp, '');
-    } catch (e) {
-      warn(
-        "invalid function parameter expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-
-  /*  */
-
-  var range = 2;
-
-  function generateCodeFrame (
-    source,
-    start,
-    end
-  ) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
-      count += lines[i].length + 1;
-      if (count >= start) {
-        for (var j = i - range; j <= i + range || end > count; j++) {
-          if (j < 0 || j >= lines.length) { continue }
-          res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-          var lineLength = lines[j].length;
-          if (j === i) {
-            // push underline
-            var pad = start - (count - lineLength) + 1;
-            var length = end > count ? lineLength - pad : end - start;
-            res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-          } else if (j > i) {
-            if (end > count) {
-              var length$1 = Math.min(end - count, lineLength);
-              res.push("   |  " + repeat$1("^", length$1));
-            }
-            count += lineLength + 1;
-          }
-        }
-        break
-      }
-    }
-    return res.join('\n')
-  }
-
-  function repeat$1 (str, n) {
-    var result = '';
-    if (n > 0) {
-      while (true) { // eslint-disable-line
-        if (n & 1) { result += str; }
-        n >>>= 1;
-        if (n <= 0) { break }
-        str += str;
-      }
-    }
-    return result
-  }
-
-  /*  */
-
-
-
-  function createFunction (code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code });
-      return noop
-    }
-  }
-
-  function createCompileToFunctionFn (compile) {
-    var cache = Object.create(null);
-
-    return function compileToFunctions (
-      template,
-      options,
-      vm
-    ) {
-      options = extend({}, options);
-      var warn$$1 = options.warn || warn;
-      delete options.warn;
-
-      /* istanbul ignore if */
-      {
-        // detect possible CSP restriction
-        try {
-          new Function('return 1');
-        } catch (e) {
-          if (e.toString().match(/unsafe-eval|CSP/)) {
-            warn$$1(
-              'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-            );
-          }
-        }
-      }
-
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template;
-      if (cache[key]) {
-        return cache[key]
-      }
-
-      // compile
-      var compiled = compile(template, options);
-
-      // check compilation errors/tips
-      {
-        if (compiled.errors && compiled.errors.length) {
-          if (options.outputSourceRange) {
-            compiled.errors.forEach(function (e) {
-              warn$$1(
-                "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-                generateCodeFrame(template, e.start, e.end),
-                vm
-              );
-            });
-          } else {
-            warn$$1(
-              "Error compiling template:\n\n" + template + "\n\n" +
-              compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-              vm
-            );
-          }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-          } else {
-            compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-          }
-        }
-      }
-
-      // turn code into functions
-      var res = {};
-      var fnGenErrors = [];
-      res.render = createFunction(compiled.render, fnGenErrors);
-      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-        return createFunction(code, fnGenErrors)
-      });
+          new Function(`return ${exp}`);
+      }
+      catch (e) {
+          const keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn(`avoid using JavaScript keyword as property name: ` +
+                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+          }
+          else {
+              warn(`invalid expression: ${e.message} in\n\n` +
+                  `    ${exp}\n\n` +
+                  `  Raw expression: ${text.trim()}\n`, range);
+          }
+      }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn(`invalid function parameter expression: ${e.message} in\n\n` +
+              `    ${exp}\n\n` +
+              `  Raw expression: ${text.trim()}\n`, range);
+      }
+  }
+
+  const range = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (let j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      continue;
+                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      const pad = start - (count - lineLength) + 1;
+                      const length = end > count ? lineLength - pad : end - start;
+                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          const length = Math.min(end - count, lineLength);
+                          res.push(`   |  ` + repeat(`^`, length));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
+          }
+      }
+      return res.join('\n');
+  }
+  function repeat(str, n) {
+      let result = '';
+      if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  result += str;
+              n >>>= 1;
+              if (n <= 0)
+                  break;
+              str += str;
+          }
+      }
+      return result;
+  }
 
-      // check function generation errors.
-      // this should only happen if there is a bug in the compiler itself.
-      // mostly for codegen development use
-      /* istanbul ignore if */
-      {
-        if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-          warn$$1(
-            "Failed to generate render function:\n\n" +
-            fnGenErrors.map(function (ref) {
-              var err = ref.err;
-              var code = ref.code;
-
-              return ((err.toString()) + " in\n\n" + code + "\n");
-          }).join('\n'),
-            vm
-          );
-        }
-      }
-
-      return (cache[key] = res)
-    }
-  }
-
-  /*  */
-
-  function createCompilerCreator (baseCompile) {
-    return function createCompiler (baseOptions) {
-      function compile (
-        template,
-        options
-      ) {
-        var finalOptions = Object.create(baseOptions);
-        var errors = [];
-        var tips = [];
-
-        var warn = function (msg, range, tip) {
-          (tip ? tips : errors).push(msg);
-        };
-
-        if (options) {
-          if (options.outputSourceRange) {
-            // $flow-disable-line
-            var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-            warn = function (msg, range, tip) {
-              var data = { msg: msg };
-              if (range) {
-                if (range.start != null) {
-                  data.start = range.start + leadingSpaceLength;
-                }
-                if (range.end != null) {
-                  data.end = range.end + leadingSpaceLength;
-                }
-              }
-              (tip ? tips : errors).push(data);
-            };
-          }
-          // merge custom modules
-          if (options.modules) {
-            finalOptions.modules =
-              (baseOptions.modules || []).concat(options.modules);
-          }
-          // merge custom directives
-          if (options.directives) {
-            finalOptions.directives = extend(
-              Object.create(baseOptions.directives || null),
-              options.directives
-            );
-          }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key];
-            }
-          }
-        }
-
-        finalOptions.warn = warn;
-
-        var compiled = baseCompile(template.trim(), finalOptions);
-        {
-          detectErrors(compiled.ast, warn);
-        }
-        compiled.errors = errors;
-        compiled.tips = tips;
-        return compiled
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
+      }
+      catch (err) {
+          errors.push({ err, code });
+          return noop$1;
       }
+  }
+  function createCompileToFunctionFn(compile) {
+      const cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          const warn = options.warn || warn$2;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
+          }
+          // check cache
+          const key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
+          }
+          // compile
+          const compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach((e) => {
+                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn(`Error compiling template:\n\n${template}\n\n` +
+                          compiled.errors.map((e) => `- ${e}`).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach((e) => tip(e.msg, vm));
+                  }
+                  else {
+                      compiled.tips.forEach((msg) => tip(msg, vm));
+                  }
+              }
+          }
+          // turn code into functions
+          const res = {};
+          const fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn(`Failed to generate render function:\n\n` +
+                      fnGenErrors
+                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
+  }
+
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              const finalOptions = Object.create(baseOptions);
+              const errors = [];
+              const tips = [];
+              let warn = (msg, range, tip) => {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = (msg, range, tip) => {
+                          const data = { msg };
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (const key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
+              }
+              finalOptions.warn = warn;
+              const compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
+          }
+          return {
+              compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
+  }
 
+  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      const ast = parse(template.trim(), options);
+      optimize(ast, options);
+      const code = generate(ast, options);
       return {
-        compile: compile,
-        compileToFunctions: createCompileToFunctionFn(compile)
-      }
-    }
-  }
-
-  /*  */
-
-  var createCompiler = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    optimize(ast, options);
-    var code = generate$1(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
+          ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
-  /*  */
-
-  var ref = createCompiler(baseOptions);
-  var compile = ref.compile;
-  var compileToFunctions = ref.compileToFunctions;
-
-  /*  */
+  const { compile, compileToFunctions } = createCompiler(baseOptions);
 
   // The template compiler attempts to minimize the need for normalization by
   // statically analyzing the template at compile time.
@@ -6650,1372 +5761,1048 @@
   // For plain HTML markup, normalization can be completely skipped because the
   // generated render function is guaranteed to return Array<VNode>. There are
   // two cases where extra normalization is needed:
-
   // 1. When the children contains components - because a functional component
   // may return an Array instead of a single root. In this case, just a simple
   // normalization is needed - if any child is an Array, we flatten the whole
   // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
   // because functional components already normalize their own children.
-  function simpleNormalizeChildren (children) {
-    for (var i = 0; i < children.length; i++) {
-      if (Array.isArray(children[i])) {
-        return Array.prototype.concat.apply([], children)
+  function simpleNormalizeChildren(children) {
+      for (let i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
       }
-    }
-    return children
+      return children;
   }
-
   // 2. When the children contains constructs that always generated nested Arrays,
   // e.g. <template>, <slot>, v-for, or when the children is provided by user
   // with hand-written render functions / JSX. In such cases a full normalization
   // is needed to cater to all possible types of children values.
-  function normalizeChildren (children) {
-    return isPrimitive(children)
-      ? [createTextVNode(children)]
-      : Array.isArray(children)
-        ? normalizeArrayChildren(children)
-        : undefined
-  }
-
-  function isTextNode (node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-  }
-
-  function normalizeArrayChildren (children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-      c = children[i];
-      if (isUndef(c) || typeof c === 'boolean') { continue }
-      lastIndex = res.length - 1;
-      last = res[lastIndex];
-      //  nested
-      if (Array.isArray(c)) {
-        if (c.length > 0) {
-          c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-          // merge adjacent text nodes
-          if (isTextNode(c[0]) && isTextNode(last)) {
-            res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-            c.shift();
-          }
-          res.push.apply(res, c);
-        }
-      } else if (isPrimitive(c)) {
-        if (isTextNode(last)) {
-          // merge adjacent text nodes
-          // this is necessary for SSR hydration because text nodes are
-          // essentially merged when rendered to HTML strings
-          res[lastIndex] = createTextVNode(last.text + c);
-        } else if (c !== '') {
-          // convert primitive to vnode
-          res.push(createTextVNode(c));
-        }
-      } else {
-        if (isTextNode(c) && isTextNode(last)) {
-          // merge adjacent text nodes
-          res[lastIndex] = createTextVNode(last.text + c.text);
-        } else {
-          // default key for nested array children (likely generated by v-for)
-          if (isTrue(children._isVList) &&
-            isDef(c.tag) &&
-            isUndef(c.key) &&
-            isDef(nestedIndex)) {
-            c.key = "__vlist" + nestedIndex + "_" + i + "__";
-          }
-          res.push(c);
-        }
-      }
-    }
-    return res
-  }
-
-  /*  */
-
-  var ssrHelpers = {
-    _ssrEscape: escape,
-    _ssrNode: renderStringNode,
-    _ssrList: renderStringList,
-    _ssrAttr: renderAttr,
-    _ssrAttrs: renderAttrs$1,
-    _ssrDOMProps: renderDOMProps$1,
-    _ssrClass: renderSSRClass,
-    _ssrStyle: renderSSRStyle
-  };
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      const res = [];
+      let i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              continue;
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = `__vlist${nestedIndex}_${i}__`;
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
+  }
 
-  function installSSRHelpers (vm) {
-    if (vm._ssrNode) {
-      return
-    }
-    var Vue = vm.constructor;
-    while (Vue.super) {
-      Vue = Vue.super;
-    }
-    extend(Vue.prototype, ssrHelpers);
-    if (Vue.FunctionalRenderContext) {
-      extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-    }
-  }
-
-  var StringNode = function StringNode (
-    open,
-    close,
-    children,
-    normalizationType
-  ) {
-    this.isString = true;
-    this.open = open;
-    this.close = close;
-    if (children) {
-      this.children = normalizationType === 1
-        ? simpleNormalizeChildren(children)
-        : normalizationType === 2
-          ? normalizeChildren(children)
-          : children;
-    } else {
-      this.children = void 0;
-    }
+  const ssrHelpers = {
+      _ssrEscape: escape,
+      _ssrNode: renderStringNode$1,
+      _ssrList: renderStringList,
+      _ssrAttr: renderAttr,
+      _ssrAttrs: renderAttrs,
+      _ssrDOMProps: renderDOMProps,
+      _ssrClass: renderSSRClass,
+      _ssrStyle: renderSSRStyle,
   };
-
-  function renderStringNode (
-    open,
-    close,
-    children,
-    normalizationType
-  ) {
-    return new StringNode(open, close, children, normalizationType)
-  }
-
-  function renderStringList (
-    val,
-    render
-  ) {
-    var ret = '';
-    var i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-      for (i = 0, l = val.length; i < l; i++) {
-        ret += render(val[i], i);
-      }
-    } else if (typeof val === 'number') {
-      for (i = 0; i < val; i++) {
-        ret += render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      keys = Object.keys(val);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret += render(val[key], key, i);
-      }
-    }
-    return ret
-  }
-
-  function renderAttrs$1 (obj) {
-    var res = '';
-    for (var key in obj) {
-      if (isSSRUnsafeAttr(key)) {
-        continue
-      }
-      res += renderAttr(key, obj[key]);
-    }
-    return res
-  }
-
-  function renderDOMProps$1 (obj) {
-    var res = '';
-    for (var key in obj) {
-      var attr = propsToAttrMap[key] || key.toLowerCase();
-      if (isRenderableAttr(attr)) {
-        res += renderAttr(attr, obj[key]);
-      }
-    }
-    return res
-  }
-
-  function renderSSRClass (
-    staticClass,
-    dynamic
-  ) {
-    var res = renderClass(staticClass, dynamic);
-    return res === '' ? res : (" class=\"" + (escape(res)) + "\"")
-  }
-
-  function renderSSRStyle (
-    staticStyle,
-    dynamic,
-    extra
-  ) {
-    var style = {};
-    if (staticStyle) { extend(style, staticStyle); }
-    if (dynamic) { extend(style, normalizeStyleBinding(dynamic)); }
-    if (extra) { extend(style, extra); }
-    var res = genStyle(style);
-    return res === '' ? res : (" style=" + (JSON.stringify(escape(res))))
+  function installSSRHelpers(vm) {
+      if (vm._ssrNode) {
+          return;
+      }
+      let Vue = vm.constructor;
+      // @ts-expect-error
+      while (Vue.super) {
+          // @ts-expect-error
+          Vue = Vue.super;
+      }
+      extend(Vue.prototype, ssrHelpers);
+      // @ts-expect-error
+      if (Vue.FunctionalRenderContext) {
+          // @ts-expect-error
+          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+      }
+  }
+  class StringNode {
+      isString;
+      open;
+      close;
+      children;
+      constructor(open, close, children, normalizationType) {
+          this.isString = true;
+          this.open = open;
+          this.close = close;
+          if (children) {
+              this.children =
+                  normalizationType === 1
+                      ? simpleNormalizeChildren(children)
+                      : normalizationType === 2
+                          ? normalizeChildren(children)
+                          : children;
+          }
+          else {
+              this.children = void 0;
+          }
+      }
+  }
+  function renderStringNode$1(open, close, children, normalizationType) {
+      return new StringNode(open, close, children, normalizationType);
+  }
+  function renderStringList(val, render) {
+      let ret = '';
+      let i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          for (i = 0, l = val.length; i < l; i++) {
+              ret += render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          for (i = 0; i < val; i++) {
+              ret += render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          keys = Object.keys(val);
+          for (i = 0, l = keys.length; i < l; i++) {
+              key = keys[i];
+              ret += render(val[key], key, i);
+          }
+      }
+      return ret;
+  }
+  function renderAttrs(obj) {
+      let res = '';
+      for (const key in obj) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          res += renderAttr(key, obj[key]);
+      }
+      return res;
+  }
+  function renderDOMProps(obj) {
+      let res = '';
+      for (const key in obj) {
+          const attr = propsToAttrMap[key] || key.toLowerCase();
+          if (isRenderableAttr(attr)) {
+              res += renderAttr(attr, obj[key]);
+          }
+      }
+      return res;
+  }
+  function renderSSRClass(staticClass, dynamic) {
+      const res = renderClass$1(staticClass, dynamic);
+      return res === '' ? res : ` class="${escape(res)}"`;
+  }
+  function renderSSRStyle(staticStyle, dynamic, extra) {
+      const style = {};
+      if (staticStyle)
+          extend(style, staticStyle);
+      if (dynamic)
+          extend(style, normalizeStyleBinding(dynamic));
+      if (extra)
+          extend(style, extra);
+      const res = genStyle(style);
+      return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
   }
 
   /* not type checking this file because flow doesn't play well with Proxy */
-
   {
-    var allowedGlobals = makeMap(
-      'Infinity,undefined,NaN,isFinite,isNaN,' +
-      'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-      'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-      'require' // for Webpack/Browserify
-    );
-
-    var hasProxy =
-      typeof Proxy !== 'undefined' && isNative(Proxy);
-
-    if (hasProxy) {
-      var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-      config.keyCodes = new Proxy(config.keyCodes, {
-        set: function set (target, key, value) {
-          if (isBuiltInModifier(key)) {
-            warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-            return false
-          } else {
-            target[key] = value;
-            return true
-          }
-        }
-      });
-    }
+      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
+      );
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
   }
 
-  /*  */
-
-  var seenObjects = new _Set();
-
+  const seenObjects = new _Set();
   /**
    * Recursively traverse an object to evoke all converted
    * getters, so that every nested property inside the object
    * is collected as a "deep" dependency.
    */
-  function traverse (val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-  }
-
-  function _traverse (val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-      return
-    }
-    if (val.__ob__) {
-      var depId = val.__ob__.dep.id;
-      if (seen.has(depId)) {
-        return
-      }
-      seen.add(depId);
-    }
-    if (isA) {
-      i = val.length;
-      while (i--) { _traverse(val[i], seen); }
-    } else {
-      keys = Object.keys(val);
-      i = keys.length;
-      while (i--) { _traverse(val[keys[i]], seen); }
-    }
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      let i, keys;
+      const isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          const depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              _traverse(val[i], seen);
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              _traverse(val[keys[i]], seen);
+      }
   }
 
-  {
-    var perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (
-      perf &&
-      perf.mark &&
-      perf.measure &&
-      perf.clearMarks &&
-      perf.clearMeasures
-    ) ;
-  }
-
-  /*  */
-
-  var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once$$1 ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-      name: name,
-      once: once$$1,
-      capture: capture,
-      passive: passive
-    }
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
+      const capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name,
+          once,
+          capture,
+          passive,
+      };
   });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          const fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      let name, cur, old, event;
+      for (name in on) {
+          cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove(event.name, oldOn[name], event.capture);
+          }
+      }
+  }
 
-  function createFnInvoker (fns, vm) {
-    function invoker () {
-      var arguments$1 = arguments;
-
-      var fns = invoker.fns;
-      if (Array.isArray(fns)) {
-        var cloned = fns.slice();
-        for (var i = 0; i < cloned.length; i++) {
-          invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-        }
-      } else {
-        // return handler return value for single handlers
-        return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-      }
-    }
-    invoker.fns = fns;
-    return invoker
-  }
-
-  function updateListeners (
-    on,
-    oldOn,
-    add,
-    remove$$1,
-    createOnceHandler,
-    vm
-  ) {
-    var name, def$$1, cur, old, event;
-    for (name in on) {
-      def$$1 = cur = on[name];
-      old = oldOn[name];
-      event = normalizeEvent(name);
-      if (isUndef(cur)) {
-        warn(
-          "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-          vm
-        );
-      } else if (isUndef(old)) {
-        if (isUndef(cur.fns)) {
-          cur = on[name] = createFnInvoker(cur, vm);
-        }
-        if (isTrue(event.once)) {
-          cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-        }
-        add(event.name, cur, event.capture, event.passive, event.params);
-      } else if (cur !== old) {
-        old.fns = cur;
-        on[name] = old;
-      }
-    }
-    for (name in oldOn) {
-      if (isUndef(on[name])) {
-        event = normalizeEvent(name);
-        remove$$1(event.name, oldOn[name], event.capture);
-      }
-    }
-  }
-
-  /*  */
-
-  /*  */
-
-  function extractPropsFromVNodeData (
-    data,
-    Ctor,
-    tag
-  ) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    var propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-      return
-    }
-    var res = {};
-    var attrs = data.attrs;
-    var props = data.props;
-    if (isDef(attrs) || isDef(props)) {
-      for (var key in propOptions) {
-        var altKey = hyphenate(key);
-        {
-          var keyInLowerCase = key.toLowerCase();
-          if (
-            key !== keyInLowerCase &&
-            attrs && hasOwn(attrs, keyInLowerCase)
-          ) {
-            tip(
-              "Prop \"" + keyInLowerCase + "\" is passed to component " +
-              (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-              " \"" + key + "\". " +
-              "Note that HTML attributes are case-insensitive and camelCased " +
-              "props need to use their kebab-case equivalents when using in-DOM " +
-              "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-            );
-          }
-        }
-        checkProp(res, props, key, altKey, true) ||
-        checkProp(res, attrs, key, altKey, false);
-      }
-    }
-    return res
-  }
-
-  function checkProp (
-    res,
-    hash,
-    key,
-    altKey,
-    preserve
-  ) {
-    if (isDef(hash)) {
-      if (hasOwn(hash, key)) {
-        res[key] = hash[key];
-        if (!preserve) {
-          delete hash[key];
-        }
-        return true
-      } else if (hasOwn(hash, altKey)) {
-        res[key] = hash[altKey];
-        if (!preserve) {
-          delete hash[altKey];
-        }
-        return true
-      }
-    }
-    return false
-  }
-
-  /*  */
-
-  var SIMPLE_NORMALIZE = 1;
-  var ALWAYS_NORMALIZE = 2;
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      const propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      const res = {};
+      const { attrs, props } = data;
+      if (isDef(attrs) || isDef(props)) {
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
+              {
+                  const keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
+  }
 
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
   // wrapper function for providing a more flexible interface
   // without getting yelled at by flow
-  function createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType,
-    alwaysNormalize
-  ) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-      normalizationType = children;
-      children = data;
-      data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-      normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType)
-  }
-
-  function _createElement (
-    context,
-    tag,
-    data,
-    children,
-    normalizationType
-  ) {
-    if (isDef(data) && isDef((data).__ob__)) {
-      warn(
-        "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-        'Always create fresh vnode data objects in each render!',
-        context
-      );
-      return createEmptyVNode()
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-      tag = data.is;
-    }
-    if (!tag) {
-      // in case of component :is set to falsy value
-      return createEmptyVNode()
-    }
-    // warn against non-primitive key
-    if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-    ) {
-      {
-        warn(
-          'Avoid using non-primitive value as key, ' +
-          'use string/number value instead.',
-          context
-        );
-      }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) &&
-      typeof children[0] === 'function'
-    ) {
-      data = data || {};
-      data.scopedSlots = { default: children[0] };
-      children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-      children = normalizeChildren(children);
-    } else if (normalizationType === SIMPLE_NORMALIZE) {
-      children = simpleNormalizeChildren(children);
-    }
-    var vnode, ns;
-    if (typeof tag === 'string') {
-      var Ctor;
-      ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-      if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-        // component
-        vnode = createComponent(Ctor, data, context, children, tag);
-      } else {
-        // unknown or unlisted namespaced elements
-        // check at runtime because it may get assigned a namespace when its
-        // parent normalizes children
-        vnode = new VNode(
-          tag, data, children,
-          undefined, undefined, context
-        );
-      }
-    } else {
-      // direct component options / constructor
-      vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-      return vnode
-    } else if (isDef(vnode)) {
-      if (isDef(ns)) { applyNS(vnode, ns); }
-      if (isDef(data)) { registerDeepBindings(data); }
-      return vnode
-    } else {
-      return createEmptyVNode()
-    }
-  }
-
-  function applyNS (vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-      // use default namespace inside foreignObject
-      ns = undefined;
-      force = true;
-    }
-    if (isDef(vnode.children)) {
-      for (var i = 0, l = vnode.children.length; i < l; i++) {
-        var child = vnode.children[i];
-        if (isDef(child.tag) && (
-          isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-          applyNS(child, ns, force);
-        }
-      }
-    }
+  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn$2('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      let vnode, ns;
+      if (typeof tag === 'string') {
+          let Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              applyNS(vnode, ns);
+          if (isDef(data))
+              registerDeepBindings(data);
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
   }
-
   // ref #5318
   // necessary to ensure parent re-render when deep bindings like :style and
   // :class are used on slot nodes
-  function registerDeepBindings (data) {
-    if (isObject(data.style)) {
-      traverse(data.style);
-    }
-    if (isObject(data.class)) {
-      traverse(data.class);
-    }
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering v-for lists.
    */
-  function renderList (
-    val,
-    render
-  ) {
-    var ret, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-      ret = new Array(val.length);
-      for (i = 0, l = val.length; i < l; i++) {
-        ret[i] = render(val[i], i);
-      }
-    } else if (typeof val === 'number') {
-      ret = new Array(val);
-      for (i = 0; i < val; i++) {
-        ret[i] = render(i + 1, i);
-      }
-    } else if (isObject(val)) {
-      if (hasSymbol && val[Symbol.iterator]) {
-        ret = [];
-        var iterator = val[Symbol.iterator]();
-        var result = iterator.next();
-        while (!result.done) {
-          ret.push(render(result.value, ret.length));
-          result = iterator.next();
-        }
-      } else {
-        keys = Object.keys(val);
-        ret = new Array(keys.length);
-        for (i = 0, l = keys.length; i < l; i++) {
-          key = keys[i];
-          ret[i] = render(val[key], key, i);
-        }
+  function renderList(val, render) {
+      let ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
       }
-    }
-    if (!isDef(ret)) {
-      ret = [];
-    }
-    (ret)._isVList = true;
-    return ret
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering <slot>
    */
-  function renderSlot (
-    name,
-    fallbackRender,
-    props,
-    bindObject
-  ) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
-    if (scopedSlotFn) {
-      // scoped slot
-      props = props || {};
-      if (bindObject) {
-        if (!isObject(bindObject)) {
-          warn('slot v-bind without argument expects an Object', this);
-        }
-        props = extend(extend({}, bindObject), props);
-      }
-      nodes =
-        scopedSlotFn(props) ||
-        (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender);
-    } else {
-      nodes =
-        this.$slots[name] ||
-        (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender);
-    }
-
-    var target = props && props.slot;
-    if (target) {
-      return this.$createElement('template', { slot: target }, nodes)
-    } else {
-      return nodes
-    }
-  }
-
-  /*  */
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn$2("slot v-bind without argument expects an Object", this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      else {
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      const target = props && props.slot;
+      if (target) {
+          return this.$createElement("template", { slot: target }, nodes);
+      }
+      else {
+          return nodes;
+      }
+  }
 
   /**
    * Runtime helper for resolving filters
    */
-  function resolveFilter (id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  /*  */
-
-  function isKeyNotMatch (expect, actual) {
-    if (Array.isArray(expect)) {
-      return expect.indexOf(actual) === -1
-    } else {
-      return expect !== actual
-    }
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
   }
-
   /**
    * Runtime helper for checking keyCodes from config.
    * exposed as Vue.prototype._k
    * passing in eventKeyName as last argument separately for backwards compat
    */
-  function checkKeyCodes (
-    eventKeyCode,
-    key,
-    builtInKeyCode,
-    eventKeyName,
-    builtInKeyName
-  ) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-      return isKeyNotMatch(builtInKeyName, eventKeyName)
-    } else if (mappedKeyCode) {
-      return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-    } else if (eventKeyName) {
-      return hyphenate(eventKeyName) !== key
-    }
-    return eventKeyCode === undefined
-  }
-
-  /*  */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+      return eventKeyCode === undefined;
+  }
 
   /**
    * Runtime helper for merging v-bind="object" into a VNode's data.
    */
-  function bindObjectProps (
-    data,
-    tag,
-    value,
-    asProp,
-    isSync
-  ) {
-    if (value) {
-      if (!isObject(value)) {
-        warn(
-          'v-bind without argument expects an Object or Array value',
-          this
-        );
-      } else {
-        if (Array.isArray(value)) {
-          value = toObject(value);
-        }
-        var hash;
-        var loop = function ( key ) {
-          if (
-            key === 'class' ||
-            key === 'style' ||
-            isReservedAttribute(key)
-          ) {
-            hash = data;
-          } else {
-            var type = data.attrs && data.attrs.type;
-            hash = asProp || config.mustUseProp(tag, type, key)
-              ? data.domProps || (data.domProps = {})
-              : data.attrs || (data.attrs = {});
-          }
-          var camelizedKey = camelize(key);
-          var hyphenatedKey = hyphenate(key);
-          if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-            hash[key] = value[key];
-
-            if (isSync) {
-              var on = data.on || (data.on = {});
-              on[("update:" + key)] = function ($event) {
-                value[key] = $event;
-              };
-            }
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn$2('v-bind without argument expects an Object or Array value', this);
+          }
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              let hash;
+              for (const key in value) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      const type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              }
           }
-        };
-
-        for (var key in value) loop( key );
       }
-    }
-    return data
+      return data;
   }
 
-  /*  */
-
   /**
    * Runtime helper for rendering static trees.
    */
-  function renderStatic (
-    index,
-    isInFor
-  ) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-      return tree
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(
-      this._renderProxy,
-      null,
-      this // for render fns generated for functional component templates
-    );
-    markStatic(tree, ("__static__" + index), false);
-    return tree
+  function renderStatic(index, isInFor) {
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, `__static__${index}`, false);
+      return tree;
   }
-
   /**
    * Runtime helper for v-once.
    * Effectively it means marking the node as static with a unique key.
    */
-  function markOnce (
-    tree,
-    index,
-    key
-  ) {
-    markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-    return tree
+  function markOnce(tree, index, key) {
+      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (let i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
-  function markStatic (
-    tree,
-    key,
-    isOnce
-  ) {
-    if (Array.isArray(tree)) {
-      for (var i = 0; i < tree.length; i++) {
-        if (tree[i] && typeof tree[i] !== 'string') {
-          markStaticNode(tree[i], (key + "_" + i), isOnce);
-        }
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn$2('v-on without argument expects an Object value', this);
+          }
+          else {
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
       }
-    } else {
-      markStaticNode(tree, key, isOnce);
-    }
+      return data;
   }
 
-  function markStaticNode (node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
-  /*  */
-
-  function bindObjectListeners (data, value) {
-    if (value) {
-      if (!isPlainObject(value)) {
-        warn(
-          'v-on without argument expects an Object value',
-          this
-        );
-      } else {
-        var on = data.on = data.on ? extend({}, data.on) : {};
-        for (var key in value) {
-          var existing = on[key];
-          var ours = value[key];
-          on[key] = existing ? [].concat(existing, ours) : ours;
-        }
-      }
-    }
-    return data
-  }
-
-  /*  */
-
-  function resolveScopedSlots (
-    fns, // see flow/vnode
-    res,
-    // the following are added in 2.6
-    hasDynamicKeys,
-    contentHashKey
-  ) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-      var slot = fns[i];
-      if (Array.isArray(slot)) {
-        resolveScopedSlots(slot, res, hasDynamicKeys);
-      } else if (slot) {
-        // marker for reverse proxying v-slot without scope on this.$slots
-        if (slot.proxy) {
-          slot.fn.proxy = true;
-        }
-        res[slot.key] = slot.fn;
-      }
-    }
-    if (contentHashKey) {
-      (res).$key = contentHashKey;
-    }
-    return res
-  }
-
-  /*  */
-
-  function bindDynamicKeys (baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-      var key = values[i];
-      if (typeof key === 'string' && key) {
-        baseObj[values[i]] = values[i + 1];
-      } else if (key !== '' && key !== null) {
-        // null is a special value for explicitly removing a binding
-        warn(
-          ("Invalid value for dynamic directive argument (expected string or null): " + key),
-          this
-        );
-      }
-    }
-    return baseObj
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+  function bindDynamicKeys(baseObj, values) {
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+          }
+      }
+      return baseObj;
   }
-
   // helper to dynamically append modifier runtime markers to event names.
   // ensure only append when value is already string, otherwise it will be cast
   // to string and cause the type check to miss.
-  function prependModifier (value, symbol) {
-    return typeof value === 'string' ? symbol + value : value
-  }
-
-  /*  */
-
-  function installRenderHelpers (target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
+  }
+
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
   }
 
-  /*  */
-
-
-
   /**
    * Runtime helper for resolving raw children VNodes into a slot object.
    */
-  function resolveSlots (
-    children,
-    context
-  ) {
-    if (!children || !children.length) {
-      return {}
-    }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-      var child = children[i];
-      var data = child.data;
-      // remove slot attribute if the node is resolved as a Vue slot node
-      if (data && data.attrs && data.attrs.slot) {
-        delete data.attrs.slot;
-      }
-      // named slots should only be respected if the vnode was rendered in the
-      // same context.
-      if ((child.context === context || child.fnContext === context) &&
-        data && data.slot != null
-      ) {
-        var name = data.slot;
-        var slot = (slots[name] || (slots[name] = []));
-        if (child.tag === 'template') {
-          slot.push.apply(slot, child.children || []);
-        } else {
-          slot.push(child);
-        }
-      } else {
-        (slots.default || (slots.default = [])).push(child);
-      }
-    }
-    // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-      if (slots[name$1].every(isWhitespace)) {
-        delete slots[name$1];
-      }
-    }
-    return slots
-  }
-
-  function isWhitespace (node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' '
-  }
-
-  /*  */
-
-  function isAsyncPlaceholder (node) {
-    return node.isComment && node.asyncFactory
-  }
-
-  /*  */
-
-  function normalizeScopedSlots (
-    slots,
-    normalSlots,
-    prevSlots
-  ) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
-    if (!slots) {
-      res = {};
-    } else if (slots._normalized) {
-      // fast path 1: child component re-render only, parent did not change
-      return slots._normalized
-    } else if (
-      isStable &&
-      prevSlots &&
-      prevSlots !== emptyObject &&
-      key === prevSlots.$key &&
-      !hasNormalSlots &&
-      !prevSlots.$hasNormal
-    ) {
-      // fast path 2: stable scoped slots w/ no normal slots to proxy,
-      // only need to normalize once
-      return prevSlots
-    } else {
-      res = {};
-      for (var key$1 in slots) {
-        if (slots[key$1] && key$1[0] !== '$') {
-          res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-        }
-      }
-    }
-    // expose normal slots on scopedSlots
-    for (var key$2 in normalSlots) {
-      if (!(key$2 in res)) {
-        res[key$2] = proxyNormalSlot(normalSlots, key$2);
-      }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-      (slots)._normalized = res;
-    }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
-    return res
-  }
-
-  function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-      var res = arguments.length ? fn.apply(null, arguments) : fn({});
-      res = res && typeof res === 'object' && !Array.isArray(res)
-        ? [res] // single vnode
-        : normalizeChildren(res);
-      var vnode = res && res[0];
-      return res && (
-        !vnode ||
-        (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode)) // #9658, #10391
-      ) ? undefined
-        : res
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-      Object.defineProperty(normalSlots, key, {
-        get: normalized,
-        enumerable: true,
-        configurable: true
-      });
-    }
-    return normalized
-  }
-
-  function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; }
-  }
-
-  /*  */
-
-  var currentRenderingInstance = null;
-
-  /*  */
-
-  function ensureCtor (comp, base) {
-    if (
-      comp.__esModule ||
-      (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-    ) {
-      comp = comp.default;
-    }
-    return isObject(comp)
-      ? base.extend(comp)
-      : comp
-  }
-
-  function createAsyncPlaceholder (
-    factory,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    var node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-    return node
-  }
-
-  function resolveAsyncComponent (
-    factory,
-    baseCtor
-  ) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-      return factory.errorComp
-    }
-
-    if (isDef(factory.resolved)) {
-      return factory.resolved
-    }
-
-    var owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-      // already pending
-      factory.owners.push(owner);
-    }
-
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-      return factory.loadingComp
-    }
-
-    if (owner && !isDef(factory.owners)) {
-      var owners = factory.owners = [owner];
-      var sync = true;
-      var timerLoading = null;
-      var timerTimeout = null
-
-      ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-      var forceRender = function (renderCompleted) {
-        for (var i = 0, l = owners.length; i < l; i++) {
-          (owners[i]).$forceUpdate();
-        }
-
-        if (renderCompleted) {
-          owners.length = 0;
-          if (timerLoading !== null) {
-            clearTimeout(timerLoading);
-            timerLoading = null;
-          }
-          if (timerTimeout !== null) {
-            clearTimeout(timerTimeout);
-            timerTimeout = null;
-          }
-        }
-      };
-
-      var resolve = once(function (res) {
-        // cache resolved
-        factory.resolved = ensureCtor(res, baseCtor);
-        // invoke callbacks only if this is not a synchronous resolve
-        // (async resolves are shimmed as synchronous during SSR)
-        if (!sync) {
-          forceRender(true);
-        } else {
-          owners.length = 0;
-        }
-      });
-
-      var reject = once(function (reason) {
-        warn(
-          "Failed to resolve async component: " + (String(factory)) +
-          (reason ? ("\nReason: " + reason) : '')
-        );
-        if (isDef(factory.errorComp)) {
-          factory.error = true;
-          forceRender(true);
-        }
-      });
-
-      var res = factory(resolve, reject);
-
-      if (isObject(res)) {
-        if (isPromise(res)) {
-          // () => Promise
-          if (isUndef(factory.resolved)) {
-            res.then(resolve, reject);
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
           }
-        } else if (isPromise(res.component)) {
-          res.component.then(resolve, reject);
-
-          if (isDef(res.error)) {
-            factory.errorComp = ensureCtor(res.error, baseCtor);
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
           }
-
-          if (isDef(res.loading)) {
-            factory.loadingComp = ensureCtor(res.loading, baseCtor);
-            if (res.delay === 0) {
-              factory.loading = true;
-            } else {
-              timerLoading = setTimeout(function () {
-                timerLoading = null;
-                if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                  factory.loading = true;
-                  forceRender(false);
-                }
-              }, res.delay || 200);
-            }
+          else {
+              (slots.default || (slots.default = [])).push(child);
           }
-
-          if (isDef(res.timeout)) {
-            timerTimeout = setTimeout(function () {
-              timerTimeout = null;
-              if (isUndef(factory.resolved)) {
-                reject(
-                  "timeout (" + (res.timeout) + "ms)"
-                );
-              }
-            }, res.timeout);
+      }
+      // ignore slots that contains only whitespace
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
           }
-        }
       }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  }
 
-      sync = false;
-      // return in case resolved synchronously
-      return factory.loading
-        ? factory.loadingComp
-        : factory.resolved
-    }
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
   }
 
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  var target;
-
-  function add (event, fn) {
-    target.$on(event, fn);
-  }
-
-  function remove$1 (event, fn) {
-    target.$off(event, fn);
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
+      return res;
   }
-
-  function createOnceHandler (event, fn) {
-    var _target = target;
-    return function onceHandler () {
-      var res = fn.apply(null, arguments);
-      if (res !== null) {
-        _target.$off(event, onceHandler);
+  function normalizeScopedSlot(normalSlots, key, fn) {
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === "object" && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
       }
-    }
-  }
-
-  function updateComponentListeners (
-    vm,
-    listeners,
-    oldListeners
-  ) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-    target = undefined;
-  }
-
-  /*  */
-
-  var activeInstance = null;
-
-  function updateChildComponent (
-    vm,
-    propsData,
-    listeners,
-    parentVnode,
-    renderChildren
-  ) {
-
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!(
-      (newScopedSlots && !newScopedSlots.$stable) ||
-      (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-      (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-      (!newScopedSlots && vm.$scopedSlots.$key)
-    );
-
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(
-      renderChildren ||               // has new static slots
-      vm.$options._renderChildren ||  // has old static slots
-      hasDynamicScopedSlot
-    );
-
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-    if (vm._vnode) { // update child tree's parent
-      vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
+      return normalized;
+  }
+  function proxyNormalSlot(slots, key) {
+      return () => slots[key];
+  }
 
-    // update props
-    if (propsData && vm.$options.props) {
-      toggleObserving(false);
-      var props = vm._props;
-      var propKeys = vm.$options._propKeys || [];
-      for (var i = 0; i < propKeys.length; i++) {
-        var key = propKeys[i];
-        var propOptions = vm.$options.props; // wtf flow?
-        props[key] = validateProp(key, propOptions, propsData, vm);
-      }
-      toggleObserving(true);
-      // keep a copy of raw propsData
-      vm.$options.propsData = propsData;
-    }
-
-    // update listeners
-    listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-      vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-      vm.$forceUpdate();
-    }
-  }
-
-  function isInInactiveTree (vm) {
-    while (vm && (vm = vm.$parent)) {
-      if (vm._inactive) { return true }
-    }
-    return false
-  }
-
-  function activateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = false;
-      if (isInInactiveTree(vm)) {
-        return
-      }
-    } else if (vm._directInactive) {
-      return
-    }
-    if (vm._inactive || vm._inactive === null) {
-      vm._inactive = false;
-      for (var i = 0; i < vm.$children.length; i++) {
-        activateChildComponent(vm.$children[i]);
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      const node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data, context, children, tag };
+      return node;
+  }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
       }
-      callHook(vm, 'activated');
-    }
   }
 
-  function deactivateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = true;
-      if (isInInactiveTree(vm)) {
-        return
+  let target;
+  function add(event, fn) {
+      target.$on(event, fn);
+  }
+  function remove(event, fn) {
+      target.$off(event, fn);
+  }
+  function createOnceHandler(event, fn) {
+      const _target = target;
+      return function onceHandler() {
+          const res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
+  }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target = vm;
+      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
+      target = undefined;
+  }
+
+  let activeInstance = null;
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      const needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      vm.$options._parentVnode = parentVnode;
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      const oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              return true;
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
       }
-    }
-    if (!vm._inactive) {
-      vm._inactive = true;
-      for (var i = 0; i < vm.$children.length; i++) {
-        deactivateChildComponent(vm.$children[i]);
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (let i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, "activated");
       }
-      callHook(vm, 'deactivated');
-    }
   }
-
-  function callHook (vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
-    if (handlers) {
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (let i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, "deactivated");
       }
-    }
-    if (vm._hasHookEvent) {
-      vm.$emit('hook:' + hook);
-    }
-    popTarget();
   }
-
-  /*  */
+  function callHook(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
+      if (handlers) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit("hook:" + hook);
+      }
+      popTarget();
+  }
 
   // Async edge case fix requires storing an event listener's attach timestamp.
-  var getNow = Date.now;
-
+  let getNow = Date.now;
   // Determine what event timestamp the browser is using. Annoyingly, the
   // timestamp can either be hi-res (relative to page load) or low-res
   // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -8023,964 +6810,820 @@
   // All IE versions use low-res event timestamps, and have problematic clock
   // implementations (#9632)
   if (inBrowser && !isIE) {
-    var performance = window.performance;
-    if (
-      performance &&
-      typeof performance.now === 'function' &&
-      getNow() > document.createEvent('Event').timeStamp
-    ) {
-      // if the event timestamp, although evaluated AFTER the Date.now(), is
-      // smaller than it, it means the event is using a hi-res timestamp,
-      // and we need to use the hi-res version for event listener timestamps as
-      // well.
-      getNow = function () { return performance.now(); };
-    }
+      const performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = () => performance.now();
+      }
   }
-
   /**
    * Queue a kept-alive component that was activated during patch.
    * The queue will be processed after the entire tree has been patched.
    */
-  function queueActivatedComponent (vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-  }
-
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  function resolveInject (inject, vm) {
-    if (inject) {
-      // inject is :any because flow is not smart enough to figure out cached
-      var result = Object.create(null);
-      var keys = hasSymbol
-        ? Reflect.ownKeys(inject)
-        : Object.keys(inject);
-
-      for (var i = 0; i < keys.length; i++) {
-        var key = keys[i];
-        // #6574 in case the inject object is observed...
-        if (key === '__ob__') { continue }
-        var provideKey = inject[key].from;
-        var source = vm;
-        while (source) {
-          if (source._provided && hasOwn(source._provided, provideKey)) {
-            result[key] = source._provided[provideKey];
-            break
-          }
-          source = source.$parent;
-        }
-        if (!source) {
-          if ('default' in inject[key]) {
-            var provideDefault = inject[key].default;
-            result[key] = typeof provideDefault === 'function'
-              ? provideDefault.call(vm)
-              : provideDefault;
-          } else {
-            warn(("Injection \"" + key + "\" not found"), vm);
-          }
-        }
-      }
-      return result
-    }
-  }
-
-  /*  */
-
-  function resolveConstructorOptions (Ctor) {
-    var options = Ctor.options;
-    if (Ctor.super) {
-      var superOptions = resolveConstructorOptions(Ctor.super);
-      var cachedSuperOptions = Ctor.superOptions;
-      if (superOptions !== cachedSuperOptions) {
-        // super option changed,
-        // need to resolve new options.
-        Ctor.superOptions = superOptions;
-        // check if there are any late-modified/attached options (#4976)
-        var modifiedOptions = resolveModifiedOptions(Ctor);
-        // update base extend options
-        if (modifiedOptions) {
-          extend(Ctor.extendOptions, modifiedOptions);
-        }
-        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-        if (options.name) {
-          options.components[options.name] = Ctor;
-        }
-      }
-    }
-    return options
-  }
-
-  function resolveModifiedOptions (Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
-      if (latest[key] !== sealed[key]) {
-        if (!modified) { modified = {}; }
-        modified[key] = latest[key];
-      }
-    }
-    return modified
-  }
-
-  /*  */
-
-  function FunctionalRenderContext (
-    data,
-    props,
-    children,
-    parent,
-    Ctor
-  ) {
-    var this$1 = this;
-
-    var options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
-    if (hasOwn(parent, '_uid')) {
-      contextVm = Object.create(parent);
-      // $flow-disable-line
-      contextVm._original = parent;
-    } else {
-      // the context vm passed in is a functional context as well.
-      // in this case we want to make sure we are able to get a hold to the
-      // real context instance.
-      contextVm = parent;
-      // $flow-disable-line
-      parent = parent._original;
-    }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
-
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-      if (!this$1.$slots) {
-        normalizeScopedSlots(
-          data.scopedSlots,
-          this$1.$slots = resolveSlots(children, parent)
-        );
-      }
-      return this$1.$slots
-    };
-
-    Object.defineProperty(this, 'scopedSlots', ({
-      enumerable: true,
-      get: function get () {
-        return normalizeScopedSlots(data.scopedSlots, this.slots())
-      }
-    }));
-
-    // support for compiled functional template
-    if (isCompiled) {
-      // exposing $options for renderStatic()
-      this.$options = options;
-      // pre-resolve slots for renderSlot()
-      this.$slots = this.slots();
-      this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-
-    if (options._scopeId) {
-      this._c = function (a, b, c, d) {
-        var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-        if (vnode && !Array.isArray(vnode)) {
-          vnode.fnScopeId = options._scopeId;
-          vnode.fnContext = parent;
-        }
-        return vnode
-      };
-    } else {
-      this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-    }
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
   }
 
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      const provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      warn$2(`Injection "${key}" not found`, vm);
+                  }
+              }
+          }
+          return result;
+      }
+  }
+
+  function resolveConstructorOptions(Ctor) {
+      let options = Ctor.options;
+      if (Ctor.super) {
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              const modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  modified = {};
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
+  }
+
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      const options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      let contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+          }
+          return this.$slots;
+      };
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = (a, b, c, d) => {
+              const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+      }
+  }
   installRenderHelpers(FunctionalRenderContext.prototype);
-
-  function createFunctionalComponent (
-    Ctor,
-    propsData,
-    data,
-    contextVm,
-    children
-  ) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
-    if (isDef(propOptions)) {
-      for (var key in propOptions) {
-        props[key] = validateProp(key, propOptions, propsData || emptyObject);
-      }
-    } else {
-      if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-      if (isDef(data.props)) { mergeProps(props, data.props); }
-    }
-
-    var renderContext = new FunctionalRenderContext(
-      data,
-      props,
-      children,
-      contextVm,
-      Ctor
-    );
-
-    var vnode = options.render.call(null, renderContext._c, renderContext);
-
-    if (vnode instanceof VNode) {
-      return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-    } else if (Array.isArray(vnode)) {
-      var vnodes = normalizeChildren(vnode) || [];
-      var res = new Array(vnodes.length);
-      for (var i = 0; i < vnodes.length; i++) {
-        res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-      }
-      return res
-    }
-  }
-
-  function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    var clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-      (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-      (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone
-  }
-
-  function mergeProps (to, from) {
-    for (var key in from) {
-      to[camelize(key)] = from[key];
-    }
-  }
-
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  /*  */
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (const key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              mergeProps(props, data.attrs);
+          if (isDef(data.props))
+              mergeProps(props, data.props);
+      }
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      const clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (const key in from) {
+          to[camelize(key)] = from[key];
+      }
+  }
 
   // inline hooks to be invoked on component VNodes during patch
-  var componentVNodeHooks = {
-    init: function init (vnode, hydrating) {
-      if (
-        vnode.componentInstance &&
-        !vnode.componentInstance._isDestroyed &&
-        vnode.data.keepAlive
-      ) {
-        // kept-alive components, treat as a patch
-        var mountedNode = vnode; // work around flow
-        componentVNodeHooks.prepatch(mountedNode, mountedNode);
-      } else {
-        var child = vnode.componentInstance = createComponentInstanceForVnode(
-          vnode,
-          activeInstance
-        );
-        child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-      }
-    },
-
-    prepatch: function prepatch (oldVnode, vnode) {
-      var options = vnode.componentOptions;
-      var child = vnode.componentInstance = oldVnode.componentInstance;
-      updateChildComponent(
-        child,
-        options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-      );
-    },
-
-    insert: function insert (vnode) {
-      var context = vnode.context;
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isMounted) {
-        componentInstance._isMounted = true;
-        callHook(componentInstance, 'mounted');
-      }
-      if (vnode.data.keepAlive) {
-        if (context._isMounted) {
-          // vue-router#1212
-          // During updates, a kept-alive component's child components may
-          // change, so directly walking the tree here may call activated hooks
-          // on incorrect children. Instead we push them into a queue which will
-          // be processed after the whole patch process ended.
-          queueActivatedComponent(componentInstance);
-        } else {
-          activateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    },
-
-    destroy: function destroy (vnode) {
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isDestroyed) {
-        if (!vnode.data.keepAlive) {
-          componentInstance.$destroy();
-        } else {
-          deactivateChildComponent(componentInstance, true /* direct */);
-        }
-      }
-    }
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              const mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy(vnode) {
+          const { componentInstance } = vnode;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
   };
-
-  var hooksToMerge = Object.keys(componentVNodeHooks);
-
-  function createComponent (
-    Ctor,
-    data,
-    context,
-    children,
-    tag
-  ) {
-    if (isUndef(Ctor)) {
-      return
-    }
-
-    var baseCtor = context.$options._base;
-
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-      Ctor = baseCtor.extend(Ctor);
-    }
-
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-      {
-        warn(("Invalid Component definition: " + (String(Ctor))), context);
-      }
-      return
-    }
-
-    // async component
-    var asyncFactory;
-    if (isUndef(Ctor.cid)) {
-      asyncFactory = Ctor;
-      Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-      if (Ctor === undefined) {
-        // return a placeholder node for async component, which is rendered
-        // as a comment node but preserves all the raw information for the node.
-        // the information will be used for async server-rendering and hydration.
-        return createAsyncPlaceholder(
-          asyncFactory,
-          data,
-          context,
-          children,
-          tag
-        )
-      }
-    }
-
-    data = data || {};
-
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-      transformModel(Ctor.options, data);
-    }
-
-    // extract props
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-    // functional component
-    if (isTrue(Ctor.options.functional)) {
-      return createFunctionalComponent(Ctor, propsData, data, context, children)
-    }
-
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    var listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-
-    if (isTrue(Ctor.options.abstract)) {
-      // abstract components do not keep anything
-      // other than props & listeners & slot
-
-      // work around flow
-      var slot = data.slot;
-      data = {};
-      if (slot) {
-        data.slot = slot;
-      }
-    }
-
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-
-    // return a placeholder vnode
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
-      ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-      data, undefined, undefined, undefined, context,
-      { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-      asyncFactory
-    );
-
-    return vnode
-  }
-
-  function createComponentInstanceForVnode (
-    // we know it's MountedComponentVNode but flow doesn't
-    vnode,
-    // activeInstance in lifecycle state
-    parent
-  ) {
-    var options = {
-      _isComponent: true,
-      _parentVnode: vnode,
-      parent: parent
-    };
-    // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-      options.render = inlineTemplate.render;
-      options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options)
-  }
-
-  function installComponentHooks (data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-      var key = hooksToMerge[i];
-      var existing = hooks[key];
-      var toMerge = componentVNodeHooks[key];
-      if (existing !== toMerge && !(existing && existing._merged)) {
-        hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
-      }
-    }
-  }
-
-  function mergeHook$1 (f1, f2) {
-    var merged = function (a, b) {
-      // flow complains about extra args which is why we use any
-      f1(a, b);
-      f2(a, b);
-    };
-    merged._merged = true;
-    return merged
+  const hooksToMerge = Object.keys(componentVNodeHooks);
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      const baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+          }
+          return;
+      }
+      // async component
+      let asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      const listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          const slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
+      // @ts-expect-error
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      const options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent,
+      };
+      // check inline-template render functions
+      const inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook(f1, f2) {
+      const merged = (a, b) => {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
   }
-
   // transform component v-model info (value and callback) into
   // prop and event handler respectively.
-  function transformModel (options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input'
-    ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
-    if (isDef(existing)) {
-      if (
-        Array.isArray(existing)
-          ? existing.indexOf(callback) === -1
-          : existing !== callback
-      ) {
-        on[event] = [callback].concat(existing);
-      }
-    } else {
-      on[event] = callback;
-    }
-  }
-
-  /*  */
-
-  var warned = Object.create(null);
-  var warnOnce = function (msg) {
-    if (!warned[msg]) {
-      warned[msg] = true;
-      // eslint-disable-next-line no-console
-      console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
-    }
-  };
+  function transformModel(options, data) {
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
+  }
 
-  var onCompilationError = function (err, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"))
+  let warned = Object.create(null);
+  const warnOnce = (msg) => {
+      if (!warned[msg]) {
+          warned[msg] = true;
+          // eslint-disable-next-line no-console
+          console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
+      }
   };
-
-  var normalizeRender = function (vm) {
-    var ref = vm.$options;
-    var render = ref.render;
-    var template = ref.template;
-    var _scopeId = ref._scopeId;
-    if (isUndef(render)) {
-      if (template) {
-        var compiled = compileToFunctions(template, {
-          scopeId: _scopeId,
-          warn: onCompilationError
-        }, vm);
-
-        vm.$options.render = compiled.render;
-        vm.$options.staticRenderFns = compiled.staticRenderFns;
-      } else {
-        throw new Error(
-          ("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'))
-        )
-      }
-    }
+  const onCompilationError = (err, vm) => {
+      const trace = vm ? generateComponentTrace(vm) : '';
+      throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
   };
-
-  function waitForServerPrefetch (vm, resolve, reject) {
-    var handlers = vm.$options.serverPrefetch;
-    if (isDef(handlers)) {
-      if (!Array.isArray(handlers)) { handlers = [handlers]; }
-      try {
-        var promises = [];
-        for (var i = 0, j = handlers.length; i < j; i++) {
-          var result = handlers[i].call(vm, vm);
-          if (result && typeof result.then === 'function') {
-            promises.push(result);
-          }
-        }
-        Promise.all(promises).then(resolve).catch(reject);
-        return
-      } catch (e) {
-        reject(e);
-      }
-    }
-    resolve();
-  }
-
-  function renderNode (node, isRoot, context) {
-    if (node.isString) {
-      renderStringNode$1(node, context);
-    } else if (isDef(node.componentOptions)) {
-      renderComponent(node, isRoot, context);
-    } else if (isDef(node.tag)) {
-      renderElement(node, isRoot, context);
-    } else if (isTrue(node.isComment)) {
-      if (isDef(node.asyncFactory)) {
-        // async component
-        renderAsyncComponent(node, isRoot, context);
-      } else {
-        context.write(("<!--" + (node.text) + "-->"), context.next);
-      }
-    } else {
-      context.write(
-        node.raw ? node.text : escape(String(node.text)),
-        context.next
-      );
-    }
-  }
-
-  function registerComponentForCache (options, write) {
-    // exposed by vue-loader, need to call this if cache hit because
-    // component lifecycle hooks will not be called.
-    var register = options._ssrRegister;
-    if (write.caching && isDef(register)) {
-      write.componentBuffer[write.componentBuffer.length - 1].add(register);
-    }
-    return register
-  }
-
-  function renderComponent (node, isRoot, context) {
-    var write = context.write;
-    var next = context.next;
-    var userContext = context.userContext;
-
-    // check cache hit
-    var Ctor = node.componentOptions.Ctor;
-    var getKey = Ctor.options.serverCacheKey;
-    var name = Ctor.options.name;
-    var cache = context.cache;
-    var registerComponent = registerComponentForCache(Ctor.options, write);
-
-    if (isDef(getKey) && isDef(cache) && isDef(name)) {
-      var rawKey = getKey(node.componentOptions.propsData);
-      if (rawKey === false) {
-        renderComponentInner(node, isRoot, context);
-        return
-      }
-      var key = name + '::' + rawKey;
-      var has = context.has;
-      var get = context.get;
-      if (isDef(has)) {
-        has(key, function (hit) {
-          if (hit === true && isDef(get)) {
-            get(key, function (res) {
-              if (isDef(registerComponent)) {
-                registerComponent(userContext);
-              }
-              res.components.forEach(function (register) { return register(userContext); });
-              write(res.html, next);
-            });
-          } else {
-            renderComponentWithCache(node, isRoot, key, context);
-          }
-        });
-      } else if (isDef(get)) {
-        get(key, function (res) {
-          if (isDef(res)) {
-            if (isDef(registerComponent)) {
-              registerComponent(userContext);
-            }
-            res.components.forEach(function (register) { return register(userContext); });
-            write(res.html, next);
-          } else {
-            renderComponentWithCache(node, isRoot, key, context);
-          }
-        });
-      }
-    } else {
-      if (isDef(getKey) && isUndef(cache)) {
-        warnOnce(
-          "[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
-          'but no cache was provided to the renderer.'
-        );
-      }
-      if (isDef(getKey) && isUndef(name)) {
-        warnOnce(
-          "[vue-server-renderer] Components that implement \"serverCacheKey\" " +
-          "must also define a unique \"name\" option."
-        );
+  const normalizeRender = (vm) => {
+      const { render, template, _scopeId } = vm.$options;
+      if (isUndef(render)) {
+          if (template) {
+              const compiled = compileToFunctions(template, {
+                  scopeId: _scopeId,
+                  warn: onCompilationError,
+              }, vm);
+              vm.$options.render = compiled.render;
+              vm.$options.staticRenderFns = compiled.staticRenderFns;
+          }
+          else {
+              throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
+          }
       }
-      renderComponentInner(node, isRoot, context);
-    }
-  }
-
-  function renderComponentWithCache (node, isRoot, key, context) {
-    var write = context.write;
-    write.caching = true;
-    var buffer = write.cacheBuffer;
-    var bufferIndex = buffer.push('') - 1;
-    var componentBuffer = write.componentBuffer;
-    componentBuffer.push(new Set());
-    context.renderStates.push({
-      type: 'ComponentWithCache',
-      key: key,
-      buffer: buffer,
-      bufferIndex: bufferIndex,
-      componentBuffer: componentBuffer
-    });
-    renderComponentInner(node, isRoot, context);
-  }
-
-  function renderComponentInner (node, isRoot, context) {
-    var prevActive = context.activeInstance;
-    // expose userContext on vnode
-    node.ssrContext = context.userContext;
-    var child = context.activeInstance = createComponentInstanceForVnode(
-      node,
-      context.activeInstance
-    );
-    normalizeRender(child);
-
-    var resolve = function () {
-      var childNode = child._render();
-      childNode.parent = node;
+  };
+  function waitForServerPrefetch(vm, resolve, reject) {
+      let handlers = vm.$options.serverPrefetch;
+      if (isDef(handlers)) {
+          if (!Array.isArray(handlers))
+              handlers = [handlers];
+          try {
+              const promises = [];
+              for (let i = 0, j = handlers.length; i < j; i++) {
+                  const result = handlers[i].call(vm, vm);
+                  if (result && typeof result.then === 'function') {
+                      promises.push(result);
+                  }
+              }
+              Promise.all(promises).then(resolve).catch(reject);
+              return;
+          }
+          catch (e) {
+              reject(e);
+          }
+      }
+      resolve();
+  }
+  function renderNode(node, isRoot, context) {
+      if (node.isString) {
+          renderStringNode(node, context);
+      }
+      else if (isDef(node.componentOptions)) {
+          renderComponent(node, isRoot, context);
+      }
+      else if (isDef(node.tag)) {
+          renderElement(node, isRoot, context);
+      }
+      else if (isTrue(node.isComment)) {
+          if (isDef(node.asyncFactory)) {
+              // async component
+              renderAsyncComponent(node, isRoot, context);
+          }
+          else {
+              context.write(`<!--${node.text}-->`, context.next);
+          }
+      }
+      else {
+          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+      }
+  }
+  function registerComponentForCache(options, write) {
+      // exposed by vue-loader, need to call this if cache hit because
+      // component lifecycle hooks will not be called.
+      const register = options._ssrRegister;
+      if (write.caching && isDef(register)) {
+          write.componentBuffer[write.componentBuffer.length - 1].add(register);
+      }
+      return register;
+  }
+  function renderComponent(node, isRoot, context) {
+      const { write, next, userContext } = context;
+      // check cache hit
+      const Ctor = node.componentOptions.Ctor;
+      const getKey = Ctor.options.serverCacheKey;
+      const name = Ctor.options.name;
+      const cache = context.cache;
+      const registerComponent = registerComponentForCache(Ctor.options, write);
+      if (isDef(getKey) && isDef(cache) && isDef(name)) {
+          const rawKey = getKey(node.componentOptions.propsData);
+          if (rawKey === false) {
+              renderComponentInner(node, isRoot, context);
+              return;
+          }
+          const key = name + '::' + rawKey;
+          const { has, get } = context;
+          if (isDef(has)) {
+              has(key, (hit) => {
+                  if (hit === true && isDef(get)) {
+                      get(key, (res) => {
+                          if (isDef(registerComponent)) {
+                              registerComponent(userContext);
+                          }
+                          res.components.forEach((register) => register(userContext));
+                          write(res.html, next);
+                      });
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+          else if (isDef(get)) {
+              get(key, (res) => {
+                  if (isDef(res)) {
+                      if (isDef(registerComponent)) {
+                          registerComponent(userContext);
+                      }
+                      res.components.forEach((register) => register(userContext));
+                      write(res.html, next);
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+      }
+      else {
+          if (isDef(getKey) && isUndef(cache)) {
+              warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
+                  'but no cache was provided to the renderer.');
+          }
+          if (isDef(getKey) && isUndef(name)) {
+              warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
+                  `must also define a unique "name" option.`);
+          }
+          renderComponentInner(node, isRoot, context);
+      }
+  }
+  function renderComponentWithCache(node, isRoot, key, context) {
+      const write = context.write;
+      write.caching = true;
+      const buffer = write.cacheBuffer;
+      const bufferIndex = buffer.push('') - 1;
+      const componentBuffer = write.componentBuffer;
+      componentBuffer.push(new Set());
       context.renderStates.push({
-        type: 'Component',
-        prevActive: prevActive
+          type: 'ComponentWithCache',
+          key,
+          buffer,
+          bufferIndex,
+          componentBuffer,
       });
-      renderNode(childNode, isRoot, context);
-    };
-
-    var reject = context.done;
-
-    waitForServerPrefetch(child, resolve, reject);
+      renderComponentInner(node, isRoot, context);
   }
-
-  function renderAsyncComponent (node, isRoot, context) {
-    var factory = node.asyncFactory;
-
-    var resolve = function (comp) {
-      if (comp.__esModule && comp.default) {
-        comp = comp.default;
-      }
-      var ref = node.asyncMeta;
-      var data = ref.data;
-      var children = ref.children;
-      var tag = ref.tag;
-      var nodeContext = node.asyncMeta.context;
-      var resolvedNode = createComponent(
-        comp,
-        data,
-        nodeContext,
-        children,
-        tag
-      );
-      if (resolvedNode) {
-        if (resolvedNode.componentOptions) {
-          // normal component
-          renderComponent(resolvedNode, isRoot, context);
-        } else if (!Array.isArray(resolvedNode)) {
-          // single return node from functional component
-          renderNode(resolvedNode, isRoot, context);
-        } else {
-          // multiple return nodes from functional component
+  function renderComponentInner(node, isRoot, context) {
+      const prevActive = context.activeInstance;
+      // expose userContext on vnode
+      node.ssrContext = context.userContext;
+      const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+      normalizeRender(child);
+      const resolve = () => {
+          const childNode = child._render();
+          childNode.parent = node;
           context.renderStates.push({
-            type: 'Fragment',
-            children: resolvedNode,
-            rendered: 0,
-            total: resolvedNode.length
+              type: 'Component',
+              prevActive,
           });
-          context.next();
-        }
-      } else {
-        // invalid component, but this does not throw on the client
-        // so render empty comment node
-        context.write("<!---->", context.next);
-      }
-    };
-
-    if (factory.resolved) {
-      resolve(factory.resolved);
-      return
-    }
-
-    var reject = context.done;
-    var res;
-    try {
-      res = factory(resolve, reject);
-    } catch (e) {
-      reject(e);
-    }
-    if (res) {
-      if (typeof res.then === 'function') {
-        res.then(resolve, reject).catch(reject);
-      } else {
-        // new syntax in 2.3
-        var comp = res.component;
-        if (comp && typeof comp.then === 'function') {
-          comp.then(resolve, reject).catch(reject);
-        }
-      }
-    }
-  }
-
-  function renderStringNode$1 (el, context) {
-    var write = context.write;
-    var next = context.next;
-    if (isUndef(el.children) || el.children.length === 0) {
-      write(el.open + (el.close || ''), next);
-    } else {
-      var children = el.children;
-      context.renderStates.push({
-        type: 'Element',
-        children: children,
-        rendered: 0,
-        total: children.length,
-        endTag: el.close
-      });
-      write(el.open, next);
-    }
-  }
-
-  function renderElement (el, isRoot, context) {
-    var write = context.write;
-    var next = context.next;
-
-    if (isTrue(isRoot)) {
-      if (!el.data) { el.data = {}; }
-      if (!el.data.attrs) { el.data.attrs = {}; }
-      el.data.attrs[SSR_ATTR] = 'true';
-    }
-
-    if (el.fnOptions) {
-      registerComponentForCache(el.fnOptions, write);
-    }
-
-    var startTag = renderStartingTag(el, context);
-    var endTag = "</" + (el.tag) + ">";
-    if (context.isUnaryTag(el.tag)) {
-      write(startTag, next);
-    } else if (isUndef(el.children) || el.children.length === 0) {
-      write(startTag + endTag, next);
-    } else {
-      var children = el.children;
-      context.renderStates.push({
-        type: 'Element',
-        children: children,
-        rendered: 0,
-        total: children.length,
-        endTag: endTag
-      });
-      write(startTag, next);
-    }
+          renderNode(childNode, isRoot, context);
+      };
+      const reject = context.done;
+      waitForServerPrefetch(child, resolve, reject);
+  }
+  function renderAsyncComponent(node, isRoot, context) {
+      const factory = node.asyncFactory;
+      const resolve = (comp) => {
+          if (comp.__esModule && comp.default) {
+              comp = comp.default;
+          }
+          const { data, children, tag } = node.asyncMeta;
+          const nodeContext = node.asyncMeta.context;
+          const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+          if (resolvedNode) {
+              if (resolvedNode.componentOptions) {
+                  // normal component
+                  renderComponent(resolvedNode, isRoot, context);
+              }
+              else if (!Array.isArray(resolvedNode)) {
+                  // single return node from functional component
+                  renderNode(resolvedNode, isRoot, context);
+              }
+              else {
+                  // multiple return nodes from functional component
+                  context.renderStates.push({
+                      type: 'Fragment',
+                      children: resolvedNode,
+                      rendered: 0,
+                      total: resolvedNode.length,
+                  });
+                  context.next();
+              }
+          }
+          else {
+              // invalid component, but this does not throw on the client
+              // so render empty comment node
+              context.write(`<!---->`, context.next);
+          }
+      };
+      if (factory.resolved) {
+          resolve(factory.resolved);
+          return;
+      }
+      const reject = context.done;
+      let res;
+      try {
+          res = factory(resolve, reject);
+      }
+      catch (e) {
+          reject(e);
+      }
+      if (res) {
+          if (typeof res.then === 'function') {
+              res.then(resolve, reject).catch(reject);
+          }
+          else {
+              // new syntax in 2.3
+              const comp = res.component;
+              if (comp && typeof comp.then === 'function') {
+                  comp.then(resolve, reject).catch(reject);
+              }
+          }
+      }
   }
-
-  function hasAncestorData (node) {
-    var parentNode = node.parent;
-    return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
+  function renderStringNode(el, context) {
+      const { write, next } = context;
+      if (isUndef(el.children) || el.children.length === 0) {
+          write(el.open + (el.close || ''), next);
+      }
+      else {
+          const children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children,
+              rendered: 0,
+              total: children.length,
+              endTag: el.close,
+          });
+          write(el.open, next);
+      }
   }
-
-  function getVShowDirectiveInfo (node) {
-    var dir;
-    var tmp;
-
-    while (isDef(node)) {
-      if (node.data && node.data.directives) {
-        tmp = node.data.directives.find(function (dir) { return dir.name === 'show'; });
-        if (tmp) {
-          dir = tmp;
-        }
+  function renderElement(el, isRoot, context) {
+      const { write, next } = context;
+      if (isTrue(isRoot)) {
+          if (!el.data)
+              el.data = {};
+          if (!el.data.attrs)
+              el.data.attrs = {};
+          el.data.attrs[SSR_ATTR] = 'true';
+      }
+      if (el.fnOptions) {
+          registerComponentForCache(el.fnOptions, write);
+      }
+      const startTag = renderStartingTag(el, context);
+      const endTag = `</${el.tag}>`;
+      if (context.isUnaryTag(el.tag)) {
+          write(startTag, next);
+      }
+      else if (isUndef(el.children) || el.children.length === 0) {
+          write(startTag + endTag, next);
+      }
+      else {
+          const children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children,
+              rendered: 0,
+              total: children.length,
+              endTag,
+          });
+          write(startTag, next);
       }
-      node = node.parent;
-    }
-    return dir
   }
-
-  function renderStartingTag (node, context) {
-    var markup = "<" + (node.tag);
-    var directives = context.directives;
-    var modules = context.modules;
-
-    // construct synthetic data for module processing
-    // because modules like style also produce code by parent VNode data
-    if (isUndef(node.data) && hasAncestorData(node)) {
-      node.data = {};
-    }
-    if (isDef(node.data)) {
-      // check directives
-      var dirs = node.data.directives;
-      if (dirs) {
-        for (var i = 0; i < dirs.length; i++) {
-          var name = dirs[i].name;
-          if (name !== 'show') {
-            var dirRenderer = resolveAsset(context, 'directives', name);
-            if (dirRenderer) {
-              // directives mutate the node's data
-              // which then gets rendered by modules
-              dirRenderer(node, dirs[i]);
-            }
-          }
-        }
-      }
-
-      // v-show directive needs to be merged from parent to child
-      var vshowDirectiveInfo = getVShowDirectiveInfo(node);
-      if (vshowDirectiveInfo) {
-        directives.show(node, vshowDirectiveInfo);
-      }
-
-      // apply other modules
-      for (var i$1 = 0; i$1 < modules.length; i$1++) {
-        var res = modules[i$1](node);
-        if (res) {
-          markup += res;
-        }
-      }
-    }
-    // attach scoped CSS ID
-    var scopeId;
-    var activeInstance = context.activeInstance;
-    if (isDef(activeInstance) &&
-      activeInstance !== node.context &&
-      isDef(scopeId = activeInstance.$options._scopeId)
-    ) {
-      markup += " " + ((scopeId));
-    }
-    if (isDef(node.fnScopeId)) {
-      markup += " " + (node.fnScopeId);
-    } else {
-      while (isDef(node)) {
-        if (isDef(scopeId = node.context.$options._scopeId)) {
-          markup += " " + scopeId;
-        }
-        node = node.parent;
-      }
-    }
-    return markup + '>'
-  }
-
-  function createRenderFunction (
-    modules,
-    directives,
-    isUnaryTag,
-    cache
-  ) {
-    return function render (
-      component,
-      write,
-      userContext,
-      done
-    ) {
-      warned = Object.create(null);
-      var context = new RenderContext({
-        activeInstance: component,
-        userContext: userContext,
-        write: write, done: done, renderNode: renderNode,
-        isUnaryTag: isUnaryTag, modules: modules, directives: directives,
-        cache: cache
-      });
-      installSSRHelpers(component);
-      normalizeRender(component);
-
-      var resolve = function () {
-        renderNode(component._render(), true, context);
-      };
-      waitForServerPrefetch(component, resolve, done);
-    }
+  function hasAncestorData(node) {
+      const parentNode = node.parent;
+      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
   }
-
-  /*  */
-
-
-  function createBasicRenderer (ref) {
-    if ( ref === void 0 ) ref = {};
-    var modules = ref.modules; if ( modules === void 0 ) modules = [];
-    var directives = ref.directives; if ( directives === void 0 ) directives = {};
-    var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = (function () { return false; });
-    var cache = ref.cache;
-
-    var render = createRenderFunction(modules, directives, isUnaryTag, cache);
-
-    return function renderToString (
-      component,
-      context,
-      done
-    ) {
-      if (typeof context === 'function') {
-        done = context;
-        context = {};
+  function getVShowDirectiveInfo(node) {
+      let dir;
+      let tmp;
+      while (isDef(node)) {
+          if (node.data && node.data.directives) {
+              tmp = node.data.directives.find((dir) => dir.name === 'show');
+              if (tmp) {
+                  dir = tmp;
+              }
+          }
+          node = node.parent;
+      }
+      //@ts-expect-error
+      return dir;
+  }
+  function renderStartingTag(node, context) {
+      let markup = `<${node.tag}`;
+      const { directives, modules } = context;
+      // construct synthetic data for module processing
+      // because modules like style also produce code by parent VNode data
+      if (isUndef(node.data) && hasAncestorData(node)) {
+          node.data = {};
+      }
+      if (isDef(node.data)) {
+          // check directives
+          const dirs = node.data.directives;
+          if (dirs) {
+              for (let i = 0; i < dirs.length; i++) {
+                  const name = dirs[i].name;
+                  if (name !== 'show') {
+                      const dirRenderer = resolveAsset(context, 'directives', name);
+                      if (dirRenderer) {
+                          // directives mutate the node's data
+                          // which then gets rendered by modules
+                          dirRenderer(node, dirs[i]);
+                      }
+                  }
+              }
+          }
+          // v-show directive needs to be merged from parent to child
+          const vshowDirectiveInfo = getVShowDirectiveInfo(node);
+          if (vshowDirectiveInfo) {
+              directives.show(node, vshowDirectiveInfo);
+          }
+          // apply other modules
+          for (let i = 0; i < modules.length; i++) {
+              const res = modules[i](node);
+              if (res) {
+                  markup += res;
+              }
+          }
       }
-      var result = '';
-      var write = createWriteFunction(function (text) {
-        result += text;
-        return false
-      }, done);
-      try {
-        render(component, write, context, function () {
-          done(null, result);
-        });
-      } catch (e) {
-        done(e);
+      // attach scoped CSS ID
+      let scopeId;
+      const activeInstance = context.activeInstance;
+      if (isDef(activeInstance) &&
+          activeInstance !== node.context &&
+          isDef((scopeId = activeInstance.$options._scopeId))) {
+          markup += ` ${scopeId}`;
+      }
+      if (isDef(node.fnScopeId)) {
+          markup += ` ${node.fnScopeId}`;
+      }
+      else {
+          while (isDef(node)) {
+              //@ts-expect-error
+              if (isDef((scopeId = node.context.$options._scopeId))) {
+                  markup += ` ${scopeId}`;
+              }
+              node = node.parent;
+          }
       }
-    }
+      return markup + '>';
+  }
+  function createRenderFunction(modules, directives, isUnaryTag, cache) {
+      return function render(component, write, userContext, done) {
+          warned = Object.create(null);
+          const context = new RenderContext({
+              activeInstance: component,
+              userContext,
+              write,
+              done,
+              renderNode,
+              isUnaryTag,
+              modules,
+              directives,
+              cache,
+          });
+          installSSRHelpers(component);
+          normalizeRender(component);
+          const resolve = () => {
+              renderNode(component._render(), true, context);
+          };
+          waitForServerPrefetch(component, resolve, done);
+      };
   }
 
-  /*  */
+  function createBasicRenderer({ modules = [], directives = {}, isUnaryTag = () => false, cache, } = {}) {
+      const render = createRenderFunction(modules, directives, isUnaryTag, cache);
+      return function renderToString(component, context, done) {
+          if (typeof context === 'function') {
+              done = context;
+              context = {};
+          }
+          let result = '';
+          const write = createWriteFunction((text) => {
+              result += text;
+              return false;
+          }, done);
+          try {
+              //@ts-expect-error
+              render(component, write, context, () => {
+                  done(null, result);
+              });
+          }
+          catch (e) {
+              done(e);
+          }
+      };
+  }
 
   var entryServerBasicRenderer = createBasicRenderer({
-    modules: modules,
-    directives: directives,
-    isUnaryTag: isUnaryTag,
-    canBeLeftOpenTag: canBeLeftOpenTag
+      // @ts-expect-error
+      modules: modules$1,
+      directives: directives$1,
+      isUnaryTag,
+      canBeLeftOpenTag,
   });
 
   return entryServerBasicRenderer;
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index 8235936b2bd..bb2bebb9468 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -2,1461 +2,1243 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var he = _interopDefault(require('he'));
+var stream = require('stream');
+var he = require('he');
 
-/*  */
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var emptyObject = Object.freeze({});
+var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
-function isDef (v) {
-  return v !== undefined && v !== null
+function isDef(v) {
+    return v !== undefined && v !== null;
 }
-
-function isTrue (v) {
-  return v === true
+function isTrue(v) {
+    return v === true;
 }
-
-function isFalse (v) {
-  return v === false
+function isFalse(v) {
+    return v === false;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
-function isPromise (val) {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
 }
-
 /**
  * Convert a value to a string that is actually rendered.
  */
-function toString (val) {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-      ? JSON.stringify(val, null, 2)
-      : String(val)
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
 }
-
 /**
  * Convert an input value to a number for persistence.
  * If the conversion fails, return original string.
  */
-function toNumber (val) {
-  var n = parseFloat(val);
-  return isNaN(n) ? val : n
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
-
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove$1(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
-
 /**
  * Capitalize a string.
  */
-var capitalize = cached(function (str) {
-  return str.charAt(0).toUpperCase() + str.slice(1)
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
 });
-
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-
-/* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /**
  * Merge an Array of Objects into a single Object.
  */
-function toObject (arr) {
-  var res = {};
-  for (var i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i]);
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop$1(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
-
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
-
+const identity = (_) => _;
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
-
 /**
  * Check if two values are loosely equal - that is,
  * if they are plain objects, do they have the same shape?
  */
-function looseEqual (a, b) {
-  if (a === b) { return true }
-  var isObjectA = isObject(a);
-  var isObjectB = isObject(b);
-  if (isObjectA && isObjectB) {
-    try {
-      var isArrayA = Array.isArray(a);
-      var isArrayB = Array.isArray(b);
-      if (isArrayA && isArrayB) {
-        return a.length === b.length && a.every(function (e, i) {
-          return looseEqual(e, b[i])
-        })
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        var keysA = Object.keys(a);
-        var keysB = Object.keys(b);
-        return keysA.length === keysB.length && keysA.every(function (key) {
-          return looseEqual(a[key], b[key])
-        })
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
 }
-
 /**
  * Return the first index at which a loosely equal value can be
  * found in the array (if value is a plain object, the array must
  * contain an object of the same shape), or -1 if it is not present.
  */
-function looseIndexOf (arr, val) {
-  for (var i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) { return i }
-  }
-  return -1
-}
-
-/**
- * Ensure a function is called only once.
- */
-function once (fn) {
-  var called = false;
-  return function () {
-    if (!called) {
-      called = true;
-      fn.apply(this, arguments);
-    }
-  }
-}
-
-/*  */
-
-var isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-  'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-  'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-  'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-  'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-  'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-  'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-  'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-  'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-  'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-  'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-  'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-  'target,title,usemap,value,width,wrap'
-);
-
-var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-var isSSRUnsafeAttr = function (name) {
-  return unsafeAttrCharRE.test(name)
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
+}
+
+const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+const isSSRUnsafeAttr = (name) => {
+    return unsafeAttrCharRE.test(name);
 };
-
 /* istanbul ignore next */
-var isRenderableAttr = function (name) {
-  return (
-    isAttr(name) ||
-    name.indexOf('data-') === 0 ||
-    name.indexOf('aria-') === 0
-  )
+const isRenderableAttr = (name) => {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
 };
-
-var propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
+const propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
 };
-
-var ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
 };
-
-function escape (s) {
-  return s.replace(/[<>"&]/g, escapeChar)
-}
-
-function escapeChar (a) {
-  return ESC[a] || a
-}
-
-var noUnitNumericStyleProps = {
-  "animation-iteration-count": true,
-  "border-image-outset": true,
-  "border-image-slice": true,
-  "border-image-width": true,
-  "box-flex": true,
-  "box-flex-group": true,
-  "box-ordinal-group": true,
-  "column-count": true,
-  "columns": true,
-  "flex": true,
-  "flex-grow": true,
-  "flex-positive": true,
-  "flex-shrink": true,
-  "flex-negative": true,
-  "flex-order": true,
-  "grid-row": true,
-  "grid-row-end": true,
-  "grid-row-span": true,
-  "grid-row-start": true,
-  "grid-column": true,
-  "grid-column-end": true,
-  "grid-column-span": true,
-  "grid-column-start": true,
-  "font-weight": true,
-  "line-clamp": true,
-  "line-height": true,
-  "opacity": true,
-  "order": true,
-  "orphans": true,
-  "tab-size": true,
-  "widows": true,
-  "z-index": true,
-  "zoom": true,
-  // SVG
-  "fill-opacity": true,
-  "flood-opacity": true,
-  "stop-opacity": true,
-  "stroke-dasharray": true,
-  "stroke-dashoffset": true,
-  "stroke-miterlimit": true,
-  "stroke-opacity": true,
-  "stroke-width": true
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
+}
+const noUnitNumericStyleProps = {
+    'animation-iteration-count': true,
+    'border-image-outset': true,
+    'border-image-slice': true,
+    'border-image-width': true,
+    'box-flex': true,
+    'box-flex-group': true,
+    'box-ordinal-group': true,
+    'column-count': true,
+    columns: true,
+    flex: true,
+    'flex-grow': true,
+    'flex-positive': true,
+    'flex-shrink': true,
+    'flex-negative': true,
+    'flex-order': true,
+    'grid-row': true,
+    'grid-row-end': true,
+    'grid-row-span': true,
+    'grid-row-start': true,
+    'grid-column': true,
+    'grid-column-end': true,
+    'grid-column-span': true,
+    'grid-column-start': true,
+    'font-weight': true,
+    'line-clamp': true,
+    'line-height': true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    'tab-size': true,
+    widows: true,
+    'z-index': true,
+    zoom: true,
+    // SVG
+    'fill-opacity': true,
+    'flood-opacity': true,
+    'stop-opacity': true,
+    'stroke-dasharray': true,
+    'stroke-dashoffset': true,
+    'stroke-miterlimit': true,
+    'stroke-opacity': true,
+    'stroke-width': true,
 };
 
-/*  */
-
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
-
+makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
-var convertEnumeratedValue = function (key, value) {
-  return isFalsyAttrValue(value) || value === 'false'
-    ? 'false'
-    // allow arbitrary string value for contenteditable
-    : key === 'contenteditable' && isValidContentEditableValue(value)
-      ? value
-      : 'true'
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
 };
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,' +
-  'truespeed,typemustmatch,visible'
-);
-
-var isFalsyAttrValue = function (val) {
-  return val == null || val === false
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-/*  */
-
-function renderAttrs (node) {
-  var attrs = node.data.attrs;
-  var res = '';
-
-  var opts = node.parent && node.parent.componentOptions;
-  if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-    var parent = node.parent;
-    while (isDef(parent)) {
-      // Stop fallthrough in case parent has inheritAttrs option set to false
-      if (parent.componentOptions && parent.componentOptions.Ctor.options.inheritAttrs === false) {
-        break;
-      }
-      if (isDef(parent.data) && isDef(parent.data.attrs)) {
-        attrs = extend(extend({}, attrs), parent.data.attrs);
-      }
-      parent = parent.parent;
-    }
-  }
-
-  if (isUndef(attrs)) {
-    return res
-  }
-
-  for (var key in attrs) {
-    if (isSSRUnsafeAttr(key)) {
-      continue
+function renderAttrs$1(node) {
+    let attrs = node.data.attrs;
+    let res = '';
+    const opts = node.parent && node.parent.componentOptions;
+    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+        let parent = node.parent;
+        while (isDef(parent)) {
+            // Stop fallthrough in case parent has inheritAttrs option set to false
+            if (parent.componentOptions &&
+                parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                break;
+            }
+            if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                attrs = extend(extend({}, attrs), parent.data.attrs);
+            }
+            parent = parent.parent;
+        }
     }
-    if (key === 'style') {
-      // leave it to the style module
-      continue
+    if (isUndef(attrs)) {
+        return res;
     }
-    res += renderAttr(key, attrs[key]);
-  }
-  return res
-}
-
-function renderAttr (key, value) {
-  if (isBooleanAttr(key)) {
-    if (!isFalsyAttrValue(value)) {
-      return (" " + key + "=\"" + key + "\"")
-    }
-  } else if (isEnumeratedAttr(key)) {
-    return (" " + key + "=\"" + (escape(convertEnumeratedValue(key, value))) + "\"")
-  } else if (!isFalsyAttrValue(value)) {
-    return (" " + key + "=\"" + (escape(String(value))) + "\"")
-  }
-  return ''
+    for (const key in attrs) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        if (key === 'style') {
+            // leave it to the style module
+            continue;
+        }
+        res += renderAttr(key, attrs[key]);
+    }
+    return res;
 }
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-  return this.componentInstance
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-
-var createEmptyVNode = function (text) {
-  if ( text === void 0 ) text = '';
-
-  var node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node
+function renderAttr(key, value) {
+    if (isBooleanAttr(key)) {
+        if (!isFalsyAttrValue(value)) {
+            return ` ${key}="${key}"`;
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
+    }
+    else if (!isFalsyAttrValue(value)) {
+        return ` ${key}="${escape(String(value))}"`;
+    }
+    return '';
+}
+
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
 };
-
-function createTextVNode (val) {
-  return new VNode(undefined, undefined, undefined, String(val))
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
 }
-
 // optimized shallow clone
 // used for static nodes and slot nodes because they may be reused across
 // multiple renders, cloning them avoids errors when DOM manipulations rely
 // on their elm reference.
-function cloneVNode (vnode) {
-  var cloned = new VNode(
-    vnode.tag,
-    vnode.data,
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
     // #7975
     // clone children array to avoid mutating original in case of cloning
     // a child.
-    vnode.children && vnode.children.slice(),
-    vnode.text,
-    vnode.elm,
-    vnode.context,
-    vnode.componentOptions,
-    vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned
-}
-
-/*  */
-
-function renderDOMProps (node) {
-  var props = node.data.domProps;
-  var res = '';
-
-  var parent = node.parent;
-  while (isDef(parent)) {
-    if (parent.data && parent.data.domProps) {
-      props = extend(extend({}, props), parent.data.domProps);
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
+}
+
+function renderDOMProps$1(node) {
+    let props = node.data.domProps;
+    let res = '';
+    let parent = node.parent;
+    while (isDef(parent)) {
+        if (parent.data && parent.data.domProps) {
+            props = extend(extend({}, props), parent.data.domProps);
+        }
+        parent = parent.parent;
     }
-    parent = parent.parent;
-  }
-
-  if (isUndef(props)) {
-    return res
-  }
-
-  var attrs = node.data.attrs;
-  for (var key in props) {
-    if (key === 'innerHTML') {
-      setText(node, props[key], true);
-    } else if (key === 'textContent') {
-      setText(node, props[key], false);
-    } else if (key === 'value' && node.tag === 'textarea') {
-      setText(node, toString(props[key]), false);
-    } else {
-      // $flow-disable-line (WTF?)
-      var attr = propsToAttrMap[key] || key.toLowerCase();
-      if (isRenderableAttr(attr) &&
-        // avoid rendering double-bound props/attrs twice
-        !(isDef(attrs) && isDef(attrs[attr]))
-      ) {
-        res += renderAttr(attr, props[key]);
-      }
-    }
-  }
-  return res
+    if (isUndef(props)) {
+        return res;
+    }
+    const attrs = node.data.attrs;
+    for (const key in props) {
+        if (key === 'innerHTML') {
+            setText(node, props[key], true);
+        }
+        else if (key === 'textContent') {
+            setText(node, props[key], false);
+        }
+        else if (key === 'value' && node.tag === 'textarea') {
+            setText(node, toString(props[key]), false);
+        }
+        else {
+            // $flow-disable-line (WTF?)
+            const attr = propsToAttrMap[key] || key.toLowerCase();
+            if (isRenderableAttr(attr) &&
+                // avoid rendering double-bound props/attrs twice
+                !(isDef(attrs) && isDef(attrs[attr]))) {
+                res += renderAttr(attr, props[key]);
+            }
+        }
+    }
+    return res;
 }
-
-function setText (node, text, raw) {
-  var child = new VNode(undefined, undefined, undefined, text);
-  child.raw = raw;
-  node.children = [child];
+function setText(node, text, raw) {
+    const child = new VNode(undefined, undefined, undefined, text);
+    child.raw = raw;
+    node.children = [child];
 }
 
-/*  */
-
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
-/*  */
-
 // can we use __proto__?
-var hasProto = '__proto__' in {};
-
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
-
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
-// detect devtools
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
     };
-
-    return Set;
-  }());
 }
 
-var SSR_ATTR = 'data-server-rendered';
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
-var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: "development" !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: "development" !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
-
-var warn = noop;
-var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop$1,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
+let warn$2 = noop$1;
+let tip = noop$1;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
 {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-/*  */
-
-var uid = 0;
-
+let uid = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
-};
-
-Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
-};
-
-Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
-};
-
-Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
-};
-
-Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
-};
-
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$1(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
-var targetStack = [];
-
-function pushTarget (target) {
-  targetStack.push(target);
-  Dep.target = target;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
 }
-
-function popTarget () {
-  targetStack.pop();
-  Dep.target = targetStack[targetStack.length - 1];
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-
-var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
 ];
-
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
  */
-var shouldObserve = true;
-
-function toggleObserving (value) {
-  shouldObserve = value;
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
 }
-
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
-};
-
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
-};
-
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
-};
-
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (isUndef(target) || isPrimitive(target)
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
-
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
     }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
-LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
 });
-
 /**
  * Assets
  *
@@ -1464,603 +1246,521 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && "development" !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
 };
-
 /**
  * Validate component names
  */
-function checkComponents (options) {
-  for (var key in options.components) {
-    validateComponentName(key);
-  }
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
 }
-
-function validateComponentName (name) {
-  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
-    warn(
-      'Invalid component name: "' + name + '". Component names ' +
-      'should conform to valid custom element name in html5 specification.'
-    );
-  }
-  if (isBuiltInTag(name) || config.isReservedTag(name)) {
-    warn(
-      'Do not use built-in or reserved HTML elements as component ' +
-      'id: ' + name
-    );
-  }
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn$2('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
 }
-
 /**
  * Ensure all props option syntax are normalized into the
  * Object-based format.
  */
-function normalizeProps (options, vm) {
-  var props = options.props;
-  if (!props) { return }
-  var res = {};
-  var i, val, name;
-  if (Array.isArray(props)) {
-    i = props.length;
-    while (i--) {
-      val = props[i];
-      if (typeof val === 'string') {
-        name = camelize(val);
-        res[name] = { type: null };
-      } else {
-        warn('props must be strings when using array syntax.');
-      }
-    }
-  } else if (isPlainObject(props)) {
-    for (var key in props) {
-      val = props[key];
-      name = camelize(key);
-      res[name] = isPlainObject(val)
-        ? val
-        : { type: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"props\": expected an Array or an Object, " +
-      "but got " + (toRawType(props)) + ".",
-      vm
-    );
-  }
-  options.props = res;
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn$2('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
 }
-
 /**
  * Normalize all injections into Object-based format
  */
-function normalizeInject (options, vm) {
-  var inject = options.inject;
-  if (!inject) { return }
-  var normalized = options.inject = {};
-  if (Array.isArray(inject)) {
-    for (var i = 0; i < inject.length; i++) {
-      normalized[inject[i]] = { from: inject[i] };
-    }
-  } else if (isPlainObject(inject)) {
-    for (var key in inject) {
-      var val = inject[key];
-      normalized[key] = isPlainObject(val)
-        ? extend({ from: key }, val)
-        : { from: val };
-    }
-  } else {
-    warn(
-      "Invalid value for option \"inject\": expected an Array or an Object, " +
-      "but got " + (toRawType(inject)) + ".",
-      vm
-    );
-  }
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
 }
-
 /**
  * Normalize raw function directives into object format.
  */
-function normalizeDirectives (options) {
-  var dirs = options.directives;
-  if (dirs) {
-    for (var key in dirs) {
-      var def$$1 = dirs[key];
-      if (typeof def$$1 === 'function') {
-        dirs[key] = { bind: def$$1, update: def$$1 };
-      }
+function normalizeDirectives(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
     }
-  }
 }
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
 }
-
 /**
  * Merge two option objects into a new one.
  * Core utility used in both instantiation and inheritance.
  */
-function mergeOptions (
-  parent,
-  child,
-  vm
-) {
-  {
-    checkComponents(child);
-  }
-
-  if (typeof child === 'function') {
-    child = child.options;
-  }
-
-  normalizeProps(child, vm);
-  normalizeInject(child, vm);
-  normalizeDirectives(child);
-
-  // Apply extends and mixins on the child options,
-  // but only if it is a raw options object that isn't
-  // the result of another mergeOptions call.
-  // Only merged options has the _base property.
-  if (!child._base) {
-    if (child.extends) {
-      parent = mergeOptions(parent, child.extends, vm);
-    }
-    if (child.mixins) {
-      for (var i = 0, l = child.mixins.length; i < l; i++) {
-        parent = mergeOptions(parent, child.mixins[i], vm);
-      }
-    }
-  }
-
-  var options = {};
-  var key;
-  for (key in parent) {
-    mergeField(key);
-  }
-  for (key in child) {
-    if (!hasOwn(parent, key)) {
-      mergeField(key);
-    }
-  }
-  function mergeField (key) {
-    var strat = strats[key] || defaultStrat;
-    options[key] = strat(parent[key], child[key], vm, key);
-  }
-  return options
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
 }
-
 /**
  * Resolve an asset.
  * This function is used because child instances need access
  * to assets defined in its ancestor chain.
  */
-function resolveAsset (
-  options,
-  type,
-  id,
-  warnMissing
-) {
-  /* istanbul ignore if */
-  if (typeof id !== 'string') {
-    return
-  }
-  var assets = options[type];
-  // check local registration variations first
-  if (hasOwn(assets, id)) { return assets[id] }
-  var camelizedId = camelize(id);
-  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
-  var PascalCaseId = capitalize(camelizedId);
-  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
-  // fallback to prototype chain
-  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-  if (warnMissing && !res) {
-    warn(
-      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
-      options
-    );
-  }
-  return res
-}
-
-/*  */
-
-
-
-function validateProp (
-  key,
-  propOptions,
-  propsData,
-  vm
-) {
-  var prop = propOptions[key];
-  var absent = !hasOwn(propsData, key);
-  var value = propsData[key];
-  // boolean casting
-  var booleanIndex = getTypeIndex(Boolean, prop.type);
-  if (booleanIndex > -1) {
-    if (absent && !hasOwn(prop, 'default')) {
-      value = false;
-    } else if (value === '' || value === hyphenate(key)) {
-      // only cast empty string / same name to boolean if
-      // boolean has higher priority
-      var stringIndex = getTypeIndex(String, prop.type);
-      if (stringIndex < 0 || booleanIndex < stringIndex) {
-        value = true;
-      }
-    }
-  }
-  // check default value
-  if (value === undefined) {
-    value = getPropDefaultValue(vm, prop, key);
-    // since the default value is a fresh copy,
-    // make sure to observe it.
-    var prevShouldObserve = shouldObserve;
-    toggleObserving(true);
-    observe(value);
-    toggleObserving(prevShouldObserve);
-  }
-  {
-    assertProp(prop, key, value, vm, absent);
-  }
-  return value
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
+}
+
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
 }
-
 /**
  * Get the default value of a prop.
  */
-function getPropDefaultValue (vm, prop, key) {
-  // no default, return undefined
-  if (!hasOwn(prop, 'default')) {
-    return undefined
-  }
-  var def = prop.default;
-  // warn against non-factory defaults for Object & Array
-  if (isObject(def)) {
-    warn(
-      'Invalid default value for prop "' + key + '": ' +
-      'Props with type Object/Array must use a factory function ' +
-      'to return the default value.',
-      vm
-    );
-  }
-  // the raw prop value was also undefined from previous render,
-  // return previous default value to avoid unnecessary watcher trigger
-  if (vm && vm.$options.propsData &&
-    vm.$options.propsData[key] === undefined &&
-    vm._props[key] !== undefined
-  ) {
-    return vm._props[key]
-  }
-  // call factory function for non-Function types
-  // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
-    ? def.call(vm)
-    : def
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn$2('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
 }
-
 /**
  * Assert whether a prop is valid.
  */
-function assertProp (
-  prop,
-  name,
-  value,
-  vm,
-  absent
-) {
-  if (prop.required && absent) {
-    warn(
-      'Missing required prop: "' + name + '"',
-      vm
-    );
-    return
-  }
-  if (value == null && !prop.required) {
-    return
-  }
-  var type = prop.type;
-  var valid = !type || type === true;
-  var expectedTypes = [];
-  if (type) {
-    if (!Array.isArray(type)) {
-      type = [type];
-    }
-    for (var i = 0; i < type.length && !valid; i++) {
-      var assertedType = assertType(value, type[i], vm);
-      expectedTypes.push(assertedType.expectedType || '');
-      valid = assertedType.valid;
-    }
-  }
-
-  var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
-  if (!valid && haveExpectedTypes) {
-    warn(
-      getInvalidTypeMessage(name, value, expectedTypes),
-      vm
-    );
-    return
-  }
-  var validator = prop.validator;
-  if (validator) {
-    if (!validator(value)) {
-      warn(
-        'Invalid prop: custom validator check failed for prop "' + name + '".',
-        vm
-      );
-    }
-  }
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn$2('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
 }
-
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-
-function assertType (value, type, vm) {
-  var valid;
-  var expectedType = getType(type);
-  if (simpleCheckRE.test(expectedType)) {
-    var t = typeof value;
-    valid = t === expectedType.toLowerCase();
-    // for primitive wrapper objects
-    if (!valid && t === 'object') {
-      valid = value instanceof type;
-    }
-  } else if (expectedType === 'Object') {
-    valid = isPlainObject(value);
-  } else if (expectedType === 'Array') {
-    valid = Array.isArray(value);
-  } else {
-    try {
-      valid = value instanceof type;
-    } catch (e) {
-      warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-      valid = false;
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
     }
-  }
-  return {
-    valid: valid,
-    expectedType: expectedType
-  }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
 }
-
-var functionTypeCheckRE = /^\s*function (\w+)/;
-
+const functionTypeCheckRE = /^\s*function (\w+)/;
 /**
  * Use function string name to check built-in types,
  * because a simple equality check will fail when running
  * across different vms / iframes.
  */
-function getType (fn) {
-  var match = fn && fn.toString().match(functionTypeCheckRE);
-  return match ? match[1] : ''
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
 }
-
-function isSameType (a, b) {
-  return getType(a) === getType(b)
+function isSameType(a, b) {
+    return getType(a) === getType(b);
 }
-
-function getTypeIndex (type, expectedTypes) {
-  if (!Array.isArray(expectedTypes)) {
-    return isSameType(expectedTypes, type) ? 0 : -1
-  }
-  for (var i = 0, len = expectedTypes.length; i < len; i++) {
-    if (isSameType(expectedTypes[i], type)) {
-      return i
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
     }
-  }
-  return -1
+    return -1;
 }
-
-function getInvalidTypeMessage (name, value, expectedTypes) {
-  var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-    " Expected " + (expectedTypes.map(capitalize).join(', '));
-  var expectedType = expectedTypes[0];
-  var receivedType = toRawType(value);
-  // check if we need to specify expected value
-  if (
-    expectedTypes.length === 1 &&
-    isExplicable(expectedType) &&
-    isExplicable(typeof value) &&
-    !isBoolean(expectedType, receivedType)
-  ) {
-    message += " with value " + (styleValue(value, expectedType));
-  }
-  message += ", got " + receivedType + " ";
-  // check if we need to specify received value
-  if (isExplicable(receivedType)) {
-    message += "with value " + (styleValue(value, receivedType)) + ".";
-  }
-  return message
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
 }
-
-function styleValue (value, type) {
-  if (type === 'String') {
-    return ("\"" + value + "\"")
-  } else if (type === 'Number') {
-    return ("" + (Number(value)))
-  } else {
-    return ("" + value)
-  }
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
 }
-
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable (value) {
-  return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; })
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
 }
-
-function isBoolean () {
-  var args = [], len = arguments.length;
-  while ( len-- ) args[ len ] = arguments[ len ];
-
-  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-/*  */
-
-function handleError (err, vm, info) {
-  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-  // See: https://github.com/vuejs/vuex/issues/1505
-  pushTarget();
-  try {
-    if (vm) {
-      var cur = vm;
-      while ((cur = cur.$parent)) {
-        var hooks = cur.$options.errorCaptured;
-        if (hooks) {
-          for (var i = 0; i < hooks.length; i++) {
-            try {
-              var capture = hooks[i].call(cur, err, vm, info) === false;
-              if (capture) { return }
-            } catch (e) {
-              globalHandleError(e, cur, 'errorCaptured hook');
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
             }
-          }
         }
-      }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
     }
-    globalHandleError(err, vm, info);
-  } finally {
-    popTarget();
-  }
 }
-
-function invokeWithErrorHandling (
-  handler,
-  context,
-  args,
-  vm,
-  info
-) {
-  var res;
-  try {
-    res = args ? handler.apply(context, args) : handler.call(context);
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-      // issue #9511
-      // avoid catch triggering multiple times when nested calls
-      res._handled = true;
-    }
-  } catch (e) {
-    handleError(e, vm, info);
-  }
-  return res
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        // @ts-expect-error should it be any?
+        handleError(e, vm, info);
+    }
+    return res;
 }
-
-function globalHandleError (err, vm, info) {
-  logError(err, vm, info);
+function globalHandleError(err, vm, info) {
+    logError(err, vm, info);
 }
-
-function logError (err, vm, info) {
-  {
-    warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
-  }
-  /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-    console.error(err);
-  } else {
-    throw err
-  }
+function logError(err, vm, info) {
+    {
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/*  */
-
-var callbacks = [];
-
-function flushCallbacks () {
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+/* globals MutationObserver */
+const callbacks = [];
+function flushCallbacks() {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -2068,412 +1768,345 @@ function flushCallbacks () {
 // completely stops working after triggering a few times... so, if native
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/*  */
-
-/*  */
-
-function genClassForVnode (vnode) {
-  var data = vnode.data;
-  var parentNode = vnode;
-  var childNode = vnode;
-  while (isDef(childNode.componentInstance)) {
-    childNode = childNode.componentInstance._vnode;
-    if (childNode && childNode.data) {
-      data = mergeClassData(childNode.data, data);
-    }
-  }
-  while (isDef(parentNode = parentNode.parent)) {
-    if (parentNode && parentNode.data) {
-      data = mergeClassData(data, parentNode.data);
-    }
-  }
-  return renderClass(data.staticClass, data.class)
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve();
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
 }
-
-function mergeClassData (child, parent) {
-  return {
-    staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class)
-      ? [child.class, parent.class]
-      : parent.class
-  }
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+else ;
+
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass$1(data.staticClass, data.class);
 }
-
-function renderClass (
-  staticClass,
-  dynamicClass
-) {
-  if (isDef(staticClass) || isDef(dynamicClass)) {
-    return concat(staticClass, stringifyClass(dynamicClass))
-  }
-  /* istanbul ignore next */
-  return ''
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
 }
-
-function concat (a, b) {
-  return a ? b ? (a + ' ' + b) : a : (b || '')
+function renderClass$1(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyClass (value) {
-  if (Array.isArray(value)) {
-    return stringifyArray(value)
-  }
-  if (isObject(value)) {
-    return stringifyObject(value)
-  }
-  if (typeof value === 'string') {
-    return value
-  }
-  /* istanbul ignore next */
-  return ''
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
 }
-
-function stringifyArray (value) {
-  var res = '';
-  var stringified;
-  for (var i = 0, l = value.length; i < l; i++) {
-    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
-      if (res) { res += ' '; }
-      res += stringified;
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
     }
-  }
-  return res
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
 }
-
-function stringifyObject (value) {
-  var res = '';
-  for (var key in value) {
-    if (value[key]) {
-      if (res) { res += ' '; }
-      res += key;
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
     }
-  }
-  return res
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-/*  */
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
-var isPreTag = function (tag) { return tag === 'pre'; };
-
-var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
 }
+makeMap('text,number,password,search,email,tel,url');
 
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/*  */
-
-/*  */
-
-function renderClass$1 (node) {
-  var classList = genClassForVnode(node);
-  if (classList !== '') {
-    return (" class=\"" + (escape(classList)) + "\"")
-  }
+function renderClass(node) {
+    const classList = genClassForVnode(node);
+    if (classList !== '') {
+        return ` class="${escape(classList)}"`;
+    }
 }
 
-/*  */
-
-var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
-
 // merge static and dynamic style data on the same vnode
-function normalizeStyleData (data) {
-  var style = normalizeStyleBinding(data.style);
-  // static style is pre-processed into an object during compilation
-  // and is always a fresh object, so it's safe to merge into it
-  return data.staticStyle
-    ? extend(data.staticStyle, style)
-    : style
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
 }
-
 // normalize possible array / string values into Object
-function normalizeStyleBinding (bindingStyle) {
-  if (Array.isArray(bindingStyle)) {
-    return toObject(bindingStyle)
-  }
-  if (typeof bindingStyle === 'string') {
-    return parseStyleText(bindingStyle)
-  }
-  return bindingStyle
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
 }
-
 /**
  * parent component style should be after child's
  * so that parent component's style could override it
  */
-function getStyle (vnode, checkChild) {
-  var res = {};
-  var styleData;
-
-  if (checkChild) {
-    var childNode = vnode;
-    while (childNode.componentInstance) {
-      childNode = childNode.componentInstance._vnode;
-      if (
-        childNode && childNode.data &&
-        (styleData = normalizeStyleData(childNode.data))
-      ) {
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
         extend(res, styleData);
-      }
     }
-  }
-
-  if ((styleData = normalizeStyleData(vnode.data))) {
-    extend(res, styleData);
-  }
-
-  var parentNode = vnode;
-  while ((parentNode = parentNode.parent)) {
-    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-      extend(res, styleData);
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
     }
-  }
-  return res
+    return res;
 }
 
-/*  */
-
-function genStyle (style) {
-  var styleText = '';
-  for (var key in style) {
-    var value = style[key];
-    var hyphenatedKey = hyphenate(key);
-    if (Array.isArray(value)) {
-      for (var i = 0, len = value.length; i < len; i++) {
-        styleText += normalizeValue(hyphenatedKey, value[i]);
-      }
-    } else {
-      styleText += normalizeValue(hyphenatedKey, value);
+function genStyle(style) {
+    let styleText = '';
+    for (const key in style) {
+        const value = style[key];
+        const hyphenatedKey = hyphenate(key);
+        if (Array.isArray(value)) {
+            for (let i = 0, len = value.length; i < len; i++) {
+                styleText += normalizeValue(hyphenatedKey, value[i]);
+            }
+        }
+        else {
+            styleText += normalizeValue(hyphenatedKey, value);
+        }
     }
-  }
-  return styleText
+    return styleText;
 }
-
 function normalizeValue(key, value) {
-  if (
-    typeof value === 'string' ||
-    (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-    value === 0
-  ) {
-    return (key + ":" + value + ";")
-  } else {
-    // invalid values
-    return ""
-  }
+    if (typeof value === 'string' ||
+        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+        value === 0) {
+        return `${key}:${value};`;
+    }
+    else {
+        // invalid values
+        return ``;
+    }
 }
-
-function renderStyle (vnode) {
-  var styleText = genStyle(getStyle(vnode, false));
-  if (styleText !== '') {
-    return (" style=" + (JSON.stringify(escape(styleText))))
-  }
+function renderStyle(vnode) {
+    const styleText = genStyle(getStyle(vnode, false));
+    if (styleText !== '') {
+        return ` style=${JSON.stringify(escape(styleText))}`;
+    }
 }
 
-var modules = [
-  renderAttrs,
-  renderDOMProps,
-  renderClass$1,
-  renderStyle
-];
-
-/*  */
+var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-function show (node, dir) {
-  if (!dir.value) {
-    var style = node.data.style || (node.data.style = {});
-    if (Array.isArray(style)) {
-      style.push({ display: 'none' });
-    } else {
-      style.display = 'none';
+function show(node, dir) {
+    if (!dir.value) {
+        const style = node.data.style || (node.data.style = {});
+        if (Array.isArray(style)) {
+            style.push({ display: 'none' });
+        }
+        else {
+            style.display = 'none';
+        }
     }
-  }
 }
 
-/*  */
-
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
-function model (node, dir) {
-  if (!node.children) { return }
-  var value = dir.value;
-  var isMultiple = node.data.attrs && node.data.attrs.multiple;
-  for (var i = 0, l = node.children.length; i < l; i++) {
-    var option = node.children[i];
-    if (option.tag === 'option') {
-      if (isMultiple) {
-        var selected =
-          Array.isArray(value) &&
-          (looseIndexOf(value, getValue(option)) > -1);
-        if (selected) {
-          setSelected(option);
-        }
-      } else {
-        if (looseEqual(value, getValue(option))) {
-          setSelected(option);
-          return
-        }
-      }
-    }
-  }
+function model$2(node, dir) {
+    if (!node.children)
+        return;
+    const value = dir.value;
+    const isMultiple = node.data.attrs && node.data.attrs.multiple;
+    for (let i = 0, l = node.children.length; i < l; i++) {
+        const option = node.children[i];
+        if (option.tag === 'option') {
+            if (isMultiple) {
+                const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                if (selected) {
+                    setSelected(option);
+                }
+            }
+            else {
+                if (looseEqual(value, getValue(option))) {
+                    setSelected(option);
+                    return;
+                }
+            }
+        }
+    }
 }
-
-function getValue (option) {
-  var data = option.data || {};
-  return (
-    (data.attrs && data.attrs.value) ||
-    (data.domProps && data.domProps.value) ||
-    (option.children && option.children[0] && option.children[0].text)
-  )
+function getValue(option) {
+    const data = option.data || {};
+    return ((data.attrs && data.attrs.value) ||
+        (data.domProps && data.domProps.value) ||
+        (option.children && option.children[0] && option.children[0].text));
 }
-
-function setSelected (option) {
-  var data = option.data || (option.data = {});
-  var attrs = data.attrs || (data.attrs = {});
-  attrs.selected = '';
+function setSelected(option) {
+    const data = option.data || (option.data = {});
+    const attrs = data.attrs || (data.attrs = {});
+    attrs.selected = '';
 }
 
-var baseDirectives = {
-  show: show,
-  model: model
+var baseDirectives$1 = {
+    show,
+    model: model$2,
 };
 
-/*  */
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
-
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
-
-/*  */
-
-var MAX_STACK_DEPTH = 800;
-var noop$1 = function (_) { return _; };
-
-var defer = typeof process !== 'undefined' && process.nextTick
-  ? process.nextTick
-  : typeof Promise !== 'undefined'
-    ? function (fn) { return Promise.resolve().then(fn); }
-    : typeof setTimeout !== 'undefined'
-      ? setTimeout
-      : noop$1;
-
-if (defer === noop$1) {
-  throw new Error(
-    'Your JavaScript runtime does not support any asynchronous primitives ' +
-    'that are required by vue-server-renderer. Please use a polyfill for ' +
-    'either Promise or setTimeout.'
-  )
-}
-
-function createWriteFunction (
-  write,
-  onError
-) {
-  var stackDepth = 0;
-  var cachedWrite = function (text, next) {
-    if (text && cachedWrite.caching) {
-      cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-    }
-    var waitForNext = write(text, next);
-    if (waitForNext !== true) {
-      if (stackDepth >= MAX_STACK_DEPTH) {
-        defer(function () {
-          try { next(); } catch (e) {
-            onError(e);
-          }
-        });
-      } else {
-        stackDepth++;
-        next();
-        stackDepth--;
-      }
-    }
-  };
-  cachedWrite.caching = false;
-  cachedWrite.cacheBuffer = [];
-  cachedWrite.componentBuffer = [];
-  return cachedWrite
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
+
+const MAX_STACK_DEPTH = 800;
+const noop = (_) => _;
+const defer = typeof process !== 'undefined' && process.nextTick
+    ? process.nextTick
+    : typeof Promise !== 'undefined'
+        ? (fn) => Promise.resolve().then(fn)
+        : typeof setTimeout !== 'undefined'
+            ? setTimeout
+            : noop;
+if (defer === noop) {
+    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+        'that are required by vue-server-renderer. Please use a polyfill for ' +
+        'either Promise or setTimeout.');
+}
+function createWriteFunction(write, onError) {
+    let stackDepth = 0;
+    const cachedWrite = (text, next) => {
+        if (text && cachedWrite.caching) {
+            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+        }
+        const waitForNext = write(text, next);
+        if (waitForNext !== true) {
+            if (stackDepth >= MAX_STACK_DEPTH) {
+                defer(() => {
+                    try {
+                        next();
+                    }
+                    catch (e) {
+                        onError(e);
+                    }
+                });
+            }
+            else {
+                stackDepth++;
+                next();
+                stackDepth--;
+            }
+        }
+    };
+    cachedWrite.caching = false;
+    cachedWrite.cacheBuffer = [];
+    cachedWrite.componentBuffer = [];
+    return cachedWrite;
 }
 
-/*  */
-
 /**
  * Original RenderStream implementation by Sasha Aickin (@aickin)
  * Licensed under the Apache License, Version 2.0
@@ -2481,992 +2114,905 @@ function createWriteFunction (
  *
  * Modified by Evan You (@yyx990803)
  */
-
-var stream = require('stream');
-
-var RenderStream = /*@__PURE__*/(function (superclass) {
-  function RenderStream (render) {
-    var this$1 = this;
-
-    superclass.call(this);
-    this.buffer = '';
-    this.render = render;
-    this.expectedSize = 0;
-
-    this.write = createWriteFunction(function (text, next) {
-      var n = this$1.expectedSize;
-      this$1.buffer += text;
-      if (this$1.buffer.length >= n) {
-        this$1.next = next;
-        this$1.pushBySize(n);
-        return true // we will decide when to call next
-      }
-      return false
-    }, function (err) {
-      this$1.emit('error', err);
-    });
-
-    this.end = function () {
-      this$1.emit('beforeEnd');
-      // the rendering is finished; we should push out the last of the buffer.
-      this$1.done = true;
-      this$1.push(this$1.buffer);
-    };
-  }
-
-  if ( superclass ) RenderStream.__proto__ = superclass;
-  RenderStream.prototype = Object.create( superclass && superclass.prototype );
-  RenderStream.prototype.constructor = RenderStream;
-
-  RenderStream.prototype.pushBySize = function pushBySize (n) {
-    var bufferToPush = this.buffer.substring(0, n);
-    this.buffer = this.buffer.substring(n);
-    this.push(bufferToPush);
-  };
-
-  RenderStream.prototype.tryRender = function tryRender () {
-    try {
-      this.render(this.write, this.end);
-    } catch (e) {
-      this.emit('error', e);
+class RenderStream extends stream.Readable {
+    buffer;
+    render;
+    expectedSize;
+    write;
+    //@ts-expect-error
+    next;
+    end;
+    //@ts-expect-error
+    done;
+    constructor(render) {
+        super();
+        this.buffer = '';
+        //@ts-expect-error
+        this.render = render;
+        this.expectedSize = 0;
+        this.write = createWriteFunction((text, next) => {
+            const n = this.expectedSize;
+            this.buffer += text;
+            if (this.buffer.length >= n) {
+                this.next = next;
+                this.pushBySize(n);
+                return true; // we will decide when to call next
+            }
+            return false;
+        }, (err) => {
+            this.emit('error', err);
+        });
+        this.end = () => {
+            this.emit('beforeEnd');
+            // the rendering is finished; we should push out the last of the buffer.
+            this.done = true;
+            this.push(this.buffer);
+        };
     }
-  };
-
-  RenderStream.prototype.tryNext = function tryNext () {
-    try {
-      this.next();
-    } catch (e) {
-      this.emit('error', e);
+    pushBySize(n) {
+        const bufferToPush = this.buffer.substring(0, n);
+        this.buffer = this.buffer.substring(n);
+        this.push(bufferToPush);
+    }
+    tryRender() {
+        try {
+            this.render(this.write, this.end);
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    tryNext() {
+        try {
+            this.next();
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    _read(n) {
+        this.expectedSize = n;
+        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
+        // which means we will need to go through multiple read calls to drain it
+        // down to < n.
+        if (isTrue(this.done)) {
+            this.push(null);
+            return;
+        }
+        if (this.buffer.length >= n) {
+            this.pushBySize(n);
+            return;
+        }
+        if (isUndef(this.next)) {
+            // start the rendering chain.
+            this.tryRender();
+        }
+        else {
+            // continue with the rendering.
+            this.tryNext();
+        }
     }
-  };
-
-  RenderStream.prototype._read = function _read (n) {
-    this.expectedSize = n;
-    // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-    // which means we will need to go through multiple read calls to drain it
-    // down to < n.
-    if (isTrue(this.done)) {
-      this.push(null);
-      return
-    }
-    if (this.buffer.length >= n) {
-      this.pushBySize(n);
-      return
-    }
-    if (isUndef(this.next)) {
-      // start the rendering chain.
-      this.tryRender();
-    } else {
-      // continue with the rendering.
-      this.tryNext();
-    }
-  };
-
-  return RenderStream;
-}(stream.Readable));
-
-/*  */
-
-
-
-var RenderContext = function RenderContext (options) {
-  this.userContext = options.userContext;
-  this.activeInstance = options.activeInstance;
-  this.renderStates = [];
-
-  this.write = options.write;
-  this.done = options.done;
-  this.renderNode = options.renderNode;
-
-  this.isUnaryTag = options.isUnaryTag;
-  this.modules = options.modules;
-  this.directives = options.directives;
-
-  var cache = options.cache;
-  if (cache && (!cache.get || !cache.set)) {
-    throw new Error('renderer cache must implement at least get & set.')
-  }
-  this.cache = cache;
-  this.get = cache && normalizeAsync(cache, 'get');
-  this.has = cache && normalizeAsync(cache, 'has');
-
-  this.next = this.next.bind(this);
-};
-
-RenderContext.prototype.next = function next () {
-  // eslint-disable-next-line
-  while (true) {
-    var lastState = this.renderStates[this.renderStates.length - 1];
-    if (isUndef(lastState)) {
-      return this.done()
-    }
-    /* eslint-disable no-case-declarations */
-    switch (lastState.type) {
-      case 'Element':
-      case 'Fragment':
-        var children = lastState.children;
-      var total = lastState.total;
-        var rendered = lastState.rendered++;
-        if (rendered < total) {
-          return this.renderNode(children[rendered], false, this)
-        } else {
-          this.renderStates.pop();
-          if (lastState.type === 'Element') {
-            return this.write(lastState.endTag, this.next)
-          }
-        }
-        break
-      case 'Component':
-        this.renderStates.pop();
-        this.activeInstance = lastState.prevActive;
-        break
-      case 'ComponentWithCache':
-        this.renderStates.pop();
-        var buffer = lastState.buffer;
-      var bufferIndex = lastState.bufferIndex;
-      var componentBuffer = lastState.componentBuffer;
-      var key = lastState.key;
-        var result = {
-          html: buffer[bufferIndex],
-          components: componentBuffer[bufferIndex]
-        };
-        this.cache.set(key, result);
-        if (bufferIndex === 0) {
-          // this is a top-level cached component,
-          // exit caching mode.
-          this.write.caching = false;
-        } else {
-          // parent component is also being cached,
-          // merge self into parent's result
-          buffer[bufferIndex - 1] += result.html;
-          var prev = componentBuffer[bufferIndex - 1];
-          result.components.forEach(function (c) { return prev.add(c); });
-        }
-        buffer.length = bufferIndex;
-        componentBuffer.length = bufferIndex;
-        break
-    }
-  }
-};
-
-function normalizeAsync (cache, method) {
-  var fn = cache[method];
-  if (isUndef(fn)) {
-    return
-  } else if (fn.length > 1) {
-    return function (key, cb) { return fn.call(cache, key, cb); }
-  } else {
-    return function (key, cb) { return cb(fn.call(cache, key)); }
-  }
 }
 
-/*  */
-
-var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+class RenderContext {
+    userContext;
+    activeInstance;
+    renderStates;
+    write;
+    renderNode;
+    //@ts-expect-error
+    next;
+    done;
+    modules;
+    directives;
+    isUnaryTag;
+    cache;
+    get;
+    has;
+    constructor(options) {
+        this.userContext = options.userContext;
+        this.activeInstance = options.activeInstance;
+        this.renderStates = [];
+        this.write = options.write;
+        this.done = options.done;
+        this.renderNode = options.renderNode;
+        this.isUnaryTag = options.isUnaryTag;
+        this.modules = options.modules;
+        this.directives = options.directives;
+        const cache = options.cache;
+        if (cache && (!cache.get || !cache.set)) {
+            throw new Error('renderer cache must implement at least get & set.');
+        }
+        this.cache = cache;
+        this.get = cache && normalizeAsync(cache, 'get');
+        this.has = cache && normalizeAsync(cache, 'has');
+        //@ts-expect-error
+        this.next = this.next.bind(this);
+    }
+    //@ts-expect-error
+    next() {
+        // eslint-disable-next-line
+        while (true) {
+            const lastState = this.renderStates[this.renderStates.length - 1];
+            if (isUndef(lastState)) {
+                return this.done();
+            }
+            /* eslint-disable no-case-declarations */
+            switch (lastState.type) {
+                case 'Element':
+                case 'Fragment':
+                    const { children, total } = lastState;
+                    const rendered = lastState.rendered++;
+                    if (rendered < total) {
+                        return this.renderNode(children[rendered], false, this);
+                    }
+                    else {
+                        this.renderStates.pop();
+                        if (lastState.type === 'Element') {
+                            return this.write(lastState.endTag, this.next);
+                        }
+                    }
+                    break;
+                case 'Component':
+                    this.renderStates.pop();
+                    this.activeInstance = lastState.prevActive;
+                    break;
+                case 'ComponentWithCache':
+                    this.renderStates.pop();
+                    const { buffer, bufferIndex, componentBuffer, key } = lastState;
+                    const result = {
+                        html: buffer[bufferIndex],
+                        components: componentBuffer[bufferIndex],
+                    };
+                    this.cache.set(key, result);
+                    if (bufferIndex === 0) {
+                        // this is a top-level cached component,
+                        // exit caching mode.
+                        //@ts-expect-error
+                        this.write.caching = false;
+                    }
+                    else {
+                        // parent component is also being cached,
+                        // merge self into parent's result
+                        buffer[bufferIndex - 1] += result.html;
+                        const prev = componentBuffer[bufferIndex - 1];
+                        result.components.forEach((c) => prev.add(c));
+                    }
+                    buffer.length = bufferIndex;
+                    componentBuffer.length = bufferIndex;
+                    break;
+            }
+        }
+    }
+}
+function normalizeAsync(cache, method) {
+    const fn = cache[method];
+    if (isUndef(fn)) {
+        return;
+    }
+    else if (fn.length > 1) {
+        return (key, cb) => fn.call(cache, key, cb);
+    }
+    else {
+        return (key, cb) => cb(fn.call(cache, key));
+    }
+}
+
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
     }
-  }
-
-  return expression
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
 }
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-/*  */
-
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
-var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/*  */
-
-
-
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
 }
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
 }
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
-    }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
-    }
-  }
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
 }
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-    if (range.end != null) {
-      item.end = range.end;
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
     }
-  }
-  return item
+    return item;
 }
 
-/*  */
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  if (staticClass) {
-    var res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        "class=\"" + staticClass + "\": " +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
 }
-
-function genData (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
 }
-
 var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-/*  */
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    {
-      var res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          "style=\"" + staticStyle + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
     }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
 }
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:(" + (el.styleBinding) + "),";
-  }
-  return data
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
 }
-
 var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
-var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
-var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-var doctype = /^<!DOCTYPE [^>]+>/i;
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/;
-var conditionalComment = /^<!\[/;
-
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
 // Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true);
-var reCache = {};
-
-var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
             }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
         }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
         }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (!stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
     }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
     }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
     }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if ((i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
     }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (i > pos || !tagName &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
 }
 
-/*  */
-
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -3481,2918 +3027,2478 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
-var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.');
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-
-  str = val;
-  index = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function next () {
-  return str.charCodeAt(++index)
+function next() {
+    return str.charCodeAt(++index);
 }
-
-function eof () {
-  return index >= len
+function eof() {
+    return index >= len;
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index;
-      break
-    }
-  }
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
-var onRE = /^@|^v-on:/;
-var dirRE = /^v-|^@|^:|^#/;
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-var stripParensRE = /^\(|\)$/g;
-var dynamicArgRE = /^\[.*\]$/;
-
-var argRE = /:(.*)$/;
-var bindRE = /^:|^\.|^v-bind:/;
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
-var slotRE = /^v-slot(:|$)|^#/;
-
-var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /[ \f\t\r\n]+/g;
-
-var invalidAttributeRE = /[\s"'<>\/=]/;
-
-var decodeHTMLCached = cached(he.decode);
-
-var emptySlotScopeToken = "_empty_";
-
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he__default["default"].decode);
+const emptySlotScopeToken = `_empty_`;
 // configurable state
-var warn$1;
-var delimiters;
-var transforms;
-var preTransforms;
-var postTransforms;
-var platformIsPreTag;
-var platformMustUseProp;
-var platformGetTagNamespace;
-var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$1 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!(
-    el.component ||
-    el.attrsMap[':is'] ||
-    el.attrsMap['v-bind:is'] ||
-    !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
-  ); };
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$1(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
     }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
     }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
     }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
     }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$1,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$1(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        warn$1(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
-        if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        {
-          checkRootConstraints(root);
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
         {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
+            if (el.tag === 'template') {
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
         }
-        currentParent.children.push(child);
-      }
+        el.key = exp;
     }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    {
-      if (el.tag === 'template') {
-        warn$1(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$1(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
 }
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
 }
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else {
-      warn$1(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
     }
-  }
 }
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
 }
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
     }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else {
-    warn$1(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
 }
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (children[i].text !== ' ') {
-        warn$1(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
     }
-  }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
 }
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (slotScope) {
-      warn$1(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (el.attrsMap['v-for']) {
-      warn$1(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    let slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        {
-          if (el.slotTarget || el.slotScope) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$1(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
-        }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        {
-          if (!maybeComponent(el)) {
-            warn$1(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$1(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
     }
-  }
 }
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else {
-      warn$1(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (el.key) {
-      warn$1(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
     }
-  }
-}
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
 }
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          value.trim().length === 0
-        ) {
-          warn$1(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i],
-                true // dynamic
-              );
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn$1(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
 }
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
     }
-    parent = parent.parent;
-  }
-  return false
+    return false;
 }
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-    }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
 }
-
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
-var ieNSBug = /^xmlns:NS\d+/;
-var ieNSPrefix = /^NS\d+:/;
-
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
     }
-  }
-  return res
 }
 
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
+var model$1 = {
+    preTransformNode,
+};
 
-/*  */
+var modules = [klass, style, model$1];
 
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap;
-    if (!map['v-model']) {
-      return
+let warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
     }
-
-    var typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
     }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = "(" + (map['v-bind']) + ").type";
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
     }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
+}
 
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      var branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      var branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
     }
-  }
 }
 
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var model$1 = {
-  preTransformNode: preTransformNode
+var directives = {
+    model,
+    text,
+    html,
 };
 
-var modules$1 = [
-  klass,
-  style,
-  model$1
-];
-
-/*  */
-
-var warn$2;
-
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
-
-function model$2 (
-  el,
-  dir,
-  _warn
-) {
-  warn$2 = _warn;
-  var value = dir.value;
-  var modifiers = dir.modifiers;
-  var tag = el.tag;
-  var type = el.attrsMap.type;
-
-  {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$2(
-        "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-        "File inputs are read only. Use a v-on:change listener instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    "Array.isArray(" + value + ")" +
-    "?_i(" + value + "," + valueBinding + ")>-1" + (
-      trueValueBinding === 'true'
-        ? (":(" + value + ")")
-        : (":_q(" + value + "," + trueValueBinding + ")")
-    )
-  );
-  addHandler(el, 'change',
-    "var $$a=" + value + "," +
-        '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-    'if(Array.isArray($$a)){' +
-      "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-      "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-      "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-    "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-  addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var selectedVal = "Array.prototype.filter" +
-    ".call($event.target.options,function(o){return o.selected})" +
-    ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-    "return " + (number ? '_n(val)' : 'val') + "})";
-
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  var code = "var $$selectedVal = " + selectedVal + ";";
-  code = code + " " + (genAssignmentCode(value, assignment));
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  {
-    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value$1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$2(
-        binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var number = ref.number;
-  var trim = ref.trim;
-  var needCompositionGuard = !lazy && type !== 'range';
-  var event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  var valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = "$event.target.value.trim()";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = "if($event.target.composing)return;" + code;
-  }
-
-  addProp(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
-}
-
-/*  */
-
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-  }
-}
-
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-  }
-}
-
-var directives = {
-  model: model$2,
-  text: text,
-  html: html
-};
-
-/*  */
-
-var baseOptions = {
-  expectHTML: true,
-  modules: modules$1,
-  directives: directives,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys(modules$1)
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys(modules),
 };
 
-/*  */
-
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-var fnInvokeRE = /\([^)]*?\);*$/;
-var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
 // KeyboardEvent.keyCode aliases
-var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
-var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
-var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
 }
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys);
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
-    }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + ".apply(null, arguments)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ").apply(null, arguments)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    return ("function($event){" + code + handlerCode + "}")
-  }
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-/*  */
-
-function on (el, dir) {
-  if (dir.modifiers) {
-    warn("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-/*  */
-
-var baseDirectives$1 = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
-};
-
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives$1), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop$1,
 };
 
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  // fix #11483, Root level <script> tags should not be rendered.
-  var code = ast ? (ast.tag === 'script' ? 'null' : genElement(ast, state)) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate$1(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData$2 (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
 }
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (el.children.length !== 1 || ast.type !== 1) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if ((el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate$1(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
 }
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
-    }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
 }
-
 function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
-}
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
     }
-    return el.children.some(containsSlotChild)
-  }
-  return false
+    return hash >>> 0;
 }
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-}
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
 }
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
 }
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
 }
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
 }
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
 }
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? (",function(){return " + children + "}") : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
-
-var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
+const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
 // let the model AST transform translate v-model into appropriate
 // props bindings
-function applyModelTransform (el, state) {
-  if (el.directives) {
-    for (var i = 0; i < el.directives.length; i++) {
-      var dir = el.directives[i];
-      if (dir.name === 'model') {
-        state.directives.model(el, dir, state.warn);
-        // remove value for textarea as its converted to text
-        if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (let i = 0; i < el.directives.length; i++) {
+            const dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter((p) => p.name !== 'value');
+                }
+                break;
+            }
         }
-        break
-      }
     }
-  }
 }
-
-function genAttrSegments (
-  attrs
-) {
-  return attrs.map(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    return genAttrSegment(name, value);
-  })
+function genAttrSegments(attrs) {
+    return attrs.map(({ name, value }) => genAttrSegment(name, value));
 }
-
-function genDOMPropSegments (
-  props,
-  attrs
-) {
-  var segments = [];
-  props.forEach(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    name = propsToAttrMap[name] || name.toLowerCase();
-    if (isRenderableAttr(name) &&
-      !(attrs && attrs.some(function (a) { return a.name === name; }))
-    ) {
-      segments.push(genAttrSegment(name, value));
+function genDOMPropSegments(props, attrs) {
+    const segments = [];
+    props.forEach(({ name, value }) => {
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some((a) => a.name === name))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== `"false"`) {
+            value = `"true"`;
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? ` ${name}="${name}"`
+                : value === '""'
+                    ? ` ${name}`
+                    : ` ${name}="${JSON.parse(value)}"`,
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+        };
     }
-  });
-  return segments
 }
-
-function genAttrSegment (name, value) {
-  if (plainStringRE.test(value)) {
-    // force double quote
-    value = value.replace(/^'|'$/g, '"');
-    // force enumerated attr to "true"
-    if (isEnumeratedAttr(name) && value !== "\"false\"") {
-      value = "\"true\"";
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
     }
-    return {
-      type: RAW,
-      value: isBooleanAttr(name)
-        ? (" " + name + "=\"" + name + "\"")
-        : value === '""'
-          ? (" " + name)
-          : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-    }
-  } else {
-    return {
-      type: EXPRESSION,
-      value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+            },
+        ];
     }
-  }
-}
-
-function genClassSegments (
-  staticClass,
-  classBinding
-) {
-  if (staticClass && !classBinding) {
-    return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-    }]
-  }
 }
-
-function genStyleSegments (
-  staticStyle,
-  parsedStaticStyle,
-  styleBinding,
-  vShowExpression
-) {
-  if (staticStyle && !styleBinding && !vShowExpression) {
-    return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-          ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-          : 'null') + ")")
-    }]
-  }
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+            },
+        ];
+    }
 }
 
-/*  */
-
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
 // optimizability constants
-var optimizability = {
-  FALSE: 0,    // whole sub tree un-optimizable
-  FULL: 1,     // whole sub tree optimizable
-  SELF: 2,     // self optimizable but has some un-optimizable children
-  CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4   // self un-optimizable with some un-optimizable children
+const optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
 };
-
-var isPlatformReservedTag;
-
-function optimize (root, options) {
-  if (!root) { return }
-  isPlatformReservedTag = options.isReservedTag || no;
-  walk(root, true);
-}
-
-function walk (node, isRoot) {
-  if (isUnOptimizableTree(node)) {
-    node.ssrOptimizability = optimizability.FALSE;
-    return
-  }
-  // root node or nodes with custom directives should always be a VNode
-  var selfUnoptimizable = isRoot || hasCustomDirective(node);
-  var check = function (child) {
-    if (child.ssrOptimizability !== optimizability.FULL) {
-      node.ssrOptimizability = selfUnoptimizable
-        ? optimizability.PARTIAL
-        : optimizability.SELF;
-    }
-  };
-  if (selfUnoptimizable) {
-    node.ssrOptimizability = optimizability.CHILDREN;
-  }
-  if (node.type === 1) {
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      walk(child);
-      check(child);
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        walk(block, isRoot);
-        check(block);
-      }
-    }
-    if (node.ssrOptimizability == null ||
-      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-    ) {
-      node.ssrOptimizability = optimizability.FULL;
-    } else {
-      node.children = optimizeSiblings(node);
-    }
-  } else {
-    node.ssrOptimizability = optimizability.FULL;
-  }
-}
-
-function optimizeSiblings (el) {
-  var children = el.children;
-  var optimizedChildren = [];
-
-  var currentOptimizableGroup = [];
-  var pushGroup = function () {
-    if (currentOptimizableGroup.length) {
-      optimizedChildren.push({
-        type: 1,
-        parent: el,
-        tag: 'template',
-        attrsList: [],
-        attrsMap: {},
-        rawAttrsMap: {},
-        children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
-      });
+let isPlatformReservedTag;
+function optimize(root, options) {
+    if (!root)
+        return;
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+    const check = (child) => {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
     }
-    currentOptimizableGroup = [];
-  };
-
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.ssrOptimizability === optimizability.FULL) {
-      currentOptimizableGroup.push(c);
-    } else {
-      // wrap fully-optimizable adjacent siblings inside a template tag
-      // so that they can be optimized into a single ssrNode by codegen
-      pushGroup();
-      optimizedChildren.push(c);
-    }
-  }
-  pushGroup();
-  return optimizedChildren
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    const children = el.children;
+    const optimizedChildren = [];
+    let currentOptimizableGroup = [];
+    const pushGroup = () => {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
 }
-
-function isUnOptimizableTree (node) {
-  if (node.type === 2 || node.type === 3) { // text or expression
-    return false
-  }
-  return (
-    isBuiltInTag(node.tag) || // built-in (slot, component)
-    !isPlatformReservedTag(node.tag) || // custom component
-    !!node.component || // "is" component
-    isSelectWithModel(node) // <select v-model> requires runtime inspection
-  )
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
 }
-
-var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-function hasCustomDirective (node) {
-  return (
-    node.type === 1 &&
-    node.directives &&
-    node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-  )
+const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some((d) => !isBuiltInDir(d.name)));
 }
-
 // <select v-model> cannot be optimized because it requires a runtime check
 // to determine proper selected option
-function isSelectWithModel (node) {
-  return (
-    node.type === 1 &&
-    node.tag === 'select' &&
-    node.directives != null &&
-    node.directives.some(function (d) { return d.name === 'model'; })
-  )
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some((d) => d.name === 'model'));
 }
 
-/*  */
-
-
-
-
+// The SSR codegen is essentially extending the default codegen to handle
 // segment types
-var RAW = 0;
-var INTERPOLATION = 1;
-var EXPRESSION = 2;
-
-function generate$1 (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genSSRElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genSSRElement (el, state) {
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genSSRElement)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state, genSSRElement)
-  } else if (el.tag === 'template' && !el.slotTarget) {
-    return el.ssrOptimizability === optimizability.FULL
-      ? genChildrenAsStringNode(el, state)
-      : genSSRChildren(el, state) || 'void 0'
-  }
-
-  switch (el.ssrOptimizability) {
-    case optimizability.FULL:
-      // stringify whole tree
-      return genStringElement(el, state)
-    case optimizability.SELF:
-      // stringify self and check children
-      return genStringElementWithChildren(el, state)
-    case optimizability.CHILDREN:
-      // generate self as VNode and stringify children
-      return genNormalElement(el, state, true)
-    case optimizability.PARTIAL:
-      // generate self as VNode and check children
-      return genNormalElement(el, state, false)
-    default:
-      // bail whole tree
-      return genElement(el, state)
-  }
-}
-
-function genNormalElement (el, state, stringifyChildren) {
-  var data = el.plain ? undefined : genData$2(el, state);
-  var children = stringifyChildren
-    ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-    : genSSRChildren(el, state, true);
-  return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-}
-
-function genSSRChildren (el, state, checkSkip) {
-  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-}
-
-function genSSRNode (el, state) {
-  return el.type === 1
-    ? genSSRElement(el, state)
-    : genText(el)
-}
-
-function genChildrenAsStringNode (el, state) {
-  return el.children.length
-    ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-    : ''
-}
-
-function genStringElement (el, state) {
-  return ("_ssrNode(" + (elementToString(el, state)) + ")")
-}
-
-function genStringElementWithChildren (el, state) {
-  var children = genSSRChildren(el, state, true);
-  return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-}
-
-function elementToString (el, state) {
-  return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-}
-
-function elementToSegments (el, state) {
-  // v-for / v-if
-  if (el.for && !el.forProcessed) {
-    el.forProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genFor(el, state, elementToString, '_ssrList')
-    }]
-  } else if (el.if && !el.ifProcessed) {
-    el.ifProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genIf(el, state, elementToString, '"<!---->"')
-    }]
-  } else if (el.tag === 'template') {
-    return childrenToSegments(el, state)
-  }
-
-  var openSegments = elementToOpenTagSegments(el, state);
-  var childrenSegments = childrenToSegments(el, state);
-  var ref = state.options;
-  var isUnaryTag = ref.isUnaryTag;
-  var close = (isUnaryTag && isUnaryTag(el.tag))
-    ? []
-    : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-  return openSegments.concat(childrenSegments, close)
-}
-
-function elementToOpenTagSegments (el, state) {
-  applyModelTransform(el, state);
-  var binding;
-  var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-  // attrs
-  if (el.attrs) {
-    segments.push.apply(segments, genAttrSegments(el.attrs));
-  }
-  // domProps
-  if (el.props) {
-    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-  }
-  // v-bind="object"
-  if ((binding = el.attrsMap['v-bind'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-  }
-  // v-bind.prop="object"
-  if ((binding = el.attrsMap['v-bind.prop'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-  }
-  // class
-  if (el.staticClass || el.classBinding) {
-    segments.push.apply(
-      segments,
-      genClassSegments(el.staticClass, el.classBinding)
-    );
-  }
-  // style & v-show
-  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-    segments.push.apply(
-      segments,
-      genStyleSegments(
-        el.attrsMap.style,
-        el.staticStyle,
-        el.styleBinding,
-        el.attrsMap['v-show']
-      )
-    );
-  }
-  // _scopedId
-  if (state.options.scopeId) {
-    segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-  }
-  segments.push({ type: RAW, value: ">" });
-  return segments
-}
-
-function childrenToSegments (el, state) {
-  var binding;
-  if ((binding = el.attrsMap['v-html'])) {
-    return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-  }
-  if ((binding = el.attrsMap['v-text'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  return el.children
-    ? nodesToSegments(el.children, state)
-    : []
+const RAW = 0;
+const INTERPOLATION = 1;
+const EXPRESSION = 2;
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function nodesToSegments (
-  children,
-  state
-) {
-  var segments = [];
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.type === 1) {
-      segments.push.apply(segments, elementToSegments(c, state));
-    } else if (c.type === 2) {
-      segments.push({ type: INTERPOLATION, value: c.expression });
-    } else if (c.type === 3) {
-      var text = escape(c.text);
-      if (c.isComment) {
-        text = '<!--' + text + '-->';
-      }
-      segments.push({ type: RAW, value: text });
-    }
-  }
-  return segments
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    const data = el.plain ? undefined : genData(el, state);
+    const children = stringifyChildren
+        ? `[${genChildrenAsStringNode(el, state)}]`
+        : genSSRChildren(el, state, true);
+    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+        : '';
+}
+function genStringElement(el, state) {
+    return `_ssrNode(${elementToString(el, state)})`;
+}
+function genStringElementWithChildren(el, state) {
+    const children = genSSRChildren(el, state, true);
+    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+}
+function elementToString(el, state) {
+    return `(${flattenSegments(elementToSegments(el, state))})`;
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            },
+        ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            },
+        ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    const openSegments = elementToOpenTagSegments(el, state);
+    const childrenSegments = childrenToSegments(el, state);
+    const { isUnaryTag } = state.options;
+    const close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: `</${el.tag}>` }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    let binding;
+    const segments = [{ type: RAW, value: `<${el.tag}` }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+    }
+    segments.push({ type: RAW, value: `>` });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    let binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    const segments = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            let text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
 }
-
-function flattenSegments (segments) {
-  var mergedSegments = [];
-  var textBuffer = '';
-
-  var pushBuffer = function () {
-    if (textBuffer) {
-      mergedSegments.push(JSON.stringify(textBuffer));
-      textBuffer = '';
+function flattenSegments(segments) {
+    const mergedSegments = [];
+    let textBuffer = '';
+    const pushBuffer = () => {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(`_ssrEscape(${s.value})`);
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(`(${s.value})`);
+        }
     }
-  };
-
-  for (var i = 0; i < segments.length; i++) {
-    var s = segments[i];
-    if (s.type === RAW) {
-      textBuffer += s.value;
-    } else if (s.type === INTERPOLATION) {
-      pushBuffer();
-      mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-    } else if (s.type === EXPRESSION) {
-      pushBuffer();
-      mergedSegments.push(("(" + (s.value) + ")"));
-    }
-  }
-  pushBuffer();
-
-  return mergedSegments.join('+')
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-/*  */
-
-
-
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
-var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkEvent (exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
     }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
-}
-
-/*  */
-
-var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
 }
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
-    }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-        }
-      }
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
+}
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
     }
-
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
     }
-
-    return (cache[key] = res)
-  }
+    return result;
 }
 
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
-            }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
+    catch (err) {
+        errors.push({ err, code });
+        return noop$1;
     }
-  }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  optimize(ast, options);
-  var code = generate$1(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    optimize(ast, options);
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
-var ref = createCompiler(baseOptions);
-var compile = ref.compile;
-var compileToFunctions = ref.compileToFunctions;
-
-/*  */
+const { compile: compile$1, compileToFunctions } = createCompiler(baseOptions);
 
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
@@ -6400,1372 +5506,1048 @@ var compileToFunctions = ref.compileToFunctions;
 // For plain HTML markup, normalization can be completely skipped because the
 // generated render function is guaranteed to return Array<VNode>. There are
 // two cases where extra normalization is needed:
-
 // 1. When the children contains components - because a functional component
 // may return an Array instead of a single root. In this case, just a simple
 // normalization is needed - if any child is an Array, we flatten the whole
 // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
 // because functional components already normalize their own children.
-function simpleNormalizeChildren (children) {
-  for (var i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
-      return Array.prototype.concat.apply([], children)
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
     }
-  }
-  return children
+    return children;
 }
-
 // 2. When the children contains constructs that always generated nested Arrays,
 // e.g. <template>, <slot>, v-for, or when the children is provided by user
 // with hand-written render functions / JSX. In such cases a full normalization
 // is needed to cater to all possible types of children values.
-function normalizeChildren (children) {
-  return isPrimitive(children)
-    ? [createTextVNode(children)]
-    : Array.isArray(children)
-      ? normalizeArrayChildren(children)
-      : undefined
-}
-
-function isTextNode (node) {
-  return isDef(node) && isDef(node.text) && isFalse(node.isComment)
-}
-
-function normalizeArrayChildren (children, nestedIndex) {
-  var res = [];
-  var i, c, lastIndex, last;
-  for (i = 0; i < children.length; i++) {
-    c = children[i];
-    if (isUndef(c) || typeof c === 'boolean') { continue }
-    lastIndex = res.length - 1;
-    last = res[lastIndex];
-    //  nested
-    if (Array.isArray(c)) {
-      if (c.length > 0) {
-        c = normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i));
-        // merge adjacent text nodes
-        if (isTextNode(c[0]) && isTextNode(last)) {
-          res[lastIndex] = createTextVNode(last.text + (c[0]).text);
-          c.shift();
-        }
-        res.push.apply(res, c);
-      }
-    } else if (isPrimitive(c)) {
-      if (isTextNode(last)) {
-        // merge adjacent text nodes
-        // this is necessary for SSR hydration because text nodes are
-        // essentially merged when rendered to HTML strings
-        res[lastIndex] = createTextVNode(last.text + c);
-      } else if (c !== '') {
-        // convert primitive to vnode
-        res.push(createTextVNode(c));
-      }
-    } else {
-      if (isTextNode(c) && isTextNode(last)) {
-        // merge adjacent text nodes
-        res[lastIndex] = createTextVNode(last.text + c.text);
-      } else {
-        // default key for nested array children (likely generated by v-for)
-        if (isTrue(children._isVList) &&
-          isDef(c.tag) &&
-          isUndef(c.key) &&
-          isDef(nestedIndex)) {
-          c.key = "__vlist" + nestedIndex + "_" + i + "__";
-        }
-        res.push(c);
-      }
-    }
-  }
-  return res
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-/*  */
-
-var ssrHelpers = {
-  _ssrEscape: escape,
-  _ssrNode: renderStringNode,
-  _ssrList: renderStringList,
-  _ssrAttr: renderAttr,
-  _ssrAttrs: renderAttrs$1,
-  _ssrDOMProps: renderDOMProps$1,
-  _ssrClass: renderSSRClass,
-  _ssrStyle: renderSSRStyle
+const ssrHelpers = {
+    _ssrEscape: escape,
+    _ssrNode: renderStringNode$1,
+    _ssrList: renderStringList,
+    _ssrAttr: renderAttr,
+    _ssrAttrs: renderAttrs,
+    _ssrDOMProps: renderDOMProps,
+    _ssrClass: renderSSRClass,
+    _ssrStyle: renderSSRStyle,
 };
-
-function installSSRHelpers (vm) {
-  if (vm._ssrNode) {
-    return
-  }
-  var Vue = vm.constructor;
-  while (Vue.super) {
-    Vue = Vue.super;
-  }
-  extend(Vue.prototype, ssrHelpers);
-  if (Vue.FunctionalRenderContext) {
-    extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-  }
+function installSSRHelpers(vm) {
+    if (vm._ssrNode) {
+        return;
+    }
+    let Vue = vm.constructor;
+    // @ts-expect-error
+    while (Vue.super) {
+        // @ts-expect-error
+        Vue = Vue.super;
+    }
+    extend(Vue.prototype, ssrHelpers);
+    // @ts-expect-error
+    if (Vue.FunctionalRenderContext) {
+        // @ts-expect-error
+        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+    }
+}
+class StringNode {
+    isString;
+    open;
+    close;
+    children;
+    constructor(open, close, children, normalizationType) {
+        this.isString = true;
+        this.open = open;
+        this.close = close;
+        if (children) {
+            this.children =
+                normalizationType === 1
+                    ? simpleNormalizeChildren(children)
+                    : normalizationType === 2
+                        ? normalizeChildren(children)
+                        : children;
+        }
+        else {
+            this.children = void 0;
+        }
+    }
 }
-
-var StringNode = function StringNode (
-  open,
-  close,
-  children,
-  normalizationType
-) {
-  this.isString = true;
-  this.open = open;
-  this.close = close;
-  if (children) {
-    this.children = normalizationType === 1
-      ? simpleNormalizeChildren(children)
-      : normalizationType === 2
-        ? normalizeChildren(children)
-        : children;
-  } else {
-    this.children = void 0;
-  }
-};
-
-function renderStringNode (
-  open,
-  close,
-  children,
-  normalizationType
-) {
-  return new StringNode(open, close, children, normalizationType)
+function renderStringNode$1(open, close, children, normalizationType) {
+    return new StringNode(open, close, children, normalizationType);
 }
-
-function renderStringList (
-  val,
-  render
-) {
-  var ret = '';
-  var i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    for (i = 0, l = val.length; i < l; i++) {
-      ret += render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    for (i = 0; i < val; i++) {
-      ret += render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    keys = Object.keys(val);
-    for (i = 0, l = keys.length; i < l; i++) {
-      key = keys[i];
-      ret += render(val[key], key, i);
-    }
-  }
-  return ret
+function renderStringList(val, render) {
+    let ret = '';
+    let i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        for (i = 0, l = val.length; i < l; i++) {
+            ret += render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        for (i = 0; i < val; i++) {
+            ret += render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        keys = Object.keys(val);
+        for (i = 0, l = keys.length; i < l; i++) {
+            key = keys[i];
+            ret += render(val[key], key, i);
+        }
+    }
+    return ret;
 }
-
-function renderAttrs$1 (obj) {
-  var res = '';
-  for (var key in obj) {
-    if (isSSRUnsafeAttr(key)) {
-      continue
+function renderAttrs(obj) {
+    let res = '';
+    for (const key in obj) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        res += renderAttr(key, obj[key]);
     }
-    res += renderAttr(key, obj[key]);
-  }
-  return res
+    return res;
 }
-
-function renderDOMProps$1 (obj) {
-  var res = '';
-  for (var key in obj) {
-    var attr = propsToAttrMap[key] || key.toLowerCase();
-    if (isRenderableAttr(attr)) {
-      res += renderAttr(attr, obj[key]);
+function renderDOMProps(obj) {
+    let res = '';
+    for (const key in obj) {
+        const attr = propsToAttrMap[key] || key.toLowerCase();
+        if (isRenderableAttr(attr)) {
+            res += renderAttr(attr, obj[key]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
-function renderSSRClass (
-  staticClass,
-  dynamic
-) {
-  var res = renderClass(staticClass, dynamic);
-  return res === '' ? res : (" class=\"" + (escape(res)) + "\"")
+function renderSSRClass(staticClass, dynamic) {
+    const res = renderClass$1(staticClass, dynamic);
+    return res === '' ? res : ` class="${escape(res)}"`;
 }
-
-function renderSSRStyle (
-  staticStyle,
-  dynamic,
-  extra
-) {
-  var style = {};
-  if (staticStyle) { extend(style, staticStyle); }
-  if (dynamic) { extend(style, normalizeStyleBinding(dynamic)); }
-  if (extra) { extend(style, extra); }
-  var res = genStyle(style);
-  return res === '' ? res : (" style=" + (JSON.stringify(escape(res))))
+function renderSSRStyle(staticStyle, dynamic, extra) {
+    const style = {};
+    if (staticStyle)
+        extend(style, staticStyle);
+    if (dynamic)
+        extend(style, normalizeStyleBinding(dynamic));
+    if (extra)
+        extend(style, extra);
+    const res = genStyle(style);
+    return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
 }
 
 /* not type checking this file because flow doesn't play well with Proxy */
-
 {
-  var allowedGlobals = makeMap(
-    'Infinity,undefined,NaN,isFinite,isNaN,' +
-    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-    'require' // for Webpack/Browserify
-  );
-
-  var hasProxy =
-    typeof Proxy !== 'undefined' && isNative(Proxy);
-
-  if (hasProxy) {
-    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-    config.keyCodes = new Proxy(config.keyCodes, {
-      set: function set (target, key, value) {
-        if (isBuiltInModifier(key)) {
-          warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
-          return false
-        } else {
-          target[key] = value;
-          return true
-        }
-      }
-    });
-  }
+    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
 }
 
-/*  */
-
-var seenObjects = new _Set();
-
+const seenObjects = new _Set();
 /**
  * Recursively traverse an object to evoke all converted
  * getters, so that every nested property inside the object
  * is collected as a "deep" dependency.
  */
-function traverse (val) {
-  _traverse(val, seenObjects);
-  seenObjects.clear();
-}
-
-function _traverse (val, seen) {
-  var i, keys;
-  var isA = Array.isArray(val);
-  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
-    return
-  }
-  if (val.__ob__) {
-    var depId = val.__ob__.dep.id;
-    if (seen.has(depId)) {
-      return
-    }
-    seen.add(depId);
-  }
-  if (isA) {
-    i = val.length;
-    while (i--) { _traverse(val[i], seen); }
-  } else {
-    keys = Object.keys(val);
-    i = keys.length;
-    while (i--) { _traverse(val[keys[i]], seen); }
-  }
-}
-
-{
-  var perf = inBrowser && window.performance;
-  /* istanbul ignore if */
-  if (
-    perf &&
-    perf.mark &&
-    perf.measure &&
-    perf.clearMarks &&
-    perf.clearMeasures
-  ) ;
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-/*  */
-
-var normalizeEvent = cached(function (name) {
-  var passive = name.charAt(0) === '&';
-  name = passive ? name.slice(1) : name;
-  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
-  name = once$$1 ? name.slice(1) : name;
-  var capture = name.charAt(0) === '!';
-  name = capture ? name.slice(1) : name;
-  return {
-    name: name,
-    once: once$$1,
-    capture: capture,
-    passive: passive
-  }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
 });
-
-function createFnInvoker (fns, vm) {
-  function invoker () {
-    var arguments$1 = arguments;
-
-    var fns = invoker.fns;
-    if (Array.isArray(fns)) {
-      var cloned = fns.slice();
-      for (var i = 0; i < cloned.length; i++) {
-        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-      }
-    } else {
-      // return handler return value for single handlers
-      return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler")
-    }
-  }
-  invoker.fns = fns;
-  return invoker
-}
-
-function updateListeners (
-  on,
-  oldOn,
-  add,
-  remove$$1,
-  createOnceHandler,
-  vm
-) {
-  var name, def$$1, cur, old, event;
-  for (name in on) {
-    def$$1 = cur = on[name];
-    old = oldOn[name];
-    event = normalizeEvent(name);
-    if (isUndef(cur)) {
-      warn(
-        "Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
-        vm
-      );
-    } else if (isUndef(old)) {
-      if (isUndef(cur.fns)) {
-        cur = on[name] = createFnInvoker(cur, vm);
-      }
-      if (isTrue(event.once)) {
-        cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-      }
-      add(event.name, cur, event.capture, event.passive, event.params);
-    } else if (cur !== old) {
-      old.fns = cur;
-      on[name] = old;
-    }
-  }
-  for (name in oldOn) {
-    if (isUndef(on[name])) {
-      event = normalizeEvent(name);
-      remove$$1(event.name, oldOn[name], event.capture);
-    }
-  }
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-/*  */
-
-/*  */
-
-function extractPropsFromVNodeData (
-  data,
-  Ctor,
-  tag
-) {
-  // we are only extracting raw values here.
-  // validation and default values are handled in the child
-  // component itself.
-  var propOptions = Ctor.options.props;
-  if (isUndef(propOptions)) {
-    return
-  }
-  var res = {};
-  var attrs = data.attrs;
-  var props = data.props;
-  if (isDef(attrs) || isDef(props)) {
-    for (var key in propOptions) {
-      var altKey = hyphenate(key);
-      {
-        var keyInLowerCase = key.toLowerCase();
-        if (
-          key !== keyInLowerCase &&
-          attrs && hasOwn(attrs, keyInLowerCase)
-        ) {
-          tip(
-            "Prop \"" + keyInLowerCase + "\" is passed to component " +
-            (formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
-            " \"" + key + "\". " +
-            "Note that HTML attributes are case-insensitive and camelCased " +
-            "props need to use their kebab-case equivalents when using in-DOM " +
-            "templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
-          );
-        }
-      }
-      checkProp(res, props, key, altKey, true) ||
-      checkProp(res, attrs, key, altKey, false);
-    }
-  }
-  return res
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
 }
-
-function checkProp (
-  res,
-  hash,
-  key,
-  altKey,
-  preserve
-) {
-  if (isDef(hash)) {
-    if (hasOwn(hash, key)) {
-      res[key] = hash[key];
-      if (!preserve) {
-        delete hash[key];
-      }
-      return true
-    } else if (hasOwn(hash, altKey)) {
-      res[key] = hash[altKey];
-      if (!preserve) {
-        delete hash[altKey];
-      }
-      return true
-    }
-  }
-  return false
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-/*  */
-
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
-
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
 // wrapper function for providing a more flexible interface
 // without getting yelled at by flow
-function createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType,
-  alwaysNormalize
-) {
-  if (Array.isArray(data) || isPrimitive(data)) {
-    normalizationType = children;
-    children = data;
-    data = undefined;
-  }
-  if (isTrue(alwaysNormalize)) {
-    normalizationType = ALWAYS_NORMALIZE;
-  }
-  return _createElement(context, tag, data, children, normalizationType)
-}
-
-function _createElement (
-  context,
-  tag,
-  data,
-  children,
-  normalizationType
-) {
-  if (isDef(data) && isDef((data).__ob__)) {
-    warn(
-      "Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
-      'Always create fresh vnode data objects in each render!',
-      context
-    );
-    return createEmptyVNode()
-  }
-  // object syntax in v-bind
-  if (isDef(data) && isDef(data.is)) {
-    tag = data.is;
-  }
-  if (!tag) {
-    // in case of component :is set to falsy value
-    return createEmptyVNode()
-  }
-  // warn against non-primitive key
-  if (isDef(data) && isDef(data.key) && !isPrimitive(data.key)
-  ) {
-    {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-        'use string/number value instead.',
-        context
-      );
-    }
-  }
-  // support single function children as default scoped slot
-  if (Array.isArray(children) &&
-    typeof children[0] === 'function'
-  ) {
-    data = data || {};
-    data.scopedSlots = { default: children[0] };
-    children.length = 0;
-  }
-  if (normalizationType === ALWAYS_NORMALIZE) {
-    children = normalizeChildren(children);
-  } else if (normalizationType === SIMPLE_NORMALIZE) {
-    children = simpleNormalizeChildren(children);
-  }
-  var vnode, ns;
-  if (typeof tag === 'string') {
-    var Ctor;
-    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-    if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
-      // component
-      vnode = createComponent(Ctor, data, context, children, tag);
-    } else {
-      // unknown or unlisted namespaced elements
-      // check at runtime because it may get assigned a namespace when its
-      // parent normalizes children
-      vnode = new VNode(
-        tag, data, children,
-        undefined, undefined, context
-      );
-    }
-  } else {
-    // direct component options / constructor
-    vnode = createComponent(tag, data, context, children);
-  }
-  if (Array.isArray(vnode)) {
-    return vnode
-  } else if (isDef(vnode)) {
-    if (isDef(ns)) { applyNS(vnode, ns); }
-    if (isDef(data)) { registerDeepBindings(data); }
-    return vnode
-  } else {
-    return createEmptyVNode()
-  }
-}
-
-function applyNS (vnode, ns, force) {
-  vnode.ns = ns;
-  if (vnode.tag === 'foreignObject') {
-    // use default namespace inside foreignObject
-    ns = undefined;
-    force = true;
-  }
-  if (isDef(vnode.children)) {
-    for (var i = 0, l = vnode.children.length; i < l; i++) {
-      var child = vnode.children[i];
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force);
-      }
-    }
-  }
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn$2('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
 }
-
 // ref #5318
 // necessary to ensure parent re-render when deep bindings like :style and
 // :class are used on slot nodes
-function registerDeepBindings (data) {
-  if (isObject(data.style)) {
-    traverse(data.style);
-  }
-  if (isObject(data.class)) {
-    traverse(data.class);
-  }
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering v-for lists.
  */
-function renderList (
-  val,
-  render
-) {
-  var ret, i, l, keys, key;
-  if (Array.isArray(val) || typeof val === 'string') {
-    ret = new Array(val.length);
-    for (i = 0, l = val.length; i < l; i++) {
-      ret[i] = render(val[i], i);
-    }
-  } else if (typeof val === 'number') {
-    ret = new Array(val);
-    for (i = 0; i < val; i++) {
-      ret[i] = render(i + 1, i);
-    }
-  } else if (isObject(val)) {
-    if (hasSymbol && val[Symbol.iterator]) {
-      ret = [];
-      var iterator = val[Symbol.iterator]();
-      var result = iterator.next();
-      while (!result.done) {
-        ret.push(render(result.value, ret.length));
-        result = iterator.next();
-      }
-    } else {
-      keys = Object.keys(val);
-      ret = new Array(keys.length);
-      for (i = 0, l = keys.length; i < l; i++) {
-        key = keys[i];
-        ret[i] = render(val[key], key, i);
-      }
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
     }
-  }
-  if (!isDef(ret)) {
-    ret = [];
-  }
-  (ret)._isVList = true;
-  return ret
-}
-
-/*  */
-
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
+}
+
 /**
  * Runtime helper for rendering <slot>
  */
-function renderSlot (
-  name,
-  fallbackRender,
-  props,
-  bindObject
-) {
-  var scopedSlotFn = this.$scopedSlots[name];
-  var nodes;
-  if (scopedSlotFn) {
-    // scoped slot
-    props = props || {};
-    if (bindObject) {
-      if (!isObject(bindObject)) {
-        warn('slot v-bind without argument expects an Object', this);
-      }
-      props = extend(extend({}, bindObject), props);
-    }
-    nodes =
-      scopedSlotFn(props) ||
-      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender);
-  } else {
-    nodes =
-      this.$slots[name] ||
-      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender);
-  }
-
-  var target = props && props.slot;
-  if (target) {
-    return this.$createElement('template', { slot: target }, nodes)
-  } else {
-    return nodes
-  }
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/*  */
-
 /**
  * Runtime helper for resolving filters
  */
-function resolveFilter (id) {
-  return resolveAsset(this.$options, 'filters', id, true) || identity
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-/*  */
-
-function isKeyNotMatch (expect, actual) {
-  if (Array.isArray(expect)) {
-    return expect.indexOf(actual) === -1
-  } else {
-    return expect !== actual
-  }
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
 }
-
 /**
  * Runtime helper for checking keyCodes from config.
  * exposed as Vue.prototype._k
  * passing in eventKeyName as last argument separately for backwards compat
  */
-function checkKeyCodes (
-  eventKeyCode,
-  key,
-  builtInKeyCode,
-  eventKeyName,
-  builtInKeyName
-) {
-  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-    return isKeyNotMatch(builtInKeyName, eventKeyName)
-  } else if (mappedKeyCode) {
-    return isKeyNotMatch(mappedKeyCode, eventKeyCode)
-  } else if (eventKeyName) {
-    return hyphenate(eventKeyName) !== key
-  }
-  return eventKeyCode === undefined
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/*  */
-
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
  */
-function bindObjectProps (
-  data,
-  tag,
-  value,
-  asProp,
-  isSync
-) {
-  if (value) {
-    if (!isObject(value)) {
-      warn(
-        'v-bind without argument expects an Object or Array value',
-        this
-      );
-    } else {
-      if (Array.isArray(value)) {
-        value = toObject(value);
-      }
-      var hash;
-      var loop = function ( key ) {
-        if (
-          key === 'class' ||
-          key === 'style' ||
-          isReservedAttribute(key)
-        ) {
-          hash = data;
-        } else {
-          var type = data.attrs && data.attrs.type;
-          hash = asProp || config.mustUseProp(tag, type, key)
-            ? data.domProps || (data.domProps = {})
-            : data.attrs || (data.attrs = {});
-        }
-        var camelizedKey = camelize(key);
-        var hyphenatedKey = hyphenate(key);
-        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-          hash[key] = value[key];
-
-          if (isSync) {
-            var on = data.on || (data.on = {});
-            on[("update:" + key)] = function ($event) {
-              value[key] = $event;
-            };
-          }
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn$2('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
         }
-      };
-
-      for (var key in value) loop( key );
     }
-  }
-  return data
+    return data;
 }
 
-/*  */
-
 /**
  * Runtime helper for rendering static trees.
  */
-function renderStatic (
-  index,
-  isInFor
-) {
-  var cached = this._staticTrees || (this._staticTrees = []);
-  var tree = cached[index];
-  // if has already-rendered static tree and not inside v-for,
-  // we can reuse the same tree.
-  if (tree && !isInFor) {
-    return tree
-  }
-  // otherwise, render a fresh tree.
-  tree = cached[index] = this.$options.staticRenderFns[index].call(
-    this._renderProxy,
-    null,
-    this // for render fns generated for functional component templates
-  );
-  markStatic(tree, ("__static__" + index), false);
-  return tree
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, `__static__${index}`, false);
+    return tree;
 }
-
 /**
  * Runtime helper for v-once.
  * Effectively it means marking the node as static with a unique key.
  */
-function markOnce (
-  tree,
-  index,
-  key
-) {
-  markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
-  return tree
-}
-
-function markStatic (
-  tree,
-  key,
-  isOnce
-) {
-  if (Array.isArray(tree)) {
-    for (var i = 0; i < tree.length; i++) {
-      if (tree[i] && typeof tree[i] !== 'string') {
-        markStaticNode(tree[i], (key + "_" + i), isOnce);
-      }
-    }
-  } else {
-    markStaticNode(tree, key, isOnce);
-  }
+function markOnce(tree, index, key) {
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
 }
-
-function markStaticNode (node, key, isOnce) {
-  node.isStatic = true;
-  node.key = key;
-  node.isOnce = isOnce;
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-/*  */
-
-function bindObjectListeners (data, value) {
-  if (value) {
-    if (!isPlainObject(value)) {
-      warn(
-        'v-on without argument expects an Object value',
-        this
-      );
-    } else {
-      var on = data.on = data.on ? extend({}, data.on) : {};
-      for (var key in value) {
-        var existing = on[key];
-        var ours = value[key];
-        on[key] = existing ? [].concat(existing, ours) : ours;
-      }
-    }
-  }
-  return data
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn$2('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-/*  */
-
-function resolveScopedSlots (
-  fns, // see flow/vnode
-  res,
-  // the following are added in 2.6
-  hasDynamicKeys,
-  contentHashKey
-) {
-  res = res || { $stable: !hasDynamicKeys };
-  for (var i = 0; i < fns.length; i++) {
-    var slot = fns[i];
-    if (Array.isArray(slot)) {
-      resolveScopedSlots(slot, res, hasDynamicKeys);
-    } else if (slot) {
-      // marker for reverse proxying v-slot without scope on this.$slots
-      if (slot.proxy) {
-        slot.fn.proxy = true;
-      }
-      res[slot.key] = slot.fn;
-    }
-  }
-  if (contentHashKey) {
-    (res).$key = contentHashKey;
-  }
-  return res
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-/*  */
-
-function bindDynamicKeys (baseObj, values) {
-  for (var i = 0; i < values.length; i += 2) {
-    var key = values[i];
-    if (typeof key === 'string' && key) {
-      baseObj[values[i]] = values[i + 1];
-    } else if (key !== '' && key !== null) {
-      // null is a special value for explicitly removing a binding
-      warn(
-        ("Invalid value for dynamic directive argument (expected string or null): " + key),
-        this
-      );
-    }
-  }
-  return baseObj
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
 }
-
 // helper to dynamically append modifier runtime markers to event names.
 // ensure only append when value is already string, otherwise it will be cast
 // to string and cause the type check to miss.
-function prependModifier (value, symbol) {
-  return typeof value === 'string' ? symbol + value : value
-}
-
-/*  */
-
-function installRenderHelpers (target) {
-  target._o = markOnce;
-  target._n = toNumber;
-  target._s = toString;
-  target._l = renderList;
-  target._t = renderSlot;
-  target._q = looseEqual;
-  target._i = looseIndexOf;
-  target._m = renderStatic;
-  target._f = resolveFilter;
-  target._k = checkKeyCodes;
-  target._b = bindObjectProps;
-  target._v = createTextVNode;
-  target._e = createEmptyVNode;
-  target._u = resolveScopedSlots;
-  target._g = bindObjectListeners;
-  target._d = bindDynamicKeys;
-  target._p = prependModifier;
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
+}
+
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-/*  */
-
-
-
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
  */
-function resolveSlots (
-  children,
-  context
-) {
-  if (!children || !children.length) {
-    return {}
-  }
-  var slots = {};
-  for (var i = 0, l = children.length; i < l; i++) {
-    var child = children[i];
-    var data = child.data;
-    // remove slot attribute if the node is resolved as a Vue slot node
-    if (data && data.attrs && data.attrs.slot) {
-      delete data.attrs.slot;
-    }
-    // named slots should only be respected if the vnode was rendered in the
-    // same context.
-    if ((child.context === context || child.fnContext === context) &&
-      data && data.slot != null
-    ) {
-      var name = data.slot;
-      var slot = (slots[name] || (slots[name] = []));
-      if (child.tag === 'template') {
-        slot.push.apply(slot, child.children || []);
-      } else {
-        slot.push(child);
-      }
-    } else {
-      (slots.default || (slots.default = [])).push(child);
-    }
-  }
-  // ignore slots that contains only whitespace
-  for (var name$1 in slots) {
-    if (slots[name$1].every(isWhitespace)) {
-      delete slots[name$1];
-    }
-  }
-  return slots
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
 }
-
-function isWhitespace (node) {
-  return (node.isComment && !node.asyncFactory) || node.text === ' '
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-/*  */
-
-function isAsyncPlaceholder (node) {
-  return node.isComment && node.asyncFactory
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-/*  */
-
-function normalizeScopedSlots (
-  slots,
-  normalSlots,
-  prevSlots
-) {
-  var res;
-  var hasNormalSlots = Object.keys(normalSlots).length > 0;
-  var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  var key = slots && slots.$key;
-  if (!slots) {
-    res = {};
-  } else if (slots._normalized) {
-    // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
-  } else if (
-    isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
-    !hasNormalSlots &&
-    !prevSlots.$hasNormal
-  ) {
-    // fast path 2: stable scoped slots w/ no normal slots to proxy,
-    // only need to normalize once
-    return prevSlots
-  } else {
-    res = {};
-    for (var key$1 in slots) {
-      if (slots[key$1] && key$1[0] !== '$') {
-        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);
-      }
-    }
-  }
-  // expose normal slots on scopedSlots
-  for (var key$2 in normalSlots) {
-    if (!(key$2 in res)) {
-      res[key$2] = proxyNormalSlot(normalSlots, key$2);
-    }
-  }
-  // avoriaz seems to mock a non-extensible $scopedSlots object
-  // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    (slots)._normalized = res;
-  }
-  def(res, '$stable', isStable);
-  def(res, '$key', key);
-  def(res, '$hasNormal', hasNormalSlots);
-  return res
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
 }
-
 function normalizeScopedSlot(normalSlots, key, fn) {
-  var normalized = function () {
-    var res = arguments.length ? fn.apply(null, arguments) : fn({});
-    res = res && typeof res === 'object' && !Array.isArray(res)
-      ? [res] // single vnode
-      : normalizeChildren(res);
-    var vnode = res && res[0];
-    return res && (
-      !vnode ||
-      (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode)) // #9658, #10391
-    ) ? undefined
-      : res
-  };
-  // this is a slot using the new v-slot syntax without scope. although it is
-  // compiled as a scoped slot, render fn users would expect it to be present
-  // on this.$slots because the usage is semantically a normal slot.
-  if (fn.proxy) {
-    Object.defineProperty(normalSlots, key, {
-      get: normalized,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return normalized
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
 }
-
 function proxyNormalSlot(slots, key) {
-  return function () { return slots[key]; }
+    return () => slots[key];
 }
 
-/*  */
-
-var currentRenderingInstance = null;
-
-/*  */
-
-function ensureCtor (comp, base) {
-  if (
-    comp.__esModule ||
-    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
-  ) {
-    comp = comp.default;
-  }
-  return isObject(comp)
-    ? base.extend(comp)
-    : comp
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
 }
-
-function createAsyncPlaceholder (
-  factory,
-  data,
-  context,
-  children,
-  tag
-) {
-  var node = createEmptyVNode();
-  node.asyncFactory = factory;
-  node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-  return node
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
 }
 
-function resolveAsyncComponent (
-  factory,
-  baseCtor
-) {
-  if (isTrue(factory.error) && isDef(factory.errorComp)) {
-    return factory.errorComp
-  }
-
-  if (isDef(factory.resolved)) {
-    return factory.resolved
-  }
-
-  var owner = currentRenderingInstance;
-  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-    // already pending
-    factory.owners.push(owner);
-  }
-
-  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-    return factory.loadingComp
-  }
-
-  if (owner && !isDef(factory.owners)) {
-    var owners = factory.owners = [owner];
-    var sync = true;
-    var timerLoading = null;
-    var timerTimeout = null
-
-    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });
-
-    var forceRender = function (renderCompleted) {
-      for (var i = 0, l = owners.length; i < l; i++) {
-        (owners[i]).$forceUpdate();
-      }
-
-      if (renderCompleted) {
-        owners.length = 0;
-        if (timerLoading !== null) {
-          clearTimeout(timerLoading);
-          timerLoading = null;
-        }
-        if (timerTimeout !== null) {
-          clearTimeout(timerTimeout);
-          timerTimeout = null;
+let target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    const _target = target;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
         }
-      }
     };
-
-    var resolve = once(function (res) {
-      // cache resolved
-      factory.resolved = ensureCtor(res, baseCtor);
-      // invoke callbacks only if this is not a synchronous resolve
-      // (async resolves are shimmed as synchronous during SSR)
-      if (!sync) {
-        forceRender(true);
-      } else {
-        owners.length = 0;
-      }
-    });
-
-    var reject = once(function (reason) {
-      warn(
-        "Failed to resolve async component: " + (String(factory)) +
-        (reason ? ("\nReason: " + reason) : '')
-      );
-      if (isDef(factory.errorComp)) {
-        factory.error = true;
-        forceRender(true);
-      }
-    });
-
-    var res = factory(resolve, reject);
-
-    if (isObject(res)) {
-      if (isPromise(res)) {
-        // () => Promise
-        if (isUndef(factory.resolved)) {
-          res.then(resolve, reject);
-        }
-      } else if (isPromise(res.component)) {
-        res.component.then(resolve, reject);
-
-        if (isDef(res.error)) {
-          factory.errorComp = ensureCtor(res.error, baseCtor);
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
+    target = undefined;
+}
+
+let activeInstance = null;
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
         }
-
-        if (isDef(res.loading)) {
-          factory.loadingComp = ensureCtor(res.loading, baseCtor);
-          if (res.delay === 0) {
-            factory.loading = true;
-          } else {
-            timerLoading = setTimeout(function () {
-              timerLoading = null;
-              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                factory.loading = true;
-                forceRender(false);
-              }
-            }, res.delay || 200);
-          }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
         }
-
-        if (isDef(res.timeout)) {
-          timerTimeout = setTimeout(function () {
-            timerTimeout = null;
-            if (isUndef(factory.resolved)) {
-              reject(
-                "timeout (" + (res.timeout) + "ms)"
-              );
-            }
-          }, res.timeout);
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
         }
-      }
+        callHook(vm, "activated");
     }
-
-    sync = false;
-    // return in case resolved synchronously
-    return factory.loading
-      ? factory.loadingComp
-      : factory.resolved
-  }
-}
-
-/*  */
-
-/*  */
-
-/*  */
-
-var target;
-
-function add (event, fn) {
-  target.$on(event, fn);
-}
-
-function remove$1 (event, fn) {
-  target.$off(event, fn);
 }
-
-function createOnceHandler (event, fn) {
-  var _target = target;
-  return function onceHandler () {
-    var res = fn.apply(null, arguments);
-    if (res !== null) {
-      _target.$off(event, onceHandler);
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
     }
-  }
-}
-
-function updateComponentListeners (
-  vm,
-  listeners,
-  oldListeners
-) {
-  target = vm;
-  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);
-  target = undefined;
-}
-
-/*  */
-
-var activeInstance = null;
-
-function updateChildComponent (
-  vm,
-  propsData,
-  listeners,
-  parentVnode,
-  renderChildren
-) {
-
-  // determine whether component has slot children
-  // we need to do this before overwriting $options._renderChildren.
-
-  // check if there are dynamic scopedSlots (hand-written or compiled but with
-  // dynamic slot names). Static scoped slots compiled from template has the
-  // "$stable" marker.
-  var newScopedSlots = parentVnode.data.scopedSlots;
-  var oldScopedSlots = vm.$scopedSlots;
-  var hasDynamicScopedSlot = !!(
-    (newScopedSlots && !newScopedSlots.$stable) ||
-    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-    (!newScopedSlots && vm.$scopedSlots.$key)
-  );
-
-  // Any static slot children from the parent may have changed during parent's
-  // update. Dynamic scoped slots may also have changed. In such cases, a forced
-  // update is necessary to ensure correctness.
-  var needsForceUpdate = !!(
-    renderChildren ||               // has new static slots
-    vm.$options._renderChildren ||  // has old static slots
-    hasDynamicScopedSlot
-  );
-
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-
-  if (vm._vnode) { // update child tree's parent
-    vm._vnode.parent = parentVnode;
-  }
-  vm.$options._renderChildren = renderChildren;
-
-  // update $attrs and $listeners hash
-  // these are also reactive so they may trigger child update if the child
-  // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
-
-  // update props
-  if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    var props = vm._props;
-    var propKeys = vm.$options._propKeys || [];
-    for (var i = 0; i < propKeys.length; i++) {
-      var key = propKeys[i];
-      var propOptions = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
-    }
-    toggleObserving(true);
-    // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
-  }
-
-  // update listeners
-  listeners = listeners || emptyObject;
-  var oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
-
-  // resolve slots + force update if has children
-  if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
-  }
-}
-
-function isInInactiveTree (vm) {
-  while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) { return true }
-  }
-  return false
-}
-
-function activateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = false;
-    if (isInInactiveTree(vm)) {
-      return
-    }
-  } else if (vm._directInactive) {
-    return
-  }
-  if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
-    for (var i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, "deactivated");
     }
-    callHook(vm, 'activated');
-  }
 }
-
-function deactivateChildComponent (vm, direct) {
-  if (direct) {
-    vm._directInactive = true;
-    if (isInInactiveTree(vm)) {
-      return
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
     }
-  }
-  if (!vm._inactive) {
-    vm._inactive = true;
-    for (var i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
     }
-    callHook(vm, 'deactivated');
-  }
-}
-
-function callHook (vm, hook) {
-  // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  var handlers = vm.$options[hook];
-  var info = hook + " hook";
-  if (handlers) {
-    for (var i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-    }
-  }
-  if (vm._hasHookEvent) {
-    vm.$emit('hook:' + hook);
-  }
-  popTarget();
+    popTarget();
 }
 
-/*  */
-
 // Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
-
+let getNow = Date.now;
 // Determine what event timestamp the browser is using. Annoyingly, the
 // timestamp can either be hi-res (relative to page load) or low-res
 // (relative to UNIX epoch), so in order to compare time we have to use the
@@ -7773,1878 +6555,1596 @@ var getNow = Date.now;
 // All IE versions use low-res event timestamps, and have problematic clock
 // implementations (#9632)
 if (inBrowser && !isIE) {
-  var performance = window.performance;
-  if (
-    performance &&
-    typeof performance.now === 'function' &&
-    getNow() > document.createEvent('Event').timeStamp
-  ) {
-    // if the event timestamp, although evaluated AFTER the Date.now(), is
-    // smaller than it, it means the event is using a hi-res timestamp,
-    // and we need to use the hi-res version for event listener timestamps as
-    // well.
-    getNow = function () { return performance.now(); };
-  }
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
 }
-
 /**
  * Queue a kept-alive component that was activated during patch.
  * The queue will be processed after the entire tree has been patched.
  */
-function queueActivatedComponent (vm) {
-  // setting _inactive to false here so that a render function can
-  // rely on checking whether it's in an inactive tree (e.g. router-view)
-  vm._inactive = false;
-}
-
-/*  */
-
-/*  */
-
-/*  */
-
-function resolveInject (inject, vm) {
-  if (inject) {
-    // inject is :any because flow is not smart enough to figure out cached
-    var result = Object.create(null);
-    var keys = hasSymbol
-      ? Reflect.ownKeys(inject)
-      : Object.keys(inject);
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      // #6574 in case the inject object is observed...
-      if (key === '__ob__') { continue }
-      var provideKey = inject[key].from;
-      var source = vm;
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey];
-          break
-        }
-        source = source.$parent;
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          var provideDefault = inject[key].default;
-          result[key] = typeof provideDefault === 'function'
-            ? provideDefault.call(vm)
-            : provideDefault;
-        } else {
-          warn(("Injection \"" + key + "\" not found"), vm);
-        }
-      }
-    }
-    return result
-  }
-}
-
-/*  */
-
-function resolveConstructorOptions (Ctor) {
-  var options = Ctor.options;
-  if (Ctor.super) {
-    var superOptions = resolveConstructorOptions(Ctor.super);
-    var cachedSuperOptions = Ctor.superOptions;
-    if (superOptions !== cachedSuperOptions) {
-      // super option changed,
-      // need to resolve new options.
-      Ctor.superOptions = superOptions;
-      // check if there are any late-modified/attached options (#4976)
-      var modifiedOptions = resolveModifiedOptions(Ctor);
-      // update base extend options
-      if (modifiedOptions) {
-        extend(Ctor.extendOptions, modifiedOptions);
-      }
-      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-      if (options.name) {
-        options.components[options.name] = Ctor;
-      }
-    }
-  }
-  return options
-}
-
-function resolveModifiedOptions (Ctor) {
-  var modified;
-  var latest = Ctor.options;
-  var sealed = Ctor.sealedOptions;
-  for (var key in latest) {
-    if (latest[key] !== sealed[key]) {
-      if (!modified) { modified = {}; }
-      modified[key] = latest[key];
-    }
-  }
-  return modified
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
 }
 
-/*  */
-
-function FunctionalRenderContext (
-  data,
-  props,
-  children,
-  parent,
-  Ctor
-) {
-  var this$1 = this;
-
-  var options = Ctor.options;
-  // ensure the createElement function in functional components
-  // gets a unique context - this is necessary for correct named slot check
-  var contextVm;
-  if (hasOwn(parent, '_uid')) {
-    contextVm = Object.create(parent);
-    // $flow-disable-line
-    contextVm._original = parent;
-  } else {
-    // the context vm passed in is a functional context as well.
-    // in this case we want to make sure we are able to get a hold to the
-    // real context instance.
-    contextVm = parent;
-    // $flow-disable-line
-    parent = parent._original;
-  }
-  var isCompiled = isTrue(options._compiled);
-  var needNormalization = !isCompiled;
-
-  this.data = data;
-  this.props = props;
-  this.children = children;
-  this.parent = parent;
-  this.listeners = data.on || emptyObject;
-  this.injections = resolveInject(options.inject, parent);
-  this.slots = function () {
-    if (!this$1.$slots) {
-      normalizeScopedSlots(
-        data.scopedSlots,
-        this$1.$slots = resolveSlots(children, parent)
-      );
-    }
-    return this$1.$slots
-  };
-
-  Object.defineProperty(this, 'scopedSlots', ({
-    enumerable: true,
-    get: function get () {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    warn$2(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
+}
+
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
     }
-  }));
-
-  // support for compiled functional template
-  if (isCompiled) {
-    // exposing $options for renderStatic()
-    this.$options = options;
-    // pre-resolve slots for renderSlot()
-    this.$slots = this.slots();
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-  }
-
-  if (options._scopeId) {
-    this._c = function (a, b, c, d) {
-      var vnode = createElement(contextVm, a, b, c, d, needNormalization);
-      if (vnode && !Array.isArray(vnode)) {
-        vnode.fnScopeId = options._scopeId;
-        vnode.fnContext = parent;
-      }
-      return vnode
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
+}
+
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
     };
-  } else {
-    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };
-  }
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+    }
 }
-
 installRenderHelpers(FunctionalRenderContext.prototype);
-
-function createFunctionalComponent (
-  Ctor,
-  propsData,
-  data,
-  contextVm,
-  children
-) {
-  var options = Ctor.options;
-  var props = {};
-  var propOptions = options.props;
-  if (isDef(propOptions)) {
-    for (var key in propOptions) {
-      props[key] = validateProp(key, propOptions, propsData || emptyObject);
-    }
-  } else {
-    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
-    if (isDef(data.props)) { mergeProps(props, data.props); }
-  }
-
-  var renderContext = new FunctionalRenderContext(
-    data,
-    props,
-    children,
-    contextVm,
-    Ctor
-  );
-
-  var vnode = options.render.call(null, renderContext._c, renderContext);
-
-  if (vnode instanceof VNode) {
-    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)
-  } else if (Array.isArray(vnode)) {
-    var vnodes = normalizeChildren(vnode) || [];
-    var res = new Array(vnodes.length);
-    for (var i = 0; i < vnodes.length; i++) {
-      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
     }
-    return res
-  }
-}
-
-function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
-  // #7817 clone node before setting fnContext, otherwise if the node is reused
-  // (e.g. it was from a cached normal slot) the fnContext causes named slots
-  // that should not be matched to match.
-  var clone = cloneVNode(vnode);
-  clone.fnContext = contextVm;
-  clone.fnOptions = options;
-  {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-  }
-  if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot;
-  }
-  return clone
-}
-
-function mergeProps (to, from) {
-  for (var key in from) {
-    to[camelize(key)] = from[key];
-  }
 }
-
-/*  */
-
-/*  */
-
-/*  */
-
-/*  */
-
-// inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-  init: function init (vnode, hydrating) {
-    if (
-      vnode.componentInstance &&
-      !vnode.componentInstance._isDestroyed &&
-      vnode.data.keepAlive
-    ) {
-      // kept-alive components, treat as a patch
-      var mountedNode = vnode; // work around flow
-      componentVNodeHooks.prepatch(mountedNode, mountedNode);
-    } else {
-      var child = vnode.componentInstance = createComponentInstanceForVnode(
-        vnode,
-        activeInstance
-      );
-      child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-    }
-  },
-
-  prepatch: function prepatch (oldVnode, vnode) {
-    var options = vnode.componentOptions;
-    var child = vnode.componentInstance = oldVnode.componentInstance;
-    updateChildComponent(
-      child,
-      options.propsData, // updated props
-      options.listeners, // updated listeners
-      vnode, // new parent vnode
-      options.children // new children
-    );
-  },
-
-  insert: function insert (vnode) {
-    var context = vnode.context;
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isMounted) {
-      componentInstance._isMounted = true;
-      callHook(componentInstance, 'mounted');
-    }
-    if (vnode.data.keepAlive) {
-      if (context._isMounted) {
-        // vue-router#1212
-        // During updates, a kept-alive component's child components may
-        // change, so directly walking the tree here may call activated hooks
-        // on incorrect children. Instead we push them into a queue which will
-        // be processed after the whole patch process ended.
-        queueActivatedComponent(componentInstance);
-      } else {
-        activateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  },
-
-  destroy: function destroy (vnode) {
-    var componentInstance = vnode.componentInstance;
-    if (!componentInstance._isDestroyed) {
-      if (!vnode.data.keepAlive) {
-        componentInstance.$destroy();
-      } else {
-        deactivateChildComponent(componentInstance, true /* direct */);
-      }
-    }
-  }
-};
-
-var hooksToMerge = Object.keys(componentVNodeHooks);
-
-function createComponent (
-  Ctor,
-  data,
-  context,
-  children,
-  tag
-) {
-  if (isUndef(Ctor)) {
-    return
-  }
-
-  var baseCtor = context.$options._base;
-
-  // plain options object: turn it into a constructor
-  if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor);
-  }
-
-  // if at this stage it's not a constructor or an async component factory,
-  // reject.
-  if (typeof Ctor !== 'function') {
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
     {
-      warn(("Invalid Component definition: " + (String(Ctor))), context);
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
     }
-    return
-  }
-
-  // async component
-  var asyncFactory;
-  if (isUndef(Ctor.cid)) {
-    asyncFactory = Ctor;
-    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-    if (Ctor === undefined) {
-      // return a placeholder node for async component, which is rendered
-      // as a comment node but preserves all the raw information for the node.
-      // the information will be used for async server-rendering and hydration.
-      return createAsyncPlaceholder(
-        asyncFactory,
-        data,
-        context,
-        children,
-        tag
-      )
-    }
-  }
-
-  data = data || {};
-
-  // resolve constructor options in case global mixins are applied after
-  // component constructor creation
-  resolveConstructorOptions(Ctor);
-
-  // transform component v-model data into props & events
-  if (isDef(data.model)) {
-    transformModel(Ctor.options, data);
-  }
-
-  // extract props
-  var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-
-  // functional component
-  if (isTrue(Ctor.options.functional)) {
-    return createFunctionalComponent(Ctor, propsData, data, context, children)
-  }
-
-  // extract listeners, since these needs to be treated as
-  // child component listeners instead of DOM listeners
-  var listeners = data.on;
-  // replace with listeners with .native modifier
-  // so it gets processed during parent component patch.
-  data.on = data.nativeOn;
-
-  if (isTrue(Ctor.options.abstract)) {
-    // abstract components do not keep anything
-    // other than props & listeners & slot
-
-    // work around flow
-    var slot = data.slot;
-    data = {};
-    if (slot) {
-      data.slot = slot;
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
     }
-  }
-
-  // install component management hooks onto the placeholder node
-  installComponentHooks(data);
-
-  // return a placeholder vnode
-  var name = Ctor.options.name || tag;
-  var vnode = new VNode(
-    ("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
-    data, undefined, undefined, undefined, context,
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
-    asyncFactory
-  );
-
-  return vnode
-}
-
-function createComponentInstanceForVnode (
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode,
-  // activeInstance in lifecycle state
-  parent
-) {
-  var options = {
-    _isComponent: true,
-    _parentVnode: vnode,
-    parent: parent
-  };
-  // check inline-template render functions
-  var inlineTemplate = vnode.data.inlineTemplate;
-  if (isDef(inlineTemplate)) {
-    options.render = inlineTemplate.render;
-    options.staticRenderFns = inlineTemplate.staticRenderFns;
-  }
-  return new vnode.componentOptions.Ctor(options)
+    return clone;
 }
-
-function installComponentHooks (data) {
-  var hooks = data.hook || (data.hook = {});
-  for (var i = 0; i < hooksToMerge.length; i++) {
-    var key = hooksToMerge[i];
-    var existing = hooks[key];
-    var toMerge = componentVNodeHooks[key];
-    if (existing !== toMerge && !(existing && existing._merged)) {
-      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
     }
-  }
 }
 
-function mergeHook$1 (f1, f2) {
-  var merged = function (a, b) {
-    // flow complains about extra args which is why we use any
-    f1(a, b);
-    f2(a, b);
-  };
-  merged._merged = true;
-  return merged
-}
-
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel (options, data) {
-  var prop = (options.model && options.model.prop) || 'value';
-  var event = (options.model && options.model.event) || 'input'
-  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
-  var on = data.on || (data.on = {});
-  var existing = on[event];
-  var callback = data.model.callback;
-  if (isDef(existing)) {
-    if (
-      Array.isArray(existing)
-        ? existing.indexOf(callback) === -1
-        : existing !== callback
-    ) {
-      on[event] = [callback].concat(existing);
-    }
-  } else {
-    on[event] = callback;
-  }
-}
-
-/*  */
-
-var warned = Object.create(null);
-var warnOnce = function (msg) {
-  if (!warned[msg]) {
-    warned[msg] = true;
-    // eslint-disable-next-line no-console
-    console.warn(("\n\u001b[31m" + msg + "\u001b[39m\n"));
-  }
-};
-
-var onCompilationError = function (err, vm) {
-  var trace = vm ? generateComponentTrace(vm) : '';
-  throw new Error(("\n\u001b[31m" + err + trace + "\u001b[39m\n"))
-};
-
-var normalizeRender = function (vm) {
-  var ref = vm.$options;
-  var render = ref.render;
-  var template = ref.template;
-  var _scopeId = ref._scopeId;
-  if (isUndef(render)) {
-    if (template) {
-      var compiled = compileToFunctions(template, {
-        scopeId: _scopeId,
-        warn: onCompilationError
-      }, vm);
-
-      vm.$options.render = compiled.render;
-      vm.$options.staticRenderFns = compiled.staticRenderFns;
-    } else {
-      throw new Error(
-        ("render function or template not defined in component: " + (vm.$options.name || vm.$options._componentTag || 'anonymous'))
-      )
-    }
-  }
-};
-
-function waitForServerPrefetch (vm, resolve, reject) {
-  var handlers = vm.$options.serverPrefetch;
-  if (isDef(handlers)) {
-    if (!Array.isArray(handlers)) { handlers = [handlers]; }
-    try {
-      var promises = [];
-      for (var i = 0, j = handlers.length; i < j; i++) {
-        var result = handlers[i].call(vm, vm);
-        if (result && typeof result.then === 'function') {
-          promises.push(result);
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
         }
-      }
-      Promise.all(promises).then(resolve).catch(reject);
-      return
-    } catch (e) {
-      reject(e);
     }
-  }
-  resolve();
 }
-
-function renderNode (node, isRoot, context) {
-  if (node.isString) {
-    renderStringNode$1(node, context);
-  } else if (isDef(node.componentOptions)) {
-    renderComponent(node, isRoot, context);
-  } else if (isDef(node.tag)) {
-    renderElement(node, isRoot, context);
-  } else if (isTrue(node.isComment)) {
-    if (isDef(node.asyncFactory)) {
-      // async component
-      renderAsyncComponent(node, isRoot, context);
-    } else {
-      context.write(("<!--" + (node.text) + "-->"), context.next);
-    }
-  } else {
-    context.write(
-      node.raw ? node.text : escape(String(node.text)),
-      context.next
-    );
-  }
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
 }
-
-function registerComponentForCache (options, write) {
-  // exposed by vue-loader, need to call this if cache hit because
-  // component lifecycle hooks will not be called.
-  var register = options._ssrRegister;
-  if (write.caching && isDef(register)) {
-    write.componentBuffer[write.componentBuffer.length - 1].add(register);
-  }
-  return register
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-function renderComponent (node, isRoot, context) {
-  var write = context.write;
-  var next = context.next;
-  var userContext = context.userContext;
-
-  // check cache hit
-  var Ctor = node.componentOptions.Ctor;
-  var getKey = Ctor.options.serverCacheKey;
-  var name = Ctor.options.name;
-  var cache = context.cache;
-  var registerComponent = registerComponentForCache(Ctor.options, write);
-
-  if (isDef(getKey) && isDef(cache) && isDef(name)) {
-    var rawKey = getKey(node.componentOptions.propsData);
-    if (rawKey === false) {
-      renderComponentInner(node, isRoot, context);
-      return
-    }
-    var key = name + '::' + rawKey;
-    var has = context.has;
-    var get = context.get;
-    if (isDef(has)) {
-      has(key, function (hit) {
-        if (hit === true && isDef(get)) {
-          get(key, function (res) {
-            if (isDef(registerComponent)) {
-              registerComponent(userContext);
-            }
-            res.components.forEach(function (register) { return register(userContext); });
-            write(res.html, next);
-          });
-        } else {
-          renderComponentWithCache(node, isRoot, key, context);
-        }
-      });
-    } else if (isDef(get)) {
-      get(key, function (res) {
-        if (isDef(res)) {
-          if (isDef(registerComponent)) {
-            registerComponent(userContext);
-          }
-          res.components.forEach(function (register) { return register(userContext); });
-          write(res.html, next);
-        } else {
-          renderComponentWithCache(node, isRoot, key, context);
-        }
-      });
-    }
-  } else {
-    if (isDef(getKey) && isUndef(cache)) {
-      warnOnce(
-        "[vue-server-renderer] Component " + (Ctor.options.name || '(anonymous)') + " implemented serverCacheKey, " +
-        'but no cache was provided to the renderer.'
-      );
-    }
-    if (isDef(getKey) && isUndef(name)) {
-      warnOnce(
-        "[vue-server-renderer] Components that implement \"serverCacheKey\" " +
-        "must also define a unique \"name\" option."
-      );
+let warned = Object.create(null);
+const warnOnce = (msg) => {
+    if (!warned[msg]) {
+        warned[msg] = true;
+        // eslint-disable-next-line no-console
+        console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
     }
-    renderComponentInner(node, isRoot, context);
-  }
+};
+const onCompilationError = (err, vm) => {
+    const trace = vm ? generateComponentTrace(vm) : '';
+    throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
+};
+const normalizeRender = (vm) => {
+    const { render, template, _scopeId } = vm.$options;
+    if (isUndef(render)) {
+        if (template) {
+            const compiled = compileToFunctions(template, {
+                scopeId: _scopeId,
+                warn: onCompilationError,
+            }, vm);
+            vm.$options.render = compiled.render;
+            vm.$options.staticRenderFns = compiled.staticRenderFns;
+        }
+        else {
+            throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
+        }
+    }
+};
+function waitForServerPrefetch(vm, resolve, reject) {
+    let handlers = vm.$options.serverPrefetch;
+    if (isDef(handlers)) {
+        if (!Array.isArray(handlers))
+            handlers = [handlers];
+        try {
+            const promises = [];
+            for (let i = 0, j = handlers.length; i < j; i++) {
+                const result = handlers[i].call(vm, vm);
+                if (result && typeof result.then === 'function') {
+                    promises.push(result);
+                }
+            }
+            Promise.all(promises).then(resolve).catch(reject);
+            return;
+        }
+        catch (e) {
+            reject(e);
+        }
+    }
+    resolve();
 }
-
-function renderComponentWithCache (node, isRoot, key, context) {
-  var write = context.write;
-  write.caching = true;
-  var buffer = write.cacheBuffer;
-  var bufferIndex = buffer.push('') - 1;
-  var componentBuffer = write.componentBuffer;
-  componentBuffer.push(new Set());
-  context.renderStates.push({
-    type: 'ComponentWithCache',
-    key: key,
-    buffer: buffer,
-    bufferIndex: bufferIndex,
-    componentBuffer: componentBuffer
-  });
-  renderComponentInner(node, isRoot, context);
+function renderNode(node, isRoot, context) {
+    if (node.isString) {
+        renderStringNode(node, context);
+    }
+    else if (isDef(node.componentOptions)) {
+        renderComponent(node, isRoot, context);
+    }
+    else if (isDef(node.tag)) {
+        renderElement(node, isRoot, context);
+    }
+    else if (isTrue(node.isComment)) {
+        if (isDef(node.asyncFactory)) {
+            // async component
+            renderAsyncComponent(node, isRoot, context);
+        }
+        else {
+            context.write(`<!--${node.text}-->`, context.next);
+        }
+    }
+    else {
+        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+    }
+}
+function registerComponentForCache(options, write) {
+    // exposed by vue-loader, need to call this if cache hit because
+    // component lifecycle hooks will not be called.
+    const register = options._ssrRegister;
+    if (write.caching && isDef(register)) {
+        write.componentBuffer[write.componentBuffer.length - 1].add(register);
+    }
+    return register;
+}
+function renderComponent(node, isRoot, context) {
+    const { write, next, userContext } = context;
+    // check cache hit
+    const Ctor = node.componentOptions.Ctor;
+    const getKey = Ctor.options.serverCacheKey;
+    const name = Ctor.options.name;
+    const cache = context.cache;
+    const registerComponent = registerComponentForCache(Ctor.options, write);
+    if (isDef(getKey) && isDef(cache) && isDef(name)) {
+        const rawKey = getKey(node.componentOptions.propsData);
+        if (rawKey === false) {
+            renderComponentInner(node, isRoot, context);
+            return;
+        }
+        const key = name + '::' + rawKey;
+        const { has, get } = context;
+        if (isDef(has)) {
+            has(key, (hit) => {
+                if (hit === true && isDef(get)) {
+                    get(key, (res) => {
+                        if (isDef(registerComponent)) {
+                            registerComponent(userContext);
+                        }
+                        res.components.forEach((register) => register(userContext));
+                        write(res.html, next);
+                    });
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+        else if (isDef(get)) {
+            get(key, (res) => {
+                if (isDef(res)) {
+                    if (isDef(registerComponent)) {
+                        registerComponent(userContext);
+                    }
+                    res.components.forEach((register) => register(userContext));
+                    write(res.html, next);
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+    }
+    else {
+        if (isDef(getKey) && isUndef(cache)) {
+            warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
+                'but no cache was provided to the renderer.');
+        }
+        if (isDef(getKey) && isUndef(name)) {
+            warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
+                `must also define a unique "name" option.`);
+        }
+        renderComponentInner(node, isRoot, context);
+    }
 }
-
-function renderComponentInner (node, isRoot, context) {
-  var prevActive = context.activeInstance;
-  // expose userContext on vnode
-  node.ssrContext = context.userContext;
-  var child = context.activeInstance = createComponentInstanceForVnode(
-    node,
-    context.activeInstance
-  );
-  normalizeRender(child);
-
-  var resolve = function () {
-    var childNode = child._render();
-    childNode.parent = node;
+function renderComponentWithCache(node, isRoot, key, context) {
+    const write = context.write;
+    write.caching = true;
+    const buffer = write.cacheBuffer;
+    const bufferIndex = buffer.push('') - 1;
+    const componentBuffer = write.componentBuffer;
+    componentBuffer.push(new Set());
     context.renderStates.push({
-      type: 'Component',
-      prevActive: prevActive
+        type: 'ComponentWithCache',
+        key,
+        buffer,
+        bufferIndex,
+        componentBuffer,
     });
-    renderNode(childNode, isRoot, context);
-  };
-
-  var reject = context.done;
-
-  waitForServerPrefetch(child, resolve, reject);
+    renderComponentInner(node, isRoot, context);
 }
-
-function renderAsyncComponent (node, isRoot, context) {
-  var factory = node.asyncFactory;
-
-  var resolve = function (comp) {
-    if (comp.__esModule && comp.default) {
-      comp = comp.default;
-    }
-    var ref = node.asyncMeta;
-    var data = ref.data;
-    var children = ref.children;
-    var tag = ref.tag;
-    var nodeContext = node.asyncMeta.context;
-    var resolvedNode = createComponent(
-      comp,
-      data,
-      nodeContext,
-      children,
-      tag
-    );
-    if (resolvedNode) {
-      if (resolvedNode.componentOptions) {
-        // normal component
-        renderComponent(resolvedNode, isRoot, context);
-      } else if (!Array.isArray(resolvedNode)) {
-        // single return node from functional component
-        renderNode(resolvedNode, isRoot, context);
-      } else {
-        // multiple return nodes from functional component
+function renderComponentInner(node, isRoot, context) {
+    const prevActive = context.activeInstance;
+    // expose userContext on vnode
+    node.ssrContext = context.userContext;
+    const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+    normalizeRender(child);
+    const resolve = () => {
+        const childNode = child._render();
+        childNode.parent = node;
         context.renderStates.push({
-          type: 'Fragment',
-          children: resolvedNode,
-          rendered: 0,
-          total: resolvedNode.length
+            type: 'Component',
+            prevActive,
         });
-        context.next();
-      }
-    } else {
-      // invalid component, but this does not throw on the client
-      // so render empty comment node
-      context.write("<!---->", context.next);
-    }
-  };
-
-  if (factory.resolved) {
-    resolve(factory.resolved);
-    return
-  }
-
-  var reject = context.done;
-  var res;
-  try {
-    res = factory(resolve, reject);
-  } catch (e) {
-    reject(e);
-  }
-  if (res) {
-    if (typeof res.then === 'function') {
-      res.then(resolve, reject).catch(reject);
-    } else {
-      // new syntax in 2.3
-      var comp = res.component;
-      if (comp && typeof comp.then === 'function') {
-        comp.then(resolve, reject).catch(reject);
-      }
-    }
-  }
-}
-
-function renderStringNode$1 (el, context) {
-  var write = context.write;
-  var next = context.next;
-  if (isUndef(el.children) || el.children.length === 0) {
-    write(el.open + (el.close || ''), next);
-  } else {
-    var children = el.children;
-    context.renderStates.push({
-      type: 'Element',
-      children: children,
-      rendered: 0,
-      total: children.length,
-      endTag: el.close
-    });
-    write(el.open, next);
-  }
-}
-
-function renderElement (el, isRoot, context) {
-  var write = context.write;
-  var next = context.next;
-
-  if (isTrue(isRoot)) {
-    if (!el.data) { el.data = {}; }
-    if (!el.data.attrs) { el.data.attrs = {}; }
-    el.data.attrs[SSR_ATTR] = 'true';
-  }
-
-  if (el.fnOptions) {
-    registerComponentForCache(el.fnOptions, write);
-  }
-
-  var startTag = renderStartingTag(el, context);
-  var endTag = "</" + (el.tag) + ">";
-  if (context.isUnaryTag(el.tag)) {
-    write(startTag, next);
-  } else if (isUndef(el.children) || el.children.length === 0) {
-    write(startTag + endTag, next);
-  } else {
-    var children = el.children;
-    context.renderStates.push({
-      type: 'Element',
-      children: children,
-      rendered: 0,
-      total: children.length,
-      endTag: endTag
-    });
-    write(startTag, next);
-  }
-}
-
-function hasAncestorData (node) {
-  var parentNode = node.parent;
-  return isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode))
+        renderNode(childNode, isRoot, context);
+    };
+    const reject = context.done;
+    waitForServerPrefetch(child, resolve, reject);
+}
+function renderAsyncComponent(node, isRoot, context) {
+    const factory = node.asyncFactory;
+    const resolve = (comp) => {
+        if (comp.__esModule && comp.default) {
+            comp = comp.default;
+        }
+        const { data, children, tag } = node.asyncMeta;
+        const nodeContext = node.asyncMeta.context;
+        const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+        if (resolvedNode) {
+            if (resolvedNode.componentOptions) {
+                // normal component
+                renderComponent(resolvedNode, isRoot, context);
+            }
+            else if (!Array.isArray(resolvedNode)) {
+                // single return node from functional component
+                renderNode(resolvedNode, isRoot, context);
+            }
+            else {
+                // multiple return nodes from functional component
+                context.renderStates.push({
+                    type: 'Fragment',
+                    children: resolvedNode,
+                    rendered: 0,
+                    total: resolvedNode.length,
+                });
+                context.next();
+            }
+        }
+        else {
+            // invalid component, but this does not throw on the client
+            // so render empty comment node
+            context.write(`<!---->`, context.next);
+        }
+    };
+    if (factory.resolved) {
+        resolve(factory.resolved);
+        return;
+    }
+    const reject = context.done;
+    let res;
+    try {
+        res = factory(resolve, reject);
+    }
+    catch (e) {
+        reject(e);
+    }
+    if (res) {
+        if (typeof res.then === 'function') {
+            res.then(resolve, reject).catch(reject);
+        }
+        else {
+            // new syntax in 2.3
+            const comp = res.component;
+            if (comp && typeof comp.then === 'function') {
+                comp.then(resolve, reject).catch(reject);
+            }
+        }
+    }
 }
-
-function getVShowDirectiveInfo (node) {
-  var dir;
-  var tmp;
-
-  while (isDef(node)) {
-    if (node.data && node.data.directives) {
-      tmp = node.data.directives.find(function (dir) { return dir.name === 'show'; });
-      if (tmp) {
-        dir = tmp;
-      }
+function renderStringNode(el, context) {
+    const { write, next } = context;
+    if (isUndef(el.children) || el.children.length === 0) {
+        write(el.open + (el.close || ''), next);
+    }
+    else {
+        const children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children,
+            rendered: 0,
+            total: children.length,
+            endTag: el.close,
+        });
+        write(el.open, next);
     }
-    node = node.parent;
-  }
-  return dir
 }
-
-function renderStartingTag (node, context) {
-  var markup = "<" + (node.tag);
-  var directives = context.directives;
-  var modules = context.modules;
-
-  // construct synthetic data for module processing
-  // because modules like style also produce code by parent VNode data
-  if (isUndef(node.data) && hasAncestorData(node)) {
-    node.data = {};
-  }
-  if (isDef(node.data)) {
-    // check directives
-    var dirs = node.data.directives;
-    if (dirs) {
-      for (var i = 0; i < dirs.length; i++) {
-        var name = dirs[i].name;
-        if (name !== 'show') {
-          var dirRenderer = resolveAsset(context, 'directives', name);
-          if (dirRenderer) {
-            // directives mutate the node's data
-            // which then gets rendered by modules
-            dirRenderer(node, dirs[i]);
-          }
-        }
-      }
+function renderElement(el, isRoot, context) {
+    const { write, next } = context;
+    if (isTrue(isRoot)) {
+        if (!el.data)
+            el.data = {};
+        if (!el.data.attrs)
+            el.data.attrs = {};
+        el.data.attrs[SSR_ATTR] = 'true';
     }
-
-    // v-show directive needs to be merged from parent to child
-    var vshowDirectiveInfo = getVShowDirectiveInfo(node);
-    if (vshowDirectiveInfo) {
-      directives.show(node, vshowDirectiveInfo);
+    if (el.fnOptions) {
+        registerComponentForCache(el.fnOptions, write);
     }
-
-    // apply other modules
-    for (var i$1 = 0; i$1 < modules.length; i$1++) {
-      var res = modules[i$1](node);
-      if (res) {
-        markup += res;
-      }
-    }
-  }
-  // attach scoped CSS ID
-  var scopeId;
-  var activeInstance = context.activeInstance;
-  if (isDef(activeInstance) &&
-    activeInstance !== node.context &&
-    isDef(scopeId = activeInstance.$options._scopeId)
-  ) {
-    markup += " " + ((scopeId));
-  }
-  if (isDef(node.fnScopeId)) {
-    markup += " " + (node.fnScopeId);
-  } else {
+    const startTag = renderStartingTag(el, context);
+    const endTag = `</${el.tag}>`;
+    if (context.isUnaryTag(el.tag)) {
+        write(startTag, next);
+    }
+    else if (isUndef(el.children) || el.children.length === 0) {
+        write(startTag + endTag, next);
+    }
+    else {
+        const children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children,
+            rendered: 0,
+            total: children.length,
+            endTag,
+        });
+        write(startTag, next);
+    }
+}
+function hasAncestorData(node) {
+    const parentNode = node.parent;
+    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+}
+function getVShowDirectiveInfo(node) {
+    let dir;
+    let tmp;
     while (isDef(node)) {
-      if (isDef(scopeId = node.context.$options._scopeId)) {
-        markup += " " + scopeId;
-      }
-      node = node.parent;
+        if (node.data && node.data.directives) {
+            tmp = node.data.directives.find((dir) => dir.name === 'show');
+            if (tmp) {
+                dir = tmp;
+            }
+        }
+        node = node.parent;
+    }
+    //@ts-expect-error
+    return dir;
+}
+function renderStartingTag(node, context) {
+    let markup = `<${node.tag}`;
+    const { directives, modules } = context;
+    // construct synthetic data for module processing
+    // because modules like style also produce code by parent VNode data
+    if (isUndef(node.data) && hasAncestorData(node)) {
+        node.data = {};
+    }
+    if (isDef(node.data)) {
+        // check directives
+        const dirs = node.data.directives;
+        if (dirs) {
+            for (let i = 0; i < dirs.length; i++) {
+                const name = dirs[i].name;
+                if (name !== 'show') {
+                    const dirRenderer = resolveAsset(context, 'directives', name);
+                    if (dirRenderer) {
+                        // directives mutate the node's data
+                        // which then gets rendered by modules
+                        dirRenderer(node, dirs[i]);
+                    }
+                }
+            }
+        }
+        // v-show directive needs to be merged from parent to child
+        const vshowDirectiveInfo = getVShowDirectiveInfo(node);
+        if (vshowDirectiveInfo) {
+            directives.show(node, vshowDirectiveInfo);
+        }
+        // apply other modules
+        for (let i = 0; i < modules.length; i++) {
+            const res = modules[i](node);
+            if (res) {
+                markup += res;
+            }
+        }
+    }
+    // attach scoped CSS ID
+    let scopeId;
+    const activeInstance = context.activeInstance;
+    if (isDef(activeInstance) &&
+        activeInstance !== node.context &&
+        isDef((scopeId = activeInstance.$options._scopeId))) {
+        markup += ` ${scopeId}`;
+    }
+    if (isDef(node.fnScopeId)) {
+        markup += ` ${node.fnScopeId}`;
+    }
+    else {
+        while (isDef(node)) {
+            //@ts-expect-error
+            if (isDef((scopeId = node.context.$options._scopeId))) {
+                markup += ` ${scopeId}`;
+            }
+            node = node.parent;
+        }
     }
-  }
-  return markup + '>'
+    return markup + '>';
+}
+function createRenderFunction(modules, directives, isUnaryTag, cache) {
+    return function render(component, write, userContext, done) {
+        warned = Object.create(null);
+        const context = new RenderContext({
+            activeInstance: component,
+            userContext,
+            write,
+            done,
+            renderNode,
+            isUnaryTag,
+            modules,
+            directives,
+            cache,
+        });
+        installSSRHelpers(component);
+        normalizeRender(component);
+        const resolve = () => {
+            renderNode(component._render(), true, context);
+        };
+        waitForServerPrefetch(component, resolve, done);
+    };
 }
 
-function createRenderFunction (
-  modules,
-  directives,
-  isUnaryTag,
-  cache
-) {
-  return function render (
-    component,
-    write,
-    userContext,
-    done
-  ) {
-    warned = Object.create(null);
-    var context = new RenderContext({
-      activeInstance: component,
-      userContext: userContext,
-      write: write, done: done, renderNode: renderNode,
-      isUnaryTag: isUnaryTag, modules: modules, directives: directives,
-      cache: cache
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
+function createPromiseCallback() {
+    let resolve, reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
     });
-    installSSRHelpers(component);
-    normalizeRender(component);
-
-    var resolve = function () {
-      renderNode(component._render(), true, context);
+    const cb = (err, res) => {
+        if (err)
+            return reject(err);
+        resolve(res || '');
     };
-    waitForServerPrefetch(component, resolve, done);
-  }
-}
-
-/*  */
-
-var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
-
-var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
-
-function createPromiseCallback () {
-  var resolve, reject;
-  var promise = new Promise(function (_resolve, _reject) {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  var cb = function (err, res) {
-    if (err) { return reject(err) }
-    resolve(res || '');
-  };
-  return { promise: promise, cb: cb }
+    return { promise, cb };
+}
+
+class TemplateStream extends stream.Transform {
+    started;
+    renderer;
+    template;
+    context;
+    inject;
+    constructor(renderer, template, context) {
+        super();
+        this.started = false;
+        this.renderer = renderer;
+        this.template = template;
+        this.context = context || {};
+        this.inject = renderer.inject;
+    }
+    _transform(data, encoding, done) {
+        if (!this.started) {
+            this.emit('beforeStart');
+            this.start();
+        }
+        this.push(data);
+        done();
+    }
+    start() {
+        this.started = true;
+        this.push(this.template.head(this.context));
+        if (this.inject) {
+            // inline server-rendered head meta information
+            if (this.context.head) {
+                this.push(this.context.head);
+            }
+            // inline preload/prefetch directives for initial/async chunks
+            const links = this.renderer.renderResourceHints(this.context);
+            if (links) {
+                this.push(links);
+            }
+            // CSS files and inline server-rendered CSS collected by vue-style-loader
+            const styles = this.renderer.renderStyles(this.context);
+            if (styles) {
+                this.push(styles);
+            }
+        }
+        this.push(this.template.neck(this.context));
+    }
+    _flush(done) {
+        this.emit('beforeEnd');
+        if (this.inject) {
+            // inline initial store state
+            const state = this.renderer.renderState(this.context);
+            if (state) {
+                this.push(state);
+            }
+            // embed scripts needed
+            const scripts = this.renderer.renderScripts(this.context);
+            if (scripts) {
+                this.push(scripts);
+            }
+        }
+        this.push(this.template.tail(this.context));
+        done();
+    }
 }
 
-/*  */
-
-var Transform = require('stream').Transform;
-
-
-
-var TemplateStream = /*@__PURE__*/(function (Transform) {
-  function TemplateStream (
-    renderer,
-    template,
-    context
-  ) {
-    Transform.call(this);
-    this.started = false;
-    this.renderer = renderer;
-    this.template = template;
-    this.context = context || {};
-    this.inject = renderer.inject;
-  }
-
-  if ( Transform ) TemplateStream.__proto__ = Transform;
-  TemplateStream.prototype = Object.create( Transform && Transform.prototype );
-  TemplateStream.prototype.constructor = TemplateStream;
-
-  TemplateStream.prototype._transform = function _transform (data, encoding, done) {
-    if (!this.started) {
-      this.emit('beforeStart');
-      this.start();
-    }
-    this.push(data);
-    done();
-  };
-
-  TemplateStream.prototype.start = function start () {
-    this.started = true;
-    this.push(this.template.head(this.context));
-
-    if (this.inject) {
-      // inline server-rendered head meta information
-      if (this.context.head) {
-        this.push(this.context.head);
-      }
-
-      // inline preload/prefetch directives for initial/async chunks
-      var links = this.renderer.renderResourceHints(this.context);
-      if (links) {
-        this.push(links);
-      }
-
-      // CSS files and inline server-rendered CSS collected by vue-style-loader
-      var styles = this.renderer.renderStyles(this.context);
-      if (styles) {
-        this.push(styles);
-      }
+const compile = require('lodash.template');
+const compileOptions = {
+    escape: /{{([^{][\s\S]+?[^}])}}/g,
+    interpolate: /{{{([\s\S]+?)}}}/g,
+};
+function parseTemplate(template, contentPlaceholder = '<!--vue-ssr-outlet-->') {
+    if (typeof template === 'object') {
+        return template;
     }
-
-    this.push(this.template.neck(this.context));
-  };
-
-  TemplateStream.prototype._flush = function _flush (done) {
-    this.emit('beforeEnd');
-
-    if (this.inject) {
-      // inline initial store state
-      var state = this.renderer.renderState(this.context);
-      if (state) {
-        this.push(state);
-      }
-
-      // embed scripts needed
-      var scripts = this.renderer.renderScripts(this.context);
-      if (scripts) {
-        this.push(scripts);
-      }
+    let i = template.indexOf('</head>');
+    const j = template.indexOf(contentPlaceholder);
+    if (j < 0) {
+        throw new Error(`Content placeholder not found in template.`);
     }
-
-    this.push(this.template.tail(this.context));
-    done();
-  };
-
-  return TemplateStream;
-}(Transform));
-
-/*  */
-
-var compile$1 = require('lodash.template');
-var compileOptions = {
-  escape: /{{([^{][\s\S]+?[^}])}}/g,
-  interpolate: /{{{([\s\S]+?)}}}/g
-};
-
-
-
-function parseTemplate (
-  template,
-  contentPlaceholder
-) {
-  if ( contentPlaceholder === void 0 ) contentPlaceholder = '<!--vue-ssr-outlet-->';
-
-  if (typeof template === 'object') {
-    return template
-  }
-
-  var i = template.indexOf('</head>');
-  var j = template.indexOf(contentPlaceholder);
-
-  if (j < 0) {
-    throw new Error("Content placeholder not found in template.")
-  }
-
-  if (i < 0) {
-    i = template.indexOf('<body>');
     if (i < 0) {
-      i = j;
+        i = template.indexOf('<body>');
+        if (i < 0) {
+            i = j;
+        }
     }
-  }
-
-  return {
-    head: compile$1(template.slice(0, i), compileOptions),
-    neck: compile$1(template.slice(i, j), compileOptions),
-    tail: compile$1(template.slice(j + contentPlaceholder.length), compileOptions)
-  }
+    return {
+        head: compile(template.slice(0, i), compileOptions),
+        neck: compile(template.slice(i, j), compileOptions),
+        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
+    };
 }
 
-/*  */
-
 /**
  * Creates a mapper that maps components used during a server-side render
  * to async chunk files in the client-side build, so that we can inline them
  * directly in the rendered HTML to avoid waterfall requests.
  */
-
-
-
-
-
-function createMapper (
-  clientManifest
-) {
-  var map = createMap(clientManifest);
-  // map server-side moduleIds to client-side files
-  return function mapper (moduleIds) {
-    var res = new Set();
-    for (var i = 0; i < moduleIds.length; i++) {
-      var mapped = map.get(moduleIds[i]);
-      if (mapped) {
-        for (var j = 0; j < mapped.length; j++) {
-          res.add(mapped[j]);
-        }
-      }
-    }
-    return Array.from(res)
-  }
-}
-
-function createMap (clientManifest) {
-  var map = new Map();
-  Object.keys(clientManifest.modules).forEach(function (id) {
-    map.set(id, mapIdToFile(id, clientManifest));
-  });
-  return map
-}
-
-function mapIdToFile (id, clientManifest) {
-  var files = [];
-  var fileIndices = clientManifest.modules[id];
-  if (fileIndices) {
-    fileIndices.forEach(function (index) {
-      var file = clientManifest.all[index];
-      // only include async files or non-js, non-css assets
-      if (
-        file &&
-        (clientManifest.async.indexOf(file) > -1 ||
-          !/\.(js|css)($|\?)/.test(file))
-      ) {
-        files.push(file);
-      }
-    });
-  }
-  return files
-}
-
-/*  */
-
-var path = require('path');
-var serialize = require('serialize-javascript');
-
-
-
-
-
-
-
-
-
-var TemplateRenderer = function TemplateRenderer (options) {
-  this.options = options;
-  this.inject = options.inject !== false;
-  // if no template option is provided, the renderer is created
-  // as a utility object for rendering assets like preload links and scripts.
-    
-  var template = options.template;
-  this.parsedTemplate = template
-    ? typeof template === 'string'
-      ? parseTemplate(template)
-      : template
-    : null;
-
-  // function used to serialize initial state JSON
-  this.serialize = options.serializer || (function (state) {
-    return serialize(state, { isJSON: true })
-  });
-
-  // extra functionality with client manifest
-  if (options.clientManifest) {
-    var clientManifest = this.clientManifest = options.clientManifest;
-    // ensure publicPath ends with /
-    this.publicPath = clientManifest.publicPath === ''
-      ? ''
-      : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-    // preload/prefetch directives
-    this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-    this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-    // initial async chunk mapping
-    this.mapFiles = createMapper(clientManifest);
-  }
-};
-
-TemplateRenderer.prototype.bindRenderFns = function bindRenderFns (context) {
-  var renderer = this
-  ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(function (type) {
-    context[("render" + type)] = renderer[("render" + type)].bind(renderer, context);
-  });
-  // also expose getPreloadFiles, useful for HTTP/2 push
-  context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
-};
-
-// render synchronously given rendered app content and render context
-TemplateRenderer.prototype.render = function render (content, context) {
-  var template = this.parsedTemplate;
-  if (!template) {
-    throw new Error('render cannot be called without a template.')
-  }
-  context = context || {};
-
-  if (typeof template === 'function') {
-    return template(content, context)
-  }
-
-  if (this.inject) {
-    return (
-      template.head(context) +
-      (context.head || '') +
-      this.renderResourceHints(context) +
-      this.renderStyles(context) +
-      template.neck(context) +
-      content +
-      this.renderState(context) +
-      this.renderScripts(context) +
-      template.tail(context)
-    )
-  } else {
-    return (
-      template.head(context) +
-      template.neck(context) +
-      content +
-      template.tail(context)
-    )
-  }
-};
-
-TemplateRenderer.prototype.renderStyles = function renderStyles (context) {
-    var this$1 = this;
-
-  var initial = this.preloadFiles || [];
-  var async = this.getUsedAsyncFiles(context) || [];
-  var cssFiles = initial.concat(async).filter(function (ref) {
-      var file = ref.file;
-
-      return isCSS(file);
-    });
-  return (
-    // render links for css files
-    (cssFiles.length
-      ? cssFiles.map(function (ref) {
-          var file = ref.file;
-
-          return ("<link rel=\"stylesheet\" href=\"" + (this$1.publicPath) + file + "\">");
-    }).join('')
-      : '') +
-    // context.styles is a getter exposed by vue-style-loader which contains
-    // the inline component styles collected during SSR
-    (context.styles || '')
-  )
-};
-
-TemplateRenderer.prototype.renderResourceHints = function renderResourceHints (context) {
-  return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context)
-};
-
-TemplateRenderer.prototype.getPreloadFiles = function getPreloadFiles (context) {
-  var usedAsyncFiles = this.getUsedAsyncFiles(context);
-  if (this.preloadFiles || usedAsyncFiles) {
-    return (this.preloadFiles || []).concat(usedAsyncFiles || [])
-  } else {
-    return []
-  }
-};
-
-TemplateRenderer.prototype.renderPreloadLinks = function renderPreloadLinks (context) {
-    var this$1 = this;
-
-  var files = this.getPreloadFiles(context);
-  var shouldPreload = this.options.shouldPreload;
-  if (files.length) {
-    return files.map(function (ref) {
-        var file = ref.file;
-        var extension = ref.extension;
-        var fileWithoutQuery = ref.fileWithoutQuery;
-        var asType = ref.asType;
-
-      var extra = '';
-      // by default, we only preload scripts or css
-      if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-        return ''
-      }
-      // user wants to explicitly control what to preload
-      if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-        return ''
-      }
-      if (asType === 'font') {
-        extra = " type=\"font/" + extension + "\" crossorigin";
-      }
-      return ("<link rel=\"preload\" href=\"" + (this$1.publicPath) + file + "\"" + (asType !== '' ? (" as=\"" + asType + "\"") : '') + extra + ">")
-    }).join('')
-  } else {
-    return ''
-  }
-};
-
-TemplateRenderer.prototype.renderPrefetchLinks = function renderPrefetchLinks (context) {
-    var this$1 = this;
-
-  var shouldPrefetch = this.options.shouldPrefetch;
-  if (this.prefetchFiles) {
-    var usedAsyncFiles = this.getUsedAsyncFiles(context);
-    var alreadyRendered = function (file) {
-      return usedAsyncFiles && usedAsyncFiles.some(function (f) { return f.file === file; })
+function createMapper(clientManifest) {
+    const map = createMap(clientManifest);
+    // map server-side moduleIds to client-side files
+    return function mapper(moduleIds) {
+        const res = new Set();
+        for (let i = 0; i < moduleIds.length; i++) {
+            const mapped = map.get(moduleIds[i]);
+            if (mapped) {
+                for (let j = 0; j < mapped.length; j++) {
+                    res.add(mapped[j]);
+                }
+            }
+        }
+        return Array.from(res);
     };
-    return this.prefetchFiles.map(function (ref) {
-        var file = ref.file;
-        var fileWithoutQuery = ref.fileWithoutQuery;
-        var asType = ref.asType;
-
-      if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-        return ''
-      }
-      if (alreadyRendered(file)) {
-        return ''
-      }
-      return ("<link rel=\"prefetch\" href=\"" + (this$1.publicPath) + file + "\">")
-    }).join('')
-  } else {
-    return ''
-  }
-};
-
-TemplateRenderer.prototype.renderState = function renderState (context, options) {
-  var ref = options || {};
-    var contextKey = ref.contextKey; if ( contextKey === void 0 ) contextKey = 'state';
-    var windowKey = ref.windowKey; if ( windowKey === void 0 ) windowKey = '__INITIAL_STATE__';
-  var state = this.serialize(context[contextKey]);
-  var autoRemove = '';
-  var nonceAttr = context.nonce ? (" nonce=\"" + (context.nonce) + "\"") : '';
-  return context[contextKey]
-    ? ("<script" + nonceAttr + ">window." + windowKey + "=" + state + autoRemove + "</script>")
-    : ''
-};
-
-TemplateRenderer.prototype.renderScripts = function renderScripts (context) {
-    var this$1 = this;
-
-  if (this.clientManifest) {
-    var initial = this.preloadFiles.filter(function (ref) {
-        var file = ref.file;
-
-        return isJS(file);
-      });
-    var async = (this.getUsedAsyncFiles(context) || []).filter(function (ref) {
-        var file = ref.file;
-
-        return isJS(file);
-      });
-    var needed = [initial[0]].concat(async, initial.slice(1));
-    return needed.map(function (ref) {
-        var file = ref.file;
-
-      return ("<script src=\"" + (this$1.publicPath) + file + "\" defer></script>")
-    }).join('')
-  } else {
-    return ''
-  }
-};
-
-TemplateRenderer.prototype.getUsedAsyncFiles = function getUsedAsyncFiles (context) {
-  if (!context._mappedFiles && context._registeredComponents && this.mapFiles) {
-    var registered = Array.from(context._registeredComponents);
-    context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-  }
-  return context._mappedFiles
-};
-
-// create a transform stream
-TemplateRenderer.prototype.createStream = function createStream (context) {
-  if (!this.parsedTemplate) {
-    throw new Error('createStream cannot be called without a template.')
-  }
-  return new TemplateStream(this, this.parsedTemplate, context || {})
-};
-
-function normalizeFile (file) {
-  var withoutQuery = file.replace(/\?.*/, '');
-  var extension = path.extname(withoutQuery).slice(1);
-  return {
-    file: file,
-    extension: extension,
-    fileWithoutQuery: withoutQuery,
-    asType: getPreloadType(extension)
-  }
 }
-
-function getPreloadType (ext) {
-  if (ext === 'js') {
-    return 'script'
-  } else if (ext === 'css') {
-    return 'style'
-  } else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
-    return 'image'
-  } else if (/woff2?|ttf|otf|eot/.test(ext)) {
-    return 'font'
-  } else {
-    // not exhausting all possibilities here, but above covers common cases
-    return ''
-  }
-}
-
-/*  */
-
-
-
-
-
-
-
-
-function createRenderer (ref) {
-  if ( ref === void 0 ) ref = {};
-  var modules = ref.modules; if ( modules === void 0 ) modules = [];
-  var directives = ref.directives; if ( directives === void 0 ) directives = {};
-  var isUnaryTag = ref.isUnaryTag; if ( isUnaryTag === void 0 ) isUnaryTag = (function () { return false; });
-  var template = ref.template;
-  var inject = ref.inject;
-  var cache = ref.cache;
-  var shouldPreload = ref.shouldPreload;
-  var shouldPrefetch = ref.shouldPrefetch;
-  var clientManifest = ref.clientManifest;
-  var serializer = ref.serializer;
-
-  var render = createRenderFunction(modules, directives, isUnaryTag, cache);
-  var templateRenderer = new TemplateRenderer({
-    template: template,
-    inject: inject,
-    shouldPreload: shouldPreload,
-    shouldPrefetch: shouldPrefetch,
-    clientManifest: clientManifest,
-    serializer: serializer
-  });
-
-  return {
-    renderToString: function renderToString (
-      component,
-      context,
-      cb
-    ) {
-      var assign;
-
-      if (typeof context === 'function') {
-        cb = context;
-        context = {};
-      }
-      if (context) {
-        templateRenderer.bindRenderFns(context);
-      }
-
-      // no callback, return Promise
-      var promise;
-      if (!cb) {
-        ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
-      }
-
-      var result = '';
-      var write = createWriteFunction(function (text) {
-        result += text;
-        return false
-      }, cb);
-      try {
-        render(component, write, context, function (err) {
-          if (err) {
-            return cb(err)
-          }
-          if (context && context.rendered) {
-            context.rendered(context);
-          }
-          if (template) {
-            try {
-              var res = templateRenderer.render(result, context);
-              if (typeof res !== 'string') {
-                // function template returning promise
-                res
-                  .then(function (html) { return cb(null, html); })
-                  .catch(cb);
-              } else {
-                cb(null, res);
-              }
-            } catch (e) {
-              cb(e);
-            }
-          } else {
-            cb(null, result);
-          }
+function createMap(clientManifest) {
+    const map = new Map();
+    Object.keys(clientManifest.modules).forEach((id) => {
+        map.set(id, mapIdToFile(id, clientManifest));
+    });
+    return map;
+}
+function mapIdToFile(id, clientManifest) {
+    const files = [];
+    const fileIndices = clientManifest.modules[id];
+    if (fileIndices) {
+        fileIndices.forEach((index) => {
+            const file = clientManifest.all[index];
+            // only include async files or non-js, non-css assets
+            if (file &&
+                (clientManifest.async.indexOf(file) > -1 ||
+                    !/\.(js|css)($|\?)/.test(file))) {
+                files.push(file);
+            }
         });
-      } catch (e) {
-        cb(e);
-      }
-
-      return promise
-    },
-
-    renderToStream: function renderToStream (
-      component,
-      context
-    ) {
-      if (context) {
-        templateRenderer.bindRenderFns(context);
-      }
-      var renderStream = new RenderStream(function (write, done) {
-        render(component, write, context, done);
-      });
-      if (!template) {
-        if (context && context.rendered) {
-          var rendered = context.rendered;
-          renderStream.once('beforeEnd', function () {
-            rendered(context);
-          });
-        }
-        return renderStream
-      } else if (typeof template === 'function') {
-        throw new Error("function template is only supported in renderToString.")
-      } else {
-        var templateStream = templateRenderer.createStream(context);
-        renderStream.on('error', function (err) {
-          templateStream.emit('error', err);
+    }
+    return files;
+}
+
+const path$2 = require('path');
+const serialize = require('serialize-javascript');
+class TemplateRenderer {
+    options;
+    inject;
+    parsedTemplate;
+    //@ts-expect-error
+    publicPath;
+    //@ts-expect-error
+    clientManifest;
+    //@ts-expect-error
+    preloadFiles;
+    //@ts-expect-error
+    prefetchFiles;
+    //@ts-expect-error
+    mapFiles;
+    serialize;
+    constructor(options) {
+        this.options = options;
+        this.inject = options.inject !== false;
+        // if no template option is provided, the renderer is created
+        // as a utility object for rendering assets like preload links and scripts.
+        const { template } = options;
+        this.parsedTemplate = template
+            ? typeof template === 'string'
+                ? parseTemplate(template)
+                : template
+            : null;
+        // function used to serialize initial state JSON
+        this.serialize =
+            options.serializer ||
+                ((state) => {
+                    return serialize(state, { isJSON: true });
+                });
+        // extra functionality with client manifest
+        if (options.clientManifest) {
+            const clientManifest = (this.clientManifest = options.clientManifest);
+            // ensure publicPath ends with /
+            this.publicPath =
+                clientManifest.publicPath === ''
+                    ? ''
+                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
+            // preload/prefetch directives
+            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
+            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
+            // initial async chunk mapping
+            this.mapFiles = createMapper(clientManifest);
+        }
+    }
+    bindRenderFns(context) {
+        const renderer = this;
+        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
+            context[`render${type}`] = renderer[`render${type}`].bind(renderer, context);
         });
-        renderStream.pipe(templateStream);
-        if (context && context.rendered) {
-          var rendered$1 = context.rendered;
-          renderStream.once('beforeEnd', function () {
-            rendered$1(context);
-          });
+        // also expose getPreloadFiles, useful for HTTP/2 push
+        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
+    }
+    // render synchronously given rendered app content and render context
+    render(content, context) {
+        const template = this.parsedTemplate;
+        if (!template) {
+            throw new Error('render cannot be called without a template.');
+        }
+        context = context || {};
+        if (typeof template === 'function') {
+            return template(content, context);
+        }
+        if (this.inject) {
+            return (template.head(context) +
+                (context.head || '') +
+                this.renderResourceHints(context) +
+                this.renderStyles(context) +
+                template.neck(context) +
+                content +
+                this.renderState(context) +
+                this.renderScripts(context) +
+                template.tail(context));
+        }
+        else {
+            return (template.head(context) +
+                template.neck(context) +
+                content +
+                template.tail(context));
         }
-        return templateStream
-      }
     }
-  }
-}
-
-var vm = require('vm');
-var path$1 = require('path');
-var resolve = require('resolve');
-var NativeModule = require('module');
-
-function createSandbox (context) {
-  var sandbox = {
-    Buffer: Buffer,
-    console: console,
-    process: process,
-    setTimeout: setTimeout,
-    setInterval: setInterval,
-    setImmediate: setImmediate,
-    clearTimeout: clearTimeout,
-    clearInterval: clearInterval,
-    clearImmediate: clearImmediate,
-    __VUE_SSR_CONTEXT__: context
-  };
-  sandbox.global = sandbox;
-  return sandbox
-}
-
-function compileModule (files, basedir, runInNewContext) {
-  var compiledScripts = {};
-  var resolvedModules = {};
-
-  function getCompiledScript (filename) {
-    if (compiledScripts[filename]) {
-      return compiledScripts[filename]
-    }
-    var code = files[filename];
-    var wrapper = NativeModule.wrap(code);
-    var script = new vm.Script(wrapper, {
-      filename: filename,
-      displayErrors: true
-    });
-    compiledScripts[filename] = script;
-    return script
-  }
-
-  function evaluateModule (filename, sandbox, evaluatedFiles) {
-    if ( evaluatedFiles === void 0 ) evaluatedFiles = {};
-
-    if (evaluatedFiles[filename]) {
-      return evaluatedFiles[filename]
+    renderStyles(context) {
+        const initial = this.preloadFiles || [];
+        const async = this.getUsedAsyncFiles(context) || [];
+        const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file));
+        return (
+        // render links for css files
+        (cssFiles.length
+            ? cssFiles
+                .map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`)
+                .join('')
+            : '') +
+            // context.styles is a getter exposed by vue-style-loader which contains
+            // the inline component styles collected during SSR
+            (context.styles || ''));
+    }
+    renderResourceHints(context) {
+        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
+    }
+    getPreloadFiles(context) {
+        const usedAsyncFiles = this.getUsedAsyncFiles(context);
+        if (this.preloadFiles || usedAsyncFiles) {
+            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
+        }
+        else {
+            return [];
+        }
     }
-
-    var script = getCompiledScript(filename);
-    var compiledWrapper = runInNewContext === false
-      ? script.runInThisContext()
-      : script.runInNewContext(sandbox);
-    var m = { exports: {}};
-    var r = function (file) {
-      file = path$1.posix.join('.', file);
-      if (files[file]) {
-        return evaluateModule(file, sandbox, evaluatedFiles)
-      } else if (basedir) {
-        return require(
-          resolvedModules[file] ||
-          (resolvedModules[file] = resolve.sync(file, { basedir: basedir }))
-        )
-      } else {
-        return require(file)
-      }
-    };
-    compiledWrapper.call(m.exports, m.exports, r, m);
-
-    var res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-      ? m.exports.default
-      : m.exports;
-    evaluatedFiles[filename] = res;
-    return res
-  }
-  return evaluateModule
-}
-
-function deepClone (val) {
-  if (isPlainObject(val)) {
-    var res = {};
-    for (var key in val) {
-      res[key] = deepClone(val[key]);
-    }
-    return res
-  } else if (Array.isArray(val)) {
-    return val.slice()
-  } else {
-    return val
-  }
-}
-
-function createBundleRunner (entry, files, basedir, runInNewContext) {
-  var evaluate = compileModule(files, basedir, runInNewContext);
-  if (runInNewContext !== false && runInNewContext !== 'once') {
-    // new context mode: creates a fresh context and re-evaluate the bundle
-    // on each render. Ensures entire application state is fresh for each
-    // render, but incurs extra evaluation cost.
-    return function (userContext) {
-      if ( userContext === void 0 ) userContext = {};
-
-      return new Promise(function (resolve) {
-      userContext._registeredComponents = new Set();
-      var res = evaluate(entry, createSandbox(userContext));
-      resolve(typeof res === 'function' ? res(userContext) : res);
-    });
+    renderPreloadLinks(context) {
+        const files = this.getPreloadFiles(context);
+        const shouldPreload = this.options.shouldPreload;
+        if (files.length) {
+            return files
+                .map(({ file, extension, fileWithoutQuery, asType }) => {
+                let extra = '';
+                // by default, we only preload scripts or css
+                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+                    return '';
+                }
+                // user wants to explicitly control what to preload
+                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (asType === 'font') {
+                    extra = ` type="font/${extension}" crossorigin`;
+                }
+                return `<link rel="preload" href="${this.publicPath}${file}"${asType !== '' ? ` as="${asType}"` : ''}${extra}>`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
     }
-  } else {
-    // direct mode: instead of re-evaluating the whole bundle on
-    // each render, it simply calls the exported function. This avoids the
-    // module evaluation costs but requires the source code to be structured
-    // slightly differently.
-    var runner; // lazy creation so that errors can be caught by user
-    var initialContext;
-    return function (userContext) {
-      if ( userContext === void 0 ) userContext = {};
-
-      return new Promise(function (resolve) {
-      if (!runner) {
-        var sandbox = runInNewContext === 'once'
-          ? createSandbox()
-          : global;
-        // the initial context is only used for collecting possible non-component
-        // styles injected by vue-style-loader.
-        initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
-        runner = evaluate(entry, sandbox);
-        // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-        // to prevent cross-request pollution.
-        delete sandbox.__VUE_SSR_CONTEXT__;
-        if (typeof runner !== 'function') {
-          throw new Error(
-            'bundle export should be a function when using ' +
-            '{ runInNewContext: false }.'
-          )
-        }
-      }
-      userContext._registeredComponents = new Set();
-
-      // vue-style-loader styles imported outside of component lifecycle hooks
-      if (initialContext._styles) {
-        userContext._styles = deepClone(initialContext._styles);
-        // #6353 ensure "styles" is exposed even if no styles are injected
-        // in component lifecycles.
-        // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-        var renderStyles = initialContext._renderStyles;
-        if (renderStyles) {
-          Object.defineProperty(userContext, 'styles', {
-            enumerable: true,
-            get: function get () {
-              return renderStyles(userContext._styles)
-            }
-          });
+    renderPrefetchLinks(context) {
+        const shouldPrefetch = this.options.shouldPrefetch;
+        if (this.prefetchFiles) {
+            const usedAsyncFiles = this.getUsedAsyncFiles(context);
+            const alreadyRendered = (file) => {
+                return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file);
+            };
+            return this.prefetchFiles
+                .map(({ file, fileWithoutQuery, asType }) => {
+                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (alreadyRendered(file)) {
+                    return '';
+                }
+                return `<link rel="prefetch" href="${this.publicPath}${file}">`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    renderState(context, options) {
+        const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } = options || {};
+        const state = this.serialize(context[contextKey]);
+        const autoRemove = '';
+        const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : '';
+        return context[contextKey]
+            ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
+            : '';
+    }
+    renderScripts(context) {
+        if (this.clientManifest) {
+            const initial = this.preloadFiles.filter(({ file }) => isJS(file));
+            const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file));
+            const needed = [initial[0]].concat(async, initial.slice(1));
+            return needed
+                .map(({ file }) => {
+                return `<script src="${this.publicPath}${file}" defer></script>`;
+            })
+                .join('');
+        }
+        else {
+            return '';
         }
-      }
-
-      resolve(runner(userContext));
-    });
     }
-  }
+    getUsedAsyncFiles(context) {
+        if (!context._mappedFiles &&
+            context._registeredComponents &&
+            this.mapFiles) {
+            const registered = Array.from(context._registeredComponents);
+            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
+        }
+        return context._mappedFiles;
+    }
+    // create a transform stream
+    createStream(context) {
+        if (!this.parsedTemplate) {
+            throw new Error('createStream cannot be called without a template.');
+        }
+        //@ts-expect-error
+        return new TemplateStream(this, this.parsedTemplate, context || {});
+    }
 }
-
-/*  */
-
-var SourceMapConsumer = require('source-map').SourceMapConsumer;
-
-var filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
-
-function createSourceMapConsumers (rawMaps) {
-  var maps = {};
-  Object.keys(rawMaps).forEach(function (file) {
-    maps[file] = new SourceMapConsumer(rawMaps[file]);
-  });
-  return maps
+function normalizeFile(file) {
+    const withoutQuery = file.replace(/\?.*/, '');
+    const extension = path$2.extname(withoutQuery).slice(1);
+    return {
+        file,
+        extension,
+        fileWithoutQuery: withoutQuery,
+        asType: getPreloadType(extension),
+    };
 }
-
-function rewriteErrorTrace (e, mapConsumers) {
-  if (e && typeof e.stack === 'string') {
-    e.stack = e.stack.split('\n').map(function (line) {
-      return rewriteTraceLine(line, mapConsumers)
-    }).join('\n');
-  }
+function getPreloadType(ext) {
+    if (ext === 'js') {
+        return 'script';
+    }
+    else if (ext === 'css') {
+        return 'style';
+    }
+    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
+        return 'image';
+    }
+    else if (/woff2?|ttf|otf|eot/.test(ext)) {
+        return 'font';
+    }
+    else {
+        // not exhausting all possibilities here, but above covers common cases
+        return '';
+    }
 }
 
-function rewriteTraceLine (trace, mapConsumers) {
-  var m = trace.match(filenameRE);
-  var map = m && mapConsumers[m[1]];
-  if (m != null && map) {
-    var originalPosition = map.originalPositionFor({
-      line: Number(m[2]),
-      column: Number(m[3])
+function createRenderer$1({ modules = [], directives = {}, isUnaryTag = () => false, template, inject, cache, shouldPreload, shouldPrefetch, clientManifest, serializer, } = {}) {
+    const render = createRenderFunction(modules, directives, isUnaryTag, cache);
+    const templateRenderer = new TemplateRenderer({
+        template,
+        inject,
+        // @ts-expect-error
+        shouldPreload,
+        // @ts-expect-error
+        shouldPrefetch,
+        clientManifest,
+        serializer,
     });
-    if (originalPosition.source != null) {
-      var source = originalPosition.source;
-      var line = originalPosition.line;
-      var column = originalPosition.column;
-      var mappedPosition = "(" + (source.replace(/^webpack:\/\/\//, '')) + ":" + (String(line)) + ":" + (String(column)) + ")";
-      return trace.replace(filenameRE, mappedPosition)
-    } else {
-      return trace
-    }
-  } else {
-    return trace
-  }
+    return {
+        renderToString(component, context, cb) {
+            if (typeof context === 'function') {
+                cb = context;
+                context = {};
+            }
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            // no callback, return Promise
+            let promise;
+            if (!cb) {
+                ({ promise, cb } = createPromiseCallback());
+            }
+            let result = '';
+            const write = createWriteFunction((text) => {
+                result += text;
+                return false;
+            }, cb);
+            try {
+                // @ts-expect-error TODO improve
+                render(component, write, context, (err) => {
+                    if (err) {
+                        return cb(err);
+                    }
+                    if (context && context.rendered) {
+                        context.rendered(context);
+                    }
+                    if (template) {
+                        try {
+                            const res = templateRenderer.render(result, context);
+                            if (typeof res !== 'string') {
+                                // function template returning promise
+                                res.then((html) => cb(null, html)).catch(cb);
+                            }
+                            else {
+                                cb(null, res);
+                            }
+                        }
+                        catch (e) {
+                            cb(e);
+                        }
+                    }
+                    else {
+                        cb(null, result);
+                    }
+                });
+            }
+            catch (e) {
+                cb(e);
+            }
+            return promise;
+        },
+        renderToStream(component, context) {
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            const renderStream = new RenderStream((write, done) => {
+                // @ts-expect-error
+                render(component, write, context, done);
+            });
+            if (!template) {
+                // @ts-expect-error
+                if (context && context.rendered) {
+                    // @ts-expect-error
+                    const rendered = context.rendered;
+                    renderStream.once('beforeEnd', () => {
+                        rendered(context);
+                    });
+                }
+                return renderStream;
+            }
+            else if (typeof template === 'function') {
+                throw new Error(`function template is only supported in renderToString.`);
+            }
+            else {
+                const templateStream = templateRenderer.createStream(context);
+                renderStream.on('error', (err) => {
+                    templateStream.emit('error', err);
+                });
+                renderStream.pipe(templateStream);
+                //@ts-expect-error
+                if (context && context.rendered) {
+                    //@ts-expect-error
+                    const rendered = context.rendered;
+                    renderStream.once('beforeEnd', () => {
+                        rendered(context);
+                    });
+                }
+                return templateStream;
+            }
+        },
+    };
 }
 
-/*  */
-
-var fs = require('fs');
-var path$2 = require('path');
-var PassThrough = require('stream').PassThrough;
-
-var INVALID_MSG =
-  'Invalid server-rendering bundle format. Should be a string ' +
-  'or a bundle Object of type:\n\n' +
-"{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";
-
-// The render bundle can either be a string (single bundled file)
-// or a bundle manifest object generated by vue-ssr-webpack-plugin.
-
-
-function createBundleRendererCreator (
-  createRenderer
-) {
-  return function createBundleRenderer (
-    bundle,
-    rendererOptions
-  ) {
-    if ( rendererOptions === void 0 ) rendererOptions = {};
-
-    var files, entry, maps;
-    var basedir = rendererOptions.basedir;
-
-    // load bundle if given filepath
-    if (
-      typeof bundle === 'string' &&
-      /\.js(on)?$/.test(bundle) &&
-      path$2.isAbsolute(bundle)
-    ) {
-      if (fs.existsSync(bundle)) {
-        var isJSON = /\.json$/.test(bundle);
-        basedir = basedir || path$2.dirname(bundle);
-        bundle = fs.readFileSync(bundle, 'utf-8');
-        if (isJSON) {
-          try {
-            bundle = JSON.parse(bundle);
-          } catch (e) {
-            throw new Error(("Invalid JSON bundle file: " + bundle))
-          }
-        }
-      } else {
-        throw new Error(("Cannot locate bundle file: " + bundle))
-      }
-    }
-
-    if (typeof bundle === 'object') {
-      entry = bundle.entry;
-      files = bundle.files;
-      basedir = basedir || bundle.basedir;
-      maps = createSourceMapConsumers(bundle.maps);
-      if (typeof entry !== 'string' || typeof files !== 'object') {
-        throw new Error(INVALID_MSG)
-      }
-    } else if (typeof bundle === 'string') {
-      entry = '__vue_ssr_bundle__';
-      files = { '__vue_ssr_bundle__': bundle };
-      maps = {};
-    } else {
-      throw new Error(INVALID_MSG)
+const vm = require('vm');
+const path$1 = require('path');
+const resolve = require('resolve');
+const NativeModule = require('module');
+function createSandbox(context) {
+    const sandbox = {
+        Buffer,
+        console,
+        process,
+        setTimeout,
+        setInterval,
+        setImmediate,
+        clearTimeout,
+        clearInterval,
+        clearImmediate,
+        __VUE_SSR_CONTEXT__: context,
+    };
+    // @ts-expect-error
+    sandbox.global = sandbox;
+    return sandbox;
+}
+function compileModule(files, basedir, runInNewContext) {
+    const compiledScripts = {};
+    const resolvedModules = {};
+    function getCompiledScript(filename) {
+        if (compiledScripts[filename]) {
+            return compiledScripts[filename];
+        }
+        const code = files[filename];
+        const wrapper = NativeModule.wrap(code);
+        const script = new vm.Script(wrapper, {
+            filename,
+            displayErrors: true,
+        });
+        compiledScripts[filename] = script;
+        return script;
     }
-
-    var renderer = createRenderer(rendererOptions);
-
-    var run = createBundleRunner(
-      entry,
-      files,
-      basedir,
-      rendererOptions.runInNewContext
-    );
-
-    return {
-      renderToString: function (context, cb) {
-        var assign;
-
-        if (typeof context === 'function') {
-          cb = context;
-          context = {};
+    function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
+        if (evaluatedFiles[filename]) {
+            return evaluatedFiles[filename];
         }
-
-        var promise;
-        if (!cb) {
-          ((assign = createPromiseCallback(), promise = assign.promise, cb = assign.cb));
+        const script = getCompiledScript(filename);
+        const compiledWrapper = runInNewContext === false
+            ? script.runInThisContext()
+            : script.runInNewContext(sandbox);
+        const m = { exports: {} };
+        const r = (file) => {
+            file = path$1.posix.join('.', file);
+            if (files[file]) {
+                return evaluateModule(file, sandbox, evaluatedFiles);
+            }
+            else if (basedir) {
+                return require(resolvedModules[file] ||
+                    (resolvedModules[file] = resolve.sync(file, { basedir })));
+            }
+            else {
+                return require(file);
+            }
+        };
+        compiledWrapper.call(m.exports, m.exports, r, m);
+        const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
+            ? // @ts-expect-error
+                m.exports.default
+            : m.exports;
+        evaluatedFiles[filename] = res;
+        return res;
+    }
+    return evaluateModule;
+}
+function deepClone(val) {
+    if (isPlainObject(val)) {
+        const res = {};
+        for (const key in val) {
+            res[key] = deepClone(val[key]);
         }
-
-        run(context).catch(function (err) {
-          rewriteErrorTrace(err, maps);
-          cb(err);
-        }).then(function (app) {
-          if (app) {
-            renderer.renderToString(app, context, function (err, res) {
-              rewriteErrorTrace(err, maps);
-              cb(err, res);
-            });
-          }
+        return res;
+    }
+    else if (Array.isArray(val)) {
+        return val.slice();
+    }
+    else {
+        return val;
+    }
+}
+function createBundleRunner(entry, files, basedir, runInNewContext) {
+    const evaluate = compileModule(files, basedir, runInNewContext);
+    if (runInNewContext !== false && runInNewContext !== 'once') {
+        // new context mode: creates a fresh context and re-evaluate the bundle
+        // on each render. Ensures entire application state is fresh for each
+        // render, but incurs extra evaluation cost.
+        return (userContext = {}) => new Promise((resolve) => {
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            const res = evaluate(entry, createSandbox(userContext));
+            resolve(typeof res === 'function' ? res(userContext) : res);
         });
-
-        return promise
-      },
-
-      renderToStream: function (context) {
-        var res = new PassThrough();
-        run(context).catch(function (err) {
-          rewriteErrorTrace(err, maps);
-          // avoid emitting synchronously before user can
-          // attach error listener
-          process.nextTick(function () {
-            res.emit('error', err);
-          });
-        }).then(function (app) {
-          if (app) {
-            var renderStream = renderer.renderToStream(app, context);
-
-            renderStream.on('error', function (err) {
-              rewriteErrorTrace(err, maps);
-              res.emit('error', err);
-            });
-
-            // relay HTMLStream special events
-            if (rendererOptions && rendererOptions.template) {
-              renderStream.on('beforeStart', function () {
-                res.emit('beforeStart');
-              });
-              renderStream.on('beforeEnd', function () {
-                res.emit('beforeEnd');
-              });
+    }
+    else {
+        // direct mode: instead of re-evaluating the whole bundle on
+        // each render, it simply calls the exported function. This avoids the
+        // module evaluation costs but requires the source code to be structured
+        // slightly differently.
+        let runner; // lazy creation so that errors can be caught by user
+        let initialContext;
+        return (userContext = {}) => new Promise((resolve) => {
+            if (!runner) {
+                const sandbox = runInNewContext === 'once' ? createSandbox() : global;
+                // the initial context is only used for collecting possible non-component
+                // styles injected by vue-style-loader.
+                // @ts-expect-error
+                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
+                runner = evaluate(entry, sandbox);
+                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+                // to prevent cross-request pollution.
+                // @ts-expect-error
+                delete sandbox.__VUE_SSR_CONTEXT__;
+                if (typeof runner !== 'function') {
+                    throw new Error('bundle export should be a function when using ' +
+                        '{ runInNewContext: false }.');
+                }
             }
-
-            renderStream.pipe(res);
-          }
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            // vue-style-loader styles imported outside of component lifecycle hooks
+            if (initialContext._styles) {
+                // @ts-expect-error
+                userContext._styles = deepClone(initialContext._styles);
+                // #6353 ensure "styles" is exposed even if no styles are injected
+                // in component lifecycles.
+                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+                const renderStyles = initialContext._renderStyles;
+                if (renderStyles) {
+                    Object.defineProperty(userContext, 'styles', {
+                        enumerable: true,
+                        get() {
+                            // @ts-expect-error
+                            return renderStyles(userContext._styles);
+                        },
+                    });
+                }
+            }
+            resolve(runner(userContext));
         });
-
-        return res
-      }
     }
-  }
 }
 
-/*  */
-
-process.env.VUE_ENV = 'server';
-
-function createRenderer$1 (options) {
-  if ( options === void 0 ) options = {};
-
-  return createRenderer(extend(extend({}, options), {
-    isUnaryTag: isUnaryTag,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    modules: modules,
-    // user can provide server-side implementations for custom directives
-    // when creating the renderer.
-    directives: extend(baseDirectives, options.directives)
-  }))
+const SourceMapConsumer = require('source-map').SourceMapConsumer;
+const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
+function createSourceMapConsumers(rawMaps) {
+    const maps = {};
+    Object.keys(rawMaps).forEach((file) => {
+        maps[file] = new SourceMapConsumer(rawMaps[file]);
+    });
+    return maps;
+}
+function rewriteErrorTrace(e, mapConsumers) {
+    if (e && typeof e.stack === 'string') {
+        e.stack = e.stack
+            .split('\n')
+            .map((line) => {
+            return rewriteTraceLine(line, mapConsumers);
+        })
+            .join('\n');
+    }
+}
+function rewriteTraceLine(trace, mapConsumers) {
+    const m = trace.match(filenameRE);
+    const map = m && mapConsumers[m[1]];
+    if (m != null && map) {
+        const originalPosition = map.originalPositionFor({
+            line: Number(m[2]),
+            column: Number(m[3]),
+        });
+        if (originalPosition.source != null) {
+            const { source, line, column } = originalPosition;
+            const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`;
+            return trace.replace(filenameRE, mappedPosition);
+        }
+        else {
+            return trace;
+        }
+    }
+    else {
+        return trace;
+    }
+}
+
+const fs = require('fs');
+const path = require('path');
+const PassThrough = require('stream').PassThrough;
+const INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
+    'or a bundle Object of type:\n\n' +
+    `{
+  entry: string;
+  files: { [filename: string]: string; };
+  maps: { [filename: string]: string; };
+}\n`;
+function createBundleRendererCreator(createRenderer) {
+    return function createBundleRenderer(bundle, rendererOptions = {}) {
+        let files, entry, maps;
+        let basedir = rendererOptions.basedir;
+        // load bundle if given filepath
+        if (typeof bundle === 'string' &&
+            /\.js(on)?$/.test(bundle) &&
+            path.isAbsolute(bundle)) {
+            if (fs.existsSync(bundle)) {
+                const isJSON = /\.json$/.test(bundle);
+                basedir = basedir || path.dirname(bundle);
+                bundle = fs.readFileSync(bundle, 'utf-8');
+                if (isJSON) {
+                    try {
+                        // @ts-expect-error
+                        bundle = JSON.parse(bundle);
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid JSON bundle file: ${bundle}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Cannot locate bundle file: ${bundle}`);
+            }
+        }
+        if (typeof bundle === 'object') {
+            entry = bundle.entry;
+            files = bundle.files;
+            basedir = basedir || bundle.basedir;
+            maps = createSourceMapConsumers(bundle.maps);
+            if (typeof entry !== 'string' || typeof files !== 'object') {
+                throw new Error(INVALID_MSG);
+            }
+        }
+        else if (typeof bundle === 'string') {
+            entry = '__vue_ssr_bundle__';
+            files = { __vue_ssr_bundle__: bundle };
+            maps = {};
+        }
+        else {
+            throw new Error(INVALID_MSG);
+        }
+        const renderer = createRenderer(rendererOptions);
+        const run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
+        return {
+            renderToString: (context, cb) => {
+                if (typeof context === 'function') {
+                    cb = context;
+                    context = {};
+                }
+                let promise;
+                if (!cb) {
+                    ({ promise, cb } = createPromiseCallback());
+                }
+                run(context)
+                    .catch((err) => {
+                    rewriteErrorTrace(err, maps);
+                    cb(err);
+                })
+                    .then((app) => {
+                    if (app) {
+                        //@ts-expect-error
+                        renderer.renderToString(app, context, (err, res) => {
+                            rewriteErrorTrace(err, maps);
+                            cb(err, res);
+                        });
+                    }
+                });
+                return promise;
+            },
+            renderToStream: (context) => {
+                const res = new PassThrough();
+                run(context)
+                    .catch((err) => {
+                    rewriteErrorTrace(err, maps);
+                    // avoid emitting synchronously before user can
+                    // attach error listener
+                    process.nextTick(() => {
+                        res.emit('error', err);
+                    });
+                })
+                    .then((app) => {
+                    if (app) {
+                        //@ts-expect-error
+                        const renderStream = renderer.renderToStream(app, context);
+                        renderStream.on('error', (err) => {
+                            rewriteErrorTrace(err, maps);
+                            res.emit('error', err);
+                        });
+                        // relay HTMLStream special events
+                        if (rendererOptions && rendererOptions.template) {
+                            renderStream.on('beforeStart', () => {
+                                res.emit('beforeStart');
+                            });
+                            renderStream.on('beforeEnd', () => {
+                                res.emit('beforeEnd');
+                            });
+                        }
+                        renderStream.pipe(res);
+                    }
+                });
+                return res;
+            },
+        };
+    };
 }
 
-var createBundleRenderer = createBundleRendererCreator(createRenderer$1);
+process.env.VUE_ENV = 'server';
+function createRenderer(options = {}) {
+    return createRenderer$1(extend(extend({}, options), {
+        isUnaryTag,
+        canBeLeftOpenTag,
+        modules: modules$1,
+        // user can provide server-side implementations for custom directives
+        // when creating the renderer.
+        directives: extend(baseDirectives$1, options.directives),
+    }));
+}
+const createBundleRenderer = createBundleRendererCreator(createRenderer);
 
-exports.createRenderer = createRenderer$1;
 exports.createBundleRenderer = createBundleRenderer;
+exports.createRenderer = createRenderer;
diff --git a/packages/vue-server-renderer/build.prod.js b/packages/vue-server-renderer/build.prod.js
index 01a786d489f..76d741da6b6 100644
--- a/packages/vue-server-renderer/build.prod.js
+++ b/packages/vue-server-renderer/build.prod.js
@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e,t=(e=require("he"))&&"object"==typeof e&&"default"in e?e.default:e,r=Object.freeze({});function n(e){return null==e}function i(e){return null!=e}function o(e){return!0===e}function a(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function s(e){return null!==e&&"object"==typeof e}var c=Object.prototype.toString;function u(e){return"[object Object]"===c.call(e)}function l(e){return i(e)&&"function"==typeof e.then&&"function"==typeof e.catch}function f(e){return null==e?"":Array.isArray(e)||u(e)&&e.toString===c?JSON.stringify(e,null,2):String(e)}function p(e){var t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){for(var r=Object.create(null),n=e.split(","),i=0;i<n.length;i++)r[n[i]]=!0;return t?function(e){return r[e.toLowerCase()]}:function(e){return r[e]}}var v=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(e,t){if(e.length){var r=e.indexOf(t);if(r>-1)return e.splice(r,1)}}var y=Object.prototype.hasOwnProperty;function g(e,t){return y.call(e,t)}function b(e){var t=Object.create(null);return function(r){return t[r]||(t[r]=e(r))}}var _=/-(\w)/g,w=b(function(e){return e.replace(_,function(e,t){return t?t.toUpperCase():""})}),x=b(function(e){return e.charAt(0).toUpperCase()+e.slice(1)}),S=/\B([A-Z])/g,$=b(function(e){return e.replace(S,"-$1").toLowerCase()});Function.prototype.bind;function A(e,t){for(var r in t)e[r]=t[r];return e}function O(e){for(var t={},r=0;r<e.length;r++)e[r]&&A(t,e[r]);return t}function k(e,t,r){}var C=function(e,t,r){return!1},T=function(e){return e};function F(e,t){if(e===t)return!0;var r=s(e),n=s(t);if(!r||!n)return!r&&!n&&String(e)===String(t);try{var i=Array.isArray(e),o=Array.isArray(t);if(i&&o)return e.length===t.length&&e.every(function(e,r){return F(e,t[r])});if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(i||o)return!1;var a=Object.keys(e),c=Object.keys(t);return a.length===c.length&&a.every(function(r){return F(e[r],t[r])})}catch(e){return!1}}function j(e,t){for(var r=0;r<e.length;r++)if(F(e[r],t))return r;return-1}function P(e){var t=!1;return function(){t||(t=!0,e.apply(this,arguments))}}var E=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),N=/[>/="'\u0009\u000a\u000c\u0020]/,L=function(e){return N.test(e)},I=function(e){return E(e)||0===e.indexOf("data-")||0===e.indexOf("aria-")},M={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},R={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function D(e){return e.replace(/[<>"&]/g,U)}function U(e){return R[e]||e}var z={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},B=d("input,textarea,option,select,progress"),q=d("contenteditable,draggable,spellcheck"),J=d("events,caret,typing,plaintext-only"),H=function(e,t){return V(t)||"false"===t?"false":"contenteditable"===e&&J(t)?t:"true"},K=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),V=function(e){return null==e||!1===e};function W(e,t){if(K(e)){if(!V(t))return" "+e+'="'+e+'"'}else{if(q(e))return" "+e+'="'+D(H(e,t))+'"';if(!V(t))return" "+e+'="'+D(String(t))+'"'}return""}var Z=function(e,t,r,n,i,o,a,s){this.tag=e,this.data=t,this.children=r,this.text=n,this.elm=i,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=a,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=s,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1},X={child:{configurable:!0}};X.child.get=function(){return this.componentInstance},Object.defineProperties(Z.prototype,X);var G=function(e){void 0===e&&(e="");var t=new Z;return t.text=e,t.isComment=!0,t};function Q(e){return new Z(void 0,void 0,void 0,String(e))}function Y(e,t,r){var n=new Z(void 0,void 0,void 0,t);n.raw=r,e.children=[n]}function ee(e,t,r,n){Object.defineProperty(e,t,{value:r,enumerable:!!n,writable:!0,configurable:!0})}var te,re="__proto__"in{},ne="undefined"!=typeof window,ie="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,oe=ie&&WXEnvironment.platform.toLowerCase(),ae=ne&&window.navigator.userAgent.toLowerCase(),se=ae&&/msie|trident/.test(ae),ce=(ae&&ae.indexOf("msie 9.0"),ae&&ae.indexOf("edge/")>0),ue=(ae&&ae.indexOf("android"),ae&&/iphone|ipad|ipod|ios/.test(ae),ae&&/chrome\/\d+/.test(ae),ae&&/phantomjs/.test(ae),ae&&ae.match(/firefox\/(\d+)/),{}.watch);if(ne)try{var le={};Object.defineProperty(le,"passive",{get:function(){}}),window.addEventListener("test-passive",null,le)}catch(e){}var fe=function(){return void 0===te&&(te=!ne&&!ie&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),te};ne&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function pe(e){return"function"==typeof e&&/native code/.test(e.toString())}var de,ve="undefined"!=typeof Symbol&&pe(Symbol)&&"undefined"!=typeof Reflect&&pe(Reflect.ownKeys);de="undefined"!=typeof Set&&pe(Set)?Set:function(){function e(){this.set=Object.create(null)}return e.prototype.has=function(e){return!0===this.set[e]},e.prototype.add=function(e){this.set[e]=!0},e.prototype.clear=function(){this.set=Object.create(null)},e}();var he="data-server-rendered",me=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"],ye={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:C,isReservedAttr:C,isUnknownElement:C,getTagNamespace:k,parsePlatformTagName:T,mustUseProp:C,async:!0,_lifecycleHooks:me},ge=k,be=0,_e=function(){this.id=be++,this.subs=[]};_e.prototype.addSub=function(e){this.subs.push(e)},_e.prototype.removeSub=function(e){m(this.subs,e)},_e.prototype.depend=function(){_e.target&&_e.target.addDep(this)},_e.prototype.notify=function(){for(var e=this.subs.slice(),t=0,r=e.length;t<r;t++)e[t].update()},_e.target=null;var we=[];function xe(e){we.push(e),_e.target=e}function Se(){we.pop(),_e.target=we[we.length-1]}var $e=Array.prototype,Ae=Object.create($e);["push","pop","shift","unshift","splice","sort","reverse"].forEach(function(e){var t=$e[e];ee(Ae,e,function(){for(var r=[],n=arguments.length;n--;)r[n]=arguments[n];var i,o=t.apply(this,r),a=this.__ob__;switch(e){case"push":case"unshift":i=r;break;case"splice":i=r.slice(2)}return i&&a.observeArray(i),a.dep.notify(),o})});var Oe=Object.getOwnPropertyNames(Ae),ke=!0;function Ce(e){ke=e}var Te=function(e){var t;this.value=e,this.dep=new _e,this.vmCount=0,ee(e,"__ob__",this),Array.isArray(e)?(re?(t=Ae,e.__proto__=t):function(e,t,r){for(var n=0,i=r.length;n<i;n++){var o=r[n];ee(e,o,t[o])}}(e,Ae,Oe),this.observeArray(e)):this.walk(e)};function Fe(e,t){var r;if(s(e)&&!(e instanceof Z))return g(e,"__ob__")&&e.__ob__ instanceof Te?r=e.__ob__:ke&&!fe()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(r=new Te(e)),t&&r&&r.vmCount++,r}function je(e,t,r,n,i){var o=new _e,a=Object.getOwnPropertyDescriptor(e,t);if(!a||!1!==a.configurable){var s=a&&a.get,c=a&&a.set;s&&!c||2!==arguments.length||(r=e[t]);var u=!i&&Fe(r);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){var t=s?s.call(e):r;return _e.target&&(o.depend(),u&&(u.dep.depend(),Array.isArray(t)&&function e(t){for(var r=void 0,n=0,i=t.length;n<i;n++)(r=t[n])&&r.__ob__&&r.__ob__.dep.depend(),Array.isArray(r)&&e(r)}(t))),t},set:function(t){var n=s?s.call(e):r;t===n||t!=t&&n!=n||s&&!c||(c?c.call(e,t):r=t,u=!i&&Fe(t),o.notify())}})}}function Pe(e,t,r){if(Array.isArray(e)&&function(e){var t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,r),r;if(t in e&&!(t in Object.prototype))return e[t]=r,r;var n=e.__ob__;return e._isVue||n&&n.vmCount?r:n?(je(n.value,t,r),n.dep.notify(),r):(e[t]=r,r)}Te.prototype.walk=function(e){for(var t=Object.keys(e),r=0;r<t.length;r++)je(e,t[r])},Te.prototype.observeArray=function(e){for(var t=0,r=e.length;t<r;t++)Fe(e[t])};var Ee=ye.optionMergeStrategies;function Ne(e,t){if(!t)return e;for(var r,n,i,o=ve?Reflect.ownKeys(t):Object.keys(t),a=0;a<o.length;a++)"__ob__"!==(r=o[a])&&(n=e[r],i=t[r],g(e,r)?n!==i&&u(n)&&u(i)&&Ne(n,i):Pe(e,r,i));return e}function Le(e,t,r){return r?function(){var n="function"==typeof t?t.call(r,r):t,i="function"==typeof e?e.call(r,r):e;return n?Ne(n,i):i}:t?e?function(){return Ne("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Ie(e,t){var r=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return r?function(e){for(var t=[],r=0;r<e.length;r++)-1===t.indexOf(e[r])&&t.push(e[r]);return t}(r):r}function Me(e,t,r,n){var i=Object.create(e||null);return t?A(i,t):i}Ee.data=function(e,t,r){return r?Le(e,t,r):t&&"function"!=typeof t?e:Le(e,t)},me.forEach(function(e){Ee[e]=Ie}),["component","directive","filter"].forEach(function(e){Ee[e+"s"]=Me}),Ee.watch=function(e,t,r,n){if(e===ue&&(e=void 0),t===ue&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;var i={};for(var o in A(i,e),t){var a=i[o],s=t[o];a&&!Array.isArray(a)&&(a=[a]),i[o]=a?a.concat(s):Array.isArray(s)?s:[s]}return i},Ee.props=Ee.methods=Ee.inject=Ee.computed=function(e,t,r,n){if(!e)return t;var i=Object.create(null);return A(i,e),t&&A(i,t),i},Ee.provide=Le;var Re=function(e,t){return void 0===t?e:t};function De(e,t,r){if("function"==typeof t&&(t=t.options),function(e,t){var r=e.props;if(r){var n,i,o={};if(Array.isArray(r))for(n=r.length;n--;)"string"==typeof(i=r[n])&&(o[w(i)]={type:null});else if(u(r))for(var a in r)i=r[a],o[w(a)]=u(i)?i:{type:i};e.props=o}}(t),function(e,t){var r=e.inject;if(r){var n=e.inject={};if(Array.isArray(r))for(var i=0;i<r.length;i++)n[r[i]]={from:r[i]};else if(u(r))for(var o in r){var a=r[o];n[o]=u(a)?A({from:o},a):{from:a}}}}(t),function(e){var t=e.directives;if(t)for(var r in t){var n=t[r];"function"==typeof n&&(t[r]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=De(e,t.extends,r)),t.mixins))for(var n=0,i=t.mixins.length;n<i;n++)e=De(e,t.mixins[n],r);var o,a={};for(o in e)s(o);for(o in t)g(e,o)||s(o);function s(n){var i=Ee[n]||Re;a[n]=i(e[n],t[n],r,n)}return a}function Ue(e,t,r,n){if("string"==typeof r){var i=e[t];if(g(i,r))return i[r];var o=w(r);if(g(i,o))return i[o];var a=x(o);return g(i,a)?i[a]:i[r]||i[o]||i[a]}}function ze(e,t,r,n){var i=t[e],o=!g(r,e),a=r[e],s=He(Boolean,i.type);if(s>-1)if(o&&!g(i,"default"))a=!1;else if(""===a||a===$(e)){var c=He(String,i.type);(c<0||s<c)&&(a=!0)}if(void 0===a){a=function(e,t,r){if(!g(t,"default"))return;var n=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[r]&&void 0!==e._props[r])return e._props[r];return"function"==typeof n&&"Function"!==qe(t.type)?n.call(e):n}(n,i,e);var u=ke;Ce(!0),Fe(a),Ce(u)}return a}var Be=/^\s*function (\w+)/;function qe(e){var t=e&&e.toString().match(Be);return t?t[1]:""}function Je(e,t){return qe(e)===qe(t)}function He(e,t){if(!Array.isArray(t))return Je(t,e)?0:-1;for(var r=0,n=t.length;r<n;r++)if(Je(t[r],e))return r;return-1}function Ke(e,t,r){xe();try{if(t)for(var n=t;n=n.$parent;){var i=n.$options.errorCaptured;if(i)for(var o=0;o<i.length;o++)try{if(!1===i[o].call(n,e,t,r))return}catch(e){We(e,n,"errorCaptured hook")}}We(e,t,r)}finally{Se()}}function Ve(e,t,r,n,i){var o;try{(o=r?e.apply(t,r):e.call(t))&&!o._isVue&&l(o)&&!o._handled&&(o.catch(function(e){return Ke(e,n,i+" (Promise/async)")}),o._handled=!0)}catch(e){Ke(e,n,i)}return o}function We(e,t,r){!function(e,t,r){if(!ne&&!ie||"undefined"==typeof console)throw e;console.error(e)}(e)}var Ze=[];if("undefined"!=typeof Promise&&pe(Promise));else if(se||"undefined"==typeof MutationObserver||!pe(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&pe(setImmediate);else{var Xe=new MutationObserver(function(){var e=Ze.slice(0);Ze.length=0;for(var t=0;t<e.length;t++)e[t]()}),Ge=document.createTextNode(String(1));Xe.observe(Ge,{characterData:!0})}function Qe(e,t){return{staticClass:et(e.staticClass,t.staticClass),class:i(e.class)?[e.class,t.class]:t.class}}function Ye(e,t){return i(e)||i(t)?et(e,tt(t)):""}function et(e,t){return e?t?e+" "+t:e:t||""}function tt(e){return Array.isArray(e)?function(e){for(var t,r="",n=0,o=e.length;n<o;n++)i(t=tt(e[n]))&&""!==t&&(r&&(r+=" "),r+=t);return r}(e):s(e)?function(e){var t="";for(var r in e)e[r]&&(t&&(t+=" "),t+=r);return t}(e):"string"==typeof e?e:""}var rt=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),nt=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);var it=b(function(e){var t={},r=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach(function(e){if(e){var n=e.split(r);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t});function ot(e){var t=at(e.style);return e.staticStyle?A(e.staticStyle,t):t}function at(e){return Array.isArray(e)?O(e):"string"==typeof e?it(e):e}function st(e){var t="";for(var r in e){var n=e[r],i=$(r);if(Array.isArray(n))for(var o=0,a=n.length;o<a;o++)t+=ct(i,n[o]);else t+=ct(i,n)}return t}function ct(e,t){return"string"==typeof t||"number"==typeof t&&z[e]||0===t?e+":"+t+";":""}var ut=[function(e){var t=e.data.attrs,r="",o=e.parent&&e.parent.componentOptions;if(n(o)||!1!==o.Ctor.options.inheritAttrs)for(var a=e.parent;i(a)&&(!a.componentOptions||!1!==a.componentOptions.Ctor.options.inheritAttrs);)i(a.data)&&i(a.data.attrs)&&(t=A(A({},t),a.data.attrs)),a=a.parent;if(n(t))return r;for(var s in t)L(s)||"style"!==s&&(r+=W(s,t[s]));return r},function(e){for(var t=e.data.domProps,r="",o=e.parent;i(o);)o.data&&o.data.domProps&&(t=A(A({},t),o.data.domProps)),o=o.parent;if(n(t))return r;var a=e.data.attrs;for(var s in t)if("innerHTML"===s)Y(e,t[s],!0);else if("textContent"===s)Y(e,t[s],!1);else if("value"===s&&"textarea"===e.tag)Y(e,f(t[s]),!1);else{var c=M[s]||s.toLowerCase();!I(c)||i(a)&&i(a[c])||(r+=W(c,t[s]))}return r},function(e){var t=function(e){for(var t=e.data,r=e,n=e;i(n.componentInstance);)(n=n.componentInstance._vnode)&&n.data&&(t=Qe(n.data,t));for(;i(r=r.parent);)r&&r.data&&(t=Qe(t,r.data));return Ye(t.staticClass,t.class)}(e);if(""!==t)return' class="'+D(t)+'"'},function(e){var t=st(function(e,t){var r,n={};if(t)for(var i=e;i.componentInstance;)(i=i.componentInstance._vnode)&&i.data&&(r=ot(i.data))&&A(n,r);(r=ot(e.data))&&A(n,r);for(var o=e;o=o.parent;)o.data&&(r=ot(o.data))&&A(n,r);return n}(e,!1));if(""!==t)return" style="+JSON.stringify(D(t))}];function lt(e){var t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function ft(e){var t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var pt={show:function(e,t){if(!t.value){var r=e.data.style||(e.data.style={});Array.isArray(r)?r.push({display:"none"}):r.display="none"}},model:function(e,t){if(e.children)for(var r=t.value,n=e.data.attrs&&e.data.attrs.multiple,i=0,o=e.children.length;i<o;i++){var a=e.children[i];if("option"===a.tag)if(n)Array.isArray(r)&&j(r,lt(a))>-1&&ft(a);else if(F(r,lt(a)))return void ft(a)}}},dt=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),vt=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ht=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),mt=800,yt=function(e){return e},gt="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?function(e){return Promise.resolve().then(e)}:"undefined"!=typeof setTimeout?setTimeout:yt;if(gt===yt)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function bt(e,t){var r=0,n=function(i,o){i&&n.caching&&(n.cacheBuffer[n.cacheBuffer.length-1]+=i),!0!==e(i,o)&&(r>=mt?gt(function(){try{o()}catch(e){t(e)}}):(r++,o(),r--))};return n.caching=!1,n.cacheBuffer=[],n.componentBuffer=[],n}var _t=function(e){function t(t){var r=this;e.call(this),this.buffer="",this.render=t,this.expectedSize=0,this.write=bt(function(e,t){var n=r.expectedSize;return r.buffer+=e,r.buffer.length>=n&&(r.next=t,r.pushBySize(n),!0)},function(e){r.emit("error",e)}),this.end=function(){r.emit("beforeEnd"),r.done=!0,r.push(r.buffer)}}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.pushBySize=function(e){var t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)},t.prototype.tryRender=function(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}},t.prototype.tryNext=function(){try{this.next()}catch(e){this.emit("error",e)}},t.prototype._read=function(e){this.expectedSize=e,o(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):n(this.next)?this.tryRender():this.tryNext()},t}(require("stream").Readable),wt=function(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;var t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&xt(t,"get"),this.has=t&&xt(t,"has"),this.next=this.next.bind(this)};function xt(e,t){var r=e[t];return n(r)?void 0:r.length>1?function(t,n){return r.call(e,t,n)}:function(t,n){return n(r.call(e,t))}}wt.prototype.next=function(){for(;;){var e=this.renderStates[this.renderStates.length-1];if(n(e))return this.done();switch(e.type){case"Element":case"Fragment":var t=e.children,r=e.total,i=e.rendered++;if(i<r)return this.renderNode(t[i],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();var o=e.buffer,a=e.bufferIndex,s=e.componentBuffer,c=e.key,u={html:o[a],components:s[a]};if(this.cache.set(c,u),0===a)this.write.caching=!1;else{o[a-1]+=u.html;var l=s[a-1];u.components.forEach(function(e){return l.add(e)})}o.length=a,s.length=a}}};var St=/[\w).+\-_$\]]/;function $t(e){var t,r,n,i,o,a=!1,s=!1,c=!1,u=!1,l=0,f=0,p=0,d=0;for(n=0;n<e.length;n++)if(r=t,t=e.charCodeAt(n),a)39===t&&92!==r&&(a=!1);else if(s)34===t&&92!==r&&(s=!1);else if(c)96===t&&92!==r&&(c=!1);else if(u)47===t&&92!==r&&(u=!1);else if(124!==t||124===e.charCodeAt(n+1)||124===e.charCodeAt(n-1)||l||f||p){switch(t){case 34:s=!0;break;case 39:a=!0;break;case 96:c=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:l++;break;case 125:l--}if(47===t){for(var v=n-1,h=void 0;v>=0&&" "===(h=e.charAt(v));v--);h&&St.test(h)||(u=!0)}}else void 0===i?(d=n+1,i=e.slice(0,n).trim()):m();function m(){(o||(o=[])).push(e.slice(d,n).trim()),d=n+1}if(void 0===i?i=e.slice(0,n).trim():0!==d&&m(),o)for(n=0;n<o.length;n++)i=At(i,o[n]);return i}function At(e,t){var r=t.indexOf("(");if(r<0)return'_f("'+t+'")('+e+")";var n=t.slice(0,r),i=t.slice(r+1);return'_f("'+n+'")('+e+(")"!==i?","+i:i)}var Ot=/\{\{((?:.|\r?\n)+?)\}\}/g,kt=/[-.*+?^${}()|[\]\/\\]/g,Ct=b(function(e){var t=e[0].replace(kt,"\\$&"),r=e[1].replace(kt,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+r,"g")});function Tt(e,t){console.error("[Vue compiler]: "+e)}function Ft(e,t){return e?e.map(function(e){return e[t]}).filter(function(e){return e}):[]}function jt(e,t,r,n,i){(e.props||(e.props=[])).push(Ut({name:t,value:r,dynamic:i},n)),e.plain=!1}function Pt(e,t,r,n,i){(i?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(Ut({name:t,value:r,dynamic:i},n)),e.plain=!1}function Et(e,t,r,n){e.attrsMap[t]=r,e.attrsList.push(Ut({name:t,value:r},n))}function Nt(e,t,r,n,i,o,a,s){(e.directives||(e.directives=[])).push(Ut({name:t,rawName:r,value:n,arg:i,isDynamicArg:o,modifiers:a},s)),e.plain=!1}function Lt(e,t,r){return r?"_p("+t+',"'+e+'")':e+t}function It(e,t,n,i,o,a,s,c){var u;(i=i||r).right?c?t="("+t+")==='click'?'contextmenu':("+t+")":"click"===t&&(t="contextmenu",delete i.right):i.middle&&(c?t="("+t+")==='click'?'mouseup':("+t+")":"click"===t&&(t="mouseup")),i.capture&&(delete i.capture,t=Lt("!",t,c)),i.once&&(delete i.once,t=Lt("~",t,c)),i.passive&&(delete i.passive,t=Lt("&",t,c)),i.native?(delete i.native,u=e.nativeEvents||(e.nativeEvents={})):u=e.events||(e.events={});var l=Ut({value:n.trim(),dynamic:c},s);i!==r&&(l.modifiers=i);var f=u[t];Array.isArray(f)?o?f.unshift(l):f.push(l):u[t]=f?o?[l,f]:[f,l]:l,e.plain=!1}function Mt(e,t,r){var n=Rt(e,":"+t)||Rt(e,"v-bind:"+t);if(null!=n)return $t(n);if(!1!==r){var i=Rt(e,t);if(null!=i)return JSON.stringify(i)}}function Rt(e,t,r){var n;if(null!=(n=e.attrsMap[t]))for(var i=e.attrsList,o=0,a=i.length;o<a;o++)if(i[o].name===t){i.splice(o,1);break}return r&&delete e.attrsMap[t],n}function Dt(e,t){for(var r=e.attrsList,n=0,i=r.length;n<i;n++){var o=r[n];if(t.test(o.name))return r.splice(n,1),o}}function Ut(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var zt={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;var r=Rt(e,"class");r&&(e.staticClass=JSON.stringify(r));var n=Mt(e,"class",!1);n&&(e.classBinding=n)},genData:function(e){var t="";return e.staticClass&&(t+="staticClass:"+e.staticClass+","),e.classBinding&&(t+="class:"+e.classBinding+","),t}};var Bt,qt,Jt,Ht,Kt,Vt,Wt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;var r=Rt(e,"style");r&&(e.staticStyle=JSON.stringify(it(r)));var n=Mt(e,"style",!1);n&&(e.styleBinding=n)},genData:function(e){var t="";return e.staticStyle&&(t+="staticStyle:"+e.staticStyle+","),e.styleBinding&&(t+="style:("+e.styleBinding+"),"),t}},Zt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Xt=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Gt="[a-zA-Z_][\\-\\.0-9_a-zA-Z"+/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source+"]*",Qt="((?:"+Gt+"\\:)?"+Gt+")",Yt=new RegExp("^<"+Qt),er=/^\s*(\/?)>/,tr=new RegExp("^<\\/"+Qt+"[^>]*>"),rr=/^<!DOCTYPE [^>]+>/i,nr=/^<!\--/,ir=/^<!\[/,or=d("script,style,textarea",!0),ar={},sr={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},cr=/&(?:lt|gt|quot|amp|#39);/g,ur=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,lr=d("pre,textarea",!0),fr=function(e,t){return e&&lr(e)&&"\n"===t[0]};function pr(e,t){var r=t?ur:cr;return e.replace(r,function(e){return sr[e]})}function dr(e,t,r){var n=r||{},i=n.number,o="$$v";n.trim&&(o="(typeof $$v === 'string'? $$v.trim(): $$v)"),i&&(o="_n("+o+")");var a=vr(t,o);e.model={value:"("+t+")",expression:JSON.stringify(t),callback:"function ($$v) {"+a+"}"}}function vr(e,t){var r=function(e){if(e=e.trim(),Bt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Bt-1)return(Ht=e.lastIndexOf("."))>-1?{exp:e.slice(0,Ht),key:'"'+e.slice(Ht+1)+'"'}:{exp:e,key:null};qt=e,Ht=Kt=Vt=0;for(;!mr();)yr(Jt=hr())?br(Jt):91===Jt&&gr(Jt);return{exp:e.slice(0,Kt),key:e.slice(Kt+1,Vt)}}(e);return null===r.key?e+"="+t:"$set("+r.exp+", "+r.key+", "+t+")"}function hr(){return qt.charCodeAt(++Ht)}function mr(){return Ht>=Bt}function yr(e){return 34===e||39===e}function gr(e){var t=1;for(Kt=Ht;!mr();)if(yr(e=hr()))br(e);else if(91===e&&t++,93===e&&t--,0===t){Vt=Ht;break}}function br(e){for(var t=e;!mr()&&(e=hr())!==t;);}var _r,wr,xr,Sr,$r,Ar,Or,kr,Cr=/^@|^v-on:/,Tr=/^v-|^@|^:|^#/,Fr=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,jr=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Pr=/^\(|\)$/g,Er=/^\[.*\]$/,Nr=/:(.*)$/,Lr=/^:|^\.|^v-bind:/,Ir=/\.[^.\]]+(?=[^\]]*$)/g,Mr=/^v-slot(:|$)|^#/,Rr=/[\r\n]/,Dr=/[ \f\t\r\n]+/g,Ur=b(t.decode),zr="_empty_";function Br(e,t,r){return{type:1,tag:e,attrsList:t,attrsMap:Zr(t),rawAttrsMap:{},parent:r,children:[]}}function qr(e,t){_r=t.warn||Tt,Ar=t.isPreTag||C,Or=t.mustUseProp||C,kr=t.getTagNamespace||C;t.isReservedTag;xr=Ft(t.modules,"transformNode"),Sr=Ft(t.modules,"preTransformNode"),$r=Ft(t.modules,"postTransformNode"),wr=t.delimiters;var r,n,i=[],o=!1!==t.preserveWhitespace,a=t.whitespace,s=!1,c=!1;function u(e){if(l(e),s||e.processed||(e=Jr(e,t)),i.length||e===r||r.if&&(e.elseif||e.else)&&Kr(r,{exp:e.elseif,block:e}),n&&!e.forbidden)if(e.elseif||e.else)a=e,(u=function(e){var t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(n.children))&&u.if&&Kr(u,{exp:a.elseif,block:a});else{if(e.slotScope){var o=e.slotTarget||'"default"';(n.scopedSlots||(n.scopedSlots={}))[o]=e}n.children.push(e),e.parent=n}var a,u;e.children=e.children.filter(function(e){return!e.slotScope}),l(e),e.pre&&(s=!1),Ar(e.tag)&&(c=!1);for(var f=0;f<$r.length;f++)$r[f](e,t)}function l(e){if(!c)for(var t;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}return function(e,t){for(var r,n,i=[],o=t.expectHTML,a=t.isUnaryTag||C,s=t.canBeLeftOpenTag||C,c=0;e;){if(r=e,n&&or(n)){var u=0,l=n.toLowerCase(),f=ar[l]||(ar[l]=new RegExp("([\\s\\S]*?)(</"+l+"[^>]*>)","i")),p=e.replace(f,function(e,r,n){return u=n.length,or(l)||"noscript"===l||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),fr(l,r)&&(r=r.slice(1)),t.chars&&t.chars(r),""});c+=e.length-p.length,e=p,O(l,c-u,c)}else{var d=e.indexOf("<");if(0===d){if(nr.test(e)){var v=e.indexOf("--\x3e");if(v>=0){t.shouldKeepComment&&t.comment(e.substring(4,v),c,c+v+3),S(v+3);continue}}if(ir.test(e)){var h=e.indexOf("]>");if(h>=0){S(h+2);continue}}var m=e.match(rr);if(m){S(m[0].length);continue}var y=e.match(tr);if(y){var g=c;S(y[0].length),O(y[1],g,c);continue}var b=$();if(b){A(b),fr(b.tagName,e)&&S(1);continue}}var _=void 0,w=void 0,x=void 0;if(d>=0){for(w=e.slice(d);!(tr.test(w)||Yt.test(w)||nr.test(w)||ir.test(w)||(x=w.indexOf("<",1))<0);)d+=x,w=e.slice(d);_=e.substring(0,d)}d<0&&(_=e),_&&S(_.length),t.chars&&_&&t.chars(_,c-_.length,c)}if(e===r){t.chars&&t.chars(e);break}}function S(t){c+=t,e=e.substring(t)}function $(){var t=e.match(Yt);if(t){var r,n,i={tagName:t[1],attrs:[],start:c};for(S(t[0].length);!(r=e.match(er))&&(n=e.match(Xt)||e.match(Zt));)n.start=c,S(n[0].length),n.end=c,i.attrs.push(n);if(r)return i.unarySlash=r[1],S(r[0].length),i.end=c,i}}function A(e){var r=e.tagName,c=e.unarySlash;o&&("p"===n&&ht(r)&&O(n),s(r)&&n===r&&O(r));for(var u=a(r)||!!c,l=e.attrs.length,f=new Array(l),p=0;p<l;p++){var d=e.attrs[p],v=d[3]||d[4]||d[5]||"",h="a"===r&&"href"===d[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[p]={name:d[1],value:pr(v,h)}}u||(i.push({tag:r,lowerCasedTag:r.toLowerCase(),attrs:f,start:e.start,end:e.end}),n=r),t.start&&t.start(r,f,u,e.start,e.end)}function O(e,r,o){var a,s;if(null==r&&(r=c),null==o&&(o=c),e)for(s=e.toLowerCase(),a=i.length-1;a>=0&&i[a].lowerCasedTag!==s;a--);else a=0;if(a>=0){for(var u=i.length-1;u>=a;u--)t.end&&t.end(i[u].tag,r,o);i.length=a,n=a&&i[a-1].tag}else"br"===s?t.start&&t.start(e,[],!0,r,o):"p"===s&&(t.start&&t.start(e,[],!1,r,o),t.end&&t.end(e,r,o))}O()}(e,{warn:_r,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start:function(e,o,a,l,f){var p=n&&n.ns||kr(e);se&&"svg"===p&&(o=function(e){for(var t=[],r=0;r<e.length;r++){var n=e[r];Xr.test(n.name)||(n.name=n.name.replace(Gr,""),t.push(n))}return t}(o));var d,v=Br(e,o,n);p&&(v.ns=p),"style"!==(d=v).tag&&("script"!==d.tag||d.attrsMap.type&&"text/javascript"!==d.attrsMap.type)||fe()||(v.forbidden=!0);for(var h=0;h<Sr.length;h++)v=Sr[h](v,t)||v;s||(!function(e){null!=Rt(e,"v-pre")&&(e.pre=!0)}(v),v.pre&&(s=!0)),Ar(v.tag)&&(c=!0),s?function(e){var t=e.attrsList,r=t.length;if(r)for(var n=e.attrs=new Array(r),i=0;i<r;i++)n[i]={name:t[i].name,value:JSON.stringify(t[i].value)},null!=t[i].start&&(n[i].start=t[i].start,n[i].end=t[i].end);else e.pre||(e.plain=!0)}(v):v.processed||(Hr(v),function(e){var t=Rt(e,"v-if");if(t)e.if=t,Kr(e,{exp:t,block:e});else{null!=Rt(e,"v-else")&&(e.else=!0);var r=Rt(e,"v-else-if");r&&(e.elseif=r)}}(v),function(e){null!=Rt(e,"v-once")&&(e.once=!0)}(v)),r||(r=v),a?u(v):(n=v,i.push(v))},end:function(e,t,r){var o=i[i.length-1];i.length-=1,n=i[i.length-1],u(o)},chars:function(e,t,r){if(n&&(!se||"textarea"!==n.tag||n.attrsMap.placeholder!==e)){var i,u,l,f=n.children;if(e=c||e.trim()?"script"===(i=n).tag||"style"===i.tag?e:Ur(e):f.length?a?"condense"===a&&Rr.test(e)?"":" ":o?" ":"":"")c||"condense"!==a||(e=e.replace(Dr," ")),!s&&" "!==e&&(u=function(e,t){var r=t?Ct(t):Ot;if(r.test(e)){for(var n,i,o,a=[],s=[],c=r.lastIndex=0;n=r.exec(e);){(i=n.index)>c&&(s.push(o=e.slice(c,i)),a.push(JSON.stringify(o)));var u=$t(n[1].trim());a.push("_s("+u+")"),s.push({"@binding":u}),c=i+n[0].length}return c<e.length&&(s.push(o=e.slice(c)),a.push(JSON.stringify(o))),{expression:a.join("+"),tokens:s}}}(e,wr))?l={type:2,expression:u.expression,tokens:u.tokens,text:e}:" "===e&&f.length&&" "===f[f.length-1].text||(l={type:3,text:e}),l&&f.push(l)}},comment:function(e,t,r){if(n){var i={type:3,text:e,isComment:!0};n.children.push(i)}}}),r}function Jr(e,t){var r,n;(n=Mt(r=e,"key"))&&(r.key=n),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){var t=Mt(e,"ref");t&&(e.ref=t,e.refInFor=function(e){var t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){var t;"template"===e.tag?(t=Rt(e,"scope"),e.slotScope=t||Rt(e,"slot-scope")):(t=Rt(e,"slot-scope"))&&(e.slotScope=t);var r=Mt(e,"slot");r&&(e.slotTarget='""'===r?'"default"':r,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||Pt(e,"slot",r,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){var n=Dt(e,Mr);if(n){var i=Vr(n),o=i.name,a=i.dynamic;e.slotTarget=o,e.slotTargetDynamic=a,e.slotScope=n.value||zr}}else{var s=Dt(e,Mr);if(s){var c=e.scopedSlots||(e.scopedSlots={}),u=Vr(s),l=u.name,f=u.dynamic,p=c[l]=Br("template",[],e);p.slotTarget=l,p.slotTargetDynamic=f,p.children=e.children.filter(function(e){if(!e.slotScope)return e.parent=p,!0}),p.slotScope=s.value||zr,e.children=[],e.plain=!1}}}(e),function(e){"slot"===e.tag&&(e.slotName=Mt(e,"name"))}(e),function(e){var t;(t=Mt(e,"is"))&&(e.component=t);null!=Rt(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(var i=0;i<xr.length;i++)e=xr[i](e,t)||e;return function(e){var t,r,n,i,o,a,s,c,u=e.attrsList;for(t=0,r=u.length;t<r;t++)if(n=i=u[t].name,o=u[t].value,Tr.test(n))if(e.hasBindings=!0,(a=Wr(n.replace(Tr,"")))&&(n=n.replace(Ir,"")),Lr.test(n))n=n.replace(Lr,""),o=$t(o),(c=Er.test(n))&&(n=n.slice(1,-1)),a&&(a.prop&&!c&&"innerHtml"===(n=w(n))&&(n="innerHTML"),a.camel&&!c&&(n=w(n)),a.sync&&(s=vr(o,"$event"),c?It(e,'"update:"+('+n+")",s,null,!1,0,u[t],!0):(It(e,"update:"+w(n),s,null,!1,0,u[t]),$(n)!==w(n)&&It(e,"update:"+$(n),s,null,!1,0,u[t])))),a&&a.prop||!e.component&&Or(e.tag,e.attrsMap.type,n)?jt(e,n,o,u[t],c):Pt(e,n,o,u[t],c);else if(Cr.test(n))n=n.replace(Cr,""),(c=Er.test(n))&&(n=n.slice(1,-1)),It(e,n,o,a,!1,0,u[t],c);else{var l=(n=n.replace(Tr,"")).match(Nr),f=l&&l[1];c=!1,f&&(n=n.slice(0,-(f.length+1)),Er.test(f)&&(f=f.slice(1,-1),c=!0)),Nt(e,n,i,o,f,c,a,u[t])}else Pt(e,n,JSON.stringify(o),u[t]),!e.component&&"muted"===n&&Or(e.tag,e.attrsMap.type,n)&&jt(e,n,"true",u[t])}(e),e}function Hr(e){var t;if(t=Rt(e,"v-for")){var r=function(e){var t=e.match(Fr);if(!t)return;var r={};r.for=t[2].trim();var n=t[1].trim().replace(Pr,""),i=n.match(jr);i?(r.alias=n.replace(jr,"").trim(),r.iterator1=i[1].trim(),i[2]&&(r.iterator2=i[2].trim())):r.alias=n;return r}(t);r&&A(e,r)}}function Kr(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Vr(e){var t=e.name.replace(Mr,"");return t||"#"!==e.name[0]&&(t="default"),Er.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:'"'+t+'"',dynamic:!1}}function Wr(e){var t=e.match(Ir);if(t){var r={};return t.forEach(function(e){r[e.slice(1)]=!0}),r}}function Zr(e){for(var t={},r=0,n=e.length;r<n;r++)t[e[r].name]=e[r].value;return t}var Xr=/^xmlns:NS\d+/,Gr=/^NS\d+:/;function Qr(e){return Br(e.tag,e.attrsList.slice(),e.parent)}var Yr=[zt,Wt,{preTransformNode:function(e,t){if("input"===e.tag){var r,n=e.attrsMap;if(!n["v-model"])return;if((n[":type"]||n["v-bind:type"])&&(r=Mt(e,"type")),n.type||r||!n["v-bind"]||(r="("+n["v-bind"]+").type"),r){var i=Rt(e,"v-if",!0),o=i?"&&("+i+")":"",a=null!=Rt(e,"v-else",!0),s=Rt(e,"v-else-if",!0),c=Qr(e);Hr(c),Et(c,"type","checkbox"),Jr(c,t),c.processed=!0,c.if="("+r+")==='checkbox'"+o,Kr(c,{exp:c.if,block:c});var u=Qr(e);Rt(u,"v-for",!0),Et(u,"type","radio"),Jr(u,t),Kr(c,{exp:"("+r+")==='radio'"+o,block:u});var l=Qr(e);return Rt(l,"v-for",!0),Et(l,":type",r),Jr(l,t),Kr(c,{exp:i,block:l}),a?c.else=!0:s&&(c.elseif=s),c}}}}],en="__r";var tn={expectHTML:!0,modules:Yr,directives:{model:function(e,t,r){var n=t.value,i=t.modifiers,o=e.tag,a=e.attrsMap.type;if(e.component)return dr(e,n,i),!1;if("select"===o)!function(e,t,r){var n='var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return '+(r&&r.number?"_n(val)":"val")+"});";n=n+" "+vr(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]"),It(e,"change",n,null,!0)}(e,n,i);else if("input"===o&&"checkbox"===a)!function(e,t,r){var n=r&&r.number,i=Mt(e,"value")||"null",o=Mt(e,"true-value")||"true",a=Mt(e,"false-value")||"false";jt(e,"checked","Array.isArray("+t+")?_i("+t+","+i+")>-1"+("true"===o?":("+t+")":":_q("+t+","+o+")")),It(e,"change","var $$a="+t+",$$el=$event.target,$$c=$$el.checked?("+o+"):("+a+");if(Array.isArray($$a)){var $$v="+(n?"_n("+i+")":i)+",$$i=_i($$a,$$v);if($$el.checked){$$i<0&&("+vr(t,"$$a.concat([$$v])")+")}else{$$i>-1&&("+vr(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")+")}}else{"+vr(t,"$$c")+"}",null,!0)}(e,n,i);else if("input"===o&&"radio"===a)!function(e,t,r){var n=r&&r.number,i=Mt(e,"value")||"null";jt(e,"checked","_q("+t+","+(i=n?"_n("+i+")":i)+")"),It(e,"change",vr(t,i),null,!0)}(e,n,i);else{if("input"!==o&&"textarea"!==o)return dr(e,n,i),!1;!function(e,t,r){var n=e.attrsMap.type,i=r||{},o=i.lazy,a=i.number,s=i.trim,c=!o&&"range"!==n,u=o?"change":"range"===n?en:"input",l="$event.target.value";s&&(l="$event.target.value.trim()"),a&&(l="_n("+l+")");var f=vr(t,l);c&&(f="if($event.target.composing)return;"+f),jt(e,"value","("+t+")"),It(e,u,f,null,!0),(s||a)&&It(e,"blur","$forceUpdate()")}(e,n,i)}return!0},text:function(e,t){t.value&&jt(e,"textContent","_s("+t.value+")",t)},html:function(e,t){t.value&&jt(e,"innerHTML","_s("+t.value+")",t)}},isPreTag:function(e){return"pre"===e},isUnaryTag:dt,mustUseProp:function(e,t,r){return"value"===r&&B(e)&&"button"!==t||"selected"===r&&"option"===e||"checked"===r&&"input"===e||"muted"===r&&"video"===e},canBeLeftOpenTag:vt,isReservedTag:function(e){return rt(e)||nt(e)},getTagNamespace:function(e){return nt(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(function(e,t){return e.concat(t.staticKeys||[])},[]).join(",")}(Yr)},rn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,nn=/\([^)]*?\);*$/,on=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,an={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},sn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},cn=function(e){return"if("+e+")return null;"},un={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:cn("$event.target !== $event.currentTarget"),ctrl:cn("!$event.ctrlKey"),shift:cn("!$event.shiftKey"),alt:cn("!$event.altKey"),meta:cn("!$event.metaKey"),left:cn("'button' in $event && $event.button !== 0"),middle:cn("'button' in $event && $event.button !== 1"),right:cn("'button' in $event && $event.button !== 2")};function ln(e,t){var r=t?"nativeOn:":"on:",n="",i="";for(var o in e){var a=fn(e[o]);e[o]&&e[o].dynamic?i+=o+","+a+",":n+='"'+o+'":'+a+","}return n="{"+n.slice(0,-1)+"}",i?r+"_d("+n+",["+i.slice(0,-1)+"])":r+n}function fn(e){if(!e)return"function(){}";if(Array.isArray(e))return"["+e.map(function(e){return fn(e)}).join(",")+"]";var t=on.test(e.value),r=rn.test(e.value),n=on.test(e.value.replace(nn,""));if(e.modifiers){var i="",o="",a=[];for(var s in e.modifiers)if(un[s])o+=un[s],an[s]&&a.push(s);else if("exact"===s){var c=e.modifiers;o+=cn(["ctrl","shift","alt","meta"].filter(function(e){return!c[e]}).map(function(e){return"$event."+e+"Key"}).join("||"))}else a.push(s);return a.length&&(i+=function(e){return"if(!$event.type.indexOf('key')&&"+e.map(pn).join("&&")+")return null;"}(a)),o&&(i+=o),"function($event){"+i+(t?"return "+e.value+".apply(null, arguments)":r?"return ("+e.value+").apply(null, arguments)":n?"return "+e.value:e.value)+"}"}return t||r?e.value:"function($event){"+(n?"return "+e.value:e.value)+"}"}function pn(e){var t=parseInt(e,10);if(t)return"$event.keyCode!=="+t;var r=an[e],n=sn[e];return"_k($event.keyCode,"+JSON.stringify(e)+","+JSON.stringify(r)+",$event.key,"+JSON.stringify(n)+")"}var dn={on:function(e,t){e.wrapListeners=function(e){return"_g("+e+","+t.value+")"}},bind:function(e,t){e.wrapData=function(r){return"_b("+r+",'"+e.tag+"',"+t.value+","+(t.modifiers&&t.modifiers.prop?"true":"false")+(t.modifiers&&t.modifiers.sync?",true":"")+")"}},cloak:k},vn=function(e){this.options=e,this.warn=e.warn||Tt,this.transforms=Ft(e.modules,"transformCode"),this.dataGenFns=Ft(e.modules,"genData"),this.directives=A(A({},dn),e.directives);var t=e.isReservedTag||C;this.maybeComponent=function(e){return!!e.component||!t(e.tag)},this.onceId=0,this.staticRenderFns=[],this.pre=!1};function hn(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return mn(e,t);if(e.once&&!e.onceProcessed)return yn(e,t);if(e.for&&!e.forProcessed)return bn(e,t);if(e.if&&!e.ifProcessed)return gn(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){var r=e.slotName||'"default"',n=Sn(e,t),i="_t("+r+(n?",function(){return "+n+"}":""),o=e.attrs||e.dynamicAttrs?kn((e.attrs||[]).concat(e.dynamicAttrs||[]).map(function(e){return{name:w(e.name),value:e.value,dynamic:e.dynamic}})):null,a=e.attrsMap["v-bind"];!o&&!a||n||(i+=",null");o&&(i+=","+o);a&&(i+=(o?"":",null")+","+a);return i+")"}(e,t);var r;if(e.component)r=function(e,t,r){var n=t.inlineTemplate?null:Sn(t,r,!0);return"_c("+e+","+_n(t,r)+(n?","+n:"")+")"}(e.component,e,t);else{var n;(!e.plain||e.pre&&t.maybeComponent(e))&&(n=_n(e,t));var i=e.inlineTemplate?null:Sn(e,t,!0);r="_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}for(var o=0;o<t.transforms.length;o++)r=t.transforms[o](e,r);return r}return Sn(e,t)||"void 0"}function mn(e,t){e.staticProcessed=!0;var r=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push("with(this){return "+hn(e,t)+"}"),t.pre=r,"_m("+(t.staticRenderFns.length-1)+(e.staticInFor?",true":"")+")"}function yn(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return gn(e,t);if(e.staticInFor){for(var r="",n=e.parent;n;){if(n.for){r=n.key;break}n=n.parent}return r?"_o("+hn(e,t)+","+t.onceId+++","+r+")":hn(e,t)}return mn(e,t)}function gn(e,t,r,n){return e.ifProcessed=!0,function e(t,r,n,i){if(!t.length)return i||"_e()";var o=t.shift();return o.exp?"("+o.exp+")?"+a(o.block)+":"+e(t,r,n,i):""+a(o.block);function a(e){return n?n(e,r):e.once?yn(e,r):hn(e,r)}}(e.ifConditions.slice(),t,r,n)}function bn(e,t,r,n){var i=e.for,o=e.alias,a=e.iterator1?","+e.iterator1:"",s=e.iterator2?","+e.iterator2:"";return e.forProcessed=!0,(n||"_l")+"(("+i+"),function("+o+a+s+"){return "+(r||hn)(e,t)+"})"}function _n(e,t){var r="{",n=function(e,t){var r=e.directives;if(!r)return;var n,i,o,a,s="directives:[",c=!1;for(n=0,i=r.length;n<i;n++){o=r[n],a=!0;var u=t.directives[o.name];u&&(a=!!u(e,o,t.warn)),a&&(c=!0,s+='{name:"'+o.name+'",rawName:"'+o.rawName+'"'+(o.value?",value:("+o.value+"),expression:"+JSON.stringify(o.value):"")+(o.arg?",arg:"+(o.isDynamicArg?o.arg:'"'+o.arg+'"'):"")+(o.modifiers?",modifiers:"+JSON.stringify(o.modifiers):"")+"},")}if(c)return s.slice(0,-1)+"]"}(e,t);n&&(r+=n+","),e.key&&(r+="key:"+e.key+","),e.ref&&(r+="ref:"+e.ref+","),e.refInFor&&(r+="refInFor:true,"),e.pre&&(r+="pre:true,"),e.component&&(r+='tag:"'+e.tag+'",');for(var i=0;i<t.dataGenFns.length;i++)r+=t.dataGenFns[i](e);if(e.attrs&&(r+="attrs:"+kn(e.attrs)+","),e.props&&(r+="domProps:"+kn(e.props)+","),e.events&&(r+=ln(e.events,!1)+","),e.nativeEvents&&(r+=ln(e.nativeEvents,!0)+","),e.slotTarget&&!e.slotScope&&(r+="slot:"+e.slotTarget+","),e.scopedSlots&&(r+=function(e,t,r){var n=e.for||Object.keys(t).some(function(e){var r=t[e];return r.slotTargetDynamic||r.if||r.for||wn(r)}),i=!!e.if;if(!n)for(var o=e.parent;o;){if(o.slotScope&&o.slotScope!==zr||o.for){n=!0;break}o.if&&(i=!0),o=o.parent}var a=Object.keys(t).map(function(e){return xn(t[e],r)}).join(",");return"scopedSlots:_u(["+a+"]"+(n?",null,true":"")+(!n&&i?",null,false,"+function(e){var t=5381,r=e.length;for(;r;)t=33*t^e.charCodeAt(--r);return t>>>0}(a):"")+")"}(e,e.scopedSlots,t)+","),e.model&&(r+="model:{value:"+e.model.value+",callback:"+e.model.callback+",expression:"+e.model.expression+"},"),e.inlineTemplate){var o=function(e,t){var r=e.children[0];if(r&&1===r.type){var n=function(e,t){var r=new vn(t);return{render:"with(this){return "+(e?"script"===e.tag?"null":hn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t.options);return"inlineTemplate:{render:function(){"+n.render+"},staticRenderFns:["+n.staticRenderFns.map(function(e){return"function(){"+e+"}"}).join(",")+"]}"}}(e,t);o&&(r+=o+",")}return r=r.replace(/,$/,"")+"}",e.dynamicAttrs&&(r="_b("+r+',"'+e.tag+'",'+kn(e.dynamicAttrs)+")"),e.wrapData&&(r=e.wrapData(r)),e.wrapListeners&&(r=e.wrapListeners(r)),r}function wn(e){return 1===e.type&&("slot"===e.tag||e.children.some(wn))}function xn(e,t){var r=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!r)return gn(e,t,xn,"null");if(e.for&&!e.forProcessed)return bn(e,t,xn);var n=e.slotScope===zr?"":String(e.slotScope),i="function("+n+"){return "+("template"===e.tag?e.if&&r?"("+e.if+")?"+(Sn(e,t)||"undefined")+":undefined":Sn(e,t)||"undefined":hn(e,t))+"}",o=n?"":",proxy:true";return"{key:"+(e.slotTarget||'"default"')+",fn:"+i+o+"}"}function Sn(e,t,r,n,i){var o=e.children;if(o.length){var a=o[0];if(1===o.length&&a.for&&"template"!==a.tag&&"slot"!==a.tag){var s=r?t.maybeComponent(a)?",1":",0":"";return""+(n||hn)(a,t)+s}var c=r?function(e,t){for(var r=0,n=0;n<e.length;n++){var i=e[n];if(1===i.type){if($n(i)||i.ifConditions&&i.ifConditions.some(function(e){return $n(e.block)})){r=2;break}(t(i)||i.ifConditions&&i.ifConditions.some(function(e){return t(e.block)}))&&(r=1)}}return r}(o,t.maybeComponent):0,u=i||An;return"["+o.map(function(e){return u(e,t)}).join(",")+"]"+(c?","+c:"")}}function $n(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function An(e,t){return 1===e.type?hn(e,t):3===e.type&&e.isComment?(r=e,"_e("+JSON.stringify(r.text)+")"):On(e);var r}function On(e){return"_v("+(2===e.type?e.expression:Cn(JSON.stringify(e.text)))+")"}function kn(e){for(var t="",r="",n=0;n<e.length;n++){var i=e[n],o=Cn(i.value);i.dynamic?r+=i.name+","+o+",":t+='"'+i.name+'":'+o+","}return t="{"+t.slice(0,-1)+"}",r?"_d("+t+",["+r.slice(0,-1)+"])":t}function Cn(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}var Tn=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function Fn(e,t){return Tn.test(t)?(t=t.replace(/^'|'$/g,'"'),q(e)&&'"false"'!==t&&(t='"true"'),{type:Ln,value:K(e)?" "+e+'="'+e+'"':'""'===t?" "+e:" "+e+'="'+JSON.parse(t)+'"'}):{type:Mn,value:"_ssrAttr("+JSON.stringify(e)+","+t+")"}}var jn,Pn={FALSE:0,FULL:1,SELF:2,CHILDREN:3,PARTIAL:4};function En(e,t){e&&(jn=t.isReservedTag||C,function e(t,r){if(function(e){if(2===e.type||3===e.type)return!1;return v(e.tag)||!jn(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some(function(e){return"model"===e.name})}(e)}(t))return void(t.ssrOptimizability=Pn.FALSE);var n=r||function(e){return 1===e.type&&e.directives&&e.directives.some(function(e){return!Nn(e.name)})}(t);var i=function(e){e.ssrOptimizability!==Pn.FULL&&(t.ssrOptimizability=n?Pn.PARTIAL:Pn.SELF)};n&&(t.ssrOptimizability=Pn.CHILDREN);if(1===t.type){for(var o=0,a=t.children.length;o<a;o++){var s=t.children[o];e(s),i(s)}if(t.ifConditions)for(var c=1,u=t.ifConditions.length;c<u;c++){var l=t.ifConditions[c].block;e(l,r),i(l)}null==t.ssrOptimizability||!r&&(t.attrsMap["v-html"]||t.attrsMap["v-text"])?t.ssrOptimizability=Pn.FULL:t.children=function(e){for(var t=e.children,r=[],n=[],i=function(){n.length&&r.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:n,ssrOptimizability:Pn.FULL}),n=[]},o=0;o<t.length;o++){var a=t[o];a.ssrOptimizability===Pn.FULL?n.push(a):(i(),r.push(a))}return i(),r}(t)}else t.ssrOptimizability=Pn.FULL}(e,!0))}var Nn=d("text,html,show,on,bind,model,pre,cloak,once");var Ln=0,In=1,Mn=2;function Rn(e,t){if(e.for&&!e.forProcessed)return bn(e,t,Rn);if(e.if&&!e.ifProcessed)return gn(e,t,Rn);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===Pn.FULL?Bn(e,t):Un(e,t)||"void 0";switch(e.ssrOptimizability){case Pn.FULL:return function(e,t){return"_ssrNode("+qn(e,t)+")"}(e,t);case Pn.SELF:return function(e,t){var r=Un(e,t,!0);return"_ssrNode("+Vn(Hn(e,t))+',"</'+e.tag+'>"'+(r?","+r:"")+")"}(e,t);case Pn.CHILDREN:return Dn(e,t,!0);case Pn.PARTIAL:return Dn(e,t,!1);default:return hn(e,t)}}function Dn(e,t,r){var n=e.plain?void 0:_n(e,t),i=r?"["+Bn(e,t)+"]":Un(e,t,!0);return"_c('"+e.tag+"'"+(n?","+n:"")+(i?","+i:"")+")"}function Un(e,t,r){return Sn(e,t,r,Rn,zn)}function zn(e,t){return 1===e.type?Rn(e,t):On(e)}function Bn(e,t){return e.children.length?"_ssrNode("+Vn(Kn(e,t))+")":""}function qn(e,t){return"("+Vn(Jn(e,t))+")"}function Jn(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:Mn,value:bn(e,t,qn,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:Mn,value:gn(e,t,qn,'"\x3c!----\x3e"')}];if("template"===e.tag)return Kn(e,t);var r=Hn(e,t),n=Kn(e,t),i=t.options.isUnaryTag,o=i&&i(e.tag)?[]:[{type:Ln,value:"</"+e.tag+">"}];return r.concat(n,o)}function Hn(e,t){var r;!function(e,t){if(e.directives)for(var r=0;r<e.directives.length;r++){var n=e.directives[r];if("model"===n.name){t.directives.model(e,n,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter(function(e){return"value"!==e.name}));break}}}(e,t);var n,i,o,a,s,c,u=[{type:Ln,value:"<"+e.tag}];return e.attrs&&u.push.apply(u,e.attrs.map(function(e){return Fn(e.name,e.value)})),e.props&&u.push.apply(u,function(e,t){var r=[];return e.forEach(function(e){var n=e.name,i=e.value;n=M[n]||n.toLowerCase(),!I(n)||t&&t.some(function(e){return e.name===n})||r.push(Fn(n,i))}),r}(e.props,e.attrs)),(r=e.attrsMap["v-bind"])&&u.push({type:Mn,value:"_ssrAttrs("+r+")"}),(r=e.attrsMap["v-bind.prop"])&&u.push({type:Mn,value:"_ssrDOMProps("+r+")"}),(e.staticClass||e.classBinding)&&u.push.apply(u,(n=e.staticClass,i=e.classBinding,n&&!i?[{type:Ln,value:' class="'+JSON.parse(n)+'"'}]:[{type:Mn,value:"_ssrClass("+(n||"null")+","+(i||"null")+")"}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&u.push.apply(u,(o=e.attrsMap.style,a=e.staticStyle,s=e.styleBinding,c=e.attrsMap["v-show"],!o||s||c?[{type:Mn,value:"_ssrStyle("+(a||"null")+","+(s||"null")+", "+(c?"{ display: ("+c+") ? '' : 'none' }":"null")+")"}]:[{type:Ln,value:" style="+JSON.stringify(o)}])),t.options.scopeId&&u.push({type:Ln,value:" "+t.options.scopeId}),u.push({type:Ln,value:">"}),u}function Kn(e,t){var r;return(r=e.attrsMap["v-html"])?[{type:Mn,value:"_s("+r+")"}]:(r=e.attrsMap["v-text"])?[{type:In,value:"_s("+r+")"}]:"textarea"===e.tag&&(r=e.attrsMap["v-model"])?[{type:In,value:"_s("+r+")"}]:e.children?function(e,t){for(var r=[],n=0;n<e.length;n++){var i=e[n];if(1===i.type)r.push.apply(r,Jn(i,t));else if(2===i.type)r.push({type:In,value:i.expression});else if(3===i.type){var o=D(i.text);i.isComment&&(o="\x3c!--"+o+"--\x3e"),r.push({type:Ln,value:o})}}return r}(e.children,t):[]}function Vn(e){for(var t=[],r="",n=function(){r&&(t.push(JSON.stringify(r)),r="")},i=0;i<e.length;i++){var o=e[i];o.type===Ln?r+=o.value:o.type===In?(n(),t.push("_ssrEscape("+o.value+")")):o.type===Mn&&(n(),t.push("("+o.value+")"))}return n(),t.join("+")}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b");function Wn(e,t){try{return new Function(e)}catch(r){return t.push({err:r,code:e}),k}}function Zn(e){var t=Object.create(null);return function(r,n,i){(n=A({},n)).warn;delete n.warn;var o=n.delimiters?String(n.delimiters)+r:r;if(t[o])return t[o];var a=e(r,n),s={},c=[];return s.render=Wn(a.render,c),s.staticRenderFns=a.staticRenderFns.map(function(e){return Wn(e,c)}),t[o]=s}}var Xn,Gn=(Xn=function(e,t){var r=qr(e.trim(),t);En(r,t);var n=function(e,t){var r=new vn(t);return{render:"with(this){return "+(e?Rn(e,r):'_c("div")')+"}",staticRenderFns:r.staticRenderFns}}(r,t);return{ast:r,render:n.render,staticRenderFns:n.staticRenderFns}},function(e){function t(t,r){var n=Object.create(e),i=[],o=[];if(r)for(var a in r.modules&&(n.modules=(e.modules||[]).concat(r.modules)),r.directives&&(n.directives=A(Object.create(e.directives||null),r.directives)),r)"modules"!==a&&"directives"!==a&&(n[a]=r[a]);n.warn=function(e,t,r){(r?o:i).push(e)};var s=Xn(t.trim(),n);return s.errors=i,s.tips=o,s}return{compile:t,compileToFunctions:Zn(t)}})(tn),Qn=(Gn.compile,Gn.compileToFunctions);function Yn(e){for(var t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function ei(e){return a(e)?[Q(e)]:Array.isArray(e)?function e(t,r){var s=[];var c,u,l,f;for(c=0;c<t.length;c++)n(u=t[c])||"boolean"==typeof u||(l=s.length-1,f=s[l],Array.isArray(u)?u.length>0&&(ti((u=e(u,(r||"")+"_"+c))[0])&&ti(f)&&(s[l]=Q(f.text+u[0].text),u.shift()),s.push.apply(s,u)):a(u)?ti(f)?s[l]=Q(f.text+u):""!==u&&s.push(Q(u)):ti(u)&&ti(f)?s[l]=Q(f.text+u.text):(o(t._isVList)&&i(u.tag)&&n(u.key)&&i(r)&&(u.key="__vlist"+r+"_"+c+"__"),s.push(u)));return s}(e):void 0}function ti(e){return i(e)&&i(e.text)&&!1===e.isComment}var ri={_ssrEscape:D,_ssrNode:function(e,t,r,n){return new ni(e,t,r,n)},_ssrList:function(e,t){var r,n,i,o,a="";if(Array.isArray(e)||"string"==typeof e)for(r=0,n=e.length;r<n;r++)a+=t(e[r],r);else if("number"==typeof e)for(r=0;r<e;r++)a+=t(r+1,r);else if(s(e))for(i=Object.keys(e),r=0,n=i.length;r<n;r++)o=i[r],a+=t(e[o],o,r);return a},_ssrAttr:W,_ssrAttrs:function(e){var t="";for(var r in e)L(r)||(t+=W(r,e[r]));return t},_ssrDOMProps:function(e){var t="";for(var r in e){var n=M[r]||r.toLowerCase();I(n)&&(t+=W(n,e[r]))}return t},_ssrClass:function(e,t){var r=Ye(e,t);return""===r?r:' class="'+D(r)+'"'},_ssrStyle:function(e,t,r){var n={};e&&A(n,e);t&&A(n,at(t));r&&A(n,r);var i=st(n);return""===i?i:" style="+JSON.stringify(D(i))}};var ni=function(e,t,r,n){this.isString=!0,this.open=e,this.close=t,this.children=r?1===n?Yn(r):2===n?ei(r):r:void 0};var ii=new de;function oi(e){!function e(t,r){var n,i;var o=Array.isArray(t);if(!o&&!s(t)||Object.isFrozen(t)||t instanceof Z)return;if(t.__ob__){var a=t.__ob__.dep.id;if(r.has(a))return;r.add(a)}if(o)for(n=t.length;n--;)e(t[n],r);else for(i=Object.keys(t),n=i.length;n--;)e(t[i[n]],r)}(e,ii),ii.clear()}var ai=b(function(e){var t="&"===e.charAt(0),r="~"===(e=t?e.slice(1):e).charAt(0),n="!"===(e=r?e.slice(1):e).charAt(0);return{name:e=n?e.slice(1):e,once:r,capture:n,passive:t}});function si(e,t){function r(){var e=arguments,n=r.fns;if(!Array.isArray(n))return Ve(n,null,arguments,t,"v-on handler");for(var i=n.slice(),o=0;o<i.length;o++)Ve(i[o],null,e,t,"v-on handler")}return r.fns=e,r}function ci(e,t,r,n,o){if(i(t)){if(g(t,r))return e[r]=t[r],o||delete t[r],!0;if(g(t,n))return e[r]=t[n],o||delete t[n],!0}return!1}var ui=1,li=2;function fi(e,t,r,c,u,l){return(Array.isArray(r)||a(r))&&(u=c,c=r,r=void 0),o(l)&&(u=li),function(e,t,r,a,c){if(i(r)&&i(r.__ob__))return G();i(r)&&i(r.is)&&(t=r.is);if(!t)return G();Array.isArray(a)&&"function"==typeof a[0]&&((r=r||{}).scopedSlots={default:a[0]},a.length=0);c===li?a=ei(a):c===ui&&(a=Yn(a));var u,l;if("string"==typeof t){var f;l=e.$vnode&&e.$vnode.ns||ye.getTagNamespace(t),u=r&&r.pre||!i(f=Ue(e.$options,"components",t))?new Z(t,r,a,void 0,void 0,e):Vi(f,r,e,a,t)}else u=Vi(t,r,e,a);return Array.isArray(u)?u:i(u)?(i(l)&&function e(t,r,a){t.ns=r;"foreignObject"===t.tag&&(r=void 0,a=!0);if(i(t.children))for(var s=0,c=t.children.length;s<c;s++){var u=t.children[s];i(u.tag)&&(n(u.ns)||o(a)&&"svg"!==u.tag)&&e(u,r,a)}}(u,l),i(r)&&function(e){s(e.style)&&oi(e.style);s(e.class)&&oi(e.class)}(r),u):G()}(e,t,r,c,u)}function pi(e,t){var r,n,o,a,c;if(Array.isArray(e)||"string"==typeof e)for(r=new Array(e.length),n=0,o=e.length;n<o;n++)r[n]=t(e[n],n);else if("number"==typeof e)for(r=new Array(e),n=0;n<e;n++)r[n]=t(n+1,n);else if(s(e))if(ve&&e[Symbol.iterator]){r=[];for(var u=e[Symbol.iterator](),l=u.next();!l.done;)r.push(t(l.value,r.length)),l=u.next()}else for(a=Object.keys(e),r=new Array(a.length),n=0,o=a.length;n<o;n++)c=a[n],r[n]=t(e[c],c,n);return i(r)||(r=[]),r._isVList=!0,r}function di(e,t,r,n){var i,o=this.$scopedSlots[e];o?(r=r||{},n&&(r=A(A({},n),r)),i=o(r)||("function"==typeof t?t():t)):i=this.$slots[e]||("function"==typeof t?t():t);var a=r&&r.slot;return a?this.$createElement("template",{slot:a},i):i}function vi(e){return Ue(this.$options,"filters",e)||T}function hi(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function mi(e,t,r,n,i){var o=ye.keyCodes[t]||r;return i&&n&&!ye.keyCodes[t]?hi(i,n):o?hi(o,e):n?$(n)!==t:void 0===e}function yi(e,t,r,n,i){if(r)if(s(r)){var o;Array.isArray(r)&&(r=O(r));var a=function(a){if("class"===a||"style"===a||h(a))o=e;else{var s=e.attrs&&e.attrs.type;o=n||ye.mustUseProp(t,s,a)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}var c=w(a),u=$(a);c in o||u in o||(o[a]=r[a],i&&((e.on||(e.on={}))["update:"+a]=function(e){r[a]=e}))};for(var c in r)a(c)}else;return e}function gi(e,t){var r=this._staticTrees||(this._staticTrees=[]),n=r[e];return n&&!t?n:(_i(n=r[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),"__static__"+e,!1),n)}function bi(e,t,r){return _i(e,"__once__"+t+(r?"_"+r:""),!0),e}function _i(e,t,r){if(Array.isArray(e))for(var n=0;n<e.length;n++)e[n]&&"string"!=typeof e[n]&&wi(e[n],t+"_"+n,r);else wi(e,t,r)}function wi(e,t,r){e.isStatic=!0,e.key=t,e.isOnce=r}function xi(e,t){if(t)if(u(t)){var r=e.on=e.on?A({},e.on):{};for(var n in t){var i=r[n],o=t[n];r[n]=i?[].concat(i,o):o}}else;return e}function Si(e,t,r,n){t=t||{$stable:!r};for(var i=0;i<e.length;i++){var o=e[i];Array.isArray(o)?Si(o,t,r):o&&(o.proxy&&(o.fn.proxy=!0),t[o.key]=o.fn)}return n&&(t.$key=n),t}function $i(e,t){for(var r=0;r<t.length;r+=2){var n=t[r];"string"==typeof n&&n&&(e[t[r]]=t[r+1])}return e}function Ai(e,t){return"string"==typeof e?t+e:e}function Oi(e,t){if(!e||!e.length)return{};for(var r={},n=0,i=e.length;n<i;n++){var o=e[n],a=o.data;if(a&&a.attrs&&a.attrs.slot&&delete a.attrs.slot,o.context!==t&&o.fnContext!==t||!a||null==a.slot)(r.default||(r.default=[])).push(o);else{var s=a.slot,c=r[s]||(r[s]=[]);"template"===o.tag?c.push.apply(c,o.children||[]):c.push(o)}}for(var u in r)r[u].every(ki)&&delete r[u];return r}function ki(e){return e.isComment&&!e.asyncFactory||" "===e.text}function Ci(e,t,n){var i,o=Object.keys(t).length>0,a=e?!!e.$stable:!o,s=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(a&&n&&n!==r&&s===n.$key&&!o&&!n.$hasNormal)return n;for(var c in i={},e)e[c]&&"$"!==c[0]&&(i[c]=Ti(t,c,e[c]))}else i={};for(var u in t)u in i||(i[u]=Fi(t,u));return e&&Object.isExtensible(e)&&(e._normalized=i),ee(i,"$stable",a),ee(i,"$key",s),ee(i,"$hasNormal",o),i}function Ti(e,t,r){var n=function(){var e,t=arguments.length?r.apply(null,arguments):r({}),n=(t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ei(t))&&t[0];return!t||n&&(1!==t.length||!n.isComment||(e=n).isComment&&e.asyncFactory)?t:void 0};return r.proxy&&Object.defineProperty(e,t,{get:n,enumerable:!0,configurable:!0}),n}function Fi(e,t){return function(){return e[t]}}var ji,Pi=null;function Ei(e,t){return(e.__esModule||ve&&"Module"===e[Symbol.toStringTag])&&(e=e.default),s(e)?t.extend(e):e}function Ni(e,t){ji.$on(e,t)}function Li(e,t){ji.$off(e,t)}function Ii(e,t){var r=ji;return function n(){null!==t.apply(null,arguments)&&r.$off(e,n)}}function Mi(e,t,r){ji=e,function(e,t,r,i,a,s){var c,u,l,f;for(c in e)u=e[c],l=t[c],f=ai(c),n(u)||(n(l)?(n(u.fns)&&(u=e[c]=si(u,s)),o(f.once)&&(u=e[c]=a(f.name,u,f.capture)),r(f.name,u,f.capture,f.passive,f.params)):u!==l&&(l.fns=u,e[c]=l));for(c in t)n(e[c])&&i((f=ai(c)).name,t[c],f.capture)}(t,r||{},Ni,Li,Ii,e),ji=void 0}function Ri(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Di(e,t){xe();var r=e.$options[t],n=t+" hook";if(r)for(var i=0,o=r.length;i<o;i++)Ve(r[i],e,null,e,n);e._hasHookEvent&&e.$emit("hook:"+t),Se()}var Ui=Date.now;if(ne&&!se){var zi=window.performance;zi&&"function"==typeof zi.now&&Ui()>document.createEvent("Event").timeStamp&&(Ui=function(){return zi.now()})}function Bi(e,t,n,i,a){var s,c=this,u=a.options;g(i,"_uid")?(s=Object.create(i))._original=i:(s=i,i=i._original);var l=o(u._compiled),f=!l;this.data=e,this.props=t,this.children=n,this.parent=i,this.listeners=e.on||r,this.injections=function(e,t){if(e){for(var r=Object.create(null),n=ve?Reflect.ownKeys(e):Object.keys(e),i=0;i<n.length;i++){var o=n[i];if("__ob__"!==o){for(var a=e[o].from,s=t;s;){if(s._provided&&g(s._provided,a)){r[o]=s._provided[a];break}s=s.$parent}if(!s&&"default"in e[o]){var c=e[o].default;r[o]="function"==typeof c?c.call(t):c}}}return r}}(u.inject,i),this.slots=function(){return c.$slots||Ci(e.scopedSlots,c.$slots=Oi(n,i)),c.$slots},Object.defineProperty(this,"scopedSlots",{enumerable:!0,get:function(){return Ci(e.scopedSlots,this.slots())}}),l&&(this.$options=u,this.$slots=this.slots(),this.$scopedSlots=Ci(e.scopedSlots,this.$slots)),u._scopeId?this._c=function(e,t,r,n){var o=fi(s,e,t,r,n,f);return o&&!Array.isArray(o)&&(o.fnScopeId=u._scopeId,o.fnContext=i),o}:this._c=function(e,t,r,n){return fi(s,e,t,r,n,f)}}function qi(e,t,r,n,i){var o=function(e){var t=new Z(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=r,o.fnOptions=n,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function Ji(e,t){for(var r in t)e[w(r)]=t[r]}!function(e){e._o=bi,e._n=p,e._s=f,e._l=pi,e._t=di,e._q=F,e._i=j,e._m=gi,e._f=vi,e._k=mi,e._b=yi,e._v=Q,e._e=G,e._u=Si,e._g=xi,e._d=$i,e._p=Ai}(Bi.prototype);var Hi={init:function(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){var r=e;Hi.prepatch(r,r)}else{(e.componentInstance=Wi(e,null)).$mount(t?e.elm:void 0,t)}},prepatch:function(e,t){var n=t.componentOptions;!function(e,t,n,i,o){var a=i.data.scopedSlots,s=e.$scopedSlots,c=!!(a&&!a.$stable||s!==r&&!s.$stable||a&&e.$scopedSlots.$key!==a.$key||!a&&e.$scopedSlots.$key),u=!!(o||e.$options._renderChildren||c);if(e.$options._parentVnode=i,e.$vnode=i,e._vnode&&(e._vnode.parent=i),e.$options._renderChildren=o,e.$attrs=i.data.attrs||r,e.$listeners=n||r,t&&e.$options.props){Ce(!1);for(var l=e._props,f=e.$options._propKeys||[],p=0;p<f.length;p++){var d=f[p],v=e.$options.props;l[d]=ze(d,v,t,e)}Ce(!0),e.$options.propsData=t}n=n||r;var h=e.$options._parentListeners;e.$options._parentListeners=n,Mi(e,n,h),u&&(e.$slots=Oi(o,i.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,n.propsData,n.listeners,t,n.children)},insert:function(e){var t=e.context,r=e.componentInstance;r._isMounted||(r._isMounted=!0,Di(r,"mounted")),e.data.keepAlive&&(t._isMounted?r._inactive=!1:function e(t,r){if(r){if(t._directInactive=!1,Ri(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Di(t,"activated")}}(r,!0))},destroy:function(e){var t=e.componentInstance;t._isDestroyed||(e.data.keepAlive?function e(t,r){if(!(r&&(t._directInactive=!0,Ri(t))||t._inactive)){t._inactive=!0;for(var n=0;n<t.$children.length;n++)e(t.$children[n]);Di(t,"deactivated")}}(t,!0):t.$destroy())}},Ki=Object.keys(Hi);function Vi(e,t,a,c,u){if(!n(e)){var f=a.$options._base;if(s(e)&&(e=f.extend(e)),"function"==typeof e){var p;if(n(e.cid)&&void 0===(e=function(e,t){if(o(e.error)&&i(e.errorComp))return e.errorComp;if(i(e.resolved))return e.resolved;var r=Pi;if(r&&i(e.owners)&&-1===e.owners.indexOf(r)&&e.owners.push(r),o(e.loading)&&i(e.loadingComp))return e.loadingComp;if(r&&!i(e.owners)){var a=e.owners=[r],c=!0,u=null,f=null;r.$on("hook:destroyed",function(){return m(a,r)});var p=function(e){for(var t=0,r=a.length;t<r;t++)a[t].$forceUpdate();e&&(a.length=0,null!==u&&(clearTimeout(u),u=null),null!==f&&(clearTimeout(f),f=null))},d=P(function(r){e.resolved=Ei(r,t),c?a.length=0:p(!0)}),v=P(function(t){i(e.errorComp)&&(e.error=!0,p(!0))}),h=e(d,v);return s(h)&&(l(h)?n(e.resolved)&&h.then(d,v):l(h.component)&&(h.component.then(d,v),i(h.error)&&(e.errorComp=Ei(h.error,t)),i(h.loading)&&(e.loadingComp=Ei(h.loading,t),0===h.delay?e.loading=!0:u=setTimeout(function(){u=null,n(e.resolved)&&n(e.error)&&(e.loading=!0,p(!1))},h.delay||200)),i(h.timeout)&&(f=setTimeout(function(){f=null,n(e.resolved)&&v(null)},h.timeout)))),c=!1,e.loading?e.loadingComp:e.resolved}}(p=e,f)))return function(e,t,r,n,i){var o=G();return o.asyncFactory=e,o.asyncMeta={data:t,context:r,children:n,tag:i},o}(p,t,a,c,u);t=t||{},function e(t){var r=t.options;if(t.super){var n=e(t.super);if(n!==t.superOptions){t.superOptions=n;var i=function(e){var t,r=e.options,n=e.sealedOptions;for(var i in r)r[i]!==n[i]&&(t||(t={}),t[i]=r[i]);return t}(t);i&&A(t.extendOptions,i),(r=t.options=De(n,t.extendOptions)).name&&(r.components[r.name]=t)}}return r}(e),i(t.model)&&function(e,t){var r=e.model&&e.model.prop||"value",n=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[r]=t.model.value;var o=t.on||(t.on={}),a=o[n],s=t.model.callback;i(a)?(Array.isArray(a)?-1===a.indexOf(s):a!==s)&&(o[n]=[s].concat(a)):o[n]=s}(e.options,t);var d=function(e,t,r){var o=t.options.props;if(!n(o)){var a={},s=e.attrs,c=e.props;if(i(s)||i(c))for(var u in o){var l=$(u);ci(a,c,u,l,!0)||ci(a,s,u,l,!1)}return a}}(t,e);if(o(e.options.functional))return function(e,t,n,o,a){var s=e.options,c={},u=s.props;if(i(u))for(var l in u)c[l]=ze(l,u,t||r);else i(n.attrs)&&Ji(c,n.attrs),i(n.props)&&Ji(c,n.props);var f=new Bi(n,c,a,o,e),p=s.render.call(null,f._c,f);if(p instanceof Z)return qi(p,n,f.parent,s);if(Array.isArray(p)){for(var d=ei(p)||[],v=new Array(d.length),h=0;h<d.length;h++)v[h]=qi(d[h],n,f.parent,s);return v}}(e,d,t,a,c);var v=t.on;if(t.on=t.nativeOn,o(e.options.abstract)){var h=t.slot;t={},h&&(t.slot=h)}!function(e){for(var t=e.hook||(e.hook={}),r=0;r<Ki.length;r++){var n=Ki[r],i=t[n],o=Hi[n];i===o||i&&i._merged||(t[n]=i?Zi(o,i):o)}}(t);var y=e.options.name||u;return new Z("vue-component-"+e.cid+(y?"-"+y:""),t,void 0,void 0,void 0,a,{Ctor:e,propsData:d,listeners:v,tag:u,children:c},p)}}}function Wi(e,t){var r={_isComponent:!0,_parentVnode:e,parent:t},n=e.data.inlineTemplate;return i(n)&&(r.render=n.render,r.staticRenderFns=n.staticRenderFns),new e.componentOptions.Ctor(r)}function Zi(e,t){var r=function(r,n){e(r,n),t(r,n)};return r._merged=!0,r}var Xi=Object.create(null),Gi=function(e){Xi[e]||(Xi[e]=!0,console.warn("\n\x1b[31m"+e+"\x1b[39m\n"))},Qi=function(e,t){var r=t?ge(t):"";throw new Error("\n\x1b[31m"+e+r+"\x1b[39m\n")},Yi=function(e){var t=e.$options,r=t.render,i=t.template,o=t._scopeId;if(n(r)){if(!i)throw new Error("render function or template not defined in component: "+(e.$options.name||e.$options._componentTag||"anonymous"));var a=Qn(i,{scopeId:o,warn:Qi},e);e.$options.render=a.render,e.$options.staticRenderFns=a.staticRenderFns}};function eo(e,t,r){var n=e.$options.serverPrefetch;if(i(n)){Array.isArray(n)||(n=[n]);try{for(var o=[],a=0,s=n.length;a<s;a++){var c=n[a].call(e,e);c&&"function"==typeof c.then&&o.push(c)}return void Promise.all(o).then(t).catch(r)}catch(e){r(e)}}t()}function to(e,t,r){e.isString?function(e,t){var r=t.write,i=t.next;if(n(e.children)||0===e.children.length)r(e.open+(e.close||""),i);else{var o=e.children;t.renderStates.push({type:"Element",children:o,rendered:0,total:o.length,endTag:e.close}),r(e.open,i)}}(e,r):i(e.componentOptions)?no(e,t,r):i(e.tag)?function(e,t,r){var a=r.write,s=r.next;o(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs[he]="true");e.fnOptions&&ro(e.fnOptions,a);var c=function(e,t){var r,o="<"+e.tag,a=t.directives,s=t.modules;n(e.data)&&function e(t){var r=t.parent;return i(r)&&(i(r.data)||e(r))}(e)&&(e.data={});if(i(e.data)){var c=e.data.directives;if(c)for(var u=0;u<c.length;u++){var l=c[u].name;if("show"!==l){var f=Ue(t,"directives",l);f&&f(e,c[u])}}var p=function(e){var t,r;for(;i(e);)e.data&&e.data.directives&&(r=e.data.directives.find(function(e){return"show"===e.name}))&&(t=r),e=e.parent;return t}(e);p&&a.show(e,p);for(var d=0;d<s.length;d++){var v=s[d](e);v&&(o+=v)}}var h=t.activeInstance;i(h)&&h!==e.context&&i(r=h.$options._scopeId)&&(o+=" "+r);if(i(e.fnScopeId))o+=" "+e.fnScopeId;else for(;i(e);)i(r=e.context.$options._scopeId)&&(o+=" "+r),e=e.parent;return o+">"}(e,r),u="</"+e.tag+">";if(r.isUnaryTag(e.tag))a(c,s);else if(n(e.children)||0===e.children.length)a(c+u,s);else{var l=e.children;r.renderStates.push({type:"Element",children:l,rendered:0,total:l.length,endTag:u}),a(c,s)}}(e,t,r):o(e.isComment)?i(e.asyncFactory)?function(e,t,r){var n=e.asyncFactory,i=function(n){n.__esModule&&n.default&&(n=n.default);var i=e.asyncMeta,o=i.data,a=i.children,s=i.tag,c=e.asyncMeta.context,u=Vi(n,o,c,a,s);u?u.componentOptions?no(u,t,r):Array.isArray(u)?(r.renderStates.push({type:"Fragment",children:u,rendered:0,total:u.length}),r.next()):to(u,t,r):r.write("\x3c!----\x3e",r.next)};if(n.resolved)return void i(n.resolved);var o,a=r.done;try{o=n(i,a)}catch(e){a(e)}if(o)if("function"==typeof o.then)o.then(i,a).catch(a);else{var s=o.component;s&&"function"==typeof s.then&&s.then(i,a).catch(a)}}(e,t,r):r.write("\x3c!--"+e.text+"--\x3e",r.next):r.write(e.raw?e.text:D(String(e.text)),r.next)}function ro(e,t){var r=e._ssrRegister;return t.caching&&i(r)&&t.componentBuffer[t.componentBuffer.length-1].add(r),r}function no(e,t,r){var o=r.write,a=r.next,s=r.userContext,c=e.componentOptions.Ctor,u=c.options.serverCacheKey,l=c.options.name,f=r.cache,p=ro(c.options,o);if(i(u)&&i(f)&&i(l)){var d=u(e.componentOptions.propsData);if(!1===d)return void oo(e,t,r);var v=l+"::"+d,h=r.has,m=r.get;i(h)?h(v,function(n){!0===n&&i(m)?m(v,function(e){i(p)&&p(s),e.components.forEach(function(e){return e(s)}),o(e.html,a)}):io(e,t,v,r)}):i(m)&&m(v,function(n){i(n)?(i(p)&&p(s),n.components.forEach(function(e){return e(s)}),o(n.html,a)):io(e,t,v,r)})}else i(u)&&n(f)&&Gi("[vue-server-renderer] Component "+(c.options.name||"(anonymous)")+" implemented serverCacheKey, but no cache was provided to the renderer."),i(u)&&n(l)&&Gi('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),oo(e,t,r)}function io(e,t,r,n){var i=n.write;i.caching=!0;var o=i.cacheBuffer,a=o.push("")-1,s=i.componentBuffer;s.push(new Set),n.renderStates.push({type:"ComponentWithCache",key:r,buffer:o,bufferIndex:a,componentBuffer:s}),oo(e,t,n)}function oo(e,t,r){var n=r.activeInstance;e.ssrContext=r.userContext;var i=r.activeInstance=Wi(e,r.activeInstance);Yi(i);var o=r.done;eo(i,function(){var o=i._render();o.parent=e,r.renderStates.push({type:"Component",prevActive:n}),to(o,t,r)},o)}function ao(e,t,r,n){return function(i,o,a,s){Xi=Object.create(null);var c=new wt({activeInstance:i,userContext:a,write:o,done:s,renderNode:to,isUnaryTag:r,modules:e,directives:t,cache:n});!function(e){if(!e._ssrNode){for(var t=e.constructor;t.super;)t=t.super;A(t.prototype,ri),t.FunctionalRenderContext&&A(t.FunctionalRenderContext.prototype,ri)}}(i),Yi(i);eo(i,function(){to(i._render(),!0,c)},s)}}var so=function(e){return/\.js(\?[^.]+)?$/.test(e)};function co(){var e,t;return{promise:new Promise(function(r,n){e=r,t=n}),cb:function(r,n){if(r)return t(r);e(n||"")}}}var uo=function(e){function t(t,r,n){e.call(this),this.started=!1,this.renderer=t,this.template=r,this.context=n||{},this.inject=t.inject}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype._transform=function(e,t,r){this.started||(this.emit("beforeStart"),this.start()),this.push(e),r()},t.prototype.start=function(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);var e=this.renderer.renderResourceHints(this.context);e&&this.push(e);var t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))},t.prototype._flush=function(e){if(this.emit("beforeEnd"),this.inject){var t=this.renderer.renderState(this.context);t&&this.push(t);var r=this.renderer.renderScripts(this.context);r&&this.push(r)}this.push(this.template.tail(this.context)),e()},t}(require("stream").Transform),lo=require("lodash.template"),fo={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function po(e){var t=function(e){var t=new Map;return Object.keys(e.modules).forEach(function(r){t.set(r,function(e,t){var r=[],n=t.modules[e];return n&&n.forEach(function(e){var n=t.all[e];n&&(t.async.indexOf(n)>-1||!/\.(js|css)($|\?)/.test(n))&&r.push(n)}),r}(r,e))}),t}(e);return function(e){for(var r=new Set,n=0;n<e.length;n++){var i=t.get(e[n]);if(i)for(var o=0;o<i.length;o++)r.add(i[o])}return Array.from(r)}}var vo=require("path"),ho=require("serialize-javascript"),mo=function(e){this.options=e,this.inject=!1!==e.inject;var t=e.template;if(this.parsedTemplate=t?"string"==typeof t?function(e,t){if(void 0===t&&(t="\x3c!--vue-ssr-outlet--\x3e"),"object"==typeof e)return e;var r=e.indexOf("</head>"),n=e.indexOf(t);if(n<0)throw new Error("Content placeholder not found in template.");return r<0&&(r=e.indexOf("<body>"))<0&&(r=n),{head:lo(e.slice(0,r),fo),neck:lo(e.slice(r,n),fo),tail:lo(e.slice(n+t.length),fo)}}(t):t:null,this.serialize=e.serializer||function(e){return ho(e,{isJSON:!0})},e.clientManifest){var r=this.clientManifest=e.clientManifest;this.publicPath=""===r.publicPath?"":r.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(r.initial||[]).map(yo),this.prefetchFiles=(r.async||[]).map(yo),this.mapFiles=po(r)}};function yo(e){var t=e.replace(/\?.*/,""),r=vo.extname(t).slice(1);return{file:e,extension:r,fileWithoutQuery:t,asType:go(r)}}function go(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}mo.prototype.bindRenderFns=function(e){var t=this;["ResourceHints","State","Scripts","Styles"].forEach(function(r){e["render"+r]=t["render"+r].bind(t,e)}),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)},mo.prototype.render=function(e,t){var r=this.parsedTemplate;if(!r)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof r?r(e,t):this.inject?r.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+r.neck(t)+e+this.renderState(t)+this.renderScripts(t)+r.tail(t):r.head(t)+r.neck(t)+e+r.tail(t)},mo.prototype.renderStyles=function(e){var t=this,r=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],i=r.concat(n).filter(function(e){return function(e){return/\.css(\?[^.]+)?$/.test(e)}(e.file)});return(i.length?i.map(function(e){var r=e.file;return'<link rel="stylesheet" href="'+t.publicPath+r+'">'}).join(""):"")+(e.styles||"")},mo.prototype.renderResourceHints=function(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)},mo.prototype.getPreloadFiles=function(e){var t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]},mo.prototype.renderPreloadLinks=function(e){var t=this,r=this.getPreloadFiles(e),n=this.options.shouldPreload;return r.length?r.map(function(e){var r=e.file,i=e.extension,o=e.fileWithoutQuery,a=e.asType,s="";return n||"script"===a||"style"===a?n&&!n(o,a)?"":("font"===a&&(s=' type="font/'+i+'" crossorigin'),'<link rel="preload" href="'+t.publicPath+r+'"'+(""!==a?' as="'+a+'"':"")+s+">"):""}).join(""):""},mo.prototype.renderPrefetchLinks=function(e){var t=this,r=this.options.shouldPrefetch;if(this.prefetchFiles){var n=this.getUsedAsyncFiles(e);return this.prefetchFiles.map(function(e){var i=e.file,o=e.fileWithoutQuery,a=e.asType;return r&&!r(o,a)?"":function(e){return n&&n.some(function(t){return t.file===e})}(i)?"":'<link rel="prefetch" href="'+t.publicPath+i+'">'}).join("")}return""},mo.prototype.renderState=function(e,t){var r=t||{},n=r.contextKey;void 0===n&&(n="state");var i=r.windowKey;void 0===i&&(i="__INITIAL_STATE__");var o=this.serialize(e[n]),a=e.nonce?' nonce="'+e.nonce+'"':"";return e[n]?"<script"+a+">window."+i+"="+o+";(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>":""},mo.prototype.renderScripts=function(e){var t=this;if(this.clientManifest){var r=this.preloadFiles.filter(function(e){var t=e.file;return so(t)}),n=(this.getUsedAsyncFiles(e)||[]).filter(function(e){var t=e.file;return so(t)});return[r[0]].concat(n,r.slice(1)).map(function(e){var r=e.file;return'<script src="'+t.publicPath+r+'" defer><\/script>'}).join("")}return""},mo.prototype.getUsedAsyncFiles=function(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){var t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(yo)}return e._mappedFiles},mo.prototype.createStream=function(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new uo(this,this.parsedTemplate,e||{})};var bo=require("vm"),_o=require("path"),wo=require("resolve"),xo=require("module");function So(e){var t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function $o(e,t,r){var n={},i={};return function o(a,s,c){if(void 0===c&&(c={}),c[a])return c[a];var u=function(t){if(n[t])return n[t];var r=e[t],i=xo.wrap(r),o=new bo.Script(i,{filename:t,displayErrors:!0});return n[t]=o,o}(a),l={exports:{}};(!1===r?u.runInThisContext():u.runInNewContext(s)).call(l.exports,l.exports,function(r){return r=_o.posix.join(".",r),e[r]?o(r,s,c):t?require(i[r]||(i[r]=wo.sync(r,{basedir:t}))):require(r)},l);var f=Object.prototype.hasOwnProperty.call(l.exports,"default")?l.exports.default:l.exports;return c[a]=f,f}}function Ao(e,t,r,n){var i,o,a=$o(t,r,n);return!1!==n&&"once"!==n?function(t){return void 0===t&&(t={}),new Promise(function(r){t._registeredComponents=new Set;var n=a(e,So(t));r("function"==typeof n?n(t):n)})}:function(t){return void 0===t&&(t={}),new Promise(function(r){if(!i){var s="once"===n?So():global;if(o=s.__VUE_SSR_CONTEXT__={},i=a(e,s),delete s.__VUE_SSR_CONTEXT__,"function"!=typeof i)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(t._registeredComponents=new Set,o._styles){t._styles=function e(t){if(u(t)){var r={};for(var n in t)r[n]=e(t[n]);return r}return Array.isArray(t)?t.slice():t}(o._styles);var c=o._renderStyles;c&&Object.defineProperty(t,"styles",{enumerable:!0,get:function(){return c(t._styles)}})}r(i(t))})}}var Oo=require("source-map").SourceMapConsumer,ko=/\(([^)]+\.js):(\d+):(\d+)\)$/;function Co(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map(function(e){return function(e,t){var r=e.match(ko),n=r&&t[r[1]];if(null!=r&&n){var i=n.originalPositionFor({line:Number(r[2]),column:Number(r[3])});if(null!=i.source){var o=i.source,a=i.line,s=i.column,c="("+o.replace(/^webpack:\/\/\//,"")+":"+String(a)+":"+String(s)+")";return e.replace(ko,c)}return e}return e}(e,t)}).join("\n"))}var To=require("fs"),Fo=require("path"),jo=require("stream").PassThrough,Po="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Eo(e){return void 0===e&&(e={}),function(e){void 0===e&&(e={});var t=e.modules;void 0===t&&(t=[]);var r=e.directives;void 0===r&&(r={});var n=e.isUnaryTag;void 0===n&&(n=function(){return!1});var i=e.template,o=e.inject,a=e.cache,s=e.shouldPreload,c=e.shouldPrefetch,u=e.clientManifest,l=e.serializer,f=ao(t,r,n,a),p=new mo({template:i,inject:o,shouldPreload:s,shouldPrefetch:c,clientManifest:u,serializer:l});return{renderToString:function(e,t,r){var n,o;"function"==typeof t&&(r=t,t={}),t&&p.bindRenderFns(t),r||(o=(n=co()).promise,r=n.cb);var a="",s=bt(function(e){return a+=e,!1},r);try{f(e,s,t,function(e){if(e)return r(e);if(t&&t.rendered&&t.rendered(t),i)try{var n=p.render(a,t);"string"!=typeof n?n.then(function(e){return r(null,e)}).catch(r):r(null,n)}catch(e){r(e)}else r(null,a)})}catch(e){r(e)}return o},renderToStream:function(e,t){t&&p.bindRenderFns(t);var r=new _t(function(r,n){f(e,r,t,n)});if(i){if("function"==typeof i)throw new Error("function template is only supported in renderToString.");var n=p.createStream(t);if(r.on("error",function(e){n.emit("error",e)}),r.pipe(n),t&&t.rendered){var o=t.rendered;r.once("beforeEnd",function(){o(t)})}return n}if(t&&t.rendered){var a=t.rendered;r.once("beforeEnd",function(){a(t)})}return r}}}(A(A({},e),{isUnaryTag:dt,canBeLeftOpenTag:vt,modules:ut,directives:A(pt,e.directives)}))}process.env.VUE_ENV="server";var No=function(e){return function(t,r){var n,i,o;void 0===r&&(r={});var a=r.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&Fo.isAbsolute(t)){if(!To.existsSync(t))throw new Error("Cannot locate bundle file: "+t);var s=/\.json$/.test(t);if(a=a||Fo.dirname(t),t=To.readFileSync(t,"utf-8"),s)try{t=JSON.parse(t)}catch(e){throw new Error("Invalid JSON bundle file: "+t)}}if("object"==typeof t){if(i=t.entry,n=t.files,a=a||t.basedir,o=function(e){var t={};return Object.keys(e).forEach(function(r){t[r]=new Oo(e[r])}),t}(t.maps),"string"!=typeof i||"object"!=typeof n)throw new Error(Po)}else{if("string"!=typeof t)throw new Error(Po);i="__vue_ssr_bundle__",n={__vue_ssr_bundle__:t},o={}}var c=e(r),u=Ao(i,n,a,r.runInNewContext);return{renderToString:function(e,t){var r,n;return"function"==typeof e&&(t=e,e={}),t||(n=(r=co()).promise,t=r.cb),u(e).catch(function(e){Co(e,o),t(e)}).then(function(r){r&&c.renderToString(r,e,function(e,r){Co(e,o),t(e,r)})}),n},renderToStream:function(e){var t=new jo;return u(e).catch(function(e){Co(e,o),process.nextTick(function(){t.emit("error",e)})}).then(function(n){if(n){var i=c.renderToStream(n,e);i.on("error",function(e){Co(e,o),t.emit("error",e)}),r&&r.template&&(i.on("beforeStart",function(){t.emit("beforeStart")}),i.on("beforeEnd",function(){t.emit("beforeEnd")})),i.pipe(t)}}),t}}}}(Eo);exports.createRenderer=Eo,exports.createBundleRenderer=No;
\ No newline at end of file
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream");function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var n=t(require("he"));const r=Object.freeze({});function s(e){return null==e}function o(e){return null!=e}function i(e){return!0===e}function c(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}const l=Object.prototype.toString;function u(e){return"[object Object]"===l.call(e)}function f(e){return null==e?"":Array.isArray(e)||u(e)&&e.toString===l?JSON.stringify(e,null,2):String(e)}function p(e){const t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){const n=Object.create(null),r=e.split(",");for(let e=0;e<r.length;e++)n[r[e]]=!0;return t?e=>n[e.toLowerCase()]:e=>n[e]}const h=d("slot,component",!0),m=d("key,ref,slot,slot-scope,is");const y=Object.prototype.hasOwnProperty;function g(e,t){return y.call(e,t)}function $(e){const t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}const v=/-(\w)/g,b=$((e=>e.replace(v,((e,t)=>t?t.toUpperCase():"")))),_=$((e=>e.charAt(0).toUpperCase()+e.slice(1))),x=/\B([A-Z])/g,w=$((e=>e.replace(x,"-$1").toLowerCase()));function S(e,t){for(const n in t)e[n]=t[n];return e}function k(e){const t={};for(let n=0;n<e.length;n++)e[n]&&S(t,e[n]);return t}function A(e,t,n){}const O=(e,t,n)=>!1,C=e=>e;function T(e,t){if(e===t)return!0;const n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{const n=Array.isArray(e),r=Array.isArray(t);if(n&&r)return e.length===t.length&&e.every(((e,n)=>T(e,t[n])));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(n||r)return!1;{const n=Object.keys(e),r=Object.keys(t);return n.length===r.length&&n.every((n=>T(e[n],t[n])))}}catch(e){return!1}}function j(e,t){for(let n=0;n<e.length;n++)if(T(e[n],t))return n;return-1}const F=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),P=/[>/="'\u0009\u000a\u000c\u0020]/,N=e=>P.test(e),E=e=>F(e)||0===e.indexOf("data-")||0===e.indexOf("aria-"),I={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},M={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function R(e){return e.replace(/[<>"&]/g,D)}function D(e){return M[e]||e}const L={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},z=d("input,textarea,option,select,progress"),B=d("contenteditable,draggable,spellcheck"),U=d("events,caret,typing,plaintext-only"),q=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),J=e=>null==e||!1===e;function K(e,t){if(q(e)){if(!J(t))return` ${e}="${e}"`}else{if(B(e))return` ${e}="${R(((e,t)=>J(t)||"false"===t?"false":"contenteditable"===e&&U(t)?t:"true")(e,t))}"`;if(!J(t))return` ${e}="${R(String(t))}"`}return""}class H{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(e,t,n,r,s,o,i,c){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=s,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=c,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const V=(e="")=>{const t=new H;return t.text=e,t.isComment=!0,t};function W(e){return new H(void 0,void 0,void 0,String(e))}function Z(e,t,n){const r=new H(void 0,void 0,void 0,t);r.raw=n,e.children=[r]}function X(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}const G="__proto__"in{},Q="undefined"!=typeof window,Y="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,ee=(Y&&WXEnvironment.platform.toLowerCase(),Q&&window.navigator.userAgent.toLowerCase()),te=ee&&/msie|trident/.test(ee);ee&&ee.indexOf("msie 9.0");ee&&ee.indexOf("edge/");ee&&ee.indexOf("android"),ee&&/iphone|ipad|ipod|ios/.test(ee),ee&&/chrome\/\d+/.test(ee),ee&&/phantomjs/.test(ee),ee&&ee.match(/firefox\/(\d+)/);const ne={}.watch;let re,se=!1;if(Q)try{const e={};Object.defineProperty(e,"passive",{get(){se=!0}}),window.addEventListener("test-passive",null,e)}catch(e){}const oe=()=>(void 0===re&&(re=!Q&&!Y&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),re);function ie(e){return"function"==typeof e&&/native code/.test(e.toString())}const ce="undefined"!=typeof Symbol&&ie(Symbol)&&"undefined"!=typeof Reflect&&ie(Reflect.ownKeys);let ae;ae="undefined"!=typeof Set&&ie(Set)?Set:class{set=Object.create(null);has(e){return!0===this.set[e]}add(e){this.set[e]=!0}clear(){this.set=Object.create(null)}};const le=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var ue={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:O,isReservedAttr:O,isUnknownElement:O,getTagNamespace:A,parsePlatformTagName:C,mustUseProp:O,async:!0,_lifecycleHooks:le};let fe=0;class pe{static target;id;subs;constructor(){this.id=fe++,this.subs=[]}addSub(e){this.subs.push(e)}removeSub(e){!function(e,t){if(e.length){const n=e.indexOf(t);if(n>-1)e.splice(n,1)}}(this.subs,e)}depend(){pe.target&&pe.target.addDep(this)}notify(){const e=this.subs.slice();for(let t=0,n=e.length;t<n;t++)e[t].update()}}pe.target=null;const de=[];function he(e){de.push(e),pe.target=e}function me(){de.pop(),pe.target=de[de.length-1]}const ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){const t=ye[e];X(ge,e,(function(...n){const r=t.apply(this,n),s=this.__ob__;let o;switch(e){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&s.observeArray(o),s.dep.notify(),r}))}));const $e=Object.getOwnPropertyNames(ge);let ve=!0;function be(e){ve=e}class _e{value;dep;vmCount;constructor(e){this.value=e,this.dep=new pe,this.vmCount=0,X(e,"__ob__",this),Array.isArray(e)?(G?function(e,t){e.__proto__=t}(e,ge):function(e,t,n){for(let r=0,s=n.length;r<s;r++){const s=n[r];X(e,s,t[s])}}(e,ge,$e),this.observeArray(e)):this.walk(e)}walk(e){const t=Object.keys(e);for(let n=0;n<t.length;n++)we(e,t[n])}observeArray(e){for(let t=0,n=e.length;t<n;t++)xe(e[t])}}function xe(e,t){if(!a(e)||e instanceof H)return;let n;return g(e,"__ob__")&&e.__ob__ instanceof _e?n=e.__ob__:ve&&!oe()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new _e(e)),t&&n&&n.vmCount++,n}function we(e,t,n,r,s){const o=new pe,i=Object.getOwnPropertyDescriptor(e,t);if(i&&!1===i.configurable)return;const c=i&&i.get,a=i&&i.set;c&&!a||2!==arguments.length||(n=e[t]);let l=!s&&xe(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){const t=c?c.call(e):n;return pe.target&&(o.depend(),l&&(l.dep.depend(),Array.isArray(t)&&ke(t))),t},set:function(t){const r=c?c.call(e):n;t===r||t!=t&&r!=r||c&&!a||(a?a.call(e,t):n=t,l=!s&&xe(t),o.notify())}})}function Se(e,t,n){if(Array.isArray(e)&&function(e){const t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;const r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(we(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e){for(let t,n=0,r=e.length;n<r;n++)t=e[n],t&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&ke(t)}const Ae=ue.optionMergeStrategies;function Oe(e,t){if(!t)return e;let n,r,s;const o=ce?Reflect.ownKeys(t):Object.keys(t);for(let i=0;i<o.length;i++)n=o[i],"__ob__"!==n&&(r=e[n],s=t[n],g(e,n)?r!==s&&u(r)&&u(s)&&Oe(r,s):Se(e,n,s));return e}function Ce(e,t,n){return n?function(){const r="function"==typeof t?t.call(n,n):t,s="function"==typeof e?e.call(n,n):e;return r?Oe(r,s):s}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){const n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){const t=[];for(let n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function je(e,t,n,r){const s=Object.create(e||null);return t?S(s,t):s}Ae.data=function(e,t,n){return n?Ce(e,t,n):t&&"function"!=typeof t?e:Ce(e,t)},le.forEach((e=>{Ae[e]=Te})),["component","directive","filter"].forEach((function(e){Ae[e+"s"]=je})),Ae.watch=function(e,t,n,r){if(e===ne&&(e=void 0),t===ne&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;const s={};S(s,e);for(const e in t){let n=s[e];const r=t[e];n&&!Array.isArray(n)&&(n=[n]),s[e]=n?n.concat(r):Array.isArray(r)?r:[r]}return s},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;const s=Object.create(null);return S(s,e),t&&S(s,t),s},Ae.provide=Ce;const Fe=function(e,t){return void 0===t?e:t};function Pe(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){const n=e.props;if(!n)return;const r={};let s,o,i;if(Array.isArray(n))for(s=n.length;s--;)o=n[s],"string"==typeof o&&(i=b(o),r[i]={type:null});else if(u(n))for(const e in n)o=n[e],i=b(e),r[i]=u(o)?o:{type:o};e.props=r}(t),function(e,t){const n=e.inject;if(!n)return;const r=e.inject={};if(Array.isArray(n))for(let e=0;e<n.length;e++)r[n[e]]={from:n[e]};else if(u(n))for(const e in n){const t=n[e];r[e]=u(t)?S({from:e},t):{from:t}}}(t),function(e){const t=e.directives;if(t)for(const e in t){const n=t[e];"function"==typeof n&&(t[e]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=Pe(e,t.extends,n)),t.mixins))for(let r=0,s=t.mixins.length;r<s;r++)e=Pe(e,t.mixins[r],n);const r={};let s;for(s in e)o(s);for(s in t)g(e,s)||o(s);function o(s){const o=Ae[s]||Fe;r[s]=o(e[s],t[s],n,s)}return r}function Ne(e,t,n,r){if("string"!=typeof n)return;const s=e[t];if(g(s,n))return s[n];const o=b(n);if(g(s,o))return s[o];const i=_(o);if(g(s,i))return s[i];return s[n]||s[o]||s[i]}function Ee(e,t,n,r){const s=t[e],o=!g(n,e);let i=n[e];const c=De(Boolean,s.type);if(c>-1)if(o&&!g(s,"default"))i=!1;else if(""===i||i===w(e)){const e=De(String,s.type);(e<0||c<e)&&(i=!0)}if(void 0===i){i=function(e,t,n){if(!g(t,"default"))return;const r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Me(t.type)?r.call(e):r}(r,s,e);const t=ve;be(!0),xe(i),be(t)}return i}const Ie=/^\s*function (\w+)/;function Me(e){const t=e&&e.toString().match(Ie);return t?t[1]:""}function Re(e,t){return Me(e)===Me(t)}function De(e,t){if(!Array.isArray(t))return Re(t,e)?0:-1;for(let n=0,r=t.length;n<r;n++)if(Re(t[n],e))return n;return-1}function Le(e,t,n){he();try{if(t){let r=t;for(;r=r.$parent;){const s=r.$options.errorCaptured;if(s)for(let o=0;o<s.length;o++)try{if(!1===s[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}}Be(e,t,n)}finally{me()}}function ze(e,t,n,r,s){let i;try{i=n?e.apply(t,n):e.call(t),i&&!i._isVue&&(o(c=i)&&"function"==typeof c.then&&"function"==typeof c.catch)&&!i._handled&&(i.catch((e=>Le(e,r,s+" (Promise/async)"))),i._handled=!0)}catch(e){Le(e,r,s)}var c;return i}function Be(e,t,n){!function(e,t,n){if(!Q&&!Y||"undefined"==typeof console)throw e;console.error(e)}(e)}const Ue=[];if("undefined"!=typeof Promise&&ie(Promise))Promise.resolve();else if(te||"undefined"==typeof MutationObserver||!ie(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&ie(setImmediate);else{let e=1;const t=new MutationObserver((function(){const e=Ue.slice(0);Ue.length=0;for(let t=0;t<e.length;t++)e[t]()})),n=document.createTextNode(String(e));t.observe(n,{characterData:!0})}function qe(e,t){return{staticClass:Ke(e.staticClass,t.staticClass),class:o(e.class)?[e.class,t.class]:t.class}}function Je(e,t){return o(e)||o(t)?Ke(e,He(t)):""}function Ke(e,t){return e?t?e+" "+t:e:t||""}function He(e){return Array.isArray(e)?function(e){let t,n="";for(let r=0,s=e.length;r<s;r++)o(t=He(e[r]))&&""!==t&&(n&&(n+=" "),n+=t);return n}(e):a(e)?function(e){let t="";for(const n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}const Ve=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),We=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);const Ze=$((function(e){const t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){const r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function Xe(e){const t=Ge(e.style);return e.staticStyle?S(e.staticStyle,t):t}function Ge(e){return Array.isArray(e)?k(e):"string"==typeof e?Ze(e):e}function Qe(e){let t="";for(const n in e){const r=e[n],s=w(n);if(Array.isArray(r))for(let e=0,n=r.length;e<n;e++)t+=Ye(s,r[e]);else t+=Ye(s,r)}return t}function Ye(e,t){return"string"==typeof t||"number"==typeof t&&L[e]||0===t?`${e}:${t};`:""}var et=[function(e){let t=e.data.attrs,n="";const r=e.parent&&e.parent.componentOptions;if(s(r)||!1!==r.Ctor.options.inheritAttrs){let n=e.parent;for(;o(n)&&(!n.componentOptions||!1!==n.componentOptions.Ctor.options.inheritAttrs);)o(n.data)&&o(n.data.attrs)&&(t=S(S({},t),n.data.attrs)),n=n.parent}if(s(t))return n;for(const e in t)N(e)||"style"!==e&&(n+=K(e,t[e]));return n},function(e){let t=e.data.domProps,n="",r=e.parent;for(;o(r);)r.data&&r.data.domProps&&(t=S(S({},t),r.data.domProps)),r=r.parent;if(s(t))return n;const i=e.data.attrs;for(const r in t)if("innerHTML"===r)Z(e,t[r],!0);else if("textContent"===r)Z(e,t[r],!1);else if("value"===r&&"textarea"===e.tag)Z(e,f(t[r]),!1);else{const e=I[r]||r.toLowerCase();!E(e)||o(i)&&o(i[e])||(n+=K(e,t[r]))}return n},function(e){const t=function(e){let t=e.data,n=e,r=e;for(;o(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(t=qe(r.data,t));for(;o(n=n.parent);)n&&n.data&&(t=qe(t,n.data));return Je(t.staticClass,t.class)}(e);if(""!==t)return` class="${R(t)}"`},function(e){const t=Qe(function(e,t){const n={};let r;if(t){let t=e;for(;t.componentInstance;)t=t.componentInstance._vnode,t&&t.data&&(r=Xe(t.data))&&S(n,r)}(r=Xe(e.data))&&S(n,r);let s=e;for(;s=s.parent;)s.data&&(r=Xe(s.data))&&S(n,r);return n}(e,!1));if(""!==t)return` style=${JSON.stringify(R(t))}`}];function tt(e){const t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function nt(e){const t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var rt={show:function(e,t){if(!t.value){const t=e.data.style||(e.data.style={});Array.isArray(t)?t.push({display:"none"}):t.display="none"}},model:function(e,t){if(!e.children)return;const n=t.value,r=e.data.attrs&&e.data.attrs.multiple;for(let t=0,s=e.children.length;t<s;t++){const s=e.children[t];if("option"===s.tag)if(r){Array.isArray(n)&&j(n,tt(s))>-1&&nt(s)}else if(T(n,tt(s)))return void nt(s)}}};const st=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),ot=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),it=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ct=e=>e,at="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?e=>Promise.resolve().then(e):"undefined"!=typeof setTimeout?setTimeout:ct;if(at===ct)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function lt(e,t){let n=0;const r=(s,o)=>{s&&r.caching&&(r.cacheBuffer[r.cacheBuffer.length-1]+=s);!0!==e(s,o)&&(n>=800?at((()=>{try{o()}catch(e){t(e)}})):(n++,o(),n--))};return r.caching=!1,r.cacheBuffer=[],r.componentBuffer=[],r}class ut extends e.Readable{buffer;render;expectedSize;write;next;end;done;constructor(e){super(),this.buffer="",this.render=e,this.expectedSize=0,this.write=lt(((e,t)=>{const n=this.expectedSize;return this.buffer+=e,this.buffer.length>=n&&(this.next=t,this.pushBySize(n),!0)}),(e=>{this.emit("error",e)})),this.end=()=>{this.emit("beforeEnd"),this.done=!0,this.push(this.buffer)}}pushBySize(e){const t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)}tryRender(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}}tryNext(){try{this.next()}catch(e){this.emit("error",e)}}_read(e){this.expectedSize=e,i(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):s(this.next)?this.tryRender():this.tryNext()}}class ft{userContext;activeInstance;renderStates;write;renderNode;next;done;modules;directives;isUnaryTag;cache;get;has;constructor(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;const t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&pt(t,"get"),this.has=t&&pt(t,"has"),this.next=this.next.bind(this)}next(){for(;;){const e=this.renderStates[this.renderStates.length-1];if(s(e))return this.done();switch(e.type){case"Element":case"Fragment":const{children:t,total:n}=e,r=e.rendered++;if(r<n)return this.renderNode(t[r],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();const{buffer:s,bufferIndex:o,componentBuffer:i,key:c}=e,a={html:s[o],components:i[o]};if(this.cache.set(c,a),0===o)this.write.caching=!1;else{s[o-1]+=a.html;const e=i[o-1];a.components.forEach((t=>e.add(t)))}s.length=o,i.length=o}}}}function pt(e,t){const n=e[t];return s(n)?void 0:n.length>1?(t,r)=>n.call(e,t,r):(t,r)=>r(n.call(e,t))}const dt=/[\w).+\-_$\]]/;function ht(e){let t,n,r,s,o,i=!1,c=!1,a=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),i)39===t&&92!==n&&(i=!1);else if(c)34===t&&92!==n&&(c=!1);else if(a)96===t&&92!==n&&(a=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:c=!0;break;case 39:i=!0;break;case 96:a=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){let t,n=r-1;for(;n>=0&&(t=e.charAt(n)," "===t);n--);t&&dt.test(t)||(l=!0)}}else void 0===s?(d=r+1,s=e.slice(0,r).trim()):h();function h(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===s?s=e.slice(0,r).trim():0!==d&&h(),o)for(r=0;r<o.length;r++)s=mt(s,o[r]);return s}function mt(e,t){const n=t.indexOf("(");if(n<0)return`_f("${t}")(${e})`;{const r=t.slice(0,n),s=t.slice(n+1);return`_f("${r}")(${e}${")"!==s?","+s:s}`}}const yt=/\{\{((?:.|\r?\n)+?)\}\}/g,gt=/[-.*+?^${}()|[\]\/\\]/g,$t=$((e=>{const t=e[0].replace(gt,"\\$&"),n=e[1].replace(gt,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));function vt(e,t){console.error(`[Vue compiler]: ${e}`)}function bt(e,t){return e?e.map((e=>e[t])).filter((e=>e)):[]}function _t(e,t,n,r,s){(e.props||(e.props=[])).push(jt({name:t,value:n,dynamic:s},r)),e.plain=!1}function xt(e,t,n,r,s){(s?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(jt({name:t,value:n,dynamic:s},r)),e.plain=!1}function wt(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(jt({name:t,value:n},r))}function St(e,t,n,r,s,o,i,c){(e.directives||(e.directives=[])).push(jt({name:t,rawName:n,value:r,arg:s,isDynamicArg:o,modifiers:i},c)),e.plain=!1}function kt(e,t,n){return n?`_p(${t},"${e}")`:e+t}function At(e,t,n,s,o,i,c,a){let l;(s=s||r).right?a?t=`(${t})==='click'?'contextmenu':(${t})`:"click"===t&&(t="contextmenu",delete s.right):s.middle&&(a?t=`(${t})==='click'?'mouseup':(${t})`:"click"===t&&(t="mouseup")),s.capture&&(delete s.capture,t=kt("!",t,a)),s.once&&(delete s.once,t=kt("~",t,a)),s.passive&&(delete s.passive,t=kt("&",t,a)),s.native?(delete s.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=jt({value:n.trim(),dynamic:a},c);s!==r&&(u.modifiers=s);const f=l[t];Array.isArray(f)?o?f.unshift(u):f.push(u):l[t]=f?o?[u,f]:[f,u]:u,e.plain=!1}function Ot(e,t,n){const r=Ct(e,":"+t)||Ct(e,"v-bind:"+t);if(null!=r)return ht(r);if(!1!==n){const n=Ct(e,t);if(null!=n)return JSON.stringify(n)}}function Ct(e,t,n){let r;if(null!=(r=e.attrsMap[t])){const n=e.attrsList;for(let e=0,r=n.length;e<r;e++)if(n[e].name===t){n.splice(e,1);break}}return n&&delete e.attrsMap[t],r}function Tt(e,t){const n=e.attrsList;for(let e=0,r=n.length;e<r;e++){const r=n[e];if(t.test(r.name))return n.splice(e,1),r}}function jt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var Ft={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;const n=Ct(e,"class");n&&(e.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const r=Ot(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){let t="";return e.staticClass&&(t+=`staticClass:${e.staticClass},`),e.classBinding&&(t+=`class:${e.classBinding},`),t}};var Pt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;const n=Ct(e,"style");n&&(e.staticStyle=JSON.stringify(Ze(n)));const r=Ot(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){let t="";return e.staticStyle&&(t+=`staticStyle:${e.staticStyle},`),e.styleBinding&&(t+=`style:(${e.styleBinding}),`),t}};const Nt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Et=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,It=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source}]*`,Mt=`((?:${It}\\:)?${It})`,Rt=new RegExp(`^<${Mt}`),Dt=/^\s*(\/?)>/,Lt=new RegExp(`^<\\/${Mt}[^>]*>`),zt=/^<!DOCTYPE [^>]+>/i,Bt=/^<!\--/,Ut=/^<!\[/,qt=d("script,style,textarea",!0),Jt={},Kt={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ht=/&(?:lt|gt|quot|amp|#39);/g,Vt=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Wt=d("pre,textarea",!0),Zt=(e,t)=>e&&Wt(e)&&"\n"===t[0];function Xt(e,t){const n=t?Vt:Ht;return e.replace(n,(e=>Kt[e]))}function Gt(e,t,n){const{number:r,trim:s}=n||{},o="$$v";let i=o;s&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),r&&(i=`_n(${i})`);const c=Qt(t,i);e.model={value:`(${t})`,expression:JSON.stringify(t),callback:`function ($$v) {${c}}`}}function Qt(e,t){const n=function(e){if(e=e.trim(),Yt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Yt-1)return nn=e.lastIndexOf("."),nn>-1?{exp:e.slice(0,nn),key:'"'+e.slice(nn+1)+'"'}:{exp:e,key:null};en=e,nn=rn=sn=0;for(;!cn();)tn=on(),an(tn)?un(tn):91===tn&&ln(tn);return{exp:e.slice(0,rn),key:e.slice(rn+1,sn)}}(e);return null===n.key?`${e}=${t}`:`$set(${n.exp}, ${n.key}, ${t})`}let Yt,en,tn,nn,rn,sn;function on(){return en.charCodeAt(++nn)}function cn(){return nn>=Yt}function an(e){return 34===e||39===e}function ln(e){let t=1;for(rn=nn;!cn();)if(an(e=on()))un(e);else if(91===e&&t++,93===e&&t--,0===t){sn=nn;break}}function un(e){const t=e;for(;!cn()&&(e=on())!==t;);}const fn=/^@|^v-on:/,pn=/^v-|^@|^:|^#/,dn=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,hn=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,mn=/^\(|\)$/g,yn=/^\[.*\]$/,gn=/:(.*)$/,$n=/^:|^\.|^v-bind:/,vn=/\.[^.\]]+(?=[^\]]*$)/g,bn=/^v-slot(:|$)|^#/,_n=/[\r\n]/,xn=/[ \f\t\r\n]+/g,wn=$(n.default.decode);let Sn,kn,An,On,Cn,Tn,jn,Fn;function Pn(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Ln(t),rawAttrsMap:{},parent:n,children:[]}}function Nn(e,t){Sn=t.warn||vt,Tn=t.isPreTag||O,jn=t.mustUseProp||O,Fn=t.getTagNamespace||O,t.isReservedTag,An=bt(t.modules,"transformNode"),On=bt(t.modules,"preTransformNode"),Cn=bt(t.modules,"postTransformNode"),kn=t.delimiters;const n=[],r=!1!==t.preserveWhitespace,s=t.whitespace;let o,i,c=!1,a=!1;function l(e){if(u(e),c||e.processed||(e=En(e,t)),n.length||e===o||o.if&&(e.elseif||e.else)&&Mn(o,{exp:e.elseif,block:e}),i&&!e.forbidden)if(e.elseif||e.else)!function(e,t){const n=function(e){let t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(t.children);n&&n.if&&Mn(n,{exp:e.elseif,block:e})}(e,i);else{if(e.slotScope){const t=e.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[t]=e}i.children.push(e),e.parent=i}e.children=e.children.filter((e=>!e.slotScope)),u(e),e.pre&&(c=!1),Tn(e.tag)&&(a=!1);for(let n=0;n<Cn.length;n++)Cn[n](e,t)}function u(e){if(!a){let t;for(;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}}return function(e,t){const n=[],r=t.expectHTML,s=t.isUnaryTag||O,o=t.canBeLeftOpenTag||O;let i,c,a=0;for(;e;){if(i=e,c&&qt(c)){let n=0;const r=c.toLowerCase(),s=Jt[r]||(Jt[r]=new RegExp("([\\s\\S]*?)(</"+r+"[^>]*>)","i")),o=e.replace(s,(function(e,s,o){return n=o.length,qt(r)||"noscript"===r||(s=s.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Zt(r,s)&&(s=s.slice(1)),t.chars&&t.chars(s),""}));a+=e.length-o.length,e=o,p(r,a-n,a)}else{let n,r,s,o=e.indexOf("<");if(0===o){if(Bt.test(e)){const n=e.indexOf("--\x3e");if(n>=0){t.shouldKeepComment&&t.comment(e.substring(4,n),a,a+n+3),l(n+3);continue}}if(Ut.test(e)){const t=e.indexOf("]>");if(t>=0){l(t+2);continue}}const n=e.match(zt);if(n){l(n[0].length);continue}const r=e.match(Lt);if(r){const e=a;l(r[0].length),p(r[1],e,a);continue}const s=u();if(s){f(s),Zt(s.tagName,e)&&l(1);continue}}if(o>=0){for(r=e.slice(o);!(Lt.test(r)||Rt.test(r)||Bt.test(r)||Ut.test(r)||(s=r.indexOf("<",1),s<0));)o+=s,r=e.slice(o);n=e.substring(0,o)}o<0&&(n=e),n&&l(n.length),t.chars&&n&&t.chars(n,a-n.length,a)}if(e===i){t.chars&&t.chars(e);break}}function l(t){a+=t,e=e.substring(t)}function u(){const t=e.match(Rt);if(t){const n={tagName:t[1],attrs:[],start:a};let r,s;for(l(t[0].length);!(r=e.match(Dt))&&(s=e.match(Et)||e.match(Nt));)s.start=a,l(s[0].length),s.end=a,n.attrs.push(s);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=a,n}}function f(e){const i=e.tagName,a=e.unarySlash;r&&("p"===c&&it(i)&&p(c),o(i)&&c===i&&p(i));const l=s(i)||!!a,u=e.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const r=e.attrs[n],s=r[3]||r[4]||r[5]||"",o="a"===i&&"href"===r[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[n]={name:r[1],value:Xt(s,o)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:e.start,end:e.end}),c=i),t.start&&t.start(i,f,l,e.start,e.end)}function p(e,r,s){let o,i;if(null==r&&(r=a),null==s&&(s=a),e)for(i=e.toLowerCase(),o=n.length-1;o>=0&&n[o].lowerCasedTag!==i;o--);else o=0;if(o>=0){for(let e=n.length-1;e>=o;e--)t.end&&t.end(n[e].tag,r,s);n.length=o,c=o&&n[o-1].tag}else"br"===i?t.start&&t.start(e,[],!0,r,s):"p"===i&&(t.start&&t.start(e,[],!1,r,s),t.end&&t.end(e,r,s))}p()}(e,{warn:Sn,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start(e,r,s,u,f){const p=i&&i.ns||Fn(e);te&&"svg"===p&&(r=function(e){const t=[];for(let n=0;n<e.length;n++){const r=e[n];zn.test(r.name)||(r.name=r.name.replace(Bn,""),t.push(r))}return t}(r));let d=Pn(e,r,i);var h;p&&(d.ns=p),"style"!==(h=d).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||oe()||(d.forbidden=!0);for(let e=0;e<On.length;e++)d=On[e](d,t)||d;c||(!function(e){null!=Ct(e,"v-pre")&&(e.pre=!0)}(d),d.pre&&(c=!0)),Tn(d.tag)&&(a=!0),c?function(e){const t=e.attrsList,n=t.length;if(n){const r=e.attrs=new Array(n);for(let e=0;e<n;e++)r[e]={name:t[e].name,value:JSON.stringify(t[e].value)},null!=t[e].start&&(r[e].start=t[e].start,r[e].end=t[e].end)}else e.pre||(e.plain=!0)}(d):d.processed||(In(d),function(e){const t=Ct(e,"v-if");if(t)e.if=t,Mn(e,{exp:t,block:e});else{null!=Ct(e,"v-else")&&(e.else=!0);const t=Ct(e,"v-else-if");t&&(e.elseif=t)}}(d),function(e){null!=Ct(e,"v-once")&&(e.once=!0)}(d)),o||(o=d),s?l(d):(i=d,n.push(d))},end(e,t,r){const s=n[n.length-1];n.length-=1,i=n[n.length-1],l(s)},chars(e,t,n){if(!i)return;if(te&&"textarea"===i.tag&&i.attrsMap.placeholder===e)return;const o=i.children;var l;if(e=a||e.trim()?"script"===(l=i).tag||"style"===l.tag?e:wn(e):o.length?s?"condense"===s&&_n.test(e)?"":" ":r?" ":"":""){let t,n;a||"condense"!==s||(e=e.replace(xn," ")),!c&&" "!==e&&(t=function(e,t){const n=t?$t(t):yt;if(!n.test(e))return;const r=[],s=[];let o,i,c,a=n.lastIndex=0;for(;o=n.exec(e);){i=o.index,i>a&&(s.push(c=e.slice(a,i)),r.push(JSON.stringify(c)));const t=ht(o[1].trim());r.push(`_s(${t})`),s.push({"@binding":t}),a=i+o[0].length}return a<e.length&&(s.push(c=e.slice(a)),r.push(JSON.stringify(c))),{expression:r.join("+"),tokens:s}}(e,kn))?n={type:2,expression:t.expression,tokens:t.tokens,text:e}:" "===e&&o.length&&" "===o[o.length-1].text||(n={type:3,text:e}),n&&o.push(n)}},comment(e,t,n){if(i){const t={type:3,text:e,isComment:!0};i.children.push(t)}}}),o}function En(e,t){var n;!function(e){const t=Ot(e,"key");t&&(e.key=t)}(e),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){const t=Ot(e,"ref");t&&(e.ref=t,e.refInFor=function(e){let t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){let t;"template"===e.tag?(t=Ct(e,"scope"),e.slotScope=t||Ct(e,"slot-scope")):(t=Ct(e,"slot-scope"))&&(e.slotScope=t);const n=Ot(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||xt(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){const t=Tt(e,bn);if(t){const{name:n,dynamic:r}=Rn(t);e.slotTarget=n,e.slotTargetDynamic=r,e.slotScope=t.value||"_empty_"}}else{const t=Tt(e,bn);if(t){const n=e.scopedSlots||(e.scopedSlots={}),{name:r,dynamic:s}=Rn(t),o=n[r]=Pn("template",[],e);o.slotTarget=r,o.slotTargetDynamic=s,o.children=e.children.filter((e=>{if(!e.slotScope)return e.parent=o,!0})),o.slotScope=t.value||"_empty_",e.children=[],e.plain=!1}}}(e),"slot"===(n=e).tag&&(n.slotName=Ot(n,"name")),function(e){let t;(t=Ot(e,"is"))&&(e.component=t);null!=Ct(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(let n=0;n<An.length;n++)e=An[n](e,t)||e;return function(e){const t=e.attrsList;let n,r,s,o,i,c,a,l;for(n=0,r=t.length;n<r;n++)if(s=o=t[n].name,i=t[n].value,pn.test(s))if(e.hasBindings=!0,c=Dn(s.replace(pn,"")),c&&(s=s.replace(vn,"")),$n.test(s))s=s.replace($n,""),i=ht(i),l=yn.test(s),l&&(s=s.slice(1,-1)),c&&(c.prop&&!l&&(s=b(s),"innerHtml"===s&&(s="innerHTML")),c.camel&&!l&&(s=b(s)),c.sync&&(a=Qt(i,"$event"),l?At(e,`"update:"+(${s})`,a,null,!1,0,t[n],!0):(At(e,`update:${b(s)}`,a,null,!1,0,t[n]),w(s)!==b(s)&&At(e,`update:${w(s)}`,a,null,!1,0,t[n])))),c&&c.prop||!e.component&&jn(e.tag,e.attrsMap.type,s)?_t(e,s,i,t[n],l):xt(e,s,i,t[n],l);else if(fn.test(s))s=s.replace(fn,""),l=yn.test(s),l&&(s=s.slice(1,-1)),At(e,s,i,c,!1,0,t[n],l);else{s=s.replace(pn,"");const r=s.match(gn);let a=r&&r[1];l=!1,a&&(s=s.slice(0,-(a.length+1)),yn.test(a)&&(a=a.slice(1,-1),l=!0)),St(e,s,o,i,a,l,c,t[n])}else xt(e,s,JSON.stringify(i),t[n]),!e.component&&"muted"===s&&jn(e.tag,e.attrsMap.type,s)&&_t(e,s,"true",t[n])}(e),e}function In(e){let t;if(t=Ct(e,"v-for")){const n=function(e){const t=e.match(dn);if(!t)return;const n={};n.for=t[2].trim();const r=t[1].trim().replace(mn,""),s=r.match(hn);s?(n.alias=r.replace(hn,"").trim(),n.iterator1=s[1].trim(),s[2]&&(n.iterator2=s[2].trim())):n.alias=r;return n}(t);n&&S(e,n)}}function Mn(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Rn(e){let t=e.name.replace(bn,"");return t||"#"!==e.name[0]&&(t="default"),yn.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:`"${t}"`,dynamic:!1}}function Dn(e){const t=e.match(vn);if(t){const e={};return t.forEach((t=>{e[t.slice(1)]=!0})),e}}function Ln(e){const t={};for(let n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}const zn=/^xmlns:NS\d+/,Bn=/^NS\d+:/;function Un(e){return Pn(e.tag,e.attrsList.slice(),e.parent)}var qn=[Ft,Pt,{preTransformNode:function(e,t){if("input"===e.tag){const n=e.attrsMap;if(!n["v-model"])return;let r;if((n[":type"]||n["v-bind:type"])&&(r=Ot(e,"type")),n.type||r||!n["v-bind"]||(r=`(${n["v-bind"]}).type`),r){const n=Ct(e,"v-if",!0),s=n?`&&(${n})`:"",o=null!=Ct(e,"v-else",!0),i=Ct(e,"v-else-if",!0),c=Un(e);In(c),wt(c,"type","checkbox"),En(c,t),c.processed=!0,c.if=`(${r})==='checkbox'`+s,Mn(c,{exp:c.if,block:c});const a=Un(e);Ct(a,"v-for",!0),wt(a,"type","radio"),En(a,t),Mn(c,{exp:`(${r})==='radio'`+s,block:a});const l=Un(e);return Ct(l,"v-for",!0),wt(l,":type",r),En(l,t),Mn(c,{exp:n,block:l}),o?c.else=!0:i&&(c.elseif=i),c}}}}];const Jn={expectHTML:!0,modules:qn,directives:{model:function(e,t,n){const r=t.value,s=t.modifiers,o=e.tag,i=e.attrsMap.type;if(e.component)return Gt(e,r,s),!1;if("select"===o)!function(e,t,n){const r=n&&n.number;let s=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${r?"_n(val)":"val"}});`;s=`${s} ${Qt(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,At(e,"change",s,null,!0)}(e,r,s);else if("input"===o&&"checkbox"===i)!function(e,t,n){const r=n&&n.number,s=Ot(e,"value")||"null",o=Ot(e,"true-value")||"true",i=Ot(e,"false-value")||"false";_t(e,"checked",`Array.isArray(${t})?_i(${t},${s})>-1`+("true"===o?`:(${t})`:`:_q(${t},${o})`)),At(e,"change",`var $$a=${t},$$el=$event.target,$$c=$$el.checked?(${o}):(${i});if(Array.isArray($$a)){var $$v=${r?"_n("+s+")":s},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${Qt(t,"$$a.concat([$$v])")})}else{$$i>-1&&(${Qt(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${Qt(t,"$$c")}}`,null,!0)}(e,r,s);else if("input"===o&&"radio"===i)!function(e,t,n){const r=n&&n.number;let s=Ot(e,"value")||"null";s=r?`_n(${s})`:s,_t(e,"checked",`_q(${t},${s})`),At(e,"change",Qt(t,s),null,!0)}(e,r,s);else{if("input"!==o&&"textarea"!==o)return Gt(e,r,s),!1;!function(e,t,n){const r=e.attrsMap.type,{lazy:s,number:o,trim:i}=n||{},c=!s&&"range"!==r,a=s?"change":"range"===r?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");o&&(l=`_n(${l})`);let u=Qt(t,l);c&&(u=`if($event.target.composing)return;${u}`);_t(e,"value",`(${t})`),At(e,a,u,null,!0),(i||o)&&At(e,"blur","$forceUpdate()")}(e,r,s)}return!0},text:function(e,t){t.value&&_t(e,"textContent",`_s(${t.value})`,t)},html:function(e,t){t.value&&_t(e,"innerHTML",`_s(${t.value})`,t)}},isPreTag:e=>"pre"===e,isUnaryTag:st,mustUseProp:(e,t,n)=>"value"===n&&z(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e,canBeLeftOpenTag:ot,isReservedTag:e=>Ve(e)||We(e),getTagNamespace:function(e){return We(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(((e,t)=>e.concat(t.staticKeys||[])),[]).join(",")}(qn)},Kn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Hn=/\([^)]*?\);*$/,Vn=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wn={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Xn=e=>`if(${e})return null;`,Gn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Xn("$event.target !== $event.currentTarget"),ctrl:Xn("!$event.ctrlKey"),shift:Xn("!$event.shiftKey"),alt:Xn("!$event.altKey"),meta:Xn("!$event.metaKey"),left:Xn("'button' in $event && $event.button !== 0"),middle:Xn("'button' in $event && $event.button !== 1"),right:Xn("'button' in $event && $event.button !== 2")};function Qn(e,t){const n=t?"nativeOn:":"on:";let r="",s="";for(const t in e){const n=Yn(e[t]);e[t]&&e[t].dynamic?s+=`${t},${n},`:r+=`"${t}":${n},`}return r=`{${r.slice(0,-1)}}`,s?n+`_d(${r},[${s.slice(0,-1)}])`:n+r}function Yn(e){if(!e)return"function(){}";if(Array.isArray(e))return`[${e.map((e=>Yn(e))).join(",")}]`;const t=Vn.test(e.value),n=Kn.test(e.value),r=Vn.test(e.value.replace(Hn,""));if(e.modifiers){let s="",o="";const i=[];for(const t in e.modifiers)if(Gn[t])o+=Gn[t],Wn[t]&&i.push(t);else if("exact"===t){const t=e.modifiers;o+=Xn(["ctrl","shift","alt","meta"].filter((e=>!t[e])).map((e=>`$event.${e}Key`)).join("||"))}else i.push(t);i.length&&(s+=function(e){return`if(!$event.type.indexOf('key')&&${e.map(er).join("&&")})return null;`}(i)),o&&(s+=o);return`function($event){${s}${t?`return ${e.value}.apply(null, arguments)`:n?`return (${e.value}).apply(null, arguments)`:r?`return ${e.value}`:e.value}}`}return t||n?e.value:`function($event){${r?`return ${e.value}`:e.value}}`}function er(e){const t=parseInt(e,10);if(t)return`$event.keyCode!==${t}`;const n=Wn[e],r=Zn[e];return`_k($event.keyCode,${JSON.stringify(e)},${JSON.stringify(n)},$event.key,${JSON.stringify(r)})`}var tr={on:function(e,t){e.wrapListeners=e=>`_g(${e},${t.value})`},bind:function(e,t){e.wrapData=n=>`_b(${n},'${e.tag}',${t.value},${t.modifiers&&t.modifiers.prop?"true":"false"}${t.modifiers&&t.modifiers.sync?",true":""})`},cloak:A};class nr{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(e){this.options=e,this.warn=e.warn||vt,this.transforms=bt(e.modules,"transformCode"),this.dataGenFns=bt(e.modules,"genData"),this.directives=S(S({},tr),e.directives);const t=e.isReservedTag||O;this.maybeComponent=e=>!!e.component||!t(e.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function rr(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return sr(e,t);if(e.once&&!e.onceProcessed)return or(e,t);if(e.for&&!e.forProcessed)return ar(e,t);if(e.if&&!e.ifProcessed)return ir(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){const n=e.slotName||'"default"',r=pr(e,t);let s=`_t(${n}${r?`,function(){return ${r}}`:""}`;const o=e.attrs||e.dynamicAttrs?yr((e.attrs||[]).concat(e.dynamicAttrs||[]).map((e=>({name:b(e.name),value:e.value,dynamic:e.dynamic})))):null,i=e.attrsMap["v-bind"];!o&&!i||r||(s+=",null");o&&(s+=`,${o}`);i&&(s+=`${o?"":",null"},${i}`);return s+")"}(e,t);{let n;if(e.component)n=function(e,t,n){const r=t.inlineTemplate?null:pr(t,n,!0);return`_c(${e},${lr(t,n)}${r?`,${r}`:""})`}(e.component,e,t);else{let r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=lr(e,t));const s=e.inlineTemplate?null:pr(e,t,!0);n=`_c('${e.tag}'${r?`,${r}`:""}${s?`,${s}`:""})`}for(let r=0;r<t.transforms.length;r++)n=t.transforms[r](e,n);return n}}return pr(e,t)||"void 0"}function sr(e,t){e.staticProcessed=!0;const n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push(`with(this){return ${rr(e,t)}}`),t.pre=n,`_m(${t.staticRenderFns.length-1}${e.staticInFor?",true":""})`}function or(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ir(e,t);if(e.staticInFor){let n="",r=e.parent;for(;r;){if(r.for){n=r.key;break}r=r.parent}return n?`_o(${rr(e,t)},${t.onceId++},${n})`:rr(e,t)}return sr(e,t)}function ir(e,t,n,r){return e.ifProcessed=!0,cr(e.ifConditions.slice(),t,n,r)}function cr(e,t,n,r){if(!e.length)return r||"_e()";const s=e.shift();return s.exp?`(${s.exp})?${o(s.block)}:${cr(e,t,n,r)}`:`${o(s.block)}`;function o(e){return n?n(e,t):e.once?or(e,t):rr(e,t)}}function ar(e,t,n,r){const s=e.for,o=e.alias,i=e.iterator1?`,${e.iterator1}`:"",c=e.iterator2?`,${e.iterator2}`:"";return e.forProcessed=!0,`${r||"_l"}((${s}),function(${o}${i}${c}){return ${(n||rr)(e,t)}})`}function lr(e,t){let n="{";const r=function(e,t){const n=e.directives;if(!n)return;let r,s,o,i,c="directives:[",a=!1;for(r=0,s=n.length;r<s;r++){o=n[r],i=!0;const s=t.directives[o.name];s&&(i=!!s(e,o,t.warn)),i&&(a=!0,c+=`{name:"${o.name}",rawName:"${o.rawName}"${o.value?`,value:(${o.value}),expression:${JSON.stringify(o.value)}`:""}${o.arg?`,arg:${o.isDynamicArg?o.arg:`"${o.arg}"`}`:""}${o.modifiers?`,modifiers:${JSON.stringify(o.modifiers)}`:""}},`)}if(a)return c.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+=`key:${e.key},`),e.ref&&(n+=`ref:${e.ref},`),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+=`tag:"${e.tag}",`);for(let r=0;r<t.dataGenFns.length;r++)n+=t.dataGenFns[r](e);if(e.attrs&&(n+=`attrs:${yr(e.attrs)},`),e.props&&(n+=`domProps:${yr(e.props)},`),e.events&&(n+=`${Qn(e.events,!1)},`),e.nativeEvents&&(n+=`${Qn(e.nativeEvents,!0)},`),e.slotTarget&&!e.slotScope&&(n+=`slot:${e.slotTarget},`),e.scopedSlots&&(n+=`${function(e,t,n){let r=e.for||Object.keys(t).some((e=>{const n=t[e];return n.slotTargetDynamic||n.if||n.for||ur(n)})),s=!!e.if;if(!r){let t=e.parent;for(;t;){if(t.slotScope&&"_empty_"!==t.slotScope||t.for){r=!0;break}t.if&&(s=!0),t=t.parent}}const o=Object.keys(t).map((e=>fr(t[e],n))).join(",");return`scopedSlots:_u([${o}]${r?",null,true":""}${!r&&s?`,null,false,${function(e){let t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o)}`:""})`}(e,e.scopedSlots,t)},`),e.model&&(n+=`model:{value:${e.model.value},callback:${e.model.callback},expression:${e.model.expression}},`),e.inlineTemplate){const r=function(e,t){const n=e.children[0];if(n&&1===n.type){const e=function(e,t){const n=new nr(t);return{render:`with(this){return ${e?"script"===e.tag?"null":rr(e,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}(n,t.options);return`inlineTemplate:{render:function(){${e.render}},staticRenderFns:[${e.staticRenderFns.map((e=>`function(){${e}}`)).join(",")}]}`}}(e,t);r&&(n+=`${r},`)}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n=`_b(${n},"${e.tag}",${yr(e.dynamicAttrs)})`),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function ur(e){return 1===e.type&&("slot"===e.tag||e.children.some(ur))}function fr(e,t){const n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ir(e,t,fr,"null");if(e.for&&!e.forProcessed)return ar(e,t,fr);const r="_empty_"===e.slotScope?"":String(e.slotScope),s=`function(${r}){return ${"template"===e.tag?e.if&&n?`(${e.if})?${pr(e,t)||"undefined"}:undefined`:pr(e,t)||"undefined":rr(e,t)}}`,o=r?"":",proxy:true";return`{key:${e.slotTarget||'"default"'},fn:${s}${o}}`}function pr(e,t,n,r,s){const o=e.children;if(o.length){const e=o[0];if(1===o.length&&e.for&&"template"!==e.tag&&"slot"!==e.tag){const s=n?t.maybeComponent(e)?",1":",0":"";return`${(r||rr)(e,t)}${s}`}const i=n?function(e,t){let n=0;for(let r=0;r<e.length;r++){const s=e[r];if(1===s.type){if(dr(s)||s.ifConditions&&s.ifConditions.some((e=>dr(e.block)))){n=2;break}(t(s)||s.ifConditions&&s.ifConditions.some((e=>t(e.block))))&&(n=1)}}return n}(o,t.maybeComponent):0,c=s||hr;return`[${o.map((e=>c(e,t))).join(",")}]${i?`,${i}`:""}`}}function dr(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function hr(e,t){return 1===e.type?rr(e,t):3===e.type&&e.isComment?function(e){return`_e(${JSON.stringify(e.text)})`}(e):mr(e)}function mr(e){return`_v(${2===e.type?e.expression:gr(JSON.stringify(e.text))})`}function yr(e){let t="",n="";for(let r=0;r<e.length;r++){const s=e[r],o=gr(s.value);s.dynamic?n+=`${s.name},${o},`:t+=`"${s.name}":${o},`}return t=`{${t.slice(0,-1)}}`,n?`_d(${t},[${n.slice(0,-1)}])`:t}function gr(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}const $r=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function vr(e,t){return $r.test(t)?(t=t.replace(/^'|'$/g,'"'),B(e)&&'"false"'!==t&&(t='"true"'),{type:Tr,value:q(e)?` ${e}="${e}"`:'""'===t?` ${e}`:` ${e}="${JSON.parse(t)}"`}):{type:jr,value:`_ssrAttr(${JSON.stringify(e)},${t})`}}const br=0,_r=1,xr=2,wr=3,Sr=4;let kr;function Ar(e,t){e&&(kr=t.isReservedTag||O,Or(e,!0))}function Or(e,t){if(function(e){if(2===e.type||3===e.type)return!1;return h(e.tag)||!kr(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some((e=>"model"===e.name))}(e)}(e))return void(e.ssrOptimizability=br);const n=t||function(e){return 1===e.type&&e.directives&&e.directives.some((e=>!Cr(e.name)))}(e),r=t=>{t.ssrOptimizability!==_r&&(e.ssrOptimizability=n?Sr:xr)};if(n&&(e.ssrOptimizability=wr),1===e.type){for(let t=0,n=e.children.length;t<n;t++){const n=e.children[t];Or(n),r(n)}if(e.ifConditions)for(let n=1,s=e.ifConditions.length;n<s;n++){const s=e.ifConditions[n].block;Or(s,t),r(s)}null==e.ssrOptimizability||!t&&(e.attrsMap["v-html"]||e.attrsMap["v-text"])?e.ssrOptimizability=_r:e.children=function(e){const t=e.children,n=[];let r=[];const s=()=>{r.length&&n.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:r,ssrOptimizability:_r}),r=[]};for(let e=0;e<t.length;e++){const o=t[e];o.ssrOptimizability===_r?r.push(o):(s(),n.push(o))}return s(),n}(e)}else e.ssrOptimizability=_r}const Cr=d("text,html,show,on,bind,model,pre,cloak,once");const Tr=0,jr=2;function Fr(e,t){if(e.for&&!e.forProcessed)return ar(e,t,Fr);if(e.if&&!e.ifProcessed)return ir(e,t,Fr);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===_r?Ir(e,t):Nr(e,t)||"void 0";switch(e.ssrOptimizability){case _r:return function(e,t){return`_ssrNode(${Mr(e,t)})`}(e,t);case xr:return function(e,t){const n=Nr(e,t,!0);return`_ssrNode(${zr(Dr(e,t))},"</${e.tag}>"${n?`,${n}`:""})`}(e,t);case wr:return Pr(e,t,!0);case Sr:return Pr(e,t,!1);default:return rr(e,t)}}function Pr(e,t,n){const r=e.plain?void 0:lr(e,t),s=n?`[${Ir(e,t)}]`:Nr(e,t,!0);return`_c('${e.tag}'${r?`,${r}`:""}${s?`,${s}`:""})`}function Nr(e,t,n){return pr(e,t,n,Fr,Er)}function Er(e,t){return 1===e.type?Fr(e,t):mr(e)}function Ir(e,t){return e.children.length?`_ssrNode(${zr(Lr(e,t))})`:""}function Mr(e,t){return`(${zr(Rr(e,t))})`}function Rr(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:jr,value:ar(e,t,Mr,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:jr,value:ir(e,t,Mr,'"\x3c!----\x3e"')}];if("template"===e.tag)return Lr(e,t);const n=Dr(e,t),r=Lr(e,t),{isUnaryTag:s}=t.options,o=s&&s(e.tag)?[]:[{type:Tr,value:`</${e.tag}>`}];return n.concat(r,o)}function Dr(e,t){let n;!function(e,t){if(e.directives)for(let n=0;n<e.directives.length;n++){const r=e.directives[n];if("model"===r.name){t.directives.model(e,r,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter((e=>"value"!==e.name)));break}}}(e,t);const r=[{type:Tr,value:`<${e.tag}`}];var s,o,i,c,a,l;return e.attrs&&r.push.apply(r,e.attrs.map((({name:e,value:t})=>vr(e,t)))),e.props&&r.push.apply(r,function(e,t){const n=[];return e.forEach((({name:e,value:r})=>{e=I[e]||e.toLowerCase(),!E(e)||t&&t.some((t=>t.name===e))||n.push(vr(e,r))})),n}(e.props,e.attrs)),(n=e.attrsMap["v-bind"])&&r.push({type:jr,value:`_ssrAttrs(${n})`}),(n=e.attrsMap["v-bind.prop"])&&r.push({type:jr,value:`_ssrDOMProps(${n})`}),(e.staticClass||e.classBinding)&&r.push.apply(r,(s=e.staticClass,o=e.classBinding,s&&!o?[{type:Tr,value:` class="${JSON.parse(s)}"`}]:[{type:jr,value:`_ssrClass(${s||"null"},${o||"null"})`}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&r.push.apply(r,(i=e.attrsMap.style,c=e.staticStyle,a=e.styleBinding,l=e.attrsMap["v-show"],!i||a||l?[{type:jr,value:`_ssrStyle(${c||"null"},${a||"null"}, ${l?`{ display: (${l}) ? '' : 'none' }`:"null"})`}]:[{type:Tr,value:` style=${JSON.stringify(i)}`}])),t.options.scopeId&&r.push({type:Tr,value:` ${t.options.scopeId}`}),r.push({type:Tr,value:">"}),r}function Lr(e,t){let n;return(n=e.attrsMap["v-html"])?[{type:jr,value:`_s(${n})`}]:(n=e.attrsMap["v-text"])||"textarea"===e.tag&&(n=e.attrsMap["v-model"])?[{type:1,value:`_s(${n})`}]:e.children?function(e,t){const n=[];for(let r=0;r<e.length;r++){const s=e[r];if(1===s.type)n.push.apply(n,Rr(s,t));else if(2===s.type)n.push({type:1,value:s.expression});else if(3===s.type){let e=R(s.text);s.isComment&&(e="\x3c!--"+e+"--\x3e"),n.push({type:Tr,value:e})}}return n}(e.children,t):[]}function zr(e){const t=[];let n="";const r=()=>{n&&(t.push(JSON.stringify(n)),n="")};for(let s=0;s<e.length;s++){const o=e[s];o.type===Tr?n+=o.value:1===o.type?(r(),t.push(`_ssrEscape(${o.value})`)):o.type===jr&&(r(),t.push(`(${o.value})`))}return r(),t.join("+")}function Br(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),A}}function Ur(e){const t=Object.create(null);return function(n,r,s){(r=S({},r)).warn,delete r.warn;const o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];const i=e(n,r),c={},a=[];return c.render=Br(i.render,a),c.staticRenderFns=i.staticRenderFns.map((e=>Br(e,a))),t[o]=c}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const qr=(Jr=function(e,t){const n=Nn(e.trim(),t);Ar(n,t);const r=function(e,t){const n=new nr(t);return{render:`with(this){return ${e?Fr(e,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){const r=Object.create(e),s=[],o=[];if(n){n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=S(Object.create(e.directives||null),n.directives));for(const e in n)"modules"!==e&&"directives"!==e&&(r[e]=n[e])}r.warn=(e,t,n)=>{(n?o:s).push(e)};const i=Jr(t.trim(),r);return i.errors=s,i.tips=o,i}return{compile:t,compileToFunctions:Ur(t)}});var Jr;const{compile:Kr,compileToFunctions:Hr}=qr(Jn);function Vr(e){for(let t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Wr(e){return c(e)?[W(e)]:Array.isArray(e)?Xr(e):void 0}function Zr(e){return o(e)&&o(e.text)&&!1===e.isComment}function Xr(e,t){const n=[];let r,a,l,u;for(r=0;r<e.length;r++)a=e[r],s(a)||"boolean"==typeof a||(l=n.length-1,u=n[l],Array.isArray(a)?a.length>0&&(a=Xr(a,`${t||""}_${r}`),Zr(a[0])&&Zr(u)&&(n[l]=W(u.text+a[0].text),a.shift()),n.push.apply(n,a)):c(a)?Zr(u)?n[l]=W(u.text+a):""!==a&&n.push(W(a)):Zr(a)&&Zr(u)?n[l]=W(u.text+a.text):(i(e._isVList)&&o(a.tag)&&s(a.key)&&o(t)&&(a.key=`__vlist${t}_${r}__`),n.push(a)));return n}const Gr={_ssrEscape:R,_ssrNode:function(e,t,n,r){return new Qr(e,t,n,r)},_ssrList:function(e,t){let n,r,s,o,i="";if(Array.isArray(e)||"string"==typeof e)for(n=0,r=e.length;n<r;n++)i+=t(e[n],n);else if("number"==typeof e)for(n=0;n<e;n++)i+=t(n+1,n);else if(a(e))for(s=Object.keys(e),n=0,r=s.length;n<r;n++)o=s[n],i+=t(e[o],o,n);return i},_ssrAttr:K,_ssrAttrs:function(e){let t="";for(const n in e)N(n)||(t+=K(n,e[n]));return t},_ssrDOMProps:function(e){let t="";for(const n in e){const r=I[n]||n.toLowerCase();E(r)&&(t+=K(r,e[n]))}return t},_ssrClass:function(e,t){const n=Je(e,t);return""===n?n:` class="${R(n)}"`},_ssrStyle:function(e,t,n){const r={};e&&S(r,e);t&&S(r,Ge(t));n&&S(r,n);const s=Qe(r);return""===s?s:` style=${JSON.stringify(R(s))}`}};class Qr{isString;open;close;children;constructor(e,t,n,r){this.isString=!0,this.open=e,this.close=t,this.children=n?1===r?Vr(n):2===r?Wr(n):n:void 0}}const Yr=new ae;function es(e){ts(e,Yr),Yr.clear()}function ts(e,t){let n,r;const s=Array.isArray(e);if(!(!s&&!a(e)||Object.isFrozen(e)||e instanceof H)){if(e.__ob__){const n=e.__ob__.dep.id;if(t.has(n))return;t.add(n)}if(s)for(n=e.length;n--;)ts(e[n],t);else for(r=Object.keys(e),n=r.length;n--;)ts(e[r[n]],t)}}const ns=$((e=>{const t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function rs(e,t){function n(){const e=n.fns;if(!Array.isArray(e))return ze(e,null,arguments,t,"v-on handler");{const n=e.slice();for(let e=0;e<n.length;e++)ze(n[e],null,arguments,t,"v-on handler")}}return n.fns=e,n}function ss(e,t,n,r,s){if(o(t)){if(g(t,n))return e[n]=t[n],s||delete t[n],!0;if(g(t,r))return e[n]=t[r],s||delete t[r],!0}return!1}function os(e,t,n,r,s,l){return(Array.isArray(n)||c(n))&&(s=r,r=n,n=void 0),i(l)&&(s=2),function(e,t,n,r,s){if(o(n)&&o(n.__ob__))return V();o(n)&&o(n.is)&&(t=n.is);if(!t)return V();Array.isArray(r)&&"function"==typeof r[0]&&((n=n||{}).scopedSlots={default:r[0]},r.length=0);2===s?r=Wr(r):1===s&&(r=Vr(r));let i,c;if("string"==typeof t){let s;c=e.$vnode&&e.$vnode.ns||ue.getTagNamespace(t),i=n&&n.pre||!o(s=Ne(e.$options,"components",t))?new H(t,n,r,void 0,void 0,e):qs(s,n,e,r,t)}else i=qs(t,n,e,r);return Array.isArray(i)?i:o(i)?(o(c)&&is(i,c),o(n)&&function(e){a(e.style)&&es(e.style);a(e.class)&&es(e.class)}(n),i):V()}(e,t,n,r,s)}function is(e,t,n){if(e.ns=t,"foreignObject"===e.tag&&(t=void 0,n=!0),o(e.children))for(let r=0,c=e.children.length;r<c;r++){const c=e.children[r];o(c.tag)&&(s(c.ns)||i(n)&&"svg"!==c.tag)&&is(c,t,n)}}function cs(e,t){let n,r,s,i,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,r=e.length;n<r;n++)c[n]=t(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=t(n+1,n);else if(a(e))if(ce&&e[Symbol.iterator]){c=[];const n=e[Symbol.iterator]();let r=n.next();for(;!r.done;)c.push(t(r.value,c.length)),r=n.next()}else for(s=Object.keys(e),c=new Array(s.length),n=0,r=s.length;n<r;n++)i=s[n],c[n]=t(e[i],i,n);return o(c)||(c=[]),c._isVList=!0,c}function as(e,t,n,r){const s=this.$scopedSlots[e];let o;s?(n=n||{},r&&(n=S(S({},r),n)),o=s(n)||("function"==typeof t?t():t)):o=this.$slots[e]||("function"==typeof t?t():t);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},o):o}function ls(e){return Ne(this.$options,"filters",e)||C}function us(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function fs(e,t,n,r,s){const o=ue.keyCodes[t]||n;return s&&r&&!ue.keyCodes[t]?us(s,r):o?us(o,e):r?w(r)!==t:void 0===e}function ps(e,t,n,r,s){if(n)if(a(n)){let o;Array.isArray(n)&&(n=k(n));for(const i in n){if("class"===i||"style"===i||m(i))o=e;else{const n=e.attrs&&e.attrs.type;o=r||ue.mustUseProp(t,n,i)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}const c=b(i),a=w(i);if(!(c in o)&&!(a in o)&&(o[i]=n[i],s)){(e.on||(e.on={}))[`update:${i}`]=function(e){n[i]=e}}}}else;return e}function ds(e,t){const n=this._staticTrees||(this._staticTrees=[]);let r=n[e];return r&&!t||(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),ms(r,`__static__${e}`,!1)),r}function hs(e,t,n){return ms(e,`__once__${t}${n?`_${n}`:""}`,!0),e}function ms(e,t,n){if(Array.isArray(e))for(let r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&ys(e[r],`${t}_${r}`,n);else ys(e,t,n)}function ys(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function gs(e,t){if(t)if(u(t)){const n=e.on=e.on?S({},e.on):{};for(const e in t){const r=n[e],s=t[e];n[e]=r?[].concat(r,s):s}}else;return e}function $s(e,t,n,r){t=t||{$stable:!n};for(let r=0;r<e.length;r++){const s=e[r];Array.isArray(s)?$s(s,t,n):s&&(s.proxy&&(s.fn.proxy=!0),t[s.key]=s.fn)}return r&&(t.$key=r),t}function vs(e,t){for(let n=0;n<t.length;n+=2){const r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function bs(e,t){return"string"==typeof e?t+e:e}function _s(e,t){if(!e||!e.length)return{};const n={};for(let r=0,s=e.length;r<s;r++){const s=e[r],o=s.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,s.context!==t&&s.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(s);else{const e=o.slot,t=n[e]||(n[e]=[]);"template"===s.tag?t.push.apply(t,s.children||[]):t.push(s)}}for(const e in n)n[e].every(xs)&&delete n[e];return n}function xs(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ws(e){return e.isComment&&e.asyncFactory}function Ss(e,t,n){let s;const o=Object.keys(t).length>0,i=e?!!e.$stable:!o,c=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&n&&n!==r&&c===n.$key&&!o&&!n.$hasNormal)return n;s={};for(const n in e)e[n]&&"$"!==n[0]&&(s[n]=ks(t,n,e[n]))}else s={};for(const e in t)e in s||(s[e]=As(t,e));return e&&Object.isExtensible(e)&&(e._normalized=s),X(s,"$stable",i),X(s,"$key",c),X(s,"$hasNormal",o),s}function ks(e,t,n){const r=function(){let e=arguments.length?n.apply(null,arguments):n({});e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Wr(e);const t=e&&e[0];return e&&(!t||1===e.length&&t.isComment&&!ws(t))?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function As(e,t){return()=>e[t]}let Os;function Cs(e,t){Os.$on(e,t)}function Ts(e,t){Os.$off(e,t)}function js(e,t){const n=Os;return function r(){const s=t.apply(null,arguments);null!==s&&n.$off(e,r)}}function Fs(e,t,n){Os=e,function(e,t,n,r,o,c){let a,l,u,f;for(a in e)l=e[a],u=t[a],f=ns(a),s(l)||(s(u)?(s(l.fns)&&(l=e[a]=rs(l,c)),i(f.once)&&(l=e[a]=o(f.name,l,f.capture)),n(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[a]=u));for(a in t)s(e[a])&&(f=ns(a),r(f.name,t[a],f.capture))}(t,n||{},Cs,Ts,js,e),Os=void 0}function Ps(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Ns(e,t){if(t){if(e._directInactive=!1,Ps(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(let t=0;t<e.$children.length;t++)Ns(e.$children[t]);Is(e,"activated")}}function Es(e,t){if(!(t&&(e._directInactive=!0,Ps(e))||e._inactive)){e._inactive=!0;for(let t=0;t<e.$children.length;t++)Es(e.$children[t]);Is(e,"deactivated")}}function Is(e,t){he();const n=e.$options[t],r=`${t} hook`;if(n)for(let t=0,s=n.length;t<s;t++)ze(n[t],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),me()}let Ms=Date.now;if(Q&&!te){const e=window.performance;e&&"function"==typeof e.now&&Ms()>document.createEvent("Event").timeStamp&&(Ms=()=>e.now())}function Rs(e){let t=e.options;if(e.super){const n=Rs(e.super);if(n!==e.superOptions){e.superOptions=n;const r=function(e){let t;const n=e.options,r=e.sealedOptions;for(const e in n)n[e]!==r[e]&&(t||(t={}),t[e]=n[e]);return t}(e);r&&S(e.extendOptions,r),t=e.options=Pe(n,e.extendOptions),t.name&&(t.components[t.name]=e)}}return t}function Ds(e,t,n,s,o){const c=o.options;let a;g(s,"_uid")?(a=Object.create(s),a._original=s):(a=s,s=s._original);const l=i(c._compiled),u=!l;this.data=e,this.props=t,this.children=n,this.parent=s,this.listeners=e.on||r,this.injections=function(e,t){if(e){const n=Object.create(null),r=ce?Reflect.ownKeys(e):Object.keys(e);for(let s=0;s<r.length;s++){const o=r[s];if("__ob__"===o)continue;const i=e[o].from;let c=t;for(;c;){if(c._provided&&g(c._provided,i)){n[o]=c._provided[i];break}c=c.$parent}if(!c&&"default"in e[o]){const r=e[o].default;n[o]="function"==typeof r?r.call(t):r}}return n}}(c.inject,s),this.slots=()=>(this.$slots||Ss(e.scopedSlots,this.$slots=_s(n,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return Ss(e.scopedSlots,this.slots())}}),l&&(this.$options=c,this.$slots=this.slots(),this.$scopedSlots=Ss(e.scopedSlots,this.$slots)),c._scopeId?this._c=(e,t,n,r)=>{const o=os(a,e,t,n,r,u);return o&&!Array.isArray(o)&&(o.fnScopeId=c._scopeId,o.fnContext=s),o}:this._c=(e,t,n,r)=>os(a,e,t,n,r,u)}function Ls(e,t,n,r,s){const o=function(e){const t=new H(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function zs(e,t){for(const n in t)e[b(n)]=t[n]}!function(e){e._o=hs,e._n=p,e._s=f,e._l=cs,e._t=as,e._q=T,e._i=j,e._m=ds,e._f=ls,e._k=fs,e._b=ps,e._v=W,e._e=V,e._u=$s,e._g=gs,e._d=vs,e._p=bs}(Ds.prototype);const Bs={init(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){const t=e;Bs.prepatch(t,t)}else{(e.componentInstance=Js(e,null)).$mount(t?e.elm:void 0,t)}},prepatch(e,t){const n=t.componentOptions;!function(e,t,n,s,o){const i=s.data.scopedSlots,c=e.$scopedSlots,a=!!(i&&!i.$stable||c!==r&&!c.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(o||e.$options._renderChildren||a);if(e.$options._parentVnode=s,e.$vnode=s,e._vnode&&(e._vnode.parent=s),e.$options._renderChildren=o,e.$attrs=s.data.attrs||r,e.$listeners=n||r,t&&e.$options.props){be(!1);const n=e._props,r=e.$options._propKeys||[];for(let s=0;s<r.length;s++){const o=r[s],i=e.$options.props;n[o]=Ee(o,i,t,e)}be(!0),e.$options.propsData=t}n=n||r;const u=e.$options._parentListeners;e.$options._parentListeners=n,Fs(e,n,u),l&&(e.$slots=_s(o,s.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,n.propsData,n.listeners,t,n.children)},insert(e){const{context:t,componentInstance:n}=e;n._isMounted||(n._isMounted=!0,Is(n,"mounted")),e.data.keepAlive&&(t._isMounted?function(e){e._inactive=!1}(n):Ns(n,!0))},destroy(e){const{componentInstance:t}=e;t._isDestroyed||(e.data.keepAlive?Es(t,!0):t.$destroy())}},Us=Object.keys(Bs);function qs(e,t,n,c,l){if(s(e))return;const u=n.$options._base;if(a(e)&&(e=u.extend(e)),"function"!=typeof e)return;let f;if(s(e.cid)&&(f=e,void 0===(e=i((p=f).error)&&o(p.errorComp)?p.errorComp:o(p.resolved)?p.resolved:i(p.loading)&&o(p.loadingComp)?p.loadingComp:void 0)))return function(e,t,n,r,s){const o=V();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:s},o}(f,t,n,c,l);var p;t=t||{},Rs(e),o(t.model)&&function(e,t){const n=e.model&&e.model.prop||"value",r=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[n]=t.model.value;const s=t.on||(t.on={}),i=s[r],c=t.model.callback;o(i)?(Array.isArray(i)?-1===i.indexOf(c):i!==c)&&(s[r]=[c].concat(i)):s[r]=c}(e.options,t);const d=function(e,t,n){const r=t.options.props;if(s(r))return;const i={},{attrs:c,props:a}=e;if(o(c)||o(a))for(const e in r){const t=w(e);ss(i,a,e,t,!0)||ss(i,c,e,t,!1)}return i}(t,e);if(i(e.options.functional))return function(e,t,n,s,i){const c=e.options,a={},l=c.props;if(o(l))for(const e in l)a[e]=Ee(e,l,t||r);else o(n.attrs)&&zs(a,n.attrs),o(n.props)&&zs(a,n.props);const u=new Ds(n,a,i,s,e),f=c.render.call(null,u._c,u);if(f instanceof H)return Ls(f,n,u.parent,c);if(Array.isArray(f)){const e=Wr(f)||[],t=new Array(e.length);for(let r=0;r<e.length;r++)t[r]=Ls(e[r],n,u.parent,c);return t}}(e,d,t,n,c);const h=t.on;if(t.on=t.nativeOn,i(e.options.abstract)){const e=t.slot;t={},e&&(t.slot=e)}!function(e){const t=e.hook||(e.hook={});for(let e=0;e<Us.length;e++){const n=Us[e],r=t[n],s=Bs[n];r===s||r&&r._merged||(t[n]=r?Ks(s,r):s)}}(t);const m=e.options.name||l;return new H(`vue-component-${e.cid}${m?`-${m}`:""}`,t,void 0,void 0,void 0,n,{Ctor:e,propsData:d,listeners:h,tag:l,children:c},f)}function Js(e,t){const n={_isComponent:!0,_parentVnode:e,parent:t},r=e.data.inlineTemplate;return o(r)&&(n.render=r.render,n.staticRenderFns=r.staticRenderFns),new e.componentOptions.Ctor(n)}function Ks(e,t){const n=(n,r)=>{e(n,r),t(n,r)};return n._merged=!0,n}let Hs=Object.create(null);const Vs=e=>{Hs[e]||(Hs[e]=!0,console.warn(`\n\x1b[31m${e}\x1b[39m\n`))},Ws=(e,t)=>{const n=t?undefined(t):"";throw new Error(`\n\x1b[31m${e}${n}\x1b[39m\n`)},Zs=e=>{const{render:t,template:n,_scopeId:r}=e.$options;if(s(t)){if(!n)throw new Error(`render function or template not defined in component: ${e.$options.name||e.$options._componentTag||"anonymous"}`);{const t=Hr(n,{scopeId:r,warn:Ws},e);e.$options.render=t.render,e.$options.staticRenderFns=t.staticRenderFns}}};function Xs(e,t,n){let r=e.$options.serverPrefetch;if(o(r)){Array.isArray(r)||(r=[r]);try{const s=[];for(let t=0,n=r.length;t<n;t++){const n=r[t].call(e,e);n&&"function"==typeof n.then&&s.push(n)}return void Promise.all(s).then(t).catch(n)}catch(e){n(e)}}t()}function Gs(e,t,n){e.isString?function(e,t){const{write:n,next:r}=t;if(s(e.children)||0===e.children.length)n(e.open+(e.close||""),r);else{const s=e.children;t.renderStates.push({type:"Element",children:s,rendered:0,total:s.length,endTag:e.close}),n(e.open,r)}}(e,n):o(e.componentOptions)?Ys(e,t,n):o(e.tag)?function(e,t,n){const{write:r,next:c}=n;i(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs["data-server-rendered"]="true");e.fnOptions&&Qs(e.fnOptions,r);const a=function(e,t){let n=`<${e.tag}`;const{directives:r,modules:i}=t;s(e.data)&&no(e)&&(e.data={});if(o(e.data)){const s=e.data.directives;if(s)for(let n=0;n<s.length;n++){const r=s[n].name;if("show"!==r){const o=Ne(t,"directives",r);o&&o(e,s[n])}}const c=function(e){let t,n;for(;o(e);)e.data&&e.data.directives&&(n=e.data.directives.find((e=>"show"===e.name)),n&&(t=n)),e=e.parent;return t}(e);c&&r.show(e,c);for(let t=0;t<i.length;t++){const r=i[t](e);r&&(n+=r)}}let c;const a=t.activeInstance;o(a)&&a!==e.context&&o(c=a.$options._scopeId)&&(n+=` ${c}`);if(o(e.fnScopeId))n+=` ${e.fnScopeId}`;else for(;o(e);)o(c=e.context.$options._scopeId)&&(n+=` ${c}`),e=e.parent;return n+">"}(e,n),l=`</${e.tag}>`;if(n.isUnaryTag(e.tag))r(a,c);else if(s(e.children)||0===e.children.length)r(a+l,c);else{const t=e.children;n.renderStates.push({type:"Element",children:t,rendered:0,total:t.length,endTag:l}),r(a,c)}}(e,t,n):i(e.isComment)?o(e.asyncFactory)?function(e,t,n){const r=e.asyncFactory,s=r=>{r.__esModule&&r.default&&(r=r.default);const{data:s,children:o,tag:i}=e.asyncMeta,c=qs(r,s,e.asyncMeta.context,o,i);c?c.componentOptions?Ys(c,t,n):Array.isArray(c)?(n.renderStates.push({type:"Fragment",children:c,rendered:0,total:c.length}),n.next()):Gs(c,t,n):n.write("\x3c!----\x3e",n.next)};if(r.resolved)return void s(r.resolved);const o=n.done;let i;try{i=r(s,o)}catch(e){o(e)}if(i)if("function"==typeof i.then)i.then(s,o).catch(o);else{const e=i.component;e&&"function"==typeof e.then&&e.then(s,o).catch(o)}}(e,t,n):n.write(`\x3c!--${e.text}--\x3e`,n.next):n.write(e.raw?e.text:R(String(e.text)),n.next)}function Qs(e,t){const n=e._ssrRegister;return t.caching&&o(n)&&t.componentBuffer[t.componentBuffer.length-1].add(n),n}function Ys(e,t,n){const{write:r,next:i,userContext:c}=n,a=e.componentOptions.Ctor,l=a.options.serverCacheKey,u=a.options.name,f=n.cache,p=Qs(a.options,r);if(o(l)&&o(f)&&o(u)){const s=l(e.componentOptions.propsData);if(!1===s)return void to(e,t,n);const a=u+"::"+s,{has:f,get:d}=n;o(f)?f(a,(s=>{!0===s&&o(d)?d(a,(e=>{o(p)&&p(c),e.components.forEach((e=>e(c))),r(e.html,i)})):eo(e,t,a,n)})):o(d)&&d(a,(s=>{o(s)?(o(p)&&p(c),s.components.forEach((e=>e(c))),r(s.html,i)):eo(e,t,a,n)}))}else o(l)&&s(f)&&Vs(`[vue-server-renderer] Component ${a.options.name||"(anonymous)"} implemented serverCacheKey, but no cache was provided to the renderer.`),o(l)&&s(u)&&Vs('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),to(e,t,n)}function eo(e,t,n,r){const s=r.write;s.caching=!0;const o=s.cacheBuffer,i=o.push("")-1,c=s.componentBuffer;c.push(new Set),r.renderStates.push({type:"ComponentWithCache",key:n,buffer:o,bufferIndex:i,componentBuffer:c}),to(e,t,r)}function to(e,t,n){const r=n.activeInstance;e.ssrContext=n.userContext;const s=n.activeInstance=Js(e,n.activeInstance);Zs(s);const o=n.done;Xs(s,(()=>{const o=s._render();o.parent=e,n.renderStates.push({type:"Component",prevActive:r}),Gs(o,t,n)}),o)}function no(e){const t=e.parent;return o(t)&&(o(t.data)||no(t))}function ro(e,t,n,r){return function(s,o,i,c){Hs=Object.create(null);const a=new ft({activeInstance:s,userContext:i,write:o,done:c,renderNode:Gs,isUnaryTag:n,modules:e,directives:t,cache:r});!function(e){if(e._ssrNode)return;let t=e.constructor;for(;t.super;)t=t.super;S(t.prototype,Gr),t.FunctionalRenderContext&&S(t.FunctionalRenderContext.prototype,Gr)}(s),Zs(s);Xs(s,(()=>{Gs(s._render(),!0,a)}),c)}}const so=e=>/\.js(\?[^.]+)?$/.test(e);function oo(){let e,t;return{promise:new Promise(((n,r)=>{e=n,t=r})),cb:(n,r)=>{if(n)return t(n);e(r||"")}}}class io extends e.Transform{started;renderer;template;context;inject;constructor(e,t,n){super(),this.started=!1,this.renderer=e,this.template=t,this.context=n||{},this.inject=e.inject}_transform(e,t,n){this.started||(this.emit("beforeStart"),this.start()),this.push(e),n()}start(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);const e=this.renderer.renderResourceHints(this.context);e&&this.push(e);const t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))}_flush(e){if(this.emit("beforeEnd"),this.inject){const e=this.renderer.renderState(this.context);e&&this.push(e);const t=this.renderer.renderScripts(this.context);t&&this.push(t)}this.push(this.template.tail(this.context)),e()}}const co=require("lodash.template"),ao={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function lo(e){const t=function(e){const t=new Map;return Object.keys(e.modules).forEach((n=>{t.set(n,function(e,t){const n=[],r=t.modules[e];r&&r.forEach((e=>{const r=t.all[e];r&&(t.async.indexOf(r)>-1||!/\.(js|css)($|\?)/.test(r))&&n.push(r)}));return n}(n,e))})),t}(e);return function(e){const n=new Set;for(let r=0;r<e.length;r++){const s=t.get(e[r]);if(s)for(let e=0;e<s.length;e++)n.add(s[e])}return Array.from(n)}}const uo=require("path"),fo=require("serialize-javascript");class po{options;inject;parsedTemplate;publicPath;clientManifest;preloadFiles;prefetchFiles;mapFiles;serialize;constructor(e){this.options=e,this.inject=!1!==e.inject;const{template:t}=e;if(this.parsedTemplate=t?"string"==typeof t?function(e,t="\x3c!--vue-ssr-outlet--\x3e"){if("object"==typeof e)return e;let n=e.indexOf("</head>");const r=e.indexOf(t);if(r<0)throw new Error("Content placeholder not found in template.");return n<0&&(n=e.indexOf("<body>"),n<0&&(n=r)),{head:co(e.slice(0,n),ao),neck:co(e.slice(n,r),ao),tail:co(e.slice(r+t.length),ao)}}(t):t:null,this.serialize=e.serializer||(e=>fo(e,{isJSON:!0})),e.clientManifest){const t=this.clientManifest=e.clientManifest;this.publicPath=""===t.publicPath?"":t.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(t.initial||[]).map(ho),this.prefetchFiles=(t.async||[]).map(ho),this.mapFiles=lo(t)}}bindRenderFns(e){const t=this;["ResourceHints","State","Scripts","Styles"].forEach((n=>{e[`render${n}`]=t[`render${n}`].bind(t,e)})),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)}render(e,t){const n=this.parsedTemplate;if(!n)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof n?n(e,t):this.inject?n.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+n.neck(t)+e+this.renderState(t)+this.renderScripts(t)+n.tail(t):n.head(t)+n.neck(t)+e+n.tail(t)}renderStyles(e){const t=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],r=t.concat(n).filter((({file:e})=>(e=>/\.css(\?[^.]+)?$/.test(e))(e)));return(r.length?r.map((({file:e})=>`<link rel="stylesheet" href="${this.publicPath}${e}">`)).join(""):"")+(e.styles||"")}renderResourceHints(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)}getPreloadFiles(e){const t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]}renderPreloadLinks(e){const t=this.getPreloadFiles(e),n=this.options.shouldPreload;return t.length?t.map((({file:e,extension:t,fileWithoutQuery:r,asType:s})=>{let o="";return n||"script"===s||"style"===s?n&&!n(r,s)?"":("font"===s&&(o=` type="font/${t}" crossorigin`),`<link rel="preload" href="${this.publicPath}${e}"${""!==s?` as="${s}"`:""}${o}>`):""})).join(""):""}renderPrefetchLinks(e){const t=this.options.shouldPrefetch;if(this.prefetchFiles){const n=this.getUsedAsyncFiles(e),r=e=>n&&n.some((t=>t.file===e));return this.prefetchFiles.map((({file:e,fileWithoutQuery:n,asType:s})=>t&&!t(n,s)||r(e)?"":`<link rel="prefetch" href="${this.publicPath}${e}">`)).join("")}return""}renderState(e,t){const{contextKey:n="state",windowKey:r="__INITIAL_STATE__"}=t||{},s=this.serialize(e[n]),o=e.nonce?` nonce="${e.nonce}"`:"";return e[n]?`<script${o}>window.${r}=${s};(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>`:""}renderScripts(e){if(this.clientManifest){const t=this.preloadFiles.filter((({file:e})=>so(e))),n=(this.getUsedAsyncFiles(e)||[]).filter((({file:e})=>so(e)));return[t[0]].concat(n,t.slice(1)).map((({file:e})=>`<script src="${this.publicPath}${e}" defer><\/script>`)).join("")}return""}getUsedAsyncFiles(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){const t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(ho)}return e._mappedFiles}createStream(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new io(this,this.parsedTemplate,e||{})}}function ho(e){const t=e.replace(/\?.*/,""),n=uo.extname(t).slice(1);return{file:e,extension:n,fileWithoutQuery:t,asType:mo(n)}}function mo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}const yo=require("vm"),go=require("path"),$o=require("resolve"),vo=require("module");function bo(e){const t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function _o(e,t,n){const r={},s={};return function o(i,c,a={}){if(a[i])return a[i];const l=function(t){if(r[t])return r[t];const n=e[t],s=vo.wrap(n),o=new yo.Script(s,{filename:t,displayErrors:!0});return r[t]=o,o}(i),u={exports:{}};(!1===n?l.runInThisContext():l.runInNewContext(c)).call(u.exports,u.exports,(n=>(n=go.posix.join(".",n),e[n]?o(n,c,a):t?require(s[n]||(s[n]=$o.sync(n,{basedir:t}))):require(n))),u);const f=Object.prototype.hasOwnProperty.call(u.exports,"default")?u.exports.default:u.exports;return a[i]=f,f}}function xo(e){if(u(e)){const t={};for(const n in e)t[n]=xo(e[n]);return t}return Array.isArray(e)?e.slice():e}function wo(e,t,n,r){const s=_o(t,n,r);if(!1!==r&&"once"!==r)return(t={})=>new Promise((n=>{t._registeredComponents=new Set;const r=s(e,bo(t));n("function"==typeof r?r(t):r)}));{let t,n;return(o={})=>new Promise((i=>{if(!t){const o="once"===r?bo():global;if(n=o.__VUE_SSR_CONTEXT__={},t=s(e,o),delete o.__VUE_SSR_CONTEXT__,"function"!=typeof t)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(o._registeredComponents=new Set,n._styles){o._styles=xo(n._styles);const e=n._renderStyles;e&&Object.defineProperty(o,"styles",{enumerable:!0,get:()=>e(o._styles)})}i(t(o))}))}}const So=require("source-map").SourceMapConsumer,ko=/\(([^)]+\.js):(\d+):(\d+)\)$/;function Ao(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map((e=>function(e,t){const n=e.match(ko),r=n&&t[n[1]];if(null!=n&&r){const t=r.originalPositionFor({line:Number(n[2]),column:Number(n[3])});if(null!=t.source){const{source:n,line:r,column:s}=t,o=`(${n.replace(/^webpack:\/\/\//,"")}:${String(r)}:${String(s)})`;return e.replace(ko,o)}return e}return e}(e,t))).join("\n"))}const Oo=require("fs"),Co=require("path"),To=require("stream").PassThrough,jo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Fo(e={}){return function({modules:e=[],directives:t={},isUnaryTag:n=(()=>!1),template:r,inject:s,cache:o,shouldPreload:i,shouldPrefetch:c,clientManifest:a,serializer:l}={}){const u=ro(e,t,n,o),f=new po({template:r,inject:s,shouldPreload:i,shouldPrefetch:c,clientManifest:a,serializer:l});return{renderToString(e,t,n){let s;"function"==typeof t&&(n=t,t={}),t&&f.bindRenderFns(t),n||({promise:s,cb:n}=oo());let o="";const i=lt((e=>(o+=e,!1)),n);try{u(e,i,t,(e=>{if(e)return n(e);if(t&&t.rendered&&t.rendered(t),r)try{const e=f.render(o,t);"string"!=typeof e?e.then((e=>n(null,e))).catch(n):n(null,e)}catch(e){n(e)}else n(null,o)}))}catch(e){n(e)}return s},renderToStream(e,t){t&&f.bindRenderFns(t);const n=new ut(((n,r)=>{u(e,n,t,r)}));if(r){if("function"==typeof r)throw new Error("function template is only supported in renderToString.");{const e=f.createStream(t);if(n.on("error",(t=>{e.emit("error",t)})),n.pipe(e),t&&t.rendered){const e=t.rendered;n.once("beforeEnd",(()=>{e(t)}))}return e}}if(t&&t.rendered){const e=t.rendered;n.once("beforeEnd",(()=>{e(t)}))}return n}}}(S(S({},e),{isUnaryTag:st,canBeLeftOpenTag:ot,modules:et,directives:S(rt,e.directives)}))}process.env.VUE_ENV="server";const Po=function(e){return function(t,n={}){let r,s,o,i=n.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&Co.isAbsolute(t)){if(!Oo.existsSync(t))throw new Error(`Cannot locate bundle file: ${t}`);{const e=/\.json$/.test(t);if(i=i||Co.dirname(t),t=Oo.readFileSync(t,"utf-8"),e)try{t=JSON.parse(t)}catch(e){throw new Error(`Invalid JSON bundle file: ${t}`)}}}if("object"==typeof t){if(s=t.entry,r=t.files,i=i||t.basedir,o=function(e){const t={};return Object.keys(e).forEach((n=>{t[n]=new So(e[n])})),t}(t.maps),"string"!=typeof s||"object"!=typeof r)throw new Error(jo)}else{if("string"!=typeof t)throw new Error(jo);s="__vue_ssr_bundle__",r={__vue_ssr_bundle__:t},o={}}const c=e(n),a=wo(s,r,i,n.runInNewContext);return{renderToString:(e,t)=>{let n;return"function"==typeof e&&(t=e,e={}),t||({promise:n,cb:t}=oo()),a(e).catch((e=>{Ao(e,o),t(e)})).then((n=>{n&&c.renderToString(n,e,((e,n)=>{Ao(e,o),t(e,n)}))})),n},renderToStream:e=>{const t=new To;return a(e).catch((e=>{Ao(e,o),process.nextTick((()=>{t.emit("error",e)}))})).then((r=>{if(r){const s=c.renderToStream(r,e);s.on("error",(e=>{Ao(e,o),t.emit("error",e)})),n&&n.template&&(s.on("beforeStart",(()=>{t.emit("beforeStart")})),s.on("beforeEnd",(()=>{t.emit("beforeEnd")}))),s.pipe(t)}})),t}}}}(Fo);exports.createBundleRenderer=Po,exports.createRenderer=Fo;
\ No newline at end of file
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 8ae5dd6c6a1..40af65818a0 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -1,124 +1,113 @@
-
-var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
-
-var isCSS = function (file) { return /\.css(\?[^.]+)?$/.test(file); };
-
-var ref = require('chalk');
-var red = ref.red;
-var yellow = ref.yellow;
-var webpack = require('webpack');
-
-var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); };
-var tip = exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); };
-
-var isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-
-var onEmit = function (compiler, name, stageName, hook) {
-  if (isWebpack5) {
-    // Webpack >= 5.0.0
-    compiler.hooks.compilation.tap(name, function (compilation) {
-      if (compilation.compiler !== compiler) {
-        // Ignore child compilers
-        return
-      }
-      var stage = webpack.Compilation[stageName];
-      compilation.hooks.processAssets.tapAsync({ name: name, stage: stage }, function (assets, cb) {
-        hook(compilation, cb);
-      });
-    });
-  } else if (compiler.hooks) {
-    // Webpack >= 4.0.0
-    compiler.hooks.emit.tapAsync(name, hook);
-  } else {
-    // Webpack < 4.0.0
-    compiler.plugin('emit', hook);
-  }
+'use strict';
+
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
+
+const { red, yellow } = require('chalk');
+const webpack = require('webpack');
+const prefix = `[vue-server-renderer-webpack-plugin]`;
+exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
+exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
+const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
+const onEmit = (compiler, name, stageName, hook) => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        compiler.hooks.compilation.tap(name, compilation => {
+            if (compilation.compiler !== compiler) {
+                // Ignore child compilers
+                return;
+            }
+            const stage = webpack.Compilation[stageName];
+            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
+                hook(compilation, cb);
+            });
+        });
+    }
+    else if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
 };
-
-var stripModuleIdHash = function (id) {
-  if (isWebpack5) {
-    // Webpack >= 5.0.0
-    return id.replace(/\|\w+$/, '')
-  }
-  // Webpack < 5.0.0
-  return id.replace(/\s\w+$/, '')
+const stripModuleIdHash = id => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        return id.replace(/\|\w+$/, '');
+    }
+    // Webpack < 5.0.0
+    return id.replace(/\s\w+$/, '');
 };
-
-var getAssetName = function (asset) {
-  if (typeof asset === 'string') {
-    return asset
-  }
-  return asset.name
+const getAssetName = asset => {
+    if (typeof asset === 'string') {
+        return asset;
+    }
+    return asset.name;
 };
 
-var hash = require('hash-sum');
-var uniq = require('lodash.uniq');
-
-var VueSSRClientPlugin = function VueSSRClientPlugin (options) {
-  if ( options === void 0 ) options = {};
-
-  this.options = Object.assign({
-    filename: 'vue-ssr-client-manifest.json'
-  }, options);
-};
-
-VueSSRClientPlugin.prototype.apply = function apply (compiler) {
-    var this$1 = this;
-
-  var stage = 'PROCESS_ASSETS_STAGE_ADDITIONAL';
-  onEmit(compiler, 'vue-client-plugin', stage, function (compilation, cb) {
-    var stats = compilation.getStats().toJson();
-
-    var allFiles = uniq(stats.assets
-      .map(function (a) { return a.name; }));
-
-    var initialFiles = uniq(Object.keys(stats.entrypoints)
-      .map(function (name) { return stats.entrypoints[name].assets; })
-      .reduce(function (assets, all) { return all.concat(assets); }, [])
-      .map(getAssetName)
-      .filter(function (file) { return isJS(file) || isCSS(file); }));
-
-    var asyncFiles = allFiles
-      .filter(function (file) { return isJS(file) || isCSS(file); })
-      .filter(function (file) { return initialFiles.indexOf(file) < 0; });
-
-    var manifest = {
-      publicPath: stats.publicPath,
-      all: allFiles,
-      initial: initialFiles,
-      async: asyncFiles,
-      modules: { /* [identifier: string]: Array<index: number> */ }
-    };
-
-    var assetModules = stats.modules.filter(function (m) { return m.assets.length; });
-    var fileToIndex = function (asset) { return manifest.all.indexOf(getAssetName(asset)); };
-    stats.modules.forEach(function (m) {
-      // ignore modules duplicated in multiple chunks
-      if (m.chunks.length === 1) {
-        var cid = m.chunks[0];
-        var chunk = stats.chunks.find(function (c) { return c.id === cid; });
-        if (!chunk || !chunk.files) {
-          return
-        }
-        var id = stripModuleIdHash(m.identifier);
-        var files = manifest.modules[hash(id)] = chunk.files.map(fileToIndex);
-        // find all asset modules associated with the same chunk
-        assetModules.forEach(function (m) {
-          if (m.chunks.some(function (id) { return id === cid; })) {
-            files.push.apply(files, m.assets.map(fileToIndex));
-          }
+const hash = require("hash-sum");
+const uniq = require("lodash.uniq");
+class VueSSRClientPlugin {
+    constructor(options = {}) {
+        //@ts-expect-error no type on options
+        this.options = Object.assign({
+            filename: "vue-ssr-client-manifest.json",
+        }, options);
+    }
+    apply(compiler) {
+        const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
+        onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
+            const stats = compilation.getStats().toJson();
+            const allFiles = uniq(stats.assets.map((a) => a.name));
+            const initialFiles = uniq(Object.keys(stats.entrypoints)
+                .map((name) => stats.entrypoints[name].assets)
+                .reduce((assets, all) => all.concat(assets), [])
+                .map(getAssetName)
+                .filter((file) => isJS(file) || isCSS(file)));
+            const asyncFiles = allFiles
+                .filter((file) => isJS(file) || isCSS(file))
+                .filter((file) => initialFiles.indexOf(file) < 0);
+            const manifest = {
+                publicPath: stats.publicPath,
+                all: allFiles,
+                initial: initialFiles,
+                async: asyncFiles,
+                modules: {
+                /* [identifier: string]: Array<index: number> */
+                },
+            };
+            const assetModules = stats.modules.filter((m) => m.assets.length);
+            const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
+            stats.modules.forEach((m) => {
+                // ignore modules duplicated in multiple chunks
+                if (m.chunks.length === 1) {
+                    const cid = m.chunks[0];
+                    const chunk = stats.chunks.find((c) => c.id === cid);
+                    if (!chunk || !chunk.files) {
+                        return;
+                    }
+                    const id = stripModuleIdHash(m.identifier);
+                    const files = (manifest.modules[hash(id)] =
+                        chunk.files.map(fileToIndex));
+                    // find all asset modules associated with the same chunk
+                    assetModules.forEach((m) => {
+                        if (m.chunks.some((id) => id === cid)) {
+                            files.push.apply(files, m.assets.map(fileToIndex));
+                        }
+                    });
+                }
+            });
+            const json = JSON.stringify(manifest, null, 2);
+            //@ts-expect-error no type on options
+            compilation.assets[this.options.filename] = {
+                source: () => json,
+                size: () => json.length,
+            };
+            cb();
         });
-      }
-    });
-
-    var json = JSON.stringify(manifest, null, 2);
-    compilation.assets[this$1.options.filename] = {
-      source: function () { return json; },
-      size: function () { return json.length; }
-    };
-    cb();
-  });
-};
+    }
+}
 
-module.exports = VueSSRClientPlugin;
\ No newline at end of file
+module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index 231bcf967ad..d8682e73387 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -1,142 +1,118 @@
 'use strict';
 
-/*  */
-
-var isJS = function (file) { return /\.js(\?[^.]+)?$/.test(file); };
-
-var ref = require('chalk');
-var red = ref.red;
-var yellow = ref.yellow;
-var webpack = require('webpack');
-
-var prefix = "[vue-server-renderer-webpack-plugin]";
-var warn = exports.warn = function (msg) { return console.error(red((prefix + " " + msg + "\n"))); };
-var tip = exports.tip = function (msg) { return console.log(yellow((prefix + " " + msg + "\n"))); };
-
-var isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-
-var validate = function (compiler) {
-  if (compiler.options.target !== 'node') {
-    warn('webpack config `target` should be "node".');
-  }
-
-  if (compiler.options.output) {
-    if (compiler.options.output.library) {
-      // Webpack >= 5.0.0
-      if (compiler.options.output.library.type !== 'commonjs2') {
-        warn('webpack config `output.library.type` should be "commonjs2".');
-      }
-    } else if (compiler.options.output.libraryTarget !== 'commonjs2') {
-      // Webpack < 5.0.0
-      warn('webpack config `output.libraryTarget` should be "commonjs2".');
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+
+const { red, yellow } = require('chalk');
+const webpack = require('webpack');
+const prefix = `[vue-server-renderer-webpack-plugin]`;
+const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
+const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
+const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
+const validate = compiler => {
+    if (compiler.options.target !== 'node') {
+        warn('webpack config `target` should be "node".');
+    }
+    if (compiler.options.output) {
+        if (compiler.options.output.library) {
+            // Webpack >= 5.0.0
+            if (compiler.options.output.library.type !== 'commonjs2') {
+                warn('webpack config `output.library.type` should be "commonjs2".');
+            }
+        }
+        else if (compiler.options.output.libraryTarget !== 'commonjs2') {
+            // Webpack < 5.0.0
+            warn('webpack config `output.libraryTarget` should be "commonjs2".');
+        }
+    }
+    if (!compiler.options.externals) {
+        tip('It is recommended to externalize dependencies in the server build for ' +
+            'better build performance.');
     }
-  }
-
-  if (!compiler.options.externals) {
-    tip(
-      'It is recommended to externalize dependencies in the server build for ' +
-      'better build performance.'
-    );
-  }
-};
-
-var onEmit = function (compiler, name, stageName, hook) {
-  if (isWebpack5) {
-    // Webpack >= 5.0.0
-    compiler.hooks.compilation.tap(name, function (compilation) {
-      if (compilation.compiler !== compiler) {
-        // Ignore child compilers
-        return
-      }
-      var stage = webpack.Compilation[stageName];
-      compilation.hooks.processAssets.tapAsync({ name: name, stage: stage }, function (assets, cb) {
-        hook(compilation, cb);
-      });
-    });
-  } else if (compiler.hooks) {
-    // Webpack >= 4.0.0
-    compiler.hooks.emit.tapAsync(name, hook);
-  } else {
-    // Webpack < 4.0.0
-    compiler.plugin('emit', hook);
-  }
-};
-
-var getAssetName = function (asset) {
-  if (typeof asset === 'string') {
-    return asset
-  }
-  return asset.name
 };
-
-var VueSSRServerPlugin = function VueSSRServerPlugin (options) {
-  if ( options === void 0 ) options = {};
-
-  this.options = Object.assign({
-    filename: 'vue-ssr-server-bundle.json'
-  }, options);
+const onEmit = (compiler, name, stageName, hook) => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        compiler.hooks.compilation.tap(name, compilation => {
+            if (compilation.compiler !== compiler) {
+                // Ignore child compilers
+                return;
+            }
+            const stage = webpack.Compilation[stageName];
+            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
+                hook(compilation, cb);
+            });
+        });
+    }
+    else if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
 };
-
-VueSSRServerPlugin.prototype.apply = function apply (compiler) {
-    var this$1 = this;
-
-  validate(compiler);
-
-  var stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
-  onEmit(compiler, 'vue-server-plugin', stage, function (compilation, cb) {
-    var stats = compilation.getStats().toJson();
-    var entryName = Object.keys(stats.entrypoints)[0];
-    var entryInfo = stats.entrypoints[entryName];
-
-    if (!entryInfo) {
-      // #5553
-      return cb()
+const getAssetName = asset => {
+    if (typeof asset === 'string') {
+        return asset;
     }
+    return asset.name;
+};
 
-    var entryAssets = entryInfo.assets
-      .map(getAssetName)
-      .filter(isJS);
-
-    if (entryAssets.length > 1) {
-      throw new Error(
-        "Server-side bundle should have one single entry file. " +
-        "Avoid using CommonsChunkPlugin in the server config."
-      )
+class VueSSRServerPlugin {
+    constructor(options = {}) {
+        //@ts-expect-error
+        this.options = Object.assign({
+            filename: 'vue-ssr-server-bundle.json',
+        }, options);
     }
-
-    var entry = entryAssets[0];
-    if (!entry || typeof entry !== 'string') {
-      throw new Error(
-        ("Entry \"" + entryName + "\" not found. Did you specify the correct entry option?")
-      )
+    apply(compiler) {
+        validate(compiler);
+        const stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
+        onEmit(compiler, 'vue-server-plugin', stage, (compilation, cb) => {
+            const stats = compilation.getStats().toJson();
+            const entryName = Object.keys(stats.entrypoints)[0];
+            const entryInfo = stats.entrypoints[entryName];
+            if (!entryInfo) {
+                // #5553
+                return cb();
+            }
+            const entryAssets = entryInfo.assets
+                .map(getAssetName)
+                .filter(isJS);
+            if (entryAssets.length > 1) {
+                throw new Error(`Server-side bundle should have one single entry file. ` +
+                    `Avoid using CommonsChunkPlugin in the server config.`);
+            }
+            const entry = entryAssets[0];
+            if (!entry || typeof entry !== 'string') {
+                throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
+            }
+            const bundle = {
+                entry,
+                files: {},
+                maps: {},
+            };
+            Object.keys(compilation.assets).forEach(name => {
+                if (isJS(name)) {
+                    bundle.files[name] = compilation.assets[name].source();
+                }
+                else if (name.match(/\.js\.map$/)) {
+                    bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
+                }
+                // do not emit anything else for server
+                delete compilation.assets[name];
+            });
+            const json = JSON.stringify(bundle, null, 2);
+            //@ts-expect-error
+            const filename = this.options.filename;
+            compilation.assets[filename] = {
+                source: () => json,
+                size: () => json.length,
+            };
+            cb();
+        });
     }
-
-    var bundle = {
-      entry: entry,
-      files: {},
-      maps: {}
-    };
-
-    Object.keys(compilation.assets).forEach(function (name) {
-      if (isJS(name)) {
-        bundle.files[name] = compilation.assets[name].source();
-      } else if (name.match(/\.js\.map$/)) {
-        bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
-      }
-      // do not emit anything else for server
-      delete compilation.assets[name];
-    });
-
-    var json = JSON.stringify(bundle, null, 2);
-    var filename = this$1.options.filename;
-
-    compilation.assets[filename] = {
-      source: function () { return json; },
-      size: function () { return json.length; }
-    };
-
-    cb();
-  });
-};
+}
 
 module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-server-renderer/types/plugin.d.ts b/packages/vue-server-renderer/types/plugin.d.ts
index 50b642290da..89d03c8da7e 100644
--- a/packages/vue-server-renderer/types/plugin.d.ts
+++ b/packages/vue-server-renderer/types/plugin.d.ts
@@ -1,9 +1,11 @@
-import { Plugin } from 'webpack';
+import { DefinePlugin } from 'webpack';
 
 interface WebpackPluginOptions {
   filename?: string;
 }
 
 export interface WebpackPlugin {
-  new (options?: WebpackPluginOptions): Plugin;
+  // NOTE NOT SURE ABOUT THIS
+  // TODO DOUBLE CHECK HERE
+  new (options?: WebpackPluginOptions): DefinePlugin;
 }
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index 92d3b5d913a..5a1007309da 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -1,5769 +1,4945 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = global || self, factory(global.VueTemplateCompiler = {}));
-}(this, function (exports) { 'use strict';
-
-  var splitRE = /\r?\n/g;
-  var emptyRE = /^\s*$/;
-  var needFixRE = /^(\r?\n)*[\t\s]/;
-
-  var deIndent = function deindent (str) {
-    if (!needFixRE.test(str)) {
-      return str
-    }
-    var lines = str.split(splitRE);
-    var min = Infinity;
-    var type, cur, c;
-    for (var i = 0; i < lines.length; i++) {
-      var line = lines[i];
-      if (!emptyRE.test(line)) {
-        if (!type) {
-          c = line.charAt(0);
-          if (c === ' ' || c === '\t') {
-            type = c;
-            cur = count(line, type);
-            if (cur < min) {
-              min = cur;
-            }
-          } else {
-            return str
-          }
-        } else {
-          cur = count(line, type);
-          if (cur < min) {
-            min = cur;
-          }
-        }
-      }
-    }
-    return lines.map(function (line) {
-      return line.slice(min)
-    }).join('\n')
-  };
-
-  function count (line, type) {
-    var i = 0;
-    while (line.charAt(i) === type) {
-      i++;
-    }
-    return i
-  }
-
-  /*  */
-
-  var emptyObject = Object.freeze({});
-
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef (v) {
-    return v === undefined || v === null
-  }
-
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive (value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
-  }
-
-  /**
-   * Quick object check - this is primarily used to tell
-   * Objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject (obj) {
-    return obj !== null && typeof obj === 'object'
-  }
-
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  var _toString = Object.prototype.toString;
-
-  function toRawType (value) {
-    return _toString.call(value).slice(8, -1)
-  }
-
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject (obj) {
-    return _toString.call(obj) === '[object Object]'
-  }
-
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex (val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
-  }
-
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap (
-    str,
-    expectsLowerCase
-  ) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase
-      ? function (val) { return map[val.toLowerCase()]; }
-      : function (val) { return map[val]; }
-  }
-
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  var isBuiltInTag = makeMap('slot,component', true);
-
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
-  /**
-   * Remove an item from an array.
-   */
-  function remove (arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item);
-      if (index > -1) {
-        return arr.splice(index, 1)
-      }
-    }
-  }
-
-  /**
-   * Check whether an object has the property.
-   */
-  var hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn (obj, key) {
-    return hasOwnProperty.call(obj, key)
-  }
-
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached (fn) {
-    var cache = Object.create(null);
-    return (function cachedFn (str) {
-      var hit = cache[str];
-      return hit || (cache[str] = fn(str))
-    })
-  }
-
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  var camelizeRE = /-(\w)/g;
-  var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
-  });
-
-  /**
-   * Hyphenate a camelCase string.
-   */
-  var hyphenateRE = /\B([A-Z])/g;
-  var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
-  });
-
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-
-  /* istanbul ignore next */
-  function polyfillBind (fn, ctx) {
-    function boundFn (a) {
-      var l = arguments.length;
-      return l
-        ? l > 1
-          ? fn.apply(ctx, arguments)
-          : fn.call(ctx, a)
-        : fn.call(ctx)
-    }
-
-    boundFn._length = fn.length;
-    return boundFn
-  }
-
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
-
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
-
-  /**
-   * Mix properties into target object.
-   */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
-    }
-    return to
-  }
-
-  /* eslint-disable no-unused-vars */
-
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop (a, b, c) {}
-
-  /**
-   * Always return false.
-   */
-  var no = function (a, b, c) { return false; };
-
-  /* eslint-enable no-unused-vars */
-
-  /**
-   * Return the same value.
-   */
-  var identity = function (_) { return _; };
-
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys (modules) {
-    return modules.reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, []).join(',')
-  }
-
-  /*  */
-
-  var isUnaryTag = makeMap(
-    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr'
-  );
-
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  var canBeLeftOpenTag = makeMap(
-    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-  );
-
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap(
-    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track'
-  );
-
-  /*  */
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
-  /**
-   * Define a property.
-   */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
-  }
-
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-
-  // Regular Expressions for parsing tags and attributes
-  var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-  var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-  var startTagOpen = new RegExp(("^<" + qnameCapture));
-  var startTagClose = /^\s*(\/?)>/;
-  var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-  var doctype = /^<!DOCTYPE [^>]+>/i;
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  var comment = /^<!\--/;
-  var conditionalComment = /^<!\[/;
-
-  // Special Elements (can contain anything)
-  var isPlainTextElement = makeMap('script,style,textarea', true);
-  var reCache = {};
-
-  var decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'"
-  };
-  var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
-  // #5992
-  var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-  function decodeAttr (value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, function (match) { return decodingMap[match]; })
-  }
-
-  function parseHTML (html, options) {
-    var stack = [];
-    var expectHTML = options.expectHTML;
-    var isUnaryTag$$1 = options.isUnaryTag || no;
-    var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-    var index = 0;
-    var last, lastTag;
-    while (html) {
-      last = html;
-      // Make sure we're not in a plaintext content element like script/style
-      if (!lastTag || !isPlainTextElement(lastTag)) {
-        var textEnd = html.indexOf('<');
-        if (textEnd === 0) {
-          // Comment:
-          if (comment.test(html)) {
-            var commentEnd = html.indexOf('-->');
-
-            if (commentEnd >= 0) {
-              if (options.shouldKeepComment) {
-                options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-              }
-              advance(commentEnd + 3);
-              continue
-            }
-          }
-
-          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (conditionalComment.test(html)) {
-            var conditionalEnd = html.indexOf(']>');
-
-            if (conditionalEnd >= 0) {
-              advance(conditionalEnd + 2);
-              continue
-            }
-          }
-
-          // Doctype:
-          var doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length);
-            continue
-          }
-
-          // End tag:
-          var endTagMatch = html.match(endTag);
-          if (endTagMatch) {
-            var curIndex = index;
-            advance(endTagMatch[0].length);
-            parseEndTag(endTagMatch[1], curIndex, index);
-            continue
-          }
-
-          // Start tag:
-          var startTagMatch = parseStartTag();
-          if (startTagMatch) {
-            handleStartTag(startTagMatch);
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1);
-            }
-            continue
-          }
-        }
-
-        var text = (void 0), rest = (void 0), next = (void 0);
-        if (textEnd >= 0) {
-          rest = html.slice(textEnd);
-          while (
-            !endTag.test(rest) &&
-            !startTagOpen.test(rest) &&
-            !comment.test(rest) &&
-            !conditionalComment.test(rest)
-          ) {
-            // < in plain text, be forgiving and treat it as text
-            next = rest.indexOf('<', 1);
-            if (next < 0) { break }
-            textEnd += next;
-            rest = html.slice(textEnd);
-          }
-          text = html.substring(0, textEnd);
-        }
-
-        if (textEnd < 0) {
-          text = html;
-        }
-
-        if (text) {
-          advance(text.length);
-        }
-
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index);
-        }
-      } else {
-        var endTagLength = 0;
-        var stackedTag = lastTag.toLowerCase();
-        var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-        var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-          endTagLength = endTag.length;
-          if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-            text = text
-              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-          }
-          if (shouldIgnoreFirstNewline(stackedTag, text)) {
-            text = text.slice(1);
-          }
-          if (options.chars) {
-            options.chars(text);
-          }
-          return ''
-        });
-        index += html.length - rest$1.length;
-        html = rest$1;
-        parseEndTag(stackedTag, index - endTagLength, index);
-      }
-
-      if (html === last) {
-        options.chars && options.chars(html);
-        if (!stack.length && options.warn) {
-          options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-        }
-        break
-      }
-    }
-
-    // Clean up any remaining tags
-    parseEndTag();
-
-    function advance (n) {
-      index += n;
-      html = html.substring(n);
-    }
-
-    function parseStartTag () {
-      var start = html.match(startTagOpen);
-      if (start) {
-        var match = {
-          tagName: start[1],
-          attrs: [],
-          start: index
-        };
-        advance(start[0].length);
-        var end, attr;
-        while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-          attr.start = index;
-          advance(attr[0].length);
-          attr.end = index;
-          match.attrs.push(attr);
-        }
-        if (end) {
-          match.unarySlash = end[1];
-          advance(end[0].length);
-          match.end = index;
-          return match
-        }
-      }
-    }
-
-    function handleStartTag (match) {
-      var tagName = match.tagName;
-      var unarySlash = match.unarySlash;
-
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag);
-        }
-        if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-          parseEndTag(tagName);
-        }
-      }
-
-      var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-      var l = match.attrs.length;
-      var attrs = new Array(l);
-      for (var i = 0; i < l; i++) {
-        var args = match.attrs[i];
-        var value = args[3] || args[4] || args[5] || '';
-        var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-          ? options.shouldDecodeNewlinesForHref
-          : options.shouldDecodeNewlines;
-        attrs[i] = {
-          name: args[1],
-          value: decodeAttr(value, shouldDecodeNewlines)
-        };
-        if (options.outputSourceRange) {
-          attrs[i].start = args.start + args[0].match(/^\s*/).length;
-          attrs[i].end = args.end;
-        }
-      }
-
-      if (!unary) {
-        stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-        lastTag = tagName;
-      }
-
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end);
-      }
-    }
-
-    function parseEndTag (tagName, start, end) {
-      var pos, lowerCasedTagName;
-      if (start == null) { start = index; }
-      if (end == null) { end = index; }
-
-      // Find the closest opened tag of the same type
-      if (tagName) {
-        lowerCasedTagName = tagName.toLowerCase();
-        for (pos = stack.length - 1; pos >= 0; pos--) {
-          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-            break
-          }
-        }
-      } else {
-        // If no tag name is provided, clean shop
-        pos = 0;
-      }
-
-      if (pos >= 0) {
-        // Close all the open elements, up the stack
-        for (var i = stack.length - 1; i >= pos; i--) {
-          if (i > pos || !tagName &&
-            options.warn
-          ) {
-            options.warn(
-              ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-              { start: stack[i].start, end: stack[i].end }
-            );
-          }
-          if (options.end) {
-            options.end(stack[i].tag, start, end);
-          }
-        }
-
-        // Remove the open elements from the stack
-        stack.length = pos;
-        lastTag = pos && stack[pos - 1].tag;
-      } else if (lowerCasedTagName === 'br') {
-        if (options.start) {
-          options.start(tagName, [], true, start, end);
-        }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end);
-        }
-        if (options.end) {
-          options.end(tagName, start, end);
-        }
-      }
-    }
-  }
-
-  /*  */
-
-  var splitRE$1 = /\r?\n/g;
-  var replaceRE = /./g;
-  var isSpecialTag = makeMap('script,style,template', true);
-
-  /**
-   * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
-   */
-  function parseComponent (
-    content,
-    options
-  ) {
-    if ( options === void 0 ) options = {};
-
-    var sfc = {
-      template: null,
-      script: null,
-      styles: [],
-      customBlocks: [],
-      errors: []
-    };
-    var depth = 0;
-    var currentBlock = null;
-
-    var warn = function (msg) {
-      sfc.errors.push(msg);
-    };
-
-    if (options.outputSourceRange) {
-      warn = function (msg, range) {
-        var data = { msg: msg };
-        if (range.start != null) {
-          data.start = range.start;
-        }
-        if (range.end != null) {
-          data.end = range.end;
-        }
-        sfc.errors.push(data);
-      };
-    }
-
-    function start (
-      tag,
-      attrs,
-      unary,
-      start,
-      end
-    ) {
-      if (depth === 0) {
-        currentBlock = {
-          type: tag,
-          content: '',
-          start: end,
-          attrs: attrs.reduce(function (cumulated, ref) {
-            var name = ref.name;
-            var value = ref.value;
-
-            cumulated[name] = value || true;
-            return cumulated
-          }, {})
-        };
-        if (isSpecialTag(tag)) {
-          checkAttrs(currentBlock, attrs);
-          if (tag === 'style') {
-            sfc.styles.push(currentBlock);
-          } else {
-            sfc[tag] = currentBlock;
-          }
-        } else { // custom blocks
-          sfc.customBlocks.push(currentBlock);
-        }
-      }
-      if (!unary) {
-        depth++;
-      }
-    }
-
-    function checkAttrs (block, attrs) {
-      for (var i = 0; i < attrs.length; i++) {
-        var attr = attrs[i];
-        if (attr.name === 'lang') {
-          block.lang = attr.value;
-        }
-        if (attr.name === 'scoped') {
-          block.scoped = true;
-        }
-        if (attr.name === 'module') {
-          block.module = attr.value || true;
-        }
-        if (attr.name === 'src') {
-          block.src = attr.value;
-        }
-      }
-    }
-
-    function end (tag, start) {
-      if (depth === 1 && currentBlock) {
-        currentBlock.end = start;
-        var text = content.slice(currentBlock.start, currentBlock.end);
-        if (options.deindent !== false) {
-          text = deIndent(text);
-        }
-        // pad content so that linters and pre-processors can output correct
-        // line numbers in errors and warnings
-        if (currentBlock.type !== 'template' && options.pad) {
-          text = padContent(currentBlock, options.pad) + text;
-        }
-        currentBlock.content = text;
-        currentBlock = null;
-      }
-      depth--;
-    }
-
-    function padContent (block, pad) {
-      if (pad === 'space') {
-        return content.slice(0, block.start).replace(replaceRE, ' ')
-      } else {
-        var offset = content.slice(0, block.start).split(splitRE$1).length;
-        var padChar = block.type === 'script' && !block.lang
-          ? '//\n'
-          : '\n';
-        return Array(offset).join(padChar)
-      }
-    }
-
-    parseHTML(content, {
-      warn: warn,
-      start: start,
-      end: end,
-      outputSourceRange: options.outputSourceRange
-    });
-
-    return sfc
-  }
-
-  /*  */
-
-  // can we use __proto__?
-  var hasProto = '__proto__' in {};
-
-  // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined';
-  var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  var isIE = UA && /msie|trident/.test(UA);
-  var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  var isEdge = UA && UA.indexOf('edge/') > 0;
-  var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-  var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-  var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-  var isPhantomJS = UA && /phantomjs/.test(UA);
-  var isFF = UA && UA.match(/firefox\/(\d+)/);
-
-  // Firefox has a "watch" function on Object.prototype...
-  var nativeWatch = ({}).watch;
-  if (inBrowser) {
-    try {
-      var opts = {};
-      Object.defineProperty(opts, 'passive', ({
-        get: function get () {
-        }
-      })); // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts);
-    } catch (e) {}
-  }
-
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  var _isServer;
-  var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-      } else {
-        _isServer = false;
-      }
-    }
-    return _isServer
-  };
-
-  // detect devtools
-  var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
-  /* istanbul ignore next */
-  function isNative (Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-
-  var hasSymbol =
-    typeof Symbol !== 'undefined' && isNative(Symbol) &&
-    typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-  var _Set;
-  /* istanbul ignore if */ // $flow-disable-line
-  if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-  } else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /*@__PURE__*/(function () {
-      function Set () {
-        this.set = Object.create(null);
-      }
-      Set.prototype.has = function has (key) {
-        return this.set[key] === true
-      };
-      Set.prototype.add = function add (key) {
-        this.set[key] = true;
-      };
-      Set.prototype.clear = function clear () {
-        this.set = Object.create(null);
-      };
-
-      return Set;
-    }());
-  }
-
-  var ASSET_TYPES = [
-    'component',
-    'directive',
-    'filter'
-  ];
-
-  var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
-  ];
-
-  /*  */
-
-
-
-  var config = ({
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  });
-
-  /*  */
-
-  var warn = noop;
-  var tip = noop;
-  var generateComponentTrace = (noop); // work around flow check
-  var formatComponentName = (noop);
-
-  {
-    var hasConsole = typeof console !== 'undefined';
-    var classifyRE = /(?:^|[-_])(\w)/g;
-    var classify = function (str) { return str
-      .replace(classifyRE, function (c) { return c.toUpperCase(); })
-      .replace(/[-_]/g, ''); };
-
-    warn = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : '';
-
-      if (hasConsole && (!config.silent)) {
-        console.error(("[Vue warn]: " + msg + trace));
-      }
-    };
-
-    tip = function (msg, vm) {
-      if (hasConsole && (!config.silent)) {
-        console.warn("[Vue tip]: " + msg + (
-          vm ? generateComponentTrace(vm) : ''
-        ));
-      }
-    };
-
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options = typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm;
-      var name = options.name || options._componentTag;
-      var file = options.__file;
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/);
-        name = match && match[1];
-      }
-
-      return (
-        (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-        (file && includeFile !== false ? (" at " + file) : '')
-      )
-    };
-
-    var repeat = function (str, n) {
-      var res = '';
-      while (n) {
-        if (n % 2 === 1) { res += str; }
-        if (n > 1) { str += str; }
-        n >>= 1;
-      }
-      return res
-    };
-
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = [];
-        var currentRecursiveSequence = 0;
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1];
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++;
-              vm = vm.$parent;
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence];
-              currentRecursiveSequence = 0;
-            }
-          }
-          tree.push(vm);
-          vm = vm.$parent;
-        }
-        return '\n\nfound in\n\n' + tree
-          .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-              ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-              : formatComponentName(vm))); })
-          .join('\n')
-      } else {
-        return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-      }
-    };
-  }
-
-  /*  */
-
-  var uid = 0;
-
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  var Dep = function Dep () {
-    this.id = uid++;
-    this.subs = [];
-  };
-
-  Dep.prototype.addSub = function addSub (sub) {
-    this.subs.push(sub);
-  };
-
-  Dep.prototype.removeSub = function removeSub (sub) {
-    remove(this.subs, sub);
-  };
-
-  Dep.prototype.depend = function depend () {
-    if (Dep.target) {
-      Dep.target.addDep(this);
-    }
-  };
-
-  Dep.prototype.notify = function notify () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice();
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update();
-    }
-  };
-
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-
-  /*  */
-
-  var VNode = function VNode (
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
-  };
-
-  var prototypeAccessors = { child: { configurable: true } };
-
-  // DEPRECATED: alias for componentInstance for backwards compat.
-  /* istanbul ignore next */
-  prototypeAccessors.child.get = function () {
-    return this.componentInstance
-  };
-
-  Object.defineProperties( VNode.prototype, prototypeAccessors );
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-
-  var arrayProto = Array.prototype;
-  var arrayMethods = Object.create(arrayProto);
-
-  var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-  ];
-
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var result = original.apply(this, args);
-      var ob = this.__ob__;
-      var inserted;
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args;
-          break
-        case 'splice':
-          inserted = args.slice(2);
-          break
-      }
-      if (inserted) { ob.observeArray(inserted); }
-      // notify change
-      ob.dep.notify();
-      return result
-    });
-  });
-
-  /*  */
-
-  var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  var shouldObserve = true;
-
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  var Observer = function Observer (value) {
-    this.value = value;
-    this.dep = new Dep();
-    this.vmCount = 0;
-    def(value, '__ob__', this);
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods);
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys);
-      }
-      this.observeArray(value);
-    } else {
-      this.walk(value);
-    }
-  };
-
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function walk (obj) {
-    var keys = Object.keys(obj);
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive$$1(obj, keys[i]);
-    }
-  };
-
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function observeArray (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i]);
-    }
-  };
-
-  // helpers
-
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment (target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-  }
-
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment (target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i];
-      def(target, key, src[key]);
-    }
-  }
-
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe (value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__;
-    } else if (
-      shouldObserve &&
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-      ob.vmCount++;
-    }
-    return ob
-  }
-
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive$$1 (
-    obj,
-    key,
-    val,
-    customSetter,
-    shallow
-  ) {
-    var dep = new Dep();
-
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-      return
-    }
-
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key];
-    }
-
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter () {
-        var value = getter ? getter.call(obj) : val;
-        if (Dep.target) {
-          dep.depend();
-          if (childOb) {
-            childOb.dep.depend();
-            if (Array.isArray(value)) {
-              dependArray(value);
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter (newVal) {
-        var value = getter ? getter.call(obj) : val;
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter();
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) { return }
-        if (setter) {
-          setter.call(obj, newVal);
-        } else {
-          val = newVal;
-        }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
-      }
-    });
-  }
-
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set (target, key, val) {
-    if (isUndef(target) || isPrimitive(target)
-    ) {
-      warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key);
-      target.splice(key, 1, val);
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val;
-      return val
-    }
-    var ob = (target).__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-        'at runtime - declare it upfront in the data option.'
-      );
-      return val
-    }
-    if (!ob) {
-      target[key] = val;
-      return val
-    }
-    defineReactive$$1(ob.value, key, val);
-    ob.dep.notify();
-    return val
-  }
-
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray (value) {
-    for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-      e = value[i];
-      e && e.__ob__ && e.__ob__.dep.depend();
-      if (Array.isArray(e)) {
-        dependArray(e);
-      }
-    }
-  }
-
-  /*  */
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  var strats = config.optionMergeStrategies;
-
-  /**
-   * Options with restrictions
-   */
-  {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn(
-          "option \"" + key + "\" can only be used during instance " +
-          'creation with the `new` keyword.'
-        );
-      }
-      return defaultStrat(parent, child)
-    };
-  }
-
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData (to, from) {
-    if (!from) { return to }
-    var key, toVal, fromVal;
-
-    var keys = hasSymbol
-      ? Reflect.ownKeys(from)
-      : Object.keys(from);
-
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i];
-      // in case the object is already observed...
-      if (key === '__ob__') { continue }
-      toVal = to[key];
-      fromVal = from[key];
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal);
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal);
-      }
-    }
-    return to
-  }
-
-  /**
-   * Data
-   */
-  function mergeDataOrFn (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn () {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn () {
-        // instance merge
-        var instanceData = typeof childVal === 'function'
-          ? childVal.call(vm, vm)
-          : childVal;
-        var defaultData = typeof parentVal === 'function'
-          ? parentVal.call(vm, vm)
-          : parentVal;
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
-      }
-    }
-  }
-
-  strats.data = function (
-    parentVal,
-    childVal,
-    vm
-  ) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn(
-          'The "data" option should be a function ' +
-          'that returns a per-instance value in component ' +
-          'definitions.',
-          vm
-        );
-
-        return parentVal
-      }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-
-    return mergeDataOrFn(parentVal, childVal, vm)
-  };
-
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook (
-    parentVal,
-    childVal
-  ) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-          ? childVal
-          : [childVal]
-      : parentVal;
-    return res
-      ? dedupeHooks(res)
-      : res
-  }
-
-  function dedupeHooks (hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i]);
-      }
-    }
-    return res
-  }
-
-  LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook;
-  });
-
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-      assertObjectType(key, childVal, vm);
-      return extend(res, childVal)
-    } else {
-      return res
-    }
-  }
-
-  ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-  });
-
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    // work around Firefox's Object.prototype.watch...
-    if (parentVal === nativeWatch) { parentVal = undefined; }
-    if (childVal === nativeWatch) { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal) { return Object.create(parentVal || null) }
-    {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key$1 in childVal) {
-      var parent = ret[key$1];
-      var child = childVal[key$1];
-      if (parent && !Array.isArray(parent)) {
-        parent = [parent];
-      }
-      ret[key$1] = parent
-        ? parent.concat(child)
-        : Array.isArray(child) ? child : [child];
-    }
-    return ret
-  };
-
-  /**
-   * Other object hashes.
-   */
-  strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed = function (
-    parentVal,
-    childVal,
-    vm,
-    key
-  ) {
-    if (childVal && "development" !== 'production') {
-      assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal) { return childVal }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal) { extend(ret, childVal); }
-    return ret
-  };
-  strats.provide = mergeDataOrFn;
-
-  /**
-   * Default strategy.
-   */
-  var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined
-      ? parentVal
-      : childVal
-  };
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
-      );
-    }
-  }
-
-  /*  */
-
-  /*  */
-
-  /*  */
-
-  var callbacks = [];
-
-  function flushCallbacks () {
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]();
-    }
-  }
-
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-    isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]'
-  )) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-      characterData: true
-    });
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-  /*  */
-
-  /*  */
-
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  var isReservedAttr = makeMap('style,class');
-
-  // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress');
-  var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
-  };
-
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
-  var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible'
-  );
-
-  /*  */
-
-  /*  */
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-  );
-
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  );
-
-  var isPreTag = function (tag) { return tag === 'pre'; };
-
-  var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
-  };
-
-  function getTagNamespace (tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
-  }
-
-  var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-  /*  */
-
-  /*  */
-
-  var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-  function parseFilters (exp) {
-    var inSingle = false;
-    var inDouble = false;
-    var inTemplateString = false;
-    var inRegex = false;
-    var curly = 0;
-    var square = 0;
-    var paren = 0;
-    var lastFilterIndex = 0;
-    var c, prev, i, expression, filters;
-
-    for (i = 0; i < exp.length; i++) {
-      prev = c;
-      c = exp.charCodeAt(i);
-      if (inSingle) {
-        if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-      } else if (inDouble) {
-        if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-      } else if (inTemplateString) {
-        if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-      } else if (inRegex) {
-        if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-      } else if (
-        c === 0x7C && // pipe
-        exp.charCodeAt(i + 1) !== 0x7C &&
-        exp.charCodeAt(i - 1) !== 0x7C &&
-        !curly && !square && !paren
-      ) {
-        if (expression === undefined) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1;
-          expression = exp.slice(0, i).trim();
-        } else {
-          pushFilter();
-        }
-      } else {
-        switch (c) {
-          case 0x22: inDouble = true; break         // "
-          case 0x27: inSingle = true; break         // '
-          case 0x60: inTemplateString = true; break // `
-          case 0x28: paren++; break                 // (
-          case 0x29: paren--; break                 // )
-          case 0x5B: square++; break                // [
-          case 0x5D: square--; break                // ]
-          case 0x7B: curly++; break                 // {
-          case 0x7D: curly--; break                 // }
-        }
-        if (c === 0x2f) { // /
-          var j = i - 1;
-          var p = (void 0);
-          // find first non-whitespace prev char
-          for (; j >= 0; j--) {
-            p = exp.charAt(j);
-            if (p !== ' ') { break }
-          }
-          if (!p || !validDivisionCharRE.test(p)) {
-            inRegex = true;
-          }
-        }
-      }
-    }
-
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
-    }
-
-    function pushFilter () {
-      (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-      lastFilterIndex = i + 1;
-    }
-
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i]);
-      }
-    }
-
-    return expression
-  }
-
-  function wrapFilter (exp, filter) {
-    var i = filter.indexOf('(');
-    if (i < 0) {
-      // _f: resolveFilter
-      return ("_f(\"" + filter + "\")(" + exp + ")")
-    } else {
-      var name = filter.slice(0, i);
-      var args = filter.slice(i + 1);
-      return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-    }
-  }
-
-  /*  */
-
-  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
-  var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-  });
-
-
-
-  function parseText (
-    text,
-    delimiters
-  ) {
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-      return
-    }
-    var tokens = [];
-    var rawTokens = [];
-    var lastIndex = tagRE.lastIndex = 0;
-    var match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-      index = match.index;
-      // push text token
-      if (index > lastIndex) {
-        rawTokens.push(tokenValue = text.slice(lastIndex, index));
-        tokens.push(JSON.stringify(tokenValue));
-      }
-      // tag token
-      var exp = parseFilters(match[1].trim());
-      tokens.push(("_s(" + exp + ")"));
-      rawTokens.push({ '@binding': exp });
-      lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-      rawTokens.push(tokenValue = text.slice(lastIndex));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
-    }
-  }
-
-  /*  */
-
-
-
-  /* eslint-disable no-unused-vars */
-  function baseWarn (msg, range) {
-    console.error(("[Vue compiler]: " + msg));
-  }
-  /* eslint-enable no-unused-vars */
-
-  function pluckModuleFunction (
-    modules,
-    key
-  ) {
-    return modules
-      ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-      : []
-  }
-
-  function addProp (el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
-  }
-
-  function addAttr (el, name, value, range, dynamic) {
-    var attrs = dynamic
-      ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-      : (el.attrs || (el.attrs = []));
-    attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-    el.plain = false;
-  }
-
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr (el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-  }
-
-  function addDirective (
-    el,
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers,
-    range
-  ) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-      name: name,
-      rawName: rawName,
-      value: value,
-      arg: arg,
-      isDynamicArg: isDynamicArg,
-      modifiers: modifiers
-    }, range));
-    el.plain = false;
-  }
-
-  function prependModifierMarker (symbol, name, dynamic) {
-    return dynamic
-      ? ("_p(" + name + ",\"" + symbol + "\")")
-      : symbol + name // mark the event as captured
-  }
-
-  function addHandler (
-    el,
-    name,
-    value,
-    modifiers,
-    important,
-    warn,
-    range,
-    dynamic
-  ) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (
-      warn &&
-      modifiers.prevent && modifiers.passive
-    ) {
-      warn(
-        'passive and prevent can\'t be used together. ' +
-        'Passive handler can\'t prevent default event.',
-        range
-      );
-    }
-
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'contextmenu';
-        delete modifiers.right;
-      }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'mouseup';
-      }
-    }
-
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture;
-      name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-      delete modifiers.once;
-      name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive;
-      name = prependModifierMarker('&', name, dynamic);
-    }
-
-    var events;
-    if (modifiers.native) {
-      delete modifiers.native;
-      events = el.nativeEvents || (el.nativeEvents = {});
-    } else {
-      events = el.events || (el.events = {});
-    }
-
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers;
-    }
-
-    var handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-      important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    } else if (handlers) {
-      events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    } else {
-      events[name] = newHandler;
-    }
-
-    el.plain = false;
-  }
-
-  function getRawBindingAttr (
-    el,
-    name
-  ) {
-    return el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
-  }
-
-  function getBindingAttr (
-    el,
-    name,
-    getStatic
-  ) {
-    var dynamicValue =
-      getAndRemoveAttr(el, ':' + name) ||
-      getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-      return parseFilters(dynamicValue)
-    } else if (getStatic !== false) {
-      var staticValue = getAndRemoveAttr(el, name);
-      if (staticValue != null) {
-        return JSON.stringify(staticValue)
-      }
-    }
-  }
-
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr (
-    el,
-    name,
-    removeFromMap
-  ) {
-    var val;
-    if ((val = el.attrsMap[name]) != null) {
-      var list = el.attrsList;
-      for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i].name === name) {
-          list.splice(i, 1);
-          break
-        }
-      }
-    }
-    if (removeFromMap) {
-      delete el.attrsMap[name];
-    }
-    return val
-  }
-
-  function getAndRemoveAttrByRegex (
-    el,
-    name
-  ) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      var attr = list[i];
-      if (name.test(attr.name)) {
-        list.splice(i, 1);
-        return attr
-      }
-    }
-  }
-
-  function rangeSetItem (
-    item,
-    range
-  ) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start;
-      }
-      if (range.end != null) {
-        item.end = range.end;
-      }
-    }
-    return item
-  }
-
-  /*  */
-
-  function transformNode (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-      var res = parseText(staticClass, options.delimiters);
-      if (res) {
-        warn(
-          "class=\"" + staticClass + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div class="{{ val }}">, use <div :class="val">.',
-          el.rawAttrsMap['class']
-        );
-      }
-    }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass);
-    }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-      el.classBinding = classBinding;
-    }
-  }
-
-  function genData (el) {
-    var data = '';
-    if (el.staticClass) {
-      data += "staticClass:" + (el.staticClass) + ",";
-    }
-    if (el.classBinding) {
-      data += "class:" + (el.classBinding) + ",";
-    }
-    return data
-  }
-
-  var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode,
-    genData: genData
-  };
-
-  /*  */
-
-  var parseStyleText = cached(function (cssText) {
-    var res = {};
-    var listDelimiter = /;(?![^(]*\))/g;
-    var propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter);
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-      }
-    });
-    return res
-  });
-
-  /*  */
-
-  function transformNode$1 (el, options) {
-    var warn = options.warn || baseWarn;
-    var staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-      /* istanbul ignore if */
-      {
-        var res = parseText(staticStyle, options.delimiters);
-        if (res) {
-          warn(
-            "style=\"" + staticStyle + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div style="{{ val }}">, use <div :style="val">.',
-            el.rawAttrsMap['style']
-          );
-        }
-      }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-      el.styleBinding = styleBinding;
-    }
-  }
-
-  function genData$1 (el) {
-    var data = '';
-    if (el.staticStyle) {
-      data += "staticStyle:" + (el.staticStyle) + ",";
-    }
-    if (el.styleBinding) {
-      data += "style:(" + (el.styleBinding) + "),";
-    }
-    return data
-  }
-
-  var style = {
-    staticKeys: ['staticStyle'],
-    transformNode: transformNode$1,
-    genData: genData$1
-  };
-
-  var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  function createCommonjsModule(fn, module) {
-  	return module = { exports: {} }, fn(module, module.exports), module.exports;
-  }
-
-  var he = createCommonjsModule(function (module, exports) {
-  (function(root) {
-
-  	// Detect free variables `exports`.
-  	var freeExports = exports;
-
-  	// Detect free variable `module`.
-  	var freeModule = module &&
-  		module.exports == freeExports && module;
-
-  	// Detect free variable `global`, from Node.js or Browserified code,
-  	// and use it as `root`.
-  	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-  		root = freeGlobal;
-  	}
-
-  	/*--------------------------------------------------------------------------*/
-
-  	// All astral symbols.
-  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  	// All ASCII symbols (not just printable ASCII) except those listed in the
-  	// first column of the overrides table.
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
-  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-  	// code points listed in the first column of the overrides table on
-  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-  	var regexEscape = /["&'<>`]/g;
-  	var escapeMap = {
-  		'"': '&quot;',
-  		'&': '&amp;',
-  		'\'': '&#x27;',
-  		'<': '&lt;',
-  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-  		// following is not strictly necessary unless it’s part of a tag or an
-  		// unquoted attribute value. We’re only escaping it to support those
-  		// situations, and for XML support.
-  		'>': '&gt;',
-  		// In Internet Explorer ≤ 8, the backtick character can be used
-  		// to break out of (un)quoted attribute values or HTML comments.
-  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
-  		// http://html5sec.org/#133.
-  		'`': '&#x60;'
-  	};
-
-  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var stringFromCharCode = String.fromCharCode;
-
-  	var object = {};
-  	var hasOwnProperty = object.hasOwnProperty;
-  	var has = function(object, propertyName) {
-  		return hasOwnProperty.call(object, propertyName);
-  	};
-
-  	var contains = function(array, value) {
-  		var index = -1;
-  		var length = array.length;
-  		while (++index < length) {
-  			if (array[index] == value) {
-  				return true;
-  			}
-  		}
-  		return false;
-  	};
-
-  	var merge = function(options, defaults) {
-  		if (!options) {
-  			return defaults;
-  		}
-  		var result = {};
-  		var key;
-  		for (key in defaults) {
-  			// A `hasOwnProperty` check is not needed here, since only recognized
-  			// option names are used anyway. Any others are ignored.
-  			result[key] = has(options, key) ? options[key] : defaults[key];
-  		}
-  		return result;
-  	};
-
-  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
-  	var codePointToSymbol = function(codePoint, strict) {
-  		var output = '';
-  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-  			// See issue #4:
-  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-  			// REPLACEMENT CHARACTER.”
-  			if (strict) {
-  				parseError('character reference outside the permissible Unicode range');
-  			}
-  			return '\uFFFD';
-  		}
-  		if (has(decodeMapNumeric, codePoint)) {
-  			if (strict) {
-  				parseError('disallowed character reference');
-  			}
-  			return decodeMapNumeric[codePoint];
-  		}
-  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-  			parseError('disallowed character reference');
-  		}
-  		if (codePoint > 0xFFFF) {
-  			codePoint -= 0x10000;
-  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-  			codePoint = 0xDC00 | codePoint & 0x3FF;
-  		}
-  		output += stringFromCharCode(codePoint);
-  		return output;
-  	};
-
-  	var hexEscape = function(codePoint) {
-  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-  	};
-
-  	var decEscape = function(codePoint) {
-  		return '&#' + codePoint + ';';
-  	};
-
-  	var parseError = function(message) {
-  		throw Error('Parse error: ' + message);
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var encode = function(string, options) {
-  		options = merge(options, encode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidRawCodePoint.test(string)) {
-  			parseError('forbidden code point');
-  		}
-  		var encodeEverything = options.encodeEverything;
-  		var useNamedReferences = options.useNamedReferences;
-  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
-  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-  		var escapeBmpSymbol = function(symbol) {
-  			return escapeCodePoint(symbol.charCodeAt(0));
-  		};
-
-  		if (encodeEverything) {
-  			// Encode ASCII symbols.
-  			string = string.replace(regexAsciiWhitelist, function(symbol) {
-  				// Use named references if requested & possible.
-  				if (useNamedReferences && has(encodeMap, symbol)) {
-  					return '&' + encodeMap[symbol] + ';';
-  				}
-  				return escapeBmpSymbol(symbol);
-  			});
-  			// Shorten a few escapes that represent two symbols, of which at least one
-  			// is within the ASCII range.
-  			if (useNamedReferences) {
-  				string = string
-  					.replace(/&gt;\u20D2/g, '&nvgt;')
-  					.replace(/&lt;\u20D2/g, '&nvlt;')
-  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
-  			}
-  			// Encode non-ASCII symbols.
-  			if (useNamedReferences) {
-  				// Encode non-ASCII symbols that can be replaced with a named reference.
-  				string = string.replace(regexEncodeNonAscii, function(string) {
-  					// Note: there is no need to check `has(encodeMap, string)` here.
-  					return '&' + encodeMap[string] + ';';
-  				});
-  			}
-  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-  		} else if (useNamedReferences) {
-  			// Apply named character references.
-  			// Encode `<>"'&` using named character references.
-  			if (!allowUnsafeSymbols) {
-  				string = string.replace(regexEscape, function(string) {
-  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-  				});
-  			}
-  			// Shorten escapes that represent two symbols, of which at least one is
-  			// `<>"'&`.
-  			string = string
-  				.replace(/&gt;\u20D2/g, '&nvgt;')
-  				.replace(/&lt;\u20D2/g, '&nvlt;');
-  			// Encode non-ASCII symbols that can be replaced with a named reference.
-  			string = string.replace(regexEncodeNonAscii, function(string) {
-  				// Note: there is no need to check `has(encodeMap, string)` here.
-  				return '&' + encodeMap[string] + ';';
-  			});
-  		} else if (!allowUnsafeSymbols) {
-  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-  			// using named character references.
-  			string = string.replace(regexEscape, escapeBmpSymbol);
-  		}
-  		return string
-  			// Encode astral symbols.
-  			.replace(regexAstralSymbols, function($0) {
-  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-  				var high = $0.charCodeAt(0);
-  				var low = $0.charCodeAt(1);
-  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-  				return escapeCodePoint(codePoint);
-  			})
-  			// Encode any remaining BMP symbols that are not printable ASCII symbols
-  			// using a hexadecimal escape.
-  			.replace(regexBmpWhitelist, escapeBmpSymbol);
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	encode.options = {
-  		'allowUnsafeSymbols': false,
-  		'encodeEverything': false,
-  		'strict': false,
-  		'useNamedReferences': false,
-  		'decimal' : false
-  	};
-
-  	var decode = function(html, options) {
-  		options = merge(options, decode.options);
-  		var strict = options.strict;
-  		if (strict && regexInvalidEntity.test(html)) {
-  			parseError('malformed character reference');
-  		}
-  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  			var codePoint;
-  			var semicolon;
-  			var decDigits;
-  			var hexDigits;
-  			var reference;
-  			var next;
-
-  			if ($1) {
-  				reference = $1;
-  				// Note: there is no need to check `has(decodeMap, reference)`.
-  				return decodeMap[reference];
-  			}
-
-  			if ($2) {
-  				// Decode named character references without trailing `;`, e.g. `&amp`.
-  				// This is only a parse error if it gets converted to `&`, or if it is
-  				// followed by `=` in an attribute context.
-  				reference = $2;
-  				next = $3;
-  				if (next && options.isAttributeValue) {
-  					if (strict && next == '=') {
-  						parseError('`&` did not start a character reference');
-  					}
-  					return $0;
-  				} else {
-  					if (strict) {
-  						parseError(
-  							'named character reference was not terminated by a semicolon'
-  						);
-  					}
-  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-  					return decodeMapLegacy[reference] + (next || '');
-  				}
-  			}
-
-  			if ($4) {
-  				// Decode decimal escapes, e.g. `&#119558;`.
-  				decDigits = $4;
-  				semicolon = $5;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(decDigits, 10);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			if ($6) {
-  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-  				hexDigits = $6;
-  				semicolon = $7;
-  				if (strict && !semicolon) {
-  					parseError('character reference was not terminated by a semicolon');
-  				}
-  				codePoint = parseInt(hexDigits, 16);
-  				return codePointToSymbol(codePoint, strict);
-  			}
-
-  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-  			if (strict) {
-  				parseError(
-  					'named character reference was not terminated by a semicolon'
-  				);
-  			}
-  			return $0;
-  		});
-  	};
-  	// Expose default options (so they can be overridden globally).
-  	decode.options = {
-  		'isAttributeValue': false,
-  		'strict': false
-  	};
-
-  	var escape = function(string) {
-  		return string.replace(regexEscape, function($0) {
-  			// Note: there is no need to check `has(escapeMap, $0)` here.
-  			return escapeMap[$0];
-  		});
-  	};
-
-  	/*--------------------------------------------------------------------------*/
-
-  	var he = {
-  		'version': '1.2.0',
-  		'encode': encode,
-  		'decode': decode,
-  		'escape': escape,
-  		'unescape': decode
-  	};
-
-  	// Some AMD build optimizers, like r.js, check for specific condition patterns
-  	// like the following:
-  	if (freeExports && !freeExports.nodeType) {
-  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-  			freeModule.exports = he;
-  		} else { // in Narwhal or RingoJS v0.7.0-
-  			for (var key in he) {
-  				has(he, key) && (freeExports[key] = he[key]);
-  			}
-  		}
-  	} else { // in Rhino or a web browser
-  		root.he = he;
-  	}
-
-  }(commonjsGlobal));
-  });
-
-  /*  */
-
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var ref = modifiers || {};
-    var number = ref.number;
-    var trim = ref.trim;
-
-    var baseValueExpression = '$$v';
-    var valueExpression = baseValueExpression;
-    if (trim) {
-      valueExpression =
-        "(typeof " + baseValueExpression + " === 'string'" +
-        "? " + baseValueExpression + ".trim()" +
-        ": " + baseValueExpression + ")";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-    var assignment = genAssignmentCode(value, valueExpression);
-
-    el.model = {
-      value: ("(" + value + ")"),
-      expression: JSON.stringify(value),
-      callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-    };
-  }
-
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode (
-    value,
-    assignment
-  ) {
-    var res = parseModel(value);
-    if (res.key === null) {
-      return (value + "=" + assignment)
-    } else {
-      return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-    }
-  }
-
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-
-  var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-  function parseModel (val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-      index = val.lastIndexOf('.');
-      if (index > -1) {
-        return {
-          exp: val.slice(0, index),
-          key: '"' + val.slice(index + 1) + '"'
-        }
-      } else {
-        return {
-          exp: val,
-          key: null
-        }
-      }
-    }
-
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-
-    while (!eof()) {
-      chr = next();
-      /* istanbul ignore if */
-      if (isStringStart(chr)) {
-        parseString(chr);
-      } else if (chr === 0x5B) {
-        parseBracket(chr);
-      }
-    }
-
-    return {
-      exp: val.slice(0, expressionPos),
-      key: val.slice(expressionPos + 1, expressionEndPos)
-    }
-  }
-
-  function next () {
-    return str.charCodeAt(++index)
-  }
-
-  function eof () {
-    return index >= len
-  }
-
-  function isStringStart (chr) {
-    return chr === 0x22 || chr === 0x27
-  }
-
-  function parseBracket (chr) {
-    var inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-      chr = next();
-      if (isStringStart(chr)) {
-        parseString(chr);
-        continue
-      }
-      if (chr === 0x5B) { inBracket++; }
-      if (chr === 0x5D) { inBracket--; }
-      if (inBracket === 0) {
-        expressionEndPos = index;
-        break
-      }
-    }
-  }
-
-  function parseString (chr) {
-    var stringQuote = chr;
-    while (!eof()) {
-      chr = next();
-      if (chr === stringQuote) {
-        break
-      }
-    }
-  }
-
-  /*  */
-
-  var onRE = /^@|^v-on:/;
-  var dirRE = /^v-|^@|^:|^#/;
-  var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  var stripParensRE = /^\(|\)$/g;
-  var dynamicArgRE = /^\[.*\]$/;
-
-  var argRE = /:(.*)$/;
-  var bindRE = /^:|^\.|^v-bind:/;
-  var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
-  var slotRE = /^v-slot(:|$)|^#/;
-
-  var lineBreakRE = /[\r\n]/;
-  var whitespaceRE = /[ \f\t\r\n]+/g;
-
-  var invalidAttributeRE = /[\s"'<>\/=]/;
-
-  var decodeHTMLCached = cached(he.decode);
-
-  var emptySlotScopeToken = "_empty_";
-
-  // configurable state
-  var warn$1;
-  var delimiters;
-  var transforms;
-  var preTransforms;
-  var postTransforms;
-  var platformIsPreTag;
-  var platformMustUseProp;
-  var platformGetTagNamespace;
-  var maybeComponent;
-
-  function createASTElement (
-    tag,
-    attrs,
-    parent
-  ) {
-    return {
-      type: 1,
-      tag: tag,
-      attrsList: attrs,
-      attrsMap: makeAttrsMap(attrs),
-      rawAttrsMap: {},
-      parent: parent,
-      children: []
-    }
-  }
-
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse (
-    template,
-    options
-  ) {
-    warn$1 = options.warn || baseWarn;
-
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    var isReservedTag = options.isReservedTag || no;
-    maybeComponent = function (el) { return !!(
-      el.component ||
-      el.attrsMap[':is'] ||
-      el.attrsMap['v-bind:is'] ||
-      !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
-    ); };
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-    delimiters = options.delimiters;
-
-    var stack = [];
-    var preserveWhitespace = options.preserveWhitespace !== false;
-    var whitespaceOption = options.whitespace;
-    var root;
-    var currentParent;
-    var inVPre = false;
-    var inPre = false;
-    var warned = false;
-
-    function warnOnce (msg, range) {
-      if (!warned) {
-        warned = true;
-        warn$1(msg, range);
-      }
-    }
-
-    function closeElement (element) {
-      trimEndingWhitespace(element);
-      if (!inVPre && !element.processed) {
-        element = processElement(element, options);
-      }
-      // tree management
-      if (!stack.length && element !== root) {
-        // allow root elements with v-if, v-else-if and v-else
-        if (root.if && (element.elseif || element.else)) {
-          {
-            checkRootConstraints(element);
-          }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          });
-        } else {
-          warnOnce(
-            "Component template should contain exactly one root element. " +
-            "If you are using v-if on multiple elements, " +
-            "use v-else-if to chain them instead.",
-            { start: element.start }
-          );
-        }
-      }
-      if (currentParent && !element.forbidden) {
-        if (element.elseif || element.else) {
-          processIfConditions(element, currentParent);
-        } else {
-          if (element.slotScope) {
-            // scoped slot
-            // keep it in the children list so that v-else(-if) conditions can
-            // find it as the prev node.
-            var name = element.slotTarget || '"default"'
-            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-          }
-          currentParent.children.push(element);
-          element.parent = currentParent;
-        }
-      }
-
-      // final children cleanup
-      // filter out scoped slots
-      element.children = element.children.filter(function (c) { return !(c).slotScope; });
-      // remove trailing whitespace node again
-      trimEndingWhitespace(element);
-
-      // check pre state
-      if (element.pre) {
-        inVPre = false;
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false;
-      }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options);
-      }
-    }
-
-    function trimEndingWhitespace (el) {
-      // remove trailing whitespace node
-      if (!inPre) {
-        var lastNode;
-        while (
-          (lastNode = el.children[el.children.length - 1]) &&
-          lastNode.type === 3 &&
-          lastNode.text === ' '
-        ) {
-          el.children.pop();
-        }
-      }
-    }
-
-    function checkRootConstraints (el) {
-      if (el.tag === 'slot' || el.tag === 'template') {
-        warnOnce(
-          "Cannot use <" + (el.tag) + "> as component root element because it may " +
-          'contain multiple nodes.',
-          { start: el.start }
-        );
-      }
-      if (el.attrsMap.hasOwnProperty('v-for')) {
-        warnOnce(
-          'Cannot use v-for on stateful component root element because ' +
-          'it renders multiple elements.',
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-
-    parseHTML(template, {
-      warn: warn$1,
-      expectHTML: options.expectHTML,
-      isUnaryTag: options.isUnaryTag,
-      canBeLeftOpenTag: options.canBeLeftOpenTag,
-      shouldDecodeNewlines: options.shouldDecodeNewlines,
-      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-      shouldKeepComment: options.comments,
-      outputSourceRange: options.outputSourceRange,
-      start: function start (tag, attrs, unary, start$1, end) {
-        // check namespace.
-        // inherit parent ns if there is one
-        var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-        // handle IE svg bug
-        /* istanbul ignore if */
-        if (isIE && ns === 'svg') {
-          attrs = guardIESVGBug(attrs);
-        }
-
-        var element = createASTElement(tag, attrs, currentParent);
-        if (ns) {
-          element.ns = ns;
-        }
-
-        {
-          if (options.outputSourceRange) {
-            element.start = start$1;
-            element.end = end;
-            element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-              cumulated[attr.name] = attr;
-              return cumulated
-            }, {});
-          }
-          attrs.forEach(function (attr) {
-            if (invalidAttributeRE.test(attr.name)) {
-              warn$1(
-                "Invalid dynamic argument expression: attribute names cannot contain " +
-                "spaces, quotes, <, >, / or =.",
-                {
-                  start: attr.start + attr.name.indexOf("["),
-                  end: attr.start + attr.name.length
-                }
-              );
-            }
-          });
-        }
-
-        if (isForbiddenTag(element) && !isServerRendering()) {
-          element.forbidden = true;
-          warn$1(
-            'Templates should only be responsible for mapping the state to the ' +
-            'UI. Avoid placing tags with side-effects in your templates, such as ' +
-            "<" + tag + ">" + ', as they will not be parsed.',
-            { start: element.start }
-          );
-        }
-
-        // apply pre-transforms
-        for (var i = 0; i < preTransforms.length; i++) {
-          element = preTransforms[i](element, options) || element;
-        }
-
-        if (!inVPre) {
-          processPre(element);
-          if (element.pre) {
-            inVPre = true;
-          }
-        }
-        if (platformIsPreTag(element.tag)) {
-          inPre = true;
-        }
-        if (inVPre) {
-          processRawAttrs(element);
-        } else if (!element.processed) {
-          // structural directives
-          processFor(element);
-          processIf(element);
-          processOnce(element);
-        }
-
-        if (!root) {
-          root = element;
-          {
-            checkRootConstraints(root);
-          }
-        }
-
-        if (!unary) {
-          currentParent = element;
-          stack.push(element);
-        } else {
-          closeElement(element);
-        }
-      },
-
-      end: function end (tag, start, end$1) {
-        var element = stack[stack.length - 1];
-        // pop stack
-        stack.length -= 1;
-        currentParent = stack[stack.length - 1];
-        if (options.outputSourceRange) {
-          element.end = end$1;
-        }
-        closeElement(element);
-      },
-
-      chars: function chars (text, start, end) {
-        if (!currentParent) {
-          {
-            if (text === template) {
-              warnOnce(
-                'Component template requires a root element, rather than just text.',
-                { start: start }
-              );
-            } else if ((text = text.trim())) {
-              warnOnce(
-                ("text \"" + text + "\" outside root element will be ignored."),
-                { start: start }
-              );
-            }
-          }
-          return
-        }
-        // IE textarea placeholder bug
-        /* istanbul ignore if */
-        if (isIE &&
-          currentParent.tag === 'textarea' &&
-          currentParent.attrsMap.placeholder === text
-        ) {
-          return
-        }
-        var children = currentParent.children;
-        if (inPre || text.trim()) {
-          text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-        } else if (!children.length) {
-          // remove the whitespace-only node right after an opening tag
-          text = '';
-        } else if (whitespaceOption) {
-          if (whitespaceOption === 'condense') {
-            // in condense mode, remove the whitespace node if it contains
-            // line break, otherwise condense to a single space
-            text = lineBreakRE.test(text) ? '' : ' ';
-          } else {
-            text = ' ';
-          }
-        } else {
-          text = preserveWhitespace ? ' ' : '';
-        }
-        if (text) {
-          if (!inPre && whitespaceOption === 'condense') {
-            // condense consecutive whitespaces into single space
-            text = text.replace(whitespaceRE, ' ');
-          }
-          var res;
-          var child;
-          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-            child = {
-              type: 2,
-              expression: res.expression,
-              tokens: res.tokens,
-              text: text
-            };
-          } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-            child = {
-              type: 3,
-              text: text
-            };
-          }
-          if (child) {
-            if (options.outputSourceRange) {
-              child.start = start;
-              child.end = end;
-            }
-            children.push(child);
-          }
-        }
-      },
-      comment: function comment (text, start, end) {
-        // adding anything as a sibling to the root node is forbidden
-        // comments should still be allowed, but ignored
-        if (currentParent) {
-          var child = {
-            type: 3,
-            text: text,
-            isComment: true
-          };
-          if (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          currentParent.children.push(child);
-        }
-      }
-    });
-    return root
-  }
-
-  function processPre (el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true;
-    }
-  }
-
-  function processRawAttrs (el) {
-    var list = el.attrsList;
-    var len = list.length;
-    if (len) {
-      var attrs = el.attrs = new Array(len);
-      for (var i = 0; i < len; i++) {
-        attrs[i] = {
-          name: list[i].name,
-          value: JSON.stringify(list[i].value)
-        };
-        if (list[i].start != null) {
-          attrs[i].start = list[i].start;
-          attrs[i].end = list[i].end;
-        }
-      }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true;
-    }
-  }
-
-  function processElement (
-    element,
-    options
-  ) {
-    processKey(element);
-
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain = (
-      !element.key &&
-      !element.scopedSlots &&
-      !element.attrsList.length
-    );
-
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element
-  }
-
-  function processKey (el) {
-    var exp = getBindingAttr(el, 'key');
-    if (exp) {
-      {
-        if (el.tag === 'template') {
-          warn$1(
-            "<template> cannot be keyed. Place the key on real elements instead.",
-            getRawBindingAttr(el, 'key')
-          );
-        }
-        if (el.for) {
-          var iterator = el.iterator2 || el.iterator1;
-          var parent = el.parent;
-          if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-            warn$1(
-              "Do not use v-for index as key on <transition-group> children, " +
-              "this is the same as not using keys.",
-              getRawBindingAttr(el, 'key'),
-              true /* tip */
-            );
-          }
-        }
-      }
-      el.key = exp;
-    }
-  }
-
-  function processRef (el) {
-    var ref = getBindingAttr(el, 'ref');
-    if (ref) {
-      el.ref = ref;
-      el.refInFor = checkInFor(el);
-    }
-  }
-
-  function processFor (el) {
-    var exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp);
-      if (res) {
-        extend(el, res);
-      } else {
-        warn$1(
-          ("Invalid v-for expression: " + exp),
-          el.rawAttrsMap['v-for']
-        );
-      }
-    }
-  }
-
-
-
-  function parseFor (exp) {
-    var inMatch = exp.match(forAliasRE);
-    if (!inMatch) { return }
-    var res = {};
-    res.for = inMatch[2].trim();
-    var alias = inMatch[1].trim().replace(stripParensRE, '');
-    var iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-      res.alias = alias.replace(forIteratorRE, '').trim();
-      res.iterator1 = iteratorMatch[1].trim();
-      if (iteratorMatch[2]) {
-        res.iterator2 = iteratorMatch[2].trim();
-      }
-    } else {
-      res.alias = alias;
-    }
-    return res
-  }
-
-  function processIf (el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-      el.if = exp;
-      addIfCondition(el, {
-        exp: exp,
-        block: el
-      });
-    } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true;
-      }
-      var elseif = getAndRemoveAttr(el, 'v-else-if');
-      if (elseif) {
-        el.elseif = elseif;
-      }
-    }
-  }
-
-  function processIfConditions (el, parent) {
-    var prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-      addIfCondition(prev, {
-        exp: el.elseif,
-        block: el
-      });
-    } else {
-      warn$1(
-        "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-        "used on element <" + (el.tag) + "> without corresponding v-if.",
-        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-      );
-    }
-  }
-
-  function findPrevElement (children) {
-    var i = children.length;
-    while (i--) {
-      if (children[i].type === 1) {
-        return children[i]
-      } else {
-        if (children[i].text !== ' ') {
-          warn$1(
-            "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-            "will be ignored.",
-            children[i]
-          );
-        }
-        children.pop();
-      }
-    }
-  }
-
-  function addIfCondition (el, condition) {
-    if (!el.ifConditions) {
-      el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-  }
-
-  function processOnce (el) {
-    var once$$1 = getAndRemoveAttr(el, 'v-once');
-    if (once$$1 != null) {
-      el.once = true;
-    }
-  }
-
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent (el) {
-    var slotScope;
-    if (el.tag === 'template') {
-      slotScope = getAndRemoveAttr(el, 'scope');
-      /* istanbul ignore if */
-      if (slotScope) {
-        warn$1(
-          "the \"scope\" attribute for scoped slots have been deprecated and " +
-          "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-          "can also be used on plain elements in addition to <template> to " +
-          "denote scoped slots.",
-          el.rawAttrsMap['scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-      /* istanbul ignore if */
-      if (el.attrsMap['v-for']) {
-        warn$1(
-          "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-          "(v-for takes higher priority). Use a wrapper <template> for the " +
-          "scoped slot to make it clearer.",
-          el.rawAttrsMap['slot-scope'],
-          true
-        );
-      }
-      el.slotScope = slotScope;
-    }
-
-    // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-      el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-      // preserve slot as an attribute for native shadow DOM compat
-      // only for non-scoped slots.
-      if (el.tag !== 'template' && !el.slotScope) {
-        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-      }
-    }
-
-    // 2.6 v-slot syntax
-    {
-      if (el.tag === 'template') {
-        // v-slot on <template>
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding) {
-          {
-            if (el.slotTarget || el.slotScope) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.parent && !maybeComponent(el.parent)) {
-              warn$1(
-                "<template v-slot> can only appear at the root level inside " +
-                "the receiving component",
-                el
-              );
-            }
-          }
-          var ref = getSlotName(slotBinding);
-          var name = ref.name;
-          var dynamic = ref.dynamic;
-          el.slotTarget = name;
-          el.slotTargetDynamic = dynamic;
-          el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-        }
-      } else {
-        // v-slot on component, denotes default slot
-        var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-        if (slotBinding$1) {
-          {
-            if (!maybeComponent(el)) {
-              warn$1(
-                "v-slot can only be used on components or <template>.",
-                slotBinding$1
-              );
-            }
-            if (el.slotScope || el.slotTarget) {
-              warn$1(
-                "Unexpected mixed usage of different slot syntaxes.",
-                el
-              );
-            }
-            if (el.scopedSlots) {
-              warn$1(
-                "To avoid scope ambiguity, the default slot should also use " +
-                "<template> syntax when there are other named slots.",
-                slotBinding$1
-              );
-            }
-          }
-          // add the component's children to its default slot
-          var slots = el.scopedSlots || (el.scopedSlots = {});
-          var ref$1 = getSlotName(slotBinding$1);
-          var name$1 = ref$1.name;
-          var dynamic$1 = ref$1.dynamic;
-          var slotContainer = slots[name$1] = createASTElement('template', [], el);
-          slotContainer.slotTarget = name$1;
-          slotContainer.slotTargetDynamic = dynamic$1;
-          slotContainer.children = el.children.filter(function (c) {
-            if (!c.slotScope) {
-              c.parent = slotContainer;
-              return true
-            }
-          });
-          slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-          // remove children as they are returned from scopedSlots now
-          el.children = [];
-          // mark el non-plain so data gets generated
-          el.plain = false;
-        }
-      }
-    }
-  }
-
-  function getSlotName (binding) {
-    var name = binding.name.replace(slotRE, '');
-    if (!name) {
-      if (binding.name[0] !== '#') {
-        name = 'default';
-      } else {
-        warn$1(
-          "v-slot shorthand syntax requires a slot name.",
-          binding
-        );
-      }
-    }
-    return dynamicArgRE.test(name)
-      // dynamic [name]
-      ? { name: name.slice(1, -1), dynamic: true }
-      // static name
-      : { name: ("\"" + name + "\""), dynamic: false }
-  }
-
-  // handle <slot/> outlets
-  function processSlotOutlet (el) {
-    if (el.tag === 'slot') {
-      el.slotName = getBindingAttr(el, 'name');
-      if (el.key) {
-        warn$1(
-          "`key` does not work on <slot> because slots are abstract outlets " +
-          "and can possibly expand into multiple elements. " +
-          "Use the key on a wrapping element instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-    }
-  }
-
-  function processComponent (el) {
-    var binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true;
-    }
-  }
-
-  function processAttrs (el) {
-    var list = el.attrsList;
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-      name = rawName = list[i].name;
-      value = list[i].value;
-      if (dirRE.test(name)) {
-        // mark element as dynamic
-        el.hasBindings = true;
-        // modifiers
-        modifiers = parseModifiers(name.replace(dirRE, ''));
-        // support .foo shorthand syntax for the .prop modifier
-        if (modifiers) {
-          name = name.replace(modifierRE, '');
-        }
-        if (bindRE.test(name)) { // v-bind
-          name = name.replace(bindRE, '');
-          value = parseFilters(value);
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          if (
-            value.trim().length === 0
-          ) {
-            warn$1(
-              ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-            );
-          }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name);
-              if (name === 'innerHtml') { name = 'innerHTML'; }
-            }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name);
-            }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, "$event");
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  ("update:" + (camelize(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-                if (hyphenate(name) !== camelize(name)) {
-                  addHandler(
-                    el,
-                    ("update:" + (hyphenate(name))),
-                    syncGen,
-                    null,
-                    false,
-                    warn$1,
-                    list[i]
-                  );
-                }
-              } else {
-                // handler w/ dynamic event name
-                addHandler(
-                  el,
-                  ("\"update:\"+(" + name + ")"),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i],
-                  true // dynamic
-                );
-              }
-            }
-          }
-          if ((modifiers && modifiers.prop) || (
-            !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-          )) {
-            addProp(el, name, value, list[i], isDynamic);
-          } else {
-            addAttr(el, name, value, list[i], isDynamic);
-          }
-        } else if (onRE.test(name)) { // v-on
-          name = name.replace(onRE, '');
-          isDynamic = dynamicArgRE.test(name);
-          if (isDynamic) {
-            name = name.slice(1, -1);
-          }
-          addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-        } else { // normal directives
-          name = name.replace(dirRE, '');
-          // parse arg
-          var argMatch = name.match(argRE);
-          var arg = argMatch && argMatch[1];
-          isDynamic = false;
-          if (arg) {
-            name = name.slice(0, -(arg.length + 1));
-            if (dynamicArgRE.test(arg)) {
-              arg = arg.slice(1, -1);
-              isDynamic = true;
-            }
-          }
-          addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-          if (name === 'model') {
-            checkForAliasModel(el, value);
-          }
-        }
-      } else {
-        // literal attribute
-        {
-          var res = parseText(value, delimiters);
-          if (res) {
-            warn$1(
-              name + "=\"" + value + "\": " +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div id="{{ val }}">, use <div :id="val">.',
-              list[i]
-            );
-          }
-        }
-        addAttr(el, name, JSON.stringify(value), list[i]);
-        // #6887 firefox doesn't update muted state if set via attribute
-        // even immediately after element creation
-        if (!el.component &&
-            name === 'muted' &&
-            platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-          addProp(el, name, 'true', list[i]);
-        }
-      }
-    }
-  }
-
-  function checkInFor (el) {
-    var parent = el;
-    while (parent) {
-      if (parent.for !== undefined) {
-        return true
-      }
-      parent = parent.parent;
-    }
-    return false
-  }
-
-  function parseModifiers (name) {
-    var match = name.match(modifierRE);
-    if (match) {
-      var ret = {};
-      match.forEach(function (m) { ret[m.slice(1)] = true; });
-      return ret
-    }
-  }
-
-  function makeAttrsMap (attrs) {
-    var map = {};
-    for (var i = 0, l = attrs.length; i < l; i++) {
-      if (
-        map[attrs[i].name] && !isIE && !isEdge
-      ) {
-        warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-      }
-      map[attrs[i].name] = attrs[i].value;
-    }
-    return map
-  }
-
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag (el) {
-    return el.tag === 'script' || el.tag === 'style'
-  }
-
-  function isForbiddenTag (el) {
-    return (
-      el.tag === 'style' ||
-      (el.tag === 'script' && (
-        !el.attrsMap.type ||
-        el.attrsMap.type === 'text/javascript'
-      ))
-    )
-  }
-
-  var ieNSBug = /^xmlns:NS\d+/;
-  var ieNSPrefix = /^NS\d+:/;
-
-  /* istanbul ignore next */
-  function guardIESVGBug (attrs) {
-    var res = [];
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (!ieNSBug.test(attr.name)) {
-        attr.name = attr.name.replace(ieNSPrefix, '');
-        res.push(attr);
-      }
-    }
-    return res
-  }
-
-  function checkForAliasModel (el, value) {
-    var _el = el;
-    while (_el) {
-      if (_el.for && _el.alias === value) {
-        warn$1(
-          "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-          "You are binding v-model directly to a v-for iteration alias. " +
-          "This will not be able to modify the v-for source array because " +
-          "writing to the alias is like modifying a function local variable. " +
-          "Consider using an array of objects and use v-model on an object property instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-      _el = _el.parent;
-    }
-  }
-
-  /*  */
-
-  function preTransformNode (el, options) {
-    if (el.tag === 'input') {
-      var map = el.attrsMap;
-      if (!map['v-model']) {
-        return
-      }
-
-      var typeBinding;
-      if (map[':type'] || map['v-bind:type']) {
-        typeBinding = getBindingAttr(el, 'type');
-      }
-      if (!map.type && !typeBinding && map['v-bind']) {
-        typeBinding = "(" + (map['v-bind']) + ").type";
-      }
-
-      if (typeBinding) {
-        var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-        var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-        // 1. checkbox
-        var branch0 = cloneASTElement(el);
-        // process for on the main node
-        processFor(branch0);
-        addRawAttr(branch0, 'type', 'checkbox');
-        processElement(branch0, options);
-        branch0.processed = true; // prevent it from double-processed
-        branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-        addIfCondition(branch0, {
-          exp: branch0.if,
-          block: branch0
-        });
-        // 2. add radio else-if condition
-        var branch1 = cloneASTElement(el);
-        getAndRemoveAttr(branch1, 'v-for', true);
-        addRawAttr(branch1, 'type', 'radio');
-        processElement(branch1, options);
-        addIfCondition(branch0, {
-          exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-          block: branch1
-        });
-        // 3. other
-        var branch2 = cloneASTElement(el);
-        getAndRemoveAttr(branch2, 'v-for', true);
-        addRawAttr(branch2, ':type', typeBinding);
-        processElement(branch2, options);
-        addIfCondition(branch0, {
-          exp: ifCondition,
-          block: branch2
-        });
-
-        if (hasElse) {
-          branch0.else = true;
-        } else if (elseIfCondition) {
-          branch0.elseif = elseIfCondition;
-        }
-
-        return branch0
-      }
-    }
-  }
-
-  function cloneASTElement (el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
-  }
-
-  var model = {
-    preTransformNode: preTransformNode
-  };
-
-  var modules = [
-    klass,
-    style,
-    model
-  ];
-
-  /*  */
-
-  var warn$2;
-
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r';
-
-  function model$1 (
-    el,
-    dir,
-    _warn
-  ) {
-    warn$2 = _warn;
-    var value = dir.value;
-    var modifiers = dir.modifiers;
-    var tag = el.tag;
-    var type = el.attrsMap.type;
-
-    {
-      // inputs with type="file" are read only and setting the input's
-      // value will throw an error.
-      if (tag === 'input' && type === 'file') {
-        warn$2(
-          "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-          "File inputs are read only. Use a v-on:change listener instead.",
-          el.rawAttrsMap['v-model']
-        );
-      }
-    }
-
-    if (el.component) {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    } else if (tag === 'select') {
-      genSelect(el, value, modifiers);
-    } else if (tag === 'input' && type === 'checkbox') {
-      genCheckboxModel(el, value, modifiers);
-    } else if (tag === 'input' && type === 'radio') {
-      genRadioModel(el, value, modifiers);
-    } else if (tag === 'input' || tag === 'textarea') {
-      genDefaultModel(el, value, modifiers);
-    } else {
-      genComponentModel(el, value, modifiers);
-      // component v-model doesn't need extra runtime
-      return false
-    }
-
-    // ensure runtime directive metadata
-    return true
-  }
-
-  function genCheckboxModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked',
-      "Array.isArray(" + value + ")" +
-      "?_i(" + value + "," + valueBinding + ")>-1" + (
-        trueValueBinding === 'true'
-          ? (":(" + value + ")")
-          : (":_q(" + value + "," + trueValueBinding + ")")
-      )
-    );
-    addHandler(el, 'change',
-      "var $$a=" + value + "," +
-          '$$el=$event.target,' +
-          "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-      'if(Array.isArray($$a)){' +
-        "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-            '$$i=_i($$a,$$v);' +
-        "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-        "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-      "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-      null, true
-    );
-  }
-
-  function genRadioModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-    addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-
-  function genSelect (
-    el,
-    value,
-    modifiers
-  ) {
-    var number = modifiers && modifiers.number;
-    var selectedVal = "Array.prototype.filter" +
-      ".call($event.target.options,function(o){return o.selected})" +
-      ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-      "return " + (number ? '_n(val)' : 'val') + "})";
-
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    var code = "var $$selectedVal = " + selectedVal + ";";
-    code = code + " " + (genAssignmentCode(value, assignment));
-    addHandler(el, 'change', code, null, true);
-  }
-
-  function genDefaultModel (
-    el,
-    value,
-    modifiers
-  ) {
-    var type = el.attrsMap.type;
-
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-      var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-      if (value$1 && !typeBinding) {
-        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-        warn$2(
-          binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-          'because the latter already expands to a value binding internally',
-          el.rawAttrsMap[binding]
-        );
-      }
-    }
-
-    var ref = modifiers || {};
-    var lazy = ref.lazy;
-    var number = ref.number;
-    var trim = ref.trim;
-    var needCompositionGuard = !lazy && type !== 'range';
-    var event = lazy
-      ? 'change'
-      : type === 'range'
-        ? RANGE_TOKEN
-        : 'input';
-
-    var valueExpression = '$event.target.value';
-    if (trim) {
-      valueExpression = "$event.target.value.trim()";
-    }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
-    }
-
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-      code = "if($event.target.composing)return;" + code;
-    }
-
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()');
-    }
-  }
-
-  /*  */
-
-  function text (el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-    }
-  }
-
-  /*  */
-
-  function html (el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-    }
-  }
-
-  var directives = {
-    model: model$1,
-    text: text,
-    html: html
-  };
-
-  /*  */
-
-  var baseOptions = {
-    expectHTML: true,
-    modules: modules,
-    directives: directives,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    staticKeys: genStaticKeys(modules)
-  };
-
-  /*  */
-
-  var isStaticKey;
-  var isPlatformReservedTag;
-
-  var genStaticKeysCached = cached(genStaticKeys$1);
-
-  /**
-   * Goal of the optimizer: walk the generated template AST tree
-   * and detect sub-trees that are purely static, i.e. parts of
-   * the DOM that never needs to change.
-   *
-   * Once we detect these sub-trees, we can:
-   *
-   * 1. Hoist them into constants, so that we no longer need to
-   *    create fresh nodes for them on each re-render;
-   * 2. Completely skip them in the patching process.
-   */
-  function optimize (root, options) {
-    if (!root) { return }
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-  }
-
-  function genStaticKeys$1 (keys) {
-    return makeMap(
-      'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-      (keys ? ',' + keys : '')
-    )
-  }
-
-  function markStatic (node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-      // do not make component slot content static. this avoids
-      // 1. components not able to mutate slot nodes
-      // 2. static slot content fails for hot-reloading
-      if (
-        !isPlatformReservedTag(node.tag) &&
-        node.tag !== 'slot' &&
-        node.attrsMap['inline-template'] == null
-      ) {
-        return
-      }
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        markStatic(child);
-        if (!child.static) {
-          node.static = false;
-        }
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          markStatic(block);
-          if (!block.static) {
-            node.static = false;
-          }
-        }
-      }
-    }
-  }
-
-  function markStaticRoots (node, isInFor) {
-    if (node.type === 1) {
-      if (node.static || node.once) {
-        node.staticInFor = isInFor;
-      }
-      // For a node to qualify as a static root, it should have children that
-      // are not just static text. Otherwise the cost of hoisting out will
-      // outweigh the benefits and it's better off to just always render it fresh.
-      if (node.static && node.children.length && !(
-        node.children.length === 1 &&
-        node.children[0].type === 3
-      )) {
-        node.staticRoot = true;
-        return
-      } else {
-        node.staticRoot = false;
-      }
-      if (node.children) {
-        for (var i = 0, l = node.children.length; i < l; i++) {
-          markStaticRoots(node.children[i], isInFor || !!node.for);
-        }
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          markStaticRoots(node.ifConditions[i$1].block, isInFor);
-        }
-      }
-    }
-  }
-
-  function isStatic (node) {
-    if (node.type === 2) { // expression
-      return false
-    }
-    if (node.type === 3) { // text
-      return true
-    }
-    return !!(node.pre || (
-      !node.hasBindings && // no dynamic bindings
-      !node.if && !node.for && // not v-if or v-for or v-else
-      !isBuiltInTag(node.tag) && // not a built-in
-      isPlatformReservedTag(node.tag) && // not a component
-      !isDirectChildOfTemplateFor(node) &&
-      Object.keys(node).every(isStaticKey)
-    ))
-  }
-
-  function isDirectChildOfTemplateFor (node) {
-    while (node.parent) {
-      node = node.parent;
-      if (node.tag !== 'template') {
-        return false
-      }
-      if (node.for) {
-        return true
-      }
-    }
-    return false
-  }
-
-  /*  */
-
-  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  var fnInvokeRE = /\([^)]*?\);*$/;
-  var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
-  // KeyboardEvent.keyCode aliases
-  var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    'delete': [8, 46]
-  };
-
-  // KeyboardEvent.key aliases
-  var keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    'delete': ['Backspace', 'Delete', 'Del']
-  };
-
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
-  var modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard("$event.target !== $event.currentTarget"),
-    ctrl: genGuard("!$event.ctrlKey"),
-    shift: genGuard("!$event.shiftKey"),
-    alt: genGuard("!$event.altKey"),
-    meta: genGuard("!$event.metaKey"),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2")
-  };
-
-  function genHandlers (
-    events,
-    isNative
-  ) {
-    var prefix = isNative ? 'nativeOn:' : 'on:';
-    var staticHandlers = "";
-    var dynamicHandlers = "";
-    for (var name in events) {
-      var handlerCode = genHandler(events[name]);
-      if (events[name] && events[name].dynamic) {
-        dynamicHandlers += name + "," + handlerCode + ",";
-      } else {
-        staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-      }
-    }
-    staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-    if (dynamicHandlers) {
-      return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-    } else {
-      return prefix + staticHandlers
-    }
-  }
-
-  function genHandler (handler) {
-    if (!handler) {
-      return 'function(){}'
-    }
-
-    if (Array.isArray(handler)) {
-      return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-    }
-
-    var isMethodPath = simplePathRE.test(handler.value);
-    var isFunctionExpression = fnExpRE.test(handler.value);
-    var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-    if (!handler.modifiers) {
-      if (isMethodPath || isFunctionExpression) {
-        return handler.value
-      }
-      return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-    } else {
-      var code = '';
-      var genModifierCode = '';
-      var keys = [];
-      for (var key in handler.modifiers) {
-        if (modifierCode[key]) {
-          genModifierCode += modifierCode[key];
-          // left/right
-          if (keyCodes[key]) {
-            keys.push(key);
-          }
-        } else if (key === 'exact') {
-          var modifiers = (handler.modifiers);
-          genModifierCode += genGuard(
-            ['ctrl', 'shift', 'alt', 'meta']
-              .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-              .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-              .join('||')
-          );
-        } else {
-          keys.push(key);
-        }
-      }
-      if (keys.length) {
-        code += genKeyFilter(keys);
-      }
-      // Make sure modifiers like prevent and stop get executed after key filtering
-      if (genModifierCode) {
-        code += genModifierCode;
-      }
-      var handlerCode = isMethodPath
-        ? ("return " + (handler.value) + ".apply(null, arguments)")
-        : isFunctionExpression
-          ? ("return (" + (handler.value) + ").apply(null, arguments)")
-          : isFunctionInvocation
-            ? ("return " + (handler.value))
-            : handler.value;
-      return ("function($event){" + code + handlerCode + "}")
-    }
-  }
-
-  function genKeyFilter (keys) {
-    return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      "if(!$event.type.indexOf('key')&&" +
-      (keys.map(genFilterCode).join('&&')) + ")return null;"
-    )
-  }
-
-  function genFilterCode (key) {
-    var keyVal = parseInt(key, 10);
-    if (keyVal) {
-      return ("$event.keyCode!==" + keyVal)
-    }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return (
-      "_k($event.keyCode," +
-      (JSON.stringify(key)) + "," +
-      (JSON.stringify(keyCode)) + "," +
-      "$event.key," +
-      "" + (JSON.stringify(keyName)) +
-      ")"
-    )
-  }
-
-  /*  */
-
-  function on (el, dir) {
-    if (dir.modifiers) {
-      warn("v-on without argument does not support modifiers.");
-    }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
-  }
-
-  /*  */
-
-  function bind$1 (el, dir) {
-    el.wrapData = function (code) {
-      return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-    };
-  }
-
-  /*  */
-
-  var baseDirectives = {
-    on: on,
-    bind: bind$1,
-    cloak: noop
-  };
-
-  /*  */
-
-
-
-
-
-  var CodegenState = function CodegenState (options) {
-    this.options = options;
-    this.warn = options.warn || baseWarn;
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-    this.directives = extend(extend({}, baseDirectives), options.directives);
-    var isReservedTag = options.isReservedTag || no;
-    this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-    this.onceId = 0;
-    this.staticRenderFns = [];
-    this.pre = false;
-  };
-
-
-
-  function generate (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    var code = ast ? (ast.tag === 'script' ? 'null' : genElement(ast, state)) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genElement (el, state) {
-    if (el.parent) {
-      el.pre = el.pre || el.parent.pre;
-    }
-
-    if (el.staticRoot && !el.staticProcessed) {
-      return genStatic(el, state)
-    } else if (el.once && !el.onceProcessed) {
-      return genOnce(el, state)
-    } else if (el.for && !el.forProcessed) {
-      return genFor(el, state)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-      return genChildren(el, state) || 'void 0'
-    } else if (el.tag === 'slot') {
-      return genSlot(el, state)
-    } else {
-      // component or element
-      var code;
-      if (el.component) {
-        code = genComponent(el.component, el, state);
-      } else {
-        var data;
-        if (!el.plain || (el.pre && state.maybeComponent(el))) {
-          data = genData$2(el, state);
-        }
-
-        var children = el.inlineTemplate ? null : genChildren(el, state, true);
-        code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
-      }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code);
-      }
-      return code
-    }
-  }
-
-  // hoist static sub-trees out
-  function genStatic (el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre;
-    if (el.pre) {
-      state.pre = el.pre;
-    }
-    state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-    state.pre = originalPreState;
-    return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
-  }
-
-  // v-once
-  function genOnce (el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.staticInFor) {
-      var key = '';
-      var parent = el.parent;
-      while (parent) {
-        if (parent.for) {
-          key = parent.key;
-          break
-        }
-        parent = parent.parent;
-      }
-      if (!key) {
-        state.warn(
-          "v-once can only be used inside v-for that is keyed. ",
-          el.rawAttrsMap['v-once']
-        );
-        return genElement(el, state)
-      }
-      return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-    } else {
-      return genStatic(el, state)
-    }
-  }
-
-  function genIf (
-    el,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-  }
-
-  function genIfConditions (
-    conditions,
-    state,
-    altGen,
-    altEmpty
-  ) {
-    if (!conditions.length) {
-      return altEmpty || '_e()'
-    }
-
-    var condition = conditions.shift();
-    if (condition.exp) {
-      return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-    } else {
-      return ("" + (genTernaryExp(condition.block)))
-    }
-
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp (el) {
-      return altGen
-        ? altGen(el, state)
-        : el.once
-          ? genOnce(el, state)
-          : genElement(el, state)
-    }
-  }
-
-  function genFor (
-    el,
-    state,
-    altGen,
-    altHelper
-  ) {
-    var exp = el.for;
-    var alias = el.alias;
-    var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-    var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-    if (state.maybeComponent(el) &&
-      el.tag !== 'slot' &&
-      el.tag !== 'template' &&
-      !el.key
-    ) {
-      state.warn(
-        "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-        "v-for should have explicit keys. " +
-        "See https://vuejs.org/guide/list.html#key for more info.",
-        el.rawAttrsMap['v-for'],
-        true /* tip */
-      );
-    }
-
-    el.forProcessed = true; // avoid recursion
-    return (altHelper || '_l') + "((" + exp + ")," +
-      "function(" + alias + iterator1 + iterator2 + "){" +
-        "return " + ((altGen || genElement)(el, state)) +
-      '})'
-  }
-
-  function genData$2 (el, state) {
-    var data = '{';
-
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state);
-    if (dirs) { data += dirs + ','; }
-
-    // key
-    if (el.key) {
-      data += "key:" + (el.key) + ",";
-    }
-    // ref
-    if (el.ref) {
-      data += "ref:" + (el.ref) + ",";
-    }
-    if (el.refInFor) {
-      data += "refInFor:true,";
-    }
-    // pre
-    if (el.pre) {
-      data += "pre:true,";
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-      data += "tag:\"" + (el.tag) + "\",";
-    }
-    // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
-      data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-      data += "attrs:" + (genProps(el.attrs)) + ",";
-    }
-    // DOM props
-    if (el.props) {
-      data += "domProps:" + (genProps(el.props)) + ",";
-    }
-    // event handlers
-    if (el.events) {
-      data += (genHandlers(el.events, false)) + ",";
-    }
-    if (el.nativeEvents) {
-      data += (genHandlers(el.nativeEvents, true)) + ",";
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-      data += "slot:" + (el.slotTarget) + ",";
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-      data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-    }
-    // component v-model
-    if (el.model) {
-      data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-      var inlineTemplate = genInlineTemplate(el, state);
-      if (inlineTemplate) {
-        data += inlineTemplate + ",";
-      }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-      data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data);
-    }
-    return data
-  }
-
-  function genDirectives (el, state) {
-    var dirs = el.directives;
-    if (!dirs) { return }
-    var res = 'directives:[';
-    var hasRuntime = false;
-    var i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-      dir = dirs[i];
-      needRuntime = true;
-      var gen = state.directives[dir.name];
-      if (gen) {
-        // compile-time directive that manipulates AST.
-        // returns true if it also needs a runtime counterpart.
-        needRuntime = !!gen(el, dir, state.warn);
-      }
-      if (needRuntime) {
-        hasRuntime = true;
-        res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-      }
-    }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
-  }
-
-  function genInlineTemplate (el, state) {
-    var ast = el.children[0];
-    if (el.children.length !== 1 || ast.type !== 1) {
-      state.warn(
-        'Inline-template components must have exactly one child element.',
-        { start: el.start }
-      );
-    }
-    if (ast && ast.type === 1) {
-      var inlineRenderFns = generate(ast, state.options);
-      return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-    }
-  }
-
-  function genScopedSlots (
-    el,
-    slots,
-    state
-  ) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-      var slot = slots[key];
-      return (
-        slot.slotTargetDynamic ||
-        slot.if ||
-        slot.for ||
-        containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-      )
-    });
-
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    var needsKey = !!el.if;
-
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-      var parent = el.parent;
-      while (parent) {
-        if (
-          (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-          parent.for
-        ) {
-          needsForceUpdate = true;
-          break
-        }
-        if (parent.if) {
-          needsKey = true;
-        }
-        parent = parent.parent;
-      }
-    }
-
-    var generatedSlots = Object.keys(slots)
-      .map(function (key) { return genScopedSlot(slots[key], state); })
-      .join(',');
-
-    return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
-  }
-
-  function hash(str) {
-    var hash = 5381;
-    var i = str.length;
-    while(i) {
-      hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0
-  }
-
-  function containsSlotChild (el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
-      }
-      return el.children.some(containsSlotChild)
-    }
-    return false
-  }
-
-  function genScopedSlot (
-    el,
-    state
-  ) {
-    var isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-      return genIf(el, state, genScopedSlot, "null")
-    }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
-    }
-    var slotScope = el.slotScope === emptySlotScopeToken
-      ? ""
-      : String(el.slotScope);
-    var fn = "function(" + slotScope + "){" +
-      "return " + (el.tag === 'template'
-        ? el.if && isLegacySyntax
-          ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-          : genChildren(el, state) || 'undefined'
-        : genElement(el, state)) + "}";
-    // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? "" : ",proxy:true";
-    return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-  }
-
-  function genChildren (
-    el,
-    state,
-    checkSkip,
-    altGenElement,
-    altGenNode
-  ) {
-    var children = el.children;
-    if (children.length) {
-      var el$1 = children[0];
-      // optimize single v-for
-      if (children.length === 1 &&
-        el$1.for &&
-        el$1.tag !== 'template' &&
-        el$1.tag !== 'slot'
-      ) {
-        var normalizationType = checkSkip
-          ? state.maybeComponent(el$1) ? ",1" : ",0"
-          : "";
-        return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-      }
-      var normalizationType$1 = checkSkip
-        ? getNormalizationType(children, state.maybeComponent)
-        : 0;
-      var gen = altGenNode || genNode;
-      return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-    }
-  }
-
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType (
-    children,
-    maybeComponent
-  ) {
-    var res = 0;
-    for (var i = 0; i < children.length; i++) {
-      var el = children[i];
-      if (el.type !== 1) {
-        continue
-      }
-      if (needsNormalization(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-        res = 2;
-        break
-      }
-      if (maybeComponent(el) ||
-          (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-        res = 1;
-      }
-    }
-    return res
-  }
-
-  function needsNormalization (el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-  }
-
-  function genNode (node, state) {
-    if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
-    }
-  }
-
-  function genText (text) {
-    return ("_v(" + (text.type === 2
-      ? text.expression // no need for () because already wrapped in _s()
-      : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-  }
-
-  function genComment (comment) {
-    return ("_e(" + (JSON.stringify(comment.text)) + ")")
-  }
-
-  function genSlot (el, state) {
-    var slotName = el.slotName || '"default"';
-    var children = genChildren(el, state);
-    var res = "_t(" + slotName + (children ? (",function(){return " + children + "}") : '');
-    var attrs = el.attrs || el.dynamicAttrs
-      ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-          // slot props are camelized
-          name: camelize(attr.name),
-          value: attr.value,
-          dynamic: attr.dynamic
-        }); }))
-      : null;
-    var bind$$1 = el.attrsMap['v-bind'];
-    if ((attrs || bind$$1) && !children) {
-      res += ",null";
-    }
-    if (attrs) {
-      res += "," + attrs;
-    }
-    if (bind$$1) {
-      res += (attrs ? '' : ',null') + "," + bind$$1;
-    }
-    return res + ')'
-  }
-
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent (
-    componentName,
-    el,
-    state
-  ) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-  }
-
-  function genProps (props) {
-    var staticProps = "";
-    var dynamicProps = "";
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      var value = transformSpecialNewlines(prop.value);
-      if (prop.dynamic) {
-        dynamicProps += (prop.name) + "," + value + ",";
-      } else {
-        staticProps += "\"" + (prop.name) + "\":" + value + ",";
-      }
-    }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-    if (dynamicProps) {
-      return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-    } else {
-      return staticProps
-    }
-  }
-
-  // #3895, #4268
-  function transformSpecialNewlines (text) {
-    return text
-      .replace(/\u2028/g, '\\u2028')
-      .replace(/\u2029/g, '\\u2029')
-  }
-
-  /*  */
-
-
-
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp('\\b' + (
-    'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-    'super,throw,while,yield,delete,export,import,return,switch,default,' +
-    'extends,finally,continue,debugger,function,arguments'
-  ).split(',').join('\\b|\\b') + '\\b');
-
-  // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp('\\b' + (
-    'delete,typeof,void'
-  ).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
-  // strip strings in expressions
-  var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
-  // detect problematic expressions in a template
-  function detectErrors (ast, warn) {
-    if (ast) {
-      checkNode(ast, warn);
-    }
-  }
-
-  function checkNode (node, warn) {
-    if (node.type === 1) {
-      for (var name in node.attrsMap) {
-        if (dirRE.test(name)) {
-          var value = node.attrsMap[name];
-          if (value) {
-            var range = node.rawAttrsMap[name];
-            if (name === 'v-for') {
-              checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-            } else if (name === 'v-slot' || name[0] === '#') {
-              checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-            } else if (onRE.test(name)) {
-              checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-            } else {
-              checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-            }
-          }
-        }
-      }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn);
-        }
-      }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node);
-    }
-  }
-
-  function checkEvent (exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '');
-    var keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        "avoid using JavaScript unary operator as property name: " +
-        "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-        range
-      );
-    }
-    checkExpression(exp, text, warn, range);
-  }
-
-  function checkFor (node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-  }
-
-  function checkIdentifier (
-    ident,
-    type,
-    text,
-    warn,
-    range
-  ) {
-    if (typeof ident === 'string') {
-      try {
-        new Function(("var " + ident + "=_"));
-      } catch (e) {
-        warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-      }
-    }
-  }
-
-  function checkExpression (exp, text, warn, range) {
-    try {
-      new Function(("return " + exp));
-    } catch (e) {
-      var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-      if (keywordMatch) {
-        warn(
-          "avoid using JavaScript keyword as property name: " +
-          "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-          range
-        );
-      } else {
-        warn(
-          "invalid expression: " + (e.message) + " in\n\n" +
-          "    " + exp + "\n\n" +
-          "  Raw expression: " + (text.trim()) + "\n",
-          range
-        );
-      }
-    }
-  }
-
-  function checkFunctionParameterExpression (exp, text, warn, range) {
-    try {
-      new Function(exp, '');
-    } catch (e) {
-      warn(
-        "invalid function parameter expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-
-  /*  */
-
-  var range = 2;
-
-  function generateCodeFrame (
-    source,
-    start,
-    end
-  ) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
-
-    var lines = source.split(/\r?\n/);
-    var count = 0;
-    var res = [];
-    for (var i = 0; i < lines.length; i++) {
-      count += lines[i].length + 1;
-      if (count >= start) {
-        for (var j = i - range; j <= i + range || end > count; j++) {
-          if (j < 0 || j >= lines.length) { continue }
-          res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-          var lineLength = lines[j].length;
-          if (j === i) {
-            // push underline
-            var pad = start - (count - lineLength) + 1;
-            var length = end > count ? lineLength - pad : end - start;
-            res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-          } else if (j > i) {
-            if (end > count) {
-              var length$1 = Math.min(end - count, lineLength);
-              res.push("   |  " + repeat$1("^", length$1));
-            }
-            count += lineLength + 1;
-          }
-        }
-        break
-      }
-    }
-    return res.join('\n')
-  }
-
-  function repeat$1 (str, n) {
-    var result = '';
-    if (n > 0) {
-      while (true) { // eslint-disable-line
-        if (n & 1) { result += str; }
-        n >>>= 1;
-        if (n <= 0) { break }
-        str += str;
-      }
-    }
-    return result
-  }
-
-  /*  */
-
-
-
-  function createFunction (code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code });
-      return noop
-    }
-  }
-
-  function createCompileToFunctionFn (compile) {
-    var cache = Object.create(null);
-
-    return function compileToFunctions (
-      template,
-      options,
-      vm
-    ) {
-      options = extend({}, options);
-      var warn$$1 = options.warn || warn;
-      delete options.warn;
-
-      /* istanbul ignore if */
-      {
-        // detect possible CSP restriction
-        try {
-          new Function('return 1');
-        } catch (e) {
-          if (e.toString().match(/unsafe-eval|CSP/)) {
-            warn$$1(
-              'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-            );
-          }
-        }
-      }
-
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template;
-      if (cache[key]) {
-        return cache[key]
-      }
-
-      // compile
-      var compiled = compile(template, options);
-
-      // check compilation errors/tips
-      {
-        if (compiled.errors && compiled.errors.length) {
-          if (options.outputSourceRange) {
-            compiled.errors.forEach(function (e) {
-              warn$$1(
-                "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-                generateCodeFrame(template, e.start, e.end),
-                vm
-              );
-            });
-          } else {
-            warn$$1(
-              "Error compiling template:\n\n" + template + "\n\n" +
-              compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-              vm
-            );
-          }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-          } else {
-            compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-          }
-        }
-      }
-
-      // turn code into functions
-      var res = {};
-      var fnGenErrors = [];
-      res.render = createFunction(compiled.render, fnGenErrors);
-      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-        return createFunction(code, fnGenErrors)
-      });
-
-      // check function generation errors.
-      // this should only happen if there is a bug in the compiler itself.
-      // mostly for codegen development use
-      /* istanbul ignore if */
-      {
-        if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-          warn$$1(
-            "Failed to generate render function:\n\n" +
-            fnGenErrors.map(function (ref) {
-              var err = ref.err;
-              var code = ref.code;
-
-              return ((err.toString()) + " in\n\n" + code + "\n");
-          }).join('\n'),
-            vm
-          );
-        }
-      }
-
-      return (cache[key] = res)
-    }
-  }
-
-  /*  */
-
-  function createCompilerCreator (baseCompile) {
-    return function createCompiler (baseOptions) {
-      function compile (
-        template,
-        options
-      ) {
-        var finalOptions = Object.create(baseOptions);
-        var errors = [];
-        var tips = [];
-
-        var warn = function (msg, range, tip) {
-          (tip ? tips : errors).push(msg);
-        };
-
-        if (options) {
-          if (options.outputSourceRange) {
-            // $flow-disable-line
-            var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-            warn = function (msg, range, tip) {
-              var data = { msg: msg };
-              if (range) {
-                if (range.start != null) {
-                  data.start = range.start + leadingSpaceLength;
-                }
-                if (range.end != null) {
-                  data.end = range.end + leadingSpaceLength;
-                }
-              }
-              (tip ? tips : errors).push(data);
-            };
-          }
-          // merge custom modules
-          if (options.modules) {
-            finalOptions.modules =
-              (baseOptions.modules || []).concat(options.modules);
-          }
-          // merge custom directives
-          if (options.directives) {
-            finalOptions.directives = extend(
-              Object.create(baseOptions.directives || null),
-              options.directives
-            );
-          }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key];
-            }
-          }
-        }
-
-        finalOptions.warn = warn;
-
-        var compiled = baseCompile(template.trim(), finalOptions);
-        {
-          detectErrors(compiled.ast, warn);
-        }
-        compiled.errors = errors;
-        compiled.tips = tips;
-        return compiled
-      }
-
-      return {
-        compile: compile,
-        compileToFunctions: createCompileToFunctionFn(compile)
-      }
-    }
-  }
-
-  /*  */
-
-  // `createCompilerCreator` allows creating compilers that use alternative
-  // parser/optimizer/codegen, e.g the SSR optimizing compiler.
-  // Here we just export a default compiler using the default parts.
-  var createCompiler = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-      optimize(ast, options);
-    }
-    var code = generate(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
-  });
-
-  /*  */
-
-  var ref = createCompiler(baseOptions);
-  var compile = ref.compile;
-  var compileToFunctions = ref.compileToFunctions;
-
-  /*  */
-
-  var isAttr = makeMap(
-    'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap'
-  );
-
-  /* istanbul ignore next */
-  var isRenderableAttr = function (name) {
-    return (
-      isAttr(name) ||
-      name.indexOf('data-') === 0 ||
-      name.indexOf('aria-') === 0
-    )
-  };
-
-  var propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv'
-  };
-
-  var ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;'
-  };
-
-  function escape (s) {
-    return s.replace(/[<>"&]/g, escapeChar)
-  }
-
-  function escapeChar (a) {
-    return ESC[a] || a
-  }
-
-  /*  */
-
-
-
-
-  var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
-  // let the model AST transform translate v-model into appropriate
-  // props bindings
-  function applyModelTransform (el, state) {
-    if (el.directives) {
-      for (var i = 0; i < el.directives.length; i++) {
-        var dir = el.directives[i];
-        if (dir.name === 'model') {
-          state.directives.model(el, dir, state.warn);
-          // remove value for textarea as its converted to text
-          if (el.tag === 'textarea' && el.props) {
-            el.props = el.props.filter(function (p) { return p.name !== 'value'; });
-          }
-          break
-        }
-      }
-    }
-  }
-
-  function genAttrSegments (
-    attrs
-  ) {
-    return attrs.map(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      return genAttrSegment(name, value);
-    })
-  }
-
-  function genDOMPropSegments (
-    props,
-    attrs
-  ) {
-    var segments = [];
-    props.forEach(function (ref) {
-      var name = ref.name;
-      var value = ref.value;
-
-      name = propsToAttrMap[name] || name.toLowerCase();
-      if (isRenderableAttr(name) &&
-        !(attrs && attrs.some(function (a) { return a.name === name; }))
-      ) {
-        segments.push(genAttrSegment(name, value));
-      }
-    });
-    return segments
-  }
-
-  function genAttrSegment (name, value) {
-    if (plainStringRE.test(value)) {
-      // force double quote
-      value = value.replace(/^'|'$/g, '"');
-      // force enumerated attr to "true"
-      if (isEnumeratedAttr(name) && value !== "\"false\"") {
-        value = "\"true\"";
-      }
-      return {
-        type: RAW,
-        value: isBooleanAttr(name)
-          ? (" " + name + "=\"" + name + "\"")
-          : value === '""'
-            ? (" " + name)
-            : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-      }
-    } else {
-      return {
-        type: EXPRESSION,
-        value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
-      }
-    }
-  }
-
-  function genClassSegments (
-    staticClass,
-    classBinding
-  ) {
-    if (staticClass && !classBinding) {
-      return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-      }]
-    }
-  }
-
-  function genStyleSegments (
-    staticStyle,
-    parsedStaticStyle,
-    styleBinding,
-    vShowExpression
-  ) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-      return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-    } else {
-      return [{
-        type: EXPRESSION,
-        value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-            ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-            : 'null') + ")")
-      }]
-    }
-  }
-
-  /*  */
-
-  // optimizability constants
-  var optimizability = {
-    FALSE: 0,    // whole sub tree un-optimizable
-    FULL: 1,     // whole sub tree optimizable
-    SELF: 2,     // self optimizable but has some un-optimizable children
-    CHILDREN: 3, // self un-optimizable but have fully optimizable children
-    PARTIAL: 4   // self un-optimizable with some un-optimizable children
-  };
-
-  var isPlatformReservedTag$1;
-
-  function optimize$1 (root, options) {
-    if (!root) { return }
-    isPlatformReservedTag$1 = options.isReservedTag || no;
-    walk(root, true);
-  }
-
-  function walk (node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-      node.ssrOptimizability = optimizability.FALSE;
-      return
-    }
-    // root node or nodes with custom directives should always be a VNode
-    var selfUnoptimizable = isRoot || hasCustomDirective(node);
-    var check = function (child) {
-      if (child.ssrOptimizability !== optimizability.FULL) {
-        node.ssrOptimizability = selfUnoptimizable
-          ? optimizability.PARTIAL
-          : optimizability.SELF;
-      }
-    };
-    if (selfUnoptimizable) {
-      node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i];
-        walk(child);
-        check(child);
-      }
-      if (node.ifConditions) {
-        for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-          var block = node.ifConditions[i$1].block;
-          walk(block, isRoot);
-          check(block);
-        }
-      }
-      if (node.ssrOptimizability == null ||
-        (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-      ) {
-        node.ssrOptimizability = optimizability.FULL;
-      } else {
-        node.children = optimizeSiblings(node);
-      }
-    } else {
-      node.ssrOptimizability = optimizability.FULL;
-    }
-  }
-
-  function optimizeSiblings (el) {
-    var children = el.children;
-    var optimizedChildren = [];
-
-    var currentOptimizableGroup = [];
-    var pushGroup = function () {
-      if (currentOptimizableGroup.length) {
-        optimizedChildren.push({
-          type: 1,
-          parent: el,
-          tag: 'template',
-          attrsList: [],
-          attrsMap: {},
-          rawAttrsMap: {},
-          children: currentOptimizableGroup,
-          ssrOptimizability: optimizability.FULL
-        });
-      }
-      currentOptimizableGroup = [];
-    };
-
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.ssrOptimizability === optimizability.FULL) {
-        currentOptimizableGroup.push(c);
-      } else {
-        // wrap fully-optimizable adjacent siblings inside a template tag
-        // so that they can be optimized into a single ssrNode by codegen
-        pushGroup();
-        optimizedChildren.push(c);
-      }
-    }
-    pushGroup();
-    return optimizedChildren
-  }
-
-  function isUnOptimizableTree (node) {
-    if (node.type === 2 || node.type === 3) { // text or expression
-      return false
-    }
-    return (
-      isBuiltInTag(node.tag) || // built-in (slot, component)
-      !isPlatformReservedTag$1(node.tag) || // custom component
-      !!node.component || // "is" component
-      isSelectWithModel(node) // <select v-model> requires runtime inspection
-    )
-  }
-
-  var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-  function hasCustomDirective (node) {
-    return (
-      node.type === 1 &&
-      node.directives &&
-      node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-    )
-  }
-
-  // <select v-model> cannot be optimized because it requires a runtime check
-  // to determine proper selected option
-  function isSelectWithModel (node) {
-    return (
-      node.type === 1 &&
-      node.tag === 'select' &&
-      node.directives != null &&
-      node.directives.some(function (d) { return d.name === 'model'; })
-    )
-  }
-
-  /*  */
-
-
-
-
-  // segment types
-  var RAW = 0;
-  var INTERPOLATION = 1;
-  var EXPRESSION = 2;
-
-  function generate$1 (
-    ast,
-    options
-  ) {
-    var state = new CodegenState(options);
-    var code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-      render: ("with(this){return " + code + "}"),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-
-  function genSSRElement (el, state) {
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genSSRElement)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state, genSSRElement)
-    } else if (el.tag === 'template' && !el.slotTarget) {
-      return el.ssrOptimizability === optimizability.FULL
-        ? genChildrenAsStringNode(el, state)
-        : genSSRChildren(el, state) || 'void 0'
-    }
-
-    switch (el.ssrOptimizability) {
-      case optimizability.FULL:
-        // stringify whole tree
-        return genStringElement(el, state)
-      case optimizability.SELF:
-        // stringify self and check children
-        return genStringElementWithChildren(el, state)
-      case optimizability.CHILDREN:
-        // generate self as VNode and stringify children
-        return genNormalElement(el, state, true)
-      case optimizability.PARTIAL:
-        // generate self as VNode and check children
-        return genNormalElement(el, state, false)
-      default:
-        // bail whole tree
-        return genElement(el, state)
-    }
-  }
-
-  function genNormalElement (el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData$2(el, state);
-    var children = stringifyChildren
-      ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-      : genSSRChildren(el, state, true);
-    return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-  }
-
-  function genSSRChildren (el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-  }
-
-  function genSSRNode (el, state) {
-    return el.type === 1
-      ? genSSRElement(el, state)
-      : genText(el)
-  }
-
-  function genChildrenAsStringNode (el, state) {
-    return el.children.length
-      ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-      : ''
-  }
-
-  function genStringElement (el, state) {
-    return ("_ssrNode(" + (elementToString(el, state)) + ")")
-  }
-
-  function genStringElementWithChildren (el, state) {
-    var children = genSSRChildren(el, state, true);
-    return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-  }
-
-  function elementToString (el, state) {
-    return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-  }
-
-  function elementToSegments (el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-      el.forProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genFor(el, state, elementToString, '_ssrList')
-      }]
-    } else if (el.if && !el.ifProcessed) {
-      el.ifProcessed = true;
-      return [{
-        type: EXPRESSION,
-        value: genIf(el, state, elementToString, '"<!---->"')
-      }]
-    } else if (el.tag === 'template') {
-      return childrenToSegments(el, state)
-    }
-
-    var openSegments = elementToOpenTagSegments(el, state);
-    var childrenSegments = childrenToSegments(el, state);
-    var ref = state.options;
-    var isUnaryTag = ref.isUnaryTag;
-    var close = (isUnaryTag && isUnaryTag(el.tag))
-      ? []
-      : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-    return openSegments.concat(childrenSegments, close)
-  }
-
-  function elementToOpenTagSegments (el, state) {
-    applyModelTransform(el, state);
-    var binding;
-    var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-    // attrs
-    if (el.attrs) {
-      segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-      segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-      segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-      segments.push.apply(
-        segments,
-        genClassSegments(el.staticClass, el.classBinding)
-      );
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-      segments.push.apply(
-        segments,
-        genStyleSegments(
-          el.attrsMap.style,
-          el.staticStyle,
-          el.styleBinding,
-          el.attrsMap['v-show']
-        )
-      );
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-      segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-    }
-    segments.push({ type: RAW, value: ">" });
-    return segments
-  }
-
-  function childrenToSegments (el, state) {
-    var binding;
-    if ((binding = el.attrsMap['v-html'])) {
-      return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-      return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-    }
-    return el.children
-      ? nodesToSegments(el.children, state)
-      : []
-  }
-
-  function nodesToSegments (
-    children,
-    state
-  ) {
-    var segments = [];
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i];
-      if (c.type === 1) {
-        segments.push.apply(segments, elementToSegments(c, state));
-      } else if (c.type === 2) {
-        segments.push({ type: INTERPOLATION, value: c.expression });
-      } else if (c.type === 3) {
-        var text = escape(c.text);
-        if (c.isComment) {
-          text = '<!--' + text + '-->';
-        }
-        segments.push({ type: RAW, value: text });
-      }
-    }
-    return segments
-  }
-
-  function flattenSegments (segments) {
-    var mergedSegments = [];
-    var textBuffer = '';
-
-    var pushBuffer = function () {
-      if (textBuffer) {
-        mergedSegments.push(JSON.stringify(textBuffer));
-        textBuffer = '';
-      }
-    };
-
-    for (var i = 0; i < segments.length; i++) {
-      var s = segments[i];
-      if (s.type === RAW) {
-        textBuffer += s.value;
-      } else if (s.type === INTERPOLATION) {
-        pushBuffer();
-        mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-      } else if (s.type === EXPRESSION) {
-        pushBuffer();
-        mergedSegments.push(("(" + (s.value) + ")"));
-      }
-    }
-    pushBuffer();
-
-    return mergedSegments.join('+')
-  }
-
-  /*  */
-
-  var createCompiler$1 = createCompilerCreator(function baseCompile (
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options);
-    optimize$1(ast, options);
-    var code = generate$1(ast, options);
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
-  });
-
-  /*  */
-
-  var ref$1 = createCompiler$1(baseOptions);
-  var compile$1 = ref$1.compile;
-  var compileToFunctions$1 = ref$1.compileToFunctions;
-
-  /*  */
-
-  exports.parseComponent = parseComponent;
-  exports.compile = compile;
-  exports.compileToFunctions = compileToFunctions;
-  exports.ssrCompile = compile$1;
-  exports.ssrCompileToFunctions = compileToFunctions$1;
-  exports.generateCodeFrame = generateCodeFrame;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VueTemplateCompiler = {}));
+})(this, (function (exports) { 'use strict';
+
+	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+	var splitRE$1 = /\r?\n/g;
+	var emptyRE = /^\s*$/;
+	var needFixRE = /^(\r?\n)*[\t\s]/;
+
+	var deIndent = function deindent (str) {
+	  if (!needFixRE.test(str)) {
+	    return str
+	  }
+	  var lines = str.split(splitRE$1);
+	  var min = Infinity;
+	  var type, cur, c;
+	  for (var i = 0; i < lines.length; i++) {
+	    var line = lines[i];
+	    if (!emptyRE.test(line)) {
+	      if (!type) {
+	        c = line.charAt(0);
+	        if (c === ' ' || c === '\t') {
+	          type = c;
+	          cur = count(line, type);
+	          if (cur < min) {
+	            min = cur;
+	          }
+	        } else {
+	          return str
+	        }
+	      } else {
+	        cur = count(line, type);
+	        if (cur < min) {
+	          min = cur;
+	        }
+	      }
+	    }
+	  }
+	  return lines.map(function (line) {
+	    return line.slice(min)
+	  }).join('\n')
+	};
+
+	function count (line, type) {
+	  var i = 0;
+	  while (line.charAt(i) === type) {
+	    i++;
+	  }
+	  return i
+	}
+
+	const emptyObject = Object.freeze({});
+	// These helpers produce better VM code in JS engines due to their
+	// explicitness and function inlining.
+	function isUndef(v) {
+	    return v === undefined || v === null;
+	}
+	/**
+	 * Check if value is primitive.
+	 */
+	function isPrimitive(value) {
+	    return (typeof value === 'string' ||
+	        typeof value === 'number' ||
+	        // $flow-disable-line
+	        typeof value === 'symbol' ||
+	        typeof value === 'boolean');
+	}
+	/**
+	 * Quick object check - this is primarily used to tell
+	 * objects from primitive values when we know the value
+	 * is a JSON-compliant type.
+	 */
+	function isObject(obj) {
+	    return obj !== null && typeof obj === 'object';
+	}
+	/**
+	 * Get the raw type string of a value, e.g., [object Object].
+	 */
+	const _toString = Object.prototype.toString;
+	function toRawType(value) {
+	    return _toString.call(value).slice(8, -1);
+	}
+	/**
+	 * Strict object type check. Only returns true
+	 * for plain JavaScript objects.
+	 */
+	function isPlainObject(obj) {
+	    return _toString.call(obj) === '[object Object]';
+	}
+	/**
+	 * Check if val is a valid array index.
+	 */
+	function isValidArrayIndex(val) {
+	    const n = parseFloat(String(val));
+	    return n >= 0 && Math.floor(n) === n && isFinite(val);
+	}
+	/**
+	 * Make a map and return a function for checking if a key
+	 * is in that map.
+	 */
+	function makeMap(str, expectsLowerCase) {
+	    const map = Object.create(null);
+	    const list = str.split(',');
+	    for (let i = 0; i < list.length; i++) {
+	        map[list[i]] = true;
+	    }
+	    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+	}
+	/**
+	 * Check if a tag is a built-in tag.
+	 */
+	const isBuiltInTag = makeMap('slot,component', true);
+	/**
+	 * Check if an attribute is a reserved attribute.
+	 */
+	makeMap('key,ref,slot,slot-scope,is');
+	/**
+	 * Remove an item from an array.
+	 */
+	function remove(arr, item) {
+	    if (arr.length) {
+	        const index = arr.indexOf(item);
+	        if (index > -1) {
+	            return arr.splice(index, 1);
+	        }
+	    }
+	}
+	/**
+	 * Check whether an object has the property.
+	 */
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function hasOwn(obj, key) {
+	    return hasOwnProperty.call(obj, key);
+	}
+	/**
+	 * Create a cached version of a pure function.
+	 */
+	function cached(fn) {
+	    const cache = Object.create(null);
+	    return function cachedFn(str) {
+	        const hit = cache[str];
+	        return hit || (cache[str] = fn(str));
+	    };
+	}
+	/**
+	 * Camelize a hyphen-delimited string.
+	 */
+	const camelizeRE = /-(\w)/g;
+	const camelize = cached((str) => {
+	    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+	});
+	/**
+	 * Hyphenate a camelCase string.
+	 */
+	const hyphenateRE = /\B([A-Z])/g;
+	const hyphenate = cached((str) => {
+	    return str.replace(hyphenateRE, '-$1').toLowerCase();
+	});
+	/**
+	 * Mix properties into target object.
+	 */
+	function extend(to, _from) {
+	    for (const key in _from) {
+	        to[key] = _from[key];
+	    }
+	    return to;
+	}
+	/* eslint-disable no-unused-vars */
+	/**
+	 * Perform no operation.
+	 * Stubbing args to make Flow happy without leaving useless transpiled code
+	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+	 */
+	function noop(a, b, c) { }
+	/**
+	 * Always return false.
+	 */
+	const no = (a, b, c) => false;
+	/* eslint-enable no-unused-vars */
+	/**
+	 * Return the same value.
+	 */
+	const identity = (_) => _;
+	/**
+	 * Generate a string containing static keys from compiler modules.
+	 */
+	function genStaticKeys$1(modules) {
+	    return modules
+	        .reduce((keys, m) => {
+	        return keys.concat(m.staticKeys || []);
+	    }, [])
+	        .join(',');
+	}
+
+	const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+	    'link,meta,param,source,track,wbr');
+	// Elements that you can, intentionally, leave open
+	// (and which close themselves)
+	const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+	const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+	    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+	    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+	    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+	    'title,tr,track');
+
+	/**
+	 * unicode letters used for parsing html tags, component names and property paths.
+	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+	 */
+	const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+	/**
+	 * Define a property.
+	 */
+	function def(obj, key, val, enumerable) {
+	    Object.defineProperty(obj, key, {
+	        value: val,
+	        enumerable: !!enumerable,
+	        writable: true,
+	        configurable: true,
+	    });
+	}
+
+	/**
+	 * Not type-checking this file because it's mostly vendor code.
+	 */
+	// Regular Expressions for parsing tags and attributes
+	const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+	const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+	const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+	const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+	const startTagOpen = new RegExp(`^<${qnameCapture}`);
+	const startTagClose = /^\s*(\/?)>/;
+	const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+	const doctype = /^<!DOCTYPE [^>]+>/i;
+	// #7298: escape - to avoid being passed as HTML comment when inlined in page
+	const comment = /^<!\--/;
+	const conditionalComment = /^<!\[/;
+	// Special Elements (can contain anything)
+	const isPlainTextElement = makeMap('script,style,textarea', true);
+	const reCache = {};
+	const decodingMap = {
+	    '&lt;': '<',
+	    '&gt;': '>',
+	    '&quot;': '"',
+	    '&amp;': '&',
+	    '&#10;': '\n',
+	    '&#9;': '\t',
+	    '&#39;': "'",
+	};
+	const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+	const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+	// #5992
+	const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+	const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+	function decodeAttr(value, shouldDecodeNewlines) {
+	    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+	    return value.replace(re, (match) => decodingMap[match]);
+	}
+	function parseHTML(html, options) {
+	    const stack = [];
+	    const expectHTML = options.expectHTML;
+	    const isUnaryTag = options.isUnaryTag || no;
+	    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+	    let index = 0;
+	    let last, lastTag;
+	    while (html) {
+	        last = html;
+	        // Make sure we're not in a plaintext content element like script/style
+	        if (!lastTag || !isPlainTextElement(lastTag)) {
+	            let textEnd = html.indexOf('<');
+	            if (textEnd === 0) {
+	                // Comment:
+	                if (comment.test(html)) {
+	                    const commentEnd = html.indexOf('-->');
+	                    if (commentEnd >= 0) {
+	                        if (options.shouldKeepComment) {
+	                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+	                        }
+	                        advance(commentEnd + 3);
+	                        continue;
+	                    }
+	                }
+	                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+	                if (conditionalComment.test(html)) {
+	                    const conditionalEnd = html.indexOf(']>');
+	                    if (conditionalEnd >= 0) {
+	                        advance(conditionalEnd + 2);
+	                        continue;
+	                    }
+	                }
+	                // Doctype:
+	                const doctypeMatch = html.match(doctype);
+	                if (doctypeMatch) {
+	                    advance(doctypeMatch[0].length);
+	                    continue;
+	                }
+	                // End tag:
+	                const endTagMatch = html.match(endTag);
+	                if (endTagMatch) {
+	                    const curIndex = index;
+	                    advance(endTagMatch[0].length);
+	                    parseEndTag(endTagMatch[1], curIndex, index);
+	                    continue;
+	                }
+	                // Start tag:
+	                const startTagMatch = parseStartTag();
+	                if (startTagMatch) {
+	                    handleStartTag(startTagMatch);
+	                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+	                        advance(1);
+	                    }
+	                    continue;
+	                }
+	            }
+	            let text, rest, next;
+	            if (textEnd >= 0) {
+	                rest = html.slice(textEnd);
+	                while (!endTag.test(rest) &&
+	                    !startTagOpen.test(rest) &&
+	                    !comment.test(rest) &&
+	                    !conditionalComment.test(rest)) {
+	                    // < in plain text, be forgiving and treat it as text
+	                    next = rest.indexOf('<', 1);
+	                    if (next < 0)
+	                        break;
+	                    textEnd += next;
+	                    rest = html.slice(textEnd);
+	                }
+	                text = html.substring(0, textEnd);
+	            }
+	            if (textEnd < 0) {
+	                text = html;
+	            }
+	            if (text) {
+	                advance(text.length);
+	            }
+	            if (options.chars && text) {
+	                options.chars(text, index - text.length, index);
+	            }
+	        }
+	        else {
+	            let endTagLength = 0;
+	            const stackedTag = lastTag.toLowerCase();
+	            const reStackedTag = reCache[stackedTag] ||
+	                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+	            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+	                endTagLength = endTag.length;
+	                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+	                    text = text
+	                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+	                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+	                }
+	                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+	                    text = text.slice(1);
+	                }
+	                if (options.chars) {
+	                    options.chars(text);
+	                }
+	                return '';
+	            });
+	            index += html.length - rest.length;
+	            html = rest;
+	            parseEndTag(stackedTag, index - endTagLength, index);
+	        }
+	        if (html === last) {
+	            options.chars && options.chars(html);
+	            if (!stack.length &&
+	                options.warn) {
+	                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+	                    start: index + html.length,
+	                });
+	            }
+	            break;
+	        }
+	    }
+	    // Clean up any remaining tags
+	    parseEndTag();
+	    function advance(n) {
+	        index += n;
+	        html = html.substring(n);
+	    }
+	    function parseStartTag() {
+	        const start = html.match(startTagOpen);
+	        if (start) {
+	            const match = {
+	                tagName: start[1],
+	                attrs: [],
+	                start: index,
+	            };
+	            advance(start[0].length);
+	            let end, attr;
+	            while (!(end = html.match(startTagClose)) &&
+	                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+	                attr.start = index;
+	                advance(attr[0].length);
+	                attr.end = index;
+	                match.attrs.push(attr);
+	            }
+	            if (end) {
+	                match.unarySlash = end[1];
+	                advance(end[0].length);
+	                match.end = index;
+	                return match;
+	            }
+	        }
+	    }
+	    function handleStartTag(match) {
+	        const tagName = match.tagName;
+	        const unarySlash = match.unarySlash;
+	        if (expectHTML) {
+	            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+	                parseEndTag(lastTag);
+	            }
+	            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+	                parseEndTag(tagName);
+	            }
+	        }
+	        const unary = isUnaryTag(tagName) || !!unarySlash;
+	        const l = match.attrs.length;
+	        const attrs = new Array(l);
+	        for (let i = 0; i < l; i++) {
+	            const args = match.attrs[i];
+	            const value = args[3] || args[4] || args[5] || '';
+	            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+	                ? options.shouldDecodeNewlinesForHref
+	                : options.shouldDecodeNewlines;
+	            attrs[i] = {
+	                name: args[1],
+	                value: decodeAttr(value, shouldDecodeNewlines),
+	            };
+	            if (options.outputSourceRange) {
+	                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+	                attrs[i].end = args.end;
+	            }
+	        }
+	        if (!unary) {
+	            stack.push({
+	                tag: tagName,
+	                lowerCasedTag: tagName.toLowerCase(),
+	                attrs: attrs,
+	                start: match.start,
+	                end: match.end,
+	            });
+	            lastTag = tagName;
+	        }
+	        if (options.start) {
+	            options.start(tagName, attrs, unary, match.start, match.end);
+	        }
+	    }
+	    function parseEndTag(tagName, start, end) {
+	        let pos, lowerCasedTagName;
+	        if (start == null)
+	            start = index;
+	        if (end == null)
+	            end = index;
+	        // Find the closest opened tag of the same type
+	        if (tagName) {
+	            lowerCasedTagName = tagName.toLowerCase();
+	            for (pos = stack.length - 1; pos >= 0; pos--) {
+	                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+	                    break;
+	                }
+	            }
+	        }
+	        else {
+	            // If no tag name is provided, clean shop
+	            pos = 0;
+	        }
+	        if (pos >= 0) {
+	            // Close all the open elements, up the stack
+	            for (let i = stack.length - 1; i >= pos; i--) {
+	                if ((i > pos || !tagName) &&
+	                    options.warn) {
+	                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+	                        start: stack[i].start,
+	                        end: stack[i].end,
+	                    });
+	                }
+	                if (options.end) {
+	                    options.end(stack[i].tag, start, end);
+	                }
+	            }
+	            // Remove the open elements from the stack
+	            stack.length = pos;
+	            lastTag = pos && stack[pos - 1].tag;
+	        }
+	        else if (lowerCasedTagName === 'br') {
+	            if (options.start) {
+	                options.start(tagName, [], true, start, end);
+	            }
+	        }
+	        else if (lowerCasedTagName === 'p') {
+	            if (options.start) {
+	                options.start(tagName, [], false, start, end);
+	            }
+	            if (options.end) {
+	                options.end(tagName, start, end);
+	            }
+	        }
+	    }
+	}
+
+	const splitRE = /\r?\n/g;
+	const replaceRE = /./g;
+	const isSpecialTag = makeMap('script,style,template', true);
+	/**
+	 * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+	 */
+	function parseComponent(content, options = {}) {
+	    const sfc = {
+	        template: null,
+	        script: null,
+	        styles: [],
+	        customBlocks: [],
+	        errors: [],
+	    };
+	    let depth = 0;
+	    let currentBlock = null;
+	    let warn = (msg) => {
+	        sfc.errors.push(msg);
+	    };
+	    if (options.outputSourceRange) {
+	        warn = (msg, range) => {
+	            const data = { msg };
+	            if (range.start != null) {
+	                data.start = range.start;
+	            }
+	            if (range.end != null) {
+	                data.end = range.end;
+	            }
+	            sfc.errors.push(data);
+	        };
+	    }
+	    function start(tag, attrs, unary, start, end) {
+	        if (depth === 0) {
+	            currentBlock = {
+	                type: tag,
+	                content: '',
+	                start: end,
+	                attrs: attrs.reduce((cumulated, { name, value }) => {
+	                    cumulated[name] = value || true;
+	                    return cumulated;
+	                }, {}),
+	            };
+	            if (isSpecialTag(tag)) {
+	                checkAttrs(currentBlock, attrs);
+	                if (tag === 'style') {
+	                    sfc.styles.push(currentBlock);
+	                }
+	                else {
+	                    sfc[tag] = currentBlock;
+	                }
+	            }
+	            else {
+	                // custom blocks
+	                sfc.customBlocks.push(currentBlock);
+	            }
+	        }
+	        if (!unary) {
+	            depth++;
+	        }
+	    }
+	    function checkAttrs(block, attrs) {
+	        for (let i = 0; i < attrs.length; i++) {
+	            const attr = attrs[i];
+	            if (attr.name === 'lang') {
+	                block.lang = attr.value;
+	            }
+	            if (attr.name === 'scoped') {
+	                block.scoped = true;
+	            }
+	            if (attr.name === 'module') {
+	                block.module = attr.value || true;
+	            }
+	            if (attr.name === 'src') {
+	                block.src = attr.value;
+	            }
+	        }
+	    }
+	    function end(tag, start) {
+	        if (depth === 1 && currentBlock) {
+	            currentBlock.end = start;
+	            let text = content.slice(currentBlock.start, currentBlock.end);
+	            if (options.deindent !== false) {
+	                text = deIndent(text);
+	            }
+	            // pad content so that linters and pre-processors can output correct
+	            // line numbers in errors and warnings
+	            if (currentBlock.type !== 'template' && options.pad) {
+	                text = padContent(currentBlock, options.pad) + text;
+	            }
+	            currentBlock.content = text;
+	            currentBlock = null;
+	        }
+	        depth--;
+	    }
+	    function padContent(block, pad) {
+	        if (pad === 'space') {
+	            return content.slice(0, block.start).replace(replaceRE, ' ');
+	        }
+	        else {
+	            const offset = content.slice(0, block.start).split(splitRE).length;
+	            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+	            return Array(offset).join(padChar);
+	        }
+	    }
+	    parseHTML(content, {
+	        warn,
+	        start,
+	        end,
+	        outputSourceRange: options.outputSourceRange,
+	    });
+	    return sfc;
+	}
+
+	// can we use __proto__?
+	const hasProto = '__proto__' in {};
+	// Browser environment sniffing
+	const inBrowser = typeof window !== 'undefined';
+	const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+	const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+	const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+	const isIE = UA && /msie|trident/.test(UA);
+	UA && UA.indexOf('msie 9.0') > 0;
+	const isEdge = UA && UA.indexOf('edge/') > 0;
+	(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+	(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+	UA && /chrome\/\d+/.test(UA) && !isEdge;
+	UA && /phantomjs/.test(UA);
+	UA && UA.match(/firefox\/(\d+)/);
+	// Firefox has a "watch" function on Object.prototype...
+	// @ts-expect-error firebox support
+	const nativeWatch = {}.watch;
+	let supportsPassive = false;
+	if (inBrowser) {
+	    try {
+	        const opts = {};
+	        Object.defineProperty(opts, 'passive', {
+	            get() {
+	                /* istanbul ignore next */
+	                supportsPassive = true;
+	            },
+	        }); // https://github.com/facebook/flow/issues/285
+	        window.addEventListener('test-passive', null, opts);
+	    }
+	    catch (e) { }
+	}
+	// this needs to be lazy-evaled because vue may be required before
+	// vue-server-renderer can set VUE_ENV
+	let _isServer;
+	const isServerRendering = () => {
+	    if (_isServer === undefined) {
+	        /* istanbul ignore if */
+	        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+	            // detect presence of vue-server-renderer and avoid
+	            // Webpack shimming the process
+	            _isServer =
+	                global['process'] && global['process'].env.VUE_ENV === 'server';
+	        }
+	        else {
+	            _isServer = false;
+	        }
+	    }
+	    return _isServer;
+	};
+	/* istanbul ignore next */
+	function isNative(Ctor) {
+	    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+	}
+	const hasSymbol = typeof Symbol !== 'undefined' &&
+	    isNative(Symbol) &&
+	    typeof Reflect !== 'undefined' &&
+	    isNative(Reflect.ownKeys);
+	/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
+
+	const ASSET_TYPES = ['component', 'directive', 'filter'];
+	const LIFECYCLE_HOOKS = [
+	    'beforeCreate',
+	    'created',
+	    'beforeMount',
+	    'mounted',
+	    'beforeUpdate',
+	    'updated',
+	    'beforeDestroy',
+	    'destroyed',
+	    'activated',
+	    'deactivated',
+	    'errorCaptured',
+	    'serverPrefetch',
+	];
+
+	var config = {
+	    /**
+	     * Option merge strategies (used in core/util/options)
+	     */
+	    // $flow-disable-line
+	    optionMergeStrategies: Object.create(null),
+	    /**
+	     * Whether to suppress warnings.
+	     */
+	    silent: false,
+	    /**
+	     * Show production mode tip message on boot?
+	     */
+	    productionTip: "development" !== 'production',
+	    /**
+	     * Whether to enable devtools
+	     */
+	    devtools: "development" !== 'production',
+	    /**
+	     * Whether to record perf
+	     */
+	    performance: false,
+	    /**
+	     * Error handler for watcher errors
+	     */
+	    errorHandler: null,
+	    /**
+	     * Warn handler for watcher warns
+	     */
+	    warnHandler: null,
+	    /**
+	     * Ignore certain custom elements
+	     */
+	    ignoredElements: [],
+	    /**
+	     * Custom user key aliases for v-on
+	     */
+	    // $flow-disable-line
+	    keyCodes: Object.create(null),
+	    /**
+	     * Check if a tag is reserved so that it cannot be registered as a
+	     * component. This is platform-dependent and may be overwritten.
+	     */
+	    isReservedTag: no,
+	    /**
+	     * Check if an attribute is reserved so that it cannot be used as a component
+	     * prop. This is platform-dependent and may be overwritten.
+	     */
+	    isReservedAttr: no,
+	    /**
+	     * Check if a tag is an unknown element.
+	     * Platform-dependent.
+	     */
+	    isUnknownElement: no,
+	    /**
+	     * Get the namespace of an element
+	     */
+	    getTagNamespace: noop,
+	    /**
+	     * Parse the real tag name for the specific platform.
+	     */
+	    parsePlatformTagName: identity,
+	    /**
+	     * Check if an attribute must be bound using property, e.g. value
+	     * Platform-dependent.
+	     */
+	    mustUseProp: no,
+	    /**
+	     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+	     * This will significantly reduce performance if set to false.
+	     */
+	    async: true,
+	    /**
+	     * Exposed for legacy reasons
+	     */
+	    _lifecycleHooks: LIFECYCLE_HOOKS,
+	};
+
+	let warn$2 = noop;
+	let tip = noop;
+	let generateComponentTrace; // work around flow check
+	let formatComponentName;
+	{
+	    const hasConsole = typeof console !== 'undefined';
+	    const classifyRE = /(?:^|[-_])(\w)/g;
+	    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+	    warn$2 = (msg, vm) => {
+	        const trace = vm ? generateComponentTrace(vm) : '';
+	        if (hasConsole && !config.silent) {
+	            console.error(`[Vue warn]: ${msg}${trace}`);
+	        }
+	    };
+	    tip = (msg, vm) => {
+	        if (hasConsole && !config.silent) {
+	            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+	        }
+	    };
+	    formatComponentName = (vm, includeFile) => {
+	        if (vm.$root === vm) {
+	            return '<Root>';
+	        }
+	        const options = typeof vm === 'function' && vm.cid != null
+	            ? vm.options
+	            : vm._isVue
+	                ? vm.$options || vm.constructor.options
+	                : vm;
+	        let name = options.name || options._componentTag;
+	        const file = options.__file;
+	        if (!name && file) {
+	            const match = file.match(/([^/\\]+)\.vue$/);
+	            name = match && match[1];
+	        }
+	        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+	            (file && includeFile !== false ? ` at ${file}` : ''));
+	    };
+	    const repeat = (str, n) => {
+	        let res = '';
+	        while (n) {
+	            if (n % 2 === 1)
+	                res += str;
+	            if (n > 1)
+	                str += str;
+	            n >>= 1;
+	        }
+	        return res;
+	    };
+	    generateComponentTrace = (vm) => {
+	        if (vm._isVue && vm.$parent) {
+	            const tree = [];
+	            let currentRecursiveSequence = 0;
+	            while (vm) {
+	                if (tree.length > 0) {
+	                    const last = tree[tree.length - 1];
+	                    if (last.constructor === vm.constructor) {
+	                        currentRecursiveSequence++;
+	                        vm = vm.$parent;
+	                        continue;
+	                    }
+	                    else if (currentRecursiveSequence > 0) {
+	                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+	                        currentRecursiveSequence = 0;
+	                    }
+	                }
+	                tree.push(vm);
+	                vm = vm.$parent;
+	            }
+	            return ('\n\nfound in\n\n' +
+	                tree
+	                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+	                    .join('\n'));
+	        }
+	        else {
+	            return `\n\n(found in ${formatComponentName(vm)})`;
+	        }
+	    };
+	}
+
+	let uid = 0;
+	/**
+	 * A dep is an observable that can have multiple
+	 * directives subscribing to it.
+	 */
+	class Dep {
+	    static target;
+	    id;
+	    subs;
+	    constructor() {
+	        this.id = uid++;
+	        this.subs = [];
+	    }
+	    addSub(sub) {
+	        this.subs.push(sub);
+	    }
+	    removeSub(sub) {
+	        remove(this.subs, sub);
+	    }
+	    depend() {
+	        if (Dep.target) {
+	            Dep.target.addDep(this);
+	        }
+	    }
+	    notify() {
+	        // stabilize the subscriber list first
+	        const subs = this.subs.slice();
+	        for (let i = 0, l = subs.length; i < l; i++) {
+	            subs[i].update();
+	        }
+	    }
+	}
+	// The current target watcher being evaluated.
+	// This is globally unique because only one watcher
+	// can be evaluated at a time.
+	Dep.target = null;
+
+	class VNode {
+	    tag;
+	    data;
+	    children;
+	    text;
+	    elm;
+	    ns;
+	    context; // rendered in this component's scope
+	    key;
+	    componentOptions;
+	    componentInstance; // component instance
+	    parent; // component placeholder node
+	    // strictly internal
+	    raw; // contains raw HTML? (server only)
+	    isStatic; // hoisted static node
+	    isRootInsert; // necessary for enter transition check
+	    isComment; // empty comment placeholder?
+	    isCloned; // is a cloned node?
+	    isOnce; // is a v-once node?
+	    asyncFactory; // async component factory function
+	    asyncMeta;
+	    isAsyncPlaceholder;
+	    ssrContext;
+	    fnContext; // real context vm for functional nodes
+	    fnOptions; // for SSR caching
+	    devtoolsMeta; // used to store functional render context for devtools
+	    fnScopeId; // functional scope id support
+	    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+	        this.tag = tag;
+	        this.data = data;
+	        this.children = children;
+	        this.text = text;
+	        this.elm = elm;
+	        this.ns = undefined;
+	        this.context = context;
+	        this.fnContext = undefined;
+	        this.fnOptions = undefined;
+	        this.fnScopeId = undefined;
+	        this.key = data && data.key;
+	        this.componentOptions = componentOptions;
+	        this.componentInstance = undefined;
+	        this.parent = undefined;
+	        this.raw = false;
+	        this.isStatic = false;
+	        this.isRootInsert = true;
+	        this.isComment = false;
+	        this.isCloned = false;
+	        this.isOnce = false;
+	        this.asyncFactory = asyncFactory;
+	        this.asyncMeta = undefined;
+	        this.isAsyncPlaceholder = false;
+	    }
+	    // DEPRECATED: alias for componentInstance for backwards compat.
+	    /* istanbul ignore next */
+	    get child() {
+	        return this.componentInstance;
+	    }
+	}
+
+	/*
+	 * not type checking this file because flow doesn't play well with
+	 * dynamically accessing methods on Array prototype
+	 */
+	const arrayProto = Array.prototype;
+	const arrayMethods = Object.create(arrayProto);
+	const methodsToPatch = [
+	    'push',
+	    'pop',
+	    'shift',
+	    'unshift',
+	    'splice',
+	    'sort',
+	    'reverse',
+	];
+	/**
+	 * Intercept mutating methods and emit events
+	 */
+	methodsToPatch.forEach(function (method) {
+	    // cache original method
+	    const original = arrayProto[method];
+	    def(arrayMethods, method, function mutator(...args) {
+	        const result = original.apply(this, args);
+	        const ob = this.__ob__;
+	        let inserted;
+	        switch (method) {
+	            case 'push':
+	            case 'unshift':
+	                inserted = args;
+	                break;
+	            case 'splice':
+	                inserted = args.slice(2);
+	                break;
+	        }
+	        if (inserted)
+	            ob.observeArray(inserted);
+	        // notify change
+	        ob.dep.notify();
+	        return result;
+	    });
+	});
+
+	const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+	/**
+	 * Observer class that is attached to each observed
+	 * object. Once attached, the observer converts the target
+	 * object's property keys into getter/setters that
+	 * collect dependencies and dispatch updates.
+	 */
+	class Observer {
+	    value;
+	    dep;
+	    vmCount; // number of vms that have this object as root $data
+	    constructor(value) {
+	        this.value = value;
+	        this.dep = new Dep();
+	        this.vmCount = 0;
+	        def(value, '__ob__', this);
+	        if (Array.isArray(value)) {
+	            if (hasProto) {
+	                protoAugment(value, arrayMethods);
+	            }
+	            else {
+	                copyAugment(value, arrayMethods, arrayKeys);
+	            }
+	            this.observeArray(value);
+	        }
+	        else {
+	            this.walk(value);
+	        }
+	    }
+	    /**
+	     * Walk through all properties and convert them into
+	     * getter/setters. This method should only be called when
+	     * value type is Object.
+	     */
+	    walk(obj) {
+	        const keys = Object.keys(obj);
+	        for (let i = 0; i < keys.length; i++) {
+	            defineReactive(obj, keys[i]);
+	        }
+	    }
+	    /**
+	     * Observe a list of Array items.
+	     */
+	    observeArray(items) {
+	        for (let i = 0, l = items.length; i < l; i++) {
+	            observe(items[i]);
+	        }
+	    }
+	}
+	// helpers
+	/**
+	 * Augment a target Object or Array by intercepting
+	 * the prototype chain using __proto__
+	 */
+	function protoAugment(target, src) {
+	    /* eslint-disable no-proto */
+	    target.__proto__ = src;
+	    /* eslint-enable no-proto */
+	}
+	/**
+	 * Augment a target Object or Array by defining
+	 * hidden properties.
+	 */
+	/* istanbul ignore next */
+	function copyAugment(target, src, keys) {
+	    for (let i = 0, l = keys.length; i < l; i++) {
+	        const key = keys[i];
+	        def(target, key, src[key]);
+	    }
+	}
+	/**
+	 * Attempt to create an observer instance for a value,
+	 * returns the new observer if successfully observed,
+	 * or the existing observer if the value already has one.
+	 */
+	function observe(value, asRootData) {
+	    if (!isObject(value) || value instanceof VNode) {
+	        return;
+	    }
+	    let ob;
+	    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+	        ob = value.__ob__;
+	    }
+	    else if (!isServerRendering() &&
+	        (Array.isArray(value) || isPlainObject(value)) &&
+	        Object.isExtensible(value) &&
+	        !value._isVue) {
+	        ob = new Observer(value);
+	    }
+	    if (asRootData && ob) {
+	        ob.vmCount++;
+	    }
+	    return ob;
+	}
+	/**
+	 * Define a reactive property on an Object.
+	 */
+	function defineReactive(obj, key, val, customSetter, shallow) {
+	    const dep = new Dep();
+	    const property = Object.getOwnPropertyDescriptor(obj, key);
+	    if (property && property.configurable === false) {
+	        return;
+	    }
+	    // cater for pre-defined getter/setters
+	    const getter = property && property.get;
+	    const setter = property && property.set;
+	    if ((!getter || setter) && arguments.length === 2) {
+	        val = obj[key];
+	    }
+	    let childOb = !shallow && observe(val);
+	    Object.defineProperty(obj, key, {
+	        enumerable: true,
+	        configurable: true,
+	        get: function reactiveGetter() {
+	            const value = getter ? getter.call(obj) : val;
+	            if (Dep.target) {
+	                dep.depend();
+	                if (childOb) {
+	                    childOb.dep.depend();
+	                    if (Array.isArray(value)) {
+	                        dependArray(value);
+	                    }
+	                }
+	            }
+	            return value;
+	        },
+	        set: function reactiveSetter(newVal) {
+	            const value = getter ? getter.call(obj) : val;
+	            /* eslint-disable no-self-compare */
+	            if (newVal === value || (newVal !== newVal && value !== value)) {
+	                return;
+	            }
+	            /* eslint-enable no-self-compare */
+	            if (customSetter) {
+	                customSetter();
+	            }
+	            // #7981: for accessor properties without setter
+	            if (getter && !setter)
+	                return;
+	            if (setter) {
+	                setter.call(obj, newVal);
+	            }
+	            else {
+	                val = newVal;
+	            }
+	            childOb = !shallow && observe(newVal);
+	            dep.notify();
+	        },
+	    });
+	}
+	/**
+	 * Set a property on an object. Adds the new property and
+	 * triggers change notification if the property doesn't
+	 * already exist.
+	 */
+	function set(target, key, val) {
+	    if ((isUndef(target) || isPrimitive(target))) {
+	        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+	    }
+	    if (Array.isArray(target) && isValidArrayIndex(key)) {
+	        target.length = Math.max(target.length, key);
+	        target.splice(key, 1, val);
+	        return val;
+	    }
+	    if (key in target && !(key in Object.prototype)) {
+	        target[key] = val;
+	        return val;
+	    }
+	    const ob = target.__ob__;
+	    if (target._isVue || (ob && ob.vmCount)) {
+	        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+	                'at runtime - declare it upfront in the data option.');
+	        return val;
+	    }
+	    if (!ob) {
+	        target[key] = val;
+	        return val;
+	    }
+	    defineReactive(ob.value, key, val);
+	    ob.dep.notify();
+	    return val;
+	}
+	/**
+	 * Collect dependencies on array elements when the array is touched, since
+	 * we cannot intercept array element access like property getters.
+	 */
+	function dependArray(value) {
+	    for (let e, i = 0, l = value.length; i < l; i++) {
+	        e = value[i];
+	        e && e.__ob__ && e.__ob__.dep.depend();
+	        if (Array.isArray(e)) {
+	            dependArray(e);
+	        }
+	    }
+	}
+
+	/**
+	 * Option overwriting strategies are functions that handle
+	 * how to merge a parent option value and a child option
+	 * value into the final value.
+	 */
+	const strats = config.optionMergeStrategies;
+	/**
+	 * Options with restrictions
+	 */
+	{
+	    strats.el = strats.propsData = function (parent, child, vm, key) {
+	        if (!vm) {
+	            warn$2(`option "${key}" can only be used during instance ` +
+	                'creation with the `new` keyword.');
+	        }
+	        return defaultStrat(parent, child);
+	    };
+	}
+	/**
+	 * Helper that recursively merges two data objects together.
+	 */
+	function mergeData(to, from) {
+	    if (!from)
+	        return to;
+	    let key, toVal, fromVal;
+	    const keys = hasSymbol
+	        ? Reflect.ownKeys(from)
+	        : Object.keys(from);
+	    for (let i = 0; i < keys.length; i++) {
+	        key = keys[i];
+	        // in case the object is already observed...
+	        if (key === '__ob__')
+	            continue;
+	        toVal = to[key];
+	        fromVal = from[key];
+	        if (!hasOwn(to, key)) {
+	            set(to, key, fromVal);
+	        }
+	        else if (toVal !== fromVal &&
+	            isPlainObject(toVal) &&
+	            isPlainObject(fromVal)) {
+	            mergeData(toVal, fromVal);
+	        }
+	    }
+	    return to;
+	}
+	/**
+	 * Data
+	 */
+	function mergeDataOrFn(parentVal, childVal, vm) {
+	    if (!vm) {
+	        // in a Vue.extend merge, both should be functions
+	        if (!childVal) {
+	            return parentVal;
+	        }
+	        if (!parentVal) {
+	            return childVal;
+	        }
+	        // when parentVal & childVal are both present,
+	        // we need to return a function that returns the
+	        // merged result of both functions... no need to
+	        // check if parentVal is a function here because
+	        // it has to be a function to pass previous merges.
+	        return function mergedDataFn() {
+	            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+	        };
+	    }
+	    else {
+	        return function mergedInstanceDataFn() {
+	            // instance merge
+	            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+	            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+	            if (instanceData) {
+	                return mergeData(instanceData, defaultData);
+	            }
+	            else {
+	                return defaultData;
+	            }
+	        };
+	    }
+	}
+	strats.data = function (parentVal, childVal, vm) {
+	    if (!vm) {
+	        if (childVal && typeof childVal !== 'function') {
+	            warn$2('The "data" option should be a function ' +
+	                    'that returns a per-instance value in component ' +
+	                    'definitions.', vm);
+	            return parentVal;
+	        }
+	        return mergeDataOrFn(parentVal, childVal);
+	    }
+	    return mergeDataOrFn(parentVal, childVal, vm);
+	};
+	/**
+	 * Hooks and props are merged as arrays.
+	 */
+	function mergeHook(parentVal, childVal) {
+	    const res = childVal
+	        ? parentVal
+	            ? parentVal.concat(childVal)
+	            : Array.isArray(childVal)
+	                ? childVal
+	                : [childVal]
+	        : parentVal;
+	    return res ? dedupeHooks(res) : res;
+	}
+	function dedupeHooks(hooks) {
+	    const res = [];
+	    for (let i = 0; i < hooks.length; i++) {
+	        if (res.indexOf(hooks[i]) === -1) {
+	            res.push(hooks[i]);
+	        }
+	    }
+	    return res;
+	}
+	LIFECYCLE_HOOKS.forEach((hook) => {
+	    strats[hook] = mergeHook;
+	});
+	/**
+	 * Assets
+	 *
+	 * When a vm is present (instance creation), we need to do
+	 * a three-way merge between constructor options, instance
+	 * options and parent options.
+	 */
+	function mergeAssets(parentVal, childVal, vm, key) {
+	    const res = Object.create(parentVal || null);
+	    if (childVal) {
+	        assertObjectType(key, childVal, vm);
+	        return extend(res, childVal);
+	    }
+	    else {
+	        return res;
+	    }
+	}
+	ASSET_TYPES.forEach(function (type) {
+	    strats[type + 's'] = mergeAssets;
+	});
+	/**
+	 * Watchers.
+	 *
+	 * Watchers hashes should not overwrite one
+	 * another, so we merge them as arrays.
+	 */
+	strats.watch = function (parentVal, childVal, vm, key) {
+	    // work around Firefox's Object.prototype.watch...
+	    //@ts-expect-error work around
+	    if (parentVal === nativeWatch)
+	        parentVal = undefined;
+	    //@ts-expect-error work around
+	    if (childVal === nativeWatch)
+	        childVal = undefined;
+	    /* istanbul ignore if */
+	    if (!childVal)
+	        return Object.create(parentVal || null);
+	    {
+	        assertObjectType(key, childVal, vm);
+	    }
+	    if (!parentVal)
+	        return childVal;
+	    const ret = {};
+	    extend(ret, parentVal);
+	    for (const key in childVal) {
+	        let parent = ret[key];
+	        const child = childVal[key];
+	        if (parent && !Array.isArray(parent)) {
+	            parent = [parent];
+	        }
+	        ret[key] = parent
+	            ? parent.concat(child)
+	            : Array.isArray(child)
+	                ? child
+	                : [child];
+	    }
+	    return ret;
+	};
+	/**
+	 * Other object hashes.
+	 */
+	strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+	    if (childVal && "development" !== 'production') {
+	        assertObjectType(key, childVal, vm);
+	    }
+	    if (!parentVal)
+	        return childVal;
+	    const ret = Object.create(null);
+	    extend(ret, parentVal);
+	    if (childVal)
+	        extend(ret, childVal);
+	    return ret;
+	};
+	strats.provide = mergeDataOrFn;
+	/**
+	 * Default strategy.
+	 */
+	const defaultStrat = function (parentVal, childVal) {
+	    return childVal === undefined ? parentVal : childVal;
+	};
+	function assertObjectType(name, value, vm) {
+	    if (!isPlainObject(value)) {
+	        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+	            `but got ${toRawType(value)}.`, vm);
+	    }
+	}
+
+	/* globals MutationObserver */
+	const callbacks = [];
+	function flushCallbacks() {
+	    const copies = callbacks.slice(0);
+	    callbacks.length = 0;
+	    for (let i = 0; i < copies.length; i++) {
+	        copies[i]();
+	    }
+	}
+	// The nextTick behavior leverages the microtask queue, which can be accessed
+	// via either native Promise.then or MutationObserver.
+	// MutationObserver has wider support, however it is seriously bugged in
+	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+	// completely stops working after triggering a few times... so, if native
+	// Promise is available, we will use it:
+	/* istanbul ignore next, $flow-disable-line */
+	if (typeof Promise !== 'undefined' && isNative(Promise)) {
+	    Promise.resolve();
+	}
+	else if (!isIE &&
+	    typeof MutationObserver !== 'undefined' &&
+	    (isNative(MutationObserver) ||
+	        // PhantomJS and iOS 7.x
+	        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+	    // Use MutationObserver where native Promise is not available,
+	    // e.g. PhantomJS, iOS7, Android 4.4
+	    // (#6466 MutationObserver is unreliable in IE11)
+	    let counter = 1;
+	    const observer = new MutationObserver(flushCallbacks);
+	    const textNode = document.createTextNode(String(counter));
+	    observer.observe(textNode, {
+	        characterData: true,
+	    });
+	}
+	else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+	else ;
+
+	// these are reserved for web because they are directly compiled away
+	// during template compilation
+	makeMap('style,class');
+	// attributes that should be using props for binding
+	const acceptValue = makeMap('input,textarea,option,select,progress');
+	const mustUseProp = (tag, type, attr) => {
+	    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+	        (attr === 'selected' && tag === 'option') ||
+	        (attr === 'checked' && tag === 'input') ||
+	        (attr === 'muted' && tag === 'video'));
+	};
+	const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+	makeMap('events,caret,typing,plaintext-only');
+	const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+	    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+	    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+	    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+	    'required,reversed,scoped,seamless,selected,sortable,' +
+	    'truespeed,typemustmatch,visible');
+
+	const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+	    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+	    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+	    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+	    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+	    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+	    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+	    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+	    'output,progress,select,textarea,' +
+	    'details,dialog,menu,menuitem,summary,' +
+	    'content,element,shadow,template,blockquote,iframe,tfoot');
+	// this map is intentionally selective, only covering SVG elements that may
+	// contain child elements.
+	const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+	    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+	    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+	const isPreTag = (tag) => tag === 'pre';
+	const isReservedTag = (tag) => {
+	    return isHTMLTag(tag) || isSVG(tag);
+	};
+	function getTagNamespace(tag) {
+	    if (isSVG(tag)) {
+	        return 'svg';
+	    }
+	    // basic support for MathML
+	    // note it doesn't support other MathML elements being component roots
+	    if (tag === 'math') {
+	        return 'math';
+	    }
+	}
+	makeMap('text,number,password,search,email,tel,url');
+
+	const validDivisionCharRE = /[\w).+\-_$\]]/;
+	function parseFilters(exp) {
+	    let inSingle = false;
+	    let inDouble = false;
+	    let inTemplateString = false;
+	    let inRegex = false;
+	    let curly = 0;
+	    let square = 0;
+	    let paren = 0;
+	    let lastFilterIndex = 0;
+	    let c, prev, i, expression, filters;
+	    for (i = 0; i < exp.length; i++) {
+	        prev = c;
+	        c = exp.charCodeAt(i);
+	        if (inSingle) {
+	            if (c === 0x27 && prev !== 0x5c)
+	                inSingle = false;
+	        }
+	        else if (inDouble) {
+	            if (c === 0x22 && prev !== 0x5c)
+	                inDouble = false;
+	        }
+	        else if (inTemplateString) {
+	            if (c === 0x60 && prev !== 0x5c)
+	                inTemplateString = false;
+	        }
+	        else if (inRegex) {
+	            if (c === 0x2f && prev !== 0x5c)
+	                inRegex = false;
+	        }
+	        else if (c === 0x7c && // pipe
+	            exp.charCodeAt(i + 1) !== 0x7c &&
+	            exp.charCodeAt(i - 1) !== 0x7c &&
+	            !curly &&
+	            !square &&
+	            !paren) {
+	            if (expression === undefined) {
+	                // first filter, end of expression
+	                lastFilterIndex = i + 1;
+	                expression = exp.slice(0, i).trim();
+	            }
+	            else {
+	                pushFilter();
+	            }
+	        }
+	        else {
+	            switch (c) {
+	                case 0x22:
+	                    inDouble = true;
+	                    break; // "
+	                case 0x27:
+	                    inSingle = true;
+	                    break; // '
+	                case 0x60:
+	                    inTemplateString = true;
+	                    break; // `
+	                case 0x28:
+	                    paren++;
+	                    break; // (
+	                case 0x29:
+	                    paren--;
+	                    break; // )
+	                case 0x5b:
+	                    square++;
+	                    break; // [
+	                case 0x5d:
+	                    square--;
+	                    break; // ]
+	                case 0x7b:
+	                    curly++;
+	                    break; // {
+	                case 0x7d:
+	                    curly--;
+	                    break; // }
+	            }
+	            if (c === 0x2f) {
+	                // /
+	                let j = i - 1;
+	                let p;
+	                // find first non-whitespace prev char
+	                for (; j >= 0; j--) {
+	                    p = exp.charAt(j);
+	                    if (p !== ' ')
+	                        break;
+	                }
+	                if (!p || !validDivisionCharRE.test(p)) {
+	                    inRegex = true;
+	                }
+	            }
+	        }
+	    }
+	    if (expression === undefined) {
+	        expression = exp.slice(0, i).trim();
+	    }
+	    else if (lastFilterIndex !== 0) {
+	        pushFilter();
+	    }
+	    function pushFilter() {
+	        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+	        lastFilterIndex = i + 1;
+	    }
+	    if (filters) {
+	        for (i = 0; i < filters.length; i++) {
+	            expression = wrapFilter(expression, filters[i]);
+	        }
+	    }
+	    return expression;
+	}
+	function wrapFilter(exp, filter) {
+	    const i = filter.indexOf('(');
+	    if (i < 0) {
+	        // _f: resolveFilter
+	        return `_f("${filter}")(${exp})`;
+	    }
+	    else {
+	        const name = filter.slice(0, i);
+	        const args = filter.slice(i + 1);
+	        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+	    }
+	}
+
+	const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+	const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+	const buildRegex = cached((delimiters) => {
+	    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+	    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+	    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+	});
+	function parseText(text, delimiters) {
+	    //@ts-expect-error
+	    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+	    if (!tagRE.test(text)) {
+	        return;
+	    }
+	    const tokens = [];
+	    const rawTokens = [];
+	    let lastIndex = (tagRE.lastIndex = 0);
+	    let match, index, tokenValue;
+	    while ((match = tagRE.exec(text))) {
+	        index = match.index;
+	        // push text token
+	        if (index > lastIndex) {
+	            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+	            tokens.push(JSON.stringify(tokenValue));
+	        }
+	        // tag token
+	        const exp = parseFilters(match[1].trim());
+	        tokens.push(`_s(${exp})`);
+	        rawTokens.push({ '@binding': exp });
+	        lastIndex = index + match[0].length;
+	    }
+	    if (lastIndex < text.length) {
+	        rawTokens.push((tokenValue = text.slice(lastIndex)));
+	        tokens.push(JSON.stringify(tokenValue));
+	    }
+	    return {
+	        expression: tokens.join('+'),
+	        tokens: rawTokens,
+	    };
+	}
+
+	/* eslint-disable no-unused-vars */
+	function baseWarn(msg, range) {
+	    console.error(`[Vue compiler]: ${msg}`);
+	}
+	/* eslint-enable no-unused-vars */
+	function pluckModuleFunction(modules, key) {
+	    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+	}
+	function addProp(el, name, value, range, dynamic) {
+	    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+	    el.plain = false;
+	}
+	function addAttr(el, name, value, range, dynamic) {
+	    const attrs = dynamic
+	        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+	        : el.attrs || (el.attrs = []);
+	    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+	    el.plain = false;
+	}
+	// add a raw attr (use this in preTransforms)
+	function addRawAttr(el, name, value, range) {
+	    el.attrsMap[name] = value;
+	    el.attrsList.push(rangeSetItem({ name, value }, range));
+	}
+	function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+	    (el.directives || (el.directives = [])).push(rangeSetItem({
+	        name,
+	        rawName,
+	        value,
+	        arg,
+	        isDynamicArg,
+	        modifiers,
+	    }, range));
+	    el.plain = false;
+	}
+	function prependModifierMarker(symbol, name, dynamic) {
+	    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+	}
+	function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+	    modifiers = modifiers || emptyObject;
+	    // warn prevent and passive modifier
+	    /* istanbul ignore if */
+	    if (warn &&
+	        modifiers.prevent &&
+	        modifiers.passive) {
+	        warn("passive and prevent can't be used together. " +
+	            "Passive handler can't prevent default event.", range);
+	    }
+	    // normalize click.right and click.middle since they don't actually fire
+	    // this is technically browser-specific, but at least for now browsers are
+	    // the only target envs that have right/middle clicks.
+	    if (modifiers.right) {
+	        if (dynamic) {
+	            name = `(${name})==='click'?'contextmenu':(${name})`;
+	        }
+	        else if (name === 'click') {
+	            name = 'contextmenu';
+	            delete modifiers.right;
+	        }
+	    }
+	    else if (modifiers.middle) {
+	        if (dynamic) {
+	            name = `(${name})==='click'?'mouseup':(${name})`;
+	        }
+	        else if (name === 'click') {
+	            name = 'mouseup';
+	        }
+	    }
+	    // check capture modifier
+	    if (modifiers.capture) {
+	        delete modifiers.capture;
+	        name = prependModifierMarker('!', name, dynamic);
+	    }
+	    if (modifiers.once) {
+	        delete modifiers.once;
+	        name = prependModifierMarker('~', name, dynamic);
+	    }
+	    /* istanbul ignore if */
+	    if (modifiers.passive) {
+	        delete modifiers.passive;
+	        name = prependModifierMarker('&', name, dynamic);
+	    }
+	    let events;
+	    if (modifiers.native) {
+	        delete modifiers.native;
+	        events = el.nativeEvents || (el.nativeEvents = {});
+	    }
+	    else {
+	        events = el.events || (el.events = {});
+	    }
+	    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+	    if (modifiers !== emptyObject) {
+	        newHandler.modifiers = modifiers;
+	    }
+	    const handlers = events[name];
+	    /* istanbul ignore if */
+	    if (Array.isArray(handlers)) {
+	        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+	    }
+	    else if (handlers) {
+	        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+	    }
+	    else {
+	        events[name] = newHandler;
+	    }
+	    el.plain = false;
+	}
+	function getRawBindingAttr(el, name) {
+	    return (el.rawAttrsMap[':' + name] ||
+	        el.rawAttrsMap['v-bind:' + name] ||
+	        el.rawAttrsMap[name]);
+	}
+	function getBindingAttr(el, name, getStatic) {
+	    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+	    if (dynamicValue != null) {
+	        return parseFilters(dynamicValue);
+	    }
+	    else if (getStatic !== false) {
+	        const staticValue = getAndRemoveAttr(el, name);
+	        if (staticValue != null) {
+	            return JSON.stringify(staticValue);
+	        }
+	    }
+	}
+	// note: this only removes the attr from the Array (attrsList) so that it
+	// doesn't get processed by processAttrs.
+	// By default it does NOT remove it from the map (attrsMap) because the map is
+	// needed during codegen.
+	function getAndRemoveAttr(el, name, removeFromMap) {
+	    let val;
+	    if ((val = el.attrsMap[name]) != null) {
+	        const list = el.attrsList;
+	        for (let i = 0, l = list.length; i < l; i++) {
+	            if (list[i].name === name) {
+	                list.splice(i, 1);
+	                break;
+	            }
+	        }
+	    }
+	    if (removeFromMap) {
+	        delete el.attrsMap[name];
+	    }
+	    return val;
+	}
+	function getAndRemoveAttrByRegex(el, name) {
+	    const list = el.attrsList;
+	    for (let i = 0, l = list.length; i < l; i++) {
+	        const attr = list[i];
+	        if (name.test(attr.name)) {
+	            list.splice(i, 1);
+	            return attr;
+	        }
+	    }
+	}
+	function rangeSetItem(item, range) {
+	    if (range) {
+	        if (range.start != null) {
+	            item.start = range.start;
+	        }
+	        if (range.end != null) {
+	            item.end = range.end;
+	        }
+	    }
+	    return item;
+	}
+
+	function transformNode$1(el, options) {
+	    const warn = options.warn || baseWarn;
+	    const staticClass = getAndRemoveAttr(el, 'class');
+	    if (staticClass) {
+	        const res = parseText(staticClass, options.delimiters);
+	        if (res) {
+	            warn(`class="${staticClass}": ` +
+	                'Interpolation inside attributes has been removed. ' +
+	                'Use v-bind or the colon shorthand instead. For example, ' +
+	                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+	        }
+	    }
+	    if (staticClass) {
+	        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+	    }
+	    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+	    if (classBinding) {
+	        el.classBinding = classBinding;
+	    }
+	}
+	function genData$2(el) {
+	    let data = '';
+	    if (el.staticClass) {
+	        data += `staticClass:${el.staticClass},`;
+	    }
+	    if (el.classBinding) {
+	        data += `class:${el.classBinding},`;
+	    }
+	    return data;
+	}
+	var klass = {
+	    staticKeys: ['staticClass'],
+	    transformNode: transformNode$1,
+	    genData: genData$2,
+	};
+
+	const parseStyleText = cached(function (cssText) {
+	    const res = {};
+	    const listDelimiter = /;(?![^(]*\))/g;
+	    const propertyDelimiter = /:(.+)/;
+	    cssText.split(listDelimiter).forEach(function (item) {
+	        if (item) {
+	            const tmp = item.split(propertyDelimiter);
+	            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+	        }
+	    });
+	    return res;
+	});
+
+	function transformNode(el, options) {
+	    const warn = options.warn || baseWarn;
+	    const staticStyle = getAndRemoveAttr(el, 'style');
+	    if (staticStyle) {
+	        /* istanbul ignore if */
+	        {
+	            const res = parseText(staticStyle, options.delimiters);
+	            if (res) {
+	                warn(`style="${staticStyle}": ` +
+	                    'Interpolation inside attributes has been removed. ' +
+	                    'Use v-bind or the colon shorthand instead. For example, ' +
+	                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+	            }
+	        }
+	        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+	    }
+	    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+	    if (styleBinding) {
+	        el.styleBinding = styleBinding;
+	    }
+	}
+	function genData$1(el) {
+	    let data = '';
+	    if (el.staticStyle) {
+	        data += `staticStyle:${el.staticStyle},`;
+	    }
+	    if (el.styleBinding) {
+	        data += `style:(${el.styleBinding}),`;
+	    }
+	    return data;
+	}
+	var style = {
+	    staticKeys: ['staticStyle'],
+	    transformNode,
+	    genData: genData$1,
+	};
+
+	var he$1 = {exports: {}};
+
+	/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+
+	(function (module, exports) {
+	(function(root) {
+
+			// Detect free variables `exports`.
+			var freeExports = exports;
+
+			// Detect free variable `module`.
+			var freeModule = module &&
+				module.exports == freeExports && module;
+
+			// Detect free variable `global`, from Node.js or Browserified code,
+			// and use it as `root`.
+			var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
+			if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+				root = freeGlobal;
+			}
+
+			/*--------------------------------------------------------------------------*/
+
+			// All astral symbols.
+			var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+			// All ASCII symbols (not just printable ASCII) except those listed in the
+			// first column of the overrides table.
+			// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+			var regexAsciiWhitelist = /[\x01-\x7F]/g;
+			// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+			// code points listed in the first column of the overrides table on
+			// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+			var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
+
+			var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
+			var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
+
+			var regexEscape = /["&'<>`]/g;
+			var escapeMap = {
+				'"': '&quot;',
+				'&': '&amp;',
+				'\'': '&#x27;',
+				'<': '&lt;',
+				// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+				// following is not strictly necessary unless it’s part of a tag or an
+				// unquoted attribute value. We’re only escaping it to support those
+				// situations, and for XML support.
+				'>': '&gt;',
+				// In Internet Explorer ≤ 8, the backtick character can be used
+				// to break out of (un)quoted attribute values or HTML comments.
+				// See http://html5sec.org/#102, http://html5sec.org/#108, and
+				// http://html5sec.org/#133.
+				'`': '&#x60;'
+			};
+
+			var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
+			var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+			var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
+			var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
+			var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
+			var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
+			var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
+
+			/*--------------------------------------------------------------------------*/
+
+			var stringFromCharCode = String.fromCharCode;
+
+			var object = {};
+			var hasOwnProperty = object.hasOwnProperty;
+			var has = function(object, propertyName) {
+				return hasOwnProperty.call(object, propertyName);
+			};
+
+			var contains = function(array, value) {
+				var index = -1;
+				var length = array.length;
+				while (++index < length) {
+					if (array[index] == value) {
+						return true;
+					}
+				}
+				return false;
+			};
+
+			var merge = function(options, defaults) {
+				if (!options) {
+					return defaults;
+				}
+				var result = {};
+				var key;
+				for (key in defaults) {
+					// A `hasOwnProperty` check is not needed here, since only recognized
+					// option names are used anyway. Any others are ignored.
+					result[key] = has(options, key) ? options[key] : defaults[key];
+				}
+				return result;
+			};
+
+			// Modified version of `ucs2encode`; see https://mths.be/punycode.
+			var codePointToSymbol = function(codePoint, strict) {
+				var output = '';
+				if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
+					// See issue #4:
+					// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+					// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+					// REPLACEMENT CHARACTER.”
+					if (strict) {
+						parseError('character reference outside the permissible Unicode range');
+					}
+					return '\uFFFD';
+				}
+				if (has(decodeMapNumeric, codePoint)) {
+					if (strict) {
+						parseError('disallowed character reference');
+					}
+					return decodeMapNumeric[codePoint];
+				}
+				if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+					parseError('disallowed character reference');
+				}
+				if (codePoint > 0xFFFF) {
+					codePoint -= 0x10000;
+					output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
+					codePoint = 0xDC00 | codePoint & 0x3FF;
+				}
+				output += stringFromCharCode(codePoint);
+				return output;
+			};
+
+			var hexEscape = function(codePoint) {
+				return '&#x' + codePoint.toString(16).toUpperCase() + ';';
+			};
+
+			var decEscape = function(codePoint) {
+				return '&#' + codePoint + ';';
+			};
+
+			var parseError = function(message) {
+				throw Error('Parse error: ' + message);
+			};
+
+			/*--------------------------------------------------------------------------*/
+
+			var encode = function(string, options) {
+				options = merge(options, encode.options);
+				var strict = options.strict;
+				if (strict && regexInvalidRawCodePoint.test(string)) {
+					parseError('forbidden code point');
+				}
+				var encodeEverything = options.encodeEverything;
+				var useNamedReferences = options.useNamedReferences;
+				var allowUnsafeSymbols = options.allowUnsafeSymbols;
+				var escapeCodePoint = options.decimal ? decEscape : hexEscape;
+
+				var escapeBmpSymbol = function(symbol) {
+					return escapeCodePoint(symbol.charCodeAt(0));
+				};
+
+				if (encodeEverything) {
+					// Encode ASCII symbols.
+					string = string.replace(regexAsciiWhitelist, function(symbol) {
+						// Use named references if requested & possible.
+						if (useNamedReferences && has(encodeMap, symbol)) {
+							return '&' + encodeMap[symbol] + ';';
+						}
+						return escapeBmpSymbol(symbol);
+					});
+					// Shorten a few escapes that represent two symbols, of which at least one
+					// is within the ASCII range.
+					if (useNamedReferences) {
+						string = string
+							.replace(/&gt;\u20D2/g, '&nvgt;')
+							.replace(/&lt;\u20D2/g, '&nvlt;')
+							.replace(/&#x66;&#x6A;/g, '&fjlig;');
+					}
+					// Encode non-ASCII symbols.
+					if (useNamedReferences) {
+						// Encode non-ASCII symbols that can be replaced with a named reference.
+						string = string.replace(regexEncodeNonAscii, function(string) {
+							// Note: there is no need to check `has(encodeMap, string)` here.
+							return '&' + encodeMap[string] + ';';
+						});
+					}
+					// Note: any remaining non-ASCII symbols are handled outside of the `if`.
+				} else if (useNamedReferences) {
+					// Apply named character references.
+					// Encode `<>"'&` using named character references.
+					if (!allowUnsafeSymbols) {
+						string = string.replace(regexEscape, function(string) {
+							return '&' + encodeMap[string] + ';'; // no need to check `has()` here
+						});
+					}
+					// Shorten escapes that represent two symbols, of which at least one is
+					// `<>"'&`.
+					string = string
+						.replace(/&gt;\u20D2/g, '&nvgt;')
+						.replace(/&lt;\u20D2/g, '&nvlt;');
+					// Encode non-ASCII symbols that can be replaced with a named reference.
+					string = string.replace(regexEncodeNonAscii, function(string) {
+						// Note: there is no need to check `has(encodeMap, string)` here.
+						return '&' + encodeMap[string] + ';';
+					});
+				} else if (!allowUnsafeSymbols) {
+					// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+					// using named character references.
+					string = string.replace(regexEscape, escapeBmpSymbol);
+				}
+				return string
+					// Encode astral symbols.
+					.replace(regexAstralSymbols, function($0) {
+						// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+						var high = $0.charCodeAt(0);
+						var low = $0.charCodeAt(1);
+						var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
+						return escapeCodePoint(codePoint);
+					})
+					// Encode any remaining BMP symbols that are not printable ASCII symbols
+					// using a hexadecimal escape.
+					.replace(regexBmpWhitelist, escapeBmpSymbol);
+			};
+			// Expose default options (so they can be overridden globally).
+			encode.options = {
+				'allowUnsafeSymbols': false,
+				'encodeEverything': false,
+				'strict': false,
+				'useNamedReferences': false,
+				'decimal' : false
+			};
+
+			var decode = function(html, options) {
+				options = merge(options, decode.options);
+				var strict = options.strict;
+				if (strict && regexInvalidEntity.test(html)) {
+					parseError('malformed character reference');
+				}
+				return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+					var codePoint;
+					var semicolon;
+					var decDigits;
+					var hexDigits;
+					var reference;
+					var next;
+
+					if ($1) {
+						reference = $1;
+						// Note: there is no need to check `has(decodeMap, reference)`.
+						return decodeMap[reference];
+					}
+
+					if ($2) {
+						// Decode named character references without trailing `;`, e.g. `&amp`.
+						// This is only a parse error if it gets converted to `&`, or if it is
+						// followed by `=` in an attribute context.
+						reference = $2;
+						next = $3;
+						if (next && options.isAttributeValue) {
+							if (strict && next == '=') {
+								parseError('`&` did not start a character reference');
+							}
+							return $0;
+						} else {
+							if (strict) {
+								parseError(
+									'named character reference was not terminated by a semicolon'
+								);
+							}
+							// Note: there is no need to check `has(decodeMapLegacy, reference)`.
+							return decodeMapLegacy[reference] + (next || '');
+						}
+					}
+
+					if ($4) {
+						// Decode decimal escapes, e.g. `&#119558;`.
+						decDigits = $4;
+						semicolon = $5;
+						if (strict && !semicolon) {
+							parseError('character reference was not terminated by a semicolon');
+						}
+						codePoint = parseInt(decDigits, 10);
+						return codePointToSymbol(codePoint, strict);
+					}
+
+					if ($6) {
+						// Decode hexadecimal escapes, e.g. `&#x1D306;`.
+						hexDigits = $6;
+						semicolon = $7;
+						if (strict && !semicolon) {
+							parseError('character reference was not terminated by a semicolon');
+						}
+						codePoint = parseInt(hexDigits, 16);
+						return codePointToSymbol(codePoint, strict);
+					}
+
+					// If we’re still here, `if ($7)` is implied; it’s an ambiguous
+					// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+					if (strict) {
+						parseError(
+							'named character reference was not terminated by a semicolon'
+						);
+					}
+					return $0;
+				});
+			};
+			// Expose default options (so they can be overridden globally).
+			decode.options = {
+				'isAttributeValue': false,
+				'strict': false
+			};
+
+			var escape = function(string) {
+				return string.replace(regexEscape, function($0) {
+					// Note: there is no need to check `has(escapeMap, $0)` here.
+					return escapeMap[$0];
+				});
+			};
+
+			/*--------------------------------------------------------------------------*/
+
+			var he = {
+				'version': '1.2.0',
+				'encode': encode,
+				'decode': decode,
+				'escape': escape,
+				'unescape': decode
+			};
+
+			// Some AMD build optimizers, like r.js, check for specific condition patterns
+			// like the following:
+			if (freeExports && !freeExports.nodeType) {
+				if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
+					freeModule.exports = he;
+				} else { // in Narwhal or RingoJS v0.7.0-
+					for (var key in he) {
+						has(he, key) && (freeExports[key] = he[key]);
+					}
+				}
+			} else { // in Rhino or a web browser
+				root.he = he;
+			}
+
+		}(commonjsGlobal));
+	} (he$1, he$1.exports));
+
+	var he = he$1.exports;
+
+	/**
+	 * Cross-platform code generation for component v-model
+	 */
+	function genComponentModel(el, value, modifiers) {
+	    const { number, trim } = modifiers || {};
+	    const baseValueExpression = '$$v';
+	    let valueExpression = baseValueExpression;
+	    if (trim) {
+	        valueExpression =
+	            `(typeof ${baseValueExpression} === 'string'` +
+	                `? ${baseValueExpression}.trim()` +
+	                `: ${baseValueExpression})`;
+	    }
+	    if (number) {
+	        valueExpression = `_n(${valueExpression})`;
+	    }
+	    const assignment = genAssignmentCode(value, valueExpression);
+	    el.model = {
+	        value: `(${value})`,
+	        expression: JSON.stringify(value),
+	        callback: `function (${baseValueExpression}) {${assignment}}`,
+	    };
+	}
+	/**
+	 * Cross-platform codegen helper for generating v-model value assignment code.
+	 */
+	function genAssignmentCode(value, assignment) {
+	    const res = parseModel(value);
+	    if (res.key === null) {
+	        return `${value}=${assignment}`;
+	    }
+	    else {
+	        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+	    }
+	}
+	/**
+	 * Parse a v-model expression into a base path and a final key segment.
+	 * Handles both dot-path and possible square brackets.
+	 *
+	 * Possible cases:
+	 *
+	 * - test
+	 * - test[key]
+	 * - test[test1[key]]
+	 * - test["a"][key]
+	 * - xxx.test[a[a].test1[key]]
+	 * - test.xxx.a["asa"][test1[key]]
+	 *
+	 */
+	let len, str, chr, index, expressionPos, expressionEndPos;
+	function parseModel(val) {
+	    // Fix https://github.com/vuejs/vue/pull/7730
+	    // allow v-model="obj.val " (trailing whitespace)
+	    val = val.trim();
+	    len = val.length;
+	    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+	        index = val.lastIndexOf('.');
+	        if (index > -1) {
+	            return {
+	                exp: val.slice(0, index),
+	                key: '"' + val.slice(index + 1) + '"',
+	            };
+	        }
+	        else {
+	            return {
+	                exp: val,
+	                key: null,
+	            };
+	        }
+	    }
+	    str = val;
+	    index = expressionPos = expressionEndPos = 0;
+	    while (!eof()) {
+	        chr = next();
+	        /* istanbul ignore if */
+	        if (isStringStart(chr)) {
+	            parseString(chr);
+	        }
+	        else if (chr === 0x5b) {
+	            parseBracket(chr);
+	        }
+	    }
+	    return {
+	        exp: val.slice(0, expressionPos),
+	        key: val.slice(expressionPos + 1, expressionEndPos),
+	    };
+	}
+	function next() {
+	    return str.charCodeAt(++index);
+	}
+	function eof() {
+	    return index >= len;
+	}
+	function isStringStart(chr) {
+	    return chr === 0x22 || chr === 0x27;
+	}
+	function parseBracket(chr) {
+	    let inBracket = 1;
+	    expressionPos = index;
+	    while (!eof()) {
+	        chr = next();
+	        if (isStringStart(chr)) {
+	            parseString(chr);
+	            continue;
+	        }
+	        if (chr === 0x5b)
+	            inBracket++;
+	        if (chr === 0x5d)
+	            inBracket--;
+	        if (inBracket === 0) {
+	            expressionEndPos = index;
+	            break;
+	        }
+	    }
+	}
+	function parseString(chr) {
+	    const stringQuote = chr;
+	    while (!eof()) {
+	        chr = next();
+	        if (chr === stringQuote) {
+	            break;
+	        }
+	    }
+	}
+
+	const onRE = /^@|^v-on:/;
+	const dirRE = /^v-|^@|^:|^#/;
+	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+	const stripParensRE = /^\(|\)$/g;
+	const dynamicArgRE = /^\[.*\]$/;
+	const argRE = /:(.*)$/;
+	const bindRE = /^:|^\.|^v-bind:/;
+	const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+	const slotRE = /^v-slot(:|$)|^#/;
+	const lineBreakRE = /[\r\n]/;
+	const whitespaceRE = /[ \f\t\r\n]+/g;
+	const invalidAttributeRE = /[\s"'<>\/=]/;
+	const decodeHTMLCached = cached(he.decode);
+	const emptySlotScopeToken = `_empty_`;
+	// configurable state
+	let warn$1;
+	let delimiters;
+	let transforms;
+	let preTransforms;
+	let postTransforms;
+	let platformIsPreTag;
+	let platformMustUseProp;
+	let platformGetTagNamespace;
+	let maybeComponent;
+	function createASTElement(tag, attrs, parent) {
+	    return {
+	        type: 1,
+	        tag,
+	        attrsList: attrs,
+	        attrsMap: makeAttrsMap(attrs),
+	        rawAttrsMap: {},
+	        parent,
+	        children: [],
+	    };
+	}
+	/**
+	 * Convert HTML string to AST.
+	 */
+	function parse(template, options) {
+	    warn$1 = options.warn || baseWarn;
+	    platformIsPreTag = options.isPreTag || no;
+	    platformMustUseProp = options.mustUseProp || no;
+	    platformGetTagNamespace = options.getTagNamespace || no;
+	    const isReservedTag = options.isReservedTag || no;
+	    maybeComponent = (el) => !!(el.component ||
+	        el.attrsMap[':is'] ||
+	        el.attrsMap['v-bind:is'] ||
+	        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+	    transforms = pluckModuleFunction(options.modules, 'transformNode');
+	    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+	    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+	    delimiters = options.delimiters;
+	    const stack = [];
+	    const preserveWhitespace = options.preserveWhitespace !== false;
+	    const whitespaceOption = options.whitespace;
+	    let root;
+	    let currentParent;
+	    let inVPre = false;
+	    let inPre = false;
+	    let warned = false;
+	    function warnOnce(msg, range) {
+	        if (!warned) {
+	            warned = true;
+	            warn$1(msg, range);
+	        }
+	    }
+	    function closeElement(element) {
+	        trimEndingWhitespace(element);
+	        if (!inVPre && !element.processed) {
+	            element = processElement(element, options);
+	        }
+	        // tree management
+	        if (!stack.length && element !== root) {
+	            // allow root elements with v-if, v-else-if and v-else
+	            if (root.if && (element.elseif || element.else)) {
+	                {
+	                    checkRootConstraints(element);
+	                }
+	                addIfCondition(root, {
+	                    exp: element.elseif,
+	                    block: element,
+	                });
+	            }
+	            else {
+	                warnOnce(`Component template should contain exactly one root element. ` +
+	                    `If you are using v-if on multiple elements, ` +
+	                    `use v-else-if to chain them instead.`, { start: element.start });
+	            }
+	        }
+	        if (currentParent && !element.forbidden) {
+	            if (element.elseif || element.else) {
+	                processIfConditions(element, currentParent);
+	            }
+	            else {
+	                if (element.slotScope) {
+	                    // scoped slot
+	                    // keep it in the children list so that v-else(-if) conditions can
+	                    // find it as the prev node.
+	                    const name = element.slotTarget || '"default"';
+	                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+	                }
+	                currentParent.children.push(element);
+	                element.parent = currentParent;
+	            }
+	        }
+	        // final children cleanup
+	        // filter out scoped slots
+	        element.children = element.children.filter((c) => !c.slotScope);
+	        // remove trailing whitespace node again
+	        trimEndingWhitespace(element);
+	        // check pre state
+	        if (element.pre) {
+	            inVPre = false;
+	        }
+	        if (platformIsPreTag(element.tag)) {
+	            inPre = false;
+	        }
+	        // apply post-transforms
+	        for (let i = 0; i < postTransforms.length; i++) {
+	            postTransforms[i](element, options);
+	        }
+	    }
+	    function trimEndingWhitespace(el) {
+	        // remove trailing whitespace node
+	        if (!inPre) {
+	            let lastNode;
+	            while ((lastNode = el.children[el.children.length - 1]) &&
+	                lastNode.type === 3 &&
+	                lastNode.text === ' ') {
+	                el.children.pop();
+	            }
+	        }
+	    }
+	    function checkRootConstraints(el) {
+	        if (el.tag === 'slot' || el.tag === 'template') {
+	            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+	                'contain multiple nodes.', { start: el.start });
+	        }
+	        if (el.attrsMap.hasOwnProperty('v-for')) {
+	            warnOnce('Cannot use v-for on stateful component root element because ' +
+	                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+	        }
+	    }
+	    parseHTML(template, {
+	        warn: warn$1,
+	        expectHTML: options.expectHTML,
+	        isUnaryTag: options.isUnaryTag,
+	        canBeLeftOpenTag: options.canBeLeftOpenTag,
+	        shouldDecodeNewlines: options.shouldDecodeNewlines,
+	        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+	        shouldKeepComment: options.comments,
+	        outputSourceRange: options.outputSourceRange,
+	        start(tag, attrs, unary, start, end) {
+	            // check namespace.
+	            // inherit parent ns if there is one
+	            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+	            // handle IE svg bug
+	            /* istanbul ignore if */
+	            if (isIE && ns === 'svg') {
+	                attrs = guardIESVGBug(attrs);
+	            }
+	            let element = createASTElement(tag, attrs, currentParent);
+	            if (ns) {
+	                element.ns = ns;
+	            }
+	            {
+	                if (options.outputSourceRange) {
+	                    element.start = start;
+	                    element.end = end;
+	                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+	                        cumulated[attr.name] = attr;
+	                        return cumulated;
+	                    }, {});
+	                }
+	                attrs.forEach((attr) => {
+	                    if (invalidAttributeRE.test(attr.name)) {
+	                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+	                            `spaces, quotes, <, >, / or =.`, {
+	                            start: attr.start + attr.name.indexOf(`[`),
+	                            end: attr.start + attr.name.length,
+	                        });
+	                    }
+	                });
+	            }
+	            if (isForbiddenTag(element) && !isServerRendering()) {
+	                element.forbidden = true;
+	                warn$1('Templates should only be responsible for mapping the state to the ' +
+	                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+	                        `<${tag}>` +
+	                        ', as they will not be parsed.', { start: element.start });
+	            }
+	            // apply pre-transforms
+	            for (let i = 0; i < preTransforms.length; i++) {
+	                element = preTransforms[i](element, options) || element;
+	            }
+	            if (!inVPre) {
+	                processPre(element);
+	                if (element.pre) {
+	                    inVPre = true;
+	                }
+	            }
+	            if (platformIsPreTag(element.tag)) {
+	                inPre = true;
+	            }
+	            if (inVPre) {
+	                processRawAttrs(element);
+	            }
+	            else if (!element.processed) {
+	                // structural directives
+	                processFor(element);
+	                processIf(element);
+	                processOnce(element);
+	            }
+	            if (!root) {
+	                root = element;
+	                {
+	                    checkRootConstraints(root);
+	                }
+	            }
+	            if (!unary) {
+	                currentParent = element;
+	                stack.push(element);
+	            }
+	            else {
+	                closeElement(element);
+	            }
+	        },
+	        end(tag, start, end) {
+	            const element = stack[stack.length - 1];
+	            // pop stack
+	            stack.length -= 1;
+	            currentParent = stack[stack.length - 1];
+	            if (options.outputSourceRange) {
+	                element.end = end;
+	            }
+	            closeElement(element);
+	        },
+	        chars(text, start, end) {
+	            if (!currentParent) {
+	                {
+	                    if (text === template) {
+	                        warnOnce('Component template requires a root element, rather than just text.', { start });
+	                    }
+	                    else if ((text = text.trim())) {
+	                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+	                            start,
+	                        });
+	                    }
+	                }
+	                return;
+	            }
+	            // IE textarea placeholder bug
+	            /* istanbul ignore if */
+	            if (isIE &&
+	                currentParent.tag === 'textarea' &&
+	                currentParent.attrsMap.placeholder === text) {
+	                return;
+	            }
+	            const children = currentParent.children;
+	            if (inPre || text.trim()) {
+	                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+	            }
+	            else if (!children.length) {
+	                // remove the whitespace-only node right after an opening tag
+	                text = '';
+	            }
+	            else if (whitespaceOption) {
+	                if (whitespaceOption === 'condense') {
+	                    // in condense mode, remove the whitespace node if it contains
+	                    // line break, otherwise condense to a single space
+	                    text = lineBreakRE.test(text) ? '' : ' ';
+	                }
+	                else {
+	                    text = ' ';
+	                }
+	            }
+	            else {
+	                text = preserveWhitespace ? ' ' : '';
+	            }
+	            if (text) {
+	                if (!inPre && whitespaceOption === 'condense') {
+	                    // condense consecutive whitespaces into single space
+	                    text = text.replace(whitespaceRE, ' ');
+	                }
+	                let res;
+	                let child;
+	                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+	                    child = {
+	                        type: 2,
+	                        expression: res.expression,
+	                        tokens: res.tokens,
+	                        text,
+	                    };
+	                }
+	                else if (text !== ' ' ||
+	                    !children.length ||
+	                    children[children.length - 1].text !== ' ') {
+	                    child = {
+	                        type: 3,
+	                        text,
+	                    };
+	                }
+	                if (child) {
+	                    if (options.outputSourceRange) {
+	                        child.start = start;
+	                        child.end = end;
+	                    }
+	                    children.push(child);
+	                }
+	            }
+	        },
+	        comment(text, start, end) {
+	            // adding anything as a sibling to the root node is forbidden
+	            // comments should still be allowed, but ignored
+	            if (currentParent) {
+	                const child = {
+	                    type: 3,
+	                    text,
+	                    isComment: true,
+	                };
+	                if (options.outputSourceRange) {
+	                    child.start = start;
+	                    child.end = end;
+	                }
+	                currentParent.children.push(child);
+	            }
+	        },
+	    });
+	    return root;
+	}
+	function processPre(el) {
+	    if (getAndRemoveAttr(el, 'v-pre') != null) {
+	        el.pre = true;
+	    }
+	}
+	function processRawAttrs(el) {
+	    const list = el.attrsList;
+	    const len = list.length;
+	    if (len) {
+	        const attrs = (el.attrs = new Array(len));
+	        for (let i = 0; i < len; i++) {
+	            attrs[i] = {
+	                name: list[i].name,
+	                value: JSON.stringify(list[i].value),
+	            };
+	            if (list[i].start != null) {
+	                attrs[i].start = list[i].start;
+	                attrs[i].end = list[i].end;
+	            }
+	        }
+	    }
+	    else if (!el.pre) {
+	        // non root node in pre blocks with no attributes
+	        el.plain = true;
+	    }
+	}
+	function processElement(element, options) {
+	    processKey(element);
+	    // determine whether this is a plain element after
+	    // removing structural attributes
+	    element.plain =
+	        !element.key && !element.scopedSlots && !element.attrsList.length;
+	    processRef(element);
+	    processSlotContent(element);
+	    processSlotOutlet(element);
+	    processComponent(element);
+	    for (let i = 0; i < transforms.length; i++) {
+	        element = transforms[i](element, options) || element;
+	    }
+	    processAttrs(element);
+	    return element;
+	}
+	function processKey(el) {
+	    const exp = getBindingAttr(el, 'key');
+	    if (exp) {
+	        {
+	            if (el.tag === 'template') {
+	                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+	            }
+	            if (el.for) {
+	                const iterator = el.iterator2 || el.iterator1;
+	                const parent = el.parent;
+	                if (iterator &&
+	                    iterator === exp &&
+	                    parent &&
+	                    parent.tag === 'transition-group') {
+	                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+	                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+	                }
+	            }
+	        }
+	        el.key = exp;
+	    }
+	}
+	function processRef(el) {
+	    const ref = getBindingAttr(el, 'ref');
+	    if (ref) {
+	        el.ref = ref;
+	        el.refInFor = checkInFor(el);
+	    }
+	}
+	function processFor(el) {
+	    let exp;
+	    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+	        const res = parseFor(exp);
+	        if (res) {
+	            extend(el, res);
+	        }
+	        else {
+	            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+	        }
+	    }
+	}
+	function parseFor(exp) {
+	    const inMatch = exp.match(forAliasRE);
+	    if (!inMatch)
+	        return;
+	    const res = {};
+	    res.for = inMatch[2].trim();
+	    const alias = inMatch[1].trim().replace(stripParensRE, '');
+	    const iteratorMatch = alias.match(forIteratorRE);
+	    if (iteratorMatch) {
+	        res.alias = alias.replace(forIteratorRE, '').trim();
+	        res.iterator1 = iteratorMatch[1].trim();
+	        if (iteratorMatch[2]) {
+	            res.iterator2 = iteratorMatch[2].trim();
+	        }
+	    }
+	    else {
+	        res.alias = alias;
+	    }
+	    return res;
+	}
+	function processIf(el) {
+	    const exp = getAndRemoveAttr(el, 'v-if');
+	    if (exp) {
+	        el.if = exp;
+	        addIfCondition(el, {
+	            exp: exp,
+	            block: el,
+	        });
+	    }
+	    else {
+	        if (getAndRemoveAttr(el, 'v-else') != null) {
+	            el.else = true;
+	        }
+	        const elseif = getAndRemoveAttr(el, 'v-else-if');
+	        if (elseif) {
+	            el.elseif = elseif;
+	        }
+	    }
+	}
+	function processIfConditions(el, parent) {
+	    const prev = findPrevElement(parent.children);
+	    if (prev && prev.if) {
+	        addIfCondition(prev, {
+	            exp: el.elseif,
+	            block: el,
+	        });
+	    }
+	    else {
+	        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+	            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+	    }
+	}
+	function findPrevElement(children) {
+	    let i = children.length;
+	    while (i--) {
+	        if (children[i].type === 1) {
+	            return children[i];
+	        }
+	        else {
+	            if (children[i].text !== ' ') {
+	                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+	                    `will be ignored.`, children[i]);
+	            }
+	            children.pop();
+	        }
+	    }
+	}
+	function addIfCondition(el, condition) {
+	    if (!el.ifConditions) {
+	        el.ifConditions = [];
+	    }
+	    el.ifConditions.push(condition);
+	}
+	function processOnce(el) {
+	    const once = getAndRemoveAttr(el, 'v-once');
+	    if (once != null) {
+	        el.once = true;
+	    }
+	}
+	// handle content being passed to a component as slot,
+	// e.g. <template slot="xxx">, <div slot-scope="xxx">
+	function processSlotContent(el) {
+	    let slotScope;
+	    if (el.tag === 'template') {
+	        slotScope = getAndRemoveAttr(el, 'scope');
+	        /* istanbul ignore if */
+	        if (slotScope) {
+	            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+	                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+	                `can also be used on plain elements in addition to <template> to ` +
+	                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+	        }
+	        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+	    }
+	    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+	        /* istanbul ignore if */
+	        if (el.attrsMap['v-for']) {
+	            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+	                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+	                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+	        }
+	        el.slotScope = slotScope;
+	    }
+	    // slot="xxx"
+	    const slotTarget = getBindingAttr(el, 'slot');
+	    if (slotTarget) {
+	        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+	        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+	        // preserve slot as an attribute for native shadow DOM compat
+	        // only for non-scoped slots.
+	        if (el.tag !== 'template' && !el.slotScope) {
+	            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+	        }
+	    }
+	    // 2.6 v-slot syntax
+	    {
+	        if (el.tag === 'template') {
+	            // v-slot on <template>
+	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+	            if (slotBinding) {
+	                {
+	                    if (el.slotTarget || el.slotScope) {
+	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+	                    }
+	                    if (el.parent && !maybeComponent(el.parent)) {
+	                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+	                            `the receiving component`, el);
+	                    }
+	                }
+	                const { name, dynamic } = getSlotName(slotBinding);
+	                el.slotTarget = name;
+	                el.slotTargetDynamic = dynamic;
+	                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+	            }
+	        }
+	        else {
+	            // v-slot on component, denotes default slot
+	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+	            if (slotBinding) {
+	                {
+	                    if (!maybeComponent(el)) {
+	                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+	                    }
+	                    if (el.slotScope || el.slotTarget) {
+	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+	                    }
+	                    if (el.scopedSlots) {
+	                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+	                            `<template> syntax when there are other named slots.`, slotBinding);
+	                    }
+	                }
+	                // add the component's children to its default slot
+	                const slots = el.scopedSlots || (el.scopedSlots = {});
+	                const { name, dynamic } = getSlotName(slotBinding);
+	                const slotContainer = (slots[name] = createASTElement('template', [], el));
+	                slotContainer.slotTarget = name;
+	                slotContainer.slotTargetDynamic = dynamic;
+	                slotContainer.children = el.children.filter((c) => {
+	                    if (!c.slotScope) {
+	                        c.parent = slotContainer;
+	                        return true;
+	                    }
+	                });
+	                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+	                // remove children as they are returned from scopedSlots now
+	                el.children = [];
+	                // mark el non-plain so data gets generated
+	                el.plain = false;
+	            }
+	        }
+	    }
+	}
+	function getSlotName(binding) {
+	    let name = binding.name.replace(slotRE, '');
+	    if (!name) {
+	        if (binding.name[0] !== '#') {
+	            name = 'default';
+	        }
+	        else {
+	            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+	        }
+	    }
+	    return dynamicArgRE.test(name)
+	        ? // dynamic [name]
+	            { name: name.slice(1, -1), dynamic: true }
+	        : // static name
+	            { name: `"${name}"`, dynamic: false };
+	}
+	// handle <slot/> outlets
+	function processSlotOutlet(el) {
+	    if (el.tag === 'slot') {
+	        el.slotName = getBindingAttr(el, 'name');
+	        if (el.key) {
+	            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+	                `and can possibly expand into multiple elements. ` +
+	                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+	        }
+	    }
+	}
+	function processComponent(el) {
+	    let binding;
+	    if ((binding = getBindingAttr(el, 'is'))) {
+	        el.component = binding;
+	    }
+	    if (getAndRemoveAttr(el, 'inline-template') != null) {
+	        el.inlineTemplate = true;
+	    }
+	}
+	function processAttrs(el) {
+	    const list = el.attrsList;
+	    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+	    for (i = 0, l = list.length; i < l; i++) {
+	        name = rawName = list[i].name;
+	        value = list[i].value;
+	        if (dirRE.test(name)) {
+	            // mark element as dynamic
+	            el.hasBindings = true;
+	            // modifiers
+	            modifiers = parseModifiers(name.replace(dirRE, ''));
+	            // support .foo shorthand syntax for the .prop modifier
+	            if (modifiers) {
+	                name = name.replace(modifierRE, '');
+	            }
+	            if (bindRE.test(name)) {
+	                // v-bind
+	                name = name.replace(bindRE, '');
+	                value = parseFilters(value);
+	                isDynamic = dynamicArgRE.test(name);
+	                if (isDynamic) {
+	                    name = name.slice(1, -1);
+	                }
+	                if (value.trim().length === 0) {
+	                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+	                }
+	                if (modifiers) {
+	                    if (modifiers.prop && !isDynamic) {
+	                        name = camelize(name);
+	                        if (name === 'innerHtml')
+	                            name = 'innerHTML';
+	                    }
+	                    if (modifiers.camel && !isDynamic) {
+	                        name = camelize(name);
+	                    }
+	                    if (modifiers.sync) {
+	                        syncGen = genAssignmentCode(value, `$event`);
+	                        if (!isDynamic) {
+	                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+	                            if (hyphenate(name) !== camelize(name)) {
+	                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+	                            }
+	                        }
+	                        else {
+	                            // handler w/ dynamic event name
+	                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+	                            );
+	                        }
+	                    }
+	                }
+	                if ((modifiers && modifiers.prop) ||
+	                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+	                    addProp(el, name, value, list[i], isDynamic);
+	                }
+	                else {
+	                    addAttr(el, name, value, list[i], isDynamic);
+	                }
+	            }
+	            else if (onRE.test(name)) {
+	                // v-on
+	                name = name.replace(onRE, '');
+	                isDynamic = dynamicArgRE.test(name);
+	                if (isDynamic) {
+	                    name = name.slice(1, -1);
+	                }
+	                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+	            }
+	            else {
+	                // normal directives
+	                name = name.replace(dirRE, '');
+	                // parse arg
+	                const argMatch = name.match(argRE);
+	                let arg = argMatch && argMatch[1];
+	                isDynamic = false;
+	                if (arg) {
+	                    name = name.slice(0, -(arg.length + 1));
+	                    if (dynamicArgRE.test(arg)) {
+	                        arg = arg.slice(1, -1);
+	                        isDynamic = true;
+	                    }
+	                }
+	                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+	                if (name === 'model') {
+	                    checkForAliasModel(el, value);
+	                }
+	            }
+	        }
+	        else {
+	            // literal attribute
+	            {
+	                const res = parseText(value, delimiters);
+	                if (res) {
+	                    warn$1(`${name}="${value}": ` +
+	                        'Interpolation inside attributes has been removed. ' +
+	                        'Use v-bind or the colon shorthand instead. For example, ' +
+	                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+	                }
+	            }
+	            addAttr(el, name, JSON.stringify(value), list[i]);
+	            // #6887 firefox doesn't update muted state if set via attribute
+	            // even immediately after element creation
+	            if (!el.component &&
+	                name === 'muted' &&
+	                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+	                addProp(el, name, 'true', list[i]);
+	            }
+	        }
+	    }
+	}
+	function checkInFor(el) {
+	    let parent = el;
+	    while (parent) {
+	        if (parent.for !== undefined) {
+	            return true;
+	        }
+	        parent = parent.parent;
+	    }
+	    return false;
+	}
+	function parseModifiers(name) {
+	    const match = name.match(modifierRE);
+	    if (match) {
+	        const ret = {};
+	        match.forEach((m) => {
+	            ret[m.slice(1)] = true;
+	        });
+	        return ret;
+	    }
+	}
+	function makeAttrsMap(attrs) {
+	    const map = {};
+	    for (let i = 0, l = attrs.length; i < l; i++) {
+	        if (map[attrs[i].name] &&
+	            !isIE &&
+	            !isEdge) {
+	            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+	        }
+	        map[attrs[i].name] = attrs[i].value;
+	    }
+	    return map;
+	}
+	// for script (e.g. type="x/template") or style, do not decode content
+	function isTextTag(el) {
+	    return el.tag === 'script' || el.tag === 'style';
+	}
+	function isForbiddenTag(el) {
+	    return (el.tag === 'style' ||
+	        (el.tag === 'script' &&
+	            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+	}
+	const ieNSBug = /^xmlns:NS\d+/;
+	const ieNSPrefix = /^NS\d+:/;
+	/* istanbul ignore next */
+	function guardIESVGBug(attrs) {
+	    const res = [];
+	    for (let i = 0; i < attrs.length; i++) {
+	        const attr = attrs[i];
+	        if (!ieNSBug.test(attr.name)) {
+	            attr.name = attr.name.replace(ieNSPrefix, '');
+	            res.push(attr);
+	        }
+	    }
+	    return res;
+	}
+	function checkForAliasModel(el, value) {
+	    let _el = el;
+	    while (_el) {
+	        if (_el.for && _el.alias === value) {
+	            warn$1(`<${el.tag} v-model="${value}">: ` +
+	                `You are binding v-model directly to a v-for iteration alias. ` +
+	                `This will not be able to modify the v-for source array because ` +
+	                `writing to the alias is like modifying a function local variable. ` +
+	                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+	        }
+	        _el = _el.parent;
+	    }
+	}
+
+	/**
+	 * Expand input[v-model] with dynamic type bindings into v-if-else chains
+	 * Turn this:
+	 *   <input v-model="data[type]" :type="type">
+	 * into this:
+	 *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+	 *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+	 *   <input v-else :type="type" v-model="data[type]">
+	 */
+	function preTransformNode(el, options) {
+	    if (el.tag === 'input') {
+	        const map = el.attrsMap;
+	        if (!map['v-model']) {
+	            return;
+	        }
+	        let typeBinding;
+	        if (map[':type'] || map['v-bind:type']) {
+	            typeBinding = getBindingAttr(el, 'type');
+	        }
+	        if (!map.type && !typeBinding && map['v-bind']) {
+	            typeBinding = `(${map['v-bind']}).type`;
+	        }
+	        if (typeBinding) {
+	            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+	            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+	            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+	            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+	            // 1. checkbox
+	            const branch0 = cloneASTElement(el);
+	            // process for on the main node
+	            processFor(branch0);
+	            addRawAttr(branch0, 'type', 'checkbox');
+	            processElement(branch0, options);
+	            branch0.processed = true; // prevent it from double-processed
+	            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+	            addIfCondition(branch0, {
+	                exp: branch0.if,
+	                block: branch0,
+	            });
+	            // 2. add radio else-if condition
+	            const branch1 = cloneASTElement(el);
+	            getAndRemoveAttr(branch1, 'v-for', true);
+	            addRawAttr(branch1, 'type', 'radio');
+	            processElement(branch1, options);
+	            addIfCondition(branch0, {
+	                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+	                block: branch1,
+	            });
+	            // 3. other
+	            const branch2 = cloneASTElement(el);
+	            getAndRemoveAttr(branch2, 'v-for', true);
+	            addRawAttr(branch2, ':type', typeBinding);
+	            processElement(branch2, options);
+	            addIfCondition(branch0, {
+	                exp: ifCondition,
+	                block: branch2,
+	            });
+	            if (hasElse) {
+	                branch0.else = true;
+	            }
+	            else if (elseIfCondition) {
+	                branch0.elseif = elseIfCondition;
+	            }
+	            return branch0;
+	        }
+	    }
+	}
+	function cloneASTElement(el) {
+	    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+	}
+	var model$1 = {
+	    preTransformNode,
+	};
+
+	var modules = [klass, style, model$1];
+
+	let warn;
+	// in some cases, the event used has to be determined at runtime
+	// so we used some reserved tokens during compile.
+	const RANGE_TOKEN = '__r';
+	function model(el, dir, _warn) {
+	    warn = _warn;
+	    const value = dir.value;
+	    const modifiers = dir.modifiers;
+	    const tag = el.tag;
+	    const type = el.attrsMap.type;
+	    {
+	        // inputs with type="file" are read only and setting the input's
+	        // value will throw an error.
+	        if (tag === 'input' && type === 'file') {
+	            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+	                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+	        }
+	    }
+	    if (el.component) {
+	        genComponentModel(el, value, modifiers);
+	        // component v-model doesn't need extra runtime
+	        return false;
+	    }
+	    else if (tag === 'select') {
+	        genSelect(el, value, modifiers);
+	    }
+	    else if (tag === 'input' && type === 'checkbox') {
+	        genCheckboxModel(el, value, modifiers);
+	    }
+	    else if (tag === 'input' && type === 'radio') {
+	        genRadioModel(el, value, modifiers);
+	    }
+	    else if (tag === 'input' || tag === 'textarea') {
+	        genDefaultModel(el, value, modifiers);
+	    }
+	    else {
+	        genComponentModel(el, value, modifiers);
+	        // component v-model doesn't need extra runtime
+	        return false;
+	    }
+	    // ensure runtime directive metadata
+	    return true;
+	}
+	function genCheckboxModel(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    const valueBinding = getBindingAttr(el, 'value') || 'null';
+	    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+	    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+	    addProp(el, 'checked', `Array.isArray(${value})` +
+	        `?_i(${value},${valueBinding})>-1` +
+	        (trueValueBinding === 'true'
+	            ? `:(${value})`
+	            : `:_q(${value},${trueValueBinding})`));
+	    addHandler(el, 'change', `var $$a=${value},` +
+	        '$$el=$event.target,' +
+	        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+	        'if(Array.isArray($$a)){' +
+	        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+	        '$$i=_i($$a,$$v);' +
+	        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+	        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+	        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+	}
+	function genRadioModel(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    let valueBinding = getBindingAttr(el, 'value') || 'null';
+	    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+	    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+	    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+	}
+	function genSelect(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    const selectedVal = `Array.prototype.filter` +
+	        `.call($event.target.options,function(o){return o.selected})` +
+	        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+	        `return ${number ? '_n(val)' : 'val'}})`;
+	    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+	    let code = `var $$selectedVal = ${selectedVal};`;
+	    code = `${code} ${genAssignmentCode(value, assignment)}`;
+	    addHandler(el, 'change', code, null, true);
+	}
+	function genDefaultModel(el, value, modifiers) {
+	    const type = el.attrsMap.type;
+	    // warn if v-bind:value conflicts with v-model
+	    // except for inputs with v-bind:type
+	    {
+	        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+	        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+	        if (value && !typeBinding) {
+	            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+	            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+	                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+	        }
+	    }
+	    const { lazy, number, trim } = modifiers || {};
+	    const needCompositionGuard = !lazy && type !== 'range';
+	    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+	    let valueExpression = '$event.target.value';
+	    if (trim) {
+	        valueExpression = `$event.target.value.trim()`;
+	    }
+	    if (number) {
+	        valueExpression = `_n(${valueExpression})`;
+	    }
+	    let code = genAssignmentCode(value, valueExpression);
+	    if (needCompositionGuard) {
+	        code = `if($event.target.composing)return;${code}`;
+	    }
+	    addProp(el, 'value', `(${value})`);
+	    addHandler(el, event, code, null, true);
+	    if (trim || number) {
+	        addHandler(el, 'blur', '$forceUpdate()');
+	    }
+	}
+
+	function text(el, dir) {
+	    if (dir.value) {
+	        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+	    }
+	}
+
+	function html(el, dir) {
+	    if (dir.value) {
+	        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+	    }
+	}
+
+	var directives = {
+	    model,
+	    text,
+	    html,
+	};
+
+	const baseOptions = {
+	    expectHTML: true,
+	    modules,
+	    directives,
+	    isPreTag,
+	    isUnaryTag,
+	    mustUseProp,
+	    canBeLeftOpenTag,
+	    isReservedTag,
+	    getTagNamespace,
+	    staticKeys: genStaticKeys$1(modules),
+	};
+
+	let isStaticKey;
+	let isPlatformReservedTag$1;
+	const genStaticKeysCached = cached(genStaticKeys);
+	/**
+	 * Goal of the optimizer: walk the generated template AST tree
+	 * and detect sub-trees that are purely static, i.e. parts of
+	 * the DOM that never needs to change.
+	 *
+	 * Once we detect these sub-trees, we can:
+	 *
+	 * 1. Hoist them into constants, so that we no longer need to
+	 *    create fresh nodes for them on each re-render;
+	 * 2. Completely skip them in the patching process.
+	 */
+	function optimize$1(root, options) {
+	    if (!root)
+	        return;
+	    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+	    isPlatformReservedTag$1 = options.isReservedTag || no;
+	    // first pass: mark all non-static nodes.
+	    markStatic(root);
+	    // second pass: mark static roots.
+	    markStaticRoots(root, false);
+	}
+	function genStaticKeys(keys) {
+	    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+	        (keys ? ',' + keys : ''));
+	}
+	function markStatic(node) {
+	    node.static = isStatic(node);
+	    if (node.type === 1) {
+	        // do not make component slot content static. this avoids
+	        // 1. components not able to mutate slot nodes
+	        // 2. static slot content fails for hot-reloading
+	        if (!isPlatformReservedTag$1(node.tag) &&
+	            node.tag !== 'slot' &&
+	            node.attrsMap['inline-template'] == null) {
+	            return;
+	        }
+	        for (let i = 0, l = node.children.length; i < l; i++) {
+	            const child = node.children[i];
+	            markStatic(child);
+	            if (!child.static) {
+	                node.static = false;
+	            }
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                const block = node.ifConditions[i].block;
+	                markStatic(block);
+	                if (!block.static) {
+	                    node.static = false;
+	                }
+	            }
+	        }
+	    }
+	}
+	function markStaticRoots(node, isInFor) {
+	    if (node.type === 1) {
+	        if (node.static || node.once) {
+	            node.staticInFor = isInFor;
+	        }
+	        // For a node to qualify as a static root, it should have children that
+	        // are not just static text. Otherwise the cost of hoisting out will
+	        // outweigh the benefits and it's better off to just always render it fresh.
+	        if (node.static &&
+	            node.children.length &&
+	            !(node.children.length === 1 && node.children[0].type === 3)) {
+	            node.staticRoot = true;
+	            return;
+	        }
+	        else {
+	            node.staticRoot = false;
+	        }
+	        if (node.children) {
+	            for (let i = 0, l = node.children.length; i < l; i++) {
+	                markStaticRoots(node.children[i], isInFor || !!node.for);
+	            }
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                markStaticRoots(node.ifConditions[i].block, isInFor);
+	            }
+	        }
+	    }
+	}
+	function isStatic(node) {
+	    if (node.type === 2) {
+	        // expression
+	        return false;
+	    }
+	    if (node.type === 3) {
+	        // text
+	        return true;
+	    }
+	    return !!(node.pre ||
+	        (!node.hasBindings && // no dynamic bindings
+	            !node.if &&
+	            !node.for && // not v-if or v-for or v-else
+	            !isBuiltInTag(node.tag) && // not a built-in
+	            isPlatformReservedTag$1(node.tag) && // not a component
+	            !isDirectChildOfTemplateFor(node) &&
+	            Object.keys(node).every(isStaticKey)));
+	}
+	function isDirectChildOfTemplateFor(node) {
+	    while (node.parent) {
+	        node = node.parent;
+	        if (node.tag !== 'template') {
+	            return false;
+	        }
+	        if (node.for) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+
+	const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+	const fnInvokeRE = /\([^)]*?\);*$/;
+	const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+	// KeyboardEvent.keyCode aliases
+	const keyCodes = {
+	    esc: 27,
+	    tab: 9,
+	    enter: 13,
+	    space: 32,
+	    up: 38,
+	    left: 37,
+	    right: 39,
+	    down: 40,
+	    delete: [8, 46],
+	};
+	// KeyboardEvent.key aliases
+	const keyNames = {
+	    // #7880: IE11 and Edge use `Esc` for Escape key name.
+	    esc: ['Esc', 'Escape'],
+	    tab: 'Tab',
+	    enter: 'Enter',
+	    // #9112: IE11 uses `Spacebar` for Space key name.
+	    space: [' ', 'Spacebar'],
+	    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+	    up: ['Up', 'ArrowUp'],
+	    left: ['Left', 'ArrowLeft'],
+	    right: ['Right', 'ArrowRight'],
+	    down: ['Down', 'ArrowDown'],
+	    // #9112: IE11 uses `Del` for Delete key name.
+	    delete: ['Backspace', 'Delete', 'Del'],
+	};
+	// #4868: modifiers that prevent the execution of the listener
+	// need to explicitly return null so that we can determine whether to remove
+	// the listener for .once
+	const genGuard = (condition) => `if(${condition})return null;`;
+	const modifierCode = {
+	    stop: '$event.stopPropagation();',
+	    prevent: '$event.preventDefault();',
+	    self: genGuard(`$event.target !== $event.currentTarget`),
+	    ctrl: genGuard(`!$event.ctrlKey`),
+	    shift: genGuard(`!$event.shiftKey`),
+	    alt: genGuard(`!$event.altKey`),
+	    meta: genGuard(`!$event.metaKey`),
+	    left: genGuard(`'button' in $event && $event.button !== 0`),
+	    middle: genGuard(`'button' in $event && $event.button !== 1`),
+	    right: genGuard(`'button' in $event && $event.button !== 2`),
+	};
+	function genHandlers(events, isNative) {
+	    const prefix = isNative ? 'nativeOn:' : 'on:';
+	    let staticHandlers = ``;
+	    let dynamicHandlers = ``;
+	    for (const name in events) {
+	        const handlerCode = genHandler(events[name]);
+	        //@ts-expect-error
+	        if (events[name] && events[name].dynamic) {
+	            dynamicHandlers += `${name},${handlerCode},`;
+	        }
+	        else {
+	            staticHandlers += `"${name}":${handlerCode},`;
+	        }
+	    }
+	    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+	    if (dynamicHandlers) {
+	        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+	    }
+	    else {
+	        return prefix + staticHandlers;
+	    }
+	}
+	function genHandler(handler) {
+	    if (!handler) {
+	        return 'function(){}';
+	    }
+	    if (Array.isArray(handler)) {
+	        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+	    }
+	    const isMethodPath = simplePathRE.test(handler.value);
+	    const isFunctionExpression = fnExpRE.test(handler.value);
+	    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+	    if (!handler.modifiers) {
+	        if (isMethodPath || isFunctionExpression) {
+	            return handler.value;
+	        }
+	        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+	    }
+	    else {
+	        let code = '';
+	        let genModifierCode = '';
+	        const keys = [];
+	        for (const key in handler.modifiers) {
+	            if (modifierCode[key]) {
+	                genModifierCode += modifierCode[key];
+	                // left/right
+	                if (keyCodes[key]) {
+	                    keys.push(key);
+	                }
+	            }
+	            else if (key === 'exact') {
+	                const modifiers = handler.modifiers;
+	                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+	                    .filter((keyModifier) => !modifiers[keyModifier])
+	                    .map((keyModifier) => `$event.${keyModifier}Key`)
+	                    .join('||'));
+	            }
+	            else {
+	                keys.push(key);
+	            }
+	        }
+	        if (keys.length) {
+	            code += genKeyFilter(keys);
+	        }
+	        // Make sure modifiers like prevent and stop get executed after key filtering
+	        if (genModifierCode) {
+	            code += genModifierCode;
+	        }
+	        const handlerCode = isMethodPath
+	            ? `return ${handler.value}.apply(null, arguments)`
+	            : isFunctionExpression
+	                ? `return (${handler.value}).apply(null, arguments)`
+	                : isFunctionInvocation
+	                    ? `return ${handler.value}`
+	                    : handler.value;
+	        return `function($event){${code}${handlerCode}}`;
+	    }
+	}
+	function genKeyFilter(keys) {
+	    return (
+	    // make sure the key filters only apply to KeyboardEvents
+	    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+	    // key events that do not have keyCode property...
+	    `if(!$event.type.indexOf('key')&&` +
+	        `${keys.map(genFilterCode).join('&&')})return null;`);
+	}
+	function genFilterCode(key) {
+	    const keyVal = parseInt(key, 10);
+	    if (keyVal) {
+	        return `$event.keyCode!==${keyVal}`;
+	    }
+	    const keyCode = keyCodes[key];
+	    const keyName = keyNames[key];
+	    return (`_k($event.keyCode,` +
+	        `${JSON.stringify(key)},` +
+	        `${JSON.stringify(keyCode)},` +
+	        `$event.key,` +
+	        `${JSON.stringify(keyName)}` +
+	        `)`);
+	}
+
+	function on(el, dir) {
+	    if (dir.modifiers) {
+	        warn$2(`v-on without argument does not support modifiers.`);
+	    }
+	    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+	}
+
+	function bind(el, dir) {
+	    el.wrapData = (code) => {
+	        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+	    };
+	}
+
+	var baseDirectives = {
+	    on,
+	    bind,
+	    cloak: noop,
+	};
+
+	class CodegenState {
+	    options;
+	    warn;
+	    transforms;
+	    dataGenFns;
+	    directives;
+	    maybeComponent;
+	    onceId;
+	    staticRenderFns;
+	    pre;
+	    constructor(options) {
+	        this.options = options;
+	        this.warn = options.warn || baseWarn;
+	        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+	        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+	        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+	        this.directives = extend(extend({}, baseDirectives), options.directives);
+	        const isReservedTag = options.isReservedTag || no;
+	        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+	        this.onceId = 0;
+	        this.staticRenderFns = [];
+	        this.pre = false;
+	    }
+	}
+	function generate$1(ast, options) {
+	    const state = new CodegenState(options);
+	    // fix #11483, Root level <script> tags should not be rendered.
+	    const code = ast
+	        ? ast.tag === 'script'
+	            ? 'null'
+	            : genElement(ast, state)
+	        : '_c("div")';
+	    return {
+	        render: `with(this){return ${code}}`,
+	        staticRenderFns: state.staticRenderFns,
+	    };
+	}
+	function genElement(el, state) {
+	    if (el.parent) {
+	        el.pre = el.pre || el.parent.pre;
+	    }
+	    if (el.staticRoot && !el.staticProcessed) {
+	        return genStatic(el, state);
+	    }
+	    else if (el.once && !el.onceProcessed) {
+	        return genOnce(el, state);
+	    }
+	    else if (el.for && !el.forProcessed) {
+	        return genFor(el, state);
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        return genIf(el, state);
+	    }
+	    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+	        return genChildren(el, state) || 'void 0';
+	    }
+	    else if (el.tag === 'slot') {
+	        return genSlot(el, state);
+	    }
+	    else {
+	        // component or element
+	        let code;
+	        if (el.component) {
+	            code = genComponent(el.component, el, state);
+	        }
+	        else {
+	            let data;
+	            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+	                data = genData(el, state);
+	            }
+	            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+	            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+	        }
+	        // module transforms
+	        for (let i = 0; i < state.transforms.length; i++) {
+	            code = state.transforms[i](el, code);
+	        }
+	        return code;
+	    }
+	}
+	// hoist static sub-trees out
+	function genStatic(el, state) {
+	    el.staticProcessed = true;
+	    // Some elements (templates) need to behave differently inside of a v-pre
+	    // node.  All pre nodes are static roots, so we can use this as a location to
+	    // wrap a state change and reset it upon exiting the pre node.
+	    const originalPreState = state.pre;
+	    if (el.pre) {
+	        state.pre = el.pre;
+	    }
+	    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+	    state.pre = originalPreState;
+	    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+	}
+	// v-once
+	function genOnce(el, state) {
+	    el.onceProcessed = true;
+	    if (el.if && !el.ifProcessed) {
+	        return genIf(el, state);
+	    }
+	    else if (el.staticInFor) {
+	        let key = '';
+	        let parent = el.parent;
+	        while (parent) {
+	            if (parent.for) {
+	                key = parent.key;
+	                break;
+	            }
+	            parent = parent.parent;
+	        }
+	        if (!key) {
+	            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+	            return genElement(el, state);
+	        }
+	        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+	    }
+	    else {
+	        return genStatic(el, state);
+	    }
+	}
+	function genIf(el, state, altGen, altEmpty) {
+	    el.ifProcessed = true; // avoid recursion
+	    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+	}
+	function genIfConditions(conditions, state, altGen, altEmpty) {
+	    if (!conditions.length) {
+	        return altEmpty || '_e()';
+	    }
+	    const condition = conditions.shift();
+	    if (condition.exp) {
+	        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+	    }
+	    else {
+	        return `${genTernaryExp(condition.block)}`;
+	    }
+	    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+	    function genTernaryExp(el) {
+	        return altGen
+	            ? altGen(el, state)
+	            : el.once
+	                ? genOnce(el, state)
+	                : genElement(el, state);
+	    }
+	}
+	function genFor(el, state, altGen, altHelper) {
+	    const exp = el.for;
+	    const alias = el.alias;
+	    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+	    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+	    if (state.maybeComponent(el) &&
+	        el.tag !== 'slot' &&
+	        el.tag !== 'template' &&
+	        !el.key) {
+	        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+	            `v-for should have explicit keys. ` +
+	            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+	    }
+	    el.forProcessed = true; // avoid recursion
+	    return (`${altHelper || '_l'}((${exp}),` +
+	        `function(${alias}${iterator1}${iterator2}){` +
+	        `return ${(altGen || genElement)(el, state)}` +
+	        '})');
+	}
+	function genData(el, state) {
+	    let data = '{';
+	    // directives first.
+	    // directives may mutate the el's other properties before they are generated.
+	    const dirs = genDirectives(el, state);
+	    if (dirs)
+	        data += dirs + ',';
+	    // key
+	    if (el.key) {
+	        data += `key:${el.key},`;
+	    }
+	    // ref
+	    if (el.ref) {
+	        data += `ref:${el.ref},`;
+	    }
+	    if (el.refInFor) {
+	        data += `refInFor:true,`;
+	    }
+	    // pre
+	    if (el.pre) {
+	        data += `pre:true,`;
+	    }
+	    // record original tag name for components using "is" attribute
+	    if (el.component) {
+	        data += `tag:"${el.tag}",`;
+	    }
+	    // module data generation functions
+	    for (let i = 0; i < state.dataGenFns.length; i++) {
+	        data += state.dataGenFns[i](el);
+	    }
+	    // attributes
+	    if (el.attrs) {
+	        data += `attrs:${genProps(el.attrs)},`;
+	    }
+	    // DOM props
+	    if (el.props) {
+	        data += `domProps:${genProps(el.props)},`;
+	    }
+	    // event handlers
+	    if (el.events) {
+	        data += `${genHandlers(el.events, false)},`;
+	    }
+	    if (el.nativeEvents) {
+	        data += `${genHandlers(el.nativeEvents, true)},`;
+	    }
+	    // slot target
+	    // only for non-scoped slots
+	    if (el.slotTarget && !el.slotScope) {
+	        data += `slot:${el.slotTarget},`;
+	    }
+	    // scoped slots
+	    if (el.scopedSlots) {
+	        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+	    }
+	    // component v-model
+	    if (el.model) {
+	        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+	    }
+	    // inline-template
+	    if (el.inlineTemplate) {
+	        const inlineTemplate = genInlineTemplate(el, state);
+	        if (inlineTemplate) {
+	            data += `${inlineTemplate},`;
+	        }
+	    }
+	    data = data.replace(/,$/, '') + '}';
+	    // v-bind dynamic argument wrap
+	    // v-bind with dynamic arguments must be applied using the same v-bind object
+	    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+	    if (el.dynamicAttrs) {
+	        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+	    }
+	    // v-bind data wrap
+	    if (el.wrapData) {
+	        data = el.wrapData(data);
+	    }
+	    // v-on data wrap
+	    if (el.wrapListeners) {
+	        data = el.wrapListeners(data);
+	    }
+	    return data;
+	}
+	function genDirectives(el, state) {
+	    const dirs = el.directives;
+	    if (!dirs)
+	        return;
+	    let res = 'directives:[';
+	    let hasRuntime = false;
+	    let i, l, dir, needRuntime;
+	    for (i = 0, l = dirs.length; i < l; i++) {
+	        dir = dirs[i];
+	        needRuntime = true;
+	        const gen = state.directives[dir.name];
+	        if (gen) {
+	            // compile-time directive that manipulates AST.
+	            // returns true if it also needs a runtime counterpart.
+	            needRuntime = !!gen(el, dir, state.warn);
+	        }
+	        if (needRuntime) {
+	            hasRuntime = true;
+	            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+	        }
+	    }
+	    if (hasRuntime) {
+	        return res.slice(0, -1) + ']';
+	    }
+	}
+	function genInlineTemplate(el, state) {
+	    const ast = el.children[0];
+	    if ((el.children.length !== 1 || ast.type !== 1)) {
+	        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+	    }
+	    if (ast && ast.type === 1) {
+	        const inlineRenderFns = generate$1(ast, state.options);
+	        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+	    }
+	}
+	function genScopedSlots(el, slots, state) {
+	    // by default scoped slots are considered "stable", this allows child
+	    // components with only scoped slots to skip forced updates from parent.
+	    // but in some cases we have to bail-out of this optimization
+	    // for example if the slot contains dynamic names, has v-if or v-for on them...
+	    let needsForceUpdate = el.for ||
+	        Object.keys(slots).some((key) => {
+	            const slot = slots[key];
+	            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+	            );
+	        });
+	    // #9534: if a component with scoped slots is inside a conditional branch,
+	    // it's possible for the same component to be reused but with different
+	    // compiled slot content. To avoid that, we generate a unique key based on
+	    // the generated code of all the slot contents.
+	    let needsKey = !!el.if;
+	    // OR when it is inside another scoped slot or v-for (the reactivity may be
+	    // disconnected due to the intermediate scope variable)
+	    // #9438, #9506
+	    // TODO: this can be further optimized by properly analyzing in-scope bindings
+	    // and skip force updating ones that do not actually use scope variables.
+	    if (!needsForceUpdate) {
+	        let parent = el.parent;
+	        while (parent) {
+	            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+	                parent.for) {
+	                needsForceUpdate = true;
+	                break;
+	            }
+	            if (parent.if) {
+	                needsKey = true;
+	            }
+	            parent = parent.parent;
+	        }
+	    }
+	    const generatedSlots = Object.keys(slots)
+	        .map((key) => genScopedSlot(slots[key], state))
+	        .join(',');
+	    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+	}
+	function hash(str) {
+	    let hash = 5381;
+	    let i = str.length;
+	    while (i) {
+	        hash = (hash * 33) ^ str.charCodeAt(--i);
+	    }
+	    return hash >>> 0;
+	}
+	function containsSlotChild(el) {
+	    if (el.type === 1) {
+	        if (el.tag === 'slot') {
+	            return true;
+	        }
+	        return el.children.some(containsSlotChild);
+	    }
+	    return false;
+	}
+	function genScopedSlot(el, state) {
+	    const isLegacySyntax = el.attrsMap['slot-scope'];
+	    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+	        return genIf(el, state, genScopedSlot, `null`);
+	    }
+	    if (el.for && !el.forProcessed) {
+	        return genFor(el, state, genScopedSlot);
+	    }
+	    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+	    const fn = `function(${slotScope}){` +
+	        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+	    // reverse proxy v-slot without scope on this.$slots
+	    const reverseProxy = slotScope ? `` : `,proxy:true`;
+	    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+	}
+	function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+	    const children = el.children;
+	    if (children.length) {
+	        const el = children[0];
+	        // optimize single v-for
+	        if (children.length === 1 &&
+	            el.for &&
+	            el.tag !== 'template' &&
+	            el.tag !== 'slot') {
+	            const normalizationType = checkSkip
+	                ? state.maybeComponent(el)
+	                    ? `,1`
+	                    : `,0`
+	                : ``;
+	            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+	        }
+	        const normalizationType = checkSkip
+	            ? getNormalizationType(children, state.maybeComponent)
+	            : 0;
+	        const gen = altGenNode || genNode;
+	        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+	    }
+	}
+	// determine the normalization needed for the children array.
+	// 0: no normalization needed
+	// 1: simple normalization needed (possible 1-level deep nested array)
+	// 2: full normalization needed
+	function getNormalizationType(children, maybeComponent) {
+	    let res = 0;
+	    for (let i = 0; i < children.length; i++) {
+	        const el = children[i];
+	        if (el.type !== 1) {
+	            continue;
+	        }
+	        if (needsNormalization(el) ||
+	            (el.ifConditions &&
+	                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+	            res = 2;
+	            break;
+	        }
+	        if (maybeComponent(el) ||
+	            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+	            res = 1;
+	        }
+	    }
+	    return res;
+	}
+	function needsNormalization(el) {
+	    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+	}
+	function genNode(node, state) {
+	    if (node.type === 1) {
+	        return genElement(node, state);
+	    }
+	    else if (node.type === 3 && node.isComment) {
+	        return genComment(node);
+	    }
+	    else {
+	        return genText(node);
+	    }
+	}
+	function genText(text) {
+	    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+	}
+	function genComment(comment) {
+	    return `_e(${JSON.stringify(comment.text)})`;
+	}
+	function genSlot(el, state) {
+	    const slotName = el.slotName || '"default"';
+	    const children = genChildren(el, state);
+	    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+	    const attrs = el.attrs || el.dynamicAttrs
+	        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+	            // slot props are camelized
+	            name: camelize(attr.name),
+	            value: attr.value,
+	            dynamic: attr.dynamic
+	        })))
+	        : null;
+	    const bind = el.attrsMap['v-bind'];
+	    if ((attrs || bind) && !children) {
+	        res += `,null`;
+	    }
+	    if (attrs) {
+	        res += `,${attrs}`;
+	    }
+	    if (bind) {
+	        res += `${attrs ? '' : ',null'},${bind}`;
+	    }
+	    return res + ')';
+	}
+	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+	function genComponent(componentName, el, state) {
+	    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+	    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+	}
+	function genProps(props) {
+	    let staticProps = ``;
+	    let dynamicProps = ``;
+	    for (let i = 0; i < props.length; i++) {
+	        const prop = props[i];
+	        const value = transformSpecialNewlines(prop.value);
+	        if (prop.dynamic) {
+	            dynamicProps += `${prop.name},${value},`;
+	        }
+	        else {
+	            staticProps += `"${prop.name}":${value},`;
+	        }
+	    }
+	    staticProps = `{${staticProps.slice(0, -1)}}`;
+	    if (dynamicProps) {
+	        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+	    }
+	    else {
+	        return staticProps;
+	    }
+	}
+	// #3895, #4268
+	function transformSpecialNewlines(text) {
+	    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+	}
+
+	// these keywords should not appear inside expressions, but operators like
+	// typeof, instanceof and in are allowed
+	const prohibitedKeywordRE = new RegExp('\\b' +
+	    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+	        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+	        'extends,finally,continue,debugger,function,arguments')
+	        .split(',')
+	        .join('\\b|\\b') +
+	    '\\b');
+	// these unary operators should not be used as property/method names
+	const unaryOperatorsRE = new RegExp('\\b' +
+	    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+	    '\\s*\\([^\\)]*\\)');
+	// strip strings in expressions
+	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+	// detect problematic expressions in a template
+	function detectErrors(ast, warn) {
+	    if (ast) {
+	        checkNode(ast, warn);
+	    }
+	}
+	function checkNode(node, warn) {
+	    if (node.type === 1) {
+	        for (const name in node.attrsMap) {
+	            if (dirRE.test(name)) {
+	                const value = node.attrsMap[name];
+	                if (value) {
+	                    const range = node.rawAttrsMap[name];
+	                    if (name === 'v-for') {
+	                        checkFor(node, `v-for="${value}"`, warn, range);
+	                    }
+	                    else if (name === 'v-slot' || name[0] === '#') {
+	                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+	                    }
+	                    else if (onRE.test(name)) {
+	                        checkEvent(value, `${name}="${value}"`, warn, range);
+	                    }
+	                    else {
+	                        checkExpression(value, `${name}="${value}"`, warn, range);
+	                    }
+	                }
+	            }
+	        }
+	        if (node.children) {
+	            for (let i = 0; i < node.children.length; i++) {
+	                checkNode(node.children[i], warn);
+	            }
+	        }
+	    }
+	    else if (node.type === 2) {
+	        checkExpression(node.expression, node.text, warn, node);
+	    }
+	}
+	function checkEvent(exp, text, warn, range) {
+	    const stripped = exp.replace(stripStringRE, '');
+	    const keywordMatch = stripped.match(unaryOperatorsRE);
+	    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+	        warn(`avoid using JavaScript unary operator as property name: ` +
+	            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+	    }
+	    checkExpression(exp, text, warn, range);
+	}
+	function checkFor(node, text, warn, range) {
+	    checkExpression(node.for || '', text, warn, range);
+	    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+	    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+	    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+	}
+	function checkIdentifier(ident, type, text, warn, range) {
+	    if (typeof ident === 'string') {
+	        try {
+	            new Function(`var ${ident}=_`);
+	        }
+	        catch (e) {
+	            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+	        }
+	    }
+	}
+	function checkExpression(exp, text, warn, range) {
+	    try {
+	        new Function(`return ${exp}`);
+	    }
+	    catch (e) {
+	        const keywordMatch = exp
+	            .replace(stripStringRE, '')
+	            .match(prohibitedKeywordRE);
+	        if (keywordMatch) {
+	            warn(`avoid using JavaScript keyword as property name: ` +
+	                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+	        }
+	        else {
+	            warn(`invalid expression: ${e.message} in\n\n` +
+	                `    ${exp}\n\n` +
+	                `  Raw expression: ${text.trim()}\n`, range);
+	        }
+	    }
+	}
+	function checkFunctionParameterExpression(exp, text, warn, range) {
+	    try {
+	        new Function(exp, '');
+	    }
+	    catch (e) {
+	        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+	            `    ${exp}\n\n` +
+	            `  Raw expression: ${text.trim()}\n`, range);
+	    }
+	}
+
+	const range = 2;
+	function generateCodeFrame(source, start = 0, end = source.length) {
+	    const lines = source.split(/\r?\n/);
+	    let count = 0;
+	    const res = [];
+	    for (let i = 0; i < lines.length; i++) {
+	        count += lines[i].length + 1;
+	        if (count >= start) {
+	            for (let j = i - range; j <= i + range || end > count; j++) {
+	                if (j < 0 || j >= lines.length)
+	                    continue;
+	                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+	                const lineLength = lines[j].length;
+	                if (j === i) {
+	                    // push underline
+	                    const pad = start - (count - lineLength) + 1;
+	                    const length = end > count ? lineLength - pad : end - start;
+	                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+	                }
+	                else if (j > i) {
+	                    if (end > count) {
+	                        const length = Math.min(end - count, lineLength);
+	                        res.push(`   |  ` + repeat(`^`, length));
+	                    }
+	                    count += lineLength + 1;
+	                }
+	            }
+	            break;
+	        }
+	    }
+	    return res.join('\n');
+	}
+	function repeat(str, n) {
+	    let result = '';
+	    if (n > 0) {
+	        // eslint-disable-next-line no-constant-condition
+	        while (true) {
+	            // eslint-disable-line
+	            if (n & 1)
+	                result += str;
+	            n >>>= 1;
+	            if (n <= 0)
+	                break;
+	            str += str;
+	        }
+	    }
+	    return result;
+	}
+
+	function createFunction(code, errors) {
+	    try {
+	        return new Function(code);
+	    }
+	    catch (err) {
+	        errors.push({ err, code });
+	        return noop;
+	    }
+	}
+	function createCompileToFunctionFn(compile) {
+	    const cache = Object.create(null);
+	    return function compileToFunctions(template, options, vm) {
+	        options = extend({}, options);
+	        const warn = options.warn || warn$2;
+	        delete options.warn;
+	        /* istanbul ignore if */
+	        {
+	            // detect possible CSP restriction
+	            try {
+	                new Function('return 1');
+	            }
+	            catch (e) {
+	                if (e.toString().match(/unsafe-eval|CSP/)) {
+	                    warn('It seems you are using the standalone build of Vue.js in an ' +
+	                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+	                        'The template compiler cannot work in this environment. Consider ' +
+	                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+	                        'templates into render functions.');
+	                }
+	            }
+	        }
+	        // check cache
+	        const key = options.delimiters
+	            ? String(options.delimiters) + template
+	            : template;
+	        if (cache[key]) {
+	            return cache[key];
+	        }
+	        // compile
+	        const compiled = compile(template, options);
+	        // check compilation errors/tips
+	        {
+	            if (compiled.errors && compiled.errors.length) {
+	                if (options.outputSourceRange) {
+	                    compiled.errors.forEach((e) => {
+	                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+	                            generateCodeFrame(template, e.start, e.end), vm);
+	                    });
+	                }
+	                else {
+	                    warn(`Error compiling template:\n\n${template}\n\n` +
+	                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+	                        '\n', vm);
+	                }
+	            }
+	            if (compiled.tips && compiled.tips.length) {
+	                if (options.outputSourceRange) {
+	                    compiled.tips.forEach((e) => tip(e.msg, vm));
+	                }
+	                else {
+	                    compiled.tips.forEach((msg) => tip(msg, vm));
+	                }
+	            }
+	        }
+	        // turn code into functions
+	        const res = {};
+	        const fnGenErrors = [];
+	        res.render = createFunction(compiled.render, fnGenErrors);
+	        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+	            return createFunction(code, fnGenErrors);
+	        });
+	        // check function generation errors.
+	        // this should only happen if there is a bug in the compiler itself.
+	        // mostly for codegen development use
+	        /* istanbul ignore if */
+	        {
+	            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+	                warn(`Failed to generate render function:\n\n` +
+	                    fnGenErrors
+	                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+	                        .join('\n'), vm);
+	            }
+	        }
+	        return (cache[key] = res);
+	    };
+	}
+
+	function createCompilerCreator(baseCompile) {
+	    return function createCompiler(baseOptions) {
+	        function compile(template, options) {
+	            const finalOptions = Object.create(baseOptions);
+	            const errors = [];
+	            const tips = [];
+	            let warn = (msg, range, tip) => {
+	                (tip ? tips : errors).push(msg);
+	            };
+	            if (options) {
+	                if (options.outputSourceRange) {
+	                    // $flow-disable-line
+	                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+	                    warn = (msg, range, tip) => {
+	                        const data = { msg };
+	                        if (range) {
+	                            if (range.start != null) {
+	                                data.start = range.start + leadingSpaceLength;
+	                            }
+	                            if (range.end != null) {
+	                                data.end = range.end + leadingSpaceLength;
+	                            }
+	                        }
+	                        (tip ? tips : errors).push(data);
+	                    };
+	                }
+	                // merge custom modules
+	                if (options.modules) {
+	                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+	                }
+	                // merge custom directives
+	                if (options.directives) {
+	                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+	                }
+	                // copy other options
+	                for (const key in options) {
+	                    if (key !== 'modules' && key !== 'directives') {
+	                        finalOptions[key] = options[key];
+	                    }
+	                }
+	            }
+	            finalOptions.warn = warn;
+	            const compiled = baseCompile(template.trim(), finalOptions);
+	            {
+	                detectErrors(compiled.ast, warn);
+	            }
+	            compiled.errors = errors;
+	            compiled.tips = tips;
+	            return compiled;
+	        }
+	        return {
+	            compile,
+	            compileToFunctions: createCompileToFunctionFn(compile),
+	        };
+	    };
+	}
+
+	// `createCompilerCreator` allows creating compilers that use alternative
+	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+	// Here we just export a default compiler using the default parts.
+	const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+	    const ast = parse(template.trim(), options);
+	    if (options.optimize !== false) {
+	        optimize$1(ast, options);
+	    }
+	    const code = generate$1(ast, options);
+	    return {
+	        ast,
+	        render: code.render,
+	        staticRenderFns: code.staticRenderFns,
+	    };
+	});
+
+	const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
+
+	const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+	    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+	    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+	    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+	    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+	    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+	    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+	    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+	    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+	    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+	    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+	    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+	    'target,title,usemap,value,width,wrap');
+	/* istanbul ignore next */
+	const isRenderableAttr = (name) => {
+	    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+	};
+	const propsToAttrMap = {
+	    acceptCharset: 'accept-charset',
+	    className: 'class',
+	    htmlFor: 'for',
+	    httpEquiv: 'http-equiv',
+	};
+	const ESC = {
+	    '<': '&lt;',
+	    '>': '&gt;',
+	    '"': '&quot;',
+	    '&': '&amp;',
+	};
+	function escape(s) {
+	    return s.replace(/[<>"&]/g, escapeChar);
+	}
+	function escapeChar(a) {
+	    return ESC[a] || a;
+	}
+
+	const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+	// let the model AST transform translate v-model into appropriate
+	// props bindings
+	function applyModelTransform(el, state) {
+	    if (el.directives) {
+	        for (let i = 0; i < el.directives.length; i++) {
+	            const dir = el.directives[i];
+	            if (dir.name === 'model') {
+	                state.directives.model(el, dir, state.warn);
+	                // remove value for textarea as its converted to text
+	                if (el.tag === 'textarea' && el.props) {
+	                    el.props = el.props.filter((p) => p.name !== 'value');
+	                }
+	                break;
+	            }
+	        }
+	    }
+	}
+	function genAttrSegments(attrs) {
+	    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+	}
+	function genDOMPropSegments(props, attrs) {
+	    const segments = [];
+	    props.forEach(({ name, value }) => {
+	        name = propsToAttrMap[name] || name.toLowerCase();
+	        if (isRenderableAttr(name) &&
+	            !(attrs && attrs.some((a) => a.name === name))) {
+	            segments.push(genAttrSegment(name, value));
+	        }
+	    });
+	    return segments;
+	}
+	function genAttrSegment(name, value) {
+	    if (plainStringRE.test(value)) {
+	        // force double quote
+	        value = value.replace(/^'|'$/g, '"');
+	        // force enumerated attr to "true"
+	        if (isEnumeratedAttr(name) && value !== `"false"`) {
+	            value = `"true"`;
+	        }
+	        return {
+	            type: RAW,
+	            value: isBooleanAttr(name)
+	                ? ` ${name}="${name}"`
+	                : value === '""'
+	                    ? ` ${name}`
+	                    : ` ${name}="${JSON.parse(value)}"`,
+	        };
+	    }
+	    else {
+	        return {
+	            type: EXPRESSION,
+	            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+	        };
+	    }
+	}
+	function genClassSegments(staticClass, classBinding) {
+	    if (staticClass && !classBinding) {
+	        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+	    }
+	    else {
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+	            },
+	        ];
+	    }
+	}
+	function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+	    if (staticStyle && !styleBinding && !vShowExpression) {
+	        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+	    }
+	    else {
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+	            },
+	        ];
+	    }
+	}
+
+	/**
+	 * In SSR, the vdom tree is generated only once and never patched, so
+	 * we can optimize most element / trees into plain string render functions.
+	 * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+	 *
+	 * The criteria for SSR optimizability is quite a bit looser than static tree
+	 * detection (which is designed for client re-render). In SSR we bail only for
+	 * components/slots/custom directives.
+	 */
+	// optimizability constants
+	const optimizability = {
+	    FALSE: 0,
+	    FULL: 1,
+	    SELF: 2,
+	    CHILDREN: 3,
+	    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+	};
+	let isPlatformReservedTag;
+	function optimize(root, options) {
+	    if (!root)
+	        return;
+	    isPlatformReservedTag = options.isReservedTag || no;
+	    walk(root, true);
+	}
+	function walk(node, isRoot) {
+	    if (isUnOptimizableTree(node)) {
+	        node.ssrOptimizability = optimizability.FALSE;
+	        return;
+	    }
+	    // root node or nodes with custom directives should always be a VNode
+	    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+	    const check = (child) => {
+	        if (child.ssrOptimizability !== optimizability.FULL) {
+	            node.ssrOptimizability = selfUnoptimizable
+	                ? optimizability.PARTIAL
+	                : optimizability.SELF;
+	        }
+	    };
+	    if (selfUnoptimizable) {
+	        node.ssrOptimizability = optimizability.CHILDREN;
+	    }
+	    if (node.type === 1) {
+	        for (let i = 0, l = node.children.length; i < l; i++) {
+	            const child = node.children[i];
+	            walk(child);
+	            check(child);
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                const block = node.ifConditions[i].block;
+	                walk(block, isRoot);
+	                check(block);
+	            }
+	        }
+	        if (node.ssrOptimizability == null ||
+	            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+	            node.ssrOptimizability = optimizability.FULL;
+	        }
+	        else {
+	            node.children = optimizeSiblings(node);
+	        }
+	    }
+	    else {
+	        node.ssrOptimizability = optimizability.FULL;
+	    }
+	}
+	function optimizeSiblings(el) {
+	    const children = el.children;
+	    const optimizedChildren = [];
+	    let currentOptimizableGroup = [];
+	    const pushGroup = () => {
+	        if (currentOptimizableGroup.length) {
+	            optimizedChildren.push({
+	                type: 1,
+	                parent: el,
+	                tag: 'template',
+	                attrsList: [],
+	                attrsMap: {},
+	                rawAttrsMap: {},
+	                children: currentOptimizableGroup,
+	                ssrOptimizability: optimizability.FULL,
+	            });
+	        }
+	        currentOptimizableGroup = [];
+	    };
+	    for (let i = 0; i < children.length; i++) {
+	        const c = children[i];
+	        if (c.ssrOptimizability === optimizability.FULL) {
+	            currentOptimizableGroup.push(c);
+	        }
+	        else {
+	            // wrap fully-optimizable adjacent siblings inside a template tag
+	            // so that they can be optimized into a single ssrNode by codegen
+	            pushGroup();
+	            optimizedChildren.push(c);
+	        }
+	    }
+	    pushGroup();
+	    return optimizedChildren;
+	}
+	function isUnOptimizableTree(node) {
+	    if (node.type === 2 || node.type === 3) {
+	        // text or expression
+	        return false;
+	    }
+	    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+	        !isPlatformReservedTag(node.tag) || // custom component
+	        !!node.component || // "is" component
+	        isSelectWithModel(node) // <select v-model> requires runtime inspection
+	    );
+	}
+	const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+	function hasCustomDirective(node) {
+	    return (node.type === 1 &&
+	        node.directives &&
+	        node.directives.some((d) => !isBuiltInDir(d.name)));
+	}
+	// <select v-model> cannot be optimized because it requires a runtime check
+	// to determine proper selected option
+	function isSelectWithModel(node) {
+	    return (node.type === 1 &&
+	        node.tag === 'select' &&
+	        node.directives != null &&
+	        node.directives.some((d) => d.name === 'model'));
+	}
+
+	// The SSR codegen is essentially extending the default codegen to handle
+	// segment types
+	const RAW = 0;
+	const INTERPOLATION = 1;
+	const EXPRESSION = 2;
+	function generate(ast, options) {
+	    const state = new CodegenState(options);
+	    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+	    return {
+	        render: `with(this){return ${code}}`,
+	        staticRenderFns: state.staticRenderFns,
+	    };
+	}
+	function genSSRElement(el, state) {
+	    if (el.for && !el.forProcessed) {
+	        return genFor(el, state, genSSRElement);
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        return genIf(el, state, genSSRElement);
+	    }
+	    else if (el.tag === 'template' && !el.slotTarget) {
+	        return el.ssrOptimizability === optimizability.FULL
+	            ? genChildrenAsStringNode(el, state)
+	            : genSSRChildren(el, state) || 'void 0';
+	    }
+	    switch (el.ssrOptimizability) {
+	        case optimizability.FULL:
+	            // stringify whole tree
+	            return genStringElement(el, state);
+	        case optimizability.SELF:
+	            // stringify self and check children
+	            return genStringElementWithChildren(el, state);
+	        case optimizability.CHILDREN:
+	            // generate self as VNode and stringify children
+	            return genNormalElement(el, state, true);
+	        case optimizability.PARTIAL:
+	            // generate self as VNode and check children
+	            return genNormalElement(el, state, false);
+	        default:
+	            // bail whole tree
+	            return genElement(el, state);
+	    }
+	}
+	function genNormalElement(el, state, stringifyChildren) {
+	    const data = el.plain ? undefined : genData(el, state);
+	    const children = stringifyChildren
+	        ? `[${genChildrenAsStringNode(el, state)}]`
+	        : genSSRChildren(el, state, true);
+	    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+	}
+	function genSSRChildren(el, state, checkSkip) {
+	    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+	}
+	function genSSRNode(el, state) {
+	    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+	}
+	function genChildrenAsStringNode(el, state) {
+	    return el.children.length
+	        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+	        : '';
+	}
+	function genStringElement(el, state) {
+	    return `_ssrNode(${elementToString(el, state)})`;
+	}
+	function genStringElementWithChildren(el, state) {
+	    const children = genSSRChildren(el, state, true);
+	    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+	}
+	function elementToString(el, state) {
+	    return `(${flattenSegments(elementToSegments(el, state))})`;
+	}
+	function elementToSegments(el, state) {
+	    // v-for / v-if
+	    if (el.for && !el.forProcessed) {
+	        el.forProcessed = true;
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: genFor(el, state, elementToString, '_ssrList'),
+	            },
+	        ];
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        el.ifProcessed = true;
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: genIf(el, state, elementToString, '"<!---->"'),
+	            },
+	        ];
+	    }
+	    else if (el.tag === 'template') {
+	        return childrenToSegments(el, state);
+	    }
+	    const openSegments = elementToOpenTagSegments(el, state);
+	    const childrenSegments = childrenToSegments(el, state);
+	    const { isUnaryTag } = state.options;
+	    const close = isUnaryTag && isUnaryTag(el.tag)
+	        ? []
+	        : [{ type: RAW, value: `</${el.tag}>` }];
+	    return openSegments.concat(childrenSegments, close);
+	}
+	function elementToOpenTagSegments(el, state) {
+	    applyModelTransform(el, state);
+	    let binding;
+	    const segments = [{ type: RAW, value: `<${el.tag}` }];
+	    // attrs
+	    if (el.attrs) {
+	        segments.push.apply(segments, genAttrSegments(el.attrs));
+	    }
+	    // domProps
+	    if (el.props) {
+	        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+	    }
+	    // v-bind="object"
+	    if ((binding = el.attrsMap['v-bind'])) {
+	        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+	    }
+	    // v-bind.prop="object"
+	    if ((binding = el.attrsMap['v-bind.prop'])) {
+	        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+	    }
+	    // class
+	    if (el.staticClass || el.classBinding) {
+	        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+	    }
+	    // style & v-show
+	    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+	        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+	    }
+	    // _scopedId
+	    if (state.options.scopeId) {
+	        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+	    }
+	    segments.push({ type: RAW, value: `>` });
+	    return segments;
+	}
+	function childrenToSegments(el, state) {
+	    let binding;
+	    if ((binding = el.attrsMap['v-html'])) {
+	        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+	    }
+	    if ((binding = el.attrsMap['v-text'])) {
+	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+	    }
+	    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+	    }
+	    return el.children ? nodesToSegments(el.children, state) : [];
+	}
+	function nodesToSegments(children, state) {
+	    const segments = [];
+	    for (let i = 0; i < children.length; i++) {
+	        const c = children[i];
+	        if (c.type === 1) {
+	            segments.push.apply(segments, elementToSegments(c, state));
+	        }
+	        else if (c.type === 2) {
+	            segments.push({ type: INTERPOLATION, value: c.expression });
+	        }
+	        else if (c.type === 3) {
+	            let text = escape(c.text);
+	            if (c.isComment) {
+	                text = '<!--' + text + '-->';
+	            }
+	            segments.push({ type: RAW, value: text });
+	        }
+	    }
+	    return segments;
+	}
+	function flattenSegments(segments) {
+	    const mergedSegments = [];
+	    let textBuffer = '';
+	    const pushBuffer = () => {
+	        if (textBuffer) {
+	            mergedSegments.push(JSON.stringify(textBuffer));
+	            textBuffer = '';
+	        }
+	    };
+	    for (let i = 0; i < segments.length; i++) {
+	        const s = segments[i];
+	        if (s.type === RAW) {
+	            textBuffer += s.value;
+	        }
+	        else if (s.type === INTERPOLATION) {
+	            pushBuffer();
+	            mergedSegments.push(`_ssrEscape(${s.value})`);
+	        }
+	        else if (s.type === EXPRESSION) {
+	            pushBuffer();
+	            mergedSegments.push(`(${s.value})`);
+	        }
+	    }
+	    pushBuffer();
+	    return mergedSegments.join('+');
+	}
+
+	const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+	    const ast = parse(template.trim(), options);
+	    optimize(ast, options);
+	    const code = generate(ast, options);
+	    return {
+	        ast,
+	        render: code.render,
+	        staticRenderFns: code.staticRenderFns,
+	    };
+	});
+
+	const { compile, compileToFunctions } = createCompiler(baseOptions);
+
+	exports.compile = compile$1;
+	exports.compileToFunctions = compileToFunctions$1;
+	exports.generateCodeFrame = generateCodeFrame;
+	exports.parseComponent = parseComponent;
+	exports.ssrCompile = compile;
+	exports.ssrCompileToFunctions = compileToFunctions;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index bd3d3e8bfad..d4394d72c73 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -2,1501 +2,1279 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+var deindent = require('de-indent');
+var he = require('he');
 
-var deindent = _interopDefault(require('de-indent'));
-var he = _interopDefault(require('he'));
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-/*  */
-
-var emptyObject = Object.freeze({});
+var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
+var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
+const emptyObject = Object.freeze({});
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
+function isUndef(v) {
+    return v === undefined || v === null;
 }
-
 /**
  * Check if value is primitive.
  */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
 }
-
 /**
  * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
+ * objects from primitive values when we know the value
  * is a JSON-compliant type.
  */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
 }
-
 /**
  * Get the raw type string of a value, e.g., [object Object].
  */
-var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
 }
-
 /**
  * Strict object type check. Only returns true
  * for plain JavaScript objects.
  */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
 }
-
 /**
  * Check if val is a valid array index.
  */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
 }
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
  */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
 }
-
 /**
  * Check if a tag is a built-in tag.
  */
-var isBuiltInTag = makeMap('slot,component', true);
-
+const isBuiltInTag = makeMap('slot,component', true);
 /**
  * Check if an attribute is a reserved attribute.
  */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
+makeMap('key,ref,slot,slot-scope,is');
 /**
  * Remove an item from an array.
  */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
+function remove(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
     }
-  }
 }
-
 /**
  * Check whether an object has the property.
  */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
 }
-
 /**
  * Create a cached version of a pure function.
  */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
 }
-
 /**
  * Camelize a hyphen-delimited string.
  */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
 });
-
 /**
  * Hyphenate a camelCase string.
  */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
 });
-
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-
-/* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
 /**
  * Mix properties into target object.
  */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
 }
-
 /* eslint-disable no-unused-vars */
-
 /**
  * Perform no operation.
  * Stubbing args to make Flow happy without leaving useless transpiled code
  * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
  */
-function noop (a, b, c) {}
-
+function noop(a, b, c) { }
 /**
  * Always return false.
  */
-var no = function (a, b, c) { return false; };
-
+const no = (a, b, c) => false;
 /* eslint-enable no-unused-vars */
-
 /**
  * Return the same value.
  */
-var identity = function (_) { return _; };
-
+const identity = (_) => _;
 /**
  * Generate a string containing static keys from compiler modules.
  */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
 
-/*  */
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
-
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
 // Elements that you can, intentionally, leave open
 // (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
 // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
-
-/*  */
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track');
 
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
 /**
  * Define a property.
  */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
 /**
  * Not type-checking this file because it's mostly vendor code.
  */
-
 // Regular Expressions for parsing tags and attributes
-var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
-var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-var doctype = /^<!DOCTYPE [^>]+>/i;
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
 // #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/;
-var conditionalComment = /^<!\[/;
-
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
 // Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true);
-var reCache = {};
-
-var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
 };
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
 // #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
             }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
         }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
         }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
         }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
     }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
     }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
     }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
     }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
 }
 
-/*  */
-
-var splitRE = /\r?\n/g;
-var replaceRE = /./g;
-var isSpecialTag = makeMap('script,style,template', true);
-
+const splitRE = /\r?\n/g;
+const replaceRE = /./g;
+const isSpecialTag = makeMap('script,style,template', true);
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
-function parseComponent (
-  content,
-  options
-) {
-  if ( options === void 0 ) options = {};
-
-  var sfc = {
-    template: null,
-    script: null,
-    styles: [],
-    customBlocks: [],
-    errors: []
-  };
-  var depth = 0;
-  var currentBlock = null;
-
-  var warn = function (msg) {
-    sfc.errors.push(msg);
-  };
-
-  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-    warn = function (msg, range) {
-      var data = { msg: msg };
-      if (range.start != null) {
-        data.start = range.start;
-      }
-      if (range.end != null) {
-        data.end = range.end;
-      }
-      sfc.errors.push(data);
+function parseComponent(content, options = {}) {
+    const sfc = {
+        template: null,
+        script: null,
+        styles: [],
+        customBlocks: [],
+        errors: [],
     };
-  }
-
-  function start (
-    tag,
-    attrs,
-    unary,
-    start,
-    end
-  ) {
-    if (depth === 0) {
-      currentBlock = {
-        type: tag,
-        content: '',
-        start: end,
-        attrs: attrs.reduce(function (cumulated, ref) {
-          var name = ref.name;
-          var value = ref.value;
-
-          cumulated[name] = value || true;
-          return cumulated
-        }, {})
-      };
-      if (isSpecialTag(tag)) {
-        checkAttrs(currentBlock, attrs);
-        if (tag === 'style') {
-          sfc.styles.push(currentBlock);
-        } else {
-          sfc[tag] = currentBlock;
-        }
-      } else { // custom blocks
-        sfc.customBlocks.push(currentBlock);
-      }
-    }
-    if (!unary) {
-      depth++;
-    }
-  }
-
-  function checkAttrs (block, attrs) {
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i];
-      if (attr.name === 'lang') {
-        block.lang = attr.value;
-      }
-      if (attr.name === 'scoped') {
-        block.scoped = true;
-      }
-      if (attr.name === 'module') {
-        block.module = attr.value || true;
-      }
-      if (attr.name === 'src') {
-        block.src = attr.value;
-      }
-    }
-  }
-
-  function end (tag, start) {
-    if (depth === 1 && currentBlock) {
-      currentBlock.end = start;
-      var text = content.slice(currentBlock.start, currentBlock.end);
-      if (options.deindent !== false) {
-        text = deindent(text);
-      }
-      // pad content so that linters and pre-processors can output correct
-      // line numbers in errors and warnings
-      if (currentBlock.type !== 'template' && options.pad) {
-        text = padContent(currentBlock, options.pad) + text;
-      }
-      currentBlock.content = text;
-      currentBlock = null;
-    }
-    depth--;
-  }
-
-  function padContent (block, pad) {
-    if (pad === 'space') {
-      return content.slice(0, block.start).replace(replaceRE, ' ')
-    } else {
-      var offset = content.slice(0, block.start).split(splitRE).length;
-      var padChar = block.type === 'script' && !block.lang
-        ? '//\n'
-        : '\n';
-      return Array(offset).join(padChar)
-    }
-  }
-
-  parseHTML(content, {
-    warn: warn,
-    start: start,
-    end: end,
-    outputSourceRange: options.outputSourceRange
-  });
-
-  return sfc
+    let depth = 0;
+    let currentBlock = null;
+    let warn = (msg) => {
+        sfc.errors.push(msg);
+    };
+    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        warn = (msg, range) => {
+            const data = { msg };
+            if (range.start != null) {
+                data.start = range.start;
+            }
+            if (range.end != null) {
+                data.end = range.end;
+            }
+            sfc.errors.push(data);
+        };
+    }
+    function start(tag, attrs, unary, start, end) {
+        if (depth === 0) {
+            currentBlock = {
+                type: tag,
+                content: '',
+                start: end,
+                attrs: attrs.reduce((cumulated, { name, value }) => {
+                    cumulated[name] = value || true;
+                    return cumulated;
+                }, {}),
+            };
+            if (isSpecialTag(tag)) {
+                checkAttrs(currentBlock, attrs);
+                if (tag === 'style') {
+                    sfc.styles.push(currentBlock);
+                }
+                else {
+                    sfc[tag] = currentBlock;
+                }
+            }
+            else {
+                // custom blocks
+                sfc.customBlocks.push(currentBlock);
+            }
+        }
+        if (!unary) {
+            depth++;
+        }
+    }
+    function checkAttrs(block, attrs) {
+        for (let i = 0; i < attrs.length; i++) {
+            const attr = attrs[i];
+            if (attr.name === 'lang') {
+                block.lang = attr.value;
+            }
+            if (attr.name === 'scoped') {
+                block.scoped = true;
+            }
+            if (attr.name === 'module') {
+                block.module = attr.value || true;
+            }
+            if (attr.name === 'src') {
+                block.src = attr.value;
+            }
+        }
+    }
+    function end(tag, start) {
+        if (depth === 1 && currentBlock) {
+            currentBlock.end = start;
+            let text = content.slice(currentBlock.start, currentBlock.end);
+            if (options.deindent !== false) {
+                text = deindent__default["default"](text);
+            }
+            // pad content so that linters and pre-processors can output correct
+            // line numbers in errors and warnings
+            if (currentBlock.type !== 'template' && options.pad) {
+                text = padContent(currentBlock, options.pad) + text;
+            }
+            currentBlock.content = text;
+            currentBlock = null;
+        }
+        depth--;
+    }
+    function padContent(block, pad) {
+        if (pad === 'space') {
+            return content.slice(0, block.start).replace(replaceRE, ' ');
+        }
+        else {
+            const offset = content.slice(0, block.start).split(splitRE).length;
+            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+            return Array(offset).join(padChar);
+        }
+    }
+    parseHTML(content, {
+        warn,
+        start,
+        end,
+        outputSourceRange: options.outputSourceRange,
+    });
+    return sfc;
 }
 
-/*  */
-
 // can we use __proto__?
-var hasProto = '__proto__' in {};
-
+const hasProto = '__proto__' in {};
 // Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
-
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
 // Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
 if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
 }
-
 // this needs to be lazy-evaled because vue may be required before
 // vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
 };
-
-// detect devtools
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
 /* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
+
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
+];
 
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
+};
 
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+if (process.env.NODE_ENV !== 'production') {
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
     };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
     };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
     };
-
-    return Set;
-  }());
-}
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
-var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
-
-var warn = noop;
-var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
-if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
 }
 
-/*  */
-
-var uid = 0;
-
+let uid = 0;
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
-};
-
-Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
-};
-
-Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
-};
-
-Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
-};
-
-Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
-};
-
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
 // The current target watcher being evaluated.
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null;
 
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-  return this.componentInstance
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
 
 /*
  * not type checking this file because flow doesn't play well with
  * dynamically accessing methods on Array prototype
  */
-
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-
-var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
 ];
-
 /**
  * Intercept mutating methods and emit events
  */
 methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-/*  */
-
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-var shouldObserve = true;
-
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
  * object's property keys into getter/setters that
  * collect dependencies and dispatch updates.
  */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
-};
-
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
-};
-
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
-};
-
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
 // helpers
-
 /**
  * Augment a target Object or Array by intercepting
  * the prototype chain using __proto__
  */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
 }
-
 /**
  * Augment a target Object or Array by defining
  * hidden properties.
  */
 /* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
 }
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (!isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
 }
-
 /**
  * Define a reactive property on an Object.
  */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
 }
-
 /**
  * Set a property on an object. Adds the new property and
  * triggers change notification if the property doesn't
  * already exist.
  */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
 }
-
 /**
  * Collect dependencies on array elements when the array is touched, since
  * we cannot intercept array element access like property getters.
  */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
     }
-  }
 }
 
-/*  */
-
 /**
  * Option overwriting strategies are functions that handle
  * how to merge a parent option value and a child option
  * value into the final value.
  */
-var strats = config.optionMergeStrategies;
-
+const strats = config.optionMergeStrategies;
 /**
  * Options with restrictions
  */
 if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
 }
-
 /**
  * Helper that recursively merges two data objects together.
  */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
 }
-
 /**
  * Data
  */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
     }
-  }
 }
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
     }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
+    return mergeDataOrFn(parentVal, childVal, vm);
 };
-
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
 }
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
     }
-  }
-  return res
+    return res;
 }
-
-LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook;
 });
-
 /**
  * Assets
  *
@@ -1504,119 +1282,95 @@ LIFECYCLE_HOOKS.forEach(function (hook) {
  * a three-way merge between constructor options, instance
  * options and parent options.
  */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
 }
-
 ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
+    strats[type + 's'] = mergeAssets;
 });
-
 /**
  * Watchers.
  *
  * Watchers hashes should not overwrite one
  * another, so we merge them as arrays.
  */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
 };
-
 /**
  * Other object hashes.
  */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
 };
 strats.provide = mergeDataOrFn;
-
 /**
  * Default strategy.
  */
-var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
 };
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
 }
 
-/*  */
-
-/*  */
-
-/*  */
-
-var callbacks = [];
-
-function flushCallbacks () {
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
+/* globals MutationObserver */
+const callbacks = [];
+function flushCallbacks() {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
 }
-
 // The nextTick behavior leverages the microtask queue, which can be accessed
 // via either native Promise.then or MutationObserver.
 // MutationObserver has wider support, however it is seriously bugged in
@@ -1624,629 +1378,528 @@ function flushCallbacks () {
 // completely stops working after triggering a few times... so, if native
 // Promise is available, we will use it:
 /* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/*  */
-
-/*  */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve();
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+else ;
 
 // these are reserved for web because they are directly compiled away
 // during template compilation
-var isReservedAttr = makeMap('style,class');
-
+makeMap('style,class');
 // attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress');
-var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
 };
-
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-
-var isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-  'required,reversed,scoped,seamless,selected,sortable,' +
-  'truespeed,typemustmatch,visible'
-);
-
-/*  */
-
-/*  */
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-  'embed,object,param,source,canvas,script,noscript,del,ins,' +
-  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-  'output,progress,select,textarea,' +
-  'details,dialog,menu,menuitem,summary,' +
-  'content,element,shadow,template,blockquote,iframe,tfoot'
-);
-
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
 // this map is intentionally selective, only covering SVG elements that may
 // contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-  'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-);
-
-var isPreTag = function (tag) { return tag === 'pre'; };
-
-var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
 };
-
-function getTagNamespace (tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
-}
-
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/*  */
-
-/*  */
-
-var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+makeMap('text,number,password,search,email,tel,url');
+
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
         expression = exp.slice(0, i).trim();
-      } else {
+    }
+    else if (lastFilterIndex !== 0) {
         pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
     }
-  }
-
-  return expression
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
 }
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-/*  */
-
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
-var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
 });
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/*  */
-
-
-
 /* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
 }
 /* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
 }
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
 }
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
 }
-
 // add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
 }
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
 }
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
 }
-
 // note: this only removes the attr from the Array (attrsList) so that it
 // doesn't get processed by processAttrs.
 // By default it does NOT remove it from the map (attrsMap) because the map is
 // needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
-    }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
-    }
-  }
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
 }
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
     }
-    if (range.end != null) {
-      item.end = range.end;
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
     }
-  }
-  return item
+    return item;
 }
 
-/*  */
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  if (process.env.NODE_ENV !== 'production' && staticClass) {
-    var res = parseText(staticClass, options.delimiters);
-    if (res) {
-      warn(
-        "class=\"" + staticClass + "\": " +
-        'Interpolation inside attributes has been removed. ' +
-        'Use v-bind or the colon shorthand instead. For example, ' +
-        'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      );
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass);
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  }
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (process.env.NODE_ENV !== 'production' && staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
 }
-
-function genData (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
 }
-
 var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-/*  */
-
-var parseStyleText = cached(function (cssText) {
-  var res = {};
-  var listDelimiter = /;(?![^(]*\))/g;
-  var propertyDelimiter = /:(.+)/;
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter);
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return res
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
 
-/*  */
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  if (staticStyle) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      var res = parseText(staticStyle, options.delimiters);
-      if (res) {
-        warn(
-          "style=\"" + staticStyle + "\": " +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        );
-      }
-    }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-  }
-
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  }
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
 }
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:(" + (el.styleBinding) + "),";
-  }
-  return data
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
 }
-
 var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$1
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-/*  */
-
 /**
  * Cross-platform code generation for component v-model
  */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
 }
-
 /**
  * Cross-platform codegen helper for generating v-model value assignment code.
  */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
 }
-
 /**
  * Parse a v-model expression into a base path and a final key segment.
  * Handles both dot-path and possible square brackets.
@@ -2261,1339 +1914,1112 @@ function genAssignmentCode (
  * - test.xxx.a["asa"][test1[key]]
  *
  */
-
-var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.');
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-
-  str = val;
-  index = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
     }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
-}
-
-function next () {
-  return str.charCodeAt(++index)
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
 }
-
-function eof () {
-  return index >= len
+function next() {
+    return str.charCodeAt(++index);
 }
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
+function eof() {
+    return index >= len;
 }
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index;
-      break
-    }
-  }
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
 }
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
     }
-  }
 }
 
-/*  */
-
-var onRE = /^@|^v-on:/;
-var dirRE = /^v-|^@|^:|^#/;
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-var stripParensRE = /^\(|\)$/g;
-var dynamicArgRE = /^\[.*\]$/;
-
-var argRE = /:(.*)$/;
-var bindRE = /^:|^\.|^v-bind:/;
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
-var slotRE = /^v-slot(:|$)|^#/;
-
-var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /[ \f\t\r\n]+/g;
-
-var invalidAttributeRE = /[\s"'<>\/=]/;
-
-var decodeHTMLCached = cached(he.decode);
-
-var emptySlotScopeToken = "_empty_";
-
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he__default["default"].decode);
+const emptySlotScopeToken = `_empty_`;
 // configurable state
-var warn$1;
-var delimiters;
-var transforms;
-var preTransforms;
-var postTransforms;
-var platformIsPreTag;
-var platformMustUseProp;
-var platformGetTagNamespace;
-var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
 }
-
 /**
  * Convert HTML string to AST.
  */
-function parse (
-  template,
-  options
-) {
-  warn$1 = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!(
-    el.component ||
-    el.attrsMap[':is'] ||
-    el.attrsMap['v-bind:is'] ||
-    !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
-  ); };
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn$1(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element);
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
         }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
     }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
     }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
     }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
     }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn$1,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$1(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        process.env.NODE_ENV !== 'production' && warn$1(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
-        if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root);
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
         }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
         if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
+            if (el.tag === 'template') {
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
         }
-        currentParent.children.push(child);
-      }
+        el.key = exp;
     }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn$1(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn$1(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
 }
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
 }
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$1(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
 }
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
 }
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
     }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
     }
-  }
 }
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$1(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
 }
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn$1(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
-    }
-  }
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
 }
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
 }
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
 }
-
 // handle content being passed to a component as slot,
 // e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn$1(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn$1(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
+function processSlotContent(el) {
+    let slotScope;
     if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$1(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
-        }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn$1(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$1(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn$1(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
     }
-  }
 }
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$1(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
 }
-
 // handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn$1(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
-}
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
 }
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn$1(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i],
-                true // dynamic
-              );
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
             }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn$1(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
 }
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
     }
-    parent = parent.parent;
-  }
-  return false
+    return false;
 }
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
 }
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-    }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
 }
-
 // for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
 }
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
 }
-
-var ieNSBug = /^xmlns:NS\d+/;
-var ieNSPrefix = /^NS\d+:/;
-
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
 /* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$1(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-function preTransformNode (el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap;
-    if (!map['v-model']) {
-      return
-    }
-
-    var typeBinding;
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type');
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
     }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = "(" + (map['v-bind']) + ").type";
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
     }
+}
 
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true);
-      var ifConditionExtra = ifCondition ? ("&&(" + ifCondition + ")") : "";
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-      // 1. checkbox
-      var branch0 = cloneASTElement(el);
-      // process for on the main node
-      processFor(branch0);
-      addRawAttr(branch0, 'type', 'checkbox');
-      processElement(branch0, options);
-      branch0.processed = true; // prevent it from double-processed
-      branch0.if = "(" + typeBinding + ")==='checkbox'" + ifConditionExtra;
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      });
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el);
-      getAndRemoveAttr(branch1, 'v-for', true);
-      addRawAttr(branch1, 'type', 'radio');
-      processElement(branch1, options);
-      addIfCondition(branch0, {
-        exp: "(" + typeBinding + ")==='radio'" + ifConditionExtra,
-        block: branch1
-      });
-      // 3. other
-      var branch2 = cloneASTElement(el);
-      getAndRemoveAttr(branch2, 'v-for', true);
-      addRawAttr(branch2, ':type', typeBinding);
-      processElement(branch2, options);
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      });
-
-      if (hasElse) {
-        branch0.else = true;
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition;
-      }
-
-      return branch0
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
     }
-  }
 }
-
-function cloneASTElement (el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
 }
-
-var model = {
-  preTransformNode: preTransformNode
+var model$1 = {
+    preTransformNode,
 };
 
-var modules = [
-  klass,
-  style,
-  model
-];
-
-/*  */
-
-var warn$2;
+var modules = [klass, style, model$1];
 
+let warn;
 // in some cases, the event used has to be determined at runtime
 // so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r';
-
-function model$1 (
-  el,
-  dir,
-  _warn
-) {
-  warn$2 = _warn;
-  var value = dir.value;
-  var modifiers = dir.modifiers;
-  var tag = el.tag;
-  var type = el.attrsMap.type;
-
-  if (process.env.NODE_ENV !== 'production') {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn$2(
-        "<" + (el.tag) + " v-model=\"" + value + "\" type=\"file\">:\n" +
-        "File inputs are read only. Use a v-on:change listener instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-  }
-
-  if (el.component) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers);
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers);
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers);
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers);
-  } else if (!config.isReservedTag(tag)) {
-    genComponentModel(el, value, modifiers);
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$2(
-      "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-      "v-model is not supported on this element type. " +
-      'If you are working with contenteditable, it\'s recommended to ' +
-      'wrap a library dedicated for that purpose inside a custom component.',
-      el.rawAttrsMap['v-model']
-    );
-  }
-
-  // ensure runtime directive metadata
-  return true
-}
-
-function genCheckboxModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-  addProp(el, 'checked',
-    "Array.isArray(" + value + ")" +
-    "?_i(" + value + "," + valueBinding + ")>-1" + (
-      trueValueBinding === 'true'
-        ? (":(" + value + ")")
-        : (":_q(" + value + "," + trueValueBinding + ")")
-    )
-  );
-  addHandler(el, 'change',
-    "var $$a=" + value + "," +
+const RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
         '$$el=$event.target,' +
-        "$$c=$$el.checked?(" + trueValueBinding + "):(" + falseValueBinding + ");" +
-    'if(Array.isArray($$a)){' +
-      "var $$v=" + (number ? '_n(' + valueBinding + ')' : valueBinding) + "," +
-          '$$i=_i($$a,$$v);' +
-      "if($$el.checked){$$i<0&&(" + (genAssignmentCode(value, '$$a.concat([$$v])')) + ")}" +
-      "else{$$i>-1&&(" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + ")}" +
-    "}else{" + (genAssignmentCode(value, '$$c')) + "}",
-    null, true
-  );
-}
-
-function genRadioModel (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var valueBinding = getBindingAttr(el, 'value') || 'null';
-  valueBinding = number ? ("_n(" + valueBinding + ")") : valueBinding;
-  addProp(el, 'checked', ("_q(" + value + "," + valueBinding + ")"));
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-
-function genSelect (
-  el,
-  value,
-  modifiers
-) {
-  var number = modifiers && modifiers.number;
-  var selectedVal = "Array.prototype.filter" +
-    ".call($event.target.options,function(o){return o.selected})" +
-    ".map(function(o){var val = \"_value\" in o ? o._value : o.value;" +
-    "return " + (number ? '_n(val)' : 'val') + "})";
-
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-  var code = "var $$selectedVal = " + selectedVal + ";";
-  code = code + " " + (genAssignmentCode(value, assignment));
-  addHandler(el, 'change', code, null, true);
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var type = el.attrsMap.type;
-
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  if (process.env.NODE_ENV !== 'production') {
-    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-    if (value$1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-      warn$2(
-        binding + "=\"" + value$1 + "\" conflicts with v-model on the same element " +
-        'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      );
-    }
-  }
-
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var number = ref.number;
-  var trim = ref.trim;
-  var needCompositionGuard = !lazy && type !== 'range';
-  var event = lazy
-    ? 'change'
-    : type === 'range'
-      ? RANGE_TOKEN
-      : 'input';
-
-  var valueExpression = '$event.target.value';
-  if (trim) {
-    valueExpression = "$event.target.value.trim()";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  if (needCompositionGuard) {
-    code = "if($event.target.composing)return;" + code;
-  }
-
-  addProp(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()');
-  }
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-/*  */
-
-function text (el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
-  }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-/*  */
-
-function html (el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
-  }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
 var directives = {
-  model: model$1,
-  text: text,
-  html: html
+    model,
+    text,
+    html,
 };
 
-/*  */
-
-var baseOptions = {
-  expectHTML: true,
-  modules: modules,
-  directives: directives,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys(modules)
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys$1(modules),
 };
 
-/*  */
-
-var isStaticKey;
-var isPlatformReservedTag;
-
-var genStaticKeysCached = cached(genStaticKeys$1);
-
+let isStaticKey;
+let isPlatformReservedTag$1;
+const genStaticKeysCached = cached(genStaticKeys);
 /**
  * Goal of the optimizer: walk the generated template AST tree
  * and detect sub-trees that are purely static, i.e. parts of
@@ -3605,1794 +3031,1545 @@ var genStaticKeysCached = cached(genStaticKeys$1);
  *    create fresh nodes for them on each re-render;
  * 2. Completely skip them in the patching process.
  */
-function optimize (root, options) {
-  if (!root) { return }
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      markStatic(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        markStatic(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        markStaticRoots(node.ifConditions[i$1].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
+function optimize$1(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag$1 = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag$1(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
 }
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
     }
-    if (node.for) {
-      return true
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag$1(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
     }
-  }
-  return false
+    return false;
 }
 
-/*  */
-
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-var fnInvokeRE = /\([^)]*?\);*$/;
-var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
 // KeyboardEvent.keyCode aliases
-var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
 };
-
 // KeyboardEvent.key aliases
-var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
 };
-
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
-var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
 };
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
 }
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys);
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
-    }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + ".apply(null, arguments)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ").apply(null, arguments)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    return ("function($event){" + code + handlerCode + "}")
-  }
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
 }
-
-function genKeyFilter (keys) {
-  return (
+function genKeyFilter(keys) {
+    return (
     // make sure the key filters only apply to KeyboardEvents
     // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
     // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
 }
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-/*  */
-
-function on (el, dir) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-/*  */
-
 var baseDirectives = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
+    on,
+    bind,
+    cloak: noop,
 };
 
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
-};
-
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  // fix #11483, Root level <script> tags should not be rendered.
-  var code = ast ? (ast.tag === 'script' ? 'null' : genElement(ast, state)) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate$1(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData$2(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
     }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
     }
-    return code
-  }
 }
-
 // hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
 }
-
 // v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData$2 (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
-    }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
 }
-
-function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate$1(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
 }
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
     }
-    return el.children.some(containsSlotChild)
-  }
-  return false
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
 }
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
 }
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
 }
-
 // determine the normalization needed for the children array.
 // 0: no normalization needed
 // 1: simple normalization needed (possible 1-level deep nested array)
 // 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
 }
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
 }
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
 }
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
 }
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
 }
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? (",function(){return " + children + "}") : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
 }
-
 // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData$2(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = transformSpecialNewlines(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
 }
-
 // #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-/*  */
-
-
-
 // these keywords should not appear inside expressions, but operators like
 // typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
 // these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
 // strip strings in expressions
-var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
 // detect problematic expressions in a template
-function detectErrors (ast, warn) {
-  if (ast) {
-    checkNode(ast, warn);
-  }
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
 }
-
-function checkNode (node, warn) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node);
-  }
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
 }
-
-function checkEvent (exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn, range);
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
 }
-
-function checkFor (node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
 }
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn,
-  range
-) {
-  if (typeof ident === 'string') {
+function checkExpression(exp, text, warn, range) {
     try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
     }
-  }
-}
-
-function checkExpression (exp, text, warn, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
-}
-
-/*  */
-
-var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
 }
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
+}
+
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
     }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
     }
+    return result;
+}
 
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-        }
-      }
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
     }
-
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
     }
-
-    return (cache[key] = res)
-  }
 }
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
             }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
-    }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-/*  */
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
+}
 
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
 // Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  var code = generate(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize$1(ast, options);
+    }
+    const code = generate$1(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
-
-var ref = createCompiler(baseOptions);
-var compile = ref.compile;
-var compileToFunctions = ref.compileToFunctions;
-
-/*  */
-
-var isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-  'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-  'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-  'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-  'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-  'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-  'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-  'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-  'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-  'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-  'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-  'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-  'target,title,usemap,value,width,wrap'
-);
-
+const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
+
+const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
 /* istanbul ignore next */
-var isRenderableAttr = function (name) {
-  return (
-    isAttr(name) ||
-    name.indexOf('data-') === 0 ||
-    name.indexOf('aria-') === 0
-  )
+const isRenderableAttr = (name) => {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
 };
-
-var propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
+const propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
 };
-
-var ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
 };
-
-function escape (s) {
-  return s.replace(/[<>"&]/g, escapeChar)
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
 }
-
-function escapeChar (a) {
-  return ESC[a] || a
+function escapeChar(a) {
+    return ESC[a] || a;
 }
 
-/*  */
-
-
-
-
-var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-
+const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
 // let the model AST transform translate v-model into appropriate
 // props bindings
-function applyModelTransform (el, state) {
-  if (el.directives) {
-    for (var i = 0; i < el.directives.length; i++) {
-      var dir = el.directives[i];
-      if (dir.name === 'model') {
-        state.directives.model(el, dir, state.warn);
-        // remove value for textarea as its converted to text
-        if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(function (p) { return p.name !== 'value'; });
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (let i = 0; i < el.directives.length; i++) {
+            const dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter((p) => p.name !== 'value');
+                }
+                break;
+            }
         }
-        break
-      }
     }
-  }
 }
-
-function genAttrSegments (
-  attrs
-) {
-  return attrs.map(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    return genAttrSegment(name, value);
-  })
+function genAttrSegments(attrs) {
+    return attrs.map(({ name, value }) => genAttrSegment(name, value));
 }
-
-function genDOMPropSegments (
-  props,
-  attrs
-) {
-  var segments = [];
-  props.forEach(function (ref) {
-    var name = ref.name;
-    var value = ref.value;
-
-    name = propsToAttrMap[name] || name.toLowerCase();
-    if (isRenderableAttr(name) &&
-      !(attrs && attrs.some(function (a) { return a.name === name; }))
-    ) {
-      segments.push(genAttrSegment(name, value));
+function genDOMPropSegments(props, attrs) {
+    const segments = [];
+    props.forEach(({ name, value }) => {
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some((a) => a.name === name))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== `"false"`) {
+            value = `"true"`;
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? ` ${name}="${name}"`
+                : value === '""'
+                    ? ` ${name}`
+                    : ` ${name}="${JSON.parse(value)}"`,
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+        };
     }
-  });
-  return segments
 }
-
-function genAttrSegment (name, value) {
-  if (plainStringRE.test(value)) {
-    // force double quote
-    value = value.replace(/^'|'$/g, '"');
-    // force enumerated attr to "true"
-    if (isEnumeratedAttr(name) && value !== "\"false\"") {
-      value = "\"true\"";
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
     }
-    return {
-      type: RAW,
-      value: isBooleanAttr(name)
-        ? (" " + name + "=\"" + name + "\"")
-        : value === '""'
-          ? (" " + name)
-          : (" " + name + "=\"" + (JSON.parse(value)) + "\"")
-    }
-  } else {
-    return {
-      type: EXPRESSION,
-      value: ("_ssrAttr(" + (JSON.stringify(name)) + "," + value + ")")
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+            },
+        ];
     }
-  }
-}
-
-function genClassSegments (
-  staticClass,
-  classBinding
-) {
-  if (staticClass && !classBinding) {
-    return [{ type: RAW, value: (" class=\"" + (JSON.parse(staticClass)) + "\"") }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrClass(" + (staticClass || 'null') + "," + (classBinding || 'null') + ")")
-    }]
-  }
 }
-
-function genStyleSegments (
-  staticStyle,
-  parsedStaticStyle,
-  styleBinding,
-  vShowExpression
-) {
-  if (staticStyle && !styleBinding && !vShowExpression) {
-    return [{ type: RAW, value: (" style=" + (JSON.stringify(staticStyle))) }]
-  } else {
-    return [{
-      type: EXPRESSION,
-      value: ("_ssrStyle(" + (parsedStaticStyle || 'null') + "," + (styleBinding || 'null') + ", " + (vShowExpression
-          ? ("{ display: (" + vShowExpression + ") ? '' : 'none' }")
-          : 'null') + ")")
-    }]
-  }
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+            },
+        ];
+    }
 }
 
-/*  */
-
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
 // optimizability constants
-var optimizability = {
-  FALSE: 0,    // whole sub tree un-optimizable
-  FULL: 1,     // whole sub tree optimizable
-  SELF: 2,     // self optimizable but has some un-optimizable children
-  CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4   // self un-optimizable with some un-optimizable children
+const optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
 };
-
-var isPlatformReservedTag$1;
-
-function optimize$1 (root, options) {
-  if (!root) { return }
-  isPlatformReservedTag$1 = options.isReservedTag || no;
-  walk(root, true);
-}
-
-function walk (node, isRoot) {
-  if (isUnOptimizableTree(node)) {
-    node.ssrOptimizability = optimizability.FALSE;
-    return
-  }
-  // root node or nodes with custom directives should always be a VNode
-  var selfUnoptimizable = isRoot || hasCustomDirective(node);
-  var check = function (child) {
-    if (child.ssrOptimizability !== optimizability.FULL) {
-      node.ssrOptimizability = selfUnoptimizable
-        ? optimizability.PARTIAL
-        : optimizability.SELF;
-    }
-  };
-  if (selfUnoptimizable) {
-    node.ssrOptimizability = optimizability.CHILDREN;
-  }
-  if (node.type === 1) {
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      walk(child);
-      check(child);
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        walk(block, isRoot);
-        check(block);
-      }
-    }
-    if (node.ssrOptimizability == null ||
-      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-    ) {
-      node.ssrOptimizability = optimizability.FULL;
-    } else {
-      node.children = optimizeSiblings(node);
-    }
-  } else {
-    node.ssrOptimizability = optimizability.FULL;
-  }
-}
-
-function optimizeSiblings (el) {
-  var children = el.children;
-  var optimizedChildren = [];
-
-  var currentOptimizableGroup = [];
-  var pushGroup = function () {
-    if (currentOptimizableGroup.length) {
-      optimizedChildren.push({
-        type: 1,
-        parent: el,
-        tag: 'template',
-        attrsList: [],
-        attrsMap: {},
-        rawAttrsMap: {},
-        children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
-      });
+let isPlatformReservedTag;
+function optimize(root, options) {
+    if (!root)
+        return;
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+    const check = (child) => {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
     }
-    currentOptimizableGroup = [];
-  };
-
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.ssrOptimizability === optimizability.FULL) {
-      currentOptimizableGroup.push(c);
-    } else {
-      // wrap fully-optimizable adjacent siblings inside a template tag
-      // so that they can be optimized into a single ssrNode by codegen
-      pushGroup();
-      optimizedChildren.push(c);
-    }
-  }
-  pushGroup();
-  return optimizedChildren
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    const children = el.children;
+    const optimizedChildren = [];
+    let currentOptimizableGroup = [];
+    const pushGroup = () => {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
 }
-
-function isUnOptimizableTree (node) {
-  if (node.type === 2 || node.type === 3) { // text or expression
-    return false
-  }
-  return (
-    isBuiltInTag(node.tag) || // built-in (slot, component)
-    !isPlatformReservedTag$1(node.tag) || // custom component
-    !!node.component || // "is" component
-    isSelectWithModel(node) // <select v-model> requires runtime inspection
-  )
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
 }
-
-var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-
-function hasCustomDirective (node) {
-  return (
-    node.type === 1 &&
-    node.directives &&
-    node.directives.some(function (d) { return !isBuiltInDir(d.name); })
-  )
+const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some((d) => !isBuiltInDir(d.name)));
 }
-
 // <select v-model> cannot be optimized because it requires a runtime check
 // to determine proper selected option
-function isSelectWithModel (node) {
-  return (
-    node.type === 1 &&
-    node.tag === 'select' &&
-    node.directives != null &&
-    node.directives.some(function (d) { return d.name === 'model'; })
-  )
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some((d) => d.name === 'model'));
 }
 
-/*  */
-
-
-
-
+// The SSR codegen is essentially extending the default codegen to handle
 // segment types
-var RAW = 0;
-var INTERPOLATION = 1;
-var EXPRESSION = 2;
-
-function generate$1 (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genSSRElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genSSRElement (el, state) {
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genSSRElement)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state, genSSRElement)
-  } else if (el.tag === 'template' && !el.slotTarget) {
-    return el.ssrOptimizability === optimizability.FULL
-      ? genChildrenAsStringNode(el, state)
-      : genSSRChildren(el, state) || 'void 0'
-  }
-
-  switch (el.ssrOptimizability) {
-    case optimizability.FULL:
-      // stringify whole tree
-      return genStringElement(el, state)
-    case optimizability.SELF:
-      // stringify self and check children
-      return genStringElementWithChildren(el, state)
-    case optimizability.CHILDREN:
-      // generate self as VNode and stringify children
-      return genNormalElement(el, state, true)
-    case optimizability.PARTIAL:
-      // generate self as VNode and check children
-      return genNormalElement(el, state, false)
-    default:
-      // bail whole tree
-      return genElement(el, state)
-  }
-}
-
-function genNormalElement (el, state, stringifyChildren) {
-  var data = el.plain ? undefined : genData$2(el, state);
-  var children = stringifyChildren
-    ? ("[" + (genChildrenAsStringNode(el, state)) + "]")
-    : genSSRChildren(el, state, true);
-  return ("_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")")
-}
-
-function genSSRChildren (el, state, checkSkip) {
-  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-}
-
-function genSSRNode (el, state) {
-  return el.type === 1
-    ? genSSRElement(el, state)
-    : genText(el)
-}
-
-function genChildrenAsStringNode (el, state) {
-  return el.children.length
-    ? ("_ssrNode(" + (flattenSegments(childrenToSegments(el, state))) + ")")
-    : ''
-}
-
-function genStringElement (el, state) {
-  return ("_ssrNode(" + (elementToString(el, state)) + ")")
-}
-
-function genStringElementWithChildren (el, state) {
-  var children = genSSRChildren(el, state, true);
-  return ("_ssrNode(" + (flattenSegments(elementToOpenTagSegments(el, state))) + ",\"</" + (el.tag) + ">\"" + (children ? ("," + children) : '') + ")")
-}
-
-function elementToString (el, state) {
-  return ("(" + (flattenSegments(elementToSegments(el, state))) + ")")
-}
-
-function elementToSegments (el, state) {
-  // v-for / v-if
-  if (el.for && !el.forProcessed) {
-    el.forProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genFor(el, state, elementToString, '_ssrList')
-    }]
-  } else if (el.if && !el.ifProcessed) {
-    el.ifProcessed = true;
-    return [{
-      type: EXPRESSION,
-      value: genIf(el, state, elementToString, '"<!---->"')
-    }]
-  } else if (el.tag === 'template') {
-    return childrenToSegments(el, state)
-  }
-
-  var openSegments = elementToOpenTagSegments(el, state);
-  var childrenSegments = childrenToSegments(el, state);
-  var ref = state.options;
-  var isUnaryTag = ref.isUnaryTag;
-  var close = (isUnaryTag && isUnaryTag(el.tag))
-    ? []
-    : [{ type: RAW, value: ("</" + (el.tag) + ">") }];
-  return openSegments.concat(childrenSegments, close)
-}
-
-function elementToOpenTagSegments (el, state) {
-  applyModelTransform(el, state);
-  var binding;
-  var segments = [{ type: RAW, value: ("<" + (el.tag)) }];
-  // attrs
-  if (el.attrs) {
-    segments.push.apply(segments, genAttrSegments(el.attrs));
-  }
-  // domProps
-  if (el.props) {
-    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-  }
-  // v-bind="object"
-  if ((binding = el.attrsMap['v-bind'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrAttrs(" + binding + ")") });
-  }
-  // v-bind.prop="object"
-  if ((binding = el.attrsMap['v-bind.prop'])) {
-    segments.push({ type: EXPRESSION, value: ("_ssrDOMProps(" + binding + ")") });
-  }
-  // class
-  if (el.staticClass || el.classBinding) {
-    segments.push.apply(
-      segments,
-      genClassSegments(el.staticClass, el.classBinding)
-    );
-  }
-  // style & v-show
-  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-    segments.push.apply(
-      segments,
-      genStyleSegments(
-        el.attrsMap.style,
-        el.staticStyle,
-        el.styleBinding,
-        el.attrsMap['v-show']
-      )
-    );
-  }
-  // _scopedId
-  if (state.options.scopeId) {
-    segments.push({ type: RAW, value: (" " + (state.options.scopeId)) });
-  }
-  segments.push({ type: RAW, value: ">" });
-  return segments
-}
-
-function childrenToSegments (el, state) {
-  var binding;
-  if ((binding = el.attrsMap['v-html'])) {
-    return [{ type: EXPRESSION, value: ("_s(" + binding + ")") }]
-  }
-  if ((binding = el.attrsMap['v-text'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-    return [{ type: INTERPOLATION, value: ("_s(" + binding + ")") }]
-  }
-  return el.children
-    ? nodesToSegments(el.children, state)
-    : []
+const RAW = 0;
+const INTERPOLATION = 1;
+const EXPRESSION = 2;
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
 }
-
-function nodesToSegments (
-  children,
-  state
-) {
-  var segments = [];
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i];
-    if (c.type === 1) {
-      segments.push.apply(segments, elementToSegments(c, state));
-    } else if (c.type === 2) {
-      segments.push({ type: INTERPOLATION, value: c.expression });
-    } else if (c.type === 3) {
-      var text = escape(c.text);
-      if (c.isComment) {
-        text = '<!--' + text + '-->';
-      }
-      segments.push({ type: RAW, value: text });
-    }
-  }
-  return segments
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    const data = el.plain ? undefined : genData(el, state);
+    const children = stringifyChildren
+        ? `[${genChildrenAsStringNode(el, state)}]`
+        : genSSRChildren(el, state, true);
+    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+        : '';
+}
+function genStringElement(el, state) {
+    return `_ssrNode(${elementToString(el, state)})`;
+}
+function genStringElementWithChildren(el, state) {
+    const children = genSSRChildren(el, state, true);
+    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+}
+function elementToString(el, state) {
+    return `(${flattenSegments(elementToSegments(el, state))})`;
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            },
+        ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            },
+        ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    const openSegments = elementToOpenTagSegments(el, state);
+    const childrenSegments = childrenToSegments(el, state);
+    const { isUnaryTag } = state.options;
+    const close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: `</${el.tag}>` }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    let binding;
+    const segments = [{ type: RAW, value: `<${el.tag}` }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+    }
+    segments.push({ type: RAW, value: `>` });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    let binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    const segments = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            let text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
 }
-
-function flattenSegments (segments) {
-  var mergedSegments = [];
-  var textBuffer = '';
-
-  var pushBuffer = function () {
-    if (textBuffer) {
-      mergedSegments.push(JSON.stringify(textBuffer));
-      textBuffer = '';
+function flattenSegments(segments) {
+    const mergedSegments = [];
+    let textBuffer = '';
+    const pushBuffer = () => {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(`_ssrEscape(${s.value})`);
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(`(${s.value})`);
+        }
     }
-  };
-
-  for (var i = 0; i < segments.length; i++) {
-    var s = segments[i];
-    if (s.type === RAW) {
-      textBuffer += s.value;
-    } else if (s.type === INTERPOLATION) {
-      pushBuffer();
-      mergedSegments.push(("_ssrEscape(" + (s.value) + ")"));
-    } else if (s.type === EXPRESSION) {
-      pushBuffer();
-      mergedSegments.push(("(" + (s.value) + ")"));
-    }
-  }
-  pushBuffer();
-
-  return mergedSegments.join('+')
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-/*  */
-
-var createCompiler$1 = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  optimize$1(ast, options);
-  var code = generate$1(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    optimize(ast, options);
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
-/*  */
+const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-var ref$1 = createCompiler$1(baseOptions);
-var compile$1 = ref$1.compile;
-var compileToFunctions$1 = ref$1.compileToFunctions;
-
-/*  */
-
-exports.parseComponent = parseComponent;
-exports.compile = compile;
-exports.compileToFunctions = compileToFunctions;
-exports.ssrCompile = compile$1;
-exports.ssrCompileToFunctions = compileToFunctions$1;
+exports.compile = compile$1;
+exports.compileToFunctions = compileToFunctions$1;
 exports.generateCodeFrame = generateCodeFrame;
+exports.parseComponent = parseComponent;
+exports.ssrCompile = compile;
+exports.ssrCompileToFunctions = compileToFunctions;
diff --git a/scripts/config.js b/scripts/config.js
index 6ca5a816b47..0b030893407 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -267,9 +267,9 @@ function genConfig (name) {
   vars.preventAssignment = true
   config.plugins.push(replace(vars))
 
-  if (opts.transpile !== false) {
-    config.plugins.push(buble())
-  }
+  // if (opts.transpile !== false) {
+  //   config.plugins.push(buble())
+  // }
 
   Object.defineProperty(config, '_name', {
     enumerable: false,
diff --git a/src/compiler/error-detector.ts b/src/compiler/error-detector.ts
index 3b81742298f..33b37595999 100644
--- a/src/compiler/error-detector.ts
+++ b/src/compiler/error-detector.ts
@@ -117,7 +117,7 @@ function checkExpression(
 ) {
   try {
     new Function(`return ${exp}`)
-  } catch (e) {
+  } catch (e:any) {
     const keywordMatch = exp
       .replace(stripStringRE, '')
       .match(prohibitedKeywordRE)
@@ -146,7 +146,7 @@ function checkFunctionParameterExpression(
 ) {
   try {
     new Function(exp, '')
-  } catch (e) {
+  } catch (e:any) {
     warn(
       `invalid function parameter expression: ${e.message} in\n\n` +
         `    ${exp}\n\n` +
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index 125655e1d21..e9d467c2d7d 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -35,7 +35,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
       // detect possible CSP restriction
       try {
         new Function('return 1')
-      } catch (e) {
+      } catch (e:any) {
         if (e.toString().match(/unsafe-eval|CSP/)) {
           warn(
             'It seems you are using the standalone build of Vue.js in an ' +
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 887beb61531..39c3b359206 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -115,7 +115,7 @@ export function renderMixin(Vue: Component) {
       // when parent component is patched.
       currentRenderingInstance = vm
       vnode = render.call(vm._renderProxy, vm.$createElement)
-    } catch (e) {
+    } catch (e: any) {
       handleError(e, vm, `render`)
       // return error render result,
       // or previous vnode to prevent render error causing blank component
@@ -127,7 +127,7 @@ export function renderMixin(Vue: Component) {
             vm.$createElement,
             e
           )
-        } catch (e) {
+        } catch (e:any) {
           handleError(e, vm, `renderError`)
           vnode = vm._vnode
         }
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 9460f45bb9a..04e609f9567 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -113,6 +113,7 @@ export default class Watcher {
       value = this.getter.call(vm, vm)
     } catch (e) {
       if (this.user) {
+        // @ts-expect-error e is unknown, should we cast or any?
         handleError(e, vm, `getter for watcher "${this.expression}"`)
       } else {
         throw e
diff --git a/src/core/util/env.ts b/src/core/util/env.ts
index 49c08f13d47..95cbe7e71f7 100644
--- a/src/core/util/env.ts
+++ b/src/core/util/env.ts
@@ -75,10 +75,8 @@ let _Set // $flow-disable-line
 } else {
   // a non-standard Set polyfill that only works with primitive keys.
   _Set = class Set implements SimpleSet {
-    set: Object
-    constructor() {
-      this.set = Object.create(null)
-    }
+    set: Record<string, boolean> = Object.create(null)
+
     has(key: string | number) {
       return this.set[key] === true
     }
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index ed7c5393ed0..54d2d5ac3eb 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -48,6 +48,7 @@ export function invokeWithErrorHandling(
       res._handled = true
     }
   } catch (e) {
+    // @ts-expect-error should it be any?
     handleError(e, vm, info)
   }
   return res
@@ -57,7 +58,7 @@ function globalHandleError(err, vm, info) {
   if (config.errorHandler) {
     try {
       return config.errorHandler.call(null, err, vm, info)
-    } catch (e) {
+    } catch (e: any) {
       // if the user intentionally throws the original error in the handler,
       // do not log it twice
       if (e !== err) {
diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index 3f0c80a0e23..a1f13450d9f 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -92,6 +92,7 @@ export function nextTick(cb?: Function, ctx?: Object) {
       try {
         cb.call(ctx)
       } catch (e) {
+        // @ts-expect-error should it be any?
         handleError(e, ctx, 'nextTick')
       }
     } else if (_resolve) {
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index feba56d96cb..ecba4d691d8 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -61,7 +61,7 @@ function normalizeScopedSlot(normalSlots, key, fn) {
       res && typeof res === "object" && !Array.isArray(res)
         ? [res] // single vnode
         : normalizeChildren(res);
-    let vnode: VNode | null = res && res[0];
+    const vnode: VNode | null = res && res[0];
     return res &&
       (!vnode ||
         (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index dd17ca19069..b86f864a0ce 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -121,6 +121,7 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy?: any) {
     try {
       fn(vnode.elm, dir, vnode, oldVnode, isDestroy)
     } catch (e) {
+     // @ts-expect-error should it be any?
       handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`)
     }
   }
diff --git a/src/platforms/web/runtime/transition-util.ts b/src/platforms/web/runtime/transition-util.ts
index f18090e4e10..d327e29b82d 100644
--- a/src/platforms/web/runtime/transition-util.ts
+++ b/src/platforms/web/runtime/transition-util.ts
@@ -45,7 +45,6 @@ if (hasTransition) {
   /* istanbul ignore if */
   if (
     window.ontransitionend === undefined &&
-    // @ts-expect-error
     window.onwebkittransitionend !== undefined
   ) {
     transitionProp = 'WebkitTransition'
@@ -53,7 +52,6 @@ if (hasTransition) {
   }
   if (
     window.onanimationend === undefined &&
-    // @ts-expect-error
     window.onwebkitanimationend !== undefined
   ) {
     animationProp = 'WebkitAnimation'
diff --git a/src/platforms/web/util/class.ts b/src/platforms/web/util/class.ts
index 52dbefa7c05..24255cc7bbf 100644
--- a/src/platforms/web/util/class.ts
+++ b/src/platforms/web/util/class.ts
@@ -13,6 +13,7 @@ export function genClassForVnode(vnode: VNodeWithData): string {
       data = mergeClassData(childNode.data, data)
     }
   }
+  // @ts-expect-error parentNode.parent not VNodeWithData
   while (isDef((parentNode = parentNode.parent))) {
     if (parentNode && parentNode.data) {
       data = mergeClassData(data, parentNode.data)
diff --git a/src/platforms/web/util/style.ts b/src/platforms/web/util/style.ts
index 524c86804c7..20d2d40fec8 100644
--- a/src/platforms/web/util/style.ts
+++ b/src/platforms/web/util/style.ts
@@ -62,6 +62,7 @@ export function getStyle(vnode: VNodeWithData, checkChild: boolean): Object {
   }
 
   let parentNode: VNodeWithData | VNode | undefined = vnode
+  // @ts-expect-error parentNode.parent not VNodeWithData
   while ((parentNode = parentNode.parent)) {
     if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
       extend(res, styleData)
diff --git a/src/platforms/weex/entry-framework.ts b/src/platforms/weex/entry-framework.ts
index 257e230595d..6adb1173a6c 100644
--- a/src/platforms/weex/entry-framework.ts
+++ b/src/platforms/weex/entry-framework.ts
@@ -26,7 +26,7 @@ export function createInstanceContext(
     config: weex.config,
     document: weex.document,
     data
-  }
+  })
 
   // Each instance has an independent `Vue` module instance
   const Vue = instance.Vue = createVueModuleInstance(instanceId, weex)
diff --git a/src/platforms/weex/runtime/recycle-list/render-component-template.ts b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
index 8dd61955d95..e301e844b9e 100644
--- a/src/platforms/weex/runtime/recycle-list/render-component-template.ts
+++ b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
@@ -22,7 +22,7 @@ export function renderRecyclableComponentTemplate(
   if (render) {
     try {
       return render.call(vm)
-    } catch (err) {
+    } catch (err:any) {
       handleError(err, vm, `@render`)
     }
   } else {
diff --git a/yarn.lock b/yarn.lock
index 3879354d438..05838c71984 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,12 +2,13 @@
 # yarn lockfile v1
 
 
-"@babel/code-frame@7.12.11":
-  version "7.12.11"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.11.tgz#f4ad435aa263db935b8f10f2c552d23fb716a63f"
-  integrity sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw==
+"@ampproject/remapping@^2.1.0":
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.0.tgz#56c133824780de3174aed5ab6834f3026790154d"
+  integrity sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==
   dependencies:
-    "@babel/highlight" "^7.10.4"
+    "@jridgewell/gen-mapping" "^0.1.0"
+    "@jridgewell/trace-mapping" "^0.3.9"
 
 "@babel/code-frame@^7.0.0":
   version "7.0.0"
@@ -23,42 +24,43 @@
   dependencies:
     "@babel/highlight" "^7.12.13"
 
-"@babel/compat-data@^7.13.0", "@babel/compat-data@^7.13.12", "@babel/compat-data@^7.13.8":
+"@babel/code-frame@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.16.7.tgz#44416b6bd7624b998f5b1af5d470856c40138789"
+  integrity sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg==
+  dependencies:
+    "@babel/highlight" "^7.16.7"
+
+"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.17.0", "@babel/compat-data@^7.17.10":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.10.tgz#711dc726a492dfc8be8220028b1b92482362baab"
+  integrity sha512-GZt/TCsG70Ms19gfZO1tM4CVnXsPgEPBCpJu+Qz3L0LUDsY5nZqFZglIoPC1kIYOtNBZlrnFT+klg12vFGZXrw==
+
+"@babel/compat-data@^7.13.12":
   version "7.13.12"
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.13.12.tgz#a8a5ccac19c200f9dd49624cac6e19d7be1236a1"
   integrity sha512-3eJJ841uKxeV8dcN/2yGEUy+RfgQspPEgQat85umsE1rotuquQ2AbIub4S6j7c50a2d+4myc+zSlnXeIHrOnhQ==
 
-"@babel/core@^7.13.14":
-  version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.13.14.tgz#8e46ebbaca460a63497c797e574038ab04ae6d06"
-  integrity sha512-wZso/vyF4ki0l0znlgM4inxbdrUvCb+cVz8grxDq+6C9k6qbqoIJteQOKicaKjCipU3ISV+XedCqpL2RJJVehA==
-  dependencies:
-    "@babel/code-frame" "^7.12.13"
-    "@babel/generator" "^7.13.9"
-    "@babel/helper-compilation-targets" "^7.13.13"
-    "@babel/helper-module-transforms" "^7.13.14"
-    "@babel/helpers" "^7.13.10"
-    "@babel/parser" "^7.13.13"
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.13"
-    "@babel/types" "^7.13.14"
+"@babel/core@^7.12.3", "@babel/core@^7.17.10":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.10.tgz#74ef0fbf56b7dfc3f198fc2d927f4f03e12f4b05"
+  integrity sha512-liKoppandF3ZcBnIYFjfSDHZLKdLHGJRkoWtG8zQyGJBQfIYobpnVGI5+pLBNtS6psFLDzyq8+h5HiVljW9PNA==
+  dependencies:
+    "@ampproject/remapping" "^2.1.0"
+    "@babel/code-frame" "^7.16.7"
+    "@babel/generator" "^7.17.10"
+    "@babel/helper-compilation-targets" "^7.17.10"
+    "@babel/helper-module-transforms" "^7.17.7"
+    "@babel/helpers" "^7.17.9"
+    "@babel/parser" "^7.17.10"
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.17.10"
+    "@babel/types" "^7.17.10"
     convert-source-map "^1.7.0"
     debug "^4.1.0"
     gensync "^1.0.0-beta.2"
-    json5 "^2.1.2"
+    json5 "^2.2.1"
     semver "^6.3.0"
-    source-map "^0.5.0"
-
-"@babel/generator@^7.0.0", "@babel/generator@^7.2.2":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.2.2.tgz#18c816c70962640eab42fe8cae5f3947a5c65ccc"
-  integrity sha512-I4o675J/iS8k+P38dvJ3IBGqObLXyQLTxtrR4u9cSUJOURvafeEWb/pFMOTwtNrmq73mJzyF6ueTbO1BtN0Zeg==
-  dependencies:
-    "@babel/types" "^7.2.2"
-    jsesc "^2.5.1"
-    lodash "^4.17.10"
-    source-map "^0.5.0"
-    trim-right "^1.0.1"
 
 "@babel/generator@^7.13.9":
   version "7.13.9"
@@ -69,6 +71,15 @@
     jsesc "^2.5.1"
     source-map "^0.5.0"
 
+"@babel/generator@^7.17.10":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.17.10.tgz#c281fa35b0c349bbe9d02916f4ae08fc85ed7189"
+  integrity sha512-46MJZZo9y3o4kmhBVc7zW7i8dtR1oIK/sdO5NcfcZRhTGYi+KKJRtHNgsU6c4VUcJmUNV/LQdebD/9Dlv4K+Tg==
+  dependencies:
+    "@babel/types" "^7.17.10"
+    "@jridgewell/gen-mapping" "^0.1.0"
+    jsesc "^2.5.1"
+
 "@babel/helper-annotate-as-pure@^7.12.13":
   version "7.12.13"
   resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz#0f58e86dfc4bb3b1fcd7db806570e177d439b6ab"
@@ -76,15 +87,22 @@
   dependencies:
     "@babel/types" "^7.12.13"
 
-"@babel/helper-builder-binary-assignment-operator-visitor@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.12.13.tgz#6bc20361c88b0a74d05137a65cac8d3cbf6f61fc"
-  integrity sha512-CZOv9tGphhDRlVjVkAgm8Nhklm9RzSmWpX2my+t7Ua/KT616pEzXsQCjinzvkRvHWJ9itO4f296efroX23XCMA==
+"@babel/helper-annotate-as-pure@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.16.7.tgz#bb2339a7534a9c128e3102024c60760a3a7f3862"
+  integrity sha512-s6t2w/IPQVTAET1HitoowRGXooX8mCgtuP5195wD/QJPV6wYjpujCGF7JuMODVX2ZAJOf1GT6DT9MHEZvLOFSw==
   dependencies:
-    "@babel/helper-explode-assignable-expression" "^7.12.13"
-    "@babel/types" "^7.12.13"
+    "@babel/types" "^7.16.7"
+
+"@babel/helper-builder-binary-assignment-operator-visitor@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.16.7.tgz#38d138561ea207f0f69eb1626a418e4f7e6a580b"
+  integrity sha512-C6FdbRaxYjwVu/geKW4ZeQ0Q31AftgRcdSnZ5/jsH6BzCJbtvXvhpfkbkThYSuutZA7nCXpPR6AD9zd1dprMkA==
+  dependencies:
+    "@babel/helper-explode-assignable-expression" "^7.16.7"
+    "@babel/types" "^7.16.7"
 
-"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.13.10", "@babel/helper-compilation-targets@^7.13.13", "@babel/helper-compilation-targets@^7.13.8":
+"@babel/helper-compilation-targets@^7.13.0":
   version "7.13.13"
   resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.13.tgz#2b2972a0926474853f41e4adbc69338f520600e5"
   integrity sha512-q1kcdHNZehBwD9jYPh3WyXcsFERi39X4I59I3NadciWtNDyZ6x+GboOxncFK0kXlKIv6BJm5acncehXWUjWQMQ==
@@ -94,16 +112,28 @@
     browserslist "^4.14.5"
     semver "^6.3.0"
 
-"@babel/helper-create-class-features-plugin@^7.13.0":
-  version "7.13.11"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.11.tgz#30d30a005bca2c953f5653fc25091a492177f4f6"
-  integrity sha512-ays0I7XYq9xbjCSvT+EvysLgfc3tOkwCULHjrnscGT3A9qD4sk3wXnJ3of0MAWsWGjdinFvajHU2smYuqXKMrw==
+"@babel/helper-compilation-targets@^7.16.7", "@babel/helper-compilation-targets@^7.17.10":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.17.10.tgz#09c63106d47af93cf31803db6bc49fef354e2ebe"
+  integrity sha512-gh3RxjWbauw/dFiU/7whjd0qN9K6nPJMqe6+Er7rOavFh0CQUSwhAE3IcTho2rywPJFxej6TUUHDkWcYI6gGqQ==
   dependencies:
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-member-expression-to-functions" "^7.13.0"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/helper-replace-supers" "^7.13.0"
-    "@babel/helper-split-export-declaration" "^7.12.13"
+    "@babel/compat-data" "^7.17.10"
+    "@babel/helper-validator-option" "^7.16.7"
+    browserslist "^4.20.2"
+    semver "^6.3.0"
+
+"@babel/helper-create-class-features-plugin@^7.16.10", "@babel/helper-create-class-features-plugin@^7.16.7", "@babel/helper-create-class-features-plugin@^7.17.6":
+  version "7.17.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.17.9.tgz#71835d7fb9f38bd9f1378e40a4c0902fdc2ea49d"
+  integrity sha512-kUjip3gruz6AJKOq5i3nC6CoCEEF/oHH3cp6tOZhB+IyyyPyW0g1Gfsxn3mkk6S08pIA2y8GQh609v9G/5sHVQ==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.16.7"
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-function-name" "^7.17.9"
+    "@babel/helper-member-expression-to-functions" "^7.17.7"
+    "@babel/helper-optimise-call-expression" "^7.16.7"
+    "@babel/helper-replace-supers" "^7.16.7"
+    "@babel/helper-split-export-declaration" "^7.16.7"
 
 "@babel/helper-create-regexp-features-plugin@^7.12.13":
   version "7.12.17"
@@ -113,10 +143,18 @@
     "@babel/helper-annotate-as-pure" "^7.12.13"
     regexpu-core "^4.7.1"
 
-"@babel/helper-define-polyfill-provider@^0.1.5":
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.1.5.tgz#3c2f91b7971b9fc11fe779c945c014065dea340e"
-  integrity sha512-nXuzCSwlJ/WKr8qxzW816gwyT6VZgiJG17zR40fou70yfAcqjoNyTLl/DQ+FExw5Hx5KNqshmN8Ldl/r2N7cTg==
+"@babel/helper-create-regexp-features-plugin@^7.16.7", "@babel/helper-create-regexp-features-plugin@^7.17.0":
+  version "7.17.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.17.0.tgz#1dcc7d40ba0c6b6b25618997c5dbfd310f186fe1"
+  integrity sha512-awO2So99wG6KnlE+TPs6rn83gCz5WlEePJDTnLEqbchMVrBeAujURVphRdigsk094VhvZehFoNOihSlcBjwsXA==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.16.7"
+    regexpu-core "^5.0.1"
+
+"@babel/helper-define-polyfill-provider@^0.3.1":
+  version "0.3.1"
+  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.3.1.tgz#52411b445bdb2e676869e5a74960d2d3826d2665"
+  integrity sha512-J9hGMpJQmtWmj46B3kBHmL38UhJGhYX7eqkcq+2gsstyYt341HmPeWspihX43yVRA0mS+8GGk2Gckc7bY/HCmA==
   dependencies:
     "@babel/helper-compilation-targets" "^7.13.0"
     "@babel/helper-module-imports" "^7.12.13"
@@ -127,21 +165,19 @@
     resolve "^1.14.2"
     semver "^6.1.2"
 
-"@babel/helper-explode-assignable-expression@^7.12.13":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.13.0.tgz#17b5c59ff473d9f956f40ef570cf3a76ca12657f"
-  integrity sha512-qS0peLTDP8kOisG1blKbaoBg/o9OSa1qoumMjTK5pM+KDTtpxpsiubnCGP34vK8BXGcb2M9eigwgvoJryrzwWA==
+"@babel/helper-environment-visitor@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.16.7.tgz#ff484094a839bde9d89cd63cba017d7aae80ecd7"
+  integrity sha512-SLLb0AAn6PkUeAfKJCCOl9e1R53pQlGAfc4y4XuMRZfqeMYLE0dM1LMhqbGAlGQY0lfw5/ohoYWAe9V1yibRag==
   dependencies:
-    "@babel/types" "^7.13.0"
+    "@babel/types" "^7.16.7"
 
-"@babel/helper-function-name@^7.1.0":
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.1.0.tgz#a0ceb01685f73355d4360c1247f582bfafc8ff53"
-  integrity sha512-A95XEoCpb3TO+KZzJ4S/5uW5fNe26DjBGqf1o9ucyLyCmi1dXq/B3c8iaWTfBk3VvetUxl16e8tIrd5teOCfGw==
+"@babel/helper-explode-assignable-expression@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.16.7.tgz#12a6d8522fdd834f194e868af6354e8650242b7a"
+  integrity sha512-KyUenhWMC8VrxzkGP0Jizjo4/Zx+1nNZhgocs+gLzyZyB8SHidhoq9KK/8Ato4anhwsivfkBLftky7gvzbZMtQ==
   dependencies:
-    "@babel/helper-get-function-arity" "^7.0.0"
-    "@babel/template" "^7.1.0"
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.16.7"
 
 "@babel/helper-function-name@^7.12.13":
   version "7.12.13"
@@ -152,12 +188,13 @@
     "@babel/template" "^7.12.13"
     "@babel/types" "^7.12.13"
 
-"@babel/helper-get-function-arity@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0.tgz#83572d4320e2a4657263734113c42868b64e49c3"
-  integrity sha512-r2DbJeg4svYvt3HOS74U4eWKsUAMRH01Z1ds1zx8KNTPtpTL5JAsdFv8BNyOpVqdFhHkkRDIg5B4AsxmkjAlmQ==
+"@babel/helper-function-name@^7.16.7", "@babel/helper-function-name@^7.17.9":
+  version "7.17.9"
+  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.17.9.tgz#136fcd54bc1da82fcb47565cf16fd8e444b1ff12"
+  integrity sha512-7cRisGlVtiVqZ0MW0/yFB4atgpGLWEHUVYnb448hZK4x+vih0YO5UoS11XIYtZYqHd0dIPMdUSv8q5K4LdMnIg==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/template" "^7.16.7"
+    "@babel/types" "^7.17.0"
 
 "@babel/helper-get-function-arity@^7.12.13":
   version "7.12.13"
@@ -166,93 +203,98 @@
   dependencies:
     "@babel/types" "^7.12.13"
 
-"@babel/helper-hoist-variables@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.0.tgz#5d5882e855b5c5eda91e0cadc26c6e7a2c8593d8"
-  integrity sha512-0kBzvXiIKfsCA0y6cFEIJf4OdzfpRuNk4+YTeHZpGGc666SATFKTz6sRncwFnQk7/ugJ4dSrCj6iJuvW4Qwr2g==
+"@babel/helper-hoist-variables@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.16.7.tgz#86bcb19a77a509c7b77d0e22323ef588fa58c246"
+  integrity sha512-m04d/0Op34H5v7pbZw6pSKP7weA6lsMvfiIAMeIvkY/R4xQtBSMFEigu9QTZ2qB/9l22vsxtM8a+Q8CzD255fg==
   dependencies:
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
+    "@babel/types" "^7.16.7"
 
-"@babel/helper-member-expression-to-functions@^7.13.0", "@babel/helper-member-expression-to-functions@^7.13.12":
-  version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.12.tgz#dfe368f26d426a07299d8d6513821768216e6d72"
-  integrity sha512-48ql1CLL59aKbU94Y88Xgb2VFy7a95ykGRbJJaaVv+LX5U8wFpLfiGXJJGUozsmA1oEh/o5Bp60Voq7ACyA/Sw==
+"@babel/helper-member-expression-to-functions@^7.16.7", "@babel/helper-member-expression-to-functions@^7.17.7":
+  version "7.17.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.17.7.tgz#a34013b57d8542a8c4ff8ba3f747c02452a4d8c4"
+  integrity sha512-thxXgnQ8qQ11W2wVUObIqDL4p148VMxkt5T/qpN5k2fboRyzFGFmKsTGViquyM5QHKUy48OZoca8kw4ajaDPyw==
   dependencies:
-    "@babel/types" "^7.13.12"
+    "@babel/types" "^7.17.0"
 
-"@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.13.12":
+"@babel/helper-module-imports@^7.12.13":
   version "7.13.12"
   resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz#c6a369a6f3621cb25da014078684da9196b61977"
   integrity sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==
   dependencies:
     "@babel/types" "^7.13.12"
 
-"@babel/helper-module-transforms@^7.13.0", "@babel/helper-module-transforms@^7.13.14":
-  version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.13.14.tgz#e600652ba48ccb1641775413cb32cfa4e8b495ef"
-  integrity sha512-QuU/OJ0iAOSIatyVZmfqB0lbkVP0kDRiKj34xy+QNsnVZi/PA6BoSoreeqnxxa9EHFAIL0R9XOaAR/G9WlIy5g==
+"@babel/helper-module-imports@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.16.7.tgz#25612a8091a999704461c8a222d0efec5d091437"
+  integrity sha512-LVtS6TqjJHFc+nYeITRo6VLXve70xmq7wPhWTqDJusJEgGmkAACWwMiTNrvfoQo6hEhFwAIixNkvB0jPXDL8Wg==
   dependencies:
-    "@babel/helper-module-imports" "^7.13.12"
-    "@babel/helper-replace-supers" "^7.13.12"
-    "@babel/helper-simple-access" "^7.13.12"
-    "@babel/helper-split-export-declaration" "^7.12.13"
-    "@babel/helper-validator-identifier" "^7.12.11"
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.13"
-    "@babel/types" "^7.13.14"
+    "@babel/types" "^7.16.7"
 
-"@babel/helper-optimise-call-expression@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz#5c02d171b4c8615b1e7163f888c1c81c30a2aaea"
-  integrity sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==
+"@babel/helper-module-transforms@^7.16.7", "@babel/helper-module-transforms@^7.17.7":
+  version "7.17.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.17.7.tgz#3943c7f777139e7954a5355c815263741a9c1cbd"
+  integrity sha512-VmZD99F3gNTYB7fJRDTi+u6l/zxY0BE6OIxPSU7a50s6ZUQkHwSDmV92FfM+oCG0pZRVojGYhkR8I0OGeCVREw==
   dependencies:
-    "@babel/types" "^7.12.13"
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-module-imports" "^7.16.7"
+    "@babel/helper-simple-access" "^7.17.7"
+    "@babel/helper-split-export-declaration" "^7.16.7"
+    "@babel/helper-validator-identifier" "^7.16.7"
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.17.3"
+    "@babel/types" "^7.17.0"
+
+"@babel/helper-optimise-call-expression@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.16.7.tgz#a34e3560605abbd31a18546bd2aad3e6d9a174f2"
+  integrity sha512-EtgBhg7rd/JcnpZFXpBy0ze1YRfdm7BnBX4uKMBd3ixa3RGAE002JZB66FJyNH7g0F38U05pXmA5P8cBh7z+1w==
+  dependencies:
+    "@babel/types" "^7.16.7"
 
 "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
   version "7.13.0"
   resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz#806526ce125aed03373bc416a828321e3a6a33af"
   integrity sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==
 
-"@babel/helper-remap-async-to-generator@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.13.0.tgz#376a760d9f7b4b2077a9dd05aa9c3927cadb2209"
-  integrity sha512-pUQpFBE9JvC9lrQbpX0TmeNIy5s7GnZjna2lhhcHC7DzgBs6fWn722Y5cfwgrtrqc7NAJwMvOa0mKhq6XaE4jg==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.12.13"
-    "@babel/helper-wrap-function" "^7.13.0"
-    "@babel/types" "^7.13.0"
+"@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.16.7.tgz#aa3a8ab4c3cceff8e65eb9e73d87dc4ff320b2f5"
+  integrity sha512-Qg3Nk7ZxpgMrsox6HreY1ZNKdBq7K72tDSliA6dCl5f007jR4ne8iD5UzuNnCJH2xBf2BEEVGr+/OL6Gdp7RxA==
 
-"@babel/helper-replace-supers@^7.12.13", "@babel/helper-replace-supers@^7.13.0", "@babel/helper-replace-supers@^7.13.12":
-  version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.13.12.tgz#6442f4c1ad912502481a564a7386de0c77ff3804"
-  integrity sha512-Gz1eiX+4yDO8mT+heB94aLVNCL+rbuT2xy4YfyNqu8F+OI6vMvJK891qGBTqL9Uc8wxEvRW92Id6G7sDen3fFw==
+"@babel/helper-remap-async-to-generator@^7.16.8":
+  version "7.16.8"
+  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.16.8.tgz#29ffaade68a367e2ed09c90901986918d25e57e3"
+  integrity sha512-fm0gH7Flb8H51LqJHy3HJ3wnE1+qtYR2A99K06ahwrawLdOFsCEWjZOrYricXJHoPSudNKxrMBUPEIPxiIIvBw==
   dependencies:
-    "@babel/helper-member-expression-to-functions" "^7.13.12"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.12"
+    "@babel/helper-annotate-as-pure" "^7.16.7"
+    "@babel/helper-wrap-function" "^7.16.8"
+    "@babel/types" "^7.16.8"
 
-"@babel/helper-simple-access@^7.12.13", "@babel/helper-simple-access@^7.13.12":
-  version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz#dd6c538afb61819d205a012c31792a39c7a5eaf6"
-  integrity sha512-7FEjbrx5SL9cWvXioDbnlYTppcZGuCY6ow3/D5vMggb2Ywgu4dMrpTJX0JdQAIcRRUElOIxF3yEooa9gUb9ZbA==
+"@babel/helper-replace-supers@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.16.7.tgz#e9f5f5f32ac90429c1a4bdec0f231ef0c2838ab1"
+  integrity sha512-y9vsWilTNaVnVh6xiJfABzsNpgDPKev9HnAgz6Gb1p6UUwf9NepdlsV7VXGCftJM+jqD5f7JIEubcpLjZj5dBw==
   dependencies:
-    "@babel/types" "^7.13.12"
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-member-expression-to-functions" "^7.16.7"
+    "@babel/helper-optimise-call-expression" "^7.16.7"
+    "@babel/traverse" "^7.16.7"
+    "@babel/types" "^7.16.7"
 
-"@babel/helper-skip-transparent-expression-wrappers@^7.12.1":
-  version "7.12.1"
-  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz#462dc63a7e435ade8468385c63d2b84cce4b3cbf"
-  integrity sha512-Mf5AUuhG1/OCChOJ/HcADmvcHM42WJockombn8ATJG3OnyiSxBK/Mm5x78BQWvmtXZKHgbjdGL2kin/HOLlZGA==
+"@babel/helper-simple-access@^7.17.7":
+  version "7.17.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.17.7.tgz#aaa473de92b7987c6dfa7ce9a7d9674724823367"
+  integrity sha512-txyMCGroZ96i+Pxr3Je3lzEJjqwaRC9buMUgtomcrLe5Nd0+fk1h0LLA+ixUF5OW7AhHuQ7Es1WcQJZmZsz2XA==
   dependencies:
-    "@babel/types" "^7.12.1"
+    "@babel/types" "^7.17.0"
 
-"@babel/helper-split-export-declaration@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0.tgz#3aae285c0311c2ab095d997b8c9a94cad547d813"
-  integrity sha512-MXkOJqva62dfC0w85mEf/LucPPS/1+04nmmRMPEBUB++hiiThQ2zPtX/mEWQ3mtzCEjIJvPY8nuwxXtQeQwUag==
+"@babel/helper-skip-transparent-expression-wrappers@^7.16.0":
+  version "7.16.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.16.0.tgz#0ee3388070147c3ae051e487eca3ebb0e2e8bb09"
+  integrity sha512-+il1gTy0oHwUsBQZyJvukbB4vPMdcYBrFHa0Uc4AizLxbq6BOYC51Rv4tWocX9BLBDLZ4kc6qUFpQ6HRgL+3zw==
   dependencies:
-    "@babel/types" "^7.0.0"
+    "@babel/types" "^7.16.0"
 
 "@babel/helper-split-export-declaration@^7.12.13":
   version "7.12.13"
@@ -261,34 +303,51 @@
   dependencies:
     "@babel/types" "^7.12.13"
 
+"@babel/helper-split-export-declaration@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.16.7.tgz#0b648c0c42da9d3920d85ad585f2778620b8726b"
+  integrity sha512-xbWoy/PFoxSWazIToT9Sif+jJTlrMcndIsaOKvTA6u7QEo7ilkRZpjew18/W3c7nm8fXdUDXh02VXTbZ0pGDNw==
+  dependencies:
+    "@babel/types" "^7.16.7"
+
 "@babel/helper-validator-identifier@^7.12.11":
   version "7.12.11"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz#c9a1f021917dcb5ccf0d4e453e399022981fc9ed"
   integrity sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==
 
+"@babel/helper-validator-identifier@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.16.7.tgz#e8c602438c4a8195751243da9031d1607d247cad"
+  integrity sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw==
+
 "@babel/helper-validator-option@^7.12.17":
   version "7.12.17"
   resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz#d1fbf012e1a79b7eebbfdc6d270baaf8d9eb9831"
   integrity sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==
 
-"@babel/helper-wrap-function@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.13.0.tgz#bdb5c66fda8526ec235ab894ad53a1235c79fcc4"
-  integrity sha512-1UX9F7K3BS42fI6qd2A4BjKzgGjToscyZTdp1DjknHLCIvpgne6918io+aL5LXFcER/8QWiwpoY902pVEqgTXA==
+"@babel/helper-validator-option@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.16.7.tgz#b203ce62ce5fe153899b617c08957de860de4d23"
+  integrity sha512-TRtenOuRUVo9oIQGPC5G9DgK4743cdxvtOw0weQNpZXaS16SCBi5MNjZF8vba3ETURjZpTbVn7Vvcf2eAwFozQ==
+
+"@babel/helper-wrap-function@^7.16.8":
+  version "7.16.8"
+  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.16.8.tgz#58afda087c4cd235de92f7ceedebca2c41274200"
+  integrity sha512-8RpyRVIAW1RcDDGTA+GpPAwV22wXCfKOoM9bet6TLkGIFTkRQSkH1nMQ5Yet4MpoXe1ZwHPVtNasc2w0uZMqnw==
   dependencies:
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
+    "@babel/helper-function-name" "^7.16.7"
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.16.8"
+    "@babel/types" "^7.16.8"
 
-"@babel/helpers@^7.13.10":
-  version "7.13.10"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.13.10.tgz#fd8e2ba7488533cdeac45cc158e9ebca5e3c7df8"
-  integrity sha512-4VO883+MWPDUVRF3PhiLBUFHoX/bsLTGFpFK/HqvvfBZz2D57u9XzPVNFVBTc0PW/CWR9BXTOKt8NF4DInUHcQ==
+"@babel/helpers@^7.17.9":
+  version "7.17.9"
+  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.17.9.tgz#b2af120821bfbe44f9907b1826e168e819375a1a"
+  integrity sha512-cPCt915ShDWUEzEp3+UNRktO2n6v49l5RSnG9M5pS24hA+2FAc5si+Pn1i4VVbQQ+jh+bIZhPFQOJOzbrOYY1Q==
   dependencies:
-    "@babel/template" "^7.12.13"
-    "@babel/traverse" "^7.13.0"
-    "@babel/types" "^7.13.0"
+    "@babel/template" "^7.16.7"
+    "@babel/traverse" "^7.17.9"
+    "@babel/types" "^7.17.0"
 
 "@babel/highlight@^7.0.0":
   version "7.0.0"
@@ -299,7 +358,7 @@
     esutils "^2.0.2"
     js-tokens "^4.0.0"
 
-"@babel/highlight@^7.10.4", "@babel/highlight@^7.12.13":
+"@babel/highlight@^7.12.13":
   version "7.13.10"
   resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.13.10.tgz#a8b2a66148f5b27d666b15d81774347a731d52d1"
   integrity sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==
@@ -308,127 +367,170 @@
     chalk "^2.0.0"
     js-tokens "^4.0.0"
 
-"@babel/parser@^7.0.0", "@babel/parser@^7.2.2", "@babel/parser@^7.2.3":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.2.3.tgz#32f5df65744b70888d17872ec106b02434ba1489"
-  integrity sha512-0LyEcVlfCoFmci8mXx8A5oIkpkOgyo8dRHtxBnK9RRBwxO2+JZPNsqtVEZQ7mJFPxnXF9lfmU24mHOPI0qnlkA==
+"@babel/highlight@^7.16.7":
+  version "7.17.9"
+  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.17.9.tgz#61b2ee7f32ea0454612def4fccdae0de232b73e3"
+  integrity sha512-J9PfEKCbFIv2X5bjTMiZu6Vf341N05QIY+d6FvVKynkG1S7G0j3I0QoRtWIrXhZ+/Nlb5Q0MzqL7TokEJ5BNHg==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.16.7"
+    chalk "^2.0.0"
+    js-tokens "^4.0.0"
 
 "@babel/parser@^7.12.13", "@babel/parser@^7.13.13":
   version "7.13.13"
   resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.13.13.tgz#42f03862f4aed50461e543270916b47dd501f0df"
   integrity sha512-OhsyMrqygfk5v8HmWwOzlYjJrtLaFhF34MrfG/Z73DgYCI6ojNUTUp2TYbtnjo8PegeJp12eamsNettCQjKjVw==
 
-"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.13.12":
-  version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.13.12.tgz#a3484d84d0b549f3fc916b99ee4783f26fabad2a"
-  integrity sha512-d0u3zWKcoZf379fOeJdr1a5WPDny4aOFZ6hlfKivgK0LY7ZxNfoaHL2fWwdGtHyVvra38FC+HVYkO+byfSA8AQ==
+"@babel/parser@^7.14.7", "@babel/parser@^7.16.7", "@babel/parser@^7.17.10", "@babel/parser@^7.7.0":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.17.10.tgz#873b16db82a8909e0fbd7f115772f4b739f6ce78"
+  integrity sha512-n2Q6i+fnJqzOaq2VkdXxy2TCPCWQZHiCo0XqmrCvDWcZQKRyZzYi4Z0yxlBuN0w+r2ZHmre+Q087DSrw3pbJDQ==
+
+"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.16.7.tgz#4eda6d6c2a0aa79c70fa7b6da67763dfe2141050"
+  integrity sha512-anv/DObl7waiGEnC24O9zqL0pSuI9hljihqiDuFHC8d7/bjr/4RLGPWuc8rYOff/QPzbEPSkzG8wGG9aDuhHRg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
-    "@babel/plugin-proposal-optional-chaining" "^7.13.12"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-proposal-async-generator-functions@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.13.8.tgz#87aacb574b3bc4b5603f6fe41458d72a5a2ec4b1"
-  integrity sha512-rPBnhj+WgoSmgq+4gQUtXx/vOcU+UYtjy1AA/aeD61Hwj410fwYyqfUcRP3lR8ucgliVJL/G7sXcNUecC75IXA==
+"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.16.7.tgz#cc001234dfc139ac45f6bcf801866198c8c72ff9"
+  integrity sha512-di8vUHRdf+4aJ7ltXhaDbPoszdkh59AQtJM5soLsuHpQJdFQZOA4uGj0V2u/CZ8bJ/u8ULDL5yq6FO/bCXnKHw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-remap-async-to-generator" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.16.0"
+    "@babel/plugin-proposal-optional-chaining" "^7.16.7"
+
+"@babel/plugin-proposal-async-generator-functions@^7.16.8":
+  version "7.16.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.16.8.tgz#3bdd1ebbe620804ea9416706cd67d60787504bc8"
+  integrity sha512-71YHIvMuiuqWJQkebWJtdhQTfd4Q4mF76q2IX37uZPkG9+olBxsX+rH1vkhFto4UeJZ9dPY2s+mDvhDm1u2BGQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-remap-async-to-generator" "^7.16.8"
     "@babel/plugin-syntax-async-generators" "^7.8.4"
 
-"@babel/plugin-proposal-class-properties@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz#146376000b94efd001e57a40a88a525afaab9f37"
-  integrity sha512-KnTDjFNC1g+45ka0myZNvSBFLhNCLN+GeGYLDEA8Oq7MZ6yMgfLoIRh86GRT0FjtJhZw8JyUskP9uvj5pHM9Zg==
+"@babel/plugin-proposal-class-properties@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.16.7.tgz#925cad7b3b1a2fcea7e59ecc8eb5954f961f91b0"
+  integrity sha512-IobU0Xme31ewjYOShSIqd/ZGM/r/cuOz2z0MDbNrhF5FW+ZVgi0f2lyeoj9KFPDOAqsYxmLWZte1WOwlvY9aww==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-create-class-features-plugin" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-proposal-dynamic-import@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.13.8.tgz#876a1f6966e1dec332e8c9451afda3bebcdf2e1d"
-  integrity sha512-ONWKj0H6+wIRCkZi9zSbZtE/r73uOhMVHh256ys0UzfM7I3d4n+spZNWjOnJv2gzopumP2Wxi186vI8N0Y2JyQ==
+"@babel/plugin-proposal-class-static-block@^7.17.6":
+  version "7.17.6"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.17.6.tgz#164e8fd25f0d80fa48c5a4d1438a6629325ad83c"
+  integrity sha512-X/tididvL2zbs7jZCeeRJ8167U/+Ac135AM6jCAx6gYXDUviZV5Ku9UDvWS2NCuWlFjIRXklYhwo6HhAC7ETnA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-create-class-features-plugin" "^7.17.6"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/plugin-syntax-class-static-block" "^7.14.5"
+
+"@babel/plugin-proposal-dynamic-import@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.16.7.tgz#c19c897eaa46b27634a00fee9fb7d829158704b2"
+  integrity sha512-I8SW9Ho3/8DRSdmDdH3gORdyUuYnk1m4cMxUAdu5oy4n3OfN8flDEH+d60iG7dUfi0KkYwSvoalHzzdRzpWHTg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-dynamic-import" "^7.8.3"
 
-"@babel/plugin-proposal-export-namespace-from@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.12.13.tgz#393be47a4acd03fa2af6e3cde9b06e33de1b446d"
-  integrity sha512-INAgtFo4OnLN3Y/j0VwAgw3HDXcDtX+C/erMvWzuV9v71r7urb6iyMXu7eM9IgLr1ElLlOkaHjJ0SbCmdOQ3Iw==
+"@babel/plugin-proposal-export-namespace-from@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.16.7.tgz#09de09df18445a5786a305681423ae63507a6163"
+  integrity sha512-ZxdtqDXLRGBL64ocZcs7ovt71L3jhC1RGSyR996svrCi3PYqHNkb3SwPJCs8RIzD86s+WPpt2S73+EHCGO+NUA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
 
-"@babel/plugin-proposal-json-strings@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.13.8.tgz#bf1fb362547075afda3634ed31571c5901afef7b"
-  integrity sha512-w4zOPKUFPX1mgvTmL/fcEqy34hrQ1CRcGxdphBc6snDnnqJ47EZDIyop6IwXzAC8G916hsIuXB2ZMBCExC5k7Q==
+"@babel/plugin-proposal-json-strings@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.16.7.tgz#9732cb1d17d9a2626a08c5be25186c195b6fa6e8"
+  integrity sha512-lNZ3EEggsGY78JavgbHsK9u5P3pQaW7k4axlgFLYkMd7UBsiNahCITShLjNQschPyjtO6dADrL24757IdhBrsQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-json-strings" "^7.8.3"
 
-"@babel/plugin-proposal-logical-assignment-operators@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.13.8.tgz#93fa78d63857c40ce3c8c3315220fd00bfbb4e1a"
-  integrity sha512-aul6znYB4N4HGweImqKn59Su9RS8lbUIqxtXTOcAGtNIDczoEFv+l1EhmX8rUBp3G1jMjKJm8m0jXVp63ZpS4A==
+"@babel/plugin-proposal-logical-assignment-operators@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.16.7.tgz#be23c0ba74deec1922e639832904be0bea73cdea"
+  integrity sha512-K3XzyZJGQCr00+EtYtrDjmwX7o7PLK6U9bi1nCwkQioRFVUv6dJoxbQjtWVtP+bCPy82bONBKG8NPyQ4+i6yjg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
 
-"@babel/plugin-proposal-nullish-coalescing-operator@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.13.8.tgz#3730a31dafd3c10d8ccd10648ed80a2ac5472ef3"
-  integrity sha512-iePlDPBn//UhxExyS9KyeYU7RM9WScAG+D3Hhno0PLJebAEpDZMocbDe64eqynhNAnwz/vZoL/q/QB2T1OH39A==
+"@babel/plugin-proposal-nullish-coalescing-operator@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.16.7.tgz#141fc20b6857e59459d430c850a0011e36561d99"
+  integrity sha512-aUOrYU3EVtjf62jQrCj63pYZ7k6vns2h/DQvHPWGmsJRYzWXZ6/AsfgpiRy6XiuIDADhJzP2Q9MwSMKauBQ+UQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
 
-"@babel/plugin-proposal-numeric-separator@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.12.13.tgz#bd9da3188e787b5120b4f9d465a8261ce67ed1db"
-  integrity sha512-O1jFia9R8BUCl3ZGB7eitaAPu62TXJRHn7rh+ojNERCFyqRwJMTmhz+tJ+k0CwI6CLjX/ee4qW74FSqlq9I35w==
+"@babel/plugin-proposal-numeric-separator@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.16.7.tgz#d6b69f4af63fb38b6ca2558442a7fb191236eba9"
+  integrity sha512-vQgPMknOIgiuVqbokToyXbkY/OmmjAzr/0lhSIbG/KmnzXPGwW/AdhdKpi+O4X/VkWiWjnkKOBiqJrTaC98VKw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-numeric-separator" "^7.10.4"
 
-"@babel/plugin-proposal-object-rest-spread@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz#5d210a4d727d6ce3b18f9de82cc99a3964eed60a"
-  integrity sha512-DhB2EuB1Ih7S3/IRX5AFVgZ16k3EzfRbq97CxAVI1KSYcW+lexV8VZb7G7L8zuPVSdQMRn0kiBpf/Yzu9ZKH0g==
+"@babel/plugin-proposal-object-rest-spread@^7.17.3":
+  version "7.17.3"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.17.3.tgz#d9eb649a54628a51701aef7e0ea3d17e2b9dd390"
+  integrity sha512-yuL5iQA/TbZn+RGAfxQXfi7CNLmKi1f8zInn4IgobuCWcAb7i+zj4TYzQ9l8cEzVyJ89PDGuqxK1xZpUDISesw==
   dependencies:
-    "@babel/compat-data" "^7.13.8"
-    "@babel/helper-compilation-targets" "^7.13.8"
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/compat-data" "^7.17.0"
+    "@babel/helper-compilation-targets" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-transform-parameters" "^7.13.0"
+    "@babel/plugin-transform-parameters" "^7.16.7"
 
-"@babel/plugin-proposal-optional-catch-binding@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.13.8.tgz#3ad6bd5901506ea996fc31bdcf3ccfa2bed71107"
-  integrity sha512-0wS/4DUF1CuTmGo+NiaHfHcVSeSLj5S3e6RivPTg/2k3wOv3jO35tZ6/ZWsQhQMvdgI7CwphjQa/ccarLymHVA==
+"@babel/plugin-proposal-optional-catch-binding@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.16.7.tgz#c623a430674ffc4ab732fd0a0ae7722b67cb74cf"
+  integrity sha512-eMOH/L4OvWSZAE1VkHbr1vckLG1WUcHGJSLqqQwl2GaUqG6QjddvrOaTUMNYiv77H5IKPMZ9U9P7EaHwvAShfA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
     "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
 
-"@babel/plugin-proposal-optional-chaining@^7.13.12":
-  version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.13.12.tgz#ba9feb601d422e0adea6760c2bd6bbb7bfec4866"
-  integrity sha512-fcEdKOkIB7Tf4IxrgEVeFC4zeJSTr78no9wTdBuZZbqF64kzllU0ybo2zrzm7gUQfxGhBgq4E39oRs8Zx/RMYQ==
+"@babel/plugin-proposal-optional-chaining@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.16.7.tgz#7cd629564724816c0e8a969535551f943c64c39a"
+  integrity sha512-eC3xy+ZrUcBtP7x+sq62Q/HYd674pPTb/77XZMb5wbDPGWIdUbSr4Agr052+zaUPSb+gGRnjxXfKFvx5iMJ+DA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.16.0"
     "@babel/plugin-syntax-optional-chaining" "^7.8.3"
 
-"@babel/plugin-proposal-private-methods@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.13.0.tgz#04bd4c6d40f6e6bbfa2f57e2d8094bad900ef787"
-  integrity sha512-MXyyKQd9inhx1kDYPkFRVOBXQ20ES8Pto3T7UZ92xj2mY0EVD8oAVzeyYuVfy/mxAdTSIayOvg+aVzcHV2bn6Q==
+"@babel/plugin-proposal-private-methods@^7.16.11":
+  version "7.16.11"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.16.11.tgz#e8df108288555ff259f4527dbe84813aac3a1c50"
+  integrity sha512-F/2uAkPlXDr8+BHpZvo19w3hLFKge+k75XUprE6jaqKxjGkSYcK+4c+bup5PdW/7W/Rpjwql7FTVEDW+fRAQsw==
   dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-create-class-features-plugin" "^7.16.10"
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-proposal-private-property-in-object@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.16.7.tgz#b0b8cef543c2c3d57e59e2c611994861d46a3fce"
+  integrity sha512-rMQkjcOFbm+ufe3bTZLyOfsOUOxyvLXZJCTARhJr+8UMSoZmqTe1K1BgkFcrW37rAchWg57yI69ORxiWvUINuQ==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.16.7"
+    "@babel/helper-create-class-features-plugin" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
+
+"@babel/plugin-proposal-unicode-property-regex@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.16.7.tgz#635d18eb10c6214210ffc5ff4932552de08188a2"
+  integrity sha512-QRK0YI/40VLhNVGIjRNAAQkEHws0cswSdFFjpFyt943YmJIU1da9uW63Iu6NFV6CxTZW5eTDCrwZUstBWgp/Rg==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-proposal-unicode-property-regex@^7.12.13", "@babel/plugin-proposal-unicode-property-regex@^7.4.4":
+"@babel/plugin-proposal-unicode-property-regex@^7.4.4":
   version "7.12.13"
   resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.12.13.tgz#bebde51339be829c17aaaaced18641deb62b39ba"
   integrity sha512-XyJmZidNfofEkqFV5VC/bLabGmO5QzenPO/YOfGuEbgU+2sSwMmio3YLb4WtBgcmmdwZHyVyv8on77IUjQ5Gvg==
@@ -450,6 +552,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.12.13"
 
+"@babel/plugin-syntax-class-static-block@^7.14.5":
+  version "7.14.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz#195df89b146b4b78b3bf897fd7a257c84659d406"
+  integrity sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.14.5"
+
 "@babel/plugin-syntax-dynamic-import@^7.8.3":
   version "7.8.3"
   resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz#62bf98b2da3cd21d626154fc96ee5b3cb68eacb3"
@@ -464,12 +573,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.3"
 
-"@babel/plugin-syntax-flow@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.12.13.tgz#5df9962503c0a9c918381c929d51d4d6949e7e86"
-  integrity sha512-J/RYxnlSLXZLVR7wTRsozxKT8qbsx1mNKJzXEEjQ0Kjx1ZACcyHgbanNWNCFtc36IzuWhYWPpvJFFoexoOWFmA==
+"@babel/plugin-syntax-flow@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.16.7.tgz#202b147e5892b8452bbb0bb269c7ed2539ab8832"
+  integrity sha512-UDo3YGQO0jH6ytzVwgSLv9i/CzMcUjbKenL67dTrAZPPv6GFAtDhe6jqnvmoKzC/7htNTohhos+onPtDMqJwaQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
 "@babel/plugin-syntax-json-strings@^7.8.3":
   version "7.8.3"
@@ -478,12 +587,12 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-syntax-jsx@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.12.13.tgz#044fb81ebad6698fe62c478875575bcbb9b70f15"
-  integrity sha512-d4HM23Q1K7oq/SLNmG6mRt85l2csmQ0cHRaxRXjKW0YFdEXqlZ5kzFQKH5Uc3rDJECgu+yCRgPkG04Mm98R/1g==
+"@babel/plugin-syntax-jsx@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.16.7.tgz#50b6571d13f764266a113d77c82b4a6508bbe665"
+  integrity sha512-Esxmk7YjA8QysKeT3VhTXvF6y77f/a91SIs4pWb4H2eWGQkCKFgQaG6hdoEVZtGsrAcb2K5BW66XsOErD4WU3Q==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
 "@babel/plugin-syntax-logical-assignment-operators@^7.10.4":
   version "7.10.4"
@@ -527,71 +636,87 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.0"
 
-"@babel/plugin-syntax-top-level-await@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz#c5f0fa6e249f5b739727f923540cf7a806130178"
-  integrity sha512-A81F9pDwyS7yM//KwbCSDqy3Uj4NMIurtplxphWxoYtNPov7cJsDkAFNNyVlIZ3jwGycVsurZ+LtOA8gZ376iQ==
+"@babel/plugin-syntax-private-property-in-object@^7.14.5":
+  version "7.14.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz#0dc6671ec0ea22b6e94a1114f857970cd39de1ad"
+  integrity sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.14.5"
 
-"@babel/plugin-transform-arrow-functions@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz#10a59bebad52d637a027afa692e8d5ceff5e3dae"
-  integrity sha512-96lgJagobeVmazXFaDrbmCLQxBysKu7U6Do3mLsx27gf5Dk85ezysrs2BZUpXD703U/Su1xTBDxxar2oa4jAGg==
+"@babel/plugin-syntax-top-level-await@^7.14.5":
+  version "7.14.5"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c"
+  integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.14.5"
 
-"@babel/plugin-transform-async-to-generator@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.13.0.tgz#8e112bf6771b82bf1e974e5e26806c5c99aa516f"
-  integrity sha512-3j6E004Dx0K3eGmhxVJxwwI89CTJrce7lg3UrtFuDAVQ/2+SJ/h/aSFOeE6/n0WB1GsOffsJp6MnPQNQ8nmwhg==
+"@babel/plugin-transform-arrow-functions@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.16.7.tgz#44125e653d94b98db76369de9c396dc14bef4154"
+  integrity sha512-9ffkFFMbvzTvv+7dTp/66xvZAWASuPD5Tl9LK3Z9vhOmANo6j94rik+5YMBt4CwHVMWLWpMsriIc2zsa3WW3xQ==
   dependencies:
-    "@babel/helper-module-imports" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-remap-async-to-generator" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-block-scoped-functions@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz#a9bf1836f2a39b4eb6cf09967739de29ea4bf4c4"
-  integrity sha512-zNyFqbc3kI/fVpqwfqkg6RvBgFpC4J18aKKMmv7KdQ/1GgREapSJAykLMVNwfRGO3BtHj3YQZl8kxCXPcVMVeg==
+"@babel/plugin-transform-async-to-generator@^7.16.8":
+  version "7.16.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.16.8.tgz#b83dff4b970cf41f1b819f8b49cc0cfbaa53a808"
+  integrity sha512-MtmUmTJQHCnyJVrScNzNlofQJ3dLFuobYn3mwOTKHnSCMtbNsqvF71GQmJfFjdrXSsAA7iysFmYWw4bXZ20hOg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-module-imports" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-remap-async-to-generator" "^7.16.8"
 
-"@babel/plugin-transform-block-scoping@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.12.13.tgz#f36e55076d06f41dfd78557ea039c1b581642e61"
-  integrity sha512-Pxwe0iqWJX4fOOM2kEZeUuAxHMWb9nK+9oh5d11bsLoB0xMg+mkDpt0eYuDZB7ETrY9bbcVlKUGTOGWy7BHsMQ==
+"@babel/plugin-transform-block-scoped-functions@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.16.7.tgz#4d0d57d9632ef6062cdf354bb717102ee042a620"
+  integrity sha512-JUuzlzmF40Z9cXyytcbZEZKckgrQzChbQJw/5PuEHYeqzCsvebDx0K0jWnIIVcmmDOAVctCgnYs0pMcrYj2zJg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-classes@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz#0265155075c42918bf4d3a4053134176ad9b533b"
-  integrity sha512-9BtHCPUARyVH1oXGcSJD3YpsqRLROJx5ZNP6tN5vnk17N0SVf9WCtf8Nuh1CFmgByKKAIMstitKduoCmsaDK5g==
+"@babel/plugin-transform-block-scoping@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.16.7.tgz#f50664ab99ddeaee5bc681b8f3a6ea9d72ab4f87"
+  integrity sha512-ObZev2nxVAYA4bhyusELdo9hb3H+A56bxH3FZMbEImZFiEDYVHXQSJ1hQKFlDnlt8G9bBrCZ5ZpURZUrV4G5qQ==
   dependencies:
-    "@babel/helper-annotate-as-pure" "^7.12.13"
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-optimise-call-expression" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-replace-supers" "^7.13.0"
-    "@babel/helper-split-export-declaration" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-classes@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.16.7.tgz#8f4b9562850cd973de3b498f1218796eb181ce00"
+  integrity sha512-WY7og38SFAGYRe64BrjKf8OrE6ulEHtr5jEYaZMwox9KebgqPi67Zqz8K53EKk1fFEJgm96r32rkKZ3qA2nCWQ==
+  dependencies:
+    "@babel/helper-annotate-as-pure" "^7.16.7"
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-function-name" "^7.16.7"
+    "@babel/helper-optimise-call-expression" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-replace-supers" "^7.16.7"
+    "@babel/helper-split-export-declaration" "^7.16.7"
     globals "^11.1.0"
 
-"@babel/plugin-transform-computed-properties@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz#845c6e8b9bb55376b1fa0b92ef0bdc8ea06644ed"
-  integrity sha512-RRqTYTeZkZAz8WbieLTvKUEUxZlUTdmL5KGMyZj7FnMfLNKV4+r5549aORG/mgojRmFlQMJDUupwAMiF2Q7OUg==
+"@babel/plugin-transform-computed-properties@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.16.7.tgz#66dee12e46f61d2aae7a73710f591eb3df616470"
+  integrity sha512-gN72G9bcmenVILj//sv1zLNaPyYcOzUho2lIJBMh/iakJ9ygCo/hEF9cpGb61SCMEDxbbyBoVQxrt+bWKu5KGw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-destructuring@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.0.tgz#c5dce270014d4e1ebb1d806116694c12b7028963"
-  integrity sha512-zym5em7tePoNT9s964c0/KU3JPPnuq7VhIxPRefJ4/s82cD+q1mgKfuGRDMCPL0HTyKz4dISuQlCusfgCJ86HA==
+"@babel/plugin-transform-destructuring@^7.17.7":
+  version "7.17.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.17.7.tgz#49dc2675a7afa9a5e4c6bdee636061136c3408d1"
+  integrity sha512-XVh0r5yq9sLR4vZ6eVZe8FKfIcSgaTBxVBRSYokRj2qksf6QerYnTxz9/GTuKTH/n/HwLP7t6gtlybHetJ/6hQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-dotall-regex@^7.12.13", "@babel/plugin-transform-dotall-regex@^7.4.4":
+"@babel/plugin-transform-dotall-regex@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.16.7.tgz#6b2d67686fab15fb6a7fd4bd895d5982cfc81241"
+  integrity sha512-Lyttaao2SjZF6Pf4vk1dVKv8YypMpomAbygW+mU5cYP3S5cWTfCJjG8xV6CFdzGFlfWK81IjL9viiTvpb6G7gQ==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-dotall-regex@^7.4.4":
   version "7.12.13"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.12.13.tgz#3f1601cc29905bfcb67f53910f197aeafebb25ad"
   integrity sha512-foDrozE65ZFdUC2OfgeOCrEPTxdB3yjqxpXh8CH+ipd9CHd4s/iq81kcUpyH8ACGNEPdFqbtzfgzbT/ZGlbDeQ==
@@ -599,222 +724,227 @@
     "@babel/helper-create-regexp-features-plugin" "^7.12.13"
     "@babel/helper-plugin-utils" "^7.12.13"
 
-"@babel/plugin-transform-duplicate-keys@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.12.13.tgz#6f06b87a8b803fd928e54b81c258f0a0033904de"
-  integrity sha512-NfADJiiHdhLBW3pulJlJI2NB0t4cci4WTZ8FtdIuNc2+8pslXdPtRRAEWqUY+m9kNOk2eRYbTAOipAxlrOcwwQ==
+"@babel/plugin-transform-duplicate-keys@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.16.7.tgz#2207e9ca8f82a0d36a5a67b6536e7ef8b08823c9"
+  integrity sha512-03DvpbRfvWIXyK0/6QiR1KMTWeT6OcQ7tbhjrXyFS02kjuX/mu5Bvnh5SDSWHxyawit2g5aWhKwI86EE7GUnTw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-exponentiation-operator@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.12.13.tgz#4d52390b9a273e651e4aba6aee49ef40e80cd0a1"
-  integrity sha512-fbUelkM1apvqez/yYx1/oICVnGo2KM5s63mhGylrmXUxK/IAXSIf87QIxVfZldWf4QsOafY6vV3bX8aMHSvNrA==
+"@babel/plugin-transform-exponentiation-operator@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.16.7.tgz#efa9862ef97e9e9e5f653f6ddc7b665e8536fe9b"
+  integrity sha512-8UYLSlyLgRixQvlYH3J2ekXFHDFLQutdy7FfFAMm3CPZ6q9wHCwnUyiXpQCe3gVVnQlHc5nsuiEVziteRNTXEA==
   dependencies:
-    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-flow-strip-types@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.13.0.tgz#58177a48c209971e8234e99906cb6bd1122addd3"
-  integrity sha512-EXAGFMJgSX8gxWD7PZtW/P6M+z74jpx3wm/+9pn+c2dOawPpBkUX7BrfyPvo6ZpXbgRIEuwgwDb/MGlKvu2pOg==
+"@babel/plugin-transform-flow-strip-types@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.16.7.tgz#291fb140c78dabbf87f2427e7c7c332b126964b8"
+  integrity sha512-mzmCq3cNsDpZZu9FADYYyfZJIOrSONmHcop2XEKPdBNMa4PDC4eEvcOvzZaCNcjKu72v0XQlA5y1g58aLRXdYg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/plugin-syntax-flow" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/plugin-syntax-flow" "^7.16.7"
 
-"@babel/plugin-transform-for-of@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz#c799f881a8091ac26b54867a845c3e97d2696062"
-  integrity sha512-IHKT00mwUVYE0zzbkDgNRP6SRzvfGCYsOxIRz8KsiaaHCcT9BWIkO+H9QRJseHBLOGBZkHUdHiqj6r0POsdytg==
+"@babel/plugin-transform-for-of@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.16.7.tgz#649d639d4617dff502a9a158c479b3b556728d8c"
+  integrity sha512-/QZm9W92Ptpw7sjI9Nx1mbcsWz33+l8kuMIQnDwgQBG5s3fAfQvkRjQ7NqXhtNcKOnPkdICmUHyCaWW06HCsqg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-function-name@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz#bb024452f9aaed861d374c8e7a24252ce3a50051"
-  integrity sha512-6K7gZycG0cmIwwF7uMK/ZqeCikCGVBdyP2J5SKNCXO5EOHcqi+z7Jwf8AmyDNcBgxET8DrEtCt/mPKPyAzXyqQ==
+"@babel/plugin-transform-function-name@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.16.7.tgz#5ab34375c64d61d083d7d2f05c38d90b97ec65cf"
+  integrity sha512-SU/C68YVwTRxqWj5kgsbKINakGag0KTgq9f2iZEXdStoAbOzLHEBRYzImmA6yFo8YZhJVflvXmIHUO7GWHmxxA==
   dependencies:
-    "@babel/helper-function-name" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-compilation-targets" "^7.16.7"
+    "@babel/helper-function-name" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-literals@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz#2ca45bafe4a820197cf315794a4d26560fe4bdb9"
-  integrity sha512-FW+WPjSR7hiUxMcKqyNjP05tQ2kmBCdpEpZHY1ARm96tGQCCBvXKnpjILtDplUnJ/eHZ0lALLM+d2lMFSpYJrQ==
+"@babel/plugin-transform-literals@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.16.7.tgz#254c9618c5ff749e87cb0c0cef1a0a050c0bdab1"
+  integrity sha512-6tH8RTpTWI0s2sV6uq3e/C9wPo4PTqqZps4uF0kzQ9/xPLFQtipynvmT1g/dOfEJ+0EQsHhkQ/zyRId8J2b8zQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-member-expression-literals@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz#5ffa66cd59b9e191314c9f1f803b938e8c081e40"
-  integrity sha512-kxLkOsg8yir4YeEPHLuO2tXP9R/gTjpuTOjshqSpELUN3ZAg2jfDnKUvzzJxObun38sw3wm4Uu69sX/zA7iRvg==
+"@babel/plugin-transform-member-expression-literals@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.16.7.tgz#6e5dcf906ef8a098e630149d14c867dd28f92384"
+  integrity sha512-mBruRMbktKQwbxaJof32LT9KLy2f3gH+27a5XSuXo6h7R3vqltl0PgZ80C8ZMKw98Bf8bqt6BEVi3svOh2PzMw==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-modules-amd@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.13.0.tgz#19f511d60e3d8753cc5a6d4e775d3a5184866cc3"
-  integrity sha512-EKy/E2NHhY/6Vw5d1k3rgoobftcNUmp9fGjb9XZwQLtTctsRBOTRO7RHHxfIky1ogMN5BxN7p9uMA3SzPfotMQ==
+"@babel/plugin-transform-modules-amd@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.16.7.tgz#b28d323016a7daaae8609781d1f8c9da42b13186"
+  integrity sha512-KaaEtgBL7FKYwjJ/teH63oAmE3lP34N3kshz8mm4VMAw7U3PxjVwwUmxEFksbgsNUaO3wId9R2AVQYSEGRa2+g==
   dependencies:
-    "@babel/helper-module-transforms" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-module-transforms" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
     babel-plugin-dynamic-import-node "^2.3.3"
 
-"@babel/plugin-transform-modules-commonjs@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz#7b01ad7c2dcf2275b06fa1781e00d13d420b3e1b"
-  integrity sha512-9QiOx4MEGglfYZ4XOnU79OHr6vIWUakIj9b4mioN8eQIoEh+pf5p/zEB36JpDFWA12nNMiRf7bfoRvl9Rn79Bw==
+"@babel/plugin-transform-modules-commonjs@^7.17.9":
+  version "7.17.9"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.17.9.tgz#274be1a2087beec0254d4abd4d86e52442e1e5b6"
+  integrity sha512-2TBFd/r2I6VlYn0YRTz2JdazS+FoUuQ2rIFHoAxtyP/0G3D82SBLaRq9rnUkpqlLg03Byfl/+M32mpxjO6KaPw==
   dependencies:
-    "@babel/helper-module-transforms" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-simple-access" "^7.12.13"
+    "@babel/helper-module-transforms" "^7.17.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-simple-access" "^7.17.7"
     babel-plugin-dynamic-import-node "^2.3.3"
 
-"@babel/plugin-transform-modules-systemjs@^7.13.8":
-  version "7.13.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.13.8.tgz#6d066ee2bff3c7b3d60bf28dec169ad993831ae3"
-  integrity sha512-hwqctPYjhM6cWvVIlOIe27jCIBgHCsdH2xCJVAYQm7V5yTMoilbVMi9f6wKg0rpQAOn6ZG4AOyvCqFF/hUh6+A==
+"@babel/plugin-transform-modules-systemjs@^7.17.8":
+  version "7.17.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.17.8.tgz#81fd834024fae14ea78fbe34168b042f38703859"
+  integrity sha512-39reIkMTUVagzgA5x88zDYXPCMT6lcaRKs1+S9K6NKBPErbgO/w/kP8GlNQTC87b412ZTlmNgr3k2JrWgHH+Bw==
   dependencies:
-    "@babel/helper-hoist-variables" "^7.13.0"
-    "@babel/helper-module-transforms" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-validator-identifier" "^7.12.11"
+    "@babel/helper-hoist-variables" "^7.16.7"
+    "@babel/helper-module-transforms" "^7.17.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-validator-identifier" "^7.16.7"
     babel-plugin-dynamic-import-node "^2.3.3"
 
-"@babel/plugin-transform-modules-umd@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.13.0.tgz#8a3d96a97d199705b9fd021580082af81c06e70b"
-  integrity sha512-D/ILzAh6uyvkWjKKyFE/W0FzWwasv6vPTSqPcjxFqn6QpX3u8DjRVliq4F2BamO2Wee/om06Vyy+vPkNrd4wxw==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.13.0"
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-named-capturing-groups-regex@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.12.13.tgz#2213725a5f5bbbe364b50c3ba5998c9599c5c9d9"
-  integrity sha512-Xsm8P2hr5hAxyYblrfACXpQKdQbx4m2df9/ZZSQ8MAhsadw06+jW7s9zsSw6he+mJZXRlVMyEnVktJo4zjk1WA==
-  dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.12.13"
-
-"@babel/plugin-transform-new-target@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.12.13.tgz#e22d8c3af24b150dd528cbd6e685e799bf1c351c"
-  integrity sha512-/KY2hbLxrG5GTQ9zzZSc3xWiOy379pIETEhbtzwZcw9rvuaVV4Fqy7BYGYOWZnaoXIQYbbJ0ziXLa/sKcGCYEQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-object-super@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz#b4416a2d63b8f7be314f3d349bd55a9c1b5171f7"
-  integrity sha512-JzYIcj3XtYspZDV8j9ulnoMPZZnF/Cj0LUxPOjR89BdBVx+zYJI9MdMIlUZjbXDX+6YVeS6I3e8op+qQ3BYBoQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-    "@babel/helper-replace-supers" "^7.12.13"
-
-"@babel/plugin-transform-parameters@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz#8fa7603e3097f9c0b7ca1a4821bc2fb52e9e5007"
-  integrity sha512-Jt8k/h/mIwE2JFEOb3lURoY5C85ETcYPnbuAJ96zRBzh1XHtQZfs62ChZ6EP22QlC8c7Xqr9q+e1SU5qttwwjw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-
-"@babel/plugin-transform-property-literals@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz#4e6a9e37864d8f1b3bc0e2dce7bf8857db8b1a81"
-  integrity sha512-nqVigwVan+lR+g8Fj8Exl0UQX2kymtjcWfMOYM1vTYEKujeyv2SkMgazf2qNcK7l4SDiKyTA/nHCPqL4e2zo1A==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-regenerator@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.12.13.tgz#b628bcc9c85260ac1aeb05b45bde25210194a2f5"
-  integrity sha512-lxb2ZAvSLyJ2PEe47hoGWPmW22v7CtSl9jW8mingV4H2sEX/JOcrAj2nPuGWi56ERUm2bUpjKzONAuT6HCn2EA==
-  dependencies:
-    regenerator-transform "^0.14.2"
-
-"@babel/plugin-transform-reserved-words@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.12.13.tgz#7d9988d4f06e0fe697ea1d9803188aa18b472695"
-  integrity sha512-xhUPzDXxZN1QfiOy/I5tyye+TRz6lA7z6xaT4CLOjPRMVg1ldRf0LHw0TDBpYL4vG78556WuHdyO9oi5UmzZBg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-shorthand-properties@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz#db755732b70c539d504c6390d9ce90fe64aff7ad"
-  integrity sha512-xpL49pqPnLtf0tVluuqvzWIgLEhuPpZzvs2yabUHSKRNlN7ScYU7aMlmavOeyXJZKgZKQRBlh8rHbKiJDraTSw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-spread@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz#84887710e273c1815ace7ae459f6f42a5d31d5fd"
-  integrity sha512-V6vkiXijjzYeFmQTr3dBxPtZYLPcUfY34DebOU27jIl2M/Y8Egm52Hw82CSjjPqd54GTlJs5x+CR7HeNr24ckg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.12.1"
-
-"@babel/plugin-transform-sticky-regex@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.12.13.tgz#760ffd936face73f860ae646fb86ee82f3d06d1f"
-  integrity sha512-Jc3JSaaWT8+fr7GRvQP02fKDsYk4K/lYwWq38r/UGfaxo89ajud321NH28KRQ7xy1Ybc0VUE5Pz8psjNNDUglg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-transform-template-literals@^7.13.0":
-  version "7.13.0"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz#a36049127977ad94438dee7443598d1cefdf409d"
-  integrity sha512-d67umW6nlfmr1iehCcBv69eSUSySk1EsIS8aTDX4Xo9qajAh6mYtcl4kJrBkGXuxZPEgVr7RVfAvNW6YQkd4Mw==
+"@babel/plugin-transform-modules-umd@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.16.7.tgz#23dad479fa585283dbd22215bff12719171e7618"
+  integrity sha512-EMh7uolsC8O4xhudF2F6wedbSHm1HHZ0C6aJ7K67zcDNidMzVcxWdGr+htW9n21klm+bOn+Rx4CBsAntZd3rEQ==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.13.0"
+    "@babel/helper-module-transforms" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-typeof-symbol@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.12.13.tgz#785dd67a1f2ea579d9c2be722de8c84cb85f5a7f"
-  integrity sha512-eKv/LmUJpMnu4npgfvs3LiHhJua5fo/CysENxa45YCQXZwKnGCQKAg87bvoqSW1fFT+HA32l03Qxsm8ouTY3ZQ==
+"@babel/plugin-transform-named-capturing-groups-regex@^7.17.10":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.17.10.tgz#715dbcfafdb54ce8bccd3d12e8917296a4ba66a4"
+  integrity sha512-v54O6yLaJySCs6mGzaVOUw9T967GnH38T6CQSAtnzdNPwu84l2qAjssKzo/WSO8Yi7NF+7ekm5cVbF/5qiIgNA==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-create-regexp-features-plugin" "^7.17.0"
 
-"@babel/plugin-transform-unicode-escapes@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.12.13.tgz#840ced3b816d3b5127dd1d12dcedc5dead1a5e74"
-  integrity sha512-0bHEkdwJ/sN/ikBHfSmOXPypN/beiGqjo+o4/5K+vxEFNPRPdImhviPakMKG4x96l85emoa0Z6cDflsdBusZbw==
+"@babel/plugin-transform-new-target@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.16.7.tgz#9967d89a5c243818e0800fdad89db22c5f514244"
+  integrity sha512-xiLDzWNMfKoGOpc6t3U+etCE2yRnn3SM09BXqWPIZOBpL2gvVrBWUKnsJx0K/ADi5F5YC5f8APFfWrz25TdlGg==
   dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-unicode-regex@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.12.13.tgz#b52521685804e155b1202e83fc188d34bb70f5ac"
-  integrity sha512-mDRzSNY7/zopwisPZ5kM9XKCfhchqIYwAKRERtEnhYscZB79VRekuRSoYbN0+KVe3y8+q1h6A4svXtP7N+UoCA==
+"@babel/plugin-transform-object-super@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.16.7.tgz#ac359cf8d32cf4354d27a46867999490b6c32a94"
+  integrity sha512-14J1feiQVWaGvRxj2WjyMuXS2jsBkgB3MdSN5HuC2G5nRspa5RK9COcs82Pwy5BuGcjb+fYaUj94mYcOj7rCvw==
   dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.12.13"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-replace-supers" "^7.16.7"
 
-"@babel/preset-env@^7.13.12":
-  version "7.13.12"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.13.12.tgz#6dff470478290582ac282fb77780eadf32480237"
-  integrity sha512-JzElc6jk3Ko6zuZgBtjOd01pf9yYDEIH8BcqVuYIuOkzOwDesoa/Nz4gIo4lBG6K861KTV9TvIgmFuT6ytOaAA==
-  dependencies:
-    "@babel/compat-data" "^7.13.12"
-    "@babel/helper-compilation-targets" "^7.13.10"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/helper-validator-option" "^7.12.17"
-    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.13.12"
-    "@babel/plugin-proposal-async-generator-functions" "^7.13.8"
-    "@babel/plugin-proposal-class-properties" "^7.13.0"
-    "@babel/plugin-proposal-dynamic-import" "^7.13.8"
-    "@babel/plugin-proposal-export-namespace-from" "^7.12.13"
-    "@babel/plugin-proposal-json-strings" "^7.13.8"
-    "@babel/plugin-proposal-logical-assignment-operators" "^7.13.8"
-    "@babel/plugin-proposal-nullish-coalescing-operator" "^7.13.8"
-    "@babel/plugin-proposal-numeric-separator" "^7.12.13"
-    "@babel/plugin-proposal-object-rest-spread" "^7.13.8"
-    "@babel/plugin-proposal-optional-catch-binding" "^7.13.8"
-    "@babel/plugin-proposal-optional-chaining" "^7.13.12"
-    "@babel/plugin-proposal-private-methods" "^7.13.0"
-    "@babel/plugin-proposal-unicode-property-regex" "^7.12.13"
+"@babel/plugin-transform-parameters@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.16.7.tgz#a1721f55b99b736511cb7e0152f61f17688f331f"
+  integrity sha512-AT3MufQ7zZEhU2hwOA11axBnExW0Lszu4RL/tAlUJBuNoRak+wehQW8h6KcXOcgjY42fHtDxswuMhMjFEuv/aw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-property-literals@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.16.7.tgz#2dadac85155436f22c696c4827730e0fe1057a55"
+  integrity sha512-z4FGr9NMGdoIl1RqavCqGG+ZuYjfZ/hkCIeuH6Do7tXmSm0ls11nYVSJqFEUOSJbDab5wC6lRE/w6YjVcr6Hqw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-regenerator@^7.17.9":
+  version "7.17.9"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.17.9.tgz#0a33c3a61cf47f45ed3232903683a0afd2d3460c"
+  integrity sha512-Lc2TfbxR1HOyn/c6b4Y/b6NHoTb67n/IoWLxTu4kC7h4KQnWlhCq2S8Tx0t2SVvv5Uu87Hs+6JEJ5kt2tYGylQ==
+  dependencies:
+    regenerator-transform "^0.15.0"
+
+"@babel/plugin-transform-reserved-words@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.16.7.tgz#1d798e078f7c5958eec952059c460b220a63f586"
+  integrity sha512-KQzzDnZ9hWQBjwi5lpY5v9shmm6IVG0U9pB18zvMu2i4H90xpT4gmqwPYsn8rObiadYe2M0gmgsiOIF5A/2rtg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-shorthand-properties@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.16.7.tgz#e8549ae4afcf8382f711794c0c7b6b934c5fbd2a"
+  integrity sha512-hah2+FEnoRoATdIb05IOXf+4GzXYTq75TVhIn1PewihbpyrNWUt2JbudKQOETWw6QpLe+AIUpJ5MVLYTQbeeUg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-spread@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.16.7.tgz#a303e2122f9f12e0105daeedd0f30fb197d8ff44"
+  integrity sha512-+pjJpgAngb53L0iaA5gU/1MLXJIfXcYepLgXB3esVRf4fqmj8f2cxM3/FKaHsZms08hFQJkFccEWuIpm429TXg==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-skip-transparent-expression-wrappers" "^7.16.0"
+
+"@babel/plugin-transform-sticky-regex@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.16.7.tgz#c84741d4f4a38072b9a1e2e3fd56d359552e8660"
+  integrity sha512-NJa0Bd/87QV5NZZzTuZG5BPJjLYadeSZ9fO6oOUoL4iQx+9EEuw/eEM92SrsT19Yc2jgB1u1hsjqDtH02c3Drw==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-template-literals@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.16.7.tgz#f3d1c45d28967c8e80f53666fc9c3e50618217ab"
+  integrity sha512-VwbkDDUeenlIjmfNeDX/V0aWrQH2QiVyJtwymVQSzItFDTpxfyJh3EVaQiS0rIN/CqbLGr0VcGmuwyTdZtdIsA==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-typeof-symbol@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.16.7.tgz#9cdbe622582c21368bd482b660ba87d5545d4f7e"
+  integrity sha512-p2rOixCKRJzpg9JB4gjnG4gjWkWa89ZoYUnl9snJ1cWIcTH/hvxZqfO+WjG6T8DRBpctEol5jw1O5rA8gkCokQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-unicode-escapes@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.16.7.tgz#da8717de7b3287a2c6d659750c964f302b31ece3"
+  integrity sha512-TAV5IGahIz3yZ9/Hfv35TV2xEm+kaBDaZQCn2S/hG9/CZ0DktxJv9eKfPc7yYCvOYR4JGx1h8C+jcSOvgaaI/Q==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/plugin-transform-unicode-regex@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.16.7.tgz#0f7aa4a501198976e25e82702574c34cfebe9ef2"
+  integrity sha512-oC5tYYKw56HO75KZVLQ+R/Nl3Hro9kf8iG0hXoaHP7tjAyCpvqBiSNe6vGrZni1Z6MggmUOC6A7VP7AVmw225Q==
+  dependencies:
+    "@babel/helper-create-regexp-features-plugin" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+
+"@babel/preset-env@^7.17.10":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.17.10.tgz#a81b093669e3eb6541bb81a23173c5963c5de69c"
+  integrity sha512-YNgyBHZQpeoBSRBg0xixsZzfT58Ze1iZrajvv0lJc70qDDGuGfonEnMGfWeSY0mQ3JTuCWFbMkzFRVafOyJx4g==
+  dependencies:
+    "@babel/compat-data" "^7.17.10"
+    "@babel/helper-compilation-targets" "^7.17.10"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-validator-option" "^7.16.7"
+    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.16.7"
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.16.7"
+    "@babel/plugin-proposal-async-generator-functions" "^7.16.8"
+    "@babel/plugin-proposal-class-properties" "^7.16.7"
+    "@babel/plugin-proposal-class-static-block" "^7.17.6"
+    "@babel/plugin-proposal-dynamic-import" "^7.16.7"
+    "@babel/plugin-proposal-export-namespace-from" "^7.16.7"
+    "@babel/plugin-proposal-json-strings" "^7.16.7"
+    "@babel/plugin-proposal-logical-assignment-operators" "^7.16.7"
+    "@babel/plugin-proposal-nullish-coalescing-operator" "^7.16.7"
+    "@babel/plugin-proposal-numeric-separator" "^7.16.7"
+    "@babel/plugin-proposal-object-rest-spread" "^7.17.3"
+    "@babel/plugin-proposal-optional-catch-binding" "^7.16.7"
+    "@babel/plugin-proposal-optional-chaining" "^7.16.7"
+    "@babel/plugin-proposal-private-methods" "^7.16.11"
+    "@babel/plugin-proposal-private-property-in-object" "^7.16.7"
+    "@babel/plugin-proposal-unicode-property-regex" "^7.16.7"
     "@babel/plugin-syntax-async-generators" "^7.8.4"
     "@babel/plugin-syntax-class-properties" "^7.12.13"
+    "@babel/plugin-syntax-class-static-block" "^7.14.5"
     "@babel/plugin-syntax-dynamic-import" "^7.8.3"
     "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
     "@babel/plugin-syntax-json-strings" "^7.8.3"
@@ -824,51 +954,52 @@
     "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
     "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
     "@babel/plugin-syntax-optional-chaining" "^7.8.3"
-    "@babel/plugin-syntax-top-level-await" "^7.12.13"
-    "@babel/plugin-transform-arrow-functions" "^7.13.0"
-    "@babel/plugin-transform-async-to-generator" "^7.13.0"
-    "@babel/plugin-transform-block-scoped-functions" "^7.12.13"
-    "@babel/plugin-transform-block-scoping" "^7.12.13"
-    "@babel/plugin-transform-classes" "^7.13.0"
-    "@babel/plugin-transform-computed-properties" "^7.13.0"
-    "@babel/plugin-transform-destructuring" "^7.13.0"
-    "@babel/plugin-transform-dotall-regex" "^7.12.13"
-    "@babel/plugin-transform-duplicate-keys" "^7.12.13"
-    "@babel/plugin-transform-exponentiation-operator" "^7.12.13"
-    "@babel/plugin-transform-for-of" "^7.13.0"
-    "@babel/plugin-transform-function-name" "^7.12.13"
-    "@babel/plugin-transform-literals" "^7.12.13"
-    "@babel/plugin-transform-member-expression-literals" "^7.12.13"
-    "@babel/plugin-transform-modules-amd" "^7.13.0"
-    "@babel/plugin-transform-modules-commonjs" "^7.13.8"
-    "@babel/plugin-transform-modules-systemjs" "^7.13.8"
-    "@babel/plugin-transform-modules-umd" "^7.13.0"
-    "@babel/plugin-transform-named-capturing-groups-regex" "^7.12.13"
-    "@babel/plugin-transform-new-target" "^7.12.13"
-    "@babel/plugin-transform-object-super" "^7.12.13"
-    "@babel/plugin-transform-parameters" "^7.13.0"
-    "@babel/plugin-transform-property-literals" "^7.12.13"
-    "@babel/plugin-transform-regenerator" "^7.12.13"
-    "@babel/plugin-transform-reserved-words" "^7.12.13"
-    "@babel/plugin-transform-shorthand-properties" "^7.12.13"
-    "@babel/plugin-transform-spread" "^7.13.0"
-    "@babel/plugin-transform-sticky-regex" "^7.12.13"
-    "@babel/plugin-transform-template-literals" "^7.13.0"
-    "@babel/plugin-transform-typeof-symbol" "^7.12.13"
-    "@babel/plugin-transform-unicode-escapes" "^7.12.13"
-    "@babel/plugin-transform-unicode-regex" "^7.12.13"
-    "@babel/preset-modules" "^0.1.4"
-    "@babel/types" "^7.13.12"
-    babel-plugin-polyfill-corejs2 "^0.1.4"
-    babel-plugin-polyfill-corejs3 "^0.1.3"
-    babel-plugin-polyfill-regenerator "^0.1.2"
-    core-js-compat "^3.9.0"
+    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
+    "@babel/plugin-syntax-top-level-await" "^7.14.5"
+    "@babel/plugin-transform-arrow-functions" "^7.16.7"
+    "@babel/plugin-transform-async-to-generator" "^7.16.8"
+    "@babel/plugin-transform-block-scoped-functions" "^7.16.7"
+    "@babel/plugin-transform-block-scoping" "^7.16.7"
+    "@babel/plugin-transform-classes" "^7.16.7"
+    "@babel/plugin-transform-computed-properties" "^7.16.7"
+    "@babel/plugin-transform-destructuring" "^7.17.7"
+    "@babel/plugin-transform-dotall-regex" "^7.16.7"
+    "@babel/plugin-transform-duplicate-keys" "^7.16.7"
+    "@babel/plugin-transform-exponentiation-operator" "^7.16.7"
+    "@babel/plugin-transform-for-of" "^7.16.7"
+    "@babel/plugin-transform-function-name" "^7.16.7"
+    "@babel/plugin-transform-literals" "^7.16.7"
+    "@babel/plugin-transform-member-expression-literals" "^7.16.7"
+    "@babel/plugin-transform-modules-amd" "^7.16.7"
+    "@babel/plugin-transform-modules-commonjs" "^7.17.9"
+    "@babel/plugin-transform-modules-systemjs" "^7.17.8"
+    "@babel/plugin-transform-modules-umd" "^7.16.7"
+    "@babel/plugin-transform-named-capturing-groups-regex" "^7.17.10"
+    "@babel/plugin-transform-new-target" "^7.16.7"
+    "@babel/plugin-transform-object-super" "^7.16.7"
+    "@babel/plugin-transform-parameters" "^7.16.7"
+    "@babel/plugin-transform-property-literals" "^7.16.7"
+    "@babel/plugin-transform-regenerator" "^7.17.9"
+    "@babel/plugin-transform-reserved-words" "^7.16.7"
+    "@babel/plugin-transform-shorthand-properties" "^7.16.7"
+    "@babel/plugin-transform-spread" "^7.16.7"
+    "@babel/plugin-transform-sticky-regex" "^7.16.7"
+    "@babel/plugin-transform-template-literals" "^7.16.7"
+    "@babel/plugin-transform-typeof-symbol" "^7.16.7"
+    "@babel/plugin-transform-unicode-escapes" "^7.16.7"
+    "@babel/plugin-transform-unicode-regex" "^7.16.7"
+    "@babel/preset-modules" "^0.1.5"
+    "@babel/types" "^7.17.10"
+    babel-plugin-polyfill-corejs2 "^0.3.0"
+    babel-plugin-polyfill-corejs3 "^0.5.0"
+    babel-plugin-polyfill-regenerator "^0.3.0"
+    core-js-compat "^3.22.1"
     semver "^6.3.0"
 
-"@babel/preset-modules@^0.1.4":
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.4.tgz#362f2b68c662842970fdb5e254ffc8fc1c2e415e"
-  integrity sha512-J36NhwnfdzpmH41M1DrnkkgAqhZaqr/NBdPfQ677mLzlaXo+oDiv1deyCDtgAhz8p328otdob0Du7+xgHGZbKg==
+"@babel/preset-modules@^0.1.5":
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.5.tgz#ef939d6e7f268827e1841638dc6ff95515e115d9"
+  integrity sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==
   dependencies:
     "@babel/helper-plugin-utils" "^7.0.0"
     "@babel/plugin-proposal-unicode-property-regex" "^7.4.4"
@@ -876,15 +1007,15 @@
     "@babel/types" "^7.4.4"
     esutils "^2.0.2"
 
-"@babel/register@^7.13.14":
-  version "7.13.14"
-  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.13.14.tgz#bbfa8f4f027c2ebc432e8e69e078b632605f2d9b"
-  integrity sha512-iyw0hUwjh/fzN8qklVqZodbyWjEBOG0KdDnBOpv3zzIgK3NmuRXBmIXH39ZBdspkn8LTHvSboN+oYb4MT43+9Q==
+"@babel/register@^7.17.7":
+  version "7.17.7"
+  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.17.7.tgz#5eef3e0f4afc07e25e847720e7b987ae33f08d0b"
+  integrity sha512-fg56SwvXRifootQEDQAu1mKdjh5uthPzdO0N6t358FktfL4XjAVXuH58ULoiW8mesxiOgNIrxiImqEwv0+hRRA==
   dependencies:
+    clone-deep "^4.0.1"
     find-cache-dir "^2.0.0"
-    lodash "^4.17.19"
     make-dir "^2.1.0"
-    pirates "^4.0.0"
+    pirates "^4.0.5"
     source-map-support "^0.5.16"
 
 "@babel/runtime@^7.8.4":
@@ -894,15 +1025,6 @@
   dependencies:
     regenerator-runtime "^0.13.4"
 
-"@babel/template@^7.0.0", "@babel/template@^7.1.0":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.2.2.tgz#005b3fdf0ed96e88041330379e0da9a708eb2907"
-  integrity sha512-zRL0IMM02AUDwghf5LMSSDEz7sBCO2YnNmpg3uWTZj/v1rcG2BmQUvaGU8GhU8BvfMh1k2KIAYZ7Ji9KXPUg7g==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    "@babel/parser" "^7.2.2"
-    "@babel/types" "^7.2.2"
-
 "@babel/template@^7.12.13":
   version "7.12.13"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.12.13.tgz#530265be8a2589dbb37523844c5bcb55947fb327"
@@ -912,22 +1034,16 @@
     "@babel/parser" "^7.12.13"
     "@babel/types" "^7.12.13"
 
-"@babel/traverse@^7.0.0":
-  version "7.2.3"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.2.3.tgz#7ff50cefa9c7c0bd2d81231fdac122f3957748d8"
-  integrity sha512-Z31oUD/fJvEWVR0lNZtfgvVt512ForCTNKYcJBGbPb1QZfve4WGH8Wsy7+Mev33/45fhP/hwQtvgusNdcCMgSw==
+"@babel/template@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.16.7.tgz#8d126c8701fde4d66b264b3eba3d96f07666d155"
+  integrity sha512-I8j/x8kHUrbYRTUxXrrMbfCa7jxkE7tZre39x3kjr9hvI82cK1FfqLygotcWN5kdPGWcLdWMHpSBavse5tWw3w==
   dependencies:
-    "@babel/code-frame" "^7.0.0"
-    "@babel/generator" "^7.2.2"
-    "@babel/helper-function-name" "^7.1.0"
-    "@babel/helper-split-export-declaration" "^7.0.0"
-    "@babel/parser" "^7.2.3"
-    "@babel/types" "^7.2.2"
-    debug "^4.1.0"
-    globals "^11.1.0"
-    lodash "^4.17.10"
+    "@babel/code-frame" "^7.16.7"
+    "@babel/parser" "^7.16.7"
+    "@babel/types" "^7.16.7"
 
-"@babel/traverse@^7.13.0", "@babel/traverse@^7.13.13":
+"@babel/traverse@^7.13.0":
   version "7.13.13"
   resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.13.13.tgz#39aa9c21aab69f74d948a486dd28a2dbdbf5114d"
   integrity sha512-CblEcwmXKR6eP43oQGG++0QMTtCjAsa3frUuzHoiIJWpaIIi8dwMyEFUJoXRLxagGqCK+jALRwIO+o3R9p/uUg==
@@ -941,16 +1057,23 @@
     debug "^4.1.0"
     globals "^11.1.0"
 
-"@babel/types@^7.0.0", "@babel/types@^7.2.2":
-  version "7.2.2"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.2.2.tgz#44e10fc24e33af524488b716cdaee5360ea8ed1e"
-  integrity sha512-fKCuD6UFUMkR541eDWL+2ih/xFZBXPOg/7EQFeTluMDebfqR4jrpaCjLhkWlQS4hT6nRa2PMEgXKbRB5/H2fpg==
-  dependencies:
-    esutils "^2.0.2"
-    lodash "^4.17.10"
-    to-fast-properties "^2.0.0"
+"@babel/traverse@^7.16.7", "@babel/traverse@^7.16.8", "@babel/traverse@^7.17.10", "@babel/traverse@^7.17.3", "@babel/traverse@^7.17.9", "@babel/traverse@^7.7.0":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.17.10.tgz#1ee1a5ac39f4eac844e6cf855b35520e5eb6f8b5"
+  integrity sha512-VmbrTHQteIdUUQNTb+zE12SHS/xQVIShmBPhlNP12hD5poF2pbITW1Z4172d03HegaQWhLffdkRJYtAzp0AGcw==
+  dependencies:
+    "@babel/code-frame" "^7.16.7"
+    "@babel/generator" "^7.17.10"
+    "@babel/helper-environment-visitor" "^7.16.7"
+    "@babel/helper-function-name" "^7.17.9"
+    "@babel/helper-hoist-variables" "^7.16.7"
+    "@babel/helper-split-export-declaration" "^7.16.7"
+    "@babel/parser" "^7.17.10"
+    "@babel/types" "^7.17.10"
+    debug "^4.1.0"
+    globals "^11.1.0"
 
-"@babel/types@^7.12.1", "@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.13.13", "@babel/types@^7.13.14", "@babel/types@^7.4.4":
+"@babel/types@^7.12.13", "@babel/types@^7.13.0", "@babel/types@^7.13.12", "@babel/types@^7.13.13", "@babel/types@^7.4.4":
   version "7.13.14"
   resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.13.14.tgz#c35a4abb15c7cd45a2746d78ab328e362cbace0d"
   integrity sha512-A2aa3QTkWoyqsZZFl56MLUsfmh7O0gN41IPvXAE/++8ojpbz12SszD7JEGYVdn4f9Kt4amIei07swF1h4AqmmQ==
@@ -959,37 +1082,180 @@
     lodash "^4.17.19"
     to-fast-properties "^2.0.0"
 
-"@eslint/eslintrc@^0.4.0":
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.0.tgz#99cc0a0584d72f1df38b900fb062ba995f395547"
-  integrity sha512-2ZPCc+uNbjV5ERJr+aKSPRwZgKd2z11x0EgLvb1PURmUrn9QNRXFqje0Ldq454PfAVyaJYyrDvvIKSFP4NnBog==
+"@babel/types@^7.16.0", "@babel/types@^7.16.7", "@babel/types@^7.16.8", "@babel/types@^7.17.0", "@babel/types@^7.17.10", "@babel/types@^7.7.0":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.17.10.tgz#d35d7b4467e439fcf06d195f8100e0fea7fc82c4"
+  integrity sha512-9O26jG0mBYfGkUYCYZRnBwbVLd1UZOICEr2Em6InB6jVfsAv1GKgwXHmrSg+WFWDmeKTA6vyTZiN8tCSM5Oo3A==
+  dependencies:
+    "@babel/helper-validator-identifier" "^7.16.7"
+    to-fast-properties "^2.0.0"
+
+"@colors/colors@1.5.0":
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
+  integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
+
+"@commitlint/config-validator@^16.2.1":
+  version "16.2.1"
+  resolved "https://registry.yarnpkg.com/@commitlint/config-validator/-/config-validator-16.2.1.tgz#794e769afd4756e4cf1bfd823b6612932e39c56d"
+  integrity sha512-hogSe0WGg7CKmp4IfNbdNES3Rq3UEI4XRPB8JL4EPgo/ORq5nrGTVzxJh78omibNuB8Ho4501Czb1Er1MoDWpw==
+  dependencies:
+    "@commitlint/types" "^16.2.1"
+    ajv "^6.12.6"
+
+"@commitlint/execute-rule@^16.2.1":
+  version "16.2.1"
+  resolved "https://registry.yarnpkg.com/@commitlint/execute-rule/-/execute-rule-16.2.1.tgz#60be73be4b9af97a41546e7ce59fdd33787c65f8"
+  integrity sha512-oSls82fmUTLM6cl5V3epdVo4gHhbmBFvCvQGHBRdQ50H/690Uq1Dyd7hXMuKITCIdcnr9umyDkr8r5C6HZDF3g==
+
+"@commitlint/load@>6.1.1":
+  version "16.2.4"
+  resolved "https://registry.yarnpkg.com/@commitlint/load/-/load-16.2.4.tgz#32c9f4c6538b21cf48cf40266312bb1adb65f435"
+  integrity sha512-HjANm3/29ROV+zt4yfaY/K6gpr9Dbzgtlp0kSwZGW0poDXlD/yqVYgPQ6JolJzZii5FUz5R4yVLC15hVL/w60w==
+  dependencies:
+    "@commitlint/config-validator" "^16.2.1"
+    "@commitlint/execute-rule" "^16.2.1"
+    "@commitlint/resolve-extends" "^16.2.1"
+    "@commitlint/types" "^16.2.1"
+    "@types/node" ">=12"
+    chalk "^4.0.0"
+    cosmiconfig "^7.0.0"
+    cosmiconfig-typescript-loader "^1.0.0"
+    lodash "^4.17.19"
+    resolve-from "^5.0.0"
+    typescript "^4.4.3"
+
+"@commitlint/resolve-extends@^16.2.1":
+  version "16.2.1"
+  resolved "https://registry.yarnpkg.com/@commitlint/resolve-extends/-/resolve-extends-16.2.1.tgz#2f7833a5a3a7aa79f508e59fcb0f1d33c45ed360"
+  integrity sha512-NbbCMPKTFf2J805kwfP9EO+vV+XvnaHRcBy6ud5dF35dxMsvdJqke54W3XazXF1ZAxC4a3LBy4i/GNVBAthsEg==
+  dependencies:
+    "@commitlint/config-validator" "^16.2.1"
+    "@commitlint/types" "^16.2.1"
+    import-fresh "^3.0.0"
+    lodash "^4.17.19"
+    resolve-from "^5.0.0"
+    resolve-global "^1.0.0"
+
+"@commitlint/types@^16.2.1":
+  version "16.2.1"
+  resolved "https://registry.yarnpkg.com/@commitlint/types/-/types-16.2.1.tgz#f25d373b88b01e51fc3fa44488101361945a61bd"
+  integrity sha512-7/z7pA7BM0i8XvMSBynO7xsB3mVQPUZbVn6zMIlp/a091XJ3qAXRXc+HwLYhiIdzzS5fuxxNIHZMGHVD4HJxdA==
+  dependencies:
+    chalk "^4.0.0"
+
+"@cspotcode/source-map-consumer@0.8.0":
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz#33bf4b7b39c178821606f669bbc447a6a629786b"
+  integrity sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg==
+
+"@cspotcode/source-map-support@0.7.0":
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.7.0.tgz#4789840aa859e46d2f3173727ab707c66bf344f5"
+  integrity sha512-X4xqRHqN8ACt2aHVe51OxeA2HjbcL4MqFqXkrmQszJ1NOUuUu5u6Vqx/0lZSVNku7velL5FC/s5uEAj1lsBMhA==
+  dependencies:
+    "@cspotcode/source-map-consumer" "0.8.0"
+
+"@eslint/eslintrc@^1.2.2":
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.2.2.tgz#4989b9e8c0216747ee7cca314ae73791bb281aae"
+  integrity sha512-lTVWHs7O2hjBFZunXTZYnYqtB9GakA1lnxIf+gKq2nY5gxkkNi/lQvveW6t8gFdOHTg6nG50Xs95PrLqVpcaLg==
   dependencies:
     ajv "^6.12.4"
-    debug "^4.1.1"
-    espree "^7.3.0"
-    globals "^12.1.0"
-    ignore "^4.0.6"
+    debug "^4.3.2"
+    espree "^9.3.1"
+    globals "^13.9.0"
+    ignore "^5.2.0"
     import-fresh "^3.2.1"
-    js-yaml "^3.13.1"
+    js-yaml "^4.1.0"
     minimatch "^3.0.4"
     strip-json-comments "^3.1.1"
 
-"@iamstarkov/listr-update-renderer@0.4.1":
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/@iamstarkov/listr-update-renderer/-/listr-update-renderer-0.4.1.tgz#d7c48092a2dcf90fd672b6c8b458649cb350c77e"
-  integrity sha512-IJyxQWsYDEkf8C8QthBn5N8tIUR9V9je6j3sMIpAkonaadjbvxmRC6RAhpa3RKxndhNnU2M6iNbtJwd7usQYIA==
+"@humanwhocodes/config-array@^0.9.2":
+  version "0.9.5"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.9.5.tgz#2cbaf9a89460da24b5ca6531b8bbfc23e1df50c7"
+  integrity sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==
   dependencies:
-    chalk "^1.1.3"
-    cli-truncate "^0.2.1"
-    elegant-spinner "^1.0.1"
-    figures "^1.7.0"
-    indent-string "^3.0.0"
-    log-symbols "^1.0.2"
-    log-update "^2.3.0"
-    strip-ansi "^3.0.1"
+    "@humanwhocodes/object-schema" "^1.2.1"
+    debug "^4.1.1"
+    minimatch "^3.0.4"
 
-"@nodelib/fs.scandir@2.1.4":
-  version "2.1.4"
+"@humanwhocodes/object-schema@^1.2.1":
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
+  integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
+
+"@hutson/parse-repository-url@^3.0.0":
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/@hutson/parse-repository-url/-/parse-repository-url-3.0.2.tgz#98c23c950a3d9b6c8f0daed06da6c3af06981340"
+  integrity sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==
+
+"@istanbuljs/load-nyc-config@^1.0.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced"
+  integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==
+  dependencies:
+    camelcase "^5.3.1"
+    find-up "^4.1.0"
+    get-package-type "^0.1.0"
+    js-yaml "^3.13.1"
+    resolve-from "^5.0.0"
+
+"@istanbuljs/schema@^0.1.2":
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98"
+  integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==
+
+"@jridgewell/gen-mapping@^0.1.0":
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz#e5d2e450306a9491e3bd77e323e38d7aff315996"
+  integrity sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==
+  dependencies:
+    "@jridgewell/set-array" "^1.0.0"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+
+"@jridgewell/resolve-uri@^3.0.3":
+  version "3.0.6"
+  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.0.6.tgz#4ac237f4dabc8dd93330386907b97591801f7352"
+  integrity sha512-R7xHtBSNm+9SyvpJkdQl+qrM3Hm2fea3Ef197M3mUug+v+yR+Rhfbs7PBtcBUVnIWJ4JcAdjvij+c8hXS9p5aw==
+
+"@jridgewell/set-array@^1.0.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.0.tgz#1179863356ac8fbea64a5a4bcde93a4871012c01"
+  integrity sha512-SfJxIxNVYLTsKwzB3MoOQ1yxf4w/E6MdkvTgrgAt1bfxjSrLUoHMKrDOykwN14q65waezZIdqDneUIPh4/sKxg==
+
+"@jridgewell/sourcemap-codec@^1.4.10":
+  version "1.4.11"
+  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.11.tgz#771a1d8d744eeb71b6adb35808e1a6c7b9b8c8ec"
+  integrity sha512-Fg32GrJo61m+VqYSdRSjRXMjQ06j8YIYfcTqndLYVAaHmroZHLJZCydsWBOTDqXS2v+mjxohBWEMfg97GXmYQg==
+
+"@jridgewell/trace-mapping@^0.3.9":
+  version "0.3.9"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
+  integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.0.3"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+
+"@nightwatch/chai@5.0.2":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@nightwatch/chai/-/chai-5.0.2.tgz#86b20908fc090dffd5c9567c0392bc6a494cc2e6"
+  integrity sha512-yzILJFCcE75OPoRfBlJ80Y3Ky06ljsdrK4Ld92yhmM477vxO2GEguwnd+ldl7pdSYTcg1gSJ1bPPQrA+/Hrn+A==
+  dependencies:
+    assertion-error "1.1.0"
+    check-error "1.0.2"
+    deep-eql "4.0.1"
+    loupe "2.3.4"
+    pathval "1.1.1"
+    type-detect "4.0.8"
+
+"@nightwatch/ejs@3.2.0":
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/@nightwatch/ejs/-/ejs-3.2.0.tgz#cc9a069d7f7fe35d94b21c346b031af10bff4570"
+  integrity sha512-NbJzBXGjh7gzG9nCYtbpdHrqQ3CnMt1FUBj8PomVyc1q5+qBFS8z3aLvBGWPt1leHmRK6d4TZn/jsS0XKmVGQQ==
+
+"@nodelib/fs.scandir@2.1.4":
+  version "2.1.4"
   resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.4.tgz#d4b3549a5db5de2683e0c1071ab4f140904bbf69"
   integrity sha512-33g3pMJk3bg5nXbL/+CY6I2eJDzZAni49PfJnL5fghPTggPvBd/pFNSgJsdAgWptuFu7qq/ERvOYFlhvsLTCKA==
   dependencies:
@@ -1009,10 +1275,10 @@
     "@nodelib/fs.scandir" "2.1.4"
     fastq "^1.6.0"
 
-"@rollup/plugin-alias@^3.1.2":
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-3.1.2.tgz#c585b05be4a7782d269c69d13def56f44e417772"
-  integrity sha512-wzDnQ6v7CcoRzS0qVwFPrFdYA4Qlr+ookA217Y2Z3DPZE1R8jrFNM3jvGgOf6o6DMjbnQIn5lCIJgHPe1Bt3uw==
+"@rollup/plugin-alias@^3.1.9":
+  version "3.1.9"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-3.1.9.tgz#a5d267548fe48441f34be8323fb64d1d4a1b3fdf"
+  integrity sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==
   dependencies:
     slash "^3.0.0"
 
@@ -1025,10 +1291,10 @@
     "@types/buble" "^0.19.2"
     buble "^0.20.0"
 
-"@rollup/plugin-commonjs@^18.0.0":
-  version "18.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-18.0.0.tgz#50dc7518b5aa9e66a270e529ea85115d269825c4"
-  integrity sha512-fj92shhg8luw7XbA0HowAqz90oo7qtLGwqTKbyZ8pmOyH8ui5e+u0wPEgeHLH3djcVma6gUCUrjY6w5R2o1u6g==
+"@rollup/plugin-commonjs@^22.0.0":
+  version "22.0.0"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.0.tgz#f4d87016e2fbf187a593ab9f46626fe05b59e8bd"
+  integrity sha512-Ktvf2j+bAO+30awhbYoCaXpBcyPmJbaEUYClQns/+6SNCYFURbvBiNbWgHITEsIgDDWCDUclWRKEuf8cwZCFoQ==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
     commondir "^1.0.1"
@@ -1038,10 +1304,10 @@
     magic-string "^0.25.7"
     resolve "^1.17.0"
 
-"@rollup/plugin-node-resolve@^11.2.1":
-  version "11.2.1"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz#82aa59397a29cd4e13248b106e6a4a1880362a60"
-  integrity sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==
+"@rollup/plugin-node-resolve@^13.2.1":
+  version "13.2.1"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-13.2.1.tgz#cdee815cf02c180ff0a42536ca67a8f67e299f84"
+  integrity sha512-btX7kzGvp1JwShQI9V6IM841YKNPYjKCvUbNrQ2EcVYbULtUd/GH6wZ/qdqH13j9pOHBER+EZXNN2L8RSJhVRA==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
     "@types/resolve" "1.17.1"
@@ -1050,10 +1316,10 @@
     is-module "^1.0.0"
     resolve "^1.19.0"
 
-"@rollup/plugin-replace@^2.4.2":
-  version "2.4.2"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-replace/-/plugin-replace-2.4.2.tgz#a2d539314fbc77c244858faa523012825068510a"
-  integrity sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==
+"@rollup/plugin-replace@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-replace/-/plugin-replace-4.0.0.tgz#e34c457d6a285f0213359740b43f39d969b38a67"
+  integrity sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
     magic-string "^0.25.7"
@@ -1067,25 +1333,65 @@
     estree-walker "^1.0.1"
     picomatch "^2.2.2"
 
-"@rollup/pluginutils@^4.1.0":
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.1.0.tgz#0dcc61c780e39257554feb7f77207dceca13c838"
-  integrity sha512-TrBhfJkFxA+ER+ew2U2/fHbebhLT/l/2pRk0hfj9KusXUuRXd2v0R58AfaZK9VXDQ4TogOSEmICVrQAA3zFnHQ==
+"@rollup/pluginutils@^4.1.2":
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.2.1.tgz#e6c6c3aba0744edce3fb2074922d3776c0af2a6d"
+  integrity sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==
   dependencies:
     estree-walker "^2.0.1"
     picomatch "^2.2.2"
 
-"@samverschueren/stream-to-observable@^0.3.0":
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.0.tgz#ecdf48d532c58ea477acfcab80348424f8d0662f"
-  integrity sha512-MI4Xx6LHs4Webyvi6EbspgyAb4D2Q2VtnCQ1blOJcoLS6mVa8lNN2rkIy1CVxfTUpoyIbCTkXES1rLXztFD1lg==
+"@sindresorhus/is@^0.7.0":
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.7.0.tgz#9a06f4f137ee84d7df0460c1fdb1135ffa6c50fd"
+  integrity sha512-ONhaKPIufzzrlNbqtWFFd+jlnemX6lJAgq9ZeiZtS7I1PIf/la7CW4m83rTXRnVnsMbW2k56pGYu7AUFJD9Pow==
+
+"@sindresorhus/is@^4.0.0":
+  version "4.6.0"
+  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-4.6.0.tgz#3c7c9c46e678feefe7a2e5bb609d3dbd665ffb3f"
+  integrity sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==
+
+"@socket.io/base64-arraybuffer@~1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@socket.io/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz#568d9beae00b0d835f4f8c53fd55714986492e61"
+  integrity sha512-dOlCBKnDw4iShaIsH/bxujKTM18+2TOAsYz+KSc11Am38H4q5Xw8Bbz97ZYdrVNM+um3p7w86Bvvmcn9q+5+eQ==
+
+"@szmarczak/http-timer@^4.0.5":
+  version "4.0.6"
+  resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-4.0.6.tgz#b4a914bb62e7c272d4e5989fe4440f812ab1d807"
+  integrity sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==
   dependencies:
-    any-observable "^0.3.0"
+    defer-to-connect "^2.0.0"
 
-"@types/anymatch@*":
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/@types/anymatch/-/anymatch-1.3.0.tgz#d1d55958d1fccc5527d4aba29fc9c4b942f563ff"
-  integrity sha512-7WcbyctkE8GTzogDb0ulRAEw7v8oIS54ft9mQTU7PfM0hp5e+8kpa+HeQ7IQrFbKtJXBKcZ4bh+Em9dTw5L6AQ==
+"@testim/chrome-version@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@testim/chrome-version/-/chrome-version-1.1.2.tgz#092005c5b77bd3bb6576a4677110a11485e11864"
+  integrity sha512-1c4ZOETSRpI0iBfIFUqU4KqwBAB2lHUAlBjZz/YqOHqwM9dTTzjV6Km0ZkiEiSCx/tLr1BtESIKyWWMww+RUqw==
+
+"@tootallnate/once@1":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-1.1.2.tgz#ccb91445360179a04e7fe6aff78c00ffc1eeaf82"
+  integrity sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==
+
+"@tsconfig/node10@^1.0.7":
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.8.tgz#c1e4e80d6f964fbecb3359c43bd48b40f7cadad9"
+  integrity sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg==
+
+"@tsconfig/node12@^1.0.7":
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.9.tgz#62c1f6dee2ebd9aead80dc3afa56810e58e1a04c"
+  integrity sha512-/yBMcem+fbvhSREH+s14YJi18sp7J9jpuhYByADT2rypfajMZZN4WQ6zBGgBKp53NKmqI36wFYDb3yaMPurITw==
+
+"@tsconfig/node14@^1.0.0":
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.1.tgz#95f2d167ffb9b8d2068b0b235302fafd4df711f2"
+  integrity sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg==
+
+"@tsconfig/node16@^1.0.2":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.2.tgz#423c77877d0569db20e1fc80885ac4118314010e"
+  integrity sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==
 
 "@types/buble@^0.19.2":
   version "0.19.2"
@@ -1094,6 +1400,47 @@
   dependencies:
     magic-string "^0.25.0"
 
+"@types/cacheable-request@^6.0.1":
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/@types/cacheable-request/-/cacheable-request-6.0.2.tgz#c324da0197de0a98a2312156536ae262429ff6b9"
+  integrity sha512-B3xVo+dlKM6nnKTcmm5ZtY/OL8bOAOd2Olee9M1zft65ox50OzjEHW91sDiU9j6cvW8Ejg1/Qkf4xd2kugApUA==
+  dependencies:
+    "@types/http-cache-semantics" "*"
+    "@types/keyv" "*"
+    "@types/node" "*"
+    "@types/responselike" "*"
+
+"@types/component-emitter@^1.2.10":
+  version "1.2.11"
+  resolved "https://registry.yarnpkg.com/@types/component-emitter/-/component-emitter-1.2.11.tgz#50d47d42b347253817a39709fef03ce66a108506"
+  integrity sha512-SRXjM+tfsSlA9VuG8hGO2nft2p8zjXCK1VcC6N4NXbBbYbSia9kzCChYQajIjzIqOOOuh5Ock6MmV2oux4jDZQ==
+
+"@types/cookie@^0.4.1":
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/@types/cookie/-/cookie-0.4.1.tgz#bfd02c1f2224567676c1545199f87c3a861d878d"
+  integrity sha512-XW/Aa8APYr6jSVVA1y/DEIZX0/GMKLEVekNG727R8cs56ahETkRAy/3DR7+fJyh7oUgGwNQaRfXCun0+KbWY7Q==
+
+"@types/cors@^2.8.12":
+  version "2.8.12"
+  resolved "https://registry.yarnpkg.com/@types/cors/-/cors-2.8.12.tgz#6b2c510a7ad7039e98e7b8d3d6598f4359e5c080"
+  integrity sha512-vt+kDhq/M2ayberEtJcIN/hxXy1Pk+59g2FV/ZQceeaTyCtCucjL2Q7FXlFjtWn4n15KCr1NE2lNNFhp0lEThw==
+
+"@types/eslint-scope@^3.7.3":
+  version "3.7.3"
+  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.3.tgz#125b88504b61e3c8bc6f870882003253005c3224"
+  integrity sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==
+  dependencies:
+    "@types/eslint" "*"
+    "@types/estree" "*"
+
+"@types/eslint@*":
+  version "8.4.1"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.4.1.tgz#c48251553e8759db9e656de3efc846954ac32304"
+  integrity sha512-GE44+DNEyxxh2Kc6ro/VkIj+9ma0pO0bwv9+uHSyBrikYOHr8zYcdPvnBOp1aw8s+CjRvuSx7CyWqRrNFQ59mA==
+  dependencies:
+    "@types/estree" "*"
+    "@types/json-schema" "*"
+
 "@types/estree@*":
   version "0.0.47"
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.47.tgz#d7a51db20f0650efec24cd04994f523d93172ed4"
@@ -1104,25 +1451,76 @@
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
   integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
 
-"@types/he@^1.1.1":
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/@types/he/-/he-1.1.1.tgz#19e14033c4ee8f1a702c74dcc6182664839ac2b7"
-  integrity sha512-jpzrsR1ns0n3kyWt92QfOUQhIuJGQ9+QGa7M62rO6toe98woQjnsnzjdMtsQXCdvjjmqjS2ZBCC7xKw0cdzU+Q==
+"@types/estree@^0.0.51":
+  version "0.0.51"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.51.tgz#cfd70924a25a3fd32b218e5e420e6897e1ac4f40"
+  integrity sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==
+
+"@types/he@^1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@types/he/-/he-1.1.2.tgz#0c8b275f36d2b8b651104638e4d45693349c3953"
+  integrity sha512-kSJPcLO1x+oolc0R89pUl2kozldQ/fVQ1C1p5mp8fPoLdF/ZcBvckaTC2M8xXh3GYendXvCpy5m/a2eSbfgNgw==
+
+"@types/http-cache-semantics@*":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@types/http-cache-semantics/-/http-cache-semantics-4.0.1.tgz#0ea7b61496902b95890dc4c3a116b60cb8dae812"
+  integrity sha512-SZs7ekbP8CN0txVG2xVRH6EgKmEm31BOxA07vkFaETzZz1xh+cbt8BcI0slpymvwhx5dlFnQG2rTlPVQn+iRPQ==
+
+"@types/json-buffer@~3.0.0":
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/@types/json-buffer/-/json-buffer-3.0.0.tgz#85c1ff0f0948fc159810d4b5be35bf8c20875f64"
+  integrity sha512-3YP80IxxFJB4b5tYC2SUPwkg0XQLiu0nWvhRgEatgjf+29IcWO9X1k8xRv5DGssJ/lCrjYTjQPcobJr2yWIVuQ==
+
+"@types/json-schema@*", "@types/json-schema@^7.0.5", "@types/json-schema@^7.0.8", "@types/json-schema@^7.0.9":
+  version "7.0.11"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3"
+  integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==
+
+"@types/keyv@*":
+  version "3.1.4"
+  resolved "https://registry.yarnpkg.com/@types/keyv/-/keyv-3.1.4.tgz#3ccdb1c6751b0c7e52300bcdacd5bcbf8faa75b6"
+  integrity sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==
+  dependencies:
+    "@types/node" "*"
 
-"@types/json-schema@^7.0.3":
-  version "7.0.7"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.7.tgz#98a993516c859eb0d5c4c8f098317a9ea68db9ad"
-  integrity sha512-cxWFQVseBm6O9Gbw1IWb8r6OS4OhSt3hPZLkFApLjM8TEXROBuQGLAH2i2gZpcXdLBIrpXuTDhH7Vbm1iXmNGA==
+"@types/minimist@^1.2.0":
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c"
+  integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==
 
 "@types/node@*":
   version "14.14.37"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.37.tgz#a3dd8da4eb84a996c36e331df98d82abd76b516e"
   integrity sha512-XYmBiy+ohOR4Lh5jE379fV2IU+6Jn4g5qASinhitfyO71b/sCo6MKsMLF5tc7Zf2CE8hViVQyYSobJNke8OvUw==
 
-"@types/node@^12.12.0":
-  version "12.12.0"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-12.12.0.tgz#ff3201972d6dc851a9275308a17b9b5094e68057"
-  integrity sha512-6N8Sa5AaENRtJnpKXZgvc119PKxT1Lk9VPy4kfT8JF23tIe1qDfaGkBR2DRKJFIA7NptMz+fps//C6aLi1Uoug==
+"@types/node@>=10.0.0", "@types/node@>=12", "@types/node@^17.0.30":
+  version "17.0.30"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.30.tgz#2c6e8512acac70815e8176aa30c38025067880ef"
+  integrity sha512-oNBIZjIqyHYP8VCNAV9uEytXVeXG2oR0w9lgAXro20eugRQfY002qr3CUl6BAe+Yf/z3CRjPdz27Pu6WWtuSRw==
+
+"@types/normalize-package-data@^2.4.0":
+  version "2.4.1"
+  resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301"
+  integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==
+
+"@types/parse-json@^4.0.0":
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/@types/parse-json/-/parse-json-4.0.0.tgz#2f8bb441434d163b35fb8ffdccd7138927ffb8c0"
+  integrity sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==
+
+"@types/puppeteer-core@^5.4.0":
+  version "5.4.0"
+  resolved "https://registry.yarnpkg.com/@types/puppeteer-core/-/puppeteer-core-5.4.0.tgz#880a7917b4ede95cbfe2d5e81a558cfcb072c0fb"
+  integrity sha512-yqRPuv4EFcSkTyin6Yy17pN6Qz2vwVwTCJIDYMXbE3j8vTPhv0nCQlZOl5xfi0WHUkqvQsjAR8hAfjeMCoetwg==
+  dependencies:
+    "@types/puppeteer" "*"
+
+"@types/puppeteer@*":
+  version "5.4.6"
+  resolved "https://registry.yarnpkg.com/@types/puppeteer/-/puppeteer-5.4.6.tgz#afc438e41dcbc27ca1ba0235ea464a372db2b21c"
+  integrity sha512-98Kghehs7+/GD9b56qryhqdqVCXUTbetTv3PlvDnmFRTHQH0j9DIp1f7rkAW3BAj4U3yoeSEQnKgdW8bDq0Y0Q==
+  dependencies:
+    "@types/node" "*"
 
 "@types/resolve@1.17.1":
   version "1.17.1"
@@ -1131,251 +1529,296 @@
   dependencies:
     "@types/node" "*"
 
-"@types/tapable@*":
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/@types/tapable/-/tapable-1.0.4.tgz#b4ffc7dc97b498c969b360a41eee247f82616370"
-  integrity sha512-78AdXtlhpCHT0K3EytMpn4JNxaf5tbqbLcbIRoQIHzpTIyjpxLQKRoxU55ujBXAtg3Nl2h/XWvfDa9dsMOd0pQ==
+"@types/responselike@*", "@types/responselike@^1.0.0":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@types/responselike/-/responselike-1.0.0.tgz#251f4fe7d154d2bad125abe1b429b23afd262e29"
+  integrity sha512-85Y2BjiufFzaMIlvJDvTTB8Fxl2xfLo4HgmHzVBz08w4wDePCTjYw66PdrolO0kzli3yam/YCgRufyo1DdQVTA==
+  dependencies:
+    "@types/node" "*"
 
-"@types/uglify-js@*":
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/@types/uglify-js/-/uglify-js-3.0.4.tgz#96beae23df6f561862a830b4288a49e86baac082"
-  integrity sha512-SudIN9TRJ+v8g5pTG8RRCqfqTMNqgWCKKd3vtynhGzkIIjxaicNAMuY5TRadJ6tzDu3Dotf3ngaMILtmOdmWEQ==
+"@types/webpack@^5.28.0":
+  version "5.28.0"
+  resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-5.28.0.tgz#78dde06212f038d77e54116cfe69e88ae9ed2c03"
+  integrity sha512-8cP0CzcxUiFuA9xGJkfeVpqmWTk9nx6CWwamRGCj95ph1SmlRRk9KlCZ6avhCbZd4L68LvYT6l1kpdEnQXrF8w==
   dependencies:
-    source-map "^0.6.1"
+    "@types/node" "*"
+    tapable "^2.2.0"
+    webpack "^5"
+
+"@types/which@^1.3.2":
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/@types/which/-/which-1.3.2.tgz#9c246fc0c93ded311c8512df2891fb41f6227fdf"
+  integrity sha512-8oDqyLC7eD4HM307boe2QWKyuzdzWBj56xI/imSl2cpL+U3tCMaTAkMJ4ee5JBZ/FsOJlvRGeIShiZDAl1qERA==
 
-"@types/webpack@^4.4.22":
-  version "4.4.22"
-  resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-4.4.22.tgz#c4a5ea8b74a31b579537515bcfe86d2b2a34382c"
-  integrity sha512-PxAAzli3krZX9rCeONSR5Z9v4CR/2HPsKsiVRFNDo9OZefN+dTemteMHZnYkddOu4bqoYqJTJ724gLy0ZySXOw==
+"@types/yauzl@^2.9.1":
+  version "2.10.0"
+  resolved "https://registry.yarnpkg.com/@types/yauzl/-/yauzl-2.10.0.tgz#b3248295276cf8c6f153ebe6a9aba0c988cb2599"
+  integrity sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==
   dependencies:
-    "@types/anymatch" "*"
     "@types/node" "*"
-    "@types/tapable" "*"
-    "@types/uglify-js" "*"
-    source-map "^0.6.0"
 
-"@typescript-eslint/eslint-plugin@^4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.21.0.tgz#3fce2bfa76d95c00ac4f33dff369cb593aab8878"
-  integrity sha512-FPUyCPKZbVGexmbCFI3EQHzCZdy2/5f+jv6k2EDljGdXSRc0cKvbndd2nHZkSLqCNOPk0jB6lGzwIkglXcYVsQ==
+"@typescript-eslint/eslint-plugin@^5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.21.0.tgz#bfc22e0191e6404ab1192973b3b4ea0461c1e878"
+  integrity sha512-fTU85q8v5ZLpoZEyn/u1S2qrFOhi33Edo2CZ0+q1gDaWWm0JuPh3bgOyU8lM0edIEYgKLDkPFiZX2MOupgjlyg==
   dependencies:
-    "@typescript-eslint/experimental-utils" "4.21.0"
-    "@typescript-eslint/scope-manager" "4.21.0"
-    debug "^4.1.1"
+    "@typescript-eslint/scope-manager" "5.21.0"
+    "@typescript-eslint/type-utils" "5.21.0"
+    "@typescript-eslint/utils" "5.21.0"
+    debug "^4.3.2"
     functional-red-black-tree "^1.0.1"
-    lodash "^4.17.15"
-    regexpp "^3.0.0"
-    semver "^7.3.2"
-    tsutils "^3.17.1"
-
-"@typescript-eslint/experimental-utils@4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/experimental-utils/-/experimental-utils-4.21.0.tgz#0b0bb7c15d379140a660c003bdbafa71ae9134b6"
-  integrity sha512-cEbgosW/tUFvKmkg3cU7LBoZhvUs+ZPVM9alb25XvR0dal4qHL3SiUqHNrzoWSxaXA9gsifrYrS1xdDV6w/gIA==
-  dependencies:
-    "@types/json-schema" "^7.0.3"
-    "@typescript-eslint/scope-manager" "4.21.0"
-    "@typescript-eslint/types" "4.21.0"
-    "@typescript-eslint/typescript-estree" "4.21.0"
-    eslint-scope "^5.0.0"
-    eslint-utils "^2.0.0"
-
-"@typescript-eslint/parser@^4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.21.0.tgz#a227fc2af4001668c3e3f7415d4feee5093894c1"
-  integrity sha512-eyNf7QmE5O/l1smaQgN0Lj2M/1jOuNg2NrBm1dqqQN0sVngTLyw8tdCbih96ixlhbF1oINoN8fDCyEH9SjLeIA==
-  dependencies:
-    "@typescript-eslint/scope-manager" "4.21.0"
-    "@typescript-eslint/types" "4.21.0"
-    "@typescript-eslint/typescript-estree" "4.21.0"
-    debug "^4.1.1"
+    ignore "^5.1.8"
+    regexpp "^3.2.0"
+    semver "^7.3.5"
+    tsutils "^3.21.0"
+
+"@typescript-eslint/parser@^5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.21.0.tgz#6cb72673dbf3e1905b9c432175a3c86cdaf2071f"
+  integrity sha512-8RUwTO77hstXUr3pZoWZbRQUxXcSXafZ8/5gpnQCfXvgmP9gpNlRGlWzvfbEQ14TLjmtU8eGnONkff8U2ui2Eg==
+  dependencies:
+    "@typescript-eslint/scope-manager" "5.21.0"
+    "@typescript-eslint/types" "5.21.0"
+    "@typescript-eslint/typescript-estree" "5.21.0"
+    debug "^4.3.2"
+
+"@typescript-eslint/scope-manager@5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.21.0.tgz#a4b7ed1618f09f95e3d17d1c0ff7a341dac7862e"
+  integrity sha512-XTX0g0IhvzcH/e3393SvjRCfYQxgxtYzL3UREteUneo72EFlt7UNoiYnikUtmGVobTbhUDByhJ4xRBNe+34kOQ==
+  dependencies:
+    "@typescript-eslint/types" "5.21.0"
+    "@typescript-eslint/visitor-keys" "5.21.0"
+
+"@typescript-eslint/type-utils@5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.21.0.tgz#ff89668786ad596d904c21b215e5285da1b6262e"
+  integrity sha512-MxmLZj0tkGlkcZCSE17ORaHl8Th3JQwBzyXL/uvC6sNmu128LsgjTX0NIzy+wdH2J7Pd02GN8FaoudJntFvSOw==
+  dependencies:
+    "@typescript-eslint/utils" "5.21.0"
+    debug "^4.3.2"
+    tsutils "^3.21.0"
+
+"@typescript-eslint/types@5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.21.0.tgz#8cdb9253c0dfce3f2ab655b9d36c03f72e684017"
+  integrity sha512-XnOOo5Wc2cBlq8Lh5WNvAgHzpjnEzxn4CJBwGkcau7b/tZ556qrWXQz4DJyChYg8JZAD06kczrdgFPpEQZfDsA==
+
+"@typescript-eslint/typescript-estree@5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.21.0.tgz#9f0c233e28be2540eaed3df050f0d54fb5aa52de"
+  integrity sha512-Y8Y2T2FNvm08qlcoSMoNchh9y2Uj3QmjtwNMdRQkcFG7Muz//wfJBGBxh8R7HAGQFpgYpdHqUpEoPQk+q9Kjfg==
+  dependencies:
+    "@typescript-eslint/types" "5.21.0"
+    "@typescript-eslint/visitor-keys" "5.21.0"
+    debug "^4.3.2"
+    globby "^11.0.4"
+    is-glob "^4.0.3"
+    semver "^7.3.5"
+    tsutils "^3.21.0"
+
+"@typescript-eslint/utils@5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.21.0.tgz#51d7886a6f0575e23706e5548c7e87bce42d7c18"
+  integrity sha512-q/emogbND9wry7zxy7VYri+7ydawo2HDZhRZ5k6yggIvXa7PvBbAAZ4PFH/oZLem72ezC4Pr63rJvDK/sTlL8Q==
+  dependencies:
+    "@types/json-schema" "^7.0.9"
+    "@typescript-eslint/scope-manager" "5.21.0"
+    "@typescript-eslint/types" "5.21.0"
+    "@typescript-eslint/typescript-estree" "5.21.0"
+    eslint-scope "^5.1.1"
+    eslint-utils "^3.0.0"
 
-"@typescript-eslint/scope-manager@4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.21.0.tgz#c81b661c4b8af1ec0c010d847a8f9ab76ab95b4d"
-  integrity sha512-kfOjF0w1Ix7+a5T1knOw00f7uAP9Gx44+OEsNQi0PvvTPLYeXJlsCJ4tYnDj5PQEYfpcgOH5yBlw7K+UEI9Agw==
+"@typescript-eslint/visitor-keys@5.21.0":
+  version "5.21.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.21.0.tgz#453fb3662409abaf2f8b1f65d515699c888dd8ae"
+  integrity sha512-SX8jNN+iHqAF0riZQMkm7e8+POXa/fXw5cxL+gjpyP+FI+JVNhii53EmQgDAfDcBpFekYSlO0fGytMQwRiMQCA==
   dependencies:
-    "@typescript-eslint/types" "4.21.0"
-    "@typescript-eslint/visitor-keys" "4.21.0"
+    "@typescript-eslint/types" "5.21.0"
+    eslint-visitor-keys "^3.0.0"
 
-"@typescript-eslint/types@4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.21.0.tgz#abdc3463bda5d31156984fa5bc316789c960edef"
-  integrity sha512-+OQaupjGVVc8iXbt6M1oZMwyKQNehAfLYJJ3SdvnofK2qcjfor9pEM62rVjBknhowTkh+2HF+/KdRAc/wGBN2w==
+"@ungap/promise-all-settled@1.1.2":
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz#aa58042711d6e3275dd37dc597e5d31e8c290a44"
+  integrity sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==
 
-"@typescript-eslint/typescript-estree@4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.21.0.tgz#3817bd91857beeaeff90f69f1f112ea58d350b0a"
-  integrity sha512-ZD3M7yLaVGVYLw4nkkoGKumb7Rog7QID9YOWobFDMQKNl+vPxqVIW/uDk+MDeGc+OHcoG2nJ2HphwiPNajKw3w==
+"@wdio/config@6.12.1":
+  version "6.12.1"
+  resolved "https://registry.yarnpkg.com/@wdio/config/-/config-6.12.1.tgz#86d987b505d8ca85ec11471830d2ba296dab3bcf"
+  integrity sha512-V5hTIW5FNlZ1W33smHF4Rd5BKjGW2KeYhyXDQfXHjqLCeRiirZ9fABCo9plaVQDnwWSUMWYaAaIAifV82/oJCQ==
   dependencies:
-    "@typescript-eslint/types" "4.21.0"
-    "@typescript-eslint/visitor-keys" "4.21.0"
-    debug "^4.1.1"
-    globby "^11.0.1"
-    is-glob "^4.0.1"
-    semver "^7.3.2"
-    tsutils "^3.17.1"
+    "@wdio/logger" "6.10.10"
+    deepmerge "^4.0.0"
+    glob "^7.1.2"
 
-"@typescript-eslint/visitor-keys@4.21.0":
-  version "4.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.21.0.tgz#990a9acdc124331f5863c2cf21c88ba65233cd8d"
-  integrity sha512-dH22dROWGi5Z6p+Igc8bLVLmwy7vEe8r+8c+raPQU0LxgogPUrRAtRGtvBWmlr9waTu3n+QLt/qrS/hWzk1x5w==
+"@wdio/logger@6.10.10":
+  version "6.10.10"
+  resolved "https://registry.yarnpkg.com/@wdio/logger/-/logger-6.10.10.tgz#1e07cf32a69606ddb94fa9fd4b0171cb839a5980"
+  integrity sha512-2nh0hJz9HeZE0VIEMI+oPgjr/Q37ohrR9iqsl7f7GW5ik+PnKYCT9Eab5mR1GNMG60askwbskgGC1S9ygtvrSw==
   dependencies:
-    "@typescript-eslint/types" "4.21.0"
-    eslint-visitor-keys "^2.0.0"
+    chalk "^4.0.0"
+    loglevel "^1.6.0"
+    loglevel-plugin-prefix "^0.8.4"
+    strip-ansi "^6.0.0"
 
-"@webassemblyjs/ast@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.7.11.tgz#b988582cafbb2b095e8b556526f30c90d057cace"
-  integrity sha512-ZEzy4vjvTzScC+SH8RBssQUawpaInUdMTYwYYLh54/s8TuT0gBLuyUnppKsVyZEi876VmmStKsUs28UxPgdvrA==
-  dependencies:
-    "@webassemblyjs/helper-module-context" "1.7.11"
-    "@webassemblyjs/helper-wasm-bytecode" "1.7.11"
-    "@webassemblyjs/wast-parser" "1.7.11"
-
-"@webassemblyjs/floating-point-hex-parser@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.7.11.tgz#a69f0af6502eb9a3c045555b1a6129d3d3f2e313"
-  integrity sha512-zY8dSNyYcgzNRNT666/zOoAyImshm3ycKdoLsyDw/Bwo6+/uktb7p4xyApuef1dwEBo/U/SYQzbGBvV+nru2Xg==
-
-"@webassemblyjs/helper-api-error@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.7.11.tgz#c7b6bb8105f84039511a2b39ce494f193818a32a"
-  integrity sha512-7r1qXLmiglC+wPNkGuXCvkmalyEstKVwcueZRP2GNC2PAvxbLYwLLPr14rcdJaE4UtHxQKfFkuDFuv91ipqvXg==
-
-"@webassemblyjs/helper-buffer@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.7.11.tgz#3122d48dcc6c9456ed982debe16c8f37101df39b"
-  integrity sha512-MynuervdylPPh3ix+mKZloTcL06P8tenNH3sx6s0qE8SLR6DdwnfgA7Hc9NSYeob2jrW5Vql6GVlsQzKQCa13w==
-
-"@webassemblyjs/helper-code-frame@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-code-frame/-/helper-code-frame-1.7.11.tgz#cf8f106e746662a0da29bdef635fcd3d1248364b"
-  integrity sha512-T8ESC9KMXFTXA5urJcyor5cn6qWeZ4/zLPyWeEXZ03hj/x9weSokGNkVCdnhSabKGYWxElSdgJ+sFa9G/RdHNw==
-  dependencies:
-    "@webassemblyjs/wast-printer" "1.7.11"
-
-"@webassemblyjs/helper-fsm@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-fsm/-/helper-fsm-1.7.11.tgz#df38882a624080d03f7503f93e3f17ac5ac01181"
-  integrity sha512-nsAQWNP1+8Z6tkzdYlXT0kxfa2Z1tRTARd8wYnc/e3Zv3VydVVnaeePgqUzFrpkGUyhUUxOl5ML7f1NuT+gC0A==
-
-"@webassemblyjs/helper-module-context@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-module-context/-/helper-module-context-1.7.11.tgz#d874d722e51e62ac202476935d649c802fa0e209"
-  integrity sha512-JxfD5DX8Ygq4PvXDucq0M+sbUFA7BJAv/GGl9ITovqE+idGX+J3QSzJYz+LwQmL7fC3Rs+utvWoJxDb6pmC0qg==
-
-"@webassemblyjs/helper-wasm-bytecode@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.7.11.tgz#dd9a1e817f1c2eb105b4cf1013093cb9f3c9cb06"
-  integrity sha512-cMXeVS9rhoXsI9LLL4tJxBgVD/KMOKXuFqYb5oCJ/opScWpkCMEz9EJtkonaNcnLv2R3K5jIeS4TRj/drde1JQ==
-
-"@webassemblyjs/helper-wasm-section@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.7.11.tgz#9c9ac41ecf9fbcfffc96f6d2675e2de33811e68a"
-  integrity sha512-8ZRY5iZbZdtNFE5UFunB8mmBEAbSI3guwbrsCl4fWdfRiAcvqQpeqd5KHhSWLL5wuxo53zcaGZDBU64qgn4I4Q==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/helper-buffer" "1.7.11"
-    "@webassemblyjs/helper-wasm-bytecode" "1.7.11"
-    "@webassemblyjs/wasm-gen" "1.7.11"
-
-"@webassemblyjs/ieee754@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.7.11.tgz#c95839eb63757a31880aaec7b6512d4191ac640b"
-  integrity sha512-Mmqx/cS68K1tSrvRLtaV/Lp3NZWzXtOHUW2IvDvl2sihAwJh4ACE0eL6A8FvMyDG9abes3saB6dMimLOs+HMoQ==
+"@wdio/protocols@6.12.0":
+  version "6.12.0"
+  resolved "https://registry.yarnpkg.com/@wdio/protocols/-/protocols-6.12.0.tgz#e40850be62c42c82dd2c486655d6419cd9ec1e3e"
+  integrity sha512-UhTBZxClCsM3VjaiDp4DoSCnsa7D1QNmI2kqEBfIpyNkT3GcZhJb7L+nL0fTkzCwi7+/uLastb3/aOwH99gt0A==
+
+"@wdio/repl@6.11.0":
+  version "6.11.0"
+  resolved "https://registry.yarnpkg.com/@wdio/repl/-/repl-6.11.0.tgz#5b1eab574b6b89f7f7c383e7295c06af23c3818e"
+  integrity sha512-FxrFKiTkFyELNGGVEH1uijyvNY7lUpmff6x+FGskFGZB4uSRs0rxkOMaEjxnxw7QP1zgQKr2xC7GyO03gIGRGg==
+  dependencies:
+    "@wdio/utils" "6.11.0"
+
+"@wdio/utils@6.11.0":
+  version "6.11.0"
+  resolved "https://registry.yarnpkg.com/@wdio/utils/-/utils-6.11.0.tgz#878c2500efb1a325bf5a66d2ff3d08162f976e8c"
+  integrity sha512-vf0sOQzd28WbI26d6/ORrQ4XKWTzSlWLm9W/K/eJO0NASKPEzR+E+Q2kaa+MJ4FKXUpjbt+Lxfo+C26TzBk7tg==
+  dependencies:
+    "@wdio/logger" "6.10.10"
+
+"@webassemblyjs/ast@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.1.tgz#2bfd767eae1a6996f432ff7e8d7fc75679c0b6a7"
+  integrity sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==
+  dependencies:
+    "@webassemblyjs/helper-numbers" "1.11.1"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
+
+"@webassemblyjs/floating-point-hex-parser@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.1.tgz#f6c61a705f0fd7a6aecaa4e8198f23d9dc179e4f"
+  integrity sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==
+
+"@webassemblyjs/helper-api-error@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.1.tgz#1a63192d8788e5c012800ba6a7a46c705288fd16"
+  integrity sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==
+
+"@webassemblyjs/helper-buffer@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.1.tgz#832a900eb444884cde9a7cad467f81500f5e5ab5"
+  integrity sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==
+
+"@webassemblyjs/helper-numbers@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.1.tgz#64d81da219fbbba1e3bd1bfc74f6e8c4e10a62ae"
+  integrity sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==
+  dependencies:
+    "@webassemblyjs/floating-point-hex-parser" "1.11.1"
+    "@webassemblyjs/helper-api-error" "1.11.1"
+    "@xtuc/long" "4.2.2"
+
+"@webassemblyjs/helper-wasm-bytecode@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.1.tgz#f328241e41e7b199d0b20c18e88429c4433295e1"
+  integrity sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==
+
+"@webassemblyjs/helper-wasm-section@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.1.tgz#21ee065a7b635f319e738f0dd73bfbda281c097a"
+  integrity sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.1"
+    "@webassemblyjs/helper-buffer" "1.11.1"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
+    "@webassemblyjs/wasm-gen" "1.11.1"
+
+"@webassemblyjs/ieee754@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.1.tgz#963929e9bbd05709e7e12243a099180812992614"
+  integrity sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==
   dependencies:
     "@xtuc/ieee754" "^1.2.0"
 
-"@webassemblyjs/leb128@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.7.11.tgz#d7267a1ee9c4594fd3f7e37298818ec65687db63"
-  integrity sha512-vuGmgZjjp3zjcerQg+JA+tGOncOnJLWVkt8Aze5eWQLwTQGNgVLcyOTqgSCxWTR4J42ijHbBxnuRaL1Rv7XMdw==
-  dependencies:
-    "@xtuc/long" "4.2.1"
-
-"@webassemblyjs/utf8@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.7.11.tgz#06d7218ea9fdc94a6793aa92208160db3d26ee82"
-  integrity sha512-C6GFkc7aErQIAH+BMrIdVSmW+6HSe20wg57HEC1uqJP8E/xpMjXqQUxkQw07MhNDSDcGpxI9G5JSNOQCqJk4sA==
-
-"@webassemblyjs/wasm-edit@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.7.11.tgz#8c74ca474d4f951d01dbae9bd70814ee22a82005"
-  integrity sha512-FUd97guNGsCZQgeTPKdgxJhBXkUbMTY6hFPf2Y4OedXd48H97J+sOY2Ltaq6WGVpIH8o/TGOVNiVz/SbpEMJGg==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/helper-buffer" "1.7.11"
-    "@webassemblyjs/helper-wasm-bytecode" "1.7.11"
-    "@webassemblyjs/helper-wasm-section" "1.7.11"
-    "@webassemblyjs/wasm-gen" "1.7.11"
-    "@webassemblyjs/wasm-opt" "1.7.11"
-    "@webassemblyjs/wasm-parser" "1.7.11"
-    "@webassemblyjs/wast-printer" "1.7.11"
-
-"@webassemblyjs/wasm-gen@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.7.11.tgz#9bbba942f22375686a6fb759afcd7ac9c45da1a8"
-  integrity sha512-U/KDYp7fgAZX5KPfq4NOupK/BmhDc5Kjy2GIqstMhvvdJRcER/kUsMThpWeRP8BMn4LXaKhSTggIJPOeYHwISA==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/helper-wasm-bytecode" "1.7.11"
-    "@webassemblyjs/ieee754" "1.7.11"
-    "@webassemblyjs/leb128" "1.7.11"
-    "@webassemblyjs/utf8" "1.7.11"
-
-"@webassemblyjs/wasm-opt@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.7.11.tgz#b331e8e7cef8f8e2f007d42c3a36a0580a7d6ca7"
-  integrity sha512-XynkOwQyiRidh0GLua7SkeHvAPXQV/RxsUeERILmAInZegApOUAIJfRuPYe2F7RcjOC9tW3Cb9juPvAC/sCqvg==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/helper-buffer" "1.7.11"
-    "@webassemblyjs/wasm-gen" "1.7.11"
-    "@webassemblyjs/wasm-parser" "1.7.11"
-
-"@webassemblyjs/wasm-parser@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.7.11.tgz#6e3d20fa6a3519f6b084ef9391ad58211efb0a1a"
-  integrity sha512-6lmXRTrrZjYD8Ng8xRyvyXQJYUQKYSXhJqXOBLw24rdiXsHAOlvw5PhesjdcaMadU/pyPQOJ5dHreMjBxwnQKg==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/helper-api-error" "1.7.11"
-    "@webassemblyjs/helper-wasm-bytecode" "1.7.11"
-    "@webassemblyjs/ieee754" "1.7.11"
-    "@webassemblyjs/leb128" "1.7.11"
-    "@webassemblyjs/utf8" "1.7.11"
-
-"@webassemblyjs/wast-parser@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-parser/-/wast-parser-1.7.11.tgz#25bd117562ca8c002720ff8116ef9072d9ca869c"
-  integrity sha512-lEyVCg2np15tS+dm7+JJTNhNWq9yTZvi3qEhAIIOaofcYlUp0UR5/tVqOwa/gXYr3gjwSZqw+/lS9dscyLelbQ==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/floating-point-hex-parser" "1.7.11"
-    "@webassemblyjs/helper-api-error" "1.7.11"
-    "@webassemblyjs/helper-code-frame" "1.7.11"
-    "@webassemblyjs/helper-fsm" "1.7.11"
-    "@xtuc/long" "4.2.1"
-
-"@webassemblyjs/wast-printer@1.7.11":
-  version "1.7.11"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.7.11.tgz#c4245b6de242cb50a2cc950174fdbf65c78d7813"
-  integrity sha512-m5vkAsuJ32QpkdkDOUPGSltrg8Cuk3KBx4YrmAGQwCZPRdUHXxG4phIOuuycLemHFr74sWL9Wthqss4fzdzSwg==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/wast-parser" "1.7.11"
-    "@xtuc/long" "4.2.1"
+"@webassemblyjs/leb128@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.1.tgz#ce814b45574e93d76bae1fb2644ab9cdd9527aa5"
+  integrity sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==
+  dependencies:
+    "@xtuc/long" "4.2.2"
+
+"@webassemblyjs/utf8@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.1.tgz#d1f8b764369e7c6e6bae350e854dec9a59f0a3ff"
+  integrity sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==
+
+"@webassemblyjs/wasm-edit@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.1.tgz#ad206ebf4bf95a058ce9880a8c092c5dec8193d6"
+  integrity sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.1"
+    "@webassemblyjs/helper-buffer" "1.11.1"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
+    "@webassemblyjs/helper-wasm-section" "1.11.1"
+    "@webassemblyjs/wasm-gen" "1.11.1"
+    "@webassemblyjs/wasm-opt" "1.11.1"
+    "@webassemblyjs/wasm-parser" "1.11.1"
+    "@webassemblyjs/wast-printer" "1.11.1"
+
+"@webassemblyjs/wasm-gen@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.1.tgz#86c5ea304849759b7d88c47a32f4f039ae3c8f76"
+  integrity sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.1"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
+    "@webassemblyjs/ieee754" "1.11.1"
+    "@webassemblyjs/leb128" "1.11.1"
+    "@webassemblyjs/utf8" "1.11.1"
+
+"@webassemblyjs/wasm-opt@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.1.tgz#657b4c2202f4cf3b345f8a4c6461c8c2418985f2"
+  integrity sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.1"
+    "@webassemblyjs/helper-buffer" "1.11.1"
+    "@webassemblyjs/wasm-gen" "1.11.1"
+    "@webassemblyjs/wasm-parser" "1.11.1"
+
+"@webassemblyjs/wasm-parser@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.1.tgz#86ca734534f417e9bd3c67c7a1c75d8be41fb199"
+  integrity sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.1"
+    "@webassemblyjs/helper-api-error" "1.11.1"
+    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
+    "@webassemblyjs/ieee754" "1.11.1"
+    "@webassemblyjs/leb128" "1.11.1"
+    "@webassemblyjs/utf8" "1.11.1"
+
+"@webassemblyjs/wast-printer@1.11.1":
+  version "1.11.1"
+  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.1.tgz#d0c73beda8eec5426f10ae8ef55cee5e7084c2f0"
+  integrity sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==
+  dependencies:
+    "@webassemblyjs/ast" "1.11.1"
+    "@xtuc/long" "4.2.2"
 
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
   integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
 
-"@xtuc/long@4.2.1":
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.1.tgz#5c85d662f76fa1d34575766c5dcd6615abcd30d8"
-  integrity sha512-FZdkNBDqBRHKQ2MEbSC17xnPFOhZxeJ2YGSfr2BKf3sujG49Qe3bB+rGCwQfIaA7WHnGeGkSijX4FuBCdrzW/g==
+"@xtuc/long@4.2.2":
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
+  integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
+
+"@yarn-tool/resolve-package@^1.0.40":
+  version "1.0.46"
+  resolved "https://registry.yarnpkg.com/@yarn-tool/resolve-package/-/resolve-package-1.0.46.tgz#db7354380e5ca7682294af59e5ab0f7fce640ac1"
+  integrity sha512-RJcBGTVywUqYGRtGkPSgJC/ozf0wK/xjUy66tXkbpL35U0o1oef4S0v23euxA/CiukqBWr2fRGtGY6FidESdTg==
+  dependencies:
+    pkg-dir "< 6 >= 5"
+    tslib "^2.3.1"
+    upath2 "^3.1.12"
 
 JSONStream@^1.0.4:
   version "1.3.5"
@@ -1385,16 +1828,6 @@ JSONStream@^1.0.4:
     jsonparse "^1.2.0"
     through ">=2.2.7 <3"
 
-abbrev@1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.1.1.tgz#f8f2c887ad10bf67f634f005b6987fed3179aac8"
-  integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==
-
-abbrev@1.0.x:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/abbrev/-/abbrev-1.0.9.tgz#91b4792588a7738c25f35dd6f63752a2f8776135"
-  integrity sha1-kbR5JYinc4wl813W9jdSovh3YTU=
-
 accepts@~1.3.4:
   version "1.3.5"
   resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.5.tgz#eb777df6011723a3b14e8a72c0805c8e86746bd2"
@@ -1403,94 +1836,67 @@ accepts@~1.3.4:
     mime-types "~2.1.18"
     negotiator "0.6.1"
 
-acorn-dynamic-import@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz#901ceee4c7faaef7e07ad2a47e890675da50a278"
-  integrity sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==
-  dependencies:
-    acorn "^5.0.0"
-
 acorn-dynamic-import@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz#482210140582a36b83c3e342e1cfebcaa9240948"
   integrity sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==
 
+acorn-import-assertions@^1.7.6:
+  version "1.8.0"
+  resolved "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.8.0.tgz#ba2b5939ce62c238db6d93d81c9b111b29b855e9"
+  integrity sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==
+
 acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
   version "5.3.1"
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
   integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==
 
-acorn-walk@^8.0.2:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.0.2.tgz#d4632bfc63fd93d0f15fd05ea0e984ffd3f5a8c3"
-  integrity sha512-+bpA9MJsHdZ4bgfDcpk0ozQyhhVct7rzOmO0s1IIr0AGGgKBljss8n2zp11rRP2wid5VGeh04CgeKzgat5/25A==
-
-acorn@^5.0.0, acorn@^5.6.2:
-  version "5.7.3"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-5.7.3.tgz#67aa231bf8812974b85235a96771eb6bd07ea279"
-  integrity sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==
+acorn-walk@^8.1.1, acorn-walk@^8.2.0:
+  version "8.2.0"
+  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
+  integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
 
 acorn@^6.4.1:
   version "6.4.2"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
   integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
 
-acorn@^7.4.0:
-  version "7.4.1"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
-  integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
-
-acorn@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.1.0.tgz#52311fd7037ae119cbb134309e901aa46295b3fe"
-  integrity sha512-LWCF/Wn0nfHOmJ9rzQApGnxnvgfROzGilS8936rqN/lfcYkY9MYZzdMqN+2NJ4SlTc+m5HiSa+kNfDtI64dwUA==
+acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
+  version "8.7.1"
+  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30"
+  integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==
 
-adm-zip@~0.4.3:
-  version "0.4.13"
-  resolved "https://registry.yarnpkg.com/adm-zip/-/adm-zip-0.4.13.tgz#597e2f8cc3672151e1307d3e95cddbc75672314a"
-  integrity sha512-fERNJX8sOXfel6qCBCMPvZLzENBEhZTzKqg6vrOW5pvoEaQuJhRU4ndTAh6lHOxn1I6jnz2NHra56ZODM751uw==
+add-stream@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/add-stream/-/add-stream-1.0.0.tgz#6a7990437ca736d5e1288db92bd3266d5f5cb2aa"
+  integrity sha1-anmQQ3ynNtXhKI25K9MmbV9csqo=
 
-after@0.8.2:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/after/-/after-0.8.2.tgz#fedb394f9f0e02aa9768e702bda23b505fae7e1f"
-  integrity sha1-/ts5T58OAqqXaOcCvaI7UF+ufh8=
+agent-base@5:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-5.1.1.tgz#e8fb3f242959db44d63be665db7a8e739537a32c"
+  integrity sha512-TMeqbNl2fMW0nMjTEPOwe3J/PRFP4vqeoNuQMG0HlMrtm5QxKqdvAkZ1pRBQ/ulIyDD5Yq0nJ7YbdD8ey0TO3g==
 
-agent-base@2:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-2.1.1.tgz#d6de10d5af6132d5bd692427d46fc538539094c7"
-  integrity sha1-1t4Q1a9hMtW9aSQn1G/FOFOQlMc=
+agent-base@6:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77"
+  integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==
   dependencies:
-    extend "~3.0.0"
-    semver "~5.0.1"
+    debug "4"
 
-agent-base@^4.1.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-4.2.1.tgz#d89e5999f797875674c07d87f260fc41e83e8ca9"
-  integrity sha512-JVwXMr9nHYTUXsBFKUqhJwvlcYU/blreOEUkhNR2eXZIvwd+c+o5V4MgDPKWnMS/56awN3TRzIP+KoPn+roQtg==
+aggregate-error@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a"
+  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
   dependencies:
-    es6-promisify "^5.0.0"
-
-ajv-errors@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ajv-errors/-/ajv-errors-1.0.1.tgz#f35986aceb91afadec4102fbd85014950cefa64d"
-  integrity sha512-DCRfO/4nQ+89p/RK43i8Ezd41EqdGIU4ld7nGF8OQ14oc/we5rEntLCUa7+jrn3nn83BosfwZA0wb4pon2o8iQ==
-
-ajv-keywords@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.2.0.tgz#e86b819c602cf8821ad637413698f1dec021847a"
-  integrity sha1-6GuBnGAs+IIa1jdBNpjx3sAhhHo=
+    clean-stack "^2.0.0"
+    indent-string "^4.0.0"
 
-ajv@^6.1.0, ajv@^6.5.5:
-  version "6.6.2"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.6.2.tgz#caceccf474bf3fc3ce3b147443711a24063cc30d"
-  integrity sha512-FBHEW6Jf5TB9MGBgUUA9XHkTbjXYfAUjY43ACMfmdMRHniyoMHjHjzD50OK8LGDWQwp4rWEsIq5kEqq7rvIM1g==
-  dependencies:
-    fast-deep-equal "^2.0.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
+ajv-keywords@^3.5.2:
+  version "3.5.2"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
+  integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
 
-ajv@^6.10.0, ajv@^6.12.4:
+ajv@^6.10.0, ajv@^6.12.4, ajv@^6.12.5, ajv@^6.12.6:
   version "6.12.6"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
   integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
@@ -1500,40 +1906,39 @@ ajv@^6.10.0, ajv@^6.12.4:
     json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
-ajv@^8.0.1:
-  version "8.0.5"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.0.5.tgz#f07d6fdeffcdbb80485570ce3f1bc845fcc812b9"
-  integrity sha512-RkiLa/AeJx7+9OvniQ/qeWu0w74A8DiPPBclQ6ji3ZQkv5KamO+QGpqmi7O4JIw3rHGUXZ6CoP9tsAkn3gyazg==
+ajv@^6.5.5:
+  version "6.6.2"
+  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.6.2.tgz#caceccf474bf3fc3ce3b147443711a24063cc30d"
+  integrity sha512-FBHEW6Jf5TB9MGBgUUA9XHkTbjXYfAUjY43ACMfmdMRHniyoMHjHjzD50OK8LGDWQwp4rWEsIq5kEqq7rvIM1g==
   dependencies:
-    fast-deep-equal "^3.1.1"
-    json-schema-traverse "^1.0.0"
-    require-from-string "^2.0.2"
+    fast-deep-equal "^2.0.1"
+    fast-json-stable-stringify "^2.0.0"
+    json-schema-traverse "^0.4.1"
     uri-js "^4.2.2"
 
-amdefine@>=0.0.4:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5"
-  integrity sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=
-
-ansi-colors@^3.0.0:
-  version "3.2.3"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-3.2.3.tgz#57d35b8686e851e2cc04c403f1c00203976a1813"
-  integrity sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==
+ansi-align@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59"
+  integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==
+  dependencies:
+    string-width "^4.1.0"
 
-ansi-colors@^4.1.1:
+ansi-colors@4.1.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
   integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
 
-ansi-escapes@^1.1.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-1.4.0.tgz#d3a8a83b319aa67793662b13e761c7911422306e"
-  integrity sha1-06ioOzGapneTZisT52HHkRQiMG4=
+ansi-escapes@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
+  integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
 
-ansi-escapes@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.1.0.tgz#f73207bb81207d75fd6c83f125af26eea378ca30"
-  integrity sha512-UgAb8H9D41AQnu/PbWlCofQVcnV4Gs2bBJi9eZPxfU/hgglFh3SMDMENRIqdr7H6XFnXdoknctFByVsCOotTVw==
+ansi-escapes@^4.3.0:
+  version "4.3.2"
+  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
+  integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
+  dependencies:
+    type-fest "^0.21.3"
 
 ansi-regex@^2.0.0:
   version "2.1.1"
@@ -1545,17 +1950,32 @@ ansi-regex@^3.0.0:
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998"
   integrity sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=
 
+ansi-regex@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.1.tgz#164daac87ab2d6f6db3a29875e2d1766582dabed"
+  integrity sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==
+
 ansi-regex@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75"
   integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==
 
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
+ansi-regex@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
+  integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
+
 ansi-styles@^2.2.1:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
   integrity sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=
 
-ansi-styles@^3.2.0, ansi-styles@^3.2.1:
+ansi-styles@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
   integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
@@ -1569,31 +1989,59 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   dependencies:
     color-convert "^2.0.1"
 
-any-observable@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/any-observable/-/any-observable-0.3.0.tgz#af933475e5806a67d0d7df090dd5e8bef65d119b"
-  integrity sha512-/FQM1EDkTsf63Ub2C6O7GuYFDsSXUwsaZDurV0np41ocwq0jthUAYCmhBX9f+KwlaCgIuWyr/4WlUQUBfKfZog==
+ansi-styles@^6.0.0:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.1.0.tgz#87313c102b8118abd57371afab34618bf7350ed3"
+  integrity sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ==
 
-anymatch@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-2.0.0.tgz#bcb24b4f37934d9aa7ac17b4adaf89e7c76ef2eb"
-  integrity sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==
+anymatch@~3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716"
+  integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==
   dependencies:
-    micromatch "^3.1.4"
-    normalize-path "^2.1.1"
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
 
-aproba@^1.0.3, aproba@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/aproba/-/aproba-1.2.0.tgz#6802e6264efd18c790a1b0d517f0f2627bf2c94a"
-  integrity sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==
+arch@^2.1.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/arch/-/arch-2.2.0.tgz#1bc47818f305764f23ab3306b0bfc086c5a29d11"
+  integrity sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ==
+
+archive-type@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/archive-type/-/archive-type-4.0.0.tgz#f92e72233056dfc6969472749c267bdb046b1d70"
+  integrity sha1-+S5yIzBW38aWlHJ0nCZ72wRrHXA=
+  dependencies:
+    file-type "^4.2.0"
+
+archiver-utils@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/archiver-utils/-/archiver-utils-2.1.0.tgz#e8a460e94b693c3e3da182a098ca6285ba9249e2"
+  integrity sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==
+  dependencies:
+    glob "^7.1.4"
+    graceful-fs "^4.2.0"
+    lazystream "^1.0.0"
+    lodash.defaults "^4.2.0"
+    lodash.difference "^4.5.0"
+    lodash.flatten "^4.4.0"
+    lodash.isplainobject "^4.0.6"
+    lodash.union "^4.6.0"
+    normalize-path "^3.0.0"
+    readable-stream "^2.0.0"
 
-are-we-there-yet@~1.1.2:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/are-we-there-yet/-/are-we-there-yet-1.1.5.tgz#4b35c2944f062a8bfcda66410760350fe9ddfc21"
-  integrity sha512-5hYdAkZlcG8tOLujVDTgCT+uPX0VnpAH28gWsLfzpXYm7wP6mp5Q/gYyR7YQ0cKVJcXJnl3j2kpBan13PtQf6w==
+archiver@^5.0.0:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/archiver/-/archiver-5.3.1.tgz#21e92811d6f09ecfce649fbefefe8c79e57cbbb6"
+  integrity sha512-8KyabkmbYrH+9ibcTScQ1xCJC/CGcugdVIwB+53f5sZziXgwUh3iXlAlANMxcZyDEfTHMe6+Z5FofV8nopXP7w==
   dependencies:
-    delegates "^1.0.0"
-    readable-stream "^2.0.6"
+    archiver-utils "^2.1.0"
+    async "^3.2.3"
+    buffer-crc32 "^0.2.1"
+    readable-stream "^3.6.0"
+    readdir-glob "^1.0.0"
+    tar-stream "^2.2.0"
+    zip-stream "^4.1.0"
 
 arg@^4.1.0:
   version "4.1.3"
@@ -1607,94 +2055,31 @@ argparse@^1.0.7:
   dependencies:
     sprintf-js "~1.0.2"
 
-argv@^0.0.2:
+argparse@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
+  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
+
+argv@0.0.2:
   version "0.0.2"
   resolved "https://registry.yarnpkg.com/argv/-/argv-0.0.2.tgz#ecbd16f8949b157183711b1bda334f37840185ab"
   integrity sha1-7L0W+JSbFXGDcRsb2jNPN4QBhas=
 
-arr-diff@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf"
-  integrity sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=
-  dependencies:
-    arr-flatten "^1.0.1"
-
-arr-diff@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
-  integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=
-
-arr-flatten@^1.0.1, arr-flatten@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
-  integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
-
-arr-union@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
-  integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
-
-array-find-index@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1"
-  integrity sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E=
-
 array-ify@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
   integrity sha1-nlKHYrSpBmrRY6aWKjZEGOlibs4=
 
-array-slice@^0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/array-slice/-/array-slice-0.2.3.tgz#dd3cfb80ed7973a75117cdac69b0b99ec86186f5"
-  integrity sha1-3Tz7gO15c6dRF82sabC5nshhhvU=
-
-array-union@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39"
-  integrity sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=
-  dependencies:
-    array-uniq "^1.0.1"
-
 array-union@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
   integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
 
-array-uniq@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6"
-  integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=
-
-array-unique@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53"
-  integrity sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=
-
-array-unique@^0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
-  integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
-
-arraybuffer.slice@~0.0.7:
-  version "0.0.7"
-  resolved "https://registry.yarnpkg.com/arraybuffer.slice/-/arraybuffer.slice-0.0.7.tgz#3bbc4275dd584cc1b10809b89d4e8b63a69e7675"
-  integrity sha512-wGUIVQXuehL5TCqQun8OW81jGzAWycqzFF8lFp+GOM5BXLYj3bKNsYC4daB7n6XjCqxQA/qgTJ+8ANR3acjrog==
-
 arrify@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
   integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=
 
-asn1.js@^4.0.0:
-  version "4.10.1"
-  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-4.10.1.tgz#b9c2bf5805f1e64aadeed6df3a2bfafb5a73f5a0"
-  integrity sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==
-  dependencies:
-    bn.js "^4.0.0"
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-
 asn1@~0.2.3:
   version "0.2.4"
   resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136"
@@ -1707,55 +2092,16 @@ assert-plus@1.0.0, assert-plus@^1.0.0:
   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 
-assert@^1.1.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/assert/-/assert-1.4.1.tgz#99912d591836b5a6f5b345c0f07eefc08fc65d91"
-  integrity sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=
-  dependencies:
-    util "0.10.3"
-
-assertion-error@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.0.0.tgz#c7f85438fdd466bc7ca16ab90c81513797a5d23b"
-  integrity sha1-x/hUOP3UZrx8oWq5DIFRN5el0js=
-
-assign-symbols@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
-  integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=
-
-ast-types@0.x.x:
-  version "0.11.7"
-  resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.11.7.tgz#f318bf44e339db6a320be0009ded64ec1471f46c"
-  integrity sha512-2mP3TwtkY/aTv5X3ZsMpNAbOnyoC/aMJwJSoaELPkHId0nSQgFcnU4dRW3isxiz7+zBexk0ym3WNVjMiQBnJSw==
+assertion-error@1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b"
+  integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==
 
 astral-regex@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
   integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
 
-async-each@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/async-each/-/async-each-1.0.1.tgz#19d386a1d9edc6e7c1c85d388aedbcc56d33602d"
-  integrity sha1-GdOGodntxufByF04iu28xW0zYC0=
-
-async-limiter@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/async-limiter/-/async-limiter-1.0.0.tgz#78faed8c3d074ab81f22b4e985d79e8738f720f8"
-  integrity sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg==
-
-async@1.x:
-  version "1.5.2"
-  resolved "https://registry.yarnpkg.com/async/-/async-1.5.2.tgz#ec6a61ae56480c0c3cb241c95618e20892f9672a"
-  integrity sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=
-
-async@^2.0.0, async@^2.1.2:
-  version "2.6.1"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.1.tgz#b245a23ca71930044ec53fa46aa00a3e87c6a610"
-  integrity sha512-fNEiL2+AZt6AlAw/29Cr0UDe4sRAHCpEHh54WMz+Bb7QfNcFw4h3loofyJpLeQs4Yx7yuqu/2dLgM5hKOs6HlQ==
-  dependencies:
-    lodash "^4.17.10"
-
 async@^2.6.2:
   version "2.6.3"
   resolved "https://registry.yarnpkg.com/async/-/async-2.6.3.tgz#d72625e2344a3656e3a3ad4fa749fa83299d82ff"
@@ -1763,12 +2109,22 @@ async@^2.6.2:
   dependencies:
     lodash "^4.17.14"
 
+async@^3.2.3:
+  version "3.2.3"
+  resolved "https://registry.yarnpkg.com/async/-/async-3.2.3.tgz#ac53dafd3f4720ee9e8a160628f18ea91df196c9"
+  integrity sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g==
+
 asynckit@^0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
   integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
 
-atob@^2.1.1:
+at-least-node@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
+  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
+
+atob@^2.1.1, atob@^2.1.2:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
@@ -1783,6 +2139,13 @@ aws4@^1.8.0:
   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.8.0.tgz#f0e003d9ca9e7f59c7a508945d7b2ef9a04a542f"
   integrity sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==
 
+axios@^0.24.0:
+  version "0.24.0"
+  resolved "https://registry.yarnpkg.com/axios/-/axios-0.24.0.tgz#804e6fa1e4b9c5288501dd9dff56a7a0940d20d6"
+  integrity sha512-Q6cWsys88HoPgAaFAVUb0WpPk0O8iTeisR9IMqy9G8AbO4NlpVknrnQS03zzF9PGAWgO3cgletO3VjV/P7VztA==
+  dependencies:
+    follow-redirects "^1.14.4"
+
 babel-code-frame@^6.26.0:
   version "6.26.0"
   resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
@@ -1792,17 +2155,17 @@ babel-code-frame@^6.26.0:
     esutils "^2.0.2"
     js-tokens "^3.0.2"
 
-babel-eslint@^10.0.1:
-  version "10.0.1"
-  resolved "https://registry.yarnpkg.com/babel-eslint/-/babel-eslint-10.0.1.tgz#919681dc099614cd7d31d45c8908695092a1faed"
-  integrity sha512-z7OT1iNV+TjOwHNLLyJk+HN+YVWX+CLE6fPD2SymJZOZQBs+QIexFjhm4keGTm8MW9xr4EC9Q0PbaLB24V5GoQ==
+babel-eslint@^10.1.0:
+  version "10.1.0"
+  resolved "https://registry.yarnpkg.com/babel-eslint/-/babel-eslint-10.1.0.tgz#6968e568a910b78fb3779cdd8b6ac2f479943232"
+  integrity sha512-ifWaTHQ0ce+448CYop8AdrQiBsGrnC+bMgfyKFdi6EsPLTAWG+QfyDeM6OH+FmWnKvEq5NnBMLvlBUPKQZoDSg==
   dependencies:
     "@babel/code-frame" "^7.0.0"
-    "@babel/parser" "^7.0.0"
-    "@babel/traverse" "^7.0.0"
-    "@babel/types" "^7.0.0"
-    eslint-scope "3.7.1"
+    "@babel/parser" "^7.7.0"
+    "@babel/traverse" "^7.7.0"
+    "@babel/types" "^7.7.0"
     eslint-visitor-keys "^1.0.0"
+    resolve "^1.12.0"
 
 babel-helper-function-name@^6.24.1:
   version "6.24.1"
@@ -1828,15 +2191,15 @@ babel-helper-vue-jsx-merge-props@^2.0.3:
   resolved "https://registry.yarnpkg.com/babel-helper-vue-jsx-merge-props/-/babel-helper-vue-jsx-merge-props-2.0.3.tgz#22aebd3b33902328e513293a8e4992b384f9f1b6"
   integrity sha512-gsLiKK7Qrb7zYJNgiXKpXblxbV5ffSwR0f5whkPAaBAR4fhi6bwRZxX9wBlIc5M/v8CCkXUbXZL4N/nSE97cqg==
 
-babel-loader@^8.0.4:
-  version "8.0.5"
-  resolved "https://registry.yarnpkg.com/babel-loader/-/babel-loader-8.0.5.tgz#225322d7509c2157655840bba52e46b6c2f2fe33"
-  integrity sha512-NTnHnVRd2JnRqPC0vW+iOQWU5pchDbYXsG2E6DMXEpMfUcQKclF9gmf3G3ZMhzG7IG9ji4coL0cm+FxeWxDpnw==
+babel-loader@^8.2.5:
+  version "8.2.5"
+  resolved "https://registry.yarnpkg.com/babel-loader/-/babel-loader-8.2.5.tgz#d45f585e654d5a5d90f5350a779d7647c5ed512e"
+  integrity sha512-OSiFfH89LrEMiWd4pLNqGz4CwJDtbs2ZVc+iGu2HrkRfPxId9F2anQj38IxWpmRfsUY0aBZYi1EFcd3mhtRMLQ==
   dependencies:
-    find-cache-dir "^2.0.0"
-    loader-utils "^1.0.2"
-    mkdirp "^0.5.1"
-    util.promisify "^1.0.0"
+    find-cache-dir "^3.3.1"
+    loader-utils "^2.0.0"
+    make-dir "^3.1.0"
+    schema-utils "^2.6.5"
 
 babel-messages@^6.23.0:
   version "6.23.0"
@@ -1852,38 +2215,40 @@ babel-plugin-dynamic-import-node@^2.3.3:
   dependencies:
     object.assign "^4.1.0"
 
-babel-plugin-istanbul@^5.1.0:
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-5.1.0.tgz#6892f529eff65a3e2d33d87dc5888ffa2ecd4a30"
-  integrity sha512-CLoXPRSUWiR8yao8bShqZUIC6qLfZVVY3X1wj+QPNXu0wfmrRRfarh1LYy+dYMVI+bDj0ghy3tuqFFRFZmL1Nw==
+babel-plugin-istanbul@^6.1.1:
+  version "6.1.1"
+  resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73"
+  integrity sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==
   dependencies:
-    find-up "^3.0.0"
-    istanbul-lib-instrument "^3.0.0"
-    test-exclude "^5.0.0"
+    "@babel/helper-plugin-utils" "^7.0.0"
+    "@istanbuljs/load-nyc-config" "^1.0.0"
+    "@istanbuljs/schema" "^0.1.2"
+    istanbul-lib-instrument "^5.0.4"
+    test-exclude "^6.0.0"
 
-babel-plugin-polyfill-corejs2@^0.1.4:
-  version "0.1.10"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.1.10.tgz#a2c5c245f56c0cac3dbddbf0726a46b24f0f81d1"
-  integrity sha512-DO95wD4g0A8KRaHKi0D51NdGXzvpqVLnLu5BTvDlpqUEpTmeEtypgC1xqesORaWmiUOQI14UHKlzNd9iZ2G3ZA==
+babel-plugin-polyfill-corejs2@^0.3.0:
+  version "0.3.1"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.3.1.tgz#440f1b70ccfaabc6b676d196239b138f8a2cfba5"
+  integrity sha512-v7/T6EQcNfVLfcN2X8Lulb7DjprieyLWJK/zOWH5DUYcAgex9sP3h25Q+DLsX9TloXe3y1O8l2q2Jv9q8UVB9w==
   dependencies:
-    "@babel/compat-data" "^7.13.0"
-    "@babel/helper-define-polyfill-provider" "^0.1.5"
+    "@babel/compat-data" "^7.13.11"
+    "@babel/helper-define-polyfill-provider" "^0.3.1"
     semver "^6.1.1"
 
-babel-plugin-polyfill-corejs3@^0.1.3:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.1.7.tgz#80449d9d6f2274912e05d9e182b54816904befd0"
-  integrity sha512-u+gbS9bbPhZWEeyy1oR/YaaSpod/KDT07arZHb80aTpl8H5ZBq+uN1nN9/xtX7jQyfLdPfoqI4Rue/MQSWJquw==
+babel-plugin-polyfill-corejs3@^0.5.0:
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.5.2.tgz#aabe4b2fa04a6e038b688c5e55d44e78cd3a5f72"
+  integrity sha512-G3uJih0XWiID451fpeFaYGVuxHEjzKTHtc9uGFEjR6hHrvNzeS/PX+LLLcetJcytsB5m4j+K3o/EpXJNb/5IEQ==
   dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.1.5"
-    core-js-compat "^3.8.1"
+    "@babel/helper-define-polyfill-provider" "^0.3.1"
+    core-js-compat "^3.21.0"
 
-babel-plugin-polyfill-regenerator@^0.1.2:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.1.6.tgz#0fe06a026fe0faa628ccc8ba3302da0a6ce02f3f"
-  integrity sha512-OUrYG9iKPKz8NxswXbRAdSwF0GhRdIEMTloQATJi4bDuFqrXaXcCUT/VGNrr8pBcjMh1RxZ7Xt9cytVJTJfvMg==
+babel-plugin-polyfill-regenerator@^0.3.0:
+  version "0.3.1"
+  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.3.1.tgz#2c0678ea47c75c8cc2fbb1852278d8fb68233990"
+  integrity sha512-Y2B06tvgHYt1x0yz17jGkGeeMr5FeKUu+ASJ+N6nB5lQ8Dapfg42i0OVrf8PNGJ3zKL4A23snMi1IRwrqqND7A==
   dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.1.5"
+    "@babel/helper-define-polyfill-provider" "^0.3.1"
 
 babel-plugin-syntax-class-properties@^6.8.0:
   version "6.13.0"
@@ -1920,15 +2285,6 @@ babel-plugin-transform-vue-jsx@^4.0.1:
   dependencies:
     esutils "^2.0.2"
 
-babel-polyfill@6.23.0:
-  version "6.23.0"
-  resolved "https://registry.yarnpkg.com/babel-polyfill/-/babel-polyfill-6.23.0.tgz#8364ca62df8eafb830499f699177466c3b03499d"
-  integrity sha1-g2TKYt+Or7gwSZ9pkXdGbDsDSZ0=
-  dependencies:
-    babel-runtime "^6.22.0"
-    core-js "^2.4.0"
-    regenerator-runtime "^0.10.0"
-
 babel-preset-flow-vue@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/babel-preset-flow-vue/-/babel-preset-flow-vue-1.0.0.tgz#bd28eb64b53d65f9c47262b32ce6c6033fe70671"
@@ -1987,48 +2343,27 @@ babylon@^6.18.0:
   resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3"
   integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==
 
-backo2@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/backo2/-/backo2-1.0.2.tgz#31ab1ac8b129363463e35b3ebb69f4dfcfba7947"
-  integrity sha1-MasayLEpNjRj41s+u2n038+6eUc=
-
 balanced-match@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
   integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c=
 
-base64-arraybuffer@0.1.5:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/base64-arraybuffer/-/base64-arraybuffer-0.1.5.tgz#73926771923b5a19747ad666aa5cd4bf9c6e9ce8"
-  integrity sha1-c5JncZI7Whl0etZmqlzUv5xunOg=
+base64-js@^1.3.1:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
+  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
 
-base64-js@^1.0.2:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.3.0.tgz#cab1e6118f051095e58b5281aea8c1cd22bfc0e3"
-  integrity sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==
+base64id@2.0.0, base64id@~2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/base64id/-/base64id-2.0.0.tgz#2770ac6bc47d312af97a8bf9a634342e0cd25cb6"
+  integrity sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==
 
-base64id@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/base64id/-/base64id-1.0.0.tgz#47688cb99bb6804f0e06d3e763b1c32e57d8e6b6"
-  integrity sha1-R2iMuZu2gE8OBtPnY7HDLlfY5rY=
-
-base@^0.11.1:
-  version "0.11.2"
-  resolved "https://registry.yarnpkg.com/base/-/base-0.11.2.tgz#7bde5ced145b6d551a90db87f83c558b4eb48a8f"
-  integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==
-  dependencies:
-    cache-base "^1.0.1"
-    class-utils "^0.3.5"
-    component-emitter "^1.2.1"
-    define-property "^1.0.0"
-    isobject "^3.0.1"
-    mixin-deep "^1.2.0"
-    pascalcase "^0.1.1"
-
-basic-auth@^1.0.3:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/basic-auth/-/basic-auth-1.1.0.tgz#45221ee429f7ee1e5035be3f51533f1cdfd29884"
-  integrity sha1-RSIe5Cn37h5QNb4/UVM/HN/SmIQ=
+basic-auth@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/basic-auth/-/basic-auth-2.0.1.tgz#b998279bf47ce38344b4f3cf916d4679bbf51e3a"
+  integrity sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==
+  dependencies:
+    safe-buffer "5.1.2"
 
 bcrypt-pbkdf@^1.0.0:
   version "1.0.2"
@@ -2037,55 +2372,108 @@ bcrypt-pbkdf@^1.0.0:
   dependencies:
     tweetnacl "^0.14.3"
 
-better-assert@~1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/better-assert/-/better-assert-1.0.2.tgz#40866b9e1b9e0b55b481894311e68faffaebc522"
-  integrity sha1-QIZrnhueC1W0gYlDEeaPr/rrxSI=
-  dependencies:
-    callsite "1.0.0"
-
 big.js@^5.2.2:
   version "5.2.2"
   resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
   integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
 
-binary-extensions@^1.0.0:
-  version "1.12.0"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-1.12.0.tgz#c2d780f53d45bba8317a8902d4ceeaf3a6385b14"
-  integrity sha512-DYWGk01lDcxeS/K9IHPGWfT8PsJmbXRtRd2Sx72Tnb8pcYZQFF1oSDb8hJtS1vhp212q1Rzi5dUf9+nq0o9UIg==
+bin-check@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/bin-check/-/bin-check-4.1.0.tgz#fc495970bdc88bb1d5a35fc17e65c4a149fc4a49"
+  integrity sha512-b6weQyEUKsDGFlACWSIOfveEnImkJyK/FGW6FAG42loyoquvjdtOIqO6yBFzHyqyVVhNgNkQxxx09SFLK28YnA==
+  dependencies:
+    execa "^0.7.0"
+    executable "^4.1.0"
+
+bin-version-check@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/bin-version-check/-/bin-version-check-4.0.0.tgz#7d819c62496991f80d893e6e02a3032361608f71"
+  integrity sha512-sR631OrhC+1f8Cvs8WyVWOA33Y8tgwjETNPyyD/myRBXLkfS/vl74FmH/lFcRl9KY3zwGh7jFhvyk9vV3/3ilQ==
+  dependencies:
+    bin-version "^3.0.0"
+    semver "^5.6.0"
+    semver-truncate "^1.1.2"
 
-blob@0.0.5:
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/blob/-/blob-0.0.5.tgz#d680eeef25f8cd91ad533f5b01eed48e64caf683"
-  integrity sha512-gaqbzQPqOoamawKg0LGVd7SzLgXS+JH61oWprSLH+P+abTczqJbhTR8CmJ2u9/bUYNmHTGJx/UEmn6doAvvuig==
+bin-version@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/bin-version/-/bin-version-3.1.0.tgz#5b09eb280752b1bd28f0c9db3f96f2f43b6c0839"
+  integrity sha512-Mkfm4iE1VFt4xd4vH+gx+0/71esbfus2LsnCGe8Pi4mndSPyT+NGES/Eg99jx8/lUGWfu3z2yuB/bt5UB+iVbQ==
+  dependencies:
+    execa "^1.0.0"
+    find-versions "^3.0.0"
 
-bluebird@^3.3.0, bluebird@^3.5.3:
-  version "3.5.3"
-  resolved "https://registry.yarnpkg.com/bluebird/-/bluebird-3.5.3.tgz#7d01c6f9616c9a51ab0f8c549a79dfe6ec33efa7"
-  integrity sha512-/qKPUQlaW1OyR51WeCPBvRnAlnZFUJkCSG5HzGnuIqhgyJtF+T94lFnn33eiazjRm2LAHVy2guNnaq48X9SJuw==
+bin-wrapper@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/bin-wrapper/-/bin-wrapper-4.1.0.tgz#99348f2cf85031e3ef7efce7e5300aeaae960605"
+  integrity sha512-hfRmo7hWIXPkbpi0ZltboCMVrU+0ClXR/JgbCKKjlDjQf6igXa7OwdqNcFWQZPZTgiY7ZpzE3+LjjkLiTN2T7Q==
+  dependencies:
+    bin-check "^4.1.0"
+    bin-version-check "^4.0.0"
+    download "^7.1.0"
+    import-lazy "^3.1.0"
+    os-filter-obj "^2.0.0"
+    pify "^4.0.1"
+
+binary-extensions@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d"
+  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
+
+bl@^1.0.0:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/bl/-/bl-1.2.3.tgz#1e8dd80142eac80d7158c9dccc047fb620e035e7"
+  integrity sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==
+  dependencies:
+    readable-stream "^2.3.5"
+    safe-buffer "^5.1.1"
 
-bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.1.1, bn.js@^4.11.9:
-  version "4.12.0"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
-  integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
+bl@^4.0.3, bl@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
+  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
+  dependencies:
+    buffer "^5.5.0"
+    inherits "^2.0.4"
+    readable-stream "^3.4.0"
 
-body-parser@^1.16.1:
-  version "1.18.3"
-  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.18.3.tgz#5b292198ffdd553b3a0f20ded0592b956955c8b4"
-  integrity sha1-WykhmP/dVTs6DyDe0FkrlWlVyLQ=
+body-parser@^1.19.0:
+  version "1.20.0"
+  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.0.tgz#3de69bd89011c11573d7bfee6a64f11b6bd27cc5"
+  integrity sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg==
   dependencies:
-    bytes "3.0.0"
+    bytes "3.1.2"
     content-type "~1.0.4"
     debug "2.6.9"
-    depd "~1.1.2"
-    http-errors "~1.6.3"
-    iconv-lite "0.4.23"
-    on-finished "~2.3.0"
-    qs "6.5.2"
-    raw-body "2.3.3"
-    type-is "~1.6.16"
+    depd "2.0.0"
+    destroy "1.2.0"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
+    on-finished "2.4.1"
+    qs "6.10.3"
+    raw-body "2.5.1"
+    type-is "~1.6.18"
+    unpipe "1.0.0"
+
+boolean@^3.0.1:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/boolean/-/boolean-3.2.0.tgz#9e5294af4e98314494cbb17979fa54ca159f116b"
+  integrity sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==
+
+boxen@5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/boxen/-/boxen-5.1.2.tgz#788cb686fc83c1f486dfa8a40c68fc2b831d2b50"
+  integrity sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==
+  dependencies:
+    ansi-align "^3.0.0"
+    camelcase "^6.2.0"
+    chalk "^4.1.0"
+    cli-boxes "^2.2.1"
+    string-width "^4.2.2"
+    type-fest "^0.20.2"
+    widest-line "^3.1.0"
+    wrap-ansi "^7.0.0"
 
-brace-expansion@^1.0.0, brace-expansion@^1.1.7:
+brace-expansion@^1.1.7:
   version "1.1.11"
   resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
   integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
@@ -2093,115 +2481,19 @@ brace-expansion@^1.0.0, brace-expansion@^1.1.7:
     balanced-match "^1.0.0"
     concat-map "0.0.1"
 
-braces@^0.1.2:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-0.1.5.tgz#c085711085291d8b75fdd74eab0f8597280711e6"
-  integrity sha1-wIVxEIUpHYt1/ddOqw+FlygHEeY=
-  dependencies:
-    expand-range "^0.1.0"
-
-braces@^1.8.2:
-  version "1.8.5"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7"
-  integrity sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=
-  dependencies:
-    expand-range "^1.8.1"
-    preserve "^0.2.0"
-    repeat-element "^1.1.2"
-
-braces@^2.3.0, braces@^2.3.1:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-2.3.2.tgz#5979fd3f14cd531565e5fa2df1abfff1dfaee729"
-  integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==
-  dependencies:
-    arr-flatten "^1.1.0"
-    array-unique "^0.3.2"
-    extend-shallow "^2.0.1"
-    fill-range "^4.0.0"
-    isobject "^3.0.1"
-    repeat-element "^1.1.2"
-    snapdragon "^0.8.1"
-    snapdragon-node "^2.0.1"
-    split-string "^3.0.2"
-    to-regex "^3.0.1"
-
-braces@^3.0.1:
+braces@^3.0.1, braces@^3.0.2, braces@~3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
   integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
   dependencies:
     fill-range "^7.0.1"
 
-brorand@^1.0.1, brorand@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
-  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
-
-browser-stdout@1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.0.tgz#f351d32969d32fa5d7a5567154263d928ae3bd1f"
-  integrity sha1-81HTKWnTL6XXpVZxVCY9korjvR8=
-
-browserify-aes@^1.0.0, browserify-aes@^1.0.4:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
-  integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
-  dependencies:
-    buffer-xor "^1.0.3"
-    cipher-base "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.3"
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-browserify-cipher@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.1.tgz#8d6474c1b870bfdabcd3bcfcc1934a10e94f15f0"
-  integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==
-  dependencies:
-    browserify-aes "^1.0.4"
-    browserify-des "^1.0.0"
-    evp_bytestokey "^1.0.0"
-
-browserify-des@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.2.tgz#3af4f1f59839403572f1c66204375f7a7f703e9c"
-  integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==
-  dependencies:
-    cipher-base "^1.0.1"
-    des.js "^1.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
-
-browserify-rsa@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.0.1.tgz#21e0abfaf6f2029cf2fafb133567a701d4135524"
-  integrity sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=
-  dependencies:
-    bn.js "^4.1.0"
-    randombytes "^2.0.1"
-
-browserify-sign@^4.0.0:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.0.4.tgz#aa4eb68e5d7b658baa6bf6a57e630cbd7a93d298"
-  integrity sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=
-  dependencies:
-    bn.js "^4.1.1"
-    browserify-rsa "^4.0.0"
-    create-hash "^1.1.0"
-    create-hmac "^1.1.2"
-    elliptic "^6.0.0"
-    inherits "^2.0.1"
-    parse-asn1 "^5.0.0"
-
-browserify-zlib@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f"
-  integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==
-  dependencies:
-    pako "~1.0.5"
+browser-stdout@1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
+  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
 
-browserslist@^4.14.5, browserslist@^4.16.3:
+browserslist@^4.14.5:
   version "4.16.3"
   resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.3.tgz#340aa46940d7db878748567c5dea24a48ddf3717"
   integrity sha512-vIyhWmIkULaq04Gt93txdh+j02yX/JzlyhLYbV3YQCn/zvES3JnY7TifHHvvr1w5hTDluNKMkV05cs4vy8Q7sw==
@@ -2212,6 +2504,17 @@ browserslist@^4.14.5, browserslist@^4.16.3:
     escalade "^3.1.1"
     node-releases "^1.1.70"
 
+browserslist@^4.20.2, browserslist@^4.20.3:
+  version "4.20.3"
+  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.20.3.tgz#eb7572f49ec430e054f56d52ff0ebe9be915f8bf"
+  integrity sha512-NBhymBQl1zM0Y5dQT/O+xiLP9/rzOIQdKM/eMJBAq7yBgaB6krIYLGejrwVYnSHZdqjscB1SPuAjHwxjvN6Wdg==
+  dependencies:
+    caniuse-lite "^1.0.30001332"
+    electron-to-chromium "^1.4.118"
+    escalade "^3.1.1"
+    node-releases "^2.0.3"
+    picocolors "^1.0.0"
+
 buble@^0.20.0:
   version "0.20.0"
   resolved "https://registry.yarnpkg.com/buble/-/buble-0.20.0.tgz#a143979a8d968b7f76b57f38f2e7ce7cfe938d1f"
@@ -2238,6 +2541,11 @@ buffer-alloc@^1.2.0:
     buffer-alloc-unsafe "^1.1.0"
     buffer-fill "^1.0.0"
 
+buffer-crc32@^0.2.1, buffer-crc32@^0.2.13, buffer-crc32@~0.2.3:
+  version "0.2.13"
+  resolved "https://registry.yarnpkg.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz#0d333e3f00eac50aa1454abd30ef8c2a5d9a7242"
+  integrity sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=
+
 buffer-fill@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/buffer-fill/-/buffer-fill-1.0.0.tgz#f8f78b76789888ef39f205cd637f68e702122b2c"
@@ -2248,19 +2556,13 @@ buffer-from@^1.0.0:
   resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
   integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
 
-buffer-xor@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
-  integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=
-
-buffer@^4.3.0:
-  version "4.9.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.1.tgz#6d1bb601b07a4efced97094132093027c95bc298"
-  integrity sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=
+buffer@^5.2.1, buffer@^5.5.0:
+  version "5.7.1"
+  resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
+  integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
   dependencies:
-    base64-js "^1.0.2"
-    ieee754 "^1.1.4"
-    isarray "^1.0.0"
+    base64-js "^1.3.1"
+    ieee754 "^1.1.13"
 
 builtin-modules@^1.0.0:
   version "1.1.1"
@@ -2272,57 +2574,46 @@ builtin-modules@^3.1.0:
   resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
   integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
 
-builtin-status-codes@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
-  integrity sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=
-
-bytes@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.0.0.tgz#d32815404d689699f85a4ea4fa8755dd13a96048"
-  integrity sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=
+bytes@3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
+  integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
 
-cacache@^11.0.2:
-  version "11.3.2"
-  resolved "https://registry.yarnpkg.com/cacache/-/cacache-11.3.2.tgz#2d81e308e3d258ca38125b676b98b2ac9ce69bfa"
-  integrity sha512-E0zP4EPGDOaT2chM08Als91eYnf8Z+eH1awwwVsngUmgppfM5jjJ8l3z5vO5p5w/I3LsiXawb1sW0VY65pQABg==
-  dependencies:
-    bluebird "^3.5.3"
-    chownr "^1.1.1"
-    figgy-pudding "^3.5.1"
-    glob "^7.1.3"
-    graceful-fs "^4.1.15"
-    lru-cache "^5.1.1"
-    mississippi "^3.0.0"
-    mkdirp "^0.5.1"
-    move-concurrently "^1.0.1"
-    promise-inflight "^1.0.1"
-    rimraf "^2.6.2"
-    ssri "^6.0.1"
-    unique-filename "^1.1.1"
-    y18n "^4.0.0"
-
-cache-base@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/cache-base/-/cache-base-1.0.1.tgz#0a7f46416831c8b662ee36fe4e7c59d76f666ab2"
-  integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==
-  dependencies:
-    collection-visit "^1.0.0"
-    component-emitter "^1.2.1"
-    get-value "^2.0.6"
-    has-value "^1.0.0"
-    isobject "^3.0.1"
-    set-value "^2.0.0"
-    to-object-path "^0.3.0"
-    union-value "^1.0.0"
-    unset-value "^1.0.0"
+cacheable-lookup@^5.0.3:
+  version "5.0.4"
+  resolved "https://registry.yarnpkg.com/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz#5a6b865b2c44357be3d5ebc2a467b032719a7005"
+  integrity sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==
 
-cachedir@^1.1.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-1.3.0.tgz#5e01928bf2d95b5edd94b0942188246740e0dbc4"
-  integrity sha512-O1ji32oyON9laVPJL1IZ5bmwd2cB46VfpxkDequezH+15FDzzVddEyrGEeX4WusDSqKxdyFdDQDEG1yo1GoWkg==
-  dependencies:
-    os-homedir "^1.0.1"
+cacheable-request@^2.1.1:
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-2.1.4.tgz#0d808801b6342ad33c91df9d0b44dc09b91e5c3d"
+  integrity sha1-DYCIAbY0KtM8kd+dC0TcCbkeXD0=
+  dependencies:
+    clone-response "1.0.2"
+    get-stream "3.0.0"
+    http-cache-semantics "3.8.1"
+    keyv "3.0.0"
+    lowercase-keys "1.0.0"
+    normalize-url "2.0.1"
+    responselike "1.0.2"
+
+cacheable-request@^7.0.2:
+  version "7.0.2"
+  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-7.0.2.tgz#ea0d0b889364a25854757301ca12b2da77f91d27"
+  integrity sha512-pouW8/FmiPQbuGpkXQ9BAPv/Mo5xDGANgSNXzTzJ8DrKGuXOssM4wIQRjfanNRh3Yu5cfYPvcorqbhg2KIJtew==
+  dependencies:
+    clone-response "^1.0.2"
+    get-stream "^5.1.0"
+    http-cache-semantics "^4.0.0"
+    keyv "^4.0.0"
+    lowercase-keys "^2.0.0"
+    normalize-url "^6.0.1"
+    responselike "^2.0.0"
+
+cachedir@2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-2.2.0.tgz#19afa4305e05d79e417566882e0c8f960f62ff0e"
+  integrity sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==
 
 call-bind@^1.0.0:
   version "1.0.2"
@@ -2332,62 +2623,80 @@ call-bind@^1.0.0:
     function-bind "^1.1.1"
     get-intrinsic "^1.0.2"
 
-callsite@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/callsite/-/callsite-1.0.0.tgz#280398e5d664bd74038b6f0905153e6e8af1bc20"
-  integrity sha1-KAOY5dZkvXQDi28JBRU+borxvCA=
-
 callsites@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.0.0.tgz#fb7eb569b72ad7a45812f93fd9430a3e410b3dd3"
   integrity sha512-tWnkwu9YEq2uzlBDI4RcLn8jrFvF9AOi8PxDNU3hZZjJcjkcRAq3vCI+vZcg1SuxISDYe86k9VZFwAxDiJGoAw==
 
-camelcase-keys@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-2.1.0.tgz#308beeaffdf28119051efa1d932213c91b8f92e7"
-  integrity sha1-MIvur/3ygRkFHvodkyITyRuPkuc=
+camel-case@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.2.tgz#9728072a954f805228225a6deea6b38461e1bd5a"
+  integrity sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==
   dependencies:
-    camelcase "^2.0.0"
-    map-obj "^1.0.0"
+    pascal-case "^3.1.2"
+    tslib "^2.0.3"
 
-camelcase-keys@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-4.2.0.tgz#a2aa5fb1af688758259c32c141426d78923b9b77"
-  integrity sha1-oqpfsa9oh1glnDLBQUJteJI7m3c=
+camelcase-keys@^6.2.2:
+  version "6.2.2"
+  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0"
+  integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==
   dependencies:
-    camelcase "^4.1.0"
-    map-obj "^2.0.0"
-    quick-lru "^1.0.0"
+    camelcase "^5.3.1"
+    map-obj "^4.0.0"
+    quick-lru "^4.0.1"
 
-camelcase@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f"
-  integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8=
+camelcase@^5.3.1:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
+  integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
 
-camelcase@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd"
-  integrity sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=
+camelcase@^6.0.0, camelcase@^6.2.0:
+  version "6.3.0"
+  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
+  integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
 
 caniuse-lite@^1.0.30001181:
   version "1.0.30001207"
   resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001207.tgz#364d47d35a3007e528f69adb6fecb07c2bb2cc50"
   integrity sha512-UPQZdmAsyp2qfCTiMU/zqGSWOYaY9F9LL61V8f+8MrubsaDGpaHD9HRV/EWZGULZn0Hxu48SKzI5DgFwTvHuYw==
 
+caniuse-lite@^1.0.30001332:
+  version "1.0.30001334"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001334.tgz#892e9965b35285033fc2b8a8eff499fe02f13d8b"
+  integrity sha512-kbaCEBRRVSoeNs74sCuq92MJyGrMtjWVfhltoHUCW4t4pXFvGjUBrfo47weBRViHkiV3eBYyIsfl956NtHGazw==
+
+capital-case@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/capital-case/-/capital-case-1.0.4.tgz#9d130292353c9249f6b00fa5852bee38a717e669"
+  integrity sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==
+  dependencies:
+    no-case "^3.0.4"
+    tslib "^2.0.3"
+    upper-case-first "^2.0.2"
+
 caseless@~0.12.0:
   version "0.12.0"
   resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
   integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
 
-chai-nightwatch@~0.1.x:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/chai-nightwatch/-/chai-nightwatch-0.1.1.tgz#1ca56de768d3c0868fe7fc2f4d32c2fe894e6be9"
-  integrity sha1-HKVt52jTwIaP5/wvTTLC/olOa+k=
+caw@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/caw/-/caw-2.0.1.tgz#6c3ca071fc194720883c2dc5da9b074bfc7e9e95"
+  integrity sha512-Cg8/ZSBEa8ZVY9HspcGUYaK63d/bN7rqS3CYCzEGUxuYv6UlmcjzDUz2fCFFHyTvUW5Pk0I+3hkA3iXlIj6guA==
+  dependencies:
+    get-proxy "^2.0.0"
+    isurl "^1.0.0-alpha5"
+    tunnel-agent "^0.6.0"
+    url-to-options "^1.0.1"
+
+chai-nightwatch@0.5.3:
+  version "0.5.3"
+  resolved "https://registry.yarnpkg.com/chai-nightwatch/-/chai-nightwatch-0.5.3.tgz#980ecf63dde5a04e7f3524370682c7ff01178ffb"
+  integrity sha512-38ixH/mqpY6IwnZkz6xPqx8aB5/KVR+j6VPugcir3EGOsphnWXrPH/mUt8Jp+ninL6ghY0AaJDQ10hSfCPGy/g==
   dependencies:
-    assertion-error "1.0.0"
-    deep-eql "0.1.3"
+    assertion-error "1.1.0"
 
-chalk@1.1.3, chalk@^1.0.0, chalk@^1.1.3:
+chalk@^1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
   integrity sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=
@@ -2398,7 +2707,7 @@ chalk@1.1.3, chalk@^1.0.0, chalk@^1.1.3:
     strip-ansi "^3.0.0"
     supports-color "^2.0.0"
 
-chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.3.0, chalk@^2.3.1, chalk@^2.4.1, chalk@^2.4.2:
+chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.4.1, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
   integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
@@ -2415,103 +2724,151 @@ chalk@^4.0.0, chalk@^4.1.0:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chardet@^0.4.0:
-  version "0.4.2"
-  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.4.2.tgz#b5473b33dc97c424e5d98dc87d55d4d8a29c8bf2"
-  integrity sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=
-
-chokidar@^2.0.2, chokidar@^2.0.3:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-2.0.4.tgz#356ff4e2b0e8e43e322d18a372460bbcf3accd26"
-  integrity sha512-z9n7yt9rOvIJrMhvDtDictKrkFHeihkNl6uWMmZlmL6tJtX9Cs+87oK+teBx+JIgzvbX3yZHT3eF8vpbDxHJXQ==
+chalk@^4.1.2:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
+  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
   dependencies:
-    anymatch "^2.0.0"
-    async-each "^1.0.0"
-    braces "^2.3.0"
-    glob-parent "^3.1.0"
-    inherits "^2.0.1"
-    is-binary-path "^1.0.0"
-    is-glob "^4.0.0"
-    lodash.debounce "^4.0.8"
-    normalize-path "^2.1.1"
-    path-is-absolute "^1.0.0"
-    readdirp "^2.0.0"
-    upath "^1.0.5"
+    ansi-styles "^4.1.0"
+    supports-color "^7.1.0"
+
+chalk@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.0.1.tgz#ca57d71e82bb534a296df63bbacc4a1c22b2a4b6"
+  integrity sha512-Fo07WOYGqMfCWHOzSXOt2CxDbC6skS/jO9ynEcmpANMoPrD+W1r1K6Vx7iNm+AQmETU1Xr2t+n8nzkV9t6xh3w==
+
+change-case@^4.1.1:
+  version "4.1.2"
+  resolved "https://registry.yarnpkg.com/change-case/-/change-case-4.1.2.tgz#fedfc5f136045e2398c0410ee441f95704641e12"
+  integrity sha512-bSxY2ws9OtviILG1EiY5K7NNxkqg/JnRnFxLtKQ96JaviiIxi7djMrSd0ECT9AC+lttClmYwKw53BWpOMblo7A==
+  dependencies:
+    camel-case "^4.1.2"
+    capital-case "^1.0.4"
+    constant-case "^3.0.4"
+    dot-case "^3.0.4"
+    header-case "^2.0.4"
+    no-case "^3.0.4"
+    param-case "^3.0.4"
+    pascal-case "^3.1.2"
+    path-case "^3.0.4"
+    sentence-case "^3.0.4"
+    snake-case "^3.0.4"
+    tslib "^2.0.3"
+
+chardet@^0.7.0:
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
+  integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
+
+check-error@1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82"
+  integrity sha1-V00xLt2Iu13YkS6Sht1sCu1KrII=
+
+chokidar@3.5.3, chokidar@^3.5.1:
+  version "3.5.3"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd"
+  integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
+  dependencies:
+    anymatch "~3.1.2"
+    braces "~3.0.2"
+    glob-parent "~5.1.2"
+    is-binary-path "~2.1.0"
+    is-glob "~4.0.1"
+    normalize-path "~3.0.0"
+    readdirp "~3.6.0"
   optionalDependencies:
-    fsevents "^1.2.2"
+    fsevents "~2.3.2"
 
 chownr@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.1.tgz#54726b8b8fff4df053c42187e801fb4412df1494"
   integrity sha512-j38EvO5+LHX84jlo6h4UzmOwi0UgW61WRyPtJz4qaadK5eY3BTS5TY/S1Stc3Uk2lIM6TPevAlULiEJwie860g==
 
-chrome-trace-event@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.0.tgz#45a91bd2c20c9411f0963b5aaeb9a1b95e09cc48"
-  integrity sha512-xDbVgyfDTT2piup/h8dK/y4QZfJRSa73bw1WZ8b4XM1o7fsFubUVGYcE+1ANtOzJJELGpYoG2961z0Z6OAld9A==
+chrome-launcher@^0.13.1:
+  version "0.13.4"
+  resolved "https://registry.yarnpkg.com/chrome-launcher/-/chrome-launcher-0.13.4.tgz#4c7d81333c98282899c4e38256da23e00ed32f73"
+  integrity sha512-nnzXiDbGKjDSK6t2I+35OAPBy5Pw/39bgkb/ZAFwMhwJbdYBp6aH+vW28ZgtjdU890Q7D+3wN/tB8N66q5Gi2A==
   dependencies:
-    tslib "^1.9.0"
+    "@types/node" "*"
+    escape-string-regexp "^1.0.5"
+    is-wsl "^2.2.0"
+    lighthouse-logger "^1.0.0"
+    mkdirp "^0.5.3"
+    rimraf "^3.0.2"
 
-chromedriver@^2.45.0:
-  version "2.45.0"
-  resolved "https://registry.yarnpkg.com/chromedriver/-/chromedriver-2.45.0.tgz#8c1b158adbbd3e0ca3f7af19d459082245554378"
-  integrity sha512-Qwmcr+2mU3INeR6mVsQ8gO00vZpL8ZeTJLclX44C0dcs88jrSDgckPqbG+qkVX+m2L/aOPnF0lYgPdOiOiLt5w==
-  dependencies:
-    del "^3.0.0"
-    extract-zip "^1.6.7"
-    mkdirp "^0.5.1"
-    request "^2.88.0"
+chrome-trace-event@^1.0.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac"
+  integrity sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==
+
+chromedriver@^100.0.0:
+  version "100.0.0"
+  resolved "https://registry.yarnpkg.com/chromedriver/-/chromedriver-100.0.0.tgz#1b4bf5c89cea12c79f53bc94d8f5bb5aa79ed7be"
+  integrity sha512-oLfB0IgFEGY9qYpFQO/BNSXbPw7bgfJUN5VX8Okps9W2qNT4IqKh5hDwKWtpUIQNI6K3ToWe2/J5NdpurTY02g==
+  dependencies:
+    "@testim/chrome-version" "^1.1.2"
+    axios "^0.24.0"
+    del "^6.0.0"
+    extract-zip "^2.0.1"
+    https-proxy-agent "^5.0.0"
+    proxy-from-env "^1.1.0"
     tcp-port-used "^1.0.1"
 
+ci-info@3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.3.0.tgz#b4ed1fb6818dea4803a55c623041f9165d2066b2"
+  integrity sha512-riT/3vI5YpVH6/qomlDnJow6TBee2PBKSEpx3O32EGPYbWGIRsIlGRms3Sm74wYE1JMo8RnO04Hb12+v1J5ICw==
+
 ci-info@^1.5.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"
   integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==
 
-cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
-  integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
+clean-stack@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
+  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
 
-circular-json@^0.5.5:
-  version "0.5.9"
-  resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.5.9.tgz#932763ae88f4f7dead7a0d09c8a51a4743a53b1d"
-  integrity sha512-4ivwqHpIFJZBuhN3g/pEcdbnGUywkBblloGbkglyloVjjR3uT6tieI89MVOfbP2tHX5sgb01FuLgAOzebNlJNQ==
+cli-boxes@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-2.2.1.tgz#ddd5035d25094fce220e9cab40a45840a440318f"
+  integrity sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==
 
-class-utils@^0.3.5:
-  version "0.3.6"
-  resolved "https://registry.yarnpkg.com/class-utils/-/class-utils-0.3.6.tgz#f93369ae8b9a7ce02fd41faad0ca83033190c463"
-  integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==
+cli-cursor@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
+  integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
   dependencies:
-    arr-union "^3.1.0"
-    define-property "^0.2.5"
-    isobject "^3.0.0"
-    static-extend "^0.1.1"
+    restore-cursor "^2.0.0"
 
-cli-cursor@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-1.0.2.tgz#64da3f7d56a54412e59794bd62dc35295e8f2987"
-  integrity sha1-ZNo/fValRBLll5S9Ytw1KV6PKYc=
+cli-cursor@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
+  integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
   dependencies:
-    restore-cursor "^1.0.1"
+    restore-cursor "^3.1.0"
+
+cli-spinners@^2.5.0:
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.6.1.tgz#adc954ebe281c37a6319bfa401e6dd2488ffb70d"
+  integrity sha512-x/5fWmGMnbKQAaNwN+UZlV79qBLM9JFnJuJ03gIi5whrob0xV0ofNVHy9DhwGdsMJQc2OKv0oGmLzvaqvAVv+g==
 
-cli-cursor@^2.0.0, cli-cursor@^2.1.0:
+cli-truncate@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
-  integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
+  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-2.1.0.tgz#c39e28bf05edcde5be3b98992a22deed5a2b93c7"
+  integrity sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==
   dependencies:
-    restore-cursor "^2.0.0"
+    slice-ansi "^3.0.0"
+    string-width "^4.2.0"
 
-cli-truncate@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-0.2.1.tgz#9f15cfbb0705005369216c626ac7d05ab90dd574"
-  integrity sha1-nxXPuwcFAFNpIWxiasfQWrkN1XQ=
+cli-truncate@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-3.1.0.tgz#3f23ab12535e3d73e839bb43e73c9de487db1389"
+  integrity sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==
   dependencies:
-    slice-ansi "0.0.4"
-    string-width "^1.0.1"
+    slice-ansi "^5.0.0"
+    string-width "^5.0.0"
 
 cli-width@^2.0.0:
   version "2.2.0"
@@ -2527,34 +2884,37 @@ cliui@^7.0.2:
     strip-ansi "^6.0.0"
     wrap-ansi "^7.0.0"
 
-co@~3.0.6:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/co/-/co-3.0.6.tgz#1445f226c5eb956138e68c9ac30167ea7d2e6bda"
-  integrity sha1-FEXyJsXrlWE45oyawwFn6n0ua9o=
-
-code-point-at@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
-  integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
+clone-deep@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
+  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
+  dependencies:
+    is-plain-object "^2.0.4"
+    kind-of "^6.0.2"
+    shallow-clone "^3.0.0"
 
-codecov@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/codecov/-/codecov-3.1.0.tgz#340bd968d361f256976b5af782dd8ba9f82bc849"
-  integrity sha512-aWQc/rtHbcWEQLka6WmBAOpV58J2TwyXqlpAQGhQaSiEUoigTTUk6lLd2vB3kXkhnDyzyH74RXfmV4dq2txmdA==
+clone-response@1.0.2, clone-response@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/clone-response/-/clone-response-1.0.2.tgz#d1dc973920314df67fbeb94223b4ee350239e96b"
+  integrity sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=
   dependencies:
-    argv "^0.0.2"
-    ignore-walk "^3.0.1"
-    js-yaml "^3.12.0"
-    request "^2.87.0"
-    urlgrey "^0.4.4"
+    mimic-response "^1.0.0"
 
-collection-visit@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0"
-  integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=
+clone@^1.0.2:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"
+  integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=
+
+codecov@^3.8.3:
+  version "3.8.3"
+  resolved "https://registry.yarnpkg.com/codecov/-/codecov-3.8.3.tgz#9c3e364b8a700c597346ae98418d09880a3fdbe7"
+  integrity sha512-Y8Hw+V3HgR7V71xWH2vQ9lyS358CbGCldWlJFR0JirqoGtOoas3R3/OclRTvgUYFK29mmJICDPauVKmpqbwhOA==
   dependencies:
-    map-visit "^1.0.0"
-    object-visit "^1.0.0"
+    argv "0.0.2"
+    ignore-walk "3.0.4"
+    js-yaml "3.14.1"
+    teeny-request "7.1.1"
+    urlgrey "1.0.0"
 
 color-convert@^1.9.0:
   version "1.9.3"
@@ -2585,22 +2945,10 @@ colorette@^1.2.1:
   resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
   integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
 
-colors@^1.1.0:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.3.tgz#39e005d546afe01e01f9c4ca8fa50f686a01205d"
-  integrity sha512-mmGt/1pZqYRjMxB1axhTo16/snVZ5krrKkcmMeVKxzECMMXoCgnvTPp10QgHfcbQZw8Dq2jMNG6je4JlWU0gWg==
-
-colors@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.4.0.tgz#c50491479d4c1bdaed2c9ced32cf7c7dc2360f78"
-  integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==
-
-combine-lists@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/combine-lists/-/combine-lists-1.0.1.tgz#458c07e09e0d900fc28b70a3fec2dacd1d2cb7f6"
-  integrity sha1-RYwH4J4NkA/Ci3Cj/sLazR0st/Y=
-  dependencies:
-    lodash "^4.5.0"
+colorette@^2.0.16:
+  version "2.0.16"
+  resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.16.tgz#713b9af84fdb000139f04546bd4a93f62a5085da"
+  integrity sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==
 
 combined-stream@^1.0.6, combined-stream@~1.0.6:
   version "1.0.7"
@@ -2609,84 +2957,85 @@ combined-stream@^1.0.6, combined-stream@~1.0.6:
   dependencies:
     delayed-stream "~1.0.0"
 
-commander@2.9.0:
-  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.9.0.tgz#9c99094176e12240cb22d6c5146098400fe0f7d4"
-  integrity sha1-nJkJQXbhIkDLItbFFGCYQA/g99Q=
+combined-stream@^1.0.8:
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
+  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
   dependencies:
-    graceful-readlink ">= 1.0.0"
-
-commander@^2.14.1, commander@^2.9.0:
-  version "2.19.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.19.0.tgz#f6198aa84e5b83c46054b94ddedbfed5ee9ff12a"
-  integrity sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==
+    delayed-stream "~1.0.0"
 
-commander@^2.20.0:
+commander@^2.20.0, commander@^2.8.1:
   version "2.20.3"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
 
-commander@~2.17.1:
-  version "2.17.1"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.17.1.tgz#bd77ab7de6de94205ceacc72f1716d29f20a77bf"
-  integrity sha512-wPMUt6FnH2yzG95SA6mzjQOEKUU3aLaDEmzs1ti+1E9h+CsrZghRlqEM/EJ4KscsQVG8uNN4uVreUeT8+drlgg==
-
-commitizen@^2.9.6:
-  version "2.10.1"
-  resolved "https://registry.yarnpkg.com/commitizen/-/commitizen-2.10.1.tgz#8c395def34a895f4e94952c2efc3c9eb4c3683bd"
-  integrity sha1-jDld7zSolfTpSVLC78PJ60w2g70=
-  dependencies:
-    cachedir "^1.1.0"
-    chalk "1.1.3"
-    cz-conventional-changelog "2.0.0"
-    dedent "0.6.0"
-    detect-indent "4.0.0"
-    find-node-modules "1.0.4"
-    find-root "1.0.0"
-    fs-extra "^1.0.0"
-    glob "7.1.1"
-    inquirer "1.2.3"
-    lodash "4.17.5"
-    minimist "1.2.0"
-    opencollective "1.0.3"
-    path-exists "2.1.0"
-    shelljs "0.7.6"
-    strip-json-comments "2.0.1"
+commander@^8.3.0:
+  version "8.3.0"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz#4837ea1b2da67b9c616a67afbb0fafee567bca66"
+  integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==
+
+commitizen@^4.0.3, commitizen@^4.2.4:
+  version "4.2.4"
+  resolved "https://registry.yarnpkg.com/commitizen/-/commitizen-4.2.4.tgz#a3e5b36bd7575f6bf6e7aa19dbbf06b0d8f37165"
+  integrity sha512-LlZChbDzg3Ir3O2S7jSo/cgWp5/QwylQVr59K4xayVq8S4/RdKzSyJkghAiZZHfhh5t4pxunUoyeg0ml1q/7aw==
+  dependencies:
+    cachedir "2.2.0"
+    cz-conventional-changelog "3.2.0"
+    dedent "0.7.0"
+    detect-indent "6.0.0"
+    find-node-modules "^2.1.2"
+    find-root "1.1.0"
+    fs-extra "8.1.0"
+    glob "7.1.4"
+    inquirer "6.5.2"
+    is-utf8 "^0.2.1"
+    lodash "^4.17.20"
+    minimist "1.2.5"
+    strip-bom "4.0.0"
+    strip-json-comments "3.0.1"
 
 commondir@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
   integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=
 
-compare-func@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-1.3.2.tgz#99dd0ba457e1f9bc722b12c08ec33eeab31fa648"
-  integrity sha1-md0LpFfh+bxyKxLAjsM+6rMfpkg=
+compare-func@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-2.0.0.tgz#fb65e75edbddfd2e568554e8b5b05fff7a51fcb3"
+  integrity sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==
   dependencies:
     array-ify "^1.0.0"
-    dot-prop "^3.0.0"
+    dot-prop "^5.1.0"
 
-component-bind@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/component-bind/-/component-bind-1.0.0.tgz#00c608ab7dcd93897c0009651b1d3a8e1e73bbd1"
-  integrity sha1-AMYIq33Nk4l8AAllGx06jh5zu9E=
+component-emitter@~1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
+  integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==
 
-component-emitter@1.2.1, component-emitter@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.2.1.tgz#137918d6d78283f7df7a6b7c5a63e140e69425e6"
-  integrity sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=
+compress-brotli@^1.3.6:
+  version "1.3.6"
+  resolved "https://registry.yarnpkg.com/compress-brotli/-/compress-brotli-1.3.6.tgz#64bd6f21f4f3e9841dbac392f4c29218caf5e9d9"
+  integrity sha512-au99/GqZtUtiCBliqLFbWlhnCxn+XSYjwZ77q6mKN4La4qOXDoLVPZ50iXr0WmAyMxl8yqoq3Yq4OeQNPPkyeQ==
+  dependencies:
+    "@types/json-buffer" "~3.0.0"
+    json-buffer "~3.0.1"
 
-component-inherit@0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/component-inherit/-/component-inherit-0.0.3.tgz#645fc4adf58b72b649d5cae65135619db26ff143"
-  integrity sha1-ZF/ErfWLcrZJ1crmUTVhnbJv8UM=
+compress-commons@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/compress-commons/-/compress-commons-4.1.1.tgz#df2a09a7ed17447642bad10a85cc9a19e5c42a7d"
+  integrity sha512-QLdDLCKNV2dtoTorqgxngQCMA+gWXkM/Nwu7FpeBhk/RdkzimqC3jueb/FDmaZeXh+uby1jkBqE3xArsLBE5wQ==
+  dependencies:
+    buffer-crc32 "^0.2.13"
+    crc32-stream "^4.0.2"
+    normalize-path "^3.0.0"
+    readable-stream "^3.6.0"
 
 concat-map@0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
   integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
 
-concat-stream@1.6.2, concat-stream@^1.4.7, concat-stream@^1.5.0:
+concat-stream@1.6.2:
   version "1.6.2"
   resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
   integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
@@ -2696,185 +3045,193 @@ concat-stream@1.6.2, concat-stream@^1.4.7, concat-stream@^1.5.0:
     readable-stream "^2.2.2"
     typedarray "^0.0.6"
 
-connect@^3.6.0:
-  version "3.6.6"
-  resolved "https://registry.yarnpkg.com/connect/-/connect-3.6.6.tgz#09eff6c55af7236e137135a72574858b6786f524"
-  integrity sha1-Ce/2xVr3I24TcTWnJXSFi2eG9SQ=
+config-chain@^1.1.11:
+  version "1.1.13"
+  resolved "https://registry.yarnpkg.com/config-chain/-/config-chain-1.1.13.tgz#fad0795aa6a6cdaff9ed1b68e9dff94372c232f4"
+  integrity sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==
+  dependencies:
+    ini "^1.3.4"
+    proto-list "~1.2.1"
+
+connect@^3.7.0:
+  version "3.7.0"
+  resolved "https://registry.yarnpkg.com/connect/-/connect-3.7.0.tgz#5d49348910caa5e07a01800b030d0c35f20484f8"
+  integrity sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==
   dependencies:
     debug "2.6.9"
-    finalhandler "1.1.0"
-    parseurl "~1.3.2"
+    finalhandler "1.1.2"
+    parseurl "~1.3.3"
     utils-merge "1.0.1"
 
-console-browserify@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.1.0.tgz#f0241c45730a9fc6323b206dbf38edc741d0bb10"
-  integrity sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=
+constant-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/constant-case/-/constant-case-3.0.4.tgz#3b84a9aeaf4cf31ec45e6bf5de91bdfb0589faf1"
+  integrity sha512-I2hSBi7Vvs7BEuJDr5dDHfzb/Ruj3FyvFyh7KLilAjNQw3Be+xgqUBA2W6scVEcL0hL1dwPRtIqEPVUCKkSsyQ==
   dependencies:
-    date-now "^0.1.4"
+    no-case "^3.0.4"
+    tslib "^2.0.3"
+    upper-case "^2.0.2"
 
-console-control-strings@^1.0.0, console-control-strings@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/console-control-strings/-/console-control-strings-1.1.0.tgz#3d7cf4464db6446ea644bf4b39507f9851008e8e"
-  integrity sha1-PXz0Rk22RG6mRL9LOVB/mFEAjo4=
-
-constants-browserify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
-  integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=
+content-disposition@^0.5.2:
+  version "0.5.4"
+  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe"
+  integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==
+  dependencies:
+    safe-buffer "5.2.1"
 
 content-type@~1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.4.tgz#e138cc75e040c727b1966fe5e5f8c9aee256fe3b"
   integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==
 
-conventional-changelog-angular@^1.6.6:
-  version "1.6.6"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-1.6.6.tgz#b27f2b315c16d0a1f23eb181309d0e6a4698ea0f"
-  integrity sha512-suQnFSqCxRwyBxY68pYTsFkG0taIdinHLNEAX5ivtw8bCRnIgnpvcHmlR/yjUyZIrNPYAoXlY1WiEKWgSE4BNg==
+conventional-changelog-angular@^5.0.12:
+  version "5.0.13"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-5.0.13.tgz#896885d63b914a70d4934b59d2fe7bde1832b28c"
+  integrity sha512-i/gipMxs7s8L/QeuavPF2hLnJgH6pEZAttySB6aiQLWcX3puWDL3ACVmvBhJGxnAy52Qc15ua26BufY6KpmrVA==
   dependencies:
-    compare-func "^1.3.1"
+    compare-func "^2.0.0"
     q "^1.5.1"
 
-conventional-changelog-atom@^0.2.8:
-  version "0.2.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-atom/-/conventional-changelog-atom-0.2.8.tgz#8037693455990e3256f297320a45fa47ee553a14"
-  integrity sha512-8pPZqhMbrnltNBizjoDCb/Sz85KyUXNDQxuAEYAU5V/eHn0okMBVjqc8aHWYpHrytyZWvMGbayOlDv7i8kEf6g==
+conventional-changelog-atom@^2.0.8:
+  version "2.0.8"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-atom/-/conventional-changelog-atom-2.0.8.tgz#a759ec61c22d1c1196925fca88fe3ae89fd7d8de"
+  integrity sha512-xo6v46icsFTK3bb7dY/8m2qvc8sZemRgdqLb/bjpBsH2UyOS8rKNTgcb5025Hri6IpANPApbXMg15QLb1LJpBw==
   dependencies:
     q "^1.5.1"
 
-conventional-changelog-codemirror@^0.3.8:
-  version "0.3.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-codemirror/-/conventional-changelog-codemirror-0.3.8.tgz#a1982c8291f4ee4d6f2f62817c6b2ecd2c4b7b47"
-  integrity sha512-3HFZKtBXTaUCHvz7ai6nk2+psRIkldDoNzCsom0egDtVmPsvvHZkzjynhdQyULfacRSsBTaiQ0ol6nBOL4dDiQ==
+conventional-changelog-codemirror@^2.0.8:
+  version "2.0.8"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-codemirror/-/conventional-changelog-codemirror-2.0.8.tgz#398e9530f08ce34ec4640af98eeaf3022eb1f7dc"
+  integrity sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw==
   dependencies:
     q "^1.5.1"
 
-conventional-changelog-core@^2.0.11:
-  version "2.0.11"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-core/-/conventional-changelog-core-2.0.11.tgz#19b5fbd55a9697773ed6661f4e32030ed7e30287"
-  integrity sha512-HvTE6RlqeEZ/NFPtQeFLsIDOLrGP3bXYr7lFLMhCVsbduF1MXIe8OODkwMFyo1i9ku9NWBwVnVn0jDmIFXjDRg==
+conventional-changelog-conventionalcommits@^4.5.0:
+  version "4.6.3"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-4.6.3.tgz#0765490f56424b46f6cb4db9135902d6e5a36dc2"
+  integrity sha512-LTTQV4fwOM4oLPad317V/QNQ1FY4Hju5qeBIM1uTHbrnCE+Eg4CdRZ3gO2pUeR+tzWdp80M2j3qFFEDWVqOV4g==
   dependencies:
-    conventional-changelog-writer "^3.0.9"
-    conventional-commits-parser "^2.1.7"
-    dateformat "^3.0.0"
-    get-pkg-repo "^1.0.0"
-    git-raw-commits "^1.3.6"
-    git-remote-origin-url "^2.0.0"
-    git-semver-tags "^1.3.6"
-    lodash "^4.2.1"
-    normalize-package-data "^2.3.5"
+    compare-func "^2.0.0"
+    lodash "^4.17.15"
     q "^1.5.1"
-    read-pkg "^1.1.0"
-    read-pkg-up "^1.0.1"
-    through2 "^2.0.0"
 
-conventional-changelog-ember@^0.3.12:
-  version "0.3.12"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-ember/-/conventional-changelog-ember-0.3.12.tgz#b7d31851756d0fcb49b031dffeb6afa93b202400"
-  integrity sha512-mmJzA7uzbrOqeF89dMMi6z17O07ORTXlTMArnLG9ZTX4oLaKNolUlxFUFlFm9JUoVWajVpaHQWjxH1EOQ+ARoQ==
+conventional-changelog-core@^4.2.1:
+  version "4.2.4"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-core/-/conventional-changelog-core-4.2.4.tgz#e50d047e8ebacf63fac3dc67bf918177001e1e9f"
+  integrity sha512-gDVS+zVJHE2v4SLc6B0sLsPiloR0ygU7HaDW14aNJE1v4SlqJPILPl/aJC7YdtRE4CybBf8gDwObBvKha8Xlyg==
   dependencies:
+    add-stream "^1.0.0"
+    conventional-changelog-writer "^5.0.0"
+    conventional-commits-parser "^3.2.0"
+    dateformat "^3.0.0"
+    get-pkg-repo "^4.0.0"
+    git-raw-commits "^2.0.8"
+    git-remote-origin-url "^2.0.0"
+    git-semver-tags "^4.1.1"
+    lodash "^4.17.15"
+    normalize-package-data "^3.0.0"
     q "^1.5.1"
+    read-pkg "^3.0.0"
+    read-pkg-up "^3.0.0"
+    through2 "^4.0.0"
 
-conventional-changelog-eslint@^1.0.9:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-eslint/-/conventional-changelog-eslint-1.0.9.tgz#b13cc7e4b472c819450ede031ff1a75c0e3d07d3"
-  integrity sha512-h87nfVh2fdk9fJIvz26wCBsbDC/KxqCc5wSlNMZbXcARtbgNbNDIF7Y7ctokFdnxkzVdaHsbINkh548T9eBA7Q==
+conventional-changelog-ember@^2.0.9:
+  version "2.0.9"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-ember/-/conventional-changelog-ember-2.0.9.tgz#619b37ec708be9e74a220f4dcf79212ae1c92962"
+  integrity sha512-ulzIReoZEvZCBDhcNYfDIsLTHzYHc7awh+eI44ZtV5cx6LVxLlVtEmcO+2/kGIHGtw+qVabJYjdI5cJOQgXh1A==
   dependencies:
     q "^1.5.1"
 
-conventional-changelog-express@^0.3.6:
-  version "0.3.6"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-express/-/conventional-changelog-express-0.3.6.tgz#4a6295cb11785059fb09202180d0e59c358b9c2c"
-  integrity sha512-3iWVtBJZ9RnRnZveNDzOD8QRn6g6vUif0qVTWWyi5nUIAbuN1FfPVyKdAlJJfp5Im+dE8Kiy/d2SpaX/0X678Q==
+conventional-changelog-eslint@^3.0.9:
+  version "3.0.9"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-eslint/-/conventional-changelog-eslint-3.0.9.tgz#689bd0a470e02f7baafe21a495880deea18b7cdb"
+  integrity sha512-6NpUCMgU8qmWmyAMSZO5NrRd7rTgErjrm4VASam2u5jrZS0n38V7Y9CzTtLT2qwz5xEChDR4BduoWIr8TfwvXA==
   dependencies:
     q "^1.5.1"
 
-conventional-changelog-jquery@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jquery/-/conventional-changelog-jquery-0.1.0.tgz#0208397162e3846986e71273b6c79c5b5f80f510"
-  integrity sha1-Agg5cWLjhGmG5xJztsecW1+A9RA=
+conventional-changelog-express@^2.0.6:
+  version "2.0.6"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-express/-/conventional-changelog-express-2.0.6.tgz#420c9d92a347b72a91544750bffa9387665a6ee8"
+  integrity sha512-SDez2f3iVJw6V563O3pRtNwXtQaSmEfTCaTBPCqn0oG0mfkq0rX4hHBq5P7De2MncoRixrALj3u3oQsNK+Q0pQ==
   dependencies:
-    q "^1.4.1"
+    q "^1.5.1"
 
-conventional-changelog-jscs@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jscs/-/conventional-changelog-jscs-0.1.0.tgz#0479eb443cc7d72c58bf0bcf0ef1d444a92f0e5c"
-  integrity sha1-BHnrRDzH1yxYvwvPDvHURKkvDlw=
+conventional-changelog-jquery@^3.0.11:
+  version "3.0.11"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-jquery/-/conventional-changelog-jquery-3.0.11.tgz#d142207400f51c9e5bb588596598e24bba8994bf"
+  integrity sha512-x8AWz5/Td55F7+o/9LQ6cQIPwrCjfJQ5Zmfqi8thwUEKHstEn4kTIofXub7plf1xvFA2TqhZlq7fy5OmV6BOMw==
   dependencies:
-    q "^1.4.1"
+    q "^1.5.1"
 
-conventional-changelog-jshint@^0.3.8:
-  version "0.3.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jshint/-/conventional-changelog-jshint-0.3.8.tgz#9051c1ac0767abaf62a31f74d2fe8790e8acc6c8"
-  integrity sha512-hn9QU4ZI/5V50wKPJNPGT4gEWgiBFpV6adieILW4MaUFynuDYOvQ71EMSj3EznJyKi/KzuXpc9dGmX8njZMjig==
+conventional-changelog-jshint@^2.0.9:
+  version "2.0.9"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-jshint/-/conventional-changelog-jshint-2.0.9.tgz#f2d7f23e6acd4927a238555d92c09b50fe3852ff"
+  integrity sha512-wMLdaIzq6TNnMHMy31hql02OEQ8nCQfExw1SE0hYL5KvU+JCTuPaDO+7JiogGT2gJAxiUGATdtYYfh+nT+6riA==
   dependencies:
-    compare-func "^1.3.1"
+    compare-func "^2.0.0"
     q "^1.5.1"
 
-conventional-changelog-preset-loader@^1.1.8:
-  version "1.1.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-1.1.8.tgz#40bb0f142cd27d16839ec6c74ee8db418099b373"
-  integrity sha512-MkksM4G4YdrMlT2MbTsV2F6LXu/hZR0Tc/yenRrDIKRwBl/SP7ER4ZDlglqJsCzLJi4UonBc52Bkm5hzrOVCcw==
+conventional-changelog-preset-loader@^2.3.4:
+  version "2.3.4"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-2.3.4.tgz#14a855abbffd59027fd602581f1f34d9862ea44c"
+  integrity sha512-GEKRWkrSAZeTq5+YjUZOYxdHq+ci4dNwHvpaBC3+ENalzFWuCWa9EZXSuZBpkr72sMdKB+1fyDV4takK1Lf58g==
 
-conventional-changelog-writer@^3.0.9:
-  version "3.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-writer/-/conventional-changelog-writer-3.0.9.tgz#4aecdfef33ff2a53bb0cf3b8071ce21f0e994634"
-  integrity sha512-n9KbsxlJxRQsUnK6wIBRnARacvNnN4C/nxnxCkH+B/R1JS2Fa+DiP1dU4I59mEDEjgnFaN2+9wr1P1s7GYB5/Q==
+conventional-changelog-writer@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/conventional-changelog-writer/-/conventional-changelog-writer-5.0.1.tgz#e0757072f045fe03d91da6343c843029e702f359"
+  integrity sha512-5WsuKUfxW7suLblAbFnxAcrvf6r+0b7GvNaWUwUIk0bXMnENP/PEieGKVUQrjPqwPT4o3EPAASBXiY6iHooLOQ==
   dependencies:
-    compare-func "^1.3.1"
-    conventional-commits-filter "^1.1.6"
+    conventional-commits-filter "^2.0.7"
     dateformat "^3.0.0"
-    handlebars "^4.0.2"
+    handlebars "^4.7.7"
     json-stringify-safe "^5.0.1"
-    lodash "^4.2.1"
-    meow "^4.0.0"
-    semver "^5.5.0"
+    lodash "^4.17.15"
+    meow "^8.0.0"
+    semver "^6.0.0"
     split "^1.0.0"
-    through2 "^2.0.0"
-
-conventional-changelog@^1.1.3:
-  version "1.1.24"
-  resolved "https://registry.yarnpkg.com/conventional-changelog/-/conventional-changelog-1.1.24.tgz#3d94c29c960f5261c002678315b756cdd3d7d1f0"
-  integrity sha512-2WcSUst4Y3Z4hHvoMTWXMJr/DmgVdLiMOVY1Kak2LfFz+GIz2KDp5naqbFesYbfXPmaZ5p491dO0FWZIJoJw1Q==
-  dependencies:
-    conventional-changelog-angular "^1.6.6"
-    conventional-changelog-atom "^0.2.8"
-    conventional-changelog-codemirror "^0.3.8"
-    conventional-changelog-core "^2.0.11"
-    conventional-changelog-ember "^0.3.12"
-    conventional-changelog-eslint "^1.0.9"
-    conventional-changelog-express "^0.3.6"
-    conventional-changelog-jquery "^0.1.0"
-    conventional-changelog-jscs "^0.1.0"
-    conventional-changelog-jshint "^0.3.8"
-    conventional-changelog-preset-loader "^1.1.8"
-
-conventional-commit-types@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/conventional-commit-types/-/conventional-commit-types-2.2.0.tgz#5db95739d6c212acbe7b6f656a11b940baa68946"
-  integrity sha1-XblXOdbCEqy+e29lahG5QLqmiUY=
+    through2 "^4.0.0"
+
+conventional-changelog@^3.1.25:
+  version "3.1.25"
+  resolved "https://registry.yarnpkg.com/conventional-changelog/-/conventional-changelog-3.1.25.tgz#3e227a37d15684f5aa1fb52222a6e9e2536ccaff"
+  integrity sha512-ryhi3fd1mKf3fSjbLXOfK2D06YwKNic1nC9mWqybBHdObPd8KJ2vjaXZfYj1U23t+V8T8n0d7gwnc9XbIdFbyQ==
+  dependencies:
+    conventional-changelog-angular "^5.0.12"
+    conventional-changelog-atom "^2.0.8"
+    conventional-changelog-codemirror "^2.0.8"
+    conventional-changelog-conventionalcommits "^4.5.0"
+    conventional-changelog-core "^4.2.1"
+    conventional-changelog-ember "^2.0.9"
+    conventional-changelog-eslint "^3.0.9"
+    conventional-changelog-express "^2.0.6"
+    conventional-changelog-jquery "^3.0.11"
+    conventional-changelog-jshint "^2.0.9"
+    conventional-changelog-preset-loader "^2.3.4"
+
+conventional-commit-types@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/conventional-commit-types/-/conventional-commit-types-3.0.0.tgz#7c9214e58eae93e85dd66dbfbafe7e4fffa2365b"
+  integrity sha512-SmmCYnOniSsAa9GqWOeLqc179lfr5TRu5b4QFDkbsrJ5TZjPJx85wtOr3zn+1dbeNiXDKGPbZ72IKbPhLXh/Lg==
 
-conventional-commits-filter@^1.1.6:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/conventional-commits-filter/-/conventional-commits-filter-1.1.6.tgz#4389cd8e58fe89750c0b5fb58f1d7f0cc8ad3831"
-  integrity sha512-KcDgtCRKJCQhyk6VLT7zR+ZOyCnerfemE/CsR3iQpzRRFbLEs0Y6rwk3mpDvtOh04X223z+1xyJ582Stfct/0Q==
+conventional-commits-filter@^2.0.7:
+  version "2.0.7"
+  resolved "https://registry.yarnpkg.com/conventional-commits-filter/-/conventional-commits-filter-2.0.7.tgz#f8d9b4f182fce00c9af7139da49365b136c8a0b3"
+  integrity sha512-ASS9SamOP4TbCClsRHxIHXRfcGCnIoQqkvAzCSbZzTFLfcTqJVugB0agRgsEELsqaeWgsXv513eS116wnlSSPA==
   dependencies:
-    is-subset "^0.1.1"
+    lodash.ismatch "^4.4.0"
     modify-values "^1.0.0"
 
-conventional-commits-parser@^2.1.7:
-  version "2.1.7"
-  resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-2.1.7.tgz#eca45ed6140d72ba9722ee4132674d639e644e8e"
-  integrity sha512-BoMaddIEJ6B4QVMSDu9IkVImlGOSGA1I2BQyOZHeLQ6qVOJLcLKn97+fL6dGbzWEiqDzfH4OkcveULmeq2MHFQ==
+conventional-commits-parser@^3.2.0:
+  version "3.2.4"
+  resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-3.2.4.tgz#a7d3b77758a202a9b2293d2112a8d8052c740972"
+  integrity sha512-nK7sAtfi+QXbxHCYfhpZsfRtaitZLIA6889kFIouLvz6repszQDgxBu7wf2WbU+Dco7sAnNCJYERCwt54WPC2Q==
   dependencies:
     JSONStream "^1.0.4"
-    is-text-path "^1.0.0"
-    lodash "^4.2.1"
-    meow "^4.0.0"
-    split2 "^2.0.0"
-    through2 "^2.0.0"
-    trim-off-newlines "^1.0.0"
+    is-text-path "^1.0.1"
+    lodash "^4.17.15"
+    meow "^8.0.0"
+    split2 "^3.0.0"
+    through2 "^4.0.0"
 
 convert-source-map@^1.7.0:
   version "1.7.0"
@@ -2883,101 +3240,91 @@ convert-source-map@^1.7.0:
   dependencies:
     safe-buffer "~5.1.1"
 
-cookie@0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.3.1.tgz#e7e0a1f9ef43b4c8ba925c5c5a96e806d16873bb"
-  integrity sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=
-
-copy-concurrently@^1.0.0:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/copy-concurrently/-/copy-concurrently-1.0.5.tgz#92297398cae34937fcafd6ec8139c18051f0b5e0"
-  integrity sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==
-  dependencies:
-    aproba "^1.1.1"
-    fs-write-stream-atomic "^1.0.8"
-    iferr "^0.1.5"
-    mkdirp "^0.5.1"
-    rimraf "^2.5.4"
-    run-queue "^1.0.0"
-
-copy-descriptor@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d"
-  integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=
+cookie@~0.4.1:
+  version "0.4.2"
+  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.2.tgz#0e41f24de5ecf317947c82fc789e06a884824432"
+  integrity sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==
 
-core-js-compat@^3.8.1, core-js-compat@^3.9.0:
-  version "3.10.0"
-  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.10.0.tgz#3600dc72869673c110215ee7a005a8609dea0fe1"
-  integrity sha512-9yVewub2MXNYyGvuLnMHcN1k9RkvB7/ofktpeKTIaASyB88YYqGzUnu0ywMMhJrDHOMiTjSHWGzR+i7Wb9Z1kQ==
+core-js-compat@^3.21.0, core-js-compat@^3.22.1:
+  version "3.22.3"
+  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.22.3.tgz#9b10d786052d042bc97ee8df9c0d1fb6a49c2005"
+  integrity sha512-wliMbvPI2idgFWpFe7UEyHMvu6HWgW8WA+HnDRtgzoSDYvXFMpoGX1H3tPDDXrcfUSyXafCLDd7hOeMQHEZxGw==
   dependencies:
-    browserslist "^4.16.3"
+    browserslist "^4.20.3"
     semver "7.0.0"
 
-core-js@^2.2.0, core-js@^2.4.0:
+core-js@^2.4.0:
   version "2.6.1"
   resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.1.tgz#87416ae817de957a3f249b3b5ca475d4aaed6042"
   integrity sha512-L72mmmEayPJBejKIWe2pYtGis5r0tQ5NaJekdhyXgeMQTpJoBsH0NL4ElY2LfSoV15xeQWKQ+XTTOZdyero5Xg==
 
-core-js@~2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.3.0.tgz#fab83fbb0b2d8dc85fa636c4b9d34c75420c6d65"
-  integrity sha1-+rg/uwstjchfpjbEudNMdUIMbWU=
+core-js@^3.6.5:
+  version "3.22.3"
+  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.22.3.tgz#498c41d997654cb00e81c7a54b44f0ab21ab01d5"
+  integrity sha512-1t+2a/d2lppW1gkLXx3pKPVGbBdxXAkqztvWb1EJ8oF8O2gIGiytzflNiFEehYwVK/t2ryUsGBoOFFvNx95mbg==
 
 core-util-is@1.0.2, core-util-is@~1.0.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
   integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
 
+cors@~2.8.5:
+  version "2.8.5"
+  resolved "https://registry.yarnpkg.com/cors/-/cors-2.8.5.tgz#eac11da51592dd86b9f06f6e7ac293b3df875d29"
+  integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==
+  dependencies:
+    object-assign "^4"
+    vary "^1"
+
 corser@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/corser/-/corser-2.0.1.tgz#8eda252ecaab5840dcd975ceb90d9370c819ff87"
   integrity sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=
 
-cosmiconfig@5.0.6:
-  version "5.0.6"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-5.0.6.tgz#dca6cf680a0bd03589aff684700858c81abeeb39"
-  integrity sha512-6DWfizHriCrFWURP1/qyhsiFvYdlJzbCzmtFWh744+KyWsJo5+kPzUZZaMRSSItoYc0pxFX7gEO7ZC1/gN/7AQ==
+cosmiconfig-typescript-loader@^1.0.0:
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-1.0.9.tgz#69c523f7e8c3d9f27f563d02bbeadaf2f27212d3"
+  integrity sha512-tRuMRhxN4m1Y8hP9SNYfz7jRwt8lZdWxdjg/ohg5esKmsndJIn4yT96oJVcf5x0eA11taXl+sIp+ielu529k6g==
   dependencies:
-    is-directory "^0.3.1"
-    js-yaml "^3.9.0"
-    parse-json "^4.0.0"
+    cosmiconfig "^7"
+    ts-node "^10.7.0"
 
-create-ecdh@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.3.tgz#c9111b6f33045c4697f144787f9254cdc77c45ff"
-  integrity sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==
+cosmiconfig@^7, cosmiconfig@^7.0.0:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-7.0.1.tgz#714d756522cace867867ccb4474c5d01bbae5d6d"
+  integrity sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==
   dependencies:
-    bn.js "^4.1.0"
-    elliptic "^6.0.0"
+    "@types/parse-json" "^4.0.0"
+    import-fresh "^3.2.1"
+    parse-json "^5.0.0"
+    path-type "^4.0.0"
+    yaml "^1.10.0"
 
-create-hash@^1.1.0, create-hash@^1.1.2:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
-  integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
-  dependencies:
-    cipher-base "^1.0.1"
-    inherits "^2.0.1"
-    md5.js "^1.3.4"
-    ripemd160 "^2.0.1"
-    sha.js "^2.4.0"
+crc-32@^1.2.0:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/crc-32/-/crc-32-1.2.2.tgz#3cad35a934b8bf71f25ca524b6da51fb7eace2ff"
+  integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==
 
-create-hmac@^1.1.0, create-hmac@^1.1.2, create-hmac@^1.1.4:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff"
-  integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
+crc32-stream@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/crc32-stream/-/crc32-stream-4.0.2.tgz#c922ad22b38395abe9d3870f02fa8134ed709007"
+  integrity sha512-DxFZ/Hk473b/muq1VJ///PMNLj0ZMnzye9thBpmjpJKCc5eMgB95aK8zCGrGfQ90cWo561Te6HK9D+j4KPdM6w==
   dependencies:
-    cipher-base "^1.0.3"
-    create-hash "^1.1.0"
-    inherits "^2.0.1"
-    ripemd160 "^2.0.0"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
+    crc-32 "^1.2.0"
+    readable-stream "^3.4.0"
 
 create-require@^1.1.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
   integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
 
+cross-fetch@3.1.5:
+  version "3.1.5"
+  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.1.5.tgz#e1389f44d9e7ba767907f7af8454787952ab534f"
+  integrity sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==
+  dependencies:
+    node-fetch "2.6.7"
+
 cross-spawn@^5.0.1:
   version "5.1.0"
   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-5.1.0.tgz#e8bd0efee58fcff6f8f94510a0a554bbfa235449"
@@ -2987,7 +3334,7 @@ cross-spawn@^5.0.1:
     shebang-command "^1.2.0"
     which "^1.2.9"
 
-cross-spawn@^6.0.0, cross-spawn@^6.0.5:
+cross-spawn@^6.0.0:
   version "6.0.5"
   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
   integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
@@ -2998,7 +3345,7 @@ cross-spawn@^6.0.0, cross-spawn@^6.0.5:
     shebang-command "^1.2.0"
     which "^1.2.9"
 
-cross-spawn@^7.0.2:
+cross-spawn@^7.0.2, cross-spawn@^7.0.3:
   version "7.0.3"
   resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
   integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
@@ -3007,22 +3354,15 @@ cross-spawn@^7.0.2:
     shebang-command "^2.0.0"
     which "^2.0.1"
 
-crypto-browserify@^3.11.0:
-  version "3.12.0"
-  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
-  integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
-  dependencies:
-    browserify-cipher "^1.0.0"
-    browserify-sign "^4.0.0"
-    create-ecdh "^4.0.0"
-    create-hash "^1.1.0"
-    create-hmac "^1.1.0"
-    diffie-hellman "^5.0.0"
-    inherits "^2.0.1"
-    pbkdf2 "^3.0.3"
-    public-encrypt "^4.0.0"
-    randombytes "^2.0.0"
-    randomfill "^1.0.3"
+css-shorthand-properties@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/css-shorthand-properties/-/css-shorthand-properties-1.1.1.tgz#1c808e63553c283f289f2dd56fcee8f3337bd935"
+  integrity sha512-Md+Juc7M3uOdbAFwOYlTrccIZ7oCFuzrhKYQjdeUEW/sE1hv17Jp/Bws+ReOPpGVBTYCBoYo+G17V5Qo8QQ75A==
+
+css-value@^0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/css-value/-/css-value-0.0.1.tgz#5efd6c2eea5ea1fd6b6ac57ec0427b18452424ea"
+  integrity sha1-Xv1sLupeof1rasV+wEJ7GEUkJOo=
 
 css@~2.2.1:
   version "2.2.4"
@@ -3034,52 +3374,43 @@ css@~2.2.1:
     source-map-resolve "^0.5.2"
     urix "^0.1.0"
 
-currently-unhandled@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/currently-unhandled/-/currently-unhandled-0.4.1.tgz#988df33feab191ef799a61369dd76c17adf957ea"
-  integrity sha1-mI3zP+qxke95mmE2nddsF635V+o=
-  dependencies:
-    array-find-index "^1.0.1"
-
 custom-event@~1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/custom-event/-/custom-event-1.0.1.tgz#5d02a46850adf1b4a317946a3928fccb5bfd0425"
   integrity sha1-XQKkaFCt8bSjF5RqOSj8y1v9BCU=
 
-cyclist@~0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/cyclist/-/cyclist-0.2.2.tgz#1b33792e11e914a2fd6d6ed6447464444e5fa640"
-  integrity sha1-GzN5LhHpFKL9bW7WRHRkRE5fpkA=
-
-cz-conventional-changelog@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-2.0.0.tgz#55a979afdfe95e7024879d2a0f5924630170b533"
-  integrity sha1-Val5r9/pXnAkh50qD1kkYwFwtTM=
+cz-conventional-changelog@3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-3.2.0.tgz#6aef1f892d64113343d7e455529089ac9f20e477"
+  integrity sha512-yAYxeGpVi27hqIilG1nh4A9Bnx4J3Ov+eXy4koL3drrR+IO9GaWPsKjik20ht608Asqi8TQPf0mczhEeyAtMzg==
   dependencies:
-    conventional-commit-types "^2.0.0"
+    chalk "^2.4.1"
+    commitizen "^4.0.3"
+    conventional-commit-types "^3.0.0"
     lodash.map "^4.5.1"
-    longest "^1.0.1"
-    pad-right "^0.2.2"
-    right-pad "^1.0.1"
+    longest "^2.0.1"
     word-wrap "^1.0.3"
+  optionalDependencies:
+    "@commitlint/load" ">6.1.1"
 
-cz-conventional-changelog@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-2.1.0.tgz#2f4bc7390e3244e4df293e6ba351e4c740a7c764"
-  integrity sha1-L0vHOQ4yROTfKT5ro1Hkx0Cnx2Q=
+cz-conventional-changelog@^3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-3.3.0.tgz#9246947c90404149b3fe2cf7ee91acad3b7d22d2"
+  integrity sha512-U466fIzU5U22eES5lTNiNbZ+d8dfcHcssH4o7QsdWaCcRs/feIPCxKYSWkYBNs5mny7MvEfwpTLWjvbm94hecw==
   dependencies:
-    conventional-commit-types "^2.0.0"
+    chalk "^2.4.1"
+    commitizen "^4.0.3"
+    conventional-commit-types "^3.0.0"
     lodash.map "^4.5.1"
-    longest "^1.0.1"
-    right-pad "^1.0.1"
+    longest "^2.0.1"
     word-wrap "^1.0.3"
+  optionalDependencies:
+    "@commitlint/load" ">6.1.1"
 
-dargs@^4.0.1:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/dargs/-/dargs-4.1.0.tgz#03a9dbb4b5c2f139bf14ae53f0b8a2a6a86f4e17"
-  integrity sha1-A6nbtLXC8Tm/FK5T8LiipqhvThc=
-  dependencies:
-    number-is-nan "^1.0.0"
+dargs@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc"
+  integrity sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==
 
 dashdash@^1.12.0:
   version "1.14.1"
@@ -3088,33 +3419,10 @@ dashdash@^1.12.0:
   dependencies:
     assert-plus "^1.0.0"
 
-data-uri-to-buffer@1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/data-uri-to-buffer/-/data-uri-to-buffer-1.2.0.tgz#77163ea9c20d8641b4707e8f18abdf9a78f34835"
-  integrity sha512-vKQ9DTQPN1FLYiiEEOQ6IBGFqvjCa5rSK3cWMy/Nespm5d/x3dGFT9UBZnkLxCwua/IXBi2TYnwTEpsOvhC4UQ==
-
-date-fns@^1.27.2:
-  version "1.30.1"
-  resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-1.30.1.tgz#2e71bf0b119153dbb4cc4e88d9ea5acfb50dc05c"
-  integrity sha512-hBSVCvSmWC+QypYObzwGOd9wqdDpOt+0wl0KbU+R+uuZBS1jN8VsD1ss3irQDknRj5NvxiTF6oj/nDRnN/UQNw==
-
-date-format@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/date-format/-/date-format-1.2.0.tgz#615e828e233dd1ab9bb9ae0950e0ceccfa6ecad8"
-  integrity sha1-YV6CjiM90aubua4JUODOzPpuytg=
-
-date-now@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/date-now/-/date-now-0.1.4.tgz#eaf439fd4d4848ad74e5cc7dbef200672b9e345b"
-  integrity sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=
-
-dateformat@^1.0.6:
-  version "1.0.12"
-  resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-1.0.12.tgz#9f124b67594c937ff706932e4a642cca8dbbfee9"
-  integrity sha1-nxJLZ1lMk3/3BpMuSmQsyo27/uk=
-  dependencies:
-    get-stdin "^4.0.1"
-    meow "^3.3.0"
+date-format@^4.0.9:
+  version "4.0.9"
+  resolved "https://registry.yarnpkg.com/date-format/-/date-format-4.0.9.tgz#4788015ac56dedebe83b03bc361f00c1ddcf1923"
+  integrity sha512-+8J+BOUpSrlKLQLeF8xJJVTxS8QfRSuJgwxSVvslzgO3E6khbI0F5mMEPf5mTYhCCm4h99knYP6H3W9n3BQFrg==
 
 dateformat@^3.0.0:
   version "3.0.3"
@@ -3126,19 +3434,19 @@ de-indent@^1.0.2:
   resolved "https://registry.yarnpkg.com/de-indent/-/de-indent-1.0.2.tgz#b2038e846dc33baa5796128d0804b455b8c1e21d"
   integrity sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=
 
-debug@2, debug@2.6.9, debug@^2.1.2, debug@^2.2.0, debug@^2.3.3, debug@^2.6.8:
+debug@2.6.9, debug@^2.6.8, debug@^2.6.9:
   version "2.6.9"
   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
   dependencies:
     ms "2.0.0"
 
-debug@2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.2.0.tgz#f87057e995b1a1f6ae6a4960664137bc56f039da"
-  integrity sha1-+HBX6ZWxofauaklgZkE3vFbwOdo=
+debug@4, debug@4.3.4, debug@^4.3.2, debug@^4.3.3, debug@^4.3.4, debug@~4.3.1, debug@~4.3.2:
+  version "4.3.4"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
+  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
   dependencies:
-    ms "0.7.1"
+    ms "2.1.2"
 
 debug@4.1.0:
   version "4.1.0"
@@ -3147,12 +3455,12 @@ debug@4.1.0:
   dependencies:
     ms "^2.1.1"
 
-debug@^3.1.0:
-  version "3.2.6"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.6.tgz#e83d17de16d8a7efb7717edbe5fb10135eee629b"
-  integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==
+debug@4.3.3:
+  version "4.3.3"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.3.tgz#04266e0b70a98d4462e6e288e38259213332b664"
+  integrity sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q==
   dependencies:
-    ms "^2.1.1"
+    ms "2.1.2"
 
 debug@^3.1.1:
   version "3.2.7"
@@ -3161,13 +3469,6 @@ debug@^3.1.1:
   dependencies:
     ms "^2.1.1"
 
-debug@^4.0.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
-  integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==
-  dependencies:
-    ms "^2.1.1"
-
 debug@^4.1.0, debug@^4.1.1:
   version "4.3.1"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
@@ -3175,14 +3476,7 @@ debug@^4.1.0, debug@^4.1.1:
   dependencies:
     ms "2.1.2"
 
-debug@~3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.1.0.tgz#5bb5a0672628b64149566ba16819e61518c67261"
-  integrity sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==
-  dependencies:
-    ms "2.0.0"
-
-decamelize-keys@^1.0.0:
+decamelize-keys@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9"
   integrity sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=
@@ -3190,164 +3484,218 @@ decamelize-keys@^1.0.0:
     decamelize "^1.1.0"
     map-obj "^1.0.0"
 
-decamelize@^1.1.0, decamelize@^1.1.2:
+decamelize@^1.1.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
 
+decamelize@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-4.0.0.tgz#aa472d7bf660eb15f3494efd531cab7f2a709837"
+  integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==
+
 decode-uri-component@^0.2.0:
   version "0.2.0"
   resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
   integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
 
-dedent@0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.6.0.tgz#0e6da8f0ce52838ef5cec5c8f9396b0c1b64a3cb"
-  integrity sha1-Dm2o8M5Sg471zsXI+TlrDBtko8s=
+decompress-response@^3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-3.3.0.tgz#80a4dd323748384bfa248083622aedec982adff3"
+  integrity sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=
+  dependencies:
+    mimic-response "^1.0.0"
+
+decompress-response@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-6.0.0.tgz#ca387612ddb7e104bd16d85aab00d5ecf09c66fc"
+  integrity sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==
+  dependencies:
+    mimic-response "^3.1.0"
 
-dedent@^0.7.0:
+decompress-tar@^4.0.0, decompress-tar@^4.1.0, decompress-tar@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/decompress-tar/-/decompress-tar-4.1.1.tgz#718cbd3fcb16209716e70a26b84e7ba4592e5af1"
+  integrity sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==
+  dependencies:
+    file-type "^5.2.0"
+    is-stream "^1.1.0"
+    tar-stream "^1.5.2"
+
+decompress-tarbz2@^4.0.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz#3082a5b880ea4043816349f378b56c516be1a39b"
+  integrity sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==
+  dependencies:
+    decompress-tar "^4.1.0"
+    file-type "^6.1.0"
+    is-stream "^1.1.0"
+    seek-bzip "^1.0.5"
+    unbzip2-stream "^1.0.9"
+
+decompress-targz@^4.0.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/decompress-targz/-/decompress-targz-4.1.1.tgz#c09bc35c4d11f3de09f2d2da53e9de23e7ce1eee"
+  integrity sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==
+  dependencies:
+    decompress-tar "^4.1.1"
+    file-type "^5.2.0"
+    is-stream "^1.1.0"
+
+decompress-unzip@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/decompress-unzip/-/decompress-unzip-4.0.1.tgz#deaaccdfd14aeaf85578f733ae8210f9b4848f69"
+  integrity sha1-3qrM39FK6vhVePczroIQ+bSEj2k=
+  dependencies:
+    file-type "^3.8.0"
+    get-stream "^2.2.0"
+    pify "^2.3.0"
+    yauzl "^2.4.2"
+
+decompress@^4.2.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/decompress/-/decompress-4.2.1.tgz#007f55cc6a62c055afa37c07eb6a4ee1b773f118"
+  integrity sha512-e48kc2IjU+2Zw8cTb6VZcJQ3lgVbS4uuB1TfCHbiZIP/haNXm+SVyhu+87jts5/3ROpd82GSVCoNs/z8l4ZOaQ==
+  dependencies:
+    decompress-tar "^4.0.0"
+    decompress-tarbz2 "^4.0.0"
+    decompress-targz "^4.0.0"
+    decompress-unzip "^4.0.1"
+    graceful-fs "^4.1.10"
+    make-dir "^1.0.0"
+    pify "^2.3.0"
+    strip-dirs "^2.0.0"
+
+dedent@0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
   integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=
 
-deep-eql@0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-0.1.3.tgz#ef558acab8de25206cd713906d74e56930eb69f2"
-  integrity sha1-71WKyrjeJSBs1xOQbXTlaTDrafI=
+deep-eql@4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-4.0.1.tgz#2b65bc89491d193780c452edee2144a91bb0a445"
+  integrity sha512-D/Oxqobjr+kxaHsgiQBZq9b6iAWdEj5W/JdJm8deNduAPc9CwXQ3BJJCuEqlrPXcy45iOMkGPZ0T81Dnz7UDCA==
   dependencies:
-    type-detect "0.1.1"
-
-deep-extend@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
-  integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
+    type-detect "^4.0.0"
 
 deep-is@^0.1.3, deep-is@~0.1.3:
   version "0.1.3"
   resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
   integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
 
-deepmerge@^4.2.2:
+deepmerge@^4.0.0, deepmerge@^4.2.2:
   version "4.2.2"
   resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955"
   integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==
 
-define-properties@^1.1.2, define-properties@^1.1.3:
+defaults@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/defaults/-/defaults-1.0.3.tgz#c656051e9817d9ff08ed881477f3fe4019f3ef7d"
+  integrity sha1-xlYFHpgX2f8I7YgUd/P+QBnz730=
+  dependencies:
+    clone "^1.0.2"
+
+defer-to-connect@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/defer-to-connect/-/defer-to-connect-2.0.1.tgz#8016bdb4143e4632b77a3449c6236277de520587"
+  integrity sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==
+
+define-properties@^1.1.3:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1"
   integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==
   dependencies:
     object-keys "^1.0.12"
 
-define-property@^0.2.5:
-  version "0.2.5"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116"
-  integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=
-  dependencies:
-    is-descriptor "^0.1.0"
-
-define-property@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6"
-  integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY=
-  dependencies:
-    is-descriptor "^1.0.0"
-
-define-property@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/define-property/-/define-property-2.0.2.tgz#d459689e8d654ba77e02a817f8710d702cb16e9d"
-  integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==
-  dependencies:
-    is-descriptor "^1.0.2"
-    isobject "^3.0.1"
-
-degenerator@~1.0.2:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/degenerator/-/degenerator-1.0.4.tgz#fcf490a37ece266464d9cc431ab98c5819ced095"
-  integrity sha1-/PSQo37OJmRk2cxDGrmMWBnO0JU=
-  dependencies:
-    ast-types "0.x.x"
-    escodegen "1.x.x"
-    esprima "3.x.x"
-
-del@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/del/-/del-3.0.0.tgz#53ecf699ffcbcb39637691ab13baf160819766e5"
-  integrity sha1-U+z2mf/LyzljdpGrE7rxYIGXZuU=
+del@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/del/-/del-6.0.0.tgz#0b40d0332cea743f1614f818be4feb717714c952"
+  integrity sha512-1shh9DQ23L16oXSZKB2JxpL7iMy2E0S9d517ptA1P8iw0alkPtQcrKH7ru31rYtKwF499HkTu+DRzq3TCKDFRQ==
   dependencies:
-    globby "^6.1.0"
-    is-path-cwd "^1.0.0"
-    is-path-in-cwd "^1.0.0"
-    p-map "^1.1.1"
-    pify "^3.0.0"
-    rimraf "^2.2.8"
+    globby "^11.0.1"
+    graceful-fs "^4.2.4"
+    is-glob "^4.0.1"
+    is-path-cwd "^2.2.0"
+    is-path-inside "^3.0.2"
+    p-map "^4.0.0"
+    rimraf "^3.0.2"
+    slash "^3.0.0"
 
 delayed-stream@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
   integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
 
-delegates@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delegates/-/delegates-1.0.0.tgz#84c6e159b81904fdca59a0ef44cd870d31250f9a"
-  integrity sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o=
+depd@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
+  integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
 
-depd@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9"
-  integrity sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=
+destroy@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015"
+  integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==
 
-des.js@^1.0.0:
+detect-file@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.0.tgz#c074d2e2aa6a8a9a07dbd61f9a15c2cd83ec8ecc"
-  integrity sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=
-  dependencies:
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-
-detect-file@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-0.1.0.tgz#4935dedfd9488648e006b0129566e9386711ea63"
-  integrity sha1-STXe39lIhkjgBrASlWbpOGcR6mM=
-  dependencies:
-    fs-exists-sync "^0.1.0"
+  resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
+  integrity sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=
 
-detect-indent@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-4.0.0.tgz#f76d064352cdf43a1cb6ce619c4ee3a9475de208"
-  integrity sha1-920GQ1LN9Docts5hnE7jqUdd4gg=
-  dependencies:
-    repeating "^2.0.0"
+detect-indent@6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-6.0.0.tgz#0abd0f549f69fc6659a254fe96786186b6f528fd"
+  integrity sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==
 
-detect-libc@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-1.0.3.tgz#fa137c4bd698edf55cd5cd02ac559f91a4c4ba9b"
-  integrity sha1-+hN8S9aY7fVc1c0CrFWfkaTEups=
+detect-node@^2.0.4:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz#c9c70775a49c3d03bc2c06d9a73be550f978f8b1"
+  integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
+
+devtools-protocol@0.0.818844:
+  version "0.0.818844"
+  resolved "https://registry.yarnpkg.com/devtools-protocol/-/devtools-protocol-0.0.818844.tgz#d1947278ec85b53e4c8ca598f607a28fa785ba9e"
+  integrity sha512-AD1hi7iVJ8OD0aMLQU5VK0XH9LDlA1+BcPIgrAxPfaibx2DbWucuyOhc4oyQCbnvDDO68nN6/LcKfqTP343Jjg==
+
+devtools-protocol@0.0.981744:
+  version "0.0.981744"
+  resolved "https://registry.yarnpkg.com/devtools-protocol/-/devtools-protocol-0.0.981744.tgz#9960da0370284577d46c28979a0b32651022bacf"
+  integrity sha512-0cuGS8+jhR67Fy7qG3i3Pc7Aw494sb9yG9QgpG97SFVWwolgYjlhJg7n+UaHxOQT30d1TYu/EYe9k01ivLErIg==
+
+devtools@6.12.1:
+  version "6.12.1"
+  resolved "https://registry.yarnpkg.com/devtools/-/devtools-6.12.1.tgz#f0298c6d6f46d8d3b751dd8fa4a0c7bc76e1268f"
+  integrity sha512-JyG46suEiZmld7/UVeogkCWM0zYGt+2ML/TI+SkEp+bTv9cs46cDb0pKF3glYZJA7wVVL2gC07Ic0iCxyJEnCQ==
+  dependencies:
+    "@wdio/config" "6.12.1"
+    "@wdio/logger" "6.10.10"
+    "@wdio/protocols" "6.12.0"
+    "@wdio/utils" "6.11.0"
+    chrome-launcher "^0.13.1"
+    edge-paths "^2.1.0"
+    puppeteer-core "^5.1.0"
+    ua-parser-js "^0.7.21"
+    uuid "^8.0.0"
 
 di@^0.0.1:
   version "0.0.1"
   resolved "https://registry.yarnpkg.com/di/-/di-0.0.1.tgz#806649326ceaa7caa3306d75d985ea2748ba913c"
   integrity sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=
 
-diff@1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-1.4.0.tgz#7f28d2eb9ee7b15a97efd89ce63dcfdaa3ccbabf"
-  integrity sha1-fyjS657nsVqX79ic5j3P2qPMur8=
+didyoumean@1.2.2:
+  version "1.2.2"
+  resolved "https://registry.yarnpkg.com/didyoumean/-/didyoumean-1.2.2.tgz#989346ffe9e839b4555ecf5666edea0d3e8ad037"
+  integrity sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==
+
+diff@5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-5.0.0.tgz#7ed6ad76d859d030787ec35855f5b1daf31d852b"
+  integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==
 
 diff@^4.0.1:
   version "4.0.2"
   resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
   integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
 
-diffie-hellman@^5.0.0:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
-  integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==
-  dependencies:
-    bn.js "^4.1.0"
-    miller-rabin "^4.0.0"
-    randombytes "^2.0.0"
-
 dir-glob@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
@@ -3362,7 +3710,7 @@ doctrine@^3.0.0:
   dependencies:
     esutils "^2.0.2"
 
-dom-serialize@^2.2.0:
+dom-serialize@^2.2.1:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/dom-serialize/-/dom-serialize-2.2.1.tgz#562ae8999f44be5ea3076f5419dcd59eb43ac95b"
   integrity sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=
@@ -3372,27 +3720,53 @@ dom-serialize@^2.2.0:
     extend "^3.0.0"
     void-elements "^2.0.0"
 
-domain-browser@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-1.2.0.tgz#3d31f50191a6749dd1375a7f522e823d42e54eda"
-  integrity sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==
-
-dot-prop@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-3.0.0.tgz#1b708af094a49c9a0e7dbcad790aba539dac1177"
-  integrity sha1-G3CK8JSknJoOfbyteQq6U52sEXc=
+dot-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
+  integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
   dependencies:
-    is-obj "^1.0.0"
+    no-case "^3.0.4"
+    tslib "^2.0.3"
 
-duplexify@^3.4.2, duplexify@^3.6.0:
-  version "3.6.1"
-  resolved "https://registry.yarnpkg.com/duplexify/-/duplexify-3.6.1.tgz#b1a7a29c4abfd639585efaecce80d666b1e34125"
-  integrity sha512-vM58DwdnKmty+FSPzT14K9JXb90H+j5emaR4KYbr2KTIz00WHGbWOe5ghQTx233ZCLZtrGDALzKwcjEtSt35mA==
+dot-prop@^5.1.0:
+  version "5.3.0"
+  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88"
+  integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==
   dependencies:
-    end-of-stream "^1.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
-    stream-shift "^1.0.0"
+    is-obj "^2.0.0"
+
+dotenv@10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-10.0.0.tgz#3d4227b8fb95f81096cdd2b66653fb2c7085ba81"
+  integrity sha512-rlBi9d8jpv9Sf1klPjNfFAuWDjKLwTIJJ/VxtoTwIR6hnZxcEOQCZg2oIL3MWBYw5GpUDKOEnND7LXTbIpQ03Q==
+
+download@^7.1.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/download/-/download-7.1.0.tgz#9059aa9d70b503ee76a132897be6dec8e5587233"
+  integrity sha512-xqnBTVd/E+GxJVrX5/eUJiLYjCGPwMpdL+jGhGU57BvtcA7wwhtHVbXBeUk51kOpW3S7Jn3BQbN9Q1R1Km2qDQ==
+  dependencies:
+    archive-type "^4.0.0"
+    caw "^2.0.1"
+    content-disposition "^0.5.2"
+    decompress "^4.2.0"
+    ext-name "^5.0.0"
+    file-type "^8.1.0"
+    filenamify "^2.0.0"
+    get-stream "^3.0.0"
+    got "^8.3.1"
+    make-dir "^1.2.0"
+    p-event "^2.1.0"
+    pify "^3.0.0"
+
+duplexer3@^0.1.4:
+  version "0.1.4"
+  resolved "https://registry.yarnpkg.com/duplexer3/-/duplexer3-0.1.4.tgz#ee01dd1cac0ed3cbc7fdbea37dc0a8f1ce002ce2"
+  integrity sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=
+
+eastasianwidth@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
+  integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
 
 ecc-jsbn@~0.1.1:
   version "0.1.2"
@@ -3402,76 +3776,49 @@ ecc-jsbn@~0.1.1:
     jsbn "~0.1.0"
     safer-buffer "^2.1.0"
 
-ecstatic@^3.3.2:
-  version "3.3.2"
-  resolved "https://registry.yarnpkg.com/ecstatic/-/ecstatic-3.3.2.tgz#6d1dd49814d00594682c652adb66076a69d46c48"
-  integrity sha512-fLf9l1hnwrHI2xn9mEDT7KIi22UDqA2jaCwyCbSUJh9a1V+LEUSL/JO/6TIz/QyuBURWUHrFL5Kg2TtO1bkkog==
+edge-paths@^2.1.0:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/edge-paths/-/edge-paths-2.2.1.tgz#d2d91513225c06514aeac9843bfce546abbf4391"
+  integrity sha512-AI5fC7dfDmCdKo3m5y7PkYE8m6bMqR6pvVpgtrZkkhcJXFLelUgkjrhk3kXXx8Kbw2cRaTT4LkOR7hqf39KJdw==
   dependencies:
-    he "^1.1.1"
-    mime "^1.6.0"
-    minimist "^1.1.0"
-    url-join "^2.0.5"
+    "@types/which" "^1.3.2"
+    which "^2.0.2"
 
 ee-first@1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
   integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
 
-ejs@2.5.7:
-  version "2.5.7"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-2.5.7.tgz#cc872c168880ae3c7189762fd5ffc00896c9518a"
-  integrity sha1-zIcsFoiArjxxiXYv1f/ACJbJUYo=
-
 electron-to-chromium@^1.3.649:
   version "1.3.709"
   resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.709.tgz#d7be0b5686a2fdfe8bad898faa3a428d04d8f656"
   integrity sha512-LolItk2/ikSGQ7SN8UkuKVNMBZp3RG7Itgaxj1npsHRzQobj9JjMneZOZfLhtwlYBe5fCJ75k+cVCiDFUs23oA==
 
-elegant-spinner@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/elegant-spinner/-/elegant-spinner-1.0.1.tgz#db043521c95d7e303fd8f345bedc3349cfb0729e"
-  integrity sha1-2wQ1IcldfjA/2PNFvtwzSc+wcp4=
-
-elliptic@^6.0.0:
-  version "6.5.4"
-  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
-  integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
-  dependencies:
-    bn.js "^4.11.9"
-    brorand "^1.1.0"
-    hash.js "^1.0.0"
-    hmac-drbg "^1.0.1"
-    inherits "^2.0.4"
-    minimalistic-assert "^1.0.1"
-    minimalistic-crypto-utils "^1.0.1"
+electron-to-chromium@^1.4.118:
+  version "1.4.127"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.127.tgz#4ef19d5d920abe2676d938f4170729b44f7f423a"
+  integrity sha512-nhD6S8nKI0O2MueC6blNOEZio+/PWppE/pevnf3LOlQA/fKPCrDp2Ao4wx4LFwmIkJpVdFdn2763YWLy9ENIZg==
 
 emoji-regex@^8.0.0:
   version "8.0.0"
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
-emojis-list@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-2.1.0.tgz#4daa4d9db00f9819880c79fa457ae5b09a1fd389"
-  integrity sha1-TapNnbAPmBmIDHn6RXrlsJof04k=
+emoji-regex@^9.2.2:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
+  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
 emojis-list@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
   integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
 
-encodeurl@~1.0.1:
+encodeurl@~1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
   integrity sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=
 
-encoding@^0.1.11:
-  version "0.1.12"
-  resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.12.tgz#538b66f3ee62cd1ab51ec323829d1f9480c74beb"
-  integrity sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=
-  dependencies:
-    iconv-lite "~0.4.13"
-
 end-of-stream@^1.0.0, end-of-stream@^1.1.0:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.1.tgz#ed29634d19baba463b6ce6b80a37213eab71ec43"
@@ -3479,127 +3826,80 @@ end-of-stream@^1.0.0, end-of-stream@^1.1.0:
   dependencies:
     once "^1.4.0"
 
-engine.io-client@~3.2.0:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/engine.io-client/-/engine.io-client-3.2.1.tgz#6f54c0475de487158a1a7c77d10178708b6add36"
-  integrity sha512-y5AbkytWeM4jQr7m/koQLc5AxpRKC1hEVUb/s1FUAWEJq5AzJJ4NLvzuKPuxtDi5Mq755WuDvZ6Iv2rXj4PTzw==
-  dependencies:
-    component-emitter "1.2.1"
-    component-inherit "0.0.3"
-    debug "~3.1.0"
-    engine.io-parser "~2.1.1"
-    has-cors "1.1.0"
-    indexof "0.0.1"
-    parseqs "0.0.5"
-    parseuri "0.0.5"
-    ws "~3.3.1"
-    xmlhttprequest-ssl "~1.5.4"
-    yeast "0.1.2"
-
-engine.io-parser@~2.1.0, engine.io-parser@~2.1.1:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-2.1.3.tgz#757ab970fbf2dfb32c7b74b033216d5739ef79a6"
-  integrity sha512-6HXPre2O4Houl7c4g7Ic/XzPnHBvaEmN90vtRO9uLmwtRqQmTOw0QMevL1TOfL2Cpu1VzsaTmMotQgMdkzGkVA==
-  dependencies:
-    after "0.8.2"
-    arraybuffer.slice "~0.0.7"
-    base64-arraybuffer "0.1.5"
-    blob "0.0.5"
-    has-binary2 "~1.0.2"
-
-engine.io@~3.2.0:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/engine.io/-/engine.io-3.2.1.tgz#b60281c35484a70ee0351ea0ebff83ec8c9522a2"
-  integrity sha512-+VlKzHzMhaU+GsCIg4AoXF1UdDFjHHwMmMKqMJNDNLlUlejz58FCy4LBqB2YVJskHGYl06BatYWKP2TVdVXE5w==
+end-of-stream@^1.4.1:
+  version "1.4.4"
+  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
+  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
   dependencies:
-    accepts "~1.3.4"
-    base64id "1.0.0"
-    cookie "0.3.1"
-    debug "~3.1.0"
-    engine.io-parser "~2.1.0"
-    ws "~3.3.1"
+    once "^1.4.0"
 
-enhanced-resolve@^4.0.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.5.0.tgz#2f3cfd84dbe3b487f18f2db2ef1e064a571ca5ec"
-  integrity sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==
+engine.io-parser@~5.0.3:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-5.0.3.tgz#ca1f0d7b11e290b4bfda251803baea765ed89c09"
+  integrity sha512-BtQxwF27XUNnSafQLvDi0dQ8s3i6VgzSoQMJacpIcGNrlUdfHSKbgm3jmjCVvQluGzqwujQMPAoMai3oYSTurg==
   dependencies:
-    graceful-fs "^4.1.2"
-    memory-fs "^0.5.0"
-    tapable "^1.0.0"
+    "@socket.io/base64-arraybuffer" "~1.0.2"
 
-enhanced-resolve@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-4.1.0.tgz#41c7e0bfdfe74ac1ffe1e57ad6a5c6c9f3742a7f"
-  integrity sha512-F/7vkyTtyc/llOIn8oWclcB25KdRaiPBpZYDgJHgh/UHtpgT2p2eldQgtQnLtUvfMKPKxbRaQM/hHkvLHt1Vng==
+engine.io@~6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/engine.io/-/engine.io-6.2.0.tgz#003bec48f6815926f2b1b17873e576acd54f41d0"
+  integrity sha512-4KzwW3F3bk+KlzSOY57fj/Jx6LyRQ1nbcyIadehl+AnXjKT7gDO0ORdRi/84ixvMKTym6ZKuxvbzN62HDDU1Lg==
   dependencies:
-    graceful-fs "^4.1.2"
-    memory-fs "^0.4.0"
-    tapable "^1.0.0"
+    "@types/cookie" "^0.4.1"
+    "@types/cors" "^2.8.12"
+    "@types/node" ">=10.0.0"
+    accepts "~1.3.4"
+    base64id "2.0.0"
+    cookie "~0.4.1"
+    cors "~2.8.5"
+    debug "~4.3.1"
+    engine.io-parser "~5.0.3"
+    ws "~8.2.3"
 
-enquirer@^2.3.5:
-  version "2.3.6"
-  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
-  integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
+enhanced-resolve@^5.0.0, enhanced-resolve@^5.9.2:
+  version "5.9.3"
+  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.9.3.tgz#44a342c012cbc473254af5cc6ae20ebd0aae5d88"
+  integrity sha512-Bq9VSor+kjvW3f9/MiiR4eE3XYgOl7/rS8lnSxbRbF3kS0B2r+Y9w5krBWxZgDxASVZbdYrn5wT4j/Wb0J9qow==
   dependencies:
-    ansi-colors "^4.1.1"
+    graceful-fs "^4.2.4"
+    tapable "^2.2.0"
 
 ent@~2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/ent/-/ent-2.2.0.tgz#e964219325a21d05f44466a2f686ed6ce5f5dd1d"
   integrity sha1-6WQhkyWiHQX0RGai9obtbOX13R0=
 
-errno@^0.1.3, errno@~0.1.7:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/errno/-/errno-0.1.7.tgz#4684d71779ad39af177e3f007996f7c67c852618"
-  integrity sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==
-  dependencies:
-    prr "~1.0.1"
+envinfo@7.8.1:
+  version "7.8.1"
+  resolved "https://registry.yarnpkg.com/envinfo/-/envinfo-7.8.1.tgz#06377e3e5f4d379fea7ac592d5ad8927e0c4d475"
+  integrity sha512-/o+BXHmB7ocbHEAs6F2EnG0ogybVVUdkRunTT2glZU9XAaGmhqskrvKwqXuDfNjEO0LZKWdejEEpnq8aM0tOaw==
 
-error-ex@^1.2.0, error-ex@^1.3.1:
+error-ex@^1.3.1:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
   integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
   dependencies:
     is-arrayish "^0.2.1"
 
-es-abstract@^1.5.1:
-  version "1.13.0"
-  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.13.0.tgz#ac86145fdd5099d8dd49558ccba2eaf9b88e24e9"
-  integrity sha512-vDZfg/ykNxQVwup/8E1BZhVzFfBxs9NqMzGcvIJrqg5k2/5Za2bWo40dK2J1pgLngZ7c+Shh8lwYtLGyrwPutg==
-  dependencies:
-    es-to-primitive "^1.2.0"
-    function-bind "^1.1.1"
-    has "^1.0.3"
-    is-callable "^1.1.4"
-    is-regex "^1.0.4"
-    object-keys "^1.0.12"
+es-module-lexer@^0.9.0:
+  version "0.9.3"
+  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-0.9.3.tgz#6f13db00cc38417137daf74366f535c8eb438f19"
+  integrity sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==
 
-es-to-primitive@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.0.tgz#edf72478033456e8dda8ef09e00ad9650707f377"
-  integrity sha512-qZryBOJjV//LaxLTV6UC//WewneB3LcXOL9NP++ozKVXsIIIpm/2c13UDiD9Jp2eThsecw9m3jPqDwTyobcdbg==
-  dependencies:
-    is-callable "^1.1.4"
-    is-date-object "^1.0.1"
-    is-symbol "^1.0.2"
+es6-error@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"
+  integrity sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==
 
-es6-promise@^4.0.3, es6-promise@^4.1.0:
+es6-promise@^4.0.3:
   version "4.2.5"
   resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.5.tgz#da6d0d5692efb461e082c14817fe2427d8f5d054"
   integrity sha512-n6wvpdE43VFtJq+lUDYDBFUwV8TZbuGXLV4D6wKafg13ldznKsyEvatubnmUe31zcvelSzOHF+XbaT+Bl9ObDg==
 
-es6-promise@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-3.0.2.tgz#010d5858423a5f118979665f46486a95c6ee2bb6"
-  integrity sha1-AQ1YWEI6XxGJeWZfRkhqlcbuK7Y=
-
-es6-promisify@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/es6-promisify/-/es6-promisify-5.0.0.tgz#5109d62f3e56ea967c4b63505aef08291c8a5203"
-  integrity sha1-UQnWLz5W6pZ8S2NQWu8IKRyKUgM=
-  dependencies:
-    es6-promise "^4.0.3"
+es6-promise@^4.2.8:
+  version "4.2.8"
+  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
+  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
 
 escalade@^3.1.1:
   version "3.1.1"
@@ -3611,64 +3911,42 @@ escape-html@~1.0.3:
   resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
   integrity sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=
 
-escape-string-regexp@1.0.5, escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.4, escape-string-regexp@^1.0.5:
+escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
+  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
+
+escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
   integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
 
-escodegen@1.8.x:
-  version "1.8.1"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.8.1.tgz#5a5b53af4693110bebb0867aa3430dd3b70a1018"
-  integrity sha1-WltTr0aTEQvrsIZ6o0MN07cKEBg=
-  dependencies:
-    esprima "^2.7.1"
-    estraverse "^1.9.1"
-    esutils "^2.0.2"
-    optionator "^0.8.1"
-  optionalDependencies:
-    source-map "~0.2.0"
-
-escodegen@1.x.x, escodegen@^1.8.1:
-  version "1.11.0"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.11.0.tgz#b27a9389481d5bfd5bec76f7bb1eb3f8f4556589"
-  integrity sha512-IeMV45ReixHS53K/OmfKAIztN/igDHzTJUhZM3k1jMhIZWjk45SMwAtBsEXiJp3vSPmTcu6CXn7mDvFHRN66fw==
+escodegen@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.0.0.tgz#5e32b12833e8aa8fa35e1bf0befa89380484c7dd"
+  integrity sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw==
   dependencies:
-    esprima "^3.1.3"
-    estraverse "^4.2.0"
+    esprima "^4.0.1"
+    estraverse "^5.2.0"
     esutils "^2.0.2"
     optionator "^0.8.1"
   optionalDependencies:
     source-map "~0.6.1"
 
-eslint-plugin-flowtype@^2.34.0:
-  version "2.50.3"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-flowtype/-/eslint-plugin-flowtype-2.50.3.tgz#61379d6dce1d010370acd6681740fd913d68175f"
-  integrity sha512-X+AoKVOr7Re0ko/yEXyM5SSZ0tazc6ffdIOocp2fFUlWoDt7DV0Bz99mngOkAFLOAWjqRA5jPwqUCbrx13XoxQ==
-  dependencies:
-    lodash "^4.17.10"
-
-eslint-plugin-jasmine@^2.8.4:
-  version "2.10.1"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-jasmine/-/eslint-plugin-jasmine-2.10.1.tgz#5733b709e751f4bc40e31e1c16989bd2cdfbec97"
-  integrity sha1-VzO3CedR9LxA4x4cFpib0s377Jc=
-
-eslint-scope@3.7.1:
-  version "3.7.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-3.7.1.tgz#3d63c3edfda02e06e01a452ad88caacc7cdcb6e8"
-  integrity sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=
+eslint-plugin-flowtype@^8.0.3:
+  version "8.0.3"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-flowtype/-/eslint-plugin-flowtype-8.0.3.tgz#e1557e37118f24734aa3122e7536a038d34a4912"
+  integrity sha512-dX8l6qUL6O+fYPtpNRideCFSpmWOUVx5QcaGLVqe/vlDiBSe4vYljDWDETwnyFzpl7By/WVIu6rcrniCgH9BqQ==
   dependencies:
-    esrecurse "^4.1.0"
-    estraverse "^4.1.1"
+    lodash "^4.17.21"
+    string-natural-compare "^3.0.1"
 
-eslint-scope@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-4.0.0.tgz#50bf3071e9338bcdc43331794a0cb533f0136172"
-  integrity sha512-1G6UTDi7Jc1ELFwnR58HV4fK9OQK4S6N985f166xqXxpjU6plxFISJa2Ba9KCQuFa8RCnj/lSFJbHo7UFDBnUA==
-  dependencies:
-    esrecurse "^4.1.0"
-    estraverse "^4.1.1"
+eslint-plugin-jasmine@^4.1.3:
+  version "4.1.3"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-jasmine/-/eslint-plugin-jasmine-4.1.3.tgz#c4ced986a61dd5b180982bafe6da1cbac0941c52"
+  integrity sha512-q8j8KnLH/4uwmPELFZvEyfEcuCuGxXScJaRdqHjOjz064GcfX6aoFbzy5VohZ5QYk2+WvoqMoqDSb9nRLf89GQ==
 
-eslint-scope@^5.0.0, eslint-scope@^5.1.1:
+eslint-scope@5.1.1, eslint-scope@^5.1.1:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
   integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
@@ -3676,91 +3954,87 @@ eslint-scope@^5.0.0, eslint-scope@^5.1.1:
     esrecurse "^4.3.0"
     estraverse "^4.1.1"
 
-eslint-utils@^2.0.0, eslint-utils@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-2.1.0.tgz#d2de5e03424e707dc10c74068ddedae708741b27"
-  integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==
+eslint-scope@^7.1.1:
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.1.1.tgz#fff34894c2f65e5226d3041ac480b4513a163642"
+  integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==
+  dependencies:
+    esrecurse "^4.3.0"
+    estraverse "^5.2.0"
+
+eslint-utils@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672"
+  integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==
   dependencies:
-    eslint-visitor-keys "^1.1.0"
+    eslint-visitor-keys "^2.0.0"
 
 eslint-visitor-keys@^1.0.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz#e2a82cea84ff246ad6fb57f9bde5b46621459ec2"
   integrity sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==
 
-eslint-visitor-keys@^1.1.0, eslint-visitor-keys@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e"
-  integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==
-
 eslint-visitor-keys@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.0.0.tgz#21fdc8fbcd9c795cc0321f0563702095751511a8"
   integrity sha512-QudtT6av5WXels9WjIM7qz1XD1cWGvX4gGXvp/zBn9nXG02D0utdU3Em2m/QjTnrsk6bBjmCygl3rmj118msQQ==
 
-eslint@^7.23.0:
-  version "7.23.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.23.0.tgz#8d029d252f6e8cf45894b4bee08f5493f8e94325"
-  integrity sha512-kqvNVbdkjzpFy0XOszNwjkKzZ+6TcwCQ/h+ozlcIWwaimBBuhlQ4nN6kbiM2L+OjDcznkTJxzYfRFH92sx4a0Q==
+eslint-visitor-keys@^3.0.0, eslint-visitor-keys@^3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826"
+  integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==
+
+eslint@^8.14.0:
+  version "8.14.0"
+  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.14.0.tgz#62741f159d9eb4a79695b28ec4989fcdec623239"
+  integrity sha512-3/CE4aJX7LNEiE3i6FeodHmI/38GZtWCsAtsymScmzYapx8q1nVVb+eLcLSzATmCPXw5pT4TqVs1E0OmxAd9tw==
   dependencies:
-    "@babel/code-frame" "7.12.11"
-    "@eslint/eslintrc" "^0.4.0"
+    "@eslint/eslintrc" "^1.2.2"
+    "@humanwhocodes/config-array" "^0.9.2"
     ajv "^6.10.0"
     chalk "^4.0.0"
     cross-spawn "^7.0.2"
-    debug "^4.0.1"
+    debug "^4.3.2"
     doctrine "^3.0.0"
-    enquirer "^2.3.5"
-    eslint-scope "^5.1.1"
-    eslint-utils "^2.1.0"
-    eslint-visitor-keys "^2.0.0"
-    espree "^7.3.1"
+    escape-string-regexp "^4.0.0"
+    eslint-scope "^7.1.1"
+    eslint-utils "^3.0.0"
+    eslint-visitor-keys "^3.3.0"
+    espree "^9.3.1"
     esquery "^1.4.0"
     esutils "^2.0.2"
+    fast-deep-equal "^3.1.3"
     file-entry-cache "^6.0.1"
     functional-red-black-tree "^1.0.1"
-    glob-parent "^5.0.0"
+    glob-parent "^6.0.1"
     globals "^13.6.0"
-    ignore "^4.0.6"
+    ignore "^5.2.0"
     import-fresh "^3.0.0"
     imurmurhash "^0.1.4"
     is-glob "^4.0.0"
-    js-yaml "^3.13.1"
+    js-yaml "^4.1.0"
     json-stable-stringify-without-jsonify "^1.0.1"
     levn "^0.4.1"
-    lodash "^4.17.21"
+    lodash.merge "^4.6.2"
     minimatch "^3.0.4"
     natural-compare "^1.4.0"
     optionator "^0.9.1"
-    progress "^2.0.0"
-    regexpp "^3.1.0"
-    semver "^7.2.1"
-    strip-ansi "^6.0.0"
+    regexpp "^3.2.0"
+    strip-ansi "^6.0.1"
     strip-json-comments "^3.1.0"
-    table "^6.0.4"
     text-table "^0.2.0"
     v8-compile-cache "^2.0.3"
 
-espree@^7.3.0, espree@^7.3.1:
-  version "7.3.1"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-7.3.1.tgz#f2df330b752c6f55019f8bd89b7660039c1bbbb6"
-  integrity sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g==
+espree@^9.3.1:
+  version "9.3.1"
+  resolved "https://registry.yarnpkg.com/espree/-/espree-9.3.1.tgz#8793b4bc27ea4c778c19908e0719e7b8f4115bcd"
+  integrity sha512-bvdyLmJMfwkV3NCRl5ZhJf22zBFo1y8bYh3VYb+bfzqNB4Je68P2sSuXyuFquzWLebHpNd2/d5uv7yoP9ISnGQ==
   dependencies:
-    acorn "^7.4.0"
+    acorn "^8.7.0"
     acorn-jsx "^5.3.1"
-    eslint-visitor-keys "^1.3.0"
+    eslint-visitor-keys "^3.3.0"
 
-esprima@2.7.x, esprima@^2.7.1:
-  version "2.7.3"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-2.7.3.tgz#96e3b70d5779f6ad49cd032673d1c312767ba581"
-  integrity sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=
-
-esprima@3.x.x, esprima@^3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-3.1.3.tgz#fdca51cee6133895e3c88d535ce49dbff62a4633"
-  integrity sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=
-
-esprima@^4.0.0:
+esprima@^4.0.0, esprima@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
@@ -3772,13 +4046,6 @@ esquery@^1.4.0:
   dependencies:
     estraverse "^5.1.0"
 
-esrecurse@^4.1.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.2.1.tgz#007a3b9fdbc2b3bb87e4879ea19c92fdbd3942cf"
-  integrity sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ==
-  dependencies:
-    estraverse "^4.1.0"
-
 esrecurse@^4.3.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
@@ -3786,12 +4053,7 @@ esrecurse@^4.3.0:
   dependencies:
     estraverse "^5.2.0"
 
-estraverse@^1.9.1:
-  version "1.9.3"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-1.9.3.tgz#af67f2dc922582415950926091a4005d29c9bb44"
-  integrity sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q=
-
-estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0:
+estraverse@^4.1.1:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13"
   integrity sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=
@@ -3821,18 +4083,23 @@ eventemitter3@^4.0.0:
   resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
   integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
 
-events@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/events/-/events-1.1.1.tgz#9ebdb7635ad099c70dcc4c2a1f5004288e8bd924"
-  integrity sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=
+events@^3.2.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
+  integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
-evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
-  integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
+execa@^0.7.0:
+  version "0.7.0"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-0.7.0.tgz#944becd34cc41ee32a63a9faf27ad5a65fc59777"
+  integrity sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=
   dependencies:
-    md5.js "^1.3.4"
-    safe-buffer "^5.1.1"
+    cross-spawn "^5.0.1"
+    get-stream "^3.0.0"
+    is-stream "^1.1.0"
+    npm-run-path "^2.0.0"
+    p-finally "^1.0.0"
+    signal-exit "^3.0.0"
+    strip-eof "^1.0.0"
 
 execa@^0.8.0:
   version "0.8.0"
@@ -3860,127 +4127,76 @@ execa@^1.0.0:
     signal-exit "^3.0.0"
     strip-eof "^1.0.0"
 
-exit-hook@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/exit-hook/-/exit-hook-1.1.1.tgz#f05ca233b48c05d54fff07765df8507e95c02ff8"
-  integrity sha1-8FyiM7SMBdVP/wd2XfhQfpXAL/g=
-
-exit@^0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
-  integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw=
-
-expand-braces@^0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/expand-braces/-/expand-braces-0.1.2.tgz#488b1d1d2451cb3d3a6b192cfc030f44c5855fea"
-  integrity sha1-SIsdHSRRyz06axks/AMPRMWFX+o=
-  dependencies:
-    array-slice "^0.2.3"
-    array-unique "^0.2.1"
-    braces "^0.1.2"
-
-expand-brackets@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b"
-  integrity sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=
-  dependencies:
-    is-posix-bracket "^0.1.0"
-
-expand-brackets@^2.1.4:
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622"
-  integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI=
-  dependencies:
-    debug "^2.3.3"
-    define-property "^0.2.5"
-    extend-shallow "^2.0.1"
-    posix-character-classes "^0.1.0"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.1"
-
-expand-range@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-0.1.1.tgz#4cb8eda0993ca56fa4f41fc42f3cbb4ccadff044"
-  integrity sha1-TLjtoJk8pW+k9B/ELzy7TMrf8EQ=
-  dependencies:
-    is-number "^0.1.1"
-    repeat-string "^0.2.2"
-
-expand-range@^1.8.1:
-  version "1.8.2"
-  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337"
-  integrity sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=
+execa@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
+  integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
+  dependencies:
+    cross-spawn "^7.0.3"
+    get-stream "^6.0.0"
+    human-signals "^2.1.0"
+    is-stream "^2.0.0"
+    merge-stream "^2.0.0"
+    npm-run-path "^4.0.1"
+    onetime "^5.1.2"
+    signal-exit "^3.0.3"
+    strip-final-newline "^2.0.0"
+
+executable@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/executable/-/executable-4.1.1.tgz#41532bff361d3e57af4d763b70582db18f5d133c"
+  integrity sha512-8iA79xD3uAch729dUG8xaaBBFGaEa0wdD2VkYLFHwlqosEj/jT66AzcreRDSgV7ehnNLBW2WR5jIXwGKjVdTLg==
   dependencies:
-    fill-range "^2.1.0"
+    pify "^2.2.0"
 
-expand-tilde@^1.2.2:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-1.2.2.tgz#0b81eba897e5a3d31d1c3d102f8f01441e559449"
-  integrity sha1-C4HrqJflo9MdHD0QL48BRB5VlEk=
+expand-tilde@^2.0.0, expand-tilde@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-2.0.2.tgz#97e801aa052df02454de46b02bf621642cdc8502"
+  integrity sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=
   dependencies:
-    os-homedir "^1.0.1"
+    homedir-polyfill "^1.0.1"
 
-extend-shallow@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f"
-  integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=
+ext-list@^2.0.0:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/ext-list/-/ext-list-2.2.2.tgz#0b98e64ed82f5acf0f2931babf69212ef52ddd37"
+  integrity sha512-u+SQgsubraE6zItfVA0tBuCBhfU9ogSRnsvygI7wht9TS510oLkBRXBsqopeUG/GBOIQyKZO9wjTqIu/sf5zFA==
   dependencies:
-    is-extendable "^0.1.0"
+    mime-db "^1.28.0"
 
-extend-shallow@^3.0.0, extend-shallow@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
-  integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=
+ext-name@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/ext-name/-/ext-name-5.0.0.tgz#70781981d183ee15d13993c8822045c506c8f0a6"
+  integrity sha512-yblEwXAbGv1VQDmow7s38W77hzAgJAO50ztBLMcUyUBfxv1HC+LGwtiEN+Co6LtlqT/5uwVOxsD4TNIilWhwdQ==
   dependencies:
-    assign-symbols "^1.0.0"
-    is-extendable "^1.0.1"
+    ext-list "^2.0.0"
+    sort-keys-length "^1.0.0"
 
-extend@3, extend@^3.0.0, extend@~3.0.0, extend@~3.0.2:
+extend@^3.0.0, extend@~3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
   integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
 
-external-editor@^1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-1.1.1.tgz#12d7b0db850f7ff7e7081baf4005700060c4600b"
-  integrity sha1-Etew24UPf/fnCBuvQAVwAGDEYAs=
-  dependencies:
-    extend "^3.0.0"
-    spawn-sync "^1.0.15"
-    tmp "^0.0.29"
-
-external-editor@^2.0.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-2.2.0.tgz#045511cfd8d133f3846673d1047c154e214ad3d5"
-  integrity sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==
+external-editor@^3.0.3:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495"
+  integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==
   dependencies:
-    chardet "^0.4.0"
-    iconv-lite "^0.4.17"
+    chardet "^0.7.0"
+    iconv-lite "^0.4.24"
     tmp "^0.0.33"
 
-extglob@^0.3.1:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1"
-  integrity sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=
+extract-zip@2.0.1, extract-zip@^2.0.0, extract-zip@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-2.0.1.tgz#663dca56fe46df890d5f131ef4a06d22bb8ba13a"
+  integrity sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==
   dependencies:
-    is-extglob "^1.0.0"
+    debug "^4.1.1"
+    get-stream "^5.1.0"
+    yauzl "^2.10.0"
+  optionalDependencies:
+    "@types/yauzl" "^2.9.1"
 
-extglob@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/extglob/-/extglob-2.0.4.tgz#ad00fe4dc612a9232e8718711dc5cb5ab0285543"
-  integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==
-  dependencies:
-    array-unique "^0.3.2"
-    define-property "^1.0.0"
-    expand-brackets "^2.1.4"
-    extend-shallow "^2.0.1"
-    fragment-cache "^0.2.1"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.1"
-
-extract-zip@^1.6.5, extract-zip@^1.6.6, extract-zip@^1.6.7:
+extract-zip@^1.6.5:
   version "1.6.7"
   resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-1.6.7.tgz#a840b4b8af6403264c8db57f4f1a74333ef81fe9"
   integrity sha1-qEC0uK9kAyZMjbV/Txp0Mz74H+k=
@@ -4005,22 +4221,21 @@ fast-deep-equal@^2.0.1:
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz#7b05218ddf9667bf7f370bf7fdb2cb15fdd0aa49"
   integrity sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=
 
-fast-deep-equal@^3.1.1:
+fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
   integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
 
-fast-glob@^3.1.1:
-  version "3.2.5"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.5.tgz#7939af2a656de79a4f1901903ee8adcaa7cb9661"
-  integrity sha512-2DtFcgT68wiTTiwZ2hNdJfcHNke9XOfnwmBRWXhmeKM8rF0TGwmC/Qto3S7RoZKp5cilZbxzO5iTNTQsJ+EeDg==
+fast-glob@^3.2.9:
+  version "3.2.11"
+  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.11.tgz#a1172ad95ceb8a16e20caa5c5e56480e5129c1d9"
+  integrity sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==
   dependencies:
     "@nodelib/fs.stat" "^2.0.2"
     "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.0"
+    glob-parent "^5.1.2"
     merge2 "^1.3.0"
-    micromatch "^4.0.2"
-    picomatch "^2.2.1"
+    micromatch "^4.0.4"
 
 fast-json-stable-stringify@^2.0.0:
   version "2.0.0"
@@ -4032,6 +4247,13 @@ fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.4:
   resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
   integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
 
+fast-url-parser@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/fast-url-parser/-/fast-url-parser-1.1.3.tgz#f4af3ea9f34d8a271cf58ad2b3759f431f0b318d"
+  integrity sha1-9K8+qfNNiicc9YrSs3WfQx8LMY0=
+  dependencies:
+    punycode "^1.3.2"
+
 fastq@^1.6.0:
   version "1.11.0"
   resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.11.0.tgz#bb9fb955a07130a918eb63c1f5161cc32a5d0858"
@@ -4046,18 +4268,12 @@ fd-slicer@~1.0.1:
   dependencies:
     pend "~1.2.0"
 
-figgy-pudding@^3.5.1:
-  version "3.5.1"
-  resolved "https://registry.yarnpkg.com/figgy-pudding/-/figgy-pudding-3.5.1.tgz#862470112901c727a0e495a80744bd5baa1d6790"
-  integrity sha512-vNKxJHTEKNThjfrdJwHc7brvM6eVevuO5nTj6ez8ZQ1qbXTvGthucRF7S4vf2cr71QVnT70V34v0S1DyQsti0w==
-
-figures@^1.3.5, figures@^1.7.0:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e"
-  integrity sha1-y+Hjr/zxzUS4DK3+0o3Hk6lwHS4=
+fd-slicer@~1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.1.0.tgz#25c7c89cb1f9077f8891bbe61d8f390eae256f1e"
+  integrity sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=
   dependencies:
-    escape-string-regexp "^1.0.5"
-    object-assign "^4.1.0"
+    pend "~1.2.0"
 
 figures@^2.0.0:
   version "2.0.0"
@@ -4073,44 +4289,52 @@ file-entry-cache@^6.0.1:
   dependencies:
     flat-cache "^3.0.4"
 
-file-loader@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-3.0.1.tgz#f8e0ba0b599918b51adfe45d66d1e771ad560faa"
-  integrity sha512-4sNIOXgtH/9WZq4NvlfU3Opn5ynUsqBwSLyM+I7UOwdGigTBYfVVQEwe/msZNX/j4pCJTIM14Fsw66Svo1oVrw==
+file-loader@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-6.2.0.tgz#baef7cf8e1840df325e4390b4484879480eebe4d"
+  integrity sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==
   dependencies:
-    loader-utils "^1.0.2"
-    schema-utils "^1.0.0"
+    loader-utils "^2.0.0"
+    schema-utils "^3.0.0"
 
-file-uri-to-path@1:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
-  integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
+file-type@^3.8.0:
+  version "3.9.0"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-3.9.0.tgz#257a078384d1db8087bc449d107d52a52672b9e9"
+  integrity sha1-JXoHg4TR24CHvESdEH1SpSZyuek=
 
-filename-regex@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.1.tgz#c1c4b9bee3e09725ddb106b75c1e301fe2f18b26"
-  integrity sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=
+file-type@^4.2.0:
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-4.4.0.tgz#1b600e5fca1fbdc6e80c0a70c71c8dba5f7906c5"
+  integrity sha1-G2AOX8ofvcboDApwxxyNul95BsU=
 
-fill-range@^2.1.0:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.4.tgz#eb1e773abb056dcd8df2bfdf6af59b8b3a936565"
-  integrity sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==
-  dependencies:
-    is-number "^2.1.0"
-    isobject "^2.0.0"
-    randomatic "^3.0.0"
-    repeat-element "^1.1.2"
-    repeat-string "^1.5.2"
+file-type@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-5.2.0.tgz#2ddbea7c73ffe36368dfae49dc338c058c2b8ad6"
+  integrity sha1-LdvqfHP/42No365J3DOMBYwritY=
 
-fill-range@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7"
-  integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=
+file-type@^6.1.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-6.2.0.tgz#e50cd75d356ffed4e306dc4f5bcf52a79903a919"
+  integrity sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==
+
+file-type@^8.1.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/file-type/-/file-type-8.1.0.tgz#244f3b7ef641bbe0cca196c7276e4b332399f68c"
+  integrity sha512-qyQ0pzAy78gVoJsmYeNgl8uH8yKhr1lVhW7JbzJmnlRi0I4R2eEDEJZVKG8agpDnLpacwNbDhLNG/LMdxHD2YQ==
+
+filename-reserved-regex@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/filename-reserved-regex/-/filename-reserved-regex-2.0.0.tgz#abf73dfab735d045440abfea2d91f389ebbfa229"
+  integrity sha1-q/c9+rc10EVECr/qLZHzieu/oik=
+
+filenamify@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/filenamify/-/filenamify-2.1.0.tgz#88faf495fb1b47abfd612300002a16228c677ee9"
+  integrity sha512-ICw7NTT6RsDp2rnYKVd8Fu4cr6ITzGy3+u4vUujPkabyaz+03F24NWEX7fs5fp+kBonlaqPH8fAO2NM+SXt/JA==
   dependencies:
-    extend-shallow "^2.0.1"
-    is-number "^3.0.0"
-    repeat-string "^1.6.1"
-    to-regex-range "^2.1.0"
+    filename-reserved-regex "^2.0.0"
+    strip-outer "^1.0.0"
+    trim-repeated "^1.0.0"
 
 fill-range@^7.0.1:
   version "7.0.1"
@@ -4119,17 +4343,17 @@ fill-range@^7.0.1:
   dependencies:
     to-regex-range "^5.0.1"
 
-finalhandler@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.1.0.tgz#ce0b6855b45853e791b2fcc680046d88253dd7f5"
-  integrity sha1-zgtoVbRYU+eRsvzGgARtiCU91/U=
+finalhandler@1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.1.2.tgz#b7e7d000ffd11938d0fdb053506f6ebabe9f587d"
+  integrity sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==
   dependencies:
     debug "2.6.9"
-    encodeurl "~1.0.1"
+    encodeurl "~1.0.2"
     escape-html "~1.0.3"
     on-finished "~2.3.0"
-    parseurl "~1.3.2"
-    statuses "~1.3.1"
+    parseurl "~1.3.3"
+    statuses "~1.5.0"
     unpipe "~1.0.0"
 
 find-cache-dir@^2.0.0:
@@ -4150,31 +4374,35 @@ find-cache-dir@^3.3.1:
     make-dir "^3.0.2"
     pkg-dir "^4.1.0"
 
-find-node-modules@1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/find-node-modules/-/find-node-modules-1.0.4.tgz#b6deb3cccb699c87037677bcede2c5f5862b2550"
-  integrity sha1-tt6zzMtpnIcDdne87eLF9YYrJVA=
+find-cache-dir@^3.3.2:
+  version "3.3.2"
+  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.2.tgz#b30c5b6eff0730731aea9bbd9dbecbd80256d64b"
+  integrity sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==
   dependencies:
-    findup-sync "0.4.2"
-    merge "^1.2.0"
+    commondir "^1.0.1"
+    make-dir "^3.0.2"
+    pkg-dir "^4.1.0"
 
-find-parent-dir@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/find-parent-dir/-/find-parent-dir-0.3.0.tgz#33c44b429ab2b2f0646299c5f9f718f376ff8d54"
-  integrity sha1-M8RLQpqysvBkYpnF+fcY83b/jVQ=
+find-node-modules@^2.1.2:
+  version "2.1.3"
+  resolved "https://registry.yarnpkg.com/find-node-modules/-/find-node-modules-2.1.3.tgz#3c976cff2ca29ee94b4f9eafc613987fc4c0ee44"
+  integrity sha512-UC2I2+nx1ZuOBclWVNdcnbDR5dlrOdVb7xNjmT/lHE+LsgztWks3dG7boJ37yTS/venXw84B/mAW9uHVoC5QRg==
+  dependencies:
+    findup-sync "^4.0.0"
+    merge "^2.1.1"
 
-find-root@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/find-root/-/find-root-1.0.0.tgz#962ff211aab25c6520feeeb8d6287f8f6e95807a"
-  integrity sha1-li/yEaqyXGUg/u641ih/j26VgHo=
+find-root@1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/find-root/-/find-root-1.1.0.tgz#abcfc8ba76f708c42a97b3d685b7e9450bfb9ce4"
+  integrity sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==
 
-find-up@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f"
-  integrity sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=
+find-up@5.0.0, find-up@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
+  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
   dependencies:
-    path-exists "^2.0.0"
-    pinkie-promise "^2.0.0"
+    locate-path "^6.0.0"
+    path-exists "^4.0.0"
 
 find-up@^2.0.0:
   version "2.1.0"
@@ -4190,7 +4418,7 @@ find-up@^3.0.0:
   dependencies:
     locate-path "^3.0.0"
 
-find-up@^4.0.0:
+find-up@^4.0.0, find-up@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
   integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
@@ -4198,15 +4426,22 @@ find-up@^4.0.0:
     locate-path "^5.0.0"
     path-exists "^4.0.0"
 
-findup-sync@0.4.2:
-  version "0.4.2"
-  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-0.4.2.tgz#a8117d0f73124f5a4546839579fe52d7129fb5e5"
-  integrity sha1-qBF9D3MST1pFRoOVef5S1xKfteU=
+find-versions@^3.0.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/find-versions/-/find-versions-3.2.0.tgz#10297f98030a786829681690545ef659ed1d254e"
+  integrity sha512-P8WRou2S+oe222TOCHitLy8zj+SIsVJh52VP4lvXkaFVnOFFdoWv1H1Jjvel1aI6NCFOAaeAVm8qrI0odiLcww==
+  dependencies:
+    semver-regex "^2.0.0"
+
+findup-sync@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-4.0.0.tgz#956c9cdde804052b881b428512905c4a5f2cdef0"
+  integrity sha512-6jvvn/12IC4quLBL1KNokxC7wWTvYncaVUYSoxWw7YykPLuRrnv4qdHcSOywOI5RpkOVGeQRtWM8/q+G6W6qfQ==
   dependencies:
-    detect-file "^0.1.0"
-    is-glob "^2.0.1"
-    micromatch "^2.3.7"
-    resolve-dir "^0.1.0"
+    detect-file "^1.0.0"
+    is-glob "^4.0.0"
+    micromatch "^4.0.2"
+    resolve-dir "^1.0.1"
 
 flat-cache@^3.0.4:
   version "3.0.4"
@@ -4216,51 +4451,50 @@ flat-cache@^3.0.4:
     flatted "^3.1.0"
     rimraf "^3.0.2"
 
-flatted@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-2.0.0.tgz#55122b6536ea496b4b44893ee2608141d10d9916"
-  integrity sha512-R+H8IZclI8AAkSBRQJLVOsxwAoHd6WC40b4QTNWIjzAa6BXOBfQcM587MXDTVPeYaopFNWHUFLx7eNmHDSxMWg==
+flat@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241"
+  integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
 
 flatted@^3.1.0:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.1.1.tgz#c4b489e80096d9df1dfc97c79871aea7c617c469"
   integrity sha512-zAoAQiudy+r5SvnSw3KJy5os/oRJYHzrzja/tBDqrZtNhUw8bt6y8OBzMWcjWr+8liV8Eb6yOhw8WZ7VFZ5ZzA==
 
-flow-bin@^0.61.0:
-  version "0.61.0"
-  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.61.0.tgz#d0473a8c35dbbf4de573823f4932124397d32d35"
-  integrity sha512-w6SGi5CDfKLNGzYssRhW6N37qKclDXijsxDQ5M8c3WbivRYta0Horv22bwakegfKBVDnyeS0lRW3OqBC74eq2g==
+flatted@^3.2.5:
+  version "3.2.5"
+  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.5.tgz#76c8584f4fc843db64702a6bd04ab7a8bd666da3"
+  integrity sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==
 
-flush-write-stream@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/flush-write-stream/-/flush-write-stream-1.0.3.tgz#c5d586ef38af6097650b49bc41b55fabb19f35bd"
-  integrity sha512-calZMC10u0FMUqoiunI2AiGIIUtUIvifNwkHhNupZH4cbNnW1Itkoh/Nf5HFYmDrwWPjrUxpkZT0KhuCq0jmGw==
-  dependencies:
-    inherits "^2.0.1"
-    readable-stream "^2.0.4"
+flow-bin@^0.176.3:
+  version "0.176.3"
+  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.176.3.tgz#d32de04e044ab474afe543b9fd245608bb6a6ac8"
+  integrity sha512-lbNqgjr2GlGLAEVp5+dhG4LdnFE7ekbvVNifAdlvTx58/nE8GrCOMiUwEQy4dLnfL2NIRMk2dbEVTrugeQJ3mA==
 
 follow-redirects@^1.0.0:
   version "1.13.0"
   resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.13.0.tgz#b42e8d93a2a7eea5ed88633676d6597bc8e384db"
   integrity sha512-aq6gF1BEKje4a9i9+5jimNFIpq4Q1WiwBToeRK5NvZBd/TRsmW8BsJfOEGkr76TbOyPVD3OVDN910EcUNtRYEA==
 
-for-in@^1.0.1, for-in@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
-  integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
-
-for-own@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce"
-  integrity sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=
-  dependencies:
-    for-in "^1.0.1"
+follow-redirects@^1.14.4:
+  version "1.14.9"
+  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.9.tgz#dd4ea157de7bfaf9ea9b3fbd85aa16951f78d8d7"
+  integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==
 
 forever-agent@~0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
   integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=
 
+form-data@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.1.tgz#ebd53791b78356a99af9a300d4282c4d5eb9755f"
+  integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg==
+  dependencies:
+    asynckit "^0.4.0"
+    combined-stream "^1.0.8"
+    mime-types "^2.1.12"
+
 form-data@~2.3.2:
   version "2.3.3"
   resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
@@ -4270,14 +4504,7 @@ form-data@~2.3.2:
     combined-stream "^1.0.6"
     mime-types "^2.1.12"
 
-fragment-cache@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19"
-  integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=
-  dependencies:
-    map-cache "^0.2.2"
-
-from2@^2.1.0:
+from2@^2.1.1:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/from2/-/from2-2.3.0.tgz#8bfb5502bde4a4d36cfdeea007fcca21d7e382af"
   integrity sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=
@@ -4285,17 +4512,10 @@ from2@^2.1.0:
     inherits "^2.0.1"
     readable-stream "^2.0.0"
 
-fs-access@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/fs-access/-/fs-access-1.0.1.tgz#d6a87f262271cefebec30c553407fb995da8777a"
-  integrity sha1-1qh/JiJxzv6+wwxVNAf7mV2od3o=
-  dependencies:
-    null-check "^1.0.0"
-
-fs-exists-sync@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/fs-exists-sync/-/fs-exists-sync-0.1.0.tgz#982d6893af918e72d08dec9e8673ff2b5a8d6add"
-  integrity sha1-mC1ok6+RjnLQjeyehnP/K1qNat0=
+fs-constants@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad"
+  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
 
 fs-extra@8.1.0:
   version "8.1.0"
@@ -4315,49 +4535,35 @@ fs-extra@^1.0.0:
     jsonfile "^2.1.0"
     klaw "^1.0.0"
 
-fs-minipass@^1.2.5:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/fs-minipass/-/fs-minipass-1.2.5.tgz#06c277218454ec288df77ada54a03b8702aacb9d"
-  integrity sha512-JhBl0skXjUPCFH7x6x61gQxrKyXsxB5gcgePLZCwfyCGGsTISMoIeObbrvVeP6Xmyaudw4TT43qV2Gz+iyd2oQ==
+fs-extra@^10.0.0, fs-extra@^10.1.0:
+  version "10.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
+  integrity sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==
   dependencies:
-    minipass "^2.2.1"
+    graceful-fs "^4.2.0"
+    jsonfile "^6.0.1"
+    universalify "^2.0.0"
 
-fs-write-stream-atomic@^1.0.8:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/fs-write-stream-atomic/-/fs-write-stream-atomic-1.0.10.tgz#b47df53493ef911df75731e70a9ded0189db40c9"
-  integrity sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=
+fs-extra@^9.0.1:
+  version "9.1.0"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d"
+  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
   dependencies:
-    graceful-fs "^4.1.2"
-    iferr "^0.1.5"
-    imurmurhash "^0.1.4"
-    readable-stream "1 || 2"
+    at-least-node "^1.0.0"
+    graceful-fs "^4.2.0"
+    jsonfile "^6.0.1"
+    universalify "^2.0.0"
 
 fs.realpath@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
 
-fsevents@^1.2.2:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-1.2.4.tgz#f41dcb1af2582af3692da36fc55cbd8e1041c426"
-  integrity sha512-z8H8/diyk76B7q5wg+Ud0+CqzcAF3mBBI/bA5ne5zrRUUIvNkJY//D3BqyH571KuAC4Nr7Rw7CjWX4r0y9DvNg==
-  dependencies:
-    nan "^2.9.2"
-    node-pre-gyp "^0.10.0"
-
-fsevents@~2.3.1:
+fsevents@~2.3.2:
   version "2.3.2"
   resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
   integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
 
-ftp@~0.3.10:
-  version "0.3.10"
-  resolved "https://registry.yarnpkg.com/ftp/-/ftp-0.3.10.tgz#9197d861ad8142f3e63d5a83bfe4c59f7330885d"
-  integrity sha1-kZfYYa2BQvPmPVqDv+TFn3MwiF0=
-  dependencies:
-    readable-stream "1.1.x"
-    xregexp "2.0.0"
-
 function-bind@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
@@ -4368,29 +4574,6 @@ functional-red-black-tree@^1.0.1:
   resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
   integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=
 
-g-status@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/g-status/-/g-status-2.0.2.tgz#270fd32119e8fc9496f066fe5fe88e0a6bc78b97"
-  integrity sha512-kQoE9qH+T1AHKgSSD0Hkv98bobE90ILQcXAF4wvGgsr7uFqNvwmh8j+Lq3l0RVt3E3HjSbv2B9biEGcEtpHLCA==
-  dependencies:
-    arrify "^1.0.1"
-    matcher "^1.0.0"
-    simple-git "^1.85.0"
-
-gauge@~2.7.3:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/gauge/-/gauge-2.7.4.tgz#2c03405c7538c39d7eb37b317022e325fb018bf7"
-  integrity sha1-LANAXHU4w51+s3sxcCLjJfsBi/c=
-  dependencies:
-    aproba "^1.0.3"
-    console-control-strings "^1.0.0"
-    has-unicode "^2.0.0"
-    object-assign "^4.1.0"
-    signal-exit "^3.0.0"
-    string-width "^1.0.1"
-    strip-ansi "^3.0.1"
-    wide-align "^1.1.0"
-
 gensync@^1.0.0-beta.2:
   version "1.0.0-beta.2"
   resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
@@ -4401,6 +4584,11 @@ get-caller-file@^2.0.5:
   resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
 
+get-func-name@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/get-func-name/-/get-func-name-2.0.0.tgz#ead774abee72e20409433a066366023dd6887a41"
+  integrity sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=
+
 get-intrinsic@^1.0.2:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
@@ -4410,32 +4598,46 @@ get-intrinsic@^1.0.2:
     has "^1.0.3"
     has-symbols "^1.0.1"
 
-get-own-enumerable-property-symbols@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.0.tgz#b877b49a5c16aefac3655f2ed2ea5b684df8d203"
-  integrity sha512-CIJYJC4GGF06TakLg8z4GQKvDsx9EMspVxOYih7LerEL/WosUnFIww45CGfxfeKHqlg3twgUrYRT1O3WQqjGCg==
+get-package-type@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
+  integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
 
-get-pkg-repo@^1.0.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/get-pkg-repo/-/get-pkg-repo-1.4.0.tgz#c73b489c06d80cc5536c2c853f9e05232056972d"
-  integrity sha1-xztInAbYDMVTbCyFP54FIyBWly0=
+get-pkg-repo@^4.0.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/get-pkg-repo/-/get-pkg-repo-4.2.1.tgz#75973e1c8050c73f48190c52047c4cee3acbf385"
+  integrity sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==
   dependencies:
-    hosted-git-info "^2.1.4"
-    meow "^3.3.0"
-    normalize-package-data "^2.3.0"
-    parse-github-repo-url "^1.3.0"
+    "@hutson/parse-repository-url" "^3.0.0"
+    hosted-git-info "^4.0.0"
     through2 "^2.0.0"
+    yargs "^16.2.0"
 
-get-stdin@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
-  integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=
+get-port@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/get-port/-/get-port-5.1.1.tgz#0469ed07563479de6efb986baf053dcd7d4e3193"
+  integrity sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==
+
+get-proxy@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/get-proxy/-/get-proxy-2.1.0.tgz#349f2b4d91d44c4d4d4e9cba2ad90143fac5ef93"
+  integrity sha512-zmZIaQTWnNQb4R4fJUEp/FC51eZsc6EkErspy3xtIYStaq8EB/hDIWipxsal+E8rz0qD7f2sL/NA9Xee4RInJw==
+  dependencies:
+    npm-conf "^1.1.0"
 
-get-stream@^3.0.0:
+get-stream@3.0.0, get-stream@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"
   integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=
 
+get-stream@^2.2.0:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-2.3.1.tgz#5f38f93f346009666ee0150a054167f91bdd95de"
+  integrity sha1-Xzj5PzRgCWZu4BUKBUFn+Rvdld4=
+  dependencies:
+    object-assign "^4.0.1"
+    pinkie-promise "^2.0.0"
+
 get-stream@^4.0.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
@@ -4443,22 +4645,17 @@ get-stream@^4.0.0:
   dependencies:
     pump "^3.0.0"
 
-get-uri@2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/get-uri/-/get-uri-2.0.2.tgz#5c795e71326f6ca1286f2fc82575cd2bab2af578"
-  integrity sha512-ZD325dMZOgerGqF/rF6vZXyFGTAay62svjQIT+X/oU2PtxYpFxvSkbsdi+oxIrsNxlZVd4y8wUDqkaExWTI/Cw==
+get-stream@^5.1.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3"
+  integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==
   dependencies:
-    data-uri-to-buffer "1"
-    debug "2"
-    extend "3"
-    file-uri-to-path "1"
-    ftp "~0.3.10"
-    readable-stream "2"
+    pump "^3.0.0"
 
-get-value@^2.0.3, get-value@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28"
-  integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=
+get-stream@^6.0.0:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
+  integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
 getpass@^0.1.1:
   version "0.1.7"
@@ -4467,16 +4664,16 @@ getpass@^0.1.1:
   dependencies:
     assert-plus "^1.0.0"
 
-git-raw-commits@^1.3.6:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-1.3.6.tgz#27c35a32a67777c1ecd412a239a6c19d71b95aff"
-  integrity sha512-svsK26tQ8vEKnMshTDatSIQSMDdz8CxIIqKsvPqbtV23Etmw6VNaFAitu8zwZ0VrOne7FztwPyRLxK7/DIUTQg==
+git-raw-commits@^2.0.8:
+  version "2.0.11"
+  resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-2.0.11.tgz#bc3576638071d18655e1cc60d7f524920008d723"
+  integrity sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==
   dependencies:
-    dargs "^4.0.1"
-    lodash.template "^4.0.2"
-    meow "^4.0.0"
-    split2 "^2.0.0"
-    through2 "^2.0.0"
+    dargs "^7.0.0"
+    lodash "^4.17.15"
+    meow "^8.0.0"
+    split2 "^3.0.0"
+    through2 "^4.0.0"
 
 git-remote-origin-url@^2.0.0:
   version "2.0.0"
@@ -4486,13 +4683,13 @@ git-remote-origin-url@^2.0.0:
     gitconfiglocal "^1.0.0"
     pify "^2.3.0"
 
-git-semver-tags@^1.3.6:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/git-semver-tags/-/git-semver-tags-1.3.6.tgz#357ea01f7280794fe0927f2806bee6414d2caba5"
-  integrity sha512-2jHlJnln4D/ECk9FxGEBh3k44wgYdWjWDtMmJPaecjoRmxKo3Y1Lh8GMYuOPu04CHw86NTAODchYjC5pnpMQig==
+git-semver-tags@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/git-semver-tags/-/git-semver-tags-4.1.1.tgz#63191bcd809b0ec3e151ba4751c16c444e5b5780"
+  integrity sha512-OWyMt5zBe7xFs8vglMmhM9lRQzCWL3WjHtxNNfJTMngGym7pC1kh8sP6jevfydJ6LP3ZvGxfb6ABYgPUM0mtsA==
   dependencies:
-    meow "^4.0.0"
-    semver "^5.5.0"
+    meow "^8.0.0"
+    semver "^6.0.0"
 
 gitconfiglocal@^1.0.0:
   version "1.0.0"
@@ -4501,72 +4698,50 @@ gitconfiglocal@^1.0.0:
   dependencies:
     ini "^1.3.2"
 
-glob-base@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4"
-  integrity sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=
-  dependencies:
-    glob-parent "^2.0.0"
-    is-glob "^2.0.0"
-
-glob-parent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28"
-  integrity sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=
-  dependencies:
-    is-glob "^2.0.0"
-
-glob-parent@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
-  integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=
-  dependencies:
-    is-glob "^3.1.0"
-    path-dirname "^1.0.0"
-
-glob-parent@^5.0.0, glob-parent@^5.1.0:
+glob-parent@^5.1.2, glob-parent@~5.1.2:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
   integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
   dependencies:
     is-glob "^4.0.1"
 
-glob@7.0.5:
-  version "7.0.5"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.0.5.tgz#b4202a69099bbb4d292a7c1b95b6682b67ebdc95"
-  integrity sha1-tCAqaQmbu00pKnwblbZoK2fr3JU=
+glob-parent@^6.0.1:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
+  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
   dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.2"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
+    is-glob "^4.0.3"
 
-glob@7.1.1:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8"
-  integrity sha1-gFIR3wT6rxxjo2ADBs31reULLsg=
+glob-to-regexp@^0.4.1:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
+  integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
+
+glob@7.1.4:
+  version "7.1.4"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.4.tgz#aa608a2f6c577ad357e1ae5a5c26d9a8d1969255"
+  integrity sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==
   dependencies:
     fs.realpath "^1.0.0"
     inflight "^1.0.4"
     inherits "2"
-    minimatch "^3.0.2"
+    minimatch "^3.0.4"
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-glob@^5.0.15:
-  version "5.0.15"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-5.0.15.tgz#1bc936b9e02f4a603fcc222ecf7633d30b8b93b1"
-  integrity sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E=
+glob@7.2.0, glob@^7.1.2, glob@^7.1.4, glob@^7.1.7:
+  version "7.2.0"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.0.tgz#d15535af7732e02e948f4c41628bd910293f6023"
+  integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==
   dependencies:
+    fs.realpath "^1.0.0"
     inflight "^1.0.4"
     inherits "2"
-    minimatch "2 || 3"
+    minimatch "^3.0.4"
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-glob@^7.0.0, glob@^7.0.3, glob@^7.0.6, glob@^7.1.1, glob@^7.1.3:
+glob@^7.0.0, glob@^7.1.3:
   version "7.1.3"
   resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.3.tgz#3960832d3f1574108342dafd3a67b332c0969df1"
   integrity sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==
@@ -4590,36 +4765,51 @@ glob@^7.1.6:
     once "^1.3.0"
     path-is-absolute "^1.0.0"
 
-global-modules@^0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-0.2.3.tgz#ea5a3bed42c6d6ce995a4f8a1269b5dae223828d"
-  integrity sha1-6lo77ULG1s6ZWk+KEmm12uIjgo0=
+global-agent@^2.1.12:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/global-agent/-/global-agent-2.2.0.tgz#566331b0646e6bf79429a16877685c4a1fbf76dc"
+  integrity sha512-+20KpaW6DDLqhG7JDiJpD1JvNvb8ts+TNl7BPOYcURqCrXqnN1Vf+XVOrkKJAFPqfX+oEhsdzOj1hLWkBTdNJg==
+  dependencies:
+    boolean "^3.0.1"
+    core-js "^3.6.5"
+    es6-error "^4.1.1"
+    matcher "^3.0.0"
+    roarr "^2.15.3"
+    semver "^7.3.2"
+    serialize-error "^7.0.1"
+
+global-dirs@^0.1.1:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-0.1.1.tgz#b319c0dd4607f353f3be9cca4c72fc148c49f445"
+  integrity sha1-sxnA3UYH81PzvpzKTHL8FIxJ9EU=
   dependencies:
-    global-prefix "^0.1.4"
-    is-windows "^0.2.0"
+    ini "^1.3.4"
 
-global-prefix@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-0.1.5.tgz#8d3bc6b8da3ca8112a160d8d496ff0462bfef78f"
-  integrity sha1-jTvGuNo8qBEqFg2NSW/wRiv+948=
+global-modules@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
+  integrity sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==
+  dependencies:
+    global-prefix "^1.0.1"
+    is-windows "^1.0.1"
+    resolve-dir "^1.0.0"
+
+global-prefix@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-1.0.2.tgz#dbf743c6c14992593c655568cb66ed32c0122ebe"
+  integrity sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=
   dependencies:
-    homedir-polyfill "^1.0.0"
+    expand-tilde "^2.0.2"
+    homedir-polyfill "^1.0.1"
     ini "^1.3.4"
-    is-windows "^0.2.0"
-    which "^1.2.12"
+    is-windows "^1.0.1"
+    which "^1.2.14"
 
 globals@^11.1.0:
   version "11.12.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
   integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
 
-globals@^12.1.0:
-  version "12.4.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-12.4.0.tgz#a18813576a41b00a24a97e7f815918c2e19925f8"
-  integrity sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg==
-  dependencies:
-    type-fest "^0.8.1"
-
 globals@^13.6.0:
   version "13.7.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-13.7.0.tgz#aed3bcefd80ad3ec0f0be2cf0c895110c0591795"
@@ -4627,35 +4817,83 @@ globals@^13.6.0:
   dependencies:
     type-fest "^0.20.2"
 
+globals@^13.9.0:
+  version "13.13.0"
+  resolved "https://registry.yarnpkg.com/globals/-/globals-13.13.0.tgz#ac32261060d8070e2719dd6998406e27d2b5727b"
+  integrity sha512-EQ7Q18AJlPwp3vUDL4mKA0KXrXyNIQyWon6T6XQiBQF0XHvRsiCSrWmmeATpUzdJN2HhWZU6Pdl0a9zdep5p6A==
+  dependencies:
+    type-fest "^0.20.2"
+
 globals@^9.18.0:
   version "9.18.0"
   resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a"
   integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==
 
-globby@^11.0.1:
-  version "11.0.3"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.3.tgz#9b1f0cb523e171dd1ad8c7b2a9fb4b644b9593cb"
-  integrity sha512-ffdmosjA807y7+lA1NM0jELARVmYul/715xiILEjo3hBLPTcirgQNnXECn5g3mtR8TOLCVbkfua1Hpen25/Xcg==
+globalthis@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/globalthis/-/globalthis-1.0.2.tgz#2a235d34f4d8036219f7e34929b5de9e18166b8b"
+  integrity sha512-ZQnSFO1la8P7auIOQECnm0sSuoMeaSq0EEdXMBFF2QJO4uNcwbyhSgG3MruWNbFTqCLmxVwGOl7LZ9kASvHdeQ==
+  dependencies:
+    define-properties "^1.1.3"
+
+globby@^11.0.1, globby@^11.0.4:
+  version "11.1.0"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
+  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
   dependencies:
     array-union "^2.1.0"
     dir-glob "^3.0.1"
-    fast-glob "^3.1.1"
-    ignore "^5.1.4"
-    merge2 "^1.3.0"
+    fast-glob "^3.2.9"
+    ignore "^5.2.0"
+    merge2 "^1.4.1"
     slash "^3.0.0"
 
-globby@^6.1.0:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-6.1.0.tgz#f5a6d70e8395e21c858fb0489d64df02424d506c"
-  integrity sha1-9abXDoOV4hyFj7BInWTfAkJNUGw=
-  dependencies:
-    array-union "^1.0.1"
-    glob "^7.0.3"
-    object-assign "^4.0.1"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
+got@^11.0.2, got@^11.7.0:
+  version "11.8.3"
+  resolved "https://registry.yarnpkg.com/got/-/got-11.8.3.tgz#f496c8fdda5d729a90b4905d2b07dbd148170770"
+  integrity sha512-7gtQ5KiPh1RtGS9/Jbv1ofDpBFuq42gyfEib+ejaRBJuj/3tQFeR5+gw57e4ipaU8c/rCjvX6fkQz2lyDlGAOg==
+  dependencies:
+    "@sindresorhus/is" "^4.0.0"
+    "@szmarczak/http-timer" "^4.0.5"
+    "@types/cacheable-request" "^6.0.1"
+    "@types/responselike" "^1.0.0"
+    cacheable-lookup "^5.0.3"
+    cacheable-request "^7.0.2"
+    decompress-response "^6.0.0"
+    http2-wrapper "^1.0.0-beta.5.2"
+    lowercase-keys "^2.0.0"
+    p-cancelable "^2.0.0"
+    responselike "^2.0.0"
+
+got@^8.3.1:
+  version "8.3.2"
+  resolved "https://registry.yarnpkg.com/got/-/got-8.3.2.tgz#1d23f64390e97f776cac52e5b936e5f514d2e937"
+  integrity sha512-qjUJ5U/hawxosMryILofZCkm3C84PLJS/0grRIpjAwu+Lkxxj5cxeCU25BG0/3mDSpXKTyZr8oh8wIgLaH0QCw==
+  dependencies:
+    "@sindresorhus/is" "^0.7.0"
+    cacheable-request "^2.1.1"
+    decompress-response "^3.3.0"
+    duplexer3 "^0.1.4"
+    get-stream "^3.0.0"
+    into-stream "^3.1.0"
+    is-retry-allowed "^1.1.0"
+    isurl "^1.0.0-alpha5"
+    lowercase-keys "^1.0.0"
+    mimic-response "^1.0.0"
+    p-cancelable "^0.4.0"
+    p-timeout "^2.0.1"
+    pify "^3.0.0"
+    safe-buffer "^5.1.1"
+    timed-out "^4.0.1"
+    url-parse-lax "^3.0.0"
+    url-to-options "^1.0.1"
 
-graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.1.9:
+graceful-fs@^4.1.10, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
+  version "4.2.10"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c"
+  integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
+
+graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.1.9:
   version "4.1.15"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.15.tgz#ffb703e1066e8a0eeaa4c8b80ba9253eeefbfb00"
   integrity sha512-6uHUhOPEBgQ24HM+r6b/QwWfZq+yiFcipKFrOFiBEnWdy5sdzYoi+pJeQaPI5qOLRFqWmAXUPQNsielzdLoecA==
@@ -4665,17 +4903,17 @@ graceful-fs@^4.2.0:
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
   integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
 
-"graceful-readlink@>= 1.0.0":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/graceful-readlink/-/graceful-readlink-1.0.1.tgz#4cafad76bc62f02fa039b2f94e9a3dd3a391a725"
-  integrity sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=
+grapheme-splitter@^1.0.2:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz#9cf3a665c6247479896834af35cf1dbb4400767e"
+  integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==
 
-growl@1.9.2:
-  version "1.9.2"
-  resolved "https://registry.yarnpkg.com/growl/-/growl-1.9.2.tgz#0ea7743715db8d8de2c5ede1775e1b45ac85c02f"
-  integrity sha1-Dqd0NxXbjY3ixe3hd14bRayFwC8=
+growl@1.10.5:
+  version "1.10.5"
+  resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.5.tgz#f2735dc2283674fa67478b10181059355c369e5e"
+  integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==
 
-handlebars@^4.0.1, handlebars@^4.0.2:
+handlebars@^4.7.7:
   version "4.7.7"
   resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.7.tgz#9ce33416aad02dbd6c8fafa8240d5d98004945a1"
   integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==
@@ -4700,6 +4938,11 @@ har-validator@~5.1.0:
     ajv "^6.5.5"
     har-schema "^2.0.0"
 
+hard-rejection@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
+  integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==
+
 has-ansi@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
@@ -4707,23 +4950,6 @@ has-ansi@^2.0.0:
   dependencies:
     ansi-regex "^2.0.0"
 
-has-binary2@~1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has-binary2/-/has-binary2-1.0.3.tgz#7776ac627f3ea77250cfc332dab7ddf5e4f5d11d"
-  integrity sha512-G1LWKhDSvhGeAQ8mPVQlqNcOB2sJdwATtZKl2pDKKHfpf/rYj24lkinxf69blJbnsvtqqNU+L3SL50vzZhXOnw==
-  dependencies:
-    isarray "2.0.1"
-
-has-cors@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/has-cors/-/has-cors-1.1.0.tgz#5e474793f7ea9843d1bb99c23eef49ff126fff39"
-  integrity sha1-XkdHk/fqmEPRu5nCPu9J/xJv/zk=
-
-has-flag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-1.0.0.tgz#9d9e793165ce017a00f00418c43f942a7b1d11fa"
-  integrity sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=
-
 has-flag@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
@@ -4734,73 +4960,36 @@ has-flag@^4.0.0:
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
   integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
 
-has-symbols@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.0.tgz#ba1a8f1af2a0fc39650f5c850367704122063b44"
-  integrity sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=
+has-symbol-support-x@^1.4.1:
+  version "1.4.2"
+  resolved "https://registry.yarnpkg.com/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz#1409f98bc00247da45da67cee0a36f282ff26455"
+  integrity sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==
 
 has-symbols@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423"
   integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==
 
-has-unicode@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
-  integrity sha1-4Ob+aijPUROIVeCG0Wkedx3iqLk=
-
-has-value@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f"
-  integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=
-  dependencies:
-    get-value "^2.0.3"
-    has-values "^0.1.4"
-    isobject "^2.0.0"
-
-has-value@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177"
-  integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=
-  dependencies:
-    get-value "^2.0.6"
-    has-values "^1.0.0"
-    isobject "^3.0.0"
-
-has-values@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771"
-  integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E=
-
-has-values@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f"
-  integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=
+has-to-string-tag-x@^1.2.0:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz#a045ab383d7b4b2012a00148ab0aa5f290044d4d"
+  integrity sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==
   dependencies:
-    is-number "^3.0.0"
-    kind-of "^4.0.0"
+    has-symbol-support-x "^1.4.1"
 
-has@^1.0.1, has@^1.0.3:
+has@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
   integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
   dependencies:
     function-bind "^1.1.1"
 
-hash-base@^3.0.0:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.0.4.tgz#5fc8686847ecd73499403319a6b0a3f3f6ae4918"
-  integrity sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-hash-sum@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/hash-sum/-/hash-sum-1.0.2.tgz#33b40777754c6432573c120cc3808bbd10d47f04"
-  integrity sha1-M7QHd3VMZDJXPBIMw4CLvRDUfwQ=
+hash-sum@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/hash-sum/-/hash-sum-2.0.0.tgz#81d01bb5de8ea4a214ad5d6ead1b523460b0b45a"
+  integrity sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==
 
-hash.js@^1.0.0, hash.js@^1.0.3:
+hash.js@^1.1.7:
   version "1.1.7"
   resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
   integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
@@ -4816,24 +5005,23 @@ hasha@^2.2.0:
     is-stream "^1.0.1"
     pinkie-promise "^2.0.0"
 
-he@^1.1.1:
+he@1.2.0, he@^1.1.1, he@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
   integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
 
-hmac-drbg@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
-  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
+header-case@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/header-case/-/header-case-2.0.4.tgz#5a42e63b55177349cf405beb8d775acabb92c063"
+  integrity sha512-H/vuk5TEEVZwrR0lp2zed9OCo1uAILMlx0JEMgC26rzyJJ3N1v6XkwHHXJQdR2doSjcGPM6OKPYoJgf0plJ11Q==
   dependencies:
-    hash.js "^1.0.3"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.1"
+    capital-case "^1.0.4"
+    tslib "^2.0.3"
 
-homedir-polyfill@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz#4c2bbc8a758998feebf5ed68580f76d46768b4bc"
-  integrity sha1-TCu8inWJmP7r9e1oWA921GdotLw=
+homedir-polyfill@^1.0.1:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
+  integrity sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==
   dependencies:
     parse-passwd "^1.0.0"
 
@@ -4842,26 +5030,56 @@ hosted-git-info@^2.1.4:
   resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.7.1.tgz#97f236977bd6e125408930ff6de3eec6281ec047"
   integrity sha512-7T/BxH19zbcCTa8XkMlbK5lTo1WtgkFi3GvdWEyNuc4Vex7/9Dqbnpsf4JMydcfj9HCg4zUWFTL3Za6lapg5/w==
 
-http-errors@1.6.3, http-errors@~1.6.3:
-  version "1.6.3"
-  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.6.3.tgz#8b55680bb4be283a0b5bf4ea2e38580be1d9320d"
-  integrity sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=
+hosted-git-info@^4.0.0, hosted-git-info@^4.0.1:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
+  integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==
+  dependencies:
+    lru-cache "^6.0.0"
+
+html-encoding-sniffer@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-3.0.0.tgz#2cb1a8cf0db52414776e5b2a7a04d5dd98158de9"
+  integrity sha512-oWv4T4yJ52iKrufjnyZPkrN0CH3QnrUqdB6In1g5Fe1mia8GmF36gnfNySxoZtxD5+NmYw1EElVXiBk93UeskA==
   dependencies:
-    depd "~1.1.2"
-    inherits "2.0.3"
-    setprototypeof "1.1.0"
-    statuses ">= 1.4.0 < 2"
+    whatwg-encoding "^2.0.0"
 
-http-proxy-agent@1:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-1.0.0.tgz#cc1ce38e453bf984a0f7702d2dd59c73d081284a"
-  integrity sha1-zBzjjkU7+YSg93AtLdWcc9CBKEo=
+html-escaper@^2.0.0:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
+  integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
+
+http-cache-semantics@3.8.1:
+  version "3.8.1"
+  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-3.8.1.tgz#39b0e16add9b605bf0a9ef3d9daaf4843b4cacd2"
+  integrity sha512-5ai2iksyV8ZXmnZhHH4rWPoxxistEexSi5936zIQ1bnNTW5VnA85B6P/VpXiRM017IgRvb2kKo1a//y+0wSp3w==
+
+http-cache-semantics@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz#49e91c5cbf36c9b94bcfcd71c23d5249ec74e390"
+  integrity sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==
+
+http-errors@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3"
+  integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==
+  dependencies:
+    depd "2.0.0"
+    inherits "2.0.4"
+    setprototypeof "1.2.0"
+    statuses "2.0.1"
+    toidentifier "1.0.1"
+
+http-proxy-agent@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz#8a8c8ef7f5932ccf953c296ca8291b95aa74aa3a"
+  integrity sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==
   dependencies:
-    agent-base "2"
-    debug "2"
-    extend "3"
+    "@tootallnate/once" "1"
+    agent-base "6"
+    debug "4"
 
-http-proxy@^1.13.0, http-proxy@^1.18.0:
+http-proxy@^1.18.1:
   version "1.18.1"
   resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz#401541f0534884bbf95260334e72f88ee3976549"
   integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
@@ -4870,21 +5088,24 @@ http-proxy@^1.13.0, http-proxy@^1.18.0:
     follow-redirects "^1.0.0"
     requires-port "^1.0.0"
 
-http-server@^0.12.3:
-  version "0.12.3"
-  resolved "https://registry.yarnpkg.com/http-server/-/http-server-0.12.3.tgz#ba0471d0ecc425886616cb35c4faf279140a0d37"
-  integrity sha512-be0dKG6pni92bRjq0kvExtj/NrrAd28/8fCXkaI/4piTwQMSDSLMhWyW0NI1V+DBI3aa1HMlQu46/HjVLfmugA==
+http-server@^14.1.0:
+  version "14.1.0"
+  resolved "https://registry.yarnpkg.com/http-server/-/http-server-14.1.0.tgz#51d43e03cdbb94f328b24821cad2cefc6c6a2eed"
+  integrity sha512-5lYsIcZtf6pdR8tCtzAHTWrAveo4liUlJdWc7YafwK/maPgYHs+VNP6KpCClmUnSorJrARVMXqtT055zBv11Yg==
   dependencies:
-    basic-auth "^1.0.3"
-    colors "^1.4.0"
+    basic-auth "^2.0.1"
+    chalk "^4.1.2"
     corser "^2.0.1"
-    ecstatic "^3.3.2"
-    http-proxy "^1.18.0"
+    he "^1.2.0"
+    html-encoding-sniffer "^3.0.0"
+    http-proxy "^1.18.1"
+    mime "^1.6.0"
     minimist "^1.2.5"
     opener "^1.5.1"
-    portfinder "^1.0.25"
+    portfinder "^1.0.28"
     secure-compare "3.0.1"
     union "~0.5.0"
+    url-join "^4.0.1"
 
 http-signature@~1.2.0:
   version "1.2.0"
@@ -4895,68 +5116,65 @@ http-signature@~1.2.0:
     jsprim "^1.2.2"
     sshpk "^1.7.0"
 
-https-browserify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73"
-  integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=
-
-https-proxy-agent@1:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-1.0.0.tgz#35f7da6c48ce4ddbfa264891ac593ee5ff8671e6"
-  integrity sha1-NffabEjOTdv6JkiRrFk+5f+GceY=
+http2-wrapper@^1.0.0-beta.5.2:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/http2-wrapper/-/http2-wrapper-1.0.3.tgz#b8f55e0c1f25d4ebd08b3b0c2c079f9590800b3d"
+  integrity sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==
   dependencies:
-    agent-base "2"
-    debug "2"
-    extend "3"
+    quick-lru "^5.1.1"
+    resolve-alpn "^1.0.0"
 
-https-proxy-agent@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-2.2.1.tgz#51552970fa04d723e04c56d04178c3f92592bbc0"
-  integrity sha512-HPCTS1LW51bcyMYbxUIOO4HEOlQ1/1qRaFWcyxvwaqUS9TY88aoEuHUY33kuAh1YhVVaDQhLZsnPd+XNARWZlQ==
+https-proxy-agent@5.0.1, https-proxy-agent@^5.0.0:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6"
+  integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==
   dependencies:
-    agent-base "^4.1.0"
-    debug "^3.1.0"
+    agent-base "6"
+    debug "4"
 
-iconv-lite@0.4.23:
-  version "0.4.23"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.23.tgz#297871f63be507adcfbfca715d0cd0eed84e9a63"
-  integrity sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==
+https-proxy-agent@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-4.0.0.tgz#702b71fb5520a132a66de1f67541d9e62154d82b"
+  integrity sha512-zoDhWrkR3of1l9QAL8/scJZyLu8j/gBkcwcaQOZh7Gyh/+uJQzGVETdgT30akuwkpL8HTRfssqI3BZuV18teDg==
   dependencies:
-    safer-buffer ">= 2.1.2 < 3"
+    agent-base "5"
+    debug "4"
+
+human-signals@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
+  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
 
-iconv-lite@^0.4.17, iconv-lite@^0.4.4, iconv-lite@~0.4.13:
+iconv-lite@0.4.24, iconv-lite@^0.4.24:
   version "0.4.24"
   resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
 
-ieee754@^1.1.4:
-  version "1.1.12"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.1.12.tgz#50bf24e5b9c8bb98af4964c941cdb0918da7b60b"
-  integrity sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==
+iconv-lite@0.6.3:
+  version "0.6.3"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501"
+  integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==
+  dependencies:
+    safer-buffer ">= 2.1.2 < 3.0.0"
 
-iferr@^0.1.5:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/iferr/-/iferr-0.1.5.tgz#c60eed69e6d8fdb6b3104a1fcbca1c192dc5b501"
-  integrity sha1-xg7taebY/bazEEofy8ocGS3FtQE=
+ieee754@^1.1.13:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
+  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
 
-ignore-walk@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-3.0.1.tgz#a83e62e7d272ac0e3b551aaa82831a19b69f82f8"
-  integrity sha512-DTVlMx3IYPe0/JJcYP7Gxg7ttZZu3IInhuEhbchuqneY9wWe5Ojy2mXLBaQFUQmo0AW2r3qG7m1mg86js+gnlQ==
+ignore-walk@3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-3.0.4.tgz#c9a09f69b7c7b479a5d74ac1a3c0d4236d2a6335"
+  integrity sha512-PY6Ii8o1jMRA1z4F2hRkH/xN59ox43DavKvD3oDpfurRlOJyAHpifIwpbdv1n4jt4ov0jSpw3kQ4GhJnpBL6WQ==
   dependencies:
     minimatch "^3.0.4"
 
-ignore@^4.0.6:
-  version "4.0.6"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc"
-  integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg==
-
-ignore@^5.1.4:
-  version "5.1.8"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.8.tgz#f150a8b50a34289b33e22f5889abd4d8016f0e57"
-  integrity sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==
+ignore@^5.1.8, ignore@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a"
+  integrity sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==
 
 immediate@~3.0.5:
   version "3.0.6"
@@ -4979,27 +5197,20 @@ import-fresh@^3.2.1:
     parent-module "^1.0.0"
     resolve-from "^4.0.0"
 
+import-lazy@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/import-lazy/-/import-lazy-3.1.0.tgz#891279202c8a2280fdbd6674dbd8da1a1dfc67cc"
+  integrity sha512-8/gvXvX2JMn0F+CDlSC4l6kOmVaLOO3XLkksI7CI3Ud95KDYJuYur2b9P/PUt/i/pDAMd/DulQsNbbbmRRsDIQ==
+
 imurmurhash@^0.1.4:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
   integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
 
-indent-string@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-2.1.0.tgz#8e2d48348742121b4a8218b7a137e9a52049dc80"
-  integrity sha1-ji1INIdCEhtKghi3oTfppSBJ3IA=
-  dependencies:
-    repeating "^2.0.0"
-
-indent-string@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-3.2.0.tgz#4a5fd6d27cc332f37e5419a504dbb837105c9289"
-  integrity sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=
-
-indexof@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/indexof/-/indexof-0.0.1.tgz#82dc336d232b9062179d05ab3293a66059fd435d"
-  integrity sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=
+indent-string@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
+  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
 
 inflight@^1.0.4:
   version "1.0.6"
@@ -5009,63 +5220,33 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3:
+inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
-inherits@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.1.tgz#b17d08d326b4423e568eff719f91b0b1cbdf69f1"
-  integrity sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=
-
-inherits@2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de"
-  integrity sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=
-
-ini@^1.3.2, ini@^1.3.4, ini@~1.3.0:
+ini@^1.3.2, ini@^1.3.4:
   version "1.3.8"
   resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
-inquirer@1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-1.2.3.tgz#4dec6f32f37ef7bb0b2ed3f1d1a5c3f545074918"
-  integrity sha1-TexvMvN+97sLLtPx0aXD9UUHSRg=
-  dependencies:
-    ansi-escapes "^1.1.0"
-    chalk "^1.0.0"
-    cli-cursor "^1.0.1"
-    cli-width "^2.0.0"
-    external-editor "^1.1.0"
-    figures "^1.3.5"
-    lodash "^4.3.0"
-    mute-stream "0.0.6"
-    pinkie-promise "^2.0.0"
-    run-async "^2.2.0"
-    rx "^4.1.0"
-    string-width "^1.0.1"
-    strip-ansi "^3.0.0"
-    through "^2.3.6"
-
-inquirer@3.0.6:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-3.0.6.tgz#e04aaa9d05b7a3cb9b0f407d04375f0447190347"
-  integrity sha1-4EqqnQW3o8ubD0B9BDdfBEcZA0c=
+inquirer@6.5.2:
+  version "6.5.2"
+  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-6.5.2.tgz#ad50942375d036d327ff528c08bd5fab089928ca"
+  integrity sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==
   dependencies:
-    ansi-escapes "^1.1.0"
-    chalk "^1.0.0"
+    ansi-escapes "^3.2.0"
+    chalk "^2.4.2"
     cli-cursor "^2.1.0"
     cli-width "^2.0.0"
-    external-editor "^2.0.1"
+    external-editor "^3.0.3"
     figures "^2.0.0"
-    lodash "^4.3.0"
+    lodash "^4.17.12"
     mute-stream "0.0.7"
     run-async "^2.2.0"
-    rx "^4.1.0"
-    string-width "^2.0.0"
-    strip-ansi "^3.0.0"
+    rxjs "^6.4.0"
+    string-width "^2.1.0"
+    strip-ansi "^5.1.0"
     through "^2.3.6"
 
 interpret@^1.0.0:
@@ -5073,6 +5254,14 @@ interpret@^1.0.0:
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.2.0.tgz#d5061a6224be58e8083985f5014d844359576296"
   integrity sha512-mT34yGKMNceBQUoVn7iCDKDntA7SC6gycMAWzGx1z/CMCTV7b2AAtXlo3nRyHZ1FelRkQbQjprHSYGwzLtkVbw==
 
+into-stream@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/into-stream/-/into-stream-3.1.0.tgz#96fb0a936c12babd6ff1752a17d05616abd094c6"
+  integrity sha1-lvsKk2wSur1v8XUqF9BWFqvQlMY=
+  dependencies:
+    from2 "^2.1.1"
+    p-is-promise "^1.1.0"
+
 invariant@^2.2.2:
   version "2.2.4"
   resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6"
@@ -5085,53 +5274,17 @@ ip-regex@^2.1.0:
   resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9"
   integrity sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=
 
-ip@1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-1.0.1.tgz#c7e356cdea225ae71b36d70f2e71a92ba4e42590"
-  integrity sha1-x+NWzeoiWucbNtcPLnGpK6TkJZA=
-
-ip@^1.1.4:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-1.1.5.tgz#bdded70114290828c0a039e72ef25f5aaec4354a"
-  integrity sha1-vd7XARQpCCjAoDnnLvJfWq7ENUo=
-
-is-accessor-descriptor@^0.1.6:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6"
-  integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-accessor-descriptor@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz#169c2f6d3df1f992618072365c9b0ea1f6878656"
-  integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==
-  dependencies:
-    kind-of "^6.0.0"
-
 is-arrayish@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
   integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=
 
-is-binary-path@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-1.0.1.tgz#75f16642b480f187a711c814161fd3a4a7655898"
-  integrity sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=
-  dependencies:
-    binary-extensions "^1.0.0"
-
-is-boolean-object@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.0.tgz#e2aaad3a3a8fca34c28f6eee135b156ed2587ff0"
-  integrity sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==
+is-binary-path@~2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
+  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
   dependencies:
-    call-bind "^1.0.0"
-
-is-buffer@^1.1.5:
-  version "1.1.6"
-  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
-  integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
+    binary-extensions "^2.0.0"
 
 is-builtin-module@^1.0.0:
   version "1.0.0"
@@ -5140,11 +5293,6 @@ is-builtin-module@^1.0.0:
   dependencies:
     builtin-modules "^1.0.0"
 
-is-callable@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.4.tgz#1e1adf219e1eeb684d691f9d6a05ff0d30a24d75"
-  integrity sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==
-
 is-ci@^1.0.10:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.2.1.tgz#e3779c8ee17fccf428488f6e281187f2e632841c"
@@ -5159,96 +5307,23 @@ is-core-module@^2.2.0:
   dependencies:
     has "^1.0.3"
 
-is-data-descriptor@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56"
-  integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-data-descriptor@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz#d84876321d0e7add03990406abbbbd36ba9268c7"
-  integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==
-  dependencies:
-    kind-of "^6.0.0"
-
-is-date-object@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
-  integrity sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=
-
-is-descriptor@^0.1.0:
-  version "0.1.6"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-0.1.6.tgz#366d8240dde487ca51823b1ab9f07a10a78251ca"
-  integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==
-  dependencies:
-    is-accessor-descriptor "^0.1.6"
-    is-data-descriptor "^0.1.4"
-    kind-of "^5.0.0"
-
-is-descriptor@^1.0.0, is-descriptor@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-descriptor/-/is-descriptor-1.0.2.tgz#3b159746a66604b04f8c81524ba365c5f14d86ec"
-  integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==
-  dependencies:
-    is-accessor-descriptor "^1.0.0"
-    is-data-descriptor "^1.0.0"
-    kind-of "^6.0.2"
-
-is-directory@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/is-directory/-/is-directory-0.3.1.tgz#61339b6f2475fc772fd9c9d83f5c8575dc154ae1"
-  integrity sha1-YTObbyR1/Hcv2cnYP1yFddwVSuE=
-
-is-dotfile@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.3.tgz#a6a2f32ffd2dfb04f5ca25ecd0f6b83cf798a1e1"
-  integrity sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=
-
-is-equal-shallow@^0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534"
-  integrity sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=
-  dependencies:
-    is-primitive "^2.0.0"
-
-is-extendable@^0.1.0, is-extendable@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
-  integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
-
-is-extendable@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
-  integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
+is-core-module@^2.5.0, is-core-module@^2.8.1:
+  version "2.9.0"
+  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.9.0.tgz#e1c34429cd51c6dd9e09e0799e396e27b19a9c69"
+  integrity sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==
   dependencies:
-    is-plain-object "^2.0.4"
+    has "^1.0.3"
 
-is-extglob@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"
-  integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=
+is-docker@^2.0.0:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
+  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
 
-is-extglob@^2.1.0, is-extglob@^2.1.1:
+is-extglob@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
   integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
 
-is-finite@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa"
-  integrity sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=
-  dependencies:
-    number-is-nan "^1.0.0"
-
-is-fullwidth-code-point@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb"
-  integrity sha1-754xOG8DGn8NZDr4L95QxFfvAMs=
-  dependencies:
-    number-is-nan "^1.0.0"
-
 is-fullwidth-code-point@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
@@ -5259,19 +5334,10 @@ is-fullwidth-code-point@^3.0.0:
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
   integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
 
-is-glob@^2.0.0, is-glob@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
-  integrity sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=
-  dependencies:
-    is-extglob "^1.0.0"
-
-is-glob@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
-  integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
-  dependencies:
-    is-extglob "^2.1.0"
+is-fullwidth-code-point@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz#fae3167c729e7463f8461ce512b080a49268aa88"
+  integrity sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==
 
 is-glob@^4.0.0:
   version "4.0.0"
@@ -5287,98 +5353,70 @@ is-glob@^4.0.1:
   dependencies:
     is-extglob "^2.1.1"
 
+is-glob@^4.0.3, is-glob@~4.0.1:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
+  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
+  dependencies:
+    is-extglob "^2.1.1"
+
+is-interactive@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-interactive/-/is-interactive-1.0.0.tgz#cea6e6ae5c870a7b0a0004070b7b587e0252912e"
+  integrity sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==
+
 is-module@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
   integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=
 
-is-number-object@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.4.tgz#36ac95e741cf18b283fc1ddf5e83da798e3ec197"
-  integrity sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==
-
-is-number@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-0.1.1.tgz#69a7af116963d47206ec9bd9b48a14216f1e3806"
-  integrity sha1-aaevEWlj1HIG7JvZtIoUIW8eOAY=
-
-is-number@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f"
-  integrity sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-number@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
-  integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=
-  dependencies:
-    kind-of "^3.0.2"
-
-is-number@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
-  integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
+is-natural-number@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/is-natural-number/-/is-natural-number-4.0.1.tgz#ab9d76e1db4ced51e35de0c72ebecf09f734cde8"
+  integrity sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=
 
 is-number@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
   integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
 
-is-obj@^1.0.0, is-obj@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-1.0.1.tgz#3e4729ac1f5fde025cd7d83a896dab9f4f67db0f"
-  integrity sha1-PkcprB9f3gJc19g6iW2rn09n2w8=
-
-is-observable@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-observable/-/is-observable-1.1.0.tgz#b3e986c8f44de950867cab5403f5a3465005975e"
-  integrity sha512-NqCa4Sa2d+u7BWc6CukaObG3Fh+CU9bvixbpcXYhy2VvYS7vVGIdAgnIS5Ks3A/cqk4rebLJ9s8zBstT2aKnIA==
-  dependencies:
-    symbol-observable "^1.1.0"
+is-obj@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982"
+  integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
 
-is-path-cwd@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d"
-  integrity sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=
+is-object@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-object/-/is-object-1.0.2.tgz#a56552e1c665c9e950b4a025461da87e72f86fcf"
+  integrity sha512-2rRIahhZr2UWb45fIOuvZGpFtz0TyOZLf32KxBbSoUCeZR495zCKlWUKKUByk3geS2eAs7ZAABt0Y/Rx0GiQGA==
 
-is-path-in-cwd@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.1.tgz#5ac48b345ef675339bd6c7a48a912110b241cf52"
-  integrity sha512-FjV1RTW48E7CWM7eE/J2NJvAEEVektecDBVBE5Hh3nM1Jd0kvhHtX68Pr3xsDf857xt3Y4AkwVULK1Vku62aaQ==
-  dependencies:
-    is-path-inside "^1.0.0"
+is-path-cwd@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-2.2.0.tgz#67d43b82664a7b5191fd9119127eb300048a9fdb"
+  integrity sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==
 
-is-path-inside@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.1.tgz#8ef5b7de50437a3fdca6b4e865ef7aa55cb48036"
-  integrity sha1-jvW33lBDej/cprToZe96pVy0gDY=
-  dependencies:
-    path-is-inside "^1.0.1"
+is-path-inside@^3.0.2:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
+  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
 
-is-plain-obj@^1.1.0:
+is-plain-obj@^1.0.0, is-plain-obj@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
   integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4=
 
-is-plain-object@^2.0.1, is-plain-object@^2.0.3, is-plain-object@^2.0.4:
+is-plain-obj@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
+  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
+
+is-plain-object@^2.0.4:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
   integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
   dependencies:
     isobject "^3.0.1"
 
-is-posix-bracket@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4"
-  integrity sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=
-
-is-primitive@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
-  integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=
-
 is-promise@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-2.1.0.tgz#79a2a9ece7f096e80f36d2b2f3bc16c1ff4bf3fa"
@@ -5391,41 +5429,22 @@ is-reference@^1.2.1:
   dependencies:
     "@types/estree" "*"
 
-is-regex@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
-  integrity sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=
-  dependencies:
-    has "^1.0.1"
-
-is-regexp@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-regexp/-/is-regexp-1.0.0.tgz#fd2d883545c46bac5a633e7b9a09e87fa2cb5069"
-  integrity sha1-/S2INUXEa6xaYz57mgnof6LLUGk=
+is-retry-allowed@^1.1.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4"
+  integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg==
 
 is-stream@^1.0.1, is-stream@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
   integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
 
-is-string@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.5.tgz#40493ed198ef3ff477b8c7f92f644ec82a5cd3a6"
-  integrity sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==
-
-is-subset@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-subset/-/is-subset-0.1.1.tgz#8a59117d932de1de00f245fcdd39ce43f1e939a6"
-  integrity sha1-ilkRfZMt4d4A8kX83TnOQ/HpOaY=
-
-is-symbol@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.2.tgz#a055f6ae57192caee329e7a860118b497a950f38"
-  integrity sha512-HS8bZ9ox60yCJLH9snBpIwv9pYUAkcuLhSA1oero1UB5y9aiQpRA8y2ex945AOtCZL1lJDeIk3G5LthswI46Lw==
-  dependencies:
-    has-symbols "^1.0.0"
+is-stream@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
+  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
-is-text-path@^1.0.0:
+is-text-path@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
   integrity sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4=
@@ -5437,26 +5456,33 @@ is-typedarray@~1.0.0:
   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
   integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
 
+is-unicode-supported@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7"
+  integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==
+
 is-url@^1.2.2:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/is-url/-/is-url-1.2.4.tgz#04a4df46d28c4cff3d73d01ff06abeb318a1aa52"
   integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==
 
-is-utf8@^0.2.0:
+is-utf8@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
   integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
 
-is-windows@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-0.2.0.tgz#de1aa6d63ea29dd248737b69f1ff8b8002d2108c"
-  integrity sha1-3hqm1j6indJIc3tp8f+LgALSEIw=
-
-is-windows@^1.0.2:
+is-windows@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
   integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
 
+is-wsl@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
+  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
+  dependencies:
+    is-docker "^2.0.0"
+
 is2@2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/is2/-/is2-2.0.1.tgz#8ac355644840921ce435d94f05d3a94634d3481a"
@@ -5466,41 +5492,22 @@ is2@2.0.1:
     ip-regex "^2.1.0"
     is-url "^1.2.2"
 
-isarray@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf"
-  integrity sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=
-
-isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0:
+isarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
   integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
 
-isarray@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-2.0.1.tgz#a37d94ed9cda2d59865c9f76fe596ee1f338741e"
-  integrity sha1-o32U7ZzaLVmGXJ92/llu4fM4dB4=
-
-isbinaryfile@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/isbinaryfile/-/isbinaryfile-3.0.3.tgz#5d6def3edebf6e8ca8cae9c30183a804b5f8be80"
-  integrity sha512-8cJBL5tTd2OS0dM4jz07wQd5g0dCCqIhUxPIGtZfa5L6hWlvV5MHTITy/DBAsF+Oe2LS1X3krBUhNwaGUWpWxw==
-  dependencies:
-    buffer-alloc "^1.2.0"
+isbinaryfile@^4.0.8:
+  version "4.0.10"
+  resolved "https://registry.yarnpkg.com/isbinaryfile/-/isbinaryfile-4.0.10.tgz#0c5b5e30c2557a2f06febd37b7322946aaee42b3"
+  integrity sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==
 
 isexe@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
   integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
 
-isobject@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
-  integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
-  dependencies:
-    isarray "1.0.0"
-
-isobject@^3.0.0, isobject@^3.0.1:
+isobject@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
   integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
@@ -5510,79 +5517,84 @@ isstream@~0.1.2:
   resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
   integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=
 
-istanbul-lib-coverage@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.1.tgz#2aee0e073ad8c5f6a0b00e0dfbf52b4667472eda"
-  integrity sha512-nPvSZsVlbG9aLhZYaC3Oi1gT/tpyo3Yt5fNyf6NmcKIayz4VV/txxJFFKAK/gU4dcNn8ehsanBbVHVl0+amOLA==
+istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
+  integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==
+
+istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.0.tgz#31d18bdd127f825dd02ea7bfdfd906f8ab840e9f"
+  integrity sha512-6Lthe1hqXHBNsqvgDzGO6l03XNeu3CrG4RqQ1KM9+l5+jNGpEJfIELx1NS3SEHmJQA8np/u+E4EPRKRiu6m19A==
+  dependencies:
+    "@babel/core" "^7.12.3"
+    "@babel/parser" "^7.14.7"
+    "@istanbuljs/schema" "^0.1.2"
+    istanbul-lib-coverage "^3.2.0"
+    semver "^6.3.0"
 
-istanbul-lib-instrument@^3.0.0:
+istanbul-lib-report@^3.0.0:
   version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-3.0.0.tgz#b5f066b2a161f75788be17a9d556f40a0cf2afc9"
-  integrity sha512-eQY9vN9elYjdgN9Iv6NS/00bptm02EBBk70lRMaVjeA6QYocQgenVrSgC28TJurdnZa80AGO3ASdFN+w/njGiQ==
-  dependencies:
-    "@babel/generator" "^7.0.0"
-    "@babel/parser" "^7.0.0"
-    "@babel/template" "^7.0.0"
-    "@babel/traverse" "^7.0.0"
-    "@babel/types" "^7.0.0"
-    istanbul-lib-coverage "^2.0.1"
-    semver "^5.5.0"
+  resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6"
+  integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==
+  dependencies:
+    istanbul-lib-coverage "^3.0.0"
+    make-dir "^3.0.0"
+    supports-color "^7.1.0"
 
-istanbul@^0.4.0:
-  version "0.4.5"
-  resolved "https://registry.yarnpkg.com/istanbul/-/istanbul-0.4.5.tgz#65c7d73d4c4da84d4f3ac310b918fb0b8033733b"
-  integrity sha1-ZcfXPUxNqE1POsMQuRj7C4Azczs=
-  dependencies:
-    abbrev "1.0.x"
-    async "1.x"
-    escodegen "1.8.x"
-    esprima "2.7.x"
-    glob "^5.0.15"
-    handlebars "^4.0.1"
-    js-yaml "3.x"
-    mkdirp "0.5.x"
-    nopt "3.x"
-    once "1.x"
-    resolve "1.1.x"
-    supports-color "^3.1.0"
-    which "^1.1.1"
-    wordwrap "^1.0.0"
+istanbul-lib-source-maps@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
+  integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==
+  dependencies:
+    debug "^4.1.1"
+    istanbul-lib-coverage "^3.0.0"
+    source-map "^0.6.1"
 
-jasmine-core@^2.99.0, jasmine-core@~2.99.0:
-  version "2.99.1"
-  resolved "https://registry.yarnpkg.com/jasmine-core/-/jasmine-core-2.99.1.tgz#e6400df1e6b56e130b61c4bcd093daa7f6e8ca15"
-  integrity sha1-5kAN8ea1bhMLYcS80JPap/boyhU=
+istanbul-reports@^3.0.5:
+  version "3.1.4"
+  resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.4.tgz#1b6f068ecbc6c331040aab5741991273e609e40c"
+  integrity sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw==
+  dependencies:
+    html-escaper "^2.0.0"
+    istanbul-lib-report "^3.0.0"
 
-jasmine-ts@^0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/jasmine-ts/-/jasmine-ts-0.3.2.tgz#831cad901a070f7fe919c91e2c87b61f9ee7cb95"
-  integrity sha512-ze8IxVX2E6j4ux4W0m8tBwbVds6XYWA0CMER50dV0lp83dF2UoONdbzE+aJLeu5n7Bi2IKTzcGHWGt7n/Yo6sw==
+isurl@^1.0.0-alpha5:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/isurl/-/isurl-1.0.0.tgz#b27f4f49f3cdaa3ea44a0a5b7f3462e6edc39d67"
+  integrity sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==
   dependencies:
-    yargs "^16.2.0"
+    has-to-string-tag-x "^1.2.0"
+    is-object "^1.0.1"
 
-jasmine@^2.99.0:
-  version "2.99.0"
-  resolved "https://registry.yarnpkg.com/jasmine/-/jasmine-2.99.0.tgz#8ca72d102e639b867c6489856e0e18a9c7aa42b7"
-  integrity sha1-jKctEC5jm4Z8ZImFbg4YqceqQrc=
+jasmine-core@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/jasmine-core/-/jasmine-core-4.1.0.tgz#2377349b0e8bfd3fbdb36c9e4f09e3b1a17cf5c2"
+  integrity sha512-8E8BiffCL8sBwK1zU9cbavLe8xpJAgOduSJ6N8PJVv8VosQ/nxVTuXj2kUeHxTlZBVvh24G19ga7xdiaxlceKg==
+
+jasmine-ts@^0.4.0:
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/jasmine-ts/-/jasmine-ts-0.4.0.tgz#b228c450cb70471344ce154c0e47d2f588f4a479"
+  integrity sha512-bIAWJKUwxfuZfGI1ctEbny7+dsyFzsN0eLzOokxh0qIUCofai2WUEKoe3MMllkGEBXJzbEVYr2IyhJBv4j7SBA==
   dependencies:
-    exit "^0.1.2"
-    glob "^7.0.6"
-    jasmine-core "~2.99.0"
+    yargs "^17.0.1"
 
-jest-get-type@^22.1.0:
-  version "22.4.3"
-  resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-22.4.3.tgz#e3a8504d8479342dd4420236b322869f18900ce4"
-  integrity sha512-/jsz0Y+V29w1chdXVygEKSz2nBoHoYqNShPe+QgxSNjAuP1i8+k4LbQNrfoliKej0P45sivkSCh7yiD6ubHS3w==
+jasmine@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/jasmine/-/jasmine-4.1.0.tgz#0de347ca8bb6cc764b0ed186ae4cfc45bd64bdc4"
+  integrity sha512-4VhjbUgwfNS9CBnUMoSWr9tdNgOoOhNIjAD8YRxTn+PmOf4qTSC0Uqhk66dWGnz2vJxtNIU0uBjiwnsp4Ud9VA==
+  dependencies:
+    glob "^7.1.6"
+    jasmine-core "^4.1.0"
 
-jest-validate@^23.5.0:
-  version "23.6.0"
-  resolved "https://registry.yarnpkg.com/jest-validate/-/jest-validate-23.6.0.tgz#36761f99d1ed33fcd425b4e4c5595d62b6597474"
-  integrity sha512-OFKapYxe72yz7agrDAWi8v2WL8GIfVqcbKRCLbRG9PAxtzF9b1SEDdTpytNDN12z2fJynoBwpMpvj2R39plI2A==
+jest-worker@^27.4.5:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
+  integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==
   dependencies:
-    chalk "^2.0.1"
-    jest-get-type "^22.1.0"
-    leven "^2.1.0"
-    pretty-format "^23.6.0"
+    "@types/node" "*"
+    merge-stream "^2.0.0"
+    supports-color "^8.0.0"
 
 "js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
   version "4.0.0"
@@ -5594,15 +5606,7 @@ js-tokens@^3.0.2:
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b"
   integrity sha1-mGbfOVECEw449/mWvOtlRDIJwls=
 
-js-yaml@3.x, js-yaml@^3.12.0, js-yaml@^3.9.0:
-  version "3.13.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847"
-  integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-js-yaml@^3.13.1:
+js-yaml@3.14.1, js-yaml@^3.13.1:
   version "3.14.1"
   resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
   integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
@@ -5610,6 +5614,13 @@ js-yaml@^3.13.1:
     argparse "^1.0.7"
     esprima "^4.0.0"
 
+js-yaml@4.1.0, js-yaml@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
+  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
+  dependencies:
+    argparse "^2.0.1"
+
 jsbn@~0.1.0:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
@@ -5625,21 +5636,31 @@ jsesc@~0.5.0:
   resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
   integrity sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=
 
+json-buffer@3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.0.tgz#5b1f397afc75d677bde8bcfc0e47e1f9a3d9a898"
+  integrity sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=
+
+json-buffer@3.0.1, json-buffer@~3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13"
+  integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==
+
 json-parse-better-errors@^1.0.1, json-parse-better-errors@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
   integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==
 
+json-parse-even-better-errors@^2.3.0:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
+  integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
+
 json-schema-traverse@^0.4.1:
   version "0.4.1"
   resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
   integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
 
-json-schema-traverse@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2"
-  integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==
-
 json-schema@0.2.3:
   version "0.2.3"
   resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13"
@@ -5655,18 +5676,6 @@ json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1:
   resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
   integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
 
-json3@3.3.2:
-  version "3.3.2"
-  resolved "https://registry.yarnpkg.com/json3/-/json3-3.3.2.tgz#3c0434743df93e2f5c42aee7b19bcb483575f4e1"
-  integrity sha1-PAQ0dD35Pi9cQq7nsZvLSDV19OE=
-
-json5@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-1.0.1.tgz#779fb0018604fa854eacbf6252180d83543e3dbe"
-  integrity sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==
-  dependencies:
-    minimist "^1.2.0"
-
 json5@^2.1.2:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
@@ -5674,6 +5683,11 @@ json5@^2.1.2:
   dependencies:
     minimist "^1.2.5"
 
+json5@^2.2.1:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.1.tgz#655d50ed1e6f95ad1a3caababd2b0efda10b395c"
+  integrity sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA==
+
 jsonfile@^2.1.0:
   version "2.4.0"
   resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-2.4.0.tgz#3736a2b428b87bbda0cc83b53fa3d633a35c2ae8"
@@ -5688,6 +5702,15 @@ jsonfile@^4.0.0:
   optionalDependencies:
     graceful-fs "^4.1.6"
 
+jsonfile@^6.0.1:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
+  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
+  dependencies:
+    universalify "^2.0.0"
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
 jsonparse@^1.2.0:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
@@ -5703,45 +5726,49 @@ jsprim@^1.2.2:
     json-schema "0.2.3"
     verror "1.10.0"
 
-jszip@^3.1.3:
-  version "3.1.5"
-  resolved "https://registry.yarnpkg.com/jszip/-/jszip-3.1.5.tgz#e3c2a6c6d706ac6e603314036d43cd40beefdf37"
-  integrity sha512-5W8NUaFRFRqTOL7ZDDrx5qWHJyBXy6velVudIzQUSoqAAYqzSh2Z7/m0Rf1QbmQJccegD0r+YZxBjzqoBiEeJQ==
+jszip@^3.6.0:
+  version "3.9.1"
+  resolved "https://registry.yarnpkg.com/jszip/-/jszip-3.9.1.tgz#784e87f328450d1e8151003a9c67733e2b901051"
+  integrity sha512-H9A60xPqJ1CuC4Ka6qxzXZeU8aNmgOeP5IFqwJbQQwtu2EUYxota3LdsiZWplF7Wgd9tkAd0mdu36nceSaPuYw==
   dependencies:
-    core-js "~2.3.0"
-    es6-promise "~3.0.2"
-    lie "~3.1.0"
+    lie "~3.3.0"
     pako "~1.0.2"
-    readable-stream "~2.0.6"
+    readable-stream "~2.3.6"
+    set-immediate-shim "~1.0.1"
 
-karma-chrome-launcher@^2.1.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/karma-chrome-launcher/-/karma-chrome-launcher-2.2.0.tgz#cf1b9d07136cc18fe239327d24654c3dbc368acf"
-  integrity sha512-uf/ZVpAabDBPvdPdveyk1EPgbnloPvFFGgmRhYLTDH7gEB4nZdSBk8yTU47w1g/drLSx5uMOkjKk7IWKfWg/+w==
+karma-chrome-launcher@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/karma-chrome-launcher/-/karma-chrome-launcher-3.1.1.tgz#baca9cc071b1562a1db241827257bfe5cab597ea"
+  integrity sha512-hsIglcq1vtboGPAN+DGCISCFOxW+ZVnIqhDQcCMqqCp+4dmJ0Qpq5QAjkbA0X2L9Mi6OBkHi2Srrbmm7pUKkzQ==
   dependencies:
-    fs-access "^1.0.0"
     which "^1.2.1"
 
-karma-coverage@^1.1.1:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/karma-coverage/-/karma-coverage-1.1.2.tgz#cc09dceb589a83101aca5fe70c287645ef387689"
-  integrity sha512-eQawj4Cl3z/CjxslYy9ariU4uDh7cCNFZHNWXWRpl0pNeblY/4wHR7M7boTYXWrn9bY0z2pZmr11eKje/S/hIw==
-  dependencies:
-    dateformat "^1.0.6"
-    istanbul "^0.4.0"
-    lodash "^4.17.0"
-    minimatch "^3.0.0"
-    source-map "^0.5.1"
+karma-coverage@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/karma-coverage/-/karma-coverage-2.2.0.tgz#64f838b66b71327802e7f6f6c39d569b7024e40c"
+  integrity sha512-gPVdoZBNDZ08UCzdMHHhEImKrw1+PAOQOIiffv1YsvxFhBjqvo/SVXNk4tqn1SYqX0BJZT6S/59zgxiBe+9OuA==
+  dependencies:
+    istanbul-lib-coverage "^3.2.0"
+    istanbul-lib-instrument "^5.1.0"
+    istanbul-lib-report "^3.0.0"
+    istanbul-lib-source-maps "^4.0.1"
+    istanbul-reports "^3.0.5"
+    minimatch "^3.0.4"
 
-karma-firefox-launcher@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/karma-firefox-launcher/-/karma-firefox-launcher-1.1.0.tgz#2c47030452f04531eb7d13d4fc7669630bb93339"
-  integrity sha512-LbZ5/XlIXLeQ3cqnCbYLn+rOVhuMIK9aZwlP6eOLGzWdo1UVp7t6CN3DP4SafiRLjexKwHeKHDm0c38Mtd3VxA==
+karma-firefox-launcher@^2.1.2:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/karma-firefox-launcher/-/karma-firefox-launcher-2.1.2.tgz#9a38cc783c579a50f3ed2a82b7386186385cfc2d"
+  integrity sha512-VV9xDQU1QIboTrjtGVD4NCfzIH7n01ZXqy/qpBhnOeGVOkG5JYPEm8kuSd7psHE6WouZaQ9Ool92g8LFweSNMA==
+  dependencies:
+    is-wsl "^2.2.0"
+    which "^2.0.1"
 
-karma-jasmine@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/karma-jasmine/-/karma-jasmine-1.1.2.tgz#394f2b25ffb4a644b9ada6f22d443e2fd08886c3"
-  integrity sha1-OU8rJf+0pkS5rabyLUQ+L9CIhsM=
+karma-jasmine@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/karma-jasmine/-/karma-jasmine-5.0.0.tgz#e270c86214b5390df77ebe1b6eaab79664d87d9f"
+  integrity sha512-dsFkCoTwyoNyQnMgegS72wIA/2xPDJG5yzTry0448U6lAY7P60Wgg4UuLlbdLv8YHbimgNpDXjjmfPdc99EDWQ==
+  dependencies:
+    jasmine-core "^4.1.0"
 
 karma-mocha-reporter@^2.2.3:
   version "2.2.5"
@@ -5765,95 +5792,91 @@ karma-safari-launcher@^1.0.0:
   resolved "https://registry.yarnpkg.com/karma-safari-launcher/-/karma-safari-launcher-1.0.0.tgz#96982a2cc47d066aae71c553babb28319115a2ce"
   integrity sha1-lpgqLMR9BmquccVTursoMZEVos4=
 
-karma-sauce-launcher@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/karma-sauce-launcher/-/karma-sauce-launcher-2.0.2.tgz#dbf98e70d86bf287b03a537cf637eb7aefa975c3"
-  integrity sha512-jLUFaJhHMcKpxFWUesyWYihzM5FvQiJsDwGcCtKeOy2lsWhkVw0V0Byqb1d+wU6myU1mribBtsIcub23HS4kWA==
+karma-sauce-launcher@^4.3.6:
+  version "4.3.6"
+  resolved "https://registry.yarnpkg.com/karma-sauce-launcher/-/karma-sauce-launcher-4.3.6.tgz#274f999ce5a3bc76577a438839cb0dbbf2746a48"
+  integrity sha512-Ej62q4mUPFktyAm8g0g8J5qhwEkXwdHrwtiV4pZjKNHNnSs+4qgDyzs3VkpOy3AmNTsTqQXUN/lpiy0tZpDJZQ==
   dependencies:
-    sauce-connect-launcher "^1.2.4"
-    saucelabs "^1.5.0"
-    selenium-webdriver "^4.0.0-alpha.1"
+    global-agent "^2.1.12"
+    saucelabs "^4.6.3"
+    webdriverio "^6.7.0"
 
-karma-sourcemap-loader@^0.3.7:
-  version "0.3.7"
-  resolved "https://registry.yarnpkg.com/karma-sourcemap-loader/-/karma-sourcemap-loader-0.3.7.tgz#91322c77f8f13d46fed062b042e1009d4c4505d8"
-  integrity sha1-kTIsd/jxPUb+0GKwQuEAnUxFBdg=
+karma-sourcemap-loader@^0.3.8:
+  version "0.3.8"
+  resolved "https://registry.yarnpkg.com/karma-sourcemap-loader/-/karma-sourcemap-loader-0.3.8.tgz#d4bae72fb7a8397328a62b75013d2df937bdcf9c"
+  integrity sha512-zorxyAakYZuBcHRJE+vbrK2o2JXLFWK8VVjiT/6P+ltLBUGUvqTEkUiQ119MGdOrK7mrmxXHZF1/pfT6GgIZ6g==
   dependencies:
     graceful-fs "^4.1.2"
 
-karma-webpack@^4.0.0-rc.2:
-  version "4.0.0-rc.5"
-  resolved "https://registry.yarnpkg.com/karma-webpack/-/karma-webpack-4.0.0-rc.5.tgz#7282945c9af56d9fc6e0bb053df9afc73dae1b15"
-  integrity sha512-JCFLWIpX1Yx/pX086/2K+c1QdsPQI3K4HVcCo4QzYPWvu7rHOHMV2d3YYVMqL1mZd7iqFlcU8vBO8xKH4CpTyg==
+karma-webpack@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/karma-webpack/-/karma-webpack-5.0.0.tgz#2a2c7b80163fe7ffd1010f83f5507f95ef39f840"
+  integrity sha512-+54i/cd3/piZuP3dr54+NcFeKOPnys5QeM1IY+0SPASwrtHsliXUiCL50iW+K9WWA7RvamC4macvvQ86l3KtaA==
   dependencies:
-    async "^2.0.0"
-    loader-utils "^1.1.0"
-    source-map "^0.5.6"
-    webpack-dev-middleware "^3.2.0"
-
-karma@^3.1.1:
-  version "3.1.4"
-  resolved "https://registry.yarnpkg.com/karma/-/karma-3.1.4.tgz#3890ca9722b10d1d14b726e1335931455788499e"
-  integrity sha512-31Vo8Qr5glN+dZEVIpnPCxEGleqE0EY6CtC2X9TagRV3rRQ3SNrvfhddICkJgUK3AgqpeKSZau03QumTGhGoSw==
-  dependencies:
-    bluebird "^3.3.0"
-    body-parser "^1.16.1"
-    chokidar "^2.0.3"
-    colors "^1.1.0"
-    combine-lists "^1.0.0"
-    connect "^3.6.0"
-    core-js "^2.2.0"
+    glob "^7.1.3"
+    minimatch "^3.0.4"
+    webpack-merge "^4.1.5"
+
+karma@^6.3.19:
+  version "6.3.19"
+  resolved "https://registry.yarnpkg.com/karma/-/karma-6.3.19.tgz#e50759667b0b9c6ad758655db0547d3ab4d2abf5"
+  integrity sha512-NDhWckzES/Y9xMiddyU1RzaKL76/scCsu8Mp0vR0Z3lQRvC3p72+Ab4ppoxs36S9tyPNX5V48yvaV++RNEBPZw==
+  dependencies:
+    "@colors/colors" "1.5.0"
+    body-parser "^1.19.0"
+    braces "^3.0.2"
+    chokidar "^3.5.1"
+    connect "^3.7.0"
     di "^0.0.1"
-    dom-serialize "^2.2.0"
-    expand-braces "^0.1.1"
-    flatted "^2.0.0"
-    glob "^7.1.1"
-    graceful-fs "^4.1.2"
-    http-proxy "^1.13.0"
-    isbinaryfile "^3.0.0"
-    lodash "^4.17.5"
-    log4js "^3.0.0"
-    mime "^2.3.1"
-    minimatch "^3.0.2"
-    optimist "^0.6.1"
-    qjobs "^1.1.4"
-    range-parser "^1.2.0"
-    rimraf "^2.6.0"
-    safe-buffer "^5.0.1"
-    socket.io "2.1.1"
+    dom-serialize "^2.2.1"
+    glob "^7.1.7"
+    graceful-fs "^4.2.6"
+    http-proxy "^1.18.1"
+    isbinaryfile "^4.0.8"
+    lodash "^4.17.21"
+    log4js "^6.4.1"
+    mime "^2.5.2"
+    minimatch "^3.0.4"
+    mkdirp "^0.5.5"
+    qjobs "^1.2.0"
+    range-parser "^1.2.1"
+    rimraf "^3.0.2"
+    socket.io "^4.4.1"
     source-map "^0.6.1"
-    tmp "0.0.33"
-    useragent "2.3.0"
+    tmp "^0.2.1"
+    ua-parser-js "^0.7.30"
+    yargs "^16.1.1"
 
 kew@^0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/kew/-/kew-0.7.0.tgz#79d93d2d33363d6fdd2970b335d9141ad591d79b"
   integrity sha1-edk9LTM2PW/dKXCzNdkUGtWR15s=
 
-kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
-  integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
+keyv@3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/keyv/-/keyv-3.0.0.tgz#44923ba39e68b12a7cec7df6c3268c031f2ef373"
+  integrity sha512-eguHnq22OE3uVoSYG0LVWNP+4ppamWr9+zWBe1bsNcovIMy6huUJFPgy4mGwCd/rnl3vOLGW1MTlu4c57CT1xA==
   dependencies:
-    is-buffer "^1.1.5"
+    json-buffer "3.0.0"
 
-kind-of@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57"
-  integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc=
+keyv@^4.0.0:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/keyv/-/keyv-4.2.2.tgz#4b6f602c0228ef4d8214c03c520bef469ed6b768"
+  integrity sha512-uYS0vKTlBIjNCAUqrjlxmruxOEiZxZIHXyp32sdcGmP+ukFrmWUnE//RcPXJH3Vxrni1H2gsQbjHE0bH7MtMQQ==
   dependencies:
-    is-buffer "^1.1.5"
+    compress-brotli "^1.3.6"
+    json-buffer "3.0.1"
 
-kind-of@^5.0.0:
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-5.1.0.tgz#729c91e2d857b7a419a1f9aa65685c4c33f5845d"
-  integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==
-
-kind-of@^6.0.0, kind-of@^6.0.2:
+kind-of@^6.0.2:
   version "6.0.2"
   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.2.tgz#01146b36a6218e64e58f3a8d66de5d7fc6f6d051"
   integrity sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==
 
+kind-of@^6.0.3:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
+  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
+
 klaw@^1.0.0:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/klaw/-/klaw-1.3.1.tgz#4088433b46b3b1ba259d78785d8e96f73ba02439"
@@ -5861,10 +5884,12 @@ klaw@^1.0.0:
   optionalDependencies:
     graceful-fs "^4.1.9"
 
-leven@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/leven/-/leven-2.1.0.tgz#c2e7a9f772094dee9d34202ae8acce4687875580"
-  integrity sha1-wuep93IJTe6dNCAq6KzORoeHVYA=
+lazystream@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/lazystream/-/lazystream-1.0.1.tgz#494c831062f1f9408251ec44db1cba29242a2638"
+  integrity sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==
+  dependencies:
+    readable-stream "^2.0.5"
 
 levn@^0.4.1:
   version "0.4.1"
@@ -5882,98 +5907,64 @@ levn@~0.3.0:
     prelude-ls "~1.1.2"
     type-check "~0.3.2"
 
-lie@~3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/lie/-/lie-3.1.1.tgz#9a436b2cc7746ca59de7a41fa469b3efb76bd87e"
-  integrity sha1-mkNrLMd0bKWd56QfpGmz77dr2H4=
+lie@~3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/lie/-/lie-3.3.0.tgz#dcf82dee545f46074daf200c7c1c5a08e0f40f6a"
+  integrity sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==
   dependencies:
     immediate "~3.0.5"
 
-lint-staged@^8.0.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-8.1.0.tgz#dbc3ae2565366d8f20efb9f9799d076da64863f2"
-  integrity sha512-yfSkyJy7EuVsaoxtUSEhrD81spdJOe/gMTGea3XaV7HyoRhTb9Gdlp6/JppRZERvKSEYXP9bjcmq6CA5oL2lYQ==
-  dependencies:
-    "@iamstarkov/listr-update-renderer" "0.4.1"
-    chalk "^2.3.1"
-    commander "^2.14.1"
-    cosmiconfig "5.0.6"
-    debug "^3.1.0"
-    dedent "^0.7.0"
-    del "^3.0.0"
-    execa "^1.0.0"
-    find-parent-dir "^0.3.0"
-    g-status "^2.0.2"
-    is-glob "^4.0.0"
-    is-windows "^1.0.2"
-    jest-validate "^23.5.0"
-    listr "^0.14.2"
-    lodash "^4.17.5"
-    log-symbols "^2.2.0"
-    micromatch "^3.1.8"
-    npm-which "^3.0.1"
-    p-map "^1.1.1"
-    path-is-inside "^1.0.2"
-    pify "^3.0.0"
-    please-upgrade-node "^3.0.2"
-    staged-git-files "1.1.2"
-    string-argv "^0.0.2"
-    stringify-object "^3.2.2"
-
-listr-silent-renderer@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz#924b5a3757153770bf1a8e3fbf74b8bbf3f9242e"
-  integrity sha1-kktaN1cVN3C/Go4/v3S4u/P5JC4=
-
-listr-update-renderer@^0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/listr-update-renderer/-/listr-update-renderer-0.5.0.tgz#4ea8368548a7b8aecb7e06d8c95cb45ae2ede6a2"
-  integrity sha512-tKRsZpKz8GSGqoI/+caPmfrypiaq+OQCbd+CovEC24uk1h952lVj5sC7SqyFUm+OaJ5HN/a1YLt5cit2FMNsFA==
-  dependencies:
-    chalk "^1.1.3"
-    cli-truncate "^0.2.1"
-    elegant-spinner "^1.0.1"
-    figures "^1.7.0"
-    indent-string "^3.0.0"
-    log-symbols "^1.0.2"
-    log-update "^2.3.0"
-    strip-ansi "^3.0.1"
-
-listr-verbose-renderer@^0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/listr-verbose-renderer/-/listr-verbose-renderer-0.5.0.tgz#f1132167535ea4c1261102b9f28dac7cba1e03db"
-  integrity sha512-04PDPqSlsqIOaaaGZ+41vq5FejI9auqTInicFRndCBgE3bXG8D6W1I+mWhk+1nqbHmyhla/6BUrd5OSiHwKRXw==
+lighthouse-logger@^1.0.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/lighthouse-logger/-/lighthouse-logger-1.3.0.tgz#ba6303e739307c4eee18f08249524e7dafd510db"
+  integrity sha512-BbqAKApLb9ywUli+0a+PcV04SyJ/N1q/8qgCNe6U97KbPCS1BTksEuHFLYdvc8DltuhfxIUBqDZsC0bBGtl3lA==
   dependencies:
-    chalk "^2.4.1"
-    cli-cursor "^2.1.0"
-    date-fns "^1.27.2"
-    figures "^2.0.0"
+    debug "^2.6.9"
+    marky "^1.2.2"
 
-listr@^0.14.2:
-  version "0.14.3"
-  resolved "https://registry.yarnpkg.com/listr/-/listr-0.14.3.tgz#2fea909604e434be464c50bddba0d496928fa586"
-  integrity sha512-RmAl7su35BFd/xoMamRjpIE4j3v+L28o8CT5YhAXQJm1fD+1l9ngXY8JAQRJ+tFK2i5njvi0iRUKV09vPwA0iA==
-  dependencies:
-    "@samverschueren/stream-to-observable" "^0.3.0"
-    is-observable "^1.1.0"
-    is-promise "^2.1.0"
-    is-stream "^1.1.0"
-    listr-silent-renderer "^1.1.1"
-    listr-update-renderer "^0.5.0"
-    listr-verbose-renderer "^0.5.0"
-    p-map "^2.0.0"
-    rxjs "^6.3.3"
+lilconfig@2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/lilconfig/-/lilconfig-2.0.4.tgz#f4507d043d7058b380b6a8f5cb7bcd4b34cee082"
+  integrity sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA==
 
-load-json-file@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0"
-  integrity sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=
-  dependencies:
-    graceful-fs "^4.1.2"
-    parse-json "^2.2.0"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
-    strip-bom "^2.0.0"
+lines-and-columns@^1.1.6:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
+  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
+
+lint-staged@^12.4.1:
+  version "12.4.1"
+  resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-12.4.1.tgz#63fa27bfc8a33515f6902f63f6670864f1fb233c"
+  integrity sha512-PTXgzpflrQ+pODQTG116QNB+Q6uUTDg5B5HqGvNhoQSGt8Qy+MA/6zSnR8n38+sxP5TapzeQGTvoKni0KRS8Vg==
+  dependencies:
+    cli-truncate "^3.1.0"
+    colorette "^2.0.16"
+    commander "^8.3.0"
+    debug "^4.3.3"
+    execa "^5.1.1"
+    lilconfig "2.0.4"
+    listr2 "^4.0.1"
+    micromatch "^4.0.4"
+    normalize-path "^3.0.0"
+    object-inspect "^1.12.0"
+    pidtree "^0.5.0"
+    string-argv "^0.3.1"
+    supports-color "^9.2.1"
+    yaml "^1.10.2"
+
+listr2@^4.0.1:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/listr2/-/listr2-4.0.5.tgz#9dcc50221583e8b4c71c43f9c7dfd0ef546b75d5"
+  integrity sha512-juGHV1doQdpNT3GSTs9IUN43QJb7KHdF9uqg7Vufs/tG9VTzpFphqF4pm/ICdAABGQxsyNn9CiYA3StkI6jpwA==
+  dependencies:
+    cli-truncate "^2.1.0"
+    colorette "^2.0.16"
+    log-update "^4.0.0"
+    p-map "^4.0.0"
+    rfdc "^1.3.0"
+    rxjs "^7.5.5"
+    through "^2.3.8"
+    wrap-ansi "^7.0.0"
 
 load-json-file@^4.0.0:
   version "4.0.0"
@@ -5985,24 +5976,15 @@ load-json-file@^4.0.0:
     pify "^3.0.0"
     strip-bom "^3.0.0"
 
-loader-runner@^2.3.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-2.3.1.tgz#026f12fe7c3115992896ac02ba022ba92971b979"
-  integrity sha512-By6ZFY7ETWOc9RFaAIb23IjJVcM4dvJC/N57nmdz9RSkMXvAXGI7SyVlAw3v8vjtDRlqThgVDVmTnr9fqMlxkw==
-
-loader-utils@^1.0.2, loader-utils@^1.1.0:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-1.2.3.tgz#1ff5dc6911c9f0a062531a4c04b609406108c2c7"
-  integrity sha512-fkpz8ejdnEMG3s37wGL07iSBDg99O9D5yflE9RGNH3hRdx9SOwYfnGYdZOUIZitN8E+E2vkq3MUMYMvPYl5ZZA==
-  dependencies:
-    big.js "^5.2.2"
-    emojis-list "^2.0.0"
-    json5 "^1.0.1"
+loader-runner@^4.2.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1"
+  integrity sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==
 
 loader-utils@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.0.tgz#e4cace5b816d425a166b5f097e10cd12b36064b0"
-  integrity sha512-rP4F0h2RaWSvPEkD7BLDFQnvSf+nK+wr3ESUjNTyAGobqrijmW92zc+SO6d4p4B1wh7+B/Jg1mkQe5NYUEHtHQ==
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.2.tgz#d6e3b4fb81870721ae4e0868ab11dd638368c129"
+  integrity sha512-TM57VeHptv569d/GKh6TAYdzKblwDNiumOdkFnejjD0XwTH87K90w3O7AiJRqdQoXygvi1VQTJTLGhJl7WqA7A==
   dependencies:
     big.js "^5.2.2"
     emojis-list "^3.0.0"
@@ -6031,6 +6013,13 @@ locate-path@^5.0.0:
   dependencies:
     p-locate "^4.1.0"
 
+locate-path@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
+  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
+  dependencies:
+    p-locate "^5.0.0"
+
 lodash._arraycopy@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/lodash._arraycopy/-/lodash._arraycopy-3.0.0.tgz#76e7b7c1f1fb92547374878a562ed06a3e50f6e1"
@@ -6061,21 +6050,11 @@ lodash._baseclone@^3.0.0:
     lodash.isarray "^3.0.0"
     lodash.keys "^3.0.0"
 
-lodash._baseclone@^4.0.0:
-  version "4.5.7"
-  resolved "https://registry.yarnpkg.com/lodash._baseclone/-/lodash._baseclone-4.5.7.tgz#ce42ade08384ef5d62fa77c30f61a46e686f8434"
-  integrity sha1-zkKt4IOE711i+nfDD2GkbmhvhDQ=
-
 lodash._basecopy@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz#8da0e6a876cf344c0ad8a54882111dd3c5c7ca36"
   integrity sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=
 
-lodash._basecreate@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/lodash._basecreate/-/lodash._basecreate-3.0.3.tgz#1bc661614daa7fc311b7d03bf16806a0213cf821"
-  integrity sha1-G8ZhYU2qf8MRt9A78WgGoCE8+CE=
-
 lodash._basefor@^3.0.0:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/lodash._basefor/-/lodash._basefor-3.0.3.tgz#7550b4e9218ef09fad24343b612021c79b4c20c2"
@@ -6101,11 +6080,6 @@ lodash._reinterpolate@^3.0.0, lodash._reinterpolate@~3.0.0:
   resolved "https://registry.yarnpkg.com/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d"
   integrity sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=
 
-lodash._stack@^4.0.0:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/lodash._stack/-/lodash._stack-4.1.3.tgz#751aa76c1b964b047e76d14fc72a093fcb5e2dd0"
-  integrity sha1-dRqnbBuWSwR+dtFPxyoJP8teLdA=
-
 lodash.clone@3.0.3:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/lodash.clone/-/lodash.clone-3.0.3.tgz#84688c73d32b5a90ca25616963f189252a997043"
@@ -6120,31 +6094,25 @@ lodash.clonedeep@^4.5.0:
   resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
   integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
 
-lodash.create@3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/lodash.create/-/lodash.create-3.1.1.tgz#d7f2849f0dbda7e04682bb8cd72ab022461debe7"
-  integrity sha1-1/KEnw29p+BGgruM1yqwIkYd6+c=
-  dependencies:
-    lodash._baseassign "^3.0.0"
-    lodash._basecreate "^3.0.0"
-    lodash._isiterateecall "^3.0.0"
-
 lodash.debounce@^4.0.8:
   version "4.0.8"
   resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
   integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168=
 
-lodash.defaultsdeep@4.3.2:
-  version "4.3.2"
-  resolved "https://registry.yarnpkg.com/lodash.defaultsdeep/-/lodash.defaultsdeep-4.3.2.tgz#6c1a586e6c5647b0e64e2d798141b8836158be8a"
-  integrity sha1-bBpYbmxWR7DmTi15gUG4g2FYvoo=
-  dependencies:
-    lodash._baseclone "^4.0.0"
-    lodash._stack "^4.0.0"
-    lodash.isplainobject "^4.0.0"
-    lodash.keysin "^4.0.0"
-    lodash.mergewith "^4.0.0"
-    lodash.rest "^4.0.0"
+lodash.defaults@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/lodash.defaults/-/lodash.defaults-4.2.0.tgz#d09178716ffea4dde9e5fb7b37f6f0802274580c"
+  integrity sha1-0JF4cW/+pN3p5ft7N/bwgCJ0WAw=
+
+lodash.defaultsdeep@4.6.1:
+  version "4.6.1"
+  resolved "https://registry.yarnpkg.com/lodash.defaultsdeep/-/lodash.defaultsdeep-4.6.1.tgz#512e9bd721d272d94e3d3a63653fa17516741ca6"
+  integrity sha512-3j8wdDzYuWO3lM3Reg03MuQR957t287Rpcxp1njpEa8oDrikb+FwGdW3n+FELh/A6qib6yPit0j/pv9G/yeAqA==
+
+lodash.difference@^4.5.0:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/lodash.difference/-/lodash.difference-4.5.0.tgz#9ccb4e505d486b91651345772885a2df27fd017c"
+  integrity sha1-nMtOUF1Ia5FlE0V3KIWi3yf9AXw=
 
 lodash.flatten@^4.4.0:
   version "4.4.0"
@@ -6161,7 +6129,17 @@ lodash.isarray@^3.0.0:
   resolved "https://registry.yarnpkg.com/lodash.isarray/-/lodash.isarray-3.0.4.tgz#79e4eb88c36a8122af86f844aa9bcd851b5fbb55"
   integrity sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=
 
-lodash.isplainobject@^4.0.0:
+lodash.ismatch@^4.4.0:
+  version "4.4.0"
+  resolved "https://registry.yarnpkg.com/lodash.ismatch/-/lodash.ismatch-4.4.0.tgz#756cb5150ca3ba6f11085a78849645f188f85f37"
+  integrity sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc=
+
+lodash.isobject@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/lodash.isobject/-/lodash.isobject-3.0.2.tgz#3c8fb8d5b5bf4bf90ae06e14f2a530a4ed935e1d"
+  integrity sha1-PI+41bW/S/kK4G4U8qUwpO2TXh0=
+
+lodash.isplainobject@^4.0.6:
   version "4.0.6"
   resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb"
   integrity sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=
@@ -6175,27 +6153,22 @@ lodash.keys@^3.0.0:
     lodash.isarguments "^3.0.0"
     lodash.isarray "^3.0.0"
 
-lodash.keysin@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.keysin/-/lodash.keysin-4.2.0.tgz#8cc3fb35c2d94acc443a1863e02fa40799ea6f28"
-  integrity sha1-jMP7NcLZSsxEOhhj4C+kB5nqbyg=
-
 lodash.map@^4.5.1:
   version "4.6.0"
   resolved "https://registry.yarnpkg.com/lodash.map/-/lodash.map-4.6.0.tgz#771ec7839e3473d9c4cde28b19394c3562f4f6d3"
   integrity sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=
 
-lodash.mergewith@^4.0.0:
-  version "4.6.1"
-  resolved "https://registry.yarnpkg.com/lodash.mergewith/-/lodash.mergewith-4.6.1.tgz#639057e726c3afbdb3e7d42741caa8d6e4335927"
-  integrity sha512-eWw5r+PYICtEBgrBE5hhlT6aAa75f411bgDz/ZL2KZqYV03USvucsxcHUIlGTDTECs1eunpI7HOV7U+WLDvNdQ==
+lodash.merge@4.6.2, lodash.merge@^4.6.1, lodash.merge@^4.6.2:
+  version "4.6.2"
+  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
+  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
 
-lodash.rest@^4.0.0:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/lodash.rest/-/lodash.rest-4.0.5.tgz#954ef75049262038c96d1fc98b28fdaf9f0772aa"
-  integrity sha1-lU73UEkmIDjJbR/Jiyj9r58Hcqo=
+lodash.sortby@^4.7.0:
+  version "4.7.0"
+  resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438"
+  integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=
 
-lodash.template@^4.0.2, lodash.template@^4.4.0:
+lodash.template@^4.4.0:
   version "4.5.0"
   resolved "https://registry.yarnpkg.com/lodash.template/-/lodash.template-4.5.0.tgz#f976195cf3f347d0d5f52483569fe8031ccce8ab"
   integrity sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==
@@ -6210,27 +6183,27 @@ lodash.templatesettings@^4.0.0:
   dependencies:
     lodash._reinterpolate "~3.0.0"
 
-lodash.truncate@^4.4.2:
-  version "4.4.2"
-  resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193"
-  integrity sha1-WjUNoLERO4N+z//VgSy+WNbq4ZM=
+lodash.union@^4.6.0:
+  version "4.6.0"
+  resolved "https://registry.yarnpkg.com/lodash.union/-/lodash.union-4.6.0.tgz#48bb5088409f16f1821666641c44dd1aaae3cd88"
+  integrity sha1-SLtQiECfFvGCFmZkHETdGqrjzYg=
 
 lodash.uniq@^4.5.0:
   version "4.5.0"
   resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
   integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
 
-lodash@4.17.5:
-  version "4.17.5"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.5.tgz#99a92d65c0272debe8c96b6057bc8fbfa3bed511"
-  integrity sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==
+lodash.zip@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/lodash.zip/-/lodash.zip-4.2.0.tgz#ec6662e4896408ed4ab6c542a3990b72cc080020"
+  integrity sha1-7GZi5IlkCO1KtsVCo5kLcswIACA=
 
-lodash@^4.0.1, lodash@^4.16.6, lodash@^4.17.0, lodash@^4.17.10, lodash@^4.17.14, lodash@^4.17.5, lodash@^4.2.1, lodash@^4.3.0, lodash@^4.5.0:
+lodash@^4.0.1, lodash@^4.17.14:
   version "4.17.20"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.20.tgz#b44a9b6297bcb698f1c51a3545a2b3b368d59c52"
   integrity sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==
 
-lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.21:
+lodash@^4.17.12, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21:
   version "4.17.21"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
@@ -6240,44 +6213,56 @@ lodash@^4.17.4:
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.19.tgz#e48ddedbe30b3321783c5b4301fbd353bc1e4a4b"
   integrity sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ==
 
-log-symbols@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-1.0.2.tgz#376ff7b58ea3086a0f09facc74617eca501e1a18"
-  integrity sha1-N2/3tY6jCGoPCfrMdGF+ylAeGhg=
+log-symbols@4.1.0, log-symbols@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503"
+  integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==
   dependencies:
-    chalk "^1.0.0"
+    chalk "^4.1.0"
+    is-unicode-supported "^0.1.0"
 
-log-symbols@^2.1.0, log-symbols@^2.2.0:
+log-symbols@^2.1.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-2.2.0.tgz#5740e1c5d6f0dfda4ad9323b5332107ef6b4c40a"
   integrity sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==
   dependencies:
     chalk "^2.0.1"
 
-log-update@^2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/log-update/-/log-update-2.3.0.tgz#88328fd7d1ce7938b29283746f0b1bc126b24708"
-  integrity sha1-iDKP19HOeTiykoN0bwsbwSayRwg=
+log-update@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
+  integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==
   dependencies:
-    ansi-escapes "^3.0.0"
-    cli-cursor "^2.0.0"
-    wrap-ansi "^3.0.1"
+    ansi-escapes "^4.3.0"
+    cli-cursor "^3.1.0"
+    slice-ansi "^4.0.0"
+    wrap-ansi "^6.2.0"
 
-log4js@^3.0.0:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/log4js/-/log4js-3.0.6.tgz#e6caced94967eeeb9ce399f9f8682a4b2b28c8ff"
-  integrity sha512-ezXZk6oPJCWL483zj64pNkMuY/NcRX5MPiB0zE6tjZM137aeusrOnW1ecxgF9cmwMWkBMhjteQxBPoZBh9FDxQ==
+log4js@^6.4.1:
+  version "6.4.6"
+  resolved "https://registry.yarnpkg.com/log4js/-/log4js-6.4.6.tgz#1878aa3f09973298ecb441345fe9dd714e355c15"
+  integrity sha512-1XMtRBZszmVZqPAOOWczH+Q94AI42mtNWjvjA5RduKTSWjEc56uOBbyM1CJnfN4Ym0wSd8cQ43zOojlSHgRDAw==
   dependencies:
-    circular-json "^0.5.5"
-    date-format "^1.2.0"
-    debug "^3.1.0"
-    rfdc "^1.1.2"
-    streamroller "0.7.0"
+    date-format "^4.0.9"
+    debug "^4.3.4"
+    flatted "^3.2.5"
+    rfdc "^1.3.0"
+    streamroller "^3.0.8"
 
-longest@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097"
-  integrity sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=
+loglevel-plugin-prefix@^0.8.4:
+  version "0.8.4"
+  resolved "https://registry.yarnpkg.com/loglevel-plugin-prefix/-/loglevel-plugin-prefix-0.8.4.tgz#2fe0e05f1a820317d98d8c123e634c1bd84ff644"
+  integrity sha512-WpG9CcFAOjz/FtNht+QJeGpvVl/cdR6P0z6OcXSkr8wFJOsV2GRj2j10JLfjuA4aYkcKCNIEqRGCyTife9R8/g==
+
+loglevel@^1.6.0:
+  version "1.8.0"
+  resolved "https://registry.yarnpkg.com/loglevel/-/loglevel-1.8.0.tgz#e7ec73a57e1e7b419cb6c6ac06bf050b67356114"
+  integrity sha512-G6A/nJLRgWOuuwdNuA6koovfEV1YpqqAG4pRUlFaz3jj2QNZ8M4vBqnVA+HBTmU/AMNUtlOsMmSpF6NyOjztbA==
+
+longest@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/longest/-/longest-2.0.1.tgz#781e183296aa94f6d4d916dc335d0d17aefa23f8"
+  integrity sha1-eB4YMpaqlPbU2RbcM10NF676I/g=
 
 loose-envify@^1.0.0:
   version "1.4.0"
@@ -6286,15 +6271,36 @@ loose-envify@^1.0.0:
   dependencies:
     js-tokens "^3.0.0 || ^4.0.0"
 
-loud-rejection@^1.0.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f"
-  integrity sha1-W0b4AUft7leIcPCG0Eghz5mOVR8=
+loupe@2.3.4:
+  version "2.3.4"
+  resolved "https://registry.yarnpkg.com/loupe/-/loupe-2.3.4.tgz#7e0b9bffc76f148f9be769cb1321d3dcf3cb25f3"
+  integrity sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==
   dependencies:
-    currently-unhandled "^0.4.1"
-    signal-exit "^3.0.0"
+    get-func-name "^2.0.0"
+
+lower-case@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
+  integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
+  dependencies:
+    tslib "^2.0.3"
+
+lowercase-keys@1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.0.tgz#4e3366b39e7f5457e35f1324bdf6f88d0bfc7306"
+  integrity sha1-TjNms55/VFfjXxMkvfb4jQv8cwY=
+
+lowercase-keys@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.1.tgz#6f9e30b47084d971a7c820ff15a6c5167b74c26f"
+  integrity sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==
+
+lowercase-keys@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-2.0.0.tgz#2603e78b7b4b0006cbca2fbcc8a3202558ac9479"
+  integrity sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==
 
-lru-cache@4.1.x, lru-cache@^4.0.1:
+lru-cache@^4.0.1:
   version "4.1.5"
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-4.1.5.tgz#8bbe50ea85bed59bc9e33dcab8235ee9bcf443cd"
   integrity sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==
@@ -6302,13 +6308,6 @@ lru-cache@4.1.x, lru-cache@^4.0.1:
     pseudomap "^1.0.2"
     yallist "^2.1.2"
 
-lru-cache@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
-  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
-  dependencies:
-    yallist "^3.0.2"
-
 lru-cache@^6.0.0:
   version "6.0.0"
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
@@ -6316,10 +6315,10 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
-lru-cache@~2.6.5:
-  version "2.6.5"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-2.6.5.tgz#e56d6354148ede8d7707b58d143220fd08df0fd5"
-  integrity sha1-5W1jVBSO3o13B7WNFDIg/QjfD9U=
+lru-cache@^7.8.1:
+  version "7.8.1"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.8.1.tgz#68ee3f4807a57d2ba185b7fd90827d5c21ce82bb"
+  integrity sha512-E1v547OCgJvbvevfjgK9sNKIVXO96NnsTsFPBlg4ZxjhsJSODoH9lk8Bm0OxvHNm6Vm5Yqkl/1fErDxhYL8Skg==
 
 magic-string@^0.25.0, magic-string@^0.25.7:
   version "0.25.7"
@@ -6328,7 +6327,7 @@ magic-string@^0.25.0, magic-string@^0.25.7:
   dependencies:
     sourcemap-codec "^1.4.4"
 
-make-dir@^1.0.0:
+make-dir@^1.0.0, make-dir@^1.2.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-1.3.0.tgz#79c1033b80515bd6d24ec9933e860ca75ee27f0c"
   integrity sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==
@@ -6343,7 +6342,7 @@ make-dir@^2.1.0:
     pify "^4.0.1"
     semver "^5.6.0"
 
-make-dir@^3.0.2:
+make-dir@^3.0.0, make-dir@^3.0.2, make-dir@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
   integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
@@ -6355,150 +6354,66 @@ make-error@^1.1.1:
   resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
   integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
 
-map-cache@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf"
-  integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=
-
-map-obj@^1.0.0, map-obj@^1.0.1:
+map-obj@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
   integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=
 
-map-obj@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-2.0.0.tgz#a65cd29087a92598b8791257a523e021222ac1f9"
-  integrity sha1-plzSkIepJZi4eRJXpSPgISIqwfk=
-
-map-visit@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f"
-  integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=
-  dependencies:
-    object-visit "^1.0.0"
-
-matcher@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/matcher/-/matcher-1.1.1.tgz#51d8301e138f840982b338b116bb0c09af62c1c2"
-  integrity sha512-+BmqxWIubKTRKNWx/ahnCkk3mG8m7OturVlqq6HiojGJTd5hVYbgZm6WzcYPCoB+KBT4Vd6R7WSRG2OADNaCjg==
-  dependencies:
-    escape-string-regexp "^1.0.4"
+map-obj@^4.0.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
+  integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
 
-math-random@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.1.tgz#8b3aac588b8a66e4975e3cdea67f7bb329601fac"
-  integrity sha1-izqsWIuKZuSXXjzepn97sylgH6w=
+marky@^1.2.2:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/marky/-/marky-1.2.4.tgz#d02bb4c08be2366687c778ecd2a328971ce23d7f"
+  integrity sha512-zd2/GiSn6U3/jeFVZ0J9CA1LzQ8RfIVvXkb/U0swFHF/zT+dVohTAWjmo2DcIuofmIIIROlwTbd+shSeXmxr0w==
 
-md5.js@^1.3.4:
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
-  integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
+matcher@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/matcher/-/matcher-3.0.0.tgz#bd9060f4c5b70aa8041ccc6f80368760994f30ca"
+  integrity sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==
   dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
+    escape-string-regexp "^4.0.0"
 
 media-typer@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
   integrity sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=
 
-memory-fs@^0.4.0, memory-fs@~0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.4.1.tgz#3a9a20b8462523e447cfbc7e8bb80ed667bfc552"
-  integrity sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=
-  dependencies:
-    errno "^0.1.3"
-    readable-stream "^2.0.1"
-
-memory-fs@^0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/memory-fs/-/memory-fs-0.5.0.tgz#324c01288b88652966d161db77838720845a8e3c"
-  integrity sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==
-  dependencies:
-    errno "^0.1.3"
-    readable-stream "^2.0.1"
-
-meow@^3.3.0:
-  version "3.7.0"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-3.7.0.tgz#72cb668b425228290abbfa856892587308a801fb"
-  integrity sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=
-  dependencies:
-    camelcase-keys "^2.0.0"
-    decamelize "^1.1.2"
-    loud-rejection "^1.0.0"
-    map-obj "^1.0.1"
-    minimist "^1.1.3"
-    normalize-package-data "^2.3.4"
-    object-assign "^4.0.1"
-    read-pkg-up "^1.0.1"
-    redent "^1.0.0"
-    trim-newlines "^1.0.0"
-
-meow@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-4.0.1.tgz#d48598f6f4b1472f35bf6317a95945ace347f975"
-  integrity sha512-xcSBHD5Z86zaOc+781KrupuHAzeGXSLtiAOmBsiLDiPSaYSB6hdew2ng9EBAnZ62jagG9MHAOdxpDi/lWBFJ/A==
-  dependencies:
-    camelcase-keys "^4.0.0"
-    decamelize-keys "^1.0.0"
-    loud-rejection "^1.0.0"
-    minimist "^1.1.3"
-    minimist-options "^3.0.1"
-    normalize-package-data "^2.3.4"
-    read-pkg-up "^3.0.0"
-    redent "^2.0.0"
-    trim-newlines "^2.0.0"
+meow@^8.0.0:
+  version "8.1.2"
+  resolved "https://registry.yarnpkg.com/meow/-/meow-8.1.2.tgz#bcbe45bda0ee1729d350c03cffc8395a36c4e897"
+  integrity sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==
+  dependencies:
+    "@types/minimist" "^1.2.0"
+    camelcase-keys "^6.2.2"
+    decamelize-keys "^1.1.0"
+    hard-rejection "^2.1.0"
+    minimist-options "4.1.0"
+    normalize-package-data "^3.0.0"
+    read-pkg-up "^7.0.1"
+    redent "^3.0.0"
+    trim-newlines "^3.0.0"
+    type-fest "^0.18.0"
+    yargs-parser "^20.2.3"
+
+merge-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
+  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
 
-merge2@^1.3.0:
+merge2@^1.3.0, merge2@^1.4.1:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
-merge@^1.2.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/merge/-/merge-1.2.1.tgz#38bebf80c3220a8a487b6fcfb3941bb11720c145"
-  integrity sha512-VjFo4P5Whtj4vsLzsYBu5ayHhoHJ0UqNm7ibvShmbmoz7tGi0vXaoJbGdB+GmDMLUdg8DpQXEIeVDAe8MaABvQ==
-
-micromatch@^2.3.7:
-  version "2.3.11"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565"
-  integrity sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=
-  dependencies:
-    arr-diff "^2.0.0"
-    array-unique "^0.2.1"
-    braces "^1.8.2"
-    expand-brackets "^0.1.4"
-    extglob "^0.3.1"
-    filename-regex "^2.0.0"
-    is-extglob "^1.0.0"
-    is-glob "^2.0.1"
-    kind-of "^3.0.2"
-    normalize-path "^2.0.1"
-    object.omit "^2.0.0"
-    parse-glob "^3.0.4"
-    regex-cache "^0.4.2"
-
-micromatch@^3.1.10, micromatch@^3.1.4, micromatch@^3.1.8:
-  version "3.1.10"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-3.1.10.tgz#70859bc95c9840952f359a068a3fc49f9ecfac23"
-  integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==
-  dependencies:
-    arr-diff "^4.0.0"
-    array-unique "^0.3.2"
-    braces "^2.3.1"
-    define-property "^2.0.2"
-    extend-shallow "^3.0.2"
-    extglob "^2.0.4"
-    fragment-cache "^0.2.1"
-    kind-of "^6.0.2"
-    nanomatch "^1.2.9"
-    object.pick "^1.3.0"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.2"
+merge@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/merge/-/merge-2.1.1.tgz#59ef4bf7e0b3e879186436e8481c06a6c162ca98"
+  integrity sha512-jz+Cfrg9GWOZbQAnDQ4hlVnQky+341Yk5ru8bZSe6sIDTCIg8n9i/u7hSQGSVOF3C7lH6mGtqjkiT9G4wFLL0w==
 
-micromatch@^4.0.0, micromatch@^4.0.2:
+micromatch@^4.0.0:
   version "4.0.2"
   resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.2.tgz#4fcb0999bf9fbc2fcbdd212f6d629b9a56c39259"
   integrity sha512-y7FpHSbMUMoyPbYUSzO6PaZ6FyRnQOpHuKwbo1G+Knck95XVU4QAiKdGEnj5wwoS7PlOgthX/09u5iFJ+aYf5Q==
@@ -6506,13 +6421,18 @@ micromatch@^4.0.0, micromatch@^4.0.2:
     braces "^3.0.1"
     picomatch "^2.0.5"
 
-miller-rabin@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
-  integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==
+micromatch@^4.0.2, micromatch@^4.0.4:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
+  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
   dependencies:
-    bn.js "^4.0.0"
-    brorand "^1.0.1"
+    braces "^3.0.2"
+    picomatch "^2.3.1"
+
+mime-db@1.52.0, mime-db@^1.28.0:
+  version "1.52.0"
+  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
+  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
 
 mime-db@~1.37.0:
   version "1.37.0"
@@ -6526,119 +6446,110 @@ mime-types@^2.1.12, mime-types@~2.1.18, mime-types@~2.1.19:
   dependencies:
     mime-db "~1.37.0"
 
+mime-types@^2.1.27, mime-types@~2.1.24:
+  version "2.1.35"
+  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
+  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
+  dependencies:
+    mime-db "1.52.0"
+
 mime@^1.6.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
   integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
 
-mime@^2.0.3, mime@^2.3.1:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-2.4.0.tgz#e051fd881358585f3279df333fe694da0bcffdd6"
-  integrity sha512-ikBcWwyqXQSHKtciCcctu9YfPbFYZ4+gbHEmE0Q8jzcTYQg5dHCr3g2wwAZjPoJfQVXZq6KXAjpXOTf5/cjT7w==
+mime@^2.5.2:
+  version "2.6.0"
+  resolved "https://registry.yarnpkg.com/mime/-/mime-2.6.0.tgz#a2a682a95cd4d0cb1d6257e28f83da7e35800367"
+  integrity sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==
 
 mimic-fn@^1.0.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
   integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==
 
-minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
+mimic-fn@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
+  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
+
+mimic-response@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
-  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
+  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-1.0.1.tgz#4923538878eef42063cb8a3e3b0798781487ab1b"
+  integrity sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==
+
+mimic-response@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-3.1.0.tgz#2d1d59af9c1b129815accc2c46a022a5ce1fa3c9"
+  integrity sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==
 
-minimalistic-crypto-utils@^1.0.1:
+min-indent@^1.0.0:
   version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
-  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
+  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
+  integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
+
+minimalistic-assert@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
+  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
 
-"minimatch@2 || 3", minimatch@^3.0.0, minimatch@^3.0.2, minimatch@^3.0.4:
+minimatch@3.0.4, minimatch@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
   integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
   dependencies:
     brace-expansion "^1.1.7"
 
-minimatch@3.0.3:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774"
-  integrity sha1-Kk5AkLlrLbBqnX3wEFWmKnfJt3Q=
+minimatch@4.2.1:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-4.2.1.tgz#40d9d511a46bdc4e563c22c3080cde9c0d8299b4"
+  integrity sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g==
   dependencies:
-    brace-expansion "^1.0.0"
+    brace-expansion "^1.1.7"
 
-minimist-options@^3.0.1:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-3.0.2.tgz#fba4c8191339e13ecf4d61beb03f070103f3d954"
-  integrity sha512-FyBrT/d0d4+uiZRbqznPXqw3IpZZG3gl3wKWiX784FycUKVwBt0uLBFkQrtE4tZOrgo78nZp2jnKz3L65T5LdQ==
+minimist-options@4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619"
+  integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==
   dependencies:
     arrify "^1.0.1"
     is-plain-obj "^1.1.0"
+    kind-of "^6.0.3"
 
 minimist@0.0.8:
   version "0.0.8"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d"
   integrity sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=
 
-minimist@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
-  integrity sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=
-
-minimist@^1.1.0, minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5:
+minimist@1.2.5, minimist@^1.2.5:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
   integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
 
-minimist@~0.0.1:
-  version "0.0.10"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.10.tgz#de3f98543dbf96082be48ad1a0c7cda836301dcf"
-  integrity sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=
-
-minipass@^2.2.1, minipass@^2.3.4:
-  version "2.3.5"
-  resolved "https://registry.yarnpkg.com/minipass/-/minipass-2.3.5.tgz#cacebe492022497f656b0f0f51e2682a9ed2d848"
-  integrity sha512-Gi1W4k059gyRbyVUZQ4mEqLm0YIUiGYfvxhF6SIlk3ui1WVxMTGfGdQ2SInh3PDrRTVvPKgULkpJtT4RH10+VA==
-  dependencies:
-    safe-buffer "^5.1.2"
-    yallist "^3.0.0"
-
-minizlib@^1.1.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/minizlib/-/minizlib-1.2.1.tgz#dd27ea6136243c7c880684e8672bb3a45fd9b614"
-  integrity sha512-7+4oTUOWKg7AuL3vloEWekXY2/D20cevzsrNT2kGWm+39J9hGTCBv8VI5Pm5lXZ/o3/mdR4f8rflAPhnQb8mPA==
-  dependencies:
-    minipass "^2.2.1"
-
-mississippi@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/mississippi/-/mississippi-3.0.0.tgz#ea0a3291f97e0b5e8776b363d5f0a12d94c67022"
-  integrity sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==
-  dependencies:
-    concat-stream "^1.5.0"
-    duplexify "^3.4.2"
-    end-of-stream "^1.1.0"
-    flush-write-stream "^1.0.0"
-    from2 "^2.1.0"
-    parallel-transform "^1.1.0"
-    pump "^3.0.0"
-    pumpify "^1.3.3"
-    stream-each "^1.1.0"
-    through2 "^2.0.0"
+minimist@1.2.6, minimist@^1.2.6:
+  version "1.2.6"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44"
+  integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==
 
-mixin-deep@^1.2.0:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/mixin-deep/-/mixin-deep-1.3.2.tgz#1120b43dc359a785dce65b55b82e257ccf479566"
-  integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==
-  dependencies:
-    for-in "^1.0.2"
-    is-extendable "^1.0.1"
+mkdirp-classic@^0.5.2:
+  version "0.5.3"
+  resolved "https://registry.yarnpkg.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz#fa10c9115cc6d8865be221ba47ee9bed78601113"
+  integrity sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==
 
-mkdirp@0.5.1, mkdirp@0.5.x, mkdirp@^0.5.0, mkdirp@^0.5.1, mkdirp@~0.5.0:
+mkdirp@0.5.1:
   version "0.5.1"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903"
   integrity sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=
   dependencies:
     minimist "0.0.8"
 
+mkdirp@^0.5.3:
+  version "0.5.6"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
+  integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
+  dependencies:
+    minimist "^1.2.6"
+
 mkdirp@^0.5.5:
   version "0.5.5"
   resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
@@ -6651,44 +6562,40 @@ mkpath@1.0.0:
   resolved "https://registry.yarnpkg.com/mkpath/-/mkpath-1.0.0.tgz#ebb3a977e7af1c683ae6fda12b545a6ba6c5853d"
   integrity sha1-67Opd+evHGg65v2hK1Raa6bFhT0=
 
-mocha-nightwatch@3.2.2:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/mocha-nightwatch/-/mocha-nightwatch-3.2.2.tgz#91bcb9b3bde057dd7677c78125e491e58d66647c"
-  integrity sha1-kby5s73gV912d8eBJeSR5Y1mZHw=
-  dependencies:
-    browser-stdout "1.3.0"
-    commander "2.9.0"
-    debug "2.2.0"
-    diff "1.4.0"
-    escape-string-regexp "1.0.5"
-    glob "7.0.5"
-    growl "1.9.2"
-    json3 "3.3.2"
-    lodash.create "3.1.1"
-    mkdirp "0.5.1"
-    supports-color "3.1.2"
+mocha@9.2.2:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/mocha/-/mocha-9.2.2.tgz#d70db46bdb93ca57402c809333e5a84977a88fb9"
+  integrity sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g==
+  dependencies:
+    "@ungap/promise-all-settled" "1.1.2"
+    ansi-colors "4.1.1"
+    browser-stdout "1.3.1"
+    chokidar "3.5.3"
+    debug "4.3.3"
+    diff "5.0.0"
+    escape-string-regexp "4.0.0"
+    find-up "5.0.0"
+    glob "7.2.0"
+    growl "1.10.5"
+    he "1.2.0"
+    js-yaml "4.1.0"
+    log-symbols "4.1.0"
+    minimatch "4.2.1"
+    ms "2.1.3"
+    nanoid "3.3.1"
+    serialize-javascript "6.0.0"
+    strip-json-comments "3.1.1"
+    supports-color "8.1.1"
+    which "2.0.2"
+    workerpool "6.2.0"
+    yargs "16.2.0"
+    yargs-parser "20.2.4"
+    yargs-unparser "2.0.0"
 
 modify-values@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022"
-  integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
-
-move-concurrently@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/move-concurrently/-/move-concurrently-1.0.1.tgz#be2c005fda32e0b29af1f05d7c4b33214c701f92"
-  integrity sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=
-  dependencies:
-    aproba "^1.1.1"
-    copy-concurrently "^1.0.0"
-    fs-write-stream-atomic "^1.0.8"
-    mkdirp "^0.5.1"
-    rimraf "^2.5.4"
-    run-queue "^1.0.3"
-
-ms@0.7.1:
-  version "0.7.1"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-0.7.1.tgz#9cd13c03adbff25b65effde7ce864ee952017098"
-  integrity sha1-nNE8A62/8ltl7/3nzoZO6VIBcJg=
+  integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
 
 ms@2.0.0:
   version "2.0.0"
@@ -6700,72 +6607,36 @@ ms@2.1.2:
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
   integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
 
-ms@^2.1.1:
+ms@2.1.3, ms@^2.1.1:
   version "2.1.3"
   resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
   integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
 
-mute-stream@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.6.tgz#48962b19e169fd1dfc240b3f1e7317627bbc47db"
-  integrity sha1-SJYrGeFp/R38JAs/HnMXYnu8R9s=
-
 mute-stream@0.0.7:
   version "0.0.7"
   resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
   integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=
 
-nan@^2.9.2:
-  version "2.12.1"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.12.1.tgz#7b1aa193e9aa86057e3c7bbd0ac448e770925552"
-  integrity sha512-JY7V6lRkStKcKTvHO5NVSQRv+RV+FIL5pvDoLiAtSL9pKlC5x9PKQcZDsq7m4FO4d57mkhC6Z+QhAh3Jdk5JFw==
-
-nanomatch@^1.2.9:
-  version "1.2.13"
-  resolved "https://registry.yarnpkg.com/nanomatch/-/nanomatch-1.2.13.tgz#b87a8aa4fc0de8fe6be88895b38983ff265bd119"
-  integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==
-  dependencies:
-    arr-diff "^4.0.0"
-    array-unique "^0.3.2"
-    define-property "^2.0.2"
-    extend-shallow "^3.0.2"
-    fragment-cache "^0.2.1"
-    is-windows "^1.0.2"
-    kind-of "^6.0.2"
-    object.pick "^1.3.0"
-    regex-not "^1.0.0"
-    snapdragon "^0.8.1"
-    to-regex "^3.0.1"
+nanoid@3.3.1:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.1.tgz#6347a18cac88af88f58af0b3594b723d5e99bb35"
+  integrity sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==
 
 natural-compare@^1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=
 
-needle@^2.2.1:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/needle/-/needle-2.2.4.tgz#51931bff82533b1928b7d1d69e01f1b00ffd2a4e"
-  integrity sha512-HyoqEb4wr/rsoaIDfTH2aVL9nWtQqba2/HvMv+++m8u0dz808MaagKILxtfeSN7QU7nvbQ79zk3vYOJp9zsNEA==
-  dependencies:
-    debug "^2.1.2"
-    iconv-lite "^0.4.4"
-    sax "^1.2.4"
-
 negotiator@0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.1.tgz#2b327184e8992101177b28563fb5e7102acd0ca9"
   integrity sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=
 
-neo-async@^2.5.0, neo-async@^2.6.0:
+neo-async@^2.6.0, neo-async@^2.6.2:
   version "2.6.2"
   resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
   integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
 
-netmask@~1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/netmask/-/netmask-1.0.6.tgz#20297e89d86f6f6400f250d9f4f6b4c1945fcd35"
-  integrity sha1-ICl+idhvb2QA8lDZ9Pa0wZRfzTU=
-
 nice-try@^1.0.4:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
@@ -6776,101 +6647,60 @@ nightwatch-helpers@^1.2.0:
   resolved "https://registry.yarnpkg.com/nightwatch-helpers/-/nightwatch-helpers-1.2.0.tgz#cdefeb7635074a141825a7b6d1b955b6d7810a0f"
   integrity sha1-ze/rdjUHShQYJae20blVtteBCg8=
 
-nightwatch@^0.9.16:
-  version "0.9.21"
-  resolved "https://registry.yarnpkg.com/nightwatch/-/nightwatch-0.9.21.tgz#9e794a7514b4fd5f46602d368e50515232ab9e90"
-  integrity sha1-nnlKdRS0/V9GYC02jlBRUjKrnpA=
-  dependencies:
-    chai-nightwatch "~0.1.x"
-    ejs "2.5.7"
+nightwatch@^2.1.3:
+  version "2.1.3"
+  resolved "https://registry.yarnpkg.com/nightwatch/-/nightwatch-2.1.3.tgz#640e339c9f47e00010569ffa7f88f8d1d2b05fb9"
+  integrity sha512-NMNr4/jPsAtfd/u+RgKTzYyhS9TUuEmP6LMxLcH/KdQlkQmPIixVStRijv0bpvK4zASsqrO2+/em2LNRNMT6sw==
+  dependencies:
+    "@nightwatch/chai" "5.0.2"
+    "@nightwatch/ejs" "3.2.0"
+    assertion-error "1.1.0"
+    boxen "5.1.2"
+    chai-nightwatch "0.5.3"
+    ci-info "3.3.0"
+    didyoumean "1.2.2"
+    dotenv "10.0.0"
+    envinfo "7.8.1"
+    glob "7.2.0"
     lodash.clone "3.0.3"
-    lodash.defaultsdeep "4.3.2"
-    minimatch "3.0.3"
+    lodash.defaultsdeep "4.6.1"
+    lodash.merge "4.6.2"
+    minimatch "3.0.4"
+    minimist "1.2.6"
     mkpath "1.0.0"
-    mocha-nightwatch "3.2.2"
-    optimist "0.6.1"
-    proxy-agent "2.0.0"
-    q "1.4.1"
-
-node-fetch@1.6.3:
-  version "1.6.3"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-1.6.3.tgz#dc234edd6489982d58e8f0db4f695029abcd8c04"
-  integrity sha1-3CNO3WSJmC1Y6PDbT2lQKavNjAQ=
+    mocha "9.2.2"
+    ora "5.4.1"
+    selenium-webdriver "4.1.1"
+    semver "7.3.5"
+    stacktrace-parser "0.1.10"
+    strip-ansi "6.0.1"
+
+no-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
+  integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
   dependencies:
-    encoding "^0.1.11"
-    is-stream "^1.0.1"
+    lower-case "^2.0.2"
+    tslib "^2.0.3"
 
-node-libs-browser@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/node-libs-browser/-/node-libs-browser-2.1.0.tgz#5f94263d404f6e44767d726901fff05478d600df"
-  integrity sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==
-  dependencies:
-    assert "^1.1.1"
-    browserify-zlib "^0.2.0"
-    buffer "^4.3.0"
-    console-browserify "^1.1.0"
-    constants-browserify "^1.0.0"
-    crypto-browserify "^3.11.0"
-    domain-browser "^1.1.1"
-    events "^1.0.0"
-    https-browserify "^1.0.0"
-    os-browserify "^0.3.0"
-    path-browserify "0.0.0"
-    process "^0.11.10"
-    punycode "^1.2.4"
-    querystring-es3 "^0.2.0"
-    readable-stream "^2.3.3"
-    stream-browserify "^2.0.1"
-    stream-http "^2.7.2"
-    string_decoder "^1.0.0"
-    timers-browserify "^2.0.4"
-    tty-browserify "0.0.0"
-    url "^0.11.0"
-    util "^0.10.3"
-    vm-browserify "0.0.4"
-
-node-modules-regexp@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz#8d9dbe28964a4ac5712e9131642107c71e90ec40"
-  integrity sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA=
-
-node-pre-gyp@^0.10.0:
-  version "0.10.3"
-  resolved "https://registry.yarnpkg.com/node-pre-gyp/-/node-pre-gyp-0.10.3.tgz#3070040716afdc778747b61b6887bf78880b80fc"
-  integrity sha512-d1xFs+C/IPS8Id0qPTZ4bUT8wWryfR/OzzAFxweG+uLN85oPzyo2Iw6bVlLQ/JOdgNonXLCoRyqDzDWq4iw72A==
-  dependencies:
-    detect-libc "^1.0.2"
-    mkdirp "^0.5.1"
-    needle "^2.2.1"
-    nopt "^4.0.1"
-    npm-packlist "^1.1.6"
-    npmlog "^4.0.2"
-    rc "^1.2.7"
-    rimraf "^2.6.1"
-    semver "^5.3.0"
-    tar "^4"
+node-fetch@2.6.7, node-fetch@^2.6.1:
+  version "2.6.7"
+  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.7.tgz#24de9fba827e3b4ae44dc8b20256a379160052ad"
+  integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==
+  dependencies:
+    whatwg-url "^5.0.0"
 
 node-releases@^1.1.70:
   version "1.1.71"
   resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.71.tgz#cb1334b179896b1c89ecfdd4b725fb7bbdfc7dbb"
   integrity sha512-zR6HoT6LrLCRBwukmrVbHv0EpEQjksO6GmFcZQQuCAy139BEsoVKPYnf3jongYW83fAa1torLGYwxxky/p28sg==
 
-nopt@3.x:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-3.0.6.tgz#c6465dbf08abcd4db359317f79ac68a646b28ff9"
-  integrity sha1-xkZdvwirzU2zWTF/eaxopkayj/k=
-  dependencies:
-    abbrev "1"
-
-nopt@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/nopt/-/nopt-4.0.1.tgz#d0d4685afd5415193c8c7505602d0d17cd64474d"
-  integrity sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=
-  dependencies:
-    abbrev "1"
-    osenv "^0.1.4"
+node-releases@^2.0.3:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.4.tgz#f38252370c43854dc48aa431c766c6c398f40476"
+  integrity sha512-gbMzqQtTtDz/00jQzZ21PQzdI9PyLYqUSvD0p3naOhX4odFji0ZxYdnVwPTxmSwkmxhcFImpozceidSG+AgoPQ==
 
-normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package-data@^2.3.4, normalize-package-data@^2.3.5:
+normalize-package-data@^2.3.2:
   version "2.4.0"
   resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.4.0.tgz#12f95a307d58352075a04907b84ac8be98ac012f"
   integrity sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==
@@ -6880,37 +6710,57 @@ normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package-
     semver "2 || 3 || 4 || 5"
     validate-npm-package-license "^3.0.1"
 
+normalize-package-data@^2.5.0:
+  version "2.5.0"
+  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
+  integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
+  dependencies:
+    hosted-git-info "^2.1.4"
+    resolve "^1.10.0"
+    semver "2 || 3 || 4 || 5"
+    validate-npm-package-license "^3.0.1"
+
+normalize-package-data@^3.0.0:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
+  integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==
+  dependencies:
+    hosted-git-info "^4.0.1"
+    is-core-module "^2.5.0"
+    semver "^7.3.4"
+    validate-npm-package-license "^3.0.1"
+
 normalize-path@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-1.0.0.tgz#32d0e472f91ff345701c15a8311018d3b0a90379"
   integrity sha1-MtDkcvkf80VwHBWoMRAY07CpA3k=
 
-normalize-path@^2.0.1, normalize-path@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
-  integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=
-  dependencies:
-    remove-trailing-separator "^1.0.1"
-
-npm-bundled@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/npm-bundled/-/npm-bundled-1.0.5.tgz#3c1732b7ba936b3a10325aef616467c0ccbcc979"
-  integrity sha512-m/e6jgWu8/v5niCUKQi9qQl8QdeEduFA96xHDDzFGqly0OOjI7c+60KM/2sppfnUU9JJagf+zs+yGhqSOFj71g==
+normalize-path@^3.0.0, normalize-path@~3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
+  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
 
-npm-packlist@^1.1.6:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/npm-packlist/-/npm-packlist-1.2.0.tgz#55a60e793e272f00862c7089274439a4cc31fc7f"
-  integrity sha512-7Mni4Z8Xkx0/oegoqlcao/JpPCPEMtUvsmB0q7mgvlMinykJLSRTYuFqoQLYgGY8biuxIeiHO+QNJKbCfljewQ==
+normalize-url@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-2.0.1.tgz#835a9da1551fa26f70e92329069a23aa6574d7e6"
+  integrity sha512-D6MUW4K/VzoJ4rJ01JFKxDrtY1v9wrgzCX5f2qj/lzH1m/lW6MhUZFKerVsnyjOhOsYzI9Kqqak+10l4LvLpMw==
   dependencies:
-    ignore-walk "^3.0.1"
-    npm-bundled "^1.0.1"
+    prepend-http "^2.0.0"
+    query-string "^5.0.1"
+    sort-keys "^2.0.0"
 
-npm-path@^2.0.2:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/npm-path/-/npm-path-2.0.4.tgz#c641347a5ff9d6a09e4d9bce5580c4f505278e64"
-  integrity sha512-IFsj0R9C7ZdR5cP+ET342q77uSRdtWOlWpih5eC+lu29tIDbNEgDbzgVJ5UFvYHWhxDZ5TFkJafFioO0pPQjCw==
+normalize-url@^6.0.1:
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-6.1.0.tgz#40d0885b535deffe3f3147bec877d05fe4c5668a"
+  integrity sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==
+
+npm-conf@^1.1.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/npm-conf/-/npm-conf-1.1.3.tgz#256cc47bd0e218c259c4e9550bf413bc2192aff9"
+  integrity sha512-Yic4bZHJOt9RCFbRP3GgpqhScOY4HH3V2P8yBj6CeYq118Qr+BLXqT2JvpJ00mryLESpgOxf5XlFv4ZjXxLScw==
   dependencies:
-    which "^1.2.10"
+    config-chain "^1.1.11"
+    pify "^3.0.0"
 
 npm-run-path@^2.0.0:
   version "2.0.2"
@@ -6919,71 +6769,33 @@ npm-run-path@^2.0.0:
   dependencies:
     path-key "^2.0.0"
 
-npm-which@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/npm-which/-/npm-which-3.0.1.tgz#9225f26ec3a285c209cae67c3b11a6b4ab7140aa"
-  integrity sha1-kiXybsOihcIJyuZ8OxGmtKtxQKo=
-  dependencies:
-    commander "^2.9.0"
-    npm-path "^2.0.2"
-    which "^1.2.10"
-
-npmlog@^4.0.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/npmlog/-/npmlog-4.1.2.tgz#08a7f2a8bf734604779a9efa4ad5cc717abb954b"
-  integrity sha512-2uUqazuKlTaSI/dC8AzicUck7+IrEaOnN/e0jd3Xtt1KcGpwx30v50mL7oPyr/h9bL3E4aZccVwpwP+5W9Vjkg==
+npm-run-path@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
+  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
   dependencies:
-    are-we-there-yet "~1.1.2"
-    console-control-strings "~1.1.0"
-    gauge "~2.7.3"
-    set-blocking "~2.0.0"
-
-null-check@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/null-check/-/null-check-1.0.0.tgz#977dffd7176012b9ec30d2a39db5cf72a0439edd"
-  integrity sha1-l33/1xdgErnsMNKjnbXPcqBDnt0=
-
-number-is-nan@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
-  integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=
+    path-key "^3.0.0"
 
 oauth-sign@~0.9.0:
   version "0.9.0"
   resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
   integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
 
-object-assign@^4.0.1, object-assign@^4.1.0:
+object-assign@^4, object-assign@^4.0.1, object-assign@^4.1.0:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
 
-object-component@0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/object-component/-/object-component-0.0.3.tgz#f0c69aa50efc95b866c186f400a33769cb2f1291"
-  integrity sha1-8MaapQ78lbhmwYb0AKM3acsvEpE=
-
-object-copy@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c"
-  integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw=
-  dependencies:
-    copy-descriptor "^0.1.0"
-    define-property "^0.2.5"
-    kind-of "^3.0.3"
+object-inspect@^1.12.0, object-inspect@^1.9.0:
+  version "1.12.0"
+  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.0.tgz#6e2c120e868fd1fd18cb4f18c31741d0d6e776f0"
+  integrity sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==
 
 object-keys@^1.0.12, object-keys@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
-object-visit@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb"
-  integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=
-  dependencies:
-    isobject "^3.0.0"
-
 object.assign@^4.1.0:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
@@ -6994,28 +6806,12 @@ object.assign@^4.1.0:
     has-symbols "^1.0.1"
     object-keys "^1.1.1"
 
-object.getownpropertydescriptors@^2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz#8758c846f5b407adab0f236e0986f14b051caa16"
-  integrity sha1-h1jIRvW0B62rDyNuCYbxSwUcqhY=
-  dependencies:
-    define-properties "^1.1.2"
-    es-abstract "^1.5.1"
-
-object.omit@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"
-  integrity sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=
-  dependencies:
-    for-own "^0.1.4"
-    is-extendable "^0.1.1"
-
-object.pick@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747"
-  integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=
+on-finished@2.4.1:
+  version "2.4.1"
+  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f"
+  integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==
   dependencies:
-    isobject "^3.0.1"
+    ee-first "1.1.1"
 
 on-finished@~2.3.0:
   version "2.3.0"
@@ -7024,18 +6820,13 @@ on-finished@~2.3.0:
   dependencies:
     ee-first "1.1.1"
 
-once@1.x, once@^1.3.0, once@^1.3.1, once@^1.4.0:
+once@^1.3.0, once@^1.3.1, once@^1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
   integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
   dependencies:
     wrappy "1"
 
-onetime@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-1.1.0.tgz#a1f7838f8314c516f05ecefcbc4ccfe04b4ed789"
-  integrity sha1-ofeDj4MUxRbwXs78vEzP4EtO14k=
-
 onetime@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
@@ -7043,39 +6834,18 @@ onetime@^2.0.0:
   dependencies:
     mimic-fn "^1.0.0"
 
-opencollective@1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/opencollective/-/opencollective-1.0.3.tgz#aee6372bc28144583690c3ca8daecfc120dd0ef1"
-  integrity sha1-ruY3K8KBRFg2kMPKja7PwSDdDvE=
+onetime@^5.1.0, onetime@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
+  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
   dependencies:
-    babel-polyfill "6.23.0"
-    chalk "1.1.3"
-    inquirer "3.0.6"
-    minimist "1.2.0"
-    node-fetch "1.6.3"
-    opn "4.0.2"
+    mimic-fn "^2.1.0"
 
 opener@^1.5.1:
   version "1.5.2"
   resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
   integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
 
-opn@4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/opn/-/opn-4.0.2.tgz#7abc22e644dff63b0a96d5ab7f2790c0f01abc95"
-  integrity sha1-erwi5kTf9jsKltWrfyeQwPAavJU=
-  dependencies:
-    object-assign "^4.0.1"
-    pinkie-promise "^2.0.0"
-
-optimist@0.6.1, optimist@^0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.6.1.tgz#da3ea74686fa21a19a111c326e90eb15a0196686"
-  integrity sha1-2j6nRob6IaGaERwybpDrFaAZZoY=
-  dependencies:
-    minimist "~0.0.1"
-    wordwrap "~0.0.2"
-
 optionator@^0.8.1:
   version "0.8.2"
   resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64"
@@ -7100,39 +6870,60 @@ optionator@^0.9.1:
     type-check "^0.4.0"
     word-wrap "^1.2.3"
 
-os-browserify@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
-  integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=
-
-os-homedir@^1.0.0, os-homedir@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3"
-  integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M=
+ora@5.4.1:
+  version "5.4.1"
+  resolved "https://registry.yarnpkg.com/ora/-/ora-5.4.1.tgz#1b2678426af4ac4a509008e5e4ac9e9959db9e18"
+  integrity sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==
+  dependencies:
+    bl "^4.1.0"
+    chalk "^4.1.0"
+    cli-cursor "^3.1.0"
+    cli-spinners "^2.5.0"
+    is-interactive "^1.0.0"
+    is-unicode-supported "^0.1.0"
+    log-symbols "^4.1.0"
+    strip-ansi "^6.0.0"
+    wcwidth "^1.0.1"
 
-os-shim@^0.1.2:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/os-shim/-/os-shim-0.1.3.tgz#6b62c3791cf7909ea35ed46e17658bb417cb3917"
-  integrity sha1-a2LDeRz3kJ6jXtRuF2WLtBfLORc=
+os-filter-obj@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/os-filter-obj/-/os-filter-obj-2.0.0.tgz#1c0b62d5f3a2442749a2d139e6dddee6e81d8d16"
+  integrity sha512-uksVLsqG3pVdzzPvmAHpBK0wKxYItuzZr7SziusRPoz67tGV8rL1szZ6IdeUrbqLjGDwApBtN29eEE3IqGHOjg==
+  dependencies:
+    arch "^2.1.0"
 
-os-tmpdir@^1.0.0, os-tmpdir@~1.0.1, os-tmpdir@~1.0.2:
+os-tmpdir@~1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
   integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
 
-osenv@^0.1.4:
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/osenv/-/osenv-0.1.5.tgz#85cdfafaeb28e8677f416e287592b5f3f49ea410"
-  integrity sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==
+p-cancelable@^0.4.0:
+  version "0.4.1"
+  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-0.4.1.tgz#35f363d67d52081c8d9585e37bcceb7e0bbcb2a0"
+  integrity sha512-HNa1A8LvB1kie7cERyy21VNeHb2CWJJYqyyC2o3klWFfMGlFmWv2Z7sFgZH8ZiaYL95ydToKTFVXgMV/Os0bBQ==
+
+p-cancelable@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-2.1.1.tgz#aab7fbd416582fa32a3db49859c122487c5ed2cf"
+  integrity sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==
+
+p-event@^2.1.0:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/p-event/-/p-event-2.3.1.tgz#596279ef169ab2c3e0cae88c1cfbb08079993ef6"
+  integrity sha512-NQCqOFhbpVTMX4qMe8PF8lbGtzZ+LCiN7pcNrb/413Na7+TRoe1xkKUzuWa/YEJdGQ0FvKtj35EEbDoVPO2kbA==
   dependencies:
-    os-homedir "^1.0.0"
-    os-tmpdir "^1.0.0"
+    p-timeout "^2.0.1"
 
 p-finally@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
   integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=
 
+p-is-promise@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/p-is-promise/-/p-is-promise-1.1.0.tgz#9c9456989e9f6588017b0434d56097675c3da05e"
+  integrity sha1-nJRWmJ6fZYgBewQ01WCXZ1w9oF4=
+
 p-limit@^1.1.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
@@ -7154,6 +6945,13 @@ p-limit@^2.2.0:
   dependencies:
     p-try "^2.0.0"
 
+p-limit@^3.0.2:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
+  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
+  dependencies:
+    yocto-queue "^0.1.0"
+
 p-locate@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
@@ -7175,15 +6973,26 @@ p-locate@^4.1.0:
   dependencies:
     p-limit "^2.2.0"
 
-p-map@^1.1.1:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-1.2.0.tgz#e4e94f311eabbc8633a1e79908165fca26241b6b"
-  integrity sha512-r6zKACMNhjPJMTl8KcFH4li//gkrXWfbD6feV8l6doRHlzljFWGJ2AP6iKaCJXyZmAUMOPtvbW7EXkbWO/pLEA==
+p-locate@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
+  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
+  dependencies:
+    p-limit "^3.0.2"
 
-p-map@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-2.0.0.tgz#be18c5a5adeb8e156460651421aceca56c213a50"
-  integrity sha512-GO107XdrSUmtHxVoi60qc9tUl/KkNKm+X2CF4P9amalpGxv5YqVPJNfSb0wcA+syCopkZvYYIzW8OVTQW59x/w==
+p-map@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b"
+  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
+  dependencies:
+    aggregate-error "^3.0.0"
+
+p-timeout@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-2.0.1.tgz#d8dd1979595d2dc0139e1fe46b8b646cb3cdf038"
+  integrity sha512-88em58dDVB/KzPEx1X0N3LwFfYZPyDc4B6eF38M1rk9VTZMbxXXgjugz8mmwpS9Ox4BDZ+t6t3QP5+/gazweIA==
+  dependencies:
+    p-finally "^1.0.0"
 
 p-try@^1.0.0:
   version "1.0.0"
@@ -7195,52 +7004,18 @@ p-try@^2.0.0:
   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.0.0.tgz#85080bb87c64688fa47996fe8f7dfbe8211760b1"
   integrity sha512-hMp0onDKIajHfIkdRk3P4CdCmErkYAxxDtP3Wx/4nZ3aGlau2VKh3mZpcuFkH27WQkL/3WBCPOktzA9ZOAnMQQ==
 
-pac-proxy-agent@1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/pac-proxy-agent/-/pac-proxy-agent-1.1.0.tgz#34a385dfdf61d2f0ecace08858c745d3e791fd4d"
-  integrity sha512-QBELCWyLYPgE2Gj+4wUEiMscHrQ8nRPBzYItQNOHWavwBt25ohZHQC4qnd5IszdVVrFbLsQ+dPkm6eqdjJAmwQ==
-  dependencies:
-    agent-base "2"
-    debug "2"
-    extend "3"
-    get-uri "2"
-    http-proxy-agent "1"
-    https-proxy-agent "1"
-    pac-resolver "~2.0.0"
-    raw-body "2"
-    socks-proxy-agent "2"
-
-pac-resolver@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/pac-resolver/-/pac-resolver-2.0.0.tgz#99b88d2f193fbdeefc1c9a529c1f3260ab5277cd"
-  integrity sha1-mbiNLxk/ve78HJpSnB8yYKtSd80=
-  dependencies:
-    co "~3.0.6"
-    degenerator "~1.0.2"
-    ip "1.0.1"
-    netmask "~1.0.4"
-    thunkify "~2.1.1"
-
-pad-right@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/pad-right/-/pad-right-0.2.2.tgz#6fbc924045d244f2a2a244503060d3bfc6009774"
-  integrity sha1-b7ySQEXSRPKiokRQMGDTv8YAl3Q=
-  dependencies:
-    repeat-string "^1.5.2"
-
-pako@~1.0.2, pako@~1.0.5:
+pako@~1.0.2:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.7.tgz#2473439021b57f1516c82f58be7275ad8ef1bb27"
   integrity sha512-3HNK5tW4x8o5mO8RuHZp3Ydw9icZXx0RANAOMzlMzx7LVXhMJ4mo3MOBpzyd7r/+RUu8BmndP47LXT+vzjtWcQ==
 
-parallel-transform@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/parallel-transform/-/parallel-transform-1.1.0.tgz#d410f065b05da23081fcd10f28854c29bda33b06"
-  integrity sha1-1BDwZbBdojCB/NEPKIVMKb2jOwY=
+param-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/param-case/-/param-case-3.0.4.tgz#7d17fe4aa12bde34d4a77d91acfb6219caad01c5"
+  integrity sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==
   dependencies:
-    cyclist "~0.2.2"
-    inherits "^2.0.3"
-    readable-stream "^2.1.5"
+    dot-case "^3.0.4"
+    tslib "^2.0.3"
 
 parent-module@^1.0.0:
   version "1.0.0"
@@ -7249,39 +7024,6 @@ parent-module@^1.0.0:
   dependencies:
     callsites "^3.0.0"
 
-parse-asn1@^5.0.0:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.1.tgz#f6bf293818332bd0dab54efb16087724745e6ca8"
-  integrity sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==
-  dependencies:
-    asn1.js "^4.0.0"
-    browserify-aes "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.0"
-    pbkdf2 "^3.0.3"
-
-parse-github-repo-url@^1.3.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/parse-github-repo-url/-/parse-github-repo-url-1.4.1.tgz#9e7d8bb252a6cb6ba42595060b7bf6df3dbc1f50"
-  integrity sha1-nn2LslKmy2ukJZUGC3v23z28H1A=
-
-parse-glob@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"
-  integrity sha1-ssN2z7EfNVE7rdFz7wu246OIORw=
-  dependencies:
-    glob-base "^0.3.0"
-    is-dotfile "^1.0.0"
-    is-extglob "^1.0.0"
-    is-glob "^2.0.0"
-
-parse-json@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9"
-  integrity sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=
-  dependencies:
-    error-ex "^1.2.0"
-
 parse-json@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
@@ -7290,51 +7032,41 @@ parse-json@^4.0.0:
     error-ex "^1.3.1"
     json-parse-better-errors "^1.0.1"
 
+parse-json@^5.0.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
+  integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
+  dependencies:
+    "@babel/code-frame" "^7.0.0"
+    error-ex "^1.3.1"
+    json-parse-even-better-errors "^2.3.0"
+    lines-and-columns "^1.1.6"
+
 parse-passwd@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
   integrity sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=
 
-parseqs@0.0.5:
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/parseqs/-/parseqs-0.0.5.tgz#d5208a3738e46766e291ba2ea173684921a8b89d"
-  integrity sha1-1SCKNzjkZ2bikbouoXNoSSGouJ0=
-  dependencies:
-    better-assert "~1.0.0"
+parseurl@~1.3.3:
+  version "1.3.3"
+  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4"
+  integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
 
-parseuri@0.0.5:
-  version "0.0.5"
-  resolved "https://registry.yarnpkg.com/parseuri/-/parseuri-0.0.5.tgz#80204a50d4dbb779bfdc6ebe2778d90e4bce320a"
-  integrity sha1-gCBKUNTbt3m/3G6+J3jZDkvOMgo=
+pascal-case@^3.1.2:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz#b48e0ef2b98e205e7c1dae747d0b1508237660eb"
+  integrity sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==
   dependencies:
-    better-assert "~1.0.0"
-
-parseurl@~1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.2.tgz#fc289d4ed8993119460c156253262cdc8de65bf3"
-  integrity sha1-/CidTtiZMRlGDBViUyYs3I3mW/M=
-
-pascalcase@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14"
-  integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=
-
-path-browserify@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-0.0.0.tgz#a0b870729aae214005b7d5032ec2cbbb0fb4451a"
-  integrity sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=
-
-path-dirname@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
-  integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=
+    no-case "^3.0.4"
+    tslib "^2.0.3"
 
-path-exists@2.1.0, path-exists@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b"
-  integrity sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=
+path-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/path-case/-/path-case-3.0.4.tgz#9168645334eb942658375c56f80b4c0cb5f82c6f"
+  integrity sha512-qO4qCFjXqVTrcbPt/hQfhTQ+VhFsqNKOPtytgNKkKxSoEp3XPUQ8ObFuePylOIok5gjn69ry8XiULxCwot3Wfg==
   dependencies:
-    pinkie-promise "^2.0.0"
+    dot-case "^3.0.4"
+    tslib "^2.0.3"
 
 path-exists@^3.0.0:
   version "3.0.0"
@@ -7351,17 +7083,19 @@ path-is-absolute@^1.0.0:
   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
   integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
 
-path-is-inside@^1.0.1, path-is-inside@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53"
-  integrity sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=
+path-is-network-drive@^1.0.13:
+  version "1.0.13"
+  resolved "https://registry.yarnpkg.com/path-is-network-drive/-/path-is-network-drive-1.0.13.tgz#c9aa0183eb72c328aa83f43def93ddcb9d7ec4d4"
+  integrity sha512-Hg74mRN6mmXV+gTm3INjFK40ncAmC/Lo4qoQaSZ+GT3hZzlKdWQSqAjqyPeW0SvObP2W073WyYEBWY9d3wOm3A==
+  dependencies:
+    tslib "^2.3.1"
 
 path-key@^2.0.0, path-key@^2.0.1:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
   integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=
 
-path-key@^3.1.0:
+path-key@^3.0.0, path-key@^3.1.0:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
@@ -7371,14 +7105,17 @@ path-parse@^1.0.6:
   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
   integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==
 
-path-type@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441"
-  integrity sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=
+path-parse@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
+  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
+
+path-strip-sep@^1.0.10:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/path-strip-sep/-/path-strip-sep-1.0.10.tgz#2be4e789406b298af8709ff79af716134b733b98"
+  integrity sha512-JpCy+8LAJQQTO1bQsb/84s1g+/Stm3h39aOpPRBQ/paMUGVPPZChLTOTKHoaCkc/6sKuF7yVsnq5Pe1S6xQGcA==
   dependencies:
-    graceful-fs "^4.1.2"
-    pify "^2.0.0"
-    pinkie-promise "^2.0.0"
+    tslib "^2.3.1"
 
 path-type@^3.0.0:
   version "3.0.0"
@@ -7392,16 +7129,10 @@ path-type@^4.0.0:
   resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
   integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
 
-pbkdf2@^3.0.3:
-  version "3.0.17"
-  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.0.17.tgz#976c206530617b14ebb32114239f7b09336e93a6"
-  integrity sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==
-  dependencies:
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-    ripemd160 "^2.0.1"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
+pathval@1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/pathval/-/pathval-1.1.1.tgz#8534e77a77ce7ac5a2512ea21e0fdb8fcf6c3d8d"
+  integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==
 
 pend@~1.2.0:
   version "1.2.0"
@@ -7428,12 +7159,27 @@ phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
     request-progress "^2.0.1"
     which "^1.2.10"
 
-picomatch@^2.0.5, picomatch@^2.2.1, picomatch@^2.2.2:
+picocolors@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
+  integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
+
+picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
+  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
+
+picomatch@^2.0.5, picomatch@^2.2.2:
   version "2.2.2"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
   integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
 
-pify@^2.0.0, pify@^2.3.0:
+pidtree@^0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/pidtree/-/pidtree-0.5.0.tgz#ad5fbc1de78b8a5f99d6fbdd4f6e4eee21d1aca1"
+  integrity sha512-9nxspIM7OpZuhBxPg73Zvyq7j1QMPMPsGKTqRc2XOaFQauDvoNz9fM1Wdkjmeo7l9GXOZiRs97sPkuayl39wjA==
+
+pify@^2.2.0, pify@^2.3.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
   integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw=
@@ -7460,35 +7206,33 @@ pinkie@^2.0.0:
   resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
   integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
 
-pirates@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.0.tgz#850b18781b4ac6ec58a43c9ed9ec5fe6796addbd"
-  integrity sha512-8t5BsXy1LUIjn3WWOlOuFDuKswhQb/tkak641lvBgmPOBUQHXveORtlMCp6OdPV1dtuTaEahKA8VNz6uLfKBtA==
-  dependencies:
-    node-modules-regexp "^1.0.0"
-
-pkg-dir@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
-  integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
-  dependencies:
-    find-up "^3.0.0"
+pirates@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.5.tgz#feec352ea5c3268fb23a37c702ab1699f35a5f3b"
+  integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==
 
-pkg-dir@^4.1.0:
+pkg-dir@4.2.0, pkg-dir@^4.1.0, pkg-dir@^4.2.0:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
   integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
   dependencies:
     find-up "^4.0.0"
 
-please-upgrade-node@^3.0.2:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/please-upgrade-node/-/please-upgrade-node-3.1.1.tgz#ed320051dfcc5024fae696712c8288993595e8ac"
-  integrity sha512-KY1uHnQ2NlQHqIJQpnh/i54rKkuxCEBx+voJIS/Mvb+L2iYd2NMotwduhKTMjfC1uKoX3VXOxLjIYG66dfJTVQ==
+"pkg-dir@< 6 >= 5":
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-5.0.0.tgz#a02d6aebe6ba133a928f74aec20bafdfe6b8e760"
+  integrity sha512-NPE8TDbzl/3YQYY7CSS228s3g2ollTFnc+Qi3tqmqJp9Vg2ovUpixcJEo2HJScN2Ez+kEaal6y70c0ehqJBJeA==
   dependencies:
-    semver-compare "^1.0.0"
+    find-up "^5.0.0"
+
+pkg-dir@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
+  integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
+  dependencies:
+    find-up "^3.0.0"
 
-portfinder@^1.0.25:
+portfinder@^1.0.28:
   version "1.0.28"
   resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.28.tgz#67c4622852bd5374dd1dd900f779f53462fac778"
   integrity sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==
@@ -7497,11 +7241,6 @@ portfinder@^1.0.25:
     debug "^3.1.1"
     mkdirp "^0.5.5"
 
-posix-character-classes@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab"
-  integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=
-
 prelude-ls@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
@@ -7512,73 +7251,41 @@ prelude-ls@~1.1.2:
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
   integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=
 
-preserve@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
-  integrity sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=
-
-pretty-format@^23.6.0:
-  version "23.6.0"
-  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-23.6.0.tgz#5eaac8eeb6b33b987b7fe6097ea6a8a146ab5760"
-  integrity sha512-zf9NV1NSlDLDjycnwm6hpFATCGl/K1lt0R/GdkAK2O5LN/rwJoB+Mh93gGJjut4YbmecbfgLWVGSTCr0Ewvvbw==
-  dependencies:
-    ansi-regex "^3.0.0"
-    ansi-styles "^3.2.0"
-
-process-nextick-args@~1.0.6:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3"
-  integrity sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=
+prepend-http@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897"
+  integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=
 
 process-nextick-args@~2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.0.tgz#a37d732f4271b4ab1ad070d35508e8290788ffaa"
   integrity sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==
 
-process@^0.11.10:
-  version "0.11.10"
-  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
-  integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
+progress@2.0.3, progress@^2.0.1:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
+  integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
 
 progress@^1.1.8:
   version "1.1.8"
   resolved "https://registry.yarnpkg.com/progress/-/progress-1.1.8.tgz#e260c78f6161cdd9b0e56cc3e0a85de17c7a57be"
   integrity sha1-4mDHj2Fhzdmw5WzD4Khd4Xx6V74=
 
-progress@^2.0.0, progress@^2.0.1:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
-  integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
-
-promise-inflight@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/promise-inflight/-/promise-inflight-1.0.1.tgz#98472870bf228132fcbdd868129bad12c3c029e3"
-  integrity sha1-mEcocL8igTL8vdhoEputEsPAKeM=
+proto-list@~1.2.1:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/proto-list/-/proto-list-1.2.4.tgz#212d5bfe1318306a420f6402b8e26ff39647a849"
+  integrity sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=
 
-proxy-agent@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/proxy-agent/-/proxy-agent-2.0.0.tgz#57eb5347aa805d74ec681cb25649dba39c933499"
-  integrity sha1-V+tTR6qAXXTsaByyVknbo5yTNJk=
-  dependencies:
-    agent-base "2"
-    debug "2"
-    extend "3"
-    http-proxy-agent "1"
-    https-proxy-agent "1"
-    lru-cache "~2.6.5"
-    pac-proxy-agent "1"
-    socks-proxy-agent "2"
+proxy-from-env@1.1.0, proxy-from-env@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2"
+  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
 
 proxy-from-env@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.0.0.tgz#33c50398f70ea7eb96d21f7b817630a55791c7ee"
   integrity sha1-M8UDmPcOp+uW0h97gXYwpVeRx+4=
 
-prr@~1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/prr/-/prr-1.0.1.tgz#d3fc114ba06995a45ec6893f484ceb1d78f5f476"
-  integrity sha1-0/wRS6BplaRexok/SEzrHXj19HY=
-
 pseudomap@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"
@@ -7589,26 +7296,6 @@ psl@^1.1.24:
   resolved "https://registry.yarnpkg.com/psl/-/psl-1.1.31.tgz#e9aa86d0101b5b105cbe93ac6b784cd547276184"
   integrity sha512-/6pt4+C+T+wZUieKR620OpzN/LlnNKuWjy1iFLQ/UG35JqHlR/89MP1d96dUfkf6Dne3TuLQzOYEYshJ+Hx8mw==
 
-public-encrypt@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.3.tgz#4fcc9d77a07e48ba7527e7cbe0de33d0701331e0"
-  integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==
-  dependencies:
-    bn.js "^4.1.0"
-    browserify-rsa "^4.0.0"
-    create-hash "^1.1.0"
-    parse-asn1 "^5.0.0"
-    randombytes "^2.0.1"
-    safe-buffer "^5.1.2"
-
-pump@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-2.0.1.tgz#12399add6e4cf7526d973cbc8b5ce2e2908b3909"
-  integrity sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
 pump@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
@@ -7617,21 +7304,7 @@ pump@^3.0.0:
     end-of-stream "^1.1.0"
     once "^1.3.1"
 
-pumpify@^1.3.3:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/pumpify/-/pumpify-1.5.1.tgz#36513be246ab27570b1a374a5ce278bfd74370ce"
-  integrity sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==
-  dependencies:
-    duplexify "^3.6.0"
-    inherits "^2.0.3"
-    pump "^2.0.0"
-
-punycode@1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
-  integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=
-
-punycode@^1.2.4, punycode@^1.4.1:
+punycode@^1.3.2, punycode@^1.4.1:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
   integrity sha1-wNWmOycYgArY4esPpSachN1BhF4=
@@ -7641,80 +7314,92 @@ punycode@^2.1.0:
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
 
-puppeteer@^1.11.0:
-  version "1.11.0"
-  resolved "https://registry.yarnpkg.com/puppeteer/-/puppeteer-1.11.0.tgz#63cdbe12b07275cd6e0b94bce41f3fcb20305770"
-  integrity sha512-iG4iMOHixc2EpzqRV+pv7o3GgmU2dNYEMkvKwSaQO/vMZURakwSOn/EYJ6OIRFYOque1qorzIBvrytPIQB3YzQ==
+puppeteer-core@^5.1.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/puppeteer-core/-/puppeteer-core-5.5.0.tgz#dfb6266efe5a933cbf1a368d27025a6fd4f5a884"
+  integrity sha512-tlA+1n+ziW/Db03hVV+bAecDKse8ihFRXYiEypBe9IlLRvOCzYFG6qrCMBYK34HO/Q/Ecjc+tvkHRAfLVH+NgQ==
   dependencies:
     debug "^4.1.0"
-    extract-zip "^1.6.6"
-    https-proxy-agent "^2.2.1"
-    mime "^2.0.3"
+    devtools-protocol "0.0.818844"
+    extract-zip "^2.0.0"
+    https-proxy-agent "^4.0.0"
+    node-fetch "^2.6.1"
+    pkg-dir "^4.2.0"
     progress "^2.0.1"
     proxy-from-env "^1.0.0"
-    rimraf "^2.6.1"
-    ws "^6.1.0"
-
-q@1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/q/-/q-1.4.1.tgz#55705bcd93c5f3673530c2c2cbc0c2b3addc286e"
-  integrity sha1-VXBbzZPF82c1MMLCy8DCs63cKG4=
+    rimraf "^3.0.2"
+    tar-fs "^2.0.0"
+    unbzip2-stream "^1.3.3"
+    ws "^7.2.3"
 
-q@^1.4.1, q@^1.5.1:
+puppeteer@^13.7.0:
+  version "13.7.0"
+  resolved "https://registry.yarnpkg.com/puppeteer/-/puppeteer-13.7.0.tgz#18e16f83e397cf02f7a0804c67c1603d381cfb0b"
+  integrity sha512-U1uufzBjz3+PkpCxFrWzh4OrMIdIb2ztzCu0YEPfRHjHswcSwHZswnK+WdsOQJsRV8WeTg3jLhJR4D867+fjsA==
+  dependencies:
+    cross-fetch "3.1.5"
+    debug "4.3.4"
+    devtools-protocol "0.0.981744"
+    extract-zip "2.0.1"
+    https-proxy-agent "5.0.1"
+    pkg-dir "4.2.0"
+    progress "2.0.3"
+    proxy-from-env "1.1.0"
+    rimraf "3.0.2"
+    tar-fs "2.1.1"
+    unbzip2-stream "1.4.3"
+    ws "8.5.0"
+
+q@^1.5.1:
   version "1.5.1"
   resolved "https://registry.yarnpkg.com/q/-/q-1.5.1.tgz#7e32f75b41381291d04611f1bf14109ac00651d7"
   integrity sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=
 
-qjobs@^1.1.4:
+qjobs@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/qjobs/-/qjobs-1.2.0.tgz#c45e9c61800bd087ef88d7e256423bdd49e5d071"
   integrity sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==
 
-qs@6.5.2, qs@~6.5.2:
-  version "6.5.2"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
-  integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
+qs@6.10.3:
+  version "6.10.3"
+  resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.3.tgz#d6cde1b2ffca87b5aa57889816c5f81535e22e8e"
+  integrity sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==
+  dependencies:
+    side-channel "^1.0.4"
 
 qs@^6.4.0:
   version "6.9.4"
   resolved "https://registry.yarnpkg.com/qs/-/qs-6.9.4.tgz#9090b290d1f91728d3c22e54843ca44aea5ab687"
   integrity sha512-A1kFqHekCTM7cz0udomYUoYNWjBebHm/5wzU/XqrBRBNWectVH0QIiN+NEcZ0Dte5hvzHwbr8+XQmguPhJ6WdQ==
 
-querystring-es3@^0.2.0:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
-  integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=
+qs@~6.5.2:
+  version "6.5.2"
+  resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
+  integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==
 
-querystring@0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
-  integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
+query-string@^5.0.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/query-string/-/query-string-5.1.1.tgz#a78c012b71c17e05f2e3fa2319dd330682efb3cb"
+  integrity sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==
+  dependencies:
+    decode-uri-component "^0.2.0"
+    object-assign "^4.1.0"
+    strict-uri-encode "^1.0.0"
 
 queue-microtask@^1.2.2:
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
-quick-lru@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8"
-  integrity sha1-Q2CxfGETatOAeDl/8RQW4Ybc+7g=
-
-randomatic@^3.0.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed"
-  integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==
-  dependencies:
-    is-number "^4.0.0"
-    kind-of "^6.0.0"
-    math-random "^1.0.1"
+quick-lru@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
+  integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==
 
-randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.0.6.tgz#d302c522948588848a8d300c932b44c24231da80"
-  integrity sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==
-  dependencies:
-    safe-buffer "^5.1.0"
+quick-lru@^5.1.1:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
+  integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
 
 randombytes@^2.1.0:
   version "2.1.0"
@@ -7723,47 +7408,21 @@ randombytes@^2.1.0:
   dependencies:
     safe-buffer "^5.1.0"
 
-randomfill@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/randomfill/-/randomfill-1.0.4.tgz#c92196fc86ab42be983f1bf31778224931d61458"
-  integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==
-  dependencies:
-    randombytes "^2.0.5"
-    safe-buffer "^5.1.0"
-
-range-parser@^1.0.3, range-parser@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.0.tgz#f49be6b487894ddc40dcc94a322f611092e00d5e"
-  integrity sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=
+range-parser@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031"
+  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
 
-raw-body@2, raw-body@2.3.3:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.3.3.tgz#1b324ece6b5706e153855bc1148c65bb7f6ea0c3"
-  integrity sha512-9esiElv1BrZoI3rCDuOuKCBRbuApGGaDPQfjSflGxdy4oyzqghxu6klEkkVIvBje+FF0BX9coEv8KqW6X/7njw==
+raw-body@2.5.1:
+  version "2.5.1"
+  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.1.tgz#fe1b1628b181b700215e5fd42389f98b71392857"
+  integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==
   dependencies:
-    bytes "3.0.0"
-    http-errors "1.6.3"
-    iconv-lite "0.4.23"
+    bytes "3.1.2"
+    http-errors "2.0.0"
+    iconv-lite "0.4.24"
     unpipe "1.0.0"
 
-rc@^1.2.7:
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed"
-  integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
-  dependencies:
-    deep-extend "^0.6.0"
-    ini "~1.3.0"
-    minimist "^1.2.0"
-    strip-json-comments "~2.0.1"
-
-read-pkg-up@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02"
-  integrity sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=
-  dependencies:
-    find-up "^1.0.0"
-    read-pkg "^1.0.0"
-
 read-pkg-up@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
@@ -7772,22 +7431,14 @@ read-pkg-up@^3.0.0:
     find-up "^2.0.0"
     read-pkg "^3.0.0"
 
-read-pkg-up@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-4.0.0.tgz#1b221c6088ba7799601c808f91161c66e58f8978"
-  integrity sha512-6etQSH7nJGsK0RbG/2TeDzZFa8shjQ1um+SwQQ5cwKy0dhSXdOncEhb1CPpvQG4h7FyOV6EB6YlV0yJvZQNAkA==
-  dependencies:
-    find-up "^3.0.0"
-    read-pkg "^3.0.0"
-
-read-pkg@^1.0.0, read-pkg@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28"
-  integrity sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=
+read-pkg-up@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
+  integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==
   dependencies:
-    load-json-file "^1.0.0"
-    normalize-package-data "^2.3.2"
-    path-type "^1.0.0"
+    find-up "^4.1.0"
+    read-pkg "^5.2.0"
+    type-fest "^0.8.1"
 
 read-pkg@^3.0.0:
   version "3.0.0"
@@ -7798,7 +7449,26 @@ read-pkg@^3.0.0:
     normalize-package-data "^2.3.2"
     path-type "^3.0.0"
 
-"readable-stream@1 || 2", readable-stream@2, readable-stream@^2.0.0, readable-stream@^2.0.1, readable-stream@^2.0.2, readable-stream@^2.0.4, readable-stream@^2.0.6, readable-stream@^2.1.5, readable-stream@^2.2.2, readable-stream@^2.3.0, readable-stream@^2.3.3, readable-stream@^2.3.6, readable-stream@~2.3.6:
+read-pkg@^5.2.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
+  integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==
+  dependencies:
+    "@types/normalize-package-data" "^2.4.0"
+    normalize-package-data "^2.5.0"
+    parse-json "^5.0.0"
+    type-fest "^0.6.0"
+
+readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
+  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
+  dependencies:
+    inherits "^2.0.3"
+    string_decoder "^1.1.1"
+    util-deprecate "^1.0.1"
+
+readable-stream@^2.0.0, readable-stream@^2.2.2, readable-stream@^2.3.0, readable-stream@~2.3.6:
   version "2.3.6"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.6.tgz#b11c27d88b8ff1fbe070643cf94b0c79ae1b0aaf"
   integrity sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==
@@ -7811,36 +7481,32 @@ read-pkg@^3.0.0:
     string_decoder "~1.1.1"
     util-deprecate "~1.0.1"
 
-readable-stream@1.1.x:
-  version "1.1.14"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.14.tgz#7cf4c54ef648e3813084c636dd2079e166c081d9"
-  integrity sha1-fPTFTvZI44EwhMY23SB54WbAgdk=
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.1"
-    isarray "0.0.1"
-    string_decoder "~0.10.x"
-
-readable-stream@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.0.6.tgz#8f90341e68a53ccc928788dacfcd11b36eb9b78e"
-  integrity sha1-j5A0HmilPMySh4jaz80Rs265t44=
+readable-stream@^2.0.5, readable-stream@^2.3.5:
+  version "2.3.7"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
+  integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
   dependencies:
     core-util-is "~1.0.0"
-    inherits "~2.0.1"
+    inherits "~2.0.3"
     isarray "~1.0.0"
-    process-nextick-args "~1.0.6"
-    string_decoder "~0.10.x"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
     util-deprecate "~1.0.1"
 
-readdirp@^2.0.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-2.2.1.tgz#0e87622a3325aa33e892285caf8b4e846529a525"
-  integrity sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==
+readdir-glob@^1.0.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/readdir-glob/-/readdir-glob-1.1.1.tgz#f0e10bb7bf7bfa7e0add8baffdc54c3f7dbee6c4"
+  integrity sha512-91/k1EzZwDx6HbERR+zucygRFfiPl2zkIYZtv3Jjr6Mn7SkKcVct8aVO+sSRiGMc6fLf72du3d92/uY63YPdEA==
+  dependencies:
+    minimatch "^3.0.4"
+
+readdirp@~3.6.0:
+  version "3.6.0"
+  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7"
+  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
   dependencies:
-    graceful-fs "^4.1.11"
-    micromatch "^3.1.10"
-    readable-stream "^2.0.2"
+    picomatch "^2.2.1"
 
 rechoir@^0.6.2:
   version "0.6.2"
@@ -7849,21 +7515,20 @@ rechoir@^0.6.2:
   dependencies:
     resolve "^1.1.6"
 
-redent@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-1.0.0.tgz#cf916ab1fd5f1f16dfb20822dd6ec7f730c2afde"
-  integrity sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94=
+redent@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f"
+  integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==
   dependencies:
-    indent-string "^2.1.0"
-    strip-indent "^1.0.1"
+    indent-string "^4.0.0"
+    strip-indent "^3.0.0"
 
-redent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-2.0.0.tgz#c1b2007b42d57eb1389079b3c8333639d5e1ccaa"
-  integrity sha1-wbIAe0LVfrE4kHmzyDM2OdXhzKo=
+regenerate-unicode-properties@^10.0.1:
+  version "10.0.1"
+  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.0.1.tgz#7f442732aa7934a3740c779bb9b3340dccc1fb56"
+  integrity sha512-vn5DU6yg6h8hP/2OkQo3K7uVILvY4iu0oI4t3HFa81UPkhGJwkRwM10JEc3upjdhHjs/k8GJY1sRBhk5sr69Bw==
   dependencies:
-    indent-string "^3.0.0"
-    strip-indent "^2.0.0"
+    regenerate "^1.4.2"
 
 regenerate-unicode-properties@^8.0.2, regenerate-unicode-properties@^8.2.0:
   version "8.2.0"
@@ -7872,16 +7537,11 @@ regenerate-unicode-properties@^8.0.2, regenerate-unicode-properties@^8.2.0:
   dependencies:
     regenerate "^1.4.0"
 
-regenerate@^1.4.0:
+regenerate@^1.4.0, regenerate@^1.4.2:
   version "1.4.2"
   resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
   integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
-regenerator-runtime@^0.10.0:
-  version "0.10.5"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz#336c3efc1220adcedda2c9fab67b5a7955a33658"
-  integrity sha1-M2w+/BIgrc7dosn6tntaeVWjNlg=
-
 regenerator-runtime@^0.11.0:
   version "0.11.1"
   resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
@@ -7892,32 +7552,17 @@ regenerator-runtime@^0.13.4:
   resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz#cac2dacc8a1ea675feaabaeb8ae833898ae46f55"
   integrity sha512-a54FxoJDIr27pgf7IgeQGxmqUNYrcV338lf/6gH456HZ/PhX+5BcwHXG9ajESmwe6WRO0tAzRUrRmNONWgkrew==
 
-regenerator-transform@^0.14.2:
-  version "0.14.5"
-  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.14.5.tgz#c98da154683671c9c4dcb16ece736517e1b7feb4"
-  integrity sha512-eOf6vka5IO151Jfsw2NO9WpGX58W6wWmefK3I1zEGr0lOD0u8rwPaNqQL1aRxUaxLeKO3ArNh3VYg1KbaD+FFw==
+regenerator-transform@^0.15.0:
+  version "0.15.0"
+  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.15.0.tgz#cbd9ead5d77fae1a48d957cf889ad0586adb6537"
+  integrity sha512-LsrGtPmbYg19bcPHwdtmXwbW+TqNvtY4riE3P83foeHRroMbH6/2ddFBfab3t7kbzc7v7p4wbkIecHImqt0QNg==
   dependencies:
     "@babel/runtime" "^7.8.4"
 
-regex-cache@^0.4.2:
-  version "0.4.4"
-  resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.4.tgz#75bdc58a2a1496cec48a12835bc54c8d562336dd"
-  integrity sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==
-  dependencies:
-    is-equal-shallow "^0.1.3"
-
-regex-not@^1.0.0, regex-not@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/regex-not/-/regex-not-1.0.2.tgz#1f4ece27e00b0b65e0247a6810e6a85d83a5752c"
-  integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==
-  dependencies:
-    extend-shallow "^3.0.2"
-    safe-regex "^1.1.0"
-
-regexpp@^3.0.0, regexpp@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.1.0.tgz#206d0ad0a5648cffbdb8ae46438f3dc51c9f78e2"
-  integrity sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q==
+regexpp@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
+  integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==
 
 regexpu-core@4.5.4:
   version "4.5.4"
@@ -7943,6 +7588,18 @@ regexpu-core@^4.7.1:
     unicode-match-property-ecmascript "^1.0.4"
     unicode-match-property-value-ecmascript "^1.2.0"
 
+regexpu-core@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-5.0.1.tgz#c531122a7840de743dcf9c83e923b5560323ced3"
+  integrity sha512-CriEZlrKK9VJw/xQGJpQM5rY88BtuL8DM+AEwvcThHilbxiTAy8vq4iJnd2tqq8wLmjbGZzP7ZcKFjbGkmEFrw==
+  dependencies:
+    regenerate "^1.4.2"
+    regenerate-unicode-properties "^10.0.1"
+    regjsgen "^0.6.0"
+    regjsparser "^0.8.2"
+    unicode-match-property-ecmascript "^2.0.0"
+    unicode-match-property-value-ecmascript "^2.0.0"
+
 regjsgen@^0.5.0:
   version "0.5.0"
   resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.0.tgz#a7634dc08f89209c2049adda3525711fb97265dd"
@@ -7953,6 +7610,11 @@ regjsgen@^0.5.1:
   resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.2.tgz#92ff295fb1deecbf6ecdab2543d207e91aa33733"
   integrity sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==
 
+regjsgen@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.6.0.tgz#83414c5354afd7d6627b16af5f10f41c4e71808d"
+  integrity sha512-ozE883Uigtqj3bx7OhL1KNbCzGyW2NQZPl6Hs09WTvCuZD5sTI4JY58bkbQWa/Y9hxIsvJ3M8Nbf7j54IqeZbA==
+
 regjsparser@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.0.tgz#f1e6ae8b7da2bae96c99399b868cd6c933a2ba9c"
@@ -7967,32 +7629,12 @@ regjsparser@^0.6.4:
   dependencies:
     jsesc "~0.5.0"
 
-remove-trailing-separator@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
-  integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8=
-
-repeat-element@^1.1.2:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce"
-  integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==
-
-repeat-string@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-0.2.2.tgz#c7a8d3236068362059a7e4651fc6884e8b1fb4ae"
-  integrity sha1-x6jTI2BoNiBZp+RlH8aITosftK4=
-
-repeat-string@^1.5.2, repeat-string@^1.6.1:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
-  integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
-
-repeating@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda"
-  integrity sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=
+regjsparser@^0.8.2:
+  version "0.8.4"
+  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.8.4.tgz#8a14285ffcc5de78c5b95d62bbf413b6bc132d5f"
+  integrity sha512-J3LABycON/VNEu3abOviqGHuB/LOtOQj8SKmfP9anY5GfAVw/SPjwzSjxGjbZXIxbGfqTHtJw58C2Li/WkStmA==
   dependencies:
-    is-finite "^1.0.0"
+    jsesc "~0.5.0"
 
 request-progress@^2.0.1:
   version "2.0.1"
@@ -8001,7 +7643,7 @@ request-progress@^2.0.1:
   dependencies:
     throttleit "^1.0.0"
 
-request@^2.81.0, request@^2.87.0, request@^2.88.0:
+request@^2.81.0:
   version "2.88.0"
   resolved "https://registry.yarnpkg.com/request/-/request-2.88.0.tgz#9c2fca4f7d35b592efe57c7f0a55e81052124fef"
   integrity sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==
@@ -8032,45 +7674,63 @@ require-directory@^2.1.1:
   resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
 
-require-from-string@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909"
-  integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==
-
-require-main-filename@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-1.0.1.tgz#97f717b69d48784f5f526a6c5aa8ffdda055a4d1"
-  integrity sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=
-
 requires-port@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
   integrity sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=
 
-resolve-dir@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-0.1.1.tgz#b219259a5602fac5c5c496ad894a6e8cc430261e"
-  integrity sha1-shklmlYC+sXFxJatiUpujMQwJh4=
+resolve-alpn@^1.0.0:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/resolve-alpn/-/resolve-alpn-1.2.1.tgz#b7adbdac3546aaaec20b45e7d8265927072726f9"
+  integrity sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==
+
+resolve-dir@^1.0.0, resolve-dir@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-1.0.1.tgz#79a40644c362be82f26effe739c9bb5382046f43"
+  integrity sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=
   dependencies:
-    expand-tilde "^1.2.2"
-    global-modules "^0.2.3"
+    expand-tilde "^2.0.0"
+    global-modules "^1.0.0"
 
 resolve-from@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
   integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
 
+resolve-from@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
+  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
+
+resolve-global@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/resolve-global/-/resolve-global-1.0.0.tgz#a2a79df4af2ca3f49bf77ef9ddacd322dad19255"
+  integrity sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==
+  dependencies:
+    global-dirs "^0.1.1"
+
 resolve-url@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
   integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
 
-resolve@1.1.x:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b"
-  integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=
+resolve@^1.1.6:
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.9.0.tgz#a14c6fdfa8f92a7df1d996cb7105fa744658ea06"
+  integrity sha512-TZNye00tI67lwYvzxCxHGjwTNlUV70io54/Ed4j6PscB8xVfuBJpRenI/o6dVk0cY0PYTY27AgCoGGxRnYuItQ==
+  dependencies:
+    path-parse "^1.0.6"
 
-resolve@1.20.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0:
+resolve@^1.10.0, resolve@^1.12.0, resolve@^1.20.0, resolve@^1.22.0:
+  version "1.22.0"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.0.tgz#5e0b8c67c15df57a89bdbabe603a002f21731198"
+  integrity sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==
+  dependencies:
+    is-core-module "^2.8.1"
+    path-parse "^1.0.7"
+    supports-preserve-symlinks-flag "^1.0.0"
+
+resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0:
   version "1.20.0"
   resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
   integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
@@ -8078,20 +7738,26 @@ resolve@1.20.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0:
     is-core-module "^2.2.0"
     path-parse "^1.0.6"
 
-resolve@^1.1.6, resolve@^1.3.3:
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.9.0.tgz#a14c6fdfa8f92a7df1d996cb7105fa744658ea06"
-  integrity sha512-TZNye00tI67lwYvzxCxHGjwTNlUV70io54/Ed4j6PscB8xVfuBJpRenI/o6dVk0cY0PYTY27AgCoGGxRnYuItQ==
+responselike@1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/responselike/-/responselike-1.0.2.tgz#918720ef3b631c5642be068f15ade5a46f4ba1e7"
+  integrity sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=
   dependencies:
-    path-parse "^1.0.6"
+    lowercase-keys "^1.0.0"
 
-restore-cursor@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541"
-  integrity sha1-NGYfRohjJ/7SmRR5FSJS35LapUE=
+responselike@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/responselike/-/responselike-2.0.0.tgz#26391bcc3174f750f9a79eacc40a12a5c42d7723"
+  integrity sha512-xH48u3FTB9VsZw7R+vvgaKeLKzT6jOogbQhEe/jewwnZgzPcnyWui2Av6JpoYZF/91uueC+lqhWqeURw5/qhCw==
+  dependencies:
+    lowercase-keys "^2.0.0"
+
+resq@^1.9.1:
+  version "1.10.2"
+  resolved "https://registry.yarnpkg.com/resq/-/resq-1.10.2.tgz#cedf4f20d53f6e574b1e12afbda446ad9576c193"
+  integrity sha512-HmgVS3j+FLrEDBTDYysPdPVF9/hioDMJ/otOiQDKqk77YfZeeLOj0qi34yObumcud1gBpk+wpBTEg4kMicD++A==
   dependencies:
-    exit-hook "^1.0.0"
-    onetime "^1.0.0"
+    fast-deep-equal "^2.0.1"
 
 restore-cursor@^2.0.0:
   version "2.0.0"
@@ -8101,65 +7767,66 @@ restore-cursor@^2.0.0:
     onetime "^2.0.0"
     signal-exit "^3.0.2"
 
-ret@~0.1.10:
-  version "0.1.15"
-  resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc"
-  integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==
+restore-cursor@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e"
+  integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==
+  dependencies:
+    onetime "^5.1.0"
+    signal-exit "^3.0.2"
 
 reusify@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
   integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
 
-rfdc@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.1.2.tgz#e6e72d74f5dc39de8f538f65e00c36c18018e349"
-  integrity sha512-92ktAgvZhBzYTIK0Mja9uen5q5J3NRVMoDkJL2VMwq6SXjVCgqvQeVP2XAaUY6HT+XpQYeLSjb3UoitBryKmdA==
-
-right-pad@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/right-pad/-/right-pad-1.0.1.tgz#8ca08c2cbb5b55e74dafa96bf7fd1a27d568c8d0"
-  integrity sha1-jKCMLLtbVedNr6lr9/0aJ9VoyNA=
+rfdc@^1.3.0:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.3.0.tgz#d0b7c441ab2720d05dc4cf26e01c89631d9da08b"
+  integrity sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==
 
-rimraf@^2.2.8, rimraf@^2.5.4, rimraf@^2.6.0, rimraf@^2.6.1, rimraf@^2.6.2:
-  version "2.6.3"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab"
-  integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==
-  dependencies:
-    glob "^7.1.3"
+rgb2hex@0.2.3:
+  version "0.2.3"
+  resolved "https://registry.yarnpkg.com/rgb2hex/-/rgb2hex-0.2.3.tgz#8aa464c517b8a26c7a79d767dabaec2b49ee78ec"
+  integrity sha512-clEe0m1xv+Tva1B/TOepuIcvLAxP0U+sCDfgt1SX1HmI2Ahr5/Cd/nzJM1e78NKVtWdoo0s33YehpFA8UfIShQ==
 
-rimraf@^3.0.2:
+rimraf@3.0.2, rimraf@^3.0.0, rimraf@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
   integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
   dependencies:
     glob "^7.1.3"
 
-ripemd160@^2.0.0, ripemd160@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
-  integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-
-rollup-plugin-typescript2@^0.30.0:
-  version "0.30.0"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.30.0.tgz#1cc99ac2309bf4b9d0a3ebdbc2002aecd56083d3"
-  integrity sha512-NUFszIQyhgDdhRS9ya/VEmsnpTe+GERDMmFo0Y+kf8ds51Xy57nPNGglJY+W6x1vcouA7Au7nsTgsLFj2I0PxQ==
+roarr@^2.15.3:
+  version "2.15.4"
+  resolved "https://registry.yarnpkg.com/roarr/-/roarr-2.15.4.tgz#f5fe795b7b838ccfe35dc608e0282b9eba2e7afd"
+  integrity sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==
   dependencies:
-    "@rollup/pluginutils" "^4.1.0"
-    find-cache-dir "^3.3.1"
-    fs-extra "8.1.0"
-    resolve "1.20.0"
-    tslib "2.1.0"
-
-rollup@^2.44.0:
-  version "2.44.0"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.44.0.tgz#8da324d1c4fd12beef9ae6e12f4068265b6d95eb"
-  integrity sha512-rGSF4pLwvuaH/x4nAS+zP6UNn5YUDWf/TeEU5IoXSZKBbKRNTCI3qMnYXKZgrC0D2KzS2baiOZt1OlqhMu5rnQ==
+    boolean "^3.0.1"
+    detect-node "^2.0.4"
+    globalthis "^1.0.1"
+    json-stringify-safe "^5.0.1"
+    semver-compare "^1.0.0"
+    sprintf-js "^1.1.2"
+
+rollup-plugin-typescript2@^0.31.2:
+  version "0.31.2"
+  resolved "https://registry.yarnpkg.com/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.31.2.tgz#463aa713a7e2bf85b92860094b9f7fb274c5a4d8"
+  integrity sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==
+  dependencies:
+    "@rollup/pluginutils" "^4.1.2"
+    "@yarn-tool/resolve-package" "^1.0.40"
+    find-cache-dir "^3.3.2"
+    fs-extra "^10.0.0"
+    resolve "^1.20.0"
+    tslib "^2.3.1"
+
+rollup@^2.70.2:
+  version "2.70.2"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.70.2.tgz#808d206a8851628a065097b7ba2053bd83ba0c0d"
+  integrity sha512-EitogNZnfku65I1DD5Mxe8JYRUCy0hkK5X84IlDtUs+O6JRMpRciXTzyCUuX11b5L5pvjH+OmFXiQ3XjabcXgg==
   optionalDependencies:
-    fsevents "~2.3.1"
+    fsevents "~2.3.2"
 
 run-async@^2.2.0:
   version "2.3.0"
@@ -8175,107 +7842,109 @@ run-parallel@^1.1.9:
   dependencies:
     queue-microtask "^1.2.2"
 
-run-queue@^1.0.0, run-queue@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/run-queue/-/run-queue-1.0.3.tgz#e848396f057d223f24386924618e25694161ec47"
-  integrity sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=
+rxjs@^6.4.0:
+  version "6.6.7"
+  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.6.7.tgz#90ac018acabf491bf65044235d5863c4dab804c9"
+  integrity sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==
   dependencies:
-    aproba "^1.1.1"
-
-rx@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/rx/-/rx-4.1.0.tgz#a5f13ff79ef3b740fe30aa803fb09f98805d4782"
-  integrity sha1-pfE/957zt0D+MKqAP7CfmIBdR4I=
+    tslib "^1.9.0"
 
-rxjs@^6.3.3:
-  version "6.3.3"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.3.3.tgz#3c6a7fa420e844a81390fb1158a9ec614f4bad55"
-  integrity sha512-JTWmoY9tWCs7zvIk/CvRjhjGaOd+OVBM987mxFo+OW66cGpdKjZcpmc74ES1sB//7Kl/PAe8+wEakuhG4pcgOw==
+rxjs@^7.5.5:
+  version "7.5.5"
+  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.5.5.tgz#2ebad89af0f560f460ad5cc4213219e1f7dd4e9f"
+  integrity sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==
   dependencies:
-    tslib "^1.9.0"
+    tslib "^2.1.0"
 
-safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
+safe-buffer@5.1.2, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
-safe-regex@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e"
-  integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4=
-  dependencies:
-    ret "~0.1.10"
+safe-buffer@5.2.1, safe-buffer@~5.2.0:
+  version "5.2.1"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
 
-"safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
+"safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
-sauce-connect-launcher@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/sauce-connect-launcher/-/sauce-connect-launcher-1.2.4.tgz#8d38f85242a9fbede1b2303b559f7e20c5609a1c"
-  integrity sha512-X2vfwulR6brUGiicXKxPm1GJ7dBEeP1II450Uv4bHGrcGOapZNgzJvn9aioea5IC5BPp/7qjKdE3xbbTBIVXMA==
-  dependencies:
-    adm-zip "~0.4.3"
-    async "^2.1.2"
-    https-proxy-agent "^2.2.1"
-    lodash "^4.16.6"
-    rimraf "^2.5.4"
-
-saucelabs@^1.5.0:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/saucelabs/-/saucelabs-1.5.0.tgz#9405a73c360d449b232839919a86c396d379fd9d"
-  integrity sha512-jlX3FGdWvYf4Q3LFfFWS1QvPg3IGCGWxIc8QBFdPTbpTJnt/v17FHXYVAn7C8sHf1yUXo2c7yIM0isDryfYtHQ==
+saucelabs@^4.6.3:
+  version "4.7.8"
+  resolved "https://registry.yarnpkg.com/saucelabs/-/saucelabs-4.7.8.tgz#099a7ddacee297b34420acd5ddc155eb1ad0efde"
+  integrity sha512-K2qaRUixc7+8JiAwpTvEsIQVzzUkYwa0mAfs0akGagRlWXUR1JrsmgJRyz28qkwpERW1KDuByn3Ju96BuW1V7Q==
   dependencies:
-    https-proxy-agent "^2.2.1"
-
-sax@>=0.6.0, sax@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9"
-  integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==
+    bin-wrapper "^4.1.0"
+    change-case "^4.1.1"
+    form-data "^3.0.0"
+    got "^11.7.0"
+    hash.js "^1.1.7"
+    tunnel "0.0.6"
+    yargs "^16.0.3"
 
-schema-utils@^0.4.4:
-  version "0.4.7"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-0.4.7.tgz#ba74f597d2be2ea880131746ee17d0a093c68187"
-  integrity sha512-v/iwU6wvwGK8HbU9yi3/nhGzP0yGSuhQMzL6ySiec1FSrZZDkhm4noOSWzrNFo/jEc+SJY6jRTwuwbSXJPDUnQ==
+schema-utils@^2.6.5:
+  version "2.7.1"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-2.7.1.tgz#1ca4f32d1b24c590c203b8e7a50bf0ea4cd394d7"
+  integrity sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==
   dependencies:
-    ajv "^6.1.0"
-    ajv-keywords "^3.1.0"
+    "@types/json-schema" "^7.0.5"
+    ajv "^6.12.4"
+    ajv-keywords "^3.5.2"
 
-schema-utils@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-1.0.0.tgz#0b79a93204d7b600d4b2850d1f66c2a34951c770"
-  integrity sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==
+schema-utils@^3.0.0, schema-utils@^3.1.0, schema-utils@^3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.1.1.tgz#bc74c4b6b6995c1d88f76a8b77bea7219e0c8281"
+  integrity sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==
   dependencies:
-    ajv "^6.1.0"
-    ajv-errors "^1.0.0"
-    ajv-keywords "^3.1.0"
+    "@types/json-schema" "^7.0.8"
+    ajv "^6.12.5"
+    ajv-keywords "^3.5.2"
 
 secure-compare@3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/secure-compare/-/secure-compare-3.0.1.tgz#f1a0329b308b221fae37b9974f3d578d0ca999e3"
   integrity sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=
 
-selenium-server@^2.53.1:
-  version "2.53.1"
-  resolved "https://registry.yarnpkg.com/selenium-server/-/selenium-server-2.53.1.tgz#d681528812f3c2e0531a6b7e613e23bb02cce8a6"
-  integrity sha1-1oFSiBLzwuBTGmt+YT4juwLM6KY=
+seek-bzip@^1.0.5:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/seek-bzip/-/seek-bzip-1.0.6.tgz#35c4171f55a680916b52a07859ecf3b5857f21c4"
+  integrity sha512-e1QtP3YL5tWww8uKaOCQ18UxIT2laNBXHjV/S2WYCiK4udiv8lkG89KRIoCjUagnAmCBurjF4zEVX2ByBbnCjQ==
+  dependencies:
+    commander "^2.8.1"
+
+selenium-server@^3.141.59:
+  version "3.141.59"
+  resolved "https://registry.yarnpkg.com/selenium-server/-/selenium-server-3.141.59.tgz#cbefdf50aae636ee4c67b819532a8233ce3fd6b0"
+  integrity sha512-pL7T1YtAqOEXiBbTx0KdZMkE2U7PYucemd7i0nDLcxcR1APXYZlJfNr5hrvL3mZgwXb7AJEZPINzC6mDU3eP5g==
 
-selenium-webdriver@^4.0.0-alpha.1:
-  version "4.0.0-alpha.1"
-  resolved "https://registry.yarnpkg.com/selenium-webdriver/-/selenium-webdriver-4.0.0-alpha.1.tgz#cc93415e21d2dc1dfd85dfc5f6b55f3ac53933b1"
-  integrity sha512-z88rdjHAv3jmTZ7KSGUkTvo4rGzcDGMq0oXWHNIDK96Gs31JKVdu9+FMtT4KBrVoibg8dUicJDok6GnqqttO5Q==
+selenium-webdriver@4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/selenium-webdriver/-/selenium-webdriver-4.1.1.tgz#da083177d811f36614950e809e2982570f67d02e"
+  integrity sha512-Fr9e9LC6zvD6/j7NO8M1M/NVxFX67abHcxDJoP5w2KN/Xb1SyYLjMVPGgD14U2TOiKe4XKHf42OmFw9g2JgCBQ==
   dependencies:
-    jszip "^3.1.3"
-    rimraf "^2.5.4"
-    tmp "0.0.30"
-    xml2js "^0.4.17"
+    jszip "^3.6.0"
+    tmp "^0.2.1"
+    ws ">=7.4.6"
 
 semver-compare@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/semver-compare/-/semver-compare-1.0.0.tgz#0dee216a1c941ab37e9efb1788f6afc5ff5537fc"
   integrity sha1-De4hahyUGrN+nvsXiPavxf9VN/w=
 
+semver-regex@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/semver-regex/-/semver-regex-2.0.0.tgz#a93c2c5844539a770233379107b38c7b4ac9d338"
+  integrity sha512-mUdIBBvdn0PLOeP3TEkMH7HHeUP3GjsXCwKarjv/kGmUFOYg1VqEemKhoQpWMu6X2I8kHeuVdGibLGkVK+/5Qw==
+
+semver-truncate@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/semver-truncate/-/semver-truncate-1.1.2.tgz#57f41de69707a62709a7e0104ba2117109ea47e8"
+  integrity sha1-V/Qd5pcHpicJp+AQS6IRcQnqR+g=
+  dependencies:
+    semver "^5.3.0"
+
 "semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0:
   version "5.6.0"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.6.0.tgz#7e74256fbaa49c75aa7c7a205cc22799cac80004"
@@ -8286,6 +7955,13 @@ semver@7.0.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-7.0.0.tgz#5f3ca35761e47e05b206c6daff2cf814f0316b8e"
   integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==
 
+semver@7.3.5, semver@^7.3.4:
+  version "7.3.5"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
+  integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
+  dependencies:
+    lru-cache "^6.0.0"
+
 semver@^5.6.0:
   version "5.7.1"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
@@ -8296,72 +7972,59 @@ semver@^6.0.0, semver@^6.1.1, semver@^6.1.2, semver@^6.3.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
-semver@^7.2.1, semver@^7.3.2, semver@^7.3.4:
-  version "7.3.5"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
-  integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
+semver@^7.3.2, semver@^7.3.5:
+  version "7.3.7"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f"
+  integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==
   dependencies:
     lru-cache "^6.0.0"
 
-semver@~5.0.1:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.0.3.tgz#77466de589cd5d3c95f138aa78bc569a3cb5d27a"
-  integrity sha1-d0Zt5YnNXTyV8TiqeLxWmjy10no=
-
-serialize-javascript@^1.4.0:
-  version "1.6.1"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-1.6.1.tgz#4d1f697ec49429a847ca6f442a2a755126c4d879"
-  integrity sha512-A5MOagrPFga4YaKQSWHryl7AXvbQkEqpw4NNYMTNYUNV51bA8ABHgYFpqKx+YFFrw59xMV1qGH1R4AgoNIVgCw==
-
-serialize-javascript@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-3.1.0.tgz#8bf3a9170712664ef2561b44b691eafe399214ea"
-  integrity sha512-JIJT1DGiWmIKhzRsG91aS6Ze4sFUrYbltlkg2onR5OrnNM02Kl/hnY/T4FN2omvyeBbQmMJv+K4cPOpGzOTFBg==
+sentence-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/sentence-case/-/sentence-case-3.0.4.tgz#3645a7b8c117c787fde8702056225bb62a45131f"
+  integrity sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg==
   dependencies:
-    randombytes "^2.1.0"
+    no-case "^3.0.4"
+    tslib "^2.0.3"
+    upper-case-first "^2.0.2"
 
-set-blocking@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7"
-  integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc=
+serialize-error@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/serialize-error/-/serialize-error-7.0.1.tgz#f1360b0447f61ffb483ec4157c737fab7d778e18"
+  integrity sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==
+  dependencies:
+    type-fest "^0.13.1"
 
-set-value@^0.4.3:
-  version "0.4.3"
-  resolved "https://registry.yarnpkg.com/set-value/-/set-value-0.4.3.tgz#7db08f9d3d22dc7f78e53af3c3bf4666ecdfccf1"
-  integrity sha1-fbCPnT0i3H945Trzw79GZuzfzPE=
+serialize-error@^8.0.0:
+  version "8.1.0"
+  resolved "https://registry.yarnpkg.com/serialize-error/-/serialize-error-8.1.0.tgz#3a069970c712f78634942ddd50fbbc0eaebe2f67"
+  integrity sha512-3NnuWfM6vBYoy5gZFvHiYsVbafvI9vZv/+jlIigFn4oP4zjNPK3LhcY0xSCgeb1a5L8jO71Mit9LlNoi2UfDDQ==
   dependencies:
-    extend-shallow "^2.0.1"
-    is-extendable "^0.1.1"
-    is-plain-object "^2.0.1"
-    to-object-path "^0.3.0"
+    type-fest "^0.20.2"
 
-set-value@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/set-value/-/set-value-2.0.0.tgz#71ae4a88f0feefbbf52d1ea604f3fb315ebb6274"
-  integrity sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==
+serialize-javascript@6.0.0, serialize-javascript@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.0.tgz#efae5d88f45d7924141da8b5c3a7a7e663fefeb8"
+  integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==
   dependencies:
-    extend-shallow "^2.0.1"
-    is-extendable "^0.1.1"
-    is-plain-object "^2.0.3"
-    split-string "^3.0.1"
+    randombytes "^2.1.0"
 
-setimmediate@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
-  integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
+set-immediate-shim@~1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61"
+  integrity sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=
 
-setprototypeof@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.1.0.tgz#d0bd85536887b6fe7c0d818cb962d9d91c54e656"
-  integrity sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==
+setprototypeof@1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424"
+  integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
 
-sha.js@^2.4.0, sha.js@^2.4.8:
-  version "2.4.11"
-  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
-  integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
+shallow-clone@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
+  integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
   dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
+    kind-of "^6.0.2"
 
 shebang-command@^1.2.0:
   version "1.2.0"
@@ -8387,45 +8050,47 @@ shebang-regex@^3.0.0:
   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
-shelljs@0.7.6:
-  version "0.7.6"
-  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.7.6.tgz#379cccfb56b91c8601e4793356eb5382924de9ad"
-  integrity sha1-N5zM+1a5HIYB5HkzVutTgpJN6a0=
+shelljs@^0.8.5:
+  version "0.8.5"
+  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c"
+  integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==
   dependencies:
     glob "^7.0.0"
     interpret "^1.0.0"
     rechoir "^0.6.2"
 
-shelljs@^0.8.1:
-  version "0.8.3"
-  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.3.tgz#a7f3319520ebf09ee81275b2368adb286659b097"
-  integrity sha512-fc0BKlAWiLpwZljmOvAOTE/gXawtCoNrP5oaY7KIaQbbyHeQVg01pSEuEGvGh3HEdBU4baCD7wQBwADmM/7f7A==
+side-channel@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf"
+  integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==
   dependencies:
-    glob "^7.0.0"
-    interpret "^1.0.0"
-    rechoir "^0.6.2"
+    call-bind "^1.0.0"
+    get-intrinsic "^1.0.2"
+    object-inspect "^1.9.0"
 
 signal-exit@^3.0.0, signal-exit@^3.0.2:
   version "3.0.2"
   resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.2.tgz#b5fdc08f1287ea1178628e415e25132b73646c6d"
   integrity sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=
 
-simple-git@^1.85.0:
-  version "1.107.0"
-  resolved "https://registry.yarnpkg.com/simple-git/-/simple-git-1.107.0.tgz#12cffaf261c14d6f450f7fdb86c21ccee968b383"
-  integrity sha512-t4OK1JRlp4ayKRfcW6owrWcRVLyHRUlhGd0uN6ZZTqfDq8a5XpcUdOKiGRNobHEuMtNqzp0vcJNvhYWwh5PsQA==
-  dependencies:
-    debug "^4.0.1"
+signal-exit@^3.0.3:
+  version "3.0.7"
+  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
+  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
 
 slash@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
   integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
 
-slice-ansi@0.0.4:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35"
-  integrity sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=
+slice-ansi@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-3.0.0.tgz#31ddc10930a1b7e0b67b08c96c2f49b77a789787"
+  integrity sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==
+  dependencies:
+    ansi-styles "^4.0.0"
+    astral-regex "^2.0.0"
+    is-fullwidth-code-point "^3.0.0"
 
 slice-ansi@^4.0.0:
   version "4.0.0"
@@ -8436,110 +8101,70 @@ slice-ansi@^4.0.0:
     astral-regex "^2.0.0"
     is-fullwidth-code-point "^3.0.0"
 
-smart-buffer@^1.0.13:
-  version "1.1.15"
-  resolved "https://registry.yarnpkg.com/smart-buffer/-/smart-buffer-1.1.15.tgz#7f114b5b65fab3e2a35aa775bb12f0d1c649bf16"
-  integrity sha1-fxFLW2X6s+KjWqd1uxLw0cZJvxY=
-
-snapdragon-node@^2.0.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-node/-/snapdragon-node-2.1.1.tgz#6c175f86ff14bdb0724563e8f3c1b021a286853b"
-  integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==
+slice-ansi@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-5.0.0.tgz#b73063c57aa96f9cd881654b15294d95d285c42a"
+  integrity sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==
   dependencies:
-    define-property "^1.0.0"
-    isobject "^3.0.0"
-    snapdragon-util "^3.0.1"
+    ansi-styles "^6.0.0"
+    is-fullwidth-code-point "^4.0.0"
 
-snapdragon-util@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/snapdragon-util/-/snapdragon-util-3.0.1.tgz#f956479486f2acd79700693f6f7b805e45ab56e2"
-  integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==
+snake-case@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz#4f2bbd568e9935abdfd593f34c691dadb49c452c"
+  integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==
   dependencies:
-    kind-of "^3.2.0"
+    dot-case "^3.0.4"
+    tslib "^2.0.3"
 
-snapdragon@^0.8.1:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/snapdragon/-/snapdragon-0.8.2.tgz#64922e7c565b0e14204ba1aa7d6964278d25182d"
-  integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==
-  dependencies:
-    base "^0.11.1"
-    debug "^2.2.0"
-    define-property "^0.2.5"
-    extend-shallow "^2.0.1"
-    map-cache "^0.2.2"
-    source-map "^0.5.6"
-    source-map-resolve "^0.5.0"
-    use "^3.1.0"
-
-socket.io-adapter@~1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/socket.io-adapter/-/socket.io-adapter-1.1.1.tgz#2a805e8a14d6372124dd9159ad4502f8cb07f06b"
-  integrity sha1-KoBeihTWNyEk3ZFZrUUC+MsH8Gs=
+socket.io-adapter@~2.4.0:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/socket.io-adapter/-/socket.io-adapter-2.4.0.tgz#b50a4a9ecdd00c34d4c8c808224daa1a786152a6"
+  integrity sha512-W4N+o69rkMEGVuk2D/cvca3uYsvGlMwsySWV447y99gUPghxq42BxqLNMndb+a1mm/5/7NeXVQS7RLa2XyXvYg==
 
-socket.io-client@2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/socket.io-client/-/socket.io-client-2.1.1.tgz#dcb38103436ab4578ddb026638ae2f21b623671f"
-  integrity sha512-jxnFyhAuFxYfjqIgduQlhzqTcOEQSn+OHKVfAxWaNWa7ecP7xSNk2Dx/3UEsDcY7NcFafxvNvKPmmO7HTwTxGQ==
-  dependencies:
-    backo2 "1.0.2"
-    base64-arraybuffer "0.1.5"
-    component-bind "1.0.0"
-    component-emitter "1.2.1"
-    debug "~3.1.0"
-    engine.io-client "~3.2.0"
-    has-binary2 "~1.0.2"
-    has-cors "1.1.0"
-    indexof "0.0.1"
-    object-component "0.0.3"
-    parseqs "0.0.5"
-    parseuri "0.0.5"
-    socket.io-parser "~3.2.0"
-    to-array "0.1.4"
-
-socket.io-parser@~3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/socket.io-parser/-/socket.io-parser-3.2.0.tgz#e7c6228b6aa1f814e6148aea325b51aa9499e077"
-  integrity sha512-FYiBx7rc/KORMJlgsXysflWx/RIvtqZbyGLlHZvjfmPTPeuD/I8MaW7cfFrj5tRltICJdgwflhfZ3NVVbVLFQA==
+socket.io-parser@~4.0.4:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/socket.io-parser/-/socket.io-parser-4.0.4.tgz#9ea21b0d61508d18196ef04a2c6b9ab630f4c2b0"
+  integrity sha512-t+b0SS+IxG7Rxzda2EVvyBZbvFPBCjJoyHuE0P//7OAsN23GItzDRdWa6ALxZI/8R5ygK7jAR6t028/z+7295g==
   dependencies:
-    component-emitter "1.2.1"
-    debug "~3.1.0"
-    isarray "2.0.1"
+    "@types/component-emitter" "^1.2.10"
+    component-emitter "~1.3.0"
+    debug "~4.3.1"
 
-socket.io@2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/socket.io/-/socket.io-2.1.1.tgz#a069c5feabee3e6b214a75b40ce0652e1cfb9980"
-  integrity sha512-rORqq9c+7W0DAK3cleWNSyfv/qKXV99hV4tZe+gGLfBECw3XEhBy7x85F3wypA9688LKjtwO9pX9L33/xQI8yA==
+socket.io@^4.4.1:
+  version "4.5.0"
+  resolved "https://registry.yarnpkg.com/socket.io/-/socket.io-4.5.0.tgz#78ae2e84784c29267086a416620c18ef95b37186"
+  integrity sha512-slTYqU2jCgMjXwresG8grhUi/cC6GjzmcfqArzaH3BN/9I/42eZk9yamNvZJdBfTubkjEdKAKs12NEztId+bUA==
   dependencies:
-    debug "~3.1.0"
-    engine.io "~3.2.0"
-    has-binary2 "~1.0.2"
-    socket.io-adapter "~1.1.0"
-    socket.io-client "2.1.1"
-    socket.io-parser "~3.2.0"
+    accepts "~1.3.4"
+    base64id "~2.0.0"
+    debug "~4.3.2"
+    engine.io "~6.2.0"
+    socket.io-adapter "~2.4.0"
+    socket.io-parser "~4.0.4"
 
-socks-proxy-agent@2:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/socks-proxy-agent/-/socks-proxy-agent-2.1.1.tgz#86ebb07193258637870e13b7bd99f26c663df3d3"
-  integrity sha512-sFtmYqdUK5dAMh85H0LEVFUCO7OhJJe1/z2x/Z6mxp3s7/QPf1RkZmpZy+BpuU0bEjcV9npqKjq9Y3kwFUjnxw==
+sort-keys-length@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/sort-keys-length/-/sort-keys-length-1.0.1.tgz#9cb6f4f4e9e48155a6aa0671edd336ff1479a188"
+  integrity sha1-nLb09OnkgVWmqgZx7dM2/xR5oYg=
   dependencies:
-    agent-base "2"
-    extend "3"
-    socks "~1.1.5"
+    sort-keys "^1.0.0"
 
-socks@~1.1.5:
-  version "1.1.10"
-  resolved "https://registry.yarnpkg.com/socks/-/socks-1.1.10.tgz#5b8b7fc7c8f341c53ed056e929b7bf4de8ba7b5a"
-  integrity sha1-W4t/x8jzQcU+0FbpKbe/Tei6e1o=
+sort-keys@^1.0.0:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/sort-keys/-/sort-keys-1.1.2.tgz#441b6d4d346798f1b4e49e8920adfba0e543f9ad"
+  integrity sha1-RBttTTRnmPG05J6JIK37oOVD+a0=
   dependencies:
-    ip "^1.1.4"
-    smart-buffer "^1.0.13"
+    is-plain-obj "^1.0.0"
 
-source-list-map@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/source-list-map/-/source-list-map-2.0.1.tgz#3993bd873bfc48479cca9ea3a547835c7c154b34"
-  integrity sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==
+sort-keys@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/sort-keys/-/sort-keys-2.0.0.tgz#658535584861ec97d730d6cf41822e1f56684128"
+  integrity sha1-ZYU1WEhh7JfXMNbPQYIuH1ZoQSg=
+  dependencies:
+    is-plain-obj "^1.0.0"
 
-source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
+source-map-resolve@^0.5.2:
   version "0.5.2"
   resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.2.tgz#72e2cc34095543e43b2c62b2c4c10d4a9054f259"
   integrity sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==
@@ -8550,7 +8175,7 @@ source-map-resolve@^0.5.0, source-map-resolve@^0.5.2:
     source-map-url "^0.4.0"
     urix "^0.1.0"
 
-source-map-support@^0.5.16, source-map-support@^0.5.17, source-map-support@~0.5.19:
+source-map-support@^0.5.16:
   version "0.5.19"
   resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
   integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
@@ -8558,10 +8183,10 @@ source-map-support@^0.5.16, source-map-support@^0.5.17, source-map-support@~0.5.
     buffer-from "^1.0.0"
     source-map "^0.6.0"
 
-source-map-support@~0.5.6:
-  version "0.5.9"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.9.tgz#41bc953b2534267ea2d605bccfa7bfa3111ced5f"
-  integrity sha512-gR6Rw4MvUlYy83vP0vxoVNzM6t8MUXqNuRsuBmBHQDu1Fh6X015FrLdgoDKcNdkwGubozq0P4N0Q37UyFVr1EA==
+source-map-support@~0.5.20:
+  version "0.5.21"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
+  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
   dependencies:
     buffer-from "^1.0.0"
     source-map "^0.6.0"
@@ -8571,7 +8196,7 @@ source-map-url@^0.4.0:
   resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"
   integrity sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=
 
-source-map@^0.5.0, source-map@^0.5.1, source-map@^0.5.6:
+source-map@^0.5.0:
   version "0.5.7"
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
@@ -8581,31 +8206,18 @@ source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
-source-map@~0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.2.0.tgz#dab73fbcfc2ba819b4de03bd6f6eaa48164b3f9d"
-  integrity sha1-2rc/vPwrqBm03gO9b26qSBZLP50=
+source-map@~0.8.0-beta.0:
+  version "0.8.0-beta.0"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.8.0-beta.0.tgz#d4c1bb42c3f7ee925f005927ba10709e0d1d1f11"
+  integrity sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==
   dependencies:
-    amdefine ">=0.0.4"
-
-source-map@~0.7.2:
-  version "0.7.3"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
-  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
+    whatwg-url "^7.0.0"
 
 sourcemap-codec@^1.4.4:
   version "1.4.8"
   resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
   integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
 
-spawn-sync@^1.0.15:
-  version "1.0.15"
-  resolved "https://registry.yarnpkg.com/spawn-sync/-/spawn-sync-1.0.15.tgz#b00799557eb7fb0c8376c29d44e8a1ea67e57476"
-  integrity sha1-sAeZVX63+wyDdsKdROih6mfldHY=
-  dependencies:
-    concat-stream "^1.4.7"
-    os-shim "^0.1.2"
-
 spdx-correct@^3.0.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.0.tgz#fb83e504445268f154b074e218c87c003cd31df4"
@@ -8632,19 +8244,12 @@ spdx-license-ids@^3.0.0:
   resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.3.tgz#81c0ce8f21474756148bbb5f3bfc0f36bf15d76e"
   integrity sha512-uBIcIl3Ih6Phe3XHK1NqboJLdGfwr1UN3k6wSD1dZpmPsIkb8AGNbZYJ1fOBk834+Gxy8rpfDxrS6XLEMZMY2g==
 
-split-string@^3.0.1, split-string@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/split-string/-/split-string-3.1.0.tgz#7cb09dda3a86585705c64b39a6466038682e8fe2"
-  integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==
-  dependencies:
-    extend-shallow "^3.0.0"
-
-split2@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/split2/-/split2-2.2.0.tgz#186b2575bcf83e85b7d18465756238ee4ee42493"
-  integrity sha512-RAb22TG39LhI31MbreBgIuKiIKhVsawfTgEGqKHTK87aG+ul/PB8Sqoi3I7kVdRWiCfrKxK3uo4/YUkpNvhPbw==
+split2@^3.0.0:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f"
+  integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==
   dependencies:
-    through2 "^2.0.2"
+    readable-stream "^3.0.0"
 
 split@^1.0.0:
   version "1.0.1"
@@ -8653,6 +8258,11 @@ split@^1.0.0:
   dependencies:
     through "2"
 
+sprintf-js@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.1.2.tgz#da1765262bf8c0f571749f2ad6c26300207ae673"
+  integrity sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==
+
 sprintf-js@~1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
@@ -8673,93 +8283,55 @@ sshpk@^1.7.0:
     safer-buffer "^2.0.2"
     tweetnacl "~0.14.0"
 
-ssri@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/ssri/-/ssri-6.0.1.tgz#2a3c41b28dd45b62b63676ecb74001265ae9edd8"
-  integrity sha512-3Wge10hNcT1Kur4PDFwEieXSCMCJs/7WvSACcrMYrNp+b8kDL1/0wJch5Ni2WrtwEa2IO8OsVfeKIciKCDx/QA==
+stacktrace-parser@0.1.10:
+  version "0.1.10"
+  resolved "https://registry.yarnpkg.com/stacktrace-parser/-/stacktrace-parser-0.1.10.tgz#29fb0cae4e0d0b85155879402857a1639eb6051a"
+  integrity sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==
   dependencies:
-    figgy-pudding "^3.5.1"
-
-staged-git-files@1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/staged-git-files/-/staged-git-files-1.1.2.tgz#4326d33886dc9ecfa29a6193bf511ba90a46454b"
-  integrity sha512-0Eyrk6uXW6tg9PYkhi/V/J4zHp33aNyi2hOCmhFLqLTIhbgqWn5jlSzI+IU0VqrZq6+DbHcabQl/WP6P3BG0QA==
+    type-fest "^0.7.1"
 
-static-extend@^0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6"
-  integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=
-  dependencies:
-    define-property "^0.2.5"
-    object-copy "^0.1.0"
+statuses@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63"
+  integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
 
-"statuses@>= 1.4.0 < 2":
+statuses@~1.5.0:
   version "1.5.0"
   resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
   integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=
 
-statuses@~1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.3.1.tgz#faf51b9eb74aaef3b3acf4ad5f61abf24cb7b93e"
-  integrity sha1-+vUbnrdKrvOzrPStX2Gr8ky3uT4=
-
-stream-browserify@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-2.0.1.tgz#66266ee5f9bdb9940a4e4514cafb43bb71e5c9db"
-  integrity sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=
-  dependencies:
-    inherits "~2.0.1"
-    readable-stream "^2.0.2"
-
-stream-each@^1.1.0:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/stream-each/-/stream-each-1.2.3.tgz#ebe27a0c389b04fbcc233642952e10731afa9bae"
-  integrity sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==
+stream-events@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/stream-events/-/stream-events-1.0.5.tgz#bbc898ec4df33a4902d892333d47da9bf1c406d5"
+  integrity sha512-E1GUzBSgvct8Jsb3v2X15pjzN1tYebtbLaMg+eBOUOAxgbLoSbT2NS91ckc5lJD1KfLjId+jXJRgo0qnV5Nerg==
   dependencies:
-    end-of-stream "^1.1.0"
-    stream-shift "^1.0.0"
+    stubs "^3.0.0"
 
-stream-http@^2.7.2:
-  version "2.8.3"
-  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-2.8.3.tgz#b2d242469288a5a27ec4fe8933acf623de6514fc"
-  integrity sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==
+streamroller@^3.0.8:
+  version "3.0.8"
+  resolved "https://registry.yarnpkg.com/streamroller/-/streamroller-3.0.8.tgz#84b190e4080ee311ca1ebe0444e30ac8eedd028d"
+  integrity sha512-VI+ni3czbFZrd1MrlybxykWZ8sMDCMtTU7YJyhgb9M5X6d1DDxLdJr+gSnmRpXPMnIWxWKMaAE8K0WumBp3lDg==
   dependencies:
-    builtin-status-codes "^3.0.0"
-    inherits "^2.0.1"
-    readable-stream "^2.3.6"
-    to-arraybuffer "^1.0.0"
-    xtend "^4.0.0"
-
-stream-shift@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/stream-shift/-/stream-shift-1.0.0.tgz#d5c752825e5367e786f78e18e445ea223a155952"
-  integrity sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=
+    date-format "^4.0.9"
+    debug "^4.3.4"
+    fs-extra "^10.1.0"
 
-streamroller@0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/streamroller/-/streamroller-0.7.0.tgz#a1d1b7cf83d39afb0d63049a5acbf93493bdf64b"
-  integrity sha512-WREzfy0r0zUqp3lGO096wRuUp7ho1X6uo/7DJfTlEi0Iv/4gT7YHqXDjKC2ioVGBZtE8QzsQD9nx1nIuoZ57jQ==
-  dependencies:
-    date-format "^1.2.0"
-    debug "^3.1.0"
-    mkdirp "^0.5.1"
-    readable-stream "^2.3.0"
+strict-uri-encode@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"
+  integrity sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=
 
-string-argv@^0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.0.2.tgz#dac30408690c21f3c3630a3ff3a05877bdcbd736"
-  integrity sha1-2sMECGkMIfPDYwo/86BYd73L1zY=
+string-argv@^0.3.1:
+  version "0.3.1"
+  resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.3.1.tgz#95e2fbec0427ae19184935f816d74aaa4c5c19da"
+  integrity sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==
 
-string-width@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3"
-  integrity sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=
-  dependencies:
-    code-point-at "^1.0.0"
-    is-fullwidth-code-point "^1.0.0"
-    strip-ansi "^3.0.0"
+string-natural-compare@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/string-natural-compare/-/string-natural-compare-3.0.1.tgz#7a42d58474454963759e8e8b7ae63d71c1e7fdf4"
+  integrity sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw==
 
-"string-width@^1.0.2 || 2", string-width@^2.0.0, string-width@^2.1.1:
+string-width@^2.1.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
   integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
@@ -8767,6 +8339,15 @@ string-width@^1.0.1:
     is-fullwidth-code-point "^2.0.0"
     strip-ansi "^4.0.0"
 
+string-width@^4.0.0, string-width@^4.2.2, string-width@^4.2.3:
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
+  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
+  dependencies:
+    emoji-regex "^8.0.0"
+    is-fullwidth-code-point "^3.0.0"
+    strip-ansi "^6.0.1"
+
 string-width@^4.1.0, string-width@^4.2.0:
   version "4.2.2"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5"
@@ -8776,17 +8357,21 @@ string-width@^4.1.0, string-width@^4.2.0:
     is-fullwidth-code-point "^3.0.0"
     strip-ansi "^6.0.0"
 
-string_decoder@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.2.0.tgz#fe86e738b19544afe70469243b2a1ee9240eae8d"
-  integrity sha512-6YqyX6ZWEYguAxgZzHGL7SsCeGx3V2TtOTqZz1xSTSWnqsbWwbptafNyvf/ACquZUXV3DANr5BDIwNYe1mN42w==
+string-width@^5.0.0:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
+  integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
   dependencies:
-    safe-buffer "~5.1.0"
+    eastasianwidth "^0.2.0"
+    emoji-regex "^9.2.2"
+    strip-ansi "^7.0.1"
 
-string_decoder@~0.10.x:
-  version "0.10.31"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94"
-  integrity sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=
+string_decoder@^1.1.1:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
+  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
+  dependencies:
+    safe-buffer "~5.2.0"
 
 string_decoder@~1.1.1:
   version "1.1.1"
@@ -8795,16 +8380,14 @@ string_decoder@~1.1.1:
   dependencies:
     safe-buffer "~5.1.0"
 
-stringify-object@^3.2.2:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/stringify-object/-/stringify-object-3.3.0.tgz#703065aefca19300d3ce88af4f5b3956d7556629"
-  integrity sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==
+strip-ansi@6.0.1, strip-ansi@^6.0.1:
+  version "6.0.1"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
+  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
   dependencies:
-    get-own-enumerable-property-symbols "^3.0.0"
-    is-obj "^1.0.1"
-    is-regexp "^1.0.0"
+    ansi-regex "^5.0.1"
 
-strip-ansi@^3.0.0, strip-ansi@^3.0.1:
+strip-ansi@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
   integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=
@@ -8818,6 +8401,13 @@ strip-ansi@^4.0.0:
   dependencies:
     ansi-regex "^3.0.0"
 
+strip-ansi@^5.1.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae"
+  integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==
+  dependencies:
+    ansi-regex "^4.1.0"
+
 strip-ansi@^6.0.0:
   version "6.0.0"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.0.tgz#0b1571dd7669ccd4f3e06e14ef1eed26225ae532"
@@ -8825,64 +8415,86 @@ strip-ansi@^6.0.0:
   dependencies:
     ansi-regex "^5.0.0"
 
-strip-bom@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
-  integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=
+strip-ansi@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.0.1.tgz#61740a08ce36b61e50e65653f07060d000975fb2"
+  integrity sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw==
   dependencies:
-    is-utf8 "^0.2.0"
+    ansi-regex "^6.0.1"
+
+strip-bom@4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878"
+  integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==
 
 strip-bom@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
   integrity sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=
 
+strip-dirs@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/strip-dirs/-/strip-dirs-2.1.0.tgz#4987736264fc344cf20f6c34aca9d13d1d4ed6c5"
+  integrity sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==
+  dependencies:
+    is-natural-number "^4.0.1"
+
 strip-eof@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf"
   integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=
 
-strip-indent@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-1.0.1.tgz#0c7962a6adefa7bbd4ac366460a638552ae1a0a2"
-  integrity sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI=
-  dependencies:
-    get-stdin "^4.0.1"
+strip-final-newline@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
+  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
 
 strip-indent@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
   integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
 
-strip-json-comments@2.0.1, strip-json-comments@~2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
-  integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo=
+strip-indent@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
+  integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==
+  dependencies:
+    min-indent "^1.0.0"
+
+strip-json-comments@3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.0.1.tgz#85713975a91fb87bf1b305cca77395e40d2a64a7"
+  integrity sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==
 
-strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
+strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
-supports-color@3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.1.2.tgz#72a262894d9d408b956ca05ff37b2ed8a6e2a2d5"
-  integrity sha1-cqJiiU2dQIuVbKBf83su2KbiotU=
+strip-outer@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/strip-outer/-/strip-outer-1.0.1.tgz#b2fd2abf6604b9d1e6013057195df836b8a9d631"
+  integrity sha512-k55yxKHwaXnpYGsOzg4Vl8+tDrWylxDEpknGjhTiZB8dFRU5rTo9CAzeycivxV3s+zlTKwrs6WxMxR95n26kwg==
+  dependencies:
+    escape-string-regexp "^1.0.2"
+
+stubs@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/stubs/-/stubs-3.0.0.tgz#e8d2ba1fa9c90570303c030b6900f7d5f89abe5b"
+  integrity sha1-6NK6H6nJBXAwPAMLaQD31fiavls=
+
+supports-color@8.1.1, supports-color@^8.0.0:
+  version "8.1.1"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
+  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
   dependencies:
-    has-flag "^1.0.0"
+    has-flag "^4.0.0"
 
 supports-color@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
   integrity sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=
 
-supports-color@^3.1.0:
-  version "3.2.3"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-3.2.3.tgz#65ac0504b3954171d8a64946b2ae3cbb8a5f54f6"
-  integrity sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=
-  dependencies:
-    has-flag "^1.0.0"
-
 supports-color@^5.3.0:
   version "5.5.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
@@ -8897,43 +8509,54 @@ supports-color@^7.1.0:
   dependencies:
     has-flag "^4.0.0"
 
-symbol-observable@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-1.2.0.tgz#c22688aed4eab3cdc2dfeacbb561660560a00804"
-  integrity sha512-e900nM8RRtGhlV36KGEU9k65K3mPb1WV70OdjfxlG2EAuM1noi/E/BaW/uMhL7bPEssK8QV57vN3esixjUvcXQ==
-
-table@^6.0.4:
-  version "6.0.9"
-  resolved "https://registry.yarnpkg.com/table/-/table-6.0.9.tgz#790a12bf1e09b87b30e60419bafd6a1fd85536fb"
-  integrity sha512-F3cLs9a3hL1Z7N4+EkSscsel3z55XT950AvB05bwayrNg5T1/gykXtigioTAjbltvbMSJvvhFCbnf6mX+ntnJQ==
-  dependencies:
-    ajv "^8.0.1"
-    is-boolean-object "^1.1.0"
-    is-number-object "^1.0.4"
-    is-string "^1.0.5"
-    lodash.clonedeep "^4.5.0"
-    lodash.flatten "^4.4.0"
-    lodash.truncate "^4.4.2"
-    slice-ansi "^4.0.0"
-    string-width "^4.2.0"
+supports-color@^9.2.1:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-9.2.2.tgz#502acaf82f2b7ee78eb7c83dcac0f89694e5a7bb"
+  integrity sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==
 
-tapable@^1.0.0, tapable@^1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/tapable/-/tapable-1.1.1.tgz#4d297923c5a72a42360de2ab52dadfaaec00018e"
-  integrity sha512-9I2ydhj8Z9veORCw5PRm4u9uebCn0mcCa6scWoNcbZ6dAtoo2618u9UUzxgmsCOreJpqDDuv61LvwofW7hLcBA==
+supports-preserve-symlinks-flag@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
+  integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
+
+tapable@^2.1.1, tapable@^2.2.0:
+  version "2.2.1"
+  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
+  integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
 
-tar@^4:
-  version "4.4.8"
-  resolved "https://registry.yarnpkg.com/tar/-/tar-4.4.8.tgz#b19eec3fde2a96e64666df9fdb40c5ca1bc3747d"
-  integrity sha512-LzHF64s5chPQQS0IYBn9IN5h3i98c12bo4NCO7e0sGM2llXQ3p2FGC5sdENN4cTW48O915Sh+x+EXx7XW96xYQ==
+tar-fs@2.1.1, tar-fs@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-2.1.1.tgz#489a15ab85f1f0befabb370b7de4f9eb5cbe8784"
+  integrity sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==
   dependencies:
     chownr "^1.1.1"
-    fs-minipass "^1.2.5"
-    minipass "^2.3.4"
-    minizlib "^1.1.1"
-    mkdirp "^0.5.0"
-    safe-buffer "^5.1.2"
-    yallist "^3.0.2"
+    mkdirp-classic "^0.5.2"
+    pump "^3.0.0"
+    tar-stream "^2.1.4"
+
+tar-stream@^1.5.2:
+  version "1.6.2"
+  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-1.6.2.tgz#8ea55dab37972253d9a9af90fdcd559ae435c555"
+  integrity sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==
+  dependencies:
+    bl "^1.0.0"
+    buffer-alloc "^1.2.0"
+    end-of-stream "^1.0.0"
+    fs-constants "^1.0.0"
+    readable-stream "^2.3.0"
+    to-buffer "^1.1.1"
+    xtend "^4.0.0"
+
+tar-stream@^2.1.4, tar-stream@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287"
+  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
+  dependencies:
+    bl "^4.0.3"
+    end-of-stream "^1.4.1"
+    fs-constants "^1.0.0"
+    inherits "^2.0.3"
+    readable-stream "^3.1.1"
 
 tcp-port-used@^1.0.1:
   version "1.0.1"
@@ -8943,47 +8566,46 @@ tcp-port-used@^1.0.1:
     debug "4.1.0"
     is2 "2.0.1"
 
-terser-webpack-plugin@^1.1.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-1.2.1.tgz#7545da9ae5f4f9ae6a0ac961eb46f5e7c845cc26"
-  integrity sha512-GGSt+gbT0oKcMDmPx4SRSfJPE1XaN3kQRWG4ghxKQw9cn5G9x6aCKSsgYdvyM0na9NJ4Drv0RG6jbBByZ5CMjw==
+teeny-request@7.1.1:
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/teeny-request/-/teeny-request-7.1.1.tgz#2b0d156f4a8ad81de44303302ba8d7f1f05e20e6"
+  integrity sha512-iwY6rkW5DDGq8hE2YgNQlKbptYpY5Nn2xecjQiNjOXWbKzPGUfmeUBCSQbbr306d7Z7U2N0TPl+/SwYRfua1Dg==
   dependencies:
-    cacache "^11.0.2"
-    find-cache-dir "^2.0.0"
-    schema-utils "^1.0.0"
-    serialize-javascript "^1.4.0"
-    source-map "^0.6.1"
-    terser "^3.8.1"
-    webpack-sources "^1.1.0"
-    worker-farm "^1.5.2"
+    http-proxy-agent "^4.0.0"
+    https-proxy-agent "^5.0.0"
+    node-fetch "^2.6.1"
+    stream-events "^1.0.5"
+    uuid "^8.0.0"
 
-terser@^3.8.1:
-  version "3.14.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-3.14.1.tgz#cc4764014af570bc79c79742358bd46926018a32"
-  integrity sha512-NSo3E99QDbYSMeJaEk9YW2lTg3qS9V0aKGlb+PlOrei1X02r1wSBHCNX/O+yeTRFSWPKPIGj6MqvvdqV4rnVGw==
+terser-webpack-plugin@^5.1.3:
+  version "5.3.1"
+  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.3.1.tgz#0320dcc270ad5372c1e8993fabbd927929773e54"
+  integrity sha512-GvlZdT6wPQKbDNW/GDQzZFg/j4vKU96yl2q6mcUkzKOgW4gwf1Z8cZToUCrz31XHlPWH8MVb1r2tFtdDtTGJ7g==
   dependencies:
-    commander "~2.17.1"
-    source-map "~0.6.1"
-    source-map-support "~0.5.6"
+    jest-worker "^27.4.5"
+    schema-utils "^3.1.1"
+    serialize-javascript "^6.0.0"
+    source-map "^0.6.1"
+    terser "^5.7.2"
 
-terser@^5.6.1:
-  version "5.6.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-5.6.1.tgz#a48eeac5300c0a09b36854bf90d9c26fb201973c"
-  integrity sha512-yv9YLFQQ+3ZqgWCUk+pvNJwgUTdlIxUk1WTN+RnaFJe2L7ipG2csPT0ra2XRm7Cs8cxN7QXmK1rFzEwYEQkzXw==
+terser@^5.13.1, terser@^5.7.2:
+  version "5.13.1"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-5.13.1.tgz#66332cdc5a01b04a224c9fad449fc1a18eaa1799"
+  integrity sha512-hn4WKOfwnwbYfe48NgrQjqNOH9jzLqRcIfbYytOXCOv46LBfWr9bDS17MQqOi+BWGD0sJK3Sj5NC/gJjiojaoA==
   dependencies:
+    acorn "^8.5.0"
     commander "^2.20.0"
-    source-map "~0.7.2"
-    source-map-support "~0.5.19"
+    source-map "~0.8.0-beta.0"
+    source-map-support "~0.5.20"
 
-test-exclude@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-5.0.0.tgz#cdce7cece785e0e829cd5c2b27baf18bc583cfb7"
-  integrity sha512-bO3Lj5+qFa9YLfYW2ZcXMOV1pmQvw+KS/DpjqhyX6Y6UZ8zstpZJ+mA2ERkXfpOqhxsJlQiLeVXD3Smsrs6oLw==
+test-exclude@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e"
+  integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==
   dependencies:
-    arrify "^1.0.1"
+    "@istanbuljs/schema" "^0.1.2"
+    glob "^7.1.4"
     minimatch "^3.0.4"
-    read-pkg-up "^4.0.0"
-    require-main-filename "^1.0.1"
 
 text-extensions@^1.0.0:
   version "1.9.0"
@@ -9000,7 +8622,7 @@ throttleit@^1.0.0:
   resolved "https://registry.yarnpkg.com/throttleit/-/throttleit-1.0.0.tgz#9e785836daf46743145a5984b6268d828528ac6c"
   integrity sha1-nnhYNtr0Z0MUWlmEtiaNgoUorGw=
 
-through2@^2.0.0, through2@^2.0.2:
+through2@^2.0.0:
   version "2.0.5"
   resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
   integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
@@ -9008,53 +8630,41 @@ through2@^2.0.0, through2@^2.0.2:
     readable-stream "~2.3.6"
     xtend "~4.0.1"
 
-through@2, "through@>=2.2.7 <3", through@^2.3.6:
+through2@^4.0.0:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764"
+  integrity sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==
+  dependencies:
+    readable-stream "3"
+
+through@2, "through@>=2.2.7 <3", through@^2.3.6, through@^2.3.8:
   version "2.3.8"
   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
   integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=
 
-thunkify@~2.1.1:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/thunkify/-/thunkify-2.1.2.tgz#faa0e9d230c51acc95ca13a361ac05ca7e04553d"
-  integrity sha1-+qDp0jDFGsyVyhOjYawFyn4EVT0=
-
-timers-browserify@^2.0.4:
-  version "2.0.10"
-  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.10.tgz#1d28e3d2aadf1d5a5996c4e9f95601cd053480ae"
-  integrity sha512-YvC1SV1XdOUaL6gx5CoGroT3Gu49pK9+TZ38ErPldOWW4j49GI1HKs9DV+KGq/w6y+LZ72W1c8cKz2vzY+qpzg==
-  dependencies:
-    setimmediate "^1.0.4"
-
-tmp@0.0.30:
-  version "0.0.30"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.30.tgz#72419d4a8be7d6ce75148fd8b324e593a711c2ed"
-  integrity sha1-ckGdSovn1s51FI/YsyTlk6cRwu0=
-  dependencies:
-    os-tmpdir "~1.0.1"
+timed-out@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f"
+  integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=
 
-tmp@0.0.33, tmp@0.0.x, tmp@^0.0.33:
+tmp@^0.0.33:
   version "0.0.33"
   resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
   integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
   dependencies:
     os-tmpdir "~1.0.2"
 
-tmp@^0.0.29:
-  version "0.0.29"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.29.tgz#f25125ff0dd9da3ccb0c2dd371ee1288bb9128c0"
-  integrity sha1-8lEl/w3Z2jzLDC3Tce4SiLuRKMA=
+tmp@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14"
+  integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==
   dependencies:
-    os-tmpdir "~1.0.1"
-
-to-array@0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/to-array/-/to-array-0.1.4.tgz#17e6c11f73dd4f3d74cda7a4ff3238e9ad9bf890"
-  integrity sha1-F+bBH3PdTz10zaek/zI46a2b+JA=
+    rimraf "^3.0.0"
 
-to-arraybuffer@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz#7d229b1fcc637e466ca081180836a7aabff83f43"
-  integrity sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=
+to-buffer@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/to-buffer/-/to-buffer-1.1.1.tgz#493bd48f62d7c43fcded313a03dcadb2e1213a80"
+  integrity sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==
 
 to-fast-properties@^1.0.3:
   version "1.0.3"
@@ -9066,21 +8676,6 @@ to-fast-properties@^2.0.0:
   resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
   integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=
 
-to-object-path@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af"
-  integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=
-  dependencies:
-    kind-of "^3.0.2"
-
-to-regex-range@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38"
-  integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=
-  dependencies:
-    is-number "^3.0.0"
-    repeat-string "^1.6.1"
-
 to-regex-range@^5.0.1:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
@@ -9088,15 +8683,10 @@ to-regex-range@^5.0.1:
   dependencies:
     is-number "^7.0.0"
 
-to-regex@^3.0.1, to-regex@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/to-regex/-/to-regex-3.0.2.tgz#13cfdd9b336552f30b51f33a8ae1b42a7a7599ce"
-  integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==
-  dependencies:
-    define-property "^2.0.2"
-    extend-shallow "^3.0.2"
-    regex-not "^1.0.2"
-    safe-regex "^1.1.0"
+toidentifier@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35"
+  integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==
 
 tough-cookie@~2.4.3:
   version "2.4.3"
@@ -9106,54 +8696,59 @@ tough-cookie@~2.4.3:
     psl "^1.1.24"
     punycode "^1.4.1"
 
-trim-newlines@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-1.0.0.tgz#5887966bb582a4503a41eb524f7d35011815a613"
-  integrity sha1-WIeWa7WCpFA6QetST301ARgVphM=
+tr46@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/tr46/-/tr46-1.0.1.tgz#a8b13fd6bfd2489519674ccde55ba3693b706d09"
+  integrity sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=
+  dependencies:
+    punycode "^2.1.0"
 
-trim-newlines@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-2.0.0.tgz#b403d0b91be50c331dfc4b82eeceb22c3de16d20"
-  integrity sha1-tAPQuRvlDDMd/EuC7s6yLD3hbSA=
+tr46@~0.0.3:
+  version "0.0.3"
+  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
+  integrity sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=
 
-trim-off-newlines@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz#9f9ba9d9efa8764c387698bcbfeb2c848f11adb3"
-  integrity sha1-n5up2e+odkw4dpi8v+sshI8RrbM=
+trim-newlines@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144"
+  integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==
 
-trim-right@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003"
-  integrity sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=
+trim-repeated@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/trim-repeated/-/trim-repeated-1.0.0.tgz#e3646a2ea4e891312bf7eace6cfb05380bc01c21"
+  integrity sha1-42RqLqTokTEr9+rObPsFOAvAHCE=
+  dependencies:
+    escape-string-regexp "^1.0.2"
 
-ts-loader@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-8.1.0.tgz#d6292487df279c7cc79b6d3b70bb9d31682b693e"
-  integrity sha512-YiQipGGAFj2zBfqLhp28yUvPP9jUGqHxRzrGYuc82Z2wM27YIHbElXiaZDc93c3x0mz4zvBmS6q/DgExpdj37A==
+ts-loader@^9.2.9:
+  version "9.2.9"
+  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-9.2.9.tgz#0653e07fa1b4f225d0ca57a84fddbfd43d930f9e"
+  integrity sha512-b0+vUY2/enb0qYtDQuNlDnJ9900NTiPiJcDJ6sY7ax1CCCwXfYIqPOMm/BwW7jsF1km+Oz8W9s31HLuD+FLIMg==
   dependencies:
     chalk "^4.1.0"
-    enhanced-resolve "^4.0.0"
-    loader-utils "^2.0.0"
+    enhanced-resolve "^5.0.0"
     micromatch "^4.0.0"
     semver "^7.3.4"
 
-ts-node@^9.1.1:
-  version "9.1.1"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-9.1.1.tgz#51a9a450a3e959401bda5f004a72d54b936d376d"
-  integrity sha512-hPlt7ZACERQGf03M253ytLY3dHbGNGrAq9qIHWUY9XHYl1z7wYngSr3OQ5xmui8o2AaxsONxIzjafLUiWBo1Fg==
-  dependencies:
+ts-node@^10.7.0:
+  version "10.7.0"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.7.0.tgz#35d503d0fab3e2baa672a0e94f4b40653c2463f5"
+  integrity sha512-TbIGS4xgJoX2i3do417KSaep1uRAW/Lu+WAL2doDHC0D6ummjirVOXU5/7aiZotbQ5p1Zp9tP7U6cYhA0O7M8A==
+  dependencies:
+    "@cspotcode/source-map-support" "0.7.0"
+    "@tsconfig/node10" "^1.0.7"
+    "@tsconfig/node12" "^1.0.7"
+    "@tsconfig/node14" "^1.0.0"
+    "@tsconfig/node16" "^1.0.2"
+    acorn "^8.4.1"
+    acorn-walk "^8.1.1"
     arg "^4.1.0"
     create-require "^1.1.0"
     diff "^4.0.1"
     make-error "^1.1.1"
-    source-map-support "^0.5.17"
+    v8-compile-cache-lib "^3.0.0"
     yn "3.1.1"
 
-tslib@2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
-  integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
-
 tslib@^1.8.1:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
@@ -9164,23 +8759,18 @@ tslib@^1.9.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286"
   integrity sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==
 
-tslib@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c"
-  integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==
+tslib@^2.0.3, tslib@^2.1.0, tslib@^2.3.1, tslib@^2.4.0:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.4.0.tgz#7cecaa7f073ce680a05847aa77be941098f36dc3"
+  integrity sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==
 
-tsutils@^3.17.1:
+tsutils@^3.21.0:
   version "3.21.0"
   resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
   integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
   dependencies:
     tslib "^1.8.1"
 
-tty-browserify@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.0.tgz#a157ba402da24e9bf957f9aa69d524eed42901a6"
-  integrity sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=
-
 tunnel-agent@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
@@ -9188,6 +8778,11 @@ tunnel-agent@^0.6.0:
   dependencies:
     safe-buffer "^5.0.1"
 
+tunnel@0.0.6:
+  version "0.0.6"
+  resolved "https://registry.yarnpkg.com/tunnel/-/tunnel-0.0.6.tgz#72f1314b34a5b192db012324df2cc587ca47f92c"
+  integrity sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==
+
 tweetnacl@^0.14.3, tweetnacl@~0.14.0:
   version "0.14.5"
   resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
@@ -9207,54 +8802,92 @@ type-check@~0.3.2:
   dependencies:
     prelude-ls "~1.1.2"
 
-type-detect@0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-0.1.1.tgz#0ba5ec2a885640e470ea4e8505971900dac58822"
-  integrity sha1-C6XsKohWQORw6k6FBZcZANrFiCI=
+type-detect@4.0.8, type-detect@^4.0.0:
+  version "4.0.8"
+  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
+  integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==
+
+type-fest@^0.13.1:
+  version "0.13.1"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.13.1.tgz#0172cb5bce80b0bd542ea348db50c7e21834d934"
+  integrity sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==
+
+type-fest@^0.18.0:
+  version "0.18.1"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f"
+  integrity sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==
 
 type-fest@^0.20.2:
   version "0.20.2"
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
   integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
 
+type-fest@^0.21.3:
+  version "0.21.3"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
+  integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
+
+type-fest@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
+  integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==
+
+type-fest@^0.7.1:
+  version "0.7.1"
+  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.7.1.tgz#8dda65feaf03ed78f0a3f9678f1869147f7c5c48"
+  integrity sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==
+
 type-fest@^0.8.1:
   version "0.8.1"
   resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
   integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
 
-type-is@~1.6.16:
-  version "1.6.16"
-  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.16.tgz#f89ce341541c672b25ee7ae3c73dee3b2be50194"
-  integrity sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==
+type-is@~1.6.18:
+  version "1.6.18"
+  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131"
+  integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
   dependencies:
     media-typer "0.3.0"
-    mime-types "~2.1.18"
+    mime-types "~2.1.24"
 
 typedarray@^0.0.6:
   version "0.0.6"
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-typescript@^4.2.2:
-  version "4.2.3"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.3.tgz#39062d8019912d43726298f09493d598048c1ce3"
-  integrity sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==
+typescript@^4.4.3, typescript@^4.6.4:
+  version "4.6.4"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.6.4.tgz#caa78bbc3a59e6a5c510d35703f6a09877ce45e9"
+  integrity sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg==
+
+ua-parser-js@^0.7.21, ua-parser-js@^0.7.30:
+  version "0.7.31"
+  resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-0.7.31.tgz#649a656b191dffab4f21d5e053e27ca17cbff5c6"
+  integrity sha512-qLK/Xe9E2uzmYI3qLeOmI0tEOt+TBBQyUIAh4aAgU05FVYzeZrKUdkAZfBNVGRaHVgV0TDkdEngJSw/SyQchkQ==
 
 uglify-js@^3.1.4:
   version "3.13.0"
   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.13.0.tgz#66ed69f7241f33f13531d3d51d5bcebf00df7f69"
   integrity sha512-TWYSWa9T2pPN4DIJYbU9oAjQx+5qdV5RUDxwARg8fmJZrD/V27Zj0JngW5xg1DFz42G0uDYl2XhzF6alSzD62w==
 
-ultron@~1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/ultron/-/ultron-1.1.1.tgz#9fe1536a10a664a65266a1e3ccf85fd36302bc9c"
-  integrity sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==
+unbzip2-stream@1.4.3, unbzip2-stream@^1.0.9, unbzip2-stream@^1.3.3:
+  version "1.4.3"
+  resolved "https://registry.yarnpkg.com/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz#b0da04c4371311df771cdc215e87f2130991ace7"
+  integrity sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==
+  dependencies:
+    buffer "^5.2.1"
+    through "^2.3.8"
 
 unicode-canonical-property-names-ecmascript@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-1.0.4.tgz#2619800c4c825800efdd8343af7dd9933cbe2818"
   integrity sha512-jDrNnXWHd4oHiTZnx/ZG7gtUTVp+gCcTTKr8L0HjlwphROEW3+Him+IpvC+xcJEFegapiMZyZe02CyuOnRmbnQ==
 
+unicode-canonical-property-names-ecmascript@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz#301acdc525631670d39f6146e0e77ff6bbdebddc"
+  integrity sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==
+
 unicode-match-property-ecmascript@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-1.0.4.tgz#8ed2a32569961bce9227d09cd3ffbb8fed5f020c"
@@ -9263,25 +8896,33 @@ unicode-match-property-ecmascript@^1.0.4:
     unicode-canonical-property-names-ecmascript "^1.0.4"
     unicode-property-aliases-ecmascript "^1.0.4"
 
+unicode-match-property-ecmascript@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz#54fd16e0ecb167cf04cf1f756bdcc92eba7976c3"
+  integrity sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==
+  dependencies:
+    unicode-canonical-property-names-ecmascript "^2.0.0"
+    unicode-property-aliases-ecmascript "^2.0.0"
+
 unicode-match-property-value-ecmascript@^1.1.0, unicode-match-property-value-ecmascript@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz#0d91f600eeeb3096aa962b1d6fc88876e64ea531"
   integrity sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==
 
+unicode-match-property-value-ecmascript@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.0.0.tgz#1a01aa57247c14c568b89775a54938788189a714"
+  integrity sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==
+
 unicode-property-aliases-ecmascript@^1.0.4:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz#dd57a99f6207bedff4628abefb94c50db941c8f4"
   integrity sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==
 
-union-value@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/union-value/-/union-value-1.0.0.tgz#5c71c34cb5bad5dcebe3ea0cd08207ba5aa1aea4"
-  integrity sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=
-  dependencies:
-    arr-union "^3.1.0"
-    get-value "^2.0.6"
-    is-extendable "^0.1.1"
-    set-value "^0.4.3"
+unicode-property-aliases-ecmascript@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.0.0.tgz#0a36cb9a585c4f6abd51ad1deddb285c165297c8"
+  integrity sha512-5Zfuy9q/DFr4tfO7ZPeVXb1aPoeQSdeFMLpYuFebehDAhbuevLs5yxSZmIFN1tP5F9Wl4IpJrYojg85/zgyZHQ==
 
 union@~0.5.0:
   version "0.5.0"
@@ -9290,42 +8931,43 @@ union@~0.5.0:
   dependencies:
     qs "^6.4.0"
 
-unique-filename@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/unique-filename/-/unique-filename-1.1.1.tgz#1d69769369ada0583103a1e6ae87681b56573230"
-  integrity sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==
-  dependencies:
-    unique-slug "^2.0.0"
-
-unique-slug@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/unique-slug/-/unique-slug-2.0.1.tgz#5e9edc6d1ce8fb264db18a507ef9bd8544451ca6"
-  integrity sha512-n9cU6+gITaVu7VGj1Z8feKMmfAjEAQGhwD9fE3zvpRRa0wEIx8ODYkVGfSc94M2OX00tUFV8wH3zYbm1I8mxFg==
-  dependencies:
-    imurmurhash "^0.1.4"
-
 universalify@^0.1.0:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
   integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
 
+universalify@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
+  integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==
+
 unpipe@1.0.0, unpipe@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
   integrity sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=
 
-unset-value@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559"
-  integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=
+upath2@^3.1.12:
+  version "3.1.12"
+  resolved "https://registry.yarnpkg.com/upath2/-/upath2-3.1.12.tgz#441b3dfbadde21731017bd1b7beb169498efd0a9"
+  integrity sha512-yC3eZeCyCXFWjy7Nu4pgjLhXNYjuzuUmJiRgSSw6TJp8Emc+E4951HGPJf+bldFC5SL7oBLeNbtm1fGzXn2gxw==
   dependencies:
-    has-value "^0.3.1"
-    isobject "^3.0.0"
+    path-is-network-drive "^1.0.13"
+    path-strip-sep "^1.0.10"
+    tslib "^2.3.1"
 
-upath@^1.0.5:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/upath/-/upath-1.1.0.tgz#35256597e46a581db4793d0ce47fa9aebfc9fabd"
-  integrity sha512-bzpH/oBhoS/QI/YtbkqCg6VEiPYjSZtrHQM6/QnJS6OL9pKUFLqb3aFh4Scvwm45+7iAgiMkLhSbaZxUqmrprw==
+upper-case-first@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/upper-case-first/-/upper-case-first-2.0.2.tgz#992c3273f882abd19d1e02894cc147117f844324"
+  integrity sha512-514ppYHBaKwfJRK/pNC6c/OxfGa0obSnAl106u97Ed0I625Nin96KAjttZF6ZL3e1XLtphxnqrOi9iWgm+u+bg==
+  dependencies:
+    tslib "^2.0.3"
+
+upper-case@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/upper-case/-/upper-case-2.0.2.tgz#d89810823faab1df1549b7d97a76f8662bae6f7a"
+  integrity sha512-KgdgDGJt2TpuwBUIjgG6lzw2GWFRCW9Qkfkiv0DxqHHLYJHmtmdUIKcZd8rHgFSjopVTlw6ggzCm1b8MFQwikg==
+  dependencies:
+    tslib "^2.0.3"
 
 uri-js@^4.2.2:
   version "4.2.2"
@@ -9339,64 +8981,35 @@ urix@^0.1.0:
   resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
   integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
 
-url-join@^2.0.5:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/url-join/-/url-join-2.0.5.tgz#5af22f18c052a000a48d7b82c5e9c2e2feeda728"
-  integrity sha1-WvIvGMBSoACkjXuCxenC4v7tpyg=
+url-join@^4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/url-join/-/url-join-4.0.1.tgz#b642e21a2646808ffa178c4c5fda39844e12cde7"
+  integrity sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==
 
-url@^0.11.0:
-  version "0.11.0"
-  resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
-  integrity sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=
+url-parse-lax@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/url-parse-lax/-/url-parse-lax-3.0.0.tgz#16b5cafc07dbe3676c1b1999177823d6503acb0c"
+  integrity sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=
   dependencies:
-    punycode "1.3.2"
-    querystring "0.2.0"
+    prepend-http "^2.0.0"
 
-urlgrey@^0.4.4:
-  version "0.4.4"
-  resolved "https://registry.yarnpkg.com/urlgrey/-/urlgrey-0.4.4.tgz#892fe95960805e85519f1cd4389f2cb4cbb7652f"
-  integrity sha1-iS/pWWCAXoVRnxzUOJ8stMu3ZS8=
-
-use@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/use/-/use-3.1.1.tgz#d50c8cac79a19fbc20f2911f56eb973f4e10070f"
-  integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==
+url-to-options@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/url-to-options/-/url-to-options-1.0.1.tgz#1505a03a289a48cbd7a434efbaeec5055f5633a9"
+  integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=
 
-useragent@2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/useragent/-/useragent-2.3.0.tgz#217f943ad540cb2128658ab23fc960f6a88c9972"
-  integrity sha512-4AoH4pxuSvHCjqLO04sU6U/uE65BYza8l/KKBS0b0hnUPWi+cQ2BpeTEwejCSx9SPV5/U03nniDTrWx5NrmKdw==
+urlgrey@1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/urlgrey/-/urlgrey-1.0.0.tgz#72d2f904482d0b602e3c7fa599343d699bbe1017"
+  integrity sha512-hJfIzMPJmI9IlLkby8QrsCykQ+SXDeO2W5Q9QTW3QpqZVTx4a/K7p8/5q+/isD8vsbVaFgql/gvAoQCRQ2Cb5w==
   dependencies:
-    lru-cache "4.1.x"
-    tmp "0.0.x"
+    fast-url-parser "^1.1.3"
 
-util-deprecate@~1.0.1:
+util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
 
-util.promisify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/util.promisify/-/util.promisify-1.0.0.tgz#440f7165a459c9a16dc145eb8e72f35687097030"
-  integrity sha512-i+6qA2MPhvoKLuxnJNpXAGhg7HphQOSUq2LKMZD0m15EiskXUkMvKdF4Uui0WYeCUGea+o2cw/ZuwehtfsrNkA==
-  dependencies:
-    define-properties "^1.1.2"
-    object.getownpropertydescriptors "^2.0.3"
-
-util@0.10.3:
-  version "0.10.3"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.10.3.tgz#7afb1afe50805246489e3db7fe0ed379336ac0f9"
-  integrity sha1-evsa/lCAUkZInj23/g7TeTNqwPk=
-  dependencies:
-    inherits "2.0.1"
-
-util@^0.10.3:
-  version "0.10.4"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.10.4.tgz#3aa0125bfe668a4672de58857d3ace27ecb76901"
-  integrity sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==
-  dependencies:
-    inherits "2.0.3"
-
 utils-merge@1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
@@ -9407,6 +9020,16 @@ uuid@^3.3.2:
   resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.3.2.tgz#1b4af4955eb3077c501c23872fc6513811587131"
   integrity sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==
 
+uuid@^8.0.0:
+  version "8.3.2"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
+  integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
+
+v8-compile-cache-lib@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
+  integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
+
 v8-compile-cache@^2.0.3:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
@@ -9420,6 +9043,11 @@ validate-npm-package-license@^3.0.1:
     spdx-correct "^3.0.0"
     spdx-expression-parse "^3.0.0"
 
+vary@^1:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc"
+  integrity sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=
+
 verror@1.10.0:
   version "1.10.0"
   resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
@@ -9429,82 +9057,118 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
-vm-browserify@0.0.4:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-0.0.4.tgz#5d7ea45bbef9e4a6ff65f95438e0a87c357d5a73"
-  integrity sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=
-  dependencies:
-    indexof "0.0.1"
-
 void-elements@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/void-elements/-/void-elements-2.0.1.tgz#c066afb582bb1cb4128d60ea92392e94d5e9dbec"
   integrity sha1-wGavtYK7HLQSjWDqkjkulNXp2+w=
 
-watchpack@^1.5.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-1.6.0.tgz#4bc12c2ebe8aa277a71f1d3f14d685c7b446cd00"
-  integrity sha512-i6dHe3EyLjMmDlU1/bGQpEw25XSjkJULPuAVKCbNRefQVq48yXKUpwg538F7AZTf9kyr57zj++pQFltUa5H7yA==
+watchpack@^2.3.1:
+  version "2.3.1"
+  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.3.1.tgz#4200d9447b401156eeca7767ee610f8809bc9d25"
+  integrity sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==
   dependencies:
-    chokidar "^2.0.2"
+    glob-to-regexp "^0.4.1"
     graceful-fs "^4.1.2"
-    neo-async "^2.5.0"
 
-webpack-dev-middleware@^3.2.0:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/webpack-dev-middleware/-/webpack-dev-middleware-3.5.0.tgz#fff0a07b0461314fb6ca82df3642c2423f768429"
-  integrity sha512-1Zie7+dMr4Vv3nGyhr8mxGQkzTQK1PTS8K3yJ4yB1mfRGwO1DzQibgmNfUqbEfQY6eEtEEUzC+o7vhpm/Sfn5w==
-  dependencies:
-    memory-fs "~0.4.1"
-    mime "^2.3.1"
-    range-parser "^1.0.3"
-    webpack-log "^2.0.0"
+wcwidth@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/wcwidth/-/wcwidth-1.0.1.tgz#f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8"
+  integrity sha1-8LDc+RW8X/FSivrbLA4XtTLaL+g=
+  dependencies:
+    defaults "^1.0.3"
+
+webdriver@6.12.1:
+  version "6.12.1"
+  resolved "https://registry.yarnpkg.com/webdriver/-/webdriver-6.12.1.tgz#30eee65340ea5124aa564f99a4dbc7d2f965b308"
+  integrity sha512-3rZgAj9o2XHp16FDTzvUYaHelPMSPbO1TpLIMUT06DfdZjNYIzZiItpIb/NbQDTPmNhzd9cuGmdI56WFBGY2BA==
+  dependencies:
+    "@wdio/config" "6.12.1"
+    "@wdio/logger" "6.10.10"
+    "@wdio/protocols" "6.12.0"
+    "@wdio/utils" "6.11.0"
+    got "^11.0.2"
+    lodash.merge "^4.6.1"
+
+webdriverio@^6.7.0:
+  version "6.12.1"
+  resolved "https://registry.yarnpkg.com/webdriverio/-/webdriverio-6.12.1.tgz#5b6f1167373bd7a154419d8a930ef1ffda9d0537"
+  integrity sha512-Nx7ge0vTWHVIRUbZCT+IuMwB5Q0Q5nLlYdgnmmJviUKLuc3XtaEBkYPTbhHWHgSBXsPZMIc023vZKNkn+6iyeQ==
+  dependencies:
+    "@types/puppeteer-core" "^5.4.0"
+    "@wdio/config" "6.12.1"
+    "@wdio/logger" "6.10.10"
+    "@wdio/repl" "6.11.0"
+    "@wdio/utils" "6.11.0"
+    archiver "^5.0.0"
+    atob "^2.1.2"
+    css-shorthand-properties "^1.1.1"
+    css-value "^0.0.1"
+    devtools "6.12.1"
+    fs-extra "^9.0.1"
+    get-port "^5.1.1"
+    grapheme-splitter "^1.0.2"
+    lodash.clonedeep "^4.5.0"
+    lodash.isobject "^3.0.2"
+    lodash.isplainobject "^4.0.6"
+    lodash.zip "^4.2.0"
+    minimatch "^3.0.4"
+    puppeteer-core "^5.1.0"
+    resq "^1.9.1"
+    rgb2hex "0.2.3"
+    serialize-error "^8.0.0"
+    webdriver "6.12.1"
 
-webpack-log@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/webpack-log/-/webpack-log-2.0.0.tgz#5b7928e0637593f119d32f6227c1e0ac31e1b47f"
-  integrity sha512-cX8G2vR/85UYG59FgkoMamwHUIkSSlV3bBMRsbxVXVUk2j6NleCKjQ/WE9eYg9WY4w25O9w8wKP4rzNZFmUcUg==
-  dependencies:
-    ansi-colors "^3.0.0"
-    uuid "^3.3.2"
+webidl-conversions@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
+  integrity sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=
 
-webpack-sources@^1.1.0, webpack-sources@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-1.3.0.tgz#2a28dcb9f1f45fe960d8f1493252b5ee6530fa85"
-  integrity sha512-OiVgSrbGu7NEnEvQJJgdSFPl2qWKkWq5lHMhgiToIiN9w34EBnjYzSYs+VbL5KoYiLNtFFa7BZIKxRED3I32pA==
+webidl-conversions@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-4.0.2.tgz#a855980b1f0b6b359ba1d5d9fb39ae941faa63ad"
+  integrity sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==
+
+webpack-merge@^4.1.5:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-4.2.2.tgz#a27c52ea783d1398afd2087f547d7b9d2f43634d"
+  integrity sha512-TUE1UGoTX2Cd42j3krGYqObZbOD+xF7u28WB7tfUordytSjbWTIjK/8V0amkBfTYN4/pB/GIDlJZZ657BGG19g==
   dependencies:
-    source-list-map "^2.0.0"
-    source-map "~0.6.1"
+    lodash "^4.17.15"
 
-webpack@~4.28.4:
-  version "4.28.4"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-4.28.4.tgz#1ddae6c89887d7efb752adf0c3cd32b9b07eacd0"
-  integrity sha512-NxjD61WsK/a3JIdwWjtIpimmvE6UrRi3yG54/74Hk9rwNj5FPkA4DJCf1z4ByDWLkvZhTZE+P3C/eh6UD5lDcw==
-  dependencies:
-    "@webassemblyjs/ast" "1.7.11"
-    "@webassemblyjs/helper-module-context" "1.7.11"
-    "@webassemblyjs/wasm-edit" "1.7.11"
-    "@webassemblyjs/wasm-parser" "1.7.11"
-    acorn "^5.6.2"
-    acorn-dynamic-import "^3.0.0"
-    ajv "^6.1.0"
-    ajv-keywords "^3.1.0"
-    chrome-trace-event "^1.0.0"
-    enhanced-resolve "^4.1.0"
-    eslint-scope "^4.0.0"
+webpack-sources@^3.2.3:
+  version "3.2.3"
+  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.2.3.tgz#2d4daab8451fd4b240cc27055ff6a0c2ccea0cde"
+  integrity sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==
+
+webpack@^5, webpack@~5.72.0:
+  version "5.72.0"
+  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.72.0.tgz#f8bc40d9c6bb489a4b7a8a685101d6022b8b6e28"
+  integrity sha512-qmSmbspI0Qo5ld49htys8GY9XhS9CGqFoHTsOVAnjBdg0Zn79y135R+k4IR4rKK6+eKaabMhJwiVB7xw0SJu5w==
+  dependencies:
+    "@types/eslint-scope" "^3.7.3"
+    "@types/estree" "^0.0.51"
+    "@webassemblyjs/ast" "1.11.1"
+    "@webassemblyjs/wasm-edit" "1.11.1"
+    "@webassemblyjs/wasm-parser" "1.11.1"
+    acorn "^8.4.1"
+    acorn-import-assertions "^1.7.6"
+    browserslist "^4.14.5"
+    chrome-trace-event "^1.0.2"
+    enhanced-resolve "^5.9.2"
+    es-module-lexer "^0.9.0"
+    eslint-scope "5.1.1"
+    events "^3.2.0"
+    glob-to-regexp "^0.4.1"
+    graceful-fs "^4.2.9"
     json-parse-better-errors "^1.0.2"
-    loader-runner "^2.3.0"
-    loader-utils "^1.1.0"
-    memory-fs "~0.4.1"
-    micromatch "^3.1.8"
-    mkdirp "~0.5.0"
-    neo-async "^2.5.0"
-    node-libs-browser "^2.0.0"
-    schema-utils "^0.4.4"
-    tapable "^1.1.0"
-    terser-webpack-plugin "^1.1.0"
-    watchpack "^1.5.0"
-    webpack-sources "^1.3.0"
+    loader-runner "^4.2.0"
+    mime-types "^2.1.27"
+    neo-async "^2.6.2"
+    schema-utils "^3.1.0"
+    tapable "^2.1.1"
+    terser-webpack-plugin "^5.1.3"
+    watchpack "^2.3.1"
+    webpack-sources "^3.2.3"
 
 weex-js-runtime@^0.23.6:
   version "0.23.7"
@@ -9518,26 +9182,50 @@ weex-styler@^0.3.0:
   dependencies:
     css "~2.2.1"
 
-which@^1.1.1, which@^1.2.1, which@^1.2.10, which@^1.2.12, which@^1.2.9:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
-  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
+whatwg-encoding@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/whatwg-encoding/-/whatwg-encoding-2.0.0.tgz#e7635f597fd87020858626805a2729fa7698ac53"
+  integrity sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg==
   dependencies:
-    isexe "^2.0.0"
+    iconv-lite "0.6.3"
 
-which@^2.0.1:
+whatwg-url@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
+  integrity sha1-lmRU6HZUYuN2RNNib2dCzotwll0=
+  dependencies:
+    tr46 "~0.0.3"
+    webidl-conversions "^3.0.0"
+
+whatwg-url@^7.0.0:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-7.1.0.tgz#c2c492f1eca612988efd3d2266be1b9fc6170d06"
+  integrity sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==
+  dependencies:
+    lodash.sortby "^4.7.0"
+    tr46 "^1.0.1"
+    webidl-conversions "^4.0.2"
+
+which@2.0.2, which@^2.0.1, which@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
   integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
   dependencies:
     isexe "^2.0.0"
 
-wide-align@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/wide-align/-/wide-align-1.1.3.tgz#ae074e6bdc0c14a431e804e624549c633b000457"
-  integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==
+which@^1.2.1, which@^1.2.10, which@^1.2.14, which@^1.2.9:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
+  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
+  dependencies:
+    isexe "^2.0.0"
+
+widest-line@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-3.1.0.tgz#8292333bbf66cb45ff0de1603b136b7ae1496eca"
+  integrity sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==
   dependencies:
-    string-width "^1.0.2 || 2"
+    string-width "^4.0.0"
 
 word-wrap@^1.0.3, word-wrap@^1.2.3:
   version "1.2.3"
@@ -9549,25 +9237,19 @@ wordwrap@^1.0.0, wordwrap@~1.0.0:
   resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
   integrity sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=
 
-wordwrap@~0.0.2:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
-  integrity sha1-o9XabNXAvAAI03I0u68b7WMFkQc=
-
-worker-farm@^1.5.2:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/worker-farm/-/worker-farm-1.6.0.tgz#aecc405976fab5a95526180846f0dba288f3a4a0"
-  integrity sha512-6w+3tHbM87WnSWnENBUvA2pxJPLhQUg5LKwUQHq3r+XPhIM+Gh2R5ycbwPCyuGbNg+lPgdcnQUhuC02kJCvffQ==
-  dependencies:
-    errno "~0.1.7"
+workerpool@6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.0.tgz#827d93c9ba23ee2019c3ffaff5c27fccea289e8b"
+  integrity sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A==
 
-wrap-ansi@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-3.0.1.tgz#288a04d87eda5c286e060dfe8f135ce8d007f8ba"
-  integrity sha1-KIoE2H7aXChuBg3+jxNc6NAH+Lo=
+wrap-ansi@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
+  integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
   dependencies:
-    string-width "^2.1.1"
-    strip-ansi "^4.0.0"
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
 
 wrap-ansi@^7.0.0:
   version "7.0.0"
@@ -9583,55 +9265,26 @@ wrappy@1:
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
 
-ws@^6.1.0:
-  version "6.1.2"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-6.1.2.tgz#3cc7462e98792f0ac679424148903ded3b9c3ad8"
-  integrity sha512-rfUqzvz0WxmSXtJpPMX2EeASXabOrSMk1ruMOV3JBTBjo4ac2lDjGGsbQSyxj8Odhw5fBib8ZKEjDNvgouNKYw==
-  dependencies:
-    async-limiter "~1.0.0"
-
-ws@~3.3.1:
-  version "3.3.3"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-3.3.3.tgz#f1cf84fe2d5e901ebce94efaece785f187a228f2"
-  integrity sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==
-  dependencies:
-    async-limiter "~1.0.0"
-    safe-buffer "~5.1.0"
-    ultron "~1.1.0"
-
-xml2js@^0.4.17:
-  version "0.4.19"
-  resolved "https://registry.yarnpkg.com/xml2js/-/xml2js-0.4.19.tgz#686c20f213209e94abf0d1bcf1efaa291c7827a7"
-  integrity sha512-esZnJZJOiJR9wWKMyuvSE1y6Dq5LCuJanqhxslH2bxM6duahNZ+HMpCLhBQGZkbX6xRf8x1Y2eJlgt2q3qo49Q==
-  dependencies:
-    sax ">=0.6.0"
-    xmlbuilder "~9.0.1"
-
-xmlbuilder@~9.0.1:
-  version "9.0.7"
-  resolved "https://registry.yarnpkg.com/xmlbuilder/-/xmlbuilder-9.0.7.tgz#132ee63d2ec5565c557e20f4c22df9aca686b10d"
-  integrity sha1-Ey7mPS7FVlxVfiD0wi35rKaGsQ0=
+ws@8.5.0, ws@>=7.4.6:
+  version "8.5.0"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.5.0.tgz#bfb4be96600757fe5382de12c670dab984a1ed4f"
+  integrity sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==
 
-xmlhttprequest-ssl@~1.5.4:
-  version "1.5.5"
-  resolved "https://registry.yarnpkg.com/xmlhttprequest-ssl/-/xmlhttprequest-ssl-1.5.5.tgz#c2876b06168aadc40e57d97e81191ac8f4398b3e"
-  integrity sha1-wodrBhaKrcQOV9l+gRkayPQ5iz4=
+ws@^7.2.3:
+  version "7.5.7"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.7.tgz#9e0ac77ee50af70d58326ecff7e85eb3fa375e67"
+  integrity sha512-KMvVuFzpKBuiIXW3E4u3mySRO2/mCHSyZDJQM5NQ9Q9KHWHWh0NHgfbRMLLrceUK5qAL4ytALJbpRMjixFZh8A==
 
-xregexp@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/xregexp/-/xregexp-2.0.0.tgz#52a63e56ca0b84a7f3a5f3d61872f126ad7a5943"
-  integrity sha1-UqY+VsoLhKfzpfPWGHLxJq16WUM=
+ws@~8.2.3:
+  version "8.2.3"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.2.3.tgz#63a56456db1b04367d0b721a0b80cae6d8becbba"
+  integrity sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==
 
 xtend@^4.0.0, xtend@~4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af"
   integrity sha1-pcbVMr5lbiPbgg77lDofBJmNY68=
 
-y18n@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.1.tgz#8db2b83c31c5d75099bb890b23f3094891e247d4"
-  integrity sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ==
-
 y18n@^5.0.5:
   version "5.0.7"
   resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.7.tgz#0c514aba53fc40e2db911aeb8b51566a3374efe7"
@@ -9642,22 +9295,47 @@ yallist@^2.1.2:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52"
   integrity sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=
 
-yallist@^3.0.0, yallist@^3.0.2:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-3.0.3.tgz#b4b049e314be545e3ce802236d6cd22cd91c3de9"
-  integrity sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A==
-
 yallist@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
+yaml@^1.10.0, yaml@^1.10.2:
+  version "1.10.2"
+  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b"
+  integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
+
+yargs-parser@20.2.4:
+  version "20.2.4"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.4.tgz#b42890f14566796f85ae8e3a25290d205f154a54"
+  integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==
+
 yargs-parser@^20.2.2:
   version "20.2.7"
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.7.tgz#61df85c113edfb5a7a4e36eb8aa60ef423cbc90a"
   integrity sha512-FiNkvbeHzB/syOjIUxFDCnhSfzAL8R5vs40MgLFBorXACCOAEaWu0gRZl14vG8MR9AOJIZbmkjhusqBYZ3HTHw==
 
-yargs@^16.2.0:
+yargs-parser@^20.2.3:
+  version "20.2.9"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
+  integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
+
+yargs-parser@^21.0.0:
+  version "21.0.1"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.0.1.tgz#0267f286c877a4f0f728fceb6f8a3e4cb95c6e35"
+  integrity sha512-9BK1jFpLzJROCI5TzwZL/TU4gqjK5xiHV/RfWLOahrjAko/e4DJkRDZQXfvqAsiZzzYhgAzbgz6lg48jcm4GLg==
+
+yargs-unparser@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-2.0.0.tgz#f131f9226911ae5d9ad38c432fe809366c2325eb"
+  integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==
+  dependencies:
+    camelcase "^6.0.0"
+    decamelize "^4.0.0"
+    flat "^5.0.2"
+    is-plain-obj "^2.1.0"
+
+yargs@16.2.0, yargs@^16.0.3, yargs@^16.1.1, yargs@^16.2.0:
   version "16.2.0"
   resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
   integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
@@ -9670,6 +9348,19 @@ yargs@^16.2.0:
     y18n "^5.0.5"
     yargs-parser "^20.2.2"
 
+yargs@^17.0.1:
+  version "17.4.1"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.4.1.tgz#ebe23284207bb75cee7c408c33e722bfb27b5284"
+  integrity sha512-WSZD9jgobAg3ZKuCQZSa3g9QOJeCCqLoLAykiWgmXnDo9EPnn4RPf5qVTtzgOx66o6/oqhcA5tHtJXpG8pMt3g==
+  dependencies:
+    cliui "^7.0.2"
+    escalade "^3.1.1"
+    get-caller-file "^2.0.5"
+    require-directory "^2.1.1"
+    string-width "^4.2.3"
+    y18n "^5.0.5"
+    yargs-parser "^21.0.0"
+
 yauzl@2.4.1:
   version "2.4.1"
   resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.4.1.tgz#9528f442dab1b2284e58b4379bb194e22e0c4005"
@@ -9677,16 +9368,24 @@ yauzl@2.4.1:
   dependencies:
     fd-slicer "~1.0.1"
 
-yeast@0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/yeast/-/yeast-0.1.2.tgz#008e06d8094320c372dbc2f8ed76a0ca6c8ac419"
-  integrity sha1-AI4G2AlDIMNy28L47XagymyKxBk=
+yauzl@^2.10.0, yauzl@^2.4.2:
+  version "2.10.0"
+  resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.10.0.tgz#c7eb17c93e112cb1086fa6d8e51fb0667b79a5f9"
+  integrity sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=
+  dependencies:
+    buffer-crc32 "~0.2.3"
+    fd-slicer "~1.1.0"
 
 yn@3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
   integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
 
+yocto-queue@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
+  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
 yorkie@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/yorkie/-/yorkie-2.0.0.tgz#92411912d435214e12c51c2ae1093e54b6bb83d9"
@@ -9696,3 +9395,12 @@ yorkie@^2.0.0:
     is-ci "^1.0.10"
     normalize-path "^1.0.0"
     strip-indent "^2.0.0"
+
+zip-stream@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/zip-stream/-/zip-stream-4.1.0.tgz#51dd326571544e36aa3f756430b313576dc8fc79"
+  integrity sha512-zshzwQW7gG7hjpBlgeQP9RuyPGNxvJdzR8SUM3QhxCnLjWN2E7j3dOvpeDcQoETfHx0urRS7EtmVToql7YpU4A==
+  dependencies:
+    archiver-utils "^2.1.0"
+    compress-commons "^4.1.0"
+    readable-stream "^3.6.0"

From 46b64ff72cbc4eda2bb9783257677e6d681048d4 Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Fri, 29 Apr 2022 14:23:21 -0600
Subject: [PATCH 023/317] restore package.json

---
 package.json | 164 +++++++++++++++++++++++++++++++++++++++++++++++++++
 yarn.lock    |   2 +-
 2 files changed, 165 insertions(+), 1 deletion(-)
 create mode 100644 package.json

diff --git a/package.json b/package.json
new file mode 100644
index 00000000000..548096e73ae
--- /dev/null
+++ b/package.json
@@ -0,0 +1,164 @@
+{
+  "name": "vue",
+  "version": "2.6.14",
+  "description": "Reactive, component-oriented view layer for modern web interfaces.",
+  "main": "dist/vue.runtime.common.js",
+  "module": "dist/vue.runtime.esm.js",
+  "unpkg": "dist/vue.js",
+  "jsdelivr": "dist/vue.js",
+  "typings": "types/index.d.ts",
+  "files": [
+    "src",
+    "dist/*.js",
+    "types/*.d.ts"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "dev": "rollup -w -c scripts/config.js --environment TARGET:web-full-dev",
+    "dev:cjs": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-cjs-dev",
+    "dev:esm": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-esm",
+    "dev:test": "karma start test/unit/karma.dev.config.js",
+    "dev:ssr": "rollup -w -c scripts/config.js --environment TARGET:web-server-renderer",
+    "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:web-compiler ",
+    "dev:weex": "rollup -w -c scripts/config.js --environment TARGET:weex-framework",
+    "dev:weex:factory": "rollup -w -c scripts/config.js --environment TARGET:weex-factory",
+    "dev:weex:compiler": "rollup -w -c scripts/config.js --environment TARGET:weex-compiler ",
+    "build": "node scripts/build.js",
+    "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
+    "build:weex": "npm run build -- weex",
+    "test": "npm run lint && flow check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
+    "test:dtw": "npm run lint && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
+    "test:unit": "karma start test/unit/karma.unit.config.js",
+    "test:cover": "karma start test/unit/karma.cover.config.js",
+    "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.js",
+    "test:weex": "npm run build:weex && jasmine-ts JASMINE_CONFIG_PATH=test/weex/jasmine.js",
+    "test:ssr": "npm run build:ssr && jasmine JASMINE_CONFIG_PATH=test/ssr/jasmine.js",
+    "test:sauce": "npm run sauce -- 0 && npm run sauce -- 1 && npm run sauce -- 2",
+    "test:types": "tsc -p ./types/test/tsconfig.json",
+    "lint": "eslint src scripts test",
+    "flow": "flow check",
+    "ts-check": "tsc --noEmit",
+    "sauce": "karma start test/unit/karma.sauce.config.js",
+    "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
+    "release": "bash scripts/release.sh",
+    "release:weex": "bash scripts/release-weex.sh",
+    "release:note": "node scripts/gen-release-note.js",
+    "commit": "git-cz"
+  },
+  "gitHooks": {
+    "pre-commit": "lint-staged",
+    "commit-msg": "node scripts/verify-commit-msg.js"
+  },
+  "lint-staged": {
+    "*.js": [
+      "eslint --fix",
+      "git add"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vue.git"
+  },
+  "keywords": [
+    "vue"
+  ],
+  "author": "Evan You",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vuejs/vue/issues"
+  },
+  "homepage": "https://github.com/vuejs/vue#readme",
+  "devDependencies": {
+    "@babel/core": "^7.17.10",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-jsx": "^7.16.7",
+    "@babel/plugin-transform-flow-strip-types": "^7.16.7",
+    "@babel/preset-env": "^7.17.10",
+    "@babel/register": "^7.17.7",
+    "@rollup/plugin-alias": "^3.1.9",
+    "@rollup/plugin-buble": "^0.21.3",
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@rollup/plugin-node-resolve": "^13.2.1",
+    "@rollup/plugin-replace": "^4.0.0",
+    "@types/node": "^17.0.30",
+    "@types/webpack": "^5.28.0",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
+    "acorn": "^8.7.1",
+    "acorn-walk": "^8.2.0",
+    "babel-eslint": "^10.1.0",
+    "babel-helper-vue-jsx-merge-props": "^2.0.3",
+    "babel-loader": "^8.2.5",
+    "babel-plugin-istanbul": "^6.1.1",
+    "babel-plugin-transform-vue-jsx": "^4.0.1",
+    "babel-preset-flow-vue": "^1.0.0",
+    "buble": "^0.20.0",
+    "chalk": "^5.0.1",
+    "chromedriver": "^100.0.0",
+    "codecov": "^3.8.3",
+    "commitizen": "^4.2.4",
+    "conventional-changelog": "^3.1.25",
+    "cross-spawn": "^7.0.3",
+    "cz-conventional-changelog": "^3.3.0",
+    "de-indent": "^1.0.2",
+    "es6-promise": "^4.2.8",
+    "escodegen": "^2.0.0",
+    "eslint": "^8.14.0",
+    "eslint-plugin-flowtype": "^8.0.3",
+    "eslint-plugin-jasmine": "^4.1.3",
+    "file-loader": "^6.2.0",
+    "flow-bin": "^0.176.3",
+    "fsevents": "2.3.2",
+    "hash-sum": "^2.0.0",
+    "he": "^1.1.1",
+    "http-server": "^14.1.0",
+    "jasmine": "^4.1.0",
+    "jasmine-core": "^4.1.0",
+    "jasmine-ts": "^0.4.0",
+    "karma": "^6.3.19",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-coverage": "^2.2.0",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-jasmine": "^5.0.0",
+    "karma-mocha-reporter": "^2.2.3",
+    "karma-phantomjs-launcher": "^1.0.4",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-sauce-launcher": "^4.3.6",
+    "karma-sourcemap-loader": "^0.3.8",
+    "karma-webpack": "^5.0.0",
+    "lint-staged": "^12.4.1",
+    "lodash": "^4.17.21",
+    "lodash.template": "^4.4.0",
+    "lodash.uniq": "^4.5.0",
+    "lru-cache": "^7.8.1",
+    "nightwatch": "^2.1.3",
+    "nightwatch-helpers": "^1.2.0",
+    "phantomjs-prebuilt": "^2.1.14",
+    "puppeteer": "^13.7.0",
+    "resolve": "^1.22.0",
+    "rollup": "^2.70.2",
+    "rollup-plugin-typescript2": "^0.31.2",
+    "selenium-server": "^3.141.59",
+    "serialize-javascript": "^6.0.0",
+    "shelljs": "^0.8.5",
+    "stream": "^0.0.2",
+    "terser": "^5.13.1",
+    "ts-loader": "^9.2.9",
+    "ts-node": "^10.7.0",
+    "tslib": "^2.4.0",
+    "typescript": "^4.6.4",
+    "webpack": "~5.72.0",
+    "weex-js-runtime": "^0.23.6",
+    "weex-styler": "^0.3.0",
+    "yorkie": "^2.0.0"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "dependencies": {
+    "@types/he": "^1.1.2"
+  }
+}
diff --git a/yarn.lock b/yarn.lock
index e70cfc36c5d..eab008d3388 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4285,7 +4285,7 @@ fs.realpath@^1.0.0:
   resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
   integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
 
-fsevents@~2.3.2:
+fsevents@2.3.2, fsevents@~2.3.2:
   version "2.3.2"
   resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
   integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==

From 534a0aa863679f8ce07463df1a735d27937f9dc0 Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Fri, 29 Apr 2022 15:43:25 -0600
Subject: [PATCH 024/317] chore: convert tests to typescript

---
 package.json                                  |   7 +-
 src/core/util/next-tick.ts                    |   1 -
 src/core/vdom/modules/directives.ts           |   1 -
 ...htwatch.config.js => nightwatch.config.ts} |   0
 test/e2e/{runner.js => runner.ts}             |   2 +-
 ...sync-edge-cases.js => async-edge-cases.ts} |   0
 test/e2e/specs/{basic-ssr.js => basic-ssr.ts} |   0
 test/e2e/specs/{commits.js => commits.ts}     |   0
 test/e2e/specs/{grid.js => grid.ts}           |   0
 test/e2e/specs/{markdown.js => markdown.ts}   |   0
 test/e2e/specs/{modal.js => modal.ts}         |   0
 test/e2e/specs/{select2.js => select2.ts}     |   0
 test/e2e/specs/{svg.js => svg.ts}             |   0
 test/e2e/specs/{todomvc.js => todomvc.ts}     |   0
 test/e2e/specs/{tree.js => tree.ts}           |   0
 test/helpers/{classlist.js => classlist.ts}   |   0
 ...object-option.js => test-object-option.ts} |   0
 test/helpers/{to-equal.js => to-equal.ts}     |   0
 ...-been-warned.js => to-have-been-warned.ts} |   1 +
 .../{trigger-event.js => trigger-event.ts}    |   0
 test/helpers/{vdom.js => vdom.ts}             |   0
 ...{wait-for-update.js => wait-for-update.ts} |   0
 test/ssr/{async-loader.js => async-loader.ts} |   0
 ...ith-webpack.js => compile-with-webpack.ts} |   0
 test/ssr/fixtures/{app.js => app.ts}          |   0
 .../fixtures/{async-bar.js => async-bar.ts}   |   0
 .../fixtures/{async-foo.js => async-foo.ts}   |   0
 .../{cache-opt-out.js => cache-opt-out.ts}    |   0
 test/ssr/fixtures/{cache.js => cache.ts}      |   0
 test/ssr/fixtures/{error.js => error.ts}      |   0
 .../{nested-cache.js => nested-cache.ts}      |   0
 ...mise-rejection.js => promise-rejection.ts} |   0
 test/ssr/fixtures/{split.js => split.ts}      |   0
 test/ssr/{jasmine.js => jasmine.ts}           |   0
 ...rer.spec.js => ssr-basic-renderer.spec.ts} |   0
 ...nder.spec.js => ssr-bundle-render.spec.ts} |   0
 ...{ssr-stream.spec.js => ssr-stream.spec.ts} |   0
 ...{ssr-string.spec.js => ssr-string.spec.ts} |   0
 ...-template.spec.js => ssr-template.spec.ts} |   0
 ...-async.spec.js => component-async.spec.ts} |   2 +-
 ...e.spec.js => component-keep-alive.spec.ts} |   0
 ....spec.js => component-scoped-slot.spec.ts} |  44 +-
 ...nt-slot.spec.js => component-slot.spec.ts} |   6 +-
 .../{component.spec.js => component.spec.ts}  |   0
 .../features/{debug.spec.js => debug.spec.ts} |   0
 .../directives/{bind.spec.js => bind.spec.ts} |   0
 .../{class.spec.js => class.spec.ts}          |   0
 .../{cloak.spec.js => cloak.spec.ts}          |   0
 .../directives/{for.spec.js => for.spec.ts}   |   0
 .../directives/{html.spec.js => html.spec.ts} |   0
 .../directives/{if.spec.js => if.spec.ts}     |   0
 ...heckbox.spec.js => model-checkbox.spec.ts} |   0
 ...ponent.spec.js => model-component.spec.ts} |   0
 ...-dynamic.spec.js => model-dynamic.spec.ts} |   0
 ...{model-file.spec.js => model-file.spec.ts} |   0
 ...odel-parse.spec.js => model-parse.spec.ts} |   0
 ...odel-radio.spec.js => model-radio.spec.ts} |   0
 ...el-select.spec.js => model-select.spec.ts} |   0
 ...{model-text.spec.js => model-text.spec.ts} |   0
 .../directives/{on.spec.js => on.spec.ts}     |   0
 .../directives/{once.spec.js => once.spec.ts} |   0
 .../directives/{pre.spec.js => pre.spec.ts}   |   0
 .../directives/{show.spec.js => show.spec.ts} |   0
 ...er.spec.js => static-style-parser.spec.ts} |   0
 .../{style.spec.js => style.spec.ts}          |   0
 .../directives/{text.spec.js => text.spec.ts} |   0
 ...andling.spec.js => error-handling.spec.ts} |   0
 .../filter/{filter.spec.js => filter.spec.ts} |   0
 .../{assets.spec.js => assets.spec.ts}        |   0
 .../{compile.spec.js => compile.spec.ts}      |   0
 .../{config.spec.js => config.spec.ts}        |   0
 .../{extend.spec.js => extend.spec.ts}        |   0
 .../{mixin.spec.js => mixin.spec.ts}          |   0
 ...{observable.spec.js => observable.spec.ts} |   0
 ...{set-delete.spec.js => set-delete.spec.ts} |   0
 .../global-api/{use.spec.js => use.spec.ts}   |   0
 .../instance/{init.spec.js => init.spec.ts}   |   0
 ...hods-data.spec.js => methods-data.spec.ts} |   0
 ...-events.spec.js => methods-events.spec.ts} |   0
 ...ycle.spec.js => methods-lifecycle.spec.ts} |   0
 ...{properties.spec.js => properties.spec.ts} |   0
 ...der-proxy.spec.js => render-proxy.spec.ts} |   0
 .../{_scopeId.spec.js => _scopeId.spec.ts}    |   0
 .../{comments.spec.js => comments.spec.ts}    |   0
 ...{components.spec.js => components.spec.ts} |   0
 .../{computed.spec.js => computed.spec.ts}    |   0
 .../options/{data.spec.js => data.spec.ts}    |   0
 ...{delimiters.spec.js => delimiters.spec.ts} |   0
 ...{directives.spec.js => directives.spec.ts} |   0
 .../options/{el.spec.js => el.spec.ts}        |   0
 ...Captured.spec.js => errorCaptured.spec.ts} |   0
 .../{extends.spec.js => extends.spec.ts}      |   0
 ...{functional.spec.js => functional.spec.ts} |   0
 ...eritAttrs.spec.js => inheritAttrs.spec.ts} |   0
 .../{inject.spec.js => inject.spec.ts}        |   0
 .../{lifecycle.spec.js => lifecycle.spec.ts}  |   0
 .../{methods.spec.js => methods.spec.ts}      |   0
 .../{mixins.spec.js => mixins.spec.ts}        |   0
 .../options/{name.spec.js => name.spec.ts}    |   0
 .../{parent.spec.js => parent.spec.ts}        |   0
 .../options/{props.spec.js => props.spec.ts}  |   0
 .../{propsData.spec.js => propsData.spec.ts}  |   0
 .../{render.spec.js => render.spec.ts}        |   0
 ...enderError.spec.js => renderError.spec.ts} |   0
 .../{template.spec.js => template.spec.ts}    |   0
 .../options/{watch.spec.js => watch.spec.ts}  |   0
 .../features/{ref.spec.js => ref.spec.ts}     |   0
 .../{inject-styles.js => inject-styles.ts}    |   0
 ...group.spec.js => transition-group.spec.ts} |   0
 ...n-mode.spec.js => transition-mode.spec.ts} |   0
 ...{transition.spec.js => transition.spec.ts} |   0
 test/unit/{index.js => index.ts}              |   0
 ...ma.base.config.js => karma.base.config.ts} |   7 +-
 ....cover.config.js => karma.cover.config.ts} |   2 +-
 ...arma.dev.config.js => karma.dev.config.ts} |   2 +-
 ....sauce.config.js => karma.sauce.config.ts} |   2 +-
 ...ma.unit.config.js => karma.unit.config.ts} |   2 +-
 .../{codeframe.spec.js => codeframe.spec.ts}  |   0
 .../{codegen.spec.js => codegen.spec.ts}      |   0
 ...tions.spec.js => compiler-options.spec.ts} |   0
 .../{optimizer.spec.js => optimizer.spec.ts}  |   0
 .../{parser.spec.js => parser.spec.ts}        |   0
 .../observer/{dep.spec.js => dep.spec.ts}     |   0
 .../{observer.spec.js => observer.spec.ts}    |   0
 .../{scheduler.spec.js => scheduler.spec.ts}  |   0
 .../{watcher.spec.js => watcher.spec.ts}      |   0
 ...tions.spec.js => compiler-options.spec.ts} |   0
 .../{optimizer.spec.js => optimizer.spec.ts}  |   0
 ...{sfc-parser.spec.js => sfc-parser.spec.ts} |   0
 .../util/{error.spec.js => error.spec.ts}     |   0
 .../{next-tick.spec.js => next-tick.spec.ts}  |   0
 ...onent.spec.js => create-component.spec.ts} |   0
 ...element.spec.js => create-element.spec.ts} |   0
 .../modules/{attrs.spec.js => attrs.spec.ts}  |   0
 .../modules/{class.spec.js => class.spec.ts}  |   0
 .../{directive.spec.js => directive.spec.ts}  |   0
 .../{dom-props.spec.js => dom-props.spec.ts}  |   0
 .../{events.spec.js => events.spec.ts}        |   0
 .../modules/{style.spec.js => style.spec.ts}  |   0
 .../{children.spec.js => children.spec.ts}    |   0
 ...{edge-cases.spec.js => edge-cases.spec.ts} |   0
 .../{element.spec.js => element.spec.ts}      |   0
 .../patch/{hooks.spec.js => hooks.spec.ts}    |   0
 .../{hydration.spec.js => hydration.spec.ts}  |   0
 .../cases/{cases.spec.js => cases.spec.ts}    |   0
 ...lick.after.vdom.js => click.after.vdom.ts} |   0
 ...ck.before.vdom.js => click.before.vdom.ts} |   0
 .../{attrs.vdom.js => attrs.vdom.ts}          |   0
 .../{classname.vdom.js => classname.vdom.ts}  |   0
 ...cle.vdom.js => stateful-lifecycle.vdom.ts} |   0
 ...model.vdom.js => stateful-v-model.vdom.ts} |   0
 .../{stateful.vdom.js => stateful.vdom.ts}    |   0
 ....js => stateless-multi-components.vdom.ts} |   0
 ...s.vdom.js => stateless-with-props.vdom.ts} |   0
 .../{stateless.vdom.js => stateless.vdom.ts}  |   0
 ...ine-style.vdom.js => inline-style.vdom.ts} |   0
 .../{text-node.vdom.js => text-node.vdom.ts}  |   0
 .../{v-else-if.vdom.js => v-else-if.vdom.ts}  |   0
 .../{v-else.vdom.js => v-else.vdom.ts}        |   0
 ...terator.vdom.js => v-for-iterator.vdom.ts} |   0
 .../{v-for.vdom.js => v-for.vdom.ts}          |   0
 .../{v-if.vdom.js => v-if.vdom.ts}            |   0
 ...-on-inline.vdom.js => v-on-inline.vdom.ts} |   0
 .../{v-on.vdom.js => v-on.vdom.ts}            |   0
 .../{v-once.vdom.js => v-once.vdom.ts}        |   0
 .../render/{class.vdom.js => class.vdom.ts}   |   0
 .../render/{sample.vdom.js => sample.vdom.ts} |   0
 .../{append.spec.js => append.spec.ts}        |   0
 .../compiler/{class.spec.js => class.spec.ts} |   0
 .../{compile.spec.js => compile.spec.ts}      |   0
 .../compiler/{props.spec.js => props.spec.ts} |   0
 .../compiler/{style.spec.js => style.spec.ts} |   0
 .../{v-model.spec.js => v-model.spec.ts}      |   0
 test/weex/helpers/{index.js => index.ts}      |   0
 test/weex/{jasmine.js => jasmine.ts}          |   0
 .../runtime/{attrs.spec.js => attrs.spec.ts}  |   0
 .../runtime/{class.spec.js => class.spec.ts}  |   0
 .../{richtext.spec.js => richtext.spec.ts}    |   0
 .../{events.spec.js => events.spec.ts}        |   0
 .../{framework.spec.js => framework.spec.ts}  |   0
 .../runtime/{node.spec.js => node.spec.ts}    |   0
 .../runtime/{style.spec.js => style.spec.ts}  |   0
 tsconfig.json                                 |   7 +-
 types/test/tsconfig.json                      |   7 +-
 yarn.lock                                     | 872 +++++++++++++++++-
 185 files changed, 904 insertions(+), 61 deletions(-)
 rename test/e2e/{nightwatch.config.js => nightwatch.config.ts} (100%)
 rename test/e2e/{runner.js => runner.ts} (91%)
 rename test/e2e/specs/{async-edge-cases.js => async-edge-cases.ts} (100%)
 rename test/e2e/specs/{basic-ssr.js => basic-ssr.ts} (100%)
 rename test/e2e/specs/{commits.js => commits.ts} (100%)
 rename test/e2e/specs/{grid.js => grid.ts} (100%)
 rename test/e2e/specs/{markdown.js => markdown.ts} (100%)
 rename test/e2e/specs/{modal.js => modal.ts} (100%)
 rename test/e2e/specs/{select2.js => select2.ts} (100%)
 rename test/e2e/specs/{svg.js => svg.ts} (100%)
 rename test/e2e/specs/{todomvc.js => todomvc.ts} (100%)
 rename test/e2e/specs/{tree.js => tree.ts} (100%)
 rename test/helpers/{classlist.js => classlist.ts} (100%)
 rename test/helpers/{test-object-option.js => test-object-option.ts} (100%)
 rename test/helpers/{to-equal.js => to-equal.ts} (100%)
 rename test/helpers/{to-have-been-warned.js => to-have-been-warned.ts} (98%)
 rename test/helpers/{trigger-event.js => trigger-event.ts} (100%)
 rename test/helpers/{vdom.js => vdom.ts} (100%)
 rename test/helpers/{wait-for-update.js => wait-for-update.ts} (100%)
 rename test/ssr/{async-loader.js => async-loader.ts} (100%)
 rename test/ssr/{compile-with-webpack.js => compile-with-webpack.ts} (100%)
 rename test/ssr/fixtures/{app.js => app.ts} (100%)
 rename test/ssr/fixtures/{async-bar.js => async-bar.ts} (100%)
 rename test/ssr/fixtures/{async-foo.js => async-foo.ts} (100%)
 rename test/ssr/fixtures/{cache-opt-out.js => cache-opt-out.ts} (100%)
 rename test/ssr/fixtures/{cache.js => cache.ts} (100%)
 rename test/ssr/fixtures/{error.js => error.ts} (100%)
 rename test/ssr/fixtures/{nested-cache.js => nested-cache.ts} (100%)
 rename test/ssr/fixtures/{promise-rejection.js => promise-rejection.ts} (100%)
 rename test/ssr/fixtures/{split.js => split.ts} (100%)
 rename test/ssr/{jasmine.js => jasmine.ts} (100%)
 rename test/ssr/{ssr-basic-renderer.spec.js => ssr-basic-renderer.spec.ts} (100%)
 rename test/ssr/{ssr-bundle-render.spec.js => ssr-bundle-render.spec.ts} (100%)
 rename test/ssr/{ssr-stream.spec.js => ssr-stream.spec.ts} (100%)
 rename test/ssr/{ssr-string.spec.js => ssr-string.spec.ts} (100%)
 rename test/ssr/{ssr-template.spec.js => ssr-template.spec.ts} (100%)
 rename test/unit/features/component/{component-async.spec.js => component-async.spec.ts} (99%)
 rename test/unit/features/component/{component-keep-alive.spec.js => component-keep-alive.spec.ts} (100%)
 rename test/unit/features/component/{component-scoped-slot.spec.js => component-scoped-slot.spec.ts} (98%)
 rename test/unit/features/component/{component-slot.spec.js => component-slot.spec.ts} (99%)
 rename test/unit/features/component/{component.spec.js => component.spec.ts} (100%)
 rename test/unit/features/{debug.spec.js => debug.spec.ts} (100%)
 rename test/unit/features/directives/{bind.spec.js => bind.spec.ts} (100%)
 rename test/unit/features/directives/{class.spec.js => class.spec.ts} (100%)
 rename test/unit/features/directives/{cloak.spec.js => cloak.spec.ts} (100%)
 rename test/unit/features/directives/{for.spec.js => for.spec.ts} (100%)
 rename test/unit/features/directives/{html.spec.js => html.spec.ts} (100%)
 rename test/unit/features/directives/{if.spec.js => if.spec.ts} (100%)
 rename test/unit/features/directives/{model-checkbox.spec.js => model-checkbox.spec.ts} (100%)
 rename test/unit/features/directives/{model-component.spec.js => model-component.spec.ts} (100%)
 rename test/unit/features/directives/{model-dynamic.spec.js => model-dynamic.spec.ts} (100%)
 rename test/unit/features/directives/{model-file.spec.js => model-file.spec.ts} (100%)
 rename test/unit/features/directives/{model-parse.spec.js => model-parse.spec.ts} (100%)
 rename test/unit/features/directives/{model-radio.spec.js => model-radio.spec.ts} (100%)
 rename test/unit/features/directives/{model-select.spec.js => model-select.spec.ts} (100%)
 rename test/unit/features/directives/{model-text.spec.js => model-text.spec.ts} (100%)
 rename test/unit/features/directives/{on.spec.js => on.spec.ts} (100%)
 rename test/unit/features/directives/{once.spec.js => once.spec.ts} (100%)
 rename test/unit/features/directives/{pre.spec.js => pre.spec.ts} (100%)
 rename test/unit/features/directives/{show.spec.js => show.spec.ts} (100%)
 rename test/unit/features/directives/{static-style-parser.spec.js => static-style-parser.spec.ts} (100%)
 rename test/unit/features/directives/{style.spec.js => style.spec.ts} (100%)
 rename test/unit/features/directives/{text.spec.js => text.spec.ts} (100%)
 rename test/unit/features/{error-handling.spec.js => error-handling.spec.ts} (100%)
 rename test/unit/features/filter/{filter.spec.js => filter.spec.ts} (100%)
 rename test/unit/features/global-api/{assets.spec.js => assets.spec.ts} (100%)
 rename test/unit/features/global-api/{compile.spec.js => compile.spec.ts} (100%)
 rename test/unit/features/global-api/{config.spec.js => config.spec.ts} (100%)
 rename test/unit/features/global-api/{extend.spec.js => extend.spec.ts} (100%)
 rename test/unit/features/global-api/{mixin.spec.js => mixin.spec.ts} (100%)
 rename test/unit/features/global-api/{observable.spec.js => observable.spec.ts} (100%)
 rename test/unit/features/global-api/{set-delete.spec.js => set-delete.spec.ts} (100%)
 rename test/unit/features/global-api/{use.spec.js => use.spec.ts} (100%)
 rename test/unit/features/instance/{init.spec.js => init.spec.ts} (100%)
 rename test/unit/features/instance/{methods-data.spec.js => methods-data.spec.ts} (100%)
 rename test/unit/features/instance/{methods-events.spec.js => methods-events.spec.ts} (100%)
 rename test/unit/features/instance/{methods-lifecycle.spec.js => methods-lifecycle.spec.ts} (100%)
 rename test/unit/features/instance/{properties.spec.js => properties.spec.ts} (100%)
 rename test/unit/features/instance/{render-proxy.spec.js => render-proxy.spec.ts} (100%)
 rename test/unit/features/options/{_scopeId.spec.js => _scopeId.spec.ts} (100%)
 rename test/unit/features/options/{comments.spec.js => comments.spec.ts} (100%)
 rename test/unit/features/options/{components.spec.js => components.spec.ts} (100%)
 rename test/unit/features/options/{computed.spec.js => computed.spec.ts} (100%)
 rename test/unit/features/options/{data.spec.js => data.spec.ts} (100%)
 rename test/unit/features/options/{delimiters.spec.js => delimiters.spec.ts} (100%)
 rename test/unit/features/options/{directives.spec.js => directives.spec.ts} (100%)
 rename test/unit/features/options/{el.spec.js => el.spec.ts} (100%)
 rename test/unit/features/options/{errorCaptured.spec.js => errorCaptured.spec.ts} (100%)
 rename test/unit/features/options/{extends.spec.js => extends.spec.ts} (100%)
 rename test/unit/features/options/{functional.spec.js => functional.spec.ts} (100%)
 rename test/unit/features/options/{inheritAttrs.spec.js => inheritAttrs.spec.ts} (100%)
 rename test/unit/features/options/{inject.spec.js => inject.spec.ts} (100%)
 rename test/unit/features/options/{lifecycle.spec.js => lifecycle.spec.ts} (100%)
 rename test/unit/features/options/{methods.spec.js => methods.spec.ts} (100%)
 rename test/unit/features/options/{mixins.spec.js => mixins.spec.ts} (100%)
 rename test/unit/features/options/{name.spec.js => name.spec.ts} (100%)
 rename test/unit/features/options/{parent.spec.js => parent.spec.ts} (100%)
 rename test/unit/features/options/{props.spec.js => props.spec.ts} (100%)
 rename test/unit/features/options/{propsData.spec.js => propsData.spec.ts} (100%)
 rename test/unit/features/options/{render.spec.js => render.spec.ts} (100%)
 rename test/unit/features/options/{renderError.spec.js => renderError.spec.ts} (100%)
 rename test/unit/features/options/{template.spec.js => template.spec.ts} (100%)
 rename test/unit/features/options/{watch.spec.js => watch.spec.ts} (100%)
 rename test/unit/features/{ref.spec.js => ref.spec.ts} (100%)
 rename test/unit/features/transition/{inject-styles.js => inject-styles.ts} (100%)
 rename test/unit/features/transition/{transition-group.spec.js => transition-group.spec.ts} (100%)
 rename test/unit/features/transition/{transition-mode.spec.js => transition-mode.spec.ts} (100%)
 rename test/unit/features/transition/{transition.spec.js => transition.spec.ts} (100%)
 rename test/unit/{index.js => index.ts} (100%)
 rename test/unit/{karma.base.config.js => karma.base.config.ts} (91%)
 rename test/unit/{karma.cover.config.js => karma.cover.config.ts} (95%)
 rename test/unit/{karma.dev.config.js => karma.dev.config.ts} (85%)
 rename test/unit/{karma.sauce.config.js => karma.sauce.config.ts} (98%)
 rename test/unit/{karma.unit.config.js => karma.unit.config.ts} (86%)
 rename test/unit/modules/compiler/{codeframe.spec.js => codeframe.spec.ts} (100%)
 rename test/unit/modules/compiler/{codegen.spec.js => codegen.spec.ts} (100%)
 rename test/unit/modules/compiler/{compiler-options.spec.js => compiler-options.spec.ts} (100%)
 rename test/unit/modules/compiler/{optimizer.spec.js => optimizer.spec.ts} (100%)
 rename test/unit/modules/compiler/{parser.spec.js => parser.spec.ts} (100%)
 rename test/unit/modules/observer/{dep.spec.js => dep.spec.ts} (100%)
 rename test/unit/modules/observer/{observer.spec.js => observer.spec.ts} (100%)
 rename test/unit/modules/observer/{scheduler.spec.js => scheduler.spec.ts} (100%)
 rename test/unit/modules/observer/{watcher.spec.js => watcher.spec.ts} (100%)
 rename test/unit/modules/server-compiler/{compiler-options.spec.js => compiler-options.spec.ts} (100%)
 rename test/unit/modules/server-compiler/{optimizer.spec.js => optimizer.spec.ts} (100%)
 rename test/unit/modules/sfc/{sfc-parser.spec.js => sfc-parser.spec.ts} (100%)
 rename test/unit/modules/util/{error.spec.js => error.spec.ts} (100%)
 rename test/unit/modules/util/{next-tick.spec.js => next-tick.spec.ts} (100%)
 rename test/unit/modules/vdom/{create-component.spec.js => create-component.spec.ts} (100%)
 rename test/unit/modules/vdom/{create-element.spec.js => create-element.spec.ts} (100%)
 rename test/unit/modules/vdom/modules/{attrs.spec.js => attrs.spec.ts} (100%)
 rename test/unit/modules/vdom/modules/{class.spec.js => class.spec.ts} (100%)
 rename test/unit/modules/vdom/modules/{directive.spec.js => directive.spec.ts} (100%)
 rename test/unit/modules/vdom/modules/{dom-props.spec.js => dom-props.spec.ts} (100%)
 rename test/unit/modules/vdom/modules/{events.spec.js => events.spec.ts} (100%)
 rename test/unit/modules/vdom/modules/{style.spec.js => style.spec.ts} (100%)
 rename test/unit/modules/vdom/patch/{children.spec.js => children.spec.ts} (100%)
 rename test/unit/modules/vdom/patch/{edge-cases.spec.js => edge-cases.spec.ts} (100%)
 rename test/unit/modules/vdom/patch/{element.spec.js => element.spec.ts} (100%)
 rename test/unit/modules/vdom/patch/{hooks.spec.js => hooks.spec.ts} (100%)
 rename test/unit/modules/vdom/patch/{hydration.spec.js => hydration.spec.ts} (100%)
 rename test/weex/cases/{cases.spec.js => cases.spec.ts} (100%)
 rename test/weex/cases/event/{click.after.vdom.js => click.after.vdom.ts} (100%)
 rename test/weex/cases/event/{click.before.vdom.js => click.before.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{attrs.vdom.js => attrs.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{classname.vdom.js => classname.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/components/{stateful-lifecycle.vdom.js => stateful-lifecycle.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/components/{stateful-v-model.vdom.js => stateful-v-model.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/components/{stateful.vdom.js => stateful.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/components/{stateless-multi-components.vdom.js => stateless-multi-components.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/components/{stateless-with-props.vdom.js => stateless-with-props.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/components/{stateless.vdom.js => stateless.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{inline-style.vdom.js => inline-style.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{text-node.vdom.js => text-node.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-else-if.vdom.js => v-else-if.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-else.vdom.js => v-else.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-for-iterator.vdom.js => v-for-iterator.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-for.vdom.js => v-for.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-if.vdom.js => v-if.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-on-inline.vdom.js => v-on-inline.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-on.vdom.js => v-on.vdom.ts} (100%)
 rename test/weex/cases/recycle-list/{v-once.vdom.js => v-once.vdom.ts} (100%)
 rename test/weex/cases/render/{class.vdom.js => class.vdom.ts} (100%)
 rename test/weex/cases/render/{sample.vdom.js => sample.vdom.ts} (100%)
 rename test/weex/compiler/{append.spec.js => append.spec.ts} (100%)
 rename test/weex/compiler/{class.spec.js => class.spec.ts} (100%)
 rename test/weex/compiler/{compile.spec.js => compile.spec.ts} (100%)
 rename test/weex/compiler/{props.spec.js => props.spec.ts} (100%)
 rename test/weex/compiler/{style.spec.js => style.spec.ts} (100%)
 rename test/weex/compiler/{v-model.spec.js => v-model.spec.ts} (100%)
 rename test/weex/helpers/{index.js => index.ts} (100%)
 rename test/weex/{jasmine.js => jasmine.ts} (100%)
 rename test/weex/runtime/{attrs.spec.js => attrs.spec.ts} (100%)
 rename test/weex/runtime/{class.spec.js => class.spec.ts} (100%)
 rename test/weex/runtime/components/{richtext.spec.js => richtext.spec.ts} (100%)
 rename test/weex/runtime/{events.spec.js => events.spec.ts} (100%)
 rename test/weex/runtime/{framework.spec.js => framework.spec.ts} (100%)
 rename test/weex/runtime/{node.spec.js => node.spec.ts} (100%)
 rename test/weex/runtime/{style.spec.js => style.spec.ts} (100%)

diff --git a/package.json b/package.json
index 548096e73ae..c39fbb9e2c5 100644
--- a/package.json
+++ b/package.json
@@ -28,8 +28,8 @@
     "build:weex": "npm run build -- weex",
     "test": "npm run lint && flow check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
     "test:dtw": "npm run lint && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
-    "test:unit": "karma start test/unit/karma.unit.config.js",
-    "test:cover": "karma start test/unit/karma.cover.config.js",
+    "test:unit": "karma start test/unit/karma.unit.config.ts",
+    "test:cover": "karma start test/unit/karma.cover.config.ts",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.js",
     "test:weex": "npm run build:weex && jasmine-ts JASMINE_CONFIG_PATH=test/weex/jasmine.js",
     "test:ssr": "npm run build:ssr && jasmine JASMINE_CONFIG_PATH=test/ssr/jasmine.js",
@@ -81,8 +81,10 @@
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-node-resolve": "^13.2.1",
     "@rollup/plugin-replace": "^4.0.0",
+    "@types/jasmine": "^4.0.3",
     "@types/node": "^17.0.30",
     "@types/webpack": "^5.28.0",
+    "@types/webpack-env": "^1.16.4",
     "@typescript-eslint/eslint-plugin": "^5.21.0",
     "@typescript-eslint/parser": "^5.21.0",
     "acorn": "^8.7.1",
@@ -126,6 +128,7 @@
     "karma-safari-launcher": "^1.0.0",
     "karma-sauce-launcher": "^4.3.6",
     "karma-sourcemap-loader": "^0.3.8",
+    "karma-typescript": "^5.5.3",
     "karma-webpack": "^5.0.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index 158001268c1..0bff7f44ed6 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -92,7 +92,6 @@ export function nextTick(cb?: Function, ctx?: Object) {
       try {
         cb.call(ctx)
       } catch (e: any) {
-        // @ts-expect-error should it be any?
         handleError(e, ctx, 'nextTick')
       }
     } else if (_resolve) {
diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 9fbfff83ecc..302f1746d0f 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -121,7 +121,6 @@ function callHook(dir, hook, vnode, oldVnode, isDestroy?: any) {
     try {
       fn(vnode.elm, dir, vnode, oldVnode, isDestroy)
     } catch (e: any) {
-     // @ts-expect-error should it be any?
       handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`)
     }
   }
diff --git a/test/e2e/nightwatch.config.js b/test/e2e/nightwatch.config.ts
similarity index 100%
rename from test/e2e/nightwatch.config.js
rename to test/e2e/nightwatch.config.ts
diff --git a/test/e2e/runner.js b/test/e2e/runner.ts
similarity index 91%
rename from test/e2e/runner.js
rename to test/e2e/runner.ts
index dadce70d1d7..7baa4507fbb 100644
--- a/test/e2e/runner.js
+++ b/test/e2e/runner.ts
@@ -9,7 +9,7 @@ server.listen(8080)
 
 let args = process.argv.slice(2)
 if (args.indexOf('--config') === -1) {
-  args = args.concat(['--config', 'test/e2e/nightwatch.config.js'])
+  args = args.concat(['--config', 'test/e2e/nightwatch.config.ts'])
 }
 if (args.indexOf('--env') === -1) {
   args = args.concat(['--env', 'chrome,phantomjs'])
diff --git a/test/e2e/specs/async-edge-cases.js b/test/e2e/specs/async-edge-cases.ts
similarity index 100%
rename from test/e2e/specs/async-edge-cases.js
rename to test/e2e/specs/async-edge-cases.ts
diff --git a/test/e2e/specs/basic-ssr.js b/test/e2e/specs/basic-ssr.ts
similarity index 100%
rename from test/e2e/specs/basic-ssr.js
rename to test/e2e/specs/basic-ssr.ts
diff --git a/test/e2e/specs/commits.js b/test/e2e/specs/commits.ts
similarity index 100%
rename from test/e2e/specs/commits.js
rename to test/e2e/specs/commits.ts
diff --git a/test/e2e/specs/grid.js b/test/e2e/specs/grid.ts
similarity index 100%
rename from test/e2e/specs/grid.js
rename to test/e2e/specs/grid.ts
diff --git a/test/e2e/specs/markdown.js b/test/e2e/specs/markdown.ts
similarity index 100%
rename from test/e2e/specs/markdown.js
rename to test/e2e/specs/markdown.ts
diff --git a/test/e2e/specs/modal.js b/test/e2e/specs/modal.ts
similarity index 100%
rename from test/e2e/specs/modal.js
rename to test/e2e/specs/modal.ts
diff --git a/test/e2e/specs/select2.js b/test/e2e/specs/select2.ts
similarity index 100%
rename from test/e2e/specs/select2.js
rename to test/e2e/specs/select2.ts
diff --git a/test/e2e/specs/svg.js b/test/e2e/specs/svg.ts
similarity index 100%
rename from test/e2e/specs/svg.js
rename to test/e2e/specs/svg.ts
diff --git a/test/e2e/specs/todomvc.js b/test/e2e/specs/todomvc.ts
similarity index 100%
rename from test/e2e/specs/todomvc.js
rename to test/e2e/specs/todomvc.ts
diff --git a/test/e2e/specs/tree.js b/test/e2e/specs/tree.ts
similarity index 100%
rename from test/e2e/specs/tree.js
rename to test/e2e/specs/tree.ts
diff --git a/test/helpers/classlist.js b/test/helpers/classlist.ts
similarity index 100%
rename from test/helpers/classlist.js
rename to test/helpers/classlist.ts
diff --git a/test/helpers/test-object-option.js b/test/helpers/test-object-option.ts
similarity index 100%
rename from test/helpers/test-object-option.js
rename to test/helpers/test-object-option.ts
diff --git a/test/helpers/to-equal.js b/test/helpers/to-equal.ts
similarity index 100%
rename from test/helpers/to-equal.js
rename to test/helpers/to-equal.ts
diff --git a/test/helpers/to-have-been-warned.js b/test/helpers/to-have-been-warned.ts
similarity index 98%
rename from test/helpers/to-have-been-warned.js
rename to test/helpers/to-have-been-warned.ts
index b3a5eaae0e3..6928542a705 100644
--- a/test/helpers/to-have-been-warned.js
+++ b/test/helpers/to-have-been-warned.ts
@@ -1,6 +1,7 @@
 function noop () {}
 
 if (typeof console === 'undefined') {
+  // @ts-expect-error
   window.console = {
     warn: noop,
     error: noop
diff --git a/test/helpers/trigger-event.js b/test/helpers/trigger-event.ts
similarity index 100%
rename from test/helpers/trigger-event.js
rename to test/helpers/trigger-event.ts
diff --git a/test/helpers/vdom.js b/test/helpers/vdom.ts
similarity index 100%
rename from test/helpers/vdom.js
rename to test/helpers/vdom.ts
diff --git a/test/helpers/wait-for-update.js b/test/helpers/wait-for-update.ts
similarity index 100%
rename from test/helpers/wait-for-update.js
rename to test/helpers/wait-for-update.ts
diff --git a/test/ssr/async-loader.js b/test/ssr/async-loader.ts
similarity index 100%
rename from test/ssr/async-loader.js
rename to test/ssr/async-loader.ts
diff --git a/test/ssr/compile-with-webpack.js b/test/ssr/compile-with-webpack.ts
similarity index 100%
rename from test/ssr/compile-with-webpack.js
rename to test/ssr/compile-with-webpack.ts
diff --git a/test/ssr/fixtures/app.js b/test/ssr/fixtures/app.ts
similarity index 100%
rename from test/ssr/fixtures/app.js
rename to test/ssr/fixtures/app.ts
diff --git a/test/ssr/fixtures/async-bar.js b/test/ssr/fixtures/async-bar.ts
similarity index 100%
rename from test/ssr/fixtures/async-bar.js
rename to test/ssr/fixtures/async-bar.ts
diff --git a/test/ssr/fixtures/async-foo.js b/test/ssr/fixtures/async-foo.ts
similarity index 100%
rename from test/ssr/fixtures/async-foo.js
rename to test/ssr/fixtures/async-foo.ts
diff --git a/test/ssr/fixtures/cache-opt-out.js b/test/ssr/fixtures/cache-opt-out.ts
similarity index 100%
rename from test/ssr/fixtures/cache-opt-out.js
rename to test/ssr/fixtures/cache-opt-out.ts
diff --git a/test/ssr/fixtures/cache.js b/test/ssr/fixtures/cache.ts
similarity index 100%
rename from test/ssr/fixtures/cache.js
rename to test/ssr/fixtures/cache.ts
diff --git a/test/ssr/fixtures/error.js b/test/ssr/fixtures/error.ts
similarity index 100%
rename from test/ssr/fixtures/error.js
rename to test/ssr/fixtures/error.ts
diff --git a/test/ssr/fixtures/nested-cache.js b/test/ssr/fixtures/nested-cache.ts
similarity index 100%
rename from test/ssr/fixtures/nested-cache.js
rename to test/ssr/fixtures/nested-cache.ts
diff --git a/test/ssr/fixtures/promise-rejection.js b/test/ssr/fixtures/promise-rejection.ts
similarity index 100%
rename from test/ssr/fixtures/promise-rejection.js
rename to test/ssr/fixtures/promise-rejection.ts
diff --git a/test/ssr/fixtures/split.js b/test/ssr/fixtures/split.ts
similarity index 100%
rename from test/ssr/fixtures/split.js
rename to test/ssr/fixtures/split.ts
diff --git a/test/ssr/jasmine.js b/test/ssr/jasmine.ts
similarity index 100%
rename from test/ssr/jasmine.js
rename to test/ssr/jasmine.ts
diff --git a/test/ssr/ssr-basic-renderer.spec.js b/test/ssr/ssr-basic-renderer.spec.ts
similarity index 100%
rename from test/ssr/ssr-basic-renderer.spec.js
rename to test/ssr/ssr-basic-renderer.spec.ts
diff --git a/test/ssr/ssr-bundle-render.spec.js b/test/ssr/ssr-bundle-render.spec.ts
similarity index 100%
rename from test/ssr/ssr-bundle-render.spec.js
rename to test/ssr/ssr-bundle-render.spec.ts
diff --git a/test/ssr/ssr-stream.spec.js b/test/ssr/ssr-stream.spec.ts
similarity index 100%
rename from test/ssr/ssr-stream.spec.js
rename to test/ssr/ssr-stream.spec.ts
diff --git a/test/ssr/ssr-string.spec.js b/test/ssr/ssr-string.spec.ts
similarity index 100%
rename from test/ssr/ssr-string.spec.js
rename to test/ssr/ssr-string.spec.ts
diff --git a/test/ssr/ssr-template.spec.js b/test/ssr/ssr-template.spec.ts
similarity index 100%
rename from test/ssr/ssr-template.spec.js
rename to test/ssr/ssr-template.spec.ts
diff --git a/test/unit/features/component/component-async.spec.js b/test/unit/features/component/component-async.spec.ts
similarity index 99%
rename from test/unit/features/component/component-async.spec.js
rename to test/unit/features/component/component-async.spec.ts
index 8ce085de313..ce4f8624f37 100644
--- a/test/unit/features/component/component-async.spec.js
+++ b/test/unit/features/component/component-async.spec.ts
@@ -16,7 +16,7 @@ describe('Component async', () => {
     timeoutsPending = {};
 
     window.setTimeout = function(func, delay) {
-      let id = oldSetTimeout(function() {
+      const id = oldSetTimeout(function() {
         delete timeoutsPending[id];
         func();
       }, delay);
diff --git a/test/unit/features/component/component-keep-alive.spec.js b/test/unit/features/component/component-keep-alive.spec.ts
similarity index 100%
rename from test/unit/features/component/component-keep-alive.spec.js
rename to test/unit/features/component/component-keep-alive.spec.ts
diff --git a/test/unit/features/component/component-scoped-slot.spec.js b/test/unit/features/component/component-scoped-slot.spec.ts
similarity index 98%
rename from test/unit/features/component/component-scoped-slot.spec.js
rename to test/unit/features/component/component-scoped-slot.spec.ts
index a77b055ccd6..017097f53f2 100644
--- a/test/unit/features/component/component-scoped-slot.spec.js
+++ b/test/unit/features/component/component-scoped-slot.spec.ts
@@ -508,28 +508,28 @@ describe('Component scoped slot', () => {
     }).then(done)
   })
 
-  it('render function usage (JSX)', () => {
-    const vm = new Vue({
-      render (h) {
-        return <test>{
-          props => <span>{props.msg}</span>
-        }</test>
-      },
-      components: {
-        test: {
-          data () {
-            return { msg: 'hello' }
-          },
-          render (h) {
-            return <div>
-              {this.$scopedSlots.default({ msg: this.msg })}
-            </div>
-          }
-        }
-      }
-    }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-  })
+  // it('render function usage (JSX)', () => {
+  //   const vm = new Vue({
+  //     render (h) {
+  //       return (<test>{
+  //         props => <span>{props.msg}</span>
+  //       }</test>)
+  //     },
+  //     components: {
+  //       test: {
+  //         data () {
+  //           return { msg: 'hello' }
+  //         },
+  //         render (h) {
+  //           return <div>
+  //             {this.$scopedSlots.default({ msg: this.msg })}
+  //           </div>
+  //         }
+  //       }
+  //     }
+  //   }).$mount()
+  //   expect(vm.$el.innerHTML).toBe('<span>hello</span>')
+  // })
 
   // #5615
   it('scoped slot with v-for', done => {
diff --git a/test/unit/features/component/component-slot.spec.js b/test/unit/features/component/component-slot.spec.ts
similarity index 99%
rename from test/unit/features/component/component-slot.spec.js
rename to test/unit/features/component/component-slot.spec.ts
index 4412a1f0c7d..aeaf4615ac9 100644
--- a/test/unit/features/component/component-slot.spec.js
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -112,9 +112,9 @@ describe('Component slot', () => {
  it('it should work with previous versions of the templates', () => {
    const Test = {
       render() {
-        var _vm = this;
-        var _h = _vm.$createElement;
-        var _c = _vm._self._c || vm._h;
+        const _vm = this;
+        const _h = _vm.$createElement;
+        const _c = _vm._self._c || vm._h;
         return _c('div', [_vm._t("default", [_c('p', [_vm._v("slot default")])])], 2)
       }
     }
diff --git a/test/unit/features/component/component.spec.js b/test/unit/features/component/component.spec.ts
similarity index 100%
rename from test/unit/features/component/component.spec.js
rename to test/unit/features/component/component.spec.ts
diff --git a/test/unit/features/debug.spec.js b/test/unit/features/debug.spec.ts
similarity index 100%
rename from test/unit/features/debug.spec.js
rename to test/unit/features/debug.spec.ts
diff --git a/test/unit/features/directives/bind.spec.js b/test/unit/features/directives/bind.spec.ts
similarity index 100%
rename from test/unit/features/directives/bind.spec.js
rename to test/unit/features/directives/bind.spec.ts
diff --git a/test/unit/features/directives/class.spec.js b/test/unit/features/directives/class.spec.ts
similarity index 100%
rename from test/unit/features/directives/class.spec.js
rename to test/unit/features/directives/class.spec.ts
diff --git a/test/unit/features/directives/cloak.spec.js b/test/unit/features/directives/cloak.spec.ts
similarity index 100%
rename from test/unit/features/directives/cloak.spec.js
rename to test/unit/features/directives/cloak.spec.ts
diff --git a/test/unit/features/directives/for.spec.js b/test/unit/features/directives/for.spec.ts
similarity index 100%
rename from test/unit/features/directives/for.spec.js
rename to test/unit/features/directives/for.spec.ts
diff --git a/test/unit/features/directives/html.spec.js b/test/unit/features/directives/html.spec.ts
similarity index 100%
rename from test/unit/features/directives/html.spec.js
rename to test/unit/features/directives/html.spec.ts
diff --git a/test/unit/features/directives/if.spec.js b/test/unit/features/directives/if.spec.ts
similarity index 100%
rename from test/unit/features/directives/if.spec.js
rename to test/unit/features/directives/if.spec.ts
diff --git a/test/unit/features/directives/model-checkbox.spec.js b/test/unit/features/directives/model-checkbox.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-checkbox.spec.js
rename to test/unit/features/directives/model-checkbox.spec.ts
diff --git a/test/unit/features/directives/model-component.spec.js b/test/unit/features/directives/model-component.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-component.spec.js
rename to test/unit/features/directives/model-component.spec.ts
diff --git a/test/unit/features/directives/model-dynamic.spec.js b/test/unit/features/directives/model-dynamic.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-dynamic.spec.js
rename to test/unit/features/directives/model-dynamic.spec.ts
diff --git a/test/unit/features/directives/model-file.spec.js b/test/unit/features/directives/model-file.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-file.spec.js
rename to test/unit/features/directives/model-file.spec.ts
diff --git a/test/unit/features/directives/model-parse.spec.js b/test/unit/features/directives/model-parse.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-parse.spec.js
rename to test/unit/features/directives/model-parse.spec.ts
diff --git a/test/unit/features/directives/model-radio.spec.js b/test/unit/features/directives/model-radio.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-radio.spec.js
rename to test/unit/features/directives/model-radio.spec.ts
diff --git a/test/unit/features/directives/model-select.spec.js b/test/unit/features/directives/model-select.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-select.spec.js
rename to test/unit/features/directives/model-select.spec.ts
diff --git a/test/unit/features/directives/model-text.spec.js b/test/unit/features/directives/model-text.spec.ts
similarity index 100%
rename from test/unit/features/directives/model-text.spec.js
rename to test/unit/features/directives/model-text.spec.ts
diff --git a/test/unit/features/directives/on.spec.js b/test/unit/features/directives/on.spec.ts
similarity index 100%
rename from test/unit/features/directives/on.spec.js
rename to test/unit/features/directives/on.spec.ts
diff --git a/test/unit/features/directives/once.spec.js b/test/unit/features/directives/once.spec.ts
similarity index 100%
rename from test/unit/features/directives/once.spec.js
rename to test/unit/features/directives/once.spec.ts
diff --git a/test/unit/features/directives/pre.spec.js b/test/unit/features/directives/pre.spec.ts
similarity index 100%
rename from test/unit/features/directives/pre.spec.js
rename to test/unit/features/directives/pre.spec.ts
diff --git a/test/unit/features/directives/show.spec.js b/test/unit/features/directives/show.spec.ts
similarity index 100%
rename from test/unit/features/directives/show.spec.js
rename to test/unit/features/directives/show.spec.ts
diff --git a/test/unit/features/directives/static-style-parser.spec.js b/test/unit/features/directives/static-style-parser.spec.ts
similarity index 100%
rename from test/unit/features/directives/static-style-parser.spec.js
rename to test/unit/features/directives/static-style-parser.spec.ts
diff --git a/test/unit/features/directives/style.spec.js b/test/unit/features/directives/style.spec.ts
similarity index 100%
rename from test/unit/features/directives/style.spec.js
rename to test/unit/features/directives/style.spec.ts
diff --git a/test/unit/features/directives/text.spec.js b/test/unit/features/directives/text.spec.ts
similarity index 100%
rename from test/unit/features/directives/text.spec.js
rename to test/unit/features/directives/text.spec.ts
diff --git a/test/unit/features/error-handling.spec.js b/test/unit/features/error-handling.spec.ts
similarity index 100%
rename from test/unit/features/error-handling.spec.js
rename to test/unit/features/error-handling.spec.ts
diff --git a/test/unit/features/filter/filter.spec.js b/test/unit/features/filter/filter.spec.ts
similarity index 100%
rename from test/unit/features/filter/filter.spec.js
rename to test/unit/features/filter/filter.spec.ts
diff --git a/test/unit/features/global-api/assets.spec.js b/test/unit/features/global-api/assets.spec.ts
similarity index 100%
rename from test/unit/features/global-api/assets.spec.js
rename to test/unit/features/global-api/assets.spec.ts
diff --git a/test/unit/features/global-api/compile.spec.js b/test/unit/features/global-api/compile.spec.ts
similarity index 100%
rename from test/unit/features/global-api/compile.spec.js
rename to test/unit/features/global-api/compile.spec.ts
diff --git a/test/unit/features/global-api/config.spec.js b/test/unit/features/global-api/config.spec.ts
similarity index 100%
rename from test/unit/features/global-api/config.spec.js
rename to test/unit/features/global-api/config.spec.ts
diff --git a/test/unit/features/global-api/extend.spec.js b/test/unit/features/global-api/extend.spec.ts
similarity index 100%
rename from test/unit/features/global-api/extend.spec.js
rename to test/unit/features/global-api/extend.spec.ts
diff --git a/test/unit/features/global-api/mixin.spec.js b/test/unit/features/global-api/mixin.spec.ts
similarity index 100%
rename from test/unit/features/global-api/mixin.spec.js
rename to test/unit/features/global-api/mixin.spec.ts
diff --git a/test/unit/features/global-api/observable.spec.js b/test/unit/features/global-api/observable.spec.ts
similarity index 100%
rename from test/unit/features/global-api/observable.spec.js
rename to test/unit/features/global-api/observable.spec.ts
diff --git a/test/unit/features/global-api/set-delete.spec.js b/test/unit/features/global-api/set-delete.spec.ts
similarity index 100%
rename from test/unit/features/global-api/set-delete.spec.js
rename to test/unit/features/global-api/set-delete.spec.ts
diff --git a/test/unit/features/global-api/use.spec.js b/test/unit/features/global-api/use.spec.ts
similarity index 100%
rename from test/unit/features/global-api/use.spec.js
rename to test/unit/features/global-api/use.spec.ts
diff --git a/test/unit/features/instance/init.spec.js b/test/unit/features/instance/init.spec.ts
similarity index 100%
rename from test/unit/features/instance/init.spec.js
rename to test/unit/features/instance/init.spec.ts
diff --git a/test/unit/features/instance/methods-data.spec.js b/test/unit/features/instance/methods-data.spec.ts
similarity index 100%
rename from test/unit/features/instance/methods-data.spec.js
rename to test/unit/features/instance/methods-data.spec.ts
diff --git a/test/unit/features/instance/methods-events.spec.js b/test/unit/features/instance/methods-events.spec.ts
similarity index 100%
rename from test/unit/features/instance/methods-events.spec.js
rename to test/unit/features/instance/methods-events.spec.ts
diff --git a/test/unit/features/instance/methods-lifecycle.spec.js b/test/unit/features/instance/methods-lifecycle.spec.ts
similarity index 100%
rename from test/unit/features/instance/methods-lifecycle.spec.js
rename to test/unit/features/instance/methods-lifecycle.spec.ts
diff --git a/test/unit/features/instance/properties.spec.js b/test/unit/features/instance/properties.spec.ts
similarity index 100%
rename from test/unit/features/instance/properties.spec.js
rename to test/unit/features/instance/properties.spec.ts
diff --git a/test/unit/features/instance/render-proxy.spec.js b/test/unit/features/instance/render-proxy.spec.ts
similarity index 100%
rename from test/unit/features/instance/render-proxy.spec.js
rename to test/unit/features/instance/render-proxy.spec.ts
diff --git a/test/unit/features/options/_scopeId.spec.js b/test/unit/features/options/_scopeId.spec.ts
similarity index 100%
rename from test/unit/features/options/_scopeId.spec.js
rename to test/unit/features/options/_scopeId.spec.ts
diff --git a/test/unit/features/options/comments.spec.js b/test/unit/features/options/comments.spec.ts
similarity index 100%
rename from test/unit/features/options/comments.spec.js
rename to test/unit/features/options/comments.spec.ts
diff --git a/test/unit/features/options/components.spec.js b/test/unit/features/options/components.spec.ts
similarity index 100%
rename from test/unit/features/options/components.spec.js
rename to test/unit/features/options/components.spec.ts
diff --git a/test/unit/features/options/computed.spec.js b/test/unit/features/options/computed.spec.ts
similarity index 100%
rename from test/unit/features/options/computed.spec.js
rename to test/unit/features/options/computed.spec.ts
diff --git a/test/unit/features/options/data.spec.js b/test/unit/features/options/data.spec.ts
similarity index 100%
rename from test/unit/features/options/data.spec.js
rename to test/unit/features/options/data.spec.ts
diff --git a/test/unit/features/options/delimiters.spec.js b/test/unit/features/options/delimiters.spec.ts
similarity index 100%
rename from test/unit/features/options/delimiters.spec.js
rename to test/unit/features/options/delimiters.spec.ts
diff --git a/test/unit/features/options/directives.spec.js b/test/unit/features/options/directives.spec.ts
similarity index 100%
rename from test/unit/features/options/directives.spec.js
rename to test/unit/features/options/directives.spec.ts
diff --git a/test/unit/features/options/el.spec.js b/test/unit/features/options/el.spec.ts
similarity index 100%
rename from test/unit/features/options/el.spec.js
rename to test/unit/features/options/el.spec.ts
diff --git a/test/unit/features/options/errorCaptured.spec.js b/test/unit/features/options/errorCaptured.spec.ts
similarity index 100%
rename from test/unit/features/options/errorCaptured.spec.js
rename to test/unit/features/options/errorCaptured.spec.ts
diff --git a/test/unit/features/options/extends.spec.js b/test/unit/features/options/extends.spec.ts
similarity index 100%
rename from test/unit/features/options/extends.spec.js
rename to test/unit/features/options/extends.spec.ts
diff --git a/test/unit/features/options/functional.spec.js b/test/unit/features/options/functional.spec.ts
similarity index 100%
rename from test/unit/features/options/functional.spec.js
rename to test/unit/features/options/functional.spec.ts
diff --git a/test/unit/features/options/inheritAttrs.spec.js b/test/unit/features/options/inheritAttrs.spec.ts
similarity index 100%
rename from test/unit/features/options/inheritAttrs.spec.js
rename to test/unit/features/options/inheritAttrs.spec.ts
diff --git a/test/unit/features/options/inject.spec.js b/test/unit/features/options/inject.spec.ts
similarity index 100%
rename from test/unit/features/options/inject.spec.js
rename to test/unit/features/options/inject.spec.ts
diff --git a/test/unit/features/options/lifecycle.spec.js b/test/unit/features/options/lifecycle.spec.ts
similarity index 100%
rename from test/unit/features/options/lifecycle.spec.js
rename to test/unit/features/options/lifecycle.spec.ts
diff --git a/test/unit/features/options/methods.spec.js b/test/unit/features/options/methods.spec.ts
similarity index 100%
rename from test/unit/features/options/methods.spec.js
rename to test/unit/features/options/methods.spec.ts
diff --git a/test/unit/features/options/mixins.spec.js b/test/unit/features/options/mixins.spec.ts
similarity index 100%
rename from test/unit/features/options/mixins.spec.js
rename to test/unit/features/options/mixins.spec.ts
diff --git a/test/unit/features/options/name.spec.js b/test/unit/features/options/name.spec.ts
similarity index 100%
rename from test/unit/features/options/name.spec.js
rename to test/unit/features/options/name.spec.ts
diff --git a/test/unit/features/options/parent.spec.js b/test/unit/features/options/parent.spec.ts
similarity index 100%
rename from test/unit/features/options/parent.spec.js
rename to test/unit/features/options/parent.spec.ts
diff --git a/test/unit/features/options/props.spec.js b/test/unit/features/options/props.spec.ts
similarity index 100%
rename from test/unit/features/options/props.spec.js
rename to test/unit/features/options/props.spec.ts
diff --git a/test/unit/features/options/propsData.spec.js b/test/unit/features/options/propsData.spec.ts
similarity index 100%
rename from test/unit/features/options/propsData.spec.js
rename to test/unit/features/options/propsData.spec.ts
diff --git a/test/unit/features/options/render.spec.js b/test/unit/features/options/render.spec.ts
similarity index 100%
rename from test/unit/features/options/render.spec.js
rename to test/unit/features/options/render.spec.ts
diff --git a/test/unit/features/options/renderError.spec.js b/test/unit/features/options/renderError.spec.ts
similarity index 100%
rename from test/unit/features/options/renderError.spec.js
rename to test/unit/features/options/renderError.spec.ts
diff --git a/test/unit/features/options/template.spec.js b/test/unit/features/options/template.spec.ts
similarity index 100%
rename from test/unit/features/options/template.spec.js
rename to test/unit/features/options/template.spec.ts
diff --git a/test/unit/features/options/watch.spec.js b/test/unit/features/options/watch.spec.ts
similarity index 100%
rename from test/unit/features/options/watch.spec.js
rename to test/unit/features/options/watch.spec.ts
diff --git a/test/unit/features/ref.spec.js b/test/unit/features/ref.spec.ts
similarity index 100%
rename from test/unit/features/ref.spec.js
rename to test/unit/features/ref.spec.ts
diff --git a/test/unit/features/transition/inject-styles.js b/test/unit/features/transition/inject-styles.ts
similarity index 100%
rename from test/unit/features/transition/inject-styles.js
rename to test/unit/features/transition/inject-styles.ts
diff --git a/test/unit/features/transition/transition-group.spec.js b/test/unit/features/transition/transition-group.spec.ts
similarity index 100%
rename from test/unit/features/transition/transition-group.spec.js
rename to test/unit/features/transition/transition-group.spec.ts
diff --git a/test/unit/features/transition/transition-mode.spec.js b/test/unit/features/transition/transition-mode.spec.ts
similarity index 100%
rename from test/unit/features/transition/transition-mode.spec.js
rename to test/unit/features/transition/transition-mode.spec.ts
diff --git a/test/unit/features/transition/transition.spec.js b/test/unit/features/transition/transition.spec.ts
similarity index 100%
rename from test/unit/features/transition/transition.spec.js
rename to test/unit/features/transition/transition.spec.ts
diff --git a/test/unit/index.js b/test/unit/index.ts
similarity index 100%
rename from test/unit/index.js
rename to test/unit/index.ts
diff --git a/test/unit/karma.base.config.js b/test/unit/karma.base.config.ts
similarity index 91%
rename from test/unit/karma.base.config.js
rename to test/unit/karma.base.config.ts
index 00a386d4de1..29293ae53cc 100644
--- a/test/unit/karma.base.config.js
+++ b/test/unit/karma.base.config.ts
@@ -39,10 +39,10 @@ const webpackConfig = {
 module.exports = {
   frameworks: ['jasmine'],
   files: [
-    './index.js'
+    './index.ts'
   ],
   preprocessors: {
-    './index.js': ['webpack', 'sourcemap']
+    './index.ts': ['webpack', 'sourcemap']
   },
   webpack: webpackConfig,
   webpackMiddleware: {
@@ -52,6 +52,7 @@ module.exports = {
     'karma-jasmine',
     'karma-mocha-reporter',
     'karma-sourcemap-loader',
-    'karma-webpack'
+    'karma-webpack',
+    'karma-typescript'
   ]
 }
diff --git a/test/unit/karma.cover.config.js b/test/unit/karma.cover.config.ts
similarity index 95%
rename from test/unit/karma.cover.config.js
rename to test/unit/karma.cover.config.ts
index 639cec462cb..062138e5058 100644
--- a/test/unit/karma.cover.config.js
+++ b/test/unit/karma.cover.config.ts
@@ -1,4 +1,4 @@
-const base = require('./karma.base.config.js')
+const base = require('./karma.base.config.ts')
 
 process.env.CHROME_BIN = require('puppeteer').executablePath()
 
diff --git a/test/unit/karma.dev.config.js b/test/unit/karma.dev.config.ts
similarity index 85%
rename from test/unit/karma.dev.config.js
rename to test/unit/karma.dev.config.ts
index b9b01b2200c..e04e13561ae 100644
--- a/test/unit/karma.dev.config.js
+++ b/test/unit/karma.dev.config.ts
@@ -1,4 +1,4 @@
-const base = require('./karma.base.config.js')
+const base = require('./karma.base.config.ts')
 
 process.env.CHROME_BIN = require('puppeteer').executablePath()
 
diff --git a/test/unit/karma.sauce.config.js b/test/unit/karma.sauce.config.ts
similarity index 98%
rename from test/unit/karma.sauce.config.js
rename to test/unit/karma.sauce.config.ts
index 0c4ab2270b1..a3bc8a61185 100644
--- a/test/unit/karma.sauce.config.js
+++ b/test/unit/karma.sauce.config.ts
@@ -1,5 +1,5 @@
 const webpack = require('webpack')
-const base = require('./karma.base.config.js')
+const base = require('./karma.base.config.ts')
 
 base.webpack.plugins = [
   new webpack.DefinePlugin({
diff --git a/test/unit/karma.unit.config.js b/test/unit/karma.unit.config.ts
similarity index 86%
rename from test/unit/karma.unit.config.js
rename to test/unit/karma.unit.config.ts
index a9337064a9d..49867dfb4a7 100644
--- a/test/unit/karma.unit.config.js
+++ b/test/unit/karma.unit.config.ts
@@ -1,4 +1,4 @@
-const base = require('./karma.base.config.js')
+const base = require('./karma.base.config.ts')
 
 module.exports = function (config) {
   config.set(Object.assign(base, {
diff --git a/test/unit/modules/compiler/codeframe.spec.js b/test/unit/modules/compiler/codeframe.spec.ts
similarity index 100%
rename from test/unit/modules/compiler/codeframe.spec.js
rename to test/unit/modules/compiler/codeframe.spec.ts
diff --git a/test/unit/modules/compiler/codegen.spec.js b/test/unit/modules/compiler/codegen.spec.ts
similarity index 100%
rename from test/unit/modules/compiler/codegen.spec.js
rename to test/unit/modules/compiler/codegen.spec.ts
diff --git a/test/unit/modules/compiler/compiler-options.spec.js b/test/unit/modules/compiler/compiler-options.spec.ts
similarity index 100%
rename from test/unit/modules/compiler/compiler-options.spec.js
rename to test/unit/modules/compiler/compiler-options.spec.ts
diff --git a/test/unit/modules/compiler/optimizer.spec.js b/test/unit/modules/compiler/optimizer.spec.ts
similarity index 100%
rename from test/unit/modules/compiler/optimizer.spec.js
rename to test/unit/modules/compiler/optimizer.spec.ts
diff --git a/test/unit/modules/compiler/parser.spec.js b/test/unit/modules/compiler/parser.spec.ts
similarity index 100%
rename from test/unit/modules/compiler/parser.spec.js
rename to test/unit/modules/compiler/parser.spec.ts
diff --git a/test/unit/modules/observer/dep.spec.js b/test/unit/modules/observer/dep.spec.ts
similarity index 100%
rename from test/unit/modules/observer/dep.spec.js
rename to test/unit/modules/observer/dep.spec.ts
diff --git a/test/unit/modules/observer/observer.spec.js b/test/unit/modules/observer/observer.spec.ts
similarity index 100%
rename from test/unit/modules/observer/observer.spec.js
rename to test/unit/modules/observer/observer.spec.ts
diff --git a/test/unit/modules/observer/scheduler.spec.js b/test/unit/modules/observer/scheduler.spec.ts
similarity index 100%
rename from test/unit/modules/observer/scheduler.spec.js
rename to test/unit/modules/observer/scheduler.spec.ts
diff --git a/test/unit/modules/observer/watcher.spec.js b/test/unit/modules/observer/watcher.spec.ts
similarity index 100%
rename from test/unit/modules/observer/watcher.spec.js
rename to test/unit/modules/observer/watcher.spec.ts
diff --git a/test/unit/modules/server-compiler/compiler-options.spec.js b/test/unit/modules/server-compiler/compiler-options.spec.ts
similarity index 100%
rename from test/unit/modules/server-compiler/compiler-options.spec.js
rename to test/unit/modules/server-compiler/compiler-options.spec.ts
diff --git a/test/unit/modules/server-compiler/optimizer.spec.js b/test/unit/modules/server-compiler/optimizer.spec.ts
similarity index 100%
rename from test/unit/modules/server-compiler/optimizer.spec.js
rename to test/unit/modules/server-compiler/optimizer.spec.ts
diff --git a/test/unit/modules/sfc/sfc-parser.spec.js b/test/unit/modules/sfc/sfc-parser.spec.ts
similarity index 100%
rename from test/unit/modules/sfc/sfc-parser.spec.js
rename to test/unit/modules/sfc/sfc-parser.spec.ts
diff --git a/test/unit/modules/util/error.spec.js b/test/unit/modules/util/error.spec.ts
similarity index 100%
rename from test/unit/modules/util/error.spec.js
rename to test/unit/modules/util/error.spec.ts
diff --git a/test/unit/modules/util/next-tick.spec.js b/test/unit/modules/util/next-tick.spec.ts
similarity index 100%
rename from test/unit/modules/util/next-tick.spec.js
rename to test/unit/modules/util/next-tick.spec.ts
diff --git a/test/unit/modules/vdom/create-component.spec.js b/test/unit/modules/vdom/create-component.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/create-component.spec.js
rename to test/unit/modules/vdom/create-component.spec.ts
diff --git a/test/unit/modules/vdom/create-element.spec.js b/test/unit/modules/vdom/create-element.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/create-element.spec.js
rename to test/unit/modules/vdom/create-element.spec.ts
diff --git a/test/unit/modules/vdom/modules/attrs.spec.js b/test/unit/modules/vdom/modules/attrs.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/modules/attrs.spec.js
rename to test/unit/modules/vdom/modules/attrs.spec.ts
diff --git a/test/unit/modules/vdom/modules/class.spec.js b/test/unit/modules/vdom/modules/class.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/modules/class.spec.js
rename to test/unit/modules/vdom/modules/class.spec.ts
diff --git a/test/unit/modules/vdom/modules/directive.spec.js b/test/unit/modules/vdom/modules/directive.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/modules/directive.spec.js
rename to test/unit/modules/vdom/modules/directive.spec.ts
diff --git a/test/unit/modules/vdom/modules/dom-props.spec.js b/test/unit/modules/vdom/modules/dom-props.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/modules/dom-props.spec.js
rename to test/unit/modules/vdom/modules/dom-props.spec.ts
diff --git a/test/unit/modules/vdom/modules/events.spec.js b/test/unit/modules/vdom/modules/events.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/modules/events.spec.js
rename to test/unit/modules/vdom/modules/events.spec.ts
diff --git a/test/unit/modules/vdom/modules/style.spec.js b/test/unit/modules/vdom/modules/style.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/modules/style.spec.js
rename to test/unit/modules/vdom/modules/style.spec.ts
diff --git a/test/unit/modules/vdom/patch/children.spec.js b/test/unit/modules/vdom/patch/children.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/patch/children.spec.js
rename to test/unit/modules/vdom/patch/children.spec.ts
diff --git a/test/unit/modules/vdom/patch/edge-cases.spec.js b/test/unit/modules/vdom/patch/edge-cases.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/patch/edge-cases.spec.js
rename to test/unit/modules/vdom/patch/edge-cases.spec.ts
diff --git a/test/unit/modules/vdom/patch/element.spec.js b/test/unit/modules/vdom/patch/element.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/patch/element.spec.js
rename to test/unit/modules/vdom/patch/element.spec.ts
diff --git a/test/unit/modules/vdom/patch/hooks.spec.js b/test/unit/modules/vdom/patch/hooks.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/patch/hooks.spec.js
rename to test/unit/modules/vdom/patch/hooks.spec.ts
diff --git a/test/unit/modules/vdom/patch/hydration.spec.js b/test/unit/modules/vdom/patch/hydration.spec.ts
similarity index 100%
rename from test/unit/modules/vdom/patch/hydration.spec.js
rename to test/unit/modules/vdom/patch/hydration.spec.ts
diff --git a/test/weex/cases/cases.spec.js b/test/weex/cases/cases.spec.ts
similarity index 100%
rename from test/weex/cases/cases.spec.js
rename to test/weex/cases/cases.spec.ts
diff --git a/test/weex/cases/event/click.after.vdom.js b/test/weex/cases/event/click.after.vdom.ts
similarity index 100%
rename from test/weex/cases/event/click.after.vdom.js
rename to test/weex/cases/event/click.after.vdom.ts
diff --git a/test/weex/cases/event/click.before.vdom.js b/test/weex/cases/event/click.before.vdom.ts
similarity index 100%
rename from test/weex/cases/event/click.before.vdom.js
rename to test/weex/cases/event/click.before.vdom.ts
diff --git a/test/weex/cases/recycle-list/attrs.vdom.js b/test/weex/cases/recycle-list/attrs.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/attrs.vdom.js
rename to test/weex/cases/recycle-list/attrs.vdom.ts
diff --git a/test/weex/cases/recycle-list/classname.vdom.js b/test/weex/cases/recycle-list/classname.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/classname.vdom.js
rename to test/weex/cases/recycle-list/classname.vdom.ts
diff --git a/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.js b/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.js
rename to test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.ts
diff --git a/test/weex/cases/recycle-list/components/stateful-v-model.vdom.js b/test/weex/cases/recycle-list/components/stateful-v-model.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/components/stateful-v-model.vdom.js
rename to test/weex/cases/recycle-list/components/stateful-v-model.vdom.ts
diff --git a/test/weex/cases/recycle-list/components/stateful.vdom.js b/test/weex/cases/recycle-list/components/stateful.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/components/stateful.vdom.js
rename to test/weex/cases/recycle-list/components/stateful.vdom.ts
diff --git a/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.js b/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/components/stateless-multi-components.vdom.js
rename to test/weex/cases/recycle-list/components/stateless-multi-components.vdom.ts
diff --git a/test/weex/cases/recycle-list/components/stateless-with-props.vdom.js b/test/weex/cases/recycle-list/components/stateless-with-props.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/components/stateless-with-props.vdom.js
rename to test/weex/cases/recycle-list/components/stateless-with-props.vdom.ts
diff --git a/test/weex/cases/recycle-list/components/stateless.vdom.js b/test/weex/cases/recycle-list/components/stateless.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/components/stateless.vdom.js
rename to test/weex/cases/recycle-list/components/stateless.vdom.ts
diff --git a/test/weex/cases/recycle-list/inline-style.vdom.js b/test/weex/cases/recycle-list/inline-style.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/inline-style.vdom.js
rename to test/weex/cases/recycle-list/inline-style.vdom.ts
diff --git a/test/weex/cases/recycle-list/text-node.vdom.js b/test/weex/cases/recycle-list/text-node.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/text-node.vdom.js
rename to test/weex/cases/recycle-list/text-node.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-else-if.vdom.js b/test/weex/cases/recycle-list/v-else-if.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-else-if.vdom.js
rename to test/weex/cases/recycle-list/v-else-if.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-else.vdom.js b/test/weex/cases/recycle-list/v-else.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-else.vdom.js
rename to test/weex/cases/recycle-list/v-else.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-for-iterator.vdom.js b/test/weex/cases/recycle-list/v-for-iterator.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-for-iterator.vdom.js
rename to test/weex/cases/recycle-list/v-for-iterator.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-for.vdom.js b/test/weex/cases/recycle-list/v-for.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-for.vdom.js
rename to test/weex/cases/recycle-list/v-for.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-if.vdom.js b/test/weex/cases/recycle-list/v-if.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-if.vdom.js
rename to test/weex/cases/recycle-list/v-if.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-on-inline.vdom.js b/test/weex/cases/recycle-list/v-on-inline.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-on-inline.vdom.js
rename to test/weex/cases/recycle-list/v-on-inline.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-on.vdom.js b/test/weex/cases/recycle-list/v-on.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-on.vdom.js
rename to test/weex/cases/recycle-list/v-on.vdom.ts
diff --git a/test/weex/cases/recycle-list/v-once.vdom.js b/test/weex/cases/recycle-list/v-once.vdom.ts
similarity index 100%
rename from test/weex/cases/recycle-list/v-once.vdom.js
rename to test/weex/cases/recycle-list/v-once.vdom.ts
diff --git a/test/weex/cases/render/class.vdom.js b/test/weex/cases/render/class.vdom.ts
similarity index 100%
rename from test/weex/cases/render/class.vdom.js
rename to test/weex/cases/render/class.vdom.ts
diff --git a/test/weex/cases/render/sample.vdom.js b/test/weex/cases/render/sample.vdom.ts
similarity index 100%
rename from test/weex/cases/render/sample.vdom.js
rename to test/weex/cases/render/sample.vdom.ts
diff --git a/test/weex/compiler/append.spec.js b/test/weex/compiler/append.spec.ts
similarity index 100%
rename from test/weex/compiler/append.spec.js
rename to test/weex/compiler/append.spec.ts
diff --git a/test/weex/compiler/class.spec.js b/test/weex/compiler/class.spec.ts
similarity index 100%
rename from test/weex/compiler/class.spec.js
rename to test/weex/compiler/class.spec.ts
diff --git a/test/weex/compiler/compile.spec.js b/test/weex/compiler/compile.spec.ts
similarity index 100%
rename from test/weex/compiler/compile.spec.js
rename to test/weex/compiler/compile.spec.ts
diff --git a/test/weex/compiler/props.spec.js b/test/weex/compiler/props.spec.ts
similarity index 100%
rename from test/weex/compiler/props.spec.js
rename to test/weex/compiler/props.spec.ts
diff --git a/test/weex/compiler/style.spec.js b/test/weex/compiler/style.spec.ts
similarity index 100%
rename from test/weex/compiler/style.spec.js
rename to test/weex/compiler/style.spec.ts
diff --git a/test/weex/compiler/v-model.spec.js b/test/weex/compiler/v-model.spec.ts
similarity index 100%
rename from test/weex/compiler/v-model.spec.js
rename to test/weex/compiler/v-model.spec.ts
diff --git a/test/weex/helpers/index.js b/test/weex/helpers/index.ts
similarity index 100%
rename from test/weex/helpers/index.js
rename to test/weex/helpers/index.ts
diff --git a/test/weex/jasmine.js b/test/weex/jasmine.ts
similarity index 100%
rename from test/weex/jasmine.js
rename to test/weex/jasmine.ts
diff --git a/test/weex/runtime/attrs.spec.js b/test/weex/runtime/attrs.spec.ts
similarity index 100%
rename from test/weex/runtime/attrs.spec.js
rename to test/weex/runtime/attrs.spec.ts
diff --git a/test/weex/runtime/class.spec.js b/test/weex/runtime/class.spec.ts
similarity index 100%
rename from test/weex/runtime/class.spec.js
rename to test/weex/runtime/class.spec.ts
diff --git a/test/weex/runtime/components/richtext.spec.js b/test/weex/runtime/components/richtext.spec.ts
similarity index 100%
rename from test/weex/runtime/components/richtext.spec.js
rename to test/weex/runtime/components/richtext.spec.ts
diff --git a/test/weex/runtime/events.spec.js b/test/weex/runtime/events.spec.ts
similarity index 100%
rename from test/weex/runtime/events.spec.js
rename to test/weex/runtime/events.spec.ts
diff --git a/test/weex/runtime/framework.spec.js b/test/weex/runtime/framework.spec.ts
similarity index 100%
rename from test/weex/runtime/framework.spec.js
rename to test/weex/runtime/framework.spec.ts
diff --git a/test/weex/runtime/node.spec.js b/test/weex/runtime/node.spec.ts
similarity index 100%
rename from test/weex/runtime/node.spec.js
rename to test/weex/runtime/node.spec.ts
diff --git a/test/weex/runtime/style.spec.js b/test/weex/runtime/style.spec.ts
similarity index 100%
rename from test/weex/runtime/style.spec.js
rename to test/weex/runtime/style.spec.ts
diff --git a/tsconfig.json b/tsconfig.json
index 38ad99633d5..69392b18633 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,7 +19,12 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": ["node"],
+    "types": [
+      "node",
+      "karma",
+      "jasmine",
+      "webpack-env"
+    ],
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
diff --git a/types/test/tsconfig.json b/types/test/tsconfig.json
index dab30a608bf..03e33c3034f 100644
--- a/types/test/tsconfig.json
+++ b/types/test/tsconfig.json
@@ -1,11 +1,16 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "es5zdfasdfasdf",
     "experimentalDecorators": true,
     "lib": [
       "dom",
       "es2015"
     ],
+    "types": [
+      "jasmine",
+      "@types/karma",
+      "webpack-env"
+    ],
     "module": "commonjs",
     "strict": true,
     "noEmit": true,
diff --git a/yarn.lock b/yarn.lock
index eab008d3388..13c0a66e77c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -22,7 +22,7 @@
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.10.tgz#711dc726a492dfc8be8220028b1b92482362baab"
   integrity sha512-GZt/TCsG70Ms19gfZO1tM4CVnXsPgEPBCpJu+Qz3L0LUDsY5nZqFZglIoPC1kIYOtNBZlrnFT+klg12vFGZXrw==
 
-"@babel/core@^7.12.3", "@babel/core@^7.17.10":
+"@babel/core@^7.12.3", "@babel/core@^7.17.10", "@babel/core@^7.7.5":
   version "7.17.10"
   resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.10.tgz#74ef0fbf56b7dfc3f198fc2d927f4f03e12f4b05"
   integrity sha512-liKoppandF3ZcBnIYFjfSDHZLKdLHGJRkoWtG8zQyGJBQfIYobpnVGI5+pLBNtS6psFLDzyq8+h5HiVljW9PNA==
@@ -1292,6 +1292,19 @@
   resolved "https://registry.yarnpkg.com/@types/http-cache-semantics/-/http-cache-semantics-4.0.1.tgz#0ea7b61496902b95890dc4c3a116b60cb8dae812"
   integrity sha512-SZs7ekbP8CN0txVG2xVRH6EgKmEm31BOxA07vkFaETzZz1xh+cbt8BcI0slpymvwhx5dlFnQG2rTlPVQn+iRPQ==
 
+"@types/jasmine@^4.0.3":
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/@types/jasmine/-/jasmine-4.0.3.tgz#097ce710d70eb7f3662e96c1f75824dd22c27d5c"
+  integrity sha512-Opp1LvvEuZdk8fSSvchK2mZwhVrsNT0JgJE9Di6MjnaIpmEXM8TLCPPrVtNTYh8+5MPdY8j9bAHMu2SSfwpZJg==
+
+"@types/jest@^27.4.1":
+  version "27.4.1"
+  resolved "https://registry.yarnpkg.com/@types/jest/-/jest-27.4.1.tgz#185cbe2926eaaf9662d340cc02e548ce9e11ab6d"
+  integrity sha512-23iPJADSmicDVrWk+HT58LMJtzLAnB2AgIzplQuq/bSrGaxCrlvRFjGbXmamnnk/mAmCdLStiGqggu28ocUyiw==
+  dependencies:
+    jest-matcher-utils "^27.0.0"
+    pretty-format "^27.0.0"
+
 "@types/json-buffer@~3.0.0":
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/@types/json-buffer/-/json-buffer-3.0.0.tgz#85c1ff0f0948fc159810d4b5be35bf8c20875f64"
@@ -1357,6 +1370,11 @@
   dependencies:
     "@types/node" "*"
 
+"@types/webpack-env@^1.16.4":
+  version "1.16.4"
+  resolved "https://registry.yarnpkg.com/@types/webpack-env/-/webpack-env-1.16.4.tgz#1f4969042bf76d7ef7b5914f59b3b60073f4e1f4"
+  integrity sha512-llS8qveOUX3wxHnSykP5hlYFFuMfJ9p5JvIyCiBgp7WTfl6K5ZcyHj8r8JsN/J6QODkAsRRCLIcTuOCu8etkUw==
+
 "@types/webpack@^5.28.0":
   version "5.28.0"
   resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-5.28.0.tgz#78dde06212f038d77e54116cfe69e88ae9ed2c03"
@@ -1672,7 +1690,7 @@ acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
 
-acorn-walk@^8.1.1, acorn-walk@^8.2.0:
+acorn-walk@^8.0.2, acorn-walk@^8.1.1, acorn-walk@^8.2.0:
   version "8.2.0"
   resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
   integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
@@ -1682,7 +1700,7 @@ acorn@^6.4.1:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
   integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
 
-acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
+acorn@^8.1.0, acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
   version "8.7.1"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30"
   integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==
@@ -1795,6 +1813,11 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   dependencies:
     color-convert "^2.0.1"
 
+ansi-styles@^5.0.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
+  integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
+
 ansi-styles@^6.0.0:
   version "6.1.0"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.1.0.tgz#87313c102b8118abd57371afab34618bf7350ed3"
@@ -1886,6 +1909,16 @@ arrify@^1.0.1:
   resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
   integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=
 
+asn1.js@^5.2.0:
+  version "5.4.1"
+  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-5.4.1.tgz#11a980b84ebb91781ce35b0fdc2ee294e3783f07"
+  integrity sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==
+  dependencies:
+    bn.js "^4.0.0"
+    inherits "^2.0.1"
+    minimalistic-assert "^1.0.0"
+    safer-buffer "^2.1.0"
+
 asn1@~0.2.3:
   version "0.2.6"
   resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.6.tgz#0d3a7bb6e64e02a90c0303b31f292868ea09a08d"
@@ -1898,6 +1931,16 @@ assert-plus@1.0.0, assert-plus@^1.0.0:
   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 
+assert@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/assert/-/assert-2.0.0.tgz#95fc1c616d48713510680f2eaf2d10dd22e02d32"
+  integrity sha512-se5Cd+js9dXJnu6Ag2JFc00t+HmHOen+8Q+L7O9zI0PqQXr20uk2J0XQqMxZEeo5U50o8Nvmmx7dZrl+Ufr35A==
+  dependencies:
+    es6-object-assign "^1.1.0"
+    is-nan "^1.2.1"
+    object-is "^1.0.1"
+    util "^0.12.0"
+
 assertion-error@1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b"
@@ -1915,7 +1958,7 @@ async@^2.6.2:
   dependencies:
     lodash "^4.17.14"
 
-async@^3.2.3:
+async@^3.0.1, async@^3.2.3:
   version "3.2.3"
   resolved "https://registry.yarnpkg.com/async/-/async-3.2.3.tgz#ac53dafd3f4720ee9e8a160628f18ea91df196c9"
   integrity sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g==
@@ -1935,6 +1978,11 @@ atob@^2.1.2:
   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 
+available-typed-arrays@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz#92f95616501069d07d10edb2fc37d3e1c65123b7"
+  integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==
+
 aws-sign2@~0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
@@ -2242,6 +2290,16 @@ bl@^4.0.3, bl@^4.1.0:
     inherits "^2.0.4"
     readable-stream "^3.4.0"
 
+bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.11.9:
+  version "4.12.0"
+  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
+  integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
+
+bn.js@^5.0.0, bn.js@^5.1.1:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.0.tgz#358860674396c6997771a9d051fcc1b57d4ae002"
+  integrity sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==
+
 body-parser@^1.19.0:
   version "1.20.0"
   resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.0.tgz#3de69bd89011c11573d7bfee6a64f11b6bd27cc5"
@@ -2294,11 +2352,84 @@ braces@^3.0.2, braces@~3.0.2:
   dependencies:
     fill-range "^7.0.1"
 
+brorand@^1.0.1, brorand@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
+  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
+
+browser-resolve@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/browser-resolve/-/browser-resolve-2.0.0.tgz#99b7304cb392f8d73dba741bb2d7da28c6d7842b"
+  integrity sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==
+  dependencies:
+    resolve "^1.17.0"
+
 browser-stdout@1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
   integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
 
+browserify-aes@^1.0.0, browserify-aes@^1.0.4:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
+  integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
+  dependencies:
+    buffer-xor "^1.0.3"
+    cipher-base "^1.0.0"
+    create-hash "^1.1.0"
+    evp_bytestokey "^1.0.3"
+    inherits "^2.0.1"
+    safe-buffer "^5.0.1"
+
+browserify-cipher@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.1.tgz#8d6474c1b870bfdabcd3bcfcc1934a10e94f15f0"
+  integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==
+  dependencies:
+    browserify-aes "^1.0.4"
+    browserify-des "^1.0.0"
+    evp_bytestokey "^1.0.0"
+
+browserify-des@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.2.tgz#3af4f1f59839403572f1c66204375f7a7f703e9c"
+  integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==
+  dependencies:
+    cipher-base "^1.0.1"
+    des.js "^1.0.0"
+    inherits "^2.0.1"
+    safe-buffer "^5.1.2"
+
+browserify-rsa@^4.0.0, browserify-rsa@^4.0.1:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.1.0.tgz#b2fd06b5b75ae297f7ce2dc651f918f5be158c8d"
+  integrity sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==
+  dependencies:
+    bn.js "^5.0.0"
+    randombytes "^2.0.1"
+
+browserify-sign@^4.0.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.2.1.tgz#eaf4add46dd54be3bb3b36c0cf15abbeba7956c3"
+  integrity sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==
+  dependencies:
+    bn.js "^5.1.1"
+    browserify-rsa "^4.0.1"
+    create-hash "^1.2.0"
+    create-hmac "^1.1.7"
+    elliptic "^6.5.3"
+    inherits "^2.0.4"
+    parse-asn1 "^5.1.5"
+    readable-stream "^3.6.0"
+    safe-buffer "^5.2.0"
+
+browserify-zlib@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f"
+  integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==
+  dependencies:
+    pako "~1.0.5"
+
 browserslist@^4.14.5, browserslist@^4.20.2, browserslist@^4.20.3:
   version "4.20.3"
   resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.20.3.tgz#eb7572f49ec430e054f56d52ff0ebe9be915f8bf"
@@ -2351,7 +2482,12 @@ buffer-from@^1.0.0:
   resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
-buffer@^5.2.1, buffer@^5.5.0:
+buffer-xor@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
+  integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=
+
+buffer@^5.2.1, buffer@^5.4.3, buffer@^5.5.0:
   version "5.7.1"
   resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
   integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
@@ -2364,6 +2500,11 @@ builtin-modules@^3.1.0:
   resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
   integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
 
+builtin-status-codes@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
+  integrity sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=
+
 bytes@3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
@@ -2405,7 +2546,7 @@ cachedir@2.2.0:
   resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-2.2.0.tgz#19afa4305e05d79e417566882e0c8f960f62ff0e"
   integrity sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==
 
-call-bind@^1.0.0:
+call-bind@^1.0.0, call-bind@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
   integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
@@ -2602,6 +2743,14 @@ ci-info@^1.5.0:
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"
   integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==
 
+cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
+  integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
+  dependencies:
+    inherits "^2.0.1"
+    safe-buffer "^5.0.1"
+
 clean-stack@^2.0.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
@@ -2722,6 +2871,16 @@ colorette@^2.0.16:
   resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.16.tgz#713b9af84fdb000139f04546bd4a93f62a5085da"
   integrity sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==
 
+combine-source-map@^0.8.0:
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/combine-source-map/-/combine-source-map-0.8.0.tgz#a58d0df042c186fcf822a8e8015f5450d2d79a8b"
+  integrity sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=
+  dependencies:
+    convert-source-map "~1.1.0"
+    inline-source-map "~0.6.0"
+    lodash.memoize "~3.0.3"
+    source-map "~0.5.3"
+
 combined-stream@^1.0.6, combined-stream@^1.0.8, combined-stream@~1.0.6:
   version "1.0.8"
   resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
@@ -2828,6 +2987,11 @@ connect@^3.7.0:
     parseurl "~1.3.3"
     utils-merge "1.0.1"
 
+console-browserify@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.2.0.tgz#67063cef57ceb6cf4993a2ab3a55840ae8c49336"
+  integrity sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==
+
 constant-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/constant-case/-/constant-case-3.0.4.tgz#3b84a9aeaf4cf31ec45e6bf5de91bdfb0589faf1"
@@ -2837,6 +3001,11 @@ constant-case@^3.0.4:
     tslib "^2.0.3"
     upper-case "^2.0.2"
 
+constants-browserify@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
+  integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=
+
 content-disposition@^0.5.2:
   version "0.5.4"
   resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe"
@@ -3005,6 +3174,11 @@ convert-source-map@^1.7.0:
   dependencies:
     safe-buffer "~5.1.1"
 
+convert-source-map@~1.1.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.1.3.tgz#4829c877e9fe49b3161f3bf3673888e204699860"
+  integrity sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=
+
 cookie@~0.4.1:
   version "0.4.2"
   resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.2.tgz#0e41f24de5ecf317947c82fc789e06a884824432"
@@ -3083,6 +3257,37 @@ crc32-stream@^4.0.2:
     crc-32 "^1.2.0"
     readable-stream "^3.4.0"
 
+create-ecdh@^4.0.0:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.4.tgz#d6e7f4bffa66736085a0762fd3a632684dabcc4e"
+  integrity sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==
+  dependencies:
+    bn.js "^4.1.0"
+    elliptic "^6.5.3"
+
+create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
+  integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
+  dependencies:
+    cipher-base "^1.0.1"
+    inherits "^2.0.1"
+    md5.js "^1.3.4"
+    ripemd160 "^2.0.1"
+    sha.js "^2.4.0"
+
+create-hmac@^1.1.0, create-hmac@^1.1.4, create-hmac@^1.1.7:
+  version "1.1.7"
+  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff"
+  integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
+  dependencies:
+    cipher-base "^1.0.3"
+    create-hash "^1.1.0"
+    inherits "^2.0.1"
+    ripemd160 "^2.0.0"
+    safe-buffer "^5.0.1"
+    sha.js "^2.4.8"
+
 create-require@^1.1.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
@@ -3124,6 +3329,23 @@ cross-spawn@^7.0.2, cross-spawn@^7.0.3:
     shebang-command "^2.0.0"
     which "^2.0.1"
 
+crypto-browserify@^3.12.0:
+  version "3.12.0"
+  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
+  integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
+  dependencies:
+    browserify-cipher "^1.0.0"
+    browserify-sign "^4.0.0"
+    create-ecdh "^4.0.0"
+    create-hash "^1.1.0"
+    create-hmac "^1.1.0"
+    diffie-hellman "^5.0.0"
+    inherits "^2.0.1"
+    pbkdf2 "^3.0.3"
+    public-encrypt "^4.0.0"
+    randombytes "^2.0.0"
+    randomfill "^1.0.3"
+
 css-shorthand-properties@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/css-shorthand-properties/-/css-shorthand-properties-1.1.1.tgz#1c808e63553c283f289f2dd56fcee8f3337bd935"
@@ -3395,6 +3617,14 @@ depd@2.0.0:
   resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
   integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
 
+des.js@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.1.tgz#5382142e1bdc53f85d86d53e5f4aa7deb91e0843"
+  integrity sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==
+  dependencies:
+    inherits "^2.0.1"
+    minimalistic-assert "^1.0.0"
+
 destroy@1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015"
@@ -3450,6 +3680,11 @@ didyoumean@1.2.2:
   resolved "https://registry.yarnpkg.com/didyoumean/-/didyoumean-1.2.2.tgz#989346ffe9e839b4555ecf5666edea0d3e8ad037"
   integrity sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==
 
+diff-sequences@^27.5.1:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-27.5.1.tgz#eaecc0d327fd68c8d9672a1e64ab8dccb2ef5327"
+  integrity sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==
+
 diff@5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/diff/-/diff-5.0.0.tgz#7ed6ad76d859d030787ec35855f5b1daf31d852b"
@@ -3460,6 +3695,15 @@ diff@^4.0.1:
   resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
   integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
 
+diffie-hellman@^5.0.0:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
+  integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==
+  dependencies:
+    bn.js "^4.1.0"
+    miller-rabin "^4.0.0"
+    randombytes "^2.0.0"
+
 dir-glob@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
@@ -3484,6 +3728,11 @@ dom-serialize@^2.2.1:
     extend "^3.0.0"
     void-elements "^2.0.0"
 
+domain-browser@^4.16.0:
+  version "4.22.0"
+  resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-4.22.0.tgz#6ddd34220ec281f9a65d3386d267ddd35c491f9f"
+  integrity sha512-IGBwjF7tNk3cwypFNH/7bfzBcgSCbaMOD3GsaY1AU/JRrnHnYgEM0+9kQt52iZxjNsjBtJYtao146V+f8jFZNw==
+
 dot-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
@@ -3558,6 +3807,19 @@ electron-to-chromium@^1.4.118:
   resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.127.tgz#4ef19d5d920abe2676d938f4170729b44f7f423a"
   integrity sha512-nhD6S8nKI0O2MueC6blNOEZio+/PWppE/pevnf3LOlQA/fKPCrDp2Ao4wx4LFwmIkJpVdFdn2763YWLy9ENIZg==
 
+elliptic@^6.5.3:
+  version "6.5.4"
+  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
+  integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
+  dependencies:
+    bn.js "^4.11.9"
+    brorand "^1.1.0"
+    hash.js "^1.0.0"
+    hmac-drbg "^1.0.1"
+    inherits "^2.0.4"
+    minimalistic-assert "^1.0.1"
+    minimalistic-crypto-utils "^1.0.1"
+
 emitter-component@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/emitter-component/-/emitter-component-1.1.1.tgz#065e2dbed6959bf470679edabeaf7981d1003ab6"
@@ -3638,16 +3900,56 @@ error-ex@^1.3.1:
   dependencies:
     is-arrayish "^0.2.1"
 
+es-abstract@^1.18.5:
+  version "1.19.5"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.19.5.tgz#a2cb01eb87f724e815b278b0dd0d00f36ca9a7f1"
+  integrity sha512-Aa2G2+Rd3b6kxEUKTF4TaW67czBLyAv3z7VOhYRU50YBx+bbsYZ9xQP4lMNazePuFlybXI0V4MruPos7qUo5fA==
+  dependencies:
+    call-bind "^1.0.2"
+    es-to-primitive "^1.2.1"
+    function-bind "^1.1.1"
+    get-intrinsic "^1.1.1"
+    get-symbol-description "^1.0.0"
+    has "^1.0.3"
+    has-symbols "^1.0.3"
+    internal-slot "^1.0.3"
+    is-callable "^1.2.4"
+    is-negative-zero "^2.0.2"
+    is-regex "^1.1.4"
+    is-shared-array-buffer "^1.0.2"
+    is-string "^1.0.7"
+    is-weakref "^1.0.2"
+    object-inspect "^1.12.0"
+    object-keys "^1.1.1"
+    object.assign "^4.1.2"
+    string.prototype.trimend "^1.0.4"
+    string.prototype.trimstart "^1.0.4"
+    unbox-primitive "^1.0.1"
+
 es-module-lexer@^0.9.0:
   version "0.9.3"
   resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-0.9.3.tgz#6f13db00cc38417137daf74366f535c8eb438f19"
   integrity sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==
 
+es-to-primitive@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
+  integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
+  dependencies:
+    is-callable "^1.1.4"
+    is-date-object "^1.0.1"
+    is-symbol "^1.0.2"
+
 es6-error@^4.1.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"
   integrity sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==
 
+es6-object-assign@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/es6-object-assign/-/es6-object-assign-1.1.0.tgz#c2c3582656247c39ea107cb1e6652b6f9f24523c"
+  integrity sha1-wsNYJlYkfDnqEHyx5mUrb58kUjw=
+
 es6-promise@^4.0.3, es6-promise@^4.2.8:
   version "4.2.8"
   resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
@@ -3840,6 +4142,14 @@ events@^3.2.0:
   resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
   integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
+evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
+  integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
+  dependencies:
+    md5.js "^1.3.4"
+    safe-buffer "^5.1.1"
+
 execa@^0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/execa/-/execa-0.7.0.tgz#944becd34cc41ee32a63a9faf27ad5a65fc59777"
@@ -4207,6 +4517,11 @@ follow-redirects@^1.0.0, follow-redirects@^1.14.4:
   resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.9.tgz#dd4ea157de7bfaf9ea9b3fbd85aa16951f78d8d7"
   integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==
 
+foreach@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
+  integrity sha1-C+4AUBiusmDQo6865ljdATbsG5k=
+
 forever-agent@~0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
@@ -4315,7 +4630,7 @@ get-func-name@^2.0.0:
   resolved "https://registry.yarnpkg.com/get-func-name/-/get-func-name-2.0.0.tgz#ead774abee72e20409433a066366023dd6887a41"
   integrity sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=
 
-get-intrinsic@^1.0.2, get-intrinsic@^1.1.1:
+get-intrinsic@^1.0.2, get-intrinsic@^1.1.0, get-intrinsic@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
   integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==
@@ -4383,6 +4698,14 @@ get-stream@^6.0.0:
   resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
   integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
+get-symbol-description@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.0.tgz#7fdb81c900101fbd564dd5f1a30af5aadc1e58d6"
+  integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==
+  dependencies:
+    call-bind "^1.0.2"
+    get-intrinsic "^1.1.1"
+
 getpass@^0.1.1:
   version "0.1.7"
   resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
@@ -4635,6 +4958,11 @@ has-ansi@^2.0.0:
   dependencies:
     ansi-regex "^2.0.0"
 
+has-bigints@^1.0.1, has-bigints@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa"
+  integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==
+
 has-flag@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
@@ -4657,7 +4985,7 @@ has-symbol-support-x@^1.4.1:
   resolved "https://registry.yarnpkg.com/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz#1409f98bc00247da45da67cee0a36f282ff26455"
   integrity sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==
 
-has-symbols@^1.0.1:
+has-symbols@^1.0.1, has-symbols@^1.0.2, has-symbols@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
   integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
@@ -4669,6 +4997,13 @@ has-to-string-tag-x@^1.2.0:
   dependencies:
     has-symbol-support-x "^1.4.1"
 
+has-tostringtag@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.0.tgz#7e133818a7d394734f941e73c3d3f9291e658b25"
+  integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==
+  dependencies:
+    has-symbols "^1.0.2"
+
 has@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
@@ -4676,12 +5011,21 @@ has@^1.0.3:
   dependencies:
     function-bind "^1.1.1"
 
+hash-base@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.1.0.tgz#55c381d9e06e1d2997a883b4a3fddfe7f0d3af33"
+  integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==
+  dependencies:
+    inherits "^2.0.4"
+    readable-stream "^3.6.0"
+    safe-buffer "^5.2.0"
+
 hash-sum@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/hash-sum/-/hash-sum-2.0.0.tgz#81d01bb5de8ea4a214ad5d6ead1b523460b0b45a"
   integrity sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==
 
-hash.js@^1.1.7:
+hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7:
   version "1.1.7"
   resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
   integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
@@ -4710,6 +5054,15 @@ header-case@^2.0.4:
     capital-case "^1.0.4"
     tslib "^2.0.3"
 
+hmac-drbg@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
+  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
+  dependencies:
+    hash.js "^1.0.3"
+    minimalistic-assert "^1.0.0"
+    minimalistic-crypto-utils "^1.0.1"
+
 homedir-polyfill@^1.0.1:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
@@ -4816,6 +5169,11 @@ http2-wrapper@^1.0.0-beta.5.2:
     quick-lru "^5.1.1"
     resolve-alpn "^1.0.0"
 
+https-browserify@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73"
+  integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=
+
 https-proxy-agent@5.0.1, https-proxy-agent@^5.0.0:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6"
@@ -4904,7 +5262,7 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3:
+inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3, inherits@~2.0.4:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
@@ -4914,6 +5272,13 @@ ini@^1.3.2, ini@^1.3.4:
   resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
+inline-source-map@~0.6.0:
+  version "0.6.2"
+  resolved "https://registry.yarnpkg.com/inline-source-map/-/inline-source-map-0.6.2.tgz#f9393471c18a79d1724f863fa38b586370ade2a5"
+  integrity sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=
+  dependencies:
+    source-map "~0.5.3"
+
 inquirer@6.5.2:
   version "6.5.2"
   resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-6.5.2.tgz#ad50942375d036d327ff528c08bd5fab089928ca"
@@ -4933,6 +5298,15 @@ inquirer@6.5.2:
     strip-ansi "^5.1.0"
     through "^2.3.6"
 
+internal-slot@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.3.tgz#7347e307deeea2faac2ac6205d4bc7d34967f59c"
+  integrity sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==
+  dependencies:
+    get-intrinsic "^1.1.0"
+    has "^1.0.3"
+    side-channel "^1.0.4"
+
 interpret@^1.0.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
@@ -4958,11 +5332,26 @@ ip-regex@^4.1.0:
   resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-4.3.0.tgz#687275ab0f57fa76978ff8f4dddc8a23d5990db5"
   integrity sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==
 
+is-arguments@^1.0.4:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.1.1.tgz#15b3f88fda01f2a97fec84ca761a560f123efa9b"
+  integrity sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==
+  dependencies:
+    call-bind "^1.0.2"
+    has-tostringtag "^1.0.0"
+
 is-arrayish@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
   integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=
 
+is-bigint@^1.0.1:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.4.tgz#08147a1875bc2b32005d41ccd8291dffc6691df3"
+  integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
+  dependencies:
+    has-bigints "^1.0.1"
+
 is-binary-path@~2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
@@ -4970,6 +5359,19 @@ is-binary-path@~2.1.0:
   dependencies:
     binary-extensions "^2.0.0"
 
+is-boolean-object@^1.1.0:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.2.tgz#5c6dc200246dd9321ae4b885a114bb1f75f63719"
+  integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
+  dependencies:
+    call-bind "^1.0.2"
+    has-tostringtag "^1.0.0"
+
+is-callable@^1.1.4, is-callable@^1.2.4:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.4.tgz#47301d58dd0259407865547853df6d61fe471945"
+  integrity sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==
+
 is-ci@^1.0.10:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.2.1.tgz#e3779c8ee17fccf428488f6e281187f2e632841c"
@@ -4984,6 +5386,13 @@ is-core-module@^2.5.0, is-core-module@^2.8.1:
   dependencies:
     has "^1.0.3"
 
+is-date-object@^1.0.1:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f"
+  integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
 is-docker@^2.0.0:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
@@ -5009,6 +5418,13 @@ is-fullwidth-code-point@^4.0.0:
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz#fae3167c729e7463f8461ce512b080a49268aa88"
   integrity sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==
 
+is-generator-function@^1.0.7:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.10.tgz#f1558baf1ac17e0deea7c0415c438351ff2b3c72"
+  integrity sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
 is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
   version "4.0.3"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
@@ -5026,11 +5442,31 @@ is-module@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
   integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=
 
+is-nan@^1.2.1:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/is-nan/-/is-nan-1.3.2.tgz#043a54adea31748b55b6cd4e09aadafa69bd9e1d"
+  integrity sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==
+  dependencies:
+    call-bind "^1.0.0"
+    define-properties "^1.1.3"
+
 is-natural-number@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/is-natural-number/-/is-natural-number-4.0.1.tgz#ab9d76e1db4ced51e35de0c72ebecf09f734cde8"
   integrity sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=
 
+is-negative-zero@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150"
+  integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==
+
+is-number-object@^1.0.4:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc"
+  integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
 is-number@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
@@ -5080,11 +5516,26 @@ is-reference@^1.2.1:
   dependencies:
     "@types/estree" "*"
 
+is-regex@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
+  integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
+  dependencies:
+    call-bind "^1.0.2"
+    has-tostringtag "^1.0.0"
+
 is-retry-allowed@^1.1.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4"
   integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg==
 
+is-shared-array-buffer@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz#8f259c573b60b6a32d4058a1a07430c0a7344c79"
+  integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==
+  dependencies:
+    call-bind "^1.0.2"
+
 is-stream@^1.0.1, is-stream@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
@@ -5095,6 +5546,20 @@ is-stream@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
   integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
+is-string@^1.0.5, is-string@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd"
+  integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
+is-symbol@^1.0.2, is-symbol@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.4.tgz#a6dac93b635b063ca6872236de88910a57af139c"
+  integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
+  dependencies:
+    has-symbols "^1.0.2"
+
 is-text-path@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
@@ -5102,6 +5567,17 @@ is-text-path@^1.0.1:
   dependencies:
     text-extensions "^1.0.0"
 
+is-typed-array@^1.1.3, is-typed-array@^1.1.7:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.8.tgz#cbaa6585dc7db43318bc5b89523ea384a6f65e79"
+  integrity sha512-HqH41TNZq2fgtGT8WHVFVJhBVGuY3AnP3Q36K8JKXUxSxRgk/d+7NjmwG2vo2mYmXK8UYZKu0qH8bVP5gEisjA==
+  dependencies:
+    available-typed-arrays "^1.0.5"
+    call-bind "^1.0.2"
+    es-abstract "^1.18.5"
+    foreach "^2.0.5"
+    has-tostringtag "^1.0.0"
+
 is-typedarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
@@ -5122,6 +5598,13 @@ is-utf8@^0.2.1:
   resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
   integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
 
+is-weakref@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.2.tgz#9529f383a9338205e89765e0392efc2f100f06f2"
+  integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==
+  dependencies:
+    call-bind "^1.0.2"
+
 is-windows@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
@@ -5173,6 +5656,16 @@ istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0:
   resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
   integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==
 
+istanbul-lib-instrument@^4.0.0:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz#873c6fff897450118222774696a3f28902d77c1d"
+  integrity sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==
+  dependencies:
+    "@babel/core" "^7.7.5"
+    "@istanbuljs/schema" "^0.1.2"
+    istanbul-lib-coverage "^3.0.0"
+    semver "^6.3.0"
+
 istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.0.tgz#31d18bdd127f825dd02ea7bfdfd906f8ab840e9f"
@@ -5193,7 +5686,7 @@ istanbul-lib-report@^3.0.0:
     make-dir "^3.0.0"
     supports-color "^7.1.0"
 
-istanbul-lib-source-maps@^4.0.1:
+istanbul-lib-source-maps@^4.0.0, istanbul-lib-source-maps@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
   integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==
@@ -5202,7 +5695,7 @@ istanbul-lib-source-maps@^4.0.1:
     istanbul-lib-coverage "^3.0.0"
     source-map "^0.6.1"
 
-istanbul-reports@^3.0.5:
+istanbul-reports@^3.0.0, istanbul-reports@^3.0.5:
   version "3.1.4"
   resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.4.tgz#1b6f068ecbc6c331040aab5741991273e609e40c"
   integrity sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw==
@@ -5238,6 +5731,31 @@ jasmine@^4.1.0:
     glob "^7.1.6"
     jasmine-core "^4.1.0"
 
+jest-diff@^27.5.1:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-27.5.1.tgz#a07f5011ac9e6643cf8a95a462b7b1ecf6680def"
+  integrity sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==
+  dependencies:
+    chalk "^4.0.0"
+    diff-sequences "^27.5.1"
+    jest-get-type "^27.5.1"
+    pretty-format "^27.5.1"
+
+jest-get-type@^27.5.1:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-27.5.1.tgz#3cd613c507b0f7ace013df407a1c1cd578bcb4f1"
+  integrity sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==
+
+jest-matcher-utils@^27.0.0:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz#9c0cdbda8245bc22d2331729d1091308b40cf8ab"
+  integrity sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==
+  dependencies:
+    chalk "^4.0.0"
+    jest-diff "^27.5.1"
+    jest-get-type "^27.5.1"
+    pretty-format "^27.5.1"
+
 jest-worker@^27.4.5:
   version "27.5.1"
   resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
@@ -5452,6 +5970,55 @@ karma-sourcemap-loader@^0.3.8:
   dependencies:
     graceful-fs "^4.1.2"
 
+karma-typescript@^5.5.3:
+  version "5.5.3"
+  resolved "https://registry.yarnpkg.com/karma-typescript/-/karma-typescript-5.5.3.tgz#29c04d9677f8bd78dfacd89e8fa6f475dd25aba2"
+  integrity sha512-l1FHurolXEBIzRa9ExpNtjzysAhsi/vLpTazpwLHWWK86mknvVpqor6pRZ5Nid7jvOPrTBqAq0JRuLgiCdRkFw==
+  dependencies:
+    acorn "^8.1.0"
+    acorn-walk "^8.0.2"
+    assert "^2.0.0"
+    async "^3.0.1"
+    browser-resolve "^2.0.0"
+    browserify-zlib "^0.2.0"
+    buffer "^5.4.3"
+    combine-source-map "^0.8.0"
+    console-browserify "^1.2.0"
+    constants-browserify "^1.0.0"
+    convert-source-map "^1.7.0"
+    crypto-browserify "^3.12.0"
+    diff "^4.0.1"
+    domain-browser "^4.16.0"
+    events "^3.2.0"
+    glob "^7.1.6"
+    https-browserify "^1.0.0"
+    istanbul-lib-coverage "^3.0.0"
+    istanbul-lib-instrument "^4.0.0"
+    istanbul-lib-report "^3.0.0"
+    istanbul-lib-source-maps "^4.0.0"
+    istanbul-reports "^3.0.0"
+    json-stringify-safe "^5.0.1"
+    lodash "^4.17.19"
+    log4js "^6.3.0"
+    minimatch "^3.0.4"
+    os-browserify "^0.3.0"
+    pad "^3.2.0"
+    path-browserify "^1.0.0"
+    process "^0.11.10"
+    punycode "^2.1.1"
+    querystring-es3 "^0.2.1"
+    readable-stream "^3.1.1"
+    source-map "^0.7.3"
+    stream-browserify "^3.0.0"
+    stream-http "^3.1.0"
+    string_decoder "^1.3.0"
+    timers-browserify "^2.0.11"
+    tmp "^0.2.1"
+    tty-browserify "^0.0.1"
+    url "^0.11.0"
+    util "^0.12.1"
+    vm-browserify "^1.1.2"
+
 karma-webpack@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/karma-webpack/-/karma-webpack-5.0.0.tgz#2a2c7b80163fe7ffd1010f83f5507f95ef39f840"
@@ -5797,6 +6364,11 @@ lodash.map@^4.5.1:
   resolved "https://registry.yarnpkg.com/lodash.map/-/lodash.map-4.6.0.tgz#771ec7839e3473d9c4cde28b19394c3562f4f6d3"
   integrity sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=
 
+lodash.memoize@~3.0.3:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-3.0.4.tgz#2dcbd2c287cbc0a55cc42328bd0c736150d53e3f"
+  integrity sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=
+
 lodash.merge@4.6.2, lodash.merge@^4.6.1, lodash.merge@^4.6.2:
   version "4.6.2"
   resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
@@ -5867,7 +6439,7 @@ log-update@^4.0.0:
     slice-ansi "^4.0.0"
     wrap-ansi "^6.2.0"
 
-log4js@^6.4.1:
+log4js@^6.3.0, log4js@^6.4.1:
   version "6.4.6"
   resolved "https://registry.yarnpkg.com/log4js/-/log4js-6.4.6.tgz#1878aa3f09973298ecb441345fe9dd714e355c15"
   integrity sha512-1XMtRBZszmVZqPAOOWczH+Q94AI42mtNWjvjA5RduKTSWjEc56uOBbyM1CJnfN4Ym0wSd8cQ43zOojlSHgRDAw==
@@ -6005,6 +6577,15 @@ matcher@^3.0.0:
   dependencies:
     escape-string-regexp "^4.0.0"
 
+md5.js@^1.3.4:
+  version "1.3.5"
+  resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
+  integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
+  dependencies:
+    hash-base "^3.0.0"
+    inherits "^2.0.1"
+    safe-buffer "^5.1.2"
+
 media-typer@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
@@ -6050,6 +6631,14 @@ micromatch@^4.0.0, micromatch@^4.0.2, micromatch@^4.0.4:
     braces "^3.0.2"
     picomatch "^2.3.1"
 
+miller-rabin@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
+  integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==
+  dependencies:
+    bn.js "^4.0.0"
+    brorand "^1.0.1"
+
 mime-db@1.52.0, mime-db@^1.28.0:
   version "1.52.0"
   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
@@ -6097,11 +6686,16 @@ min-indent@^1.0.0:
   resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
   integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
 
-minimalistic-assert@^1.0.1:
+minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
   integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
 
+minimalistic-crypto-utils@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
+  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
+
 minimatch@3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
@@ -6373,12 +6967,20 @@ object-inspect@^1.12.0, object-inspect@^1.9.0:
   resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.0.tgz#6e2c120e868fd1fd18cb4f18c31741d0d6e776f0"
   integrity sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==
 
+object-is@^1.0.1:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/object-is/-/object-is-1.1.5.tgz#b9deeaa5fc7f1846a0faecdceec138e5778f53ac"
+  integrity sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
 object-keys@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
-object.assign@^4.1.0:
+object.assign@^4.1.0, object.assign@^4.1.2:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
   integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==
@@ -6467,6 +7069,11 @@ ora@5.4.1:
     strip-ansi "^6.0.0"
     wcwidth "^1.0.1"
 
+os-browserify@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
+  integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=
+
 os-filter-obj@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/os-filter-obj/-/os-filter-obj-2.0.0.tgz#1c0b62d5f3a2442749a2d139e6dddee6e81d8d16"
@@ -6579,7 +7186,14 @@ p-try@^2.0.0:
   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
   integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
 
-pako@~1.0.2:
+pad@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/pad/-/pad-3.2.0.tgz#be7a1d1cb6757049b4ad5b70e71977158fea95d1"
+  integrity sha512-2u0TrjcGbOjBTJpyewEl4hBO3OeX5wWue7eIFPzQTg6wFSvoaHcBTTUY5m+n0hd04gmTCPuY0kCpVIVuw5etwg==
+  dependencies:
+    wcwidth "^1.0.1"
+
+pako@~1.0.2, pako@~1.0.5:
   version "1.0.11"
   resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf"
   integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==
@@ -6599,6 +7213,17 @@ parent-module@^1.0.0:
   dependencies:
     callsites "^3.0.0"
 
+parse-asn1@^5.0.0, parse-asn1@^5.1.5:
+  version "5.1.6"
+  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.6.tgz#385080a3ec13cb62a62d39409cb3e88844cdaed4"
+  integrity sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==
+  dependencies:
+    asn1.js "^5.2.0"
+    browserify-aes "^1.0.0"
+    evp_bytestokey "^1.0.0"
+    pbkdf2 "^3.0.3"
+    safe-buffer "^5.1.1"
+
 parse-json@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
@@ -6635,6 +7260,11 @@ pascal-case@^3.1.2:
     no-case "^3.0.4"
     tslib "^2.0.3"
 
+path-browserify@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd"
+  integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==
+
 path-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/path-case/-/path-case-3.0.4.tgz#9168645334eb942658375c56f80b4c0cb5f82c6f"
@@ -6704,6 +7334,17 @@ pathval@1.1.1:
   resolved "https://registry.yarnpkg.com/pathval/-/pathval-1.1.1.tgz#8534e77a77ce7ac5a2512ea21e0fdb8fcf6c3d8d"
   integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==
 
+pbkdf2@^3.0.3:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.2.tgz#dd822aa0887580e52f1a039dc3eda108efae3075"
+  integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==
+  dependencies:
+    create-hash "^1.1.2"
+    create-hmac "^1.1.4"
+    ripemd160 "^2.0.1"
+    safe-buffer "^5.0.1"
+    sha.js "^2.4.8"
+
 pend@~1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
@@ -6821,11 +7462,25 @@ prepend-http@^2.0.0:
   resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897"
   integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=
 
+pretty-format@^27.0.0, pretty-format@^27.5.1:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-27.5.1.tgz#2181879fdea51a7a5851fb39d920faa63f01d88e"
+  integrity sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==
+  dependencies:
+    ansi-regex "^5.0.1"
+    ansi-styles "^5.0.0"
+    react-is "^17.0.1"
+
 process-nextick-args@~2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
   integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
 
+process@^0.11.10:
+  version "0.11.10"
+  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
+  integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
+
 progress@2.0.3, progress@^2.0.1:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
@@ -6856,6 +7511,18 @@ psl@^1.1.28:
   resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24"
   integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==
 
+public-encrypt@^4.0.0:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.3.tgz#4fcc9d77a07e48ba7527e7cbe0de33d0701331e0"
+  integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==
+  dependencies:
+    bn.js "^4.1.0"
+    browserify-rsa "^4.0.0"
+    create-hash "^1.1.0"
+    parse-asn1 "^5.0.0"
+    randombytes "^2.0.1"
+    safe-buffer "^5.1.2"
+
 pump@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
@@ -6864,6 +7531,11 @@ pump@^3.0.0:
     end-of-stream "^1.1.0"
     once "^1.3.1"
 
+punycode@1.3.2:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
+  integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=
+
 punycode@^1.3.2:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
@@ -6941,6 +7613,16 @@ query-string@^5.0.1:
     object-assign "^4.1.0"
     strict-uri-encode "^1.0.0"
 
+querystring-es3@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
+  integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=
+
+querystring@0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
+  integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
+
 queue-microtask@^1.2.2:
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
@@ -6956,13 +7638,21 @@ quick-lru@^5.1.1:
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
   integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
 
-randombytes@^2.1.0:
+randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5, randombytes@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
   integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
   dependencies:
     safe-buffer "^5.1.0"
 
+randomfill@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/randomfill/-/randomfill-1.0.4.tgz#c92196fc86ab42be983f1bf31778224931d61458"
+  integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==
+  dependencies:
+    randombytes "^2.0.5"
+    safe-buffer "^5.1.0"
+
 range-parser@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031"
@@ -6978,6 +7668,11 @@ raw-body@2.5.1:
     iconv-lite "0.4.24"
     unpipe "1.0.0"
 
+react-is@^17.0.1:
+  version "17.0.2"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-17.0.2.tgz#e691d4a8e9c789365655539ab372762b0efb54f0"
+  integrity sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==
+
 read-pkg-up@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
@@ -7014,7 +7709,7 @@ read-pkg@^5.2.0:
     parse-json "^5.0.0"
     type-fest "^0.6.0"
 
-readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
+readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.5.0, readable-stream@^3.6.0:
   version "3.6.0"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
   integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
@@ -7300,6 +7995,14 @@ rimraf@3.0.2, rimraf@^3.0.0, rimraf@^3.0.2:
   dependencies:
     glob "^7.1.3"
 
+ripemd160@^2.0.0, ripemd160@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
+  integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
+  dependencies:
+    hash-base "^3.0.0"
+    inherits "^2.0.1"
+
 roarr@^2.15.3:
   version "2.15.4"
   resolved "https://registry.yarnpkg.com/roarr/-/roarr-2.15.4.tgz#f5fe795b7b838ccfe35dc608e0282b9eba2e7afd"
@@ -7362,7 +8065,7 @@ safe-buffer@5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
-safe-buffer@5.2.1, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@~5.2.0:
+safe-buffer@5.2.1, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0:
   version "5.2.1"
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
@@ -7510,11 +8213,24 @@ set-immediate-shim@~1.0.1:
   resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61"
   integrity sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=
 
+setimmediate@^1.0.4:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
+  integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
+
 setprototypeof@1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424"
   integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
 
+sha.js@^2.4.0, sha.js@^2.4.8:
+  version "2.4.11"
+  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
+  integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
+  dependencies:
+    inherits "^2.0.1"
+    safe-buffer "^5.0.1"
+
 shallow-clone@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
@@ -7684,6 +8400,16 @@ source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
+source-map@^0.7.3:
+  version "0.7.3"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
+  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
+
+source-map@~0.5.3:
+  version "0.5.7"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
+  integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
+
 source-map@~0.8.0-beta.0:
   version "0.8.0-beta.0"
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.8.0-beta.0.tgz#d4c1bb42c3f7ee925f005927ba10709e0d1d1f11"
@@ -7778,6 +8504,14 @@ statuses@~1.5.0:
   resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
   integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=
 
+stream-browserify@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-3.0.0.tgz#22b0a2850cdf6503e73085da1fc7b7d0c2122f2f"
+  integrity sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==
+  dependencies:
+    inherits "~2.0.4"
+    readable-stream "^3.5.0"
+
 stream-events@^1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/stream-events/-/stream-events-1.0.5.tgz#bbc898ec4df33a4902d892333d47da9bf1c406d5"
@@ -7785,6 +8519,16 @@ stream-events@^1.0.5:
   dependencies:
     stubs "^3.0.0"
 
+stream-http@^3.1.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-3.2.0.tgz#1872dfcf24cb15752677e40e5c3f9cc1926028b5"
+  integrity sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==
+  dependencies:
+    builtin-status-codes "^3.0.0"
+    inherits "^2.0.4"
+    readable-stream "^3.6.0"
+    xtend "^4.0.2"
+
 stream@^0.0.2:
   version "0.0.2"
   resolved "https://registry.yarnpkg.com/stream/-/stream-0.0.2.tgz#7f5363f057f6592c5595f00bc80a27f5cec1f0ef"
@@ -7842,7 +8586,23 @@ string-width@^5.0.0:
     emoji-regex "^9.2.2"
     strip-ansi "^7.0.1"
 
-string_decoder@^1.1.1:
+string.prototype.trimend@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz#e75ae90c2942c63504686c18b287b4a0b1a45f80"
+  integrity sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
+string.prototype.trimstart@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz#b36399af4ab2999b4c9c648bd7a3fb2bb26feeed"
+  integrity sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
+string_decoder@^1.1.1, string_decoder@^1.3.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
   integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
@@ -8116,6 +8876,13 @@ timed-out@^4.0.1:
   resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f"
   integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=
 
+timers-browserify@^2.0.11:
+  version "2.0.12"
+  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.12.tgz#44a45c11fbf407f34f97bccd1577c652361b00ee"
+  integrity sha512-9phl76Cqm6FhSX9Xe1ZUAMLtm1BLkKj2Qd5ApyWkXzsMRaA7dgr81kf4wJmQf/hAvg8EEyJxDo3du/0KlhPiKQ==
+  dependencies:
+    setimmediate "^1.0.4"
+
 tmp@^0.0.33:
   version "0.0.33"
   resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
@@ -8235,6 +9002,11 @@ tsutils@^3.21.0:
   dependencies:
     tslib "^1.8.1"
 
+tty-browserify@^0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.1.tgz#3f05251ee17904dfd0677546670db9651682b811"
+  integrity sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==
+
 tunnel-agent@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
@@ -8334,6 +9106,16 @@ uglify-js@^3.1.4:
   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.15.4.tgz#fa95c257e88f85614915b906204b9623d4fa340d"
   integrity sha512-vMOPGDuvXecPs34V74qDKk4iJ/SN4vL3Ow/23ixafENYvtrNvtbcgUeugTcUGRGsOF/5fU8/NYSL5Hyb3l1OJA==
 
+unbox-primitive@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e"
+  integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==
+  dependencies:
+    call-bind "^1.0.2"
+    has-bigints "^1.0.2"
+    has-symbols "^1.0.3"
+    which-boxed-primitive "^1.0.2"
+
 unbzip2-stream@1.4.3, unbzip2-stream@^1.0.9, unbzip2-stream@^1.3.3:
   version "1.4.3"
   resolved "https://registry.yarnpkg.com/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz#b0da04c4371311df771cdc215e87f2130991ace7"
@@ -8462,6 +9244,14 @@ url-to-options@^1.0.1:
   resolved "https://registry.yarnpkg.com/url-to-options/-/url-to-options-1.0.1.tgz#1505a03a289a48cbd7a434efbaeec5055f5633a9"
   integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=
 
+url@^0.11.0:
+  version "0.11.0"
+  resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
+  integrity sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=
+  dependencies:
+    punycode "1.3.2"
+    querystring "0.2.0"
+
 urlgrey@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/urlgrey/-/urlgrey-1.0.0.tgz#72d2f904482d0b602e3c7fa599343d699bbe1017"
@@ -8474,6 +9264,18 @@ util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
 
+util@^0.12.0, util@^0.12.1:
+  version "0.12.4"
+  resolved "https://registry.yarnpkg.com/util/-/util-0.12.4.tgz#66121a31420df8f01ca0c464be15dfa1d1850253"
+  integrity sha512-bxZ9qtSlGUWSOy9Qa9Xgk11kSslpuZwaxCg4sNIDj6FLucDab2JxnHwyNTCpHMtK1MjoQiWQ6DiUMZYbSrO+Sw==
+  dependencies:
+    inherits "^2.0.3"
+    is-arguments "^1.0.4"
+    is-generator-function "^1.0.7"
+    is-typed-array "^1.1.3"
+    safe-buffer "^5.1.2"
+    which-typed-array "^1.1.2"
+
 utils-merge@1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
@@ -8521,6 +9323,11 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
+vm-browserify@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0"
+  integrity sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==
+
 void-elements@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/void-elements/-/void-elements-2.0.1.tgz#c066afb582bb1cb4128d60ea92392e94d5e9dbec"
@@ -8670,6 +9477,29 @@ whatwg-url@^7.0.0:
     tr46 "^1.0.1"
     webidl-conversions "^4.0.2"
 
+which-boxed-primitive@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6"
+  integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
+  dependencies:
+    is-bigint "^1.0.1"
+    is-boolean-object "^1.1.0"
+    is-number-object "^1.0.4"
+    is-string "^1.0.5"
+    is-symbol "^1.0.3"
+
+which-typed-array@^1.1.2:
+  version "1.1.7"
+  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.7.tgz#2761799b9a22d4b8660b3c1b40abaa7739691793"
+  integrity sha512-vjxaB4nfDqwKI0ws7wZpxIlde1XrLX5uB0ZjpfshgmapJMD7jJWhZI+yToJTqaFByF0eNBcYxbjmCzoRP7CfEw==
+  dependencies:
+    available-typed-arrays "^1.0.5"
+    call-bind "^1.0.2"
+    es-abstract "^1.18.5"
+    foreach "^2.0.5"
+    has-tostringtag "^1.0.0"
+    is-typed-array "^1.1.7"
+
 which@2.0.2, which@^2.0.1, which@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
@@ -8744,7 +9574,7 @@ ws@~8.2.3:
   resolved "https://registry.yarnpkg.com/ws/-/ws-8.2.3.tgz#63a56456db1b04367d0b721a0b80cae6d8becbba"
   integrity sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==
 
-xtend@^4.0.0, xtend@~4.0.1:
+xtend@^4.0.0, xtend@^4.0.2, xtend@~4.0.1:
   version "4.0.2"
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
   integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==

From ee5243fdccec55bba52ccd04cc80eecff449d335 Mon Sep 17 00:00:00 2001
From: Carlos Rodrigues <carlos@hypermob.co.uk>
Date: Sat, 30 Apr 2022 09:07:01 +0100
Subject: [PATCH 025/317] chore: fix tests

---
 .flowconfig                                   |  23 -
 package.json                                  |  10 +-
 test/ssr/ssr-bundle-render.spec.js            |   2 +-
 .../component/component-keep-alive.spec.js    |   2 +-
 test/unit/features/directives/class.spec.js   |   7 +-
 .../transition/transition-mode.spec.js        |   2 +-
 test/unit/karma.base.config.js                |  16 +-
 test/unit/karma.cover.config.js               |   2 +-
 yarn.lock                                     | 818 +++++++++++++++++-
 9 files changed, 816 insertions(+), 66 deletions(-)
 delete mode 100644 .flowconfig

diff --git a/.flowconfig b/.flowconfig
deleted file mode 100644
index 2d6f9a739ea..00000000000
--- a/.flowconfig
+++ /dev/null
@@ -1,23 +0,0 @@
-[ignore]
-.*/node_modules/.*
-.*/test/.*
-.*/scripts/.*
-.*/examples/.*
-.*/benchmarks/.*
-
-[include]
-
-[libs]
-flow
-
-[options]
-unsafe.enable_getters_and_setters=true
-module.name_mapper='^compiler/\(.*\)$' -> '<PROJECT_ROOT>/src/compiler/\1'
-module.name_mapper='^core/\(.*\)$' -> '<PROJECT_ROOT>/src/core/\1'
-module.name_mapper='^shared/\(.*\)$' -> '<PROJECT_ROOT>/src/shared/\1'
-module.name_mapper='^web/\(.*\)$' -> '<PROJECT_ROOT>/src/platforms/web/\1'
-module.name_mapper='^weex/\(.*\)$' -> '<PROJECT_ROOT>/src/platforms/weex/\1'
-module.name_mapper='^server/\(.*\)$' -> '<PROJECT_ROOT>/src/server/\1'
-module.name_mapper='^entries/\(.*\)$' -> '<PROJECT_ROOT>/src/entries/\1'
-module.name_mapper='^sfc/\(.*\)$' -> '<PROJECT_ROOT>/src/sfc/\1'
-suppress_comment= \\(.\\|\n\\)*\\$flow-disable-line
diff --git a/package.json b/package.json
index c786eeab9a1..4316d5daf5c 100644
--- a/package.json
+++ b/package.json
@@ -26,7 +26,7 @@
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
     "build:weex": "npm run build -- weex",
-    "test": "npm run lint && flow check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
+    "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
     "test:unit": "karma start test/unit/karma.unit.config.js",
     "test:cover": "karma start test/unit/karma.cover.config.js",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.js",
@@ -35,7 +35,6 @@
     "test:sauce": "npm run sauce -- 0 && npm run sauce -- 1 && npm run sauce -- 2",
     "test:types": "tsc -p ./types/test/tsconfig.json",
     "lint": "eslint src scripts test",
-    "flow": "flow check",
     "ts-check": "tsc --noEmit",
     "sauce": "karma start test/unit/karma.sauce.config.js",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
@@ -80,6 +79,7 @@
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-node-resolve": "^13.2.1",
     "@rollup/plugin-replace": "^4.0.0",
+    "@types/he": "^1.1.2",
     "@types/node": "^17.0.30",
     "@types/webpack": "^5.28.0",
     "@typescript-eslint/eslint-plugin": "^5.21.0",
@@ -107,7 +107,6 @@
     "eslint-plugin-flowtype": "^8.0.3",
     "eslint-plugin-jasmine": "^4.1.3",
     "file-loader": "^6.2.0",
-    "flow-bin": "^0.176.3",
     "hash-sum": "^2.0.0",
     "he": "^1.1.1",
     "http-server": "^14.1.0",
@@ -124,6 +123,7 @@
     "karma-safari-launcher": "^1.0.0",
     "karma-sauce-launcher": "^4.3.6",
     "karma-sourcemap-loader": "^0.3.8",
+    "karma-typescript": "^5.5.3",
     "karma-webpack": "^5.0.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
@@ -140,6 +140,7 @@
     "selenium-server": "^3.141.59",
     "serialize-javascript": "^6.0.0",
     "shelljs": "^0.8.5",
+    "stream-browserify": "^3.0.0",
     "terser": "^5.13.1",
     "ts-loader": "^9.2.9",
     "ts-node": "^10.7.0",
@@ -154,8 +155,5 @@
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
-  },
-  "dependencies": {
-    "@types/he": "^1.1.2"
   }
 }
diff --git a/test/ssr/ssr-bundle-render.spec.js b/test/ssr/ssr-bundle-render.spec.js
index ce7f8780a90..184eb98be5c 100644
--- a/test/ssr/ssr-bundle-render.spec.js
+++ b/test/ssr/ssr-bundle-render.spec.js
@@ -13,7 +13,7 @@ export function createRenderer (file, options, cb) {
 
   compileWithWebpack(file, {
     target: 'node',
-    devtool: asBundle ? '#source-map' : false,
+    devtool: asBundle ? 'source-map' : false,
     output: {
       path: '/',
       filename: 'bundle.js',
diff --git a/test/unit/features/component/component-keep-alive.spec.js b/test/unit/features/component/component-keep-alive.spec.js
index 9d30d2c7d58..56bd212b277 100644
--- a/test/unit/features/component/component-keep-alive.spec.js
+++ b/test/unit/features/component/component-keep-alive.spec.js
@@ -1111,7 +1111,7 @@ describe('Component keep-alive', () => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>'
         )
-      }).then(done).then(done)
+      }).then(done)
     })
 
     // #4339
diff --git a/test/unit/features/directives/class.spec.js b/test/unit/features/directives/class.spec.js
index 38a25988d2a..1b50301a721 100644
--- a/test/unit/features/directives/class.spec.js
+++ b/test/unit/features/directives/class.spec.js
@@ -15,9 +15,10 @@ function assertClass (assertions, done) {
       }
     }).then(() => {
       expect(vm.$el.className).toBe(expected)
-      if (i >= assertions.length - 1) {
-        done()
-      }
+      // NOTE THIS WAS MAKING 
+      // if (i >= assertions.length - 1) {
+      //   done()
+      // }
     })
   })
   chain.then(done)
diff --git a/test/unit/features/transition/transition-mode.spec.js b/test/unit/features/transition/transition-mode.spec.js
index f8afca82f5e..a67efe9ed96 100644
--- a/test/unit/features/transition/transition-mode.spec.js
+++ b/test/unit/features/transition/transition-mode.spec.js
@@ -253,7 +253,7 @@ if (!isIE9) {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>'
         )
-      }).then(done).then(done)
+      }).then(done)
     })
 
     it('normal elements with different keys, simultaneous', done => {
diff --git a/test/unit/karma.base.config.js b/test/unit/karma.base.config.js
index 228ca8e28d7..93f447f7d39 100644
--- a/test/unit/karma.base.config.js
+++ b/test/unit/karma.base.config.js
@@ -21,6 +21,9 @@ const webpackConfig = {
   resolve: {
     alias: alias,
     extensions: ['.tsx', '.ts', '.js'],
+    fallback: {
+      'stream': require.resolve("stream-browserify")
+    }
   },
   plugins: [
     new webpack.DefinePlugin({
@@ -32,17 +35,19 @@ const webpackConfig = {
       }
     })
   ],
-  devtool: '#inline-source-map'
+  devtool: 'inline-source-map'
 }
 
 // shared config for all unit tests
 module.exports = {
-  frameworks: ['jasmine'],
+  frameworks: ['jasmine', 'webpack', 'karma-typescript'],
   files: [
-    './index.js'
+    './index.js',
+    "src/**/*.ts" // *.tsx for React Jsx
   ],
   preprocessors: {
-    './index.js': ['webpack', 'sourcemap']
+    './index.js': ['webpack', 'sourcemap'],
+    "**/*.ts": ["karma-typescript", 'webpack', 'sourcemap'] // *.tsx for React Jsx
   },
   webpack: webpackConfig,
   webpackMiddleware: {
@@ -52,6 +57,7 @@ module.exports = {
     'karma-jasmine',
     'karma-mocha-reporter',
     'karma-sourcemap-loader',
-    'karma-webpack'
+    'karma-webpack',
+    'karma-typescript'
   ]
 }
diff --git a/test/unit/karma.cover.config.js b/test/unit/karma.cover.config.js
index 639cec462cb..fb4749887cc 100644
--- a/test/unit/karma.cover.config.js
+++ b/test/unit/karma.cover.config.js
@@ -11,7 +11,7 @@ module.exports = function (config) {
         flags: ['--no-sandbox']
       }
     },
-    reporters: ['mocha', 'coverage'],
+    reporters: ['mocha', 'coverage', 'karma-typescript'],
     coverageReporter: {
       reporters: [
         { type: 'lcov', dir: '../../coverage', subdir: '.' },
diff --git a/yarn.lock b/yarn.lock
index 05838c71984..c834777e1f3 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -41,7 +41,7 @@
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.13.12.tgz#a8a5ccac19c200f9dd49624cac6e19d7be1236a1"
   integrity sha512-3eJJ841uKxeV8dcN/2yGEUy+RfgQspPEgQat85umsE1rotuquQ2AbIub4S6j7c50a2d+4myc+zSlnXeIHrOnhQ==
 
-"@babel/core@^7.12.3", "@babel/core@^7.17.10":
+"@babel/core@^7.12.3", "@babel/core@^7.17.10", "@babel/core@^7.7.5":
   version "7.17.10"
   resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.10.tgz#74ef0fbf56b7dfc3f198fc2d927f4f03e12f4b05"
   integrity sha512-liKoppandF3ZcBnIYFjfSDHZLKdLHGJRkoWtG8zQyGJBQfIYobpnVGI5+pLBNtS6psFLDzyq8+h5HiVljW9PNA==
@@ -1851,7 +1851,7 @@ acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.1.tgz#fc8661e11b7ac1539c47dbfea2e72b3af34d267b"
   integrity sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==
 
-acorn-walk@^8.1.1, acorn-walk@^8.2.0:
+acorn-walk@^8.0.2, acorn-walk@^8.1.1, acorn-walk@^8.2.0:
   version "8.2.0"
   resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
   integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
@@ -1861,7 +1861,7 @@ acorn@^6.4.1:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
   integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
 
-acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
+acorn@^8.1.0, acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
   version "8.7.1"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30"
   integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==
@@ -2080,6 +2080,16 @@ arrify@^1.0.1:
   resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
   integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=
 
+asn1.js@^5.2.0:
+  version "5.4.1"
+  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-5.4.1.tgz#11a980b84ebb91781ce35b0fdc2ee294e3783f07"
+  integrity sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==
+  dependencies:
+    bn.js "^4.0.0"
+    inherits "^2.0.1"
+    minimalistic-assert "^1.0.0"
+    safer-buffer "^2.1.0"
+
 asn1@~0.2.3:
   version "0.2.4"
   resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136"
@@ -2092,6 +2102,16 @@ assert-plus@1.0.0, assert-plus@^1.0.0:
   resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
   integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
 
+assert@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/assert/-/assert-2.0.0.tgz#95fc1c616d48713510680f2eaf2d10dd22e02d32"
+  integrity sha512-se5Cd+js9dXJnu6Ag2JFc00t+HmHOen+8Q+L7O9zI0PqQXr20uk2J0XQqMxZEeo5U50o8Nvmmx7dZrl+Ufr35A==
+  dependencies:
+    es6-object-assign "^1.1.0"
+    is-nan "^1.2.1"
+    object-is "^1.0.1"
+    util "^0.12.0"
+
 assertion-error@1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b"
@@ -2109,7 +2129,7 @@ async@^2.6.2:
   dependencies:
     lodash "^4.17.14"
 
-async@^3.2.3:
+async@^3.0.1, async@^3.2.3:
   version "3.2.3"
   resolved "https://registry.yarnpkg.com/async/-/async-3.2.3.tgz#ac53dafd3f4720ee9e8a160628f18ea91df196c9"
   integrity sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g==
@@ -2129,6 +2149,11 @@ atob@^2.1.1, atob@^2.1.2:
   resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
   integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
 
+available-typed-arrays@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz#92f95616501069d07d10edb2fc37d3e1c65123b7"
+  integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==
+
 aws-sign2@~0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
@@ -2436,6 +2461,16 @@ bl@^4.0.3, bl@^4.1.0:
     inherits "^2.0.4"
     readable-stream "^3.4.0"
 
+bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.11.9:
+  version "4.12.0"
+  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
+  integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
+
+bn.js@^5.0.0, bn.js@^5.1.1:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.0.tgz#358860674396c6997771a9d051fcc1b57d4ae002"
+  integrity sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==
+
 body-parser@^1.19.0:
   version "1.20.0"
   resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.0.tgz#3de69bd89011c11573d7bfee6a64f11b6bd27cc5"
@@ -2488,11 +2523,84 @@ braces@^3.0.1, braces@^3.0.2, braces@~3.0.2:
   dependencies:
     fill-range "^7.0.1"
 
+brorand@^1.0.1, brorand@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
+  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
+
+browser-resolve@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/browser-resolve/-/browser-resolve-2.0.0.tgz#99b7304cb392f8d73dba741bb2d7da28c6d7842b"
+  integrity sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==
+  dependencies:
+    resolve "^1.17.0"
+
 browser-stdout@1.3.1:
   version "1.3.1"
   resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
   integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
 
+browserify-aes@^1.0.0, browserify-aes@^1.0.4:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
+  integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
+  dependencies:
+    buffer-xor "^1.0.3"
+    cipher-base "^1.0.0"
+    create-hash "^1.1.0"
+    evp_bytestokey "^1.0.3"
+    inherits "^2.0.1"
+    safe-buffer "^5.0.1"
+
+browserify-cipher@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.1.tgz#8d6474c1b870bfdabcd3bcfcc1934a10e94f15f0"
+  integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==
+  dependencies:
+    browserify-aes "^1.0.4"
+    browserify-des "^1.0.0"
+    evp_bytestokey "^1.0.0"
+
+browserify-des@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.2.tgz#3af4f1f59839403572f1c66204375f7a7f703e9c"
+  integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==
+  dependencies:
+    cipher-base "^1.0.1"
+    des.js "^1.0.0"
+    inherits "^2.0.1"
+    safe-buffer "^5.1.2"
+
+browserify-rsa@^4.0.0, browserify-rsa@^4.0.1:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.1.0.tgz#b2fd06b5b75ae297f7ce2dc651f918f5be158c8d"
+  integrity sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==
+  dependencies:
+    bn.js "^5.0.0"
+    randombytes "^2.0.1"
+
+browserify-sign@^4.0.0:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.2.1.tgz#eaf4add46dd54be3bb3b36c0cf15abbeba7956c3"
+  integrity sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==
+  dependencies:
+    bn.js "^5.1.1"
+    browserify-rsa "^4.0.1"
+    create-hash "^1.2.0"
+    create-hmac "^1.1.7"
+    elliptic "^6.5.3"
+    inherits "^2.0.4"
+    parse-asn1 "^5.1.5"
+    readable-stream "^3.6.0"
+    safe-buffer "^5.2.0"
+
+browserify-zlib@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f"
+  integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==
+  dependencies:
+    pako "~1.0.5"
+
 browserslist@^4.14.5:
   version "4.16.3"
   resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.3.tgz#340aa46940d7db878748567c5dea24a48ddf3717"
@@ -2556,7 +2664,12 @@ buffer-from@^1.0.0:
   resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
   integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
 
-buffer@^5.2.1, buffer@^5.5.0:
+buffer-xor@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
+  integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=
+
+buffer@^5.2.1, buffer@^5.4.3, buffer@^5.5.0:
   version "5.7.1"
   resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
   integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
@@ -2574,6 +2687,11 @@ builtin-modules@^3.1.0:
   resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
   integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
 
+builtin-status-codes@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
+  integrity sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=
+
 bytes@3.1.2:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
@@ -2615,7 +2733,7 @@ cachedir@2.2.0:
   resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-2.2.0.tgz#19afa4305e05d79e417566882e0c8f960f62ff0e"
   integrity sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==
 
-call-bind@^1.0.0:
+call-bind@^1.0.0, call-bind@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
   integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
@@ -2825,6 +2943,14 @@ ci-info@^1.5.0:
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"
   integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==
 
+cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
+  integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
+  dependencies:
+    inherits "^2.0.1"
+    safe-buffer "^5.0.1"
+
 clean-stack@^2.0.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
@@ -2950,6 +3076,16 @@ colorette@^2.0.16:
   resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.16.tgz#713b9af84fdb000139f04546bd4a93f62a5085da"
   integrity sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==
 
+combine-source-map@^0.8.0:
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/combine-source-map/-/combine-source-map-0.8.0.tgz#a58d0df042c186fcf822a8e8015f5450d2d79a8b"
+  integrity sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=
+  dependencies:
+    convert-source-map "~1.1.0"
+    inline-source-map "~0.6.0"
+    lodash.memoize "~3.0.3"
+    source-map "~0.5.3"
+
 combined-stream@^1.0.6, combined-stream@~1.0.6:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.7.tgz#2d1d24317afb8abe95d6d2c0b07b57813539d828"
@@ -3063,6 +3199,11 @@ connect@^3.7.0:
     parseurl "~1.3.3"
     utils-merge "1.0.1"
 
+console-browserify@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.2.0.tgz#67063cef57ceb6cf4993a2ab3a55840ae8c49336"
+  integrity sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==
+
 constant-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/constant-case/-/constant-case-3.0.4.tgz#3b84a9aeaf4cf31ec45e6bf5de91bdfb0589faf1"
@@ -3072,6 +3213,11 @@ constant-case@^3.0.4:
     tslib "^2.0.3"
     upper-case "^2.0.2"
 
+constants-browserify@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
+  integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=
+
 content-disposition@^0.5.2:
   version "0.5.4"
   resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe"
@@ -3240,6 +3386,11 @@ convert-source-map@^1.7.0:
   dependencies:
     safe-buffer "~5.1.1"
 
+convert-source-map@~1.1.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.1.3.tgz#4829c877e9fe49b3161f3bf3673888e204699860"
+  integrity sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=
+
 cookie@~0.4.1:
   version "0.4.2"
   resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.2.tgz#0e41f24de5ecf317947c82fc789e06a884824432"
@@ -3313,6 +3464,37 @@ crc32-stream@^4.0.2:
     crc-32 "^1.2.0"
     readable-stream "^3.4.0"
 
+create-ecdh@^4.0.0:
+  version "4.0.4"
+  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.4.tgz#d6e7f4bffa66736085a0762fd3a632684dabcc4e"
+  integrity sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==
+  dependencies:
+    bn.js "^4.1.0"
+    elliptic "^6.5.3"
+
+create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
+  integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
+  dependencies:
+    cipher-base "^1.0.1"
+    inherits "^2.0.1"
+    md5.js "^1.3.4"
+    ripemd160 "^2.0.1"
+    sha.js "^2.4.0"
+
+create-hmac@^1.1.0, create-hmac@^1.1.4, create-hmac@^1.1.7:
+  version "1.1.7"
+  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff"
+  integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
+  dependencies:
+    cipher-base "^1.0.3"
+    create-hash "^1.1.0"
+    inherits "^2.0.1"
+    ripemd160 "^2.0.0"
+    safe-buffer "^5.0.1"
+    sha.js "^2.4.8"
+
 create-require@^1.1.0:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
@@ -3354,6 +3536,23 @@ cross-spawn@^7.0.2, cross-spawn@^7.0.3:
     shebang-command "^2.0.0"
     which "^2.0.1"
 
+crypto-browserify@^3.12.0:
+  version "3.12.0"
+  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
+  integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
+  dependencies:
+    browserify-cipher "^1.0.0"
+    browserify-sign "^4.0.0"
+    create-ecdh "^4.0.0"
+    create-hash "^1.1.0"
+    create-hmac "^1.1.0"
+    diffie-hellman "^5.0.0"
+    inherits "^2.0.1"
+    pbkdf2 "^3.0.3"
+    public-encrypt "^4.0.0"
+    randombytes "^2.0.0"
+    randomfill "^1.0.3"
+
 css-shorthand-properties@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/css-shorthand-properties/-/css-shorthand-properties-1.1.1.tgz#1c808e63553c283f289f2dd56fcee8f3337bd935"
@@ -3631,6 +3830,14 @@ depd@2.0.0:
   resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
   integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
 
+des.js@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.1.tgz#5382142e1bdc53f85d86d53e5f4aa7deb91e0843"
+  integrity sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==
+  dependencies:
+    inherits "^2.0.1"
+    minimalistic-assert "^1.0.0"
+
 destroy@1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015"
@@ -3696,6 +3903,15 @@ diff@^4.0.1:
   resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
   integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
 
+diffie-hellman@^5.0.0:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
+  integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==
+  dependencies:
+    bn.js "^4.1.0"
+    miller-rabin "^4.0.0"
+    randombytes "^2.0.0"
+
 dir-glob@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
@@ -3720,6 +3936,11 @@ dom-serialize@^2.2.1:
     extend "^3.0.0"
     void-elements "^2.0.0"
 
+domain-browser@^4.16.0:
+  version "4.22.0"
+  resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-4.22.0.tgz#6ddd34220ec281f9a65d3386d267ddd35c491f9f"
+  integrity sha512-IGBwjF7tNk3cwypFNH/7bfzBcgSCbaMOD3GsaY1AU/JRrnHnYgEM0+9kQt52iZxjNsjBtJYtao146V+f8jFZNw==
+
 dot-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
@@ -3799,6 +4020,19 @@ electron-to-chromium@^1.4.118:
   resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.127.tgz#4ef19d5d920abe2676d938f4170729b44f7f423a"
   integrity sha512-nhD6S8nKI0O2MueC6blNOEZio+/PWppE/pevnf3LOlQA/fKPCrDp2Ao4wx4LFwmIkJpVdFdn2763YWLy9ENIZg==
 
+elliptic@^6.5.3:
+  version "6.5.4"
+  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
+  integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
+  dependencies:
+    bn.js "^4.11.9"
+    brorand "^1.1.0"
+    hash.js "^1.0.0"
+    hmac-drbg "^1.0.1"
+    inherits "^2.0.4"
+    minimalistic-assert "^1.0.1"
+    minimalistic-crypto-utils "^1.0.1"
+
 emoji-regex@^8.0.0:
   version "8.0.0"
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
@@ -3881,16 +4115,56 @@ error-ex@^1.3.1:
   dependencies:
     is-arrayish "^0.2.1"
 
+es-abstract@^1.18.5:
+  version "1.19.5"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.19.5.tgz#a2cb01eb87f724e815b278b0dd0d00f36ca9a7f1"
+  integrity sha512-Aa2G2+Rd3b6kxEUKTF4TaW67czBLyAv3z7VOhYRU50YBx+bbsYZ9xQP4lMNazePuFlybXI0V4MruPos7qUo5fA==
+  dependencies:
+    call-bind "^1.0.2"
+    es-to-primitive "^1.2.1"
+    function-bind "^1.1.1"
+    get-intrinsic "^1.1.1"
+    get-symbol-description "^1.0.0"
+    has "^1.0.3"
+    has-symbols "^1.0.3"
+    internal-slot "^1.0.3"
+    is-callable "^1.2.4"
+    is-negative-zero "^2.0.2"
+    is-regex "^1.1.4"
+    is-shared-array-buffer "^1.0.2"
+    is-string "^1.0.7"
+    is-weakref "^1.0.2"
+    object-inspect "^1.12.0"
+    object-keys "^1.1.1"
+    object.assign "^4.1.2"
+    string.prototype.trimend "^1.0.4"
+    string.prototype.trimstart "^1.0.4"
+    unbox-primitive "^1.0.1"
+
 es-module-lexer@^0.9.0:
   version "0.9.3"
   resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-0.9.3.tgz#6f13db00cc38417137daf74366f535c8eb438f19"
   integrity sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==
 
+es-to-primitive@^1.2.1:
+  version "1.2.1"
+  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
+  integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
+  dependencies:
+    is-callable "^1.1.4"
+    is-date-object "^1.0.1"
+    is-symbol "^1.0.2"
+
 es6-error@^4.1.1:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"
   integrity sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==
 
+es6-object-assign@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/es6-object-assign/-/es6-object-assign-1.1.0.tgz#c2c3582656247c39ea107cb1e6652b6f9f24523c"
+  integrity sha1-wsNYJlYkfDnqEHyx5mUrb58kUjw=
+
 es6-promise@^4.0.3:
   version "4.2.5"
   resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.5.tgz#da6d0d5692efb461e082c14817fe2427d8f5d054"
@@ -4088,6 +4362,14 @@ events@^3.2.0:
   resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
   integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
 
+evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
+  integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
+  dependencies:
+    md5.js "^1.3.4"
+    safe-buffer "^5.1.1"
+
 execa@^0.7.0:
   version "0.7.0"
   resolved "https://registry.yarnpkg.com/execa/-/execa-0.7.0.tgz#944becd34cc41ee32a63a9faf27ad5a65fc59777"
@@ -4466,11 +4748,6 @@ flatted@^3.2.5:
   resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.5.tgz#76c8584f4fc843db64702a6bd04ab7a8bd666da3"
   integrity sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==
 
-flow-bin@^0.176.3:
-  version "0.176.3"
-  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.176.3.tgz#d32de04e044ab474afe543b9fd245608bb6a6ac8"
-  integrity sha512-lbNqgjr2GlGLAEVp5+dhG4LdnFE7ekbvVNifAdlvTx58/nE8GrCOMiUwEQy4dLnfL2NIRMk2dbEVTrugeQJ3mA==
-
 follow-redirects@^1.0.0:
   version "1.13.0"
   resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.13.0.tgz#b42e8d93a2a7eea5ed88633676d6597bc8e384db"
@@ -4481,6 +4758,11 @@ follow-redirects@^1.14.4:
   resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.9.tgz#dd4ea157de7bfaf9ea9b3fbd85aa16951f78d8d7"
   integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==
 
+foreach@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
+  integrity sha1-C+4AUBiusmDQo6865ljdATbsG5k=
+
 forever-agent@~0.6.1:
   version "0.6.1"
   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
@@ -4589,7 +4871,7 @@ get-func-name@^2.0.0:
   resolved "https://registry.yarnpkg.com/get-func-name/-/get-func-name-2.0.0.tgz#ead774abee72e20409433a066366023dd6887a41"
   integrity sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=
 
-get-intrinsic@^1.0.2:
+get-intrinsic@^1.0.2, get-intrinsic@^1.1.0, get-intrinsic@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
   integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==
@@ -4657,6 +4939,14 @@ get-stream@^6.0.0:
   resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
   integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
 
+get-symbol-description@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.0.tgz#7fdb81c900101fbd564dd5f1a30af5aadc1e58d6"
+  integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==
+  dependencies:
+    call-bind "^1.0.2"
+    get-intrinsic "^1.1.1"
+
 getpass@^0.1.1:
   version "0.1.7"
   resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
@@ -4950,6 +5240,11 @@ has-ansi@^2.0.0:
   dependencies:
     ansi-regex "^2.0.0"
 
+has-bigints@^1.0.1, has-bigints@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa"
+  integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==
+
 has-flag@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
@@ -4970,6 +5265,11 @@ has-symbols@^1.0.1:
   resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.2.tgz#165d3070c00309752a1236a479331e3ac56f1423"
   integrity sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==
 
+has-symbols@^1.0.2, has-symbols@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
+  integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
+
 has-to-string-tag-x@^1.2.0:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz#a045ab383d7b4b2012a00148ab0aa5f290044d4d"
@@ -4977,6 +5277,13 @@ has-to-string-tag-x@^1.2.0:
   dependencies:
     has-symbol-support-x "^1.4.1"
 
+has-tostringtag@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.0.tgz#7e133818a7d394734f941e73c3d3f9291e658b25"
+  integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==
+  dependencies:
+    has-symbols "^1.0.2"
+
 has@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
@@ -4984,12 +5291,21 @@ has@^1.0.3:
   dependencies:
     function-bind "^1.1.1"
 
+hash-base@^3.0.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.1.0.tgz#55c381d9e06e1d2997a883b4a3fddfe7f0d3af33"
+  integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==
+  dependencies:
+    inherits "^2.0.4"
+    readable-stream "^3.6.0"
+    safe-buffer "^5.2.0"
+
 hash-sum@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/hash-sum/-/hash-sum-2.0.0.tgz#81d01bb5de8ea4a214ad5d6ead1b523460b0b45a"
   integrity sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==
 
-hash.js@^1.1.7:
+hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7:
   version "1.1.7"
   resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
   integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
@@ -5018,6 +5334,15 @@ header-case@^2.0.4:
     capital-case "^1.0.4"
     tslib "^2.0.3"
 
+hmac-drbg@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
+  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
+  dependencies:
+    hash.js "^1.0.3"
+    minimalistic-assert "^1.0.0"
+    minimalistic-crypto-utils "^1.0.1"
+
 homedir-polyfill@^1.0.1:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
@@ -5124,6 +5449,11 @@ http2-wrapper@^1.0.0-beta.5.2:
     quick-lru "^5.1.1"
     resolve-alpn "^1.0.0"
 
+https-browserify@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73"
+  integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=
+
 https-proxy-agent@5.0.1, https-proxy-agent@^5.0.0:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6"
@@ -5220,7 +5550,7 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3:
+inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3, inherits@~2.0.4:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
@@ -5230,6 +5560,13 @@ ini@^1.3.2, ini@^1.3.4:
   resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
 
+inline-source-map@~0.6.0:
+  version "0.6.2"
+  resolved "https://registry.yarnpkg.com/inline-source-map/-/inline-source-map-0.6.2.tgz#f9393471c18a79d1724f863fa38b586370ade2a5"
+  integrity sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=
+  dependencies:
+    source-map "~0.5.3"
+
 inquirer@6.5.2:
   version "6.5.2"
   resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-6.5.2.tgz#ad50942375d036d327ff528c08bd5fab089928ca"
@@ -5249,6 +5586,15 @@ inquirer@6.5.2:
     strip-ansi "^5.1.0"
     through "^2.3.6"
 
+internal-slot@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.3.tgz#7347e307deeea2faac2ac6205d4bc7d34967f59c"
+  integrity sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==
+  dependencies:
+    get-intrinsic "^1.1.0"
+    has "^1.0.3"
+    side-channel "^1.0.4"
+
 interpret@^1.0.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.2.0.tgz#d5061a6224be58e8083985f5014d844359576296"
@@ -5274,11 +5620,26 @@ ip-regex@^2.1.0:
   resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9"
   integrity sha1-+ni/XS5pE8kRzp+BnuUUa7bYROk=
 
+is-arguments@^1.0.4:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.1.1.tgz#15b3f88fda01f2a97fec84ca761a560f123efa9b"
+  integrity sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==
+  dependencies:
+    call-bind "^1.0.2"
+    has-tostringtag "^1.0.0"
+
 is-arrayish@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
   integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=
 
+is-bigint@^1.0.1:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.4.tgz#08147a1875bc2b32005d41ccd8291dffc6691df3"
+  integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
+  dependencies:
+    has-bigints "^1.0.1"
+
 is-binary-path@~2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
@@ -5286,6 +5647,14 @@ is-binary-path@~2.1.0:
   dependencies:
     binary-extensions "^2.0.0"
 
+is-boolean-object@^1.1.0:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.2.tgz#5c6dc200246dd9321ae4b885a114bb1f75f63719"
+  integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
+  dependencies:
+    call-bind "^1.0.2"
+    has-tostringtag "^1.0.0"
+
 is-builtin-module@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-1.0.0.tgz#540572d34f7ac3119f8f76c30cbc1b1e037affbe"
@@ -5293,6 +5662,11 @@ is-builtin-module@^1.0.0:
   dependencies:
     builtin-modules "^1.0.0"
 
+is-callable@^1.1.4, is-callable@^1.2.4:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.4.tgz#47301d58dd0259407865547853df6d61fe471945"
+  integrity sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==
+
 is-ci@^1.0.10:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.2.1.tgz#e3779c8ee17fccf428488f6e281187f2e632841c"
@@ -5314,6 +5688,13 @@ is-core-module@^2.5.0, is-core-module@^2.8.1:
   dependencies:
     has "^1.0.3"
 
+is-date-object@^1.0.1:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f"
+  integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
 is-docker@^2.0.0:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
@@ -5339,6 +5720,13 @@ is-fullwidth-code-point@^4.0.0:
   resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz#fae3167c729e7463f8461ce512b080a49268aa88"
   integrity sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==
 
+is-generator-function@^1.0.7:
+  version "1.0.10"
+  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.10.tgz#f1558baf1ac17e0deea7c0415c438351ff2b3c72"
+  integrity sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
 is-glob@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.0.tgz#9521c76845cc2610a85203ddf080a958c2ffabc0"
@@ -5370,11 +5758,31 @@ is-module@^1.0.0:
   resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
   integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=
 
+is-nan@^1.2.1:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/is-nan/-/is-nan-1.3.2.tgz#043a54adea31748b55b6cd4e09aadafa69bd9e1d"
+  integrity sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==
+  dependencies:
+    call-bind "^1.0.0"
+    define-properties "^1.1.3"
+
 is-natural-number@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/is-natural-number/-/is-natural-number-4.0.1.tgz#ab9d76e1db4ced51e35de0c72ebecf09f734cde8"
   integrity sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=
 
+is-negative-zero@^2.0.2:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150"
+  integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==
+
+is-number-object@^1.0.4:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc"
+  integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
 is-number@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
@@ -5429,11 +5837,26 @@ is-reference@^1.2.1:
   dependencies:
     "@types/estree" "*"
 
+is-regex@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
+  integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
+  dependencies:
+    call-bind "^1.0.2"
+    has-tostringtag "^1.0.0"
+
 is-retry-allowed@^1.1.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4"
   integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg==
 
+is-shared-array-buffer@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz#8f259c573b60b6a32d4058a1a07430c0a7344c79"
+  integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==
+  dependencies:
+    call-bind "^1.0.2"
+
 is-stream@^1.0.1, is-stream@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
@@ -5444,6 +5867,20 @@ is-stream@^2.0.0:
   resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
   integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
 
+is-string@^1.0.5, is-string@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd"
+  integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
+  dependencies:
+    has-tostringtag "^1.0.0"
+
+is-symbol@^1.0.2, is-symbol@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.4.tgz#a6dac93b635b063ca6872236de88910a57af139c"
+  integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
+  dependencies:
+    has-symbols "^1.0.2"
+
 is-text-path@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
@@ -5451,6 +5888,17 @@ is-text-path@^1.0.1:
   dependencies:
     text-extensions "^1.0.0"
 
+is-typed-array@^1.1.3, is-typed-array@^1.1.7:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.8.tgz#cbaa6585dc7db43318bc5b89523ea384a6f65e79"
+  integrity sha512-HqH41TNZq2fgtGT8WHVFVJhBVGuY3AnP3Q36K8JKXUxSxRgk/d+7NjmwG2vo2mYmXK8UYZKu0qH8bVP5gEisjA==
+  dependencies:
+    available-typed-arrays "^1.0.5"
+    call-bind "^1.0.2"
+    es-abstract "^1.18.5"
+    foreach "^2.0.5"
+    has-tostringtag "^1.0.0"
+
 is-typedarray@~1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
@@ -5471,6 +5919,13 @@ is-utf8@^0.2.1:
   resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
   integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
 
+is-weakref@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.2.tgz#9529f383a9338205e89765e0392efc2f100f06f2"
+  integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==
+  dependencies:
+    call-bind "^1.0.2"
+
 is-windows@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
@@ -5522,6 +5977,16 @@ istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0:
   resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
   integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==
 
+istanbul-lib-instrument@^4.0.0:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz#873c6fff897450118222774696a3f28902d77c1d"
+  integrity sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==
+  dependencies:
+    "@babel/core" "^7.7.5"
+    "@istanbuljs/schema" "^0.1.2"
+    istanbul-lib-coverage "^3.0.0"
+    semver "^6.3.0"
+
 istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.0.tgz#31d18bdd127f825dd02ea7bfdfd906f8ab840e9f"
@@ -5542,7 +6007,7 @@ istanbul-lib-report@^3.0.0:
     make-dir "^3.0.0"
     supports-color "^7.1.0"
 
-istanbul-lib-source-maps@^4.0.1:
+istanbul-lib-source-maps@^4.0.0, istanbul-lib-source-maps@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
   integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==
@@ -5551,7 +6016,7 @@ istanbul-lib-source-maps@^4.0.1:
     istanbul-lib-coverage "^3.0.0"
     source-map "^0.6.1"
 
-istanbul-reports@^3.0.5:
+istanbul-reports@^3.0.0, istanbul-reports@^3.0.5:
   version "3.1.4"
   resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.4.tgz#1b6f068ecbc6c331040aab5741991273e609e40c"
   integrity sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw==
@@ -5808,6 +6273,55 @@ karma-sourcemap-loader@^0.3.8:
   dependencies:
     graceful-fs "^4.1.2"
 
+karma-typescript@^5.5.3:
+  version "5.5.3"
+  resolved "https://registry.yarnpkg.com/karma-typescript/-/karma-typescript-5.5.3.tgz#29c04d9677f8bd78dfacd89e8fa6f475dd25aba2"
+  integrity sha512-l1FHurolXEBIzRa9ExpNtjzysAhsi/vLpTazpwLHWWK86mknvVpqor6pRZ5Nid7jvOPrTBqAq0JRuLgiCdRkFw==
+  dependencies:
+    acorn "^8.1.0"
+    acorn-walk "^8.0.2"
+    assert "^2.0.0"
+    async "^3.0.1"
+    browser-resolve "^2.0.0"
+    browserify-zlib "^0.2.0"
+    buffer "^5.4.3"
+    combine-source-map "^0.8.0"
+    console-browserify "^1.2.0"
+    constants-browserify "^1.0.0"
+    convert-source-map "^1.7.0"
+    crypto-browserify "^3.12.0"
+    diff "^4.0.1"
+    domain-browser "^4.16.0"
+    events "^3.2.0"
+    glob "^7.1.6"
+    https-browserify "^1.0.0"
+    istanbul-lib-coverage "^3.0.0"
+    istanbul-lib-instrument "^4.0.0"
+    istanbul-lib-report "^3.0.0"
+    istanbul-lib-source-maps "^4.0.0"
+    istanbul-reports "^3.0.0"
+    json-stringify-safe "^5.0.1"
+    lodash "^4.17.19"
+    log4js "^6.3.0"
+    minimatch "^3.0.4"
+    os-browserify "^0.3.0"
+    pad "^3.2.0"
+    path-browserify "^1.0.0"
+    process "^0.11.10"
+    punycode "^2.1.1"
+    querystring-es3 "^0.2.1"
+    readable-stream "^3.1.1"
+    source-map "^0.7.3"
+    stream-browserify "^3.0.0"
+    stream-http "^3.1.0"
+    string_decoder "^1.3.0"
+    timers-browserify "^2.0.11"
+    tmp "^0.2.1"
+    tty-browserify "^0.0.1"
+    url "^0.11.0"
+    util "^0.12.1"
+    vm-browserify "^1.1.2"
+
 karma-webpack@^5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/karma-webpack/-/karma-webpack-5.0.0.tgz#2a2c7b80163fe7ffd1010f83f5507f95ef39f840"
@@ -6158,6 +6672,11 @@ lodash.map@^4.5.1:
   resolved "https://registry.yarnpkg.com/lodash.map/-/lodash.map-4.6.0.tgz#771ec7839e3473d9c4cde28b19394c3562f4f6d3"
   integrity sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=
 
+lodash.memoize@~3.0.3:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-3.0.4.tgz#2dcbd2c287cbc0a55cc42328bd0c736150d53e3f"
+  integrity sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=
+
 lodash.merge@4.6.2, lodash.merge@^4.6.1, lodash.merge@^4.6.2:
   version "4.6.2"
   resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
@@ -6238,7 +6757,7 @@ log-update@^4.0.0:
     slice-ansi "^4.0.0"
     wrap-ansi "^6.2.0"
 
-log4js@^6.4.1:
+log4js@^6.3.0, log4js@^6.4.1:
   version "6.4.6"
   resolved "https://registry.yarnpkg.com/log4js/-/log4js-6.4.6.tgz#1878aa3f09973298ecb441345fe9dd714e355c15"
   integrity sha512-1XMtRBZszmVZqPAOOWczH+Q94AI42mtNWjvjA5RduKTSWjEc56uOBbyM1CJnfN4Ym0wSd8cQ43zOojlSHgRDAw==
@@ -6376,6 +6895,15 @@ matcher@^3.0.0:
   dependencies:
     escape-string-regexp "^4.0.0"
 
+md5.js@^1.3.4:
+  version "1.3.5"
+  resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
+  integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
+  dependencies:
+    hash-base "^3.0.0"
+    inherits "^2.0.1"
+    safe-buffer "^5.1.2"
+
 media-typer@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
@@ -6429,6 +6957,14 @@ micromatch@^4.0.2, micromatch@^4.0.4:
     braces "^3.0.2"
     picomatch "^2.3.1"
 
+miller-rabin@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
+  integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==
+  dependencies:
+    bn.js "^4.0.0"
+    brorand "^1.0.1"
+
 mime-db@1.52.0, mime-db@^1.28.0:
   version "1.52.0"
   resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
@@ -6488,11 +7024,16 @@ min-indent@^1.0.0:
   resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
   integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
 
-minimalistic-assert@^1.0.1:
+minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
   integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
 
+minimalistic-crypto-utils@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
+  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
+
 minimatch@3.0.4, minimatch@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
@@ -6791,12 +7332,20 @@ object-inspect@^1.12.0, object-inspect@^1.9.0:
   resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.0.tgz#6e2c120e868fd1fd18cb4f18c31741d0d6e776f0"
   integrity sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==
 
+object-is@^1.0.1:
+  version "1.1.5"
+  resolved "https://registry.yarnpkg.com/object-is/-/object-is-1.1.5.tgz#b9deeaa5fc7f1846a0faecdceec138e5778f53ac"
+  integrity sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
 object-keys@^1.0.12, object-keys@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
   integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
 
-object.assign@^4.1.0:
+object.assign@^4.1.0, object.assign@^4.1.2:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
   integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==
@@ -6885,6 +7434,11 @@ ora@5.4.1:
     strip-ansi "^6.0.0"
     wcwidth "^1.0.1"
 
+os-browserify@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
+  integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=
+
 os-filter-obj@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/os-filter-obj/-/os-filter-obj-2.0.0.tgz#1c0b62d5f3a2442749a2d139e6dddee6e81d8d16"
@@ -7004,11 +7558,23 @@ p-try@^2.0.0:
   resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.0.0.tgz#85080bb87c64688fa47996fe8f7dfbe8211760b1"
   integrity sha512-hMp0onDKIajHfIkdRk3P4CdCmErkYAxxDtP3Wx/4nZ3aGlau2VKh3mZpcuFkH27WQkL/3WBCPOktzA9ZOAnMQQ==
 
+pad@^3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/pad/-/pad-3.2.0.tgz#be7a1d1cb6757049b4ad5b70e71977158fea95d1"
+  integrity sha512-2u0TrjcGbOjBTJpyewEl4hBO3OeX5wWue7eIFPzQTg6wFSvoaHcBTTUY5m+n0hd04gmTCPuY0kCpVIVuw5etwg==
+  dependencies:
+    wcwidth "^1.0.1"
+
 pako@~1.0.2:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.7.tgz#2473439021b57f1516c82f58be7275ad8ef1bb27"
   integrity sha512-3HNK5tW4x8o5mO8RuHZp3Ydw9icZXx0RANAOMzlMzx7LVXhMJ4mo3MOBpzyd7r/+RUu8BmndP47LXT+vzjtWcQ==
 
+pako@~1.0.5:
+  version "1.0.11"
+  resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf"
+  integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==
+
 param-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/param-case/-/param-case-3.0.4.tgz#7d17fe4aa12bde34d4a77d91acfb6219caad01c5"
@@ -7024,6 +7590,17 @@ parent-module@^1.0.0:
   dependencies:
     callsites "^3.0.0"
 
+parse-asn1@^5.0.0, parse-asn1@^5.1.5:
+  version "5.1.6"
+  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.6.tgz#385080a3ec13cb62a62d39409cb3e88844cdaed4"
+  integrity sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==
+  dependencies:
+    asn1.js "^5.2.0"
+    browserify-aes "^1.0.0"
+    evp_bytestokey "^1.0.0"
+    pbkdf2 "^3.0.3"
+    safe-buffer "^5.1.1"
+
 parse-json@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
@@ -7060,6 +7637,11 @@ pascal-case@^3.1.2:
     no-case "^3.0.4"
     tslib "^2.0.3"
 
+path-browserify@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd"
+  integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==
+
 path-case@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/path-case/-/path-case-3.0.4.tgz#9168645334eb942658375c56f80b4c0cb5f82c6f"
@@ -7134,6 +7716,17 @@ pathval@1.1.1:
   resolved "https://registry.yarnpkg.com/pathval/-/pathval-1.1.1.tgz#8534e77a77ce7ac5a2512ea21e0fdb8fcf6c3d8d"
   integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==
 
+pbkdf2@^3.0.3:
+  version "3.1.2"
+  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.2.tgz#dd822aa0887580e52f1a039dc3eda108efae3075"
+  integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==
+  dependencies:
+    create-hash "^1.1.2"
+    create-hmac "^1.1.4"
+    ripemd160 "^2.0.1"
+    safe-buffer "^5.0.1"
+    sha.js "^2.4.8"
+
 pend@~1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
@@ -7261,6 +7854,11 @@ process-nextick-args@~2.0.0:
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.0.tgz#a37d732f4271b4ab1ad070d35508e8290788ffaa"
   integrity sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==
 
+process@^0.11.10:
+  version "0.11.10"
+  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
+  integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
+
 progress@2.0.3, progress@^2.0.1:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
@@ -7296,6 +7894,18 @@ psl@^1.1.24:
   resolved "https://registry.yarnpkg.com/psl/-/psl-1.1.31.tgz#e9aa86d0101b5b105cbe93ac6b784cd547276184"
   integrity sha512-/6pt4+C+T+wZUieKR620OpzN/LlnNKuWjy1iFLQ/UG35JqHlR/89MP1d96dUfkf6Dne3TuLQzOYEYshJ+Hx8mw==
 
+public-encrypt@^4.0.0:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.3.tgz#4fcc9d77a07e48ba7527e7cbe0de33d0701331e0"
+  integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==
+  dependencies:
+    bn.js "^4.1.0"
+    browserify-rsa "^4.0.0"
+    create-hash "^1.1.0"
+    parse-asn1 "^5.0.0"
+    randombytes "^2.0.1"
+    safe-buffer "^5.1.2"
+
 pump@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
@@ -7304,12 +7914,17 @@ pump@^3.0.0:
     end-of-stream "^1.1.0"
     once "^1.3.1"
 
+punycode@1.3.2:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
+  integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=
+
 punycode@^1.3.2, punycode@^1.4.1:
   version "1.4.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
   integrity sha1-wNWmOycYgArY4esPpSachN1BhF4=
 
-punycode@^2.1.0:
+punycode@^2.1.0, punycode@^2.1.1:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
@@ -7386,6 +8001,16 @@ query-string@^5.0.1:
     object-assign "^4.1.0"
     strict-uri-encode "^1.0.0"
 
+querystring-es3@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
+  integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=
+
+querystring@0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
+  integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
+
 queue-microtask@^1.2.2:
   version "1.2.3"
   resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
@@ -7401,13 +8026,21 @@ quick-lru@^5.1.1:
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
   integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
 
-randombytes@^2.1.0:
+randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5, randombytes@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
   integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
   dependencies:
     safe-buffer "^5.1.0"
 
+randomfill@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/randomfill/-/randomfill-1.0.4.tgz#c92196fc86ab42be983f1bf31778224931d61458"
+  integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==
+  dependencies:
+    randombytes "^2.0.5"
+    safe-buffer "^5.1.0"
+
 range-parser@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031"
@@ -7459,7 +8092,7 @@ read-pkg@^5.2.0:
     parse-json "^5.0.0"
     type-fest "^0.6.0"
 
-readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.6.0:
+readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.5.0, readable-stream@^3.6.0:
   version "3.6.0"
   resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
   integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
@@ -7797,6 +8430,14 @@ rimraf@3.0.2, rimraf@^3.0.0, rimraf@^3.0.2:
   dependencies:
     glob "^7.1.3"
 
+ripemd160@^2.0.0, ripemd160@^2.0.1:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
+  integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
+  dependencies:
+    hash-base "^3.0.0"
+    inherits "^2.0.1"
+
 roarr@^2.15.3:
   version "2.15.4"
   resolved "https://registry.yarnpkg.com/roarr/-/roarr-2.15.4.tgz#f5fe795b7b838ccfe35dc608e0282b9eba2e7afd"
@@ -7861,7 +8502,7 @@ safe-buffer@5.1.2, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, s
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
-safe-buffer@5.2.1, safe-buffer@~5.2.0:
+safe-buffer@5.2.1, safe-buffer@^5.2.0, safe-buffer@~5.2.0:
   version "5.2.1"
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
   integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
@@ -8014,11 +8655,24 @@ set-immediate-shim@~1.0.1:
   resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61"
   integrity sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=
 
+setimmediate@^1.0.4:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
+  integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
+
 setprototypeof@1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424"
   integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
 
+sha.js@^2.4.0, sha.js@^2.4.8:
+  version "2.4.11"
+  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
+  integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
+  dependencies:
+    inherits "^2.0.1"
+    safe-buffer "^5.0.1"
+
 shallow-clone@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
@@ -8196,7 +8850,7 @@ source-map-url@^0.4.0:
   resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"
   integrity sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM=
 
-source-map@^0.5.0:
+source-map@^0.5.0, source-map@~0.5.3:
   version "0.5.7"
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
   integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
@@ -8206,6 +8860,11 @@ source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
+source-map@^0.7.3:
+  version "0.7.3"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
+  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
+
 source-map@~0.8.0-beta.0:
   version "0.8.0-beta.0"
   resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.8.0-beta.0.tgz#d4c1bb42c3f7ee925f005927ba10709e0d1d1f11"
@@ -8300,6 +8959,14 @@ statuses@~1.5.0:
   resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
   integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=
 
+stream-browserify@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-3.0.0.tgz#22b0a2850cdf6503e73085da1fc7b7d0c2122f2f"
+  integrity sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==
+  dependencies:
+    inherits "~2.0.4"
+    readable-stream "^3.5.0"
+
 stream-events@^1.0.5:
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/stream-events/-/stream-events-1.0.5.tgz#bbc898ec4df33a4902d892333d47da9bf1c406d5"
@@ -8307,6 +8974,16 @@ stream-events@^1.0.5:
   dependencies:
     stubs "^3.0.0"
 
+stream-http@^3.1.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-3.2.0.tgz#1872dfcf24cb15752677e40e5c3f9cc1926028b5"
+  integrity sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==
+  dependencies:
+    builtin-status-codes "^3.0.0"
+    inherits "^2.0.4"
+    readable-stream "^3.6.0"
+    xtend "^4.0.2"
+
 streamroller@^3.0.8:
   version "3.0.8"
   resolved "https://registry.yarnpkg.com/streamroller/-/streamroller-3.0.8.tgz#84b190e4080ee311ca1ebe0444e30ac8eedd028d"
@@ -8366,7 +9043,23 @@ string-width@^5.0.0:
     emoji-regex "^9.2.2"
     strip-ansi "^7.0.1"
 
-string_decoder@^1.1.1:
+string.prototype.trimend@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz#e75ae90c2942c63504686c18b287b4a0b1a45f80"
+  integrity sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
+string.prototype.trimstart@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz#b36399af4ab2999b4c9c648bd7a3fb2bb26feeed"
+  integrity sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
+string_decoder@^1.1.1, string_decoder@^1.3.0:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
   integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
@@ -8647,6 +9340,13 @@ timed-out@^4.0.1:
   resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f"
   integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=
 
+timers-browserify@^2.0.11:
+  version "2.0.12"
+  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.12.tgz#44a45c11fbf407f34f97bccd1577c652361b00ee"
+  integrity sha512-9phl76Cqm6FhSX9Xe1ZUAMLtm1BLkKj2Qd5ApyWkXzsMRaA7dgr81kf4wJmQf/hAvg8EEyJxDo3du/0KlhPiKQ==
+  dependencies:
+    setimmediate "^1.0.4"
+
 tmp@^0.0.33:
   version "0.0.33"
   resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
@@ -8771,6 +9471,11 @@ tsutils@^3.21.0:
   dependencies:
     tslib "^1.8.1"
 
+tty-browserify@^0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.1.tgz#3f05251ee17904dfd0677546670db9651682b811"
+  integrity sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==
+
 tunnel-agent@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
@@ -8870,6 +9575,16 @@ uglify-js@^3.1.4:
   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.13.0.tgz#66ed69f7241f33f13531d3d51d5bcebf00df7f69"
   integrity sha512-TWYSWa9T2pPN4DIJYbU9oAjQx+5qdV5RUDxwARg8fmJZrD/V27Zj0JngW5xg1DFz42G0uDYl2XhzF6alSzD62w==
 
+unbox-primitive@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e"
+  integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==
+  dependencies:
+    call-bind "^1.0.2"
+    has-bigints "^1.0.2"
+    has-symbols "^1.0.3"
+    which-boxed-primitive "^1.0.2"
+
 unbzip2-stream@1.4.3, unbzip2-stream@^1.0.9, unbzip2-stream@^1.3.3:
   version "1.4.3"
   resolved "https://registry.yarnpkg.com/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz#b0da04c4371311df771cdc215e87f2130991ace7"
@@ -8998,6 +9713,14 @@ url-to-options@^1.0.1:
   resolved "https://registry.yarnpkg.com/url-to-options/-/url-to-options-1.0.1.tgz#1505a03a289a48cbd7a434efbaeec5055f5633a9"
   integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=
 
+url@^0.11.0:
+  version "0.11.0"
+  resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
+  integrity sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=
+  dependencies:
+    punycode "1.3.2"
+    querystring "0.2.0"
+
 urlgrey@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/urlgrey/-/urlgrey-1.0.0.tgz#72d2f904482d0b602e3c7fa599343d699bbe1017"
@@ -9010,6 +9733,18 @@ util-deprecate@^1.0.1, util-deprecate@~1.0.1:
   resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
   integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
 
+util@^0.12.0, util@^0.12.1:
+  version "0.12.4"
+  resolved "https://registry.yarnpkg.com/util/-/util-0.12.4.tgz#66121a31420df8f01ca0c464be15dfa1d1850253"
+  integrity sha512-bxZ9qtSlGUWSOy9Qa9Xgk11kSslpuZwaxCg4sNIDj6FLucDab2JxnHwyNTCpHMtK1MjoQiWQ6DiUMZYbSrO+Sw==
+  dependencies:
+    inherits "^2.0.3"
+    is-arguments "^1.0.4"
+    is-generator-function "^1.0.7"
+    is-typed-array "^1.1.3"
+    safe-buffer "^5.1.2"
+    which-typed-array "^1.1.2"
+
 utils-merge@1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
@@ -9057,6 +9792,11 @@ verror@1.10.0:
     core-util-is "1.0.2"
     extsprintf "^1.2.0"
 
+vm-browserify@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0"
+  integrity sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==
+
 void-elements@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/void-elements/-/void-elements-2.0.1.tgz#c066afb582bb1cb4128d60ea92392e94d5e9dbec"
@@ -9206,6 +9946,29 @@ whatwg-url@^7.0.0:
     tr46 "^1.0.1"
     webidl-conversions "^4.0.2"
 
+which-boxed-primitive@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6"
+  integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
+  dependencies:
+    is-bigint "^1.0.1"
+    is-boolean-object "^1.1.0"
+    is-number-object "^1.0.4"
+    is-string "^1.0.5"
+    is-symbol "^1.0.3"
+
+which-typed-array@^1.1.2:
+  version "1.1.7"
+  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.7.tgz#2761799b9a22d4b8660b3c1b40abaa7739691793"
+  integrity sha512-vjxaB4nfDqwKI0ws7wZpxIlde1XrLX5uB0ZjpfshgmapJMD7jJWhZI+yToJTqaFByF0eNBcYxbjmCzoRP7CfEw==
+  dependencies:
+    available-typed-arrays "^1.0.5"
+    call-bind "^1.0.2"
+    es-abstract "^1.18.5"
+    foreach "^2.0.5"
+    has-tostringtag "^1.0.0"
+    is-typed-array "^1.1.7"
+
 which@2.0.2, which@^2.0.1, which@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
@@ -9285,6 +10048,11 @@ xtend@^4.0.0, xtend@~4.0.1:
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af"
   integrity sha1-pcbVMr5lbiPbgg77lDofBJmNY68=
 
+xtend@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
+  integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
+
 y18n@^5.0.5:
   version "5.0.7"
   resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.7.tgz#0c514aba53fc40e2db911aeb8b51566a3374efe7"

From 24e7ab5774c9e7c42d37f218a34f6fe7fe75513a Mon Sep 17 00:00:00 2001
From: Carlos Rodrigues <carlos@hypermob.co.uk>
Date: Sat, 30 Apr 2022 18:08:55 +0100
Subject: [PATCH 026/317] change image to node:lts

---
 .circleci/config.yml | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 9c940960845..347a369b2fb 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -3,7 +3,7 @@ version: 2
 defaults: &defaults
   working_directory: ~/project/vue
   docker:
-    - image: vuejs/ci
+    - image: node:lts
 
 jobs:
   install:
@@ -15,6 +15,7 @@ jobs:
             - v1-vue-{{ .Branch }}-{{ checksum "yarn.lock" }}
             - v1-vue-{{ .Branch }}-
             - v1-vue-
+
       - run: npm install
       - save_cache:
           key: v1-vue-{{ .Branch }}-{{ checksum "yarn.lock" }}
@@ -41,11 +42,11 @@ jobs:
           at: ~/project
       - run: npm run test:cover
       - run:
-         name: report coverage stats for non-PRs
-         command: |
-           if [[ -z $CI_PULL_REQUEST ]]; then
-             ./node_modules/.bin/codecov
-           fi
+          name: report coverage stats for non-PRs
+          command: |
+            if [[ -z $CI_PULL_REQUEST ]]; then
+              ./node_modules/.bin/codecov
+            fi
 
   test-e2e:
     <<: *defaults
@@ -107,8 +108,7 @@ workflows:
           cron: "0 13 * * 1"
           filters:
             branches:
-              only:
-                dev
+              only: dev
     jobs:
       - install
       - test-cover:

From be4b617942ed288056978ce9d593a2c4887b95b9 Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Sun, 1 May 2022 14:37:05 -0600
Subject: [PATCH 027/317] chore: cleanup on tests; babel preset for typescript
 help

---
 .babelrc.js                                   |   1 +
 package.json                                  |   1 +
 src/compiler/codeframe.ts                     |   2 +-
 src/compiler/create-compiler.ts               |   6 +-
 src/compiler/to-function.ts                   |   2 +-
 src/core/vdom/patch.ts                        |   2 +-
 test/helpers/to-have-been-warned.ts           |   8 +-
 test/helpers/trigger-event.ts                 |   5 +-
 test/helpers/vdom.ts                          |   2 +-
 test/helpers/wait-for-update.ts               |   8 +-
 .../component/component-async.spec.ts         |   7 +-
 .../component/component-keep-alive.spec.ts    |  42 +++---
 .../features/component/component-slot.spec.ts |  18 +--
 test/unit/features/debug.spec.ts              |   3 +-
 test/unit/features/directives/on.spec.ts      |   6 +-
 test/unit/features/error-handling.spec.ts     |  23 +--
 test/unit/features/global-api/extend.spec.ts  |   2 +-
 test/unit/features/global-api/mixin.spec.ts   |   2 +-
 .../unit/features/instance/properties.spec.ts |   2 +-
 .../features/options/errorCaptured.spec.ts    |   4 +-
 test/unit/features/options/lifecycle.spec.ts  |   4 +-
 test/unit/features/options/render.spec.ts     |   2 +-
 .../unit/features/transition/inject-styles.ts |   4 +-
 .../features/transition/transition.spec.ts    |  74 +++++-----
 test/unit/global.d.ts                         |  15 ++
 test/unit/karma.cover.config.ts               |   8 +-
 test/unit/modules/observer/observer.spec.ts   |   2 +-
 test/unit/modules/observer/scheduler.spec.ts  |   6 +-
 test/unit/modules/vdom/create-element.spec.ts |   2 +-
 .../modules/vdom/modules/dom-props.spec.ts    |   2 +-
 test/unit/modules/vdom/modules/events.spec.ts |  30 ++--
 test/unit/modules/vdom/patch/children.spec.ts |   6 +-
 .../modules/vdom/patch/edge-cases.spec.ts     |   2 +-
 test/unit/modules/vdom/patch/hooks.spec.ts    |  25 ++--
 .../unit/modules/vdom/patch/hydration.spec.ts |   2 +-
 test/weex/cases/cases.spec.ts                 |   2 +-
 test/weex/helpers/index.ts                    |   2 +-
 tsconfig.json                                 |   4 +-
 types/test/tsconfig.json                      |  11 +-
 types/tsconfig.json                           |  11 --
 typescript/modules.d.ts                       |  12 ++
 yarn.lock                                     | 132 +++++++-----------
 42 files changed, 245 insertions(+), 259 deletions(-)
 delete mode 100644 types/tsconfig.json

diff --git a/.babelrc.js b/.babelrc.js
index 4d2b9e504cc..c6346183a9a 100644
--- a/.babelrc.js
+++ b/.babelrc.js
@@ -2,6 +2,7 @@
 module.exports = {
   presets: [
     "@babel/preset-env",
+    "@babel/preset-typescript"
   ],
   plugins: [
     require("babel-plugin-transform-vue-jsx"),
diff --git a/package.json b/package.json
index c39fbb9e2c5..ab6e5b6b4ec 100644
--- a/package.json
+++ b/package.json
@@ -75,6 +75,7 @@
     "@babel/plugin-syntax-jsx": "^7.16.7",
     "@babel/plugin-transform-flow-strip-types": "^7.16.7",
     "@babel/preset-env": "^7.17.10",
+    "@babel/preset-typescript": "^7.16.7",
     "@babel/register": "^7.17.7",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-buble": "^0.21.3",
diff --git a/src/compiler/codeframe.ts b/src/compiler/codeframe.ts
index 021592727e5..a06f387f45a 100644
--- a/src/compiler/codeframe.ts
+++ b/src/compiler/codeframe.ts
@@ -37,7 +37,7 @@ export function generateCodeFrame(
   return res.join('\n')
 }
 
-function repeat(str, n) {
+function repeat(str: string, n: number) {
   let result = ''
   if (n > 0) {
     // eslint-disable-next-line no-constant-condition
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index 63872650af8..7c29513f383 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -13,7 +13,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
       const errors: WarningMessage[] = []
       const tips: WarningMessage[] = []
 
-      let warn = (msg, range, tip) => {
+      let warn = (msg: WarningMessage, range: { start: number, end: number }, tip: string) => {
         (tip ? tips : errors).push(msg)
       }
 
@@ -25,7 +25,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
           // $flow-disable-line
           const leadingSpaceLength = template.match(/^\s*/)![0].length
 
-          warn = (msg, range, tip) => {
+          warn = (msg: WarningMessage, range: { start: number, end: number }, tip: string) => {
             const data: WarningMessage = { msg }
             if (range) {
               if (range.start != null) {
@@ -54,7 +54,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
         // copy other options
         for (const key in options) {
           if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key]
+            finalOptions[key] = options[key as keyof CompilerOptions]
           }
         }
       }
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index aaf9c01626d..8a384b5d07c 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -90,7 +90,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
 
     // turn code into functions
     const res: any = {}
-    const fnGenErrors = []
+    const fnGenErrors: any[] = []
     res.render = createFunction(compiled.render, fnGenErrors)
     res.staticRenderFns = compiled.staticRenderFns.map((code) => {
       return createFunction(code, fnGenErrors)
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index ce250b97c9d..5f925a5ca71 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -830,7 +830,7 @@ export function createPatchFunction(backend) {
     }
 
     let isInitialPatch = false
-    const insertedVnodeQueue = []
+    const insertedVnodeQueue: any[] = []
 
     if (isUndef(oldVnode)) {
       // empty mount (likely as component), create new root element
diff --git a/test/helpers/to-have-been-warned.ts b/test/helpers/to-have-been-warned.ts
index 6928542a705..2a462814597 100644
--- a/test/helpers/to-have-been-warned.ts
+++ b/test/helpers/to-have-been-warned.ts
@@ -51,8 +51,12 @@ beforeEach(() => {
   spyOn(console, 'warn')
   spyOn(console, 'error')
   jasmine.addMatchers({
-    toHaveBeenWarned: () => createCompareFn(console.error),
-    toHaveBeenTipped: () => createCompareFn(console.warn)
+    toHaveBeenWarned: () => 
+      // @ts-ignore
+      createCompareFn(console.error),
+    toHaveBeenTipped: () => 
+      // @ts-ignore
+      createCompareFn(console.warn)
   })
 })
 
diff --git a/test/helpers/trigger-event.ts b/test/helpers/trigger-event.ts
index e2825135730..8fb5a2274ee 100644
--- a/test/helpers/trigger-event.ts
+++ b/test/helpers/trigger-event.ts
@@ -1,8 +1,9 @@
-window.triggerEvent = function triggerEvent (target, event, process) {
+global.triggerEvent = function triggerEvent (target, event, process) {
   const e = document.createEvent('HTMLEvents')
   e.initEvent(event, true, true)
   if (event === 'click') {
-    e.button = 0
+    // @ts-expect-error Button is readonly
+    (e as MouseEvent).button = 0
   }
   if (process) process(e)
   target.dispatchEvent(e)
diff --git a/test/helpers/vdom.ts b/test/helpers/vdom.ts
index abfb189054b..ab74df8f621 100644
--- a/test/helpers/vdom.ts
+++ b/test/helpers/vdom.ts
@@ -1,5 +1,5 @@
 import VNode from 'core/vdom/vnode'
 
-window.createTextVNode = function (text) {
+global.createTextVNode = function (text) {
   return new VNode(undefined, undefined, undefined, text)
 }
diff --git a/test/helpers/wait-for-update.ts b/test/helpers/wait-for-update.ts
index 37f87dbd3cd..0a351b68313 100644
--- a/test/helpers/wait-for-update.ts
+++ b/test/helpers/wait-for-update.ts
@@ -12,7 +12,7 @@ import Vue from 'vue'
 //   // more assertions...
 // })
 // .then(done)
-window.waitForUpdate = initialCb => {
+globalThis.waitForUpdate = initialCb => {
   let end
   const queue = initialCb ? [initialCb] : []
 
@@ -21,7 +21,7 @@ window.waitForUpdate = initialCb => {
     if (queue.length) {
       let hasError = false
       try {
-        job.wait ? job(shift) : job()
+        job.wait ? job(shift) : (job ? job() : null)
       } catch (e) {
         hasError = true
         const done = queue[queue.length - 1]
@@ -29,7 +29,7 @@ window.waitForUpdate = initialCb => {
           done.fail(e)
         }
       }
-      if (!hasError && !job.wait) {
+      if (!hasError && !job?.wait) {
         if (queue.length) {
           Vue.nextTick(shift)
         }
@@ -40,7 +40,7 @@ window.waitForUpdate = initialCb => {
   }
 
   Vue.nextTick(() => {
-    if (!queue.length || (!end && !queue[queue.length - 1].fail)) {
+    if (!queue.length || (!end && !queue[queue.length - 1]?.fail)) {
       throw new Error('waitForUpdate chain is missing .then(done)')
     }
     shift()
diff --git a/test/unit/features/component/component-async.spec.ts b/test/unit/features/component/component-async.spec.ts
index ce4f8624f37..f4f6cf14cf1 100644
--- a/test/unit/features/component/component-async.spec.ts
+++ b/test/unit/features/component/component-async.spec.ts
@@ -15,7 +15,8 @@ describe('Component async', () => {
     // reset the timeouts for this iteration
     timeoutsPending = {};
 
-    window.setTimeout = function(func, delay) {
+    // @ts-expect-error
+    global.setTimeout = function(func, delay) {
       const id = oldSetTimeout(function() {
         delete timeoutsPending[id];
         func();
@@ -152,7 +153,7 @@ describe('Component async', () => {
       expect(vm.$el.tagName).toBe('P')
       expect(vm.$el.textContent).toBe('B')
       vm.view = 'view-a'
-      waitForUpdate(function () {
+      global.waitForUpdate(function () {
         expect(vm.$el.tagName).toBe('DIV')
         expect(vm.$el.textContent).toBe('A')
       }).then(done)
@@ -431,7 +432,7 @@ describe('Component async', () => {
       }).$mount()
 
       expect(vm.$el.textContent).toBe('one ')
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.textContent).toBe('one two')
       }).then(done)
     })
diff --git a/test/unit/features/component/component-keep-alive.spec.ts b/test/unit/features/component/component-keep-alive.spec.ts
index 9d30d2c7d58..8c415ee5d27 100644
--- a/test/unit/features/component/component-keep-alive.spec.ts
+++ b/test/unit/features/component/component-keep-alive.spec.ts
@@ -60,7 +60,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [0, 0, 0, 0, 0])
     vm.view = 'two'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('two')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
@@ -104,7 +104,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [1, 1, 1, 0, 0])
     vm.ok = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 1, 0])
@@ -145,7 +145,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [1, 1, 1, 0, 0])
     vm.ok = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 1, 0])
@@ -214,7 +214,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [0, 0, 0, 0, 0])
     vm.view = 'two'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('two')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 0, 0, 0])
@@ -379,7 +379,7 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     vm.view = 'two'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.include = 'two'
@@ -410,7 +410,7 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     vm.view = 'two'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.include = 'one'
@@ -439,7 +439,7 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     vm.include = 'two'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
@@ -468,7 +468,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(two, [1, 1, 1, 0, 0])
 
     vm.ok = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 1, 1])
       assertHookCalls(two, [1, 1, 1, 1, 1])
     }).then(done)
@@ -498,7 +498,7 @@ describe('Component keep-alive', () => {
 
     expect(vm.$el.textContent).toBe('one 1')
     vm.n++
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('one 2')
       vm.view = 'two'
     }).then(() => {
@@ -555,7 +555,7 @@ describe('Component keep-alive', () => {
 
     assertCount([1, 0, 0, 0, 0, 0])
     vm.n = 'bb'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       assertCount([1, 0, 1, 0, 0, 0])
       vm.n = 'cc'
     }).then(() => {
@@ -621,7 +621,7 @@ describe('Component keep-alive', () => {
 
     assertCount([1, 0, 0, 0, 0, 0])
     vm.n = 'bb'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       // should prune A because max cache reached
       assertCount([1, 1, 1, 0, 0, 0])
       vm.n = 'cc'
@@ -686,7 +686,7 @@ describe('Component keep-alive', () => {
     expect(vm.$el.textContent).toBe('foo')
     assert(1, 0)
     vm.view = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('bar')
       assert(1, 1)
       vm.view = true
@@ -738,7 +738,7 @@ describe('Component keep-alive', () => {
     expect(vm.$el.textContent).toBe('foo')
     assert(1, 0)
     vm.view = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('bar')
       assert(1, 1)
       vm.view = true
@@ -773,7 +773,7 @@ describe('Component keep-alive', () => {
     }).$mount()
     // condition: a render where a previous component is reused
     vm.include = ['foo']
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       vm.include = ['']
     }).then(() => {
       expect(Foo.destroyed).not.toHaveBeenCalled()
@@ -805,7 +805,7 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">one</div><!---->'
         )
@@ -890,7 +890,7 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">one</div><!---->'
         )
@@ -975,7 +975,7 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
@@ -1066,7 +1066,7 @@ describe('Component keep-alive', () => {
       }).$mount(el)
       expect(vm.$el.textContent).toBe('one')
       vm.view = 'two'
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
@@ -1134,7 +1134,7 @@ describe('Component keep-alive', () => {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.view = 'bar'
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test v-leave v-leave-active">foo</div>' +
           '<div class="test test-enter test-enter-active">bar</div>'
@@ -1210,7 +1210,7 @@ describe('Component keep-alive', () => {
       next = () => {
         assertHookCalls(one, [1, 1, 1, 0, 0])
         assertHookCalls(two, [0, 0, 0, 0, 0])
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(vm.$el.innerHTML).toBe(
             '<div class="test test-enter test-enter-active">one</div>'
           )
@@ -1274,7 +1274,7 @@ describe('Component keep-alive', () => {
       btn.click()
       expect(vm.n).toBe(1)
       vm.showBtn = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         vm.showBtn = true
       }).then(() => {
         btn.click()
diff --git a/test/unit/features/component/component-slot.spec.ts b/test/unit/features/component/component-slot.spec.ts
index aeaf4615ac9..d9367956e93 100644
--- a/test/unit/features/component/component-slot.spec.ts
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -218,7 +218,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.textContent).toBe('12')
     vm.a = 2
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('22')
       vm.show = false
     }).then(() => {
@@ -255,7 +255,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<div><p>foo</p></div>')
     vm.msg = 'bar'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('<div><p>bar</p></div>')
     }).then(done)
   })
@@ -275,7 +275,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<p>hi</p>')
     vm.ok = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('fallback')
       vm.ok = true
       vm.msg = 'bye'
@@ -475,14 +475,14 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.textContent).toBe('foo1')
     vm.$children[0].a = 2
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('foo2')
     }).then(done)
   })
 
   // #3437
   it('should correctly re-create components in slot', done => {
-    const calls = []
+    const calls: any[] = []
     const vm = new Vue({
       template: `
         <comp ref="child">
@@ -512,7 +512,7 @@ describe('Component slot', () => {
 
     expect(calls).toEqual([1])
     vm.$refs.child.ok = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(calls).toEqual([1, 2])
       vm.$refs.child.ok = true
     }).then(() => {
@@ -550,7 +550,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe(`<div>1</div> <div>1</div> <pre><div>1</div></pre>`)
     vm.n++
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe(`<div>2</div> <div>2</div> <pre><div>2</div></pre>`)
       vm.n++
     }).then(() => {
@@ -586,10 +586,10 @@ describe('Component slot', () => {
     document.body.appendChild(vm.$el)
     expect(vm.$el.textContent).toBe('hi')
     vm.$children[0].toggle = false
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       vm.$children[0].toggle = true
     }).then(() => {
-      triggerEvent(vm.$el.querySelector('.click'), 'click')
+      global.triggerEvent(vm.$el.querySelector('.click'), 'click')
       expect(spy).toHaveBeenCalled()
     }).then(() => {
       document.body.removeChild(vm.$el)
diff --git a/test/unit/features/debug.spec.ts b/test/unit/features/debug.spec.ts
index ff4953245fa..f66b1c4084f 100644
--- a/test/unit/features/debug.spec.ts
+++ b/test/unit/features/debug.spec.ts
@@ -83,7 +83,7 @@ found in
 
   describe('warn', () => {
     const msg = 'message'
-    const vm = new Vue()
+    const vm = new Vue('div')
 
     it('calls warnHandler if warnHandler is set', () => {
       Vue.config.warnHandler = jasmine.createSpy()
@@ -92,6 +92,7 @@ found in
 
       expect(Vue.config.warnHandler).toHaveBeenCalledWith(msg, vm, jasmine.any(String))
 
+      // @ts-expect-error
       Vue.config.warnHandler = null
     })
 
diff --git a/test/unit/features/directives/on.spec.ts b/test/unit/features/directives/on.spec.ts
index 353d3df5372..46f0f9a9881 100644
--- a/test/unit/features/directives/on.spec.ts
+++ b/test/unit/features/directives/on.spec.ts
@@ -103,7 +103,7 @@ describe('Directive v-on', () => {
   })
 
   it('should support capture', () => {
-    const callOrder = []
+    const callOrder: any[] = []
     vm = new Vue({
       el,
       template: `
@@ -159,7 +159,7 @@ describe('Directive v-on', () => {
   })
 
   it('should support capture and once', () => {
-    const callOrder = []
+    const callOrder: any[] = []
     vm = new Vue({
       el,
       template: `
@@ -1072,7 +1072,7 @@ describe('Directive v-on', () => {
     })
 
     it('with .capture modifier', () => {
-      const callOrder = []
+      const callOrder: any[] = []
       const vm = new Vue({
         template: `
           <div @[key].capture="foo">
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index 7dd36dc9f1f..c8d624587e0 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -32,7 +32,7 @@ describe('Error handling', () => {
   ].forEach(([type, description]) => {
     it(`should recover from promise errors in ${type}`, done => {
       createTestInstance(components[`${type}Async`])
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
         expect(`Error: ${type}`).toHaveBeenWarned()
       }).then(done)
@@ -84,7 +84,7 @@ describe('Error handling', () => {
     it(`should recover from errors in ${type} hook`, done => {
       const vm = createTestInstance(components[type])
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(`Error in ${description}`).toHaveBeenWarned()
         expect(`Error: ${type}`).toHaveBeenWarned()
       }).thenWaitFor(next => {
@@ -111,12 +111,12 @@ describe('Error handling', () => {
   it('should recover from errors in user watcher getter', done => {
     const vm = createTestInstance(components.userWatcherGetter)
     vm.n++
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(`Error in getter for watcher`).toHaveBeenWarned()
       function getErrorMsg () {
         try {
           this.a.b.c
-        } catch (e) {
+        } catch (e: any) {
           return e.toString()
         }
       }
@@ -158,6 +158,7 @@ describe('Error handling', () => {
     expect(args[2]).toContain('render') // description
 
     assertRootInstanceActive(vm).then(() => {
+      // @ts-expect-error
       Vue.config.errorHandler = null
     }).then(done)
   })
@@ -210,7 +211,7 @@ describe('Error handling', () => {
         methods: { bork () { throw new Error('v-on') } }
       }).$mount()
       document.body.appendChild(vm.$el)
-      triggerEvent(vm.$el, 'click')
+      global.triggerEvent(vm.$el, 'click')
       expect('Error in v-on handler').toHaveBeenWarned()
       expect('Error: v-on').toHaveBeenWarned()
       document.body.removeChild(vm.$el)
@@ -224,8 +225,8 @@ describe('Error handling', () => {
         } }
       }).$mount()
       document.body.appendChild(vm.$el)
-      triggerEvent(vm.$el, 'click')
-      waitForUpdate(() => {
+      global.triggerEvent(vm.$el, 'click')
+      global.waitForUpdate(() => {
         expect('Error in v-on handler (Promise/async)').toHaveBeenWarned()
         expect('Error: v-on').toHaveBeenWarned()
         document.body.removeChild(vm.$el)
@@ -235,7 +236,7 @@ describe('Error handling', () => {
 })
 
 function createErrorTestComponents () {
-  const components = {}
+  const components: any = {}
 
   // data
   components.data = {
@@ -431,17 +432,17 @@ function createTestInstance (Comp) {
   }).$mount()
 }
 
-function assertRootInstanceActive (vm, chain) {
+function assertRootInstanceActive (vm) {
   expect(vm.$el.innerHTML).toContain('n:0\n')
   vm.n++
-  return waitForUpdate(() => {
+  return global.waitForUpdate(() => {
     expect(vm.$el.innerHTML).toContain('n:1\n')
   })
 }
 
 function assertBothInstancesActive (vm) {
   vm.n = 0
-  return waitForUpdate(() => {
+  return global.waitForUpdate(() => {
     expect(vm.$refs.child.$el.innerHTML).toContain('0')
   }).thenWaitFor(next => {
     assertRootInstanceActive(vm).then(() => {
diff --git a/test/unit/features/global-api/extend.spec.ts b/test/unit/features/global-api/extend.spec.ts
index f0867ac1b5a..f8ab40c6f6a 100644
--- a/test/unit/features/global-api/extend.spec.ts
+++ b/test/unit/features/global-api/extend.spec.ts
@@ -52,7 +52,7 @@ describe('Global API: extend', () => {
   })
 
   it('should merge lifecycle hooks', () => {
-    const calls = []
+    const calls: any[] = []
     const A = Vue.extend({
       created () {
         calls.push(1)
diff --git a/test/unit/features/global-api/mixin.spec.ts b/test/unit/features/global-api/mixin.spec.ts
index 14b65918c50..8ba796b0676 100644
--- a/test/unit/features/global-api/mixin.spec.ts
+++ b/test/unit/features/global-api/mixin.spec.ts
@@ -19,7 +19,7 @@ describe('Global API: mixin', () => {
   })
 
   it('should work for constructors created before mixin is applied', () => {
-    const calls = []
+    const calls: any[] = []
     const Test = Vue.extend({
       name: 'test',
       beforeCreate () {
diff --git a/test/unit/features/instance/properties.spec.ts b/test/unit/features/instance/properties.spec.ts
index abe1cc62c16..8f220fbdc74 100644
--- a/test/unit/features/instance/properties.spec.ts
+++ b/test/unit/features/instance/properties.spec.ts
@@ -55,7 +55,7 @@ describe('Instance properties', () => {
   })
 
   it('$parent', () => {
-    const calls = []
+    const calls: any[] = []
     const makeOption = name => ({
       name,
       template: `<div><slot></slot></div>`,
diff --git a/test/unit/features/options/errorCaptured.spec.ts b/test/unit/features/options/errorCaptured.spec.ts
index 0c1aba35b79..516af743c85 100644
--- a/test/unit/features/options/errorCaptured.spec.ts
+++ b/test/unit/features/options/errorCaptured.spec.ts
@@ -120,7 +120,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should work across multiple parents, mixins and extends', () => {
-    const calls = []
+    const calls: any[] = []
 
     const Child = {
       created () {
@@ -165,7 +165,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should work across multiple parents, mixins and extends with return false', () => {
-    const calls = []
+    const calls: any[] = []
 
     const Child = {
       created () {
diff --git a/test/unit/features/options/lifecycle.spec.ts b/test/unit/features/options/lifecycle.spec.ts
index 6f48ba06368..a1e83b056ac 100644
--- a/test/unit/features/options/lifecycle.spec.ts
+++ b/test/unit/features/options/lifecycle.spec.ts
@@ -91,7 +91,7 @@ describe('Options lifecycle hooks', () => {
     })
 
     it('should mount child parent in correct order', () => {
-      const calls = []
+      const calls: any[] = []
       new Vue({
         template: '<div><test></test></div>',
         mounted () {
@@ -210,7 +210,7 @@ describe('Options lifecycle hooks', () => {
     })
 
     it('should be called after children are updated', done => {
-      const calls = []
+      const calls: any[] = []
       const vm = new Vue({
         template: '<div><test ref="child">{{ msg }}</test></div>',
         data: { msg: 'foo' },
diff --git a/test/unit/features/options/render.spec.ts b/test/unit/features/options/render.spec.ts
index 302e2ee0098..736afa2ca4d 100644
--- a/test/unit/features/options/render.spec.ts
+++ b/test/unit/features/options/render.spec.ts
@@ -4,7 +4,7 @@ describe('Options render', () => {
   it('basic usage', () => {
     const vm = new Vue({
       render (h) {
-        const children = []
+        const children: any[] = []
         for (let i = 0; i < this.items.length; i++) {
           children.push(h('li', { staticClass: 'task' }, [this.items[i].name]))
         }
diff --git a/test/unit/features/transition/inject-styles.ts b/test/unit/features/transition/inject-styles.ts
index 34185096f62..e2f8f87ccf9 100644
--- a/test/unit/features/transition/inject-styles.ts
+++ b/test/unit/features/transition/inject-styles.ts
@@ -4,8 +4,8 @@ function insertCSS (text) {
   document.head.appendChild(cssEl)
 }
 
-const duration = process.env.TRANSITION_DURATION || 50
-const buffer = process.env.TRANSITION_BUFFER || 10
+const duration = parseInt(process.env.TRANSITION_DURATION || '50')
+const buffer = parseInt(process.env.TRANSITION_BUFFER || '10')
 let injected = false
 
 export default function injectStyles () {
diff --git a/test/unit/features/transition/transition.spec.ts b/test/unit/features/transition/transition.spec.ts
index 6bfc8e7e53b..aa3bdee579f 100644
--- a/test/unit/features/transition/transition.spec.ts
+++ b/test/unit/features/transition/transition.spec.ts
@@ -5,7 +5,7 @@ import { nextFrame } from 'web/runtime/transition-util'
 
 if (!isIE9) {
   describe('Transition basic', () => {
-    const { duration, buffer } = injectStyles()
+    const { duration, buffer } = injectStyles() as { duration: number, buffer: number }
     const explicitDuration = duration * 2
 
     let el
@@ -23,7 +23,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -48,7 +48,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -85,7 +85,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test bye byebye active more')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test byebye active more bye-to')
@@ -119,7 +119,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -165,7 +165,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test bye byebye active')
         expect(leave).toHaveBeenCalled()
       }).thenWaitFor(nextFrame).then(() => {
@@ -233,7 +233,7 @@ if (!isIE9) {
 
       let _el = vm.$el.children[0]
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
         expect(onLeaveSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
@@ -318,7 +318,7 @@ if (!isIE9) {
 
       let _el = vm.$el.children[0]
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
         expect(onLeaveSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
@@ -362,7 +362,7 @@ if (!isIE9) {
         }
       }).$mount(el)
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -404,7 +404,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(leaveSpy).toHaveBeenCalled()
         expect(vm.$el.innerHTML).toBe('<!---->')
         vm.ok = true
@@ -427,7 +427,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(leaveSpy).toHaveBeenCalled()
         expect(vm.$el.innerHTML).toBe('<div class="nope-leave nope-leave-active">foo</div><!---->')
       }).thenWaitFor(nextFrame).then(() => {
@@ -459,7 +459,7 @@ if (!isIE9) {
 
       expect(vm.$el.innerHTML).toBe('<!---->')
       vm.ok = true
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
@@ -493,7 +493,7 @@ if (!isIE9) {
 
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(duration / 2).then(() => {
         vm.ok = true
@@ -525,7 +525,7 @@ if (!isIE9) {
       expect(vm.$el.children[0].style.display).toBe('')
       expect(vm.$el.children[0].className).toBe('test')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -561,7 +561,7 @@ if (!isIE9) {
       expect(vm.$el.textContent).toBe('foo')
       expect(vm.$el.children[0].style.display).toBe('')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -596,7 +596,7 @@ if (!isIE9) {
 
       expect(vm.$el.children[0].style.display).toBe('')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -625,7 +625,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         vm.ok = true
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
@@ -647,7 +647,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = true
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         vm.ok = false
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -671,7 +671,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div>foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
@@ -702,7 +702,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-anim-long-leave test-anim-long-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-anim-long-leave-active test-anim-long-leave-to')
@@ -739,7 +739,7 @@ if (!isIE9) {
         data: { ok: true }
       }).$mount(el)
 
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
@@ -760,7 +760,7 @@ if (!isIE9) {
         data: { ok: true }
       }).$mount(el)
 
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
@@ -784,7 +784,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave-active v-leave-to')
@@ -826,7 +826,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -864,7 +864,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -898,7 +898,7 @@ if (!isIE9) {
         }
       }).$mount(el)
 
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
@@ -937,7 +937,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -976,7 +976,7 @@ if (!isIE9) {
         }
       }).$mount(el)
 
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
@@ -1010,7 +1010,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -1048,7 +1048,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1078,7 +1078,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1108,7 +1108,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1141,7 +1141,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1180,7 +1180,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1228,7 +1228,7 @@ if (!isIE9) {
         }).$mount(el)
 
         vm.ok = false
-        waitForUpdate(() => {
+        global.waitForUpdate(() => {
           expect(`<transition> explicit leave duration is not a valid number - got "foo"`).toHaveBeenWarned()
         }).thenWaitFor(duration + buffer).then(() => {
           vm.ok = true
@@ -1262,7 +1262,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<!---->')
       vm.view = 'two'
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe('<div class="test v-enter v-enter-active">two</div>')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
@@ -1297,7 +1297,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      waitForUpdate(() => {
+      global.waitForUpdate(() => {
         expect(vm.$el.children[0].innerHTML).toBe('false')
       }).then(done)
     })
diff --git a/test/unit/global.d.ts b/test/unit/global.d.ts
index 6d72e300690..5b7e275071c 100644
--- a/test/unit/global.d.ts
+++ b/test/unit/global.d.ts
@@ -1,3 +1,18 @@
 declare function waitForUpdate(
   cb: Function
 ): any;
+
+declare namespace jasmine {
+  interface Matchers<T> {
+    toHaveBeenWarned(): void;
+    toHaveBeenTipped(): void;
+  }
+
+  interface ArrayLikeMatchers<T> {
+    toHaveBeenWarned(): void;
+    toHaveBeenTipped(): void;
+  }
+}
+
+// @ts-ignore
+declare let global: typeof globalThis;
diff --git a/test/unit/karma.cover.config.ts b/test/unit/karma.cover.config.ts
index 062138e5058..711c29b45fe 100644
--- a/test/unit/karma.cover.config.ts
+++ b/test/unit/karma.cover.config.ts
@@ -2,7 +2,7 @@ const base = require('./karma.base.config.ts')
 
 process.env.CHROME_BIN = require('puppeteer').executablePath()
 
-module.exports = function (config) {
+module.exports = function (config: any) {
   const options = Object.assign(base, {
     browsers: ['ChromeHeadlessCI'],
     customLaunchers: {
@@ -30,9 +30,9 @@ module.exports = function (config) {
     plugins: [['istanbul', {
       exclude: [
         'test/',
-        'src/compiler/parser/html-parser.js',
-        'src/core/instance/proxy.js',
-        'src/sfc/deindent.js',
+        'src/compiler/parser/html-parser.ts',
+        'src/core/instance/proxy.ts',
+        'src/sfc/deindent.ts',
         'src/platforms/weex/'
       ]
     }]]
diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index f81813717d8..540be60bc8d 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -326,7 +326,7 @@ describe('Observer', () => {
   })
 
   it('observing array mutation', () => {
-    const arr = []
+    const arr: any[] = []
     const ob = observe(arr)
     const dep = ob.dep
     spyOn(dep, 'notify')
diff --git a/test/unit/modules/observer/scheduler.spec.ts b/test/unit/modules/observer/scheduler.spec.ts
index 1443375356e..20409957e7f 100644
--- a/test/unit/modules/observer/scheduler.spec.ts
+++ b/test/unit/modules/observer/scheduler.spec.ts
@@ -54,7 +54,7 @@ describe('Scheduler', () => {
   })
 
   it('call user watchers before component re-render', done => {
-    const calls = []
+    const calls: any[] = []
     const vm = new Vue({
       data: {
         a: 1
@@ -75,7 +75,7 @@ describe('Scheduler', () => {
 
   it('call user watcher triggered by component re-render immediately', done => {
     // this happens when a component re-render updates the props of a child
-    const calls = []
+    const calls: any[] = []
     const vm = new Vue({
       data: {
         a: 1
@@ -127,7 +127,7 @@ describe('Scheduler', () => {
   })
 
   it('should call newly pushed watcher after current watcher is done', done => {
-    const callOrder = []
+    const callOrder: any[] = []
     queueWatcher({
       id: 1,
       user: true,
diff --git a/test/unit/modules/vdom/create-element.spec.ts b/test/unit/modules/vdom/create-element.spec.ts
index 68773850be7..405ad4143ad 100644
--- a/test/unit/modules/vdom/create-element.spec.ts
+++ b/test/unit/modules/vdom/create-element.spec.ts
@@ -230,7 +230,7 @@ describe('create-element', () => {
     const vm = new Vue({
       data: { n: 1 },
       render (h) {
-        const list = []
+        const list: any[] = []
         for (let i = 0; i < this.n; i++) {
           list.push(h('span', i))
         }
diff --git a/test/unit/modules/vdom/modules/dom-props.spec.ts b/test/unit/modules/vdom/modules/dom-props.spec.ts
index 90176759ab3..1fd098a022f 100644
--- a/test/unit/modules/vdom/modules/dom-props.spec.ts
+++ b/test/unit/modules/vdom/modules/dom-props.spec.ts
@@ -80,7 +80,7 @@ describe('vdom domProps module', () => {
 
     expect(vm.$el.id).toBe('foo')
     vm.props.id = 'bar'
-    waitForUpdate(() => {
+    global.waitForUpdate(() => {
       expect(vm.$el.id).toBe('bar')
       vm.props = { id: 'baz' }
     }).then(() => {
diff --git a/test/unit/modules/vdom/modules/events.spec.ts b/test/unit/modules/vdom/modules/events.spec.ts
index 9dcd72c4774..b59935adbf8 100644
--- a/test/unit/modules/vdom/modules/events.spec.ts
+++ b/test/unit/modules/vdom/modules/events.spec.ts
@@ -8,7 +8,7 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
   })
 
@@ -20,7 +20,7 @@ describe('vdom events module', () => {
     const elm = patch(null, vnode1)
     patch(vnode1, vnode2)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
   })
 
@@ -32,12 +32,12 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
     expect(click2.calls.count()).toBe(0)
 
     patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
     expect(click2.calls.count()).toBe(1)
   })
@@ -48,7 +48,7 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(2)
   })
 
@@ -60,12 +60,12 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
     expect(click2.calls.count()).toBe(1)
 
     patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(2)
     expect(click2.calls.count()).toBe(1)
   })
@@ -77,11 +77,11 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
 
     patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
   })
 
@@ -92,11 +92,11 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(2)
 
     patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(2)
   })
 
@@ -112,22 +112,22 @@ describe('vdom events module', () => {
 
     const elm = patch(null, vnode0)
     document.body.appendChild(elm)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(1)
     expect(click2.calls.count()).toBe(0)
 
     patch(vnode0, vnode1)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(2)
     expect(click2.calls.count()).toBe(1)
 
     patch(vnode1, vnode2)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(3)
     expect(click2.calls.count()).toBe(1)
 
     patch(vnode2, vnode3)
-    triggerEvent(elm, 'click')
+    global.triggerEvent(elm, 'click')
     expect(click.calls.count()).toBe(3)
     expect(click2.calls.count()).toBe(2)
     expect(click3.calls.count()).toBe(1)
diff --git a/test/unit/modules/vdom/patch/children.spec.ts b/test/unit/modules/vdom/patch/children.spec.ts
index f42c5413edd..202a4314d06 100644
--- a/test/unit/modules/vdom/patch/children.spec.ts
+++ b/test/unit/modules/vdom/patch/children.spec.ts
@@ -6,7 +6,7 @@ function prop (name) {
 }
 
 function map (fn, list) {
-  const ret = []
+  const ret: any[] = []
   for (let i = 0; i < list.length; i++) {
     ret[i] = fn(list[i])
   }
@@ -235,8 +235,8 @@ describe('vdom patch: children', () => {
   it('should handle random shuffle', () => {
     let n
     let i
-    const arr = []
-    const opacities = []
+    const arr: any[] = []
+    const opacities: any[] = []
     const elms = 14
     const samples = 5
     function spanNumWithOpacity (n, o) {
diff --git a/test/unit/modules/vdom/patch/edge-cases.spec.ts b/test/unit/modules/vdom/patch/edge-cases.spec.ts
index 24d97a63dba..294ab9cd9ba 100644
--- a/test/unit/modules/vdom/patch/edge-cases.spec.ts
+++ b/test/unit/modules/vdom/patch/edge-cases.spec.ts
@@ -48,7 +48,7 @@ describe('vdom patch: edge cases', () => {
       directives: {
         test: {
           bind (el, binding, vnode) {
-            waitForUpdate(() => {
+            global.waitForUpdate(() => {
               expect(vnode.children[0].data.on.click()).toBe(5)
               expect(vnode.children[2].data.on.click(dummyEvt)).toBe(5)
               expect(vnode.children[4].data.on.click()).toBe(10)
diff --git a/test/unit/modules/vdom/patch/hooks.spec.ts b/test/unit/modules/vdom/patch/hooks.spec.ts
index dbb7ee3bd1b..4105349b143 100644
--- a/test/unit/modules/vdom/patch/hooks.spec.ts
+++ b/test/unit/modules/vdom/patch/hooks.spec.ts
@@ -5,7 +5,7 @@ import * as nodeOps from 'web/runtime/node-ops'
 import platformModules from 'web/runtime/modules/index'
 import VNode from 'core/vdom/vnode'
 
-const modules = baseModules.concat(platformModules)
+const modules = baseModules.concat(platformModules) as any[]
 
 describe('vdom patch: hooks', () => {
   let vnode0
@@ -15,7 +15,7 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should call `insert` listener after both parents, siblings and children have been inserted', () => {
-    const result = []
+    const result: any[] = []
     function insert (vnode) {
       expect(vnode.elm.children.length).toBe(2)
       expect(vnode.elm.parentNode.children.length).toBe(3)
@@ -34,7 +34,7 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should call `prepatch` listener', () => {
-    const result = []
+    const result: any[] = []
     function prepatch (oldVnode, newVnode) {
       expect(oldVnode).toEqual(vnode1.children[1])
       expect(newVnode).toEqual(vnode2.children[1])
@@ -60,8 +60,8 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should call `postpatch` after `prepatch` listener', () => {
-    const pre = []
-    const post = []
+    const pre: any[] = []
+    const post: any[] = []
     function prepatch (oldVnode, newVnode) {
       pre.push(pre)
     }
@@ -90,8 +90,8 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should call `update` listener', () => {
-    const result1 = []
-    const result2 = []
+    const result1: any[] = []
+    const result2: any[] = []
     function cb (result, oldVnode, newVnode) {
       if (result.length > 1) {
         expect(result[result.length - 1]).toEqual(oldVnode)
@@ -119,7 +119,7 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should call `remove` listener', () => {
-    const result = []
+    const result: any[] = []
     function remove (vnode, rm) {
       const parent = vnode.elm.parentNode
       expect(vnode.elm.children.length).toBe(2)
@@ -159,6 +159,7 @@ describe('vdom patch: hooks', () => {
     let rm1, rm2, rm3
     const patch1 = createPatchFunction({
       nodeOps,
+      // @ts-ignore - TODO dtw
       modules: modules.concat([
         { remove (_, rm) { rm1 = rm } },
         { remove (_, rm) { rm2 = rm } }
@@ -181,7 +182,7 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should invoke the remove hook on replaced root', () => {
-    const result = []
+    const result: any[] = []
     const parent = nodeOps.createElement('div')
     vnode0 = nodeOps.createElement('div')
     parent.appendChild(vnode0)
@@ -203,7 +204,7 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should invoke global `destroy` hook for all removed children', () => {
-    const result = []
+    const result: any[] = []
     function destroy (vnode) { result.push(vnode) }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
@@ -301,7 +302,7 @@ describe('vdom patch: hooks', () => {
   })
 
   it('should call `create` listener before inserted into parent but after children', () => {
-    const result = []
+    const result: any[] = []
     function create (empty, vnode) {
       expect(vnode.elm.children.length).toBe(2)
       expect(vnode.elm.parentNode).toBe(null)
@@ -318,4 +319,4 @@ describe('vdom patch: hooks', () => {
     patch(vnode0, vnode1)
     expect(result.length).toBe(1)
   })
-})
+})
\ No newline at end of file
diff --git a/test/unit/modules/vdom/patch/hydration.spec.ts b/test/unit/modules/vdom/patch/hydration.spec.ts
index 930ad47cc81..48ddb64d9ae 100644
--- a/test/unit/modules/vdom/patch/hydration.spec.ts
+++ b/test/unit/modules/vdom/patch/hydration.spec.ts
@@ -18,7 +18,7 @@ describe('vdom patch: hydration', () => {
   })
 
   it('should hydrate elements when server-rendered DOM tree is same as virtual DOM tree', () => {
-    const result = []
+    const result: any[] = []
     function init (vnode) { result.push(vnode) }
     function createServerRenderedDOM () {
       const root = document.createElement('div')
diff --git a/test/weex/cases/cases.spec.ts b/test/weex/cases/cases.spec.ts
index f02ea217b70..d4838eb3e2b 100644
--- a/test/weex/cases/cases.spec.ts
+++ b/test/weex/cases/cases.spec.ts
@@ -130,7 +130,7 @@ describe('Usage', () => {
     })
 
     it('stateful component', done => {
-      const tasks = []
+      const tasks: any[] = []
       addTaskHook((_, task) => tasks.push(task))
       compileWithDeps('recycle-list/components/stateful.vue', [{
         name: 'counter',
diff --git a/test/weex/helpers/index.ts b/test/weex/helpers/index.ts
index ce74bf819db..c75ab07a052 100644
--- a/test/weex/helpers/index.ts
+++ b/test/weex/helpers/index.ts
@@ -137,7 +137,7 @@ export function getRoot (instance) {
 
 // Get all binding events in the instance
 export function getEvents (instance) {
-  const events = []
+  const events: any[] = []
   const recordEvent = node => {
     if (!node) { return }
     if (Array.isArray(node.event)) {
diff --git a/tsconfig.json b/tsconfig.json
index 69392b18633..8090ae4e036 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,9 +6,9 @@
     "target": "ESNext",
     "module": "ESNext",
     "moduleResolution": "node",
-    "allowJs": true,
     "strict": true,
     
+    "allowJs": true,
     "noImplicitAny": false,
     "noImplicitThis": false,
 
@@ -20,8 +20,6 @@
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
     "types": [
-      "node",
-      "karma",
       "jasmine",
       "webpack-env"
     ],
diff --git a/types/test/tsconfig.json b/types/test/tsconfig.json
index 03e33c3034f..9f66f31aacc 100644
--- a/types/test/tsconfig.json
+++ b/types/test/tsconfig.json
@@ -1,27 +1,22 @@
 {
   "compilerOptions": {
-    "target": "es5zdfasdfasdf",
+    "target": "es5",
     "experimentalDecorators": true,
     "lib": [
       "dom",
       "es2015"
     ],
-    "types": [
-      "jasmine",
-      "@types/karma",
-      "webpack-env"
-    ],
     "module": "commonjs",
     "strict": true,
     "noEmit": true,
     "baseUrl": ".",
     "paths": {
       "vue": ["../index.d.ts"]
-    }
+    },
   },
   "include": [
     "../*.d.ts",
     "*.ts"
   ],
   "compileOnSave": false
-}
+}
\ No newline at end of file
diff --git a/types/tsconfig.json b/types/tsconfig.json
deleted file mode 100644
index dc2f0455c71..00000000000
--- a/types/tsconfig.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "compilerOptions": {
-        "strict": true,
-        "lib": [
-            "es2015", "dom"
-        ]
-    },
-    "include": [
-        "./*.ts"
-    ]
-}
\ No newline at end of file
diff --git a/typescript/modules.d.ts b/typescript/modules.d.ts
index 393a6eb671a..0f97add3161 100644
--- a/typescript/modules.d.ts
+++ b/typescript/modules.d.ts
@@ -1,3 +1,15 @@
 declare module 'de-indent' {
   export default function deindent (input: string): string
+}
+
+declare namespace jasmine {
+  interface Matchers<T> {
+    toHaveBeenWarned(): void;
+    toHaveBeenTipped(): void;
+  }
+
+  interface ArrayLikeMatchers<T> {
+    toHaveBeenWarned(): void;
+    toHaveBeenTipped(): void;
+  }
 }
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index 13c0a66e77c..439f98e1d1c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -521,6 +521,13 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.14.5"
 
+"@babel/plugin-syntax-typescript@^7.16.7":
+  version "7.17.10"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.17.10.tgz#80031e6042cad6a95ed753f672ebd23c30933195"
+  integrity sha512-xJefea1DWXW09pW4Tm9bjwVlPDyYA2it3fWlmEjpYz6alPvTUjL0EOzNzI/FEOyI3r4/J7uVH5UqKgl1TQ5hqQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+
 "@babel/plugin-transform-arrow-functions@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.16.7.tgz#44125e653d94b98db76369de9c396dc14bef4154"
@@ -764,6 +771,15 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.16.7"
 
+"@babel/plugin-transform-typescript@^7.16.7":
+  version "7.16.8"
+  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.16.8.tgz#591ce9b6b83504903fa9dd3652c357c2ba7a1ee0"
+  integrity sha512-bHdQ9k7YpBDO2d0NVfkj51DpQcvwIzIusJ7mEUaMlbZq3Kt/U47j24inXZHQ5MDiYpCs+oZiwnXyKedE8+q7AQ==
+  dependencies:
+    "@babel/helper-create-class-features-plugin" "^7.16.7"
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/plugin-syntax-typescript" "^7.16.7"
+
 "@babel/plugin-transform-unicode-escapes@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.16.7.tgz#da8717de7b3287a2c6d659750c964f302b31ece3"
@@ -870,6 +886,15 @@
     "@babel/types" "^7.4.4"
     esutils "^2.0.2"
 
+"@babel/preset-typescript@^7.16.7":
+  version "7.16.7"
+  resolved "https://registry.yarnpkg.com/@babel/preset-typescript/-/preset-typescript-7.16.7.tgz#ab114d68bb2020afc069cd51b37ff98a046a70b9"
+  integrity sha512-WbVEmgXdIyvzB77AQjGBEyYPZx+8tTsO50XtfozQrkW8QB2rLJpH2lgx0TRw5EJrBxOZQ+wCcyPVQvS8tjEHpQ==
+  dependencies:
+    "@babel/helper-plugin-utils" "^7.16.7"
+    "@babel/helper-validator-option" "^7.16.7"
+    "@babel/plugin-transform-typescript" "^7.16.7"
+
 "@babel/register@^7.17.7":
   version "7.17.7"
   resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.17.7.tgz#5eef3e0f4afc07e25e847720e7b987ae33f08d0b"
@@ -1182,11 +1207,6 @@
   resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-4.6.0.tgz#3c7c9c46e678feefe7a2e5bb609d3dbd665ffb3f"
   integrity sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==
 
-"@socket.io/base64-arraybuffer@~1.0.2":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@socket.io/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz#568d9beae00b0d835f4f8c53fd55714986492e61"
-  integrity sha512-dOlCBKnDw4iShaIsH/bxujKTM18+2TOAsYz+KSc11Am38H4q5Xw8Bbz97ZYdrVNM+um3p7w86Bvvmcn9q+5+eQ==
-
 "@szmarczak/http-timer@^4.0.5":
   version "4.0.6"
   resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-4.0.6.tgz#b4a914bb62e7c272d4e5989fe4440f812ab1d807"
@@ -1297,14 +1317,6 @@
   resolved "https://registry.yarnpkg.com/@types/jasmine/-/jasmine-4.0.3.tgz#097ce710d70eb7f3662e96c1f75824dd22c27d5c"
   integrity sha512-Opp1LvvEuZdk8fSSvchK2mZwhVrsNT0JgJE9Di6MjnaIpmEXM8TLCPPrVtNTYh8+5MPdY8j9bAHMu2SSfwpZJg==
 
-"@types/jest@^27.4.1":
-  version "27.4.1"
-  resolved "https://registry.yarnpkg.com/@types/jest/-/jest-27.4.1.tgz#185cbe2926eaaf9662d340cc02e548ce9e11ab6d"
-  integrity sha512-23iPJADSmicDVrWk+HT58LMJtzLAnB2AgIzplQuq/bSrGaxCrlvRFjGbXmamnnk/mAmCdLStiGqggu28ocUyiw==
-  dependencies:
-    jest-matcher-utils "^27.0.0"
-    pretty-format "^27.0.0"
-
 "@types/json-buffer@~3.0.0":
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/@types/json-buffer/-/json-buffer-3.0.0.tgz#85c1ff0f0948fc159810d4b5be35bf8c20875f64"
@@ -1813,11 +1825,6 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   dependencies:
     color-convert "^2.0.1"
 
-ansi-styles@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
-  integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
-
 ansi-styles@^6.0.0:
   version "6.1.0"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.1.0.tgz#87313c102b8118abd57371afab34618bf7350ed3"
@@ -3680,11 +3687,6 @@ didyoumean@1.2.2:
   resolved "https://registry.yarnpkg.com/didyoumean/-/didyoumean-1.2.2.tgz#989346ffe9e839b4555ecf5666edea0d3e8ad037"
   integrity sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==
 
-diff-sequences@^27.5.1:
-  version "27.5.1"
-  resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-27.5.1.tgz#eaecc0d327fd68c8d9672a1e64ab8dccb2ef5327"
-  integrity sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==
-
 diff@5.0.0:
   version "5.0.0"
   resolved "https://registry.yarnpkg.com/diff/-/diff-5.0.0.tgz#7ed6ad76d859d030787ec35855f5b1daf31d852b"
@@ -3803,9 +3805,9 @@ ee-first@1.1.1:
   integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
 
 electron-to-chromium@^1.4.118:
-  version "1.4.127"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.127.tgz#4ef19d5d920abe2676d938f4170729b44f7f423a"
-  integrity sha512-nhD6S8nKI0O2MueC6blNOEZio+/PWppE/pevnf3LOlQA/fKPCrDp2Ao4wx4LFwmIkJpVdFdn2763YWLy9ENIZg==
+  version "1.4.129"
+  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.129.tgz#c675793885721beefff99da50f57c6525c2cd238"
+  integrity sha512-GgtN6bsDtHdtXJtlMYZWGB/uOyjZWjmRDumXTas7dGBaB9zUyCjzHet1DY2KhyHN8R0GLbzZWqm4efeddqqyRQ==
 
 elliptic@^6.5.3:
   version "6.5.4"
@@ -3853,11 +3855,9 @@ end-of-stream@^1.0.0, end-of-stream@^1.1.0, end-of-stream@^1.4.1:
     once "^1.4.0"
 
 engine.io-parser@~5.0.3:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-5.0.3.tgz#ca1f0d7b11e290b4bfda251803baea765ed89c09"
-  integrity sha512-BtQxwF27XUNnSafQLvDi0dQ8s3i6VgzSoQMJacpIcGNrlUdfHSKbgm3jmjCVvQluGzqwujQMPAoMai3oYSTurg==
-  dependencies:
-    "@socket.io/base64-arraybuffer" "~1.0.2"
+  version "5.0.4"
+  resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-5.0.4.tgz#0b13f704fa9271b3ec4f33112410d8f3f41d0fc0"
+  integrity sha512-+nVFp+5z1E3HcToEnO7ZIj3g+3k9389DvWtvJZz0T6/eOCPIyyxehFcedoYrZQrp0LgQbD9pPXhpMBKMd5QURg==
 
 engine.io@~6.2.0:
   version "6.2.0"
@@ -5731,31 +5731,6 @@ jasmine@^4.1.0:
     glob "^7.1.6"
     jasmine-core "^4.1.0"
 
-jest-diff@^27.5.1:
-  version "27.5.1"
-  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-27.5.1.tgz#a07f5011ac9e6643cf8a95a462b7b1ecf6680def"
-  integrity sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==
-  dependencies:
-    chalk "^4.0.0"
-    diff-sequences "^27.5.1"
-    jest-get-type "^27.5.1"
-    pretty-format "^27.5.1"
-
-jest-get-type@^27.5.1:
-  version "27.5.1"
-  resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-27.5.1.tgz#3cd613c507b0f7ace013df407a1c1cd578bcb4f1"
-  integrity sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==
-
-jest-matcher-utils@^27.0.0:
-  version "27.5.1"
-  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz#9c0cdbda8245bc22d2331729d1091308b40cf8ab"
-  integrity sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==
-  dependencies:
-    chalk "^4.0.0"
-    jest-diff "^27.5.1"
-    jest-get-type "^27.5.1"
-    pretty-format "^27.5.1"
-
 jest-worker@^27.4.5:
   version "27.5.1"
   resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
@@ -6517,9 +6492,9 @@ lru-cache@^6.0.0:
     yallist "^4.0.0"
 
 lru-cache@^7.8.1:
-  version "7.8.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.8.1.tgz#68ee3f4807a57d2ba185b7fd90827d5c21ce82bb"
-  integrity sha512-E1v547OCgJvbvevfjgK9sNKIVXO96NnsTsFPBlg4ZxjhsJSODoH9lk8Bm0OxvHNm6Vm5Yqkl/1fErDxhYL8Skg==
+  version "7.9.0"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.9.0.tgz#29c2a989b6c10f32ceccc66ff44059e1490af3e1"
+  integrity sha512-lkcNMUKqdJk96TuIXUidxaPuEg5sJo/+ZyVE2BDFnuZGzwXem7d8582eG8vbu4todLfT14snP6iHriCHXXi5Rw==
 
 magic-string@^0.25.0, magic-string@^0.25.7:
   version "0.25.9"
@@ -6839,9 +6814,9 @@ nightwatch-helpers@^1.2.0:
   integrity sha1-ze/rdjUHShQYJae20blVtteBCg8=
 
 nightwatch@^2.1.3:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/nightwatch/-/nightwatch-2.1.3.tgz#640e339c9f47e00010569ffa7f88f8d1d2b05fb9"
-  integrity sha512-NMNr4/jPsAtfd/u+RgKTzYyhS9TUuEmP6LMxLcH/KdQlkQmPIixVStRijv0bpvK4zASsqrO2+/em2LNRNMT6sw==
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/nightwatch/-/nightwatch-2.1.4.tgz#5363cf8fb3abc886f00cb4523339c71a85a015bf"
+  integrity sha512-IozG45KPn2Rth3vbm6/KBlrK+G4f4ut711aaMcCIX+QKrunLuMGWziM4708DYqgToZ65muMTfd3QsNm2SYqHkQ==
   dependencies:
     "@nightwatch/chai" "5.0.2"
     "@nightwatch/ejs" "3.2.0"
@@ -7462,15 +7437,6 @@ prepend-http@^2.0.0:
   resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897"
   integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=
 
-pretty-format@^27.0.0, pretty-format@^27.5.1:
-  version "27.5.1"
-  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-27.5.1.tgz#2181879fdea51a7a5851fb39d920faa63f01d88e"
-  integrity sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==
-  dependencies:
-    ansi-regex "^5.0.1"
-    ansi-styles "^5.0.0"
-    react-is "^17.0.1"
-
 process-nextick-args@~2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
@@ -7668,11 +7634,6 @@ raw-body@2.5.1:
     iconv-lite "0.4.24"
     unpipe "1.0.0"
 
-react-is@^17.0.1:
-  version "17.0.2"
-  resolved "https://registry.yarnpkg.com/react-is/-/react-is-17.0.2.tgz#e691d4a8e9c789365655539ab372762b0efb54f0"
-  integrity sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==
-
 read-pkg-up@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
@@ -8028,9 +7989,9 @@ rollup-plugin-typescript2@^0.31.2:
     tslib "^2.3.1"
 
 rollup@^2.70.2:
-  version "2.70.2"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.70.2.tgz#808d206a8851628a065097b7ba2053bd83ba0c0d"
-  integrity sha512-EitogNZnfku65I1DD5Mxe8JYRUCy0hkK5X84IlDtUs+O6JRMpRciXTzyCUuX11b5L5pvjH+OmFXiQ3XjabcXgg==
+  version "2.71.1"
+  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.71.1.tgz#82b259af7733dfd1224a8171013aaaad02971a22"
+  integrity sha512-lMZk3XfUBGjrrZQpvPSoXcZSfKcJ2Bgn+Z0L1MoW2V8Wh7BVM+LOBJTPo16yul2MwL59cXedzW1ruq3rCjSRgw==
   optionalDependencies:
     fsevents "~2.3.2"
 
@@ -8957,9 +8918,9 @@ trim-repeated@^1.0.0:
     escape-string-regexp "^1.0.2"
 
 ts-loader@^9.2.9:
-  version "9.2.9"
-  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-9.2.9.tgz#0653e07fa1b4f225d0ca57a84fddbfd43d930f9e"
-  integrity sha512-b0+vUY2/enb0qYtDQuNlDnJ9900NTiPiJcDJ6sY7ax1CCCwXfYIqPOMm/BwW7jsF1km+Oz8W9s31HLuD+FLIMg==
+  version "9.3.0"
+  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-9.3.0.tgz#980f4dbfb60e517179e15e10ed98e454b132159f"
+  integrity sha512-2kLLAdAD+FCKijvGKi9sS0OzoqxLCF3CxHpok7rVgCZ5UldRzH0TkbwG9XECKjBzHsAewntC5oDaI/FwKzEUog==
   dependencies:
     chalk "^4.1.0"
     enhanced-resolve "^5.0.0"
@@ -9559,11 +9520,16 @@ wrappy@1:
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
   integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
 
-ws@8.5.0, ws@>=7.4.6:
+ws@8.5.0:
   version "8.5.0"
   resolved "https://registry.yarnpkg.com/ws/-/ws-8.5.0.tgz#bfb4be96600757fe5382de12c670dab984a1ed4f"
   integrity sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==
 
+ws@>=7.4.6:
+  version "8.6.0"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.6.0.tgz#e5e9f1d9e7ff88083d0c0dd8281ea662a42c9c23"
+  integrity sha512-AzmM3aH3gk0aX7/rZLYvjdvZooofDu3fFOzGqcSnQ1tOcTWwhM/o+q++E8mAyVVIyUdajrkzWUGftaVSDLn1bw==
+
 ws@^7.2.3:
   version "7.5.7"
   resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.7.tgz#9e0ac77ee50af70d58326ecff7e85eb3fa375e67"

From 40dccfedd1d92ef9d61ee350ed8fbd7fc525b5b9 Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Tue, 3 May 2022 11:04:55 -0600
Subject: [PATCH 028/317] chore: fix test harness; most of the tooling + test
 harness is happy; coverage still needs fixing

---
 .babelrc.js                                   |     2 +-
 dist/vue.common.dev.js                        | 20396 ++++++++-------
 dist/vue.esm.browser.js                       | 20396 ++++++++-------
 dist/vue.esm.js                               | 20504 ++++++++--------
 dist/vue.js                                   | 20396 ++++++++-------
 dist/vue.runtime.common.dev.js                | 14428 ++++++-----
 dist/vue.runtime.esm.js                       | 14510 ++++++-----
 dist/vue.runtime.js                           | 14428 ++++++-----
 flow/compiler.js                              |   227 -
 flow/component.js                             |   148 -
 flow/global-api.js                            |    23 -
 flow/modules.js                               |    44 -
 flow/options.js                               |    90 -
 flow/ssr.js                                   |    21 -
 flow/vnode.js                                 |    79 -
 flow/weex.js                                  |   122 -
 package.json                                  |     7 +-
 packages/vue-server-renderer/basic.js         | 14465 ++++++-----
 packages/vue-server-renderer/build.dev.js     | 15869 ++++++------
 packages/vue-server-renderer/client-plugin.js |   208 +-
 packages/vue-server-renderer/server-plugin.js |   218 +-
 packages/vue-template-compiler/browser.js     |  8902 +++----
 packages/vue-template-compiler/build.js       |  8914 +++----
 src/compiler/create-compiler.ts               |     4 +-
 src/server/render-stream.ts                   |     4 +-
 test/e2e/specs/select2.ts                     |     3 +-
 test/e2e/specs/svg.ts                         |    10 +-
 test/helpers/wait-for-update.ts               |     5 +-
 test/ssr/compile-with-webpack.ts              |     3 +
 .../component/component-scoped-slot.spec.ts   |     1 +
 .../features/component/component-slot.spec.ts |     2 +-
 .../unit/features/component/component.spec.ts |     2 +-
 test/unit/features/debug.spec.ts              |     2 +-
 test/unit/features/error-handling.spec.ts     |    11 +-
 test/unit/features/global-api/mixin.spec.ts   |     2 +-
 .../features/global-api/set-delete.spec.ts    |     3 +-
 test/unit/features/instance/init.spec.ts      |     4 +-
 .../features/instance/methods-events.spec.ts  |     2 +-
 .../unit/features/instance/properties.spec.ts |     4 +-
 test/unit/features/options/data.spec.ts       |     2 +-
 .../features/options/errorCaptured.spec.ts    |     2 +-
 test/unit/features/options/lifecycle.spec.ts  |     2 +-
 test/unit/features/options/render.spec.ts     |     2 +-
 .../unit/features/options/renderError.spec.ts |     2 +-
 test/unit/features/ref.spec.ts                |    14 +-
 test/unit/global.d.ts                         |     9 +-
 test/unit/{index.ts => index.js}              |     3 +-
 test/unit/karma.base.config.ts                |    57 +-
 test/unit/modules/observer/observer.spec.ts   |     2 +-
 tsconfig.json                                 |     3 +-
 types/{test => }/tsconfig.json                |     7 +-
 yarn.lock                                     |    60 +-
 52 files changed, 86967 insertions(+), 87657 deletions(-)
 delete mode 100644 flow/compiler.js
 delete mode 100644 flow/component.js
 delete mode 100644 flow/global-api.js
 delete mode 100644 flow/modules.js
 delete mode 100644 flow/options.js
 delete mode 100644 flow/ssr.js
 delete mode 100644 flow/vnode.js
 delete mode 100644 flow/weex.js
 rename test/unit/{index.ts => index.js} (68%)
 rename types/{test => }/tsconfig.json (78%)

diff --git a/.babelrc.js b/.babelrc.js
index c6346183a9a..4104dde65d5 100644
--- a/.babelrc.js
+++ b/.babelrc.js
@@ -6,7 +6,7 @@ module.exports = {
   ],
   plugins: [
     require("babel-plugin-transform-vue-jsx"),
-    require("@babel/plugin-syntax-dynamic-import"),
+    require("@babel/plugin-syntax-dynamic-import")
   ],
 
   ignore: ["dist/*.js", "packages/**/*.js"],
diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
index fdbed175c5c..a68fe89f2bc 100644
--- a/dist/vue.common.dev.js
+++ b/dist/vue.common.dev.js
@@ -5,4996 +5,4993 @@
  */
 'use strict';
 
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$2(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Simple bind polyfill for environments that do not support it,
+ * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+ * since native bind is now performant enough in most browsers.
+ * But removing it would mean breaking code that was able to run in
+ * PhantomJS 1.x, so this must be kept for backward compatibility.
+ */
+/* istanbul ignore next */
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        const l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+/**
+ * Convert an Array-like object to a real Array.
+ */
+function toArray(list, start) {
+    start = start || 0;
+    let i = list.length - start;
+    const ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
+}
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
+}
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Ensure a function is called only once.
+ */
+function once(fn) {
+    let called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Check if a string starts with $ or _
+ */
+function isReserved(str) {
+    const c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
+}
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Parse simple path.
+ */
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    const segments = path.split('.');
+    return function (obj) {
+        for (let i = 0; i < segments.length; i++) {
+            if (!obj)
+                return;
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+// detect devtools
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+{
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid$2 = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Delete a property and trigger change if necessary.
+ */
+function del(target, key) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+{
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn$2('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn$2('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives$1(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn$2('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn$2('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                // @ts-expect-error should it be any?
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
+/* globals MutationObserver */
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
+function flushCallbacks() {
+    pending = false;
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// Here we have async deferring wrappers using microtasks.
+// In 2.5 we used (macro) tasks (in combination with microtasks).
+// However, it has subtle problems when state is changed right before repaint
+// (e.g. #6813, out-in transitions).
+// Also, using (macro) tasks in event handler would cause some weird behaviors
+// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+// So we now use microtasks everywhere, again.
+// A major drawback of this tradeoff is that there are some scenarios
+// where microtasks have too high a priority and fire in between supposedly
+// sequential events (e.g. #4521, #6690, which have workarounds)
+// or even between bubbling of the same event (#6566).
+let timerFunc;
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            setTimeout(noop);
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = () => {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = () => {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    let _resolve;
+    callbacks.push(() => {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise((resolve) => {
+            _resolve = resolve;
+        });
+    }
 }
 
-let mark;
-let measure;
-{
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
+let mark;
+let measure;
+{
+    const perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-{
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn$2(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
+/* not type checking this file because flow doesn't play well with Proxy */
+let initProxy;
+{
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const warnNonPresent = (target, key) => {
+        warn$2(`Property or method "${key}" is not defined on the instance but ` +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    const warnReservedPrefix = (target, key) => {
+        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return has || !isAllowed;
+        },
+    };
+    const getHandler = {
+        get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    let invoker;
+    const oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            {
-                defineReactive(vm, key, result[key], () => {
-                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function initProvide(vm) {
+    const provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    const result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach((key) => {
+            /* istanbul ignore else */
+            {
+                defineReactive(vm, key, result[key], () => {
+                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
+                });
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    warn$2(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn$2('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic$1(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic$1(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic$1(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic$1(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn$2('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook$1(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn$2('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-        }, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (Array.isArray(vnode)) {
-                warn$2('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    const parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
+        }, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
+        }, true);
+    }
+}
+let currentRenderingInstance = null;
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        let vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
+        }
+        catch (e) {
+            handleError(e, vm, `render`);
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, `renderError`);
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
+        }
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (Array.isArray(vnode)) {
+                warn$2('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
+            }
+            vnode = createEmptyVNode();
+        }
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            warn$2(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`
-                                );
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
+}
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    const owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        const resolve = once((res) => {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        const reject = once((reason) => {
+            warn$2(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(`timeout (${res.timeout}ms)`
+                                );
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
+    }
 }
 
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    const listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
+    }
+}
+let target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target$1.$off(event, fn);
+}
+function createOnceHandler$1(event, fn) {
+    const _target = target$1;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
+}
+function eventsMixin(Vue) {
+    const hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        const vm = this;
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        const vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        const vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
+            }
+            return vm;
+        }
+        // specific event
+        const cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        let cb;
+        let i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        const vm = this;
+        {
+            const lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+            }
+        }
+        let cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn$2("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn$2("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+let isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    const prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return () => {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    const options = vm.$options;
+    // locate first non-abstract parent
+    let parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        const vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        const vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook$1(vm, "beforeDestroy");
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        const parent = vm.$parent;
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove$2(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        let i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook$1(vm, "destroyed");
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                vm.$options.el ||
+                el) {
+                warn$2("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
+            }
+            else {
+                warn$2("Failed to mount component: template or render function not defined.", vm);
+            }
+        }
+    }
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
+            mark(startTag);
+            const vnode = vm._render();
+            mark(endTag);
+            measure(`vue ${name} render`, startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = () => {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook$1(vm, "beforeUpdate");
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook$1(vm, "mounted");
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "deactivated");
+    }
+}
+function callHook$1(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index$1 = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index$1 = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index$1 = 0; index$1 < queue.length; index$1++) {
-        watcher = queue[index$1];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn$2('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index$1 && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (!config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index$1 = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index$1 = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+let currentFlushTimestamp = 0;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Flush both queues and run the watchers.
+ */
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    let watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort((a, b) => a.id - b.id);
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index$1 = 0; index$1 < queue.length; index$1++) {
+        watcher = queue[index$1];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn$2('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
+    }
+}
+function callUpdatedHooks(queue) {
+    let i = queue.length;
+    while (i--) {
+        const watcher = queue[i];
+        const vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, 'updated');
+        }
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
+}
+function callActivatedHooks(queue) {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
+}
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ */
+function queueWatcher(watcher) {
+    const id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            let i = queue.length - 1;
+            while (i > index$1 && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (!config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
+    }
 }
 
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = expOrFn.toString()
-            ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn$2(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                // @ts-expect-error e is unknown, should we cast or any?
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
+let uid$1 = 0;
+/**
+ * A watcher parses an expression, collects dependencies,
+ * and fires callback when the expression value changes.
+ * This is used for both the $watch() api and directives.
+ */
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = expOrFn.toString()
+            ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn$2(`Failed watching path: "${expOrFn}" ` +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
+        }
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    }
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    }
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    }
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    }
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    }
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
+    }
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    }
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
 }
 
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        warn$2("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        {
-            if (methods && hasOwn(methods, key)) {
-                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            warn$2(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (getter == null) {
-            warn$2(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else {
-            if (key in vm.$data) {
-                warn$2(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        {
-            if (typeof methods[key] !== "function") {
-                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    {
-        dataDef.set = function () {
-            warn$2("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn$2(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
+const sharedPropertyDefinition = {
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
+};
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    const opts = vm.$options;
+    if (opts.props)
+        initProps$1(vm, opts.props);
+    if (opts.methods)
+        initMethods(vm, opts.methods);
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        initComputed$1(vm, opts.computed);
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps$1(vm, propsOptions) {
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    for (const key in propsOptions) {
+        keys.push(key);
+        const value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        {
+            const hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+            }
+            defineReactive(props, key, value, () => {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn$2(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
+                }
+            });
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, `_props`, key);
+        }
+    }
+    toggleObserving(true);
+}
+function initData(vm) {
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        warn$2("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+    }
+    // proxy data on instance
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
+    while (i--) {
+        const key = keys[i];
+        {
+            if (methods && hasOwn(methods, key)) {
+                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            warn$2(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, `_data`, key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
+}
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
+    }
+    catch (e) {
+        handleError(e, vm, `data()`);
+        return {};
+    }
+    finally {
+        popTarget();
+    }
+}
+const computedWatcherOptions = { lazy: true };
+function initComputed$1(vm, computed) {
+    // $flow-disable-line
+    const watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (getter == null) {
+            warn$2(`Getter is missing for computed property "${key}".`, vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else {
+            if (key in vm.$data) {
+                warn$2(`The computed property "${key}" is already defined in data.`, vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
+            }
+        }
+    }
+}
+function defineComputed(target, key, userDef) {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        const watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
+}
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
+        {
+            if (typeof methods[key] !== "function") {
+                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
+            }
+        }
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
+    }
+}
+function initWatch(vm, watch) {
+    for (const key in watch) {
+        const handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (let i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === "string") {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    const dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    const propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    {
+        dataDef.set = function () {
+            warn$2("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
+        };
+        propsDef.set = function () {
+            warn$2(`$props is readonly.`, this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        const vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        const watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
+            pushTarget();
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        {
-            initProxy(vm);
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+let uid = 0;
+function initMixin$1(Vue) {
+    Vue.prototype._init = function (options) {
+        const vm = this;
+        // a uid
+        vm._uid = uid++;
+        let startTag, endTag;
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        {
+            initProxy(vm);
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook$1(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook$1(vm, 'created');
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    const opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    const parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    const vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function Vue(options) {
-    if (!(this instanceof Vue)) {
-        warn$2("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
+function Vue(options) {
+    if (!(this instanceof Vue)) {
+        warn$2("Vue is a constructor and should be called with the `new` keyword");
+    }
+    this._init(options);
+}
+//@ts-expect-error Vue has function type
+initMixin$1(Vue);
+//@ts-expect-error Vue has function type
+stateMixin(Vue);
+//@ts-expect-error Vue has function type
+eventsMixin(Vue);
+//@ts-expect-error Vue has function type
+lifecycleMixin(Vue);
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        const args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
+function initMixin(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    let cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        const name = extendOptions.name || Super.options.name;
+        if (name) {
+            validateComponentName(name);
+        }
+        const Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps(Comp) {
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
+    }
+}
+function initComputed(Comp) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach((type) => {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
+/* @flow */
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
+}
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
+var KeepAlive = {
+    name: "keep-alive",
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed() {
+        for (const key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
+        });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
+        });
+    },
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            const { cache, keys } = this;
+            const key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove$2(keys, key);
+                keys.push(key);
+            }
+            else {
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
+            }
+            // @ts-expect-error can vnode.data can be undefined
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
-var builtInComponents = {
-    KeepAlive,
+var builtInComponents = {
+    KeepAlive,
 };
 
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    {
-        configDef.set = () => {
-            warn$2('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn$2,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+function initGlobalAPI(Vue) {
+    // config
+    const configDef = {};
+    configDef.get = () => config;
+    {
+        configDef.set = () => {
+            warn$2('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn$2,
+        extend,
+        mergeOptions,
+        defineReactive,
+    };
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = (obj) => {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach((type) => {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
+initGlobalAPI(Vue);
+Object.defineProperty(Vue.prototype, '$isServer', {
+    get: isServerRendering,
+});
+Object.defineProperty(Vue.prototype, '$ssrContext', {
+    get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
+});
+// expose FunctionalRenderContext for ssr runtime helper installation
+Object.defineProperty(Vue, 'FunctionalRenderContext', {
+    value: FunctionalRenderContext,
+});
 Vue.version = '2.6.14';
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+const isReservedAttr = makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+};
+const getXlinkProp = (name) => {
+    return isXlink(name) ? name.slice(6, name.length) : '';
+};
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
+const namespaceMap = {
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
+};
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+const unknownElementCache = Object.create(null);
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    const el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
+}
 const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        const selected = document.querySelector(el);
+        if (!selected) {
+            warn$2('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
+function createElement(tagName, vnode) {
+    const elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
+}
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
+}
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function createComment(text) {
+    return document.createComment(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    node.appendChild(child);
+}
+function parentNode(node) {
+    return node.parentNode;
+}
+function nextSibling(node) {
+    return node.nextSibling;
+}
+function tagName(node) {
+    return node.tagName;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5013,5440 +5010,5439 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
+var ref = {
+    create(_, vnode) {
+        registerRef(vnode);
+    },
+    update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy(vnode) {
+        registerRef(vnode, true);
+    },
+};
+function registerRef(vnode, isRemoval) {
+    const key = vnode.data.ref;
+    if (!isDef(key))
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
+    if (isRemoval) {
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
+        }
+        else if (obj === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(obj)) {
+                refs[key] = [ref];
+            }
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
+    }
 }
 
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn$2('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else {
-                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
+/**
+ * Virtual DOM patching algorithm based on Snabbdom by
+ * Simon Friis Vindum (@paldepind)
+ * Licensed under the MIT License
+ * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+ *
+ * modified by Evan You (@yyx990803)
+ *
+ * Not type-checking this because this file is perf-critical and the cost
+ * of making flow understand it is not worth it.
+ */
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    let i, key;
+    const map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            map[key] = i;
+    }
+    return map;
+}
+function createPatchFunction(backend) {
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
+    }
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    }
+    function createRmCb(childElm, listeners) {
+        function remove() {
+            if (--remove.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove.listeners = listeners;
+        return remove;
+    }
+    function removeNode(el) {
+        const parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
+    }
+    function isUnknownElement(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some((ignore) => {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    let creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
+        if (isDef(tag)) {
+            {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn$2('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i = vnode.data;
+        if (isDef(i)) {
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        let innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref) {
+        if (isDef(parent)) {
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            {
+                checkDuplicateKeys(children);
+            }
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                i.create(emptyNode, vnode);
+            if (isDef(i.insert))
+                insertedVnodeQueue.push(vnode);
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        let i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            let ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        let i, j;
+        const data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                i(vnode);
+            for (i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            let i;
+            const listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        const canMove = !removeOnly;
+        {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function checkDuplicateKeys(children) {
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                return i;
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        const elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        let i;
+        const data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                i(oldVnode, vnode);
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+            }
+            else if (isDef(ch)) {
+                {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    nodeOps.setTextContent(elm, '');
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                i(oldVnode, vnode);
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    let hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        let i;
+        const { tag, data, children } = vnode;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                i(vnode, true /* hydrating */);
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                let fullInvoke = false;
+                for (const key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                invokeDestroyHook(oldVnode);
+            return;
+        }
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            const isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else {
+                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-var directives$1 = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            // @ts-expect-error should it be any?
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
+var directives$1 = {
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
+};
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
+    }
+}
+const emptyModifiers = Object.create(null);
+function normalizeDirectives(dirs, vm) {
+    const res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    let i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
+    // $flow-disable-line
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+}
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    const fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+        }
+    }
 }
 
 var baseModules = [ref, directives$1];
 
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
+function updateAttrs(oldVnode, vnode) {
+    const opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            const blocker = (e) => {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
+}
+var attrs = {
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass$1 = {
-    create: updateClass,
-    update: updateClass,
+function updateClass(oldVnode, vnode) {
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    let cls = genClassForVnode(vnode);
+    // handle transition classes
+    const transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
+}
+var klass$1 = {
+    create: updateClass,
+    update: updateClass,
 };
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-let warn$1;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn$1;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+// normalize v-model event tokens that can only be determined at runtime.
+// it's important to place the event as the first in the array because
+// the whole point is ensuring the v-model callback gets called before
+// user-attached handlers.
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
+}
+let target;
+function createOnceHandler(event, handler, capture) {
+    const _target = target; // save current target element in closure
+    return function onceHandler() {
+        const res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove(event, onceHandler, capture, _target);
+        }
+    };
+}
+// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+// implementation and does not fire microtasks in between event propagation, so
+// safe to exclude.
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+function add(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+}
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
+}
+var events = {
+    create: updateDOMListeners,
+    update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
+let svgContainer;
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                vnode.children.length = 0;
+            if (cur === oldProps[key])
+                continue;
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            const strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    let notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
+}
+var domProps = {
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style$1 = {
-    create: updateStyle,
-    update: updateStyle,
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        const normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (let i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
+};
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
+});
+function updateStyle(oldVnode, vnode) {
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    const newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
+    }
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
+    }
+}
+var style$1 = {
+    create: updateStyle,
+    update: updateStyle,
 };
 
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
+const whitespaceRE$1 = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        const cur = ` ${el.getAttribute('class') || ''} `;
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        const res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+const autoCssTransition = cached((name) => {
+    return {
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
+    };
+});
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
+// Transition property/event sniffing
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+const raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ (fn) => fn();
+function nextFrame(fn) {
+    raf(() => {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type)
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    const onEnd = (e) => {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(() => {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+const transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type,
+        timeout,
+        propCount,
+        hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map((d, i) => {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
+function enter(vnode, toggleDisplay) {
+    const el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    const el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    const cb = (el._leaveCb = once(() => {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    const invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
+    if (vnode.data.show !== true) {
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
+    }
     : {};
 
 var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules$1 = platformModules.concat(baseModules);
+// the directive module should be applied last, after all
+// built-in modules have been applied.
+const modules$1 = platformModules.concat(baseModules);
 const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+/**
+ * Not type checking this file because flow doesn't like attaching
+ * properties to Elements.
+ */
+/* istanbul ignore if */
+if (isIE9) {
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
+}
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', () => {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                // trigger change event if
+                // no matching option found for at least one value
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
+};
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(() => {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    const value = binding.value;
+    const isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+        return;
+    }
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
+}
+function hasNoMatchingOption(value, options) {
+    return options.every((o) => !looseEqual(o, value));
+}
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
+}
+function onCompositionStart(e) {
+    e.target.composing = true;
+}
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        return;
+    e.target.composing = false;
+    trigger(e.target, 'input');
+}
+function trigger(el, type) {
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind(el, { value }, vnode) {
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, () => {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update(el, { value, oldValue }, vnode) {
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, () => {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, () => {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
-var platformDirectives = {
-    model: directive,
-    show,
+var platformDirectives = {
+    model: directive,
+    show,
 };
 
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (children.length > 1) {
-            warn$2('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn$2('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
+// Provides transition support for a single element/component.
+const transitionProps = {
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
+};
+// in case the child is also an abstract component, e.g. <keep-alive>
+// we want to recursively retrieve the real component to be rendered
+function getRealChild(vnode) {
+    const compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    const data = {};
+    const options = comp.$options;
+    // props
+    for (const key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
+}
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
+    }
+}
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
+}
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
+var Transition = {
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render(h) {
+        let children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (children.length > 1) {
+            warn$2('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        const mode = this.mode;
+        // warn invalid mode
+        if (mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn$2('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        const rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        const child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        const id = `__transition-${this._uid}-`;
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            const oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn$2(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
+// Provides transition support for list items.
+const props = extend({
+    tag: String,
+    moveClass: String,
+}, transitionProps);
+delete props.mode;
+var TransitionGroup = {
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
+            // force removing pass
+            this.__patch__(this._vnode, this.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this._vnode = this.kept;
+            restoreActiveInstance();
+            update.call(this, vnode, hydrating);
+        };
+    },
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
+                        : c.tag;
+                    warn$2(`<transition-group> children must be keyed: <${name}>`);
+                }
+            }
+        }
+        if (prevChildren) {
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
+                }
+                else {
+                    removed.push(c);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach((c) => {
+            if (c.data.moved) {
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
+        });
+    },
+    methods: {
+        hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            const clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach((cls) => {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = "none";
+            this.$el.appendChild(clone);
+            const info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
+};
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    if (c.elm._moveCb) {
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    if (c.elm._enterCb) {
+        c.elm._enterCb();
+    }
+}
+function recordPosition(c) {
+    c.data.newPos = c.elm.getBoundingClientRect();
+}
+function applyTranslation(c) {
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        c.data.moved = true;
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
+    }
 }
 
-var platformComponents = {
-    Transition,
-    TransitionGroup,
+var platformComponents = {
+    Transition,
+    TransitionGroup,
 };
 
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
+// install platform specific utils
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
+Vue.config.isReservedAttr = isReservedAttr;
+Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.isUnknownElement = isUnknownElement;
+// install platform runtime directives & components
+extend(Vue.options.directives, platformDirectives);
+extend(Vue.options.components, platformComponents);
+// install platform patch function
+Vue.prototype.__patch__ = inBrowser ? patch : noop;
+// public mount method
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
+};
+// devtools global hook
+/* istanbul ignore next */
+if (inBrowser) {
+    setTimeout(() => {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
+        }
+    }, 0);
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-let decoder;
-var he = {
-    decode(html) {
-        decoder = decoder || document.createElement('div');
-        decoder.innerHTML = html;
-        return decoder.textContent;
-    },
+let decoder;
+var he = {
+    decode(html) {
+        decoder = decoder || document.createElement('div');
+        decoder.innerHTML = html;
+        return decoder.textContent;
+    },
 };
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if ((i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he.decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he.decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        {
+            if (el.tag === 'template') {
+                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model];
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model: model$1,
-    text,
-    html,
+var directives = {
+    model: model$1,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys$1(modules),
 };
 
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
+let isStaticKey;
+let isPlatformReservedTag;
+const genStaticKeysCached = cached(genStaticKeys);
+/**
+ * Goal of the optimizer: walk the generated template AST tree
+ * and detect sub-trees that are purely static, i.e. parts of
+ * the DOM that never needs to change.
+ *
+ * Once we detect these sub-trees, we can:
+ *
+ * 1. Hoist them into constants, so that we no longer need to
+ *    create fresh nodes for them on each re-render;
+ * 2. Completely skip them in the patching process.
+ */
+function optimize(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
 }
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if ((el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = typeof (msg) === 'string' ? { msg } : msg;
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize(ast, options);
-    }
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-// check whether current browser encodes a char inside attribute values
-let div;
-function getShouldDecode(href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-    return div.innerHTML.indexOf('&#10;') > 0;
-}
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-// #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
-    ? getShouldDecode(true)
+// check whether current browser encodes a char inside attribute values
+let div;
+function getShouldDecode(href) {
+    div = div || document.createElement('div');
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
+    return div.innerHTML.indexOf('&#10;') > 0;
+}
+// #3663: IE encodes newlines inside attribute values while other browsers don't
+const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+// #6828: chrome encodes content in a[href]
+const shouldDecodeNewlinesForHref = inBrowser
+    ? getShouldDecode(true)
     : false;
 
-const idToTemplate = cached((id) => {
-    const el = query(id);
-    return el && el.innerHTML;
-});
-const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && query(el);
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-        return this;
-    }
-    const options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-        let template = options.template;
-        if (template) {
-            if (typeof template === 'string') {
-                if (template.charAt(0) === '#') {
-                    template = idToTemplate(template);
-                    /* istanbul ignore if */
-                    if (!template) {
-                        warn$2(`Template element not found or is empty: ${options.template}`, this);
-                    }
-                }
-            }
-            else if (template.nodeType) {
-                template = template.innerHTML;
-            }
-            else {
-                {
-                    warn$2('invalid template option:' + template, this);
-                }
-                return this;
-            }
-        }
-        else if (el) {
-            // @ts-expect-error
-            template = getOuterHTML(el);
-        }
-        if (template) {
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile');
-            }
-            const { render, staticRenderFns } = compileToFunctions(template, {
-                outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
-                delimiters: options.delimiters,
-                comments: options.comments,
-            }, this);
-            options.render = render;
-            options.staticRenderFns = staticRenderFns;
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
-            }
-        }
-    }
-    return mount.call(this, el, hydrating);
-};
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el) {
-    if (el.outerHTML) {
-        return el.outerHTML;
-    }
-    else {
-        const container = document.createElement('div');
-        container.appendChild(el.cloneNode(true));
-        return container.innerHTML;
-    }
-}
+const idToTemplate = cached((id) => {
+    const el = query(id);
+    return el && el.innerHTML;
+});
+const mount = Vue.prototype.$mount;
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && query(el);
+    /* istanbul ignore if */
+    if (el === document.body || el === document.documentElement) {
+        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
+        return this;
+    }
+    const options = this.$options;
+    // resolve template/el and convert to render function
+    if (!options.render) {
+        let template = options.template;
+        if (template) {
+            if (typeof template === 'string') {
+                if (template.charAt(0) === '#') {
+                    template = idToTemplate(template);
+                    /* istanbul ignore if */
+                    if (!template) {
+                        warn$2(`Template element not found or is empty: ${options.template}`, this);
+                    }
+                }
+            }
+            else if (template.nodeType) {
+                template = template.innerHTML;
+            }
+            else {
+                {
+                    warn$2('invalid template option:' + template, this);
+                }
+                return this;
+            }
+        }
+        else if (el) {
+            // @ts-expect-error
+            template = getOuterHTML(el);
+        }
+        if (template) {
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile');
+            }
+            const { render, staticRenderFns } = compileToFunctions(template, {
+                outputSourceRange: "development" !== 'production',
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
+                delimiters: options.delimiters,
+                comments: options.comments,
+            }, this);
+            options.render = render;
+            options.staticRenderFns = staticRenderFns;
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
+            }
+        }
+    }
+    return mount.call(this, el, hydrating);
+};
+/**
+ * Get outerHTML of elements, taking care
+ * of SVG elements in IE as well.
+ */
+function getOuterHTML(el) {
+    if (el.outerHTML) {
+        return el.outerHTML;
+    }
+    else {
+        const container = document.createElement('div');
+        container.appendChild(el.cloneNode(true));
+        return container.innerHTML;
+    }
+}
 Vue.compile = compileToFunctions;
 
 module.exports = Vue;
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
index 8ceec70714b..3f78b4d1bbd 100644
--- a/dist/vue.esm.browser.js
+++ b/dist/vue.esm.browser.js
@@ -3,4996 +3,4993 @@
  * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$2(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Simple bind polyfill for environments that do not support it,
+ * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+ * since native bind is now performant enough in most browsers.
+ * But removing it would mean breaking code that was able to run in
+ * PhantomJS 1.x, so this must be kept for backward compatibility.
+ */
+/* istanbul ignore next */
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        const l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+/**
+ * Convert an Array-like object to a real Array.
+ */
+function toArray(list, start) {
+    start = start || 0;
+    let i = list.length - start;
+    const ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
+}
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
+}
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Ensure a function is called only once.
+ */
+function once(fn) {
+    let called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Check if a string starts with $ or _
+ */
+function isReserved(str) {
+    const c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
+}
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Parse simple path.
+ */
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    const segments = path.split('.');
+    return function (obj) {
+        for (let i = 0; i < segments.length; i++) {
+            if (!obj)
+                return;
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+// detect devtools
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+{
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid$2 = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Delete a property and trigger change if necessary.
+ */
+function del(target, key) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+{
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn$2('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn$2('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives$1(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn$2('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn$2('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                // @ts-expect-error should it be any?
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
+/* globals MutationObserver */
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
+function flushCallbacks() {
+    pending = false;
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// Here we have async deferring wrappers using microtasks.
+// In 2.5 we used (macro) tasks (in combination with microtasks).
+// However, it has subtle problems when state is changed right before repaint
+// (e.g. #6813, out-in transitions).
+// Also, using (macro) tasks in event handler would cause some weird behaviors
+// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+// So we now use microtasks everywhere, again.
+// A major drawback of this tradeoff is that there are some scenarios
+// where microtasks have too high a priority and fire in between supposedly
+// sequential events (e.g. #4521, #6690, which have workarounds)
+// or even between bubbling of the same event (#6566).
+let timerFunc;
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            setTimeout(noop);
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = () => {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = () => {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    let _resolve;
+    callbacks.push(() => {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise((resolve) => {
+            _resolve = resolve;
+        });
+    }
 }
 
-let mark;
-let measure;
-{
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
+let mark;
+let measure;
+{
+    const perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-{
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn$2(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
+/* not type checking this file because flow doesn't play well with Proxy */
+let initProxy;
+{
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const warnNonPresent = (target, key) => {
+        warn$2(`Property or method "${key}" is not defined on the instance but ` +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    const warnReservedPrefix = (target, key) => {
+        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return has || !isAllowed;
+        },
+    };
+    const getHandler = {
+        get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    let invoker;
+    const oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            {
-                defineReactive(vm, key, result[key], () => {
-                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function initProvide(vm) {
+    const provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    const result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach((key) => {
+            /* istanbul ignore else */
+            {
+                defineReactive(vm, key, result[key], () => {
+                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
+                });
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    warn$2(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn$2('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic$1(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic$1(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic$1(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic$1(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn$2('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook$1(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn$2('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-        }, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (Array.isArray(vnode)) {
-                warn$2('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    const parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
+        }, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
+        }, true);
+    }
+}
+let currentRenderingInstance = null;
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        let vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
+        }
+        catch (e) {
+            handleError(e, vm, `render`);
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, `renderError`);
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
+        }
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (Array.isArray(vnode)) {
+                warn$2('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
+            }
+            vnode = createEmptyVNode();
+        }
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            warn$2(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`
-                                );
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
+}
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    const owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        const resolve = once((res) => {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        const reject = once((reason) => {
+            warn$2(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(`timeout (${res.timeout}ms)`
+                                );
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
+    }
 }
 
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    const listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
+    }
+}
+let target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target$1.$off(event, fn);
+}
+function createOnceHandler$1(event, fn) {
+    const _target = target$1;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
+}
+function eventsMixin(Vue) {
+    const hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        const vm = this;
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        const vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        const vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
+            }
+            return vm;
+        }
+        // specific event
+        const cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        let cb;
+        let i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        const vm = this;
+        {
+            const lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+            }
+        }
+        let cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn$2("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn$2("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+let isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    const prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return () => {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    const options = vm.$options;
+    // locate first non-abstract parent
+    let parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        const vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        const vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook$1(vm, "beforeDestroy");
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        const parent = vm.$parent;
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove$2(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        let i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook$1(vm, "destroyed");
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                vm.$options.el ||
+                el) {
+                warn$2("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
+            }
+            else {
+                warn$2("Failed to mount component: template or render function not defined.", vm);
+            }
+        }
+    }
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
+            mark(startTag);
+            const vnode = vm._render();
+            mark(endTag);
+            measure(`vue ${name} render`, startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = () => {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook$1(vm, "beforeUpdate");
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook$1(vm, "mounted");
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "deactivated");
+    }
+}
+function callHook$1(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index$1 = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index$1 = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index$1 = 0; index$1 < queue.length; index$1++) {
-        watcher = queue[index$1];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn$2('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index$1 && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (!config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index$1 = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index$1 = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+let currentFlushTimestamp = 0;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Flush both queues and run the watchers.
+ */
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    let watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort((a, b) => a.id - b.id);
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index$1 = 0; index$1 < queue.length; index$1++) {
+        watcher = queue[index$1];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn$2('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
+    }
+}
+function callUpdatedHooks(queue) {
+    let i = queue.length;
+    while (i--) {
+        const watcher = queue[i];
+        const vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, 'updated');
+        }
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
+}
+function callActivatedHooks(queue) {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
+}
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ */
+function queueWatcher(watcher) {
+    const id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            let i = queue.length - 1;
+            while (i > index$1 && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (!config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
+    }
 }
 
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = expOrFn.toString()
-            ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn$2(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                // @ts-expect-error e is unknown, should we cast or any?
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
+let uid$1 = 0;
+/**
+ * A watcher parses an expression, collects dependencies,
+ * and fires callback when the expression value changes.
+ * This is used for both the $watch() api and directives.
+ */
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = expOrFn.toString()
+            ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn$2(`Failed watching path: "${expOrFn}" ` +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
+        }
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    }
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    }
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    }
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    }
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    }
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
+    }
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    }
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
 }
 
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        warn$2("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        {
-            if (methods && hasOwn(methods, key)) {
-                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            warn$2(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (getter == null) {
-            warn$2(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else {
-            if (key in vm.$data) {
-                warn$2(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        {
-            if (typeof methods[key] !== "function") {
-                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    {
-        dataDef.set = function () {
-            warn$2("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn$2(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
+const sharedPropertyDefinition = {
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
+};
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    const opts = vm.$options;
+    if (opts.props)
+        initProps$1(vm, opts.props);
+    if (opts.methods)
+        initMethods(vm, opts.methods);
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        initComputed$1(vm, opts.computed);
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps$1(vm, propsOptions) {
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    for (const key in propsOptions) {
+        keys.push(key);
+        const value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        {
+            const hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+            }
+            defineReactive(props, key, value, () => {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn$2(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
+                }
+            });
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, `_props`, key);
+        }
+    }
+    toggleObserving(true);
+}
+function initData(vm) {
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        warn$2("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+    }
+    // proxy data on instance
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
+    while (i--) {
+        const key = keys[i];
+        {
+            if (methods && hasOwn(methods, key)) {
+                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            warn$2(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, `_data`, key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
+}
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
+    }
+    catch (e) {
+        handleError(e, vm, `data()`);
+        return {};
+    }
+    finally {
+        popTarget();
+    }
+}
+const computedWatcherOptions = { lazy: true };
+function initComputed$1(vm, computed) {
+    // $flow-disable-line
+    const watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (getter == null) {
+            warn$2(`Getter is missing for computed property "${key}".`, vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else {
+            if (key in vm.$data) {
+                warn$2(`The computed property "${key}" is already defined in data.`, vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
+            }
+        }
+    }
+}
+function defineComputed(target, key, userDef) {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        const watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
+}
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
+        {
+            if (typeof methods[key] !== "function") {
+                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
+            }
+        }
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
+    }
+}
+function initWatch(vm, watch) {
+    for (const key in watch) {
+        const handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (let i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === "string") {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    const dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    const propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    {
+        dataDef.set = function () {
+            warn$2("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
+        };
+        propsDef.set = function () {
+            warn$2(`$props is readonly.`, this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        const vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        const watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
+            pushTarget();
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        {
-            initProxy(vm);
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+let uid = 0;
+function initMixin$1(Vue) {
+    Vue.prototype._init = function (options) {
+        const vm = this;
+        // a uid
+        vm._uid = uid++;
+        let startTag, endTag;
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        {
+            initProxy(vm);
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook$1(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook$1(vm, 'created');
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    const opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    const parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    const vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function Vue(options) {
-    if (!(this instanceof Vue)) {
-        warn$2("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
+function Vue(options) {
+    if (!(this instanceof Vue)) {
+        warn$2("Vue is a constructor and should be called with the `new` keyword");
+    }
+    this._init(options);
+}
+//@ts-expect-error Vue has function type
+initMixin$1(Vue);
+//@ts-expect-error Vue has function type
+stateMixin(Vue);
+//@ts-expect-error Vue has function type
+eventsMixin(Vue);
+//@ts-expect-error Vue has function type
+lifecycleMixin(Vue);
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        const args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
+function initMixin(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    let cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        const name = extendOptions.name || Super.options.name;
+        if (name) {
+            validateComponentName(name);
+        }
+        const Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps(Comp) {
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
+    }
+}
+function initComputed(Comp) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach((type) => {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
+/* @flow */
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
+}
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
+var KeepAlive = {
+    name: "keep-alive",
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed() {
+        for (const key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
+        });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
+        });
+    },
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            const { cache, keys } = this;
+            const key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove$2(keys, key);
+                keys.push(key);
+            }
+            else {
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
+            }
+            // @ts-expect-error can vnode.data can be undefined
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
-var builtInComponents = {
-    KeepAlive,
+var builtInComponents = {
+    KeepAlive,
 };
 
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    {
-        configDef.set = () => {
-            warn$2('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn$2,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+function initGlobalAPI(Vue) {
+    // config
+    const configDef = {};
+    configDef.get = () => config;
+    {
+        configDef.set = () => {
+            warn$2('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn$2,
+        extend,
+        mergeOptions,
+        defineReactive,
+    };
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = (obj) => {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach((type) => {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
+initGlobalAPI(Vue);
+Object.defineProperty(Vue.prototype, '$isServer', {
+    get: isServerRendering,
+});
+Object.defineProperty(Vue.prototype, '$ssrContext', {
+    get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
+});
+// expose FunctionalRenderContext for ssr runtime helper installation
+Object.defineProperty(Vue, 'FunctionalRenderContext', {
+    value: FunctionalRenderContext,
+});
 Vue.version = '2.6.14';
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+const isReservedAttr = makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+};
+const getXlinkProp = (name) => {
+    return isXlink(name) ? name.slice(6, name.length) : '';
+};
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
+const namespaceMap = {
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
+};
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+const unknownElementCache = Object.create(null);
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    const el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
+}
 const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        const selected = document.querySelector(el);
+        if (!selected) {
+            warn$2('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
+function createElement(tagName, vnode) {
+    const elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
+}
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
+}
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function createComment(text) {
+    return document.createComment(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    node.appendChild(child);
+}
+function parentNode(node) {
+    return node.parentNode;
+}
+function nextSibling(node) {
+    return node.nextSibling;
+}
+function tagName(node) {
+    return node.tagName;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5011,5440 +5008,5439 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
+var ref = {
+    create(_, vnode) {
+        registerRef(vnode);
+    },
+    update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy(vnode) {
+        registerRef(vnode, true);
+    },
+};
+function registerRef(vnode, isRemoval) {
+    const key = vnode.data.ref;
+    if (!isDef(key))
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
+    if (isRemoval) {
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
+        }
+        else if (obj === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(obj)) {
+                refs[key] = [ref];
+            }
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
+    }
 }
 
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn$2('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else {
-                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
+/**
+ * Virtual DOM patching algorithm based on Snabbdom by
+ * Simon Friis Vindum (@paldepind)
+ * Licensed under the MIT License
+ * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+ *
+ * modified by Evan You (@yyx990803)
+ *
+ * Not type-checking this because this file is perf-critical and the cost
+ * of making flow understand it is not worth it.
+ */
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    let i, key;
+    const map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            map[key] = i;
+    }
+    return map;
+}
+function createPatchFunction(backend) {
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
+    }
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    }
+    function createRmCb(childElm, listeners) {
+        function remove() {
+            if (--remove.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove.listeners = listeners;
+        return remove;
+    }
+    function removeNode(el) {
+        const parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
+    }
+    function isUnknownElement(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some((ignore) => {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    let creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
+        if (isDef(tag)) {
+            {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn$2('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i = vnode.data;
+        if (isDef(i)) {
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        let innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref) {
+        if (isDef(parent)) {
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            {
+                checkDuplicateKeys(children);
+            }
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                i.create(emptyNode, vnode);
+            if (isDef(i.insert))
+                insertedVnodeQueue.push(vnode);
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        let i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            let ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        let i, j;
+        const data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                i(vnode);
+            for (i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            let i;
+            const listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        const canMove = !removeOnly;
+        {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function checkDuplicateKeys(children) {
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                return i;
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        const elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        let i;
+        const data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                i(oldVnode, vnode);
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+            }
+            else if (isDef(ch)) {
+                {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    nodeOps.setTextContent(elm, '');
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                i(oldVnode, vnode);
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    let hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        let i;
+        const { tag, data, children } = vnode;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                i(vnode, true /* hydrating */);
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                let fullInvoke = false;
+                for (const key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                invokeDestroyHook(oldVnode);
+            return;
+        }
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            const isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else {
+                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-var directives$1 = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            // @ts-expect-error should it be any?
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
+var directives$1 = {
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
+};
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
+    }
+}
+const emptyModifiers = Object.create(null);
+function normalizeDirectives(dirs, vm) {
+    const res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    let i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
+    // $flow-disable-line
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+}
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    const fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+        }
+    }
 }
 
 var baseModules = [ref, directives$1];
 
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
+function updateAttrs(oldVnode, vnode) {
+    const opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            const blocker = (e) => {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
+}
+var attrs = {
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass$1 = {
-    create: updateClass,
-    update: updateClass,
+function updateClass(oldVnode, vnode) {
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    let cls = genClassForVnode(vnode);
+    // handle transition classes
+    const transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
+}
+var klass$1 = {
+    create: updateClass,
+    update: updateClass,
 };
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-let warn$1;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn$1;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+// normalize v-model event tokens that can only be determined at runtime.
+// it's important to place the event as the first in the array because
+// the whole point is ensuring the v-model callback gets called before
+// user-attached handlers.
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
+}
+let target;
+function createOnceHandler(event, handler, capture) {
+    const _target = target; // save current target element in closure
+    return function onceHandler() {
+        const res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove(event, onceHandler, capture, _target);
+        }
+    };
+}
+// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+// implementation and does not fire microtasks in between event propagation, so
+// safe to exclude.
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+function add(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+}
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
+}
+var events = {
+    create: updateDOMListeners,
+    update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
+let svgContainer;
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                vnode.children.length = 0;
+            if (cur === oldProps[key])
+                continue;
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            const strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    let notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
+}
+var domProps = {
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style$1 = {
-    create: updateStyle,
-    update: updateStyle,
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        const normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (let i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
+};
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
+});
+function updateStyle(oldVnode, vnode) {
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    const newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
+    }
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
+    }
+}
+var style$1 = {
+    create: updateStyle,
+    update: updateStyle,
 };
 
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
+const whitespaceRE$1 = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        const cur = ` ${el.getAttribute('class') || ''} `;
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        const res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+const autoCssTransition = cached((name) => {
+    return {
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
+    };
+});
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
+// Transition property/event sniffing
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+const raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ (fn) => fn();
+function nextFrame(fn) {
+    raf(() => {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type)
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    const onEnd = (e) => {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(() => {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+const transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type,
+        timeout,
+        propCount,
+        hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map((d, i) => {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
+function enter(vnode, toggleDisplay) {
+    const el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    const el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    const cb = (el._leaveCb = once(() => {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    const invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
+    if (vnode.data.show !== true) {
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
+    }
     : {};
 
 var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules$1 = platformModules.concat(baseModules);
+// the directive module should be applied last, after all
+// built-in modules have been applied.
+const modules$1 = platformModules.concat(baseModules);
 const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+/**
+ * Not type checking this file because flow doesn't like attaching
+ * properties to Elements.
+ */
+/* istanbul ignore if */
+if (isIE9) {
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
+}
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', () => {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                // trigger change event if
+                // no matching option found for at least one value
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
+};
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(() => {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    const value = binding.value;
+    const isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+        return;
+    }
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
+}
+function hasNoMatchingOption(value, options) {
+    return options.every((o) => !looseEqual(o, value));
+}
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
+}
+function onCompositionStart(e) {
+    e.target.composing = true;
+}
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        return;
+    e.target.composing = false;
+    trigger(e.target, 'input');
+}
+function trigger(el, type) {
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind(el, { value }, vnode) {
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, () => {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update(el, { value, oldValue }, vnode) {
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, () => {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, () => {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
-var platformDirectives = {
-    model: directive,
-    show,
+var platformDirectives = {
+    model: directive,
+    show,
 };
 
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (children.length > 1) {
-            warn$2('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn$2('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
+// Provides transition support for a single element/component.
+const transitionProps = {
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
+};
+// in case the child is also an abstract component, e.g. <keep-alive>
+// we want to recursively retrieve the real component to be rendered
+function getRealChild(vnode) {
+    const compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    const data = {};
+    const options = comp.$options;
+    // props
+    for (const key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
+}
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
+    }
+}
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
+}
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
+var Transition = {
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render(h) {
+        let children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (children.length > 1) {
+            warn$2('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        const mode = this.mode;
+        // warn invalid mode
+        if (mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn$2('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        const rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        const child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        const id = `__transition-${this._uid}-`;
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            const oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn$2(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
+// Provides transition support for list items.
+const props = extend({
+    tag: String,
+    moveClass: String,
+}, transitionProps);
+delete props.mode;
+var TransitionGroup = {
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
+            // force removing pass
+            this.__patch__(this._vnode, this.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this._vnode = this.kept;
+            restoreActiveInstance();
+            update.call(this, vnode, hydrating);
+        };
+    },
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
+                        : c.tag;
+                    warn$2(`<transition-group> children must be keyed: <${name}>`);
+                }
+            }
+        }
+        if (prevChildren) {
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
+                }
+                else {
+                    removed.push(c);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach((c) => {
+            if (c.data.moved) {
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
+        });
+    },
+    methods: {
+        hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            const clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach((cls) => {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = "none";
+            this.$el.appendChild(clone);
+            const info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
+};
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    if (c.elm._moveCb) {
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    if (c.elm._enterCb) {
+        c.elm._enterCb();
+    }
+}
+function recordPosition(c) {
+    c.data.newPos = c.elm.getBoundingClientRect();
+}
+function applyTranslation(c) {
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        c.data.moved = true;
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
+    }
 }
 
-var platformComponents = {
-    Transition,
-    TransitionGroup,
+var platformComponents = {
+    Transition,
+    TransitionGroup,
 };
 
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
+// install platform specific utils
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
+Vue.config.isReservedAttr = isReservedAttr;
+Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.isUnknownElement = isUnknownElement;
+// install platform runtime directives & components
+extend(Vue.options.directives, platformDirectives);
+extend(Vue.options.components, platformComponents);
+// install platform patch function
+Vue.prototype.__patch__ = inBrowser ? patch : noop;
+// public mount method
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
+};
+// devtools global hook
+/* istanbul ignore next */
+if (inBrowser) {
+    setTimeout(() => {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
+        }
+    }, 0);
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-let decoder;
-var he = {
-    decode(html) {
-        decoder = decoder || document.createElement('div');
-        decoder.innerHTML = html;
-        return decoder.textContent;
-    },
+let decoder;
+var he = {
+    decode(html) {
+        decoder = decoder || document.createElement('div');
+        decoder.innerHTML = html;
+        return decoder.textContent;
+    },
 };
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if ((i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he.decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he.decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        {
+            if (el.tag === 'template') {
+                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model];
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model: model$1,
-    text,
-    html,
+var directives = {
+    model: model$1,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys$1(modules),
 };
 
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
+let isStaticKey;
+let isPlatformReservedTag;
+const genStaticKeysCached = cached(genStaticKeys);
+/**
+ * Goal of the optimizer: walk the generated template AST tree
+ * and detect sub-trees that are purely static, i.e. parts of
+ * the DOM that never needs to change.
+ *
+ * Once we detect these sub-trees, we can:
+ *
+ * 1. Hoist them into constants, so that we no longer need to
+ *    create fresh nodes for them on each re-render;
+ * 2. Completely skip them in the patching process.
+ */
+function optimize(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
 }
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if ((el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = typeof (msg) === 'string' ? { msg } : msg;
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize(ast, options);
-    }
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-// check whether current browser encodes a char inside attribute values
-let div;
-function getShouldDecode(href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-    return div.innerHTML.indexOf('&#10;') > 0;
-}
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-// #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
-    ? getShouldDecode(true)
+// check whether current browser encodes a char inside attribute values
+let div;
+function getShouldDecode(href) {
+    div = div || document.createElement('div');
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
+    return div.innerHTML.indexOf('&#10;') > 0;
+}
+// #3663: IE encodes newlines inside attribute values while other browsers don't
+const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+// #6828: chrome encodes content in a[href]
+const shouldDecodeNewlinesForHref = inBrowser
+    ? getShouldDecode(true)
     : false;
 
-const idToTemplate = cached((id) => {
-    const el = query(id);
-    return el && el.innerHTML;
-});
-const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && query(el);
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-        return this;
-    }
-    const options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-        let template = options.template;
-        if (template) {
-            if (typeof template === 'string') {
-                if (template.charAt(0) === '#') {
-                    template = idToTemplate(template);
-                    /* istanbul ignore if */
-                    if (!template) {
-                        warn$2(`Template element not found or is empty: ${options.template}`, this);
-                    }
-                }
-            }
-            else if (template.nodeType) {
-                template = template.innerHTML;
-            }
-            else {
-                {
-                    warn$2('invalid template option:' + template, this);
-                }
-                return this;
-            }
-        }
-        else if (el) {
-            // @ts-expect-error
-            template = getOuterHTML(el);
-        }
-        if (template) {
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile');
-            }
-            const { render, staticRenderFns } = compileToFunctions(template, {
-                outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
-                delimiters: options.delimiters,
-                comments: options.comments,
-            }, this);
-            options.render = render;
-            options.staticRenderFns = staticRenderFns;
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
-            }
-        }
-    }
-    return mount.call(this, el, hydrating);
-};
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el) {
-    if (el.outerHTML) {
-        return el.outerHTML;
-    }
-    else {
-        const container = document.createElement('div');
-        container.appendChild(el.cloneNode(true));
-        return container.innerHTML;
-    }
-}
+const idToTemplate = cached((id) => {
+    const el = query(id);
+    return el && el.innerHTML;
+});
+const mount = Vue.prototype.$mount;
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && query(el);
+    /* istanbul ignore if */
+    if (el === document.body || el === document.documentElement) {
+        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
+        return this;
+    }
+    const options = this.$options;
+    // resolve template/el and convert to render function
+    if (!options.render) {
+        let template = options.template;
+        if (template) {
+            if (typeof template === 'string') {
+                if (template.charAt(0) === '#') {
+                    template = idToTemplate(template);
+                    /* istanbul ignore if */
+                    if (!template) {
+                        warn$2(`Template element not found or is empty: ${options.template}`, this);
+                    }
+                }
+            }
+            else if (template.nodeType) {
+                template = template.innerHTML;
+            }
+            else {
+                {
+                    warn$2('invalid template option:' + template, this);
+                }
+                return this;
+            }
+        }
+        else if (el) {
+            // @ts-expect-error
+            template = getOuterHTML(el);
+        }
+        if (template) {
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile');
+            }
+            const { render, staticRenderFns } = compileToFunctions(template, {
+                outputSourceRange: "development" !== 'production',
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
+                delimiters: options.delimiters,
+                comments: options.comments,
+            }, this);
+            options.render = render;
+            options.staticRenderFns = staticRenderFns;
+            /* istanbul ignore if */
+            if (config.performance && mark) {
+                mark('compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
+            }
+        }
+    }
+    return mount.call(this, el, hydrating);
+};
+/**
+ * Get outerHTML of elements, taking care
+ * of SVG elements in IE as well.
+ */
+function getOuterHTML(el) {
+    if (el.outerHTML) {
+        return el.outerHTML;
+    }
+    else {
+        const container = document.createElement('div');
+        container.appendChild(el.cloneNode(true));
+        return container.innerHTML;
+    }
+}
 Vue.compile = compileToFunctions;
 
 export { Vue as default };
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
index 4671d375b3f..b986f24df11 100644
--- a/dist/vue.esm.js
+++ b/dist/vue.esm.js
@@ -3,5030 +3,5027 @@
  * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$2(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Simple bind polyfill for environments that do not support it,
+ * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+ * since native bind is now performant enough in most browsers.
+ * But removing it would mean breaking code that was able to run in
+ * PhantomJS 1.x, so this must be kept for backward compatibility.
+ */
+/* istanbul ignore next */
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        const l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+/**
+ * Convert an Array-like object to a real Array.
+ */
+function toArray(list, start) {
+    start = start || 0;
+    let i = list.length - start;
+    const ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
+}
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
+}
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Ensure a function is called only once.
+ */
+function once(fn) {
+    let called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Check if a string starts with $ or _
+ */
+function isReserved(str) {
+    const c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
+}
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Parse simple path.
+ */
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    const segments = path.split('.');
+    return function (obj) {
+        for (let i = 0; i < segments.length; i++) {
+            if (!obj)
+                return;
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+// detect devtools
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+if (process.env.NODE_ENV !== 'production') {
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid$2 = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Delete a property and trigger change if necessary.
+ */
+function del(target, key) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+if (process.env.NODE_ENV !== 'production') {
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn$2('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warn$2('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives$1(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-        // skip validation for weex recycle-list child component props
-        !(false  )) {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        // skip validation for weex recycle-list child component props
+        !(false  )) {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+        warn$2('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn$2('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    if (process.env.NODE_ENV !== 'production') {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    if (process.env.NODE_ENV !== 'production') {
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                // @ts-expect-error should it be any?
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
+/* globals MutationObserver */
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
+function flushCallbacks() {
+    pending = false;
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// Here we have async deferring wrappers using microtasks.
+// In 2.5 we used (macro) tasks (in combination with microtasks).
+// However, it has subtle problems when state is changed right before repaint
+// (e.g. #6813, out-in transitions).
+// Also, using (macro) tasks in event handler would cause some weird behaviors
+// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+// So we now use microtasks everywhere, again.
+// A major drawback of this tradeoff is that there are some scenarios
+// where microtasks have too high a priority and fire in between supposedly
+// sequential events (e.g. #4521, #6690, which have workarounds)
+// or even between bubbling of the same event (#6566).
+let timerFunc;
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            setTimeout(noop);
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = () => {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = () => {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    let _resolve;
+    callbacks.push(() => {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise((resolve) => {
+            _resolve = resolve;
+        });
+    }
 }
 
-let mark;
-let measure;
-if (process.env.NODE_ENV !== 'production') {
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
+let mark;
+let measure;
+if (process.env.NODE_ENV !== 'production') {
+    const perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-if (process.env.NODE_ENV !== 'production') {
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn$2(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
+/* not type checking this file because flow doesn't play well with Proxy */
+let initProxy;
+if (process.env.NODE_ENV !== 'production') {
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const warnNonPresent = (target, key) => {
+        warn$2(`Property or method "${key}" is not defined on the instance but ` +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    const warnReservedPrefix = (target, key) => {
+        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return has || !isAllowed;
+        },
+    };
+    const getHandler = {
+        get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    let invoker;
+    const oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            if (process.env.NODE_ENV !== 'production') {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            if (process.env.NODE_ENV !== 'production') {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], () => {
-                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-            else {
-                defineReactive(vm, key, result[key]);
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else if (process.env.NODE_ENV !== 'production') {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function initProvide(vm) {
+    const provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    const result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach((key) => {
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production') {
+                defineReactive(vm, key, result[key], () => {
+                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
+                });
+            }
+            else {
+                defineReactive(vm, key, result[key]);
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    warn$2(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic$1(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic$1(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic$1(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic$1(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (process.env.NODE_ENV !== 'production' &&
-            key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (process.env.NODE_ENV !== 'production' &&
+            key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    if (process.env.NODE_ENV !== 'production') {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    if (process.env.NODE_ENV !== 'production') {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        if (process.env.NODE_ENV !== 'production') {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook$1(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        if (process.env.NODE_ENV !== 'production') {
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (process.env.NODE_ENV !== 'production' &&
-        isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (process.env.NODE_ENV !== 'production' &&
-                isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (process.env.NODE_ENV !== 'production' &&
+        isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn$2('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (process.env.NODE_ENV !== 'production' &&
+                isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-        }, true);
-    }
-    else {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-                warn$2('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    const parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
+        }, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
+        }, true);
+    }
+    else {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
+    }
+}
+let currentRenderingInstance = null;
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        let vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
+        }
+        catch (e) {
+            handleError(e, vm, `render`);
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, `renderError`);
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
+        }
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+                warn$2('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
+            }
+            vnode = createEmptyVNode();
+        }
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(process.env.NODE_ENV !== 'production'
-                                ? `timeout (${res.timeout}ms)`
-                                : null);
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
+}
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    const owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        const resolve = once((res) => {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        const reject = once((reason) => {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(process.env.NODE_ENV !== 'production'
+                                ? `timeout (${res.timeout}ms)`
+                                : null);
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
+    }
 }
 
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        if (process.env.NODE_ENV !== 'production') {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    const listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
+    }
+}
+let target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target$1.$off(event, fn);
+}
+function createOnceHandler$1(event, fn) {
+    const _target = target$1;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
+}
+function eventsMixin(Vue) {
+    const hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        const vm = this;
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        const vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        const vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
+            }
+            return vm;
+        }
+        // specific event
+        const cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        let cb;
+        let i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        const vm = this;
+        if (process.env.NODE_ENV !== 'production') {
+            const lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+            }
+        }
+        let cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== "production") {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn$2("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn$2("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+let isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    const prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return () => {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    const options = vm.$options;
+    // locate first non-abstract parent
+    let parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        const vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        const vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook$1(vm, "beforeDestroy");
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        const parent = vm.$parent;
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove$2(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        let i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook$1(vm, "destroyed");
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        if (process.env.NODE_ENV !== "production") {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                vm.$options.el ||
+                el) {
+                warn$2("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
+            }
+            else {
+                warn$2("Failed to mount component: template or render function not defined.", vm);
+            }
+        }
+    }
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
+            mark(startTag);
+            const vnode = vm._render();
+            mark(endTag);
+            measure(`vue ${name} render`, startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = () => {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook$1(vm, "beforeUpdate");
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook$1(vm, "mounted");
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    if (process.env.NODE_ENV !== "production") {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    if (process.env.NODE_ENV !== "production") {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "deactivated");
+    }
+}
+function callHook$1(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index$1 = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index$1 = queue.length = activatedChildren.length = 0;
-    has = {};
-    if (process.env.NODE_ENV !== 'production') {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index$1 = 0; index$1 < queue.length; index$1++) {
-        watcher = queue[index$1];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn$2('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index$1 && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (process.env.NODE_ENV !== 'production' && !config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index$1 = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index$1 = queue.length = activatedChildren.length = 0;
+    has = {};
+    if (process.env.NODE_ENV !== 'production') {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+let currentFlushTimestamp = 0;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Flush both queues and run the watchers.
+ */
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    let watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort((a, b) => a.id - b.id);
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index$1 = 0; index$1 < queue.length; index$1++) {
+        watcher = queue[index$1];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn$2('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
+    }
+}
+function callUpdatedHooks(queue) {
+    let i = queue.length;
+    while (i--) {
+        const watcher = queue[i];
+        const vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, 'updated');
+        }
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
+}
+function callActivatedHooks(queue) {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
+}
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ */
+function queueWatcher(watcher) {
+    const id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            let i = queue.length - 1;
+            while (i > index$1 && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (process.env.NODE_ENV !== 'production' && !config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
+    }
 }
 
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = process.env.NODE_ENV !== 'production'
-            ? expOrFn.toString()
-            : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' && warn$2(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                // @ts-expect-error e is unknown, should we cast or any?
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
+let uid$1 = 0;
+/**
+ * A watcher parses an expression, collects dependencies,
+ * and fires callback when the expression value changes.
+ * This is used for both the $watch() api and directives.
+ */
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = process.env.NODE_ENV !== 'production'
+            ? expOrFn.toString()
+            : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' && warn$2(`Failed watching path: "${expOrFn}" ` +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
+        }
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    }
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    }
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    }
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    }
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    }
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
+    }
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    }
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
 }
 
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== "production") {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        else {
-            defineReactive(props, key, value);
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        process.env.NODE_ENV !== "production" &&
-            warn$2("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        if (process.env.NODE_ENV !== "production") {
-            if (methods && hasOwn(methods, key)) {
-                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== "production" &&
-                warn$2(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== "production" && getter == null) {
-            warn$2(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else if (process.env.NODE_ENV !== "production") {
-            if (key in vm.$data) {
-                warn$2(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (process.env.NODE_ENV !== "production" &&
-        sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        if (process.env.NODE_ENV !== "production") {
-            if (typeof methods[key] !== "function") {
-                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    if (process.env.NODE_ENV !== "production") {
-        dataDef.set = function () {
-            warn$2("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn$2(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
+const sharedPropertyDefinition = {
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
+};
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    const opts = vm.$options;
+    if (opts.props)
+        initProps$1(vm, opts.props);
+    if (opts.methods)
+        initMethods(vm, opts.methods);
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        initComputed$1(vm, opts.computed);
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps$1(vm, propsOptions) {
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    for (const key in propsOptions) {
+        keys.push(key);
+        const value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== "production") {
+            const hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+            }
+            defineReactive(props, key, value, () => {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn$2(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
+                }
+            });
+        }
+        else {
+            defineReactive(props, key, value);
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, `_props`, key);
+        }
+    }
+    toggleObserving(true);
+}
+function initData(vm) {
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        process.env.NODE_ENV !== "production" &&
+            warn$2("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+    }
+    // proxy data on instance
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
+    while (i--) {
+        const key = keys[i];
+        if (process.env.NODE_ENV !== "production") {
+            if (methods && hasOwn(methods, key)) {
+                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            process.env.NODE_ENV !== "production" &&
+                warn$2(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, `_data`, key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
+}
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
+    }
+    catch (e) {
+        handleError(e, vm, `data()`);
+        return {};
+    }
+    finally {
+        popTarget();
+    }
+}
+const computedWatcherOptions = { lazy: true };
+function initComputed$1(vm, computed) {
+    // $flow-disable-line
+    const watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== "production" && getter == null) {
+            warn$2(`Getter is missing for computed property "${key}".`, vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else if (process.env.NODE_ENV !== "production") {
+            if (key in vm.$data) {
+                warn$2(`The computed property "${key}" is already defined in data.`, vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
+            }
+        }
+    }
+}
+function defineComputed(target, key, userDef) {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (process.env.NODE_ENV !== "production" &&
+        sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        const watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
+}
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
+        if (process.env.NODE_ENV !== "production") {
+            if (typeof methods[key] !== "function") {
+                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
+            }
+        }
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
+    }
+}
+function initWatch(vm, watch) {
+    for (const key in watch) {
+        const handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (let i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === "string") {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    const dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    const propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    if (process.env.NODE_ENV !== "production") {
+        dataDef.set = function () {
+            warn$2("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
+        };
+        propsDef.set = function () {
+            warn$2(`$props is readonly.`, this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        const vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        const watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
+            pushTarget();
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            initProxy(vm);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+let uid = 0;
+function initMixin$1(Vue) {
+    Vue.prototype._init = function (options) {
+        const vm = this;
+        // a uid
+        vm._uid = uid++;
+        let startTag, endTag;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            initProxy(vm);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook$1(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook$1(vm, 'created');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    const opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    const parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    const vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function Vue(options) {
-    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
-        warn$2("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
+function Vue(options) {
+    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
+        warn$2("Vue is a constructor and should be called with the `new` keyword");
+    }
+    this._init(options);
+}
+//@ts-expect-error Vue has function type
+initMixin$1(Vue);
+//@ts-expect-error Vue has function type
+stateMixin(Vue);
+//@ts-expect-error Vue has function type
+eventsMixin(Vue);
+//@ts-expect-error Vue has function type
+lifecycleMixin(Vue);
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        const args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
+function initMixin(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (process.env.NODE_ENV !== 'production' && name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    let cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        const name = extendOptions.name || Super.options.name;
+        if (process.env.NODE_ENV !== 'production' && name) {
+            validateComponentName(name);
+        }
+        const Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps(Comp) {
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
+    }
+}
+function initComputed(Comp) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (process.env.NODE_ENV !== 'production' && type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach((type) => {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (process.env.NODE_ENV !== 'production' && type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
+/* @flow */
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
+}
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
+var KeepAlive = {
+    name: "keep-alive",
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed() {
+        for (const key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
+        });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
+        });
+    },
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            const { cache, keys } = this;
+            const key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove$2(keys, key);
+                keys.push(key);
+            }
+            else {
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
+            }
+            // @ts-expect-error can vnode.data can be undefined
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
-var builtInComponents = {
-    KeepAlive,
+var builtInComponents = {
+    KeepAlive,
 };
 
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    if (process.env.NODE_ENV !== 'production') {
-        configDef.set = () => {
-            warn$2('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn$2,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+function initGlobalAPI(Vue) {
+    // config
+    const configDef = {};
+    configDef.get = () => config;
+    if (process.env.NODE_ENV !== 'production') {
+        configDef.set = () => {
+            warn$2('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn: warn$2,
+        extend,
+        mergeOptions,
+        defineReactive,
+    };
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = (obj) => {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach((type) => {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
+initGlobalAPI(Vue);
+Object.defineProperty(Vue.prototype, '$isServer', {
+    get: isServerRendering,
+});
+Object.defineProperty(Vue.prototype, '$ssrContext', {
+    get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
+});
+// expose FunctionalRenderContext for ssr runtime helper installation
+Object.defineProperty(Vue, 'FunctionalRenderContext', {
+    value: FunctionalRenderContext,
+});
 Vue.version = '2.6.14';
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+const isReservedAttr = makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+};
+const getXlinkProp = (name) => {
+    return isXlink(name) ? name.slice(6, name.length) : '';
+};
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
+const namespaceMap = {
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
+};
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+const unknownElementCache = Object.create(null);
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    const el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
+}
 const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        const selected = document.querySelector(el);
+        if (!selected) {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
+function createElement(tagName, vnode) {
+    const elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
+}
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
+}
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function createComment(text) {
+    return document.createComment(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    node.appendChild(child);
+}
+function parentNode(node) {
+    return node.parentNode;
+}
+function nextSibling(node) {
+    return node.nextSibling;
+}
+function tagName(node) {
+    return node.tagName;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5045,5460 +5042,5459 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
+var ref = {
+    create(_, vnode) {
+        registerRef(vnode);
+    },
+    update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy(vnode) {
+        registerRef(vnode, true);
+    },
+};
+function registerRef(vnode, isRemoval) {
+    const key = vnode.data.ref;
+    if (!isDef(key))
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
+    if (isRemoval) {
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
+        }
+        else if (obj === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(obj)) {
+                refs[key] = [ref];
+            }
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
+    }
 }
 
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            if (process.env.NODE_ENV !== 'production') {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn$2('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            if (process.env.NODE_ENV !== 'production') {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        if (process.env.NODE_ENV !== 'production') {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        if (process.env.NODE_ENV !== 'production') {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else if (process.env.NODE_ENV !== 'production') {
-                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
+/**
+ * Virtual DOM patching algorithm based on Snabbdom by
+ * Simon Friis Vindum (@paldepind)
+ * Licensed under the MIT License
+ * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+ *
+ * modified by Evan You (@yyx990803)
+ *
+ * Not type-checking this because this file is perf-critical and the cost
+ * of making flow understand it is not worth it.
+ */
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    let i, key;
+    const map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            map[key] = i;
+    }
+    return map;
+}
+function createPatchFunction(backend) {
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
+    }
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    }
+    function createRmCb(childElm, listeners) {
+        function remove() {
+            if (--remove.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove.listeners = listeners;
+        return remove;
+    }
+    function removeNode(el) {
+        const parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
+    }
+    function isUnknownElement(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some((ignore) => {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    let creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
+        if (isDef(tag)) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn$2('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i = vnode.data;
+        if (isDef(i)) {
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        let innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref) {
+        if (isDef(parent)) {
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            if (process.env.NODE_ENV !== 'production') {
+                checkDuplicateKeys(children);
+            }
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                i.create(emptyNode, vnode);
+            if (isDef(i.insert))
+                insertedVnodeQueue.push(vnode);
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        let i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            let ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        let i, j;
+        const data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                i(vnode);
+            for (i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            let i;
+            const listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        const canMove = !removeOnly;
+        if (process.env.NODE_ENV !== 'production') {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function checkDuplicateKeys(children) {
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                return i;
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        const elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        let i;
+        const data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                i(oldVnode, vnode);
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+            }
+            else if (isDef(ch)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    nodeOps.setTextContent(elm, '');
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                i(oldVnode, vnode);
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    let hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        let i;
+        const { tag, data, children } = vnode;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        if (process.env.NODE_ENV !== 'production') {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                i(vnode, true /* hydrating */);
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                let fullInvoke = false;
+                for (const key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                invokeDestroyHook(oldVnode);
+            return;
+        }
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            const isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else if (process.env.NODE_ENV !== 'production') {
+                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-var directives$1 = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            // @ts-expect-error should it be any?
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
+var directives$1 = {
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
+};
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
+    }
+}
+const emptyModifiers = Object.create(null);
+function normalizeDirectives(dirs, vm) {
+    const res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    let i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
+    // $flow-disable-line
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+}
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    const fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+        }
+    }
 }
 
 var baseModules = [ref, directives$1];
 
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
+function updateAttrs(oldVnode, vnode) {
+    const opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            const blocker = (e) => {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
+}
+var attrs = {
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass$1 = {
-    create: updateClass,
-    update: updateClass,
+function updateClass(oldVnode, vnode) {
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    let cls = genClassForVnode(vnode);
+    // handle transition classes
+    const transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
+}
+var klass$1 = {
+    create: updateClass,
+    update: updateClass,
 };
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' &&
-        warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-let warn$1;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn$1;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+const CHECKBOX_RADIO_TOKEN = '__c';
+function model$1(el, dir, _warn) {
+    warn$1 = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else if (!config.isReservedTag(tag)) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1(`<${el.tag} v-model="${value}">: ` +
+            `v-model is not supported on this element type. ` +
+            "If you are working with contenteditable, it's recommended to " +
+            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+// normalize v-model event tokens that can only be determined at runtime.
+// it's important to place the event as the first in the array because
+// the whole point is ensuring the v-model callback gets called before
+// user-attached handlers.
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
+}
+let target;
+function createOnceHandler(event, handler, capture) {
+    const _target = target; // save current target element in closure
+    return function onceHandler() {
+        const res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove(event, onceHandler, capture, _target);
+        }
+    };
+}
+// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+// implementation and does not fire microtasks in between event propagation, so
+// safe to exclude.
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+function add(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+}
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
+}
+var events = {
+    create: updateDOMListeners,
+    update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
+let svgContainer;
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                vnode.children.length = 0;
+            if (cur === oldProps[key])
+                continue;
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            const strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    let notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
+}
+var domProps = {
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style$1 = {
-    create: updateStyle,
-    update: updateStyle,
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        const normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (let i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
+};
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
+});
+function updateStyle(oldVnode, vnode) {
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    const newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
+    }
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
+    }
+}
+var style$1 = {
+    create: updateStyle,
+    update: updateStyle,
 };
 
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
+const whitespaceRE$1 = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        const cur = ` ${el.getAttribute('class') || ''} `;
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        const res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+const autoCssTransition = cached((name) => {
+    return {
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
+    };
+});
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
+// Transition property/event sniffing
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+const raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ (fn) => fn();
+function nextFrame(fn) {
+    raf(() => {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type)
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    const onEnd = (e) => {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(() => {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+const transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type,
+        timeout,
+        propCount,
+        hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map((d, i) => {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
+function enter(vnode, toggleDisplay) {
+    const el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    const el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    const cb = (el._leaveCb = once(() => {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn$2(`<transition> explicit ${name} duration is NaN - ` +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    const invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
+    if (vnode.data.show !== true) {
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
+    }
     : {};
 
 var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules$1 = platformModules.concat(baseModules);
+// the directive module should be applied last, after all
+// built-in modules have been applied.
+const modules$1 = platformModules.concat(baseModules);
 const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+/**
+ * Not type checking this file because flow doesn't like attaching
+ * properties to Elements.
+ */
+/* istanbul ignore if */
+if (isIE9) {
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
+}
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', () => {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                // trigger change event if
+                // no matching option found for at least one value
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
+};
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(() => {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    const value = binding.value;
+    const isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+        return;
+    }
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
+}
+function hasNoMatchingOption(value, options) {
+    return options.every((o) => !looseEqual(o, value));
+}
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
+}
+function onCompositionStart(e) {
+    e.target.composing = true;
+}
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        return;
+    e.target.composing = false;
+    trigger(e.target, 'input');
+}
+function trigger(el, type) {
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind(el, { value }, vnode) {
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, () => {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update(el, { value, oldValue }, vnode) {
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, () => {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, () => {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
-var platformDirectives = {
-    model: directive,
-    show,
+var platformDirectives = {
+    model: directive,
+    show,
 };
 
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-            warn$2('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (process.env.NODE_ENV !== 'production' &&
-            mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn$2('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
+// Provides transition support for a single element/component.
+const transitionProps = {
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
+};
+// in case the child is also an abstract component, e.g. <keep-alive>
+// we want to recursively retrieve the real component to be rendered
+function getRealChild(vnode) {
+    const compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    const data = {};
+    const options = comp.$options;
+    // props
+    for (const key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
+}
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
+    }
+}
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
+}
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
+var Transition = {
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render(h) {
+        let children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+            warn$2('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        const mode = this.mode;
+        // warn invalid mode
+        if (process.env.NODE_ENV !== 'production' &&
+            mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn$2('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        const rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        const child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        const id = `__transition-${this._uid}-`;
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            const oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else if (process.env.NODE_ENV !== "production") {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn$2(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
+// Provides transition support for list items.
+const props = extend({
+    tag: String,
+    moveClass: String,
+}, transitionProps);
+delete props.mode;
+var TransitionGroup = {
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
+            // force removing pass
+            this.__patch__(this._vnode, this.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this._vnode = this.kept;
+            restoreActiveInstance();
+            update.call(this, vnode, hydrating);
+        };
+    },
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else if (process.env.NODE_ENV !== "production") {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
+                        : c.tag;
+                    warn$2(`<transition-group> children must be keyed: <${name}>`);
+                }
+            }
+        }
+        if (prevChildren) {
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
+                }
+                else {
+                    removed.push(c);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach((c) => {
+            if (c.data.moved) {
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
+        });
+    },
+    methods: {
+        hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            const clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach((cls) => {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = "none";
+            this.$el.appendChild(clone);
+            const info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
+};
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    if (c.elm._moveCb) {
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    if (c.elm._enterCb) {
+        c.elm._enterCb();
+    }
+}
+function recordPosition(c) {
+    c.data.newPos = c.elm.getBoundingClientRect();
+}
+function applyTranslation(c) {
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        c.data.moved = true;
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
+    }
 }
 
-var platformComponents = {
-    Transition,
-    TransitionGroup,
+var platformComponents = {
+    Transition,
+    TransitionGroup,
 };
 
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else if (process.env.NODE_ENV !== 'production' &&
-                process.env.NODE_ENV !== 'test') {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (process.env.NODE_ENV !== 'production' &&
-            process.env.NODE_ENV !== 'test' &&
-            config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
+// install platform specific utils
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
+Vue.config.isReservedAttr = isReservedAttr;
+Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.isUnknownElement = isUnknownElement;
+// install platform runtime directives & components
+extend(Vue.options.directives, platformDirectives);
+extend(Vue.options.components, platformComponents);
+// install platform patch function
+Vue.prototype.__patch__ = inBrowser ? patch : noop;
+// public mount method
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
+};
+// devtools global hook
+/* istanbul ignore next */
+if (inBrowser) {
+    setTimeout(() => {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else if (process.env.NODE_ENV !== 'production' &&
+                process.env.NODE_ENV !== 'test') {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (process.env.NODE_ENV !== 'production' &&
+            process.env.NODE_ENV !== 'test' &&
+            config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
+        }
+    }, 0);
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (process.env.NODE_ENV !== 'production' && staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (process.env.NODE_ENV !== 'production' && staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-let decoder;
-var he = {
-    decode(html) {
-        decoder = decoder || document.createElement('div');
-        decoder.innerHTML = html;
-        return decoder.textContent;
-    },
+let decoder;
+var he = {
+    decode(html) {
+        decoder = decoder || document.createElement('div');
+        decoder.innerHTML = html;
+        return decoder.textContent;
+    },
 };
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (process.env.NODE_ENV !== 'production' &&
-                !stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    (i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he.decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                process.env.NODE_ENV !== 'production' &&
-                    warn('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (process.env.NODE_ENV !== 'production' &&
-                        options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (el.tag === 'template') {
-                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (el.slotTarget || el.slotScope) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (!maybeComponent(el)) {
-                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (process.env.NODE_ENV !== 'production' &&
-                    value.trim().length === 0) {
-                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (process.env.NODE_ENV !== 'production' && name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            if (process.env.NODE_ENV !== 'production') {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (process.env.NODE_ENV !== 'production' &&
-            map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he.decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (el.tag === 'template') {
+                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model];
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model: model$1,
-    text,
-    html,
+var directives = {
+    model: model$1,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys$1(modules),
 };
 
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
+let isStaticKey;
+let isPlatformReservedTag;
+const genStaticKeysCached = cached(genStaticKeys);
+/**
+ * Goal of the optimizer: walk the generated template AST tree
+ * and detect sub-trees that are purely static, i.e. parts of
+ * the DOM that never needs to change.
+ *
+ * Once we detect these sub-trees, we can:
+ *
+ * 1. Hoist them into constants, so that we no longer need to
+ *    create fresh nodes for them on each re-render;
+ * 2. Completely skip them in the patching process.
+ */
+function optimize(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
 }
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            process.env.NODE_ENV !== 'production' &&
-                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (process.env.NODE_ENV !== 'production' &&
-        state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if (process.env.NODE_ENV !== 'production' &&
-        (el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        if (process.env.NODE_ENV !== 'production') {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            if (process.env.NODE_ENV !== 'production') {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = typeof (msg) === 'string' ? { msg } : msg;
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize(ast, options);
-    }
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize(ast, options);
+    }
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-// check whether current browser encodes a char inside attribute values
-let div;
-function getShouldDecode(href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-    return div.innerHTML.indexOf('&#10;') > 0;
-}
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-// #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
-    ? getShouldDecode(true)
+// check whether current browser encodes a char inside attribute values
+let div;
+function getShouldDecode(href) {
+    div = div || document.createElement('div');
+    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
+    return div.innerHTML.indexOf('&#10;') > 0;
+}
+// #3663: IE encodes newlines inside attribute values while other browsers don't
+const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+// #6828: chrome encodes content in a[href]
+const shouldDecodeNewlinesForHref = inBrowser
+    ? getShouldDecode(true)
     : false;
 
-const idToTemplate = cached((id) => {
-    const el = query(id);
-    return el && el.innerHTML;
-});
-const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && query(el);
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-        return this;
-    }
-    const options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-        let template = options.template;
-        if (template) {
-            if (typeof template === 'string') {
-                if (template.charAt(0) === '#') {
-                    template = idToTemplate(template);
-                    /* istanbul ignore if */
-                    if (process.env.NODE_ENV !== 'production' && !template) {
-                        warn$2(`Template element not found or is empty: ${options.template}`, this);
-                    }
-                }
-            }
-            else if (template.nodeType) {
-                template = template.innerHTML;
-            }
-            else {
-                if (process.env.NODE_ENV !== 'production') {
-                    warn$2('invalid template option:' + template, this);
-                }
-                return this;
-            }
-        }
-        else if (el) {
-            // @ts-expect-error
-            template = getOuterHTML(el);
-        }
-        if (template) {
-            /* istanbul ignore if */
-            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-                mark('compile');
-            }
-            const { render, staticRenderFns } = compileToFunctions(template, {
-                outputSourceRange: process.env.NODE_ENV !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
-                delimiters: options.delimiters,
-                comments: options.comments,
-            }, this);
-            options.render = render;
-            options.staticRenderFns = staticRenderFns;
-            /* istanbul ignore if */
-            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-                mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
-            }
-        }
-    }
-    return mount.call(this, el, hydrating);
-};
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el) {
-    if (el.outerHTML) {
-        return el.outerHTML;
-    }
-    else {
-        const container = document.createElement('div');
-        container.appendChild(el.cloneNode(true));
-        return container.innerHTML;
-    }
-}
+const idToTemplate = cached((id) => {
+    const el = query(id);
+    return el && el.innerHTML;
+});
+const mount = Vue.prototype.$mount;
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && query(el);
+    /* istanbul ignore if */
+    if (el === document.body || el === document.documentElement) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
+        return this;
+    }
+    const options = this.$options;
+    // resolve template/el and convert to render function
+    if (!options.render) {
+        let template = options.template;
+        if (template) {
+            if (typeof template === 'string') {
+                if (template.charAt(0) === '#') {
+                    template = idToTemplate(template);
+                    /* istanbul ignore if */
+                    if (process.env.NODE_ENV !== 'production' && !template) {
+                        warn$2(`Template element not found or is empty: ${options.template}`, this);
+                    }
+                }
+            }
+            else if (template.nodeType) {
+                template = template.innerHTML;
+            }
+            else {
+                if (process.env.NODE_ENV !== 'production') {
+                    warn$2('invalid template option:' + template, this);
+                }
+                return this;
+            }
+        }
+        else if (el) {
+            // @ts-expect-error
+            template = getOuterHTML(el);
+        }
+        if (template) {
+            /* istanbul ignore if */
+            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+                mark('compile');
+            }
+            const { render, staticRenderFns } = compileToFunctions(template, {
+                outputSourceRange: process.env.NODE_ENV !== 'production',
+                shouldDecodeNewlines,
+                shouldDecodeNewlinesForHref,
+                delimiters: options.delimiters,
+                comments: options.comments,
+            }, this);
+            options.render = render;
+            options.staticRenderFns = staticRenderFns;
+            /* istanbul ignore if */
+            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+                mark('compile end');
+                measure(`vue ${this._name} compile`, 'compile', 'compile end');
+            }
+        }
+    }
+    return mount.call(this, el, hydrating);
+};
+/**
+ * Get outerHTML of elements, taking care
+ * of SVG elements in IE as well.
+ */
+function getOuterHTML(el) {
+    if (el.outerHTML) {
+        return el.outerHTML;
+    }
+    else {
+        const container = document.createElement('div');
+        container.appendChild(el.cloneNode(true));
+        return container.innerHTML;
+    }
+}
 Vue.compile = compileToFunctions;
 
 export { Vue as default };
diff --git a/dist/vue.js b/dist/vue.js
index 2582d0352dd..58b38d0e024 100644
--- a/dist/vue.js
+++ b/dist/vue.js
@@ -9,4996 +9,4993 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
 })(this, (function () { 'use strict';
 
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  function isRegExp(v) {
-      return _toString.call(v) === '[object RegExp]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$2(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-  /* istanbul ignore next */
-  function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          const l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
-  }
-  function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
-  }
-  // @ts-expect-error bind cannot be `undefined`
-  const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-  /**
-   * Convert an Array-like object to a real Array.
-   */
-  function toArray(list, start) {
-      start = start || 0;
-      let i = list.length - start;
-      const ret = new Array(i);
-      while (i--) {
-          ret[i] = list[i + start];
-      }
-      return ret;
-  }
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys$1(modules) {
-      return modules
-          .reduce((keys, m) => {
-          return keys.concat(m.staticKeys || []);
-      }, [])
-          .join(',');
-  }
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-  /**
-   * Ensure a function is called only once.
-   */
-  function once(fn) {
-      let called = false;
-      return function () {
-          if (!called) {
-              called = true;
-              fn.apply(this, arguments);
-          }
-      };
+  const emptyObject = Object.freeze({});
+  // These helpers produce better VM code in JS engines due to their
+  // explicitness and function inlining.
+  function isUndef(v) {
+      return v === undefined || v === null;
+  }
+  function isDef(v) {
+      return v !== undefined && v !== null;
+  }
+  function isTrue(v) {
+      return v === true;
+  }
+  function isFalse(v) {
+      return v === false;
+  }
+  /**
+   * Check if value is primitive.
+   */
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
+  }
+  /**
+   * Quick object check - this is primarily used to tell
+   * objects from primitive values when we know the value
+   * is a JSON-compliant type.
+   */
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
+  }
+  /**
+   * Get the raw type string of a value, e.g., [object Object].
+   */
+  const _toString = Object.prototype.toString;
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
+  }
+  /**
+   * Strict object type check. Only returns true
+   * for plain JavaScript objects.
+   */
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
+  }
+  function isRegExp(v) {
+      return _toString.call(v) === '[object RegExp]';
+  }
+  /**
+   * Check if val is a valid array index.
+   */
+  function isValidArrayIndex(val) {
+      const n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
+  }
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
+  }
+  /**
+   * Convert a value to a string that is actually rendered.
+   */
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
+  }
+  /**
+   * Convert an input value to a number for persistence.
+   * If the conversion fails, return original string.
+   */
+  function toNumber(val) {
+      const n = parseFloat(val);
+      return isNaN(n) ? val : n;
+  }
+  /**
+   * Make a map and return a function for checking if a key
+   * is in that map.
+   */
+  function makeMap(str, expectsLowerCase) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+  }
+  /**
+   * Check if a tag is a built-in tag.
+   */
+  const isBuiltInTag = makeMap('slot,component', true);
+  /**
+   * Check if an attribute is a reserved attribute.
+   */
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  /**
+   * Remove an item from an array.
+   */
+  function remove$2(arr, item) {
+      if (arr.length) {
+          const index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
+      }
+  }
+  /**
+   * Check whether an object has the property.
+   */
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
+  }
+  /**
+   * Create a cached version of a pure function.
+   */
+  function cached(fn) {
+      const cache = Object.create(null);
+      return function cachedFn(str) {
+          const hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
+  }
+  /**
+   * Camelize a hyphen-delimited string.
+   */
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+  });
+  /**
+   * Capitalize a string.
+   */
+  const capitalize = cached((str) => {
+      return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  /**
+   * Hyphenate a camelCase string.
+   */
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
+  });
+  /**
+   * Simple bind polyfill for environments that do not support it,
+   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+   * since native bind is now performant enough in most browsers.
+   * But removing it would mean breaking code that was able to run in
+   * PhantomJS 1.x, so this must be kept for backward compatibility.
+   */
+  /* istanbul ignore next */
+  function polyfillBind(fn, ctx) {
+      function boundFn(a) {
+          const l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
+  }
+  function nativeBind(fn, ctx) {
+      return fn.bind(ctx);
+  }
+  // @ts-expect-error bind cannot be `undefined`
+  const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
+  /**
+   * Convert an Array-like object to a real Array.
+   */
+  function toArray(list, start) {
+      start = start || 0;
+      let i = list.length - start;
+      const ret = new Array(i);
+      while (i--) {
+          ret[i] = list[i + start];
+      }
+      return ret;
+  }
+  /**
+   * Mix properties into target object.
+   */
+  function extend(to, _from) {
+      for (const key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
+  }
+  /**
+   * Merge an Array of Objects into a single Object.
+   */
+  function toObject(arr) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
+      }
+      return res;
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * Perform no operation.
+   * Stubbing args to make Flow happy without leaving useless transpiled code
+   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+   */
+  function noop(a, b, c) { }
+  /**
+   * Always return false.
+   */
+  const no = (a, b, c) => false;
+  /* eslint-enable no-unused-vars */
+  /**
+   * Return the same value.
+   */
+  const identity = (_) => _;
+  /**
+   * Generate a string containing static keys from compiler modules.
+   */
+  function genStaticKeys$1(modules) {
+      return modules
+          .reduce((keys, m) => {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
+  }
+  /**
+   * Check if two values are loosely equal - that is,
+   * if they are plain objects, do they have the same shape?
+   */
+  function looseEqual(a, b) {
+      if (a === b)
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every((e, i) => {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every((key) => {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
+  }
+  /**
+   * Return the first index at which a loosely equal value can be
+   * found in the array (if value is a plain object, the array must
+   * contain an object of the same shape), or -1 if it is not present.
+   */
+  function looseIndexOf(arr, val) {
+      for (let i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              return i;
+      }
+      return -1;
+  }
+  /**
+   * Ensure a function is called only once.
+   */
+  function once(fn) {
+      let called = false;
+      return function () {
+          if (!called) {
+              called = true;
+              fn.apply(this, arguments);
+          }
+      };
   }
 
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch',
   ];
 
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Check if a string starts with $ or _
-   */
-  function isReserved(str) {
-      const c = (str + '').charCodeAt(0);
-      return c === 0x24 || c === 0x5f;
-  }
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-  /**
-   * Parse simple path.
-   */
-  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-  function parsePath(path) {
-      if (bailRE.test(path)) {
-          return;
-      }
-      const segments = path.split('.');
-      return function (obj) {
-          for (let i = 0; i < segments.length; i++) {
-              if (!obj)
-                  return;
-              obj = obj[segments[i]];
-          }
-          return obj;
-      };
+  /**
+   * unicode letters used for parsing html tags, component names and property paths.
+   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+   */
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+  /**
+   * Check if a string starts with $ or _
+   */
+  function isReserved(str) {
+      const c = (str + '').charCodeAt(0);
+      return c === 0x24 || c === 0x5f;
+  }
+  /**
+   * Define a property.
+   */
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
+  }
+  /**
+   * Parse simple path.
+   */
+  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+  function parsePath(path) {
+      if (bailRE.test(path)) {
+          return;
+      }
+      const segments = path.split('.');
+      return function (obj) {
+          for (let i = 0; i < segments.length; i++) {
+              if (!obj)
+                  return;
+              obj = obj[segments[i]];
+          }
+          return obj;
+      };
   }
 
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  const isFF = UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
-  };
-  // detect devtools
-  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
+  // can we use __proto__?
+  const hasProto = '__proto__' in {};
+  // Browser environment sniffing
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  const isFF = UA && UA.match(/firefox\/(\d+)/);
+  // Firefox has a "watch" function on Object.prototype...
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
+  if (inBrowser) {
+      try {
+          const opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
+  }
+  // this needs to be lazy-evaled because vue may be required before
+  // vue-server-renderer can set VUE_ENV
+  let _isServer;
+  const isServerRendering = () => {
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
+  };
+  // detect devtools
+  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+  /* istanbul ignore next */
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  const hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  let _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
+              return this.set[key] === true;
+          }
+          add(key) {
+              this.set[key] = true;
+          }
+          clear() {
+              this.set = Object.create(null);
+          }
+      };
   }
 
-  let warn$2 = noop;
-  let tip = noop;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn$2 = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (config.warnHandler) {
-              config.warnHandler.call(null, msg, vm, trace);
-          }
-          else if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
+  let warn$2 = noop;
+  let tip = noop;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
+  {
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn$2 = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
+          if (config.warnHandler) {
+              config.warnHandler.call(null, msg, vm, trace);
+          }
+          else if (hasConsole && !config.silent) {
+              console.error(`[Vue warn]: ${msg}${trace}`);
+          }
+      };
+      tip = (msg, vm) => {
+          if (hasConsole && !config.silent) {
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = (vm, includeFile) => {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
+              : vm._isVue
+                  ? vm.$options || vm.constructor.options
+                  : vm;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
+          if (!name && file) {
+              const match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
+      };
+      const repeat = (str, n) => {
+          let res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  res += str;
+              if (n > 1)
+                  str += str;
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = (vm) => {
+          if (vm._isVue && vm.$parent) {
+              const tree = [];
+              let currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      const last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                      .join('\n'));
+          }
+          else {
+              return `\n\n(found in ${formatComponentName(vm)})`;
+          }
+      };
   }
 
-  let uid$2 = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid$2++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$2(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          if (!config.async) {
-              // subs aren't sorted in scheduler if not running async
-              // we need to sort them now to make sure they fire in correct
-              // order
-              subs.sort((a, b) => a.id - b.id);
-          }
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
+  let uid$2 = 0;
+  /**
+   * A dep is an observable that can have multiple
+   * directives subscribing to it.
+   */
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid$2++;
+          this.subs = [];
+      }
+      addSub(sub) {
+          this.subs.push(sub);
+      }
+      removeSub(sub) {
+          remove$2(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          if (!config.async) {
+              // subs aren't sorted in scheduler if not running async
+              // we need to sort them now to make sure they fire in correct
+              // order
+              subs.sort((a, b) => a.id - b.id);
+          }
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
+  // The current target watcher being evaluated.
+  // This is globally unique because only one watcher
+  // can be evaluated at a time.
+  Dep.target = null;
+  const targetStack = [];
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
+  }
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
   }
 
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
+  };
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
+  }
+  // optimized shallow clone
+  // used for static nodes and slot nodes because they may be reused across
+  // multiple renders, cloning them avoids errors when DOM manipulations rely
+  // on their elm reference.
+  function cloneVNode(vnode) {
+      const cloned = new VNode(vnode.tag, vnode.data, 
+      // #7975
+      // clone children array to avoid mutating original in case of cloning
+      // a child.
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
   }
 
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
+  /*
+   * not type checking this file because flow doesn't play well with
+   * dynamically accessing methods on Array prototype
+   */
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse',
+  ];
+  /**
+   * Intercept mutating methods and emit events
+   */
+  methodsToPatch.forEach(function (method) {
+      // cache original method
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              ob.observeArray(inserted);
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Delete a property and trigger change if necessary.
-   */
-  function del(target, key) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.splice(key, 1);
-          return;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                  '- just set it to null.');
-          return;
-      }
-      if (!hasOwn(target, key)) {
-          return;
-      }
-      delete target[key];
-      if (!ob) {
-          return;
-      }
-      ob.dep.notify();
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+  /**
+   * In some cases we may want to disable observation inside a component's
+   * update computation.
+   */
+  let shouldObserve = true;
+  function toggleObserving(value) {
+      shouldObserve = value;
+  }
+  /**
+   * Observer class that is attached to each observed
+   * object. Once attached, the observer converts the target
+   * object's property keys into getter/setters that
+   * collect dependencies and dispatch updates.
+   */
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
+          }
+          else {
+              this.walk(value);
+          }
+      }
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      }
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      }
+  }
+  // helpers
+  /**
+   * Augment a target Object or Array by intercepting
+   * the prototype chain using __proto__
+   */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
+  }
+  /**
+   * Augment a target Object or Array by defining
+   * hidden properties.
+   */
+  /* istanbul ignore next */
+  function copyAugment(target, src, keys) {
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
+          def(target, key, src[key]);
+      }
+  }
+  /**
+   * Attempt to create an observer instance for a value,
+   * returns the new observer if successfully observed,
+   * or the existing observer if the value already has one.
+   */
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      let ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
+  }
+  /**
+   * Define a reactive property on an Object.
+   */
+  function defineReactive(obj, key, val, customSetter, shallow) {
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      const getter = property && property.get;
+      const setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      let childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              const value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              const value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  return;
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
+  }
+  /**
+   * Set a property on an object. Adds the new property and
+   * triggers change notification if the property doesn't
+   * already exist.
+   */
+  function set(target, key, val) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive(ob.value, key, val);
+      ob.dep.notify();
+      return val;
+  }
+  /**
+   * Delete a property and trigger change if necessary.
+   */
+  function del(target, key) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.splice(key, 1);
+          return;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
+                  '- just set it to null.');
+          return;
+      }
+      if (!hasOwn(target, key)) {
+          return;
+      }
+      delete target[key];
+      if (!ob) {
+          return;
+      }
+      ob.dep.notify();
+  }
+  /**
+   * Collect dependencies on array elements when the array is touched, since
+   * we cannot intercept array element access like property getters.
+   */
+  function dependArray(value) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
+      }
   }
 
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn$2(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn$2('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
-  });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn$2('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn$2('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn$2('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives$1(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn$2(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives$1(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
+  /**
+   * Option overwriting strategies are functions that handle
+   * how to merge a parent option value and a child option
+   * value into the final value.
+   */
+  const strats = config.optionMergeStrategies;
+  /**
+   * Options with restrictions
+   */
+  {
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn$2(`option "${key}" can only be used during instance ` +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
+  }
+  /**
+   * Helper that recursively merges two data objects together.
+   */
+  function mergeData(to, from) {
+      if (!from)
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (let i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              continue;
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
+  }
+  /**
+   * Data
+   */
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn$2('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
+  };
+  /**
+   * Hooks and props are merged as arrays.
+   */
+  function mergeHook$1(parentVal, childVal) {
+      const res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
+  }
+  LIFECYCLE_HOOKS.forEach((hook) => {
+      strats[hook] = mergeHook$1;
+  });
+  /**
+   * Assets
+   *
+   * When a vm is present (instance creation), we need to do
+   * a three-way merge between constructor options, instance
+   * options and parent options.
+   */
+  function mergeAssets(parentVal, childVal, vm, key) {
+      const res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
+  }
+  ASSET_TYPES.forEach(function (type) {
+      strats[type + 's'] = mergeAssets;
+  });
+  /**
+   * Watchers.
+   *
+   * Watchers hashes should not overwrite one
+   * another, so we merge them as arrays.
+   */
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          parentVal = undefined;
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          childVal = undefined;
+      /* istanbul ignore if */
+      if (!childVal)
+          return Object.create(parentVal || null);
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = {};
+      extend(ret, parentVal);
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
+  };
+  /**
+   * Other object hashes.
+   */
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          extend(ret, childVal);
+      return ret;
+  };
+  strats.provide = mergeDataOrFn;
+  /**
+   * Default strategy.
+   */
+  const defaultStrat = function (parentVal, childVal) {
+      return childVal === undefined ? parentVal : childVal;
+  };
+  /**
+   * Validate component names
+   */
+  function checkComponents(options) {
+      for (const key in options.components) {
+          validateComponentName(key);
+      }
+  }
+  function validateComponentName(name) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+          warn$2('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn$2('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
+  }
+  /**
+   * Ensure all props option syntax are normalized into the
+   * Object-based format.
+   */
+  function normalizeProps(options, vm) {
+      const props = options.props;
+      if (!props)
+          return;
+      const res = {};
+      let i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn$2('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (const key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
+      }
+      options.props = res;
+  }
+  /**
+   * Normalize all injections into Object-based format
+   */
+  function normalizeInject(options, vm) {
+      const inject = options.inject;
+      if (!inject)
+          return;
+      const normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (let i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (const key in inject) {
+              const val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
+      }
+  }
+  /**
+   * Normalize raw function directives into object format.
+   */
+  function normalizeDirectives$1(options) {
+      const dirs = options.directives;
+      if (dirs) {
+          for (const key in dirs) {
+              const def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn$2(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
+      }
+  }
+  /**
+   * Merge two option objects into a new one.
+   * Core utility used in both instantiation and inheritance.
+   */
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives$1(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      const options = {};
+      let key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          const strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
+  }
+  /**
+   * Resolve an asset.
+   * This function is used because child instances need access
+   * to assets defined in its ancestor chain.
+   */
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      const assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          return assets[id];
+      const camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          return assets[PascalCaseId];
+      // fallback to prototype chain
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
   }
 
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn$2('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn$2('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
+  function validateProp(key, propOptions, propsData, vm) {
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
+      // boolean casting
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              const stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          const prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
+  }
+  /**
+   * Get the default value of a prop.
+   */
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      const def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn$2('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
+  }
+  /**
+   * Assert whether a prop is valid.
+   */
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn$2('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      const haveExpectedTypes = expectedTypes.some((t) => t);
+      if (!valid && haveExpectedTypes) {
+          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      const validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
+  }
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      let valid;
+      const expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          const t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid,
+          expectedType,
+      };
+  }
+  const functionTypeCheckRE = /^\s*function (\w+)/;
+  /**
+   * Use function string name to check built-in types,
+   * because a simple equality check will fail when running
+   * across different vms / iframes.
+   */
+  function getType(fn) {
+      const match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
+          }
+      }
+      return -1;
+  }
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += ` with value ${styleValue(value, expectedType)}`;
+      }
+      message += `, got ${receivedType} `;
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += `with value ${styleValue(value, receivedType)}.`;
+      }
+      return message;
+  }
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return `"${value}"`;
+      }
+      else if (type === 'Number') {
+          return `${Number(value)}`;
+      }
+      else {
+          return `${value}`;
+      }
+  }
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
   }
 
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          // @ts-expect-error should it be any?
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      if (config.errorHandler) {
-          try {
-              return config.errorHandler.call(null, err, vm, info);
-          }
-          catch (e) {
-              // if the user intentionally throws the original error in the handler,
-              // do not log it twice
-              if (e !== err) {
-                  logError(e, null, 'config.errorHandler');
-              }
-          }
-      }
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              let cur = vm;
+              while ((cur = cur.$parent)) {
+                  const hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (let i = 0; i < hooks.length; i++) {
+                          try {
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  return;
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      let res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      if (config.errorHandler) {
+          try {
+              return config.errorHandler.call(null, err, vm, info);
+          }
+          catch (e) {
+              // if the user intentionally throws the original error in the handler,
+              // do not log it twice
+              if (e !== err) {
+                  logError(e, null, 'config.errorHandler');
+              }
+          }
+      }
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
   }
 
-  /* globals MutationObserver */
-  let isUsingMicroTask = false;
-  const callbacks = [];
-  let pending = false;
-  function flushCallbacks() {
-      pending = false;
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // Here we have async deferring wrappers using microtasks.
-  // In 2.5 we used (macro) tasks (in combination with microtasks).
-  // However, it has subtle problems when state is changed right before repaint
-  // (e.g. #6813, out-in transitions).
-  // Also, using (macro) tasks in event handler would cause some weird behaviors
-  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-  // So we now use microtasks everywhere, again.
-  // A major drawback of this tradeoff is that there are some scenarios
-  // where microtasks have too high a priority and fire in between supposedly
-  // sequential events (e.g. #4521, #6690, which have workarounds)
-  // or even between bubbling of the same event (#6566).
-  let timerFunc;
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      const p = Promise.resolve();
-      timerFunc = () => {
-          p.then(flushCallbacks);
-          // In problematic UIWebViews, Promise.then doesn't completely break, but
-          // it can get stuck in a weird state where callbacks are pushed into the
-          // microtask queue but the queue isn't being flushed, until the browser
-          // needs to do some other work, e.g. handle a timer. Therefore we can
-          // "force" the microtask queue to be flushed by adding an empty timer.
-          if (isIOS)
-              setTimeout(noop);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-      timerFunc = () => {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-      // Fallback to setImmediate.
-      // Technically it leverages the (macro) task queue,
-      // but it is still a better choice than setTimeout.
-      timerFunc = () => {
-          setImmediate(flushCallbacks);
-      };
-  }
-  else {
-      // Fallback to setTimeout.
-      timerFunc = () => {
-          setTimeout(flushCallbacks, 0);
-      };
-  }
-  function nextTick(cb, ctx) {
-      let _resolve;
-      callbacks.push(() => {
-          if (cb) {
-              try {
-                  cb.call(ctx);
-              }
-              catch (e) {
-                  // @ts-expect-error should it be any?
-                  handleError(e, ctx, 'nextTick');
-              }
-          }
-          else if (_resolve) {
-              _resolve(ctx);
-          }
-      });
-      if (!pending) {
-          pending = true;
-          timerFunc();
-      }
-      // $flow-disable-line
-      if (!cb && typeof Promise !== 'undefined') {
-          return new Promise((resolve) => {
-              _resolve = resolve;
-          });
-      }
+  /* globals MutationObserver */
+  let isUsingMicroTask = false;
+  const callbacks = [];
+  let pending = false;
+  function flushCallbacks() {
+      pending = false;
+      const copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (let i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
+  }
+  // Here we have async deferring wrappers using microtasks.
+  // In 2.5 we used (macro) tasks (in combination with microtasks).
+  // However, it has subtle problems when state is changed right before repaint
+  // (e.g. #6813, out-in transitions).
+  // Also, using (macro) tasks in event handler would cause some weird behaviors
+  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+  // So we now use microtasks everywhere, again.
+  // A major drawback of this tradeoff is that there are some scenarios
+  // where microtasks have too high a priority and fire in between supposedly
+  // sequential events (e.g. #4521, #6690, which have workarounds)
+  // or even between bubbling of the same event (#6566).
+  let timerFunc;
+  // The nextTick behavior leverages the microtask queue, which can be accessed
+  // via either native Promise.then or MutationObserver.
+  // MutationObserver has wider support, however it is seriously bugged in
+  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+  // completely stops working after triggering a few times... so, if native
+  // Promise is available, we will use it:
+  /* istanbul ignore next, $flow-disable-line */
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+      const p = Promise.resolve();
+      timerFunc = () => {
+          p.then(flushCallbacks);
+          // In problematic UIWebViews, Promise.then doesn't completely break, but
+          // it can get stuck in a weird state where callbacks are pushed into the
+          // microtask queue but the queue isn't being flushed, until the browser
+          // needs to do some other work, e.g. handle a timer. Therefore we can
+          // "force" the microtask queue to be flushed by adding an empty timer.
+          if (isIOS)
+              setTimeout(noop);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+      timerFunc = () => {
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+      // Fallback to setImmediate.
+      // Technically it leverages the (macro) task queue,
+      // but it is still a better choice than setTimeout.
+      timerFunc = () => {
+          setImmediate(flushCallbacks);
+      };
+  }
+  else {
+      // Fallback to setTimeout.
+      timerFunc = () => {
+          setTimeout(flushCallbacks, 0);
+      };
+  }
+  function nextTick(cb, ctx) {
+      let _resolve;
+      callbacks.push(() => {
+          if (cb) {
+              try {
+                  cb.call(ctx);
+              }
+              catch (e) {
+                  handleError(e, ctx, 'nextTick');
+              }
+          }
+          else if (_resolve) {
+              _resolve(ctx);
+          }
+      });
+      if (!pending) {
+          pending = true;
+          timerFunc();
+      }
+      // $flow-disable-line
+      if (!cb && typeof Promise !== 'undefined') {
+          return new Promise((resolve) => {
+              _resolve = resolve;
+          });
+      }
   }
 
-  let mark;
-  let measure;
-  {
-      const perf = inBrowser && window.performance;
-      /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = (tag) => perf.mark(tag);
-          measure = (name, startTag, endTag) => {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
-              // perf.clearMeasures(name)
-          };
-      }
+  let mark;
+  let measure;
+  {
+      const perf = inBrowser && window.performance;
+      /* istanbul ignore if */
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = (tag) => perf.mark(tag);
+          measure = (name, startTag, endTag) => {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+              // perf.clearMeasures(name)
+          };
+      }
   }
 
-  /* not type checking this file because flow doesn't play well with Proxy */
-  let initProxy;
-  {
-      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const warnNonPresent = (target, key) => {
-          warn$2(`Property or method "${key}" is not defined on the instance but ` +
-              'referenced during render. Make sure that this property is reactive, ' +
-              'either in the data option, or for class-based components, by ' +
-              'initializing the property. ' +
-              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-      };
-      const warnReservedPrefix = (target, key) => {
-          warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-              'prevent conflicts with Vue internals. ' +
-              'See: https://vuejs.org/v2/api/#data', target);
-      };
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-      const hasHandler = {
-          has(target, key) {
-              const has = key in target;
-              const isAllowed = allowedGlobals(key) ||
-                  (typeof key === 'string' &&
-                      key.charAt(0) === '_' &&
-                      !(key in target.$data));
-              if (!has && !isAllowed) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return has || !isAllowed;
-          },
-      };
-      const getHandler = {
-          get(target, key) {
-              if (typeof key === 'string' && !(key in target)) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return target[key];
-          },
-      };
-      initProxy = function initProxy(vm) {
-          if (hasProxy) {
-              // determine which proxy handler to use
-              const options = vm.$options;
-              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-              vm._renderProxy = new Proxy(vm, handlers);
-          }
-          else {
-              vm._renderProxy = vm;
-          }
-      };
+  /* not type checking this file because flow doesn't play well with Proxy */
+  let initProxy;
+  {
+      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
+      );
+      const warnNonPresent = (target, key) => {
+          warn$2(`Property or method "${key}" is not defined on the instance but ` +
+              'referenced during render. Make sure that this property is reactive, ' +
+              'either in the data option, or for class-based components, by ' +
+              'initializing the property. ' +
+              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+      };
+      const warnReservedPrefix = (target, key) => {
+          warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
+              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+              'prevent conflicts with Vue internals. ' +
+              'See: https://vuejs.org/v2/api/#data', target);
+      };
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
+      const hasHandler = {
+          has(target, key) {
+              const has = key in target;
+              const isAllowed = allowedGlobals(key) ||
+                  (typeof key === 'string' &&
+                      key.charAt(0) === '_' &&
+                      !(key in target.$data));
+              if (!has && !isAllowed) {
+                  if (key in target.$data)
+                      warnReservedPrefix(target, key);
+                  else
+                      warnNonPresent(target, key);
+              }
+              return has || !isAllowed;
+          },
+      };
+      const getHandler = {
+          get(target, key) {
+              if (typeof key === 'string' && !(key in target)) {
+                  if (key in target.$data)
+                      warnReservedPrefix(target, key);
+                  else
+                      warnNonPresent(target, key);
+              }
+              return target[key];
+          },
+      };
+      initProxy = function initProxy(vm) {
+          if (hasProxy) {
+              // determine which proxy handler to use
+              const options = vm.$options;
+              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              vm._renderProxy = new Proxy(vm, handlers);
+          }
+          else {
+              vm._renderProxy = vm;
+          }
+      };
   }
 
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
+  const seenObjects = new _Set();
+  /**
+   * Recursively traverse an object to evoke all converted
+   * getters, so that every nested property inside the object
+   * is collected as a "deep" dependency.
+   */
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      let i, keys;
+      const isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          const depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              _traverse(val[i], seen);
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              _traverse(val[keys[i]], seen);
+      }
   }
 
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
+      const capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name,
+          once,
+          capture,
+          passive,
+      };
+  });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          const fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      let name, cur, old, event;
+      for (name in on) {
+          cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove(event.name, oldOn[name], event.capture);
+          }
+      }
   }
 
-  function mergeVNodeHook(def, hookKey, hook) {
-      if (def instanceof VNode) {
-          def = def.data.hook || (def.data.hook = {});
-      }
-      let invoker;
-      const oldHook = def[hookKey];
-      function wrappedHook() {
-          hook.apply(this, arguments);
-          // important: remove merged hook to ensure it's called only once
-          // and prevent memory leak
-          remove$2(invoker.fns, wrappedHook);
-      }
-      if (isUndef(oldHook)) {
-          // no existing hook
-          invoker = createFnInvoker([wrappedHook]);
-      }
-      else {
-          /* istanbul ignore if */
-          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-              // already a merged invoker
-              invoker = oldHook;
-              invoker.fns.push(wrappedHook);
-          }
-          else {
-              // existing plain hook
-              invoker = createFnInvoker([oldHook, wrappedHook]);
-          }
-      }
-      invoker.merged = true;
-      def[hookKey] = invoker;
+  function mergeVNodeHook(def, hookKey, hook) {
+      if (def instanceof VNode) {
+          def = def.data.hook || (def.data.hook = {});
+      }
+      let invoker;
+      const oldHook = def[hookKey];
+      function wrappedHook() {
+          hook.apply(this, arguments);
+          // important: remove merged hook to ensure it's called only once
+          // and prevent memory leak
+          remove$2(invoker.fns, wrappedHook);
+      }
+      if (isUndef(oldHook)) {
+          // no existing hook
+          invoker = createFnInvoker([wrappedHook]);
+      }
+      else {
+          /* istanbul ignore if */
+          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+              // already a merged invoker
+              invoker = oldHook;
+              invoker.fns.push(wrappedHook);
+          }
+          else {
+              // existing plain hook
+              invoker = createFnInvoker([oldHook, wrappedHook]);
+          }
+      }
+      invoker.merged = true;
+      def[hookKey] = invoker;
   }
 
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      const propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      const res = {};
+      const { attrs, props } = data;
+      if (isDef(attrs) || isDef(props)) {
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
+              {
+                  const keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
   }
 
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
+  // The template compiler attempts to minimize the need for normalization by
+  // statically analyzing the template at compile time.
+  //
+  // For plain HTML markup, normalization can be completely skipped because the
+  // generated render function is guaranteed to return Array<VNode>. There are
+  // two cases where extra normalization is needed:
+  // 1. When the children contains components - because a functional component
+  // may return an Array instead of a single root. In this case, just a simple
+  // normalization is needed - if any child is an Array, we flatten the whole
+  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+  // because functional components already normalize their own children.
+  function simpleNormalizeChildren(children) {
+      for (let i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
+      }
+      return children;
+  }
+  // 2. When the children contains constructs that always generated nested Arrays,
+  // e.g. <template>, <slot>, v-for, or when the children is provided by user
+  // with hand-written render functions / JSX. In such cases a full normalization
+  // is needed to cater to all possible types of children values.
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      const res = [];
+      let i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              continue;
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = `__vlist${nestedIndex}_${i}__`;
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
   }
 
-  function initProvide(vm) {
-      const provide = vm.$options.provide;
-      if (provide) {
-          vm._provided =
-              typeof provide === 'function'
-                  ? // @ts-expect-error typing not correct
-                      provide.call(vm)
-                  : provide;
-      }
-  }
-  function initInjections(vm) {
-      const result = resolveInject(vm.$options.inject, vm);
-      if (result) {
-          toggleObserving(false);
-          Object.keys(result).forEach((key) => {
-              /* istanbul ignore else */
-              {
-                  defineReactive(vm, key, result[key], () => {
-                      warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                          `overwritten whenever the provided component re-renders. ` +
-                          `injection being mutated: "${key}"`, vm);
-                  });
-              }
-          });
-          toggleObserving(true);
-      }
-  }
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn$2(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
+  function initProvide(vm) {
+      const provide = vm.$options.provide;
+      if (provide) {
+          vm._provided =
+              typeof provide === 'function'
+                  ? // @ts-expect-error typing not correct
+                      provide.call(vm)
+                  : provide;
+      }
+  }
+  function initInjections(vm) {
+      const result = resolveInject(vm.$options.inject, vm);
+      if (result) {
+          toggleObserving(false);
+          Object.keys(result).forEach((key) => {
+              /* istanbul ignore else */
+              {
+                  defineReactive(vm, key, result[key], () => {
+                      warn$2(`Avoid mutating an injected value directly since the changes will be ` +
+                          `overwritten whenever the provided component re-renders. ` +
+                          `injection being mutated: "${key}"`, vm);
+                  });
+              }
+          });
+          toggleObserving(true);
+      }
+  }
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      const provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      warn$2(`Injection "${key}" not found`, vm);
+                  }
+              }
+          }
+          return result;
+      }
   }
 
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  /**
+   * Runtime helper for resolving raw children VNodes into a slot object.
+   */
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
   }
 
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
+      return res;
+  }
+  function normalizeScopedSlot(normalSlots, key, fn) {
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === "object" && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
+  }
+  function proxyNormalSlot(slots, key) {
+      return () => slots[key];
   }
 
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
+  /**
+   * Runtime helper for rendering v-for lists.
+   */
+  function renderList(val, render) {
+      let ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
   }
 
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn$2("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
+  /**
+   * Runtime helper for rendering <slot>
+   */
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn$2("slot v-bind without argument expects an Object", this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      else {
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      const target = props && props.slot;
+      if (target) {
+          return this.$createElement("template", { slot: target }, nodes);
+      }
+      else {
+          return nodes;
+      }
   }
 
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
+  /**
+   * Runtime helper for resolving filters
+   */
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
+  }
+  /**
+   * Runtime helper for checking keyCodes from config.
+   * exposed as Vue.prototype._k
+   * passing in eventKeyName as last argument separately for backwards compat
+   */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+      return eventKeyCode === undefined;
   }
 
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn$2('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
+  /**
+   * Runtime helper for merging v-bind="object" into a VNode's data.
+   */
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn$2('v-bind without argument expects an Object or Array value', this);
+          }
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              let hash;
+              for (const key in value) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      const type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              }
+          }
+      }
+      return data;
   }
 
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic$1(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic$1(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
+  /**
+   * Runtime helper for rendering static trees.
+   */
+  function renderStatic(index, isInFor) {
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic$1(tree, `__static__${index}`, false);
+      return tree;
+  }
+  /**
+   * Runtime helper for v-once.
+   * Effectively it means marking the node as static with a unique key.
+   */
+  function markOnce(tree, index, key) {
+      markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+      return tree;
+  }
+  function markStatic$1(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (let i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn$2('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn$2('v-on without argument expects an Object value', this);
+          }
+          else {
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
+      }
+      return data;
   }
 
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+  function bindDynamicKeys(baseObj, values) {
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+          }
+      }
+      return baseObj;
+  }
+  // helper to dynamically append modifier runtime markers to event names.
+  // ensure only append when value is already string, otherwise it will be cast
+  // to string and cause the type check to miss.
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
   }
 
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
   }
 
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      const options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      let contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+          }
+          return this.$slots;
+      };
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = (a, b, c, d) => {
+              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+      }
+  }
+  installRenderHelpers(FunctionalRenderContext.prototype);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (const key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              mergeProps(props, data.attrs);
+          if (isDef(data.props))
+              mergeProps(props, data.props);
+      }
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      const clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (const key in from) {
+          to[camelize(key)] = from[key];
+      }
   }
 
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook$1(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
+  // inline hooks to be invoked on component VNodes during patch
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              const mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook$1(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy(vnode) {
+          const { componentInstance } = vnode;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+  };
+  const hooksToMerge = Object.keys(componentVNodeHooks);
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      const baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+          }
+          return;
+      }
+      // async component
+      let asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      const listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          const slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
+      // @ts-expect-error
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      const options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent,
+      };
+      // check inline-template render functions
+      const inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook(f1, f2) {
+      const merged = (a, b) => {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
+  }
+  // transform component v-model info (value and callback) into
+  // prop and event handler respectively.
+  function transformModel(options, data) {
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
   }
 
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn$2('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if (config.isReservedTag(tag)) {
-              // platform built-in elements
-              if (isDef(data) &&
-                  isDef(data.nativeOn) &&
-                  data.tag !== 'component') {
-                  warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-              }
-              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-          }
-          else if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
+  // wrapper function for providing a more flexible interface
+  // without getting yelled at by flow
+  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn$2('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      let vnode, ns;
+      if (typeof tag === 'string') {
+          let Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if (config.isReservedTag(tag)) {
+              // platform built-in elements
+              if (isDef(data) &&
+                  isDef(data.nativeOn) &&
+                  data.tag !== 'component') {
+                  warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+              }
+              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+          }
+          else if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              applyNS(vnode, ns);
+          if (isDef(data))
+              registerDeepBindings(data);
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
+  }
+  // ref #5318
+  // necessary to ensure parent re-render when deep bindings like :style and
+  // :class are used on slot nodes
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
   }
 
-  function initRender(vm) {
-      vm._vnode = null; // the root of the child tree
-      vm._staticTrees = null; // v-once cached trees
-      const options = vm.$options;
-      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      const renderContext = parentVnode && parentVnode.context;
-      vm.$slots = resolveSlots(options._renderChildren, renderContext);
-      vm.$scopedSlots = emptyObject;
-      // bind the createElement fn to this instance
-      // so that we get proper render context inside it.
-      // args order: tag, data, children, normalizationType, alwaysNormalize
-      // internal version is used by render functions compiled from templates
-      // @ts-expect-error
-      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-      // normalization is always applied for the public version, used in
-      // user-written render functions.
-      // @ts-expect-error
-      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-      // $attrs & $listeners are exposed for easier HOC creation.
-      // they need to be reactive so that HOCs using them are always updated
-      const parentData = parentVnode && parentVnode.data;
-      /* istanbul ignore else */
-      {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-              !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-          }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-              !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-          }, true);
-      }
-  }
-  let currentRenderingInstance = null;
-  function renderMixin(Vue) {
-      // install runtime convenience helpers
-      installRenderHelpers(Vue.prototype);
-      Vue.prototype.$nextTick = function (fn) {
-          return nextTick(fn, this);
-      };
-      Vue.prototype._render = function () {
-          const vm = this;
-          const { render, _parentVnode } = vm.$options;
-          if (_parentVnode) {
-              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-          }
-          // set parent vnode. this allows render functions to have access
-          // to the data on the placeholder node.
-          vm.$vnode = _parentVnode;
-          // render self
-          let vnode;
-          try {
-              // There's no need to maintain a stack because all render fns are called
-              // separately from one another. Nested component's render fns are called
-              // when parent component is patched.
-              currentRenderingInstance = vm;
-              vnode = render.call(vm._renderProxy, vm.$createElement);
-          }
-          catch (e) {
-              handleError(e, vm, `render`);
-              // return error render result,
-              // or previous vnode to prevent render error causing blank component
-              /* istanbul ignore else */
-              if (vm.$options.renderError) {
-                  try {
-                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                  }
-                  catch (e) {
-                      handleError(e, vm, `renderError`);
-                      vnode = vm._vnode;
-                  }
-              }
-              else {
-                  vnode = vm._vnode;
-              }
-          }
-          finally {
-              currentRenderingInstance = null;
-          }
-          // if the returned array contains only a single node, allow it
-          if (Array.isArray(vnode) && vnode.length === 1) {
-              vnode = vnode[0];
-          }
-          // return empty vnode in case the render function errored out
-          if (!(vnode instanceof VNode)) {
-              if (Array.isArray(vnode)) {
-                  warn$2('Multiple root nodes returned from render function. Render function ' +
-                      'should return a single root node.', vm);
-              }
-              vnode = createEmptyVNode();
-          }
-          // set parent
-          vnode.parent = _parentVnode;
-          return vnode;
-      };
+  function initRender(vm) {
+      vm._vnode = null; // the root of the child tree
+      vm._staticTrees = null; // v-once cached trees
+      const options = vm.$options;
+      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      const renderContext = parentVnode && parentVnode.context;
+      vm.$slots = resolveSlots(options._renderChildren, renderContext);
+      vm.$scopedSlots = emptyObject;
+      // bind the createElement fn to this instance
+      // so that we get proper render context inside it.
+      // args order: tag, data, children, normalizationType, alwaysNormalize
+      // internal version is used by render functions compiled from templates
+      // @ts-expect-error
+      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+      // normalization is always applied for the public version, used in
+      // user-written render functions.
+      // @ts-expect-error
+      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+      // $attrs & $listeners are exposed for easier HOC creation.
+      // they need to be reactive so that HOCs using them are always updated
+      const parentData = parentVnode && parentVnode.data;
+      /* istanbul ignore else */
+      {
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+              !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
+          }, true);
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+              !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
+          }, true);
+      }
+  }
+  let currentRenderingInstance = null;
+  function renderMixin(Vue) {
+      // install runtime convenience helpers
+      installRenderHelpers(Vue.prototype);
+      Vue.prototype.$nextTick = function (fn) {
+          return nextTick(fn, this);
+      };
+      Vue.prototype._render = function () {
+          const vm = this;
+          const { render, _parentVnode } = vm.$options;
+          if (_parentVnode) {
+              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+          }
+          // set parent vnode. this allows render functions to have access
+          // to the data on the placeholder node.
+          vm.$vnode = _parentVnode;
+          // render self
+          let vnode;
+          try {
+              // There's no need to maintain a stack because all render fns are called
+              // separately from one another. Nested component's render fns are called
+              // when parent component is patched.
+              currentRenderingInstance = vm;
+              vnode = render.call(vm._renderProxy, vm.$createElement);
+          }
+          catch (e) {
+              handleError(e, vm, `render`);
+              // return error render result,
+              // or previous vnode to prevent render error causing blank component
+              /* istanbul ignore else */
+              if (vm.$options.renderError) {
+                  try {
+                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                  }
+                  catch (e) {
+                      handleError(e, vm, `renderError`);
+                      vnode = vm._vnode;
+                  }
+              }
+              else {
+                  vnode = vm._vnode;
+              }
+          }
+          finally {
+              currentRenderingInstance = null;
+          }
+          // if the returned array contains only a single node, allow it
+          if (Array.isArray(vnode) && vnode.length === 1) {
+              vnode = vnode[0];
+          }
+          // return empty vnode in case the render function errored out
+          if (!(vnode instanceof VNode)) {
+              if (Array.isArray(vnode)) {
+                  warn$2('Multiple root nodes returned from render function. Render function ' +
+                      'should return a single root node.', vm);
+              }
+              vnode = createEmptyVNode();
+          }
+          // set parent
+          vnode.parent = _parentVnode;
+          return vnode;
+      };
   }
 
-  function ensureCtor(comp, base) {
-      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-          comp = comp.default;
-      }
-      return isObject(comp) ? base.extend(comp) : comp;
-  }
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      const owner = currentRenderingInstance;
-      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-          // already pending
-          factory.owners.push(owner);
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-      if (owner && !isDef(factory.owners)) {
-          const owners = (factory.owners = [owner]);
-          let sync = true;
-          let timerLoading = null;
-          let timerTimeout = null;
-          owner.$on('hook:destroyed', () => remove$2(owners, owner));
-          const forceRender = (renderCompleted) => {
-              for (let i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
-              }
-              if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
-                  }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
-                  }
-              }
-          };
-          const resolve = once((res) => {
-              // cache resolved
-              factory.resolved = ensureCtor(res, baseCtor);
-              // invoke callbacks only if this is not a synchronous resolve
-              // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
-              }
-              else {
-                  owners.length = 0;
-              }
-          });
-          const reject = once((reason) => {
-              warn$2(`Failed to resolve async component: ${String(factory)}` +
-                      (reason ? `\nReason: ${reason}` : ''));
-              if (isDef(factory.errorComp)) {
-                  factory.error = true;
-                  forceRender(true);
-              }
-          });
-          const res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
-                  // () => Promise
-                  if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
-                  }
-              }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
-                  }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
-                          factory.loading = true;
-                      }
-                      else {
-                          // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(() => {
-                              timerLoading = null;
-                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                  factory.loading = true;
-                                  forceRender(false);
-                              }
-                          }, res.delay || 200);
-                      }
-                  }
-                  if (isDef(res.timeout)) {
-                      // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(() => {
-                          timerTimeout = null;
-                          if (isUndef(factory.resolved)) {
-                              reject(`timeout (${res.timeout}ms)`
-                                  );
-                          }
-                      }, res.timeout);
-                  }
-              }
-          }
-          sync = false;
-          // return in case resolved synchronously
-          return factory.loading ? factory.loadingComp : factory.resolved;
-      }
+  function ensureCtor(comp, base) {
+      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+          comp = comp.default;
+      }
+      return isObject(comp) ? base.extend(comp) : comp;
+  }
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      const node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data, context, children, tag };
+      return node;
+  }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      const owner = currentRenderingInstance;
+      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+          // already pending
+          factory.owners.push(owner);
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+      if (owner && !isDef(factory.owners)) {
+          const owners = (factory.owners = [owner]);
+          let sync = true;
+          let timerLoading = null;
+          let timerTimeout = null;
+          owner.$on('hook:destroyed', () => remove$2(owners, owner));
+          const forceRender = (renderCompleted) => {
+              for (let i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
+              }
+              if (renderCompleted) {
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
+                  }
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
+                  }
+              }
+          };
+          const resolve = once((res) => {
+              // cache resolved
+              factory.resolved = ensureCtor(res, baseCtor);
+              // invoke callbacks only if this is not a synchronous resolve
+              // (async resolves are shimmed as synchronous during SSR)
+              if (!sync) {
+                  forceRender(true);
+              }
+              else {
+                  owners.length = 0;
+              }
+          });
+          const reject = once((reason) => {
+              warn$2(`Failed to resolve async component: ${String(factory)}` +
+                      (reason ? `\nReason: ${reason}` : ''));
+              if (isDef(factory.errorComp)) {
+                  factory.error = true;
+                  forceRender(true);
+              }
+          });
+          const res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
+                  // () => Promise
+                  if (isUndef(factory.resolved)) {
+                      res.then(resolve, reject);
+                  }
+              }
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
+                  }
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
+                          factory.loading = true;
+                      }
+                      else {
+                          // @ts-expect-error NodeJS timeout type
+                          timerLoading = setTimeout(() => {
+                              timerLoading = null;
+                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                  factory.loading = true;
+                                  forceRender(false);
+                              }
+                          }, res.delay || 200);
+                      }
+                  }
+                  if (isDef(res.timeout)) {
+                      // @ts-expect-error NodeJS timeout type
+                      timerTimeout = setTimeout(() => {
+                          timerTimeout = null;
+                          if (isUndef(factory.resolved)) {
+                              reject(`timeout (${res.timeout}ms)`
+                                  );
+                          }
+                      }, res.timeout);
+                  }
+              }
+          }
+          sync = false;
+          // return in case resolved synchronously
+          return factory.loading ? factory.loadingComp : factory.resolved;
+      }
   }
 
-  function getFirstComponentChild(children) {
-      if (Array.isArray(children)) {
-          for (let i = 0; i < children.length; i++) {
-              const c = children[i];
-              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                  return c;
-              }
-          }
-      }
+  function getFirstComponentChild(children) {
+      if (Array.isArray(children)) {
+          for (let i = 0; i < children.length; i++) {
+              const c = children[i];
+              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                  return c;
+              }
+          }
+      }
   }
 
-  function initEvents(vm) {
-      vm._events = Object.create(null);
-      vm._hasHookEvent = false;
-      // init parent attached events
-      const listeners = vm.$options._parentListeners;
-      if (listeners) {
-          updateComponentListeners(vm, listeners);
-      }
-  }
-  let target$1;
-  function add$1(event, fn) {
-      target$1.$on(event, fn);
-  }
-  function remove$1(event, fn) {
-      target$1.$off(event, fn);
-  }
-  function createOnceHandler$1(event, fn) {
-      const _target = target$1;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target$1 = vm;
-      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-      target$1 = undefined;
-  }
-  function eventsMixin(Vue) {
-      const hookRE = /^hook:/;
-      Vue.prototype.$on = function (event, fn) {
-          const vm = this;
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$on(event[i], fn);
-              }
-          }
-          else {
-              (vm._events[event] || (vm._events[event] = [])).push(fn);
-              // optimize hook:event cost by using a boolean flag marked at registration
-              // instead of a hash lookup
-              if (hookRE.test(event)) {
-                  vm._hasHookEvent = true;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$once = function (event, fn) {
-          const vm = this;
-          function on() {
-              vm.$off(event, on);
-              fn.apply(vm, arguments);
-          }
-          on.fn = fn;
-          vm.$on(event, on);
-          return vm;
-      };
-      Vue.prototype.$off = function (event, fn) {
-          const vm = this;
-          // all
-          if (!arguments.length) {
-              vm._events = Object.create(null);
-              return vm;
-          }
-          // array of events
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$off(event[i], fn);
-              }
-              return vm;
-          }
-          // specific event
-          const cbs = vm._events[event];
-          if (!cbs) {
-              return vm;
-          }
-          if (!fn) {
-              vm._events[event] = null;
-              return vm;
-          }
-          // specific handler
-          let cb;
-          let i = cbs.length;
-          while (i--) {
-              cb = cbs[i];
-              if (cb === fn || cb.fn === fn) {
-                  cbs.splice(i, 1);
-                  break;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$emit = function (event) {
-          const vm = this;
-          {
-              const lowerCaseEvent = event.toLowerCase();
-              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                      `Note that HTML attributes are case-insensitive and you cannot use ` +
-                      `v-on to listen to camelCase events when using in-DOM templates. ` +
-                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-              }
-          }
-          let cbs = vm._events[event];
-          if (cbs) {
-              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              const args = toArray(arguments, 1);
-              const info = `event handler for "${event}"`;
-              for (let i = 0, l = cbs.length; i < l; i++) {
-                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-              }
-          }
-          return vm;
-      };
+  function initEvents(vm) {
+      vm._events = Object.create(null);
+      vm._hasHookEvent = false;
+      // init parent attached events
+      const listeners = vm.$options._parentListeners;
+      if (listeners) {
+          updateComponentListeners(vm, listeners);
+      }
+  }
+  let target$1;
+  function add$1(event, fn) {
+      target$1.$on(event, fn);
+  }
+  function remove$1(event, fn) {
+      target$1.$off(event, fn);
+  }
+  function createOnceHandler$1(event, fn) {
+      const _target = target$1;
+      return function onceHandler() {
+          const res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
+  }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target$1 = vm;
+      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+      target$1 = undefined;
+  }
+  function eventsMixin(Vue) {
+      const hookRE = /^hook:/;
+      Vue.prototype.$on = function (event, fn) {
+          const vm = this;
+          if (Array.isArray(event)) {
+              for (let i = 0, l = event.length; i < l; i++) {
+                  vm.$on(event[i], fn);
+              }
+          }
+          else {
+              (vm._events[event] || (vm._events[event] = [])).push(fn);
+              // optimize hook:event cost by using a boolean flag marked at registration
+              // instead of a hash lookup
+              if (hookRE.test(event)) {
+                  vm._hasHookEvent = true;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$once = function (event, fn) {
+          const vm = this;
+          function on() {
+              vm.$off(event, on);
+              fn.apply(vm, arguments);
+          }
+          on.fn = fn;
+          vm.$on(event, on);
+          return vm;
+      };
+      Vue.prototype.$off = function (event, fn) {
+          const vm = this;
+          // all
+          if (!arguments.length) {
+              vm._events = Object.create(null);
+              return vm;
+          }
+          // array of events
+          if (Array.isArray(event)) {
+              for (let i = 0, l = event.length; i < l; i++) {
+                  vm.$off(event[i], fn);
+              }
+              return vm;
+          }
+          // specific event
+          const cbs = vm._events[event];
+          if (!cbs) {
+              return vm;
+          }
+          if (!fn) {
+              vm._events[event] = null;
+              return vm;
+          }
+          // specific handler
+          let cb;
+          let i = cbs.length;
+          while (i--) {
+              cb = cbs[i];
+              if (cb === fn || cb.fn === fn) {
+                  cbs.splice(i, 1);
+                  break;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$emit = function (event) {
+          const vm = this;
+          {
+              const lowerCaseEvent = event.toLowerCase();
+              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                      `Note that HTML attributes are case-insensitive and you cannot use ` +
+                      `v-on to listen to camelCase events when using in-DOM templates. ` +
+                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+              }
+          }
+          let cbs = vm._events[event];
+          if (cbs) {
+              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+              const args = toArray(arguments, 1);
+              const info = `event handler for "${event}"`;
+              for (let i = 0, l = cbs.length; i < l; i++) {
+                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+              }
+          }
+          return vm;
+      };
   }
 
-  let activeInstance = null;
-  let isUpdatingChildComponent = false;
-  function setActiveInstance(vm) {
-      const prevActiveInstance = activeInstance;
-      activeInstance = vm;
-      return () => {
-          activeInstance = prevActiveInstance;
-      };
-  }
-  function initLifecycle(vm) {
-      const options = vm.$options;
-      // locate first non-abstract parent
-      let parent = options.parent;
-      if (parent && !options.abstract) {
-          while (parent.$options.abstract && parent.$parent) {
-              parent = parent.$parent;
-          }
-          parent.$children.push(vm);
-      }
-      vm.$parent = parent;
-      vm.$root = parent ? parent.$root : vm;
-      vm.$children = [];
-      vm.$refs = {};
-      vm._watcher = null;
-      vm._inactive = null;
-      vm._directInactive = false;
-      vm._isMounted = false;
-      vm._isDestroyed = false;
-      vm._isBeingDestroyed = false;
-  }
-  function lifecycleMixin(Vue) {
-      Vue.prototype._update = function (vnode, hydrating) {
-          const vm = this;
-          const prevEl = vm.$el;
-          const prevVnode = vm._vnode;
-          const restoreActiveInstance = setActiveInstance(vm);
-          vm._vnode = vnode;
-          // Vue.prototype.__patch__ is injected in entry points
-          // based on the rendering backend used.
-          if (!prevVnode) {
-              // initial render
-              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-          }
-          else {
-              // updates
-              vm.$el = vm.__patch__(prevVnode, vnode);
-          }
-          restoreActiveInstance();
-          // update __vue__ reference
-          if (prevEl) {
-              prevEl.__vue__ = null;
-          }
-          if (vm.$el) {
-              vm.$el.__vue__ = vm;
-          }
-          // if parent is an HOC, update its $el as well
-          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-              vm.$parent.$el = vm.$el;
-          }
-          // updated hook is called by the scheduler to ensure that children are
-          // updated in a parent's updated hook.
-      };
-      Vue.prototype.$forceUpdate = function () {
-          const vm = this;
-          if (vm._watcher) {
-              vm._watcher.update();
-          }
-      };
-      Vue.prototype.$destroy = function () {
-          const vm = this;
-          if (vm._isBeingDestroyed) {
-              return;
-          }
-          callHook$1(vm, "beforeDestroy");
-          vm._isBeingDestroyed = true;
-          // remove self from parent
-          const parent = vm.$parent;
-          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove$2(parent.$children, vm);
-          }
-          // teardown watchers
-          if (vm._watcher) {
-              vm._watcher.teardown();
-          }
-          let i = vm._watchers.length;
-          while (i--) {
-              vm._watchers[i].teardown();
-          }
-          // remove reference from data ob
-          // frozen object may not have observer.
-          if (vm._data.__ob__) {
-              vm._data.__ob__.vmCount--;
-          }
-          // call the last hook...
-          vm._isDestroyed = true;
-          // invoke destroy hooks on current rendered tree
-          vm.__patch__(vm._vnode, null);
-          // fire destroyed hook
-          callHook$1(vm, "destroyed");
-          // turn off all instance listeners.
-          vm.$off();
-          // remove __vue__ reference
-          if (vm.$el) {
-              vm.$el.__vue__ = null;
-          }
-          // release circular reference (#6759)
-          if (vm.$vnode) {
-              vm.$vnode.parent = null;
-          }
-      };
-  }
-  function mountComponent(vm, el, hydrating) {
-      vm.$el = el;
-      if (!vm.$options.render) {
-          // @ts-expect-error invalid type
-          vm.$options.render = createEmptyVNode;
-          {
-              /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                  vm.$options.el ||
-                  el) {
-                  warn$2("You are using the runtime-only build of Vue where the template " +
-                      "compiler is not available. Either pre-compile the templates into " +
-                      "render functions, or use the compiler-included build.", vm);
-              }
-              else {
-                  warn$2("Failed to mount component: template or render function not defined.", vm);
-              }
-          }
-      }
-      callHook$1(vm, "beforeMount");
-      let updateComponent;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-          updateComponent = () => {
-              const name = vm._name;
-              const id = vm._uid;
-              const startTag = `vue-perf-start:${id}`;
-              const endTag = `vue-perf-end:${id}`;
-              mark(startTag);
-              const vnode = vm._render();
-              mark(endTag);
-              measure(`vue ${name} render`, startTag, endTag);
-              mark(startTag);
-              vm._update(vnode, hydrating);
-              mark(endTag);
-              measure(`vue ${name} patch`, startTag, endTag);
-          };
-      }
-      else {
-          updateComponent = () => {
-              vm._update(vm._render(), hydrating);
-          };
-      }
-      // we set this to vm._watcher inside the watcher's constructor
-      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-      // component's mounted hook), which relies on vm._watcher being already defined
-      new Watcher(vm, updateComponent, noop, {
-          before() {
-              if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, "beforeUpdate");
-              }
-          },
-      }, true /* isRenderWatcher */);
-      hydrating = false;
-      // manually mounted instance, call mounted on self
-      // mounted is called for render-created child components in its inserted hook
-      if (vm.$vnode == null) {
-          vm._isMounted = true;
-          callHook$1(vm, "mounted");
-      }
-      return vm;
-  }
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      {
-          isUpdatingChildComponent = true;
-      }
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-      {
-          isUpdatingChildComponent = false;
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "deactivated");
-      }
-  }
-  function callHook$1(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
+  let activeInstance = null;
+  let isUpdatingChildComponent = false;
+  function setActiveInstance(vm) {
+      const prevActiveInstance = activeInstance;
+      activeInstance = vm;
+      return () => {
+          activeInstance = prevActiveInstance;
+      };
+  }
+  function initLifecycle(vm) {
+      const options = vm.$options;
+      // locate first non-abstract parent
+      let parent = options.parent;
+      if (parent && !options.abstract) {
+          while (parent.$options.abstract && parent.$parent) {
+              parent = parent.$parent;
+          }
+          parent.$children.push(vm);
+      }
+      vm.$parent = parent;
+      vm.$root = parent ? parent.$root : vm;
+      vm.$children = [];
+      vm.$refs = {};
+      vm._watcher = null;
+      vm._inactive = null;
+      vm._directInactive = false;
+      vm._isMounted = false;
+      vm._isDestroyed = false;
+      vm._isBeingDestroyed = false;
+  }
+  function lifecycleMixin(Vue) {
+      Vue.prototype._update = function (vnode, hydrating) {
+          const vm = this;
+          const prevEl = vm.$el;
+          const prevVnode = vm._vnode;
+          const restoreActiveInstance = setActiveInstance(vm);
+          vm._vnode = vnode;
+          // Vue.prototype.__patch__ is injected in entry points
+          // based on the rendering backend used.
+          if (!prevVnode) {
+              // initial render
+              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+          }
+          else {
+              // updates
+              vm.$el = vm.__patch__(prevVnode, vnode);
+          }
+          restoreActiveInstance();
+          // update __vue__ reference
+          if (prevEl) {
+              prevEl.__vue__ = null;
+          }
+          if (vm.$el) {
+              vm.$el.__vue__ = vm;
+          }
+          // if parent is an HOC, update its $el as well
+          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+              vm.$parent.$el = vm.$el;
+          }
+          // updated hook is called by the scheduler to ensure that children are
+          // updated in a parent's updated hook.
+      };
+      Vue.prototype.$forceUpdate = function () {
+          const vm = this;
+          if (vm._watcher) {
+              vm._watcher.update();
+          }
+      };
+      Vue.prototype.$destroy = function () {
+          const vm = this;
+          if (vm._isBeingDestroyed) {
+              return;
+          }
+          callHook$1(vm, "beforeDestroy");
+          vm._isBeingDestroyed = true;
+          // remove self from parent
+          const parent = vm.$parent;
+          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+              remove$2(parent.$children, vm);
+          }
+          // teardown watchers
+          if (vm._watcher) {
+              vm._watcher.teardown();
+          }
+          let i = vm._watchers.length;
+          while (i--) {
+              vm._watchers[i].teardown();
+          }
+          // remove reference from data ob
+          // frozen object may not have observer.
+          if (vm._data.__ob__) {
+              vm._data.__ob__.vmCount--;
+          }
+          // call the last hook...
+          vm._isDestroyed = true;
+          // invoke destroy hooks on current rendered tree
+          vm.__patch__(vm._vnode, null);
+          // fire destroyed hook
+          callHook$1(vm, "destroyed");
+          // turn off all instance listeners.
+          vm.$off();
+          // remove __vue__ reference
+          if (vm.$el) {
+              vm.$el.__vue__ = null;
+          }
+          // release circular reference (#6759)
+          if (vm.$vnode) {
+              vm.$vnode.parent = null;
+          }
+      };
+  }
+  function mountComponent(vm, el, hydrating) {
+      vm.$el = el;
+      if (!vm.$options.render) {
+          // @ts-expect-error invalid type
+          vm.$options.render = createEmptyVNode;
+          {
+              /* istanbul ignore if */
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                  vm.$options.el ||
+                  el) {
+                  warn$2("You are using the runtime-only build of Vue where the template " +
+                      "compiler is not available. Either pre-compile the templates into " +
+                      "render functions, or use the compiler-included build.", vm);
+              }
+              else {
+                  warn$2("Failed to mount component: template or render function not defined.", vm);
+              }
+          }
+      }
+      callHook$1(vm, "beforeMount");
+      let updateComponent;
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+          updateComponent = () => {
+              const name = vm._name;
+              const id = vm._uid;
+              const startTag = `vue-perf-start:${id}`;
+              const endTag = `vue-perf-end:${id}`;
+              mark(startTag);
+              const vnode = vm._render();
+              mark(endTag);
+              measure(`vue ${name} render`, startTag, endTag);
+              mark(startTag);
+              vm._update(vnode, hydrating);
+              mark(endTag);
+              measure(`vue ${name} patch`, startTag, endTag);
+          };
+      }
+      else {
+          updateComponent = () => {
+              vm._update(vm._render(), hydrating);
+          };
+      }
+      // we set this to vm._watcher inside the watcher's constructor
+      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+      // component's mounted hook), which relies on vm._watcher being already defined
+      new Watcher(vm, updateComponent, noop, {
+          before() {
+              if (vm._isMounted && !vm._isDestroyed) {
+                  callHook$1(vm, "beforeUpdate");
+              }
+          },
+      }, true /* isRenderWatcher */);
+      hydrating = false;
+      // manually mounted instance, call mounted on self
+      // mounted is called for render-created child components in its inserted hook
+      if (vm.$vnode == null) {
+          vm._isMounted = true;
+          callHook$1(vm, "mounted");
+      }
+      return vm;
+  }
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      {
+          isUpdatingChildComponent = true;
+      }
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      const needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      vm.$options._parentVnode = parentVnode;
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      const oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+      {
+          isUpdatingChildComponent = false;
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              return true;
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (let i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook$1(vm, "activated");
+      }
+  }
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (let i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook$1(vm, "deactivated");
+      }
+  }
+  function callHook$1(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
+      if (handlers) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit("hook:" + hook);
+      }
+      popTarget();
   }
 
-  const MAX_UPDATE_COUNT = 100;
-  const queue = [];
-  const activatedChildren = [];
-  let has = {};
-  let circular = {};
-  let waiting = false;
-  let flushing = false;
-  let index$1 = 0;
-  /**
-   * Reset the scheduler's state.
-   */
-  function resetSchedulerState() {
-      index$1 = queue.length = activatedChildren.length = 0;
-      has = {};
-      {
-          circular = {};
-      }
-      waiting = flushing = false;
-  }
-  // Async edge case #6566 requires saving the timestamp when event listeners are
-  // attached. However, calling performance.now() has a perf overhead especially
-  // if the page has thousands of event listeners. Instead, we take a timestamp
-  // every time the scheduler flushes and use that for all event listeners
-  // attached during that flush.
-  let currentFlushTimestamp = 0;
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Flush both queues and run the watchers.
-   */
-  function flushSchedulerQueue() {
-      currentFlushTimestamp = getNow();
-      flushing = true;
-      let watcher, id;
-      // Sort queue before flush.
-      // This ensures that:
-      // 1. Components are updated from parent to child. (because parent is always
-      //    created before the child)
-      // 2. A component's user watchers are run before its render watcher (because
-      //    user watchers are created before the render watcher)
-      // 3. If a component is destroyed during a parent component's watcher run,
-      //    its watchers can be skipped.
-      queue.sort((a, b) => a.id - b.id);
-      // do not cache length because more watchers might be pushed
-      // as we run existing watchers
-      for (index$1 = 0; index$1 < queue.length; index$1++) {
-          watcher = queue[index$1];
-          if (watcher.before) {
-              watcher.before();
-          }
-          id = watcher.id;
-          has[id] = null;
-          watcher.run();
-          // in dev build, check and stop circular updates.
-          if (has[id] != null) {
-              circular[id] = (circular[id] || 0) + 1;
-              if (circular[id] > MAX_UPDATE_COUNT) {
-                  warn$2('You may have an infinite update loop ' +
-                      (watcher.user
-                          ? `in watcher with expression "${watcher.expression}"`
-                          : `in a component render function.`), watcher.vm);
-                  break;
-              }
-          }
-      }
-      // keep copies of post queues before resetting state
-      const activatedQueue = activatedChildren.slice();
-      const updatedQueue = queue.slice();
-      resetSchedulerState();
-      // call component updated and activated hooks
-      callActivatedHooks(activatedQueue);
-      callUpdatedHooks(updatedQueue);
-      // devtool hook
-      /* istanbul ignore if */
-      if (devtools && config.devtools) {
-          devtools.emit('flush');
-      }
-  }
-  function callUpdatedHooks(queue) {
-      let i = queue.length;
-      while (i--) {
-          const watcher = queue[i];
-          const vm = watcher.vm;
-          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook$1(vm, 'updated');
-          }
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-      activatedChildren.push(vm);
-  }
-  function callActivatedHooks(queue) {
-      for (let i = 0; i < queue.length; i++) {
-          queue[i]._inactive = true;
-          activateChildComponent(queue[i], true /* true */);
-      }
-  }
-  /**
-   * Push a watcher into the watcher queue.
-   * Jobs with duplicate IDs will be skipped unless it's
-   * pushed when the queue is being flushed.
-   */
-  function queueWatcher(watcher) {
-      const id = watcher.id;
-      if (has[id] == null) {
-          has[id] = true;
-          if (!flushing) {
-              queue.push(watcher);
-          }
-          else {
-              // if already flushing, splice the watcher based on its id
-              // if already past its id, it will be run next immediately.
-              let i = queue.length - 1;
-              while (i > index$1 && queue[i].id > watcher.id) {
-                  i--;
-              }
-              queue.splice(i + 1, 0, watcher);
-          }
-          // queue the flush
-          if (!waiting) {
-              waiting = true;
-              if (!config.async) {
-                  flushSchedulerQueue();
-                  return;
-              }
-              nextTick(flushSchedulerQueue);
-          }
-      }
+  const MAX_UPDATE_COUNT = 100;
+  const queue = [];
+  const activatedChildren = [];
+  let has = {};
+  let circular = {};
+  let waiting = false;
+  let flushing = false;
+  let index$1 = 0;
+  /**
+   * Reset the scheduler's state.
+   */
+  function resetSchedulerState() {
+      index$1 = queue.length = activatedChildren.length = 0;
+      has = {};
+      {
+          circular = {};
+      }
+      waiting = flushing = false;
+  }
+  // Async edge case #6566 requires saving the timestamp when event listeners are
+  // attached. However, calling performance.now() has a perf overhead especially
+  // if the page has thousands of event listeners. Instead, we take a timestamp
+  // every time the scheduler flushes and use that for all event listeners
+  // attached during that flush.
+  let currentFlushTimestamp = 0;
+  // Async edge case fix requires storing an event listener's attach timestamp.
+  let getNow = Date.now;
+  // Determine what event timestamp the browser is using. Annoyingly, the
+  // timestamp can either be hi-res (relative to page load) or low-res
+  // (relative to UNIX epoch), so in order to compare time we have to use the
+  // same timestamp type when saving the flush timestamp.
+  // All IE versions use low-res event timestamps, and have problematic clock
+  // implementations (#9632)
+  if (inBrowser && !isIE) {
+      const performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = () => performance.now();
+      }
+  }
+  /**
+   * Flush both queues and run the watchers.
+   */
+  function flushSchedulerQueue() {
+      currentFlushTimestamp = getNow();
+      flushing = true;
+      let watcher, id;
+      // Sort queue before flush.
+      // This ensures that:
+      // 1. Components are updated from parent to child. (because parent is always
+      //    created before the child)
+      // 2. A component's user watchers are run before its render watcher (because
+      //    user watchers are created before the render watcher)
+      // 3. If a component is destroyed during a parent component's watcher run,
+      //    its watchers can be skipped.
+      queue.sort((a, b) => a.id - b.id);
+      // do not cache length because more watchers might be pushed
+      // as we run existing watchers
+      for (index$1 = 0; index$1 < queue.length; index$1++) {
+          watcher = queue[index$1];
+          if (watcher.before) {
+              watcher.before();
+          }
+          id = watcher.id;
+          has[id] = null;
+          watcher.run();
+          // in dev build, check and stop circular updates.
+          if (has[id] != null) {
+              circular[id] = (circular[id] || 0) + 1;
+              if (circular[id] > MAX_UPDATE_COUNT) {
+                  warn$2('You may have an infinite update loop ' +
+                      (watcher.user
+                          ? `in watcher with expression "${watcher.expression}"`
+                          : `in a component render function.`), watcher.vm);
+                  break;
+              }
+          }
+      }
+      // keep copies of post queues before resetting state
+      const activatedQueue = activatedChildren.slice();
+      const updatedQueue = queue.slice();
+      resetSchedulerState();
+      // call component updated and activated hooks
+      callActivatedHooks(activatedQueue);
+      callUpdatedHooks(updatedQueue);
+      // devtool hook
+      /* istanbul ignore if */
+      if (devtools && config.devtools) {
+          devtools.emit('flush');
+      }
+  }
+  function callUpdatedHooks(queue) {
+      let i = queue.length;
+      while (i--) {
+          const watcher = queue[i];
+          const vm = watcher.vm;
+          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+              callHook$1(vm, 'updated');
+          }
+      }
+  }
+  /**
+   * Queue a kept-alive component that was activated during patch.
+   * The queue will be processed after the entire tree has been patched.
+   */
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+      activatedChildren.push(vm);
+  }
+  function callActivatedHooks(queue) {
+      for (let i = 0; i < queue.length; i++) {
+          queue[i]._inactive = true;
+          activateChildComponent(queue[i], true /* true */);
+      }
+  }
+  /**
+   * Push a watcher into the watcher queue.
+   * Jobs with duplicate IDs will be skipped unless it's
+   * pushed when the queue is being flushed.
+   */
+  function queueWatcher(watcher) {
+      const id = watcher.id;
+      if (has[id] == null) {
+          has[id] = true;
+          if (!flushing) {
+              queue.push(watcher);
+          }
+          else {
+              // if already flushing, splice the watcher based on its id
+              // if already past its id, it will be run next immediately.
+              let i = queue.length - 1;
+              while (i > index$1 && queue[i].id > watcher.id) {
+                  i--;
+              }
+              queue.splice(i + 1, 0, watcher);
+          }
+          // queue the flush
+          if (!waiting) {
+              waiting = true;
+              if (!config.async) {
+                  flushSchedulerQueue();
+                  return;
+              }
+              nextTick(flushSchedulerQueue);
+          }
+      }
   }
 
-  let uid$1 = 0;
-  /**
-   * A watcher parses an expression, collects dependencies,
-   * and fires callback when the expression value changes.
-   * This is used for both the $watch() api and directives.
-   */
-  class Watcher {
-      vm;
-      expression;
-      cb;
-      id;
-      deep;
-      user;
-      lazy;
-      sync;
-      dirty;
-      active;
-      deps;
-      newDeps;
-      depIds;
-      newDepIds;
-      before;
-      getter;
-      value;
-      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-          this.vm = vm;
-          if (isRenderWatcher) {
-              vm._watcher = this;
-          }
-          vm._watchers.push(this);
-          // options
-          if (options) {
-              this.deep = !!options.deep;
-              this.user = !!options.user;
-              this.lazy = !!options.lazy;
-              this.sync = !!options.sync;
-              this.before = options.before;
-          }
-          else {
-              this.deep = this.user = this.lazy = this.sync = false;
-          }
-          this.cb = cb;
-          this.id = ++uid$1; // uid for batching
-          this.active = true;
-          this.dirty = this.lazy; // for lazy watchers
-          this.deps = [];
-          this.newDeps = [];
-          this.depIds = new _Set();
-          this.newDepIds = new _Set();
-          this.expression = expOrFn.toString()
-              ;
-          // parse expression for getter
-          if (typeof expOrFn === 'function') {
-              this.getter = expOrFn;
-          }
-          else {
-              this.getter = parsePath(expOrFn);
-              if (!this.getter) {
-                  this.getter = noop;
-                  warn$2(`Failed watching path: "${expOrFn}" ` +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
-              }
-          }
-          this.value = this.lazy
-              ? undefined
-              : this.get();
-      }
-      /**
-       * Evaluate the getter, and re-collect dependencies.
-       */
-      get() {
-          pushTarget(this);
-          let value;
-          const vm = this.vm;
-          try {
-              value = this.getter.call(vm, vm);
-          }
-          catch (e) {
-              if (this.user) {
-                  // @ts-expect-error e is unknown, should we cast or any?
-                  handleError(e, vm, `getter for watcher "${this.expression}"`);
-              }
-              else {
-                  throw e;
-              }
-          }
-          finally {
-              // "touch" every property so they are all tracked as
-              // dependencies for deep watching
-              if (this.deep) {
-                  traverse(value);
-              }
-              popTarget();
-              this.cleanupDeps();
-          }
-          return value;
-      }
-      /**
-       * Add a dependency to this directive.
-       */
-      addDep(dep) {
-          const id = dep.id;
-          if (!this.newDepIds.has(id)) {
-              this.newDepIds.add(id);
-              this.newDeps.push(dep);
-              if (!this.depIds.has(id)) {
-                  dep.addSub(this);
-              }
-          }
-      }
-      /**
-       * Clean up for dependency collection.
-       */
-      cleanupDeps() {
-          let i = this.deps.length;
-          while (i--) {
-              const dep = this.deps[i];
-              if (!this.newDepIds.has(dep.id)) {
-                  dep.removeSub(this);
-              }
-          }
-          let tmp = this.depIds;
-          this.depIds = this.newDepIds;
-          this.newDepIds = tmp;
-          this.newDepIds.clear();
-          tmp = this.deps;
-          this.deps = this.newDeps;
-          this.newDeps = tmp;
-          this.newDeps.length = 0;
-      }
-      /**
-       * Subscriber interface.
-       * Will be called when a dependency changes.
-       */
-      update() {
-          /* istanbul ignore else */
-          if (this.lazy) {
-              this.dirty = true;
-          }
-          else if (this.sync) {
-              this.run();
-          }
-          else {
-              queueWatcher(this);
-          }
-      }
-      /**
-       * Scheduler job interface.
-       * Will be called by the scheduler.
-       */
-      run() {
-          if (this.active) {
-              const value = this.get();
-              if (value !== this.value ||
-                  // Deep watchers and watchers on Object/Arrays should fire even
-                  // when the value is the same, because the value may
-                  // have mutated.
-                  isObject(value) ||
-                  this.deep) {
-                  // set new value
-                  const oldValue = this.value;
-                  this.value = value;
-                  if (this.user) {
-                      const info = `callback for watcher "${this.expression}"`;
-                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                  }
-                  else {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-              }
-          }
-      }
-      /**
-       * Evaluate the value of the watcher.
-       * This only gets called for lazy watchers.
-       */
-      evaluate() {
-          this.value = this.get();
-          this.dirty = false;
-      }
-      /**
-       * Depend on all deps collected by this watcher.
-       */
-      depend() {
-          let i = this.deps.length;
-          while (i--) {
-              this.deps[i].depend();
-          }
-      }
-      /**
-       * Remove self from all dependencies' subscriber list.
-       */
-      teardown() {
-          if (this.active) {
-              // remove self from vm's watcher list
-              // this is a somewhat expensive operation so we skip it
-              // if the vm is being destroyed.
-              if (!this.vm._isBeingDestroyed) {
-                  remove$2(this.vm._watchers, this);
-              }
-              let i = this.deps.length;
-              while (i--) {
-                  this.deps[i].removeSub(this);
-              }
-              this.active = false;
-          }
-      }
+  let uid$1 = 0;
+  /**
+   * A watcher parses an expression, collects dependencies,
+   * and fires callback when the expression value changes.
+   * This is used for both the $watch() api and directives.
+   */
+  class Watcher {
+      vm;
+      expression;
+      cb;
+      id;
+      deep;
+      user;
+      lazy;
+      sync;
+      dirty;
+      active;
+      deps;
+      newDeps;
+      depIds;
+      newDepIds;
+      before;
+      getter;
+      value;
+      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+          this.vm = vm;
+          if (isRenderWatcher) {
+              vm._watcher = this;
+          }
+          vm._watchers.push(this);
+          // options
+          if (options) {
+              this.deep = !!options.deep;
+              this.user = !!options.user;
+              this.lazy = !!options.lazy;
+              this.sync = !!options.sync;
+              this.before = options.before;
+          }
+          else {
+              this.deep = this.user = this.lazy = this.sync = false;
+          }
+          this.cb = cb;
+          this.id = ++uid$1; // uid for batching
+          this.active = true;
+          this.dirty = this.lazy; // for lazy watchers
+          this.deps = [];
+          this.newDeps = [];
+          this.depIds = new _Set();
+          this.newDepIds = new _Set();
+          this.expression = expOrFn.toString()
+              ;
+          // parse expression for getter
+          if (typeof expOrFn === 'function') {
+              this.getter = expOrFn;
+          }
+          else {
+              this.getter = parsePath(expOrFn);
+              if (!this.getter) {
+                  this.getter = noop;
+                  warn$2(`Failed watching path: "${expOrFn}" ` +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
+              }
+          }
+          this.value = this.lazy
+              ? undefined
+              : this.get();
+      }
+      /**
+       * Evaluate the getter, and re-collect dependencies.
+       */
+      get() {
+          pushTarget(this);
+          let value;
+          const vm = this.vm;
+          try {
+              value = this.getter.call(vm, vm);
+          }
+          catch (e) {
+              if (this.user) {
+                  handleError(e, vm, `getter for watcher "${this.expression}"`);
+              }
+              else {
+                  throw e;
+              }
+          }
+          finally {
+              // "touch" every property so they are all tracked as
+              // dependencies for deep watching
+              if (this.deep) {
+                  traverse(value);
+              }
+              popTarget();
+              this.cleanupDeps();
+          }
+          return value;
+      }
+      /**
+       * Add a dependency to this directive.
+       */
+      addDep(dep) {
+          const id = dep.id;
+          if (!this.newDepIds.has(id)) {
+              this.newDepIds.add(id);
+              this.newDeps.push(dep);
+              if (!this.depIds.has(id)) {
+                  dep.addSub(this);
+              }
+          }
+      }
+      /**
+       * Clean up for dependency collection.
+       */
+      cleanupDeps() {
+          let i = this.deps.length;
+          while (i--) {
+              const dep = this.deps[i];
+              if (!this.newDepIds.has(dep.id)) {
+                  dep.removeSub(this);
+              }
+          }
+          let tmp = this.depIds;
+          this.depIds = this.newDepIds;
+          this.newDepIds = tmp;
+          this.newDepIds.clear();
+          tmp = this.deps;
+          this.deps = this.newDeps;
+          this.newDeps = tmp;
+          this.newDeps.length = 0;
+      }
+      /**
+       * Subscriber interface.
+       * Will be called when a dependency changes.
+       */
+      update() {
+          /* istanbul ignore else */
+          if (this.lazy) {
+              this.dirty = true;
+          }
+          else if (this.sync) {
+              this.run();
+          }
+          else {
+              queueWatcher(this);
+          }
+      }
+      /**
+       * Scheduler job interface.
+       * Will be called by the scheduler.
+       */
+      run() {
+          if (this.active) {
+              const value = this.get();
+              if (value !== this.value ||
+                  // Deep watchers and watchers on Object/Arrays should fire even
+                  // when the value is the same, because the value may
+                  // have mutated.
+                  isObject(value) ||
+                  this.deep) {
+                  // set new value
+                  const oldValue = this.value;
+                  this.value = value;
+                  if (this.user) {
+                      const info = `callback for watcher "${this.expression}"`;
+                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                  }
+                  else {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+              }
+          }
+      }
+      /**
+       * Evaluate the value of the watcher.
+       * This only gets called for lazy watchers.
+       */
+      evaluate() {
+          this.value = this.get();
+          this.dirty = false;
+      }
+      /**
+       * Depend on all deps collected by this watcher.
+       */
+      depend() {
+          let i = this.deps.length;
+          while (i--) {
+              this.deps[i].depend();
+          }
+      }
+      /**
+       * Remove self from all dependencies' subscriber list.
+       */
+      teardown() {
+          if (this.active) {
+              // remove self from vm's watcher list
+              // this is a somewhat expensive operation so we skip it
+              // if the vm is being destroyed.
+              if (!this.vm._isBeingDestroyed) {
+                  remove$2(this.vm._watchers, this);
+              }
+              let i = this.deps.length;
+              while (i--) {
+                  this.deps[i].removeSub(this);
+              }
+              this.active = false;
+          }
+      }
   }
 
-  const sharedPropertyDefinition = {
-      enumerable: true,
-      configurable: true,
-      get: noop,
-      set: noop,
-  };
-  function proxy(target, sourceKey, key) {
-      sharedPropertyDefinition.get = function proxyGetter() {
-          return this[sourceKey][key];
-      };
-      sharedPropertyDefinition.set = function proxySetter(val) {
-          this[sourceKey][key] = val;
-      };
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function initState(vm) {
-      vm._watchers = [];
-      const opts = vm.$options;
-      if (opts.props)
-          initProps$1(vm, opts.props);
-      if (opts.methods)
-          initMethods(vm, opts.methods);
-      if (opts.data) {
-          initData(vm);
-      }
-      else {
-          observe((vm._data = {}), true /* asRootData */);
-      }
-      if (opts.computed)
-          initComputed$1(vm, opts.computed);
-      if (opts.watch && opts.watch !== nativeWatch) {
-          initWatch(vm, opts.watch);
-      }
-  }
-  function initProps$1(vm, propsOptions) {
-      const propsData = vm.$options.propsData || {};
-      const props = (vm._props = {});
-      // cache prop keys so that future props updates can iterate using Array
-      // instead of dynamic object key enumeration.
-      const keys = (vm.$options._propKeys = []);
-      const isRoot = !vm.$parent;
-      // root instance props should be converted
-      if (!isRoot) {
-          toggleObserving(false);
-      }
-      for (const key in propsOptions) {
-          keys.push(key);
-          const value = validateProp(key, propsOptions, propsData, vm);
-          /* istanbul ignore else */
-          {
-              const hyphenatedKey = hyphenate(key);
-              if (isReservedAttribute(hyphenatedKey) ||
-                  config.isReservedAttr(hyphenatedKey)) {
-                  warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-              }
-              defineReactive(props, key, value, () => {
-                  if (!isRoot && !isUpdatingChildComponent) {
-                      warn$2(`Avoid mutating a prop directly since the value will be ` +
-                          `overwritten whenever the parent component re-renders. ` +
-                          `Instead, use a data or computed property based on the prop's ` +
-                          `value. Prop being mutated: "${key}"`, vm);
-                  }
-              });
-          }
-          // static props are already proxied on the component's prototype
-          // during Vue.extend(). We only need to proxy props defined at
-          // instantiation here.
-          if (!(key in vm)) {
-              proxy(vm, `_props`, key);
-          }
-      }
-      toggleObserving(true);
-  }
-  function initData(vm) {
-      let data = vm.$options.data;
-      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-      if (!isPlainObject(data)) {
-          data = {};
-          warn$2("data functions should return an object:\n" +
-                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-      }
-      // proxy data on instance
-      const keys = Object.keys(data);
-      const props = vm.$options.props;
-      const methods = vm.$options.methods;
-      let i = keys.length;
-      while (i--) {
-          const key = keys[i];
-          {
-              if (methods && hasOwn(methods, key)) {
-                  warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-              }
-          }
-          if (props && hasOwn(props, key)) {
-              warn$2(`The data property "${key}" is already declared as a prop. ` +
-                      `Use prop default value instead.`, vm);
-          }
-          else if (!isReserved(key)) {
-              proxy(vm, `_data`, key);
-          }
-      }
-      // observe data
-      observe(data, true /* asRootData */);
-  }
-  function getData(data, vm) {
-      // #7573 disable dep collection when invoking data getters
-      pushTarget();
-      try {
-          return data.call(vm, vm);
-      }
-      catch (e) {
-          handleError(e, vm, `data()`);
-          return {};
-      }
-      finally {
-          popTarget();
-      }
-  }
-  const computedWatcherOptions = { lazy: true };
-  function initComputed$1(vm, computed) {
-      // $flow-disable-line
-      const watchers = (vm._computedWatchers = Object.create(null));
-      // computed properties are just getters during SSR
-      const isSSR = isServerRendering();
-      for (const key in computed) {
-          const userDef = computed[key];
-          const getter = typeof userDef === "function" ? userDef : userDef.get;
-          if (getter == null) {
-              warn$2(`Getter is missing for computed property "${key}".`, vm);
-          }
-          if (!isSSR) {
-              // create internal watcher for the computed property.
-              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-          }
-          // component-defined computed properties are already defined on the
-          // component prototype. We only need to define computed properties defined
-          // at instantiation here.
-          if (!(key in vm)) {
-              defineComputed(vm, key, userDef);
-          }
-          else {
-              if (key in vm.$data) {
-                  warn$2(`The computed property "${key}" is already defined in data.`, vm);
-              }
-              else if (vm.$options.props && key in vm.$options.props) {
-                  warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-              }
-              else if (vm.$options.methods && key in vm.$options.methods) {
-                  warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-              }
-          }
-      }
-  }
-  function defineComputed(target, key, userDef) {
-      const shouldCache = !isServerRendering();
-      if (typeof userDef === "function") {
-          sharedPropertyDefinition.get = shouldCache
-              ? createComputedGetter(key)
-              : createGetterInvoker(userDef);
-          sharedPropertyDefinition.set = noop;
-      }
-      else {
-          sharedPropertyDefinition.get = userDef.get
-              ? shouldCache && userDef.cache !== false
-                  ? createComputedGetter(key)
-                  : createGetterInvoker(userDef.get)
-              : noop;
-          sharedPropertyDefinition.set = userDef.set || noop;
-      }
-      if (sharedPropertyDefinition.set === noop) {
-          sharedPropertyDefinition.set = function () {
-              warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-          };
-      }
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function createComputedGetter(key) {
-      return function computedGetter() {
-          const watcher = this._computedWatchers && this._computedWatchers[key];
-          if (watcher) {
-              if (watcher.dirty) {
-                  watcher.evaluate();
-              }
-              if (Dep.target) {
-                  watcher.depend();
-              }
-              return watcher.value;
-          }
-      };
-  }
-  function createGetterInvoker(fn) {
-      return function computedGetter() {
-          return fn.call(this, this);
-      };
-  }
-  function initMethods(vm, methods) {
-      const props = vm.$options.props;
-      for (const key in methods) {
-          {
-              if (typeof methods[key] !== "function") {
-                  warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                      `Did you reference the function correctly?`, vm);
-              }
-              if (props && hasOwn(props, key)) {
-                  warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-              }
-              if (key in vm && isReserved(key)) {
-                  warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                      `Avoid defining component methods that start with _ or $.`);
-              }
-          }
-          vm[key] =
-              typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-      }
-  }
-  function initWatch(vm, watch) {
-      for (const key in watch) {
-          const handler = watch[key];
-          if (Array.isArray(handler)) {
-              for (let i = 0; i < handler.length; i++) {
-                  createWatcher(vm, key, handler[i]);
-              }
-          }
-          else {
-              createWatcher(vm, key, handler);
-          }
-      }
-  }
-  function createWatcher(vm, expOrFn, handler, options) {
-      if (isPlainObject(handler)) {
-          options = handler;
-          handler = handler.handler;
-      }
-      if (typeof handler === "string") {
-          handler = vm[handler];
-      }
-      return vm.$watch(expOrFn, handler, options);
-  }
-  function stateMixin(Vue) {
-      // flow somehow has problems with directly declared definition object
-      // when using Object.defineProperty, so we have to procedurally build up
-      // the object here.
-      const dataDef = {};
-      dataDef.get = function () {
-          return this._data;
-      };
-      const propsDef = {};
-      propsDef.get = function () {
-          return this._props;
-      };
-      {
-          dataDef.set = function () {
-              warn$2("Avoid replacing instance root $data. " +
-                  "Use nested data properties instead.", this);
-          };
-          propsDef.set = function () {
-              warn$2(`$props is readonly.`, this);
-          };
-      }
-      Object.defineProperty(Vue.prototype, "$data", dataDef);
-      Object.defineProperty(Vue.prototype, "$props", propsDef);
-      Vue.prototype.$set = set;
-      Vue.prototype.$delete = del;
-      Vue.prototype.$watch = function (expOrFn, cb, options) {
-          const vm = this;
-          if (isPlainObject(cb)) {
-              return createWatcher(vm, expOrFn, cb, options);
-          }
-          options = options || {};
-          options.user = true;
-          const watcher = new Watcher(vm, expOrFn, cb, options);
-          if (options.immediate) {
-              const info = `callback for immediate watcher "${watcher.expression}"`;
-              pushTarget();
-              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-              popTarget();
-          }
-          return function unwatchFn() {
-              watcher.teardown();
-          };
-      };
+  const sharedPropertyDefinition = {
+      enumerable: true,
+      configurable: true,
+      get: noop,
+      set: noop,
+  };
+  function proxy(target, sourceKey, key) {
+      sharedPropertyDefinition.get = function proxyGetter() {
+          return this[sourceKey][key];
+      };
+      sharedPropertyDefinition.set = function proxySetter(val) {
+          this[sourceKey][key] = val;
+      };
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function initState(vm) {
+      vm._watchers = [];
+      const opts = vm.$options;
+      if (opts.props)
+          initProps$1(vm, opts.props);
+      if (opts.methods)
+          initMethods(vm, opts.methods);
+      if (opts.data) {
+          initData(vm);
+      }
+      else {
+          observe((vm._data = {}), true /* asRootData */);
+      }
+      if (opts.computed)
+          initComputed$1(vm, opts.computed);
+      if (opts.watch && opts.watch !== nativeWatch) {
+          initWatch(vm, opts.watch);
+      }
+  }
+  function initProps$1(vm, propsOptions) {
+      const propsData = vm.$options.propsData || {};
+      const props = (vm._props = {});
+      // cache prop keys so that future props updates can iterate using Array
+      // instead of dynamic object key enumeration.
+      const keys = (vm.$options._propKeys = []);
+      const isRoot = !vm.$parent;
+      // root instance props should be converted
+      if (!isRoot) {
+          toggleObserving(false);
+      }
+      for (const key in propsOptions) {
+          keys.push(key);
+          const value = validateProp(key, propsOptions, propsData, vm);
+          /* istanbul ignore else */
+          {
+              const hyphenatedKey = hyphenate(key);
+              if (isReservedAttribute(hyphenatedKey) ||
+                  config.isReservedAttr(hyphenatedKey)) {
+                  warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+              }
+              defineReactive(props, key, value, () => {
+                  if (!isRoot && !isUpdatingChildComponent) {
+                      warn$2(`Avoid mutating a prop directly since the value will be ` +
+                          `overwritten whenever the parent component re-renders. ` +
+                          `Instead, use a data or computed property based on the prop's ` +
+                          `value. Prop being mutated: "${key}"`, vm);
+                  }
+              });
+          }
+          // static props are already proxied on the component's prototype
+          // during Vue.extend(). We only need to proxy props defined at
+          // instantiation here.
+          if (!(key in vm)) {
+              proxy(vm, `_props`, key);
+          }
+      }
+      toggleObserving(true);
+  }
+  function initData(vm) {
+      let data = vm.$options.data;
+      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+      if (!isPlainObject(data)) {
+          data = {};
+          warn$2("data functions should return an object:\n" +
+                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+      }
+      // proxy data on instance
+      const keys = Object.keys(data);
+      const props = vm.$options.props;
+      const methods = vm.$options.methods;
+      let i = keys.length;
+      while (i--) {
+          const key = keys[i];
+          {
+              if (methods && hasOwn(methods, key)) {
+                  warn$2(`Method "${key}" has already been defined as a data property.`, vm);
+              }
+          }
+          if (props && hasOwn(props, key)) {
+              warn$2(`The data property "${key}" is already declared as a prop. ` +
+                      `Use prop default value instead.`, vm);
+          }
+          else if (!isReserved(key)) {
+              proxy(vm, `_data`, key);
+          }
+      }
+      // observe data
+      observe(data, true /* asRootData */);
+  }
+  function getData(data, vm) {
+      // #7573 disable dep collection when invoking data getters
+      pushTarget();
+      try {
+          return data.call(vm, vm);
+      }
+      catch (e) {
+          handleError(e, vm, `data()`);
+          return {};
+      }
+      finally {
+          popTarget();
+      }
+  }
+  const computedWatcherOptions = { lazy: true };
+  function initComputed$1(vm, computed) {
+      // $flow-disable-line
+      const watchers = (vm._computedWatchers = Object.create(null));
+      // computed properties are just getters during SSR
+      const isSSR = isServerRendering();
+      for (const key in computed) {
+          const userDef = computed[key];
+          const getter = typeof userDef === "function" ? userDef : userDef.get;
+          if (getter == null) {
+              warn$2(`Getter is missing for computed property "${key}".`, vm);
+          }
+          if (!isSSR) {
+              // create internal watcher for the computed property.
+              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+          }
+          // component-defined computed properties are already defined on the
+          // component prototype. We only need to define computed properties defined
+          // at instantiation here.
+          if (!(key in vm)) {
+              defineComputed(vm, key, userDef);
+          }
+          else {
+              if (key in vm.$data) {
+                  warn$2(`The computed property "${key}" is already defined in data.`, vm);
+              }
+              else if (vm.$options.props && key in vm.$options.props) {
+                  warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
+              }
+              else if (vm.$options.methods && key in vm.$options.methods) {
+                  warn$2(`The computed property "${key}" is already defined as a method.`, vm);
+              }
+          }
+      }
+  }
+  function defineComputed(target, key, userDef) {
+      const shouldCache = !isServerRendering();
+      if (typeof userDef === "function") {
+          sharedPropertyDefinition.get = shouldCache
+              ? createComputedGetter(key)
+              : createGetterInvoker(userDef);
+          sharedPropertyDefinition.set = noop;
+      }
+      else {
+          sharedPropertyDefinition.get = userDef.get
+              ? shouldCache && userDef.cache !== false
+                  ? createComputedGetter(key)
+                  : createGetterInvoker(userDef.get)
+              : noop;
+          sharedPropertyDefinition.set = userDef.set || noop;
+      }
+      if (sharedPropertyDefinition.set === noop) {
+          sharedPropertyDefinition.set = function () {
+              warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
+          };
+      }
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function createComputedGetter(key) {
+      return function computedGetter() {
+          const watcher = this._computedWatchers && this._computedWatchers[key];
+          if (watcher) {
+              if (watcher.dirty) {
+                  watcher.evaluate();
+              }
+              if (Dep.target) {
+                  watcher.depend();
+              }
+              return watcher.value;
+          }
+      };
+  }
+  function createGetterInvoker(fn) {
+      return function computedGetter() {
+          return fn.call(this, this);
+      };
+  }
+  function initMethods(vm, methods) {
+      const props = vm.$options.props;
+      for (const key in methods) {
+          {
+              if (typeof methods[key] !== "function") {
+                  warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                      `Did you reference the function correctly?`, vm);
+              }
+              if (props && hasOwn(props, key)) {
+                  warn$2(`Method "${key}" has already been defined as a prop.`, vm);
+              }
+              if (key in vm && isReserved(key)) {
+                  warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                      `Avoid defining component methods that start with _ or $.`);
+              }
+          }
+          vm[key] =
+              typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
+      }
+  }
+  function initWatch(vm, watch) {
+      for (const key in watch) {
+          const handler = watch[key];
+          if (Array.isArray(handler)) {
+              for (let i = 0; i < handler.length; i++) {
+                  createWatcher(vm, key, handler[i]);
+              }
+          }
+          else {
+              createWatcher(vm, key, handler);
+          }
+      }
+  }
+  function createWatcher(vm, expOrFn, handler, options) {
+      if (isPlainObject(handler)) {
+          options = handler;
+          handler = handler.handler;
+      }
+      if (typeof handler === "string") {
+          handler = vm[handler];
+      }
+      return vm.$watch(expOrFn, handler, options);
+  }
+  function stateMixin(Vue) {
+      // flow somehow has problems with directly declared definition object
+      // when using Object.defineProperty, so we have to procedurally build up
+      // the object here.
+      const dataDef = {};
+      dataDef.get = function () {
+          return this._data;
+      };
+      const propsDef = {};
+      propsDef.get = function () {
+          return this._props;
+      };
+      {
+          dataDef.set = function () {
+              warn$2("Avoid replacing instance root $data. " +
+                  "Use nested data properties instead.", this);
+          };
+          propsDef.set = function () {
+              warn$2(`$props is readonly.`, this);
+          };
+      }
+      Object.defineProperty(Vue.prototype, "$data", dataDef);
+      Object.defineProperty(Vue.prototype, "$props", propsDef);
+      Vue.prototype.$set = set;
+      Vue.prototype.$delete = del;
+      Vue.prototype.$watch = function (expOrFn, cb, options) {
+          const vm = this;
+          if (isPlainObject(cb)) {
+              return createWatcher(vm, expOrFn, cb, options);
+          }
+          options = options || {};
+          options.user = true;
+          const watcher = new Watcher(vm, expOrFn, cb, options);
+          if (options.immediate) {
+              const info = `callback for immediate watcher "${watcher.expression}"`;
+              pushTarget();
+              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+              popTarget();
+          }
+          return function unwatchFn() {
+              watcher.teardown();
+          };
+      };
   }
 
-  let uid = 0;
-  function initMixin$1(Vue) {
-      Vue.prototype._init = function (options) {
-          const vm = this;
-          // a uid
-          vm._uid = uid++;
-          let startTag, endTag;
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              startTag = `vue-perf-start:${vm._uid}`;
-              endTag = `vue-perf-end:${vm._uid}`;
-              mark(startTag);
-          }
-          // a flag to avoid this being observed
-          vm._isVue = true;
-          // merge options
-          if (options && options._isComponent) {
-              // optimize internal component instantiation
-              // since dynamic options merging is pretty slow, and none of the
-              // internal component options needs special treatment.
-              initInternalComponent(vm, options);
-          }
-          else {
-              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-          }
-          /* istanbul ignore else */
-          {
-              initProxy(vm);
-          }
-          // expose real self
-          vm._self = vm;
-          initLifecycle(vm);
-          initEvents(vm);
-          initRender(vm);
-          callHook$1(vm, 'beforeCreate');
-          initInjections(vm); // resolve injections before data/props
-          initState(vm);
-          initProvide(vm); // resolve provide after data/props
-          callHook$1(vm, 'created');
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              vm._name = formatComponentName(vm, false);
-              mark(endTag);
-              measure(`vue ${vm._name} init`, startTag, endTag);
-          }
-          if (vm.$options.el) {
-              vm.$mount(vm.$options.el);
-          }
-      };
-  }
-  function initInternalComponent(vm, options) {
-      const opts = (vm.$options = Object.create(vm.constructor.options));
-      // doing this because it's faster than dynamic enumeration.
-      const parentVnode = options._parentVnode;
-      opts.parent = options.parent;
-      opts._parentVnode = parentVnode;
-      const vnodeComponentOptions = parentVnode.componentOptions;
-      opts.propsData = vnodeComponentOptions.propsData;
-      opts._parentListeners = vnodeComponentOptions.listeners;
-      opts._renderChildren = vnodeComponentOptions.children;
-      opts._componentTag = vnodeComponentOptions.tag;
-      if (options.render) {
-          opts.render = options.render;
-          opts.staticRenderFns = options.staticRenderFns;
-      }
-  }
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
+  let uid = 0;
+  function initMixin$1(Vue) {
+      Vue.prototype._init = function (options) {
+          const vm = this;
+          // a uid
+          vm._uid = uid++;
+          let startTag, endTag;
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              startTag = `vue-perf-start:${vm._uid}`;
+              endTag = `vue-perf-end:${vm._uid}`;
+              mark(startTag);
+          }
+          // a flag to avoid this being observed
+          vm._isVue = true;
+          // merge options
+          if (options && options._isComponent) {
+              // optimize internal component instantiation
+              // since dynamic options merging is pretty slow, and none of the
+              // internal component options needs special treatment.
+              initInternalComponent(vm, options);
+          }
+          else {
+              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+          }
+          /* istanbul ignore else */
+          {
+              initProxy(vm);
+          }
+          // expose real self
+          vm._self = vm;
+          initLifecycle(vm);
+          initEvents(vm);
+          initRender(vm);
+          callHook$1(vm, 'beforeCreate');
+          initInjections(vm); // resolve injections before data/props
+          initState(vm);
+          initProvide(vm); // resolve provide after data/props
+          callHook$1(vm, 'created');
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              vm._name = formatComponentName(vm, false);
+              mark(endTag);
+              measure(`vue ${vm._name} init`, startTag, endTag);
+          }
+          if (vm.$options.el) {
+              vm.$mount(vm.$options.el);
+          }
+      };
+  }
+  function initInternalComponent(vm, options) {
+      const opts = (vm.$options = Object.create(vm.constructor.options));
+      // doing this because it's faster than dynamic enumeration.
+      const parentVnode = options._parentVnode;
+      opts.parent = options.parent;
+      opts._parentVnode = parentVnode;
+      const vnodeComponentOptions = parentVnode.componentOptions;
+      opts.propsData = vnodeComponentOptions.propsData;
+      opts._parentListeners = vnodeComponentOptions.listeners;
+      opts._renderChildren = vnodeComponentOptions.children;
+      opts._componentTag = vnodeComponentOptions.tag;
+      if (options.render) {
+          opts.render = options.render;
+          opts.staticRenderFns = options.staticRenderFns;
+      }
+  }
+  function resolveConstructorOptions(Ctor) {
+      let options = Ctor.options;
+      if (Ctor.super) {
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              const modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  modified = {};
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
   }
 
-  function Vue(options) {
-      if (!(this instanceof Vue)) {
-          warn$2("Vue is a constructor and should be called with the `new` keyword");
-      }
-      this._init(options);
-  }
-  //@ts-expect-error Vue has function type
-  initMixin$1(Vue);
-  //@ts-expect-error Vue has function type
-  stateMixin(Vue);
-  //@ts-expect-error Vue has function type
-  eventsMixin(Vue);
-  //@ts-expect-error Vue has function type
-  lifecycleMixin(Vue);
-  //@ts-expect-error Vue has function type
+  function Vue(options) {
+      if (!(this instanceof Vue)) {
+          warn$2("Vue is a constructor and should be called with the `new` keyword");
+      }
+      this._init(options);
+  }
+  //@ts-expect-error Vue has function type
+  initMixin$1(Vue);
+  //@ts-expect-error Vue has function type
+  stateMixin(Vue);
+  //@ts-expect-error Vue has function type
+  eventsMixin(Vue);
+  //@ts-expect-error Vue has function type
+  lifecycleMixin(Vue);
+  //@ts-expect-error Vue has function type
   renderMixin(Vue);
 
-  function initUse(Vue) {
-      Vue.use = function (plugin) {
-          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-          if (installedPlugins.indexOf(plugin) > -1) {
-              return this;
-          }
-          // additional parameters
-          const args = toArray(arguments, 1);
-          args.unshift(this);
-          if (typeof plugin.install === 'function') {
-              plugin.install.apply(plugin, args);
-          }
-          else if (typeof plugin === 'function') {
-              plugin.apply(null, args);
-          }
-          installedPlugins.push(plugin);
-          return this;
-      };
+  function initUse(Vue) {
+      Vue.use = function (plugin) {
+          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          if (installedPlugins.indexOf(plugin) > -1) {
+              return this;
+          }
+          // additional parameters
+          const args = toArray(arguments, 1);
+          args.unshift(this);
+          if (typeof plugin.install === 'function') {
+              plugin.install.apply(plugin, args);
+          }
+          else if (typeof plugin === 'function') {
+              plugin.apply(null, args);
+          }
+          installedPlugins.push(plugin);
+          return this;
+      };
   }
 
-  function initMixin(Vue) {
-      Vue.mixin = function (mixin) {
-          this.options = mergeOptions(this.options, mixin);
-          return this;
-      };
+  function initMixin(Vue) {
+      Vue.mixin = function (mixin) {
+          this.options = mergeOptions(this.options, mixin);
+          return this;
+      };
   }
 
-  function initExtend(Vue) {
-      /**
-       * Each instance constructor, including Vue, has a unique
-       * cid. This enables us to create wrapped "child
-       * constructors" for prototypal inheritance and cache them.
-       */
-      Vue.cid = 0;
-      let cid = 1;
-      /**
-       * Class inheritance
-       */
-      Vue.extend = function (extendOptions) {
-          extendOptions = extendOptions || {};
-          const Super = this;
-          const SuperId = Super.cid;
-          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-          if (cachedCtors[SuperId]) {
-              return cachedCtors[SuperId];
-          }
-          const name = extendOptions.name || Super.options.name;
-          if (name) {
-              validateComponentName(name);
-          }
-          const Sub = function VueComponent(options) {
-              this._init(options);
-          };
-          Sub.prototype = Object.create(Super.prototype);
-          Sub.prototype.constructor = Sub;
-          Sub.cid = cid++;
-          Sub.options = mergeOptions(Super.options, extendOptions);
-          Sub['super'] = Super;
-          // For props and computed properties, we define the proxy getters on
-          // the Vue instances at extension time, on the extended prototype. This
-          // avoids Object.defineProperty calls for each instance created.
-          if (Sub.options.props) {
-              initProps(Sub);
-          }
-          if (Sub.options.computed) {
-              initComputed(Sub);
-          }
-          // allow further extension/mixin/plugin usage
-          Sub.extend = Super.extend;
-          Sub.mixin = Super.mixin;
-          Sub.use = Super.use;
-          // create asset registers, so extended classes
-          // can have their private assets too.
-          ASSET_TYPES.forEach(function (type) {
-              Sub[type] = Super[type];
-          });
-          // enable recursive self-lookup
-          if (name) {
-              Sub.options.components[name] = Sub;
-          }
-          // keep a reference to the super options at extension time.
-          // later at instantiation we can check if Super's options have
-          // been updated.
-          Sub.superOptions = Super.options;
-          Sub.extendOptions = extendOptions;
-          Sub.sealedOptions = extend({}, Sub.options);
-          // cache constructor
-          cachedCtors[SuperId] = Sub;
-          return Sub;
-      };
-  }
-  function initProps(Comp) {
-      const props = Comp.options.props;
-      for (const key in props) {
-          proxy(Comp.prototype, `_props`, key);
-      }
-  }
-  function initComputed(Comp) {
-      const computed = Comp.options.computed;
-      for (const key in computed) {
-          defineComputed(Comp.prototype, key, computed[key]);
-      }
+  function initExtend(Vue) {
+      /**
+       * Each instance constructor, including Vue, has a unique
+       * cid. This enables us to create wrapped "child
+       * constructors" for prototypal inheritance and cache them.
+       */
+      Vue.cid = 0;
+      let cid = 1;
+      /**
+       * Class inheritance
+       */
+      Vue.extend = function (extendOptions) {
+          extendOptions = extendOptions || {};
+          const Super = this;
+          const SuperId = Super.cid;
+          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          if (cachedCtors[SuperId]) {
+              return cachedCtors[SuperId];
+          }
+          const name = extendOptions.name || Super.options.name;
+          if (name) {
+              validateComponentName(name);
+          }
+          const Sub = function VueComponent(options) {
+              this._init(options);
+          };
+          Sub.prototype = Object.create(Super.prototype);
+          Sub.prototype.constructor = Sub;
+          Sub.cid = cid++;
+          Sub.options = mergeOptions(Super.options, extendOptions);
+          Sub['super'] = Super;
+          // For props and computed properties, we define the proxy getters on
+          // the Vue instances at extension time, on the extended prototype. This
+          // avoids Object.defineProperty calls for each instance created.
+          if (Sub.options.props) {
+              initProps(Sub);
+          }
+          if (Sub.options.computed) {
+              initComputed(Sub);
+          }
+          // allow further extension/mixin/plugin usage
+          Sub.extend = Super.extend;
+          Sub.mixin = Super.mixin;
+          Sub.use = Super.use;
+          // create asset registers, so extended classes
+          // can have their private assets too.
+          ASSET_TYPES.forEach(function (type) {
+              Sub[type] = Super[type];
+          });
+          // enable recursive self-lookup
+          if (name) {
+              Sub.options.components[name] = Sub;
+          }
+          // keep a reference to the super options at extension time.
+          // later at instantiation we can check if Super's options have
+          // been updated.
+          Sub.superOptions = Super.options;
+          Sub.extendOptions = extendOptions;
+          Sub.sealedOptions = extend({}, Sub.options);
+          // cache constructor
+          cachedCtors[SuperId] = Sub;
+          return Sub;
+      };
+  }
+  function initProps(Comp) {
+      const props = Comp.options.props;
+      for (const key in props) {
+          proxy(Comp.prototype, `_props`, key);
+      }
+  }
+  function initComputed(Comp) {
+      const computed = Comp.options.computed;
+      for (const key in computed) {
+          defineComputed(Comp.prototype, key, computed[key]);
+      }
   }
 
-  function initAssetRegisters(Vue) {
-      /**
-       * Create asset registration methods.
-       */
-      ASSET_TYPES.forEach((type) => {
-          // @ts-expect-error function is not exact same type
-          Vue[type] = function (id, definition) {
-              if (!definition) {
-                  return this.options[type + 's'][id];
-              }
-              else {
-                  /* istanbul ignore if */
-                  if (type === 'component') {
-                      validateComponentName(id);
-                  }
-                  if (type === 'component' && isPlainObject(definition)) {
-                      // @ts-expect-error
-                      definition.name = definition.name || id;
-                      definition = this.options._base.extend(definition);
-                  }
-                  if (type === 'directive' && typeof definition === 'function') {
-                      definition = { bind: definition, update: definition };
-                  }
-                  this.options[type + 's'][id] = definition;
-                  return definition;
-              }
-          };
-      });
+  function initAssetRegisters(Vue) {
+      /**
+       * Create asset registration methods.
+       */
+      ASSET_TYPES.forEach((type) => {
+          // @ts-expect-error function is not exact same type
+          Vue[type] = function (id, definition) {
+              if (!definition) {
+                  return this.options[type + 's'][id];
+              }
+              else {
+                  /* istanbul ignore if */
+                  if (type === 'component') {
+                      validateComponentName(id);
+                  }
+                  if (type === 'component' && isPlainObject(definition)) {
+                      // @ts-expect-error
+                      definition.name = definition.name || id;
+                      definition = this.options._base.extend(definition);
+                  }
+                  if (type === 'directive' && typeof definition === 'function') {
+                      definition = { bind: definition, update: definition };
+                  }
+                  this.options[type + 's'][id] = definition;
+                  return definition;
+              }
+          };
+      });
   }
 
-  /* @flow */
-  function getComponentName(opts) {
-      return opts && (opts.Ctor.options.name || opts.tag);
-  }
-  function matches(pattern, name) {
-      if (Array.isArray(pattern)) {
-          return pattern.indexOf(name) > -1;
-      }
-      else if (typeof pattern === "string") {
-          return pattern.split(",").indexOf(name) > -1;
-      }
-      else if (isRegExp(pattern)) {
-          return pattern.test(name);
-      }
-      /* istanbul ignore next */
-      return false;
-  }
-  function pruneCache(keepAliveInstance, filter) {
-      const { cache, keys, _vnode } = keepAliveInstance;
-      for (const key in cache) {
-          const entry = cache[key];
-          if (entry) {
-              const name = entry.name;
-              if (name && !filter(name)) {
-                  pruneCacheEntry(cache, key, keys, _vnode);
-              }
-          }
-      }
-  }
-  function pruneCacheEntry(cache, key, keys, current) {
-      const entry = cache[key];
-      if (entry && (!current || entry.tag !== current.tag)) {
-          // @ts-expect-error can be undefined
-          entry.componentInstance.$destroy();
-      }
-      cache[key] = null;
-      remove$2(keys, key);
-  }
-  const patternTypes = [String, RegExp, Array];
-  // TODO defineComponent
-  var KeepAlive = {
-      name: "keep-alive",
-      abstract: true,
-      props: {
-          include: patternTypes,
-          exclude: patternTypes,
-          max: [String, Number],
-      },
-      methods: {
-          cacheVNode() {
-              const { cache, keys, vnodeToCache, keyToCache } = this;
-              if (vnodeToCache) {
-                  const { tag, componentInstance, componentOptions } = vnodeToCache;
-                  cache[keyToCache] = {
-                      name: getComponentName(componentOptions),
-                      tag,
-                      componentInstance,
-                  };
-                  keys.push(keyToCache);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
-                  this.vnodeToCache = null;
-              }
-          },
-      },
-      created() {
-          this.cache = Object.create(null);
-          this.keys = [];
-      },
-      destroyed() {
-          for (const key in this.cache) {
-              pruneCacheEntry(this.cache, key, this.keys);
-          }
-      },
-      mounted() {
-          this.cacheVNode();
-          this.$watch("include", (val) => {
-              pruneCache(this, (name) => matches(val, name));
-          });
-          this.$watch("exclude", (val) => {
-              pruneCache(this, (name) => !matches(val, name));
-          });
-      },
-      updated() {
-          this.cacheVNode();
-      },
-      render() {
-          const slot = this.$slots.default;
-          const vnode = getFirstComponentChild(slot);
-          const componentOptions = vnode && vnode.componentOptions;
-          if (componentOptions) {
-              // check pattern
-              const name = getComponentName(componentOptions);
-              const { include, exclude } = this;
-              if (
-              // not included
-              (include && (!name || !matches(include, name))) ||
-                  // excluded
-                  (exclude && name && matches(exclude, name))) {
-                  return vnode;
-              }
-              const { cache, keys } = this;
-              const key = vnode.key == null
-                  ? // same constructor may get registered as different local components
-                      // so cid alone is not enough (#3269)
-                      componentOptions.Ctor.cid +
-                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                  : vnode.key;
-              if (cache[key]) {
-                  vnode.componentInstance = cache[key].componentInstance;
-                  // make current key freshest
-                  remove$2(keys, key);
-                  keys.push(key);
-              }
-              else {
-                  // delay setting the cache until update
-                  this.vnodeToCache = vnode;
-                  this.keyToCache = key;
-              }
-              // @ts-expect-error can vnode.data can be undefined
-              vnode.data.keepAlive = true;
-          }
-          return vnode || (slot && slot[0]);
-      },
+  /* @flow */
+  function getComponentName(opts) {
+      return opts && (opts.Ctor.options.name || opts.tag);
+  }
+  function matches(pattern, name) {
+      if (Array.isArray(pattern)) {
+          return pattern.indexOf(name) > -1;
+      }
+      else if (typeof pattern === "string") {
+          return pattern.split(",").indexOf(name) > -1;
+      }
+      else if (isRegExp(pattern)) {
+          return pattern.test(name);
+      }
+      /* istanbul ignore next */
+      return false;
+  }
+  function pruneCache(keepAliveInstance, filter) {
+      const { cache, keys, _vnode } = keepAliveInstance;
+      for (const key in cache) {
+          const entry = cache[key];
+          if (entry) {
+              const name = entry.name;
+              if (name && !filter(name)) {
+                  pruneCacheEntry(cache, key, keys, _vnode);
+              }
+          }
+      }
+  }
+  function pruneCacheEntry(cache, key, keys, current) {
+      const entry = cache[key];
+      if (entry && (!current || entry.tag !== current.tag)) {
+          // @ts-expect-error can be undefined
+          entry.componentInstance.$destroy();
+      }
+      cache[key] = null;
+      remove$2(keys, key);
+  }
+  const patternTypes = [String, RegExp, Array];
+  // TODO defineComponent
+  var KeepAlive = {
+      name: "keep-alive",
+      abstract: true,
+      props: {
+          include: patternTypes,
+          exclude: patternTypes,
+          max: [String, Number],
+      },
+      methods: {
+          cacheVNode() {
+              const { cache, keys, vnodeToCache, keyToCache } = this;
+              if (vnodeToCache) {
+                  const { tag, componentInstance, componentOptions } = vnodeToCache;
+                  cache[keyToCache] = {
+                      name: getComponentName(componentOptions),
+                      tag,
+                      componentInstance,
+                  };
+                  keys.push(keyToCache);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+                  this.vnodeToCache = null;
+              }
+          },
+      },
+      created() {
+          this.cache = Object.create(null);
+          this.keys = [];
+      },
+      destroyed() {
+          for (const key in this.cache) {
+              pruneCacheEntry(this.cache, key, this.keys);
+          }
+      },
+      mounted() {
+          this.cacheVNode();
+          this.$watch("include", (val) => {
+              pruneCache(this, (name) => matches(val, name));
+          });
+          this.$watch("exclude", (val) => {
+              pruneCache(this, (name) => !matches(val, name));
+          });
+      },
+      updated() {
+          this.cacheVNode();
+      },
+      render() {
+          const slot = this.$slots.default;
+          const vnode = getFirstComponentChild(slot);
+          const componentOptions = vnode && vnode.componentOptions;
+          if (componentOptions) {
+              // check pattern
+              const name = getComponentName(componentOptions);
+              const { include, exclude } = this;
+              if (
+              // not included
+              (include && (!name || !matches(include, name))) ||
+                  // excluded
+                  (exclude && name && matches(exclude, name))) {
+                  return vnode;
+              }
+              const { cache, keys } = this;
+              const key = vnode.key == null
+                  ? // same constructor may get registered as different local components
+                      // so cid alone is not enough (#3269)
+                      componentOptions.Ctor.cid +
+                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                  : vnode.key;
+              if (cache[key]) {
+                  vnode.componentInstance = cache[key].componentInstance;
+                  // make current key freshest
+                  remove$2(keys, key);
+                  keys.push(key);
+              }
+              else {
+                  // delay setting the cache until update
+                  this.vnodeToCache = vnode;
+                  this.keyToCache = key;
+              }
+              // @ts-expect-error can vnode.data can be undefined
+              vnode.data.keepAlive = true;
+          }
+          return vnode || (slot && slot[0]);
+      },
   };
 
-  var builtInComponents = {
-      KeepAlive,
+  var builtInComponents = {
+      KeepAlive,
   };
 
-  function initGlobalAPI(Vue) {
-      // config
-      const configDef = {};
-      configDef.get = () => config;
-      {
-          configDef.set = () => {
-              warn$2('Do not replace the Vue.config object, set individual fields instead.');
-          };
-      }
-      Object.defineProperty(Vue, 'config', configDef);
-      // exposed util methods.
-      // NOTE: these are not considered part of the public API - avoid relying on
-      // them unless you are aware of the risk.
-      Vue.util = {
-          warn: warn$2,
-          extend,
-          mergeOptions,
-          defineReactive,
-      };
-      Vue.set = set;
-      Vue.delete = del;
-      Vue.nextTick = nextTick;
-      // 2.6 explicit observable API
-      Vue.observable = (obj) => {
-          observe(obj);
-          return obj;
-      };
-      Vue.options = Object.create(null);
-      ASSET_TYPES.forEach((type) => {
-          Vue.options[type + 's'] = Object.create(null);
-      });
-      // this is used to identify the "base" constructor to extend all plain-object
-      // components with in Weex's multi-instance scenarios.
-      Vue.options._base = Vue;
-      extend(Vue.options.components, builtInComponents);
-      initUse(Vue);
-      initMixin(Vue);
-      initExtend(Vue);
-      initAssetRegisters(Vue);
+  function initGlobalAPI(Vue) {
+      // config
+      const configDef = {};
+      configDef.get = () => config;
+      {
+          configDef.set = () => {
+              warn$2('Do not replace the Vue.config object, set individual fields instead.');
+          };
+      }
+      Object.defineProperty(Vue, 'config', configDef);
+      // exposed util methods.
+      // NOTE: these are not considered part of the public API - avoid relying on
+      // them unless you are aware of the risk.
+      Vue.util = {
+          warn: warn$2,
+          extend,
+          mergeOptions,
+          defineReactive,
+      };
+      Vue.set = set;
+      Vue.delete = del;
+      Vue.nextTick = nextTick;
+      // 2.6 explicit observable API
+      Vue.observable = (obj) => {
+          observe(obj);
+          return obj;
+      };
+      Vue.options = Object.create(null);
+      ASSET_TYPES.forEach((type) => {
+          Vue.options[type + 's'] = Object.create(null);
+      });
+      // this is used to identify the "base" constructor to extend all plain-object
+      // components with in Weex's multi-instance scenarios.
+      Vue.options._base = Vue;
+      extend(Vue.options.components, builtInComponents);
+      initUse(Vue);
+      initMixin(Vue);
+      initExtend(Vue);
+      initAssetRegisters(Vue);
   }
 
-  initGlobalAPI(Vue);
-  Object.defineProperty(Vue.prototype, '$isServer', {
-      get: isServerRendering,
-  });
-  Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get() {
-          /* istanbul ignore next */
-          return this.$vnode && this.$vnode.ssrContext;
-      },
-  });
-  // expose FunctionalRenderContext for ssr runtime helper installation
-  Object.defineProperty(Vue, 'FunctionalRenderContext', {
-      value: FunctionalRenderContext,
-  });
+  initGlobalAPI(Vue);
+  Object.defineProperty(Vue.prototype, '$isServer', {
+      get: isServerRendering,
+  });
+  Object.defineProperty(Vue.prototype, '$ssrContext', {
+      get() {
+          /* istanbul ignore next */
+          return this.$vnode && this.$vnode.ssrContext;
+      },
+  });
+  // expose FunctionalRenderContext for ssr runtime helper installation
+  Object.defineProperty(Vue, 'FunctionalRenderContext', {
+      value: FunctionalRenderContext,
+  });
   Vue.version = '2.6.14';
 
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  const isReservedAttr = makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const xlinkNS = 'http://www.w3.org/1999/xlink';
-  const isXlink = (name) => {
-      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-  };
-  const getXlinkProp = (name) => {
-      return isXlink(name) ? name.slice(6, name.length) : '';
-  };
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  const isReservedAttr = makeMap('style,class');
+  // attributes that should be using props for binding
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
+  };
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
+  };
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+  const xlinkNS = 'http://www.w3.org/1999/xlink';
+  const isXlink = (name) => {
+      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+  };
+  const getXlinkProp = (name) => {
+      return isXlink(name) ? name.slice(6, name.length) : '';
+  };
+  const isFalsyAttrValue = (val) => {
+      return val == null || val === false;
   };
 
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
+  function genClassForVnode(vnode) {
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass(data.staticClass, data.class);
+  }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
+  }
+  function renderClass(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
+  }
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function stringifyArray(value) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  res += ' ';
+              res += stringified;
+          }
+      }
+      return res;
+  }
+  function stringifyObject(value) {
+      let res = '';
+      for (const key in value) {
+          if (value[key]) {
+              if (res)
+                  res += ' ';
+              res += key;
+          }
+      }
+      return res;
   }
 
-  const namespaceMap = {
-      svg: 'http://www.w3.org/2000/svg',
-      math: 'http://www.w3.org/1998/Math/MathML',
-  };
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isPreTag = (tag) => tag === 'pre';
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
-  const unknownElementCache = Object.create(null);
-  function isUnknownElement(tag) {
-      /* istanbul ignore if */
-      if (!inBrowser) {
-          return true;
-      }
-      if (isReservedTag(tag)) {
-          return false;
-      }
-      tag = tag.toLowerCase();
-      /* istanbul ignore if */
-      if (unknownElementCache[tag] != null) {
-          return unknownElementCache[tag];
-      }
-      const el = document.createElement(tag);
-      if (tag.indexOf('-') > -1) {
-          // http://stackoverflow.com/a/28210364/1070244
-          return (unknownElementCache[tag] =
-              el.constructor === window.HTMLUnknownElement ||
-                  el.constructor === window.HTMLElement);
-      }
-      else {
-          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-      }
-  }
+  const namespaceMap = {
+      svg: 'http://www.w3.org/2000/svg',
+      math: 'http://www.w3.org/1998/Math/MathML',
+  };
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
+  // this map is intentionally selective, only covering SVG elements that may
+  // contain child elements.
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  const isPreTag = (tag) => tag === 'pre';
+  const isReservedTag = (tag) => {
+      return isHTMLTag(tag) || isSVG(tag);
+  };
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
+  }
+  const unknownElementCache = Object.create(null);
+  function isUnknownElement(tag) {
+      /* istanbul ignore if */
+      if (!inBrowser) {
+          return true;
+      }
+      if (isReservedTag(tag)) {
+          return false;
+      }
+      tag = tag.toLowerCase();
+      /* istanbul ignore if */
+      if (unknownElementCache[tag] != null) {
+          return unknownElementCache[tag];
+      }
+      const el = document.createElement(tag);
+      if (tag.indexOf('-') > -1) {
+          // http://stackoverflow.com/a/28210364/1070244
+          return (unknownElementCache[tag] =
+              el.constructor === window.HTMLUnknownElement ||
+                  el.constructor === window.HTMLElement);
+      }
+      else {
+          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+      }
+  }
   const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /**
-   * Query an element selector if it's not an element already.
-   */
-  function query(el) {
-      if (typeof el === 'string') {
-          const selected = document.querySelector(el);
-          if (!selected) {
-              warn$2('Cannot find element: ' + el);
-              return document.createElement('div');
-          }
-          return selected;
-      }
-      else {
-          return el;
-      }
+  /**
+   * Query an element selector if it's not an element already.
+   */
+  function query(el) {
+      if (typeof el === 'string') {
+          const selected = document.querySelector(el);
+          if (!selected) {
+              warn$2('Cannot find element: ' + el);
+              return document.createElement('div');
+          }
+          return selected;
+      }
+      else {
+          return el;
+      }
   }
 
-  function createElement(tagName, vnode) {
-      const elm = document.createElement(tagName);
-      if (tagName !== 'select') {
-          return elm;
-      }
-      // false or null will remove the attribute but undefined will not
-      if (vnode.data &&
-          vnode.data.attrs &&
-          vnode.data.attrs.multiple !== undefined) {
-          elm.setAttribute('multiple', 'multiple');
-      }
-      return elm;
-  }
-  function createElementNS(namespace, tagName) {
-      return document.createElementNS(namespaceMap[namespace], tagName);
-  }
-  function createTextNode(text) {
-      return document.createTextNode(text);
-  }
-  function createComment(text) {
-      return document.createComment(text);
-  }
-  function insertBefore(parentNode, newNode, referenceNode) {
-      parentNode.insertBefore(newNode, referenceNode);
-  }
-  function removeChild(node, child) {
-      node.removeChild(child);
-  }
-  function appendChild(node, child) {
-      node.appendChild(child);
-  }
-  function parentNode(node) {
-      return node.parentNode;
-  }
-  function nextSibling(node) {
-      return node.nextSibling;
-  }
-  function tagName(node) {
-      return node.tagName;
-  }
-  function setTextContent(node, text) {
-      node.textContent = text;
-  }
-  function setStyleScope(node, scopeId) {
-      node.setAttribute(scopeId, '');
+  function createElement(tagName, vnode) {
+      const elm = document.createElement(tagName);
+      if (tagName !== 'select') {
+          return elm;
+      }
+      // false or null will remove the attribute but undefined will not
+      if (vnode.data &&
+          vnode.data.attrs &&
+          vnode.data.attrs.multiple !== undefined) {
+          elm.setAttribute('multiple', 'multiple');
+      }
+      return elm;
+  }
+  function createElementNS(namespace, tagName) {
+      return document.createElementNS(namespaceMap[namespace], tagName);
+  }
+  function createTextNode(text) {
+      return document.createTextNode(text);
+  }
+  function createComment(text) {
+      return document.createComment(text);
+  }
+  function insertBefore(parentNode, newNode, referenceNode) {
+      parentNode.insertBefore(newNode, referenceNode);
+  }
+  function removeChild(node, child) {
+      node.removeChild(child);
+  }
+  function appendChild(node, child) {
+      node.appendChild(child);
+  }
+  function parentNode(node) {
+      return node.parentNode;
+  }
+  function nextSibling(node) {
+      return node.nextSibling;
+  }
+  function tagName(node) {
+      return node.tagName;
+  }
+  function setTextContent(node, text) {
+      node.textContent = text;
+  }
+  function setStyleScope(node, scopeId) {
+      node.setAttribute(scopeId, '');
   }
 
   var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5017,5440 +5014,5439 @@
     setStyleScope: setStyleScope
   });
 
-  var ref = {
-      create(_, vnode) {
-          registerRef(vnode);
-      },
-      update(oldVnode, vnode) {
-          if (oldVnode.data.ref !== vnode.data.ref) {
-              registerRef(oldVnode, true);
-              registerRef(vnode);
-          }
-      },
-      destroy(vnode) {
-          registerRef(vnode, true);
-      },
-  };
-  function registerRef(vnode, isRemoval) {
-      const key = vnode.data.ref;
-      if (!isDef(key))
-          return;
-      const vm = vnode.context;
-      const ref = vnode.componentInstance || vnode.elm;
-      const refs = vm.$refs;
-      const obj = refs[key];
-      if (isRemoval) {
-          if (Array.isArray(obj)) {
-              remove$2(obj, ref);
-          }
-          else if (obj === ref) {
-              refs[key] = undefined;
-          }
-      }
-      else {
-          if (vnode.data.refInFor) {
-              if (!Array.isArray(obj)) {
-                  refs[key] = [ref];
-              }
-              else if (obj.indexOf(ref) < 0) {
-                  obj.push(ref);
-              }
-          }
-          else {
-              refs[key] = ref;
-          }
-      }
+  var ref = {
+      create(_, vnode) {
+          registerRef(vnode);
+      },
+      update(oldVnode, vnode) {
+          if (oldVnode.data.ref !== vnode.data.ref) {
+              registerRef(oldVnode, true);
+              registerRef(vnode);
+          }
+      },
+      destroy(vnode) {
+          registerRef(vnode, true);
+      },
+  };
+  function registerRef(vnode, isRemoval) {
+      const key = vnode.data.ref;
+      if (!isDef(key))
+          return;
+      const vm = vnode.context;
+      const ref = vnode.componentInstance || vnode.elm;
+      const refs = vm.$refs;
+      const obj = refs[key];
+      if (isRemoval) {
+          if (Array.isArray(obj)) {
+              remove$2(obj, ref);
+          }
+          else if (obj === ref) {
+              refs[key] = undefined;
+          }
+      }
+      else {
+          if (vnode.data.refInFor) {
+              if (!Array.isArray(obj)) {
+                  refs[key] = [ref];
+              }
+              else if (obj.indexOf(ref) < 0) {
+                  obj.push(ref);
+              }
+          }
+          else {
+              refs[key] = ref;
+          }
+      }
   }
 
-  /**
-   * Virtual DOM patching algorithm based on Snabbdom by
-   * Simon Friis Vindum (@paldepind)
-   * Licensed under the MIT License
-   * https://github.com/paldepind/snabbdom/blob/master/LICENSE
-   *
-   * modified by Evan You (@yyx990803)
-   *
-   * Not type-checking this because this file is perf-critical and the cost
-   * of making flow understand it is not worth it.
-   */
-  const emptyNode = new VNode('', {}, []);
-  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-  function sameVnode(a, b) {
-      return (a.key === b.key &&
-          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-          a.isComment === b.isComment &&
-          isDef(a.data) === isDef(b.data) &&
-          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-          isUndef(b.asyncFactory.error))));
-  }
-  function sameInputType(a, b) {
-      if (a.tag !== 'input')
-          return true;
-      let i;
-      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-  }
-  function createKeyToOldIdx(children, beginIdx, endIdx) {
-      let i, key;
-      const map = {};
-      for (i = beginIdx; i <= endIdx; ++i) {
-          key = children[i].key;
-          if (isDef(key))
-              map[key] = i;
-      }
-      return map;
-  }
-  function createPatchFunction(backend) {
-      let i, j;
-      const cbs = {};
-      const { modules, nodeOps } = backend;
-      for (i = 0; i < hooks.length; ++i) {
-          cbs[hooks[i]] = [];
-          for (j = 0; j < modules.length; ++j) {
-              if (isDef(modules[j][hooks[i]])) {
-                  cbs[hooks[i]].push(modules[j][hooks[i]]);
-              }
-          }
-      }
-      function emptyNodeAt(elm) {
-          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-      }
-      function createRmCb(childElm, listeners) {
-          function remove() {
-              if (--remove.listeners === 0) {
-                  removeNode(childElm);
-              }
-          }
-          remove.listeners = listeners;
-          return remove;
-      }
-      function removeNode(el) {
-          const parent = nodeOps.parentNode(el);
-          // element may have already been removed due to v-html / v-text
-          if (isDef(parent)) {
-              nodeOps.removeChild(parent, el);
-          }
-      }
-      function isUnknownElement(vnode, inVPre) {
-          return (!inVPre &&
-              !vnode.ns &&
-              !(config.ignoredElements.length &&
-                  config.ignoredElements.some((ignore) => {
-                      return isRegExp(ignore)
-                          ? ignore.test(vnode.tag)
-                          : ignore === vnode.tag;
-                  })) &&
-              config.isUnknownElement(vnode.tag));
-      }
-      let creatingElmInVPre = 0;
-      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // This vnode was used in a previous render!
-              // now it's used as a new node, overwriting its elm would cause
-              // potential patch errors down the road when it's used as an insertion
-              // reference node. Instead, we clone the node on-demand before creating
-              // associated DOM element for it.
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          vnode.isRootInsert = !nested; // for transition enter check
-          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-              return;
-          }
-          const data = vnode.data;
-          const children = vnode.children;
-          const tag = vnode.tag;
-          if (isDef(tag)) {
-              {
-                  if (data && data.pre) {
-                      creatingElmInVPre++;
-                  }
-                  if (isUnknownElement(vnode, creatingElmInVPre)) {
-                      warn$2('Unknown custom element: <' +
-                          tag +
-                          '> - did you ' +
-                          'register the component correctly? For recursive components, ' +
-                          'make sure to provide the "name" option.', vnode.context);
-                  }
-              }
-              vnode.elm = vnode.ns
-                  ? nodeOps.createElementNS(vnode.ns, tag)
-                  : nodeOps.createElement(tag, vnode);
-              setScope(vnode);
-              /* istanbul ignore if */
-              {
-                  createChildren(vnode, children, insertedVnodeQueue);
-                  if (isDef(data)) {
-                      invokeCreateHooks(vnode, insertedVnodeQueue);
-                  }
-                  insert(parentElm, vnode.elm, refElm);
-              }
-              if (data && data.pre) {
-                  creatingElmInVPre--;
-              }
-          }
-          else if (isTrue(vnode.isComment)) {
-              vnode.elm = nodeOps.createComment(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-          else {
-              vnode.elm = nodeOps.createTextNode(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-      }
-      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i = vnode.data;
-          if (isDef(i)) {
-              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-              if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                  i(vnode, false /* hydrating */);
-              }
-              // after calling the init hook, if the vnode is a child component
-              // it should've created a child instance and mounted it. the child
-              // component also has set the placeholder vnode's elm.
-              // in that case we can just return the element and be done.
-              if (isDef(vnode.componentInstance)) {
-                  initComponent(vnode, insertedVnodeQueue);
-                  insert(parentElm, vnode.elm, refElm);
-                  if (isTrue(isReactivated)) {
-                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                  }
-                  return true;
-              }
-          }
-      }
-      function initComponent(vnode, insertedVnodeQueue) {
-          if (isDef(vnode.data.pendingInsert)) {
-              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-              vnode.data.pendingInsert = null;
-          }
-          vnode.elm = vnode.componentInstance.$el;
-          if (isPatchable(vnode)) {
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              setScope(vnode);
-          }
-          else {
-              // empty component root.
-              // skip all element-related modules except for ref (#3455)
-              registerRef(vnode);
-              // make sure to invoke the insert hook
-              insertedVnodeQueue.push(vnode);
-          }
-      }
-      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i;
-          // hack for #4339: a reactivated component with inner transition
-          // does not trigger because the inner node's created hooks are not called
-          // again. It's not ideal to involve module-specific logic in here but
-          // there doesn't seem to be a better way to do it.
-          let innerNode = vnode;
-          while (innerNode.componentInstance) {
-              innerNode = innerNode.componentInstance._vnode;
-              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                  for (i = 0; i < cbs.activate.length; ++i) {
-                      cbs.activate[i](emptyNode, innerNode);
-                  }
-                  insertedVnodeQueue.push(innerNode);
-                  break;
-              }
-          }
-          // unlike a newly created component,
-          // a reactivated keep-alive component doesn't insert itself
-          insert(parentElm, vnode.elm, refElm);
-      }
-      function insert(parent, elm, ref) {
-          if (isDef(parent)) {
-              if (isDef(ref)) {
-                  if (nodeOps.parentNode(ref) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref);
-                  }
-              }
-              else {
-                  nodeOps.appendChild(parent, elm);
-              }
-          }
-      }
-      function createChildren(vnode, children, insertedVnodeQueue) {
-          if (Array.isArray(children)) {
-              {
-                  checkDuplicateKeys(children);
-              }
-              for (let i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-              }
-          }
-          else if (isPrimitive(vnode.text)) {
-              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-          }
-      }
-      function isPatchable(vnode) {
-          while (vnode.componentInstance) {
-              vnode = vnode.componentInstance._vnode;
-          }
-          return isDef(vnode.tag);
-      }
-      function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (let i = 0; i < cbs.create.length; ++i) {
-              cbs.create[i](emptyNode, vnode);
-          }
-          i = vnode.data.hook; // Reuse variable
-          if (isDef(i)) {
-              if (isDef(i.create))
-                  i.create(emptyNode, vnode);
-              if (isDef(i.insert))
-                  insertedVnodeQueue.push(vnode);
-          }
-      }
-      // set scope id attribute for scoped CSS.
-      // this is implemented as a special case to avoid the overhead
-      // of going through the normal attribute patching process.
-      function setScope(vnode) {
-          let i;
-          if (isDef((i = vnode.fnScopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-          else {
-              let ancestor = vnode;
-              while (ancestor) {
-                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                      nodeOps.setStyleScope(vnode.elm, i);
-                  }
-                  ancestor = ancestor.parent;
-              }
-          }
-          // for slot content they should also get the scopeId from the host instance.
-          if (isDef((i = activeInstance)) &&
-              i !== vnode.context &&
-              i !== vnode.fnContext &&
-              isDef((i = i.$options._scopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-      }
-      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-          }
-      }
-      function invokeDestroyHook(vnode) {
-          let i, j;
-          const data = vnode.data;
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  i(vnode);
-              for (i = 0; i < cbs.destroy.length; ++i)
-                  cbs.destroy[i](vnode);
-          }
-          if (isDef((i = vnode.children))) {
-              for (j = 0; j < vnode.children.length; ++j) {
-                  invokeDestroyHook(vnode.children[j]);
-              }
-          }
-      }
-      function removeVnodes(vnodes, startIdx, endIdx) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              const ch = vnodes[startIdx];
-              if (isDef(ch)) {
-                  if (isDef(ch.tag)) {
-                      removeAndInvokeRemoveHook(ch);
-                      invokeDestroyHook(ch);
-                  }
-                  else {
-                      // Text node
-                      removeNode(ch.elm);
-                  }
-              }
-          }
-      }
-      function removeAndInvokeRemoveHook(vnode, rm) {
-          if (isDef(rm) || isDef(vnode.data)) {
-              let i;
-              const listeners = cbs.remove.length + 1;
-              if (isDef(rm)) {
-                  // we have a recursively passed down rm callback
-                  // increase the listeners count
-                  rm.listeners += listeners;
-              }
-              else {
-                  // directly removing
-                  rm = createRmCb(vnode.elm, listeners);
-              }
-              // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
-              }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
-              }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          }
-          else {
-              removeNode(vnode.elm);
-          }
-      }
-      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          let oldStartIdx = 0;
-          let newStartIdx = 0;
-          let oldEndIdx = oldCh.length - 1;
-          let oldStartVnode = oldCh[0];
-          let oldEndVnode = oldCh[oldEndIdx];
-          let newEndIdx = newCh.length - 1;
-          let newStartVnode = newCh[0];
-          let newEndVnode = newCh[newEndIdx];
-          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-          // removeOnly is a special flag used only by <transition-group>
-          // to ensure removed elements stay in correct relative positions
-          // during leaving transitions
-          const canMove = !removeOnly;
-          {
-              checkDuplicateKeys(newCh);
-          }
-          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-              if (isUndef(oldStartVnode)) {
-                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-              }
-              else if (isUndef(oldEndVnode)) {
-                  oldEndVnode = oldCh[--oldEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newStartVnode)) {
-                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else if (sameVnode(oldEndVnode, newEndVnode)) {
-                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newEndVnode)) {
-                  // Vnode moved right
-                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldEndVnode, newStartVnode)) {
-                  // Vnode moved left
-                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else {
-                  if (isUndef(oldKeyToIdx))
-                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                  idxInOld = isDef(newStartVnode.key)
-                      ? oldKeyToIdx[newStartVnode.key]
-                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                  if (isUndef(idxInOld)) {
-                      // New element
-                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                  }
-                  else {
-                      vnodeToMove = oldCh[idxInOld];
-                      if (sameVnode(vnodeToMove, newStartVnode)) {
-                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                          oldCh[idxInOld] = undefined;
-                          canMove &&
-                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                      }
-                      else {
-                          // same key but different element. treat as new element
-                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                      }
-                  }
-                  newStartVnode = newCh[++newStartIdx];
-              }
-          }
-          if (oldStartIdx > oldEndIdx) {
-              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-          }
-          else if (newStartIdx > newEndIdx) {
-              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-          }
-      }
-      function checkDuplicateKeys(children) {
-          const seenKeys = {};
-          for (let i = 0; i < children.length; i++) {
-              const vnode = children[i];
-              const key = vnode.key;
-              if (isDef(key)) {
-                  if (seenKeys[key]) {
-                      warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                  }
-                  else {
-                      seenKeys[key] = true;
-                  }
-              }
-          }
-      }
-      function findIdxInOld(node, oldCh, start, end) {
-          for (let i = start; i < end; i++) {
-              const c = oldCh[i];
-              if (isDef(c) && sameVnode(node, c))
-                  return i;
-          }
-      }
-      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-          if (oldVnode === vnode) {
-              return;
-          }
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // clone reused vnode
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          const elm = (vnode.elm = oldVnode.elm);
-          if (isTrue(oldVnode.isAsyncPlaceholder)) {
-              if (isDef(vnode.asyncFactory.resolved)) {
-                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-              }
-              else {
-                  vnode.isAsyncPlaceholder = true;
-              }
-              return;
-          }
-          // reuse element for static trees.
-          // note we only do this if the vnode is cloned -
-          // if the new node is not cloned it means the render functions have been
-          // reset by the hot-reload-api and we need to do a proper re-render.
-          if (isTrue(vnode.isStatic) &&
-              isTrue(oldVnode.isStatic) &&
-              vnode.key === oldVnode.key &&
-              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-              vnode.componentInstance = oldVnode.componentInstance;
-              return;
-          }
-          let i;
-          const data = vnode.data;
-          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-              i(oldVnode, vnode);
-          }
-          const oldCh = oldVnode.children;
-          const ch = vnode.children;
-          if (isDef(data) && isPatchable(vnode)) {
-              for (i = 0; i < cbs.update.length; ++i)
-                  cbs.update[i](oldVnode, vnode);
-              if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  i(oldVnode, vnode);
-          }
-          if (isUndef(vnode.text)) {
-              if (isDef(oldCh) && isDef(ch)) {
-                  if (oldCh !== ch)
-                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-              }
-              else if (isDef(ch)) {
-                  {
-                      checkDuplicateKeys(ch);
-                  }
-                  if (isDef(oldVnode.text))
-                      nodeOps.setTextContent(elm, '');
-                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-              }
-              else if (isDef(oldCh)) {
-                  removeVnodes(oldCh, 0, oldCh.length - 1);
-              }
-              else if (isDef(oldVnode.text)) {
-                  nodeOps.setTextContent(elm, '');
-              }
-          }
-          else if (oldVnode.text !== vnode.text) {
-              nodeOps.setTextContent(elm, vnode.text);
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  i(oldVnode, vnode);
-          }
-      }
-      function invokeInsertHook(vnode, queue, initial) {
-          // delay insert hooks for component root nodes, invoke them after the
-          // element is really inserted
-          if (isTrue(initial) && isDef(vnode.parent)) {
-              vnode.parent.data.pendingInsert = queue;
-          }
-          else {
-              for (let i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
-              }
-          }
-      }
-      let hydrationBailed = false;
-      // list of modules that can skip create hook during hydration because they
-      // are already rendered on the client or has no need for initialization
-      // Note: style is excluded because it relies on initial clone for future
-      // deep updates (#7063).
-      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-      // Note: this is a browser-only function so we can assume elms are DOM nodes.
-      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          let i;
-          const { tag, data, children } = vnode;
-          inVPre = inVPre || (data && data.pre);
-          vnode.elm = elm;
-          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-              vnode.isAsyncPlaceholder = true;
-              return true;
-          }
-          // assert node match
-          {
-              if (!assertNodeMatch(elm, vnode, inVPre)) {
-                  return false;
-              }
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  i(vnode, true /* hydrating */);
-              if (isDef((i = vnode.componentInstance))) {
-                  // child component. it should have hydrated its own tree.
-                  initComponent(vnode, insertedVnodeQueue);
-                  return true;
-              }
-          }
-          if (isDef(tag)) {
-              if (isDef(children)) {
-                  // empty element, allow client to pick up and populate children
-                  if (!elm.hasChildNodes()) {
-                      createChildren(vnode, children, insertedVnodeQueue);
-                  }
-                  else {
-                      // v-html and domProps: innerHTML
-                      if (isDef((i = data)) &&
-                          isDef((i = i.domProps)) &&
-                          isDef((i = i.innerHTML))) {
-                          if (i !== elm.innerHTML) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('server innerHTML: ', i);
-                                  console.warn('client innerHTML: ', elm.innerHTML);
-                              }
-                              return false;
-                          }
-                      }
-                      else {
-                          // iterate and compare children lists
-                          let childrenMatch = true;
-                          let childNode = elm.firstChild;
-                          for (let i = 0; i < children.length; i++) {
-                              if (!childNode ||
-                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                  childrenMatch = false;
-                                  break;
-                              }
-                              childNode = childNode.nextSibling;
-                          }
-                          // if childNode is not null, it means the actual childNodes list is
-                          // longer than the virtual children list.
-                          if (!childrenMatch || childNode) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                              }
-                              return false;
-                          }
-                      }
-                  }
-              }
-              if (isDef(data)) {
-                  let fullInvoke = false;
-                  for (const key in data) {
-                      if (!isRenderedModule(key)) {
-                          fullInvoke = true;
-                          invokeCreateHooks(vnode, insertedVnodeQueue);
-                          break;
-                      }
-                  }
-                  if (!fullInvoke && data['class']) {
-                      // ensure collecting deps for deep class bindings for future updates
-                      traverse(data['class']);
-                  }
-              }
-          }
-          else if (elm.data !== vnode.text) {
-              elm.data = vnode.text;
-          }
-          return true;
-      }
-      function assertNodeMatch(node, vnode, inVPre) {
-          if (isDef(vnode.tag)) {
-              return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement(vnode, inVPre) &&
-                      vnode.tag.toLowerCase() ===
-                          (node.tagName && node.tagName.toLowerCase())));
-          }
-          else {
-              return node.nodeType === (vnode.isComment ? 8 : 3);
-          }
-      }
-      return function patch(oldVnode, vnode, hydrating, removeOnly) {
-          if (isUndef(vnode)) {
-              if (isDef(oldVnode))
-                  invokeDestroyHook(oldVnode);
-              return;
-          }
-          let isInitialPatch = false;
-          const insertedVnodeQueue = [];
-          if (isUndef(oldVnode)) {
-              // empty mount (likely as component), create new root element
-              isInitialPatch = true;
-              createElm(vnode, insertedVnodeQueue);
-          }
-          else {
-              const isRealElement = isDef(oldVnode.nodeType);
-              if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                  // patch existing root node
-                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-              }
-              else {
-                  if (isRealElement) {
-                      // mounting to a real element
-                      // check if this is server-rendered content and if we can perform
-                      // a successful hydration.
-                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                          oldVnode.removeAttribute(SSR_ATTR);
-                          hydrating = true;
-                      }
-                      if (isTrue(hydrating)) {
-                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                              invokeInsertHook(vnode, insertedVnodeQueue, true);
-                              return oldVnode;
-                          }
-                          else {
-                              warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                  'server-rendered content. This is likely caused by incorrect ' +
-                                  'HTML markup, for example nesting block-level elements inside ' +
-                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                  'full client-side render.');
-                          }
-                      }
-                      // either not server-rendered, or hydration failed.
-                      // create an empty node and replace it
-                      oldVnode = emptyNodeAt(oldVnode);
-                  }
-                  // replacing existing element
-                  const oldElm = oldVnode.elm;
-                  const parentElm = nodeOps.parentNode(oldElm);
-                  // create new node
-                  createElm(vnode, insertedVnodeQueue, 
-                  // extremely rare edge case: do not insert if old element is in a
-                  // leaving transition. Only happens when combining transition +
-                  // keep-alive + HOCs. (#4590)
-                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                  // update parent placeholder node element, recursively
-                  if (isDef(vnode.parent)) {
-                      let ancestor = vnode.parent;
-                      const patchable = isPatchable(vnode);
-                      while (ancestor) {
-                          for (let i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
-                          }
-                          ancestor.elm = vnode.elm;
-                          if (patchable) {
-                              for (let i = 0; i < cbs.create.length; ++i) {
-                                  cbs.create[i](emptyNode, ancestor);
-                              }
-                              // #6513
-                              // invoke insert hooks that may have been merged by create hooks.
-                              // e.g. for directives that uses the "inserted" hook.
-                              const insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
-                                  // start at index 1 to avoid re-invoking component mounted hook
-                                  for (let i = 1; i < insert.fns.length; i++) {
-                                      insert.fns[i]();
-                                  }
-                              }
-                          }
-                          else {
-                              registerRef(ancestor);
-                          }
-                          ancestor = ancestor.parent;
-                      }
-                  }
-                  // destroy old node
-                  if (isDef(parentElm)) {
-                      removeVnodes([oldVnode], 0, 0);
-                  }
-                  else if (isDef(oldVnode.tag)) {
-                      invokeDestroyHook(oldVnode);
-                  }
-              }
-          }
-          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-          return vnode.elm;
-      };
+  /**
+   * Virtual DOM patching algorithm based on Snabbdom by
+   * Simon Friis Vindum (@paldepind)
+   * Licensed under the MIT License
+   * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+   *
+   * modified by Evan You (@yyx990803)
+   *
+   * Not type-checking this because this file is perf-critical and the cost
+   * of making flow understand it is not worth it.
+   */
+  const emptyNode = new VNode('', {}, []);
+  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+  function sameVnode(a, b) {
+      return (a.key === b.key &&
+          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+          a.isComment === b.isComment &&
+          isDef(a.data) === isDef(b.data) &&
+          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+          isUndef(b.asyncFactory.error))));
+  }
+  function sameInputType(a, b) {
+      if (a.tag !== 'input')
+          return true;
+      let i;
+      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+  }
+  function createKeyToOldIdx(children, beginIdx, endIdx) {
+      let i, key;
+      const map = {};
+      for (i = beginIdx; i <= endIdx; ++i) {
+          key = children[i].key;
+          if (isDef(key))
+              map[key] = i;
+      }
+      return map;
+  }
+  function createPatchFunction(backend) {
+      let i, j;
+      const cbs = {};
+      const { modules, nodeOps } = backend;
+      for (i = 0; i < hooks.length; ++i) {
+          cbs[hooks[i]] = [];
+          for (j = 0; j < modules.length; ++j) {
+              if (isDef(modules[j][hooks[i]])) {
+                  cbs[hooks[i]].push(modules[j][hooks[i]]);
+              }
+          }
+      }
+      function emptyNodeAt(elm) {
+          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+      }
+      function createRmCb(childElm, listeners) {
+          function remove() {
+              if (--remove.listeners === 0) {
+                  removeNode(childElm);
+              }
+          }
+          remove.listeners = listeners;
+          return remove;
+      }
+      function removeNode(el) {
+          const parent = nodeOps.parentNode(el);
+          // element may have already been removed due to v-html / v-text
+          if (isDef(parent)) {
+              nodeOps.removeChild(parent, el);
+          }
+      }
+      function isUnknownElement(vnode, inVPre) {
+          return (!inVPre &&
+              !vnode.ns &&
+              !(config.ignoredElements.length &&
+                  config.ignoredElements.some((ignore) => {
+                      return isRegExp(ignore)
+                          ? ignore.test(vnode.tag)
+                          : ignore === vnode.tag;
+                  })) &&
+              config.isUnknownElement(vnode.tag));
+      }
+      let creatingElmInVPre = 0;
+      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // This vnode was used in a previous render!
+              // now it's used as a new node, overwriting its elm would cause
+              // potential patch errors down the road when it's used as an insertion
+              // reference node. Instead, we clone the node on-demand before creating
+              // associated DOM element for it.
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          vnode.isRootInsert = !nested; // for transition enter check
+          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+              return;
+          }
+          const data = vnode.data;
+          const children = vnode.children;
+          const tag = vnode.tag;
+          if (isDef(tag)) {
+              {
+                  if (data && data.pre) {
+                      creatingElmInVPre++;
+                  }
+                  if (isUnknownElement(vnode, creatingElmInVPre)) {
+                      warn$2('Unknown custom element: <' +
+                          tag +
+                          '> - did you ' +
+                          'register the component correctly? For recursive components, ' +
+                          'make sure to provide the "name" option.', vnode.context);
+                  }
+              }
+              vnode.elm = vnode.ns
+                  ? nodeOps.createElementNS(vnode.ns, tag)
+                  : nodeOps.createElement(tag, vnode);
+              setScope(vnode);
+              /* istanbul ignore if */
+              {
+                  createChildren(vnode, children, insertedVnodeQueue);
+                  if (isDef(data)) {
+                      invokeCreateHooks(vnode, insertedVnodeQueue);
+                  }
+                  insert(parentElm, vnode.elm, refElm);
+              }
+              if (data && data.pre) {
+                  creatingElmInVPre--;
+              }
+          }
+          else if (isTrue(vnode.isComment)) {
+              vnode.elm = nodeOps.createComment(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+          else {
+              vnode.elm = nodeOps.createTextNode(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+      }
+      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          let i = vnode.data;
+          if (isDef(i)) {
+              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                  i(vnode, false /* hydrating */);
+              }
+              // after calling the init hook, if the vnode is a child component
+              // it should've created a child instance and mounted it. the child
+              // component also has set the placeholder vnode's elm.
+              // in that case we can just return the element and be done.
+              if (isDef(vnode.componentInstance)) {
+                  initComponent(vnode, insertedVnodeQueue);
+                  insert(parentElm, vnode.elm, refElm);
+                  if (isTrue(isReactivated)) {
+                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                  }
+                  return true;
+              }
+          }
+      }
+      function initComponent(vnode, insertedVnodeQueue) {
+          if (isDef(vnode.data.pendingInsert)) {
+              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+              vnode.data.pendingInsert = null;
+          }
+          vnode.elm = vnode.componentInstance.$el;
+          if (isPatchable(vnode)) {
+              invokeCreateHooks(vnode, insertedVnodeQueue);
+              setScope(vnode);
+          }
+          else {
+              // empty component root.
+              // skip all element-related modules except for ref (#3455)
+              registerRef(vnode);
+              // make sure to invoke the insert hook
+              insertedVnodeQueue.push(vnode);
+          }
+      }
+      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          let i;
+          // hack for #4339: a reactivated component with inner transition
+          // does not trigger because the inner node's created hooks are not called
+          // again. It's not ideal to involve module-specific logic in here but
+          // there doesn't seem to be a better way to do it.
+          let innerNode = vnode;
+          while (innerNode.componentInstance) {
+              innerNode = innerNode.componentInstance._vnode;
+              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                  for (i = 0; i < cbs.activate.length; ++i) {
+                      cbs.activate[i](emptyNode, innerNode);
+                  }
+                  insertedVnodeQueue.push(innerNode);
+                  break;
+              }
+          }
+          // unlike a newly created component,
+          // a reactivated keep-alive component doesn't insert itself
+          insert(parentElm, vnode.elm, refElm);
+      }
+      function insert(parent, elm, ref) {
+          if (isDef(parent)) {
+              if (isDef(ref)) {
+                  if (nodeOps.parentNode(ref) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref);
+                  }
+              }
+              else {
+                  nodeOps.appendChild(parent, elm);
+              }
+          }
+      }
+      function createChildren(vnode, children, insertedVnodeQueue) {
+          if (Array.isArray(children)) {
+              {
+                  checkDuplicateKeys(children);
+              }
+              for (let i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              }
+          }
+          else if (isPrimitive(vnode.text)) {
+              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+          }
+      }
+      function isPatchable(vnode) {
+          while (vnode.componentInstance) {
+              vnode = vnode.componentInstance._vnode;
+          }
+          return isDef(vnode.tag);
+      }
+      function invokeCreateHooks(vnode, insertedVnodeQueue) {
+          for (let i = 0; i < cbs.create.length; ++i) {
+              cbs.create[i](emptyNode, vnode);
+          }
+          i = vnode.data.hook; // Reuse variable
+          if (isDef(i)) {
+              if (isDef(i.create))
+                  i.create(emptyNode, vnode);
+              if (isDef(i.insert))
+                  insertedVnodeQueue.push(vnode);
+          }
+      }
+      // set scope id attribute for scoped CSS.
+      // this is implemented as a special case to avoid the overhead
+      // of going through the normal attribute patching process.
+      function setScope(vnode) {
+          let i;
+          if (isDef((i = vnode.fnScopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+          else {
+              let ancestor = vnode;
+              while (ancestor) {
+                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                      nodeOps.setStyleScope(vnode.elm, i);
+                  }
+                  ancestor = ancestor.parent;
+              }
+          }
+          // for slot content they should also get the scopeId from the host instance.
+          if (isDef((i = activeInstance)) &&
+              i !== vnode.context &&
+              i !== vnode.fnContext &&
+              isDef((i = i.$options._scopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+      }
+      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+          }
+      }
+      function invokeDestroyHook(vnode) {
+          let i, j;
+          const data = vnode.data;
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                  i(vnode);
+              for (i = 0; i < cbs.destroy.length; ++i)
+                  cbs.destroy[i](vnode);
+          }
+          if (isDef((i = vnode.children))) {
+              for (j = 0; j < vnode.children.length; ++j) {
+                  invokeDestroyHook(vnode.children[j]);
+              }
+          }
+      }
+      function removeVnodes(vnodes, startIdx, endIdx) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              const ch = vnodes[startIdx];
+              if (isDef(ch)) {
+                  if (isDef(ch.tag)) {
+                      removeAndInvokeRemoveHook(ch);
+                      invokeDestroyHook(ch);
+                  }
+                  else {
+                      // Text node
+                      removeNode(ch.elm);
+                  }
+              }
+          }
+      }
+      function removeAndInvokeRemoveHook(vnode, rm) {
+          if (isDef(rm) || isDef(vnode.data)) {
+              let i;
+              const listeners = cbs.remove.length + 1;
+              if (isDef(rm)) {
+                  // we have a recursively passed down rm callback
+                  // increase the listeners count
+                  rm.listeners += listeners;
+              }
+              else {
+                  // directly removing
+                  rm = createRmCb(vnode.elm, listeners);
+              }
+              // recursively invoke hooks on child component root node
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
+              }
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
+              }
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          }
+          else {
+              removeNode(vnode.elm);
+          }
+      }
+      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+          let oldStartIdx = 0;
+          let newStartIdx = 0;
+          let oldEndIdx = oldCh.length - 1;
+          let oldStartVnode = oldCh[0];
+          let oldEndVnode = oldCh[oldEndIdx];
+          let newEndIdx = newCh.length - 1;
+          let newStartVnode = newCh[0];
+          let newEndVnode = newCh[newEndIdx];
+          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          // removeOnly is a special flag used only by <transition-group>
+          // to ensure removed elements stay in correct relative positions
+          // during leaving transitions
+          const canMove = !removeOnly;
+          {
+              checkDuplicateKeys(newCh);
+          }
+          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+              if (isUndef(oldStartVnode)) {
+                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+              }
+              else if (isUndef(oldEndVnode)) {
+                  oldEndVnode = oldCh[--oldEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newStartVnode)) {
+                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else if (sameVnode(oldEndVnode, newEndVnode)) {
+                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newEndVnode)) {
+                  // Vnode moved right
+                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldEndVnode, newStartVnode)) {
+                  // Vnode moved left
+                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else {
+                  if (isUndef(oldKeyToIdx))
+                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                  idxInOld = isDef(newStartVnode.key)
+                      ? oldKeyToIdx[newStartVnode.key]
+                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                  if (isUndef(idxInOld)) {
+                      // New element
+                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                  }
+                  else {
+                      vnodeToMove = oldCh[idxInOld];
+                      if (sameVnode(vnodeToMove, newStartVnode)) {
+                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                          oldCh[idxInOld] = undefined;
+                          canMove &&
+                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                      }
+                      else {
+                          // same key but different element. treat as new element
+                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                      }
+                  }
+                  newStartVnode = newCh[++newStartIdx];
+              }
+          }
+          if (oldStartIdx > oldEndIdx) {
+              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+          }
+          else if (newStartIdx > newEndIdx) {
+              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+          }
+      }
+      function checkDuplicateKeys(children) {
+          const seenKeys = {};
+          for (let i = 0; i < children.length; i++) {
+              const vnode = children[i];
+              const key = vnode.key;
+              if (isDef(key)) {
+                  if (seenKeys[key]) {
+                      warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                  }
+                  else {
+                      seenKeys[key] = true;
+                  }
+              }
+          }
+      }
+      function findIdxInOld(node, oldCh, start, end) {
+          for (let i = start; i < end; i++) {
+              const c = oldCh[i];
+              if (isDef(c) && sameVnode(node, c))
+                  return i;
+          }
+      }
+      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+          if (oldVnode === vnode) {
+              return;
+          }
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // clone reused vnode
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          const elm = (vnode.elm = oldVnode.elm);
+          if (isTrue(oldVnode.isAsyncPlaceholder)) {
+              if (isDef(vnode.asyncFactory.resolved)) {
+                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+              }
+              else {
+                  vnode.isAsyncPlaceholder = true;
+              }
+              return;
+          }
+          // reuse element for static trees.
+          // note we only do this if the vnode is cloned -
+          // if the new node is not cloned it means the render functions have been
+          // reset by the hot-reload-api and we need to do a proper re-render.
+          if (isTrue(vnode.isStatic) &&
+              isTrue(oldVnode.isStatic) &&
+              vnode.key === oldVnode.key &&
+              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+              vnode.componentInstance = oldVnode.componentInstance;
+              return;
+          }
+          let i;
+          const data = vnode.data;
+          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+              i(oldVnode, vnode);
+          }
+          const oldCh = oldVnode.children;
+          const ch = vnode.children;
+          if (isDef(data) && isPatchable(vnode)) {
+              for (i = 0; i < cbs.update.length; ++i)
+                  cbs.update[i](oldVnode, vnode);
+              if (isDef((i = data.hook)) && isDef((i = i.update)))
+                  i(oldVnode, vnode);
+          }
+          if (isUndef(vnode.text)) {
+              if (isDef(oldCh) && isDef(ch)) {
+                  if (oldCh !== ch)
+                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+              }
+              else if (isDef(ch)) {
+                  {
+                      checkDuplicateKeys(ch);
+                  }
+                  if (isDef(oldVnode.text))
+                      nodeOps.setTextContent(elm, '');
+                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+              }
+              else if (isDef(oldCh)) {
+                  removeVnodes(oldCh, 0, oldCh.length - 1);
+              }
+              else if (isDef(oldVnode.text)) {
+                  nodeOps.setTextContent(elm, '');
+              }
+          }
+          else if (oldVnode.text !== vnode.text) {
+              nodeOps.setTextContent(elm, vnode.text);
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                  i(oldVnode, vnode);
+          }
+      }
+      function invokeInsertHook(vnode, queue, initial) {
+          // delay insert hooks for component root nodes, invoke them after the
+          // element is really inserted
+          if (isTrue(initial) && isDef(vnode.parent)) {
+              vnode.parent.data.pendingInsert = queue;
+          }
+          else {
+              for (let i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
+              }
+          }
+      }
+      let hydrationBailed = false;
+      // list of modules that can skip create hook during hydration because they
+      // are already rendered on the client or has no need for initialization
+      // Note: style is excluded because it relies on initial clone for future
+      // deep updates (#7063).
+      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      // Note: this is a browser-only function so we can assume elms are DOM nodes.
+      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+          let i;
+          const { tag, data, children } = vnode;
+          inVPre = inVPre || (data && data.pre);
+          vnode.elm = elm;
+          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+              vnode.isAsyncPlaceholder = true;
+              return true;
+          }
+          // assert node match
+          {
+              if (!assertNodeMatch(elm, vnode, inVPre)) {
+                  return false;
+              }
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.init)))
+                  i(vnode, true /* hydrating */);
+              if (isDef((i = vnode.componentInstance))) {
+                  // child component. it should have hydrated its own tree.
+                  initComponent(vnode, insertedVnodeQueue);
+                  return true;
+              }
+          }
+          if (isDef(tag)) {
+              if (isDef(children)) {
+                  // empty element, allow client to pick up and populate children
+                  if (!elm.hasChildNodes()) {
+                      createChildren(vnode, children, insertedVnodeQueue);
+                  }
+                  else {
+                      // v-html and domProps: innerHTML
+                      if (isDef((i = data)) &&
+                          isDef((i = i.domProps)) &&
+                          isDef((i = i.innerHTML))) {
+                          if (i !== elm.innerHTML) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('server innerHTML: ', i);
+                                  console.warn('client innerHTML: ', elm.innerHTML);
+                              }
+                              return false;
+                          }
+                      }
+                      else {
+                          // iterate and compare children lists
+                          let childrenMatch = true;
+                          let childNode = elm.firstChild;
+                          for (let i = 0; i < children.length; i++) {
+                              if (!childNode ||
+                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                  childrenMatch = false;
+                                  break;
+                              }
+                              childNode = childNode.nextSibling;
+                          }
+                          // if childNode is not null, it means the actual childNodes list is
+                          // longer than the virtual children list.
+                          if (!childrenMatch || childNode) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                              }
+                              return false;
+                          }
+                      }
+                  }
+              }
+              if (isDef(data)) {
+                  let fullInvoke = false;
+                  for (const key in data) {
+                      if (!isRenderedModule(key)) {
+                          fullInvoke = true;
+                          invokeCreateHooks(vnode, insertedVnodeQueue);
+                          break;
+                      }
+                  }
+                  if (!fullInvoke && data['class']) {
+                      // ensure collecting deps for deep class bindings for future updates
+                      traverse(data['class']);
+                  }
+              }
+          }
+          else if (elm.data !== vnode.text) {
+              elm.data = vnode.text;
+          }
+          return true;
+      }
+      function assertNodeMatch(node, vnode, inVPre) {
+          if (isDef(vnode.tag)) {
+              return (vnode.tag.indexOf('vue-component') === 0 ||
+                  (!isUnknownElement(vnode, inVPre) &&
+                      vnode.tag.toLowerCase() ===
+                          (node.tagName && node.tagName.toLowerCase())));
+          }
+          else {
+              return node.nodeType === (vnode.isComment ? 8 : 3);
+          }
+      }
+      return function patch(oldVnode, vnode, hydrating, removeOnly) {
+          if (isUndef(vnode)) {
+              if (isDef(oldVnode))
+                  invokeDestroyHook(oldVnode);
+              return;
+          }
+          let isInitialPatch = false;
+          const insertedVnodeQueue = [];
+          if (isUndef(oldVnode)) {
+              // empty mount (likely as component), create new root element
+              isInitialPatch = true;
+              createElm(vnode, insertedVnodeQueue);
+          }
+          else {
+              const isRealElement = isDef(oldVnode.nodeType);
+              if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                  // patch existing root node
+                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+              }
+              else {
+                  if (isRealElement) {
+                      // mounting to a real element
+                      // check if this is server-rendered content and if we can perform
+                      // a successful hydration.
+                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                          oldVnode.removeAttribute(SSR_ATTR);
+                          hydrating = true;
+                      }
+                      if (isTrue(hydrating)) {
+                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                              invokeInsertHook(vnode, insertedVnodeQueue, true);
+                              return oldVnode;
+                          }
+                          else {
+                              warn$2('The client-side rendered virtual DOM tree is not matching ' +
+                                  'server-rendered content. This is likely caused by incorrect ' +
+                                  'HTML markup, for example nesting block-level elements inside ' +
+                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                  'full client-side render.');
+                          }
+                      }
+                      // either not server-rendered, or hydration failed.
+                      // create an empty node and replace it
+                      oldVnode = emptyNodeAt(oldVnode);
+                  }
+                  // replacing existing element
+                  const oldElm = oldVnode.elm;
+                  const parentElm = nodeOps.parentNode(oldElm);
+                  // create new node
+                  createElm(vnode, insertedVnodeQueue, 
+                  // extremely rare edge case: do not insert if old element is in a
+                  // leaving transition. Only happens when combining transition +
+                  // keep-alive + HOCs. (#4590)
+                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                  // update parent placeholder node element, recursively
+                  if (isDef(vnode.parent)) {
+                      let ancestor = vnode.parent;
+                      const patchable = isPatchable(vnode);
+                      while (ancestor) {
+                          for (let i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
+                          }
+                          ancestor.elm = vnode.elm;
+                          if (patchable) {
+                              for (let i = 0; i < cbs.create.length; ++i) {
+                                  cbs.create[i](emptyNode, ancestor);
+                              }
+                              // #6513
+                              // invoke insert hooks that may have been merged by create hooks.
+                              // e.g. for directives that uses the "inserted" hook.
+                              const insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
+                                  // start at index 1 to avoid re-invoking component mounted hook
+                                  for (let i = 1; i < insert.fns.length; i++) {
+                                      insert.fns[i]();
+                                  }
+                              }
+                          }
+                          else {
+                              registerRef(ancestor);
+                          }
+                          ancestor = ancestor.parent;
+                      }
+                  }
+                  // destroy old node
+                  if (isDef(parentElm)) {
+                      removeVnodes([oldVnode], 0, 0);
+                  }
+                  else if (isDef(oldVnode.tag)) {
+                      invokeDestroyHook(oldVnode);
+                  }
+              }
+          }
+          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+          return vnode.elm;
+      };
   }
 
-  var directives$1 = {
-      create: updateDirectives,
-      update: updateDirectives,
-      destroy: function unbindDirectives(vnode) {
-          // @ts-expect-error emptyNode is not VNodeWithData
-          updateDirectives(vnode, emptyNode);
-      },
-  };
-  function updateDirectives(oldVnode, vnode) {
-      if (oldVnode.data.directives || vnode.data.directives) {
-          _update(oldVnode, vnode);
-      }
-  }
-  function _update(oldVnode, vnode) {
-      const isCreate = oldVnode === emptyNode;
-      const isDestroy = vnode === emptyNode;
-      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      const dirsWithInsert = [];
-      const dirsWithPostpatch = [];
-      let key, oldDir, dir;
-      for (key in newDirs) {
-          oldDir = oldDirs[key];
-          dir = newDirs[key];
-          if (!oldDir) {
-              // new directive, bind
-              callHook(dir, 'bind', vnode, oldVnode);
-              if (dir.def && dir.def.inserted) {
-                  dirsWithInsert.push(dir);
-              }
-          }
-          else {
-              // existing directive, update
-              dir.oldValue = oldDir.value;
-              dir.oldArg = oldDir.arg;
-              callHook(dir, 'update', vnode, oldVnode);
-              if (dir.def && dir.def.componentUpdated) {
-                  dirsWithPostpatch.push(dir);
-              }
-          }
-      }
-      if (dirsWithInsert.length) {
-          const callInsert = () => {
-              for (let i = 0; i < dirsWithInsert.length; i++) {
-                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-              }
-          };
-          if (isCreate) {
-              mergeVNodeHook(vnode, 'insert', callInsert);
-          }
-          else {
-              callInsert();
-          }
-      }
-      if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', () => {
-              for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-              }
-          });
-      }
-      if (!isCreate) {
-          for (key in oldDirs) {
-              if (!newDirs[key]) {
-                  // no longer present, unbind
-                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-              }
-          }
-      }
-  }
-  const emptyModifiers = Object.create(null);
-  function normalizeDirectives(dirs, vm) {
-      const res = Object.create(null);
-      if (!dirs) {
-          // $flow-disable-line
-          return res;
-      }
-      let i, dir;
-      for (i = 0; i < dirs.length; i++) {
-          dir = dirs[i];
-          if (!dir.modifiers) {
-              // $flow-disable-line
-              dir.modifiers = emptyModifiers;
-          }
-          res[getRawDirName(dir)] = dir;
-          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-      }
-      // $flow-disable-line
-      return res;
-  }
-  function getRawDirName(dir) {
-      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-  }
-  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      const fn = dir.def && dir.def[hook];
-      if (fn) {
-          try {
-              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-          }
-          catch (e) {
-              // @ts-expect-error should it be any?
-              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-          }
-      }
+  var directives$1 = {
+      create: updateDirectives,
+      update: updateDirectives,
+      destroy: function unbindDirectives(vnode) {
+          // @ts-expect-error emptyNode is not VNodeWithData
+          updateDirectives(vnode, emptyNode);
+      },
+  };
+  function updateDirectives(oldVnode, vnode) {
+      if (oldVnode.data.directives || vnode.data.directives) {
+          _update(oldVnode, vnode);
+      }
+  }
+  function _update(oldVnode, vnode) {
+      const isCreate = oldVnode === emptyNode;
+      const isDestroy = vnode === emptyNode;
+      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+      const dirsWithInsert = [];
+      const dirsWithPostpatch = [];
+      let key, oldDir, dir;
+      for (key in newDirs) {
+          oldDir = oldDirs[key];
+          dir = newDirs[key];
+          if (!oldDir) {
+              // new directive, bind
+              callHook(dir, 'bind', vnode, oldVnode);
+              if (dir.def && dir.def.inserted) {
+                  dirsWithInsert.push(dir);
+              }
+          }
+          else {
+              // existing directive, update
+              dir.oldValue = oldDir.value;
+              dir.oldArg = oldDir.arg;
+              callHook(dir, 'update', vnode, oldVnode);
+              if (dir.def && dir.def.componentUpdated) {
+                  dirsWithPostpatch.push(dir);
+              }
+          }
+      }
+      if (dirsWithInsert.length) {
+          const callInsert = () => {
+              for (let i = 0; i < dirsWithInsert.length; i++) {
+                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+              }
+          };
+          if (isCreate) {
+              mergeVNodeHook(vnode, 'insert', callInsert);
+          }
+          else {
+              callInsert();
+          }
+      }
+      if (dirsWithPostpatch.length) {
+          mergeVNodeHook(vnode, 'postpatch', () => {
+              for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+              }
+          });
+      }
+      if (!isCreate) {
+          for (key in oldDirs) {
+              if (!newDirs[key]) {
+                  // no longer present, unbind
+                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+              }
+          }
+      }
+  }
+  const emptyModifiers = Object.create(null);
+  function normalizeDirectives(dirs, vm) {
+      const res = Object.create(null);
+      if (!dirs) {
+          // $flow-disable-line
+          return res;
+      }
+      let i, dir;
+      for (i = 0; i < dirs.length; i++) {
+          dir = dirs[i];
+          if (!dir.modifiers) {
+              // $flow-disable-line
+              dir.modifiers = emptyModifiers;
+          }
+          res[getRawDirName(dir)] = dir;
+          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+      }
+      // $flow-disable-line
+      return res;
+  }
+  function getRawDirName(dir) {
+      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+  }
+  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+      const fn = dir.def && dir.def[hook];
+      if (fn) {
+          try {
+              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+          }
+          catch (e) {
+              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+          }
+      }
   }
 
   var baseModules = [ref, directives$1];
 
-  function updateAttrs(oldVnode, vnode) {
-      const opts = vnode.componentOptions;
-      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-          return;
-      }
-      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-          return;
-      }
-      let key, cur, old;
-      const elm = vnode.elm;
-      const oldAttrs = oldVnode.data.attrs || {};
-      let attrs = vnode.data.attrs || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(attrs.__ob__)) {
-          attrs = vnode.data.attrs = extend({}, attrs);
-      }
-      for (key in attrs) {
-          cur = attrs[key];
-          old = oldAttrs[key];
-          if (old !== cur) {
-              setAttr(elm, key, cur, vnode.data.pre);
-          }
-      }
-      // #4391: in IE9, setting type can reset value for input[type=radio]
-      // #6666: IE/Edge forces progress value down to 1 before setting a max
-      /* istanbul ignore if */
-      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-          setAttr(elm, 'value', attrs.value);
-      }
-      for (key in oldAttrs) {
-          if (isUndef(attrs[key])) {
-              if (isXlink(key)) {
-                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-              }
-              else if (!isEnumeratedAttr(key)) {
-                  elm.removeAttribute(key);
-              }
-          }
-      }
-  }
-  function setAttr(el, key, value, isInPre) {
-      if (isInPre || el.tagName.indexOf('-') > -1) {
-          baseSetAttr(el, key, value);
-      }
-      else if (isBooleanAttr(key)) {
-          // set attribute for blank value
-          // e.g. <option disabled>Select one</option>
-          if (isFalsyAttrValue(value)) {
-              el.removeAttribute(key);
-          }
-          else {
-              // technically allowfullscreen is a boolean attribute for <iframe>,
-              // but Flash expects a value of "true" when used on <embed> tag
-              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-              el.setAttribute(key, value);
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          el.setAttribute(key, convertEnumeratedValue(key, value));
-      }
-      else if (isXlink(key)) {
-          if (isFalsyAttrValue(value)) {
-              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-          }
-          else {
-              el.setAttributeNS(xlinkNS, key, value);
-          }
-      }
-      else {
-          baseSetAttr(el, key, value);
-      }
-  }
-  function baseSetAttr(el, key, value) {
-      if (isFalsyAttrValue(value)) {
-          el.removeAttribute(key);
-      }
-      else {
-          // #7138: IE10 & 11 fires input event when setting placeholder on
-          // <textarea>... block the first input event and remove the blocker
-          // immediately.
-          /* istanbul ignore if */
-          if (isIE &&
-              !isIE9 &&
-              el.tagName === 'TEXTAREA' &&
-              key === 'placeholder' &&
-              value !== '' &&
-              !el.__ieph) {
-              const blocker = (e) => {
-                  e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
-              };
-              el.addEventListener('input', blocker);
-              // $flow-disable-line
-              el.__ieph = true; /* IE placeholder patched */
-          }
-          el.setAttribute(key, value);
-      }
-  }
-  var attrs = {
-      create: updateAttrs,
-      update: updateAttrs,
+  function updateAttrs(oldVnode, vnode) {
+      const opts = vnode.componentOptions;
+      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+          return;
+      }
+      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+          return;
+      }
+      let key, cur, old;
+      const elm = vnode.elm;
+      const oldAttrs = oldVnode.data.attrs || {};
+      let attrs = vnode.data.attrs || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(attrs.__ob__)) {
+          attrs = vnode.data.attrs = extend({}, attrs);
+      }
+      for (key in attrs) {
+          cur = attrs[key];
+          old = oldAttrs[key];
+          if (old !== cur) {
+              setAttr(elm, key, cur, vnode.data.pre);
+          }
+      }
+      // #4391: in IE9, setting type can reset value for input[type=radio]
+      // #6666: IE/Edge forces progress value down to 1 before setting a max
+      /* istanbul ignore if */
+      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+          setAttr(elm, 'value', attrs.value);
+      }
+      for (key in oldAttrs) {
+          if (isUndef(attrs[key])) {
+              if (isXlink(key)) {
+                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+              }
+              else if (!isEnumeratedAttr(key)) {
+                  elm.removeAttribute(key);
+              }
+          }
+      }
+  }
+  function setAttr(el, key, value, isInPre) {
+      if (isInPre || el.tagName.indexOf('-') > -1) {
+          baseSetAttr(el, key, value);
+      }
+      else if (isBooleanAttr(key)) {
+          // set attribute for blank value
+          // e.g. <option disabled>Select one</option>
+          if (isFalsyAttrValue(value)) {
+              el.removeAttribute(key);
+          }
+          else {
+              // technically allowfullscreen is a boolean attribute for <iframe>,
+              // but Flash expects a value of "true" when used on <embed> tag
+              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+              el.setAttribute(key, value);
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          el.setAttribute(key, convertEnumeratedValue(key, value));
+      }
+      else if (isXlink(key)) {
+          if (isFalsyAttrValue(value)) {
+              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+          }
+          else {
+              el.setAttributeNS(xlinkNS, key, value);
+          }
+      }
+      else {
+          baseSetAttr(el, key, value);
+      }
+  }
+  function baseSetAttr(el, key, value) {
+      if (isFalsyAttrValue(value)) {
+          el.removeAttribute(key);
+      }
+      else {
+          // #7138: IE10 & 11 fires input event when setting placeholder on
+          // <textarea>... block the first input event and remove the blocker
+          // immediately.
+          /* istanbul ignore if */
+          if (isIE &&
+              !isIE9 &&
+              el.tagName === 'TEXTAREA' &&
+              key === 'placeholder' &&
+              value !== '' &&
+              !el.__ieph) {
+              const blocker = (e) => {
+                  e.stopImmediatePropagation();
+                  el.removeEventListener('input', blocker);
+              };
+              el.addEventListener('input', blocker);
+              // $flow-disable-line
+              el.__ieph = true; /* IE placeholder patched */
+          }
+          el.setAttribute(key, value);
+      }
+  }
+  var attrs = {
+      create: updateAttrs,
+      update: updateAttrs,
   };
 
-  function updateClass(oldVnode, vnode) {
-      const el = vnode.elm;
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticClass) &&
-          isUndef(data.class) &&
-          (isUndef(oldData) ||
-              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-          return;
-      }
-      let cls = genClassForVnode(vnode);
-      // handle transition classes
-      const transitionClass = el._transitionClasses;
-      if (isDef(transitionClass)) {
-          cls = concat(cls, stringifyClass(transitionClass));
-      }
-      // set the class
-      if (cls !== el._prevClass) {
-          el.setAttribute('class', cls);
-          el._prevClass = cls;
-      }
-  }
-  var klass$1 = {
-      create: updateClass,
-      update: updateClass,
+  function updateClass(oldVnode, vnode) {
+      const el = vnode.elm;
+      const data = vnode.data;
+      const oldData = oldVnode.data;
+      if (isUndef(data.staticClass) &&
+          isUndef(data.class) &&
+          (isUndef(oldData) ||
+              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+          return;
+      }
+      let cls = genClassForVnode(vnode);
+      // handle transition classes
+      const transitionClass = el._transitionClasses;
+      if (isDef(transitionClass)) {
+          cls = concat(cls, stringifyClass(transitionClass));
+      }
+      // set the class
+      if (cls !== el._prevClass) {
+          el.setAttribute('class', cls);
+          el._prevClass = cls;
+      }
+  }
+  var klass$1 = {
+      create: updateClass,
+      update: updateClass,
   };
 
-  const validDivisionCharRE = /[\w).+\-_$\]]/;
-  function parseFilters(exp) {
-      let inSingle = false;
-      let inDouble = false;
-      let inTemplateString = false;
-      let inRegex = false;
-      let curly = 0;
-      let square = 0;
-      let paren = 0;
-      let lastFilterIndex = 0;
-      let c, prev, i, expression, filters;
-      for (i = 0; i < exp.length; i++) {
-          prev = c;
-          c = exp.charCodeAt(i);
-          if (inSingle) {
-              if (c === 0x27 && prev !== 0x5c)
-                  inSingle = false;
-          }
-          else if (inDouble) {
-              if (c === 0x22 && prev !== 0x5c)
-                  inDouble = false;
-          }
-          else if (inTemplateString) {
-              if (c === 0x60 && prev !== 0x5c)
-                  inTemplateString = false;
-          }
-          else if (inRegex) {
-              if (c === 0x2f && prev !== 0x5c)
-                  inRegex = false;
-          }
-          else if (c === 0x7c && // pipe
-              exp.charCodeAt(i + 1) !== 0x7c &&
-              exp.charCodeAt(i - 1) !== 0x7c &&
-              !curly &&
-              !square &&
-              !paren) {
-              if (expression === undefined) {
-                  // first filter, end of expression
-                  lastFilterIndex = i + 1;
-                  expression = exp.slice(0, i).trim();
-              }
-              else {
-                  pushFilter();
-              }
-          }
-          else {
-              switch (c) {
-                  case 0x22:
-                      inDouble = true;
-                      break; // "
-                  case 0x27:
-                      inSingle = true;
-                      break; // '
-                  case 0x60:
-                      inTemplateString = true;
-                      break; // `
-                  case 0x28:
-                      paren++;
-                      break; // (
-                  case 0x29:
-                      paren--;
-                      break; // )
-                  case 0x5b:
-                      square++;
-                      break; // [
-                  case 0x5d:
-                      square--;
-                      break; // ]
-                  case 0x7b:
-                      curly++;
-                      break; // {
-                  case 0x7d:
-                      curly--;
-                      break; // }
-              }
-              if (c === 0x2f) {
-                  // /
-                  let j = i - 1;
-                  let p;
-                  // find first non-whitespace prev char
-                  for (; j >= 0; j--) {
-                      p = exp.charAt(j);
-                      if (p !== ' ')
-                          break;
-                  }
-                  if (!p || !validDivisionCharRE.test(p)) {
-                      inRegex = true;
-                  }
-              }
-          }
-      }
-      if (expression === undefined) {
-          expression = exp.slice(0, i).trim();
-      }
-      else if (lastFilterIndex !== 0) {
-          pushFilter();
-      }
-      function pushFilter() {
-          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-          lastFilterIndex = i + 1;
-      }
-      if (filters) {
-          for (i = 0; i < filters.length; i++) {
-              expression = wrapFilter(expression, filters[i]);
-          }
-      }
-      return expression;
-  }
-  function wrapFilter(exp, filter) {
-      const i = filter.indexOf('(');
-      if (i < 0) {
-          // _f: resolveFilter
-          return `_f("${filter}")(${exp})`;
-      }
-      else {
-          const name = filter.slice(0, i);
-          const args = filter.slice(i + 1);
-          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-      }
+  const validDivisionCharRE = /[\w).+\-_$\]]/;
+  function parseFilters(exp) {
+      let inSingle = false;
+      let inDouble = false;
+      let inTemplateString = false;
+      let inRegex = false;
+      let curly = 0;
+      let square = 0;
+      let paren = 0;
+      let lastFilterIndex = 0;
+      let c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  inSingle = false;
+          }
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  inDouble = false;
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  inTemplateString = false;
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  inRegex = false;
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  let j = i - 1;
+                  let p;
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          break;
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
+          }
+      }
+      if (expression === undefined) {
+          expression = exp.slice(0, i).trim();
+      }
+      else if (lastFilterIndex !== 0) {
+          pushFilter();
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
+  }
+  function wrapFilter(exp, filter) {
+      const i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return `_f("${filter}")(${exp})`;
+      }
+      else {
+          const name = filter.slice(0, i);
+          const args = filter.slice(i + 1);
+          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+      }
   }
 
-  /* eslint-disable no-unused-vars */
-  function baseWarn(msg, range) {
-      console.error(`[Vue compiler]: ${msg}`);
-  }
-  /* eslint-enable no-unused-vars */
-  function pluckModuleFunction(modules, key) {
-      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-  }
-  function addProp(el, name, value, range, dynamic) {
-      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  function addAttr(el, name, value, range, dynamic) {
-      const attrs = dynamic
-          ? el.dynamicAttrs || (el.dynamicAttrs = [])
-          : el.attrs || (el.attrs = []);
-      attrs.push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr(el, name, value, range) {
-      el.attrsMap[name] = value;
-      el.attrsList.push(rangeSetItem({ name, value }, range));
-  }
-  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-      (el.directives || (el.directives = [])).push(rangeSetItem({
-          name,
-          rawName,
-          value,
-          arg,
-          isDynamicArg,
-          modifiers,
-      }, range));
-      el.plain = false;
-  }
-  function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-  }
-  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-      modifiers = modifiers || emptyObject;
-      // warn prevent and passive modifier
-      /* istanbul ignore if */
-      if (warn &&
-          modifiers.prevent &&
-          modifiers.passive) {
-          warn("passive and prevent can't be used together. " +
-              "Passive handler can't prevent default event.", range);
-      }
-      // normalize click.right and click.middle since they don't actually fire
-      // this is technically browser-specific, but at least for now browsers are
-      // the only target envs that have right/middle clicks.
-      if (modifiers.right) {
-          if (dynamic) {
-              name = `(${name})==='click'?'contextmenu':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'contextmenu';
-              delete modifiers.right;
-          }
-      }
-      else if (modifiers.middle) {
-          if (dynamic) {
-              name = `(${name})==='click'?'mouseup':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'mouseup';
-          }
-      }
-      // check capture modifier
-      if (modifiers.capture) {
-          delete modifiers.capture;
-          name = prependModifierMarker('!', name, dynamic);
-      }
-      if (modifiers.once) {
-          delete modifiers.once;
-          name = prependModifierMarker('~', name, dynamic);
-      }
-      /* istanbul ignore if */
-      if (modifiers.passive) {
-          delete modifiers.passive;
-          name = prependModifierMarker('&', name, dynamic);
-      }
-      let events;
-      if (modifiers.native) {
-          delete modifiers.native;
-          events = el.nativeEvents || (el.nativeEvents = {});
-      }
-      else {
-          events = el.events || (el.events = {});
-      }
-      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-      if (modifiers !== emptyObject) {
-          newHandler.modifiers = modifiers;
-      }
-      const handlers = events[name];
-      /* istanbul ignore if */
-      if (Array.isArray(handlers)) {
-          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-      }
-      else if (handlers) {
-          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-      }
-      else {
-          events[name] = newHandler;
-      }
-      el.plain = false;
-  }
-  function getRawBindingAttr(el, name) {
-      return (el.rawAttrsMap[':' + name] ||
-          el.rawAttrsMap['v-bind:' + name] ||
-          el.rawAttrsMap[name]);
-  }
-  function getBindingAttr(el, name, getStatic) {
-      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-      if (dynamicValue != null) {
-          return parseFilters(dynamicValue);
-      }
-      else if (getStatic !== false) {
-          const staticValue = getAndRemoveAttr(el, name);
-          if (staticValue != null) {
-              return JSON.stringify(staticValue);
-          }
-      }
-  }
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr(el, name, removeFromMap) {
-      let val;
-      if ((val = el.attrsMap[name]) != null) {
-          const list = el.attrsList;
-          for (let i = 0, l = list.length; i < l; i++) {
-              if (list[i].name === name) {
-                  list.splice(i, 1);
-                  break;
-              }
-          }
-      }
-      if (removeFromMap) {
-          delete el.attrsMap[name];
-      }
-      return val;
-  }
-  function getAndRemoveAttrByRegex(el, name) {
-      const list = el.attrsList;
-      for (let i = 0, l = list.length; i < l; i++) {
-          const attr = list[i];
-          if (name.test(attr.name)) {
-              list.splice(i, 1);
-              return attr;
-          }
-      }
-  }
-  function rangeSetItem(item, range) {
-      if (range) {
-          if (range.start != null) {
-              item.start = range.start;
-          }
-          if (range.end != null) {
-              item.end = range.end;
-          }
-      }
-      return item;
+  /* eslint-disable no-unused-vars */
+  function baseWarn(msg, range) {
+      console.error(`[Vue compiler]: ${msg}`);
+  }
+  /* eslint-enable no-unused-vars */
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+  }
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
+  }
+  function addAttr(el, name, value, range, dynamic) {
+      const attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
+  }
+  // add a raw attr (use this in preTransforms)
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name, value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamicArg,
+          modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = `(${name})==='click'?'contextmenu':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = `(${name})==='click'?'mouseup':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      let events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      const handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
+  }
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
+  }
+  function getBindingAttr(el, name, getStatic) {
+      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          const staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
+  }
+  // note: this only removes the attr from the Array (attrsList) so that it
+  // doesn't get processed by processAttrs.
+  // By default it does NOT remove it from the map (attrsMap) because the map is
+  // needed during codegen.
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      let val;
+      if ((val = el.attrsMap[name]) != null) {
+          const list = el.attrsList;
+          for (let i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
+      }
+      if (removeFromMap) {
+          delete el.attrsMap[name];
+      }
+      return val;
+  }
+  function getAndRemoveAttrByRegex(el, name) {
+      const list = el.attrsList;
+      for (let i = 0, l = list.length; i < l; i++) {
+          const attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
+      }
+  }
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
+      }
+      return item;
   }
 
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel(el, value, modifiers) {
-      const { number, trim } = modifiers || {};
-      const baseValueExpression = '$$v';
-      let valueExpression = baseValueExpression;
-      if (trim) {
-          valueExpression =
-              `(typeof ${baseValueExpression} === 'string'` +
-                  `? ${baseValueExpression}.trim()` +
-                  `: ${baseValueExpression})`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      const assignment = genAssignmentCode(value, valueExpression);
-      el.model = {
-          value: `(${value})`,
-          expression: JSON.stringify(value),
-          callback: `function (${baseValueExpression}) {${assignment}}`,
-      };
-  }
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode(value, assignment) {
-      const res = parseModel(value);
-      if (res.key === null) {
-          return `${value}=${assignment}`;
-      }
-      else {
-          return `$set(${res.exp}, ${res.key}, ${assignment})`;
-      }
-  }
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-  let len, str, chr, index, expressionPos, expressionEndPos;
-  function parseModel(val) {
-      // Fix https://github.com/vuejs/vue/pull/7730
-      // allow v-model="obj.val " (trailing whitespace)
-      val = val.trim();
-      len = val.length;
-      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-          index = val.lastIndexOf('.');
-          if (index > -1) {
-              return {
-                  exp: val.slice(0, index),
-                  key: '"' + val.slice(index + 1) + '"',
-              };
-          }
-          else {
-              return {
-                  exp: val,
-                  key: null,
-              };
-          }
-      }
-      str = val;
-      index = expressionPos = expressionEndPos = 0;
-      while (!eof()) {
-          chr = next();
-          /* istanbul ignore if */
-          if (isStringStart(chr)) {
-              parseString(chr);
-          }
-          else if (chr === 0x5b) {
-              parseBracket(chr);
-          }
-      }
-      return {
-          exp: val.slice(0, expressionPos),
-          key: val.slice(expressionPos + 1, expressionEndPos),
-      };
-  }
-  function next() {
-      return str.charCodeAt(++index);
-  }
-  function eof() {
-      return index >= len;
-  }
-  function isStringStart(chr) {
-      return chr === 0x22 || chr === 0x27;
-  }
-  function parseBracket(chr) {
-      let inBracket = 1;
-      expressionPos = index;
-      while (!eof()) {
-          chr = next();
-          if (isStringStart(chr)) {
-              parseString(chr);
-              continue;
-          }
-          if (chr === 0x5b)
-              inBracket++;
-          if (chr === 0x5d)
-              inBracket--;
-          if (inBracket === 0) {
-              expressionEndPos = index;
-              break;
-          }
-      }
-  }
-  function parseString(chr) {
-      const stringQuote = chr;
-      while (!eof()) {
-          chr = next();
-          if (chr === stringQuote) {
-              break;
-          }
-      }
+  /**
+   * Cross-platform code generation for component v-model
+   */
+  function genComponentModel(el, value, modifiers) {
+      const { number, trim } = modifiers || {};
+      const baseValueExpression = '$$v';
+      let valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              `(typeof ${baseValueExpression} === 'string'` +
+                  `? ${baseValueExpression}.trim()` +
+                  `: ${baseValueExpression})`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      const assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: `(${value})`,
+          expression: JSON.stringify(value),
+          callback: `function (${baseValueExpression}) {${assignment}}`,
+      };
+  }
+  /**
+   * Cross-platform codegen helper for generating v-model value assignment code.
+   */
+  function genAssignmentCode(value, assignment) {
+      const res = parseModel(value);
+      if (res.key === null) {
+          return `${value}=${assignment}`;
+      }
+      else {
+          return `$set(${res.exp}, ${res.key}, ${assignment})`;
+      }
+  }
+  /**
+   * Parse a v-model expression into a base path and a final key segment.
+   * Handles both dot-path and possible square brackets.
+   *
+   * Possible cases:
+   *
+   * - test
+   * - test[key]
+   * - test[test1[key]]
+   * - test["a"][key]
+   * - xxx.test[a[a].test1[key]]
+   * - test.xxx.a["asa"][test1[key]]
+   *
+   */
+  let len, str, chr, index, expressionPos, expressionEndPos;
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
+              return {
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
+      }
+      str = val;
+      index = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
+      }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
+  }
+  function next() {
+      return str.charCodeAt(++index);
+  }
+  function eof() {
+      return index >= len;
+  }
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
+  }
+  function parseBracket(chr) {
+      let inBracket = 1;
+      expressionPos = index;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              inBracket++;
+          if (chr === 0x5d)
+              inBracket--;
+          if (inBracket === 0) {
+              expressionEndPos = index;
+              break;
+          }
+      }
+  }
+  function parseString(chr) {
+      const stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
+      }
   }
 
-  let warn$1;
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
-  const CHECKBOX_RADIO_TOKEN = '__c';
-  function model$1(el, dir, _warn) {
-      warn$1 = _warn;
-      const value = dir.value;
-      const modifiers = dir.modifiers;
-      const tag = el.tag;
-      const type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else if (!config.isReservedTag(tag)) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else {
-          warn$1(`<${el.tag} v-model="${value}">: ` +
-              `v-model is not supported on this element type. ` +
-              "If you are working with contenteditable, it's recommended to " +
-              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const valueBinding = getBindingAttr(el, 'value') || 'null';
-      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', `Array.isArray(${value})` +
-          `?_i(${value},${valueBinding})>-1` +
-          (trueValueBinding === 'true'
-              ? `:(${value})`
-              : `:_q(${value},${trueValueBinding})`));
-      addHandler(el, 'change', `var $$a=${value},` +
-          '$$el=$event.target,' +
-          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-          'if(Array.isArray($$a)){' +
-          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      let valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-      addProp(el, 'checked', `_q(${value},${valueBinding})`);
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const selectedVal = `Array.prototype.filter` +
-          `.call($event.target.options,function(o){return o.selected})` +
-          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-          `return ${number ? '_n(val)' : 'val'}})`;
-      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      let code = `var $$selectedVal = ${selectedVal};`;
-      code = `${code} ${genAssignmentCode(value, assignment)}`;
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      const type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value && !typeBinding) {
-              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      const { lazy, number, trim } = modifiers || {};
-      const needCompositionGuard = !lazy && type !== 'range';
-      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      let valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = `$event.target.value.trim()`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      let code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = `if($event.target.composing)return;${code}`;
-      }
-      addProp(el, 'value', `(${value})`);
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
+  let warn$1;
+  // in some cases, the event used has to be determined at runtime
+  // so we used some reserved tokens during compile.
+  const RANGE_TOKEN = '__r';
+  const CHECKBOX_RADIO_TOKEN = '__c';
+  function model$1(el, dir, _warn) {
+      warn$1 = _warn;
+      const value = dir.value;
+      const modifiers = dir.modifiers;
+      const tag = el.tag;
+      const type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
+                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else if (!config.isReservedTag(tag)) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else {
+          warn$1(`<${el.tag} v-model="${value}">: ` +
+              `v-model is not supported on this element type. ` +
+              "If you are working with contenteditable, it's recommended to " +
+              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const valueBinding = getBindingAttr(el, 'value') || 'null';
+      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', `Array.isArray(${value})` +
+          `?_i(${value},${valueBinding})>-1` +
+          (trueValueBinding === 'true'
+              ? `:(${value})`
+              : `:_q(${value},${trueValueBinding})`));
+      addHandler(el, 'change', `var $$a=${value},` +
+          '$$el=$event.target,' +
+          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+          'if(Array.isArray($$a)){' +
+          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+          '$$i=_i($$a,$$v);' +
+          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      let valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+      addProp(el, 'checked', `_q(${value},${valueBinding})`);
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const selectedVal = `Array.prototype.filter` +
+          `.call($event.target.options,function(o){return o.selected})` +
+          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+          `return ${number ? '_n(val)' : 'val'}})`;
+      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      let code = `var $$selectedVal = ${selectedVal};`;
+      code = `${code} ${genAssignmentCode(value, assignment)}`;
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      const type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value && !typeBinding) {
+              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      const { lazy, number, trim } = modifiers || {};
+      const needCompositionGuard = !lazy && type !== 'range';
+      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      let valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = `$event.target.value.trim()`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      let code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = `if($event.target.composing)return;${code}`;
+      }
+      addProp(el, 'value', `(${value})`);
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
   }
 
-  // normalize v-model event tokens that can only be determined at runtime.
-  // it's important to place the event as the first in the array because
-  // the whole point is ensuring the v-model callback gets called before
-  // user-attached handlers.
-  function normalizeEvents(on) {
-      /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN])) {
-          // IE input[type=range] only supports `change` event
-          const event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-          delete on[RANGE_TOKEN];
-      }
-      // This was originally intended to fix #4521 but no longer necessary
-      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-      /* istanbul ignore if */
-      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-          delete on[CHECKBOX_RADIO_TOKEN];
-      }
-  }
-  let target;
-  function createOnceHandler(event, handler, capture) {
-      const _target = target; // save current target element in closure
-      return function onceHandler() {
-          const res = handler.apply(null, arguments);
-          if (res !== null) {
-              remove(event, onceHandler, capture, _target);
-          }
-      };
-  }
-  // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-  // implementation and does not fire microtasks in between event propagation, so
-  // safe to exclude.
-  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-  function add(name, handler, capture, passive) {
-      // async edge case #6566: inner click event triggers patch, event handler
-      // attached to outer element during patch, and triggered again. This
-      // happens because browsers fire microtask ticks between event propagation.
-      // the solution is simple: we save the timestamp when a handler is attached,
-      // and the handler would only fire if the event passed to it was fired
-      // AFTER it was attached.
-      if (useMicrotaskFix) {
-          const attachedTimestamp = currentFlushTimestamp;
-          const original = handler;
-          //@ts-expect-error 
-          handler = original._wrapper = function (e) {
-              if (
-              // no bubbling, should always fire.
-              // this is just a safety net in case event.timeStamp is unreliable in
-              // certain weird environments...
-              e.target === e.currentTarget ||
-                  // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
-                  // bail for environments that have buggy event.timeStamp implementations
-                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                  // #9681 QtWebEngine event.timeStamp is negative value
-                  e.timeStamp <= 0 ||
-                  // #9448 bail if event is fired in another document in a multi-page
-                  // electron/nw.js app, since event.timeStamp will be using a different
-                  // starting reference
-                  e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
-              }
-          };
-      }
-      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-  }
-  function remove(name, handler, capture, _target) {
-      (_target || target).removeEventListener(name, 
-      //@ts-expect-error
-      handler._wrapper || handler, capture);
-  }
-  function updateDOMListeners(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-          return;
-      }
-      const on = vnode.data.on || {};
-      const oldOn = oldVnode.data.on || {};
-      // vnode is empty when removing all listeners,
-      // and use old vnode dom element
-      target = vnode.elm || oldVnode.elm;
-      normalizeEvents(on);
-      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-      target = undefined;
-  }
-  var events = {
-      create: updateDOMListeners,
-      update: updateDOMListeners,
-      // @ts-expect-error emptyNode has actually data
-      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+  // normalize v-model event tokens that can only be determined at runtime.
+  // it's important to place the event as the first in the array because
+  // the whole point is ensuring the v-model callback gets called before
+  // user-attached handlers.
+  function normalizeEvents(on) {
+      /* istanbul ignore if */
+      if (isDef(on[RANGE_TOKEN])) {
+          // IE input[type=range] only supports `change` event
+          const event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          delete on[RANGE_TOKEN];
+      }
+      // This was originally intended to fix #4521 but no longer necessary
+      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+      /* istanbul ignore if */
+      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+          delete on[CHECKBOX_RADIO_TOKEN];
+      }
+  }
+  let target;
+  function createOnceHandler(event, handler, capture) {
+      const _target = target; // save current target element in closure
+      return function onceHandler() {
+          const res = handler.apply(null, arguments);
+          if (res !== null) {
+              remove(event, onceHandler, capture, _target);
+          }
+      };
+  }
+  // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+  // implementation and does not fire microtasks in between event propagation, so
+  // safe to exclude.
+  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+  function add(name, handler, capture, passive) {
+      // async edge case #6566: inner click event triggers patch, event handler
+      // attached to outer element during patch, and triggered again. This
+      // happens because browsers fire microtask ticks between event propagation.
+      // the solution is simple: we save the timestamp when a handler is attached,
+      // and the handler would only fire if the event passed to it was fired
+      // AFTER it was attached.
+      if (useMicrotaskFix) {
+          const attachedTimestamp = currentFlushTimestamp;
+          const original = handler;
+          //@ts-expect-error 
+          handler = original._wrapper = function (e) {
+              if (
+              // no bubbling, should always fire.
+              // this is just a safety net in case event.timeStamp is unreliable in
+              // certain weird environments...
+              e.target === e.currentTarget ||
+                  // event is fired after handler attachment
+                  e.timeStamp >= attachedTimestamp ||
+                  // bail for environments that have buggy event.timeStamp implementations
+                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                  // #9681 QtWebEngine event.timeStamp is negative value
+                  e.timeStamp <= 0 ||
+                  // #9448 bail if event is fired in another document in a multi-page
+                  // electron/nw.js app, since event.timeStamp will be using a different
+                  // starting reference
+                  e.target.ownerDocument !== document) {
+                  return original.apply(this, arguments);
+              }
+          };
+      }
+      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+  }
+  function remove(name, handler, capture, _target) {
+      (_target || target).removeEventListener(name, 
+      //@ts-expect-error
+      handler._wrapper || handler, capture);
+  }
+  function updateDOMListeners(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+          return;
+      }
+      const on = vnode.data.on || {};
+      const oldOn = oldVnode.data.on || {};
+      // vnode is empty when removing all listeners,
+      // and use old vnode dom element
+      target = vnode.elm || oldVnode.elm;
+      normalizeEvents(on);
+      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+      target = undefined;
+  }
+  var events = {
+      create: updateDOMListeners,
+      update: updateDOMListeners,
+      // @ts-expect-error emptyNode has actually data
+      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
   };
 
-  let svgContainer;
-  function updateDOMProps(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-          return;
-      }
-      let key, cur;
-      const elm = vnode.elm;
-      const oldProps = oldVnode.data.domProps || {};
-      let props = vnode.data.domProps || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(props.__ob__)) {
-          props = vnode.data.domProps = extend({}, props);
-      }
-      for (key in oldProps) {
-          if (!(key in props)) {
-              elm[key] = '';
-          }
-      }
-      for (key in props) {
-          cur = props[key];
-          // ignore children if the node has textContent or innerHTML,
-          // as these will throw away existing DOM nodes and cause removal errors
-          // on subsequent patches (#3360)
-          if (key === 'textContent' || key === 'innerHTML') {
-              if (vnode.children)
-                  vnode.children.length = 0;
-              if (cur === oldProps[key])
-                  continue;
-              // #6601 work around Chrome version <= 55 bug where single textNode
-              // replaced by innerHTML/textContent retains its parentNode property
-              if (elm.childNodes.length === 1) {
-                  elm.removeChild(elm.childNodes[0]);
-              }
-          }
-          if (key === 'value' && elm.tagName !== 'PROGRESS') {
-              // store value as _value as well since
-              // non-string values will be stringified
-              elm._value = cur;
-              // avoid resetting cursor position when value is the same
-              const strCur = isUndef(cur) ? '' : String(cur);
-              if (shouldUpdateValue(elm, strCur)) {
-                  elm.value = strCur;
-              }
-          }
-          else if (key === 'innerHTML' &&
-              isSVG(elm.tagName) &&
-              isUndef(elm.innerHTML)) {
-              // IE doesn't support innerHTML for SVG elements
-              svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = `<svg>${cur}</svg>`;
-              const svg = svgContainer.firstChild;
-              while (elm.firstChild) {
-                  elm.removeChild(elm.firstChild);
-              }
-              while (svg.firstChild) {
-                  elm.appendChild(svg.firstChild);
-              }
-          }
-          else if (
-          // skip the update if old and new VDOM state is the same.
-          // `value` is handled separately because the DOM value may be temporarily
-          // out of sync with VDOM state due to focus, composition and modifiers.
-          // This  #4521 by skipping the unnecessary `checked` update.
-          cur !== oldProps[key]) {
-              // some property updates can throw
-              // e.g. `value` on <progress> w/ non-finite value
-              try {
-                  elm[key] = cur;
-              }
-              catch (e) { }
-          }
-      }
-  }
-  function shouldUpdateValue(elm, checkVal) {
-      return (
-      //@ts-expect-error
-      !elm.composing &&
-          (elm.tagName === 'OPTION' ||
-              isNotInFocusAndDirty(elm, checkVal) ||
-              isDirtyWithModifiers(elm, checkVal)));
-  }
-  function isNotInFocusAndDirty(elm, checkVal) {
-      // return true when textbox (.number and .trim) loses focus and its value is
-      // not equal to the updated value
-      let notInFocus = true;
-      // #6157
-      // work around IE bug when accessing document.activeElement in an iframe
-      try {
-          notInFocus = document.activeElement !== elm;
-      }
-      catch (e) { }
-      return notInFocus && elm.value !== checkVal;
-  }
-  function isDirtyWithModifiers(elm, newVal) {
-      const value = elm.value;
-      const modifiers = elm._vModifiers; // injected by v-model runtime
-      if (isDef(modifiers)) {
-          if (modifiers.number) {
-              return toNumber(value) !== toNumber(newVal);
-          }
-          if (modifiers.trim) {
-              return value.trim() !== newVal.trim();
-          }
-      }
-      return value !== newVal;
-  }
-  var domProps = {
-      create: updateDOMProps,
-      update: updateDOMProps,
+  let svgContainer;
+  function updateDOMProps(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+          return;
+      }
+      let key, cur;
+      const elm = vnode.elm;
+      const oldProps = oldVnode.data.domProps || {};
+      let props = vnode.data.domProps || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(props.__ob__)) {
+          props = vnode.data.domProps = extend({}, props);
+      }
+      for (key in oldProps) {
+          if (!(key in props)) {
+              elm[key] = '';
+          }
+      }
+      for (key in props) {
+          cur = props[key];
+          // ignore children if the node has textContent or innerHTML,
+          // as these will throw away existing DOM nodes and cause removal errors
+          // on subsequent patches (#3360)
+          if (key === 'textContent' || key === 'innerHTML') {
+              if (vnode.children)
+                  vnode.children.length = 0;
+              if (cur === oldProps[key])
+                  continue;
+              // #6601 work around Chrome version <= 55 bug where single textNode
+              // replaced by innerHTML/textContent retains its parentNode property
+              if (elm.childNodes.length === 1) {
+                  elm.removeChild(elm.childNodes[0]);
+              }
+          }
+          if (key === 'value' && elm.tagName !== 'PROGRESS') {
+              // store value as _value as well since
+              // non-string values will be stringified
+              elm._value = cur;
+              // avoid resetting cursor position when value is the same
+              const strCur = isUndef(cur) ? '' : String(cur);
+              if (shouldUpdateValue(elm, strCur)) {
+                  elm.value = strCur;
+              }
+          }
+          else if (key === 'innerHTML' &&
+              isSVG(elm.tagName) &&
+              isUndef(elm.innerHTML)) {
+              // IE doesn't support innerHTML for SVG elements
+              svgContainer = svgContainer || document.createElement('div');
+              svgContainer.innerHTML = `<svg>${cur}</svg>`;
+              const svg = svgContainer.firstChild;
+              while (elm.firstChild) {
+                  elm.removeChild(elm.firstChild);
+              }
+              while (svg.firstChild) {
+                  elm.appendChild(svg.firstChild);
+              }
+          }
+          else if (
+          // skip the update if old and new VDOM state is the same.
+          // `value` is handled separately because the DOM value may be temporarily
+          // out of sync with VDOM state due to focus, composition and modifiers.
+          // This  #4521 by skipping the unnecessary `checked` update.
+          cur !== oldProps[key]) {
+              // some property updates can throw
+              // e.g. `value` on <progress> w/ non-finite value
+              try {
+                  elm[key] = cur;
+              }
+              catch (e) { }
+          }
+      }
+  }
+  function shouldUpdateValue(elm, checkVal) {
+      return (
+      //@ts-expect-error
+      !elm.composing &&
+          (elm.tagName === 'OPTION' ||
+              isNotInFocusAndDirty(elm, checkVal) ||
+              isDirtyWithModifiers(elm, checkVal)));
+  }
+  function isNotInFocusAndDirty(elm, checkVal) {
+      // return true when textbox (.number and .trim) loses focus and its value is
+      // not equal to the updated value
+      let notInFocus = true;
+      // #6157
+      // work around IE bug when accessing document.activeElement in an iframe
+      try {
+          notInFocus = document.activeElement !== elm;
+      }
+      catch (e) { }
+      return notInFocus && elm.value !== checkVal;
+  }
+  function isDirtyWithModifiers(elm, newVal) {
+      const value = elm.value;
+      const modifiers = elm._vModifiers; // injected by v-model runtime
+      if (isDef(modifiers)) {
+          if (modifiers.number) {
+              return toNumber(value) !== toNumber(newVal);
+          }
+          if (modifiers.trim) {
+              return value.trim() !== newVal.trim();
+          }
+      }
+      return value !== newVal;
+  }
+  var domProps = {
+      create: updateDOMProps,
+      update: updateDOMProps,
   };
 
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              const tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
+  });
+  // merge static and dynamic style data on the same vnode
+  function normalizeStyleData(data) {
+      const style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
+  }
+  // normalize possible array / string values into Object
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
+  }
+  /**
+   * parent component style should be after child's
+   * so that parent component's style could override it
+   */
+  function getStyle(vnode, checkChild) {
+      const res = {};
+      let styleData;
+      if (checkChild) {
+          let childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
+          extend(res, styleData);
+      }
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
+      }
+      return res;
   }
 
-  const cssVarRE = /^--/;
-  const importantRE = /\s*!important$/;
-  const setProp = (el, name, val) => {
-      /* istanbul ignore if */
-      if (cssVarRE.test(name)) {
-          el.style.setProperty(name, val);
-      }
-      else if (importantRE.test(val)) {
-          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-      }
-      else {
-          const normalizedName = normalize(name);
-          if (Array.isArray(val)) {
-              // Support values array created by autoprefixer, e.g.
-              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-              // Set them one by one, and the browser will only set those it can recognize
-              for (let i = 0, len = val.length; i < len; i++) {
-                  el.style[normalizedName] = val[i];
-              }
-          }
-          else {
-              el.style[normalizedName] = val;
-          }
-      }
-  };
-  const vendorNames = ['Webkit', 'Moz', 'ms'];
-  let emptyStyle;
-  const normalize = cached(function (prop) {
-      emptyStyle = emptyStyle || document.createElement('div').style;
-      prop = camelize(prop);
-      if (prop !== 'filter' && prop in emptyStyle) {
-          return prop;
-      }
-      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (let i = 0; i < vendorNames.length; i++) {
-          const name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
-          }
-      }
-  });
-  function updateStyle(oldVnode, vnode) {
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticStyle) &&
-          isUndef(data.style) &&
-          isUndef(oldData.staticStyle) &&
-          isUndef(oldData.style)) {
-          return;
-      }
-      let cur, name;
-      const el = vnode.elm;
-      const oldStaticStyle = oldData.staticStyle;
-      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      const oldStyle = oldStaticStyle || oldStyleBinding;
-      const style = normalizeStyleBinding(vnode.data.style) || {};
-      // store normalized style under a different key for next diff
-      // make sure to clone it if it's reactive, since the user likely wants
-      // to mutate it.
-      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      const newStyle = getStyle(vnode, true);
-      for (name in oldStyle) {
-          if (isUndef(newStyle[name])) {
-              setProp(el, name, '');
-          }
-      }
-      for (name in newStyle) {
-          cur = newStyle[name];
-          if (cur !== oldStyle[name]) {
-              // ie9 setting to null has no effect, must use empty string
-              setProp(el, name, cur == null ? '' : cur);
-          }
-      }
-  }
-  var style$1 = {
-      create: updateStyle,
-      update: updateStyle,
+  const cssVarRE = /^--/;
+  const importantRE = /\s*!important$/;
+  const setProp = (el, name, val) => {
+      /* istanbul ignore if */
+      if (cssVarRE.test(name)) {
+          el.style.setProperty(name, val);
+      }
+      else if (importantRE.test(val)) {
+          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+      }
+      else {
+          const normalizedName = normalize(name);
+          if (Array.isArray(val)) {
+              // Support values array created by autoprefixer, e.g.
+              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+              // Set them one by one, and the browser will only set those it can recognize
+              for (let i = 0, len = val.length; i < len; i++) {
+                  el.style[normalizedName] = val[i];
+              }
+          }
+          else {
+              el.style[normalizedName] = val;
+          }
+      }
+  };
+  const vendorNames = ['Webkit', 'Moz', 'ms'];
+  let emptyStyle;
+  const normalize = cached(function (prop) {
+      emptyStyle = emptyStyle || document.createElement('div').style;
+      prop = camelize(prop);
+      if (prop !== 'filter' && prop in emptyStyle) {
+          return prop;
+      }
+      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (let i = 0; i < vendorNames.length; i++) {
+          const name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
+          }
+      }
+  });
+  function updateStyle(oldVnode, vnode) {
+      const data = vnode.data;
+      const oldData = oldVnode.data;
+      if (isUndef(data.staticStyle) &&
+          isUndef(data.style) &&
+          isUndef(oldData.staticStyle) &&
+          isUndef(oldData.style)) {
+          return;
+      }
+      let cur, name;
+      const el = vnode.elm;
+      const oldStaticStyle = oldData.staticStyle;
+      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+      const oldStyle = oldStaticStyle || oldStyleBinding;
+      const style = normalizeStyleBinding(vnode.data.style) || {};
+      // store normalized style under a different key for next diff
+      // make sure to clone it if it's reactive, since the user likely wants
+      // to mutate it.
+      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+      const newStyle = getStyle(vnode, true);
+      for (name in oldStyle) {
+          if (isUndef(newStyle[name])) {
+              setProp(el, name, '');
+          }
+      }
+      for (name in newStyle) {
+          cur = newStyle[name];
+          if (cur !== oldStyle[name]) {
+              // ie9 setting to null has no effect, must use empty string
+              setProp(el, name, cur == null ? '' : cur);
+          }
+      }
+  }
+  var style$1 = {
+      create: updateStyle,
+      update: updateStyle,
   };
 
-  const whitespaceRE$1 = /\s+/;
-  /**
-   * Add class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function addClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          const cur = ` ${el.getAttribute('class') || ''} `;
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
-  }
-  /**
-   * Remove class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function removeClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          let cur = ` ${el.getAttribute('class') || ''} `;
-          const tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
+  const whitespaceRE$1 = /\s+/;
+  /**
+   * Add class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function addClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
+          }
+          else {
+              el.classList.add(cls);
+          }
+      }
+      else {
+          const cur = ` ${el.getAttribute('class') || ''} `;
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
+      }
+  }
+  /**
+   * Remove class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function removeClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          let cur = ` ${el.getAttribute('class') || ''} `;
+          const tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
+      }
   }
 
-  function resolveTransition(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          const res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition(def);
-      }
-  }
-  const autoCssTransition = cached((name) => {
-      return {
-          enterClass: `${name}-enter`,
-          enterToClass: `${name}-enter-to`,
-          enterActiveClass: `${name}-enter-active`,
-          leaveClass: `${name}-leave`,
-          leaveToClass: `${name}-leave-to`,
-          leaveActiveClass: `${name}-leave-active`,
-      };
-  });
-  const hasTransition = inBrowser && !isIE9;
-  const TRANSITION = 'transition';
-  const ANIMATION = 'animation';
-  // Transition property/event sniffing
-  let transitionProp = 'transition';
-  let transitionEndEvent = 'transitionend';
-  let animationProp = 'animation';
-  let animationEndEvent = 'animationend';
-  if (hasTransition) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
-      }
-  }
-  // binding to window is necessary to make hot reload work in IE in strict mode
-  const raf = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ (fn) => fn();
-  function nextFrame(fn) {
-      raf(() => {
-          // @ts-expect-error
-          raf(fn);
-      });
-  }
-  function addTransitionClass(el, cls) {
-      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass(el, cls);
-      }
-  }
-  function removeTransitionClass(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass(el, cls);
-  }
-  function whenTransitionEnds(el, expectedType, cb) {
-      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-      if (!type)
-          return cb();
-      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      let ended = 0;
-      const end = () => {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      const onEnd = (e) => {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(() => {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
-  }
-  const transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
-      const styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      const animationTimeout = getTimeout(animationDelays, animationDurations);
-      let type;
-      let timeout = 0;
-      let propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION) {
-          if (animationTimeout > 0) {
-              type = ANIMATION;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
-                  : null;
-          propCount = type
-              ? type === TRANSITION
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-      return {
-          type,
-          timeout,
-          propCount,
-          hasTransform,
-      };
-  }
-  function getTimeout(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map((d, i) => {
-          return toMs(d) + toMs(delays[i]);
-      }));
-  }
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+  function resolveTransition(def) {
+      if (!def) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def === 'object') {
+          const res = {};
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
+          }
+          extend(res, def);
+          return res;
+      }
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
+      }
+  }
+  const autoCssTransition = cached((name) => {
+      return {
+          enterClass: `${name}-enter`,
+          enterToClass: `${name}-enter-to`,
+          enterActiveClass: `${name}-enter-active`,
+          leaveClass: `${name}-leave`,
+          leaveToClass: `${name}-leave-to`,
+          leaveActiveClass: `${name}-leave-active`,
+      };
+  });
+  const hasTransition = inBrowser && !isIE9;
+  const TRANSITION = 'transition';
+  const ANIMATION = 'animation';
+  // Transition property/event sniffing
+  let transitionProp = 'transition';
+  let transitionEndEvent = 'transitionend';
+  let animationProp = 'animation';
+  let animationEndEvent = 'animationend';
+  if (hasTransition) {
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
+  }
+  // binding to window is necessary to make hot reload work in IE in strict mode
+  const raf = inBrowser
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ (fn) => fn();
+  function nextFrame(fn) {
+      raf(() => {
+          // @ts-expect-error
+          raf(fn);
+      });
+  }
+  function addTransitionClass(el, cls) {
+      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
+  }
+  function removeTransitionClass(el, cls) {
+      if (el._transitionClasses) {
+          remove$2(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
+  }
+  function whenTransitionEnds(el, expectedType, cb) {
+      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+      if (!type)
+          return cb();
+      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      let ended = 0;
+      const end = () => {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      const onEnd = (e) => {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(() => {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
+  }
+  const transformRE = /\b(transform|all)(,|$)/;
+  function getTransitionInfo(el, expectedType) {
+      const styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      const animationTimeout = getTimeout(animationDelays, animationDurations);
+      let type;
+      let timeout = 0;
+      let propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
+      }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type,
+          timeout,
+          propCount,
+          hasTransform,
+      };
+  }
+  function getTimeout(delays, durations) {
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map((d, i) => {
+          return toMs(d) + toMs(delays[i]);
+      }));
+  }
+  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+  // in a locale-dependent way, using a comma instead of a dot.
+  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+  // as a floor function) causing unexpected behaviors
+  function toMs(s) {
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  function enter(vnode, toggleDisplay) {
-      const el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      let context = activeInstance;
-      let transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      const isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      const startClass = isAppear && appearClass ? appearClass : enterClass;
-      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      const enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      const enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
-      }
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(enterHook);
-      const cb = (el._enterCb = once(() => {
-          if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', () => {
-              const parent = el.parentNode;
-              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
-      if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(() => {
-              removeTransitionClass(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
-      }
-  }
-  function leave(vnode, rm) {
-      const el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
-      }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
-      }
-      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(leave);
-      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
-      }
-      const cb = (el._leaveCb = once(() => {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
-              }
-              leaveCancelled && leaveCancelled(el);
-          }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
-      }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(() => {
-                  removeTransitionClass(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
-      }
-  }
-  // only used in dev mode
-  function checkDuration(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-              `got ${JSON.stringify(val)}.`, vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn$2(`<transition> explicit ${name} duration is NaN - ` +
-              'the duration expression might be incorrect.', vnode.context);
-      }
-  }
-  function isValidDuration(val) {
-      return typeof val === 'number' && !isNaN(val);
-  }
-  /**
-   * Normalize a transition hook's argument length. The hook may be:
-   * - a merged hook (invoker) with the original in .fns
-   * - a wrapped component method (check ._length)
-   * - a plain function (.length)
-   */
-  function getHookArgumentsLength(fn) {
-      if (isUndef(fn)) {
-          return false;
-      }
-      // @ts-expect-error
-      const invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-      }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
-      }
-  }
-  function _enter(_, vnode) {
-      if (vnode.data.show !== true) {
-          enter(vnode);
-      }
-  }
-  var transition = inBrowser
-      ? {
-          create: _enter,
-          activate: _enter,
-          remove(vnode, rm) {
-              /* istanbul ignore else */
-              if (vnode.data.show !== true) {
-                  // @ts-expect-error
-                  leave(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          },
-      }
+  function enter(vnode, toggleDisplay) {
+      const el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
+      }
+      const data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
+      }
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      let context = activeInstance;
+      let transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      const isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      const startClass = isAppear && appearClass ? appearClass : enterClass;
+      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      const enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      const enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(enterHook);
+      const cb = (el._enterCb = once(() => {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', () => {
+              const parent = el.parentNode;
+              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
+      }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
+      if (expectsCSS) {
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(() => {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
+      if (!expectsCSS && !userWantsControl) {
+          cb();
+      }
+  }
+  function leave(vnode, rm) {
+      const el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
+      }
+      const data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
+      }
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
+      }
+      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(leave);
+      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      const cb = (el._leaveCb = once(() => {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
+              }
+              leaveCancelled && leaveCancelled(el);
+          }
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
+      }
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(() => {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
+      }
+  }
+  // only used in dev mode
+  function checkDuration(val, name, vnode) {
+      if (typeof val !== 'number') {
+          warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
+              `got ${JSON.stringify(val)}.`, vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn$2(`<transition> explicit ${name} duration is NaN - ` +
+              'the duration expression might be incorrect.', vnode.context);
+      }
+  }
+  function isValidDuration(val) {
+      return typeof val === 'number' && !isNaN(val);
+  }
+  /**
+   * Normalize a transition hook's argument length. The hook may be:
+   * - a merged hook (invoker) with the original in .fns
+   * - a wrapped component method (check ._length)
+   * - a plain function (.length)
+   */
+  function getHookArgumentsLength(fn) {
+      if (isUndef(fn)) {
+          return false;
+      }
+      // @ts-expect-error
+      const invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
+  }
+  function _enter(_, vnode) {
+      if (vnode.data.show !== true) {
+          enter(vnode);
+      }
+  }
+  var transition = inBrowser
+      ? {
+          create: _enter,
+          activate: _enter,
+          remove(vnode, rm) {
+              /* istanbul ignore else */
+              if (vnode.data.show !== true) {
+                  // @ts-expect-error
+                  leave(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          },
+      }
       : {};
 
   var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
 
-  // the directive module should be applied last, after all
-  // built-in modules have been applied.
-  const modules$1 = platformModules.concat(baseModules);
+  // the directive module should be applied last, after all
+  // built-in modules have been applied.
+  const modules$1 = platformModules.concat(baseModules);
   const patch = createPatchFunction({ nodeOps, modules: modules$1 });
 
-  /**
-   * Not type checking this file because flow doesn't like attaching
-   * properties to Elements.
-   */
-  /* istanbul ignore if */
-  if (isIE9) {
-      // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', () => {
-          const el = document.activeElement;
-          // @ts-expect-error
-          if (el && el.vmodel) {
-              trigger(el, 'input');
-          }
-      });
-  }
-  const directive = {
-      inserted(el, binding, vnode, oldVnode) {
-          if (vnode.tag === 'select') {
-              // #6903
-              if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', () => {
-                      directive.componentUpdated(el, binding, vnode);
-                  });
-              }
-              else {
-                  setSelected(el, binding, vnode.context);
-              }
-              el._vOptions = [].map.call(el.options, getValue);
-          }
-          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-              el._vModifiers = binding.modifiers;
-              if (!binding.modifiers.lazy) {
-                  el.addEventListener('compositionstart', onCompositionStart);
-                  el.addEventListener('compositionend', onCompositionEnd);
-                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                  // switching focus before confirming composition choice
-                  // this also fixes the issue where some browsers e.g. iOS Chrome
-                  // fires "change" instead of "input" on autocomplete.
-                  el.addEventListener('change', onCompositionEnd);
-                  /* istanbul ignore if */
-                  if (isIE9) {
-                      el.vmodel = true;
-                  }
-              }
-          }
-      },
-      componentUpdated(el, binding, vnode) {
-          if (vnode.tag === 'select') {
-              setSelected(el, binding, vnode.context);
-              // in case the options rendered by v-for have changed,
-              // it's possible that the value is out-of-sync with the rendered options.
-              // detect such cases and filter out values that no longer has a matching
-              // option in the DOM.
-              const prevOptions = el._vOptions;
-              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                  // trigger change event if
-                  // no matching option found for at least one value
-                  const needReset = el.multiple
-                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                      : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
-                  if (needReset) {
-                      trigger(el, 'change');
-                  }
-              }
-          }
-      },
-  };
-  function setSelected(el, binding, vm) {
-      actuallySetSelected(el, binding, vm);
-      /* istanbul ignore if */
-      if (isIE || isEdge) {
-          setTimeout(() => {
-              actuallySetSelected(el, binding, vm);
-          }, 0);
-      }
-  }
-  function actuallySetSelected(el, binding, vm) {
-      const value = binding.value;
-      const isMultiple = el.multiple;
-      if (isMultiple && !Array.isArray(value)) {
-          warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                  `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-          return;
-      }
-      let selected, option;
-      for (let i = 0, l = el.options.length; i < l; i++) {
-          option = el.options[i];
-          if (isMultiple) {
-              selected = looseIndexOf(value, getValue(option)) > -1;
-              if (option.selected !== selected) {
-                  option.selected = selected;
-              }
-          }
-          else {
-              if (looseEqual(getValue(option), value)) {
-                  if (el.selectedIndex !== i) {
-                      el.selectedIndex = i;
-                  }
-                  return;
-              }
-          }
-      }
-      if (!isMultiple) {
-          el.selectedIndex = -1;
-      }
-  }
-  function hasNoMatchingOption(value, options) {
-      return options.every((o) => !looseEqual(o, value));
-  }
-  function getValue(option) {
-      return '_value' in option ? option._value : option.value;
-  }
-  function onCompositionStart(e) {
-      e.target.composing = true;
-  }
-  function onCompositionEnd(e) {
-      // prevent triggering an input event for no reason
-      if (!e.target.composing)
-          return;
-      e.target.composing = false;
-      trigger(e.target, 'input');
-  }
-  function trigger(el, type) {
-      const e = document.createEvent('HTMLEvents');
-      e.initEvent(type, true, true);
-      el.dispatchEvent(e);
+  /**
+   * Not type checking this file because flow doesn't like attaching
+   * properties to Elements.
+   */
+  /* istanbul ignore if */
+  if (isIE9) {
+      // http://www.matts411.com/post/internet-explorer-9-oninput/
+      document.addEventListener('selectionchange', () => {
+          const el = document.activeElement;
+          // @ts-expect-error
+          if (el && el.vmodel) {
+              trigger(el, 'input');
+          }
+      });
+  }
+  const directive = {
+      inserted(el, binding, vnode, oldVnode) {
+          if (vnode.tag === 'select') {
+              // #6903
+              if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                  mergeVNodeHook(vnode, 'postpatch', () => {
+                      directive.componentUpdated(el, binding, vnode);
+                  });
+              }
+              else {
+                  setSelected(el, binding, vnode.context);
+              }
+              el._vOptions = [].map.call(el.options, getValue);
+          }
+          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+              el._vModifiers = binding.modifiers;
+              if (!binding.modifiers.lazy) {
+                  el.addEventListener('compositionstart', onCompositionStart);
+                  el.addEventListener('compositionend', onCompositionEnd);
+                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                  // switching focus before confirming composition choice
+                  // this also fixes the issue where some browsers e.g. iOS Chrome
+                  // fires "change" instead of "input" on autocomplete.
+                  el.addEventListener('change', onCompositionEnd);
+                  /* istanbul ignore if */
+                  if (isIE9) {
+                      el.vmodel = true;
+                  }
+              }
+          }
+      },
+      componentUpdated(el, binding, vnode) {
+          if (vnode.tag === 'select') {
+              setSelected(el, binding, vnode.context);
+              // in case the options rendered by v-for have changed,
+              // it's possible that the value is out-of-sync with the rendered options.
+              // detect such cases and filter out values that no longer has a matching
+              // option in the DOM.
+              const prevOptions = el._vOptions;
+              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                  // trigger change event if
+                  // no matching option found for at least one value
+                  const needReset = el.multiple
+                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                      : binding.value !== binding.oldValue &&
+                          hasNoMatchingOption(binding.value, curOptions);
+                  if (needReset) {
+                      trigger(el, 'change');
+                  }
+              }
+          }
+      },
+  };
+  function setSelected(el, binding, vm) {
+      actuallySetSelected(el, binding, vm);
+      /* istanbul ignore if */
+      if (isIE || isEdge) {
+          setTimeout(() => {
+              actuallySetSelected(el, binding, vm);
+          }, 0);
+      }
+  }
+  function actuallySetSelected(el, binding, vm) {
+      const value = binding.value;
+      const isMultiple = el.multiple;
+      if (isMultiple && !Array.isArray(value)) {
+          warn$2(`<select multiple v-model="${binding.expression}"> ` +
+                  `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+          return;
+      }
+      let selected, option;
+      for (let i = 0, l = el.options.length; i < l; i++) {
+          option = el.options[i];
+          if (isMultiple) {
+              selected = looseIndexOf(value, getValue(option)) > -1;
+              if (option.selected !== selected) {
+                  option.selected = selected;
+              }
+          }
+          else {
+              if (looseEqual(getValue(option), value)) {
+                  if (el.selectedIndex !== i) {
+                      el.selectedIndex = i;
+                  }
+                  return;
+              }
+          }
+      }
+      if (!isMultiple) {
+          el.selectedIndex = -1;
+      }
+  }
+  function hasNoMatchingOption(value, options) {
+      return options.every((o) => !looseEqual(o, value));
+  }
+  function getValue(option) {
+      return '_value' in option ? option._value : option.value;
+  }
+  function onCompositionStart(e) {
+      e.target.composing = true;
+  }
+  function onCompositionEnd(e) {
+      // prevent triggering an input event for no reason
+      if (!e.target.composing)
+          return;
+      e.target.composing = false;
+      trigger(e.target, 'input');
+  }
+  function trigger(el, type) {
+      const e = document.createEvent('HTMLEvents');
+      e.initEvent(type, true, true);
+      el.dispatchEvent(e);
   }
 
-  // recursively search for possible transition defined inside the component root
-  function locateNode(vnode) {
-      // @ts-expect-error
-      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-          ? locateNode(vnode.componentInstance._vnode)
-          : vnode;
-  }
-  var show = {
-      bind(el, { value }, vnode) {
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          const originalDisplay = (el.__vOriginalDisplay =
-              el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition) {
-              vnode.data.show = true;
-              enter(vnode, () => {
-                  el.style.display = originalDisplay;
-              });
-          }
-          else {
-              el.style.display = value ? originalDisplay : 'none';
-          }
-      },
-      update(el, { value, oldValue }, vnode) {
-          /* istanbul ignore if */
-          if (!value === !oldValue)
-              return;
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          if (transition) {
-              vnode.data.show = true;
-              if (value) {
-                  enter(vnode, () => {
-                      el.style.display = el.__vOriginalDisplay;
-                  });
-              }
-              else {
-                  leave(vnode, () => {
-                      el.style.display = 'none';
-                  });
-              }
-          }
-          else {
-              el.style.display = value ? el.__vOriginalDisplay : 'none';
-          }
-      },
-      unbind(el, binding, vnode, oldVnode, isDestroy) {
-          if (!isDestroy) {
-              el.style.display = el.__vOriginalDisplay;
-          }
-      },
+  // recursively search for possible transition defined inside the component root
+  function locateNode(vnode) {
+      // @ts-expect-error
+      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+          ? locateNode(vnode.componentInstance._vnode)
+          : vnode;
+  }
+  var show = {
+      bind(el, { value }, vnode) {
+          vnode = locateNode(vnode);
+          const transition = vnode.data && vnode.data.transition;
+          const originalDisplay = (el.__vOriginalDisplay =
+              el.style.display === 'none' ? '' : el.style.display);
+          if (value && transition) {
+              vnode.data.show = true;
+              enter(vnode, () => {
+                  el.style.display = originalDisplay;
+              });
+          }
+          else {
+              el.style.display = value ? originalDisplay : 'none';
+          }
+      },
+      update(el, { value, oldValue }, vnode) {
+          /* istanbul ignore if */
+          if (!value === !oldValue)
+              return;
+          vnode = locateNode(vnode);
+          const transition = vnode.data && vnode.data.transition;
+          if (transition) {
+              vnode.data.show = true;
+              if (value) {
+                  enter(vnode, () => {
+                      el.style.display = el.__vOriginalDisplay;
+                  });
+              }
+              else {
+                  leave(vnode, () => {
+                      el.style.display = 'none';
+                  });
+              }
+          }
+          else {
+              el.style.display = value ? el.__vOriginalDisplay : 'none';
+          }
+      },
+      unbind(el, binding, vnode, oldVnode, isDestroy) {
+          if (!isDestroy) {
+              el.style.display = el.__vOriginalDisplay;
+          }
+      },
   };
 
-  var platformDirectives = {
-      model: directive,
-      show,
+  var platformDirectives = {
+      model: directive,
+      show,
   };
 
-  // Provides transition support for a single element/component.
-  const transitionProps = {
-      name: String,
-      appear: Boolean,
-      css: Boolean,
-      mode: String,
-      type: String,
-      enterClass: String,
-      leaveClass: String,
-      enterToClass: String,
-      leaveToClass: String,
-      enterActiveClass: String,
-      leaveActiveClass: String,
-      appearClass: String,
-      appearActiveClass: String,
-      appearToClass: String,
-      duration: [Number, String, Object],
-  };
-  // in case the child is also an abstract component, e.g. <keep-alive>
-  // we want to recursively retrieve the real component to be rendered
-  function getRealChild(vnode) {
-      const compOptions = vnode && vnode.componentOptions;
-      if (compOptions && compOptions.Ctor.options.abstract) {
-          return getRealChild(getFirstComponentChild(compOptions.children));
-      }
-      else {
-          return vnode;
-      }
-  }
-  function extractTransitionData(comp) {
-      const data = {};
-      const options = comp.$options;
-      // props
-      for (const key in options.propsData) {
-          data[key] = comp[key];
-      }
-      // events.
-      // extract listeners and pass them directly to the transition methods
-      const listeners = options._parentListeners;
-      for (const key in listeners) {
-          data[camelize(key)] = listeners[key];
-      }
-      return data;
-  }
-  function placeholder(h, rawChild) {
-      // @ts-expect-error
-      if (/\d-keep-alive$/.test(rawChild.tag)) {
-          return h('keep-alive', {
-              props: rawChild.componentOptions.propsData,
-          });
-      }
-  }
-  function hasParentTransition(vnode) {
-      while ((vnode = vnode.parent)) {
-          if (vnode.data.transition) {
-              return true;
-          }
-      }
-  }
-  function isSameChild(child, oldChild) {
-      return oldChild.key === child.key && oldChild.tag === child.tag;
-  }
-  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-  const isVShowDirective = (d) => d.name === 'show';
-  var Transition = {
-      name: 'transition',
-      props: transitionProps,
-      abstract: true,
-      render(h) {
-          let children = this.$slots.default;
-          if (!children) {
-              return;
-          }
-          // filter out text nodes (possible whitespaces)
-          children = children.filter(isNotTextNode);
-          /* istanbul ignore if */
-          if (!children.length) {
-              return;
-          }
-          // warn multiple elements
-          if (children.length > 1) {
-              warn$2('<transition> can only be used on a single element. Use ' +
-                  '<transition-group> for lists.', this.$parent);
-          }
-          const mode = this.mode;
-          // warn invalid mode
-          if (mode &&
-              mode !== 'in-out' &&
-              mode !== 'out-in') {
-              warn$2('invalid <transition> mode: ' + mode, this.$parent);
-          }
-          const rawChild = children[0];
-          // if this is a component root node and the component's
-          // parent container node also has transition, skip.
-          if (hasParentTransition(this.$vnode)) {
-              return rawChild;
-          }
-          // apply transition data to child
-          // use getRealChild() to ignore abstract components e.g. keep-alive
-          const child = getRealChild(rawChild);
-          /* istanbul ignore if */
-          if (!child) {
-              return rawChild;
-          }
-          if (this._leaving) {
-              return placeholder(h, rawChild);
-          }
-          // ensure a key that is unique to the vnode type and to this transition
-          // component instance. This key will be used to remove pending leaving nodes
-          // during entering.
-          const id = `__transition-${this._uid}-`;
-          child.key =
-              child.key == null
-                  ? child.isComment
-                      ? id + 'comment'
-                      : id + child.tag
-                  : isPrimitive(child.key)
-                      ? String(child.key).indexOf(id) === 0
-                          ? child.key
-                          : id + child.key
-                      : child.key;
-          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          const oldRawChild = this._vnode;
-          const oldChild = getRealChild(oldRawChild);
-          // mark v-show
-          // so that the transition module can hand over the control to the directive
-          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-              child.data.show = true;
-          }
-          if (oldChild &&
-              oldChild.data &&
-              !isSameChild(child, oldChild) &&
-              !isAsyncPlaceholder(oldChild) &&
-              // #6687 component root is a comment node
-              !(oldChild.componentInstance &&
-                  oldChild.componentInstance._vnode.isComment)) {
-              // replace old child transition data with fresh one
-              // important for dynamic transitions!
-              const oldData = (oldChild.data.transition = extend({}, data));
-              // handle transition mode
-              if (mode === 'out-in') {
-                  // return placeholder node and queue update when leave finishes
-                  this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', () => {
-                      this._leaving = false;
-                      this.$forceUpdate();
-                  });
-                  return placeholder(h, rawChild);
-              }
-              else if (mode === 'in-out') {
-                  if (isAsyncPlaceholder(child)) {
-                      return oldRawChild;
-                  }
-                  let delayedLeave;
-                  const performLeave = () => {
-                      delayedLeave();
-                  };
-                  mergeVNodeHook(data, 'afterEnter', performLeave);
-                  mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                      delayedLeave = leave;
-                  });
-              }
-          }
-          return rawChild;
-      },
+  // Provides transition support for a single element/component.
+  const transitionProps = {
+      name: String,
+      appear: Boolean,
+      css: Boolean,
+      mode: String,
+      type: String,
+      enterClass: String,
+      leaveClass: String,
+      enterToClass: String,
+      leaveToClass: String,
+      enterActiveClass: String,
+      leaveActiveClass: String,
+      appearClass: String,
+      appearActiveClass: String,
+      appearToClass: String,
+      duration: [Number, String, Object],
+  };
+  // in case the child is also an abstract component, e.g. <keep-alive>
+  // we want to recursively retrieve the real component to be rendered
+  function getRealChild(vnode) {
+      const compOptions = vnode && vnode.componentOptions;
+      if (compOptions && compOptions.Ctor.options.abstract) {
+          return getRealChild(getFirstComponentChild(compOptions.children));
+      }
+      else {
+          return vnode;
+      }
+  }
+  function extractTransitionData(comp) {
+      const data = {};
+      const options = comp.$options;
+      // props
+      for (const key in options.propsData) {
+          data[key] = comp[key];
+      }
+      // events.
+      // extract listeners and pass them directly to the transition methods
+      const listeners = options._parentListeners;
+      for (const key in listeners) {
+          data[camelize(key)] = listeners[key];
+      }
+      return data;
+  }
+  function placeholder(h, rawChild) {
+      // @ts-expect-error
+      if (/\d-keep-alive$/.test(rawChild.tag)) {
+          return h('keep-alive', {
+              props: rawChild.componentOptions.propsData,
+          });
+      }
+  }
+  function hasParentTransition(vnode) {
+      while ((vnode = vnode.parent)) {
+          if (vnode.data.transition) {
+              return true;
+          }
+      }
+  }
+  function isSameChild(child, oldChild) {
+      return oldChild.key === child.key && oldChild.tag === child.tag;
+  }
+  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+  const isVShowDirective = (d) => d.name === 'show';
+  var Transition = {
+      name: 'transition',
+      props: transitionProps,
+      abstract: true,
+      render(h) {
+          let children = this.$slots.default;
+          if (!children) {
+              return;
+          }
+          // filter out text nodes (possible whitespaces)
+          children = children.filter(isNotTextNode);
+          /* istanbul ignore if */
+          if (!children.length) {
+              return;
+          }
+          // warn multiple elements
+          if (children.length > 1) {
+              warn$2('<transition> can only be used on a single element. Use ' +
+                  '<transition-group> for lists.', this.$parent);
+          }
+          const mode = this.mode;
+          // warn invalid mode
+          if (mode &&
+              mode !== 'in-out' &&
+              mode !== 'out-in') {
+              warn$2('invalid <transition> mode: ' + mode, this.$parent);
+          }
+          const rawChild = children[0];
+          // if this is a component root node and the component's
+          // parent container node also has transition, skip.
+          if (hasParentTransition(this.$vnode)) {
+              return rawChild;
+          }
+          // apply transition data to child
+          // use getRealChild() to ignore abstract components e.g. keep-alive
+          const child = getRealChild(rawChild);
+          /* istanbul ignore if */
+          if (!child) {
+              return rawChild;
+          }
+          if (this._leaving) {
+              return placeholder(h, rawChild);
+          }
+          // ensure a key that is unique to the vnode type and to this transition
+          // component instance. This key will be used to remove pending leaving nodes
+          // during entering.
+          const id = `__transition-${this._uid}-`;
+          child.key =
+              child.key == null
+                  ? child.isComment
+                      ? id + 'comment'
+                      : id + child.tag
+                  : isPrimitive(child.key)
+                      ? String(child.key).indexOf(id) === 0
+                          ? child.key
+                          : id + child.key
+                      : child.key;
+          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          const oldRawChild = this._vnode;
+          const oldChild = getRealChild(oldRawChild);
+          // mark v-show
+          // so that the transition module can hand over the control to the directive
+          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+              child.data.show = true;
+          }
+          if (oldChild &&
+              oldChild.data &&
+              !isSameChild(child, oldChild) &&
+              !isAsyncPlaceholder(oldChild) &&
+              // #6687 component root is a comment node
+              !(oldChild.componentInstance &&
+                  oldChild.componentInstance._vnode.isComment)) {
+              // replace old child transition data with fresh one
+              // important for dynamic transitions!
+              const oldData = (oldChild.data.transition = extend({}, data));
+              // handle transition mode
+              if (mode === 'out-in') {
+                  // return placeholder node and queue update when leave finishes
+                  this._leaving = true;
+                  mergeVNodeHook(oldData, 'afterLeave', () => {
+                      this._leaving = false;
+                      this.$forceUpdate();
+                  });
+                  return placeholder(h, rawChild);
+              }
+              else if (mode === 'in-out') {
+                  if (isAsyncPlaceholder(child)) {
+                      return oldRawChild;
+                  }
+                  let delayedLeave;
+                  const performLeave = () => {
+                      delayedLeave();
+                  };
+                  mergeVNodeHook(data, 'afterEnter', performLeave);
+                  mergeVNodeHook(data, 'enterCancelled', performLeave);
+                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                      delayedLeave = leave;
+                  });
+              }
+          }
+          return rawChild;
+      },
   };
 
-  // Provides transition support for list items.
-  const props = extend({
-      tag: String,
-      moveClass: String,
-  }, transitionProps);
-  delete props.mode;
-  var TransitionGroup = {
-      props,
-      beforeMount() {
-          const update = this._update;
-          this._update = (vnode, hydrating) => {
-              const restoreActiveInstance = setActiveInstance(this);
-              // force removing pass
-              this.__patch__(this._vnode, this.kept, false, // hydrating
-              true // removeOnly (!important, avoids unnecessary moves)
-              );
-              this._vnode = this.kept;
-              restoreActiveInstance();
-              update.call(this, vnode, hydrating);
-          };
-      },
-      render(h) {
-          const tag = this.tag || this.$vnode.data.tag || "span";
-          const map = Object.create(null);
-          const prevChildren = (this.prevChildren = this.children);
-          const rawChildren = this.$slots.default || [];
-          const children = (this.children = []);
-          const transitionData = extractTransitionData(this);
-          for (let i = 0; i < rawChildren.length; i++) {
-              const c = rawChildren[i];
-              if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                      children.push(c);
-                      map[c.key] = c;
-                      (c.data || (c.data = {})).transition = transitionData;
-                  }
-                  else {
-                      const opts = c.componentOptions;
-                      const name = opts
-                          ? opts.Ctor.options.name || opts.tag || ""
-                          : c.tag;
-                      warn$2(`<transition-group> children must be keyed: <${name}>`);
-                  }
-              }
-          }
-          if (prevChildren) {
-              const kept = [];
-              const removed = [];
-              for (let i = 0; i < prevChildren.length; i++) {
-                  const c = prevChildren[i];
-                  c.data.transition = transitionData;
-                  // @ts-expect-error .getBoundingClientRect is not typed in Node
-                  c.data.pos = c.elm.getBoundingClientRect();
-                  if (map[c.key]) {
-                      kept.push(c);
-                  }
-                  else {
-                      removed.push(c);
-                  }
-              }
-              this.kept = h(tag, null, kept);
-              this.removed = removed;
-          }
-          return h(tag, null, children);
-      },
-      updated() {
-          const children = this.prevChildren;
-          const moveClass = this.moveClass || (this.name || "v") + "-move";
-          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-              return;
-          }
-          // we divide the work into three loops to avoid mixing DOM reads and writes
-          // in each iteration - which helps prevent layout thrashing.
-          children.forEach(callPendingCbs);
-          children.forEach(recordPosition);
-          children.forEach(applyTranslation);
-          // force reflow to put everything in position
-          // assign to this to avoid being removed in tree-shaking
-          // $flow-disable-line
-          this._reflow = document.body.offsetHeight;
-          children.forEach((c) => {
-              if (c.data.moved) {
-                  const el = c.elm;
-                  const s = el.style;
-                  addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = "";
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
-                          return;
-                      }
-                      if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
-                      }
-                  }));
-              }
-          });
-      },
-      methods: {
-          hasMove(el, moveClass) {
-              /* istanbul ignore if */
-              if (!hasTransition) {
-                  return false;
-              }
-              /* istanbul ignore if */
-              if (this._hasMove) {
-                  return this._hasMove;
-              }
-              // Detect whether an element with the move class applied has
-              // CSS transitions. Since the element may be inside an entering
-              // transition at this very moment, we make a clone of it and remove
-              // all other transition classes applied to ensure only the move class
-              // is applied.
-              const clone = el.cloneNode();
-              if (el._transitionClasses) {
-                  el._transitionClasses.forEach((cls) => {
-                      removeClass(clone, cls);
-                  });
-              }
-              addClass(clone, moveClass);
-              clone.style.display = "none";
-              this.$el.appendChild(clone);
-              const info = getTransitionInfo(clone);
-              this.$el.removeChild(clone);
-              return (this._hasMove = info.hasTransform);
-          },
-      },
-  };
-  function callPendingCbs(c) {
-      /* istanbul ignore if */
-      if (c.elm._moveCb) {
-          c.elm._moveCb();
-      }
-      /* istanbul ignore if */
-      if (c.elm._enterCb) {
-          c.elm._enterCb();
-      }
-  }
-  function recordPosition(c) {
-      c.data.newPos = c.elm.getBoundingClientRect();
-  }
-  function applyTranslation(c) {
-      const oldPos = c.data.pos;
-      const newPos = c.data.newPos;
-      const dx = oldPos.left - newPos.left;
-      const dy = oldPos.top - newPos.top;
-      if (dx || dy) {
-          c.data.moved = true;
-          const s = c.elm.style;
-          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-          s.transitionDuration = "0s";
-      }
+  // Provides transition support for list items.
+  const props = extend({
+      tag: String,
+      moveClass: String,
+  }, transitionProps);
+  delete props.mode;
+  var TransitionGroup = {
+      props,
+      beforeMount() {
+          const update = this._update;
+          this._update = (vnode, hydrating) => {
+              const restoreActiveInstance = setActiveInstance(this);
+              // force removing pass
+              this.__patch__(this._vnode, this.kept, false, // hydrating
+              true // removeOnly (!important, avoids unnecessary moves)
+              );
+              this._vnode = this.kept;
+              restoreActiveInstance();
+              update.call(this, vnode, hydrating);
+          };
+      },
+      render(h) {
+          const tag = this.tag || this.$vnode.data.tag || "span";
+          const map = Object.create(null);
+          const prevChildren = (this.prevChildren = this.children);
+          const rawChildren = this.$slots.default || [];
+          const children = (this.children = []);
+          const transitionData = extractTransitionData(this);
+          for (let i = 0; i < rawChildren.length; i++) {
+              const c = rawChildren[i];
+              if (c.tag) {
+                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                      children.push(c);
+                      map[c.key] = c;
+                      (c.data || (c.data = {})).transition = transitionData;
+                  }
+                  else {
+                      const opts = c.componentOptions;
+                      const name = opts
+                          ? opts.Ctor.options.name || opts.tag || ""
+                          : c.tag;
+                      warn$2(`<transition-group> children must be keyed: <${name}>`);
+                  }
+              }
+          }
+          if (prevChildren) {
+              const kept = [];
+              const removed = [];
+              for (let i = 0; i < prevChildren.length; i++) {
+                  const c = prevChildren[i];
+                  c.data.transition = transitionData;
+                  // @ts-expect-error .getBoundingClientRect is not typed in Node
+                  c.data.pos = c.elm.getBoundingClientRect();
+                  if (map[c.key]) {
+                      kept.push(c);
+                  }
+                  else {
+                      removed.push(c);
+                  }
+              }
+              this.kept = h(tag, null, kept);
+              this.removed = removed;
+          }
+          return h(tag, null, children);
+      },
+      updated() {
+          const children = this.prevChildren;
+          const moveClass = this.moveClass || (this.name || "v") + "-move";
+          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+              return;
+          }
+          // we divide the work into three loops to avoid mixing DOM reads and writes
+          // in each iteration - which helps prevent layout thrashing.
+          children.forEach(callPendingCbs);
+          children.forEach(recordPosition);
+          children.forEach(applyTranslation);
+          // force reflow to put everything in position
+          // assign to this to avoid being removed in tree-shaking
+          // $flow-disable-line
+          this._reflow = document.body.offsetHeight;
+          children.forEach((c) => {
+              if (c.data.moved) {
+                  const el = c.elm;
+                  const s = el.style;
+                  addTransitionClass(el, moveClass);
+                  s.transform = s.WebkitTransform = s.transitionDuration = "";
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
+                          return;
+                      }
+                      if (!e || /transform$/.test(e.propertyName)) {
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
+                      }
+                  }));
+              }
+          });
+      },
+      methods: {
+          hasMove(el, moveClass) {
+              /* istanbul ignore if */
+              if (!hasTransition) {
+                  return false;
+              }
+              /* istanbul ignore if */
+              if (this._hasMove) {
+                  return this._hasMove;
+              }
+              // Detect whether an element with the move class applied has
+              // CSS transitions. Since the element may be inside an entering
+              // transition at this very moment, we make a clone of it and remove
+              // all other transition classes applied to ensure only the move class
+              // is applied.
+              const clone = el.cloneNode();
+              if (el._transitionClasses) {
+                  el._transitionClasses.forEach((cls) => {
+                      removeClass(clone, cls);
+                  });
+              }
+              addClass(clone, moveClass);
+              clone.style.display = "none";
+              this.$el.appendChild(clone);
+              const info = getTransitionInfo(clone);
+              this.$el.removeChild(clone);
+              return (this._hasMove = info.hasTransform);
+          },
+      },
+  };
+  function callPendingCbs(c) {
+      /* istanbul ignore if */
+      if (c.elm._moveCb) {
+          c.elm._moveCb();
+      }
+      /* istanbul ignore if */
+      if (c.elm._enterCb) {
+          c.elm._enterCb();
+      }
+  }
+  function recordPosition(c) {
+      c.data.newPos = c.elm.getBoundingClientRect();
+  }
+  function applyTranslation(c) {
+      const oldPos = c.data.pos;
+      const newPos = c.data.newPos;
+      const dx = oldPos.left - newPos.left;
+      const dy = oldPos.top - newPos.top;
+      if (dx || dy) {
+          c.data.moved = true;
+          const s = c.elm.style;
+          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+          s.transitionDuration = "0s";
+      }
   }
 
-  var platformComponents = {
-      Transition,
-      TransitionGroup,
+  var platformComponents = {
+      Transition,
+      TransitionGroup,
   };
 
-  // install platform specific utils
-  Vue.config.mustUseProp = mustUseProp;
-  Vue.config.isReservedTag = isReservedTag;
-  Vue.config.isReservedAttr = isReservedAttr;
-  Vue.config.getTagNamespace = getTagNamespace;
-  Vue.config.isUnknownElement = isUnknownElement;
-  // install platform runtime directives & components
-  extend(Vue.options.directives, platformDirectives);
-  extend(Vue.options.components, platformComponents);
-  // install platform patch function
-  Vue.prototype.__patch__ = inBrowser ? patch : noop;
-  // public mount method
-  Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query(el) : undefined;
-      return mountComponent(this, el, hydrating);
-  };
-  // devtools global hook
-  /* istanbul ignore next */
-  if (inBrowser) {
-      setTimeout(() => {
-          if (config.devtools) {
-              if (devtools) {
-                  devtools.emit('init', Vue);
-              }
-              else {
-                  // @ts-expect-error
-                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                      'https://github.com/vuejs/vue-devtools');
-              }
-          }
-          if (config.productionTip !== false &&
-              typeof console !== 'undefined') {
-              // @ts-expect-error
-              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                  `Make sure to turn on production mode when deploying for production.\n` +
-                  `See more tips at https://vuejs.org/guide/deployment.html`);
-          }
-      }, 0);
+  // install platform specific utils
+  Vue.config.mustUseProp = mustUseProp;
+  Vue.config.isReservedTag = isReservedTag;
+  Vue.config.isReservedAttr = isReservedAttr;
+  Vue.config.getTagNamespace = getTagNamespace;
+  Vue.config.isUnknownElement = isUnknownElement;
+  // install platform runtime directives & components
+  extend(Vue.options.directives, platformDirectives);
+  extend(Vue.options.components, platformComponents);
+  // install platform patch function
+  Vue.prototype.__patch__ = inBrowser ? patch : noop;
+  // public mount method
+  Vue.prototype.$mount = function (el, hydrating) {
+      el = el && inBrowser ? query(el) : undefined;
+      return mountComponent(this, el, hydrating);
+  };
+  // devtools global hook
+  /* istanbul ignore next */
+  if (inBrowser) {
+      setTimeout(() => {
+          if (config.devtools) {
+              if (devtools) {
+                  devtools.emit('init', Vue);
+              }
+              else {
+                  // @ts-expect-error
+                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                      'https://github.com/vuejs/vue-devtools');
+              }
+          }
+          if (config.productionTip !== false &&
+              typeof console !== 'undefined') {
+              // @ts-expect-error
+              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                  `Make sure to turn on production mode when deploying for production.\n` +
+                  `See more tips at https://vuejs.org/guide/deployment.html`);
+          }
+      }, 0);
   }
 
-  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  const buildRegex = cached((delimiters) => {
-      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-  });
-  function parseText(text, delimiters) {
-      //@ts-expect-error
-      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-      if (!tagRE.test(text)) {
-          return;
-      }
-      const tokens = [];
-      const rawTokens = [];
-      let lastIndex = (tagRE.lastIndex = 0);
-      let match, index, tokenValue;
-      while ((match = tagRE.exec(text))) {
-          index = match.index;
-          // push text token
-          if (index > lastIndex) {
-              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-              tokens.push(JSON.stringify(tokenValue));
-          }
-          // tag token
-          const exp = parseFilters(match[1].trim());
-          tokens.push(`_s(${exp})`);
-          rawTokens.push({ '@binding': exp });
-          lastIndex = index + match[0].length;
-      }
-      if (lastIndex < text.length) {
-          rawTokens.push((tokenValue = text.slice(lastIndex)));
-          tokens.push(JSON.stringify(tokenValue));
-      }
-      return {
-          expression: tokens.join('+'),
-          tokens: rawTokens,
-      };
+  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+  const buildRegex = cached((delimiters) => {
+      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+  });
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      const tokens = [];
+      const rawTokens = [];
+      let lastIndex = (tagRE.lastIndex = 0);
+      let match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          const exp = parseFilters(match[1].trim());
+          tokens.push(`_s(${exp})`);
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
   }
 
-  function transformNode$1(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticClass = getAndRemoveAttr(el, 'class');
-      if (staticClass) {
-          const res = parseText(staticClass, options.delimiters);
-          if (res) {
-              warn(`class="${staticClass}": ` +
-                  'Interpolation inside attributes has been removed. ' +
-                  'Use v-bind or the colon shorthand instead. For example, ' +
-                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-          }
-      }
-      if (staticClass) {
-          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-      }
-      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-      if (classBinding) {
-          el.classBinding = classBinding;
-      }
-  }
-  function genData$2(el) {
-      let data = '';
-      if (el.staticClass) {
-          data += `staticClass:${el.staticClass},`;
-      }
-      if (el.classBinding) {
-          data += `class:${el.classBinding},`;
-      }
-      return data;
-  }
-  var klass = {
-      staticKeys: ['staticClass'],
-      transformNode: transformNode$1,
-      genData: genData$2,
+  function transformNode$1(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          const res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn(`class="${staticClass}": ` +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
+      }
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+      }
+      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
+      }
+  }
+  function genData$2(el) {
+      let data = '';
+      if (el.staticClass) {
+          data += `staticClass:${el.staticClass},`;
+      }
+      if (el.classBinding) {
+          data += `class:${el.classBinding},`;
+      }
+      return data;
+  }
+  var klass = {
+      staticKeys: ['staticClass'],
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
-  function transformNode(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticStyle = getAndRemoveAttr(el, 'style');
-      if (staticStyle) {
-          /* istanbul ignore if */
-          {
-              const res = parseText(staticStyle, options.delimiters);
-              if (res) {
-                  warn(`style="${staticStyle}": ` +
-                      'Interpolation inside attributes has been removed. ' +
-                      'Use v-bind or the colon shorthand instead. For example, ' +
-                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-              }
-          }
-          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-      }
-      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-      if (styleBinding) {
-          el.styleBinding = styleBinding;
-      }
-  }
-  function genData$1(el) {
-      let data = '';
-      if (el.staticStyle) {
-          data += `staticStyle:${el.staticStyle},`;
-      }
-      if (el.styleBinding) {
-          data += `style:(${el.styleBinding}),`;
-      }
-      return data;
-  }
-  var style = {
-      staticKeys: ['staticStyle'],
-      transformNode,
-      genData: genData$1,
+  function transformNode(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              const res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn(`style="${staticStyle}": ` +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
+      }
+  }
+  function genData$1(el) {
+      let data = '';
+      if (el.staticStyle) {
+          data += `staticStyle:${el.staticStyle},`;
+      }
+      if (el.styleBinding) {
+          data += `style:(${el.styleBinding}),`;
+      }
+      return data;
+  }
+  var style = {
+      staticKeys: ['staticStyle'],
+      transformNode,
+      genData: genData$1,
   };
 
-  let decoder;
-  var he = {
-      decode(html) {
-          decoder = decoder || document.createElement('div');
-          decoder.innerHTML = html;
-          return decoder.textContent;
-      },
+  let decoder;
+  var he = {
+      decode(html) {
+          decoder = decoder || document.createElement('div');
+          decoder.innerHTML = html;
+          return decoder.textContent;
+      },
   };
 
-  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr');
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
       'title,tr,track');
 
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-  // Regular Expressions for parsing tags and attributes
-  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-  const startTagOpen = new RegExp(`^<${qnameCapture}`);
-  const startTagClose = /^\s*(\/?)>/;
-  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-  const doctype = /^<!DOCTYPE [^>]+>/i;
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  const comment = /^<!\--/;
-  const conditionalComment = /^<!\[/;
-  // Special Elements (can contain anything)
-  const isPlainTextElement = makeMap('script,style,textarea', true);
-  const reCache = {};
-  const decodingMap = {
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&amp;': '&',
-      '&#10;': '\n',
-      '&#9;': '\t',
-      '&#39;': "'",
-  };
-  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-  // #5992
-  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  function decodeAttr(value, shouldDecodeNewlines) {
-      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-      return value.replace(re, (match) => decodingMap[match]);
-  }
-  function parseHTML(html, options) {
-      const stack = [];
-      const expectHTML = options.expectHTML;
-      const isUnaryTag = options.isUnaryTag || no;
-      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-      let index = 0;
-      let last, lastTag;
-      while (html) {
-          last = html;
-          // Make sure we're not in a plaintext content element like script/style
-          if (!lastTag || !isPlainTextElement(lastTag)) {
-              let textEnd = html.indexOf('<');
-              if (textEnd === 0) {
-                  // Comment:
-                  if (comment.test(html)) {
-                      const commentEnd = html.indexOf('-->');
-                      if (commentEnd >= 0) {
-                          if (options.shouldKeepComment) {
-                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                          }
-                          advance(commentEnd + 3);
-                          continue;
-                      }
-                  }
-                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                  if (conditionalComment.test(html)) {
-                      const conditionalEnd = html.indexOf(']>');
-                      if (conditionalEnd >= 0) {
-                          advance(conditionalEnd + 2);
-                          continue;
-                      }
-                  }
-                  // Doctype:
-                  const doctypeMatch = html.match(doctype);
-                  if (doctypeMatch) {
-                      advance(doctypeMatch[0].length);
-                      continue;
-                  }
-                  // End tag:
-                  const endTagMatch = html.match(endTag);
-                  if (endTagMatch) {
-                      const curIndex = index;
-                      advance(endTagMatch[0].length);
-                      parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
-                  }
-                  // Start tag:
-                  const startTagMatch = parseStartTag();
-                  if (startTagMatch) {
-                      handleStartTag(startTagMatch);
-                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                          advance(1);
-                      }
-                      continue;
-                  }
-              }
-              let text, rest, next;
-              if (textEnd >= 0) {
-                  rest = html.slice(textEnd);
-                  while (!endTag.test(rest) &&
-                      !startTagOpen.test(rest) &&
-                      !comment.test(rest) &&
-                      !conditionalComment.test(rest)) {
-                      // < in plain text, be forgiving and treat it as text
-                      next = rest.indexOf('<', 1);
-                      if (next < 0)
-                          break;
-                      textEnd += next;
-                      rest = html.slice(textEnd);
-                  }
-                  text = html.substring(0, textEnd);
-              }
-              if (textEnd < 0) {
-                  text = html;
-              }
-              if (text) {
-                  advance(text.length);
-              }
-              if (options.chars && text) {
-                  options.chars(text, index - text.length, index);
-              }
-          }
-          else {
-              let endTagLength = 0;
-              const stackedTag = lastTag.toLowerCase();
-              const reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                      text = text
-                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                  }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                      text = text.slice(1);
-                  }
-                  if (options.chars) {
-                      options.chars(text);
-                  }
-                  return '';
-              });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag, index - endTagLength, index);
-          }
-          if (html === last) {
-              options.chars && options.chars(html);
-              if (!stack.length &&
-                  options.warn) {
-                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                      start: index + html.length,
-                  });
-              }
-              break;
-          }
-      }
-      // Clean up any remaining tags
-      parseEndTag();
-      function advance(n) {
-          index += n;
-          html = html.substring(n);
-      }
-      function parseStartTag() {
-          const start = html.match(startTagOpen);
-          if (start) {
-              const match = {
-                  tagName: start[1],
-                  attrs: [],
-                  start: index,
-              };
-              advance(start[0].length);
-              let end, attr;
-              while (!(end = html.match(startTagClose)) &&
-                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                  attr.start = index;
-                  advance(attr[0].length);
-                  attr.end = index;
-                  match.attrs.push(attr);
-              }
-              if (end) {
-                  match.unarySlash = end[1];
-                  advance(end[0].length);
-                  match.end = index;
-                  return match;
-              }
-          }
-      }
-      function handleStartTag(match) {
-          const tagName = match.tagName;
-          const unarySlash = match.unarySlash;
-          if (expectHTML) {
-              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                  parseEndTag(lastTag);
-              }
-              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                  parseEndTag(tagName);
-              }
-          }
-          const unary = isUnaryTag(tagName) || !!unarySlash;
-          const l = match.attrs.length;
-          const attrs = new Array(l);
-          for (let i = 0; i < l; i++) {
-              const args = match.attrs[i];
-              const value = args[3] || args[4] || args[5] || '';
-              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                  ? options.shouldDecodeNewlinesForHref
-                  : options.shouldDecodeNewlines;
-              attrs[i] = {
-                  name: args[1],
-                  value: decodeAttr(value, shouldDecodeNewlines),
-              };
-              if (options.outputSourceRange) {
-                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                  attrs[i].end = args.end;
-              }
-          }
-          if (!unary) {
-              stack.push({
-                  tag: tagName,
-                  lowerCasedTag: tagName.toLowerCase(),
-                  attrs: attrs,
-                  start: match.start,
-                  end: match.end,
-              });
-              lastTag = tagName;
-          }
-          if (options.start) {
-              options.start(tagName, attrs, unary, match.start, match.end);
-          }
-      }
-      function parseEndTag(tagName, start, end) {
-          let pos, lowerCasedTagName;
-          if (start == null)
-              start = index;
-          if (end == null)
-              end = index;
-          // Find the closest opened tag of the same type
-          if (tagName) {
-              lowerCasedTagName = tagName.toLowerCase();
-              for (pos = stack.length - 1; pos >= 0; pos--) {
-                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                      break;
-                  }
-              }
-          }
-          else {
-              // If no tag name is provided, clean shop
-              pos = 0;
-          }
-          if (pos >= 0) {
-              // Close all the open elements, up the stack
-              for (let i = stack.length - 1; i >= pos; i--) {
-                  if ((i > pos || !tagName) &&
-                      options.warn) {
-                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                          start: stack[i].start,
-                          end: stack[i].end,
-                      });
-                  }
-                  if (options.end) {
-                      options.end(stack[i].tag, start, end);
-                  }
-              }
-              // Remove the open elements from the stack
-              stack.length = pos;
-              lastTag = pos && stack[pos - 1].tag;
-          }
-          else if (lowerCasedTagName === 'br') {
-              if (options.start) {
-                  options.start(tagName, [], true, start, end);
-              }
-          }
-          else if (lowerCasedTagName === 'p') {
-              if (options.start) {
-                  options.start(tagName, [], false, start, end);
-              }
-              if (options.end) {
-                  options.end(tagName, start, end);
-              }
-          }
-      }
+  /**
+   * Not type-checking this file because it's mostly vendor code.
+   */
+  // Regular Expressions for parsing tags and attributes
+  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+  const startTagOpen = new RegExp(`^<${qnameCapture}`);
+  const startTagClose = /^\s*(\/?)>/;
+  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+  const doctype = /^<!DOCTYPE [^>]+>/i;
+  // #7298: escape - to avoid being passed as HTML comment when inlined in page
+  const comment = /^<!\--/;
+  const conditionalComment = /^<!\[/;
+  // Special Elements (can contain anything)
+  const isPlainTextElement = makeMap('script,style,textarea', true);
+  const reCache = {};
+  const decodingMap = {
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
+  };
+  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+  // #5992
+  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  function decodeAttr(value, shouldDecodeNewlines) {
+      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, (match) => decodingMap[match]);
+  }
+  function parseHTML(html, options) {
+      const stack = [];
+      const expectHTML = options.expectHTML;
+      const isUnaryTag = options.isUnaryTag || no;
+      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+      let index = 0;
+      let last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              let textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      const commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      const conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  const doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  const endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      const curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  const startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              let text, rest, next;
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          break;
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
+              }
+          }
+          else {
+              let endTagLength = 0;
+              const stackedTag = lastTag.toLowerCase();
+              const reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag, index - endTagLength, index);
+          }
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                      start: index + html.length,
+                  });
+              }
+              break;
+          }
+      }
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          const start = html.match(startTagOpen);
+          if (start) {
+              const match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              let end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
+      }
+      function handleStartTag(match) {
+          const tagName = match.tagName;
+          const unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          const unary = isUnaryTag(tagName) || !!unarySlash;
+          const l = match.attrs.length;
+          const attrs = new Array(l);
+          for (let i = 0; i < l; i++) {
+              const args = match.attrs[i];
+              const value = args[3] || args[4] || args[5] || '';
+              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
+          }
+      }
+      function parseEndTag(tagName, start, end) {
+          let pos, lowerCasedTagName;
+          if (start == null)
+              start = index;
+          if (end == null)
+              end = index;
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (let i = stack.length - 1; i >= pos; i--) {
+                  if ((i > pos || !tagName) &&
+                      options.warn) {
+                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
+          }
+      }
   }
 
-  const onRE = /^@|^v-on:/;
-  const dirRE = /^v-|^@|^:|^#/;
-  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  const stripParensRE = /^\(|\)$/g;
-  const dynamicArgRE = /^\[.*\]$/;
-  const argRE = /:(.*)$/;
-  const bindRE = /^:|^\.|^v-bind:/;
-  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-  const slotRE = /^v-slot(:|$)|^#/;
-  const lineBreakRE = /[\r\n]/;
-  const whitespaceRE = /[ \f\t\r\n]+/g;
-  const invalidAttributeRE = /[\s"'<>\/=]/;
-  const decodeHTMLCached = cached(he.decode);
-  const emptySlotScopeToken = `_empty_`;
-  // configurable state
-  let warn;
-  let delimiters;
-  let transforms;
-  let preTransforms;
-  let postTransforms;
-  let platformIsPreTag;
-  let platformMustUseProp;
-  let platformGetTagNamespace;
-  let maybeComponent;
-  function createASTElement(tag, attrs, parent) {
-      return {
-          type: 1,
-          tag,
-          attrsList: attrs,
-          attrsMap: makeAttrsMap(attrs),
-          rawAttrsMap: {},
-          parent,
-          children: [],
-      };
-  }
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse(template, options) {
-      warn = options.warn || baseWarn;
-      platformIsPreTag = options.isPreTag || no;
-      platformMustUseProp = options.mustUseProp || no;
-      platformGetTagNamespace = options.getTagNamespace || no;
-      const isReservedTag = options.isReservedTag || no;
-      maybeComponent = (el) => !!(el.component ||
-          el.attrsMap[':is'] ||
-          el.attrsMap['v-bind:is'] ||
-          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-      transforms = pluckModuleFunction(options.modules, 'transformNode');
-      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-      delimiters = options.delimiters;
-      const stack = [];
-      const preserveWhitespace = options.preserveWhitespace !== false;
-      const whitespaceOption = options.whitespace;
-      let root;
-      let currentParent;
-      let inVPre = false;
-      let inPre = false;
-      let warned = false;
-      function warnOnce(msg, range) {
-          if (!warned) {
-              warned = true;
-              warn(msg, range);
-          }
-      }
-      function closeElement(element) {
-          trimEndingWhitespace(element);
-          if (!inVPre && !element.processed) {
-              element = processElement(element, options);
-          }
-          // tree management
-          if (!stack.length && element !== root) {
-              // allow root elements with v-if, v-else-if and v-else
-              if (root.if && (element.elseif || element.else)) {
-                  {
-                      checkRootConstraints(element);
-                  }
-                  addIfCondition(root, {
-                      exp: element.elseif,
-                      block: element,
-                  });
-              }
-              else {
-                  warnOnce(`Component template should contain exactly one root element. ` +
-                      `If you are using v-if on multiple elements, ` +
-                      `use v-else-if to chain them instead.`, { start: element.start });
-              }
-          }
-          if (currentParent && !element.forbidden) {
-              if (element.elseif || element.else) {
-                  processIfConditions(element, currentParent);
-              }
-              else {
-                  if (element.slotScope) {
-                      // scoped slot
-                      // keep it in the children list so that v-else(-if) conditions can
-                      // find it as the prev node.
-                      const name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                  }
-                  currentParent.children.push(element);
-                  element.parent = currentParent;
-              }
-          }
-          // final children cleanup
-          // filter out scoped slots
-          element.children = element.children.filter((c) => !c.slotScope);
-          // remove trailing whitespace node again
-          trimEndingWhitespace(element);
-          // check pre state
-          if (element.pre) {
-              inVPre = false;
-          }
-          if (platformIsPreTag(element.tag)) {
-              inPre = false;
-          }
-          // apply post-transforms
-          for (let i = 0; i < postTransforms.length; i++) {
-              postTransforms[i](element, options);
-          }
-      }
-      function trimEndingWhitespace(el) {
-          // remove trailing whitespace node
-          if (!inPre) {
-              let lastNode;
-              while ((lastNode = el.children[el.children.length - 1]) &&
-                  lastNode.type === 3 &&
-                  lastNode.text === ' ') {
-                  el.children.pop();
-              }
-          }
-      }
-      function checkRootConstraints(el) {
-          if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                  'contain multiple nodes.', { start: el.start });
-          }
-          if (el.attrsMap.hasOwnProperty('v-for')) {
-              warnOnce('Cannot use v-for on stateful component root element because ' +
-                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
-          }
-      }
-      parseHTML(template, {
-          warn,
-          expectHTML: options.expectHTML,
-          isUnaryTag: options.isUnaryTag,
-          canBeLeftOpenTag: options.canBeLeftOpenTag,
-          shouldDecodeNewlines: options.shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-          shouldKeepComment: options.comments,
-          outputSourceRange: options.outputSourceRange,
-          start(tag, attrs, unary, start, end) {
-              // check namespace.
-              // inherit parent ns if there is one
-              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-              // handle IE svg bug
-              /* istanbul ignore if */
-              if (isIE && ns === 'svg') {
-                  attrs = guardIESVGBug(attrs);
-              }
-              let element = createASTElement(tag, attrs, currentParent);
-              if (ns) {
-                  element.ns = ns;
-              }
-              {
-                  if (options.outputSourceRange) {
-                      element.start = start;
-                      element.end = end;
-                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                          cumulated[attr.name] = attr;
-                          return cumulated;
-                      }, {});
-                  }
-                  attrs.forEach((attr) => {
-                      if (invalidAttributeRE.test(attr.name)) {
-                          warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                              `spaces, quotes, <, >, / or =.`, {
-                              start: attr.start + attr.name.indexOf(`[`),
-                              end: attr.start + attr.name.length,
-                          });
-                      }
-                  });
-              }
-              if (isForbiddenTag(element) && !isServerRendering()) {
-                  element.forbidden = true;
-                  warn('Templates should only be responsible for mapping the state to the ' +
-                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          `<${tag}>` +
-                          ', as they will not be parsed.', { start: element.start });
-              }
-              // apply pre-transforms
-              for (let i = 0; i < preTransforms.length; i++) {
-                  element = preTransforms[i](element, options) || element;
-              }
-              if (!inVPre) {
-                  processPre(element);
-                  if (element.pre) {
-                      inVPre = true;
-                  }
-              }
-              if (platformIsPreTag(element.tag)) {
-                  inPre = true;
-              }
-              if (inVPre) {
-                  processRawAttrs(element);
-              }
-              else if (!element.processed) {
-                  // structural directives
-                  processFor(element);
-                  processIf(element);
-                  processOnce(element);
-              }
-              if (!root) {
-                  root = element;
-                  {
-                      checkRootConstraints(root);
-                  }
-              }
-              if (!unary) {
-                  currentParent = element;
-                  stack.push(element);
-              }
-              else {
-                  closeElement(element);
-              }
-          },
-          end(tag, start, end) {
-              const element = stack[stack.length - 1];
-              // pop stack
-              stack.length -= 1;
-              currentParent = stack[stack.length - 1];
-              if (options.outputSourceRange) {
-                  element.end = end;
-              }
-              closeElement(element);
-          },
-          chars(text, start, end) {
-              if (!currentParent) {
-                  {
-                      if (text === template) {
-                          warnOnce('Component template requires a root element, rather than just text.', { start });
-                      }
-                      else if ((text = text.trim())) {
-                          warnOnce(`text "${text}" outside root element will be ignored.`, {
-                              start,
-                          });
-                      }
-                  }
-                  return;
-              }
-              // IE textarea placeholder bug
-              /* istanbul ignore if */
-              if (isIE &&
-                  currentParent.tag === 'textarea' &&
-                  currentParent.attrsMap.placeholder === text) {
-                  return;
-              }
-              const children = currentParent.children;
-              if (inPre || text.trim()) {
-                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-              }
-              else if (!children.length) {
-                  // remove the whitespace-only node right after an opening tag
-                  text = '';
-              }
-              else if (whitespaceOption) {
-                  if (whitespaceOption === 'condense') {
-                      // in condense mode, remove the whitespace node if it contains
-                      // line break, otherwise condense to a single space
-                      text = lineBreakRE.test(text) ? '' : ' ';
-                  }
-                  else {
-                      text = ' ';
-                  }
-              }
-              else {
-                  text = preserveWhitespace ? ' ' : '';
-              }
-              if (text) {
-                  if (!inPre && whitespaceOption === 'condense') {
-                      // condense consecutive whitespaces into single space
-                      text = text.replace(whitespaceRE, ' ');
-                  }
-                  let res;
-                  let child;
-                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                      child = {
-                          type: 2,
-                          expression: res.expression,
-                          tokens: res.tokens,
-                          text,
-                      };
-                  }
-                  else if (text !== ' ' ||
-                      !children.length ||
-                      children[children.length - 1].text !== ' ') {
-                      child = {
-                          type: 3,
-                          text,
-                      };
-                  }
-                  if (child) {
-                      if (options.outputSourceRange) {
-                          child.start = start;
-                          child.end = end;
-                      }
-                      children.push(child);
-                  }
-              }
-          },
-          comment(text, start, end) {
-              // adding anything as a sibling to the root node is forbidden
-              // comments should still be allowed, but ignored
-              if (currentParent) {
-                  const child = {
-                      type: 3,
-                      text,
-                      isComment: true,
-                  };
-                  if (options.outputSourceRange) {
-                      child.start = start;
-                      child.end = end;
-                  }
-                  currentParent.children.push(child);
-              }
-          },
-      });
-      return root;
-  }
-  function processPre(el) {
-      if (getAndRemoveAttr(el, 'v-pre') != null) {
-          el.pre = true;
-      }
-  }
-  function processRawAttrs(el) {
-      const list = el.attrsList;
-      const len = list.length;
-      if (len) {
-          const attrs = (el.attrs = new Array(len));
-          for (let i = 0; i < len; i++) {
-              attrs[i] = {
-                  name: list[i].name,
-                  value: JSON.stringify(list[i].value),
-              };
-              if (list[i].start != null) {
-                  attrs[i].start = list[i].start;
-                  attrs[i].end = list[i].end;
-              }
-          }
-      }
-      else if (!el.pre) {
-          // non root node in pre blocks with no attributes
-          el.plain = true;
-      }
-  }
-  function processElement(element, options) {
-      processKey(element);
-      // determine whether this is a plain element after
-      // removing structural attributes
-      element.plain =
-          !element.key && !element.scopedSlots && !element.attrsList.length;
-      processRef(element);
-      processSlotContent(element);
-      processSlotOutlet(element);
-      processComponent(element);
-      for (let i = 0; i < transforms.length; i++) {
-          element = transforms[i](element, options) || element;
-      }
-      processAttrs(element);
-      return element;
-  }
-  function processKey(el) {
-      const exp = getBindingAttr(el, 'key');
-      if (exp) {
-          {
-              if (el.tag === 'template') {
-                  warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-              }
-              if (el.for) {
-                  const iterator = el.iterator2 || el.iterator1;
-                  const parent = el.parent;
-                  if (iterator &&
-                      iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
-                      warn(`Do not use v-for index as key on <transition-group> children, ` +
-                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                  }
-              }
-          }
-          el.key = exp;
-      }
-  }
-  function processRef(el) {
-      const ref = getBindingAttr(el, 'ref');
-      if (ref) {
-          el.ref = ref;
-          el.refInFor = checkInFor(el);
-      }
-  }
-  function processFor(el) {
-      let exp;
-      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-          const res = parseFor(exp);
-          if (res) {
-              extend(el, res);
-          }
-          else {
-              warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-          }
-      }
-  }
-  function parseFor(exp) {
-      const inMatch = exp.match(forAliasRE);
-      if (!inMatch)
-          return;
-      const res = {};
-      res.for = inMatch[2].trim();
-      const alias = inMatch[1].trim().replace(stripParensRE, '');
-      const iteratorMatch = alias.match(forIteratorRE);
-      if (iteratorMatch) {
-          res.alias = alias.replace(forIteratorRE, '').trim();
-          res.iterator1 = iteratorMatch[1].trim();
-          if (iteratorMatch[2]) {
-              res.iterator2 = iteratorMatch[2].trim();
-          }
-      }
-      else {
-          res.alias = alias;
-      }
-      return res;
-  }
-  function processIf(el) {
-      const exp = getAndRemoveAttr(el, 'v-if');
-      if (exp) {
-          el.if = exp;
-          addIfCondition(el, {
-              exp: exp,
-              block: el,
-          });
-      }
-      else {
-          if (getAndRemoveAttr(el, 'v-else') != null) {
-              el.else = true;
-          }
-          const elseif = getAndRemoveAttr(el, 'v-else-if');
-          if (elseif) {
-              el.elseif = elseif;
-          }
-      }
-  }
-  function processIfConditions(el, parent) {
-      const prev = findPrevElement(parent.children);
-      if (prev && prev.if) {
-          addIfCondition(prev, {
-              exp: el.elseif,
-              block: el,
-          });
-      }
-      else {
-          warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-      }
-  }
-  function findPrevElement(children) {
-      let i = children.length;
-      while (i--) {
-          if (children[i].type === 1) {
-              return children[i];
-          }
-          else {
-              if (children[i].text !== ' ') {
-                  warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                      `will be ignored.`, children[i]);
-              }
-              children.pop();
-          }
-      }
-  }
-  function addIfCondition(el, condition) {
-      if (!el.ifConditions) {
-          el.ifConditions = [];
-      }
-      el.ifConditions.push(condition);
-  }
-  function processOnce(el) {
-      const once = getAndRemoveAttr(el, 'v-once');
-      if (once != null) {
-          el.once = true;
-      }
-  }
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent(el) {
-      let slotScope;
-      if (el.tag === 'template') {
-          slotScope = getAndRemoveAttr(el, 'scope');
-          /* istanbul ignore if */
-          if (slotScope) {
-              warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                  `can also be used on plain elements in addition to <template> to ` +
-                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-          }
-          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-      }
-      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-          /* istanbul ignore if */
-          if (el.attrsMap['v-for']) {
-              warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-          }
-          el.slotScope = slotScope;
-      }
-      // slot="xxx"
-      const slotTarget = getBindingAttr(el, 'slot');
-      if (slotTarget) {
-          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-          // preserve slot as an attribute for native shadow DOM compat
-          // only for non-scoped slots.
-          if (el.tag !== 'template' && !el.slotScope) {
-              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-          }
-      }
-      // 2.6 v-slot syntax
-      {
-          if (el.tag === 'template') {
-              // v-slot on <template>
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (el.slotTarget || el.slotScope) {
-                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.parent && !maybeComponent(el.parent)) {
-                          warn(`<template v-slot> can only appear at the root level inside ` +
-                              `the receiving component`, el);
-                      }
-                  }
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  el.slotTarget = name;
-                  el.slotTargetDynamic = dynamic;
-                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-              }
-          }
-          else {
-              // v-slot on component, denotes default slot
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (!maybeComponent(el)) {
-                          warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                      }
-                      if (el.slotScope || el.slotTarget) {
-                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.scopedSlots) {
-                          warn(`To avoid scope ambiguity, the default slot should also use ` +
-                              `<template> syntax when there are other named slots.`, slotBinding);
-                      }
-                  }
-                  // add the component's children to its default slot
-                  const slots = el.scopedSlots || (el.scopedSlots = {});
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  const slotContainer = (slots[name] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name;
-                  slotContainer.slotTargetDynamic = dynamic;
-                  slotContainer.children = el.children.filter((c) => {
-                      if (!c.slotScope) {
-                          c.parent = slotContainer;
-                          return true;
-                      }
-                  });
-                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                  // remove children as they are returned from scopedSlots now
-                  el.children = [];
-                  // mark el non-plain so data gets generated
-                  el.plain = false;
-              }
-          }
-      }
-  }
-  function getSlotName(binding) {
-      let name = binding.name.replace(slotRE, '');
-      if (!name) {
-          if (binding.name[0] !== '#') {
-              name = 'default';
-          }
-          else {
-              warn(`v-slot shorthand syntax requires a slot name.`, binding);
-          }
-      }
-      return dynamicArgRE.test(name)
-          ? // dynamic [name]
-              { name: name.slice(1, -1), dynamic: true }
-          : // static name
-              { name: `"${name}"`, dynamic: false };
-  }
-  // handle <slot/> outlets
-  function processSlotOutlet(el) {
-      if (el.tag === 'slot') {
-          el.slotName = getBindingAttr(el, 'name');
-          if (el.key) {
-              warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                  `and can possibly expand into multiple elements. ` +
-                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-          }
-      }
-  }
-  function processComponent(el) {
-      let binding;
-      if ((binding = getBindingAttr(el, 'is'))) {
-          el.component = binding;
-      }
-      if (getAndRemoveAttr(el, 'inline-template') != null) {
-          el.inlineTemplate = true;
-      }
-  }
-  function processAttrs(el) {
-      const list = el.attrsList;
-      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-      for (i = 0, l = list.length; i < l; i++) {
-          name = rawName = list[i].name;
-          value = list[i].value;
-          if (dirRE.test(name)) {
-              // mark element as dynamic
-              el.hasBindings = true;
-              // modifiers
-              modifiers = parseModifiers(name.replace(dirRE, ''));
-              // support .foo shorthand syntax for the .prop modifier
-              if (modifiers) {
-                  name = name.replace(modifierRE, '');
-              }
-              if (bindRE.test(name)) {
-                  // v-bind
-                  name = name.replace(bindRE, '');
-                  value = parseFilters(value);
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  if (value.trim().length === 0) {
-                      warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                  }
-                  if (modifiers) {
-                      if (modifiers.prop && !isDynamic) {
-                          name = camelize(name);
-                          if (name === 'innerHtml')
-                              name = 'innerHTML';
-                      }
-                      if (modifiers.camel && !isDynamic) {
-                          name = camelize(name);
-                      }
-                      if (modifiers.sync) {
-                          syncGen = genAssignmentCode(value, `$event`);
-                          if (!isDynamic) {
-                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                              if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                              }
-                          }
-                          else {
-                              // handler w/ dynamic event name
-                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                              );
-                          }
-                      }
-                  }
-                  if ((modifiers && modifiers.prop) ||
-                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                      addProp(el, name, value, list[i], isDynamic);
-                  }
-                  else {
-                      addAttr(el, name, value, list[i], isDynamic);
-                  }
-              }
-              else if (onRE.test(name)) {
-                  // v-on
-                  name = name.replace(onRE, '');
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-              }
-              else {
-                  // normal directives
-                  name = name.replace(dirRE, '');
-                  // parse arg
-                  const argMatch = name.match(argRE);
-                  let arg = argMatch && argMatch[1];
-                  isDynamic = false;
-                  if (arg) {
-                      name = name.slice(0, -(arg.length + 1));
-                      if (dynamicArgRE.test(arg)) {
-                          arg = arg.slice(1, -1);
-                          isDynamic = true;
-                      }
-                  }
-                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                  if (name === 'model') {
-                      checkForAliasModel(el, value);
-                  }
-              }
-          }
-          else {
-              // literal attribute
-              {
-                  const res = parseText(value, delimiters);
-                  if (res) {
-                      warn(`${name}="${value}": ` +
-                          'Interpolation inside attributes has been removed. ' +
-                          'Use v-bind or the colon shorthand instead. For example, ' +
-                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                  }
-              }
-              addAttr(el, name, JSON.stringify(value), list[i]);
-              // #6887 firefox doesn't update muted state if set via attribute
-              // even immediately after element creation
-              if (!el.component &&
-                  name === 'muted' &&
-                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                  addProp(el, name, 'true', list[i]);
-              }
-          }
-      }
-  }
-  function checkInFor(el) {
-      let parent = el;
-      while (parent) {
-          if (parent.for !== undefined) {
-              return true;
-          }
-          parent = parent.parent;
-      }
-      return false;
-  }
-  function parseModifiers(name) {
-      const match = name.match(modifierRE);
-      if (match) {
-          const ret = {};
-          match.forEach((m) => {
-              ret[m.slice(1)] = true;
-          });
-          return ret;
-      }
-  }
-  function makeAttrsMap(attrs) {
-      const map = {};
-      for (let i = 0, l = attrs.length; i < l; i++) {
-          if (map[attrs[i].name] &&
-              !isIE &&
-              !isEdge) {
-              warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-          }
-          map[attrs[i].name] = attrs[i].value;
-      }
-      return map;
-  }
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag(el) {
-      return el.tag === 'script' || el.tag === 'style';
-  }
-  function isForbiddenTag(el) {
-      return (el.tag === 'style' ||
-          (el.tag === 'script' &&
-              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-  }
-  const ieNSBug = /^xmlns:NS\d+/;
-  const ieNSPrefix = /^NS\d+:/;
-  /* istanbul ignore next */
-  function guardIESVGBug(attrs) {
-      const res = [];
-      for (let i = 0; i < attrs.length; i++) {
-          const attr = attrs[i];
-          if (!ieNSBug.test(attr.name)) {
-              attr.name = attr.name.replace(ieNSPrefix, '');
-              res.push(attr);
-          }
-      }
-      return res;
-  }
-  function checkForAliasModel(el, value) {
-      let _el = el;
-      while (_el) {
-          if (_el.for && _el.alias === value) {
-              warn(`<${el.tag} v-model="${value}">: ` +
-                  `You are binding v-model directly to a v-for iteration alias. ` +
-                  `This will not be able to modify the v-for source array because ` +
-                  `writing to the alias is like modifying a function local variable. ` +
-                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-          }
-          _el = _el.parent;
-      }
+  const onRE = /^@|^v-on:/;
+  const dirRE = /^v-|^@|^:|^#/;
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  const dynamicArgRE = /^\[.*\]$/;
+  const argRE = /:(.*)$/;
+  const bindRE = /^:|^\.|^v-bind:/;
+  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+  const slotRE = /^v-slot(:|$)|^#/;
+  const lineBreakRE = /[\r\n]/;
+  const whitespaceRE = /[ \f\t\r\n]+/g;
+  const invalidAttributeRE = /[\s"'<>\/=]/;
+  const decodeHTMLCached = cached(he.decode);
+  const emptySlotScopeToken = `_empty_`;
+  // configurable state
+  let warn;
+  let delimiters;
+  let transforms;
+  let preTransforms;
+  let postTransforms;
+  let platformIsPreTag;
+  let platformMustUseProp;
+  let platformGetTagNamespace;
+  let maybeComponent;
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent,
+          children: [],
+      };
+  }
+  /**
+   * Convert HTML string to AST.
+   */
+  function parse(template, options) {
+      warn = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      const isReservedTag = options.isReservedTag || no;
+      maybeComponent = (el) => !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      const stack = [];
+      const preserveWhitespace = options.preserveWhitespace !== false;
+      const whitespaceOption = options.whitespace;
+      let root;
+      let currentParent;
+      let inVPre = false;
+      let inPre = false;
+      let warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn(msg, range);
+          }
+      }
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce(`Component template should contain exactly one root element. ` +
+                      `If you are using v-if on multiple elements, ` +
+                      `use v-else-if to chain them instead.`, { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      const name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter((c) => !c.slotScope);
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
+          if (element.pre) {
+              inVPre = false;
+          }
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
+          }
+          // apply post-transforms
+          for (let i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
+          }
+      }
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              let lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
+          }
+      }
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                  'contain multiple nodes.', { start: el.start });
+          }
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
+          }
+      }
+      parseHTML(template, {
+          warn,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start(tag, attrs, unary, start, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              let element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach((attr) => {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                              `spaces, quotes, <, >, / or =.`, {
+                              start: attr.start + attr.name.indexOf(`[`),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          `<${tag}>` +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (let i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end(tag, start, end) {
+              const element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end;
+              }
+              closeElement(element);
+          },
+          chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(`text "${text}" outside root element will be ignored.`, {
+                              start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              const children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE, ' ');
+                  }
+                  let res;
+                  let child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  const child = {
+                      type: 3,
+                      text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
+      });
+      return root;
+  }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
+  }
+  function processRawAttrs(el) {
+      const list = el.attrsList;
+      const len = list.length;
+      if (len) {
+          const attrs = (el.attrs = new Array(len));
+          for (let i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
+      }
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (let i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      const exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  const iterator = el.iterator2 || el.iterator1;
+                  const parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn(`Do not use v-for index as key on <transition-group> children, ` +
+                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
+      }
+  }
+  function processRef(el) {
+      const ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
+      }
+  }
+  function processFor(el) {
+      let exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          const res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+          }
+      }
+  }
+  function parseFor(exp) {
+      const inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          return;
+      const res = {};
+      res.for = inMatch[2].trim();
+      const alias = inMatch[1].trim().replace(stripParensRE, '');
+      const iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
+          }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
+  }
+  function processIf(el) {
+      const exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          const elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
+      }
+  }
+  function processIfConditions(el, parent) {
+      const prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
+          });
+      }
+      else {
+          warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+      }
+  }
+  function findPrevElement(children) {
+      let i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                      `will be ignored.`, children[i]);
+              }
+              children.pop();
+          }
+      }
+  }
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
+  }
+  function processOnce(el) {
+      const once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
+          el.once = true;
+      }
+  }
+  // handle content being passed to a component as slot,
+  // e.g. <template slot="xxx">, <div slot-scope="xxx">
+  function processSlotContent(el) {
+      let slotScope;
+      if (el.tag === 'template') {
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn(`the "scope" attribute for scoped slots have been deprecated and ` +
+                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                  `can also be used on plain elements in addition to <template> to ` +
+                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+          }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      const slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn(`<template v-slot> can only appear at the root level inside ` +
+                              `the receiving component`, el);
+                      }
+                  }
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn(`v-slot can only be used on components or <template>.`, slotBinding);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.scopedSlots) {
+                          warn(`To avoid scope ambiguity, the default slot should also use ` +
+                              `<template> syntax when there are other named slots.`, slotBinding);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  const slots = el.scopedSlots || (el.scopedSlots = {});
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  const slotContainer = (slots[name] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name;
+                  slotContainer.slotTargetDynamic = dynamic;
+                  slotContainer.children = el.children.filter((c) => {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
+          }
+      }
+  }
+  function getSlotName(binding) {
+      let name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn(`v-slot shorthand syntax requires a slot name.`, binding);
+          }
+      }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: `"${name}"`, dynamic: false };
+  }
+  // handle <slot/> outlets
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                  `and can possibly expand into multiple elements. ` +
+                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+          }
+      }
+  }
+  function processComponent(el) {
+      let binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
+      }
+  }
+  function processAttrs(el) {
+      const list = el.attrsList;
+      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              name = 'innerHTML';
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, `$event`);
+                          if (!isDynamic) {
+                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  const argMatch = name.match(argRE);
+                  let arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
+              }
+          }
+          else {
+              // literal attribute
+              {
+                  const res = parseText(value, delimiters);
+                  if (res) {
+                      warn(`${name}="${value}": ` +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
+          }
+      }
+  }
+  function checkInFor(el) {
+      let parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
+      }
+      return false;
+  }
+  function parseModifiers(name) {
+      const match = name.match(modifierRE);
+      if (match) {
+          const ret = {};
+          match.forEach((m) => {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
+  }
+  function makeAttrsMap(attrs) {
+      const map = {};
+      for (let i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
+  }
+  // for script (e.g. type="x/template") or style, do not decode content
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
+  }
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+  }
+  const ieNSBug = /^xmlns:NS\d+/;
+  const ieNSPrefix = /^NS\d+:/;
+  /* istanbul ignore next */
+  function guardIESVGBug(attrs) {
+      const res = [];
+      for (let i = 0; i < attrs.length; i++) {
+          const attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
+      }
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      let _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn(`<${el.tag} v-model="${value}">: ` +
+                  `You are binding v-model directly to a v-for iteration alias. ` +
+                  `This will not be able to modify the v-for source array because ` +
+                  `writing to the alias is like modifying a function local variable. ` +
+                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
+      }
   }
 
-  /**
-   * Expand input[v-model] with dynamic type bindings into v-if-else chains
-   * Turn this:
-   *   <input v-model="data[type]" :type="type">
-   * into this:
-   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-   *   <input v-else :type="type" v-model="data[type]">
-   */
-  function preTransformNode(el, options) {
-      if (el.tag === 'input') {
-          const map = el.attrsMap;
-          if (!map['v-model']) {
-              return;
-          }
-          let typeBinding;
-          if (map[':type'] || map['v-bind:type']) {
-              typeBinding = getBindingAttr(el, 'type');
-          }
-          if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = `(${map['v-bind']}).type`;
-          }
-          if (typeBinding) {
-              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-              // 1. checkbox
-              const branch0 = cloneASTElement(el);
-              // process for on the main node
-              processFor(branch0);
-              addRawAttr(branch0, 'type', 'checkbox');
-              processElement(branch0, options);
-              branch0.processed = true; // prevent it from double-processed
-              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-              addIfCondition(branch0, {
-                  exp: branch0.if,
-                  block: branch0,
-              });
-              // 2. add radio else-if condition
-              const branch1 = cloneASTElement(el);
-              getAndRemoveAttr(branch1, 'v-for', true);
-              addRawAttr(branch1, 'type', 'radio');
-              processElement(branch1, options);
-              addIfCondition(branch0, {
-                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                  block: branch1,
-              });
-              // 3. other
-              const branch2 = cloneASTElement(el);
-              getAndRemoveAttr(branch2, 'v-for', true);
-              addRawAttr(branch2, ':type', typeBinding);
-              processElement(branch2, options);
-              addIfCondition(branch0, {
-                  exp: ifCondition,
-                  block: branch2,
-              });
-              if (hasElse) {
-                  branch0.else = true;
-              }
-              else if (elseIfCondition) {
-                  branch0.elseif = elseIfCondition;
-              }
-              return branch0;
-          }
-      }
-  }
-  function cloneASTElement(el) {
-      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-  }
-  var model = {
-      preTransformNode,
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          const map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          let typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = `(${map['v-bind']}).type`;
+          }
+          if (typeBinding) {
+              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              const branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              const branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              const branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
+      }
+  }
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+  }
+  var model = {
+      preTransformNode,
   };
 
   var modules = [klass, style, model];
 
-  function text(el, dir) {
-      if (dir.value) {
-          addProp(el, 'textContent', `_s(${dir.value})`, dir);
-      }
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', `_s(${dir.value})`, dir);
+      }
   }
 
-  function html(el, dir) {
-      if (dir.value) {
-          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-      }
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+      }
   }
 
-  var directives = {
-      model: model$1,
-      text,
-      html,
+  var directives = {
+      model: model$1,
+      text,
+      html,
   };
 
-  const baseOptions = {
-      expectHTML: true,
-      modules,
-      directives,
-      isPreTag,
-      isUnaryTag,
-      mustUseProp,
-      canBeLeftOpenTag,
-      isReservedTag,
-      getTagNamespace,
-      staticKeys: genStaticKeys$1(modules),
+  const baseOptions = {
+      expectHTML: true,
+      modules,
+      directives,
+      isPreTag,
+      isUnaryTag,
+      mustUseProp,
+      canBeLeftOpenTag,
+      isReservedTag,
+      getTagNamespace,
+      staticKeys: genStaticKeys$1(modules),
   };
 
-  let isStaticKey;
-  let isPlatformReservedTag;
-  const genStaticKeysCached = cached(genStaticKeys);
-  /**
-   * Goal of the optimizer: walk the generated template AST tree
-   * and detect sub-trees that are purely static, i.e. parts of
-   * the DOM that never needs to change.
-   *
-   * Once we detect these sub-trees, we can:
-   *
-   * 1. Hoist them into constants, so that we no longer need to
-   *    create fresh nodes for them on each re-render;
-   * 2. Completely skip them in the patching process.
-   */
-  function optimize(root, options) {
-      if (!root)
-          return;
-      isStaticKey = genStaticKeysCached(options.staticKeys || '');
-      isPlatformReservedTag = options.isReservedTag || no;
-      // first pass: mark all non-static nodes.
-      markStatic(root);
-      // second pass: mark static roots.
-      markStaticRoots(root, false);
-  }
-  function genStaticKeys(keys) {
-      return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-          (keys ? ',' + keys : ''));
-  }
-  function markStatic(node) {
-      node.static = isStatic(node);
-      if (node.type === 1) {
-          // do not make component slot content static. this avoids
-          // 1. components not able to mutate slot nodes
-          // 2. static slot content fails for hot-reloading
-          if (!isPlatformReservedTag(node.tag) &&
-              node.tag !== 'slot' &&
-              node.attrsMap['inline-template'] == null) {
-              return;
-          }
-          for (let i = 0, l = node.children.length; i < l; i++) {
-              const child = node.children[i];
-              markStatic(child);
-              if (!child.static) {
-                  node.static = false;
-              }
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  const block = node.ifConditions[i].block;
-                  markStatic(block);
-                  if (!block.static) {
-                      node.static = false;
-                  }
-              }
-          }
-      }
-  }
-  function markStaticRoots(node, isInFor) {
-      if (node.type === 1) {
-          if (node.static || node.once) {
-              node.staticInFor = isInFor;
-          }
-          // For a node to qualify as a static root, it should have children that
-          // are not just static text. Otherwise the cost of hoisting out will
-          // outweigh the benefits and it's better off to just always render it fresh.
-          if (node.static &&
-              node.children.length &&
-              !(node.children.length === 1 && node.children[0].type === 3)) {
-              node.staticRoot = true;
-              return;
-          }
-          else {
-              node.staticRoot = false;
-          }
-          if (node.children) {
-              for (let i = 0, l = node.children.length; i < l; i++) {
-                  markStaticRoots(node.children[i], isInFor || !!node.for);
-              }
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  markStaticRoots(node.ifConditions[i].block, isInFor);
-              }
-          }
-      }
-  }
-  function isStatic(node) {
-      if (node.type === 2) {
-          // expression
-          return false;
-      }
-      if (node.type === 3) {
-          // text
-          return true;
-      }
-      return !!(node.pre ||
-          (!node.hasBindings && // no dynamic bindings
-              !node.if &&
-              !node.for && // not v-if or v-for or v-else
-              !isBuiltInTag(node.tag) && // not a built-in
-              isPlatformReservedTag(node.tag) && // not a component
-              !isDirectChildOfTemplateFor(node) &&
-              Object.keys(node).every(isStaticKey)));
-  }
-  function isDirectChildOfTemplateFor(node) {
-      while (node.parent) {
-          node = node.parent;
-          if (node.tag !== 'template') {
-              return false;
-          }
-          if (node.for) {
-              return true;
-          }
-      }
-      return false;
+  let isStaticKey;
+  let isPlatformReservedTag;
+  const genStaticKeysCached = cached(genStaticKeys);
+  /**
+   * Goal of the optimizer: walk the generated template AST tree
+   * and detect sub-trees that are purely static, i.e. parts of
+   * the DOM that never needs to change.
+   *
+   * Once we detect these sub-trees, we can:
+   *
+   * 1. Hoist them into constants, so that we no longer need to
+   *    create fresh nodes for them on each re-render;
+   * 2. Completely skip them in the patching process.
+   */
+  function optimize(root, options) {
+      if (!root)
+          return;
+      isStaticKey = genStaticKeysCached(options.staticKeys || '');
+      isPlatformReservedTag = options.isReservedTag || no;
+      // first pass: mark all non-static nodes.
+      markStatic(root);
+      // second pass: mark static roots.
+      markStaticRoots(root, false);
+  }
+  function genStaticKeys(keys) {
+      return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+          (keys ? ',' + keys : ''));
+  }
+  function markStatic(node) {
+      node.static = isStatic(node);
+      if (node.type === 1) {
+          // do not make component slot content static. this avoids
+          // 1. components not able to mutate slot nodes
+          // 2. static slot content fails for hot-reloading
+          if (!isPlatformReservedTag(node.tag) &&
+              node.tag !== 'slot' &&
+              node.attrsMap['inline-template'] == null) {
+              return;
+          }
+          for (let i = 0, l = node.children.length; i < l; i++) {
+              const child = node.children[i];
+              markStatic(child);
+              if (!child.static) {
+                  node.static = false;
+              }
+          }
+          if (node.ifConditions) {
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  const block = node.ifConditions[i].block;
+                  markStatic(block);
+                  if (!block.static) {
+                      node.static = false;
+                  }
+              }
+          }
+      }
+  }
+  function markStaticRoots(node, isInFor) {
+      if (node.type === 1) {
+          if (node.static || node.once) {
+              node.staticInFor = isInFor;
+          }
+          // For a node to qualify as a static root, it should have children that
+          // are not just static text. Otherwise the cost of hoisting out will
+          // outweigh the benefits and it's better off to just always render it fresh.
+          if (node.static &&
+              node.children.length &&
+              !(node.children.length === 1 && node.children[0].type === 3)) {
+              node.staticRoot = true;
+              return;
+          }
+          else {
+              node.staticRoot = false;
+          }
+          if (node.children) {
+              for (let i = 0, l = node.children.length; i < l; i++) {
+                  markStaticRoots(node.children[i], isInFor || !!node.for);
+              }
+          }
+          if (node.ifConditions) {
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  markStaticRoots(node.ifConditions[i].block, isInFor);
+              }
+          }
+      }
+  }
+  function isStatic(node) {
+      if (node.type === 2) {
+          // expression
+          return false;
+      }
+      if (node.type === 3) {
+          // text
+          return true;
+      }
+      return !!(node.pre ||
+          (!node.hasBindings && // no dynamic bindings
+              !node.if &&
+              !node.for && // not v-if or v-for or v-else
+              !isBuiltInTag(node.tag) && // not a built-in
+              isPlatformReservedTag(node.tag) && // not a component
+              !isDirectChildOfTemplateFor(node) &&
+              Object.keys(node).every(isStaticKey)));
+  }
+  function isDirectChildOfTemplateFor(node) {
+      while (node.parent) {
+          node = node.parent;
+          if (node.tag !== 'template') {
+              return false;
+          }
+          if (node.for) {
+              return true;
+          }
+      }
+      return false;
   }
 
-  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  const fnInvokeRE = /\([^)]*?\);*$/;
-  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-  // KeyboardEvent.keyCode aliases
-  const keyCodes = {
-      esc: 27,
-      tab: 9,
-      enter: 13,
-      space: 32,
-      up: 38,
-      left: 37,
-      right: 39,
-      down: 40,
-      delete: [8, 46],
-  };
-  // KeyboardEvent.key aliases
-  const keyNames = {
-      // #7880: IE11 and Edge use `Esc` for Escape key name.
-      esc: ['Esc', 'Escape'],
-      tab: 'Tab',
-      enter: 'Enter',
-      // #9112: IE11 uses `Spacebar` for Space key name.
-      space: [' ', 'Spacebar'],
-      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-      up: ['Up', 'ArrowUp'],
-      left: ['Left', 'ArrowLeft'],
-      right: ['Right', 'ArrowRight'],
-      down: ['Down', 'ArrowDown'],
-      // #9112: IE11 uses `Del` for Delete key name.
-      delete: ['Backspace', 'Delete', 'Del'],
-  };
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  const genGuard = (condition) => `if(${condition})return null;`;
-  const modifierCode = {
-      stop: '$event.stopPropagation();',
-      prevent: '$event.preventDefault();',
-      self: genGuard(`$event.target !== $event.currentTarget`),
-      ctrl: genGuard(`!$event.ctrlKey`),
-      shift: genGuard(`!$event.shiftKey`),
-      alt: genGuard(`!$event.altKey`),
-      meta: genGuard(`!$event.metaKey`),
-      left: genGuard(`'button' in $event && $event.button !== 0`),
-      middle: genGuard(`'button' in $event && $event.button !== 1`),
-      right: genGuard(`'button' in $event && $event.button !== 2`),
-  };
-  function genHandlers(events, isNative) {
-      const prefix = isNative ? 'nativeOn:' : 'on:';
-      let staticHandlers = ``;
-      let dynamicHandlers = ``;
-      for (const name in events) {
-          const handlerCode = genHandler(events[name]);
-          //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += `${name},${handlerCode},`;
-          }
-          else {
-              staticHandlers += `"${name}":${handlerCode},`;
-          }
-      }
-      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-      if (dynamicHandlers) {
-          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-      }
-      else {
-          return prefix + staticHandlers;
-      }
-  }
-  function genHandler(handler) {
-      if (!handler) {
-          return 'function(){}';
-      }
-      if (Array.isArray(handler)) {
-          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-      }
-      const isMethodPath = simplePathRE.test(handler.value);
-      const isFunctionExpression = fnExpRE.test(handler.value);
-      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-      if (!handler.modifiers) {
-          if (isMethodPath || isFunctionExpression) {
-              return handler.value;
-          }
-          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-      }
-      else {
-          let code = '';
-          let genModifierCode = '';
-          const keys = [];
-          for (const key in handler.modifiers) {
-              if (modifierCode[key]) {
-                  genModifierCode += modifierCode[key];
-                  // left/right
-                  if (keyCodes[key]) {
-                      keys.push(key);
-                  }
-              }
-              else if (key === 'exact') {
-                  const modifiers = handler.modifiers;
-                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter((keyModifier) => !modifiers[keyModifier])
-                      .map((keyModifier) => `$event.${keyModifier}Key`)
-                      .join('||'));
-              }
-              else {
-                  keys.push(key);
-              }
-          }
-          if (keys.length) {
-              code += genKeyFilter(keys);
-          }
-          // Make sure modifiers like prevent and stop get executed after key filtering
-          if (genModifierCode) {
-              code += genModifierCode;
-          }
-          const handlerCode = isMethodPath
-              ? `return ${handler.value}.apply(null, arguments)`
-              : isFunctionExpression
-                  ? `return (${handler.value}).apply(null, arguments)`
-                  : isFunctionInvocation
-                      ? `return ${handler.value}`
-                      : handler.value;
-          return `function($event){${code}${handlerCode}}`;
-      }
-  }
-  function genKeyFilter(keys) {
-      return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      `if(!$event.type.indexOf('key')&&` +
-          `${keys.map(genFilterCode).join('&&')})return null;`);
-  }
-  function genFilterCode(key) {
-      const keyVal = parseInt(key, 10);
-      if (keyVal) {
-          return `$event.keyCode!==${keyVal}`;
-      }
-      const keyCode = keyCodes[key];
-      const keyName = keyNames[key];
-      return (`_k($event.keyCode,` +
-          `${JSON.stringify(key)},` +
-          `${JSON.stringify(keyCode)},` +
-          `$event.key,` +
-          `${JSON.stringify(keyName)}` +
-          `)`);
+  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+  const fnInvokeRE = /\([^)]*?\);*$/;
+  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+  // KeyboardEvent.keyCode aliases
+  const keyCodes = {
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
+  };
+  // KeyboardEvent.key aliases
+  const keyNames = {
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
+  };
+  // #4868: modifiers that prevent the execution of the listener
+  // need to explicitly return null so that we can determine whether to remove
+  // the listener for .once
+  const genGuard = (condition) => `if(${condition})return null;`;
+  const modifierCode = {
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard(`$event.target !== $event.currentTarget`),
+      ctrl: genGuard(`!$event.ctrlKey`),
+      shift: genGuard(`!$event.shiftKey`),
+      alt: genGuard(`!$event.altKey`),
+      meta: genGuard(`!$event.metaKey`),
+      left: genGuard(`'button' in $event && $event.button !== 0`),
+      middle: genGuard(`'button' in $event && $event.button !== 1`),
+      right: genGuard(`'button' in $event && $event.button !== 2`),
+  };
+  function genHandlers(events, isNative) {
+      const prefix = isNative ? 'nativeOn:' : 'on:';
+      let staticHandlers = ``;
+      let dynamicHandlers = ``;
+      for (const name in events) {
+          const handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += `${name},${handlerCode},`;
+          }
+          else {
+              staticHandlers += `"${name}":${handlerCode},`;
+          }
+      }
+      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+      if (dynamicHandlers) {
+          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+      }
+      else {
+          return prefix + staticHandlers;
+      }
+  }
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+      }
+      const isMethodPath = simplePathRE.test(handler.value);
+      const isFunctionExpression = fnExpRE.test(handler.value);
+      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+      }
+      else {
+          let code = '';
+          let genModifierCode = '';
+          const keys = [];
+          for (const key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  const modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter((keyModifier) => !modifiers[keyModifier])
+                      .map((keyModifier) => `$event.${keyModifier}Key`)
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          const handlerCode = isMethodPath
+              ? `return ${handler.value}.apply(null, arguments)`
+              : isFunctionExpression
+                  ? `return (${handler.value}).apply(null, arguments)`
+                  : isFunctionInvocation
+                      ? `return ${handler.value}`
+                      : handler.value;
+          return `function($event){${code}${handlerCode}}`;
+      }
+  }
+  function genKeyFilter(keys) {
+      return (
+      // make sure the key filters only apply to KeyboardEvents
+      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+      // key events that do not have keyCode property...
+      `if(!$event.type.indexOf('key')&&` +
+          `${keys.map(genFilterCode).join('&&')})return null;`);
+  }
+  function genFilterCode(key) {
+      const keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return `$event.keyCode!==${keyVal}`;
+      }
+      const keyCode = keyCodes[key];
+      const keyName = keyNames[key];
+      return (`_k($event.keyCode,` +
+          `${JSON.stringify(key)},` +
+          `${JSON.stringify(keyCode)},` +
+          `$event.key,` +
+          `${JSON.stringify(keyName)}` +
+          `)`);
   }
 
-  function on(el, dir) {
-      if (dir.modifiers) {
-          warn$2(`v-on without argument does not support modifiers.`);
-      }
-      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn$2(`v-on without argument does not support modifiers.`);
+      }
+      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
   }
 
-  function bind(el, dir) {
-      el.wrapData = (code) => {
-          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-      };
+  function bind(el, dir) {
+      el.wrapData = (code) => {
+          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+      };
   }
 
-  var baseDirectives = {
-      on,
-      bind,
-      cloak: noop,
+  var baseDirectives = {
+      on,
+      bind,
+      cloak: noop,
   };
 
-  class CodegenState {
-      options;
-      warn;
-      transforms;
-      dataGenFns;
-      directives;
-      maybeComponent;
-      onceId;
-      staticRenderFns;
-      pre;
-      constructor(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          const isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-  }
-  function generate(ast, options) {
-      const state = new CodegenState(options);
-      // fix #11483, Root level <script> tags should not be rendered.
-      const code = ast
-          ? ast.tag === 'script'
-              ? 'null'
-              : genElement(ast, state)
-          : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genElement(el, state) {
-      if (el.parent) {
-          el.pre = el.pre || el.parent.pre;
-      }
-      if (el.staticRoot && !el.staticProcessed) {
-          return genStatic(el, state);
-      }
-      else if (el.once && !el.onceProcessed) {
-          return genOnce(el, state);
-      }
-      else if (el.for && !el.forProcessed) {
-          return genFor(el, state);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-          return genChildren(el, state) || 'void 0';
-      }
-      else if (el.tag === 'slot') {
-          return genSlot(el, state);
-      }
-      else {
-          // component or element
-          let code;
-          if (el.component) {
-              code = genComponent(el.component, el, state);
-          }
-          else {
-              let data;
-              if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData(el, state);
-              }
-              const children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-          }
-          // module transforms
-          for (let i = 0; i < state.transforms.length; i++) {
-              code = state.transforms[i](el, code);
-          }
-          return code;
-      }
-  }
-  // hoist static sub-trees out
-  function genStatic(el, state) {
-      el.staticProcessed = true;
-      // Some elements (templates) need to behave differently inside of a v-pre
-      // node.  All pre nodes are static roots, so we can use this as a location to
-      // wrap a state change and reset it upon exiting the pre node.
-      const originalPreState = state.pre;
-      if (el.pre) {
-          state.pre = el.pre;
-      }
-      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-      state.pre = originalPreState;
-      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-  }
-  // v-once
-  function genOnce(el, state) {
-      el.onceProcessed = true;
-      if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.staticInFor) {
-          let key = '';
-          let parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
-                  break;
-              }
-              parent = parent.parent;
-          }
-          if (!key) {
-              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-              return genElement(el, state);
-          }
-          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-      }
-      else {
-          return genStatic(el, state);
-      }
-  }
-  function genIf(el, state, altGen, altEmpty) {
-      el.ifProcessed = true; // avoid recursion
-      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-  }
-  function genIfConditions(conditions, state, altGen, altEmpty) {
-      if (!conditions.length) {
-          return altEmpty || '_e()';
-      }
-      const condition = conditions.shift();
-      if (condition.exp) {
-          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-      }
-      else {
-          return `${genTernaryExp(condition.block)}`;
-      }
-      // v-if with v-once should generate code like (a)?_m(0):_m(1)
-      function genTernaryExp(el) {
-          return altGen
-              ? altGen(el, state)
-              : el.once
-                  ? genOnce(el, state)
-                  : genElement(el, state);
-      }
-  }
-  function genFor(el, state, altGen, altHelper) {
-      const exp = el.for;
-      const alias = el.alias;
-      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-      if (state.maybeComponent(el) &&
-          el.tag !== 'slot' &&
-          el.tag !== 'template' &&
-          !el.key) {
-          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-              `v-for should have explicit keys. ` +
-              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-      }
-      el.forProcessed = true; // avoid recursion
-      return (`${altHelper || '_l'}((${exp}),` +
-          `function(${alias}${iterator1}${iterator2}){` +
-          `return ${(altGen || genElement)(el, state)}` +
-          '})');
-  }
-  function genData(el, state) {
-      let data = '{';
-      // directives first.
-      // directives may mutate the el's other properties before they are generated.
-      const dirs = genDirectives(el, state);
-      if (dirs)
-          data += dirs + ',';
-      // key
-      if (el.key) {
-          data += `key:${el.key},`;
-      }
-      // ref
-      if (el.ref) {
-          data += `ref:${el.ref},`;
-      }
-      if (el.refInFor) {
-          data += `refInFor:true,`;
-      }
-      // pre
-      if (el.pre) {
-          data += `pre:true,`;
-      }
-      // record original tag name for components using "is" attribute
-      if (el.component) {
-          data += `tag:"${el.tag}",`;
-      }
-      // module data generation functions
-      for (let i = 0; i < state.dataGenFns.length; i++) {
-          data += state.dataGenFns[i](el);
-      }
-      // attributes
-      if (el.attrs) {
-          data += `attrs:${genProps(el.attrs)},`;
-      }
-      // DOM props
-      if (el.props) {
-          data += `domProps:${genProps(el.props)},`;
-      }
-      // event handlers
-      if (el.events) {
-          data += `${genHandlers(el.events, false)},`;
-      }
-      if (el.nativeEvents) {
-          data += `${genHandlers(el.nativeEvents, true)},`;
-      }
-      // slot target
-      // only for non-scoped slots
-      if (el.slotTarget && !el.slotScope) {
-          data += `slot:${el.slotTarget},`;
-      }
-      // scoped slots
-      if (el.scopedSlots) {
-          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-      }
-      // component v-model
-      if (el.model) {
-          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-      }
-      // inline-template
-      if (el.inlineTemplate) {
-          const inlineTemplate = genInlineTemplate(el, state);
-          if (inlineTemplate) {
-              data += `${inlineTemplate},`;
-          }
-      }
-      data = data.replace(/,$/, '') + '}';
-      // v-bind dynamic argument wrap
-      // v-bind with dynamic arguments must be applied using the same v-bind object
-      // merge helper so that class/style/mustUseProp attrs are handled correctly.
-      if (el.dynamicAttrs) {
-          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-      }
-      // v-bind data wrap
-      if (el.wrapData) {
-          data = el.wrapData(data);
-      }
-      // v-on data wrap
-      if (el.wrapListeners) {
-          data = el.wrapListeners(data);
-      }
-      return data;
-  }
-  function genDirectives(el, state) {
-      const dirs = el.directives;
-      if (!dirs)
-          return;
-      let res = 'directives:[';
-      let hasRuntime = false;
-      let i, l, dir, needRuntime;
-      for (i = 0, l = dirs.length; i < l; i++) {
-          dir = dirs[i];
-          needRuntime = true;
-          const gen = state.directives[dir.name];
-          if (gen) {
-              // compile-time directive that manipulates AST.
-              // returns true if it also needs a runtime counterpart.
-              needRuntime = !!gen(el, dir, state.warn);
-          }
-          if (needRuntime) {
-              hasRuntime = true;
-              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-          }
-      }
-      if (hasRuntime) {
-          return res.slice(0, -1) + ']';
-      }
-  }
-  function genInlineTemplate(el, state) {
-      const ast = el.children[0];
-      if ((el.children.length !== 1 || ast.type !== 1)) {
-          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-      }
-      if (ast && ast.type === 1) {
-          const inlineRenderFns = generate(ast, state.options);
-          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-      }
-  }
-  function genScopedSlots(el, slots, state) {
-      // by default scoped slots are considered "stable", this allows child
-      // components with only scoped slots to skip forced updates from parent.
-      // but in some cases we have to bail-out of this optimization
-      // for example if the slot contains dynamic names, has v-if or v-for on them...
-      let needsForceUpdate = el.for ||
-          Object.keys(slots).some((key) => {
-              const slot = slots[key];
-              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-              );
-          });
-      // #9534: if a component with scoped slots is inside a conditional branch,
-      // it's possible for the same component to be reused but with different
-      // compiled slot content. To avoid that, we generate a unique key based on
-      // the generated code of all the slot contents.
-      let needsKey = !!el.if;
-      // OR when it is inside another scoped slot or v-for (the reactivity may be
-      // disconnected due to the intermediate scope variable)
-      // #9438, #9506
-      // TODO: this can be further optimized by properly analyzing in-scope bindings
-      // and skip force updating ones that do not actually use scope variables.
-      if (!needsForceUpdate) {
-          let parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
-                  needsForceUpdate = true;
-                  break;
-              }
-              if (parent.if) {
-                  needsKey = true;
-              }
-              parent = parent.parent;
-          }
-      }
-      const generatedSlots = Object.keys(slots)
-          .map((key) => genScopedSlot(slots[key], state))
-          .join(',');
-      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-  }
-  function hash(str) {
-      let hash = 5381;
-      let i = str.length;
-      while (i) {
-          hash = (hash * 33) ^ str.charCodeAt(--i);
-      }
-      return hash >>> 0;
-  }
-  function containsSlotChild(el) {
-      if (el.type === 1) {
-          if (el.tag === 'slot') {
-              return true;
-          }
-          return el.children.some(containsSlotChild);
-      }
-      return false;
-  }
-  function genScopedSlot(el, state) {
-      const isLegacySyntax = el.attrsMap['slot-scope'];
-      if (el.if && !el.ifProcessed && !isLegacySyntax) {
-          return genIf(el, state, genScopedSlot, `null`);
-      }
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genScopedSlot);
-      }
-      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-      const fn = `function(${slotScope}){` +
-          `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-      // reverse proxy v-slot without scope on this.$slots
-      const reverseProxy = slotScope ? `` : `,proxy:true`;
-      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-  }
-  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-      const children = el.children;
-      if (children.length) {
-          const el = children[0];
-          // optimize single v-for
-          if (children.length === 1 &&
-              el.for &&
-              el.tag !== 'template' &&
-              el.tag !== 'slot') {
-              const normalizationType = checkSkip
-                  ? state.maybeComponent(el)
-                      ? `,1`
-                      : `,0`
-                  : ``;
-              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-          }
-          const normalizationType = checkSkip
-              ? getNormalizationType(children, state.maybeComponent)
-              : 0;
-          const gen = altGenNode || genNode;
-          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-      }
-  }
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType(children, maybeComponent) {
-      let res = 0;
-      for (let i = 0; i < children.length; i++) {
-          const el = children[i];
-          if (el.type !== 1) {
-              continue;
-          }
-          if (needsNormalization(el) ||
-              (el.ifConditions &&
-                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
-              res = 2;
-              break;
-          }
-          if (maybeComponent(el) ||
-              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-              res = 1;
-          }
-      }
-      return res;
-  }
-  function needsNormalization(el) {
-      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-  }
-  function genNode(node, state) {
-      if (node.type === 1) {
-          return genElement(node, state);
-      }
-      else if (node.type === 3 && node.isComment) {
-          return genComment(node);
-      }
-      else {
-          return genText(node);
-      }
-  }
-  function genText(text) {
-      return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-  }
-  function genComment(comment) {
-      return `_e(${JSON.stringify(comment.text)})`;
-  }
-  function genSlot(el, state) {
-      const slotName = el.slotName || '"default"';
-      const children = genChildren(el, state);
-      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-      const attrs = el.attrs || el.dynamicAttrs
-          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-              // slot props are camelized
-              name: camelize(attr.name),
-              value: attr.value,
-              dynamic: attr.dynamic
-          })))
-          : null;
-      const bind = el.attrsMap['v-bind'];
-      if ((attrs || bind) && !children) {
-          res += `,null`;
-      }
-      if (attrs) {
-          res += `,${attrs}`;
-      }
-      if (bind) {
-          res += `${attrs ? '' : ',null'},${bind}`;
-      }
-      return res + ')';
-  }
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent(componentName, el, state) {
-      const children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-  }
-  function genProps(props) {
-      let staticProps = ``;
-      let dynamicProps = ``;
-      for (let i = 0; i < props.length; i++) {
-          const prop = props[i];
-          const value = transformSpecialNewlines(prop.value);
-          if (prop.dynamic) {
-              dynamicProps += `${prop.name},${value},`;
-          }
-          else {
-              staticProps += `"${prop.name}":${value},`;
-          }
-      }
-      staticProps = `{${staticProps.slice(0, -1)}}`;
-      if (dynamicProps) {
-          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-      }
-      else {
-          return staticProps;
-      }
-  }
-  // #3895, #4268
-  function transformSpecialNewlines(text) {
-      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+  class CodegenState {
+      options;
+      warn;
+      transforms;
+      dataGenFns;
+      directives;
+      maybeComponent;
+      onceId;
+      staticRenderFns;
+      pre;
+      constructor(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          const isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+  }
+  function generate(ast, options) {
+      const state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      const code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
+      }
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
+      }
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
+      }
+      else {
+          // component or element
+          let code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              let data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData(el, state);
+              }
+              const children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+          }
+          // module transforms
+          for (let i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
+      }
+  }
+  // hoist static sub-trees out
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      const originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+      state.pre = originalPreState;
+      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+  }
+  // v-once
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.staticInFor) {
+          let key = '';
+          let parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      const condition = conditions.shift();
+      if (condition.exp) {
+          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+      }
+      else {
+          return `${genTernaryExp(condition.block)}`;
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      const exp = el.for;
+      const alias = el.alias;
+      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+              `v-for should have explicit keys. ` +
+              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return (`${altHelper || '_l'}((${exp}),` +
+          `function(${alias}${iterator1}${iterator2}){` +
+          `return ${(altGen || genElement)(el, state)}` +
+          '})');
+  }
+  function genData(el, state) {
+      let data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      const dirs = genDirectives(el, state);
+      if (dirs)
+          data += dirs + ',';
+      // key
+      if (el.key) {
+          data += `key:${el.key},`;
+      }
+      // ref
+      if (el.ref) {
+          data += `ref:${el.ref},`;
+      }
+      if (el.refInFor) {
+          data += `refInFor:true,`;
+      }
+      // pre
+      if (el.pre) {
+          data += `pre:true,`;
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += `tag:"${el.tag}",`;
+      }
+      // module data generation functions
+      for (let i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += `attrs:${genProps(el.attrs)},`;
+      }
+      // DOM props
+      if (el.props) {
+          data += `domProps:${genProps(el.props)},`;
+      }
+      // event handlers
+      if (el.events) {
+          data += `${genHandlers(el.events, false)},`;
+      }
+      if (el.nativeEvents) {
+          data += `${genHandlers(el.nativeEvents, true)},`;
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += `slot:${el.slotTarget},`;
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+      }
+      // component v-model
+      if (el.model) {
+          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          const inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += `${inlineTemplate},`;
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      const dirs = el.directives;
+      if (!dirs)
+          return;
+      let res = 'directives:[';
+      let hasRuntime = false;
+      let i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          const gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
+      }
+  }
+  function genInlineTemplate(el, state) {
+      const ast = el.children[0];
+      if ((el.children.length !== 1 || ast.type !== 1)) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          const inlineRenderFns = generate(ast, state.options);
+          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+      }
+  }
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      let needsForceUpdate = el.for ||
+          Object.keys(slots).some((key) => {
+              const slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      let needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          let parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
+      }
+      const generatedSlots = Object.keys(slots)
+          .map((key) => genScopedSlot(slots[key], state))
+          .join(',');
+      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+  }
+  function hash(str) {
+      let hash = 5381;
+      let i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
+      }
+      return hash >>> 0;
+  }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      const isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, `null`);
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+      const fn = `function(${slotScope}){` +
+          `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+      // reverse proxy v-slot without scope on this.$slots
+      const reverseProxy = slotScope ? `` : `,proxy:true`;
+      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      const children = el.children;
+      if (children.length) {
+          const el = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el.for &&
+              el.tag !== 'template' &&
+              el.tag !== 'slot') {
+              const normalizationType = checkSkip
+                  ? state.maybeComponent(el)
+                      ? `,1`
+                      : `,0`
+                  : ``;
+              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+          }
+          const normalizationType = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          const gen = altGenNode || genNode;
+          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+      }
+  }
+  // determine the normalization needed for the children array.
+  // 0: no normalization needed
+  // 1: simple normalization needed (possible 1-level deep nested array)
+  // 2: full normalization needed
+  function getNormalizationType(children, maybeComponent) {
+      let res = 0;
+      for (let i = 0; i < children.length; i++) {
+          const el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+              res = 1;
+          }
+      }
+      return res;
+  }
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+  }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
+  }
+  function genText(text) {
+      return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+  }
+  function genComment(comment) {
+      return `_e(${JSON.stringify(comment.text)})`;
+  }
+  function genSlot(el, state) {
+      const slotName = el.slotName || '"default"';
+      const children = genChildren(el, state);
+      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+      const attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic
+          })))
+          : null;
+      const bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
+          res += `,null`;
+      }
+      if (attrs) {
+          res += `,${attrs}`;
+      }
+      if (bind) {
+          res += `${attrs ? '' : ',null'},${bind}`;
+      }
+      return res + ')';
+  }
+  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
+  function genComponent(componentName, el, state) {
+      const children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+  }
+  function genProps(props) {
+      let staticProps = ``;
+      let dynamicProps = ``;
+      for (let i = 0; i < props.length; i++) {
+          const prop = props[i];
+          const value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += `${prop.name},${value},`;
+          }
+          else {
+              staticProps += `"${prop.name}":${value},`;
+          }
+      }
+      staticProps = `{${staticProps.slice(0, -1)}}`;
+      if (dynamicProps) {
+          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+      }
+      else {
+          return staticProps;
+      }
+  }
+  // #3895, #4268
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
   }
 
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  const prohibitedKeywordRE = new RegExp('\\b' +
-      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-          'super,throw,while,yield,delete,export,import,return,switch,default,' +
-          'extends,finally,continue,debugger,function,arguments')
-          .split(',')
-          .join('\\b|\\b') +
-      '\\b');
-  // these unary operators should not be used as property/method names
-  const unaryOperatorsRE = new RegExp('\\b' +
-      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-      '\\s*\\([^\\)]*\\)');
-  // strip strings in expressions
-  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-  // detect problematic expressions in a template
-  function detectErrors(ast, warn) {
-      if (ast) {
-          checkNode(ast, warn);
-      }
-  }
-  function checkNode(node, warn) {
-      if (node.type === 1) {
-          for (const name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  const value = node.attrsMap[name];
-                  if (value) {
-                      const range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, `v-for="${value}"`, warn, range);
-                      }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, `${name}="${value}"`, warn, range);
-                      }
-                      else {
-                          checkExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                  }
-              }
-          }
-          if (node.children) {
-              for (let i = 0; i < node.children.length; i++) {
-                  checkNode(node.children[i], warn);
-              }
-          }
-      }
-      else if (node.type === 2) {
-          checkExpression(node.expression, node.text, warn, node);
-      }
-  }
-  function checkEvent(exp, text, warn, range) {
-      const stripped = exp.replace(stripStringRE, '');
-      const keywordMatch = stripped.match(unaryOperatorsRE);
-      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-          warn(`avoid using JavaScript unary operator as property name: ` +
-              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-      }
-      checkExpression(exp, text, warn, range);
-  }
-  function checkFor(node, text, warn, range) {
-      checkExpression(node.for || '', text, warn, range);
-      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-  }
-  function checkIdentifier(ident, type, text, warn, range) {
-      if (typeof ident === 'string') {
-          try {
-              new Function(`var ${ident}=_`);
-          }
-          catch (e) {
-              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-          }
-      }
-  }
-  function checkExpression(exp, text, warn, range) {
-      try {
-          new Function(`return ${exp}`);
-      }
-      catch (e) {
-          const keywordMatch = exp
-              .replace(stripStringRE, '')
-              .match(prohibitedKeywordRE);
-          if (keywordMatch) {
-              warn(`avoid using JavaScript keyword as property name: ` +
-                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-          }
-          else {
-              warn(`invalid expression: ${e.message} in\n\n` +
-                  `    ${exp}\n\n` +
-                  `  Raw expression: ${text.trim()}\n`, range);
-          }
-      }
-  }
-  function checkFunctionParameterExpression(exp, text, warn, range) {
-      try {
-          new Function(exp, '');
-      }
-      catch (e) {
-          warn(`invalid function parameter expression: ${e.message} in\n\n` +
-              `    ${exp}\n\n` +
-              `  Raw expression: ${text.trim()}\n`, range);
-      }
+  // these keywords should not appear inside expressions, but operators like
+  // typeof, instanceof and in are allowed
+  const prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
+  // these unary operators should not be used as property/method names
+  const unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
+  // strip strings in expressions
+  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+  // detect problematic expressions in a template
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (const name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  const value = node.attrsMap[name];
+                  if (value) {
+                      const range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, `v-for="${value}"`, warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, `${name}="${value}"`, warn, range);
+                      }
+                      else {
+                          checkExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (let i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
+          }
+      }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
+      }
+  }
+  function checkEvent(exp, text, warn, range) {
+      const stripped = exp.replace(stripStringRE, '');
+      const keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn(`avoid using JavaScript unary operator as property name: ` +
+              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+      }
+      checkExpression(exp, text, warn, range);
+  }
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(`var ${ident}=_`);
+          }
+          catch (e) {
+              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+          }
+      }
+  }
+  function checkExpression(exp, text, warn, range) {
+      try {
+          new Function(`return ${exp}`);
+      }
+      catch (e) {
+          const keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn(`avoid using JavaScript keyword as property name: ` +
+                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+          }
+          else {
+              warn(`invalid expression: ${e.message} in\n\n` +
+                  `    ${exp}\n\n` +
+                  `  Raw expression: ${text.trim()}\n`, range);
+          }
+      }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn(`invalid function parameter expression: ${e.message} in\n\n` +
+              `    ${exp}\n\n` +
+              `  Raw expression: ${text.trim()}\n`, range);
+      }
   }
 
-  const range = 2;
-  function generateCodeFrame(source, start = 0, end = source.length) {
-      const lines = source.split(/\r?\n/);
-      let count = 0;
-      const res = [];
-      for (let i = 0; i < lines.length; i++) {
-          count += lines[i].length + 1;
-          if (count >= start) {
-              for (let j = i - range; j <= i + range || end > count; j++) {
-                  if (j < 0 || j >= lines.length)
-                      continue;
-                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                  const lineLength = lines[j].length;
-                  if (j === i) {
-                      // push underline
-                      const pad = start - (count - lineLength) + 1;
-                      const length = end > count ? lineLength - pad : end - start;
-                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                  }
-                  else if (j > i) {
-                      if (end > count) {
-                          const length = Math.min(end - count, lineLength);
-                          res.push(`   |  ` + repeat(`^`, length));
-                      }
-                      count += lineLength + 1;
-                  }
-              }
-              break;
-          }
-      }
-      return res.join('\n');
-  }
-  function repeat(str, n) {
-      let result = '';
-      if (n > 0) {
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-              // eslint-disable-line
-              if (n & 1)
-                  result += str;
-              n >>>= 1;
-              if (n <= 0)
-                  break;
-              str += str;
-          }
-      }
-      return result;
+  const range = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (let j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      continue;
+                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      const pad = start - (count - lineLength) + 1;
+                      const length = end > count ? lineLength - pad : end - start;
+                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          const length = Math.min(end - count, lineLength);
+                          res.push(`   |  ` + repeat(`^`, length));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
+          }
+      }
+      return res.join('\n');
+  }
+  function repeat(str, n) {
+      let result = '';
+      if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  result += str;
+              n >>>= 1;
+              if (n <= 0)
+                  break;
+              str += str;
+          }
+      }
+      return result;
   }
 
-  function createFunction(code, errors) {
-      try {
-          return new Function(code);
-      }
-      catch (err) {
-          errors.push({ err, code });
-          return noop;
-      }
-  }
-  function createCompileToFunctionFn(compile) {
-      const cache = Object.create(null);
-      return function compileToFunctions(template, options, vm) {
-          options = extend({}, options);
-          const warn = options.warn || warn$2;
-          delete options.warn;
-          /* istanbul ignore if */
-          {
-              // detect possible CSP restriction
-              try {
-                  new Function('return 1');
-              }
-              catch (e) {
-                  if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn('It seems you are using the standalone build of Vue.js in an ' +
-                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                          'The template compiler cannot work in this environment. Consider ' +
-                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                          'templates into render functions.');
-                  }
-              }
-          }
-          // check cache
-          const key = options.delimiters
-              ? String(options.delimiters) + template
-              : template;
-          if (cache[key]) {
-              return cache[key];
-          }
-          // compile
-          const compiled = compile(template, options);
-          // check compilation errors/tips
-          {
-              if (compiled.errors && compiled.errors.length) {
-                  if (options.outputSourceRange) {
-                      compiled.errors.forEach((e) => {
-                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                              generateCodeFrame(template, e.start, e.end), vm);
-                      });
-                  }
-                  else {
-                      warn(`Error compiling template:\n\n${template}\n\n` +
-                          compiled.errors.map((e) => `- ${e}`).join('\n') +
-                          '\n', vm);
-                  }
-              }
-              if (compiled.tips && compiled.tips.length) {
-                  if (options.outputSourceRange) {
-                      compiled.tips.forEach((e) => tip(e.msg, vm));
-                  }
-                  else {
-                      compiled.tips.forEach((msg) => tip(msg, vm));
-                  }
-              }
-          }
-          // turn code into functions
-          const res = {};
-          const fnGenErrors = [];
-          res.render = createFunction(compiled.render, fnGenErrors);
-          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-              return createFunction(code, fnGenErrors);
-          });
-          // check function generation errors.
-          // this should only happen if there is a bug in the compiler itself.
-          // mostly for codegen development use
-          /* istanbul ignore if */
-          {
-              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn(`Failed to generate render function:\n\n` +
-                      fnGenErrors
-                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                          .join('\n'), vm);
-              }
-          }
-          return (cache[key] = res);
-      };
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
+      }
+      catch (err) {
+          errors.push({ err, code });
+          return noop;
+      }
+  }
+  function createCompileToFunctionFn(compile) {
+      const cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          const warn = options.warn || warn$2;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
+          }
+          // check cache
+          const key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
+          }
+          // compile
+          const compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach((e) => {
+                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn(`Error compiling template:\n\n${template}\n\n` +
+                          compiled.errors.map((e) => `- ${e}`).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach((e) => tip(e.msg, vm));
+                  }
+                  else {
+                      compiled.tips.forEach((msg) => tip(msg, vm));
+                  }
+              }
+          }
+          // turn code into functions
+          const res = {};
+          const fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn(`Failed to generate render function:\n\n` +
+                      fnGenErrors
+                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
   }
 
-  function createCompilerCreator(baseCompile) {
-      return function createCompiler(baseOptions) {
-          function compile(template, options) {
-              const finalOptions = Object.create(baseOptions);
-              const errors = [];
-              const tips = [];
-              let warn = (msg, range, tip) => {
-                  (tip ? tips : errors).push(msg);
-              };
-              if (options) {
-                  if (options.outputSourceRange) {
-                      // $flow-disable-line
-                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                      warn = (msg, range, tip) => {
-                          const data = { msg };
-                          if (range) {
-                              if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
-                              }
-                              if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
-                              }
-                          }
-                          (tip ? tips : errors).push(data);
-                      };
-                  }
-                  // merge custom modules
-                  if (options.modules) {
-                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                  }
-                  // merge custom directives
-                  if (options.directives) {
-                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                  }
-                  // copy other options
-                  for (const key in options) {
-                      if (key !== 'modules' && key !== 'directives') {
-                          finalOptions[key] = options[key];
-                      }
-                  }
-              }
-              finalOptions.warn = warn;
-              const compiled = baseCompile(template.trim(), finalOptions);
-              {
-                  detectErrors(compiled.ast, warn);
-              }
-              compiled.errors = errors;
-              compiled.tips = tips;
-              return compiled;
-          }
-          return {
-              compile,
-              compileToFunctions: createCompileToFunctionFn(compile),
-          };
-      };
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              const finalOptions = Object.create(baseOptions);
+              const errors = [];
+              const tips = [];
+              let warn = (msg, range, tip) => {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = (msg, range, tip) => {
+                          const data = typeof (msg) === 'string' ? { msg } : msg;
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (const key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
+              }
+              finalOptions.warn = warn;
+              const compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
+          }
+          return {
+              compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
   }
 
-  // `createCompilerCreator` allows creating compilers that use alternative
-  // parser/optimizer/codegen, e.g the SSR optimizing compiler.
-  // Here we just export a default compiler using the default parts.
-  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-      const ast = parse(template.trim(), options);
-      if (options.optimize !== false) {
-          optimize(ast, options);
-      }
-      const code = generate(ast, options);
-      return {
-          ast,
-          render: code.render,
-          staticRenderFns: code.staticRenderFns,
-      };
+  // `createCompilerCreator` allows creating compilers that use alternative
+  // parser/optimizer/codegen, e.g the SSR optimizing compiler.
+  // Here we just export a default compiler using the default parts.
+  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      const ast = parse(template.trim(), options);
+      if (options.optimize !== false) {
+          optimize(ast, options);
+      }
+      const code = generate(ast, options);
+      return {
+          ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
   const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-  // check whether current browser encodes a char inside attribute values
-  let div;
-  function getShouldDecode(href) {
-      div = div || document.createElement('div');
-      div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-      return div.innerHTML.indexOf('&#10;') > 0;
-  }
-  // #3663: IE encodes newlines inside attribute values while other browsers don't
-  const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-  // #6828: chrome encodes content in a[href]
-  const shouldDecodeNewlinesForHref = inBrowser
-      ? getShouldDecode(true)
+  // check whether current browser encodes a char inside attribute values
+  let div;
+  function getShouldDecode(href) {
+      div = div || document.createElement('div');
+      div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
+      return div.innerHTML.indexOf('&#10;') > 0;
+  }
+  // #3663: IE encodes newlines inside attribute values while other browsers don't
+  const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
+  // #6828: chrome encodes content in a[href]
+  const shouldDecodeNewlinesForHref = inBrowser
+      ? getShouldDecode(true)
       : false;
 
-  const idToTemplate = cached((id) => {
-      const el = query(id);
-      return el && el.innerHTML;
-  });
-  const mount = Vue.prototype.$mount;
-  Vue.prototype.$mount = function (el, hydrating) {
-      el = el && query(el);
-      /* istanbul ignore if */
-      if (el === document.body || el === document.documentElement) {
-          warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-          return this;
-      }
-      const options = this.$options;
-      // resolve template/el and convert to render function
-      if (!options.render) {
-          let template = options.template;
-          if (template) {
-              if (typeof template === 'string') {
-                  if (template.charAt(0) === '#') {
-                      template = idToTemplate(template);
-                      /* istanbul ignore if */
-                      if (!template) {
-                          warn$2(`Template element not found or is empty: ${options.template}`, this);
-                      }
-                  }
-              }
-              else if (template.nodeType) {
-                  template = template.innerHTML;
-              }
-              else {
-                  {
-                      warn$2('invalid template option:' + template, this);
-                  }
-                  return this;
-              }
-          }
-          else if (el) {
-              // @ts-expect-error
-              template = getOuterHTML(el);
-          }
-          if (template) {
-              /* istanbul ignore if */
-              if (config.performance && mark) {
-                  mark('compile');
-              }
-              const { render, staticRenderFns } = compileToFunctions(template, {
-                  outputSourceRange: "development" !== 'production',
-                  shouldDecodeNewlines,
-                  shouldDecodeNewlinesForHref,
-                  delimiters: options.delimiters,
-                  comments: options.comments,
-              }, this);
-              options.render = render;
-              options.staticRenderFns = staticRenderFns;
-              /* istanbul ignore if */
-              if (config.performance && mark) {
-                  mark('compile end');
-                  measure(`vue ${this._name} compile`, 'compile', 'compile end');
-              }
-          }
-      }
-      return mount.call(this, el, hydrating);
-  };
-  /**
-   * Get outerHTML of elements, taking care
-   * of SVG elements in IE as well.
-   */
-  function getOuterHTML(el) {
-      if (el.outerHTML) {
-          return el.outerHTML;
-      }
-      else {
-          const container = document.createElement('div');
-          container.appendChild(el.cloneNode(true));
-          return container.innerHTML;
-      }
-  }
+  const idToTemplate = cached((id) => {
+      const el = query(id);
+      return el && el.innerHTML;
+  });
+  const mount = Vue.prototype.$mount;
+  Vue.prototype.$mount = function (el, hydrating) {
+      el = el && query(el);
+      /* istanbul ignore if */
+      if (el === document.body || el === document.documentElement) {
+          warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
+          return this;
+      }
+      const options = this.$options;
+      // resolve template/el and convert to render function
+      if (!options.render) {
+          let template = options.template;
+          if (template) {
+              if (typeof template === 'string') {
+                  if (template.charAt(0) === '#') {
+                      template = idToTemplate(template);
+                      /* istanbul ignore if */
+                      if (!template) {
+                          warn$2(`Template element not found or is empty: ${options.template}`, this);
+                      }
+                  }
+              }
+              else if (template.nodeType) {
+                  template = template.innerHTML;
+              }
+              else {
+                  {
+                      warn$2('invalid template option:' + template, this);
+                  }
+                  return this;
+              }
+          }
+          else if (el) {
+              // @ts-expect-error
+              template = getOuterHTML(el);
+          }
+          if (template) {
+              /* istanbul ignore if */
+              if (config.performance && mark) {
+                  mark('compile');
+              }
+              const { render, staticRenderFns } = compileToFunctions(template, {
+                  outputSourceRange: "development" !== 'production',
+                  shouldDecodeNewlines,
+                  shouldDecodeNewlinesForHref,
+                  delimiters: options.delimiters,
+                  comments: options.comments,
+              }, this);
+              options.render = render;
+              options.staticRenderFns = staticRenderFns;
+              /* istanbul ignore if */
+              if (config.performance && mark) {
+                  mark('compile end');
+                  measure(`vue ${this._name} compile`, 'compile', 'compile end');
+              }
+          }
+      }
+      return mount.call(this, el, hydrating);
+  };
+  /**
+   * Get outerHTML of elements, taking care
+   * of SVG elements in IE as well.
+   */
+  function getOuterHTML(el) {
+      if (el.outerHTML) {
+          return el.outerHTML;
+      }
+      else {
+          const container = document.createElement('div');
+          container.appendChild(el.cloneNode(true));
+          return container.innerHTML;
+      }
+  }
   Vue.compile = compileToFunctions;
 
   return Vue;
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
index a203036f2bf..ac55f353bdc 100644
--- a/dist/vue.runtime.common.dev.js
+++ b/dist/vue.runtime.common.dev.js
@@ -5,4985 +5,4982 @@
  */
 'use strict';
 
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$2(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Simple bind polyfill for environments that do not support it,
+ * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+ * since native bind is now performant enough in most browsers.
+ * But removing it would mean breaking code that was able to run in
+ * PhantomJS 1.x, so this must be kept for backward compatibility.
+ */
+/* istanbul ignore next */
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        const l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+const bind = Function.prototype.bind ? nativeBind : polyfillBind;
+/**
+ * Convert an Array-like object to a real Array.
+ */
+function toArray(list, start) {
+    start = start || 0;
+    let i = list.length - start;
+    const ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
+}
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Ensure a function is called only once.
+ */
+function once(fn) {
+    let called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Check if a string starts with $ or _
+ */
+function isReserved(str) {
+    const c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
+}
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Parse simple path.
+ */
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    const segments = path.split('.');
+    return function (obj) {
+        for (let i = 0; i < segments.length; i++) {
+            if (!obj)
+                return;
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+// detect devtools
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-let warn = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+{
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid$2 = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (!config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Delete a property and trigger change if necessary.
+ */
+function del(target, key) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+{
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives$1(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                // @ts-expect-error should it be any?
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
+/* globals MutationObserver */
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
+function flushCallbacks() {
+    pending = false;
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// Here we have async deferring wrappers using microtasks.
+// In 2.5 we used (macro) tasks (in combination with microtasks).
+// However, it has subtle problems when state is changed right before repaint
+// (e.g. #6813, out-in transitions).
+// Also, using (macro) tasks in event handler would cause some weird behaviors
+// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+// So we now use microtasks everywhere, again.
+// A major drawback of this tradeoff is that there are some scenarios
+// where microtasks have too high a priority and fire in between supposedly
+// sequential events (e.g. #4521, #6690, which have workarounds)
+// or even between bubbling of the same event (#6566).
+let timerFunc;
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            setTimeout(noop);
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = () => {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = () => {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    let _resolve;
+    callbacks.push(() => {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise((resolve) => {
+            _resolve = resolve;
+        });
+    }
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-{
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
+/* not type checking this file because flow doesn't play well with Proxy */
+let initProxy;
+{
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const warnNonPresent = (target, key) => {
+        warn(`Property or method "${key}" is not defined on the instance but ` +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    const warnReservedPrefix = (target, key) => {
+        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return has || !isAllowed;
+        },
+    };
+    const getHandler = {
+        get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-let mark;
-let measure;
-{
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
+let mark;
+let measure;
+{
+    const perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    let invoker;
+    const oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            {
-                defineReactive(vm, key, result[key], () => {
-                    warn(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function initProvide(vm) {
+    const provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    const result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach((key) => {
+            /* istanbul ignore else */
+            {
+                defineReactive(vm, key, result[key], () => {
+                    warn(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
+                });
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    warn(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook$1(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-        }, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    const parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
+        }, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
+        }, true);
+    }
+}
+let currentRenderingInstance = null;
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        let vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
+        }
+        catch (e) {
+            handleError(e, vm, `render`);
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, `renderError`);
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
+        }
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
+            }
+            vnode = createEmptyVNode();
+        }
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            warn(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`
-                                );
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
+}
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    const owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        const resolve = once((res) => {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        const reject = once((reason) => {
+            warn(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(`timeout (${res.timeout}ms)`
+                                );
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
+    }
 }
 
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    const listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
+    }
+}
+let target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target$1.$off(event, fn);
+}
+function createOnceHandler$1(event, fn) {
+    const _target = target$1;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
+}
+function eventsMixin(Vue) {
+    const hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        const vm = this;
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        const vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        const vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
+            }
+            return vm;
+        }
+        // specific event
+        const cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        let cb;
+        let i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        const vm = this;
+        {
+            const lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+            }
+        }
+        let cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+let isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    const prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return () => {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    const options = vm.$options;
+    // locate first non-abstract parent
+    let parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        const vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        const vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook$1(vm, "beforeDestroy");
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        const parent = vm.$parent;
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove$2(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        let i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook$1(vm, "destroyed");
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                vm.$options.el ||
+                el) {
+                warn("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
+            }
+            else {
+                warn("Failed to mount component: template or render function not defined.", vm);
+            }
+        }
+    }
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
+    /* istanbul ignore if */
+    if (config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
+            mark(startTag);
+            const vnode = vm._render();
+            mark(endTag);
+            measure(`vue ${name} render`, startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = () => {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook$1(vm, "beforeUpdate");
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook$1(vm, "mounted");
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "deactivated");
+    }
+}
+function callHook$1(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (!config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+let currentFlushTimestamp = 0;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Flush both queues and run the watchers.
+ */
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    let watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort((a, b) => a.id - b.id);
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
+    }
+}
+function callUpdatedHooks(queue) {
+    let i = queue.length;
+    while (i--) {
+        const watcher = queue[i];
+        const vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, 'updated');
+        }
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
+}
+function callActivatedHooks(queue) {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
+}
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ */
+function queueWatcher(watcher) {
+    const id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            let i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (!config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
+    }
 }
 
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = expOrFn.toString()
-            ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                // @ts-expect-error e is unknown, should we cast or any?
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
+let uid$1 = 0;
+/**
+ * A watcher parses an expression, collects dependencies,
+ * and fires callback when the expression value changes.
+ * This is used for both the $watch() api and directives.
+ */
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = expOrFn.toString()
+            ;
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                warn(`Failed watching path: "${expOrFn}" ` +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
+        }
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    }
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    }
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    }
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    }
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    }
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
+    }
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    }
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
 }
 
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        warn("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        {
-            if (methods && hasOwn(methods, key)) {
-                warn(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            warn(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (getter == null) {
-            warn(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else {
-            if (key in vm.$data) {
-                warn(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        {
-            if (typeof methods[key] !== "function") {
-                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    {
-        dataDef.set = function () {
-            warn("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
+const sharedPropertyDefinition = {
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
+};
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    const opts = vm.$options;
+    if (opts.props)
+        initProps$1(vm, opts.props);
+    if (opts.methods)
+        initMethods(vm, opts.methods);
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        initComputed$1(vm, opts.computed);
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps$1(vm, propsOptions) {
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    for (const key in propsOptions) {
+        keys.push(key);
+        const value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        {
+            const hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+            }
+            defineReactive(props, key, value, () => {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
+                }
+            });
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, `_props`, key);
+        }
+    }
+    toggleObserving(true);
+}
+function initData(vm) {
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        warn("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+    }
+    // proxy data on instance
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
+    while (i--) {
+        const key = keys[i];
+        {
+            if (methods && hasOwn(methods, key)) {
+                warn(`Method "${key}" has already been defined as a data property.`, vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            warn(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, `_data`, key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
+}
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
+    }
+    catch (e) {
+        handleError(e, vm, `data()`);
+        return {};
+    }
+    finally {
+        popTarget();
+    }
+}
+const computedWatcherOptions = { lazy: true };
+function initComputed$1(vm, computed) {
+    // $flow-disable-line
+    const watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (getter == null) {
+            warn(`Getter is missing for computed property "${key}".`, vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else {
+            if (key in vm.$data) {
+                warn(`The computed property "${key}" is already defined in data.`, vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn(`The computed property "${key}" is already defined as a method.`, vm);
+            }
+        }
+    }
+}
+function defineComputed(target, key, userDef) {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        const watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
+}
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
+        {
+            if (typeof methods[key] !== "function") {
+                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(`Method "${key}" has already been defined as a prop.`, vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
+            }
+        }
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
+    }
+}
+function initWatch(vm, watch) {
+    for (const key in watch) {
+        const handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (let i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === "string") {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    const dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    const propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    {
+        dataDef.set = function () {
+            warn("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
+        };
+        propsDef.set = function () {
+            warn(`$props is readonly.`, this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        const vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        const watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
+            pushTarget();
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        {
-            initProxy(vm);
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+let uid = 0;
+function initMixin$1(Vue) {
+    Vue.prototype._init = function (options) {
+        const vm = this;
+        // a uid
+        vm._uid = uid++;
+        let startTag, endTag;
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        {
+            initProxy(vm);
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook$1(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook$1(vm, 'created');
+        /* istanbul ignore if */
+        if (config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    const opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    const parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    const vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function Vue(options) {
-    if (!(this instanceof Vue)) {
-        warn("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
+function Vue(options) {
+    if (!(this instanceof Vue)) {
+        warn("Vue is a constructor and should be called with the `new` keyword");
+    }
+    this._init(options);
+}
+//@ts-expect-error Vue has function type
+initMixin$1(Vue);
+//@ts-expect-error Vue has function type
+stateMixin(Vue);
+//@ts-expect-error Vue has function type
+eventsMixin(Vue);
+//@ts-expect-error Vue has function type
+lifecycleMixin(Vue);
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        const args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
+function initMixin(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    let cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        const name = extendOptions.name || Super.options.name;
+        if (name) {
+            validateComponentName(name);
+        }
+        const Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps(Comp) {
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
+    }
+}
+function initComputed(Comp) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach((type) => {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
+/* @flow */
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
+}
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
+var KeepAlive = {
+    name: "keep-alive",
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed() {
+        for (const key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
+        });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
+        });
+    },
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            const { cache, keys } = this;
+            const key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove$2(keys, key);
+                keys.push(key);
+            }
+            else {
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
+            }
+            // @ts-expect-error can vnode.data can be undefined
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
-var builtInComponents = {
-    KeepAlive,
+var builtInComponents = {
+    KeepAlive,
 };
 
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    {
-        configDef.set = () => {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+function initGlobalAPI(Vue) {
+    // config
+    const configDef = {};
+    configDef.get = () => config;
+    {
+        configDef.set = () => {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn,
+        extend,
+        mergeOptions,
+        defineReactive,
+    };
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = (obj) => {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach((type) => {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
+initGlobalAPI(Vue);
+Object.defineProperty(Vue.prototype, '$isServer', {
+    get: isServerRendering,
+});
+Object.defineProperty(Vue.prototype, '$ssrContext', {
+    get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
+});
+// expose FunctionalRenderContext for ssr runtime helper installation
+Object.defineProperty(Vue, 'FunctionalRenderContext', {
+    value: FunctionalRenderContext,
+});
 Vue.version = '2.6.14';
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+const isReservedAttr = makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+};
+const getXlinkProp = (name) => {
+    return isXlink(name) ? name.slice(6, name.length) : '';
+};
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
+const namespaceMap = {
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
+};
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+const unknownElementCache = Object.create(null);
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    const el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
+}
 const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        const selected = document.querySelector(el);
+        if (!selected) {
+            warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
+function createElement(tagName, vnode) {
+    const elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
+}
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
+}
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function createComment(text) {
+    return document.createComment(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    node.appendChild(child);
+}
+function parentNode(node) {
+    return node.parentNode;
+}
+function nextSibling(node) {
+    return node.nextSibling;
+}
+function tagName(node) {
+    return node.tagName;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5002,2407 +4999,2406 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
+var ref = {
+    create(_, vnode) {
+        registerRef(vnode);
+    },
+    update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy(vnode) {
+        registerRef(vnode, true);
+    },
+};
+function registerRef(vnode, isRemoval) {
+    const key = vnode.data.ref;
+    if (!isDef(key))
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
+    if (isRemoval) {
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
+        }
+        else if (obj === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(obj)) {
+                refs[key] = [ref];
+            }
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
+    }
 }
 
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
+/**
+ * Virtual DOM patching algorithm based on Snabbdom by
+ * Simon Friis Vindum (@paldepind)
+ * Licensed under the MIT License
+ * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+ *
+ * modified by Evan You (@yyx990803)
+ *
+ * Not type-checking this because this file is perf-critical and the cost
+ * of making flow understand it is not worth it.
+ */
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    let i, key;
+    const map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            map[key] = i;
+    }
+    return map;
+}
+function createPatchFunction(backend) {
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
+    }
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    }
+    function createRmCb(childElm, listeners) {
+        function remove() {
+            if (--remove.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove.listeners = listeners;
+        return remove;
+    }
+    function removeNode(el) {
+        const parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
+    }
+    function isUnknownElement(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some((ignore) => {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    let creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
+        if (isDef(tag)) {
+            {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i = vnode.data;
+        if (isDef(i)) {
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        let innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref) {
+        if (isDef(parent)) {
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            {
+                checkDuplicateKeys(children);
+            }
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                i.create(emptyNode, vnode);
+            if (isDef(i.insert))
+                insertedVnodeQueue.push(vnode);
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        let i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            let ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        let i, j;
+        const data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                i(vnode);
+            for (i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            let i;
+            const listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        const canMove = !removeOnly;
+        {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function checkDuplicateKeys(children) {
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                return i;
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        const elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        let i;
+        const data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                i(oldVnode, vnode);
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+            }
+            else if (isDef(ch)) {
+                {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    nodeOps.setTextContent(elm, '');
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                i(oldVnode, vnode);
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    let hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        let i;
+        const { tag, data, children } = vnode;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                i(vnode, true /* hydrating */);
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                let fullInvoke = false;
+                for (const key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                invokeDestroyHook(oldVnode);
+            return;
+        }
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            const isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            // @ts-expect-error should it be any?
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
+var directives = {
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
+};
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
+    }
+}
+const emptyModifiers = Object.create(null);
+function normalizeDirectives(dirs, vm) {
+    const res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    let i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
+    // $flow-disable-line
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+}
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    const fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+        }
+    }
 }
 
 var baseModules = [ref, directives];
 
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
+function updateAttrs(oldVnode, vnode) {
+    const opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            const blocker = (e) => {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
+}
+var attrs = {
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass = {
-    create: updateClass,
-    update: updateClass,
+function updateClass(oldVnode, vnode) {
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    let cls = genClassForVnode(vnode);
+    // handle transition classes
+    const transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
+}
+var klass = {
+    create: updateClass,
+    update: updateClass,
 };
 
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
 const CHECKBOX_RADIO_TOKEN = '__c';
 
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+// normalize v-model event tokens that can only be determined at runtime.
+// it's important to place the event as the first in the array because
+// the whole point is ensuring the v-model callback gets called before
+// user-attached handlers.
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
+}
+let target;
+function createOnceHandler(event, handler, capture) {
+    const _target = target; // save current target element in closure
+    return function onceHandler() {
+        const res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove(event, onceHandler, capture, _target);
+        }
+    };
+}
+// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+// implementation and does not fire microtasks in between event propagation, so
+// safe to exclude.
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+function add(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+}
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
+}
+var events = {
+    create: updateDOMListeners,
+    update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
+let svgContainer;
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                vnode.children.length = 0;
+            if (cur === oldProps[key])
+                continue;
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            const strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    let notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
+}
+var domProps = {
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style = {
-    create: updateStyle,
-    update: updateStyle,
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        const normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (let i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
+};
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
+});
+function updateStyle(oldVnode, vnode) {
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    const newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
+    }
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
+    }
+}
+var style = {
+    create: updateStyle,
+    update: updateStyle,
 };
 
-const whitespaceRE = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
+const whitespaceRE = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        const cur = ` ${el.getAttribute('class') || ''} `;
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        const res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+const autoCssTransition = cached((name) => {
+    return {
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
+    };
+});
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
+// Transition property/event sniffing
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+const raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ (fn) => fn();
+function nextFrame(fn) {
+    raf(() => {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type)
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    const onEnd = (e) => {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(() => {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+const transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type,
+        timeout,
+        propCount,
+        hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map((d, i) => {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
+function enter(vnode, toggleDisplay) {
+    const el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    const el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    const cb = (el._leaveCb = once(() => {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn(`<transition> explicit ${name} duration is NaN - ` +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    const invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
+    if (vnode.data.show !== true) {
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
+    }
     : {};
 
 var platformModules = [attrs, klass, events, domProps, style, transition];
 
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules);
+// the directive module should be applied last, after all
+// built-in modules have been applied.
+const modules = platformModules.concat(baseModules);
 const patch = createPatchFunction({ nodeOps, modules });
 
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        warn(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+/**
+ * Not type checking this file because flow doesn't like attaching
+ * properties to Elements.
+ */
+/* istanbul ignore if */
+if (isIE9) {
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
+}
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', () => {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                // trigger change event if
+                // no matching option found for at least one value
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
+};
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(() => {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    const value = binding.value;
+    const isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        warn(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+        return;
+    }
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
+}
+function hasNoMatchingOption(value, options) {
+    return options.every((o) => !looseEqual(o, value));
+}
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
+}
+function onCompositionStart(e) {
+    e.target.composing = true;
+}
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        return;
+    e.target.composing = false;
+    trigger(e.target, 'input');
+}
+function trigger(el, type) {
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind(el, { value }, vnode) {
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, () => {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update(el, { value, oldValue }, vnode) {
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, () => {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, () => {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
-var platformDirectives = {
-    model: directive,
-    show,
+var platformDirectives = {
+    model: directive,
+    show,
 };
 
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
+// Provides transition support for a single element/component.
+const transitionProps = {
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
+};
+// in case the child is also an abstract component, e.g. <keep-alive>
+// we want to recursively retrieve the real component to be rendered
+function getRealChild(vnode) {
+    const compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    const data = {};
+    const options = comp.$options;
+    // props
+    for (const key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
+}
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
+    }
+}
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
+}
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
+var Transition = {
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render(h) {
+        let children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        const mode = this.mode;
+        // warn invalid mode
+        if (mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        const rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        const child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        const id = `__transition-${this._uid}-`;
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            const oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
+// Provides transition support for list items.
+const props = extend({
+    tag: String,
+    moveClass: String,
+}, transitionProps);
+delete props.mode;
+var TransitionGroup = {
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
+            // force removing pass
+            this.__patch__(this._vnode, this.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this._vnode = this.kept;
+            restoreActiveInstance();
+            update.call(this, vnode, hydrating);
+        };
+    },
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
+                        : c.tag;
+                    warn(`<transition-group> children must be keyed: <${name}>`);
+                }
+            }
+        }
+        if (prevChildren) {
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
+                }
+                else {
+                    removed.push(c);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach((c) => {
+            if (c.data.moved) {
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
+        });
+    },
+    methods: {
+        hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            const clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach((cls) => {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = "none";
+            this.$el.appendChild(clone);
+            const info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
+};
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    if (c.elm._moveCb) {
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    if (c.elm._enterCb) {
+        c.elm._enterCb();
+    }
+}
+function recordPosition(c) {
+    c.data.newPos = c.elm.getBoundingClientRect();
+}
+function applyTranslation(c) {
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        c.data.moved = true;
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
+    }
 }
 
-var platformComponents = {
-    Transition,
-    TransitionGroup,
+var platformComponents = {
+    Transition,
+    TransitionGroup,
 };
 
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
+// install platform specific utils
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
+Vue.config.isReservedAttr = isReservedAttr;
+Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.isUnknownElement = isUnknownElement;
+// install platform runtime directives & components
+extend(Vue.options.directives, platformDirectives);
+extend(Vue.options.components, platformComponents);
+// install platform patch function
+Vue.prototype.__patch__ = inBrowser ? patch : noop;
+// public mount method
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
+};
+// devtools global hook
+/* istanbul ignore next */
+if (inBrowser) {
+    setTimeout(() => {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
+        }
+    }, 0);
 }
 
 module.exports = Vue;
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
index a6fb79b350a..f7fa9715b81 100644
--- a/dist/vue.runtime.esm.js
+++ b/dist/vue.runtime.esm.js
@@ -3,5019 +3,5016 @@
  * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+function isRegExp(v) {
+    return _toString.call(v) === '[object RegExp]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$2(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Simple bind polyfill for environments that do not support it,
+ * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+ * since native bind is now performant enough in most browsers.
+ * But removing it would mean breaking code that was able to run in
+ * PhantomJS 1.x, so this must be kept for backward compatibility.
+ */
+/* istanbul ignore next */
+function polyfillBind(fn, ctx) {
+    function boundFn(a) {
+        const l = arguments.length;
+        return l
+            ? l > 1
+                ? fn.apply(ctx, arguments)
+                : fn.call(ctx, a)
+            : fn.call(ctx);
+    }
+    boundFn._length = fn.length;
+    return boundFn;
+}
+function nativeBind(fn, ctx) {
+    return fn.bind(ctx);
+}
+// @ts-expect-error bind cannot be `undefined`
+const bind = Function.prototype.bind ? nativeBind : polyfillBind;
+/**
+ * Convert an Array-like object to a real Array.
+ */
+function toArray(list, start) {
+    start = start || 0;
+    let i = list.length - start;
+    const ret = new Array(i);
+    while (i--) {
+        ret[i] = list[i + start];
+    }
+    return ret;
+}
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Ensure a function is called only once.
+ */
+function once(fn) {
+    let called = false;
+    return function () {
+        if (!called) {
+            called = true;
+            fn.apply(this, arguments);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Check if a string starts with $ or _
+ */
+function isReserved(str) {
+    const c = (str + '').charCodeAt(0);
+    return c === 0x24 || c === 0x5f;
+}
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
+}
+/**
+ * Parse simple path.
+ */
+const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+function parsePath(path) {
+    if (bailRE.test(path)) {
+        return;
+    }
+    const segments = path.split('.');
+    return function (obj) {
+        for (let i = 0; i < segments.length; i++) {
+            if (!obj)
+                return;
+            obj = obj[segments[i]];
+        }
+        return obj;
+    };
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+const isFF = UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+// detect devtools
+const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-let warn = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+if (process.env.NODE_ENV !== 'production') {
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (config.warnHandler) {
+            config.warnHandler.call(null, msg, vm, trace);
+        }
+        else if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid$2 = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid$2++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$2(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Delete a property and trigger change if necessary.
+ */
+function del(target, key) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.splice(key, 1);
+        return;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                '- just set it to null.');
+        return;
+    }
+    if (!hasOwn(target, key)) {
+        return;
+    }
+    delete target[key];
+    if (!ob) {
+        return;
+    }
+    ob.dep.notify();
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warn('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+if (process.env.NODE_ENV !== 'production') {
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warn('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives$1(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    if (process.env.NODE_ENV !== 'production') {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives$1(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-        // skip validation for weex recycle-list child component props
-        !(false  )) {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-        warn('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    if (process.env.NODE_ENV !== 'production' &&
+        // skip validation for weex recycle-list child component props
+        !(false  )) {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+        warn('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    if (process.env.NODE_ENV !== 'production') {
-        warn(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    if (config.errorHandler) {
+        try {
+            return config.errorHandler.call(null, err, vm, info);
+        }
+        catch (e) {
+            // if the user intentionally throws the original error in the handler,
+            // do not log it twice
+            if (e !== err) {
+                logError(e, null, 'config.errorHandler');
+            }
+        }
+    }
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    if (process.env.NODE_ENV !== 'production') {
+        warn(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                // @ts-expect-error should it be any?
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
+/* globals MutationObserver */
+let isUsingMicroTask = false;
+const callbacks = [];
+let pending = false;
+function flushCallbacks() {
+    pending = false;
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// Here we have async deferring wrappers using microtasks.
+// In 2.5 we used (macro) tasks (in combination with microtasks).
+// However, it has subtle problems when state is changed right before repaint
+// (e.g. #6813, out-in transitions).
+// Also, using (macro) tasks in event handler would cause some weird behaviors
+// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+// So we now use microtasks everywhere, again.
+// A major drawback of this tradeoff is that there are some scenarios
+// where microtasks have too high a priority and fire in between supposedly
+// sequential events (e.g. #4521, #6690, which have workarounds)
+// or even between bubbling of the same event (#6566).
+let timerFunc;
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    const p = Promise.resolve();
+    timerFunc = () => {
+        p.then(flushCallbacks);
+        // In problematic UIWebViews, Promise.then doesn't completely break, but
+        // it can get stuck in a weird state where callbacks are pushed into the
+        // microtask queue but the queue isn't being flushed, until the browser
+        // needs to do some other work, e.g. handle a timer. Therefore we can
+        // "force" the microtask queue to be flushed by adding an empty timer.
+        if (isIOS)
+            setTimeout(noop);
+    };
+    isUsingMicroTask = true;
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+    timerFunc = () => {
+        counter = (counter + 1) % 2;
+        textNode.data = String(counter);
+    };
+    isUsingMicroTask = true;
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+    // Fallback to setImmediate.
+    // Technically it leverages the (macro) task queue,
+    // but it is still a better choice than setTimeout.
+    timerFunc = () => {
+        setImmediate(flushCallbacks);
+    };
+}
+else {
+    // Fallback to setTimeout.
+    timerFunc = () => {
+        setTimeout(flushCallbacks, 0);
+    };
+}
+function nextTick(cb, ctx) {
+    let _resolve;
+    callbacks.push(() => {
+        if (cb) {
+            try {
+                cb.call(ctx);
+            }
+            catch (e) {
+                handleError(e, ctx, 'nextTick');
+            }
+        }
+        else if (_resolve) {
+            _resolve(ctx);
+        }
+    });
+    if (!pending) {
+        pending = true;
+        timerFunc();
+    }
+    // $flow-disable-line
+    if (!cb && typeof Promise !== 'undefined') {
+        return new Promise((resolve) => {
+            _resolve = resolve;
+        });
+    }
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-if (process.env.NODE_ENV !== 'production') {
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
+/* not type checking this file because flow doesn't play well with Proxy */
+let initProxy;
+if (process.env.NODE_ENV !== 'production') {
+    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const warnNonPresent = (target, key) => {
+        warn(`Property or method "${key}" is not defined on the instance but ` +
+            'referenced during render. Make sure that this property is reactive, ' +
+            'either in the data option, or for class-based components, by ' +
+            'initializing the property. ' +
+            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+    };
+    const warnReservedPrefix = (target, key) => {
+        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
+            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+            'prevent conflicts with Vue internals. ' +
+            'See: https://vuejs.org/v2/api/#data', target);
+    };
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
+    const hasHandler = {
+        has(target, key) {
+            const has = key in target;
+            const isAllowed = allowedGlobals(key) ||
+                (typeof key === 'string' &&
+                    key.charAt(0) === '_' &&
+                    !(key in target.$data));
+            if (!has && !isAllowed) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return has || !isAllowed;
+        },
+    };
+    const getHandler = {
+        get(target, key) {
+            if (typeof key === 'string' && !(key in target)) {
+                if (key in target.$data)
+                    warnReservedPrefix(target, key);
+                else
+                    warnNonPresent(target, key);
+            }
+            return target[key];
+        },
+    };
+    initProxy = function initProxy(vm) {
+        if (hasProxy) {
+            // determine which proxy handler to use
+            const options = vm.$options;
+            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+            vm._renderProxy = new Proxy(vm, handlers);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+    };
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-let mark;
-let measure;
-if (process.env.NODE_ENV !== 'production') {
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
+let mark;
+let measure;
+if (process.env.NODE_ENV !== 'production') {
+    const perf = inBrowser && window.performance;
+    /* istanbul ignore if */
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        perf.clearMeasures) {
+        mark = (tag) => perf.mark(tag);
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+            // perf.clearMeasures(name)
+        };
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
+function mergeVNodeHook(def, hookKey, hook) {
+    if (def instanceof VNode) {
+        def = def.data.hook || (def.data.hook = {});
+    }
+    let invoker;
+    const oldHook = def[hookKey];
+    function wrappedHook() {
+        hook.apply(this, arguments);
+        // important: remove merged hook to ensure it's called only once
+        // and prevent memory leak
+        remove$2(invoker.fns, wrappedHook);
+    }
+    if (isUndef(oldHook)) {
+        // no existing hook
+        invoker = createFnInvoker([wrappedHook]);
+    }
+    else {
+        /* istanbul ignore if */
+        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+            // already a merged invoker
+            invoker = oldHook;
+            invoker.fns.push(wrappedHook);
+        }
+        else {
+            // existing plain hook
+            invoker = createFnInvoker([oldHook, wrappedHook]);
+        }
+    }
+    invoker.merged = true;
+    def[hookKey] = invoker;
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            if (process.env.NODE_ENV !== 'production') {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            if (process.env.NODE_ENV !== 'production') {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], () => {
-                    warn(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-            else {
-                defineReactive(vm, key, result[key]);
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else if (process.env.NODE_ENV !== 'production') {
-                    warn(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function initProvide(vm) {
+    const provide = vm.$options.provide;
+    if (provide) {
+        vm._provided =
+            typeof provide === 'function'
+                ? // @ts-expect-error typing not correct
+                    provide.call(vm)
+                : provide;
+    }
+}
+function initInjections(vm) {
+    const result = resolveInject(vm.$options.inject, vm);
+    if (result) {
+        toggleObserving(false);
+        Object.keys(result).forEach((key) => {
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production') {
+                defineReactive(vm, key, result[key], () => {
+                    warn(`Avoid mutating an injected value directly since the changes will be ` +
+                        `overwritten whenever the provided component re-renders. ` +
+                        `injection being mutated: "${key}"`, vm);
+                });
+            }
+            else {
+                defineReactive(vm, key, result[key]);
+            }
+        });
+        toggleObserving(true);
+    }
+}
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else if (process.env.NODE_ENV !== 'production') {
+                    warn(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
-                warn("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
+                warn("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (process.env.NODE_ENV !== 'production' &&
-            key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (process.env.NODE_ENV !== 'production' &&
+            key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    if (process.env.NODE_ENV !== 'production') {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    if (process.env.NODE_ENV !== 'production') {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        if (process.env.NODE_ENV !== 'production') {
-            warn(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook$1(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        if (process.env.NODE_ENV !== 'production') {
+            warn(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (process.env.NODE_ENV !== 'production' &&
-        isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (process.env.NODE_ENV !== 'production' &&
-                isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (process.env.NODE_ENV !== 'production' &&
+        isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if (config.isReservedTag(tag)) {
+            // platform built-in elements
+            if (process.env.NODE_ENV !== 'production' &&
+                isDef(data) &&
+                isDef(data.nativeOn) &&
+                data.tag !== 'component') {
+                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+            }
+            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+        }
+        else if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-        }, true);
-    }
-    else {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
+function initRender(vm) {
+    vm._vnode = null; // the root of the child tree
+    vm._staticTrees = null; // v-once cached trees
+    const options = vm.$options;
+    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+    const renderContext = parentVnode && parentVnode.context;
+    vm.$slots = resolveSlots(options._renderChildren, renderContext);
+    vm.$scopedSlots = emptyObject;
+    // bind the createElement fn to this instance
+    // so that we get proper render context inside it.
+    // args order: tag, data, children, normalizationType, alwaysNormalize
+    // internal version is used by render functions compiled from templates
+    // @ts-expect-error
+    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+    // normalization is always applied for the public version, used in
+    // user-written render functions.
+    // @ts-expect-error
+    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+    // $attrs & $listeners are exposed for easier HOC creation.
+    // they need to be reactive so that HOCs using them are always updated
+    const parentData = parentVnode && parentVnode.data;
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
+        }, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
+        }, true);
+    }
+    else {
+        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
+        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
+    }
+}
+let currentRenderingInstance = null;
+function renderMixin(Vue) {
+    // install runtime convenience helpers
+    installRenderHelpers(Vue.prototype);
+    Vue.prototype.$nextTick = function (fn) {
+        return nextTick(fn, this);
+    };
+    Vue.prototype._render = function () {
+        const vm = this;
+        const { render, _parentVnode } = vm.$options;
+        if (_parentVnode) {
+            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+        }
+        // set parent vnode. this allows render functions to have access
+        // to the data on the placeholder node.
+        vm.$vnode = _parentVnode;
+        // render self
+        let vnode;
+        try {
+            // There's no need to maintain a stack because all render fns are called
+            // separately from one another. Nested component's render fns are called
+            // when parent component is patched.
+            currentRenderingInstance = vm;
+            vnode = render.call(vm._renderProxy, vm.$createElement);
+        }
+        catch (e) {
+            handleError(e, vm, `render`);
+            // return error render result,
+            // or previous vnode to prevent render error causing blank component
+            /* istanbul ignore else */
+            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+                try {
+                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                }
+                catch (e) {
+                    handleError(e, vm, `renderError`);
+                    vnode = vm._vnode;
+                }
+            }
+            else {
+                vnode = vm._vnode;
+            }
+        }
+        finally {
+            currentRenderingInstance = null;
+        }
+        // if the returned array contains only a single node, allow it
+        if (Array.isArray(vnode) && vnode.length === 1) {
+            vnode = vnode[0];
+        }
+        // return empty vnode in case the render function errored out
+        if (!(vnode instanceof VNode)) {
+            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+                warn('Multiple root nodes returned from render function. Render function ' +
+                    'should return a single root node.', vm);
+            }
+            vnode = createEmptyVNode();
+        }
+        // set parent
+        vnode.parent = _parentVnode;
+        return vnode;
+    };
 }
 
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            process.env.NODE_ENV !== 'production' &&
-                warn(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(process.env.NODE_ENV !== 'production'
-                                ? `timeout (${res.timeout}ms)`
-                                : null);
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
+function ensureCtor(comp, base) {
+    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+        comp = comp.default;
+    }
+    return isObject(comp) ? base.extend(comp) : comp;
+}
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    const owner = currentRenderingInstance;
+    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+        // already pending
+        factory.owners.push(owner);
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
+    if (owner && !isDef(factory.owners)) {
+        const owners = (factory.owners = [owner]);
+        let sync = true;
+        let timerLoading = null;
+        let timerTimeout = null;
+        owner.$on('hook:destroyed', () => remove$2(owners, owner));
+        const forceRender = (renderCompleted) => {
+            for (let i = 0, l = owners.length; i < l; i++) {
+                owners[i].$forceUpdate();
+            }
+            if (renderCompleted) {
+                owners.length = 0;
+                if (timerLoading !== null) {
+                    clearTimeout(timerLoading);
+                    timerLoading = null;
+                }
+                if (timerTimeout !== null) {
+                    clearTimeout(timerTimeout);
+                    timerTimeout = null;
+                }
+            }
+        };
+        const resolve = once((res) => {
+            // cache resolved
+            factory.resolved = ensureCtor(res, baseCtor);
+            // invoke callbacks only if this is not a synchronous resolve
+            // (async resolves are shimmed as synchronous during SSR)
+            if (!sync) {
+                forceRender(true);
+            }
+            else {
+                owners.length = 0;
+            }
+        });
+        const reject = once((reason) => {
+            process.env.NODE_ENV !== 'production' &&
+                warn(`Failed to resolve async component: ${String(factory)}` +
+                    (reason ? `\nReason: ${reason}` : ''));
+            if (isDef(factory.errorComp)) {
+                factory.error = true;
+                forceRender(true);
+            }
+        });
+        const res = factory(resolve, reject);
+        if (isObject(res)) {
+            if (isPromise(res)) {
+                // () => Promise
+                if (isUndef(factory.resolved)) {
+                    res.then(resolve, reject);
+                }
+            }
+            else if (isPromise(res.component)) {
+                res.component.then(resolve, reject);
+                if (isDef(res.error)) {
+                    factory.errorComp = ensureCtor(res.error, baseCtor);
+                }
+                if (isDef(res.loading)) {
+                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                    if (res.delay === 0) {
+                        factory.loading = true;
+                    }
+                    else {
+                        // @ts-expect-error NodeJS timeout type
+                        timerLoading = setTimeout(() => {
+                            timerLoading = null;
+                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                factory.loading = true;
+                                forceRender(false);
+                            }
+                        }, res.delay || 200);
+                    }
+                }
+                if (isDef(res.timeout)) {
+                    // @ts-expect-error NodeJS timeout type
+                    timerTimeout = setTimeout(() => {
+                        timerTimeout = null;
+                        if (isUndef(factory.resolved)) {
+                            reject(process.env.NODE_ENV !== 'production'
+                                ? `timeout (${res.timeout}ms)`
+                                : null);
+                        }
+                    }, res.timeout);
+                }
+            }
+        }
+        sync = false;
+        // return in case resolved synchronously
+        return factory.loading ? factory.loadingComp : factory.resolved;
+    }
 }
 
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
+function getFirstComponentChild(children) {
+    if (Array.isArray(children)) {
+        for (let i = 0; i < children.length; i++) {
+            const c = children[i];
+            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                return c;
+            }
+        }
+    }
 }
 
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        if (process.env.NODE_ENV !== 'production') {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
+function initEvents(vm) {
+    vm._events = Object.create(null);
+    vm._hasHookEvent = false;
+    // init parent attached events
+    const listeners = vm.$options._parentListeners;
+    if (listeners) {
+        updateComponentListeners(vm, listeners);
+    }
+}
+let target$1;
+function add$1(event, fn) {
+    target$1.$on(event, fn);
+}
+function remove$1(event, fn) {
+    target$1.$off(event, fn);
+}
+function createOnceHandler$1(event, fn) {
+    const _target = target$1;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target$1 = vm;
+    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+    target$1 = undefined;
+}
+function eventsMixin(Vue) {
+    const hookRE = /^hook:/;
+    Vue.prototype.$on = function (event, fn) {
+        const vm = this;
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$on(event[i], fn);
+            }
+        }
+        else {
+            (vm._events[event] || (vm._events[event] = [])).push(fn);
+            // optimize hook:event cost by using a boolean flag marked at registration
+            // instead of a hash lookup
+            if (hookRE.test(event)) {
+                vm._hasHookEvent = true;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$once = function (event, fn) {
+        const vm = this;
+        function on() {
+            vm.$off(event, on);
+            fn.apply(vm, arguments);
+        }
+        on.fn = fn;
+        vm.$on(event, on);
+        return vm;
+    };
+    Vue.prototype.$off = function (event, fn) {
+        const vm = this;
+        // all
+        if (!arguments.length) {
+            vm._events = Object.create(null);
+            return vm;
+        }
+        // array of events
+        if (Array.isArray(event)) {
+            for (let i = 0, l = event.length; i < l; i++) {
+                vm.$off(event[i], fn);
+            }
+            return vm;
+        }
+        // specific event
+        const cbs = vm._events[event];
+        if (!cbs) {
+            return vm;
+        }
+        if (!fn) {
+            vm._events[event] = null;
+            return vm;
+        }
+        // specific handler
+        let cb;
+        let i = cbs.length;
+        while (i--) {
+            cb = cbs[i];
+            if (cb === fn || cb.fn === fn) {
+                cbs.splice(i, 1);
+                break;
+            }
+        }
+        return vm;
+    };
+    Vue.prototype.$emit = function (event) {
+        const vm = this;
+        if (process.env.NODE_ENV !== 'production') {
+            const lowerCaseEvent = event.toLowerCase();
+            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                    `Note that HTML attributes are case-insensitive and you cannot use ` +
+                    `v-on to listen to camelCase events when using in-DOM templates. ` +
+                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+            }
+        }
+        let cbs = vm._events[event];
+        if (cbs) {
+            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+            const args = toArray(arguments, 1);
+            const info = `event handler for "${event}"`;
+            for (let i = 0, l = cbs.length; i < l; i++) {
+                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+            }
+        }
+        return vm;
+    };
 }
 
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== "production") {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+let isUpdatingChildComponent = false;
+function setActiveInstance(vm) {
+    const prevActiveInstance = activeInstance;
+    activeInstance = vm;
+    return () => {
+        activeInstance = prevActiveInstance;
+    };
+}
+function initLifecycle(vm) {
+    const options = vm.$options;
+    // locate first non-abstract parent
+    let parent = options.parent;
+    if (parent && !options.abstract) {
+        while (parent.$options.abstract && parent.$parent) {
+            parent = parent.$parent;
+        }
+        parent.$children.push(vm);
+    }
+    vm.$parent = parent;
+    vm.$root = parent ? parent.$root : vm;
+    vm.$children = [];
+    vm.$refs = {};
+    vm._watcher = null;
+    vm._inactive = null;
+    vm._directInactive = false;
+    vm._isMounted = false;
+    vm._isDestroyed = false;
+    vm._isBeingDestroyed = false;
+}
+function lifecycleMixin(Vue) {
+    Vue.prototype._update = function (vnode, hydrating) {
+        const vm = this;
+        const prevEl = vm.$el;
+        const prevVnode = vm._vnode;
+        const restoreActiveInstance = setActiveInstance(vm);
+        vm._vnode = vnode;
+        // Vue.prototype.__patch__ is injected in entry points
+        // based on the rendering backend used.
+        if (!prevVnode) {
+            // initial render
+            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+        }
+        else {
+            // updates
+            vm.$el = vm.__patch__(prevVnode, vnode);
+        }
+        restoreActiveInstance();
+        // update __vue__ reference
+        if (prevEl) {
+            prevEl.__vue__ = null;
+        }
+        if (vm.$el) {
+            vm.$el.__vue__ = vm;
+        }
+        // if parent is an HOC, update its $el as well
+        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+            vm.$parent.$el = vm.$el;
+        }
+        // updated hook is called by the scheduler to ensure that children are
+        // updated in a parent's updated hook.
+    };
+    Vue.prototype.$forceUpdate = function () {
+        const vm = this;
+        if (vm._watcher) {
+            vm._watcher.update();
+        }
+    };
+    Vue.prototype.$destroy = function () {
+        const vm = this;
+        if (vm._isBeingDestroyed) {
+            return;
+        }
+        callHook$1(vm, "beforeDestroy");
+        vm._isBeingDestroyed = true;
+        // remove self from parent
+        const parent = vm.$parent;
+        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+            remove$2(parent.$children, vm);
+        }
+        // teardown watchers
+        if (vm._watcher) {
+            vm._watcher.teardown();
+        }
+        let i = vm._watchers.length;
+        while (i--) {
+            vm._watchers[i].teardown();
+        }
+        // remove reference from data ob
+        // frozen object may not have observer.
+        if (vm._data.__ob__) {
+            vm._data.__ob__.vmCount--;
+        }
+        // call the last hook...
+        vm._isDestroyed = true;
+        // invoke destroy hooks on current rendered tree
+        vm.__patch__(vm._vnode, null);
+        // fire destroyed hook
+        callHook$1(vm, "destroyed");
+        // turn off all instance listeners.
+        vm.$off();
+        // remove __vue__ reference
+        if (vm.$el) {
+            vm.$el.__vue__ = null;
+        }
+        // release circular reference (#6759)
+        if (vm.$vnode) {
+            vm.$vnode.parent = null;
+        }
+    };
+}
+function mountComponent(vm, el, hydrating) {
+    vm.$el = el;
+    if (!vm.$options.render) {
+        // @ts-expect-error invalid type
+        vm.$options.render = createEmptyVNode;
+        if (process.env.NODE_ENV !== "production") {
+            /* istanbul ignore if */
+            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                vm.$options.el ||
+                el) {
+                warn("You are using the runtime-only build of Vue where the template " +
+                    "compiler is not available. Either pre-compile the templates into " +
+                    "render functions, or use the compiler-included build.", vm);
+            }
+            else {
+                warn("Failed to mount component: template or render function not defined.", vm);
+            }
+        }
+    }
+    callHook$1(vm, "beforeMount");
+    let updateComponent;
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
+        updateComponent = () => {
+            const name = vm._name;
+            const id = vm._uid;
+            const startTag = `vue-perf-start:${id}`;
+            const endTag = `vue-perf-end:${id}`;
+            mark(startTag);
+            const vnode = vm._render();
+            mark(endTag);
+            measure(`vue ${name} render`, startTag, endTag);
+            mark(startTag);
+            vm._update(vnode, hydrating);
+            mark(endTag);
+            measure(`vue ${name} patch`, startTag, endTag);
+        };
+    }
+    else {
+        updateComponent = () => {
+            vm._update(vm._render(), hydrating);
+        };
+    }
+    // we set this to vm._watcher inside the watcher's constructor
+    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+    // component's mounted hook), which relies on vm._watcher being already defined
+    new Watcher(vm, updateComponent, noop, {
+        before() {
+            if (vm._isMounted && !vm._isDestroyed) {
+                callHook$1(vm, "beforeUpdate");
+            }
+        },
+    }, true /* isRenderWatcher */);
+    hydrating = false;
+    // manually mounted instance, call mounted on self
+    // mounted is called for render-created child components in its inserted hook
+    if (vm.$vnode == null) {
+        vm._isMounted = true;
+        callHook$1(vm, "mounted");
+    }
+    return vm;
+}
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    if (process.env.NODE_ENV !== "production") {
+        isUpdatingChildComponent = true;
+    }
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+    if (process.env.NODE_ENV !== "production") {
+        isUpdatingChildComponent = false;
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook$1(vm, "deactivated");
+    }
+}
+function callHook$1(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    if (process.env.NODE_ENV !== 'production') {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (process.env.NODE_ENV !== 'production' && !config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
+const MAX_UPDATE_COUNT = 100;
+const queue = [];
+const activatedChildren = [];
+let has = {};
+let circular = {};
+let waiting = false;
+let flushing = false;
+let index = 0;
+/**
+ * Reset the scheduler's state.
+ */
+function resetSchedulerState() {
+    index = queue.length = activatedChildren.length = 0;
+    has = {};
+    if (process.env.NODE_ENV !== 'production') {
+        circular = {};
+    }
+    waiting = flushing = false;
+}
+// Async edge case #6566 requires saving the timestamp when event listeners are
+// attached. However, calling performance.now() has a perf overhead especially
+// if the page has thousands of event listeners. Instead, we take a timestamp
+// every time the scheduler flushes and use that for all event listeners
+// attached during that flush.
+let currentFlushTimestamp = 0;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Flush both queues and run the watchers.
+ */
+function flushSchedulerQueue() {
+    currentFlushTimestamp = getNow();
+    flushing = true;
+    let watcher, id;
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child)
+    // 2. A component's user watchers are run before its render watcher (because
+    //    user watchers are created before the render watcher)
+    // 3. If a component is destroyed during a parent component's watcher run,
+    //    its watchers can be skipped.
+    queue.sort((a, b) => a.id - b.id);
+    // do not cache length because more watchers might be pushed
+    // as we run existing watchers
+    for (index = 0; index < queue.length; index++) {
+        watcher = queue[index];
+        if (watcher.before) {
+            watcher.before();
+        }
+        id = watcher.id;
+        has[id] = null;
+        watcher.run();
+        // in dev build, check and stop circular updates.
+        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+            circular[id] = (circular[id] || 0) + 1;
+            if (circular[id] > MAX_UPDATE_COUNT) {
+                warn('You may have an infinite update loop ' +
+                    (watcher.user
+                        ? `in watcher with expression "${watcher.expression}"`
+                        : `in a component render function.`), watcher.vm);
+                break;
+            }
+        }
+    }
+    // keep copies of post queues before resetting state
+    const activatedQueue = activatedChildren.slice();
+    const updatedQueue = queue.slice();
+    resetSchedulerState();
+    // call component updated and activated hooks
+    callActivatedHooks(activatedQueue);
+    callUpdatedHooks(updatedQueue);
+    // devtool hook
+    /* istanbul ignore if */
+    if (devtools && config.devtools) {
+        devtools.emit('flush');
+    }
+}
+function callUpdatedHooks(queue) {
+    let i = queue.length;
+    while (i--) {
+        const watcher = queue[i];
+        const vm = watcher.vm;
+        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+            callHook$1(vm, 'updated');
+        }
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
+    activatedChildren.push(vm);
+}
+function callActivatedHooks(queue) {
+    for (let i = 0; i < queue.length; i++) {
+        queue[i]._inactive = true;
+        activateChildComponent(queue[i], true /* true */);
+    }
+}
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ */
+function queueWatcher(watcher) {
+    const id = watcher.id;
+    if (has[id] == null) {
+        has[id] = true;
+        if (!flushing) {
+            queue.push(watcher);
+        }
+        else {
+            // if already flushing, splice the watcher based on its id
+            // if already past its id, it will be run next immediately.
+            let i = queue.length - 1;
+            while (i > index && queue[i].id > watcher.id) {
+                i--;
+            }
+            queue.splice(i + 1, 0, watcher);
+        }
+        // queue the flush
+        if (!waiting) {
+            waiting = true;
+            if (process.env.NODE_ENV !== 'production' && !config.async) {
+                flushSchedulerQueue();
+                return;
+            }
+            nextTick(flushSchedulerQueue);
+        }
+    }
 }
 
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = process.env.NODE_ENV !== 'production'
-            ? expOrFn.toString()
-            : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' && warn(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                // @ts-expect-error e is unknown, should we cast or any?
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
+let uid$1 = 0;
+/**
+ * A watcher parses an expression, collects dependencies,
+ * and fires callback when the expression value changes.
+ * This is used for both the $watch() api and directives.
+ */
+class Watcher {
+    vm;
+    expression;
+    cb;
+    id;
+    deep;
+    user;
+    lazy;
+    sync;
+    dirty;
+    active;
+    deps;
+    newDeps;
+    depIds;
+    newDepIds;
+    before;
+    getter;
+    value;
+    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+        this.vm = vm;
+        if (isRenderWatcher) {
+            vm._watcher = this;
+        }
+        vm._watchers.push(this);
+        // options
+        if (options) {
+            this.deep = !!options.deep;
+            this.user = !!options.user;
+            this.lazy = !!options.lazy;
+            this.sync = !!options.sync;
+            this.before = options.before;
+        }
+        else {
+            this.deep = this.user = this.lazy = this.sync = false;
+        }
+        this.cb = cb;
+        this.id = ++uid$1; // uid for batching
+        this.active = true;
+        this.dirty = this.lazy; // for lazy watchers
+        this.deps = [];
+        this.newDeps = [];
+        this.depIds = new _Set();
+        this.newDepIds = new _Set();
+        this.expression = process.env.NODE_ENV !== 'production'
+            ? expOrFn.toString()
+            : '';
+        // parse expression for getter
+        if (typeof expOrFn === 'function') {
+            this.getter = expOrFn;
+        }
+        else {
+            this.getter = parsePath(expOrFn);
+            if (!this.getter) {
+                this.getter = noop;
+                process.env.NODE_ENV !== 'production' && warn(`Failed watching path: "${expOrFn}" ` +
+                    'Watcher only accepts simple dot-delimited paths. ' +
+                    'For full control, use a function instead.', vm);
+            }
+        }
+        this.value = this.lazy
+            ? undefined
+            : this.get();
+    }
+    /**
+     * Evaluate the getter, and re-collect dependencies.
+     */
+    get() {
+        pushTarget(this);
+        let value;
+        const vm = this.vm;
+        try {
+            value = this.getter.call(vm, vm);
+        }
+        catch (e) {
+            if (this.user) {
+                handleError(e, vm, `getter for watcher "${this.expression}"`);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            // "touch" every property so they are all tracked as
+            // dependencies for deep watching
+            if (this.deep) {
+                traverse(value);
+            }
+            popTarget();
+            this.cleanupDeps();
+        }
+        return value;
+    }
+    /**
+     * Add a dependency to this directive.
+     */
+    addDep(dep) {
+        const id = dep.id;
+        if (!this.newDepIds.has(id)) {
+            this.newDepIds.add(id);
+            this.newDeps.push(dep);
+            if (!this.depIds.has(id)) {
+                dep.addSub(this);
+            }
+        }
+    }
+    /**
+     * Clean up for dependency collection.
+     */
+    cleanupDeps() {
+        let i = this.deps.length;
+        while (i--) {
+            const dep = this.deps[i];
+            if (!this.newDepIds.has(dep.id)) {
+                dep.removeSub(this);
+            }
+        }
+        let tmp = this.depIds;
+        this.depIds = this.newDepIds;
+        this.newDepIds = tmp;
+        this.newDepIds.clear();
+        tmp = this.deps;
+        this.deps = this.newDeps;
+        this.newDeps = tmp;
+        this.newDeps.length = 0;
+    }
+    /**
+     * Subscriber interface.
+     * Will be called when a dependency changes.
+     */
+    update() {
+        /* istanbul ignore else */
+        if (this.lazy) {
+            this.dirty = true;
+        }
+        else if (this.sync) {
+            this.run();
+        }
+        else {
+            queueWatcher(this);
+        }
+    }
+    /**
+     * Scheduler job interface.
+     * Will be called by the scheduler.
+     */
+    run() {
+        if (this.active) {
+            const value = this.get();
+            if (value !== this.value ||
+                // Deep watchers and watchers on Object/Arrays should fire even
+                // when the value is the same, because the value may
+                // have mutated.
+                isObject(value) ||
+                this.deep) {
+                // set new value
+                const oldValue = this.value;
+                this.value = value;
+                if (this.user) {
+                    const info = `callback for watcher "${this.expression}"`;
+                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                }
+                else {
+                    this.cb.call(this.vm, value, oldValue);
+                }
+            }
+        }
+    }
+    /**
+     * Evaluate the value of the watcher.
+     * This only gets called for lazy watchers.
+     */
+    evaluate() {
+        this.value = this.get();
+        this.dirty = false;
+    }
+    /**
+     * Depend on all deps collected by this watcher.
+     */
+    depend() {
+        let i = this.deps.length;
+        while (i--) {
+            this.deps[i].depend();
+        }
+    }
+    /**
+     * Remove self from all dependencies' subscriber list.
+     */
+    teardown() {
+        if (this.active) {
+            // remove self from vm's watcher list
+            // this is a somewhat expensive operation so we skip it
+            // if the vm is being destroyed.
+            if (!this.vm._isBeingDestroyed) {
+                remove$2(this.vm._watchers, this);
+            }
+            let i = this.deps.length;
+            while (i--) {
+                this.deps[i].removeSub(this);
+            }
+            this.active = false;
+        }
+    }
 }
 
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== "production") {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        else {
-            defineReactive(props, key, value);
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        process.env.NODE_ENV !== "production" &&
-            warn("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        if (process.env.NODE_ENV !== "production") {
-            if (methods && hasOwn(methods, key)) {
-                warn(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== "production" &&
-                warn(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== "production" && getter == null) {
-            warn(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else if (process.env.NODE_ENV !== "production") {
-            if (key in vm.$data) {
-                warn(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (process.env.NODE_ENV !== "production" &&
-        sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        if (process.env.NODE_ENV !== "production") {
-            if (typeof methods[key] !== "function") {
-                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    if (process.env.NODE_ENV !== "production") {
-        dataDef.set = function () {
-            warn("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
+const sharedPropertyDefinition = {
+    enumerable: true,
+    configurable: true,
+    get: noop,
+    set: noop,
+};
+function proxy(target, sourceKey, key) {
+    sharedPropertyDefinition.get = function proxyGetter() {
+        return this[sourceKey][key];
+    };
+    sharedPropertyDefinition.set = function proxySetter(val) {
+        this[sourceKey][key] = val;
+    };
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function initState(vm) {
+    vm._watchers = [];
+    const opts = vm.$options;
+    if (opts.props)
+        initProps$1(vm, opts.props);
+    if (opts.methods)
+        initMethods(vm, opts.methods);
+    if (opts.data) {
+        initData(vm);
+    }
+    else {
+        observe((vm._data = {}), true /* asRootData */);
+    }
+    if (opts.computed)
+        initComputed$1(vm, opts.computed);
+    if (opts.watch && opts.watch !== nativeWatch) {
+        initWatch(vm, opts.watch);
+    }
+}
+function initProps$1(vm, propsOptions) {
+    const propsData = vm.$options.propsData || {};
+    const props = (vm._props = {});
+    // cache prop keys so that future props updates can iterate using Array
+    // instead of dynamic object key enumeration.
+    const keys = (vm.$options._propKeys = []);
+    const isRoot = !vm.$parent;
+    // root instance props should be converted
+    if (!isRoot) {
+        toggleObserving(false);
+    }
+    for (const key in propsOptions) {
+        keys.push(key);
+        const value = validateProp(key, propsOptions, propsData, vm);
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== "production") {
+            const hyphenatedKey = hyphenate(key);
+            if (isReservedAttribute(hyphenatedKey) ||
+                config.isReservedAttr(hyphenatedKey)) {
+                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+            }
+            defineReactive(props, key, value, () => {
+                if (!isRoot && !isUpdatingChildComponent) {
+                    warn(`Avoid mutating a prop directly since the value will be ` +
+                        `overwritten whenever the parent component re-renders. ` +
+                        `Instead, use a data or computed property based on the prop's ` +
+                        `value. Prop being mutated: "${key}"`, vm);
+                }
+            });
+        }
+        else {
+            defineReactive(props, key, value);
+        }
+        // static props are already proxied on the component's prototype
+        // during Vue.extend(). We only need to proxy props defined at
+        // instantiation here.
+        if (!(key in vm)) {
+            proxy(vm, `_props`, key);
+        }
+    }
+    toggleObserving(true);
+}
+function initData(vm) {
+    let data = vm.$options.data;
+    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+    if (!isPlainObject(data)) {
+        data = {};
+        process.env.NODE_ENV !== "production" &&
+            warn("data functions should return an object:\n" +
+                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+    }
+    // proxy data on instance
+    const keys = Object.keys(data);
+    const props = vm.$options.props;
+    const methods = vm.$options.methods;
+    let i = keys.length;
+    while (i--) {
+        const key = keys[i];
+        if (process.env.NODE_ENV !== "production") {
+            if (methods && hasOwn(methods, key)) {
+                warn(`Method "${key}" has already been defined as a data property.`, vm);
+            }
+        }
+        if (props && hasOwn(props, key)) {
+            process.env.NODE_ENV !== "production" &&
+                warn(`The data property "${key}" is already declared as a prop. ` +
+                    `Use prop default value instead.`, vm);
+        }
+        else if (!isReserved(key)) {
+            proxy(vm, `_data`, key);
+        }
+    }
+    // observe data
+    observe(data, true /* asRootData */);
+}
+function getData(data, vm) {
+    // #7573 disable dep collection when invoking data getters
+    pushTarget();
+    try {
+        return data.call(vm, vm);
+    }
+    catch (e) {
+        handleError(e, vm, `data()`);
+        return {};
+    }
+    finally {
+        popTarget();
+    }
+}
+const computedWatcherOptions = { lazy: true };
+function initComputed$1(vm, computed) {
+    // $flow-disable-line
+    const watchers = (vm._computedWatchers = Object.create(null));
+    // computed properties are just getters during SSR
+    const isSSR = isServerRendering();
+    for (const key in computed) {
+        const userDef = computed[key];
+        const getter = typeof userDef === "function" ? userDef : userDef.get;
+        if (process.env.NODE_ENV !== "production" && getter == null) {
+            warn(`Getter is missing for computed property "${key}".`, vm);
+        }
+        if (!isSSR) {
+            // create internal watcher for the computed property.
+            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+        }
+        // component-defined computed properties are already defined on the
+        // component prototype. We only need to define computed properties defined
+        // at instantiation here.
+        if (!(key in vm)) {
+            defineComputed(vm, key, userDef);
+        }
+        else if (process.env.NODE_ENV !== "production") {
+            if (key in vm.$data) {
+                warn(`The computed property "${key}" is already defined in data.`, vm);
+            }
+            else if (vm.$options.props && key in vm.$options.props) {
+                warn(`The computed property "${key}" is already defined as a prop.`, vm);
+            }
+            else if (vm.$options.methods && key in vm.$options.methods) {
+                warn(`The computed property "${key}" is already defined as a method.`, vm);
+            }
+        }
+    }
+}
+function defineComputed(target, key, userDef) {
+    const shouldCache = !isServerRendering();
+    if (typeof userDef === "function") {
+        sharedPropertyDefinition.get = shouldCache
+            ? createComputedGetter(key)
+            : createGetterInvoker(userDef);
+        sharedPropertyDefinition.set = noop;
+    }
+    else {
+        sharedPropertyDefinition.get = userDef.get
+            ? shouldCache && userDef.cache !== false
+                ? createComputedGetter(key)
+                : createGetterInvoker(userDef.get)
+            : noop;
+        sharedPropertyDefinition.set = userDef.set || noop;
+    }
+    if (process.env.NODE_ENV !== "production" &&
+        sharedPropertyDefinition.set === noop) {
+        sharedPropertyDefinition.set = function () {
+            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
+        };
+    }
+    Object.defineProperty(target, key, sharedPropertyDefinition);
+}
+function createComputedGetter(key) {
+    return function computedGetter() {
+        const watcher = this._computedWatchers && this._computedWatchers[key];
+        if (watcher) {
+            if (watcher.dirty) {
+                watcher.evaluate();
+            }
+            if (Dep.target) {
+                watcher.depend();
+            }
+            return watcher.value;
+        }
+    };
+}
+function createGetterInvoker(fn) {
+    return function computedGetter() {
+        return fn.call(this, this);
+    };
+}
+function initMethods(vm, methods) {
+    const props = vm.$options.props;
+    for (const key in methods) {
+        if (process.env.NODE_ENV !== "production") {
+            if (typeof methods[key] !== "function") {
+                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                    `Did you reference the function correctly?`, vm);
+            }
+            if (props && hasOwn(props, key)) {
+                warn(`Method "${key}" has already been defined as a prop.`, vm);
+            }
+            if (key in vm && isReserved(key)) {
+                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                    `Avoid defining component methods that start with _ or $.`);
+            }
+        }
+        vm[key] =
+            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
+    }
+}
+function initWatch(vm, watch) {
+    for (const key in watch) {
+        const handler = watch[key];
+        if (Array.isArray(handler)) {
+            for (let i = 0; i < handler.length; i++) {
+                createWatcher(vm, key, handler[i]);
+            }
+        }
+        else {
+            createWatcher(vm, key, handler);
+        }
+    }
+}
+function createWatcher(vm, expOrFn, handler, options) {
+    if (isPlainObject(handler)) {
+        options = handler;
+        handler = handler.handler;
+    }
+    if (typeof handler === "string") {
+        handler = vm[handler];
+    }
+    return vm.$watch(expOrFn, handler, options);
+}
+function stateMixin(Vue) {
+    // flow somehow has problems with directly declared definition object
+    // when using Object.defineProperty, so we have to procedurally build up
+    // the object here.
+    const dataDef = {};
+    dataDef.get = function () {
+        return this._data;
+    };
+    const propsDef = {};
+    propsDef.get = function () {
+        return this._props;
+    };
+    if (process.env.NODE_ENV !== "production") {
+        dataDef.set = function () {
+            warn("Avoid replacing instance root $data. " +
+                "Use nested data properties instead.", this);
+        };
+        propsDef.set = function () {
+            warn(`$props is readonly.`, this);
+        };
+    }
+    Object.defineProperty(Vue.prototype, "$data", dataDef);
+    Object.defineProperty(Vue.prototype, "$props", propsDef);
+    Vue.prototype.$set = set;
+    Vue.prototype.$delete = del;
+    Vue.prototype.$watch = function (expOrFn, cb, options) {
+        const vm = this;
+        if (isPlainObject(cb)) {
+            return createWatcher(vm, expOrFn, cb, options);
+        }
+        options = options || {};
+        options.user = true;
+        const watcher = new Watcher(vm, expOrFn, cb, options);
+        if (options.immediate) {
+            const info = `callback for immediate watcher "${watcher.expression}"`;
+            pushTarget();
+            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+            popTarget();
+        }
+        return function unwatchFn() {
+            watcher.teardown();
+        };
+    };
 }
 
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            initProxy(vm);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+let uid = 0;
+function initMixin$1(Vue) {
+    Vue.prototype._init = function (options) {
+        const vm = this;
+        // a uid
+        vm._uid = uid++;
+        let startTag, endTag;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            startTag = `vue-perf-start:${vm._uid}`;
+            endTag = `vue-perf-end:${vm._uid}`;
+            mark(startTag);
+        }
+        // a flag to avoid this being observed
+        vm._isVue = true;
+        // merge options
+        if (options && options._isComponent) {
+            // optimize internal component instantiation
+            // since dynamic options merging is pretty slow, and none of the
+            // internal component options needs special treatment.
+            initInternalComponent(vm, options);
+        }
+        else {
+            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+        }
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+            initProxy(vm);
+        }
+        else {
+            vm._renderProxy = vm;
+        }
+        // expose real self
+        vm._self = vm;
+        initLifecycle(vm);
+        initEvents(vm);
+        initRender(vm);
+        callHook$1(vm, 'beforeCreate');
+        initInjections(vm); // resolve injections before data/props
+        initState(vm);
+        initProvide(vm); // resolve provide after data/props
+        callHook$1(vm, 'created');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+            vm._name = formatComponentName(vm, false);
+            mark(endTag);
+            measure(`vue ${vm._name} init`, startTag, endTag);
+        }
+        if (vm.$options.el) {
+            vm.$mount(vm.$options.el);
+        }
+    };
+}
+function initInternalComponent(vm, options) {
+    const opts = (vm.$options = Object.create(vm.constructor.options));
+    // doing this because it's faster than dynamic enumeration.
+    const parentVnode = options._parentVnode;
+    opts.parent = options.parent;
+    opts._parentVnode = parentVnode;
+    const vnodeComponentOptions = parentVnode.componentOptions;
+    opts.propsData = vnodeComponentOptions.propsData;
+    opts._parentListeners = vnodeComponentOptions.listeners;
+    opts._renderChildren = vnodeComponentOptions.children;
+    opts._componentTag = vnodeComponentOptions.tag;
+    if (options.render) {
+        opts.render = options.render;
+        opts.staticRenderFns = options.staticRenderFns;
+    }
+}
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function Vue(options) {
-    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
-        warn("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
+function Vue(options) {
+    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
+        warn("Vue is a constructor and should be called with the `new` keyword");
+    }
+    this._init(options);
+}
+//@ts-expect-error Vue has function type
+initMixin$1(Vue);
+//@ts-expect-error Vue has function type
+stateMixin(Vue);
+//@ts-expect-error Vue has function type
+eventsMixin(Vue);
+//@ts-expect-error Vue has function type
+lifecycleMixin(Vue);
+//@ts-expect-error Vue has function type
 renderMixin(Vue);
 
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
+function initUse(Vue) {
+    Vue.use = function (plugin) {
+        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+        if (installedPlugins.indexOf(plugin) > -1) {
+            return this;
+        }
+        // additional parameters
+        const args = toArray(arguments, 1);
+        args.unshift(this);
+        if (typeof plugin.install === 'function') {
+            plugin.install.apply(plugin, args);
+        }
+        else if (typeof plugin === 'function') {
+            plugin.apply(null, args);
+        }
+        installedPlugins.push(plugin);
+        return this;
+    };
 }
 
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
+function initMixin(Vue) {
+    Vue.mixin = function (mixin) {
+        this.options = mergeOptions(this.options, mixin);
+        return this;
+    };
 }
 
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (process.env.NODE_ENV !== 'production' && name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
+function initExtend(Vue) {
+    /**
+     * Each instance constructor, including Vue, has a unique
+     * cid. This enables us to create wrapped "child
+     * constructors" for prototypal inheritance and cache them.
+     */
+    Vue.cid = 0;
+    let cid = 1;
+    /**
+     * Class inheritance
+     */
+    Vue.extend = function (extendOptions) {
+        extendOptions = extendOptions || {};
+        const Super = this;
+        const SuperId = Super.cid;
+        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+        if (cachedCtors[SuperId]) {
+            return cachedCtors[SuperId];
+        }
+        const name = extendOptions.name || Super.options.name;
+        if (process.env.NODE_ENV !== 'production' && name) {
+            validateComponentName(name);
+        }
+        const Sub = function VueComponent(options) {
+            this._init(options);
+        };
+        Sub.prototype = Object.create(Super.prototype);
+        Sub.prototype.constructor = Sub;
+        Sub.cid = cid++;
+        Sub.options = mergeOptions(Super.options, extendOptions);
+        Sub['super'] = Super;
+        // For props and computed properties, we define the proxy getters on
+        // the Vue instances at extension time, on the extended prototype. This
+        // avoids Object.defineProperty calls for each instance created.
+        if (Sub.options.props) {
+            initProps(Sub);
+        }
+        if (Sub.options.computed) {
+            initComputed(Sub);
+        }
+        // allow further extension/mixin/plugin usage
+        Sub.extend = Super.extend;
+        Sub.mixin = Super.mixin;
+        Sub.use = Super.use;
+        // create asset registers, so extended classes
+        // can have their private assets too.
+        ASSET_TYPES.forEach(function (type) {
+            Sub[type] = Super[type];
+        });
+        // enable recursive self-lookup
+        if (name) {
+            Sub.options.components[name] = Sub;
+        }
+        // keep a reference to the super options at extension time.
+        // later at instantiation we can check if Super's options have
+        // been updated.
+        Sub.superOptions = Super.options;
+        Sub.extendOptions = extendOptions;
+        Sub.sealedOptions = extend({}, Sub.options);
+        // cache constructor
+        cachedCtors[SuperId] = Sub;
+        return Sub;
+    };
+}
+function initProps(Comp) {
+    const props = Comp.options.props;
+    for (const key in props) {
+        proxy(Comp.prototype, `_props`, key);
+    }
+}
+function initComputed(Comp) {
+    const computed = Comp.options.computed;
+    for (const key in computed) {
+        defineComputed(Comp.prototype, key, computed[key]);
+    }
 }
 
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (process.env.NODE_ENV !== 'production' && type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
+function initAssetRegisters(Vue) {
+    /**
+     * Create asset registration methods.
+     */
+    ASSET_TYPES.forEach((type) => {
+        // @ts-expect-error function is not exact same type
+        Vue[type] = function (id, definition) {
+            if (!definition) {
+                return this.options[type + 's'][id];
+            }
+            else {
+                /* istanbul ignore if */
+                if (process.env.NODE_ENV !== 'production' && type === 'component') {
+                    validateComponentName(id);
+                }
+                if (type === 'component' && isPlainObject(definition)) {
+                    // @ts-expect-error
+                    definition.name = definition.name || id;
+                    definition = this.options._base.extend(definition);
+                }
+                if (type === 'directive' && typeof definition === 'function') {
+                    definition = { bind: definition, update: definition };
+                }
+                this.options[type + 's'][id] = definition;
+                return definition;
+            }
+        };
+    });
 }
 
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
+/* @flow */
+function getComponentName(opts) {
+    return opts && (opts.Ctor.options.name || opts.tag);
+}
+function matches(pattern, name) {
+    if (Array.isArray(pattern)) {
+        return pattern.indexOf(name) > -1;
+    }
+    else if (typeof pattern === "string") {
+        return pattern.split(",").indexOf(name) > -1;
+    }
+    else if (isRegExp(pattern)) {
+        return pattern.test(name);
+    }
+    /* istanbul ignore next */
+    return false;
+}
+function pruneCache(keepAliveInstance, filter) {
+    const { cache, keys, _vnode } = keepAliveInstance;
+    for (const key in cache) {
+        const entry = cache[key];
+        if (entry) {
+            const name = entry.name;
+            if (name && !filter(name)) {
+                pruneCacheEntry(cache, key, keys, _vnode);
+            }
+        }
+    }
+}
+function pruneCacheEntry(cache, key, keys, current) {
+    const entry = cache[key];
+    if (entry && (!current || entry.tag !== current.tag)) {
+        // @ts-expect-error can be undefined
+        entry.componentInstance.$destroy();
+    }
+    cache[key] = null;
+    remove$2(keys, key);
+}
+const patternTypes = [String, RegExp, Array];
+// TODO defineComponent
+var KeepAlive = {
+    name: "keep-alive",
+    abstract: true,
+    props: {
+        include: patternTypes,
+        exclude: patternTypes,
+        max: [String, Number],
+    },
+    methods: {
+        cacheVNode() {
+            const { cache, keys, vnodeToCache, keyToCache } = this;
+            if (vnodeToCache) {
+                const { tag, componentInstance, componentOptions } = vnodeToCache;
+                cache[keyToCache] = {
+                    name: getComponentName(componentOptions),
+                    tag,
+                    componentInstance,
+                };
+                keys.push(keyToCache);
+                // prune oldest entry
+                if (this.max && keys.length > parseInt(this.max)) {
+                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                }
+                this.vnodeToCache = null;
+            }
+        },
+    },
+    created() {
+        this.cache = Object.create(null);
+        this.keys = [];
+    },
+    destroyed() {
+        for (const key in this.cache) {
+            pruneCacheEntry(this.cache, key, this.keys);
+        }
+    },
+    mounted() {
+        this.cacheVNode();
+        this.$watch("include", (val) => {
+            pruneCache(this, (name) => matches(val, name));
+        });
+        this.$watch("exclude", (val) => {
+            pruneCache(this, (name) => !matches(val, name));
+        });
+    },
+    updated() {
+        this.cacheVNode();
+    },
+    render() {
+        const slot = this.$slots.default;
+        const vnode = getFirstComponentChild(slot);
+        const componentOptions = vnode && vnode.componentOptions;
+        if (componentOptions) {
+            // check pattern
+            const name = getComponentName(componentOptions);
+            const { include, exclude } = this;
+            if (
+            // not included
+            (include && (!name || !matches(include, name))) ||
+                // excluded
+                (exclude && name && matches(exclude, name))) {
+                return vnode;
+            }
+            const { cache, keys } = this;
+            const key = vnode.key == null
+                ? // same constructor may get registered as different local components
+                    // so cid alone is not enough (#3269)
+                    componentOptions.Ctor.cid +
+                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                : vnode.key;
+            if (cache[key]) {
+                vnode.componentInstance = cache[key].componentInstance;
+                // make current key freshest
+                remove$2(keys, key);
+                keys.push(key);
+            }
+            else {
+                // delay setting the cache until update
+                this.vnodeToCache = vnode;
+                this.keyToCache = key;
+            }
+            // @ts-expect-error can vnode.data can be undefined
+            vnode.data.keepAlive = true;
+        }
+        return vnode || (slot && slot[0]);
+    },
 };
 
-var builtInComponents = {
-    KeepAlive,
+var builtInComponents = {
+    KeepAlive,
 };
 
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    if (process.env.NODE_ENV !== 'production') {
-        configDef.set = () => {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
+function initGlobalAPI(Vue) {
+    // config
+    const configDef = {};
+    configDef.get = () => config;
+    if (process.env.NODE_ENV !== 'production') {
+        configDef.set = () => {
+            warn('Do not replace the Vue.config object, set individual fields instead.');
+        };
+    }
+    Object.defineProperty(Vue, 'config', configDef);
+    // exposed util methods.
+    // NOTE: these are not considered part of the public API - avoid relying on
+    // them unless you are aware of the risk.
+    Vue.util = {
+        warn,
+        extend,
+        mergeOptions,
+        defineReactive,
+    };
+    Vue.set = set;
+    Vue.delete = del;
+    Vue.nextTick = nextTick;
+    // 2.6 explicit observable API
+    Vue.observable = (obj) => {
+        observe(obj);
+        return obj;
+    };
+    Vue.options = Object.create(null);
+    ASSET_TYPES.forEach((type) => {
+        Vue.options[type + 's'] = Object.create(null);
+    });
+    // this is used to identify the "base" constructor to extend all plain-object
+    // components with in Weex's multi-instance scenarios.
+    Vue.options._base = Vue;
+    extend(Vue.options.components, builtInComponents);
+    initUse(Vue);
+    initMixin(Vue);
+    initExtend(Vue);
+    initAssetRegisters(Vue);
 }
 
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
+initGlobalAPI(Vue);
+Object.defineProperty(Vue.prototype, '$isServer', {
+    get: isServerRendering,
+});
+Object.defineProperty(Vue.prototype, '$ssrContext', {
+    get() {
+        /* istanbul ignore next */
+        return this.$vnode && this.$vnode.ssrContext;
+    },
+});
+// expose FunctionalRenderContext for ssr runtime helper installation
+Object.defineProperty(Vue, 'FunctionalRenderContext', {
+    value: FunctionalRenderContext,
+});
 Vue.version = '2.6.14';
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+const isReservedAttr = makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const xlinkNS = 'http://www.w3.org/1999/xlink';
+const isXlink = (name) => {
+    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+};
+const getXlinkProp = (name) => {
+    return isXlink(name) ? name.slice(6, name.length) : '';
+};
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
+const namespaceMap = {
+    svg: 'http://www.w3.org/2000/svg',
+    math: 'http://www.w3.org/1998/Math/MathML',
+};
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
+const unknownElementCache = Object.create(null);
+function isUnknownElement(tag) {
+    /* istanbul ignore if */
+    if (!inBrowser) {
+        return true;
+    }
+    if (isReservedTag(tag)) {
+        return false;
+    }
+    tag = tag.toLowerCase();
+    /* istanbul ignore if */
+    if (unknownElementCache[tag] != null) {
+        return unknownElementCache[tag];
+    }
+    const el = document.createElement(tag);
+    if (tag.indexOf('-') > -1) {
+        // http://stackoverflow.com/a/28210364/1070244
+        return (unknownElementCache[tag] =
+            el.constructor === window.HTMLUnknownElement ||
+                el.constructor === window.HTMLElement);
+    }
+    else {
+        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+    }
+}
 const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
+/**
+ * Query an element selector if it's not an element already.
+ */
+function query(el) {
+    if (typeof el === 'string') {
+        const selected = document.querySelector(el);
+        if (!selected) {
+            process.env.NODE_ENV !== 'production' &&
+                warn('Cannot find element: ' + el);
+            return document.createElement('div');
+        }
+        return selected;
+    }
+    else {
+        return el;
+    }
 }
 
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
+function createElement(tagName, vnode) {
+    const elm = document.createElement(tagName);
+    if (tagName !== 'select') {
+        return elm;
+    }
+    // false or null will remove the attribute but undefined will not
+    if (vnode.data &&
+        vnode.data.attrs &&
+        vnode.data.attrs.multiple !== undefined) {
+        elm.setAttribute('multiple', 'multiple');
+    }
+    return elm;
+}
+function createElementNS(namespace, tagName) {
+    return document.createElementNS(namespaceMap[namespace], tagName);
+}
+function createTextNode(text) {
+    return document.createTextNode(text);
+}
+function createComment(text) {
+    return document.createComment(text);
+}
+function insertBefore(parentNode, newNode, referenceNode) {
+    parentNode.insertBefore(newNode, referenceNode);
+}
+function removeChild(node, child) {
+    node.removeChild(child);
+}
+function appendChild(node, child) {
+    node.appendChild(child);
+}
+function parentNode(node) {
+    return node.parentNode;
+}
+function nextSibling(node) {
+    return node.nextSibling;
+}
+function tagName(node) {
+    return node.tagName;
+}
+function setTextContent(node, text) {
+    node.textContent = text;
+}
+function setStyleScope(node, scopeId) {
+    node.setAttribute(scopeId, '');
 }
 
 var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5034,2414 +5031,2413 @@ var nodeOps = /*#__PURE__*/Object.freeze({
   setStyleScope: setStyleScope
 });
 
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
+var ref = {
+    create(_, vnode) {
+        registerRef(vnode);
+    },
+    update(oldVnode, vnode) {
+        if (oldVnode.data.ref !== vnode.data.ref) {
+            registerRef(oldVnode, true);
+            registerRef(vnode);
+        }
+    },
+    destroy(vnode) {
+        registerRef(vnode, true);
+    },
+};
+function registerRef(vnode, isRemoval) {
+    const key = vnode.data.ref;
+    if (!isDef(key))
+        return;
+    const vm = vnode.context;
+    const ref = vnode.componentInstance || vnode.elm;
+    const refs = vm.$refs;
+    const obj = refs[key];
+    if (isRemoval) {
+        if (Array.isArray(obj)) {
+            remove$2(obj, ref);
+        }
+        else if (obj === ref) {
+            refs[key] = undefined;
+        }
+    }
+    else {
+        if (vnode.data.refInFor) {
+            if (!Array.isArray(obj)) {
+                refs[key] = [ref];
+            }
+            else if (obj.indexOf(ref) < 0) {
+                obj.push(ref);
+            }
+        }
+        else {
+            refs[key] = ref;
+        }
+    }
 }
 
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            if (process.env.NODE_ENV !== 'production') {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            if (process.env.NODE_ENV !== 'production') {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        if (process.env.NODE_ENV !== 'production') {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        if (process.env.NODE_ENV !== 'production') {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else if (process.env.NODE_ENV !== 'production') {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
+/**
+ * Virtual DOM patching algorithm based on Snabbdom by
+ * Simon Friis Vindum (@paldepind)
+ * Licensed under the MIT License
+ * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+ *
+ * modified by Evan You (@yyx990803)
+ *
+ * Not type-checking this because this file is perf-critical and the cost
+ * of making flow understand it is not worth it.
+ */
+const emptyNode = new VNode('', {}, []);
+const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+function sameVnode(a, b) {
+    return (a.key === b.key &&
+        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+        a.isComment === b.isComment &&
+        isDef(a.data) === isDef(b.data) &&
+        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+        isUndef(b.asyncFactory.error))));
+}
+function sameInputType(a, b) {
+    if (a.tag !== 'input')
+        return true;
+    let i;
+    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+}
+function createKeyToOldIdx(children, beginIdx, endIdx) {
+    let i, key;
+    const map = {};
+    for (i = beginIdx; i <= endIdx; ++i) {
+        key = children[i].key;
+        if (isDef(key))
+            map[key] = i;
+    }
+    return map;
+}
+function createPatchFunction(backend) {
+    let i, j;
+    const cbs = {};
+    const { modules, nodeOps } = backend;
+    for (i = 0; i < hooks.length; ++i) {
+        cbs[hooks[i]] = [];
+        for (j = 0; j < modules.length; ++j) {
+            if (isDef(modules[j][hooks[i]])) {
+                cbs[hooks[i]].push(modules[j][hooks[i]]);
+            }
+        }
+    }
+    function emptyNodeAt(elm) {
+        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+    }
+    function createRmCb(childElm, listeners) {
+        function remove() {
+            if (--remove.listeners === 0) {
+                removeNode(childElm);
+            }
+        }
+        remove.listeners = listeners;
+        return remove;
+    }
+    function removeNode(el) {
+        const parent = nodeOps.parentNode(el);
+        // element may have already been removed due to v-html / v-text
+        if (isDef(parent)) {
+            nodeOps.removeChild(parent, el);
+        }
+    }
+    function isUnknownElement(vnode, inVPre) {
+        return (!inVPre &&
+            !vnode.ns &&
+            !(config.ignoredElements.length &&
+                config.ignoredElements.some((ignore) => {
+                    return isRegExp(ignore)
+                        ? ignore.test(vnode.tag)
+                        : ignore === vnode.tag;
+                })) &&
+            config.isUnknownElement(vnode.tag));
+    }
+    let creatingElmInVPre = 0;
+    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // This vnode was used in a previous render!
+            // now it's used as a new node, overwriting its elm would cause
+            // potential patch errors down the road when it's used as an insertion
+            // reference node. Instead, we clone the node on-demand before creating
+            // associated DOM element for it.
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        vnode.isRootInsert = !nested; // for transition enter check
+        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+            return;
+        }
+        const data = vnode.data;
+        const children = vnode.children;
+        const tag = vnode.tag;
+        if (isDef(tag)) {
+            if (process.env.NODE_ENV !== 'production') {
+                if (data && data.pre) {
+                    creatingElmInVPre++;
+                }
+                if (isUnknownElement(vnode, creatingElmInVPre)) {
+                    warn('Unknown custom element: <' +
+                        tag +
+                        '> - did you ' +
+                        'register the component correctly? For recursive components, ' +
+                        'make sure to provide the "name" option.', vnode.context);
+                }
+            }
+            vnode.elm = vnode.ns
+                ? nodeOps.createElementNS(vnode.ns, tag)
+                : nodeOps.createElement(tag, vnode);
+            setScope(vnode);
+            /* istanbul ignore if */
+            {
+                createChildren(vnode, children, insertedVnodeQueue);
+                if (isDef(data)) {
+                    invokeCreateHooks(vnode, insertedVnodeQueue);
+                }
+                insert(parentElm, vnode.elm, refElm);
+            }
+            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+                creatingElmInVPre--;
+            }
+        }
+        else if (isTrue(vnode.isComment)) {
+            vnode.elm = nodeOps.createComment(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+        else {
+            vnode.elm = nodeOps.createTextNode(vnode.text);
+            insert(parentElm, vnode.elm, refElm);
+        }
+    }
+    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i = vnode.data;
+        if (isDef(i)) {
+            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+            if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                i(vnode, false /* hydrating */);
+            }
+            // after calling the init hook, if the vnode is a child component
+            // it should've created a child instance and mounted it. the child
+            // component also has set the placeholder vnode's elm.
+            // in that case we can just return the element and be done.
+            if (isDef(vnode.componentInstance)) {
+                initComponent(vnode, insertedVnodeQueue);
+                insert(parentElm, vnode.elm, refElm);
+                if (isTrue(isReactivated)) {
+                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                }
+                return true;
+            }
+        }
+    }
+    function initComponent(vnode, insertedVnodeQueue) {
+        if (isDef(vnode.data.pendingInsert)) {
+            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+            vnode.data.pendingInsert = null;
+        }
+        vnode.elm = vnode.componentInstance.$el;
+        if (isPatchable(vnode)) {
+            invokeCreateHooks(vnode, insertedVnodeQueue);
+            setScope(vnode);
+        }
+        else {
+            // empty component root.
+            // skip all element-related modules except for ref (#3455)
+            registerRef(vnode);
+            // make sure to invoke the insert hook
+            insertedVnodeQueue.push(vnode);
+        }
+    }
+    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+        let i;
+        // hack for #4339: a reactivated component with inner transition
+        // does not trigger because the inner node's created hooks are not called
+        // again. It's not ideal to involve module-specific logic in here but
+        // there doesn't seem to be a better way to do it.
+        let innerNode = vnode;
+        while (innerNode.componentInstance) {
+            innerNode = innerNode.componentInstance._vnode;
+            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                for (i = 0; i < cbs.activate.length; ++i) {
+                    cbs.activate[i](emptyNode, innerNode);
+                }
+                insertedVnodeQueue.push(innerNode);
+                break;
+            }
+        }
+        // unlike a newly created component,
+        // a reactivated keep-alive component doesn't insert itself
+        insert(parentElm, vnode.elm, refElm);
+    }
+    function insert(parent, elm, ref) {
+        if (isDef(parent)) {
+            if (isDef(ref)) {
+                if (nodeOps.parentNode(ref) === parent) {
+                    nodeOps.insertBefore(parent, elm, ref);
+                }
+            }
+            else {
+                nodeOps.appendChild(parent, elm);
+            }
+        }
+    }
+    function createChildren(vnode, children, insertedVnodeQueue) {
+        if (Array.isArray(children)) {
+            if (process.env.NODE_ENV !== 'production') {
+                checkDuplicateKeys(children);
+            }
+            for (let i = 0; i < children.length; ++i) {
+                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+            }
+        }
+        else if (isPrimitive(vnode.text)) {
+            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        }
+    }
+    function isPatchable(vnode) {
+        while (vnode.componentInstance) {
+            vnode = vnode.componentInstance._vnode;
+        }
+        return isDef(vnode.tag);
+    }
+    function invokeCreateHooks(vnode, insertedVnodeQueue) {
+        for (let i = 0; i < cbs.create.length; ++i) {
+            cbs.create[i](emptyNode, vnode);
+        }
+        i = vnode.data.hook; // Reuse variable
+        if (isDef(i)) {
+            if (isDef(i.create))
+                i.create(emptyNode, vnode);
+            if (isDef(i.insert))
+                insertedVnodeQueue.push(vnode);
+        }
+    }
+    // set scope id attribute for scoped CSS.
+    // this is implemented as a special case to avoid the overhead
+    // of going through the normal attribute patching process.
+    function setScope(vnode) {
+        let i;
+        if (isDef((i = vnode.fnScopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+        else {
+            let ancestor = vnode;
+            while (ancestor) {
+                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                    nodeOps.setStyleScope(vnode.elm, i);
+                }
+                ancestor = ancestor.parent;
+            }
+        }
+        // for slot content they should also get the scopeId from the host instance.
+        if (isDef((i = activeInstance)) &&
+            i !== vnode.context &&
+            i !== vnode.fnContext &&
+            isDef((i = i.$options._scopeId))) {
+            nodeOps.setStyleScope(vnode.elm, i);
+        }
+    }
+    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+        }
+    }
+    function invokeDestroyHook(vnode) {
+        let i, j;
+        const data = vnode.data;
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                i(vnode);
+            for (i = 0; i < cbs.destroy.length; ++i)
+                cbs.destroy[i](vnode);
+        }
+        if (isDef((i = vnode.children))) {
+            for (j = 0; j < vnode.children.length; ++j) {
+                invokeDestroyHook(vnode.children[j]);
+            }
+        }
+    }
+    function removeVnodes(vnodes, startIdx, endIdx) {
+        for (; startIdx <= endIdx; ++startIdx) {
+            const ch = vnodes[startIdx];
+            if (isDef(ch)) {
+                if (isDef(ch.tag)) {
+                    removeAndInvokeRemoveHook(ch);
+                    invokeDestroyHook(ch);
+                }
+                else {
+                    // Text node
+                    removeNode(ch.elm);
+                }
+            }
+        }
+    }
+    function removeAndInvokeRemoveHook(vnode, rm) {
+        if (isDef(rm) || isDef(vnode.data)) {
+            let i;
+            const listeners = cbs.remove.length + 1;
+            if (isDef(rm)) {
+                // we have a recursively passed down rm callback
+                // increase the listeners count
+                rm.listeners += listeners;
+            }
+            else {
+                // directly removing
+                rm = createRmCb(vnode.elm, listeners);
+            }
+            // recursively invoke hooks on child component root node
+            if (isDef((i = vnode.componentInstance)) &&
+                isDef((i = i._vnode)) &&
+                isDef(i.data)) {
+                removeAndInvokeRemoveHook(i, rm);
+            }
+            for (i = 0; i < cbs.remove.length; ++i) {
+                cbs.remove[i](vnode, rm);
+            }
+            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                i(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        }
+        else {
+            removeNode(vnode.elm);
+        }
+    }
+    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+        let oldStartIdx = 0;
+        let newStartIdx = 0;
+        let oldEndIdx = oldCh.length - 1;
+        let oldStartVnode = oldCh[0];
+        let oldEndVnode = oldCh[oldEndIdx];
+        let newEndIdx = newCh.length - 1;
+        let newStartVnode = newCh[0];
+        let newEndVnode = newCh[newEndIdx];
+        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+        // removeOnly is a special flag used only by <transition-group>
+        // to ensure removed elements stay in correct relative positions
+        // during leaving transitions
+        const canMove = !removeOnly;
+        if (process.env.NODE_ENV !== 'production') {
+            checkDuplicateKeys(newCh);
+        }
+        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+            if (isUndef(oldStartVnode)) {
+                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+            }
+            else if (isUndef(oldEndVnode)) {
+                oldEndVnode = oldCh[--oldEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newStartVnode)) {
+                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                oldStartVnode = oldCh[++oldStartIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else if (sameVnode(oldEndVnode, newEndVnode)) {
+                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldStartVnode, newEndVnode)) {
+                // Vnode moved right
+                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                oldStartVnode = oldCh[++oldStartIdx];
+                newEndVnode = newCh[--newEndIdx];
+            }
+            else if (sameVnode(oldEndVnode, newStartVnode)) {
+                // Vnode moved left
+                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                canMove &&
+                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                oldEndVnode = oldCh[--oldEndIdx];
+                newStartVnode = newCh[++newStartIdx];
+            }
+            else {
+                if (isUndef(oldKeyToIdx))
+                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                idxInOld = isDef(newStartVnode.key)
+                    ? oldKeyToIdx[newStartVnode.key]
+                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                if (isUndef(idxInOld)) {
+                    // New element
+                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                }
+                else {
+                    vnodeToMove = oldCh[idxInOld];
+                    if (sameVnode(vnodeToMove, newStartVnode)) {
+                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                        oldCh[idxInOld] = undefined;
+                        canMove &&
+                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                    }
+                    else {
+                        // same key but different element. treat as new element
+                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                    }
+                }
+                newStartVnode = newCh[++newStartIdx];
+            }
+        }
+        if (oldStartIdx > oldEndIdx) {
+            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+        }
+        else if (newStartIdx > newEndIdx) {
+            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+        }
+    }
+    function checkDuplicateKeys(children) {
+        const seenKeys = {};
+        for (let i = 0; i < children.length; i++) {
+            const vnode = children[i];
+            const key = vnode.key;
+            if (isDef(key)) {
+                if (seenKeys[key]) {
+                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                }
+                else {
+                    seenKeys[key] = true;
+                }
+            }
+        }
+    }
+    function findIdxInOld(node, oldCh, start, end) {
+        for (let i = start; i < end; i++) {
+            const c = oldCh[i];
+            if (isDef(c) && sameVnode(node, c))
+                return i;
+        }
+    }
+    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+        if (oldVnode === vnode) {
+            return;
+        }
+        if (isDef(vnode.elm) && isDef(ownerArray)) {
+            // clone reused vnode
+            vnode = ownerArray[index] = cloneVNode(vnode);
+        }
+        const elm = (vnode.elm = oldVnode.elm);
+        if (isTrue(oldVnode.isAsyncPlaceholder)) {
+            if (isDef(vnode.asyncFactory.resolved)) {
+                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+            }
+            else {
+                vnode.isAsyncPlaceholder = true;
+            }
+            return;
+        }
+        // reuse element for static trees.
+        // note we only do this if the vnode is cloned -
+        // if the new node is not cloned it means the render functions have been
+        // reset by the hot-reload-api and we need to do a proper re-render.
+        if (isTrue(vnode.isStatic) &&
+            isTrue(oldVnode.isStatic) &&
+            vnode.key === oldVnode.key &&
+            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+            vnode.componentInstance = oldVnode.componentInstance;
+            return;
+        }
+        let i;
+        const data = vnode.data;
+        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+            i(oldVnode, vnode);
+        }
+        const oldCh = oldVnode.children;
+        const ch = vnode.children;
+        if (isDef(data) && isPatchable(vnode)) {
+            for (i = 0; i < cbs.update.length; ++i)
+                cbs.update[i](oldVnode, vnode);
+            if (isDef((i = data.hook)) && isDef((i = i.update)))
+                i(oldVnode, vnode);
+        }
+        if (isUndef(vnode.text)) {
+            if (isDef(oldCh) && isDef(ch)) {
+                if (oldCh !== ch)
+                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+            }
+            else if (isDef(ch)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkDuplicateKeys(ch);
+                }
+                if (isDef(oldVnode.text))
+                    nodeOps.setTextContent(elm, '');
+                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+            }
+            else if (isDef(oldCh)) {
+                removeVnodes(oldCh, 0, oldCh.length - 1);
+            }
+            else if (isDef(oldVnode.text)) {
+                nodeOps.setTextContent(elm, '');
+            }
+        }
+        else if (oldVnode.text !== vnode.text) {
+            nodeOps.setTextContent(elm, vnode.text);
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                i(oldVnode, vnode);
+        }
+    }
+    function invokeInsertHook(vnode, queue, initial) {
+        // delay insert hooks for component root nodes, invoke them after the
+        // element is really inserted
+        if (isTrue(initial) && isDef(vnode.parent)) {
+            vnode.parent.data.pendingInsert = queue;
+        }
+        else {
+            for (let i = 0; i < queue.length; ++i) {
+                queue[i].data.hook.insert(queue[i]);
+            }
+        }
+    }
+    let hydrationBailed = false;
+    // list of modules that can skip create hook during hydration because they
+    // are already rendered on the client or has no need for initialization
+    // Note: style is excluded because it relies on initial clone for future
+    // deep updates (#7063).
+    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+    // Note: this is a browser-only function so we can assume elms are DOM nodes.
+    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+        let i;
+        const { tag, data, children } = vnode;
+        inVPre = inVPre || (data && data.pre);
+        vnode.elm = elm;
+        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+            vnode.isAsyncPlaceholder = true;
+            return true;
+        }
+        // assert node match
+        if (process.env.NODE_ENV !== 'production') {
+            if (!assertNodeMatch(elm, vnode, inVPre)) {
+                return false;
+            }
+        }
+        if (isDef(data)) {
+            if (isDef((i = data.hook)) && isDef((i = i.init)))
+                i(vnode, true /* hydrating */);
+            if (isDef((i = vnode.componentInstance))) {
+                // child component. it should have hydrated its own tree.
+                initComponent(vnode, insertedVnodeQueue);
+                return true;
+            }
+        }
+        if (isDef(tag)) {
+            if (isDef(children)) {
+                // empty element, allow client to pick up and populate children
+                if (!elm.hasChildNodes()) {
+                    createChildren(vnode, children, insertedVnodeQueue);
+                }
+                else {
+                    // v-html and domProps: innerHTML
+                    if (isDef((i = data)) &&
+                        isDef((i = i.domProps)) &&
+                        isDef((i = i.innerHTML))) {
+                        if (i !== elm.innerHTML) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('server innerHTML: ', i);
+                                console.warn('client innerHTML: ', elm.innerHTML);
+                            }
+                            return false;
+                        }
+                    }
+                    else {
+                        // iterate and compare children lists
+                        let childrenMatch = true;
+                        let childNode = elm.firstChild;
+                        for (let i = 0; i < children.length; i++) {
+                            if (!childNode ||
+                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                childrenMatch = false;
+                                break;
+                            }
+                            childNode = childNode.nextSibling;
+                        }
+                        // if childNode is not null, it means the actual childNodes list is
+                        // longer than the virtual children list.
+                        if (!childrenMatch || childNode) {
+                            /* istanbul ignore if */
+                            if (process.env.NODE_ENV !== 'production' &&
+                                typeof console !== 'undefined' &&
+                                !hydrationBailed) {
+                                hydrationBailed = true;
+                                console.warn('Parent: ', elm);
+                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                            }
+                            return false;
+                        }
+                    }
+                }
+            }
+            if (isDef(data)) {
+                let fullInvoke = false;
+                for (const key in data) {
+                    if (!isRenderedModule(key)) {
+                        fullInvoke = true;
+                        invokeCreateHooks(vnode, insertedVnodeQueue);
+                        break;
+                    }
+                }
+                if (!fullInvoke && data['class']) {
+                    // ensure collecting deps for deep class bindings for future updates
+                    traverse(data['class']);
+                }
+            }
+        }
+        else if (elm.data !== vnode.text) {
+            elm.data = vnode.text;
+        }
+        return true;
+    }
+    function assertNodeMatch(node, vnode, inVPre) {
+        if (isDef(vnode.tag)) {
+            return (vnode.tag.indexOf('vue-component') === 0 ||
+                (!isUnknownElement(vnode, inVPre) &&
+                    vnode.tag.toLowerCase() ===
+                        (node.tagName && node.tagName.toLowerCase())));
+        }
+        else {
+            return node.nodeType === (vnode.isComment ? 8 : 3);
+        }
+    }
+    return function patch(oldVnode, vnode, hydrating, removeOnly) {
+        if (isUndef(vnode)) {
+            if (isDef(oldVnode))
+                invokeDestroyHook(oldVnode);
+            return;
+        }
+        let isInitialPatch = false;
+        const insertedVnodeQueue = [];
+        if (isUndef(oldVnode)) {
+            // empty mount (likely as component), create new root element
+            isInitialPatch = true;
+            createElm(vnode, insertedVnodeQueue);
+        }
+        else {
+            const isRealElement = isDef(oldVnode.nodeType);
+            if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                // patch existing root node
+                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+            }
+            else {
+                if (isRealElement) {
+                    // mounting to a real element
+                    // check if this is server-rendered content and if we can perform
+                    // a successful hydration.
+                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                        oldVnode.removeAttribute(SSR_ATTR);
+                        hydrating = true;
+                    }
+                    if (isTrue(hydrating)) {
+                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                            invokeInsertHook(vnode, insertedVnodeQueue, true);
+                            return oldVnode;
+                        }
+                        else if (process.env.NODE_ENV !== 'production') {
+                            warn('The client-side rendered virtual DOM tree is not matching ' +
+                                'server-rendered content. This is likely caused by incorrect ' +
+                                'HTML markup, for example nesting block-level elements inside ' +
+                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                'full client-side render.');
+                        }
+                    }
+                    // either not server-rendered, or hydration failed.
+                    // create an empty node and replace it
+                    oldVnode = emptyNodeAt(oldVnode);
+                }
+                // replacing existing element
+                const oldElm = oldVnode.elm;
+                const parentElm = nodeOps.parentNode(oldElm);
+                // create new node
+                createElm(vnode, insertedVnodeQueue, 
+                // extremely rare edge case: do not insert if old element is in a
+                // leaving transition. Only happens when combining transition +
+                // keep-alive + HOCs. (#4590)
+                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                // update parent placeholder node element, recursively
+                if (isDef(vnode.parent)) {
+                    let ancestor = vnode.parent;
+                    const patchable = isPatchable(vnode);
+                    while (ancestor) {
+                        for (let i = 0; i < cbs.destroy.length; ++i) {
+                            cbs.destroy[i](ancestor);
+                        }
+                        ancestor.elm = vnode.elm;
+                        if (patchable) {
+                            for (let i = 0; i < cbs.create.length; ++i) {
+                                cbs.create[i](emptyNode, ancestor);
+                            }
+                            // #6513
+                            // invoke insert hooks that may have been merged by create hooks.
+                            // e.g. for directives that uses the "inserted" hook.
+                            const insert = ancestor.data.hook.insert;
+                            if (insert.merged) {
+                                // start at index 1 to avoid re-invoking component mounted hook
+                                for (let i = 1; i < insert.fns.length; i++) {
+                                    insert.fns[i]();
+                                }
+                            }
+                        }
+                        else {
+                            registerRef(ancestor);
+                        }
+                        ancestor = ancestor.parent;
+                    }
+                }
+                // destroy old node
+                if (isDef(parentElm)) {
+                    removeVnodes([oldVnode], 0, 0);
+                }
+                else if (isDef(oldVnode.tag)) {
+                    invokeDestroyHook(oldVnode);
+                }
+            }
+        }
+        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+        return vnode.elm;
+    };
 }
 
-var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            // @ts-expect-error should it be any?
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
+var directives = {
+    create: updateDirectives,
+    update: updateDirectives,
+    destroy: function unbindDirectives(vnode) {
+        // @ts-expect-error emptyNode is not VNodeWithData
+        updateDirectives(vnode, emptyNode);
+    },
+};
+function updateDirectives(oldVnode, vnode) {
+    if (oldVnode.data.directives || vnode.data.directives) {
+        _update(oldVnode, vnode);
+    }
+}
+function _update(oldVnode, vnode) {
+    const isCreate = oldVnode === emptyNode;
+    const isDestroy = vnode === emptyNode;
+    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+    const dirsWithInsert = [];
+    const dirsWithPostpatch = [];
+    let key, oldDir, dir;
+    for (key in newDirs) {
+        oldDir = oldDirs[key];
+        dir = newDirs[key];
+        if (!oldDir) {
+            // new directive, bind
+            callHook(dir, 'bind', vnode, oldVnode);
+            if (dir.def && dir.def.inserted) {
+                dirsWithInsert.push(dir);
+            }
+        }
+        else {
+            // existing directive, update
+            dir.oldValue = oldDir.value;
+            dir.oldArg = oldDir.arg;
+            callHook(dir, 'update', vnode, oldVnode);
+            if (dir.def && dir.def.componentUpdated) {
+                dirsWithPostpatch.push(dir);
+            }
+        }
+    }
+    if (dirsWithInsert.length) {
+        const callInsert = () => {
+            for (let i = 0; i < dirsWithInsert.length; i++) {
+                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+            }
+        };
+        if (isCreate) {
+            mergeVNodeHook(vnode, 'insert', callInsert);
+        }
+        else {
+            callInsert();
+        }
+    }
+    if (dirsWithPostpatch.length) {
+        mergeVNodeHook(vnode, 'postpatch', () => {
+            for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+            }
+        });
+    }
+    if (!isCreate) {
+        for (key in oldDirs) {
+            if (!newDirs[key]) {
+                // no longer present, unbind
+                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+            }
+        }
+    }
+}
+const emptyModifiers = Object.create(null);
+function normalizeDirectives(dirs, vm) {
+    const res = Object.create(null);
+    if (!dirs) {
+        // $flow-disable-line
+        return res;
+    }
+    let i, dir;
+    for (i = 0; i < dirs.length; i++) {
+        dir = dirs[i];
+        if (!dir.modifiers) {
+            // $flow-disable-line
+            dir.modifiers = emptyModifiers;
+        }
+        res[getRawDirName(dir)] = dir;
+        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+    }
+    // $flow-disable-line
+    return res;
+}
+function getRawDirName(dir) {
+    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+}
+function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+    const fn = dir.def && dir.def[hook];
+    if (fn) {
+        try {
+            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+        }
+        catch (e) {
+            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+        }
+    }
 }
 
 var baseModules = [ref, directives];
 
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
+function updateAttrs(oldVnode, vnode) {
+    const opts = vnode.componentOptions;
+    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+        return;
+    }
+    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+        return;
+    }
+    let key, cur, old;
+    const elm = vnode.elm;
+    const oldAttrs = oldVnode.data.attrs || {};
+    let attrs = vnode.data.attrs || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(attrs.__ob__)) {
+        attrs = vnode.data.attrs = extend({}, attrs);
+    }
+    for (key in attrs) {
+        cur = attrs[key];
+        old = oldAttrs[key];
+        if (old !== cur) {
+            setAttr(elm, key, cur, vnode.data.pre);
+        }
+    }
+    // #4391: in IE9, setting type can reset value for input[type=radio]
+    // #6666: IE/Edge forces progress value down to 1 before setting a max
+    /* istanbul ignore if */
+    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+        setAttr(elm, 'value', attrs.value);
+    }
+    for (key in oldAttrs) {
+        if (isUndef(attrs[key])) {
+            if (isXlink(key)) {
+                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+            }
+            else if (!isEnumeratedAttr(key)) {
+                elm.removeAttribute(key);
+            }
+        }
+    }
+}
+function setAttr(el, key, value, isInPre) {
+    if (isInPre || el.tagName.indexOf('-') > -1) {
+        baseSetAttr(el, key, value);
+    }
+    else if (isBooleanAttr(key)) {
+        // set attribute for blank value
+        // e.g. <option disabled>Select one</option>
+        if (isFalsyAttrValue(value)) {
+            el.removeAttribute(key);
+        }
+        else {
+            // technically allowfullscreen is a boolean attribute for <iframe>,
+            // but Flash expects a value of "true" when used on <embed> tag
+            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+            el.setAttribute(key, value);
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        el.setAttribute(key, convertEnumeratedValue(key, value));
+    }
+    else if (isXlink(key)) {
+        if (isFalsyAttrValue(value)) {
+            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+        }
+        else {
+            el.setAttributeNS(xlinkNS, key, value);
+        }
+    }
+    else {
+        baseSetAttr(el, key, value);
+    }
+}
+function baseSetAttr(el, key, value) {
+    if (isFalsyAttrValue(value)) {
+        el.removeAttribute(key);
+    }
+    else {
+        // #7138: IE10 & 11 fires input event when setting placeholder on
+        // <textarea>... block the first input event and remove the blocker
+        // immediately.
+        /* istanbul ignore if */
+        if (isIE &&
+            !isIE9 &&
+            el.tagName === 'TEXTAREA' &&
+            key === 'placeholder' &&
+            value !== '' &&
+            !el.__ieph) {
+            const blocker = (e) => {
+                e.stopImmediatePropagation();
+                el.removeEventListener('input', blocker);
+            };
+            el.addEventListener('input', blocker);
+            // $flow-disable-line
+            el.__ieph = true; /* IE placeholder patched */
+        }
+        el.setAttribute(key, value);
+    }
+}
+var attrs = {
+    create: updateAttrs,
+    update: updateAttrs,
 };
 
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass = {
-    create: updateClass,
-    update: updateClass,
+function updateClass(oldVnode, vnode) {
+    const el = vnode.elm;
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticClass) &&
+        isUndef(data.class) &&
+        (isUndef(oldData) ||
+            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+        return;
+    }
+    let cls = genClassForVnode(vnode);
+    // handle transition classes
+    const transitionClass = el._transitionClasses;
+    if (isDef(transitionClass)) {
+        cls = concat(cls, stringifyClass(transitionClass));
+    }
+    // set the class
+    if (cls !== el._prevClass) {
+        el.setAttribute('class', cls);
+        el._prevClass = cls;
+    }
+}
+var klass = {
+    create: updateClass,
+    update: updateClass,
 };
 
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
 const CHECKBOX_RADIO_TOKEN = '__c';
 
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+// normalize v-model event tokens that can only be determined at runtime.
+// it's important to place the event as the first in the array because
+// the whole point is ensuring the v-model callback gets called before
+// user-attached handlers.
+function normalizeEvents(on) {
+    /* istanbul ignore if */
+    if (isDef(on[RANGE_TOKEN])) {
+        // IE input[type=range] only supports `change` event
+        const event = isIE ? 'change' : 'input';
+        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+        delete on[RANGE_TOKEN];
+    }
+    // This was originally intended to fix #4521 but no longer necessary
+    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+    /* istanbul ignore if */
+    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+        delete on[CHECKBOX_RADIO_TOKEN];
+    }
+}
+let target;
+function createOnceHandler(event, handler, capture) {
+    const _target = target; // save current target element in closure
+    return function onceHandler() {
+        const res = handler.apply(null, arguments);
+        if (res !== null) {
+            remove(event, onceHandler, capture, _target);
+        }
+    };
+}
+// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+// implementation and does not fire microtasks in between event propagation, so
+// safe to exclude.
+const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+function add(name, handler, capture, passive) {
+    // async edge case #6566: inner click event triggers patch, event handler
+    // attached to outer element during patch, and triggered again. This
+    // happens because browsers fire microtask ticks between event propagation.
+    // the solution is simple: we save the timestamp when a handler is attached,
+    // and the handler would only fire if the event passed to it was fired
+    // AFTER it was attached.
+    if (useMicrotaskFix) {
+        const attachedTimestamp = currentFlushTimestamp;
+        const original = handler;
+        //@ts-expect-error 
+        handler = original._wrapper = function (e) {
+            if (
+            // no bubbling, should always fire.
+            // this is just a safety net in case event.timeStamp is unreliable in
+            // certain weird environments...
+            e.target === e.currentTarget ||
+                // event is fired after handler attachment
+                e.timeStamp >= attachedTimestamp ||
+                // bail for environments that have buggy event.timeStamp implementations
+                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                // #9681 QtWebEngine event.timeStamp is negative value
+                e.timeStamp <= 0 ||
+                // #9448 bail if event is fired in another document in a multi-page
+                // electron/nw.js app, since event.timeStamp will be using a different
+                // starting reference
+                e.target.ownerDocument !== document) {
+                return original.apply(this, arguments);
+            }
+        };
+    }
+    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+}
+function remove(name, handler, capture, _target) {
+    (_target || target).removeEventListener(name, 
+    //@ts-expect-error
+    handler._wrapper || handler, capture);
+}
+function updateDOMListeners(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+        return;
+    }
+    const on = vnode.data.on || {};
+    const oldOn = oldVnode.data.on || {};
+    // vnode is empty when removing all listeners,
+    // and use old vnode dom element
+    target = vnode.elm || oldVnode.elm;
+    normalizeEvents(on);
+    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+    target = undefined;
+}
+var events = {
+    create: updateDOMListeners,
+    update: updateDOMListeners,
+    // @ts-expect-error emptyNode has actually data
+    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
 };
 
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
+let svgContainer;
+function updateDOMProps(oldVnode, vnode) {
+    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+        return;
+    }
+    let key, cur;
+    const elm = vnode.elm;
+    const oldProps = oldVnode.data.domProps || {};
+    let props = vnode.data.domProps || {};
+    // clone observed objects, as the user probably wants to mutate it
+    if (isDef(props.__ob__)) {
+        props = vnode.data.domProps = extend({}, props);
+    }
+    for (key in oldProps) {
+        if (!(key in props)) {
+            elm[key] = '';
+        }
+    }
+    for (key in props) {
+        cur = props[key];
+        // ignore children if the node has textContent or innerHTML,
+        // as these will throw away existing DOM nodes and cause removal errors
+        // on subsequent patches (#3360)
+        if (key === 'textContent' || key === 'innerHTML') {
+            if (vnode.children)
+                vnode.children.length = 0;
+            if (cur === oldProps[key])
+                continue;
+            // #6601 work around Chrome version <= 55 bug where single textNode
+            // replaced by innerHTML/textContent retains its parentNode property
+            if (elm.childNodes.length === 1) {
+                elm.removeChild(elm.childNodes[0]);
+            }
+        }
+        if (key === 'value' && elm.tagName !== 'PROGRESS') {
+            // store value as _value as well since
+            // non-string values will be stringified
+            elm._value = cur;
+            // avoid resetting cursor position when value is the same
+            const strCur = isUndef(cur) ? '' : String(cur);
+            if (shouldUpdateValue(elm, strCur)) {
+                elm.value = strCur;
+            }
+        }
+        else if (key === 'innerHTML' &&
+            isSVG(elm.tagName) &&
+            isUndef(elm.innerHTML)) {
+            // IE doesn't support innerHTML for SVG elements
+            svgContainer = svgContainer || document.createElement('div');
+            svgContainer.innerHTML = `<svg>${cur}</svg>`;
+            const svg = svgContainer.firstChild;
+            while (elm.firstChild) {
+                elm.removeChild(elm.firstChild);
+            }
+            while (svg.firstChild) {
+                elm.appendChild(svg.firstChild);
+            }
+        }
+        else if (
+        // skip the update if old and new VDOM state is the same.
+        // `value` is handled separately because the DOM value may be temporarily
+        // out of sync with VDOM state due to focus, composition and modifiers.
+        // This  #4521 by skipping the unnecessary `checked` update.
+        cur !== oldProps[key]) {
+            // some property updates can throw
+            // e.g. `value` on <progress> w/ non-finite value
+            try {
+                elm[key] = cur;
+            }
+            catch (e) { }
+        }
+    }
+}
+function shouldUpdateValue(elm, checkVal) {
+    return (
+    //@ts-expect-error
+    !elm.composing &&
+        (elm.tagName === 'OPTION' ||
+            isNotInFocusAndDirty(elm, checkVal) ||
+            isDirtyWithModifiers(elm, checkVal)));
+}
+function isNotInFocusAndDirty(elm, checkVal) {
+    // return true when textbox (.number and .trim) loses focus and its value is
+    // not equal to the updated value
+    let notInFocus = true;
+    // #6157
+    // work around IE bug when accessing document.activeElement in an iframe
+    try {
+        notInFocus = document.activeElement !== elm;
+    }
+    catch (e) { }
+    return notInFocus && elm.value !== checkVal;
+}
+function isDirtyWithModifiers(elm, newVal) {
+    const value = elm.value;
+    const modifiers = elm._vModifiers; // injected by v-model runtime
+    if (isDef(modifiers)) {
+        if (modifiers.number) {
+            return toNumber(value) !== toNumber(newVal);
+        }
+        if (modifiers.trim) {
+            return value.trim() !== newVal.trim();
+        }
+    }
+    return value !== newVal;
+}
+var domProps = {
+    create: updateDOMProps,
+    update: updateDOMProps,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style = {
-    create: updateStyle,
-    update: updateStyle,
+const cssVarRE = /^--/;
+const importantRE = /\s*!important$/;
+const setProp = (el, name, val) => {
+    /* istanbul ignore if */
+    if (cssVarRE.test(name)) {
+        el.style.setProperty(name, val);
+    }
+    else if (importantRE.test(val)) {
+        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+    }
+    else {
+        const normalizedName = normalize(name);
+        if (Array.isArray(val)) {
+            // Support values array created by autoprefixer, e.g.
+            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+            // Set them one by one, and the browser will only set those it can recognize
+            for (let i = 0, len = val.length; i < len; i++) {
+                el.style[normalizedName] = val[i];
+            }
+        }
+        else {
+            el.style[normalizedName] = val;
+        }
+    }
+};
+const vendorNames = ['Webkit', 'Moz', 'ms'];
+let emptyStyle;
+const normalize = cached(function (prop) {
+    emptyStyle = emptyStyle || document.createElement('div').style;
+    prop = camelize(prop);
+    if (prop !== 'filter' && prop in emptyStyle) {
+        return prop;
+    }
+    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+    for (let i = 0; i < vendorNames.length; i++) {
+        const name = vendorNames[i] + capName;
+        if (name in emptyStyle) {
+            return name;
+        }
+    }
+});
+function updateStyle(oldVnode, vnode) {
+    const data = vnode.data;
+    const oldData = oldVnode.data;
+    if (isUndef(data.staticStyle) &&
+        isUndef(data.style) &&
+        isUndef(oldData.staticStyle) &&
+        isUndef(oldData.style)) {
+        return;
+    }
+    let cur, name;
+    const el = vnode.elm;
+    const oldStaticStyle = oldData.staticStyle;
+    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+    const oldStyle = oldStaticStyle || oldStyleBinding;
+    const style = normalizeStyleBinding(vnode.data.style) || {};
+    // store normalized style under a different key for next diff
+    // make sure to clone it if it's reactive, since the user likely wants
+    // to mutate it.
+    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+    const newStyle = getStyle(vnode, true);
+    for (name in oldStyle) {
+        if (isUndef(newStyle[name])) {
+            setProp(el, name, '');
+        }
+    }
+    for (name in newStyle) {
+        cur = newStyle[name];
+        if (cur !== oldStyle[name]) {
+            // ie9 setting to null has no effect, must use empty string
+            setProp(el, name, cur == null ? '' : cur);
+        }
+    }
+}
+var style = {
+    create: updateStyle,
+    update: updateStyle,
 };
 
-const whitespaceRE = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
+const whitespaceRE = /\s+/;
+/**
+ * Add class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function addClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
+        }
+        else {
+            el.classList.add(cls);
+        }
+    }
+    else {
+        const cur = ` ${el.getAttribute('class') || ''} `;
+        if (cur.indexOf(' ' + cls + ' ') < 0) {
+            el.setAttribute('class', (cur + cls).trim());
+        }
+    }
+}
+/**
+ * Remove class with compatibility for SVG since classList is not supported on
+ * SVG elements in IE
+ */
+function removeClass(el, cls) {
+    /* istanbul ignore if */
+    if (!cls || !(cls = cls.trim())) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (el.classList) {
+        if (cls.indexOf(' ') > -1) {
+            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
+        }
+        else {
+            el.classList.remove(cls);
+        }
+        if (!el.classList.length) {
+            el.removeAttribute('class');
+        }
+    }
+    else {
+        let cur = ` ${el.getAttribute('class') || ''} `;
+        const tar = ' ' + cls + ' ';
+        while (cur.indexOf(tar) >= 0) {
+            cur = cur.replace(tar, ' ');
+        }
+        cur = cur.trim();
+        if (cur) {
+            el.setAttribute('class', cur);
+        }
+        else {
+            el.removeAttribute('class');
+        }
+    }
 }
 
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+function resolveTransition(def) {
+    if (!def) {
+        return;
+    }
+    /* istanbul ignore else */
+    if (typeof def === 'object') {
+        const res = {};
+        if (def.css !== false) {
+            extend(res, autoCssTransition(def.name || 'v'));
+        }
+        extend(res, def);
+        return res;
+    }
+    else if (typeof def === 'string') {
+        return autoCssTransition(def);
+    }
+}
+const autoCssTransition = cached((name) => {
+    return {
+        enterClass: `${name}-enter`,
+        enterToClass: `${name}-enter-to`,
+        enterActiveClass: `${name}-enter-active`,
+        leaveClass: `${name}-leave`,
+        leaveToClass: `${name}-leave-to`,
+        leaveActiveClass: `${name}-leave-active`,
+    };
+});
+const hasTransition = inBrowser && !isIE9;
+const TRANSITION = 'transition';
+const ANIMATION = 'animation';
+// Transition property/event sniffing
+let transitionProp = 'transition';
+let transitionEndEvent = 'transitionend';
+let animationProp = 'animation';
+let animationEndEvent = 'animationend';
+if (hasTransition) {
+    /* istanbul ignore if */
+    if (window.ontransitionend === undefined &&
+        window.onwebkittransitionend !== undefined) {
+        transitionProp = 'WebkitTransition';
+        transitionEndEvent = 'webkitTransitionEnd';
+    }
+    if (window.onanimationend === undefined &&
+        window.onwebkitanimationend !== undefined) {
+        animationProp = 'WebkitAnimation';
+        animationEndEvent = 'webkitAnimationEnd';
+    }
+}
+// binding to window is necessary to make hot reload work in IE in strict mode
+const raf = inBrowser
+    ? window.requestAnimationFrame
+        ? window.requestAnimationFrame.bind(window)
+        : setTimeout
+    : /* istanbul ignore next */ (fn) => fn();
+function nextFrame(fn) {
+    raf(() => {
+        // @ts-expect-error
+        raf(fn);
+    });
+}
+function addTransitionClass(el, cls) {
+    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+    if (transitionClasses.indexOf(cls) < 0) {
+        transitionClasses.push(cls);
+        addClass(el, cls);
+    }
+}
+function removeTransitionClass(el, cls) {
+    if (el._transitionClasses) {
+        remove$2(el._transitionClasses, cls);
+    }
+    removeClass(el, cls);
+}
+function whenTransitionEnds(el, expectedType, cb) {
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type)
+        return cb();
+    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+    let ended = 0;
+    const end = () => {
+        el.removeEventListener(event, onEnd);
+        cb();
+    };
+    const onEnd = (e) => {
+        if (e.target === el) {
+            if (++ended >= propCount) {
+                end();
+            }
+        }
+    };
+    setTimeout(() => {
+        if (ended < propCount) {
+            end();
+        }
+    }, timeout + 1);
+    el.addEventListener(event, onEnd);
+}
+const transformRE = /\b(transform|all)(,|$)/;
+function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    // JSDOM may return undefined for transition properties
+    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type;
+    let timeout = 0;
+    let propCount = 0;
+    /* istanbul ignore if */
+    if (expectedType === TRANSITION) {
+        if (transitionTimeout > 0) {
+            type = TRANSITION;
+            timeout = transitionTimeout;
+            propCount = transitionDurations.length;
+        }
+    }
+    else if (expectedType === ANIMATION) {
+        if (animationTimeout > 0) {
+            type = ANIMATION;
+            timeout = animationTimeout;
+            propCount = animationDurations.length;
+        }
+    }
+    else {
+        timeout = Math.max(transitionTimeout, animationTimeout);
+        type =
+            timeout > 0
+                ? transitionTimeout > animationTimeout
+                    ? TRANSITION
+                    : ANIMATION
+                : null;
+        propCount = type
+            ? type === TRANSITION
+                ? transitionDurations.length
+                : animationDurations.length
+            : 0;
+    }
+    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+    return {
+        type,
+        timeout,
+        propCount,
+        hasTransform,
+    };
+}
+function getTimeout(delays, durations) {
+    /* istanbul ignore next */
+    while (delays.length < durations.length) {
+        delays = delays.concat(delays);
+    }
+    return Math.max.apply(null, durations.map((d, i) => {
+        return toMs(d) + toMs(delays[i]);
+    }));
+}
+// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+// in a locale-dependent way, using a comma instead of a dot.
+// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+// as a floor function) causing unexpected behaviors
+function toMs(s) {
+    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
 }
 
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
+function enter(vnode, toggleDisplay) {
+    const el = vnode.elm;
+    // call leave callback now
+    if (isDef(el._leaveCb)) {
+        el._leaveCb.cancelled = true;
+        el._leaveCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data)) {
+        return;
+    }
+    /* istanbul ignore if */
+    if (isDef(el._enterCb) || el.nodeType !== 1) {
+        return;
+    }
+    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+    // activeInstance will always be the <transition> component managing this
+    // transition. One edge case to check is when the <transition> is placed
+    // as the root node of a child component. In that case we need to check
+    // <transition>'s parent for appear check.
+    let context = activeInstance;
+    let transitionNode = activeInstance.$vnode;
+    while (transitionNode && transitionNode.parent) {
+        context = transitionNode.context;
+        transitionNode = transitionNode.parent;
+    }
+    const isAppear = !context._isMounted || !vnode.isRootInsert;
+    if (isAppear && !appear && appear !== '') {
+        return;
+    }
+    const startClass = isAppear && appearClass ? appearClass : enterClass;
+    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+    const enterHook = isAppear
+        ? typeof appear === 'function'
+            ? appear
+            : enter
+        : enter;
+    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+    const enterCancelledHook = isAppear
+        ? appearCancelled || enterCancelled
+        : enterCancelled;
+    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+        checkDuration(explicitEnterDuration, 'enter', vnode);
+    }
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(enterHook);
+    const cb = (el._enterCb = once(() => {
+        if (expectsCSS) {
+            removeTransitionClass(el, toClass);
+            removeTransitionClass(el, activeClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, startClass);
+            }
+            enterCancelledHook && enterCancelledHook(el);
+        }
+        else {
+            afterEnterHook && afterEnterHook(el);
+        }
+        el._enterCb = null;
+    }));
+    if (!vnode.data.show) {
+        // remove pending leave element on enter by injecting an insert hook
+        mergeVNodeHook(vnode, 'insert', () => {
+            const parent = el.parentNode;
+            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+            if (pendingNode &&
+                pendingNode.tag === vnode.tag &&
+                pendingNode.elm._leaveCb) {
+                pendingNode.elm._leaveCb();
+            }
+            enterHook && enterHook(el, cb);
+        });
+    }
+    // start enter transition
+    beforeEnterHook && beforeEnterHook(el);
+    if (expectsCSS) {
+        addTransitionClass(el, startClass);
+        addTransitionClass(el, activeClass);
+        nextFrame(() => {
+            removeTransitionClass(el, startClass);
+            // @ts-expect-error
+            if (!cb.cancelled) {
+                addTransitionClass(el, toClass);
+                if (!userWantsControl) {
+                    if (isValidDuration(explicitEnterDuration)) {
+                        setTimeout(cb, explicitEnterDuration);
+                    }
+                    else {
+                        whenTransitionEnds(el, type, cb);
+                    }
+                }
+            }
+        });
+    }
+    if (vnode.data.show) {
+        toggleDisplay && toggleDisplay();
+        enterHook && enterHook(el, cb);
+    }
+    if (!expectsCSS && !userWantsControl) {
+        cb();
+    }
+}
+function leave(vnode, rm) {
+    const el = vnode.elm;
+    // call enter callback now
+    if (isDef(el._enterCb)) {
+        el._enterCb.cancelled = true;
+        el._enterCb();
+    }
+    const data = resolveTransition(vnode.data.transition);
+    if (isUndef(data) || el.nodeType !== 1) {
+        return rm();
+    }
+    /* istanbul ignore if */
+    if (isDef(el._leaveCb)) {
+        return;
+    }
+    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+    const expectsCSS = css !== false && !isIE9;
+    const userWantsControl = getHookArgumentsLength(leave);
+    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+        checkDuration(explicitLeaveDuration, 'leave', vnode);
+    }
+    const cb = (el._leaveCb = once(() => {
+        if (el.parentNode && el.parentNode._pending) {
+            el.parentNode._pending[vnode.key] = null;
+        }
+        if (expectsCSS) {
+            removeTransitionClass(el, leaveToClass);
+            removeTransitionClass(el, leaveActiveClass);
+        }
+        // @ts-expect-error
+        if (cb.cancelled) {
+            if (expectsCSS) {
+                removeTransitionClass(el, leaveClass);
+            }
+            leaveCancelled && leaveCancelled(el);
+        }
+        else {
+            rm();
+            afterLeave && afterLeave(el);
+        }
+        el._leaveCb = null;
+    }));
+    if (delayLeave) {
+        delayLeave(performLeave);
+    }
+    else {
+        performLeave();
+    }
+    function performLeave() {
+        // the delayed leave may have already been cancelled
+        // @ts-expect-error
+        if (cb.cancelled) {
+            return;
+        }
+        // record leaving element
+        if (!vnode.data.show && el.parentNode) {
+            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+        }
+        beforeLeave && beforeLeave(el);
+        if (expectsCSS) {
+            addTransitionClass(el, leaveClass);
+            addTransitionClass(el, leaveActiveClass);
+            nextFrame(() => {
+                removeTransitionClass(el, leaveClass);
+                // @ts-expect-error
+                if (!cb.cancelled) {
+                    addTransitionClass(el, leaveToClass);
+                    if (!userWantsControl) {
+                        if (isValidDuration(explicitLeaveDuration)) {
+                            setTimeout(cb, explicitLeaveDuration);
+                        }
+                        else {
+                            whenTransitionEnds(el, type, cb);
+                        }
+                    }
+                }
+            });
+        }
+        leave && leave(el, cb);
+        if (!expectsCSS && !userWantsControl) {
+            cb();
+        }
+    }
+}
+// only used in dev mode
+function checkDuration(val, name, vnode) {
+    if (typeof val !== 'number') {
+        warn(`<transition> explicit ${name} duration is not a valid number - ` +
+            `got ${JSON.stringify(val)}.`, vnode.context);
+    }
+    else if (isNaN(val)) {
+        warn(`<transition> explicit ${name} duration is NaN - ` +
+            'the duration expression might be incorrect.', vnode.context);
+    }
+}
+function isValidDuration(val) {
+    return typeof val === 'number' && !isNaN(val);
+}
+/**
+ * Normalize a transition hook's argument length. The hook may be:
+ * - a merged hook (invoker) with the original in .fns
+ * - a wrapped component method (check ._length)
+ * - a plain function (.length)
+ */
+function getHookArgumentsLength(fn) {
+    if (isUndef(fn)) {
+        return false;
+    }
+    // @ts-expect-error
+    const invokerFns = fn.fns;
+    if (isDef(invokerFns)) {
+        // invoker
+        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+    }
+    else {
+        // @ts-expect-error
+        return (fn._length || fn.length) > 1;
+    }
+}
+function _enter(_, vnode) {
+    if (vnode.data.show !== true) {
+        enter(vnode);
+    }
+}
+var transition = inBrowser
+    ? {
+        create: _enter,
+        activate: _enter,
+        remove(vnode, rm) {
+            /* istanbul ignore else */
+            if (vnode.data.show !== true) {
+                // @ts-expect-error
+                leave(vnode, rm);
+            }
+            else {
+                rm();
+            }
+        },
+    }
     : {};
 
 var platformModules = [attrs, klass, events, domProps, style, transition];
 
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules);
+// the directive module should be applied last, after all
+// built-in modules have been applied.
+const modules = platformModules.concat(baseModules);
 const patch = createPatchFunction({ nodeOps, modules });
 
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+/**
+ * Not type checking this file because flow doesn't like attaching
+ * properties to Elements.
+ */
+/* istanbul ignore if */
+if (isIE9) {
+    // http://www.matts411.com/post/internet-explorer-9-oninput/
+    document.addEventListener('selectionchange', () => {
+        const el = document.activeElement;
+        // @ts-expect-error
+        if (el && el.vmodel) {
+            trigger(el, 'input');
+        }
+    });
+}
+const directive = {
+    inserted(el, binding, vnode, oldVnode) {
+        if (vnode.tag === 'select') {
+            // #6903
+            if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                mergeVNodeHook(vnode, 'postpatch', () => {
+                    directive.componentUpdated(el, binding, vnode);
+                });
+            }
+            else {
+                setSelected(el, binding, vnode.context);
+            }
+            el._vOptions = [].map.call(el.options, getValue);
+        }
+        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+            el._vModifiers = binding.modifiers;
+            if (!binding.modifiers.lazy) {
+                el.addEventListener('compositionstart', onCompositionStart);
+                el.addEventListener('compositionend', onCompositionEnd);
+                // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                // switching focus before confirming composition choice
+                // this also fixes the issue where some browsers e.g. iOS Chrome
+                // fires "change" instead of "input" on autocomplete.
+                el.addEventListener('change', onCompositionEnd);
+                /* istanbul ignore if */
+                if (isIE9) {
+                    el.vmodel = true;
+                }
+            }
+        }
+    },
+    componentUpdated(el, binding, vnode) {
+        if (vnode.tag === 'select') {
+            setSelected(el, binding, vnode.context);
+            // in case the options rendered by v-for have changed,
+            // it's possible that the value is out-of-sync with the rendered options.
+            // detect such cases and filter out values that no longer has a matching
+            // option in the DOM.
+            const prevOptions = el._vOptions;
+            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                // trigger change event if
+                // no matching option found for at least one value
+                const needReset = el.multiple
+                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                    : binding.value !== binding.oldValue &&
+                        hasNoMatchingOption(binding.value, curOptions);
+                if (needReset) {
+                    trigger(el, 'change');
+                }
+            }
+        }
+    },
+};
+function setSelected(el, binding, vm) {
+    actuallySetSelected(el, binding, vm);
+    /* istanbul ignore if */
+    if (isIE || isEdge) {
+        setTimeout(() => {
+            actuallySetSelected(el, binding, vm);
+        }, 0);
+    }
+}
+function actuallySetSelected(el, binding, vm) {
+    const value = binding.value;
+    const isMultiple = el.multiple;
+    if (isMultiple && !Array.isArray(value)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn(`<select multiple v-model="${binding.expression}"> ` +
+                `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+        return;
+    }
+    let selected, option;
+    for (let i = 0, l = el.options.length; i < l; i++) {
+        option = el.options[i];
+        if (isMultiple) {
+            selected = looseIndexOf(value, getValue(option)) > -1;
+            if (option.selected !== selected) {
+                option.selected = selected;
+            }
+        }
+        else {
+            if (looseEqual(getValue(option), value)) {
+                if (el.selectedIndex !== i) {
+                    el.selectedIndex = i;
+                }
+                return;
+            }
+        }
+    }
+    if (!isMultiple) {
+        el.selectedIndex = -1;
+    }
+}
+function hasNoMatchingOption(value, options) {
+    return options.every((o) => !looseEqual(o, value));
+}
+function getValue(option) {
+    return '_value' in option ? option._value : option.value;
+}
+function onCompositionStart(e) {
+    e.target.composing = true;
+}
+function onCompositionEnd(e) {
+    // prevent triggering an input event for no reason
+    if (!e.target.composing)
+        return;
+    e.target.composing = false;
+    trigger(e.target, 'input');
+}
+function trigger(el, type) {
+    const e = document.createEvent('HTMLEvents');
+    e.initEvent(type, true, true);
+    el.dispatchEvent(e);
 }
 
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
+// recursively search for possible transition defined inside the component root
+function locateNode(vnode) {
+    // @ts-expect-error
+    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+        ? locateNode(vnode.componentInstance._vnode)
+        : vnode;
+}
+var show = {
+    bind(el, { value }, vnode) {
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        const originalDisplay = (el.__vOriginalDisplay =
+            el.style.display === 'none' ? '' : el.style.display);
+        if (value && transition) {
+            vnode.data.show = true;
+            enter(vnode, () => {
+                el.style.display = originalDisplay;
+            });
+        }
+        else {
+            el.style.display = value ? originalDisplay : 'none';
+        }
+    },
+    update(el, { value, oldValue }, vnode) {
+        /* istanbul ignore if */
+        if (!value === !oldValue)
+            return;
+        vnode = locateNode(vnode);
+        const transition = vnode.data && vnode.data.transition;
+        if (transition) {
+            vnode.data.show = true;
+            if (value) {
+                enter(vnode, () => {
+                    el.style.display = el.__vOriginalDisplay;
+                });
+            }
+            else {
+                leave(vnode, () => {
+                    el.style.display = 'none';
+                });
+            }
+        }
+        else {
+            el.style.display = value ? el.__vOriginalDisplay : 'none';
+        }
+    },
+    unbind(el, binding, vnode, oldVnode, isDestroy) {
+        if (!isDestroy) {
+            el.style.display = el.__vOriginalDisplay;
+        }
+    },
 };
 
-var platformDirectives = {
-    model: directive,
-    show,
+var platformDirectives = {
+    model: directive,
+    show,
 };
 
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (process.env.NODE_ENV !== 'production' &&
-            mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
+// Provides transition support for a single element/component.
+const transitionProps = {
+    name: String,
+    appear: Boolean,
+    css: Boolean,
+    mode: String,
+    type: String,
+    enterClass: String,
+    leaveClass: String,
+    enterToClass: String,
+    leaveToClass: String,
+    enterActiveClass: String,
+    leaveActiveClass: String,
+    appearClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    duration: [Number, String, Object],
+};
+// in case the child is also an abstract component, e.g. <keep-alive>
+// we want to recursively retrieve the real component to be rendered
+function getRealChild(vnode) {
+    const compOptions = vnode && vnode.componentOptions;
+    if (compOptions && compOptions.Ctor.options.abstract) {
+        return getRealChild(getFirstComponentChild(compOptions.children));
+    }
+    else {
+        return vnode;
+    }
+}
+function extractTransitionData(comp) {
+    const data = {};
+    const options = comp.$options;
+    // props
+    for (const key in options.propsData) {
+        data[key] = comp[key];
+    }
+    // events.
+    // extract listeners and pass them directly to the transition methods
+    const listeners = options._parentListeners;
+    for (const key in listeners) {
+        data[camelize(key)] = listeners[key];
+    }
+    return data;
+}
+function placeholder(h, rawChild) {
+    // @ts-expect-error
+    if (/\d-keep-alive$/.test(rawChild.tag)) {
+        return h('keep-alive', {
+            props: rawChild.componentOptions.propsData,
+        });
+    }
+}
+function hasParentTransition(vnode) {
+    while ((vnode = vnode.parent)) {
+        if (vnode.data.transition) {
+            return true;
+        }
+    }
+}
+function isSameChild(child, oldChild) {
+    return oldChild.key === child.key && oldChild.tag === child.tag;
+}
+const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+const isVShowDirective = (d) => d.name === 'show';
+var Transition = {
+    name: 'transition',
+    props: transitionProps,
+    abstract: true,
+    render(h) {
+        let children = this.$slots.default;
+        if (!children) {
+            return;
+        }
+        // filter out text nodes (possible whitespaces)
+        children = children.filter(isNotTextNode);
+        /* istanbul ignore if */
+        if (!children.length) {
+            return;
+        }
+        // warn multiple elements
+        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+            warn('<transition> can only be used on a single element. Use ' +
+                '<transition-group> for lists.', this.$parent);
+        }
+        const mode = this.mode;
+        // warn invalid mode
+        if (process.env.NODE_ENV !== 'production' &&
+            mode &&
+            mode !== 'in-out' &&
+            mode !== 'out-in') {
+            warn('invalid <transition> mode: ' + mode, this.$parent);
+        }
+        const rawChild = children[0];
+        // if this is a component root node and the component's
+        // parent container node also has transition, skip.
+        if (hasParentTransition(this.$vnode)) {
+            return rawChild;
+        }
+        // apply transition data to child
+        // use getRealChild() to ignore abstract components e.g. keep-alive
+        const child = getRealChild(rawChild);
+        /* istanbul ignore if */
+        if (!child) {
+            return rawChild;
+        }
+        if (this._leaving) {
+            return placeholder(h, rawChild);
+        }
+        // ensure a key that is unique to the vnode type and to this transition
+        // component instance. This key will be used to remove pending leaving nodes
+        // during entering.
+        const id = `__transition-${this._uid}-`;
+        child.key =
+            child.key == null
+                ? child.isComment
+                    ? id + 'comment'
+                    : id + child.tag
+                : isPrimitive(child.key)
+                    ? String(child.key).indexOf(id) === 0
+                        ? child.key
+                        : id + child.key
+                    : child.key;
+        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+        const oldRawChild = this._vnode;
+        const oldChild = getRealChild(oldRawChild);
+        // mark v-show
+        // so that the transition module can hand over the control to the directive
+        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+            child.data.show = true;
+        }
+        if (oldChild &&
+            oldChild.data &&
+            !isSameChild(child, oldChild) &&
+            !isAsyncPlaceholder(oldChild) &&
+            // #6687 component root is a comment node
+            !(oldChild.componentInstance &&
+                oldChild.componentInstance._vnode.isComment)) {
+            // replace old child transition data with fresh one
+            // important for dynamic transitions!
+            const oldData = (oldChild.data.transition = extend({}, data));
+            // handle transition mode
+            if (mode === 'out-in') {
+                // return placeholder node and queue update when leave finishes
+                this._leaving = true;
+                mergeVNodeHook(oldData, 'afterLeave', () => {
+                    this._leaving = false;
+                    this.$forceUpdate();
+                });
+                return placeholder(h, rawChild);
+            }
+            else if (mode === 'in-out') {
+                if (isAsyncPlaceholder(child)) {
+                    return oldRawChild;
+                }
+                let delayedLeave;
+                const performLeave = () => {
+                    delayedLeave();
+                };
+                mergeVNodeHook(data, 'afterEnter', performLeave);
+                mergeVNodeHook(data, 'enterCancelled', performLeave);
+                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                    delayedLeave = leave;
+                });
+            }
+        }
+        return rawChild;
+    },
 };
 
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else if (process.env.NODE_ENV !== "production") {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
+// Provides transition support for list items.
+const props = extend({
+    tag: String,
+    moveClass: String,
+}, transitionProps);
+delete props.mode;
+var TransitionGroup = {
+    props,
+    beforeMount() {
+        const update = this._update;
+        this._update = (vnode, hydrating) => {
+            const restoreActiveInstance = setActiveInstance(this);
+            // force removing pass
+            this.__patch__(this._vnode, this.kept, false, // hydrating
+            true // removeOnly (!important, avoids unnecessary moves)
+            );
+            this._vnode = this.kept;
+            restoreActiveInstance();
+            update.call(this, vnode, hydrating);
+        };
+    },
+    render(h) {
+        const tag = this.tag || this.$vnode.data.tag || "span";
+        const map = Object.create(null);
+        const prevChildren = (this.prevChildren = this.children);
+        const rawChildren = this.$slots.default || [];
+        const children = (this.children = []);
+        const transitionData = extractTransitionData(this);
+        for (let i = 0; i < rawChildren.length; i++) {
+            const c = rawChildren[i];
+            if (c.tag) {
+                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                    children.push(c);
+                    map[c.key] = c;
+                    (c.data || (c.data = {})).transition = transitionData;
+                }
+                else if (process.env.NODE_ENV !== "production") {
+                    const opts = c.componentOptions;
+                    const name = opts
+                        ? opts.Ctor.options.name || opts.tag || ""
+                        : c.tag;
+                    warn(`<transition-group> children must be keyed: <${name}>`);
+                }
+            }
+        }
+        if (prevChildren) {
+            const kept = [];
+            const removed = [];
+            for (let i = 0; i < prevChildren.length; i++) {
+                const c = prevChildren[i];
+                c.data.transition = transitionData;
+                // @ts-expect-error .getBoundingClientRect is not typed in Node
+                c.data.pos = c.elm.getBoundingClientRect();
+                if (map[c.key]) {
+                    kept.push(c);
+                }
+                else {
+                    removed.push(c);
+                }
+            }
+            this.kept = h(tag, null, kept);
+            this.removed = removed;
+        }
+        return h(tag, null, children);
+    },
+    updated() {
+        const children = this.prevChildren;
+        const moveClass = this.moveClass || (this.name || "v") + "-move";
+        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+            return;
+        }
+        // we divide the work into three loops to avoid mixing DOM reads and writes
+        // in each iteration - which helps prevent layout thrashing.
+        children.forEach(callPendingCbs);
+        children.forEach(recordPosition);
+        children.forEach(applyTranslation);
+        // force reflow to put everything in position
+        // assign to this to avoid being removed in tree-shaking
+        // $flow-disable-line
+        this._reflow = document.body.offsetHeight;
+        children.forEach((c) => {
+            if (c.data.moved) {
+                const el = c.elm;
+                const s = el.style;
+                addTransitionClass(el, moveClass);
+                s.transform = s.WebkitTransform = s.transitionDuration = "";
+                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                    if (e && e.target !== el) {
+                        return;
+                    }
+                    if (!e || /transform$/.test(e.propertyName)) {
+                        el.removeEventListener(transitionEndEvent, cb);
+                        el._moveCb = null;
+                        removeTransitionClass(el, moveClass);
+                    }
+                }));
+            }
+        });
+    },
+    methods: {
+        hasMove(el, moveClass) {
+            /* istanbul ignore if */
+            if (!hasTransition) {
+                return false;
+            }
+            /* istanbul ignore if */
+            if (this._hasMove) {
+                return this._hasMove;
+            }
+            // Detect whether an element with the move class applied has
+            // CSS transitions. Since the element may be inside an entering
+            // transition at this very moment, we make a clone of it and remove
+            // all other transition classes applied to ensure only the move class
+            // is applied.
+            const clone = el.cloneNode();
+            if (el._transitionClasses) {
+                el._transitionClasses.forEach((cls) => {
+                    removeClass(clone, cls);
+                });
+            }
+            addClass(clone, moveClass);
+            clone.style.display = "none";
+            this.$el.appendChild(clone);
+            const info = getTransitionInfo(clone);
+            this.$el.removeChild(clone);
+            return (this._hasMove = info.hasTransform);
+        },
+    },
+};
+function callPendingCbs(c) {
+    /* istanbul ignore if */
+    if (c.elm._moveCb) {
+        c.elm._moveCb();
+    }
+    /* istanbul ignore if */
+    if (c.elm._enterCb) {
+        c.elm._enterCb();
+    }
+}
+function recordPosition(c) {
+    c.data.newPos = c.elm.getBoundingClientRect();
+}
+function applyTranslation(c) {
+    const oldPos = c.data.pos;
+    const newPos = c.data.newPos;
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+        c.data.moved = true;
+        const s = c.elm.style;
+        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+        s.transitionDuration = "0s";
+    }
 }
 
-var platformComponents = {
-    Transition,
-    TransitionGroup,
+var platformComponents = {
+    Transition,
+    TransitionGroup,
 };
 
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else if (process.env.NODE_ENV !== 'production' &&
-                process.env.NODE_ENV !== 'test') {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (process.env.NODE_ENV !== 'production' &&
-            process.env.NODE_ENV !== 'test' &&
-            config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
+// install platform specific utils
+Vue.config.mustUseProp = mustUseProp;
+Vue.config.isReservedTag = isReservedTag;
+Vue.config.isReservedAttr = isReservedAttr;
+Vue.config.getTagNamespace = getTagNamespace;
+Vue.config.isUnknownElement = isUnknownElement;
+// install platform runtime directives & components
+extend(Vue.options.directives, platformDirectives);
+extend(Vue.options.components, platformComponents);
+// install platform patch function
+Vue.prototype.__patch__ = inBrowser ? patch : noop;
+// public mount method
+Vue.prototype.$mount = function (el, hydrating) {
+    el = el && inBrowser ? query(el) : undefined;
+    return mountComponent(this, el, hydrating);
+};
+// devtools global hook
+/* istanbul ignore next */
+if (inBrowser) {
+    setTimeout(() => {
+        if (config.devtools) {
+            if (devtools) {
+                devtools.emit('init', Vue);
+            }
+            else if (process.env.NODE_ENV !== 'production' &&
+                process.env.NODE_ENV !== 'test') {
+                // @ts-expect-error
+                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                    'https://github.com/vuejs/vue-devtools');
+            }
+        }
+        if (process.env.NODE_ENV !== 'production' &&
+            process.env.NODE_ENV !== 'test' &&
+            config.productionTip !== false &&
+            typeof console !== 'undefined') {
+            // @ts-expect-error
+            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                `Make sure to turn on production mode when deploying for production.\n` +
+                `See more tips at https://vuejs.org/guide/deployment.html`);
+        }
+    }, 0);
 }
 
 export { Vue as default };
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
index 0fd13ae54ed..bdf6b208b4d 100644
--- a/dist/vue.runtime.js
+++ b/dist/vue.runtime.js
@@ -9,4985 +9,4982 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
 })(this, (function () { 'use strict';
 
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  function isRegExp(v) {
-      return _toString.call(v) === '[object RegExp]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$2(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-  /* istanbul ignore next */
-  function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          const l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
-  }
-  function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
-  }
-  // @ts-expect-error bind cannot be `undefined`
-  const bind = Function.prototype.bind ? nativeBind : polyfillBind;
-  /**
-   * Convert an Array-like object to a real Array.
-   */
-  function toArray(list, start) {
-      start = start || 0;
-      let i = list.length - start;
-      const ret = new Array(i);
-      while (i--) {
-          ret[i] = list[i + start];
-      }
-      return ret;
-  }
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-  /**
-   * Ensure a function is called only once.
-   */
-  function once(fn) {
-      let called = false;
-      return function () {
-          if (!called) {
-              called = true;
-              fn.apply(this, arguments);
-          }
-      };
+  const emptyObject = Object.freeze({});
+  // These helpers produce better VM code in JS engines due to their
+  // explicitness and function inlining.
+  function isUndef(v) {
+      return v === undefined || v === null;
+  }
+  function isDef(v) {
+      return v !== undefined && v !== null;
+  }
+  function isTrue(v) {
+      return v === true;
+  }
+  function isFalse(v) {
+      return v === false;
+  }
+  /**
+   * Check if value is primitive.
+   */
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
+  }
+  /**
+   * Quick object check - this is primarily used to tell
+   * objects from primitive values when we know the value
+   * is a JSON-compliant type.
+   */
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
+  }
+  /**
+   * Get the raw type string of a value, e.g., [object Object].
+   */
+  const _toString = Object.prototype.toString;
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
+  }
+  /**
+   * Strict object type check. Only returns true
+   * for plain JavaScript objects.
+   */
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
+  }
+  function isRegExp(v) {
+      return _toString.call(v) === '[object RegExp]';
+  }
+  /**
+   * Check if val is a valid array index.
+   */
+  function isValidArrayIndex(val) {
+      const n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
+  }
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
+  }
+  /**
+   * Convert a value to a string that is actually rendered.
+   */
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
+  }
+  /**
+   * Convert an input value to a number for persistence.
+   * If the conversion fails, return original string.
+   */
+  function toNumber(val) {
+      const n = parseFloat(val);
+      return isNaN(n) ? val : n;
+  }
+  /**
+   * Make a map and return a function for checking if a key
+   * is in that map.
+   */
+  function makeMap(str, expectsLowerCase) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+  }
+  /**
+   * Check if a tag is a built-in tag.
+   */
+  const isBuiltInTag = makeMap('slot,component', true);
+  /**
+   * Check if an attribute is a reserved attribute.
+   */
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  /**
+   * Remove an item from an array.
+   */
+  function remove$2(arr, item) {
+      if (arr.length) {
+          const index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
+      }
+  }
+  /**
+   * Check whether an object has the property.
+   */
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
+  }
+  /**
+   * Create a cached version of a pure function.
+   */
+  function cached(fn) {
+      const cache = Object.create(null);
+      return function cachedFn(str) {
+          const hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
+  }
+  /**
+   * Camelize a hyphen-delimited string.
+   */
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+  });
+  /**
+   * Capitalize a string.
+   */
+  const capitalize = cached((str) => {
+      return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  /**
+   * Hyphenate a camelCase string.
+   */
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
+  });
+  /**
+   * Simple bind polyfill for environments that do not support it,
+   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
+   * since native bind is now performant enough in most browsers.
+   * But removing it would mean breaking code that was able to run in
+   * PhantomJS 1.x, so this must be kept for backward compatibility.
+   */
+  /* istanbul ignore next */
+  function polyfillBind(fn, ctx) {
+      function boundFn(a) {
+          const l = arguments.length;
+          return l
+              ? l > 1
+                  ? fn.apply(ctx, arguments)
+                  : fn.call(ctx, a)
+              : fn.call(ctx);
+      }
+      boundFn._length = fn.length;
+      return boundFn;
+  }
+  function nativeBind(fn, ctx) {
+      return fn.bind(ctx);
+  }
+  // @ts-expect-error bind cannot be `undefined`
+  const bind = Function.prototype.bind ? nativeBind : polyfillBind;
+  /**
+   * Convert an Array-like object to a real Array.
+   */
+  function toArray(list, start) {
+      start = start || 0;
+      let i = list.length - start;
+      const ret = new Array(i);
+      while (i--) {
+          ret[i] = list[i + start];
+      }
+      return ret;
+  }
+  /**
+   * Mix properties into target object.
+   */
+  function extend(to, _from) {
+      for (const key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
+  }
+  /**
+   * Merge an Array of Objects into a single Object.
+   */
+  function toObject(arr) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
+      }
+      return res;
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * Perform no operation.
+   * Stubbing args to make Flow happy without leaving useless transpiled code
+   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+   */
+  function noop(a, b, c) { }
+  /**
+   * Always return false.
+   */
+  const no = (a, b, c) => false;
+  /* eslint-enable no-unused-vars */
+  /**
+   * Return the same value.
+   */
+  const identity = (_) => _;
+  /**
+   * Check if two values are loosely equal - that is,
+   * if they are plain objects, do they have the same shape?
+   */
+  function looseEqual(a, b) {
+      if (a === b)
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every((e, i) => {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every((key) => {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
+  }
+  /**
+   * Return the first index at which a loosely equal value can be
+   * found in the array (if value is a plain object, the array must
+   * contain an object of the same shape), or -1 if it is not present.
+   */
+  function looseIndexOf(arr, val) {
+      for (let i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              return i;
+      }
+      return -1;
+  }
+  /**
+   * Ensure a function is called only once.
+   */
+  function once(fn) {
+      let called = false;
+      return function () {
+          if (!called) {
+              called = true;
+              fn.apply(this, arguments);
+          }
+      };
   }
 
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch',
   ];
 
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Check if a string starts with $ or _
-   */
-  function isReserved(str) {
-      const c = (str + '').charCodeAt(0);
-      return c === 0x24 || c === 0x5f;
-  }
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-  /**
-   * Parse simple path.
-   */
-  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-  function parsePath(path) {
-      if (bailRE.test(path)) {
-          return;
-      }
-      const segments = path.split('.');
-      return function (obj) {
-          for (let i = 0; i < segments.length; i++) {
-              if (!obj)
-                  return;
-              obj = obj[segments[i]];
-          }
-          return obj;
-      };
+  /**
+   * unicode letters used for parsing html tags, component names and property paths.
+   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+   */
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+  /**
+   * Check if a string starts with $ or _
+   */
+  function isReserved(str) {
+      const c = (str + '').charCodeAt(0);
+      return c === 0x24 || c === 0x5f;
+  }
+  /**
+   * Define a property.
+   */
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
+  }
+  /**
+   * Parse simple path.
+   */
+  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
+  function parsePath(path) {
+      if (bailRE.test(path)) {
+          return;
+      }
+      const segments = path.split('.');
+      return function (obj) {
+          for (let i = 0; i < segments.length; i++) {
+              if (!obj)
+                  return;
+              obj = obj[segments[i]];
+          }
+          return obj;
+      };
   }
 
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  const isFF = UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
-  };
-  // detect devtools
-  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
+  // can we use __proto__?
+  const hasProto = '__proto__' in {};
+  // Browser environment sniffing
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  const isFF = UA && UA.match(/firefox\/(\d+)/);
+  // Firefox has a "watch" function on Object.prototype...
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
+  if (inBrowser) {
+      try {
+          const opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
+  }
+  // this needs to be lazy-evaled because vue may be required before
+  // vue-server-renderer can set VUE_ENV
+  let _isServer;
+  const isServerRendering = () => {
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
+  };
+  // detect devtools
+  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
+  /* istanbul ignore next */
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  const hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  let _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
+              return this.set[key] === true;
+          }
+          add(key) {
+              this.set[key] = true;
+          }
+          clear() {
+              this.set = Object.create(null);
+          }
+      };
   }
 
-  let warn = noop;
-  let tip = noop;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (config.warnHandler) {
-              config.warnHandler.call(null, msg, vm, trace);
-          }
-          else if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
+  let warn = noop;
+  let tip = noop;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
+  {
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
+          if (config.warnHandler) {
+              config.warnHandler.call(null, msg, vm, trace);
+          }
+          else if (hasConsole && !config.silent) {
+              console.error(`[Vue warn]: ${msg}${trace}`);
+          }
+      };
+      tip = (msg, vm) => {
+          if (hasConsole && !config.silent) {
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = (vm, includeFile) => {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
+              : vm._isVue
+                  ? vm.$options || vm.constructor.options
+                  : vm;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
+          if (!name && file) {
+              const match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
+      };
+      const repeat = (str, n) => {
+          let res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  res += str;
+              if (n > 1)
+                  str += str;
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = (vm) => {
+          if (vm._isVue && vm.$parent) {
+              const tree = [];
+              let currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      const last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                      .join('\n'));
+          }
+          else {
+              return `\n\n(found in ${formatComponentName(vm)})`;
+          }
+      };
   }
 
-  let uid$2 = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid$2++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$2(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          if (!config.async) {
-              // subs aren't sorted in scheduler if not running async
-              // we need to sort them now to make sure they fire in correct
-              // order
-              subs.sort((a, b) => a.id - b.id);
-          }
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
+  let uid$2 = 0;
+  /**
+   * A dep is an observable that can have multiple
+   * directives subscribing to it.
+   */
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid$2++;
+          this.subs = [];
+      }
+      addSub(sub) {
+          this.subs.push(sub);
+      }
+      removeSub(sub) {
+          remove$2(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          if (!config.async) {
+              // subs aren't sorted in scheduler if not running async
+              // we need to sort them now to make sure they fire in correct
+              // order
+              subs.sort((a, b) => a.id - b.id);
+          }
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
+  // The current target watcher being evaluated.
+  // This is globally unique because only one watcher
+  // can be evaluated at a time.
+  Dep.target = null;
+  const targetStack = [];
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
+  }
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
   }
 
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
+  };
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
+  }
+  // optimized shallow clone
+  // used for static nodes and slot nodes because they may be reused across
+  // multiple renders, cloning them avoids errors when DOM manipulations rely
+  // on their elm reference.
+  function cloneVNode(vnode) {
+      const cloned = new VNode(vnode.tag, vnode.data, 
+      // #7975
+      // clone children array to avoid mutating original in case of cloning
+      // a child.
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
   }
 
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
+  /*
+   * not type checking this file because flow doesn't play well with
+   * dynamically accessing methods on Array prototype
+   */
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse',
+  ];
+  /**
+   * Intercept mutating methods and emit events
+   */
+  methodsToPatch.forEach(function (method) {
+      // cache original method
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              ob.observeArray(inserted);
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
 
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Delete a property and trigger change if necessary.
-   */
-  function del(target, key) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.splice(key, 1);
-          return;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                  '- just set it to null.');
-          return;
-      }
-      if (!hasOwn(target, key)) {
-          return;
-      }
-      delete target[key];
-      if (!ob) {
-          return;
-      }
-      ob.dep.notify();
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+  /**
+   * In some cases we may want to disable observation inside a component's
+   * update computation.
+   */
+  let shouldObserve = true;
+  function toggleObserving(value) {
+      shouldObserve = value;
+  }
+  /**
+   * Observer class that is attached to each observed
+   * object. Once attached, the observer converts the target
+   * object's property keys into getter/setters that
+   * collect dependencies and dispatch updates.
+   */
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
+          }
+          else {
+              this.walk(value);
+          }
+      }
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      }
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      }
+  }
+  // helpers
+  /**
+   * Augment a target Object or Array by intercepting
+   * the prototype chain using __proto__
+   */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
+  }
+  /**
+   * Augment a target Object or Array by defining
+   * hidden properties.
+   */
+  /* istanbul ignore next */
+  function copyAugment(target, src, keys) {
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
+          def(target, key, src[key]);
+      }
+  }
+  /**
+   * Attempt to create an observer instance for a value,
+   * returns the new observer if successfully observed,
+   * or the existing observer if the value already has one.
+   */
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      let ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
+  }
+  /**
+   * Define a reactive property on an Object.
+   */
+  function defineReactive(obj, key, val, customSetter, shallow) {
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      const getter = property && property.get;
+      const setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      let childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              const value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              const value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  return;
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
+  }
+  /**
+   * Set a property on an object. Adds the new property and
+   * triggers change notification if the property doesn't
+   * already exist.
+   */
+  function set(target, key, val) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive(ob.value, key, val);
+      ob.dep.notify();
+      return val;
+  }
+  /**
+   * Delete a property and trigger change if necessary.
+   */
+  function del(target, key) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.splice(key, 1);
+          return;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn('Avoid deleting properties on a Vue instance or its root $data ' +
+                  '- just set it to null.');
+          return;
+      }
+      if (!hasOwn(target, key)) {
+          return;
+      }
+      delete target[key];
+      if (!ob) {
+          return;
+      }
+      ob.dep.notify();
+  }
+  /**
+   * Collect dependencies on array elements when the array is touched, since
+   * we cannot intercept array element access like property getters.
+   */
+  function dependArray(value) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
+      }
   }
 
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
-  });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives$1(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives$1(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
+  /**
+   * Option overwriting strategies are functions that handle
+   * how to merge a parent option value and a child option
+   * value into the final value.
+   */
+  const strats = config.optionMergeStrategies;
+  /**
+   * Options with restrictions
+   */
+  {
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn(`option "${key}" can only be used during instance ` +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
+  }
+  /**
+   * Helper that recursively merges two data objects together.
+   */
+  function mergeData(to, from) {
+      if (!from)
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (let i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              continue;
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
+  }
+  /**
+   * Data
+   */
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
+  };
+  /**
+   * Hooks and props are merged as arrays.
+   */
+  function mergeHook$1(parentVal, childVal) {
+      const res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
+  }
+  LIFECYCLE_HOOKS.forEach((hook) => {
+      strats[hook] = mergeHook$1;
+  });
+  /**
+   * Assets
+   *
+   * When a vm is present (instance creation), we need to do
+   * a three-way merge between constructor options, instance
+   * options and parent options.
+   */
+  function mergeAssets(parentVal, childVal, vm, key) {
+      const res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
+  }
+  ASSET_TYPES.forEach(function (type) {
+      strats[type + 's'] = mergeAssets;
+  });
+  /**
+   * Watchers.
+   *
+   * Watchers hashes should not overwrite one
+   * another, so we merge them as arrays.
+   */
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          parentVal = undefined;
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          childVal = undefined;
+      /* istanbul ignore if */
+      if (!childVal)
+          return Object.create(parentVal || null);
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = {};
+      extend(ret, parentVal);
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
+  };
+  /**
+   * Other object hashes.
+   */
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          extend(ret, childVal);
+      return ret;
+  };
+  strats.provide = mergeDataOrFn;
+  /**
+   * Default strategy.
+   */
+  const defaultStrat = function (parentVal, childVal) {
+      return childVal === undefined ? parentVal : childVal;
+  };
+  /**
+   * Validate component names
+   */
+  function checkComponents(options) {
+      for (const key in options.components) {
+          validateComponentName(key);
+      }
+  }
+  function validateComponentName(name) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+          warn('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
+  }
+  /**
+   * Ensure all props option syntax are normalized into the
+   * Object-based format.
+   */
+  function normalizeProps(options, vm) {
+      const props = options.props;
+      if (!props)
+          return;
+      const res = {};
+      let i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (const key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
+      }
+      options.props = res;
+  }
+  /**
+   * Normalize all injections into Object-based format
+   */
+  function normalizeInject(options, vm) {
+      const inject = options.inject;
+      if (!inject)
+          return;
+      const normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (let i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (const key in inject) {
+              const val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
+      }
+  }
+  /**
+   * Normalize raw function directives into object format.
+   */
+  function normalizeDirectives$1(options) {
+      const dirs = options.directives;
+      if (dirs) {
+          for (const key in dirs) {
+              const def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
+      }
+  }
+  /**
+   * Merge two option objects into a new one.
+   * Core utility used in both instantiation and inheritance.
+   */
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives$1(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      const options = {};
+      let key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          const strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
+  }
+  /**
+   * Resolve an asset.
+   * This function is used because child instances need access
+   * to assets defined in its ancestor chain.
+   */
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      const assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          return assets[id];
+      const camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          return assets[PascalCaseId];
+      // fallback to prototype chain
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
   }
 
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
+  function validateProp(key, propOptions, propsData, vm) {
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
+      // boolean casting
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              const stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          const prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
+  }
+  /**
+   * Get the default value of a prop.
+   */
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      const def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
+  }
+  /**
+   * Assert whether a prop is valid.
+   */
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      const haveExpectedTypes = expectedTypes.some((t) => t);
+      if (!valid && haveExpectedTypes) {
+          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      const validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
+  }
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      let valid;
+      const expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          const t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid,
+          expectedType,
+      };
+  }
+  const functionTypeCheckRE = /^\s*function (\w+)/;
+  /**
+   * Use function string name to check built-in types,
+   * because a simple equality check will fail when running
+   * across different vms / iframes.
+   */
+  function getType(fn) {
+      const match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
+          }
+      }
+      return -1;
+  }
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += ` with value ${styleValue(value, expectedType)}`;
+      }
+      message += `, got ${receivedType} `;
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += `with value ${styleValue(value, receivedType)}.`;
+      }
+      return message;
+  }
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return `"${value}"`;
+      }
+      else if (type === 'Number') {
+          return `${Number(value)}`;
+      }
+      else {
+          return `${value}`;
+      }
+  }
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
   }
 
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          // @ts-expect-error should it be any?
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      if (config.errorHandler) {
-          try {
-              return config.errorHandler.call(null, err, vm, info);
-          }
-          catch (e) {
-              // if the user intentionally throws the original error in the handler,
-              // do not log it twice
-              if (e !== err) {
-                  logError(e, null, 'config.errorHandler');
-              }
-          }
-      }
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              let cur = vm;
+              while ((cur = cur.$parent)) {
+                  const hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (let i = 0; i < hooks.length; i++) {
+                          try {
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  return;
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      let res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      if (config.errorHandler) {
+          try {
+              return config.errorHandler.call(null, err, vm, info);
+          }
+          catch (e) {
+              // if the user intentionally throws the original error in the handler,
+              // do not log it twice
+              if (e !== err) {
+                  logError(e, null, 'config.errorHandler');
+              }
+          }
+      }
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn(`Error in ${info}: "${err.toString()}"`, vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
   }
 
-  /* globals MutationObserver */
-  let isUsingMicroTask = false;
-  const callbacks = [];
-  let pending = false;
-  function flushCallbacks() {
-      pending = false;
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // Here we have async deferring wrappers using microtasks.
-  // In 2.5 we used (macro) tasks (in combination with microtasks).
-  // However, it has subtle problems when state is changed right before repaint
-  // (e.g. #6813, out-in transitions).
-  // Also, using (macro) tasks in event handler would cause some weird behaviors
-  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-  // So we now use microtasks everywhere, again.
-  // A major drawback of this tradeoff is that there are some scenarios
-  // where microtasks have too high a priority and fire in between supposedly
-  // sequential events (e.g. #4521, #6690, which have workarounds)
-  // or even between bubbling of the same event (#6566).
-  let timerFunc;
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      const p = Promise.resolve();
-      timerFunc = () => {
-          p.then(flushCallbacks);
-          // In problematic UIWebViews, Promise.then doesn't completely break, but
-          // it can get stuck in a weird state where callbacks are pushed into the
-          // microtask queue but the queue isn't being flushed, until the browser
-          // needs to do some other work, e.g. handle a timer. Therefore we can
-          // "force" the microtask queue to be flushed by adding an empty timer.
-          if (isIOS)
-              setTimeout(noop);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-      timerFunc = () => {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-      // Fallback to setImmediate.
-      // Technically it leverages the (macro) task queue,
-      // but it is still a better choice than setTimeout.
-      timerFunc = () => {
-          setImmediate(flushCallbacks);
-      };
-  }
-  else {
-      // Fallback to setTimeout.
-      timerFunc = () => {
-          setTimeout(flushCallbacks, 0);
-      };
-  }
-  function nextTick(cb, ctx) {
-      let _resolve;
-      callbacks.push(() => {
-          if (cb) {
-              try {
-                  cb.call(ctx);
-              }
-              catch (e) {
-                  // @ts-expect-error should it be any?
-                  handleError(e, ctx, 'nextTick');
-              }
-          }
-          else if (_resolve) {
-              _resolve(ctx);
-          }
-      });
-      if (!pending) {
-          pending = true;
-          timerFunc();
-      }
-      // $flow-disable-line
-      if (!cb && typeof Promise !== 'undefined') {
-          return new Promise((resolve) => {
-              _resolve = resolve;
-          });
-      }
+  /* globals MutationObserver */
+  let isUsingMicroTask = false;
+  const callbacks = [];
+  let pending = false;
+  function flushCallbacks() {
+      pending = false;
+      const copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (let i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
+  }
+  // Here we have async deferring wrappers using microtasks.
+  // In 2.5 we used (macro) tasks (in combination with microtasks).
+  // However, it has subtle problems when state is changed right before repaint
+  // (e.g. #6813, out-in transitions).
+  // Also, using (macro) tasks in event handler would cause some weird behaviors
+  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
+  // So we now use microtasks everywhere, again.
+  // A major drawback of this tradeoff is that there are some scenarios
+  // where microtasks have too high a priority and fire in between supposedly
+  // sequential events (e.g. #4521, #6690, which have workarounds)
+  // or even between bubbling of the same event (#6566).
+  let timerFunc;
+  // The nextTick behavior leverages the microtask queue, which can be accessed
+  // via either native Promise.then or MutationObserver.
+  // MutationObserver has wider support, however it is seriously bugged in
+  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+  // completely stops working after triggering a few times... so, if native
+  // Promise is available, we will use it:
+  /* istanbul ignore next, $flow-disable-line */
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+      const p = Promise.resolve();
+      timerFunc = () => {
+          p.then(flushCallbacks);
+          // In problematic UIWebViews, Promise.then doesn't completely break, but
+          // it can get stuck in a weird state where callbacks are pushed into the
+          // microtask queue but the queue isn't being flushed, until the browser
+          // needs to do some other work, e.g. handle a timer. Therefore we can
+          // "force" the microtask queue to be flushed by adding an empty timer.
+          if (isIOS)
+              setTimeout(noop);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+      timerFunc = () => {
+          counter = (counter + 1) % 2;
+          textNode.data = String(counter);
+      };
+      isUsingMicroTask = true;
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+      // Fallback to setImmediate.
+      // Technically it leverages the (macro) task queue,
+      // but it is still a better choice than setTimeout.
+      timerFunc = () => {
+          setImmediate(flushCallbacks);
+      };
+  }
+  else {
+      // Fallback to setTimeout.
+      timerFunc = () => {
+          setTimeout(flushCallbacks, 0);
+      };
+  }
+  function nextTick(cb, ctx) {
+      let _resolve;
+      callbacks.push(() => {
+          if (cb) {
+              try {
+                  cb.call(ctx);
+              }
+              catch (e) {
+                  handleError(e, ctx, 'nextTick');
+              }
+          }
+          else if (_resolve) {
+              _resolve(ctx);
+          }
+      });
+      if (!pending) {
+          pending = true;
+          timerFunc();
+      }
+      // $flow-disable-line
+      if (!cb && typeof Promise !== 'undefined') {
+          return new Promise((resolve) => {
+              _resolve = resolve;
+          });
+      }
   }
 
-  /* not type checking this file because flow doesn't play well with Proxy */
-  let initProxy;
-  {
-      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const warnNonPresent = (target, key) => {
-          warn(`Property or method "${key}" is not defined on the instance but ` +
-              'referenced during render. Make sure that this property is reactive, ' +
-              'either in the data option, or for class-based components, by ' +
-              'initializing the property. ' +
-              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-      };
-      const warnReservedPrefix = (target, key) => {
-          warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
-              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-              'prevent conflicts with Vue internals. ' +
-              'See: https://vuejs.org/v2/api/#data', target);
-      };
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-      const hasHandler = {
-          has(target, key) {
-              const has = key in target;
-              const isAllowed = allowedGlobals(key) ||
-                  (typeof key === 'string' &&
-                      key.charAt(0) === '_' &&
-                      !(key in target.$data));
-              if (!has && !isAllowed) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return has || !isAllowed;
-          },
-      };
-      const getHandler = {
-          get(target, key) {
-              if (typeof key === 'string' && !(key in target)) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return target[key];
-          },
-      };
-      initProxy = function initProxy(vm) {
-          if (hasProxy) {
-              // determine which proxy handler to use
-              const options = vm.$options;
-              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-              vm._renderProxy = new Proxy(vm, handlers);
-          }
-          else {
-              vm._renderProxy = vm;
-          }
-      };
+  /* not type checking this file because flow doesn't play well with Proxy */
+  let initProxy;
+  {
+      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
+      );
+      const warnNonPresent = (target, key) => {
+          warn(`Property or method "${key}" is not defined on the instance but ` +
+              'referenced during render. Make sure that this property is reactive, ' +
+              'either in the data option, or for class-based components, by ' +
+              'initializing the property. ' +
+              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+      };
+      const warnReservedPrefix = (target, key) => {
+          warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
+              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
+              'prevent conflicts with Vue internals. ' +
+              'See: https://vuejs.org/v2/api/#data', target);
+      };
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
+      const hasHandler = {
+          has(target, key) {
+              const has = key in target;
+              const isAllowed = allowedGlobals(key) ||
+                  (typeof key === 'string' &&
+                      key.charAt(0) === '_' &&
+                      !(key in target.$data));
+              if (!has && !isAllowed) {
+                  if (key in target.$data)
+                      warnReservedPrefix(target, key);
+                  else
+                      warnNonPresent(target, key);
+              }
+              return has || !isAllowed;
+          },
+      };
+      const getHandler = {
+          get(target, key) {
+              if (typeof key === 'string' && !(key in target)) {
+                  if (key in target.$data)
+                      warnReservedPrefix(target, key);
+                  else
+                      warnNonPresent(target, key);
+              }
+              return target[key];
+          },
+      };
+      initProxy = function initProxy(vm) {
+          if (hasProxy) {
+              // determine which proxy handler to use
+              const options = vm.$options;
+              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
+              vm._renderProxy = new Proxy(vm, handlers);
+          }
+          else {
+              vm._renderProxy = vm;
+          }
+      };
   }
 
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
+  const seenObjects = new _Set();
+  /**
+   * Recursively traverse an object to evoke all converted
+   * getters, so that every nested property inside the object
+   * is collected as a "deep" dependency.
+   */
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      let i, keys;
+      const isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          const depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              _traverse(val[i], seen);
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              _traverse(val[keys[i]], seen);
+      }
   }
 
-  let mark;
-  let measure;
-  {
-      const perf = inBrowser && window.performance;
-      /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = (tag) => perf.mark(tag);
-          measure = (name, startTag, endTag) => {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
-              // perf.clearMeasures(name)
-          };
-      }
+  let mark;
+  let measure;
+  {
+      const perf = inBrowser && window.performance;
+      /* istanbul ignore if */
+      if (perf &&
+          perf.mark &&
+          perf.measure &&
+          perf.clearMarks &&
+          perf.clearMeasures) {
+          mark = (tag) => perf.mark(tag);
+          measure = (name, startTag, endTag) => {
+              perf.measure(name, startTag, endTag);
+              perf.clearMarks(startTag);
+              perf.clearMarks(endTag);
+              // perf.clearMeasures(name)
+          };
+      }
   }
 
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
+      const capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name,
+          once,
+          capture,
+          passive,
+      };
+  });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          const fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      let name, cur, old, event;
+      for (name in on) {
+          cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove(event.name, oldOn[name], event.capture);
+          }
+      }
   }
 
-  function mergeVNodeHook(def, hookKey, hook) {
-      if (def instanceof VNode) {
-          def = def.data.hook || (def.data.hook = {});
-      }
-      let invoker;
-      const oldHook = def[hookKey];
-      function wrappedHook() {
-          hook.apply(this, arguments);
-          // important: remove merged hook to ensure it's called only once
-          // and prevent memory leak
-          remove$2(invoker.fns, wrappedHook);
-      }
-      if (isUndef(oldHook)) {
-          // no existing hook
-          invoker = createFnInvoker([wrappedHook]);
-      }
-      else {
-          /* istanbul ignore if */
-          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-              // already a merged invoker
-              invoker = oldHook;
-              invoker.fns.push(wrappedHook);
-          }
-          else {
-              // existing plain hook
-              invoker = createFnInvoker([oldHook, wrappedHook]);
-          }
-      }
-      invoker.merged = true;
-      def[hookKey] = invoker;
+  function mergeVNodeHook(def, hookKey, hook) {
+      if (def instanceof VNode) {
+          def = def.data.hook || (def.data.hook = {});
+      }
+      let invoker;
+      const oldHook = def[hookKey];
+      function wrappedHook() {
+          hook.apply(this, arguments);
+          // important: remove merged hook to ensure it's called only once
+          // and prevent memory leak
+          remove$2(invoker.fns, wrappedHook);
+      }
+      if (isUndef(oldHook)) {
+          // no existing hook
+          invoker = createFnInvoker([wrappedHook]);
+      }
+      else {
+          /* istanbul ignore if */
+          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
+              // already a merged invoker
+              invoker = oldHook;
+              invoker.fns.push(wrappedHook);
+          }
+          else {
+              // existing plain hook
+              invoker = createFnInvoker([oldHook, wrappedHook]);
+          }
+      }
+      invoker.merged = true;
+      def[hookKey] = invoker;
   }
 
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      const propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      const res = {};
+      const { attrs, props } = data;
+      if (isDef(attrs) || isDef(props)) {
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
+              {
+                  const keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
   }
 
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
+  // The template compiler attempts to minimize the need for normalization by
+  // statically analyzing the template at compile time.
+  //
+  // For plain HTML markup, normalization can be completely skipped because the
+  // generated render function is guaranteed to return Array<VNode>. There are
+  // two cases where extra normalization is needed:
+  // 1. When the children contains components - because a functional component
+  // may return an Array instead of a single root. In this case, just a simple
+  // normalization is needed - if any child is an Array, we flatten the whole
+  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+  // because functional components already normalize their own children.
+  function simpleNormalizeChildren(children) {
+      for (let i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
+      }
+      return children;
+  }
+  // 2. When the children contains constructs that always generated nested Arrays,
+  // e.g. <template>, <slot>, v-for, or when the children is provided by user
+  // with hand-written render functions / JSX. In such cases a full normalization
+  // is needed to cater to all possible types of children values.
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      const res = [];
+      let i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              continue;
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = `__vlist${nestedIndex}_${i}__`;
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
   }
 
-  function initProvide(vm) {
-      const provide = vm.$options.provide;
-      if (provide) {
-          vm._provided =
-              typeof provide === 'function'
-                  ? // @ts-expect-error typing not correct
-                      provide.call(vm)
-                  : provide;
-      }
-  }
-  function initInjections(vm) {
-      const result = resolveInject(vm.$options.inject, vm);
-      if (result) {
-          toggleObserving(false);
-          Object.keys(result).forEach((key) => {
-              /* istanbul ignore else */
-              {
-                  defineReactive(vm, key, result[key], () => {
-                      warn(`Avoid mutating an injected value directly since the changes will be ` +
-                          `overwritten whenever the provided component re-renders. ` +
-                          `injection being mutated: "${key}"`, vm);
-                  });
-              }
-          });
-          toggleObserving(true);
-      }
-  }
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
+  function initProvide(vm) {
+      const provide = vm.$options.provide;
+      if (provide) {
+          vm._provided =
+              typeof provide === 'function'
+                  ? // @ts-expect-error typing not correct
+                      provide.call(vm)
+                  : provide;
+      }
+  }
+  function initInjections(vm) {
+      const result = resolveInject(vm.$options.inject, vm);
+      if (result) {
+          toggleObserving(false);
+          Object.keys(result).forEach((key) => {
+              /* istanbul ignore else */
+              {
+                  defineReactive(vm, key, result[key], () => {
+                      warn(`Avoid mutating an injected value directly since the changes will be ` +
+                          `overwritten whenever the provided component re-renders. ` +
+                          `injection being mutated: "${key}"`, vm);
+                  });
+              }
+          });
+          toggleObserving(true);
+      }
+  }
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      const provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      warn(`Injection "${key}" not found`, vm);
+                  }
+              }
+          }
+          return result;
+      }
   }
 
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  /**
+   * Runtime helper for resolving raw children VNodes into a slot object.
+   */
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
   }
 
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
   }
 
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
+      return res;
+  }
+  function normalizeScopedSlot(normalSlots, key, fn) {
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === "object" && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
+  }
+  function proxyNormalSlot(slots, key) {
+      return () => slots[key];
   }
 
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
+  /**
+   * Runtime helper for rendering v-for lists.
+   */
+  function renderList(val, render) {
+      let ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
   }
 
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
+  /**
+   * Runtime helper for rendering <slot>
+   */
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn("slot v-bind without argument expects an Object", this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      else {
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      const target = props && props.slot;
+      if (target) {
+          return this.$createElement("template", { slot: target }, nodes);
+      }
+      else {
+          return nodes;
+      }
   }
 
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
+  /**
+   * Runtime helper for resolving filters
+   */
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
   }
 
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
+  }
+  /**
+   * Runtime helper for checking keyCodes from config.
+   * exposed as Vue.prototype._k
+   * passing in eventKeyName as last argument separately for backwards compat
+   */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+      return eventKeyCode === undefined;
   }
 
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
+  /**
+   * Runtime helper for merging v-bind="object" into a VNode's data.
+   */
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn('v-bind without argument expects an Object or Array value', this);
+          }
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              let hash;
+              for (const key in value) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      const type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              }
+          }
+      }
+      return data;
   }
 
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
+  /**
+   * Runtime helper for rendering static trees.
+   */
+  function renderStatic(index, isInFor) {
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, `__static__${index}`, false);
+      return tree;
+  }
+  /**
+   * Runtime helper for v-once.
+   * Effectively it means marking the node as static with a unique key.
+   */
+  function markOnce(tree, index, key) {
+      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (let i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
   }
 
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn('v-on without argument expects an Object value', this);
+          }
+          else {
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
+      }
+      return data;
   }
 
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
   }
 
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+  function bindDynamicKeys(baseObj, values) {
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+          }
+      }
+      return baseObj;
+  }
+  // helper to dynamically append modifier runtime markers to event names.
+  // ensure only append when value is already string, otherwise it will be cast
+  // to string and cause the type check to miss.
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
   }
 
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
   }
 
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      const options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      let contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+          }
+          return this.$slots;
+      };
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = (a, b, c, d) => {
+              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
+      }
+  }
+  installRenderHelpers(FunctionalRenderContext.prototype);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (const key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              mergeProps(props, data.attrs);
+          if (isDef(data.props))
+              mergeProps(props, data.props);
+      }
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      const clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (const key in from) {
+          to[camelize(key)] = from[key];
+      }
   }
 
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook$1(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
+  // inline hooks to be invoked on component VNodes during patch
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              const mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook$1(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy(vnode) {
+          const { componentInstance } = vnode;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+  };
+  const hooksToMerge = Object.keys(componentVNodeHooks);
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      const baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn(`Invalid Component definition: ${String(Ctor)}`, context);
+          }
+          return;
+      }
+      // async component
+      let asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      const listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          const slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
+      // @ts-expect-error
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      const options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent,
+      };
+      // check inline-template render functions
+      const inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook(f1, f2) {
+      const merged = (a, b) => {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
+  }
+  // transform component v-model info (value and callback) into
+  // prop and event handler respectively.
+  function transformModel(options, data) {
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
   }
 
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if (config.isReservedTag(tag)) {
-              // platform built-in elements
-              if (isDef(data) &&
-                  isDef(data.nativeOn) &&
-                  data.tag !== 'component') {
-                  warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-              }
-              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-          }
-          else if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
+  // wrapper function for providing a more flexible interface
+  // without getting yelled at by flow
+  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      let vnode, ns;
+      if (typeof tag === 'string') {
+          let Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if (config.isReservedTag(tag)) {
+              // platform built-in elements
+              if (isDef(data) &&
+                  isDef(data.nativeOn) &&
+                  data.tag !== 'component') {
+                  warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
+              }
+              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
+          }
+          else if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              applyNS(vnode, ns);
+          if (isDef(data))
+              registerDeepBindings(data);
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
+  }
+  // ref #5318
+  // necessary to ensure parent re-render when deep bindings like :style and
+  // :class are used on slot nodes
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
   }
 
-  function initRender(vm) {
-      vm._vnode = null; // the root of the child tree
-      vm._staticTrees = null; // v-once cached trees
-      const options = vm.$options;
-      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      const renderContext = parentVnode && parentVnode.context;
-      vm.$slots = resolveSlots(options._renderChildren, renderContext);
-      vm.$scopedSlots = emptyObject;
-      // bind the createElement fn to this instance
-      // so that we get proper render context inside it.
-      // args order: tag, data, children, normalizationType, alwaysNormalize
-      // internal version is used by render functions compiled from templates
-      // @ts-expect-error
-      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-      // normalization is always applied for the public version, used in
-      // user-written render functions.
-      // @ts-expect-error
-      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-      // $attrs & $listeners are exposed for easier HOC creation.
-      // they need to be reactive so that HOCs using them are always updated
-      const parentData = parentVnode && parentVnode.data;
-      /* istanbul ignore else */
-      {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-              !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-          }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-              !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-          }, true);
-      }
-  }
-  let currentRenderingInstance = null;
-  function renderMixin(Vue) {
-      // install runtime convenience helpers
-      installRenderHelpers(Vue.prototype);
-      Vue.prototype.$nextTick = function (fn) {
-          return nextTick(fn, this);
-      };
-      Vue.prototype._render = function () {
-          const vm = this;
-          const { render, _parentVnode } = vm.$options;
-          if (_parentVnode) {
-              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-          }
-          // set parent vnode. this allows render functions to have access
-          // to the data on the placeholder node.
-          vm.$vnode = _parentVnode;
-          // render self
-          let vnode;
-          try {
-              // There's no need to maintain a stack because all render fns are called
-              // separately from one another. Nested component's render fns are called
-              // when parent component is patched.
-              currentRenderingInstance = vm;
-              vnode = render.call(vm._renderProxy, vm.$createElement);
-          }
-          catch (e) {
-              handleError(e, vm, `render`);
-              // return error render result,
-              // or previous vnode to prevent render error causing blank component
-              /* istanbul ignore else */
-              if (vm.$options.renderError) {
-                  try {
-                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                  }
-                  catch (e) {
-                      handleError(e, vm, `renderError`);
-                      vnode = vm._vnode;
-                  }
-              }
-              else {
-                  vnode = vm._vnode;
-              }
-          }
-          finally {
-              currentRenderingInstance = null;
-          }
-          // if the returned array contains only a single node, allow it
-          if (Array.isArray(vnode) && vnode.length === 1) {
-              vnode = vnode[0];
-          }
-          // return empty vnode in case the render function errored out
-          if (!(vnode instanceof VNode)) {
-              if (Array.isArray(vnode)) {
-                  warn('Multiple root nodes returned from render function. Render function ' +
-                      'should return a single root node.', vm);
-              }
-              vnode = createEmptyVNode();
-          }
-          // set parent
-          vnode.parent = _parentVnode;
-          return vnode;
-      };
+  function initRender(vm) {
+      vm._vnode = null; // the root of the child tree
+      vm._staticTrees = null; // v-once cached trees
+      const options = vm.$options;
+      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
+      const renderContext = parentVnode && parentVnode.context;
+      vm.$slots = resolveSlots(options._renderChildren, renderContext);
+      vm.$scopedSlots = emptyObject;
+      // bind the createElement fn to this instance
+      // so that we get proper render context inside it.
+      // args order: tag, data, children, normalizationType, alwaysNormalize
+      // internal version is used by render functions compiled from templates
+      // @ts-expect-error
+      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
+      // normalization is always applied for the public version, used in
+      // user-written render functions.
+      // @ts-expect-error
+      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
+      // $attrs & $listeners are exposed for easier HOC creation.
+      // they need to be reactive so that HOCs using them are always updated
+      const parentData = parentVnode && parentVnode.data;
+      /* istanbul ignore else */
+      {
+          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
+              !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
+          }, true);
+          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
+              !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
+          }, true);
+      }
+  }
+  let currentRenderingInstance = null;
+  function renderMixin(Vue) {
+      // install runtime convenience helpers
+      installRenderHelpers(Vue.prototype);
+      Vue.prototype.$nextTick = function (fn) {
+          return nextTick(fn, this);
+      };
+      Vue.prototype._render = function () {
+          const vm = this;
+          const { render, _parentVnode } = vm.$options;
+          if (_parentVnode) {
+              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
+          }
+          // set parent vnode. this allows render functions to have access
+          // to the data on the placeholder node.
+          vm.$vnode = _parentVnode;
+          // render self
+          let vnode;
+          try {
+              // There's no need to maintain a stack because all render fns are called
+              // separately from one another. Nested component's render fns are called
+              // when parent component is patched.
+              currentRenderingInstance = vm;
+              vnode = render.call(vm._renderProxy, vm.$createElement);
+          }
+          catch (e) {
+              handleError(e, vm, `render`);
+              // return error render result,
+              // or previous vnode to prevent render error causing blank component
+              /* istanbul ignore else */
+              if (vm.$options.renderError) {
+                  try {
+                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
+                  }
+                  catch (e) {
+                      handleError(e, vm, `renderError`);
+                      vnode = vm._vnode;
+                  }
+              }
+              else {
+                  vnode = vm._vnode;
+              }
+          }
+          finally {
+              currentRenderingInstance = null;
+          }
+          // if the returned array contains only a single node, allow it
+          if (Array.isArray(vnode) && vnode.length === 1) {
+              vnode = vnode[0];
+          }
+          // return empty vnode in case the render function errored out
+          if (!(vnode instanceof VNode)) {
+              if (Array.isArray(vnode)) {
+                  warn('Multiple root nodes returned from render function. Render function ' +
+                      'should return a single root node.', vm);
+              }
+              vnode = createEmptyVNode();
+          }
+          // set parent
+          vnode.parent = _parentVnode;
+          return vnode;
+      };
   }
 
-  function ensureCtor(comp, base) {
-      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-          comp = comp.default;
-      }
-      return isObject(comp) ? base.extend(comp) : comp;
-  }
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      const owner = currentRenderingInstance;
-      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-          // already pending
-          factory.owners.push(owner);
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-      if (owner && !isDef(factory.owners)) {
-          const owners = (factory.owners = [owner]);
-          let sync = true;
-          let timerLoading = null;
-          let timerTimeout = null;
-          owner.$on('hook:destroyed', () => remove$2(owners, owner));
-          const forceRender = (renderCompleted) => {
-              for (let i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
-              }
-              if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
-                  }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
-                  }
-              }
-          };
-          const resolve = once((res) => {
-              // cache resolved
-              factory.resolved = ensureCtor(res, baseCtor);
-              // invoke callbacks only if this is not a synchronous resolve
-              // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
-              }
-              else {
-                  owners.length = 0;
-              }
-          });
-          const reject = once((reason) => {
-              warn(`Failed to resolve async component: ${String(factory)}` +
-                      (reason ? `\nReason: ${reason}` : ''));
-              if (isDef(factory.errorComp)) {
-                  factory.error = true;
-                  forceRender(true);
-              }
-          });
-          const res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
-                  // () => Promise
-                  if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
-                  }
-              }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
-                  }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
-                          factory.loading = true;
-                      }
-                      else {
-                          // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(() => {
-                              timerLoading = null;
-                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                  factory.loading = true;
-                                  forceRender(false);
-                              }
-                          }, res.delay || 200);
-                      }
-                  }
-                  if (isDef(res.timeout)) {
-                      // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(() => {
-                          timerTimeout = null;
-                          if (isUndef(factory.resolved)) {
-                              reject(`timeout (${res.timeout}ms)`
-                                  );
-                          }
-                      }, res.timeout);
-                  }
-              }
-          }
-          sync = false;
-          // return in case resolved synchronously
-          return factory.loading ? factory.loadingComp : factory.resolved;
-      }
+  function ensureCtor(comp, base) {
+      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
+          comp = comp.default;
+      }
+      return isObject(comp) ? base.extend(comp) : comp;
+  }
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      const node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data, context, children, tag };
+      return node;
+  }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      const owner = currentRenderingInstance;
+      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
+          // already pending
+          factory.owners.push(owner);
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+      if (owner && !isDef(factory.owners)) {
+          const owners = (factory.owners = [owner]);
+          let sync = true;
+          let timerLoading = null;
+          let timerTimeout = null;
+          owner.$on('hook:destroyed', () => remove$2(owners, owner));
+          const forceRender = (renderCompleted) => {
+              for (let i = 0, l = owners.length; i < l; i++) {
+                  owners[i].$forceUpdate();
+              }
+              if (renderCompleted) {
+                  owners.length = 0;
+                  if (timerLoading !== null) {
+                      clearTimeout(timerLoading);
+                      timerLoading = null;
+                  }
+                  if (timerTimeout !== null) {
+                      clearTimeout(timerTimeout);
+                      timerTimeout = null;
+                  }
+              }
+          };
+          const resolve = once((res) => {
+              // cache resolved
+              factory.resolved = ensureCtor(res, baseCtor);
+              // invoke callbacks only if this is not a synchronous resolve
+              // (async resolves are shimmed as synchronous during SSR)
+              if (!sync) {
+                  forceRender(true);
+              }
+              else {
+                  owners.length = 0;
+              }
+          });
+          const reject = once((reason) => {
+              warn(`Failed to resolve async component: ${String(factory)}` +
+                      (reason ? `\nReason: ${reason}` : ''));
+              if (isDef(factory.errorComp)) {
+                  factory.error = true;
+                  forceRender(true);
+              }
+          });
+          const res = factory(resolve, reject);
+          if (isObject(res)) {
+              if (isPromise(res)) {
+                  // () => Promise
+                  if (isUndef(factory.resolved)) {
+                      res.then(resolve, reject);
+                  }
+              }
+              else if (isPromise(res.component)) {
+                  res.component.then(resolve, reject);
+                  if (isDef(res.error)) {
+                      factory.errorComp = ensureCtor(res.error, baseCtor);
+                  }
+                  if (isDef(res.loading)) {
+                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
+                      if (res.delay === 0) {
+                          factory.loading = true;
+                      }
+                      else {
+                          // @ts-expect-error NodeJS timeout type
+                          timerLoading = setTimeout(() => {
+                              timerLoading = null;
+                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
+                                  factory.loading = true;
+                                  forceRender(false);
+                              }
+                          }, res.delay || 200);
+                      }
+                  }
+                  if (isDef(res.timeout)) {
+                      // @ts-expect-error NodeJS timeout type
+                      timerTimeout = setTimeout(() => {
+                          timerTimeout = null;
+                          if (isUndef(factory.resolved)) {
+                              reject(`timeout (${res.timeout}ms)`
+                                  );
+                          }
+                      }, res.timeout);
+                  }
+              }
+          }
+          sync = false;
+          // return in case resolved synchronously
+          return factory.loading ? factory.loadingComp : factory.resolved;
+      }
   }
 
-  function getFirstComponentChild(children) {
-      if (Array.isArray(children)) {
-          for (let i = 0; i < children.length; i++) {
-              const c = children[i];
-              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                  return c;
-              }
-          }
-      }
+  function getFirstComponentChild(children) {
+      if (Array.isArray(children)) {
+          for (let i = 0; i < children.length; i++) {
+              const c = children[i];
+              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
+                  return c;
+              }
+          }
+      }
   }
 
-  function initEvents(vm) {
-      vm._events = Object.create(null);
-      vm._hasHookEvent = false;
-      // init parent attached events
-      const listeners = vm.$options._parentListeners;
-      if (listeners) {
-          updateComponentListeners(vm, listeners);
-      }
-  }
-  let target$1;
-  function add$1(event, fn) {
-      target$1.$on(event, fn);
-  }
-  function remove$1(event, fn) {
-      target$1.$off(event, fn);
-  }
-  function createOnceHandler$1(event, fn) {
-      const _target = target$1;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target$1 = vm;
-      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-      target$1 = undefined;
-  }
-  function eventsMixin(Vue) {
-      const hookRE = /^hook:/;
-      Vue.prototype.$on = function (event, fn) {
-          const vm = this;
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$on(event[i], fn);
-              }
-          }
-          else {
-              (vm._events[event] || (vm._events[event] = [])).push(fn);
-              // optimize hook:event cost by using a boolean flag marked at registration
-              // instead of a hash lookup
-              if (hookRE.test(event)) {
-                  vm._hasHookEvent = true;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$once = function (event, fn) {
-          const vm = this;
-          function on() {
-              vm.$off(event, on);
-              fn.apply(vm, arguments);
-          }
-          on.fn = fn;
-          vm.$on(event, on);
-          return vm;
-      };
-      Vue.prototype.$off = function (event, fn) {
-          const vm = this;
-          // all
-          if (!arguments.length) {
-              vm._events = Object.create(null);
-              return vm;
-          }
-          // array of events
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$off(event[i], fn);
-              }
-              return vm;
-          }
-          // specific event
-          const cbs = vm._events[event];
-          if (!cbs) {
-              return vm;
-          }
-          if (!fn) {
-              vm._events[event] = null;
-              return vm;
-          }
-          // specific handler
-          let cb;
-          let i = cbs.length;
-          while (i--) {
-              cb = cbs[i];
-              if (cb === fn || cb.fn === fn) {
-                  cbs.splice(i, 1);
-                  break;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$emit = function (event) {
-          const vm = this;
-          {
-              const lowerCaseEvent = event.toLowerCase();
-              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                      `Note that HTML attributes are case-insensitive and you cannot use ` +
-                      `v-on to listen to camelCase events when using in-DOM templates. ` +
-                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-              }
-          }
-          let cbs = vm._events[event];
-          if (cbs) {
-              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              const args = toArray(arguments, 1);
-              const info = `event handler for "${event}"`;
-              for (let i = 0, l = cbs.length; i < l; i++) {
-                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-              }
-          }
-          return vm;
-      };
+  function initEvents(vm) {
+      vm._events = Object.create(null);
+      vm._hasHookEvent = false;
+      // init parent attached events
+      const listeners = vm.$options._parentListeners;
+      if (listeners) {
+          updateComponentListeners(vm, listeners);
+      }
+  }
+  let target$1;
+  function add$1(event, fn) {
+      target$1.$on(event, fn);
+  }
+  function remove$1(event, fn) {
+      target$1.$off(event, fn);
+  }
+  function createOnceHandler$1(event, fn) {
+      const _target = target$1;
+      return function onceHandler() {
+          const res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
+  }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target$1 = vm;
+      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
+      target$1 = undefined;
+  }
+  function eventsMixin(Vue) {
+      const hookRE = /^hook:/;
+      Vue.prototype.$on = function (event, fn) {
+          const vm = this;
+          if (Array.isArray(event)) {
+              for (let i = 0, l = event.length; i < l; i++) {
+                  vm.$on(event[i], fn);
+              }
+          }
+          else {
+              (vm._events[event] || (vm._events[event] = [])).push(fn);
+              // optimize hook:event cost by using a boolean flag marked at registration
+              // instead of a hash lookup
+              if (hookRE.test(event)) {
+                  vm._hasHookEvent = true;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$once = function (event, fn) {
+          const vm = this;
+          function on() {
+              vm.$off(event, on);
+              fn.apply(vm, arguments);
+          }
+          on.fn = fn;
+          vm.$on(event, on);
+          return vm;
+      };
+      Vue.prototype.$off = function (event, fn) {
+          const vm = this;
+          // all
+          if (!arguments.length) {
+              vm._events = Object.create(null);
+              return vm;
+          }
+          // array of events
+          if (Array.isArray(event)) {
+              for (let i = 0, l = event.length; i < l; i++) {
+                  vm.$off(event[i], fn);
+              }
+              return vm;
+          }
+          // specific event
+          const cbs = vm._events[event];
+          if (!cbs) {
+              return vm;
+          }
+          if (!fn) {
+              vm._events[event] = null;
+              return vm;
+          }
+          // specific handler
+          let cb;
+          let i = cbs.length;
+          while (i--) {
+              cb = cbs[i];
+              if (cb === fn || cb.fn === fn) {
+                  cbs.splice(i, 1);
+                  break;
+              }
+          }
+          return vm;
+      };
+      Vue.prototype.$emit = function (event) {
+          const vm = this;
+          {
+              const lowerCaseEvent = event.toLowerCase();
+              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
+                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
+                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
+                      `Note that HTML attributes are case-insensitive and you cannot use ` +
+                      `v-on to listen to camelCase events when using in-DOM templates. ` +
+                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
+              }
+          }
+          let cbs = vm._events[event];
+          if (cbs) {
+              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
+              const args = toArray(arguments, 1);
+              const info = `event handler for "${event}"`;
+              for (let i = 0, l = cbs.length; i < l; i++) {
+                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
+              }
+          }
+          return vm;
+      };
   }
 
-  let activeInstance = null;
-  let isUpdatingChildComponent = false;
-  function setActiveInstance(vm) {
-      const prevActiveInstance = activeInstance;
-      activeInstance = vm;
-      return () => {
-          activeInstance = prevActiveInstance;
-      };
-  }
-  function initLifecycle(vm) {
-      const options = vm.$options;
-      // locate first non-abstract parent
-      let parent = options.parent;
-      if (parent && !options.abstract) {
-          while (parent.$options.abstract && parent.$parent) {
-              parent = parent.$parent;
-          }
-          parent.$children.push(vm);
-      }
-      vm.$parent = parent;
-      vm.$root = parent ? parent.$root : vm;
-      vm.$children = [];
-      vm.$refs = {};
-      vm._watcher = null;
-      vm._inactive = null;
-      vm._directInactive = false;
-      vm._isMounted = false;
-      vm._isDestroyed = false;
-      vm._isBeingDestroyed = false;
-  }
-  function lifecycleMixin(Vue) {
-      Vue.prototype._update = function (vnode, hydrating) {
-          const vm = this;
-          const prevEl = vm.$el;
-          const prevVnode = vm._vnode;
-          const restoreActiveInstance = setActiveInstance(vm);
-          vm._vnode = vnode;
-          // Vue.prototype.__patch__ is injected in entry points
-          // based on the rendering backend used.
-          if (!prevVnode) {
-              // initial render
-              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-          }
-          else {
-              // updates
-              vm.$el = vm.__patch__(prevVnode, vnode);
-          }
-          restoreActiveInstance();
-          // update __vue__ reference
-          if (prevEl) {
-              prevEl.__vue__ = null;
-          }
-          if (vm.$el) {
-              vm.$el.__vue__ = vm;
-          }
-          // if parent is an HOC, update its $el as well
-          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-              vm.$parent.$el = vm.$el;
-          }
-          // updated hook is called by the scheduler to ensure that children are
-          // updated in a parent's updated hook.
-      };
-      Vue.prototype.$forceUpdate = function () {
-          const vm = this;
-          if (vm._watcher) {
-              vm._watcher.update();
-          }
-      };
-      Vue.prototype.$destroy = function () {
-          const vm = this;
-          if (vm._isBeingDestroyed) {
-              return;
-          }
-          callHook$1(vm, "beforeDestroy");
-          vm._isBeingDestroyed = true;
-          // remove self from parent
-          const parent = vm.$parent;
-          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove$2(parent.$children, vm);
-          }
-          // teardown watchers
-          if (vm._watcher) {
-              vm._watcher.teardown();
-          }
-          let i = vm._watchers.length;
-          while (i--) {
-              vm._watchers[i].teardown();
-          }
-          // remove reference from data ob
-          // frozen object may not have observer.
-          if (vm._data.__ob__) {
-              vm._data.__ob__.vmCount--;
-          }
-          // call the last hook...
-          vm._isDestroyed = true;
-          // invoke destroy hooks on current rendered tree
-          vm.__patch__(vm._vnode, null);
-          // fire destroyed hook
-          callHook$1(vm, "destroyed");
-          // turn off all instance listeners.
-          vm.$off();
-          // remove __vue__ reference
-          if (vm.$el) {
-              vm.$el.__vue__ = null;
-          }
-          // release circular reference (#6759)
-          if (vm.$vnode) {
-              vm.$vnode.parent = null;
-          }
-      };
-  }
-  function mountComponent(vm, el, hydrating) {
-      vm.$el = el;
-      if (!vm.$options.render) {
-          // @ts-expect-error invalid type
-          vm.$options.render = createEmptyVNode;
-          {
-              /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                  vm.$options.el ||
-                  el) {
-                  warn("You are using the runtime-only build of Vue where the template " +
-                      "compiler is not available. Either pre-compile the templates into " +
-                      "render functions, or use the compiler-included build.", vm);
-              }
-              else {
-                  warn("Failed to mount component: template or render function not defined.", vm);
-              }
-          }
-      }
-      callHook$1(vm, "beforeMount");
-      let updateComponent;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-          updateComponent = () => {
-              const name = vm._name;
-              const id = vm._uid;
-              const startTag = `vue-perf-start:${id}`;
-              const endTag = `vue-perf-end:${id}`;
-              mark(startTag);
-              const vnode = vm._render();
-              mark(endTag);
-              measure(`vue ${name} render`, startTag, endTag);
-              mark(startTag);
-              vm._update(vnode, hydrating);
-              mark(endTag);
-              measure(`vue ${name} patch`, startTag, endTag);
-          };
-      }
-      else {
-          updateComponent = () => {
-              vm._update(vm._render(), hydrating);
-          };
-      }
-      // we set this to vm._watcher inside the watcher's constructor
-      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-      // component's mounted hook), which relies on vm._watcher being already defined
-      new Watcher(vm, updateComponent, noop, {
-          before() {
-              if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, "beforeUpdate");
-              }
-          },
-      }, true /* isRenderWatcher */);
-      hydrating = false;
-      // manually mounted instance, call mounted on self
-      // mounted is called for render-created child components in its inserted hook
-      if (vm.$vnode == null) {
-          vm._isMounted = true;
-          callHook$1(vm, "mounted");
-      }
-      return vm;
-  }
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      {
-          isUpdatingChildComponent = true;
-      }
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-      {
-          isUpdatingChildComponent = false;
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "deactivated");
-      }
-  }
-  function callHook$1(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
+  let activeInstance = null;
+  let isUpdatingChildComponent = false;
+  function setActiveInstance(vm) {
+      const prevActiveInstance = activeInstance;
+      activeInstance = vm;
+      return () => {
+          activeInstance = prevActiveInstance;
+      };
+  }
+  function initLifecycle(vm) {
+      const options = vm.$options;
+      // locate first non-abstract parent
+      let parent = options.parent;
+      if (parent && !options.abstract) {
+          while (parent.$options.abstract && parent.$parent) {
+              parent = parent.$parent;
+          }
+          parent.$children.push(vm);
+      }
+      vm.$parent = parent;
+      vm.$root = parent ? parent.$root : vm;
+      vm.$children = [];
+      vm.$refs = {};
+      vm._watcher = null;
+      vm._inactive = null;
+      vm._directInactive = false;
+      vm._isMounted = false;
+      vm._isDestroyed = false;
+      vm._isBeingDestroyed = false;
+  }
+  function lifecycleMixin(Vue) {
+      Vue.prototype._update = function (vnode, hydrating) {
+          const vm = this;
+          const prevEl = vm.$el;
+          const prevVnode = vm._vnode;
+          const restoreActiveInstance = setActiveInstance(vm);
+          vm._vnode = vnode;
+          // Vue.prototype.__patch__ is injected in entry points
+          // based on the rendering backend used.
+          if (!prevVnode) {
+              // initial render
+              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+          }
+          else {
+              // updates
+              vm.$el = vm.__patch__(prevVnode, vnode);
+          }
+          restoreActiveInstance();
+          // update __vue__ reference
+          if (prevEl) {
+              prevEl.__vue__ = null;
+          }
+          if (vm.$el) {
+              vm.$el.__vue__ = vm;
+          }
+          // if parent is an HOC, update its $el as well
+          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
+              vm.$parent.$el = vm.$el;
+          }
+          // updated hook is called by the scheduler to ensure that children are
+          // updated in a parent's updated hook.
+      };
+      Vue.prototype.$forceUpdate = function () {
+          const vm = this;
+          if (vm._watcher) {
+              vm._watcher.update();
+          }
+      };
+      Vue.prototype.$destroy = function () {
+          const vm = this;
+          if (vm._isBeingDestroyed) {
+              return;
+          }
+          callHook$1(vm, "beforeDestroy");
+          vm._isBeingDestroyed = true;
+          // remove self from parent
+          const parent = vm.$parent;
+          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
+              remove$2(parent.$children, vm);
+          }
+          // teardown watchers
+          if (vm._watcher) {
+              vm._watcher.teardown();
+          }
+          let i = vm._watchers.length;
+          while (i--) {
+              vm._watchers[i].teardown();
+          }
+          // remove reference from data ob
+          // frozen object may not have observer.
+          if (vm._data.__ob__) {
+              vm._data.__ob__.vmCount--;
+          }
+          // call the last hook...
+          vm._isDestroyed = true;
+          // invoke destroy hooks on current rendered tree
+          vm.__patch__(vm._vnode, null);
+          // fire destroyed hook
+          callHook$1(vm, "destroyed");
+          // turn off all instance listeners.
+          vm.$off();
+          // remove __vue__ reference
+          if (vm.$el) {
+              vm.$el.__vue__ = null;
+          }
+          // release circular reference (#6759)
+          if (vm.$vnode) {
+              vm.$vnode.parent = null;
+          }
+      };
+  }
+  function mountComponent(vm, el, hydrating) {
+      vm.$el = el;
+      if (!vm.$options.render) {
+          // @ts-expect-error invalid type
+          vm.$options.render = createEmptyVNode;
+          {
+              /* istanbul ignore if */
+              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+                  vm.$options.el ||
+                  el) {
+                  warn("You are using the runtime-only build of Vue where the template " +
+                      "compiler is not available. Either pre-compile the templates into " +
+                      "render functions, or use the compiler-included build.", vm);
+              }
+              else {
+                  warn("Failed to mount component: template or render function not defined.", vm);
+              }
+          }
+      }
+      callHook$1(vm, "beforeMount");
+      let updateComponent;
+      /* istanbul ignore if */
+      if (config.performance && mark) {
+          updateComponent = () => {
+              const name = vm._name;
+              const id = vm._uid;
+              const startTag = `vue-perf-start:${id}`;
+              const endTag = `vue-perf-end:${id}`;
+              mark(startTag);
+              const vnode = vm._render();
+              mark(endTag);
+              measure(`vue ${name} render`, startTag, endTag);
+              mark(startTag);
+              vm._update(vnode, hydrating);
+              mark(endTag);
+              measure(`vue ${name} patch`, startTag, endTag);
+          };
+      }
+      else {
+          updateComponent = () => {
+              vm._update(vm._render(), hydrating);
+          };
+      }
+      // we set this to vm._watcher inside the watcher's constructor
+      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
+      // component's mounted hook), which relies on vm._watcher being already defined
+      new Watcher(vm, updateComponent, noop, {
+          before() {
+              if (vm._isMounted && !vm._isDestroyed) {
+                  callHook$1(vm, "beforeUpdate");
+              }
+          },
+      }, true /* isRenderWatcher */);
+      hydrating = false;
+      // manually mounted instance, call mounted on self
+      // mounted is called for render-created child components in its inserted hook
+      if (vm.$vnode == null) {
+          vm._isMounted = true;
+          callHook$1(vm, "mounted");
+      }
+      return vm;
+  }
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      {
+          isUpdatingChildComponent = true;
+      }
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      const needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      vm.$options._parentVnode = parentVnode;
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      const oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+      {
+          isUpdatingChildComponent = false;
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              return true;
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (let i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook$1(vm, "activated");
+      }
+  }
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (let i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook$1(vm, "deactivated");
+      }
+  }
+  function callHook$1(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
+      if (handlers) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit("hook:" + hook);
+      }
+      popTarget();
   }
 
-  const MAX_UPDATE_COUNT = 100;
-  const queue = [];
-  const activatedChildren = [];
-  let has = {};
-  let circular = {};
-  let waiting = false;
-  let flushing = false;
-  let index = 0;
-  /**
-   * Reset the scheduler's state.
-   */
-  function resetSchedulerState() {
-      index = queue.length = activatedChildren.length = 0;
-      has = {};
-      {
-          circular = {};
-      }
-      waiting = flushing = false;
-  }
-  // Async edge case #6566 requires saving the timestamp when event listeners are
-  // attached. However, calling performance.now() has a perf overhead especially
-  // if the page has thousands of event listeners. Instead, we take a timestamp
-  // every time the scheduler flushes and use that for all event listeners
-  // attached during that flush.
-  let currentFlushTimestamp = 0;
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Flush both queues and run the watchers.
-   */
-  function flushSchedulerQueue() {
-      currentFlushTimestamp = getNow();
-      flushing = true;
-      let watcher, id;
-      // Sort queue before flush.
-      // This ensures that:
-      // 1. Components are updated from parent to child. (because parent is always
-      //    created before the child)
-      // 2. A component's user watchers are run before its render watcher (because
-      //    user watchers are created before the render watcher)
-      // 3. If a component is destroyed during a parent component's watcher run,
-      //    its watchers can be skipped.
-      queue.sort((a, b) => a.id - b.id);
-      // do not cache length because more watchers might be pushed
-      // as we run existing watchers
-      for (index = 0; index < queue.length; index++) {
-          watcher = queue[index];
-          if (watcher.before) {
-              watcher.before();
-          }
-          id = watcher.id;
-          has[id] = null;
-          watcher.run();
-          // in dev build, check and stop circular updates.
-          if (has[id] != null) {
-              circular[id] = (circular[id] || 0) + 1;
-              if (circular[id] > MAX_UPDATE_COUNT) {
-                  warn('You may have an infinite update loop ' +
-                      (watcher.user
-                          ? `in watcher with expression "${watcher.expression}"`
-                          : `in a component render function.`), watcher.vm);
-                  break;
-              }
-          }
-      }
-      // keep copies of post queues before resetting state
-      const activatedQueue = activatedChildren.slice();
-      const updatedQueue = queue.slice();
-      resetSchedulerState();
-      // call component updated and activated hooks
-      callActivatedHooks(activatedQueue);
-      callUpdatedHooks(updatedQueue);
-      // devtool hook
-      /* istanbul ignore if */
-      if (devtools && config.devtools) {
-          devtools.emit('flush');
-      }
-  }
-  function callUpdatedHooks(queue) {
-      let i = queue.length;
-      while (i--) {
-          const watcher = queue[i];
-          const vm = watcher.vm;
-          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook$1(vm, 'updated');
-          }
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-      activatedChildren.push(vm);
-  }
-  function callActivatedHooks(queue) {
-      for (let i = 0; i < queue.length; i++) {
-          queue[i]._inactive = true;
-          activateChildComponent(queue[i], true /* true */);
-      }
-  }
-  /**
-   * Push a watcher into the watcher queue.
-   * Jobs with duplicate IDs will be skipped unless it's
-   * pushed when the queue is being flushed.
-   */
-  function queueWatcher(watcher) {
-      const id = watcher.id;
-      if (has[id] == null) {
-          has[id] = true;
-          if (!flushing) {
-              queue.push(watcher);
-          }
-          else {
-              // if already flushing, splice the watcher based on its id
-              // if already past its id, it will be run next immediately.
-              let i = queue.length - 1;
-              while (i > index && queue[i].id > watcher.id) {
-                  i--;
-              }
-              queue.splice(i + 1, 0, watcher);
-          }
-          // queue the flush
-          if (!waiting) {
-              waiting = true;
-              if (!config.async) {
-                  flushSchedulerQueue();
-                  return;
-              }
-              nextTick(flushSchedulerQueue);
-          }
-      }
+  const MAX_UPDATE_COUNT = 100;
+  const queue = [];
+  const activatedChildren = [];
+  let has = {};
+  let circular = {};
+  let waiting = false;
+  let flushing = false;
+  let index = 0;
+  /**
+   * Reset the scheduler's state.
+   */
+  function resetSchedulerState() {
+      index = queue.length = activatedChildren.length = 0;
+      has = {};
+      {
+          circular = {};
+      }
+      waiting = flushing = false;
+  }
+  // Async edge case #6566 requires saving the timestamp when event listeners are
+  // attached. However, calling performance.now() has a perf overhead especially
+  // if the page has thousands of event listeners. Instead, we take a timestamp
+  // every time the scheduler flushes and use that for all event listeners
+  // attached during that flush.
+  let currentFlushTimestamp = 0;
+  // Async edge case fix requires storing an event listener's attach timestamp.
+  let getNow = Date.now;
+  // Determine what event timestamp the browser is using. Annoyingly, the
+  // timestamp can either be hi-res (relative to page load) or low-res
+  // (relative to UNIX epoch), so in order to compare time we have to use the
+  // same timestamp type when saving the flush timestamp.
+  // All IE versions use low-res event timestamps, and have problematic clock
+  // implementations (#9632)
+  if (inBrowser && !isIE) {
+      const performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = () => performance.now();
+      }
+  }
+  /**
+   * Flush both queues and run the watchers.
+   */
+  function flushSchedulerQueue() {
+      currentFlushTimestamp = getNow();
+      flushing = true;
+      let watcher, id;
+      // Sort queue before flush.
+      // This ensures that:
+      // 1. Components are updated from parent to child. (because parent is always
+      //    created before the child)
+      // 2. A component's user watchers are run before its render watcher (because
+      //    user watchers are created before the render watcher)
+      // 3. If a component is destroyed during a parent component's watcher run,
+      //    its watchers can be skipped.
+      queue.sort((a, b) => a.id - b.id);
+      // do not cache length because more watchers might be pushed
+      // as we run existing watchers
+      for (index = 0; index < queue.length; index++) {
+          watcher = queue[index];
+          if (watcher.before) {
+              watcher.before();
+          }
+          id = watcher.id;
+          has[id] = null;
+          watcher.run();
+          // in dev build, check and stop circular updates.
+          if (has[id] != null) {
+              circular[id] = (circular[id] || 0) + 1;
+              if (circular[id] > MAX_UPDATE_COUNT) {
+                  warn('You may have an infinite update loop ' +
+                      (watcher.user
+                          ? `in watcher with expression "${watcher.expression}"`
+                          : `in a component render function.`), watcher.vm);
+                  break;
+              }
+          }
+      }
+      // keep copies of post queues before resetting state
+      const activatedQueue = activatedChildren.slice();
+      const updatedQueue = queue.slice();
+      resetSchedulerState();
+      // call component updated and activated hooks
+      callActivatedHooks(activatedQueue);
+      callUpdatedHooks(updatedQueue);
+      // devtool hook
+      /* istanbul ignore if */
+      if (devtools && config.devtools) {
+          devtools.emit('flush');
+      }
+  }
+  function callUpdatedHooks(queue) {
+      let i = queue.length;
+      while (i--) {
+          const watcher = queue[i];
+          const vm = watcher.vm;
+          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+              callHook$1(vm, 'updated');
+          }
+      }
+  }
+  /**
+   * Queue a kept-alive component that was activated during patch.
+   * The queue will be processed after the entire tree has been patched.
+   */
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+      activatedChildren.push(vm);
+  }
+  function callActivatedHooks(queue) {
+      for (let i = 0; i < queue.length; i++) {
+          queue[i]._inactive = true;
+          activateChildComponent(queue[i], true /* true */);
+      }
+  }
+  /**
+   * Push a watcher into the watcher queue.
+   * Jobs with duplicate IDs will be skipped unless it's
+   * pushed when the queue is being flushed.
+   */
+  function queueWatcher(watcher) {
+      const id = watcher.id;
+      if (has[id] == null) {
+          has[id] = true;
+          if (!flushing) {
+              queue.push(watcher);
+          }
+          else {
+              // if already flushing, splice the watcher based on its id
+              // if already past its id, it will be run next immediately.
+              let i = queue.length - 1;
+              while (i > index && queue[i].id > watcher.id) {
+                  i--;
+              }
+              queue.splice(i + 1, 0, watcher);
+          }
+          // queue the flush
+          if (!waiting) {
+              waiting = true;
+              if (!config.async) {
+                  flushSchedulerQueue();
+                  return;
+              }
+              nextTick(flushSchedulerQueue);
+          }
+      }
   }
 
-  let uid$1 = 0;
-  /**
-   * A watcher parses an expression, collects dependencies,
-   * and fires callback when the expression value changes.
-   * This is used for both the $watch() api and directives.
-   */
-  class Watcher {
-      vm;
-      expression;
-      cb;
-      id;
-      deep;
-      user;
-      lazy;
-      sync;
-      dirty;
-      active;
-      deps;
-      newDeps;
-      depIds;
-      newDepIds;
-      before;
-      getter;
-      value;
-      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-          this.vm = vm;
-          if (isRenderWatcher) {
-              vm._watcher = this;
-          }
-          vm._watchers.push(this);
-          // options
-          if (options) {
-              this.deep = !!options.deep;
-              this.user = !!options.user;
-              this.lazy = !!options.lazy;
-              this.sync = !!options.sync;
-              this.before = options.before;
-          }
-          else {
-              this.deep = this.user = this.lazy = this.sync = false;
-          }
-          this.cb = cb;
-          this.id = ++uid$1; // uid for batching
-          this.active = true;
-          this.dirty = this.lazy; // for lazy watchers
-          this.deps = [];
-          this.newDeps = [];
-          this.depIds = new _Set();
-          this.newDepIds = new _Set();
-          this.expression = expOrFn.toString()
-              ;
-          // parse expression for getter
-          if (typeof expOrFn === 'function') {
-              this.getter = expOrFn;
-          }
-          else {
-              this.getter = parsePath(expOrFn);
-              if (!this.getter) {
-                  this.getter = noop;
-                  warn(`Failed watching path: "${expOrFn}" ` +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
-              }
-          }
-          this.value = this.lazy
-              ? undefined
-              : this.get();
-      }
-      /**
-       * Evaluate the getter, and re-collect dependencies.
-       */
-      get() {
-          pushTarget(this);
-          let value;
-          const vm = this.vm;
-          try {
-              value = this.getter.call(vm, vm);
-          }
-          catch (e) {
-              if (this.user) {
-                  // @ts-expect-error e is unknown, should we cast or any?
-                  handleError(e, vm, `getter for watcher "${this.expression}"`);
-              }
-              else {
-                  throw e;
-              }
-          }
-          finally {
-              // "touch" every property so they are all tracked as
-              // dependencies for deep watching
-              if (this.deep) {
-                  traverse(value);
-              }
-              popTarget();
-              this.cleanupDeps();
-          }
-          return value;
-      }
-      /**
-       * Add a dependency to this directive.
-       */
-      addDep(dep) {
-          const id = dep.id;
-          if (!this.newDepIds.has(id)) {
-              this.newDepIds.add(id);
-              this.newDeps.push(dep);
-              if (!this.depIds.has(id)) {
-                  dep.addSub(this);
-              }
-          }
-      }
-      /**
-       * Clean up for dependency collection.
-       */
-      cleanupDeps() {
-          let i = this.deps.length;
-          while (i--) {
-              const dep = this.deps[i];
-              if (!this.newDepIds.has(dep.id)) {
-                  dep.removeSub(this);
-              }
-          }
-          let tmp = this.depIds;
-          this.depIds = this.newDepIds;
-          this.newDepIds = tmp;
-          this.newDepIds.clear();
-          tmp = this.deps;
-          this.deps = this.newDeps;
-          this.newDeps = tmp;
-          this.newDeps.length = 0;
-      }
-      /**
-       * Subscriber interface.
-       * Will be called when a dependency changes.
-       */
-      update() {
-          /* istanbul ignore else */
-          if (this.lazy) {
-              this.dirty = true;
-          }
-          else if (this.sync) {
-              this.run();
-          }
-          else {
-              queueWatcher(this);
-          }
-      }
-      /**
-       * Scheduler job interface.
-       * Will be called by the scheduler.
-       */
-      run() {
-          if (this.active) {
-              const value = this.get();
-              if (value !== this.value ||
-                  // Deep watchers and watchers on Object/Arrays should fire even
-                  // when the value is the same, because the value may
-                  // have mutated.
-                  isObject(value) ||
-                  this.deep) {
-                  // set new value
-                  const oldValue = this.value;
-                  this.value = value;
-                  if (this.user) {
-                      const info = `callback for watcher "${this.expression}"`;
-                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                  }
-                  else {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-              }
-          }
-      }
-      /**
-       * Evaluate the value of the watcher.
-       * This only gets called for lazy watchers.
-       */
-      evaluate() {
-          this.value = this.get();
-          this.dirty = false;
-      }
-      /**
-       * Depend on all deps collected by this watcher.
-       */
-      depend() {
-          let i = this.deps.length;
-          while (i--) {
-              this.deps[i].depend();
-          }
-      }
-      /**
-       * Remove self from all dependencies' subscriber list.
-       */
-      teardown() {
-          if (this.active) {
-              // remove self from vm's watcher list
-              // this is a somewhat expensive operation so we skip it
-              // if the vm is being destroyed.
-              if (!this.vm._isBeingDestroyed) {
-                  remove$2(this.vm._watchers, this);
-              }
-              let i = this.deps.length;
-              while (i--) {
-                  this.deps[i].removeSub(this);
-              }
-              this.active = false;
-          }
-      }
+  let uid$1 = 0;
+  /**
+   * A watcher parses an expression, collects dependencies,
+   * and fires callback when the expression value changes.
+   * This is used for both the $watch() api and directives.
+   */
+  class Watcher {
+      vm;
+      expression;
+      cb;
+      id;
+      deep;
+      user;
+      lazy;
+      sync;
+      dirty;
+      active;
+      deps;
+      newDeps;
+      depIds;
+      newDepIds;
+      before;
+      getter;
+      value;
+      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
+          this.vm = vm;
+          if (isRenderWatcher) {
+              vm._watcher = this;
+          }
+          vm._watchers.push(this);
+          // options
+          if (options) {
+              this.deep = !!options.deep;
+              this.user = !!options.user;
+              this.lazy = !!options.lazy;
+              this.sync = !!options.sync;
+              this.before = options.before;
+          }
+          else {
+              this.deep = this.user = this.lazy = this.sync = false;
+          }
+          this.cb = cb;
+          this.id = ++uid$1; // uid for batching
+          this.active = true;
+          this.dirty = this.lazy; // for lazy watchers
+          this.deps = [];
+          this.newDeps = [];
+          this.depIds = new _Set();
+          this.newDepIds = new _Set();
+          this.expression = expOrFn.toString()
+              ;
+          // parse expression for getter
+          if (typeof expOrFn === 'function') {
+              this.getter = expOrFn;
+          }
+          else {
+              this.getter = parsePath(expOrFn);
+              if (!this.getter) {
+                  this.getter = noop;
+                  warn(`Failed watching path: "${expOrFn}" ` +
+                      'Watcher only accepts simple dot-delimited paths. ' +
+                      'For full control, use a function instead.', vm);
+              }
+          }
+          this.value = this.lazy
+              ? undefined
+              : this.get();
+      }
+      /**
+       * Evaluate the getter, and re-collect dependencies.
+       */
+      get() {
+          pushTarget(this);
+          let value;
+          const vm = this.vm;
+          try {
+              value = this.getter.call(vm, vm);
+          }
+          catch (e) {
+              if (this.user) {
+                  handleError(e, vm, `getter for watcher "${this.expression}"`);
+              }
+              else {
+                  throw e;
+              }
+          }
+          finally {
+              // "touch" every property so they are all tracked as
+              // dependencies for deep watching
+              if (this.deep) {
+                  traverse(value);
+              }
+              popTarget();
+              this.cleanupDeps();
+          }
+          return value;
+      }
+      /**
+       * Add a dependency to this directive.
+       */
+      addDep(dep) {
+          const id = dep.id;
+          if (!this.newDepIds.has(id)) {
+              this.newDepIds.add(id);
+              this.newDeps.push(dep);
+              if (!this.depIds.has(id)) {
+                  dep.addSub(this);
+              }
+          }
+      }
+      /**
+       * Clean up for dependency collection.
+       */
+      cleanupDeps() {
+          let i = this.deps.length;
+          while (i--) {
+              const dep = this.deps[i];
+              if (!this.newDepIds.has(dep.id)) {
+                  dep.removeSub(this);
+              }
+          }
+          let tmp = this.depIds;
+          this.depIds = this.newDepIds;
+          this.newDepIds = tmp;
+          this.newDepIds.clear();
+          tmp = this.deps;
+          this.deps = this.newDeps;
+          this.newDeps = tmp;
+          this.newDeps.length = 0;
+      }
+      /**
+       * Subscriber interface.
+       * Will be called when a dependency changes.
+       */
+      update() {
+          /* istanbul ignore else */
+          if (this.lazy) {
+              this.dirty = true;
+          }
+          else if (this.sync) {
+              this.run();
+          }
+          else {
+              queueWatcher(this);
+          }
+      }
+      /**
+       * Scheduler job interface.
+       * Will be called by the scheduler.
+       */
+      run() {
+          if (this.active) {
+              const value = this.get();
+              if (value !== this.value ||
+                  // Deep watchers and watchers on Object/Arrays should fire even
+                  // when the value is the same, because the value may
+                  // have mutated.
+                  isObject(value) ||
+                  this.deep) {
+                  // set new value
+                  const oldValue = this.value;
+                  this.value = value;
+                  if (this.user) {
+                      const info = `callback for watcher "${this.expression}"`;
+                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
+                  }
+                  else {
+                      this.cb.call(this.vm, value, oldValue);
+                  }
+              }
+          }
+      }
+      /**
+       * Evaluate the value of the watcher.
+       * This only gets called for lazy watchers.
+       */
+      evaluate() {
+          this.value = this.get();
+          this.dirty = false;
+      }
+      /**
+       * Depend on all deps collected by this watcher.
+       */
+      depend() {
+          let i = this.deps.length;
+          while (i--) {
+              this.deps[i].depend();
+          }
+      }
+      /**
+       * Remove self from all dependencies' subscriber list.
+       */
+      teardown() {
+          if (this.active) {
+              // remove self from vm's watcher list
+              // this is a somewhat expensive operation so we skip it
+              // if the vm is being destroyed.
+              if (!this.vm._isBeingDestroyed) {
+                  remove$2(this.vm._watchers, this);
+              }
+              let i = this.deps.length;
+              while (i--) {
+                  this.deps[i].removeSub(this);
+              }
+              this.active = false;
+          }
+      }
   }
 
-  const sharedPropertyDefinition = {
-      enumerable: true,
-      configurable: true,
-      get: noop,
-      set: noop,
-  };
-  function proxy(target, sourceKey, key) {
-      sharedPropertyDefinition.get = function proxyGetter() {
-          return this[sourceKey][key];
-      };
-      sharedPropertyDefinition.set = function proxySetter(val) {
-          this[sourceKey][key] = val;
-      };
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function initState(vm) {
-      vm._watchers = [];
-      const opts = vm.$options;
-      if (opts.props)
-          initProps$1(vm, opts.props);
-      if (opts.methods)
-          initMethods(vm, opts.methods);
-      if (opts.data) {
-          initData(vm);
-      }
-      else {
-          observe((vm._data = {}), true /* asRootData */);
-      }
-      if (opts.computed)
-          initComputed$1(vm, opts.computed);
-      if (opts.watch && opts.watch !== nativeWatch) {
-          initWatch(vm, opts.watch);
-      }
-  }
-  function initProps$1(vm, propsOptions) {
-      const propsData = vm.$options.propsData || {};
-      const props = (vm._props = {});
-      // cache prop keys so that future props updates can iterate using Array
-      // instead of dynamic object key enumeration.
-      const keys = (vm.$options._propKeys = []);
-      const isRoot = !vm.$parent;
-      // root instance props should be converted
-      if (!isRoot) {
-          toggleObserving(false);
-      }
-      for (const key in propsOptions) {
-          keys.push(key);
-          const value = validateProp(key, propsOptions, propsData, vm);
-          /* istanbul ignore else */
-          {
-              const hyphenatedKey = hyphenate(key);
-              if (isReservedAttribute(hyphenatedKey) ||
-                  config.isReservedAttr(hyphenatedKey)) {
-                  warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-              }
-              defineReactive(props, key, value, () => {
-                  if (!isRoot && !isUpdatingChildComponent) {
-                      warn(`Avoid mutating a prop directly since the value will be ` +
-                          `overwritten whenever the parent component re-renders. ` +
-                          `Instead, use a data or computed property based on the prop's ` +
-                          `value. Prop being mutated: "${key}"`, vm);
-                  }
-              });
-          }
-          // static props are already proxied on the component's prototype
-          // during Vue.extend(). We only need to proxy props defined at
-          // instantiation here.
-          if (!(key in vm)) {
-              proxy(vm, `_props`, key);
-          }
-      }
-      toggleObserving(true);
-  }
-  function initData(vm) {
-      let data = vm.$options.data;
-      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-      if (!isPlainObject(data)) {
-          data = {};
-          warn("data functions should return an object:\n" +
-                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-      }
-      // proxy data on instance
-      const keys = Object.keys(data);
-      const props = vm.$options.props;
-      const methods = vm.$options.methods;
-      let i = keys.length;
-      while (i--) {
-          const key = keys[i];
-          {
-              if (methods && hasOwn(methods, key)) {
-                  warn(`Method "${key}" has already been defined as a data property.`, vm);
-              }
-          }
-          if (props && hasOwn(props, key)) {
-              warn(`The data property "${key}" is already declared as a prop. ` +
-                      `Use prop default value instead.`, vm);
-          }
-          else if (!isReserved(key)) {
-              proxy(vm, `_data`, key);
-          }
-      }
-      // observe data
-      observe(data, true /* asRootData */);
-  }
-  function getData(data, vm) {
-      // #7573 disable dep collection when invoking data getters
-      pushTarget();
-      try {
-          return data.call(vm, vm);
-      }
-      catch (e) {
-          handleError(e, vm, `data()`);
-          return {};
-      }
-      finally {
-          popTarget();
-      }
-  }
-  const computedWatcherOptions = { lazy: true };
-  function initComputed$1(vm, computed) {
-      // $flow-disable-line
-      const watchers = (vm._computedWatchers = Object.create(null));
-      // computed properties are just getters during SSR
-      const isSSR = isServerRendering();
-      for (const key in computed) {
-          const userDef = computed[key];
-          const getter = typeof userDef === "function" ? userDef : userDef.get;
-          if (getter == null) {
-              warn(`Getter is missing for computed property "${key}".`, vm);
-          }
-          if (!isSSR) {
-              // create internal watcher for the computed property.
-              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-          }
-          // component-defined computed properties are already defined on the
-          // component prototype. We only need to define computed properties defined
-          // at instantiation here.
-          if (!(key in vm)) {
-              defineComputed(vm, key, userDef);
-          }
-          else {
-              if (key in vm.$data) {
-                  warn(`The computed property "${key}" is already defined in data.`, vm);
-              }
-              else if (vm.$options.props && key in vm.$options.props) {
-                  warn(`The computed property "${key}" is already defined as a prop.`, vm);
-              }
-              else if (vm.$options.methods && key in vm.$options.methods) {
-                  warn(`The computed property "${key}" is already defined as a method.`, vm);
-              }
-          }
-      }
-  }
-  function defineComputed(target, key, userDef) {
-      const shouldCache = !isServerRendering();
-      if (typeof userDef === "function") {
-          sharedPropertyDefinition.get = shouldCache
-              ? createComputedGetter(key)
-              : createGetterInvoker(userDef);
-          sharedPropertyDefinition.set = noop;
-      }
-      else {
-          sharedPropertyDefinition.get = userDef.get
-              ? shouldCache && userDef.cache !== false
-                  ? createComputedGetter(key)
-                  : createGetterInvoker(userDef.get)
-              : noop;
-          sharedPropertyDefinition.set = userDef.set || noop;
-      }
-      if (sharedPropertyDefinition.set === noop) {
-          sharedPropertyDefinition.set = function () {
-              warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
-          };
-      }
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function createComputedGetter(key) {
-      return function computedGetter() {
-          const watcher = this._computedWatchers && this._computedWatchers[key];
-          if (watcher) {
-              if (watcher.dirty) {
-                  watcher.evaluate();
-              }
-              if (Dep.target) {
-                  watcher.depend();
-              }
-              return watcher.value;
-          }
-      };
-  }
-  function createGetterInvoker(fn) {
-      return function computedGetter() {
-          return fn.call(this, this);
-      };
-  }
-  function initMethods(vm, methods) {
-      const props = vm.$options.props;
-      for (const key in methods) {
-          {
-              if (typeof methods[key] !== "function") {
-                  warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                      `Did you reference the function correctly?`, vm);
-              }
-              if (props && hasOwn(props, key)) {
-                  warn(`Method "${key}" has already been defined as a prop.`, vm);
-              }
-              if (key in vm && isReserved(key)) {
-                  warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                      `Avoid defining component methods that start with _ or $.`);
-              }
-          }
-          vm[key] =
-              typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-      }
-  }
-  function initWatch(vm, watch) {
-      for (const key in watch) {
-          const handler = watch[key];
-          if (Array.isArray(handler)) {
-              for (let i = 0; i < handler.length; i++) {
-                  createWatcher(vm, key, handler[i]);
-              }
-          }
-          else {
-              createWatcher(vm, key, handler);
-          }
-      }
-  }
-  function createWatcher(vm, expOrFn, handler, options) {
-      if (isPlainObject(handler)) {
-          options = handler;
-          handler = handler.handler;
-      }
-      if (typeof handler === "string") {
-          handler = vm[handler];
-      }
-      return vm.$watch(expOrFn, handler, options);
-  }
-  function stateMixin(Vue) {
-      // flow somehow has problems with directly declared definition object
-      // when using Object.defineProperty, so we have to procedurally build up
-      // the object here.
-      const dataDef = {};
-      dataDef.get = function () {
-          return this._data;
-      };
-      const propsDef = {};
-      propsDef.get = function () {
-          return this._props;
-      };
-      {
-          dataDef.set = function () {
-              warn("Avoid replacing instance root $data. " +
-                  "Use nested data properties instead.", this);
-          };
-          propsDef.set = function () {
-              warn(`$props is readonly.`, this);
-          };
-      }
-      Object.defineProperty(Vue.prototype, "$data", dataDef);
-      Object.defineProperty(Vue.prototype, "$props", propsDef);
-      Vue.prototype.$set = set;
-      Vue.prototype.$delete = del;
-      Vue.prototype.$watch = function (expOrFn, cb, options) {
-          const vm = this;
-          if (isPlainObject(cb)) {
-              return createWatcher(vm, expOrFn, cb, options);
-          }
-          options = options || {};
-          options.user = true;
-          const watcher = new Watcher(vm, expOrFn, cb, options);
-          if (options.immediate) {
-              const info = `callback for immediate watcher "${watcher.expression}"`;
-              pushTarget();
-              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-              popTarget();
-          }
-          return function unwatchFn() {
-              watcher.teardown();
-          };
-      };
+  const sharedPropertyDefinition = {
+      enumerable: true,
+      configurable: true,
+      get: noop,
+      set: noop,
+  };
+  function proxy(target, sourceKey, key) {
+      sharedPropertyDefinition.get = function proxyGetter() {
+          return this[sourceKey][key];
+      };
+      sharedPropertyDefinition.set = function proxySetter(val) {
+          this[sourceKey][key] = val;
+      };
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function initState(vm) {
+      vm._watchers = [];
+      const opts = vm.$options;
+      if (opts.props)
+          initProps$1(vm, opts.props);
+      if (opts.methods)
+          initMethods(vm, opts.methods);
+      if (opts.data) {
+          initData(vm);
+      }
+      else {
+          observe((vm._data = {}), true /* asRootData */);
+      }
+      if (opts.computed)
+          initComputed$1(vm, opts.computed);
+      if (opts.watch && opts.watch !== nativeWatch) {
+          initWatch(vm, opts.watch);
+      }
+  }
+  function initProps$1(vm, propsOptions) {
+      const propsData = vm.$options.propsData || {};
+      const props = (vm._props = {});
+      // cache prop keys so that future props updates can iterate using Array
+      // instead of dynamic object key enumeration.
+      const keys = (vm.$options._propKeys = []);
+      const isRoot = !vm.$parent;
+      // root instance props should be converted
+      if (!isRoot) {
+          toggleObserving(false);
+      }
+      for (const key in propsOptions) {
+          keys.push(key);
+          const value = validateProp(key, propsOptions, propsData, vm);
+          /* istanbul ignore else */
+          {
+              const hyphenatedKey = hyphenate(key);
+              if (isReservedAttribute(hyphenatedKey) ||
+                  config.isReservedAttr(hyphenatedKey)) {
+                  warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
+              }
+              defineReactive(props, key, value, () => {
+                  if (!isRoot && !isUpdatingChildComponent) {
+                      warn(`Avoid mutating a prop directly since the value will be ` +
+                          `overwritten whenever the parent component re-renders. ` +
+                          `Instead, use a data or computed property based on the prop's ` +
+                          `value. Prop being mutated: "${key}"`, vm);
+                  }
+              });
+          }
+          // static props are already proxied on the component's prototype
+          // during Vue.extend(). We only need to proxy props defined at
+          // instantiation here.
+          if (!(key in vm)) {
+              proxy(vm, `_props`, key);
+          }
+      }
+      toggleObserving(true);
+  }
+  function initData(vm) {
+      let data = vm.$options.data;
+      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+      if (!isPlainObject(data)) {
+          data = {};
+          warn("data functions should return an object:\n" +
+                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
+      }
+      // proxy data on instance
+      const keys = Object.keys(data);
+      const props = vm.$options.props;
+      const methods = vm.$options.methods;
+      let i = keys.length;
+      while (i--) {
+          const key = keys[i];
+          {
+              if (methods && hasOwn(methods, key)) {
+                  warn(`Method "${key}" has already been defined as a data property.`, vm);
+              }
+          }
+          if (props && hasOwn(props, key)) {
+              warn(`The data property "${key}" is already declared as a prop. ` +
+                      `Use prop default value instead.`, vm);
+          }
+          else if (!isReserved(key)) {
+              proxy(vm, `_data`, key);
+          }
+      }
+      // observe data
+      observe(data, true /* asRootData */);
+  }
+  function getData(data, vm) {
+      // #7573 disable dep collection when invoking data getters
+      pushTarget();
+      try {
+          return data.call(vm, vm);
+      }
+      catch (e) {
+          handleError(e, vm, `data()`);
+          return {};
+      }
+      finally {
+          popTarget();
+      }
+  }
+  const computedWatcherOptions = { lazy: true };
+  function initComputed$1(vm, computed) {
+      // $flow-disable-line
+      const watchers = (vm._computedWatchers = Object.create(null));
+      // computed properties are just getters during SSR
+      const isSSR = isServerRendering();
+      for (const key in computed) {
+          const userDef = computed[key];
+          const getter = typeof userDef === "function" ? userDef : userDef.get;
+          if (getter == null) {
+              warn(`Getter is missing for computed property "${key}".`, vm);
+          }
+          if (!isSSR) {
+              // create internal watcher for the computed property.
+              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
+          }
+          // component-defined computed properties are already defined on the
+          // component prototype. We only need to define computed properties defined
+          // at instantiation here.
+          if (!(key in vm)) {
+              defineComputed(vm, key, userDef);
+          }
+          else {
+              if (key in vm.$data) {
+                  warn(`The computed property "${key}" is already defined in data.`, vm);
+              }
+              else if (vm.$options.props && key in vm.$options.props) {
+                  warn(`The computed property "${key}" is already defined as a prop.`, vm);
+              }
+              else if (vm.$options.methods && key in vm.$options.methods) {
+                  warn(`The computed property "${key}" is already defined as a method.`, vm);
+              }
+          }
+      }
+  }
+  function defineComputed(target, key, userDef) {
+      const shouldCache = !isServerRendering();
+      if (typeof userDef === "function") {
+          sharedPropertyDefinition.get = shouldCache
+              ? createComputedGetter(key)
+              : createGetterInvoker(userDef);
+          sharedPropertyDefinition.set = noop;
+      }
+      else {
+          sharedPropertyDefinition.get = userDef.get
+              ? shouldCache && userDef.cache !== false
+                  ? createComputedGetter(key)
+                  : createGetterInvoker(userDef.get)
+              : noop;
+          sharedPropertyDefinition.set = userDef.set || noop;
+      }
+      if (sharedPropertyDefinition.set === noop) {
+          sharedPropertyDefinition.set = function () {
+              warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
+          };
+      }
+      Object.defineProperty(target, key, sharedPropertyDefinition);
+  }
+  function createComputedGetter(key) {
+      return function computedGetter() {
+          const watcher = this._computedWatchers && this._computedWatchers[key];
+          if (watcher) {
+              if (watcher.dirty) {
+                  watcher.evaluate();
+              }
+              if (Dep.target) {
+                  watcher.depend();
+              }
+              return watcher.value;
+          }
+      };
+  }
+  function createGetterInvoker(fn) {
+      return function computedGetter() {
+          return fn.call(this, this);
+      };
+  }
+  function initMethods(vm, methods) {
+      const props = vm.$options.props;
+      for (const key in methods) {
+          {
+              if (typeof methods[key] !== "function") {
+                  warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
+                      `Did you reference the function correctly?`, vm);
+              }
+              if (props && hasOwn(props, key)) {
+                  warn(`Method "${key}" has already been defined as a prop.`, vm);
+              }
+              if (key in vm && isReserved(key)) {
+                  warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
+                      `Avoid defining component methods that start with _ or $.`);
+              }
+          }
+          vm[key] =
+              typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
+      }
+  }
+  function initWatch(vm, watch) {
+      for (const key in watch) {
+          const handler = watch[key];
+          if (Array.isArray(handler)) {
+              for (let i = 0; i < handler.length; i++) {
+                  createWatcher(vm, key, handler[i]);
+              }
+          }
+          else {
+              createWatcher(vm, key, handler);
+          }
+      }
+  }
+  function createWatcher(vm, expOrFn, handler, options) {
+      if (isPlainObject(handler)) {
+          options = handler;
+          handler = handler.handler;
+      }
+      if (typeof handler === "string") {
+          handler = vm[handler];
+      }
+      return vm.$watch(expOrFn, handler, options);
+  }
+  function stateMixin(Vue) {
+      // flow somehow has problems with directly declared definition object
+      // when using Object.defineProperty, so we have to procedurally build up
+      // the object here.
+      const dataDef = {};
+      dataDef.get = function () {
+          return this._data;
+      };
+      const propsDef = {};
+      propsDef.get = function () {
+          return this._props;
+      };
+      {
+          dataDef.set = function () {
+              warn("Avoid replacing instance root $data. " +
+                  "Use nested data properties instead.", this);
+          };
+          propsDef.set = function () {
+              warn(`$props is readonly.`, this);
+          };
+      }
+      Object.defineProperty(Vue.prototype, "$data", dataDef);
+      Object.defineProperty(Vue.prototype, "$props", propsDef);
+      Vue.prototype.$set = set;
+      Vue.prototype.$delete = del;
+      Vue.prototype.$watch = function (expOrFn, cb, options) {
+          const vm = this;
+          if (isPlainObject(cb)) {
+              return createWatcher(vm, expOrFn, cb, options);
+          }
+          options = options || {};
+          options.user = true;
+          const watcher = new Watcher(vm, expOrFn, cb, options);
+          if (options.immediate) {
+              const info = `callback for immediate watcher "${watcher.expression}"`;
+              pushTarget();
+              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
+              popTarget();
+          }
+          return function unwatchFn() {
+              watcher.teardown();
+          };
+      };
   }
 
-  let uid = 0;
-  function initMixin$1(Vue) {
-      Vue.prototype._init = function (options) {
-          const vm = this;
-          // a uid
-          vm._uid = uid++;
-          let startTag, endTag;
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              startTag = `vue-perf-start:${vm._uid}`;
-              endTag = `vue-perf-end:${vm._uid}`;
-              mark(startTag);
-          }
-          // a flag to avoid this being observed
-          vm._isVue = true;
-          // merge options
-          if (options && options._isComponent) {
-              // optimize internal component instantiation
-              // since dynamic options merging is pretty slow, and none of the
-              // internal component options needs special treatment.
-              initInternalComponent(vm, options);
-          }
-          else {
-              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-          }
-          /* istanbul ignore else */
-          {
-              initProxy(vm);
-          }
-          // expose real self
-          vm._self = vm;
-          initLifecycle(vm);
-          initEvents(vm);
-          initRender(vm);
-          callHook$1(vm, 'beforeCreate');
-          initInjections(vm); // resolve injections before data/props
-          initState(vm);
-          initProvide(vm); // resolve provide after data/props
-          callHook$1(vm, 'created');
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              vm._name = formatComponentName(vm, false);
-              mark(endTag);
-              measure(`vue ${vm._name} init`, startTag, endTag);
-          }
-          if (vm.$options.el) {
-              vm.$mount(vm.$options.el);
-          }
-      };
-  }
-  function initInternalComponent(vm, options) {
-      const opts = (vm.$options = Object.create(vm.constructor.options));
-      // doing this because it's faster than dynamic enumeration.
-      const parentVnode = options._parentVnode;
-      opts.parent = options.parent;
-      opts._parentVnode = parentVnode;
-      const vnodeComponentOptions = parentVnode.componentOptions;
-      opts.propsData = vnodeComponentOptions.propsData;
-      opts._parentListeners = vnodeComponentOptions.listeners;
-      opts._renderChildren = vnodeComponentOptions.children;
-      opts._componentTag = vnodeComponentOptions.tag;
-      if (options.render) {
-          opts.render = options.render;
-          opts.staticRenderFns = options.staticRenderFns;
-      }
-  }
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
+  let uid = 0;
+  function initMixin$1(Vue) {
+      Vue.prototype._init = function (options) {
+          const vm = this;
+          // a uid
+          vm._uid = uid++;
+          let startTag, endTag;
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              startTag = `vue-perf-start:${vm._uid}`;
+              endTag = `vue-perf-end:${vm._uid}`;
+              mark(startTag);
+          }
+          // a flag to avoid this being observed
+          vm._isVue = true;
+          // merge options
+          if (options && options._isComponent) {
+              // optimize internal component instantiation
+              // since dynamic options merging is pretty slow, and none of the
+              // internal component options needs special treatment.
+              initInternalComponent(vm, options);
+          }
+          else {
+              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
+          }
+          /* istanbul ignore else */
+          {
+              initProxy(vm);
+          }
+          // expose real self
+          vm._self = vm;
+          initLifecycle(vm);
+          initEvents(vm);
+          initRender(vm);
+          callHook$1(vm, 'beforeCreate');
+          initInjections(vm); // resolve injections before data/props
+          initState(vm);
+          initProvide(vm); // resolve provide after data/props
+          callHook$1(vm, 'created');
+          /* istanbul ignore if */
+          if (config.performance && mark) {
+              vm._name = formatComponentName(vm, false);
+              mark(endTag);
+              measure(`vue ${vm._name} init`, startTag, endTag);
+          }
+          if (vm.$options.el) {
+              vm.$mount(vm.$options.el);
+          }
+      };
+  }
+  function initInternalComponent(vm, options) {
+      const opts = (vm.$options = Object.create(vm.constructor.options));
+      // doing this because it's faster than dynamic enumeration.
+      const parentVnode = options._parentVnode;
+      opts.parent = options.parent;
+      opts._parentVnode = parentVnode;
+      const vnodeComponentOptions = parentVnode.componentOptions;
+      opts.propsData = vnodeComponentOptions.propsData;
+      opts._parentListeners = vnodeComponentOptions.listeners;
+      opts._renderChildren = vnodeComponentOptions.children;
+      opts._componentTag = vnodeComponentOptions.tag;
+      if (options.render) {
+          opts.render = options.render;
+          opts.staticRenderFns = options.staticRenderFns;
+      }
+  }
+  function resolveConstructorOptions(Ctor) {
+      let options = Ctor.options;
+      if (Ctor.super) {
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              const modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  modified = {};
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
   }
 
-  function Vue(options) {
-      if (!(this instanceof Vue)) {
-          warn("Vue is a constructor and should be called with the `new` keyword");
-      }
-      this._init(options);
-  }
-  //@ts-expect-error Vue has function type
-  initMixin$1(Vue);
-  //@ts-expect-error Vue has function type
-  stateMixin(Vue);
-  //@ts-expect-error Vue has function type
-  eventsMixin(Vue);
-  //@ts-expect-error Vue has function type
-  lifecycleMixin(Vue);
-  //@ts-expect-error Vue has function type
+  function Vue(options) {
+      if (!(this instanceof Vue)) {
+          warn("Vue is a constructor and should be called with the `new` keyword");
+      }
+      this._init(options);
+  }
+  //@ts-expect-error Vue has function type
+  initMixin$1(Vue);
+  //@ts-expect-error Vue has function type
+  stateMixin(Vue);
+  //@ts-expect-error Vue has function type
+  eventsMixin(Vue);
+  //@ts-expect-error Vue has function type
+  lifecycleMixin(Vue);
+  //@ts-expect-error Vue has function type
   renderMixin(Vue);
 
-  function initUse(Vue) {
-      Vue.use = function (plugin) {
-          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-          if (installedPlugins.indexOf(plugin) > -1) {
-              return this;
-          }
-          // additional parameters
-          const args = toArray(arguments, 1);
-          args.unshift(this);
-          if (typeof plugin.install === 'function') {
-              plugin.install.apply(plugin, args);
-          }
-          else if (typeof plugin === 'function') {
-              plugin.apply(null, args);
-          }
-          installedPlugins.push(plugin);
-          return this;
-      };
+  function initUse(Vue) {
+      Vue.use = function (plugin) {
+          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
+          if (installedPlugins.indexOf(plugin) > -1) {
+              return this;
+          }
+          // additional parameters
+          const args = toArray(arguments, 1);
+          args.unshift(this);
+          if (typeof plugin.install === 'function') {
+              plugin.install.apply(plugin, args);
+          }
+          else if (typeof plugin === 'function') {
+              plugin.apply(null, args);
+          }
+          installedPlugins.push(plugin);
+          return this;
+      };
   }
 
-  function initMixin(Vue) {
-      Vue.mixin = function (mixin) {
-          this.options = mergeOptions(this.options, mixin);
-          return this;
-      };
+  function initMixin(Vue) {
+      Vue.mixin = function (mixin) {
+          this.options = mergeOptions(this.options, mixin);
+          return this;
+      };
   }
 
-  function initExtend(Vue) {
-      /**
-       * Each instance constructor, including Vue, has a unique
-       * cid. This enables us to create wrapped "child
-       * constructors" for prototypal inheritance and cache them.
-       */
-      Vue.cid = 0;
-      let cid = 1;
-      /**
-       * Class inheritance
-       */
-      Vue.extend = function (extendOptions) {
-          extendOptions = extendOptions || {};
-          const Super = this;
-          const SuperId = Super.cid;
-          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-          if (cachedCtors[SuperId]) {
-              return cachedCtors[SuperId];
-          }
-          const name = extendOptions.name || Super.options.name;
-          if (name) {
-              validateComponentName(name);
-          }
-          const Sub = function VueComponent(options) {
-              this._init(options);
-          };
-          Sub.prototype = Object.create(Super.prototype);
-          Sub.prototype.constructor = Sub;
-          Sub.cid = cid++;
-          Sub.options = mergeOptions(Super.options, extendOptions);
-          Sub['super'] = Super;
-          // For props and computed properties, we define the proxy getters on
-          // the Vue instances at extension time, on the extended prototype. This
-          // avoids Object.defineProperty calls for each instance created.
-          if (Sub.options.props) {
-              initProps(Sub);
-          }
-          if (Sub.options.computed) {
-              initComputed(Sub);
-          }
-          // allow further extension/mixin/plugin usage
-          Sub.extend = Super.extend;
-          Sub.mixin = Super.mixin;
-          Sub.use = Super.use;
-          // create asset registers, so extended classes
-          // can have their private assets too.
-          ASSET_TYPES.forEach(function (type) {
-              Sub[type] = Super[type];
-          });
-          // enable recursive self-lookup
-          if (name) {
-              Sub.options.components[name] = Sub;
-          }
-          // keep a reference to the super options at extension time.
-          // later at instantiation we can check if Super's options have
-          // been updated.
-          Sub.superOptions = Super.options;
-          Sub.extendOptions = extendOptions;
-          Sub.sealedOptions = extend({}, Sub.options);
-          // cache constructor
-          cachedCtors[SuperId] = Sub;
-          return Sub;
-      };
-  }
-  function initProps(Comp) {
-      const props = Comp.options.props;
-      for (const key in props) {
-          proxy(Comp.prototype, `_props`, key);
-      }
-  }
-  function initComputed(Comp) {
-      const computed = Comp.options.computed;
-      for (const key in computed) {
-          defineComputed(Comp.prototype, key, computed[key]);
-      }
+  function initExtend(Vue) {
+      /**
+       * Each instance constructor, including Vue, has a unique
+       * cid. This enables us to create wrapped "child
+       * constructors" for prototypal inheritance and cache them.
+       */
+      Vue.cid = 0;
+      let cid = 1;
+      /**
+       * Class inheritance
+       */
+      Vue.extend = function (extendOptions) {
+          extendOptions = extendOptions || {};
+          const Super = this;
+          const SuperId = Super.cid;
+          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
+          if (cachedCtors[SuperId]) {
+              return cachedCtors[SuperId];
+          }
+          const name = extendOptions.name || Super.options.name;
+          if (name) {
+              validateComponentName(name);
+          }
+          const Sub = function VueComponent(options) {
+              this._init(options);
+          };
+          Sub.prototype = Object.create(Super.prototype);
+          Sub.prototype.constructor = Sub;
+          Sub.cid = cid++;
+          Sub.options = mergeOptions(Super.options, extendOptions);
+          Sub['super'] = Super;
+          // For props and computed properties, we define the proxy getters on
+          // the Vue instances at extension time, on the extended prototype. This
+          // avoids Object.defineProperty calls for each instance created.
+          if (Sub.options.props) {
+              initProps(Sub);
+          }
+          if (Sub.options.computed) {
+              initComputed(Sub);
+          }
+          // allow further extension/mixin/plugin usage
+          Sub.extend = Super.extend;
+          Sub.mixin = Super.mixin;
+          Sub.use = Super.use;
+          // create asset registers, so extended classes
+          // can have their private assets too.
+          ASSET_TYPES.forEach(function (type) {
+              Sub[type] = Super[type];
+          });
+          // enable recursive self-lookup
+          if (name) {
+              Sub.options.components[name] = Sub;
+          }
+          // keep a reference to the super options at extension time.
+          // later at instantiation we can check if Super's options have
+          // been updated.
+          Sub.superOptions = Super.options;
+          Sub.extendOptions = extendOptions;
+          Sub.sealedOptions = extend({}, Sub.options);
+          // cache constructor
+          cachedCtors[SuperId] = Sub;
+          return Sub;
+      };
+  }
+  function initProps(Comp) {
+      const props = Comp.options.props;
+      for (const key in props) {
+          proxy(Comp.prototype, `_props`, key);
+      }
+  }
+  function initComputed(Comp) {
+      const computed = Comp.options.computed;
+      for (const key in computed) {
+          defineComputed(Comp.prototype, key, computed[key]);
+      }
   }
 
-  function initAssetRegisters(Vue) {
-      /**
-       * Create asset registration methods.
-       */
-      ASSET_TYPES.forEach((type) => {
-          // @ts-expect-error function is not exact same type
-          Vue[type] = function (id, definition) {
-              if (!definition) {
-                  return this.options[type + 's'][id];
-              }
-              else {
-                  /* istanbul ignore if */
-                  if (type === 'component') {
-                      validateComponentName(id);
-                  }
-                  if (type === 'component' && isPlainObject(definition)) {
-                      // @ts-expect-error
-                      definition.name = definition.name || id;
-                      definition = this.options._base.extend(definition);
-                  }
-                  if (type === 'directive' && typeof definition === 'function') {
-                      definition = { bind: definition, update: definition };
-                  }
-                  this.options[type + 's'][id] = definition;
-                  return definition;
-              }
-          };
-      });
+  function initAssetRegisters(Vue) {
+      /**
+       * Create asset registration methods.
+       */
+      ASSET_TYPES.forEach((type) => {
+          // @ts-expect-error function is not exact same type
+          Vue[type] = function (id, definition) {
+              if (!definition) {
+                  return this.options[type + 's'][id];
+              }
+              else {
+                  /* istanbul ignore if */
+                  if (type === 'component') {
+                      validateComponentName(id);
+                  }
+                  if (type === 'component' && isPlainObject(definition)) {
+                      // @ts-expect-error
+                      definition.name = definition.name || id;
+                      definition = this.options._base.extend(definition);
+                  }
+                  if (type === 'directive' && typeof definition === 'function') {
+                      definition = { bind: definition, update: definition };
+                  }
+                  this.options[type + 's'][id] = definition;
+                  return definition;
+              }
+          };
+      });
   }
 
-  /* @flow */
-  function getComponentName(opts) {
-      return opts && (opts.Ctor.options.name || opts.tag);
-  }
-  function matches(pattern, name) {
-      if (Array.isArray(pattern)) {
-          return pattern.indexOf(name) > -1;
-      }
-      else if (typeof pattern === "string") {
-          return pattern.split(",").indexOf(name) > -1;
-      }
-      else if (isRegExp(pattern)) {
-          return pattern.test(name);
-      }
-      /* istanbul ignore next */
-      return false;
-  }
-  function pruneCache(keepAliveInstance, filter) {
-      const { cache, keys, _vnode } = keepAliveInstance;
-      for (const key in cache) {
-          const entry = cache[key];
-          if (entry) {
-              const name = entry.name;
-              if (name && !filter(name)) {
-                  pruneCacheEntry(cache, key, keys, _vnode);
-              }
-          }
-      }
-  }
-  function pruneCacheEntry(cache, key, keys, current) {
-      const entry = cache[key];
-      if (entry && (!current || entry.tag !== current.tag)) {
-          // @ts-expect-error can be undefined
-          entry.componentInstance.$destroy();
-      }
-      cache[key] = null;
-      remove$2(keys, key);
-  }
-  const patternTypes = [String, RegExp, Array];
-  // TODO defineComponent
-  var KeepAlive = {
-      name: "keep-alive",
-      abstract: true,
-      props: {
-          include: patternTypes,
-          exclude: patternTypes,
-          max: [String, Number],
-      },
-      methods: {
-          cacheVNode() {
-              const { cache, keys, vnodeToCache, keyToCache } = this;
-              if (vnodeToCache) {
-                  const { tag, componentInstance, componentOptions } = vnodeToCache;
-                  cache[keyToCache] = {
-                      name: getComponentName(componentOptions),
-                      tag,
-                      componentInstance,
-                  };
-                  keys.push(keyToCache);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
-                  this.vnodeToCache = null;
-              }
-          },
-      },
-      created() {
-          this.cache = Object.create(null);
-          this.keys = [];
-      },
-      destroyed() {
-          for (const key in this.cache) {
-              pruneCacheEntry(this.cache, key, this.keys);
-          }
-      },
-      mounted() {
-          this.cacheVNode();
-          this.$watch("include", (val) => {
-              pruneCache(this, (name) => matches(val, name));
-          });
-          this.$watch("exclude", (val) => {
-              pruneCache(this, (name) => !matches(val, name));
-          });
-      },
-      updated() {
-          this.cacheVNode();
-      },
-      render() {
-          const slot = this.$slots.default;
-          const vnode = getFirstComponentChild(slot);
-          const componentOptions = vnode && vnode.componentOptions;
-          if (componentOptions) {
-              // check pattern
-              const name = getComponentName(componentOptions);
-              const { include, exclude } = this;
-              if (
-              // not included
-              (include && (!name || !matches(include, name))) ||
-                  // excluded
-                  (exclude && name && matches(exclude, name))) {
-                  return vnode;
-              }
-              const { cache, keys } = this;
-              const key = vnode.key == null
-                  ? // same constructor may get registered as different local components
-                      // so cid alone is not enough (#3269)
-                      componentOptions.Ctor.cid +
-                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                  : vnode.key;
-              if (cache[key]) {
-                  vnode.componentInstance = cache[key].componentInstance;
-                  // make current key freshest
-                  remove$2(keys, key);
-                  keys.push(key);
-              }
-              else {
-                  // delay setting the cache until update
-                  this.vnodeToCache = vnode;
-                  this.keyToCache = key;
-              }
-              // @ts-expect-error can vnode.data can be undefined
-              vnode.data.keepAlive = true;
-          }
-          return vnode || (slot && slot[0]);
-      },
+  /* @flow */
+  function getComponentName(opts) {
+      return opts && (opts.Ctor.options.name || opts.tag);
+  }
+  function matches(pattern, name) {
+      if (Array.isArray(pattern)) {
+          return pattern.indexOf(name) > -1;
+      }
+      else if (typeof pattern === "string") {
+          return pattern.split(",").indexOf(name) > -1;
+      }
+      else if (isRegExp(pattern)) {
+          return pattern.test(name);
+      }
+      /* istanbul ignore next */
+      return false;
+  }
+  function pruneCache(keepAliveInstance, filter) {
+      const { cache, keys, _vnode } = keepAliveInstance;
+      for (const key in cache) {
+          const entry = cache[key];
+          if (entry) {
+              const name = entry.name;
+              if (name && !filter(name)) {
+                  pruneCacheEntry(cache, key, keys, _vnode);
+              }
+          }
+      }
+  }
+  function pruneCacheEntry(cache, key, keys, current) {
+      const entry = cache[key];
+      if (entry && (!current || entry.tag !== current.tag)) {
+          // @ts-expect-error can be undefined
+          entry.componentInstance.$destroy();
+      }
+      cache[key] = null;
+      remove$2(keys, key);
+  }
+  const patternTypes = [String, RegExp, Array];
+  // TODO defineComponent
+  var KeepAlive = {
+      name: "keep-alive",
+      abstract: true,
+      props: {
+          include: patternTypes,
+          exclude: patternTypes,
+          max: [String, Number],
+      },
+      methods: {
+          cacheVNode() {
+              const { cache, keys, vnodeToCache, keyToCache } = this;
+              if (vnodeToCache) {
+                  const { tag, componentInstance, componentOptions } = vnodeToCache;
+                  cache[keyToCache] = {
+                      name: getComponentName(componentOptions),
+                      tag,
+                      componentInstance,
+                  };
+                  keys.push(keyToCache);
+                  // prune oldest entry
+                  if (this.max && keys.length > parseInt(this.max)) {
+                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
+                  }
+                  this.vnodeToCache = null;
+              }
+          },
+      },
+      created() {
+          this.cache = Object.create(null);
+          this.keys = [];
+      },
+      destroyed() {
+          for (const key in this.cache) {
+              pruneCacheEntry(this.cache, key, this.keys);
+          }
+      },
+      mounted() {
+          this.cacheVNode();
+          this.$watch("include", (val) => {
+              pruneCache(this, (name) => matches(val, name));
+          });
+          this.$watch("exclude", (val) => {
+              pruneCache(this, (name) => !matches(val, name));
+          });
+      },
+      updated() {
+          this.cacheVNode();
+      },
+      render() {
+          const slot = this.$slots.default;
+          const vnode = getFirstComponentChild(slot);
+          const componentOptions = vnode && vnode.componentOptions;
+          if (componentOptions) {
+              // check pattern
+              const name = getComponentName(componentOptions);
+              const { include, exclude } = this;
+              if (
+              // not included
+              (include && (!name || !matches(include, name))) ||
+                  // excluded
+                  (exclude && name && matches(exclude, name))) {
+                  return vnode;
+              }
+              const { cache, keys } = this;
+              const key = vnode.key == null
+                  ? // same constructor may get registered as different local components
+                      // so cid alone is not enough (#3269)
+                      componentOptions.Ctor.cid +
+                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
+                  : vnode.key;
+              if (cache[key]) {
+                  vnode.componentInstance = cache[key].componentInstance;
+                  // make current key freshest
+                  remove$2(keys, key);
+                  keys.push(key);
+              }
+              else {
+                  // delay setting the cache until update
+                  this.vnodeToCache = vnode;
+                  this.keyToCache = key;
+              }
+              // @ts-expect-error can vnode.data can be undefined
+              vnode.data.keepAlive = true;
+          }
+          return vnode || (slot && slot[0]);
+      },
   };
 
-  var builtInComponents = {
-      KeepAlive,
+  var builtInComponents = {
+      KeepAlive,
   };
 
-  function initGlobalAPI(Vue) {
-      // config
-      const configDef = {};
-      configDef.get = () => config;
-      {
-          configDef.set = () => {
-              warn('Do not replace the Vue.config object, set individual fields instead.');
-          };
-      }
-      Object.defineProperty(Vue, 'config', configDef);
-      // exposed util methods.
-      // NOTE: these are not considered part of the public API - avoid relying on
-      // them unless you are aware of the risk.
-      Vue.util = {
-          warn,
-          extend,
-          mergeOptions,
-          defineReactive,
-      };
-      Vue.set = set;
-      Vue.delete = del;
-      Vue.nextTick = nextTick;
-      // 2.6 explicit observable API
-      Vue.observable = (obj) => {
-          observe(obj);
-          return obj;
-      };
-      Vue.options = Object.create(null);
-      ASSET_TYPES.forEach((type) => {
-          Vue.options[type + 's'] = Object.create(null);
-      });
-      // this is used to identify the "base" constructor to extend all plain-object
-      // components with in Weex's multi-instance scenarios.
-      Vue.options._base = Vue;
-      extend(Vue.options.components, builtInComponents);
-      initUse(Vue);
-      initMixin(Vue);
-      initExtend(Vue);
-      initAssetRegisters(Vue);
+  function initGlobalAPI(Vue) {
+      // config
+      const configDef = {};
+      configDef.get = () => config;
+      {
+          configDef.set = () => {
+              warn('Do not replace the Vue.config object, set individual fields instead.');
+          };
+      }
+      Object.defineProperty(Vue, 'config', configDef);
+      // exposed util methods.
+      // NOTE: these are not considered part of the public API - avoid relying on
+      // them unless you are aware of the risk.
+      Vue.util = {
+          warn,
+          extend,
+          mergeOptions,
+          defineReactive,
+      };
+      Vue.set = set;
+      Vue.delete = del;
+      Vue.nextTick = nextTick;
+      // 2.6 explicit observable API
+      Vue.observable = (obj) => {
+          observe(obj);
+          return obj;
+      };
+      Vue.options = Object.create(null);
+      ASSET_TYPES.forEach((type) => {
+          Vue.options[type + 's'] = Object.create(null);
+      });
+      // this is used to identify the "base" constructor to extend all plain-object
+      // components with in Weex's multi-instance scenarios.
+      Vue.options._base = Vue;
+      extend(Vue.options.components, builtInComponents);
+      initUse(Vue);
+      initMixin(Vue);
+      initExtend(Vue);
+      initAssetRegisters(Vue);
   }
 
-  initGlobalAPI(Vue);
-  Object.defineProperty(Vue.prototype, '$isServer', {
-      get: isServerRendering,
-  });
-  Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get() {
-          /* istanbul ignore next */
-          return this.$vnode && this.$vnode.ssrContext;
-      },
-  });
-  // expose FunctionalRenderContext for ssr runtime helper installation
-  Object.defineProperty(Vue, 'FunctionalRenderContext', {
-      value: FunctionalRenderContext,
-  });
+  initGlobalAPI(Vue);
+  Object.defineProperty(Vue.prototype, '$isServer', {
+      get: isServerRendering,
+  });
+  Object.defineProperty(Vue.prototype, '$ssrContext', {
+      get() {
+          /* istanbul ignore next */
+          return this.$vnode && this.$vnode.ssrContext;
+      },
+  });
+  // expose FunctionalRenderContext for ssr runtime helper installation
+  Object.defineProperty(Vue, 'FunctionalRenderContext', {
+      value: FunctionalRenderContext,
+  });
   Vue.version = '2.6.14';
 
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  const isReservedAttr = makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const xlinkNS = 'http://www.w3.org/1999/xlink';
-  const isXlink = (name) => {
-      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-  };
-  const getXlinkProp = (name) => {
-      return isXlink(name) ? name.slice(6, name.length) : '';
-  };
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  const isReservedAttr = makeMap('style,class');
+  // attributes that should be using props for binding
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
+  };
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
+  };
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+  const xlinkNS = 'http://www.w3.org/1999/xlink';
+  const isXlink = (name) => {
+      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
+  };
+  const getXlinkProp = (name) => {
+      return isXlink(name) ? name.slice(6, name.length) : '';
+  };
+  const isFalsyAttrValue = (val) => {
+      return val == null || val === false;
   };
 
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
+  function genClassForVnode(vnode) {
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass(data.staticClass, data.class);
+  }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
+  }
+  function renderClass(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
+  }
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function stringifyArray(value) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  res += ' ';
+              res += stringified;
+          }
+      }
+      return res;
+  }
+  function stringifyObject(value) {
+      let res = '';
+      for (const key in value) {
+          if (value[key]) {
+              if (res)
+                  res += ' ';
+              res += key;
+          }
+      }
+      return res;
   }
 
-  const namespaceMap = {
-      svg: 'http://www.w3.org/2000/svg',
-      math: 'http://www.w3.org/1998/Math/MathML',
-  };
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
-  const unknownElementCache = Object.create(null);
-  function isUnknownElement(tag) {
-      /* istanbul ignore if */
-      if (!inBrowser) {
-          return true;
-      }
-      if (isReservedTag(tag)) {
-          return false;
-      }
-      tag = tag.toLowerCase();
-      /* istanbul ignore if */
-      if (unknownElementCache[tag] != null) {
-          return unknownElementCache[tag];
-      }
-      const el = document.createElement(tag);
-      if (tag.indexOf('-') > -1) {
-          // http://stackoverflow.com/a/28210364/1070244
-          return (unknownElementCache[tag] =
-              el.constructor === window.HTMLUnknownElement ||
-                  el.constructor === window.HTMLElement);
-      }
-      else {
-          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-      }
-  }
+  const namespaceMap = {
+      svg: 'http://www.w3.org/2000/svg',
+      math: 'http://www.w3.org/1998/Math/MathML',
+  };
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
+  // this map is intentionally selective, only covering SVG elements that may
+  // contain child elements.
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  const isReservedTag = (tag) => {
+      return isHTMLTag(tag) || isSVG(tag);
+  };
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
+  }
+  const unknownElementCache = Object.create(null);
+  function isUnknownElement(tag) {
+      /* istanbul ignore if */
+      if (!inBrowser) {
+          return true;
+      }
+      if (isReservedTag(tag)) {
+          return false;
+      }
+      tag = tag.toLowerCase();
+      /* istanbul ignore if */
+      if (unknownElementCache[tag] != null) {
+          return unknownElementCache[tag];
+      }
+      const el = document.createElement(tag);
+      if (tag.indexOf('-') > -1) {
+          // http://stackoverflow.com/a/28210364/1070244
+          return (unknownElementCache[tag] =
+              el.constructor === window.HTMLUnknownElement ||
+                  el.constructor === window.HTMLElement);
+      }
+      else {
+          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
+      }
+  }
   const isTextInputType = makeMap('text,number,password,search,email,tel,url');
 
-  /**
-   * Query an element selector if it's not an element already.
-   */
-  function query(el) {
-      if (typeof el === 'string') {
-          const selected = document.querySelector(el);
-          if (!selected) {
-              warn('Cannot find element: ' + el);
-              return document.createElement('div');
-          }
-          return selected;
-      }
-      else {
-          return el;
-      }
+  /**
+   * Query an element selector if it's not an element already.
+   */
+  function query(el) {
+      if (typeof el === 'string') {
+          const selected = document.querySelector(el);
+          if (!selected) {
+              warn('Cannot find element: ' + el);
+              return document.createElement('div');
+          }
+          return selected;
+      }
+      else {
+          return el;
+      }
   }
 
-  function createElement(tagName, vnode) {
-      const elm = document.createElement(tagName);
-      if (tagName !== 'select') {
-          return elm;
-      }
-      // false or null will remove the attribute but undefined will not
-      if (vnode.data &&
-          vnode.data.attrs &&
-          vnode.data.attrs.multiple !== undefined) {
-          elm.setAttribute('multiple', 'multiple');
-      }
-      return elm;
-  }
-  function createElementNS(namespace, tagName) {
-      return document.createElementNS(namespaceMap[namespace], tagName);
-  }
-  function createTextNode(text) {
-      return document.createTextNode(text);
-  }
-  function createComment(text) {
-      return document.createComment(text);
-  }
-  function insertBefore(parentNode, newNode, referenceNode) {
-      parentNode.insertBefore(newNode, referenceNode);
-  }
-  function removeChild(node, child) {
-      node.removeChild(child);
-  }
-  function appendChild(node, child) {
-      node.appendChild(child);
-  }
-  function parentNode(node) {
-      return node.parentNode;
-  }
-  function nextSibling(node) {
-      return node.nextSibling;
-  }
-  function tagName(node) {
-      return node.tagName;
-  }
-  function setTextContent(node, text) {
-      node.textContent = text;
-  }
-  function setStyleScope(node, scopeId) {
-      node.setAttribute(scopeId, '');
+  function createElement(tagName, vnode) {
+      const elm = document.createElement(tagName);
+      if (tagName !== 'select') {
+          return elm;
+      }
+      // false or null will remove the attribute but undefined will not
+      if (vnode.data &&
+          vnode.data.attrs &&
+          vnode.data.attrs.multiple !== undefined) {
+          elm.setAttribute('multiple', 'multiple');
+      }
+      return elm;
+  }
+  function createElementNS(namespace, tagName) {
+      return document.createElementNS(namespaceMap[namespace], tagName);
+  }
+  function createTextNode(text) {
+      return document.createTextNode(text);
+  }
+  function createComment(text) {
+      return document.createComment(text);
+  }
+  function insertBefore(parentNode, newNode, referenceNode) {
+      parentNode.insertBefore(newNode, referenceNode);
+  }
+  function removeChild(node, child) {
+      node.removeChild(child);
+  }
+  function appendChild(node, child) {
+      node.appendChild(child);
+  }
+  function parentNode(node) {
+      return node.parentNode;
+  }
+  function nextSibling(node) {
+      return node.nextSibling;
+  }
+  function tagName(node) {
+      return node.tagName;
+  }
+  function setTextContent(node, text) {
+      node.textContent = text;
+  }
+  function setStyleScope(node, scopeId) {
+      node.setAttribute(scopeId, '');
   }
 
   var nodeOps = /*#__PURE__*/Object.freeze({
@@ -5006,2407 +5003,2406 @@
     setStyleScope: setStyleScope
   });
 
-  var ref = {
-      create(_, vnode) {
-          registerRef(vnode);
-      },
-      update(oldVnode, vnode) {
-          if (oldVnode.data.ref !== vnode.data.ref) {
-              registerRef(oldVnode, true);
-              registerRef(vnode);
-          }
-      },
-      destroy(vnode) {
-          registerRef(vnode, true);
-      },
-  };
-  function registerRef(vnode, isRemoval) {
-      const key = vnode.data.ref;
-      if (!isDef(key))
-          return;
-      const vm = vnode.context;
-      const ref = vnode.componentInstance || vnode.elm;
-      const refs = vm.$refs;
-      const obj = refs[key];
-      if (isRemoval) {
-          if (Array.isArray(obj)) {
-              remove$2(obj, ref);
-          }
-          else if (obj === ref) {
-              refs[key] = undefined;
-          }
-      }
-      else {
-          if (vnode.data.refInFor) {
-              if (!Array.isArray(obj)) {
-                  refs[key] = [ref];
-              }
-              else if (obj.indexOf(ref) < 0) {
-                  obj.push(ref);
-              }
-          }
-          else {
-              refs[key] = ref;
-          }
-      }
+  var ref = {
+      create(_, vnode) {
+          registerRef(vnode);
+      },
+      update(oldVnode, vnode) {
+          if (oldVnode.data.ref !== vnode.data.ref) {
+              registerRef(oldVnode, true);
+              registerRef(vnode);
+          }
+      },
+      destroy(vnode) {
+          registerRef(vnode, true);
+      },
+  };
+  function registerRef(vnode, isRemoval) {
+      const key = vnode.data.ref;
+      if (!isDef(key))
+          return;
+      const vm = vnode.context;
+      const ref = vnode.componentInstance || vnode.elm;
+      const refs = vm.$refs;
+      const obj = refs[key];
+      if (isRemoval) {
+          if (Array.isArray(obj)) {
+              remove$2(obj, ref);
+          }
+          else if (obj === ref) {
+              refs[key] = undefined;
+          }
+      }
+      else {
+          if (vnode.data.refInFor) {
+              if (!Array.isArray(obj)) {
+                  refs[key] = [ref];
+              }
+              else if (obj.indexOf(ref) < 0) {
+                  obj.push(ref);
+              }
+          }
+          else {
+              refs[key] = ref;
+          }
+      }
   }
 
-  /**
-   * Virtual DOM patching algorithm based on Snabbdom by
-   * Simon Friis Vindum (@paldepind)
-   * Licensed under the MIT License
-   * https://github.com/paldepind/snabbdom/blob/master/LICENSE
-   *
-   * modified by Evan You (@yyx990803)
-   *
-   * Not type-checking this because this file is perf-critical and the cost
-   * of making flow understand it is not worth it.
-   */
-  const emptyNode = new VNode('', {}, []);
-  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-  function sameVnode(a, b) {
-      return (a.key === b.key &&
-          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-          a.isComment === b.isComment &&
-          isDef(a.data) === isDef(b.data) &&
-          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-          isUndef(b.asyncFactory.error))));
-  }
-  function sameInputType(a, b) {
-      if (a.tag !== 'input')
-          return true;
-      let i;
-      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-  }
-  function createKeyToOldIdx(children, beginIdx, endIdx) {
-      let i, key;
-      const map = {};
-      for (i = beginIdx; i <= endIdx; ++i) {
-          key = children[i].key;
-          if (isDef(key))
-              map[key] = i;
-      }
-      return map;
-  }
-  function createPatchFunction(backend) {
-      let i, j;
-      const cbs = {};
-      const { modules, nodeOps } = backend;
-      for (i = 0; i < hooks.length; ++i) {
-          cbs[hooks[i]] = [];
-          for (j = 0; j < modules.length; ++j) {
-              if (isDef(modules[j][hooks[i]])) {
-                  cbs[hooks[i]].push(modules[j][hooks[i]]);
-              }
-          }
-      }
-      function emptyNodeAt(elm) {
-          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-      }
-      function createRmCb(childElm, listeners) {
-          function remove() {
-              if (--remove.listeners === 0) {
-                  removeNode(childElm);
-              }
-          }
-          remove.listeners = listeners;
-          return remove;
-      }
-      function removeNode(el) {
-          const parent = nodeOps.parentNode(el);
-          // element may have already been removed due to v-html / v-text
-          if (isDef(parent)) {
-              nodeOps.removeChild(parent, el);
-          }
-      }
-      function isUnknownElement(vnode, inVPre) {
-          return (!inVPre &&
-              !vnode.ns &&
-              !(config.ignoredElements.length &&
-                  config.ignoredElements.some((ignore) => {
-                      return isRegExp(ignore)
-                          ? ignore.test(vnode.tag)
-                          : ignore === vnode.tag;
-                  })) &&
-              config.isUnknownElement(vnode.tag));
-      }
-      let creatingElmInVPre = 0;
-      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // This vnode was used in a previous render!
-              // now it's used as a new node, overwriting its elm would cause
-              // potential patch errors down the road when it's used as an insertion
-              // reference node. Instead, we clone the node on-demand before creating
-              // associated DOM element for it.
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          vnode.isRootInsert = !nested; // for transition enter check
-          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-              return;
-          }
-          const data = vnode.data;
-          const children = vnode.children;
-          const tag = vnode.tag;
-          if (isDef(tag)) {
-              {
-                  if (data && data.pre) {
-                      creatingElmInVPre++;
-                  }
-                  if (isUnknownElement(vnode, creatingElmInVPre)) {
-                      warn('Unknown custom element: <' +
-                          tag +
-                          '> - did you ' +
-                          'register the component correctly? For recursive components, ' +
-                          'make sure to provide the "name" option.', vnode.context);
-                  }
-              }
-              vnode.elm = vnode.ns
-                  ? nodeOps.createElementNS(vnode.ns, tag)
-                  : nodeOps.createElement(tag, vnode);
-              setScope(vnode);
-              /* istanbul ignore if */
-              {
-                  createChildren(vnode, children, insertedVnodeQueue);
-                  if (isDef(data)) {
-                      invokeCreateHooks(vnode, insertedVnodeQueue);
-                  }
-                  insert(parentElm, vnode.elm, refElm);
-              }
-              if (data && data.pre) {
-                  creatingElmInVPre--;
-              }
-          }
-          else if (isTrue(vnode.isComment)) {
-              vnode.elm = nodeOps.createComment(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-          else {
-              vnode.elm = nodeOps.createTextNode(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-      }
-      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i = vnode.data;
-          if (isDef(i)) {
-              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-              if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                  i(vnode, false /* hydrating */);
-              }
-              // after calling the init hook, if the vnode is a child component
-              // it should've created a child instance and mounted it. the child
-              // component also has set the placeholder vnode's elm.
-              // in that case we can just return the element and be done.
-              if (isDef(vnode.componentInstance)) {
-                  initComponent(vnode, insertedVnodeQueue);
-                  insert(parentElm, vnode.elm, refElm);
-                  if (isTrue(isReactivated)) {
-                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                  }
-                  return true;
-              }
-          }
-      }
-      function initComponent(vnode, insertedVnodeQueue) {
-          if (isDef(vnode.data.pendingInsert)) {
-              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-              vnode.data.pendingInsert = null;
-          }
-          vnode.elm = vnode.componentInstance.$el;
-          if (isPatchable(vnode)) {
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              setScope(vnode);
-          }
-          else {
-              // empty component root.
-              // skip all element-related modules except for ref (#3455)
-              registerRef(vnode);
-              // make sure to invoke the insert hook
-              insertedVnodeQueue.push(vnode);
-          }
-      }
-      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i;
-          // hack for #4339: a reactivated component with inner transition
-          // does not trigger because the inner node's created hooks are not called
-          // again. It's not ideal to involve module-specific logic in here but
-          // there doesn't seem to be a better way to do it.
-          let innerNode = vnode;
-          while (innerNode.componentInstance) {
-              innerNode = innerNode.componentInstance._vnode;
-              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                  for (i = 0; i < cbs.activate.length; ++i) {
-                      cbs.activate[i](emptyNode, innerNode);
-                  }
-                  insertedVnodeQueue.push(innerNode);
-                  break;
-              }
-          }
-          // unlike a newly created component,
-          // a reactivated keep-alive component doesn't insert itself
-          insert(parentElm, vnode.elm, refElm);
-      }
-      function insert(parent, elm, ref) {
-          if (isDef(parent)) {
-              if (isDef(ref)) {
-                  if (nodeOps.parentNode(ref) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref);
-                  }
-              }
-              else {
-                  nodeOps.appendChild(parent, elm);
-              }
-          }
-      }
-      function createChildren(vnode, children, insertedVnodeQueue) {
-          if (Array.isArray(children)) {
-              {
-                  checkDuplicateKeys(children);
-              }
-              for (let i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-              }
-          }
-          else if (isPrimitive(vnode.text)) {
-              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-          }
-      }
-      function isPatchable(vnode) {
-          while (vnode.componentInstance) {
-              vnode = vnode.componentInstance._vnode;
-          }
-          return isDef(vnode.tag);
-      }
-      function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (let i = 0; i < cbs.create.length; ++i) {
-              cbs.create[i](emptyNode, vnode);
-          }
-          i = vnode.data.hook; // Reuse variable
-          if (isDef(i)) {
-              if (isDef(i.create))
-                  i.create(emptyNode, vnode);
-              if (isDef(i.insert))
-                  insertedVnodeQueue.push(vnode);
-          }
-      }
-      // set scope id attribute for scoped CSS.
-      // this is implemented as a special case to avoid the overhead
-      // of going through the normal attribute patching process.
-      function setScope(vnode) {
-          let i;
-          if (isDef((i = vnode.fnScopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-          else {
-              let ancestor = vnode;
-              while (ancestor) {
-                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                      nodeOps.setStyleScope(vnode.elm, i);
-                  }
-                  ancestor = ancestor.parent;
-              }
-          }
-          // for slot content they should also get the scopeId from the host instance.
-          if (isDef((i = activeInstance)) &&
-              i !== vnode.context &&
-              i !== vnode.fnContext &&
-              isDef((i = i.$options._scopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-      }
-      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-          }
-      }
-      function invokeDestroyHook(vnode) {
-          let i, j;
-          const data = vnode.data;
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  i(vnode);
-              for (i = 0; i < cbs.destroy.length; ++i)
-                  cbs.destroy[i](vnode);
-          }
-          if (isDef((i = vnode.children))) {
-              for (j = 0; j < vnode.children.length; ++j) {
-                  invokeDestroyHook(vnode.children[j]);
-              }
-          }
-      }
-      function removeVnodes(vnodes, startIdx, endIdx) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              const ch = vnodes[startIdx];
-              if (isDef(ch)) {
-                  if (isDef(ch.tag)) {
-                      removeAndInvokeRemoveHook(ch);
-                      invokeDestroyHook(ch);
-                  }
-                  else {
-                      // Text node
-                      removeNode(ch.elm);
-                  }
-              }
-          }
-      }
-      function removeAndInvokeRemoveHook(vnode, rm) {
-          if (isDef(rm) || isDef(vnode.data)) {
-              let i;
-              const listeners = cbs.remove.length + 1;
-              if (isDef(rm)) {
-                  // we have a recursively passed down rm callback
-                  // increase the listeners count
-                  rm.listeners += listeners;
-              }
-              else {
-                  // directly removing
-                  rm = createRmCb(vnode.elm, listeners);
-              }
-              // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
-              }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
-              }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          }
-          else {
-              removeNode(vnode.elm);
-          }
-      }
-      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          let oldStartIdx = 0;
-          let newStartIdx = 0;
-          let oldEndIdx = oldCh.length - 1;
-          let oldStartVnode = oldCh[0];
-          let oldEndVnode = oldCh[oldEndIdx];
-          let newEndIdx = newCh.length - 1;
-          let newStartVnode = newCh[0];
-          let newEndVnode = newCh[newEndIdx];
-          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-          // removeOnly is a special flag used only by <transition-group>
-          // to ensure removed elements stay in correct relative positions
-          // during leaving transitions
-          const canMove = !removeOnly;
-          {
-              checkDuplicateKeys(newCh);
-          }
-          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-              if (isUndef(oldStartVnode)) {
-                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-              }
-              else if (isUndef(oldEndVnode)) {
-                  oldEndVnode = oldCh[--oldEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newStartVnode)) {
-                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else if (sameVnode(oldEndVnode, newEndVnode)) {
-                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newEndVnode)) {
-                  // Vnode moved right
-                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldEndVnode, newStartVnode)) {
-                  // Vnode moved left
-                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else {
-                  if (isUndef(oldKeyToIdx))
-                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                  idxInOld = isDef(newStartVnode.key)
-                      ? oldKeyToIdx[newStartVnode.key]
-                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                  if (isUndef(idxInOld)) {
-                      // New element
-                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                  }
-                  else {
-                      vnodeToMove = oldCh[idxInOld];
-                      if (sameVnode(vnodeToMove, newStartVnode)) {
-                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                          oldCh[idxInOld] = undefined;
-                          canMove &&
-                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                      }
-                      else {
-                          // same key but different element. treat as new element
-                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                      }
-                  }
-                  newStartVnode = newCh[++newStartIdx];
-              }
-          }
-          if (oldStartIdx > oldEndIdx) {
-              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-          }
-          else if (newStartIdx > newEndIdx) {
-              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-          }
-      }
-      function checkDuplicateKeys(children) {
-          const seenKeys = {};
-          for (let i = 0; i < children.length; i++) {
-              const vnode = children[i];
-              const key = vnode.key;
-              if (isDef(key)) {
-                  if (seenKeys[key]) {
-                      warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                  }
-                  else {
-                      seenKeys[key] = true;
-                  }
-              }
-          }
-      }
-      function findIdxInOld(node, oldCh, start, end) {
-          for (let i = start; i < end; i++) {
-              const c = oldCh[i];
-              if (isDef(c) && sameVnode(node, c))
-                  return i;
-          }
-      }
-      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-          if (oldVnode === vnode) {
-              return;
-          }
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // clone reused vnode
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          const elm = (vnode.elm = oldVnode.elm);
-          if (isTrue(oldVnode.isAsyncPlaceholder)) {
-              if (isDef(vnode.asyncFactory.resolved)) {
-                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-              }
-              else {
-                  vnode.isAsyncPlaceholder = true;
-              }
-              return;
-          }
-          // reuse element for static trees.
-          // note we only do this if the vnode is cloned -
-          // if the new node is not cloned it means the render functions have been
-          // reset by the hot-reload-api and we need to do a proper re-render.
-          if (isTrue(vnode.isStatic) &&
-              isTrue(oldVnode.isStatic) &&
-              vnode.key === oldVnode.key &&
-              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-              vnode.componentInstance = oldVnode.componentInstance;
-              return;
-          }
-          let i;
-          const data = vnode.data;
-          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-              i(oldVnode, vnode);
-          }
-          const oldCh = oldVnode.children;
-          const ch = vnode.children;
-          if (isDef(data) && isPatchable(vnode)) {
-              for (i = 0; i < cbs.update.length; ++i)
-                  cbs.update[i](oldVnode, vnode);
-              if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  i(oldVnode, vnode);
-          }
-          if (isUndef(vnode.text)) {
-              if (isDef(oldCh) && isDef(ch)) {
-                  if (oldCh !== ch)
-                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-              }
-              else if (isDef(ch)) {
-                  {
-                      checkDuplicateKeys(ch);
-                  }
-                  if (isDef(oldVnode.text))
-                      nodeOps.setTextContent(elm, '');
-                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-              }
-              else if (isDef(oldCh)) {
-                  removeVnodes(oldCh, 0, oldCh.length - 1);
-              }
-              else if (isDef(oldVnode.text)) {
-                  nodeOps.setTextContent(elm, '');
-              }
-          }
-          else if (oldVnode.text !== vnode.text) {
-              nodeOps.setTextContent(elm, vnode.text);
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  i(oldVnode, vnode);
-          }
-      }
-      function invokeInsertHook(vnode, queue, initial) {
-          // delay insert hooks for component root nodes, invoke them after the
-          // element is really inserted
-          if (isTrue(initial) && isDef(vnode.parent)) {
-              vnode.parent.data.pendingInsert = queue;
-          }
-          else {
-              for (let i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
-              }
-          }
-      }
-      let hydrationBailed = false;
-      // list of modules that can skip create hook during hydration because they
-      // are already rendered on the client or has no need for initialization
-      // Note: style is excluded because it relies on initial clone for future
-      // deep updates (#7063).
-      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-      // Note: this is a browser-only function so we can assume elms are DOM nodes.
-      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          let i;
-          const { tag, data, children } = vnode;
-          inVPre = inVPre || (data && data.pre);
-          vnode.elm = elm;
-          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-              vnode.isAsyncPlaceholder = true;
-              return true;
-          }
-          // assert node match
-          {
-              if (!assertNodeMatch(elm, vnode, inVPre)) {
-                  return false;
-              }
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  i(vnode, true /* hydrating */);
-              if (isDef((i = vnode.componentInstance))) {
-                  // child component. it should have hydrated its own tree.
-                  initComponent(vnode, insertedVnodeQueue);
-                  return true;
-              }
-          }
-          if (isDef(tag)) {
-              if (isDef(children)) {
-                  // empty element, allow client to pick up and populate children
-                  if (!elm.hasChildNodes()) {
-                      createChildren(vnode, children, insertedVnodeQueue);
-                  }
-                  else {
-                      // v-html and domProps: innerHTML
-                      if (isDef((i = data)) &&
-                          isDef((i = i.domProps)) &&
-                          isDef((i = i.innerHTML))) {
-                          if (i !== elm.innerHTML) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('server innerHTML: ', i);
-                                  console.warn('client innerHTML: ', elm.innerHTML);
-                              }
-                              return false;
-                          }
-                      }
-                      else {
-                          // iterate and compare children lists
-                          let childrenMatch = true;
-                          let childNode = elm.firstChild;
-                          for (let i = 0; i < children.length; i++) {
-                              if (!childNode ||
-                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                  childrenMatch = false;
-                                  break;
-                              }
-                              childNode = childNode.nextSibling;
-                          }
-                          // if childNode is not null, it means the actual childNodes list is
-                          // longer than the virtual children list.
-                          if (!childrenMatch || childNode) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                              }
-                              return false;
-                          }
-                      }
-                  }
-              }
-              if (isDef(data)) {
-                  let fullInvoke = false;
-                  for (const key in data) {
-                      if (!isRenderedModule(key)) {
-                          fullInvoke = true;
-                          invokeCreateHooks(vnode, insertedVnodeQueue);
-                          break;
-                      }
-                  }
-                  if (!fullInvoke && data['class']) {
-                      // ensure collecting deps for deep class bindings for future updates
-                      traverse(data['class']);
-                  }
-              }
-          }
-          else if (elm.data !== vnode.text) {
-              elm.data = vnode.text;
-          }
-          return true;
-      }
-      function assertNodeMatch(node, vnode, inVPre) {
-          if (isDef(vnode.tag)) {
-              return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement(vnode, inVPre) &&
-                      vnode.tag.toLowerCase() ===
-                          (node.tagName && node.tagName.toLowerCase())));
-          }
-          else {
-              return node.nodeType === (vnode.isComment ? 8 : 3);
-          }
-      }
-      return function patch(oldVnode, vnode, hydrating, removeOnly) {
-          if (isUndef(vnode)) {
-              if (isDef(oldVnode))
-                  invokeDestroyHook(oldVnode);
-              return;
-          }
-          let isInitialPatch = false;
-          const insertedVnodeQueue = [];
-          if (isUndef(oldVnode)) {
-              // empty mount (likely as component), create new root element
-              isInitialPatch = true;
-              createElm(vnode, insertedVnodeQueue);
-          }
-          else {
-              const isRealElement = isDef(oldVnode.nodeType);
-              if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                  // patch existing root node
-                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-              }
-              else {
-                  if (isRealElement) {
-                      // mounting to a real element
-                      // check if this is server-rendered content and if we can perform
-                      // a successful hydration.
-                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                          oldVnode.removeAttribute(SSR_ATTR);
-                          hydrating = true;
-                      }
-                      if (isTrue(hydrating)) {
-                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                              invokeInsertHook(vnode, insertedVnodeQueue, true);
-                              return oldVnode;
-                          }
-                          else {
-                              warn('The client-side rendered virtual DOM tree is not matching ' +
-                                  'server-rendered content. This is likely caused by incorrect ' +
-                                  'HTML markup, for example nesting block-level elements inside ' +
-                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                  'full client-side render.');
-                          }
-                      }
-                      // either not server-rendered, or hydration failed.
-                      // create an empty node and replace it
-                      oldVnode = emptyNodeAt(oldVnode);
-                  }
-                  // replacing existing element
-                  const oldElm = oldVnode.elm;
-                  const parentElm = nodeOps.parentNode(oldElm);
-                  // create new node
-                  createElm(vnode, insertedVnodeQueue, 
-                  // extremely rare edge case: do not insert if old element is in a
-                  // leaving transition. Only happens when combining transition +
-                  // keep-alive + HOCs. (#4590)
-                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                  // update parent placeholder node element, recursively
-                  if (isDef(vnode.parent)) {
-                      let ancestor = vnode.parent;
-                      const patchable = isPatchable(vnode);
-                      while (ancestor) {
-                          for (let i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
-                          }
-                          ancestor.elm = vnode.elm;
-                          if (patchable) {
-                              for (let i = 0; i < cbs.create.length; ++i) {
-                                  cbs.create[i](emptyNode, ancestor);
-                              }
-                              // #6513
-                              // invoke insert hooks that may have been merged by create hooks.
-                              // e.g. for directives that uses the "inserted" hook.
-                              const insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
-                                  // start at index 1 to avoid re-invoking component mounted hook
-                                  for (let i = 1; i < insert.fns.length; i++) {
-                                      insert.fns[i]();
-                                  }
-                              }
-                          }
-                          else {
-                              registerRef(ancestor);
-                          }
-                          ancestor = ancestor.parent;
-                      }
-                  }
-                  // destroy old node
-                  if (isDef(parentElm)) {
-                      removeVnodes([oldVnode], 0, 0);
-                  }
-                  else if (isDef(oldVnode.tag)) {
-                      invokeDestroyHook(oldVnode);
-                  }
-              }
-          }
-          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-          return vnode.elm;
-      };
+  /**
+   * Virtual DOM patching algorithm based on Snabbdom by
+   * Simon Friis Vindum (@paldepind)
+   * Licensed under the MIT License
+   * https://github.com/paldepind/snabbdom/blob/master/LICENSE
+   *
+   * modified by Evan You (@yyx990803)
+   *
+   * Not type-checking this because this file is perf-critical and the cost
+   * of making flow understand it is not worth it.
+   */
+  const emptyNode = new VNode('', {}, []);
+  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
+  function sameVnode(a, b) {
+      return (a.key === b.key &&
+          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
+          a.isComment === b.isComment &&
+          isDef(a.data) === isDef(b.data) &&
+          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
+          isUndef(b.asyncFactory.error))));
+  }
+  function sameInputType(a, b) {
+      if (a.tag !== 'input')
+          return true;
+      let i;
+      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
+      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
+      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
+  }
+  function createKeyToOldIdx(children, beginIdx, endIdx) {
+      let i, key;
+      const map = {};
+      for (i = beginIdx; i <= endIdx; ++i) {
+          key = children[i].key;
+          if (isDef(key))
+              map[key] = i;
+      }
+      return map;
+  }
+  function createPatchFunction(backend) {
+      let i, j;
+      const cbs = {};
+      const { modules, nodeOps } = backend;
+      for (i = 0; i < hooks.length; ++i) {
+          cbs[hooks[i]] = [];
+          for (j = 0; j < modules.length; ++j) {
+              if (isDef(modules[j][hooks[i]])) {
+                  cbs[hooks[i]].push(modules[j][hooks[i]]);
+              }
+          }
+      }
+      function emptyNodeAt(elm) {
+          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
+      }
+      function createRmCb(childElm, listeners) {
+          function remove() {
+              if (--remove.listeners === 0) {
+                  removeNode(childElm);
+              }
+          }
+          remove.listeners = listeners;
+          return remove;
+      }
+      function removeNode(el) {
+          const parent = nodeOps.parentNode(el);
+          // element may have already been removed due to v-html / v-text
+          if (isDef(parent)) {
+              nodeOps.removeChild(parent, el);
+          }
+      }
+      function isUnknownElement(vnode, inVPre) {
+          return (!inVPre &&
+              !vnode.ns &&
+              !(config.ignoredElements.length &&
+                  config.ignoredElements.some((ignore) => {
+                      return isRegExp(ignore)
+                          ? ignore.test(vnode.tag)
+                          : ignore === vnode.tag;
+                  })) &&
+              config.isUnknownElement(vnode.tag));
+      }
+      let creatingElmInVPre = 0;
+      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // This vnode was used in a previous render!
+              // now it's used as a new node, overwriting its elm would cause
+              // potential patch errors down the road when it's used as an insertion
+              // reference node. Instead, we clone the node on-demand before creating
+              // associated DOM element for it.
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          vnode.isRootInsert = !nested; // for transition enter check
+          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
+              return;
+          }
+          const data = vnode.data;
+          const children = vnode.children;
+          const tag = vnode.tag;
+          if (isDef(tag)) {
+              {
+                  if (data && data.pre) {
+                      creatingElmInVPre++;
+                  }
+                  if (isUnknownElement(vnode, creatingElmInVPre)) {
+                      warn('Unknown custom element: <' +
+                          tag +
+                          '> - did you ' +
+                          'register the component correctly? For recursive components, ' +
+                          'make sure to provide the "name" option.', vnode.context);
+                  }
+              }
+              vnode.elm = vnode.ns
+                  ? nodeOps.createElementNS(vnode.ns, tag)
+                  : nodeOps.createElement(tag, vnode);
+              setScope(vnode);
+              /* istanbul ignore if */
+              {
+                  createChildren(vnode, children, insertedVnodeQueue);
+                  if (isDef(data)) {
+                      invokeCreateHooks(vnode, insertedVnodeQueue);
+                  }
+                  insert(parentElm, vnode.elm, refElm);
+              }
+              if (data && data.pre) {
+                  creatingElmInVPre--;
+              }
+          }
+          else if (isTrue(vnode.isComment)) {
+              vnode.elm = nodeOps.createComment(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+          else {
+              vnode.elm = nodeOps.createTextNode(vnode.text);
+              insert(parentElm, vnode.elm, refElm);
+          }
+      }
+      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          let i = vnode.data;
+          if (isDef(i)) {
+              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
+              if (isDef((i = i.hook)) && isDef((i = i.init))) {
+                  i(vnode, false /* hydrating */);
+              }
+              // after calling the init hook, if the vnode is a child component
+              // it should've created a child instance and mounted it. the child
+              // component also has set the placeholder vnode's elm.
+              // in that case we can just return the element and be done.
+              if (isDef(vnode.componentInstance)) {
+                  initComponent(vnode, insertedVnodeQueue);
+                  insert(parentElm, vnode.elm, refElm);
+                  if (isTrue(isReactivated)) {
+                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
+                  }
+                  return true;
+              }
+          }
+      }
+      function initComponent(vnode, insertedVnodeQueue) {
+          if (isDef(vnode.data.pendingInsert)) {
+              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
+              vnode.data.pendingInsert = null;
+          }
+          vnode.elm = vnode.componentInstance.$el;
+          if (isPatchable(vnode)) {
+              invokeCreateHooks(vnode, insertedVnodeQueue);
+              setScope(vnode);
+          }
+          else {
+              // empty component root.
+              // skip all element-related modules except for ref (#3455)
+              registerRef(vnode);
+              // make sure to invoke the insert hook
+              insertedVnodeQueue.push(vnode);
+          }
+      }
+      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
+          let i;
+          // hack for #4339: a reactivated component with inner transition
+          // does not trigger because the inner node's created hooks are not called
+          // again. It's not ideal to involve module-specific logic in here but
+          // there doesn't seem to be a better way to do it.
+          let innerNode = vnode;
+          while (innerNode.componentInstance) {
+              innerNode = innerNode.componentInstance._vnode;
+              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
+                  for (i = 0; i < cbs.activate.length; ++i) {
+                      cbs.activate[i](emptyNode, innerNode);
+                  }
+                  insertedVnodeQueue.push(innerNode);
+                  break;
+              }
+          }
+          // unlike a newly created component,
+          // a reactivated keep-alive component doesn't insert itself
+          insert(parentElm, vnode.elm, refElm);
+      }
+      function insert(parent, elm, ref) {
+          if (isDef(parent)) {
+              if (isDef(ref)) {
+                  if (nodeOps.parentNode(ref) === parent) {
+                      nodeOps.insertBefore(parent, elm, ref);
+                  }
+              }
+              else {
+                  nodeOps.appendChild(parent, elm);
+              }
+          }
+      }
+      function createChildren(vnode, children, insertedVnodeQueue) {
+          if (Array.isArray(children)) {
+              {
+                  checkDuplicateKeys(children);
+              }
+              for (let i = 0; i < children.length; ++i) {
+                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
+              }
+          }
+          else if (isPrimitive(vnode.text)) {
+              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+          }
+      }
+      function isPatchable(vnode) {
+          while (vnode.componentInstance) {
+              vnode = vnode.componentInstance._vnode;
+          }
+          return isDef(vnode.tag);
+      }
+      function invokeCreateHooks(vnode, insertedVnodeQueue) {
+          for (let i = 0; i < cbs.create.length; ++i) {
+              cbs.create[i](emptyNode, vnode);
+          }
+          i = vnode.data.hook; // Reuse variable
+          if (isDef(i)) {
+              if (isDef(i.create))
+                  i.create(emptyNode, vnode);
+              if (isDef(i.insert))
+                  insertedVnodeQueue.push(vnode);
+          }
+      }
+      // set scope id attribute for scoped CSS.
+      // this is implemented as a special case to avoid the overhead
+      // of going through the normal attribute patching process.
+      function setScope(vnode) {
+          let i;
+          if (isDef((i = vnode.fnScopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+          else {
+              let ancestor = vnode;
+              while (ancestor) {
+                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
+                      nodeOps.setStyleScope(vnode.elm, i);
+                  }
+                  ancestor = ancestor.parent;
+              }
+          }
+          // for slot content they should also get the scopeId from the host instance.
+          if (isDef((i = activeInstance)) &&
+              i !== vnode.context &&
+              i !== vnode.fnContext &&
+              isDef((i = i.$options._scopeId))) {
+              nodeOps.setStyleScope(vnode.elm, i);
+          }
+      }
+      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
+          }
+      }
+      function invokeDestroyHook(vnode) {
+          let i, j;
+          const data = vnode.data;
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
+                  i(vnode);
+              for (i = 0; i < cbs.destroy.length; ++i)
+                  cbs.destroy[i](vnode);
+          }
+          if (isDef((i = vnode.children))) {
+              for (j = 0; j < vnode.children.length; ++j) {
+                  invokeDestroyHook(vnode.children[j]);
+              }
+          }
+      }
+      function removeVnodes(vnodes, startIdx, endIdx) {
+          for (; startIdx <= endIdx; ++startIdx) {
+              const ch = vnodes[startIdx];
+              if (isDef(ch)) {
+                  if (isDef(ch.tag)) {
+                      removeAndInvokeRemoveHook(ch);
+                      invokeDestroyHook(ch);
+                  }
+                  else {
+                      // Text node
+                      removeNode(ch.elm);
+                  }
+              }
+          }
+      }
+      function removeAndInvokeRemoveHook(vnode, rm) {
+          if (isDef(rm) || isDef(vnode.data)) {
+              let i;
+              const listeners = cbs.remove.length + 1;
+              if (isDef(rm)) {
+                  // we have a recursively passed down rm callback
+                  // increase the listeners count
+                  rm.listeners += listeners;
+              }
+              else {
+                  // directly removing
+                  rm = createRmCb(vnode.elm, listeners);
+              }
+              // recursively invoke hooks on child component root node
+              if (isDef((i = vnode.componentInstance)) &&
+                  isDef((i = i._vnode)) &&
+                  isDef(i.data)) {
+                  removeAndInvokeRemoveHook(i, rm);
+              }
+              for (i = 0; i < cbs.remove.length; ++i) {
+                  cbs.remove[i](vnode, rm);
+              }
+              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
+                  i(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          }
+          else {
+              removeNode(vnode.elm);
+          }
+      }
+      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
+          let oldStartIdx = 0;
+          let newStartIdx = 0;
+          let oldEndIdx = oldCh.length - 1;
+          let oldStartVnode = oldCh[0];
+          let oldEndVnode = oldCh[oldEndIdx];
+          let newEndIdx = newCh.length - 1;
+          let newStartVnode = newCh[0];
+          let newEndVnode = newCh[newEndIdx];
+          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
+          // removeOnly is a special flag used only by <transition-group>
+          // to ensure removed elements stay in correct relative positions
+          // during leaving transitions
+          const canMove = !removeOnly;
+          {
+              checkDuplicateKeys(newCh);
+          }
+          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
+              if (isUndef(oldStartVnode)) {
+                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
+              }
+              else if (isUndef(oldEndVnode)) {
+                  oldEndVnode = oldCh[--oldEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newStartVnode)) {
+                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else if (sameVnode(oldEndVnode, newEndVnode)) {
+                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldStartVnode, newEndVnode)) {
+                  // Vnode moved right
+                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
+                  oldStartVnode = oldCh[++oldStartIdx];
+                  newEndVnode = newCh[--newEndIdx];
+              }
+              else if (sameVnode(oldEndVnode, newStartVnode)) {
+                  // Vnode moved left
+                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                  canMove &&
+                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
+                  oldEndVnode = oldCh[--oldEndIdx];
+                  newStartVnode = newCh[++newStartIdx];
+              }
+              else {
+                  if (isUndef(oldKeyToIdx))
+                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
+                  idxInOld = isDef(newStartVnode.key)
+                      ? oldKeyToIdx[newStartVnode.key]
+                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
+                  if (isUndef(idxInOld)) {
+                      // New element
+                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                  }
+                  else {
+                      vnodeToMove = oldCh[idxInOld];
+                      if (sameVnode(vnodeToMove, newStartVnode)) {
+                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
+                          oldCh[idxInOld] = undefined;
+                          canMove &&
+                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
+                      }
+                      else {
+                          // same key but different element. treat as new element
+                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
+                      }
+                  }
+                  newStartVnode = newCh[++newStartIdx];
+              }
+          }
+          if (oldStartIdx > oldEndIdx) {
+              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
+              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
+          }
+          else if (newStartIdx > newEndIdx) {
+              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
+          }
+      }
+      function checkDuplicateKeys(children) {
+          const seenKeys = {};
+          for (let i = 0; i < children.length; i++) {
+              const vnode = children[i];
+              const key = vnode.key;
+              if (isDef(key)) {
+                  if (seenKeys[key]) {
+                      warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
+                  }
+                  else {
+                      seenKeys[key] = true;
+                  }
+              }
+          }
+      }
+      function findIdxInOld(node, oldCh, start, end) {
+          for (let i = start; i < end; i++) {
+              const c = oldCh[i];
+              if (isDef(c) && sameVnode(node, c))
+                  return i;
+          }
+      }
+      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
+          if (oldVnode === vnode) {
+              return;
+          }
+          if (isDef(vnode.elm) && isDef(ownerArray)) {
+              // clone reused vnode
+              vnode = ownerArray[index] = cloneVNode(vnode);
+          }
+          const elm = (vnode.elm = oldVnode.elm);
+          if (isTrue(oldVnode.isAsyncPlaceholder)) {
+              if (isDef(vnode.asyncFactory.resolved)) {
+                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
+              }
+              else {
+                  vnode.isAsyncPlaceholder = true;
+              }
+              return;
+          }
+          // reuse element for static trees.
+          // note we only do this if the vnode is cloned -
+          // if the new node is not cloned it means the render functions have been
+          // reset by the hot-reload-api and we need to do a proper re-render.
+          if (isTrue(vnode.isStatic) &&
+              isTrue(oldVnode.isStatic) &&
+              vnode.key === oldVnode.key &&
+              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
+              vnode.componentInstance = oldVnode.componentInstance;
+              return;
+          }
+          let i;
+          const data = vnode.data;
+          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
+              i(oldVnode, vnode);
+          }
+          const oldCh = oldVnode.children;
+          const ch = vnode.children;
+          if (isDef(data) && isPatchable(vnode)) {
+              for (i = 0; i < cbs.update.length; ++i)
+                  cbs.update[i](oldVnode, vnode);
+              if (isDef((i = data.hook)) && isDef((i = i.update)))
+                  i(oldVnode, vnode);
+          }
+          if (isUndef(vnode.text)) {
+              if (isDef(oldCh) && isDef(ch)) {
+                  if (oldCh !== ch)
+                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
+              }
+              else if (isDef(ch)) {
+                  {
+                      checkDuplicateKeys(ch);
+                  }
+                  if (isDef(oldVnode.text))
+                      nodeOps.setTextContent(elm, '');
+                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
+              }
+              else if (isDef(oldCh)) {
+                  removeVnodes(oldCh, 0, oldCh.length - 1);
+              }
+              else if (isDef(oldVnode.text)) {
+                  nodeOps.setTextContent(elm, '');
+              }
+          }
+          else if (oldVnode.text !== vnode.text) {
+              nodeOps.setTextContent(elm, vnode.text);
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
+                  i(oldVnode, vnode);
+          }
+      }
+      function invokeInsertHook(vnode, queue, initial) {
+          // delay insert hooks for component root nodes, invoke them after the
+          // element is really inserted
+          if (isTrue(initial) && isDef(vnode.parent)) {
+              vnode.parent.data.pendingInsert = queue;
+          }
+          else {
+              for (let i = 0; i < queue.length; ++i) {
+                  queue[i].data.hook.insert(queue[i]);
+              }
+          }
+      }
+      let hydrationBailed = false;
+      // list of modules that can skip create hook during hydration because they
+      // are already rendered on the client or has no need for initialization
+      // Note: style is excluded because it relies on initial clone for future
+      // deep updates (#7063).
+      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
+      // Note: this is a browser-only function so we can assume elms are DOM nodes.
+      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
+          let i;
+          const { tag, data, children } = vnode;
+          inVPre = inVPre || (data && data.pre);
+          vnode.elm = elm;
+          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
+              vnode.isAsyncPlaceholder = true;
+              return true;
+          }
+          // assert node match
+          {
+              if (!assertNodeMatch(elm, vnode, inVPre)) {
+                  return false;
+              }
+          }
+          if (isDef(data)) {
+              if (isDef((i = data.hook)) && isDef((i = i.init)))
+                  i(vnode, true /* hydrating */);
+              if (isDef((i = vnode.componentInstance))) {
+                  // child component. it should have hydrated its own tree.
+                  initComponent(vnode, insertedVnodeQueue);
+                  return true;
+              }
+          }
+          if (isDef(tag)) {
+              if (isDef(children)) {
+                  // empty element, allow client to pick up and populate children
+                  if (!elm.hasChildNodes()) {
+                      createChildren(vnode, children, insertedVnodeQueue);
+                  }
+                  else {
+                      // v-html and domProps: innerHTML
+                      if (isDef((i = data)) &&
+                          isDef((i = i.domProps)) &&
+                          isDef((i = i.innerHTML))) {
+                          if (i !== elm.innerHTML) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('server innerHTML: ', i);
+                                  console.warn('client innerHTML: ', elm.innerHTML);
+                              }
+                              return false;
+                          }
+                      }
+                      else {
+                          // iterate and compare children lists
+                          let childrenMatch = true;
+                          let childNode = elm.firstChild;
+                          for (let i = 0; i < children.length; i++) {
+                              if (!childNode ||
+                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
+                                  childrenMatch = false;
+                                  break;
+                              }
+                              childNode = childNode.nextSibling;
+                          }
+                          // if childNode is not null, it means the actual childNodes list is
+                          // longer than the virtual children list.
+                          if (!childrenMatch || childNode) {
+                              /* istanbul ignore if */
+                              if (typeof console !== 'undefined' &&
+                                  !hydrationBailed) {
+                                  hydrationBailed = true;
+                                  console.warn('Parent: ', elm);
+                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
+                              }
+                              return false;
+                          }
+                      }
+                  }
+              }
+              if (isDef(data)) {
+                  let fullInvoke = false;
+                  for (const key in data) {
+                      if (!isRenderedModule(key)) {
+                          fullInvoke = true;
+                          invokeCreateHooks(vnode, insertedVnodeQueue);
+                          break;
+                      }
+                  }
+                  if (!fullInvoke && data['class']) {
+                      // ensure collecting deps for deep class bindings for future updates
+                      traverse(data['class']);
+                  }
+              }
+          }
+          else if (elm.data !== vnode.text) {
+              elm.data = vnode.text;
+          }
+          return true;
+      }
+      function assertNodeMatch(node, vnode, inVPre) {
+          if (isDef(vnode.tag)) {
+              return (vnode.tag.indexOf('vue-component') === 0 ||
+                  (!isUnknownElement(vnode, inVPre) &&
+                      vnode.tag.toLowerCase() ===
+                          (node.tagName && node.tagName.toLowerCase())));
+          }
+          else {
+              return node.nodeType === (vnode.isComment ? 8 : 3);
+          }
+      }
+      return function patch(oldVnode, vnode, hydrating, removeOnly) {
+          if (isUndef(vnode)) {
+              if (isDef(oldVnode))
+                  invokeDestroyHook(oldVnode);
+              return;
+          }
+          let isInitialPatch = false;
+          const insertedVnodeQueue = [];
+          if (isUndef(oldVnode)) {
+              // empty mount (likely as component), create new root element
+              isInitialPatch = true;
+              createElm(vnode, insertedVnodeQueue);
+          }
+          else {
+              const isRealElement = isDef(oldVnode.nodeType);
+              if (!isRealElement && sameVnode(oldVnode, vnode)) {
+                  // patch existing root node
+                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
+              }
+              else {
+                  if (isRealElement) {
+                      // mounting to a real element
+                      // check if this is server-rendered content and if we can perform
+                      // a successful hydration.
+                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
+                          oldVnode.removeAttribute(SSR_ATTR);
+                          hydrating = true;
+                      }
+                      if (isTrue(hydrating)) {
+                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
+                              invokeInsertHook(vnode, insertedVnodeQueue, true);
+                              return oldVnode;
+                          }
+                          else {
+                              warn('The client-side rendered virtual DOM tree is not matching ' +
+                                  'server-rendered content. This is likely caused by incorrect ' +
+                                  'HTML markup, for example nesting block-level elements inside ' +
+                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
+                                  'full client-side render.');
+                          }
+                      }
+                      // either not server-rendered, or hydration failed.
+                      // create an empty node and replace it
+                      oldVnode = emptyNodeAt(oldVnode);
+                  }
+                  // replacing existing element
+                  const oldElm = oldVnode.elm;
+                  const parentElm = nodeOps.parentNode(oldElm);
+                  // create new node
+                  createElm(vnode, insertedVnodeQueue, 
+                  // extremely rare edge case: do not insert if old element is in a
+                  // leaving transition. Only happens when combining transition +
+                  // keep-alive + HOCs. (#4590)
+                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
+                  // update parent placeholder node element, recursively
+                  if (isDef(vnode.parent)) {
+                      let ancestor = vnode.parent;
+                      const patchable = isPatchable(vnode);
+                      while (ancestor) {
+                          for (let i = 0; i < cbs.destroy.length; ++i) {
+                              cbs.destroy[i](ancestor);
+                          }
+                          ancestor.elm = vnode.elm;
+                          if (patchable) {
+                              for (let i = 0; i < cbs.create.length; ++i) {
+                                  cbs.create[i](emptyNode, ancestor);
+                              }
+                              // #6513
+                              // invoke insert hooks that may have been merged by create hooks.
+                              // e.g. for directives that uses the "inserted" hook.
+                              const insert = ancestor.data.hook.insert;
+                              if (insert.merged) {
+                                  // start at index 1 to avoid re-invoking component mounted hook
+                                  for (let i = 1; i < insert.fns.length; i++) {
+                                      insert.fns[i]();
+                                  }
+                              }
+                          }
+                          else {
+                              registerRef(ancestor);
+                          }
+                          ancestor = ancestor.parent;
+                      }
+                  }
+                  // destroy old node
+                  if (isDef(parentElm)) {
+                      removeVnodes([oldVnode], 0, 0);
+                  }
+                  else if (isDef(oldVnode.tag)) {
+                      invokeDestroyHook(oldVnode);
+                  }
+              }
+          }
+          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
+          return vnode.elm;
+      };
   }
 
-  var directives = {
-      create: updateDirectives,
-      update: updateDirectives,
-      destroy: function unbindDirectives(vnode) {
-          // @ts-expect-error emptyNode is not VNodeWithData
-          updateDirectives(vnode, emptyNode);
-      },
-  };
-  function updateDirectives(oldVnode, vnode) {
-      if (oldVnode.data.directives || vnode.data.directives) {
-          _update(oldVnode, vnode);
-      }
-  }
-  function _update(oldVnode, vnode) {
-      const isCreate = oldVnode === emptyNode;
-      const isDestroy = vnode === emptyNode;
-      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      const dirsWithInsert = [];
-      const dirsWithPostpatch = [];
-      let key, oldDir, dir;
-      for (key in newDirs) {
-          oldDir = oldDirs[key];
-          dir = newDirs[key];
-          if (!oldDir) {
-              // new directive, bind
-              callHook(dir, 'bind', vnode, oldVnode);
-              if (dir.def && dir.def.inserted) {
-                  dirsWithInsert.push(dir);
-              }
-          }
-          else {
-              // existing directive, update
-              dir.oldValue = oldDir.value;
-              dir.oldArg = oldDir.arg;
-              callHook(dir, 'update', vnode, oldVnode);
-              if (dir.def && dir.def.componentUpdated) {
-                  dirsWithPostpatch.push(dir);
-              }
-          }
-      }
-      if (dirsWithInsert.length) {
-          const callInsert = () => {
-              for (let i = 0; i < dirsWithInsert.length; i++) {
-                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-              }
-          };
-          if (isCreate) {
-              mergeVNodeHook(vnode, 'insert', callInsert);
-          }
-          else {
-              callInsert();
-          }
-      }
-      if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', () => {
-              for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-              }
-          });
-      }
-      if (!isCreate) {
-          for (key in oldDirs) {
-              if (!newDirs[key]) {
-                  // no longer present, unbind
-                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-              }
-          }
-      }
-  }
-  const emptyModifiers = Object.create(null);
-  function normalizeDirectives(dirs, vm) {
-      const res = Object.create(null);
-      if (!dirs) {
-          // $flow-disable-line
-          return res;
-      }
-      let i, dir;
-      for (i = 0; i < dirs.length; i++) {
-          dir = dirs[i];
-          if (!dir.modifiers) {
-              // $flow-disable-line
-              dir.modifiers = emptyModifiers;
-          }
-          res[getRawDirName(dir)] = dir;
-          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-      }
-      // $flow-disable-line
-      return res;
-  }
-  function getRawDirName(dir) {
-      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-  }
-  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      const fn = dir.def && dir.def[hook];
-      if (fn) {
-          try {
-              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-          }
-          catch (e) {
-              // @ts-expect-error should it be any?
-              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-          }
-      }
+  var directives = {
+      create: updateDirectives,
+      update: updateDirectives,
+      destroy: function unbindDirectives(vnode) {
+          // @ts-expect-error emptyNode is not VNodeWithData
+          updateDirectives(vnode, emptyNode);
+      },
+  };
+  function updateDirectives(oldVnode, vnode) {
+      if (oldVnode.data.directives || vnode.data.directives) {
+          _update(oldVnode, vnode);
+      }
+  }
+  function _update(oldVnode, vnode) {
+      const isCreate = oldVnode === emptyNode;
+      const isDestroy = vnode === emptyNode;
+      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
+      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
+      const dirsWithInsert = [];
+      const dirsWithPostpatch = [];
+      let key, oldDir, dir;
+      for (key in newDirs) {
+          oldDir = oldDirs[key];
+          dir = newDirs[key];
+          if (!oldDir) {
+              // new directive, bind
+              callHook(dir, 'bind', vnode, oldVnode);
+              if (dir.def && dir.def.inserted) {
+                  dirsWithInsert.push(dir);
+              }
+          }
+          else {
+              // existing directive, update
+              dir.oldValue = oldDir.value;
+              dir.oldArg = oldDir.arg;
+              callHook(dir, 'update', vnode, oldVnode);
+              if (dir.def && dir.def.componentUpdated) {
+                  dirsWithPostpatch.push(dir);
+              }
+          }
+      }
+      if (dirsWithInsert.length) {
+          const callInsert = () => {
+              for (let i = 0; i < dirsWithInsert.length; i++) {
+                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+              }
+          };
+          if (isCreate) {
+              mergeVNodeHook(vnode, 'insert', callInsert);
+          }
+          else {
+              callInsert();
+          }
+      }
+      if (dirsWithPostpatch.length) {
+          mergeVNodeHook(vnode, 'postpatch', () => {
+              for (let i = 0; i < dirsWithPostpatch.length; i++) {
+                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+              }
+          });
+      }
+      if (!isCreate) {
+          for (key in oldDirs) {
+              if (!newDirs[key]) {
+                  // no longer present, unbind
+                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+              }
+          }
+      }
+  }
+  const emptyModifiers = Object.create(null);
+  function normalizeDirectives(dirs, vm) {
+      const res = Object.create(null);
+      if (!dirs) {
+          // $flow-disable-line
+          return res;
+      }
+      let i, dir;
+      for (i = 0; i < dirs.length; i++) {
+          dir = dirs[i];
+          if (!dir.modifiers) {
+              // $flow-disable-line
+              dir.modifiers = emptyModifiers;
+          }
+          res[getRawDirName(dir)] = dir;
+          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+      }
+      // $flow-disable-line
+      return res;
+  }
+  function getRawDirName(dir) {
+      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
+  }
+  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
+      const fn = dir.def && dir.def[hook];
+      if (fn) {
+          try {
+              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
+          }
+          catch (e) {
+              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
+          }
+      }
   }
 
   var baseModules = [ref, directives];
 
-  function updateAttrs(oldVnode, vnode) {
-      const opts = vnode.componentOptions;
-      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-          return;
-      }
-      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-          return;
-      }
-      let key, cur, old;
-      const elm = vnode.elm;
-      const oldAttrs = oldVnode.data.attrs || {};
-      let attrs = vnode.data.attrs || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(attrs.__ob__)) {
-          attrs = vnode.data.attrs = extend({}, attrs);
-      }
-      for (key in attrs) {
-          cur = attrs[key];
-          old = oldAttrs[key];
-          if (old !== cur) {
-              setAttr(elm, key, cur, vnode.data.pre);
-          }
-      }
-      // #4391: in IE9, setting type can reset value for input[type=radio]
-      // #6666: IE/Edge forces progress value down to 1 before setting a max
-      /* istanbul ignore if */
-      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-          setAttr(elm, 'value', attrs.value);
-      }
-      for (key in oldAttrs) {
-          if (isUndef(attrs[key])) {
-              if (isXlink(key)) {
-                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-              }
-              else if (!isEnumeratedAttr(key)) {
-                  elm.removeAttribute(key);
-              }
-          }
-      }
-  }
-  function setAttr(el, key, value, isInPre) {
-      if (isInPre || el.tagName.indexOf('-') > -1) {
-          baseSetAttr(el, key, value);
-      }
-      else if (isBooleanAttr(key)) {
-          // set attribute for blank value
-          // e.g. <option disabled>Select one</option>
-          if (isFalsyAttrValue(value)) {
-              el.removeAttribute(key);
-          }
-          else {
-              // technically allowfullscreen is a boolean attribute for <iframe>,
-              // but Flash expects a value of "true" when used on <embed> tag
-              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-              el.setAttribute(key, value);
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          el.setAttribute(key, convertEnumeratedValue(key, value));
-      }
-      else if (isXlink(key)) {
-          if (isFalsyAttrValue(value)) {
-              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-          }
-          else {
-              el.setAttributeNS(xlinkNS, key, value);
-          }
-      }
-      else {
-          baseSetAttr(el, key, value);
-      }
-  }
-  function baseSetAttr(el, key, value) {
-      if (isFalsyAttrValue(value)) {
-          el.removeAttribute(key);
-      }
-      else {
-          // #7138: IE10 & 11 fires input event when setting placeholder on
-          // <textarea>... block the first input event and remove the blocker
-          // immediately.
-          /* istanbul ignore if */
-          if (isIE &&
-              !isIE9 &&
-              el.tagName === 'TEXTAREA' &&
-              key === 'placeholder' &&
-              value !== '' &&
-              !el.__ieph) {
-              const blocker = (e) => {
-                  e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
-              };
-              el.addEventListener('input', blocker);
-              // $flow-disable-line
-              el.__ieph = true; /* IE placeholder patched */
-          }
-          el.setAttribute(key, value);
-      }
-  }
-  var attrs = {
-      create: updateAttrs,
-      update: updateAttrs,
+  function updateAttrs(oldVnode, vnode) {
+      const opts = vnode.componentOptions;
+      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
+          return;
+      }
+      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
+          return;
+      }
+      let key, cur, old;
+      const elm = vnode.elm;
+      const oldAttrs = oldVnode.data.attrs || {};
+      let attrs = vnode.data.attrs || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(attrs.__ob__)) {
+          attrs = vnode.data.attrs = extend({}, attrs);
+      }
+      for (key in attrs) {
+          cur = attrs[key];
+          old = oldAttrs[key];
+          if (old !== cur) {
+              setAttr(elm, key, cur, vnode.data.pre);
+          }
+      }
+      // #4391: in IE9, setting type can reset value for input[type=radio]
+      // #6666: IE/Edge forces progress value down to 1 before setting a max
+      /* istanbul ignore if */
+      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
+          setAttr(elm, 'value', attrs.value);
+      }
+      for (key in oldAttrs) {
+          if (isUndef(attrs[key])) {
+              if (isXlink(key)) {
+                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
+              }
+              else if (!isEnumeratedAttr(key)) {
+                  elm.removeAttribute(key);
+              }
+          }
+      }
+  }
+  function setAttr(el, key, value, isInPre) {
+      if (isInPre || el.tagName.indexOf('-') > -1) {
+          baseSetAttr(el, key, value);
+      }
+      else if (isBooleanAttr(key)) {
+          // set attribute for blank value
+          // e.g. <option disabled>Select one</option>
+          if (isFalsyAttrValue(value)) {
+              el.removeAttribute(key);
+          }
+          else {
+              // technically allowfullscreen is a boolean attribute for <iframe>,
+              // but Flash expects a value of "true" when used on <embed> tag
+              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
+              el.setAttribute(key, value);
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          el.setAttribute(key, convertEnumeratedValue(key, value));
+      }
+      else if (isXlink(key)) {
+          if (isFalsyAttrValue(value)) {
+              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
+          }
+          else {
+              el.setAttributeNS(xlinkNS, key, value);
+          }
+      }
+      else {
+          baseSetAttr(el, key, value);
+      }
+  }
+  function baseSetAttr(el, key, value) {
+      if (isFalsyAttrValue(value)) {
+          el.removeAttribute(key);
+      }
+      else {
+          // #7138: IE10 & 11 fires input event when setting placeholder on
+          // <textarea>... block the first input event and remove the blocker
+          // immediately.
+          /* istanbul ignore if */
+          if (isIE &&
+              !isIE9 &&
+              el.tagName === 'TEXTAREA' &&
+              key === 'placeholder' &&
+              value !== '' &&
+              !el.__ieph) {
+              const blocker = (e) => {
+                  e.stopImmediatePropagation();
+                  el.removeEventListener('input', blocker);
+              };
+              el.addEventListener('input', blocker);
+              // $flow-disable-line
+              el.__ieph = true; /* IE placeholder patched */
+          }
+          el.setAttribute(key, value);
+      }
+  }
+  var attrs = {
+      create: updateAttrs,
+      update: updateAttrs,
   };
 
-  function updateClass(oldVnode, vnode) {
-      const el = vnode.elm;
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticClass) &&
-          isUndef(data.class) &&
-          (isUndef(oldData) ||
-              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-          return;
-      }
-      let cls = genClassForVnode(vnode);
-      // handle transition classes
-      const transitionClass = el._transitionClasses;
-      if (isDef(transitionClass)) {
-          cls = concat(cls, stringifyClass(transitionClass));
-      }
-      // set the class
-      if (cls !== el._prevClass) {
-          el.setAttribute('class', cls);
-          el._prevClass = cls;
-      }
-  }
-  var klass = {
-      create: updateClass,
-      update: updateClass,
+  function updateClass(oldVnode, vnode) {
+      const el = vnode.elm;
+      const data = vnode.data;
+      const oldData = oldVnode.data;
+      if (isUndef(data.staticClass) &&
+          isUndef(data.class) &&
+          (isUndef(oldData) ||
+              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
+          return;
+      }
+      let cls = genClassForVnode(vnode);
+      // handle transition classes
+      const transitionClass = el._transitionClasses;
+      if (isDef(transitionClass)) {
+          cls = concat(cls, stringifyClass(transitionClass));
+      }
+      // set the class
+      if (cls !== el._prevClass) {
+          el.setAttribute('class', cls);
+          el._prevClass = cls;
+      }
+  }
+  var klass = {
+      create: updateClass,
+      update: updateClass,
   };
 
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
+  // in some cases, the event used has to be determined at runtime
+  // so we used some reserved tokens during compile.
+  const RANGE_TOKEN = '__r';
   const CHECKBOX_RADIO_TOKEN = '__c';
 
-  // normalize v-model event tokens that can only be determined at runtime.
-  // it's important to place the event as the first in the array because
-  // the whole point is ensuring the v-model callback gets called before
-  // user-attached handlers.
-  function normalizeEvents(on) {
-      /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN])) {
-          // IE input[type=range] only supports `change` event
-          const event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-          delete on[RANGE_TOKEN];
-      }
-      // This was originally intended to fix #4521 but no longer necessary
-      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-      /* istanbul ignore if */
-      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-          delete on[CHECKBOX_RADIO_TOKEN];
-      }
-  }
-  let target;
-  function createOnceHandler(event, handler, capture) {
-      const _target = target; // save current target element in closure
-      return function onceHandler() {
-          const res = handler.apply(null, arguments);
-          if (res !== null) {
-              remove(event, onceHandler, capture, _target);
-          }
-      };
-  }
-  // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-  // implementation and does not fire microtasks in between event propagation, so
-  // safe to exclude.
-  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-  function add(name, handler, capture, passive) {
-      // async edge case #6566: inner click event triggers patch, event handler
-      // attached to outer element during patch, and triggered again. This
-      // happens because browsers fire microtask ticks between event propagation.
-      // the solution is simple: we save the timestamp when a handler is attached,
-      // and the handler would only fire if the event passed to it was fired
-      // AFTER it was attached.
-      if (useMicrotaskFix) {
-          const attachedTimestamp = currentFlushTimestamp;
-          const original = handler;
-          //@ts-expect-error 
-          handler = original._wrapper = function (e) {
-              if (
-              // no bubbling, should always fire.
-              // this is just a safety net in case event.timeStamp is unreliable in
-              // certain weird environments...
-              e.target === e.currentTarget ||
-                  // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
-                  // bail for environments that have buggy event.timeStamp implementations
-                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                  // #9681 QtWebEngine event.timeStamp is negative value
-                  e.timeStamp <= 0 ||
-                  // #9448 bail if event is fired in another document in a multi-page
-                  // electron/nw.js app, since event.timeStamp will be using a different
-                  // starting reference
-                  e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
-              }
-          };
-      }
-      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-  }
-  function remove(name, handler, capture, _target) {
-      (_target || target).removeEventListener(name, 
-      //@ts-expect-error
-      handler._wrapper || handler, capture);
-  }
-  function updateDOMListeners(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-          return;
-      }
-      const on = vnode.data.on || {};
-      const oldOn = oldVnode.data.on || {};
-      // vnode is empty when removing all listeners,
-      // and use old vnode dom element
-      target = vnode.elm || oldVnode.elm;
-      normalizeEvents(on);
-      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-      target = undefined;
-  }
-  var events = {
-      create: updateDOMListeners,
-      update: updateDOMListeners,
-      // @ts-expect-error emptyNode has actually data
-      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
+  // normalize v-model event tokens that can only be determined at runtime.
+  // it's important to place the event as the first in the array because
+  // the whole point is ensuring the v-model callback gets called before
+  // user-attached handlers.
+  function normalizeEvents(on) {
+      /* istanbul ignore if */
+      if (isDef(on[RANGE_TOKEN])) {
+          // IE input[type=range] only supports `change` event
+          const event = isIE ? 'change' : 'input';
+          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
+          delete on[RANGE_TOKEN];
+      }
+      // This was originally intended to fix #4521 but no longer necessary
+      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
+      /* istanbul ignore if */
+      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
+          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
+          delete on[CHECKBOX_RADIO_TOKEN];
+      }
+  }
+  let target;
+  function createOnceHandler(event, handler, capture) {
+      const _target = target; // save current target element in closure
+      return function onceHandler() {
+          const res = handler.apply(null, arguments);
+          if (res !== null) {
+              remove(event, onceHandler, capture, _target);
+          }
+      };
+  }
+  // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
+  // implementation and does not fire microtasks in between event propagation, so
+  // safe to exclude.
+  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
+  function add(name, handler, capture, passive) {
+      // async edge case #6566: inner click event triggers patch, event handler
+      // attached to outer element during patch, and triggered again. This
+      // happens because browsers fire microtask ticks between event propagation.
+      // the solution is simple: we save the timestamp when a handler is attached,
+      // and the handler would only fire if the event passed to it was fired
+      // AFTER it was attached.
+      if (useMicrotaskFix) {
+          const attachedTimestamp = currentFlushTimestamp;
+          const original = handler;
+          //@ts-expect-error 
+          handler = original._wrapper = function (e) {
+              if (
+              // no bubbling, should always fire.
+              // this is just a safety net in case event.timeStamp is unreliable in
+              // certain weird environments...
+              e.target === e.currentTarget ||
+                  // event is fired after handler attachment
+                  e.timeStamp >= attachedTimestamp ||
+                  // bail for environments that have buggy event.timeStamp implementations
+                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
+                  // #9681 QtWebEngine event.timeStamp is negative value
+                  e.timeStamp <= 0 ||
+                  // #9448 bail if event is fired in another document in a multi-page
+                  // electron/nw.js app, since event.timeStamp will be using a different
+                  // starting reference
+                  e.target.ownerDocument !== document) {
+                  return original.apply(this, arguments);
+              }
+          };
+      }
+      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
+  }
+  function remove(name, handler, capture, _target) {
+      (_target || target).removeEventListener(name, 
+      //@ts-expect-error
+      handler._wrapper || handler, capture);
+  }
+  function updateDOMListeners(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
+          return;
+      }
+      const on = vnode.data.on || {};
+      const oldOn = oldVnode.data.on || {};
+      // vnode is empty when removing all listeners,
+      // and use old vnode dom element
+      target = vnode.elm || oldVnode.elm;
+      normalizeEvents(on);
+      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
+      target = undefined;
+  }
+  var events = {
+      create: updateDOMListeners,
+      update: updateDOMListeners,
+      // @ts-expect-error emptyNode has actually data
+      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
   };
 
-  let svgContainer;
-  function updateDOMProps(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-          return;
-      }
-      let key, cur;
-      const elm = vnode.elm;
-      const oldProps = oldVnode.data.domProps || {};
-      let props = vnode.data.domProps || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(props.__ob__)) {
-          props = vnode.data.domProps = extend({}, props);
-      }
-      for (key in oldProps) {
-          if (!(key in props)) {
-              elm[key] = '';
-          }
-      }
-      for (key in props) {
-          cur = props[key];
-          // ignore children if the node has textContent or innerHTML,
-          // as these will throw away existing DOM nodes and cause removal errors
-          // on subsequent patches (#3360)
-          if (key === 'textContent' || key === 'innerHTML') {
-              if (vnode.children)
-                  vnode.children.length = 0;
-              if (cur === oldProps[key])
-                  continue;
-              // #6601 work around Chrome version <= 55 bug where single textNode
-              // replaced by innerHTML/textContent retains its parentNode property
-              if (elm.childNodes.length === 1) {
-                  elm.removeChild(elm.childNodes[0]);
-              }
-          }
-          if (key === 'value' && elm.tagName !== 'PROGRESS') {
-              // store value as _value as well since
-              // non-string values will be stringified
-              elm._value = cur;
-              // avoid resetting cursor position when value is the same
-              const strCur = isUndef(cur) ? '' : String(cur);
-              if (shouldUpdateValue(elm, strCur)) {
-                  elm.value = strCur;
-              }
-          }
-          else if (key === 'innerHTML' &&
-              isSVG(elm.tagName) &&
-              isUndef(elm.innerHTML)) {
-              // IE doesn't support innerHTML for SVG elements
-              svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = `<svg>${cur}</svg>`;
-              const svg = svgContainer.firstChild;
-              while (elm.firstChild) {
-                  elm.removeChild(elm.firstChild);
-              }
-              while (svg.firstChild) {
-                  elm.appendChild(svg.firstChild);
-              }
-          }
-          else if (
-          // skip the update if old and new VDOM state is the same.
-          // `value` is handled separately because the DOM value may be temporarily
-          // out of sync with VDOM state due to focus, composition and modifiers.
-          // This  #4521 by skipping the unnecessary `checked` update.
-          cur !== oldProps[key]) {
-              // some property updates can throw
-              // e.g. `value` on <progress> w/ non-finite value
-              try {
-                  elm[key] = cur;
-              }
-              catch (e) { }
-          }
-      }
-  }
-  function shouldUpdateValue(elm, checkVal) {
-      return (
-      //@ts-expect-error
-      !elm.composing &&
-          (elm.tagName === 'OPTION' ||
-              isNotInFocusAndDirty(elm, checkVal) ||
-              isDirtyWithModifiers(elm, checkVal)));
-  }
-  function isNotInFocusAndDirty(elm, checkVal) {
-      // return true when textbox (.number and .trim) loses focus and its value is
-      // not equal to the updated value
-      let notInFocus = true;
-      // #6157
-      // work around IE bug when accessing document.activeElement in an iframe
-      try {
-          notInFocus = document.activeElement !== elm;
-      }
-      catch (e) { }
-      return notInFocus && elm.value !== checkVal;
-  }
-  function isDirtyWithModifiers(elm, newVal) {
-      const value = elm.value;
-      const modifiers = elm._vModifiers; // injected by v-model runtime
-      if (isDef(modifiers)) {
-          if (modifiers.number) {
-              return toNumber(value) !== toNumber(newVal);
-          }
-          if (modifiers.trim) {
-              return value.trim() !== newVal.trim();
-          }
-      }
-      return value !== newVal;
-  }
-  var domProps = {
-      create: updateDOMProps,
-      update: updateDOMProps,
+  let svgContainer;
+  function updateDOMProps(oldVnode, vnode) {
+      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
+          return;
+      }
+      let key, cur;
+      const elm = vnode.elm;
+      const oldProps = oldVnode.data.domProps || {};
+      let props = vnode.data.domProps || {};
+      // clone observed objects, as the user probably wants to mutate it
+      if (isDef(props.__ob__)) {
+          props = vnode.data.domProps = extend({}, props);
+      }
+      for (key in oldProps) {
+          if (!(key in props)) {
+              elm[key] = '';
+          }
+      }
+      for (key in props) {
+          cur = props[key];
+          // ignore children if the node has textContent or innerHTML,
+          // as these will throw away existing DOM nodes and cause removal errors
+          // on subsequent patches (#3360)
+          if (key === 'textContent' || key === 'innerHTML') {
+              if (vnode.children)
+                  vnode.children.length = 0;
+              if (cur === oldProps[key])
+                  continue;
+              // #6601 work around Chrome version <= 55 bug where single textNode
+              // replaced by innerHTML/textContent retains its parentNode property
+              if (elm.childNodes.length === 1) {
+                  elm.removeChild(elm.childNodes[0]);
+              }
+          }
+          if (key === 'value' && elm.tagName !== 'PROGRESS') {
+              // store value as _value as well since
+              // non-string values will be stringified
+              elm._value = cur;
+              // avoid resetting cursor position when value is the same
+              const strCur = isUndef(cur) ? '' : String(cur);
+              if (shouldUpdateValue(elm, strCur)) {
+                  elm.value = strCur;
+              }
+          }
+          else if (key === 'innerHTML' &&
+              isSVG(elm.tagName) &&
+              isUndef(elm.innerHTML)) {
+              // IE doesn't support innerHTML for SVG elements
+              svgContainer = svgContainer || document.createElement('div');
+              svgContainer.innerHTML = `<svg>${cur}</svg>`;
+              const svg = svgContainer.firstChild;
+              while (elm.firstChild) {
+                  elm.removeChild(elm.firstChild);
+              }
+              while (svg.firstChild) {
+                  elm.appendChild(svg.firstChild);
+              }
+          }
+          else if (
+          // skip the update if old and new VDOM state is the same.
+          // `value` is handled separately because the DOM value may be temporarily
+          // out of sync with VDOM state due to focus, composition and modifiers.
+          // This  #4521 by skipping the unnecessary `checked` update.
+          cur !== oldProps[key]) {
+              // some property updates can throw
+              // e.g. `value` on <progress> w/ non-finite value
+              try {
+                  elm[key] = cur;
+              }
+              catch (e) { }
+          }
+      }
+  }
+  function shouldUpdateValue(elm, checkVal) {
+      return (
+      //@ts-expect-error
+      !elm.composing &&
+          (elm.tagName === 'OPTION' ||
+              isNotInFocusAndDirty(elm, checkVal) ||
+              isDirtyWithModifiers(elm, checkVal)));
+  }
+  function isNotInFocusAndDirty(elm, checkVal) {
+      // return true when textbox (.number and .trim) loses focus and its value is
+      // not equal to the updated value
+      let notInFocus = true;
+      // #6157
+      // work around IE bug when accessing document.activeElement in an iframe
+      try {
+          notInFocus = document.activeElement !== elm;
+      }
+      catch (e) { }
+      return notInFocus && elm.value !== checkVal;
+  }
+  function isDirtyWithModifiers(elm, newVal) {
+      const value = elm.value;
+      const modifiers = elm._vModifiers; // injected by v-model runtime
+      if (isDef(modifiers)) {
+          if (modifiers.number) {
+              return toNumber(value) !== toNumber(newVal);
+          }
+          if (modifiers.trim) {
+              return value.trim() !== newVal.trim();
+          }
+      }
+      return value !== newVal;
+  }
+  var domProps = {
+      create: updateDOMProps,
+      update: updateDOMProps,
   };
 
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              const tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
+  });
+  // merge static and dynamic style data on the same vnode
+  function normalizeStyleData(data) {
+      const style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
+  }
+  // normalize possible array / string values into Object
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
+  }
+  /**
+   * parent component style should be after child's
+   * so that parent component's style could override it
+   */
+  function getStyle(vnode, checkChild) {
+      const res = {};
+      let styleData;
+      if (checkChild) {
+          let childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
+          extend(res, styleData);
+      }
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
+      }
+      return res;
   }
 
-  const cssVarRE = /^--/;
-  const importantRE = /\s*!important$/;
-  const setProp = (el, name, val) => {
-      /* istanbul ignore if */
-      if (cssVarRE.test(name)) {
-          el.style.setProperty(name, val);
-      }
-      else if (importantRE.test(val)) {
-          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-      }
-      else {
-          const normalizedName = normalize(name);
-          if (Array.isArray(val)) {
-              // Support values array created by autoprefixer, e.g.
-              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-              // Set them one by one, and the browser will only set those it can recognize
-              for (let i = 0, len = val.length; i < len; i++) {
-                  el.style[normalizedName] = val[i];
-              }
-          }
-          else {
-              el.style[normalizedName] = val;
-          }
-      }
-  };
-  const vendorNames = ['Webkit', 'Moz', 'ms'];
-  let emptyStyle;
-  const normalize = cached(function (prop) {
-      emptyStyle = emptyStyle || document.createElement('div').style;
-      prop = camelize(prop);
-      if (prop !== 'filter' && prop in emptyStyle) {
-          return prop;
-      }
-      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (let i = 0; i < vendorNames.length; i++) {
-          const name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
-          }
-      }
-  });
-  function updateStyle(oldVnode, vnode) {
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticStyle) &&
-          isUndef(data.style) &&
-          isUndef(oldData.staticStyle) &&
-          isUndef(oldData.style)) {
-          return;
-      }
-      let cur, name;
-      const el = vnode.elm;
-      const oldStaticStyle = oldData.staticStyle;
-      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      const oldStyle = oldStaticStyle || oldStyleBinding;
-      const style = normalizeStyleBinding(vnode.data.style) || {};
-      // store normalized style under a different key for next diff
-      // make sure to clone it if it's reactive, since the user likely wants
-      // to mutate it.
-      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      const newStyle = getStyle(vnode, true);
-      for (name in oldStyle) {
-          if (isUndef(newStyle[name])) {
-              setProp(el, name, '');
-          }
-      }
-      for (name in newStyle) {
-          cur = newStyle[name];
-          if (cur !== oldStyle[name]) {
-              // ie9 setting to null has no effect, must use empty string
-              setProp(el, name, cur == null ? '' : cur);
-          }
-      }
-  }
-  var style = {
-      create: updateStyle,
-      update: updateStyle,
+  const cssVarRE = /^--/;
+  const importantRE = /\s*!important$/;
+  const setProp = (el, name, val) => {
+      /* istanbul ignore if */
+      if (cssVarRE.test(name)) {
+          el.style.setProperty(name, val);
+      }
+      else if (importantRE.test(val)) {
+          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
+      }
+      else {
+          const normalizedName = normalize(name);
+          if (Array.isArray(val)) {
+              // Support values array created by autoprefixer, e.g.
+              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
+              // Set them one by one, and the browser will only set those it can recognize
+              for (let i = 0, len = val.length; i < len; i++) {
+                  el.style[normalizedName] = val[i];
+              }
+          }
+          else {
+              el.style[normalizedName] = val;
+          }
+      }
+  };
+  const vendorNames = ['Webkit', 'Moz', 'ms'];
+  let emptyStyle;
+  const normalize = cached(function (prop) {
+      emptyStyle = emptyStyle || document.createElement('div').style;
+      prop = camelize(prop);
+      if (prop !== 'filter' && prop in emptyStyle) {
+          return prop;
+      }
+      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
+      for (let i = 0; i < vendorNames.length; i++) {
+          const name = vendorNames[i] + capName;
+          if (name in emptyStyle) {
+              return name;
+          }
+      }
+  });
+  function updateStyle(oldVnode, vnode) {
+      const data = vnode.data;
+      const oldData = oldVnode.data;
+      if (isUndef(data.staticStyle) &&
+          isUndef(data.style) &&
+          isUndef(oldData.staticStyle) &&
+          isUndef(oldData.style)) {
+          return;
+      }
+      let cur, name;
+      const el = vnode.elm;
+      const oldStaticStyle = oldData.staticStyle;
+      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
+      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
+      const oldStyle = oldStaticStyle || oldStyleBinding;
+      const style = normalizeStyleBinding(vnode.data.style) || {};
+      // store normalized style under a different key for next diff
+      // make sure to clone it if it's reactive, since the user likely wants
+      // to mutate it.
+      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
+      const newStyle = getStyle(vnode, true);
+      for (name in oldStyle) {
+          if (isUndef(newStyle[name])) {
+              setProp(el, name, '');
+          }
+      }
+      for (name in newStyle) {
+          cur = newStyle[name];
+          if (cur !== oldStyle[name]) {
+              // ie9 setting to null has no effect, must use empty string
+              setProp(el, name, cur == null ? '' : cur);
+          }
+      }
+  }
+  var style = {
+      create: updateStyle,
+      update: updateStyle,
   };
 
-  const whitespaceRE = /\s+/;
-  /**
-   * Add class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function addClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          const cur = ` ${el.getAttribute('class') || ''} `;
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
-  }
-  /**
-   * Remove class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function removeClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          let cur = ` ${el.getAttribute('class') || ''} `;
-          const tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
+  const whitespaceRE = /\s+/;
+  /**
+   * Add class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function addClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
+          }
+          else {
+              el.classList.add(cls);
+          }
+      }
+      else {
+          const cur = ` ${el.getAttribute('class') || ''} `;
+          if (cur.indexOf(' ' + cls + ' ') < 0) {
+              el.setAttribute('class', (cur + cls).trim());
+          }
+      }
+  }
+  /**
+   * Remove class with compatibility for SVG since classList is not supported on
+   * SVG elements in IE
+   */
+  function removeClass(el, cls) {
+      /* istanbul ignore if */
+      if (!cls || !(cls = cls.trim())) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (el.classList) {
+          if (cls.indexOf(' ') > -1) {
+              cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
+          }
+          else {
+              el.classList.remove(cls);
+          }
+          if (!el.classList.length) {
+              el.removeAttribute('class');
+          }
+      }
+      else {
+          let cur = ` ${el.getAttribute('class') || ''} `;
+          const tar = ' ' + cls + ' ';
+          while (cur.indexOf(tar) >= 0) {
+              cur = cur.replace(tar, ' ');
+          }
+          cur = cur.trim();
+          if (cur) {
+              el.setAttribute('class', cur);
+          }
+          else {
+              el.removeAttribute('class');
+          }
+      }
   }
 
-  function resolveTransition(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          const res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition(def);
-      }
-  }
-  const autoCssTransition = cached((name) => {
-      return {
-          enterClass: `${name}-enter`,
-          enterToClass: `${name}-enter-to`,
-          enterActiveClass: `${name}-enter-active`,
-          leaveClass: `${name}-leave`,
-          leaveToClass: `${name}-leave-to`,
-          leaveActiveClass: `${name}-leave-active`,
-      };
-  });
-  const hasTransition = inBrowser && !isIE9;
-  const TRANSITION = 'transition';
-  const ANIMATION = 'animation';
-  // Transition property/event sniffing
-  let transitionProp = 'transition';
-  let transitionEndEvent = 'transitionend';
-  let animationProp = 'animation';
-  let animationEndEvent = 'animationend';
-  if (hasTransition) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
-      }
-  }
-  // binding to window is necessary to make hot reload work in IE in strict mode
-  const raf = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ (fn) => fn();
-  function nextFrame(fn) {
-      raf(() => {
-          // @ts-expect-error
-          raf(fn);
-      });
-  }
-  function addTransitionClass(el, cls) {
-      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass(el, cls);
-      }
-  }
-  function removeTransitionClass(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass(el, cls);
-  }
-  function whenTransitionEnds(el, expectedType, cb) {
-      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-      if (!type)
-          return cb();
-      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      let ended = 0;
-      const end = () => {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      const onEnd = (e) => {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(() => {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
-  }
-  const transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
-      const styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      const animationTimeout = getTimeout(animationDelays, animationDurations);
-      let type;
-      let timeout = 0;
-      let propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION) {
-          if (animationTimeout > 0) {
-              type = ANIMATION;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
-                  : null;
-          propCount = type
-              ? type === TRANSITION
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-      return {
-          type,
-          timeout,
-          propCount,
-          hasTransform,
-      };
-  }
-  function getTimeout(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map((d, i) => {
-          return toMs(d) + toMs(delays[i]);
-      }));
-  }
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
+  function resolveTransition(def) {
+      if (!def) {
+          return;
+      }
+      /* istanbul ignore else */
+      if (typeof def === 'object') {
+          const res = {};
+          if (def.css !== false) {
+              extend(res, autoCssTransition(def.name || 'v'));
+          }
+          extend(res, def);
+          return res;
+      }
+      else if (typeof def === 'string') {
+          return autoCssTransition(def);
+      }
+  }
+  const autoCssTransition = cached((name) => {
+      return {
+          enterClass: `${name}-enter`,
+          enterToClass: `${name}-enter-to`,
+          enterActiveClass: `${name}-enter-active`,
+          leaveClass: `${name}-leave`,
+          leaveToClass: `${name}-leave-to`,
+          leaveActiveClass: `${name}-leave-active`,
+      };
+  });
+  const hasTransition = inBrowser && !isIE9;
+  const TRANSITION = 'transition';
+  const ANIMATION = 'animation';
+  // Transition property/event sniffing
+  let transitionProp = 'transition';
+  let transitionEndEvent = 'transitionend';
+  let animationProp = 'animation';
+  let animationEndEvent = 'animationend';
+  if (hasTransition) {
+      /* istanbul ignore if */
+      if (window.ontransitionend === undefined &&
+          window.onwebkittransitionend !== undefined) {
+          transitionProp = 'WebkitTransition';
+          transitionEndEvent = 'webkitTransitionEnd';
+      }
+      if (window.onanimationend === undefined &&
+          window.onwebkitanimationend !== undefined) {
+          animationProp = 'WebkitAnimation';
+          animationEndEvent = 'webkitAnimationEnd';
+      }
+  }
+  // binding to window is necessary to make hot reload work in IE in strict mode
+  const raf = inBrowser
+      ? window.requestAnimationFrame
+          ? window.requestAnimationFrame.bind(window)
+          : setTimeout
+      : /* istanbul ignore next */ (fn) => fn();
+  function nextFrame(fn) {
+      raf(() => {
+          // @ts-expect-error
+          raf(fn);
+      });
+  }
+  function addTransitionClass(el, cls) {
+      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
+      if (transitionClasses.indexOf(cls) < 0) {
+          transitionClasses.push(cls);
+          addClass(el, cls);
+      }
+  }
+  function removeTransitionClass(el, cls) {
+      if (el._transitionClasses) {
+          remove$2(el._transitionClasses, cls);
+      }
+      removeClass(el, cls);
+  }
+  function whenTransitionEnds(el, expectedType, cb) {
+      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+      if (!type)
+          return cb();
+      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
+      let ended = 0;
+      const end = () => {
+          el.removeEventListener(event, onEnd);
+          cb();
+      };
+      const onEnd = (e) => {
+          if (e.target === el) {
+              if (++ended >= propCount) {
+                  end();
+              }
+          }
+      };
+      setTimeout(() => {
+          if (ended < propCount) {
+              end();
+          }
+      }, timeout + 1);
+      el.addEventListener(event, onEnd);
+  }
+  const transformRE = /\b(transform|all)(,|$)/;
+  function getTransitionInfo(el, expectedType) {
+      const styles = window.getComputedStyle(el);
+      // JSDOM may return undefined for transition properties
+      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
+      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
+      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
+      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
+      const animationTimeout = getTimeout(animationDelays, animationDurations);
+      let type;
+      let timeout = 0;
+      let propCount = 0;
+      /* istanbul ignore if */
+      if (expectedType === TRANSITION) {
+          if (transitionTimeout > 0) {
+              type = TRANSITION;
+              timeout = transitionTimeout;
+              propCount = transitionDurations.length;
+          }
+      }
+      else if (expectedType === ANIMATION) {
+          if (animationTimeout > 0) {
+              type = ANIMATION;
+              timeout = animationTimeout;
+              propCount = animationDurations.length;
+          }
+      }
+      else {
+          timeout = Math.max(transitionTimeout, animationTimeout);
+          type =
+              timeout > 0
+                  ? transitionTimeout > animationTimeout
+                      ? TRANSITION
+                      : ANIMATION
+                  : null;
+          propCount = type
+              ? type === TRANSITION
+                  ? transitionDurations.length
+                  : animationDurations.length
+              : 0;
+      }
+      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
+      return {
+          type,
+          timeout,
+          propCount,
+          hasTransform,
+      };
+  }
+  function getTimeout(delays, durations) {
+      /* istanbul ignore next */
+      while (delays.length < durations.length) {
+          delays = delays.concat(delays);
+      }
+      return Math.max.apply(null, durations.map((d, i) => {
+          return toMs(d) + toMs(delays[i]);
+      }));
+  }
+  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
+  // in a locale-dependent way, using a comma instead of a dot.
+  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
+  // as a floor function) causing unexpected behaviors
+  function toMs(s) {
+      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
   }
 
-  function enter(vnode, toggleDisplay) {
-      const el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      let context = activeInstance;
-      let transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      const isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      const startClass = isAppear && appearClass ? appearClass : enterClass;
-      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      const enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      const enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
-      }
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(enterHook);
-      const cb = (el._enterCb = once(() => {
-          if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', () => {
-              const parent = el.parentNode;
-              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
-      if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(() => {
-              removeTransitionClass(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
-      }
-  }
-  function leave(vnode, rm) {
-      const el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
-      }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
-      }
-      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(leave);
-      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
-      }
-      const cb = (el._leaveCb = once(() => {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
-              }
-              leaveCancelled && leaveCancelled(el);
-          }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
-      }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(() => {
-                  removeTransitionClass(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
-      }
-  }
-  // only used in dev mode
-  function checkDuration(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn(`<transition> explicit ${name} duration is not a valid number - ` +
-              `got ${JSON.stringify(val)}.`, vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn(`<transition> explicit ${name} duration is NaN - ` +
-              'the duration expression might be incorrect.', vnode.context);
-      }
-  }
-  function isValidDuration(val) {
-      return typeof val === 'number' && !isNaN(val);
-  }
-  /**
-   * Normalize a transition hook's argument length. The hook may be:
-   * - a merged hook (invoker) with the original in .fns
-   * - a wrapped component method (check ._length)
-   * - a plain function (.length)
-   */
-  function getHookArgumentsLength(fn) {
-      if (isUndef(fn)) {
-          return false;
-      }
-      // @ts-expect-error
-      const invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-      }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
-      }
-  }
-  function _enter(_, vnode) {
-      if (vnode.data.show !== true) {
-          enter(vnode);
-      }
-  }
-  var transition = inBrowser
-      ? {
-          create: _enter,
-          activate: _enter,
-          remove(vnode, rm) {
-              /* istanbul ignore else */
-              if (vnode.data.show !== true) {
-                  // @ts-expect-error
-                  leave(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          },
-      }
+  function enter(vnode, toggleDisplay) {
+      const el = vnode.elm;
+      // call leave callback now
+      if (isDef(el._leaveCb)) {
+          el._leaveCb.cancelled = true;
+          el._leaveCb();
+      }
+      const data = resolveTransition(vnode.data.transition);
+      if (isUndef(data)) {
+          return;
+      }
+      /* istanbul ignore if */
+      if (isDef(el._enterCb) || el.nodeType !== 1) {
+          return;
+      }
+      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
+      // activeInstance will always be the <transition> component managing this
+      // transition. One edge case to check is when the <transition> is placed
+      // as the root node of a child component. In that case we need to check
+      // <transition>'s parent for appear check.
+      let context = activeInstance;
+      let transitionNode = activeInstance.$vnode;
+      while (transitionNode && transitionNode.parent) {
+          context = transitionNode.context;
+          transitionNode = transitionNode.parent;
+      }
+      const isAppear = !context._isMounted || !vnode.isRootInsert;
+      if (isAppear && !appear && appear !== '') {
+          return;
+      }
+      const startClass = isAppear && appearClass ? appearClass : enterClass;
+      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
+      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
+      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
+      const enterHook = isAppear
+          ? typeof appear === 'function'
+              ? appear
+              : enter
+          : enter;
+      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
+      const enterCancelledHook = isAppear
+          ? appearCancelled || enterCancelled
+          : enterCancelled;
+      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
+      if (explicitEnterDuration != null) {
+          checkDuration(explicitEnterDuration, 'enter', vnode);
+      }
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(enterHook);
+      const cb = (el._enterCb = once(() => {
+          if (expectsCSS) {
+              removeTransitionClass(el, toClass);
+              removeTransitionClass(el, activeClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, startClass);
+              }
+              enterCancelledHook && enterCancelledHook(el);
+          }
+          else {
+              afterEnterHook && afterEnterHook(el);
+          }
+          el._enterCb = null;
+      }));
+      if (!vnode.data.show) {
+          // remove pending leave element on enter by injecting an insert hook
+          mergeVNodeHook(vnode, 'insert', () => {
+              const parent = el.parentNode;
+              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
+              if (pendingNode &&
+                  pendingNode.tag === vnode.tag &&
+                  pendingNode.elm._leaveCb) {
+                  pendingNode.elm._leaveCb();
+              }
+              enterHook && enterHook(el, cb);
+          });
+      }
+      // start enter transition
+      beforeEnterHook && beforeEnterHook(el);
+      if (expectsCSS) {
+          addTransitionClass(el, startClass);
+          addTransitionClass(el, activeClass);
+          nextFrame(() => {
+              removeTransitionClass(el, startClass);
+              // @ts-expect-error
+              if (!cb.cancelled) {
+                  addTransitionClass(el, toClass);
+                  if (!userWantsControl) {
+                      if (isValidDuration(explicitEnterDuration)) {
+                          setTimeout(cb, explicitEnterDuration);
+                      }
+                      else {
+                          whenTransitionEnds(el, type, cb);
+                      }
+                  }
+              }
+          });
+      }
+      if (vnode.data.show) {
+          toggleDisplay && toggleDisplay();
+          enterHook && enterHook(el, cb);
+      }
+      if (!expectsCSS && !userWantsControl) {
+          cb();
+      }
+  }
+  function leave(vnode, rm) {
+      const el = vnode.elm;
+      // call enter callback now
+      if (isDef(el._enterCb)) {
+          el._enterCb.cancelled = true;
+          el._enterCb();
+      }
+      const data = resolveTransition(vnode.data.transition);
+      if (isUndef(data) || el.nodeType !== 1) {
+          return rm();
+      }
+      /* istanbul ignore if */
+      if (isDef(el._leaveCb)) {
+          return;
+      }
+      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
+      const expectsCSS = css !== false && !isIE9;
+      const userWantsControl = getHookArgumentsLength(leave);
+      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
+      if (isDef(explicitLeaveDuration)) {
+          checkDuration(explicitLeaveDuration, 'leave', vnode);
+      }
+      const cb = (el._leaveCb = once(() => {
+          if (el.parentNode && el.parentNode._pending) {
+              el.parentNode._pending[vnode.key] = null;
+          }
+          if (expectsCSS) {
+              removeTransitionClass(el, leaveToClass);
+              removeTransitionClass(el, leaveActiveClass);
+          }
+          // @ts-expect-error
+          if (cb.cancelled) {
+              if (expectsCSS) {
+                  removeTransitionClass(el, leaveClass);
+              }
+              leaveCancelled && leaveCancelled(el);
+          }
+          else {
+              rm();
+              afterLeave && afterLeave(el);
+          }
+          el._leaveCb = null;
+      }));
+      if (delayLeave) {
+          delayLeave(performLeave);
+      }
+      else {
+          performLeave();
+      }
+      function performLeave() {
+          // the delayed leave may have already been cancelled
+          // @ts-expect-error
+          if (cb.cancelled) {
+              return;
+          }
+          // record leaving element
+          if (!vnode.data.show && el.parentNode) {
+              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
+          }
+          beforeLeave && beforeLeave(el);
+          if (expectsCSS) {
+              addTransitionClass(el, leaveClass);
+              addTransitionClass(el, leaveActiveClass);
+              nextFrame(() => {
+                  removeTransitionClass(el, leaveClass);
+                  // @ts-expect-error
+                  if (!cb.cancelled) {
+                      addTransitionClass(el, leaveToClass);
+                      if (!userWantsControl) {
+                          if (isValidDuration(explicitLeaveDuration)) {
+                              setTimeout(cb, explicitLeaveDuration);
+                          }
+                          else {
+                              whenTransitionEnds(el, type, cb);
+                          }
+                      }
+                  }
+              });
+          }
+          leave && leave(el, cb);
+          if (!expectsCSS && !userWantsControl) {
+              cb();
+          }
+      }
+  }
+  // only used in dev mode
+  function checkDuration(val, name, vnode) {
+      if (typeof val !== 'number') {
+          warn(`<transition> explicit ${name} duration is not a valid number - ` +
+              `got ${JSON.stringify(val)}.`, vnode.context);
+      }
+      else if (isNaN(val)) {
+          warn(`<transition> explicit ${name} duration is NaN - ` +
+              'the duration expression might be incorrect.', vnode.context);
+      }
+  }
+  function isValidDuration(val) {
+      return typeof val === 'number' && !isNaN(val);
+  }
+  /**
+   * Normalize a transition hook's argument length. The hook may be:
+   * - a merged hook (invoker) with the original in .fns
+   * - a wrapped component method (check ._length)
+   * - a plain function (.length)
+   */
+  function getHookArgumentsLength(fn) {
+      if (isUndef(fn)) {
+          return false;
+      }
+      // @ts-expect-error
+      const invokerFns = fn.fns;
+      if (isDef(invokerFns)) {
+          // invoker
+          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
+      }
+      else {
+          // @ts-expect-error
+          return (fn._length || fn.length) > 1;
+      }
+  }
+  function _enter(_, vnode) {
+      if (vnode.data.show !== true) {
+          enter(vnode);
+      }
+  }
+  var transition = inBrowser
+      ? {
+          create: _enter,
+          activate: _enter,
+          remove(vnode, rm) {
+              /* istanbul ignore else */
+              if (vnode.data.show !== true) {
+                  // @ts-expect-error
+                  leave(vnode, rm);
+              }
+              else {
+                  rm();
+              }
+          },
+      }
       : {};
 
   var platformModules = [attrs, klass, events, domProps, style, transition];
 
-  // the directive module should be applied last, after all
-  // built-in modules have been applied.
-  const modules = platformModules.concat(baseModules);
+  // the directive module should be applied last, after all
+  // built-in modules have been applied.
+  const modules = platformModules.concat(baseModules);
   const patch = createPatchFunction({ nodeOps, modules });
 
-  /**
-   * Not type checking this file because flow doesn't like attaching
-   * properties to Elements.
-   */
-  /* istanbul ignore if */
-  if (isIE9) {
-      // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', () => {
-          const el = document.activeElement;
-          // @ts-expect-error
-          if (el && el.vmodel) {
-              trigger(el, 'input');
-          }
-      });
-  }
-  const directive = {
-      inserted(el, binding, vnode, oldVnode) {
-          if (vnode.tag === 'select') {
-              // #6903
-              if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', () => {
-                      directive.componentUpdated(el, binding, vnode);
-                  });
-              }
-              else {
-                  setSelected(el, binding, vnode.context);
-              }
-              el._vOptions = [].map.call(el.options, getValue);
-          }
-          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-              el._vModifiers = binding.modifiers;
-              if (!binding.modifiers.lazy) {
-                  el.addEventListener('compositionstart', onCompositionStart);
-                  el.addEventListener('compositionend', onCompositionEnd);
-                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                  // switching focus before confirming composition choice
-                  // this also fixes the issue where some browsers e.g. iOS Chrome
-                  // fires "change" instead of "input" on autocomplete.
-                  el.addEventListener('change', onCompositionEnd);
-                  /* istanbul ignore if */
-                  if (isIE9) {
-                      el.vmodel = true;
-                  }
-              }
-          }
-      },
-      componentUpdated(el, binding, vnode) {
-          if (vnode.tag === 'select') {
-              setSelected(el, binding, vnode.context);
-              // in case the options rendered by v-for have changed,
-              // it's possible that the value is out-of-sync with the rendered options.
-              // detect such cases and filter out values that no longer has a matching
-              // option in the DOM.
-              const prevOptions = el._vOptions;
-              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                  // trigger change event if
-                  // no matching option found for at least one value
-                  const needReset = el.multiple
-                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                      : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
-                  if (needReset) {
-                      trigger(el, 'change');
-                  }
-              }
-          }
-      },
-  };
-  function setSelected(el, binding, vm) {
-      actuallySetSelected(el, binding, vm);
-      /* istanbul ignore if */
-      if (isIE || isEdge) {
-          setTimeout(() => {
-              actuallySetSelected(el, binding, vm);
-          }, 0);
-      }
-  }
-  function actuallySetSelected(el, binding, vm) {
-      const value = binding.value;
-      const isMultiple = el.multiple;
-      if (isMultiple && !Array.isArray(value)) {
-          warn(`<select multiple v-model="${binding.expression}"> ` +
-                  `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-          return;
-      }
-      let selected, option;
-      for (let i = 0, l = el.options.length; i < l; i++) {
-          option = el.options[i];
-          if (isMultiple) {
-              selected = looseIndexOf(value, getValue(option)) > -1;
-              if (option.selected !== selected) {
-                  option.selected = selected;
-              }
-          }
-          else {
-              if (looseEqual(getValue(option), value)) {
-                  if (el.selectedIndex !== i) {
-                      el.selectedIndex = i;
-                  }
-                  return;
-              }
-          }
-      }
-      if (!isMultiple) {
-          el.selectedIndex = -1;
-      }
-  }
-  function hasNoMatchingOption(value, options) {
-      return options.every((o) => !looseEqual(o, value));
-  }
-  function getValue(option) {
-      return '_value' in option ? option._value : option.value;
-  }
-  function onCompositionStart(e) {
-      e.target.composing = true;
-  }
-  function onCompositionEnd(e) {
-      // prevent triggering an input event for no reason
-      if (!e.target.composing)
-          return;
-      e.target.composing = false;
-      trigger(e.target, 'input');
-  }
-  function trigger(el, type) {
-      const e = document.createEvent('HTMLEvents');
-      e.initEvent(type, true, true);
-      el.dispatchEvent(e);
+  /**
+   * Not type checking this file because flow doesn't like attaching
+   * properties to Elements.
+   */
+  /* istanbul ignore if */
+  if (isIE9) {
+      // http://www.matts411.com/post/internet-explorer-9-oninput/
+      document.addEventListener('selectionchange', () => {
+          const el = document.activeElement;
+          // @ts-expect-error
+          if (el && el.vmodel) {
+              trigger(el, 'input');
+          }
+      });
+  }
+  const directive = {
+      inserted(el, binding, vnode, oldVnode) {
+          if (vnode.tag === 'select') {
+              // #6903
+              if (oldVnode.elm && !oldVnode.elm._vOptions) {
+                  mergeVNodeHook(vnode, 'postpatch', () => {
+                      directive.componentUpdated(el, binding, vnode);
+                  });
+              }
+              else {
+                  setSelected(el, binding, vnode.context);
+              }
+              el._vOptions = [].map.call(el.options, getValue);
+          }
+          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
+              el._vModifiers = binding.modifiers;
+              if (!binding.modifiers.lazy) {
+                  el.addEventListener('compositionstart', onCompositionStart);
+                  el.addEventListener('compositionend', onCompositionEnd);
+                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
+                  // switching focus before confirming composition choice
+                  // this also fixes the issue where some browsers e.g. iOS Chrome
+                  // fires "change" instead of "input" on autocomplete.
+                  el.addEventListener('change', onCompositionEnd);
+                  /* istanbul ignore if */
+                  if (isIE9) {
+                      el.vmodel = true;
+                  }
+              }
+          }
+      },
+      componentUpdated(el, binding, vnode) {
+          if (vnode.tag === 'select') {
+              setSelected(el, binding, vnode.context);
+              // in case the options rendered by v-for have changed,
+              // it's possible that the value is out-of-sync with the rendered options.
+              // detect such cases and filter out values that no longer has a matching
+              // option in the DOM.
+              const prevOptions = el._vOptions;
+              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
+              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
+                  // trigger change event if
+                  // no matching option found for at least one value
+                  const needReset = el.multiple
+                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+                      : binding.value !== binding.oldValue &&
+                          hasNoMatchingOption(binding.value, curOptions);
+                  if (needReset) {
+                      trigger(el, 'change');
+                  }
+              }
+          }
+      },
+  };
+  function setSelected(el, binding, vm) {
+      actuallySetSelected(el, binding, vm);
+      /* istanbul ignore if */
+      if (isIE || isEdge) {
+          setTimeout(() => {
+              actuallySetSelected(el, binding, vm);
+          }, 0);
+      }
+  }
+  function actuallySetSelected(el, binding, vm) {
+      const value = binding.value;
+      const isMultiple = el.multiple;
+      if (isMultiple && !Array.isArray(value)) {
+          warn(`<select multiple v-model="${binding.expression}"> ` +
+                  `expects an Array value for its binding, but got ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)}`, vm);
+          return;
+      }
+      let selected, option;
+      for (let i = 0, l = el.options.length; i < l; i++) {
+          option = el.options[i];
+          if (isMultiple) {
+              selected = looseIndexOf(value, getValue(option)) > -1;
+              if (option.selected !== selected) {
+                  option.selected = selected;
+              }
+          }
+          else {
+              if (looseEqual(getValue(option), value)) {
+                  if (el.selectedIndex !== i) {
+                      el.selectedIndex = i;
+                  }
+                  return;
+              }
+          }
+      }
+      if (!isMultiple) {
+          el.selectedIndex = -1;
+      }
+  }
+  function hasNoMatchingOption(value, options) {
+      return options.every((o) => !looseEqual(o, value));
+  }
+  function getValue(option) {
+      return '_value' in option ? option._value : option.value;
+  }
+  function onCompositionStart(e) {
+      e.target.composing = true;
+  }
+  function onCompositionEnd(e) {
+      // prevent triggering an input event for no reason
+      if (!e.target.composing)
+          return;
+      e.target.composing = false;
+      trigger(e.target, 'input');
+  }
+  function trigger(el, type) {
+      const e = document.createEvent('HTMLEvents');
+      e.initEvent(type, true, true);
+      el.dispatchEvent(e);
   }
 
-  // recursively search for possible transition defined inside the component root
-  function locateNode(vnode) {
-      // @ts-expect-error
-      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-          ? locateNode(vnode.componentInstance._vnode)
-          : vnode;
-  }
-  var show = {
-      bind(el, { value }, vnode) {
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          const originalDisplay = (el.__vOriginalDisplay =
-              el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition) {
-              vnode.data.show = true;
-              enter(vnode, () => {
-                  el.style.display = originalDisplay;
-              });
-          }
-          else {
-              el.style.display = value ? originalDisplay : 'none';
-          }
-      },
-      update(el, { value, oldValue }, vnode) {
-          /* istanbul ignore if */
-          if (!value === !oldValue)
-              return;
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          if (transition) {
-              vnode.data.show = true;
-              if (value) {
-                  enter(vnode, () => {
-                      el.style.display = el.__vOriginalDisplay;
-                  });
-              }
-              else {
-                  leave(vnode, () => {
-                      el.style.display = 'none';
-                  });
-              }
-          }
-          else {
-              el.style.display = value ? el.__vOriginalDisplay : 'none';
-          }
-      },
-      unbind(el, binding, vnode, oldVnode, isDestroy) {
-          if (!isDestroy) {
-              el.style.display = el.__vOriginalDisplay;
-          }
-      },
+  // recursively search for possible transition defined inside the component root
+  function locateNode(vnode) {
+      // @ts-expect-error
+      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
+          ? locateNode(vnode.componentInstance._vnode)
+          : vnode;
+  }
+  var show = {
+      bind(el, { value }, vnode) {
+          vnode = locateNode(vnode);
+          const transition = vnode.data && vnode.data.transition;
+          const originalDisplay = (el.__vOriginalDisplay =
+              el.style.display === 'none' ? '' : el.style.display);
+          if (value && transition) {
+              vnode.data.show = true;
+              enter(vnode, () => {
+                  el.style.display = originalDisplay;
+              });
+          }
+          else {
+              el.style.display = value ? originalDisplay : 'none';
+          }
+      },
+      update(el, { value, oldValue }, vnode) {
+          /* istanbul ignore if */
+          if (!value === !oldValue)
+              return;
+          vnode = locateNode(vnode);
+          const transition = vnode.data && vnode.data.transition;
+          if (transition) {
+              vnode.data.show = true;
+              if (value) {
+                  enter(vnode, () => {
+                      el.style.display = el.__vOriginalDisplay;
+                  });
+              }
+              else {
+                  leave(vnode, () => {
+                      el.style.display = 'none';
+                  });
+              }
+          }
+          else {
+              el.style.display = value ? el.__vOriginalDisplay : 'none';
+          }
+      },
+      unbind(el, binding, vnode, oldVnode, isDestroy) {
+          if (!isDestroy) {
+              el.style.display = el.__vOriginalDisplay;
+          }
+      },
   };
 
-  var platformDirectives = {
-      model: directive,
-      show,
+  var platformDirectives = {
+      model: directive,
+      show,
   };
 
-  // Provides transition support for a single element/component.
-  const transitionProps = {
-      name: String,
-      appear: Boolean,
-      css: Boolean,
-      mode: String,
-      type: String,
-      enterClass: String,
-      leaveClass: String,
-      enterToClass: String,
-      leaveToClass: String,
-      enterActiveClass: String,
-      leaveActiveClass: String,
-      appearClass: String,
-      appearActiveClass: String,
-      appearToClass: String,
-      duration: [Number, String, Object],
-  };
-  // in case the child is also an abstract component, e.g. <keep-alive>
-  // we want to recursively retrieve the real component to be rendered
-  function getRealChild(vnode) {
-      const compOptions = vnode && vnode.componentOptions;
-      if (compOptions && compOptions.Ctor.options.abstract) {
-          return getRealChild(getFirstComponentChild(compOptions.children));
-      }
-      else {
-          return vnode;
-      }
-  }
-  function extractTransitionData(comp) {
-      const data = {};
-      const options = comp.$options;
-      // props
-      for (const key in options.propsData) {
-          data[key] = comp[key];
-      }
-      // events.
-      // extract listeners and pass them directly to the transition methods
-      const listeners = options._parentListeners;
-      for (const key in listeners) {
-          data[camelize(key)] = listeners[key];
-      }
-      return data;
-  }
-  function placeholder(h, rawChild) {
-      // @ts-expect-error
-      if (/\d-keep-alive$/.test(rawChild.tag)) {
-          return h('keep-alive', {
-              props: rawChild.componentOptions.propsData,
-          });
-      }
-  }
-  function hasParentTransition(vnode) {
-      while ((vnode = vnode.parent)) {
-          if (vnode.data.transition) {
-              return true;
-          }
-      }
-  }
-  function isSameChild(child, oldChild) {
-      return oldChild.key === child.key && oldChild.tag === child.tag;
-  }
-  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-  const isVShowDirective = (d) => d.name === 'show';
-  var Transition = {
-      name: 'transition',
-      props: transitionProps,
-      abstract: true,
-      render(h) {
-          let children = this.$slots.default;
-          if (!children) {
-              return;
-          }
-          // filter out text nodes (possible whitespaces)
-          children = children.filter(isNotTextNode);
-          /* istanbul ignore if */
-          if (!children.length) {
-              return;
-          }
-          // warn multiple elements
-          if (children.length > 1) {
-              warn('<transition> can only be used on a single element. Use ' +
-                  '<transition-group> for lists.', this.$parent);
-          }
-          const mode = this.mode;
-          // warn invalid mode
-          if (mode &&
-              mode !== 'in-out' &&
-              mode !== 'out-in') {
-              warn('invalid <transition> mode: ' + mode, this.$parent);
-          }
-          const rawChild = children[0];
-          // if this is a component root node and the component's
-          // parent container node also has transition, skip.
-          if (hasParentTransition(this.$vnode)) {
-              return rawChild;
-          }
-          // apply transition data to child
-          // use getRealChild() to ignore abstract components e.g. keep-alive
-          const child = getRealChild(rawChild);
-          /* istanbul ignore if */
-          if (!child) {
-              return rawChild;
-          }
-          if (this._leaving) {
-              return placeholder(h, rawChild);
-          }
-          // ensure a key that is unique to the vnode type and to this transition
-          // component instance. This key will be used to remove pending leaving nodes
-          // during entering.
-          const id = `__transition-${this._uid}-`;
-          child.key =
-              child.key == null
-                  ? child.isComment
-                      ? id + 'comment'
-                      : id + child.tag
-                  : isPrimitive(child.key)
-                      ? String(child.key).indexOf(id) === 0
-                          ? child.key
-                          : id + child.key
-                      : child.key;
-          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          const oldRawChild = this._vnode;
-          const oldChild = getRealChild(oldRawChild);
-          // mark v-show
-          // so that the transition module can hand over the control to the directive
-          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-              child.data.show = true;
-          }
-          if (oldChild &&
-              oldChild.data &&
-              !isSameChild(child, oldChild) &&
-              !isAsyncPlaceholder(oldChild) &&
-              // #6687 component root is a comment node
-              !(oldChild.componentInstance &&
-                  oldChild.componentInstance._vnode.isComment)) {
-              // replace old child transition data with fresh one
-              // important for dynamic transitions!
-              const oldData = (oldChild.data.transition = extend({}, data));
-              // handle transition mode
-              if (mode === 'out-in') {
-                  // return placeholder node and queue update when leave finishes
-                  this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', () => {
-                      this._leaving = false;
-                      this.$forceUpdate();
-                  });
-                  return placeholder(h, rawChild);
-              }
-              else if (mode === 'in-out') {
-                  if (isAsyncPlaceholder(child)) {
-                      return oldRawChild;
-                  }
-                  let delayedLeave;
-                  const performLeave = () => {
-                      delayedLeave();
-                  };
-                  mergeVNodeHook(data, 'afterEnter', performLeave);
-                  mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                      delayedLeave = leave;
-                  });
-              }
-          }
-          return rawChild;
-      },
+  // Provides transition support for a single element/component.
+  const transitionProps = {
+      name: String,
+      appear: Boolean,
+      css: Boolean,
+      mode: String,
+      type: String,
+      enterClass: String,
+      leaveClass: String,
+      enterToClass: String,
+      leaveToClass: String,
+      enterActiveClass: String,
+      leaveActiveClass: String,
+      appearClass: String,
+      appearActiveClass: String,
+      appearToClass: String,
+      duration: [Number, String, Object],
+  };
+  // in case the child is also an abstract component, e.g. <keep-alive>
+  // we want to recursively retrieve the real component to be rendered
+  function getRealChild(vnode) {
+      const compOptions = vnode && vnode.componentOptions;
+      if (compOptions && compOptions.Ctor.options.abstract) {
+          return getRealChild(getFirstComponentChild(compOptions.children));
+      }
+      else {
+          return vnode;
+      }
+  }
+  function extractTransitionData(comp) {
+      const data = {};
+      const options = comp.$options;
+      // props
+      for (const key in options.propsData) {
+          data[key] = comp[key];
+      }
+      // events.
+      // extract listeners and pass them directly to the transition methods
+      const listeners = options._parentListeners;
+      for (const key in listeners) {
+          data[camelize(key)] = listeners[key];
+      }
+      return data;
+  }
+  function placeholder(h, rawChild) {
+      // @ts-expect-error
+      if (/\d-keep-alive$/.test(rawChild.tag)) {
+          return h('keep-alive', {
+              props: rawChild.componentOptions.propsData,
+          });
+      }
+  }
+  function hasParentTransition(vnode) {
+      while ((vnode = vnode.parent)) {
+          if (vnode.data.transition) {
+              return true;
+          }
+      }
+  }
+  function isSameChild(child, oldChild) {
+      return oldChild.key === child.key && oldChild.tag === child.tag;
+  }
+  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
+  const isVShowDirective = (d) => d.name === 'show';
+  var Transition = {
+      name: 'transition',
+      props: transitionProps,
+      abstract: true,
+      render(h) {
+          let children = this.$slots.default;
+          if (!children) {
+              return;
+          }
+          // filter out text nodes (possible whitespaces)
+          children = children.filter(isNotTextNode);
+          /* istanbul ignore if */
+          if (!children.length) {
+              return;
+          }
+          // warn multiple elements
+          if (children.length > 1) {
+              warn('<transition> can only be used on a single element. Use ' +
+                  '<transition-group> for lists.', this.$parent);
+          }
+          const mode = this.mode;
+          // warn invalid mode
+          if (mode &&
+              mode !== 'in-out' &&
+              mode !== 'out-in') {
+              warn('invalid <transition> mode: ' + mode, this.$parent);
+          }
+          const rawChild = children[0];
+          // if this is a component root node and the component's
+          // parent container node also has transition, skip.
+          if (hasParentTransition(this.$vnode)) {
+              return rawChild;
+          }
+          // apply transition data to child
+          // use getRealChild() to ignore abstract components e.g. keep-alive
+          const child = getRealChild(rawChild);
+          /* istanbul ignore if */
+          if (!child) {
+              return rawChild;
+          }
+          if (this._leaving) {
+              return placeholder(h, rawChild);
+          }
+          // ensure a key that is unique to the vnode type and to this transition
+          // component instance. This key will be used to remove pending leaving nodes
+          // during entering.
+          const id = `__transition-${this._uid}-`;
+          child.key =
+              child.key == null
+                  ? child.isComment
+                      ? id + 'comment'
+                      : id + child.tag
+                  : isPrimitive(child.key)
+                      ? String(child.key).indexOf(id) === 0
+                          ? child.key
+                          : id + child.key
+                      : child.key;
+          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
+          const oldRawChild = this._vnode;
+          const oldChild = getRealChild(oldRawChild);
+          // mark v-show
+          // so that the transition module can hand over the control to the directive
+          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
+              child.data.show = true;
+          }
+          if (oldChild &&
+              oldChild.data &&
+              !isSameChild(child, oldChild) &&
+              !isAsyncPlaceholder(oldChild) &&
+              // #6687 component root is a comment node
+              !(oldChild.componentInstance &&
+                  oldChild.componentInstance._vnode.isComment)) {
+              // replace old child transition data with fresh one
+              // important for dynamic transitions!
+              const oldData = (oldChild.data.transition = extend({}, data));
+              // handle transition mode
+              if (mode === 'out-in') {
+                  // return placeholder node and queue update when leave finishes
+                  this._leaving = true;
+                  mergeVNodeHook(oldData, 'afterLeave', () => {
+                      this._leaving = false;
+                      this.$forceUpdate();
+                  });
+                  return placeholder(h, rawChild);
+              }
+              else if (mode === 'in-out') {
+                  if (isAsyncPlaceholder(child)) {
+                      return oldRawChild;
+                  }
+                  let delayedLeave;
+                  const performLeave = () => {
+                      delayedLeave();
+                  };
+                  mergeVNodeHook(data, 'afterEnter', performLeave);
+                  mergeVNodeHook(data, 'enterCancelled', performLeave);
+                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+                      delayedLeave = leave;
+                  });
+              }
+          }
+          return rawChild;
+      },
   };
 
-  // Provides transition support for list items.
-  const props = extend({
-      tag: String,
-      moveClass: String,
-  }, transitionProps);
-  delete props.mode;
-  var TransitionGroup = {
-      props,
-      beforeMount() {
-          const update = this._update;
-          this._update = (vnode, hydrating) => {
-              const restoreActiveInstance = setActiveInstance(this);
-              // force removing pass
-              this.__patch__(this._vnode, this.kept, false, // hydrating
-              true // removeOnly (!important, avoids unnecessary moves)
-              );
-              this._vnode = this.kept;
-              restoreActiveInstance();
-              update.call(this, vnode, hydrating);
-          };
-      },
-      render(h) {
-          const tag = this.tag || this.$vnode.data.tag || "span";
-          const map = Object.create(null);
-          const prevChildren = (this.prevChildren = this.children);
-          const rawChildren = this.$slots.default || [];
-          const children = (this.children = []);
-          const transitionData = extractTransitionData(this);
-          for (let i = 0; i < rawChildren.length; i++) {
-              const c = rawChildren[i];
-              if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                      children.push(c);
-                      map[c.key] = c;
-                      (c.data || (c.data = {})).transition = transitionData;
-                  }
-                  else {
-                      const opts = c.componentOptions;
-                      const name = opts
-                          ? opts.Ctor.options.name || opts.tag || ""
-                          : c.tag;
-                      warn(`<transition-group> children must be keyed: <${name}>`);
-                  }
-              }
-          }
-          if (prevChildren) {
-              const kept = [];
-              const removed = [];
-              for (let i = 0; i < prevChildren.length; i++) {
-                  const c = prevChildren[i];
-                  c.data.transition = transitionData;
-                  // @ts-expect-error .getBoundingClientRect is not typed in Node
-                  c.data.pos = c.elm.getBoundingClientRect();
-                  if (map[c.key]) {
-                      kept.push(c);
-                  }
-                  else {
-                      removed.push(c);
-                  }
-              }
-              this.kept = h(tag, null, kept);
-              this.removed = removed;
-          }
-          return h(tag, null, children);
-      },
-      updated() {
-          const children = this.prevChildren;
-          const moveClass = this.moveClass || (this.name || "v") + "-move";
-          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-              return;
-          }
-          // we divide the work into three loops to avoid mixing DOM reads and writes
-          // in each iteration - which helps prevent layout thrashing.
-          children.forEach(callPendingCbs);
-          children.forEach(recordPosition);
-          children.forEach(applyTranslation);
-          // force reflow to put everything in position
-          // assign to this to avoid being removed in tree-shaking
-          // $flow-disable-line
-          this._reflow = document.body.offsetHeight;
-          children.forEach((c) => {
-              if (c.data.moved) {
-                  const el = c.elm;
-                  const s = el.style;
-                  addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = "";
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
-                          return;
-                      }
-                      if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
-                      }
-                  }));
-              }
-          });
-      },
-      methods: {
-          hasMove(el, moveClass) {
-              /* istanbul ignore if */
-              if (!hasTransition) {
-                  return false;
-              }
-              /* istanbul ignore if */
-              if (this._hasMove) {
-                  return this._hasMove;
-              }
-              // Detect whether an element with the move class applied has
-              // CSS transitions. Since the element may be inside an entering
-              // transition at this very moment, we make a clone of it and remove
-              // all other transition classes applied to ensure only the move class
-              // is applied.
-              const clone = el.cloneNode();
-              if (el._transitionClasses) {
-                  el._transitionClasses.forEach((cls) => {
-                      removeClass(clone, cls);
-                  });
-              }
-              addClass(clone, moveClass);
-              clone.style.display = "none";
-              this.$el.appendChild(clone);
-              const info = getTransitionInfo(clone);
-              this.$el.removeChild(clone);
-              return (this._hasMove = info.hasTransform);
-          },
-      },
-  };
-  function callPendingCbs(c) {
-      /* istanbul ignore if */
-      if (c.elm._moveCb) {
-          c.elm._moveCb();
-      }
-      /* istanbul ignore if */
-      if (c.elm._enterCb) {
-          c.elm._enterCb();
-      }
-  }
-  function recordPosition(c) {
-      c.data.newPos = c.elm.getBoundingClientRect();
-  }
-  function applyTranslation(c) {
-      const oldPos = c.data.pos;
-      const newPos = c.data.newPos;
-      const dx = oldPos.left - newPos.left;
-      const dy = oldPos.top - newPos.top;
-      if (dx || dy) {
-          c.data.moved = true;
-          const s = c.elm.style;
-          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-          s.transitionDuration = "0s";
-      }
+  // Provides transition support for list items.
+  const props = extend({
+      tag: String,
+      moveClass: String,
+  }, transitionProps);
+  delete props.mode;
+  var TransitionGroup = {
+      props,
+      beforeMount() {
+          const update = this._update;
+          this._update = (vnode, hydrating) => {
+              const restoreActiveInstance = setActiveInstance(this);
+              // force removing pass
+              this.__patch__(this._vnode, this.kept, false, // hydrating
+              true // removeOnly (!important, avoids unnecessary moves)
+              );
+              this._vnode = this.kept;
+              restoreActiveInstance();
+              update.call(this, vnode, hydrating);
+          };
+      },
+      render(h) {
+          const tag = this.tag || this.$vnode.data.tag || "span";
+          const map = Object.create(null);
+          const prevChildren = (this.prevChildren = this.children);
+          const rawChildren = this.$slots.default || [];
+          const children = (this.children = []);
+          const transitionData = extractTransitionData(this);
+          for (let i = 0; i < rawChildren.length; i++) {
+              const c = rawChildren[i];
+              if (c.tag) {
+                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
+                      children.push(c);
+                      map[c.key] = c;
+                      (c.data || (c.data = {})).transition = transitionData;
+                  }
+                  else {
+                      const opts = c.componentOptions;
+                      const name = opts
+                          ? opts.Ctor.options.name || opts.tag || ""
+                          : c.tag;
+                      warn(`<transition-group> children must be keyed: <${name}>`);
+                  }
+              }
+          }
+          if (prevChildren) {
+              const kept = [];
+              const removed = [];
+              for (let i = 0; i < prevChildren.length; i++) {
+                  const c = prevChildren[i];
+                  c.data.transition = transitionData;
+                  // @ts-expect-error .getBoundingClientRect is not typed in Node
+                  c.data.pos = c.elm.getBoundingClientRect();
+                  if (map[c.key]) {
+                      kept.push(c);
+                  }
+                  else {
+                      removed.push(c);
+                  }
+              }
+              this.kept = h(tag, null, kept);
+              this.removed = removed;
+          }
+          return h(tag, null, children);
+      },
+      updated() {
+          const children = this.prevChildren;
+          const moveClass = this.moveClass || (this.name || "v") + "-move";
+          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
+              return;
+          }
+          // we divide the work into three loops to avoid mixing DOM reads and writes
+          // in each iteration - which helps prevent layout thrashing.
+          children.forEach(callPendingCbs);
+          children.forEach(recordPosition);
+          children.forEach(applyTranslation);
+          // force reflow to put everything in position
+          // assign to this to avoid being removed in tree-shaking
+          // $flow-disable-line
+          this._reflow = document.body.offsetHeight;
+          children.forEach((c) => {
+              if (c.data.moved) {
+                  const el = c.elm;
+                  const s = el.style;
+                  addTransitionClass(el, moveClass);
+                  s.transform = s.WebkitTransform = s.transitionDuration = "";
+                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
+                      if (e && e.target !== el) {
+                          return;
+                      }
+                      if (!e || /transform$/.test(e.propertyName)) {
+                          el.removeEventListener(transitionEndEvent, cb);
+                          el._moveCb = null;
+                          removeTransitionClass(el, moveClass);
+                      }
+                  }));
+              }
+          });
+      },
+      methods: {
+          hasMove(el, moveClass) {
+              /* istanbul ignore if */
+              if (!hasTransition) {
+                  return false;
+              }
+              /* istanbul ignore if */
+              if (this._hasMove) {
+                  return this._hasMove;
+              }
+              // Detect whether an element with the move class applied has
+              // CSS transitions. Since the element may be inside an entering
+              // transition at this very moment, we make a clone of it and remove
+              // all other transition classes applied to ensure only the move class
+              // is applied.
+              const clone = el.cloneNode();
+              if (el._transitionClasses) {
+                  el._transitionClasses.forEach((cls) => {
+                      removeClass(clone, cls);
+                  });
+              }
+              addClass(clone, moveClass);
+              clone.style.display = "none";
+              this.$el.appendChild(clone);
+              const info = getTransitionInfo(clone);
+              this.$el.removeChild(clone);
+              return (this._hasMove = info.hasTransform);
+          },
+      },
+  };
+  function callPendingCbs(c) {
+      /* istanbul ignore if */
+      if (c.elm._moveCb) {
+          c.elm._moveCb();
+      }
+      /* istanbul ignore if */
+      if (c.elm._enterCb) {
+          c.elm._enterCb();
+      }
+  }
+  function recordPosition(c) {
+      c.data.newPos = c.elm.getBoundingClientRect();
+  }
+  function applyTranslation(c) {
+      const oldPos = c.data.pos;
+      const newPos = c.data.newPos;
+      const dx = oldPos.left - newPos.left;
+      const dy = oldPos.top - newPos.top;
+      if (dx || dy) {
+          c.data.moved = true;
+          const s = c.elm.style;
+          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
+          s.transitionDuration = "0s";
+      }
   }
 
-  var platformComponents = {
-      Transition,
-      TransitionGroup,
+  var platformComponents = {
+      Transition,
+      TransitionGroup,
   };
 
-  // install platform specific utils
-  Vue.config.mustUseProp = mustUseProp;
-  Vue.config.isReservedTag = isReservedTag;
-  Vue.config.isReservedAttr = isReservedAttr;
-  Vue.config.getTagNamespace = getTagNamespace;
-  Vue.config.isUnknownElement = isUnknownElement;
-  // install platform runtime directives & components
-  extend(Vue.options.directives, platformDirectives);
-  extend(Vue.options.components, platformComponents);
-  // install platform patch function
-  Vue.prototype.__patch__ = inBrowser ? patch : noop;
-  // public mount method
-  Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query(el) : undefined;
-      return mountComponent(this, el, hydrating);
-  };
-  // devtools global hook
-  /* istanbul ignore next */
-  if (inBrowser) {
-      setTimeout(() => {
-          if (config.devtools) {
-              if (devtools) {
-                  devtools.emit('init', Vue);
-              }
-              else {
-                  // @ts-expect-error
-                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                      'https://github.com/vuejs/vue-devtools');
-              }
-          }
-          if (config.productionTip !== false &&
-              typeof console !== 'undefined') {
-              // @ts-expect-error
-              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                  `Make sure to turn on production mode when deploying for production.\n` +
-                  `See more tips at https://vuejs.org/guide/deployment.html`);
-          }
-      }, 0);
+  // install platform specific utils
+  Vue.config.mustUseProp = mustUseProp;
+  Vue.config.isReservedTag = isReservedTag;
+  Vue.config.isReservedAttr = isReservedAttr;
+  Vue.config.getTagNamespace = getTagNamespace;
+  Vue.config.isUnknownElement = isUnknownElement;
+  // install platform runtime directives & components
+  extend(Vue.options.directives, platformDirectives);
+  extend(Vue.options.components, platformComponents);
+  // install platform patch function
+  Vue.prototype.__patch__ = inBrowser ? patch : noop;
+  // public mount method
+  Vue.prototype.$mount = function (el, hydrating) {
+      el = el && inBrowser ? query(el) : undefined;
+      return mountComponent(this, el, hydrating);
+  };
+  // devtools global hook
+  /* istanbul ignore next */
+  if (inBrowser) {
+      setTimeout(() => {
+          if (config.devtools) {
+              if (devtools) {
+                  devtools.emit('init', Vue);
+              }
+              else {
+                  // @ts-expect-error
+                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
+                      'https://github.com/vuejs/vue-devtools');
+              }
+          }
+          if (config.productionTip !== false &&
+              typeof console !== 'undefined') {
+              // @ts-expect-error
+              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
+                  `Make sure to turn on production mode when deploying for production.\n` +
+                  `See more tips at https://vuejs.org/guide/deployment.html`);
+          }
+      }, 0);
   }
 
   return Vue;
diff --git a/flow/compiler.js b/flow/compiler.js
deleted file mode 100644
index ad09a2e2ebe..00000000000
--- a/flow/compiler.js
+++ /dev/null
@@ -1,227 +0,0 @@
-declare type CompilerOptions = {
-  warn?: Function; // allow customizing warning in different environments; e.g. node
-  modules?: Array<ModuleOptions>; // platform specific modules; e.g. style; class
-  directives?: { [key: string]: Function }; // platform specific directives
-  staticKeys?: string; // a list of AST properties to be considered static; for optimization
-  isUnaryTag?: (tag: string) => ?boolean; // check if a tag is unary for the platform
-  canBeLeftOpenTag?: (tag: string) => ?boolean; // check if a tag can be left opened
-  isReservedTag?: (tag: string) => ?boolean; // check if a tag is a native for the platform
-  preserveWhitespace?: boolean; // preserve whitespace between elements? (Deprecated)
-  whitespace?: 'preserve' | 'condense'; // whitespace handling strategy
-  optimize?: boolean; // optimize static content?
-
-  // web specific
-  mustUseProp?: (tag: string, type: ?string, name: string) => boolean; // check if an attribute should be bound as a property
-  isPreTag?: (attr: string) => ?boolean; // check if a tag needs to preserve whitespace
-  getTagNamespace?: (tag: string) => ?string; // check the namespace for a tag
-  expectHTML?: boolean; // only false for non-web builds
-  isFromDOM?: boolean;
-  shouldDecodeTags?: boolean;
-  shouldDecodeNewlines?:  boolean;
-  shouldDecodeNewlinesForHref?: boolean;
-  outputSourceRange?: boolean;
-
-  // runtime user-configurable
-  delimiters?: [string, string]; // template delimiters
-  comments?: boolean; // preserve comments in template
-
-  // for ssr optimization compiler
-  scopeId?: string;
-};
-
-declare type WarningMessage = {
-  msg: string;
-  start?: number;
-  end?: number;
-};
-
-declare type CompiledResult = {
-  ast: ?ASTElement;
-  render: string;
-  staticRenderFns: Array<string>;
-  stringRenderFns?: Array<string>;
-  errors?: Array<string | WarningMessage>;
-  tips?: Array<string | WarningMessage>;
-};
-
-declare type ModuleOptions = {
-  // transform an AST node before any attributes are processed
-  // returning an ASTElement from pre/transforms replaces the element
-  preTransformNode: (el: ASTElement) => ?ASTElement;
-  // transform an AST node after built-ins like v-if, v-for are processed
-  transformNode: (el: ASTElement) => ?ASTElement;
-  // transform an AST node after its children have been processed
-  // cannot return replacement in postTransform because tree is already finalized
-  postTransformNode: (el: ASTElement) => void;
-  genData: (el: ASTElement) => string; // generate extra data string for an element
-  transformCode?: (el: ASTElement, code: string) => string; // further transform generated code for an element
-  staticKeys?: Array<string>; // AST properties to be considered static
-};
-
-declare type ASTModifiers = { [key: string]: boolean };
-declare type ASTIfCondition = { exp: ?string; block: ASTElement };
-declare type ASTIfConditions = Array<ASTIfCondition>;
-
-declare type ASTAttr = {
-  name: string;
-  value: any;
-  dynamic?: boolean;
-  start?: number;
-  end?: number
-};
-
-declare type ASTElementHandler = {
-  value: string;
-  params?: Array<any>;
-  modifiers: ?ASTModifiers;
-  dynamic?: boolean;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTElementHandlers = {
-  [key: string]: ASTElementHandler | Array<ASTElementHandler>;
-};
-
-declare type ASTDirective = {
-  name: string;
-  rawName: string;
-  value: string;
-  arg: ?string;
-  isDynamicArg: boolean;
-  modifiers: ?ASTModifiers;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTNode = ASTElement | ASTText | ASTExpression;
-
-declare type ASTElement = {
-  type: 1;
-  tag: string;
-  attrsList: Array<ASTAttr>;
-  attrsMap: { [key: string]: any };
-  rawAttrsMap: { [key: string]: ASTAttr };
-  parent: ASTElement | void;
-  children: Array<ASTNode>;
-
-  start?: number;
-  end?: number;
-
-  processed?: true;
-
-  static?: boolean;
-  staticRoot?: boolean;
-  staticInFor?: boolean;
-  staticProcessed?: boolean;
-  hasBindings?: boolean;
-
-  text?: string;
-  attrs?: Array<ASTAttr>;
-  dynamicAttrs?: Array<ASTAttr>;
-  props?: Array<ASTAttr>;
-  plain?: boolean;
-  pre?: true;
-  ns?: string;
-
-  component?: string;
-  inlineTemplate?: true;
-  transitionMode?: string | null;
-  slotName?: ?string;
-  slotTarget?: ?string;
-  slotTargetDynamic?: boolean;
-  slotScope?: ?string;
-  scopedSlots?: { [name: string]: ASTElement };
-
-  ref?: string;
-  refInFor?: boolean;
-
-  if?: string;
-  ifProcessed?: boolean;
-  elseif?: string;
-  else?: true;
-  ifConditions?: ASTIfConditions;
-
-  for?: string;
-  forProcessed?: boolean;
-  key?: string;
-  alias?: string;
-  iterator1?: string;
-  iterator2?: string;
-
-  staticClass?: string;
-  classBinding?: string;
-  staticStyle?: string;
-  styleBinding?: string;
-  events?: ASTElementHandlers;
-  nativeEvents?: ASTElementHandlers;
-
-  transition?: string | true;
-  transitionOnAppear?: boolean;
-
-  model?: {
-    value: string;
-    callback: string;
-    expression: string;
-  };
-
-  directives?: Array<ASTDirective>;
-
-  forbidden?: true;
-  once?: true;
-  onceProcessed?: boolean;
-  wrapData?: (code: string) => string;
-  wrapListeners?: (code: string) => string;
-
-  // 2.4 ssr optimization
-  ssrOptimizability?: number;
-
-  // weex specific
-  appendAsTree?: boolean;
-};
-
-declare type ASTExpression = {
-  type: 2;
-  expression: string;
-  text: string;
-  tokens: Array<string | Object>;
-  static?: boolean;
-  // 2.4 ssr optimization
-  ssrOptimizability?: number;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTText = {
-  type: 3;
-  text: string;
-  static?: boolean;
-  isComment?: boolean;
-  // 2.4 ssr optimization
-  ssrOptimizability?: number;
-  start?: number;
-  end?: number;
-};
-
-// SFC-parser related declarations
-
-// an object format describing a single-file component
-declare type SFCDescriptor = {
-  template: ?SFCBlock;
-  script: ?SFCBlock;
-  styles: Array<SFCBlock>;
-  customBlocks: Array<SFCBlock>;
-  errors: Array<string | WarningMessage>;
-}
-
-declare type SFCBlock = {
-  type: string;
-  content: string;
-  attrs: {[attribute:string]: string};
-  start?: number;
-  end?: number;
-  lang?: string;
-  src?: string;
-  scoped?: boolean;
-  module?: string | boolean;
-};
diff --git a/flow/component.js b/flow/component.js
deleted file mode 100644
index 0dc67a48a3e..00000000000
--- a/flow/component.js
+++ /dev/null
@@ -1,148 +0,0 @@
-import type { Config } from '../src/core/config'
-import type VNode from '../src/core/vdom/vnode'
-import type Watcher from '../src/core/observer/watcher'
-
-declare interface Component {
-  // constructor information
-  static cid: number;
-  static options: Object;
-  // extend
-  static extend: (options: Object) => Function;
-  static superOptions: Object;
-  static extendOptions: Object;
-  static sealedOptions: Object;
-  static super: Class<Component>;
-  // assets
-  static directive: (id: string, def?: Function | Object) => Function | Object | void;
-  static component: (id: string, def?: Class<Component> | Object) => Class<Component>;
-  static filter: (id: string, def?: Function) => Function | void;
-  // functional context constructor
-  static FunctionalRenderContext: Function;
-
-  // public properties
-  $el: any; // so that we can attach __vue__ to it
-  $data: Object;
-  $props: Object;
-  $options: ComponentOptions;
-  $parent: Component | void;
-  $root: Component;
-  $children: Array<Component>;
-  $refs: { [key: string]: Component | Element | Array<Component | Element> | void };
-  $slots: { [key: string]: Array<VNode> };
-  $scopedSlots: { [key: string]: () => VNodeChildren };
-  $vnode: VNode; // the placeholder node for the component in parent's render tree
-  $attrs: { [key: string] : string };
-  $listeners: { [key: string]: Function | Array<Function> };
-  $isServer: boolean;
-
-  // public methods
-  $mount: (el?: Element | string, hydrating?: boolean) => Component;
-  $forceUpdate: () => void;
-  $destroy: () => void;
-  $set: <T>(target: Object | Array<T>, key: string | number, val: T) => T;
-  $delete: <T>(target: Object | Array<T>, key: string | number) => void;
-  $watch: (expOrFn: string | Function, cb: Function, options?: Object) => Function;
-  $on: (event: string | Array<string>, fn: Function) => Component;
-  $once: (event: string, fn: Function) => Component;
-  $off: (event?: string | Array<string>, fn?: Function) => Component;
-  $emit: (event: string, ...args: Array<mixed>) => Component;
-  $nextTick: (fn: Function) => void | Promise<*>;
-  $createElement: (tag?: string | Component, data?: Object, children?: VNodeChildren) => VNode;
-
-  // private properties
-  _uid: number | string;
-  _name: string; // this only exists in dev mode
-  _isVue: true;
-  _self: Component;
-  _renderProxy: Component;
-  _renderContext: ?Component;
-  _watcher: Watcher;
-  _watchers: Array<Watcher>;
-  _computedWatchers: { [key: string]: Watcher };
-  _data: Object;
-  _props: Object;
-  _events: Object;
-  _inactive: boolean | null;
-  _directInactive: boolean;
-  _isMounted: boolean;
-  _isDestroyed: boolean;
-  _isBeingDestroyed: boolean;
-  _vnode: ?VNode; // self root node
-  _staticTrees: ?Array<VNode>; // v-once cached trees
-  _hasHookEvent: boolean;
-  _provided: ?Object;
-  // _virtualComponents?: { [key: string]: Component };
-
-  // private methods
-
-  // lifecycle
-  _init: Function;
-  _mount: (el?: Element | void, hydrating?: boolean) => Component;
-  _update: (vnode: VNode, hydrating?: boolean) => void;
-
-  // rendering
-  _render: () => VNode;
-
-  __patch__: (
-    a: Element | VNode | void,
-    b: VNode,
-    hydrating?: boolean,
-    removeOnly?: boolean,
-    parentElm?: any,
-    refElm?: any
-  ) => any;
-
-  // createElement
-
-  // _c is internal that accepts `normalizationType` optimization hint
-  _c: (
-    vnode?: VNode,
-    data?: VNodeData,
-    children?: VNodeChildren,
-    normalizationType?: number
-  ) => VNode | void;
-
-  // renderStatic
-  _m: (index: number, isInFor?: boolean) => VNode | VNodeChildren;
-  // markOnce
-  _o: (vnode: VNode | Array<VNode>, index: number, key: string) => VNode | VNodeChildren;
-  // toString
-  _s: (value: mixed) => string;
-  // text to VNode
-  _v: (value: string | number) => VNode;
-  // toNumber
-  _n: (value: string) => number | string;
-  // empty vnode
-  _e: () => VNode;
-  // loose equal
-  _q: (a: mixed, b: mixed) => boolean;
-  // loose indexOf
-  _i: (arr: Array<mixed>, val: mixed) => number;
-  // resolveFilter
-  _f: (id: string) => Function;
-  // renderList
-  _l: (val: mixed, render: Function) => ?Array<VNode>;
-  // renderSlot
-  _t: (name: string, fallback: ?Array<VNode>, props: ?Object) => ?Array<VNode>;
-  // apply v-bind object
-  _b: (data: any, tag: string, value: any, asProp: boolean, isSync?: boolean) => VNodeData;
-  // apply v-on object
-  _g: (data: any, value: any) => VNodeData;
-  // check custom keyCode
-  _k: (eventKeyCode: number, key: string, builtInAlias?: number | Array<number>, eventKeyName?: string) => ?boolean;
-  // resolve scoped slots
-  _u: (scopedSlots: ScopedSlotsData, res?: Object) => { [key: string]: Function };
-
-  // SSR specific
-  _ssrNode: Function;
-  _ssrList: Function;
-  _ssrEscape: Function;
-  _ssrAttr: Function;
-  _ssrAttrs: Function;
-  _ssrDOMProps: Function;
-  _ssrClass: Function;
-  _ssrStyle: Function;
-
-  // allow dynamic method registration
-  [key: string]: any
-};
diff --git a/flow/global-api.js b/flow/global-api.js
deleted file mode 100644
index 0ce54fda3f4..00000000000
--- a/flow/global-api.js
+++ /dev/null
@@ -1,23 +0,0 @@
-declare interface GlobalAPI {
-  cid: number;
-  options: Object;
-  config: Config;
-  util: Object;
-
-  extend: (options: Object) => Function;
-  set: <T>(target: Object | Array<T>, key: string | number, value: T) => T;
-  delete: <T>(target: Object| Array<T>, key: string | number) => void;
-  nextTick: (fn: Function, context?: Object) => void | Promise<*>;
-  use: (plugin: Function | Object) => GlobalAPI;
-  mixin: (mixin: Object) => GlobalAPI;
-  compile: (template: string) => { render: Function, staticRenderFns: Array<Function> };
-
-  directive: (id: string, def?: Function | Object) => Function | Object | void;
-  component: (id: string, def?: Class<Component> | Object) => Class<Component>;
-  filter: (id: string, def?: Function) => Function | void;
-
-  observable: <T>(value: T) => T;
-
-  // allow dynamic method registration
-  [key: string]: any
-};
diff --git a/flow/modules.js b/flow/modules.js
deleted file mode 100644
index a660e9c9101..00000000000
--- a/flow/modules.js
+++ /dev/null
@@ -1,44 +0,0 @@
-declare module 'he' {
-  declare function escape(html: string): string;
-  declare function decode(html: string): string;
-}
-
-declare module 'source-map' {
-  declare class SourceMapGenerator {
-    setSourceContent(filename: string, content: string): void;
-    addMapping(mapping: Object): void;
-    toString(): string;
-  }
-  declare class SourceMapConsumer {
-    constructor (map: Object): void;
-    originalPositionFor(position: { line: number; column: number; }): {
-      source: ?string;
-      line: ?number;
-      column: ?number;
-    };
-  }
-}
-
-declare module 'lru-cache' {
-  declare var exports: {
-    (): any
-  }
-}
-
-declare module 'de-indent' {
-  declare var exports: {
-    (input: string): string
-  }
-}
-
-declare module 'serialize-javascript' {
-  declare var exports: {
-    (input: string, options: { isJSON: boolean }): string
-  }
-}
-
-declare module 'lodash.template' {
-  declare var exports: {
-    (input: string, options: { interpolate: RegExp, escape: RegExp }): Function
-  }
-}
diff --git a/flow/options.js b/flow/options.js
deleted file mode 100644
index 09bd93f5d24..00000000000
--- a/flow/options.js
+++ /dev/null
@@ -1,90 +0,0 @@
-declare type InternalComponentOptions = {
-  _isComponent: true;
-  parent: Component;
-  _parentVnode: VNode;
-  render?: Function;
-  staticRenderFns?: Array<Function>
-};
-
-type InjectKey = string | Symbol;
-
-declare type ComponentOptions = {
-  componentId?: string;
-
-  // data
-  data: Object | Function | void;
-  props?: { [key: string]: PropOptions };
-  propsData?: ?Object;
-  computed?: {
-    [key: string]: Function | {
-      get?: Function;
-      set?: Function;
-      cache?: boolean
-    }
-  };
-  methods?: { [key: string]: Function };
-  watch?: { [key: string]: Function | string };
-
-  // DOM
-  el?: string | Element;
-  template?: string;
-  render: (h: () => VNode) => VNode;
-  renderError?: (h: () => VNode, err: Error) => VNode;
-  staticRenderFns?: Array<() => VNode>;
-
-  // lifecycle
-  beforeCreate?: Function;
-  created?: Function;
-  beforeMount?: Function;
-  mounted?: Function;
-  beforeUpdate?: Function;
-  updated?: Function;
-  activated?: Function;
-  deactivated?: Function;
-  beforeDestroy?: Function;
-  destroyed?: Function;
-  errorCaptured?: () => boolean | void;
-  serverPrefetch?: Function;
-
-  // assets
-  directives?: { [key: string]: Object };
-  components?: { [key: string]: Class<Component> };
-  transitions?: { [key: string]: Object };
-  filters?: { [key: string]: Function };
-
-  // context
-  provide?: { [key: string | Symbol]: any } | () => { [key: string | Symbol]: any };
-  inject?: { [key: string]: InjectKey | { from?: InjectKey, default?: any }} | Array<string>;
-
-  // component v-model customization
-  model?: {
-    prop?: string;
-    event?: string;
-  };
-
-  // misc
-  parent?: Component;
-  mixins?: Array<Object>;
-  name?: string;
-  extends?: Class<Component> | Object;
-  delimiters?: [string, string];
-  comments?: boolean;
-  inheritAttrs?: boolean;
-
-  // private
-  _isComponent?: true;
-  _propKeys?: Array<string>;
-  _parentVnode?: VNode;
-  _parentListeners?: ?Object;
-  _renderChildren?: ?Array<VNode>;
-  _componentTag: ?string;
-  _scopeId: ?string;
-  _base: Class<Component>;
-};
-
-declare type PropOptions = {
-  type: Function | Array<Function> | null;
-  default: any;
-  required: ?boolean;
-  validator: ?Function;
-}
diff --git a/flow/ssr.js b/flow/ssr.js
deleted file mode 100644
index d6a94592454..00000000000
--- a/flow/ssr.js
+++ /dev/null
@@ -1,21 +0,0 @@
-declare type ComponentWithCacheContext = {
-  type: 'ComponentWithCache';
-  bufferIndex: number;
-  buffer: Array<string>;
-  key: string;
-};
-
-declare type ElementContext = {
-  type: 'Element';
-  children: Array<VNode>;
-  rendered: number;
-  endTag: string;
-  total: number;
-};
-
-declare type ComponentContext = {
-  type: 'Component';
-  prevActive: Component;
-};
-
-declare type RenderState = ComponentContext | ComponentWithCacheContext | ElementContext;
diff --git a/flow/vnode.js b/flow/vnode.js
deleted file mode 100644
index c9f3b3887d3..00000000000
--- a/flow/vnode.js
+++ /dev/null
@@ -1,79 +0,0 @@
-declare type VNodeChildren = Array<?VNode | string | VNodeChildren> | string;
-
-declare type VNodeComponentOptions = {
-  Ctor: Class<Component>;
-  propsData: ?Object;
-  listeners: ?Object;
-  children: ?Array<VNode>;
-  tag?: string;
-};
-
-declare type MountedComponentVNode = {
-  context: Component;
-  componentOptions: VNodeComponentOptions;
-  componentInstance: Component;
-  parent: VNode;
-  data: VNodeData;
-};
-
-// interface for vnodes in update modules
-declare type VNodeWithData = {
-  tag: string;
-  data: VNodeData;
-  children: ?Array<VNode>;
-  text: void;
-  elm: any;
-  ns: string | void;
-  context: Component;
-  key: string | number | void;
-  parent?: VNodeWithData;
-  componentOptions?: VNodeComponentOptions;
-  componentInstance?: Component;
-  isRootInsert: boolean;
-};
-
-declare interface VNodeData {
-  key?: string | number;
-  slot?: string;
-  ref?: string;
-  is?: string;
-  pre?: boolean;
-  tag?: string;
-  staticClass?: string;
-  class?: any;
-  staticStyle?: { [key: string]: any };
-  style?: string | Array<Object> | Object;
-  normalizedStyle?: Object;
-  props?: { [key: string]: any };
-  attrs?: { [key: string]: string };
-  domProps?: { [key: string]: any };
-  hook?: { [key: string]: Function };
-  on?: ?{ [key: string]: Function | Array<Function> };
-  nativeOn?: { [key: string]: Function | Array<Function> };
-  transition?: Object;
-  show?: boolean; // marker for v-show
-  inlineTemplate?: {
-    render: Function;
-    staticRenderFns: Array<Function>;
-  };
-  directives?: Array<VNodeDirective>;
-  keepAlive?: boolean;
-  scopedSlots?: { [key: string]: Function };
-  model?: {
-    value: any;
-    callback: Function;
-  };
-};
-
-declare type VNodeDirective = {
-  name: string;
-  rawName: string;
-  value?: any;
-  oldValue?: any;
-  arg?: string;
-  oldArg?: string;
-  modifiers?: ASTModifiers;
-  def?: Object;
-};
-
-declare type ScopedSlotsData = Array<{ key: string, fn: Function } | ScopedSlotsData>;
diff --git a/flow/weex.js b/flow/weex.js
deleted file mode 100644
index 6d21a57934a..00000000000
--- a/flow/weex.js
+++ /dev/null
@@ -1,122 +0,0 @@
-// global flag to be compiled away
-declare var __WEEX__: boolean;
-
-// global object in Weex
-declare var WXEnvironment: WeexEnvironment;
-
-declare type Weex = {
-  config: WeexConfigAPI;
-  document: WeexDocument;
-  requireModule: (name: string) => Object | void;
-  supports: (condition: string) => boolean | void;
-  isRegisteredModule: (name: string, method?: string) => boolean;
-  isRegisteredComponent: (name: string) => boolean;
-};
-
-declare type WeexConfigAPI = {
-  bundleUrl: string; // === weex.document.URL
-  bundleType: string;
-  env: WeexEnvironment; // === WXEnvironment
-};
-
-declare type WeexEnvironment = {
-  platform: string; // could be "Web", "iOS", "Android"
-  weexVersion: string; // the version of WeexSDK
-
-  osName: string; // could be "iOS", "Android" or others
-  osVersion: string;
-  appName: string; // mobile app name or browser name
-  appVersion: string;
-
-  // information about current running device
-  deviceModel: string; // phone device model
-  deviceWidth: number;
-  deviceHeight: number;
-  scale: number;
-
-  // only available on the web
-  userAgent?: string;
-  dpr?: number;
-  rem?: number;
-};
-
-declare interface WeexDocument {
-  id: string;
-  URL: string;
-  taskCenter: WeexTaskCenter;
-
-  open: () => void;
-  close: () => void;
-  createElement: (tagName: string, props?: Object) => WeexElement;
-  createComment: (text: string) => Object;
-  fireEvent: (type: string) => void;
-  destroy: () => void;
-};
-
-declare interface WeexTaskCenter {
-  instanceId: string;
-  callbackManager: Object;
-  send: (type: string, params: Object, args: Array<any>, options?: Object) => void;
-  registerHook: (componentId: string, type: string, hook: string, fn: Function) => void;
-  updateData: (componentId: string, data: Object | void, callback?: Function) => void;
-};
-
-declare interface WeexElement {
-  nodeType: number;
-  nodeId: string;
-  type: string;
-  ref: string;
-  text?: string;
-
-  parentNode: WeexElement | void;
-  children: Array<WeexElement>;
-  previousSibling: WeexElement | void;
-  nextSibling: WeexElement | void;
-
-  appendChild: (node: WeexElement) => void;
-  removeChild: (node: WeexElement, preserved?: boolean) => void;
-  insertBefore: (node: WeexElement, before: WeexElement) => void;
-  insertAfter: (node: WeexElement, after: WeexElement) => void;
-  setAttr: (key: string, value: any, silent?: boolean) => void;
-  setAttrs: (attrs: Object, silent?: boolean) => void;
-  setStyle: (key: string, value: any, silent?: boolean) => void;
-  setStyles: (attrs: Object, silent?: boolean) => void;
-  addEvent: (type: string, handler: Function, args?: Array<any>) => void;
-  removeEvent: (type: string) => void;
-  fireEvent: (type: string) => void;
-  destroy: () => void;
-};
-
-declare type WeexInstanceOption = {
-  instanceId: string;
-  config: WeexConfigAPI;
-  document: WeexDocument;
-  Vue?: GlobalAPI;
-  app?: Component;
-  data?: Object;
-};
-
-declare type WeexRuntimeContext = {
-  weex: Weex;
-  service: Object;
-  BroadcastChannel?: Function;
-};
-
-declare type WeexInstanceContext = {
-  Vue: GlobalAPI;
-
-  // DEPRECATED
-  setTimeout?: Function;
-  clearTimeout?: Function;
-  setInterval?: Function;
-  clearInterval?: Function;
-};
-
-declare type WeexCompilerOptions = CompilerOptions & {
-  // whether to compile special template for <recycle-list>
-  recyclable?: boolean;
-};
-
-declare type WeexCompiledResult = CompiledResult & {
-  '@render'?: string;
-};
diff --git a/package.json b/package.json
index 97c4250d0e1..6c71dcc7d28 100644
--- a/package.json
+++ b/package.json
@@ -34,7 +34,7 @@
     "test:weex": "npm run build:weex && jasmine-ts JASMINE_CONFIG_PATH=test/weex/jasmine.ts",
     "test:ssr": "npm run build:ssr && jasmine JASMINE_CONFIG_PATH=test/ssr/jasmine.ts",
     "test:sauce": "npm run sauce -- 0 && npm run sauce -- 1 && npm run sauce -- 2",
-    "test:types": "tsc -p ./types/test/tsconfig.json",
+    "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
     "ts-check": "tsc --noEmit",
     "sauce": "karma start test/unit/karma.sauce.config.ts",
@@ -81,8 +81,8 @@
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-node-resolve": "^13.2.1",
     "@rollup/plugin-replace": "^4.0.0",
-    "@types/jasmine": "^4.0.3",
     "@types/he": "^1.1.2",
+    "@types/jasmine": "^4.0.3",
     "@types/node": "^17.0.30",
     "@types/webpack": "^5.28.0",
     "@types/webpack-env": "^1.16.4",
@@ -94,6 +94,7 @@
     "babel-helper-vue-jsx-merge-props": "^2.0.3",
     "babel-loader": "^8.2.5",
     "babel-plugin-istanbul": "^6.1.1",
+    "babel-plugin-transform-require-context": "^0.1.1",
     "babel-plugin-transform-vue-jsx": "^4.0.1",
     "babel-preset-flow-vue": "^1.0.0",
     "buble": "^0.20.0",
@@ -130,6 +131,7 @@
     "karma-sauce-launcher": "^4.3.6",
     "karma-sourcemap-loader": "^0.3.8",
     "karma-typescript": "^5.5.3",
+    "karma-typescript-es6-transform": "^5.5.3",
     "karma-webpack": "^5.0.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
@@ -146,7 +148,6 @@
     "selenium-server": "^3.141.59",
     "serialize-javascript": "^6.0.0",
     "shelljs": "^0.8.5",
-    "stream": "^0.0.2",
     "stream-browserify": "^3.0.0",
     "terser": "^5.13.1",
     "ts-loader": "^9.2.9",
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 96c1dceb156..5fe9e2be005 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -4,2606 +4,2605 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.renderVueComponentToString = factory());
 })(this, (function () { 'use strict';
 
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$1(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop$1(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys(modules) {
-      return modules
-          .reduce((keys, m) => {
-          return keys.concat(m.staticKeys || []);
-      }, [])
-          .join(',');
-  }
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-
-  const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-      'target,title,usemap,value,width,wrap');
-  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-  const isSSRUnsafeAttr = (name) => {
-      return unsafeAttrCharRE.test(name);
-  };
-  /* istanbul ignore next */
-  const isRenderableAttr = (name) => {
-      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-  };
-  const propsToAttrMap = {
-      acceptCharset: 'accept-charset',
-      className: 'class',
-      htmlFor: 'for',
-      httpEquiv: 'http-equiv',
+  const emptyObject = Object.freeze({});
+  // These helpers produce better VM code in JS engines due to their
+  // explicitness and function inlining.
+  function isUndef(v) {
+      return v === undefined || v === null;
+  }
+  function isDef(v) {
+      return v !== undefined && v !== null;
+  }
+  function isTrue(v) {
+      return v === true;
+  }
+  function isFalse(v) {
+      return v === false;
+  }
+  /**
+   * Check if value is primitive.
+   */
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
+  }
+  /**
+   * Quick object check - this is primarily used to tell
+   * objects from primitive values when we know the value
+   * is a JSON-compliant type.
+   */
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
+  }
+  /**
+   * Get the raw type string of a value, e.g., [object Object].
+   */
+  const _toString = Object.prototype.toString;
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
+  }
+  /**
+   * Strict object type check. Only returns true
+   * for plain JavaScript objects.
+   */
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
+  }
+  /**
+   * Check if val is a valid array index.
+   */
+  function isValidArrayIndex(val) {
+      const n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
+  }
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
+  }
+  /**
+   * Convert a value to a string that is actually rendered.
+   */
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
+  }
+  /**
+   * Convert an input value to a number for persistence.
+   * If the conversion fails, return original string.
+   */
+  function toNumber(val) {
+      const n = parseFloat(val);
+      return isNaN(n) ? val : n;
+  }
+  /**
+   * Make a map and return a function for checking if a key
+   * is in that map.
+   */
+  function makeMap(str, expectsLowerCase) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+  }
+  /**
+   * Check if a tag is a built-in tag.
+   */
+  const isBuiltInTag = makeMap('slot,component', true);
+  /**
+   * Check if an attribute is a reserved attribute.
+   */
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  /**
+   * Remove an item from an array.
+   */
+  function remove$1(arr, item) {
+      if (arr.length) {
+          const index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
+      }
+  }
+  /**
+   * Check whether an object has the property.
+   */
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
+  }
+  /**
+   * Create a cached version of a pure function.
+   */
+  function cached(fn) {
+      const cache = Object.create(null);
+      return function cachedFn(str) {
+          const hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
+  }
+  /**
+   * Camelize a hyphen-delimited string.
+   */
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+  });
+  /**
+   * Capitalize a string.
+   */
+  const capitalize = cached((str) => {
+      return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  /**
+   * Hyphenate a camelCase string.
+   */
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
+  });
+  /**
+   * Mix properties into target object.
+   */
+  function extend(to, _from) {
+      for (const key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
+  }
+  /**
+   * Merge an Array of Objects into a single Object.
+   */
+  function toObject(arr) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
+      }
+      return res;
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * Perform no operation.
+   * Stubbing args to make Flow happy without leaving useless transpiled code
+   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+   */
+  function noop$1(a, b, c) { }
+  /**
+   * Always return false.
+   */
+  const no = (a, b, c) => false;
+  /* eslint-enable no-unused-vars */
+  /**
+   * Return the same value.
+   */
+  const identity = (_) => _;
+  /**
+   * Generate a string containing static keys from compiler modules.
+   */
+  function genStaticKeys(modules) {
+      return modules
+          .reduce((keys, m) => {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
+  }
+  /**
+   * Check if two values are loosely equal - that is,
+   * if they are plain objects, do they have the same shape?
+   */
+  function looseEqual(a, b) {
+      if (a === b)
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every((e, i) => {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every((key) => {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
+  }
+  /**
+   * Return the first index at which a loosely equal value can be
+   * found in the array (if value is a plain object, the array must
+   * contain an object of the same shape), or -1 if it is not present.
+   */
+  function looseIndexOf(arr, val) {
+      for (let i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              return i;
+      }
+      return -1;
+  }
+
+  const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap');
+  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+  const isSSRUnsafeAttr = (name) => {
+      return unsafeAttrCharRE.test(name);
+  };
+  /* istanbul ignore next */
+  const isRenderableAttr = (name) => {
+      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+  };
+  const propsToAttrMap = {
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv',
+  };
+  const ESC = {
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;',
+  };
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
+  }
+  function escapeChar(a) {
+      return ESC[a] || a;
+  }
+  const noUnitNumericStyleProps = {
+      'animation-iteration-count': true,
+      'border-image-outset': true,
+      'border-image-slice': true,
+      'border-image-width': true,
+      'box-flex': true,
+      'box-flex-group': true,
+      'box-ordinal-group': true,
+      'column-count': true,
+      columns: true,
+      flex: true,
+      'flex-grow': true,
+      'flex-positive': true,
+      'flex-shrink': true,
+      'flex-negative': true,
+      'flex-order': true,
+      'grid-row': true,
+      'grid-row-end': true,
+      'grid-row-span': true,
+      'grid-row-start': true,
+      'grid-column': true,
+      'grid-column-end': true,
+      'grid-column-span': true,
+      'grid-column-start': true,
+      'font-weight': true,
+      'line-clamp': true,
+      'line-height': true,
+      opacity: true,
+      order: true,
+      orphans: true,
+      'tab-size': true,
+      widows: true,
+      'z-index': true,
+      zoom: true,
+      // SVG
+      'fill-opacity': true,
+      'flood-opacity': true,
+      'stop-opacity': true,
+      'stroke-dasharray': true,
+      'stroke-dashoffset': true,
+      'stroke-miterlimit': true,
+      'stroke-opacity': true,
+      'stroke-width': true,
   };
-  const ESC = {
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      '&': '&amp;',
-  };
-  function escape(s) {
-      return s.replace(/[<>"&]/g, escapeChar);
-  }
-  function escapeChar(a) {
-      return ESC[a] || a;
-  }
-  const noUnitNumericStyleProps = {
-      'animation-iteration-count': true,
-      'border-image-outset': true,
-      'border-image-slice': true,
-      'border-image-width': true,
-      'box-flex': true,
-      'box-flex-group': true,
-      'box-ordinal-group': true,
-      'column-count': true,
-      columns: true,
-      flex: true,
-      'flex-grow': true,
-      'flex-positive': true,
-      'flex-shrink': true,
-      'flex-negative': true,
-      'flex-order': true,
-      'grid-row': true,
-      'grid-row-end': true,
-      'grid-row-span': true,
-      'grid-row-start': true,
-      'grid-column': true,
-      'grid-column-end': true,
-      'grid-column-span': true,
-      'grid-column-start': true,
-      'font-weight': true,
-      'line-clamp': true,
-      'line-height': true,
-      opacity: true,
-      order: true,
-      orphans: true,
-      'tab-size': true,
-      widows: true,
-      'z-index': true,
-      zoom: true,
-      // SVG
-      'fill-opacity': true,
-      'flood-opacity': true,
-      'stop-opacity': true,
-      'stroke-dasharray': true,
-      'stroke-dashoffset': true,
-      'stroke-miterlimit': true,
-      'stroke-opacity': true,
-      'stroke-width': true,
-  };
-
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
-  };
-
-  function renderAttrs$1(node) {
-      let attrs = node.data.attrs;
-      let res = '';
-      const opts = node.parent && node.parent.componentOptions;
-      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-          let parent = node.parent;
-          while (isDef(parent)) {
-              // Stop fallthrough in case parent has inheritAttrs option set to false
-              if (parent.componentOptions &&
-                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
-                  break;
-              }
-              if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                  attrs = extend(extend({}, attrs), parent.data.attrs);
-              }
-              parent = parent.parent;
-          }
-      }
-      if (isUndef(attrs)) {
-          return res;
-      }
-      for (const key in attrs) {
-          if (isSSRUnsafeAttr(key)) {
-              continue;
-          }
-          if (key === 'style') {
-              // leave it to the style module
-              continue;
-          }
-          res += renderAttr(key, attrs[key]);
-      }
-      return res;
-  }
-  function renderAttr(key, value) {
-      if (isBooleanAttr(key)) {
-          if (!isFalsyAttrValue(value)) {
-              return ` ${key}="${key}"`;
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
-      }
-      else if (!isFalsyAttrValue(value)) {
-          return ` ${key}="${escape(String(value))}"`;
-      }
-      return '';
-  }
-
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
-  }
 
-  function renderDOMProps$1(node) {
-      let props = node.data.domProps;
-      let res = '';
-      let parent = node.parent;
-      while (isDef(parent)) {
-          if (parent.data && parent.data.domProps) {
-              props = extend(extend({}, props), parent.data.domProps);
-          }
-          parent = parent.parent;
-      }
-      if (isUndef(props)) {
-          return res;
-      }
-      const attrs = node.data.attrs;
-      for (const key in props) {
-          if (key === 'innerHTML') {
-              setText(node, props[key], true);
-          }
-          else if (key === 'textContent') {
-              setText(node, props[key], false);
-          }
-          else if (key === 'value' && node.tag === 'textarea') {
-              setText(node, toString(props[key]), false);
-          }
-          else {
-              // $flow-disable-line (WTF?)
-              const attr = propsToAttrMap[key] || key.toLowerCase();
-              if (isRenderableAttr(attr) &&
-                  // avoid rendering double-bound props/attrs twice
-                  !(isDef(attrs) && isDef(attrs[attr]))) {
-                  res += renderAttr(attr, props[key]);
-              }
-          }
-      }
-      return res;
-  }
-  function setText(node, text, raw) {
-      const child = new VNode(undefined, undefined, undefined, text);
-      child.raw = raw;
-      node.children = [child];
-  }
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  makeMap('style,class');
+  // attributes that should be using props for binding
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
+  };
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
+  };
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+  const isFalsyAttrValue = (val) => {
+      return val == null || val === false;
   };
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
-  }
 
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
+  function renderAttrs$1(node) {
+      let attrs = node.data.attrs;
+      let res = '';
+      const opts = node.parent && node.parent.componentOptions;
+      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+          let parent = node.parent;
+          while (isDef(parent)) {
+              // Stop fallthrough in case parent has inheritAttrs option set to false
+              if (parent.componentOptions &&
+                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                  break;
+              }
+              if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                  attrs = extend(extend({}, attrs), parent.data.attrs);
+              }
+              parent = parent.parent;
+          }
+      }
+      if (isUndef(attrs)) {
+          return res;
+      }
+      for (const key in attrs) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          if (key === 'style') {
+              // leave it to the style module
+              continue;
+          }
+          res += renderAttr(key, attrs[key]);
+      }
+      return res;
+  }
+  function renderAttr(key, value) {
+      if (isBooleanAttr(key)) {
+          if (!isFalsyAttrValue(value)) {
+              return ` ${key}="${key}"`;
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
+      }
+      else if (!isFalsyAttrValue(value)) {
+          return ` ${key}="${escape(String(value))}"`;
+      }
+      return '';
+  }
+
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
+  };
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
+  }
+  // optimized shallow clone
+  // used for static nodes and slot nodes because they may be reused across
+  // multiple renders, cloning them avoids errors when DOM manipulations rely
+  // on their elm reference.
+  function cloneVNode(vnode) {
+      const cloned = new VNode(vnode.tag, vnode.data, 
+      // #7975
+      // clone children array to avoid mutating original in case of cloning
+      // a child.
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
+  }
+
+  function renderDOMProps$1(node) {
+      let props = node.data.domProps;
+      let res = '';
+      let parent = node.parent;
+      while (isDef(parent)) {
+          if (parent.data && parent.data.domProps) {
+              props = extend(extend({}, props), parent.data.domProps);
+          }
+          parent = parent.parent;
+      }
+      if (isUndef(props)) {
+          return res;
+      }
+      const attrs = node.data.attrs;
+      for (const key in props) {
+          if (key === 'innerHTML') {
+              setText(node, props[key], true);
+          }
+          else if (key === 'textContent') {
+              setText(node, props[key], false);
+          }
+          else if (key === 'value' && node.tag === 'textarea') {
+              setText(node, toString(props[key]), false);
+          }
+          else {
+              // $flow-disable-line (WTF?)
+              const attr = propsToAttrMap[key] || key.toLowerCase();
+              if (isRenderableAttr(attr) &&
+                  // avoid rendering double-bound props/attrs twice
+                  !(isDef(attrs) && isDef(attrs[attr]))) {
+                  res += renderAttr(attr, props[key]);
+              }
+          }
+      }
+      return res;
+  }
+  function setText(node, text, raw) {
+      const child = new VNode(undefined, undefined, undefined, text);
+      child.raw = raw;
+      node.children = [child];
+  }
+
+  /**
+   * unicode letters used for parsing html tags, component names and property paths.
+   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+   */
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+  /**
+   * Define a property.
+   */
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
+  }
+
+  // can we use __proto__?
+  const hasProto = '__proto__' in {};
+  // Browser environment sniffing
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  UA && UA.match(/firefox\/(\d+)/);
+  // Firefox has a "watch" function on Object.prototype...
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
+  if (inBrowser) {
+      try {
+          const opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
+  }
+  // this needs to be lazy-evaled because vue may be required before
+  // vue-server-renderer can set VUE_ENV
+  let _isServer;
+  const isServerRendering = () => {
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
+  };
+  /* istanbul ignore next */
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  const hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  let _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
+              return this.set[key] === true;
+          }
+          add(key) {
+              this.set[key] = true;
+          }
+          clear() {
+              this.set = Object.create(null);
+          }
+      };
+  }
+
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch',
   ];
 
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop$1,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop$1,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  let warn$2 = noop$1;
-  let tip = noop$1;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn$2 = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
-  }
-
-  let uid = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$1(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
-  });
-
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn$2(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn$2('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
+  let warn$2 = noop$1;
+  let tip = noop$1;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
+  {
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn$2 = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
+          if (hasConsole && !config.silent) {
+              console.error(`[Vue warn]: ${msg}${trace}`);
+          }
+      };
+      tip = (msg, vm) => {
+          if (hasConsole && !config.silent) {
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = (vm, includeFile) => {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
+              : vm._isVue
+                  ? vm.$options || vm.constructor.options
+                  : vm;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
+          if (!name && file) {
+              const match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
+      };
+      const repeat = (str, n) => {
+          let res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  res += str;
+              if (n > 1)
+                  str += str;
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = (vm) => {
+          if (vm._isVue && vm.$parent) {
+              const tree = [];
+              let currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      const last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                      .join('\n'));
+          }
+          else {
+              return `\n\n(found in ${formatComponentName(vm)})`;
+          }
+      };
+  }
+
+  let uid = 0;
+  /**
+   * A dep is an observable that can have multiple
+   * directives subscribing to it.
+   */
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid++;
+          this.subs = [];
+      }
+      addSub(sub) {
+          this.subs.push(sub);
+      }
+      removeSub(sub) {
+          remove$1(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
+  // The current target watcher being evaluated.
+  // This is globally unique because only one watcher
+  // can be evaluated at a time.
+  Dep.target = null;
+  const targetStack = [];
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
+  }
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
+  }
+
+  /*
+   * not type checking this file because flow doesn't play well with
+   * dynamically accessing methods on Array prototype
+   */
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse',
+  ];
+  /**
+   * Intercept mutating methods and emit events
+   */
+  methodsToPatch.forEach(function (method) {
+      // cache original method
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              ob.observeArray(inserted);
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
   });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn$2('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn$2('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn$2('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn$2(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
-  }
-
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn$2('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn$2('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
-  }
-
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          // @ts-expect-error should it be any?
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
-  }
 
-  /* globals MutationObserver */
-  const callbacks = [];
-  function flushCallbacks() {
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      Promise.resolve();
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+  /**
+   * In some cases we may want to disable observation inside a component's
+   * update computation.
+   */
+  let shouldObserve = true;
+  function toggleObserving(value) {
+      shouldObserve = value;
+  }
+  /**
+   * Observer class that is attached to each observed
+   * object. Once attached, the observer converts the target
+   * object's property keys into getter/setters that
+   * collect dependencies and dispatch updates.
+   */
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
+          }
+          else {
+              this.walk(value);
+          }
+      }
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      }
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      }
+  }
+  // helpers
+  /**
+   * Augment a target Object or Array by intercepting
+   * the prototype chain using __proto__
+   */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
+  }
+  /**
+   * Augment a target Object or Array by defining
+   * hidden properties.
+   */
+  /* istanbul ignore next */
+  function copyAugment(target, src, keys) {
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
+          def(target, key, src[key]);
+      }
+  }
+  /**
+   * Attempt to create an observer instance for a value,
+   * returns the new observer if successfully observed,
+   * or the existing observer if the value already has one.
+   */
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      let ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
+  }
+  /**
+   * Define a reactive property on an Object.
+   */
+  function defineReactive(obj, key, val, customSetter, shallow) {
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      const getter = property && property.get;
+      const setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      let childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              const value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              const value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  return;
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
+  }
+  /**
+   * Set a property on an object. Adds the new property and
+   * triggers change notification if the property doesn't
+   * already exist.
+   */
+  function set(target, key, val) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive(ob.value, key, val);
+      ob.dep.notify();
+      return val;
+  }
+  /**
+   * Collect dependencies on array elements when the array is touched, since
+   * we cannot intercept array element access like property getters.
+   */
+  function dependArray(value) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
+      }
+  }
+
+  /**
+   * Option overwriting strategies are functions that handle
+   * how to merge a parent option value and a child option
+   * value into the final value.
+   */
+  const strats = config.optionMergeStrategies;
+  /**
+   * Options with restrictions
+   */
+  {
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn$2(`option "${key}" can only be used during instance ` +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
+  }
+  /**
+   * Helper that recursively merges two data objects together.
+   */
+  function mergeData(to, from) {
+      if (!from)
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (let i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              continue;
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
+  }
+  /**
+   * Data
+   */
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn$2('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
+  };
+  /**
+   * Hooks and props are merged as arrays.
+   */
+  function mergeHook$1(parentVal, childVal) {
+      const res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
+  }
+  LIFECYCLE_HOOKS.forEach((hook) => {
+      strats[hook] = mergeHook$1;
+  });
+  /**
+   * Assets
+   *
+   * When a vm is present (instance creation), we need to do
+   * a three-way merge between constructor options, instance
+   * options and parent options.
+   */
+  function mergeAssets(parentVal, childVal, vm, key) {
+      const res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
+  }
+  ASSET_TYPES.forEach(function (type) {
+      strats[type + 's'] = mergeAssets;
+  });
+  /**
+   * Watchers.
+   *
+   * Watchers hashes should not overwrite one
+   * another, so we merge them as arrays.
+   */
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          parentVal = undefined;
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          childVal = undefined;
+      /* istanbul ignore if */
+      if (!childVal)
+          return Object.create(parentVal || null);
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = {};
+      extend(ret, parentVal);
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
+  };
+  /**
+   * Other object hashes.
+   */
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          extend(ret, childVal);
+      return ret;
+  };
+  strats.provide = mergeDataOrFn;
+  /**
+   * Default strategy.
+   */
+  const defaultStrat = function (parentVal, childVal) {
+      return childVal === undefined ? parentVal : childVal;
+  };
+  /**
+   * Validate component names
+   */
+  function checkComponents(options) {
+      for (const key in options.components) {
+          validateComponentName(key);
+      }
+  }
+  function validateComponentName(name) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+          warn$2('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn$2('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
+  }
+  /**
+   * Ensure all props option syntax are normalized into the
+   * Object-based format.
+   */
+  function normalizeProps(options, vm) {
+      const props = options.props;
+      if (!props)
+          return;
+      const res = {};
+      let i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn$2('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (const key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
+      }
+      options.props = res;
+  }
+  /**
+   * Normalize all injections into Object-based format
+   */
+  function normalizeInject(options, vm) {
+      const inject = options.inject;
+      if (!inject)
+          return;
+      const normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (let i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (const key in inject) {
+              const val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
+      }
+  }
+  /**
+   * Normalize raw function directives into object format.
+   */
+  function normalizeDirectives(options) {
+      const dirs = options.directives;
+      if (dirs) {
+          for (const key in dirs) {
+              const def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn$2(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
+      }
+  }
+  /**
+   * Merge two option objects into a new one.
+   * Core utility used in both instantiation and inheritance.
+   */
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      const options = {};
+      let key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          const strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
+  }
+  /**
+   * Resolve an asset.
+   * This function is used because child instances need access
+   * to assets defined in its ancestor chain.
+   */
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      const assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          return assets[id];
+      const camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          return assets[PascalCaseId];
+      // fallback to prototype chain
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
+  }
+
+  function validateProp(key, propOptions, propsData, vm) {
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
+      // boolean casting
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              const stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          const prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
+  }
+  /**
+   * Get the default value of a prop.
+   */
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      const def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn$2('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
+  }
+  /**
+   * Assert whether a prop is valid.
+   */
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn$2('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      const haveExpectedTypes = expectedTypes.some((t) => t);
+      if (!valid && haveExpectedTypes) {
+          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      const validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
+  }
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      let valid;
+      const expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          const t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid,
+          expectedType,
+      };
+  }
+  const functionTypeCheckRE = /^\s*function (\w+)/;
+  /**
+   * Use function string name to check built-in types,
+   * because a simple equality check will fail when running
+   * across different vms / iframes.
+   */
+  function getType(fn) {
+      const match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
+          }
+      }
+      return -1;
+  }
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += ` with value ${styleValue(value, expectedType)}`;
+      }
+      message += `, got ${receivedType} `;
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += `with value ${styleValue(value, receivedType)}.`;
+      }
+      return message;
+  }
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return `"${value}"`;
+      }
+      else if (type === 'Number') {
+          return `${Number(value)}`;
+      }
+      else {
+          return `${value}`;
+      }
+  }
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
+  }
+
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              let cur = vm;
+              while ((cur = cur.$parent)) {
+                  const hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (let i = 0; i < hooks.length; i++) {
+                          try {
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  return;
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      let res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
+  }
+
+  /* globals MutationObserver */
+  const callbacks = [];
+  function flushCallbacks() {
+      const copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (let i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
+  }
+  // The nextTick behavior leverages the microtask queue, which can be accessed
+  // via either native Promise.then or MutationObserver.
+  // MutationObserver has wider support, however it is seriously bugged in
+  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+  // completely stops working after triggering a few times... so, if native
+  // Promise is available, we will use it:
+  /* istanbul ignore next, $flow-disable-line */
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+      Promise.resolve();
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
   else ;
 
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass$1(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass$1(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
-  }
-
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isPreTag = (tag) => tag === 'pre';
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
+  function genClassForVnode(vnode) {
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass$1(data.staticClass, data.class);
+  }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
+  }
+  function renderClass$1(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
+  }
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function stringifyArray(value) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  res += ' ';
+              res += stringified;
+          }
+      }
+      return res;
+  }
+  function stringifyObject(value) {
+      let res = '';
+      for (const key in value) {
+          if (value[key]) {
+              if (res)
+                  res += ' ';
+              res += key;
+          }
+      }
+      return res;
+  }
+
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
+  // this map is intentionally selective, only covering SVG elements that may
+  // contain child elements.
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  const isPreTag = (tag) => tag === 'pre';
+  const isReservedTag = (tag) => {
+      return isHTMLTag(tag) || isSVG(tag);
+  };
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
+  }
   makeMap('text,number,password,search,email,tel,url');
 
-  function renderClass(node) {
-      const classList = genClassForVnode(node);
-      if (classList !== '') {
-          return ` class="${escape(classList)}"`;
-      }
-  }
-
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
-  }
-
-  function genStyle(style) {
-      let styleText = '';
-      for (const key in style) {
-          const value = style[key];
-          const hyphenatedKey = hyphenate(key);
-          if (Array.isArray(value)) {
-              for (let i = 0, len = value.length; i < len; i++) {
-                  styleText += normalizeValue(hyphenatedKey, value[i]);
-              }
-          }
-          else {
-              styleText += normalizeValue(hyphenatedKey, value);
-          }
-      }
-      return styleText;
-  }
-  function normalizeValue(key, value) {
-      if (typeof value === 'string' ||
-          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-          value === 0) {
-          return `${key}:${value};`;
-      }
-      else {
-          // invalid values
-          return ``;
-      }
-  }
-  function renderStyle(vnode) {
-      const styleText = genStyle(getStyle(vnode, false));
-      if (styleText !== '') {
-          return ` style=${JSON.stringify(escape(styleText))}`;
-      }
+  function renderClass(node) {
+      const classList = genClassForVnode(node);
+      if (classList !== '') {
+          return ` class="${escape(classList)}"`;
+      }
+  }
+
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              const tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
+  });
+  // merge static and dynamic style data on the same vnode
+  function normalizeStyleData(data) {
+      const style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
+  }
+  // normalize possible array / string values into Object
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
+  }
+  /**
+   * parent component style should be after child's
+   * so that parent component's style could override it
+   */
+  function getStyle(vnode, checkChild) {
+      const res = {};
+      let styleData;
+      if (checkChild) {
+          let childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
+          extend(res, styleData);
+      }
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
+      }
+      return res;
+  }
+
+  function genStyle(style) {
+      let styleText = '';
+      for (const key in style) {
+          const value = style[key];
+          const hyphenatedKey = hyphenate(key);
+          if (Array.isArray(value)) {
+              for (let i = 0, len = value.length; i < len; i++) {
+                  styleText += normalizeValue(hyphenatedKey, value[i]);
+              }
+          }
+          else {
+              styleText += normalizeValue(hyphenatedKey, value);
+          }
+      }
+      return styleText;
+  }
+  function normalizeValue(key, value) {
+      if (typeof value === 'string' ||
+          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+          value === 0) {
+          return `${key}:${value};`;
+      }
+      else {
+          // invalid values
+          return ``;
+      }
+  }
+  function renderStyle(vnode) {
+      const styleText = genStyle(getStyle(vnode, false));
+      if (styleText !== '') {
+          return ` style=${JSON.stringify(escape(styleText))}`;
+      }
   }
 
   var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-  function show(node, dir) {
-      if (!dir.value) {
-          const style = node.data.style || (node.data.style = {});
-          if (Array.isArray(style)) {
-              style.push({ display: 'none' });
-          }
-          else {
-              style.display = 'none';
-          }
-      }
-  }
-
-  // this is only applied for <select v-model> because it is the only edge case
-  // that must be done at runtime instead of compile time.
-  function model$2(node, dir) {
-      if (!node.children)
-          return;
-      const value = dir.value;
-      const isMultiple = node.data.attrs && node.data.attrs.multiple;
-      for (let i = 0, l = node.children.length; i < l; i++) {
-          const option = node.children[i];
-          if (option.tag === 'option') {
-              if (isMultiple) {
-                  const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
-                  if (selected) {
-                      setSelected(option);
-                  }
-              }
-              else {
-                  if (looseEqual(value, getValue(option))) {
-                      setSelected(option);
-                      return;
-                  }
-              }
-          }
-      }
-  }
-  function getValue(option) {
-      const data = option.data || {};
-      return ((data.attrs && data.attrs.value) ||
-          (data.domProps && data.domProps.value) ||
-          (option.children && option.children[0] && option.children[0].text));
-  }
-  function setSelected(option) {
-      const data = option.data || (option.data = {});
-      const attrs = data.attrs || (data.attrs = {});
-      attrs.selected = '';
-  }
-
-  var directives$1 = {
-      show,
-      model: model$2,
+  function show(node, dir) {
+      if (!dir.value) {
+          const style = node.data.style || (node.data.style = {});
+          if (Array.isArray(style)) {
+              style.push({ display: 'none' });
+          }
+          else {
+              style.display = 'none';
+          }
+      }
+  }
+
+  // this is only applied for <select v-model> because it is the only edge case
+  // that must be done at runtime instead of compile time.
+  function model$2(node, dir) {
+      if (!node.children)
+          return;
+      const value = dir.value;
+      const isMultiple = node.data.attrs && node.data.attrs.multiple;
+      for (let i = 0, l = node.children.length; i < l; i++) {
+          const option = node.children[i];
+          if (option.tag === 'option') {
+              if (isMultiple) {
+                  const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                  if (selected) {
+                      setSelected(option);
+                  }
+              }
+              else {
+                  if (looseEqual(value, getValue(option))) {
+                      setSelected(option);
+                      return;
+                  }
+              }
+          }
+      }
+  }
+  function getValue(option) {
+      const data = option.data || {};
+      return ((data.attrs && data.attrs.value) ||
+          (data.domProps && data.domProps.value) ||
+          (option.children && option.children[0] && option.children[0].text));
+  }
+  function setSelected(option) {
+      const data = option.data || (option.data = {});
+      const attrs = data.attrs || (data.attrs = {});
+      attrs.selected = '';
+  }
+
+  var directives$1 = {
+      show,
+      model: model$2,
   };
 
-  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr');
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
       'title,tr,track');
 
-  const MAX_STACK_DEPTH = 800;
-  const noop = (_) => _;
-  const defer = typeof process !== 'undefined' && process.nextTick
-      ? process.nextTick
-      : typeof Promise !== 'undefined'
-          ? (fn) => Promise.resolve().then(fn)
-          : typeof setTimeout !== 'undefined'
-              ? setTimeout
-              : noop;
-  if (defer === noop) {
-      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
-          'that are required by vue-server-renderer. Please use a polyfill for ' +
-          'either Promise or setTimeout.');
-  }
-  function createWriteFunction(write, onError) {
-      let stackDepth = 0;
-      const cachedWrite = (text, next) => {
-          if (text && cachedWrite.caching) {
-              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-          }
-          const waitForNext = write(text, next);
-          if (waitForNext !== true) {
-              if (stackDepth >= MAX_STACK_DEPTH) {
-                  defer(() => {
-                      try {
-                          next();
-                      }
-                      catch (e) {
-                          onError(e);
-                      }
-                  });
-              }
-              else {
-                  stackDepth++;
-                  next();
-                  stackDepth--;
-              }
-          }
-      };
-      cachedWrite.caching = false;
-      cachedWrite.cacheBuffer = [];
-      cachedWrite.componentBuffer = [];
-      return cachedWrite;
-  }
-
-  class RenderContext {
-      userContext;
-      activeInstance;
-      renderStates;
-      write;
-      renderNode;
-      //@ts-expect-error
-      next;
-      done;
-      modules;
-      directives;
-      isUnaryTag;
-      cache;
-      get;
-      has;
-      constructor(options) {
-          this.userContext = options.userContext;
-          this.activeInstance = options.activeInstance;
-          this.renderStates = [];
-          this.write = options.write;
-          this.done = options.done;
-          this.renderNode = options.renderNode;
-          this.isUnaryTag = options.isUnaryTag;
-          this.modules = options.modules;
-          this.directives = options.directives;
-          const cache = options.cache;
-          if (cache && (!cache.get || !cache.set)) {
-              throw new Error('renderer cache must implement at least get & set.');
-          }
-          this.cache = cache;
-          this.get = cache && normalizeAsync(cache, 'get');
-          this.has = cache && normalizeAsync(cache, 'has');
-          //@ts-expect-error
-          this.next = this.next.bind(this);
-      }
-      //@ts-expect-error
-      next() {
-          // eslint-disable-next-line
-          while (true) {
-              const lastState = this.renderStates[this.renderStates.length - 1];
-              if (isUndef(lastState)) {
-                  return this.done();
-              }
-              /* eslint-disable no-case-declarations */
-              switch (lastState.type) {
-                  case 'Element':
-                  case 'Fragment':
-                      const { children, total } = lastState;
-                      const rendered = lastState.rendered++;
-                      if (rendered < total) {
-                          return this.renderNode(children[rendered], false, this);
-                      }
-                      else {
-                          this.renderStates.pop();
-                          if (lastState.type === 'Element') {
-                              return this.write(lastState.endTag, this.next);
-                          }
-                      }
-                      break;
-                  case 'Component':
-                      this.renderStates.pop();
-                      this.activeInstance = lastState.prevActive;
-                      break;
-                  case 'ComponentWithCache':
-                      this.renderStates.pop();
-                      const { buffer, bufferIndex, componentBuffer, key } = lastState;
-                      const result = {
-                          html: buffer[bufferIndex],
-                          components: componentBuffer[bufferIndex],
-                      };
-                      this.cache.set(key, result);
-                      if (bufferIndex === 0) {
-                          // this is a top-level cached component,
-                          // exit caching mode.
-                          //@ts-expect-error
-                          this.write.caching = false;
-                      }
-                      else {
-                          // parent component is also being cached,
-                          // merge self into parent's result
-                          buffer[bufferIndex - 1] += result.html;
-                          const prev = componentBuffer[bufferIndex - 1];
-                          result.components.forEach((c) => prev.add(c));
-                      }
-                      buffer.length = bufferIndex;
-                      componentBuffer.length = bufferIndex;
-                      break;
-              }
-          }
-      }
-  }
-  function normalizeAsync(cache, method) {
-      const fn = cache[method];
-      if (isUndef(fn)) {
-          return;
-      }
-      else if (fn.length > 1) {
-          return (key, cb) => fn.call(cache, key, cb);
-      }
-      else {
-          return (key, cb) => cb(fn.call(cache, key));
-      }
-  }
-
-  const validDivisionCharRE = /[\w).+\-_$\]]/;
-  function parseFilters(exp) {
-      let inSingle = false;
-      let inDouble = false;
-      let inTemplateString = false;
-      let inRegex = false;
-      let curly = 0;
-      let square = 0;
-      let paren = 0;
-      let lastFilterIndex = 0;
-      let c, prev, i, expression, filters;
-      for (i = 0; i < exp.length; i++) {
-          prev = c;
-          c = exp.charCodeAt(i);
-          if (inSingle) {
-              if (c === 0x27 && prev !== 0x5c)
-                  inSingle = false;
-          }
-          else if (inDouble) {
-              if (c === 0x22 && prev !== 0x5c)
-                  inDouble = false;
-          }
-          else if (inTemplateString) {
-              if (c === 0x60 && prev !== 0x5c)
-                  inTemplateString = false;
-          }
-          else if (inRegex) {
-              if (c === 0x2f && prev !== 0x5c)
-                  inRegex = false;
-          }
-          else if (c === 0x7c && // pipe
-              exp.charCodeAt(i + 1) !== 0x7c &&
-              exp.charCodeAt(i - 1) !== 0x7c &&
-              !curly &&
-              !square &&
-              !paren) {
-              if (expression === undefined) {
-                  // first filter, end of expression
-                  lastFilterIndex = i + 1;
-                  expression = exp.slice(0, i).trim();
-              }
-              else {
-                  pushFilter();
-              }
-          }
-          else {
-              switch (c) {
-                  case 0x22:
-                      inDouble = true;
-                      break; // "
-                  case 0x27:
-                      inSingle = true;
-                      break; // '
-                  case 0x60:
-                      inTemplateString = true;
-                      break; // `
-                  case 0x28:
-                      paren++;
-                      break; // (
-                  case 0x29:
-                      paren--;
-                      break; // )
-                  case 0x5b:
-                      square++;
-                      break; // [
-                  case 0x5d:
-                      square--;
-                      break; // ]
-                  case 0x7b:
-                      curly++;
-                      break; // {
-                  case 0x7d:
-                      curly--;
-                      break; // }
-              }
-              if (c === 0x2f) {
-                  // /
-                  let j = i - 1;
-                  let p;
-                  // find first non-whitespace prev char
-                  for (; j >= 0; j--) {
-                      p = exp.charAt(j);
-                      if (p !== ' ')
-                          break;
-                  }
-                  if (!p || !validDivisionCharRE.test(p)) {
-                      inRegex = true;
-                  }
-              }
-          }
-      }
-      if (expression === undefined) {
-          expression = exp.slice(0, i).trim();
-      }
-      else if (lastFilterIndex !== 0) {
-          pushFilter();
-      }
-      function pushFilter() {
-          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-          lastFilterIndex = i + 1;
-      }
-      if (filters) {
-          for (i = 0; i < filters.length; i++) {
-              expression = wrapFilter(expression, filters[i]);
-          }
-      }
-      return expression;
-  }
-  function wrapFilter(exp, filter) {
-      const i = filter.indexOf('(');
-      if (i < 0) {
-          // _f: resolveFilter
-          return `_f("${filter}")(${exp})`;
-      }
-      else {
-          const name = filter.slice(0, i);
-          const args = filter.slice(i + 1);
-          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-      }
-  }
-
-  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  const buildRegex = cached((delimiters) => {
-      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-  });
-  function parseText(text, delimiters) {
-      //@ts-expect-error
-      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-      if (!tagRE.test(text)) {
-          return;
-      }
-      const tokens = [];
-      const rawTokens = [];
-      let lastIndex = (tagRE.lastIndex = 0);
-      let match, index, tokenValue;
-      while ((match = tagRE.exec(text))) {
-          index = match.index;
-          // push text token
-          if (index > lastIndex) {
-              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-              tokens.push(JSON.stringify(tokenValue));
-          }
-          // tag token
-          const exp = parseFilters(match[1].trim());
-          tokens.push(`_s(${exp})`);
-          rawTokens.push({ '@binding': exp });
-          lastIndex = index + match[0].length;
-      }
-      if (lastIndex < text.length) {
-          rawTokens.push((tokenValue = text.slice(lastIndex)));
-          tokens.push(JSON.stringify(tokenValue));
-      }
-      return {
-          expression: tokens.join('+'),
-          tokens: rawTokens,
-      };
-  }
-
-  /* eslint-disable no-unused-vars */
-  function baseWarn(msg, range) {
-      console.error(`[Vue compiler]: ${msg}`);
-  }
-  /* eslint-enable no-unused-vars */
-  function pluckModuleFunction(modules, key) {
-      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-  }
-  function addProp(el, name, value, range, dynamic) {
-      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  function addAttr(el, name, value, range, dynamic) {
-      const attrs = dynamic
-          ? el.dynamicAttrs || (el.dynamicAttrs = [])
-          : el.attrs || (el.attrs = []);
-      attrs.push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr(el, name, value, range) {
-      el.attrsMap[name] = value;
-      el.attrsList.push(rangeSetItem({ name, value }, range));
-  }
-  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-      (el.directives || (el.directives = [])).push(rangeSetItem({
-          name,
-          rawName,
-          value,
-          arg,
-          isDynamicArg,
-          modifiers,
-      }, range));
-      el.plain = false;
-  }
-  function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-  }
-  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-      modifiers = modifiers || emptyObject;
-      // warn prevent and passive modifier
-      /* istanbul ignore if */
-      if (warn &&
-          modifiers.prevent &&
-          modifiers.passive) {
-          warn("passive and prevent can't be used together. " +
-              "Passive handler can't prevent default event.", range);
-      }
-      // normalize click.right and click.middle since they don't actually fire
-      // this is technically browser-specific, but at least for now browsers are
-      // the only target envs that have right/middle clicks.
-      if (modifiers.right) {
-          if (dynamic) {
-              name = `(${name})==='click'?'contextmenu':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'contextmenu';
-              delete modifiers.right;
-          }
-      }
-      else if (modifiers.middle) {
-          if (dynamic) {
-              name = `(${name})==='click'?'mouseup':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'mouseup';
-          }
-      }
-      // check capture modifier
-      if (modifiers.capture) {
-          delete modifiers.capture;
-          name = prependModifierMarker('!', name, dynamic);
-      }
-      if (modifiers.once) {
-          delete modifiers.once;
-          name = prependModifierMarker('~', name, dynamic);
-      }
-      /* istanbul ignore if */
-      if (modifiers.passive) {
-          delete modifiers.passive;
-          name = prependModifierMarker('&', name, dynamic);
-      }
-      let events;
-      if (modifiers.native) {
-          delete modifiers.native;
-          events = el.nativeEvents || (el.nativeEvents = {});
-      }
-      else {
-          events = el.events || (el.events = {});
-      }
-      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-      if (modifiers !== emptyObject) {
-          newHandler.modifiers = modifiers;
-      }
-      const handlers = events[name];
-      /* istanbul ignore if */
-      if (Array.isArray(handlers)) {
-          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-      }
-      else if (handlers) {
-          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-      }
-      else {
-          events[name] = newHandler;
-      }
-      el.plain = false;
-  }
-  function getRawBindingAttr(el, name) {
-      return (el.rawAttrsMap[':' + name] ||
-          el.rawAttrsMap['v-bind:' + name] ||
-          el.rawAttrsMap[name]);
-  }
-  function getBindingAttr(el, name, getStatic) {
-      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-      if (dynamicValue != null) {
-          return parseFilters(dynamicValue);
-      }
-      else if (getStatic !== false) {
-          const staticValue = getAndRemoveAttr(el, name);
-          if (staticValue != null) {
-              return JSON.stringify(staticValue);
-          }
-      }
-  }
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr(el, name, removeFromMap) {
-      let val;
-      if ((val = el.attrsMap[name]) != null) {
-          const list = el.attrsList;
-          for (let i = 0, l = list.length; i < l; i++) {
-              if (list[i].name === name) {
-                  list.splice(i, 1);
-                  break;
-              }
-          }
-      }
-      if (removeFromMap) {
-          delete el.attrsMap[name];
-      }
-      return val;
-  }
-  function getAndRemoveAttrByRegex(el, name) {
-      const list = el.attrsList;
-      for (let i = 0, l = list.length; i < l; i++) {
-          const attr = list[i];
-          if (name.test(attr.name)) {
-              list.splice(i, 1);
-              return attr;
-          }
-      }
-  }
-  function rangeSetItem(item, range) {
-      if (range) {
-          if (range.start != null) {
-              item.start = range.start;
-          }
-          if (range.end != null) {
-              item.end = range.end;
-          }
-      }
-      return item;
-  }
-
-  function transformNode$1(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticClass = getAndRemoveAttr(el, 'class');
-      if (staticClass) {
-          const res = parseText(staticClass, options.delimiters);
-          if (res) {
-              warn(`class="${staticClass}": ` +
-                  'Interpolation inside attributes has been removed. ' +
-                  'Use v-bind or the colon shorthand instead. For example, ' +
-                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-          }
-      }
-      if (staticClass) {
-          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-      }
-      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-      if (classBinding) {
-          el.classBinding = classBinding;
-      }
-  }
-  function genData$2(el) {
-      let data = '';
-      if (el.staticClass) {
-          data += `staticClass:${el.staticClass},`;
-      }
-      if (el.classBinding) {
-          data += `class:${el.classBinding},`;
-      }
-      return data;
-  }
-  var klass = {
-      staticKeys: ['staticClass'],
-      transformNode: transformNode$1,
-      genData: genData$2,
+  const MAX_STACK_DEPTH = 800;
+  const noop = (_) => _;
+  const defer = typeof process !== 'undefined' && process.nextTick
+      ? process.nextTick
+      : typeof Promise !== 'undefined'
+          ? (fn) => Promise.resolve().then(fn)
+          : typeof setTimeout !== 'undefined'
+              ? setTimeout
+              : noop;
+  if (defer === noop) {
+      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+          'that are required by vue-server-renderer. Please use a polyfill for ' +
+          'either Promise or setTimeout.');
+  }
+  function createWriteFunction(write, onError) {
+      let stackDepth = 0;
+      const cachedWrite = (text, next) => {
+          if (text && cachedWrite.caching) {
+              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+          }
+          const waitForNext = write(text, next);
+          if (waitForNext !== true) {
+              if (stackDepth >= MAX_STACK_DEPTH) {
+                  defer(() => {
+                      try {
+                          next();
+                      }
+                      catch (e) {
+                          onError(e);
+                      }
+                  });
+              }
+              else {
+                  stackDepth++;
+                  next();
+                  stackDepth--;
+              }
+          }
+      };
+      cachedWrite.caching = false;
+      cachedWrite.cacheBuffer = [];
+      cachedWrite.componentBuffer = [];
+      return cachedWrite;
+  }
+
+  class RenderContext {
+      userContext;
+      activeInstance;
+      renderStates;
+      write;
+      renderNode;
+      //@ts-expect-error
+      next;
+      done;
+      modules;
+      directives;
+      isUnaryTag;
+      cache;
+      get;
+      has;
+      constructor(options) {
+          this.userContext = options.userContext;
+          this.activeInstance = options.activeInstance;
+          this.renderStates = [];
+          this.write = options.write;
+          this.done = options.done;
+          this.renderNode = options.renderNode;
+          this.isUnaryTag = options.isUnaryTag;
+          this.modules = options.modules;
+          this.directives = options.directives;
+          const cache = options.cache;
+          if (cache && (!cache.get || !cache.set)) {
+              throw new Error('renderer cache must implement at least get & set.');
+          }
+          this.cache = cache;
+          this.get = cache && normalizeAsync(cache, 'get');
+          this.has = cache && normalizeAsync(cache, 'has');
+          //@ts-expect-error
+          this.next = this.next.bind(this);
+      }
+      //@ts-expect-error
+      next() {
+          // eslint-disable-next-line
+          while (true) {
+              const lastState = this.renderStates[this.renderStates.length - 1];
+              if (isUndef(lastState)) {
+                  return this.done();
+              }
+              /* eslint-disable no-case-declarations */
+              switch (lastState.type) {
+                  case 'Element':
+                  case 'Fragment':
+                      const { children, total } = lastState;
+                      const rendered = lastState.rendered++;
+                      if (rendered < total) {
+                          return this.renderNode(children[rendered], false, this);
+                      }
+                      else {
+                          this.renderStates.pop();
+                          if (lastState.type === 'Element') {
+                              return this.write(lastState.endTag, this.next);
+                          }
+                      }
+                      break;
+                  case 'Component':
+                      this.renderStates.pop();
+                      this.activeInstance = lastState.prevActive;
+                      break;
+                  case 'ComponentWithCache':
+                      this.renderStates.pop();
+                      const { buffer, bufferIndex, componentBuffer, key } = lastState;
+                      const result = {
+                          html: buffer[bufferIndex],
+                          components: componentBuffer[bufferIndex],
+                      };
+                      this.cache.set(key, result);
+                      if (bufferIndex === 0) {
+                          // this is a top-level cached component,
+                          // exit caching mode.
+                          //@ts-expect-error
+                          this.write.caching = false;
+                      }
+                      else {
+                          // parent component is also being cached,
+                          // merge self into parent's result
+                          buffer[bufferIndex - 1] += result.html;
+                          const prev = componentBuffer[bufferIndex - 1];
+                          result.components.forEach((c) => prev.add(c));
+                      }
+                      buffer.length = bufferIndex;
+                      componentBuffer.length = bufferIndex;
+                      break;
+              }
+          }
+      }
+  }
+  function normalizeAsync(cache, method) {
+      const fn = cache[method];
+      if (isUndef(fn)) {
+          return;
+      }
+      else if (fn.length > 1) {
+          return (key, cb) => fn.call(cache, key, cb);
+      }
+      else {
+          return (key, cb) => cb(fn.call(cache, key));
+      }
+  }
+
+  const validDivisionCharRE = /[\w).+\-_$\]]/;
+  function parseFilters(exp) {
+      let inSingle = false;
+      let inDouble = false;
+      let inTemplateString = false;
+      let inRegex = false;
+      let curly = 0;
+      let square = 0;
+      let paren = 0;
+      let lastFilterIndex = 0;
+      let c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  inSingle = false;
+          }
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  inDouble = false;
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  inTemplateString = false;
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  inRegex = false;
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  let j = i - 1;
+                  let p;
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          break;
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
+          }
+      }
+      if (expression === undefined) {
+          expression = exp.slice(0, i).trim();
+      }
+      else if (lastFilterIndex !== 0) {
+          pushFilter();
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
+  }
+  function wrapFilter(exp, filter) {
+      const i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return `_f("${filter}")(${exp})`;
+      }
+      else {
+          const name = filter.slice(0, i);
+          const args = filter.slice(i + 1);
+          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+      }
+  }
+
+  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+  const buildRegex = cached((delimiters) => {
+      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+  });
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      const tokens = [];
+      const rawTokens = [];
+      let lastIndex = (tagRE.lastIndex = 0);
+      let match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          const exp = parseFilters(match[1].trim());
+          tokens.push(`_s(${exp})`);
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
+  }
+
+  /* eslint-disable no-unused-vars */
+  function baseWarn(msg, range) {
+      console.error(`[Vue compiler]: ${msg}`);
+  }
+  /* eslint-enable no-unused-vars */
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+  }
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
+  }
+  function addAttr(el, name, value, range, dynamic) {
+      const attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
+  }
+  // add a raw attr (use this in preTransforms)
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name, value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamicArg,
+          modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = `(${name})==='click'?'contextmenu':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = `(${name})==='click'?'mouseup':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      let events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      const handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
+  }
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
+  }
+  function getBindingAttr(el, name, getStatic) {
+      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          const staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
+  }
+  // note: this only removes the attr from the Array (attrsList) so that it
+  // doesn't get processed by processAttrs.
+  // By default it does NOT remove it from the map (attrsMap) because the map is
+  // needed during codegen.
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      let val;
+      if ((val = el.attrsMap[name]) != null) {
+          const list = el.attrsList;
+          for (let i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
+      }
+      if (removeFromMap) {
+          delete el.attrsMap[name];
+      }
+      return val;
+  }
+  function getAndRemoveAttrByRegex(el, name) {
+      const list = el.attrsList;
+      for (let i = 0, l = list.length; i < l; i++) {
+          const attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
+      }
+  }
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
+      }
+      return item;
+  }
+
+  function transformNode$1(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          const res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn(`class="${staticClass}": ` +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
+      }
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+      }
+      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
+      }
+  }
+  function genData$2(el) {
+      let data = '';
+      if (el.staticClass) {
+          data += `staticClass:${el.staticClass},`;
+      }
+      if (el.classBinding) {
+          data += `class:${el.classBinding},`;
+      }
+      return data;
+  }
+  var klass = {
+      staticKeys: ['staticClass'],
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
-  function transformNode(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticStyle = getAndRemoveAttr(el, 'style');
-      if (staticStyle) {
-          /* istanbul ignore if */
-          {
-              const res = parseText(staticStyle, options.delimiters);
-              if (res) {
-                  warn(`style="${staticStyle}": ` +
-                      'Interpolation inside attributes has been removed. ' +
-                      'Use v-bind or the colon shorthand instead. For example, ' +
-                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-              }
-          }
-          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-      }
-      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-      if (styleBinding) {
-          el.styleBinding = styleBinding;
-      }
-  }
-  function genData$1(el) {
-      let data = '';
-      if (el.staticStyle) {
-          data += `staticStyle:${el.staticStyle},`;
-      }
-      if (el.styleBinding) {
-          data += `style:(${el.styleBinding}),`;
-      }
-      return data;
-  }
-  var style = {
-      staticKeys: ['staticStyle'],
-      transformNode,
-      genData: genData$1,
+  function transformNode(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              const res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn(`style="${staticStyle}": ` +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
+      }
+  }
+  function genData$1(el) {
+      let data = '';
+      if (el.staticStyle) {
+          data += `staticStyle:${el.staticStyle},`;
+      }
+      if (el.styleBinding) {
+          data += `style:(${el.styleBinding}),`;
+      }
+      return data;
+  }
+  var style = {
+      staticKeys: ['staticStyle'],
+      transformNode,
+      genData: genData$1,
   };
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -2953,4677 +2952,4677 @@
 
   var he = he$1.exports;
 
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-  // Regular Expressions for parsing tags and attributes
-  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-  const startTagOpen = new RegExp(`^<${qnameCapture}`);
-  const startTagClose = /^\s*(\/?)>/;
-  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-  const doctype = /^<!DOCTYPE [^>]+>/i;
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  const comment = /^<!\--/;
-  const conditionalComment = /^<!\[/;
-  // Special Elements (can contain anything)
-  const isPlainTextElement = makeMap('script,style,textarea', true);
-  const reCache = {};
-  const decodingMap = {
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&amp;': '&',
-      '&#10;': '\n',
-      '&#9;': '\t',
-      '&#39;': "'",
-  };
-  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-  // #5992
-  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  function decodeAttr(value, shouldDecodeNewlines) {
-      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-      return value.replace(re, (match) => decodingMap[match]);
-  }
-  function parseHTML(html, options) {
-      const stack = [];
-      const expectHTML = options.expectHTML;
-      const isUnaryTag = options.isUnaryTag || no;
-      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-      let index = 0;
-      let last, lastTag;
-      while (html) {
-          last = html;
-          // Make sure we're not in a plaintext content element like script/style
-          if (!lastTag || !isPlainTextElement(lastTag)) {
-              let textEnd = html.indexOf('<');
-              if (textEnd === 0) {
-                  // Comment:
-                  if (comment.test(html)) {
-                      const commentEnd = html.indexOf('-->');
-                      if (commentEnd >= 0) {
-                          if (options.shouldKeepComment) {
-                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                          }
-                          advance(commentEnd + 3);
-                          continue;
-                      }
-                  }
-                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                  if (conditionalComment.test(html)) {
-                      const conditionalEnd = html.indexOf(']>');
-                      if (conditionalEnd >= 0) {
-                          advance(conditionalEnd + 2);
-                          continue;
-                      }
-                  }
-                  // Doctype:
-                  const doctypeMatch = html.match(doctype);
-                  if (doctypeMatch) {
-                      advance(doctypeMatch[0].length);
-                      continue;
-                  }
-                  // End tag:
-                  const endTagMatch = html.match(endTag);
-                  if (endTagMatch) {
-                      const curIndex = index;
-                      advance(endTagMatch[0].length);
-                      parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
-                  }
-                  // Start tag:
-                  const startTagMatch = parseStartTag();
-                  if (startTagMatch) {
-                      handleStartTag(startTagMatch);
-                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                          advance(1);
-                      }
-                      continue;
-                  }
-              }
-              let text, rest, next;
-              if (textEnd >= 0) {
-                  rest = html.slice(textEnd);
-                  while (!endTag.test(rest) &&
-                      !startTagOpen.test(rest) &&
-                      !comment.test(rest) &&
-                      !conditionalComment.test(rest)) {
-                      // < in plain text, be forgiving and treat it as text
-                      next = rest.indexOf('<', 1);
-                      if (next < 0)
-                          break;
-                      textEnd += next;
-                      rest = html.slice(textEnd);
-                  }
-                  text = html.substring(0, textEnd);
-              }
-              if (textEnd < 0) {
-                  text = html;
-              }
-              if (text) {
-                  advance(text.length);
-              }
-              if (options.chars && text) {
-                  options.chars(text, index - text.length, index);
-              }
-          }
-          else {
-              let endTagLength = 0;
-              const stackedTag = lastTag.toLowerCase();
-              const reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                      text = text
-                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                  }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                      text = text.slice(1);
-                  }
-                  if (options.chars) {
-                      options.chars(text);
-                  }
-                  return '';
-              });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag, index - endTagLength, index);
-          }
-          if (html === last) {
-              options.chars && options.chars(html);
-              if (!stack.length &&
-                  options.warn) {
-                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                      start: index + html.length,
-                  });
-              }
-              break;
-          }
-      }
-      // Clean up any remaining tags
-      parseEndTag();
-      function advance(n) {
-          index += n;
-          html = html.substring(n);
-      }
-      function parseStartTag() {
-          const start = html.match(startTagOpen);
-          if (start) {
-              const match = {
-                  tagName: start[1],
-                  attrs: [],
-                  start: index,
-              };
-              advance(start[0].length);
-              let end, attr;
-              while (!(end = html.match(startTagClose)) &&
-                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                  attr.start = index;
-                  advance(attr[0].length);
-                  attr.end = index;
-                  match.attrs.push(attr);
-              }
-              if (end) {
-                  match.unarySlash = end[1];
-                  advance(end[0].length);
-                  match.end = index;
-                  return match;
-              }
-          }
-      }
-      function handleStartTag(match) {
-          const tagName = match.tagName;
-          const unarySlash = match.unarySlash;
-          if (expectHTML) {
-              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                  parseEndTag(lastTag);
-              }
-              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                  parseEndTag(tagName);
-              }
-          }
-          const unary = isUnaryTag(tagName) || !!unarySlash;
-          const l = match.attrs.length;
-          const attrs = new Array(l);
-          for (let i = 0; i < l; i++) {
-              const args = match.attrs[i];
-              const value = args[3] || args[4] || args[5] || '';
-              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                  ? options.shouldDecodeNewlinesForHref
-                  : options.shouldDecodeNewlines;
-              attrs[i] = {
-                  name: args[1],
-                  value: decodeAttr(value, shouldDecodeNewlines),
-              };
-              if (options.outputSourceRange) {
-                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                  attrs[i].end = args.end;
-              }
-          }
-          if (!unary) {
-              stack.push({
-                  tag: tagName,
-                  lowerCasedTag: tagName.toLowerCase(),
-                  attrs: attrs,
-                  start: match.start,
-                  end: match.end,
-              });
-              lastTag = tagName;
-          }
-          if (options.start) {
-              options.start(tagName, attrs, unary, match.start, match.end);
-          }
-      }
-      function parseEndTag(tagName, start, end) {
-          let pos, lowerCasedTagName;
-          if (start == null)
-              start = index;
-          if (end == null)
-              end = index;
-          // Find the closest opened tag of the same type
-          if (tagName) {
-              lowerCasedTagName = tagName.toLowerCase();
-              for (pos = stack.length - 1; pos >= 0; pos--) {
-                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                      break;
-                  }
-              }
-          }
-          else {
-              // If no tag name is provided, clean shop
-              pos = 0;
-          }
-          if (pos >= 0) {
-              // Close all the open elements, up the stack
-              for (let i = stack.length - 1; i >= pos; i--) {
-                  if ((i > pos || !tagName) &&
-                      options.warn) {
-                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                          start: stack[i].start,
-                          end: stack[i].end,
-                      });
-                  }
-                  if (options.end) {
-                      options.end(stack[i].tag, start, end);
-                  }
-              }
-              // Remove the open elements from the stack
-              stack.length = pos;
-              lastTag = pos && stack[pos - 1].tag;
-          }
-          else if (lowerCasedTagName === 'br') {
-              if (options.start) {
-                  options.start(tagName, [], true, start, end);
-              }
-          }
-          else if (lowerCasedTagName === 'p') {
-              if (options.start) {
-                  options.start(tagName, [], false, start, end);
-              }
-              if (options.end) {
-                  options.end(tagName, start, end);
-              }
-          }
-      }
-  }
-
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel(el, value, modifiers) {
-      const { number, trim } = modifiers || {};
-      const baseValueExpression = '$$v';
-      let valueExpression = baseValueExpression;
-      if (trim) {
-          valueExpression =
-              `(typeof ${baseValueExpression} === 'string'` +
-                  `? ${baseValueExpression}.trim()` +
-                  `: ${baseValueExpression})`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      const assignment = genAssignmentCode(value, valueExpression);
-      el.model = {
-          value: `(${value})`,
-          expression: JSON.stringify(value),
-          callback: `function (${baseValueExpression}) {${assignment}}`,
-      };
-  }
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode(value, assignment) {
-      const res = parseModel(value);
-      if (res.key === null) {
-          return `${value}=${assignment}`;
-      }
-      else {
-          return `$set(${res.exp}, ${res.key}, ${assignment})`;
-      }
-  }
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-  let len, str, chr, index, expressionPos, expressionEndPos;
-  function parseModel(val) {
-      // Fix https://github.com/vuejs/vue/pull/7730
-      // allow v-model="obj.val " (trailing whitespace)
-      val = val.trim();
-      len = val.length;
-      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-          index = val.lastIndexOf('.');
-          if (index > -1) {
-              return {
-                  exp: val.slice(0, index),
-                  key: '"' + val.slice(index + 1) + '"',
-              };
-          }
-          else {
-              return {
-                  exp: val,
-                  key: null,
-              };
-          }
-      }
-      str = val;
-      index = expressionPos = expressionEndPos = 0;
-      while (!eof()) {
-          chr = next();
-          /* istanbul ignore if */
-          if (isStringStart(chr)) {
-              parseString(chr);
-          }
-          else if (chr === 0x5b) {
-              parseBracket(chr);
-          }
-      }
-      return {
-          exp: val.slice(0, expressionPos),
-          key: val.slice(expressionPos + 1, expressionEndPos),
-      };
-  }
-  function next() {
-      return str.charCodeAt(++index);
-  }
-  function eof() {
-      return index >= len;
-  }
-  function isStringStart(chr) {
-      return chr === 0x22 || chr === 0x27;
-  }
-  function parseBracket(chr) {
-      let inBracket = 1;
-      expressionPos = index;
-      while (!eof()) {
-          chr = next();
-          if (isStringStart(chr)) {
-              parseString(chr);
-              continue;
-          }
-          if (chr === 0x5b)
-              inBracket++;
-          if (chr === 0x5d)
-              inBracket--;
-          if (inBracket === 0) {
-              expressionEndPos = index;
-              break;
-          }
-      }
-  }
-  function parseString(chr) {
-      const stringQuote = chr;
-      while (!eof()) {
-          chr = next();
-          if (chr === stringQuote) {
-              break;
-          }
-      }
-  }
-
-  const onRE = /^@|^v-on:/;
-  const dirRE = /^v-|^@|^:|^#/;
-  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  const stripParensRE = /^\(|\)$/g;
-  const dynamicArgRE = /^\[.*\]$/;
-  const argRE = /:(.*)$/;
-  const bindRE = /^:|^\.|^v-bind:/;
-  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-  const slotRE = /^v-slot(:|$)|^#/;
-  const lineBreakRE = /[\r\n]/;
-  const whitespaceRE = /[ \f\t\r\n]+/g;
-  const invalidAttributeRE = /[\s"'<>\/=]/;
-  const decodeHTMLCached = cached(he.decode);
-  const emptySlotScopeToken = `_empty_`;
-  // configurable state
-  let warn$1;
-  let delimiters;
-  let transforms;
-  let preTransforms;
-  let postTransforms;
-  let platformIsPreTag;
-  let platformMustUseProp;
-  let platformGetTagNamespace;
-  let maybeComponent;
-  function createASTElement(tag, attrs, parent) {
-      return {
-          type: 1,
-          tag,
-          attrsList: attrs,
-          attrsMap: makeAttrsMap(attrs),
-          rawAttrsMap: {},
-          parent,
-          children: [],
-      };
-  }
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse(template, options) {
-      warn$1 = options.warn || baseWarn;
-      platformIsPreTag = options.isPreTag || no;
-      platformMustUseProp = options.mustUseProp || no;
-      platformGetTagNamespace = options.getTagNamespace || no;
-      const isReservedTag = options.isReservedTag || no;
-      maybeComponent = (el) => !!(el.component ||
-          el.attrsMap[':is'] ||
-          el.attrsMap['v-bind:is'] ||
-          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-      transforms = pluckModuleFunction(options.modules, 'transformNode');
-      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-      delimiters = options.delimiters;
-      const stack = [];
-      const preserveWhitespace = options.preserveWhitespace !== false;
-      const whitespaceOption = options.whitespace;
-      let root;
-      let currentParent;
-      let inVPre = false;
-      let inPre = false;
-      let warned = false;
-      function warnOnce(msg, range) {
-          if (!warned) {
-              warned = true;
-              warn$1(msg, range);
-          }
-      }
-      function closeElement(element) {
-          trimEndingWhitespace(element);
-          if (!inVPre && !element.processed) {
-              element = processElement(element, options);
-          }
-          // tree management
-          if (!stack.length && element !== root) {
-              // allow root elements with v-if, v-else-if and v-else
-              if (root.if && (element.elseif || element.else)) {
-                  {
-                      checkRootConstraints(element);
-                  }
-                  addIfCondition(root, {
-                      exp: element.elseif,
-                      block: element,
-                  });
-              }
-              else {
-                  warnOnce(`Component template should contain exactly one root element. ` +
-                      `If you are using v-if on multiple elements, ` +
-                      `use v-else-if to chain them instead.`, { start: element.start });
-              }
-          }
-          if (currentParent && !element.forbidden) {
-              if (element.elseif || element.else) {
-                  processIfConditions(element, currentParent);
-              }
-              else {
-                  if (element.slotScope) {
-                      // scoped slot
-                      // keep it in the children list so that v-else(-if) conditions can
-                      // find it as the prev node.
-                      const name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                  }
-                  currentParent.children.push(element);
-                  element.parent = currentParent;
-              }
-          }
-          // final children cleanup
-          // filter out scoped slots
-          element.children = element.children.filter((c) => !c.slotScope);
-          // remove trailing whitespace node again
-          trimEndingWhitespace(element);
-          // check pre state
-          if (element.pre) {
-              inVPre = false;
-          }
-          if (platformIsPreTag(element.tag)) {
-              inPre = false;
-          }
-          // apply post-transforms
-          for (let i = 0; i < postTransforms.length; i++) {
-              postTransforms[i](element, options);
-          }
-      }
-      function trimEndingWhitespace(el) {
-          // remove trailing whitespace node
-          if (!inPre) {
-              let lastNode;
-              while ((lastNode = el.children[el.children.length - 1]) &&
-                  lastNode.type === 3 &&
-                  lastNode.text === ' ') {
-                  el.children.pop();
-              }
-          }
-      }
-      function checkRootConstraints(el) {
-          if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                  'contain multiple nodes.', { start: el.start });
-          }
-          if (el.attrsMap.hasOwnProperty('v-for')) {
-              warnOnce('Cannot use v-for on stateful component root element because ' +
-                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
-          }
-      }
-      parseHTML(template, {
-          warn: warn$1,
-          expectHTML: options.expectHTML,
-          isUnaryTag: options.isUnaryTag,
-          canBeLeftOpenTag: options.canBeLeftOpenTag,
-          shouldDecodeNewlines: options.shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-          shouldKeepComment: options.comments,
-          outputSourceRange: options.outputSourceRange,
-          start(tag, attrs, unary, start, end) {
-              // check namespace.
-              // inherit parent ns if there is one
-              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-              // handle IE svg bug
-              /* istanbul ignore if */
-              if (isIE && ns === 'svg') {
-                  attrs = guardIESVGBug(attrs);
-              }
-              let element = createASTElement(tag, attrs, currentParent);
-              if (ns) {
-                  element.ns = ns;
-              }
-              {
-                  if (options.outputSourceRange) {
-                      element.start = start;
-                      element.end = end;
-                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                          cumulated[attr.name] = attr;
-                          return cumulated;
-                      }, {});
-                  }
-                  attrs.forEach((attr) => {
-                      if (invalidAttributeRE.test(attr.name)) {
-                          warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                              `spaces, quotes, <, >, / or =.`, {
-                              start: attr.start + attr.name.indexOf(`[`),
-                              end: attr.start + attr.name.length,
-                          });
-                      }
-                  });
-              }
-              if (isForbiddenTag(element) && !isServerRendering()) {
-                  element.forbidden = true;
-                  warn$1('Templates should only be responsible for mapping the state to the ' +
-                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          `<${tag}>` +
-                          ', as they will not be parsed.', { start: element.start });
-              }
-              // apply pre-transforms
-              for (let i = 0; i < preTransforms.length; i++) {
-                  element = preTransforms[i](element, options) || element;
-              }
-              if (!inVPre) {
-                  processPre(element);
-                  if (element.pre) {
-                      inVPre = true;
-                  }
-              }
-              if (platformIsPreTag(element.tag)) {
-                  inPre = true;
-              }
-              if (inVPre) {
-                  processRawAttrs(element);
-              }
-              else if (!element.processed) {
-                  // structural directives
-                  processFor(element);
-                  processIf(element);
-                  processOnce(element);
-              }
-              if (!root) {
-                  root = element;
-                  {
-                      checkRootConstraints(root);
-                  }
-              }
-              if (!unary) {
-                  currentParent = element;
-                  stack.push(element);
-              }
-              else {
-                  closeElement(element);
-              }
-          },
-          end(tag, start, end) {
-              const element = stack[stack.length - 1];
-              // pop stack
-              stack.length -= 1;
-              currentParent = stack[stack.length - 1];
-              if (options.outputSourceRange) {
-                  element.end = end;
-              }
-              closeElement(element);
-          },
-          chars(text, start, end) {
-              if (!currentParent) {
-                  {
-                      if (text === template) {
-                          warnOnce('Component template requires a root element, rather than just text.', { start });
-                      }
-                      else if ((text = text.trim())) {
-                          warnOnce(`text "${text}" outside root element will be ignored.`, {
-                              start,
-                          });
-                      }
-                  }
-                  return;
-              }
-              // IE textarea placeholder bug
-              /* istanbul ignore if */
-              if (isIE &&
-                  currentParent.tag === 'textarea' &&
-                  currentParent.attrsMap.placeholder === text) {
-                  return;
-              }
-              const children = currentParent.children;
-              if (inPre || text.trim()) {
-                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-              }
-              else if (!children.length) {
-                  // remove the whitespace-only node right after an opening tag
-                  text = '';
-              }
-              else if (whitespaceOption) {
-                  if (whitespaceOption === 'condense') {
-                      // in condense mode, remove the whitespace node if it contains
-                      // line break, otherwise condense to a single space
-                      text = lineBreakRE.test(text) ? '' : ' ';
-                  }
-                  else {
-                      text = ' ';
-                  }
-              }
-              else {
-                  text = preserveWhitespace ? ' ' : '';
-              }
-              if (text) {
-                  if (!inPre && whitespaceOption === 'condense') {
-                      // condense consecutive whitespaces into single space
-                      text = text.replace(whitespaceRE, ' ');
-                  }
-                  let res;
-                  let child;
-                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                      child = {
-                          type: 2,
-                          expression: res.expression,
-                          tokens: res.tokens,
-                          text,
-                      };
-                  }
-                  else if (text !== ' ' ||
-                      !children.length ||
-                      children[children.length - 1].text !== ' ') {
-                      child = {
-                          type: 3,
-                          text,
-                      };
-                  }
-                  if (child) {
-                      if (options.outputSourceRange) {
-                          child.start = start;
-                          child.end = end;
-                      }
-                      children.push(child);
-                  }
-              }
-          },
-          comment(text, start, end) {
-              // adding anything as a sibling to the root node is forbidden
-              // comments should still be allowed, but ignored
-              if (currentParent) {
-                  const child = {
-                      type: 3,
-                      text,
-                      isComment: true,
-                  };
-                  if (options.outputSourceRange) {
-                      child.start = start;
-                      child.end = end;
-                  }
-                  currentParent.children.push(child);
-              }
-          },
-      });
-      return root;
-  }
-  function processPre(el) {
-      if (getAndRemoveAttr(el, 'v-pre') != null) {
-          el.pre = true;
-      }
-  }
-  function processRawAttrs(el) {
-      const list = el.attrsList;
-      const len = list.length;
-      if (len) {
-          const attrs = (el.attrs = new Array(len));
-          for (let i = 0; i < len; i++) {
-              attrs[i] = {
-                  name: list[i].name,
-                  value: JSON.stringify(list[i].value),
-              };
-              if (list[i].start != null) {
-                  attrs[i].start = list[i].start;
-                  attrs[i].end = list[i].end;
-              }
-          }
-      }
-      else if (!el.pre) {
-          // non root node in pre blocks with no attributes
-          el.plain = true;
-      }
-  }
-  function processElement(element, options) {
-      processKey(element);
-      // determine whether this is a plain element after
-      // removing structural attributes
-      element.plain =
-          !element.key && !element.scopedSlots && !element.attrsList.length;
-      processRef(element);
-      processSlotContent(element);
-      processSlotOutlet(element);
-      processComponent(element);
-      for (let i = 0; i < transforms.length; i++) {
-          element = transforms[i](element, options) || element;
-      }
-      processAttrs(element);
-      return element;
-  }
-  function processKey(el) {
-      const exp = getBindingAttr(el, 'key');
-      if (exp) {
-          {
-              if (el.tag === 'template') {
-                  warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-              }
-              if (el.for) {
-                  const iterator = el.iterator2 || el.iterator1;
-                  const parent = el.parent;
-                  if (iterator &&
-                      iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
-                      warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                  }
-              }
-          }
-          el.key = exp;
-      }
-  }
-  function processRef(el) {
-      const ref = getBindingAttr(el, 'ref');
-      if (ref) {
-          el.ref = ref;
-          el.refInFor = checkInFor(el);
-      }
-  }
-  function processFor(el) {
-      let exp;
-      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-          const res = parseFor(exp);
-          if (res) {
-              extend(el, res);
-          }
-          else {
-              warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-          }
-      }
-  }
-  function parseFor(exp) {
-      const inMatch = exp.match(forAliasRE);
-      if (!inMatch)
-          return;
-      const res = {};
-      res.for = inMatch[2].trim();
-      const alias = inMatch[1].trim().replace(stripParensRE, '');
-      const iteratorMatch = alias.match(forIteratorRE);
-      if (iteratorMatch) {
-          res.alias = alias.replace(forIteratorRE, '').trim();
-          res.iterator1 = iteratorMatch[1].trim();
-          if (iteratorMatch[2]) {
-              res.iterator2 = iteratorMatch[2].trim();
-          }
-      }
-      else {
-          res.alias = alias;
-      }
-      return res;
-  }
-  function processIf(el) {
-      const exp = getAndRemoveAttr(el, 'v-if');
-      if (exp) {
-          el.if = exp;
-          addIfCondition(el, {
-              exp: exp,
-              block: el,
-          });
-      }
-      else {
-          if (getAndRemoveAttr(el, 'v-else') != null) {
-              el.else = true;
-          }
-          const elseif = getAndRemoveAttr(el, 'v-else-if');
-          if (elseif) {
-              el.elseif = elseif;
-          }
-      }
-  }
-  function processIfConditions(el, parent) {
-      const prev = findPrevElement(parent.children);
-      if (prev && prev.if) {
-          addIfCondition(prev, {
-              exp: el.elseif,
-              block: el,
-          });
-      }
-      else {
-          warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-      }
-  }
-  function findPrevElement(children) {
-      let i = children.length;
-      while (i--) {
-          if (children[i].type === 1) {
-              return children[i];
-          }
-          else {
-              if (children[i].text !== ' ') {
-                  warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                      `will be ignored.`, children[i]);
-              }
-              children.pop();
-          }
-      }
-  }
-  function addIfCondition(el, condition) {
-      if (!el.ifConditions) {
-          el.ifConditions = [];
-      }
-      el.ifConditions.push(condition);
-  }
-  function processOnce(el) {
-      const once = getAndRemoveAttr(el, 'v-once');
-      if (once != null) {
-          el.once = true;
-      }
-  }
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent(el) {
-      let slotScope;
-      if (el.tag === 'template') {
-          slotScope = getAndRemoveAttr(el, 'scope');
-          /* istanbul ignore if */
-          if (slotScope) {
-              warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                  `can also be used on plain elements in addition to <template> to ` +
-                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-          }
-          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-      }
-      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-          /* istanbul ignore if */
-          if (el.attrsMap['v-for']) {
-              warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-          }
-          el.slotScope = slotScope;
-      }
-      // slot="xxx"
-      const slotTarget = getBindingAttr(el, 'slot');
-      if (slotTarget) {
-          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-          // preserve slot as an attribute for native shadow DOM compat
-          // only for non-scoped slots.
-          if (el.tag !== 'template' && !el.slotScope) {
-              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-          }
-      }
-      // 2.6 v-slot syntax
-      {
-          if (el.tag === 'template') {
-              // v-slot on <template>
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (el.slotTarget || el.slotScope) {
-                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.parent && !maybeComponent(el.parent)) {
-                          warn$1(`<template v-slot> can only appear at the root level inside ` +
-                              `the receiving component`, el);
-                      }
-                  }
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  el.slotTarget = name;
-                  el.slotTargetDynamic = dynamic;
-                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-              }
-          }
-          else {
-              // v-slot on component, denotes default slot
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (!maybeComponent(el)) {
-                          warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                      }
-                      if (el.slotScope || el.slotTarget) {
-                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.scopedSlots) {
-                          warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                              `<template> syntax when there are other named slots.`, slotBinding);
-                      }
-                  }
-                  // add the component's children to its default slot
-                  const slots = el.scopedSlots || (el.scopedSlots = {});
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  const slotContainer = (slots[name] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name;
-                  slotContainer.slotTargetDynamic = dynamic;
-                  slotContainer.children = el.children.filter((c) => {
-                      if (!c.slotScope) {
-                          c.parent = slotContainer;
-                          return true;
-                      }
-                  });
-                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                  // remove children as they are returned from scopedSlots now
-                  el.children = [];
-                  // mark el non-plain so data gets generated
-                  el.plain = false;
-              }
-          }
-      }
-  }
-  function getSlotName(binding) {
-      let name = binding.name.replace(slotRE, '');
-      if (!name) {
-          if (binding.name[0] !== '#') {
-              name = 'default';
-          }
-          else {
-              warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-          }
-      }
-      return dynamicArgRE.test(name)
-          ? // dynamic [name]
-              { name: name.slice(1, -1), dynamic: true }
-          : // static name
-              { name: `"${name}"`, dynamic: false };
-  }
-  // handle <slot/> outlets
-  function processSlotOutlet(el) {
-      if (el.tag === 'slot') {
-          el.slotName = getBindingAttr(el, 'name');
-          if (el.key) {
-              warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                  `and can possibly expand into multiple elements. ` +
-                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-          }
-      }
-  }
-  function processComponent(el) {
-      let binding;
-      if ((binding = getBindingAttr(el, 'is'))) {
-          el.component = binding;
-      }
-      if (getAndRemoveAttr(el, 'inline-template') != null) {
-          el.inlineTemplate = true;
-      }
-  }
-  function processAttrs(el) {
-      const list = el.attrsList;
-      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-      for (i = 0, l = list.length; i < l; i++) {
-          name = rawName = list[i].name;
-          value = list[i].value;
-          if (dirRE.test(name)) {
-              // mark element as dynamic
-              el.hasBindings = true;
-              // modifiers
-              modifiers = parseModifiers(name.replace(dirRE, ''));
-              // support .foo shorthand syntax for the .prop modifier
-              if (modifiers) {
-                  name = name.replace(modifierRE, '');
-              }
-              if (bindRE.test(name)) {
-                  // v-bind
-                  name = name.replace(bindRE, '');
-                  value = parseFilters(value);
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  if (value.trim().length === 0) {
-                      warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                  }
-                  if (modifiers) {
-                      if (modifiers.prop && !isDynamic) {
-                          name = camelize(name);
-                          if (name === 'innerHtml')
-                              name = 'innerHTML';
-                      }
-                      if (modifiers.camel && !isDynamic) {
-                          name = camelize(name);
-                      }
-                      if (modifiers.sync) {
-                          syncGen = genAssignmentCode(value, `$event`);
-                          if (!isDynamic) {
-                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                              if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                              }
-                          }
-                          else {
-                              // handler w/ dynamic event name
-                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                              );
-                          }
-                      }
-                  }
-                  if ((modifiers && modifiers.prop) ||
-                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                      addProp(el, name, value, list[i], isDynamic);
-                  }
-                  else {
-                      addAttr(el, name, value, list[i], isDynamic);
-                  }
-              }
-              else if (onRE.test(name)) {
-                  // v-on
-                  name = name.replace(onRE, '');
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-              }
-              else {
-                  // normal directives
-                  name = name.replace(dirRE, '');
-                  // parse arg
-                  const argMatch = name.match(argRE);
-                  let arg = argMatch && argMatch[1];
-                  isDynamic = false;
-                  if (arg) {
-                      name = name.slice(0, -(arg.length + 1));
-                      if (dynamicArgRE.test(arg)) {
-                          arg = arg.slice(1, -1);
-                          isDynamic = true;
-                      }
-                  }
-                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                  if (name === 'model') {
-                      checkForAliasModel(el, value);
-                  }
-              }
-          }
-          else {
-              // literal attribute
-              {
-                  const res = parseText(value, delimiters);
-                  if (res) {
-                      warn$1(`${name}="${value}": ` +
-                          'Interpolation inside attributes has been removed. ' +
-                          'Use v-bind or the colon shorthand instead. For example, ' +
-                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                  }
-              }
-              addAttr(el, name, JSON.stringify(value), list[i]);
-              // #6887 firefox doesn't update muted state if set via attribute
-              // even immediately after element creation
-              if (!el.component &&
-                  name === 'muted' &&
-                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                  addProp(el, name, 'true', list[i]);
-              }
-          }
-      }
-  }
-  function checkInFor(el) {
-      let parent = el;
-      while (parent) {
-          if (parent.for !== undefined) {
-              return true;
-          }
-          parent = parent.parent;
-      }
-      return false;
-  }
-  function parseModifiers(name) {
-      const match = name.match(modifierRE);
-      if (match) {
-          const ret = {};
-          match.forEach((m) => {
-              ret[m.slice(1)] = true;
-          });
-          return ret;
-      }
-  }
-  function makeAttrsMap(attrs) {
-      const map = {};
-      for (let i = 0, l = attrs.length; i < l; i++) {
-          if (map[attrs[i].name] &&
-              !isIE &&
-              !isEdge) {
-              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-          }
-          map[attrs[i].name] = attrs[i].value;
-      }
-      return map;
-  }
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag(el) {
-      return el.tag === 'script' || el.tag === 'style';
-  }
-  function isForbiddenTag(el) {
-      return (el.tag === 'style' ||
-          (el.tag === 'script' &&
-              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-  }
-  const ieNSBug = /^xmlns:NS\d+/;
-  const ieNSPrefix = /^NS\d+:/;
-  /* istanbul ignore next */
-  function guardIESVGBug(attrs) {
-      const res = [];
-      for (let i = 0; i < attrs.length; i++) {
-          const attr = attrs[i];
-          if (!ieNSBug.test(attr.name)) {
-              attr.name = attr.name.replace(ieNSPrefix, '');
-              res.push(attr);
-          }
-      }
-      return res;
-  }
-  function checkForAliasModel(el, value) {
-      let _el = el;
-      while (_el) {
-          if (_el.for && _el.alias === value) {
-              warn$1(`<${el.tag} v-model="${value}">: ` +
-                  `You are binding v-model directly to a v-for iteration alias. ` +
-                  `This will not be able to modify the v-for source array because ` +
-                  `writing to the alias is like modifying a function local variable. ` +
-                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-          }
-          _el = _el.parent;
-      }
-  }
-
-  /**
-   * Expand input[v-model] with dynamic type bindings into v-if-else chains
-   * Turn this:
-   *   <input v-model="data[type]" :type="type">
-   * into this:
-   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-   *   <input v-else :type="type" v-model="data[type]">
-   */
-  function preTransformNode(el, options) {
-      if (el.tag === 'input') {
-          const map = el.attrsMap;
-          if (!map['v-model']) {
-              return;
-          }
-          let typeBinding;
-          if (map[':type'] || map['v-bind:type']) {
-              typeBinding = getBindingAttr(el, 'type');
-          }
-          if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = `(${map['v-bind']}).type`;
-          }
-          if (typeBinding) {
-              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-              // 1. checkbox
-              const branch0 = cloneASTElement(el);
-              // process for on the main node
-              processFor(branch0);
-              addRawAttr(branch0, 'type', 'checkbox');
-              processElement(branch0, options);
-              branch0.processed = true; // prevent it from double-processed
-              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-              addIfCondition(branch0, {
-                  exp: branch0.if,
-                  block: branch0,
-              });
-              // 2. add radio else-if condition
-              const branch1 = cloneASTElement(el);
-              getAndRemoveAttr(branch1, 'v-for', true);
-              addRawAttr(branch1, 'type', 'radio');
-              processElement(branch1, options);
-              addIfCondition(branch0, {
-                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                  block: branch1,
-              });
-              // 3. other
-              const branch2 = cloneASTElement(el);
-              getAndRemoveAttr(branch2, 'v-for', true);
-              addRawAttr(branch2, ':type', typeBinding);
-              processElement(branch2, options);
-              addIfCondition(branch0, {
-                  exp: ifCondition,
-                  block: branch2,
-              });
-              if (hasElse) {
-                  branch0.else = true;
-              }
-              else if (elseIfCondition) {
-                  branch0.elseif = elseIfCondition;
-              }
-              return branch0;
-          }
-      }
-  }
-  function cloneASTElement(el) {
-      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-  }
-  var model$1 = {
-      preTransformNode,
+  /**
+   * Not type-checking this file because it's mostly vendor code.
+   */
+  // Regular Expressions for parsing tags and attributes
+  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+  const startTagOpen = new RegExp(`^<${qnameCapture}`);
+  const startTagClose = /^\s*(\/?)>/;
+  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+  const doctype = /^<!DOCTYPE [^>]+>/i;
+  // #7298: escape - to avoid being passed as HTML comment when inlined in page
+  const comment = /^<!\--/;
+  const conditionalComment = /^<!\[/;
+  // Special Elements (can contain anything)
+  const isPlainTextElement = makeMap('script,style,textarea', true);
+  const reCache = {};
+  const decodingMap = {
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
+  };
+  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+  // #5992
+  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  function decodeAttr(value, shouldDecodeNewlines) {
+      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, (match) => decodingMap[match]);
+  }
+  function parseHTML(html, options) {
+      const stack = [];
+      const expectHTML = options.expectHTML;
+      const isUnaryTag = options.isUnaryTag || no;
+      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+      let index = 0;
+      let last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              let textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      const commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      const conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  const doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  const endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      const curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  const startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              let text, rest, next;
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          break;
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
+              }
+          }
+          else {
+              let endTagLength = 0;
+              const stackedTag = lastTag.toLowerCase();
+              const reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag, index - endTagLength, index);
+          }
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                      start: index + html.length,
+                  });
+              }
+              break;
+          }
+      }
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          const start = html.match(startTagOpen);
+          if (start) {
+              const match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              let end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
+      }
+      function handleStartTag(match) {
+          const tagName = match.tagName;
+          const unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          const unary = isUnaryTag(tagName) || !!unarySlash;
+          const l = match.attrs.length;
+          const attrs = new Array(l);
+          for (let i = 0; i < l; i++) {
+              const args = match.attrs[i];
+              const value = args[3] || args[4] || args[5] || '';
+              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
+          }
+      }
+      function parseEndTag(tagName, start, end) {
+          let pos, lowerCasedTagName;
+          if (start == null)
+              start = index;
+          if (end == null)
+              end = index;
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (let i = stack.length - 1; i >= pos; i--) {
+                  if ((i > pos || !tagName) &&
+                      options.warn) {
+                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
+          }
+      }
+  }
+
+  /**
+   * Cross-platform code generation for component v-model
+   */
+  function genComponentModel(el, value, modifiers) {
+      const { number, trim } = modifiers || {};
+      const baseValueExpression = '$$v';
+      let valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              `(typeof ${baseValueExpression} === 'string'` +
+                  `? ${baseValueExpression}.trim()` +
+                  `: ${baseValueExpression})`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      const assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: `(${value})`,
+          expression: JSON.stringify(value),
+          callback: `function (${baseValueExpression}) {${assignment}}`,
+      };
+  }
+  /**
+   * Cross-platform codegen helper for generating v-model value assignment code.
+   */
+  function genAssignmentCode(value, assignment) {
+      const res = parseModel(value);
+      if (res.key === null) {
+          return `${value}=${assignment}`;
+      }
+      else {
+          return `$set(${res.exp}, ${res.key}, ${assignment})`;
+      }
+  }
+  /**
+   * Parse a v-model expression into a base path and a final key segment.
+   * Handles both dot-path and possible square brackets.
+   *
+   * Possible cases:
+   *
+   * - test
+   * - test[key]
+   * - test[test1[key]]
+   * - test["a"][key]
+   * - xxx.test[a[a].test1[key]]
+   * - test.xxx.a["asa"][test1[key]]
+   *
+   */
+  let len, str, chr, index, expressionPos, expressionEndPos;
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
+              return {
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
+      }
+      str = val;
+      index = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
+      }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
+  }
+  function next() {
+      return str.charCodeAt(++index);
+  }
+  function eof() {
+      return index >= len;
+  }
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
+  }
+  function parseBracket(chr) {
+      let inBracket = 1;
+      expressionPos = index;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              inBracket++;
+          if (chr === 0x5d)
+              inBracket--;
+          if (inBracket === 0) {
+              expressionEndPos = index;
+              break;
+          }
+      }
+  }
+  function parseString(chr) {
+      const stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
+      }
+  }
+
+  const onRE = /^@|^v-on:/;
+  const dirRE = /^v-|^@|^:|^#/;
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  const dynamicArgRE = /^\[.*\]$/;
+  const argRE = /:(.*)$/;
+  const bindRE = /^:|^\.|^v-bind:/;
+  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+  const slotRE = /^v-slot(:|$)|^#/;
+  const lineBreakRE = /[\r\n]/;
+  const whitespaceRE = /[ \f\t\r\n]+/g;
+  const invalidAttributeRE = /[\s"'<>\/=]/;
+  const decodeHTMLCached = cached(he.decode);
+  const emptySlotScopeToken = `_empty_`;
+  // configurable state
+  let warn$1;
+  let delimiters;
+  let transforms;
+  let preTransforms;
+  let postTransforms;
+  let platformIsPreTag;
+  let platformMustUseProp;
+  let platformGetTagNamespace;
+  let maybeComponent;
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent,
+          children: [],
+      };
+  }
+  /**
+   * Convert HTML string to AST.
+   */
+  function parse(template, options) {
+      warn$1 = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      const isReservedTag = options.isReservedTag || no;
+      maybeComponent = (el) => !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      const stack = [];
+      const preserveWhitespace = options.preserveWhitespace !== false;
+      const whitespaceOption = options.whitespace;
+      let root;
+      let currentParent;
+      let inVPre = false;
+      let inPre = false;
+      let warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn$1(msg, range);
+          }
+      }
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce(`Component template should contain exactly one root element. ` +
+                      `If you are using v-if on multiple elements, ` +
+                      `use v-else-if to chain them instead.`, { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      const name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter((c) => !c.slotScope);
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
+          if (element.pre) {
+              inVPre = false;
+          }
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
+          }
+          // apply post-transforms
+          for (let i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
+          }
+      }
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              let lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
+          }
+      }
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                  'contain multiple nodes.', { start: el.start });
+          }
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
+          }
+      }
+      parseHTML(template, {
+          warn: warn$1,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start(tag, attrs, unary, start, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              let element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach((attr) => {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                              `spaces, quotes, <, >, / or =.`, {
+                              start: attr.start + attr.name.indexOf(`[`),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn$1('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          `<${tag}>` +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (let i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end(tag, start, end) {
+              const element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end;
+              }
+              closeElement(element);
+          },
+          chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(`text "${text}" outside root element will be ignored.`, {
+                              start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              const children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE, ' ');
+                  }
+                  let res;
+                  let child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  const child = {
+                      type: 3,
+                      text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
+      });
+      return root;
+  }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
+  }
+  function processRawAttrs(el) {
+      const list = el.attrsList;
+      const len = list.length;
+      if (len) {
+          const attrs = (el.attrs = new Array(len));
+          for (let i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
+      }
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (let i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      const exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  const iterator = el.iterator2 || el.iterator1;
+                  const parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
+      }
+  }
+  function processRef(el) {
+      const ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
+      }
+  }
+  function processFor(el) {
+      let exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          const res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+          }
+      }
+  }
+  function parseFor(exp) {
+      const inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          return;
+      const res = {};
+      res.for = inMatch[2].trim();
+      const alias = inMatch[1].trim().replace(stripParensRE, '');
+      const iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
+          }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
+  }
+  function processIf(el) {
+      const exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          const elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
+      }
+  }
+  function processIfConditions(el, parent) {
+      const prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
+          });
+      }
+      else {
+          warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+      }
+  }
+  function findPrevElement(children) {
+      let i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                      `will be ignored.`, children[i]);
+              }
+              children.pop();
+          }
+      }
+  }
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
+  }
+  function processOnce(el) {
+      const once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
+          el.once = true;
+      }
+  }
+  // handle content being passed to a component as slot,
+  // e.g. <template slot="xxx">, <div slot-scope="xxx">
+  function processSlotContent(el) {
+      let slotScope;
+      if (el.tag === 'template') {
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                  `can also be used on plain elements in addition to <template> to ` +
+                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+          }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      const slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn$1(`<template v-slot> can only appear at the root level inside ` +
+                              `the receiving component`, el);
+                      }
+                  }
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.scopedSlots) {
+                          warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                              `<template> syntax when there are other named slots.`, slotBinding);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  const slots = el.scopedSlots || (el.scopedSlots = {});
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  const slotContainer = (slots[name] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name;
+                  slotContainer.slotTargetDynamic = dynamic;
+                  slotContainer.children = el.children.filter((c) => {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
+          }
+      }
+  }
+  function getSlotName(binding) {
+      let name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+          }
+      }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: `"${name}"`, dynamic: false };
+  }
+  // handle <slot/> outlets
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                  `and can possibly expand into multiple elements. ` +
+                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+          }
+      }
+  }
+  function processComponent(el) {
+      let binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
+      }
+  }
+  function processAttrs(el) {
+      const list = el.attrsList;
+      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              name = 'innerHTML';
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, `$event`);
+                          if (!isDynamic) {
+                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  const argMatch = name.match(argRE);
+                  let arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
+              }
+          }
+          else {
+              // literal attribute
+              {
+                  const res = parseText(value, delimiters);
+                  if (res) {
+                      warn$1(`${name}="${value}": ` +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
+          }
+      }
+  }
+  function checkInFor(el) {
+      let parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
+      }
+      return false;
+  }
+  function parseModifiers(name) {
+      const match = name.match(modifierRE);
+      if (match) {
+          const ret = {};
+          match.forEach((m) => {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
+  }
+  function makeAttrsMap(attrs) {
+      const map = {};
+      for (let i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
+  }
+  // for script (e.g. type="x/template") or style, do not decode content
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
+  }
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+  }
+  const ieNSBug = /^xmlns:NS\d+/;
+  const ieNSPrefix = /^NS\d+:/;
+  /* istanbul ignore next */
+  function guardIESVGBug(attrs) {
+      const res = [];
+      for (let i = 0; i < attrs.length; i++) {
+          const attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
+      }
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      let _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn$1(`<${el.tag} v-model="${value}">: ` +
+                  `You are binding v-model directly to a v-for iteration alias. ` +
+                  `This will not be able to modify the v-for source array because ` +
+                  `writing to the alias is like modifying a function local variable. ` +
+                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
+      }
+  }
+
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          const map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          let typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = `(${map['v-bind']}).type`;
+          }
+          if (typeBinding) {
+              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              const branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              const branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              const branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
+      }
+  }
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+  }
+  var model$1 = {
+      preTransformNode,
   };
 
   var modules = [klass, style, model$1];
 
-  let warn;
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
-  function model(el, dir, _warn) {
-      warn = _warn;
-      const value = dir.value;
-      const modifiers = dir.modifiers;
-      const tag = el.tag;
-      const type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const valueBinding = getBindingAttr(el, 'value') || 'null';
-      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', `Array.isArray(${value})` +
-          `?_i(${value},${valueBinding})>-1` +
-          (trueValueBinding === 'true'
-              ? `:(${value})`
-              : `:_q(${value},${trueValueBinding})`));
-      addHandler(el, 'change', `var $$a=${value},` +
-          '$$el=$event.target,' +
-          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-          'if(Array.isArray($$a)){' +
-          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      let valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-      addProp(el, 'checked', `_q(${value},${valueBinding})`);
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const selectedVal = `Array.prototype.filter` +
-          `.call($event.target.options,function(o){return o.selected})` +
-          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-          `return ${number ? '_n(val)' : 'val'}})`;
-      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      let code = `var $$selectedVal = ${selectedVal};`;
-      code = `${code} ${genAssignmentCode(value, assignment)}`;
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      const type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value && !typeBinding) {
-              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      const { lazy, number, trim } = modifiers || {};
-      const needCompositionGuard = !lazy && type !== 'range';
-      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      let valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = `$event.target.value.trim()`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      let code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = `if($event.target.composing)return;${code}`;
-      }
-      addProp(el, 'value', `(${value})`);
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
-  }
-
-  function text(el, dir) {
-      if (dir.value) {
-          addProp(el, 'textContent', `_s(${dir.value})`, dir);
-      }
-  }
-
-  function html(el, dir) {
-      if (dir.value) {
-          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-      }
-  }
-
-  var directives = {
-      model,
-      text,
-      html,
+  let warn;
+  // in some cases, the event used has to be determined at runtime
+  // so we used some reserved tokens during compile.
+  const RANGE_TOKEN = '__r';
+  function model(el, dir, _warn) {
+      warn = _warn;
+      const value = dir.value;
+      const modifiers = dir.modifiers;
+      const tag = el.tag;
+      const type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const valueBinding = getBindingAttr(el, 'value') || 'null';
+      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', `Array.isArray(${value})` +
+          `?_i(${value},${valueBinding})>-1` +
+          (trueValueBinding === 'true'
+              ? `:(${value})`
+              : `:_q(${value},${trueValueBinding})`));
+      addHandler(el, 'change', `var $$a=${value},` +
+          '$$el=$event.target,' +
+          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+          'if(Array.isArray($$a)){' +
+          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+          '$$i=_i($$a,$$v);' +
+          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      let valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+      addProp(el, 'checked', `_q(${value},${valueBinding})`);
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const selectedVal = `Array.prototype.filter` +
+          `.call($event.target.options,function(o){return o.selected})` +
+          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+          `return ${number ? '_n(val)' : 'val'}})`;
+      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      let code = `var $$selectedVal = ${selectedVal};`;
+      code = `${code} ${genAssignmentCode(value, assignment)}`;
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      const type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value && !typeBinding) {
+              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      const { lazy, number, trim } = modifiers || {};
+      const needCompositionGuard = !lazy && type !== 'range';
+      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      let valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = `$event.target.value.trim()`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      let code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = `if($event.target.composing)return;${code}`;
+      }
+      addProp(el, 'value', `(${value})`);
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
+  }
+
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', `_s(${dir.value})`, dir);
+      }
+  }
+
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+      }
+  }
+
+  var directives = {
+      model,
+      text,
+      html,
   };
 
-  const baseOptions = {
-      expectHTML: true,
-      modules,
-      directives,
-      isPreTag,
-      isUnaryTag,
-      mustUseProp,
-      canBeLeftOpenTag,
-      isReservedTag,
-      getTagNamespace,
-      staticKeys: genStaticKeys(modules),
+  const baseOptions = {
+      expectHTML: true,
+      modules,
+      directives,
+      isPreTag,
+      isUnaryTag,
+      mustUseProp,
+      canBeLeftOpenTag,
+      isReservedTag,
+      getTagNamespace,
+      staticKeys: genStaticKeys(modules),
   };
 
-  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  const fnInvokeRE = /\([^)]*?\);*$/;
-  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-  // KeyboardEvent.keyCode aliases
-  const keyCodes = {
-      esc: 27,
-      tab: 9,
-      enter: 13,
-      space: 32,
-      up: 38,
-      left: 37,
-      right: 39,
-      down: 40,
-      delete: [8, 46],
-  };
-  // KeyboardEvent.key aliases
-  const keyNames = {
-      // #7880: IE11 and Edge use `Esc` for Escape key name.
-      esc: ['Esc', 'Escape'],
-      tab: 'Tab',
-      enter: 'Enter',
-      // #9112: IE11 uses `Spacebar` for Space key name.
-      space: [' ', 'Spacebar'],
-      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-      up: ['Up', 'ArrowUp'],
-      left: ['Left', 'ArrowLeft'],
-      right: ['Right', 'ArrowRight'],
-      down: ['Down', 'ArrowDown'],
-      // #9112: IE11 uses `Del` for Delete key name.
-      delete: ['Backspace', 'Delete', 'Del'],
+  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+  const fnInvokeRE = /\([^)]*?\);*$/;
+  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+  // KeyboardEvent.keyCode aliases
+  const keyCodes = {
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
+  };
+  // KeyboardEvent.key aliases
+  const keyNames = {
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
+  };
+  // #4868: modifiers that prevent the execution of the listener
+  // need to explicitly return null so that we can determine whether to remove
+  // the listener for .once
+  const genGuard = (condition) => `if(${condition})return null;`;
+  const modifierCode = {
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard(`$event.target !== $event.currentTarget`),
+      ctrl: genGuard(`!$event.ctrlKey`),
+      shift: genGuard(`!$event.shiftKey`),
+      alt: genGuard(`!$event.altKey`),
+      meta: genGuard(`!$event.metaKey`),
+      left: genGuard(`'button' in $event && $event.button !== 0`),
+      middle: genGuard(`'button' in $event && $event.button !== 1`),
+      right: genGuard(`'button' in $event && $event.button !== 2`),
+  };
+  function genHandlers(events, isNative) {
+      const prefix = isNative ? 'nativeOn:' : 'on:';
+      let staticHandlers = ``;
+      let dynamicHandlers = ``;
+      for (const name in events) {
+          const handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += `${name},${handlerCode},`;
+          }
+          else {
+              staticHandlers += `"${name}":${handlerCode},`;
+          }
+      }
+      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+      if (dynamicHandlers) {
+          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+      }
+      else {
+          return prefix + staticHandlers;
+      }
+  }
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+      }
+      const isMethodPath = simplePathRE.test(handler.value);
+      const isFunctionExpression = fnExpRE.test(handler.value);
+      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+      }
+      else {
+          let code = '';
+          let genModifierCode = '';
+          const keys = [];
+          for (const key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  const modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter((keyModifier) => !modifiers[keyModifier])
+                      .map((keyModifier) => `$event.${keyModifier}Key`)
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          const handlerCode = isMethodPath
+              ? `return ${handler.value}.apply(null, arguments)`
+              : isFunctionExpression
+                  ? `return (${handler.value}).apply(null, arguments)`
+                  : isFunctionInvocation
+                      ? `return ${handler.value}`
+                      : handler.value;
+          return `function($event){${code}${handlerCode}}`;
+      }
+  }
+  function genKeyFilter(keys) {
+      return (
+      // make sure the key filters only apply to KeyboardEvents
+      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+      // key events that do not have keyCode property...
+      `if(!$event.type.indexOf('key')&&` +
+          `${keys.map(genFilterCode).join('&&')})return null;`);
+  }
+  function genFilterCode(key) {
+      const keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return `$event.keyCode!==${keyVal}`;
+      }
+      const keyCode = keyCodes[key];
+      const keyName = keyNames[key];
+      return (`_k($event.keyCode,` +
+          `${JSON.stringify(key)},` +
+          `${JSON.stringify(keyCode)},` +
+          `$event.key,` +
+          `${JSON.stringify(keyName)}` +
+          `)`);
+  }
+
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn$2(`v-on without argument does not support modifiers.`);
+      }
+      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+  }
+
+  function bind(el, dir) {
+      el.wrapData = (code) => {
+          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+      };
+  }
+
+  var baseDirectives = {
+      on,
+      bind,
+      cloak: noop$1,
   };
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  const genGuard = (condition) => `if(${condition})return null;`;
-  const modifierCode = {
-      stop: '$event.stopPropagation();',
-      prevent: '$event.preventDefault();',
-      self: genGuard(`$event.target !== $event.currentTarget`),
-      ctrl: genGuard(`!$event.ctrlKey`),
-      shift: genGuard(`!$event.shiftKey`),
-      alt: genGuard(`!$event.altKey`),
-      meta: genGuard(`!$event.metaKey`),
-      left: genGuard(`'button' in $event && $event.button !== 0`),
-      middle: genGuard(`'button' in $event && $event.button !== 1`),
-      right: genGuard(`'button' in $event && $event.button !== 2`),
-  };
-  function genHandlers(events, isNative) {
-      const prefix = isNative ? 'nativeOn:' : 'on:';
-      let staticHandlers = ``;
-      let dynamicHandlers = ``;
-      for (const name in events) {
-          const handlerCode = genHandler(events[name]);
-          //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += `${name},${handlerCode},`;
-          }
-          else {
-              staticHandlers += `"${name}":${handlerCode},`;
-          }
-      }
-      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-      if (dynamicHandlers) {
-          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-      }
-      else {
-          return prefix + staticHandlers;
-      }
-  }
-  function genHandler(handler) {
-      if (!handler) {
-          return 'function(){}';
-      }
-      if (Array.isArray(handler)) {
-          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-      }
-      const isMethodPath = simplePathRE.test(handler.value);
-      const isFunctionExpression = fnExpRE.test(handler.value);
-      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-      if (!handler.modifiers) {
-          if (isMethodPath || isFunctionExpression) {
-              return handler.value;
-          }
-          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-      }
-      else {
-          let code = '';
-          let genModifierCode = '';
-          const keys = [];
-          for (const key in handler.modifiers) {
-              if (modifierCode[key]) {
-                  genModifierCode += modifierCode[key];
-                  // left/right
-                  if (keyCodes[key]) {
-                      keys.push(key);
-                  }
-              }
-              else if (key === 'exact') {
-                  const modifiers = handler.modifiers;
-                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter((keyModifier) => !modifiers[keyModifier])
-                      .map((keyModifier) => `$event.${keyModifier}Key`)
-                      .join('||'));
-              }
-              else {
-                  keys.push(key);
-              }
-          }
-          if (keys.length) {
-              code += genKeyFilter(keys);
-          }
-          // Make sure modifiers like prevent and stop get executed after key filtering
-          if (genModifierCode) {
-              code += genModifierCode;
-          }
-          const handlerCode = isMethodPath
-              ? `return ${handler.value}.apply(null, arguments)`
-              : isFunctionExpression
-                  ? `return (${handler.value}).apply(null, arguments)`
-                  : isFunctionInvocation
-                      ? `return ${handler.value}`
-                      : handler.value;
-          return `function($event){${code}${handlerCode}}`;
-      }
-  }
-  function genKeyFilter(keys) {
-      return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      `if(!$event.type.indexOf('key')&&` +
-          `${keys.map(genFilterCode).join('&&')})return null;`);
-  }
-  function genFilterCode(key) {
-      const keyVal = parseInt(key, 10);
-      if (keyVal) {
-          return `$event.keyCode!==${keyVal}`;
-      }
-      const keyCode = keyCodes[key];
-      const keyName = keyNames[key];
-      return (`_k($event.keyCode,` +
-          `${JSON.stringify(key)},` +
-          `${JSON.stringify(keyCode)},` +
-          `$event.key,` +
-          `${JSON.stringify(keyName)}` +
-          `)`);
-  }
-
-  function on(el, dir) {
-      if (dir.modifiers) {
-          warn$2(`v-on without argument does not support modifiers.`);
-      }
-      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-  }
 
-  function bind(el, dir) {
-      el.wrapData = (code) => {
-          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-      };
-  }
-
-  var baseDirectives = {
-      on,
-      bind,
-      cloak: noop$1,
-  };
-
-  class CodegenState {
-      options;
-      warn;
-      transforms;
-      dataGenFns;
-      directives;
-      maybeComponent;
-      onceId;
-      staticRenderFns;
-      pre;
-      constructor(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          const isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-  }
-  function generate$1(ast, options) {
-      const state = new CodegenState(options);
-      // fix #11483, Root level <script> tags should not be rendered.
-      const code = ast
-          ? ast.tag === 'script'
-              ? 'null'
-              : genElement(ast, state)
-          : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genElement(el, state) {
-      if (el.parent) {
-          el.pre = el.pre || el.parent.pre;
-      }
-      if (el.staticRoot && !el.staticProcessed) {
-          return genStatic(el, state);
-      }
-      else if (el.once && !el.onceProcessed) {
-          return genOnce(el, state);
-      }
-      else if (el.for && !el.forProcessed) {
-          return genFor(el, state);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-          return genChildren(el, state) || 'void 0';
-      }
-      else if (el.tag === 'slot') {
-          return genSlot(el, state);
-      }
-      else {
-          // component or element
-          let code;
-          if (el.component) {
-              code = genComponent(el.component, el, state);
-          }
-          else {
-              let data;
-              if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData(el, state);
-              }
-              const children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-          }
-          // module transforms
-          for (let i = 0; i < state.transforms.length; i++) {
-              code = state.transforms[i](el, code);
-          }
-          return code;
-      }
-  }
-  // hoist static sub-trees out
-  function genStatic(el, state) {
-      el.staticProcessed = true;
-      // Some elements (templates) need to behave differently inside of a v-pre
-      // node.  All pre nodes are static roots, so we can use this as a location to
-      // wrap a state change and reset it upon exiting the pre node.
-      const originalPreState = state.pre;
-      if (el.pre) {
-          state.pre = el.pre;
-      }
-      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-      state.pre = originalPreState;
-      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-  }
-  // v-once
-  function genOnce(el, state) {
-      el.onceProcessed = true;
-      if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.staticInFor) {
-          let key = '';
-          let parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
-                  break;
-              }
-              parent = parent.parent;
-          }
-          if (!key) {
-              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-              return genElement(el, state);
-          }
-          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-      }
-      else {
-          return genStatic(el, state);
-      }
-  }
-  function genIf(el, state, altGen, altEmpty) {
-      el.ifProcessed = true; // avoid recursion
-      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-  }
-  function genIfConditions(conditions, state, altGen, altEmpty) {
-      if (!conditions.length) {
-          return altEmpty || '_e()';
-      }
-      const condition = conditions.shift();
-      if (condition.exp) {
-          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-      }
-      else {
-          return `${genTernaryExp(condition.block)}`;
-      }
-      // v-if with v-once should generate code like (a)?_m(0):_m(1)
-      function genTernaryExp(el) {
-          return altGen
-              ? altGen(el, state)
-              : el.once
-                  ? genOnce(el, state)
-                  : genElement(el, state);
-      }
-  }
-  function genFor(el, state, altGen, altHelper) {
-      const exp = el.for;
-      const alias = el.alias;
-      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-      if (state.maybeComponent(el) &&
-          el.tag !== 'slot' &&
-          el.tag !== 'template' &&
-          !el.key) {
-          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-              `v-for should have explicit keys. ` +
-              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-      }
-      el.forProcessed = true; // avoid recursion
-      return (`${altHelper || '_l'}((${exp}),` +
-          `function(${alias}${iterator1}${iterator2}){` +
-          `return ${(altGen || genElement)(el, state)}` +
-          '})');
-  }
-  function genData(el, state) {
-      let data = '{';
-      // directives first.
-      // directives may mutate the el's other properties before they are generated.
-      const dirs = genDirectives(el, state);
-      if (dirs)
-          data += dirs + ',';
-      // key
-      if (el.key) {
-          data += `key:${el.key},`;
-      }
-      // ref
-      if (el.ref) {
-          data += `ref:${el.ref},`;
-      }
-      if (el.refInFor) {
-          data += `refInFor:true,`;
-      }
-      // pre
-      if (el.pre) {
-          data += `pre:true,`;
-      }
-      // record original tag name for components using "is" attribute
-      if (el.component) {
-          data += `tag:"${el.tag}",`;
-      }
-      // module data generation functions
-      for (let i = 0; i < state.dataGenFns.length; i++) {
-          data += state.dataGenFns[i](el);
-      }
-      // attributes
-      if (el.attrs) {
-          data += `attrs:${genProps(el.attrs)},`;
-      }
-      // DOM props
-      if (el.props) {
-          data += `domProps:${genProps(el.props)},`;
-      }
-      // event handlers
-      if (el.events) {
-          data += `${genHandlers(el.events, false)},`;
-      }
-      if (el.nativeEvents) {
-          data += `${genHandlers(el.nativeEvents, true)},`;
-      }
-      // slot target
-      // only for non-scoped slots
-      if (el.slotTarget && !el.slotScope) {
-          data += `slot:${el.slotTarget},`;
-      }
-      // scoped slots
-      if (el.scopedSlots) {
-          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-      }
-      // component v-model
-      if (el.model) {
-          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-      }
-      // inline-template
-      if (el.inlineTemplate) {
-          const inlineTemplate = genInlineTemplate(el, state);
-          if (inlineTemplate) {
-              data += `${inlineTemplate},`;
-          }
-      }
-      data = data.replace(/,$/, '') + '}';
-      // v-bind dynamic argument wrap
-      // v-bind with dynamic arguments must be applied using the same v-bind object
-      // merge helper so that class/style/mustUseProp attrs are handled correctly.
-      if (el.dynamicAttrs) {
-          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-      }
-      // v-bind data wrap
-      if (el.wrapData) {
-          data = el.wrapData(data);
-      }
-      // v-on data wrap
-      if (el.wrapListeners) {
-          data = el.wrapListeners(data);
-      }
-      return data;
-  }
-  function genDirectives(el, state) {
-      const dirs = el.directives;
-      if (!dirs)
-          return;
-      let res = 'directives:[';
-      let hasRuntime = false;
-      let i, l, dir, needRuntime;
-      for (i = 0, l = dirs.length; i < l; i++) {
-          dir = dirs[i];
-          needRuntime = true;
-          const gen = state.directives[dir.name];
-          if (gen) {
-              // compile-time directive that manipulates AST.
-              // returns true if it also needs a runtime counterpart.
-              needRuntime = !!gen(el, dir, state.warn);
-          }
-          if (needRuntime) {
-              hasRuntime = true;
-              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-          }
-      }
-      if (hasRuntime) {
-          return res.slice(0, -1) + ']';
-      }
-  }
-  function genInlineTemplate(el, state) {
-      const ast = el.children[0];
-      if ((el.children.length !== 1 || ast.type !== 1)) {
-          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-      }
-      if (ast && ast.type === 1) {
-          const inlineRenderFns = generate$1(ast, state.options);
-          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-      }
-  }
-  function genScopedSlots(el, slots, state) {
-      // by default scoped slots are considered "stable", this allows child
-      // components with only scoped slots to skip forced updates from parent.
-      // but in some cases we have to bail-out of this optimization
-      // for example if the slot contains dynamic names, has v-if or v-for on them...
-      let needsForceUpdate = el.for ||
-          Object.keys(slots).some((key) => {
-              const slot = slots[key];
-              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-              );
-          });
-      // #9534: if a component with scoped slots is inside a conditional branch,
-      // it's possible for the same component to be reused but with different
-      // compiled slot content. To avoid that, we generate a unique key based on
-      // the generated code of all the slot contents.
-      let needsKey = !!el.if;
-      // OR when it is inside another scoped slot or v-for (the reactivity may be
-      // disconnected due to the intermediate scope variable)
-      // #9438, #9506
-      // TODO: this can be further optimized by properly analyzing in-scope bindings
-      // and skip force updating ones that do not actually use scope variables.
-      if (!needsForceUpdate) {
-          let parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
-                  needsForceUpdate = true;
-                  break;
-              }
-              if (parent.if) {
-                  needsKey = true;
-              }
-              parent = parent.parent;
-          }
-      }
-      const generatedSlots = Object.keys(slots)
-          .map((key) => genScopedSlot(slots[key], state))
-          .join(',');
-      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-  }
-  function hash(str) {
-      let hash = 5381;
-      let i = str.length;
-      while (i) {
-          hash = (hash * 33) ^ str.charCodeAt(--i);
-      }
-      return hash >>> 0;
-  }
-  function containsSlotChild(el) {
-      if (el.type === 1) {
-          if (el.tag === 'slot') {
-              return true;
-          }
-          return el.children.some(containsSlotChild);
-      }
-      return false;
-  }
-  function genScopedSlot(el, state) {
-      const isLegacySyntax = el.attrsMap['slot-scope'];
-      if (el.if && !el.ifProcessed && !isLegacySyntax) {
-          return genIf(el, state, genScopedSlot, `null`);
-      }
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genScopedSlot);
-      }
-      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-      const fn = `function(${slotScope}){` +
-          `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-      // reverse proxy v-slot without scope on this.$slots
-      const reverseProxy = slotScope ? `` : `,proxy:true`;
-      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-  }
-  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-      const children = el.children;
-      if (children.length) {
-          const el = children[0];
-          // optimize single v-for
-          if (children.length === 1 &&
-              el.for &&
-              el.tag !== 'template' &&
-              el.tag !== 'slot') {
-              const normalizationType = checkSkip
-                  ? state.maybeComponent(el)
-                      ? `,1`
-                      : `,0`
-                  : ``;
-              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-          }
-          const normalizationType = checkSkip
-              ? getNormalizationType(children, state.maybeComponent)
-              : 0;
-          const gen = altGenNode || genNode;
-          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-      }
-  }
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType(children, maybeComponent) {
-      let res = 0;
-      for (let i = 0; i < children.length; i++) {
-          const el = children[i];
-          if (el.type !== 1) {
-              continue;
-          }
-          if (needsNormalization(el) ||
-              (el.ifConditions &&
-                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
-              res = 2;
-              break;
-          }
-          if (maybeComponent(el) ||
-              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-              res = 1;
-          }
-      }
-      return res;
-  }
-  function needsNormalization(el) {
-      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-  }
-  function genNode(node, state) {
-      if (node.type === 1) {
-          return genElement(node, state);
-      }
-      else if (node.type === 3 && node.isComment) {
-          return genComment(node);
-      }
-      else {
-          return genText(node);
-      }
-  }
-  function genText(text) {
-      return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-  }
-  function genComment(comment) {
-      return `_e(${JSON.stringify(comment.text)})`;
-  }
-  function genSlot(el, state) {
-      const slotName = el.slotName || '"default"';
-      const children = genChildren(el, state);
-      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-      const attrs = el.attrs || el.dynamicAttrs
-          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-              // slot props are camelized
-              name: camelize(attr.name),
-              value: attr.value,
-              dynamic: attr.dynamic
-          })))
-          : null;
-      const bind = el.attrsMap['v-bind'];
-      if ((attrs || bind) && !children) {
-          res += `,null`;
-      }
-      if (attrs) {
-          res += `,${attrs}`;
-      }
-      if (bind) {
-          res += `${attrs ? '' : ',null'},${bind}`;
-      }
-      return res + ')';
-  }
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent(componentName, el, state) {
-      const children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-  }
-  function genProps(props) {
-      let staticProps = ``;
-      let dynamicProps = ``;
-      for (let i = 0; i < props.length; i++) {
-          const prop = props[i];
-          const value = transformSpecialNewlines(prop.value);
-          if (prop.dynamic) {
-              dynamicProps += `${prop.name},${value},`;
-          }
-          else {
-              staticProps += `"${prop.name}":${value},`;
-          }
-      }
-      staticProps = `{${staticProps.slice(0, -1)}}`;
-      if (dynamicProps) {
-          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-      }
-      else {
-          return staticProps;
-      }
-  }
-  // #3895, #4268
-  function transformSpecialNewlines(text) {
-      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-  }
-
-  const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-  // let the model AST transform translate v-model into appropriate
-  // props bindings
-  function applyModelTransform(el, state) {
-      if (el.directives) {
-          for (let i = 0; i < el.directives.length; i++) {
-              const dir = el.directives[i];
-              if (dir.name === 'model') {
-                  state.directives.model(el, dir, state.warn);
-                  // remove value for textarea as its converted to text
-                  if (el.tag === 'textarea' && el.props) {
-                      el.props = el.props.filter((p) => p.name !== 'value');
-                  }
-                  break;
-              }
-          }
-      }
-  }
-  function genAttrSegments(attrs) {
-      return attrs.map(({ name, value }) => genAttrSegment(name, value));
-  }
-  function genDOMPropSegments(props, attrs) {
-      const segments = [];
-      props.forEach(({ name, value }) => {
-          name = propsToAttrMap[name] || name.toLowerCase();
-          if (isRenderableAttr(name) &&
-              !(attrs && attrs.some((a) => a.name === name))) {
-              segments.push(genAttrSegment(name, value));
-          }
-      });
-      return segments;
-  }
-  function genAttrSegment(name, value) {
-      if (plainStringRE.test(value)) {
-          // force double quote
-          value = value.replace(/^'|'$/g, '"');
-          // force enumerated attr to "true"
-          if (isEnumeratedAttr(name) && value !== `"false"`) {
-              value = `"true"`;
-          }
-          return {
-              type: RAW,
-              value: isBooleanAttr(name)
-                  ? ` ${name}="${name}"`
-                  : value === '""'
-                      ? ` ${name}`
-                      : ` ${name}="${JSON.parse(value)}"`,
-          };
-      }
-      else {
-          return {
-              type: EXPRESSION,
-              value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-          };
-      }
-  }
-  function genClassSegments(staticClass, classBinding) {
-      if (staticClass && !classBinding) {
-          return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-      }
-      else {
-          return [
-              {
-                  type: EXPRESSION,
-                  value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-              },
-          ];
-      }
-  }
-  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-      if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-      }
-      else {
-          return [
-              {
-                  type: EXPRESSION,
-                  value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-              },
-          ];
-      }
-  }
-
-  /**
-   * In SSR, the vdom tree is generated only once and never patched, so
-   * we can optimize most element / trees into plain string render functions.
-   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-   *
-   * The criteria for SSR optimizability is quite a bit looser than static tree
-   * detection (which is designed for client re-render). In SSR we bail only for
-   * components/slots/custom directives.
-   */
-  // optimizability constants
-  const optimizability = {
-      FALSE: 0,
-      FULL: 1,
-      SELF: 2,
-      CHILDREN: 3,
-      PARTIAL: 4, // self un-optimizable with some un-optimizable children
-  };
-  let isPlatformReservedTag;
-  function optimize(root, options) {
-      if (!root)
-          return;
-      isPlatformReservedTag = options.isReservedTag || no;
-      walk(root, true);
-  }
-  function walk(node, isRoot) {
-      if (isUnOptimizableTree(node)) {
-          node.ssrOptimizability = optimizability.FALSE;
-          return;
-      }
-      // root node or nodes with custom directives should always be a VNode
-      const selfUnoptimizable = isRoot || hasCustomDirective(node);
-      const check = (child) => {
-          if (child.ssrOptimizability !== optimizability.FULL) {
-              node.ssrOptimizability = selfUnoptimizable
-                  ? optimizability.PARTIAL
-                  : optimizability.SELF;
-          }
-      };
-      if (selfUnoptimizable) {
-          node.ssrOptimizability = optimizability.CHILDREN;
-      }
-      if (node.type === 1) {
-          for (let i = 0, l = node.children.length; i < l; i++) {
-              const child = node.children[i];
-              walk(child);
-              check(child);
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  const block = node.ifConditions[i].block;
-                  walk(block, isRoot);
-                  check(block);
-              }
-          }
-          if (node.ssrOptimizability == null ||
-              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-              node.ssrOptimizability = optimizability.FULL;
-          }
-          else {
-              node.children = optimizeSiblings(node);
-          }
-      }
-      else {
-          node.ssrOptimizability = optimizability.FULL;
-      }
-  }
-  function optimizeSiblings(el) {
-      const children = el.children;
-      const optimizedChildren = [];
-      let currentOptimizableGroup = [];
-      const pushGroup = () => {
-          if (currentOptimizableGroup.length) {
-              optimizedChildren.push({
-                  type: 1,
-                  parent: el,
-                  tag: 'template',
-                  attrsList: [],
-                  attrsMap: {},
-                  rawAttrsMap: {},
-                  children: currentOptimizableGroup,
-                  ssrOptimizability: optimizability.FULL,
-              });
-          }
-          currentOptimizableGroup = [];
-      };
-      for (let i = 0; i < children.length; i++) {
-          const c = children[i];
-          if (c.ssrOptimizability === optimizability.FULL) {
-              currentOptimizableGroup.push(c);
-          }
-          else {
-              // wrap fully-optimizable adjacent siblings inside a template tag
-              // so that they can be optimized into a single ssrNode by codegen
-              pushGroup();
-              optimizedChildren.push(c);
-          }
-      }
-      pushGroup();
-      return optimizedChildren;
-  }
-  function isUnOptimizableTree(node) {
-      if (node.type === 2 || node.type === 3) {
-          // text or expression
-          return false;
-      }
-      return (isBuiltInTag(node.tag) || // built-in (slot, component)
-          !isPlatformReservedTag(node.tag) || // custom component
-          !!node.component || // "is" component
-          isSelectWithModel(node) // <select v-model> requires runtime inspection
-      );
-  }
-  const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-  function hasCustomDirective(node) {
-      return (node.type === 1 &&
-          node.directives &&
-          node.directives.some((d) => !isBuiltInDir(d.name)));
-  }
-  // <select v-model> cannot be optimized because it requires a runtime check
-  // to determine proper selected option
-  function isSelectWithModel(node) {
-      return (node.type === 1 &&
-          node.tag === 'select' &&
-          node.directives != null &&
-          node.directives.some((d) => d.name === 'model'));
-  }
-
-  // The SSR codegen is essentially extending the default codegen to handle
-  // segment types
-  const RAW = 0;
-  const INTERPOLATION = 1;
-  const EXPRESSION = 2;
-  function generate(ast, options) {
-      const state = new CodegenState(options);
-      const code = ast ? genSSRElement(ast, state) : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genSSRElement(el, state) {
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genSSRElement);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state, genSSRElement);
-      }
-      else if (el.tag === 'template' && !el.slotTarget) {
-          return el.ssrOptimizability === optimizability.FULL
-              ? genChildrenAsStringNode(el, state)
-              : genSSRChildren(el, state) || 'void 0';
-      }
-      switch (el.ssrOptimizability) {
-          case optimizability.FULL:
-              // stringify whole tree
-              return genStringElement(el, state);
-          case optimizability.SELF:
-              // stringify self and check children
-              return genStringElementWithChildren(el, state);
-          case optimizability.CHILDREN:
-              // generate self as VNode and stringify children
-              return genNormalElement(el, state, true);
-          case optimizability.PARTIAL:
-              // generate self as VNode and check children
-              return genNormalElement(el, state, false);
-          default:
-              // bail whole tree
-              return genElement(el, state);
-      }
-  }
-  function genNormalElement(el, state, stringifyChildren) {
-      const data = el.plain ? undefined : genData(el, state);
-      const children = stringifyChildren
-          ? `[${genChildrenAsStringNode(el, state)}]`
-          : genSSRChildren(el, state, true);
-      return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-  }
-  function genSSRChildren(el, state, checkSkip) {
-      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-  }
-  function genSSRNode(el, state) {
-      return el.type === 1 ? genSSRElement(el, state) : genText(el);
-  }
-  function genChildrenAsStringNode(el, state) {
-      return el.children.length
-          ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-          : '';
-  }
-  function genStringElement(el, state) {
-      return `_ssrNode(${elementToString(el, state)})`;
-  }
-  function genStringElementWithChildren(el, state) {
-      const children = genSSRChildren(el, state, true);
-      return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-  }
-  function elementToString(el, state) {
-      return `(${flattenSegments(elementToSegments(el, state))})`;
-  }
-  function elementToSegments(el, state) {
-      // v-for / v-if
-      if (el.for && !el.forProcessed) {
-          el.forProcessed = true;
-          return [
-              {
-                  type: EXPRESSION,
-                  value: genFor(el, state, elementToString, '_ssrList'),
-              },
-          ];
-      }
-      else if (el.if && !el.ifProcessed) {
-          el.ifProcessed = true;
-          return [
-              {
-                  type: EXPRESSION,
-                  value: genIf(el, state, elementToString, '"<!---->"'),
-              },
-          ];
-      }
-      else if (el.tag === 'template') {
-          return childrenToSegments(el, state);
-      }
-      const openSegments = elementToOpenTagSegments(el, state);
-      const childrenSegments = childrenToSegments(el, state);
-      const { isUnaryTag } = state.options;
-      const close = isUnaryTag && isUnaryTag(el.tag)
-          ? []
-          : [{ type: RAW, value: `</${el.tag}>` }];
-      return openSegments.concat(childrenSegments, close);
-  }
-  function elementToOpenTagSegments(el, state) {
-      applyModelTransform(el, state);
-      let binding;
-      const segments = [{ type: RAW, value: `<${el.tag}` }];
-      // attrs
-      if (el.attrs) {
-          segments.push.apply(segments, genAttrSegments(el.attrs));
-      }
-      // domProps
-      if (el.props) {
-          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-      }
-      // v-bind="object"
-      if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-      }
-      // v-bind.prop="object"
-      if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-      }
-      // class
-      if (el.staticClass || el.classBinding) {
-          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-      }
-      // style & v-show
-      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-      }
-      // _scopedId
-      if (state.options.scopeId) {
-          segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-      }
-      segments.push({ type: RAW, value: `>` });
-      return segments;
-  }
-  function childrenToSegments(el, state) {
-      let binding;
-      if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: `_s(${binding})` }];
-      }
-      if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-      }
-      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-      }
-      return el.children ? nodesToSegments(el.children, state) : [];
-  }
-  function nodesToSegments(children, state) {
-      const segments = [];
-      for (let i = 0; i < children.length; i++) {
-          const c = children[i];
-          if (c.type === 1) {
-              segments.push.apply(segments, elementToSegments(c, state));
-          }
-          else if (c.type === 2) {
-              segments.push({ type: INTERPOLATION, value: c.expression });
-          }
-          else if (c.type === 3) {
-              let text = escape(c.text);
-              if (c.isComment) {
-                  text = '<!--' + text + '-->';
-              }
-              segments.push({ type: RAW, value: text });
-          }
-      }
-      return segments;
-  }
-  function flattenSegments(segments) {
-      const mergedSegments = [];
-      let textBuffer = '';
-      const pushBuffer = () => {
-          if (textBuffer) {
-              mergedSegments.push(JSON.stringify(textBuffer));
-              textBuffer = '';
-          }
-      };
-      for (let i = 0; i < segments.length; i++) {
-          const s = segments[i];
-          if (s.type === RAW) {
-              textBuffer += s.value;
-          }
-          else if (s.type === INTERPOLATION) {
-              pushBuffer();
-              mergedSegments.push(`_ssrEscape(${s.value})`);
-          }
-          else if (s.type === EXPRESSION) {
-              pushBuffer();
-              mergedSegments.push(`(${s.value})`);
-          }
-      }
-      pushBuffer();
-      return mergedSegments.join('+');
-  }
-
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  const prohibitedKeywordRE = new RegExp('\\b' +
-      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-          'super,throw,while,yield,delete,export,import,return,switch,default,' +
-          'extends,finally,continue,debugger,function,arguments')
-          .split(',')
-          .join('\\b|\\b') +
-      '\\b');
-  // these unary operators should not be used as property/method names
-  const unaryOperatorsRE = new RegExp('\\b' +
-      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-      '\\s*\\([^\\)]*\\)');
-  // strip strings in expressions
-  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-  // detect problematic expressions in a template
-  function detectErrors(ast, warn) {
-      if (ast) {
-          checkNode(ast, warn);
-      }
-  }
-  function checkNode(node, warn) {
-      if (node.type === 1) {
-          for (const name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  const value = node.attrsMap[name];
-                  if (value) {
-                      const range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, `v-for="${value}"`, warn, range);
-                      }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, `${name}="${value}"`, warn, range);
-                      }
-                      else {
-                          checkExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                  }
-              }
-          }
-          if (node.children) {
-              for (let i = 0; i < node.children.length; i++) {
-                  checkNode(node.children[i], warn);
-              }
-          }
-      }
-      else if (node.type === 2) {
-          checkExpression(node.expression, node.text, warn, node);
-      }
-  }
-  function checkEvent(exp, text, warn, range) {
-      const stripped = exp.replace(stripStringRE, '');
-      const keywordMatch = stripped.match(unaryOperatorsRE);
-      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-          warn(`avoid using JavaScript unary operator as property name: ` +
-              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-      }
-      checkExpression(exp, text, warn, range);
-  }
-  function checkFor(node, text, warn, range) {
-      checkExpression(node.for || '', text, warn, range);
-      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-  }
-  function checkIdentifier(ident, type, text, warn, range) {
-      if (typeof ident === 'string') {
-          try {
-              new Function(`var ${ident}=_`);
-          }
-          catch (e) {
-              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-          }
-      }
-  }
-  function checkExpression(exp, text, warn, range) {
-      try {
-          new Function(`return ${exp}`);
-      }
-      catch (e) {
-          const keywordMatch = exp
-              .replace(stripStringRE, '')
-              .match(prohibitedKeywordRE);
-          if (keywordMatch) {
-              warn(`avoid using JavaScript keyword as property name: ` +
-                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-          }
-          else {
-              warn(`invalid expression: ${e.message} in\n\n` +
-                  `    ${exp}\n\n` +
-                  `  Raw expression: ${text.trim()}\n`, range);
-          }
-      }
-  }
-  function checkFunctionParameterExpression(exp, text, warn, range) {
-      try {
-          new Function(exp, '');
-      }
-      catch (e) {
-          warn(`invalid function parameter expression: ${e.message} in\n\n` +
-              `    ${exp}\n\n` +
-              `  Raw expression: ${text.trim()}\n`, range);
-      }
-  }
-
-  const range = 2;
-  function generateCodeFrame(source, start = 0, end = source.length) {
-      const lines = source.split(/\r?\n/);
-      let count = 0;
-      const res = [];
-      for (let i = 0; i < lines.length; i++) {
-          count += lines[i].length + 1;
-          if (count >= start) {
-              for (let j = i - range; j <= i + range || end > count; j++) {
-                  if (j < 0 || j >= lines.length)
-                      continue;
-                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                  const lineLength = lines[j].length;
-                  if (j === i) {
-                      // push underline
-                      const pad = start - (count - lineLength) + 1;
-                      const length = end > count ? lineLength - pad : end - start;
-                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                  }
-                  else if (j > i) {
-                      if (end > count) {
-                          const length = Math.min(end - count, lineLength);
-                          res.push(`   |  ` + repeat(`^`, length));
-                      }
-                      count += lineLength + 1;
-                  }
-              }
-              break;
-          }
-      }
-      return res.join('\n');
-  }
-  function repeat(str, n) {
-      let result = '';
-      if (n > 0) {
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-              // eslint-disable-line
-              if (n & 1)
-                  result += str;
-              n >>>= 1;
-              if (n <= 0)
-                  break;
-              str += str;
-          }
-      }
-      return result;
-  }
-
-  function createFunction(code, errors) {
-      try {
-          return new Function(code);
-      }
-      catch (err) {
-          errors.push({ err, code });
-          return noop$1;
-      }
-  }
-  function createCompileToFunctionFn(compile) {
-      const cache = Object.create(null);
-      return function compileToFunctions(template, options, vm) {
-          options = extend({}, options);
-          const warn = options.warn || warn$2;
-          delete options.warn;
-          /* istanbul ignore if */
-          {
-              // detect possible CSP restriction
-              try {
-                  new Function('return 1');
-              }
-              catch (e) {
-                  if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn('It seems you are using the standalone build of Vue.js in an ' +
-                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                          'The template compiler cannot work in this environment. Consider ' +
-                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                          'templates into render functions.');
-                  }
-              }
-          }
-          // check cache
-          const key = options.delimiters
-              ? String(options.delimiters) + template
-              : template;
-          if (cache[key]) {
-              return cache[key];
-          }
-          // compile
-          const compiled = compile(template, options);
-          // check compilation errors/tips
-          {
-              if (compiled.errors && compiled.errors.length) {
-                  if (options.outputSourceRange) {
-                      compiled.errors.forEach((e) => {
-                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                              generateCodeFrame(template, e.start, e.end), vm);
-                      });
-                  }
-                  else {
-                      warn(`Error compiling template:\n\n${template}\n\n` +
-                          compiled.errors.map((e) => `- ${e}`).join('\n') +
-                          '\n', vm);
-                  }
-              }
-              if (compiled.tips && compiled.tips.length) {
-                  if (options.outputSourceRange) {
-                      compiled.tips.forEach((e) => tip(e.msg, vm));
-                  }
-                  else {
-                      compiled.tips.forEach((msg) => tip(msg, vm));
-                  }
-              }
-          }
-          // turn code into functions
-          const res = {};
-          const fnGenErrors = [];
-          res.render = createFunction(compiled.render, fnGenErrors);
-          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-              return createFunction(code, fnGenErrors);
-          });
-          // check function generation errors.
-          // this should only happen if there is a bug in the compiler itself.
-          // mostly for codegen development use
-          /* istanbul ignore if */
-          {
-              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn(`Failed to generate render function:\n\n` +
-                      fnGenErrors
-                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                          .join('\n'), vm);
-              }
-          }
-          return (cache[key] = res);
-      };
-  }
-
-  function createCompilerCreator(baseCompile) {
-      return function createCompiler(baseOptions) {
-          function compile(template, options) {
-              const finalOptions = Object.create(baseOptions);
-              const errors = [];
-              const tips = [];
-              let warn = (msg, range, tip) => {
-                  (tip ? tips : errors).push(msg);
-              };
-              if (options) {
-                  if (options.outputSourceRange) {
-                      // $flow-disable-line
-                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                      warn = (msg, range, tip) => {
-                          const data = { msg };
-                          if (range) {
-                              if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
-                              }
-                              if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
-                              }
-                          }
-                          (tip ? tips : errors).push(data);
-                      };
-                  }
-                  // merge custom modules
-                  if (options.modules) {
-                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                  }
-                  // merge custom directives
-                  if (options.directives) {
-                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                  }
-                  // copy other options
-                  for (const key in options) {
-                      if (key !== 'modules' && key !== 'directives') {
-                          finalOptions[key] = options[key];
-                      }
-                  }
-              }
-              finalOptions.warn = warn;
-              const compiled = baseCompile(template.trim(), finalOptions);
-              {
-                  detectErrors(compiled.ast, warn);
-              }
-              compiled.errors = errors;
-              compiled.tips = tips;
-              return compiled;
-          }
-          return {
-              compile,
-              compileToFunctions: createCompileToFunctionFn(compile),
-          };
-      };
-  }
-
-  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-      const ast = parse(template.trim(), options);
-      optimize(ast, options);
-      const code = generate(ast, options);
-      return {
-          ast,
-          render: code.render,
-          staticRenderFns: code.staticRenderFns,
-      };
+  class CodegenState {
+      options;
+      warn;
+      transforms;
+      dataGenFns;
+      directives;
+      maybeComponent;
+      onceId;
+      staticRenderFns;
+      pre;
+      constructor(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          const isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+  }
+  function generate$1(ast, options) {
+      const state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      const code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
+      }
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
+      }
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
+      }
+      else {
+          // component or element
+          let code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              let data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData(el, state);
+              }
+              const children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+          }
+          // module transforms
+          for (let i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
+      }
+  }
+  // hoist static sub-trees out
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      const originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+      state.pre = originalPreState;
+      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+  }
+  // v-once
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.staticInFor) {
+          let key = '';
+          let parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      const condition = conditions.shift();
+      if (condition.exp) {
+          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+      }
+      else {
+          return `${genTernaryExp(condition.block)}`;
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      const exp = el.for;
+      const alias = el.alias;
+      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+              `v-for should have explicit keys. ` +
+              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return (`${altHelper || '_l'}((${exp}),` +
+          `function(${alias}${iterator1}${iterator2}){` +
+          `return ${(altGen || genElement)(el, state)}` +
+          '})');
+  }
+  function genData(el, state) {
+      let data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      const dirs = genDirectives(el, state);
+      if (dirs)
+          data += dirs + ',';
+      // key
+      if (el.key) {
+          data += `key:${el.key},`;
+      }
+      // ref
+      if (el.ref) {
+          data += `ref:${el.ref},`;
+      }
+      if (el.refInFor) {
+          data += `refInFor:true,`;
+      }
+      // pre
+      if (el.pre) {
+          data += `pre:true,`;
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += `tag:"${el.tag}",`;
+      }
+      // module data generation functions
+      for (let i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += `attrs:${genProps(el.attrs)},`;
+      }
+      // DOM props
+      if (el.props) {
+          data += `domProps:${genProps(el.props)},`;
+      }
+      // event handlers
+      if (el.events) {
+          data += `${genHandlers(el.events, false)},`;
+      }
+      if (el.nativeEvents) {
+          data += `${genHandlers(el.nativeEvents, true)},`;
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += `slot:${el.slotTarget},`;
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+      }
+      // component v-model
+      if (el.model) {
+          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          const inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += `${inlineTemplate},`;
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      const dirs = el.directives;
+      if (!dirs)
+          return;
+      let res = 'directives:[';
+      let hasRuntime = false;
+      let i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          const gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
+      }
+  }
+  function genInlineTemplate(el, state) {
+      const ast = el.children[0];
+      if ((el.children.length !== 1 || ast.type !== 1)) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          const inlineRenderFns = generate$1(ast, state.options);
+          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+      }
+  }
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      let needsForceUpdate = el.for ||
+          Object.keys(slots).some((key) => {
+              const slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      let needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          let parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
+      }
+      const generatedSlots = Object.keys(slots)
+          .map((key) => genScopedSlot(slots[key], state))
+          .join(',');
+      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+  }
+  function hash(str) {
+      let hash = 5381;
+      let i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
+      }
+      return hash >>> 0;
+  }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      const isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, `null`);
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+      const fn = `function(${slotScope}){` +
+          `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+      // reverse proxy v-slot without scope on this.$slots
+      const reverseProxy = slotScope ? `` : `,proxy:true`;
+      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      const children = el.children;
+      if (children.length) {
+          const el = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el.for &&
+              el.tag !== 'template' &&
+              el.tag !== 'slot') {
+              const normalizationType = checkSkip
+                  ? state.maybeComponent(el)
+                      ? `,1`
+                      : `,0`
+                  : ``;
+              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+          }
+          const normalizationType = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          const gen = altGenNode || genNode;
+          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+      }
+  }
+  // determine the normalization needed for the children array.
+  // 0: no normalization needed
+  // 1: simple normalization needed (possible 1-level deep nested array)
+  // 2: full normalization needed
+  function getNormalizationType(children, maybeComponent) {
+      let res = 0;
+      for (let i = 0; i < children.length; i++) {
+          const el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+              res = 1;
+          }
+      }
+      return res;
+  }
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+  }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
+  }
+  function genText(text) {
+      return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+  }
+  function genComment(comment) {
+      return `_e(${JSON.stringify(comment.text)})`;
+  }
+  function genSlot(el, state) {
+      const slotName = el.slotName || '"default"';
+      const children = genChildren(el, state);
+      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+      const attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic
+          })))
+          : null;
+      const bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
+          res += `,null`;
+      }
+      if (attrs) {
+          res += `,${attrs}`;
+      }
+      if (bind) {
+          res += `${attrs ? '' : ',null'},${bind}`;
+      }
+      return res + ')';
+  }
+  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
+  function genComponent(componentName, el, state) {
+      const children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+  }
+  function genProps(props) {
+      let staticProps = ``;
+      let dynamicProps = ``;
+      for (let i = 0; i < props.length; i++) {
+          const prop = props[i];
+          const value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += `${prop.name},${value},`;
+          }
+          else {
+              staticProps += `"${prop.name}":${value},`;
+          }
+      }
+      staticProps = `{${staticProps.slice(0, -1)}}`;
+      if (dynamicProps) {
+          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+      }
+      else {
+          return staticProps;
+      }
+  }
+  // #3895, #4268
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+  }
+
+  const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+  // let the model AST transform translate v-model into appropriate
+  // props bindings
+  function applyModelTransform(el, state) {
+      if (el.directives) {
+          for (let i = 0; i < el.directives.length; i++) {
+              const dir = el.directives[i];
+              if (dir.name === 'model') {
+                  state.directives.model(el, dir, state.warn);
+                  // remove value for textarea as its converted to text
+                  if (el.tag === 'textarea' && el.props) {
+                      el.props = el.props.filter((p) => p.name !== 'value');
+                  }
+                  break;
+              }
+          }
+      }
+  }
+  function genAttrSegments(attrs) {
+      return attrs.map(({ name, value }) => genAttrSegment(name, value));
+  }
+  function genDOMPropSegments(props, attrs) {
+      const segments = [];
+      props.forEach(({ name, value }) => {
+          name = propsToAttrMap[name] || name.toLowerCase();
+          if (isRenderableAttr(name) &&
+              !(attrs && attrs.some((a) => a.name === name))) {
+              segments.push(genAttrSegment(name, value));
+          }
+      });
+      return segments;
+  }
+  function genAttrSegment(name, value) {
+      if (plainStringRE.test(value)) {
+          // force double quote
+          value = value.replace(/^'|'$/g, '"');
+          // force enumerated attr to "true"
+          if (isEnumeratedAttr(name) && value !== `"false"`) {
+              value = `"true"`;
+          }
+          return {
+              type: RAW,
+              value: isBooleanAttr(name)
+                  ? ` ${name}="${name}"`
+                  : value === '""'
+                      ? ` ${name}`
+                      : ` ${name}="${JSON.parse(value)}"`,
+          };
+      }
+      else {
+          return {
+              type: EXPRESSION,
+              value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+          };
+      }
+  }
+  function genClassSegments(staticClass, classBinding) {
+      if (staticClass && !classBinding) {
+          return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+              },
+          ];
+      }
+  }
+  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+      if (staticStyle && !styleBinding && !vShowExpression) {
+          return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+              },
+          ];
+      }
+  }
+
+  /**
+   * In SSR, the vdom tree is generated only once and never patched, so
+   * we can optimize most element / trees into plain string render functions.
+   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+   *
+   * The criteria for SSR optimizability is quite a bit looser than static tree
+   * detection (which is designed for client re-render). In SSR we bail only for
+   * components/slots/custom directives.
+   */
+  // optimizability constants
+  const optimizability = {
+      FALSE: 0,
+      FULL: 1,
+      SELF: 2,
+      CHILDREN: 3,
+      PARTIAL: 4, // self un-optimizable with some un-optimizable children
+  };
+  let isPlatformReservedTag;
+  function optimize(root, options) {
+      if (!root)
+          return;
+      isPlatformReservedTag = options.isReservedTag || no;
+      walk(root, true);
+  }
+  function walk(node, isRoot) {
+      if (isUnOptimizableTree(node)) {
+          node.ssrOptimizability = optimizability.FALSE;
+          return;
+      }
+      // root node or nodes with custom directives should always be a VNode
+      const selfUnoptimizable = isRoot || hasCustomDirective(node);
+      const check = (child) => {
+          if (child.ssrOptimizability !== optimizability.FULL) {
+              node.ssrOptimizability = selfUnoptimizable
+                  ? optimizability.PARTIAL
+                  : optimizability.SELF;
+          }
+      };
+      if (selfUnoptimizable) {
+          node.ssrOptimizability = optimizability.CHILDREN;
+      }
+      if (node.type === 1) {
+          for (let i = 0, l = node.children.length; i < l; i++) {
+              const child = node.children[i];
+              walk(child);
+              check(child);
+          }
+          if (node.ifConditions) {
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  const block = node.ifConditions[i].block;
+                  walk(block, isRoot);
+                  check(block);
+              }
+          }
+          if (node.ssrOptimizability == null ||
+              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+              node.ssrOptimizability = optimizability.FULL;
+          }
+          else {
+              node.children = optimizeSiblings(node);
+          }
+      }
+      else {
+          node.ssrOptimizability = optimizability.FULL;
+      }
+  }
+  function optimizeSiblings(el) {
+      const children = el.children;
+      const optimizedChildren = [];
+      let currentOptimizableGroup = [];
+      const pushGroup = () => {
+          if (currentOptimizableGroup.length) {
+              optimizedChildren.push({
+                  type: 1,
+                  parent: el,
+                  tag: 'template',
+                  attrsList: [],
+                  attrsMap: {},
+                  rawAttrsMap: {},
+                  children: currentOptimizableGroup,
+                  ssrOptimizability: optimizability.FULL,
+              });
+          }
+          currentOptimizableGroup = [];
+      };
+      for (let i = 0; i < children.length; i++) {
+          const c = children[i];
+          if (c.ssrOptimizability === optimizability.FULL) {
+              currentOptimizableGroup.push(c);
+          }
+          else {
+              // wrap fully-optimizable adjacent siblings inside a template tag
+              // so that they can be optimized into a single ssrNode by codegen
+              pushGroup();
+              optimizedChildren.push(c);
+          }
+      }
+      pushGroup();
+      return optimizedChildren;
+  }
+  function isUnOptimizableTree(node) {
+      if (node.type === 2 || node.type === 3) {
+          // text or expression
+          return false;
+      }
+      return (isBuiltInTag(node.tag) || // built-in (slot, component)
+          !isPlatformReservedTag(node.tag) || // custom component
+          !!node.component || // "is" component
+          isSelectWithModel(node) // <select v-model> requires runtime inspection
+      );
+  }
+  const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+  function hasCustomDirective(node) {
+      return (node.type === 1 &&
+          node.directives &&
+          node.directives.some((d) => !isBuiltInDir(d.name)));
+  }
+  // <select v-model> cannot be optimized because it requires a runtime check
+  // to determine proper selected option
+  function isSelectWithModel(node) {
+      return (node.type === 1 &&
+          node.tag === 'select' &&
+          node.directives != null &&
+          node.directives.some((d) => d.name === 'model'));
+  }
+
+  // The SSR codegen is essentially extending the default codegen to handle
+  // segment types
+  const RAW = 0;
+  const INTERPOLATION = 1;
+  const EXPRESSION = 2;
+  function generate(ast, options) {
+      const state = new CodegenState(options);
+      const code = ast ? genSSRElement(ast, state) : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genSSRElement(el, state) {
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genSSRElement);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state, genSSRElement);
+      }
+      else if (el.tag === 'template' && !el.slotTarget) {
+          return el.ssrOptimizability === optimizability.FULL
+              ? genChildrenAsStringNode(el, state)
+              : genSSRChildren(el, state) || 'void 0';
+      }
+      switch (el.ssrOptimizability) {
+          case optimizability.FULL:
+              // stringify whole tree
+              return genStringElement(el, state);
+          case optimizability.SELF:
+              // stringify self and check children
+              return genStringElementWithChildren(el, state);
+          case optimizability.CHILDREN:
+              // generate self as VNode and stringify children
+              return genNormalElement(el, state, true);
+          case optimizability.PARTIAL:
+              // generate self as VNode and check children
+              return genNormalElement(el, state, false);
+          default:
+              // bail whole tree
+              return genElement(el, state);
+      }
+  }
+  function genNormalElement(el, state, stringifyChildren) {
+      const data = el.plain ? undefined : genData(el, state);
+      const children = stringifyChildren
+          ? `[${genChildrenAsStringNode(el, state)}]`
+          : genSSRChildren(el, state, true);
+      return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+  }
+  function genSSRChildren(el, state, checkSkip) {
+      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+  }
+  function genSSRNode(el, state) {
+      return el.type === 1 ? genSSRElement(el, state) : genText(el);
+  }
+  function genChildrenAsStringNode(el, state) {
+      return el.children.length
+          ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+          : '';
+  }
+  function genStringElement(el, state) {
+      return `_ssrNode(${elementToString(el, state)})`;
+  }
+  function genStringElementWithChildren(el, state) {
+      const children = genSSRChildren(el, state, true);
+      return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+  }
+  function elementToString(el, state) {
+      return `(${flattenSegments(elementToSegments(el, state))})`;
+  }
+  function elementToSegments(el, state) {
+      // v-for / v-if
+      if (el.for && !el.forProcessed) {
+          el.forProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genFor(el, state, elementToString, '_ssrList'),
+              },
+          ];
+      }
+      else if (el.if && !el.ifProcessed) {
+          el.ifProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genIf(el, state, elementToString, '"<!---->"'),
+              },
+          ];
+      }
+      else if (el.tag === 'template') {
+          return childrenToSegments(el, state);
+      }
+      const openSegments = elementToOpenTagSegments(el, state);
+      const childrenSegments = childrenToSegments(el, state);
+      const { isUnaryTag } = state.options;
+      const close = isUnaryTag && isUnaryTag(el.tag)
+          ? []
+          : [{ type: RAW, value: `</${el.tag}>` }];
+      return openSegments.concat(childrenSegments, close);
+  }
+  function elementToOpenTagSegments(el, state) {
+      applyModelTransform(el, state);
+      let binding;
+      const segments = [{ type: RAW, value: `<${el.tag}` }];
+      // attrs
+      if (el.attrs) {
+          segments.push.apply(segments, genAttrSegments(el.attrs));
+      }
+      // domProps
+      if (el.props) {
+          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+      }
+      // v-bind="object"
+      if ((binding = el.attrsMap['v-bind'])) {
+          segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+      }
+      // v-bind.prop="object"
+      if ((binding = el.attrsMap['v-bind.prop'])) {
+          segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+      }
+      // class
+      if (el.staticClass || el.classBinding) {
+          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+      }
+      // style & v-show
+      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+      }
+      // _scopedId
+      if (state.options.scopeId) {
+          segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+      }
+      segments.push({ type: RAW, value: `>` });
+      return segments;
+  }
+  function childrenToSegments(el, state) {
+      let binding;
+      if ((binding = el.attrsMap['v-html'])) {
+          return [{ type: EXPRESSION, value: `_s(${binding})` }];
+      }
+      if ((binding = el.attrsMap['v-text'])) {
+          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+      }
+      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+      }
+      return el.children ? nodesToSegments(el.children, state) : [];
+  }
+  function nodesToSegments(children, state) {
+      const segments = [];
+      for (let i = 0; i < children.length; i++) {
+          const c = children[i];
+          if (c.type === 1) {
+              segments.push.apply(segments, elementToSegments(c, state));
+          }
+          else if (c.type === 2) {
+              segments.push({ type: INTERPOLATION, value: c.expression });
+          }
+          else if (c.type === 3) {
+              let text = escape(c.text);
+              if (c.isComment) {
+                  text = '<!--' + text + '-->';
+              }
+              segments.push({ type: RAW, value: text });
+          }
+      }
+      return segments;
+  }
+  function flattenSegments(segments) {
+      const mergedSegments = [];
+      let textBuffer = '';
+      const pushBuffer = () => {
+          if (textBuffer) {
+              mergedSegments.push(JSON.stringify(textBuffer));
+              textBuffer = '';
+          }
+      };
+      for (let i = 0; i < segments.length; i++) {
+          const s = segments[i];
+          if (s.type === RAW) {
+              textBuffer += s.value;
+          }
+          else if (s.type === INTERPOLATION) {
+              pushBuffer();
+              mergedSegments.push(`_ssrEscape(${s.value})`);
+          }
+          else if (s.type === EXPRESSION) {
+              pushBuffer();
+              mergedSegments.push(`(${s.value})`);
+          }
+      }
+      pushBuffer();
+      return mergedSegments.join('+');
+  }
+
+  // these keywords should not appear inside expressions, but operators like
+  // typeof, instanceof and in are allowed
+  const prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
+  // these unary operators should not be used as property/method names
+  const unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
+  // strip strings in expressions
+  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+  // detect problematic expressions in a template
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (const name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  const value = node.attrsMap[name];
+                  if (value) {
+                      const range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, `v-for="${value}"`, warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, `${name}="${value}"`, warn, range);
+                      }
+                      else {
+                          checkExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (let i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
+          }
+      }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
+      }
+  }
+  function checkEvent(exp, text, warn, range) {
+      const stripped = exp.replace(stripStringRE, '');
+      const keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn(`avoid using JavaScript unary operator as property name: ` +
+              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+      }
+      checkExpression(exp, text, warn, range);
+  }
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(`var ${ident}=_`);
+          }
+          catch (e) {
+              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+          }
+      }
+  }
+  function checkExpression(exp, text, warn, range) {
+      try {
+          new Function(`return ${exp}`);
+      }
+      catch (e) {
+          const keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn(`avoid using JavaScript keyword as property name: ` +
+                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+          }
+          else {
+              warn(`invalid expression: ${e.message} in\n\n` +
+                  `    ${exp}\n\n` +
+                  `  Raw expression: ${text.trim()}\n`, range);
+          }
+      }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn(`invalid function parameter expression: ${e.message} in\n\n` +
+              `    ${exp}\n\n` +
+              `  Raw expression: ${text.trim()}\n`, range);
+      }
+  }
+
+  const range = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (let j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      continue;
+                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      const pad = start - (count - lineLength) + 1;
+                      const length = end > count ? lineLength - pad : end - start;
+                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          const length = Math.min(end - count, lineLength);
+                          res.push(`   |  ` + repeat(`^`, length));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
+          }
+      }
+      return res.join('\n');
+  }
+  function repeat(str, n) {
+      let result = '';
+      if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  result += str;
+              n >>>= 1;
+              if (n <= 0)
+                  break;
+              str += str;
+          }
+      }
+      return result;
+  }
+
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
+      }
+      catch (err) {
+          errors.push({ err, code });
+          return noop$1;
+      }
+  }
+  function createCompileToFunctionFn(compile) {
+      const cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          const warn = options.warn || warn$2;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
+          }
+          // check cache
+          const key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
+          }
+          // compile
+          const compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach((e) => {
+                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn(`Error compiling template:\n\n${template}\n\n` +
+                          compiled.errors.map((e) => `- ${e}`).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach((e) => tip(e.msg, vm));
+                  }
+                  else {
+                      compiled.tips.forEach((msg) => tip(msg, vm));
+                  }
+              }
+          }
+          // turn code into functions
+          const res = {};
+          const fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn(`Failed to generate render function:\n\n` +
+                      fnGenErrors
+                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
+  }
+
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              const finalOptions = Object.create(baseOptions);
+              const errors = [];
+              const tips = [];
+              let warn = (msg, range, tip) => {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = (msg, range, tip) => {
+                          const data = typeof (msg) === 'string' ? { msg } : msg;
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (const key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
+              }
+              finalOptions.warn = warn;
+              const compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
+          }
+          return {
+              compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
+  }
+
+  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      const ast = parse(template.trim(), options);
+      optimize(ast, options);
+      const code = generate(ast, options);
+      return {
+          ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
   const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
-  }
-
-  const ssrHelpers = {
-      _ssrEscape: escape,
-      _ssrNode: renderStringNode$1,
-      _ssrList: renderStringList,
-      _ssrAttr: renderAttr,
-      _ssrAttrs: renderAttrs,
-      _ssrDOMProps: renderDOMProps,
-      _ssrClass: renderSSRClass,
-      _ssrStyle: renderSSRStyle,
-  };
-  function installSSRHelpers(vm) {
-      if (vm._ssrNode) {
-          return;
-      }
-      let Vue = vm.constructor;
-      // @ts-expect-error
-      while (Vue.super) {
-          // @ts-expect-error
-          Vue = Vue.super;
-      }
-      extend(Vue.prototype, ssrHelpers);
-      // @ts-expect-error
-      if (Vue.FunctionalRenderContext) {
-          // @ts-expect-error
-          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-      }
-  }
-  class StringNode {
-      isString;
-      open;
-      close;
-      children;
-      constructor(open, close, children, normalizationType) {
-          this.isString = true;
-          this.open = open;
-          this.close = close;
-          if (children) {
-              this.children =
-                  normalizationType === 1
-                      ? simpleNormalizeChildren(children)
-                      : normalizationType === 2
-                          ? normalizeChildren(children)
-                          : children;
-          }
-          else {
-              this.children = void 0;
-          }
-      }
-  }
-  function renderStringNode$1(open, close, children, normalizationType) {
-      return new StringNode(open, close, children, normalizationType);
-  }
-  function renderStringList(val, render) {
-      let ret = '';
-      let i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          for (i = 0, l = val.length; i < l; i++) {
-              ret += render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          for (i = 0; i < val; i++) {
-              ret += render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          keys = Object.keys(val);
-          for (i = 0, l = keys.length; i < l; i++) {
-              key = keys[i];
-              ret += render(val[key], key, i);
-          }
-      }
-      return ret;
-  }
-  function renderAttrs(obj) {
-      let res = '';
-      for (const key in obj) {
-          if (isSSRUnsafeAttr(key)) {
-              continue;
-          }
-          res += renderAttr(key, obj[key]);
-      }
-      return res;
-  }
-  function renderDOMProps(obj) {
-      let res = '';
-      for (const key in obj) {
-          const attr = propsToAttrMap[key] || key.toLowerCase();
-          if (isRenderableAttr(attr)) {
-              res += renderAttr(attr, obj[key]);
-          }
-      }
-      return res;
-  }
-  function renderSSRClass(staticClass, dynamic) {
-      const res = renderClass$1(staticClass, dynamic);
-      return res === '' ? res : ` class="${escape(res)}"`;
-  }
-  function renderSSRStyle(staticStyle, dynamic, extra) {
-      const style = {};
-      if (staticStyle)
-          extend(style, staticStyle);
-      if (dynamic)
-          extend(style, normalizeStyleBinding(dynamic));
-      if (extra)
-          extend(style, extra);
-      const res = genStyle(style);
-      return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
-  }
-
-  /* not type checking this file because flow doesn't play well with Proxy */
-  {
-      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-  }
-
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
-  }
-
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
-  }
-
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
-  }
-
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn$2('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
-  }
-
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
-  }
-
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn$2("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
-  }
-
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
-  }
-
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn$2('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
-  }
-
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
-  }
-
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn$2('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
-  }
-
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
-  }
-
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
-  }
-
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
-  }
-
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
-  }
-
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
-  }
-
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-  }
-
-  let target;
-  function add(event, fn) {
-      target.$on(event, fn);
-  }
-  function remove(event, fn) {
-      target.$off(event, fn);
-  }
-  function createOnceHandler(event, fn) {
-      const _target = target;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target = vm;
-      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
-      target = undefined;
-  }
-
-  let activeInstance = null;
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook(vm, "deactivated");
-      }
-  }
-  function callHook(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
-  }
-
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-  }
-
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn$2(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
-  }
-
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
-  }
-
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
-  }
-
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
-  }
-
-  let warned = Object.create(null);
-  const warnOnce = (msg) => {
-      if (!warned[msg]) {
-          warned[msg] = true;
-          // eslint-disable-next-line no-console
-          console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
-      }
-  };
-  const onCompilationError = (err, vm) => {
-      const trace = vm ? generateComponentTrace(vm) : '';
-      throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
-  };
-  const normalizeRender = (vm) => {
-      const { render, template, _scopeId } = vm.$options;
-      if (isUndef(render)) {
-          if (template) {
-              const compiled = compileToFunctions(template, {
-                  scopeId: _scopeId,
-                  warn: onCompilationError,
-              }, vm);
-              vm.$options.render = compiled.render;
-              vm.$options.staticRenderFns = compiled.staticRenderFns;
-          }
-          else {
-              throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
-          }
-      }
-  };
-  function waitForServerPrefetch(vm, resolve, reject) {
-      let handlers = vm.$options.serverPrefetch;
-      if (isDef(handlers)) {
-          if (!Array.isArray(handlers))
-              handlers = [handlers];
-          try {
-              const promises = [];
-              for (let i = 0, j = handlers.length; i < j; i++) {
-                  const result = handlers[i].call(vm, vm);
-                  if (result && typeof result.then === 'function') {
-                      promises.push(result);
-                  }
-              }
-              Promise.all(promises).then(resolve).catch(reject);
-              return;
-          }
-          catch (e) {
-              reject(e);
-          }
-      }
-      resolve();
-  }
-  function renderNode(node, isRoot, context) {
-      if (node.isString) {
-          renderStringNode(node, context);
-      }
-      else if (isDef(node.componentOptions)) {
-          renderComponent(node, isRoot, context);
-      }
-      else if (isDef(node.tag)) {
-          renderElement(node, isRoot, context);
-      }
-      else if (isTrue(node.isComment)) {
-          if (isDef(node.asyncFactory)) {
-              // async component
-              renderAsyncComponent(node, isRoot, context);
-          }
-          else {
-              context.write(`<!--${node.text}-->`, context.next);
-          }
-      }
-      else {
-          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
-      }
-  }
-  function registerComponentForCache(options, write) {
-      // exposed by vue-loader, need to call this if cache hit because
-      // component lifecycle hooks will not be called.
-      const register = options._ssrRegister;
-      if (write.caching && isDef(register)) {
-          write.componentBuffer[write.componentBuffer.length - 1].add(register);
-      }
-      return register;
-  }
-  function renderComponent(node, isRoot, context) {
-      const { write, next, userContext } = context;
-      // check cache hit
-      const Ctor = node.componentOptions.Ctor;
-      const getKey = Ctor.options.serverCacheKey;
-      const name = Ctor.options.name;
-      const cache = context.cache;
-      const registerComponent = registerComponentForCache(Ctor.options, write);
-      if (isDef(getKey) && isDef(cache) && isDef(name)) {
-          const rawKey = getKey(node.componentOptions.propsData);
-          if (rawKey === false) {
-              renderComponentInner(node, isRoot, context);
-              return;
-          }
-          const key = name + '::' + rawKey;
-          const { has, get } = context;
-          if (isDef(has)) {
-              has(key, (hit) => {
-                  if (hit === true && isDef(get)) {
-                      get(key, (res) => {
-                          if (isDef(registerComponent)) {
-                              registerComponent(userContext);
-                          }
-                          res.components.forEach((register) => register(userContext));
-                          write(res.html, next);
-                      });
-                  }
-                  else {
-                      renderComponentWithCache(node, isRoot, key, context);
-                  }
-              });
-          }
-          else if (isDef(get)) {
-              get(key, (res) => {
-                  if (isDef(res)) {
-                      if (isDef(registerComponent)) {
-                          registerComponent(userContext);
-                      }
-                      res.components.forEach((register) => register(userContext));
-                      write(res.html, next);
-                  }
-                  else {
-                      renderComponentWithCache(node, isRoot, key, context);
-                  }
-              });
-          }
-      }
-      else {
-          if (isDef(getKey) && isUndef(cache)) {
-              warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
-                  'but no cache was provided to the renderer.');
-          }
-          if (isDef(getKey) && isUndef(name)) {
-              warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
-                  `must also define a unique "name" option.`);
-          }
-          renderComponentInner(node, isRoot, context);
-      }
-  }
-  function renderComponentWithCache(node, isRoot, key, context) {
-      const write = context.write;
-      write.caching = true;
-      const buffer = write.cacheBuffer;
-      const bufferIndex = buffer.push('') - 1;
-      const componentBuffer = write.componentBuffer;
-      componentBuffer.push(new Set());
-      context.renderStates.push({
-          type: 'ComponentWithCache',
-          key,
-          buffer,
-          bufferIndex,
-          componentBuffer,
-      });
-      renderComponentInner(node, isRoot, context);
-  }
-  function renderComponentInner(node, isRoot, context) {
-      const prevActive = context.activeInstance;
-      // expose userContext on vnode
-      node.ssrContext = context.userContext;
-      const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
-      normalizeRender(child);
-      const resolve = () => {
-          const childNode = child._render();
-          childNode.parent = node;
-          context.renderStates.push({
-              type: 'Component',
-              prevActive,
-          });
-          renderNode(childNode, isRoot, context);
-      };
-      const reject = context.done;
-      waitForServerPrefetch(child, resolve, reject);
-  }
-  function renderAsyncComponent(node, isRoot, context) {
-      const factory = node.asyncFactory;
-      const resolve = (comp) => {
-          if (comp.__esModule && comp.default) {
-              comp = comp.default;
-          }
-          const { data, children, tag } = node.asyncMeta;
-          const nodeContext = node.asyncMeta.context;
-          const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
-          if (resolvedNode) {
-              if (resolvedNode.componentOptions) {
-                  // normal component
-                  renderComponent(resolvedNode, isRoot, context);
-              }
-              else if (!Array.isArray(resolvedNode)) {
-                  // single return node from functional component
-                  renderNode(resolvedNode, isRoot, context);
-              }
-              else {
-                  // multiple return nodes from functional component
-                  context.renderStates.push({
-                      type: 'Fragment',
-                      children: resolvedNode,
-                      rendered: 0,
-                      total: resolvedNode.length,
-                  });
-                  context.next();
-              }
-          }
-          else {
-              // invalid component, but this does not throw on the client
-              // so render empty comment node
-              context.write(`<!---->`, context.next);
-          }
-      };
-      if (factory.resolved) {
-          resolve(factory.resolved);
-          return;
-      }
-      const reject = context.done;
-      let res;
-      try {
-          res = factory(resolve, reject);
-      }
-      catch (e) {
-          reject(e);
-      }
-      if (res) {
-          if (typeof res.then === 'function') {
-              res.then(resolve, reject).catch(reject);
-          }
-          else {
-              // new syntax in 2.3
-              const comp = res.component;
-              if (comp && typeof comp.then === 'function') {
-                  comp.then(resolve, reject).catch(reject);
-              }
-          }
-      }
-  }
-  function renderStringNode(el, context) {
-      const { write, next } = context;
-      if (isUndef(el.children) || el.children.length === 0) {
-          write(el.open + (el.close || ''), next);
-      }
-      else {
-          const children = el.children;
-          context.renderStates.push({
-              type: 'Element',
-              children,
-              rendered: 0,
-              total: children.length,
-              endTag: el.close,
-          });
-          write(el.open, next);
-      }
-  }
-  function renderElement(el, isRoot, context) {
-      const { write, next } = context;
-      if (isTrue(isRoot)) {
-          if (!el.data)
-              el.data = {};
-          if (!el.data.attrs)
-              el.data.attrs = {};
-          el.data.attrs[SSR_ATTR] = 'true';
-      }
-      if (el.fnOptions) {
-          registerComponentForCache(el.fnOptions, write);
-      }
-      const startTag = renderStartingTag(el, context);
-      const endTag = `</${el.tag}>`;
-      if (context.isUnaryTag(el.tag)) {
-          write(startTag, next);
-      }
-      else if (isUndef(el.children) || el.children.length === 0) {
-          write(startTag + endTag, next);
-      }
-      else {
-          const children = el.children;
-          context.renderStates.push({
-              type: 'Element',
-              children,
-              rendered: 0,
-              total: children.length,
-              endTag,
-          });
-          write(startTag, next);
-      }
-  }
-  function hasAncestorData(node) {
-      const parentNode = node.parent;
-      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
-  }
-  function getVShowDirectiveInfo(node) {
-      let dir;
-      let tmp;
-      while (isDef(node)) {
-          if (node.data && node.data.directives) {
-              tmp = node.data.directives.find((dir) => dir.name === 'show');
-              if (tmp) {
-                  dir = tmp;
-              }
-          }
-          node = node.parent;
-      }
-      //@ts-expect-error
-      return dir;
-  }
-  function renderStartingTag(node, context) {
-      let markup = `<${node.tag}`;
-      const { directives, modules } = context;
-      // construct synthetic data for module processing
-      // because modules like style also produce code by parent VNode data
-      if (isUndef(node.data) && hasAncestorData(node)) {
-          node.data = {};
-      }
-      if (isDef(node.data)) {
-          // check directives
-          const dirs = node.data.directives;
-          if (dirs) {
-              for (let i = 0; i < dirs.length; i++) {
-                  const name = dirs[i].name;
-                  if (name !== 'show') {
-                      const dirRenderer = resolveAsset(context, 'directives', name);
-                      if (dirRenderer) {
-                          // directives mutate the node's data
-                          // which then gets rendered by modules
-                          dirRenderer(node, dirs[i]);
-                      }
-                  }
-              }
-          }
-          // v-show directive needs to be merged from parent to child
-          const vshowDirectiveInfo = getVShowDirectiveInfo(node);
-          if (vshowDirectiveInfo) {
-              directives.show(node, vshowDirectiveInfo);
-          }
-          // apply other modules
-          for (let i = 0; i < modules.length; i++) {
-              const res = modules[i](node);
-              if (res) {
-                  markup += res;
-              }
-          }
-      }
-      // attach scoped CSS ID
-      let scopeId;
-      const activeInstance = context.activeInstance;
-      if (isDef(activeInstance) &&
-          activeInstance !== node.context &&
-          isDef((scopeId = activeInstance.$options._scopeId))) {
-          markup += ` ${scopeId}`;
-      }
-      if (isDef(node.fnScopeId)) {
-          markup += ` ${node.fnScopeId}`;
-      }
-      else {
-          while (isDef(node)) {
-              //@ts-expect-error
-              if (isDef((scopeId = node.context.$options._scopeId))) {
-                  markup += ` ${scopeId}`;
-              }
-              node = node.parent;
-          }
-      }
-      return markup + '>';
-  }
-  function createRenderFunction(modules, directives, isUnaryTag, cache) {
-      return function render(component, write, userContext, done) {
-          warned = Object.create(null);
-          const context = new RenderContext({
-              activeInstance: component,
-              userContext,
-              write,
-              done,
-              renderNode,
-              isUnaryTag,
-              modules,
-              directives,
-              cache,
-          });
-          installSSRHelpers(component);
-          normalizeRender(component);
-          const resolve = () => {
-              renderNode(component._render(), true, context);
-          };
-          waitForServerPrefetch(component, resolve, done);
-      };
-  }
-
-  function createBasicRenderer({ modules = [], directives = {}, isUnaryTag = () => false, cache, } = {}) {
-      const render = createRenderFunction(modules, directives, isUnaryTag, cache);
-      return function renderToString(component, context, done) {
-          if (typeof context === 'function') {
-              done = context;
-              context = {};
-          }
-          let result = '';
-          const write = createWriteFunction((text) => {
-              result += text;
-              return false;
-          }, done);
-          try {
-              //@ts-expect-error
-              render(component, write, context, () => {
-                  done(null, result);
-              });
-          }
-          catch (e) {
-              done(e);
-          }
-      };
-  }
-
-  var entryServerBasicRenderer = createBasicRenderer({
-      // @ts-expect-error
-      modules: modules$1,
-      directives: directives$1,
-      isUnaryTag,
-      canBeLeftOpenTag,
+  // The template compiler attempts to minimize the need for normalization by
+  // statically analyzing the template at compile time.
+  //
+  // For plain HTML markup, normalization can be completely skipped because the
+  // generated render function is guaranteed to return Array<VNode>. There are
+  // two cases where extra normalization is needed:
+  // 1. When the children contains components - because a functional component
+  // may return an Array instead of a single root. In this case, just a simple
+  // normalization is needed - if any child is an Array, we flatten the whole
+  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+  // because functional components already normalize their own children.
+  function simpleNormalizeChildren(children) {
+      for (let i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
+      }
+      return children;
+  }
+  // 2. When the children contains constructs that always generated nested Arrays,
+  // e.g. <template>, <slot>, v-for, or when the children is provided by user
+  // with hand-written render functions / JSX. In such cases a full normalization
+  // is needed to cater to all possible types of children values.
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      const res = [];
+      let i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              continue;
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = `__vlist${nestedIndex}_${i}__`;
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
+  }
+
+  const ssrHelpers = {
+      _ssrEscape: escape,
+      _ssrNode: renderStringNode$1,
+      _ssrList: renderStringList,
+      _ssrAttr: renderAttr,
+      _ssrAttrs: renderAttrs,
+      _ssrDOMProps: renderDOMProps,
+      _ssrClass: renderSSRClass,
+      _ssrStyle: renderSSRStyle,
+  };
+  function installSSRHelpers(vm) {
+      if (vm._ssrNode) {
+          return;
+      }
+      let Vue = vm.constructor;
+      // @ts-expect-error
+      while (Vue.super) {
+          // @ts-expect-error
+          Vue = Vue.super;
+      }
+      extend(Vue.prototype, ssrHelpers);
+      // @ts-expect-error
+      if (Vue.FunctionalRenderContext) {
+          // @ts-expect-error
+          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+      }
+  }
+  class StringNode {
+      isString;
+      open;
+      close;
+      children;
+      constructor(open, close, children, normalizationType) {
+          this.isString = true;
+          this.open = open;
+          this.close = close;
+          if (children) {
+              this.children =
+                  normalizationType === 1
+                      ? simpleNormalizeChildren(children)
+                      : normalizationType === 2
+                          ? normalizeChildren(children)
+                          : children;
+          }
+          else {
+              this.children = void 0;
+          }
+      }
+  }
+  function renderStringNode$1(open, close, children, normalizationType) {
+      return new StringNode(open, close, children, normalizationType);
+  }
+  function renderStringList(val, render) {
+      let ret = '';
+      let i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          for (i = 0, l = val.length; i < l; i++) {
+              ret += render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          for (i = 0; i < val; i++) {
+              ret += render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          keys = Object.keys(val);
+          for (i = 0, l = keys.length; i < l; i++) {
+              key = keys[i];
+              ret += render(val[key], key, i);
+          }
+      }
+      return ret;
+  }
+  function renderAttrs(obj) {
+      let res = '';
+      for (const key in obj) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          res += renderAttr(key, obj[key]);
+      }
+      return res;
+  }
+  function renderDOMProps(obj) {
+      let res = '';
+      for (const key in obj) {
+          const attr = propsToAttrMap[key] || key.toLowerCase();
+          if (isRenderableAttr(attr)) {
+              res += renderAttr(attr, obj[key]);
+          }
+      }
+      return res;
+  }
+  function renderSSRClass(staticClass, dynamic) {
+      const res = renderClass$1(staticClass, dynamic);
+      return res === '' ? res : ` class="${escape(res)}"`;
+  }
+  function renderSSRStyle(staticStyle, dynamic, extra) {
+      const style = {};
+      if (staticStyle)
+          extend(style, staticStyle);
+      if (dynamic)
+          extend(style, normalizeStyleBinding(dynamic));
+      if (extra)
+          extend(style, extra);
+      const res = genStyle(style);
+      return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
+  }
+
+  /* not type checking this file because flow doesn't play well with Proxy */
+  {
+      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
+      );
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
+  }
+
+  const seenObjects = new _Set();
+  /**
+   * Recursively traverse an object to evoke all converted
+   * getters, so that every nested property inside the object
+   * is collected as a "deep" dependency.
+   */
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      let i, keys;
+      const isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          const depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              _traverse(val[i], seen);
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              _traverse(val[keys[i]], seen);
+      }
+  }
+
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
+      const capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name,
+          once,
+          capture,
+          passive,
+      };
+  });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          const fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      let name, cur, old, event;
+      for (name in on) {
+          cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove(event.name, oldOn[name], event.capture);
+          }
+      }
+  }
+
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      const propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      const res = {};
+      const { attrs, props } = data;
+      if (isDef(attrs) || isDef(props)) {
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
+              {
+                  const keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
+  }
+
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
+  // wrapper function for providing a more flexible interface
+  // without getting yelled at by flow
+  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn$2('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      let vnode, ns;
+      if (typeof tag === 'string') {
+          let Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              applyNS(vnode, ns);
+          if (isDef(data))
+              registerDeepBindings(data);
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
+  }
+  // ref #5318
+  // necessary to ensure parent re-render when deep bindings like :style and
+  // :class are used on slot nodes
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
+  }
+
+  /**
+   * Runtime helper for rendering v-for lists.
+   */
+  function renderList(val, render) {
+      let ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
+  }
+
+  /**
+   * Runtime helper for rendering <slot>
+   */
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn$2("slot v-bind without argument expects an Object", this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      else {
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      const target = props && props.slot;
+      if (target) {
+          return this.$createElement("template", { slot: target }, nodes);
+      }
+      else {
+          return nodes;
+      }
+  }
+
+  /**
+   * Runtime helper for resolving filters
+   */
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
+  }
+
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
+  }
+  /**
+   * Runtime helper for checking keyCodes from config.
+   * exposed as Vue.prototype._k
+   * passing in eventKeyName as last argument separately for backwards compat
+   */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+      return eventKeyCode === undefined;
+  }
+
+  /**
+   * Runtime helper for merging v-bind="object" into a VNode's data.
+   */
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn$2('v-bind without argument expects an Object or Array value', this);
+          }
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              let hash;
+              for (const key in value) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      const type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              }
+          }
+      }
+      return data;
+  }
+
+  /**
+   * Runtime helper for rendering static trees.
+   */
+  function renderStatic(index, isInFor) {
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, `__static__${index}`, false);
+      return tree;
+  }
+  /**
+   * Runtime helper for v-once.
+   * Effectively it means marking the node as static with a unique key.
+   */
+  function markOnce(tree, index, key) {
+      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (let i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
+  }
+
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn$2('v-on without argument expects an Object value', this);
+          }
+          else {
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
+      }
+      return data;
+  }
+
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
+  }
+
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+  function bindDynamicKeys(baseObj, values) {
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+          }
+      }
+      return baseObj;
+  }
+  // helper to dynamically append modifier runtime markers to event names.
+  // ensure only append when value is already string, otherwise it will be cast
+  // to string and cause the type check to miss.
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
+  }
+
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
+  }
+
+  /**
+   * Runtime helper for resolving raw children VNodes into a slot object.
+   */
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  }
+
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
+  }
+
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
+      return res;
+  }
+  function normalizeScopedSlot(normalSlots, key, fn) {
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === "object" && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
+  }
+  function proxyNormalSlot(slots, key) {
+      return () => slots[key];
+  }
+
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      const node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data, context, children, tag };
+      return node;
+  }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+  }
+
+  let target;
+  function add(event, fn) {
+      target.$on(event, fn);
+  }
+  function remove(event, fn) {
+      target.$off(event, fn);
+  }
+  function createOnceHandler(event, fn) {
+      const _target = target;
+      return function onceHandler() {
+          const res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
+  }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target = vm;
+      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
+      target = undefined;
+  }
+
+  let activeInstance = null;
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      const needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      vm.$options._parentVnode = parentVnode;
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      const oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              return true;
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (let i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, "activated");
+      }
+  }
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (let i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, "deactivated");
+      }
+  }
+  function callHook(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
+      if (handlers) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit("hook:" + hook);
+      }
+      popTarget();
+  }
+
+  // Async edge case fix requires storing an event listener's attach timestamp.
+  let getNow = Date.now;
+  // Determine what event timestamp the browser is using. Annoyingly, the
+  // timestamp can either be hi-res (relative to page load) or low-res
+  // (relative to UNIX epoch), so in order to compare time we have to use the
+  // same timestamp type when saving the flush timestamp.
+  // All IE versions use low-res event timestamps, and have problematic clock
+  // implementations (#9632)
+  if (inBrowser && !isIE) {
+      const performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = () => performance.now();
+      }
+  }
+  /**
+   * Queue a kept-alive component that was activated during patch.
+   * The queue will be processed after the entire tree has been patched.
+   */
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+  }
+
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      const provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      warn$2(`Injection "${key}" not found`, vm);
+                  }
+              }
+          }
+          return result;
+      }
+  }
+
+  function resolveConstructorOptions(Ctor) {
+      let options = Ctor.options;
+      if (Ctor.super) {
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              const modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  modified = {};
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
+  }
+
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      const options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      let contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+          }
+          return this.$slots;
+      };
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = (a, b, c, d) => {
+              const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+      }
+  }
+  installRenderHelpers(FunctionalRenderContext.prototype);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (const key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              mergeProps(props, data.attrs);
+          if (isDef(data.props))
+              mergeProps(props, data.props);
+      }
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      const clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (const key in from) {
+          to[camelize(key)] = from[key];
+      }
+  }
+
+  // inline hooks to be invoked on component VNodes during patch
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              const mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy(vnode) {
+          const { componentInstance } = vnode;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+  };
+  const hooksToMerge = Object.keys(componentVNodeHooks);
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      const baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+          }
+          return;
+      }
+      // async component
+      let asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      const listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          const slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
+      // @ts-expect-error
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      const options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent,
+      };
+      // check inline-template render functions
+      const inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook(f1, f2) {
+      const merged = (a, b) => {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
+  }
+  // transform component v-model info (value and callback) into
+  // prop and event handler respectively.
+  function transformModel(options, data) {
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
+  }
+
+  let warned = Object.create(null);
+  const warnOnce = (msg) => {
+      if (!warned[msg]) {
+          warned[msg] = true;
+          // eslint-disable-next-line no-console
+          console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
+      }
+  };
+  const onCompilationError = (err, vm) => {
+      const trace = vm ? generateComponentTrace(vm) : '';
+      throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
+  };
+  const normalizeRender = (vm) => {
+      const { render, template, _scopeId } = vm.$options;
+      if (isUndef(render)) {
+          if (template) {
+              const compiled = compileToFunctions(template, {
+                  scopeId: _scopeId,
+                  warn: onCompilationError,
+              }, vm);
+              vm.$options.render = compiled.render;
+              vm.$options.staticRenderFns = compiled.staticRenderFns;
+          }
+          else {
+              throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
+          }
+      }
+  };
+  function waitForServerPrefetch(vm, resolve, reject) {
+      let handlers = vm.$options.serverPrefetch;
+      if (isDef(handlers)) {
+          if (!Array.isArray(handlers))
+              handlers = [handlers];
+          try {
+              const promises = [];
+              for (let i = 0, j = handlers.length; i < j; i++) {
+                  const result = handlers[i].call(vm, vm);
+                  if (result && typeof result.then === 'function') {
+                      promises.push(result);
+                  }
+              }
+              Promise.all(promises).then(resolve).catch(reject);
+              return;
+          }
+          catch (e) {
+              reject(e);
+          }
+      }
+      resolve();
+  }
+  function renderNode(node, isRoot, context) {
+      if (node.isString) {
+          renderStringNode(node, context);
+      }
+      else if (isDef(node.componentOptions)) {
+          renderComponent(node, isRoot, context);
+      }
+      else if (isDef(node.tag)) {
+          renderElement(node, isRoot, context);
+      }
+      else if (isTrue(node.isComment)) {
+          if (isDef(node.asyncFactory)) {
+              // async component
+              renderAsyncComponent(node, isRoot, context);
+          }
+          else {
+              context.write(`<!--${node.text}-->`, context.next);
+          }
+      }
+      else {
+          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+      }
+  }
+  function registerComponentForCache(options, write) {
+      // exposed by vue-loader, need to call this if cache hit because
+      // component lifecycle hooks will not be called.
+      const register = options._ssrRegister;
+      if (write.caching && isDef(register)) {
+          write.componentBuffer[write.componentBuffer.length - 1].add(register);
+      }
+      return register;
+  }
+  function renderComponent(node, isRoot, context) {
+      const { write, next, userContext } = context;
+      // check cache hit
+      const Ctor = node.componentOptions.Ctor;
+      const getKey = Ctor.options.serverCacheKey;
+      const name = Ctor.options.name;
+      const cache = context.cache;
+      const registerComponent = registerComponentForCache(Ctor.options, write);
+      if (isDef(getKey) && isDef(cache) && isDef(name)) {
+          const rawKey = getKey(node.componentOptions.propsData);
+          if (rawKey === false) {
+              renderComponentInner(node, isRoot, context);
+              return;
+          }
+          const key = name + '::' + rawKey;
+          const { has, get } = context;
+          if (isDef(has)) {
+              has(key, (hit) => {
+                  if (hit === true && isDef(get)) {
+                      get(key, (res) => {
+                          if (isDef(registerComponent)) {
+                              registerComponent(userContext);
+                          }
+                          res.components.forEach((register) => register(userContext));
+                          write(res.html, next);
+                      });
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+          else if (isDef(get)) {
+              get(key, (res) => {
+                  if (isDef(res)) {
+                      if (isDef(registerComponent)) {
+                          registerComponent(userContext);
+                      }
+                      res.components.forEach((register) => register(userContext));
+                      write(res.html, next);
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+      }
+      else {
+          if (isDef(getKey) && isUndef(cache)) {
+              warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
+                  'but no cache was provided to the renderer.');
+          }
+          if (isDef(getKey) && isUndef(name)) {
+              warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
+                  `must also define a unique "name" option.`);
+          }
+          renderComponentInner(node, isRoot, context);
+      }
+  }
+  function renderComponentWithCache(node, isRoot, key, context) {
+      const write = context.write;
+      write.caching = true;
+      const buffer = write.cacheBuffer;
+      const bufferIndex = buffer.push('') - 1;
+      const componentBuffer = write.componentBuffer;
+      componentBuffer.push(new Set());
+      context.renderStates.push({
+          type: 'ComponentWithCache',
+          key,
+          buffer,
+          bufferIndex,
+          componentBuffer,
+      });
+      renderComponentInner(node, isRoot, context);
+  }
+  function renderComponentInner(node, isRoot, context) {
+      const prevActive = context.activeInstance;
+      // expose userContext on vnode
+      node.ssrContext = context.userContext;
+      const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+      normalizeRender(child);
+      const resolve = () => {
+          const childNode = child._render();
+          childNode.parent = node;
+          context.renderStates.push({
+              type: 'Component',
+              prevActive,
+          });
+          renderNode(childNode, isRoot, context);
+      };
+      const reject = context.done;
+      waitForServerPrefetch(child, resolve, reject);
+  }
+  function renderAsyncComponent(node, isRoot, context) {
+      const factory = node.asyncFactory;
+      const resolve = (comp) => {
+          if (comp.__esModule && comp.default) {
+              comp = comp.default;
+          }
+          const { data, children, tag } = node.asyncMeta;
+          const nodeContext = node.asyncMeta.context;
+          const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+          if (resolvedNode) {
+              if (resolvedNode.componentOptions) {
+                  // normal component
+                  renderComponent(resolvedNode, isRoot, context);
+              }
+              else if (!Array.isArray(resolvedNode)) {
+                  // single return node from functional component
+                  renderNode(resolvedNode, isRoot, context);
+              }
+              else {
+                  // multiple return nodes from functional component
+                  context.renderStates.push({
+                      type: 'Fragment',
+                      children: resolvedNode,
+                      rendered: 0,
+                      total: resolvedNode.length,
+                  });
+                  context.next();
+              }
+          }
+          else {
+              // invalid component, but this does not throw on the client
+              // so render empty comment node
+              context.write(`<!---->`, context.next);
+          }
+      };
+      if (factory.resolved) {
+          resolve(factory.resolved);
+          return;
+      }
+      const reject = context.done;
+      let res;
+      try {
+          res = factory(resolve, reject);
+      }
+      catch (e) {
+          reject(e);
+      }
+      if (res) {
+          if (typeof res.then === 'function') {
+              res.then(resolve, reject).catch(reject);
+          }
+          else {
+              // new syntax in 2.3
+              const comp = res.component;
+              if (comp && typeof comp.then === 'function') {
+                  comp.then(resolve, reject).catch(reject);
+              }
+          }
+      }
+  }
+  function renderStringNode(el, context) {
+      const { write, next } = context;
+      if (isUndef(el.children) || el.children.length === 0) {
+          write(el.open + (el.close || ''), next);
+      }
+      else {
+          const children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children,
+              rendered: 0,
+              total: children.length,
+              endTag: el.close,
+          });
+          write(el.open, next);
+      }
+  }
+  function renderElement(el, isRoot, context) {
+      const { write, next } = context;
+      if (isTrue(isRoot)) {
+          if (!el.data)
+              el.data = {};
+          if (!el.data.attrs)
+              el.data.attrs = {};
+          el.data.attrs[SSR_ATTR] = 'true';
+      }
+      if (el.fnOptions) {
+          registerComponentForCache(el.fnOptions, write);
+      }
+      const startTag = renderStartingTag(el, context);
+      const endTag = `</${el.tag}>`;
+      if (context.isUnaryTag(el.tag)) {
+          write(startTag, next);
+      }
+      else if (isUndef(el.children) || el.children.length === 0) {
+          write(startTag + endTag, next);
+      }
+      else {
+          const children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children,
+              rendered: 0,
+              total: children.length,
+              endTag,
+          });
+          write(startTag, next);
+      }
+  }
+  function hasAncestorData(node) {
+      const parentNode = node.parent;
+      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+  }
+  function getVShowDirectiveInfo(node) {
+      let dir;
+      let tmp;
+      while (isDef(node)) {
+          if (node.data && node.data.directives) {
+              tmp = node.data.directives.find((dir) => dir.name === 'show');
+              if (tmp) {
+                  dir = tmp;
+              }
+          }
+          node = node.parent;
+      }
+      //@ts-expect-error
+      return dir;
+  }
+  function renderStartingTag(node, context) {
+      let markup = `<${node.tag}`;
+      const { directives, modules } = context;
+      // construct synthetic data for module processing
+      // because modules like style also produce code by parent VNode data
+      if (isUndef(node.data) && hasAncestorData(node)) {
+          node.data = {};
+      }
+      if (isDef(node.data)) {
+          // check directives
+          const dirs = node.data.directives;
+          if (dirs) {
+              for (let i = 0; i < dirs.length; i++) {
+                  const name = dirs[i].name;
+                  if (name !== 'show') {
+                      const dirRenderer = resolveAsset(context, 'directives', name);
+                      if (dirRenderer) {
+                          // directives mutate the node's data
+                          // which then gets rendered by modules
+                          dirRenderer(node, dirs[i]);
+                      }
+                  }
+              }
+          }
+          // v-show directive needs to be merged from parent to child
+          const vshowDirectiveInfo = getVShowDirectiveInfo(node);
+          if (vshowDirectiveInfo) {
+              directives.show(node, vshowDirectiveInfo);
+          }
+          // apply other modules
+          for (let i = 0; i < modules.length; i++) {
+              const res = modules[i](node);
+              if (res) {
+                  markup += res;
+              }
+          }
+      }
+      // attach scoped CSS ID
+      let scopeId;
+      const activeInstance = context.activeInstance;
+      if (isDef(activeInstance) &&
+          activeInstance !== node.context &&
+          isDef((scopeId = activeInstance.$options._scopeId))) {
+          markup += ` ${scopeId}`;
+      }
+      if (isDef(node.fnScopeId)) {
+          markup += ` ${node.fnScopeId}`;
+      }
+      else {
+          while (isDef(node)) {
+              //@ts-expect-error
+              if (isDef((scopeId = node.context.$options._scopeId))) {
+                  markup += ` ${scopeId}`;
+              }
+              node = node.parent;
+          }
+      }
+      return markup + '>';
+  }
+  function createRenderFunction(modules, directives, isUnaryTag, cache) {
+      return function render(component, write, userContext, done) {
+          warned = Object.create(null);
+          const context = new RenderContext({
+              activeInstance: component,
+              userContext,
+              write,
+              done,
+              renderNode,
+              isUnaryTag,
+              modules,
+              directives,
+              cache,
+          });
+          installSSRHelpers(component);
+          normalizeRender(component);
+          const resolve = () => {
+              renderNode(component._render(), true, context);
+          };
+          waitForServerPrefetch(component, resolve, done);
+      };
+  }
+
+  function createBasicRenderer({ modules = [], directives = {}, isUnaryTag = () => false, cache, } = {}) {
+      const render = createRenderFunction(modules, directives, isUnaryTag, cache);
+      return function renderToString(component, context, done) {
+          if (typeof context === 'function') {
+              done = context;
+              context = {};
+          }
+          let result = '';
+          const write = createWriteFunction((text) => {
+              result += text;
+              return false;
+          }, done);
+          try {
+              //@ts-expect-error
+              render(component, write, context, () => {
+                  done(null, result);
+              });
+          }
+          catch (e) {
+              done(e);
+          }
+      };
+  }
+
+  var entryServerBasicRenderer = createBasicRenderer({
+      // @ts-expect-error
+      modules: modules$1,
+      directives: directives$1,
+      isUnaryTag,
+      canBeLeftOpenTag,
   });
 
   return entryServerBasicRenderer;
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index bb2bebb9468..19aab554e8b 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -9,8141 +9,8140 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$1(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop$1(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$1(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop$1(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
+}
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
 }
 
-const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap');
-const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-const isSSRUnsafeAttr = (name) => {
-    return unsafeAttrCharRE.test(name);
-};
-/* istanbul ignore next */
-const isRenderableAttr = (name) => {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-};
-const propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv',
-};
-const ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;',
-};
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
-}
-function escapeChar(a) {
-    return ESC[a] || a;
-}
-const noUnitNumericStyleProps = {
-    'animation-iteration-count': true,
-    'border-image-outset': true,
-    'border-image-slice': true,
-    'border-image-width': true,
-    'box-flex': true,
-    'box-flex-group': true,
-    'box-ordinal-group': true,
-    'column-count': true,
-    columns: true,
-    flex: true,
-    'flex-grow': true,
-    'flex-positive': true,
-    'flex-shrink': true,
-    'flex-negative': true,
-    'flex-order': true,
-    'grid-row': true,
-    'grid-row-end': true,
-    'grid-row-span': true,
-    'grid-row-start': true,
-    'grid-column': true,
-    'grid-column-end': true,
-    'grid-column-span': true,
-    'grid-column-start': true,
-    'font-weight': true,
-    'line-clamp': true,
-    'line-height': true,
-    opacity: true,
-    order: true,
-    orphans: true,
-    'tab-size': true,
-    widows: true,
-    'z-index': true,
-    zoom: true,
-    // SVG
-    'fill-opacity': true,
-    'flood-opacity': true,
-    'stop-opacity': true,
-    'stroke-dasharray': true,
-    'stroke-dashoffset': true,
-    'stroke-miterlimit': true,
-    'stroke-opacity': true,
-    'stroke-width': true,
+const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+const isSSRUnsafeAttr = (name) => {
+    return unsafeAttrCharRE.test(name);
+};
+/* istanbul ignore next */
+const isRenderableAttr = (name) => {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+};
+const propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
+};
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
+};
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
+}
+const noUnitNumericStyleProps = {
+    'animation-iteration-count': true,
+    'border-image-outset': true,
+    'border-image-slice': true,
+    'border-image-width': true,
+    'box-flex': true,
+    'box-flex-group': true,
+    'box-ordinal-group': true,
+    'column-count': true,
+    columns: true,
+    flex: true,
+    'flex-grow': true,
+    'flex-positive': true,
+    'flex-shrink': true,
+    'flex-negative': true,
+    'flex-order': true,
+    'grid-row': true,
+    'grid-row-end': true,
+    'grid-row-span': true,
+    'grid-row-start': true,
+    'grid-column': true,
+    'grid-column-end': true,
+    'grid-column-span': true,
+    'grid-column-start': true,
+    'font-weight': true,
+    'line-clamp': true,
+    'line-height': true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    'tab-size': true,
+    widows: true,
+    'z-index': true,
+    zoom: true,
+    // SVG
+    'fill-opacity': true,
+    'flood-opacity': true,
+    'stop-opacity': true,
+    'stroke-dasharray': true,
+    'stroke-dashoffset': true,
+    'stroke-miterlimit': true,
+    'stroke-opacity': true,
+    'stroke-width': true,
 };
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function renderAttrs$1(node) {
-    let attrs = node.data.attrs;
-    let res = '';
-    const opts = node.parent && node.parent.componentOptions;
-    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-        let parent = node.parent;
-        while (isDef(parent)) {
-            // Stop fallthrough in case parent has inheritAttrs option set to false
-            if (parent.componentOptions &&
-                parent.componentOptions.Ctor.options.inheritAttrs === false) {
-                break;
-            }
-            if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                attrs = extend(extend({}, attrs), parent.data.attrs);
-            }
-            parent = parent.parent;
-        }
-    }
-    if (isUndef(attrs)) {
-        return res;
-    }
-    for (const key in attrs) {
-        if (isSSRUnsafeAttr(key)) {
-            continue;
-        }
-        if (key === 'style') {
-            // leave it to the style module
-            continue;
-        }
-        res += renderAttr(key, attrs[key]);
-    }
-    return res;
-}
-function renderAttr(key, value) {
-    if (isBooleanAttr(key)) {
-        if (!isFalsyAttrValue(value)) {
-            return ` ${key}="${key}"`;
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
-    }
-    else if (!isFalsyAttrValue(value)) {
-        return ` ${key}="${escape(String(value))}"`;
-    }
-    return '';
+function renderAttrs$1(node) {
+    let attrs = node.data.attrs;
+    let res = '';
+    const opts = node.parent && node.parent.componentOptions;
+    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+        let parent = node.parent;
+        while (isDef(parent)) {
+            // Stop fallthrough in case parent has inheritAttrs option set to false
+            if (parent.componentOptions &&
+                parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                break;
+            }
+            if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                attrs = extend(extend({}, attrs), parent.data.attrs);
+            }
+            parent = parent.parent;
+        }
+    }
+    if (isUndef(attrs)) {
+        return res;
+    }
+    for (const key in attrs) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        if (key === 'style') {
+            // leave it to the style module
+            continue;
+        }
+        res += renderAttr(key, attrs[key]);
+    }
+    return res;
+}
+function renderAttr(key, value) {
+    if (isBooleanAttr(key)) {
+        if (!isFalsyAttrValue(value)) {
+            return ` ${key}="${key}"`;
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
+    }
+    else if (!isFalsyAttrValue(value)) {
+        return ` ${key}="${escape(String(value))}"`;
+    }
+    return '';
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-function renderDOMProps$1(node) {
-    let props = node.data.domProps;
-    let res = '';
-    let parent = node.parent;
-    while (isDef(parent)) {
-        if (parent.data && parent.data.domProps) {
-            props = extend(extend({}, props), parent.data.domProps);
-        }
-        parent = parent.parent;
-    }
-    if (isUndef(props)) {
-        return res;
-    }
-    const attrs = node.data.attrs;
-    for (const key in props) {
-        if (key === 'innerHTML') {
-            setText(node, props[key], true);
-        }
-        else if (key === 'textContent') {
-            setText(node, props[key], false);
-        }
-        else if (key === 'value' && node.tag === 'textarea') {
-            setText(node, toString(props[key]), false);
-        }
-        else {
-            // $flow-disable-line (WTF?)
-            const attr = propsToAttrMap[key] || key.toLowerCase();
-            if (isRenderableAttr(attr) &&
-                // avoid rendering double-bound props/attrs twice
-                !(isDef(attrs) && isDef(attrs[attr]))) {
-                res += renderAttr(attr, props[key]);
-            }
-        }
-    }
-    return res;
-}
-function setText(node, text, raw) {
-    const child = new VNode(undefined, undefined, undefined, text);
-    child.raw = raw;
-    node.children = [child];
+function renderDOMProps$1(node) {
+    let props = node.data.domProps;
+    let res = '';
+    let parent = node.parent;
+    while (isDef(parent)) {
+        if (parent.data && parent.data.domProps) {
+            props = extend(extend({}, props), parent.data.domProps);
+        }
+        parent = parent.parent;
+    }
+    if (isUndef(props)) {
+        return res;
+    }
+    const attrs = node.data.attrs;
+    for (const key in props) {
+        if (key === 'innerHTML') {
+            setText(node, props[key], true);
+        }
+        else if (key === 'textContent') {
+            setText(node, props[key], false);
+        }
+        else if (key === 'value' && node.tag === 'textarea') {
+            setText(node, toString(props[key]), false);
+        }
+        else {
+            // $flow-disable-line (WTF?)
+            const attr = propsToAttrMap[key] || key.toLowerCase();
+            if (isRenderableAttr(attr) &&
+                // avoid rendering double-bound props/attrs twice
+                !(isDef(attrs) && isDef(attrs[attr]))) {
+                res += renderAttr(attr, props[key]);
+            }
+        }
+    }
+    return res;
+}
+function setText(node, text, raw) {
+    const child = new VNode(undefined, undefined, undefined, text);
+    child.raw = raw;
+    node.children = [child];
 }
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop$1,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop$1,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-let warn$2 = noop$1;
-let tip = noop$1;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop$1;
+let tip = noop$1;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+{
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$1(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$1(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+{
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn$2('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn$2('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn$2('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn$2('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-const callbacks = [];
-function flushCallbacks() {
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve();
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+/* globals MutationObserver */
+const callbacks = [];
+function flushCallbacks() {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve();
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 else ;
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass$1(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass$1(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass$1(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass$1(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
 makeMap('text,number,password,search,email,tel,url');
 
-function renderClass(node) {
-    const classList = genClassForVnode(node);
-    if (classList !== '') {
-        return ` class="${escape(classList)}"`;
-    }
+function renderClass(node) {
+    const classList = genClassForVnode(node);
+    if (classList !== '') {
+        return ` class="${escape(classList)}"`;
+    }
 }
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-function genStyle(style) {
-    let styleText = '';
-    for (const key in style) {
-        const value = style[key];
-        const hyphenatedKey = hyphenate(key);
-        if (Array.isArray(value)) {
-            for (let i = 0, len = value.length; i < len; i++) {
-                styleText += normalizeValue(hyphenatedKey, value[i]);
-            }
-        }
-        else {
-            styleText += normalizeValue(hyphenatedKey, value);
-        }
-    }
-    return styleText;
-}
-function normalizeValue(key, value) {
-    if (typeof value === 'string' ||
-        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-        value === 0) {
-        return `${key}:${value};`;
-    }
-    else {
-        // invalid values
-        return ``;
-    }
-}
-function renderStyle(vnode) {
-    const styleText = genStyle(getStyle(vnode, false));
-    if (styleText !== '') {
-        return ` style=${JSON.stringify(escape(styleText))}`;
-    }
+function genStyle(style) {
+    let styleText = '';
+    for (const key in style) {
+        const value = style[key];
+        const hyphenatedKey = hyphenate(key);
+        if (Array.isArray(value)) {
+            for (let i = 0, len = value.length; i < len; i++) {
+                styleText += normalizeValue(hyphenatedKey, value[i]);
+            }
+        }
+        else {
+            styleText += normalizeValue(hyphenatedKey, value);
+        }
+    }
+    return styleText;
+}
+function normalizeValue(key, value) {
+    if (typeof value === 'string' ||
+        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+        value === 0) {
+        return `${key}:${value};`;
+    }
+    else {
+        // invalid values
+        return ``;
+    }
+}
+function renderStyle(vnode) {
+    const styleText = genStyle(getStyle(vnode, false));
+    if (styleText !== '') {
+        return ` style=${JSON.stringify(escape(styleText))}`;
+    }
 }
 
 var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-function show(node, dir) {
-    if (!dir.value) {
-        const style = node.data.style || (node.data.style = {});
-        if (Array.isArray(style)) {
-            style.push({ display: 'none' });
-        }
-        else {
-            style.display = 'none';
-        }
-    }
+function show(node, dir) {
+    if (!dir.value) {
+        const style = node.data.style || (node.data.style = {});
+        if (Array.isArray(style)) {
+            style.push({ display: 'none' });
+        }
+        else {
+            style.display = 'none';
+        }
+    }
 }
 
-// this is only applied for <select v-model> because it is the only edge case
-// that must be done at runtime instead of compile time.
-function model$2(node, dir) {
-    if (!node.children)
-        return;
-    const value = dir.value;
-    const isMultiple = node.data.attrs && node.data.attrs.multiple;
-    for (let i = 0, l = node.children.length; i < l; i++) {
-        const option = node.children[i];
-        if (option.tag === 'option') {
-            if (isMultiple) {
-                const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
-                if (selected) {
-                    setSelected(option);
-                }
-            }
-            else {
-                if (looseEqual(value, getValue(option))) {
-                    setSelected(option);
-                    return;
-                }
-            }
-        }
-    }
-}
-function getValue(option) {
-    const data = option.data || {};
-    return ((data.attrs && data.attrs.value) ||
-        (data.domProps && data.domProps.value) ||
-        (option.children && option.children[0] && option.children[0].text));
-}
-function setSelected(option) {
-    const data = option.data || (option.data = {});
-    const attrs = data.attrs || (data.attrs = {});
-    attrs.selected = '';
+// this is only applied for <select v-model> because it is the only edge case
+// that must be done at runtime instead of compile time.
+function model$2(node, dir) {
+    if (!node.children)
+        return;
+    const value = dir.value;
+    const isMultiple = node.data.attrs && node.data.attrs.multiple;
+    for (let i = 0, l = node.children.length; i < l; i++) {
+        const option = node.children[i];
+        if (option.tag === 'option') {
+            if (isMultiple) {
+                const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                if (selected) {
+                    setSelected(option);
+                }
+            }
+            else {
+                if (looseEqual(value, getValue(option))) {
+                    setSelected(option);
+                    return;
+                }
+            }
+        }
+    }
+}
+function getValue(option) {
+    const data = option.data || {};
+    return ((data.attrs && data.attrs.value) ||
+        (data.domProps && data.domProps.value) ||
+        (option.children && option.children[0] && option.children[0].text));
+}
+function setSelected(option) {
+    const data = option.data || (option.data = {});
+    const attrs = data.attrs || (data.attrs = {});
+    attrs.selected = '';
 }
 
-var baseDirectives$1 = {
-    show,
-    model: model$2,
+var baseDirectives$1 = {
+    show,
+    model: model$2,
 };
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-const MAX_STACK_DEPTH = 800;
-const noop = (_) => _;
-const defer = typeof process !== 'undefined' && process.nextTick
-    ? process.nextTick
-    : typeof Promise !== 'undefined'
-        ? (fn) => Promise.resolve().then(fn)
-        : typeof setTimeout !== 'undefined'
-            ? setTimeout
-            : noop;
-if (defer === noop) {
-    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
-        'that are required by vue-server-renderer. Please use a polyfill for ' +
-        'either Promise or setTimeout.');
-}
-function createWriteFunction(write, onError) {
-    let stackDepth = 0;
-    const cachedWrite = (text, next) => {
-        if (text && cachedWrite.caching) {
-            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-        }
-        const waitForNext = write(text, next);
-        if (waitForNext !== true) {
-            if (stackDepth >= MAX_STACK_DEPTH) {
-                defer(() => {
-                    try {
-                        next();
-                    }
-                    catch (e) {
-                        onError(e);
-                    }
-                });
-            }
-            else {
-                stackDepth++;
-                next();
-                stackDepth--;
-            }
-        }
-    };
-    cachedWrite.caching = false;
-    cachedWrite.cacheBuffer = [];
-    cachedWrite.componentBuffer = [];
-    return cachedWrite;
+const MAX_STACK_DEPTH = 800;
+const noop = (_) => _;
+const defer = typeof process !== 'undefined' && process.nextTick
+    ? process.nextTick
+    : typeof Promise !== 'undefined'
+        ? (fn) => Promise.resolve().then(fn)
+        : typeof setTimeout !== 'undefined'
+            ? setTimeout
+            : noop;
+if (defer === noop) {
+    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+        'that are required by vue-server-renderer. Please use a polyfill for ' +
+        'either Promise or setTimeout.');
+}
+function createWriteFunction(write, onError) {
+    let stackDepth = 0;
+    const cachedWrite = (text, next) => {
+        if (text && cachedWrite.caching) {
+            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+        }
+        const waitForNext = write(text, next);
+        if (waitForNext !== true) {
+            if (stackDepth >= MAX_STACK_DEPTH) {
+                defer(() => {
+                    try {
+                        next();
+                    }
+                    catch (e) {
+                        onError(e);
+                    }
+                });
+            }
+            else {
+                stackDepth++;
+                next();
+                stackDepth--;
+            }
+        }
+    };
+    cachedWrite.caching = false;
+    cachedWrite.cacheBuffer = [];
+    cachedWrite.componentBuffer = [];
+    return cachedWrite;
 }
 
-/**
- * Original RenderStream implementation by Sasha Aickin (@aickin)
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Modified by Evan You (@yyx990803)
- */
-class RenderStream extends stream.Readable {
-    buffer;
-    render;
-    expectedSize;
-    write;
-    //@ts-expect-error
-    next;
-    end;
-    //@ts-expect-error
-    done;
-    constructor(render) {
-        super();
-        this.buffer = '';
-        //@ts-expect-error
-        this.render = render;
-        this.expectedSize = 0;
-        this.write = createWriteFunction((text, next) => {
-            const n = this.expectedSize;
-            this.buffer += text;
-            if (this.buffer.length >= n) {
-                this.next = next;
-                this.pushBySize(n);
-                return true; // we will decide when to call next
-            }
-            return false;
-        }, (err) => {
-            this.emit('error', err);
-        });
-        this.end = () => {
-            this.emit('beforeEnd');
-            // the rendering is finished; we should push out the last of the buffer.
-            this.done = true;
-            this.push(this.buffer);
-        };
-    }
-    pushBySize(n) {
-        const bufferToPush = this.buffer.substring(0, n);
-        this.buffer = this.buffer.substring(n);
-        this.push(bufferToPush);
-    }
-    tryRender() {
-        try {
-            this.render(this.write, this.end);
-        }
-        catch (e) {
-            this.emit('error', e);
-        }
-    }
-    tryNext() {
-        try {
-            this.next();
-        }
-        catch (e) {
-            this.emit('error', e);
-        }
-    }
-    _read(n) {
-        this.expectedSize = n;
-        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-        // which means we will need to go through multiple read calls to drain it
-        // down to < n.
-        if (isTrue(this.done)) {
-            this.push(null);
-            return;
-        }
-        if (this.buffer.length >= n) {
-            this.pushBySize(n);
-            return;
-        }
-        if (isUndef(this.next)) {
-            // start the rendering chain.
-            this.tryRender();
-        }
-        else {
-            // continue with the rendering.
-            this.tryNext();
-        }
-    }
+/**
+ * Original RenderStream implementation by Sasha Aickin (@aickin)
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Modified by Evan You (@yyx990803)
+ */
+class RenderStream extends stream.Readable {
+    buffer;
+    render;
+    expectedSize;
+    write;
+    //@ts-expect-error
+    next;
+    end;
+    //@ts-expect-error
+    done;
+    constructor(render) {
+        super();
+        this.buffer = '';
+        //@ts-expect-error
+        this.render = render;
+        this.expectedSize = 0;
+        this.write = createWriteFunction((text, next) => {
+            const n = this.expectedSize;
+            this.buffer += text;
+            if (this.buffer.length >= n) {
+                this.next = next;
+                this.pushBySize(n);
+                return true; // we will decide when to call next
+            }
+            return false;
+        }, (err) => {
+            this.emit('error', err);
+        });
+        this.end = () => {
+            this.emit('beforeEnd');
+            // the rendering is finished; we should push out the last of the buffer.
+            this.done = true;
+            this.push(this.buffer);
+        };
+    }
+    pushBySize(n) {
+        const bufferToPush = this.buffer.substring(0, n);
+        this.buffer = this.buffer.substring(n);
+        this.push(bufferToPush);
+    }
+    tryRender() {
+        try {
+            this.render(this.write, this.end);
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    tryNext() {
+        try {
+            this.next();
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    _read(n) {
+        this.expectedSize = n;
+        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
+        // which means we will need to go through multiple read calls to drain it
+        // down to < n.
+        if (isTrue(this.done)) {
+            this.push(null);
+            return;
+        }
+        if (this.buffer.length >= n) {
+            this.pushBySize(n);
+            return;
+        }
+        if (isUndef(this.next)) {
+            // start the rendering chain.
+            this.tryRender();
+        }
+        else {
+            // continue with the rendering.
+            this.tryNext();
+        }
+    }
 }
 
-class RenderContext {
-    userContext;
-    activeInstance;
-    renderStates;
-    write;
-    renderNode;
-    //@ts-expect-error
-    next;
-    done;
-    modules;
-    directives;
-    isUnaryTag;
-    cache;
-    get;
-    has;
-    constructor(options) {
-        this.userContext = options.userContext;
-        this.activeInstance = options.activeInstance;
-        this.renderStates = [];
-        this.write = options.write;
-        this.done = options.done;
-        this.renderNode = options.renderNode;
-        this.isUnaryTag = options.isUnaryTag;
-        this.modules = options.modules;
-        this.directives = options.directives;
-        const cache = options.cache;
-        if (cache && (!cache.get || !cache.set)) {
-            throw new Error('renderer cache must implement at least get & set.');
-        }
-        this.cache = cache;
-        this.get = cache && normalizeAsync(cache, 'get');
-        this.has = cache && normalizeAsync(cache, 'has');
-        //@ts-expect-error
-        this.next = this.next.bind(this);
-    }
-    //@ts-expect-error
-    next() {
-        // eslint-disable-next-line
-        while (true) {
-            const lastState = this.renderStates[this.renderStates.length - 1];
-            if (isUndef(lastState)) {
-                return this.done();
-            }
-            /* eslint-disable no-case-declarations */
-            switch (lastState.type) {
-                case 'Element':
-                case 'Fragment':
-                    const { children, total } = lastState;
-                    const rendered = lastState.rendered++;
-                    if (rendered < total) {
-                        return this.renderNode(children[rendered], false, this);
-                    }
-                    else {
-                        this.renderStates.pop();
-                        if (lastState.type === 'Element') {
-                            return this.write(lastState.endTag, this.next);
-                        }
-                    }
-                    break;
-                case 'Component':
-                    this.renderStates.pop();
-                    this.activeInstance = lastState.prevActive;
-                    break;
-                case 'ComponentWithCache':
-                    this.renderStates.pop();
-                    const { buffer, bufferIndex, componentBuffer, key } = lastState;
-                    const result = {
-                        html: buffer[bufferIndex],
-                        components: componentBuffer[bufferIndex],
-                    };
-                    this.cache.set(key, result);
-                    if (bufferIndex === 0) {
-                        // this is a top-level cached component,
-                        // exit caching mode.
-                        //@ts-expect-error
-                        this.write.caching = false;
-                    }
-                    else {
-                        // parent component is also being cached,
-                        // merge self into parent's result
-                        buffer[bufferIndex - 1] += result.html;
-                        const prev = componentBuffer[bufferIndex - 1];
-                        result.components.forEach((c) => prev.add(c));
-                    }
-                    buffer.length = bufferIndex;
-                    componentBuffer.length = bufferIndex;
-                    break;
-            }
-        }
-    }
-}
-function normalizeAsync(cache, method) {
-    const fn = cache[method];
-    if (isUndef(fn)) {
-        return;
-    }
-    else if (fn.length > 1) {
-        return (key, cb) => fn.call(cache, key, cb);
-    }
-    else {
-        return (key, cb) => cb(fn.call(cache, key));
-    }
+class RenderContext {
+    userContext;
+    activeInstance;
+    renderStates;
+    write;
+    renderNode;
+    //@ts-expect-error
+    next;
+    done;
+    modules;
+    directives;
+    isUnaryTag;
+    cache;
+    get;
+    has;
+    constructor(options) {
+        this.userContext = options.userContext;
+        this.activeInstance = options.activeInstance;
+        this.renderStates = [];
+        this.write = options.write;
+        this.done = options.done;
+        this.renderNode = options.renderNode;
+        this.isUnaryTag = options.isUnaryTag;
+        this.modules = options.modules;
+        this.directives = options.directives;
+        const cache = options.cache;
+        if (cache && (!cache.get || !cache.set)) {
+            throw new Error('renderer cache must implement at least get & set.');
+        }
+        this.cache = cache;
+        this.get = cache && normalizeAsync(cache, 'get');
+        this.has = cache && normalizeAsync(cache, 'has');
+        //@ts-expect-error
+        this.next = this.next.bind(this);
+    }
+    //@ts-expect-error
+    next() {
+        // eslint-disable-next-line
+        while (true) {
+            const lastState = this.renderStates[this.renderStates.length - 1];
+            if (isUndef(lastState)) {
+                return this.done();
+            }
+            /* eslint-disable no-case-declarations */
+            switch (lastState.type) {
+                case 'Element':
+                case 'Fragment':
+                    const { children, total } = lastState;
+                    const rendered = lastState.rendered++;
+                    if (rendered < total) {
+                        return this.renderNode(children[rendered], false, this);
+                    }
+                    else {
+                        this.renderStates.pop();
+                        if (lastState.type === 'Element') {
+                            return this.write(lastState.endTag, this.next);
+                        }
+                    }
+                    break;
+                case 'Component':
+                    this.renderStates.pop();
+                    this.activeInstance = lastState.prevActive;
+                    break;
+                case 'ComponentWithCache':
+                    this.renderStates.pop();
+                    const { buffer, bufferIndex, componentBuffer, key } = lastState;
+                    const result = {
+                        html: buffer[bufferIndex],
+                        components: componentBuffer[bufferIndex],
+                    };
+                    this.cache.set(key, result);
+                    if (bufferIndex === 0) {
+                        // this is a top-level cached component,
+                        // exit caching mode.
+                        //@ts-expect-error
+                        this.write.caching = false;
+                    }
+                    else {
+                        // parent component is also being cached,
+                        // merge self into parent's result
+                        buffer[bufferIndex - 1] += result.html;
+                        const prev = componentBuffer[bufferIndex - 1];
+                        result.components.forEach((c) => prev.add(c));
+                    }
+                    buffer.length = bufferIndex;
+                    componentBuffer.length = bufferIndex;
+                    break;
+            }
+        }
+    }
+}
+function normalizeAsync(cache, method) {
+    const fn = cache[method];
+    if (isUndef(fn)) {
+        return;
+    }
+    else if (fn.length > 1) {
+        return (key, cb) => fn.call(cache, key, cb);
+    }
+    else {
+        return (key, cb) => cb(fn.call(cache, key));
+    }
 }
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if ((i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he__default["default"].decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn$1;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn$1(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn: warn$1,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn$1('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn$1(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he__default["default"].decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        {
+            if (el.tag === 'template') {
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model$1 = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model$1 = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model$1];
 
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model,
-    text,
-    html,
+var directives = {
+    model,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys(modules),
 };
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop$1,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop$1,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate$1(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate$1(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate$1(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if ((el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate$1(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-    if (el.directives) {
-        for (let i = 0; i < el.directives.length; i++) {
-            const dir = el.directives[i];
-            if (dir.name === 'model') {
-                state.directives.model(el, dir, state.warn);
-                // remove value for textarea as its converted to text
-                if (el.tag === 'textarea' && el.props) {
-                    el.props = el.props.filter((p) => p.name !== 'value');
-                }
-                break;
-            }
-        }
-    }
-}
-function genAttrSegments(attrs) {
-    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-}
-function genDOMPropSegments(props, attrs) {
-    const segments = [];
-    props.forEach(({ name, value }) => {
-        name = propsToAttrMap[name] || name.toLowerCase();
-        if (isRenderableAttr(name) &&
-            !(attrs && attrs.some((a) => a.name === name))) {
-            segments.push(genAttrSegment(name, value));
-        }
-    });
-    return segments;
-}
-function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-        // force double quote
-        value = value.replace(/^'|'$/g, '"');
-        // force enumerated attr to "true"
-        if (isEnumeratedAttr(name) && value !== `"false"`) {
-            value = `"true"`;
-        }
-        return {
-            type: RAW,
-            value: isBooleanAttr(name)
-                ? ` ${name}="${name}"`
-                : value === '""'
-                    ? ` ${name}`
-                    : ` ${name}="${JSON.parse(value)}"`,
-        };
-    }
-    else {
-        return {
-            type: EXPRESSION,
-            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-        };
-    }
-}
-function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-            },
-        ];
-    }
-}
-function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-            },
-        ];
-    }
+const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+// let the model AST transform translate v-model into appropriate
+// props bindings
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (let i = 0; i < el.directives.length; i++) {
+            const dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter((p) => p.name !== 'value');
+                }
+                break;
+            }
+        }
+    }
+}
+function genAttrSegments(attrs) {
+    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+}
+function genDOMPropSegments(props, attrs) {
+    const segments = [];
+    props.forEach(({ name, value }) => {
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some((a) => a.name === name))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== `"false"`) {
+            value = `"true"`;
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? ` ${name}="${name}"`
+                : value === '""'
+                    ? ` ${name}`
+                    : ` ${name}="${JSON.parse(value)}"`,
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+        };
+    }
+}
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+            },
+        ];
+    }
+}
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+            },
+        ];
+    }
 }
 
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-const optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-};
-let isPlatformReservedTag;
-function optimize(root, options) {
-    if (!root)
-        return;
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-}
-function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-        node.ssrOptimizability = optimizability.FALSE;
-        return;
-    }
-    // root node or nodes with custom directives should always be a VNode
-    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-    const check = (child) => {
-        if (child.ssrOptimizability !== optimizability.FULL) {
-            node.ssrOptimizability = selfUnoptimizable
-                ? optimizability.PARTIAL
-                : optimizability.SELF;
-        }
-    };
-    if (selfUnoptimizable) {
-        node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            walk(child);
-            check(child);
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                walk(block, isRoot);
-                check(block);
-            }
-        }
-        if (node.ssrOptimizability == null ||
-            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-            node.ssrOptimizability = optimizability.FULL;
-        }
-        else {
-            node.children = optimizeSiblings(node);
-        }
-    }
-    else {
-        node.ssrOptimizability = optimizability.FULL;
-    }
-}
-function optimizeSiblings(el) {
-    const children = el.children;
-    const optimizedChildren = [];
-    let currentOptimizableGroup = [];
-    const pushGroup = () => {
-        if (currentOptimizableGroup.length) {
-            optimizedChildren.push({
-                type: 1,
-                parent: el,
-                tag: 'template',
-                attrsList: [],
-                attrsMap: {},
-                rawAttrsMap: {},
-                children: currentOptimizableGroup,
-                ssrOptimizability: optimizability.FULL,
-            });
-        }
-        currentOptimizableGroup = [];
-    };
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.ssrOptimizability === optimizability.FULL) {
-            currentOptimizableGroup.push(c);
-        }
-        else {
-            // wrap fully-optimizable adjacent siblings inside a template tag
-            // so that they can be optimized into a single ssrNode by codegen
-            pushGroup();
-            optimizedChildren.push(c);
-        }
-    }
-    pushGroup();
-    return optimizedChildren;
-}
-function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-        // text or expression
-        return false;
-    }
-    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag(node.tag) || // custom component
-        !!node.component || // "is" component
-        isSelectWithModel(node) // <select v-model> requires runtime inspection
-    );
-}
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-function hasCustomDirective(node) {
-    return (node.type === 1 &&
-        node.directives &&
-        node.directives.some((d) => !isBuiltInDir(d.name)));
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-    return (node.type === 1 &&
-        node.tag === 'select' &&
-        node.directives != null &&
-        node.directives.some((d) => d.name === 'model'));
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
+// optimizability constants
+const optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+};
+let isPlatformReservedTag;
+function optimize(root, options) {
+    if (!root)
+        return;
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+    const check = (child) => {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
+    }
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    const children = el.children;
+    const optimizedChildren = [];
+    let currentOptimizableGroup = [];
+    const pushGroup = () => {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
+}
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
+}
+const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some((d) => !isBuiltInDir(d.name)));
+}
+// <select v-model> cannot be optimized because it requires a runtime check
+// to determine proper selected option
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some((d) => d.name === 'model'));
 }
 
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-const RAW = 0;
-const INTERPOLATION = 1;
-const EXPRESSION = 2;
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genSSRElement);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state, genSSRElement);
-    }
-    else if (el.tag === 'template' && !el.slotTarget) {
-        return el.ssrOptimizability === optimizability.FULL
-            ? genChildrenAsStringNode(el, state)
-            : genSSRChildren(el, state) || 'void 0';
-    }
-    switch (el.ssrOptimizability) {
-        case optimizability.FULL:
-            // stringify whole tree
-            return genStringElement(el, state);
-        case optimizability.SELF:
-            // stringify self and check children
-            return genStringElementWithChildren(el, state);
-        case optimizability.CHILDREN:
-            // generate self as VNode and stringify children
-            return genNormalElement(el, state, true);
-        case optimizability.PARTIAL:
-            // generate self as VNode and check children
-            return genNormalElement(el, state, false);
-        default:
-            // bail whole tree
-            return genElement(el, state);
-    }
-}
-function genNormalElement(el, state, stringifyChildren) {
-    const data = el.plain ? undefined : genData(el, state);
-    const children = stringifyChildren
-        ? `[${genChildrenAsStringNode(el, state)}]`
-        : genSSRChildren(el, state, true);
-    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-}
-function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-}
-function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-}
-function genChildrenAsStringNode(el, state) {
-    return el.children.length
-        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-        : '';
-}
-function genStringElement(el, state) {
-    return `_ssrNode(${elementToString(el, state)})`;
-}
-function genStringElementWithChildren(el, state) {
-    const children = genSSRChildren(el, state, true);
-    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-}
-function elementToString(el, state) {
-    return `(${flattenSegments(elementToSegments(el, state))})`;
-}
-function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-        el.forProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genFor(el, state, elementToString, '_ssrList'),
-            },
-        ];
-    }
-    else if (el.if && !el.ifProcessed) {
-        el.ifProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genIf(el, state, elementToString, '"<!---->"'),
-            },
-        ];
-    }
-    else if (el.tag === 'template') {
-        return childrenToSegments(el, state);
-    }
-    const openSegments = elementToOpenTagSegments(el, state);
-    const childrenSegments = childrenToSegments(el, state);
-    const { isUnaryTag } = state.options;
-    const close = isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: `</${el.tag}>` }];
-    return openSegments.concat(childrenSegments, close);
-}
-function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state);
-    let binding;
-    const segments = [{ type: RAW, value: `<${el.tag}` }];
-    // attrs
-    if (el.attrs) {
-        segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-    }
-    segments.push({ type: RAW, value: `>` });
-    return segments;
-}
-function childrenToSegments(el, state) {
-    let binding;
-    if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    return el.children ? nodesToSegments(el.children, state) : [];
-}
-function nodesToSegments(children, state) {
-    const segments = [];
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.type === 1) {
-            segments.push.apply(segments, elementToSegments(c, state));
-        }
-        else if (c.type === 2) {
-            segments.push({ type: INTERPOLATION, value: c.expression });
-        }
-        else if (c.type === 3) {
-            let text = escape(c.text);
-            if (c.isComment) {
-                text = '<!--' + text + '-->';
-            }
-            segments.push({ type: RAW, value: text });
-        }
-    }
-    return segments;
-}
-function flattenSegments(segments) {
-    const mergedSegments = [];
-    let textBuffer = '';
-    const pushBuffer = () => {
-        if (textBuffer) {
-            mergedSegments.push(JSON.stringify(textBuffer));
-            textBuffer = '';
-        }
-    };
-    for (let i = 0; i < segments.length; i++) {
-        const s = segments[i];
-        if (s.type === RAW) {
-            textBuffer += s.value;
-        }
-        else if (s.type === INTERPOLATION) {
-            pushBuffer();
-            mergedSegments.push(`_ssrEscape(${s.value})`);
-        }
-        else if (s.type === EXPRESSION) {
-            pushBuffer();
-            mergedSegments.push(`(${s.value})`);
-        }
-    }
-    pushBuffer();
-    return mergedSegments.join('+');
+// The SSR codegen is essentially extending the default codegen to handle
+// segment types
+const RAW = 0;
+const INTERPOLATION = 1;
+const EXPRESSION = 2;
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    const data = el.plain ? undefined : genData(el, state);
+    const children = stringifyChildren
+        ? `[${genChildrenAsStringNode(el, state)}]`
+        : genSSRChildren(el, state, true);
+    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+        : '';
+}
+function genStringElement(el, state) {
+    return `_ssrNode(${elementToString(el, state)})`;
+}
+function genStringElementWithChildren(el, state) {
+    const children = genSSRChildren(el, state, true);
+    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+}
+function elementToString(el, state) {
+    return `(${flattenSegments(elementToSegments(el, state))})`;
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            },
+        ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            },
+        ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    const openSegments = elementToOpenTagSegments(el, state);
+    const childrenSegments = childrenToSegments(el, state);
+    const { isUnaryTag } = state.options;
+    const close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: `</${el.tag}>` }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    let binding;
+    const segments = [{ type: RAW, value: `<${el.tag}` }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+    }
+    segments.push({ type: RAW, value: `>` });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    let binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    const segments = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            let text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
+}
+function flattenSegments(segments) {
+    const mergedSegments = [];
+    let textBuffer = '';
+    const pushBuffer = () => {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(`_ssrEscape(${s.value})`);
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(`(${s.value})`);
+        }
+    }
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop$1;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop$1;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = typeof (msg) === 'string' ? { msg } : msg;
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    optimize(ast, options);
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    optimize(ast, options);
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile: compile$1, compileToFunctions } = createCompiler(baseOptions);
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-const ssrHelpers = {
-    _ssrEscape: escape,
-    _ssrNode: renderStringNode$1,
-    _ssrList: renderStringList,
-    _ssrAttr: renderAttr,
-    _ssrAttrs: renderAttrs,
-    _ssrDOMProps: renderDOMProps,
-    _ssrClass: renderSSRClass,
-    _ssrStyle: renderSSRStyle,
-};
-function installSSRHelpers(vm) {
-    if (vm._ssrNode) {
-        return;
-    }
-    let Vue = vm.constructor;
-    // @ts-expect-error
-    while (Vue.super) {
-        // @ts-expect-error
-        Vue = Vue.super;
-    }
-    extend(Vue.prototype, ssrHelpers);
-    // @ts-expect-error
-    if (Vue.FunctionalRenderContext) {
-        // @ts-expect-error
-        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-    }
-}
-class StringNode {
-    isString;
-    open;
-    close;
-    children;
-    constructor(open, close, children, normalizationType) {
-        this.isString = true;
-        this.open = open;
-        this.close = close;
-        if (children) {
-            this.children =
-                normalizationType === 1
-                    ? simpleNormalizeChildren(children)
-                    : normalizationType === 2
-                        ? normalizeChildren(children)
-                        : children;
-        }
-        else {
-            this.children = void 0;
-        }
-    }
-}
-function renderStringNode$1(open, close, children, normalizationType) {
-    return new StringNode(open, close, children, normalizationType);
-}
-function renderStringList(val, render) {
-    let ret = '';
-    let i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        for (i = 0, l = val.length; i < l; i++) {
-            ret += render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        for (i = 0; i < val; i++) {
-            ret += render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        keys = Object.keys(val);
-        for (i = 0, l = keys.length; i < l; i++) {
-            key = keys[i];
-            ret += render(val[key], key, i);
-        }
-    }
-    return ret;
-}
-function renderAttrs(obj) {
-    let res = '';
-    for (const key in obj) {
-        if (isSSRUnsafeAttr(key)) {
-            continue;
-        }
-        res += renderAttr(key, obj[key]);
-    }
-    return res;
-}
-function renderDOMProps(obj) {
-    let res = '';
-    for (const key in obj) {
-        const attr = propsToAttrMap[key] || key.toLowerCase();
-        if (isRenderableAttr(attr)) {
-            res += renderAttr(attr, obj[key]);
-        }
-    }
-    return res;
-}
-function renderSSRClass(staticClass, dynamic) {
-    const res = renderClass$1(staticClass, dynamic);
-    return res === '' ? res : ` class="${escape(res)}"`;
-}
-function renderSSRStyle(staticStyle, dynamic, extra) {
-    const style = {};
-    if (staticStyle)
-        extend(style, staticStyle);
-    if (dynamic)
-        extend(style, normalizeStyleBinding(dynamic));
-    if (extra)
-        extend(style, extra);
-    const res = genStyle(style);
-    return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
+const ssrHelpers = {
+    _ssrEscape: escape,
+    _ssrNode: renderStringNode$1,
+    _ssrList: renderStringList,
+    _ssrAttr: renderAttr,
+    _ssrAttrs: renderAttrs,
+    _ssrDOMProps: renderDOMProps,
+    _ssrClass: renderSSRClass,
+    _ssrStyle: renderSSRStyle,
+};
+function installSSRHelpers(vm) {
+    if (vm._ssrNode) {
+        return;
+    }
+    let Vue = vm.constructor;
+    // @ts-expect-error
+    while (Vue.super) {
+        // @ts-expect-error
+        Vue = Vue.super;
+    }
+    extend(Vue.prototype, ssrHelpers);
+    // @ts-expect-error
+    if (Vue.FunctionalRenderContext) {
+        // @ts-expect-error
+        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+    }
+}
+class StringNode {
+    isString;
+    open;
+    close;
+    children;
+    constructor(open, close, children, normalizationType) {
+        this.isString = true;
+        this.open = open;
+        this.close = close;
+        if (children) {
+            this.children =
+                normalizationType === 1
+                    ? simpleNormalizeChildren(children)
+                    : normalizationType === 2
+                        ? normalizeChildren(children)
+                        : children;
+        }
+        else {
+            this.children = void 0;
+        }
+    }
+}
+function renderStringNode$1(open, close, children, normalizationType) {
+    return new StringNode(open, close, children, normalizationType);
+}
+function renderStringList(val, render) {
+    let ret = '';
+    let i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        for (i = 0, l = val.length; i < l; i++) {
+            ret += render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        for (i = 0; i < val; i++) {
+            ret += render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        keys = Object.keys(val);
+        for (i = 0, l = keys.length; i < l; i++) {
+            key = keys[i];
+            ret += render(val[key], key, i);
+        }
+    }
+    return ret;
+}
+function renderAttrs(obj) {
+    let res = '';
+    for (const key in obj) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        res += renderAttr(key, obj[key]);
+    }
+    return res;
+}
+function renderDOMProps(obj) {
+    let res = '';
+    for (const key in obj) {
+        const attr = propsToAttrMap[key] || key.toLowerCase();
+        if (isRenderableAttr(attr)) {
+            res += renderAttr(attr, obj[key]);
+        }
+    }
+    return res;
+}
+function renderSSRClass(staticClass, dynamic) {
+    const res = renderClass$1(staticClass, dynamic);
+    return res === '' ? res : ` class="${escape(res)}"`;
+}
+function renderSSRStyle(staticStyle, dynamic, extra) {
+    const style = {};
+    if (staticStyle)
+        extend(style, staticStyle);
+    if (dynamic)
+        extend(style, normalizeStyleBinding(dynamic));
+    if (extra)
+        extend(style, extra);
+    const res = genStyle(style);
+    return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-{
-    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
+/* not type checking this file because flow doesn't play well with Proxy */
+{
+    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn$2('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn$2('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn$2('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
 }
 
-let target;
-function add(event, fn) {
-    target.$on(event, fn);
-}
-function remove(event, fn) {
-    target.$off(event, fn);
-}
-function createOnceHandler(event, fn) {
-    const _target = target;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
-    target = undefined;
+let target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    const _target = target;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
+    target = undefined;
 }
 
-let activeInstance = null;
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook(vm, "deactivated");
-    }
-}
-function callHook(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, "deactivated");
+    }
+}
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
 }
 
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    warn$2(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-let warned = Object.create(null);
-const warnOnce = (msg) => {
-    if (!warned[msg]) {
-        warned[msg] = true;
-        // eslint-disable-next-line no-console
-        console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
-    }
-};
-const onCompilationError = (err, vm) => {
-    const trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
-};
-const normalizeRender = (vm) => {
-    const { render, template, _scopeId } = vm.$options;
-    if (isUndef(render)) {
-        if (template) {
-            const compiled = compileToFunctions(template, {
-                scopeId: _scopeId,
-                warn: onCompilationError,
-            }, vm);
-            vm.$options.render = compiled.render;
-            vm.$options.staticRenderFns = compiled.staticRenderFns;
-        }
-        else {
-            throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
-        }
-    }
-};
-function waitForServerPrefetch(vm, resolve, reject) {
-    let handlers = vm.$options.serverPrefetch;
-    if (isDef(handlers)) {
-        if (!Array.isArray(handlers))
-            handlers = [handlers];
-        try {
-            const promises = [];
-            for (let i = 0, j = handlers.length; i < j; i++) {
-                const result = handlers[i].call(vm, vm);
-                if (result && typeof result.then === 'function') {
-                    promises.push(result);
-                }
-            }
-            Promise.all(promises).then(resolve).catch(reject);
-            return;
-        }
-        catch (e) {
-            reject(e);
-        }
-    }
-    resolve();
-}
-function renderNode(node, isRoot, context) {
-    if (node.isString) {
-        renderStringNode(node, context);
-    }
-    else if (isDef(node.componentOptions)) {
-        renderComponent(node, isRoot, context);
-    }
-    else if (isDef(node.tag)) {
-        renderElement(node, isRoot, context);
-    }
-    else if (isTrue(node.isComment)) {
-        if (isDef(node.asyncFactory)) {
-            // async component
-            renderAsyncComponent(node, isRoot, context);
-        }
-        else {
-            context.write(`<!--${node.text}-->`, context.next);
-        }
-    }
-    else {
-        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
-    }
-}
-function registerComponentForCache(options, write) {
-    // exposed by vue-loader, need to call this if cache hit because
-    // component lifecycle hooks will not be called.
-    const register = options._ssrRegister;
-    if (write.caching && isDef(register)) {
-        write.componentBuffer[write.componentBuffer.length - 1].add(register);
-    }
-    return register;
-}
-function renderComponent(node, isRoot, context) {
-    const { write, next, userContext } = context;
-    // check cache hit
-    const Ctor = node.componentOptions.Ctor;
-    const getKey = Ctor.options.serverCacheKey;
-    const name = Ctor.options.name;
-    const cache = context.cache;
-    const registerComponent = registerComponentForCache(Ctor.options, write);
-    if (isDef(getKey) && isDef(cache) && isDef(name)) {
-        const rawKey = getKey(node.componentOptions.propsData);
-        if (rawKey === false) {
-            renderComponentInner(node, isRoot, context);
-            return;
-        }
-        const key = name + '::' + rawKey;
-        const { has, get } = context;
-        if (isDef(has)) {
-            has(key, (hit) => {
-                if (hit === true && isDef(get)) {
-                    get(key, (res) => {
-                        if (isDef(registerComponent)) {
-                            registerComponent(userContext);
-                        }
-                        res.components.forEach((register) => register(userContext));
-                        write(res.html, next);
-                    });
-                }
-                else {
-                    renderComponentWithCache(node, isRoot, key, context);
-                }
-            });
-        }
-        else if (isDef(get)) {
-            get(key, (res) => {
-                if (isDef(res)) {
-                    if (isDef(registerComponent)) {
-                        registerComponent(userContext);
-                    }
-                    res.components.forEach((register) => register(userContext));
-                    write(res.html, next);
-                }
-                else {
-                    renderComponentWithCache(node, isRoot, key, context);
-                }
-            });
-        }
-    }
-    else {
-        if (isDef(getKey) && isUndef(cache)) {
-            warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
-                'but no cache was provided to the renderer.');
-        }
-        if (isDef(getKey) && isUndef(name)) {
-            warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
-                `must also define a unique "name" option.`);
-        }
-        renderComponentInner(node, isRoot, context);
-    }
-}
-function renderComponentWithCache(node, isRoot, key, context) {
-    const write = context.write;
-    write.caching = true;
-    const buffer = write.cacheBuffer;
-    const bufferIndex = buffer.push('') - 1;
-    const componentBuffer = write.componentBuffer;
-    componentBuffer.push(new Set());
-    context.renderStates.push({
-        type: 'ComponentWithCache',
-        key,
-        buffer,
-        bufferIndex,
-        componentBuffer,
-    });
-    renderComponentInner(node, isRoot, context);
-}
-function renderComponentInner(node, isRoot, context) {
-    const prevActive = context.activeInstance;
-    // expose userContext on vnode
-    node.ssrContext = context.userContext;
-    const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
-    normalizeRender(child);
-    const resolve = () => {
-        const childNode = child._render();
-        childNode.parent = node;
-        context.renderStates.push({
-            type: 'Component',
-            prevActive,
-        });
-        renderNode(childNode, isRoot, context);
-    };
-    const reject = context.done;
-    waitForServerPrefetch(child, resolve, reject);
-}
-function renderAsyncComponent(node, isRoot, context) {
-    const factory = node.asyncFactory;
-    const resolve = (comp) => {
-        if (comp.__esModule && comp.default) {
-            comp = comp.default;
-        }
-        const { data, children, tag } = node.asyncMeta;
-        const nodeContext = node.asyncMeta.context;
-        const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
-        if (resolvedNode) {
-            if (resolvedNode.componentOptions) {
-                // normal component
-                renderComponent(resolvedNode, isRoot, context);
-            }
-            else if (!Array.isArray(resolvedNode)) {
-                // single return node from functional component
-                renderNode(resolvedNode, isRoot, context);
-            }
-            else {
-                // multiple return nodes from functional component
-                context.renderStates.push({
-                    type: 'Fragment',
-                    children: resolvedNode,
-                    rendered: 0,
-                    total: resolvedNode.length,
-                });
-                context.next();
-            }
-        }
-        else {
-            // invalid component, but this does not throw on the client
-            // so render empty comment node
-            context.write(`<!---->`, context.next);
-        }
-    };
-    if (factory.resolved) {
-        resolve(factory.resolved);
-        return;
-    }
-    const reject = context.done;
-    let res;
-    try {
-        res = factory(resolve, reject);
-    }
-    catch (e) {
-        reject(e);
-    }
-    if (res) {
-        if (typeof res.then === 'function') {
-            res.then(resolve, reject).catch(reject);
-        }
-        else {
-            // new syntax in 2.3
-            const comp = res.component;
-            if (comp && typeof comp.then === 'function') {
-                comp.then(resolve, reject).catch(reject);
-            }
-        }
-    }
-}
-function renderStringNode(el, context) {
-    const { write, next } = context;
-    if (isUndef(el.children) || el.children.length === 0) {
-        write(el.open + (el.close || ''), next);
-    }
-    else {
-        const children = el.children;
-        context.renderStates.push({
-            type: 'Element',
-            children,
-            rendered: 0,
-            total: children.length,
-            endTag: el.close,
-        });
-        write(el.open, next);
-    }
-}
-function renderElement(el, isRoot, context) {
-    const { write, next } = context;
-    if (isTrue(isRoot)) {
-        if (!el.data)
-            el.data = {};
-        if (!el.data.attrs)
-            el.data.attrs = {};
-        el.data.attrs[SSR_ATTR] = 'true';
-    }
-    if (el.fnOptions) {
-        registerComponentForCache(el.fnOptions, write);
-    }
-    const startTag = renderStartingTag(el, context);
-    const endTag = `</${el.tag}>`;
-    if (context.isUnaryTag(el.tag)) {
-        write(startTag, next);
-    }
-    else if (isUndef(el.children) || el.children.length === 0) {
-        write(startTag + endTag, next);
-    }
-    else {
-        const children = el.children;
-        context.renderStates.push({
-            type: 'Element',
-            children,
-            rendered: 0,
-            total: children.length,
-            endTag,
-        });
-        write(startTag, next);
-    }
-}
-function hasAncestorData(node) {
-    const parentNode = node.parent;
-    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
-}
-function getVShowDirectiveInfo(node) {
-    let dir;
-    let tmp;
-    while (isDef(node)) {
-        if (node.data && node.data.directives) {
-            tmp = node.data.directives.find((dir) => dir.name === 'show');
-            if (tmp) {
-                dir = tmp;
-            }
-        }
-        node = node.parent;
-    }
-    //@ts-expect-error
-    return dir;
-}
-function renderStartingTag(node, context) {
-    let markup = `<${node.tag}`;
-    const { directives, modules } = context;
-    // construct synthetic data for module processing
-    // because modules like style also produce code by parent VNode data
-    if (isUndef(node.data) && hasAncestorData(node)) {
-        node.data = {};
-    }
-    if (isDef(node.data)) {
-        // check directives
-        const dirs = node.data.directives;
-        if (dirs) {
-            for (let i = 0; i < dirs.length; i++) {
-                const name = dirs[i].name;
-                if (name !== 'show') {
-                    const dirRenderer = resolveAsset(context, 'directives', name);
-                    if (dirRenderer) {
-                        // directives mutate the node's data
-                        // which then gets rendered by modules
-                        dirRenderer(node, dirs[i]);
-                    }
-                }
-            }
-        }
-        // v-show directive needs to be merged from parent to child
-        const vshowDirectiveInfo = getVShowDirectiveInfo(node);
-        if (vshowDirectiveInfo) {
-            directives.show(node, vshowDirectiveInfo);
-        }
-        // apply other modules
-        for (let i = 0; i < modules.length; i++) {
-            const res = modules[i](node);
-            if (res) {
-                markup += res;
-            }
-        }
-    }
-    // attach scoped CSS ID
-    let scopeId;
-    const activeInstance = context.activeInstance;
-    if (isDef(activeInstance) &&
-        activeInstance !== node.context &&
-        isDef((scopeId = activeInstance.$options._scopeId))) {
-        markup += ` ${scopeId}`;
-    }
-    if (isDef(node.fnScopeId)) {
-        markup += ` ${node.fnScopeId}`;
-    }
-    else {
-        while (isDef(node)) {
-            //@ts-expect-error
-            if (isDef((scopeId = node.context.$options._scopeId))) {
-                markup += ` ${scopeId}`;
-            }
-            node = node.parent;
-        }
-    }
-    return markup + '>';
-}
-function createRenderFunction(modules, directives, isUnaryTag, cache) {
-    return function render(component, write, userContext, done) {
-        warned = Object.create(null);
-        const context = new RenderContext({
-            activeInstance: component,
-            userContext,
-            write,
-            done,
-            renderNode,
-            isUnaryTag,
-            modules,
-            directives,
-            cache,
-        });
-        installSSRHelpers(component);
-        normalizeRender(component);
-        const resolve = () => {
-            renderNode(component._render(), true, context);
-        };
-        waitForServerPrefetch(component, resolve, done);
-    };
+let warned = Object.create(null);
+const warnOnce = (msg) => {
+    if (!warned[msg]) {
+        warned[msg] = true;
+        // eslint-disable-next-line no-console
+        console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
+    }
+};
+const onCompilationError = (err, vm) => {
+    const trace = vm ? generateComponentTrace(vm) : '';
+    throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
+};
+const normalizeRender = (vm) => {
+    const { render, template, _scopeId } = vm.$options;
+    if (isUndef(render)) {
+        if (template) {
+            const compiled = compileToFunctions(template, {
+                scopeId: _scopeId,
+                warn: onCompilationError,
+            }, vm);
+            vm.$options.render = compiled.render;
+            vm.$options.staticRenderFns = compiled.staticRenderFns;
+        }
+        else {
+            throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
+        }
+    }
+};
+function waitForServerPrefetch(vm, resolve, reject) {
+    let handlers = vm.$options.serverPrefetch;
+    if (isDef(handlers)) {
+        if (!Array.isArray(handlers))
+            handlers = [handlers];
+        try {
+            const promises = [];
+            for (let i = 0, j = handlers.length; i < j; i++) {
+                const result = handlers[i].call(vm, vm);
+                if (result && typeof result.then === 'function') {
+                    promises.push(result);
+                }
+            }
+            Promise.all(promises).then(resolve).catch(reject);
+            return;
+        }
+        catch (e) {
+            reject(e);
+        }
+    }
+    resolve();
+}
+function renderNode(node, isRoot, context) {
+    if (node.isString) {
+        renderStringNode(node, context);
+    }
+    else if (isDef(node.componentOptions)) {
+        renderComponent(node, isRoot, context);
+    }
+    else if (isDef(node.tag)) {
+        renderElement(node, isRoot, context);
+    }
+    else if (isTrue(node.isComment)) {
+        if (isDef(node.asyncFactory)) {
+            // async component
+            renderAsyncComponent(node, isRoot, context);
+        }
+        else {
+            context.write(`<!--${node.text}-->`, context.next);
+        }
+    }
+    else {
+        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+    }
+}
+function registerComponentForCache(options, write) {
+    // exposed by vue-loader, need to call this if cache hit because
+    // component lifecycle hooks will not be called.
+    const register = options._ssrRegister;
+    if (write.caching && isDef(register)) {
+        write.componentBuffer[write.componentBuffer.length - 1].add(register);
+    }
+    return register;
+}
+function renderComponent(node, isRoot, context) {
+    const { write, next, userContext } = context;
+    // check cache hit
+    const Ctor = node.componentOptions.Ctor;
+    const getKey = Ctor.options.serverCacheKey;
+    const name = Ctor.options.name;
+    const cache = context.cache;
+    const registerComponent = registerComponentForCache(Ctor.options, write);
+    if (isDef(getKey) && isDef(cache) && isDef(name)) {
+        const rawKey = getKey(node.componentOptions.propsData);
+        if (rawKey === false) {
+            renderComponentInner(node, isRoot, context);
+            return;
+        }
+        const key = name + '::' + rawKey;
+        const { has, get } = context;
+        if (isDef(has)) {
+            has(key, (hit) => {
+                if (hit === true && isDef(get)) {
+                    get(key, (res) => {
+                        if (isDef(registerComponent)) {
+                            registerComponent(userContext);
+                        }
+                        res.components.forEach((register) => register(userContext));
+                        write(res.html, next);
+                    });
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+        else if (isDef(get)) {
+            get(key, (res) => {
+                if (isDef(res)) {
+                    if (isDef(registerComponent)) {
+                        registerComponent(userContext);
+                    }
+                    res.components.forEach((register) => register(userContext));
+                    write(res.html, next);
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+    }
+    else {
+        if (isDef(getKey) && isUndef(cache)) {
+            warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
+                'but no cache was provided to the renderer.');
+        }
+        if (isDef(getKey) && isUndef(name)) {
+            warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
+                `must also define a unique "name" option.`);
+        }
+        renderComponentInner(node, isRoot, context);
+    }
+}
+function renderComponentWithCache(node, isRoot, key, context) {
+    const write = context.write;
+    write.caching = true;
+    const buffer = write.cacheBuffer;
+    const bufferIndex = buffer.push('') - 1;
+    const componentBuffer = write.componentBuffer;
+    componentBuffer.push(new Set());
+    context.renderStates.push({
+        type: 'ComponentWithCache',
+        key,
+        buffer,
+        bufferIndex,
+        componentBuffer,
+    });
+    renderComponentInner(node, isRoot, context);
+}
+function renderComponentInner(node, isRoot, context) {
+    const prevActive = context.activeInstance;
+    // expose userContext on vnode
+    node.ssrContext = context.userContext;
+    const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+    normalizeRender(child);
+    const resolve = () => {
+        const childNode = child._render();
+        childNode.parent = node;
+        context.renderStates.push({
+            type: 'Component',
+            prevActive,
+        });
+        renderNode(childNode, isRoot, context);
+    };
+    const reject = context.done;
+    waitForServerPrefetch(child, resolve, reject);
+}
+function renderAsyncComponent(node, isRoot, context) {
+    const factory = node.asyncFactory;
+    const resolve = (comp) => {
+        if (comp.__esModule && comp.default) {
+            comp = comp.default;
+        }
+        const { data, children, tag } = node.asyncMeta;
+        const nodeContext = node.asyncMeta.context;
+        const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+        if (resolvedNode) {
+            if (resolvedNode.componentOptions) {
+                // normal component
+                renderComponent(resolvedNode, isRoot, context);
+            }
+            else if (!Array.isArray(resolvedNode)) {
+                // single return node from functional component
+                renderNode(resolvedNode, isRoot, context);
+            }
+            else {
+                // multiple return nodes from functional component
+                context.renderStates.push({
+                    type: 'Fragment',
+                    children: resolvedNode,
+                    rendered: 0,
+                    total: resolvedNode.length,
+                });
+                context.next();
+            }
+        }
+        else {
+            // invalid component, but this does not throw on the client
+            // so render empty comment node
+            context.write(`<!---->`, context.next);
+        }
+    };
+    if (factory.resolved) {
+        resolve(factory.resolved);
+        return;
+    }
+    const reject = context.done;
+    let res;
+    try {
+        res = factory(resolve, reject);
+    }
+    catch (e) {
+        reject(e);
+    }
+    if (res) {
+        if (typeof res.then === 'function') {
+            res.then(resolve, reject).catch(reject);
+        }
+        else {
+            // new syntax in 2.3
+            const comp = res.component;
+            if (comp && typeof comp.then === 'function') {
+                comp.then(resolve, reject).catch(reject);
+            }
+        }
+    }
+}
+function renderStringNode(el, context) {
+    const { write, next } = context;
+    if (isUndef(el.children) || el.children.length === 0) {
+        write(el.open + (el.close || ''), next);
+    }
+    else {
+        const children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children,
+            rendered: 0,
+            total: children.length,
+            endTag: el.close,
+        });
+        write(el.open, next);
+    }
+}
+function renderElement(el, isRoot, context) {
+    const { write, next } = context;
+    if (isTrue(isRoot)) {
+        if (!el.data)
+            el.data = {};
+        if (!el.data.attrs)
+            el.data.attrs = {};
+        el.data.attrs[SSR_ATTR] = 'true';
+    }
+    if (el.fnOptions) {
+        registerComponentForCache(el.fnOptions, write);
+    }
+    const startTag = renderStartingTag(el, context);
+    const endTag = `</${el.tag}>`;
+    if (context.isUnaryTag(el.tag)) {
+        write(startTag, next);
+    }
+    else if (isUndef(el.children) || el.children.length === 0) {
+        write(startTag + endTag, next);
+    }
+    else {
+        const children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children,
+            rendered: 0,
+            total: children.length,
+            endTag,
+        });
+        write(startTag, next);
+    }
+}
+function hasAncestorData(node) {
+    const parentNode = node.parent;
+    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+}
+function getVShowDirectiveInfo(node) {
+    let dir;
+    let tmp;
+    while (isDef(node)) {
+        if (node.data && node.data.directives) {
+            tmp = node.data.directives.find((dir) => dir.name === 'show');
+            if (tmp) {
+                dir = tmp;
+            }
+        }
+        node = node.parent;
+    }
+    //@ts-expect-error
+    return dir;
+}
+function renderStartingTag(node, context) {
+    let markup = `<${node.tag}`;
+    const { directives, modules } = context;
+    // construct synthetic data for module processing
+    // because modules like style also produce code by parent VNode data
+    if (isUndef(node.data) && hasAncestorData(node)) {
+        node.data = {};
+    }
+    if (isDef(node.data)) {
+        // check directives
+        const dirs = node.data.directives;
+        if (dirs) {
+            for (let i = 0; i < dirs.length; i++) {
+                const name = dirs[i].name;
+                if (name !== 'show') {
+                    const dirRenderer = resolveAsset(context, 'directives', name);
+                    if (dirRenderer) {
+                        // directives mutate the node's data
+                        // which then gets rendered by modules
+                        dirRenderer(node, dirs[i]);
+                    }
+                }
+            }
+        }
+        // v-show directive needs to be merged from parent to child
+        const vshowDirectiveInfo = getVShowDirectiveInfo(node);
+        if (vshowDirectiveInfo) {
+            directives.show(node, vshowDirectiveInfo);
+        }
+        // apply other modules
+        for (let i = 0; i < modules.length; i++) {
+            const res = modules[i](node);
+            if (res) {
+                markup += res;
+            }
+        }
+    }
+    // attach scoped CSS ID
+    let scopeId;
+    const activeInstance = context.activeInstance;
+    if (isDef(activeInstance) &&
+        activeInstance !== node.context &&
+        isDef((scopeId = activeInstance.$options._scopeId))) {
+        markup += ` ${scopeId}`;
+    }
+    if (isDef(node.fnScopeId)) {
+        markup += ` ${node.fnScopeId}`;
+    }
+    else {
+        while (isDef(node)) {
+            //@ts-expect-error
+            if (isDef((scopeId = node.context.$options._scopeId))) {
+                markup += ` ${scopeId}`;
+            }
+            node = node.parent;
+        }
+    }
+    return markup + '>';
+}
+function createRenderFunction(modules, directives, isUnaryTag, cache) {
+    return function render(component, write, userContext, done) {
+        warned = Object.create(null);
+        const context = new RenderContext({
+            activeInstance: component,
+            userContext,
+            write,
+            done,
+            renderNode,
+            isUnaryTag,
+            modules,
+            directives,
+            cache,
+        });
+        installSSRHelpers(component);
+        normalizeRender(component);
+        const resolve = () => {
+            renderNode(component._render(), true, context);
+        };
+        waitForServerPrefetch(component, resolve, done);
+    };
 }
 
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
-const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
-function createPromiseCallback() {
-    let resolve, reject;
-    const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
-    const cb = (err, res) => {
-        if (err)
-            return reject(err);
-        resolve(res || '');
-    };
-    return { promise, cb };
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
+function createPromiseCallback() {
+    let resolve, reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    const cb = (err, res) => {
+        if (err)
+            return reject(err);
+        resolve(res || '');
+    };
+    return { promise, cb };
 }
 
-class TemplateStream extends stream.Transform {
-    started;
-    renderer;
-    template;
-    context;
-    inject;
-    constructor(renderer, template, context) {
-        super();
-        this.started = false;
-        this.renderer = renderer;
-        this.template = template;
-        this.context = context || {};
-        this.inject = renderer.inject;
-    }
-    _transform(data, encoding, done) {
-        if (!this.started) {
-            this.emit('beforeStart');
-            this.start();
-        }
-        this.push(data);
-        done();
-    }
-    start() {
-        this.started = true;
-        this.push(this.template.head(this.context));
-        if (this.inject) {
-            // inline server-rendered head meta information
-            if (this.context.head) {
-                this.push(this.context.head);
-            }
-            // inline preload/prefetch directives for initial/async chunks
-            const links = this.renderer.renderResourceHints(this.context);
-            if (links) {
-                this.push(links);
-            }
-            // CSS files and inline server-rendered CSS collected by vue-style-loader
-            const styles = this.renderer.renderStyles(this.context);
-            if (styles) {
-                this.push(styles);
-            }
-        }
-        this.push(this.template.neck(this.context));
-    }
-    _flush(done) {
-        this.emit('beforeEnd');
-        if (this.inject) {
-            // inline initial store state
-            const state = this.renderer.renderState(this.context);
-            if (state) {
-                this.push(state);
-            }
-            // embed scripts needed
-            const scripts = this.renderer.renderScripts(this.context);
-            if (scripts) {
-                this.push(scripts);
-            }
-        }
-        this.push(this.template.tail(this.context));
-        done();
-    }
+class TemplateStream extends stream.Transform {
+    started;
+    renderer;
+    template;
+    context;
+    inject;
+    constructor(renderer, template, context) {
+        super();
+        this.started = false;
+        this.renderer = renderer;
+        this.template = template;
+        this.context = context || {};
+        this.inject = renderer.inject;
+    }
+    _transform(data, encoding, done) {
+        if (!this.started) {
+            this.emit('beforeStart');
+            this.start();
+        }
+        this.push(data);
+        done();
+    }
+    start() {
+        this.started = true;
+        this.push(this.template.head(this.context));
+        if (this.inject) {
+            // inline server-rendered head meta information
+            if (this.context.head) {
+                this.push(this.context.head);
+            }
+            // inline preload/prefetch directives for initial/async chunks
+            const links = this.renderer.renderResourceHints(this.context);
+            if (links) {
+                this.push(links);
+            }
+            // CSS files and inline server-rendered CSS collected by vue-style-loader
+            const styles = this.renderer.renderStyles(this.context);
+            if (styles) {
+                this.push(styles);
+            }
+        }
+        this.push(this.template.neck(this.context));
+    }
+    _flush(done) {
+        this.emit('beforeEnd');
+        if (this.inject) {
+            // inline initial store state
+            const state = this.renderer.renderState(this.context);
+            if (state) {
+                this.push(state);
+            }
+            // embed scripts needed
+            const scripts = this.renderer.renderScripts(this.context);
+            if (scripts) {
+                this.push(scripts);
+            }
+        }
+        this.push(this.template.tail(this.context));
+        done();
+    }
 }
 
-const compile = require('lodash.template');
-const compileOptions = {
-    escape: /{{([^{][\s\S]+?[^}])}}/g,
-    interpolate: /{{{([\s\S]+?)}}}/g,
-};
-function parseTemplate(template, contentPlaceholder = '<!--vue-ssr-outlet-->') {
-    if (typeof template === 'object') {
-        return template;
-    }
-    let i = template.indexOf('</head>');
-    const j = template.indexOf(contentPlaceholder);
-    if (j < 0) {
-        throw new Error(`Content placeholder not found in template.`);
-    }
-    if (i < 0) {
-        i = template.indexOf('<body>');
-        if (i < 0) {
-            i = j;
-        }
-    }
-    return {
-        head: compile(template.slice(0, i), compileOptions),
-        neck: compile(template.slice(i, j), compileOptions),
-        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
-    };
+const compile = require('lodash.template');
+const compileOptions = {
+    escape: /{{([^{][\s\S]+?[^}])}}/g,
+    interpolate: /{{{([\s\S]+?)}}}/g,
+};
+function parseTemplate(template, contentPlaceholder = '<!--vue-ssr-outlet-->') {
+    if (typeof template === 'object') {
+        return template;
+    }
+    let i = template.indexOf('</head>');
+    const j = template.indexOf(contentPlaceholder);
+    if (j < 0) {
+        throw new Error(`Content placeholder not found in template.`);
+    }
+    if (i < 0) {
+        i = template.indexOf('<body>');
+        if (i < 0) {
+            i = j;
+        }
+    }
+    return {
+        head: compile(template.slice(0, i), compileOptions),
+        neck: compile(template.slice(i, j), compileOptions),
+        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
+    };
 }
 
-/**
- * Creates a mapper that maps components used during a server-side render
- * to async chunk files in the client-side build, so that we can inline them
- * directly in the rendered HTML to avoid waterfall requests.
- */
-function createMapper(clientManifest) {
-    const map = createMap(clientManifest);
-    // map server-side moduleIds to client-side files
-    return function mapper(moduleIds) {
-        const res = new Set();
-        for (let i = 0; i < moduleIds.length; i++) {
-            const mapped = map.get(moduleIds[i]);
-            if (mapped) {
-                for (let j = 0; j < mapped.length; j++) {
-                    res.add(mapped[j]);
-                }
-            }
-        }
-        return Array.from(res);
-    };
-}
-function createMap(clientManifest) {
-    const map = new Map();
-    Object.keys(clientManifest.modules).forEach((id) => {
-        map.set(id, mapIdToFile(id, clientManifest));
-    });
-    return map;
-}
-function mapIdToFile(id, clientManifest) {
-    const files = [];
-    const fileIndices = clientManifest.modules[id];
-    if (fileIndices) {
-        fileIndices.forEach((index) => {
-            const file = clientManifest.all[index];
-            // only include async files or non-js, non-css assets
-            if (file &&
-                (clientManifest.async.indexOf(file) > -1 ||
-                    !/\.(js|css)($|\?)/.test(file))) {
-                files.push(file);
-            }
-        });
-    }
-    return files;
+/**
+ * Creates a mapper that maps components used during a server-side render
+ * to async chunk files in the client-side build, so that we can inline them
+ * directly in the rendered HTML to avoid waterfall requests.
+ */
+function createMapper(clientManifest) {
+    const map = createMap(clientManifest);
+    // map server-side moduleIds to client-side files
+    return function mapper(moduleIds) {
+        const res = new Set();
+        for (let i = 0; i < moduleIds.length; i++) {
+            const mapped = map.get(moduleIds[i]);
+            if (mapped) {
+                for (let j = 0; j < mapped.length; j++) {
+                    res.add(mapped[j]);
+                }
+            }
+        }
+        return Array.from(res);
+    };
+}
+function createMap(clientManifest) {
+    const map = new Map();
+    Object.keys(clientManifest.modules).forEach((id) => {
+        map.set(id, mapIdToFile(id, clientManifest));
+    });
+    return map;
+}
+function mapIdToFile(id, clientManifest) {
+    const files = [];
+    const fileIndices = clientManifest.modules[id];
+    if (fileIndices) {
+        fileIndices.forEach((index) => {
+            const file = clientManifest.all[index];
+            // only include async files or non-js, non-css assets
+            if (file &&
+                (clientManifest.async.indexOf(file) > -1 ||
+                    !/\.(js|css)($|\?)/.test(file))) {
+                files.push(file);
+            }
+        });
+    }
+    return files;
 }
 
-const path$2 = require('path');
-const serialize = require('serialize-javascript');
-class TemplateRenderer {
-    options;
-    inject;
-    parsedTemplate;
-    //@ts-expect-error
-    publicPath;
-    //@ts-expect-error
-    clientManifest;
-    //@ts-expect-error
-    preloadFiles;
-    //@ts-expect-error
-    prefetchFiles;
-    //@ts-expect-error
-    mapFiles;
-    serialize;
-    constructor(options) {
-        this.options = options;
-        this.inject = options.inject !== false;
-        // if no template option is provided, the renderer is created
-        // as a utility object for rendering assets like preload links and scripts.
-        const { template } = options;
-        this.parsedTemplate = template
-            ? typeof template === 'string'
-                ? parseTemplate(template)
-                : template
-            : null;
-        // function used to serialize initial state JSON
-        this.serialize =
-            options.serializer ||
-                ((state) => {
-                    return serialize(state, { isJSON: true });
-                });
-        // extra functionality with client manifest
-        if (options.clientManifest) {
-            const clientManifest = (this.clientManifest = options.clientManifest);
-            // ensure publicPath ends with /
-            this.publicPath =
-                clientManifest.publicPath === ''
-                    ? ''
-                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-            // preload/prefetch directives
-            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-            // initial async chunk mapping
-            this.mapFiles = createMapper(clientManifest);
-        }
-    }
-    bindRenderFns(context) {
-        const renderer = this;
-        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
-            context[`render${type}`] = renderer[`render${type}`].bind(renderer, context);
-        });
-        // also expose getPreloadFiles, useful for HTTP/2 push
-        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
-    }
-    // render synchronously given rendered app content and render context
-    render(content, context) {
-        const template = this.parsedTemplate;
-        if (!template) {
-            throw new Error('render cannot be called without a template.');
-        }
-        context = context || {};
-        if (typeof template === 'function') {
-            return template(content, context);
-        }
-        if (this.inject) {
-            return (template.head(context) +
-                (context.head || '') +
-                this.renderResourceHints(context) +
-                this.renderStyles(context) +
-                template.neck(context) +
-                content +
-                this.renderState(context) +
-                this.renderScripts(context) +
-                template.tail(context));
-        }
-        else {
-            return (template.head(context) +
-                template.neck(context) +
-                content +
-                template.tail(context));
-        }
-    }
-    renderStyles(context) {
-        const initial = this.preloadFiles || [];
-        const async = this.getUsedAsyncFiles(context) || [];
-        const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file));
-        return (
-        // render links for css files
-        (cssFiles.length
-            ? cssFiles
-                .map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`)
-                .join('')
-            : '') +
-            // context.styles is a getter exposed by vue-style-loader which contains
-            // the inline component styles collected during SSR
-            (context.styles || ''));
-    }
-    renderResourceHints(context) {
-        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
-    }
-    getPreloadFiles(context) {
-        const usedAsyncFiles = this.getUsedAsyncFiles(context);
-        if (this.preloadFiles || usedAsyncFiles) {
-            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
-        }
-        else {
-            return [];
-        }
-    }
-    renderPreloadLinks(context) {
-        const files = this.getPreloadFiles(context);
-        const shouldPreload = this.options.shouldPreload;
-        if (files.length) {
-            return files
-                .map(({ file, extension, fileWithoutQuery, asType }) => {
-                let extra = '';
-                // by default, we only preload scripts or css
-                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-                    return '';
-                }
-                // user wants to explicitly control what to preload
-                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (asType === 'font') {
-                    extra = ` type="font/${extension}" crossorigin`;
-                }
-                return `<link rel="preload" href="${this.publicPath}${file}"${asType !== '' ? ` as="${asType}"` : ''}${extra}>`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    renderPrefetchLinks(context) {
-        const shouldPrefetch = this.options.shouldPrefetch;
-        if (this.prefetchFiles) {
-            const usedAsyncFiles = this.getUsedAsyncFiles(context);
-            const alreadyRendered = (file) => {
-                return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file);
-            };
-            return this.prefetchFiles
-                .map(({ file, fileWithoutQuery, asType }) => {
-                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (alreadyRendered(file)) {
-                    return '';
-                }
-                return `<link rel="prefetch" href="${this.publicPath}${file}">`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    renderState(context, options) {
-        const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } = options || {};
-        const state = this.serialize(context[contextKey]);
-        const autoRemove = '';
-        const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : '';
-        return context[contextKey]
-            ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
-            : '';
-    }
-    renderScripts(context) {
-        if (this.clientManifest) {
-            const initial = this.preloadFiles.filter(({ file }) => isJS(file));
-            const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file));
-            const needed = [initial[0]].concat(async, initial.slice(1));
-            return needed
-                .map(({ file }) => {
-                return `<script src="${this.publicPath}${file}" defer></script>`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    getUsedAsyncFiles(context) {
-        if (!context._mappedFiles &&
-            context._registeredComponents &&
-            this.mapFiles) {
-            const registered = Array.from(context._registeredComponents);
-            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-        }
-        return context._mappedFiles;
-    }
-    // create a transform stream
-    createStream(context) {
-        if (!this.parsedTemplate) {
-            throw new Error('createStream cannot be called without a template.');
-        }
-        //@ts-expect-error
-        return new TemplateStream(this, this.parsedTemplate, context || {});
-    }
-}
-function normalizeFile(file) {
-    const withoutQuery = file.replace(/\?.*/, '');
-    const extension = path$2.extname(withoutQuery).slice(1);
-    return {
-        file,
-        extension,
-        fileWithoutQuery: withoutQuery,
-        asType: getPreloadType(extension),
-    };
-}
-function getPreloadType(ext) {
-    if (ext === 'js') {
-        return 'script';
-    }
-    else if (ext === 'css') {
-        return 'style';
-    }
-    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
-        return 'image';
-    }
-    else if (/woff2?|ttf|otf|eot/.test(ext)) {
-        return 'font';
-    }
-    else {
-        // not exhausting all possibilities here, but above covers common cases
-        return '';
-    }
+const path$2 = require('path');
+const serialize = require('serialize-javascript');
+class TemplateRenderer {
+    options;
+    inject;
+    parsedTemplate;
+    //@ts-expect-error
+    publicPath;
+    //@ts-expect-error
+    clientManifest;
+    //@ts-expect-error
+    preloadFiles;
+    //@ts-expect-error
+    prefetchFiles;
+    //@ts-expect-error
+    mapFiles;
+    serialize;
+    constructor(options) {
+        this.options = options;
+        this.inject = options.inject !== false;
+        // if no template option is provided, the renderer is created
+        // as a utility object for rendering assets like preload links and scripts.
+        const { template } = options;
+        this.parsedTemplate = template
+            ? typeof template === 'string'
+                ? parseTemplate(template)
+                : template
+            : null;
+        // function used to serialize initial state JSON
+        this.serialize =
+            options.serializer ||
+                ((state) => {
+                    return serialize(state, { isJSON: true });
+                });
+        // extra functionality with client manifest
+        if (options.clientManifest) {
+            const clientManifest = (this.clientManifest = options.clientManifest);
+            // ensure publicPath ends with /
+            this.publicPath =
+                clientManifest.publicPath === ''
+                    ? ''
+                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
+            // preload/prefetch directives
+            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
+            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
+            // initial async chunk mapping
+            this.mapFiles = createMapper(clientManifest);
+        }
+    }
+    bindRenderFns(context) {
+        const renderer = this;
+        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
+            context[`render${type}`] = renderer[`render${type}`].bind(renderer, context);
+        });
+        // also expose getPreloadFiles, useful for HTTP/2 push
+        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
+    }
+    // render synchronously given rendered app content and render context
+    render(content, context) {
+        const template = this.parsedTemplate;
+        if (!template) {
+            throw new Error('render cannot be called without a template.');
+        }
+        context = context || {};
+        if (typeof template === 'function') {
+            return template(content, context);
+        }
+        if (this.inject) {
+            return (template.head(context) +
+                (context.head || '') +
+                this.renderResourceHints(context) +
+                this.renderStyles(context) +
+                template.neck(context) +
+                content +
+                this.renderState(context) +
+                this.renderScripts(context) +
+                template.tail(context));
+        }
+        else {
+            return (template.head(context) +
+                template.neck(context) +
+                content +
+                template.tail(context));
+        }
+    }
+    renderStyles(context) {
+        const initial = this.preloadFiles || [];
+        const async = this.getUsedAsyncFiles(context) || [];
+        const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file));
+        return (
+        // render links for css files
+        (cssFiles.length
+            ? cssFiles
+                .map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`)
+                .join('')
+            : '') +
+            // context.styles is a getter exposed by vue-style-loader which contains
+            // the inline component styles collected during SSR
+            (context.styles || ''));
+    }
+    renderResourceHints(context) {
+        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
+    }
+    getPreloadFiles(context) {
+        const usedAsyncFiles = this.getUsedAsyncFiles(context);
+        if (this.preloadFiles || usedAsyncFiles) {
+            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
+        }
+        else {
+            return [];
+        }
+    }
+    renderPreloadLinks(context) {
+        const files = this.getPreloadFiles(context);
+        const shouldPreload = this.options.shouldPreload;
+        if (files.length) {
+            return files
+                .map(({ file, extension, fileWithoutQuery, asType }) => {
+                let extra = '';
+                // by default, we only preload scripts or css
+                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+                    return '';
+                }
+                // user wants to explicitly control what to preload
+                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (asType === 'font') {
+                    extra = ` type="font/${extension}" crossorigin`;
+                }
+                return `<link rel="preload" href="${this.publicPath}${file}"${asType !== '' ? ` as="${asType}"` : ''}${extra}>`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    renderPrefetchLinks(context) {
+        const shouldPrefetch = this.options.shouldPrefetch;
+        if (this.prefetchFiles) {
+            const usedAsyncFiles = this.getUsedAsyncFiles(context);
+            const alreadyRendered = (file) => {
+                return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file);
+            };
+            return this.prefetchFiles
+                .map(({ file, fileWithoutQuery, asType }) => {
+                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (alreadyRendered(file)) {
+                    return '';
+                }
+                return `<link rel="prefetch" href="${this.publicPath}${file}">`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    renderState(context, options) {
+        const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } = options || {};
+        const state = this.serialize(context[contextKey]);
+        const autoRemove = '';
+        const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : '';
+        return context[contextKey]
+            ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
+            : '';
+    }
+    renderScripts(context) {
+        if (this.clientManifest) {
+            const initial = this.preloadFiles.filter(({ file }) => isJS(file));
+            const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file));
+            const needed = [initial[0]].concat(async, initial.slice(1));
+            return needed
+                .map(({ file }) => {
+                return `<script src="${this.publicPath}${file}" defer></script>`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    getUsedAsyncFiles(context) {
+        if (!context._mappedFiles &&
+            context._registeredComponents &&
+            this.mapFiles) {
+            const registered = Array.from(context._registeredComponents);
+            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
+        }
+        return context._mappedFiles;
+    }
+    // create a transform stream
+    createStream(context) {
+        if (!this.parsedTemplate) {
+            throw new Error('createStream cannot be called without a template.');
+        }
+        //@ts-expect-error
+        return new TemplateStream(this, this.parsedTemplate, context || {});
+    }
+}
+function normalizeFile(file) {
+    const withoutQuery = file.replace(/\?.*/, '');
+    const extension = path$2.extname(withoutQuery).slice(1);
+    return {
+        file,
+        extension,
+        fileWithoutQuery: withoutQuery,
+        asType: getPreloadType(extension),
+    };
+}
+function getPreloadType(ext) {
+    if (ext === 'js') {
+        return 'script';
+    }
+    else if (ext === 'css') {
+        return 'style';
+    }
+    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
+        return 'image';
+    }
+    else if (/woff2?|ttf|otf|eot/.test(ext)) {
+        return 'font';
+    }
+    else {
+        // not exhausting all possibilities here, but above covers common cases
+        return '';
+    }
 }
 
-function createRenderer$1({ modules = [], directives = {}, isUnaryTag = () => false, template, inject, cache, shouldPreload, shouldPrefetch, clientManifest, serializer, } = {}) {
-    const render = createRenderFunction(modules, directives, isUnaryTag, cache);
-    const templateRenderer = new TemplateRenderer({
-        template,
-        inject,
-        // @ts-expect-error
-        shouldPreload,
-        // @ts-expect-error
-        shouldPrefetch,
-        clientManifest,
-        serializer,
-    });
-    return {
-        renderToString(component, context, cb) {
-            if (typeof context === 'function') {
-                cb = context;
-                context = {};
-            }
-            if (context) {
-                templateRenderer.bindRenderFns(context);
-            }
-            // no callback, return Promise
-            let promise;
-            if (!cb) {
-                ({ promise, cb } = createPromiseCallback());
-            }
-            let result = '';
-            const write = createWriteFunction((text) => {
-                result += text;
-                return false;
-            }, cb);
-            try {
-                // @ts-expect-error TODO improve
-                render(component, write, context, (err) => {
-                    if (err) {
-                        return cb(err);
-                    }
-                    if (context && context.rendered) {
-                        context.rendered(context);
-                    }
-                    if (template) {
-                        try {
-                            const res = templateRenderer.render(result, context);
-                            if (typeof res !== 'string') {
-                                // function template returning promise
-                                res.then((html) => cb(null, html)).catch(cb);
-                            }
-                            else {
-                                cb(null, res);
-                            }
-                        }
-                        catch (e) {
-                            cb(e);
-                        }
-                    }
-                    else {
-                        cb(null, result);
-                    }
-                });
-            }
-            catch (e) {
-                cb(e);
-            }
-            return promise;
-        },
-        renderToStream(component, context) {
-            if (context) {
-                templateRenderer.bindRenderFns(context);
-            }
-            const renderStream = new RenderStream((write, done) => {
-                // @ts-expect-error
-                render(component, write, context, done);
-            });
-            if (!template) {
-                // @ts-expect-error
-                if (context && context.rendered) {
-                    // @ts-expect-error
-                    const rendered = context.rendered;
-                    renderStream.once('beforeEnd', () => {
-                        rendered(context);
-                    });
-                }
-                return renderStream;
-            }
-            else if (typeof template === 'function') {
-                throw new Error(`function template is only supported in renderToString.`);
-            }
-            else {
-                const templateStream = templateRenderer.createStream(context);
-                renderStream.on('error', (err) => {
-                    templateStream.emit('error', err);
-                });
-                renderStream.pipe(templateStream);
-                //@ts-expect-error
-                if (context && context.rendered) {
-                    //@ts-expect-error
-                    const rendered = context.rendered;
-                    renderStream.once('beforeEnd', () => {
-                        rendered(context);
-                    });
-                }
-                return templateStream;
-            }
-        },
-    };
+function createRenderer$1({ modules = [], directives = {}, isUnaryTag = () => false, template, inject, cache, shouldPreload, shouldPrefetch, clientManifest, serializer, } = {}) {
+    const render = createRenderFunction(modules, directives, isUnaryTag, cache);
+    const templateRenderer = new TemplateRenderer({
+        template,
+        inject,
+        // @ts-expect-error
+        shouldPreload,
+        // @ts-expect-error
+        shouldPrefetch,
+        clientManifest,
+        serializer,
+    });
+    return {
+        renderToString(component, context, cb) {
+            if (typeof context === 'function') {
+                cb = context;
+                context = {};
+            }
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            // no callback, return Promise
+            let promise;
+            if (!cb) {
+                ({ promise, cb } = createPromiseCallback());
+            }
+            let result = '';
+            const write = createWriteFunction((text) => {
+                result += text;
+                return false;
+            }, cb);
+            try {
+                // @ts-expect-error TODO improve
+                render(component, write, context, (err) => {
+                    if (err) {
+                        return cb(err);
+                    }
+                    if (context && context.rendered) {
+                        context.rendered(context);
+                    }
+                    if (template) {
+                        try {
+                            const res = templateRenderer.render(result, context);
+                            if (typeof res !== 'string') {
+                                // function template returning promise
+                                res.then((html) => cb(null, html)).catch(cb);
+                            }
+                            else {
+                                cb(null, res);
+                            }
+                        }
+                        catch (e) {
+                            cb(e);
+                        }
+                    }
+                    else {
+                        cb(null, result);
+                    }
+                });
+            }
+            catch (e) {
+                cb(e);
+            }
+            return promise;
+        },
+        renderToStream(component, context) {
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            const renderStream = new RenderStream((write, done) => {
+                // @ts-expect-error
+                render(component, write, context, done);
+            });
+            if (!template) {
+                // @ts-expect-error
+                if (context && context.rendered) {
+                    // @ts-expect-error
+                    const rendered = context.rendered;
+                    renderStream.once('beforeEnd', () => {
+                        rendered(context);
+                    });
+                }
+                return renderStream;
+            }
+            else if (typeof template === 'function') {
+                throw new Error(`function template is only supported in renderToString.`);
+            }
+            else {
+                const templateStream = templateRenderer.createStream(context);
+                renderStream.on('error', (err) => {
+                    templateStream.emit('error', err);
+                });
+                renderStream.pipe(templateStream);
+                //@ts-expect-error
+                if (context && context.rendered) {
+                    //@ts-expect-error
+                    const rendered = context.rendered;
+                    renderStream.once('beforeEnd', () => {
+                        rendered(context);
+                    });
+                }
+                return templateStream;
+            }
+        },
+    };
 }
 
-const vm = require('vm');
-const path$1 = require('path');
-const resolve = require('resolve');
-const NativeModule = require('module');
-function createSandbox(context) {
-    const sandbox = {
-        Buffer,
-        console,
-        process,
-        setTimeout,
-        setInterval,
-        setImmediate,
-        clearTimeout,
-        clearInterval,
-        clearImmediate,
-        __VUE_SSR_CONTEXT__: context,
-    };
-    // @ts-expect-error
-    sandbox.global = sandbox;
-    return sandbox;
-}
-function compileModule(files, basedir, runInNewContext) {
-    const compiledScripts = {};
-    const resolvedModules = {};
-    function getCompiledScript(filename) {
-        if (compiledScripts[filename]) {
-            return compiledScripts[filename];
-        }
-        const code = files[filename];
-        const wrapper = NativeModule.wrap(code);
-        const script = new vm.Script(wrapper, {
-            filename,
-            displayErrors: true,
-        });
-        compiledScripts[filename] = script;
-        return script;
-    }
-    function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
-        if (evaluatedFiles[filename]) {
-            return evaluatedFiles[filename];
-        }
-        const script = getCompiledScript(filename);
-        const compiledWrapper = runInNewContext === false
-            ? script.runInThisContext()
-            : script.runInNewContext(sandbox);
-        const m = { exports: {} };
-        const r = (file) => {
-            file = path$1.posix.join('.', file);
-            if (files[file]) {
-                return evaluateModule(file, sandbox, evaluatedFiles);
-            }
-            else if (basedir) {
-                return require(resolvedModules[file] ||
-                    (resolvedModules[file] = resolve.sync(file, { basedir })));
-            }
-            else {
-                return require(file);
-            }
-        };
-        compiledWrapper.call(m.exports, m.exports, r, m);
-        const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-            ? // @ts-expect-error
-                m.exports.default
-            : m.exports;
-        evaluatedFiles[filename] = res;
-        return res;
-    }
-    return evaluateModule;
-}
-function deepClone(val) {
-    if (isPlainObject(val)) {
-        const res = {};
-        for (const key in val) {
-            res[key] = deepClone(val[key]);
-        }
-        return res;
-    }
-    else if (Array.isArray(val)) {
-        return val.slice();
-    }
-    else {
-        return val;
-    }
-}
-function createBundleRunner(entry, files, basedir, runInNewContext) {
-    const evaluate = compileModule(files, basedir, runInNewContext);
-    if (runInNewContext !== false && runInNewContext !== 'once') {
-        // new context mode: creates a fresh context and re-evaluate the bundle
-        // on each render. Ensures entire application state is fresh for each
-        // render, but incurs extra evaluation cost.
-        return (userContext = {}) => new Promise((resolve) => {
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            const res = evaluate(entry, createSandbox(userContext));
-            resolve(typeof res === 'function' ? res(userContext) : res);
-        });
-    }
-    else {
-        // direct mode: instead of re-evaluating the whole bundle on
-        // each render, it simply calls the exported function. This avoids the
-        // module evaluation costs but requires the source code to be structured
-        // slightly differently.
-        let runner; // lazy creation so that errors can be caught by user
-        let initialContext;
-        return (userContext = {}) => new Promise((resolve) => {
-            if (!runner) {
-                const sandbox = runInNewContext === 'once' ? createSandbox() : global;
-                // the initial context is only used for collecting possible non-component
-                // styles injected by vue-style-loader.
-                // @ts-expect-error
-                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
-                runner = evaluate(entry, sandbox);
-                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-                // to prevent cross-request pollution.
-                // @ts-expect-error
-                delete sandbox.__VUE_SSR_CONTEXT__;
-                if (typeof runner !== 'function') {
-                    throw new Error('bundle export should be a function when using ' +
-                        '{ runInNewContext: false }.');
-                }
-            }
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            // vue-style-loader styles imported outside of component lifecycle hooks
-            if (initialContext._styles) {
-                // @ts-expect-error
-                userContext._styles = deepClone(initialContext._styles);
-                // #6353 ensure "styles" is exposed even if no styles are injected
-                // in component lifecycles.
-                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-                const renderStyles = initialContext._renderStyles;
-                if (renderStyles) {
-                    Object.defineProperty(userContext, 'styles', {
-                        enumerable: true,
-                        get() {
-                            // @ts-expect-error
-                            return renderStyles(userContext._styles);
-                        },
-                    });
-                }
-            }
-            resolve(runner(userContext));
-        });
-    }
+const vm = require('vm');
+const path$1 = require('path');
+const resolve = require('resolve');
+const NativeModule = require('module');
+function createSandbox(context) {
+    const sandbox = {
+        Buffer,
+        console,
+        process,
+        setTimeout,
+        setInterval,
+        setImmediate,
+        clearTimeout,
+        clearInterval,
+        clearImmediate,
+        __VUE_SSR_CONTEXT__: context,
+    };
+    // @ts-expect-error
+    sandbox.global = sandbox;
+    return sandbox;
+}
+function compileModule(files, basedir, runInNewContext) {
+    const compiledScripts = {};
+    const resolvedModules = {};
+    function getCompiledScript(filename) {
+        if (compiledScripts[filename]) {
+            return compiledScripts[filename];
+        }
+        const code = files[filename];
+        const wrapper = NativeModule.wrap(code);
+        const script = new vm.Script(wrapper, {
+            filename,
+            displayErrors: true,
+        });
+        compiledScripts[filename] = script;
+        return script;
+    }
+    function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
+        if (evaluatedFiles[filename]) {
+            return evaluatedFiles[filename];
+        }
+        const script = getCompiledScript(filename);
+        const compiledWrapper = runInNewContext === false
+            ? script.runInThisContext()
+            : script.runInNewContext(sandbox);
+        const m = { exports: {} };
+        const r = (file) => {
+            file = path$1.posix.join('.', file);
+            if (files[file]) {
+                return evaluateModule(file, sandbox, evaluatedFiles);
+            }
+            else if (basedir) {
+                return require(resolvedModules[file] ||
+                    (resolvedModules[file] = resolve.sync(file, { basedir })));
+            }
+            else {
+                return require(file);
+            }
+        };
+        compiledWrapper.call(m.exports, m.exports, r, m);
+        const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
+            ? // @ts-expect-error
+                m.exports.default
+            : m.exports;
+        evaluatedFiles[filename] = res;
+        return res;
+    }
+    return evaluateModule;
+}
+function deepClone(val) {
+    if (isPlainObject(val)) {
+        const res = {};
+        for (const key in val) {
+            res[key] = deepClone(val[key]);
+        }
+        return res;
+    }
+    else if (Array.isArray(val)) {
+        return val.slice();
+    }
+    else {
+        return val;
+    }
+}
+function createBundleRunner(entry, files, basedir, runInNewContext) {
+    const evaluate = compileModule(files, basedir, runInNewContext);
+    if (runInNewContext !== false && runInNewContext !== 'once') {
+        // new context mode: creates a fresh context and re-evaluate the bundle
+        // on each render. Ensures entire application state is fresh for each
+        // render, but incurs extra evaluation cost.
+        return (userContext = {}) => new Promise((resolve) => {
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            const res = evaluate(entry, createSandbox(userContext));
+            resolve(typeof res === 'function' ? res(userContext) : res);
+        });
+    }
+    else {
+        // direct mode: instead of re-evaluating the whole bundle on
+        // each render, it simply calls the exported function. This avoids the
+        // module evaluation costs but requires the source code to be structured
+        // slightly differently.
+        let runner; // lazy creation so that errors can be caught by user
+        let initialContext;
+        return (userContext = {}) => new Promise((resolve) => {
+            if (!runner) {
+                const sandbox = runInNewContext === 'once' ? createSandbox() : global;
+                // the initial context is only used for collecting possible non-component
+                // styles injected by vue-style-loader.
+                // @ts-expect-error
+                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
+                runner = evaluate(entry, sandbox);
+                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+                // to prevent cross-request pollution.
+                // @ts-expect-error
+                delete sandbox.__VUE_SSR_CONTEXT__;
+                if (typeof runner !== 'function') {
+                    throw new Error('bundle export should be a function when using ' +
+                        '{ runInNewContext: false }.');
+                }
+            }
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            // vue-style-loader styles imported outside of component lifecycle hooks
+            if (initialContext._styles) {
+                // @ts-expect-error
+                userContext._styles = deepClone(initialContext._styles);
+                // #6353 ensure "styles" is exposed even if no styles are injected
+                // in component lifecycles.
+                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+                const renderStyles = initialContext._renderStyles;
+                if (renderStyles) {
+                    Object.defineProperty(userContext, 'styles', {
+                        enumerable: true,
+                        get() {
+                            // @ts-expect-error
+                            return renderStyles(userContext._styles);
+                        },
+                    });
+                }
+            }
+            resolve(runner(userContext));
+        });
+    }
 }
 
-const SourceMapConsumer = require('source-map').SourceMapConsumer;
-const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
-function createSourceMapConsumers(rawMaps) {
-    const maps = {};
-    Object.keys(rawMaps).forEach((file) => {
-        maps[file] = new SourceMapConsumer(rawMaps[file]);
-    });
-    return maps;
-}
-function rewriteErrorTrace(e, mapConsumers) {
-    if (e && typeof e.stack === 'string') {
-        e.stack = e.stack
-            .split('\n')
-            .map((line) => {
-            return rewriteTraceLine(line, mapConsumers);
-        })
-            .join('\n');
-    }
-}
-function rewriteTraceLine(trace, mapConsumers) {
-    const m = trace.match(filenameRE);
-    const map = m && mapConsumers[m[1]];
-    if (m != null && map) {
-        const originalPosition = map.originalPositionFor({
-            line: Number(m[2]),
-            column: Number(m[3]),
-        });
-        if (originalPosition.source != null) {
-            const { source, line, column } = originalPosition;
-            const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`;
-            return trace.replace(filenameRE, mappedPosition);
-        }
-        else {
-            return trace;
-        }
-    }
-    else {
-        return trace;
-    }
+const SourceMapConsumer = require('source-map').SourceMapConsumer;
+const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
+function createSourceMapConsumers(rawMaps) {
+    const maps = {};
+    Object.keys(rawMaps).forEach((file) => {
+        maps[file] = new SourceMapConsumer(rawMaps[file]);
+    });
+    return maps;
+}
+function rewriteErrorTrace(e, mapConsumers) {
+    if (e && typeof e.stack === 'string') {
+        e.stack = e.stack
+            .split('\n')
+            .map((line) => {
+            return rewriteTraceLine(line, mapConsumers);
+        })
+            .join('\n');
+    }
+}
+function rewriteTraceLine(trace, mapConsumers) {
+    const m = trace.match(filenameRE);
+    const map = m && mapConsumers[m[1]];
+    if (m != null && map) {
+        const originalPosition = map.originalPositionFor({
+            line: Number(m[2]),
+            column: Number(m[3]),
+        });
+        if (originalPosition.source != null) {
+            const { source, line, column } = originalPosition;
+            const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`;
+            return trace.replace(filenameRE, mappedPosition);
+        }
+        else {
+            return trace;
+        }
+    }
+    else {
+        return trace;
+    }
 }
 
-const fs = require('fs');
-const path = require('path');
-const PassThrough = require('stream').PassThrough;
-const INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
-    'or a bundle Object of type:\n\n' +
+const fs = require('fs');
+const path = require('path');
+const PassThrough = require('stream').PassThrough;
+const INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
+    'or a bundle Object of type:\n\n' +
     `{
   entry: string;
   files: { [filename: string]: string; };
   maps: { [filename: string]: string; };
-}\n`;
-function createBundleRendererCreator(createRenderer) {
-    return function createBundleRenderer(bundle, rendererOptions = {}) {
-        let files, entry, maps;
-        let basedir = rendererOptions.basedir;
-        // load bundle if given filepath
-        if (typeof bundle === 'string' &&
-            /\.js(on)?$/.test(bundle) &&
-            path.isAbsolute(bundle)) {
-            if (fs.existsSync(bundle)) {
-                const isJSON = /\.json$/.test(bundle);
-                basedir = basedir || path.dirname(bundle);
-                bundle = fs.readFileSync(bundle, 'utf-8');
-                if (isJSON) {
-                    try {
-                        // @ts-expect-error
-                        bundle = JSON.parse(bundle);
-                    }
-                    catch (e) {
-                        throw new Error(`Invalid JSON bundle file: ${bundle}`);
-                    }
-                }
-            }
-            else {
-                throw new Error(`Cannot locate bundle file: ${bundle}`);
-            }
-        }
-        if (typeof bundle === 'object') {
-            entry = bundle.entry;
-            files = bundle.files;
-            basedir = basedir || bundle.basedir;
-            maps = createSourceMapConsumers(bundle.maps);
-            if (typeof entry !== 'string' || typeof files !== 'object') {
-                throw new Error(INVALID_MSG);
-            }
-        }
-        else if (typeof bundle === 'string') {
-            entry = '__vue_ssr_bundle__';
-            files = { __vue_ssr_bundle__: bundle };
-            maps = {};
-        }
-        else {
-            throw new Error(INVALID_MSG);
-        }
-        const renderer = createRenderer(rendererOptions);
-        const run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
-        return {
-            renderToString: (context, cb) => {
-                if (typeof context === 'function') {
-                    cb = context;
-                    context = {};
-                }
-                let promise;
-                if (!cb) {
-                    ({ promise, cb } = createPromiseCallback());
-                }
-                run(context)
-                    .catch((err) => {
-                    rewriteErrorTrace(err, maps);
-                    cb(err);
-                })
-                    .then((app) => {
-                    if (app) {
-                        //@ts-expect-error
-                        renderer.renderToString(app, context, (err, res) => {
-                            rewriteErrorTrace(err, maps);
-                            cb(err, res);
-                        });
-                    }
-                });
-                return promise;
-            },
-            renderToStream: (context) => {
-                const res = new PassThrough();
-                run(context)
-                    .catch((err) => {
-                    rewriteErrorTrace(err, maps);
-                    // avoid emitting synchronously before user can
-                    // attach error listener
-                    process.nextTick(() => {
-                        res.emit('error', err);
-                    });
-                })
-                    .then((app) => {
-                    if (app) {
-                        //@ts-expect-error
-                        const renderStream = renderer.renderToStream(app, context);
-                        renderStream.on('error', (err) => {
-                            rewriteErrorTrace(err, maps);
-                            res.emit('error', err);
-                        });
-                        // relay HTMLStream special events
-                        if (rendererOptions && rendererOptions.template) {
-                            renderStream.on('beforeStart', () => {
-                                res.emit('beforeStart');
-                            });
-                            renderStream.on('beforeEnd', () => {
-                                res.emit('beforeEnd');
-                            });
-                        }
-                        renderStream.pipe(res);
-                    }
-                });
-                return res;
-            },
-        };
-    };
+}\n`;
+function createBundleRendererCreator(createRenderer) {
+    return function createBundleRenderer(bundle, rendererOptions = {}) {
+        let files, entry, maps;
+        let basedir = rendererOptions.basedir;
+        // load bundle if given filepath
+        if (typeof bundle === 'string' &&
+            /\.js(on)?$/.test(bundle) &&
+            path.isAbsolute(bundle)) {
+            if (fs.existsSync(bundle)) {
+                const isJSON = /\.json$/.test(bundle);
+                basedir = basedir || path.dirname(bundle);
+                bundle = fs.readFileSync(bundle, 'utf-8');
+                if (isJSON) {
+                    try {
+                        // @ts-expect-error
+                        bundle = JSON.parse(bundle);
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid JSON bundle file: ${bundle}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Cannot locate bundle file: ${bundle}`);
+            }
+        }
+        if (typeof bundle === 'object') {
+            entry = bundle.entry;
+            files = bundle.files;
+            basedir = basedir || bundle.basedir;
+            maps = createSourceMapConsumers(bundle.maps);
+            if (typeof entry !== 'string' || typeof files !== 'object') {
+                throw new Error(INVALID_MSG);
+            }
+        }
+        else if (typeof bundle === 'string') {
+            entry = '__vue_ssr_bundle__';
+            files = { __vue_ssr_bundle__: bundle };
+            maps = {};
+        }
+        else {
+            throw new Error(INVALID_MSG);
+        }
+        const renderer = createRenderer(rendererOptions);
+        const run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
+        return {
+            renderToString: (context, cb) => {
+                if (typeof context === 'function') {
+                    cb = context;
+                    context = {};
+                }
+                let promise;
+                if (!cb) {
+                    ({ promise, cb } = createPromiseCallback());
+                }
+                run(context)
+                    .catch((err) => {
+                    rewriteErrorTrace(err, maps);
+                    cb(err);
+                })
+                    .then((app) => {
+                    if (app) {
+                        //@ts-expect-error
+                        renderer.renderToString(app, context, (err, res) => {
+                            rewriteErrorTrace(err, maps);
+                            cb(err, res);
+                        });
+                    }
+                });
+                return promise;
+            },
+            renderToStream: (context) => {
+                const res = new PassThrough();
+                run(context)
+                    .catch((err) => {
+                    rewriteErrorTrace(err, maps);
+                    // avoid emitting synchronously before user can
+                    // attach error listener
+                    process.nextTick(() => {
+                        res.emit('error', err);
+                    });
+                })
+                    .then((app) => {
+                    if (app) {
+                        //@ts-expect-error
+                        const renderStream = renderer.renderToStream(app, context);
+                        renderStream.on('error', (err) => {
+                            rewriteErrorTrace(err, maps);
+                            res.emit('error', err);
+                        });
+                        // relay HTMLStream special events
+                        if (rendererOptions && rendererOptions.template) {
+                            renderStream.on('beforeStart', () => {
+                                res.emit('beforeStart');
+                            });
+                            renderStream.on('beforeEnd', () => {
+                                res.emit('beforeEnd');
+                            });
+                        }
+                        renderStream.pipe(res);
+                    }
+                });
+                return res;
+            },
+        };
+    };
 }
 
-process.env.VUE_ENV = 'server';
-function createRenderer(options = {}) {
-    return createRenderer$1(extend(extend({}, options), {
-        isUnaryTag,
-        canBeLeftOpenTag,
-        modules: modules$1,
-        // user can provide server-side implementations for custom directives
-        // when creating the renderer.
-        directives: extend(baseDirectives$1, options.directives),
-    }));
-}
+process.env.VUE_ENV = 'server';
+function createRenderer(options = {}) {
+    return createRenderer$1(extend(extend({}, options), {
+        isUnaryTag,
+        canBeLeftOpenTag,
+        modules: modules$1,
+        // user can provide server-side implementations for custom directives
+        // when creating the renderer.
+        directives: extend(baseDirectives$1, options.directives),
+    }));
+}
 const createBundleRenderer = createBundleRendererCreator(createRenderer);
 
 exports.createBundleRenderer = createBundleRenderer;
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 40af65818a0..1301fcd323a 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -1,113 +1,113 @@
 'use strict';
 
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
 const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
 
-const { red, yellow } = require('chalk');
-const webpack = require('webpack');
-const prefix = `[vue-server-renderer-webpack-plugin]`;
-exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
-exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
-const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-const onEmit = (compiler, name, stageName, hook) => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        compiler.hooks.compilation.tap(name, compilation => {
-            if (compilation.compiler !== compiler) {
-                // Ignore child compilers
-                return;
-            }
-            const stage = webpack.Compilation[stageName];
-            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-                hook(compilation, cb);
-            });
-        });
-    }
-    else if (compiler.hooks) {
-        // Webpack >= 4.0.0
-        compiler.hooks.emit.tapAsync(name, hook);
-    }
-    else {
-        // Webpack < 4.0.0
-        compiler.plugin('emit', hook);
-    }
-};
-const stripModuleIdHash = id => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        return id.replace(/\|\w+$/, '');
-    }
-    // Webpack < 5.0.0
-    return id.replace(/\s\w+$/, '');
-};
-const getAssetName = asset => {
-    if (typeof asset === 'string') {
-        return asset;
-    }
-    return asset.name;
+const { red, yellow } = require('chalk');
+const webpack = require('webpack');
+const prefix = `[vue-server-renderer-webpack-plugin]`;
+exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
+exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
+const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
+const onEmit = (compiler, name, stageName, hook) => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        compiler.hooks.compilation.tap(name, compilation => {
+            if (compilation.compiler !== compiler) {
+                // Ignore child compilers
+                return;
+            }
+            const stage = webpack.Compilation[stageName];
+            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
+                hook(compilation, cb);
+            });
+        });
+    }
+    else if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
+};
+const stripModuleIdHash = id => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        return id.replace(/\|\w+$/, '');
+    }
+    // Webpack < 5.0.0
+    return id.replace(/\s\w+$/, '');
+};
+const getAssetName = asset => {
+    if (typeof asset === 'string') {
+        return asset;
+    }
+    return asset.name;
 };
 
-const hash = require("hash-sum");
-const uniq = require("lodash.uniq");
-class VueSSRClientPlugin {
-    constructor(options = {}) {
-        //@ts-expect-error no type on options
-        this.options = Object.assign({
-            filename: "vue-ssr-client-manifest.json",
-        }, options);
-    }
-    apply(compiler) {
-        const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
-        onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
-            const stats = compilation.getStats().toJson();
-            const allFiles = uniq(stats.assets.map((a) => a.name));
-            const initialFiles = uniq(Object.keys(stats.entrypoints)
-                .map((name) => stats.entrypoints[name].assets)
-                .reduce((assets, all) => all.concat(assets), [])
-                .map(getAssetName)
-                .filter((file) => isJS(file) || isCSS(file)));
-            const asyncFiles = allFiles
-                .filter((file) => isJS(file) || isCSS(file))
-                .filter((file) => initialFiles.indexOf(file) < 0);
-            const manifest = {
-                publicPath: stats.publicPath,
-                all: allFiles,
-                initial: initialFiles,
-                async: asyncFiles,
-                modules: {
-                /* [identifier: string]: Array<index: number> */
-                },
-            };
-            const assetModules = stats.modules.filter((m) => m.assets.length);
-            const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
-            stats.modules.forEach((m) => {
-                // ignore modules duplicated in multiple chunks
-                if (m.chunks.length === 1) {
-                    const cid = m.chunks[0];
-                    const chunk = stats.chunks.find((c) => c.id === cid);
-                    if (!chunk || !chunk.files) {
-                        return;
-                    }
-                    const id = stripModuleIdHash(m.identifier);
-                    const files = (manifest.modules[hash(id)] =
-                        chunk.files.map(fileToIndex));
-                    // find all asset modules associated with the same chunk
-                    assetModules.forEach((m) => {
-                        if (m.chunks.some((id) => id === cid)) {
-                            files.push.apply(files, m.assets.map(fileToIndex));
-                        }
-                    });
-                }
-            });
-            const json = JSON.stringify(manifest, null, 2);
-            //@ts-expect-error no type on options
-            compilation.assets[this.options.filename] = {
-                source: () => json,
-                size: () => json.length,
-            };
-            cb();
-        });
-    }
+const hash = require("hash-sum");
+const uniq = require("lodash.uniq");
+class VueSSRClientPlugin {
+    constructor(options = {}) {
+        //@ts-expect-error no type on options
+        this.options = Object.assign({
+            filename: "vue-ssr-client-manifest.json",
+        }, options);
+    }
+    apply(compiler) {
+        const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
+        onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
+            const stats = compilation.getStats().toJson();
+            const allFiles = uniq(stats.assets.map((a) => a.name));
+            const initialFiles = uniq(Object.keys(stats.entrypoints)
+                .map((name) => stats.entrypoints[name].assets)
+                .reduce((assets, all) => all.concat(assets), [])
+                .map(getAssetName)
+                .filter((file) => isJS(file) || isCSS(file)));
+            const asyncFiles = allFiles
+                .filter((file) => isJS(file) || isCSS(file))
+                .filter((file) => initialFiles.indexOf(file) < 0);
+            const manifest = {
+                publicPath: stats.publicPath,
+                all: allFiles,
+                initial: initialFiles,
+                async: asyncFiles,
+                modules: {
+                /* [identifier: string]: Array<index: number> */
+                },
+            };
+            const assetModules = stats.modules.filter((m) => m.assets.length);
+            const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
+            stats.modules.forEach((m) => {
+                // ignore modules duplicated in multiple chunks
+                if (m.chunks.length === 1) {
+                    const cid = m.chunks[0];
+                    const chunk = stats.chunks.find((c) => c.id === cid);
+                    if (!chunk || !chunk.files) {
+                        return;
+                    }
+                    const id = stripModuleIdHash(m.identifier);
+                    const files = (manifest.modules[hash(id)] =
+                        chunk.files.map(fileToIndex));
+                    // find all asset modules associated with the same chunk
+                    assetModules.forEach((m) => {
+                        if (m.chunks.some((id) => id === cid)) {
+                            files.push.apply(files, m.assets.map(fileToIndex));
+                        }
+                    });
+                }
+            });
+            const json = JSON.stringify(manifest, null, 2);
+            //@ts-expect-error no type on options
+            compilation.assets[this.options.filename] = {
+                source: () => json,
+                size: () => json.length,
+            };
+            cb();
+        });
+    }
 }
 
 module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index d8682e73387..2cdc79c9df7 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -2,117 +2,117 @@
 
 const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
 
-const { red, yellow } = require('chalk');
-const webpack = require('webpack');
-const prefix = `[vue-server-renderer-webpack-plugin]`;
-const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
-const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
-const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-const validate = compiler => {
-    if (compiler.options.target !== 'node') {
-        warn('webpack config `target` should be "node".');
-    }
-    if (compiler.options.output) {
-        if (compiler.options.output.library) {
-            // Webpack >= 5.0.0
-            if (compiler.options.output.library.type !== 'commonjs2') {
-                warn('webpack config `output.library.type` should be "commonjs2".');
-            }
-        }
-        else if (compiler.options.output.libraryTarget !== 'commonjs2') {
-            // Webpack < 5.0.0
-            warn('webpack config `output.libraryTarget` should be "commonjs2".');
-        }
-    }
-    if (!compiler.options.externals) {
-        tip('It is recommended to externalize dependencies in the server build for ' +
-            'better build performance.');
-    }
-};
-const onEmit = (compiler, name, stageName, hook) => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        compiler.hooks.compilation.tap(name, compilation => {
-            if (compilation.compiler !== compiler) {
-                // Ignore child compilers
-                return;
-            }
-            const stage = webpack.Compilation[stageName];
-            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-                hook(compilation, cb);
-            });
-        });
-    }
-    else if (compiler.hooks) {
-        // Webpack >= 4.0.0
-        compiler.hooks.emit.tapAsync(name, hook);
-    }
-    else {
-        // Webpack < 4.0.0
-        compiler.plugin('emit', hook);
-    }
-};
-const getAssetName = asset => {
-    if (typeof asset === 'string') {
-        return asset;
-    }
-    return asset.name;
+const { red, yellow } = require('chalk');
+const webpack = require('webpack');
+const prefix = `[vue-server-renderer-webpack-plugin]`;
+const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
+const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
+const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
+const validate = compiler => {
+    if (compiler.options.target !== 'node') {
+        warn('webpack config `target` should be "node".');
+    }
+    if (compiler.options.output) {
+        if (compiler.options.output.library) {
+            // Webpack >= 5.0.0
+            if (compiler.options.output.library.type !== 'commonjs2') {
+                warn('webpack config `output.library.type` should be "commonjs2".');
+            }
+        }
+        else if (compiler.options.output.libraryTarget !== 'commonjs2') {
+            // Webpack < 5.0.0
+            warn('webpack config `output.libraryTarget` should be "commonjs2".');
+        }
+    }
+    if (!compiler.options.externals) {
+        tip('It is recommended to externalize dependencies in the server build for ' +
+            'better build performance.');
+    }
+};
+const onEmit = (compiler, name, stageName, hook) => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        compiler.hooks.compilation.tap(name, compilation => {
+            if (compilation.compiler !== compiler) {
+                // Ignore child compilers
+                return;
+            }
+            const stage = webpack.Compilation[stageName];
+            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
+                hook(compilation, cb);
+            });
+        });
+    }
+    else if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
+};
+const getAssetName = asset => {
+    if (typeof asset === 'string') {
+        return asset;
+    }
+    return asset.name;
 };
 
-class VueSSRServerPlugin {
-    constructor(options = {}) {
-        //@ts-expect-error
-        this.options = Object.assign({
-            filename: 'vue-ssr-server-bundle.json',
-        }, options);
-    }
-    apply(compiler) {
-        validate(compiler);
-        const stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
-        onEmit(compiler, 'vue-server-plugin', stage, (compilation, cb) => {
-            const stats = compilation.getStats().toJson();
-            const entryName = Object.keys(stats.entrypoints)[0];
-            const entryInfo = stats.entrypoints[entryName];
-            if (!entryInfo) {
-                // #5553
-                return cb();
-            }
-            const entryAssets = entryInfo.assets
-                .map(getAssetName)
-                .filter(isJS);
-            if (entryAssets.length > 1) {
-                throw new Error(`Server-side bundle should have one single entry file. ` +
-                    `Avoid using CommonsChunkPlugin in the server config.`);
-            }
-            const entry = entryAssets[0];
-            if (!entry || typeof entry !== 'string') {
-                throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
-            }
-            const bundle = {
-                entry,
-                files: {},
-                maps: {},
-            };
-            Object.keys(compilation.assets).forEach(name => {
-                if (isJS(name)) {
-                    bundle.files[name] = compilation.assets[name].source();
-                }
-                else if (name.match(/\.js\.map$/)) {
-                    bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
-                }
-                // do not emit anything else for server
-                delete compilation.assets[name];
-            });
-            const json = JSON.stringify(bundle, null, 2);
-            //@ts-expect-error
-            const filename = this.options.filename;
-            compilation.assets[filename] = {
-                source: () => json,
-                size: () => json.length,
-            };
-            cb();
-        });
-    }
+class VueSSRServerPlugin {
+    constructor(options = {}) {
+        //@ts-expect-error
+        this.options = Object.assign({
+            filename: 'vue-ssr-server-bundle.json',
+        }, options);
+    }
+    apply(compiler) {
+        validate(compiler);
+        const stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
+        onEmit(compiler, 'vue-server-plugin', stage, (compilation, cb) => {
+            const stats = compilation.getStats().toJson();
+            const entryName = Object.keys(stats.entrypoints)[0];
+            const entryInfo = stats.entrypoints[entryName];
+            if (!entryInfo) {
+                // #5553
+                return cb();
+            }
+            const entryAssets = entryInfo.assets
+                .map(getAssetName)
+                .filter(isJS);
+            if (entryAssets.length > 1) {
+                throw new Error(`Server-side bundle should have one single entry file. ` +
+                    `Avoid using CommonsChunkPlugin in the server config.`);
+            }
+            const entry = entryAssets[0];
+            if (!entry || typeof entry !== 'string') {
+                throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
+            }
+            const bundle = {
+                entry,
+                files: {},
+                maps: {},
+            };
+            Object.keys(compilation.assets).forEach(name => {
+                if (isJS(name)) {
+                    bundle.files[name] = compilation.assets[name].source();
+                }
+                else if (name.match(/\.js\.map$/)) {
+                    bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
+                }
+                // do not emit anything else for server
+                delete compilation.assets[name];
+            });
+            const json = JSON.stringify(bundle, null, 2);
+            //@ts-expect-error
+            const filename = this.options.filename;
+            compilation.assets[filename] = {
+                source: () => json,
+                size: () => json.length,
+            };
+            cb();
+        });
+    }
 }
 
 module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index 5a1007309da..1c3dfdd3adc 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -52,1847 +52,1847 @@
 	  return i
 	}
 
-	const emptyObject = Object.freeze({});
-	// These helpers produce better VM code in JS engines due to their
-	// explicitness and function inlining.
-	function isUndef(v) {
-	    return v === undefined || v === null;
-	}
-	/**
-	 * Check if value is primitive.
-	 */
-	function isPrimitive(value) {
-	    return (typeof value === 'string' ||
-	        typeof value === 'number' ||
-	        // $flow-disable-line
-	        typeof value === 'symbol' ||
-	        typeof value === 'boolean');
-	}
-	/**
-	 * Quick object check - this is primarily used to tell
-	 * objects from primitive values when we know the value
-	 * is a JSON-compliant type.
-	 */
-	function isObject(obj) {
-	    return obj !== null && typeof obj === 'object';
-	}
-	/**
-	 * Get the raw type string of a value, e.g., [object Object].
-	 */
-	const _toString = Object.prototype.toString;
-	function toRawType(value) {
-	    return _toString.call(value).slice(8, -1);
-	}
-	/**
-	 * Strict object type check. Only returns true
-	 * for plain JavaScript objects.
-	 */
-	function isPlainObject(obj) {
-	    return _toString.call(obj) === '[object Object]';
-	}
-	/**
-	 * Check if val is a valid array index.
-	 */
-	function isValidArrayIndex(val) {
-	    const n = parseFloat(String(val));
-	    return n >= 0 && Math.floor(n) === n && isFinite(val);
-	}
-	/**
-	 * Make a map and return a function for checking if a key
-	 * is in that map.
-	 */
-	function makeMap(str, expectsLowerCase) {
-	    const map = Object.create(null);
-	    const list = str.split(',');
-	    for (let i = 0; i < list.length; i++) {
-	        map[list[i]] = true;
-	    }
-	    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-	}
-	/**
-	 * Check if a tag is a built-in tag.
-	 */
-	const isBuiltInTag = makeMap('slot,component', true);
-	/**
-	 * Check if an attribute is a reserved attribute.
-	 */
-	makeMap('key,ref,slot,slot-scope,is');
-	/**
-	 * Remove an item from an array.
-	 */
-	function remove(arr, item) {
-	    if (arr.length) {
-	        const index = arr.indexOf(item);
-	        if (index > -1) {
-	            return arr.splice(index, 1);
-	        }
-	    }
-	}
-	/**
-	 * Check whether an object has the property.
-	 */
-	const hasOwnProperty = Object.prototype.hasOwnProperty;
-	function hasOwn(obj, key) {
-	    return hasOwnProperty.call(obj, key);
-	}
-	/**
-	 * Create a cached version of a pure function.
-	 */
-	function cached(fn) {
-	    const cache = Object.create(null);
-	    return function cachedFn(str) {
-	        const hit = cache[str];
-	        return hit || (cache[str] = fn(str));
-	    };
-	}
-	/**
-	 * Camelize a hyphen-delimited string.
-	 */
-	const camelizeRE = /-(\w)/g;
-	const camelize = cached((str) => {
-	    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-	});
-	/**
-	 * Hyphenate a camelCase string.
-	 */
-	const hyphenateRE = /\B([A-Z])/g;
-	const hyphenate = cached((str) => {
-	    return str.replace(hyphenateRE, '-$1').toLowerCase();
-	});
-	/**
-	 * Mix properties into target object.
-	 */
-	function extend(to, _from) {
-	    for (const key in _from) {
-	        to[key] = _from[key];
-	    }
-	    return to;
-	}
-	/* eslint-disable no-unused-vars */
-	/**
-	 * Perform no operation.
-	 * Stubbing args to make Flow happy without leaving useless transpiled code
-	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-	 */
-	function noop(a, b, c) { }
-	/**
-	 * Always return false.
-	 */
-	const no = (a, b, c) => false;
-	/* eslint-enable no-unused-vars */
-	/**
-	 * Return the same value.
-	 */
-	const identity = (_) => _;
-	/**
-	 * Generate a string containing static keys from compiler modules.
-	 */
-	function genStaticKeys$1(modules) {
-	    return modules
-	        .reduce((keys, m) => {
-	        return keys.concat(m.staticKeys || []);
-	    }, [])
-	        .join(',');
+	const emptyObject = Object.freeze({});
+	// These helpers produce better VM code in JS engines due to their
+	// explicitness and function inlining.
+	function isUndef(v) {
+	    return v === undefined || v === null;
+	}
+	/**
+	 * Check if value is primitive.
+	 */
+	function isPrimitive(value) {
+	    return (typeof value === 'string' ||
+	        typeof value === 'number' ||
+	        // $flow-disable-line
+	        typeof value === 'symbol' ||
+	        typeof value === 'boolean');
+	}
+	/**
+	 * Quick object check - this is primarily used to tell
+	 * objects from primitive values when we know the value
+	 * is a JSON-compliant type.
+	 */
+	function isObject(obj) {
+	    return obj !== null && typeof obj === 'object';
+	}
+	/**
+	 * Get the raw type string of a value, e.g., [object Object].
+	 */
+	const _toString = Object.prototype.toString;
+	function toRawType(value) {
+	    return _toString.call(value).slice(8, -1);
+	}
+	/**
+	 * Strict object type check. Only returns true
+	 * for plain JavaScript objects.
+	 */
+	function isPlainObject(obj) {
+	    return _toString.call(obj) === '[object Object]';
+	}
+	/**
+	 * Check if val is a valid array index.
+	 */
+	function isValidArrayIndex(val) {
+	    const n = parseFloat(String(val));
+	    return n >= 0 && Math.floor(n) === n && isFinite(val);
+	}
+	/**
+	 * Make a map and return a function for checking if a key
+	 * is in that map.
+	 */
+	function makeMap(str, expectsLowerCase) {
+	    const map = Object.create(null);
+	    const list = str.split(',');
+	    for (let i = 0; i < list.length; i++) {
+	        map[list[i]] = true;
+	    }
+	    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+	}
+	/**
+	 * Check if a tag is a built-in tag.
+	 */
+	const isBuiltInTag = makeMap('slot,component', true);
+	/**
+	 * Check if an attribute is a reserved attribute.
+	 */
+	makeMap('key,ref,slot,slot-scope,is');
+	/**
+	 * Remove an item from an array.
+	 */
+	function remove(arr, item) {
+	    if (arr.length) {
+	        const index = arr.indexOf(item);
+	        if (index > -1) {
+	            return arr.splice(index, 1);
+	        }
+	    }
+	}
+	/**
+	 * Check whether an object has the property.
+	 */
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function hasOwn(obj, key) {
+	    return hasOwnProperty.call(obj, key);
+	}
+	/**
+	 * Create a cached version of a pure function.
+	 */
+	function cached(fn) {
+	    const cache = Object.create(null);
+	    return function cachedFn(str) {
+	        const hit = cache[str];
+	        return hit || (cache[str] = fn(str));
+	    };
+	}
+	/**
+	 * Camelize a hyphen-delimited string.
+	 */
+	const camelizeRE = /-(\w)/g;
+	const camelize = cached((str) => {
+	    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+	});
+	/**
+	 * Hyphenate a camelCase string.
+	 */
+	const hyphenateRE = /\B([A-Z])/g;
+	const hyphenate = cached((str) => {
+	    return str.replace(hyphenateRE, '-$1').toLowerCase();
+	});
+	/**
+	 * Mix properties into target object.
+	 */
+	function extend(to, _from) {
+	    for (const key in _from) {
+	        to[key] = _from[key];
+	    }
+	    return to;
+	}
+	/* eslint-disable no-unused-vars */
+	/**
+	 * Perform no operation.
+	 * Stubbing args to make Flow happy without leaving useless transpiled code
+	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+	 */
+	function noop(a, b, c) { }
+	/**
+	 * Always return false.
+	 */
+	const no = (a, b, c) => false;
+	/* eslint-enable no-unused-vars */
+	/**
+	 * Return the same value.
+	 */
+	const identity = (_) => _;
+	/**
+	 * Generate a string containing static keys from compiler modules.
+	 */
+	function genStaticKeys$1(modules) {
+	    return modules
+	        .reduce((keys, m) => {
+	        return keys.concat(m.staticKeys || []);
+	    }, [])
+	        .join(',');
 	}
 
-	const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-	    'link,meta,param,source,track,wbr');
-	// Elements that you can, intentionally, leave open
-	// (and which close themselves)
-	const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-	const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-	    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-	    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-	    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+	const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+	    'link,meta,param,source,track,wbr');
+	// Elements that you can, intentionally, leave open
+	// (and which close themselves)
+	const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+	const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+	    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+	    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+	    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
 	    'title,tr,track');
 
-	/**
-	 * unicode letters used for parsing html tags, component names and property paths.
-	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-	 */
-	const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-	/**
-	 * Define a property.
-	 */
-	function def(obj, key, val, enumerable) {
-	    Object.defineProperty(obj, key, {
-	        value: val,
-	        enumerable: !!enumerable,
-	        writable: true,
-	        configurable: true,
-	    });
+	/**
+	 * unicode letters used for parsing html tags, component names and property paths.
+	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+	 */
+	const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+	/**
+	 * Define a property.
+	 */
+	function def(obj, key, val, enumerable) {
+	    Object.defineProperty(obj, key, {
+	        value: val,
+	        enumerable: !!enumerable,
+	        writable: true,
+	        configurable: true,
+	    });
 	}
 
-	/**
-	 * Not type-checking this file because it's mostly vendor code.
-	 */
-	// Regular Expressions for parsing tags and attributes
-	const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-	const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-	const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-	const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-	const startTagOpen = new RegExp(`^<${qnameCapture}`);
-	const startTagClose = /^\s*(\/?)>/;
-	const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-	const doctype = /^<!DOCTYPE [^>]+>/i;
-	// #7298: escape - to avoid being passed as HTML comment when inlined in page
-	const comment = /^<!\--/;
-	const conditionalComment = /^<!\[/;
-	// Special Elements (can contain anything)
-	const isPlainTextElement = makeMap('script,style,textarea', true);
-	const reCache = {};
-	const decodingMap = {
-	    '&lt;': '<',
-	    '&gt;': '>',
-	    '&quot;': '"',
-	    '&amp;': '&',
-	    '&#10;': '\n',
-	    '&#9;': '\t',
-	    '&#39;': "'",
-	};
-	const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-	const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-	// #5992
-	const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-	const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-	function decodeAttr(value, shouldDecodeNewlines) {
-	    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-	    return value.replace(re, (match) => decodingMap[match]);
-	}
-	function parseHTML(html, options) {
-	    const stack = [];
-	    const expectHTML = options.expectHTML;
-	    const isUnaryTag = options.isUnaryTag || no;
-	    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-	    let index = 0;
-	    let last, lastTag;
-	    while (html) {
-	        last = html;
-	        // Make sure we're not in a plaintext content element like script/style
-	        if (!lastTag || !isPlainTextElement(lastTag)) {
-	            let textEnd = html.indexOf('<');
-	            if (textEnd === 0) {
-	                // Comment:
-	                if (comment.test(html)) {
-	                    const commentEnd = html.indexOf('-->');
-	                    if (commentEnd >= 0) {
-	                        if (options.shouldKeepComment) {
-	                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-	                        }
-	                        advance(commentEnd + 3);
-	                        continue;
-	                    }
-	                }
-	                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-	                if (conditionalComment.test(html)) {
-	                    const conditionalEnd = html.indexOf(']>');
-	                    if (conditionalEnd >= 0) {
-	                        advance(conditionalEnd + 2);
-	                        continue;
-	                    }
-	                }
-	                // Doctype:
-	                const doctypeMatch = html.match(doctype);
-	                if (doctypeMatch) {
-	                    advance(doctypeMatch[0].length);
-	                    continue;
-	                }
-	                // End tag:
-	                const endTagMatch = html.match(endTag);
-	                if (endTagMatch) {
-	                    const curIndex = index;
-	                    advance(endTagMatch[0].length);
-	                    parseEndTag(endTagMatch[1], curIndex, index);
-	                    continue;
-	                }
-	                // Start tag:
-	                const startTagMatch = parseStartTag();
-	                if (startTagMatch) {
-	                    handleStartTag(startTagMatch);
-	                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-	                        advance(1);
-	                    }
-	                    continue;
-	                }
-	            }
-	            let text, rest, next;
-	            if (textEnd >= 0) {
-	                rest = html.slice(textEnd);
-	                while (!endTag.test(rest) &&
-	                    !startTagOpen.test(rest) &&
-	                    !comment.test(rest) &&
-	                    !conditionalComment.test(rest)) {
-	                    // < in plain text, be forgiving and treat it as text
-	                    next = rest.indexOf('<', 1);
-	                    if (next < 0)
-	                        break;
-	                    textEnd += next;
-	                    rest = html.slice(textEnd);
-	                }
-	                text = html.substring(0, textEnd);
-	            }
-	            if (textEnd < 0) {
-	                text = html;
-	            }
-	            if (text) {
-	                advance(text.length);
-	            }
-	            if (options.chars && text) {
-	                options.chars(text, index - text.length, index);
-	            }
-	        }
-	        else {
-	            let endTagLength = 0;
-	            const stackedTag = lastTag.toLowerCase();
-	            const reStackedTag = reCache[stackedTag] ||
-	                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-	            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-	                endTagLength = endTag.length;
-	                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-	                    text = text
-	                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-	                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-	                }
-	                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-	                    text = text.slice(1);
-	                }
-	                if (options.chars) {
-	                    options.chars(text);
-	                }
-	                return '';
-	            });
-	            index += html.length - rest.length;
-	            html = rest;
-	            parseEndTag(stackedTag, index - endTagLength, index);
-	        }
-	        if (html === last) {
-	            options.chars && options.chars(html);
-	            if (!stack.length &&
-	                options.warn) {
-	                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-	                    start: index + html.length,
-	                });
-	            }
-	            break;
-	        }
-	    }
-	    // Clean up any remaining tags
-	    parseEndTag();
-	    function advance(n) {
-	        index += n;
-	        html = html.substring(n);
-	    }
-	    function parseStartTag() {
-	        const start = html.match(startTagOpen);
-	        if (start) {
-	            const match = {
-	                tagName: start[1],
-	                attrs: [],
-	                start: index,
-	            };
-	            advance(start[0].length);
-	            let end, attr;
-	            while (!(end = html.match(startTagClose)) &&
-	                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-	                attr.start = index;
-	                advance(attr[0].length);
-	                attr.end = index;
-	                match.attrs.push(attr);
-	            }
-	            if (end) {
-	                match.unarySlash = end[1];
-	                advance(end[0].length);
-	                match.end = index;
-	                return match;
-	            }
-	        }
-	    }
-	    function handleStartTag(match) {
-	        const tagName = match.tagName;
-	        const unarySlash = match.unarySlash;
-	        if (expectHTML) {
-	            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-	                parseEndTag(lastTag);
-	            }
-	            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-	                parseEndTag(tagName);
-	            }
-	        }
-	        const unary = isUnaryTag(tagName) || !!unarySlash;
-	        const l = match.attrs.length;
-	        const attrs = new Array(l);
-	        for (let i = 0; i < l; i++) {
-	            const args = match.attrs[i];
-	            const value = args[3] || args[4] || args[5] || '';
-	            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-	                ? options.shouldDecodeNewlinesForHref
-	                : options.shouldDecodeNewlines;
-	            attrs[i] = {
-	                name: args[1],
-	                value: decodeAttr(value, shouldDecodeNewlines),
-	            };
-	            if (options.outputSourceRange) {
-	                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-	                attrs[i].end = args.end;
-	            }
-	        }
-	        if (!unary) {
-	            stack.push({
-	                tag: tagName,
-	                lowerCasedTag: tagName.toLowerCase(),
-	                attrs: attrs,
-	                start: match.start,
-	                end: match.end,
-	            });
-	            lastTag = tagName;
-	        }
-	        if (options.start) {
-	            options.start(tagName, attrs, unary, match.start, match.end);
-	        }
-	    }
-	    function parseEndTag(tagName, start, end) {
-	        let pos, lowerCasedTagName;
-	        if (start == null)
-	            start = index;
-	        if (end == null)
-	            end = index;
-	        // Find the closest opened tag of the same type
-	        if (tagName) {
-	            lowerCasedTagName = tagName.toLowerCase();
-	            for (pos = stack.length - 1; pos >= 0; pos--) {
-	                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-	                    break;
-	                }
-	            }
-	        }
-	        else {
-	            // If no tag name is provided, clean shop
-	            pos = 0;
-	        }
-	        if (pos >= 0) {
-	            // Close all the open elements, up the stack
-	            for (let i = stack.length - 1; i >= pos; i--) {
-	                if ((i > pos || !tagName) &&
-	                    options.warn) {
-	                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-	                        start: stack[i].start,
-	                        end: stack[i].end,
-	                    });
-	                }
-	                if (options.end) {
-	                    options.end(stack[i].tag, start, end);
-	                }
-	            }
-	            // Remove the open elements from the stack
-	            stack.length = pos;
-	            lastTag = pos && stack[pos - 1].tag;
-	        }
-	        else if (lowerCasedTagName === 'br') {
-	            if (options.start) {
-	                options.start(tagName, [], true, start, end);
-	            }
-	        }
-	        else if (lowerCasedTagName === 'p') {
-	            if (options.start) {
-	                options.start(tagName, [], false, start, end);
-	            }
-	            if (options.end) {
-	                options.end(tagName, start, end);
-	            }
-	        }
-	    }
+	/**
+	 * Not type-checking this file because it's mostly vendor code.
+	 */
+	// Regular Expressions for parsing tags and attributes
+	const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+	const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+	const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+	const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+	const startTagOpen = new RegExp(`^<${qnameCapture}`);
+	const startTagClose = /^\s*(\/?)>/;
+	const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+	const doctype = /^<!DOCTYPE [^>]+>/i;
+	// #7298: escape - to avoid being passed as HTML comment when inlined in page
+	const comment = /^<!\--/;
+	const conditionalComment = /^<!\[/;
+	// Special Elements (can contain anything)
+	const isPlainTextElement = makeMap('script,style,textarea', true);
+	const reCache = {};
+	const decodingMap = {
+	    '&lt;': '<',
+	    '&gt;': '>',
+	    '&quot;': '"',
+	    '&amp;': '&',
+	    '&#10;': '\n',
+	    '&#9;': '\t',
+	    '&#39;': "'",
+	};
+	const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+	const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+	// #5992
+	const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+	const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+	function decodeAttr(value, shouldDecodeNewlines) {
+	    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+	    return value.replace(re, (match) => decodingMap[match]);
+	}
+	function parseHTML(html, options) {
+	    const stack = [];
+	    const expectHTML = options.expectHTML;
+	    const isUnaryTag = options.isUnaryTag || no;
+	    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+	    let index = 0;
+	    let last, lastTag;
+	    while (html) {
+	        last = html;
+	        // Make sure we're not in a plaintext content element like script/style
+	        if (!lastTag || !isPlainTextElement(lastTag)) {
+	            let textEnd = html.indexOf('<');
+	            if (textEnd === 0) {
+	                // Comment:
+	                if (comment.test(html)) {
+	                    const commentEnd = html.indexOf('-->');
+	                    if (commentEnd >= 0) {
+	                        if (options.shouldKeepComment) {
+	                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+	                        }
+	                        advance(commentEnd + 3);
+	                        continue;
+	                    }
+	                }
+	                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+	                if (conditionalComment.test(html)) {
+	                    const conditionalEnd = html.indexOf(']>');
+	                    if (conditionalEnd >= 0) {
+	                        advance(conditionalEnd + 2);
+	                        continue;
+	                    }
+	                }
+	                // Doctype:
+	                const doctypeMatch = html.match(doctype);
+	                if (doctypeMatch) {
+	                    advance(doctypeMatch[0].length);
+	                    continue;
+	                }
+	                // End tag:
+	                const endTagMatch = html.match(endTag);
+	                if (endTagMatch) {
+	                    const curIndex = index;
+	                    advance(endTagMatch[0].length);
+	                    parseEndTag(endTagMatch[1], curIndex, index);
+	                    continue;
+	                }
+	                // Start tag:
+	                const startTagMatch = parseStartTag();
+	                if (startTagMatch) {
+	                    handleStartTag(startTagMatch);
+	                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+	                        advance(1);
+	                    }
+	                    continue;
+	                }
+	            }
+	            let text, rest, next;
+	            if (textEnd >= 0) {
+	                rest = html.slice(textEnd);
+	                while (!endTag.test(rest) &&
+	                    !startTagOpen.test(rest) &&
+	                    !comment.test(rest) &&
+	                    !conditionalComment.test(rest)) {
+	                    // < in plain text, be forgiving and treat it as text
+	                    next = rest.indexOf('<', 1);
+	                    if (next < 0)
+	                        break;
+	                    textEnd += next;
+	                    rest = html.slice(textEnd);
+	                }
+	                text = html.substring(0, textEnd);
+	            }
+	            if (textEnd < 0) {
+	                text = html;
+	            }
+	            if (text) {
+	                advance(text.length);
+	            }
+	            if (options.chars && text) {
+	                options.chars(text, index - text.length, index);
+	            }
+	        }
+	        else {
+	            let endTagLength = 0;
+	            const stackedTag = lastTag.toLowerCase();
+	            const reStackedTag = reCache[stackedTag] ||
+	                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+	            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+	                endTagLength = endTag.length;
+	                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+	                    text = text
+	                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+	                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+	                }
+	                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+	                    text = text.slice(1);
+	                }
+	                if (options.chars) {
+	                    options.chars(text);
+	                }
+	                return '';
+	            });
+	            index += html.length - rest.length;
+	            html = rest;
+	            parseEndTag(stackedTag, index - endTagLength, index);
+	        }
+	        if (html === last) {
+	            options.chars && options.chars(html);
+	            if (!stack.length &&
+	                options.warn) {
+	                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+	                    start: index + html.length,
+	                });
+	            }
+	            break;
+	        }
+	    }
+	    // Clean up any remaining tags
+	    parseEndTag();
+	    function advance(n) {
+	        index += n;
+	        html = html.substring(n);
+	    }
+	    function parseStartTag() {
+	        const start = html.match(startTagOpen);
+	        if (start) {
+	            const match = {
+	                tagName: start[1],
+	                attrs: [],
+	                start: index,
+	            };
+	            advance(start[0].length);
+	            let end, attr;
+	            while (!(end = html.match(startTagClose)) &&
+	                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+	                attr.start = index;
+	                advance(attr[0].length);
+	                attr.end = index;
+	                match.attrs.push(attr);
+	            }
+	            if (end) {
+	                match.unarySlash = end[1];
+	                advance(end[0].length);
+	                match.end = index;
+	                return match;
+	            }
+	        }
+	    }
+	    function handleStartTag(match) {
+	        const tagName = match.tagName;
+	        const unarySlash = match.unarySlash;
+	        if (expectHTML) {
+	            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+	                parseEndTag(lastTag);
+	            }
+	            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+	                parseEndTag(tagName);
+	            }
+	        }
+	        const unary = isUnaryTag(tagName) || !!unarySlash;
+	        const l = match.attrs.length;
+	        const attrs = new Array(l);
+	        for (let i = 0; i < l; i++) {
+	            const args = match.attrs[i];
+	            const value = args[3] || args[4] || args[5] || '';
+	            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+	                ? options.shouldDecodeNewlinesForHref
+	                : options.shouldDecodeNewlines;
+	            attrs[i] = {
+	                name: args[1],
+	                value: decodeAttr(value, shouldDecodeNewlines),
+	            };
+	            if (options.outputSourceRange) {
+	                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+	                attrs[i].end = args.end;
+	            }
+	        }
+	        if (!unary) {
+	            stack.push({
+	                tag: tagName,
+	                lowerCasedTag: tagName.toLowerCase(),
+	                attrs: attrs,
+	                start: match.start,
+	                end: match.end,
+	            });
+	            lastTag = tagName;
+	        }
+	        if (options.start) {
+	            options.start(tagName, attrs, unary, match.start, match.end);
+	        }
+	    }
+	    function parseEndTag(tagName, start, end) {
+	        let pos, lowerCasedTagName;
+	        if (start == null)
+	            start = index;
+	        if (end == null)
+	            end = index;
+	        // Find the closest opened tag of the same type
+	        if (tagName) {
+	            lowerCasedTagName = tagName.toLowerCase();
+	            for (pos = stack.length - 1; pos >= 0; pos--) {
+	                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+	                    break;
+	                }
+	            }
+	        }
+	        else {
+	            // If no tag name is provided, clean shop
+	            pos = 0;
+	        }
+	        if (pos >= 0) {
+	            // Close all the open elements, up the stack
+	            for (let i = stack.length - 1; i >= pos; i--) {
+	                if ((i > pos || !tagName) &&
+	                    options.warn) {
+	                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+	                        start: stack[i].start,
+	                        end: stack[i].end,
+	                    });
+	                }
+	                if (options.end) {
+	                    options.end(stack[i].tag, start, end);
+	                }
+	            }
+	            // Remove the open elements from the stack
+	            stack.length = pos;
+	            lastTag = pos && stack[pos - 1].tag;
+	        }
+	        else if (lowerCasedTagName === 'br') {
+	            if (options.start) {
+	                options.start(tagName, [], true, start, end);
+	            }
+	        }
+	        else if (lowerCasedTagName === 'p') {
+	            if (options.start) {
+	                options.start(tagName, [], false, start, end);
+	            }
+	            if (options.end) {
+	                options.end(tagName, start, end);
+	            }
+	        }
+	    }
 	}
 
-	const splitRE = /\r?\n/g;
-	const replaceRE = /./g;
-	const isSpecialTag = makeMap('script,style,template', true);
-	/**
-	 * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
-	 */
-	function parseComponent(content, options = {}) {
-	    const sfc = {
-	        template: null,
-	        script: null,
-	        styles: [],
-	        customBlocks: [],
-	        errors: [],
-	    };
-	    let depth = 0;
-	    let currentBlock = null;
-	    let warn = (msg) => {
-	        sfc.errors.push(msg);
-	    };
-	    if (options.outputSourceRange) {
-	        warn = (msg, range) => {
-	            const data = { msg };
-	            if (range.start != null) {
-	                data.start = range.start;
-	            }
-	            if (range.end != null) {
-	                data.end = range.end;
-	            }
-	            sfc.errors.push(data);
-	        };
-	    }
-	    function start(tag, attrs, unary, start, end) {
-	        if (depth === 0) {
-	            currentBlock = {
-	                type: tag,
-	                content: '',
-	                start: end,
-	                attrs: attrs.reduce((cumulated, { name, value }) => {
-	                    cumulated[name] = value || true;
-	                    return cumulated;
-	                }, {}),
-	            };
-	            if (isSpecialTag(tag)) {
-	                checkAttrs(currentBlock, attrs);
-	                if (tag === 'style') {
-	                    sfc.styles.push(currentBlock);
-	                }
-	                else {
-	                    sfc[tag] = currentBlock;
-	                }
-	            }
-	            else {
-	                // custom blocks
-	                sfc.customBlocks.push(currentBlock);
-	            }
-	        }
-	        if (!unary) {
-	            depth++;
-	        }
-	    }
-	    function checkAttrs(block, attrs) {
-	        for (let i = 0; i < attrs.length; i++) {
-	            const attr = attrs[i];
-	            if (attr.name === 'lang') {
-	                block.lang = attr.value;
-	            }
-	            if (attr.name === 'scoped') {
-	                block.scoped = true;
-	            }
-	            if (attr.name === 'module') {
-	                block.module = attr.value || true;
-	            }
-	            if (attr.name === 'src') {
-	                block.src = attr.value;
-	            }
-	        }
-	    }
-	    function end(tag, start) {
-	        if (depth === 1 && currentBlock) {
-	            currentBlock.end = start;
-	            let text = content.slice(currentBlock.start, currentBlock.end);
-	            if (options.deindent !== false) {
-	                text = deIndent(text);
-	            }
-	            // pad content so that linters and pre-processors can output correct
-	            // line numbers in errors and warnings
-	            if (currentBlock.type !== 'template' && options.pad) {
-	                text = padContent(currentBlock, options.pad) + text;
-	            }
-	            currentBlock.content = text;
-	            currentBlock = null;
-	        }
-	        depth--;
-	    }
-	    function padContent(block, pad) {
-	        if (pad === 'space') {
-	            return content.slice(0, block.start).replace(replaceRE, ' ');
-	        }
-	        else {
-	            const offset = content.slice(0, block.start).split(splitRE).length;
-	            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
-	            return Array(offset).join(padChar);
-	        }
-	    }
-	    parseHTML(content, {
-	        warn,
-	        start,
-	        end,
-	        outputSourceRange: options.outputSourceRange,
-	    });
-	    return sfc;
+	const splitRE = /\r?\n/g;
+	const replaceRE = /./g;
+	const isSpecialTag = makeMap('script,style,template', true);
+	/**
+	 * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+	 */
+	function parseComponent(content, options = {}) {
+	    const sfc = {
+	        template: null,
+	        script: null,
+	        styles: [],
+	        customBlocks: [],
+	        errors: [],
+	    };
+	    let depth = 0;
+	    let currentBlock = null;
+	    let warn = (msg) => {
+	        sfc.errors.push(msg);
+	    };
+	    if (options.outputSourceRange) {
+	        warn = (msg, range) => {
+	            const data = { msg };
+	            if (range.start != null) {
+	                data.start = range.start;
+	            }
+	            if (range.end != null) {
+	                data.end = range.end;
+	            }
+	            sfc.errors.push(data);
+	        };
+	    }
+	    function start(tag, attrs, unary, start, end) {
+	        if (depth === 0) {
+	            currentBlock = {
+	                type: tag,
+	                content: '',
+	                start: end,
+	                attrs: attrs.reduce((cumulated, { name, value }) => {
+	                    cumulated[name] = value || true;
+	                    return cumulated;
+	                }, {}),
+	            };
+	            if (isSpecialTag(tag)) {
+	                checkAttrs(currentBlock, attrs);
+	                if (tag === 'style') {
+	                    sfc.styles.push(currentBlock);
+	                }
+	                else {
+	                    sfc[tag] = currentBlock;
+	                }
+	            }
+	            else {
+	                // custom blocks
+	                sfc.customBlocks.push(currentBlock);
+	            }
+	        }
+	        if (!unary) {
+	            depth++;
+	        }
+	    }
+	    function checkAttrs(block, attrs) {
+	        for (let i = 0; i < attrs.length; i++) {
+	            const attr = attrs[i];
+	            if (attr.name === 'lang') {
+	                block.lang = attr.value;
+	            }
+	            if (attr.name === 'scoped') {
+	                block.scoped = true;
+	            }
+	            if (attr.name === 'module') {
+	                block.module = attr.value || true;
+	            }
+	            if (attr.name === 'src') {
+	                block.src = attr.value;
+	            }
+	        }
+	    }
+	    function end(tag, start) {
+	        if (depth === 1 && currentBlock) {
+	            currentBlock.end = start;
+	            let text = content.slice(currentBlock.start, currentBlock.end);
+	            if (options.deindent !== false) {
+	                text = deIndent(text);
+	            }
+	            // pad content so that linters and pre-processors can output correct
+	            // line numbers in errors and warnings
+	            if (currentBlock.type !== 'template' && options.pad) {
+	                text = padContent(currentBlock, options.pad) + text;
+	            }
+	            currentBlock.content = text;
+	            currentBlock = null;
+	        }
+	        depth--;
+	    }
+	    function padContent(block, pad) {
+	        if (pad === 'space') {
+	            return content.slice(0, block.start).replace(replaceRE, ' ');
+	        }
+	        else {
+	            const offset = content.slice(0, block.start).split(splitRE).length;
+	            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+	            return Array(offset).join(padChar);
+	        }
+	    }
+	    parseHTML(content, {
+	        warn,
+	        start,
+	        end,
+	        outputSourceRange: options.outputSourceRange,
+	    });
+	    return sfc;
 	}
 
-	// can we use __proto__?
-	const hasProto = '__proto__' in {};
-	// Browser environment sniffing
-	const inBrowser = typeof window !== 'undefined';
-	const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-	const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-	const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-	const isIE = UA && /msie|trident/.test(UA);
-	UA && UA.indexOf('msie 9.0') > 0;
-	const isEdge = UA && UA.indexOf('edge/') > 0;
-	(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-	(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-	UA && /chrome\/\d+/.test(UA) && !isEdge;
-	UA && /phantomjs/.test(UA);
-	UA && UA.match(/firefox\/(\d+)/);
-	// Firefox has a "watch" function on Object.prototype...
-	// @ts-expect-error firebox support
-	const nativeWatch = {}.watch;
-	let supportsPassive = false;
-	if (inBrowser) {
-	    try {
-	        const opts = {};
-	        Object.defineProperty(opts, 'passive', {
-	            get() {
-	                /* istanbul ignore next */
-	                supportsPassive = true;
-	            },
-	        }); // https://github.com/facebook/flow/issues/285
-	        window.addEventListener('test-passive', null, opts);
-	    }
-	    catch (e) { }
-	}
-	// this needs to be lazy-evaled because vue may be required before
-	// vue-server-renderer can set VUE_ENV
-	let _isServer;
-	const isServerRendering = () => {
-	    if (_isServer === undefined) {
-	        /* istanbul ignore if */
-	        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-	            // detect presence of vue-server-renderer and avoid
-	            // Webpack shimming the process
-	            _isServer =
-	                global['process'] && global['process'].env.VUE_ENV === 'server';
-	        }
-	        else {
-	            _isServer = false;
-	        }
-	    }
-	    return _isServer;
-	};
-	/* istanbul ignore next */
-	function isNative(Ctor) {
-	    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-	}
-	const hasSymbol = typeof Symbol !== 'undefined' &&
-	    isNative(Symbol) &&
-	    typeof Reflect !== 'undefined' &&
-	    isNative(Reflect.ownKeys);
+	// can we use __proto__?
+	const hasProto = '__proto__' in {};
+	// Browser environment sniffing
+	const inBrowser = typeof window !== 'undefined';
+	const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+	const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+	const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+	const isIE = UA && /msie|trident/.test(UA);
+	UA && UA.indexOf('msie 9.0') > 0;
+	const isEdge = UA && UA.indexOf('edge/') > 0;
+	(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+	(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+	UA && /chrome\/\d+/.test(UA) && !isEdge;
+	UA && /phantomjs/.test(UA);
+	UA && UA.match(/firefox\/(\d+)/);
+	// Firefox has a "watch" function on Object.prototype...
+	// @ts-expect-error firebox support
+	const nativeWatch = {}.watch;
+	let supportsPassive = false;
+	if (inBrowser) {
+	    try {
+	        const opts = {};
+	        Object.defineProperty(opts, 'passive', {
+	            get() {
+	                /* istanbul ignore next */
+	                supportsPassive = true;
+	            },
+	        }); // https://github.com/facebook/flow/issues/285
+	        window.addEventListener('test-passive', null, opts);
+	    }
+	    catch (e) { }
+	}
+	// this needs to be lazy-evaled because vue may be required before
+	// vue-server-renderer can set VUE_ENV
+	let _isServer;
+	const isServerRendering = () => {
+	    if (_isServer === undefined) {
+	        /* istanbul ignore if */
+	        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+	            // detect presence of vue-server-renderer and avoid
+	            // Webpack shimming the process
+	            _isServer =
+	                global['process'] && global['process'].env.VUE_ENV === 'server';
+	        }
+	        else {
+	            _isServer = false;
+	        }
+	    }
+	    return _isServer;
+	};
+	/* istanbul ignore next */
+	function isNative(Ctor) {
+	    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+	}
+	const hasSymbol = typeof Symbol !== 'undefined' &&
+	    isNative(Symbol) &&
+	    typeof Reflect !== 'undefined' &&
+	    isNative(Reflect.ownKeys);
 	/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
 
-	const ASSET_TYPES = ['component', 'directive', 'filter'];
-	const LIFECYCLE_HOOKS = [
-	    'beforeCreate',
-	    'created',
-	    'beforeMount',
-	    'mounted',
-	    'beforeUpdate',
-	    'updated',
-	    'beforeDestroy',
-	    'destroyed',
-	    'activated',
-	    'deactivated',
-	    'errorCaptured',
-	    'serverPrefetch',
+	const ASSET_TYPES = ['component', 'directive', 'filter'];
+	const LIFECYCLE_HOOKS = [
+	    'beforeCreate',
+	    'created',
+	    'beforeMount',
+	    'mounted',
+	    'beforeUpdate',
+	    'updated',
+	    'beforeDestroy',
+	    'destroyed',
+	    'activated',
+	    'deactivated',
+	    'errorCaptured',
+	    'serverPrefetch',
 	];
 
-	var config = {
-	    /**
-	     * Option merge strategies (used in core/util/options)
-	     */
-	    // $flow-disable-line
-	    optionMergeStrategies: Object.create(null),
-	    /**
-	     * Whether to suppress warnings.
-	     */
-	    silent: false,
-	    /**
-	     * Show production mode tip message on boot?
-	     */
-	    productionTip: "development" !== 'production',
-	    /**
-	     * Whether to enable devtools
-	     */
-	    devtools: "development" !== 'production',
-	    /**
-	     * Whether to record perf
-	     */
-	    performance: false,
-	    /**
-	     * Error handler for watcher errors
-	     */
-	    errorHandler: null,
-	    /**
-	     * Warn handler for watcher warns
-	     */
-	    warnHandler: null,
-	    /**
-	     * Ignore certain custom elements
-	     */
-	    ignoredElements: [],
-	    /**
-	     * Custom user key aliases for v-on
-	     */
-	    // $flow-disable-line
-	    keyCodes: Object.create(null),
-	    /**
-	     * Check if a tag is reserved so that it cannot be registered as a
-	     * component. This is platform-dependent and may be overwritten.
-	     */
-	    isReservedTag: no,
-	    /**
-	     * Check if an attribute is reserved so that it cannot be used as a component
-	     * prop. This is platform-dependent and may be overwritten.
-	     */
-	    isReservedAttr: no,
-	    /**
-	     * Check if a tag is an unknown element.
-	     * Platform-dependent.
-	     */
-	    isUnknownElement: no,
-	    /**
-	     * Get the namespace of an element
-	     */
-	    getTagNamespace: noop,
-	    /**
-	     * Parse the real tag name for the specific platform.
-	     */
-	    parsePlatformTagName: identity,
-	    /**
-	     * Check if an attribute must be bound using property, e.g. value
-	     * Platform-dependent.
-	     */
-	    mustUseProp: no,
-	    /**
-	     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-	     * This will significantly reduce performance if set to false.
-	     */
-	    async: true,
-	    /**
-	     * Exposed for legacy reasons
-	     */
-	    _lifecycleHooks: LIFECYCLE_HOOKS,
+	var config = {
+	    /**
+	     * Option merge strategies (used in core/util/options)
+	     */
+	    // $flow-disable-line
+	    optionMergeStrategies: Object.create(null),
+	    /**
+	     * Whether to suppress warnings.
+	     */
+	    silent: false,
+	    /**
+	     * Show production mode tip message on boot?
+	     */
+	    productionTip: "development" !== 'production',
+	    /**
+	     * Whether to enable devtools
+	     */
+	    devtools: "development" !== 'production',
+	    /**
+	     * Whether to record perf
+	     */
+	    performance: false,
+	    /**
+	     * Error handler for watcher errors
+	     */
+	    errorHandler: null,
+	    /**
+	     * Warn handler for watcher warns
+	     */
+	    warnHandler: null,
+	    /**
+	     * Ignore certain custom elements
+	     */
+	    ignoredElements: [],
+	    /**
+	     * Custom user key aliases for v-on
+	     */
+	    // $flow-disable-line
+	    keyCodes: Object.create(null),
+	    /**
+	     * Check if a tag is reserved so that it cannot be registered as a
+	     * component. This is platform-dependent and may be overwritten.
+	     */
+	    isReservedTag: no,
+	    /**
+	     * Check if an attribute is reserved so that it cannot be used as a component
+	     * prop. This is platform-dependent and may be overwritten.
+	     */
+	    isReservedAttr: no,
+	    /**
+	     * Check if a tag is an unknown element.
+	     * Platform-dependent.
+	     */
+	    isUnknownElement: no,
+	    /**
+	     * Get the namespace of an element
+	     */
+	    getTagNamespace: noop,
+	    /**
+	     * Parse the real tag name for the specific platform.
+	     */
+	    parsePlatformTagName: identity,
+	    /**
+	     * Check if an attribute must be bound using property, e.g. value
+	     * Platform-dependent.
+	     */
+	    mustUseProp: no,
+	    /**
+	     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+	     * This will significantly reduce performance if set to false.
+	     */
+	    async: true,
+	    /**
+	     * Exposed for legacy reasons
+	     */
+	    _lifecycleHooks: LIFECYCLE_HOOKS,
 	};
 
-	let warn$2 = noop;
-	let tip = noop;
-	let generateComponentTrace; // work around flow check
-	let formatComponentName;
-	{
-	    const hasConsole = typeof console !== 'undefined';
-	    const classifyRE = /(?:^|[-_])(\w)/g;
-	    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-	    warn$2 = (msg, vm) => {
-	        const trace = vm ? generateComponentTrace(vm) : '';
-	        if (hasConsole && !config.silent) {
-	            console.error(`[Vue warn]: ${msg}${trace}`);
-	        }
-	    };
-	    tip = (msg, vm) => {
-	        if (hasConsole && !config.silent) {
-	            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-	        }
-	    };
-	    formatComponentName = (vm, includeFile) => {
-	        if (vm.$root === vm) {
-	            return '<Root>';
-	        }
-	        const options = typeof vm === 'function' && vm.cid != null
-	            ? vm.options
-	            : vm._isVue
-	                ? vm.$options || vm.constructor.options
-	                : vm;
-	        let name = options.name || options._componentTag;
-	        const file = options.__file;
-	        if (!name && file) {
-	            const match = file.match(/([^/\\]+)\.vue$/);
-	            name = match && match[1];
-	        }
-	        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-	            (file && includeFile !== false ? ` at ${file}` : ''));
-	    };
-	    const repeat = (str, n) => {
-	        let res = '';
-	        while (n) {
-	            if (n % 2 === 1)
-	                res += str;
-	            if (n > 1)
-	                str += str;
-	            n >>= 1;
-	        }
-	        return res;
-	    };
-	    generateComponentTrace = (vm) => {
-	        if (vm._isVue && vm.$parent) {
-	            const tree = [];
-	            let currentRecursiveSequence = 0;
-	            while (vm) {
-	                if (tree.length > 0) {
-	                    const last = tree[tree.length - 1];
-	                    if (last.constructor === vm.constructor) {
-	                        currentRecursiveSequence++;
-	                        vm = vm.$parent;
-	                        continue;
-	                    }
-	                    else if (currentRecursiveSequence > 0) {
-	                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-	                        currentRecursiveSequence = 0;
-	                    }
-	                }
-	                tree.push(vm);
-	                vm = vm.$parent;
-	            }
-	            return ('\n\nfound in\n\n' +
-	                tree
-	                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-	                    .join('\n'));
-	        }
-	        else {
-	            return `\n\n(found in ${formatComponentName(vm)})`;
-	        }
-	    };
+	let warn$2 = noop;
+	let tip = noop;
+	let generateComponentTrace; // work around flow check
+	let formatComponentName;
+	{
+	    const hasConsole = typeof console !== 'undefined';
+	    const classifyRE = /(?:^|[-_])(\w)/g;
+	    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+	    warn$2 = (msg, vm) => {
+	        const trace = vm ? generateComponentTrace(vm) : '';
+	        if (hasConsole && !config.silent) {
+	            console.error(`[Vue warn]: ${msg}${trace}`);
+	        }
+	    };
+	    tip = (msg, vm) => {
+	        if (hasConsole && !config.silent) {
+	            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+	        }
+	    };
+	    formatComponentName = (vm, includeFile) => {
+	        if (vm.$root === vm) {
+	            return '<Root>';
+	        }
+	        const options = typeof vm === 'function' && vm.cid != null
+	            ? vm.options
+	            : vm._isVue
+	                ? vm.$options || vm.constructor.options
+	                : vm;
+	        let name = options.name || options._componentTag;
+	        const file = options.__file;
+	        if (!name && file) {
+	            const match = file.match(/([^/\\]+)\.vue$/);
+	            name = match && match[1];
+	        }
+	        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+	            (file && includeFile !== false ? ` at ${file}` : ''));
+	    };
+	    const repeat = (str, n) => {
+	        let res = '';
+	        while (n) {
+	            if (n % 2 === 1)
+	                res += str;
+	            if (n > 1)
+	                str += str;
+	            n >>= 1;
+	        }
+	        return res;
+	    };
+	    generateComponentTrace = (vm) => {
+	        if (vm._isVue && vm.$parent) {
+	            const tree = [];
+	            let currentRecursiveSequence = 0;
+	            while (vm) {
+	                if (tree.length > 0) {
+	                    const last = tree[tree.length - 1];
+	                    if (last.constructor === vm.constructor) {
+	                        currentRecursiveSequence++;
+	                        vm = vm.$parent;
+	                        continue;
+	                    }
+	                    else if (currentRecursiveSequence > 0) {
+	                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+	                        currentRecursiveSequence = 0;
+	                    }
+	                }
+	                tree.push(vm);
+	                vm = vm.$parent;
+	            }
+	            return ('\n\nfound in\n\n' +
+	                tree
+	                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+	                    .join('\n'));
+	        }
+	        else {
+	            return `\n\n(found in ${formatComponentName(vm)})`;
+	        }
+	    };
 	}
 
-	let uid = 0;
-	/**
-	 * A dep is an observable that can have multiple
-	 * directives subscribing to it.
-	 */
-	class Dep {
-	    static target;
-	    id;
-	    subs;
-	    constructor() {
-	        this.id = uid++;
-	        this.subs = [];
-	    }
-	    addSub(sub) {
-	        this.subs.push(sub);
-	    }
-	    removeSub(sub) {
-	        remove(this.subs, sub);
-	    }
-	    depend() {
-	        if (Dep.target) {
-	            Dep.target.addDep(this);
-	        }
-	    }
-	    notify() {
-	        // stabilize the subscriber list first
-	        const subs = this.subs.slice();
-	        for (let i = 0, l = subs.length; i < l; i++) {
-	            subs[i].update();
-	        }
-	    }
-	}
-	// The current target watcher being evaluated.
-	// This is globally unique because only one watcher
-	// can be evaluated at a time.
+	let uid = 0;
+	/**
+	 * A dep is an observable that can have multiple
+	 * directives subscribing to it.
+	 */
+	class Dep {
+	    static target;
+	    id;
+	    subs;
+	    constructor() {
+	        this.id = uid++;
+	        this.subs = [];
+	    }
+	    addSub(sub) {
+	        this.subs.push(sub);
+	    }
+	    removeSub(sub) {
+	        remove(this.subs, sub);
+	    }
+	    depend() {
+	        if (Dep.target) {
+	            Dep.target.addDep(this);
+	        }
+	    }
+	    notify() {
+	        // stabilize the subscriber list first
+	        const subs = this.subs.slice();
+	        for (let i = 0, l = subs.length; i < l; i++) {
+	            subs[i].update();
+	        }
+	    }
+	}
+	// The current target watcher being evaluated.
+	// This is globally unique because only one watcher
+	// can be evaluated at a time.
 	Dep.target = null;
 
-	class VNode {
-	    tag;
-	    data;
-	    children;
-	    text;
-	    elm;
-	    ns;
-	    context; // rendered in this component's scope
-	    key;
-	    componentOptions;
-	    componentInstance; // component instance
-	    parent; // component placeholder node
-	    // strictly internal
-	    raw; // contains raw HTML? (server only)
-	    isStatic; // hoisted static node
-	    isRootInsert; // necessary for enter transition check
-	    isComment; // empty comment placeholder?
-	    isCloned; // is a cloned node?
-	    isOnce; // is a v-once node?
-	    asyncFactory; // async component factory function
-	    asyncMeta;
-	    isAsyncPlaceholder;
-	    ssrContext;
-	    fnContext; // real context vm for functional nodes
-	    fnOptions; // for SSR caching
-	    devtoolsMeta; // used to store functional render context for devtools
-	    fnScopeId; // functional scope id support
-	    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-	        this.tag = tag;
-	        this.data = data;
-	        this.children = children;
-	        this.text = text;
-	        this.elm = elm;
-	        this.ns = undefined;
-	        this.context = context;
-	        this.fnContext = undefined;
-	        this.fnOptions = undefined;
-	        this.fnScopeId = undefined;
-	        this.key = data && data.key;
-	        this.componentOptions = componentOptions;
-	        this.componentInstance = undefined;
-	        this.parent = undefined;
-	        this.raw = false;
-	        this.isStatic = false;
-	        this.isRootInsert = true;
-	        this.isComment = false;
-	        this.isCloned = false;
-	        this.isOnce = false;
-	        this.asyncFactory = asyncFactory;
-	        this.asyncMeta = undefined;
-	        this.isAsyncPlaceholder = false;
-	    }
-	    // DEPRECATED: alias for componentInstance for backwards compat.
-	    /* istanbul ignore next */
-	    get child() {
-	        return this.componentInstance;
-	    }
+	class VNode {
+	    tag;
+	    data;
+	    children;
+	    text;
+	    elm;
+	    ns;
+	    context; // rendered in this component's scope
+	    key;
+	    componentOptions;
+	    componentInstance; // component instance
+	    parent; // component placeholder node
+	    // strictly internal
+	    raw; // contains raw HTML? (server only)
+	    isStatic; // hoisted static node
+	    isRootInsert; // necessary for enter transition check
+	    isComment; // empty comment placeholder?
+	    isCloned; // is a cloned node?
+	    isOnce; // is a v-once node?
+	    asyncFactory; // async component factory function
+	    asyncMeta;
+	    isAsyncPlaceholder;
+	    ssrContext;
+	    fnContext; // real context vm for functional nodes
+	    fnOptions; // for SSR caching
+	    devtoolsMeta; // used to store functional render context for devtools
+	    fnScopeId; // functional scope id support
+	    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+	        this.tag = tag;
+	        this.data = data;
+	        this.children = children;
+	        this.text = text;
+	        this.elm = elm;
+	        this.ns = undefined;
+	        this.context = context;
+	        this.fnContext = undefined;
+	        this.fnOptions = undefined;
+	        this.fnScopeId = undefined;
+	        this.key = data && data.key;
+	        this.componentOptions = componentOptions;
+	        this.componentInstance = undefined;
+	        this.parent = undefined;
+	        this.raw = false;
+	        this.isStatic = false;
+	        this.isRootInsert = true;
+	        this.isComment = false;
+	        this.isCloned = false;
+	        this.isOnce = false;
+	        this.asyncFactory = asyncFactory;
+	        this.asyncMeta = undefined;
+	        this.isAsyncPlaceholder = false;
+	    }
+	    // DEPRECATED: alias for componentInstance for backwards compat.
+	    /* istanbul ignore next */
+	    get child() {
+	        return this.componentInstance;
+	    }
 	}
 
-	/*
-	 * not type checking this file because flow doesn't play well with
-	 * dynamically accessing methods on Array prototype
-	 */
-	const arrayProto = Array.prototype;
-	const arrayMethods = Object.create(arrayProto);
-	const methodsToPatch = [
-	    'push',
-	    'pop',
-	    'shift',
-	    'unshift',
-	    'splice',
-	    'sort',
-	    'reverse',
-	];
-	/**
-	 * Intercept mutating methods and emit events
-	 */
-	methodsToPatch.forEach(function (method) {
-	    // cache original method
-	    const original = arrayProto[method];
-	    def(arrayMethods, method, function mutator(...args) {
-	        const result = original.apply(this, args);
-	        const ob = this.__ob__;
-	        let inserted;
-	        switch (method) {
-	            case 'push':
-	            case 'unshift':
-	                inserted = args;
-	                break;
-	            case 'splice':
-	                inserted = args.slice(2);
-	                break;
-	        }
-	        if (inserted)
-	            ob.observeArray(inserted);
-	        // notify change
-	        ob.dep.notify();
-	        return result;
-	    });
+	/*
+	 * not type checking this file because flow doesn't play well with
+	 * dynamically accessing methods on Array prototype
+	 */
+	const arrayProto = Array.prototype;
+	const arrayMethods = Object.create(arrayProto);
+	const methodsToPatch = [
+	    'push',
+	    'pop',
+	    'shift',
+	    'unshift',
+	    'splice',
+	    'sort',
+	    'reverse',
+	];
+	/**
+	 * Intercept mutating methods and emit events
+	 */
+	methodsToPatch.forEach(function (method) {
+	    // cache original method
+	    const original = arrayProto[method];
+	    def(arrayMethods, method, function mutator(...args) {
+	        const result = original.apply(this, args);
+	        const ob = this.__ob__;
+	        let inserted;
+	        switch (method) {
+	            case 'push':
+	            case 'unshift':
+	                inserted = args;
+	                break;
+	            case 'splice':
+	                inserted = args.slice(2);
+	                break;
+	        }
+	        if (inserted)
+	            ob.observeArray(inserted);
+	        // notify change
+	        ob.dep.notify();
+	        return result;
+	    });
 	});
 
-	const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-	/**
-	 * Observer class that is attached to each observed
-	 * object. Once attached, the observer converts the target
-	 * object's property keys into getter/setters that
-	 * collect dependencies and dispatch updates.
-	 */
-	class Observer {
-	    value;
-	    dep;
-	    vmCount; // number of vms that have this object as root $data
-	    constructor(value) {
-	        this.value = value;
-	        this.dep = new Dep();
-	        this.vmCount = 0;
-	        def(value, '__ob__', this);
-	        if (Array.isArray(value)) {
-	            if (hasProto) {
-	                protoAugment(value, arrayMethods);
-	            }
-	            else {
-	                copyAugment(value, arrayMethods, arrayKeys);
-	            }
-	            this.observeArray(value);
-	        }
-	        else {
-	            this.walk(value);
-	        }
-	    }
-	    /**
-	     * Walk through all properties and convert them into
-	     * getter/setters. This method should only be called when
-	     * value type is Object.
-	     */
-	    walk(obj) {
-	        const keys = Object.keys(obj);
-	        for (let i = 0; i < keys.length; i++) {
-	            defineReactive(obj, keys[i]);
-	        }
-	    }
-	    /**
-	     * Observe a list of Array items.
-	     */
-	    observeArray(items) {
-	        for (let i = 0, l = items.length; i < l; i++) {
-	            observe(items[i]);
-	        }
-	    }
-	}
-	// helpers
-	/**
-	 * Augment a target Object or Array by intercepting
-	 * the prototype chain using __proto__
-	 */
-	function protoAugment(target, src) {
-	    /* eslint-disable no-proto */
-	    target.__proto__ = src;
-	    /* eslint-enable no-proto */
-	}
-	/**
-	 * Augment a target Object or Array by defining
-	 * hidden properties.
-	 */
-	/* istanbul ignore next */
-	function copyAugment(target, src, keys) {
-	    for (let i = 0, l = keys.length; i < l; i++) {
-	        const key = keys[i];
-	        def(target, key, src[key]);
-	    }
-	}
-	/**
-	 * Attempt to create an observer instance for a value,
-	 * returns the new observer if successfully observed,
-	 * or the existing observer if the value already has one.
-	 */
-	function observe(value, asRootData) {
-	    if (!isObject(value) || value instanceof VNode) {
-	        return;
-	    }
-	    let ob;
-	    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-	        ob = value.__ob__;
-	    }
-	    else if (!isServerRendering() &&
-	        (Array.isArray(value) || isPlainObject(value)) &&
-	        Object.isExtensible(value) &&
-	        !value._isVue) {
-	        ob = new Observer(value);
-	    }
-	    if (asRootData && ob) {
-	        ob.vmCount++;
-	    }
-	    return ob;
-	}
-	/**
-	 * Define a reactive property on an Object.
-	 */
-	function defineReactive(obj, key, val, customSetter, shallow) {
-	    const dep = new Dep();
-	    const property = Object.getOwnPropertyDescriptor(obj, key);
-	    if (property && property.configurable === false) {
-	        return;
-	    }
-	    // cater for pre-defined getter/setters
-	    const getter = property && property.get;
-	    const setter = property && property.set;
-	    if ((!getter || setter) && arguments.length === 2) {
-	        val = obj[key];
-	    }
-	    let childOb = !shallow && observe(val);
-	    Object.defineProperty(obj, key, {
-	        enumerable: true,
-	        configurable: true,
-	        get: function reactiveGetter() {
-	            const value = getter ? getter.call(obj) : val;
-	            if (Dep.target) {
-	                dep.depend();
-	                if (childOb) {
-	                    childOb.dep.depend();
-	                    if (Array.isArray(value)) {
-	                        dependArray(value);
-	                    }
-	                }
-	            }
-	            return value;
-	        },
-	        set: function reactiveSetter(newVal) {
-	            const value = getter ? getter.call(obj) : val;
-	            /* eslint-disable no-self-compare */
-	            if (newVal === value || (newVal !== newVal && value !== value)) {
-	                return;
-	            }
-	            /* eslint-enable no-self-compare */
-	            if (customSetter) {
-	                customSetter();
-	            }
-	            // #7981: for accessor properties without setter
-	            if (getter && !setter)
-	                return;
-	            if (setter) {
-	                setter.call(obj, newVal);
-	            }
-	            else {
-	                val = newVal;
-	            }
-	            childOb = !shallow && observe(newVal);
-	            dep.notify();
-	        },
-	    });
-	}
-	/**
-	 * Set a property on an object. Adds the new property and
-	 * triggers change notification if the property doesn't
-	 * already exist.
-	 */
-	function set(target, key, val) {
-	    if ((isUndef(target) || isPrimitive(target))) {
-	        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-	    }
-	    if (Array.isArray(target) && isValidArrayIndex(key)) {
-	        target.length = Math.max(target.length, key);
-	        target.splice(key, 1, val);
-	        return val;
-	    }
-	    if (key in target && !(key in Object.prototype)) {
-	        target[key] = val;
-	        return val;
-	    }
-	    const ob = target.__ob__;
-	    if (target._isVue || (ob && ob.vmCount)) {
-	        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-	                'at runtime - declare it upfront in the data option.');
-	        return val;
-	    }
-	    if (!ob) {
-	        target[key] = val;
-	        return val;
-	    }
-	    defineReactive(ob.value, key, val);
-	    ob.dep.notify();
-	    return val;
-	}
-	/**
-	 * Collect dependencies on array elements when the array is touched, since
-	 * we cannot intercept array element access like property getters.
-	 */
-	function dependArray(value) {
-	    for (let e, i = 0, l = value.length; i < l; i++) {
-	        e = value[i];
-	        e && e.__ob__ && e.__ob__.dep.depend();
-	        if (Array.isArray(e)) {
-	            dependArray(e);
-	        }
-	    }
+	const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+	/**
+	 * Observer class that is attached to each observed
+	 * object. Once attached, the observer converts the target
+	 * object's property keys into getter/setters that
+	 * collect dependencies and dispatch updates.
+	 */
+	class Observer {
+	    value;
+	    dep;
+	    vmCount; // number of vms that have this object as root $data
+	    constructor(value) {
+	        this.value = value;
+	        this.dep = new Dep();
+	        this.vmCount = 0;
+	        def(value, '__ob__', this);
+	        if (Array.isArray(value)) {
+	            if (hasProto) {
+	                protoAugment(value, arrayMethods);
+	            }
+	            else {
+	                copyAugment(value, arrayMethods, arrayKeys);
+	            }
+	            this.observeArray(value);
+	        }
+	        else {
+	            this.walk(value);
+	        }
+	    }
+	    /**
+	     * Walk through all properties and convert them into
+	     * getter/setters. This method should only be called when
+	     * value type is Object.
+	     */
+	    walk(obj) {
+	        const keys = Object.keys(obj);
+	        for (let i = 0; i < keys.length; i++) {
+	            defineReactive(obj, keys[i]);
+	        }
+	    }
+	    /**
+	     * Observe a list of Array items.
+	     */
+	    observeArray(items) {
+	        for (let i = 0, l = items.length; i < l; i++) {
+	            observe(items[i]);
+	        }
+	    }
+	}
+	// helpers
+	/**
+	 * Augment a target Object or Array by intercepting
+	 * the prototype chain using __proto__
+	 */
+	function protoAugment(target, src) {
+	    /* eslint-disable no-proto */
+	    target.__proto__ = src;
+	    /* eslint-enable no-proto */
+	}
+	/**
+	 * Augment a target Object or Array by defining
+	 * hidden properties.
+	 */
+	/* istanbul ignore next */
+	function copyAugment(target, src, keys) {
+	    for (let i = 0, l = keys.length; i < l; i++) {
+	        const key = keys[i];
+	        def(target, key, src[key]);
+	    }
+	}
+	/**
+	 * Attempt to create an observer instance for a value,
+	 * returns the new observer if successfully observed,
+	 * or the existing observer if the value already has one.
+	 */
+	function observe(value, asRootData) {
+	    if (!isObject(value) || value instanceof VNode) {
+	        return;
+	    }
+	    let ob;
+	    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+	        ob = value.__ob__;
+	    }
+	    else if (!isServerRendering() &&
+	        (Array.isArray(value) || isPlainObject(value)) &&
+	        Object.isExtensible(value) &&
+	        !value._isVue) {
+	        ob = new Observer(value);
+	    }
+	    if (asRootData && ob) {
+	        ob.vmCount++;
+	    }
+	    return ob;
+	}
+	/**
+	 * Define a reactive property on an Object.
+	 */
+	function defineReactive(obj, key, val, customSetter, shallow) {
+	    const dep = new Dep();
+	    const property = Object.getOwnPropertyDescriptor(obj, key);
+	    if (property && property.configurable === false) {
+	        return;
+	    }
+	    // cater for pre-defined getter/setters
+	    const getter = property && property.get;
+	    const setter = property && property.set;
+	    if ((!getter || setter) && arguments.length === 2) {
+	        val = obj[key];
+	    }
+	    let childOb = !shallow && observe(val);
+	    Object.defineProperty(obj, key, {
+	        enumerable: true,
+	        configurable: true,
+	        get: function reactiveGetter() {
+	            const value = getter ? getter.call(obj) : val;
+	            if (Dep.target) {
+	                dep.depend();
+	                if (childOb) {
+	                    childOb.dep.depend();
+	                    if (Array.isArray(value)) {
+	                        dependArray(value);
+	                    }
+	                }
+	            }
+	            return value;
+	        },
+	        set: function reactiveSetter(newVal) {
+	            const value = getter ? getter.call(obj) : val;
+	            /* eslint-disable no-self-compare */
+	            if (newVal === value || (newVal !== newVal && value !== value)) {
+	                return;
+	            }
+	            /* eslint-enable no-self-compare */
+	            if (customSetter) {
+	                customSetter();
+	            }
+	            // #7981: for accessor properties without setter
+	            if (getter && !setter)
+	                return;
+	            if (setter) {
+	                setter.call(obj, newVal);
+	            }
+	            else {
+	                val = newVal;
+	            }
+	            childOb = !shallow && observe(newVal);
+	            dep.notify();
+	        },
+	    });
+	}
+	/**
+	 * Set a property on an object. Adds the new property and
+	 * triggers change notification if the property doesn't
+	 * already exist.
+	 */
+	function set(target, key, val) {
+	    if ((isUndef(target) || isPrimitive(target))) {
+	        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+	    }
+	    if (Array.isArray(target) && isValidArrayIndex(key)) {
+	        target.length = Math.max(target.length, key);
+	        target.splice(key, 1, val);
+	        return val;
+	    }
+	    if (key in target && !(key in Object.prototype)) {
+	        target[key] = val;
+	        return val;
+	    }
+	    const ob = target.__ob__;
+	    if (target._isVue || (ob && ob.vmCount)) {
+	        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+	                'at runtime - declare it upfront in the data option.');
+	        return val;
+	    }
+	    if (!ob) {
+	        target[key] = val;
+	        return val;
+	    }
+	    defineReactive(ob.value, key, val);
+	    ob.dep.notify();
+	    return val;
+	}
+	/**
+	 * Collect dependencies on array elements when the array is touched, since
+	 * we cannot intercept array element access like property getters.
+	 */
+	function dependArray(value) {
+	    for (let e, i = 0, l = value.length; i < l; i++) {
+	        e = value[i];
+	        e && e.__ob__ && e.__ob__.dep.depend();
+	        if (Array.isArray(e)) {
+	            dependArray(e);
+	        }
+	    }
 	}
 
-	/**
-	 * Option overwriting strategies are functions that handle
-	 * how to merge a parent option value and a child option
-	 * value into the final value.
-	 */
-	const strats = config.optionMergeStrategies;
-	/**
-	 * Options with restrictions
-	 */
-	{
-	    strats.el = strats.propsData = function (parent, child, vm, key) {
-	        if (!vm) {
-	            warn$2(`option "${key}" can only be used during instance ` +
-	                'creation with the `new` keyword.');
-	        }
-	        return defaultStrat(parent, child);
-	    };
-	}
-	/**
-	 * Helper that recursively merges two data objects together.
-	 */
-	function mergeData(to, from) {
-	    if (!from)
-	        return to;
-	    let key, toVal, fromVal;
-	    const keys = hasSymbol
-	        ? Reflect.ownKeys(from)
-	        : Object.keys(from);
-	    for (let i = 0; i < keys.length; i++) {
-	        key = keys[i];
-	        // in case the object is already observed...
-	        if (key === '__ob__')
-	            continue;
-	        toVal = to[key];
-	        fromVal = from[key];
-	        if (!hasOwn(to, key)) {
-	            set(to, key, fromVal);
-	        }
-	        else if (toVal !== fromVal &&
-	            isPlainObject(toVal) &&
-	            isPlainObject(fromVal)) {
-	            mergeData(toVal, fromVal);
-	        }
-	    }
-	    return to;
-	}
-	/**
-	 * Data
-	 */
-	function mergeDataOrFn(parentVal, childVal, vm) {
-	    if (!vm) {
-	        // in a Vue.extend merge, both should be functions
-	        if (!childVal) {
-	            return parentVal;
-	        }
-	        if (!parentVal) {
-	            return childVal;
-	        }
-	        // when parentVal & childVal are both present,
-	        // we need to return a function that returns the
-	        // merged result of both functions... no need to
-	        // check if parentVal is a function here because
-	        // it has to be a function to pass previous merges.
-	        return function mergedDataFn() {
-	            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-	        };
-	    }
-	    else {
-	        return function mergedInstanceDataFn() {
-	            // instance merge
-	            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-	            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-	            if (instanceData) {
-	                return mergeData(instanceData, defaultData);
-	            }
-	            else {
-	                return defaultData;
-	            }
-	        };
-	    }
-	}
-	strats.data = function (parentVal, childVal, vm) {
-	    if (!vm) {
-	        if (childVal && typeof childVal !== 'function') {
-	            warn$2('The "data" option should be a function ' +
-	                    'that returns a per-instance value in component ' +
-	                    'definitions.', vm);
-	            return parentVal;
-	        }
-	        return mergeDataOrFn(parentVal, childVal);
-	    }
-	    return mergeDataOrFn(parentVal, childVal, vm);
-	};
-	/**
-	 * Hooks and props are merged as arrays.
-	 */
-	function mergeHook(parentVal, childVal) {
-	    const res = childVal
-	        ? parentVal
-	            ? parentVal.concat(childVal)
-	            : Array.isArray(childVal)
-	                ? childVal
-	                : [childVal]
-	        : parentVal;
-	    return res ? dedupeHooks(res) : res;
-	}
-	function dedupeHooks(hooks) {
-	    const res = [];
-	    for (let i = 0; i < hooks.length; i++) {
-	        if (res.indexOf(hooks[i]) === -1) {
-	            res.push(hooks[i]);
-	        }
-	    }
-	    return res;
-	}
-	LIFECYCLE_HOOKS.forEach((hook) => {
-	    strats[hook] = mergeHook;
-	});
-	/**
-	 * Assets
-	 *
-	 * When a vm is present (instance creation), we need to do
-	 * a three-way merge between constructor options, instance
-	 * options and parent options.
-	 */
-	function mergeAssets(parentVal, childVal, vm, key) {
-	    const res = Object.create(parentVal || null);
-	    if (childVal) {
-	        assertObjectType(key, childVal, vm);
-	        return extend(res, childVal);
-	    }
-	    else {
-	        return res;
-	    }
-	}
-	ASSET_TYPES.forEach(function (type) {
-	    strats[type + 's'] = mergeAssets;
-	});
-	/**
-	 * Watchers.
-	 *
-	 * Watchers hashes should not overwrite one
-	 * another, so we merge them as arrays.
-	 */
-	strats.watch = function (parentVal, childVal, vm, key) {
-	    // work around Firefox's Object.prototype.watch...
-	    //@ts-expect-error work around
-	    if (parentVal === nativeWatch)
-	        parentVal = undefined;
-	    //@ts-expect-error work around
-	    if (childVal === nativeWatch)
-	        childVal = undefined;
-	    /* istanbul ignore if */
-	    if (!childVal)
-	        return Object.create(parentVal || null);
-	    {
-	        assertObjectType(key, childVal, vm);
-	    }
-	    if (!parentVal)
-	        return childVal;
-	    const ret = {};
-	    extend(ret, parentVal);
-	    for (const key in childVal) {
-	        let parent = ret[key];
-	        const child = childVal[key];
-	        if (parent && !Array.isArray(parent)) {
-	            parent = [parent];
-	        }
-	        ret[key] = parent
-	            ? parent.concat(child)
-	            : Array.isArray(child)
-	                ? child
-	                : [child];
-	    }
-	    return ret;
-	};
-	/**
-	 * Other object hashes.
-	 */
-	strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-	    if (childVal && "development" !== 'production') {
-	        assertObjectType(key, childVal, vm);
-	    }
-	    if (!parentVal)
-	        return childVal;
-	    const ret = Object.create(null);
-	    extend(ret, parentVal);
-	    if (childVal)
-	        extend(ret, childVal);
-	    return ret;
-	};
-	strats.provide = mergeDataOrFn;
-	/**
-	 * Default strategy.
-	 */
-	const defaultStrat = function (parentVal, childVal) {
-	    return childVal === undefined ? parentVal : childVal;
-	};
-	function assertObjectType(name, value, vm) {
-	    if (!isPlainObject(value)) {
-	        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-	            `but got ${toRawType(value)}.`, vm);
-	    }
+	/**
+	 * Option overwriting strategies are functions that handle
+	 * how to merge a parent option value and a child option
+	 * value into the final value.
+	 */
+	const strats = config.optionMergeStrategies;
+	/**
+	 * Options with restrictions
+	 */
+	{
+	    strats.el = strats.propsData = function (parent, child, vm, key) {
+	        if (!vm) {
+	            warn$2(`option "${key}" can only be used during instance ` +
+	                'creation with the `new` keyword.');
+	        }
+	        return defaultStrat(parent, child);
+	    };
+	}
+	/**
+	 * Helper that recursively merges two data objects together.
+	 */
+	function mergeData(to, from) {
+	    if (!from)
+	        return to;
+	    let key, toVal, fromVal;
+	    const keys = hasSymbol
+	        ? Reflect.ownKeys(from)
+	        : Object.keys(from);
+	    for (let i = 0; i < keys.length; i++) {
+	        key = keys[i];
+	        // in case the object is already observed...
+	        if (key === '__ob__')
+	            continue;
+	        toVal = to[key];
+	        fromVal = from[key];
+	        if (!hasOwn(to, key)) {
+	            set(to, key, fromVal);
+	        }
+	        else if (toVal !== fromVal &&
+	            isPlainObject(toVal) &&
+	            isPlainObject(fromVal)) {
+	            mergeData(toVal, fromVal);
+	        }
+	    }
+	    return to;
+	}
+	/**
+	 * Data
+	 */
+	function mergeDataOrFn(parentVal, childVal, vm) {
+	    if (!vm) {
+	        // in a Vue.extend merge, both should be functions
+	        if (!childVal) {
+	            return parentVal;
+	        }
+	        if (!parentVal) {
+	            return childVal;
+	        }
+	        // when parentVal & childVal are both present,
+	        // we need to return a function that returns the
+	        // merged result of both functions... no need to
+	        // check if parentVal is a function here because
+	        // it has to be a function to pass previous merges.
+	        return function mergedDataFn() {
+	            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+	        };
+	    }
+	    else {
+	        return function mergedInstanceDataFn() {
+	            // instance merge
+	            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+	            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+	            if (instanceData) {
+	                return mergeData(instanceData, defaultData);
+	            }
+	            else {
+	                return defaultData;
+	            }
+	        };
+	    }
+	}
+	strats.data = function (parentVal, childVal, vm) {
+	    if (!vm) {
+	        if (childVal && typeof childVal !== 'function') {
+	            warn$2('The "data" option should be a function ' +
+	                    'that returns a per-instance value in component ' +
+	                    'definitions.', vm);
+	            return parentVal;
+	        }
+	        return mergeDataOrFn(parentVal, childVal);
+	    }
+	    return mergeDataOrFn(parentVal, childVal, vm);
+	};
+	/**
+	 * Hooks and props are merged as arrays.
+	 */
+	function mergeHook(parentVal, childVal) {
+	    const res = childVal
+	        ? parentVal
+	            ? parentVal.concat(childVal)
+	            : Array.isArray(childVal)
+	                ? childVal
+	                : [childVal]
+	        : parentVal;
+	    return res ? dedupeHooks(res) : res;
+	}
+	function dedupeHooks(hooks) {
+	    const res = [];
+	    for (let i = 0; i < hooks.length; i++) {
+	        if (res.indexOf(hooks[i]) === -1) {
+	            res.push(hooks[i]);
+	        }
+	    }
+	    return res;
+	}
+	LIFECYCLE_HOOKS.forEach((hook) => {
+	    strats[hook] = mergeHook;
+	});
+	/**
+	 * Assets
+	 *
+	 * When a vm is present (instance creation), we need to do
+	 * a three-way merge between constructor options, instance
+	 * options and parent options.
+	 */
+	function mergeAssets(parentVal, childVal, vm, key) {
+	    const res = Object.create(parentVal || null);
+	    if (childVal) {
+	        assertObjectType(key, childVal, vm);
+	        return extend(res, childVal);
+	    }
+	    else {
+	        return res;
+	    }
+	}
+	ASSET_TYPES.forEach(function (type) {
+	    strats[type + 's'] = mergeAssets;
+	});
+	/**
+	 * Watchers.
+	 *
+	 * Watchers hashes should not overwrite one
+	 * another, so we merge them as arrays.
+	 */
+	strats.watch = function (parentVal, childVal, vm, key) {
+	    // work around Firefox's Object.prototype.watch...
+	    //@ts-expect-error work around
+	    if (parentVal === nativeWatch)
+	        parentVal = undefined;
+	    //@ts-expect-error work around
+	    if (childVal === nativeWatch)
+	        childVal = undefined;
+	    /* istanbul ignore if */
+	    if (!childVal)
+	        return Object.create(parentVal || null);
+	    {
+	        assertObjectType(key, childVal, vm);
+	    }
+	    if (!parentVal)
+	        return childVal;
+	    const ret = {};
+	    extend(ret, parentVal);
+	    for (const key in childVal) {
+	        let parent = ret[key];
+	        const child = childVal[key];
+	        if (parent && !Array.isArray(parent)) {
+	            parent = [parent];
+	        }
+	        ret[key] = parent
+	            ? parent.concat(child)
+	            : Array.isArray(child)
+	                ? child
+	                : [child];
+	    }
+	    return ret;
+	};
+	/**
+	 * Other object hashes.
+	 */
+	strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+	    if (childVal && "development" !== 'production') {
+	        assertObjectType(key, childVal, vm);
+	    }
+	    if (!parentVal)
+	        return childVal;
+	    const ret = Object.create(null);
+	    extend(ret, parentVal);
+	    if (childVal)
+	        extend(ret, childVal);
+	    return ret;
+	};
+	strats.provide = mergeDataOrFn;
+	/**
+	 * Default strategy.
+	 */
+	const defaultStrat = function (parentVal, childVal) {
+	    return childVal === undefined ? parentVal : childVal;
+	};
+	function assertObjectType(name, value, vm) {
+	    if (!isPlainObject(value)) {
+	        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+	            `but got ${toRawType(value)}.`, vm);
+	    }
 	}
 
-	/* globals MutationObserver */
-	const callbacks = [];
-	function flushCallbacks() {
-	    const copies = callbacks.slice(0);
-	    callbacks.length = 0;
-	    for (let i = 0; i < copies.length; i++) {
-	        copies[i]();
-	    }
-	}
-	// The nextTick behavior leverages the microtask queue, which can be accessed
-	// via either native Promise.then or MutationObserver.
-	// MutationObserver has wider support, however it is seriously bugged in
-	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-	// completely stops working after triggering a few times... so, if native
-	// Promise is available, we will use it:
-	/* istanbul ignore next, $flow-disable-line */
-	if (typeof Promise !== 'undefined' && isNative(Promise)) {
-	    Promise.resolve();
-	}
-	else if (!isIE &&
-	    typeof MutationObserver !== 'undefined' &&
-	    (isNative(MutationObserver) ||
-	        // PhantomJS and iOS 7.x
-	        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-	    // Use MutationObserver where native Promise is not available,
-	    // e.g. PhantomJS, iOS7, Android 4.4
-	    // (#6466 MutationObserver is unreliable in IE11)
-	    let counter = 1;
-	    const observer = new MutationObserver(flushCallbacks);
-	    const textNode = document.createTextNode(String(counter));
-	    observer.observe(textNode, {
-	        characterData: true,
-	    });
-	}
-	else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+	/* globals MutationObserver */
+	const callbacks = [];
+	function flushCallbacks() {
+	    const copies = callbacks.slice(0);
+	    callbacks.length = 0;
+	    for (let i = 0; i < copies.length; i++) {
+	        copies[i]();
+	    }
+	}
+	// The nextTick behavior leverages the microtask queue, which can be accessed
+	// via either native Promise.then or MutationObserver.
+	// MutationObserver has wider support, however it is seriously bugged in
+	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+	// completely stops working after triggering a few times... so, if native
+	// Promise is available, we will use it:
+	/* istanbul ignore next, $flow-disable-line */
+	if (typeof Promise !== 'undefined' && isNative(Promise)) {
+	    Promise.resolve();
+	}
+	else if (!isIE &&
+	    typeof MutationObserver !== 'undefined' &&
+	    (isNative(MutationObserver) ||
+	        // PhantomJS and iOS 7.x
+	        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+	    // Use MutationObserver where native Promise is not available,
+	    // e.g. PhantomJS, iOS7, Android 4.4
+	    // (#6466 MutationObserver is unreliable in IE11)
+	    let counter = 1;
+	    const observer = new MutationObserver(flushCallbacks);
+	    const textNode = document.createTextNode(String(counter));
+	    observer.observe(textNode, {
+	        characterData: true,
+	    });
+	}
+	else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 	else ;
 
-	// these are reserved for web because they are directly compiled away
-	// during template compilation
-	makeMap('style,class');
-	// attributes that should be using props for binding
-	const acceptValue = makeMap('input,textarea,option,select,progress');
-	const mustUseProp = (tag, type, attr) => {
-	    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-	        (attr === 'selected' && tag === 'option') ||
-	        (attr === 'checked' && tag === 'input') ||
-	        (attr === 'muted' && tag === 'video'));
-	};
-	const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-	makeMap('events,caret,typing,plaintext-only');
-	const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-	    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-	    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-	    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-	    'required,reversed,scoped,seamless,selected,sortable,' +
+	// these are reserved for web because they are directly compiled away
+	// during template compilation
+	makeMap('style,class');
+	// attributes that should be using props for binding
+	const acceptValue = makeMap('input,textarea,option,select,progress');
+	const mustUseProp = (tag, type, attr) => {
+	    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+	        (attr === 'selected' && tag === 'option') ||
+	        (attr === 'checked' && tag === 'input') ||
+	        (attr === 'muted' && tag === 'video'));
+	};
+	const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+	makeMap('events,caret,typing,plaintext-only');
+	const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+	    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+	    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+	    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+	    'required,reversed,scoped,seamless,selected,sortable,' +
 	    'truespeed,typemustmatch,visible');
 
-	const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-	    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-	    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-	    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-	    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-	    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-	    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-	    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-	    'output,progress,select,textarea,' +
-	    'details,dialog,menu,menuitem,summary,' +
-	    'content,element,shadow,template,blockquote,iframe,tfoot');
-	// this map is intentionally selective, only covering SVG elements that may
-	// contain child elements.
-	const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-	    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-	    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-	const isPreTag = (tag) => tag === 'pre';
-	const isReservedTag = (tag) => {
-	    return isHTMLTag(tag) || isSVG(tag);
-	};
-	function getTagNamespace(tag) {
-	    if (isSVG(tag)) {
-	        return 'svg';
-	    }
-	    // basic support for MathML
-	    // note it doesn't support other MathML elements being component roots
-	    if (tag === 'math') {
-	        return 'math';
-	    }
-	}
+	const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+	    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+	    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+	    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+	    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+	    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+	    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+	    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+	    'output,progress,select,textarea,' +
+	    'details,dialog,menu,menuitem,summary,' +
+	    'content,element,shadow,template,blockquote,iframe,tfoot');
+	// this map is intentionally selective, only covering SVG elements that may
+	// contain child elements.
+	const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+	    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+	    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+	const isPreTag = (tag) => tag === 'pre';
+	const isReservedTag = (tag) => {
+	    return isHTMLTag(tag) || isSVG(tag);
+	};
+	function getTagNamespace(tag) {
+	    if (isSVG(tag)) {
+	        return 'svg';
+	    }
+	    // basic support for MathML
+	    // note it doesn't support other MathML elements being component roots
+	    if (tag === 'math') {
+	        return 'math';
+	    }
+	}
 	makeMap('text,number,password,search,email,tel,url');
 
-	const validDivisionCharRE = /[\w).+\-_$\]]/;
-	function parseFilters(exp) {
-	    let inSingle = false;
-	    let inDouble = false;
-	    let inTemplateString = false;
-	    let inRegex = false;
-	    let curly = 0;
-	    let square = 0;
-	    let paren = 0;
-	    let lastFilterIndex = 0;
-	    let c, prev, i, expression, filters;
-	    for (i = 0; i < exp.length; i++) {
-	        prev = c;
-	        c = exp.charCodeAt(i);
-	        if (inSingle) {
-	            if (c === 0x27 && prev !== 0x5c)
-	                inSingle = false;
-	        }
-	        else if (inDouble) {
-	            if (c === 0x22 && prev !== 0x5c)
-	                inDouble = false;
-	        }
-	        else if (inTemplateString) {
-	            if (c === 0x60 && prev !== 0x5c)
-	                inTemplateString = false;
-	        }
-	        else if (inRegex) {
-	            if (c === 0x2f && prev !== 0x5c)
-	                inRegex = false;
-	        }
-	        else if (c === 0x7c && // pipe
-	            exp.charCodeAt(i + 1) !== 0x7c &&
-	            exp.charCodeAt(i - 1) !== 0x7c &&
-	            !curly &&
-	            !square &&
-	            !paren) {
-	            if (expression === undefined) {
-	                // first filter, end of expression
-	                lastFilterIndex = i + 1;
-	                expression = exp.slice(0, i).trim();
-	            }
-	            else {
-	                pushFilter();
-	            }
-	        }
-	        else {
-	            switch (c) {
-	                case 0x22:
-	                    inDouble = true;
-	                    break; // "
-	                case 0x27:
-	                    inSingle = true;
-	                    break; // '
-	                case 0x60:
-	                    inTemplateString = true;
-	                    break; // `
-	                case 0x28:
-	                    paren++;
-	                    break; // (
-	                case 0x29:
-	                    paren--;
-	                    break; // )
-	                case 0x5b:
-	                    square++;
-	                    break; // [
-	                case 0x5d:
-	                    square--;
-	                    break; // ]
-	                case 0x7b:
-	                    curly++;
-	                    break; // {
-	                case 0x7d:
-	                    curly--;
-	                    break; // }
-	            }
-	            if (c === 0x2f) {
-	                // /
-	                let j = i - 1;
-	                let p;
-	                // find first non-whitespace prev char
-	                for (; j >= 0; j--) {
-	                    p = exp.charAt(j);
-	                    if (p !== ' ')
-	                        break;
-	                }
-	                if (!p || !validDivisionCharRE.test(p)) {
-	                    inRegex = true;
-	                }
-	            }
-	        }
-	    }
-	    if (expression === undefined) {
-	        expression = exp.slice(0, i).trim();
-	    }
-	    else if (lastFilterIndex !== 0) {
-	        pushFilter();
-	    }
-	    function pushFilter() {
-	        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-	        lastFilterIndex = i + 1;
-	    }
-	    if (filters) {
-	        for (i = 0; i < filters.length; i++) {
-	            expression = wrapFilter(expression, filters[i]);
-	        }
-	    }
-	    return expression;
-	}
-	function wrapFilter(exp, filter) {
-	    const i = filter.indexOf('(');
-	    if (i < 0) {
-	        // _f: resolveFilter
-	        return `_f("${filter}")(${exp})`;
-	    }
-	    else {
-	        const name = filter.slice(0, i);
-	        const args = filter.slice(i + 1);
-	        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-	    }
+	const validDivisionCharRE = /[\w).+\-_$\]]/;
+	function parseFilters(exp) {
+	    let inSingle = false;
+	    let inDouble = false;
+	    let inTemplateString = false;
+	    let inRegex = false;
+	    let curly = 0;
+	    let square = 0;
+	    let paren = 0;
+	    let lastFilterIndex = 0;
+	    let c, prev, i, expression, filters;
+	    for (i = 0; i < exp.length; i++) {
+	        prev = c;
+	        c = exp.charCodeAt(i);
+	        if (inSingle) {
+	            if (c === 0x27 && prev !== 0x5c)
+	                inSingle = false;
+	        }
+	        else if (inDouble) {
+	            if (c === 0x22 && prev !== 0x5c)
+	                inDouble = false;
+	        }
+	        else if (inTemplateString) {
+	            if (c === 0x60 && prev !== 0x5c)
+	                inTemplateString = false;
+	        }
+	        else if (inRegex) {
+	            if (c === 0x2f && prev !== 0x5c)
+	                inRegex = false;
+	        }
+	        else if (c === 0x7c && // pipe
+	            exp.charCodeAt(i + 1) !== 0x7c &&
+	            exp.charCodeAt(i - 1) !== 0x7c &&
+	            !curly &&
+	            !square &&
+	            !paren) {
+	            if (expression === undefined) {
+	                // first filter, end of expression
+	                lastFilterIndex = i + 1;
+	                expression = exp.slice(0, i).trim();
+	            }
+	            else {
+	                pushFilter();
+	            }
+	        }
+	        else {
+	            switch (c) {
+	                case 0x22:
+	                    inDouble = true;
+	                    break; // "
+	                case 0x27:
+	                    inSingle = true;
+	                    break; // '
+	                case 0x60:
+	                    inTemplateString = true;
+	                    break; // `
+	                case 0x28:
+	                    paren++;
+	                    break; // (
+	                case 0x29:
+	                    paren--;
+	                    break; // )
+	                case 0x5b:
+	                    square++;
+	                    break; // [
+	                case 0x5d:
+	                    square--;
+	                    break; // ]
+	                case 0x7b:
+	                    curly++;
+	                    break; // {
+	                case 0x7d:
+	                    curly--;
+	                    break; // }
+	            }
+	            if (c === 0x2f) {
+	                // /
+	                let j = i - 1;
+	                let p;
+	                // find first non-whitespace prev char
+	                for (; j >= 0; j--) {
+	                    p = exp.charAt(j);
+	                    if (p !== ' ')
+	                        break;
+	                }
+	                if (!p || !validDivisionCharRE.test(p)) {
+	                    inRegex = true;
+	                }
+	            }
+	        }
+	    }
+	    if (expression === undefined) {
+	        expression = exp.slice(0, i).trim();
+	    }
+	    else if (lastFilterIndex !== 0) {
+	        pushFilter();
+	    }
+	    function pushFilter() {
+	        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+	        lastFilterIndex = i + 1;
+	    }
+	    if (filters) {
+	        for (i = 0; i < filters.length; i++) {
+	            expression = wrapFilter(expression, filters[i]);
+	        }
+	    }
+	    return expression;
+	}
+	function wrapFilter(exp, filter) {
+	    const i = filter.indexOf('(');
+	    if (i < 0) {
+	        // _f: resolveFilter
+	        return `_f("${filter}")(${exp})`;
+	    }
+	    else {
+	        const name = filter.slice(0, i);
+	        const args = filter.slice(i + 1);
+	        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+	    }
 	}
 
-	const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-	const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-	const buildRegex = cached((delimiters) => {
-	    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-	    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-	    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-	});
-	function parseText(text, delimiters) {
-	    //@ts-expect-error
-	    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-	    if (!tagRE.test(text)) {
-	        return;
-	    }
-	    const tokens = [];
-	    const rawTokens = [];
-	    let lastIndex = (tagRE.lastIndex = 0);
-	    let match, index, tokenValue;
-	    while ((match = tagRE.exec(text))) {
-	        index = match.index;
-	        // push text token
-	        if (index > lastIndex) {
-	            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-	            tokens.push(JSON.stringify(tokenValue));
-	        }
-	        // tag token
-	        const exp = parseFilters(match[1].trim());
-	        tokens.push(`_s(${exp})`);
-	        rawTokens.push({ '@binding': exp });
-	        lastIndex = index + match[0].length;
-	    }
-	    if (lastIndex < text.length) {
-	        rawTokens.push((tokenValue = text.slice(lastIndex)));
-	        tokens.push(JSON.stringify(tokenValue));
-	    }
-	    return {
-	        expression: tokens.join('+'),
-	        tokens: rawTokens,
-	    };
+	const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+	const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+	const buildRegex = cached((delimiters) => {
+	    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+	    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+	    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+	});
+	function parseText(text, delimiters) {
+	    //@ts-expect-error
+	    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+	    if (!tagRE.test(text)) {
+	        return;
+	    }
+	    const tokens = [];
+	    const rawTokens = [];
+	    let lastIndex = (tagRE.lastIndex = 0);
+	    let match, index, tokenValue;
+	    while ((match = tagRE.exec(text))) {
+	        index = match.index;
+	        // push text token
+	        if (index > lastIndex) {
+	            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+	            tokens.push(JSON.stringify(tokenValue));
+	        }
+	        // tag token
+	        const exp = parseFilters(match[1].trim());
+	        tokens.push(`_s(${exp})`);
+	        rawTokens.push({ '@binding': exp });
+	        lastIndex = index + match[0].length;
+	    }
+	    if (lastIndex < text.length) {
+	        rawTokens.push((tokenValue = text.slice(lastIndex)));
+	        tokens.push(JSON.stringify(tokenValue));
+	    }
+	    return {
+	        expression: tokens.join('+'),
+	        tokens: rawTokens,
+	    };
 	}
 
-	/* eslint-disable no-unused-vars */
-	function baseWarn(msg, range) {
-	    console.error(`[Vue compiler]: ${msg}`);
-	}
-	/* eslint-enable no-unused-vars */
-	function pluckModuleFunction(modules, key) {
-	    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-	}
-	function addProp(el, name, value, range, dynamic) {
-	    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-	    el.plain = false;
-	}
-	function addAttr(el, name, value, range, dynamic) {
-	    const attrs = dynamic
-	        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-	        : el.attrs || (el.attrs = []);
-	    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-	    el.plain = false;
-	}
-	// add a raw attr (use this in preTransforms)
-	function addRawAttr(el, name, value, range) {
-	    el.attrsMap[name] = value;
-	    el.attrsList.push(rangeSetItem({ name, value }, range));
-	}
-	function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-	    (el.directives || (el.directives = [])).push(rangeSetItem({
-	        name,
-	        rawName,
-	        value,
-	        arg,
-	        isDynamicArg,
-	        modifiers,
-	    }, range));
-	    el.plain = false;
-	}
-	function prependModifierMarker(symbol, name, dynamic) {
-	    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-	}
-	function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-	    modifiers = modifiers || emptyObject;
-	    // warn prevent and passive modifier
-	    /* istanbul ignore if */
-	    if (warn &&
-	        modifiers.prevent &&
-	        modifiers.passive) {
-	        warn("passive and prevent can't be used together. " +
-	            "Passive handler can't prevent default event.", range);
-	    }
-	    // normalize click.right and click.middle since they don't actually fire
-	    // this is technically browser-specific, but at least for now browsers are
-	    // the only target envs that have right/middle clicks.
-	    if (modifiers.right) {
-	        if (dynamic) {
-	            name = `(${name})==='click'?'contextmenu':(${name})`;
-	        }
-	        else if (name === 'click') {
-	            name = 'contextmenu';
-	            delete modifiers.right;
-	        }
-	    }
-	    else if (modifiers.middle) {
-	        if (dynamic) {
-	            name = `(${name})==='click'?'mouseup':(${name})`;
-	        }
-	        else if (name === 'click') {
-	            name = 'mouseup';
-	        }
-	    }
-	    // check capture modifier
-	    if (modifiers.capture) {
-	        delete modifiers.capture;
-	        name = prependModifierMarker('!', name, dynamic);
-	    }
-	    if (modifiers.once) {
-	        delete modifiers.once;
-	        name = prependModifierMarker('~', name, dynamic);
-	    }
-	    /* istanbul ignore if */
-	    if (modifiers.passive) {
-	        delete modifiers.passive;
-	        name = prependModifierMarker('&', name, dynamic);
-	    }
-	    let events;
-	    if (modifiers.native) {
-	        delete modifiers.native;
-	        events = el.nativeEvents || (el.nativeEvents = {});
-	    }
-	    else {
-	        events = el.events || (el.events = {});
-	    }
-	    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-	    if (modifiers !== emptyObject) {
-	        newHandler.modifiers = modifiers;
-	    }
-	    const handlers = events[name];
-	    /* istanbul ignore if */
-	    if (Array.isArray(handlers)) {
-	        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-	    }
-	    else if (handlers) {
-	        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-	    }
-	    else {
-	        events[name] = newHandler;
-	    }
-	    el.plain = false;
-	}
-	function getRawBindingAttr(el, name) {
-	    return (el.rawAttrsMap[':' + name] ||
-	        el.rawAttrsMap['v-bind:' + name] ||
-	        el.rawAttrsMap[name]);
-	}
-	function getBindingAttr(el, name, getStatic) {
-	    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-	    if (dynamicValue != null) {
-	        return parseFilters(dynamicValue);
-	    }
-	    else if (getStatic !== false) {
-	        const staticValue = getAndRemoveAttr(el, name);
-	        if (staticValue != null) {
-	            return JSON.stringify(staticValue);
-	        }
-	    }
-	}
-	// note: this only removes the attr from the Array (attrsList) so that it
-	// doesn't get processed by processAttrs.
-	// By default it does NOT remove it from the map (attrsMap) because the map is
-	// needed during codegen.
-	function getAndRemoveAttr(el, name, removeFromMap) {
-	    let val;
-	    if ((val = el.attrsMap[name]) != null) {
-	        const list = el.attrsList;
-	        for (let i = 0, l = list.length; i < l; i++) {
-	            if (list[i].name === name) {
-	                list.splice(i, 1);
-	                break;
-	            }
-	        }
-	    }
-	    if (removeFromMap) {
-	        delete el.attrsMap[name];
-	    }
-	    return val;
-	}
-	function getAndRemoveAttrByRegex(el, name) {
-	    const list = el.attrsList;
-	    for (let i = 0, l = list.length; i < l; i++) {
-	        const attr = list[i];
-	        if (name.test(attr.name)) {
-	            list.splice(i, 1);
-	            return attr;
-	        }
-	    }
-	}
-	function rangeSetItem(item, range) {
-	    if (range) {
-	        if (range.start != null) {
-	            item.start = range.start;
-	        }
-	        if (range.end != null) {
-	            item.end = range.end;
-	        }
-	    }
-	    return item;
+	/* eslint-disable no-unused-vars */
+	function baseWarn(msg, range) {
+	    console.error(`[Vue compiler]: ${msg}`);
+	}
+	/* eslint-enable no-unused-vars */
+	function pluckModuleFunction(modules, key) {
+	    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+	}
+	function addProp(el, name, value, range, dynamic) {
+	    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+	    el.plain = false;
+	}
+	function addAttr(el, name, value, range, dynamic) {
+	    const attrs = dynamic
+	        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+	        : el.attrs || (el.attrs = []);
+	    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+	    el.plain = false;
+	}
+	// add a raw attr (use this in preTransforms)
+	function addRawAttr(el, name, value, range) {
+	    el.attrsMap[name] = value;
+	    el.attrsList.push(rangeSetItem({ name, value }, range));
+	}
+	function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+	    (el.directives || (el.directives = [])).push(rangeSetItem({
+	        name,
+	        rawName,
+	        value,
+	        arg,
+	        isDynamicArg,
+	        modifiers,
+	    }, range));
+	    el.plain = false;
+	}
+	function prependModifierMarker(symbol, name, dynamic) {
+	    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+	}
+	function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+	    modifiers = modifiers || emptyObject;
+	    // warn prevent and passive modifier
+	    /* istanbul ignore if */
+	    if (warn &&
+	        modifiers.prevent &&
+	        modifiers.passive) {
+	        warn("passive and prevent can't be used together. " +
+	            "Passive handler can't prevent default event.", range);
+	    }
+	    // normalize click.right and click.middle since they don't actually fire
+	    // this is technically browser-specific, but at least for now browsers are
+	    // the only target envs that have right/middle clicks.
+	    if (modifiers.right) {
+	        if (dynamic) {
+	            name = `(${name})==='click'?'contextmenu':(${name})`;
+	        }
+	        else if (name === 'click') {
+	            name = 'contextmenu';
+	            delete modifiers.right;
+	        }
+	    }
+	    else if (modifiers.middle) {
+	        if (dynamic) {
+	            name = `(${name})==='click'?'mouseup':(${name})`;
+	        }
+	        else if (name === 'click') {
+	            name = 'mouseup';
+	        }
+	    }
+	    // check capture modifier
+	    if (modifiers.capture) {
+	        delete modifiers.capture;
+	        name = prependModifierMarker('!', name, dynamic);
+	    }
+	    if (modifiers.once) {
+	        delete modifiers.once;
+	        name = prependModifierMarker('~', name, dynamic);
+	    }
+	    /* istanbul ignore if */
+	    if (modifiers.passive) {
+	        delete modifiers.passive;
+	        name = prependModifierMarker('&', name, dynamic);
+	    }
+	    let events;
+	    if (modifiers.native) {
+	        delete modifiers.native;
+	        events = el.nativeEvents || (el.nativeEvents = {});
+	    }
+	    else {
+	        events = el.events || (el.events = {});
+	    }
+	    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+	    if (modifiers !== emptyObject) {
+	        newHandler.modifiers = modifiers;
+	    }
+	    const handlers = events[name];
+	    /* istanbul ignore if */
+	    if (Array.isArray(handlers)) {
+	        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+	    }
+	    else if (handlers) {
+	        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+	    }
+	    else {
+	        events[name] = newHandler;
+	    }
+	    el.plain = false;
+	}
+	function getRawBindingAttr(el, name) {
+	    return (el.rawAttrsMap[':' + name] ||
+	        el.rawAttrsMap['v-bind:' + name] ||
+	        el.rawAttrsMap[name]);
+	}
+	function getBindingAttr(el, name, getStatic) {
+	    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+	    if (dynamicValue != null) {
+	        return parseFilters(dynamicValue);
+	    }
+	    else if (getStatic !== false) {
+	        const staticValue = getAndRemoveAttr(el, name);
+	        if (staticValue != null) {
+	            return JSON.stringify(staticValue);
+	        }
+	    }
+	}
+	// note: this only removes the attr from the Array (attrsList) so that it
+	// doesn't get processed by processAttrs.
+	// By default it does NOT remove it from the map (attrsMap) because the map is
+	// needed during codegen.
+	function getAndRemoveAttr(el, name, removeFromMap) {
+	    let val;
+	    if ((val = el.attrsMap[name]) != null) {
+	        const list = el.attrsList;
+	        for (let i = 0, l = list.length; i < l; i++) {
+	            if (list[i].name === name) {
+	                list.splice(i, 1);
+	                break;
+	            }
+	        }
+	    }
+	    if (removeFromMap) {
+	        delete el.attrsMap[name];
+	    }
+	    return val;
+	}
+	function getAndRemoveAttrByRegex(el, name) {
+	    const list = el.attrsList;
+	    for (let i = 0, l = list.length; i < l; i++) {
+	        const attr = list[i];
+	        if (name.test(attr.name)) {
+	            list.splice(i, 1);
+	            return attr;
+	        }
+	    }
+	}
+	function rangeSetItem(item, range) {
+	    if (range) {
+	        if (range.start != null) {
+	            item.start = range.start;
+	        }
+	        if (range.end != null) {
+	            item.end = range.end;
+	        }
+	    }
+	    return item;
 	}
 
-	function transformNode$1(el, options) {
-	    const warn = options.warn || baseWarn;
-	    const staticClass = getAndRemoveAttr(el, 'class');
-	    if (staticClass) {
-	        const res = parseText(staticClass, options.delimiters);
-	        if (res) {
-	            warn(`class="${staticClass}": ` +
-	                'Interpolation inside attributes has been removed. ' +
-	                'Use v-bind or the colon shorthand instead. For example, ' +
-	                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-	        }
-	    }
-	    if (staticClass) {
-	        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-	    }
-	    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-	    if (classBinding) {
-	        el.classBinding = classBinding;
-	    }
-	}
-	function genData$2(el) {
-	    let data = '';
-	    if (el.staticClass) {
-	        data += `staticClass:${el.staticClass},`;
-	    }
-	    if (el.classBinding) {
-	        data += `class:${el.classBinding},`;
-	    }
-	    return data;
-	}
-	var klass = {
-	    staticKeys: ['staticClass'],
-	    transformNode: transformNode$1,
-	    genData: genData$2,
+	function transformNode$1(el, options) {
+	    const warn = options.warn || baseWarn;
+	    const staticClass = getAndRemoveAttr(el, 'class');
+	    if (staticClass) {
+	        const res = parseText(staticClass, options.delimiters);
+	        if (res) {
+	            warn(`class="${staticClass}": ` +
+	                'Interpolation inside attributes has been removed. ' +
+	                'Use v-bind or the colon shorthand instead. For example, ' +
+	                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+	        }
+	    }
+	    if (staticClass) {
+	        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+	    }
+	    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+	    if (classBinding) {
+	        el.classBinding = classBinding;
+	    }
+	}
+	function genData$2(el) {
+	    let data = '';
+	    if (el.staticClass) {
+	        data += `staticClass:${el.staticClass},`;
+	    }
+	    if (el.classBinding) {
+	        data += `class:${el.classBinding},`;
+	    }
+	    return data;
+	}
+	var klass = {
+	    staticKeys: ['staticClass'],
+	    transformNode: transformNode$1,
+	    genData: genData$2,
 	};
 
-	const parseStyleText = cached(function (cssText) {
-	    const res = {};
-	    const listDelimiter = /;(?![^(]*\))/g;
-	    const propertyDelimiter = /:(.+)/;
-	    cssText.split(listDelimiter).forEach(function (item) {
-	        if (item) {
-	            const tmp = item.split(propertyDelimiter);
-	            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-	        }
-	    });
-	    return res;
+	const parseStyleText = cached(function (cssText) {
+	    const res = {};
+	    const listDelimiter = /;(?![^(]*\))/g;
+	    const propertyDelimiter = /:(.+)/;
+	    cssText.split(listDelimiter).forEach(function (item) {
+	        if (item) {
+	            const tmp = item.split(propertyDelimiter);
+	            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+	        }
+	    });
+	    return res;
 	});
 
-	function transformNode(el, options) {
-	    const warn = options.warn || baseWarn;
-	    const staticStyle = getAndRemoveAttr(el, 'style');
-	    if (staticStyle) {
-	        /* istanbul ignore if */
-	        {
-	            const res = parseText(staticStyle, options.delimiters);
-	            if (res) {
-	                warn(`style="${staticStyle}": ` +
-	                    'Interpolation inside attributes has been removed. ' +
-	                    'Use v-bind or the colon shorthand instead. For example, ' +
-	                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-	            }
-	        }
-	        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-	    }
-	    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-	    if (styleBinding) {
-	        el.styleBinding = styleBinding;
-	    }
-	}
-	function genData$1(el) {
-	    let data = '';
-	    if (el.staticStyle) {
-	        data += `staticStyle:${el.staticStyle},`;
-	    }
-	    if (el.styleBinding) {
-	        data += `style:(${el.styleBinding}),`;
-	    }
-	    return data;
-	}
-	var style = {
-	    staticKeys: ['staticStyle'],
-	    transformNode,
-	    genData: genData$1,
+	function transformNode(el, options) {
+	    const warn = options.warn || baseWarn;
+	    const staticStyle = getAndRemoveAttr(el, 'style');
+	    if (staticStyle) {
+	        /* istanbul ignore if */
+	        {
+	            const res = parseText(staticStyle, options.delimiters);
+	            if (res) {
+	                warn(`style="${staticStyle}": ` +
+	                    'Interpolation inside attributes has been removed. ' +
+	                    'Use v-bind or the colon shorthand instead. For example, ' +
+	                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+	            }
+	        }
+	        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+	    }
+	    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+	    if (styleBinding) {
+	        el.styleBinding = styleBinding;
+	    }
+	}
+	function genData$1(el) {
+	    let data = '';
+	    if (el.staticStyle) {
+	        data += `staticStyle:${el.staticStyle},`;
+	    }
+	    if (el.styleBinding) {
+	        data += `style:(${el.styleBinding}),`;
+	    }
+	    return data;
+	}
+	var style = {
+	    staticKeys: ['staticStyle'],
+	    transformNode,
+	    genData: genData$1,
 	};
 
 	var he$1 = {exports: {}};
@@ -2240,2695 +2240,2695 @@
 
 	var he = he$1.exports;
 
-	/**
-	 * Cross-platform code generation for component v-model
-	 */
-	function genComponentModel(el, value, modifiers) {
-	    const { number, trim } = modifiers || {};
-	    const baseValueExpression = '$$v';
-	    let valueExpression = baseValueExpression;
-	    if (trim) {
-	        valueExpression =
-	            `(typeof ${baseValueExpression} === 'string'` +
-	                `? ${baseValueExpression}.trim()` +
-	                `: ${baseValueExpression})`;
-	    }
-	    if (number) {
-	        valueExpression = `_n(${valueExpression})`;
-	    }
-	    const assignment = genAssignmentCode(value, valueExpression);
-	    el.model = {
-	        value: `(${value})`,
-	        expression: JSON.stringify(value),
-	        callback: `function (${baseValueExpression}) {${assignment}}`,
-	    };
+	/**
+	 * Cross-platform code generation for component v-model
+	 */
+	function genComponentModel(el, value, modifiers) {
+	    const { number, trim } = modifiers || {};
+	    const baseValueExpression = '$$v';
+	    let valueExpression = baseValueExpression;
+	    if (trim) {
+	        valueExpression =
+	            `(typeof ${baseValueExpression} === 'string'` +
+	                `? ${baseValueExpression}.trim()` +
+	                `: ${baseValueExpression})`;
+	    }
+	    if (number) {
+	        valueExpression = `_n(${valueExpression})`;
+	    }
+	    const assignment = genAssignmentCode(value, valueExpression);
+	    el.model = {
+	        value: `(${value})`,
+	        expression: JSON.stringify(value),
+	        callback: `function (${baseValueExpression}) {${assignment}}`,
+	    };
+	}
+	/**
+	 * Cross-platform codegen helper for generating v-model value assignment code.
+	 */
+	function genAssignmentCode(value, assignment) {
+	    const res = parseModel(value);
+	    if (res.key === null) {
+	        return `${value}=${assignment}`;
+	    }
+	    else {
+	        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+	    }
+	}
+	/**
+	 * Parse a v-model expression into a base path and a final key segment.
+	 * Handles both dot-path and possible square brackets.
+	 *
+	 * Possible cases:
+	 *
+	 * - test
+	 * - test[key]
+	 * - test[test1[key]]
+	 * - test["a"][key]
+	 * - xxx.test[a[a].test1[key]]
+	 * - test.xxx.a["asa"][test1[key]]
+	 *
+	 */
+	let len, str, chr, index, expressionPos, expressionEndPos;
+	function parseModel(val) {
+	    // Fix https://github.com/vuejs/vue/pull/7730
+	    // allow v-model="obj.val " (trailing whitespace)
+	    val = val.trim();
+	    len = val.length;
+	    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+	        index = val.lastIndexOf('.');
+	        if (index > -1) {
+	            return {
+	                exp: val.slice(0, index),
+	                key: '"' + val.slice(index + 1) + '"',
+	            };
+	        }
+	        else {
+	            return {
+	                exp: val,
+	                key: null,
+	            };
+	        }
+	    }
+	    str = val;
+	    index = expressionPos = expressionEndPos = 0;
+	    while (!eof()) {
+	        chr = next();
+	        /* istanbul ignore if */
+	        if (isStringStart(chr)) {
+	            parseString(chr);
+	        }
+	        else if (chr === 0x5b) {
+	            parseBracket(chr);
+	        }
+	    }
+	    return {
+	        exp: val.slice(0, expressionPos),
+	        key: val.slice(expressionPos + 1, expressionEndPos),
+	    };
+	}
+	function next() {
+	    return str.charCodeAt(++index);
+	}
+	function eof() {
+	    return index >= len;
+	}
+	function isStringStart(chr) {
+	    return chr === 0x22 || chr === 0x27;
+	}
+	function parseBracket(chr) {
+	    let inBracket = 1;
+	    expressionPos = index;
+	    while (!eof()) {
+	        chr = next();
+	        if (isStringStart(chr)) {
+	            parseString(chr);
+	            continue;
+	        }
+	        if (chr === 0x5b)
+	            inBracket++;
+	        if (chr === 0x5d)
+	            inBracket--;
+	        if (inBracket === 0) {
+	            expressionEndPos = index;
+	            break;
+	        }
+	    }
+	}
+	function parseString(chr) {
+	    const stringQuote = chr;
+	    while (!eof()) {
+	        chr = next();
+	        if (chr === stringQuote) {
+	            break;
+	        }
+	    }
 	}
-	/**
-	 * Cross-platform codegen helper for generating v-model value assignment code.
-	 */
-	function genAssignmentCode(value, assignment) {
-	    const res = parseModel(value);
-	    if (res.key === null) {
-	        return `${value}=${assignment}`;
-	    }
-	    else {
-	        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-	    }
+
+	const onRE = /^@|^v-on:/;
+	const dirRE = /^v-|^@|^:|^#/;
+	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+	const stripParensRE = /^\(|\)$/g;
+	const dynamicArgRE = /^\[.*\]$/;
+	const argRE = /:(.*)$/;
+	const bindRE = /^:|^\.|^v-bind:/;
+	const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+	const slotRE = /^v-slot(:|$)|^#/;
+	const lineBreakRE = /[\r\n]/;
+	const whitespaceRE = /[ \f\t\r\n]+/g;
+	const invalidAttributeRE = /[\s"'<>\/=]/;
+	const decodeHTMLCached = cached(he.decode);
+	const emptySlotScopeToken = `_empty_`;
+	// configurable state
+	let warn$1;
+	let delimiters;
+	let transforms;
+	let preTransforms;
+	let postTransforms;
+	let platformIsPreTag;
+	let platformMustUseProp;
+	let platformGetTagNamespace;
+	let maybeComponent;
+	function createASTElement(tag, attrs, parent) {
+	    return {
+	        type: 1,
+	        tag,
+	        attrsList: attrs,
+	        attrsMap: makeAttrsMap(attrs),
+	        rawAttrsMap: {},
+	        parent,
+	        children: [],
+	    };
+	}
+	/**
+	 * Convert HTML string to AST.
+	 */
+	function parse(template, options) {
+	    warn$1 = options.warn || baseWarn;
+	    platformIsPreTag = options.isPreTag || no;
+	    platformMustUseProp = options.mustUseProp || no;
+	    platformGetTagNamespace = options.getTagNamespace || no;
+	    const isReservedTag = options.isReservedTag || no;
+	    maybeComponent = (el) => !!(el.component ||
+	        el.attrsMap[':is'] ||
+	        el.attrsMap['v-bind:is'] ||
+	        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+	    transforms = pluckModuleFunction(options.modules, 'transformNode');
+	    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+	    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+	    delimiters = options.delimiters;
+	    const stack = [];
+	    const preserveWhitespace = options.preserveWhitespace !== false;
+	    const whitespaceOption = options.whitespace;
+	    let root;
+	    let currentParent;
+	    let inVPre = false;
+	    let inPre = false;
+	    let warned = false;
+	    function warnOnce(msg, range) {
+	        if (!warned) {
+	            warned = true;
+	            warn$1(msg, range);
+	        }
+	    }
+	    function closeElement(element) {
+	        trimEndingWhitespace(element);
+	        if (!inVPre && !element.processed) {
+	            element = processElement(element, options);
+	        }
+	        // tree management
+	        if (!stack.length && element !== root) {
+	            // allow root elements with v-if, v-else-if and v-else
+	            if (root.if && (element.elseif || element.else)) {
+	                {
+	                    checkRootConstraints(element);
+	                }
+	                addIfCondition(root, {
+	                    exp: element.elseif,
+	                    block: element,
+	                });
+	            }
+	            else {
+	                warnOnce(`Component template should contain exactly one root element. ` +
+	                    `If you are using v-if on multiple elements, ` +
+	                    `use v-else-if to chain them instead.`, { start: element.start });
+	            }
+	        }
+	        if (currentParent && !element.forbidden) {
+	            if (element.elseif || element.else) {
+	                processIfConditions(element, currentParent);
+	            }
+	            else {
+	                if (element.slotScope) {
+	                    // scoped slot
+	                    // keep it in the children list so that v-else(-if) conditions can
+	                    // find it as the prev node.
+	                    const name = element.slotTarget || '"default"';
+	                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+	                }
+	                currentParent.children.push(element);
+	                element.parent = currentParent;
+	            }
+	        }
+	        // final children cleanup
+	        // filter out scoped slots
+	        element.children = element.children.filter((c) => !c.slotScope);
+	        // remove trailing whitespace node again
+	        trimEndingWhitespace(element);
+	        // check pre state
+	        if (element.pre) {
+	            inVPre = false;
+	        }
+	        if (platformIsPreTag(element.tag)) {
+	            inPre = false;
+	        }
+	        // apply post-transforms
+	        for (let i = 0; i < postTransforms.length; i++) {
+	            postTransforms[i](element, options);
+	        }
+	    }
+	    function trimEndingWhitespace(el) {
+	        // remove trailing whitespace node
+	        if (!inPre) {
+	            let lastNode;
+	            while ((lastNode = el.children[el.children.length - 1]) &&
+	                lastNode.type === 3 &&
+	                lastNode.text === ' ') {
+	                el.children.pop();
+	            }
+	        }
+	    }
+	    function checkRootConstraints(el) {
+	        if (el.tag === 'slot' || el.tag === 'template') {
+	            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+	                'contain multiple nodes.', { start: el.start });
+	        }
+	        if (el.attrsMap.hasOwnProperty('v-for')) {
+	            warnOnce('Cannot use v-for on stateful component root element because ' +
+	                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+	        }
+	    }
+	    parseHTML(template, {
+	        warn: warn$1,
+	        expectHTML: options.expectHTML,
+	        isUnaryTag: options.isUnaryTag,
+	        canBeLeftOpenTag: options.canBeLeftOpenTag,
+	        shouldDecodeNewlines: options.shouldDecodeNewlines,
+	        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+	        shouldKeepComment: options.comments,
+	        outputSourceRange: options.outputSourceRange,
+	        start(tag, attrs, unary, start, end) {
+	            // check namespace.
+	            // inherit parent ns if there is one
+	            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+	            // handle IE svg bug
+	            /* istanbul ignore if */
+	            if (isIE && ns === 'svg') {
+	                attrs = guardIESVGBug(attrs);
+	            }
+	            let element = createASTElement(tag, attrs, currentParent);
+	            if (ns) {
+	                element.ns = ns;
+	            }
+	            {
+	                if (options.outputSourceRange) {
+	                    element.start = start;
+	                    element.end = end;
+	                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+	                        cumulated[attr.name] = attr;
+	                        return cumulated;
+	                    }, {});
+	                }
+	                attrs.forEach((attr) => {
+	                    if (invalidAttributeRE.test(attr.name)) {
+	                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+	                            `spaces, quotes, <, >, / or =.`, {
+	                            start: attr.start + attr.name.indexOf(`[`),
+	                            end: attr.start + attr.name.length,
+	                        });
+	                    }
+	                });
+	            }
+	            if (isForbiddenTag(element) && !isServerRendering()) {
+	                element.forbidden = true;
+	                warn$1('Templates should only be responsible for mapping the state to the ' +
+	                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+	                        `<${tag}>` +
+	                        ', as they will not be parsed.', { start: element.start });
+	            }
+	            // apply pre-transforms
+	            for (let i = 0; i < preTransforms.length; i++) {
+	                element = preTransforms[i](element, options) || element;
+	            }
+	            if (!inVPre) {
+	                processPre(element);
+	                if (element.pre) {
+	                    inVPre = true;
+	                }
+	            }
+	            if (platformIsPreTag(element.tag)) {
+	                inPre = true;
+	            }
+	            if (inVPre) {
+	                processRawAttrs(element);
+	            }
+	            else if (!element.processed) {
+	                // structural directives
+	                processFor(element);
+	                processIf(element);
+	                processOnce(element);
+	            }
+	            if (!root) {
+	                root = element;
+	                {
+	                    checkRootConstraints(root);
+	                }
+	            }
+	            if (!unary) {
+	                currentParent = element;
+	                stack.push(element);
+	            }
+	            else {
+	                closeElement(element);
+	            }
+	        },
+	        end(tag, start, end) {
+	            const element = stack[stack.length - 1];
+	            // pop stack
+	            stack.length -= 1;
+	            currentParent = stack[stack.length - 1];
+	            if (options.outputSourceRange) {
+	                element.end = end;
+	            }
+	            closeElement(element);
+	        },
+	        chars(text, start, end) {
+	            if (!currentParent) {
+	                {
+	                    if (text === template) {
+	                        warnOnce('Component template requires a root element, rather than just text.', { start });
+	                    }
+	                    else if ((text = text.trim())) {
+	                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+	                            start,
+	                        });
+	                    }
+	                }
+	                return;
+	            }
+	            // IE textarea placeholder bug
+	            /* istanbul ignore if */
+	            if (isIE &&
+	                currentParent.tag === 'textarea' &&
+	                currentParent.attrsMap.placeholder === text) {
+	                return;
+	            }
+	            const children = currentParent.children;
+	            if (inPre || text.trim()) {
+	                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+	            }
+	            else if (!children.length) {
+	                // remove the whitespace-only node right after an opening tag
+	                text = '';
+	            }
+	            else if (whitespaceOption) {
+	                if (whitespaceOption === 'condense') {
+	                    // in condense mode, remove the whitespace node if it contains
+	                    // line break, otherwise condense to a single space
+	                    text = lineBreakRE.test(text) ? '' : ' ';
+	                }
+	                else {
+	                    text = ' ';
+	                }
+	            }
+	            else {
+	                text = preserveWhitespace ? ' ' : '';
+	            }
+	            if (text) {
+	                if (!inPre && whitespaceOption === 'condense') {
+	                    // condense consecutive whitespaces into single space
+	                    text = text.replace(whitespaceRE, ' ');
+	                }
+	                let res;
+	                let child;
+	                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+	                    child = {
+	                        type: 2,
+	                        expression: res.expression,
+	                        tokens: res.tokens,
+	                        text,
+	                    };
+	                }
+	                else if (text !== ' ' ||
+	                    !children.length ||
+	                    children[children.length - 1].text !== ' ') {
+	                    child = {
+	                        type: 3,
+	                        text,
+	                    };
+	                }
+	                if (child) {
+	                    if (options.outputSourceRange) {
+	                        child.start = start;
+	                        child.end = end;
+	                    }
+	                    children.push(child);
+	                }
+	            }
+	        },
+	        comment(text, start, end) {
+	            // adding anything as a sibling to the root node is forbidden
+	            // comments should still be allowed, but ignored
+	            if (currentParent) {
+	                const child = {
+	                    type: 3,
+	                    text,
+	                    isComment: true,
+	                };
+	                if (options.outputSourceRange) {
+	                    child.start = start;
+	                    child.end = end;
+	                }
+	                currentParent.children.push(child);
+	            }
+	        },
+	    });
+	    return root;
+	}
+	function processPre(el) {
+	    if (getAndRemoveAttr(el, 'v-pre') != null) {
+	        el.pre = true;
+	    }
+	}
+	function processRawAttrs(el) {
+	    const list = el.attrsList;
+	    const len = list.length;
+	    if (len) {
+	        const attrs = (el.attrs = new Array(len));
+	        for (let i = 0; i < len; i++) {
+	            attrs[i] = {
+	                name: list[i].name,
+	                value: JSON.stringify(list[i].value),
+	            };
+	            if (list[i].start != null) {
+	                attrs[i].start = list[i].start;
+	                attrs[i].end = list[i].end;
+	            }
+	        }
+	    }
+	    else if (!el.pre) {
+	        // non root node in pre blocks with no attributes
+	        el.plain = true;
+	    }
+	}
+	function processElement(element, options) {
+	    processKey(element);
+	    // determine whether this is a plain element after
+	    // removing structural attributes
+	    element.plain =
+	        !element.key && !element.scopedSlots && !element.attrsList.length;
+	    processRef(element);
+	    processSlotContent(element);
+	    processSlotOutlet(element);
+	    processComponent(element);
+	    for (let i = 0; i < transforms.length; i++) {
+	        element = transforms[i](element, options) || element;
+	    }
+	    processAttrs(element);
+	    return element;
+	}
+	function processKey(el) {
+	    const exp = getBindingAttr(el, 'key');
+	    if (exp) {
+	        {
+	            if (el.tag === 'template') {
+	                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+	            }
+	            if (el.for) {
+	                const iterator = el.iterator2 || el.iterator1;
+	                const parent = el.parent;
+	                if (iterator &&
+	                    iterator === exp &&
+	                    parent &&
+	                    parent.tag === 'transition-group') {
+	                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+	                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+	                }
+	            }
+	        }
+	        el.key = exp;
+	    }
+	}
+	function processRef(el) {
+	    const ref = getBindingAttr(el, 'ref');
+	    if (ref) {
+	        el.ref = ref;
+	        el.refInFor = checkInFor(el);
+	    }
+	}
+	function processFor(el) {
+	    let exp;
+	    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+	        const res = parseFor(exp);
+	        if (res) {
+	            extend(el, res);
+	        }
+	        else {
+	            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+	        }
+	    }
+	}
+	function parseFor(exp) {
+	    const inMatch = exp.match(forAliasRE);
+	    if (!inMatch)
+	        return;
+	    const res = {};
+	    res.for = inMatch[2].trim();
+	    const alias = inMatch[1].trim().replace(stripParensRE, '');
+	    const iteratorMatch = alias.match(forIteratorRE);
+	    if (iteratorMatch) {
+	        res.alias = alias.replace(forIteratorRE, '').trim();
+	        res.iterator1 = iteratorMatch[1].trim();
+	        if (iteratorMatch[2]) {
+	            res.iterator2 = iteratorMatch[2].trim();
+	        }
+	    }
+	    else {
+	        res.alias = alias;
+	    }
+	    return res;
+	}
+	function processIf(el) {
+	    const exp = getAndRemoveAttr(el, 'v-if');
+	    if (exp) {
+	        el.if = exp;
+	        addIfCondition(el, {
+	            exp: exp,
+	            block: el,
+	        });
+	    }
+	    else {
+	        if (getAndRemoveAttr(el, 'v-else') != null) {
+	            el.else = true;
+	        }
+	        const elseif = getAndRemoveAttr(el, 'v-else-if');
+	        if (elseif) {
+	            el.elseif = elseif;
+	        }
+	    }
+	}
+	function processIfConditions(el, parent) {
+	    const prev = findPrevElement(parent.children);
+	    if (prev && prev.if) {
+	        addIfCondition(prev, {
+	            exp: el.elseif,
+	            block: el,
+	        });
+	    }
+	    else {
+	        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+	            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+	    }
+	}
+	function findPrevElement(children) {
+	    let i = children.length;
+	    while (i--) {
+	        if (children[i].type === 1) {
+	            return children[i];
+	        }
+	        else {
+	            if (children[i].text !== ' ') {
+	                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+	                    `will be ignored.`, children[i]);
+	            }
+	            children.pop();
+	        }
+	    }
+	}
+	function addIfCondition(el, condition) {
+	    if (!el.ifConditions) {
+	        el.ifConditions = [];
+	    }
+	    el.ifConditions.push(condition);
+	}
+	function processOnce(el) {
+	    const once = getAndRemoveAttr(el, 'v-once');
+	    if (once != null) {
+	        el.once = true;
+	    }
+	}
+	// handle content being passed to a component as slot,
+	// e.g. <template slot="xxx">, <div slot-scope="xxx">
+	function processSlotContent(el) {
+	    let slotScope;
+	    if (el.tag === 'template') {
+	        slotScope = getAndRemoveAttr(el, 'scope');
+	        /* istanbul ignore if */
+	        if (slotScope) {
+	            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+	                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+	                `can also be used on plain elements in addition to <template> to ` +
+	                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+	        }
+	        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+	    }
+	    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+	        /* istanbul ignore if */
+	        if (el.attrsMap['v-for']) {
+	            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+	                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+	                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+	        }
+	        el.slotScope = slotScope;
+	    }
+	    // slot="xxx"
+	    const slotTarget = getBindingAttr(el, 'slot');
+	    if (slotTarget) {
+	        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+	        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+	        // preserve slot as an attribute for native shadow DOM compat
+	        // only for non-scoped slots.
+	        if (el.tag !== 'template' && !el.slotScope) {
+	            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+	        }
+	    }
+	    // 2.6 v-slot syntax
+	    {
+	        if (el.tag === 'template') {
+	            // v-slot on <template>
+	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+	            if (slotBinding) {
+	                {
+	                    if (el.slotTarget || el.slotScope) {
+	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+	                    }
+	                    if (el.parent && !maybeComponent(el.parent)) {
+	                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+	                            `the receiving component`, el);
+	                    }
+	                }
+	                const { name, dynamic } = getSlotName(slotBinding);
+	                el.slotTarget = name;
+	                el.slotTargetDynamic = dynamic;
+	                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+	            }
+	        }
+	        else {
+	            // v-slot on component, denotes default slot
+	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+	            if (slotBinding) {
+	                {
+	                    if (!maybeComponent(el)) {
+	                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+	                    }
+	                    if (el.slotScope || el.slotTarget) {
+	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+	                    }
+	                    if (el.scopedSlots) {
+	                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+	                            `<template> syntax when there are other named slots.`, slotBinding);
+	                    }
+	                }
+	                // add the component's children to its default slot
+	                const slots = el.scopedSlots || (el.scopedSlots = {});
+	                const { name, dynamic } = getSlotName(slotBinding);
+	                const slotContainer = (slots[name] = createASTElement('template', [], el));
+	                slotContainer.slotTarget = name;
+	                slotContainer.slotTargetDynamic = dynamic;
+	                slotContainer.children = el.children.filter((c) => {
+	                    if (!c.slotScope) {
+	                        c.parent = slotContainer;
+	                        return true;
+	                    }
+	                });
+	                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+	                // remove children as they are returned from scopedSlots now
+	                el.children = [];
+	                // mark el non-plain so data gets generated
+	                el.plain = false;
+	            }
+	        }
+	    }
+	}
+	function getSlotName(binding) {
+	    let name = binding.name.replace(slotRE, '');
+	    if (!name) {
+	        if (binding.name[0] !== '#') {
+	            name = 'default';
+	        }
+	        else {
+	            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+	        }
+	    }
+	    return dynamicArgRE.test(name)
+	        ? // dynamic [name]
+	            { name: name.slice(1, -1), dynamic: true }
+	        : // static name
+	            { name: `"${name}"`, dynamic: false };
+	}
+	// handle <slot/> outlets
+	function processSlotOutlet(el) {
+	    if (el.tag === 'slot') {
+	        el.slotName = getBindingAttr(el, 'name');
+	        if (el.key) {
+	            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+	                `and can possibly expand into multiple elements. ` +
+	                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+	        }
+	    }
+	}
+	function processComponent(el) {
+	    let binding;
+	    if ((binding = getBindingAttr(el, 'is'))) {
+	        el.component = binding;
+	    }
+	    if (getAndRemoveAttr(el, 'inline-template') != null) {
+	        el.inlineTemplate = true;
+	    }
+	}
+	function processAttrs(el) {
+	    const list = el.attrsList;
+	    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+	    for (i = 0, l = list.length; i < l; i++) {
+	        name = rawName = list[i].name;
+	        value = list[i].value;
+	        if (dirRE.test(name)) {
+	            // mark element as dynamic
+	            el.hasBindings = true;
+	            // modifiers
+	            modifiers = parseModifiers(name.replace(dirRE, ''));
+	            // support .foo shorthand syntax for the .prop modifier
+	            if (modifiers) {
+	                name = name.replace(modifierRE, '');
+	            }
+	            if (bindRE.test(name)) {
+	                // v-bind
+	                name = name.replace(bindRE, '');
+	                value = parseFilters(value);
+	                isDynamic = dynamicArgRE.test(name);
+	                if (isDynamic) {
+	                    name = name.slice(1, -1);
+	                }
+	                if (value.trim().length === 0) {
+	                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+	                }
+	                if (modifiers) {
+	                    if (modifiers.prop && !isDynamic) {
+	                        name = camelize(name);
+	                        if (name === 'innerHtml')
+	                            name = 'innerHTML';
+	                    }
+	                    if (modifiers.camel && !isDynamic) {
+	                        name = camelize(name);
+	                    }
+	                    if (modifiers.sync) {
+	                        syncGen = genAssignmentCode(value, `$event`);
+	                        if (!isDynamic) {
+	                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+	                            if (hyphenate(name) !== camelize(name)) {
+	                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+	                            }
+	                        }
+	                        else {
+	                            // handler w/ dynamic event name
+	                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+	                            );
+	                        }
+	                    }
+	                }
+	                if ((modifiers && modifiers.prop) ||
+	                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+	                    addProp(el, name, value, list[i], isDynamic);
+	                }
+	                else {
+	                    addAttr(el, name, value, list[i], isDynamic);
+	                }
+	            }
+	            else if (onRE.test(name)) {
+	                // v-on
+	                name = name.replace(onRE, '');
+	                isDynamic = dynamicArgRE.test(name);
+	                if (isDynamic) {
+	                    name = name.slice(1, -1);
+	                }
+	                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+	            }
+	            else {
+	                // normal directives
+	                name = name.replace(dirRE, '');
+	                // parse arg
+	                const argMatch = name.match(argRE);
+	                let arg = argMatch && argMatch[1];
+	                isDynamic = false;
+	                if (arg) {
+	                    name = name.slice(0, -(arg.length + 1));
+	                    if (dynamicArgRE.test(arg)) {
+	                        arg = arg.slice(1, -1);
+	                        isDynamic = true;
+	                    }
+	                }
+	                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+	                if (name === 'model') {
+	                    checkForAliasModel(el, value);
+	                }
+	            }
+	        }
+	        else {
+	            // literal attribute
+	            {
+	                const res = parseText(value, delimiters);
+	                if (res) {
+	                    warn$1(`${name}="${value}": ` +
+	                        'Interpolation inside attributes has been removed. ' +
+	                        'Use v-bind or the colon shorthand instead. For example, ' +
+	                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+	                }
+	            }
+	            addAttr(el, name, JSON.stringify(value), list[i]);
+	            // #6887 firefox doesn't update muted state if set via attribute
+	            // even immediately after element creation
+	            if (!el.component &&
+	                name === 'muted' &&
+	                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+	                addProp(el, name, 'true', list[i]);
+	            }
+	        }
+	    }
+	}
+	function checkInFor(el) {
+	    let parent = el;
+	    while (parent) {
+	        if (parent.for !== undefined) {
+	            return true;
+	        }
+	        parent = parent.parent;
+	    }
+	    return false;
+	}
+	function parseModifiers(name) {
+	    const match = name.match(modifierRE);
+	    if (match) {
+	        const ret = {};
+	        match.forEach((m) => {
+	            ret[m.slice(1)] = true;
+	        });
+	        return ret;
+	    }
+	}
+	function makeAttrsMap(attrs) {
+	    const map = {};
+	    for (let i = 0, l = attrs.length; i < l; i++) {
+	        if (map[attrs[i].name] &&
+	            !isIE &&
+	            !isEdge) {
+	            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+	        }
+	        map[attrs[i].name] = attrs[i].value;
+	    }
+	    return map;
+	}
+	// for script (e.g. type="x/template") or style, do not decode content
+	function isTextTag(el) {
+	    return el.tag === 'script' || el.tag === 'style';
+	}
+	function isForbiddenTag(el) {
+	    return (el.tag === 'style' ||
+	        (el.tag === 'script' &&
+	            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+	}
+	const ieNSBug = /^xmlns:NS\d+/;
+	const ieNSPrefix = /^NS\d+:/;
+	/* istanbul ignore next */
+	function guardIESVGBug(attrs) {
+	    const res = [];
+	    for (let i = 0; i < attrs.length; i++) {
+	        const attr = attrs[i];
+	        if (!ieNSBug.test(attr.name)) {
+	            attr.name = attr.name.replace(ieNSPrefix, '');
+	            res.push(attr);
+	        }
+	    }
+	    return res;
+	}
+	function checkForAliasModel(el, value) {
+	    let _el = el;
+	    while (_el) {
+	        if (_el.for && _el.alias === value) {
+	            warn$1(`<${el.tag} v-model="${value}">: ` +
+	                `You are binding v-model directly to a v-for iteration alias. ` +
+	                `This will not be able to modify the v-for source array because ` +
+	                `writing to the alias is like modifying a function local variable. ` +
+	                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+	        }
+	        _el = _el.parent;
+	    }
 	}
-	/**
-	 * Parse a v-model expression into a base path and a final key segment.
-	 * Handles both dot-path and possible square brackets.
-	 *
-	 * Possible cases:
-	 *
-	 * - test
-	 * - test[key]
-	 * - test[test1[key]]
-	 * - test["a"][key]
-	 * - xxx.test[a[a].test1[key]]
-	 * - test.xxx.a["asa"][test1[key]]
-	 *
-	 */
-	let len, str, chr, index, expressionPos, expressionEndPos;
-	function parseModel(val) {
-	    // Fix https://github.com/vuejs/vue/pull/7730
-	    // allow v-model="obj.val " (trailing whitespace)
-	    val = val.trim();
-	    len = val.length;
-	    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-	        index = val.lastIndexOf('.');
-	        if (index > -1) {
-	            return {
-	                exp: val.slice(0, index),
-	                key: '"' + val.slice(index + 1) + '"',
-	            };
-	        }
-	        else {
-	            return {
-	                exp: val,
-	                key: null,
-	            };
-	        }
-	    }
-	    str = val;
-	    index = expressionPos = expressionEndPos = 0;
-	    while (!eof()) {
-	        chr = next();
-	        /* istanbul ignore if */
-	        if (isStringStart(chr)) {
-	            parseString(chr);
-	        }
-	        else if (chr === 0x5b) {
-	            parseBracket(chr);
-	        }
-	    }
-	    return {
-	        exp: val.slice(0, expressionPos),
-	        key: val.slice(expressionPos + 1, expressionEndPos),
-	    };
+
+	/**
+	 * Expand input[v-model] with dynamic type bindings into v-if-else chains
+	 * Turn this:
+	 *   <input v-model="data[type]" :type="type">
+	 * into this:
+	 *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+	 *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+	 *   <input v-else :type="type" v-model="data[type]">
+	 */
+	function preTransformNode(el, options) {
+	    if (el.tag === 'input') {
+	        const map = el.attrsMap;
+	        if (!map['v-model']) {
+	            return;
+	        }
+	        let typeBinding;
+	        if (map[':type'] || map['v-bind:type']) {
+	            typeBinding = getBindingAttr(el, 'type');
+	        }
+	        if (!map.type && !typeBinding && map['v-bind']) {
+	            typeBinding = `(${map['v-bind']}).type`;
+	        }
+	        if (typeBinding) {
+	            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+	            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+	            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+	            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+	            // 1. checkbox
+	            const branch0 = cloneASTElement(el);
+	            // process for on the main node
+	            processFor(branch0);
+	            addRawAttr(branch0, 'type', 'checkbox');
+	            processElement(branch0, options);
+	            branch0.processed = true; // prevent it from double-processed
+	            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+	            addIfCondition(branch0, {
+	                exp: branch0.if,
+	                block: branch0,
+	            });
+	            // 2. add radio else-if condition
+	            const branch1 = cloneASTElement(el);
+	            getAndRemoveAttr(branch1, 'v-for', true);
+	            addRawAttr(branch1, 'type', 'radio');
+	            processElement(branch1, options);
+	            addIfCondition(branch0, {
+	                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+	                block: branch1,
+	            });
+	            // 3. other
+	            const branch2 = cloneASTElement(el);
+	            getAndRemoveAttr(branch2, 'v-for', true);
+	            addRawAttr(branch2, ':type', typeBinding);
+	            processElement(branch2, options);
+	            addIfCondition(branch0, {
+	                exp: ifCondition,
+	                block: branch2,
+	            });
+	            if (hasElse) {
+	                branch0.else = true;
+	            }
+	            else if (elseIfCondition) {
+	                branch0.elseif = elseIfCondition;
+	            }
+	            return branch0;
+	        }
+	    }
+	}
+	function cloneASTElement(el) {
+	    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+	}
+	var model$1 = {
+	    preTransformNode,
+	};
+
+	var modules = [klass, style, model$1];
+
+	let warn;
+	// in some cases, the event used has to be determined at runtime
+	// so we used some reserved tokens during compile.
+	const RANGE_TOKEN = '__r';
+	function model(el, dir, _warn) {
+	    warn = _warn;
+	    const value = dir.value;
+	    const modifiers = dir.modifiers;
+	    const tag = el.tag;
+	    const type = el.attrsMap.type;
+	    {
+	        // inputs with type="file" are read only and setting the input's
+	        // value will throw an error.
+	        if (tag === 'input' && type === 'file') {
+	            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+	                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+	        }
+	    }
+	    if (el.component) {
+	        genComponentModel(el, value, modifiers);
+	        // component v-model doesn't need extra runtime
+	        return false;
+	    }
+	    else if (tag === 'select') {
+	        genSelect(el, value, modifiers);
+	    }
+	    else if (tag === 'input' && type === 'checkbox') {
+	        genCheckboxModel(el, value, modifiers);
+	    }
+	    else if (tag === 'input' && type === 'radio') {
+	        genRadioModel(el, value, modifiers);
+	    }
+	    else if (tag === 'input' || tag === 'textarea') {
+	        genDefaultModel(el, value, modifiers);
+	    }
+	    else {
+	        genComponentModel(el, value, modifiers);
+	        // component v-model doesn't need extra runtime
+	        return false;
+	    }
+	    // ensure runtime directive metadata
+	    return true;
+	}
+	function genCheckboxModel(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    const valueBinding = getBindingAttr(el, 'value') || 'null';
+	    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+	    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+	    addProp(el, 'checked', `Array.isArray(${value})` +
+	        `?_i(${value},${valueBinding})>-1` +
+	        (trueValueBinding === 'true'
+	            ? `:(${value})`
+	            : `:_q(${value},${trueValueBinding})`));
+	    addHandler(el, 'change', `var $$a=${value},` +
+	        '$$el=$event.target,' +
+	        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+	        'if(Array.isArray($$a)){' +
+	        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+	        '$$i=_i($$a,$$v);' +
+	        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+	        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+	        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+	}
+	function genRadioModel(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    let valueBinding = getBindingAttr(el, 'value') || 'null';
+	    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+	    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+	    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+	}
+	function genSelect(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    const selectedVal = `Array.prototype.filter` +
+	        `.call($event.target.options,function(o){return o.selected})` +
+	        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+	        `return ${number ? '_n(val)' : 'val'}})`;
+	    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+	    let code = `var $$selectedVal = ${selectedVal};`;
+	    code = `${code} ${genAssignmentCode(value, assignment)}`;
+	    addHandler(el, 'change', code, null, true);
+	}
+	function genDefaultModel(el, value, modifiers) {
+	    const type = el.attrsMap.type;
+	    // warn if v-bind:value conflicts with v-model
+	    // except for inputs with v-bind:type
+	    {
+	        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+	        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+	        if (value && !typeBinding) {
+	            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+	            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+	                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+	        }
+	    }
+	    const { lazy, number, trim } = modifiers || {};
+	    const needCompositionGuard = !lazy && type !== 'range';
+	    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+	    let valueExpression = '$event.target.value';
+	    if (trim) {
+	        valueExpression = `$event.target.value.trim()`;
+	    }
+	    if (number) {
+	        valueExpression = `_n(${valueExpression})`;
+	    }
+	    let code = genAssignmentCode(value, valueExpression);
+	    if (needCompositionGuard) {
+	        code = `if($event.target.composing)return;${code}`;
+	    }
+	    addProp(el, 'value', `(${value})`);
+	    addHandler(el, event, code, null, true);
+	    if (trim || number) {
+	        addHandler(el, 'blur', '$forceUpdate()');
+	    }
 	}
-	function next() {
-	    return str.charCodeAt(++index);
+
+	function text(el, dir) {
+	    if (dir.value) {
+	        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+	    }
 	}
-	function eof() {
-	    return index >= len;
+
+	function html(el, dir) {
+	    if (dir.value) {
+	        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+	    }
 	}
-	function isStringStart(chr) {
-	    return chr === 0x22 || chr === 0x27;
+
+	var directives = {
+	    model,
+	    text,
+	    html,
+	};
+
+	const baseOptions = {
+	    expectHTML: true,
+	    modules,
+	    directives,
+	    isPreTag,
+	    isUnaryTag,
+	    mustUseProp,
+	    canBeLeftOpenTag,
+	    isReservedTag,
+	    getTagNamespace,
+	    staticKeys: genStaticKeys$1(modules),
+	};
+
+	let isStaticKey;
+	let isPlatformReservedTag$1;
+	const genStaticKeysCached = cached(genStaticKeys);
+	/**
+	 * Goal of the optimizer: walk the generated template AST tree
+	 * and detect sub-trees that are purely static, i.e. parts of
+	 * the DOM that never needs to change.
+	 *
+	 * Once we detect these sub-trees, we can:
+	 *
+	 * 1. Hoist them into constants, so that we no longer need to
+	 *    create fresh nodes for them on each re-render;
+	 * 2. Completely skip them in the patching process.
+	 */
+	function optimize$1(root, options) {
+	    if (!root)
+	        return;
+	    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+	    isPlatformReservedTag$1 = options.isReservedTag || no;
+	    // first pass: mark all non-static nodes.
+	    markStatic(root);
+	    // second pass: mark static roots.
+	    markStaticRoots(root, false);
+	}
+	function genStaticKeys(keys) {
+	    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+	        (keys ? ',' + keys : ''));
+	}
+	function markStatic(node) {
+	    node.static = isStatic(node);
+	    if (node.type === 1) {
+	        // do not make component slot content static. this avoids
+	        // 1. components not able to mutate slot nodes
+	        // 2. static slot content fails for hot-reloading
+	        if (!isPlatformReservedTag$1(node.tag) &&
+	            node.tag !== 'slot' &&
+	            node.attrsMap['inline-template'] == null) {
+	            return;
+	        }
+	        for (let i = 0, l = node.children.length; i < l; i++) {
+	            const child = node.children[i];
+	            markStatic(child);
+	            if (!child.static) {
+	                node.static = false;
+	            }
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                const block = node.ifConditions[i].block;
+	                markStatic(block);
+	                if (!block.static) {
+	                    node.static = false;
+	                }
+	            }
+	        }
+	    }
+	}
+	function markStaticRoots(node, isInFor) {
+	    if (node.type === 1) {
+	        if (node.static || node.once) {
+	            node.staticInFor = isInFor;
+	        }
+	        // For a node to qualify as a static root, it should have children that
+	        // are not just static text. Otherwise the cost of hoisting out will
+	        // outweigh the benefits and it's better off to just always render it fresh.
+	        if (node.static &&
+	            node.children.length &&
+	            !(node.children.length === 1 && node.children[0].type === 3)) {
+	            node.staticRoot = true;
+	            return;
+	        }
+	        else {
+	            node.staticRoot = false;
+	        }
+	        if (node.children) {
+	            for (let i = 0, l = node.children.length; i < l; i++) {
+	                markStaticRoots(node.children[i], isInFor || !!node.for);
+	            }
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                markStaticRoots(node.ifConditions[i].block, isInFor);
+	            }
+	        }
+	    }
+	}
+	function isStatic(node) {
+	    if (node.type === 2) {
+	        // expression
+	        return false;
+	    }
+	    if (node.type === 3) {
+	        // text
+	        return true;
+	    }
+	    return !!(node.pre ||
+	        (!node.hasBindings && // no dynamic bindings
+	            !node.if &&
+	            !node.for && // not v-if or v-for or v-else
+	            !isBuiltInTag(node.tag) && // not a built-in
+	            isPlatformReservedTag$1(node.tag) && // not a component
+	            !isDirectChildOfTemplateFor(node) &&
+	            Object.keys(node).every(isStaticKey)));
+	}
+	function isDirectChildOfTemplateFor(node) {
+	    while (node.parent) {
+	        node = node.parent;
+	        if (node.tag !== 'template') {
+	            return false;
+	        }
+	        if (node.for) {
+	            return true;
+	        }
+	    }
+	    return false;
 	}
-	function parseBracket(chr) {
-	    let inBracket = 1;
-	    expressionPos = index;
-	    while (!eof()) {
-	        chr = next();
-	        if (isStringStart(chr)) {
-	            parseString(chr);
-	            continue;
-	        }
-	        if (chr === 0x5b)
-	            inBracket++;
-	        if (chr === 0x5d)
-	            inBracket--;
-	        if (inBracket === 0) {
-	            expressionEndPos = index;
-	            break;
-	        }
-	    }
+
+	const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+	const fnInvokeRE = /\([^)]*?\);*$/;
+	const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+	// KeyboardEvent.keyCode aliases
+	const keyCodes = {
+	    esc: 27,
+	    tab: 9,
+	    enter: 13,
+	    space: 32,
+	    up: 38,
+	    left: 37,
+	    right: 39,
+	    down: 40,
+	    delete: [8, 46],
+	};
+	// KeyboardEvent.key aliases
+	const keyNames = {
+	    // #7880: IE11 and Edge use `Esc` for Escape key name.
+	    esc: ['Esc', 'Escape'],
+	    tab: 'Tab',
+	    enter: 'Enter',
+	    // #9112: IE11 uses `Spacebar` for Space key name.
+	    space: [' ', 'Spacebar'],
+	    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+	    up: ['Up', 'ArrowUp'],
+	    left: ['Left', 'ArrowLeft'],
+	    right: ['Right', 'ArrowRight'],
+	    down: ['Down', 'ArrowDown'],
+	    // #9112: IE11 uses `Del` for Delete key name.
+	    delete: ['Backspace', 'Delete', 'Del'],
+	};
+	// #4868: modifiers that prevent the execution of the listener
+	// need to explicitly return null so that we can determine whether to remove
+	// the listener for .once
+	const genGuard = (condition) => `if(${condition})return null;`;
+	const modifierCode = {
+	    stop: '$event.stopPropagation();',
+	    prevent: '$event.preventDefault();',
+	    self: genGuard(`$event.target !== $event.currentTarget`),
+	    ctrl: genGuard(`!$event.ctrlKey`),
+	    shift: genGuard(`!$event.shiftKey`),
+	    alt: genGuard(`!$event.altKey`),
+	    meta: genGuard(`!$event.metaKey`),
+	    left: genGuard(`'button' in $event && $event.button !== 0`),
+	    middle: genGuard(`'button' in $event && $event.button !== 1`),
+	    right: genGuard(`'button' in $event && $event.button !== 2`),
+	};
+	function genHandlers(events, isNative) {
+	    const prefix = isNative ? 'nativeOn:' : 'on:';
+	    let staticHandlers = ``;
+	    let dynamicHandlers = ``;
+	    for (const name in events) {
+	        const handlerCode = genHandler(events[name]);
+	        //@ts-expect-error
+	        if (events[name] && events[name].dynamic) {
+	            dynamicHandlers += `${name},${handlerCode},`;
+	        }
+	        else {
+	            staticHandlers += `"${name}":${handlerCode},`;
+	        }
+	    }
+	    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+	    if (dynamicHandlers) {
+	        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+	    }
+	    else {
+	        return prefix + staticHandlers;
+	    }
+	}
+	function genHandler(handler) {
+	    if (!handler) {
+	        return 'function(){}';
+	    }
+	    if (Array.isArray(handler)) {
+	        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+	    }
+	    const isMethodPath = simplePathRE.test(handler.value);
+	    const isFunctionExpression = fnExpRE.test(handler.value);
+	    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+	    if (!handler.modifiers) {
+	        if (isMethodPath || isFunctionExpression) {
+	            return handler.value;
+	        }
+	        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+	    }
+	    else {
+	        let code = '';
+	        let genModifierCode = '';
+	        const keys = [];
+	        for (const key in handler.modifiers) {
+	            if (modifierCode[key]) {
+	                genModifierCode += modifierCode[key];
+	                // left/right
+	                if (keyCodes[key]) {
+	                    keys.push(key);
+	                }
+	            }
+	            else if (key === 'exact') {
+	                const modifiers = handler.modifiers;
+	                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+	                    .filter((keyModifier) => !modifiers[keyModifier])
+	                    .map((keyModifier) => `$event.${keyModifier}Key`)
+	                    .join('||'));
+	            }
+	            else {
+	                keys.push(key);
+	            }
+	        }
+	        if (keys.length) {
+	            code += genKeyFilter(keys);
+	        }
+	        // Make sure modifiers like prevent and stop get executed after key filtering
+	        if (genModifierCode) {
+	            code += genModifierCode;
+	        }
+	        const handlerCode = isMethodPath
+	            ? `return ${handler.value}.apply(null, arguments)`
+	            : isFunctionExpression
+	                ? `return (${handler.value}).apply(null, arguments)`
+	                : isFunctionInvocation
+	                    ? `return ${handler.value}`
+	                    : handler.value;
+	        return `function($event){${code}${handlerCode}}`;
+	    }
+	}
+	function genKeyFilter(keys) {
+	    return (
+	    // make sure the key filters only apply to KeyboardEvents
+	    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+	    // key events that do not have keyCode property...
+	    `if(!$event.type.indexOf('key')&&` +
+	        `${keys.map(genFilterCode).join('&&')})return null;`);
+	}
+	function genFilterCode(key) {
+	    const keyVal = parseInt(key, 10);
+	    if (keyVal) {
+	        return `$event.keyCode!==${keyVal}`;
+	    }
+	    const keyCode = keyCodes[key];
+	    const keyName = keyNames[key];
+	    return (`_k($event.keyCode,` +
+	        `${JSON.stringify(key)},` +
+	        `${JSON.stringify(keyCode)},` +
+	        `$event.key,` +
+	        `${JSON.stringify(keyName)}` +
+	        `)`);
 	}
-	function parseString(chr) {
-	    const stringQuote = chr;
-	    while (!eof()) {
-	        chr = next();
-	        if (chr === stringQuote) {
-	            break;
-	        }
-	    }
+
+	function on(el, dir) {
+	    if (dir.modifiers) {
+	        warn$2(`v-on without argument does not support modifiers.`);
+	    }
+	    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 	}
 
-	const onRE = /^@|^v-on:/;
-	const dirRE = /^v-|^@|^:|^#/;
-	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-	const stripParensRE = /^\(|\)$/g;
-	const dynamicArgRE = /^\[.*\]$/;
-	const argRE = /:(.*)$/;
-	const bindRE = /^:|^\.|^v-bind:/;
-	const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-	const slotRE = /^v-slot(:|$)|^#/;
-	const lineBreakRE = /[\r\n]/;
-	const whitespaceRE = /[ \f\t\r\n]+/g;
-	const invalidAttributeRE = /[\s"'<>\/=]/;
-	const decodeHTMLCached = cached(he.decode);
-	const emptySlotScopeToken = `_empty_`;
-	// configurable state
-	let warn$1;
-	let delimiters;
-	let transforms;
-	let preTransforms;
-	let postTransforms;
-	let platformIsPreTag;
-	let platformMustUseProp;
-	let platformGetTagNamespace;
-	let maybeComponent;
-	function createASTElement(tag, attrs, parent) {
-	    return {
-	        type: 1,
-	        tag,
-	        attrsList: attrs,
-	        attrsMap: makeAttrsMap(attrs),
-	        rawAttrsMap: {},
-	        parent,
-	        children: [],
-	    };
-	}
-	/**
-	 * Convert HTML string to AST.
-	 */
-	function parse(template, options) {
-	    warn$1 = options.warn || baseWarn;
-	    platformIsPreTag = options.isPreTag || no;
-	    platformMustUseProp = options.mustUseProp || no;
-	    platformGetTagNamespace = options.getTagNamespace || no;
-	    const isReservedTag = options.isReservedTag || no;
-	    maybeComponent = (el) => !!(el.component ||
-	        el.attrsMap[':is'] ||
-	        el.attrsMap['v-bind:is'] ||
-	        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-	    transforms = pluckModuleFunction(options.modules, 'transformNode');
-	    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-	    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-	    delimiters = options.delimiters;
-	    const stack = [];
-	    const preserveWhitespace = options.preserveWhitespace !== false;
-	    const whitespaceOption = options.whitespace;
-	    let root;
-	    let currentParent;
-	    let inVPre = false;
-	    let inPre = false;
-	    let warned = false;
-	    function warnOnce(msg, range) {
-	        if (!warned) {
-	            warned = true;
-	            warn$1(msg, range);
-	        }
-	    }
-	    function closeElement(element) {
-	        trimEndingWhitespace(element);
-	        if (!inVPre && !element.processed) {
-	            element = processElement(element, options);
-	        }
-	        // tree management
-	        if (!stack.length && element !== root) {
-	            // allow root elements with v-if, v-else-if and v-else
-	            if (root.if && (element.elseif || element.else)) {
-	                {
-	                    checkRootConstraints(element);
-	                }
-	                addIfCondition(root, {
-	                    exp: element.elseif,
-	                    block: element,
-	                });
-	            }
-	            else {
-	                warnOnce(`Component template should contain exactly one root element. ` +
-	                    `If you are using v-if on multiple elements, ` +
-	                    `use v-else-if to chain them instead.`, { start: element.start });
-	            }
-	        }
-	        if (currentParent && !element.forbidden) {
-	            if (element.elseif || element.else) {
-	                processIfConditions(element, currentParent);
-	            }
-	            else {
-	                if (element.slotScope) {
-	                    // scoped slot
-	                    // keep it in the children list so that v-else(-if) conditions can
-	                    // find it as the prev node.
-	                    const name = element.slotTarget || '"default"';
-	                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-	                }
-	                currentParent.children.push(element);
-	                element.parent = currentParent;
-	            }
-	        }
-	        // final children cleanup
-	        // filter out scoped slots
-	        element.children = element.children.filter((c) => !c.slotScope);
-	        // remove trailing whitespace node again
-	        trimEndingWhitespace(element);
-	        // check pre state
-	        if (element.pre) {
-	            inVPre = false;
-	        }
-	        if (platformIsPreTag(element.tag)) {
-	            inPre = false;
-	        }
-	        // apply post-transforms
-	        for (let i = 0; i < postTransforms.length; i++) {
-	            postTransforms[i](element, options);
-	        }
-	    }
-	    function trimEndingWhitespace(el) {
-	        // remove trailing whitespace node
-	        if (!inPre) {
-	            let lastNode;
-	            while ((lastNode = el.children[el.children.length - 1]) &&
-	                lastNode.type === 3 &&
-	                lastNode.text === ' ') {
-	                el.children.pop();
-	            }
-	        }
-	    }
-	    function checkRootConstraints(el) {
-	        if (el.tag === 'slot' || el.tag === 'template') {
-	            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-	                'contain multiple nodes.', { start: el.start });
-	        }
-	        if (el.attrsMap.hasOwnProperty('v-for')) {
-	            warnOnce('Cannot use v-for on stateful component root element because ' +
-	                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-	        }
-	    }
-	    parseHTML(template, {
-	        warn: warn$1,
-	        expectHTML: options.expectHTML,
-	        isUnaryTag: options.isUnaryTag,
-	        canBeLeftOpenTag: options.canBeLeftOpenTag,
-	        shouldDecodeNewlines: options.shouldDecodeNewlines,
-	        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-	        shouldKeepComment: options.comments,
-	        outputSourceRange: options.outputSourceRange,
-	        start(tag, attrs, unary, start, end) {
-	            // check namespace.
-	            // inherit parent ns if there is one
-	            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-	            // handle IE svg bug
-	            /* istanbul ignore if */
-	            if (isIE && ns === 'svg') {
-	                attrs = guardIESVGBug(attrs);
-	            }
-	            let element = createASTElement(tag, attrs, currentParent);
-	            if (ns) {
-	                element.ns = ns;
-	            }
-	            {
-	                if (options.outputSourceRange) {
-	                    element.start = start;
-	                    element.end = end;
-	                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-	                        cumulated[attr.name] = attr;
-	                        return cumulated;
-	                    }, {});
-	                }
-	                attrs.forEach((attr) => {
-	                    if (invalidAttributeRE.test(attr.name)) {
-	                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-	                            `spaces, quotes, <, >, / or =.`, {
-	                            start: attr.start + attr.name.indexOf(`[`),
-	                            end: attr.start + attr.name.length,
-	                        });
-	                    }
-	                });
-	            }
-	            if (isForbiddenTag(element) && !isServerRendering()) {
-	                element.forbidden = true;
-	                warn$1('Templates should only be responsible for mapping the state to the ' +
-	                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-	                        `<${tag}>` +
-	                        ', as they will not be parsed.', { start: element.start });
-	            }
-	            // apply pre-transforms
-	            for (let i = 0; i < preTransforms.length; i++) {
-	                element = preTransforms[i](element, options) || element;
-	            }
-	            if (!inVPre) {
-	                processPre(element);
-	                if (element.pre) {
-	                    inVPre = true;
-	                }
-	            }
-	            if (platformIsPreTag(element.tag)) {
-	                inPre = true;
-	            }
-	            if (inVPre) {
-	                processRawAttrs(element);
-	            }
-	            else if (!element.processed) {
-	                // structural directives
-	                processFor(element);
-	                processIf(element);
-	                processOnce(element);
-	            }
-	            if (!root) {
-	                root = element;
-	                {
-	                    checkRootConstraints(root);
-	                }
-	            }
-	            if (!unary) {
-	                currentParent = element;
-	                stack.push(element);
-	            }
-	            else {
-	                closeElement(element);
-	            }
-	        },
-	        end(tag, start, end) {
-	            const element = stack[stack.length - 1];
-	            // pop stack
-	            stack.length -= 1;
-	            currentParent = stack[stack.length - 1];
-	            if (options.outputSourceRange) {
-	                element.end = end;
-	            }
-	            closeElement(element);
-	        },
-	        chars(text, start, end) {
-	            if (!currentParent) {
-	                {
-	                    if (text === template) {
-	                        warnOnce('Component template requires a root element, rather than just text.', { start });
-	                    }
-	                    else if ((text = text.trim())) {
-	                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-	                            start,
-	                        });
-	                    }
-	                }
-	                return;
-	            }
-	            // IE textarea placeholder bug
-	            /* istanbul ignore if */
-	            if (isIE &&
-	                currentParent.tag === 'textarea' &&
-	                currentParent.attrsMap.placeholder === text) {
-	                return;
-	            }
-	            const children = currentParent.children;
-	            if (inPre || text.trim()) {
-	                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-	            }
-	            else if (!children.length) {
-	                // remove the whitespace-only node right after an opening tag
-	                text = '';
-	            }
-	            else if (whitespaceOption) {
-	                if (whitespaceOption === 'condense') {
-	                    // in condense mode, remove the whitespace node if it contains
-	                    // line break, otherwise condense to a single space
-	                    text = lineBreakRE.test(text) ? '' : ' ';
-	                }
-	                else {
-	                    text = ' ';
-	                }
-	            }
-	            else {
-	                text = preserveWhitespace ? ' ' : '';
-	            }
-	            if (text) {
-	                if (!inPre && whitespaceOption === 'condense') {
-	                    // condense consecutive whitespaces into single space
-	                    text = text.replace(whitespaceRE, ' ');
-	                }
-	                let res;
-	                let child;
-	                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-	                    child = {
-	                        type: 2,
-	                        expression: res.expression,
-	                        tokens: res.tokens,
-	                        text,
-	                    };
-	                }
-	                else if (text !== ' ' ||
-	                    !children.length ||
-	                    children[children.length - 1].text !== ' ') {
-	                    child = {
-	                        type: 3,
-	                        text,
-	                    };
-	                }
-	                if (child) {
-	                    if (options.outputSourceRange) {
-	                        child.start = start;
-	                        child.end = end;
-	                    }
-	                    children.push(child);
-	                }
-	            }
-	        },
-	        comment(text, start, end) {
-	            // adding anything as a sibling to the root node is forbidden
-	            // comments should still be allowed, but ignored
-	            if (currentParent) {
-	                const child = {
-	                    type: 3,
-	                    text,
-	                    isComment: true,
-	                };
-	                if (options.outputSourceRange) {
-	                    child.start = start;
-	                    child.end = end;
-	                }
-	                currentParent.children.push(child);
-	            }
-	        },
-	    });
-	    return root;
-	}
-	function processPre(el) {
-	    if (getAndRemoveAttr(el, 'v-pre') != null) {
-	        el.pre = true;
-	    }
-	}
-	function processRawAttrs(el) {
-	    const list = el.attrsList;
-	    const len = list.length;
-	    if (len) {
-	        const attrs = (el.attrs = new Array(len));
-	        for (let i = 0; i < len; i++) {
-	            attrs[i] = {
-	                name: list[i].name,
-	                value: JSON.stringify(list[i].value),
-	            };
-	            if (list[i].start != null) {
-	                attrs[i].start = list[i].start;
-	                attrs[i].end = list[i].end;
-	            }
-	        }
-	    }
-	    else if (!el.pre) {
-	        // non root node in pre blocks with no attributes
-	        el.plain = true;
-	    }
-	}
-	function processElement(element, options) {
-	    processKey(element);
-	    // determine whether this is a plain element after
-	    // removing structural attributes
-	    element.plain =
-	        !element.key && !element.scopedSlots && !element.attrsList.length;
-	    processRef(element);
-	    processSlotContent(element);
-	    processSlotOutlet(element);
-	    processComponent(element);
-	    for (let i = 0; i < transforms.length; i++) {
-	        element = transforms[i](element, options) || element;
-	    }
-	    processAttrs(element);
-	    return element;
-	}
-	function processKey(el) {
-	    const exp = getBindingAttr(el, 'key');
-	    if (exp) {
-	        {
-	            if (el.tag === 'template') {
-	                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-	            }
-	            if (el.for) {
-	                const iterator = el.iterator2 || el.iterator1;
-	                const parent = el.parent;
-	                if (iterator &&
-	                    iterator === exp &&
-	                    parent &&
-	                    parent.tag === 'transition-group') {
-	                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-	                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-	                }
-	            }
-	        }
-	        el.key = exp;
-	    }
-	}
-	function processRef(el) {
-	    const ref = getBindingAttr(el, 'ref');
-	    if (ref) {
-	        el.ref = ref;
-	        el.refInFor = checkInFor(el);
-	    }
-	}
-	function processFor(el) {
-	    let exp;
-	    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-	        const res = parseFor(exp);
-	        if (res) {
-	            extend(el, res);
-	        }
-	        else {
-	            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-	        }
-	    }
-	}
-	function parseFor(exp) {
-	    const inMatch = exp.match(forAliasRE);
-	    if (!inMatch)
-	        return;
-	    const res = {};
-	    res.for = inMatch[2].trim();
-	    const alias = inMatch[1].trim().replace(stripParensRE, '');
-	    const iteratorMatch = alias.match(forIteratorRE);
-	    if (iteratorMatch) {
-	        res.alias = alias.replace(forIteratorRE, '').trim();
-	        res.iterator1 = iteratorMatch[1].trim();
-	        if (iteratorMatch[2]) {
-	            res.iterator2 = iteratorMatch[2].trim();
-	        }
-	    }
-	    else {
-	        res.alias = alias;
-	    }
-	    return res;
-	}
-	function processIf(el) {
-	    const exp = getAndRemoveAttr(el, 'v-if');
-	    if (exp) {
-	        el.if = exp;
-	        addIfCondition(el, {
-	            exp: exp,
-	            block: el,
-	        });
-	    }
-	    else {
-	        if (getAndRemoveAttr(el, 'v-else') != null) {
-	            el.else = true;
-	        }
-	        const elseif = getAndRemoveAttr(el, 'v-else-if');
-	        if (elseif) {
-	            el.elseif = elseif;
-	        }
-	    }
-	}
-	function processIfConditions(el, parent) {
-	    const prev = findPrevElement(parent.children);
-	    if (prev && prev.if) {
-	        addIfCondition(prev, {
-	            exp: el.elseif,
-	            block: el,
-	        });
-	    }
-	    else {
-	        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-	            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-	    }
-	}
-	function findPrevElement(children) {
-	    let i = children.length;
-	    while (i--) {
-	        if (children[i].type === 1) {
-	            return children[i];
-	        }
-	        else {
-	            if (children[i].text !== ' ') {
-	                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-	                    `will be ignored.`, children[i]);
-	            }
-	            children.pop();
-	        }
-	    }
-	}
-	function addIfCondition(el, condition) {
-	    if (!el.ifConditions) {
-	        el.ifConditions = [];
-	    }
-	    el.ifConditions.push(condition);
-	}
-	function processOnce(el) {
-	    const once = getAndRemoveAttr(el, 'v-once');
-	    if (once != null) {
-	        el.once = true;
-	    }
-	}
-	// handle content being passed to a component as slot,
-	// e.g. <template slot="xxx">, <div slot-scope="xxx">
-	function processSlotContent(el) {
-	    let slotScope;
-	    if (el.tag === 'template') {
-	        slotScope = getAndRemoveAttr(el, 'scope');
-	        /* istanbul ignore if */
-	        if (slotScope) {
-	            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-	                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-	                `can also be used on plain elements in addition to <template> to ` +
-	                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-	        }
-	        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-	    }
-	    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-	        /* istanbul ignore if */
-	        if (el.attrsMap['v-for']) {
-	            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-	                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-	                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-	        }
-	        el.slotScope = slotScope;
-	    }
-	    // slot="xxx"
-	    const slotTarget = getBindingAttr(el, 'slot');
-	    if (slotTarget) {
-	        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-	        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-	        // preserve slot as an attribute for native shadow DOM compat
-	        // only for non-scoped slots.
-	        if (el.tag !== 'template' && !el.slotScope) {
-	            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-	        }
-	    }
-	    // 2.6 v-slot syntax
-	    {
-	        if (el.tag === 'template') {
-	            // v-slot on <template>
-	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-	            if (slotBinding) {
-	                {
-	                    if (el.slotTarget || el.slotScope) {
-	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-	                    }
-	                    if (el.parent && !maybeComponent(el.parent)) {
-	                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-	                            `the receiving component`, el);
-	                    }
-	                }
-	                const { name, dynamic } = getSlotName(slotBinding);
-	                el.slotTarget = name;
-	                el.slotTargetDynamic = dynamic;
-	                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-	            }
-	        }
-	        else {
-	            // v-slot on component, denotes default slot
-	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-	            if (slotBinding) {
-	                {
-	                    if (!maybeComponent(el)) {
-	                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-	                    }
-	                    if (el.slotScope || el.slotTarget) {
-	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-	                    }
-	                    if (el.scopedSlots) {
-	                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-	                            `<template> syntax when there are other named slots.`, slotBinding);
-	                    }
-	                }
-	                // add the component's children to its default slot
-	                const slots = el.scopedSlots || (el.scopedSlots = {});
-	                const { name, dynamic } = getSlotName(slotBinding);
-	                const slotContainer = (slots[name] = createASTElement('template', [], el));
-	                slotContainer.slotTarget = name;
-	                slotContainer.slotTargetDynamic = dynamic;
-	                slotContainer.children = el.children.filter((c) => {
-	                    if (!c.slotScope) {
-	                        c.parent = slotContainer;
-	                        return true;
-	                    }
-	                });
-	                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-	                // remove children as they are returned from scopedSlots now
-	                el.children = [];
-	                // mark el non-plain so data gets generated
-	                el.plain = false;
-	            }
-	        }
-	    }
-	}
-	function getSlotName(binding) {
-	    let name = binding.name.replace(slotRE, '');
-	    if (!name) {
-	        if (binding.name[0] !== '#') {
-	            name = 'default';
-	        }
-	        else {
-	            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-	        }
-	    }
-	    return dynamicArgRE.test(name)
-	        ? // dynamic [name]
-	            { name: name.slice(1, -1), dynamic: true }
-	        : // static name
-	            { name: `"${name}"`, dynamic: false };
-	}
-	// handle <slot/> outlets
-	function processSlotOutlet(el) {
-	    if (el.tag === 'slot') {
-	        el.slotName = getBindingAttr(el, 'name');
-	        if (el.key) {
-	            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-	                `and can possibly expand into multiple elements. ` +
-	                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-	        }
-	    }
-	}
-	function processComponent(el) {
-	    let binding;
-	    if ((binding = getBindingAttr(el, 'is'))) {
-	        el.component = binding;
-	    }
-	    if (getAndRemoveAttr(el, 'inline-template') != null) {
-	        el.inlineTemplate = true;
-	    }
-	}
-	function processAttrs(el) {
-	    const list = el.attrsList;
-	    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-	    for (i = 0, l = list.length; i < l; i++) {
-	        name = rawName = list[i].name;
-	        value = list[i].value;
-	        if (dirRE.test(name)) {
-	            // mark element as dynamic
-	            el.hasBindings = true;
-	            // modifiers
-	            modifiers = parseModifiers(name.replace(dirRE, ''));
-	            // support .foo shorthand syntax for the .prop modifier
-	            if (modifiers) {
-	                name = name.replace(modifierRE, '');
-	            }
-	            if (bindRE.test(name)) {
-	                // v-bind
-	                name = name.replace(bindRE, '');
-	                value = parseFilters(value);
-	                isDynamic = dynamicArgRE.test(name);
-	                if (isDynamic) {
-	                    name = name.slice(1, -1);
-	                }
-	                if (value.trim().length === 0) {
-	                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-	                }
-	                if (modifiers) {
-	                    if (modifiers.prop && !isDynamic) {
-	                        name = camelize(name);
-	                        if (name === 'innerHtml')
-	                            name = 'innerHTML';
-	                    }
-	                    if (modifiers.camel && !isDynamic) {
-	                        name = camelize(name);
-	                    }
-	                    if (modifiers.sync) {
-	                        syncGen = genAssignmentCode(value, `$event`);
-	                        if (!isDynamic) {
-	                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-	                            if (hyphenate(name) !== camelize(name)) {
-	                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-	                            }
-	                        }
-	                        else {
-	                            // handler w/ dynamic event name
-	                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-	                            );
-	                        }
-	                    }
-	                }
-	                if ((modifiers && modifiers.prop) ||
-	                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-	                    addProp(el, name, value, list[i], isDynamic);
-	                }
-	                else {
-	                    addAttr(el, name, value, list[i], isDynamic);
-	                }
-	            }
-	            else if (onRE.test(name)) {
-	                // v-on
-	                name = name.replace(onRE, '');
-	                isDynamic = dynamicArgRE.test(name);
-	                if (isDynamic) {
-	                    name = name.slice(1, -1);
-	                }
-	                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-	            }
-	            else {
-	                // normal directives
-	                name = name.replace(dirRE, '');
-	                // parse arg
-	                const argMatch = name.match(argRE);
-	                let arg = argMatch && argMatch[1];
-	                isDynamic = false;
-	                if (arg) {
-	                    name = name.slice(0, -(arg.length + 1));
-	                    if (dynamicArgRE.test(arg)) {
-	                        arg = arg.slice(1, -1);
-	                        isDynamic = true;
-	                    }
-	                }
-	                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-	                if (name === 'model') {
-	                    checkForAliasModel(el, value);
-	                }
-	            }
-	        }
-	        else {
-	            // literal attribute
-	            {
-	                const res = parseText(value, delimiters);
-	                if (res) {
-	                    warn$1(`${name}="${value}": ` +
-	                        'Interpolation inside attributes has been removed. ' +
-	                        'Use v-bind or the colon shorthand instead. For example, ' +
-	                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-	                }
-	            }
-	            addAttr(el, name, JSON.stringify(value), list[i]);
-	            // #6887 firefox doesn't update muted state if set via attribute
-	            // even immediately after element creation
-	            if (!el.component &&
-	                name === 'muted' &&
-	                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-	                addProp(el, name, 'true', list[i]);
-	            }
-	        }
-	    }
-	}
-	function checkInFor(el) {
-	    let parent = el;
-	    while (parent) {
-	        if (parent.for !== undefined) {
-	            return true;
-	        }
-	        parent = parent.parent;
-	    }
-	    return false;
-	}
-	function parseModifiers(name) {
-	    const match = name.match(modifierRE);
-	    if (match) {
-	        const ret = {};
-	        match.forEach((m) => {
-	            ret[m.slice(1)] = true;
-	        });
-	        return ret;
-	    }
-	}
-	function makeAttrsMap(attrs) {
-	    const map = {};
-	    for (let i = 0, l = attrs.length; i < l; i++) {
-	        if (map[attrs[i].name] &&
-	            !isIE &&
-	            !isEdge) {
-	            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-	        }
-	        map[attrs[i].name] = attrs[i].value;
-	    }
-	    return map;
-	}
-	// for script (e.g. type="x/template") or style, do not decode content
-	function isTextTag(el) {
-	    return el.tag === 'script' || el.tag === 'style';
-	}
-	function isForbiddenTag(el) {
-	    return (el.tag === 'style' ||
-	        (el.tag === 'script' &&
-	            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-	}
-	const ieNSBug = /^xmlns:NS\d+/;
-	const ieNSPrefix = /^NS\d+:/;
-	/* istanbul ignore next */
-	function guardIESVGBug(attrs) {
-	    const res = [];
-	    for (let i = 0; i < attrs.length; i++) {
-	        const attr = attrs[i];
-	        if (!ieNSBug.test(attr.name)) {
-	            attr.name = attr.name.replace(ieNSPrefix, '');
-	            res.push(attr);
-	        }
-	    }
-	    return res;
-	}
-	function checkForAliasModel(el, value) {
-	    let _el = el;
-	    while (_el) {
-	        if (_el.for && _el.alias === value) {
-	            warn$1(`<${el.tag} v-model="${value}">: ` +
-	                `You are binding v-model directly to a v-for iteration alias. ` +
-	                `This will not be able to modify the v-for source array because ` +
-	                `writing to the alias is like modifying a function local variable. ` +
-	                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-	        }
-	        _el = _el.parent;
-	    }
-	}
-
-	/**
-	 * Expand input[v-model] with dynamic type bindings into v-if-else chains
-	 * Turn this:
-	 *   <input v-model="data[type]" :type="type">
-	 * into this:
-	 *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-	 *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-	 *   <input v-else :type="type" v-model="data[type]">
-	 */
-	function preTransformNode(el, options) {
-	    if (el.tag === 'input') {
-	        const map = el.attrsMap;
-	        if (!map['v-model']) {
-	            return;
-	        }
-	        let typeBinding;
-	        if (map[':type'] || map['v-bind:type']) {
-	            typeBinding = getBindingAttr(el, 'type');
-	        }
-	        if (!map.type && !typeBinding && map['v-bind']) {
-	            typeBinding = `(${map['v-bind']}).type`;
-	        }
-	        if (typeBinding) {
-	            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-	            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-	            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-	            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-	            // 1. checkbox
-	            const branch0 = cloneASTElement(el);
-	            // process for on the main node
-	            processFor(branch0);
-	            addRawAttr(branch0, 'type', 'checkbox');
-	            processElement(branch0, options);
-	            branch0.processed = true; // prevent it from double-processed
-	            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-	            addIfCondition(branch0, {
-	                exp: branch0.if,
-	                block: branch0,
-	            });
-	            // 2. add radio else-if condition
-	            const branch1 = cloneASTElement(el);
-	            getAndRemoveAttr(branch1, 'v-for', true);
-	            addRawAttr(branch1, 'type', 'radio');
-	            processElement(branch1, options);
-	            addIfCondition(branch0, {
-	                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-	                block: branch1,
-	            });
-	            // 3. other
-	            const branch2 = cloneASTElement(el);
-	            getAndRemoveAttr(branch2, 'v-for', true);
-	            addRawAttr(branch2, ':type', typeBinding);
-	            processElement(branch2, options);
-	            addIfCondition(branch0, {
-	                exp: ifCondition,
-	                block: branch2,
-	            });
-	            if (hasElse) {
-	                branch0.else = true;
-	            }
-	            else if (elseIfCondition) {
-	                branch0.elseif = elseIfCondition;
-	            }
-	            return branch0;
-	        }
-	    }
-	}
-	function cloneASTElement(el) {
-	    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-	}
-	var model$1 = {
-	    preTransformNode,
-	};
-
-	var modules = [klass, style, model$1];
-
-	let warn;
-	// in some cases, the event used has to be determined at runtime
-	// so we used some reserved tokens during compile.
-	const RANGE_TOKEN = '__r';
-	function model(el, dir, _warn) {
-	    warn = _warn;
-	    const value = dir.value;
-	    const modifiers = dir.modifiers;
-	    const tag = el.tag;
-	    const type = el.attrsMap.type;
-	    {
-	        // inputs with type="file" are read only and setting the input's
-	        // value will throw an error.
-	        if (tag === 'input' && type === 'file') {
-	            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-	                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-	        }
-	    }
-	    if (el.component) {
-	        genComponentModel(el, value, modifiers);
-	        // component v-model doesn't need extra runtime
-	        return false;
-	    }
-	    else if (tag === 'select') {
-	        genSelect(el, value, modifiers);
-	    }
-	    else if (tag === 'input' && type === 'checkbox') {
-	        genCheckboxModel(el, value, modifiers);
-	    }
-	    else if (tag === 'input' && type === 'radio') {
-	        genRadioModel(el, value, modifiers);
-	    }
-	    else if (tag === 'input' || tag === 'textarea') {
-	        genDefaultModel(el, value, modifiers);
-	    }
-	    else {
-	        genComponentModel(el, value, modifiers);
-	        // component v-model doesn't need extra runtime
-	        return false;
-	    }
-	    // ensure runtime directive metadata
-	    return true;
-	}
-	function genCheckboxModel(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    const valueBinding = getBindingAttr(el, 'value') || 'null';
-	    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-	    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-	    addProp(el, 'checked', `Array.isArray(${value})` +
-	        `?_i(${value},${valueBinding})>-1` +
-	        (trueValueBinding === 'true'
-	            ? `:(${value})`
-	            : `:_q(${value},${trueValueBinding})`));
-	    addHandler(el, 'change', `var $$a=${value},` +
-	        '$$el=$event.target,' +
-	        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-	        'if(Array.isArray($$a)){' +
-	        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-	        '$$i=_i($$a,$$v);' +
-	        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-	        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-	        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-	}
-	function genRadioModel(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    let valueBinding = getBindingAttr(el, 'value') || 'null';
-	    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-	    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-	    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-	}
-	function genSelect(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    const selectedVal = `Array.prototype.filter` +
-	        `.call($event.target.options,function(o){return o.selected})` +
-	        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-	        `return ${number ? '_n(val)' : 'val'}})`;
-	    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-	    let code = `var $$selectedVal = ${selectedVal};`;
-	    code = `${code} ${genAssignmentCode(value, assignment)}`;
-	    addHandler(el, 'change', code, null, true);
-	}
-	function genDefaultModel(el, value, modifiers) {
-	    const type = el.attrsMap.type;
-	    // warn if v-bind:value conflicts with v-model
-	    // except for inputs with v-bind:type
-	    {
-	        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-	        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-	        if (value && !typeBinding) {
-	            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-	            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-	                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-	        }
-	    }
-	    const { lazy, number, trim } = modifiers || {};
-	    const needCompositionGuard = !lazy && type !== 'range';
-	    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-	    let valueExpression = '$event.target.value';
-	    if (trim) {
-	        valueExpression = `$event.target.value.trim()`;
-	    }
-	    if (number) {
-	        valueExpression = `_n(${valueExpression})`;
-	    }
-	    let code = genAssignmentCode(value, valueExpression);
-	    if (needCompositionGuard) {
-	        code = `if($event.target.composing)return;${code}`;
-	    }
-	    addProp(el, 'value', `(${value})`);
-	    addHandler(el, event, code, null, true);
-	    if (trim || number) {
-	        addHandler(el, 'blur', '$forceUpdate()');
-	    }
-	}
-
-	function text(el, dir) {
-	    if (dir.value) {
-	        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-	    }
-	}
-
-	function html(el, dir) {
-	    if (dir.value) {
-	        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-	    }
+	function bind(el, dir) {
+	    el.wrapData = (code) => {
+	        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+	    };
 	}
 
-	var directives = {
-	    model,
-	    text,
-	    html,
+	var baseDirectives = {
+	    on,
+	    bind,
+	    cloak: noop,
 	};
 
-	const baseOptions = {
-	    expectHTML: true,
-	    modules,
-	    directives,
-	    isPreTag,
-	    isUnaryTag,
-	    mustUseProp,
-	    canBeLeftOpenTag,
-	    isReservedTag,
-	    getTagNamespace,
-	    staticKeys: genStaticKeys$1(modules),
-	};
-
-	let isStaticKey;
-	let isPlatformReservedTag$1;
-	const genStaticKeysCached = cached(genStaticKeys);
-	/**
-	 * Goal of the optimizer: walk the generated template AST tree
-	 * and detect sub-trees that are purely static, i.e. parts of
-	 * the DOM that never needs to change.
-	 *
-	 * Once we detect these sub-trees, we can:
-	 *
-	 * 1. Hoist them into constants, so that we no longer need to
-	 *    create fresh nodes for them on each re-render;
-	 * 2. Completely skip them in the patching process.
-	 */
-	function optimize$1(root, options) {
-	    if (!root)
-	        return;
-	    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-	    isPlatformReservedTag$1 = options.isReservedTag || no;
-	    // first pass: mark all non-static nodes.
-	    markStatic(root);
-	    // second pass: mark static roots.
-	    markStaticRoots(root, false);
-	}
-	function genStaticKeys(keys) {
-	    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-	        (keys ? ',' + keys : ''));
-	}
-	function markStatic(node) {
-	    node.static = isStatic(node);
-	    if (node.type === 1) {
-	        // do not make component slot content static. this avoids
-	        // 1. components not able to mutate slot nodes
-	        // 2. static slot content fails for hot-reloading
-	        if (!isPlatformReservedTag$1(node.tag) &&
-	            node.tag !== 'slot' &&
-	            node.attrsMap['inline-template'] == null) {
-	            return;
-	        }
-	        for (let i = 0, l = node.children.length; i < l; i++) {
-	            const child = node.children[i];
-	            markStatic(child);
-	            if (!child.static) {
-	                node.static = false;
-	            }
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                const block = node.ifConditions[i].block;
-	                markStatic(block);
-	                if (!block.static) {
-	                    node.static = false;
-	                }
-	            }
-	        }
-	    }
-	}
-	function markStaticRoots(node, isInFor) {
-	    if (node.type === 1) {
-	        if (node.static || node.once) {
-	            node.staticInFor = isInFor;
-	        }
-	        // For a node to qualify as a static root, it should have children that
-	        // are not just static text. Otherwise the cost of hoisting out will
-	        // outweigh the benefits and it's better off to just always render it fresh.
-	        if (node.static &&
-	            node.children.length &&
-	            !(node.children.length === 1 && node.children[0].type === 3)) {
-	            node.staticRoot = true;
-	            return;
-	        }
-	        else {
-	            node.staticRoot = false;
-	        }
-	        if (node.children) {
-	            for (let i = 0, l = node.children.length; i < l; i++) {
-	                markStaticRoots(node.children[i], isInFor || !!node.for);
-	            }
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                markStaticRoots(node.ifConditions[i].block, isInFor);
-	            }
-	        }
-	    }
-	}
-	function isStatic(node) {
-	    if (node.type === 2) {
-	        // expression
-	        return false;
-	    }
-	    if (node.type === 3) {
-	        // text
-	        return true;
-	    }
-	    return !!(node.pre ||
-	        (!node.hasBindings && // no dynamic bindings
-	            !node.if &&
-	            !node.for && // not v-if or v-for or v-else
-	            !isBuiltInTag(node.tag) && // not a built-in
-	            isPlatformReservedTag$1(node.tag) && // not a component
-	            !isDirectChildOfTemplateFor(node) &&
-	            Object.keys(node).every(isStaticKey)));
-	}
-	function isDirectChildOfTemplateFor(node) {
-	    while (node.parent) {
-	        node = node.parent;
-	        if (node.tag !== 'template') {
-	            return false;
-	        }
-	        if (node.for) {
-	            return true;
-	        }
-	    }
-	    return false;
-	}
-
-	const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-	const fnInvokeRE = /\([^)]*?\);*$/;
-	const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-	// KeyboardEvent.keyCode aliases
-	const keyCodes = {
-	    esc: 27,
-	    tab: 9,
-	    enter: 13,
-	    space: 32,
-	    up: 38,
-	    left: 37,
-	    right: 39,
-	    down: 40,
-	    delete: [8, 46],
-	};
-	// KeyboardEvent.key aliases
-	const keyNames = {
-	    // #7880: IE11 and Edge use `Esc` for Escape key name.
-	    esc: ['Esc', 'Escape'],
-	    tab: 'Tab',
-	    enter: 'Enter',
-	    // #9112: IE11 uses `Spacebar` for Space key name.
-	    space: [' ', 'Spacebar'],
-	    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-	    up: ['Up', 'ArrowUp'],
-	    left: ['Left', 'ArrowLeft'],
-	    right: ['Right', 'ArrowRight'],
-	    down: ['Down', 'ArrowDown'],
-	    // #9112: IE11 uses `Del` for Delete key name.
-	    delete: ['Backspace', 'Delete', 'Del'],
-	};
-	// #4868: modifiers that prevent the execution of the listener
-	// need to explicitly return null so that we can determine whether to remove
-	// the listener for .once
-	const genGuard = (condition) => `if(${condition})return null;`;
-	const modifierCode = {
-	    stop: '$event.stopPropagation();',
-	    prevent: '$event.preventDefault();',
-	    self: genGuard(`$event.target !== $event.currentTarget`),
-	    ctrl: genGuard(`!$event.ctrlKey`),
-	    shift: genGuard(`!$event.shiftKey`),
-	    alt: genGuard(`!$event.altKey`),
-	    meta: genGuard(`!$event.metaKey`),
-	    left: genGuard(`'button' in $event && $event.button !== 0`),
-	    middle: genGuard(`'button' in $event && $event.button !== 1`),
-	    right: genGuard(`'button' in $event && $event.button !== 2`),
-	};
-	function genHandlers(events, isNative) {
-	    const prefix = isNative ? 'nativeOn:' : 'on:';
-	    let staticHandlers = ``;
-	    let dynamicHandlers = ``;
-	    for (const name in events) {
-	        const handlerCode = genHandler(events[name]);
-	        //@ts-expect-error
-	        if (events[name] && events[name].dynamic) {
-	            dynamicHandlers += `${name},${handlerCode},`;
-	        }
-	        else {
-	            staticHandlers += `"${name}":${handlerCode},`;
-	        }
-	    }
-	    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-	    if (dynamicHandlers) {
-	        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-	    }
-	    else {
-	        return prefix + staticHandlers;
-	    }
-	}
-	function genHandler(handler) {
-	    if (!handler) {
-	        return 'function(){}';
-	    }
-	    if (Array.isArray(handler)) {
-	        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-	    }
-	    const isMethodPath = simplePathRE.test(handler.value);
-	    const isFunctionExpression = fnExpRE.test(handler.value);
-	    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-	    if (!handler.modifiers) {
-	        if (isMethodPath || isFunctionExpression) {
-	            return handler.value;
-	        }
-	        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-	    }
-	    else {
-	        let code = '';
-	        let genModifierCode = '';
-	        const keys = [];
-	        for (const key in handler.modifiers) {
-	            if (modifierCode[key]) {
-	                genModifierCode += modifierCode[key];
-	                // left/right
-	                if (keyCodes[key]) {
-	                    keys.push(key);
-	                }
-	            }
-	            else if (key === 'exact') {
-	                const modifiers = handler.modifiers;
-	                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-	                    .filter((keyModifier) => !modifiers[keyModifier])
-	                    .map((keyModifier) => `$event.${keyModifier}Key`)
-	                    .join('||'));
-	            }
-	            else {
-	                keys.push(key);
-	            }
-	        }
-	        if (keys.length) {
-	            code += genKeyFilter(keys);
-	        }
-	        // Make sure modifiers like prevent and stop get executed after key filtering
-	        if (genModifierCode) {
-	            code += genModifierCode;
-	        }
-	        const handlerCode = isMethodPath
-	            ? `return ${handler.value}.apply(null, arguments)`
-	            : isFunctionExpression
-	                ? `return (${handler.value}).apply(null, arguments)`
-	                : isFunctionInvocation
-	                    ? `return ${handler.value}`
-	                    : handler.value;
-	        return `function($event){${code}${handlerCode}}`;
-	    }
-	}
-	function genKeyFilter(keys) {
-	    return (
-	    // make sure the key filters only apply to KeyboardEvents
-	    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-	    // key events that do not have keyCode property...
-	    `if(!$event.type.indexOf('key')&&` +
-	        `${keys.map(genFilterCode).join('&&')})return null;`);
-	}
-	function genFilterCode(key) {
-	    const keyVal = parseInt(key, 10);
-	    if (keyVal) {
-	        return `$event.keyCode!==${keyVal}`;
-	    }
-	    const keyCode = keyCodes[key];
-	    const keyName = keyNames[key];
-	    return (`_k($event.keyCode,` +
-	        `${JSON.stringify(key)},` +
-	        `${JSON.stringify(keyCode)},` +
-	        `$event.key,` +
-	        `${JSON.stringify(keyName)}` +
-	        `)`);
-	}
-
-	function on(el, dir) {
-	    if (dir.modifiers) {
-	        warn$2(`v-on without argument does not support modifiers.`);
-	    }
-	    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-	}
-
-	function bind(el, dir) {
-	    el.wrapData = (code) => {
-	        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-	    };
-	}
-
-	var baseDirectives = {
-	    on,
-	    bind,
-	    cloak: noop,
-	};
-
-	class CodegenState {
-	    options;
-	    warn;
-	    transforms;
-	    dataGenFns;
-	    directives;
-	    maybeComponent;
-	    onceId;
-	    staticRenderFns;
-	    pre;
-	    constructor(options) {
-	        this.options = options;
-	        this.warn = options.warn || baseWarn;
-	        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-	        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-	        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-	        this.directives = extend(extend({}, baseDirectives), options.directives);
-	        const isReservedTag = options.isReservedTag || no;
-	        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-	        this.onceId = 0;
-	        this.staticRenderFns = [];
-	        this.pre = false;
-	    }
-	}
-	function generate$1(ast, options) {
-	    const state = new CodegenState(options);
-	    // fix #11483, Root level <script> tags should not be rendered.
-	    const code = ast
-	        ? ast.tag === 'script'
-	            ? 'null'
-	            : genElement(ast, state)
-	        : '_c("div")';
-	    return {
-	        render: `with(this){return ${code}}`,
-	        staticRenderFns: state.staticRenderFns,
-	    };
-	}
-	function genElement(el, state) {
-	    if (el.parent) {
-	        el.pre = el.pre || el.parent.pre;
-	    }
-	    if (el.staticRoot && !el.staticProcessed) {
-	        return genStatic(el, state);
-	    }
-	    else if (el.once && !el.onceProcessed) {
-	        return genOnce(el, state);
-	    }
-	    else if (el.for && !el.forProcessed) {
-	        return genFor(el, state);
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        return genIf(el, state);
-	    }
-	    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-	        return genChildren(el, state) || 'void 0';
-	    }
-	    else if (el.tag === 'slot') {
-	        return genSlot(el, state);
-	    }
-	    else {
-	        // component or element
-	        let code;
-	        if (el.component) {
-	            code = genComponent(el.component, el, state);
-	        }
-	        else {
-	            let data;
-	            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-	                data = genData(el, state);
-	            }
-	            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-	            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-	        }
-	        // module transforms
-	        for (let i = 0; i < state.transforms.length; i++) {
-	            code = state.transforms[i](el, code);
-	        }
-	        return code;
-	    }
-	}
-	// hoist static sub-trees out
-	function genStatic(el, state) {
-	    el.staticProcessed = true;
-	    // Some elements (templates) need to behave differently inside of a v-pre
-	    // node.  All pre nodes are static roots, so we can use this as a location to
-	    // wrap a state change and reset it upon exiting the pre node.
-	    const originalPreState = state.pre;
-	    if (el.pre) {
-	        state.pre = el.pre;
-	    }
-	    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-	    state.pre = originalPreState;
-	    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-	}
-	// v-once
-	function genOnce(el, state) {
-	    el.onceProcessed = true;
-	    if (el.if && !el.ifProcessed) {
-	        return genIf(el, state);
-	    }
-	    else if (el.staticInFor) {
-	        let key = '';
-	        let parent = el.parent;
-	        while (parent) {
-	            if (parent.for) {
-	                key = parent.key;
-	                break;
-	            }
-	            parent = parent.parent;
-	        }
-	        if (!key) {
-	            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-	            return genElement(el, state);
-	        }
-	        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-	    }
-	    else {
-	        return genStatic(el, state);
-	    }
-	}
-	function genIf(el, state, altGen, altEmpty) {
-	    el.ifProcessed = true; // avoid recursion
-	    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-	}
-	function genIfConditions(conditions, state, altGen, altEmpty) {
-	    if (!conditions.length) {
-	        return altEmpty || '_e()';
-	    }
-	    const condition = conditions.shift();
-	    if (condition.exp) {
-	        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-	    }
-	    else {
-	        return `${genTernaryExp(condition.block)}`;
-	    }
-	    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-	    function genTernaryExp(el) {
-	        return altGen
-	            ? altGen(el, state)
-	            : el.once
-	                ? genOnce(el, state)
-	                : genElement(el, state);
-	    }
-	}
-	function genFor(el, state, altGen, altHelper) {
-	    const exp = el.for;
-	    const alias = el.alias;
-	    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-	    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-	    if (state.maybeComponent(el) &&
-	        el.tag !== 'slot' &&
-	        el.tag !== 'template' &&
-	        !el.key) {
-	        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-	            `v-for should have explicit keys. ` +
-	            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-	    }
-	    el.forProcessed = true; // avoid recursion
-	    return (`${altHelper || '_l'}((${exp}),` +
-	        `function(${alias}${iterator1}${iterator2}){` +
-	        `return ${(altGen || genElement)(el, state)}` +
-	        '})');
-	}
-	function genData(el, state) {
-	    let data = '{';
-	    // directives first.
-	    // directives may mutate the el's other properties before they are generated.
-	    const dirs = genDirectives(el, state);
-	    if (dirs)
-	        data += dirs + ',';
-	    // key
-	    if (el.key) {
-	        data += `key:${el.key},`;
-	    }
-	    // ref
-	    if (el.ref) {
-	        data += `ref:${el.ref},`;
-	    }
-	    if (el.refInFor) {
-	        data += `refInFor:true,`;
-	    }
-	    // pre
-	    if (el.pre) {
-	        data += `pre:true,`;
-	    }
-	    // record original tag name for components using "is" attribute
-	    if (el.component) {
-	        data += `tag:"${el.tag}",`;
-	    }
-	    // module data generation functions
-	    for (let i = 0; i < state.dataGenFns.length; i++) {
-	        data += state.dataGenFns[i](el);
-	    }
-	    // attributes
-	    if (el.attrs) {
-	        data += `attrs:${genProps(el.attrs)},`;
-	    }
-	    // DOM props
-	    if (el.props) {
-	        data += `domProps:${genProps(el.props)},`;
-	    }
-	    // event handlers
-	    if (el.events) {
-	        data += `${genHandlers(el.events, false)},`;
-	    }
-	    if (el.nativeEvents) {
-	        data += `${genHandlers(el.nativeEvents, true)},`;
-	    }
-	    // slot target
-	    // only for non-scoped slots
-	    if (el.slotTarget && !el.slotScope) {
-	        data += `slot:${el.slotTarget},`;
-	    }
-	    // scoped slots
-	    if (el.scopedSlots) {
-	        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-	    }
-	    // component v-model
-	    if (el.model) {
-	        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-	    }
-	    // inline-template
-	    if (el.inlineTemplate) {
-	        const inlineTemplate = genInlineTemplate(el, state);
-	        if (inlineTemplate) {
-	            data += `${inlineTemplate},`;
-	        }
-	    }
-	    data = data.replace(/,$/, '') + '}';
-	    // v-bind dynamic argument wrap
-	    // v-bind with dynamic arguments must be applied using the same v-bind object
-	    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-	    if (el.dynamicAttrs) {
-	        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-	    }
-	    // v-bind data wrap
-	    if (el.wrapData) {
-	        data = el.wrapData(data);
-	    }
-	    // v-on data wrap
-	    if (el.wrapListeners) {
-	        data = el.wrapListeners(data);
-	    }
-	    return data;
-	}
-	function genDirectives(el, state) {
-	    const dirs = el.directives;
-	    if (!dirs)
-	        return;
-	    let res = 'directives:[';
-	    let hasRuntime = false;
-	    let i, l, dir, needRuntime;
-	    for (i = 0, l = dirs.length; i < l; i++) {
-	        dir = dirs[i];
-	        needRuntime = true;
-	        const gen = state.directives[dir.name];
-	        if (gen) {
-	            // compile-time directive that manipulates AST.
-	            // returns true if it also needs a runtime counterpart.
-	            needRuntime = !!gen(el, dir, state.warn);
-	        }
-	        if (needRuntime) {
-	            hasRuntime = true;
-	            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-	        }
-	    }
-	    if (hasRuntime) {
-	        return res.slice(0, -1) + ']';
-	    }
-	}
-	function genInlineTemplate(el, state) {
-	    const ast = el.children[0];
-	    if ((el.children.length !== 1 || ast.type !== 1)) {
-	        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-	    }
-	    if (ast && ast.type === 1) {
-	        const inlineRenderFns = generate$1(ast, state.options);
-	        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-	    }
-	}
-	function genScopedSlots(el, slots, state) {
-	    // by default scoped slots are considered "stable", this allows child
-	    // components with only scoped slots to skip forced updates from parent.
-	    // but in some cases we have to bail-out of this optimization
-	    // for example if the slot contains dynamic names, has v-if or v-for on them...
-	    let needsForceUpdate = el.for ||
-	        Object.keys(slots).some((key) => {
-	            const slot = slots[key];
-	            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-	            );
-	        });
-	    // #9534: if a component with scoped slots is inside a conditional branch,
-	    // it's possible for the same component to be reused but with different
-	    // compiled slot content. To avoid that, we generate a unique key based on
-	    // the generated code of all the slot contents.
-	    let needsKey = !!el.if;
-	    // OR when it is inside another scoped slot or v-for (the reactivity may be
-	    // disconnected due to the intermediate scope variable)
-	    // #9438, #9506
-	    // TODO: this can be further optimized by properly analyzing in-scope bindings
-	    // and skip force updating ones that do not actually use scope variables.
-	    if (!needsForceUpdate) {
-	        let parent = el.parent;
-	        while (parent) {
-	            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-	                parent.for) {
-	                needsForceUpdate = true;
-	                break;
-	            }
-	            if (parent.if) {
-	                needsKey = true;
-	            }
-	            parent = parent.parent;
-	        }
-	    }
-	    const generatedSlots = Object.keys(slots)
-	        .map((key) => genScopedSlot(slots[key], state))
-	        .join(',');
-	    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-	}
-	function hash(str) {
-	    let hash = 5381;
-	    let i = str.length;
-	    while (i) {
-	        hash = (hash * 33) ^ str.charCodeAt(--i);
-	    }
-	    return hash >>> 0;
-	}
-	function containsSlotChild(el) {
-	    if (el.type === 1) {
-	        if (el.tag === 'slot') {
-	            return true;
-	        }
-	        return el.children.some(containsSlotChild);
-	    }
-	    return false;
-	}
-	function genScopedSlot(el, state) {
-	    const isLegacySyntax = el.attrsMap['slot-scope'];
-	    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-	        return genIf(el, state, genScopedSlot, `null`);
-	    }
-	    if (el.for && !el.forProcessed) {
-	        return genFor(el, state, genScopedSlot);
-	    }
-	    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-	    const fn = `function(${slotScope}){` +
-	        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-	    // reverse proxy v-slot without scope on this.$slots
-	    const reverseProxy = slotScope ? `` : `,proxy:true`;
-	    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-	}
-	function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-	    const children = el.children;
-	    if (children.length) {
-	        const el = children[0];
-	        // optimize single v-for
-	        if (children.length === 1 &&
-	            el.for &&
-	            el.tag !== 'template' &&
-	            el.tag !== 'slot') {
-	            const normalizationType = checkSkip
-	                ? state.maybeComponent(el)
-	                    ? `,1`
-	                    : `,0`
-	                : ``;
-	            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-	        }
-	        const normalizationType = checkSkip
-	            ? getNormalizationType(children, state.maybeComponent)
-	            : 0;
-	        const gen = altGenNode || genNode;
-	        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-	    }
-	}
-	// determine the normalization needed for the children array.
-	// 0: no normalization needed
-	// 1: simple normalization needed (possible 1-level deep nested array)
-	// 2: full normalization needed
-	function getNormalizationType(children, maybeComponent) {
-	    let res = 0;
-	    for (let i = 0; i < children.length; i++) {
-	        const el = children[i];
-	        if (el.type !== 1) {
-	            continue;
-	        }
-	        if (needsNormalization(el) ||
-	            (el.ifConditions &&
-	                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-	            res = 2;
-	            break;
-	        }
-	        if (maybeComponent(el) ||
-	            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-	            res = 1;
-	        }
-	    }
-	    return res;
-	}
-	function needsNormalization(el) {
-	    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-	}
-	function genNode(node, state) {
-	    if (node.type === 1) {
-	        return genElement(node, state);
-	    }
-	    else if (node.type === 3 && node.isComment) {
-	        return genComment(node);
-	    }
-	    else {
-	        return genText(node);
-	    }
-	}
-	function genText(text) {
-	    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-	}
-	function genComment(comment) {
-	    return `_e(${JSON.stringify(comment.text)})`;
-	}
-	function genSlot(el, state) {
-	    const slotName = el.slotName || '"default"';
-	    const children = genChildren(el, state);
-	    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-	    const attrs = el.attrs || el.dynamicAttrs
-	        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-	            // slot props are camelized
-	            name: camelize(attr.name),
-	            value: attr.value,
-	            dynamic: attr.dynamic
-	        })))
-	        : null;
-	    const bind = el.attrsMap['v-bind'];
-	    if ((attrs || bind) && !children) {
-	        res += `,null`;
-	    }
-	    if (attrs) {
-	        res += `,${attrs}`;
-	    }
-	    if (bind) {
-	        res += `${attrs ? '' : ',null'},${bind}`;
-	    }
-	    return res + ')';
-	}
-	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-	function genComponent(componentName, el, state) {
-	    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-	    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-	}
-	function genProps(props) {
-	    let staticProps = ``;
-	    let dynamicProps = ``;
-	    for (let i = 0; i < props.length; i++) {
-	        const prop = props[i];
-	        const value = transformSpecialNewlines(prop.value);
-	        if (prop.dynamic) {
-	            dynamicProps += `${prop.name},${value},`;
-	        }
-	        else {
-	            staticProps += `"${prop.name}":${value},`;
-	        }
-	    }
-	    staticProps = `{${staticProps.slice(0, -1)}}`;
-	    if (dynamicProps) {
-	        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-	    }
-	    else {
-	        return staticProps;
-	    }
-	}
-	// #3895, #4268
-	function transformSpecialNewlines(text) {
-	    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+	class CodegenState {
+	    options;
+	    warn;
+	    transforms;
+	    dataGenFns;
+	    directives;
+	    maybeComponent;
+	    onceId;
+	    staticRenderFns;
+	    pre;
+	    constructor(options) {
+	        this.options = options;
+	        this.warn = options.warn || baseWarn;
+	        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+	        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+	        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+	        this.directives = extend(extend({}, baseDirectives), options.directives);
+	        const isReservedTag = options.isReservedTag || no;
+	        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+	        this.onceId = 0;
+	        this.staticRenderFns = [];
+	        this.pre = false;
+	    }
+	}
+	function generate$1(ast, options) {
+	    const state = new CodegenState(options);
+	    // fix #11483, Root level <script> tags should not be rendered.
+	    const code = ast
+	        ? ast.tag === 'script'
+	            ? 'null'
+	            : genElement(ast, state)
+	        : '_c("div")';
+	    return {
+	        render: `with(this){return ${code}}`,
+	        staticRenderFns: state.staticRenderFns,
+	    };
+	}
+	function genElement(el, state) {
+	    if (el.parent) {
+	        el.pre = el.pre || el.parent.pre;
+	    }
+	    if (el.staticRoot && !el.staticProcessed) {
+	        return genStatic(el, state);
+	    }
+	    else if (el.once && !el.onceProcessed) {
+	        return genOnce(el, state);
+	    }
+	    else if (el.for && !el.forProcessed) {
+	        return genFor(el, state);
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        return genIf(el, state);
+	    }
+	    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+	        return genChildren(el, state) || 'void 0';
+	    }
+	    else if (el.tag === 'slot') {
+	        return genSlot(el, state);
+	    }
+	    else {
+	        // component or element
+	        let code;
+	        if (el.component) {
+	            code = genComponent(el.component, el, state);
+	        }
+	        else {
+	            let data;
+	            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+	                data = genData(el, state);
+	            }
+	            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+	            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+	        }
+	        // module transforms
+	        for (let i = 0; i < state.transforms.length; i++) {
+	            code = state.transforms[i](el, code);
+	        }
+	        return code;
+	    }
+	}
+	// hoist static sub-trees out
+	function genStatic(el, state) {
+	    el.staticProcessed = true;
+	    // Some elements (templates) need to behave differently inside of a v-pre
+	    // node.  All pre nodes are static roots, so we can use this as a location to
+	    // wrap a state change and reset it upon exiting the pre node.
+	    const originalPreState = state.pre;
+	    if (el.pre) {
+	        state.pre = el.pre;
+	    }
+	    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+	    state.pre = originalPreState;
+	    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+	}
+	// v-once
+	function genOnce(el, state) {
+	    el.onceProcessed = true;
+	    if (el.if && !el.ifProcessed) {
+	        return genIf(el, state);
+	    }
+	    else if (el.staticInFor) {
+	        let key = '';
+	        let parent = el.parent;
+	        while (parent) {
+	            if (parent.for) {
+	                key = parent.key;
+	                break;
+	            }
+	            parent = parent.parent;
+	        }
+	        if (!key) {
+	            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+	            return genElement(el, state);
+	        }
+	        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+	    }
+	    else {
+	        return genStatic(el, state);
+	    }
+	}
+	function genIf(el, state, altGen, altEmpty) {
+	    el.ifProcessed = true; // avoid recursion
+	    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+	}
+	function genIfConditions(conditions, state, altGen, altEmpty) {
+	    if (!conditions.length) {
+	        return altEmpty || '_e()';
+	    }
+	    const condition = conditions.shift();
+	    if (condition.exp) {
+	        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+	    }
+	    else {
+	        return `${genTernaryExp(condition.block)}`;
+	    }
+	    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+	    function genTernaryExp(el) {
+	        return altGen
+	            ? altGen(el, state)
+	            : el.once
+	                ? genOnce(el, state)
+	                : genElement(el, state);
+	    }
+	}
+	function genFor(el, state, altGen, altHelper) {
+	    const exp = el.for;
+	    const alias = el.alias;
+	    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+	    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+	    if (state.maybeComponent(el) &&
+	        el.tag !== 'slot' &&
+	        el.tag !== 'template' &&
+	        !el.key) {
+	        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+	            `v-for should have explicit keys. ` +
+	            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+	    }
+	    el.forProcessed = true; // avoid recursion
+	    return (`${altHelper || '_l'}((${exp}),` +
+	        `function(${alias}${iterator1}${iterator2}){` +
+	        `return ${(altGen || genElement)(el, state)}` +
+	        '})');
+	}
+	function genData(el, state) {
+	    let data = '{';
+	    // directives first.
+	    // directives may mutate the el's other properties before they are generated.
+	    const dirs = genDirectives(el, state);
+	    if (dirs)
+	        data += dirs + ',';
+	    // key
+	    if (el.key) {
+	        data += `key:${el.key},`;
+	    }
+	    // ref
+	    if (el.ref) {
+	        data += `ref:${el.ref},`;
+	    }
+	    if (el.refInFor) {
+	        data += `refInFor:true,`;
+	    }
+	    // pre
+	    if (el.pre) {
+	        data += `pre:true,`;
+	    }
+	    // record original tag name for components using "is" attribute
+	    if (el.component) {
+	        data += `tag:"${el.tag}",`;
+	    }
+	    // module data generation functions
+	    for (let i = 0; i < state.dataGenFns.length; i++) {
+	        data += state.dataGenFns[i](el);
+	    }
+	    // attributes
+	    if (el.attrs) {
+	        data += `attrs:${genProps(el.attrs)},`;
+	    }
+	    // DOM props
+	    if (el.props) {
+	        data += `domProps:${genProps(el.props)},`;
+	    }
+	    // event handlers
+	    if (el.events) {
+	        data += `${genHandlers(el.events, false)},`;
+	    }
+	    if (el.nativeEvents) {
+	        data += `${genHandlers(el.nativeEvents, true)},`;
+	    }
+	    // slot target
+	    // only for non-scoped slots
+	    if (el.slotTarget && !el.slotScope) {
+	        data += `slot:${el.slotTarget},`;
+	    }
+	    // scoped slots
+	    if (el.scopedSlots) {
+	        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+	    }
+	    // component v-model
+	    if (el.model) {
+	        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+	    }
+	    // inline-template
+	    if (el.inlineTemplate) {
+	        const inlineTemplate = genInlineTemplate(el, state);
+	        if (inlineTemplate) {
+	            data += `${inlineTemplate},`;
+	        }
+	    }
+	    data = data.replace(/,$/, '') + '}';
+	    // v-bind dynamic argument wrap
+	    // v-bind with dynamic arguments must be applied using the same v-bind object
+	    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+	    if (el.dynamicAttrs) {
+	        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+	    }
+	    // v-bind data wrap
+	    if (el.wrapData) {
+	        data = el.wrapData(data);
+	    }
+	    // v-on data wrap
+	    if (el.wrapListeners) {
+	        data = el.wrapListeners(data);
+	    }
+	    return data;
+	}
+	function genDirectives(el, state) {
+	    const dirs = el.directives;
+	    if (!dirs)
+	        return;
+	    let res = 'directives:[';
+	    let hasRuntime = false;
+	    let i, l, dir, needRuntime;
+	    for (i = 0, l = dirs.length; i < l; i++) {
+	        dir = dirs[i];
+	        needRuntime = true;
+	        const gen = state.directives[dir.name];
+	        if (gen) {
+	            // compile-time directive that manipulates AST.
+	            // returns true if it also needs a runtime counterpart.
+	            needRuntime = !!gen(el, dir, state.warn);
+	        }
+	        if (needRuntime) {
+	            hasRuntime = true;
+	            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+	        }
+	    }
+	    if (hasRuntime) {
+	        return res.slice(0, -1) + ']';
+	    }
+	}
+	function genInlineTemplate(el, state) {
+	    const ast = el.children[0];
+	    if ((el.children.length !== 1 || ast.type !== 1)) {
+	        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+	    }
+	    if (ast && ast.type === 1) {
+	        const inlineRenderFns = generate$1(ast, state.options);
+	        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+	    }
+	}
+	function genScopedSlots(el, slots, state) {
+	    // by default scoped slots are considered "stable", this allows child
+	    // components with only scoped slots to skip forced updates from parent.
+	    // but in some cases we have to bail-out of this optimization
+	    // for example if the slot contains dynamic names, has v-if or v-for on them...
+	    let needsForceUpdate = el.for ||
+	        Object.keys(slots).some((key) => {
+	            const slot = slots[key];
+	            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+	            );
+	        });
+	    // #9534: if a component with scoped slots is inside a conditional branch,
+	    // it's possible for the same component to be reused but with different
+	    // compiled slot content. To avoid that, we generate a unique key based on
+	    // the generated code of all the slot contents.
+	    let needsKey = !!el.if;
+	    // OR when it is inside another scoped slot or v-for (the reactivity may be
+	    // disconnected due to the intermediate scope variable)
+	    // #9438, #9506
+	    // TODO: this can be further optimized by properly analyzing in-scope bindings
+	    // and skip force updating ones that do not actually use scope variables.
+	    if (!needsForceUpdate) {
+	        let parent = el.parent;
+	        while (parent) {
+	            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+	                parent.for) {
+	                needsForceUpdate = true;
+	                break;
+	            }
+	            if (parent.if) {
+	                needsKey = true;
+	            }
+	            parent = parent.parent;
+	        }
+	    }
+	    const generatedSlots = Object.keys(slots)
+	        .map((key) => genScopedSlot(slots[key], state))
+	        .join(',');
+	    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+	}
+	function hash(str) {
+	    let hash = 5381;
+	    let i = str.length;
+	    while (i) {
+	        hash = (hash * 33) ^ str.charCodeAt(--i);
+	    }
+	    return hash >>> 0;
+	}
+	function containsSlotChild(el) {
+	    if (el.type === 1) {
+	        if (el.tag === 'slot') {
+	            return true;
+	        }
+	        return el.children.some(containsSlotChild);
+	    }
+	    return false;
+	}
+	function genScopedSlot(el, state) {
+	    const isLegacySyntax = el.attrsMap['slot-scope'];
+	    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+	        return genIf(el, state, genScopedSlot, `null`);
+	    }
+	    if (el.for && !el.forProcessed) {
+	        return genFor(el, state, genScopedSlot);
+	    }
+	    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+	    const fn = `function(${slotScope}){` +
+	        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+	    // reverse proxy v-slot without scope on this.$slots
+	    const reverseProxy = slotScope ? `` : `,proxy:true`;
+	    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+	}
+	function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+	    const children = el.children;
+	    if (children.length) {
+	        const el = children[0];
+	        // optimize single v-for
+	        if (children.length === 1 &&
+	            el.for &&
+	            el.tag !== 'template' &&
+	            el.tag !== 'slot') {
+	            const normalizationType = checkSkip
+	                ? state.maybeComponent(el)
+	                    ? `,1`
+	                    : `,0`
+	                : ``;
+	            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+	        }
+	        const normalizationType = checkSkip
+	            ? getNormalizationType(children, state.maybeComponent)
+	            : 0;
+	        const gen = altGenNode || genNode;
+	        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+	    }
+	}
+	// determine the normalization needed for the children array.
+	// 0: no normalization needed
+	// 1: simple normalization needed (possible 1-level deep nested array)
+	// 2: full normalization needed
+	function getNormalizationType(children, maybeComponent) {
+	    let res = 0;
+	    for (let i = 0; i < children.length; i++) {
+	        const el = children[i];
+	        if (el.type !== 1) {
+	            continue;
+	        }
+	        if (needsNormalization(el) ||
+	            (el.ifConditions &&
+	                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+	            res = 2;
+	            break;
+	        }
+	        if (maybeComponent(el) ||
+	            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+	            res = 1;
+	        }
+	    }
+	    return res;
+	}
+	function needsNormalization(el) {
+	    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+	}
+	function genNode(node, state) {
+	    if (node.type === 1) {
+	        return genElement(node, state);
+	    }
+	    else if (node.type === 3 && node.isComment) {
+	        return genComment(node);
+	    }
+	    else {
+	        return genText(node);
+	    }
+	}
+	function genText(text) {
+	    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+	}
+	function genComment(comment) {
+	    return `_e(${JSON.stringify(comment.text)})`;
+	}
+	function genSlot(el, state) {
+	    const slotName = el.slotName || '"default"';
+	    const children = genChildren(el, state);
+	    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+	    const attrs = el.attrs || el.dynamicAttrs
+	        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+	            // slot props are camelized
+	            name: camelize(attr.name),
+	            value: attr.value,
+	            dynamic: attr.dynamic
+	        })))
+	        : null;
+	    const bind = el.attrsMap['v-bind'];
+	    if ((attrs || bind) && !children) {
+	        res += `,null`;
+	    }
+	    if (attrs) {
+	        res += `,${attrs}`;
+	    }
+	    if (bind) {
+	        res += `${attrs ? '' : ',null'},${bind}`;
+	    }
+	    return res + ')';
+	}
+	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+	function genComponent(componentName, el, state) {
+	    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+	    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+	}
+	function genProps(props) {
+	    let staticProps = ``;
+	    let dynamicProps = ``;
+	    for (let i = 0; i < props.length; i++) {
+	        const prop = props[i];
+	        const value = transformSpecialNewlines(prop.value);
+	        if (prop.dynamic) {
+	            dynamicProps += `${prop.name},${value},`;
+	        }
+	        else {
+	            staticProps += `"${prop.name}":${value},`;
+	        }
+	    }
+	    staticProps = `{${staticProps.slice(0, -1)}}`;
+	    if (dynamicProps) {
+	        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+	    }
+	    else {
+	        return staticProps;
+	    }
+	}
+	// #3895, #4268
+	function transformSpecialNewlines(text) {
+	    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 	}
 
-	// these keywords should not appear inside expressions, but operators like
-	// typeof, instanceof and in are allowed
-	const prohibitedKeywordRE = new RegExp('\\b' +
-	    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-	        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-	        'extends,finally,continue,debugger,function,arguments')
-	        .split(',')
-	        .join('\\b|\\b') +
-	    '\\b');
-	// these unary operators should not be used as property/method names
-	const unaryOperatorsRE = new RegExp('\\b' +
-	    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-	    '\\s*\\([^\\)]*\\)');
-	// strip strings in expressions
-	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-	// detect problematic expressions in a template
-	function detectErrors(ast, warn) {
-	    if (ast) {
-	        checkNode(ast, warn);
-	    }
-	}
-	function checkNode(node, warn) {
-	    if (node.type === 1) {
-	        for (const name in node.attrsMap) {
-	            if (dirRE.test(name)) {
-	                const value = node.attrsMap[name];
-	                if (value) {
-	                    const range = node.rawAttrsMap[name];
-	                    if (name === 'v-for') {
-	                        checkFor(node, `v-for="${value}"`, warn, range);
-	                    }
-	                    else if (name === 'v-slot' || name[0] === '#') {
-	                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-	                    }
-	                    else if (onRE.test(name)) {
-	                        checkEvent(value, `${name}="${value}"`, warn, range);
-	                    }
-	                    else {
-	                        checkExpression(value, `${name}="${value}"`, warn, range);
-	                    }
-	                }
-	            }
-	        }
-	        if (node.children) {
-	            for (let i = 0; i < node.children.length; i++) {
-	                checkNode(node.children[i], warn);
-	            }
-	        }
-	    }
-	    else if (node.type === 2) {
-	        checkExpression(node.expression, node.text, warn, node);
-	    }
-	}
-	function checkEvent(exp, text, warn, range) {
-	    const stripped = exp.replace(stripStringRE, '');
-	    const keywordMatch = stripped.match(unaryOperatorsRE);
-	    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-	        warn(`avoid using JavaScript unary operator as property name: ` +
-	            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-	    }
-	    checkExpression(exp, text, warn, range);
-	}
-	function checkFor(node, text, warn, range) {
-	    checkExpression(node.for || '', text, warn, range);
-	    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-	    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-	    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-	}
-	function checkIdentifier(ident, type, text, warn, range) {
-	    if (typeof ident === 'string') {
-	        try {
-	            new Function(`var ${ident}=_`);
-	        }
-	        catch (e) {
-	            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-	        }
-	    }
-	}
-	function checkExpression(exp, text, warn, range) {
-	    try {
-	        new Function(`return ${exp}`);
-	    }
-	    catch (e) {
-	        const keywordMatch = exp
-	            .replace(stripStringRE, '')
-	            .match(prohibitedKeywordRE);
-	        if (keywordMatch) {
-	            warn(`avoid using JavaScript keyword as property name: ` +
-	                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-	        }
-	        else {
-	            warn(`invalid expression: ${e.message} in\n\n` +
-	                `    ${exp}\n\n` +
-	                `  Raw expression: ${text.trim()}\n`, range);
-	        }
-	    }
-	}
-	function checkFunctionParameterExpression(exp, text, warn, range) {
-	    try {
-	        new Function(exp, '');
-	    }
-	    catch (e) {
-	        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-	            `    ${exp}\n\n` +
-	            `  Raw expression: ${text.trim()}\n`, range);
-	    }
+	// these keywords should not appear inside expressions, but operators like
+	// typeof, instanceof and in are allowed
+	const prohibitedKeywordRE = new RegExp('\\b' +
+	    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+	        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+	        'extends,finally,continue,debugger,function,arguments')
+	        .split(',')
+	        .join('\\b|\\b') +
+	    '\\b');
+	// these unary operators should not be used as property/method names
+	const unaryOperatorsRE = new RegExp('\\b' +
+	    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+	    '\\s*\\([^\\)]*\\)');
+	// strip strings in expressions
+	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+	// detect problematic expressions in a template
+	function detectErrors(ast, warn) {
+	    if (ast) {
+	        checkNode(ast, warn);
+	    }
+	}
+	function checkNode(node, warn) {
+	    if (node.type === 1) {
+	        for (const name in node.attrsMap) {
+	            if (dirRE.test(name)) {
+	                const value = node.attrsMap[name];
+	                if (value) {
+	                    const range = node.rawAttrsMap[name];
+	                    if (name === 'v-for') {
+	                        checkFor(node, `v-for="${value}"`, warn, range);
+	                    }
+	                    else if (name === 'v-slot' || name[0] === '#') {
+	                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+	                    }
+	                    else if (onRE.test(name)) {
+	                        checkEvent(value, `${name}="${value}"`, warn, range);
+	                    }
+	                    else {
+	                        checkExpression(value, `${name}="${value}"`, warn, range);
+	                    }
+	                }
+	            }
+	        }
+	        if (node.children) {
+	            for (let i = 0; i < node.children.length; i++) {
+	                checkNode(node.children[i], warn);
+	            }
+	        }
+	    }
+	    else if (node.type === 2) {
+	        checkExpression(node.expression, node.text, warn, node);
+	    }
+	}
+	function checkEvent(exp, text, warn, range) {
+	    const stripped = exp.replace(stripStringRE, '');
+	    const keywordMatch = stripped.match(unaryOperatorsRE);
+	    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+	        warn(`avoid using JavaScript unary operator as property name: ` +
+	            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+	    }
+	    checkExpression(exp, text, warn, range);
+	}
+	function checkFor(node, text, warn, range) {
+	    checkExpression(node.for || '', text, warn, range);
+	    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+	    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+	    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+	}
+	function checkIdentifier(ident, type, text, warn, range) {
+	    if (typeof ident === 'string') {
+	        try {
+	            new Function(`var ${ident}=_`);
+	        }
+	        catch (e) {
+	            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+	        }
+	    }
+	}
+	function checkExpression(exp, text, warn, range) {
+	    try {
+	        new Function(`return ${exp}`);
+	    }
+	    catch (e) {
+	        const keywordMatch = exp
+	            .replace(stripStringRE, '')
+	            .match(prohibitedKeywordRE);
+	        if (keywordMatch) {
+	            warn(`avoid using JavaScript keyword as property name: ` +
+	                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+	        }
+	        else {
+	            warn(`invalid expression: ${e.message} in\n\n` +
+	                `    ${exp}\n\n` +
+	                `  Raw expression: ${text.trim()}\n`, range);
+	        }
+	    }
+	}
+	function checkFunctionParameterExpression(exp, text, warn, range) {
+	    try {
+	        new Function(exp, '');
+	    }
+	    catch (e) {
+	        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+	            `    ${exp}\n\n` +
+	            `  Raw expression: ${text.trim()}\n`, range);
+	    }
 	}
 
-	const range = 2;
-	function generateCodeFrame(source, start = 0, end = source.length) {
-	    const lines = source.split(/\r?\n/);
-	    let count = 0;
-	    const res = [];
-	    for (let i = 0; i < lines.length; i++) {
-	        count += lines[i].length + 1;
-	        if (count >= start) {
-	            for (let j = i - range; j <= i + range || end > count; j++) {
-	                if (j < 0 || j >= lines.length)
-	                    continue;
-	                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-	                const lineLength = lines[j].length;
-	                if (j === i) {
-	                    // push underline
-	                    const pad = start - (count - lineLength) + 1;
-	                    const length = end > count ? lineLength - pad : end - start;
-	                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-	                }
-	                else if (j > i) {
-	                    if (end > count) {
-	                        const length = Math.min(end - count, lineLength);
-	                        res.push(`   |  ` + repeat(`^`, length));
-	                    }
-	                    count += lineLength + 1;
-	                }
-	            }
-	            break;
-	        }
-	    }
-	    return res.join('\n');
-	}
-	function repeat(str, n) {
-	    let result = '';
-	    if (n > 0) {
-	        // eslint-disable-next-line no-constant-condition
-	        while (true) {
-	            // eslint-disable-line
-	            if (n & 1)
-	                result += str;
-	            n >>>= 1;
-	            if (n <= 0)
-	                break;
-	            str += str;
-	        }
-	    }
-	    return result;
+	const range = 2;
+	function generateCodeFrame(source, start = 0, end = source.length) {
+	    const lines = source.split(/\r?\n/);
+	    let count = 0;
+	    const res = [];
+	    for (let i = 0; i < lines.length; i++) {
+	        count += lines[i].length + 1;
+	        if (count >= start) {
+	            for (let j = i - range; j <= i + range || end > count; j++) {
+	                if (j < 0 || j >= lines.length)
+	                    continue;
+	                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+	                const lineLength = lines[j].length;
+	                if (j === i) {
+	                    // push underline
+	                    const pad = start - (count - lineLength) + 1;
+	                    const length = end > count ? lineLength - pad : end - start;
+	                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+	                }
+	                else if (j > i) {
+	                    if (end > count) {
+	                        const length = Math.min(end - count, lineLength);
+	                        res.push(`   |  ` + repeat(`^`, length));
+	                    }
+	                    count += lineLength + 1;
+	                }
+	            }
+	            break;
+	        }
+	    }
+	    return res.join('\n');
+	}
+	function repeat(str, n) {
+	    let result = '';
+	    if (n > 0) {
+	        // eslint-disable-next-line no-constant-condition
+	        while (true) {
+	            // eslint-disable-line
+	            if (n & 1)
+	                result += str;
+	            n >>>= 1;
+	            if (n <= 0)
+	                break;
+	            str += str;
+	        }
+	    }
+	    return result;
 	}
 
-	function createFunction(code, errors) {
-	    try {
-	        return new Function(code);
-	    }
-	    catch (err) {
-	        errors.push({ err, code });
-	        return noop;
-	    }
-	}
-	function createCompileToFunctionFn(compile) {
-	    const cache = Object.create(null);
-	    return function compileToFunctions(template, options, vm) {
-	        options = extend({}, options);
-	        const warn = options.warn || warn$2;
-	        delete options.warn;
-	        /* istanbul ignore if */
-	        {
-	            // detect possible CSP restriction
-	            try {
-	                new Function('return 1');
-	            }
-	            catch (e) {
-	                if (e.toString().match(/unsafe-eval|CSP/)) {
-	                    warn('It seems you are using the standalone build of Vue.js in an ' +
-	                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-	                        'The template compiler cannot work in this environment. Consider ' +
-	                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-	                        'templates into render functions.');
-	                }
-	            }
-	        }
-	        // check cache
-	        const key = options.delimiters
-	            ? String(options.delimiters) + template
-	            : template;
-	        if (cache[key]) {
-	            return cache[key];
-	        }
-	        // compile
-	        const compiled = compile(template, options);
-	        // check compilation errors/tips
-	        {
-	            if (compiled.errors && compiled.errors.length) {
-	                if (options.outputSourceRange) {
-	                    compiled.errors.forEach((e) => {
-	                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-	                            generateCodeFrame(template, e.start, e.end), vm);
-	                    });
-	                }
-	                else {
-	                    warn(`Error compiling template:\n\n${template}\n\n` +
-	                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-	                        '\n', vm);
-	                }
-	            }
-	            if (compiled.tips && compiled.tips.length) {
-	                if (options.outputSourceRange) {
-	                    compiled.tips.forEach((e) => tip(e.msg, vm));
-	                }
-	                else {
-	                    compiled.tips.forEach((msg) => tip(msg, vm));
-	                }
-	            }
-	        }
-	        // turn code into functions
-	        const res = {};
-	        const fnGenErrors = [];
-	        res.render = createFunction(compiled.render, fnGenErrors);
-	        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-	            return createFunction(code, fnGenErrors);
-	        });
-	        // check function generation errors.
-	        // this should only happen if there is a bug in the compiler itself.
-	        // mostly for codegen development use
-	        /* istanbul ignore if */
-	        {
-	            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-	                warn(`Failed to generate render function:\n\n` +
-	                    fnGenErrors
-	                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-	                        .join('\n'), vm);
-	            }
-	        }
-	        return (cache[key] = res);
-	    };
+	function createFunction(code, errors) {
+	    try {
+	        return new Function(code);
+	    }
+	    catch (err) {
+	        errors.push({ err, code });
+	        return noop;
+	    }
+	}
+	function createCompileToFunctionFn(compile) {
+	    const cache = Object.create(null);
+	    return function compileToFunctions(template, options, vm) {
+	        options = extend({}, options);
+	        const warn = options.warn || warn$2;
+	        delete options.warn;
+	        /* istanbul ignore if */
+	        {
+	            // detect possible CSP restriction
+	            try {
+	                new Function('return 1');
+	            }
+	            catch (e) {
+	                if (e.toString().match(/unsafe-eval|CSP/)) {
+	                    warn('It seems you are using the standalone build of Vue.js in an ' +
+	                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+	                        'The template compiler cannot work in this environment. Consider ' +
+	                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+	                        'templates into render functions.');
+	                }
+	            }
+	        }
+	        // check cache
+	        const key = options.delimiters
+	            ? String(options.delimiters) + template
+	            : template;
+	        if (cache[key]) {
+	            return cache[key];
+	        }
+	        // compile
+	        const compiled = compile(template, options);
+	        // check compilation errors/tips
+	        {
+	            if (compiled.errors && compiled.errors.length) {
+	                if (options.outputSourceRange) {
+	                    compiled.errors.forEach((e) => {
+	                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+	                            generateCodeFrame(template, e.start, e.end), vm);
+	                    });
+	                }
+	                else {
+	                    warn(`Error compiling template:\n\n${template}\n\n` +
+	                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+	                        '\n', vm);
+	                }
+	            }
+	            if (compiled.tips && compiled.tips.length) {
+	                if (options.outputSourceRange) {
+	                    compiled.tips.forEach((e) => tip(e.msg, vm));
+	                }
+	                else {
+	                    compiled.tips.forEach((msg) => tip(msg, vm));
+	                }
+	            }
+	        }
+	        // turn code into functions
+	        const res = {};
+	        const fnGenErrors = [];
+	        res.render = createFunction(compiled.render, fnGenErrors);
+	        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+	            return createFunction(code, fnGenErrors);
+	        });
+	        // check function generation errors.
+	        // this should only happen if there is a bug in the compiler itself.
+	        // mostly for codegen development use
+	        /* istanbul ignore if */
+	        {
+	            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+	                warn(`Failed to generate render function:\n\n` +
+	                    fnGenErrors
+	                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+	                        .join('\n'), vm);
+	            }
+	        }
+	        return (cache[key] = res);
+	    };
 	}
 
-	function createCompilerCreator(baseCompile) {
-	    return function createCompiler(baseOptions) {
-	        function compile(template, options) {
-	            const finalOptions = Object.create(baseOptions);
-	            const errors = [];
-	            const tips = [];
-	            let warn = (msg, range, tip) => {
-	                (tip ? tips : errors).push(msg);
-	            };
-	            if (options) {
-	                if (options.outputSourceRange) {
-	                    // $flow-disable-line
-	                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-	                    warn = (msg, range, tip) => {
-	                        const data = { msg };
-	                        if (range) {
-	                            if (range.start != null) {
-	                                data.start = range.start + leadingSpaceLength;
-	                            }
-	                            if (range.end != null) {
-	                                data.end = range.end + leadingSpaceLength;
-	                            }
-	                        }
-	                        (tip ? tips : errors).push(data);
-	                    };
-	                }
-	                // merge custom modules
-	                if (options.modules) {
-	                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-	                }
-	                // merge custom directives
-	                if (options.directives) {
-	                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-	                }
-	                // copy other options
-	                for (const key in options) {
-	                    if (key !== 'modules' && key !== 'directives') {
-	                        finalOptions[key] = options[key];
-	                    }
-	                }
-	            }
-	            finalOptions.warn = warn;
-	            const compiled = baseCompile(template.trim(), finalOptions);
-	            {
-	                detectErrors(compiled.ast, warn);
-	            }
-	            compiled.errors = errors;
-	            compiled.tips = tips;
-	            return compiled;
-	        }
-	        return {
-	            compile,
-	            compileToFunctions: createCompileToFunctionFn(compile),
-	        };
-	    };
+	function createCompilerCreator(baseCompile) {
+	    return function createCompiler(baseOptions) {
+	        function compile(template, options) {
+	            const finalOptions = Object.create(baseOptions);
+	            const errors = [];
+	            const tips = [];
+	            let warn = (msg, range, tip) => {
+	                (tip ? tips : errors).push(msg);
+	            };
+	            if (options) {
+	                if (options.outputSourceRange) {
+	                    // $flow-disable-line
+	                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+	                    warn = (msg, range, tip) => {
+	                        const data = typeof (msg) === 'string' ? { msg } : msg;
+	                        if (range) {
+	                            if (range.start != null) {
+	                                data.start = range.start + leadingSpaceLength;
+	                            }
+	                            if (range.end != null) {
+	                                data.end = range.end + leadingSpaceLength;
+	                            }
+	                        }
+	                        (tip ? tips : errors).push(data);
+	                    };
+	                }
+	                // merge custom modules
+	                if (options.modules) {
+	                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+	                }
+	                // merge custom directives
+	                if (options.directives) {
+	                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+	                }
+	                // copy other options
+	                for (const key in options) {
+	                    if (key !== 'modules' && key !== 'directives') {
+	                        finalOptions[key] = options[key];
+	                    }
+	                }
+	            }
+	            finalOptions.warn = warn;
+	            const compiled = baseCompile(template.trim(), finalOptions);
+	            {
+	                detectErrors(compiled.ast, warn);
+	            }
+	            compiled.errors = errors;
+	            compiled.tips = tips;
+	            return compiled;
+	        }
+	        return {
+	            compile,
+	            compileToFunctions: createCompileToFunctionFn(compile),
+	        };
+	    };
 	}
 
-	// `createCompilerCreator` allows creating compilers that use alternative
-	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-	// Here we just export a default compiler using the default parts.
-	const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
-	    const ast = parse(template.trim(), options);
-	    if (options.optimize !== false) {
-	        optimize$1(ast, options);
-	    }
-	    const code = generate$1(ast, options);
-	    return {
-	        ast,
-	        render: code.render,
-	        staticRenderFns: code.staticRenderFns,
-	    };
+	// `createCompilerCreator` allows creating compilers that use alternative
+	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+	// Here we just export a default compiler using the default parts.
+	const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+	    const ast = parse(template.trim(), options);
+	    if (options.optimize !== false) {
+	        optimize$1(ast, options);
+	    }
+	    const code = generate$1(ast, options);
+	    return {
+	        ast,
+	        render: code.render,
+	        staticRenderFns: code.staticRenderFns,
+	    };
 	});
 
 	const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
 
-	const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-	    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-	    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-	    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-	    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-	    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-	    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-	    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-	    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-	    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-	    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-	    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-	    'target,title,usemap,value,width,wrap');
-	/* istanbul ignore next */
-	const isRenderableAttr = (name) => {
-	    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-	};
-	const propsToAttrMap = {
-	    acceptCharset: 'accept-charset',
-	    className: 'class',
-	    htmlFor: 'for',
-	    httpEquiv: 'http-equiv',
-	};
-	const ESC = {
-	    '<': '&lt;',
-	    '>': '&gt;',
-	    '"': '&quot;',
-	    '&': '&amp;',
-	};
-	function escape(s) {
-	    return s.replace(/[<>"&]/g, escapeChar);
-	}
-	function escapeChar(a) {
-	    return ESC[a] || a;
+	const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+	    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+	    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+	    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+	    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+	    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+	    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+	    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+	    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+	    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+	    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+	    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+	    'target,title,usemap,value,width,wrap');
+	/* istanbul ignore next */
+	const isRenderableAttr = (name) => {
+	    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+	};
+	const propsToAttrMap = {
+	    acceptCharset: 'accept-charset',
+	    className: 'class',
+	    htmlFor: 'for',
+	    httpEquiv: 'http-equiv',
+	};
+	const ESC = {
+	    '<': '&lt;',
+	    '>': '&gt;',
+	    '"': '&quot;',
+	    '&': '&amp;',
+	};
+	function escape(s) {
+	    return s.replace(/[<>"&]/g, escapeChar);
+	}
+	function escapeChar(a) {
+	    return ESC[a] || a;
 	}
 
-	const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-	// let the model AST transform translate v-model into appropriate
-	// props bindings
-	function applyModelTransform(el, state) {
-	    if (el.directives) {
-	        for (let i = 0; i < el.directives.length; i++) {
-	            const dir = el.directives[i];
-	            if (dir.name === 'model') {
-	                state.directives.model(el, dir, state.warn);
-	                // remove value for textarea as its converted to text
-	                if (el.tag === 'textarea' && el.props) {
-	                    el.props = el.props.filter((p) => p.name !== 'value');
-	                }
-	                break;
-	            }
-	        }
-	    }
-	}
-	function genAttrSegments(attrs) {
-	    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-	}
-	function genDOMPropSegments(props, attrs) {
-	    const segments = [];
-	    props.forEach(({ name, value }) => {
-	        name = propsToAttrMap[name] || name.toLowerCase();
-	        if (isRenderableAttr(name) &&
-	            !(attrs && attrs.some((a) => a.name === name))) {
-	            segments.push(genAttrSegment(name, value));
-	        }
-	    });
-	    return segments;
-	}
-	function genAttrSegment(name, value) {
-	    if (plainStringRE.test(value)) {
-	        // force double quote
-	        value = value.replace(/^'|'$/g, '"');
-	        // force enumerated attr to "true"
-	        if (isEnumeratedAttr(name) && value !== `"false"`) {
-	            value = `"true"`;
-	        }
-	        return {
-	            type: RAW,
-	            value: isBooleanAttr(name)
-	                ? ` ${name}="${name}"`
-	                : value === '""'
-	                    ? ` ${name}`
-	                    : ` ${name}="${JSON.parse(value)}"`,
-	        };
-	    }
-	    else {
-	        return {
-	            type: EXPRESSION,
-	            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-	        };
-	    }
-	}
-	function genClassSegments(staticClass, classBinding) {
-	    if (staticClass && !classBinding) {
-	        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-	    }
-	    else {
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-	            },
-	        ];
-	    }
-	}
-	function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-	    if (staticStyle && !styleBinding && !vShowExpression) {
-	        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-	    }
-	    else {
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-	            },
-	        ];
-	    }
+	const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+	// let the model AST transform translate v-model into appropriate
+	// props bindings
+	function applyModelTransform(el, state) {
+	    if (el.directives) {
+	        for (let i = 0; i < el.directives.length; i++) {
+	            const dir = el.directives[i];
+	            if (dir.name === 'model') {
+	                state.directives.model(el, dir, state.warn);
+	                // remove value for textarea as its converted to text
+	                if (el.tag === 'textarea' && el.props) {
+	                    el.props = el.props.filter((p) => p.name !== 'value');
+	                }
+	                break;
+	            }
+	        }
+	    }
+	}
+	function genAttrSegments(attrs) {
+	    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+	}
+	function genDOMPropSegments(props, attrs) {
+	    const segments = [];
+	    props.forEach(({ name, value }) => {
+	        name = propsToAttrMap[name] || name.toLowerCase();
+	        if (isRenderableAttr(name) &&
+	            !(attrs && attrs.some((a) => a.name === name))) {
+	            segments.push(genAttrSegment(name, value));
+	        }
+	    });
+	    return segments;
+	}
+	function genAttrSegment(name, value) {
+	    if (plainStringRE.test(value)) {
+	        // force double quote
+	        value = value.replace(/^'|'$/g, '"');
+	        // force enumerated attr to "true"
+	        if (isEnumeratedAttr(name) && value !== `"false"`) {
+	            value = `"true"`;
+	        }
+	        return {
+	            type: RAW,
+	            value: isBooleanAttr(name)
+	                ? ` ${name}="${name}"`
+	                : value === '""'
+	                    ? ` ${name}`
+	                    : ` ${name}="${JSON.parse(value)}"`,
+	        };
+	    }
+	    else {
+	        return {
+	            type: EXPRESSION,
+	            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+	        };
+	    }
+	}
+	function genClassSegments(staticClass, classBinding) {
+	    if (staticClass && !classBinding) {
+	        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+	    }
+	    else {
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+	            },
+	        ];
+	    }
+	}
+	function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+	    if (staticStyle && !styleBinding && !vShowExpression) {
+	        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+	    }
+	    else {
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+	            },
+	        ];
+	    }
 	}
 
-	/**
-	 * In SSR, the vdom tree is generated only once and never patched, so
-	 * we can optimize most element / trees into plain string render functions.
-	 * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-	 *
-	 * The criteria for SSR optimizability is quite a bit looser than static tree
-	 * detection (which is designed for client re-render). In SSR we bail only for
-	 * components/slots/custom directives.
-	 */
-	// optimizability constants
-	const optimizability = {
-	    FALSE: 0,
-	    FULL: 1,
-	    SELF: 2,
-	    CHILDREN: 3,
-	    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-	};
-	let isPlatformReservedTag;
-	function optimize(root, options) {
-	    if (!root)
-	        return;
-	    isPlatformReservedTag = options.isReservedTag || no;
-	    walk(root, true);
-	}
-	function walk(node, isRoot) {
-	    if (isUnOptimizableTree(node)) {
-	        node.ssrOptimizability = optimizability.FALSE;
-	        return;
-	    }
-	    // root node or nodes with custom directives should always be a VNode
-	    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-	    const check = (child) => {
-	        if (child.ssrOptimizability !== optimizability.FULL) {
-	            node.ssrOptimizability = selfUnoptimizable
-	                ? optimizability.PARTIAL
-	                : optimizability.SELF;
-	        }
-	    };
-	    if (selfUnoptimizable) {
-	        node.ssrOptimizability = optimizability.CHILDREN;
-	    }
-	    if (node.type === 1) {
-	        for (let i = 0, l = node.children.length; i < l; i++) {
-	            const child = node.children[i];
-	            walk(child);
-	            check(child);
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                const block = node.ifConditions[i].block;
-	                walk(block, isRoot);
-	                check(block);
-	            }
-	        }
-	        if (node.ssrOptimizability == null ||
-	            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-	            node.ssrOptimizability = optimizability.FULL;
-	        }
-	        else {
-	            node.children = optimizeSiblings(node);
-	        }
-	    }
-	    else {
-	        node.ssrOptimizability = optimizability.FULL;
-	    }
-	}
-	function optimizeSiblings(el) {
-	    const children = el.children;
-	    const optimizedChildren = [];
-	    let currentOptimizableGroup = [];
-	    const pushGroup = () => {
-	        if (currentOptimizableGroup.length) {
-	            optimizedChildren.push({
-	                type: 1,
-	                parent: el,
-	                tag: 'template',
-	                attrsList: [],
-	                attrsMap: {},
-	                rawAttrsMap: {},
-	                children: currentOptimizableGroup,
-	                ssrOptimizability: optimizability.FULL,
-	            });
-	        }
-	        currentOptimizableGroup = [];
-	    };
-	    for (let i = 0; i < children.length; i++) {
-	        const c = children[i];
-	        if (c.ssrOptimizability === optimizability.FULL) {
-	            currentOptimizableGroup.push(c);
-	        }
-	        else {
-	            // wrap fully-optimizable adjacent siblings inside a template tag
-	            // so that they can be optimized into a single ssrNode by codegen
-	            pushGroup();
-	            optimizedChildren.push(c);
-	        }
-	    }
-	    pushGroup();
-	    return optimizedChildren;
-	}
-	function isUnOptimizableTree(node) {
-	    if (node.type === 2 || node.type === 3) {
-	        // text or expression
-	        return false;
-	    }
-	    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-	        !isPlatformReservedTag(node.tag) || // custom component
-	        !!node.component || // "is" component
-	        isSelectWithModel(node) // <select v-model> requires runtime inspection
-	    );
-	}
-	const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-	function hasCustomDirective(node) {
-	    return (node.type === 1 &&
-	        node.directives &&
-	        node.directives.some((d) => !isBuiltInDir(d.name)));
-	}
-	// <select v-model> cannot be optimized because it requires a runtime check
-	// to determine proper selected option
-	function isSelectWithModel(node) {
-	    return (node.type === 1 &&
-	        node.tag === 'select' &&
-	        node.directives != null &&
-	        node.directives.some((d) => d.name === 'model'));
+	/**
+	 * In SSR, the vdom tree is generated only once and never patched, so
+	 * we can optimize most element / trees into plain string render functions.
+	 * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+	 *
+	 * The criteria for SSR optimizability is quite a bit looser than static tree
+	 * detection (which is designed for client re-render). In SSR we bail only for
+	 * components/slots/custom directives.
+	 */
+	// optimizability constants
+	const optimizability = {
+	    FALSE: 0,
+	    FULL: 1,
+	    SELF: 2,
+	    CHILDREN: 3,
+	    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+	};
+	let isPlatformReservedTag;
+	function optimize(root, options) {
+	    if (!root)
+	        return;
+	    isPlatformReservedTag = options.isReservedTag || no;
+	    walk(root, true);
+	}
+	function walk(node, isRoot) {
+	    if (isUnOptimizableTree(node)) {
+	        node.ssrOptimizability = optimizability.FALSE;
+	        return;
+	    }
+	    // root node or nodes with custom directives should always be a VNode
+	    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+	    const check = (child) => {
+	        if (child.ssrOptimizability !== optimizability.FULL) {
+	            node.ssrOptimizability = selfUnoptimizable
+	                ? optimizability.PARTIAL
+	                : optimizability.SELF;
+	        }
+	    };
+	    if (selfUnoptimizable) {
+	        node.ssrOptimizability = optimizability.CHILDREN;
+	    }
+	    if (node.type === 1) {
+	        for (let i = 0, l = node.children.length; i < l; i++) {
+	            const child = node.children[i];
+	            walk(child);
+	            check(child);
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                const block = node.ifConditions[i].block;
+	                walk(block, isRoot);
+	                check(block);
+	            }
+	        }
+	        if (node.ssrOptimizability == null ||
+	            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+	            node.ssrOptimizability = optimizability.FULL;
+	        }
+	        else {
+	            node.children = optimizeSiblings(node);
+	        }
+	    }
+	    else {
+	        node.ssrOptimizability = optimizability.FULL;
+	    }
+	}
+	function optimizeSiblings(el) {
+	    const children = el.children;
+	    const optimizedChildren = [];
+	    let currentOptimizableGroup = [];
+	    const pushGroup = () => {
+	        if (currentOptimizableGroup.length) {
+	            optimizedChildren.push({
+	                type: 1,
+	                parent: el,
+	                tag: 'template',
+	                attrsList: [],
+	                attrsMap: {},
+	                rawAttrsMap: {},
+	                children: currentOptimizableGroup,
+	                ssrOptimizability: optimizability.FULL,
+	            });
+	        }
+	        currentOptimizableGroup = [];
+	    };
+	    for (let i = 0; i < children.length; i++) {
+	        const c = children[i];
+	        if (c.ssrOptimizability === optimizability.FULL) {
+	            currentOptimizableGroup.push(c);
+	        }
+	        else {
+	            // wrap fully-optimizable adjacent siblings inside a template tag
+	            // so that they can be optimized into a single ssrNode by codegen
+	            pushGroup();
+	            optimizedChildren.push(c);
+	        }
+	    }
+	    pushGroup();
+	    return optimizedChildren;
+	}
+	function isUnOptimizableTree(node) {
+	    if (node.type === 2 || node.type === 3) {
+	        // text or expression
+	        return false;
+	    }
+	    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+	        !isPlatformReservedTag(node.tag) || // custom component
+	        !!node.component || // "is" component
+	        isSelectWithModel(node) // <select v-model> requires runtime inspection
+	    );
+	}
+	const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+	function hasCustomDirective(node) {
+	    return (node.type === 1 &&
+	        node.directives &&
+	        node.directives.some((d) => !isBuiltInDir(d.name)));
+	}
+	// <select v-model> cannot be optimized because it requires a runtime check
+	// to determine proper selected option
+	function isSelectWithModel(node) {
+	    return (node.type === 1 &&
+	        node.tag === 'select' &&
+	        node.directives != null &&
+	        node.directives.some((d) => d.name === 'model'));
 	}
 
-	// The SSR codegen is essentially extending the default codegen to handle
-	// segment types
-	const RAW = 0;
-	const INTERPOLATION = 1;
-	const EXPRESSION = 2;
-	function generate(ast, options) {
-	    const state = new CodegenState(options);
-	    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-	    return {
-	        render: `with(this){return ${code}}`,
-	        staticRenderFns: state.staticRenderFns,
-	    };
-	}
-	function genSSRElement(el, state) {
-	    if (el.for && !el.forProcessed) {
-	        return genFor(el, state, genSSRElement);
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        return genIf(el, state, genSSRElement);
-	    }
-	    else if (el.tag === 'template' && !el.slotTarget) {
-	        return el.ssrOptimizability === optimizability.FULL
-	            ? genChildrenAsStringNode(el, state)
-	            : genSSRChildren(el, state) || 'void 0';
-	    }
-	    switch (el.ssrOptimizability) {
-	        case optimizability.FULL:
-	            // stringify whole tree
-	            return genStringElement(el, state);
-	        case optimizability.SELF:
-	            // stringify self and check children
-	            return genStringElementWithChildren(el, state);
-	        case optimizability.CHILDREN:
-	            // generate self as VNode and stringify children
-	            return genNormalElement(el, state, true);
-	        case optimizability.PARTIAL:
-	            // generate self as VNode and check children
-	            return genNormalElement(el, state, false);
-	        default:
-	            // bail whole tree
-	            return genElement(el, state);
-	    }
-	}
-	function genNormalElement(el, state, stringifyChildren) {
-	    const data = el.plain ? undefined : genData(el, state);
-	    const children = stringifyChildren
-	        ? `[${genChildrenAsStringNode(el, state)}]`
-	        : genSSRChildren(el, state, true);
-	    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-	}
-	function genSSRChildren(el, state, checkSkip) {
-	    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-	}
-	function genSSRNode(el, state) {
-	    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-	}
-	function genChildrenAsStringNode(el, state) {
-	    return el.children.length
-	        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-	        : '';
-	}
-	function genStringElement(el, state) {
-	    return `_ssrNode(${elementToString(el, state)})`;
-	}
-	function genStringElementWithChildren(el, state) {
-	    const children = genSSRChildren(el, state, true);
-	    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-	}
-	function elementToString(el, state) {
-	    return `(${flattenSegments(elementToSegments(el, state))})`;
-	}
-	function elementToSegments(el, state) {
-	    // v-for / v-if
-	    if (el.for && !el.forProcessed) {
-	        el.forProcessed = true;
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: genFor(el, state, elementToString, '_ssrList'),
-	            },
-	        ];
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        el.ifProcessed = true;
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: genIf(el, state, elementToString, '"<!---->"'),
-	            },
-	        ];
-	    }
-	    else if (el.tag === 'template') {
-	        return childrenToSegments(el, state);
-	    }
-	    const openSegments = elementToOpenTagSegments(el, state);
-	    const childrenSegments = childrenToSegments(el, state);
-	    const { isUnaryTag } = state.options;
-	    const close = isUnaryTag && isUnaryTag(el.tag)
-	        ? []
-	        : [{ type: RAW, value: `</${el.tag}>` }];
-	    return openSegments.concat(childrenSegments, close);
-	}
-	function elementToOpenTagSegments(el, state) {
-	    applyModelTransform(el, state);
-	    let binding;
-	    const segments = [{ type: RAW, value: `<${el.tag}` }];
-	    // attrs
-	    if (el.attrs) {
-	        segments.push.apply(segments, genAttrSegments(el.attrs));
-	    }
-	    // domProps
-	    if (el.props) {
-	        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-	    }
-	    // v-bind="object"
-	    if ((binding = el.attrsMap['v-bind'])) {
-	        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-	    }
-	    // v-bind.prop="object"
-	    if ((binding = el.attrsMap['v-bind.prop'])) {
-	        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-	    }
-	    // class
-	    if (el.staticClass || el.classBinding) {
-	        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-	    }
-	    // style & v-show
-	    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-	        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-	    }
-	    // _scopedId
-	    if (state.options.scopeId) {
-	        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-	    }
-	    segments.push({ type: RAW, value: `>` });
-	    return segments;
-	}
-	function childrenToSegments(el, state) {
-	    let binding;
-	    if ((binding = el.attrsMap['v-html'])) {
-	        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-	    }
-	    if ((binding = el.attrsMap['v-text'])) {
-	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-	    }
-	    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-	    }
-	    return el.children ? nodesToSegments(el.children, state) : [];
-	}
-	function nodesToSegments(children, state) {
-	    const segments = [];
-	    for (let i = 0; i < children.length; i++) {
-	        const c = children[i];
-	        if (c.type === 1) {
-	            segments.push.apply(segments, elementToSegments(c, state));
-	        }
-	        else if (c.type === 2) {
-	            segments.push({ type: INTERPOLATION, value: c.expression });
-	        }
-	        else if (c.type === 3) {
-	            let text = escape(c.text);
-	            if (c.isComment) {
-	                text = '<!--' + text + '-->';
-	            }
-	            segments.push({ type: RAW, value: text });
-	        }
-	    }
-	    return segments;
-	}
-	function flattenSegments(segments) {
-	    const mergedSegments = [];
-	    let textBuffer = '';
-	    const pushBuffer = () => {
-	        if (textBuffer) {
-	            mergedSegments.push(JSON.stringify(textBuffer));
-	            textBuffer = '';
-	        }
-	    };
-	    for (let i = 0; i < segments.length; i++) {
-	        const s = segments[i];
-	        if (s.type === RAW) {
-	            textBuffer += s.value;
-	        }
-	        else if (s.type === INTERPOLATION) {
-	            pushBuffer();
-	            mergedSegments.push(`_ssrEscape(${s.value})`);
-	        }
-	        else if (s.type === EXPRESSION) {
-	            pushBuffer();
-	            mergedSegments.push(`(${s.value})`);
-	        }
-	    }
-	    pushBuffer();
-	    return mergedSegments.join('+');
+	// The SSR codegen is essentially extending the default codegen to handle
+	// segment types
+	const RAW = 0;
+	const INTERPOLATION = 1;
+	const EXPRESSION = 2;
+	function generate(ast, options) {
+	    const state = new CodegenState(options);
+	    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+	    return {
+	        render: `with(this){return ${code}}`,
+	        staticRenderFns: state.staticRenderFns,
+	    };
+	}
+	function genSSRElement(el, state) {
+	    if (el.for && !el.forProcessed) {
+	        return genFor(el, state, genSSRElement);
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        return genIf(el, state, genSSRElement);
+	    }
+	    else if (el.tag === 'template' && !el.slotTarget) {
+	        return el.ssrOptimizability === optimizability.FULL
+	            ? genChildrenAsStringNode(el, state)
+	            : genSSRChildren(el, state) || 'void 0';
+	    }
+	    switch (el.ssrOptimizability) {
+	        case optimizability.FULL:
+	            // stringify whole tree
+	            return genStringElement(el, state);
+	        case optimizability.SELF:
+	            // stringify self and check children
+	            return genStringElementWithChildren(el, state);
+	        case optimizability.CHILDREN:
+	            // generate self as VNode and stringify children
+	            return genNormalElement(el, state, true);
+	        case optimizability.PARTIAL:
+	            // generate self as VNode and check children
+	            return genNormalElement(el, state, false);
+	        default:
+	            // bail whole tree
+	            return genElement(el, state);
+	    }
+	}
+	function genNormalElement(el, state, stringifyChildren) {
+	    const data = el.plain ? undefined : genData(el, state);
+	    const children = stringifyChildren
+	        ? `[${genChildrenAsStringNode(el, state)}]`
+	        : genSSRChildren(el, state, true);
+	    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+	}
+	function genSSRChildren(el, state, checkSkip) {
+	    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+	}
+	function genSSRNode(el, state) {
+	    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+	}
+	function genChildrenAsStringNode(el, state) {
+	    return el.children.length
+	        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+	        : '';
+	}
+	function genStringElement(el, state) {
+	    return `_ssrNode(${elementToString(el, state)})`;
+	}
+	function genStringElementWithChildren(el, state) {
+	    const children = genSSRChildren(el, state, true);
+	    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+	}
+	function elementToString(el, state) {
+	    return `(${flattenSegments(elementToSegments(el, state))})`;
+	}
+	function elementToSegments(el, state) {
+	    // v-for / v-if
+	    if (el.for && !el.forProcessed) {
+	        el.forProcessed = true;
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: genFor(el, state, elementToString, '_ssrList'),
+	            },
+	        ];
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        el.ifProcessed = true;
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: genIf(el, state, elementToString, '"<!---->"'),
+	            },
+	        ];
+	    }
+	    else if (el.tag === 'template') {
+	        return childrenToSegments(el, state);
+	    }
+	    const openSegments = elementToOpenTagSegments(el, state);
+	    const childrenSegments = childrenToSegments(el, state);
+	    const { isUnaryTag } = state.options;
+	    const close = isUnaryTag && isUnaryTag(el.tag)
+	        ? []
+	        : [{ type: RAW, value: `</${el.tag}>` }];
+	    return openSegments.concat(childrenSegments, close);
+	}
+	function elementToOpenTagSegments(el, state) {
+	    applyModelTransform(el, state);
+	    let binding;
+	    const segments = [{ type: RAW, value: `<${el.tag}` }];
+	    // attrs
+	    if (el.attrs) {
+	        segments.push.apply(segments, genAttrSegments(el.attrs));
+	    }
+	    // domProps
+	    if (el.props) {
+	        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+	    }
+	    // v-bind="object"
+	    if ((binding = el.attrsMap['v-bind'])) {
+	        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+	    }
+	    // v-bind.prop="object"
+	    if ((binding = el.attrsMap['v-bind.prop'])) {
+	        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+	    }
+	    // class
+	    if (el.staticClass || el.classBinding) {
+	        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+	    }
+	    // style & v-show
+	    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+	        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+	    }
+	    // _scopedId
+	    if (state.options.scopeId) {
+	        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+	    }
+	    segments.push({ type: RAW, value: `>` });
+	    return segments;
+	}
+	function childrenToSegments(el, state) {
+	    let binding;
+	    if ((binding = el.attrsMap['v-html'])) {
+	        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+	    }
+	    if ((binding = el.attrsMap['v-text'])) {
+	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+	    }
+	    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+	    }
+	    return el.children ? nodesToSegments(el.children, state) : [];
+	}
+	function nodesToSegments(children, state) {
+	    const segments = [];
+	    for (let i = 0; i < children.length; i++) {
+	        const c = children[i];
+	        if (c.type === 1) {
+	            segments.push.apply(segments, elementToSegments(c, state));
+	        }
+	        else if (c.type === 2) {
+	            segments.push({ type: INTERPOLATION, value: c.expression });
+	        }
+	        else if (c.type === 3) {
+	            let text = escape(c.text);
+	            if (c.isComment) {
+	                text = '<!--' + text + '-->';
+	            }
+	            segments.push({ type: RAW, value: text });
+	        }
+	    }
+	    return segments;
+	}
+	function flattenSegments(segments) {
+	    const mergedSegments = [];
+	    let textBuffer = '';
+	    const pushBuffer = () => {
+	        if (textBuffer) {
+	            mergedSegments.push(JSON.stringify(textBuffer));
+	            textBuffer = '';
+	        }
+	    };
+	    for (let i = 0; i < segments.length; i++) {
+	        const s = segments[i];
+	        if (s.type === RAW) {
+	            textBuffer += s.value;
+	        }
+	        else if (s.type === INTERPOLATION) {
+	            pushBuffer();
+	            mergedSegments.push(`_ssrEscape(${s.value})`);
+	        }
+	        else if (s.type === EXPRESSION) {
+	            pushBuffer();
+	            mergedSegments.push(`(${s.value})`);
+	        }
+	    }
+	    pushBuffer();
+	    return mergedSegments.join('+');
 	}
 
-	const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-	    const ast = parse(template.trim(), options);
-	    optimize(ast, options);
-	    const code = generate(ast, options);
-	    return {
-	        ast,
-	        render: code.render,
-	        staticRenderFns: code.staticRenderFns,
-	    };
+	const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+	    const ast = parse(template.trim(), options);
+	    optimize(ast, options);
+	    const code = generate(ast, options);
+	    return {
+	        ast,
+	        render: code.render,
+	        staticRenderFns: code.staticRenderFns,
+	    };
 	});
 
 	const { compile, compileToFunctions } = createCompiler(baseOptions);
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index d4394d72c73..9be57952d57 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -10,4559 +10,4559 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
 var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (process.env.NODE_ENV !== 'production' &&
-                !stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    (i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-const splitRE = /\r?\n/g;
-const replaceRE = /./g;
-const isSpecialTag = makeMap('script,style,template', true);
-/**
- * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
- */
-function parseComponent(content, options = {}) {
-    const sfc = {
-        template: null,
-        script: null,
-        styles: [],
-        customBlocks: [],
-        errors: [],
-    };
-    let depth = 0;
-    let currentBlock = null;
-    let warn = (msg) => {
-        sfc.errors.push(msg);
-    };
-    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        warn = (msg, range) => {
-            const data = { msg };
-            if (range.start != null) {
-                data.start = range.start;
-            }
-            if (range.end != null) {
-                data.end = range.end;
-            }
-            sfc.errors.push(data);
-        };
-    }
-    function start(tag, attrs, unary, start, end) {
-        if (depth === 0) {
-            currentBlock = {
-                type: tag,
-                content: '',
-                start: end,
-                attrs: attrs.reduce((cumulated, { name, value }) => {
-                    cumulated[name] = value || true;
-                    return cumulated;
-                }, {}),
-            };
-            if (isSpecialTag(tag)) {
-                checkAttrs(currentBlock, attrs);
-                if (tag === 'style') {
-                    sfc.styles.push(currentBlock);
-                }
-                else {
-                    sfc[tag] = currentBlock;
-                }
-            }
-            else {
-                // custom blocks
-                sfc.customBlocks.push(currentBlock);
-            }
-        }
-        if (!unary) {
-            depth++;
-        }
-    }
-    function checkAttrs(block, attrs) {
-        for (let i = 0; i < attrs.length; i++) {
-            const attr = attrs[i];
-            if (attr.name === 'lang') {
-                block.lang = attr.value;
-            }
-            if (attr.name === 'scoped') {
-                block.scoped = true;
-            }
-            if (attr.name === 'module') {
-                block.module = attr.value || true;
-            }
-            if (attr.name === 'src') {
-                block.src = attr.value;
-            }
-        }
-    }
-    function end(tag, start) {
-        if (depth === 1 && currentBlock) {
-            currentBlock.end = start;
-            let text = content.slice(currentBlock.start, currentBlock.end);
-            if (options.deindent !== false) {
-                text = deindent__default["default"](text);
-            }
-            // pad content so that linters and pre-processors can output correct
-            // line numbers in errors and warnings
-            if (currentBlock.type !== 'template' && options.pad) {
-                text = padContent(currentBlock, options.pad) + text;
-            }
-            currentBlock.content = text;
-            currentBlock = null;
-        }
-        depth--;
-    }
-    function padContent(block, pad) {
-        if (pad === 'space') {
-            return content.slice(0, block.start).replace(replaceRE, ' ');
-        }
-        else {
-            const offset = content.slice(0, block.start).split(splitRE).length;
-            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
-            return Array(offset).join(padChar);
-        }
-    }
-    parseHTML(content, {
-        warn,
-        start,
-        end,
-        outputSourceRange: options.outputSourceRange,
-    });
-    return sfc;
+const splitRE = /\r?\n/g;
+const replaceRE = /./g;
+const isSpecialTag = makeMap('script,style,template', true);
+/**
+ * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+ */
+function parseComponent(content, options = {}) {
+    const sfc = {
+        template: null,
+        script: null,
+        styles: [],
+        customBlocks: [],
+        errors: [],
+    };
+    let depth = 0;
+    let currentBlock = null;
+    let warn = (msg) => {
+        sfc.errors.push(msg);
+    };
+    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        warn = (msg, range) => {
+            const data = { msg };
+            if (range.start != null) {
+                data.start = range.start;
+            }
+            if (range.end != null) {
+                data.end = range.end;
+            }
+            sfc.errors.push(data);
+        };
+    }
+    function start(tag, attrs, unary, start, end) {
+        if (depth === 0) {
+            currentBlock = {
+                type: tag,
+                content: '',
+                start: end,
+                attrs: attrs.reduce((cumulated, { name, value }) => {
+                    cumulated[name] = value || true;
+                    return cumulated;
+                }, {}),
+            };
+            if (isSpecialTag(tag)) {
+                checkAttrs(currentBlock, attrs);
+                if (tag === 'style') {
+                    sfc.styles.push(currentBlock);
+                }
+                else {
+                    sfc[tag] = currentBlock;
+                }
+            }
+            else {
+                // custom blocks
+                sfc.customBlocks.push(currentBlock);
+            }
+        }
+        if (!unary) {
+            depth++;
+        }
+    }
+    function checkAttrs(block, attrs) {
+        for (let i = 0; i < attrs.length; i++) {
+            const attr = attrs[i];
+            if (attr.name === 'lang') {
+                block.lang = attr.value;
+            }
+            if (attr.name === 'scoped') {
+                block.scoped = true;
+            }
+            if (attr.name === 'module') {
+                block.module = attr.value || true;
+            }
+            if (attr.name === 'src') {
+                block.src = attr.value;
+            }
+        }
+    }
+    function end(tag, start) {
+        if (depth === 1 && currentBlock) {
+            currentBlock.end = start;
+            let text = content.slice(currentBlock.start, currentBlock.end);
+            if (options.deindent !== false) {
+                text = deindent__default["default"](text);
+            }
+            // pad content so that linters and pre-processors can output correct
+            // line numbers in errors and warnings
+            if (currentBlock.type !== 'template' && options.pad) {
+                text = padContent(currentBlock, options.pad) + text;
+            }
+            currentBlock.content = text;
+            currentBlock = null;
+        }
+        depth--;
+    }
+    function padContent(block, pad) {
+        if (pad === 'space') {
+            return content.slice(0, block.start).replace(replaceRE, ' ');
+        }
+        else {
+            const offset = content.slice(0, block.start).split(splitRE).length;
+            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+            return Array(offset).join(padChar);
+        }
+    }
+    parseHTML(content, {
+        warn,
+        start,
+        end,
+        outputSourceRange: options.outputSourceRange,
+    });
+    return sfc;
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
 
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+if (process.env.NODE_ENV !== 'production') {
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
+let uid = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
 Dep.target = null;
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (!isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (!isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+if (process.env.NODE_ENV !== 'production') {
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
 }
 
-/* globals MutationObserver */
-const callbacks = [];
-function flushCallbacks() {
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve();
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+/* globals MutationObserver */
+const callbacks = [];
+function flushCallbacks() {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve();
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 else ;
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-makeMap('events,caret,typing,plaintext-only');
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
 
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
 makeMap('text,number,password,search,email,tel,url');
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' &&
-        warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (process.env.NODE_ENV !== 'production' && staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (process.env.NODE_ENV !== 'production' && staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he__default["default"].decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn$1;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn$1(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn: warn$1,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                process.env.NODE_ENV !== 'production' &&
-                    warn$1('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (process.env.NODE_ENV !== 'production' &&
-                        options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (process.env.NODE_ENV !== 'production' &&
-                    value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (process.env.NODE_ENV !== 'production' && name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            if (process.env.NODE_ENV !== 'production') {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn$1(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (process.env.NODE_ENV !== 'production' &&
-            map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he__default["default"].decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (el.tag === 'template') {
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model$1 = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model$1 = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model$1];
 
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model,
-    text,
-    html,
+var directives = {
+    model,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys$1(modules),
 };
 
-let isStaticKey;
-let isPlatformReservedTag$1;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize$1(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag$1 = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag$1(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag$1(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
+let isStaticKey;
+let isPlatformReservedTag$1;
+const genStaticKeysCached = cached(genStaticKeys);
+/**
+ * Goal of the optimizer: walk the generated template AST tree
+ * and detect sub-trees that are purely static, i.e. parts of
+ * the DOM that never needs to change.
+ *
+ * Once we detect these sub-trees, we can:
+ *
+ * 1. Hoist them into constants, so that we no longer need to
+ *    create fresh nodes for them on each re-render;
+ * 2. Completely skip them in the patching process.
+ */
+function optimize$1(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag$1 = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag$1(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag$1(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
 }
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate$1(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            process.env.NODE_ENV !== 'production' &&
-                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (process.env.NODE_ENV !== 'production' &&
-        state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if (process.env.NODE_ENV !== 'production' &&
-        (el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate$1(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate$1(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate$1(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        if (process.env.NODE_ENV !== 'production') {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            if (process.env.NODE_ENV !== 'production') {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = typeof (msg) === 'string' ? { msg } : msg;
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize$1(ast, options);
-    }
-    const code = generate$1(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize$1(ast, options);
+    }
+    const code = generate$1(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
 
-const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap');
-/* istanbul ignore next */
-const isRenderableAttr = (name) => {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-};
-const propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv',
-};
-const ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;',
-};
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
-}
-function escapeChar(a) {
-    return ESC[a] || a;
+const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
+/* istanbul ignore next */
+const isRenderableAttr = (name) => {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+};
+const propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
+};
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
+};
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
 }
 
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-    if (el.directives) {
-        for (let i = 0; i < el.directives.length; i++) {
-            const dir = el.directives[i];
-            if (dir.name === 'model') {
-                state.directives.model(el, dir, state.warn);
-                // remove value for textarea as its converted to text
-                if (el.tag === 'textarea' && el.props) {
-                    el.props = el.props.filter((p) => p.name !== 'value');
-                }
-                break;
-            }
-        }
-    }
-}
-function genAttrSegments(attrs) {
-    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-}
-function genDOMPropSegments(props, attrs) {
-    const segments = [];
-    props.forEach(({ name, value }) => {
-        name = propsToAttrMap[name] || name.toLowerCase();
-        if (isRenderableAttr(name) &&
-            !(attrs && attrs.some((a) => a.name === name))) {
-            segments.push(genAttrSegment(name, value));
-        }
-    });
-    return segments;
-}
-function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-        // force double quote
-        value = value.replace(/^'|'$/g, '"');
-        // force enumerated attr to "true"
-        if (isEnumeratedAttr(name) && value !== `"false"`) {
-            value = `"true"`;
-        }
-        return {
-            type: RAW,
-            value: isBooleanAttr(name)
-                ? ` ${name}="${name}"`
-                : value === '""'
-                    ? ` ${name}`
-                    : ` ${name}="${JSON.parse(value)}"`,
-        };
-    }
-    else {
-        return {
-            type: EXPRESSION,
-            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-        };
-    }
-}
-function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-            },
-        ];
-    }
-}
-function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-            },
-        ];
-    }
+const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+// let the model AST transform translate v-model into appropriate
+// props bindings
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (let i = 0; i < el.directives.length; i++) {
+            const dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter((p) => p.name !== 'value');
+                }
+                break;
+            }
+        }
+    }
+}
+function genAttrSegments(attrs) {
+    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+}
+function genDOMPropSegments(props, attrs) {
+    const segments = [];
+    props.forEach(({ name, value }) => {
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some((a) => a.name === name))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== `"false"`) {
+            value = `"true"`;
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? ` ${name}="${name}"`
+                : value === '""'
+                    ? ` ${name}`
+                    : ` ${name}="${JSON.parse(value)}"`,
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+        };
+    }
+}
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+            },
+        ];
+    }
+}
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+            },
+        ];
+    }
 }
 
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-const optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-};
-let isPlatformReservedTag;
-function optimize(root, options) {
-    if (!root)
-        return;
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-}
-function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-        node.ssrOptimizability = optimizability.FALSE;
-        return;
-    }
-    // root node or nodes with custom directives should always be a VNode
-    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-    const check = (child) => {
-        if (child.ssrOptimizability !== optimizability.FULL) {
-            node.ssrOptimizability = selfUnoptimizable
-                ? optimizability.PARTIAL
-                : optimizability.SELF;
-        }
-    };
-    if (selfUnoptimizable) {
-        node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            walk(child);
-            check(child);
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                walk(block, isRoot);
-                check(block);
-            }
-        }
-        if (node.ssrOptimizability == null ||
-            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-            node.ssrOptimizability = optimizability.FULL;
-        }
-        else {
-            node.children = optimizeSiblings(node);
-        }
-    }
-    else {
-        node.ssrOptimizability = optimizability.FULL;
-    }
-}
-function optimizeSiblings(el) {
-    const children = el.children;
-    const optimizedChildren = [];
-    let currentOptimizableGroup = [];
-    const pushGroup = () => {
-        if (currentOptimizableGroup.length) {
-            optimizedChildren.push({
-                type: 1,
-                parent: el,
-                tag: 'template',
-                attrsList: [],
-                attrsMap: {},
-                rawAttrsMap: {},
-                children: currentOptimizableGroup,
-                ssrOptimizability: optimizability.FULL,
-            });
-        }
-        currentOptimizableGroup = [];
-    };
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.ssrOptimizability === optimizability.FULL) {
-            currentOptimizableGroup.push(c);
-        }
-        else {
-            // wrap fully-optimizable adjacent siblings inside a template tag
-            // so that they can be optimized into a single ssrNode by codegen
-            pushGroup();
-            optimizedChildren.push(c);
-        }
-    }
-    pushGroup();
-    return optimizedChildren;
-}
-function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-        // text or expression
-        return false;
-    }
-    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag(node.tag) || // custom component
-        !!node.component || // "is" component
-        isSelectWithModel(node) // <select v-model> requires runtime inspection
-    );
-}
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-function hasCustomDirective(node) {
-    return (node.type === 1 &&
-        node.directives &&
-        node.directives.some((d) => !isBuiltInDir(d.name)));
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-    return (node.type === 1 &&
-        node.tag === 'select' &&
-        node.directives != null &&
-        node.directives.some((d) => d.name === 'model'));
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
+// optimizability constants
+const optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+};
+let isPlatformReservedTag;
+function optimize(root, options) {
+    if (!root)
+        return;
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+    const check = (child) => {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
+    }
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    const children = el.children;
+    const optimizedChildren = [];
+    let currentOptimizableGroup = [];
+    const pushGroup = () => {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
+}
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
+}
+const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some((d) => !isBuiltInDir(d.name)));
+}
+// <select v-model> cannot be optimized because it requires a runtime check
+// to determine proper selected option
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some((d) => d.name === 'model'));
 }
 
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-const RAW = 0;
-const INTERPOLATION = 1;
-const EXPRESSION = 2;
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genSSRElement);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state, genSSRElement);
-    }
-    else if (el.tag === 'template' && !el.slotTarget) {
-        return el.ssrOptimizability === optimizability.FULL
-            ? genChildrenAsStringNode(el, state)
-            : genSSRChildren(el, state) || 'void 0';
-    }
-    switch (el.ssrOptimizability) {
-        case optimizability.FULL:
-            // stringify whole tree
-            return genStringElement(el, state);
-        case optimizability.SELF:
-            // stringify self and check children
-            return genStringElementWithChildren(el, state);
-        case optimizability.CHILDREN:
-            // generate self as VNode and stringify children
-            return genNormalElement(el, state, true);
-        case optimizability.PARTIAL:
-            // generate self as VNode and check children
-            return genNormalElement(el, state, false);
-        default:
-            // bail whole tree
-            return genElement(el, state);
-    }
-}
-function genNormalElement(el, state, stringifyChildren) {
-    const data = el.plain ? undefined : genData(el, state);
-    const children = stringifyChildren
-        ? `[${genChildrenAsStringNode(el, state)}]`
-        : genSSRChildren(el, state, true);
-    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-}
-function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-}
-function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-}
-function genChildrenAsStringNode(el, state) {
-    return el.children.length
-        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-        : '';
-}
-function genStringElement(el, state) {
-    return `_ssrNode(${elementToString(el, state)})`;
-}
-function genStringElementWithChildren(el, state) {
-    const children = genSSRChildren(el, state, true);
-    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-}
-function elementToString(el, state) {
-    return `(${flattenSegments(elementToSegments(el, state))})`;
-}
-function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-        el.forProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genFor(el, state, elementToString, '_ssrList'),
-            },
-        ];
-    }
-    else if (el.if && !el.ifProcessed) {
-        el.ifProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genIf(el, state, elementToString, '"<!---->"'),
-            },
-        ];
-    }
-    else if (el.tag === 'template') {
-        return childrenToSegments(el, state);
-    }
-    const openSegments = elementToOpenTagSegments(el, state);
-    const childrenSegments = childrenToSegments(el, state);
-    const { isUnaryTag } = state.options;
-    const close = isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: `</${el.tag}>` }];
-    return openSegments.concat(childrenSegments, close);
-}
-function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state);
-    let binding;
-    const segments = [{ type: RAW, value: `<${el.tag}` }];
-    // attrs
-    if (el.attrs) {
-        segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-    }
-    segments.push({ type: RAW, value: `>` });
-    return segments;
-}
-function childrenToSegments(el, state) {
-    let binding;
-    if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    return el.children ? nodesToSegments(el.children, state) : [];
-}
-function nodesToSegments(children, state) {
-    const segments = [];
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.type === 1) {
-            segments.push.apply(segments, elementToSegments(c, state));
-        }
-        else if (c.type === 2) {
-            segments.push({ type: INTERPOLATION, value: c.expression });
-        }
-        else if (c.type === 3) {
-            let text = escape(c.text);
-            if (c.isComment) {
-                text = '<!--' + text + '-->';
-            }
-            segments.push({ type: RAW, value: text });
-        }
-    }
-    return segments;
-}
-function flattenSegments(segments) {
-    const mergedSegments = [];
-    let textBuffer = '';
-    const pushBuffer = () => {
-        if (textBuffer) {
-            mergedSegments.push(JSON.stringify(textBuffer));
-            textBuffer = '';
-        }
-    };
-    for (let i = 0; i < segments.length; i++) {
-        const s = segments[i];
-        if (s.type === RAW) {
-            textBuffer += s.value;
-        }
-        else if (s.type === INTERPOLATION) {
-            pushBuffer();
-            mergedSegments.push(`_ssrEscape(${s.value})`);
-        }
-        else if (s.type === EXPRESSION) {
-            pushBuffer();
-            mergedSegments.push(`(${s.value})`);
-        }
-    }
-    pushBuffer();
-    return mergedSegments.join('+');
+// The SSR codegen is essentially extending the default codegen to handle
+// segment types
+const RAW = 0;
+const INTERPOLATION = 1;
+const EXPRESSION = 2;
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    const data = el.plain ? undefined : genData(el, state);
+    const children = stringifyChildren
+        ? `[${genChildrenAsStringNode(el, state)}]`
+        : genSSRChildren(el, state, true);
+    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+        : '';
+}
+function genStringElement(el, state) {
+    return `_ssrNode(${elementToString(el, state)})`;
+}
+function genStringElementWithChildren(el, state) {
+    const children = genSSRChildren(el, state, true);
+    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+}
+function elementToString(el, state) {
+    return `(${flattenSegments(elementToSegments(el, state))})`;
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            },
+        ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            },
+        ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    const openSegments = elementToOpenTagSegments(el, state);
+    const childrenSegments = childrenToSegments(el, state);
+    const { isUnaryTag } = state.options;
+    const close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: `</${el.tag}>` }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    let binding;
+    const segments = [{ type: RAW, value: `<${el.tag}` }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+    }
+    segments.push({ type: RAW, value: `>` });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    let binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    const segments = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            let text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
+}
+function flattenSegments(segments) {
+    const mergedSegments = [];
+    let textBuffer = '';
+    const pushBuffer = () => {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(`_ssrEscape(${s.value})`);
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(`(${s.value})`);
+        }
+    }
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    optimize(ast, options);
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    optimize(ast, options);
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile, compileToFunctions } = createCompiler(baseOptions);
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index 7c29513f383..214c0e48a49 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -25,8 +25,8 @@ export function createCompilerCreator(baseCompile: Function): Function {
           // $flow-disable-line
           const leadingSpaceLength = template.match(/^\s*/)![0].length
 
-          warn = (msg: WarningMessage, range: { start: number, end: number }, tip: string) => {
-            const data: WarningMessage = { msg }
+          warn = (msg: WarningMessage | string, range: { start: number, end: number }, tip: string) => {
+            const data: WarningMessage = typeof(msg) === 'string' ? { msg } : msg
             if (range) {
               if (range.start != null) {
                 data.start = range.start + leadingSpaceLength
diff --git a/src/server/render-stream.ts b/src/server/render-stream.ts
index 1218b441753..998ad391232 100644
--- a/src/server/render-stream.ts
+++ b/src/server/render-stream.ts
@@ -64,7 +64,7 @@ export default class RenderStream extends Readable {
   tryRender() {
     try {
       this.render(this.write, this.end)
-    } catch (e: any) {
+    } catch (e) {
       this.emit('error', e)
     }
   }
@@ -72,7 +72,7 @@ export default class RenderStream extends Readable {
   tryNext() {
     try {
       this.next()
-    } catch (e: any) {
+    } catch (e) {
       this.emit('error', e)
     }
   }
diff --git a/test/e2e/specs/select2.ts b/test/e2e/specs/select2.ts
index ada225d80bf..24a2a87b6d3 100644
--- a/test/e2e/specs/select2.ts
+++ b/test/e2e/specs/select2.ts
@@ -1,4 +1,5 @@
-/* globals vm */
+declare const vm: any 
+
 module.exports = {
   'select2': function (browser) {
     browser
diff --git a/test/e2e/specs/svg.ts b/test/e2e/specs/svg.ts
index cc9af55f62a..59d4b3c0ef0 100644
--- a/test/e2e/specs/svg.ts
+++ b/test/e2e/specs/svg.ts
@@ -1,4 +1,8 @@
-/* globals stats, valueToPoint */
+/* globals */
+
+declare const stats: any
+declare const valueToPoint: Function
+
 module.exports = {
   'svg': function (browser) {
     browser
@@ -16,7 +20,7 @@ module.exports = {
         const point = valueToPoint(stat.value, i, 6)
           return point.x + ',' + point.y
         }).join(' ')
-        return document.querySelector('polygon').attributes[0].value === points
+        return document.querySelector('polygon')!.attributes[0].value === points
       })
       .click('button.remove')
       .assert.count('text', 5)
@@ -28,7 +32,7 @@ module.exports = {
         const point = valueToPoint(stat.value, i, 5)
           return point.x + ',' + point.y
         }).join(' ')
-        return document.querySelector('polygon').attributes[0].value === points
+        return document.querySelector('polygon')!.attributes[0].value === points
       })
       .setValue('input[name="newlabel"]', 'foo')
       .click('#add > button')
diff --git a/test/helpers/wait-for-update.ts b/test/helpers/wait-for-update.ts
index 0a351b68313..28a97ef5f68 100644
--- a/test/helpers/wait-for-update.ts
+++ b/test/helpers/wait-for-update.ts
@@ -12,7 +12,8 @@ import Vue from 'vue'
 //   // more assertions...
 // })
 // .then(done)
-globalThis.waitForUpdate = initialCb => {
+// @ts-expect-error
+window.waitForUpdate = initialCb => {
   let end
   const queue = initialCb ? [initialCb] : []
 
@@ -21,7 +22,7 @@ globalThis.waitForUpdate = initialCb => {
     if (queue.length) {
       let hasError = false
       try {
-        job.wait ? job(shift) : (job ? job() : null)
+        job.wait ? job(shift) : job()
       } catch (e) {
         hasError = true
         const done = queue[queue.length - 1]
diff --git a/test/ssr/compile-with-webpack.ts b/test/ssr/compile-with-webpack.ts
index 6e648c8b489..62c5a81cca3 100644
--- a/test/ssr/compile-with-webpack.ts
+++ b/test/ssr/compile-with-webpack.ts
@@ -3,6 +3,9 @@ import webpack from 'webpack'
 import MemoryFS from 'memory-fs'
 
 export function compileWithWebpack (file, extraConfig, cb) {
+  if( process.env.FOOBAR !== 'blah') {
+    throw new Error('die')
+  }
   const config = Object.assign({
     mode: 'development',
     entry: path.resolve(__dirname, 'fixtures', file),
diff --git a/test/unit/features/component/component-scoped-slot.spec.ts b/test/unit/features/component/component-scoped-slot.spec.ts
index 017097f53f2..daf99928025 100644
--- a/test/unit/features/component/component-scoped-slot.spec.ts
+++ b/test/unit/features/component/component-scoped-slot.spec.ts
@@ -882,6 +882,7 @@ describe('Component scoped slot', () => {
     })
 
     it('warn when v-slot used on non-root <template>', () => {
+      // @ts-ignore unused
       const vm = new Vue({
         template: `
           <foo>
diff --git a/test/unit/features/component/component-slot.spec.ts b/test/unit/features/component/component-slot.spec.ts
index d9367956e93..16fae86815f 100644
--- a/test/unit/features/component/component-slot.spec.ts
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -113,7 +113,7 @@ describe('Component slot', () => {
    const Test = {
       render() {
         const _vm = this;
-        const _h = _vm.$createElement;
+        // const _h = _vm.$createElement;
         const _c = _vm._self._c || vm._h;
         return _c('div', [_vm._t("default", [_c('p', [_vm._v("slot default")])])], 2)
       }
diff --git a/test/unit/features/component/component.spec.ts b/test/unit/features/component/component.spec.ts
index 697a9dddbe7..49d4ea53d91 100644
--- a/test/unit/features/component/component.spec.ts
+++ b/test/unit/features/component/component.spec.ts
@@ -381,7 +381,7 @@ describe('Component', () => {
       vm.a = { b: 234 }
     }).then(() => {
       expect(vm.$el.textContent).toBe('234') // should be able to recover
-      Vue.config.errorHandler = null
+      Vue.config.errorHandler = undefined
     }).then(done)
   })
 
diff --git a/test/unit/features/debug.spec.ts b/test/unit/features/debug.spec.ts
index f66b1c4084f..222964babb0 100644
--- a/test/unit/features/debug.spec.ts
+++ b/test/unit/features/debug.spec.ts
@@ -3,7 +3,7 @@ import { formatComponentName, warn } from 'core/util/debug'
 
 describe('Debug utilities', () => {
   it('properly format component names', () => {
-    const vm = new Vue()
+    const vm = new Vue('div')
     expect(formatComponentName(vm)).toBe('<Root>')
 
     vm.$root = null
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index c8d624587e0..bfabb21bc37 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -158,8 +158,7 @@ describe('Error handling', () => {
     expect(args[2]).toContain('render') // description
 
     assertRootInstanceActive(vm).then(() => {
-      // @ts-expect-error
-      Vue.config.errorHandler = null
+      Vue.config.errorHandler = undefined
     }).then(done)
   })
 
@@ -171,12 +170,12 @@ describe('Error handling', () => {
     Vue.nextTick(() => {
       expect(spy).toHaveBeenCalledWith(err1, undefined, 'nextTick')
 
-      const vm = new Vue()
+      const vm = new Vue('div')
       vm.$nextTick(() => { throw err2 })
       Vue.nextTick(() => {
         // should be called with correct instance info
         expect(spy).toHaveBeenCalledWith(err2, vm, 'nextTick')
-        Vue.config.errorHandler = null
+        Vue.config.errorHandler = undefined
         done()
       })
     })
@@ -197,7 +196,7 @@ describe('Error handling', () => {
     expect('error in errorHandler').toHaveBeenWarned()
     expect('error in render').toHaveBeenWarned()
     expect(vm.$el.textContent).toContain('error in render')
-    Vue.config.errorHandler = null
+    Vue.config.errorHandler = undefined
   })
 
   // event handlers that can throw errors or return rejected promise
@@ -305,7 +304,7 @@ function createErrorTestComponents () {
   // directive hooks errors
   ;['bind', 'update', 'unbind'].forEach(hook => {
     const key = 'directive ' + hook
-    const dirComp = components[key] = {
+    const dirComp: any = components[key] = {
       props: ['n'],
       template: `<div v-foo="n">{{ n }}</div>`
     }
diff --git a/test/unit/features/global-api/mixin.spec.ts b/test/unit/features/global-api/mixin.spec.ts
index 8ba796b0676..503b1ff157b 100644
--- a/test/unit/features/global-api/mixin.spec.ts
+++ b/test/unit/features/global-api/mixin.spec.ts
@@ -20,7 +20,7 @@ describe('Global API: mixin', () => {
 
   it('should work for constructors created before mixin is applied', () => {
     const calls: any[] = []
-    const Test = Vue.extend({
+    const Test: Vue = Vue.extend({
       name: 'test',
       beforeCreate () {
         calls.push(this.$options.myOption + ' local')
diff --git a/test/unit/features/global-api/set-delete.spec.ts b/test/unit/features/global-api/set-delete.spec.ts
index 59e75ae4dbe..cfc4cf3744d 100644
--- a/test/unit/features/global-api/set-delete.spec.ts
+++ b/test/unit/features/global-api/set-delete.spec.ts
@@ -84,6 +84,7 @@ describe('Global API: set/delete', () => {
     // #6845
     it('should not overwrite properties on prototype chain', () => {
       class Model {
+        _bar?: string
         constructor () {
           this._bar = null
         }
@@ -161,7 +162,7 @@ describe('Global API: set/delete', () => {
       }).then(() => {
         expect(vm.$el.innerHTML).toBe('<p>A</p>')
         /* eslint-disable no-new-wrappers */
-        Vue.delete(vm.lists, new Number(0))
+        Vue.delete(vm.lists, new Number(0) as number)
       }).then(() => {
         expect(vm.$el.innerHTML).toBe('')
       }).then(done)
diff --git a/test/unit/features/instance/init.spec.ts b/test/unit/features/instance/init.spec.ts
index 62cc06dc22d..a11d0fd5004 100644
--- a/test/unit/features/instance/init.spec.ts
+++ b/test/unit/features/instance/init.spec.ts
@@ -2,11 +2,11 @@ import Vue from 'vue'
 
 describe('Initialization', () => {
   it('without new', () => {
-    try { Vue() } catch (e) {}
+    try { Vue('div') } catch (e) {}
     expect('Vue is a constructor and should be called with the `new` keyword').toHaveBeenWarned()
   })
 
   it('with new', () => {
-    expect(new Vue() instanceof Vue).toBe(true)
+    expect(new Vue('div') instanceof Vue).toBe(true)
   })
 })
diff --git a/test/unit/features/instance/methods-events.spec.ts b/test/unit/features/instance/methods-events.spec.ts
index 47d15bd6a5c..db66f74a4e9 100644
--- a/test/unit/features/instance/methods-events.spec.ts
+++ b/test/unit/features/instance/methods-events.spec.ts
@@ -3,7 +3,7 @@ import Vue from 'vue'
 describe('Instance methods events', () => {
   let vm, spy
   beforeEach(() => {
-    vm = new Vue()
+    vm = new Vue('div')
     spy = jasmine.createSpy('emitter')
   })
 
diff --git a/test/unit/features/instance/properties.spec.ts b/test/unit/features/instance/properties.spec.ts
index 8f220fbdc74..1aaa8110b1a 100644
--- a/test/unit/features/instance/properties.spec.ts
+++ b/test/unit/features/instance/properties.spec.ts
@@ -161,7 +161,7 @@ describe('Instance properties', () => {
   })
 
   it('warn mutating $attrs', () => {
-    const vm = new Vue()
+    const vm = new Vue('div')
     vm.$attrs = {}
     expect(`$attrs is readonly`).toHaveBeenWarned()
   })
@@ -196,7 +196,7 @@ describe('Instance properties', () => {
   })
 
   it('warn mutating $listeners', () => {
-    const vm = new Vue()
+    const vm = new Vue('div')
     vm.$listeners = {}
     expect(`$listeners is readonly`).toHaveBeenWarned()
   })
diff --git a/test/unit/features/options/data.spec.ts b/test/unit/features/options/data.spec.ts
index ac431bbd939..0f543b2a9fb 100644
--- a/test/unit/features/options/data.spec.ts
+++ b/test/unit/features/options/data.spec.ts
@@ -16,7 +16,7 @@ describe('Options data', () => {
   })
 
   it('should merge data properly', () => {
-    const Test = Vue.extend({
+    const Test: Vue = Vue.extend({
       data () {
         return { a: 1 }
       }
diff --git a/test/unit/features/options/errorCaptured.spec.ts b/test/unit/features/options/errorCaptured.spec.ts
index 516af743c85..bf87144a5fb 100644
--- a/test/unit/features/options/errorCaptured.spec.ts
+++ b/test/unit/features/options/errorCaptured.spec.ts
@@ -8,7 +8,7 @@ describe('Options errorCaptured', () => {
   })
 
   afterEach(() => {
-    Vue.config.errorHandler = null
+    Vue.config.errorHandler = undefined
   })
 
   it('should capture error from child component', () => {
diff --git a/test/unit/features/options/lifecycle.spec.ts b/test/unit/features/options/lifecycle.spec.ts
index a1e83b056ac..23b9071d0ba 100644
--- a/test/unit/features/options/lifecycle.spec.ts
+++ b/test/unit/features/options/lifecycle.spec.ts
@@ -78,7 +78,7 @@ describe('Options lifecycle hooks', () => {
 
     // #3898
     it('should call for manually mounted instance with parent', () => {
-      const parent = new Vue()
+      const parent = new Vue('div')
       expect(spy).not.toHaveBeenCalled()
       new Vue({
         parent,
diff --git a/test/unit/features/options/render.spec.ts b/test/unit/features/options/render.spec.ts
index 736afa2ca4d..2e16b808c81 100644
--- a/test/unit/features/options/render.spec.ts
+++ b/test/unit/features/options/render.spec.ts
@@ -33,7 +33,7 @@ describe('Options render', () => {
   })
 
   it('should warn non `render` option and non `template` option', () => {
-    new Vue().$mount()
+    new Vue('div').$mount()
     expect('Failed to mount component: template or render function not defined.').toHaveBeenWarned()
   })
 })
diff --git a/test/unit/features/options/renderError.spec.ts b/test/unit/features/options/renderError.spec.ts
index 20a0aa749a2..4b4b04be801 100644
--- a/test/unit/features/options/renderError.spec.ts
+++ b/test/unit/features/options/renderError.spec.ts
@@ -22,7 +22,7 @@ describe('Options renderError', () => {
     vm.ok = false
     waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('Error: no')
-      Vue.config.errorHandler = null
+      Vue.config.errorHandler = undefined
     }).then(done)
   })
 
diff --git a/test/unit/features/ref.spec.ts b/test/unit/features/ref.spec.ts
index 971c8fbe678..880a6ca67c9 100644
--- a/test/unit/features/ref.spec.ts
+++ b/test/unit/features/ref.spec.ts
@@ -1,7 +1,19 @@
 import Vue from 'vue'
 
 describe('ref', () => {
-  const components = {
+  
+  type TestShape = { 
+    id: string,
+    template: string,
+    data?: any
+    components?: any
+  }
+  type ComponentShape = {
+    test: TestShape,
+    test2: TestShape,
+    test3: TestShape,
+  }
+  const components: ComponentShape = {
     test: {
       id: 'test',
       template: '<div>test</div>'
diff --git a/test/unit/global.d.ts b/test/unit/global.d.ts
index 5b7e275071c..8c7cccc51ac 100644
--- a/test/unit/global.d.ts
+++ b/test/unit/global.d.ts
@@ -2,6 +2,10 @@ declare function waitForUpdate(
   cb: Function
 ): any;
 
+declare function createTextVNode(
+  arg?: any
+): any;
+
 declare namespace jasmine {
   interface Matchers<T> {
     toHaveBeenWarned(): void;
@@ -12,7 +16,4 @@ declare namespace jasmine {
     toHaveBeenWarned(): void;
     toHaveBeenTipped(): void;
   }
-}
-
-// @ts-ignore
-declare let global: typeof globalThis;
+}
\ No newline at end of file
diff --git a/test/unit/index.ts b/test/unit/index.js
similarity index 68%
rename from test/unit/index.ts
rename to test/unit/index.js
index 35df6c940ea..19bd294ee78 100644
--- a/test/unit/index.ts
+++ b/test/unit/index.js
@@ -1,3 +1,4 @@
+// NOTE: do not convert this to typescript (or karma will be unhappy)
 require('es6-promise/auto')
 
 // import all helpers
@@ -6,4 +7,4 @@ helpersContext.keys().forEach(helpersContext)
 
 // require all test files
 const testsContext = require.context('./', true, /\.spec$/)
-testsContext.keys().forEach(testsContext)
+testsContext.keys().forEach(testsContext)
\ No newline at end of file
diff --git a/test/unit/karma.base.config.ts b/test/unit/karma.base.config.ts
index d69b77014cd..0d37e02435e 100644
--- a/test/unit/karma.base.config.ts
+++ b/test/unit/karma.base.config.ts
@@ -14,7 +14,9 @@ const webpackConfig = {
       {
         test: /\.tsx?$/,
         exclude: /node_modules/,
-        loader: 'ts-loader',
+        // loader: 'ts-loader',
+        // loader: 'babel-loader!ts-loader',
+        use: ['babel-loader', 'ts-loader']
       },
     ]
   },
@@ -42,11 +44,11 @@ const webpackConfig = {
 module.exports = {
   frameworks: ['jasmine', 'webpack', 'karma-typescript'],
   files: [
-    './index.ts',
+    './index.js',
     "../../src/**/*.ts" // *.tsx for React Jsx
   ],
   preprocessors: {
-    './index.ts': ['webpack', 'sourcemap'],
+    './index.js': ['webpack', 'sourcemap'],
     "**/*.ts": ["karma-typescript", 'webpack', 'sourcemap'] // *.tsx for React Jsx
   },
   webpack: webpackConfig,
@@ -59,5 +61,52 @@ module.exports = {
     'karma-sourcemap-loader',
     'karma-webpack',
     'karma-typescript'
-  ]
+  ],
+  karmaTypescriptConfig: {
+  //   "compilerOptions": {
+  //     "baseUrl": ".",
+  //     "outDir": "dist",
+  //     "sourceMap": true,
+  //     "target": "ESNext",
+  //     "module": "ESNext",
+  //     "moduleResolution": "node",
+  //     "strict": true,
+      
+  //     "allowJs": true,
+  //     "noImplicitAny": false,
+  //     "noImplicitThis": false,
+  
+  //     "noUnusedLocals": true,
+  //     "experimentalDecorators": true,
+  //     "resolveJsonModule": true,
+  //     "esModuleInterop": true,
+  //     "removeComments": false,
+  //     "jsx": "preserve",
+  //     "lib": ["esnext", "dom"],
+  //     "types": [
+  //       "node",
+  //       "jasmine",
+  //       "webpack-env"
+  //     ],
+  //     "paths": {
+  //       "compiler/*": ["../../src/compiler/*"],
+  //       "core/*": ["../../src/core/*"],
+  
+  //       "server/*": ["../../src/server/*"],
+  //       "sfc/*": ["../../src/sfc/*"],
+  //       "shared/*": ["../../src/shared/*"],
+  
+  //       "web/*": ["../../src/platforms/web/*"],
+  //       "weex/*": ["../../src/platforms/weex/*"],
+  
+  //       "vue": ["../../src/platforms/web/entry-runtime-with-compiler"]
+  //     }
+  //   },
+    "include": ["./global.d.ts"],
+  
+  //   "exclude": ["flow", "node_modules", "packages", "types"]
+  // //   bundlerOptions: {
+  // //     transforms: [require("karma-typescript-es6-transform")()]
+  // //   }
+  }
 }
diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index 540be60bc8d..f17d5b535f2 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -14,7 +14,7 @@ describe('Observer', () => {
     const ob1 = observe(1)
     expect(ob1).toBeUndefined()
     // avoid vue instance
-    const ob2 = observe(new Vue())
+    const ob2 = observe(new Vue('div'))
     expect(ob2).toBeUndefined()
     // avoid frozen objects
     const ob3 = observe(Object.freeze({}))
diff --git a/tsconfig.json b/tsconfig.json
index 8090ae4e036..89587580854 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -20,6 +20,7 @@
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
     "types": [
+      "node",
       "jasmine",
       "webpack-env"
     ],
@@ -37,7 +38,7 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "test-dts", "typescript"],
+  "include": ["src", "test-dts", "typescript", "test"],
 
   "exclude": ["flow", "node_modules", "packages", "types"]
 }
diff --git a/types/test/tsconfig.json b/types/tsconfig.json
similarity index 78%
rename from types/test/tsconfig.json
rename to types/tsconfig.json
index 9f66f31aacc..57d9919cc76 100644
--- a/types/test/tsconfig.json
+++ b/types/tsconfig.json
@@ -6,6 +6,11 @@
       "dom",
       "es2015"
     ],
+    "types": [
+      "node",
+      "jasmine",
+      "webpack-env"
+    ],
     "module": "commonjs",
     "strict": true,
     "noEmit": true,
@@ -15,7 +20,7 @@
     },
   },
   "include": [
-    "../*.d.ts",
+    "./*.d.ts",
     "*.ts"
   ],
   "compileOnSave": false
diff --git a/yarn.lock b/yarn.lock
index 83ea16116bd..d17ee146c82 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -22,7 +22,7 @@
   resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.10.tgz#711dc726a492dfc8be8220028b1b92482362baab"
   integrity sha512-GZt/TCsG70Ms19gfZO1tM4CVnXsPgEPBCpJu+Qz3L0LUDsY5nZqFZglIoPC1kIYOtNBZlrnFT+klg12vFGZXrw==
 
-"@babel/core@^7.12.3", "@babel/core@^7.17.10", "@babel/core@^7.7.5":
+"@babel/core@^7.11.1", "@babel/core@^7.12.3", "@babel/core@^7.17.10", "@babel/core@^7.7.5":
   version "7.17.10"
   resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.10.tgz#74ef0fbf56b7dfc3f198fc2d927f4f03e12f4b05"
   integrity sha512-liKoppandF3ZcBnIYFjfSDHZLKdLHGJRkoWtG8zQyGJBQfIYobpnVGI5+pLBNtS6psFLDzyq8+h5HiVljW9PNA==
@@ -795,7 +795,7 @@
     "@babel/helper-create-regexp-features-plugin" "^7.16.7"
     "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/preset-env@^7.17.10":
+"@babel/preset-env@^7.11.0", "@babel/preset-env@^7.17.10":
   version "7.17.10"
   resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.17.10.tgz#a81b093669e3eb6541bb81a23173c5963c5de69c"
   integrity sha512-YNgyBHZQpeoBSRBg0xixsZzfT58Ze1iZrajvv0lJc70qDDGuGfonEnMGfWeSY0mQ3JTuCWFbMkzFRVafOyJx4g==
@@ -913,7 +913,7 @@
   dependencies:
     regenerator-runtime "^0.13.4"
 
-"@babel/template@^7.16.7":
+"@babel/template@7", "@babel/template@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.16.7.tgz#8d126c8701fde4d66b264b3eba3d96f07666d155"
   integrity sha512-I8j/x8kHUrbYRTUxXrrMbfCa7jxkE7tZre39x3kjr9hvI82cK1FfqLygotcWN5kdPGWcLdWMHpSBavse5tWw3w==
@@ -1161,14 +1161,14 @@
     resolve "^1.17.0"
 
 "@rollup/plugin-node-resolve@^13.2.1":
-  version "13.2.1"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-13.2.1.tgz#cdee815cf02c180ff0a42536ca67a8f67e299f84"
-  integrity sha512-btX7kzGvp1JwShQI9V6IM841YKNPYjKCvUbNrQ2EcVYbULtUd/GH6wZ/qdqH13j9pOHBER+EZXNN2L8RSJhVRA==
+  version "13.3.0"
+  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-13.3.0.tgz#da1c5c5ce8316cef96a2f823d111c1e4e498801c"
+  integrity sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==
   dependencies:
     "@rollup/pluginutils" "^3.1.0"
     "@types/resolve" "1.17.1"
-    builtin-modules "^3.1.0"
     deepmerge "^4.2.2"
+    is-builtin-module "^3.1.0"
     is-module "^1.0.0"
     resolve "^1.19.0"
 
@@ -2139,6 +2139,13 @@ babel-plugin-transform-flow-strip-types@^6.8.0:
     babel-plugin-syntax-flow "^6.18.0"
     babel-runtime "^6.22.0"
 
+babel-plugin-transform-require-context@^0.1.1:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/babel-plugin-transform-require-context/-/babel-plugin-transform-require-context-0.1.1.tgz#319b545ca83080b5062776b46cc9b8b346fea9a6"
+  integrity sha512-4ceqYOtzgmq4/QsB8dP7pUrUOCjY/jrRYdt7YkIOWHxtGDQbcf6YZDyLCiPQf6KsEIcIbSQiTRXOsbLiuJfgNQ==
+  dependencies:
+    "@babel/template" "7"
+
 babel-plugin-transform-vue-jsx@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/babel-plugin-transform-vue-jsx/-/babel-plugin-transform-vue-jsx-4.0.1.tgz#2c8bddce87a6ef09eaa59869ff1bfbeeafc5f88d"
@@ -2502,7 +2509,7 @@ buffer@^5.2.1, buffer@^5.4.3, buffer@^5.5.0:
     base64-js "^1.3.1"
     ieee754 "^1.1.13"
 
-builtin-modules@^3.1.0:
+builtin-modules@^3.0.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
   integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
@@ -2594,9 +2601,9 @@ camelcase@^6.0.0, camelcase@^6.2.0:
   integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
 
 caniuse-lite@^1.0.30001332:
-  version "1.0.30001334"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001334.tgz#892e9965b35285033fc2b8a8eff499fe02f13d8b"
-  integrity sha512-kbaCEBRRVSoeNs74sCuq92MJyGrMtjWVfhltoHUCW4t4pXFvGjUBrfo47weBRViHkiV3eBYyIsfl956NtHGazw==
+  version "1.0.30001335"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001335.tgz#899254a0b70579e5a957c32dced79f0727c61f2a"
+  integrity sha512-ddP1Tgm7z2iIxu6QTtbZUv6HJxSaV/PZeSrWFZtbY4JZ69tOeNhBCl3HyRQgeNZKE5AOn1kpV7fhljigy0Ty3w==
 
 capital-case@^1.0.4:
   version "1.0.4"
@@ -3822,11 +3829,6 @@ elliptic@^6.5.3:
     minimalistic-assert "^1.0.1"
     minimalistic-crypto-utils "^1.0.1"
 
-emitter-component@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/emitter-component/-/emitter-component-1.1.1.tgz#065e2dbed6959bf470679edabeaf7981d1003ab6"
-  integrity sha1-Bl4tvtaVm/RwZ57avq95gdEAOrY=
-
 emoji-regex@^8.0.0:
   version "8.0.0"
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
@@ -5367,6 +5369,13 @@ is-boolean-object@^1.1.0:
     call-bind "^1.0.2"
     has-tostringtag "^1.0.0"
 
+is-builtin-module@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-3.1.0.tgz#6fdb24313b1c03b75f8b9711c0feb8c30b903b00"
+  integrity sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==
+  dependencies:
+    builtin-modules "^3.0.0"
+
 is-callable@^1.1.4, is-callable@^1.2.4:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.4.tgz#47301d58dd0259407865547853df6d61fe471945"
@@ -5945,6 +5954,18 @@ karma-sourcemap-loader@^0.3.8:
   dependencies:
     graceful-fs "^4.1.2"
 
+karma-typescript-es6-transform@^5.5.3:
+  version "5.5.3"
+  resolved "https://registry.yarnpkg.com/karma-typescript-es6-transform/-/karma-typescript-es6-transform-5.5.3.tgz#5396da512c20b69d49e3e362a41f250342da5c03"
+  integrity sha512-vB1Cv8z9yxyR2KQuvks5soNKASyS2RPApdMsB3Ad55RqFJeag9G+xyGIwxOdyCHtgOwa4yn1rngMwaN7WBQTbQ==
+  dependencies:
+    "@babel/core" "^7.11.1"
+    "@babel/preset-env" "^7.11.0"
+    acorn "^8.1.0"
+    acorn-walk "^8.0.2"
+    log4js "^6.3.0"
+    magic-string "^0.25.7"
+
 karma-typescript@^5.5.3:
   version "5.5.3"
   resolved "https://registry.yarnpkg.com/karma-typescript/-/karma-typescript-5.5.3.tgz#29c04d9677f8bd78dfacd89e8fa6f475dd25aba2"
@@ -8490,13 +8511,6 @@ stream-http@^3.1.0:
     readable-stream "^3.6.0"
     xtend "^4.0.2"
 
-stream@^0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/stream/-/stream-0.0.2.tgz#7f5363f057f6592c5595f00bc80a27f5cec1f0ef"
-  integrity sha1-f1Nj8Ff2WSxVlfALyAon9c7B8O8=
-  dependencies:
-    emitter-component "^1.1.1"
-
 streamroller@^3.0.8:
   version "3.0.8"
   resolved "https://registry.yarnpkg.com/streamroller/-/streamroller-3.0.8.tgz#84b190e4080ee311ca1ebe0444e30ac8eedd028d"

From e2f1ce06cf1475629900683ae3ebb6927008e9cd Mon Sep 17 00:00:00 2001
From: David Welch <david@davidwelch.co>
Date: Wed, 4 May 2022 15:16:17 -0600
Subject: [PATCH 029/317] chore: cleanup tweaks that would affect JS; rolled
 back packages folder to @pikax output

---
 packages/vue-server-renderer/basic.js         | 14465 +++++++-------
 packages/vue-server-renderer/build.dev.js     | 15869 ++++++++--------
 packages/vue-server-renderer/client-plugin.js |   208 +-
 packages/vue-server-renderer/server-plugin.js |   218 +-
 packages/vue-template-compiler/browser.js     |  8922 ++++-----
 packages/vue-template-compiler/build.js       |  8914 ++++-----
 test/e2e/specs/svg.ts                         |     4 +-
 test/helpers/to-have-been-warned.ts           |     4 +-
 test/helpers/trigger-event.ts                 |     2 +-
 test/helpers/wait-for-update.ts               |     6 +-
 test/ssr/compile-with-webpack.ts              |     3 -
 test/unit/features/debug.spec.ts              |     6 +-
 test/unit/features/error-handling.spec.ts     |     3 +-
 test/unit/features/instance/init.spec.ts      |     6 +-
 .../features/instance/methods-events.spec.ts  |     3 +-
 .../unit/features/instance/properties.spec.ts |     6 +-
 test/unit/features/options/lifecycle.spec.ts  |     3 +-
 test/unit/features/options/render.spec.ts     |     3 +-
 .../features/transition/transition.spec.ts    |     2 +-
 test/unit/modules/observer/observer.spec.ts   |     3 +-
 20 files changed, 24329 insertions(+), 24321 deletions(-)

diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
index 5fe9e2be005..96c1dceb156 100644
--- a/packages/vue-server-renderer/basic.js
+++ b/packages/vue-server-renderer/basic.js
@@ -4,2605 +4,2606 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.renderVueComponentToString = factory());
 })(this, (function () { 'use strict';
 
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$1(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop$1(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys(modules) {
-      return modules
-          .reduce((keys, m) => {
-          return keys.concat(m.staticKeys || []);
-      }, [])
-          .join(',');
-  }
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-
-  const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-      'target,title,usemap,value,width,wrap');
-  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-  const isSSRUnsafeAttr = (name) => {
-      return unsafeAttrCharRE.test(name);
-  };
-  /* istanbul ignore next */
-  const isRenderableAttr = (name) => {
-      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-  };
-  const propsToAttrMap = {
-      acceptCharset: 'accept-charset',
-      className: 'class',
-      htmlFor: 'for',
-      httpEquiv: 'http-equiv',
-  };
-  const ESC = {
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      '&': '&amp;',
-  };
-  function escape(s) {
-      return s.replace(/[<>"&]/g, escapeChar);
-  }
-  function escapeChar(a) {
-      return ESC[a] || a;
-  }
-  const noUnitNumericStyleProps = {
-      'animation-iteration-count': true,
-      'border-image-outset': true,
-      'border-image-slice': true,
-      'border-image-width': true,
-      'box-flex': true,
-      'box-flex-group': true,
-      'box-ordinal-group': true,
-      'column-count': true,
-      columns: true,
-      flex: true,
-      'flex-grow': true,
-      'flex-positive': true,
-      'flex-shrink': true,
-      'flex-negative': true,
-      'flex-order': true,
-      'grid-row': true,
-      'grid-row-end': true,
-      'grid-row-span': true,
-      'grid-row-start': true,
-      'grid-column': true,
-      'grid-column-end': true,
-      'grid-column-span': true,
-      'grid-column-start': true,
-      'font-weight': true,
-      'line-clamp': true,
-      'line-height': true,
-      opacity: true,
-      order: true,
-      orphans: true,
-      'tab-size': true,
-      widows: true,
-      'z-index': true,
-      zoom: true,
-      // SVG
-      'fill-opacity': true,
-      'flood-opacity': true,
-      'stop-opacity': true,
-      'stroke-dasharray': true,
-      'stroke-dashoffset': true,
-      'stroke-miterlimit': true,
-      'stroke-opacity': true,
-      'stroke-width': true,
+  const emptyObject = Object.freeze({});
+  // These helpers produce better VM code in JS engines due to their
+  // explicitness and function inlining.
+  function isUndef(v) {
+      return v === undefined || v === null;
+  }
+  function isDef(v) {
+      return v !== undefined && v !== null;
+  }
+  function isTrue(v) {
+      return v === true;
+  }
+  function isFalse(v) {
+      return v === false;
+  }
+  /**
+   * Check if value is primitive.
+   */
+  function isPrimitive(value) {
+      return (typeof value === 'string' ||
+          typeof value === 'number' ||
+          // $flow-disable-line
+          typeof value === 'symbol' ||
+          typeof value === 'boolean');
+  }
+  /**
+   * Quick object check - this is primarily used to tell
+   * objects from primitive values when we know the value
+   * is a JSON-compliant type.
+   */
+  function isObject(obj) {
+      return obj !== null && typeof obj === 'object';
+  }
+  /**
+   * Get the raw type string of a value, e.g., [object Object].
+   */
+  const _toString = Object.prototype.toString;
+  function toRawType(value) {
+      return _toString.call(value).slice(8, -1);
+  }
+  /**
+   * Strict object type check. Only returns true
+   * for plain JavaScript objects.
+   */
+  function isPlainObject(obj) {
+      return _toString.call(obj) === '[object Object]';
+  }
+  /**
+   * Check if val is a valid array index.
+   */
+  function isValidArrayIndex(val) {
+      const n = parseFloat(String(val));
+      return n >= 0 && Math.floor(n) === n && isFinite(val);
+  }
+  function isPromise(val) {
+      return (isDef(val) &&
+          typeof val.then === 'function' &&
+          typeof val.catch === 'function');
+  }
+  /**
+   * Convert a value to a string that is actually rendered.
+   */
+  function toString(val) {
+      return val == null
+          ? ''
+          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+              ? JSON.stringify(val, null, 2)
+              : String(val);
+  }
+  /**
+   * Convert an input value to a number for persistence.
+   * If the conversion fails, return original string.
+   */
+  function toNumber(val) {
+      const n = parseFloat(val);
+      return isNaN(n) ? val : n;
+  }
+  /**
+   * Make a map and return a function for checking if a key
+   * is in that map.
+   */
+  function makeMap(str, expectsLowerCase) {
+      const map = Object.create(null);
+      const list = str.split(',');
+      for (let i = 0; i < list.length; i++) {
+          map[list[i]] = true;
+      }
+      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+  }
+  /**
+   * Check if a tag is a built-in tag.
+   */
+  const isBuiltInTag = makeMap('slot,component', true);
+  /**
+   * Check if an attribute is a reserved attribute.
+   */
+  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+  /**
+   * Remove an item from an array.
+   */
+  function remove$1(arr, item) {
+      if (arr.length) {
+          const index = arr.indexOf(item);
+          if (index > -1) {
+              return arr.splice(index, 1);
+          }
+      }
+  }
+  /**
+   * Check whether an object has the property.
+   */
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  function hasOwn(obj, key) {
+      return hasOwnProperty.call(obj, key);
+  }
+  /**
+   * Create a cached version of a pure function.
+   */
+  function cached(fn) {
+      const cache = Object.create(null);
+      return function cachedFn(str) {
+          const hit = cache[str];
+          return hit || (cache[str] = fn(str));
+      };
+  }
+  /**
+   * Camelize a hyphen-delimited string.
+   */
+  const camelizeRE = /-(\w)/g;
+  const camelize = cached((str) => {
+      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+  });
+  /**
+   * Capitalize a string.
+   */
+  const capitalize = cached((str) => {
+      return str.charAt(0).toUpperCase() + str.slice(1);
+  });
+  /**
+   * Hyphenate a camelCase string.
+   */
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cached((str) => {
+      return str.replace(hyphenateRE, '-$1').toLowerCase();
+  });
+  /**
+   * Mix properties into target object.
+   */
+  function extend(to, _from) {
+      for (const key in _from) {
+          to[key] = _from[key];
+      }
+      return to;
+  }
+  /**
+   * Merge an Array of Objects into a single Object.
+   */
+  function toObject(arr) {
+      const res = {};
+      for (let i = 0; i < arr.length; i++) {
+          if (arr[i]) {
+              extend(res, arr[i]);
+          }
+      }
+      return res;
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * Perform no operation.
+   * Stubbing args to make Flow happy without leaving useless transpiled code
+   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+   */
+  function noop$1(a, b, c) { }
+  /**
+   * Always return false.
+   */
+  const no = (a, b, c) => false;
+  /* eslint-enable no-unused-vars */
+  /**
+   * Return the same value.
+   */
+  const identity = (_) => _;
+  /**
+   * Generate a string containing static keys from compiler modules.
+   */
+  function genStaticKeys(modules) {
+      return modules
+          .reduce((keys, m) => {
+          return keys.concat(m.staticKeys || []);
+      }, [])
+          .join(',');
+  }
+  /**
+   * Check if two values are loosely equal - that is,
+   * if they are plain objects, do they have the same shape?
+   */
+  function looseEqual(a, b) {
+      if (a === b)
+          return true;
+      const isObjectA = isObject(a);
+      const isObjectB = isObject(b);
+      if (isObjectA && isObjectB) {
+          try {
+              const isArrayA = Array.isArray(a);
+              const isArrayB = Array.isArray(b);
+              if (isArrayA && isArrayB) {
+                  return (a.length === b.length &&
+                      a.every((e, i) => {
+                          return looseEqual(e, b[i]);
+                      }));
+              }
+              else if (a instanceof Date && b instanceof Date) {
+                  return a.getTime() === b.getTime();
+              }
+              else if (!isArrayA && !isArrayB) {
+                  const keysA = Object.keys(a);
+                  const keysB = Object.keys(b);
+                  return (keysA.length === keysB.length &&
+                      keysA.every((key) => {
+                          return looseEqual(a[key], b[key]);
+                      }));
+              }
+              else {
+                  /* istanbul ignore next */
+                  return false;
+              }
+          }
+          catch (e) {
+              /* istanbul ignore next */
+              return false;
+          }
+      }
+      else if (!isObjectA && !isObjectB) {
+          return String(a) === String(b);
+      }
+      else {
+          return false;
+      }
+  }
+  /**
+   * Return the first index at which a loosely equal value can be
+   * found in the array (if value is a plain object, the array must
+   * contain an object of the same shape), or -1 if it is not present.
+   */
+  function looseIndexOf(arr, val) {
+      for (let i = 0; i < arr.length; i++) {
+          if (looseEqual(arr[i], val))
+              return i;
+      }
+      return -1;
+  }
+
+  const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap');
+  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+  const isSSRUnsafeAttr = (name) => {
+      return unsafeAttrCharRE.test(name);
+  };
+  /* istanbul ignore next */
+  const isRenderableAttr = (name) => {
+      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+  };
+  const propsToAttrMap = {
+      acceptCharset: 'accept-charset',
+      className: 'class',
+      htmlFor: 'for',
+      httpEquiv: 'http-equiv',
   };
+  const ESC = {
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      '&': '&amp;',
+  };
+  function escape(s) {
+      return s.replace(/[<>"&]/g, escapeChar);
+  }
+  function escapeChar(a) {
+      return ESC[a] || a;
+  }
+  const noUnitNumericStyleProps = {
+      'animation-iteration-count': true,
+      'border-image-outset': true,
+      'border-image-slice': true,
+      'border-image-width': true,
+      'box-flex': true,
+      'box-flex-group': true,
+      'box-ordinal-group': true,
+      'column-count': true,
+      columns: true,
+      flex: true,
+      'flex-grow': true,
+      'flex-positive': true,
+      'flex-shrink': true,
+      'flex-negative': true,
+      'flex-order': true,
+      'grid-row': true,
+      'grid-row-end': true,
+      'grid-row-span': true,
+      'grid-row-start': true,
+      'grid-column': true,
+      'grid-column-end': true,
+      'grid-column-span': true,
+      'grid-column-start': true,
+      'font-weight': true,
+      'line-clamp': true,
+      'line-height': true,
+      opacity: true,
+      order: true,
+      orphans: true,
+      'tab-size': true,
+      widows: true,
+      'z-index': true,
+      zoom: true,
+      // SVG
+      'fill-opacity': true,
+      'flood-opacity': true,
+      'stop-opacity': true,
+      'stroke-dasharray': true,
+      'stroke-dashoffset': true,
+      'stroke-miterlimit': true,
+      'stroke-opacity': true,
+      'stroke-width': true,
+  };
+
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  makeMap('style,class');
+  // attributes that should be using props for binding
+  const acceptValue = makeMap('input,textarea,option,select,progress');
+  const mustUseProp = (tag, type, attr) => {
+      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+          (attr === 'selected' && tag === 'option') ||
+          (attr === 'checked' && tag === 'input') ||
+          (attr === 'muted' && tag === 'video'));
+  };
+  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+  const convertEnumeratedValue = (key, value) => {
+      return isFalsyAttrValue(value) || value === 'false'
+          ? 'false'
+          : // allow arbitrary string value for contenteditable
+              key === 'contenteditable' && isValidContentEditableValue(value)
+                  ? value
+                  : 'true';
+  };
+  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible');
+  const isFalsyAttrValue = (val) => {
+      return val == null || val === false;
+  };
+
+  function renderAttrs$1(node) {
+      let attrs = node.data.attrs;
+      let res = '';
+      const opts = node.parent && node.parent.componentOptions;
+      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+          let parent = node.parent;
+          while (isDef(parent)) {
+              // Stop fallthrough in case parent has inheritAttrs option set to false
+              if (parent.componentOptions &&
+                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                  break;
+              }
+              if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                  attrs = extend(extend({}, attrs), parent.data.attrs);
+              }
+              parent = parent.parent;
+          }
+      }
+      if (isUndef(attrs)) {
+          return res;
+      }
+      for (const key in attrs) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          if (key === 'style') {
+              // leave it to the style module
+              continue;
+          }
+          res += renderAttr(key, attrs[key]);
+      }
+      return res;
+  }
+  function renderAttr(key, value) {
+      if (isBooleanAttr(key)) {
+          if (!isFalsyAttrValue(value)) {
+              return ` ${key}="${key}"`;
+          }
+      }
+      else if (isEnumeratedAttr(key)) {
+          return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
+      }
+      else if (!isFalsyAttrValue(value)) {
+          return ` ${key}="${escape(String(value))}"`;
+      }
+      return '';
+  }
+
+  class VNode {
+      tag;
+      data;
+      children;
+      text;
+      elm;
+      ns;
+      context; // rendered in this component's scope
+      key;
+      componentOptions;
+      componentInstance; // component instance
+      parent; // component placeholder node
+      // strictly internal
+      raw; // contains raw HTML? (server only)
+      isStatic; // hoisted static node
+      isRootInsert; // necessary for enter transition check
+      isComment; // empty comment placeholder?
+      isCloned; // is a cloned node?
+      isOnce; // is a v-once node?
+      asyncFactory; // async component factory function
+      asyncMeta;
+      isAsyncPlaceholder;
+      ssrContext;
+      fnContext; // real context vm for functional nodes
+      fnOptions; // for SSR caching
+      devtoolsMeta; // used to store functional render context for devtools
+      fnScopeId; // functional scope id support
+      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+          this.tag = tag;
+          this.data = data;
+          this.children = children;
+          this.text = text;
+          this.elm = elm;
+          this.ns = undefined;
+          this.context = context;
+          this.fnContext = undefined;
+          this.fnOptions = undefined;
+          this.fnScopeId = undefined;
+          this.key = data && data.key;
+          this.componentOptions = componentOptions;
+          this.componentInstance = undefined;
+          this.parent = undefined;
+          this.raw = false;
+          this.isStatic = false;
+          this.isRootInsert = true;
+          this.isComment = false;
+          this.isCloned = false;
+          this.isOnce = false;
+          this.asyncFactory = asyncFactory;
+          this.asyncMeta = undefined;
+          this.isAsyncPlaceholder = false;
+      }
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get child() {
+          return this.componentInstance;
+      }
+  }
+  const createEmptyVNode = (text = "") => {
+      const node = new VNode();
+      node.text = text;
+      node.isComment = true;
+      return node;
+  };
+  function createTextVNode(val) {
+      return new VNode(undefined, undefined, undefined, String(val));
+  }
+  // optimized shallow clone
+  // used for static nodes and slot nodes because they may be reused across
+  // multiple renders, cloning them avoids errors when DOM manipulations rely
+  // on their elm reference.
+  function cloneVNode(vnode) {
+      const cloned = new VNode(vnode.tag, vnode.data, 
+      // #7975
+      // clone children array to avoid mutating original in case of cloning
+      // a child.
+      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+      cloned.ns = vnode.ns;
+      cloned.isStatic = vnode.isStatic;
+      cloned.key = vnode.key;
+      cloned.isComment = vnode.isComment;
+      cloned.fnContext = vnode.fnContext;
+      cloned.fnOptions = vnode.fnOptions;
+      cloned.fnScopeId = vnode.fnScopeId;
+      cloned.asyncMeta = vnode.asyncMeta;
+      cloned.isCloned = true;
+      return cloned;
+  }
 
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
+  function renderDOMProps$1(node) {
+      let props = node.data.domProps;
+      let res = '';
+      let parent = node.parent;
+      while (isDef(parent)) {
+          if (parent.data && parent.data.domProps) {
+              props = extend(extend({}, props), parent.data.domProps);
+          }
+          parent = parent.parent;
+      }
+      if (isUndef(props)) {
+          return res;
+      }
+      const attrs = node.data.attrs;
+      for (const key in props) {
+          if (key === 'innerHTML') {
+              setText(node, props[key], true);
+          }
+          else if (key === 'textContent') {
+              setText(node, props[key], false);
+          }
+          else if (key === 'value' && node.tag === 'textarea') {
+              setText(node, toString(props[key]), false);
+          }
+          else {
+              // $flow-disable-line (WTF?)
+              const attr = propsToAttrMap[key] || key.toLowerCase();
+              if (isRenderableAttr(attr) &&
+                  // avoid rendering double-bound props/attrs twice
+                  !(isDef(attrs) && isDef(attrs[attr]))) {
+                  res += renderAttr(attr, props[key]);
+              }
+          }
+      }
+      return res;
+  }
+  function setText(node, text, raw) {
+      const child = new VNode(undefined, undefined, undefined, text);
+      child.raw = raw;
+      node.children = [child];
+  }
+
+  /**
+   * unicode letters used for parsing html tags, component names and property paths.
+   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+   */
+  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+  /**
+   * Define a property.
+   */
+  function def(obj, key, val, enumerable) {
+      Object.defineProperty(obj, key, {
+          value: val,
+          enumerable: !!enumerable,
+          writable: true,
+          configurable: true,
+      });
+  }
+
+  // can we use __proto__?
+  const hasProto = '__proto__' in {};
+  // Browser environment sniffing
+  const inBrowser = typeof window !== 'undefined';
+  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+  const isIE = UA && /msie|trident/.test(UA);
+  UA && UA.indexOf('msie 9.0') > 0;
+  const isEdge = UA && UA.indexOf('edge/') > 0;
+  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+  UA && /chrome\/\d+/.test(UA) && !isEdge;
+  UA && /phantomjs/.test(UA);
+  UA && UA.match(/firefox\/(\d+)/);
+  // Firefox has a "watch" function on Object.prototype...
+  // @ts-expect-error firebox support
+  const nativeWatch = {}.watch;
+  let supportsPassive = false;
+  if (inBrowser) {
+      try {
+          const opts = {};
+          Object.defineProperty(opts, 'passive', {
+              get() {
+                  /* istanbul ignore next */
+                  supportsPassive = true;
+              },
+          }); // https://github.com/facebook/flow/issues/285
+          window.addEventListener('test-passive', null, opts);
+      }
+      catch (e) { }
+  }
+  // this needs to be lazy-evaled because vue may be required before
+  // vue-server-renderer can set VUE_ENV
+  let _isServer;
+  const isServerRendering = () => {
+      if (_isServer === undefined) {
+          /* istanbul ignore if */
+          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+              // detect presence of vue-server-renderer and avoid
+              // Webpack shimming the process
+              _isServer =
+                  global['process'] && global['process'].env.VUE_ENV === 'server';
+          }
+          else {
+              _isServer = false;
+          }
+      }
+      return _isServer;
   };
+  /* istanbul ignore next */
+  function isNative(Ctor) {
+      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+  }
+  const hasSymbol = typeof Symbol !== 'undefined' &&
+      isNative(Symbol) &&
+      typeof Reflect !== 'undefined' &&
+      isNative(Reflect.ownKeys);
+  let _Set; // $flow-disable-line
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+      // use native Set when available.
+      _Set = Set;
+  }
+  else {
+      // a non-standard Set polyfill that only works with primitive keys.
+      _Set = class Set {
+          set = Object.create(null);
+          has(key) {
+              return this.set[key] === true;
+          }
+          add(key) {
+              this.set[key] = true;
+          }
+          clear() {
+              this.set = Object.create(null);
+          }
+      };
+  }
 
-  function renderAttrs$1(node) {
-      let attrs = node.data.attrs;
-      let res = '';
-      const opts = node.parent && node.parent.componentOptions;
-      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-          let parent = node.parent;
-          while (isDef(parent)) {
-              // Stop fallthrough in case parent has inheritAttrs option set to false
-              if (parent.componentOptions &&
-                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
-                  break;
-              }
-              if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                  attrs = extend(extend({}, attrs), parent.data.attrs);
-              }
-              parent = parent.parent;
-          }
-      }
-      if (isUndef(attrs)) {
-          return res;
-      }
-      for (const key in attrs) {
-          if (isSSRUnsafeAttr(key)) {
-              continue;
-          }
-          if (key === 'style') {
-              // leave it to the style module
-              continue;
-          }
-          res += renderAttr(key, attrs[key]);
-      }
-      return res;
-  }
-  function renderAttr(key, value) {
-      if (isBooleanAttr(key)) {
-          if (!isFalsyAttrValue(value)) {
-              return ` ${key}="${key}"`;
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
-      }
-      else if (!isFalsyAttrValue(value)) {
-          return ` ${key}="${escape(String(value))}"`;
-      }
-      return '';
-  }
-
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
-  }
-
-  function renderDOMProps$1(node) {
-      let props = node.data.domProps;
-      let res = '';
-      let parent = node.parent;
-      while (isDef(parent)) {
-          if (parent.data && parent.data.domProps) {
-              props = extend(extend({}, props), parent.data.domProps);
-          }
-          parent = parent.parent;
-      }
-      if (isUndef(props)) {
-          return res;
-      }
-      const attrs = node.data.attrs;
-      for (const key in props) {
-          if (key === 'innerHTML') {
-              setText(node, props[key], true);
-          }
-          else if (key === 'textContent') {
-              setText(node, props[key], false);
-          }
-          else if (key === 'value' && node.tag === 'textarea') {
-              setText(node, toString(props[key]), false);
-          }
-          else {
-              // $flow-disable-line (WTF?)
-              const attr = propsToAttrMap[key] || key.toLowerCase();
-              if (isRenderableAttr(attr) &&
-                  // avoid rendering double-bound props/attrs twice
-                  !(isDef(attrs) && isDef(attrs[attr]))) {
-                  res += renderAttr(attr, props[key]);
-              }
-          }
-      }
-      return res;
-  }
-  function setText(node, text, raw) {
-      const child = new VNode(undefined, undefined, undefined, text);
-      child.raw = raw;
-      node.children = [child];
-  }
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
-  };
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
-  }
-
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
+  const SSR_ATTR = 'data-server-rendered';
+  const ASSET_TYPES = ['component', 'directive', 'filter'];
+  const LIFECYCLE_HOOKS = [
+      'beforeCreate',
+      'created',
+      'beforeMount',
+      'mounted',
+      'beforeUpdate',
+      'updated',
+      'beforeDestroy',
+      'destroyed',
+      'activated',
+      'deactivated',
+      'errorCaptured',
+      'serverPrefetch',
   ];
 
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop$1,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
+  var config = {
+      /**
+       * Option merge strategies (used in core/util/options)
+       */
+      // $flow-disable-line
+      optionMergeStrategies: Object.create(null),
+      /**
+       * Whether to suppress warnings.
+       */
+      silent: false,
+      /**
+       * Show production mode tip message on boot?
+       */
+      productionTip: "development" !== 'production',
+      /**
+       * Whether to enable devtools
+       */
+      devtools: "development" !== 'production',
+      /**
+       * Whether to record perf
+       */
+      performance: false,
+      /**
+       * Error handler for watcher errors
+       */
+      errorHandler: null,
+      /**
+       * Warn handler for watcher warns
+       */
+      warnHandler: null,
+      /**
+       * Ignore certain custom elements
+       */
+      ignoredElements: [],
+      /**
+       * Custom user key aliases for v-on
+       */
+      // $flow-disable-line
+      keyCodes: Object.create(null),
+      /**
+       * Check if a tag is reserved so that it cannot be registered as a
+       * component. This is platform-dependent and may be overwritten.
+       */
+      isReservedTag: no,
+      /**
+       * Check if an attribute is reserved so that it cannot be used as a component
+       * prop. This is platform-dependent and may be overwritten.
+       */
+      isReservedAttr: no,
+      /**
+       * Check if a tag is an unknown element.
+       * Platform-dependent.
+       */
+      isUnknownElement: no,
+      /**
+       * Get the namespace of an element
+       */
+      getTagNamespace: noop$1,
+      /**
+       * Parse the real tag name for the specific platform.
+       */
+      parsePlatformTagName: identity,
+      /**
+       * Check if an attribute must be bound using property, e.g. value
+       * Platform-dependent.
+       */
+      mustUseProp: no,
+      /**
+       * Perform updates asynchronously. Intended to be used by Vue Test Utils
+       * This will significantly reduce performance if set to false.
+       */
+      async: true,
+      /**
+       * Exposed for legacy reasons
+       */
+      _lifecycleHooks: LIFECYCLE_HOOKS,
   };
 
-  let warn$2 = noop$1;
-  let tip = noop$1;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn$2 = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
-  }
-
-  let uid = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$1(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
+  let warn$2 = noop$1;
+  let tip = noop$1;
+  let generateComponentTrace; // work around flow check
+  let formatComponentName;
+  {
+      const hasConsole = typeof console !== 'undefined';
+      const classifyRE = /(?:^|[-_])(\w)/g;
+      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+      warn$2 = (msg, vm) => {
+          const trace = vm ? generateComponentTrace(vm) : '';
+          if (hasConsole && !config.silent) {
+              console.error(`[Vue warn]: ${msg}${trace}`);
+          }
+      };
+      tip = (msg, vm) => {
+          if (hasConsole && !config.silent) {
+              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+          }
+      };
+      formatComponentName = (vm, includeFile) => {
+          if (vm.$root === vm) {
+              return '<Root>';
+          }
+          const options = typeof vm === 'function' && vm.cid != null
+              ? vm.options
+              : vm._isVue
+                  ? vm.$options || vm.constructor.options
+                  : vm;
+          let name = options.name || options._componentTag;
+          const file = options.__file;
+          if (!name && file) {
+              const match = file.match(/([^/\\]+)\.vue$/);
+              name = match && match[1];
+          }
+          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+              (file && includeFile !== false ? ` at ${file}` : ''));
+      };
+      const repeat = (str, n) => {
+          let res = '';
+          while (n) {
+              if (n % 2 === 1)
+                  res += str;
+              if (n > 1)
+                  str += str;
+              n >>= 1;
+          }
+          return res;
+      };
+      generateComponentTrace = (vm) => {
+          if (vm._isVue && vm.$parent) {
+              const tree = [];
+              let currentRecursiveSequence = 0;
+              while (vm) {
+                  if (tree.length > 0) {
+                      const last = tree[tree.length - 1];
+                      if (last.constructor === vm.constructor) {
+                          currentRecursiveSequence++;
+                          vm = vm.$parent;
+                          continue;
+                      }
+                      else if (currentRecursiveSequence > 0) {
+                          tree[tree.length - 1] = [last, currentRecursiveSequence];
+                          currentRecursiveSequence = 0;
+                      }
+                  }
+                  tree.push(vm);
+                  vm = vm.$parent;
+              }
+              return ('\n\nfound in\n\n' +
+                  tree
+                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                      .join('\n'));
+          }
+          else {
+              return `\n\n(found in ${formatComponentName(vm)})`;
+          }
+      };
+  }
+
+  let uid = 0;
+  /**
+   * A dep is an observable that can have multiple
+   * directives subscribing to it.
+   */
+  class Dep {
+      static target;
+      id;
+      subs;
+      constructor() {
+          this.id = uid++;
+          this.subs = [];
+      }
+      addSub(sub) {
+          this.subs.push(sub);
+      }
+      removeSub(sub) {
+          remove$1(this.subs, sub);
+      }
+      depend() {
+          if (Dep.target) {
+              Dep.target.addDep(this);
+          }
+      }
+      notify() {
+          // stabilize the subscriber list first
+          const subs = this.subs.slice();
+          for (let i = 0, l = subs.length; i < l; i++) {
+              subs[i].update();
+          }
+      }
+  }
+  // The current target watcher being evaluated.
+  // This is globally unique because only one watcher
+  // can be evaluated at a time.
+  Dep.target = null;
+  const targetStack = [];
+  function pushTarget(target) {
+      targetStack.push(target);
+      Dep.target = target;
+  }
+  function popTarget() {
+      targetStack.pop();
+      Dep.target = targetStack[targetStack.length - 1];
+  }
+
+  /*
+   * not type checking this file because flow doesn't play well with
+   * dynamically accessing methods on Array prototype
+   */
+  const arrayProto = Array.prototype;
+  const arrayMethods = Object.create(arrayProto);
+  const methodsToPatch = [
+      'push',
+      'pop',
+      'shift',
+      'unshift',
+      'splice',
+      'sort',
+      'reverse',
+  ];
+  /**
+   * Intercept mutating methods and emit events
+   */
+  methodsToPatch.forEach(function (method) {
+      // cache original method
+      const original = arrayProto[method];
+      def(arrayMethods, method, function mutator(...args) {
+          const result = original.apply(this, args);
+          const ob = this.__ob__;
+          let inserted;
+          switch (method) {
+              case 'push':
+              case 'unshift':
+                  inserted = args;
+                  break;
+              case 'splice':
+                  inserted = args.slice(2);
+                  break;
+          }
+          if (inserted)
+              ob.observeArray(inserted);
+          // notify change
+          ob.dep.notify();
+          return result;
+      });
+  });
+
+  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+  /**
+   * In some cases we may want to disable observation inside a component's
+   * update computation.
+   */
+  let shouldObserve = true;
+  function toggleObserving(value) {
+      shouldObserve = value;
+  }
+  /**
+   * Observer class that is attached to each observed
+   * object. Once attached, the observer converts the target
+   * object's property keys into getter/setters that
+   * collect dependencies and dispatch updates.
+   */
+  class Observer {
+      value;
+      dep;
+      vmCount; // number of vms that have this object as root $data
+      constructor(value) {
+          this.value = value;
+          this.dep = new Dep();
+          this.vmCount = 0;
+          def(value, '__ob__', this);
+          if (Array.isArray(value)) {
+              if (hasProto) {
+                  protoAugment(value, arrayMethods);
+              }
+              else {
+                  copyAugment(value, arrayMethods, arrayKeys);
+              }
+              this.observeArray(value);
+          }
+          else {
+              this.walk(value);
+          }
+      }
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      walk(obj) {
+          const keys = Object.keys(obj);
+          for (let i = 0; i < keys.length; i++) {
+              defineReactive(obj, keys[i]);
+          }
+      }
+      /**
+       * Observe a list of Array items.
+       */
+      observeArray(items) {
+          for (let i = 0, l = items.length; i < l; i++) {
+              observe(items[i]);
+          }
+      }
+  }
+  // helpers
+  /**
+   * Augment a target Object or Array by intercepting
+   * the prototype chain using __proto__
+   */
+  function protoAugment(target, src) {
+      /* eslint-disable no-proto */
+      target.__proto__ = src;
+      /* eslint-enable no-proto */
+  }
+  /**
+   * Augment a target Object or Array by defining
+   * hidden properties.
+   */
+  /* istanbul ignore next */
+  function copyAugment(target, src, keys) {
+      for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
+          def(target, key, src[key]);
+      }
+  }
+  /**
+   * Attempt to create an observer instance for a value,
+   * returns the new observer if successfully observed,
+   * or the existing observer if the value already has one.
+   */
+  function observe(value, asRootData) {
+      if (!isObject(value) || value instanceof VNode) {
+          return;
+      }
+      let ob;
+      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+          ob = value.__ob__;
+      }
+      else if (shouldObserve &&
+          !isServerRendering() &&
+          (Array.isArray(value) || isPlainObject(value)) &&
+          Object.isExtensible(value) &&
+          !value._isVue) {
+          ob = new Observer(value);
+      }
+      if (asRootData && ob) {
+          ob.vmCount++;
+      }
+      return ob;
+  }
+  /**
+   * Define a reactive property on an Object.
+   */
+  function defineReactive(obj, key, val, customSetter, shallow) {
+      const dep = new Dep();
+      const property = Object.getOwnPropertyDescriptor(obj, key);
+      if (property && property.configurable === false) {
+          return;
+      }
+      // cater for pre-defined getter/setters
+      const getter = property && property.get;
+      const setter = property && property.set;
+      if ((!getter || setter) && arguments.length === 2) {
+          val = obj[key];
+      }
+      let childOb = !shallow && observe(val);
+      Object.defineProperty(obj, key, {
+          enumerable: true,
+          configurable: true,
+          get: function reactiveGetter() {
+              const value = getter ? getter.call(obj) : val;
+              if (Dep.target) {
+                  dep.depend();
+                  if (childOb) {
+                      childOb.dep.depend();
+                      if (Array.isArray(value)) {
+                          dependArray(value);
+                      }
+                  }
+              }
+              return value;
+          },
+          set: function reactiveSetter(newVal) {
+              const value = getter ? getter.call(obj) : val;
+              /* eslint-disable no-self-compare */
+              if (newVal === value || (newVal !== newVal && value !== value)) {
+                  return;
+              }
+              /* eslint-enable no-self-compare */
+              if (customSetter) {
+                  customSetter();
+              }
+              // #7981: for accessor properties without setter
+              if (getter && !setter)
+                  return;
+              if (setter) {
+                  setter.call(obj, newVal);
+              }
+              else {
+                  val = newVal;
+              }
+              childOb = !shallow && observe(newVal);
+              dep.notify();
+          },
+      });
+  }
+  /**
+   * Set a property on an object. Adds the new property and
+   * triggers change notification if the property doesn't
+   * already exist.
+   */
+  function set(target, key, val) {
+      if ((isUndef(target) || isPrimitive(target))) {
+          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+      }
+      if (Array.isArray(target) && isValidArrayIndex(key)) {
+          target.length = Math.max(target.length, key);
+          target.splice(key, 1, val);
+          return val;
+      }
+      if (key in target && !(key in Object.prototype)) {
+          target[key] = val;
+          return val;
+      }
+      const ob = target.__ob__;
+      if (target._isVue || (ob && ob.vmCount)) {
+          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                  'at runtime - declare it upfront in the data option.');
+          return val;
+      }
+      if (!ob) {
+          target[key] = val;
+          return val;
+      }
+      defineReactive(ob.value, key, val);
+      ob.dep.notify();
+      return val;
+  }
+  /**
+   * Collect dependencies on array elements when the array is touched, since
+   * we cannot intercept array element access like property getters.
+   */
+  function dependArray(value) {
+      for (let e, i = 0, l = value.length; i < l; i++) {
+          e = value[i];
+          e && e.__ob__ && e.__ob__.dep.depend();
+          if (Array.isArray(e)) {
+              dependArray(e);
+          }
+      }
+  }
+
+  /**
+   * Option overwriting strategies are functions that handle
+   * how to merge a parent option value and a child option
+   * value into the final value.
+   */
+  const strats = config.optionMergeStrategies;
+  /**
+   * Options with restrictions
+   */
+  {
+      strats.el = strats.propsData = function (parent, child, vm, key) {
+          if (!vm) {
+              warn$2(`option "${key}" can only be used during instance ` +
+                  'creation with the `new` keyword.');
+          }
+          return defaultStrat(parent, child);
+      };
+  }
+  /**
+   * Helper that recursively merges two data objects together.
+   */
+  function mergeData(to, from) {
+      if (!from)
+          return to;
+      let key, toVal, fromVal;
+      const keys = hasSymbol
+          ? Reflect.ownKeys(from)
+          : Object.keys(from);
+      for (let i = 0; i < keys.length; i++) {
+          key = keys[i];
+          // in case the object is already observed...
+          if (key === '__ob__')
+              continue;
+          toVal = to[key];
+          fromVal = from[key];
+          if (!hasOwn(to, key)) {
+              set(to, key, fromVal);
+          }
+          else if (toVal !== fromVal &&
+              isPlainObject(toVal) &&
+              isPlainObject(fromVal)) {
+              mergeData(toVal, fromVal);
+          }
+      }
+      return to;
+  }
+  /**
+   * Data
+   */
+  function mergeDataOrFn(parentVal, childVal, vm) {
+      if (!vm) {
+          // in a Vue.extend merge, both should be functions
+          if (!childVal) {
+              return parentVal;
+          }
+          if (!parentVal) {
+              return childVal;
+          }
+          // when parentVal & childVal are both present,
+          // we need to return a function that returns the
+          // merged result of both functions... no need to
+          // check if parentVal is a function here because
+          // it has to be a function to pass previous merges.
+          return function mergedDataFn() {
+              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+          };
+      }
+      else {
+          return function mergedInstanceDataFn() {
+              // instance merge
+              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+              if (instanceData) {
+                  return mergeData(instanceData, defaultData);
+              }
+              else {
+                  return defaultData;
+              }
+          };
+      }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+      if (!vm) {
+          if (childVal && typeof childVal !== 'function') {
+              warn$2('The "data" option should be a function ' +
+                      'that returns a per-instance value in component ' +
+                      'definitions.', vm);
+              return parentVal;
+          }
+          return mergeDataOrFn(parentVal, childVal);
+      }
+      return mergeDataOrFn(parentVal, childVal, vm);
+  };
+  /**
+   * Hooks and props are merged as arrays.
+   */
+  function mergeHook$1(parentVal, childVal) {
+      const res = childVal
+          ? parentVal
+              ? parentVal.concat(childVal)
+              : Array.isArray(childVal)
+                  ? childVal
+                  : [childVal]
+          : parentVal;
+      return res ? dedupeHooks(res) : res;
+  }
+  function dedupeHooks(hooks) {
+      const res = [];
+      for (let i = 0; i < hooks.length; i++) {
+          if (res.indexOf(hooks[i]) === -1) {
+              res.push(hooks[i]);
+          }
+      }
+      return res;
+  }
+  LIFECYCLE_HOOKS.forEach((hook) => {
+      strats[hook] = mergeHook$1;
   });
+  /**
+   * Assets
+   *
+   * When a vm is present (instance creation), we need to do
+   * a three-way merge between constructor options, instance
+   * options and parent options.
+   */
+  function mergeAssets(parentVal, childVal, vm, key) {
+      const res = Object.create(parentVal || null);
+      if (childVal) {
+          assertObjectType(key, childVal, vm);
+          return extend(res, childVal);
+      }
+      else {
+          return res;
+      }
+  }
+  ASSET_TYPES.forEach(function (type) {
+      strats[type + 's'] = mergeAssets;
+  });
+  /**
+   * Watchers.
+   *
+   * Watchers hashes should not overwrite one
+   * another, so we merge them as arrays.
+   */
+  strats.watch = function (parentVal, childVal, vm, key) {
+      // work around Firefox's Object.prototype.watch...
+      //@ts-expect-error work around
+      if (parentVal === nativeWatch)
+          parentVal = undefined;
+      //@ts-expect-error work around
+      if (childVal === nativeWatch)
+          childVal = undefined;
+      /* istanbul ignore if */
+      if (!childVal)
+          return Object.create(parentVal || null);
+      {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = {};
+      extend(ret, parentVal);
+      for (const key in childVal) {
+          let parent = ret[key];
+          const child = childVal[key];
+          if (parent && !Array.isArray(parent)) {
+              parent = [parent];
+          }
+          ret[key] = parent
+              ? parent.concat(child)
+              : Array.isArray(child)
+                  ? child
+                  : [child];
+      }
+      return ret;
+  };
+  /**
+   * Other object hashes.
+   */
+  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+      if (childVal && "development" !== 'production') {
+          assertObjectType(key, childVal, vm);
+      }
+      if (!parentVal)
+          return childVal;
+      const ret = Object.create(null);
+      extend(ret, parentVal);
+      if (childVal)
+          extend(ret, childVal);
+      return ret;
+  };
+  strats.provide = mergeDataOrFn;
+  /**
+   * Default strategy.
+   */
+  const defaultStrat = function (parentVal, childVal) {
+      return childVal === undefined ? parentVal : childVal;
+  };
+  /**
+   * Validate component names
+   */
+  function checkComponents(options) {
+      for (const key in options.components) {
+          validateComponentName(key);
+      }
+  }
+  function validateComponentName(name) {
+      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+          warn$2('Invalid component name: "' +
+              name +
+              '". Component names ' +
+              'should conform to valid custom element name in html5 specification.');
+      }
+      if (isBuiltInTag(name) || config.isReservedTag(name)) {
+          warn$2('Do not use built-in or reserved HTML elements as component ' +
+              'id: ' +
+              name);
+      }
+  }
+  /**
+   * Ensure all props option syntax are normalized into the
+   * Object-based format.
+   */
+  function normalizeProps(options, vm) {
+      const props = options.props;
+      if (!props)
+          return;
+      const res = {};
+      let i, val, name;
+      if (Array.isArray(props)) {
+          i = props.length;
+          while (i--) {
+              val = props[i];
+              if (typeof val === 'string') {
+                  name = camelize(val);
+                  res[name] = { type: null };
+              }
+              else {
+                  warn$2('props must be strings when using array syntax.');
+              }
+          }
+      }
+      else if (isPlainObject(props)) {
+          for (const key in props) {
+              val = props[key];
+              name = camelize(key);
+              res[name] = isPlainObject(val) ? val : { type: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+              `but got ${toRawType(props)}.`, vm);
+      }
+      options.props = res;
+  }
+  /**
+   * Normalize all injections into Object-based format
+   */
+  function normalizeInject(options, vm) {
+      const inject = options.inject;
+      if (!inject)
+          return;
+      const normalized = (options.inject = {});
+      if (Array.isArray(inject)) {
+          for (let i = 0; i < inject.length; i++) {
+              normalized[inject[i]] = { from: inject[i] };
+          }
+      }
+      else if (isPlainObject(inject)) {
+          for (const key in inject) {
+              const val = inject[key];
+              normalized[key] = isPlainObject(val)
+                  ? extend({ from: key }, val)
+                  : { from: val };
+          }
+      }
+      else {
+          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+              `but got ${toRawType(inject)}.`, vm);
+      }
+  }
+  /**
+   * Normalize raw function directives into object format.
+   */
+  function normalizeDirectives(options) {
+      const dirs = options.directives;
+      if (dirs) {
+          for (const key in dirs) {
+              const def = dirs[key];
+              if (typeof def === 'function') {
+                  dirs[key] = { bind: def, update: def };
+              }
+          }
+      }
+  }
+  function assertObjectType(name, value, vm) {
+      if (!isPlainObject(value)) {
+          warn$2(`Invalid value for option "${name}": expected an Object, ` +
+              `but got ${toRawType(value)}.`, vm);
+      }
+  }
+  /**
+   * Merge two option objects into a new one.
+   * Core utility used in both instantiation and inheritance.
+   */
+  function mergeOptions(parent, child, vm) {
+      {
+          checkComponents(child);
+      }
+      if (typeof child === 'function') {
+          // @ts-expect-error
+          child = child.options;
+      }
+      normalizeProps(child, vm);
+      normalizeInject(child, vm);
+      normalizeDirectives(child);
+      // Apply extends and mixins on the child options,
+      // but only if it is a raw options object that isn't
+      // the result of another mergeOptions call.
+      // Only merged options has the _base property.
+      if (!child._base) {
+          if (child.extends) {
+              parent = mergeOptions(parent, child.extends, vm);
+          }
+          if (child.mixins) {
+              for (let i = 0, l = child.mixins.length; i < l; i++) {
+                  parent = mergeOptions(parent, child.mixins[i], vm);
+              }
+          }
+      }
+      const options = {};
+      let key;
+      for (key in parent) {
+          mergeField(key);
+      }
+      for (key in child) {
+          if (!hasOwn(parent, key)) {
+              mergeField(key);
+          }
+      }
+      function mergeField(key) {
+          const strat = strats[key] || defaultStrat;
+          options[key] = strat(parent[key], child[key], vm, key);
+      }
+      return options;
+  }
+  /**
+   * Resolve an asset.
+   * This function is used because child instances need access
+   * to assets defined in its ancestor chain.
+   */
+  function resolveAsset(options, type, id, warnMissing) {
+      /* istanbul ignore if */
+      if (typeof id !== 'string') {
+          return;
+      }
+      const assets = options[type];
+      // check local registration variations first
+      if (hasOwn(assets, id))
+          return assets[id];
+      const camelizedId = camelize(id);
+      if (hasOwn(assets, camelizedId))
+          return assets[camelizedId];
+      const PascalCaseId = capitalize(camelizedId);
+      if (hasOwn(assets, PascalCaseId))
+          return assets[PascalCaseId];
+      // fallback to prototype chain
+      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+      if (warnMissing && !res) {
+          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+      }
+      return res;
+  }
+
+  function validateProp(key, propOptions, propsData, vm) {
+      const prop = propOptions[key];
+      const absent = !hasOwn(propsData, key);
+      let value = propsData[key];
+      // boolean casting
+      const booleanIndex = getTypeIndex(Boolean, prop.type);
+      if (booleanIndex > -1) {
+          if (absent && !hasOwn(prop, 'default')) {
+              value = false;
+          }
+          else if (value === '' || value === hyphenate(key)) {
+              // only cast empty string / same name to boolean if
+              // boolean has higher priority
+              const stringIndex = getTypeIndex(String, prop.type);
+              if (stringIndex < 0 || booleanIndex < stringIndex) {
+                  value = true;
+              }
+          }
+      }
+      // check default value
+      if (value === undefined) {
+          value = getPropDefaultValue(vm, prop, key);
+          // since the default value is a fresh copy,
+          // make sure to observe it.
+          const prevShouldObserve = shouldObserve;
+          toggleObserving(true);
+          observe(value);
+          toggleObserving(prevShouldObserve);
+      }
+      {
+          assertProp(prop, key, value, vm, absent);
+      }
+      return value;
+  }
+  /**
+   * Get the default value of a prop.
+   */
+  function getPropDefaultValue(vm, prop, key) {
+      // no default, return undefined
+      if (!hasOwn(prop, 'default')) {
+          return undefined;
+      }
+      const def = prop.default;
+      // warn against non-factory defaults for Object & Array
+      if (isObject(def)) {
+          warn$2('Invalid default value for prop "' +
+              key +
+              '": ' +
+              'Props with type Object/Array must use a factory function ' +
+              'to return the default value.', vm);
+      }
+      // the raw prop value was also undefined from previous render,
+      // return previous default value to avoid unnecessary watcher trigger
+      if (vm &&
+          vm.$options.propsData &&
+          vm.$options.propsData[key] === undefined &&
+          vm._props[key] !== undefined) {
+          return vm._props[key];
+      }
+      // call factory function for non-Function types
+      // a value is Function if its prototype is function even across different execution context
+      return typeof def === 'function' && getType(prop.type) !== 'Function'
+          ? def.call(vm)
+          : def;
+  }
+  /**
+   * Assert whether a prop is valid.
+   */
+  function assertProp(prop, name, value, vm, absent) {
+      if (prop.required && absent) {
+          warn$2('Missing required prop: "' + name + '"', vm);
+          return;
+      }
+      if (value == null && !prop.required) {
+          return;
+      }
+      let type = prop.type;
+      let valid = !type || type === true;
+      const expectedTypes = [];
+      if (type) {
+          if (!Array.isArray(type)) {
+              type = [type];
+          }
+          for (let i = 0; i < type.length && !valid; i++) {
+              const assertedType = assertType(value, type[i], vm);
+              expectedTypes.push(assertedType.expectedType || '');
+              valid = assertedType.valid;
+          }
+      }
+      const haveExpectedTypes = expectedTypes.some((t) => t);
+      if (!valid && haveExpectedTypes) {
+          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+          return;
+      }
+      const validator = prop.validator;
+      if (validator) {
+          if (!validator(value)) {
+              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+          }
+      }
+  }
+  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+  function assertType(value, type, vm) {
+      let valid;
+      const expectedType = getType(type);
+      if (simpleCheckRE.test(expectedType)) {
+          const t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isPlainObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = Array.isArray(value);
+      }
+      else {
+          try {
+              valid = value instanceof type;
+          }
+          catch (e) {
+              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+              valid = false;
+          }
+      }
+      return {
+          valid,
+          expectedType,
+      };
+  }
+  const functionTypeCheckRE = /^\s*function (\w+)/;
+  /**
+   * Use function string name to check built-in types,
+   * because a simple equality check will fail when running
+   * across different vms / iframes.
+   */
+  function getType(fn) {
+      const match = fn && fn.toString().match(functionTypeCheckRE);
+      return match ? match[1] : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (!Array.isArray(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      for (let i = 0, len = expectedTypes.length; i < len; i++) {
+          if (isSameType(expectedTypes[i], type)) {
+              return i;
+          }
+      }
+      return -1;
+  }
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          isExplicable(typeof value) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += ` with value ${styleValue(value, expectedType)}`;
+      }
+      message += `, got ${receivedType} `;
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += `with value ${styleValue(value, receivedType)}.`;
+      }
+      return message;
+  }
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return `"${value}"`;
+      }
+      else if (type === 'Number') {
+          return `${Number(value)}`;
+      }
+      else {
+          return `${value}`;
+      }
+  }
+  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+  function isExplicable(value) {
+      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+      return args.some((elem) => elem.toLowerCase() === 'boolean');
+  }
+
+  function handleError(err, vm, info) {
+      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+      // See: https://github.com/vuejs/vuex/issues/1505
+      pushTarget();
+      try {
+          if (vm) {
+              let cur = vm;
+              while ((cur = cur.$parent)) {
+                  const hooks = cur.$options.errorCaptured;
+                  if (hooks) {
+                      for (let i = 0; i < hooks.length; i++) {
+                          try {
+                              const capture = hooks[i].call(cur, err, vm, info) === false;
+                              if (capture)
+                                  return;
+                          }
+                          catch (e) {
+                              globalHandleError(e, cur, 'errorCaptured hook');
+                          }
+                      }
+                  }
+              }
+          }
+          globalHandleError(err, vm, info);
+      }
+      finally {
+          popTarget();
+      }
+  }
+  function invokeWithErrorHandling(handler, context, args, vm, info) {
+      let res;
+      try {
+          res = args ? handler.apply(context, args) : handler.call(context);
+          if (res && !res._isVue && isPromise(res) && !res._handled) {
+              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+              // issue #9511
+              // avoid catch triggering multiple times when nested calls
+              res._handled = true;
+          }
+      }
+      catch (e) {
+          // @ts-expect-error should it be any?
+          handleError(e, vm, info);
+      }
+      return res;
+  }
+  function globalHandleError(err, vm, info) {
+      logError(err, vm, info);
+  }
+  function logError(err, vm, info) {
+      {
+          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+      }
+      /* istanbul ignore else */
+      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+          console.error(err);
+      }
+      else {
+          throw err;
+      }
+  }
 
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn$2(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn$2('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
-  });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn$2('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn$2('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn$2('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn$2(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
-  }
-
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn$2('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn$2('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
-  }
-
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
-  }
-
-  /* globals MutationObserver */
-  const callbacks = [];
-  function flushCallbacks() {
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      Promise.resolve();
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+  /* globals MutationObserver */
+  const callbacks = [];
+  function flushCallbacks() {
+      const copies = callbacks.slice(0);
+      callbacks.length = 0;
+      for (let i = 0; i < copies.length; i++) {
+          copies[i]();
+      }
+  }
+  // The nextTick behavior leverages the microtask queue, which can be accessed
+  // via either native Promise.then or MutationObserver.
+  // MutationObserver has wider support, however it is seriously bugged in
+  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+  // completely stops working after triggering a few times... so, if native
+  // Promise is available, we will use it:
+  /* istanbul ignore next, $flow-disable-line */
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+      Promise.resolve();
+  }
+  else if (!isIE &&
+      typeof MutationObserver !== 'undefined' &&
+      (isNative(MutationObserver) ||
+          // PhantomJS and iOS 7.x
+          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+      // Use MutationObserver where native Promise is not available,
+      // e.g. PhantomJS, iOS7, Android 4.4
+      // (#6466 MutationObserver is unreliable in IE11)
+      let counter = 1;
+      const observer = new MutationObserver(flushCallbacks);
+      const textNode = document.createTextNode(String(counter));
+      observer.observe(textNode, {
+          characterData: true,
+      });
+  }
+  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
   else ;
 
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass$1(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass$1(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
-  }
-
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isPreTag = (tag) => tag === 'pre';
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
+  function genClassForVnode(vnode) {
+      let data = vnode.data;
+      let parentNode = vnode;
+      let childNode = vnode;
+      while (isDef(childNode.componentInstance)) {
+          childNode = childNode.componentInstance._vnode;
+          if (childNode && childNode.data) {
+              data = mergeClassData(childNode.data, data);
+          }
+      }
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while (isDef((parentNode = parentNode.parent))) {
+          if (parentNode && parentNode.data) {
+              data = mergeClassData(data, parentNode.data);
+          }
+      }
+      return renderClass$1(data.staticClass, data.class);
+  }
+  function mergeClassData(child, parent) {
+      return {
+          staticClass: concat(child.staticClass, parent.staticClass),
+          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+      };
+  }
+  function renderClass$1(staticClass, dynamicClass) {
+      if (isDef(staticClass) || isDef(dynamicClass)) {
+          return concat(staticClass, stringifyClass(dynamicClass));
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function concat(a, b) {
+      return a ? (b ? a + ' ' + b : a) : b || '';
+  }
+  function stringifyClass(value) {
+      if (Array.isArray(value)) {
+          return stringifyArray(value);
+      }
+      if (isObject(value)) {
+          return stringifyObject(value);
+      }
+      if (typeof value === 'string') {
+          return value;
+      }
+      /* istanbul ignore next */
+      return '';
+  }
+  function stringifyArray(value) {
+      let res = '';
+      let stringified;
+      for (let i = 0, l = value.length; i < l; i++) {
+          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+              if (res)
+                  res += ' ';
+              res += stringified;
+          }
+      }
+      return res;
+  }
+  function stringifyObject(value) {
+      let res = '';
+      for (const key in value) {
+          if (value[key]) {
+              if (res)
+                  res += ' ';
+              res += key;
+          }
+      }
+      return res;
+  }
+
+  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot');
+  // this map is intentionally selective, only covering SVG elements that may
+  // contain child elements.
+  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+  const isPreTag = (tag) => tag === 'pre';
+  const isReservedTag = (tag) => {
+      return isHTMLTag(tag) || isSVG(tag);
+  };
+  function getTagNamespace(tag) {
+      if (isSVG(tag)) {
+          return 'svg';
+      }
+      // basic support for MathML
+      // note it doesn't support other MathML elements being component roots
+      if (tag === 'math') {
+          return 'math';
+      }
+  }
   makeMap('text,number,password,search,email,tel,url');
 
-  function renderClass(node) {
-      const classList = genClassForVnode(node);
-      if (classList !== '') {
-          return ` class="${escape(classList)}"`;
-      }
-  }
-
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
-  }
-
-  function genStyle(style) {
-      let styleText = '';
-      for (const key in style) {
-          const value = style[key];
-          const hyphenatedKey = hyphenate(key);
-          if (Array.isArray(value)) {
-              for (let i = 0, len = value.length; i < len; i++) {
-                  styleText += normalizeValue(hyphenatedKey, value[i]);
-              }
-          }
-          else {
-              styleText += normalizeValue(hyphenatedKey, value);
-          }
-      }
-      return styleText;
-  }
-  function normalizeValue(key, value) {
-      if (typeof value === 'string' ||
-          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-          value === 0) {
-          return `${key}:${value};`;
-      }
-      else {
-          // invalid values
-          return ``;
-      }
-  }
-  function renderStyle(vnode) {
-      const styleText = genStyle(getStyle(vnode, false));
-      if (styleText !== '') {
-          return ` style=${JSON.stringify(escape(styleText))}`;
-      }
+  function renderClass(node) {
+      const classList = genClassForVnode(node);
+      if (classList !== '') {
+          return ` class="${escape(classList)}"`;
+      }
+  }
+
+  const parseStyleText = cached(function (cssText) {
+      const res = {};
+      const listDelimiter = /;(?![^(]*\))/g;
+      const propertyDelimiter = /:(.+)/;
+      cssText.split(listDelimiter).forEach(function (item) {
+          if (item) {
+              const tmp = item.split(propertyDelimiter);
+              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+          }
+      });
+      return res;
+  });
+  // merge static and dynamic style data on the same vnode
+  function normalizeStyleData(data) {
+      const style = normalizeStyleBinding(data.style);
+      // static style is pre-processed into an object during compilation
+      // and is always a fresh object, so it's safe to merge into it
+      return data.staticStyle ? extend(data.staticStyle, style) : style;
+  }
+  // normalize possible array / string values into Object
+  function normalizeStyleBinding(bindingStyle) {
+      if (Array.isArray(bindingStyle)) {
+          return toObject(bindingStyle);
+      }
+      if (typeof bindingStyle === 'string') {
+          return parseStyleText(bindingStyle);
+      }
+      return bindingStyle;
+  }
+  /**
+   * parent component style should be after child's
+   * so that parent component's style could override it
+   */
+  function getStyle(vnode, checkChild) {
+      const res = {};
+      let styleData;
+      if (checkChild) {
+          let childNode = vnode;
+          while (childNode.componentInstance) {
+              childNode = childNode.componentInstance._vnode;
+              if (childNode &&
+                  childNode.data &&
+                  (styleData = normalizeStyleData(childNode.data))) {
+                  extend(res, styleData);
+              }
+          }
+      }
+      if ((styleData = normalizeStyleData(vnode.data))) {
+          extend(res, styleData);
+      }
+      let parentNode = vnode;
+      // @ts-expect-error parentNode.parent not VNodeWithData
+      while ((parentNode = parentNode.parent)) {
+          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+              extend(res, styleData);
+          }
+      }
+      return res;
+  }
+
+  function genStyle(style) {
+      let styleText = '';
+      for (const key in style) {
+          const value = style[key];
+          const hyphenatedKey = hyphenate(key);
+          if (Array.isArray(value)) {
+              for (let i = 0, len = value.length; i < len; i++) {
+                  styleText += normalizeValue(hyphenatedKey, value[i]);
+              }
+          }
+          else {
+              styleText += normalizeValue(hyphenatedKey, value);
+          }
+      }
+      return styleText;
+  }
+  function normalizeValue(key, value) {
+      if (typeof value === 'string' ||
+          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+          value === 0) {
+          return `${key}:${value};`;
+      }
+      else {
+          // invalid values
+          return ``;
+      }
+  }
+  function renderStyle(vnode) {
+      const styleText = genStyle(getStyle(vnode, false));
+      if (styleText !== '') {
+          return ` style=${JSON.stringify(escape(styleText))}`;
+      }
   }
 
   var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-  function show(node, dir) {
-      if (!dir.value) {
-          const style = node.data.style || (node.data.style = {});
-          if (Array.isArray(style)) {
-              style.push({ display: 'none' });
-          }
-          else {
-              style.display = 'none';
-          }
-      }
-  }
-
-  // this is only applied for <select v-model> because it is the only edge case
-  // that must be done at runtime instead of compile time.
-  function model$2(node, dir) {
-      if (!node.children)
-          return;
-      const value = dir.value;
-      const isMultiple = node.data.attrs && node.data.attrs.multiple;
-      for (let i = 0, l = node.children.length; i < l; i++) {
-          const option = node.children[i];
-          if (option.tag === 'option') {
-              if (isMultiple) {
-                  const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
-                  if (selected) {
-                      setSelected(option);
-                  }
-              }
-              else {
-                  if (looseEqual(value, getValue(option))) {
-                      setSelected(option);
-                      return;
-                  }
-              }
-          }
-      }
-  }
-  function getValue(option) {
-      const data = option.data || {};
-      return ((data.attrs && data.attrs.value) ||
-          (data.domProps && data.domProps.value) ||
-          (option.children && option.children[0] && option.children[0].text));
-  }
-  function setSelected(option) {
-      const data = option.data || (option.data = {});
-      const attrs = data.attrs || (data.attrs = {});
-      attrs.selected = '';
-  }
-
-  var directives$1 = {
-      show,
-      model: model$2,
+  function show(node, dir) {
+      if (!dir.value) {
+          const style = node.data.style || (node.data.style = {});
+          if (Array.isArray(style)) {
+              style.push({ display: 'none' });
+          }
+          else {
+              style.display = 'none';
+          }
+      }
+  }
+
+  // this is only applied for <select v-model> because it is the only edge case
+  // that must be done at runtime instead of compile time.
+  function model$2(node, dir) {
+      if (!node.children)
+          return;
+      const value = dir.value;
+      const isMultiple = node.data.attrs && node.data.attrs.multiple;
+      for (let i = 0, l = node.children.length; i < l; i++) {
+          const option = node.children[i];
+          if (option.tag === 'option') {
+              if (isMultiple) {
+                  const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                  if (selected) {
+                      setSelected(option);
+                  }
+              }
+              else {
+                  if (looseEqual(value, getValue(option))) {
+                      setSelected(option);
+                      return;
+                  }
+              }
+          }
+      }
+  }
+  function getValue(option) {
+      const data = option.data || {};
+      return ((data.attrs && data.attrs.value) ||
+          (data.domProps && data.domProps.value) ||
+          (option.children && option.children[0] && option.children[0].text));
+  }
+  function setSelected(option) {
+      const data = option.data || (option.data = {});
+      const attrs = data.attrs || (data.attrs = {});
+      attrs.selected = '';
+  }
+
+  var directives$1 = {
+      show,
+      model: model$2,
   };
 
-  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr');
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr');
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
       'title,tr,track');
 
-  const MAX_STACK_DEPTH = 800;
-  const noop = (_) => _;
-  const defer = typeof process !== 'undefined' && process.nextTick
-      ? process.nextTick
-      : typeof Promise !== 'undefined'
-          ? (fn) => Promise.resolve().then(fn)
-          : typeof setTimeout !== 'undefined'
-              ? setTimeout
-              : noop;
-  if (defer === noop) {
-      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
-          'that are required by vue-server-renderer. Please use a polyfill for ' +
-          'either Promise or setTimeout.');
-  }
-  function createWriteFunction(write, onError) {
-      let stackDepth = 0;
-      const cachedWrite = (text, next) => {
-          if (text && cachedWrite.caching) {
-              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-          }
-          const waitForNext = write(text, next);
-          if (waitForNext !== true) {
-              if (stackDepth >= MAX_STACK_DEPTH) {
-                  defer(() => {
-                      try {
-                          next();
-                      }
-                      catch (e) {
-                          onError(e);
-                      }
-                  });
-              }
-              else {
-                  stackDepth++;
-                  next();
-                  stackDepth--;
-              }
-          }
-      };
-      cachedWrite.caching = false;
-      cachedWrite.cacheBuffer = [];
-      cachedWrite.componentBuffer = [];
-      return cachedWrite;
-  }
-
-  class RenderContext {
-      userContext;
-      activeInstance;
-      renderStates;
-      write;
-      renderNode;
-      //@ts-expect-error
-      next;
-      done;
-      modules;
-      directives;
-      isUnaryTag;
-      cache;
-      get;
-      has;
-      constructor(options) {
-          this.userContext = options.userContext;
-          this.activeInstance = options.activeInstance;
-          this.renderStates = [];
-          this.write = options.write;
-          this.done = options.done;
-          this.renderNode = options.renderNode;
-          this.isUnaryTag = options.isUnaryTag;
-          this.modules = options.modules;
-          this.directives = options.directives;
-          const cache = options.cache;
-          if (cache && (!cache.get || !cache.set)) {
-              throw new Error('renderer cache must implement at least get & set.');
-          }
-          this.cache = cache;
-          this.get = cache && normalizeAsync(cache, 'get');
-          this.has = cache && normalizeAsync(cache, 'has');
-          //@ts-expect-error
-          this.next = this.next.bind(this);
-      }
-      //@ts-expect-error
-      next() {
-          // eslint-disable-next-line
-          while (true) {
-              const lastState = this.renderStates[this.renderStates.length - 1];
-              if (isUndef(lastState)) {
-                  return this.done();
-              }
-              /* eslint-disable no-case-declarations */
-              switch (lastState.type) {
-                  case 'Element':
-                  case 'Fragment':
-                      const { children, total } = lastState;
-                      const rendered = lastState.rendered++;
-                      if (rendered < total) {
-                          return this.renderNode(children[rendered], false, this);
-                      }
-                      else {
-                          this.renderStates.pop();
-                          if (lastState.type === 'Element') {
-                              return this.write(lastState.endTag, this.next);
-                          }
-                      }
-                      break;
-                  case 'Component':
-                      this.renderStates.pop();
-                      this.activeInstance = lastState.prevActive;
-                      break;
-                  case 'ComponentWithCache':
-                      this.renderStates.pop();
-                      const { buffer, bufferIndex, componentBuffer, key } = lastState;
-                      const result = {
-                          html: buffer[bufferIndex],
-                          components: componentBuffer[bufferIndex],
-                      };
-                      this.cache.set(key, result);
-                      if (bufferIndex === 0) {
-                          // this is a top-level cached component,
-                          // exit caching mode.
-                          //@ts-expect-error
-                          this.write.caching = false;
-                      }
-                      else {
-                          // parent component is also being cached,
-                          // merge self into parent's result
-                          buffer[bufferIndex - 1] += result.html;
-                          const prev = componentBuffer[bufferIndex - 1];
-                          result.components.forEach((c) => prev.add(c));
-                      }
-                      buffer.length = bufferIndex;
-                      componentBuffer.length = bufferIndex;
-                      break;
-              }
-          }
-      }
-  }
-  function normalizeAsync(cache, method) {
-      const fn = cache[method];
-      if (isUndef(fn)) {
-          return;
-      }
-      else if (fn.length > 1) {
-          return (key, cb) => fn.call(cache, key, cb);
-      }
-      else {
-          return (key, cb) => cb(fn.call(cache, key));
-      }
-  }
-
-  const validDivisionCharRE = /[\w).+\-_$\]]/;
-  function parseFilters(exp) {
-      let inSingle = false;
-      let inDouble = false;
-      let inTemplateString = false;
-      let inRegex = false;
-      let curly = 0;
-      let square = 0;
-      let paren = 0;
-      let lastFilterIndex = 0;
-      let c, prev, i, expression, filters;
-      for (i = 0; i < exp.length; i++) {
-          prev = c;
-          c = exp.charCodeAt(i);
-          if (inSingle) {
-              if (c === 0x27 && prev !== 0x5c)
-                  inSingle = false;
-          }
-          else if (inDouble) {
-              if (c === 0x22 && prev !== 0x5c)
-                  inDouble = false;
-          }
-          else if (inTemplateString) {
-              if (c === 0x60 && prev !== 0x5c)
-                  inTemplateString = false;
-          }
-          else if (inRegex) {
-              if (c === 0x2f && prev !== 0x5c)
-                  inRegex = false;
-          }
-          else if (c === 0x7c && // pipe
-              exp.charCodeAt(i + 1) !== 0x7c &&
-              exp.charCodeAt(i - 1) !== 0x7c &&
-              !curly &&
-              !square &&
-              !paren) {
-              if (expression === undefined) {
-                  // first filter, end of expression
-                  lastFilterIndex = i + 1;
-                  expression = exp.slice(0, i).trim();
-              }
-              else {
-                  pushFilter();
-              }
-          }
-          else {
-              switch (c) {
-                  case 0x22:
-                      inDouble = true;
-                      break; // "
-                  case 0x27:
-                      inSingle = true;
-                      break; // '
-                  case 0x60:
-                      inTemplateString = true;
-                      break; // `
-                  case 0x28:
-                      paren++;
-                      break; // (
-                  case 0x29:
-                      paren--;
-                      break; // )
-                  case 0x5b:
-                      square++;
-                      break; // [
-                  case 0x5d:
-                      square--;
-                      break; // ]
-                  case 0x7b:
-                      curly++;
-                      break; // {
-                  case 0x7d:
-                      curly--;
-                      break; // }
-              }
-              if (c === 0x2f) {
-                  // /
-                  let j = i - 1;
-                  let p;
-                  // find first non-whitespace prev char
-                  for (; j >= 0; j--) {
-                      p = exp.charAt(j);
-                      if (p !== ' ')
-                          break;
-                  }
-                  if (!p || !validDivisionCharRE.test(p)) {
-                      inRegex = true;
-                  }
-              }
-          }
-      }
-      if (expression === undefined) {
-          expression = exp.slice(0, i).trim();
-      }
-      else if (lastFilterIndex !== 0) {
-          pushFilter();
-      }
-      function pushFilter() {
-          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-          lastFilterIndex = i + 1;
-      }
-      if (filters) {
-          for (i = 0; i < filters.length; i++) {
-              expression = wrapFilter(expression, filters[i]);
-          }
-      }
-      return expression;
-  }
-  function wrapFilter(exp, filter) {
-      const i = filter.indexOf('(');
-      if (i < 0) {
-          // _f: resolveFilter
-          return `_f("${filter}")(${exp})`;
-      }
-      else {
-          const name = filter.slice(0, i);
-          const args = filter.slice(i + 1);
-          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-      }
-  }
-
-  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  const buildRegex = cached((delimiters) => {
-      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-  });
-  function parseText(text, delimiters) {
-      //@ts-expect-error
-      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-      if (!tagRE.test(text)) {
-          return;
-      }
-      const tokens = [];
-      const rawTokens = [];
-      let lastIndex = (tagRE.lastIndex = 0);
-      let match, index, tokenValue;
-      while ((match = tagRE.exec(text))) {
-          index = match.index;
-          // push text token
-          if (index > lastIndex) {
-              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-              tokens.push(JSON.stringify(tokenValue));
-          }
-          // tag token
-          const exp = parseFilters(match[1].trim());
-          tokens.push(`_s(${exp})`);
-          rawTokens.push({ '@binding': exp });
-          lastIndex = index + match[0].length;
-      }
-      if (lastIndex < text.length) {
-          rawTokens.push((tokenValue = text.slice(lastIndex)));
-          tokens.push(JSON.stringify(tokenValue));
-      }
-      return {
-          expression: tokens.join('+'),
-          tokens: rawTokens,
-      };
-  }
-
-  /* eslint-disable no-unused-vars */
-  function baseWarn(msg, range) {
-      console.error(`[Vue compiler]: ${msg}`);
-  }
-  /* eslint-enable no-unused-vars */
-  function pluckModuleFunction(modules, key) {
-      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-  }
-  function addProp(el, name, value, range, dynamic) {
-      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  function addAttr(el, name, value, range, dynamic) {
-      const attrs = dynamic
-          ? el.dynamicAttrs || (el.dynamicAttrs = [])
-          : el.attrs || (el.attrs = []);
-      attrs.push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr(el, name, value, range) {
-      el.attrsMap[name] = value;
-      el.attrsList.push(rangeSetItem({ name, value }, range));
-  }
-  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-      (el.directives || (el.directives = [])).push(rangeSetItem({
-          name,
-          rawName,
-          value,
-          arg,
-          isDynamicArg,
-          modifiers,
-      }, range));
-      el.plain = false;
-  }
-  function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-  }
-  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-      modifiers = modifiers || emptyObject;
-      // warn prevent and passive modifier
-      /* istanbul ignore if */
-      if (warn &&
-          modifiers.prevent &&
-          modifiers.passive) {
-          warn("passive and prevent can't be used together. " +
-              "Passive handler can't prevent default event.", range);
-      }
-      // normalize click.right and click.middle since they don't actually fire
-      // this is technically browser-specific, but at least for now browsers are
-      // the only target envs that have right/middle clicks.
-      if (modifiers.right) {
-          if (dynamic) {
-              name = `(${name})==='click'?'contextmenu':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'contextmenu';
-              delete modifiers.right;
-          }
-      }
-      else if (modifiers.middle) {
-          if (dynamic) {
-              name = `(${name})==='click'?'mouseup':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'mouseup';
-          }
-      }
-      // check capture modifier
-      if (modifiers.capture) {
-          delete modifiers.capture;
-          name = prependModifierMarker('!', name, dynamic);
-      }
-      if (modifiers.once) {
-          delete modifiers.once;
-          name = prependModifierMarker('~', name, dynamic);
-      }
-      /* istanbul ignore if */
-      if (modifiers.passive) {
-          delete modifiers.passive;
-          name = prependModifierMarker('&', name, dynamic);
-      }
-      let events;
-      if (modifiers.native) {
-          delete modifiers.native;
-          events = el.nativeEvents || (el.nativeEvents = {});
-      }
-      else {
-          events = el.events || (el.events = {});
-      }
-      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-      if (modifiers !== emptyObject) {
-          newHandler.modifiers = modifiers;
-      }
-      const handlers = events[name];
-      /* istanbul ignore if */
-      if (Array.isArray(handlers)) {
-          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-      }
-      else if (handlers) {
-          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-      }
-      else {
-          events[name] = newHandler;
-      }
-      el.plain = false;
-  }
-  function getRawBindingAttr(el, name) {
-      return (el.rawAttrsMap[':' + name] ||
-          el.rawAttrsMap['v-bind:' + name] ||
-          el.rawAttrsMap[name]);
-  }
-  function getBindingAttr(el, name, getStatic) {
-      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-      if (dynamicValue != null) {
-          return parseFilters(dynamicValue);
-      }
-      else if (getStatic !== false) {
-          const staticValue = getAndRemoveAttr(el, name);
-          if (staticValue != null) {
-              return JSON.stringify(staticValue);
-          }
-      }
-  }
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr(el, name, removeFromMap) {
-      let val;
-      if ((val = el.attrsMap[name]) != null) {
-          const list = el.attrsList;
-          for (let i = 0, l = list.length; i < l; i++) {
-              if (list[i].name === name) {
-                  list.splice(i, 1);
-                  break;
-              }
-          }
-      }
-      if (removeFromMap) {
-          delete el.attrsMap[name];
-      }
-      return val;
-  }
-  function getAndRemoveAttrByRegex(el, name) {
-      const list = el.attrsList;
-      for (let i = 0, l = list.length; i < l; i++) {
-          const attr = list[i];
-          if (name.test(attr.name)) {
-              list.splice(i, 1);
-              return attr;
-          }
-      }
-  }
-  function rangeSetItem(item, range) {
-      if (range) {
-          if (range.start != null) {
-              item.start = range.start;
-          }
-          if (range.end != null) {
-              item.end = range.end;
-          }
-      }
-      return item;
-  }
-
-  function transformNode$1(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticClass = getAndRemoveAttr(el, 'class');
-      if (staticClass) {
-          const res = parseText(staticClass, options.delimiters);
-          if (res) {
-              warn(`class="${staticClass}": ` +
-                  'Interpolation inside attributes has been removed. ' +
-                  'Use v-bind or the colon shorthand instead. For example, ' +
-                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-          }
-      }
-      if (staticClass) {
-          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-      }
-      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-      if (classBinding) {
-          el.classBinding = classBinding;
-      }
-  }
-  function genData$2(el) {
-      let data = '';
-      if (el.staticClass) {
-          data += `staticClass:${el.staticClass},`;
-      }
-      if (el.classBinding) {
-          data += `class:${el.classBinding},`;
-      }
-      return data;
-  }
-  var klass = {
-      staticKeys: ['staticClass'],
-      transformNode: transformNode$1,
-      genData: genData$2,
+  const MAX_STACK_DEPTH = 800;
+  const noop = (_) => _;
+  const defer = typeof process !== 'undefined' && process.nextTick
+      ? process.nextTick
+      : typeof Promise !== 'undefined'
+          ? (fn) => Promise.resolve().then(fn)
+          : typeof setTimeout !== 'undefined'
+              ? setTimeout
+              : noop;
+  if (defer === noop) {
+      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+          'that are required by vue-server-renderer. Please use a polyfill for ' +
+          'either Promise or setTimeout.');
+  }
+  function createWriteFunction(write, onError) {
+      let stackDepth = 0;
+      const cachedWrite = (text, next) => {
+          if (text && cachedWrite.caching) {
+              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+          }
+          const waitForNext = write(text, next);
+          if (waitForNext !== true) {
+              if (stackDepth >= MAX_STACK_DEPTH) {
+                  defer(() => {
+                      try {
+                          next();
+                      }
+                      catch (e) {
+                          onError(e);
+                      }
+                  });
+              }
+              else {
+                  stackDepth++;
+                  next();
+                  stackDepth--;
+              }
+          }
+      };
+      cachedWrite.caching = false;
+      cachedWrite.cacheBuffer = [];
+      cachedWrite.componentBuffer = [];
+      return cachedWrite;
+  }
+
+  class RenderContext {
+      userContext;
+      activeInstance;
+      renderStates;
+      write;
+      renderNode;
+      //@ts-expect-error
+      next;
+      done;
+      modules;
+      directives;
+      isUnaryTag;
+      cache;
+      get;
+      has;
+      constructor(options) {
+          this.userContext = options.userContext;
+          this.activeInstance = options.activeInstance;
+          this.renderStates = [];
+          this.write = options.write;
+          this.done = options.done;
+          this.renderNode = options.renderNode;
+          this.isUnaryTag = options.isUnaryTag;
+          this.modules = options.modules;
+          this.directives = options.directives;
+          const cache = options.cache;
+          if (cache && (!cache.get || !cache.set)) {
+              throw new Error('renderer cache must implement at least get & set.');
+          }
+          this.cache = cache;
+          this.get = cache && normalizeAsync(cache, 'get');
+          this.has = cache && normalizeAsync(cache, 'has');
+          //@ts-expect-error
+          this.next = this.next.bind(this);
+      }
+      //@ts-expect-error
+      next() {
+          // eslint-disable-next-line
+          while (true) {
+              const lastState = this.renderStates[this.renderStates.length - 1];
+              if (isUndef(lastState)) {
+                  return this.done();
+              }
+              /* eslint-disable no-case-declarations */
+              switch (lastState.type) {
+                  case 'Element':
+                  case 'Fragment':
+                      const { children, total } = lastState;
+                      const rendered = lastState.rendered++;
+                      if (rendered < total) {
+                          return this.renderNode(children[rendered], false, this);
+                      }
+                      else {
+                          this.renderStates.pop();
+                          if (lastState.type === 'Element') {
+                              return this.write(lastState.endTag, this.next);
+                          }
+                      }
+                      break;
+                  case 'Component':
+                      this.renderStates.pop();
+                      this.activeInstance = lastState.prevActive;
+                      break;
+                  case 'ComponentWithCache':
+                      this.renderStates.pop();
+                      const { buffer, bufferIndex, componentBuffer, key } = lastState;
+                      const result = {
+                          html: buffer[bufferIndex],
+                          components: componentBuffer[bufferIndex],
+                      };
+                      this.cache.set(key, result);
+                      if (bufferIndex === 0) {
+                          // this is a top-level cached component,
+                          // exit caching mode.
+                          //@ts-expect-error
+                          this.write.caching = false;
+                      }
+                      else {
+                          // parent component is also being cached,
+                          // merge self into parent's result
+                          buffer[bufferIndex - 1] += result.html;
+                          const prev = componentBuffer[bufferIndex - 1];
+                          result.components.forEach((c) => prev.add(c));
+                      }
+                      buffer.length = bufferIndex;
+                      componentBuffer.length = bufferIndex;
+                      break;
+              }
+          }
+      }
+  }
+  function normalizeAsync(cache, method) {
+      const fn = cache[method];
+      if (isUndef(fn)) {
+          return;
+      }
+      else if (fn.length > 1) {
+          return (key, cb) => fn.call(cache, key, cb);
+      }
+      else {
+          return (key, cb) => cb(fn.call(cache, key));
+      }
+  }
+
+  const validDivisionCharRE = /[\w).+\-_$\]]/;
+  function parseFilters(exp) {
+      let inSingle = false;
+      let inDouble = false;
+      let inTemplateString = false;
+      let inRegex = false;
+      let curly = 0;
+      let square = 0;
+      let paren = 0;
+      let lastFilterIndex = 0;
+      let c, prev, i, expression, filters;
+      for (i = 0; i < exp.length; i++) {
+          prev = c;
+          c = exp.charCodeAt(i);
+          if (inSingle) {
+              if (c === 0x27 && prev !== 0x5c)
+                  inSingle = false;
+          }
+          else if (inDouble) {
+              if (c === 0x22 && prev !== 0x5c)
+                  inDouble = false;
+          }
+          else if (inTemplateString) {
+              if (c === 0x60 && prev !== 0x5c)
+                  inTemplateString = false;
+          }
+          else if (inRegex) {
+              if (c === 0x2f && prev !== 0x5c)
+                  inRegex = false;
+          }
+          else if (c === 0x7c && // pipe
+              exp.charCodeAt(i + 1) !== 0x7c &&
+              exp.charCodeAt(i - 1) !== 0x7c &&
+              !curly &&
+              !square &&
+              !paren) {
+              if (expression === undefined) {
+                  // first filter, end of expression
+                  lastFilterIndex = i + 1;
+                  expression = exp.slice(0, i).trim();
+              }
+              else {
+                  pushFilter();
+              }
+          }
+          else {
+              switch (c) {
+                  case 0x22:
+                      inDouble = true;
+                      break; // "
+                  case 0x27:
+                      inSingle = true;
+                      break; // '
+                  case 0x60:
+                      inTemplateString = true;
+                      break; // `
+                  case 0x28:
+                      paren++;
+                      break; // (
+                  case 0x29:
+                      paren--;
+                      break; // )
+                  case 0x5b:
+                      square++;
+                      break; // [
+                  case 0x5d:
+                      square--;
+                      break; // ]
+                  case 0x7b:
+                      curly++;
+                      break; // {
+                  case 0x7d:
+                      curly--;
+                      break; // }
+              }
+              if (c === 0x2f) {
+                  // /
+                  let j = i - 1;
+                  let p;
+                  // find first non-whitespace prev char
+                  for (; j >= 0; j--) {
+                      p = exp.charAt(j);
+                      if (p !== ' ')
+                          break;
+                  }
+                  if (!p || !validDivisionCharRE.test(p)) {
+                      inRegex = true;
+                  }
+              }
+          }
+      }
+      if (expression === undefined) {
+          expression = exp.slice(0, i).trim();
+      }
+      else if (lastFilterIndex !== 0) {
+          pushFilter();
+      }
+      function pushFilter() {
+          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+          lastFilterIndex = i + 1;
+      }
+      if (filters) {
+          for (i = 0; i < filters.length; i++) {
+              expression = wrapFilter(expression, filters[i]);
+          }
+      }
+      return expression;
+  }
+  function wrapFilter(exp, filter) {
+      const i = filter.indexOf('(');
+      if (i < 0) {
+          // _f: resolveFilter
+          return `_f("${filter}")(${exp})`;
+      }
+      else {
+          const name = filter.slice(0, i);
+          const args = filter.slice(i + 1);
+          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+      }
+  }
+
+  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+  const buildRegex = cached((delimiters) => {
+      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+  });
+  function parseText(text, delimiters) {
+      //@ts-expect-error
+      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+      if (!tagRE.test(text)) {
+          return;
+      }
+      const tokens = [];
+      const rawTokens = [];
+      let lastIndex = (tagRE.lastIndex = 0);
+      let match, index, tokenValue;
+      while ((match = tagRE.exec(text))) {
+          index = match.index;
+          // push text token
+          if (index > lastIndex) {
+              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+              tokens.push(JSON.stringify(tokenValue));
+          }
+          // tag token
+          const exp = parseFilters(match[1].trim());
+          tokens.push(`_s(${exp})`);
+          rawTokens.push({ '@binding': exp });
+          lastIndex = index + match[0].length;
+      }
+      if (lastIndex < text.length) {
+          rawTokens.push((tokenValue = text.slice(lastIndex)));
+          tokens.push(JSON.stringify(tokenValue));
+      }
+      return {
+          expression: tokens.join('+'),
+          tokens: rawTokens,
+      };
+  }
+
+  /* eslint-disable no-unused-vars */
+  function baseWarn(msg, range) {
+      console.error(`[Vue compiler]: ${msg}`);
+  }
+  /* eslint-enable no-unused-vars */
+  function pluckModuleFunction(modules, key) {
+      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+  }
+  function addProp(el, name, value, range, dynamic) {
+      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
+  }
+  function addAttr(el, name, value, range, dynamic) {
+      const attrs = dynamic
+          ? el.dynamicAttrs || (el.dynamicAttrs = [])
+          : el.attrs || (el.attrs = []);
+      attrs.push(rangeSetItem({ name, value, dynamic }, range));
+      el.plain = false;
+  }
+  // add a raw attr (use this in preTransforms)
+  function addRawAttr(el, name, value, range) {
+      el.attrsMap[name] = value;
+      el.attrsList.push(rangeSetItem({ name, value }, range));
+  }
+  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+      (el.directives || (el.directives = [])).push(rangeSetItem({
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamicArg,
+          modifiers,
+      }, range));
+      el.plain = false;
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+  }
+  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+      modifiers = modifiers || emptyObject;
+      // warn prevent and passive modifier
+      /* istanbul ignore if */
+      if (warn &&
+          modifiers.prevent &&
+          modifiers.passive) {
+          warn("passive and prevent can't be used together. " +
+              "Passive handler can't prevent default event.", range);
+      }
+      // normalize click.right and click.middle since they don't actually fire
+      // this is technically browser-specific, but at least for now browsers are
+      // the only target envs that have right/middle clicks.
+      if (modifiers.right) {
+          if (dynamic) {
+              name = `(${name})==='click'?'contextmenu':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'contextmenu';
+              delete modifiers.right;
+          }
+      }
+      else if (modifiers.middle) {
+          if (dynamic) {
+              name = `(${name})==='click'?'mouseup':(${name})`;
+          }
+          else if (name === 'click') {
+              name = 'mouseup';
+          }
+      }
+      // check capture modifier
+      if (modifiers.capture) {
+          delete modifiers.capture;
+          name = prependModifierMarker('!', name, dynamic);
+      }
+      if (modifiers.once) {
+          delete modifiers.once;
+          name = prependModifierMarker('~', name, dynamic);
+      }
+      /* istanbul ignore if */
+      if (modifiers.passive) {
+          delete modifiers.passive;
+          name = prependModifierMarker('&', name, dynamic);
+      }
+      let events;
+      if (modifiers.native) {
+          delete modifiers.native;
+          events = el.nativeEvents || (el.nativeEvents = {});
+      }
+      else {
+          events = el.events || (el.events = {});
+      }
+      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+      if (modifiers !== emptyObject) {
+          newHandler.modifiers = modifiers;
+      }
+      const handlers = events[name];
+      /* istanbul ignore if */
+      if (Array.isArray(handlers)) {
+          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+      }
+      else if (handlers) {
+          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+      }
+      else {
+          events[name] = newHandler;
+      }
+      el.plain = false;
+  }
+  function getRawBindingAttr(el, name) {
+      return (el.rawAttrsMap[':' + name] ||
+          el.rawAttrsMap['v-bind:' + name] ||
+          el.rawAttrsMap[name]);
+  }
+  function getBindingAttr(el, name, getStatic) {
+      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+      if (dynamicValue != null) {
+          return parseFilters(dynamicValue);
+      }
+      else if (getStatic !== false) {
+          const staticValue = getAndRemoveAttr(el, name);
+          if (staticValue != null) {
+              return JSON.stringify(staticValue);
+          }
+      }
+  }
+  // note: this only removes the attr from the Array (attrsList) so that it
+  // doesn't get processed by processAttrs.
+  // By default it does NOT remove it from the map (attrsMap) because the map is
+  // needed during codegen.
+  function getAndRemoveAttr(el, name, removeFromMap) {
+      let val;
+      if ((val = el.attrsMap[name]) != null) {
+          const list = el.attrsList;
+          for (let i = 0, l = list.length; i < l; i++) {
+              if (list[i].name === name) {
+                  list.splice(i, 1);
+                  break;
+              }
+          }
+      }
+      if (removeFromMap) {
+          delete el.attrsMap[name];
+      }
+      return val;
+  }
+  function getAndRemoveAttrByRegex(el, name) {
+      const list = el.attrsList;
+      for (let i = 0, l = list.length; i < l; i++) {
+          const attr = list[i];
+          if (name.test(attr.name)) {
+              list.splice(i, 1);
+              return attr;
+          }
+      }
+  }
+  function rangeSetItem(item, range) {
+      if (range) {
+          if (range.start != null) {
+              item.start = range.start;
+          }
+          if (range.end != null) {
+              item.end = range.end;
+          }
+      }
+      return item;
+  }
+
+  function transformNode$1(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticClass = getAndRemoveAttr(el, 'class');
+      if (staticClass) {
+          const res = parseText(staticClass, options.delimiters);
+          if (res) {
+              warn(`class="${staticClass}": ` +
+                  'Interpolation inside attributes has been removed. ' +
+                  'Use v-bind or the colon shorthand instead. For example, ' +
+                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+          }
+      }
+      if (staticClass) {
+          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+      }
+      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+      if (classBinding) {
+          el.classBinding = classBinding;
+      }
+  }
+  function genData$2(el) {
+      let data = '';
+      if (el.staticClass) {
+          data += `staticClass:${el.staticClass},`;
+      }
+      if (el.classBinding) {
+          data += `class:${el.classBinding},`;
+      }
+      return data;
+  }
+  var klass = {
+      staticKeys: ['staticClass'],
+      transformNode: transformNode$1,
+      genData: genData$2,
   };
 
-  function transformNode(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticStyle = getAndRemoveAttr(el, 'style');
-      if (staticStyle) {
-          /* istanbul ignore if */
-          {
-              const res = parseText(staticStyle, options.delimiters);
-              if (res) {
-                  warn(`style="${staticStyle}": ` +
-                      'Interpolation inside attributes has been removed. ' +
-                      'Use v-bind or the colon shorthand instead. For example, ' +
-                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-              }
-          }
-          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-      }
-      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-      if (styleBinding) {
-          el.styleBinding = styleBinding;
-      }
-  }
-  function genData$1(el) {
-      let data = '';
-      if (el.staticStyle) {
-          data += `staticStyle:${el.staticStyle},`;
-      }
-      if (el.styleBinding) {
-          data += `style:(${el.styleBinding}),`;
-      }
-      return data;
-  }
-  var style = {
-      staticKeys: ['staticStyle'],
-      transformNode,
-      genData: genData$1,
+  function transformNode(el, options) {
+      const warn = options.warn || baseWarn;
+      const staticStyle = getAndRemoveAttr(el, 'style');
+      if (staticStyle) {
+          /* istanbul ignore if */
+          {
+              const res = parseText(staticStyle, options.delimiters);
+              if (res) {
+                  warn(`style="${staticStyle}": ` +
+                      'Interpolation inside attributes has been removed. ' +
+                      'Use v-bind or the colon shorthand instead. For example, ' +
+                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+              }
+          }
+          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+      }
+      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+      if (styleBinding) {
+          el.styleBinding = styleBinding;
+      }
+  }
+  function genData$1(el) {
+      let data = '';
+      if (el.staticStyle) {
+          data += `staticStyle:${el.staticStyle},`;
+      }
+      if (el.styleBinding) {
+          data += `style:(${el.styleBinding}),`;
+      }
+      return data;
+  }
+  var style = {
+      staticKeys: ['staticStyle'],
+      transformNode,
+      genData: genData$1,
   };
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -2952,4677 +2953,4677 @@
 
   var he = he$1.exports;
 
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-  // Regular Expressions for parsing tags and attributes
-  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-  const startTagOpen = new RegExp(`^<${qnameCapture}`);
-  const startTagClose = /^\s*(\/?)>/;
-  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-  const doctype = /^<!DOCTYPE [^>]+>/i;
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  const comment = /^<!\--/;
-  const conditionalComment = /^<!\[/;
-  // Special Elements (can contain anything)
-  const isPlainTextElement = makeMap('script,style,textarea', true);
-  const reCache = {};
-  const decodingMap = {
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&amp;': '&',
-      '&#10;': '\n',
-      '&#9;': '\t',
-      '&#39;': "'",
-  };
-  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-  // #5992
-  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  function decodeAttr(value, shouldDecodeNewlines) {
-      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-      return value.replace(re, (match) => decodingMap[match]);
-  }
-  function parseHTML(html, options) {
-      const stack = [];
-      const expectHTML = options.expectHTML;
-      const isUnaryTag = options.isUnaryTag || no;
-      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-      let index = 0;
-      let last, lastTag;
-      while (html) {
-          last = html;
-          // Make sure we're not in a plaintext content element like script/style
-          if (!lastTag || !isPlainTextElement(lastTag)) {
-              let textEnd = html.indexOf('<');
-              if (textEnd === 0) {
-                  // Comment:
-                  if (comment.test(html)) {
-                      const commentEnd = html.indexOf('-->');
-                      if (commentEnd >= 0) {
-                          if (options.shouldKeepComment) {
-                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                          }
-                          advance(commentEnd + 3);
-                          continue;
-                      }
-                  }
-                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                  if (conditionalComment.test(html)) {
-                      const conditionalEnd = html.indexOf(']>');
-                      if (conditionalEnd >= 0) {
-                          advance(conditionalEnd + 2);
-                          continue;
-                      }
-                  }
-                  // Doctype:
-                  const doctypeMatch = html.match(doctype);
-                  if (doctypeMatch) {
-                      advance(doctypeMatch[0].length);
-                      continue;
-                  }
-                  // End tag:
-                  const endTagMatch = html.match(endTag);
-                  if (endTagMatch) {
-                      const curIndex = index;
-                      advance(endTagMatch[0].length);
-                      parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
-                  }
-                  // Start tag:
-                  const startTagMatch = parseStartTag();
-                  if (startTagMatch) {
-                      handleStartTag(startTagMatch);
-                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                          advance(1);
-                      }
-                      continue;
-                  }
-              }
-              let text, rest, next;
-              if (textEnd >= 0) {
-                  rest = html.slice(textEnd);
-                  while (!endTag.test(rest) &&
-                      !startTagOpen.test(rest) &&
-                      !comment.test(rest) &&
-                      !conditionalComment.test(rest)) {
-                      // < in plain text, be forgiving and treat it as text
-                      next = rest.indexOf('<', 1);
-                      if (next < 0)
-                          break;
-                      textEnd += next;
-                      rest = html.slice(textEnd);
-                  }
-                  text = html.substring(0, textEnd);
-              }
-              if (textEnd < 0) {
-                  text = html;
-              }
-              if (text) {
-                  advance(text.length);
-              }
-              if (options.chars && text) {
-                  options.chars(text, index - text.length, index);
-              }
-          }
-          else {
-              let endTagLength = 0;
-              const stackedTag = lastTag.toLowerCase();
-              const reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                      text = text
-                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                  }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                      text = text.slice(1);
-                  }
-                  if (options.chars) {
-                      options.chars(text);
-                  }
-                  return '';
-              });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag, index - endTagLength, index);
-          }
-          if (html === last) {
-              options.chars && options.chars(html);
-              if (!stack.length &&
-                  options.warn) {
-                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                      start: index + html.length,
-                  });
-              }
-              break;
-          }
-      }
-      // Clean up any remaining tags
-      parseEndTag();
-      function advance(n) {
-          index += n;
-          html = html.substring(n);
-      }
-      function parseStartTag() {
-          const start = html.match(startTagOpen);
-          if (start) {
-              const match = {
-                  tagName: start[1],
-                  attrs: [],
-                  start: index,
-              };
-              advance(start[0].length);
-              let end, attr;
-              while (!(end = html.match(startTagClose)) &&
-                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                  attr.start = index;
-                  advance(attr[0].length);
-                  attr.end = index;
-                  match.attrs.push(attr);
-              }
-              if (end) {
-                  match.unarySlash = end[1];
-                  advance(end[0].length);
-                  match.end = index;
-                  return match;
-              }
-          }
-      }
-      function handleStartTag(match) {
-          const tagName = match.tagName;
-          const unarySlash = match.unarySlash;
-          if (expectHTML) {
-              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                  parseEndTag(lastTag);
-              }
-              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                  parseEndTag(tagName);
-              }
-          }
-          const unary = isUnaryTag(tagName) || !!unarySlash;
-          const l = match.attrs.length;
-          const attrs = new Array(l);
-          for (let i = 0; i < l; i++) {
-              const args = match.attrs[i];
-              const value = args[3] || args[4] || args[5] || '';
-              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                  ? options.shouldDecodeNewlinesForHref
-                  : options.shouldDecodeNewlines;
-              attrs[i] = {
-                  name: args[1],
-                  value: decodeAttr(value, shouldDecodeNewlines),
-              };
-              if (options.outputSourceRange) {
-                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                  attrs[i].end = args.end;
-              }
-          }
-          if (!unary) {
-              stack.push({
-                  tag: tagName,
-                  lowerCasedTag: tagName.toLowerCase(),
-                  attrs: attrs,
-                  start: match.start,
-                  end: match.end,
-              });
-              lastTag = tagName;
-          }
-          if (options.start) {
-              options.start(tagName, attrs, unary, match.start, match.end);
-          }
-      }
-      function parseEndTag(tagName, start, end) {
-          let pos, lowerCasedTagName;
-          if (start == null)
-              start = index;
-          if (end == null)
-              end = index;
-          // Find the closest opened tag of the same type
-          if (tagName) {
-              lowerCasedTagName = tagName.toLowerCase();
-              for (pos = stack.length - 1; pos >= 0; pos--) {
-                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                      break;
-                  }
-              }
-          }
-          else {
-              // If no tag name is provided, clean shop
-              pos = 0;
-          }
-          if (pos >= 0) {
-              // Close all the open elements, up the stack
-              for (let i = stack.length - 1; i >= pos; i--) {
-                  if ((i > pos || !tagName) &&
-                      options.warn) {
-                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                          start: stack[i].start,
-                          end: stack[i].end,
-                      });
-                  }
-                  if (options.end) {
-                      options.end(stack[i].tag, start, end);
-                  }
-              }
-              // Remove the open elements from the stack
-              stack.length = pos;
-              lastTag = pos && stack[pos - 1].tag;
-          }
-          else if (lowerCasedTagName === 'br') {
-              if (options.start) {
-                  options.start(tagName, [], true, start, end);
-              }
-          }
-          else if (lowerCasedTagName === 'p') {
-              if (options.start) {
-                  options.start(tagName, [], false, start, end);
-              }
-              if (options.end) {
-                  options.end(tagName, start, end);
-              }
-          }
-      }
-  }
-
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel(el, value, modifiers) {
-      const { number, trim } = modifiers || {};
-      const baseValueExpression = '$$v';
-      let valueExpression = baseValueExpression;
-      if (trim) {
-          valueExpression =
-              `(typeof ${baseValueExpression} === 'string'` +
-                  `? ${baseValueExpression}.trim()` +
-                  `: ${baseValueExpression})`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      const assignment = genAssignmentCode(value, valueExpression);
-      el.model = {
-          value: `(${value})`,
-          expression: JSON.stringify(value),
-          callback: `function (${baseValueExpression}) {${assignment}}`,
-      };
-  }
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode(value, assignment) {
-      const res = parseModel(value);
-      if (res.key === null) {
-          return `${value}=${assignment}`;
-      }
-      else {
-          return `$set(${res.exp}, ${res.key}, ${assignment})`;
-      }
-  }
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-  let len, str, chr, index, expressionPos, expressionEndPos;
-  function parseModel(val) {
-      // Fix https://github.com/vuejs/vue/pull/7730
-      // allow v-model="obj.val " (trailing whitespace)
-      val = val.trim();
-      len = val.length;
-      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-          index = val.lastIndexOf('.');
-          if (index > -1) {
-              return {
-                  exp: val.slice(0, index),
-                  key: '"' + val.slice(index + 1) + '"',
-              };
-          }
-          else {
-              return {
-                  exp: val,
-                  key: null,
-              };
-          }
-      }
-      str = val;
-      index = expressionPos = expressionEndPos = 0;
-      while (!eof()) {
-          chr = next();
-          /* istanbul ignore if */
-          if (isStringStart(chr)) {
-              parseString(chr);
-          }
-          else if (chr === 0x5b) {
-              parseBracket(chr);
-          }
-      }
-      return {
-          exp: val.slice(0, expressionPos),
-          key: val.slice(expressionPos + 1, expressionEndPos),
-      };
-  }
-  function next() {
-      return str.charCodeAt(++index);
-  }
-  function eof() {
-      return index >= len;
-  }
-  function isStringStart(chr) {
-      return chr === 0x22 || chr === 0x27;
-  }
-  function parseBracket(chr) {
-      let inBracket = 1;
-      expressionPos = index;
-      while (!eof()) {
-          chr = next();
-          if (isStringStart(chr)) {
-              parseString(chr);
-              continue;
-          }
-          if (chr === 0x5b)
-              inBracket++;
-          if (chr === 0x5d)
-              inBracket--;
-          if (inBracket === 0) {
-              expressionEndPos = index;
-              break;
-          }
-      }
-  }
-  function parseString(chr) {
-      const stringQuote = chr;
-      while (!eof()) {
-          chr = next();
-          if (chr === stringQuote) {
-              break;
-          }
-      }
-  }
-
-  const onRE = /^@|^v-on:/;
-  const dirRE = /^v-|^@|^:|^#/;
-  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  const stripParensRE = /^\(|\)$/g;
-  const dynamicArgRE = /^\[.*\]$/;
-  const argRE = /:(.*)$/;
-  const bindRE = /^:|^\.|^v-bind:/;
-  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-  const slotRE = /^v-slot(:|$)|^#/;
-  const lineBreakRE = /[\r\n]/;
-  const whitespaceRE = /[ \f\t\r\n]+/g;
-  const invalidAttributeRE = /[\s"'<>\/=]/;
-  const decodeHTMLCached = cached(he.decode);
-  const emptySlotScopeToken = `_empty_`;
-  // configurable state
-  let warn$1;
-  let delimiters;
-  let transforms;
-  let preTransforms;
-  let postTransforms;
-  let platformIsPreTag;
-  let platformMustUseProp;
-  let platformGetTagNamespace;
-  let maybeComponent;
-  function createASTElement(tag, attrs, parent) {
-      return {
-          type: 1,
-          tag,
-          attrsList: attrs,
-          attrsMap: makeAttrsMap(attrs),
-          rawAttrsMap: {},
-          parent,
-          children: [],
-      };
-  }
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse(template, options) {
-      warn$1 = options.warn || baseWarn;
-      platformIsPreTag = options.isPreTag || no;
-      platformMustUseProp = options.mustUseProp || no;
-      platformGetTagNamespace = options.getTagNamespace || no;
-      const isReservedTag = options.isReservedTag || no;
-      maybeComponent = (el) => !!(el.component ||
-          el.attrsMap[':is'] ||
-          el.attrsMap['v-bind:is'] ||
-          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-      transforms = pluckModuleFunction(options.modules, 'transformNode');
-      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-      delimiters = options.delimiters;
-      const stack = [];
-      const preserveWhitespace = options.preserveWhitespace !== false;
-      const whitespaceOption = options.whitespace;
-      let root;
-      let currentParent;
-      let inVPre = false;
-      let inPre = false;
-      let warned = false;
-      function warnOnce(msg, range) {
-          if (!warned) {
-              warned = true;
-              warn$1(msg, range);
-          }
-      }
-      function closeElement(element) {
-          trimEndingWhitespace(element);
-          if (!inVPre && !element.processed) {
-              element = processElement(element, options);
-          }
-          // tree management
-          if (!stack.length && element !== root) {
-              // allow root elements with v-if, v-else-if and v-else
-              if (root.if && (element.elseif || element.else)) {
-                  {
-                      checkRootConstraints(element);
-                  }
-                  addIfCondition(root, {
-                      exp: element.elseif,
-                      block: element,
-                  });
-              }
-              else {
-                  warnOnce(`Component template should contain exactly one root element. ` +
-                      `If you are using v-if on multiple elements, ` +
-                      `use v-else-if to chain them instead.`, { start: element.start });
-              }
-          }
-          if (currentParent && !element.forbidden) {
-              if (element.elseif || element.else) {
-                  processIfConditions(element, currentParent);
-              }
-              else {
-                  if (element.slotScope) {
-                      // scoped slot
-                      // keep it in the children list so that v-else(-if) conditions can
-                      // find it as the prev node.
-                      const name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                  }
-                  currentParent.children.push(element);
-                  element.parent = currentParent;
-              }
-          }
-          // final children cleanup
-          // filter out scoped slots
-          element.children = element.children.filter((c) => !c.slotScope);
-          // remove trailing whitespace node again
-          trimEndingWhitespace(element);
-          // check pre state
-          if (element.pre) {
-              inVPre = false;
-          }
-          if (platformIsPreTag(element.tag)) {
-              inPre = false;
-          }
-          // apply post-transforms
-          for (let i = 0; i < postTransforms.length; i++) {
-              postTransforms[i](element, options);
-          }
-      }
-      function trimEndingWhitespace(el) {
-          // remove trailing whitespace node
-          if (!inPre) {
-              let lastNode;
-              while ((lastNode = el.children[el.children.length - 1]) &&
-                  lastNode.type === 3 &&
-                  lastNode.text === ' ') {
-                  el.children.pop();
-              }
-          }
-      }
-      function checkRootConstraints(el) {
-          if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                  'contain multiple nodes.', { start: el.start });
-          }
-          if (el.attrsMap.hasOwnProperty('v-for')) {
-              warnOnce('Cannot use v-for on stateful component root element because ' +
-                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
-          }
-      }
-      parseHTML(template, {
-          warn: warn$1,
-          expectHTML: options.expectHTML,
-          isUnaryTag: options.isUnaryTag,
-          canBeLeftOpenTag: options.canBeLeftOpenTag,
-          shouldDecodeNewlines: options.shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-          shouldKeepComment: options.comments,
-          outputSourceRange: options.outputSourceRange,
-          start(tag, attrs, unary, start, end) {
-              // check namespace.
-              // inherit parent ns if there is one
-              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-              // handle IE svg bug
-              /* istanbul ignore if */
-              if (isIE && ns === 'svg') {
-                  attrs = guardIESVGBug(attrs);
-              }
-              let element = createASTElement(tag, attrs, currentParent);
-              if (ns) {
-                  element.ns = ns;
-              }
-              {
-                  if (options.outputSourceRange) {
-                      element.start = start;
-                      element.end = end;
-                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                          cumulated[attr.name] = attr;
-                          return cumulated;
-                      }, {});
-                  }
-                  attrs.forEach((attr) => {
-                      if (invalidAttributeRE.test(attr.name)) {
-                          warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                              `spaces, quotes, <, >, / or =.`, {
-                              start: attr.start + attr.name.indexOf(`[`),
-                              end: attr.start + attr.name.length,
-                          });
-                      }
-                  });
-              }
-              if (isForbiddenTag(element) && !isServerRendering()) {
-                  element.forbidden = true;
-                  warn$1('Templates should only be responsible for mapping the state to the ' +
-                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          `<${tag}>` +
-                          ', as they will not be parsed.', { start: element.start });
-              }
-              // apply pre-transforms
-              for (let i = 0; i < preTransforms.length; i++) {
-                  element = preTransforms[i](element, options) || element;
-              }
-              if (!inVPre) {
-                  processPre(element);
-                  if (element.pre) {
-                      inVPre = true;
-                  }
-              }
-              if (platformIsPreTag(element.tag)) {
-                  inPre = true;
-              }
-              if (inVPre) {
-                  processRawAttrs(element);
-              }
-              else if (!element.processed) {
-                  // structural directives
-                  processFor(element);
-                  processIf(element);
-                  processOnce(element);
-              }
-              if (!root) {
-                  root = element;
-                  {
-                      checkRootConstraints(root);
-                  }
-              }
-              if (!unary) {
-                  currentParent = element;
-                  stack.push(element);
-              }
-              else {
-                  closeElement(element);
-              }
-          },
-          end(tag, start, end) {
-              const element = stack[stack.length - 1];
-              // pop stack
-              stack.length -= 1;
-              currentParent = stack[stack.length - 1];
-              if (options.outputSourceRange) {
-                  element.end = end;
-              }
-              closeElement(element);
-          },
-          chars(text, start, end) {
-              if (!currentParent) {
-                  {
-                      if (text === template) {
-                          warnOnce('Component template requires a root element, rather than just text.', { start });
-                      }
-                      else if ((text = text.trim())) {
-                          warnOnce(`text "${text}" outside root element will be ignored.`, {
-                              start,
-                          });
-                      }
-                  }
-                  return;
-              }
-              // IE textarea placeholder bug
-              /* istanbul ignore if */
-              if (isIE &&
-                  currentParent.tag === 'textarea' &&
-                  currentParent.attrsMap.placeholder === text) {
-                  return;
-              }
-              const children = currentParent.children;
-              if (inPre || text.trim()) {
-                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-              }
-              else if (!children.length) {
-                  // remove the whitespace-only node right after an opening tag
-                  text = '';
-              }
-              else if (whitespaceOption) {
-                  if (whitespaceOption === 'condense') {
-                      // in condense mode, remove the whitespace node if it contains
-                      // line break, otherwise condense to a single space
-                      text = lineBreakRE.test(text) ? '' : ' ';
-                  }
-                  else {
-                      text = ' ';
-                  }
-              }
-              else {
-                  text = preserveWhitespace ? ' ' : '';
-              }
-              if (text) {
-                  if (!inPre && whitespaceOption === 'condense') {
-                      // condense consecutive whitespaces into single space
-                      text = text.replace(whitespaceRE, ' ');
-                  }
-                  let res;
-                  let child;
-                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                      child = {
-                          type: 2,
-                          expression: res.expression,
-                          tokens: res.tokens,
-                          text,
-                      };
-                  }
-                  else if (text !== ' ' ||
-                      !children.length ||
-                      children[children.length - 1].text !== ' ') {
-                      child = {
-                          type: 3,
-                          text,
-                      };
-                  }
-                  if (child) {
-                      if (options.outputSourceRange) {
-                          child.start = start;
-                          child.end = end;
-                      }
-                      children.push(child);
-                  }
-              }
-          },
-          comment(text, start, end) {
-              // adding anything as a sibling to the root node is forbidden
-              // comments should still be allowed, but ignored
-              if (currentParent) {
-                  const child = {
-                      type: 3,
-                      text,
-                      isComment: true,
-                  };
-                  if (options.outputSourceRange) {
-                      child.start = start;
-                      child.end = end;
-                  }
-                  currentParent.children.push(child);
-              }
-          },
-      });
-      return root;
-  }
-  function processPre(el) {
-      if (getAndRemoveAttr(el, 'v-pre') != null) {
-          el.pre = true;
-      }
-  }
-  function processRawAttrs(el) {
-      const list = el.attrsList;
-      const len = list.length;
-      if (len) {
-          const attrs = (el.attrs = new Array(len));
-          for (let i = 0; i < len; i++) {
-              attrs[i] = {
-                  name: list[i].name,
-                  value: JSON.stringify(list[i].value),
-              };
-              if (list[i].start != null) {
-                  attrs[i].start = list[i].start;
-                  attrs[i].end = list[i].end;
-              }
-          }
-      }
-      else if (!el.pre) {
-          // non root node in pre blocks with no attributes
-          el.plain = true;
-      }
-  }
-  function processElement(element, options) {
-      processKey(element);
-      // determine whether this is a plain element after
-      // removing structural attributes
-      element.plain =
-          !element.key && !element.scopedSlots && !element.attrsList.length;
-      processRef(element);
-      processSlotContent(element);
-      processSlotOutlet(element);
-      processComponent(element);
-      for (let i = 0; i < transforms.length; i++) {
-          element = transforms[i](element, options) || element;
-      }
-      processAttrs(element);
-      return element;
-  }
-  function processKey(el) {
-      const exp = getBindingAttr(el, 'key');
-      if (exp) {
-          {
-              if (el.tag === 'template') {
-                  warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-              }
-              if (el.for) {
-                  const iterator = el.iterator2 || el.iterator1;
-                  const parent = el.parent;
-                  if (iterator &&
-                      iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
-                      warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                  }
-              }
-          }
-          el.key = exp;
-      }
-  }
-  function processRef(el) {
-      const ref = getBindingAttr(el, 'ref');
-      if (ref) {
-          el.ref = ref;
-          el.refInFor = checkInFor(el);
-      }
-  }
-  function processFor(el) {
-      let exp;
-      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-          const res = parseFor(exp);
-          if (res) {
-              extend(el, res);
-          }
-          else {
-              warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-          }
-      }
-  }
-  function parseFor(exp) {
-      const inMatch = exp.match(forAliasRE);
-      if (!inMatch)
-          return;
-      const res = {};
-      res.for = inMatch[2].trim();
-      const alias = inMatch[1].trim().replace(stripParensRE, '');
-      const iteratorMatch = alias.match(forIteratorRE);
-      if (iteratorMatch) {
-          res.alias = alias.replace(forIteratorRE, '').trim();
-          res.iterator1 = iteratorMatch[1].trim();
-          if (iteratorMatch[2]) {
-              res.iterator2 = iteratorMatch[2].trim();
-          }
-      }
-      else {
-          res.alias = alias;
-      }
-      return res;
-  }
-  function processIf(el) {
-      const exp = getAndRemoveAttr(el, 'v-if');
-      if (exp) {
-          el.if = exp;
-          addIfCondition(el, {
-              exp: exp,
-              block: el,
-          });
-      }
-      else {
-          if (getAndRemoveAttr(el, 'v-else') != null) {
-              el.else = true;
-          }
-          const elseif = getAndRemoveAttr(el, 'v-else-if');
-          if (elseif) {
-              el.elseif = elseif;
-          }
-      }
-  }
-  function processIfConditions(el, parent) {
-      const prev = findPrevElement(parent.children);
-      if (prev && prev.if) {
-          addIfCondition(prev, {
-              exp: el.elseif,
-              block: el,
-          });
-      }
-      else {
-          warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-      }
-  }
-  function findPrevElement(children) {
-      let i = children.length;
-      while (i--) {
-          if (children[i].type === 1) {
-              return children[i];
-          }
-          else {
-              if (children[i].text !== ' ') {
-                  warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                      `will be ignored.`, children[i]);
-              }
-              children.pop();
-          }
-      }
-  }
-  function addIfCondition(el, condition) {
-      if (!el.ifConditions) {
-          el.ifConditions = [];
-      }
-      el.ifConditions.push(condition);
-  }
-  function processOnce(el) {
-      const once = getAndRemoveAttr(el, 'v-once');
-      if (once != null) {
-          el.once = true;
-      }
-  }
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent(el) {
-      let slotScope;
-      if (el.tag === 'template') {
-          slotScope = getAndRemoveAttr(el, 'scope');
-          /* istanbul ignore if */
-          if (slotScope) {
-              warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                  `can also be used on plain elements in addition to <template> to ` +
-                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-          }
-          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-      }
-      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-          /* istanbul ignore if */
-          if (el.attrsMap['v-for']) {
-              warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-          }
-          el.slotScope = slotScope;
-      }
-      // slot="xxx"
-      const slotTarget = getBindingAttr(el, 'slot');
-      if (slotTarget) {
-          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-          // preserve slot as an attribute for native shadow DOM compat
-          // only for non-scoped slots.
-          if (el.tag !== 'template' && !el.slotScope) {
-              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-          }
-      }
-      // 2.6 v-slot syntax
-      {
-          if (el.tag === 'template') {
-              // v-slot on <template>
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (el.slotTarget || el.slotScope) {
-                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.parent && !maybeComponent(el.parent)) {
-                          warn$1(`<template v-slot> can only appear at the root level inside ` +
-                              `the receiving component`, el);
-                      }
-                  }
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  el.slotTarget = name;
-                  el.slotTargetDynamic = dynamic;
-                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-              }
-          }
-          else {
-              // v-slot on component, denotes default slot
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (!maybeComponent(el)) {
-                          warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                      }
-                      if (el.slotScope || el.slotTarget) {
-                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.scopedSlots) {
-                          warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                              `<template> syntax when there are other named slots.`, slotBinding);
-                      }
-                  }
-                  // add the component's children to its default slot
-                  const slots = el.scopedSlots || (el.scopedSlots = {});
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  const slotContainer = (slots[name] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name;
-                  slotContainer.slotTargetDynamic = dynamic;
-                  slotContainer.children = el.children.filter((c) => {
-                      if (!c.slotScope) {
-                          c.parent = slotContainer;
-                          return true;
-                      }
-                  });
-                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                  // remove children as they are returned from scopedSlots now
-                  el.children = [];
-                  // mark el non-plain so data gets generated
-                  el.plain = false;
-              }
-          }
-      }
-  }
-  function getSlotName(binding) {
-      let name = binding.name.replace(slotRE, '');
-      if (!name) {
-          if (binding.name[0] !== '#') {
-              name = 'default';
-          }
-          else {
-              warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-          }
-      }
-      return dynamicArgRE.test(name)
-          ? // dynamic [name]
-              { name: name.slice(1, -1), dynamic: true }
-          : // static name
-              { name: `"${name}"`, dynamic: false };
-  }
-  // handle <slot/> outlets
-  function processSlotOutlet(el) {
-      if (el.tag === 'slot') {
-          el.slotName = getBindingAttr(el, 'name');
-          if (el.key) {
-              warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                  `and can possibly expand into multiple elements. ` +
-                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-          }
-      }
-  }
-  function processComponent(el) {
-      let binding;
-      if ((binding = getBindingAttr(el, 'is'))) {
-          el.component = binding;
-      }
-      if (getAndRemoveAttr(el, 'inline-template') != null) {
-          el.inlineTemplate = true;
-      }
-  }
-  function processAttrs(el) {
-      const list = el.attrsList;
-      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-      for (i = 0, l = list.length; i < l; i++) {
-          name = rawName = list[i].name;
-          value = list[i].value;
-          if (dirRE.test(name)) {
-              // mark element as dynamic
-              el.hasBindings = true;
-              // modifiers
-              modifiers = parseModifiers(name.replace(dirRE, ''));
-              // support .foo shorthand syntax for the .prop modifier
-              if (modifiers) {
-                  name = name.replace(modifierRE, '');
-              }
-              if (bindRE.test(name)) {
-                  // v-bind
-                  name = name.replace(bindRE, '');
-                  value = parseFilters(value);
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  if (value.trim().length === 0) {
-                      warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                  }
-                  if (modifiers) {
-                      if (modifiers.prop && !isDynamic) {
-                          name = camelize(name);
-                          if (name === 'innerHtml')
-                              name = 'innerHTML';
-                      }
-                      if (modifiers.camel && !isDynamic) {
-                          name = camelize(name);
-                      }
-                      if (modifiers.sync) {
-                          syncGen = genAssignmentCode(value, `$event`);
-                          if (!isDynamic) {
-                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                              if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                              }
-                          }
-                          else {
-                              // handler w/ dynamic event name
-                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                              );
-                          }
-                      }
-                  }
-                  if ((modifiers && modifiers.prop) ||
-                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                      addProp(el, name, value, list[i], isDynamic);
-                  }
-                  else {
-                      addAttr(el, name, value, list[i], isDynamic);
-                  }
-              }
-              else if (onRE.test(name)) {
-                  // v-on
-                  name = name.replace(onRE, '');
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-              }
-              else {
-                  // normal directives
-                  name = name.replace(dirRE, '');
-                  // parse arg
-                  const argMatch = name.match(argRE);
-                  let arg = argMatch && argMatch[1];
-                  isDynamic = false;
-                  if (arg) {
-                      name = name.slice(0, -(arg.length + 1));
-                      if (dynamicArgRE.test(arg)) {
-                          arg = arg.slice(1, -1);
-                          isDynamic = true;
-                      }
-                  }
-                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                  if (name === 'model') {
-                      checkForAliasModel(el, value);
-                  }
-              }
-          }
-          else {
-              // literal attribute
-              {
-                  const res = parseText(value, delimiters);
-                  if (res) {
-                      warn$1(`${name}="${value}": ` +
-                          'Interpolation inside attributes has been removed. ' +
-                          'Use v-bind or the colon shorthand instead. For example, ' +
-                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                  }
-              }
-              addAttr(el, name, JSON.stringify(value), list[i]);
-              // #6887 firefox doesn't update muted state if set via attribute
-              // even immediately after element creation
-              if (!el.component &&
-                  name === 'muted' &&
-                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                  addProp(el, name, 'true', list[i]);
-              }
-          }
-      }
-  }
-  function checkInFor(el) {
-      let parent = el;
-      while (parent) {
-          if (parent.for !== undefined) {
-              return true;
-          }
-          parent = parent.parent;
-      }
-      return false;
-  }
-  function parseModifiers(name) {
-      const match = name.match(modifierRE);
-      if (match) {
-          const ret = {};
-          match.forEach((m) => {
-              ret[m.slice(1)] = true;
-          });
-          return ret;
-      }
-  }
-  function makeAttrsMap(attrs) {
-      const map = {};
-      for (let i = 0, l = attrs.length; i < l; i++) {
-          if (map[attrs[i].name] &&
-              !isIE &&
-              !isEdge) {
-              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-          }
-          map[attrs[i].name] = attrs[i].value;
-      }
-      return map;
-  }
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag(el) {
-      return el.tag === 'script' || el.tag === 'style';
-  }
-  function isForbiddenTag(el) {
-      return (el.tag === 'style' ||
-          (el.tag === 'script' &&
-              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-  }
-  const ieNSBug = /^xmlns:NS\d+/;
-  const ieNSPrefix = /^NS\d+:/;
-  /* istanbul ignore next */
-  function guardIESVGBug(attrs) {
-      const res = [];
-      for (let i = 0; i < attrs.length; i++) {
-          const attr = attrs[i];
-          if (!ieNSBug.test(attr.name)) {
-              attr.name = attr.name.replace(ieNSPrefix, '');
-              res.push(attr);
-          }
-      }
-      return res;
-  }
-  function checkForAliasModel(el, value) {
-      let _el = el;
-      while (_el) {
-          if (_el.for && _el.alias === value) {
-              warn$1(`<${el.tag} v-model="${value}">: ` +
-                  `You are binding v-model directly to a v-for iteration alias. ` +
-                  `This will not be able to modify the v-for source array because ` +
-                  `writing to the alias is like modifying a function local variable. ` +
-                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-          }
-          _el = _el.parent;
-      }
-  }
-
-  /**
-   * Expand input[v-model] with dynamic type bindings into v-if-else chains
-   * Turn this:
-   *   <input v-model="data[type]" :type="type">
-   * into this:
-   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-   *   <input v-else :type="type" v-model="data[type]">
-   */
-  function preTransformNode(el, options) {
-      if (el.tag === 'input') {
-          const map = el.attrsMap;
-          if (!map['v-model']) {
-              return;
-          }
-          let typeBinding;
-          if (map[':type'] || map['v-bind:type']) {
-              typeBinding = getBindingAttr(el, 'type');
-          }
-          if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = `(${map['v-bind']}).type`;
-          }
-          if (typeBinding) {
-              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-              // 1. checkbox
-              const branch0 = cloneASTElement(el);
-              // process for on the main node
-              processFor(branch0);
-              addRawAttr(branch0, 'type', 'checkbox');
-              processElement(branch0, options);
-              branch0.processed = true; // prevent it from double-processed
-              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-              addIfCondition(branch0, {
-                  exp: branch0.if,
-                  block: branch0,
-              });
-              // 2. add radio else-if condition
-              const branch1 = cloneASTElement(el);
-              getAndRemoveAttr(branch1, 'v-for', true);
-              addRawAttr(branch1, 'type', 'radio');
-              processElement(branch1, options);
-              addIfCondition(branch0, {
-                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                  block: branch1,
-              });
-              // 3. other
-              const branch2 = cloneASTElement(el);
-              getAndRemoveAttr(branch2, 'v-for', true);
-              addRawAttr(branch2, ':type', typeBinding);
-              processElement(branch2, options);
-              addIfCondition(branch0, {
-                  exp: ifCondition,
-                  block: branch2,
-              });
-              if (hasElse) {
-                  branch0.else = true;
-              }
-              else if (elseIfCondition) {
-                  branch0.elseif = elseIfCondition;
-              }
-              return branch0;
-          }
-      }
-  }
-  function cloneASTElement(el) {
-      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-  }
-  var model$1 = {
-      preTransformNode,
+  /**
+   * Not type-checking this file because it's mostly vendor code.
+   */
+  // Regular Expressions for parsing tags and attributes
+  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+  const startTagOpen = new RegExp(`^<${qnameCapture}`);
+  const startTagClose = /^\s*(\/?)>/;
+  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+  const doctype = /^<!DOCTYPE [^>]+>/i;
+  // #7298: escape - to avoid being passed as HTML comment when inlined in page
+  const comment = /^<!\--/;
+  const conditionalComment = /^<!\[/;
+  // Special Elements (can contain anything)
+  const isPlainTextElement = makeMap('script,style,textarea', true);
+  const reCache = {};
+  const decodingMap = {
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&amp;': '&',
+      '&#10;': '\n',
+      '&#9;': '\t',
+      '&#39;': "'",
+  };
+  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+  // #5992
+  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+  function decodeAttr(value, shouldDecodeNewlines) {
+      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+      return value.replace(re, (match) => decodingMap[match]);
+  }
+  function parseHTML(html, options) {
+      const stack = [];
+      const expectHTML = options.expectHTML;
+      const isUnaryTag = options.isUnaryTag || no;
+      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+      let index = 0;
+      let last, lastTag;
+      while (html) {
+          last = html;
+          // Make sure we're not in a plaintext content element like script/style
+          if (!lastTag || !isPlainTextElement(lastTag)) {
+              let textEnd = html.indexOf('<');
+              if (textEnd === 0) {
+                  // Comment:
+                  if (comment.test(html)) {
+                      const commentEnd = html.indexOf('-->');
+                      if (commentEnd >= 0) {
+                          if (options.shouldKeepComment) {
+                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                          }
+                          advance(commentEnd + 3);
+                          continue;
+                      }
+                  }
+                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  if (conditionalComment.test(html)) {
+                      const conditionalEnd = html.indexOf(']>');
+                      if (conditionalEnd >= 0) {
+                          advance(conditionalEnd + 2);
+                          continue;
+                      }
+                  }
+                  // Doctype:
+                  const doctypeMatch = html.match(doctype);
+                  if (doctypeMatch) {
+                      advance(doctypeMatch[0].length);
+                      continue;
+                  }
+                  // End tag:
+                  const endTagMatch = html.match(endTag);
+                  if (endTagMatch) {
+                      const curIndex = index;
+                      advance(endTagMatch[0].length);
+                      parseEndTag(endTagMatch[1], curIndex, index);
+                      continue;
+                  }
+                  // Start tag:
+                  const startTagMatch = parseStartTag();
+                  if (startTagMatch) {
+                      handleStartTag(startTagMatch);
+                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                          advance(1);
+                      }
+                      continue;
+                  }
+              }
+              let text, rest, next;
+              if (textEnd >= 0) {
+                  rest = html.slice(textEnd);
+                  while (!endTag.test(rest) &&
+                      !startTagOpen.test(rest) &&
+                      !comment.test(rest) &&
+                      !conditionalComment.test(rest)) {
+                      // < in plain text, be forgiving and treat it as text
+                      next = rest.indexOf('<', 1);
+                      if (next < 0)
+                          break;
+                      textEnd += next;
+                      rest = html.slice(textEnd);
+                  }
+                  text = html.substring(0, textEnd);
+              }
+              if (textEnd < 0) {
+                  text = html;
+              }
+              if (text) {
+                  advance(text.length);
+              }
+              if (options.chars && text) {
+                  options.chars(text, index - text.length, index);
+              }
+          }
+          else {
+              let endTagLength = 0;
+              const stackedTag = lastTag.toLowerCase();
+              const reStackedTag = reCache[stackedTag] ||
+                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+              const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                  endTagLength = endTag.length;
+                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                      text = text
+                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                  }
+                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                      text = text.slice(1);
+                  }
+                  if (options.chars) {
+                      options.chars(text);
+                  }
+                  return '';
+              });
+              index += html.length - rest.length;
+              html = rest;
+              parseEndTag(stackedTag, index - endTagLength, index);
+          }
+          if (html === last) {
+              options.chars && options.chars(html);
+              if (!stack.length &&
+                  options.warn) {
+                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                      start: index + html.length,
+                  });
+              }
+              break;
+          }
+      }
+      // Clean up any remaining tags
+      parseEndTag();
+      function advance(n) {
+          index += n;
+          html = html.substring(n);
+      }
+      function parseStartTag() {
+          const start = html.match(startTagOpen);
+          if (start) {
+              const match = {
+                  tagName: start[1],
+                  attrs: [],
+                  start: index,
+              };
+              advance(start[0].length);
+              let end, attr;
+              while (!(end = html.match(startTagClose)) &&
+                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                  attr.start = index;
+                  advance(attr[0].length);
+                  attr.end = index;
+                  match.attrs.push(attr);
+              }
+              if (end) {
+                  match.unarySlash = end[1];
+                  advance(end[0].length);
+                  match.end = index;
+                  return match;
+              }
+          }
+      }
+      function handleStartTag(match) {
+          const tagName = match.tagName;
+          const unarySlash = match.unarySlash;
+          if (expectHTML) {
+              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                  parseEndTag(lastTag);
+              }
+              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                  parseEndTag(tagName);
+              }
+          }
+          const unary = isUnaryTag(tagName) || !!unarySlash;
+          const l = match.attrs.length;
+          const attrs = new Array(l);
+          for (let i = 0; i < l; i++) {
+              const args = match.attrs[i];
+              const value = args[3] || args[4] || args[5] || '';
+              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                  ? options.shouldDecodeNewlinesForHref
+                  : options.shouldDecodeNewlines;
+              attrs[i] = {
+                  name: args[1],
+                  value: decodeAttr(value, shouldDecodeNewlines),
+              };
+              if (options.outputSourceRange) {
+                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                  attrs[i].end = args.end;
+              }
+          }
+          if (!unary) {
+              stack.push({
+                  tag: tagName,
+                  lowerCasedTag: tagName.toLowerCase(),
+                  attrs: attrs,
+                  start: match.start,
+                  end: match.end,
+              });
+              lastTag = tagName;
+          }
+          if (options.start) {
+              options.start(tagName, attrs, unary, match.start, match.end);
+          }
+      }
+      function parseEndTag(tagName, start, end) {
+          let pos, lowerCasedTagName;
+          if (start == null)
+              start = index;
+          if (end == null)
+              end = index;
+          // Find the closest opened tag of the same type
+          if (tagName) {
+              lowerCasedTagName = tagName.toLowerCase();
+              for (pos = stack.length - 1; pos >= 0; pos--) {
+                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                      break;
+                  }
+              }
+          }
+          else {
+              // If no tag name is provided, clean shop
+              pos = 0;
+          }
+          if (pos >= 0) {
+              // Close all the open elements, up the stack
+              for (let i = stack.length - 1; i >= pos; i--) {
+                  if ((i > pos || !tagName) &&
+                      options.warn) {
+                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                          start: stack[i].start,
+                          end: stack[i].end,
+                      });
+                  }
+                  if (options.end) {
+                      options.end(stack[i].tag, start, end);
+                  }
+              }
+              // Remove the open elements from the stack
+              stack.length = pos;
+              lastTag = pos && stack[pos - 1].tag;
+          }
+          else if (lowerCasedTagName === 'br') {
+              if (options.start) {
+                  options.start(tagName, [], true, start, end);
+              }
+          }
+          else if (lowerCasedTagName === 'p') {
+              if (options.start) {
+                  options.start(tagName, [], false, start, end);
+              }
+              if (options.end) {
+                  options.end(tagName, start, end);
+              }
+          }
+      }
+  }
+
+  /**
+   * Cross-platform code generation for component v-model
+   */
+  function genComponentModel(el, value, modifiers) {
+      const { number, trim } = modifiers || {};
+      const baseValueExpression = '$$v';
+      let valueExpression = baseValueExpression;
+      if (trim) {
+          valueExpression =
+              `(typeof ${baseValueExpression} === 'string'` +
+                  `? ${baseValueExpression}.trim()` +
+                  `: ${baseValueExpression})`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      const assignment = genAssignmentCode(value, valueExpression);
+      el.model = {
+          value: `(${value})`,
+          expression: JSON.stringify(value),
+          callback: `function (${baseValueExpression}) {${assignment}}`,
+      };
+  }
+  /**
+   * Cross-platform codegen helper for generating v-model value assignment code.
+   */
+  function genAssignmentCode(value, assignment) {
+      const res = parseModel(value);
+      if (res.key === null) {
+          return `${value}=${assignment}`;
+      }
+      else {
+          return `$set(${res.exp}, ${res.key}, ${assignment})`;
+      }
+  }
+  /**
+   * Parse a v-model expression into a base path and a final key segment.
+   * Handles both dot-path and possible square brackets.
+   *
+   * Possible cases:
+   *
+   * - test
+   * - test[key]
+   * - test[test1[key]]
+   * - test["a"][key]
+   * - xxx.test[a[a].test1[key]]
+   * - test.xxx.a["asa"][test1[key]]
+   *
+   */
+  let len, str, chr, index, expressionPos, expressionEndPos;
+  function parseModel(val) {
+      // Fix https://github.com/vuejs/vue/pull/7730
+      // allow v-model="obj.val " (trailing whitespace)
+      val = val.trim();
+      len = val.length;
+      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+          index = val.lastIndexOf('.');
+          if (index > -1) {
+              return {
+                  exp: val.slice(0, index),
+                  key: '"' + val.slice(index + 1) + '"',
+              };
+          }
+          else {
+              return {
+                  exp: val,
+                  key: null,
+              };
+          }
+      }
+      str = val;
+      index = expressionPos = expressionEndPos = 0;
+      while (!eof()) {
+          chr = next();
+          /* istanbul ignore if */
+          if (isStringStart(chr)) {
+              parseString(chr);
+          }
+          else if (chr === 0x5b) {
+              parseBracket(chr);
+          }
+      }
+      return {
+          exp: val.slice(0, expressionPos),
+          key: val.slice(expressionPos + 1, expressionEndPos),
+      };
+  }
+  function next() {
+      return str.charCodeAt(++index);
+  }
+  function eof() {
+      return index >= len;
+  }
+  function isStringStart(chr) {
+      return chr === 0x22 || chr === 0x27;
+  }
+  function parseBracket(chr) {
+      let inBracket = 1;
+      expressionPos = index;
+      while (!eof()) {
+          chr = next();
+          if (isStringStart(chr)) {
+              parseString(chr);
+              continue;
+          }
+          if (chr === 0x5b)
+              inBracket++;
+          if (chr === 0x5d)
+              inBracket--;
+          if (inBracket === 0) {
+              expressionEndPos = index;
+              break;
+          }
+      }
+  }
+  function parseString(chr) {
+      const stringQuote = chr;
+      while (!eof()) {
+          chr = next();
+          if (chr === stringQuote) {
+              break;
+          }
+      }
+  }
+
+  const onRE = /^@|^v-on:/;
+  const dirRE = /^v-|^@|^:|^#/;
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  const dynamicArgRE = /^\[.*\]$/;
+  const argRE = /:(.*)$/;
+  const bindRE = /^:|^\.|^v-bind:/;
+  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+  const slotRE = /^v-slot(:|$)|^#/;
+  const lineBreakRE = /[\r\n]/;
+  const whitespaceRE = /[ \f\t\r\n]+/g;
+  const invalidAttributeRE = /[\s"'<>\/=]/;
+  const decodeHTMLCached = cached(he.decode);
+  const emptySlotScopeToken = `_empty_`;
+  // configurable state
+  let warn$1;
+  let delimiters;
+  let transforms;
+  let preTransforms;
+  let postTransforms;
+  let platformIsPreTag;
+  let platformMustUseProp;
+  let platformGetTagNamespace;
+  let maybeComponent;
+  function createASTElement(tag, attrs, parent) {
+      return {
+          type: 1,
+          tag,
+          attrsList: attrs,
+          attrsMap: makeAttrsMap(attrs),
+          rawAttrsMap: {},
+          parent,
+          children: [],
+      };
+  }
+  /**
+   * Convert HTML string to AST.
+   */
+  function parse(template, options) {
+      warn$1 = options.warn || baseWarn;
+      platformIsPreTag = options.isPreTag || no;
+      platformMustUseProp = options.mustUseProp || no;
+      platformGetTagNamespace = options.getTagNamespace || no;
+      const isReservedTag = options.isReservedTag || no;
+      maybeComponent = (el) => !!(el.component ||
+          el.attrsMap[':is'] ||
+          el.attrsMap['v-bind:is'] ||
+          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+      transforms = pluckModuleFunction(options.modules, 'transformNode');
+      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+      delimiters = options.delimiters;
+      const stack = [];
+      const preserveWhitespace = options.preserveWhitespace !== false;
+      const whitespaceOption = options.whitespace;
+      let root;
+      let currentParent;
+      let inVPre = false;
+      let inPre = false;
+      let warned = false;
+      function warnOnce(msg, range) {
+          if (!warned) {
+              warned = true;
+              warn$1(msg, range);
+          }
+      }
+      function closeElement(element) {
+          trimEndingWhitespace(element);
+          if (!inVPre && !element.processed) {
+              element = processElement(element, options);
+          }
+          // tree management
+          if (!stack.length && element !== root) {
+              // allow root elements with v-if, v-else-if and v-else
+              if (root.if && (element.elseif || element.else)) {
+                  {
+                      checkRootConstraints(element);
+                  }
+                  addIfCondition(root, {
+                      exp: element.elseif,
+                      block: element,
+                  });
+              }
+              else {
+                  warnOnce(`Component template should contain exactly one root element. ` +
+                      `If you are using v-if on multiple elements, ` +
+                      `use v-else-if to chain them instead.`, { start: element.start });
+              }
+          }
+          if (currentParent && !element.forbidden) {
+              if (element.elseif || element.else) {
+                  processIfConditions(element, currentParent);
+              }
+              else {
+                  if (element.slotScope) {
+                      // scoped slot
+                      // keep it in the children list so that v-else(-if) conditions can
+                      // find it as the prev node.
+                      const name = element.slotTarget || '"default"';
+                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                  }
+                  currentParent.children.push(element);
+                  element.parent = currentParent;
+              }
+          }
+          // final children cleanup
+          // filter out scoped slots
+          element.children = element.children.filter((c) => !c.slotScope);
+          // remove trailing whitespace node again
+          trimEndingWhitespace(element);
+          // check pre state
+          if (element.pre) {
+              inVPre = false;
+          }
+          if (platformIsPreTag(element.tag)) {
+              inPre = false;
+          }
+          // apply post-transforms
+          for (let i = 0; i < postTransforms.length; i++) {
+              postTransforms[i](element, options);
+          }
+      }
+      function trimEndingWhitespace(el) {
+          // remove trailing whitespace node
+          if (!inPre) {
+              let lastNode;
+              while ((lastNode = el.children[el.children.length - 1]) &&
+                  lastNode.type === 3 &&
+                  lastNode.text === ' ') {
+                  el.children.pop();
+              }
+          }
+      }
+      function checkRootConstraints(el) {
+          if (el.tag === 'slot' || el.tag === 'template') {
+              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                  'contain multiple nodes.', { start: el.start });
+          }
+          if (el.attrsMap.hasOwnProperty('v-for')) {
+              warnOnce('Cannot use v-for on stateful component root element because ' +
+                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
+          }
+      }
+      parseHTML(template, {
+          warn: warn$1,
+          expectHTML: options.expectHTML,
+          isUnaryTag: options.isUnaryTag,
+          canBeLeftOpenTag: options.canBeLeftOpenTag,
+          shouldDecodeNewlines: options.shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+          shouldKeepComment: options.comments,
+          outputSourceRange: options.outputSourceRange,
+          start(tag, attrs, unary, start, end) {
+              // check namespace.
+              // inherit parent ns if there is one
+              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+              // handle IE svg bug
+              /* istanbul ignore if */
+              if (isIE && ns === 'svg') {
+                  attrs = guardIESVGBug(attrs);
+              }
+              let element = createASTElement(tag, attrs, currentParent);
+              if (ns) {
+                  element.ns = ns;
+              }
+              {
+                  if (options.outputSourceRange) {
+                      element.start = start;
+                      element.end = end;
+                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                          cumulated[attr.name] = attr;
+                          return cumulated;
+                      }, {});
+                  }
+                  attrs.forEach((attr) => {
+                      if (invalidAttributeRE.test(attr.name)) {
+                          warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                              `spaces, quotes, <, >, / or =.`, {
+                              start: attr.start + attr.name.indexOf(`[`),
+                              end: attr.start + attr.name.length,
+                          });
+                      }
+                  });
+              }
+              if (isForbiddenTag(element) && !isServerRendering()) {
+                  element.forbidden = true;
+                  warn$1('Templates should only be responsible for mapping the state to the ' +
+                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                          `<${tag}>` +
+                          ', as they will not be parsed.', { start: element.start });
+              }
+              // apply pre-transforms
+              for (let i = 0; i < preTransforms.length; i++) {
+                  element = preTransforms[i](element, options) || element;
+              }
+              if (!inVPre) {
+                  processPre(element);
+                  if (element.pre) {
+                      inVPre = true;
+                  }
+              }
+              if (platformIsPreTag(element.tag)) {
+                  inPre = true;
+              }
+              if (inVPre) {
+                  processRawAttrs(element);
+              }
+              else if (!element.processed) {
+                  // structural directives
+                  processFor(element);
+                  processIf(element);
+                  processOnce(element);
+              }
+              if (!root) {
+                  root = element;
+                  {
+                      checkRootConstraints(root);
+                  }
+              }
+              if (!unary) {
+                  currentParent = element;
+                  stack.push(element);
+              }
+              else {
+                  closeElement(element);
+              }
+          },
+          end(tag, start, end) {
+              const element = stack[stack.length - 1];
+              // pop stack
+              stack.length -= 1;
+              currentParent = stack[stack.length - 1];
+              if (options.outputSourceRange) {
+                  element.end = end;
+              }
+              closeElement(element);
+          },
+          chars(text, start, end) {
+              if (!currentParent) {
+                  {
+                      if (text === template) {
+                          warnOnce('Component template requires a root element, rather than just text.', { start });
+                      }
+                      else if ((text = text.trim())) {
+                          warnOnce(`text "${text}" outside root element will be ignored.`, {
+                              start,
+                          });
+                      }
+                  }
+                  return;
+              }
+              // IE textarea placeholder bug
+              /* istanbul ignore if */
+              if (isIE &&
+                  currentParent.tag === 'textarea' &&
+                  currentParent.attrsMap.placeholder === text) {
+                  return;
+              }
+              const children = currentParent.children;
+              if (inPre || text.trim()) {
+                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+              }
+              else if (!children.length) {
+                  // remove the whitespace-only node right after an opening tag
+                  text = '';
+              }
+              else if (whitespaceOption) {
+                  if (whitespaceOption === 'condense') {
+                      // in condense mode, remove the whitespace node if it contains
+                      // line break, otherwise condense to a single space
+                      text = lineBreakRE.test(text) ? '' : ' ';
+                  }
+                  else {
+                      text = ' ';
+                  }
+              }
+              else {
+                  text = preserveWhitespace ? ' ' : '';
+              }
+              if (text) {
+                  if (!inPre && whitespaceOption === 'condense') {
+                      // condense consecutive whitespaces into single space
+                      text = text.replace(whitespaceRE, ' ');
+                  }
+                  let res;
+                  let child;
+                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                      child = {
+                          type: 2,
+                          expression: res.expression,
+                          tokens: res.tokens,
+                          text,
+                      };
+                  }
+                  else if (text !== ' ' ||
+                      !children.length ||
+                      children[children.length - 1].text !== ' ') {
+                      child = {
+                          type: 3,
+                          text,
+                      };
+                  }
+                  if (child) {
+                      if (options.outputSourceRange) {
+                          child.start = start;
+                          child.end = end;
+                      }
+                      children.push(child);
+                  }
+              }
+          },
+          comment(text, start, end) {
+              // adding anything as a sibling to the root node is forbidden
+              // comments should still be allowed, but ignored
+              if (currentParent) {
+                  const child = {
+                      type: 3,
+                      text,
+                      isComment: true,
+                  };
+                  if (options.outputSourceRange) {
+                      child.start = start;
+                      child.end = end;
+                  }
+                  currentParent.children.push(child);
+              }
+          },
+      });
+      return root;
+  }
+  function processPre(el) {
+      if (getAndRemoveAttr(el, 'v-pre') != null) {
+          el.pre = true;
+      }
+  }
+  function processRawAttrs(el) {
+      const list = el.attrsList;
+      const len = list.length;
+      if (len) {
+          const attrs = (el.attrs = new Array(len));
+          for (let i = 0; i < len; i++) {
+              attrs[i] = {
+                  name: list[i].name,
+                  value: JSON.stringify(list[i].value),
+              };
+              if (list[i].start != null) {
+                  attrs[i].start = list[i].start;
+                  attrs[i].end = list[i].end;
+              }
+          }
+      }
+      else if (!el.pre) {
+          // non root node in pre blocks with no attributes
+          el.plain = true;
+      }
+  }
+  function processElement(element, options) {
+      processKey(element);
+      // determine whether this is a plain element after
+      // removing structural attributes
+      element.plain =
+          !element.key && !element.scopedSlots && !element.attrsList.length;
+      processRef(element);
+      processSlotContent(element);
+      processSlotOutlet(element);
+      processComponent(element);
+      for (let i = 0; i < transforms.length; i++) {
+          element = transforms[i](element, options) || element;
+      }
+      processAttrs(element);
+      return element;
+  }
+  function processKey(el) {
+      const exp = getBindingAttr(el, 'key');
+      if (exp) {
+          {
+              if (el.tag === 'template') {
+                  warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+              }
+              if (el.for) {
+                  const iterator = el.iterator2 || el.iterator1;
+                  const parent = el.parent;
+                  if (iterator &&
+                      iterator === exp &&
+                      parent &&
+                      parent.tag === 'transition-group') {
+                      warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                  }
+              }
+          }
+          el.key = exp;
+      }
+  }
+  function processRef(el) {
+      const ref = getBindingAttr(el, 'ref');
+      if (ref) {
+          el.ref = ref;
+          el.refInFor = checkInFor(el);
+      }
+  }
+  function processFor(el) {
+      let exp;
+      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+          const res = parseFor(exp);
+          if (res) {
+              extend(el, res);
+          }
+          else {
+              warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+          }
+      }
+  }
+  function parseFor(exp) {
+      const inMatch = exp.match(forAliasRE);
+      if (!inMatch)
+          return;
+      const res = {};
+      res.for = inMatch[2].trim();
+      const alias = inMatch[1].trim().replace(stripParensRE, '');
+      const iteratorMatch = alias.match(forIteratorRE);
+      if (iteratorMatch) {
+          res.alias = alias.replace(forIteratorRE, '').trim();
+          res.iterator1 = iteratorMatch[1].trim();
+          if (iteratorMatch[2]) {
+              res.iterator2 = iteratorMatch[2].trim();
+          }
+      }
+      else {
+          res.alias = alias;
+      }
+      return res;
+  }
+  function processIf(el) {
+      const exp = getAndRemoveAttr(el, 'v-if');
+      if (exp) {
+          el.if = exp;
+          addIfCondition(el, {
+              exp: exp,
+              block: el,
+          });
+      }
+      else {
+          if (getAndRemoveAttr(el, 'v-else') != null) {
+              el.else = true;
+          }
+          const elseif = getAndRemoveAttr(el, 'v-else-if');
+          if (elseif) {
+              el.elseif = elseif;
+          }
+      }
+  }
+  function processIfConditions(el, parent) {
+      const prev = findPrevElement(parent.children);
+      if (prev && prev.if) {
+          addIfCondition(prev, {
+              exp: el.elseif,
+              block: el,
+          });
+      }
+      else {
+          warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+      }
+  }
+  function findPrevElement(children) {
+      let i = children.length;
+      while (i--) {
+          if (children[i].type === 1) {
+              return children[i];
+          }
+          else {
+              if (children[i].text !== ' ') {
+                  warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                      `will be ignored.`, children[i]);
+              }
+              children.pop();
+          }
+      }
+  }
+  function addIfCondition(el, condition) {
+      if (!el.ifConditions) {
+          el.ifConditions = [];
+      }
+      el.ifConditions.push(condition);
+  }
+  function processOnce(el) {
+      const once = getAndRemoveAttr(el, 'v-once');
+      if (once != null) {
+          el.once = true;
+      }
+  }
+  // handle content being passed to a component as slot,
+  // e.g. <template slot="xxx">, <div slot-scope="xxx">
+  function processSlotContent(el) {
+      let slotScope;
+      if (el.tag === 'template') {
+          slotScope = getAndRemoveAttr(el, 'scope');
+          /* istanbul ignore if */
+          if (slotScope) {
+              warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                  `can also be used on plain elements in addition to <template> to ` +
+                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+          }
+          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+      }
+      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+          /* istanbul ignore if */
+          if (el.attrsMap['v-for']) {
+              warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+          }
+          el.slotScope = slotScope;
+      }
+      // slot="xxx"
+      const slotTarget = getBindingAttr(el, 'slot');
+      if (slotTarget) {
+          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+          // preserve slot as an attribute for native shadow DOM compat
+          // only for non-scoped slots.
+          if (el.tag !== 'template' && !el.slotScope) {
+              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+          }
+      }
+      // 2.6 v-slot syntax
+      {
+          if (el.tag === 'template') {
+              // v-slot on <template>
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (el.slotTarget || el.slotScope) {
+                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.parent && !maybeComponent(el.parent)) {
+                          warn$1(`<template v-slot> can only appear at the root level inside ` +
+                              `the receiving component`, el);
+                      }
+                  }
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  el.slotTarget = name;
+                  el.slotTargetDynamic = dynamic;
+                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+              }
+          }
+          else {
+              // v-slot on component, denotes default slot
+              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+              if (slotBinding) {
+                  {
+                      if (!maybeComponent(el)) {
+                          warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                      }
+                      if (el.slotScope || el.slotTarget) {
+                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                      }
+                      if (el.scopedSlots) {
+                          warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                              `<template> syntax when there are other named slots.`, slotBinding);
+                      }
+                  }
+                  // add the component's children to its default slot
+                  const slots = el.scopedSlots || (el.scopedSlots = {});
+                  const { name, dynamic } = getSlotName(slotBinding);
+                  const slotContainer = (slots[name] = createASTElement('template', [], el));
+                  slotContainer.slotTarget = name;
+                  slotContainer.slotTargetDynamic = dynamic;
+                  slotContainer.children = el.children.filter((c) => {
+                      if (!c.slotScope) {
+                          c.parent = slotContainer;
+                          return true;
+                      }
+                  });
+                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                  // remove children as they are returned from scopedSlots now
+                  el.children = [];
+                  // mark el non-plain so data gets generated
+                  el.plain = false;
+              }
+          }
+      }
+  }
+  function getSlotName(binding) {
+      let name = binding.name.replace(slotRE, '');
+      if (!name) {
+          if (binding.name[0] !== '#') {
+              name = 'default';
+          }
+          else {
+              warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+          }
+      }
+      return dynamicArgRE.test(name)
+          ? // dynamic [name]
+              { name: name.slice(1, -1), dynamic: true }
+          : // static name
+              { name: `"${name}"`, dynamic: false };
+  }
+  // handle <slot/> outlets
+  function processSlotOutlet(el) {
+      if (el.tag === 'slot') {
+          el.slotName = getBindingAttr(el, 'name');
+          if (el.key) {
+              warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                  `and can possibly expand into multiple elements. ` +
+                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+          }
+      }
+  }
+  function processComponent(el) {
+      let binding;
+      if ((binding = getBindingAttr(el, 'is'))) {
+          el.component = binding;
+      }
+      if (getAndRemoveAttr(el, 'inline-template') != null) {
+          el.inlineTemplate = true;
+      }
+  }
+  function processAttrs(el) {
+      const list = el.attrsList;
+      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+      for (i = 0, l = list.length; i < l; i++) {
+          name = rawName = list[i].name;
+          value = list[i].value;
+          if (dirRE.test(name)) {
+              // mark element as dynamic
+              el.hasBindings = true;
+              // modifiers
+              modifiers = parseModifiers(name.replace(dirRE, ''));
+              // support .foo shorthand syntax for the .prop modifier
+              if (modifiers) {
+                  name = name.replace(modifierRE, '');
+              }
+              if (bindRE.test(name)) {
+                  // v-bind
+                  name = name.replace(bindRE, '');
+                  value = parseFilters(value);
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  if (value.trim().length === 0) {
+                      warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                  }
+                  if (modifiers) {
+                      if (modifiers.prop && !isDynamic) {
+                          name = camelize(name);
+                          if (name === 'innerHtml')
+                              name = 'innerHTML';
+                      }
+                      if (modifiers.camel && !isDynamic) {
+                          name = camelize(name);
+                      }
+                      if (modifiers.sync) {
+                          syncGen = genAssignmentCode(value, `$event`);
+                          if (!isDynamic) {
+                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                              if (hyphenate(name) !== camelize(name)) {
+                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                              }
+                          }
+                          else {
+                              // handler w/ dynamic event name
+                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                              );
+                          }
+                      }
+                  }
+                  if ((modifiers && modifiers.prop) ||
+                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                      addProp(el, name, value, list[i], isDynamic);
+                  }
+                  else {
+                      addAttr(el, name, value, list[i], isDynamic);
+                  }
+              }
+              else if (onRE.test(name)) {
+                  // v-on
+                  name = name.replace(onRE, '');
+                  isDynamic = dynamicArgRE.test(name);
+                  if (isDynamic) {
+                      name = name.slice(1, -1);
+                  }
+                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+              }
+              else {
+                  // normal directives
+                  name = name.replace(dirRE, '');
+                  // parse arg
+                  const argMatch = name.match(argRE);
+                  let arg = argMatch && argMatch[1];
+                  isDynamic = false;
+                  if (arg) {
+                      name = name.slice(0, -(arg.length + 1));
+                      if (dynamicArgRE.test(arg)) {
+                          arg = arg.slice(1, -1);
+                          isDynamic = true;
+                      }
+                  }
+                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                  if (name === 'model') {
+                      checkForAliasModel(el, value);
+                  }
+              }
+          }
+          else {
+              // literal attribute
+              {
+                  const res = parseText(value, delimiters);
+                  if (res) {
+                      warn$1(`${name}="${value}": ` +
+                          'Interpolation inside attributes has been removed. ' +
+                          'Use v-bind or the colon shorthand instead. For example, ' +
+                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                  }
+              }
+              addAttr(el, name, JSON.stringify(value), list[i]);
+              // #6887 firefox doesn't update muted state if set via attribute
+              // even immediately after element creation
+              if (!el.component &&
+                  name === 'muted' &&
+                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                  addProp(el, name, 'true', list[i]);
+              }
+          }
+      }
+  }
+  function checkInFor(el) {
+      let parent = el;
+      while (parent) {
+          if (parent.for !== undefined) {
+              return true;
+          }
+          parent = parent.parent;
+      }
+      return false;
+  }
+  function parseModifiers(name) {
+      const match = name.match(modifierRE);
+      if (match) {
+          const ret = {};
+          match.forEach((m) => {
+              ret[m.slice(1)] = true;
+          });
+          return ret;
+      }
+  }
+  function makeAttrsMap(attrs) {
+      const map = {};
+      for (let i = 0, l = attrs.length; i < l; i++) {
+          if (map[attrs[i].name] &&
+              !isIE &&
+              !isEdge) {
+              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+          }
+          map[attrs[i].name] = attrs[i].value;
+      }
+      return map;
+  }
+  // for script (e.g. type="x/template") or style, do not decode content
+  function isTextTag(el) {
+      return el.tag === 'script' || el.tag === 'style';
+  }
+  function isForbiddenTag(el) {
+      return (el.tag === 'style' ||
+          (el.tag === 'script' &&
+              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+  }
+  const ieNSBug = /^xmlns:NS\d+/;
+  const ieNSPrefix = /^NS\d+:/;
+  /* istanbul ignore next */
+  function guardIESVGBug(attrs) {
+      const res = [];
+      for (let i = 0; i < attrs.length; i++) {
+          const attr = attrs[i];
+          if (!ieNSBug.test(attr.name)) {
+              attr.name = attr.name.replace(ieNSPrefix, '');
+              res.push(attr);
+          }
+      }
+      return res;
+  }
+  function checkForAliasModel(el, value) {
+      let _el = el;
+      while (_el) {
+          if (_el.for && _el.alias === value) {
+              warn$1(`<${el.tag} v-model="${value}">: ` +
+                  `You are binding v-model directly to a v-for iteration alias. ` +
+                  `This will not be able to modify the v-for source array because ` +
+                  `writing to the alias is like modifying a function local variable. ` +
+                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+          }
+          _el = _el.parent;
+      }
+  }
+
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
+  function preTransformNode(el, options) {
+      if (el.tag === 'input') {
+          const map = el.attrsMap;
+          if (!map['v-model']) {
+              return;
+          }
+          let typeBinding;
+          if (map[':type'] || map['v-bind:type']) {
+              typeBinding = getBindingAttr(el, 'type');
+          }
+          if (!map.type && !typeBinding && map['v-bind']) {
+              typeBinding = `(${map['v-bind']}).type`;
+          }
+          if (typeBinding) {
+              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+              // 1. checkbox
+              const branch0 = cloneASTElement(el);
+              // process for on the main node
+              processFor(branch0);
+              addRawAttr(branch0, 'type', 'checkbox');
+              processElement(branch0, options);
+              branch0.processed = true; // prevent it from double-processed
+              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+              addIfCondition(branch0, {
+                  exp: branch0.if,
+                  block: branch0,
+              });
+              // 2. add radio else-if condition
+              const branch1 = cloneASTElement(el);
+              getAndRemoveAttr(branch1, 'v-for', true);
+              addRawAttr(branch1, 'type', 'radio');
+              processElement(branch1, options);
+              addIfCondition(branch0, {
+                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                  block: branch1,
+              });
+              // 3. other
+              const branch2 = cloneASTElement(el);
+              getAndRemoveAttr(branch2, 'v-for', true);
+              addRawAttr(branch2, ':type', typeBinding);
+              processElement(branch2, options);
+              addIfCondition(branch0, {
+                  exp: ifCondition,
+                  block: branch2,
+              });
+              if (hasElse) {
+                  branch0.else = true;
+              }
+              else if (elseIfCondition) {
+                  branch0.elseif = elseIfCondition;
+              }
+              return branch0;
+          }
+      }
+  }
+  function cloneASTElement(el) {
+      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+  }
+  var model$1 = {
+      preTransformNode,
   };
 
   var modules = [klass, style, model$1];
 
-  let warn;
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
-  function model(el, dir, _warn) {
-      warn = _warn;
-      const value = dir.value;
-      const modifiers = dir.modifiers;
-      const tag = el.tag;
-      const type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const valueBinding = getBindingAttr(el, 'value') || 'null';
-      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', `Array.isArray(${value})` +
-          `?_i(${value},${valueBinding})>-1` +
-          (trueValueBinding === 'true'
-              ? `:(${value})`
-              : `:_q(${value},${trueValueBinding})`));
-      addHandler(el, 'change', `var $$a=${value},` +
-          '$$el=$event.target,' +
-          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-          'if(Array.isArray($$a)){' +
-          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      let valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-      addProp(el, 'checked', `_q(${value},${valueBinding})`);
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const selectedVal = `Array.prototype.filter` +
-          `.call($event.target.options,function(o){return o.selected})` +
-          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-          `return ${number ? '_n(val)' : 'val'}})`;
-      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      let code = `var $$selectedVal = ${selectedVal};`;
-      code = `${code} ${genAssignmentCode(value, assignment)}`;
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      const type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value && !typeBinding) {
-              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      const { lazy, number, trim } = modifiers || {};
-      const needCompositionGuard = !lazy && type !== 'range';
-      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      let valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = `$event.target.value.trim()`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      let code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = `if($event.target.composing)return;${code}`;
-      }
-      addProp(el, 'value', `(${value})`);
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
-  }
-
-  function text(el, dir) {
-      if (dir.value) {
-          addProp(el, 'textContent', `_s(${dir.value})`, dir);
-      }
-  }
-
-  function html(el, dir) {
-      if (dir.value) {
-          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-      }
-  }
-
-  var directives = {
-      model,
-      text,
-      html,
+  let warn;
+  // in some cases, the event used has to be determined at runtime
+  // so we used some reserved tokens during compile.
+  const RANGE_TOKEN = '__r';
+  function model(el, dir, _warn) {
+      warn = _warn;
+      const value = dir.value;
+      const modifiers = dir.modifiers;
+      const tag = el.tag;
+      const type = el.attrsMap.type;
+      {
+          // inputs with type="file" are read only and setting the input's
+          // value will throw an error.
+          if (tag === 'input' && type === 'file') {
+              warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+          }
+      }
+      if (el.component) {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      else if (tag === 'select') {
+          genSelect(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'checkbox') {
+          genCheckboxModel(el, value, modifiers);
+      }
+      else if (tag === 'input' && type === 'radio') {
+          genRadioModel(el, value, modifiers);
+      }
+      else if (tag === 'input' || tag === 'textarea') {
+          genDefaultModel(el, value, modifiers);
+      }
+      else {
+          genComponentModel(el, value, modifiers);
+          // component v-model doesn't need extra runtime
+          return false;
+      }
+      // ensure runtime directive metadata
+      return true;
+  }
+  function genCheckboxModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const valueBinding = getBindingAttr(el, 'value') || 'null';
+      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+      addProp(el, 'checked', `Array.isArray(${value})` +
+          `?_i(${value},${valueBinding})>-1` +
+          (trueValueBinding === 'true'
+              ? `:(${value})`
+              : `:_q(${value},${trueValueBinding})`));
+      addHandler(el, 'change', `var $$a=${value},` +
+          '$$el=$event.target,' +
+          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+          'if(Array.isArray($$a)){' +
+          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+          '$$i=_i($$a,$$v);' +
+          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+  }
+  function genRadioModel(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      let valueBinding = getBindingAttr(el, 'value') || 'null';
+      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+      addProp(el, 'checked', `_q(${value},${valueBinding})`);
+      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+  }
+  function genSelect(el, value, modifiers) {
+      const number = modifiers && modifiers.number;
+      const selectedVal = `Array.prototype.filter` +
+          `.call($event.target.options,function(o){return o.selected})` +
+          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+          `return ${number ? '_n(val)' : 'val'}})`;
+      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+      let code = `var $$selectedVal = ${selectedVal};`;
+      code = `${code} ${genAssignmentCode(value, assignment)}`;
+      addHandler(el, 'change', code, null, true);
+  }
+  function genDefaultModel(el, value, modifiers) {
+      const type = el.attrsMap.type;
+      // warn if v-bind:value conflicts with v-model
+      // except for inputs with v-bind:type
+      {
+          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+          if (value && !typeBinding) {
+              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+              warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+          }
+      }
+      const { lazy, number, trim } = modifiers || {};
+      const needCompositionGuard = !lazy && type !== 'range';
+      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+      let valueExpression = '$event.target.value';
+      if (trim) {
+          valueExpression = `$event.target.value.trim()`;
+      }
+      if (number) {
+          valueExpression = `_n(${valueExpression})`;
+      }
+      let code = genAssignmentCode(value, valueExpression);
+      if (needCompositionGuard) {
+          code = `if($event.target.composing)return;${code}`;
+      }
+      addProp(el, 'value', `(${value})`);
+      addHandler(el, event, code, null, true);
+      if (trim || number) {
+          addHandler(el, 'blur', '$forceUpdate()');
+      }
+  }
+
+  function text(el, dir) {
+      if (dir.value) {
+          addProp(el, 'textContent', `_s(${dir.value})`, dir);
+      }
+  }
+
+  function html(el, dir) {
+      if (dir.value) {
+          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+      }
+  }
+
+  var directives = {
+      model,
+      text,
+      html,
   };
 
-  const baseOptions = {
-      expectHTML: true,
-      modules,
-      directives,
-      isPreTag,
-      isUnaryTag,
-      mustUseProp,
-      canBeLeftOpenTag,
-      isReservedTag,
-      getTagNamespace,
-      staticKeys: genStaticKeys(modules),
+  const baseOptions = {
+      expectHTML: true,
+      modules,
+      directives,
+      isPreTag,
+      isUnaryTag,
+      mustUseProp,
+      canBeLeftOpenTag,
+      isReservedTag,
+      getTagNamespace,
+      staticKeys: genStaticKeys(modules),
   };
 
-  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  const fnInvokeRE = /\([^)]*?\);*$/;
-  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-  // KeyboardEvent.keyCode aliases
-  const keyCodes = {
-      esc: 27,
-      tab: 9,
-      enter: 13,
-      space: 32,
-      up: 38,
-      left: 37,
-      right: 39,
-      down: 40,
-      delete: [8, 46],
-  };
-  // KeyboardEvent.key aliases
-  const keyNames = {
-      // #7880: IE11 and Edge use `Esc` for Escape key name.
-      esc: ['Esc', 'Escape'],
-      tab: 'Tab',
-      enter: 'Enter',
-      // #9112: IE11 uses `Spacebar` for Space key name.
-      space: [' ', 'Spacebar'],
-      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-      up: ['Up', 'ArrowUp'],
-      left: ['Left', 'ArrowLeft'],
-      right: ['Right', 'ArrowRight'],
-      down: ['Down', 'ArrowDown'],
-      // #9112: IE11 uses `Del` for Delete key name.
-      delete: ['Backspace', 'Delete', 'Del'],
-  };
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  const genGuard = (condition) => `if(${condition})return null;`;
-  const modifierCode = {
-      stop: '$event.stopPropagation();',
-      prevent: '$event.preventDefault();',
-      self: genGuard(`$event.target !== $event.currentTarget`),
-      ctrl: genGuard(`!$event.ctrlKey`),
-      shift: genGuard(`!$event.shiftKey`),
-      alt: genGuard(`!$event.altKey`),
-      meta: genGuard(`!$event.metaKey`),
-      left: genGuard(`'button' in $event && $event.button !== 0`),
-      middle: genGuard(`'button' in $event && $event.button !== 1`),
-      right: genGuard(`'button' in $event && $event.button !== 2`),
-  };
-  function genHandlers(events, isNative) {
-      const prefix = isNative ? 'nativeOn:' : 'on:';
-      let staticHandlers = ``;
-      let dynamicHandlers = ``;
-      for (const name in events) {
-          const handlerCode = genHandler(events[name]);
-          //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += `${name},${handlerCode},`;
-          }
-          else {
-              staticHandlers += `"${name}":${handlerCode},`;
-          }
-      }
-      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-      if (dynamicHandlers) {
-          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-      }
-      else {
-          return prefix + staticHandlers;
-      }
-  }
-  function genHandler(handler) {
-      if (!handler) {
-          return 'function(){}';
-      }
-      if (Array.isArray(handler)) {
-          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-      }
-      const isMethodPath = simplePathRE.test(handler.value);
-      const isFunctionExpression = fnExpRE.test(handler.value);
-      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-      if (!handler.modifiers) {
-          if (isMethodPath || isFunctionExpression) {
-              return handler.value;
-          }
-          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-      }
-      else {
-          let code = '';
-          let genModifierCode = '';
-          const keys = [];
-          for (const key in handler.modifiers) {
-              if (modifierCode[key]) {
-                  genModifierCode += modifierCode[key];
-                  // left/right
-                  if (keyCodes[key]) {
-                      keys.push(key);
-                  }
-              }
-              else if (key === 'exact') {
-                  const modifiers = handler.modifiers;
-                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter((keyModifier) => !modifiers[keyModifier])
-                      .map((keyModifier) => `$event.${keyModifier}Key`)
-                      .join('||'));
-              }
-              else {
-                  keys.push(key);
-              }
-          }
-          if (keys.length) {
-              code += genKeyFilter(keys);
-          }
-          // Make sure modifiers like prevent and stop get executed after key filtering
-          if (genModifierCode) {
-              code += genModifierCode;
-          }
-          const handlerCode = isMethodPath
-              ? `return ${handler.value}.apply(null, arguments)`
-              : isFunctionExpression
-                  ? `return (${handler.value}).apply(null, arguments)`
-                  : isFunctionInvocation
-                      ? `return ${handler.value}`
-                      : handler.value;
-          return `function($event){${code}${handlerCode}}`;
-      }
-  }
-  function genKeyFilter(keys) {
-      return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      `if(!$event.type.indexOf('key')&&` +
-          `${keys.map(genFilterCode).join('&&')})return null;`);
-  }
-  function genFilterCode(key) {
-      const keyVal = parseInt(key, 10);
-      if (keyVal) {
-          return `$event.keyCode!==${keyVal}`;
-      }
-      const keyCode = keyCodes[key];
-      const keyName = keyNames[key];
-      return (`_k($event.keyCode,` +
-          `${JSON.stringify(key)},` +
-          `${JSON.stringify(keyCode)},` +
-          `$event.key,` +
-          `${JSON.stringify(keyName)}` +
-          `)`);
-  }
-
-  function on(el, dir) {
-      if (dir.modifiers) {
-          warn$2(`v-on without argument does not support modifiers.`);
-      }
-      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-  }
-
-  function bind(el, dir) {
-      el.wrapData = (code) => {
-          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-      };
-  }
-
-  var baseDirectives = {
-      on,
-      bind,
-      cloak: noop$1,
+  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+  const fnInvokeRE = /\([^)]*?\);*$/;
+  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+  // KeyboardEvent.keyCode aliases
+  const keyCodes = {
+      esc: 27,
+      tab: 9,
+      enter: 13,
+      space: 32,
+      up: 38,
+      left: 37,
+      right: 39,
+      down: 40,
+      delete: [8, 46],
+  };
+  // KeyboardEvent.key aliases
+  const keyNames = {
+      // #7880: IE11 and Edge use `Esc` for Escape key name.
+      esc: ['Esc', 'Escape'],
+      tab: 'Tab',
+      enter: 'Enter',
+      // #9112: IE11 uses `Spacebar` for Space key name.
+      space: [' ', 'Spacebar'],
+      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+      up: ['Up', 'ArrowUp'],
+      left: ['Left', 'ArrowLeft'],
+      right: ['Right', 'ArrowRight'],
+      down: ['Down', 'ArrowDown'],
+      // #9112: IE11 uses `Del` for Delete key name.
+      delete: ['Backspace', 'Delete', 'Del'],
   };
+  // #4868: modifiers that prevent the execution of the listener
+  // need to explicitly return null so that we can determine whether to remove
+  // the listener for .once
+  const genGuard = (condition) => `if(${condition})return null;`;
+  const modifierCode = {
+      stop: '$event.stopPropagation();',
+      prevent: '$event.preventDefault();',
+      self: genGuard(`$event.target !== $event.currentTarget`),
+      ctrl: genGuard(`!$event.ctrlKey`),
+      shift: genGuard(`!$event.shiftKey`),
+      alt: genGuard(`!$event.altKey`),
+      meta: genGuard(`!$event.metaKey`),
+      left: genGuard(`'button' in $event && $event.button !== 0`),
+      middle: genGuard(`'button' in $event && $event.button !== 1`),
+      right: genGuard(`'button' in $event && $event.button !== 2`),
+  };
+  function genHandlers(events, isNative) {
+      const prefix = isNative ? 'nativeOn:' : 'on:';
+      let staticHandlers = ``;
+      let dynamicHandlers = ``;
+      for (const name in events) {
+          const handlerCode = genHandler(events[name]);
+          //@ts-expect-error
+          if (events[name] && events[name].dynamic) {
+              dynamicHandlers += `${name},${handlerCode},`;
+          }
+          else {
+              staticHandlers += `"${name}":${handlerCode},`;
+          }
+      }
+      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+      if (dynamicHandlers) {
+          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+      }
+      else {
+          return prefix + staticHandlers;
+      }
+  }
+  function genHandler(handler) {
+      if (!handler) {
+          return 'function(){}';
+      }
+      if (Array.isArray(handler)) {
+          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+      }
+      const isMethodPath = simplePathRE.test(handler.value);
+      const isFunctionExpression = fnExpRE.test(handler.value);
+      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+      if (!handler.modifiers) {
+          if (isMethodPath || isFunctionExpression) {
+              return handler.value;
+          }
+          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+      }
+      else {
+          let code = '';
+          let genModifierCode = '';
+          const keys = [];
+          for (const key in handler.modifiers) {
+              if (modifierCode[key]) {
+                  genModifierCode += modifierCode[key];
+                  // left/right
+                  if (keyCodes[key]) {
+                      keys.push(key);
+                  }
+              }
+              else if (key === 'exact') {
+                  const modifiers = handler.modifiers;
+                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                      .filter((keyModifier) => !modifiers[keyModifier])
+                      .map((keyModifier) => `$event.${keyModifier}Key`)
+                      .join('||'));
+              }
+              else {
+                  keys.push(key);
+              }
+          }
+          if (keys.length) {
+              code += genKeyFilter(keys);
+          }
+          // Make sure modifiers like prevent and stop get executed after key filtering
+          if (genModifierCode) {
+              code += genModifierCode;
+          }
+          const handlerCode = isMethodPath
+              ? `return ${handler.value}.apply(null, arguments)`
+              : isFunctionExpression
+                  ? `return (${handler.value}).apply(null, arguments)`
+                  : isFunctionInvocation
+                      ? `return ${handler.value}`
+                      : handler.value;
+          return `function($event){${code}${handlerCode}}`;
+      }
+  }
+  function genKeyFilter(keys) {
+      return (
+      // make sure the key filters only apply to KeyboardEvents
+      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+      // key events that do not have keyCode property...
+      `if(!$event.type.indexOf('key')&&` +
+          `${keys.map(genFilterCode).join('&&')})return null;`);
+  }
+  function genFilterCode(key) {
+      const keyVal = parseInt(key, 10);
+      if (keyVal) {
+          return `$event.keyCode!==${keyVal}`;
+      }
+      const keyCode = keyCodes[key];
+      const keyName = keyNames[key];
+      return (`_k($event.keyCode,` +
+          `${JSON.stringify(key)},` +
+          `${JSON.stringify(keyCode)},` +
+          `$event.key,` +
+          `${JSON.stringify(keyName)}` +
+          `)`);
+  }
+
+  function on(el, dir) {
+      if (dir.modifiers) {
+          warn$2(`v-on without argument does not support modifiers.`);
+      }
+      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+  }
 
-  class CodegenState {
-      options;
-      warn;
-      transforms;
-      dataGenFns;
-      directives;
-      maybeComponent;
-      onceId;
-      staticRenderFns;
-      pre;
-      constructor(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          const isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-  }
-  function generate$1(ast, options) {
-      const state = new CodegenState(options);
-      // fix #11483, Root level <script> tags should not be rendered.
-      const code = ast
-          ? ast.tag === 'script'
-              ? 'null'
-              : genElement(ast, state)
-          : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genElement(el, state) {
-      if (el.parent) {
-          el.pre = el.pre || el.parent.pre;
-      }
-      if (el.staticRoot && !el.staticProcessed) {
-          return genStatic(el, state);
-      }
-      else if (el.once && !el.onceProcessed) {
-          return genOnce(el, state);
-      }
-      else if (el.for && !el.forProcessed) {
-          return genFor(el, state);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-          return genChildren(el, state) || 'void 0';
-      }
-      else if (el.tag === 'slot') {
-          return genSlot(el, state);
-      }
-      else {
-          // component or element
-          let code;
-          if (el.component) {
-              code = genComponent(el.component, el, state);
-          }
-          else {
-              let data;
-              if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData(el, state);
-              }
-              const children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-          }
-          // module transforms
-          for (let i = 0; i < state.transforms.length; i++) {
-              code = state.transforms[i](el, code);
-          }
-          return code;
-      }
-  }
-  // hoist static sub-trees out
-  function genStatic(el, state) {
-      el.staticProcessed = true;
-      // Some elements (templates) need to behave differently inside of a v-pre
-      // node.  All pre nodes are static roots, so we can use this as a location to
-      // wrap a state change and reset it upon exiting the pre node.
-      const originalPreState = state.pre;
-      if (el.pre) {
-          state.pre = el.pre;
-      }
-      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-      state.pre = originalPreState;
-      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-  }
-  // v-once
-  function genOnce(el, state) {
-      el.onceProcessed = true;
-      if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.staticInFor) {
-          let key = '';
-          let parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
-                  break;
-              }
-              parent = parent.parent;
-          }
-          if (!key) {
-              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-              return genElement(el, state);
-          }
-          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-      }
-      else {
-          return genStatic(el, state);
-      }
-  }
-  function genIf(el, state, altGen, altEmpty) {
-      el.ifProcessed = true; // avoid recursion
-      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-  }
-  function genIfConditions(conditions, state, altGen, altEmpty) {
-      if (!conditions.length) {
-          return altEmpty || '_e()';
-      }
-      const condition = conditions.shift();
-      if (condition.exp) {
-          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-      }
-      else {
-          return `${genTernaryExp(condition.block)}`;
-      }
-      // v-if with v-once should generate code like (a)?_m(0):_m(1)
-      function genTernaryExp(el) {
-          return altGen
-              ? altGen(el, state)
-              : el.once
-                  ? genOnce(el, state)
-                  : genElement(el, state);
-      }
-  }
-  function genFor(el, state, altGen, altHelper) {
-      const exp = el.for;
-      const alias = el.alias;
-      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-      if (state.maybeComponent(el) &&
-          el.tag !== 'slot' &&
-          el.tag !== 'template' &&
-          !el.key) {
-          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-              `v-for should have explicit keys. ` +
-              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-      }
-      el.forProcessed = true; // avoid recursion
-      return (`${altHelper || '_l'}((${exp}),` +
-          `function(${alias}${iterator1}${iterator2}){` +
-          `return ${(altGen || genElement)(el, state)}` +
-          '})');
-  }
-  function genData(el, state) {
-      let data = '{';
-      // directives first.
-      // directives may mutate the el's other properties before they are generated.
-      const dirs = genDirectives(el, state);
-      if (dirs)
-          data += dirs + ',';
-      // key
-      if (el.key) {
-          data += `key:${el.key},`;
-      }
-      // ref
-      if (el.ref) {
-          data += `ref:${el.ref},`;
-      }
-      if (el.refInFor) {
-          data += `refInFor:true,`;
-      }
-      // pre
-      if (el.pre) {
-          data += `pre:true,`;
-      }
-      // record original tag name for components using "is" attribute
-      if (el.component) {
-          data += `tag:"${el.tag}",`;
-      }
-      // module data generation functions
-      for (let i = 0; i < state.dataGenFns.length; i++) {
-          data += state.dataGenFns[i](el);
-      }
-      // attributes
-      if (el.attrs) {
-          data += `attrs:${genProps(el.attrs)},`;
-      }
-      // DOM props
-      if (el.props) {
-          data += `domProps:${genProps(el.props)},`;
-      }
-      // event handlers
-      if (el.events) {
-          data += `${genHandlers(el.events, false)},`;
-      }
-      if (el.nativeEvents) {
-          data += `${genHandlers(el.nativeEvents, true)},`;
-      }
-      // slot target
-      // only for non-scoped slots
-      if (el.slotTarget && !el.slotScope) {
-          data += `slot:${el.slotTarget},`;
-      }
-      // scoped slots
-      if (el.scopedSlots) {
-          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-      }
-      // component v-model
-      if (el.model) {
-          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-      }
-      // inline-template
-      if (el.inlineTemplate) {
-          const inlineTemplate = genInlineTemplate(el, state);
-          if (inlineTemplate) {
-              data += `${inlineTemplate},`;
-          }
-      }
-      data = data.replace(/,$/, '') + '}';
-      // v-bind dynamic argument wrap
-      // v-bind with dynamic arguments must be applied using the same v-bind object
-      // merge helper so that class/style/mustUseProp attrs are handled correctly.
-      if (el.dynamicAttrs) {
-          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-      }
-      // v-bind data wrap
-      if (el.wrapData) {
-          data = el.wrapData(data);
-      }
-      // v-on data wrap
-      if (el.wrapListeners) {
-          data = el.wrapListeners(data);
-      }
-      return data;
-  }
-  function genDirectives(el, state) {
-      const dirs = el.directives;
-      if (!dirs)
-          return;
-      let res = 'directives:[';
-      let hasRuntime = false;
-      let i, l, dir, needRuntime;
-      for (i = 0, l = dirs.length; i < l; i++) {
-          dir = dirs[i];
-          needRuntime = true;
-          const gen = state.directives[dir.name];
-          if (gen) {
-              // compile-time directive that manipulates AST.
-              // returns true if it also needs a runtime counterpart.
-              needRuntime = !!gen(el, dir, state.warn);
-          }
-          if (needRuntime) {
-              hasRuntime = true;
-              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-          }
-      }
-      if (hasRuntime) {
-          return res.slice(0, -1) + ']';
-      }
-  }
-  function genInlineTemplate(el, state) {
-      const ast = el.children[0];
-      if ((el.children.length !== 1 || ast.type !== 1)) {
-          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-      }
-      if (ast && ast.type === 1) {
-          const inlineRenderFns = generate$1(ast, state.options);
-          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-      }
-  }
-  function genScopedSlots(el, slots, state) {
-      // by default scoped slots are considered "stable", this allows child
-      // components with only scoped slots to skip forced updates from parent.
-      // but in some cases we have to bail-out of this optimization
-      // for example if the slot contains dynamic names, has v-if or v-for on them...
-      let needsForceUpdate = el.for ||
-          Object.keys(slots).some((key) => {
-              const slot = slots[key];
-              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-              );
-          });
-      // #9534: if a component with scoped slots is inside a conditional branch,
-      // it's possible for the same component to be reused but with different
-      // compiled slot content. To avoid that, we generate a unique key based on
-      // the generated code of all the slot contents.
-      let needsKey = !!el.if;
-      // OR when it is inside another scoped slot or v-for (the reactivity may be
-      // disconnected due to the intermediate scope variable)
-      // #9438, #9506
-      // TODO: this can be further optimized by properly analyzing in-scope bindings
-      // and skip force updating ones that do not actually use scope variables.
-      if (!needsForceUpdate) {
-          let parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
-                  needsForceUpdate = true;
-                  break;
-              }
-              if (parent.if) {
-                  needsKey = true;
-              }
-              parent = parent.parent;
-          }
-      }
-      const generatedSlots = Object.keys(slots)
-          .map((key) => genScopedSlot(slots[key], state))
-          .join(',');
-      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-  }
-  function hash(str) {
-      let hash = 5381;
-      let i = str.length;
-      while (i) {
-          hash = (hash * 33) ^ str.charCodeAt(--i);
-      }
-      return hash >>> 0;
-  }
-  function containsSlotChild(el) {
-      if (el.type === 1) {
-          if (el.tag === 'slot') {
-              return true;
-          }
-          return el.children.some(containsSlotChild);
-      }
-      return false;
-  }
-  function genScopedSlot(el, state) {
-      const isLegacySyntax = el.attrsMap['slot-scope'];
-      if (el.if && !el.ifProcessed && !isLegacySyntax) {
-          return genIf(el, state, genScopedSlot, `null`);
-      }
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genScopedSlot);
-      }
-      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-      const fn = `function(${slotScope}){` +
-          `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-      // reverse proxy v-slot without scope on this.$slots
-      const reverseProxy = slotScope ? `` : `,proxy:true`;
-      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-  }
-  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-      const children = el.children;
-      if (children.length) {
-          const el = children[0];
-          // optimize single v-for
-          if (children.length === 1 &&
-              el.for &&
-              el.tag !== 'template' &&
-              el.tag !== 'slot') {
-              const normalizationType = checkSkip
-                  ? state.maybeComponent(el)
-                      ? `,1`
-                      : `,0`
-                  : ``;
-              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-          }
-          const normalizationType = checkSkip
-              ? getNormalizationType(children, state.maybeComponent)
-              : 0;
-          const gen = altGenNode || genNode;
-          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-      }
-  }
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType(children, maybeComponent) {
-      let res = 0;
-      for (let i = 0; i < children.length; i++) {
-          const el = children[i];
-          if (el.type !== 1) {
-              continue;
-          }
-          if (needsNormalization(el) ||
-              (el.ifConditions &&
-                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
-              res = 2;
-              break;
-          }
-          if (maybeComponent(el) ||
-              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-              res = 1;
-          }
-      }
-      return res;
-  }
-  function needsNormalization(el) {
-      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-  }
-  function genNode(node, state) {
-      if (node.type === 1) {
-          return genElement(node, state);
-      }
-      else if (node.type === 3 && node.isComment) {
-          return genComment(node);
-      }
-      else {
-          return genText(node);
-      }
-  }
-  function genText(text) {
-      return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-  }
-  function genComment(comment) {
-      return `_e(${JSON.stringify(comment.text)})`;
-  }
-  function genSlot(el, state) {
-      const slotName = el.slotName || '"default"';
-      const children = genChildren(el, state);
-      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-      const attrs = el.attrs || el.dynamicAttrs
-          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-              // slot props are camelized
-              name: camelize(attr.name),
-              value: attr.value,
-              dynamic: attr.dynamic
-          })))
-          : null;
-      const bind = el.attrsMap['v-bind'];
-      if ((attrs || bind) && !children) {
-          res += `,null`;
-      }
-      if (attrs) {
-          res += `,${attrs}`;
-      }
-      if (bind) {
-          res += `${attrs ? '' : ',null'},${bind}`;
-      }
-      return res + ')';
-  }
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent(componentName, el, state) {
-      const children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-  }
-  function genProps(props) {
-      let staticProps = ``;
-      let dynamicProps = ``;
-      for (let i = 0; i < props.length; i++) {
-          const prop = props[i];
-          const value = transformSpecialNewlines(prop.value);
-          if (prop.dynamic) {
-              dynamicProps += `${prop.name},${value},`;
-          }
-          else {
-              staticProps += `"${prop.name}":${value},`;
-          }
-      }
-      staticProps = `{${staticProps.slice(0, -1)}}`;
-      if (dynamicProps) {
-          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-      }
-      else {
-          return staticProps;
-      }
-  }
-  // #3895, #4268
-  function transformSpecialNewlines(text) {
-      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-  }
-
-  const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-  // let the model AST transform translate v-model into appropriate
-  // props bindings
-  function applyModelTransform(el, state) {
-      if (el.directives) {
-          for (let i = 0; i < el.directives.length; i++) {
-              const dir = el.directives[i];
-              if (dir.name === 'model') {
-                  state.directives.model(el, dir, state.warn);
-                  // remove value for textarea as its converted to text
-                  if (el.tag === 'textarea' && el.props) {
-                      el.props = el.props.filter((p) => p.name !== 'value');
-                  }
-                  break;
-              }
-          }
-      }
-  }
-  function genAttrSegments(attrs) {
-      return attrs.map(({ name, value }) => genAttrSegment(name, value));
-  }
-  function genDOMPropSegments(props, attrs) {
-      const segments = [];
-      props.forEach(({ name, value }) => {
-          name = propsToAttrMap[name] || name.toLowerCase();
-          if (isRenderableAttr(name) &&
-              !(attrs && attrs.some((a) => a.name === name))) {
-              segments.push(genAttrSegment(name, value));
-          }
-      });
-      return segments;
-  }
-  function genAttrSegment(name, value) {
-      if (plainStringRE.test(value)) {
-          // force double quote
-          value = value.replace(/^'|'$/g, '"');
-          // force enumerated attr to "true"
-          if (isEnumeratedAttr(name) && value !== `"false"`) {
-              value = `"true"`;
-          }
-          return {
-              type: RAW,
-              value: isBooleanAttr(name)
-                  ? ` ${name}="${name}"`
-                  : value === '""'
-                      ? ` ${name}`
-                      : ` ${name}="${JSON.parse(value)}"`,
-          };
-      }
-      else {
-          return {
-              type: EXPRESSION,
-              value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-          };
-      }
-  }
-  function genClassSegments(staticClass, classBinding) {
-      if (staticClass && !classBinding) {
-          return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-      }
-      else {
-          return [
-              {
-                  type: EXPRESSION,
-                  value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-              },
-          ];
-      }
-  }
-  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-      if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-      }
-      else {
-          return [
-              {
-                  type: EXPRESSION,
-                  value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-              },
-          ];
-      }
-  }
-
-  /**
-   * In SSR, the vdom tree is generated only once and never patched, so
-   * we can optimize most element / trees into plain string render functions.
-   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-   *
-   * The criteria for SSR optimizability is quite a bit looser than static tree
-   * detection (which is designed for client re-render). In SSR we bail only for
-   * components/slots/custom directives.
-   */
-  // optimizability constants
-  const optimizability = {
-      FALSE: 0,
-      FULL: 1,
-      SELF: 2,
-      CHILDREN: 3,
-      PARTIAL: 4, // self un-optimizable with some un-optimizable children
-  };
-  let isPlatformReservedTag;
-  function optimize(root, options) {
-      if (!root)
-          return;
-      isPlatformReservedTag = options.isReservedTag || no;
-      walk(root, true);
-  }
-  function walk(node, isRoot) {
-      if (isUnOptimizableTree(node)) {
-          node.ssrOptimizability = optimizability.FALSE;
-          return;
-      }
-      // root node or nodes with custom directives should always be a VNode
-      const selfUnoptimizable = isRoot || hasCustomDirective(node);
-      const check = (child) => {
-          if (child.ssrOptimizability !== optimizability.FULL) {
-              node.ssrOptimizability = selfUnoptimizable
-                  ? optimizability.PARTIAL
-                  : optimizability.SELF;
-          }
-      };
-      if (selfUnoptimizable) {
-          node.ssrOptimizability = optimizability.CHILDREN;
-      }
-      if (node.type === 1) {
-          for (let i = 0, l = node.children.length; i < l; i++) {
-              const child = node.children[i];
-              walk(child);
-              check(child);
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  const block = node.ifConditions[i].block;
-                  walk(block, isRoot);
-                  check(block);
-              }
-          }
-          if (node.ssrOptimizability == null ||
-              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-              node.ssrOptimizability = optimizability.FULL;
-          }
-          else {
-              node.children = optimizeSiblings(node);
-          }
-      }
-      else {
-          node.ssrOptimizability = optimizability.FULL;
-      }
-  }
-  function optimizeSiblings(el) {
-      const children = el.children;
-      const optimizedChildren = [];
-      let currentOptimizableGroup = [];
-      const pushGroup = () => {
-          if (currentOptimizableGroup.length) {
-              optimizedChildren.push({
-                  type: 1,
-                  parent: el,
-                  tag: 'template',
-                  attrsList: [],
-                  attrsMap: {},
-                  rawAttrsMap: {},
-                  children: currentOptimizableGroup,
-                  ssrOptimizability: optimizability.FULL,
-              });
-          }
-          currentOptimizableGroup = [];
-      };
-      for (let i = 0; i < children.length; i++) {
-          const c = children[i];
-          if (c.ssrOptimizability === optimizability.FULL) {
-              currentOptimizableGroup.push(c);
-          }
-          else {
-              // wrap fully-optimizable adjacent siblings inside a template tag
-              // so that they can be optimized into a single ssrNode by codegen
-              pushGroup();
-              optimizedChildren.push(c);
-          }
-      }
-      pushGroup();
-      return optimizedChildren;
-  }
-  function isUnOptimizableTree(node) {
-      if (node.type === 2 || node.type === 3) {
-          // text or expression
-          return false;
-      }
-      return (isBuiltInTag(node.tag) || // built-in (slot, component)
-          !isPlatformReservedTag(node.tag) || // custom component
-          !!node.component || // "is" component
-          isSelectWithModel(node) // <select v-model> requires runtime inspection
-      );
-  }
-  const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-  function hasCustomDirective(node) {
-      return (node.type === 1 &&
-          node.directives &&
-          node.directives.some((d) => !isBuiltInDir(d.name)));
-  }
-  // <select v-model> cannot be optimized because it requires a runtime check
-  // to determine proper selected option
-  function isSelectWithModel(node) {
-      return (node.type === 1 &&
-          node.tag === 'select' &&
-          node.directives != null &&
-          node.directives.some((d) => d.name === 'model'));
-  }
-
-  // The SSR codegen is essentially extending the default codegen to handle
-  // segment types
-  const RAW = 0;
-  const INTERPOLATION = 1;
-  const EXPRESSION = 2;
-  function generate(ast, options) {
-      const state = new CodegenState(options);
-      const code = ast ? genSSRElement(ast, state) : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genSSRElement(el, state) {
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genSSRElement);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state, genSSRElement);
-      }
-      else if (el.tag === 'template' && !el.slotTarget) {
-          return el.ssrOptimizability === optimizability.FULL
-              ? genChildrenAsStringNode(el, state)
-              : genSSRChildren(el, state) || 'void 0';
-      }
-      switch (el.ssrOptimizability) {
-          case optimizability.FULL:
-              // stringify whole tree
-              return genStringElement(el, state);
-          case optimizability.SELF:
-              // stringify self and check children
-              return genStringElementWithChildren(el, state);
-          case optimizability.CHILDREN:
-              // generate self as VNode and stringify children
-              return genNormalElement(el, state, true);
-          case optimizability.PARTIAL:
-              // generate self as VNode and check children
-              return genNormalElement(el, state, false);
-          default:
-              // bail whole tree
-              return genElement(el, state);
-      }
-  }
-  function genNormalElement(el, state, stringifyChildren) {
-      const data = el.plain ? undefined : genData(el, state);
-      const children = stringifyChildren
-          ? `[${genChildrenAsStringNode(el, state)}]`
-          : genSSRChildren(el, state, true);
-      return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-  }
-  function genSSRChildren(el, state, checkSkip) {
-      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-  }
-  function genSSRNode(el, state) {
-      return el.type === 1 ? genSSRElement(el, state) : genText(el);
-  }
-  function genChildrenAsStringNode(el, state) {
-      return el.children.length
-          ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-          : '';
-  }
-  function genStringElement(el, state) {
-      return `_ssrNode(${elementToString(el, state)})`;
-  }
-  function genStringElementWithChildren(el, state) {
-      const children = genSSRChildren(el, state, true);
-      return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-  }
-  function elementToString(el, state) {
-      return `(${flattenSegments(elementToSegments(el, state))})`;
-  }
-  function elementToSegments(el, state) {
-      // v-for / v-if
-      if (el.for && !el.forProcessed) {
-          el.forProcessed = true;
-          return [
-              {
-                  type: EXPRESSION,
-                  value: genFor(el, state, elementToString, '_ssrList'),
-              },
-          ];
-      }
-      else if (el.if && !el.ifProcessed) {
-          el.ifProcessed = true;
-          return [
-              {
-                  type: EXPRESSION,
-                  value: genIf(el, state, elementToString, '"<!---->"'),
-              },
-          ];
-      }
-      else if (el.tag === 'template') {
-          return childrenToSegments(el, state);
-      }
-      const openSegments = elementToOpenTagSegments(el, state);
-      const childrenSegments = childrenToSegments(el, state);
-      const { isUnaryTag } = state.options;
-      const close = isUnaryTag && isUnaryTag(el.tag)
-          ? []
-          : [{ type: RAW, value: `</${el.tag}>` }];
-      return openSegments.concat(childrenSegments, close);
-  }
-  function elementToOpenTagSegments(el, state) {
-      applyModelTransform(el, state);
-      let binding;
-      const segments = [{ type: RAW, value: `<${el.tag}` }];
-      // attrs
-      if (el.attrs) {
-          segments.push.apply(segments, genAttrSegments(el.attrs));
-      }
-      // domProps
-      if (el.props) {
-          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-      }
-      // v-bind="object"
-      if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-      }
-      // v-bind.prop="object"
-      if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-      }
-      // class
-      if (el.staticClass || el.classBinding) {
-          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-      }
-      // style & v-show
-      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-      }
-      // _scopedId
-      if (state.options.scopeId) {
-          segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-      }
-      segments.push({ type: RAW, value: `>` });
-      return segments;
-  }
-  function childrenToSegments(el, state) {
-      let binding;
-      if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: `_s(${binding})` }];
-      }
-      if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-      }
-      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-      }
-      return el.children ? nodesToSegments(el.children, state) : [];
-  }
-  function nodesToSegments(children, state) {
-      const segments = [];
-      for (let i = 0; i < children.length; i++) {
-          const c = children[i];
-          if (c.type === 1) {
-              segments.push.apply(segments, elementToSegments(c, state));
-          }
-          else if (c.type === 2) {
-              segments.push({ type: INTERPOLATION, value: c.expression });
-          }
-          else if (c.type === 3) {
-              let text = escape(c.text);
-              if (c.isComment) {
-                  text = '<!--' + text + '-->';
-              }
-              segments.push({ type: RAW, value: text });
-          }
-      }
-      return segments;
-  }
-  function flattenSegments(segments) {
-      const mergedSegments = [];
-      let textBuffer = '';
-      const pushBuffer = () => {
-          if (textBuffer) {
-              mergedSegments.push(JSON.stringify(textBuffer));
-              textBuffer = '';
-          }
-      };
-      for (let i = 0; i < segments.length; i++) {
-          const s = segments[i];
-          if (s.type === RAW) {
-              textBuffer += s.value;
-          }
-          else if (s.type === INTERPOLATION) {
-              pushBuffer();
-              mergedSegments.push(`_ssrEscape(${s.value})`);
-          }
-          else if (s.type === EXPRESSION) {
-              pushBuffer();
-              mergedSegments.push(`(${s.value})`);
-          }
-      }
-      pushBuffer();
-      return mergedSegments.join('+');
-  }
-
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  const prohibitedKeywordRE = new RegExp('\\b' +
-      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-          'super,throw,while,yield,delete,export,import,return,switch,default,' +
-          'extends,finally,continue,debugger,function,arguments')
-          .split(',')
-          .join('\\b|\\b') +
-      '\\b');
-  // these unary operators should not be used as property/method names
-  const unaryOperatorsRE = new RegExp('\\b' +
-      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-      '\\s*\\([^\\)]*\\)');
-  // strip strings in expressions
-  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-  // detect problematic expressions in a template
-  function detectErrors(ast, warn) {
-      if (ast) {
-          checkNode(ast, warn);
-      }
-  }
-  function checkNode(node, warn) {
-      if (node.type === 1) {
-          for (const name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  const value = node.attrsMap[name];
-                  if (value) {
-                      const range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, `v-for="${value}"`, warn, range);
-                      }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, `${name}="${value}"`, warn, range);
-                      }
-                      else {
-                          checkExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                  }
-              }
-          }
-          if (node.children) {
-              for (let i = 0; i < node.children.length; i++) {
-                  checkNode(node.children[i], warn);
-              }
-          }
-      }
-      else if (node.type === 2) {
-          checkExpression(node.expression, node.text, warn, node);
-      }
-  }
-  function checkEvent(exp, text, warn, range) {
-      const stripped = exp.replace(stripStringRE, '');
-      const keywordMatch = stripped.match(unaryOperatorsRE);
-      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-          warn(`avoid using JavaScript unary operator as property name: ` +
-              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-      }
-      checkExpression(exp, text, warn, range);
-  }
-  function checkFor(node, text, warn, range) {
-      checkExpression(node.for || '', text, warn, range);
-      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-  }
-  function checkIdentifier(ident, type, text, warn, range) {
-      if (typeof ident === 'string') {
-          try {
-              new Function(`var ${ident}=_`);
-          }
-          catch (e) {
-              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-          }
-      }
-  }
-  function checkExpression(exp, text, warn, range) {
-      try {
-          new Function(`return ${exp}`);
-      }
-      catch (e) {
-          const keywordMatch = exp
-              .replace(stripStringRE, '')
-              .match(prohibitedKeywordRE);
-          if (keywordMatch) {
-              warn(`avoid using JavaScript keyword as property name: ` +
-                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-          }
-          else {
-              warn(`invalid expression: ${e.message} in\n\n` +
-                  `    ${exp}\n\n` +
-                  `  Raw expression: ${text.trim()}\n`, range);
-          }
-      }
-  }
-  function checkFunctionParameterExpression(exp, text, warn, range) {
-      try {
-          new Function(exp, '');
-      }
-      catch (e) {
-          warn(`invalid function parameter expression: ${e.message} in\n\n` +
-              `    ${exp}\n\n` +
-              `  Raw expression: ${text.trim()}\n`, range);
-      }
-  }
-
-  const range = 2;
-  function generateCodeFrame(source, start = 0, end = source.length) {
-      const lines = source.split(/\r?\n/);
-      let count = 0;
-      const res = [];
-      for (let i = 0; i < lines.length; i++) {
-          count += lines[i].length + 1;
-          if (count >= start) {
-              for (let j = i - range; j <= i + range || end > count; j++) {
-                  if (j < 0 || j >= lines.length)
-                      continue;
-                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                  const lineLength = lines[j].length;
-                  if (j === i) {
-                      // push underline
-                      const pad = start - (count - lineLength) + 1;
-                      const length = end > count ? lineLength - pad : end - start;
-                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                  }
-                  else if (j > i) {
-                      if (end > count) {
-                          const length = Math.min(end - count, lineLength);
-                          res.push(`   |  ` + repeat(`^`, length));
-                      }
-                      count += lineLength + 1;
-                  }
-              }
-              break;
-          }
-      }
-      return res.join('\n');
-  }
-  function repeat(str, n) {
-      let result = '';
-      if (n > 0) {
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-              // eslint-disable-line
-              if (n & 1)
-                  result += str;
-              n >>>= 1;
-              if (n <= 0)
-                  break;
-              str += str;
-          }
-      }
-      return result;
-  }
-
-  function createFunction(code, errors) {
-      try {
-          return new Function(code);
-      }
-      catch (err) {
-          errors.push({ err, code });
-          return noop$1;
-      }
-  }
-  function createCompileToFunctionFn(compile) {
-      const cache = Object.create(null);
-      return function compileToFunctions(template, options, vm) {
-          options = extend({}, options);
-          const warn = options.warn || warn$2;
-          delete options.warn;
-          /* istanbul ignore if */
-          {
-              // detect possible CSP restriction
-              try {
-                  new Function('return 1');
-              }
-              catch (e) {
-                  if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn('It seems you are using the standalone build of Vue.js in an ' +
-                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                          'The template compiler cannot work in this environment. Consider ' +
-                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                          'templates into render functions.');
-                  }
-              }
-          }
-          // check cache
-          const key = options.delimiters
-              ? String(options.delimiters) + template
-              : template;
-          if (cache[key]) {
-              return cache[key];
-          }
-          // compile
-          const compiled = compile(template, options);
-          // check compilation errors/tips
-          {
-              if (compiled.errors && compiled.errors.length) {
-                  if (options.outputSourceRange) {
-                      compiled.errors.forEach((e) => {
-                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                              generateCodeFrame(template, e.start, e.end), vm);
-                      });
-                  }
-                  else {
-                      warn(`Error compiling template:\n\n${template}\n\n` +
-                          compiled.errors.map((e) => `- ${e}`).join('\n') +
-                          '\n', vm);
-                  }
-              }
-              if (compiled.tips && compiled.tips.length) {
-                  if (options.outputSourceRange) {
-                      compiled.tips.forEach((e) => tip(e.msg, vm));
-                  }
-                  else {
-                      compiled.tips.forEach((msg) => tip(msg, vm));
-                  }
-              }
-          }
-          // turn code into functions
-          const res = {};
-          const fnGenErrors = [];
-          res.render = createFunction(compiled.render, fnGenErrors);
-          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-              return createFunction(code, fnGenErrors);
-          });
-          // check function generation errors.
-          // this should only happen if there is a bug in the compiler itself.
-          // mostly for codegen development use
-          /* istanbul ignore if */
-          {
-              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn(`Failed to generate render function:\n\n` +
-                      fnGenErrors
-                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                          .join('\n'), vm);
-              }
-          }
-          return (cache[key] = res);
-      };
-  }
-
-  function createCompilerCreator(baseCompile) {
-      return function createCompiler(baseOptions) {
-          function compile(template, options) {
-              const finalOptions = Object.create(baseOptions);
-              const errors = [];
-              const tips = [];
-              let warn = (msg, range, tip) => {
-                  (tip ? tips : errors).push(msg);
-              };
-              if (options) {
-                  if (options.outputSourceRange) {
-                      // $flow-disable-line
-                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                      warn = (msg, range, tip) => {
-                          const data = typeof (msg) === 'string' ? { msg } : msg;
-                          if (range) {
-                              if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
-                              }
-                              if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
-                              }
-                          }
-                          (tip ? tips : errors).push(data);
-                      };
-                  }
-                  // merge custom modules
-                  if (options.modules) {
-                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                  }
-                  // merge custom directives
-                  if (options.directives) {
-                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                  }
-                  // copy other options
-                  for (const key in options) {
-                      if (key !== 'modules' && key !== 'directives') {
-                          finalOptions[key] = options[key];
-                      }
-                  }
-              }
-              finalOptions.warn = warn;
-              const compiled = baseCompile(template.trim(), finalOptions);
-              {
-                  detectErrors(compiled.ast, warn);
-              }
-              compiled.errors = errors;
-              compiled.tips = tips;
-              return compiled;
-          }
-          return {
-              compile,
-              compileToFunctions: createCompileToFunctionFn(compile),
-          };
-      };
-  }
-
-  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-      const ast = parse(template.trim(), options);
-      optimize(ast, options);
-      const code = generate(ast, options);
-      return {
-          ast,
-          render: code.render,
-          staticRenderFns: code.staticRenderFns,
-      };
+  function bind(el, dir) {
+      el.wrapData = (code) => {
+          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+      };
+  }
+
+  var baseDirectives = {
+      on,
+      bind,
+      cloak: noop$1,
+  };
+
+  class CodegenState {
+      options;
+      warn;
+      transforms;
+      dataGenFns;
+      directives;
+      maybeComponent;
+      onceId;
+      staticRenderFns;
+      pre;
+      constructor(options) {
+          this.options = options;
+          this.warn = options.warn || baseWarn;
+          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+          this.directives = extend(extend({}, baseDirectives), options.directives);
+          const isReservedTag = options.isReservedTag || no;
+          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+          this.onceId = 0;
+          this.staticRenderFns = [];
+          this.pre = false;
+      }
+  }
+  function generate$1(ast, options) {
+      const state = new CodegenState(options);
+      // fix #11483, Root level <script> tags should not be rendered.
+      const code = ast
+          ? ast.tag === 'script'
+              ? 'null'
+              : genElement(ast, state)
+          : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genElement(el, state) {
+      if (el.parent) {
+          el.pre = el.pre || el.parent.pre;
+      }
+      if (el.staticRoot && !el.staticProcessed) {
+          return genStatic(el, state);
+      }
+      else if (el.once && !el.onceProcessed) {
+          return genOnce(el, state);
+      }
+      else if (el.for && !el.forProcessed) {
+          return genFor(el, state);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+          return genChildren(el, state) || 'void 0';
+      }
+      else if (el.tag === 'slot') {
+          return genSlot(el, state);
+      }
+      else {
+          // component or element
+          let code;
+          if (el.component) {
+              code = genComponent(el.component, el, state);
+          }
+          else {
+              let data;
+              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                  data = genData(el, state);
+              }
+              const children = el.inlineTemplate ? null : genChildren(el, state, true);
+              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+          }
+          // module transforms
+          for (let i = 0; i < state.transforms.length; i++) {
+              code = state.transforms[i](el, code);
+          }
+          return code;
+      }
+  }
+  // hoist static sub-trees out
+  function genStatic(el, state) {
+      el.staticProcessed = true;
+      // Some elements (templates) need to behave differently inside of a v-pre
+      // node.  All pre nodes are static roots, so we can use this as a location to
+      // wrap a state change and reset it upon exiting the pre node.
+      const originalPreState = state.pre;
+      if (el.pre) {
+          state.pre = el.pre;
+      }
+      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+      state.pre = originalPreState;
+      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+  }
+  // v-once
+  function genOnce(el, state) {
+      el.onceProcessed = true;
+      if (el.if && !el.ifProcessed) {
+          return genIf(el, state);
+      }
+      else if (el.staticInFor) {
+          let key = '';
+          let parent = el.parent;
+          while (parent) {
+              if (parent.for) {
+                  key = parent.key;
+                  break;
+              }
+              parent = parent.parent;
+          }
+          if (!key) {
+              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+              return genElement(el, state);
+          }
+          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+      }
+      else {
+          return genStatic(el, state);
+      }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+      el.ifProcessed = true; // avoid recursion
+      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+      if (!conditions.length) {
+          return altEmpty || '_e()';
+      }
+      const condition = conditions.shift();
+      if (condition.exp) {
+          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+      }
+      else {
+          return `${genTernaryExp(condition.block)}`;
+      }
+      // v-if with v-once should generate code like (a)?_m(0):_m(1)
+      function genTernaryExp(el) {
+          return altGen
+              ? altGen(el, state)
+              : el.once
+                  ? genOnce(el, state)
+                  : genElement(el, state);
+      }
+  }
+  function genFor(el, state, altGen, altHelper) {
+      const exp = el.for;
+      const alias = el.alias;
+      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+      if (state.maybeComponent(el) &&
+          el.tag !== 'slot' &&
+          el.tag !== 'template' &&
+          !el.key) {
+          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+              `v-for should have explicit keys. ` +
+              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+      }
+      el.forProcessed = true; // avoid recursion
+      return (`${altHelper || '_l'}((${exp}),` +
+          `function(${alias}${iterator1}${iterator2}){` +
+          `return ${(altGen || genElement)(el, state)}` +
+          '})');
+  }
+  function genData(el, state) {
+      let data = '{';
+      // directives first.
+      // directives may mutate the el's other properties before they are generated.
+      const dirs = genDirectives(el, state);
+      if (dirs)
+          data += dirs + ',';
+      // key
+      if (el.key) {
+          data += `key:${el.key},`;
+      }
+      // ref
+      if (el.ref) {
+          data += `ref:${el.ref},`;
+      }
+      if (el.refInFor) {
+          data += `refInFor:true,`;
+      }
+      // pre
+      if (el.pre) {
+          data += `pre:true,`;
+      }
+      // record original tag name for components using "is" attribute
+      if (el.component) {
+          data += `tag:"${el.tag}",`;
+      }
+      // module data generation functions
+      for (let i = 0; i < state.dataGenFns.length; i++) {
+          data += state.dataGenFns[i](el);
+      }
+      // attributes
+      if (el.attrs) {
+          data += `attrs:${genProps(el.attrs)},`;
+      }
+      // DOM props
+      if (el.props) {
+          data += `domProps:${genProps(el.props)},`;
+      }
+      // event handlers
+      if (el.events) {
+          data += `${genHandlers(el.events, false)},`;
+      }
+      if (el.nativeEvents) {
+          data += `${genHandlers(el.nativeEvents, true)},`;
+      }
+      // slot target
+      // only for non-scoped slots
+      if (el.slotTarget && !el.slotScope) {
+          data += `slot:${el.slotTarget},`;
+      }
+      // scoped slots
+      if (el.scopedSlots) {
+          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+      }
+      // component v-model
+      if (el.model) {
+          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+      }
+      // inline-template
+      if (el.inlineTemplate) {
+          const inlineTemplate = genInlineTemplate(el, state);
+          if (inlineTemplate) {
+              data += `${inlineTemplate},`;
+          }
+      }
+      data = data.replace(/,$/, '') + '}';
+      // v-bind dynamic argument wrap
+      // v-bind with dynamic arguments must be applied using the same v-bind object
+      // merge helper so that class/style/mustUseProp attrs are handled correctly.
+      if (el.dynamicAttrs) {
+          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+      }
+      // v-bind data wrap
+      if (el.wrapData) {
+          data = el.wrapData(data);
+      }
+      // v-on data wrap
+      if (el.wrapListeners) {
+          data = el.wrapListeners(data);
+      }
+      return data;
+  }
+  function genDirectives(el, state) {
+      const dirs = el.directives;
+      if (!dirs)
+          return;
+      let res = 'directives:[';
+      let hasRuntime = false;
+      let i, l, dir, needRuntime;
+      for (i = 0, l = dirs.length; i < l; i++) {
+          dir = dirs[i];
+          needRuntime = true;
+          const gen = state.directives[dir.name];
+          if (gen) {
+              // compile-time directive that manipulates AST.
+              // returns true if it also needs a runtime counterpart.
+              needRuntime = !!gen(el, dir, state.warn);
+          }
+          if (needRuntime) {
+              hasRuntime = true;
+              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+          }
+      }
+      if (hasRuntime) {
+          return res.slice(0, -1) + ']';
+      }
+  }
+  function genInlineTemplate(el, state) {
+      const ast = el.children[0];
+      if ((el.children.length !== 1 || ast.type !== 1)) {
+          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+      }
+      if (ast && ast.type === 1) {
+          const inlineRenderFns = generate$1(ast, state.options);
+          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+      }
+  }
+  function genScopedSlots(el, slots, state) {
+      // by default scoped slots are considered "stable", this allows child
+      // components with only scoped slots to skip forced updates from parent.
+      // but in some cases we have to bail-out of this optimization
+      // for example if the slot contains dynamic names, has v-if or v-for on them...
+      let needsForceUpdate = el.for ||
+          Object.keys(slots).some((key) => {
+              const slot = slots[key];
+              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+              );
+          });
+      // #9534: if a component with scoped slots is inside a conditional branch,
+      // it's possible for the same component to be reused but with different
+      // compiled slot content. To avoid that, we generate a unique key based on
+      // the generated code of all the slot contents.
+      let needsKey = !!el.if;
+      // OR when it is inside another scoped slot or v-for (the reactivity may be
+      // disconnected due to the intermediate scope variable)
+      // #9438, #9506
+      // TODO: this can be further optimized by properly analyzing in-scope bindings
+      // and skip force updating ones that do not actually use scope variables.
+      if (!needsForceUpdate) {
+          let parent = el.parent;
+          while (parent) {
+              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                  parent.for) {
+                  needsForceUpdate = true;
+                  break;
+              }
+              if (parent.if) {
+                  needsKey = true;
+              }
+              parent = parent.parent;
+          }
+      }
+      const generatedSlots = Object.keys(slots)
+          .map((key) => genScopedSlot(slots[key], state))
+          .join(',');
+      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+  }
+  function hash(str) {
+      let hash = 5381;
+      let i = str.length;
+      while (i) {
+          hash = (hash * 33) ^ str.charCodeAt(--i);
+      }
+      return hash >>> 0;
+  }
+  function containsSlotChild(el) {
+      if (el.type === 1) {
+          if (el.tag === 'slot') {
+              return true;
+          }
+          return el.children.some(containsSlotChild);
+      }
+      return false;
+  }
+  function genScopedSlot(el, state) {
+      const isLegacySyntax = el.attrsMap['slot-scope'];
+      if (el.if && !el.ifProcessed && !isLegacySyntax) {
+          return genIf(el, state, genScopedSlot, `null`);
+      }
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genScopedSlot);
+      }
+      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+      const fn = `function(${slotScope}){` +
+          `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+      // reverse proxy v-slot without scope on this.$slots
+      const reverseProxy = slotScope ? `` : `,proxy:true`;
+      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+      const children = el.children;
+      if (children.length) {
+          const el = children[0];
+          // optimize single v-for
+          if (children.length === 1 &&
+              el.for &&
+              el.tag !== 'template' &&
+              el.tag !== 'slot') {
+              const normalizationType = checkSkip
+                  ? state.maybeComponent(el)
+                      ? `,1`
+                      : `,0`
+                  : ``;
+              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+          }
+          const normalizationType = checkSkip
+              ? getNormalizationType(children, state.maybeComponent)
+              : 0;
+          const gen = altGenNode || genNode;
+          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+      }
+  }
+  // determine the normalization needed for the children array.
+  // 0: no normalization needed
+  // 1: simple normalization needed (possible 1-level deep nested array)
+  // 2: full normalization needed
+  function getNormalizationType(children, maybeComponent) {
+      let res = 0;
+      for (let i = 0; i < children.length; i++) {
+          const el = children[i];
+          if (el.type !== 1) {
+              continue;
+          }
+          if (needsNormalization(el) ||
+              (el.ifConditions &&
+                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
+              res = 2;
+              break;
+          }
+          if (maybeComponent(el) ||
+              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+              res = 1;
+          }
+      }
+      return res;
+  }
+  function needsNormalization(el) {
+      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+  }
+  function genNode(node, state) {
+      if (node.type === 1) {
+          return genElement(node, state);
+      }
+      else if (node.type === 3 && node.isComment) {
+          return genComment(node);
+      }
+      else {
+          return genText(node);
+      }
+  }
+  function genText(text) {
+      return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+  }
+  function genComment(comment) {
+      return `_e(${JSON.stringify(comment.text)})`;
+  }
+  function genSlot(el, state) {
+      const slotName = el.slotName || '"default"';
+      const children = genChildren(el, state);
+      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+      const attrs = el.attrs || el.dynamicAttrs
+          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic
+          })))
+          : null;
+      const bind = el.attrsMap['v-bind'];
+      if ((attrs || bind) && !children) {
+          res += `,null`;
+      }
+      if (attrs) {
+          res += `,${attrs}`;
+      }
+      if (bind) {
+          res += `${attrs ? '' : ',null'},${bind}`;
+      }
+      return res + ')';
+  }
+  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
+  function genComponent(componentName, el, state) {
+      const children = el.inlineTemplate ? null : genChildren(el, state, true);
+      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+  }
+  function genProps(props) {
+      let staticProps = ``;
+      let dynamicProps = ``;
+      for (let i = 0; i < props.length; i++) {
+          const prop = props[i];
+          const value = transformSpecialNewlines(prop.value);
+          if (prop.dynamic) {
+              dynamicProps += `${prop.name},${value},`;
+          }
+          else {
+              staticProps += `"${prop.name}":${value},`;
+          }
+      }
+      staticProps = `{${staticProps.slice(0, -1)}}`;
+      if (dynamicProps) {
+          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+      }
+      else {
+          return staticProps;
+      }
+  }
+  // #3895, #4268
+  function transformSpecialNewlines(text) {
+      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+  }
+
+  const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+  // let the model AST transform translate v-model into appropriate
+  // props bindings
+  function applyModelTransform(el, state) {
+      if (el.directives) {
+          for (let i = 0; i < el.directives.length; i++) {
+              const dir = el.directives[i];
+              if (dir.name === 'model') {
+                  state.directives.model(el, dir, state.warn);
+                  // remove value for textarea as its converted to text
+                  if (el.tag === 'textarea' && el.props) {
+                      el.props = el.props.filter((p) => p.name !== 'value');
+                  }
+                  break;
+              }
+          }
+      }
+  }
+  function genAttrSegments(attrs) {
+      return attrs.map(({ name, value }) => genAttrSegment(name, value));
+  }
+  function genDOMPropSegments(props, attrs) {
+      const segments = [];
+      props.forEach(({ name, value }) => {
+          name = propsToAttrMap[name] || name.toLowerCase();
+          if (isRenderableAttr(name) &&
+              !(attrs && attrs.some((a) => a.name === name))) {
+              segments.push(genAttrSegment(name, value));
+          }
+      });
+      return segments;
+  }
+  function genAttrSegment(name, value) {
+      if (plainStringRE.test(value)) {
+          // force double quote
+          value = value.replace(/^'|'$/g, '"');
+          // force enumerated attr to "true"
+          if (isEnumeratedAttr(name) && value !== `"false"`) {
+              value = `"true"`;
+          }
+          return {
+              type: RAW,
+              value: isBooleanAttr(name)
+                  ? ` ${name}="${name}"`
+                  : value === '""'
+                      ? ` ${name}`
+                      : ` ${name}="${JSON.parse(value)}"`,
+          };
+      }
+      else {
+          return {
+              type: EXPRESSION,
+              value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+          };
+      }
+  }
+  function genClassSegments(staticClass, classBinding) {
+      if (staticClass && !classBinding) {
+          return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+              },
+          ];
+      }
+  }
+  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+      if (staticStyle && !styleBinding && !vShowExpression) {
+          return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+      }
+      else {
+          return [
+              {
+                  type: EXPRESSION,
+                  value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+              },
+          ];
+      }
+  }
+
+  /**
+   * In SSR, the vdom tree is generated only once and never patched, so
+   * we can optimize most element / trees into plain string render functions.
+   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+   *
+   * The criteria for SSR optimizability is quite a bit looser than static tree
+   * detection (which is designed for client re-render). In SSR we bail only for
+   * components/slots/custom directives.
+   */
+  // optimizability constants
+  const optimizability = {
+      FALSE: 0,
+      FULL: 1,
+      SELF: 2,
+      CHILDREN: 3,
+      PARTIAL: 4, // self un-optimizable with some un-optimizable children
+  };
+  let isPlatformReservedTag;
+  function optimize(root, options) {
+      if (!root)
+          return;
+      isPlatformReservedTag = options.isReservedTag || no;
+      walk(root, true);
+  }
+  function walk(node, isRoot) {
+      if (isUnOptimizableTree(node)) {
+          node.ssrOptimizability = optimizability.FALSE;
+          return;
+      }
+      // root node or nodes with custom directives should always be a VNode
+      const selfUnoptimizable = isRoot || hasCustomDirective(node);
+      const check = (child) => {
+          if (child.ssrOptimizability !== optimizability.FULL) {
+              node.ssrOptimizability = selfUnoptimizable
+                  ? optimizability.PARTIAL
+                  : optimizability.SELF;
+          }
+      };
+      if (selfUnoptimizable) {
+          node.ssrOptimizability = optimizability.CHILDREN;
+      }
+      if (node.type === 1) {
+          for (let i = 0, l = node.children.length; i < l; i++) {
+              const child = node.children[i];
+              walk(child);
+              check(child);
+          }
+          if (node.ifConditions) {
+              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                  const block = node.ifConditions[i].block;
+                  walk(block, isRoot);
+                  check(block);
+              }
+          }
+          if (node.ssrOptimizability == null ||
+              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+              node.ssrOptimizability = optimizability.FULL;
+          }
+          else {
+              node.children = optimizeSiblings(node);
+          }
+      }
+      else {
+          node.ssrOptimizability = optimizability.FULL;
+      }
+  }
+  function optimizeSiblings(el) {
+      const children = el.children;
+      const optimizedChildren = [];
+      let currentOptimizableGroup = [];
+      const pushGroup = () => {
+          if (currentOptimizableGroup.length) {
+              optimizedChildren.push({
+                  type: 1,
+                  parent: el,
+                  tag: 'template',
+                  attrsList: [],
+                  attrsMap: {},
+                  rawAttrsMap: {},
+                  children: currentOptimizableGroup,
+                  ssrOptimizability: optimizability.FULL,
+              });
+          }
+          currentOptimizableGroup = [];
+      };
+      for (let i = 0; i < children.length; i++) {
+          const c = children[i];
+          if (c.ssrOptimizability === optimizability.FULL) {
+              currentOptimizableGroup.push(c);
+          }
+          else {
+              // wrap fully-optimizable adjacent siblings inside a template tag
+              // so that they can be optimized into a single ssrNode by codegen
+              pushGroup();
+              optimizedChildren.push(c);
+          }
+      }
+      pushGroup();
+      return optimizedChildren;
+  }
+  function isUnOptimizableTree(node) {
+      if (node.type === 2 || node.type === 3) {
+          // text or expression
+          return false;
+      }
+      return (isBuiltInTag(node.tag) || // built-in (slot, component)
+          !isPlatformReservedTag(node.tag) || // custom component
+          !!node.component || // "is" component
+          isSelectWithModel(node) // <select v-model> requires runtime inspection
+      );
+  }
+  const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+  function hasCustomDirective(node) {
+      return (node.type === 1 &&
+          node.directives &&
+          node.directives.some((d) => !isBuiltInDir(d.name)));
+  }
+  // <select v-model> cannot be optimized because it requires a runtime check
+  // to determine proper selected option
+  function isSelectWithModel(node) {
+      return (node.type === 1 &&
+          node.tag === 'select' &&
+          node.directives != null &&
+          node.directives.some((d) => d.name === 'model'));
+  }
+
+  // The SSR codegen is essentially extending the default codegen to handle
+  // segment types
+  const RAW = 0;
+  const INTERPOLATION = 1;
+  const EXPRESSION = 2;
+  function generate(ast, options) {
+      const state = new CodegenState(options);
+      const code = ast ? genSSRElement(ast, state) : '_c("div")';
+      return {
+          render: `with(this){return ${code}}`,
+          staticRenderFns: state.staticRenderFns,
+      };
+  }
+  function genSSRElement(el, state) {
+      if (el.for && !el.forProcessed) {
+          return genFor(el, state, genSSRElement);
+      }
+      else if (el.if && !el.ifProcessed) {
+          return genIf(el, state, genSSRElement);
+      }
+      else if (el.tag === 'template' && !el.slotTarget) {
+          return el.ssrOptimizability === optimizability.FULL
+              ? genChildrenAsStringNode(el, state)
+              : genSSRChildren(el, state) || 'void 0';
+      }
+      switch (el.ssrOptimizability) {
+          case optimizability.FULL:
+              // stringify whole tree
+              return genStringElement(el, state);
+          case optimizability.SELF:
+              // stringify self and check children
+              return genStringElementWithChildren(el, state);
+          case optimizability.CHILDREN:
+              // generate self as VNode and stringify children
+              return genNormalElement(el, state, true);
+          case optimizability.PARTIAL:
+              // generate self as VNode and check children
+              return genNormalElement(el, state, false);
+          default:
+              // bail whole tree
+              return genElement(el, state);
+      }
+  }
+  function genNormalElement(el, state, stringifyChildren) {
+      const data = el.plain ? undefined : genData(el, state);
+      const children = stringifyChildren
+          ? `[${genChildrenAsStringNode(el, state)}]`
+          : genSSRChildren(el, state, true);
+      return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+  }
+  function genSSRChildren(el, state, checkSkip) {
+      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+  }
+  function genSSRNode(el, state) {
+      return el.type === 1 ? genSSRElement(el, state) : genText(el);
+  }
+  function genChildrenAsStringNode(el, state) {
+      return el.children.length
+          ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+          : '';
+  }
+  function genStringElement(el, state) {
+      return `_ssrNode(${elementToString(el, state)})`;
+  }
+  function genStringElementWithChildren(el, state) {
+      const children = genSSRChildren(el, state, true);
+      return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+  }
+  function elementToString(el, state) {
+      return `(${flattenSegments(elementToSegments(el, state))})`;
+  }
+  function elementToSegments(el, state) {
+      // v-for / v-if
+      if (el.for && !el.forProcessed) {
+          el.forProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genFor(el, state, elementToString, '_ssrList'),
+              },
+          ];
+      }
+      else if (el.if && !el.ifProcessed) {
+          el.ifProcessed = true;
+          return [
+              {
+                  type: EXPRESSION,
+                  value: genIf(el, state, elementToString, '"<!---->"'),
+              },
+          ];
+      }
+      else if (el.tag === 'template') {
+          return childrenToSegments(el, state);
+      }
+      const openSegments = elementToOpenTagSegments(el, state);
+      const childrenSegments = childrenToSegments(el, state);
+      const { isUnaryTag } = state.options;
+      const close = isUnaryTag && isUnaryTag(el.tag)
+          ? []
+          : [{ type: RAW, value: `</${el.tag}>` }];
+      return openSegments.concat(childrenSegments, close);
+  }
+  function elementToOpenTagSegments(el, state) {
+      applyModelTransform(el, state);
+      let binding;
+      const segments = [{ type: RAW, value: `<${el.tag}` }];
+      // attrs
+      if (el.attrs) {
+          segments.push.apply(segments, genAttrSegments(el.attrs));
+      }
+      // domProps
+      if (el.props) {
+          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+      }
+      // v-bind="object"
+      if ((binding = el.attrsMap['v-bind'])) {
+          segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+      }
+      // v-bind.prop="object"
+      if ((binding = el.attrsMap['v-bind.prop'])) {
+          segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+      }
+      // class
+      if (el.staticClass || el.classBinding) {
+          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+      }
+      // style & v-show
+      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+      }
+      // _scopedId
+      if (state.options.scopeId) {
+          segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+      }
+      segments.push({ type: RAW, value: `>` });
+      return segments;
+  }
+  function childrenToSegments(el, state) {
+      let binding;
+      if ((binding = el.attrsMap['v-html'])) {
+          return [{ type: EXPRESSION, value: `_s(${binding})` }];
+      }
+      if ((binding = el.attrsMap['v-text'])) {
+          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+      }
+      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+      }
+      return el.children ? nodesToSegments(el.children, state) : [];
+  }
+  function nodesToSegments(children, state) {
+      const segments = [];
+      for (let i = 0; i < children.length; i++) {
+          const c = children[i];
+          if (c.type === 1) {
+              segments.push.apply(segments, elementToSegments(c, state));
+          }
+          else if (c.type === 2) {
+              segments.push({ type: INTERPOLATION, value: c.expression });
+          }
+          else if (c.type === 3) {
+              let text = escape(c.text);
+              if (c.isComment) {
+                  text = '<!--' + text + '-->';
+              }
+              segments.push({ type: RAW, value: text });
+          }
+      }
+      return segments;
+  }
+  function flattenSegments(segments) {
+      const mergedSegments = [];
+      let textBuffer = '';
+      const pushBuffer = () => {
+          if (textBuffer) {
+              mergedSegments.push(JSON.stringify(textBuffer));
+              textBuffer = '';
+          }
+      };
+      for (let i = 0; i < segments.length; i++) {
+          const s = segments[i];
+          if (s.type === RAW) {
+              textBuffer += s.value;
+          }
+          else if (s.type === INTERPOLATION) {
+              pushBuffer();
+              mergedSegments.push(`_ssrEscape(${s.value})`);
+          }
+          else if (s.type === EXPRESSION) {
+              pushBuffer();
+              mergedSegments.push(`(${s.value})`);
+          }
+      }
+      pushBuffer();
+      return mergedSegments.join('+');
+  }
+
+  // these keywords should not appear inside expressions, but operators like
+  // typeof, instanceof and in are allowed
+  const prohibitedKeywordRE = new RegExp('\\b' +
+      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+          'super,throw,while,yield,delete,export,import,return,switch,default,' +
+          'extends,finally,continue,debugger,function,arguments')
+          .split(',')
+          .join('\\b|\\b') +
+      '\\b');
+  // these unary operators should not be used as property/method names
+  const unaryOperatorsRE = new RegExp('\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)');
+  // strip strings in expressions
+  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+  // detect problematic expressions in a template
+  function detectErrors(ast, warn) {
+      if (ast) {
+          checkNode(ast, warn);
+      }
+  }
+  function checkNode(node, warn) {
+      if (node.type === 1) {
+          for (const name in node.attrsMap) {
+              if (dirRE.test(name)) {
+                  const value = node.attrsMap[name];
+                  if (value) {
+                      const range = node.rawAttrsMap[name];
+                      if (name === 'v-for') {
+                          checkFor(node, `v-for="${value}"`, warn, range);
+                      }
+                      else if (name === 'v-slot' || name[0] === '#') {
+                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                      else if (onRE.test(name)) {
+                          checkEvent(value, `${name}="${value}"`, warn, range);
+                      }
+                      else {
+                          checkExpression(value, `${name}="${value}"`, warn, range);
+                      }
+                  }
+              }
+          }
+          if (node.children) {
+              for (let i = 0; i < node.children.length; i++) {
+                  checkNode(node.children[i], warn);
+              }
+          }
+      }
+      else if (node.type === 2) {
+          checkExpression(node.expression, node.text, warn, node);
+      }
+  }
+  function checkEvent(exp, text, warn, range) {
+      const stripped = exp.replace(stripStringRE, '');
+      const keywordMatch = stripped.match(unaryOperatorsRE);
+      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+          warn(`avoid using JavaScript unary operator as property name: ` +
+              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+      }
+      checkExpression(exp, text, warn, range);
+  }
+  function checkFor(node, text, warn, range) {
+      checkExpression(node.for || '', text, warn, range);
+      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+      if (typeof ident === 'string') {
+          try {
+              new Function(`var ${ident}=_`);
+          }
+          catch (e) {
+              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+          }
+      }
+  }
+  function checkExpression(exp, text, warn, range) {
+      try {
+          new Function(`return ${exp}`);
+      }
+      catch (e) {
+          const keywordMatch = exp
+              .replace(stripStringRE, '')
+              .match(prohibitedKeywordRE);
+          if (keywordMatch) {
+              warn(`avoid using JavaScript keyword as property name: ` +
+                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+          }
+          else {
+              warn(`invalid expression: ${e.message} in\n\n` +
+                  `    ${exp}\n\n` +
+                  `  Raw expression: ${text.trim()}\n`, range);
+          }
+      }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+      try {
+          new Function(exp, '');
+      }
+      catch (e) {
+          warn(`invalid function parameter expression: ${e.message} in\n\n` +
+              `    ${exp}\n\n` +
+              `  Raw expression: ${text.trim()}\n`, range);
+      }
+  }
+
+  const range = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+      const lines = source.split(/\r?\n/);
+      let count = 0;
+      const res = [];
+      for (let i = 0; i < lines.length; i++) {
+          count += lines[i].length + 1;
+          if (count >= start) {
+              for (let j = i - range; j <= i + range || end > count; j++) {
+                  if (j < 0 || j >= lines.length)
+                      continue;
+                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                  const lineLength = lines[j].length;
+                  if (j === i) {
+                      // push underline
+                      const pad = start - (count - lineLength) + 1;
+                      const length = end > count ? lineLength - pad : end - start;
+                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                  }
+                  else if (j > i) {
+                      if (end > count) {
+                          const length = Math.min(end - count, lineLength);
+                          res.push(`   |  ` + repeat(`^`, length));
+                      }
+                      count += lineLength + 1;
+                  }
+              }
+              break;
+          }
+      }
+      return res.join('\n');
+  }
+  function repeat(str, n) {
+      let result = '';
+      if (n > 0) {
+          // eslint-disable-next-line no-constant-condition
+          while (true) {
+              // eslint-disable-line
+              if (n & 1)
+                  result += str;
+              n >>>= 1;
+              if (n <= 0)
+                  break;
+              str += str;
+          }
+      }
+      return result;
+  }
+
+  function createFunction(code, errors) {
+      try {
+          return new Function(code);
+      }
+      catch (err) {
+          errors.push({ err, code });
+          return noop$1;
+      }
+  }
+  function createCompileToFunctionFn(compile) {
+      const cache = Object.create(null);
+      return function compileToFunctions(template, options, vm) {
+          options = extend({}, options);
+          const warn = options.warn || warn$2;
+          delete options.warn;
+          /* istanbul ignore if */
+          {
+              // detect possible CSP restriction
+              try {
+                  new Function('return 1');
+              }
+              catch (e) {
+                  if (e.toString().match(/unsafe-eval|CSP/)) {
+                      warn('It seems you are using the standalone build of Vue.js in an ' +
+                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                          'The template compiler cannot work in this environment. Consider ' +
+                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                          'templates into render functions.');
+                  }
+              }
+          }
+          // check cache
+          const key = options.delimiters
+              ? String(options.delimiters) + template
+              : template;
+          if (cache[key]) {
+              return cache[key];
+          }
+          // compile
+          const compiled = compile(template, options);
+          // check compilation errors/tips
+          {
+              if (compiled.errors && compiled.errors.length) {
+                  if (options.outputSourceRange) {
+                      compiled.errors.forEach((e) => {
+                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                              generateCodeFrame(template, e.start, e.end), vm);
+                      });
+                  }
+                  else {
+                      warn(`Error compiling template:\n\n${template}\n\n` +
+                          compiled.errors.map((e) => `- ${e}`).join('\n') +
+                          '\n', vm);
+                  }
+              }
+              if (compiled.tips && compiled.tips.length) {
+                  if (options.outputSourceRange) {
+                      compiled.tips.forEach((e) => tip(e.msg, vm));
+                  }
+                  else {
+                      compiled.tips.forEach((msg) => tip(msg, vm));
+                  }
+              }
+          }
+          // turn code into functions
+          const res = {};
+          const fnGenErrors = [];
+          res.render = createFunction(compiled.render, fnGenErrors);
+          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+              return createFunction(code, fnGenErrors);
+          });
+          // check function generation errors.
+          // this should only happen if there is a bug in the compiler itself.
+          // mostly for codegen development use
+          /* istanbul ignore if */
+          {
+              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                  warn(`Failed to generate render function:\n\n` +
+                      fnGenErrors
+                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                          .join('\n'), vm);
+              }
+          }
+          return (cache[key] = res);
+      };
+  }
+
+  function createCompilerCreator(baseCompile) {
+      return function createCompiler(baseOptions) {
+          function compile(template, options) {
+              const finalOptions = Object.create(baseOptions);
+              const errors = [];
+              const tips = [];
+              let warn = (msg, range, tip) => {
+                  (tip ? tips : errors).push(msg);
+              };
+              if (options) {
+                  if (options.outputSourceRange) {
+                      // $flow-disable-line
+                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                      warn = (msg, range, tip) => {
+                          const data = { msg };
+                          if (range) {
+                              if (range.start != null) {
+                                  data.start = range.start + leadingSpaceLength;
+                              }
+                              if (range.end != null) {
+                                  data.end = range.end + leadingSpaceLength;
+                              }
+                          }
+                          (tip ? tips : errors).push(data);
+                      };
+                  }
+                  // merge custom modules
+                  if (options.modules) {
+                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                  }
+                  // merge custom directives
+                  if (options.directives) {
+                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                  }
+                  // copy other options
+                  for (const key in options) {
+                      if (key !== 'modules' && key !== 'directives') {
+                          finalOptions[key] = options[key];
+                      }
+                  }
+              }
+              finalOptions.warn = warn;
+              const compiled = baseCompile(template.trim(), finalOptions);
+              {
+                  detectErrors(compiled.ast, warn);
+              }
+              compiled.errors = errors;
+              compiled.tips = tips;
+              return compiled;
+          }
+          return {
+              compile,
+              compileToFunctions: createCompileToFunctionFn(compile),
+          };
+      };
+  }
+
+  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+      const ast = parse(template.trim(), options);
+      optimize(ast, options);
+      const code = generate(ast, options);
+      return {
+          ast,
+          render: code.render,
+          staticRenderFns: code.staticRenderFns,
+      };
   });
 
   const { compile, compileToFunctions } = createCompiler(baseOptions);
 
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
-  }
-
-  const ssrHelpers = {
-      _ssrEscape: escape,
-      _ssrNode: renderStringNode$1,
-      _ssrList: renderStringList,
-      _ssrAttr: renderAttr,
-      _ssrAttrs: renderAttrs,
-      _ssrDOMProps: renderDOMProps,
-      _ssrClass: renderSSRClass,
-      _ssrStyle: renderSSRStyle,
-  };
-  function installSSRHelpers(vm) {
-      if (vm._ssrNode) {
-          return;
-      }
-      let Vue = vm.constructor;
-      // @ts-expect-error
-      while (Vue.super) {
-          // @ts-expect-error
-          Vue = Vue.super;
-      }
-      extend(Vue.prototype, ssrHelpers);
-      // @ts-expect-error
-      if (Vue.FunctionalRenderContext) {
-          // @ts-expect-error
-          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-      }
-  }
-  class StringNode {
-      isString;
-      open;
-      close;
-      children;
-      constructor(open, close, children, normalizationType) {
-          this.isString = true;
-          this.open = open;
-          this.close = close;
-          if (children) {
-              this.children =
-                  normalizationType === 1
-                      ? simpleNormalizeChildren(children)
-                      : normalizationType === 2
-                          ? normalizeChildren(children)
-                          : children;
-          }
-          else {
-              this.children = void 0;
-          }
-      }
-  }
-  function renderStringNode$1(open, close, children, normalizationType) {
-      return new StringNode(open, close, children, normalizationType);
-  }
-  function renderStringList(val, render) {
-      let ret = '';
-      let i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          for (i = 0, l = val.length; i < l; i++) {
-              ret += render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          for (i = 0; i < val; i++) {
-              ret += render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          keys = Object.keys(val);
-          for (i = 0, l = keys.length; i < l; i++) {
-              key = keys[i];
-              ret += render(val[key], key, i);
-          }
-      }
-      return ret;
-  }
-  function renderAttrs(obj) {
-      let res = '';
-      for (const key in obj) {
-          if (isSSRUnsafeAttr(key)) {
-              continue;
-          }
-          res += renderAttr(key, obj[key]);
-      }
-      return res;
-  }
-  function renderDOMProps(obj) {
-      let res = '';
-      for (const key in obj) {
-          const attr = propsToAttrMap[key] || key.toLowerCase();
-          if (isRenderableAttr(attr)) {
-              res += renderAttr(attr, obj[key]);
-          }
-      }
-      return res;
-  }
-  function renderSSRClass(staticClass, dynamic) {
-      const res = renderClass$1(staticClass, dynamic);
-      return res === '' ? res : ` class="${escape(res)}"`;
-  }
-  function renderSSRStyle(staticStyle, dynamic, extra) {
-      const style = {};
-      if (staticStyle)
-          extend(style, staticStyle);
-      if (dynamic)
-          extend(style, normalizeStyleBinding(dynamic));
-      if (extra)
-          extend(style, extra);
-      const res = genStyle(style);
-      return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
-  }
-
-  /* not type checking this file because flow doesn't play well with Proxy */
-  {
-      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-  }
-
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
-  }
-
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
-  }
-
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
-  }
-
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn$2('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
-  }
-
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
-  }
-
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn$2("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
-  }
-
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
-  }
-
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn$2('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
-  }
-
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
-  }
-
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn$2('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
-  }
-
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
-  }
-
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
-  }
-
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
-  }
-
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
-  }
-
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
-  }
-
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-  }
-
-  let target;
-  function add(event, fn) {
-      target.$on(event, fn);
-  }
-  function remove(event, fn) {
-      target.$off(event, fn);
-  }
-  function createOnceHandler(event, fn) {
-      const _target = target;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target = vm;
-      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
-      target = undefined;
-  }
-
-  let activeInstance = null;
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook(vm, "deactivated");
-      }
-  }
-  function callHook(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
-  }
-
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-  }
-
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn$2(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
-  }
-
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
-  }
-
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
-  }
-
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
-  }
-
-  let warned = Object.create(null);
-  const warnOnce = (msg) => {
-      if (!warned[msg]) {
-          warned[msg] = true;
-          // eslint-disable-next-line no-console
-          console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
-      }
-  };
-  const onCompilationError = (err, vm) => {
-      const trace = vm ? generateComponentTrace(vm) : '';
-      throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
-  };
-  const normalizeRender = (vm) => {
-      const { render, template, _scopeId } = vm.$options;
-      if (isUndef(render)) {
-          if (template) {
-              const compiled = compileToFunctions(template, {
-                  scopeId: _scopeId,
-                  warn: onCompilationError,
-              }, vm);
-              vm.$options.render = compiled.render;
-              vm.$options.staticRenderFns = compiled.staticRenderFns;
-          }
-          else {
-              throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
-          }
-      }
-  };
-  function waitForServerPrefetch(vm, resolve, reject) {
-      let handlers = vm.$options.serverPrefetch;
-      if (isDef(handlers)) {
-          if (!Array.isArray(handlers))
-              handlers = [handlers];
-          try {
-              const promises = [];
-              for (let i = 0, j = handlers.length; i < j; i++) {
-                  const result = handlers[i].call(vm, vm);
-                  if (result && typeof result.then === 'function') {
-                      promises.push(result);
-                  }
-              }
-              Promise.all(promises).then(resolve).catch(reject);
-              return;
-          }
-          catch (e) {
-              reject(e);
-          }
-      }
-      resolve();
-  }
-  function renderNode(node, isRoot, context) {
-      if (node.isString) {
-          renderStringNode(node, context);
-      }
-      else if (isDef(node.componentOptions)) {
-          renderComponent(node, isRoot, context);
-      }
-      else if (isDef(node.tag)) {
-          renderElement(node, isRoot, context);
-      }
-      else if (isTrue(node.isComment)) {
-          if (isDef(node.asyncFactory)) {
-              // async component
-              renderAsyncComponent(node, isRoot, context);
-          }
-          else {
-              context.write(`<!--${node.text}-->`, context.next);
-          }
-      }
-      else {
-          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
-      }
-  }
-  function registerComponentForCache(options, write) {
-      // exposed by vue-loader, need to call this if cache hit because
-      // component lifecycle hooks will not be called.
-      const register = options._ssrRegister;
-      if (write.caching && isDef(register)) {
-          write.componentBuffer[write.componentBuffer.length - 1].add(register);
-      }
-      return register;
-  }
-  function renderComponent(node, isRoot, context) {
-      const { write, next, userContext } = context;
-      // check cache hit
-      const Ctor = node.componentOptions.Ctor;
-      const getKey = Ctor.options.serverCacheKey;
-      const name = Ctor.options.name;
-      const cache = context.cache;
-      const registerComponent = registerComponentForCache(Ctor.options, write);
-      if (isDef(getKey) && isDef(cache) && isDef(name)) {
-          const rawKey = getKey(node.componentOptions.propsData);
-          if (rawKey === false) {
-              renderComponentInner(node, isRoot, context);
-              return;
-          }
-          const key = name + '::' + rawKey;
-          const { has, get } = context;
-          if (isDef(has)) {
-              has(key, (hit) => {
-                  if (hit === true && isDef(get)) {
-                      get(key, (res) => {
-                          if (isDef(registerComponent)) {
-                              registerComponent(userContext);
-                          }
-                          res.components.forEach((register) => register(userContext));
-                          write(res.html, next);
-                      });
-                  }
-                  else {
-                      renderComponentWithCache(node, isRoot, key, context);
-                  }
-              });
-          }
-          else if (isDef(get)) {
-              get(key, (res) => {
-                  if (isDef(res)) {
-                      if (isDef(registerComponent)) {
-                          registerComponent(userContext);
-                      }
-                      res.components.forEach((register) => register(userContext));
-                      write(res.html, next);
-                  }
-                  else {
-                      renderComponentWithCache(node, isRoot, key, context);
-                  }
-              });
-          }
-      }
-      else {
-          if (isDef(getKey) && isUndef(cache)) {
-              warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
-                  'but no cache was provided to the renderer.');
-          }
-          if (isDef(getKey) && isUndef(name)) {
-              warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
-                  `must also define a unique "name" option.`);
-          }
-          renderComponentInner(node, isRoot, context);
-      }
-  }
-  function renderComponentWithCache(node, isRoot, key, context) {
-      const write = context.write;
-      write.caching = true;
-      const buffer = write.cacheBuffer;
-      const bufferIndex = buffer.push('') - 1;
-      const componentBuffer = write.componentBuffer;
-      componentBuffer.push(new Set());
-      context.renderStates.push({
-          type: 'ComponentWithCache',
-          key,
-          buffer,
-          bufferIndex,
-          componentBuffer,
-      });
-      renderComponentInner(node, isRoot, context);
-  }
-  function renderComponentInner(node, isRoot, context) {
-      const prevActive = context.activeInstance;
-      // expose userContext on vnode
-      node.ssrContext = context.userContext;
-      const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
-      normalizeRender(child);
-      const resolve = () => {
-          const childNode = child._render();
-          childNode.parent = node;
-          context.renderStates.push({
-              type: 'Component',
-              prevActive,
-          });
-          renderNode(childNode, isRoot, context);
-      };
-      const reject = context.done;
-      waitForServerPrefetch(child, resolve, reject);
-  }
-  function renderAsyncComponent(node, isRoot, context) {
-      const factory = node.asyncFactory;
-      const resolve = (comp) => {
-          if (comp.__esModule && comp.default) {
-              comp = comp.default;
-          }
-          const { data, children, tag } = node.asyncMeta;
-          const nodeContext = node.asyncMeta.context;
-          const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
-          if (resolvedNode) {
-              if (resolvedNode.componentOptions) {
-                  // normal component
-                  renderComponent(resolvedNode, isRoot, context);
-              }
-              else if (!Array.isArray(resolvedNode)) {
-                  // single return node from functional component
-                  renderNode(resolvedNode, isRoot, context);
-              }
-              else {
-                  // multiple return nodes from functional component
-                  context.renderStates.push({
-                      type: 'Fragment',
-                      children: resolvedNode,
-                      rendered: 0,
-                      total: resolvedNode.length,
-                  });
-                  context.next();
-              }
-          }
-          else {
-              // invalid component, but this does not throw on the client
-              // so render empty comment node
-              context.write(`<!---->`, context.next);
-          }
-      };
-      if (factory.resolved) {
-          resolve(factory.resolved);
-          return;
-      }
-      const reject = context.done;
-      let res;
-      try {
-          res = factory(resolve, reject);
-      }
-      catch (e) {
-          reject(e);
-      }
-      if (res) {
-          if (typeof res.then === 'function') {
-              res.then(resolve, reject).catch(reject);
-          }
-          else {
-              // new syntax in 2.3
-              const comp = res.component;
-              if (comp && typeof comp.then === 'function') {
-                  comp.then(resolve, reject).catch(reject);
-              }
-          }
-      }
-  }
-  function renderStringNode(el, context) {
-      const { write, next } = context;
-      if (isUndef(el.children) || el.children.length === 0) {
-          write(el.open + (el.close || ''), next);
-      }
-      else {
-          const children = el.children;
-          context.renderStates.push({
-              type: 'Element',
-              children,
-              rendered: 0,
-              total: children.length,
-              endTag: el.close,
-          });
-          write(el.open, next);
-      }
-  }
-  function renderElement(el, isRoot, context) {
-      const { write, next } = context;
-      if (isTrue(isRoot)) {
-          if (!el.data)
-              el.data = {};
-          if (!el.data.attrs)
-              el.data.attrs = {};
-          el.data.attrs[SSR_ATTR] = 'true';
-      }
-      if (el.fnOptions) {
-          registerComponentForCache(el.fnOptions, write);
-      }
-      const startTag = renderStartingTag(el, context);
-      const endTag = `</${el.tag}>`;
-      if (context.isUnaryTag(el.tag)) {
-          write(startTag, next);
-      }
-      else if (isUndef(el.children) || el.children.length === 0) {
-          write(startTag + endTag, next);
-      }
-      else {
-          const children = el.children;
-          context.renderStates.push({
-              type: 'Element',
-              children,
-              rendered: 0,
-              total: children.length,
-              endTag,
-          });
-          write(startTag, next);
-      }
-  }
-  function hasAncestorData(node) {
-      const parentNode = node.parent;
-      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
-  }
-  function getVShowDirectiveInfo(node) {
-      let dir;
-      let tmp;
-      while (isDef(node)) {
-          if (node.data && node.data.directives) {
-              tmp = node.data.directives.find((dir) => dir.name === 'show');
-              if (tmp) {
-                  dir = tmp;
-              }
-          }
-          node = node.parent;
-      }
-      //@ts-expect-error
-      return dir;
-  }
-  function renderStartingTag(node, context) {
-      let markup = `<${node.tag}`;
-      const { directives, modules } = context;
-      // construct synthetic data for module processing
-      // because modules like style also produce code by parent VNode data
-      if (isUndef(node.data) && hasAncestorData(node)) {
-          node.data = {};
-      }
-      if (isDef(node.data)) {
-          // check directives
-          const dirs = node.data.directives;
-          if (dirs) {
-              for (let i = 0; i < dirs.length; i++) {
-                  const name = dirs[i].name;
-                  if (name !== 'show') {
-                      const dirRenderer = resolveAsset(context, 'directives', name);
-                      if (dirRenderer) {
-                          // directives mutate the node's data
-                          // which then gets rendered by modules
-                          dirRenderer(node, dirs[i]);
-                      }
-                  }
-              }
-          }
-          // v-show directive needs to be merged from parent to child
-          const vshowDirectiveInfo = getVShowDirectiveInfo(node);
-          if (vshowDirectiveInfo) {
-              directives.show(node, vshowDirectiveInfo);
-          }
-          // apply other modules
-          for (let i = 0; i < modules.length; i++) {
-              const res = modules[i](node);
-              if (res) {
-                  markup += res;
-              }
-          }
-      }
-      // attach scoped CSS ID
-      let scopeId;
-      const activeInstance = context.activeInstance;
-      if (isDef(activeInstance) &&
-          activeInstance !== node.context &&
-          isDef((scopeId = activeInstance.$options._scopeId))) {
-          markup += ` ${scopeId}`;
-      }
-      if (isDef(node.fnScopeId)) {
-          markup += ` ${node.fnScopeId}`;
-      }
-      else {
-          while (isDef(node)) {
-              //@ts-expect-error
-              if (isDef((scopeId = node.context.$options._scopeId))) {
-                  markup += ` ${scopeId}`;
-              }
-              node = node.parent;
-          }
-      }
-      return markup + '>';
-  }
-  function createRenderFunction(modules, directives, isUnaryTag, cache) {
-      return function render(component, write, userContext, done) {
-          warned = Object.create(null);
-          const context = new RenderContext({
-              activeInstance: component,
-              userContext,
-              write,
-              done,
-              renderNode,
-              isUnaryTag,
-              modules,
-              directives,
-              cache,
-          });
-          installSSRHelpers(component);
-          normalizeRender(component);
-          const resolve = () => {
-              renderNode(component._render(), true, context);
-          };
-          waitForServerPrefetch(component, resolve, done);
-      };
-  }
-
-  function createBasicRenderer({ modules = [], directives = {}, isUnaryTag = () => false, cache, } = {}) {
-      const render = createRenderFunction(modules, directives, isUnaryTag, cache);
-      return function renderToString(component, context, done) {
-          if (typeof context === 'function') {
-              done = context;
-              context = {};
-          }
-          let result = '';
-          const write = createWriteFunction((text) => {
-              result += text;
-              return false;
-          }, done);
-          try {
-              //@ts-expect-error
-              render(component, write, context, () => {
-                  done(null, result);
-              });
-          }
-          catch (e) {
-              done(e);
-          }
-      };
-  }
-
-  var entryServerBasicRenderer = createBasicRenderer({
-      // @ts-expect-error
-      modules: modules$1,
-      directives: directives$1,
-      isUnaryTag,
-      canBeLeftOpenTag,
+  // The template compiler attempts to minimize the need for normalization by
+  // statically analyzing the template at compile time.
+  //
+  // For plain HTML markup, normalization can be completely skipped because the
+  // generated render function is guaranteed to return Array<VNode>. There are
+  // two cases where extra normalization is needed:
+  // 1. When the children contains components - because a functional component
+  // may return an Array instead of a single root. In this case, just a simple
+  // normalization is needed - if any child is an Array, we flatten the whole
+  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+  // because functional components already normalize their own children.
+  function simpleNormalizeChildren(children) {
+      for (let i = 0; i < children.length; i++) {
+          if (Array.isArray(children[i])) {
+              return Array.prototype.concat.apply([], children);
+          }
+      }
+      return children;
+  }
+  // 2. When the children contains constructs that always generated nested Arrays,
+  // e.g. <template>, <slot>, v-for, or when the children is provided by user
+  // with hand-written render functions / JSX. In such cases a full normalization
+  // is needed to cater to all possible types of children values.
+  function normalizeChildren(children) {
+      return isPrimitive(children)
+          ? [createTextVNode(children)]
+          : Array.isArray(children)
+              ? normalizeArrayChildren(children)
+              : undefined;
+  }
+  function isTextNode(node) {
+      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+  }
+  function normalizeArrayChildren(children, nestedIndex) {
+      const res = [];
+      let i, c, lastIndex, last;
+      for (i = 0; i < children.length; i++) {
+          c = children[i];
+          if (isUndef(c) || typeof c === 'boolean')
+              continue;
+          lastIndex = res.length - 1;
+          last = res[lastIndex];
+          //  nested
+          if (Array.isArray(c)) {
+              if (c.length > 0) {
+                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                  // merge adjacent text nodes
+                  if (isTextNode(c[0]) && isTextNode(last)) {
+                      res[lastIndex] = createTextVNode(last.text + c[0].text);
+                      c.shift();
+                  }
+                  res.push.apply(res, c);
+              }
+          }
+          else if (isPrimitive(c)) {
+              if (isTextNode(last)) {
+                  // merge adjacent text nodes
+                  // this is necessary for SSR hydration because text nodes are
+                  // essentially merged when rendered to HTML strings
+                  res[lastIndex] = createTextVNode(last.text + c);
+              }
+              else if (c !== '') {
+                  // convert primitive to vnode
+                  res.push(createTextVNode(c));
+              }
+          }
+          else {
+              if (isTextNode(c) && isTextNode(last)) {
+                  // merge adjacent text nodes
+                  res[lastIndex] = createTextVNode(last.text + c.text);
+              }
+              else {
+                  // default key for nested array children (likely generated by v-for)
+                  if (isTrue(children._isVList) &&
+                      isDef(c.tag) &&
+                      isUndef(c.key) &&
+                      isDef(nestedIndex)) {
+                      c.key = `__vlist${nestedIndex}_${i}__`;
+                  }
+                  res.push(c);
+              }
+          }
+      }
+      return res;
+  }
+
+  const ssrHelpers = {
+      _ssrEscape: escape,
+      _ssrNode: renderStringNode$1,
+      _ssrList: renderStringList,
+      _ssrAttr: renderAttr,
+      _ssrAttrs: renderAttrs,
+      _ssrDOMProps: renderDOMProps,
+      _ssrClass: renderSSRClass,
+      _ssrStyle: renderSSRStyle,
+  };
+  function installSSRHelpers(vm) {
+      if (vm._ssrNode) {
+          return;
+      }
+      let Vue = vm.constructor;
+      // @ts-expect-error
+      while (Vue.super) {
+          // @ts-expect-error
+          Vue = Vue.super;
+      }
+      extend(Vue.prototype, ssrHelpers);
+      // @ts-expect-error
+      if (Vue.FunctionalRenderContext) {
+          // @ts-expect-error
+          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+      }
+  }
+  class StringNode {
+      isString;
+      open;
+      close;
+      children;
+      constructor(open, close, children, normalizationType) {
+          this.isString = true;
+          this.open = open;
+          this.close = close;
+          if (children) {
+              this.children =
+                  normalizationType === 1
+                      ? simpleNormalizeChildren(children)
+                      : normalizationType === 2
+                          ? normalizeChildren(children)
+                          : children;
+          }
+          else {
+              this.children = void 0;
+          }
+      }
+  }
+  function renderStringNode$1(open, close, children, normalizationType) {
+      return new StringNode(open, close, children, normalizationType);
+  }
+  function renderStringList(val, render) {
+      let ret = '';
+      let i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          for (i = 0, l = val.length; i < l; i++) {
+              ret += render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          for (i = 0; i < val; i++) {
+              ret += render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          keys = Object.keys(val);
+          for (i = 0, l = keys.length; i < l; i++) {
+              key = keys[i];
+              ret += render(val[key], key, i);
+          }
+      }
+      return ret;
+  }
+  function renderAttrs(obj) {
+      let res = '';
+      for (const key in obj) {
+          if (isSSRUnsafeAttr(key)) {
+              continue;
+          }
+          res += renderAttr(key, obj[key]);
+      }
+      return res;
+  }
+  function renderDOMProps(obj) {
+      let res = '';
+      for (const key in obj) {
+          const attr = propsToAttrMap[key] || key.toLowerCase();
+          if (isRenderableAttr(attr)) {
+              res += renderAttr(attr, obj[key]);
+          }
+      }
+      return res;
+  }
+  function renderSSRClass(staticClass, dynamic) {
+      const res = renderClass$1(staticClass, dynamic);
+      return res === '' ? res : ` class="${escape(res)}"`;
+  }
+  function renderSSRStyle(staticStyle, dynamic, extra) {
+      const style = {};
+      if (staticStyle)
+          extend(style, staticStyle);
+      if (dynamic)
+          extend(style, normalizeStyleBinding(dynamic));
+      if (extra)
+          extend(style, extra);
+      const res = genStyle(style);
+      return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
+  }
+
+  /* not type checking this file because flow doesn't play well with Proxy */
+  {
+      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+          'require' // for Webpack/Browserify
+      );
+      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+      if (hasProxy) {
+          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+          config.keyCodes = new Proxy(config.keyCodes, {
+              set(target, key, value) {
+                  if (isBuiltInModifier(key)) {
+                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                      return false;
+                  }
+                  else {
+                      target[key] = value;
+                      return true;
+                  }
+              },
+          });
+      }
+  }
+
+  const seenObjects = new _Set();
+  /**
+   * Recursively traverse an object to evoke all converted
+   * getters, so that every nested property inside the object
+   * is collected as a "deep" dependency.
+   */
+  function traverse(val) {
+      _traverse(val, seenObjects);
+      seenObjects.clear();
+  }
+  function _traverse(val, seen) {
+      let i, keys;
+      const isA = Array.isArray(val);
+      if ((!isA && !isObject(val)) ||
+          Object.isFrozen(val) ||
+          val instanceof VNode) {
+          return;
+      }
+      if (val.__ob__) {
+          const depId = val.__ob__.dep.id;
+          if (seen.has(depId)) {
+              return;
+          }
+          seen.add(depId);
+      }
+      if (isA) {
+          i = val.length;
+          while (i--)
+              _traverse(val[i], seen);
+      }
+      else {
+          keys = Object.keys(val);
+          i = keys.length;
+          while (i--)
+              _traverse(val[keys[i]], seen);
+      }
+  }
+
+  const normalizeEvent = cached((name) => {
+      const passive = name.charAt(0) === '&';
+      name = passive ? name.slice(1) : name;
+      const once = name.charAt(0) === '~'; // Prefixed last, checked first
+      name = once ? name.slice(1) : name;
+      const capture = name.charAt(0) === '!';
+      name = capture ? name.slice(1) : name;
+      return {
+          name,
+          once,
+          capture,
+          passive,
+      };
+  });
+  function createFnInvoker(fns, vm) {
+      function invoker() {
+          const fns = invoker.fns;
+          if (Array.isArray(fns)) {
+              const cloned = fns.slice();
+              for (let i = 0; i < cloned.length; i++) {
+                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+              }
+          }
+          else {
+              // return handler return value for single handlers
+              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+          }
+      }
+      invoker.fns = fns;
+      return invoker;
+  }
+  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+      let name, cur, old, event;
+      for (name in on) {
+          cur = on[name];
+          old = oldOn[name];
+          event = normalizeEvent(name);
+          if (isUndef(cur)) {
+              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+          }
+          else if (isUndef(old)) {
+              if (isUndef(cur.fns)) {
+                  cur = on[name] = createFnInvoker(cur, vm);
+              }
+              if (isTrue(event.once)) {
+                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+              }
+              add(event.name, cur, event.capture, event.passive, event.params);
+          }
+          else if (cur !== old) {
+              old.fns = cur;
+              on[name] = old;
+          }
+      }
+      for (name in oldOn) {
+          if (isUndef(on[name])) {
+              event = normalizeEvent(name);
+              remove(event.name, oldOn[name], event.capture);
+          }
+      }
+  }
+
+  function extractPropsFromVNodeData(data, Ctor, tag) {
+      // we are only extracting raw values here.
+      // validation and default values are handled in the child
+      // component itself.
+      const propOptions = Ctor.options.props;
+      if (isUndef(propOptions)) {
+          return;
+      }
+      const res = {};
+      const { attrs, props } = data;
+      if (isDef(attrs) || isDef(props)) {
+          for (const key in propOptions) {
+              const altKey = hyphenate(key);
+              {
+                  const keyInLowerCase = key.toLowerCase();
+                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                          `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                          ` "${key}". ` +
+                          `Note that HTML attributes are case-insensitive and camelCased ` +
+                          `props need to use their kebab-case equivalents when using in-DOM ` +
+                          `templates. You should probably use "${altKey}" instead of "${key}".`);
+                  }
+              }
+              checkProp(res, props, key, altKey, true) ||
+                  checkProp(res, attrs, key, altKey, false);
+          }
+      }
+      return res;
+  }
+  function checkProp(res, hash, key, altKey, preserve) {
+      if (isDef(hash)) {
+          if (hasOwn(hash, key)) {
+              res[key] = hash[key];
+              if (!preserve) {
+                  delete hash[key];
+              }
+              return true;
+          }
+          else if (hasOwn(hash, altKey)) {
+              res[key] = hash[altKey];
+              if (!preserve) {
+                  delete hash[altKey];
+              }
+              return true;
+          }
+      }
+      return false;
+  }
+
+  const SIMPLE_NORMALIZE = 1;
+  const ALWAYS_NORMALIZE = 2;
+  // wrapper function for providing a more flexible interface
+  // without getting yelled at by flow
+  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+      if (Array.isArray(data) || isPrimitive(data)) {
+          normalizationType = children;
+          children = data;
+          data = undefined;
+      }
+      if (isTrue(alwaysNormalize)) {
+          normalizationType = ALWAYS_NORMALIZE;
+      }
+      return _createElement(context, tag, data, children, normalizationType);
+  }
+  function _createElement(context, tag, data, children, normalizationType) {
+      if (isDef(data) && isDef(data.__ob__)) {
+          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+          return createEmptyVNode();
+      }
+      // object syntax in v-bind
+      if (isDef(data) && isDef(data.is)) {
+          tag = data.is;
+      }
+      if (!tag) {
+          // in case of component :is set to falsy value
+          return createEmptyVNode();
+      }
+      // warn against non-primitive key
+      if (isDef(data) &&
+          isDef(data.key) &&
+          !isPrimitive(data.key)) {
+          // @ts-expect-error
+          {
+              warn$2('Avoid using non-primitive value as key, ' +
+                  'use string/number value instead.', context);
+          }
+      }
+      // support single function children as default scoped slot
+      if (Array.isArray(children) && typeof children[0] === 'function') {
+          data = data || {};
+          data.scopedSlots = { default: children[0] };
+          children.length = 0;
+      }
+      if (normalizationType === ALWAYS_NORMALIZE) {
+          children = normalizeChildren(children);
+      }
+      else if (normalizationType === SIMPLE_NORMALIZE) {
+          children = simpleNormalizeChildren(children);
+      }
+      let vnode, ns;
+      if (typeof tag === 'string') {
+          let Ctor;
+          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+          if ((!data || !data.pre) &&
+              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+              // component
+              vnode = createComponent(Ctor, data, context, children, tag);
+          }
+          else {
+              // unknown or unlisted namespaced elements
+              // check at runtime because it may get assigned a namespace when its
+              // parent normalizes children
+              vnode = new VNode(tag, data, children, undefined, undefined, context);
+          }
+      }
+      else {
+          // direct component options / constructor
+          vnode = createComponent(tag, data, context, children);
+      }
+      if (Array.isArray(vnode)) {
+          return vnode;
+      }
+      else if (isDef(vnode)) {
+          if (isDef(ns))
+              applyNS(vnode, ns);
+          if (isDef(data))
+              registerDeepBindings(data);
+          return vnode;
+      }
+      else {
+          return createEmptyVNode();
+      }
+  }
+  function applyNS(vnode, ns, force) {
+      vnode.ns = ns;
+      if (vnode.tag === 'foreignObject') {
+          // use default namespace inside foreignObject
+          ns = undefined;
+          force = true;
+      }
+      if (isDef(vnode.children)) {
+          for (let i = 0, l = vnode.children.length; i < l; i++) {
+              const child = vnode.children[i];
+              if (isDef(child.tag) &&
+                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                  applyNS(child, ns, force);
+              }
+          }
+      }
+  }
+  // ref #5318
+  // necessary to ensure parent re-render when deep bindings like :style and
+  // :class are used on slot nodes
+  function registerDeepBindings(data) {
+      if (isObject(data.style)) {
+          traverse(data.style);
+      }
+      if (isObject(data.class)) {
+          traverse(data.class);
+      }
+  }
+
+  /**
+   * Runtime helper for rendering v-for lists.
+   */
+  function renderList(val, render) {
+      let ret = null, i, l, keys, key;
+      if (Array.isArray(val) || typeof val === 'string') {
+          ret = new Array(val.length);
+          for (i = 0, l = val.length; i < l; i++) {
+              ret[i] = render(val[i], i);
+          }
+      }
+      else if (typeof val === 'number') {
+          ret = new Array(val);
+          for (i = 0; i < val; i++) {
+              ret[i] = render(i + 1, i);
+          }
+      }
+      else if (isObject(val)) {
+          if (hasSymbol && val[Symbol.iterator]) {
+              ret = [];
+              const iterator = val[Symbol.iterator]();
+              let result = iterator.next();
+              while (!result.done) {
+                  ret.push(render(result.value, ret.length));
+                  result = iterator.next();
+              }
+          }
+          else {
+              keys = Object.keys(val);
+              ret = new Array(keys.length);
+              for (i = 0, l = keys.length; i < l; i++) {
+                  key = keys[i];
+                  ret[i] = render(val[key], key, i);
+              }
+          }
+      }
+      if (!isDef(ret)) {
+          ret = [];
+      }
+      ret._isVList = true;
+      return ret;
+  }
+
+  /**
+   * Runtime helper for rendering <slot>
+   */
+  function renderSlot(name, fallbackRender, props, bindObject) {
+      const scopedSlotFn = this.$scopedSlots[name];
+      let nodes;
+      if (scopedSlotFn) {
+          // scoped slot
+          props = props || {};
+          if (bindObject) {
+              if (!isObject(bindObject)) {
+                  warn$2("slot v-bind without argument expects an Object", this);
+              }
+              props = extend(extend({}, bindObject), props);
+          }
+          nodes =
+              scopedSlotFn(props) ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      else {
+          nodes =
+              this.$slots[name] ||
+                  (typeof fallbackRender === "function"
+                      ? fallbackRender()
+                      : fallbackRender);
+      }
+      const target = props && props.slot;
+      if (target) {
+          return this.$createElement("template", { slot: target }, nodes);
+      }
+      else {
+          return nodes;
+      }
+  }
+
+  /**
+   * Runtime helper for resolving filters
+   */
+  function resolveFilter(id) {
+      return resolveAsset(this.$options, 'filters', id, true) || identity;
+  }
+
+  function isKeyNotMatch(expect, actual) {
+      if (Array.isArray(expect)) {
+          return expect.indexOf(actual) === -1;
+      }
+      else {
+          return expect !== actual;
+      }
+  }
+  /**
+   * Runtime helper for checking keyCodes from config.
+   * exposed as Vue.prototype._k
+   * passing in eventKeyName as last argument separately for backwards compat
+   */
+  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+          return isKeyNotMatch(builtInKeyName, eventKeyName);
+      }
+      else if (mappedKeyCode) {
+          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+      }
+      else if (eventKeyName) {
+          return hyphenate(eventKeyName) !== key;
+      }
+      return eventKeyCode === undefined;
+  }
+
+  /**
+   * Runtime helper for merging v-bind="object" into a VNode's data.
+   */
+  function bindObjectProps(data, tag, value, asProp, isSync) {
+      if (value) {
+          if (!isObject(value)) {
+              warn$2('v-bind without argument expects an Object or Array value', this);
+          }
+          else {
+              if (Array.isArray(value)) {
+                  value = toObject(value);
+              }
+              let hash;
+              for (const key in value) {
+                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                      hash = data;
+                  }
+                  else {
+                      const type = data.attrs && data.attrs.type;
+                      hash =
+                          asProp || config.mustUseProp(tag, type, key)
+                              ? data.domProps || (data.domProps = {})
+                              : data.attrs || (data.attrs = {});
+                  }
+                  const camelizedKey = camelize(key);
+                  const hyphenatedKey = hyphenate(key);
+                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                      hash[key] = value[key];
+                      if (isSync) {
+                          const on = data.on || (data.on = {});
+                          on[`update:${key}`] = function ($event) {
+                              value[key] = $event;
+                          };
+                      }
+                  }
+              }
+          }
+      }
+      return data;
+  }
+
+  /**
+   * Runtime helper for rendering static trees.
+   */
+  function renderStatic(index, isInFor) {
+      const cached = this._staticTrees || (this._staticTrees = []);
+      let tree = cached[index];
+      // if has already-rendered static tree and not inside v-for,
+      // we can reuse the same tree.
+      if (tree && !isInFor) {
+          return tree;
+      }
+      // otherwise, render a fresh tree.
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      );
+      markStatic(tree, `__static__${index}`, false);
+      return tree;
+  }
+  /**
+   * Runtime helper for v-once.
+   * Effectively it means marking the node as static with a unique key.
+   */
+  function markOnce(tree, index, key) {
+      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+      return tree;
+  }
+  function markStatic(tree, key, isOnce) {
+      if (Array.isArray(tree)) {
+          for (let i = 0; i < tree.length; i++) {
+              if (tree[i] && typeof tree[i] !== 'string') {
+                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
+              }
+          }
+      }
+      else {
+          markStaticNode(tree, key, isOnce);
+      }
+  }
+  function markStaticNode(node, key, isOnce) {
+      node.isStatic = true;
+      node.key = key;
+      node.isOnce = isOnce;
+  }
+
+  function bindObjectListeners(data, value) {
+      if (value) {
+          if (!isPlainObject(value)) {
+              warn$2('v-on without argument expects an Object value', this);
+          }
+          else {
+              const on = (data.on = data.on ? extend({}, data.on) : {});
+              for (const key in value) {
+                  const existing = on[key];
+                  const ours = value[key];
+                  on[key] = existing ? [].concat(existing, ours) : ours;
+              }
+          }
+      }
+      return data;
+  }
+
+  function resolveScopedSlots(fns, res, 
+  // the following are added in 2.6
+  hasDynamicKeys, contentHashKey) {
+      res = res || { $stable: !hasDynamicKeys };
+      for (let i = 0; i < fns.length; i++) {
+          const slot = fns[i];
+          if (Array.isArray(slot)) {
+              resolveScopedSlots(slot, res, hasDynamicKeys);
+          }
+          else if (slot) {
+              // marker for reverse proxying v-slot without scope on this.$slots
+              // @ts-expect-error
+              if (slot.proxy) {
+                  // @ts-expect-error
+                  slot.fn.proxy = true;
+              }
+              res[slot.key] = slot.fn;
+          }
+      }
+      if (contentHashKey) {
+          res.$key = contentHashKey;
+      }
+      return res;
+  }
+
+  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+  function bindDynamicKeys(baseObj, values) {
+      for (let i = 0; i < values.length; i += 2) {
+          const key = values[i];
+          if (typeof key === 'string' && key) {
+              baseObj[values[i]] = values[i + 1];
+          }
+          else if (key !== '' &&
+              key !== null) {
+              // null is a special value for explicitly removing a binding
+              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+          }
+      }
+      return baseObj;
+  }
+  // helper to dynamically append modifier runtime markers to event names.
+  // ensure only append when value is already string, otherwise it will be cast
+  // to string and cause the type check to miss.
+  function prependModifier(value, symbol) {
+      return typeof value === 'string' ? symbol + value : value;
+  }
+
+  function installRenderHelpers(target) {
+      target._o = markOnce;
+      target._n = toNumber;
+      target._s = toString;
+      target._l = renderList;
+      target._t = renderSlot;
+      target._q = looseEqual;
+      target._i = looseIndexOf;
+      target._m = renderStatic;
+      target._f = resolveFilter;
+      target._k = checkKeyCodes;
+      target._b = bindObjectProps;
+      target._v = createTextVNode;
+      target._e = createEmptyVNode;
+      target._u = resolveScopedSlots;
+      target._g = bindObjectListeners;
+      target._d = bindDynamicKeys;
+      target._p = prependModifier;
+  }
+
+  /**
+   * Runtime helper for resolving raw children VNodes into a slot object.
+   */
+  function resolveSlots(children, context) {
+      if (!children || !children.length) {
+          return {};
+      }
+      const slots = {};
+      for (let i = 0, l = children.length; i < l; i++) {
+          const child = children[i];
+          const data = child.data;
+          // remove slot attribute if the node is resolved as a Vue slot node
+          if (data && data.attrs && data.attrs.slot) {
+              delete data.attrs.slot;
+          }
+          // named slots should only be respected if the vnode was rendered in the
+          // same context.
+          if ((child.context === context || child.fnContext === context) &&
+              data &&
+              data.slot != null) {
+              const name = data.slot;
+              const slot = slots[name] || (slots[name] = []);
+              if (child.tag === 'template') {
+                  slot.push.apply(slot, child.children || []);
+              }
+              else {
+                  slot.push(child);
+              }
+          }
+          else {
+              (slots.default || (slots.default = [])).push(child);
+          }
+      }
+      // ignore slots that contains only whitespace
+      for (const name in slots) {
+          if (slots[name].every(isWhitespace)) {
+              delete slots[name];
+          }
+      }
+      return slots;
+  }
+  function isWhitespace(node) {
+      return (node.isComment && !node.asyncFactory) || node.text === ' ';
+  }
+
+  function isAsyncPlaceholder(node) {
+      // @ts-expect-error not really boolean type
+      return node.isComment && node.asyncFactory;
+  }
+
+  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+      let res;
+      const hasNormalSlots = Object.keys(normalSlots).length > 0;
+      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+      const key = slots && slots.$key;
+      if (!slots) {
+          res = {};
+      }
+      else if (slots._normalized) {
+          // fast path 1: child component re-render only, parent did not change
+          return slots._normalized;
+      }
+      else if (isStable &&
+          prevSlots &&
+          prevSlots !== emptyObject &&
+          key === prevSlots.$key &&
+          !hasNormalSlots &&
+          !prevSlots.$hasNormal) {
+          // fast path 2: stable scoped slots w/ no normal slots to proxy,
+          // only need to normalize once
+          return prevSlots;
+      }
+      else {
+          res = {};
+          for (const key in slots) {
+              if (slots[key] && key[0] !== "$") {
+                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+              }
+          }
+      }
+      // expose normal slots on scopedSlots
+      for (const key in normalSlots) {
+          if (!(key in res)) {
+              res[key] = proxyNormalSlot(normalSlots, key);
+          }
+      }
+      // avoriaz seems to mock a non-extensible $scopedSlots object
+      // and when that is passed down this would cause an error
+      if (slots && Object.isExtensible(slots)) {
+          slots._normalized = res;
+      }
+      def(res, "$stable", isStable);
+      def(res, "$key", key);
+      def(res, "$hasNormal", hasNormalSlots);
+      return res;
+  }
+  function normalizeScopedSlot(normalSlots, key, fn) {
+      const normalized = function () {
+          let res = arguments.length ? fn.apply(null, arguments) : fn({});
+          res =
+              res && typeof res === "object" && !Array.isArray(res)
+                  ? [res] // single vnode
+                  : normalizeChildren(res);
+          const vnode = res && res[0];
+          return res &&
+              (!vnode ||
+                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+              ? undefined
+              : res;
+      };
+      // this is a slot using the new v-slot syntax without scope. although it is
+      // compiled as a scoped slot, render fn users would expect it to be present
+      // on this.$slots because the usage is semantically a normal slot.
+      if (fn.proxy) {
+          Object.defineProperty(normalSlots, key, {
+              get: normalized,
+              enumerable: true,
+              configurable: true,
+          });
+      }
+      return normalized;
+  }
+  function proxyNormalSlot(slots, key) {
+      return () => slots[key];
+  }
+
+  function createAsyncPlaceholder(factory, data, context, children, tag) {
+      const node = createEmptyVNode();
+      node.asyncFactory = factory;
+      node.asyncMeta = { data, context, children, tag };
+      return node;
+  }
+  function resolveAsyncComponent(factory, baseCtor) {
+      if (isTrue(factory.error) && isDef(factory.errorComp)) {
+          return factory.errorComp;
+      }
+      if (isDef(factory.resolved)) {
+          return factory.resolved;
+      }
+      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+          return factory.loadingComp;
+      }
+  }
+
+  let target;
+  function add(event, fn) {
+      target.$on(event, fn);
+  }
+  function remove(event, fn) {
+      target.$off(event, fn);
+  }
+  function createOnceHandler(event, fn) {
+      const _target = target;
+      return function onceHandler() {
+          const res = fn.apply(null, arguments);
+          if (res !== null) {
+              _target.$off(event, onceHandler);
+          }
+      };
+  }
+  function updateComponentListeners(vm, listeners, oldListeners) {
+      target = vm;
+      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
+      target = undefined;
+  }
+
+  let activeInstance = null;
+  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+      // determine whether component has slot children
+      // we need to do this before overwriting $options._renderChildren.
+      // check if there are dynamic scopedSlots (hand-written or compiled but with
+      // dynamic slot names). Static scoped slots compiled from template has the
+      // "$stable" marker.
+      const newScopedSlots = parentVnode.data.scopedSlots;
+      const oldScopedSlots = vm.$scopedSlots;
+      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+          (!newScopedSlots && vm.$scopedSlots.$key));
+      // Any static slot children from the parent may have changed during parent's
+      // update. Dynamic scoped slots may also have changed. In such cases, a forced
+      // update is necessary to ensure correctness.
+      const needsForceUpdate = !!(renderChildren || // has new static slots
+          vm.$options._renderChildren || // has old static slots
+          hasDynamicScopedSlot);
+      vm.$options._parentVnode = parentVnode;
+      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+      if (vm._vnode) {
+          // update child tree's parent
+          vm._vnode.parent = parentVnode;
+      }
+      vm.$options._renderChildren = renderChildren;
+      // update $attrs and $listeners hash
+      // these are also reactive so they may trigger child update if the child
+      // used them during render
+      vm.$attrs = parentVnode.data.attrs || emptyObject;
+      vm.$listeners = listeners || emptyObject;
+      // update props
+      if (propsData && vm.$options.props) {
+          toggleObserving(false);
+          const props = vm._props;
+          const propKeys = vm.$options._propKeys || [];
+          for (let i = 0; i < propKeys.length; i++) {
+              const key = propKeys[i];
+              const propOptions = vm.$options.props; // wtf flow?
+              props[key] = validateProp(key, propOptions, propsData, vm);
+          }
+          toggleObserving(true);
+          // keep a copy of raw propsData
+          vm.$options.propsData = propsData;
+      }
+      // update listeners
+      listeners = listeners || emptyObject;
+      const oldListeners = vm.$options._parentListeners;
+      vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, oldListeners);
+      // resolve slots + force update if has children
+      if (needsForceUpdate) {
+          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+          vm.$forceUpdate();
+      }
+  }
+  function isInInactiveTree(vm) {
+      while (vm && (vm = vm.$parent)) {
+          if (vm._inactive)
+              return true;
+      }
+      return false;
+  }
+  function activateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = false;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      else if (vm._directInactive) {
+          return;
+      }
+      if (vm._inactive || vm._inactive === null) {
+          vm._inactive = false;
+          for (let i = 0; i < vm.$children.length; i++) {
+              activateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, "activated");
+      }
+  }
+  function deactivateChildComponent(vm, direct) {
+      if (direct) {
+          vm._directInactive = true;
+          if (isInInactiveTree(vm)) {
+              return;
+          }
+      }
+      if (!vm._inactive) {
+          vm._inactive = true;
+          for (let i = 0; i < vm.$children.length; i++) {
+              deactivateChildComponent(vm.$children[i]);
+          }
+          callHook(vm, "deactivated");
+      }
+  }
+  function callHook(vm, hook) {
+      // #7573 disable dep collection when invoking lifecycle hooks
+      pushTarget();
+      const handlers = vm.$options[hook];
+      const info = `${hook} hook`;
+      if (handlers) {
+          for (let i = 0, j = handlers.length; i < j; i++) {
+              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+          }
+      }
+      if (vm._hasHookEvent) {
+          vm.$emit("hook:" + hook);
+      }
+      popTarget();
+  }
+
+  // Async edge case fix requires storing an event listener's attach timestamp.
+  let getNow = Date.now;
+  // Determine what event timestamp the browser is using. Annoyingly, the
+  // timestamp can either be hi-res (relative to page load) or low-res
+  // (relative to UNIX epoch), so in order to compare time we have to use the
+  // same timestamp type when saving the flush timestamp.
+  // All IE versions use low-res event timestamps, and have problematic clock
+  // implementations (#9632)
+  if (inBrowser && !isIE) {
+      const performance = window.performance;
+      if (performance &&
+          typeof performance.now === 'function' &&
+          getNow() > document.createEvent('Event').timeStamp) {
+          // if the event timestamp, although evaluated AFTER the Date.now(), is
+          // smaller than it, it means the event is using a hi-res timestamp,
+          // and we need to use the hi-res version for event listener timestamps as
+          // well.
+          getNow = () => performance.now();
+      }
+  }
+  /**
+   * Queue a kept-alive component that was activated during patch.
+   * The queue will be processed after the entire tree has been patched.
+   */
+  function queueActivatedComponent(vm) {
+      // setting _inactive to false here so that a render function can
+      // rely on checking whether it's in an inactive tree (e.g. router-view)
+      vm._inactive = false;
+  }
+
+  function resolveInject(inject, vm) {
+      if (inject) {
+          // inject is :any because flow is not smart enough to figure out cached
+          const result = Object.create(null);
+          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+          for (let i = 0; i < keys.length; i++) {
+              const key = keys[i];
+              // #6574 in case the inject object is observed...
+              if (key === '__ob__')
+                  continue;
+              const provideKey = inject[key].from;
+              let source = vm;
+              while (source) {
+                  if (source._provided && hasOwn(source._provided, provideKey)) {
+                      result[key] = source._provided[provideKey];
+                      break;
+                  }
+                  // @ts-expect-error
+                  source = source.$parent;
+              }
+              if (!source) {
+                  if ('default' in inject[key]) {
+                      const provideDefault = inject[key].default;
+                      result[key] =
+                          typeof provideDefault === 'function'
+                              ? provideDefault.call(vm)
+                              : provideDefault;
+                  }
+                  else {
+                      warn$2(`Injection "${key}" not found`, vm);
+                  }
+              }
+          }
+          return result;
+      }
+  }
+
+  function resolveConstructorOptions(Ctor) {
+      let options = Ctor.options;
+      if (Ctor.super) {
+          const superOptions = resolveConstructorOptions(Ctor.super);
+          const cachedSuperOptions = Ctor.superOptions;
+          if (superOptions !== cachedSuperOptions) {
+              // super option changed,
+              // need to resolve new options.
+              Ctor.superOptions = superOptions;
+              // check if there are any late-modified/attached options (#4976)
+              const modifiedOptions = resolveModifiedOptions(Ctor);
+              // update base extend options
+              if (modifiedOptions) {
+                  extend(Ctor.extendOptions, modifiedOptions);
+              }
+              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+              if (options.name) {
+                  options.components[options.name] = Ctor;
+              }
+          }
+      }
+      return options;
+  }
+  function resolveModifiedOptions(Ctor) {
+      let modified;
+      const latest = Ctor.options;
+      const sealed = Ctor.sealedOptions;
+      for (const key in latest) {
+          if (latest[key] !== sealed[key]) {
+              if (!modified)
+                  modified = {};
+              modified[key] = latest[key];
+          }
+      }
+      return modified;
+  }
+
+  function FunctionalRenderContext(data, props, children, parent, Ctor) {
+      const options = Ctor.options;
+      // ensure the createElement function in functional components
+      // gets a unique context - this is necessary for correct named slot check
+      let contextVm;
+      if (hasOwn(parent, '_uid')) {
+          contextVm = Object.create(parent);
+          // $flow-disable-line
+          contextVm._original = parent;
+      }
+      else {
+          // the context vm passed in is a functional context as well.
+          // in this case we want to make sure we are able to get a hold to the
+          // real context instance.
+          contextVm = parent;
+          // $flow-disable-line
+          parent = parent._original;
+      }
+      const isCompiled = isTrue(options._compiled);
+      const needNormalization = !isCompiled;
+      this.data = data;
+      this.props = props;
+      this.children = children;
+      this.parent = parent;
+      this.listeners = data.on || emptyObject;
+      this.injections = resolveInject(options.inject, parent);
+      this.slots = () => {
+          if (!this.$slots) {
+              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+          }
+          return this.$slots;
+      };
+      Object.defineProperty(this, 'scopedSlots', {
+          enumerable: true,
+          get() {
+              return normalizeScopedSlots(data.scopedSlots, this.slots());
+          },
+      });
+      // support for compiled functional template
+      if (isCompiled) {
+          // exposing $options for renderStatic()
+          this.$options = options;
+          // pre-resolve slots for renderSlot()
+          this.$slots = this.slots();
+          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+      }
+      if (options._scopeId) {
+          this._c = (a, b, c, d) => {
+              const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+              if (vnode && !Array.isArray(vnode)) {
+                  vnode.fnScopeId = options._scopeId;
+                  vnode.fnContext = parent;
+              }
+              return vnode;
+          };
+      }
+      else {
+          this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+      }
+  }
+  installRenderHelpers(FunctionalRenderContext.prototype);
+  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+      const options = Ctor.options;
+      const props = {};
+      const propOptions = options.props;
+      if (isDef(propOptions)) {
+          for (const key in propOptions) {
+              props[key] = validateProp(key, propOptions, propsData || emptyObject);
+          }
+      }
+      else {
+          if (isDef(data.attrs))
+              mergeProps(props, data.attrs);
+          if (isDef(data.props))
+              mergeProps(props, data.props);
+      }
+      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+      const vnode = options.render.call(null, renderContext._c, renderContext);
+      if (vnode instanceof VNode) {
+          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+      }
+      else if (Array.isArray(vnode)) {
+          const vnodes = normalizeChildren(vnode) || [];
+          const res = new Array(vnodes.length);
+          for (let i = 0; i < vnodes.length; i++) {
+              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+          }
+          return res;
+      }
+  }
+  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+      // #7817 clone node before setting fnContext, otherwise if the node is reused
+      // (e.g. it was from a cached normal slot) the fnContext causes named slots
+      // that should not be matched to match.
+      const clone = cloneVNode(vnode);
+      clone.fnContext = contextVm;
+      clone.fnOptions = options;
+      {
+          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+      }
+      if (data.slot) {
+          (clone.data || (clone.data = {})).slot = data.slot;
+      }
+      return clone;
+  }
+  function mergeProps(to, from) {
+      for (const key in from) {
+          to[camelize(key)] = from[key];
+      }
+  }
+
+  // inline hooks to be invoked on component VNodes during patch
+  const componentVNodeHooks = {
+      init(vnode, hydrating) {
+          if (vnode.componentInstance &&
+              !vnode.componentInstance._isDestroyed &&
+              vnode.data.keepAlive) {
+              // kept-alive components, treat as a patch
+              const mountedNode = vnode; // work around flow
+              componentVNodeHooks.prepatch(mountedNode, mountedNode);
+          }
+          else {
+              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+          }
+      },
+      prepatch(oldVnode, vnode) {
+          const options = vnode.componentOptions;
+          const child = (vnode.componentInstance = oldVnode.componentInstance);
+          updateChildComponent(child, options.propsData, // updated props
+          options.listeners, // updated listeners
+          vnode, // new parent vnode
+          options.children // new children
+          );
+      },
+      insert(vnode) {
+          const { context, componentInstance } = vnode;
+          if (!componentInstance._isMounted) {
+              componentInstance._isMounted = true;
+              callHook(componentInstance, 'mounted');
+          }
+          if (vnode.data.keepAlive) {
+              if (context._isMounted) {
+                  // vue-router#1212
+                  // During updates, a kept-alive component's child components may
+                  // change, so directly walking the tree here may call activated hooks
+                  // on incorrect children. Instead we push them into a queue which will
+                  // be processed after the whole patch process ended.
+                  queueActivatedComponent(componentInstance);
+              }
+              else {
+                  activateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+      destroy(vnode) {
+          const { componentInstance } = vnode;
+          if (!componentInstance._isDestroyed) {
+              if (!vnode.data.keepAlive) {
+                  componentInstance.$destroy();
+              }
+              else {
+                  deactivateChildComponent(componentInstance, true /* direct */);
+              }
+          }
+      },
+  };
+  const hooksToMerge = Object.keys(componentVNodeHooks);
+  function createComponent(Ctor, data, context, children, tag) {
+      if (isUndef(Ctor)) {
+          return;
+      }
+      const baseCtor = context.$options._base;
+      // plain options object: turn it into a constructor
+      if (isObject(Ctor)) {
+          Ctor = baseCtor.extend(Ctor);
+      }
+      // if at this stage it's not a constructor or an async component factory,
+      // reject.
+      if (typeof Ctor !== 'function') {
+          {
+              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+          }
+          return;
+      }
+      // async component
+      let asyncFactory;
+      // @ts-expect-error
+      if (isUndef(Ctor.cid)) {
+          asyncFactory = Ctor;
+          Ctor = resolveAsyncComponent(asyncFactory);
+          if (Ctor === undefined) {
+              // return a placeholder node for async component, which is rendered
+              // as a comment node but preserves all the raw information for the node.
+              // the information will be used for async server-rendering and hydration.
+              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+          }
+      }
+      data = data || {};
+      // resolve constructor options in case global mixins are applied after
+      // component constructor creation
+      resolveConstructorOptions(Ctor);
+      // transform component v-model data into props & events
+      if (isDef(data.model)) {
+          // @ts-expect-error
+          transformModel(Ctor.options, data);
+      }
+      // extract props
+      // @ts-expect-error
+      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+      // functional component
+      // @ts-expect-error
+      if (isTrue(Ctor.options.functional)) {
+          return createFunctionalComponent(Ctor, propsData, data, context, children);
+      }
+      // extract listeners, since these needs to be treated as
+      // child component listeners instead of DOM listeners
+      const listeners = data.on;
+      // replace with listeners with .native modifier
+      // so it gets processed during parent component patch.
+      data.on = data.nativeOn;
+      // @ts-expect-error
+      if (isTrue(Ctor.options.abstract)) {
+          // abstract components do not keep anything
+          // other than props & listeners & slot
+          // work around flow
+          const slot = data.slot;
+          data = {};
+          if (slot) {
+              data.slot = slot;
+          }
+      }
+      // install component management hooks onto the placeholder node
+      installComponentHooks(data);
+      // return a placeholder vnode
+      // @ts-expect-error
+      const name = Ctor.options.name || tag;
+      const vnode = new VNode(
+      // @ts-expect-error
+      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+      // @ts-expect-error
+      { Ctor, propsData, listeners, tag, children }, asyncFactory);
+      return vnode;
+  }
+  function createComponentInstanceForVnode(
+  // we know it's MountedComponentVNode but flow doesn't
+  vnode, 
+  // activeInstance in lifecycle state
+  parent) {
+      const options = {
+          _isComponent: true,
+          _parentVnode: vnode,
+          parent,
+      };
+      // check inline-template render functions
+      const inlineTemplate = vnode.data.inlineTemplate;
+      if (isDef(inlineTemplate)) {
+          options.render = inlineTemplate.render;
+          options.staticRenderFns = inlineTemplate.staticRenderFns;
+      }
+      return new vnode.componentOptions.Ctor(options);
+  }
+  function installComponentHooks(data) {
+      const hooks = data.hook || (data.hook = {});
+      for (let i = 0; i < hooksToMerge.length; i++) {
+          const key = hooksToMerge[i];
+          const existing = hooks[key];
+          const toMerge = componentVNodeHooks[key];
+          // @ts-expect-error
+          if (existing !== toMerge && !(existing && existing._merged)) {
+              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+          }
+      }
+  }
+  function mergeHook(f1, f2) {
+      const merged = (a, b) => {
+          // flow complains about extra args which is why we use any
+          f1(a, b);
+          f2(a, b);
+      };
+      merged._merged = true;
+      return merged;
+  }
+  // transform component v-model info (value and callback) into
+  // prop and event handler respectively.
+  function transformModel(options, data) {
+      const prop = (options.model && options.model.prop) || 'value';
+      const event = (options.model && options.model.event) || 'input';
+      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+      const on = data.on || (data.on = {});
+      const existing = on[event];
+      const callback = data.model.callback;
+      if (isDef(existing)) {
+          if (Array.isArray(existing)
+              ? existing.indexOf(callback) === -1
+              : existing !== callback) {
+              on[event] = [callback].concat(existing);
+          }
+      }
+      else {
+          on[event] = callback;
+      }
+  }
+
+  let warned = Object.create(null);
+  const warnOnce = (msg) => {
+      if (!warned[msg]) {
+          warned[msg] = true;
+          // eslint-disable-next-line no-console
+          console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
+      }
+  };
+  const onCompilationError = (err, vm) => {
+      const trace = vm ? generateComponentTrace(vm) : '';
+      throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
+  };
+  const normalizeRender = (vm) => {
+      const { render, template, _scopeId } = vm.$options;
+      if (isUndef(render)) {
+          if (template) {
+              const compiled = compileToFunctions(template, {
+                  scopeId: _scopeId,
+                  warn: onCompilationError,
+              }, vm);
+              vm.$options.render = compiled.render;
+              vm.$options.staticRenderFns = compiled.staticRenderFns;
+          }
+          else {
+              throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
+          }
+      }
+  };
+  function waitForServerPrefetch(vm, resolve, reject) {
+      let handlers = vm.$options.serverPrefetch;
+      if (isDef(handlers)) {
+          if (!Array.isArray(handlers))
+              handlers = [handlers];
+          try {
+              const promises = [];
+              for (let i = 0, j = handlers.length; i < j; i++) {
+                  const result = handlers[i].call(vm, vm);
+                  if (result && typeof result.then === 'function') {
+                      promises.push(result);
+                  }
+              }
+              Promise.all(promises).then(resolve).catch(reject);
+              return;
+          }
+          catch (e) {
+              reject(e);
+          }
+      }
+      resolve();
+  }
+  function renderNode(node, isRoot, context) {
+      if (node.isString) {
+          renderStringNode(node, context);
+      }
+      else if (isDef(node.componentOptions)) {
+          renderComponent(node, isRoot, context);
+      }
+      else if (isDef(node.tag)) {
+          renderElement(node, isRoot, context);
+      }
+      else if (isTrue(node.isComment)) {
+          if (isDef(node.asyncFactory)) {
+              // async component
+              renderAsyncComponent(node, isRoot, context);
+          }
+          else {
+              context.write(`<!--${node.text}-->`, context.next);
+          }
+      }
+      else {
+          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+      }
+  }
+  function registerComponentForCache(options, write) {
+      // exposed by vue-loader, need to call this if cache hit because
+      // component lifecycle hooks will not be called.
+      const register = options._ssrRegister;
+      if (write.caching && isDef(register)) {
+          write.componentBuffer[write.componentBuffer.length - 1].add(register);
+      }
+      return register;
+  }
+  function renderComponent(node, isRoot, context) {
+      const { write, next, userContext } = context;
+      // check cache hit
+      const Ctor = node.componentOptions.Ctor;
+      const getKey = Ctor.options.serverCacheKey;
+      const name = Ctor.options.name;
+      const cache = context.cache;
+      const registerComponent = registerComponentForCache(Ctor.options, write);
+      if (isDef(getKey) && isDef(cache) && isDef(name)) {
+          const rawKey = getKey(node.componentOptions.propsData);
+          if (rawKey === false) {
+              renderComponentInner(node, isRoot, context);
+              return;
+          }
+          const key = name + '::' + rawKey;
+          const { has, get } = context;
+          if (isDef(has)) {
+              has(key, (hit) => {
+                  if (hit === true && isDef(get)) {
+                      get(key, (res) => {
+                          if (isDef(registerComponent)) {
+                              registerComponent(userContext);
+                          }
+                          res.components.forEach((register) => register(userContext));
+                          write(res.html, next);
+                      });
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+          else if (isDef(get)) {
+              get(key, (res) => {
+                  if (isDef(res)) {
+                      if (isDef(registerComponent)) {
+                          registerComponent(userContext);
+                      }
+                      res.components.forEach((register) => register(userContext));
+                      write(res.html, next);
+                  }
+                  else {
+                      renderComponentWithCache(node, isRoot, key, context);
+                  }
+              });
+          }
+      }
+      else {
+          if (isDef(getKey) && isUndef(cache)) {
+              warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
+                  'but no cache was provided to the renderer.');
+          }
+          if (isDef(getKey) && isUndef(name)) {
+              warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
+                  `must also define a unique "name" option.`);
+          }
+          renderComponentInner(node, isRoot, context);
+      }
+  }
+  function renderComponentWithCache(node, isRoot, key, context) {
+      const write = context.write;
+      write.caching = true;
+      const buffer = write.cacheBuffer;
+      const bufferIndex = buffer.push('') - 1;
+      const componentBuffer = write.componentBuffer;
+      componentBuffer.push(new Set());
+      context.renderStates.push({
+          type: 'ComponentWithCache',
+          key,
+          buffer,
+          bufferIndex,
+          componentBuffer,
+      });
+      renderComponentInner(node, isRoot, context);
+  }
+  function renderComponentInner(node, isRoot, context) {
+      const prevActive = context.activeInstance;
+      // expose userContext on vnode
+      node.ssrContext = context.userContext;
+      const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+      normalizeRender(child);
+      const resolve = () => {
+          const childNode = child._render();
+          childNode.parent = node;
+          context.renderStates.push({
+              type: 'Component',
+              prevActive,
+          });
+          renderNode(childNode, isRoot, context);
+      };
+      const reject = context.done;
+      waitForServerPrefetch(child, resolve, reject);
+  }
+  function renderAsyncComponent(node, isRoot, context) {
+      const factory = node.asyncFactory;
+      const resolve = (comp) => {
+          if (comp.__esModule && comp.default) {
+              comp = comp.default;
+          }
+          const { data, children, tag } = node.asyncMeta;
+          const nodeContext = node.asyncMeta.context;
+          const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+          if (resolvedNode) {
+              if (resolvedNode.componentOptions) {
+                  // normal component
+                  renderComponent(resolvedNode, isRoot, context);
+              }
+              else if (!Array.isArray(resolvedNode)) {
+                  // single return node from functional component
+                  renderNode(resolvedNode, isRoot, context);
+              }
+              else {
+                  // multiple return nodes from functional component
+                  context.renderStates.push({
+                      type: 'Fragment',
+                      children: resolvedNode,
+                      rendered: 0,
+                      total: resolvedNode.length,
+                  });
+                  context.next();
+              }
+          }
+          else {
+              // invalid component, but this does not throw on the client
+              // so render empty comment node
+              context.write(`<!---->`, context.next);
+          }
+      };
+      if (factory.resolved) {
+          resolve(factory.resolved);
+          return;
+      }
+      const reject = context.done;
+      let res;
+      try {
+          res = factory(resolve, reject);
+      }
+      catch (e) {
+          reject(e);
+      }
+      if (res) {
+          if (typeof res.then === 'function') {
+              res.then(resolve, reject).catch(reject);
+          }
+          else {
+              // new syntax in 2.3
+              const comp = res.component;
+              if (comp && typeof comp.then === 'function') {
+                  comp.then(resolve, reject).catch(reject);
+              }
+          }
+      }
+  }
+  function renderStringNode(el, context) {
+      const { write, next } = context;
+      if (isUndef(el.children) || el.children.length === 0) {
+          write(el.open + (el.close || ''), next);
+      }
+      else {
+          const children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children,
+              rendered: 0,
+              total: children.length,
+              endTag: el.close,
+          });
+          write(el.open, next);
+      }
+  }
+  function renderElement(el, isRoot, context) {
+      const { write, next } = context;
+      if (isTrue(isRoot)) {
+          if (!el.data)
+              el.data = {};
+          if (!el.data.attrs)
+              el.data.attrs = {};
+          el.data.attrs[SSR_ATTR] = 'true';
+      }
+      if (el.fnOptions) {
+          registerComponentForCache(el.fnOptions, write);
+      }
+      const startTag = renderStartingTag(el, context);
+      const endTag = `</${el.tag}>`;
+      if (context.isUnaryTag(el.tag)) {
+          write(startTag, next);
+      }
+      else if (isUndef(el.children) || el.children.length === 0) {
+          write(startTag + endTag, next);
+      }
+      else {
+          const children = el.children;
+          context.renderStates.push({
+              type: 'Element',
+              children,
+              rendered: 0,
+              total: children.length,
+              endTag,
+          });
+          write(startTag, next);
+      }
+  }
+  function hasAncestorData(node) {
+      const parentNode = node.parent;
+      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+  }
+  function getVShowDirectiveInfo(node) {
+      let dir;
+      let tmp;
+      while (isDef(node)) {
+          if (node.data && node.data.directives) {
+              tmp = node.data.directives.find((dir) => dir.name === 'show');
+              if (tmp) {
+                  dir = tmp;
+              }
+          }
+          node = node.parent;
+      }
+      //@ts-expect-error
+      return dir;
+  }
+  function renderStartingTag(node, context) {
+      let markup = `<${node.tag}`;
+      const { directives, modules } = context;
+      // construct synthetic data for module processing
+      // because modules like style also produce code by parent VNode data
+      if (isUndef(node.data) && hasAncestorData(node)) {
+          node.data = {};
+      }
+      if (isDef(node.data)) {
+          // check directives
+          const dirs = node.data.directives;
+          if (dirs) {
+              for (let i = 0; i < dirs.length; i++) {
+                  const name = dirs[i].name;
+                  if (name !== 'show') {
+                      const dirRenderer = resolveAsset(context, 'directives', name);
+                      if (dirRenderer) {
+                          // directives mutate the node's data
+                          // which then gets rendered by modules
+                          dirRenderer(node, dirs[i]);
+                      }
+                  }
+              }
+          }
+          // v-show directive needs to be merged from parent to child
+          const vshowDirectiveInfo = getVShowDirectiveInfo(node);
+          if (vshowDirectiveInfo) {
+              directives.show(node, vshowDirectiveInfo);
+          }
+          // apply other modules
+          for (let i = 0; i < modules.length; i++) {
+              const res = modules[i](node);
+              if (res) {
+                  markup += res;
+              }
+          }
+      }
+      // attach scoped CSS ID
+      let scopeId;
+      const activeInstance = context.activeInstance;
+      if (isDef(activeInstance) &&
+          activeInstance !== node.context &&
+          isDef((scopeId = activeInstance.$options._scopeId))) {
+          markup += ` ${scopeId}`;
+      }
+      if (isDef(node.fnScopeId)) {
+          markup += ` ${node.fnScopeId}`;
+      }
+      else {
+          while (isDef(node)) {
+              //@ts-expect-error
+              if (isDef((scopeId = node.context.$options._scopeId))) {
+                  markup += ` ${scopeId}`;
+              }
+              node = node.parent;
+          }
+      }
+      return markup + '>';
+  }
+  function createRenderFunction(modules, directives, isUnaryTag, cache) {
+      return function render(component, write, userContext, done) {
+          warned = Object.create(null);
+          const context = new RenderContext({
+              activeInstance: component,
+              userContext,
+              write,
+              done,
+              renderNode,
+              isUnaryTag,
+              modules,
+              directives,
+              cache,
+          });
+          installSSRHelpers(component);
+          normalizeRender(component);
+          const resolve = () => {
+              renderNode(component._render(), true, context);
+          };
+          waitForServerPrefetch(component, resolve, done);
+      };
+  }
+
+  function createBasicRenderer({ modules = [], directives = {}, isUnaryTag = () => false, cache, } = {}) {
+      const render = createRenderFunction(modules, directives, isUnaryTag, cache);
+      return function renderToString(component, context, done) {
+          if (typeof context === 'function') {
+              done = context;
+              context = {};
+          }
+          let result = '';
+          const write = createWriteFunction((text) => {
+              result += text;
+              return false;
+          }, done);
+          try {
+              //@ts-expect-error
+              render(component, write, context, () => {
+                  done(null, result);
+              });
+          }
+          catch (e) {
+              done(e);
+          }
+      };
+  }
+
+  var entryServerBasicRenderer = createBasicRenderer({
+      // @ts-expect-error
+      modules: modules$1,
+      directives: directives$1,
+      isUnaryTag,
+      canBeLeftOpenTag,
   });
 
   return entryServerBasicRenderer;
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
index 19aab554e8b..bb2bebb9468 100644
--- a/packages/vue-server-renderer/build.dev.js
+++ b/packages/vue-server-renderer/build.dev.js
@@ -9,8140 +9,8141 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$1(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop$1(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+function isDef(v) {
+    return v !== undefined && v !== null;
+}
+function isTrue(v) {
+    return v === true;
+}
+function isFalse(v) {
+    return v === false;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+function isPromise(val) {
+    return (isDef(val) &&
+        typeof val.then === 'function' &&
+        typeof val.catch === 'function');
+}
+/**
+ * Convert a value to a string that is actually rendered.
+ */
+function toString(val) {
+    return val == null
+        ? ''
+        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+}
+/**
+ * Convert an input value to a number for persistence.
+ * If the conversion fails, return original string.
+ */
+function toNumber(val) {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove$1(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Capitalize a string.
+ */
+const capitalize = cached((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/**
+ * Merge an Array of Objects into a single Object.
+ */
+function toObject(arr) {
+    const res = {};
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i]) {
+            extend(res, arr[i]);
+        }
+    }
+    return res;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop$1(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
+}
+/**
+ * Check if two values are loosely equal - that is,
+ * if they are plain objects, do they have the same shape?
+ */
+function looseEqual(a, b) {
+    if (a === b)
+        return true;
+    const isObjectA = isObject(a);
+    const isObjectB = isObject(b);
+    if (isObjectA && isObjectB) {
+        try {
+            const isArrayA = Array.isArray(a);
+            const isArrayB = Array.isArray(b);
+            if (isArrayA && isArrayB) {
+                return (a.length === b.length &&
+                    a.every((e, i) => {
+                        return looseEqual(e, b[i]);
+                    }));
+            }
+            else if (a instanceof Date && b instanceof Date) {
+                return a.getTime() === b.getTime();
+            }
+            else if (!isArrayA && !isArrayB) {
+                const keysA = Object.keys(a);
+                const keysB = Object.keys(b);
+                return (keysA.length === keysB.length &&
+                    keysA.every((key) => {
+                        return looseEqual(a[key], b[key]);
+                    }));
+            }
+            else {
+                /* istanbul ignore next */
+                return false;
+            }
+        }
+        catch (e) {
+            /* istanbul ignore next */
+            return false;
+        }
+    }
+    else if (!isObjectA && !isObjectB) {
+        return String(a) === String(b);
+    }
+    else {
+        return false;
+    }
+}
+/**
+ * Return the first index at which a loosely equal value can be
+ * found in the array (if value is a plain object, the array must
+ * contain an object of the same shape), or -1 if it is not present.
+ */
+function looseIndexOf(arr, val) {
+    for (let i = 0; i < arr.length; i++) {
+        if (looseEqual(arr[i], val))
+            return i;
+    }
+    return -1;
 }
 
-const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap');
-const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-const isSSRUnsafeAttr = (name) => {
-    return unsafeAttrCharRE.test(name);
-};
-/* istanbul ignore next */
-const isRenderableAttr = (name) => {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-};
-const propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv',
-};
-const ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;',
-};
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
-}
-function escapeChar(a) {
-    return ESC[a] || a;
-}
-const noUnitNumericStyleProps = {
-    'animation-iteration-count': true,
-    'border-image-outset': true,
-    'border-image-slice': true,
-    'border-image-width': true,
-    'box-flex': true,
-    'box-flex-group': true,
-    'box-ordinal-group': true,
-    'column-count': true,
-    columns: true,
-    flex: true,
-    'flex-grow': true,
-    'flex-positive': true,
-    'flex-shrink': true,
-    'flex-negative': true,
-    'flex-order': true,
-    'grid-row': true,
-    'grid-row-end': true,
-    'grid-row-span': true,
-    'grid-row-start': true,
-    'grid-column': true,
-    'grid-column-end': true,
-    'grid-column-span': true,
-    'grid-column-start': true,
-    'font-weight': true,
-    'line-clamp': true,
-    'line-height': true,
-    opacity: true,
-    order: true,
-    orphans: true,
-    'tab-size': true,
-    widows: true,
-    'z-index': true,
-    zoom: true,
-    // SVG
-    'fill-opacity': true,
-    'flood-opacity': true,
-    'stop-opacity': true,
-    'stroke-dasharray': true,
-    'stroke-dashoffset': true,
-    'stroke-miterlimit': true,
-    'stroke-opacity': true,
-    'stroke-width': true,
+const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
+const isSSRUnsafeAttr = (name) => {
+    return unsafeAttrCharRE.test(name);
+};
+/* istanbul ignore next */
+const isRenderableAttr = (name) => {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+};
+const propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
+};
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
+};
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
+}
+const noUnitNumericStyleProps = {
+    'animation-iteration-count': true,
+    'border-image-outset': true,
+    'border-image-slice': true,
+    'border-image-width': true,
+    'box-flex': true,
+    'box-flex-group': true,
+    'box-ordinal-group': true,
+    'column-count': true,
+    columns: true,
+    flex: true,
+    'flex-grow': true,
+    'flex-positive': true,
+    'flex-shrink': true,
+    'flex-negative': true,
+    'flex-order': true,
+    'grid-row': true,
+    'grid-row-end': true,
+    'grid-row-span': true,
+    'grid-row-start': true,
+    'grid-column': true,
+    'grid-column-end': true,
+    'grid-column-span': true,
+    'grid-column-start': true,
+    'font-weight': true,
+    'line-clamp': true,
+    'line-height': true,
+    opacity: true,
+    order: true,
+    orphans: true,
+    'tab-size': true,
+    widows: true,
+    'z-index': true,
+    zoom: true,
+    // SVG
+    'fill-opacity': true,
+    'flood-opacity': true,
+    'stop-opacity': true,
+    'stroke-dasharray': true,
+    'stroke-dashoffset': true,
+    'stroke-miterlimit': true,
+    'stroke-opacity': true,
+    'stroke-width': true,
 };
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
+const convertEnumeratedValue = (key, value) => {
+    return isFalsyAttrValue(value) || value === 'false'
+        ? 'false'
+        : // allow arbitrary string value for contenteditable
+            key === 'contenteditable' && isValidContentEditableValue(value)
+                ? value
+                : 'true';
+};
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible');
+const isFalsyAttrValue = (val) => {
+    return val == null || val === false;
 };
 
-function renderAttrs$1(node) {
-    let attrs = node.data.attrs;
-    let res = '';
-    const opts = node.parent && node.parent.componentOptions;
-    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-        let parent = node.parent;
-        while (isDef(parent)) {
-            // Stop fallthrough in case parent has inheritAttrs option set to false
-            if (parent.componentOptions &&
-                parent.componentOptions.Ctor.options.inheritAttrs === false) {
-                break;
-            }
-            if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                attrs = extend(extend({}, attrs), parent.data.attrs);
-            }
-            parent = parent.parent;
-        }
-    }
-    if (isUndef(attrs)) {
-        return res;
-    }
-    for (const key in attrs) {
-        if (isSSRUnsafeAttr(key)) {
-            continue;
-        }
-        if (key === 'style') {
-            // leave it to the style module
-            continue;
-        }
-        res += renderAttr(key, attrs[key]);
-    }
-    return res;
-}
-function renderAttr(key, value) {
-    if (isBooleanAttr(key)) {
-        if (!isFalsyAttrValue(value)) {
-            return ` ${key}="${key}"`;
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
-    }
-    else if (!isFalsyAttrValue(value)) {
-        return ` ${key}="${escape(String(value))}"`;
-    }
-    return '';
+function renderAttrs$1(node) {
+    let attrs = node.data.attrs;
+    let res = '';
+    const opts = node.parent && node.parent.componentOptions;
+    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
+        let parent = node.parent;
+        while (isDef(parent)) {
+            // Stop fallthrough in case parent has inheritAttrs option set to false
+            if (parent.componentOptions &&
+                parent.componentOptions.Ctor.options.inheritAttrs === false) {
+                break;
+            }
+            if (isDef(parent.data) && isDef(parent.data.attrs)) {
+                attrs = extend(extend({}, attrs), parent.data.attrs);
+            }
+            parent = parent.parent;
+        }
+    }
+    if (isUndef(attrs)) {
+        return res;
+    }
+    for (const key in attrs) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        if (key === 'style') {
+            // leave it to the style module
+            continue;
+        }
+        res += renderAttr(key, attrs[key]);
+    }
+    return res;
+}
+function renderAttr(key, value) {
+    if (isBooleanAttr(key)) {
+        if (!isFalsyAttrValue(value)) {
+            return ` ${key}="${key}"`;
+        }
+    }
+    else if (isEnumeratedAttr(key)) {
+        return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
+    }
+    else if (!isFalsyAttrValue(value)) {
+        return ` ${key}="${escape(String(value))}"`;
+    }
+    return '';
 }
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
+}
+const createEmptyVNode = (text = "") => {
+    const node = new VNode();
+    node.text = text;
+    node.isComment = true;
+    return node;
+};
+function createTextVNode(val) {
+    return new VNode(undefined, undefined, undefined, String(val));
+}
+// optimized shallow clone
+// used for static nodes and slot nodes because they may be reused across
+// multiple renders, cloning them avoids errors when DOM manipulations rely
+// on their elm reference.
+function cloneVNode(vnode) {
+    const cloned = new VNode(vnode.tag, vnode.data, 
+    // #7975
+    // clone children array to avoid mutating original in case of cloning
+    // a child.
+    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
+    cloned.ns = vnode.ns;
+    cloned.isStatic = vnode.isStatic;
+    cloned.key = vnode.key;
+    cloned.isComment = vnode.isComment;
+    cloned.fnContext = vnode.fnContext;
+    cloned.fnOptions = vnode.fnOptions;
+    cloned.fnScopeId = vnode.fnScopeId;
+    cloned.asyncMeta = vnode.asyncMeta;
+    cloned.isCloned = true;
+    return cloned;
 }
 
-function renderDOMProps$1(node) {
-    let props = node.data.domProps;
-    let res = '';
-    let parent = node.parent;
-    while (isDef(parent)) {
-        if (parent.data && parent.data.domProps) {
-            props = extend(extend({}, props), parent.data.domProps);
-        }
-        parent = parent.parent;
-    }
-    if (isUndef(props)) {
-        return res;
-    }
-    const attrs = node.data.attrs;
-    for (const key in props) {
-        if (key === 'innerHTML') {
-            setText(node, props[key], true);
-        }
-        else if (key === 'textContent') {
-            setText(node, props[key], false);
-        }
-        else if (key === 'value' && node.tag === 'textarea') {
-            setText(node, toString(props[key]), false);
-        }
-        else {
-            // $flow-disable-line (WTF?)
-            const attr = propsToAttrMap[key] || key.toLowerCase();
-            if (isRenderableAttr(attr) &&
-                // avoid rendering double-bound props/attrs twice
-                !(isDef(attrs) && isDef(attrs[attr]))) {
-                res += renderAttr(attr, props[key]);
-            }
-        }
-    }
-    return res;
-}
-function setText(node, text, raw) {
-    const child = new VNode(undefined, undefined, undefined, text);
-    child.raw = raw;
-    node.children = [child];
+function renderDOMProps$1(node) {
+    let props = node.data.domProps;
+    let res = '';
+    let parent = node.parent;
+    while (isDef(parent)) {
+        if (parent.data && parent.data.domProps) {
+            props = extend(extend({}, props), parent.data.domProps);
+        }
+        parent = parent.parent;
+    }
+    if (isUndef(props)) {
+        return res;
+    }
+    const attrs = node.data.attrs;
+    for (const key in props) {
+        if (key === 'innerHTML') {
+            setText(node, props[key], true);
+        }
+        else if (key === 'textContent') {
+            setText(node, props[key], false);
+        }
+        else if (key === 'value' && node.tag === 'textarea') {
+            setText(node, toString(props[key]), false);
+        }
+        else {
+            // $flow-disable-line (WTF?)
+            const attr = propsToAttrMap[key] || key.toLowerCase();
+            if (isRenderableAttr(attr) &&
+                // avoid rendering double-bound props/attrs twice
+                !(isDef(attrs) && isDef(attrs[attr]))) {
+                res += renderAttr(attr, props[key]);
+            }
+        }
+    }
+    return res;
+}
+function setText(node, text, raw) {
+    const child = new VNode(undefined, undefined, undefined, text);
+    child.raw = raw;
+    node.children = [child];
 }
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
+let _Set; // $flow-disable-line
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
+    // use native Set when available.
+    _Set = Set;
+}
+else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    _Set = class Set {
+        set = Object.create(null);
+        has(key) {
+            return this.set[key] === true;
+        }
+        add(key) {
+            this.set[key] = true;
+        }
+        clear() {
+            this.set = Object.create(null);
+        }
+    };
 }
 
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const SSR_ATTR = 'data-server-rendered';
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop$1,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: "development" !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: "development" !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop$1,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-let warn$2 = noop$1;
-let tip = noop$1;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop$1;
+let tip = noop$1;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+{
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$1(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
+let uid = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove$1(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null;
+const targetStack = [];
+function pushTarget(target) {
+    targetStack.push(target);
+    Dep.target = target;
+}
+function popTarget() {
+    targetStack.pop();
+    Dep.target = targetStack[targetStack.length - 1];
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * In some cases we may want to disable observation inside a component's
+ * update computation.
+ */
+let shouldObserve = true;
+function toggleObserving(value) {
+    shouldObserve = value;
+}
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (shouldObserve &&
+        !isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if ((isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+{
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook$1(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook$1;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && "development" !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+/**
+ * Validate component names
+ */
+function checkComponents(options) {
+    for (const key in options.components) {
+        validateComponentName(key);
+    }
+}
+function validateComponentName(name) {
+    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
+        warn$2('Invalid component name: "' +
+            name +
+            '". Component names ' +
+            'should conform to valid custom element name in html5 specification.');
+    }
+    if (isBuiltInTag(name) || config.isReservedTag(name)) {
+        warn$2('Do not use built-in or reserved HTML elements as component ' +
+            'id: ' +
+            name);
+    }
+}
+/**
+ * Ensure all props option syntax are normalized into the
+ * Object-based format.
+ */
+function normalizeProps(options, vm) {
+    const props = options.props;
+    if (!props)
+        return;
+    const res = {};
+    let i, val, name;
+    if (Array.isArray(props)) {
+        i = props.length;
+        while (i--) {
+            val = props[i];
+            if (typeof val === 'string') {
+                name = camelize(val);
+                res[name] = { type: null };
+            }
+            else {
+                warn$2('props must be strings when using array syntax.');
+            }
+        }
+    }
+    else if (isPlainObject(props)) {
+        for (const key in props) {
+            val = props[key];
+            name = camelize(key);
+            res[name] = isPlainObject(val) ? val : { type: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
+            `but got ${toRawType(props)}.`, vm);
+    }
+    options.props = res;
+}
+/**
+ * Normalize all injections into Object-based format
+ */
+function normalizeInject(options, vm) {
+    const inject = options.inject;
+    if (!inject)
+        return;
+    const normalized = (options.inject = {});
+    if (Array.isArray(inject)) {
+        for (let i = 0; i < inject.length; i++) {
+            normalized[inject[i]] = { from: inject[i] };
+        }
+    }
+    else if (isPlainObject(inject)) {
+        for (const key in inject) {
+            const val = inject[key];
+            normalized[key] = isPlainObject(val)
+                ? extend({ from: key }, val)
+                : { from: val };
+        }
+    }
+    else {
+        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
+            `but got ${toRawType(inject)}.`, vm);
+    }
+}
+/**
+ * Normalize raw function directives into object format.
+ */
+function normalizeDirectives(options) {
+    const dirs = options.directives;
+    if (dirs) {
+        for (const key in dirs) {
+            const def = dirs[key];
+            if (typeof def === 'function') {
+                dirs[key] = { bind: def, update: def };
+            }
+        }
+    }
+}
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
+}
+/**
+ * Merge two option objects into a new one.
+ * Core utility used in both instantiation and inheritance.
+ */
+function mergeOptions(parent, child, vm) {
+    {
+        checkComponents(child);
+    }
+    if (typeof child === 'function') {
+        // @ts-expect-error
+        child = child.options;
+    }
+    normalizeProps(child, vm);
+    normalizeInject(child, vm);
+    normalizeDirectives(child);
+    // Apply extends and mixins on the child options,
+    // but only if it is a raw options object that isn't
+    // the result of another mergeOptions call.
+    // Only merged options has the _base property.
+    if (!child._base) {
+        if (child.extends) {
+            parent = mergeOptions(parent, child.extends, vm);
+        }
+        if (child.mixins) {
+            for (let i = 0, l = child.mixins.length; i < l; i++) {
+                parent = mergeOptions(parent, child.mixins[i], vm);
+            }
+        }
+    }
+    const options = {};
+    let key;
+    for (key in parent) {
+        mergeField(key);
+    }
+    for (key in child) {
+        if (!hasOwn(parent, key)) {
+            mergeField(key);
+        }
+    }
+    function mergeField(key) {
+        const strat = strats[key] || defaultStrat;
+        options[key] = strat(parent[key], child[key], vm, key);
+    }
+    return options;
+}
+/**
+ * Resolve an asset.
+ * This function is used because child instances need access
+ * to assets defined in its ancestor chain.
+ */
+function resolveAsset(options, type, id, warnMissing) {
+    /* istanbul ignore if */
+    if (typeof id !== 'string') {
+        return;
+    }
+    const assets = options[type];
+    // check local registration variations first
+    if (hasOwn(assets, id))
+        return assets[id];
+    const camelizedId = camelize(id);
+    if (hasOwn(assets, camelizedId))
+        return assets[camelizedId];
+    const PascalCaseId = capitalize(camelizedId);
+    if (hasOwn(assets, PascalCaseId))
+        return assets[PascalCaseId];
+    // fallback to prototype chain
+    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
+    if (warnMissing && !res) {
+        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
+    }
+    return res;
 }
 
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
+function validateProp(key, propOptions, propsData, vm) {
+    const prop = propOptions[key];
+    const absent = !hasOwn(propsData, key);
+    let value = propsData[key];
+    // boolean casting
+    const booleanIndex = getTypeIndex(Boolean, prop.type);
+    if (booleanIndex > -1) {
+        if (absent && !hasOwn(prop, 'default')) {
+            value = false;
+        }
+        else if (value === '' || value === hyphenate(key)) {
+            // only cast empty string / same name to boolean if
+            // boolean has higher priority
+            const stringIndex = getTypeIndex(String, prop.type);
+            if (stringIndex < 0 || booleanIndex < stringIndex) {
+                value = true;
+            }
+        }
+    }
+    // check default value
+    if (value === undefined) {
+        value = getPropDefaultValue(vm, prop, key);
+        // since the default value is a fresh copy,
+        // make sure to observe it.
+        const prevShouldObserve = shouldObserve;
+        toggleObserving(true);
+        observe(value);
+        toggleObserving(prevShouldObserve);
+    }
+    {
+        assertProp(prop, key, value, vm, absent);
+    }
+    return value;
+}
+/**
+ * Get the default value of a prop.
+ */
+function getPropDefaultValue(vm, prop, key) {
+    // no default, return undefined
+    if (!hasOwn(prop, 'default')) {
+        return undefined;
+    }
+    const def = prop.default;
+    // warn against non-factory defaults for Object & Array
+    if (isObject(def)) {
+        warn$2('Invalid default value for prop "' +
+            key +
+            '": ' +
+            'Props with type Object/Array must use a factory function ' +
+            'to return the default value.', vm);
+    }
+    // the raw prop value was also undefined from previous render,
+    // return previous default value to avoid unnecessary watcher trigger
+    if (vm &&
+        vm.$options.propsData &&
+        vm.$options.propsData[key] === undefined &&
+        vm._props[key] !== undefined) {
+        return vm._props[key];
+    }
+    // call factory function for non-Function types
+    // a value is Function if its prototype is function even across different execution context
+    return typeof def === 'function' && getType(prop.type) !== 'Function'
+        ? def.call(vm)
+        : def;
+}
+/**
+ * Assert whether a prop is valid.
+ */
+function assertProp(prop, name, value, vm, absent) {
+    if (prop.required && absent) {
+        warn$2('Missing required prop: "' + name + '"', vm);
+        return;
+    }
+    if (value == null && !prop.required) {
+        return;
+    }
+    let type = prop.type;
+    let valid = !type || type === true;
+    const expectedTypes = [];
+    if (type) {
+        if (!Array.isArray(type)) {
+            type = [type];
+        }
+        for (let i = 0; i < type.length && !valid; i++) {
+            const assertedType = assertType(value, type[i], vm);
+            expectedTypes.push(assertedType.expectedType || '');
+            valid = assertedType.valid;
+        }
+    }
+    const haveExpectedTypes = expectedTypes.some((t) => t);
+    if (!valid && haveExpectedTypes) {
+        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
+        return;
+    }
+    const validator = prop.validator;
+    if (validator) {
+        if (!validator(value)) {
+            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
+        }
+    }
+}
+const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
+function assertType(value, type, vm) {
+    let valid;
+    const expectedType = getType(type);
+    if (simpleCheckRE.test(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = isPlainObject(value);
+    }
+    else if (expectedType === 'Array') {
+        valid = Array.isArray(value);
+    }
+    else {
+        try {
+            valid = value instanceof type;
+        }
+        catch (e) {
+            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
+            valid = false;
+        }
+    }
+    return {
+        valid,
+        expectedType,
+    };
+}
+const functionTypeCheckRE = /^\s*function (\w+)/;
+/**
+ * Use function string name to check built-in types,
+ * because a simple equality check will fail when running
+ * across different vms / iframes.
+ */
+function getType(fn) {
+    const match = fn && fn.toString().match(functionTypeCheckRE);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (!Array.isArray(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    for (let i = 0, len = expectedTypes.length; i < len; i++) {
+        if (isSameType(expectedTypes[i], type)) {
+            return i;
+        }
+    }
+    return -1;
+}
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        isExplicable(typeof value) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${styleValue(value, expectedType)}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${styleValue(value, receivedType)}.`;
+    }
+    return message;
+}
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
+function isExplicable(value) {
+    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
+}
+function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === 'boolean');
 }
 
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
+function handleError(err, vm, info) {
+    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
+    // See: https://github.com/vuejs/vuex/issues/1505
+    pushTarget();
+    try {
+        if (vm) {
+            let cur = vm;
+            while ((cur = cur.$parent)) {
+                const hooks = cur.$options.errorCaptured;
+                if (hooks) {
+                    for (let i = 0; i < hooks.length; i++) {
+                        try {
+                            const capture = hooks[i].call(cur, err, vm, info) === false;
+                            if (capture)
+                                return;
+                        }
+                        catch (e) {
+                            globalHandleError(e, cur, 'errorCaptured hook');
+                        }
+                    }
+                }
+            }
+        }
+        globalHandleError(err, vm, info);
+    }
+    finally {
+        popTarget();
+    }
+}
+function invokeWithErrorHandling(handler, context, args, vm, info) {
+    let res;
+    try {
+        res = args ? handler.apply(context, args) : handler.call(context);
+        if (res && !res._isVue && isPromise(res) && !res._handled) {
+            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
+            // issue #9511
+            // avoid catch triggering multiple times when nested calls
+            res._handled = true;
+        }
+    }
+    catch (e) {
+        // @ts-expect-error should it be any?
+        handleError(e, vm, info);
+    }
+    return res;
+}
+function globalHandleError(err, vm, info) {
+    logError(err, vm, info);
+}
+function logError(err, vm, info) {
+    {
+        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
+    }
+    /* istanbul ignore else */
+    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+        console.error(err);
+    }
+    else {
+        throw err;
+    }
 }
 
-/* globals MutationObserver */
-const callbacks = [];
-function flushCallbacks() {
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve();
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+/* globals MutationObserver */
+const callbacks = [];
+function flushCallbacks() {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve();
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 else ;
 
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass$1(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass$1(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
+function genClassForVnode(vnode) {
+    let data = vnode.data;
+    let parentNode = vnode;
+    let childNode = vnode;
+    while (isDef(childNode.componentInstance)) {
+        childNode = childNode.componentInstance._vnode;
+        if (childNode && childNode.data) {
+            data = mergeClassData(childNode.data, data);
+        }
+    }
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while (isDef((parentNode = parentNode.parent))) {
+        if (parentNode && parentNode.data) {
+            data = mergeClassData(data, parentNode.data);
+        }
+    }
+    return renderClass$1(data.staticClass, data.class);
+}
+function mergeClassData(child, parent) {
+    return {
+        staticClass: concat(child.staticClass, parent.staticClass),
+        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    };
+}
+function renderClass$1(staticClass, dynamicClass) {
+    if (isDef(staticClass) || isDef(dynamicClass)) {
+        return concat(staticClass, stringifyClass(dynamicClass));
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function concat(a, b) {
+    return a ? (b ? a + ' ' + b : a) : b || '';
+}
+function stringifyClass(value) {
+    if (Array.isArray(value)) {
+        return stringifyArray(value);
+    }
+    if (isObject(value)) {
+        return stringifyObject(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    /* istanbul ignore next */
+    return '';
+}
+function stringifyArray(value) {
+    let res = '';
+    let stringified;
+    for (let i = 0, l = value.length; i < l; i++) {
+        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
+            if (res)
+                res += ' ';
+            res += stringified;
+        }
+    }
+    return res;
+}
+function stringifyObject(value) {
+    let res = '';
+    for (const key in value) {
+        if (value[key]) {
+            if (res)
+                res += ' ';
+            res += key;
+        }
+    }
+    return res;
 }
 
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
 makeMap('text,number,password,search,email,tel,url');
 
-function renderClass(node) {
-    const classList = genClassForVnode(node);
-    if (classList !== '') {
-        return ` class="${escape(classList)}"`;
-    }
+function renderClass(node) {
+    const classList = genClassForVnode(node);
+    if (classList !== '') {
+        return ` class="${escape(classList)}"`;
+    }
 }
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
+});
+// merge static and dynamic style data on the same vnode
+function normalizeStyleData(data) {
+    const style = normalizeStyleBinding(data.style);
+    // static style is pre-processed into an object during compilation
+    // and is always a fresh object, so it's safe to merge into it
+    return data.staticStyle ? extend(data.staticStyle, style) : style;
+}
+// normalize possible array / string values into Object
+function normalizeStyleBinding(bindingStyle) {
+    if (Array.isArray(bindingStyle)) {
+        return toObject(bindingStyle);
+    }
+    if (typeof bindingStyle === 'string') {
+        return parseStyleText(bindingStyle);
+    }
+    return bindingStyle;
+}
+/**
+ * parent component style should be after child's
+ * so that parent component's style could override it
+ */
+function getStyle(vnode, checkChild) {
+    const res = {};
+    let styleData;
+    if (checkChild) {
+        let childNode = vnode;
+        while (childNode.componentInstance) {
+            childNode = childNode.componentInstance._vnode;
+            if (childNode &&
+                childNode.data &&
+                (styleData = normalizeStyleData(childNode.data))) {
+                extend(res, styleData);
+            }
+        }
+    }
+    if ((styleData = normalizeStyleData(vnode.data))) {
+        extend(res, styleData);
+    }
+    let parentNode = vnode;
+    // @ts-expect-error parentNode.parent not VNodeWithData
+    while ((parentNode = parentNode.parent)) {
+        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
+            extend(res, styleData);
+        }
+    }
+    return res;
 }
 
-function genStyle(style) {
-    let styleText = '';
-    for (const key in style) {
-        const value = style[key];
-        const hyphenatedKey = hyphenate(key);
-        if (Array.isArray(value)) {
-            for (let i = 0, len = value.length; i < len; i++) {
-                styleText += normalizeValue(hyphenatedKey, value[i]);
-            }
-        }
-        else {
-            styleText += normalizeValue(hyphenatedKey, value);
-        }
-    }
-    return styleText;
-}
-function normalizeValue(key, value) {
-    if (typeof value === 'string' ||
-        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-        value === 0) {
-        return `${key}:${value};`;
-    }
-    else {
-        // invalid values
-        return ``;
-    }
-}
-function renderStyle(vnode) {
-    const styleText = genStyle(getStyle(vnode, false));
-    if (styleText !== '') {
-        return ` style=${JSON.stringify(escape(styleText))}`;
-    }
+function genStyle(style) {
+    let styleText = '';
+    for (const key in style) {
+        const value = style[key];
+        const hyphenatedKey = hyphenate(key);
+        if (Array.isArray(value)) {
+            for (let i = 0, len = value.length; i < len; i++) {
+                styleText += normalizeValue(hyphenatedKey, value[i]);
+            }
+        }
+        else {
+            styleText += normalizeValue(hyphenatedKey, value);
+        }
+    }
+    return styleText;
+}
+function normalizeValue(key, value) {
+    if (typeof value === 'string' ||
+        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
+        value === 0) {
+        return `${key}:${value};`;
+    }
+    else {
+        // invalid values
+        return ``;
+    }
+}
+function renderStyle(vnode) {
+    const styleText = genStyle(getStyle(vnode, false));
+    if (styleText !== '') {
+        return ` style=${JSON.stringify(escape(styleText))}`;
+    }
 }
 
 var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
 
-function show(node, dir) {
-    if (!dir.value) {
-        const style = node.data.style || (node.data.style = {});
-        if (Array.isArray(style)) {
-            style.push({ display: 'none' });
-        }
-        else {
-            style.display = 'none';
-        }
-    }
+function show(node, dir) {
+    if (!dir.value) {
+        const style = node.data.style || (node.data.style = {});
+        if (Array.isArray(style)) {
+            style.push({ display: 'none' });
+        }
+        else {
+            style.display = 'none';
+        }
+    }
 }
 
-// this is only applied for <select v-model> because it is the only edge case
-// that must be done at runtime instead of compile time.
-function model$2(node, dir) {
-    if (!node.children)
-        return;
-    const value = dir.value;
-    const isMultiple = node.data.attrs && node.data.attrs.multiple;
-    for (let i = 0, l = node.children.length; i < l; i++) {
-        const option = node.children[i];
-        if (option.tag === 'option') {
-            if (isMultiple) {
-                const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
-                if (selected) {
-                    setSelected(option);
-                }
-            }
-            else {
-                if (looseEqual(value, getValue(option))) {
-                    setSelected(option);
-                    return;
-                }
-            }
-        }
-    }
-}
-function getValue(option) {
-    const data = option.data || {};
-    return ((data.attrs && data.attrs.value) ||
-        (data.domProps && data.domProps.value) ||
-        (option.children && option.children[0] && option.children[0].text));
-}
-function setSelected(option) {
-    const data = option.data || (option.data = {});
-    const attrs = data.attrs || (data.attrs = {});
-    attrs.selected = '';
+// this is only applied for <select v-model> because it is the only edge case
+// that must be done at runtime instead of compile time.
+function model$2(node, dir) {
+    if (!node.children)
+        return;
+    const value = dir.value;
+    const isMultiple = node.data.attrs && node.data.attrs.multiple;
+    for (let i = 0, l = node.children.length; i < l; i++) {
+        const option = node.children[i];
+        if (option.tag === 'option') {
+            if (isMultiple) {
+                const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
+                if (selected) {
+                    setSelected(option);
+                }
+            }
+            else {
+                if (looseEqual(value, getValue(option))) {
+                    setSelected(option);
+                    return;
+                }
+            }
+        }
+    }
+}
+function getValue(option) {
+    const data = option.data || {};
+    return ((data.attrs && data.attrs.value) ||
+        (data.domProps && data.domProps.value) ||
+        (option.children && option.children[0] && option.children[0].text));
+}
+function setSelected(option) {
+    const data = option.data || (option.data = {});
+    const attrs = data.attrs || (data.attrs = {});
+    attrs.selected = '';
 }
 
-var baseDirectives$1 = {
-    show,
-    model: model$2,
+var baseDirectives$1 = {
+    show,
+    model: model$2,
 };
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-const MAX_STACK_DEPTH = 800;
-const noop = (_) => _;
-const defer = typeof process !== 'undefined' && process.nextTick
-    ? process.nextTick
-    : typeof Promise !== 'undefined'
-        ? (fn) => Promise.resolve().then(fn)
-        : typeof setTimeout !== 'undefined'
-            ? setTimeout
-            : noop;
-if (defer === noop) {
-    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
-        'that are required by vue-server-renderer. Please use a polyfill for ' +
-        'either Promise or setTimeout.');
-}
-function createWriteFunction(write, onError) {
-    let stackDepth = 0;
-    const cachedWrite = (text, next) => {
-        if (text && cachedWrite.caching) {
-            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-        }
-        const waitForNext = write(text, next);
-        if (waitForNext !== true) {
-            if (stackDepth >= MAX_STACK_DEPTH) {
-                defer(() => {
-                    try {
-                        next();
-                    }
-                    catch (e) {
-                        onError(e);
-                    }
-                });
-            }
-            else {
-                stackDepth++;
-                next();
-                stackDepth--;
-            }
-        }
-    };
-    cachedWrite.caching = false;
-    cachedWrite.cacheBuffer = [];
-    cachedWrite.componentBuffer = [];
-    return cachedWrite;
+const MAX_STACK_DEPTH = 800;
+const noop = (_) => _;
+const defer = typeof process !== 'undefined' && process.nextTick
+    ? process.nextTick
+    : typeof Promise !== 'undefined'
+        ? (fn) => Promise.resolve().then(fn)
+        : typeof setTimeout !== 'undefined'
+            ? setTimeout
+            : noop;
+if (defer === noop) {
+    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
+        'that are required by vue-server-renderer. Please use a polyfill for ' +
+        'either Promise or setTimeout.');
+}
+function createWriteFunction(write, onError) {
+    let stackDepth = 0;
+    const cachedWrite = (text, next) => {
+        if (text && cachedWrite.caching) {
+            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
+        }
+        const waitForNext = write(text, next);
+        if (waitForNext !== true) {
+            if (stackDepth >= MAX_STACK_DEPTH) {
+                defer(() => {
+                    try {
+                        next();
+                    }
+                    catch (e) {
+                        onError(e);
+                    }
+                });
+            }
+            else {
+                stackDepth++;
+                next();
+                stackDepth--;
+            }
+        }
+    };
+    cachedWrite.caching = false;
+    cachedWrite.cacheBuffer = [];
+    cachedWrite.componentBuffer = [];
+    return cachedWrite;
 }
 
-/**
- * Original RenderStream implementation by Sasha Aickin (@aickin)
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Modified by Evan You (@yyx990803)
- */
-class RenderStream extends stream.Readable {
-    buffer;
-    render;
-    expectedSize;
-    write;
-    //@ts-expect-error
-    next;
-    end;
-    //@ts-expect-error
-    done;
-    constructor(render) {
-        super();
-        this.buffer = '';
-        //@ts-expect-error
-        this.render = render;
-        this.expectedSize = 0;
-        this.write = createWriteFunction((text, next) => {
-            const n = this.expectedSize;
-            this.buffer += text;
-            if (this.buffer.length >= n) {
-                this.next = next;
-                this.pushBySize(n);
-                return true; // we will decide when to call next
-            }
-            return false;
-        }, (err) => {
-            this.emit('error', err);
-        });
-        this.end = () => {
-            this.emit('beforeEnd');
-            // the rendering is finished; we should push out the last of the buffer.
-            this.done = true;
-            this.push(this.buffer);
-        };
-    }
-    pushBySize(n) {
-        const bufferToPush = this.buffer.substring(0, n);
-        this.buffer = this.buffer.substring(n);
-        this.push(bufferToPush);
-    }
-    tryRender() {
-        try {
-            this.render(this.write, this.end);
-        }
-        catch (e) {
-            this.emit('error', e);
-        }
-    }
-    tryNext() {
-        try {
-            this.next();
-        }
-        catch (e) {
-            this.emit('error', e);
-        }
-    }
-    _read(n) {
-        this.expectedSize = n;
-        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-        // which means we will need to go through multiple read calls to drain it
-        // down to < n.
-        if (isTrue(this.done)) {
-            this.push(null);
-            return;
-        }
-        if (this.buffer.length >= n) {
-            this.pushBySize(n);
-            return;
-        }
-        if (isUndef(this.next)) {
-            // start the rendering chain.
-            this.tryRender();
-        }
-        else {
-            // continue with the rendering.
-            this.tryNext();
-        }
-    }
+/**
+ * Original RenderStream implementation by Sasha Aickin (@aickin)
+ * Licensed under the Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Modified by Evan You (@yyx990803)
+ */
+class RenderStream extends stream.Readable {
+    buffer;
+    render;
+    expectedSize;
+    write;
+    //@ts-expect-error
+    next;
+    end;
+    //@ts-expect-error
+    done;
+    constructor(render) {
+        super();
+        this.buffer = '';
+        //@ts-expect-error
+        this.render = render;
+        this.expectedSize = 0;
+        this.write = createWriteFunction((text, next) => {
+            const n = this.expectedSize;
+            this.buffer += text;
+            if (this.buffer.length >= n) {
+                this.next = next;
+                this.pushBySize(n);
+                return true; // we will decide when to call next
+            }
+            return false;
+        }, (err) => {
+            this.emit('error', err);
+        });
+        this.end = () => {
+            this.emit('beforeEnd');
+            // the rendering is finished; we should push out the last of the buffer.
+            this.done = true;
+            this.push(this.buffer);
+        };
+    }
+    pushBySize(n) {
+        const bufferToPush = this.buffer.substring(0, n);
+        this.buffer = this.buffer.substring(n);
+        this.push(bufferToPush);
+    }
+    tryRender() {
+        try {
+            this.render(this.write, this.end);
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    tryNext() {
+        try {
+            this.next();
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    _read(n) {
+        this.expectedSize = n;
+        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
+        // which means we will need to go through multiple read calls to drain it
+        // down to < n.
+        if (isTrue(this.done)) {
+            this.push(null);
+            return;
+        }
+        if (this.buffer.length >= n) {
+            this.pushBySize(n);
+            return;
+        }
+        if (isUndef(this.next)) {
+            // start the rendering chain.
+            this.tryRender();
+        }
+        else {
+            // continue with the rendering.
+            this.tryNext();
+        }
+    }
 }
 
-class RenderContext {
-    userContext;
-    activeInstance;
-    renderStates;
-    write;
-    renderNode;
-    //@ts-expect-error
-    next;
-    done;
-    modules;
-    directives;
-    isUnaryTag;
-    cache;
-    get;
-    has;
-    constructor(options) {
-        this.userContext = options.userContext;
-        this.activeInstance = options.activeInstance;
-        this.renderStates = [];
-        this.write = options.write;
-        this.done = options.done;
-        this.renderNode = options.renderNode;
-        this.isUnaryTag = options.isUnaryTag;
-        this.modules = options.modules;
-        this.directives = options.directives;
-        const cache = options.cache;
-        if (cache && (!cache.get || !cache.set)) {
-            throw new Error('renderer cache must implement at least get & set.');
-        }
-        this.cache = cache;
-        this.get = cache && normalizeAsync(cache, 'get');
-        this.has = cache && normalizeAsync(cache, 'has');
-        //@ts-expect-error
-        this.next = this.next.bind(this);
-    }
-    //@ts-expect-error
-    next() {
-        // eslint-disable-next-line
-        while (true) {
-            const lastState = this.renderStates[this.renderStates.length - 1];
-            if (isUndef(lastState)) {
-                return this.done();
-            }
-            /* eslint-disable no-case-declarations */
-            switch (lastState.type) {
-                case 'Element':
-                case 'Fragment':
-                    const { children, total } = lastState;
-                    const rendered = lastState.rendered++;
-                    if (rendered < total) {
-                        return this.renderNode(children[rendered], false, this);
-                    }
-                    else {
-                        this.renderStates.pop();
-                        if (lastState.type === 'Element') {
-                            return this.write(lastState.endTag, this.next);
-                        }
-                    }
-                    break;
-                case 'Component':
-                    this.renderStates.pop();
-                    this.activeInstance = lastState.prevActive;
-                    break;
-                case 'ComponentWithCache':
-                    this.renderStates.pop();
-                    const { buffer, bufferIndex, componentBuffer, key } = lastState;
-                    const result = {
-                        html: buffer[bufferIndex],
-                        components: componentBuffer[bufferIndex],
-                    };
-                    this.cache.set(key, result);
-                    if (bufferIndex === 0) {
-                        // this is a top-level cached component,
-                        // exit caching mode.
-                        //@ts-expect-error
-                        this.write.caching = false;
-                    }
-                    else {
-                        // parent component is also being cached,
-                        // merge self into parent's result
-                        buffer[bufferIndex - 1] += result.html;
-                        const prev = componentBuffer[bufferIndex - 1];
-                        result.components.forEach((c) => prev.add(c));
-                    }
-                    buffer.length = bufferIndex;
-                    componentBuffer.length = bufferIndex;
-                    break;
-            }
-        }
-    }
-}
-function normalizeAsync(cache, method) {
-    const fn = cache[method];
-    if (isUndef(fn)) {
-        return;
-    }
-    else if (fn.length > 1) {
-        return (key, cb) => fn.call(cache, key, cb);
-    }
-    else {
-        return (key, cb) => cb(fn.call(cache, key));
-    }
+class RenderContext {
+    userContext;
+    activeInstance;
+    renderStates;
+    write;
+    renderNode;
+    //@ts-expect-error
+    next;
+    done;
+    modules;
+    directives;
+    isUnaryTag;
+    cache;
+    get;
+    has;
+    constructor(options) {
+        this.userContext = options.userContext;
+        this.activeInstance = options.activeInstance;
+        this.renderStates = [];
+        this.write = options.write;
+        this.done = options.done;
+        this.renderNode = options.renderNode;
+        this.isUnaryTag = options.isUnaryTag;
+        this.modules = options.modules;
+        this.directives = options.directives;
+        const cache = options.cache;
+        if (cache && (!cache.get || !cache.set)) {
+            throw new Error('renderer cache must implement at least get & set.');
+        }
+        this.cache = cache;
+        this.get = cache && normalizeAsync(cache, 'get');
+        this.has = cache && normalizeAsync(cache, 'has');
+        //@ts-expect-error
+        this.next = this.next.bind(this);
+    }
+    //@ts-expect-error
+    next() {
+        // eslint-disable-next-line
+        while (true) {
+            const lastState = this.renderStates[this.renderStates.length - 1];
+            if (isUndef(lastState)) {
+                return this.done();
+            }
+            /* eslint-disable no-case-declarations */
+            switch (lastState.type) {
+                case 'Element':
+                case 'Fragment':
+                    const { children, total } = lastState;
+                    const rendered = lastState.rendered++;
+                    if (rendered < total) {
+                        return this.renderNode(children[rendered], false, this);
+                    }
+                    else {
+                        this.renderStates.pop();
+                        if (lastState.type === 'Element') {
+                            return this.write(lastState.endTag, this.next);
+                        }
+                    }
+                    break;
+                case 'Component':
+                    this.renderStates.pop();
+                    this.activeInstance = lastState.prevActive;
+                    break;
+                case 'ComponentWithCache':
+                    this.renderStates.pop();
+                    const { buffer, bufferIndex, componentBuffer, key } = lastState;
+                    const result = {
+                        html: buffer[bufferIndex],
+                        components: componentBuffer[bufferIndex],
+                    };
+                    this.cache.set(key, result);
+                    if (bufferIndex === 0) {
+                        // this is a top-level cached component,
+                        // exit caching mode.
+                        //@ts-expect-error
+                        this.write.caching = false;
+                    }
+                    else {
+                        // parent component is also being cached,
+                        // merge self into parent's result
+                        buffer[bufferIndex - 1] += result.html;
+                        const prev = componentBuffer[bufferIndex - 1];
+                        result.components.forEach((c) => prev.add(c));
+                    }
+                    buffer.length = bufferIndex;
+                    componentBuffer.length = bufferIndex;
+                    break;
+            }
+        }
+    }
+}
+function normalizeAsync(cache, method) {
+    const fn = cache[method];
+    if (isUndef(fn)) {
+        return;
+    }
+    else if (fn.length > 1) {
+        return (key, cb) => fn.call(cache, key, cb);
+    }
+    else {
+        return (key, cb) => cb(fn.call(cache, key));
+    }
 }
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (!stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if ((i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he__default["default"].decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn$1;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn$1(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn: warn$1,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn$1('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn$1(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he__default["default"].decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        {
+            if (el.tag === 'template') {
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else {
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else {
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (children[i].text !== ' ') {
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (slotScope) {
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (el.attrsMap['v-for']) {
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                {
+                    if (!maybeComponent(el)) {
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else {
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (el.key) {
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (value.trim().length === 0) {
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model$1 = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model$1 = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model$1];
 
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model,
-    text,
-    html,
+var directives = {
+    model,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys(modules),
 };
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop$1,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop$1,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate$1(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate$1(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate$1(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if ((el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate$1(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-    if (el.directives) {
-        for (let i = 0; i < el.directives.length; i++) {
-            const dir = el.directives[i];
-            if (dir.name === 'model') {
-                state.directives.model(el, dir, state.warn);
-                // remove value for textarea as its converted to text
-                if (el.tag === 'textarea' && el.props) {
-                    el.props = el.props.filter((p) => p.name !== 'value');
-                }
-                break;
-            }
-        }
-    }
-}
-function genAttrSegments(attrs) {
-    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-}
-function genDOMPropSegments(props, attrs) {
-    const segments = [];
-    props.forEach(({ name, value }) => {
-        name = propsToAttrMap[name] || name.toLowerCase();
-        if (isRenderableAttr(name) &&
-            !(attrs && attrs.some((a) => a.name === name))) {
-            segments.push(genAttrSegment(name, value));
-        }
-    });
-    return segments;
-}
-function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-        // force double quote
-        value = value.replace(/^'|'$/g, '"');
-        // force enumerated attr to "true"
-        if (isEnumeratedAttr(name) && value !== `"false"`) {
-            value = `"true"`;
-        }
-        return {
-            type: RAW,
-            value: isBooleanAttr(name)
-                ? ` ${name}="${name}"`
-                : value === '""'
-                    ? ` ${name}`
-                    : ` ${name}="${JSON.parse(value)}"`,
-        };
-    }
-    else {
-        return {
-            type: EXPRESSION,
-            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-        };
-    }
-}
-function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-            },
-        ];
-    }
-}
-function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-            },
-        ];
-    }
+const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+// let the model AST transform translate v-model into appropriate
+// props bindings
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (let i = 0; i < el.directives.length; i++) {
+            const dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter((p) => p.name !== 'value');
+                }
+                break;
+            }
+        }
+    }
+}
+function genAttrSegments(attrs) {
+    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+}
+function genDOMPropSegments(props, attrs) {
+    const segments = [];
+    props.forEach(({ name, value }) => {
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some((a) => a.name === name))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== `"false"`) {
+            value = `"true"`;
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? ` ${name}="${name}"`
+                : value === '""'
+                    ? ` ${name}`
+                    : ` ${name}="${JSON.parse(value)}"`,
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+        };
+    }
+}
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+            },
+        ];
+    }
+}
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+            },
+        ];
+    }
 }
 
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-const optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-};
-let isPlatformReservedTag;
-function optimize(root, options) {
-    if (!root)
-        return;
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-}
-function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-        node.ssrOptimizability = optimizability.FALSE;
-        return;
-    }
-    // root node or nodes with custom directives should always be a VNode
-    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-    const check = (child) => {
-        if (child.ssrOptimizability !== optimizability.FULL) {
-            node.ssrOptimizability = selfUnoptimizable
-                ? optimizability.PARTIAL
-                : optimizability.SELF;
-        }
-    };
-    if (selfUnoptimizable) {
-        node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            walk(child);
-            check(child);
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                walk(block, isRoot);
-                check(block);
-            }
-        }
-        if (node.ssrOptimizability == null ||
-            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-            node.ssrOptimizability = optimizability.FULL;
-        }
-        else {
-            node.children = optimizeSiblings(node);
-        }
-    }
-    else {
-        node.ssrOptimizability = optimizability.FULL;
-    }
-}
-function optimizeSiblings(el) {
-    const children = el.children;
-    const optimizedChildren = [];
-    let currentOptimizableGroup = [];
-    const pushGroup = () => {
-        if (currentOptimizableGroup.length) {
-            optimizedChildren.push({
-                type: 1,
-                parent: el,
-                tag: 'template',
-                attrsList: [],
-                attrsMap: {},
-                rawAttrsMap: {},
-                children: currentOptimizableGroup,
-                ssrOptimizability: optimizability.FULL,
-            });
-        }
-        currentOptimizableGroup = [];
-    };
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.ssrOptimizability === optimizability.FULL) {
-            currentOptimizableGroup.push(c);
-        }
-        else {
-            // wrap fully-optimizable adjacent siblings inside a template tag
-            // so that they can be optimized into a single ssrNode by codegen
-            pushGroup();
-            optimizedChildren.push(c);
-        }
-    }
-    pushGroup();
-    return optimizedChildren;
-}
-function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-        // text or expression
-        return false;
-    }
-    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag(node.tag) || // custom component
-        !!node.component || // "is" component
-        isSelectWithModel(node) // <select v-model> requires runtime inspection
-    );
-}
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-function hasCustomDirective(node) {
-    return (node.type === 1 &&
-        node.directives &&
-        node.directives.some((d) => !isBuiltInDir(d.name)));
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-    return (node.type === 1 &&
-        node.tag === 'select' &&
-        node.directives != null &&
-        node.directives.some((d) => d.name === 'model'));
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
+// optimizability constants
+const optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+};
+let isPlatformReservedTag;
+function optimize(root, options) {
+    if (!root)
+        return;
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+    const check = (child) => {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
+    }
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    const children = el.children;
+    const optimizedChildren = [];
+    let currentOptimizableGroup = [];
+    const pushGroup = () => {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
+}
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
+}
+const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some((d) => !isBuiltInDir(d.name)));
+}
+// <select v-model> cannot be optimized because it requires a runtime check
+// to determine proper selected option
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some((d) => d.name === 'model'));
 }
 
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-const RAW = 0;
-const INTERPOLATION = 1;
-const EXPRESSION = 2;
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genSSRElement);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state, genSSRElement);
-    }
-    else if (el.tag === 'template' && !el.slotTarget) {
-        return el.ssrOptimizability === optimizability.FULL
-            ? genChildrenAsStringNode(el, state)
-            : genSSRChildren(el, state) || 'void 0';
-    }
-    switch (el.ssrOptimizability) {
-        case optimizability.FULL:
-            // stringify whole tree
-            return genStringElement(el, state);
-        case optimizability.SELF:
-            // stringify self and check children
-            return genStringElementWithChildren(el, state);
-        case optimizability.CHILDREN:
-            // generate self as VNode and stringify children
-            return genNormalElement(el, state, true);
-        case optimizability.PARTIAL:
-            // generate self as VNode and check children
-            return genNormalElement(el, state, false);
-        default:
-            // bail whole tree
-            return genElement(el, state);
-    }
-}
-function genNormalElement(el, state, stringifyChildren) {
-    const data = el.plain ? undefined : genData(el, state);
-    const children = stringifyChildren
-        ? `[${genChildrenAsStringNode(el, state)}]`
-        : genSSRChildren(el, state, true);
-    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-}
-function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-}
-function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-}
-function genChildrenAsStringNode(el, state) {
-    return el.children.length
-        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-        : '';
-}
-function genStringElement(el, state) {
-    return `_ssrNode(${elementToString(el, state)})`;
-}
-function genStringElementWithChildren(el, state) {
-    const children = genSSRChildren(el, state, true);
-    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-}
-function elementToString(el, state) {
-    return `(${flattenSegments(elementToSegments(el, state))})`;
-}
-function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-        el.forProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genFor(el, state, elementToString, '_ssrList'),
-            },
-        ];
-    }
-    else if (el.if && !el.ifProcessed) {
-        el.ifProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genIf(el, state, elementToString, '"<!---->"'),
-            },
-        ];
-    }
-    else if (el.tag === 'template') {
-        return childrenToSegments(el, state);
-    }
-    const openSegments = elementToOpenTagSegments(el, state);
-    const childrenSegments = childrenToSegments(el, state);
-    const { isUnaryTag } = state.options;
-    const close = isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: `</${el.tag}>` }];
-    return openSegments.concat(childrenSegments, close);
-}
-function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state);
-    let binding;
-    const segments = [{ type: RAW, value: `<${el.tag}` }];
-    // attrs
-    if (el.attrs) {
-        segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-    }
-    segments.push({ type: RAW, value: `>` });
-    return segments;
-}
-function childrenToSegments(el, state) {
-    let binding;
-    if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    return el.children ? nodesToSegments(el.children, state) : [];
-}
-function nodesToSegments(children, state) {
-    const segments = [];
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.type === 1) {
-            segments.push.apply(segments, elementToSegments(c, state));
-        }
-        else if (c.type === 2) {
-            segments.push({ type: INTERPOLATION, value: c.expression });
-        }
-        else if (c.type === 3) {
-            let text = escape(c.text);
-            if (c.isComment) {
-                text = '<!--' + text + '-->';
-            }
-            segments.push({ type: RAW, value: text });
-        }
-    }
-    return segments;
-}
-function flattenSegments(segments) {
-    const mergedSegments = [];
-    let textBuffer = '';
-    const pushBuffer = () => {
-        if (textBuffer) {
-            mergedSegments.push(JSON.stringify(textBuffer));
-            textBuffer = '';
-        }
-    };
-    for (let i = 0; i < segments.length; i++) {
-        const s = segments[i];
-        if (s.type === RAW) {
-            textBuffer += s.value;
-        }
-        else if (s.type === INTERPOLATION) {
-            pushBuffer();
-            mergedSegments.push(`_ssrEscape(${s.value})`);
-        }
-        else if (s.type === EXPRESSION) {
-            pushBuffer();
-            mergedSegments.push(`(${s.value})`);
-        }
-    }
-    pushBuffer();
-    return mergedSegments.join('+');
+// The SSR codegen is essentially extending the default codegen to handle
+// segment types
+const RAW = 0;
+const INTERPOLATION = 1;
+const EXPRESSION = 2;
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    const data = el.plain ? undefined : genData(el, state);
+    const children = stringifyChildren
+        ? `[${genChildrenAsStringNode(el, state)}]`
+        : genSSRChildren(el, state, true);
+    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+        : '';
+}
+function genStringElement(el, state) {
+    return `_ssrNode(${elementToString(el, state)})`;
+}
+function genStringElementWithChildren(el, state) {
+    const children = genSSRChildren(el, state, true);
+    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+}
+function elementToString(el, state) {
+    return `(${flattenSegments(elementToSegments(el, state))})`;
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            },
+        ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            },
+        ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    const openSegments = elementToOpenTagSegments(el, state);
+    const childrenSegments = childrenToSegments(el, state);
+    const { isUnaryTag } = state.options;
+    const close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: `</${el.tag}>` }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    let binding;
+    const segments = [{ type: RAW, value: `<${el.tag}` }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+    }
+    segments.push({ type: RAW, value: `>` });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    let binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    const segments = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            let text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
+}
+function flattenSegments(segments) {
+    const mergedSegments = [];
+    let textBuffer = '';
+    const pushBuffer = () => {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(`_ssrEscape(${s.value})`);
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(`(${s.value})`);
+        }
+    }
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop$1;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop$1;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = typeof (msg) === 'string' ? { msg } : msg;
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    optimize(ast, options);
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    optimize(ast, options);
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile: compile$1, compileToFunctions } = createCompiler(baseOptions);
 
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
+// The template compiler attempts to minimize the need for normalization by
+// statically analyzing the template at compile time.
+//
+// For plain HTML markup, normalization can be completely skipped because the
+// generated render function is guaranteed to return Array<VNode>. There are
+// two cases where extra normalization is needed:
+// 1. When the children contains components - because a functional component
+// may return an Array instead of a single root. In this case, just a simple
+// normalization is needed - if any child is an Array, we flatten the whole
+// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
+// because functional components already normalize their own children.
+function simpleNormalizeChildren(children) {
+    for (let i = 0; i < children.length; i++) {
+        if (Array.isArray(children[i])) {
+            return Array.prototype.concat.apply([], children);
+        }
+    }
+    return children;
+}
+// 2. When the children contains constructs that always generated nested Arrays,
+// e.g. <template>, <slot>, v-for, or when the children is provided by user
+// with hand-written render functions / JSX. In such cases a full normalization
+// is needed to cater to all possible types of children values.
+function normalizeChildren(children) {
+    return isPrimitive(children)
+        ? [createTextVNode(children)]
+        : Array.isArray(children)
+            ? normalizeArrayChildren(children)
+            : undefined;
+}
+function isTextNode(node) {
+    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
+}
+function normalizeArrayChildren(children, nestedIndex) {
+    const res = [];
+    let i, c, lastIndex, last;
+    for (i = 0; i < children.length; i++) {
+        c = children[i];
+        if (isUndef(c) || typeof c === 'boolean')
+            continue;
+        lastIndex = res.length - 1;
+        last = res[lastIndex];
+        //  nested
+        if (Array.isArray(c)) {
+            if (c.length > 0) {
+                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
+                // merge adjacent text nodes
+                if (isTextNode(c[0]) && isTextNode(last)) {
+                    res[lastIndex] = createTextVNode(last.text + c[0].text);
+                    c.shift();
+                }
+                res.push.apply(res, c);
+            }
+        }
+        else if (isPrimitive(c)) {
+            if (isTextNode(last)) {
+                // merge adjacent text nodes
+                // this is necessary for SSR hydration because text nodes are
+                // essentially merged when rendered to HTML strings
+                res[lastIndex] = createTextVNode(last.text + c);
+            }
+            else if (c !== '') {
+                // convert primitive to vnode
+                res.push(createTextVNode(c));
+            }
+        }
+        else {
+            if (isTextNode(c) && isTextNode(last)) {
+                // merge adjacent text nodes
+                res[lastIndex] = createTextVNode(last.text + c.text);
+            }
+            else {
+                // default key for nested array children (likely generated by v-for)
+                if (isTrue(children._isVList) &&
+                    isDef(c.tag) &&
+                    isUndef(c.key) &&
+                    isDef(nestedIndex)) {
+                    c.key = `__vlist${nestedIndex}_${i}__`;
+                }
+                res.push(c);
+            }
+        }
+    }
+    return res;
 }
 
-const ssrHelpers = {
-    _ssrEscape: escape,
-    _ssrNode: renderStringNode$1,
-    _ssrList: renderStringList,
-    _ssrAttr: renderAttr,
-    _ssrAttrs: renderAttrs,
-    _ssrDOMProps: renderDOMProps,
-    _ssrClass: renderSSRClass,
-    _ssrStyle: renderSSRStyle,
-};
-function installSSRHelpers(vm) {
-    if (vm._ssrNode) {
-        return;
-    }
-    let Vue = vm.constructor;
-    // @ts-expect-error
-    while (Vue.super) {
-        // @ts-expect-error
-        Vue = Vue.super;
-    }
-    extend(Vue.prototype, ssrHelpers);
-    // @ts-expect-error
-    if (Vue.FunctionalRenderContext) {
-        // @ts-expect-error
-        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-    }
-}
-class StringNode {
-    isString;
-    open;
-    close;
-    children;
-    constructor(open, close, children, normalizationType) {
-        this.isString = true;
-        this.open = open;
-        this.close = close;
-        if (children) {
-            this.children =
-                normalizationType === 1
-                    ? simpleNormalizeChildren(children)
-                    : normalizationType === 2
-                        ? normalizeChildren(children)
-                        : children;
-        }
-        else {
-            this.children = void 0;
-        }
-    }
-}
-function renderStringNode$1(open, close, children, normalizationType) {
-    return new StringNode(open, close, children, normalizationType);
-}
-function renderStringList(val, render) {
-    let ret = '';
-    let i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        for (i = 0, l = val.length; i < l; i++) {
-            ret += render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        for (i = 0; i < val; i++) {
-            ret += render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        keys = Object.keys(val);
-        for (i = 0, l = keys.length; i < l; i++) {
-            key = keys[i];
-            ret += render(val[key], key, i);
-        }
-    }
-    return ret;
-}
-function renderAttrs(obj) {
-    let res = '';
-    for (const key in obj) {
-        if (isSSRUnsafeAttr(key)) {
-            continue;
-        }
-        res += renderAttr(key, obj[key]);
-    }
-    return res;
-}
-function renderDOMProps(obj) {
-    let res = '';
-    for (const key in obj) {
-        const attr = propsToAttrMap[key] || key.toLowerCase();
-        if (isRenderableAttr(attr)) {
-            res += renderAttr(attr, obj[key]);
-        }
-    }
-    return res;
-}
-function renderSSRClass(staticClass, dynamic) {
-    const res = renderClass$1(staticClass, dynamic);
-    return res === '' ? res : ` class="${escape(res)}"`;
-}
-function renderSSRStyle(staticStyle, dynamic, extra) {
-    const style = {};
-    if (staticStyle)
-        extend(style, staticStyle);
-    if (dynamic)
-        extend(style, normalizeStyleBinding(dynamic));
-    if (extra)
-        extend(style, extra);
-    const res = genStyle(style);
-    return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
+const ssrHelpers = {
+    _ssrEscape: escape,
+    _ssrNode: renderStringNode$1,
+    _ssrList: renderStringList,
+    _ssrAttr: renderAttr,
+    _ssrAttrs: renderAttrs,
+    _ssrDOMProps: renderDOMProps,
+    _ssrClass: renderSSRClass,
+    _ssrStyle: renderSSRStyle,
+};
+function installSSRHelpers(vm) {
+    if (vm._ssrNode) {
+        return;
+    }
+    let Vue = vm.constructor;
+    // @ts-expect-error
+    while (Vue.super) {
+        // @ts-expect-error
+        Vue = Vue.super;
+    }
+    extend(Vue.prototype, ssrHelpers);
+    // @ts-expect-error
+    if (Vue.FunctionalRenderContext) {
+        // @ts-expect-error
+        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
+    }
+}
+class StringNode {
+    isString;
+    open;
+    close;
+    children;
+    constructor(open, close, children, normalizationType) {
+        this.isString = true;
+        this.open = open;
+        this.close = close;
+        if (children) {
+            this.children =
+                normalizationType === 1
+                    ? simpleNormalizeChildren(children)
+                    : normalizationType === 2
+                        ? normalizeChildren(children)
+                        : children;
+        }
+        else {
+            this.children = void 0;
+        }
+    }
+}
+function renderStringNode$1(open, close, children, normalizationType) {
+    return new StringNode(open, close, children, normalizationType);
+}
+function renderStringList(val, render) {
+    let ret = '';
+    let i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        for (i = 0, l = val.length; i < l; i++) {
+            ret += render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        for (i = 0; i < val; i++) {
+            ret += render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        keys = Object.keys(val);
+        for (i = 0, l = keys.length; i < l; i++) {
+            key = keys[i];
+            ret += render(val[key], key, i);
+        }
+    }
+    return ret;
+}
+function renderAttrs(obj) {
+    let res = '';
+    for (const key in obj) {
+        if (isSSRUnsafeAttr(key)) {
+            continue;
+        }
+        res += renderAttr(key, obj[key]);
+    }
+    return res;
+}
+function renderDOMProps(obj) {
+    let res = '';
+    for (const key in obj) {
+        const attr = propsToAttrMap[key] || key.toLowerCase();
+        if (isRenderableAttr(attr)) {
+            res += renderAttr(attr, obj[key]);
+        }
+    }
+    return res;
+}
+function renderSSRClass(staticClass, dynamic) {
+    const res = renderClass$1(staticClass, dynamic);
+    return res === '' ? res : ` class="${escape(res)}"`;
+}
+function renderSSRStyle(staticStyle, dynamic, extra) {
+    const style = {};
+    if (staticStyle)
+        extend(style, staticStyle);
+    if (dynamic)
+        extend(style, normalizeStyleBinding(dynamic));
+    if (extra)
+        extend(style, extra);
+    const res = genStyle(style);
+    return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
 }
 
-/* not type checking this file because flow doesn't play well with Proxy */
-{
-    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
+/* not type checking this file because flow doesn't play well with Proxy */
+{
+    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
+        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
+        'require' // for Webpack/Browserify
+    );
+    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
+    if (hasProxy) {
+        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
+        config.keyCodes = new Proxy(config.keyCodes, {
+            set(target, key, value) {
+                if (isBuiltInModifier(key)) {
+                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
+                    return false;
+                }
+                else {
+                    target[key] = value;
+                    return true;
+                }
+            },
+        });
+    }
 }
 
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
+const seenObjects = new _Set();
+/**
+ * Recursively traverse an object to evoke all converted
+ * getters, so that every nested property inside the object
+ * is collected as a "deep" dependency.
+ */
+function traverse(val) {
+    _traverse(val, seenObjects);
+    seenObjects.clear();
+}
+function _traverse(val, seen) {
+    let i, keys;
+    const isA = Array.isArray(val);
+    if ((!isA && !isObject(val)) ||
+        Object.isFrozen(val) ||
+        val instanceof VNode) {
+        return;
+    }
+    if (val.__ob__) {
+        const depId = val.__ob__.dep.id;
+        if (seen.has(depId)) {
+            return;
+        }
+        seen.add(depId);
+    }
+    if (isA) {
+        i = val.length;
+        while (i--)
+            _traverse(val[i], seen);
+    }
+    else {
+        keys = Object.keys(val);
+        i = keys.length;
+        while (i--)
+            _traverse(val[keys[i]], seen);
+    }
 }
 
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
+const normalizeEvent = cached((name) => {
+    const passive = name.charAt(0) === '&';
+    name = passive ? name.slice(1) : name;
+    const once = name.charAt(0) === '~'; // Prefixed last, checked first
+    name = once ? name.slice(1) : name;
+    const capture = name.charAt(0) === '!';
+    name = capture ? name.slice(1) : name;
+    return {
+        name,
+        once,
+        capture,
+        passive,
+    };
+});
+function createFnInvoker(fns, vm) {
+    function invoker() {
+        const fns = invoker.fns;
+        if (Array.isArray(fns)) {
+            const cloned = fns.slice();
+            for (let i = 0; i < cloned.length; i++) {
+                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
+            }
+        }
+        else {
+            // return handler return value for single handlers
+            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
+        }
+    }
+    invoker.fns = fns;
+    return invoker;
+}
+function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
+    let name, cur, old, event;
+    for (name in on) {
+        cur = on[name];
+        old = oldOn[name];
+        event = normalizeEvent(name);
+        if (isUndef(cur)) {
+            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
+        }
+        else if (isUndef(old)) {
+            if (isUndef(cur.fns)) {
+                cur = on[name] = createFnInvoker(cur, vm);
+            }
+            if (isTrue(event.once)) {
+                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
+            }
+            add(event.name, cur, event.capture, event.passive, event.params);
+        }
+        else if (cur !== old) {
+            old.fns = cur;
+            on[name] = old;
+        }
+    }
+    for (name in oldOn) {
+        if (isUndef(on[name])) {
+            event = normalizeEvent(name);
+            remove(event.name, oldOn[name], event.capture);
+        }
+    }
 }
 
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
+function extractPropsFromVNodeData(data, Ctor, tag) {
+    // we are only extracting raw values here.
+    // validation and default values are handled in the child
+    // component itself.
+    const propOptions = Ctor.options.props;
+    if (isUndef(propOptions)) {
+        return;
+    }
+    const res = {};
+    const { attrs, props } = data;
+    if (isDef(attrs) || isDef(props)) {
+        for (const key in propOptions) {
+            const altKey = hyphenate(key);
+            {
+                const keyInLowerCase = key.toLowerCase();
+                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
+                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
+                        `${formatComponentName(
+                        // @ts-expect-error tag is string
+                        tag || Ctor)}, but the declared prop name is` +
+                        ` "${key}". ` +
+                        `Note that HTML attributes are case-insensitive and camelCased ` +
+                        `props need to use their kebab-case equivalents when using in-DOM ` +
+                        `templates. You should probably use "${altKey}" instead of "${key}".`);
+                }
+            }
+            checkProp(res, props, key, altKey, true) ||
+                checkProp(res, attrs, key, altKey, false);
+        }
+    }
+    return res;
+}
+function checkProp(res, hash, key, altKey, preserve) {
+    if (isDef(hash)) {
+        if (hasOwn(hash, key)) {
+            res[key] = hash[key];
+            if (!preserve) {
+                delete hash[key];
+            }
+            return true;
+        }
+        else if (hasOwn(hash, altKey)) {
+            res[key] = hash[altKey];
+            if (!preserve) {
+                delete hash[altKey];
+            }
+            return true;
+        }
+    }
+    return false;
 }
 
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
+const SIMPLE_NORMALIZE = 1;
+const ALWAYS_NORMALIZE = 2;
+// wrapper function for providing a more flexible interface
+// without getting yelled at by flow
+function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
+    if (Array.isArray(data) || isPrimitive(data)) {
+        normalizationType = children;
+        children = data;
+        data = undefined;
+    }
+    if (isTrue(alwaysNormalize)) {
+        normalizationType = ALWAYS_NORMALIZE;
+    }
+    return _createElement(context, tag, data, children, normalizationType);
+}
+function _createElement(context, tag, data, children, normalizationType) {
+    if (isDef(data) && isDef(data.__ob__)) {
+        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
+        return createEmptyVNode();
+    }
+    // object syntax in v-bind
+    if (isDef(data) && isDef(data.is)) {
+        tag = data.is;
+    }
+    if (!tag) {
+        // in case of component :is set to falsy value
+        return createEmptyVNode();
+    }
+    // warn against non-primitive key
+    if (isDef(data) &&
+        isDef(data.key) &&
+        !isPrimitive(data.key)) {
+        // @ts-expect-error
+        {
+            warn$2('Avoid using non-primitive value as key, ' +
+                'use string/number value instead.', context);
+        }
+    }
+    // support single function children as default scoped slot
+    if (Array.isArray(children) && typeof children[0] === 'function') {
+        data = data || {};
+        data.scopedSlots = { default: children[0] };
+        children.length = 0;
+    }
+    if (normalizationType === ALWAYS_NORMALIZE) {
+        children = normalizeChildren(children);
+    }
+    else if (normalizationType === SIMPLE_NORMALIZE) {
+        children = simpleNormalizeChildren(children);
+    }
+    let vnode, ns;
+    if (typeof tag === 'string') {
+        let Ctor;
+        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
+        if ((!data || !data.pre) &&
+            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
+            // component
+            vnode = createComponent(Ctor, data, context, children, tag);
+        }
+        else {
+            // unknown or unlisted namespaced elements
+            // check at runtime because it may get assigned a namespace when its
+            // parent normalizes children
+            vnode = new VNode(tag, data, children, undefined, undefined, context);
+        }
+    }
+    else {
+        // direct component options / constructor
+        vnode = createComponent(tag, data, context, children);
+    }
+    if (Array.isArray(vnode)) {
+        return vnode;
+    }
+    else if (isDef(vnode)) {
+        if (isDef(ns))
+            applyNS(vnode, ns);
+        if (isDef(data))
+            registerDeepBindings(data);
+        return vnode;
+    }
+    else {
+        return createEmptyVNode();
+    }
+}
+function applyNS(vnode, ns, force) {
+    vnode.ns = ns;
+    if (vnode.tag === 'foreignObject') {
+        // use default namespace inside foreignObject
+        ns = undefined;
+        force = true;
+    }
+    if (isDef(vnode.children)) {
+        for (let i = 0, l = vnode.children.length; i < l; i++) {
+            const child = vnode.children[i];
+            if (isDef(child.tag) &&
+                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+                applyNS(child, ns, force);
+            }
+        }
+    }
+}
+// ref #5318
+// necessary to ensure parent re-render when deep bindings like :style and
+// :class are used on slot nodes
+function registerDeepBindings(data) {
+    if (isObject(data.style)) {
+        traverse(data.style);
+    }
+    if (isObject(data.class)) {
+        traverse(data.class);
+    }
 }
 
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
+/**
+ * Runtime helper for rendering v-for lists.
+ */
+function renderList(val, render) {
+    let ret = null, i, l, keys, key;
+    if (Array.isArray(val) || typeof val === 'string') {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = render(val[i], i);
+        }
+    }
+    else if (typeof val === 'number') {
+        ret = new Array(val);
+        for (i = 0; i < val; i++) {
+            ret[i] = render(i + 1, i);
+        }
+    }
+    else if (isObject(val)) {
+        if (hasSymbol && val[Symbol.iterator]) {
+            ret = [];
+            const iterator = val[Symbol.iterator]();
+            let result = iterator.next();
+            while (!result.done) {
+                ret.push(render(result.value, ret.length));
+                result = iterator.next();
+            }
+        }
+        else {
+            keys = Object.keys(val);
+            ret = new Array(keys.length);
+            for (i = 0, l = keys.length; i < l; i++) {
+                key = keys[i];
+                ret[i] = render(val[key], key, i);
+            }
+        }
+    }
+    if (!isDef(ret)) {
+        ret = [];
+    }
+    ret._isVList = true;
+    return ret;
 }
 
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
+/**
+ * Runtime helper for rendering <slot>
+ */
+function renderSlot(name, fallbackRender, props, bindObject) {
+    const scopedSlotFn = this.$scopedSlots[name];
+    let nodes;
+    if (scopedSlotFn) {
+        // scoped slot
+        props = props || {};
+        if (bindObject) {
+            if (!isObject(bindObject)) {
+                warn$2("slot v-bind without argument expects an Object", this);
+            }
+            props = extend(extend({}, bindObject), props);
+        }
+        nodes =
+            scopedSlotFn(props) ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    else {
+        nodes =
+            this.$slots[name] ||
+                (typeof fallbackRender === "function"
+                    ? fallbackRender()
+                    : fallbackRender);
+    }
+    const target = props && props.slot;
+    if (target) {
+        return this.$createElement("template", { slot: target }, nodes);
+    }
+    else {
+        return nodes;
+    }
 }
 
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
+/**
+ * Runtime helper for resolving filters
+ */
+function resolveFilter(id) {
+    return resolveAsset(this.$options, 'filters', id, true) || identity;
 }
 
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
+function isKeyNotMatch(expect, actual) {
+    if (Array.isArray(expect)) {
+        return expect.indexOf(actual) === -1;
+    }
+    else {
+        return expect !== actual;
+    }
+}
+/**
+ * Runtime helper for checking keyCodes from config.
+ * exposed as Vue.prototype._k
+ * passing in eventKeyName as last argument separately for backwards compat
+ */
+function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
+    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
+    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
+        return isKeyNotMatch(builtInKeyName, eventKeyName);
+    }
+    else if (mappedKeyCode) {
+        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
+    }
+    else if (eventKeyName) {
+        return hyphenate(eventKeyName) !== key;
+    }
+    return eventKeyCode === undefined;
 }
 
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
+/**
+ * Runtime helper for merging v-bind="object" into a VNode's data.
+ */
+function bindObjectProps(data, tag, value, asProp, isSync) {
+    if (value) {
+        if (!isObject(value)) {
+            warn$2('v-bind without argument expects an Object or Array value', this);
+        }
+        else {
+            if (Array.isArray(value)) {
+                value = toObject(value);
+            }
+            let hash;
+            for (const key in value) {
+                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
+                    hash = data;
+                }
+                else {
+                    const type = data.attrs && data.attrs.type;
+                    hash =
+                        asProp || config.mustUseProp(tag, type, key)
+                            ? data.domProps || (data.domProps = {})
+                            : data.attrs || (data.attrs = {});
+                }
+                const camelizedKey = camelize(key);
+                const hyphenatedKey = hyphenate(key);
+                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
+                    hash[key] = value[key];
+                    if (isSync) {
+                        const on = data.on || (data.on = {});
+                        on[`update:${key}`] = function ($event) {
+                            value[key] = $event;
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return data;
 }
 
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
+/**
+ * Runtime helper for rendering static trees.
+ */
+function renderStatic(index, isInFor) {
+    const cached = this._staticTrees || (this._staticTrees = []);
+    let tree = cached[index];
+    // if has already-rendered static tree and not inside v-for,
+    // we can reuse the same tree.
+    if (tree && !isInFor) {
+        return tree;
+    }
+    // otherwise, render a fresh tree.
+    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+    );
+    markStatic(tree, `__static__${index}`, false);
+    return tree;
+}
+/**
+ * Runtime helper for v-once.
+ * Effectively it means marking the node as static with a unique key.
+ */
+function markOnce(tree, index, key) {
+    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
+    return tree;
+}
+function markStatic(tree, key, isOnce) {
+    if (Array.isArray(tree)) {
+        for (let i = 0; i < tree.length; i++) {
+            if (tree[i] && typeof tree[i] !== 'string') {
+                markStaticNode(tree[i], `${key}_${i}`, isOnce);
+            }
+        }
+    }
+    else {
+        markStaticNode(tree, key, isOnce);
+    }
+}
+function markStaticNode(node, key, isOnce) {
+    node.isStatic = true;
+    node.key = key;
+    node.isOnce = isOnce;
 }
 
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
+function bindObjectListeners(data, value) {
+    if (value) {
+        if (!isPlainObject(value)) {
+            warn$2('v-on without argument expects an Object value', this);
+        }
+        else {
+            const on = (data.on = data.on ? extend({}, data.on) : {});
+            for (const key in value) {
+                const existing = on[key];
+                const ours = value[key];
+                on[key] = existing ? [].concat(existing, ours) : ours;
+            }
+        }
+    }
+    return data;
 }
 
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
+function resolveScopedSlots(fns, res, 
+// the following are added in 2.6
+hasDynamicKeys, contentHashKey) {
+    res = res || { $stable: !hasDynamicKeys };
+    for (let i = 0; i < fns.length; i++) {
+        const slot = fns[i];
+        if (Array.isArray(slot)) {
+            resolveScopedSlots(slot, res, hasDynamicKeys);
+        }
+        else if (slot) {
+            // marker for reverse proxying v-slot without scope on this.$slots
+            // @ts-expect-error
+            if (slot.proxy) {
+                // @ts-expect-error
+                slot.fn.proxy = true;
+            }
+            res[slot.key] = slot.fn;
+        }
+    }
+    if (contentHashKey) {
+        res.$key = contentHashKey;
+    }
+    return res;
 }
 
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
+// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
+function bindDynamicKeys(baseObj, values) {
+    for (let i = 0; i < values.length; i += 2) {
+        const key = values[i];
+        if (typeof key === 'string' && key) {
+            baseObj[values[i]] = values[i + 1];
+        }
+        else if (key !== '' &&
+            key !== null) {
+            // null is a special value for explicitly removing a binding
+            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
+        }
+    }
+    return baseObj;
+}
+// helper to dynamically append modifier runtime markers to event names.
+// ensure only append when value is already string, otherwise it will be cast
+// to string and cause the type check to miss.
+function prependModifier(value, symbol) {
+    return typeof value === 'string' ? symbol + value : value;
 }
 
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
+function installRenderHelpers(target) {
+    target._o = markOnce;
+    target._n = toNumber;
+    target._s = toString;
+    target._l = renderList;
+    target._t = renderSlot;
+    target._q = looseEqual;
+    target._i = looseIndexOf;
+    target._m = renderStatic;
+    target._f = resolveFilter;
+    target._k = checkKeyCodes;
+    target._b = bindObjectProps;
+    target._v = createTextVNode;
+    target._e = createEmptyVNode;
+    target._u = resolveScopedSlots;
+    target._g = bindObjectListeners;
+    target._d = bindDynamicKeys;
+    target._p = prependModifier;
 }
 
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
+/**
+ * Runtime helper for resolving raw children VNodes into a slot object.
+ */
+function resolveSlots(children, context) {
+    if (!children || !children.length) {
+        return {};
+    }
+    const slots = {};
+    for (let i = 0, l = children.length; i < l; i++) {
+        const child = children[i];
+        const data = child.data;
+        // remove slot attribute if the node is resolved as a Vue slot node
+        if (data && data.attrs && data.attrs.slot) {
+            delete data.attrs.slot;
+        }
+        // named slots should only be respected if the vnode was rendered in the
+        // same context.
+        if ((child.context === context || child.fnContext === context) &&
+            data &&
+            data.slot != null) {
+            const name = data.slot;
+            const slot = slots[name] || (slots[name] = []);
+            if (child.tag === 'template') {
+                slot.push.apply(slot, child.children || []);
+            }
+            else {
+                slot.push(child);
+            }
+        }
+        else {
+            (slots.default || (slots.default = [])).push(child);
+        }
+    }
+    // ignore slots that contains only whitespace
+    for (const name in slots) {
+        if (slots[name].every(isWhitespace)) {
+            delete slots[name];
+        }
+    }
+    return slots;
+}
+function isWhitespace(node) {
+    return (node.isComment && !node.asyncFactory) || node.text === ' ';
 }
 
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
+function isAsyncPlaceholder(node) {
+    // @ts-expect-error not really boolean type
+    return node.isComment && node.asyncFactory;
 }
 
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
+function normalizeScopedSlots(slots, normalSlots, prevSlots) {
+    let res;
+    const hasNormalSlots = Object.keys(normalSlots).length > 0;
+    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
+    const key = slots && slots.$key;
+    if (!slots) {
+        res = {};
+    }
+    else if (slots._normalized) {
+        // fast path 1: child component re-render only, parent did not change
+        return slots._normalized;
+    }
+    else if (isStable &&
+        prevSlots &&
+        prevSlots !== emptyObject &&
+        key === prevSlots.$key &&
+        !hasNormalSlots &&
+        !prevSlots.$hasNormal) {
+        // fast path 2: stable scoped slots w/ no normal slots to proxy,
+        // only need to normalize once
+        return prevSlots;
+    }
+    else {
+        res = {};
+        for (const key in slots) {
+            if (slots[key] && key[0] !== "$") {
+                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+            }
+        }
+    }
+    // expose normal slots on scopedSlots
+    for (const key in normalSlots) {
+        if (!(key in res)) {
+            res[key] = proxyNormalSlot(normalSlots, key);
+        }
+    }
+    // avoriaz seems to mock a non-extensible $scopedSlots object
+    // and when that is passed down this would cause an error
+    if (slots && Object.isExtensible(slots)) {
+        slots._normalized = res;
+    }
+    def(res, "$stable", isStable);
+    def(res, "$key", key);
+    def(res, "$hasNormal", hasNormalSlots);
+    return res;
+}
+function normalizeScopedSlot(normalSlots, key, fn) {
+    const normalized = function () {
+        let res = arguments.length ? fn.apply(null, arguments) : fn({});
+        res =
+            res && typeof res === "object" && !Array.isArray(res)
+                ? [res] // single vnode
+                : normalizeChildren(res);
+        const vnode = res && res[0];
+        return res &&
+            (!vnode ||
+                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
+            ? undefined
+            : res;
+    };
+    // this is a slot using the new v-slot syntax without scope. although it is
+    // compiled as a scoped slot, render fn users would expect it to be present
+    // on this.$slots because the usage is semantically a normal slot.
+    if (fn.proxy) {
+        Object.defineProperty(normalSlots, key, {
+            get: normalized,
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return normalized;
+}
+function proxyNormalSlot(slots, key) {
+    return () => slots[key];
 }
 
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
+function createAsyncPlaceholder(factory, data, context, children, tag) {
+    const node = createEmptyVNode();
+    node.asyncFactory = factory;
+    node.asyncMeta = { data, context, children, tag };
+    return node;
+}
+function resolveAsyncComponent(factory, baseCtor) {
+    if (isTrue(factory.error) && isDef(factory.errorComp)) {
+        return factory.errorComp;
+    }
+    if (isDef(factory.resolved)) {
+        return factory.resolved;
+    }
+    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
+        return factory.loadingComp;
+    }
 }
 
-let target;
-function add(event, fn) {
-    target.$on(event, fn);
-}
-function remove(event, fn) {
-    target.$off(event, fn);
-}
-function createOnceHandler(event, fn) {
-    const _target = target;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
-    target = undefined;
+let target;
+function add(event, fn) {
+    target.$on(event, fn);
+}
+function remove(event, fn) {
+    target.$off(event, fn);
+}
+function createOnceHandler(event, fn) {
+    const _target = target;
+    return function onceHandler() {
+        const res = fn.apply(null, arguments);
+        if (res !== null) {
+            _target.$off(event, onceHandler);
+        }
+    };
+}
+function updateComponentListeners(vm, listeners, oldListeners) {
+    target = vm;
+    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
+    target = undefined;
 }
 
-let activeInstance = null;
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook(vm, "deactivated");
-    }
-}
-function callHook(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
+let activeInstance = null;
+function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
+    // determine whether component has slot children
+    // we need to do this before overwriting $options._renderChildren.
+    // check if there are dynamic scopedSlots (hand-written or compiled but with
+    // dynamic slot names). Static scoped slots compiled from template has the
+    // "$stable" marker.
+    const newScopedSlots = parentVnode.data.scopedSlots;
+    const oldScopedSlots = vm.$scopedSlots;
+    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
+        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
+        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
+        (!newScopedSlots && vm.$scopedSlots.$key));
+    // Any static slot children from the parent may have changed during parent's
+    // update. Dynamic scoped slots may also have changed. In such cases, a forced
+    // update is necessary to ensure correctness.
+    const needsForceUpdate = !!(renderChildren || // has new static slots
+        vm.$options._renderChildren || // has old static slots
+        hasDynamicScopedSlot);
+    vm.$options._parentVnode = parentVnode;
+    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+    if (vm._vnode) {
+        // update child tree's parent
+        vm._vnode.parent = parentVnode;
+    }
+    vm.$options._renderChildren = renderChildren;
+    // update $attrs and $listeners hash
+    // these are also reactive so they may trigger child update if the child
+    // used them during render
+    vm.$attrs = parentVnode.data.attrs || emptyObject;
+    vm.$listeners = listeners || emptyObject;
+    // update props
+    if (propsData && vm.$options.props) {
+        toggleObserving(false);
+        const props = vm._props;
+        const propKeys = vm.$options._propKeys || [];
+        for (let i = 0; i < propKeys.length; i++) {
+            const key = propKeys[i];
+            const propOptions = vm.$options.props; // wtf flow?
+            props[key] = validateProp(key, propOptions, propsData, vm);
+        }
+        toggleObserving(true);
+        // keep a copy of raw propsData
+        vm.$options.propsData = propsData;
+    }
+    // update listeners
+    listeners = listeners || emptyObject;
+    const oldListeners = vm.$options._parentListeners;
+    vm.$options._parentListeners = listeners;
+    updateComponentListeners(vm, listeners, oldListeners);
+    // resolve slots + force update if has children
+    if (needsForceUpdate) {
+        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
+        vm.$forceUpdate();
+    }
+}
+function isInInactiveTree(vm) {
+    while (vm && (vm = vm.$parent)) {
+        if (vm._inactive)
+            return true;
+    }
+    return false;
+}
+function activateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = false;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    else if (vm._directInactive) {
+        return;
+    }
+    if (vm._inactive || vm._inactive === null) {
+        vm._inactive = false;
+        for (let i = 0; i < vm.$children.length; i++) {
+            activateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, "activated");
+    }
+}
+function deactivateChildComponent(vm, direct) {
+    if (direct) {
+        vm._directInactive = true;
+        if (isInInactiveTree(vm)) {
+            return;
+        }
+    }
+    if (!vm._inactive) {
+        vm._inactive = true;
+        for (let i = 0; i < vm.$children.length; i++) {
+            deactivateChildComponent(vm.$children[i]);
+        }
+        callHook(vm, "deactivated");
+    }
+}
+function callHook(vm, hook) {
+    // #7573 disable dep collection when invoking lifecycle hooks
+    pushTarget();
+    const handlers = vm.$options[hook];
+    const info = `${hook} hook`;
+    if (handlers) {
+        for (let i = 0, j = handlers.length; i < j; i++) {
+            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+        }
+    }
+    if (vm._hasHookEvent) {
+        vm.$emit("hook:" + hook);
+    }
+    popTarget();
 }
 
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
+// Async edge case fix requires storing an event listener's attach timestamp.
+let getNow = Date.now;
+// Determine what event timestamp the browser is using. Annoyingly, the
+// timestamp can either be hi-res (relative to page load) or low-res
+// (relative to UNIX epoch), so in order to compare time we have to use the
+// same timestamp type when saving the flush timestamp.
+// All IE versions use low-res event timestamps, and have problematic clock
+// implementations (#9632)
+if (inBrowser && !isIE) {
+    const performance = window.performance;
+    if (performance &&
+        typeof performance.now === 'function' &&
+        getNow() > document.createEvent('Event').timeStamp) {
+        // if the event timestamp, although evaluated AFTER the Date.now(), is
+        // smaller than it, it means the event is using a hi-res timestamp,
+        // and we need to use the hi-res version for event listener timestamps as
+        // well.
+        getNow = () => performance.now();
+    }
+}
+/**
+ * Queue a kept-alive component that was activated during patch.
+ * The queue will be processed after the entire tree has been patched.
+ */
+function queueActivatedComponent(vm) {
+    // setting _inactive to false here so that a render function can
+    // rely on checking whether it's in an inactive tree (e.g. router-view)
+    vm._inactive = false;
 }
 
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
+function resolveInject(inject, vm) {
+    if (inject) {
+        // inject is :any because flow is not smart enough to figure out cached
+        const result = Object.create(null);
+        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            // #6574 in case the inject object is observed...
+            if (key === '__ob__')
+                continue;
+            const provideKey = inject[key].from;
+            let source = vm;
+            while (source) {
+                if (source._provided && hasOwn(source._provided, provideKey)) {
+                    result[key] = source._provided[provideKey];
+                    break;
+                }
+                // @ts-expect-error
+                source = source.$parent;
+            }
+            if (!source) {
+                if ('default' in inject[key]) {
+                    const provideDefault = inject[key].default;
+                    result[key] =
+                        typeof provideDefault === 'function'
+                            ? provideDefault.call(vm)
+                            : provideDefault;
+                }
+                else {
+                    warn$2(`Injection "${key}" not found`, vm);
+                }
+            }
+        }
+        return result;
+    }
 }
 
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
+function resolveConstructorOptions(Ctor) {
+    let options = Ctor.options;
+    if (Ctor.super) {
+        const superOptions = resolveConstructorOptions(Ctor.super);
+        const cachedSuperOptions = Ctor.superOptions;
+        if (superOptions !== cachedSuperOptions) {
+            // super option changed,
+            // need to resolve new options.
+            Ctor.superOptions = superOptions;
+            // check if there are any late-modified/attached options (#4976)
+            const modifiedOptions = resolveModifiedOptions(Ctor);
+            // update base extend options
+            if (modifiedOptions) {
+                extend(Ctor.extendOptions, modifiedOptions);
+            }
+            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
+            if (options.name) {
+                options.components[options.name] = Ctor;
+            }
+        }
+    }
+    return options;
+}
+function resolveModifiedOptions(Ctor) {
+    let modified;
+    const latest = Ctor.options;
+    const sealed = Ctor.sealedOptions;
+    for (const key in latest) {
+        if (latest[key] !== sealed[key]) {
+            if (!modified)
+                modified = {};
+            modified[key] = latest[key];
+        }
+    }
+    return modified;
 }
 
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
+function FunctionalRenderContext(data, props, children, parent, Ctor) {
+    const options = Ctor.options;
+    // ensure the createElement function in functional components
+    // gets a unique context - this is necessary for correct named slot check
+    let contextVm;
+    if (hasOwn(parent, '_uid')) {
+        contextVm = Object.create(parent);
+        // $flow-disable-line
+        contextVm._original = parent;
+    }
+    else {
+        // the context vm passed in is a functional context as well.
+        // in this case we want to make sure we are able to get a hold to the
+        // real context instance.
+        contextVm = parent;
+        // $flow-disable-line
+        parent = parent._original;
+    }
+    const isCompiled = isTrue(options._compiled);
+    const needNormalization = !isCompiled;
+    this.data = data;
+    this.props = props;
+    this.children = children;
+    this.parent = parent;
+    this.listeners = data.on || emptyObject;
+    this.injections = resolveInject(options.inject, parent);
+    this.slots = () => {
+        if (!this.$slots) {
+            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
+        }
+        return this.$slots;
+    };
+    Object.defineProperty(this, 'scopedSlots', {
+        enumerable: true,
+        get() {
+            return normalizeScopedSlots(data.scopedSlots, this.slots());
+        },
+    });
+    // support for compiled functional template
+    if (isCompiled) {
+        // exposing $options for renderStatic()
+        this.$options = options;
+        // pre-resolve slots for renderSlot()
+        this.$slots = this.slots();
+        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
+    }
+    if (options._scopeId) {
+        this._c = (a, b, c, d) => {
+            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
+            if (vnode && !Array.isArray(vnode)) {
+                vnode.fnScopeId = options._scopeId;
+                vnode.fnContext = parent;
+            }
+            return vnode;
+        };
+    }
+    else {
+        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
+    }
+}
+installRenderHelpers(FunctionalRenderContext.prototype);
+function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
+    const options = Ctor.options;
+    const props = {};
+    const propOptions = options.props;
+    if (isDef(propOptions)) {
+        for (const key in propOptions) {
+            props[key] = validateProp(key, propOptions, propsData || emptyObject);
+        }
+    }
+    else {
+        if (isDef(data.attrs))
+            mergeProps(props, data.attrs);
+        if (isDef(data.props))
+            mergeProps(props, data.props);
+    }
+    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
+    const vnode = options.render.call(null, renderContext._c, renderContext);
+    if (vnode instanceof VNode) {
+        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
+    }
+    else if (Array.isArray(vnode)) {
+        const vnodes = normalizeChildren(vnode) || [];
+        const res = new Array(vnodes.length);
+        for (let i = 0; i < vnodes.length; i++) {
+            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
+        }
+        return res;
+    }
+}
+function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
+    // #7817 clone node before setting fnContext, otherwise if the node is reused
+    // (e.g. it was from a cached normal slot) the fnContext causes named slots
+    // that should not be matched to match.
+    const clone = cloneVNode(vnode);
+    clone.fnContext = contextVm;
+    clone.fnOptions = options;
+    {
+        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
+    }
+    if (data.slot) {
+        (clone.data || (clone.data = {})).slot = data.slot;
+    }
+    return clone;
+}
+function mergeProps(to, from) {
+    for (const key in from) {
+        to[camelize(key)] = from[key];
+    }
 }
 
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
+// inline hooks to be invoked on component VNodes during patch
+const componentVNodeHooks = {
+    init(vnode, hydrating) {
+        if (vnode.componentInstance &&
+            !vnode.componentInstance._isDestroyed &&
+            vnode.data.keepAlive) {
+            // kept-alive components, treat as a patch
+            const mountedNode = vnode; // work around flow
+            componentVNodeHooks.prepatch(mountedNode, mountedNode);
+        }
+        else {
+            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
+            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
+        }
+    },
+    prepatch(oldVnode, vnode) {
+        const options = vnode.componentOptions;
+        const child = (vnode.componentInstance = oldVnode.componentInstance);
+        updateChildComponent(child, options.propsData, // updated props
+        options.listeners, // updated listeners
+        vnode, // new parent vnode
+        options.children // new children
+        );
+    },
+    insert(vnode) {
+        const { context, componentInstance } = vnode;
+        if (!componentInstance._isMounted) {
+            componentInstance._isMounted = true;
+            callHook(componentInstance, 'mounted');
+        }
+        if (vnode.data.keepAlive) {
+            if (context._isMounted) {
+                // vue-router#1212
+                // During updates, a kept-alive component's child components may
+                // change, so directly walking the tree here may call activated hooks
+                // on incorrect children. Instead we push them into a queue which will
+                // be processed after the whole patch process ended.
+                queueActivatedComponent(componentInstance);
+            }
+            else {
+                activateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+    destroy(vnode) {
+        const { componentInstance } = vnode;
+        if (!componentInstance._isDestroyed) {
+            if (!vnode.data.keepAlive) {
+                componentInstance.$destroy();
+            }
+            else {
+                deactivateChildComponent(componentInstance, true /* direct */);
+            }
+        }
+    },
+};
+const hooksToMerge = Object.keys(componentVNodeHooks);
+function createComponent(Ctor, data, context, children, tag) {
+    if (isUndef(Ctor)) {
+        return;
+    }
+    const baseCtor = context.$options._base;
+    // plain options object: turn it into a constructor
+    if (isObject(Ctor)) {
+        Ctor = baseCtor.extend(Ctor);
+    }
+    // if at this stage it's not a constructor or an async component factory,
+    // reject.
+    if (typeof Ctor !== 'function') {
+        {
+            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
+        }
+        return;
+    }
+    // async component
+    let asyncFactory;
+    // @ts-expect-error
+    if (isUndef(Ctor.cid)) {
+        asyncFactory = Ctor;
+        Ctor = resolveAsyncComponent(asyncFactory);
+        if (Ctor === undefined) {
+            // return a placeholder node for async component, which is rendered
+            // as a comment node but preserves all the raw information for the node.
+            // the information will be used for async server-rendering and hydration.
+            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
+        }
+    }
+    data = data || {};
+    // resolve constructor options in case global mixins are applied after
+    // component constructor creation
+    resolveConstructorOptions(Ctor);
+    // transform component v-model data into props & events
+    if (isDef(data.model)) {
+        // @ts-expect-error
+        transformModel(Ctor.options, data);
+    }
+    // extract props
+    // @ts-expect-error
+    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
+    // functional component
+    // @ts-expect-error
+    if (isTrue(Ctor.options.functional)) {
+        return createFunctionalComponent(Ctor, propsData, data, context, children);
+    }
+    // extract listeners, since these needs to be treated as
+    // child component listeners instead of DOM listeners
+    const listeners = data.on;
+    // replace with listeners with .native modifier
+    // so it gets processed during parent component patch.
+    data.on = data.nativeOn;
+    // @ts-expect-error
+    if (isTrue(Ctor.options.abstract)) {
+        // abstract components do not keep anything
+        // other than props & listeners & slot
+        // work around flow
+        const slot = data.slot;
+        data = {};
+        if (slot) {
+            data.slot = slot;
+        }
+    }
+    // install component management hooks onto the placeholder node
+    installComponentHooks(data);
+    // return a placeholder vnode
+    // @ts-expect-error
+    const name = Ctor.options.name || tag;
+    const vnode = new VNode(
+    // @ts-expect-error
+    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
+    // @ts-expect-error
+    { Ctor, propsData, listeners, tag, children }, asyncFactory);
+    return vnode;
+}
+function createComponentInstanceForVnode(
+// we know it's MountedComponentVNode but flow doesn't
+vnode, 
+// activeInstance in lifecycle state
+parent) {
+    const options = {
+        _isComponent: true,
+        _parentVnode: vnode,
+        parent,
+    };
+    // check inline-template render functions
+    const inlineTemplate = vnode.data.inlineTemplate;
+    if (isDef(inlineTemplate)) {
+        options.render = inlineTemplate.render;
+        options.staticRenderFns = inlineTemplate.staticRenderFns;
+    }
+    return new vnode.componentOptions.Ctor(options);
+}
+function installComponentHooks(data) {
+    const hooks = data.hook || (data.hook = {});
+    for (let i = 0; i < hooksToMerge.length; i++) {
+        const key = hooksToMerge[i];
+        const existing = hooks[key];
+        const toMerge = componentVNodeHooks[key];
+        // @ts-expect-error
+        if (existing !== toMerge && !(existing && existing._merged)) {
+            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
+        }
+    }
+}
+function mergeHook(f1, f2) {
+    const merged = (a, b) => {
+        // flow complains about extra args which is why we use any
+        f1(a, b);
+        f2(a, b);
+    };
+    merged._merged = true;
+    return merged;
+}
+// transform component v-model info (value and callback) into
+// prop and event handler respectively.
+function transformModel(options, data) {
+    const prop = (options.model && options.model.prop) || 'value';
+    const event = (options.model && options.model.event) || 'input';
+    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
+    const on = data.on || (data.on = {});
+    const existing = on[event];
+    const callback = data.model.callback;
+    if (isDef(existing)) {
+        if (Array.isArray(existing)
+            ? existing.indexOf(callback) === -1
+            : existing !== callback) {
+            on[event] = [callback].concat(existing);
+        }
+    }
+    else {
+        on[event] = callback;
+    }
 }
 
-let warned = Object.create(null);
-const warnOnce = (msg) => {
-    if (!warned[msg]) {
-        warned[msg] = true;
-        // eslint-disable-next-line no-console
-        console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
-    }
-};
-const onCompilationError = (err, vm) => {
-    const trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
-};
-const normalizeRender = (vm) => {
-    const { render, template, _scopeId } = vm.$options;
-    if (isUndef(render)) {
-        if (template) {
-            const compiled = compileToFunctions(template, {
-                scopeId: _scopeId,
-                warn: onCompilationError,
-            }, vm);
-            vm.$options.render = compiled.render;
-            vm.$options.staticRenderFns = compiled.staticRenderFns;
-        }
-        else {
-            throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
-        }
-    }
-};
-function waitForServerPrefetch(vm, resolve, reject) {
-    let handlers = vm.$options.serverPrefetch;
-    if (isDef(handlers)) {
-        if (!Array.isArray(handlers))
-            handlers = [handlers];
-        try {
-            const promises = [];
-            for (let i = 0, j = handlers.length; i < j; i++) {
-                const result = handlers[i].call(vm, vm);
-                if (result && typeof result.then === 'function') {
-                    promises.push(result);
-                }
-            }
-            Promise.all(promises).then(resolve).catch(reject);
-            return;
-        }
-        catch (e) {
-            reject(e);
-        }
-    }
-    resolve();
-}
-function renderNode(node, isRoot, context) {
-    if (node.isString) {
-        renderStringNode(node, context);
-    }
-    else if (isDef(node.componentOptions)) {
-        renderComponent(node, isRoot, context);
-    }
-    else if (isDef(node.tag)) {
-        renderElement(node, isRoot, context);
-    }
-    else if (isTrue(node.isComment)) {
-        if (isDef(node.asyncFactory)) {
-            // async component
-            renderAsyncComponent(node, isRoot, context);
-        }
-        else {
-            context.write(`<!--${node.text}-->`, context.next);
-        }
-    }
-    else {
-        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
-    }
-}
-function registerComponentForCache(options, write) {
-    // exposed by vue-loader, need to call this if cache hit because
-    // component lifecycle hooks will not be called.
-    const register = options._ssrRegister;
-    if (write.caching && isDef(register)) {
-        write.componentBuffer[write.componentBuffer.length - 1].add(register);
-    }
-    return register;
-}
-function renderComponent(node, isRoot, context) {
-    const { write, next, userContext } = context;
-    // check cache hit
-    const Ctor = node.componentOptions.Ctor;
-    const getKey = Ctor.options.serverCacheKey;
-    const name = Ctor.options.name;
-    const cache = context.cache;
-    const registerComponent = registerComponentForCache(Ctor.options, write);
-    if (isDef(getKey) && isDef(cache) && isDef(name)) {
-        const rawKey = getKey(node.componentOptions.propsData);
-        if (rawKey === false) {
-            renderComponentInner(node, isRoot, context);
-            return;
-        }
-        const key = name + '::' + rawKey;
-        const { has, get } = context;
-        if (isDef(has)) {
-            has(key, (hit) => {
-                if (hit === true && isDef(get)) {
-                    get(key, (res) => {
-                        if (isDef(registerComponent)) {
-                            registerComponent(userContext);
-                        }
-                        res.components.forEach((register) => register(userContext));
-                        write(res.html, next);
-                    });
-                }
-                else {
-                    renderComponentWithCache(node, isRoot, key, context);
-                }
-            });
-        }
-        else if (isDef(get)) {
-            get(key, (res) => {
-                if (isDef(res)) {
-                    if (isDef(registerComponent)) {
-                        registerComponent(userContext);
-                    }
-                    res.components.forEach((register) => register(userContext));
-                    write(res.html, next);
-                }
-                else {
-                    renderComponentWithCache(node, isRoot, key, context);
-                }
-            });
-        }
-    }
-    else {
-        if (isDef(getKey) && isUndef(cache)) {
-            warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
-                'but no cache was provided to the renderer.');
-        }
-        if (isDef(getKey) && isUndef(name)) {
-            warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
-                `must also define a unique "name" option.`);
-        }
-        renderComponentInner(node, isRoot, context);
-    }
-}
-function renderComponentWithCache(node, isRoot, key, context) {
-    const write = context.write;
-    write.caching = true;
-    const buffer = write.cacheBuffer;
-    const bufferIndex = buffer.push('') - 1;
-    const componentBuffer = write.componentBuffer;
-    componentBuffer.push(new Set());
-    context.renderStates.push({
-        type: 'ComponentWithCache',
-        key,
-        buffer,
-        bufferIndex,
-        componentBuffer,
-    });
-    renderComponentInner(node, isRoot, context);
-}
-function renderComponentInner(node, isRoot, context) {
-    const prevActive = context.activeInstance;
-    // expose userContext on vnode
-    node.ssrContext = context.userContext;
-    const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
-    normalizeRender(child);
-    const resolve = () => {
-        const childNode = child._render();
-        childNode.parent = node;
-        context.renderStates.push({
-            type: 'Component',
-            prevActive,
-        });
-        renderNode(childNode, isRoot, context);
-    };
-    const reject = context.done;
-    waitForServerPrefetch(child, resolve, reject);
-}
-function renderAsyncComponent(node, isRoot, context) {
-    const factory = node.asyncFactory;
-    const resolve = (comp) => {
-        if (comp.__esModule && comp.default) {
-            comp = comp.default;
-        }
-        const { data, children, tag } = node.asyncMeta;
-        const nodeContext = node.asyncMeta.context;
-        const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
-        if (resolvedNode) {
-            if (resolvedNode.componentOptions) {
-                // normal component
-                renderComponent(resolvedNode, isRoot, context);
-            }
-            else if (!Array.isArray(resolvedNode)) {
-                // single return node from functional component
-                renderNode(resolvedNode, isRoot, context);
-            }
-            else {
-                // multiple return nodes from functional component
-                context.renderStates.push({
-                    type: 'Fragment',
-                    children: resolvedNode,
-                    rendered: 0,
-                    total: resolvedNode.length,
-                });
-                context.next();
-            }
-        }
-        else {
-            // invalid component, but this does not throw on the client
-            // so render empty comment node
-            context.write(`<!---->`, context.next);
-        }
-    };
-    if (factory.resolved) {
-        resolve(factory.resolved);
-        return;
-    }
-    const reject = context.done;
-    let res;
-    try {
-        res = factory(resolve, reject);
-    }
-    catch (e) {
-        reject(e);
-    }
-    if (res) {
-        if (typeof res.then === 'function') {
-            res.then(resolve, reject).catch(reject);
-        }
-        else {
-            // new syntax in 2.3
-            const comp = res.component;
-            if (comp && typeof comp.then === 'function') {
-                comp.then(resolve, reject).catch(reject);
-            }
-        }
-    }
-}
-function renderStringNode(el, context) {
-    const { write, next } = context;
-    if (isUndef(el.children) || el.children.length === 0) {
-        write(el.open + (el.close || ''), next);
-    }
-    else {
-        const children = el.children;
-        context.renderStates.push({
-            type: 'Element',
-            children,
-            rendered: 0,
-            total: children.length,
-            endTag: el.close,
-        });
-        write(el.open, next);
-    }
-}
-function renderElement(el, isRoot, context) {
-    const { write, next } = context;
-    if (isTrue(isRoot)) {
-        if (!el.data)
-            el.data = {};
-        if (!el.data.attrs)
-            el.data.attrs = {};
-        el.data.attrs[SSR_ATTR] = 'true';
-    }
-    if (el.fnOptions) {
-        registerComponentForCache(el.fnOptions, write);
-    }
-    const startTag = renderStartingTag(el, context);
-    const endTag = `</${el.tag}>`;
-    if (context.isUnaryTag(el.tag)) {
-        write(startTag, next);
-    }
-    else if (isUndef(el.children) || el.children.length === 0) {
-        write(startTag + endTag, next);
-    }
-    else {
-        const children = el.children;
-        context.renderStates.push({
-            type: 'Element',
-            children,
-            rendered: 0,
-            total: children.length,
-            endTag,
-        });
-        write(startTag, next);
-    }
-}
-function hasAncestorData(node) {
-    const parentNode = node.parent;
-    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
-}
-function getVShowDirectiveInfo(node) {
-    let dir;
-    let tmp;
-    while (isDef(node)) {
-        if (node.data && node.data.directives) {
-            tmp = node.data.directives.find((dir) => dir.name === 'show');
-            if (tmp) {
-                dir = tmp;
-            }
-        }
-        node = node.parent;
-    }
-    //@ts-expect-error
-    return dir;
-}
-function renderStartingTag(node, context) {
-    let markup = `<${node.tag}`;
-    const { directives, modules } = context;
-    // construct synthetic data for module processing
-    // because modules like style also produce code by parent VNode data
-    if (isUndef(node.data) && hasAncestorData(node)) {
-        node.data = {};
-    }
-    if (isDef(node.data)) {
-        // check directives
-        const dirs = node.data.directives;
-        if (dirs) {
-            for (let i = 0; i < dirs.length; i++) {
-                const name = dirs[i].name;
-                if (name !== 'show') {
-                    const dirRenderer = resolveAsset(context, 'directives', name);
-                    if (dirRenderer) {
-                        // directives mutate the node's data
-                        // which then gets rendered by modules
-                        dirRenderer(node, dirs[i]);
-                    }
-                }
-            }
-        }
-        // v-show directive needs to be merged from parent to child
-        const vshowDirectiveInfo = getVShowDirectiveInfo(node);
-        if (vshowDirectiveInfo) {
-            directives.show(node, vshowDirectiveInfo);
-        }
-        // apply other modules
-        for (let i = 0; i < modules.length; i++) {
-            const res = modules[i](node);
-            if (res) {
-                markup += res;
-            }
-        }
-    }
-    // attach scoped CSS ID
-    let scopeId;
-    const activeInstance = context.activeInstance;
-    if (isDef(activeInstance) &&
-        activeInstance !== node.context &&
-        isDef((scopeId = activeInstance.$options._scopeId))) {
-        markup += ` ${scopeId}`;
-    }
-    if (isDef(node.fnScopeId)) {
-        markup += ` ${node.fnScopeId}`;
-    }
-    else {
-        while (isDef(node)) {
-            //@ts-expect-error
-            if (isDef((scopeId = node.context.$options._scopeId))) {
-                markup += ` ${scopeId}`;
-            }
-            node = node.parent;
-        }
-    }
-    return markup + '>';
-}
-function createRenderFunction(modules, directives, isUnaryTag, cache) {
-    return function render(component, write, userContext, done) {
-        warned = Object.create(null);
-        const context = new RenderContext({
-            activeInstance: component,
-            userContext,
-            write,
-            done,
-            renderNode,
-            isUnaryTag,
-            modules,
-            directives,
-            cache,
-        });
-        installSSRHelpers(component);
-        normalizeRender(component);
-        const resolve = () => {
-            renderNode(component._render(), true, context);
-        };
-        waitForServerPrefetch(component, resolve, done);
-    };
+let warned = Object.create(null);
+const warnOnce = (msg) => {
+    if (!warned[msg]) {
+        warned[msg] = true;
+        // eslint-disable-next-line no-console
+        console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
+    }
+};
+const onCompilationError = (err, vm) => {
+    const trace = vm ? generateComponentTrace(vm) : '';
+    throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
+};
+const normalizeRender = (vm) => {
+    const { render, template, _scopeId } = vm.$options;
+    if (isUndef(render)) {
+        if (template) {
+            const compiled = compileToFunctions(template, {
+                scopeId: _scopeId,
+                warn: onCompilationError,
+            }, vm);
+            vm.$options.render = compiled.render;
+            vm.$options.staticRenderFns = compiled.staticRenderFns;
+        }
+        else {
+            throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
+        }
+    }
+};
+function waitForServerPrefetch(vm, resolve, reject) {
+    let handlers = vm.$options.serverPrefetch;
+    if (isDef(handlers)) {
+        if (!Array.isArray(handlers))
+            handlers = [handlers];
+        try {
+            const promises = [];
+            for (let i = 0, j = handlers.length; i < j; i++) {
+                const result = handlers[i].call(vm, vm);
+                if (result && typeof result.then === 'function') {
+                    promises.push(result);
+                }
+            }
+            Promise.all(promises).then(resolve).catch(reject);
+            return;
+        }
+        catch (e) {
+            reject(e);
+        }
+    }
+    resolve();
+}
+function renderNode(node, isRoot, context) {
+    if (node.isString) {
+        renderStringNode(node, context);
+    }
+    else if (isDef(node.componentOptions)) {
+        renderComponent(node, isRoot, context);
+    }
+    else if (isDef(node.tag)) {
+        renderElement(node, isRoot, context);
+    }
+    else if (isTrue(node.isComment)) {
+        if (isDef(node.asyncFactory)) {
+            // async component
+            renderAsyncComponent(node, isRoot, context);
+        }
+        else {
+            context.write(`<!--${node.text}-->`, context.next);
+        }
+    }
+    else {
+        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
+    }
+}
+function registerComponentForCache(options, write) {
+    // exposed by vue-loader, need to call this if cache hit because
+    // component lifecycle hooks will not be called.
+    const register = options._ssrRegister;
+    if (write.caching && isDef(register)) {
+        write.componentBuffer[write.componentBuffer.length - 1].add(register);
+    }
+    return register;
+}
+function renderComponent(node, isRoot, context) {
+    const { write, next, userContext } = context;
+    // check cache hit
+    const Ctor = node.componentOptions.Ctor;
+    const getKey = Ctor.options.serverCacheKey;
+    const name = Ctor.options.name;
+    const cache = context.cache;
+    const registerComponent = registerComponentForCache(Ctor.options, write);
+    if (isDef(getKey) && isDef(cache) && isDef(name)) {
+        const rawKey = getKey(node.componentOptions.propsData);
+        if (rawKey === false) {
+            renderComponentInner(node, isRoot, context);
+            return;
+        }
+        const key = name + '::' + rawKey;
+        const { has, get } = context;
+        if (isDef(has)) {
+            has(key, (hit) => {
+                if (hit === true && isDef(get)) {
+                    get(key, (res) => {
+                        if (isDef(registerComponent)) {
+                            registerComponent(userContext);
+                        }
+                        res.components.forEach((register) => register(userContext));
+                        write(res.html, next);
+                    });
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+        else if (isDef(get)) {
+            get(key, (res) => {
+                if (isDef(res)) {
+                    if (isDef(registerComponent)) {
+                        registerComponent(userContext);
+                    }
+                    res.components.forEach((register) => register(userContext));
+                    write(res.html, next);
+                }
+                else {
+                    renderComponentWithCache(node, isRoot, key, context);
+                }
+            });
+        }
+    }
+    else {
+        if (isDef(getKey) && isUndef(cache)) {
+            warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
+                'but no cache was provided to the renderer.');
+        }
+        if (isDef(getKey) && isUndef(name)) {
+            warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
+                `must also define a unique "name" option.`);
+        }
+        renderComponentInner(node, isRoot, context);
+    }
+}
+function renderComponentWithCache(node, isRoot, key, context) {
+    const write = context.write;
+    write.caching = true;
+    const buffer = write.cacheBuffer;
+    const bufferIndex = buffer.push('') - 1;
+    const componentBuffer = write.componentBuffer;
+    componentBuffer.push(new Set());
+    context.renderStates.push({
+        type: 'ComponentWithCache',
+        key,
+        buffer,
+        bufferIndex,
+        componentBuffer,
+    });
+    renderComponentInner(node, isRoot, context);
+}
+function renderComponentInner(node, isRoot, context) {
+    const prevActive = context.activeInstance;
+    // expose userContext on vnode
+    node.ssrContext = context.userContext;
+    const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
+    normalizeRender(child);
+    const resolve = () => {
+        const childNode = child._render();
+        childNode.parent = node;
+        context.renderStates.push({
+            type: 'Component',
+            prevActive,
+        });
+        renderNode(childNode, isRoot, context);
+    };
+    const reject = context.done;
+    waitForServerPrefetch(child, resolve, reject);
+}
+function renderAsyncComponent(node, isRoot, context) {
+    const factory = node.asyncFactory;
+    const resolve = (comp) => {
+        if (comp.__esModule && comp.default) {
+            comp = comp.default;
+        }
+        const { data, children, tag } = node.asyncMeta;
+        const nodeContext = node.asyncMeta.context;
+        const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
+        if (resolvedNode) {
+            if (resolvedNode.componentOptions) {
+                // normal component
+                renderComponent(resolvedNode, isRoot, context);
+            }
+            else if (!Array.isArray(resolvedNode)) {
+                // single return node from functional component
+                renderNode(resolvedNode, isRoot, context);
+            }
+            else {
+                // multiple return nodes from functional component
+                context.renderStates.push({
+                    type: 'Fragment',
+                    children: resolvedNode,
+                    rendered: 0,
+                    total: resolvedNode.length,
+                });
+                context.next();
+            }
+        }
+        else {
+            // invalid component, but this does not throw on the client
+            // so render empty comment node
+            context.write(`<!---->`, context.next);
+        }
+    };
+    if (factory.resolved) {
+        resolve(factory.resolved);
+        return;
+    }
+    const reject = context.done;
+    let res;
+    try {
+        res = factory(resolve, reject);
+    }
+    catch (e) {
+        reject(e);
+    }
+    if (res) {
+        if (typeof res.then === 'function') {
+            res.then(resolve, reject).catch(reject);
+        }
+        else {
+            // new syntax in 2.3
+            const comp = res.component;
+            if (comp && typeof comp.then === 'function') {
+                comp.then(resolve, reject).catch(reject);
+            }
+        }
+    }
+}
+function renderStringNode(el, context) {
+    const { write, next } = context;
+    if (isUndef(el.children) || el.children.length === 0) {
+        write(el.open + (el.close || ''), next);
+    }
+    else {
+        const children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children,
+            rendered: 0,
+            total: children.length,
+            endTag: el.close,
+        });
+        write(el.open, next);
+    }
+}
+function renderElement(el, isRoot, context) {
+    const { write, next } = context;
+    if (isTrue(isRoot)) {
+        if (!el.data)
+            el.data = {};
+        if (!el.data.attrs)
+            el.data.attrs = {};
+        el.data.attrs[SSR_ATTR] = 'true';
+    }
+    if (el.fnOptions) {
+        registerComponentForCache(el.fnOptions, write);
+    }
+    const startTag = renderStartingTag(el, context);
+    const endTag = `</${el.tag}>`;
+    if (context.isUnaryTag(el.tag)) {
+        write(startTag, next);
+    }
+    else if (isUndef(el.children) || el.children.length === 0) {
+        write(startTag + endTag, next);
+    }
+    else {
+        const children = el.children;
+        context.renderStates.push({
+            type: 'Element',
+            children,
+            rendered: 0,
+            total: children.length,
+            endTag,
+        });
+        write(startTag, next);
+    }
+}
+function hasAncestorData(node) {
+    const parentNode = node.parent;
+    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
+}
+function getVShowDirectiveInfo(node) {
+    let dir;
+    let tmp;
+    while (isDef(node)) {
+        if (node.data && node.data.directives) {
+            tmp = node.data.directives.find((dir) => dir.name === 'show');
+            if (tmp) {
+                dir = tmp;
+            }
+        }
+        node = node.parent;
+    }
+    //@ts-expect-error
+    return dir;
+}
+function renderStartingTag(node, context) {
+    let markup = `<${node.tag}`;
+    const { directives, modules } = context;
+    // construct synthetic data for module processing
+    // because modules like style also produce code by parent VNode data
+    if (isUndef(node.data) && hasAncestorData(node)) {
+        node.data = {};
+    }
+    if (isDef(node.data)) {
+        // check directives
+        const dirs = node.data.directives;
+        if (dirs) {
+            for (let i = 0; i < dirs.length; i++) {
+                const name = dirs[i].name;
+                if (name !== 'show') {
+                    const dirRenderer = resolveAsset(context, 'directives', name);
+                    if (dirRenderer) {
+                        // directives mutate the node's data
+                        // which then gets rendered by modules
+                        dirRenderer(node, dirs[i]);
+                    }
+                }
+            }
+        }
+        // v-show directive needs to be merged from parent to child
+        const vshowDirectiveInfo = getVShowDirectiveInfo(node);
+        if (vshowDirectiveInfo) {
+            directives.show(node, vshowDirectiveInfo);
+        }
+        // apply other modules
+        for (let i = 0; i < modules.length; i++) {
+            const res = modules[i](node);
+            if (res) {
+                markup += res;
+            }
+        }
+    }
+    // attach scoped CSS ID
+    let scopeId;
+    const activeInstance = context.activeInstance;
+    if (isDef(activeInstance) &&
+        activeInstance !== node.context &&
+        isDef((scopeId = activeInstance.$options._scopeId))) {
+        markup += ` ${scopeId}`;
+    }
+    if (isDef(node.fnScopeId)) {
+        markup += ` ${node.fnScopeId}`;
+    }
+    else {
+        while (isDef(node)) {
+            //@ts-expect-error
+            if (isDef((scopeId = node.context.$options._scopeId))) {
+                markup += ` ${scopeId}`;
+            }
+            node = node.parent;
+        }
+    }
+    return markup + '>';
+}
+function createRenderFunction(modules, directives, isUnaryTag, cache) {
+    return function render(component, write, userContext, done) {
+        warned = Object.create(null);
+        const context = new RenderContext({
+            activeInstance: component,
+            userContext,
+            write,
+            done,
+            renderNode,
+            isUnaryTag,
+            modules,
+            directives,
+            cache,
+        });
+        installSSRHelpers(component);
+        normalizeRender(component);
+        const resolve = () => {
+            renderNode(component._render(), true, context);
+        };
+        waitForServerPrefetch(component, resolve, done);
+    };
 }
 
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
-const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
-function createPromiseCallback() {
-    let resolve, reject;
-    const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
-    const cb = (err, res) => {
-        if (err)
-            return reject(err);
-        resolve(res || '');
-    };
-    return { promise, cb };
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
+function createPromiseCallback() {
+    let resolve, reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    const cb = (err, res) => {
+        if (err)
+            return reject(err);
+        resolve(res || '');
+    };
+    return { promise, cb };
 }
 
-class TemplateStream extends stream.Transform {
-    started;
-    renderer;
-    template;
-    context;
-    inject;
-    constructor(renderer, template, context) {
-        super();
-        this.started = false;
-        this.renderer = renderer;
-        this.template = template;
-        this.context = context || {};
-        this.inject = renderer.inject;
-    }
-    _transform(data, encoding, done) {
-        if (!this.started) {
-            this.emit('beforeStart');
-            this.start();
-        }
-        this.push(data);
-        done();
-    }
-    start() {
-        this.started = true;
-        this.push(this.template.head(this.context));
-        if (this.inject) {
-            // inline server-rendered head meta information
-            if (this.context.head) {
-                this.push(this.context.head);
-            }
-            // inline preload/prefetch directives for initial/async chunks
-            const links = this.renderer.renderResourceHints(this.context);
-            if (links) {
-                this.push(links);
-            }
-            // CSS files and inline server-rendered CSS collected by vue-style-loader
-            const styles = this.renderer.renderStyles(this.context);
-            if (styles) {
-                this.push(styles);
-            }
-        }
-        this.push(this.template.neck(this.context));
-    }
-    _flush(done) {
-        this.emit('beforeEnd');
-        if (this.inject) {
-            // inline initial store state
-            const state = this.renderer.renderState(this.context);
-            if (state) {
-                this.push(state);
-            }
-            // embed scripts needed
-            const scripts = this.renderer.renderScripts(this.context);
-            if (scripts) {
-                this.push(scripts);
-            }
-        }
-        this.push(this.template.tail(this.context));
-        done();
-    }
+class TemplateStream extends stream.Transform {
+    started;
+    renderer;
+    template;
+    context;
+    inject;
+    constructor(renderer, template, context) {
+        super();
+        this.started = false;
+        this.renderer = renderer;
+        this.template = template;
+        this.context = context || {};
+        this.inject = renderer.inject;
+    }
+    _transform(data, encoding, done) {
+        if (!this.started) {
+            this.emit('beforeStart');
+            this.start();
+        }
+        this.push(data);
+        done();
+    }
+    start() {
+        this.started = true;
+        this.push(this.template.head(this.context));
+        if (this.inject) {
+            // inline server-rendered head meta information
+            if (this.context.head) {
+                this.push(this.context.head);
+            }
+            // inline preload/prefetch directives for initial/async chunks
+            const links = this.renderer.renderResourceHints(this.context);
+            if (links) {
+                this.push(links);
+            }
+            // CSS files and inline server-rendered CSS collected by vue-style-loader
+            const styles = this.renderer.renderStyles(this.context);
+            if (styles) {
+                this.push(styles);
+            }
+        }
+        this.push(this.template.neck(this.context));
+    }
+    _flush(done) {
+        this.emit('beforeEnd');
+        if (this.inject) {
+            // inline initial store state
+            const state = this.renderer.renderState(this.context);
+            if (state) {
+                this.push(state);
+            }
+            // embed scripts needed
+            const scripts = this.renderer.renderScripts(this.context);
+            if (scripts) {
+                this.push(scripts);
+            }
+        }
+        this.push(this.template.tail(this.context));
+        done();
+    }
 }
 
-const compile = require('lodash.template');
-const compileOptions = {
-    escape: /{{([^{][\s\S]+?[^}])}}/g,
-    interpolate: /{{{([\s\S]+?)}}}/g,
-};
-function parseTemplate(template, contentPlaceholder = '<!--vue-ssr-outlet-->') {
-    if (typeof template === 'object') {
-        return template;
-    }
-    let i = template.indexOf('</head>');
-    const j = template.indexOf(contentPlaceholder);
-    if (j < 0) {
-        throw new Error(`Content placeholder not found in template.`);
-    }
-    if (i < 0) {
-        i = template.indexOf('<body>');
-        if (i < 0) {
-            i = j;
-        }
-    }
-    return {
-        head: compile(template.slice(0, i), compileOptions),
-        neck: compile(template.slice(i, j), compileOptions),
-        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
-    };
+const compile = require('lodash.template');
+const compileOptions = {
+    escape: /{{([^{][\s\S]+?[^}])}}/g,
+    interpolate: /{{{([\s\S]+?)}}}/g,
+};
+function parseTemplate(template, contentPlaceholder = '<!--vue-ssr-outlet-->') {
+    if (typeof template === 'object') {
+        return template;
+    }
+    let i = template.indexOf('</head>');
+    const j = template.indexOf(contentPlaceholder);
+    if (j < 0) {
+        throw new Error(`Content placeholder not found in template.`);
+    }
+    if (i < 0) {
+        i = template.indexOf('<body>');
+        if (i < 0) {
+            i = j;
+        }
+    }
+    return {
+        head: compile(template.slice(0, i), compileOptions),
+        neck: compile(template.slice(i, j), compileOptions),
+        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
+    };
 }
 
-/**
- * Creates a mapper that maps components used during a server-side render
- * to async chunk files in the client-side build, so that we can inline them
- * directly in the rendered HTML to avoid waterfall requests.
- */
-function createMapper(clientManifest) {
-    const map = createMap(clientManifest);
-    // map server-side moduleIds to client-side files
-    return function mapper(moduleIds) {
-        const res = new Set();
-        for (let i = 0; i < moduleIds.length; i++) {
-            const mapped = map.get(moduleIds[i]);
-            if (mapped) {
-                for (let j = 0; j < mapped.length; j++) {
-                    res.add(mapped[j]);
-                }
-            }
-        }
-        return Array.from(res);
-    };
-}
-function createMap(clientManifest) {
-    const map = new Map();
-    Object.keys(clientManifest.modules).forEach((id) => {
-        map.set(id, mapIdToFile(id, clientManifest));
-    });
-    return map;
-}
-function mapIdToFile(id, clientManifest) {
-    const files = [];
-    const fileIndices = clientManifest.modules[id];
-    if (fileIndices) {
-        fileIndices.forEach((index) => {
-            const file = clientManifest.all[index];
-            // only include async files or non-js, non-css assets
-            if (file &&
-                (clientManifest.async.indexOf(file) > -1 ||
-                    !/\.(js|css)($|\?)/.test(file))) {
-                files.push(file);
-            }
-        });
-    }
-    return files;
+/**
+ * Creates a mapper that maps components used during a server-side render
+ * to async chunk files in the client-side build, so that we can inline them
+ * directly in the rendered HTML to avoid waterfall requests.
+ */
+function createMapper(clientManifest) {
+    const map = createMap(clientManifest);
+    // map server-side moduleIds to client-side files
+    return function mapper(moduleIds) {
+        const res = new Set();
+        for (let i = 0; i < moduleIds.length; i++) {
+            const mapped = map.get(moduleIds[i]);
+            if (mapped) {
+                for (let j = 0; j < mapped.length; j++) {
+                    res.add(mapped[j]);
+                }
+            }
+        }
+        return Array.from(res);
+    };
+}
+function createMap(clientManifest) {
+    const map = new Map();
+    Object.keys(clientManifest.modules).forEach((id) => {
+        map.set(id, mapIdToFile(id, clientManifest));
+    });
+    return map;
+}
+function mapIdToFile(id, clientManifest) {
+    const files = [];
+    const fileIndices = clientManifest.modules[id];
+    if (fileIndices) {
+        fileIndices.forEach((index) => {
+            const file = clientManifest.all[index];
+            // only include async files or non-js, non-css assets
+            if (file &&
+                (clientManifest.async.indexOf(file) > -1 ||
+                    !/\.(js|css)($|\?)/.test(file))) {
+                files.push(file);
+            }
+        });
+    }
+    return files;
 }
 
-const path$2 = require('path');
-const serialize = require('serialize-javascript');
-class TemplateRenderer {
-    options;
-    inject;
-    parsedTemplate;
-    //@ts-expect-error
-    publicPath;
-    //@ts-expect-error
-    clientManifest;
-    //@ts-expect-error
-    preloadFiles;
-    //@ts-expect-error
-    prefetchFiles;
-    //@ts-expect-error
-    mapFiles;
-    serialize;
-    constructor(options) {
-        this.options = options;
-        this.inject = options.inject !== false;
-        // if no template option is provided, the renderer is created
-        // as a utility object for rendering assets like preload links and scripts.
-        const { template } = options;
-        this.parsedTemplate = template
-            ? typeof template === 'string'
-                ? parseTemplate(template)
-                : template
-            : null;
-        // function used to serialize initial state JSON
-        this.serialize =
-            options.serializer ||
-                ((state) => {
-                    return serialize(state, { isJSON: true });
-                });
-        // extra functionality with client manifest
-        if (options.clientManifest) {
-            const clientManifest = (this.clientManifest = options.clientManifest);
-            // ensure publicPath ends with /
-            this.publicPath =
-                clientManifest.publicPath === ''
-                    ? ''
-                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-            // preload/prefetch directives
-            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-            // initial async chunk mapping
-            this.mapFiles = createMapper(clientManifest);
-        }
-    }
-    bindRenderFns(context) {
-        const renderer = this;
-        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
-            context[`render${type}`] = renderer[`render${type}`].bind(renderer, context);
-        });
-        // also expose getPreloadFiles, useful for HTTP/2 push
-        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
-    }
-    // render synchronously given rendered app content and render context
-    render(content, context) {
-        const template = this.parsedTemplate;
-        if (!template) {
-            throw new Error('render cannot be called without a template.');
-        }
-        context = context || {};
-        if (typeof template === 'function') {
-            return template(content, context);
-        }
-        if (this.inject) {
-            return (template.head(context) +
-                (context.head || '') +
-                this.renderResourceHints(context) +
-                this.renderStyles(context) +
-                template.neck(context) +
-                content +
-                this.renderState(context) +
-                this.renderScripts(context) +
-                template.tail(context));
-        }
-        else {
-            return (template.head(context) +
-                template.neck(context) +
-                content +
-                template.tail(context));
-        }
-    }
-    renderStyles(context) {
-        const initial = this.preloadFiles || [];
-        const async = this.getUsedAsyncFiles(context) || [];
-        const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file));
-        return (
-        // render links for css files
-        (cssFiles.length
-            ? cssFiles
-                .map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`)
-                .join('')
-            : '') +
-            // context.styles is a getter exposed by vue-style-loader which contains
-            // the inline component styles collected during SSR
-            (context.styles || ''));
-    }
-    renderResourceHints(context) {
-        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
-    }
-    getPreloadFiles(context) {
-        const usedAsyncFiles = this.getUsedAsyncFiles(context);
-        if (this.preloadFiles || usedAsyncFiles) {
-            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
-        }
-        else {
-            return [];
-        }
-    }
-    renderPreloadLinks(context) {
-        const files = this.getPreloadFiles(context);
-        const shouldPreload = this.options.shouldPreload;
-        if (files.length) {
-            return files
-                .map(({ file, extension, fileWithoutQuery, asType }) => {
-                let extra = '';
-                // by default, we only preload scripts or css
-                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-                    return '';
-                }
-                // user wants to explicitly control what to preload
-                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (asType === 'font') {
-                    extra = ` type="font/${extension}" crossorigin`;
-                }
-                return `<link rel="preload" href="${this.publicPath}${file}"${asType !== '' ? ` as="${asType}"` : ''}${extra}>`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    renderPrefetchLinks(context) {
-        const shouldPrefetch = this.options.shouldPrefetch;
-        if (this.prefetchFiles) {
-            const usedAsyncFiles = this.getUsedAsyncFiles(context);
-            const alreadyRendered = (file) => {
-                return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file);
-            };
-            return this.prefetchFiles
-                .map(({ file, fileWithoutQuery, asType }) => {
-                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (alreadyRendered(file)) {
-                    return '';
-                }
-                return `<link rel="prefetch" href="${this.publicPath}${file}">`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    renderState(context, options) {
-        const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } = options || {};
-        const state = this.serialize(context[contextKey]);
-        const autoRemove = '';
-        const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : '';
-        return context[contextKey]
-            ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
-            : '';
-    }
-    renderScripts(context) {
-        if (this.clientManifest) {
-            const initial = this.preloadFiles.filter(({ file }) => isJS(file));
-            const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file));
-            const needed = [initial[0]].concat(async, initial.slice(1));
-            return needed
-                .map(({ file }) => {
-                return `<script src="${this.publicPath}${file}" defer></script>`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    getUsedAsyncFiles(context) {
-        if (!context._mappedFiles &&
-            context._registeredComponents &&
-            this.mapFiles) {
-            const registered = Array.from(context._registeredComponents);
-            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-        }
-        return context._mappedFiles;
-    }
-    // create a transform stream
-    createStream(context) {
-        if (!this.parsedTemplate) {
-            throw new Error('createStream cannot be called without a template.');
-        }
-        //@ts-expect-error
-        return new TemplateStream(this, this.parsedTemplate, context || {});
-    }
-}
-function normalizeFile(file) {
-    const withoutQuery = file.replace(/\?.*/, '');
-    const extension = path$2.extname(withoutQuery).slice(1);
-    return {
-        file,
-        extension,
-        fileWithoutQuery: withoutQuery,
-        asType: getPreloadType(extension),
-    };
-}
-function getPreloadType(ext) {
-    if (ext === 'js') {
-        return 'script';
-    }
-    else if (ext === 'css') {
-        return 'style';
-    }
-    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
-        return 'image';
-    }
-    else if (/woff2?|ttf|otf|eot/.test(ext)) {
-        return 'font';
-    }
-    else {
-        // not exhausting all possibilities here, but above covers common cases
-        return '';
-    }
+const path$2 = require('path');
+const serialize = require('serialize-javascript');
+class TemplateRenderer {
+    options;
+    inject;
+    parsedTemplate;
+    //@ts-expect-error
+    publicPath;
+    //@ts-expect-error
+    clientManifest;
+    //@ts-expect-error
+    preloadFiles;
+    //@ts-expect-error
+    prefetchFiles;
+    //@ts-expect-error
+    mapFiles;
+    serialize;
+    constructor(options) {
+        this.options = options;
+        this.inject = options.inject !== false;
+        // if no template option is provided, the renderer is created
+        // as a utility object for rendering assets like preload links and scripts.
+        const { template } = options;
+        this.parsedTemplate = template
+            ? typeof template === 'string'
+                ? parseTemplate(template)
+                : template
+            : null;
+        // function used to serialize initial state JSON
+        this.serialize =
+            options.serializer ||
+                ((state) => {
+                    return serialize(state, { isJSON: true });
+                });
+        // extra functionality with client manifest
+        if (options.clientManifest) {
+            const clientManifest = (this.clientManifest = options.clientManifest);
+            // ensure publicPath ends with /
+            this.publicPath =
+                clientManifest.publicPath === ''
+                    ? ''
+                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
+            // preload/prefetch directives
+            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
+            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
+            // initial async chunk mapping
+            this.mapFiles = createMapper(clientManifest);
+        }
+    }
+    bindRenderFns(context) {
+        const renderer = this;
+        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
+            context[`render${type}`] = renderer[`render${type}`].bind(renderer, context);
+        });
+        // also expose getPreloadFiles, useful for HTTP/2 push
+        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
+    }
+    // render synchronously given rendered app content and render context
+    render(content, context) {
+        const template = this.parsedTemplate;
+        if (!template) {
+            throw new Error('render cannot be called without a template.');
+        }
+        context = context || {};
+        if (typeof template === 'function') {
+            return template(content, context);
+        }
+        if (this.inject) {
+            return (template.head(context) +
+                (context.head || '') +
+                this.renderResourceHints(context) +
+                this.renderStyles(context) +
+                template.neck(context) +
+                content +
+                this.renderState(context) +
+                this.renderScripts(context) +
+                template.tail(context));
+        }
+        else {
+            return (template.head(context) +
+                template.neck(context) +
+                content +
+                template.tail(context));
+        }
+    }
+    renderStyles(context) {
+        const initial = this.preloadFiles || [];
+        const async = this.getUsedAsyncFiles(context) || [];
+        const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file));
+        return (
+        // render links for css files
+        (cssFiles.length
+            ? cssFiles
+                .map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`)
+                .join('')
+            : '') +
+            // context.styles is a getter exposed by vue-style-loader which contains
+            // the inline component styles collected during SSR
+            (context.styles || ''));
+    }
+    renderResourceHints(context) {
+        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
+    }
+    getPreloadFiles(context) {
+        const usedAsyncFiles = this.getUsedAsyncFiles(context);
+        if (this.preloadFiles || usedAsyncFiles) {
+            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
+        }
+        else {
+            return [];
+        }
+    }
+    renderPreloadLinks(context) {
+        const files = this.getPreloadFiles(context);
+        const shouldPreload = this.options.shouldPreload;
+        if (files.length) {
+            return files
+                .map(({ file, extension, fileWithoutQuery, asType }) => {
+                let extra = '';
+                // by default, we only preload scripts or css
+                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
+                    return '';
+                }
+                // user wants to explicitly control what to preload
+                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (asType === 'font') {
+                    extra = ` type="font/${extension}" crossorigin`;
+                }
+                return `<link rel="preload" href="${this.publicPath}${file}"${asType !== '' ? ` as="${asType}"` : ''}${extra}>`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    renderPrefetchLinks(context) {
+        const shouldPrefetch = this.options.shouldPrefetch;
+        if (this.prefetchFiles) {
+            const usedAsyncFiles = this.getUsedAsyncFiles(context);
+            const alreadyRendered = (file) => {
+                return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file);
+            };
+            return this.prefetchFiles
+                .map(({ file, fileWithoutQuery, asType }) => {
+                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
+                    return '';
+                }
+                if (alreadyRendered(file)) {
+                    return '';
+                }
+                return `<link rel="prefetch" href="${this.publicPath}${file}">`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    renderState(context, options) {
+        const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } = options || {};
+        const state = this.serialize(context[contextKey]);
+        const autoRemove = '';
+        const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : '';
+        return context[contextKey]
+            ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
+            : '';
+    }
+    renderScripts(context) {
+        if (this.clientManifest) {
+            const initial = this.preloadFiles.filter(({ file }) => isJS(file));
+            const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file));
+            const needed = [initial[0]].concat(async, initial.slice(1));
+            return needed
+                .map(({ file }) => {
+                return `<script src="${this.publicPath}${file}" defer></script>`;
+            })
+                .join('');
+        }
+        else {
+            return '';
+        }
+    }
+    getUsedAsyncFiles(context) {
+        if (!context._mappedFiles &&
+            context._registeredComponents &&
+            this.mapFiles) {
+            const registered = Array.from(context._registeredComponents);
+            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
+        }
+        return context._mappedFiles;
+    }
+    // create a transform stream
+    createStream(context) {
+        if (!this.parsedTemplate) {
+            throw new Error('createStream cannot be called without a template.');
+        }
+        //@ts-expect-error
+        return new TemplateStream(this, this.parsedTemplate, context || {});
+    }
+}
+function normalizeFile(file) {
+    const withoutQuery = file.replace(/\?.*/, '');
+    const extension = path$2.extname(withoutQuery).slice(1);
+    return {
+        file,
+        extension,
+        fileWithoutQuery: withoutQuery,
+        asType: getPreloadType(extension),
+    };
+}
+function getPreloadType(ext) {
+    if (ext === 'js') {
+        return 'script';
+    }
+    else if (ext === 'css') {
+        return 'style';
+    }
+    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
+        return 'image';
+    }
+    else if (/woff2?|ttf|otf|eot/.test(ext)) {
+        return 'font';
+    }
+    else {
+        // not exhausting all possibilities here, but above covers common cases
+        return '';
+    }
 }
 
-function createRenderer$1({ modules = [], directives = {}, isUnaryTag = () => false, template, inject, cache, shouldPreload, shouldPrefetch, clientManifest, serializer, } = {}) {
-    const render = createRenderFunction(modules, directives, isUnaryTag, cache);
-    const templateRenderer = new TemplateRenderer({
-        template,
-        inject,
-        // @ts-expect-error
-        shouldPreload,
-        // @ts-expect-error
-        shouldPrefetch,
-        clientManifest,
-        serializer,
-    });
-    return {
-        renderToString(component, context, cb) {
-            if (typeof context === 'function') {
-                cb = context;
-                context = {};
-            }
-            if (context) {
-                templateRenderer.bindRenderFns(context);
-            }
-            // no callback, return Promise
-            let promise;
-            if (!cb) {
-                ({ promise, cb } = createPromiseCallback());
-            }
-            let result = '';
-            const write = createWriteFunction((text) => {
-                result += text;
-                return false;
-            }, cb);
-            try {
-                // @ts-expect-error TODO improve
-                render(component, write, context, (err) => {
-                    if (err) {
-                        return cb(err);
-                    }
-                    if (context && context.rendered) {
-                        context.rendered(context);
-                    }
-                    if (template) {
-                        try {
-                            const res = templateRenderer.render(result, context);
-                            if (typeof res !== 'string') {
-                                // function template returning promise
-                                res.then((html) => cb(null, html)).catch(cb);
-                            }
-                            else {
-                                cb(null, res);
-                            }
-                        }
-                        catch (e) {
-                            cb(e);
-                        }
-                    }
-                    else {
-                        cb(null, result);
-                    }
-                });
-            }
-            catch (e) {
-                cb(e);
-            }
-            return promise;
-        },
-        renderToStream(component, context) {
-            if (context) {
-                templateRenderer.bindRenderFns(context);
-            }
-            const renderStream = new RenderStream((write, done) => {
-                // @ts-expect-error
-                render(component, write, context, done);
-            });
-            if (!template) {
-                // @ts-expect-error
-                if (context && context.rendered) {
-                    // @ts-expect-error
-                    const rendered = context.rendered;
-                    renderStream.once('beforeEnd', () => {
-                        rendered(context);
-                    });
-                }
-                return renderStream;
-            }
-            else if (typeof template === 'function') {
-                throw new Error(`function template is only supported in renderToString.`);
-            }
-            else {
-                const templateStream = templateRenderer.createStream(context);
-                renderStream.on('error', (err) => {
-                    templateStream.emit('error', err);
-                });
-                renderStream.pipe(templateStream);
-                //@ts-expect-error
-                if (context && context.rendered) {
-                    //@ts-expect-error
-                    const rendered = context.rendered;
-                    renderStream.once('beforeEnd', () => {
-                        rendered(context);
-                    });
-                }
-                return templateStream;
-            }
-        },
-    };
+function createRenderer$1({ modules = [], directives = {}, isUnaryTag = () => false, template, inject, cache, shouldPreload, shouldPrefetch, clientManifest, serializer, } = {}) {
+    const render = createRenderFunction(modules, directives, isUnaryTag, cache);
+    const templateRenderer = new TemplateRenderer({
+        template,
+        inject,
+        // @ts-expect-error
+        shouldPreload,
+        // @ts-expect-error
+        shouldPrefetch,
+        clientManifest,
+        serializer,
+    });
+    return {
+        renderToString(component, context, cb) {
+            if (typeof context === 'function') {
+                cb = context;
+                context = {};
+            }
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            // no callback, return Promise
+            let promise;
+            if (!cb) {
+                ({ promise, cb } = createPromiseCallback());
+            }
+            let result = '';
+            const write = createWriteFunction((text) => {
+                result += text;
+                return false;
+            }, cb);
+            try {
+                // @ts-expect-error TODO improve
+                render(component, write, context, (err) => {
+                    if (err) {
+                        return cb(err);
+                    }
+                    if (context && context.rendered) {
+                        context.rendered(context);
+                    }
+                    if (template) {
+                        try {
+                            const res = templateRenderer.render(result, context);
+                            if (typeof res !== 'string') {
+                                // function template returning promise
+                                res.then((html) => cb(null, html)).catch(cb);
+                            }
+                            else {
+                                cb(null, res);
+                            }
+                        }
+                        catch (e) {
+                            cb(e);
+                        }
+                    }
+                    else {
+                        cb(null, result);
+                    }
+                });
+            }
+            catch (e) {
+                cb(e);
+            }
+            return promise;
+        },
+        renderToStream(component, context) {
+            if (context) {
+                templateRenderer.bindRenderFns(context);
+            }
+            const renderStream = new RenderStream((write, done) => {
+                // @ts-expect-error
+                render(component, write, context, done);
+            });
+            if (!template) {
+                // @ts-expect-error
+                if (context && context.rendered) {
+                    // @ts-expect-error
+                    const rendered = context.rendered;
+                    renderStream.once('beforeEnd', () => {
+                        rendered(context);
+                    });
+                }
+                return renderStream;
+            }
+            else if (typeof template === 'function') {
+                throw new Error(`function template is only supported in renderToString.`);
+            }
+            else {
+                const templateStream = templateRenderer.createStream(context);
+                renderStream.on('error', (err) => {
+                    templateStream.emit('error', err);
+                });
+                renderStream.pipe(templateStream);
+                //@ts-expect-error
+                if (context && context.rendered) {
+                    //@ts-expect-error
+                    const rendered = context.rendered;
+                    renderStream.once('beforeEnd', () => {
+                        rendered(context);
+                    });
+                }
+                return templateStream;
+            }
+        },
+    };
 }
 
-const vm = require('vm');
-const path$1 = require('path');
-const resolve = require('resolve');
-const NativeModule = require('module');
-function createSandbox(context) {
-    const sandbox = {
-        Buffer,
-        console,
-        process,
-        setTimeout,
-        setInterval,
-        setImmediate,
-        clearTimeout,
-        clearInterval,
-        clearImmediate,
-        __VUE_SSR_CONTEXT__: context,
-    };
-    // @ts-expect-error
-    sandbox.global = sandbox;
-    return sandbox;
-}
-function compileModule(files, basedir, runInNewContext) {
-    const compiledScripts = {};
-    const resolvedModules = {};
-    function getCompiledScript(filename) {
-        if (compiledScripts[filename]) {
-            return compiledScripts[filename];
-        }
-        const code = files[filename];
-        const wrapper = NativeModule.wrap(code);
-        const script = new vm.Script(wrapper, {
-            filename,
-            displayErrors: true,
-        });
-        compiledScripts[filename] = script;
-        return script;
-    }
-    function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
-        if (evaluatedFiles[filename]) {
-            return evaluatedFiles[filename];
-        }
-        const script = getCompiledScript(filename);
-        const compiledWrapper = runInNewContext === false
-            ? script.runInThisContext()
-            : script.runInNewContext(sandbox);
-        const m = { exports: {} };
-        const r = (file) => {
-            file = path$1.posix.join('.', file);
-            if (files[file]) {
-                return evaluateModule(file, sandbox, evaluatedFiles);
-            }
-            else if (basedir) {
-                return require(resolvedModules[file] ||
-                    (resolvedModules[file] = resolve.sync(file, { basedir })));
-            }
-            else {
-                return require(file);
-            }
-        };
-        compiledWrapper.call(m.exports, m.exports, r, m);
-        const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-            ? // @ts-expect-error
-                m.exports.default
-            : m.exports;
-        evaluatedFiles[filename] = res;
-        return res;
-    }
-    return evaluateModule;
-}
-function deepClone(val) {
-    if (isPlainObject(val)) {
-        const res = {};
-        for (const key in val) {
-            res[key] = deepClone(val[key]);
-        }
-        return res;
-    }
-    else if (Array.isArray(val)) {
-        return val.slice();
-    }
-    else {
-        return val;
-    }
-}
-function createBundleRunner(entry, files, basedir, runInNewContext) {
-    const evaluate = compileModule(files, basedir, runInNewContext);
-    if (runInNewContext !== false && runInNewContext !== 'once') {
-        // new context mode: creates a fresh context and re-evaluate the bundle
-        // on each render. Ensures entire application state is fresh for each
-        // render, but incurs extra evaluation cost.
-        return (userContext = {}) => new Promise((resolve) => {
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            const res = evaluate(entry, createSandbox(userContext));
-            resolve(typeof res === 'function' ? res(userContext) : res);
-        });
-    }
-    else {
-        // direct mode: instead of re-evaluating the whole bundle on
-        // each render, it simply calls the exported function. This avoids the
-        // module evaluation costs but requires the source code to be structured
-        // slightly differently.
-        let runner; // lazy creation so that errors can be caught by user
-        let initialContext;
-        return (userContext = {}) => new Promise((resolve) => {
-            if (!runner) {
-                const sandbox = runInNewContext === 'once' ? createSandbox() : global;
-                // the initial context is only used for collecting possible non-component
-                // styles injected by vue-style-loader.
-                // @ts-expect-error
-                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
-                runner = evaluate(entry, sandbox);
-                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-                // to prevent cross-request pollution.
-                // @ts-expect-error
-                delete sandbox.__VUE_SSR_CONTEXT__;
-                if (typeof runner !== 'function') {
-                    throw new Error('bundle export should be a function when using ' +
-                        '{ runInNewContext: false }.');
-                }
-            }
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            // vue-style-loader styles imported outside of component lifecycle hooks
-            if (initialContext._styles) {
-                // @ts-expect-error
-                userContext._styles = deepClone(initialContext._styles);
-                // #6353 ensure "styles" is exposed even if no styles are injected
-                // in component lifecycles.
-                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-                const renderStyles = initialContext._renderStyles;
-                if (renderStyles) {
-                    Object.defineProperty(userContext, 'styles', {
-                        enumerable: true,
-                        get() {
-                            // @ts-expect-error
-                            return renderStyles(userContext._styles);
-                        },
-                    });
-                }
-            }
-            resolve(runner(userContext));
-        });
-    }
+const vm = require('vm');
+const path$1 = require('path');
+const resolve = require('resolve');
+const NativeModule = require('module');
+function createSandbox(context) {
+    const sandbox = {
+        Buffer,
+        console,
+        process,
+        setTimeout,
+        setInterval,
+        setImmediate,
+        clearTimeout,
+        clearInterval,
+        clearImmediate,
+        __VUE_SSR_CONTEXT__: context,
+    };
+    // @ts-expect-error
+    sandbox.global = sandbox;
+    return sandbox;
+}
+function compileModule(files, basedir, runInNewContext) {
+    const compiledScripts = {};
+    const resolvedModules = {};
+    function getCompiledScript(filename) {
+        if (compiledScripts[filename]) {
+            return compiledScripts[filename];
+        }
+        const code = files[filename];
+        const wrapper = NativeModule.wrap(code);
+        const script = new vm.Script(wrapper, {
+            filename,
+            displayErrors: true,
+        });
+        compiledScripts[filename] = script;
+        return script;
+    }
+    function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
+        if (evaluatedFiles[filename]) {
+            return evaluatedFiles[filename];
+        }
+        const script = getCompiledScript(filename);
+        const compiledWrapper = runInNewContext === false
+            ? script.runInThisContext()
+            : script.runInNewContext(sandbox);
+        const m = { exports: {} };
+        const r = (file) => {
+            file = path$1.posix.join('.', file);
+            if (files[file]) {
+                return evaluateModule(file, sandbox, evaluatedFiles);
+            }
+            else if (basedir) {
+                return require(resolvedModules[file] ||
+                    (resolvedModules[file] = resolve.sync(file, { basedir })));
+            }
+            else {
+                return require(file);
+            }
+        };
+        compiledWrapper.call(m.exports, m.exports, r, m);
+        const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
+            ? // @ts-expect-error
+                m.exports.default
+            : m.exports;
+        evaluatedFiles[filename] = res;
+        return res;
+    }
+    return evaluateModule;
+}
+function deepClone(val) {
+    if (isPlainObject(val)) {
+        const res = {};
+        for (const key in val) {
+            res[key] = deepClone(val[key]);
+        }
+        return res;
+    }
+    else if (Array.isArray(val)) {
+        return val.slice();
+    }
+    else {
+        return val;
+    }
+}
+function createBundleRunner(entry, files, basedir, runInNewContext) {
+    const evaluate = compileModule(files, basedir, runInNewContext);
+    if (runInNewContext !== false && runInNewContext !== 'once') {
+        // new context mode: creates a fresh context and re-evaluate the bundle
+        // on each render. Ensures entire application state is fresh for each
+        // render, but incurs extra evaluation cost.
+        return (userContext = {}) => new Promise((resolve) => {
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            const res = evaluate(entry, createSandbox(userContext));
+            resolve(typeof res === 'function' ? res(userContext) : res);
+        });
+    }
+    else {
+        // direct mode: instead of re-evaluating the whole bundle on
+        // each render, it simply calls the exported function. This avoids the
+        // module evaluation costs but requires the source code to be structured
+        // slightly differently.
+        let runner; // lazy creation so that errors can be caught by user
+        let initialContext;
+        return (userContext = {}) => new Promise((resolve) => {
+            if (!runner) {
+                const sandbox = runInNewContext === 'once' ? createSandbox() : global;
+                // the initial context is only used for collecting possible non-component
+                // styles injected by vue-style-loader.
+                // @ts-expect-error
+                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
+                runner = evaluate(entry, sandbox);
+                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
+                // to prevent cross-request pollution.
+                // @ts-expect-error
+                delete sandbox.__VUE_SSR_CONTEXT__;
+                if (typeof runner !== 'function') {
+                    throw new Error('bundle export should be a function when using ' +
+                        '{ runInNewContext: false }.');
+                }
+            }
+            // @ts-expect-error
+            userContext._registeredComponents = new Set();
+            // vue-style-loader styles imported outside of component lifecycle hooks
+            if (initialContext._styles) {
+                // @ts-expect-error
+                userContext._styles = deepClone(initialContext._styles);
+                // #6353 ensure "styles" is exposed even if no styles are injected
+                // in component lifecycles.
+                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
+                const renderStyles = initialContext._renderStyles;
+                if (renderStyles) {
+                    Object.defineProperty(userContext, 'styles', {
+                        enumerable: true,
+                        get() {
+                            // @ts-expect-error
+                            return renderStyles(userContext._styles);
+                        },
+                    });
+                }
+            }
+            resolve(runner(userContext));
+        });
+    }
 }
 
-const SourceMapConsumer = require('source-map').SourceMapConsumer;
-const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
-function createSourceMapConsumers(rawMaps) {
-    const maps = {};
-    Object.keys(rawMaps).forEach((file) => {
-        maps[file] = new SourceMapConsumer(rawMaps[file]);
-    });
-    return maps;
-}
-function rewriteErrorTrace(e, mapConsumers) {
-    if (e && typeof e.stack === 'string') {
-        e.stack = e.stack
-            .split('\n')
-            .map((line) => {
-            return rewriteTraceLine(line, mapConsumers);
-        })
-            .join('\n');
-    }
-}
-function rewriteTraceLine(trace, mapConsumers) {
-    const m = trace.match(filenameRE);
-    const map = m && mapConsumers[m[1]];
-    if (m != null && map) {
-        const originalPosition = map.originalPositionFor({
-            line: Number(m[2]),
-            column: Number(m[3]),
-        });
-        if (originalPosition.source != null) {
-            const { source, line, column } = originalPosition;
-            const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`;
-            return trace.replace(filenameRE, mappedPosition);
-        }
-        else {
-            return trace;
-        }
-    }
-    else {
-        return trace;
-    }
+const SourceMapConsumer = require('source-map').SourceMapConsumer;
+const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
+function createSourceMapConsumers(rawMaps) {
+    const maps = {};
+    Object.keys(rawMaps).forEach((file) => {
+        maps[file] = new SourceMapConsumer(rawMaps[file]);
+    });
+    return maps;
+}
+function rewriteErrorTrace(e, mapConsumers) {
+    if (e && typeof e.stack === 'string') {
+        e.stack = e.stack
+            .split('\n')
+            .map((line) => {
+            return rewriteTraceLine(line, mapConsumers);
+        })
+            .join('\n');
+    }
+}
+function rewriteTraceLine(trace, mapConsumers) {
+    const m = trace.match(filenameRE);
+    const map = m && mapConsumers[m[1]];
+    if (m != null && map) {
+        const originalPosition = map.originalPositionFor({
+            line: Number(m[2]),
+            column: Number(m[3]),
+        });
+        if (originalPosition.source != null) {
+            const { source, line, column } = originalPosition;
+            const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`;
+            return trace.replace(filenameRE, mappedPosition);
+        }
+        else {
+            return trace;
+        }
+    }
+    else {
+        return trace;
+    }
 }
 
-const fs = require('fs');
-const path = require('path');
-const PassThrough = require('stream').PassThrough;
-const INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
-    'or a bundle Object of type:\n\n' +
+const fs = require('fs');
+const path = require('path');
+const PassThrough = require('stream').PassThrough;
+const INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
+    'or a bundle Object of type:\n\n' +
     `{
   entry: string;
   files: { [filename: string]: string; };
   maps: { [filename: string]: string; };
-}\n`;
-function createBundleRendererCreator(createRenderer) {
-    return function createBundleRenderer(bundle, rendererOptions = {}) {
-        let files, entry, maps;
-        let basedir = rendererOptions.basedir;
-        // load bundle if given filepath
-        if (typeof bundle === 'string' &&
-            /\.js(on)?$/.test(bundle) &&
-            path.isAbsolute(bundle)) {
-            if (fs.existsSync(bundle)) {
-                const isJSON = /\.json$/.test(bundle);
-                basedir = basedir || path.dirname(bundle);
-                bundle = fs.readFileSync(bundle, 'utf-8');
-                if (isJSON) {
-                    try {
-                        // @ts-expect-error
-                        bundle = JSON.parse(bundle);
-                    }
-                    catch (e) {
-                        throw new Error(`Invalid JSON bundle file: ${bundle}`);
-                    }
-                }
-            }
-            else {
-                throw new Error(`Cannot locate bundle file: ${bundle}`);
-            }
-        }
-        if (typeof bundle === 'object') {
-            entry = bundle.entry;
-            files = bundle.files;
-            basedir = basedir || bundle.basedir;
-            maps = createSourceMapConsumers(bundle.maps);
-            if (typeof entry !== 'string' || typeof files !== 'object') {
-                throw new Error(INVALID_MSG);
-            }
-        }
-        else if (typeof bundle === 'string') {
-            entry = '__vue_ssr_bundle__';
-            files = { __vue_ssr_bundle__: bundle };
-            maps = {};
-        }
-        else {
-            throw new Error(INVALID_MSG);
-        }
-        const renderer = createRenderer(rendererOptions);
-        const run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
-        return {
-            renderToString: (context, cb) => {
-                if (typeof context === 'function') {
-                    cb = context;
-                    context = {};
-                }
-                let promise;
-                if (!cb) {
-                    ({ promise, cb } = createPromiseCallback());
-                }
-                run(context)
-                    .catch((err) => {
-                    rewriteErrorTrace(err, maps);
-                    cb(err);
-                })
-                    .then((app) => {
-                    if (app) {
-                        //@ts-expect-error
-                        renderer.renderToString(app, context, (err, res) => {
-                            rewriteErrorTrace(err, maps);
-                            cb(err, res);
-                        });
-                    }
-                });
-                return promise;
-            },
-            renderToStream: (context) => {
-                const res = new PassThrough();
-                run(context)
-                    .catch((err) => {
-                    rewriteErrorTrace(err, maps);
-                    // avoid emitting synchronously before user can
-                    // attach error listener
-                    process.nextTick(() => {
-                        res.emit('error', err);
-                    });
-                })
-                    .then((app) => {
-                    if (app) {
-                        //@ts-expect-error
-                        const renderStream = renderer.renderToStream(app, context);
-                        renderStream.on('error', (err) => {
-                            rewriteErrorTrace(err, maps);
-                            res.emit('error', err);
-                        });
-                        // relay HTMLStream special events
-                        if (rendererOptions && rendererOptions.template) {
-                            renderStream.on('beforeStart', () => {
-                                res.emit('beforeStart');
-                            });
-                            renderStream.on('beforeEnd', () => {
-                                res.emit('beforeEnd');
-                            });
-                        }
-                        renderStream.pipe(res);
-                    }
-                });
-                return res;
-            },
-        };
-    };
+}\n`;
+function createBundleRendererCreator(createRenderer) {
+    return function createBundleRenderer(bundle, rendererOptions = {}) {
+        let files, entry, maps;
+        let basedir = rendererOptions.basedir;
+        // load bundle if given filepath
+        if (typeof bundle === 'string' &&
+            /\.js(on)?$/.test(bundle) &&
+            path.isAbsolute(bundle)) {
+            if (fs.existsSync(bundle)) {
+                const isJSON = /\.json$/.test(bundle);
+                basedir = basedir || path.dirname(bundle);
+                bundle = fs.readFileSync(bundle, 'utf-8');
+                if (isJSON) {
+                    try {
+                        // @ts-expect-error
+                        bundle = JSON.parse(bundle);
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid JSON bundle file: ${bundle}`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Cannot locate bundle file: ${bundle}`);
+            }
+        }
+        if (typeof bundle === 'object') {
+            entry = bundle.entry;
+            files = bundle.files;
+            basedir = basedir || bundle.basedir;
+            maps = createSourceMapConsumers(bundle.maps);
+            if (typeof entry !== 'string' || typeof files !== 'object') {
+                throw new Error(INVALID_MSG);
+            }
+        }
+        else if (typeof bundle === 'string') {
+            entry = '__vue_ssr_bundle__';
+            files = { __vue_ssr_bundle__: bundle };
+            maps = {};
+        }
+        else {
+            throw new Error(INVALID_MSG);
+        }
+        const renderer = createRenderer(rendererOptions);
+        const run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
+        return {
+            renderToString: (context, cb) => {
+                if (typeof context === 'function') {
+                    cb = context;
+                    context = {};
+                }
+                let promise;
+                if (!cb) {
+                    ({ promise, cb } = createPromiseCallback());
+                }
+                run(context)
+                    .catch((err) => {
+                    rewriteErrorTrace(err, maps);
+                    cb(err);
+                })
+                    .then((app) => {
+                    if (app) {
+                        //@ts-expect-error
+                        renderer.renderToString(app, context, (err, res) => {
+                            rewriteErrorTrace(err, maps);
+                            cb(err, res);
+                        });
+                    }
+                });
+                return promise;
+            },
+            renderToStream: (context) => {
+                const res = new PassThrough();
+                run(context)
+                    .catch((err) => {
+                    rewriteErrorTrace(err, maps);
+                    // avoid emitting synchronously before user can
+                    // attach error listener
+                    process.nextTick(() => {
+                        res.emit('error', err);
+                    });
+                })
+                    .then((app) => {
+                    if (app) {
+                        //@ts-expect-error
+                        const renderStream = renderer.renderToStream(app, context);
+                        renderStream.on('error', (err) => {
+                            rewriteErrorTrace(err, maps);
+                            res.emit('error', err);
+                        });
+                        // relay HTMLStream special events
+                        if (rendererOptions && rendererOptions.template) {
+                            renderStream.on('beforeStart', () => {
+                                res.emit('beforeStart');
+                            });
+                            renderStream.on('beforeEnd', () => {
+                                res.emit('beforeEnd');
+                            });
+                        }
+                        renderStream.pipe(res);
+                    }
+                });
+                return res;
+            },
+        };
+    };
 }
 
-process.env.VUE_ENV = 'server';
-function createRenderer(options = {}) {
-    return createRenderer$1(extend(extend({}, options), {
-        isUnaryTag,
-        canBeLeftOpenTag,
-        modules: modules$1,
-        // user can provide server-side implementations for custom directives
-        // when creating the renderer.
-        directives: extend(baseDirectives$1, options.directives),
-    }));
-}
+process.env.VUE_ENV = 'server';
+function createRenderer(options = {}) {
+    return createRenderer$1(extend(extend({}, options), {
+        isUnaryTag,
+        canBeLeftOpenTag,
+        modules: modules$1,
+        // user can provide server-side implementations for custom directives
+        // when creating the renderer.
+        directives: extend(baseDirectives$1, options.directives),
+    }));
+}
 const createBundleRenderer = createBundleRendererCreator(createRenderer);
 
 exports.createBundleRenderer = createBundleRenderer;
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
index 1301fcd323a..40af65818a0 100644
--- a/packages/vue-server-renderer/client-plugin.js
+++ b/packages/vue-server-renderer/client-plugin.js
@@ -1,113 +1,113 @@
 'use strict';
 
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
+const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
 const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
 
-const { red, yellow } = require('chalk');
-const webpack = require('webpack');
-const prefix = `[vue-server-renderer-webpack-plugin]`;
-exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
-exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
-const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-const onEmit = (compiler, name, stageName, hook) => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        compiler.hooks.compilation.tap(name, compilation => {
-            if (compilation.compiler !== compiler) {
-                // Ignore child compilers
-                return;
-            }
-            const stage = webpack.Compilation[stageName];
-            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-                hook(compilation, cb);
-            });
-        });
-    }
-    else if (compiler.hooks) {
-        // Webpack >= 4.0.0
-        compiler.hooks.emit.tapAsync(name, hook);
-    }
-    else {
-        // Webpack < 4.0.0
-        compiler.plugin('emit', hook);
-    }
-};
-const stripModuleIdHash = id => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        return id.replace(/\|\w+$/, '');
-    }
-    // Webpack < 5.0.0
-    return id.replace(/\s\w+$/, '');
-};
-const getAssetName = asset => {
-    if (typeof asset === 'string') {
-        return asset;
-    }
-    return asset.name;
+const { red, yellow } = require('chalk');
+const webpack = require('webpack');
+const prefix = `[vue-server-renderer-webpack-plugin]`;
+exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
+exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
+const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
+const onEmit = (compiler, name, stageName, hook) => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        compiler.hooks.compilation.tap(name, compilation => {
+            if (compilation.compiler !== compiler) {
+                // Ignore child compilers
+                return;
+            }
+            const stage = webpack.Compilation[stageName];
+            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
+                hook(compilation, cb);
+            });
+        });
+    }
+    else if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
+};
+const stripModuleIdHash = id => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        return id.replace(/\|\w+$/, '');
+    }
+    // Webpack < 5.0.0
+    return id.replace(/\s\w+$/, '');
+};
+const getAssetName = asset => {
+    if (typeof asset === 'string') {
+        return asset;
+    }
+    return asset.name;
 };
 
-const hash = require("hash-sum");
-const uniq = require("lodash.uniq");
-class VueSSRClientPlugin {
-    constructor(options = {}) {
-        //@ts-expect-error no type on options
-        this.options = Object.assign({
-            filename: "vue-ssr-client-manifest.json",
-        }, options);
-    }
-    apply(compiler) {
-        const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
-        onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
-            const stats = compilation.getStats().toJson();
-            const allFiles = uniq(stats.assets.map((a) => a.name));
-            const initialFiles = uniq(Object.keys(stats.entrypoints)
-                .map((name) => stats.entrypoints[name].assets)
-                .reduce((assets, all) => all.concat(assets), [])
-                .map(getAssetName)
-                .filter((file) => isJS(file) || isCSS(file)));
-            const asyncFiles = allFiles
-                .filter((file) => isJS(file) || isCSS(file))
-                .filter((file) => initialFiles.indexOf(file) < 0);
-            const manifest = {
-                publicPath: stats.publicPath,
-                all: allFiles,
-                initial: initialFiles,
-                async: asyncFiles,
-                modules: {
-                /* [identifier: string]: Array<index: number> */
-                },
-            };
-            const assetModules = stats.modules.filter((m) => m.assets.length);
-            const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
-            stats.modules.forEach((m) => {
-                // ignore modules duplicated in multiple chunks
-                if (m.chunks.length === 1) {
-                    const cid = m.chunks[0];
-                    const chunk = stats.chunks.find((c) => c.id === cid);
-                    if (!chunk || !chunk.files) {
-                        return;
-                    }
-                    const id = stripModuleIdHash(m.identifier);
-                    const files = (manifest.modules[hash(id)] =
-                        chunk.files.map(fileToIndex));
-                    // find all asset modules associated with the same chunk
-                    assetModules.forEach((m) => {
-                        if (m.chunks.some((id) => id === cid)) {
-                            files.push.apply(files, m.assets.map(fileToIndex));
-                        }
-                    });
-                }
-            });
-            const json = JSON.stringify(manifest, null, 2);
-            //@ts-expect-error no type on options
-            compilation.assets[this.options.filename] = {
-                source: () => json,
-                size: () => json.length,
-            };
-            cb();
-        });
-    }
+const hash = require("hash-sum");
+const uniq = require("lodash.uniq");
+class VueSSRClientPlugin {
+    constructor(options = {}) {
+        //@ts-expect-error no type on options
+        this.options = Object.assign({
+            filename: "vue-ssr-client-manifest.json",
+        }, options);
+    }
+    apply(compiler) {
+        const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
+        onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
+            const stats = compilation.getStats().toJson();
+            const allFiles = uniq(stats.assets.map((a) => a.name));
+            const initialFiles = uniq(Object.keys(stats.entrypoints)
+                .map((name) => stats.entrypoints[name].assets)
+                .reduce((assets, all) => all.concat(assets), [])
+                .map(getAssetName)
+                .filter((file) => isJS(file) || isCSS(file)));
+            const asyncFiles = allFiles
+                .filter((file) => isJS(file) || isCSS(file))
+                .filter((file) => initialFiles.indexOf(file) < 0);
+            const manifest = {
+                publicPath: stats.publicPath,
+                all: allFiles,
+                initial: initialFiles,
+                async: asyncFiles,
+                modules: {
+                /* [identifier: string]: Array<index: number> */
+                },
+            };
+            const assetModules = stats.modules.filter((m) => m.assets.length);
+            const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
+            stats.modules.forEach((m) => {
+                // ignore modules duplicated in multiple chunks
+                if (m.chunks.length === 1) {
+                    const cid = m.chunks[0];
+                    const chunk = stats.chunks.find((c) => c.id === cid);
+                    if (!chunk || !chunk.files) {
+                        return;
+                    }
+                    const id = stripModuleIdHash(m.identifier);
+                    const files = (manifest.modules[hash(id)] =
+                        chunk.files.map(fileToIndex));
+                    // find all asset modules associated with the same chunk
+                    assetModules.forEach((m) => {
+                        if (m.chunks.some((id) => id === cid)) {
+                            files.push.apply(files, m.assets.map(fileToIndex));
+                        }
+                    });
+                }
+            });
+            const json = JSON.stringify(manifest, null, 2);
+            //@ts-expect-error no type on options
+            compilation.assets[this.options.filename] = {
+                source: () => json,
+                size: () => json.length,
+            };
+            cb();
+        });
+    }
 }
 
 module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
index 2cdc79c9df7..d8682e73387 100644
--- a/packages/vue-server-renderer/server-plugin.js
+++ b/packages/vue-server-renderer/server-plugin.js
@@ -2,117 +2,117 @@
 
 const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
 
-const { red, yellow } = require('chalk');
-const webpack = require('webpack');
-const prefix = `[vue-server-renderer-webpack-plugin]`;
-const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
-const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
-const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-const validate = compiler => {
-    if (compiler.options.target !== 'node') {
-        warn('webpack config `target` should be "node".');
-    }
-    if (compiler.options.output) {
-        if (compiler.options.output.library) {
-            // Webpack >= 5.0.0
-            if (compiler.options.output.library.type !== 'commonjs2') {
-                warn('webpack config `output.library.type` should be "commonjs2".');
-            }
-        }
-        else if (compiler.options.output.libraryTarget !== 'commonjs2') {
-            // Webpack < 5.0.0
-            warn('webpack config `output.libraryTarget` should be "commonjs2".');
-        }
-    }
-    if (!compiler.options.externals) {
-        tip('It is recommended to externalize dependencies in the server build for ' +
-            'better build performance.');
-    }
-};
-const onEmit = (compiler, name, stageName, hook) => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        compiler.hooks.compilation.tap(name, compilation => {
-            if (compilation.compiler !== compiler) {
-                // Ignore child compilers
-                return;
-            }
-            const stage = webpack.Compilation[stageName];
-            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-                hook(compilation, cb);
-            });
-        });
-    }
-    else if (compiler.hooks) {
-        // Webpack >= 4.0.0
-        compiler.hooks.emit.tapAsync(name, hook);
-    }
-    else {
-        // Webpack < 4.0.0
-        compiler.plugin('emit', hook);
-    }
-};
-const getAssetName = asset => {
-    if (typeof asset === 'string') {
-        return asset;
-    }
-    return asset.name;
+const { red, yellow } = require('chalk');
+const webpack = require('webpack');
+const prefix = `[vue-server-renderer-webpack-plugin]`;
+const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
+const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
+const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
+const validate = compiler => {
+    if (compiler.options.target !== 'node') {
+        warn('webpack config `target` should be "node".');
+    }
+    if (compiler.options.output) {
+        if (compiler.options.output.library) {
+            // Webpack >= 5.0.0
+            if (compiler.options.output.library.type !== 'commonjs2') {
+                warn('webpack config `output.library.type` should be "commonjs2".');
+            }
+        }
+        else if (compiler.options.output.libraryTarget !== 'commonjs2') {
+            // Webpack < 5.0.0
+            warn('webpack config `output.libraryTarget` should be "commonjs2".');
+        }
+    }
+    if (!compiler.options.externals) {
+        tip('It is recommended to externalize dependencies in the server build for ' +
+            'better build performance.');
+    }
+};
+const onEmit = (compiler, name, stageName, hook) => {
+    if (isWebpack5) {
+        // Webpack >= 5.0.0
+        compiler.hooks.compilation.tap(name, compilation => {
+            if (compilation.compiler !== compiler) {
+                // Ignore child compilers
+                return;
+            }
+            const stage = webpack.Compilation[stageName];
+            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
+                hook(compilation, cb);
+            });
+        });
+    }
+    else if (compiler.hooks) {
+        // Webpack >= 4.0.0
+        compiler.hooks.emit.tapAsync(name, hook);
+    }
+    else {
+        // Webpack < 4.0.0
+        compiler.plugin('emit', hook);
+    }
+};
+const getAssetName = asset => {
+    if (typeof asset === 'string') {
+        return asset;
+    }
+    return asset.name;
 };
 
-class VueSSRServerPlugin {
-    constructor(options = {}) {
-        //@ts-expect-error
-        this.options = Object.assign({
-            filename: 'vue-ssr-server-bundle.json',
-        }, options);
-    }
-    apply(compiler) {
-        validate(compiler);
-        const stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
-        onEmit(compiler, 'vue-server-plugin', stage, (compilation, cb) => {
-            const stats = compilation.getStats().toJson();
-            const entryName = Object.keys(stats.entrypoints)[0];
-            const entryInfo = stats.entrypoints[entryName];
-            if (!entryInfo) {
-                // #5553
-                return cb();
-            }
-            const entryAssets = entryInfo.assets
-                .map(getAssetName)
-                .filter(isJS);
-            if (entryAssets.length > 1) {
-                throw new Error(`Server-side bundle should have one single entry file. ` +
-                    `Avoid using CommonsChunkPlugin in the server config.`);
-            }
-            const entry = entryAssets[0];
-            if (!entry || typeof entry !== 'string') {
-                throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
-            }
-            const bundle = {
-                entry,
-                files: {},
-                maps: {},
-            };
-            Object.keys(compilation.assets).forEach(name => {
-                if (isJS(name)) {
-                    bundle.files[name] = compilation.assets[name].source();
-                }
-                else if (name.match(/\.js\.map$/)) {
-                    bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
-                }
-                // do not emit anything else for server
-                delete compilation.assets[name];
-            });
-            const json = JSON.stringify(bundle, null, 2);
-            //@ts-expect-error
-            const filename = this.options.filename;
-            compilation.assets[filename] = {
-                source: () => json,
-                size: () => json.length,
-            };
-            cb();
-        });
-    }
+class VueSSRServerPlugin {
+    constructor(options = {}) {
+        //@ts-expect-error
+        this.options = Object.assign({
+            filename: 'vue-ssr-server-bundle.json',
+        }, options);
+    }
+    apply(compiler) {
+        validate(compiler);
+        const stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
+        onEmit(compiler, 'vue-server-plugin', stage, (compilation, cb) => {
+            const stats = compilation.getStats().toJson();
+            const entryName = Object.keys(stats.entrypoints)[0];
+            const entryInfo = stats.entrypoints[entryName];
+            if (!entryInfo) {
+                // #5553
+                return cb();
+            }
+            const entryAssets = entryInfo.assets
+                .map(getAssetName)
+                .filter(isJS);
+            if (entryAssets.length > 1) {
+                throw new Error(`Server-side bundle should have one single entry file. ` +
+                    `Avoid using CommonsChunkPlugin in the server config.`);
+            }
+            const entry = entryAssets[0];
+            if (!entry || typeof entry !== 'string') {
+                throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
+            }
+            const bundle = {
+                entry,
+                files: {},
+                maps: {},
+            };
+            Object.keys(compilation.assets).forEach(name => {
+                if (isJS(name)) {
+                    bundle.files[name] = compilation.assets[name].source();
+                }
+                else if (name.match(/\.js\.map$/)) {
+                    bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
+                }
+                // do not emit anything else for server
+                delete compilation.assets[name];
+            });
+            const json = JSON.stringify(bundle, null, 2);
+            //@ts-expect-error
+            const filename = this.options.filename;
+            compilation.assets[filename] = {
+                source: () => json,
+                size: () => json.length,
+            };
+            cb();
+        });
+    }
 }
 
 module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
index 1c3dfdd3adc..5a1007309da 100644
--- a/packages/vue-template-compiler/browser.js
+++ b/packages/vue-template-compiler/browser.js
@@ -52,1847 +52,1847 @@
 	  return i
 	}
 
-	const emptyObject = Object.freeze({});
-	// These helpers produce better VM code in JS engines due to their
-	// explicitness and function inlining.
-	function isUndef(v) {
-	    return v === undefined || v === null;
-	}
-	/**
-	 * Check if value is primitive.
-	 */
-	function isPrimitive(value) {
-	    return (typeof value === 'string' ||
-	        typeof value === 'number' ||
-	        // $flow-disable-line
-	        typeof value === 'symbol' ||
-	        typeof value === 'boolean');
-	}
-	/**
-	 * Quick object check - this is primarily used to tell
-	 * objects from primitive values when we know the value
-	 * is a JSON-compliant type.
-	 */
-	function isObject(obj) {
-	    return obj !== null && typeof obj === 'object';
-	}
-	/**
-	 * Get the raw type string of a value, e.g., [object Object].
-	 */
-	const _toString = Object.prototype.toString;
-	function toRawType(value) {
-	    return _toString.call(value).slice(8, -1);
-	}
-	/**
-	 * Strict object type check. Only returns true
-	 * for plain JavaScript objects.
-	 */
-	function isPlainObject(obj) {
-	    return _toString.call(obj) === '[object Object]';
-	}
-	/**
-	 * Check if val is a valid array index.
-	 */
-	function isValidArrayIndex(val) {
-	    const n = parseFloat(String(val));
-	    return n >= 0 && Math.floor(n) === n && isFinite(val);
-	}
-	/**
-	 * Make a map and return a function for checking if a key
-	 * is in that map.
-	 */
-	function makeMap(str, expectsLowerCase) {
-	    const map = Object.create(null);
-	    const list = str.split(',');
-	    for (let i = 0; i < list.length; i++) {
-	        map[list[i]] = true;
-	    }
-	    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-	}
-	/**
-	 * Check if a tag is a built-in tag.
-	 */
-	const isBuiltInTag = makeMap('slot,component', true);
-	/**
-	 * Check if an attribute is a reserved attribute.
-	 */
-	makeMap('key,ref,slot,slot-scope,is');
-	/**
-	 * Remove an item from an array.
-	 */
-	function remove(arr, item) {
-	    if (arr.length) {
-	        const index = arr.indexOf(item);
-	        if (index > -1) {
-	            return arr.splice(index, 1);
-	        }
-	    }
-	}
-	/**
-	 * Check whether an object has the property.
-	 */
-	const hasOwnProperty = Object.prototype.hasOwnProperty;
-	function hasOwn(obj, key) {
-	    return hasOwnProperty.call(obj, key);
-	}
-	/**
-	 * Create a cached version of a pure function.
-	 */
-	function cached(fn) {
-	    const cache = Object.create(null);
-	    return function cachedFn(str) {
-	        const hit = cache[str];
-	        return hit || (cache[str] = fn(str));
-	    };
-	}
-	/**
-	 * Camelize a hyphen-delimited string.
-	 */
-	const camelizeRE = /-(\w)/g;
-	const camelize = cached((str) => {
-	    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-	});
-	/**
-	 * Hyphenate a camelCase string.
-	 */
-	const hyphenateRE = /\B([A-Z])/g;
-	const hyphenate = cached((str) => {
-	    return str.replace(hyphenateRE, '-$1').toLowerCase();
-	});
-	/**
-	 * Mix properties into target object.
-	 */
-	function extend(to, _from) {
-	    for (const key in _from) {
-	        to[key] = _from[key];
-	    }
-	    return to;
-	}
-	/* eslint-disable no-unused-vars */
-	/**
-	 * Perform no operation.
-	 * Stubbing args to make Flow happy without leaving useless transpiled code
-	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-	 */
-	function noop(a, b, c) { }
-	/**
-	 * Always return false.
-	 */
-	const no = (a, b, c) => false;
-	/* eslint-enable no-unused-vars */
-	/**
-	 * Return the same value.
-	 */
-	const identity = (_) => _;
-	/**
-	 * Generate a string containing static keys from compiler modules.
-	 */
-	function genStaticKeys$1(modules) {
-	    return modules
-	        .reduce((keys, m) => {
-	        return keys.concat(m.staticKeys || []);
-	    }, [])
-	        .join(',');
+	const emptyObject = Object.freeze({});
+	// These helpers produce better VM code in JS engines due to their
+	// explicitness and function inlining.
+	function isUndef(v) {
+	    return v === undefined || v === null;
+	}
+	/**
+	 * Check if value is primitive.
+	 */
+	function isPrimitive(value) {
+	    return (typeof value === 'string' ||
+	        typeof value === 'number' ||
+	        // $flow-disable-line
+	        typeof value === 'symbol' ||
+	        typeof value === 'boolean');
+	}
+	/**
+	 * Quick object check - this is primarily used to tell
+	 * objects from primitive values when we know the value
+	 * is a JSON-compliant type.
+	 */
+	function isObject(obj) {
+	    return obj !== null && typeof obj === 'object';
+	}
+	/**
+	 * Get the raw type string of a value, e.g., [object Object].
+	 */
+	const _toString = Object.prototype.toString;
+	function toRawType(value) {
+	    return _toString.call(value).slice(8, -1);
+	}
+	/**
+	 * Strict object type check. Only returns true
+	 * for plain JavaScript objects.
+	 */
+	function isPlainObject(obj) {
+	    return _toString.call(obj) === '[object Object]';
+	}
+	/**
+	 * Check if val is a valid array index.
+	 */
+	function isValidArrayIndex(val) {
+	    const n = parseFloat(String(val));
+	    return n >= 0 && Math.floor(n) === n && isFinite(val);
+	}
+	/**
+	 * Make a map and return a function for checking if a key
+	 * is in that map.
+	 */
+	function makeMap(str, expectsLowerCase) {
+	    const map = Object.create(null);
+	    const list = str.split(',');
+	    for (let i = 0; i < list.length; i++) {
+	        map[list[i]] = true;
+	    }
+	    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+	}
+	/**
+	 * Check if a tag is a built-in tag.
+	 */
+	const isBuiltInTag = makeMap('slot,component', true);
+	/**
+	 * Check if an attribute is a reserved attribute.
+	 */
+	makeMap('key,ref,slot,slot-scope,is');
+	/**
+	 * Remove an item from an array.
+	 */
+	function remove(arr, item) {
+	    if (arr.length) {
+	        const index = arr.indexOf(item);
+	        if (index > -1) {
+	            return arr.splice(index, 1);
+	        }
+	    }
+	}
+	/**
+	 * Check whether an object has the property.
+	 */
+	const hasOwnProperty = Object.prototype.hasOwnProperty;
+	function hasOwn(obj, key) {
+	    return hasOwnProperty.call(obj, key);
+	}
+	/**
+	 * Create a cached version of a pure function.
+	 */
+	function cached(fn) {
+	    const cache = Object.create(null);
+	    return function cachedFn(str) {
+	        const hit = cache[str];
+	        return hit || (cache[str] = fn(str));
+	    };
+	}
+	/**
+	 * Camelize a hyphen-delimited string.
+	 */
+	const camelizeRE = /-(\w)/g;
+	const camelize = cached((str) => {
+	    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+	});
+	/**
+	 * Hyphenate a camelCase string.
+	 */
+	const hyphenateRE = /\B([A-Z])/g;
+	const hyphenate = cached((str) => {
+	    return str.replace(hyphenateRE, '-$1').toLowerCase();
+	});
+	/**
+	 * Mix properties into target object.
+	 */
+	function extend(to, _from) {
+	    for (const key in _from) {
+	        to[key] = _from[key];
+	    }
+	    return to;
+	}
+	/* eslint-disable no-unused-vars */
+	/**
+	 * Perform no operation.
+	 * Stubbing args to make Flow happy without leaving useless transpiled code
+	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+	 */
+	function noop(a, b, c) { }
+	/**
+	 * Always return false.
+	 */
+	const no = (a, b, c) => false;
+	/* eslint-enable no-unused-vars */
+	/**
+	 * Return the same value.
+	 */
+	const identity = (_) => _;
+	/**
+	 * Generate a string containing static keys from compiler modules.
+	 */
+	function genStaticKeys$1(modules) {
+	    return modules
+	        .reduce((keys, m) => {
+	        return keys.concat(m.staticKeys || []);
+	    }, [])
+	        .join(',');
 	}
 
-	const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-	    'link,meta,param,source,track,wbr');
-	// Elements that you can, intentionally, leave open
-	// (and which close themselves)
-	const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-	const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-	    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-	    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-	    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+	const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+	    'link,meta,param,source,track,wbr');
+	// Elements that you can, intentionally, leave open
+	// (and which close themselves)
+	const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+	const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+	    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+	    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+	    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
 	    'title,tr,track');
 
-	/**
-	 * unicode letters used for parsing html tags, component names and property paths.
-	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-	 */
-	const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-	/**
-	 * Define a property.
-	 */
-	function def(obj, key, val, enumerable) {
-	    Object.defineProperty(obj, key, {
-	        value: val,
-	        enumerable: !!enumerable,
-	        writable: true,
-	        configurable: true,
-	    });
+	/**
+	 * unicode letters used for parsing html tags, component names and property paths.
+	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+	 */
+	const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+	/**
+	 * Define a property.
+	 */
+	function def(obj, key, val, enumerable) {
+	    Object.defineProperty(obj, key, {
+	        value: val,
+	        enumerable: !!enumerable,
+	        writable: true,
+	        configurable: true,
+	    });
 	}
 
-	/**
-	 * Not type-checking this file because it's mostly vendor code.
-	 */
-	// Regular Expressions for parsing tags and attributes
-	const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-	const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-	const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-	const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-	const startTagOpen = new RegExp(`^<${qnameCapture}`);
-	const startTagClose = /^\s*(\/?)>/;
-	const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-	const doctype = /^<!DOCTYPE [^>]+>/i;
-	// #7298: escape - to avoid being passed as HTML comment when inlined in page
-	const comment = /^<!\--/;
-	const conditionalComment = /^<!\[/;
-	// Special Elements (can contain anything)
-	const isPlainTextElement = makeMap('script,style,textarea', true);
-	const reCache = {};
-	const decodingMap = {
-	    '&lt;': '<',
-	    '&gt;': '>',
-	    '&quot;': '"',
-	    '&amp;': '&',
-	    '&#10;': '\n',
-	    '&#9;': '\t',
-	    '&#39;': "'",
-	};
-	const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-	const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-	// #5992
-	const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-	const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-	function decodeAttr(value, shouldDecodeNewlines) {
-	    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-	    return value.replace(re, (match) => decodingMap[match]);
-	}
-	function parseHTML(html, options) {
-	    const stack = [];
-	    const expectHTML = options.expectHTML;
-	    const isUnaryTag = options.isUnaryTag || no;
-	    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-	    let index = 0;
-	    let last, lastTag;
-	    while (html) {
-	        last = html;
-	        // Make sure we're not in a plaintext content element like script/style
-	        if (!lastTag || !isPlainTextElement(lastTag)) {
-	            let textEnd = html.indexOf('<');
-	            if (textEnd === 0) {
-	                // Comment:
-	                if (comment.test(html)) {
-	                    const commentEnd = html.indexOf('-->');
-	                    if (commentEnd >= 0) {
-	                        if (options.shouldKeepComment) {
-	                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-	                        }
-	                        advance(commentEnd + 3);
-	                        continue;
-	                    }
-	                }
-	                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-	                if (conditionalComment.test(html)) {
-	                    const conditionalEnd = html.indexOf(']>');
-	                    if (conditionalEnd >= 0) {
-	                        advance(conditionalEnd + 2);
-	                        continue;
-	                    }
-	                }
-	                // Doctype:
-	                const doctypeMatch = html.match(doctype);
-	                if (doctypeMatch) {
-	                    advance(doctypeMatch[0].length);
-	                    continue;
-	                }
-	                // End tag:
-	                const endTagMatch = html.match(endTag);
-	                if (endTagMatch) {
-	                    const curIndex = index;
-	                    advance(endTagMatch[0].length);
-	                    parseEndTag(endTagMatch[1], curIndex, index);
-	                    continue;
-	                }
-	                // Start tag:
-	                const startTagMatch = parseStartTag();
-	                if (startTagMatch) {
-	                    handleStartTag(startTagMatch);
-	                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-	                        advance(1);
-	                    }
-	                    continue;
-	                }
-	            }
-	            let text, rest, next;
-	            if (textEnd >= 0) {
-	                rest = html.slice(textEnd);
-	                while (!endTag.test(rest) &&
-	                    !startTagOpen.test(rest) &&
-	                    !comment.test(rest) &&
-	                    !conditionalComment.test(rest)) {
-	                    // < in plain text, be forgiving and treat it as text
-	                    next = rest.indexOf('<', 1);
-	                    if (next < 0)
-	                        break;
-	                    textEnd += next;
-	                    rest = html.slice(textEnd);
-	                }
-	                text = html.substring(0, textEnd);
-	            }
-	            if (textEnd < 0) {
-	                text = html;
-	            }
-	            if (text) {
-	                advance(text.length);
-	            }
-	            if (options.chars && text) {
-	                options.chars(text, index - text.length, index);
-	            }
-	        }
-	        else {
-	            let endTagLength = 0;
-	            const stackedTag = lastTag.toLowerCase();
-	            const reStackedTag = reCache[stackedTag] ||
-	                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-	            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-	                endTagLength = endTag.length;
-	                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-	                    text = text
-	                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-	                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-	                }
-	                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-	                    text = text.slice(1);
-	                }
-	                if (options.chars) {
-	                    options.chars(text);
-	                }
-	                return '';
-	            });
-	            index += html.length - rest.length;
-	            html = rest;
-	            parseEndTag(stackedTag, index - endTagLength, index);
-	        }
-	        if (html === last) {
-	            options.chars && options.chars(html);
-	            if (!stack.length &&
-	                options.warn) {
-	                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-	                    start: index + html.length,
-	                });
-	            }
-	            break;
-	        }
-	    }
-	    // Clean up any remaining tags
-	    parseEndTag();
-	    function advance(n) {
-	        index += n;
-	        html = html.substring(n);
-	    }
-	    function parseStartTag() {
-	        const start = html.match(startTagOpen);
-	        if (start) {
-	            const match = {
-	                tagName: start[1],
-	                attrs: [],
-	                start: index,
-	            };
-	            advance(start[0].length);
-	            let end, attr;
-	            while (!(end = html.match(startTagClose)) &&
-	                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-	                attr.start = index;
-	                advance(attr[0].length);
-	                attr.end = index;
-	                match.attrs.push(attr);
-	            }
-	            if (end) {
-	                match.unarySlash = end[1];
-	                advance(end[0].length);
-	                match.end = index;
-	                return match;
-	            }
-	        }
-	    }
-	    function handleStartTag(match) {
-	        const tagName = match.tagName;
-	        const unarySlash = match.unarySlash;
-	        if (expectHTML) {
-	            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-	                parseEndTag(lastTag);
-	            }
-	            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-	                parseEndTag(tagName);
-	            }
-	        }
-	        const unary = isUnaryTag(tagName) || !!unarySlash;
-	        const l = match.attrs.length;
-	        const attrs = new Array(l);
-	        for (let i = 0; i < l; i++) {
-	            const args = match.attrs[i];
-	            const value = args[3] || args[4] || args[5] || '';
-	            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-	                ? options.shouldDecodeNewlinesForHref
-	                : options.shouldDecodeNewlines;
-	            attrs[i] = {
-	                name: args[1],
-	                value: decodeAttr(value, shouldDecodeNewlines),
-	            };
-	            if (options.outputSourceRange) {
-	                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-	                attrs[i].end = args.end;
-	            }
-	        }
-	        if (!unary) {
-	            stack.push({
-	                tag: tagName,
-	                lowerCasedTag: tagName.toLowerCase(),
-	                attrs: attrs,
-	                start: match.start,
-	                end: match.end,
-	            });
-	            lastTag = tagName;
-	        }
-	        if (options.start) {
-	            options.start(tagName, attrs, unary, match.start, match.end);
-	        }
-	    }
-	    function parseEndTag(tagName, start, end) {
-	        let pos, lowerCasedTagName;
-	        if (start == null)
-	            start = index;
-	        if (end == null)
-	            end = index;
-	        // Find the closest opened tag of the same type
-	        if (tagName) {
-	            lowerCasedTagName = tagName.toLowerCase();
-	            for (pos = stack.length - 1; pos >= 0; pos--) {
-	                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-	                    break;
-	                }
-	            }
-	        }
-	        else {
-	            // If no tag name is provided, clean shop
-	            pos = 0;
-	        }
-	        if (pos >= 0) {
-	            // Close all the open elements, up the stack
-	            for (let i = stack.length - 1; i >= pos; i--) {
-	                if ((i > pos || !tagName) &&
-	                    options.warn) {
-	                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-	                        start: stack[i].start,
-	                        end: stack[i].end,
-	                    });
-	                }
-	                if (options.end) {
-	                    options.end(stack[i].tag, start, end);
-	                }
-	            }
-	            // Remove the open elements from the stack
-	            stack.length = pos;
-	            lastTag = pos && stack[pos - 1].tag;
-	        }
-	        else if (lowerCasedTagName === 'br') {
-	            if (options.start) {
-	                options.start(tagName, [], true, start, end);
-	            }
-	        }
-	        else if (lowerCasedTagName === 'p') {
-	            if (options.start) {
-	                options.start(tagName, [], false, start, end);
-	            }
-	            if (options.end) {
-	                options.end(tagName, start, end);
-	            }
-	        }
-	    }
+	/**
+	 * Not type-checking this file because it's mostly vendor code.
+	 */
+	// Regular Expressions for parsing tags and attributes
+	const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+	const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+	const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+	const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+	const startTagOpen = new RegExp(`^<${qnameCapture}`);
+	const startTagClose = /^\s*(\/?)>/;
+	const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+	const doctype = /^<!DOCTYPE [^>]+>/i;
+	// #7298: escape - to avoid being passed as HTML comment when inlined in page
+	const comment = /^<!\--/;
+	const conditionalComment = /^<!\[/;
+	// Special Elements (can contain anything)
+	const isPlainTextElement = makeMap('script,style,textarea', true);
+	const reCache = {};
+	const decodingMap = {
+	    '&lt;': '<',
+	    '&gt;': '>',
+	    '&quot;': '"',
+	    '&amp;': '&',
+	    '&#10;': '\n',
+	    '&#9;': '\t',
+	    '&#39;': "'",
+	};
+	const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+	const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+	// #5992
+	const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+	const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+	function decodeAttr(value, shouldDecodeNewlines) {
+	    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+	    return value.replace(re, (match) => decodingMap[match]);
+	}
+	function parseHTML(html, options) {
+	    const stack = [];
+	    const expectHTML = options.expectHTML;
+	    const isUnaryTag = options.isUnaryTag || no;
+	    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+	    let index = 0;
+	    let last, lastTag;
+	    while (html) {
+	        last = html;
+	        // Make sure we're not in a plaintext content element like script/style
+	        if (!lastTag || !isPlainTextElement(lastTag)) {
+	            let textEnd = html.indexOf('<');
+	            if (textEnd === 0) {
+	                // Comment:
+	                if (comment.test(html)) {
+	                    const commentEnd = html.indexOf('-->');
+	                    if (commentEnd >= 0) {
+	                        if (options.shouldKeepComment) {
+	                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+	                        }
+	                        advance(commentEnd + 3);
+	                        continue;
+	                    }
+	                }
+	                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+	                if (conditionalComment.test(html)) {
+	                    const conditionalEnd = html.indexOf(']>');
+	                    if (conditionalEnd >= 0) {
+	                        advance(conditionalEnd + 2);
+	                        continue;
+	                    }
+	                }
+	                // Doctype:
+	                const doctypeMatch = html.match(doctype);
+	                if (doctypeMatch) {
+	                    advance(doctypeMatch[0].length);
+	                    continue;
+	                }
+	                // End tag:
+	                const endTagMatch = html.match(endTag);
+	                if (endTagMatch) {
+	                    const curIndex = index;
+	                    advance(endTagMatch[0].length);
+	                    parseEndTag(endTagMatch[1], curIndex, index);
+	                    continue;
+	                }
+	                // Start tag:
+	                const startTagMatch = parseStartTag();
+	                if (startTagMatch) {
+	                    handleStartTag(startTagMatch);
+	                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+	                        advance(1);
+	                    }
+	                    continue;
+	                }
+	            }
+	            let text, rest, next;
+	            if (textEnd >= 0) {
+	                rest = html.slice(textEnd);
+	                while (!endTag.test(rest) &&
+	                    !startTagOpen.test(rest) &&
+	                    !comment.test(rest) &&
+	                    !conditionalComment.test(rest)) {
+	                    // < in plain text, be forgiving and treat it as text
+	                    next = rest.indexOf('<', 1);
+	                    if (next < 0)
+	                        break;
+	                    textEnd += next;
+	                    rest = html.slice(textEnd);
+	                }
+	                text = html.substring(0, textEnd);
+	            }
+	            if (textEnd < 0) {
+	                text = html;
+	            }
+	            if (text) {
+	                advance(text.length);
+	            }
+	            if (options.chars && text) {
+	                options.chars(text, index - text.length, index);
+	            }
+	        }
+	        else {
+	            let endTagLength = 0;
+	            const stackedTag = lastTag.toLowerCase();
+	            const reStackedTag = reCache[stackedTag] ||
+	                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+	            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+	                endTagLength = endTag.length;
+	                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+	                    text = text
+	                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+	                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+	                }
+	                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+	                    text = text.slice(1);
+	                }
+	                if (options.chars) {
+	                    options.chars(text);
+	                }
+	                return '';
+	            });
+	            index += html.length - rest.length;
+	            html = rest;
+	            parseEndTag(stackedTag, index - endTagLength, index);
+	        }
+	        if (html === last) {
+	            options.chars && options.chars(html);
+	            if (!stack.length &&
+	                options.warn) {
+	                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+	                    start: index + html.length,
+	                });
+	            }
+	            break;
+	        }
+	    }
+	    // Clean up any remaining tags
+	    parseEndTag();
+	    function advance(n) {
+	        index += n;
+	        html = html.substring(n);
+	    }
+	    function parseStartTag() {
+	        const start = html.match(startTagOpen);
+	        if (start) {
+	            const match = {
+	                tagName: start[1],
+	                attrs: [],
+	                start: index,
+	            };
+	            advance(start[0].length);
+	            let end, attr;
+	            while (!(end = html.match(startTagClose)) &&
+	                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+	                attr.start = index;
+	                advance(attr[0].length);
+	                attr.end = index;
+	                match.attrs.push(attr);
+	            }
+	            if (end) {
+	                match.unarySlash = end[1];
+	                advance(end[0].length);
+	                match.end = index;
+	                return match;
+	            }
+	        }
+	    }
+	    function handleStartTag(match) {
+	        const tagName = match.tagName;
+	        const unarySlash = match.unarySlash;
+	        if (expectHTML) {
+	            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+	                parseEndTag(lastTag);
+	            }
+	            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+	                parseEndTag(tagName);
+	            }
+	        }
+	        const unary = isUnaryTag(tagName) || !!unarySlash;
+	        const l = match.attrs.length;
+	        const attrs = new Array(l);
+	        for (let i = 0; i < l; i++) {
+	            const args = match.attrs[i];
+	            const value = args[3] || args[4] || args[5] || '';
+	            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+	                ? options.shouldDecodeNewlinesForHref
+	                : options.shouldDecodeNewlines;
+	            attrs[i] = {
+	                name: args[1],
+	                value: decodeAttr(value, shouldDecodeNewlines),
+	            };
+	            if (options.outputSourceRange) {
+	                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+	                attrs[i].end = args.end;
+	            }
+	        }
+	        if (!unary) {
+	            stack.push({
+	                tag: tagName,
+	                lowerCasedTag: tagName.toLowerCase(),
+	                attrs: attrs,
+	                start: match.start,
+	                end: match.end,
+	            });
+	            lastTag = tagName;
+	        }
+	        if (options.start) {
+	            options.start(tagName, attrs, unary, match.start, match.end);
+	        }
+	    }
+	    function parseEndTag(tagName, start, end) {
+	        let pos, lowerCasedTagName;
+	        if (start == null)
+	            start = index;
+	        if (end == null)
+	            end = index;
+	        // Find the closest opened tag of the same type
+	        if (tagName) {
+	            lowerCasedTagName = tagName.toLowerCase();
+	            for (pos = stack.length - 1; pos >= 0; pos--) {
+	                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+	                    break;
+	                }
+	            }
+	        }
+	        else {
+	            // If no tag name is provided, clean shop
+	            pos = 0;
+	        }
+	        if (pos >= 0) {
+	            // Close all the open elements, up the stack
+	            for (let i = stack.length - 1; i >= pos; i--) {
+	                if ((i > pos || !tagName) &&
+	                    options.warn) {
+	                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+	                        start: stack[i].start,
+	                        end: stack[i].end,
+	                    });
+	                }
+	                if (options.end) {
+	                    options.end(stack[i].tag, start, end);
+	                }
+	            }
+	            // Remove the open elements from the stack
+	            stack.length = pos;
+	            lastTag = pos && stack[pos - 1].tag;
+	        }
+	        else if (lowerCasedTagName === 'br') {
+	            if (options.start) {
+	                options.start(tagName, [], true, start, end);
+	            }
+	        }
+	        else if (lowerCasedTagName === 'p') {
+	            if (options.start) {
+	                options.start(tagName, [], false, start, end);
+	            }
+	            if (options.end) {
+	                options.end(tagName, start, end);
+	            }
+	        }
+	    }
 	}
 
-	const splitRE = /\r?\n/g;
-	const replaceRE = /./g;
-	const isSpecialTag = makeMap('script,style,template', true);
-	/**
-	 * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
-	 */
-	function parseComponent(content, options = {}) {
-	    const sfc = {
-	        template: null,
-	        script: null,
-	        styles: [],
-	        customBlocks: [],
-	        errors: [],
-	    };
-	    let depth = 0;
-	    let currentBlock = null;
-	    let warn = (msg) => {
-	        sfc.errors.push(msg);
-	    };
-	    if (options.outputSourceRange) {
-	        warn = (msg, range) => {
-	            const data = { msg };
-	            if (range.start != null) {
-	                data.start = range.start;
-	            }
-	            if (range.end != null) {
-	                data.end = range.end;
-	            }
-	            sfc.errors.push(data);
-	        };
-	    }
-	    function start(tag, attrs, unary, start, end) {
-	        if (depth === 0) {
-	            currentBlock = {
-	                type: tag,
-	                content: '',
-	                start: end,
-	                attrs: attrs.reduce((cumulated, { name, value }) => {
-	                    cumulated[name] = value || true;
-	                    return cumulated;
-	                }, {}),
-	            };
-	            if (isSpecialTag(tag)) {
-	                checkAttrs(currentBlock, attrs);
-	                if (tag === 'style') {
-	                    sfc.styles.push(currentBlock);
-	                }
-	                else {
-	                    sfc[tag] = currentBlock;
-	                }
-	            }
-	            else {
-	                // custom blocks
-	                sfc.customBlocks.push(currentBlock);
-	            }
-	        }
-	        if (!unary) {
-	            depth++;
-	        }
-	    }
-	    function checkAttrs(block, attrs) {
-	        for (let i = 0; i < attrs.length; i++) {
-	            const attr = attrs[i];
-	            if (attr.name === 'lang') {
-	                block.lang = attr.value;
-	            }
-	            if (attr.name === 'scoped') {
-	                block.scoped = true;
-	            }
-	            if (attr.name === 'module') {
-	                block.module = attr.value || true;
-	            }
-	            if (attr.name === 'src') {
-	                block.src = attr.value;
-	            }
-	        }
-	    }
-	    function end(tag, start) {
-	        if (depth === 1 && currentBlock) {
-	            currentBlock.end = start;
-	            let text = content.slice(currentBlock.start, currentBlock.end);
-	            if (options.deindent !== false) {
-	                text = deIndent(text);
-	            }
-	            // pad content so that linters and pre-processors can output correct
-	            // line numbers in errors and warnings
-	            if (currentBlock.type !== 'template' && options.pad) {
-	                text = padContent(currentBlock, options.pad) + text;
-	            }
-	            currentBlock.content = text;
-	            currentBlock = null;
-	        }
-	        depth--;
-	    }
-	    function padContent(block, pad) {
-	        if (pad === 'space') {
-	            return content.slice(0, block.start).replace(replaceRE, ' ');
-	        }
-	        else {
-	            const offset = content.slice(0, block.start).split(splitRE).length;
-	            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
-	            return Array(offset).join(padChar);
-	        }
-	    }
-	    parseHTML(content, {
-	        warn,
-	        start,
-	        end,
-	        outputSourceRange: options.outputSourceRange,
-	    });
-	    return sfc;
+	const splitRE = /\r?\n/g;
+	const replaceRE = /./g;
+	const isSpecialTag = makeMap('script,style,template', true);
+	/**
+	 * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+	 */
+	function parseComponent(content, options = {}) {
+	    const sfc = {
+	        template: null,
+	        script: null,
+	        styles: [],
+	        customBlocks: [],
+	        errors: [],
+	    };
+	    let depth = 0;
+	    let currentBlock = null;
+	    let warn = (msg) => {
+	        sfc.errors.push(msg);
+	    };
+	    if (options.outputSourceRange) {
+	        warn = (msg, range) => {
+	            const data = { msg };
+	            if (range.start != null) {
+	                data.start = range.start;
+	            }
+	            if (range.end != null) {
+	                data.end = range.end;
+	            }
+	            sfc.errors.push(data);
+	        };
+	    }
+	    function start(tag, attrs, unary, start, end) {
+	        if (depth === 0) {
+	            currentBlock = {
+	                type: tag,
+	                content: '',
+	                start: end,
+	                attrs: attrs.reduce((cumulated, { name, value }) => {
+	                    cumulated[name] = value || true;
+	                    return cumulated;
+	                }, {}),
+	            };
+	            if (isSpecialTag(tag)) {
+	                checkAttrs(currentBlock, attrs);
+	                if (tag === 'style') {
+	                    sfc.styles.push(currentBlock);
+	                }
+	                else {
+	                    sfc[tag] = currentBlock;
+	                }
+	            }
+	            else {
+	                // custom blocks
+	                sfc.customBlocks.push(currentBlock);
+	            }
+	        }
+	        if (!unary) {
+	            depth++;
+	        }
+	    }
+	    function checkAttrs(block, attrs) {
+	        for (let i = 0; i < attrs.length; i++) {
+	            const attr = attrs[i];
+	            if (attr.name === 'lang') {
+	                block.lang = attr.value;
+	            }
+	            if (attr.name === 'scoped') {
+	                block.scoped = true;
+	            }
+	            if (attr.name === 'module') {
+	                block.module = attr.value || true;
+	            }
+	            if (attr.name === 'src') {
+	                block.src = attr.value;
+	            }
+	        }
+	    }
+	    function end(tag, start) {
+	        if (depth === 1 && currentBlock) {
+	            currentBlock.end = start;
+	            let text = content.slice(currentBlock.start, currentBlock.end);
+	            if (options.deindent !== false) {
+	                text = deIndent(text);
+	            }
+	            // pad content so that linters and pre-processors can output correct
+	            // line numbers in errors and warnings
+	            if (currentBlock.type !== 'template' && options.pad) {
+	                text = padContent(currentBlock, options.pad) + text;
+	            }
+	            currentBlock.content = text;
+	            currentBlock = null;
+	        }
+	        depth--;
+	    }
+	    function padContent(block, pad) {
+	        if (pad === 'space') {
+	            return content.slice(0, block.start).replace(replaceRE, ' ');
+	        }
+	        else {
+	            const offset = content.slice(0, block.start).split(splitRE).length;
+	            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+	            return Array(offset).join(padChar);
+	        }
+	    }
+	    parseHTML(content, {
+	        warn,
+	        start,
+	        end,
+	        outputSourceRange: options.outputSourceRange,
+	    });
+	    return sfc;
 	}
 
-	// can we use __proto__?
-	const hasProto = '__proto__' in {};
-	// Browser environment sniffing
-	const inBrowser = typeof window !== 'undefined';
-	const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-	const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-	const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-	const isIE = UA && /msie|trident/.test(UA);
-	UA && UA.indexOf('msie 9.0') > 0;
-	const isEdge = UA && UA.indexOf('edge/') > 0;
-	(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-	(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-	UA && /chrome\/\d+/.test(UA) && !isEdge;
-	UA && /phantomjs/.test(UA);
-	UA && UA.match(/firefox\/(\d+)/);
-	// Firefox has a "watch" function on Object.prototype...
-	// @ts-expect-error firebox support
-	const nativeWatch = {}.watch;
-	let supportsPassive = false;
-	if (inBrowser) {
-	    try {
-	        const opts = {};
-	        Object.defineProperty(opts, 'passive', {
-	            get() {
-	                /* istanbul ignore next */
-	                supportsPassive = true;
-	            },
-	        }); // https://github.com/facebook/flow/issues/285
-	        window.addEventListener('test-passive', null, opts);
-	    }
-	    catch (e) { }
-	}
-	// this needs to be lazy-evaled because vue may be required before
-	// vue-server-renderer can set VUE_ENV
-	let _isServer;
-	const isServerRendering = () => {
-	    if (_isServer === undefined) {
-	        /* istanbul ignore if */
-	        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-	            // detect presence of vue-server-renderer and avoid
-	            // Webpack shimming the process
-	            _isServer =
-	                global['process'] && global['process'].env.VUE_ENV === 'server';
-	        }
-	        else {
-	            _isServer = false;
-	        }
-	    }
-	    return _isServer;
-	};
-	/* istanbul ignore next */
-	function isNative(Ctor) {
-	    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-	}
-	const hasSymbol = typeof Symbol !== 'undefined' &&
-	    isNative(Symbol) &&
-	    typeof Reflect !== 'undefined' &&
-	    isNative(Reflect.ownKeys);
+	// can we use __proto__?
+	const hasProto = '__proto__' in {};
+	// Browser environment sniffing
+	const inBrowser = typeof window !== 'undefined';
+	const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+	const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+	const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+	const isIE = UA && /msie|trident/.test(UA);
+	UA && UA.indexOf('msie 9.0') > 0;
+	const isEdge = UA && UA.indexOf('edge/') > 0;
+	(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+	(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+	UA && /chrome\/\d+/.test(UA) && !isEdge;
+	UA && /phantomjs/.test(UA);
+	UA && UA.match(/firefox\/(\d+)/);
+	// Firefox has a "watch" function on Object.prototype...
+	// @ts-expect-error firebox support
+	const nativeWatch = {}.watch;
+	let supportsPassive = false;
+	if (inBrowser) {
+	    try {
+	        const opts = {};
+	        Object.defineProperty(opts, 'passive', {
+	            get() {
+	                /* istanbul ignore next */
+	                supportsPassive = true;
+	            },
+	        }); // https://github.com/facebook/flow/issues/285
+	        window.addEventListener('test-passive', null, opts);
+	    }
+	    catch (e) { }
+	}
+	// this needs to be lazy-evaled because vue may be required before
+	// vue-server-renderer can set VUE_ENV
+	let _isServer;
+	const isServerRendering = () => {
+	    if (_isServer === undefined) {
+	        /* istanbul ignore if */
+	        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+	            // detect presence of vue-server-renderer and avoid
+	            // Webpack shimming the process
+	            _isServer =
+	                global['process'] && global['process'].env.VUE_ENV === 'server';
+	        }
+	        else {
+	            _isServer = false;
+	        }
+	    }
+	    return _isServer;
+	};
+	/* istanbul ignore next */
+	function isNative(Ctor) {
+	    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+	}
+	const hasSymbol = typeof Symbol !== 'undefined' &&
+	    isNative(Symbol) &&
+	    typeof Reflect !== 'undefined' &&
+	    isNative(Reflect.ownKeys);
 	/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
 
-	const ASSET_TYPES = ['component', 'directive', 'filter'];
-	const LIFECYCLE_HOOKS = [
-	    'beforeCreate',
-	    'created',
-	    'beforeMount',
-	    'mounted',
-	    'beforeUpdate',
-	    'updated',
-	    'beforeDestroy',
-	    'destroyed',
-	    'activated',
-	    'deactivated',
-	    'errorCaptured',
-	    'serverPrefetch',
+	const ASSET_TYPES = ['component', 'directive', 'filter'];
+	const LIFECYCLE_HOOKS = [
+	    'beforeCreate',
+	    'created',
+	    'beforeMount',
+	    'mounted',
+	    'beforeUpdate',
+	    'updated',
+	    'beforeDestroy',
+	    'destroyed',
+	    'activated',
+	    'deactivated',
+	    'errorCaptured',
+	    'serverPrefetch',
 	];
 
-	var config = {
-	    /**
-	     * Option merge strategies (used in core/util/options)
-	     */
-	    // $flow-disable-line
-	    optionMergeStrategies: Object.create(null),
-	    /**
-	     * Whether to suppress warnings.
-	     */
-	    silent: false,
-	    /**
-	     * Show production mode tip message on boot?
-	     */
-	    productionTip: "development" !== 'production',
-	    /**
-	     * Whether to enable devtools
-	     */
-	    devtools: "development" !== 'production',
-	    /**
-	     * Whether to record perf
-	     */
-	    performance: false,
-	    /**
-	     * Error handler for watcher errors
-	     */
-	    errorHandler: null,
-	    /**
-	     * Warn handler for watcher warns
-	     */
-	    warnHandler: null,
-	    /**
-	     * Ignore certain custom elements
-	     */
-	    ignoredElements: [],
-	    /**
-	     * Custom user key aliases for v-on
-	     */
-	    // $flow-disable-line
-	    keyCodes: Object.create(null),
-	    /**
-	     * Check if a tag is reserved so that it cannot be registered as a
-	     * component. This is platform-dependent and may be overwritten.
-	     */
-	    isReservedTag: no,
-	    /**
-	     * Check if an attribute is reserved so that it cannot be used as a component
-	     * prop. This is platform-dependent and may be overwritten.
-	     */
-	    isReservedAttr: no,
-	    /**
-	     * Check if a tag is an unknown element.
-	     * Platform-dependent.
-	     */
-	    isUnknownElement: no,
-	    /**
-	     * Get the namespace of an element
-	     */
-	    getTagNamespace: noop,
-	    /**
-	     * Parse the real tag name for the specific platform.
-	     */
-	    parsePlatformTagName: identity,
-	    /**
-	     * Check if an attribute must be bound using property, e.g. value
-	     * Platform-dependent.
-	     */
-	    mustUseProp: no,
-	    /**
-	     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-	     * This will significantly reduce performance if set to false.
-	     */
-	    async: true,
-	    /**
-	     * Exposed for legacy reasons
-	     */
-	    _lifecycleHooks: LIFECYCLE_HOOKS,
+	var config = {
+	    /**
+	     * Option merge strategies (used in core/util/options)
+	     */
+	    // $flow-disable-line
+	    optionMergeStrategies: Object.create(null),
+	    /**
+	     * Whether to suppress warnings.
+	     */
+	    silent: false,
+	    /**
+	     * Show production mode tip message on boot?
+	     */
+	    productionTip: "development" !== 'production',
+	    /**
+	     * Whether to enable devtools
+	     */
+	    devtools: "development" !== 'production',
+	    /**
+	     * Whether to record perf
+	     */
+	    performance: false,
+	    /**
+	     * Error handler for watcher errors
+	     */
+	    errorHandler: null,
+	    /**
+	     * Warn handler for watcher warns
+	     */
+	    warnHandler: null,
+	    /**
+	     * Ignore certain custom elements
+	     */
+	    ignoredElements: [],
+	    /**
+	     * Custom user key aliases for v-on
+	     */
+	    // $flow-disable-line
+	    keyCodes: Object.create(null),
+	    /**
+	     * Check if a tag is reserved so that it cannot be registered as a
+	     * component. This is platform-dependent and may be overwritten.
+	     */
+	    isReservedTag: no,
+	    /**
+	     * Check if an attribute is reserved so that it cannot be used as a component
+	     * prop. This is platform-dependent and may be overwritten.
+	     */
+	    isReservedAttr: no,
+	    /**
+	     * Check if a tag is an unknown element.
+	     * Platform-dependent.
+	     */
+	    isUnknownElement: no,
+	    /**
+	     * Get the namespace of an element
+	     */
+	    getTagNamespace: noop,
+	    /**
+	     * Parse the real tag name for the specific platform.
+	     */
+	    parsePlatformTagName: identity,
+	    /**
+	     * Check if an attribute must be bound using property, e.g. value
+	     * Platform-dependent.
+	     */
+	    mustUseProp: no,
+	    /**
+	     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+	     * This will significantly reduce performance if set to false.
+	     */
+	    async: true,
+	    /**
+	     * Exposed for legacy reasons
+	     */
+	    _lifecycleHooks: LIFECYCLE_HOOKS,
 	};
 
-	let warn$2 = noop;
-	let tip = noop;
-	let generateComponentTrace; // work around flow check
-	let formatComponentName;
-	{
-	    const hasConsole = typeof console !== 'undefined';
-	    const classifyRE = /(?:^|[-_])(\w)/g;
-	    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-	    warn$2 = (msg, vm) => {
-	        const trace = vm ? generateComponentTrace(vm) : '';
-	        if (hasConsole && !config.silent) {
-	            console.error(`[Vue warn]: ${msg}${trace}`);
-	        }
-	    };
-	    tip = (msg, vm) => {
-	        if (hasConsole && !config.silent) {
-	            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-	        }
-	    };
-	    formatComponentName = (vm, includeFile) => {
-	        if (vm.$root === vm) {
-	            return '<Root>';
-	        }
-	        const options = typeof vm === 'function' && vm.cid != null
-	            ? vm.options
-	            : vm._isVue
-	                ? vm.$options || vm.constructor.options
-	                : vm;
-	        let name = options.name || options._componentTag;
-	        const file = options.__file;
-	        if (!name && file) {
-	            const match = file.match(/([^/\\]+)\.vue$/);
-	            name = match && match[1];
-	        }
-	        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-	            (file && includeFile !== false ? ` at ${file}` : ''));
-	    };
-	    const repeat = (str, n) => {
-	        let res = '';
-	        while (n) {
-	            if (n % 2 === 1)
-	                res += str;
-	            if (n > 1)
-	                str += str;
-	            n >>= 1;
-	        }
-	        return res;
-	    };
-	    generateComponentTrace = (vm) => {
-	        if (vm._isVue && vm.$parent) {
-	            const tree = [];
-	            let currentRecursiveSequence = 0;
-	            while (vm) {
-	                if (tree.length > 0) {
-	                    const last = tree[tree.length - 1];
-	                    if (last.constructor === vm.constructor) {
-	                        currentRecursiveSequence++;
-	                        vm = vm.$parent;
-	                        continue;
-	                    }
-	                    else if (currentRecursiveSequence > 0) {
-	                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-	                        currentRecursiveSequence = 0;
-	                    }
-	                }
-	                tree.push(vm);
-	                vm = vm.$parent;
-	            }
-	            return ('\n\nfound in\n\n' +
-	                tree
-	                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-	                    .join('\n'));
-	        }
-	        else {
-	            return `\n\n(found in ${formatComponentName(vm)})`;
-	        }
-	    };
+	let warn$2 = noop;
+	let tip = noop;
+	let generateComponentTrace; // work around flow check
+	let formatComponentName;
+	{
+	    const hasConsole = typeof console !== 'undefined';
+	    const classifyRE = /(?:^|[-_])(\w)/g;
+	    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+	    warn$2 = (msg, vm) => {
+	        const trace = vm ? generateComponentTrace(vm) : '';
+	        if (hasConsole && !config.silent) {
+	            console.error(`[Vue warn]: ${msg}${trace}`);
+	        }
+	    };
+	    tip = (msg, vm) => {
+	        if (hasConsole && !config.silent) {
+	            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+	        }
+	    };
+	    formatComponentName = (vm, includeFile) => {
+	        if (vm.$root === vm) {
+	            return '<Root>';
+	        }
+	        const options = typeof vm === 'function' && vm.cid != null
+	            ? vm.options
+	            : vm._isVue
+	                ? vm.$options || vm.constructor.options
+	                : vm;
+	        let name = options.name || options._componentTag;
+	        const file = options.__file;
+	        if (!name && file) {
+	            const match = file.match(/([^/\\]+)\.vue$/);
+	            name = match && match[1];
+	        }
+	        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+	            (file && includeFile !== false ? ` at ${file}` : ''));
+	    };
+	    const repeat = (str, n) => {
+	        let res = '';
+	        while (n) {
+	            if (n % 2 === 1)
+	                res += str;
+	            if (n > 1)
+	                str += str;
+	            n >>= 1;
+	        }
+	        return res;
+	    };
+	    generateComponentTrace = (vm) => {
+	        if (vm._isVue && vm.$parent) {
+	            const tree = [];
+	            let currentRecursiveSequence = 0;
+	            while (vm) {
+	                if (tree.length > 0) {
+	                    const last = tree[tree.length - 1];
+	                    if (last.constructor === vm.constructor) {
+	                        currentRecursiveSequence++;
+	                        vm = vm.$parent;
+	                        continue;
+	                    }
+	                    else if (currentRecursiveSequence > 0) {
+	                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+	                        currentRecursiveSequence = 0;
+	                    }
+	                }
+	                tree.push(vm);
+	                vm = vm.$parent;
+	            }
+	            return ('\n\nfound in\n\n' +
+	                tree
+	                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+	                    .join('\n'));
+	        }
+	        else {
+	            return `\n\n(found in ${formatComponentName(vm)})`;
+	        }
+	    };
 	}
 
-	let uid = 0;
-	/**
-	 * A dep is an observable that can have multiple
-	 * directives subscribing to it.
-	 */
-	class Dep {
-	    static target;
-	    id;
-	    subs;
-	    constructor() {
-	        this.id = uid++;
-	        this.subs = [];
-	    }
-	    addSub(sub) {
-	        this.subs.push(sub);
-	    }
-	    removeSub(sub) {
-	        remove(this.subs, sub);
-	    }
-	    depend() {
-	        if (Dep.target) {
-	            Dep.target.addDep(this);
-	        }
-	    }
-	    notify() {
-	        // stabilize the subscriber list first
-	        const subs = this.subs.slice();
-	        for (let i = 0, l = subs.length; i < l; i++) {
-	            subs[i].update();
-	        }
-	    }
-	}
-	// The current target watcher being evaluated.
-	// This is globally unique because only one watcher
-	// can be evaluated at a time.
+	let uid = 0;
+	/**
+	 * A dep is an observable that can have multiple
+	 * directives subscribing to it.
+	 */
+	class Dep {
+	    static target;
+	    id;
+	    subs;
+	    constructor() {
+	        this.id = uid++;
+	        this.subs = [];
+	    }
+	    addSub(sub) {
+	        this.subs.push(sub);
+	    }
+	    removeSub(sub) {
+	        remove(this.subs, sub);
+	    }
+	    depend() {
+	        if (Dep.target) {
+	            Dep.target.addDep(this);
+	        }
+	    }
+	    notify() {
+	        // stabilize the subscriber list first
+	        const subs = this.subs.slice();
+	        for (let i = 0, l = subs.length; i < l; i++) {
+	            subs[i].update();
+	        }
+	    }
+	}
+	// The current target watcher being evaluated.
+	// This is globally unique because only one watcher
+	// can be evaluated at a time.
 	Dep.target = null;
 
-	class VNode {
-	    tag;
-	    data;
-	    children;
-	    text;
-	    elm;
-	    ns;
-	    context; // rendered in this component's scope
-	    key;
-	    componentOptions;
-	    componentInstance; // component instance
-	    parent; // component placeholder node
-	    // strictly internal
-	    raw; // contains raw HTML? (server only)
-	    isStatic; // hoisted static node
-	    isRootInsert; // necessary for enter transition check
-	    isComment; // empty comment placeholder?
-	    isCloned; // is a cloned node?
-	    isOnce; // is a v-once node?
-	    asyncFactory; // async component factory function
-	    asyncMeta;
-	    isAsyncPlaceholder;
-	    ssrContext;
-	    fnContext; // real context vm for functional nodes
-	    fnOptions; // for SSR caching
-	    devtoolsMeta; // used to store functional render context for devtools
-	    fnScopeId; // functional scope id support
-	    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-	        this.tag = tag;
-	        this.data = data;
-	        this.children = children;
-	        this.text = text;
-	        this.elm = elm;
-	        this.ns = undefined;
-	        this.context = context;
-	        this.fnContext = undefined;
-	        this.fnOptions = undefined;
-	        this.fnScopeId = undefined;
-	        this.key = data && data.key;
-	        this.componentOptions = componentOptions;
-	        this.componentInstance = undefined;
-	        this.parent = undefined;
-	        this.raw = false;
-	        this.isStatic = false;
-	        this.isRootInsert = true;
-	        this.isComment = false;
-	        this.isCloned = false;
-	        this.isOnce = false;
-	        this.asyncFactory = asyncFactory;
-	        this.asyncMeta = undefined;
-	        this.isAsyncPlaceholder = false;
-	    }
-	    // DEPRECATED: alias for componentInstance for backwards compat.
-	    /* istanbul ignore next */
-	    get child() {
-	        return this.componentInstance;
-	    }
+	class VNode {
+	    tag;
+	    data;
+	    children;
+	    text;
+	    elm;
+	    ns;
+	    context; // rendered in this component's scope
+	    key;
+	    componentOptions;
+	    componentInstance; // component instance
+	    parent; // component placeholder node
+	    // strictly internal
+	    raw; // contains raw HTML? (server only)
+	    isStatic; // hoisted static node
+	    isRootInsert; // necessary for enter transition check
+	    isComment; // empty comment placeholder?
+	    isCloned; // is a cloned node?
+	    isOnce; // is a v-once node?
+	    asyncFactory; // async component factory function
+	    asyncMeta;
+	    isAsyncPlaceholder;
+	    ssrContext;
+	    fnContext; // real context vm for functional nodes
+	    fnOptions; // for SSR caching
+	    devtoolsMeta; // used to store functional render context for devtools
+	    fnScopeId; // functional scope id support
+	    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+	        this.tag = tag;
+	        this.data = data;
+	        this.children = children;
+	        this.text = text;
+	        this.elm = elm;
+	        this.ns = undefined;
+	        this.context = context;
+	        this.fnContext = undefined;
+	        this.fnOptions = undefined;
+	        this.fnScopeId = undefined;
+	        this.key = data && data.key;
+	        this.componentOptions = componentOptions;
+	        this.componentInstance = undefined;
+	        this.parent = undefined;
+	        this.raw = false;
+	        this.isStatic = false;
+	        this.isRootInsert = true;
+	        this.isComment = false;
+	        this.isCloned = false;
+	        this.isOnce = false;
+	        this.asyncFactory = asyncFactory;
+	        this.asyncMeta = undefined;
+	        this.isAsyncPlaceholder = false;
+	    }
+	    // DEPRECATED: alias for componentInstance for backwards compat.
+	    /* istanbul ignore next */
+	    get child() {
+	        return this.componentInstance;
+	    }
 	}
 
-	/*
-	 * not type checking this file because flow doesn't play well with
-	 * dynamically accessing methods on Array prototype
-	 */
-	const arrayProto = Array.prototype;
-	const arrayMethods = Object.create(arrayProto);
-	const methodsToPatch = [
-	    'push',
-	    'pop',
-	    'shift',
-	    'unshift',
-	    'splice',
-	    'sort',
-	    'reverse',
-	];
-	/**
-	 * Intercept mutating methods and emit events
-	 */
-	methodsToPatch.forEach(function (method) {
-	    // cache original method
-	    const original = arrayProto[method];
-	    def(arrayMethods, method, function mutator(...args) {
-	        const result = original.apply(this, args);
-	        const ob = this.__ob__;
-	        let inserted;
-	        switch (method) {
-	            case 'push':
-	            case 'unshift':
-	                inserted = args;
-	                break;
-	            case 'splice':
-	                inserted = args.slice(2);
-	                break;
-	        }
-	        if (inserted)
-	            ob.observeArray(inserted);
-	        // notify change
-	        ob.dep.notify();
-	        return result;
-	    });
+	/*
+	 * not type checking this file because flow doesn't play well with
+	 * dynamically accessing methods on Array prototype
+	 */
+	const arrayProto = Array.prototype;
+	const arrayMethods = Object.create(arrayProto);
+	const methodsToPatch = [
+	    'push',
+	    'pop',
+	    'shift',
+	    'unshift',
+	    'splice',
+	    'sort',
+	    'reverse',
+	];
+	/**
+	 * Intercept mutating methods and emit events
+	 */
+	methodsToPatch.forEach(function (method) {
+	    // cache original method
+	    const original = arrayProto[method];
+	    def(arrayMethods, method, function mutator(...args) {
+	        const result = original.apply(this, args);
+	        const ob = this.__ob__;
+	        let inserted;
+	        switch (method) {
+	            case 'push':
+	            case 'unshift':
+	                inserted = args;
+	                break;
+	            case 'splice':
+	                inserted = args.slice(2);
+	                break;
+	        }
+	        if (inserted)
+	            ob.observeArray(inserted);
+	        // notify change
+	        ob.dep.notify();
+	        return result;
+	    });
 	});
 
-	const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-	/**
-	 * Observer class that is attached to each observed
-	 * object. Once attached, the observer converts the target
-	 * object's property keys into getter/setters that
-	 * collect dependencies and dispatch updates.
-	 */
-	class Observer {
-	    value;
-	    dep;
-	    vmCount; // number of vms that have this object as root $data
-	    constructor(value) {
-	        this.value = value;
-	        this.dep = new Dep();
-	        this.vmCount = 0;
-	        def(value, '__ob__', this);
-	        if (Array.isArray(value)) {
-	            if (hasProto) {
-	                protoAugment(value, arrayMethods);
-	            }
-	            else {
-	                copyAugment(value, arrayMethods, arrayKeys);
-	            }
-	            this.observeArray(value);
-	        }
-	        else {
-	            this.walk(value);
-	        }
-	    }
-	    /**
-	     * Walk through all properties and convert them into
-	     * getter/setters. This method should only be called when
-	     * value type is Object.
-	     */
-	    walk(obj) {
-	        const keys = Object.keys(obj);
-	        for (let i = 0; i < keys.length; i++) {
-	            defineReactive(obj, keys[i]);
-	        }
-	    }
-	    /**
-	     * Observe a list of Array items.
-	     */
-	    observeArray(items) {
-	        for (let i = 0, l = items.length; i < l; i++) {
-	            observe(items[i]);
-	        }
-	    }
-	}
-	// helpers
-	/**
-	 * Augment a target Object or Array by intercepting
-	 * the prototype chain using __proto__
-	 */
-	function protoAugment(target, src) {
-	    /* eslint-disable no-proto */
-	    target.__proto__ = src;
-	    /* eslint-enable no-proto */
-	}
-	/**
-	 * Augment a target Object or Array by defining
-	 * hidden properties.
-	 */
-	/* istanbul ignore next */
-	function copyAugment(target, src, keys) {
-	    for (let i = 0, l = keys.length; i < l; i++) {
-	        const key = keys[i];
-	        def(target, key, src[key]);
-	    }
-	}
-	/**
-	 * Attempt to create an observer instance for a value,
-	 * returns the new observer if successfully observed,
-	 * or the existing observer if the value already has one.
-	 */
-	function observe(value, asRootData) {
-	    if (!isObject(value) || value instanceof VNode) {
-	        return;
-	    }
-	    let ob;
-	    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-	        ob = value.__ob__;
-	    }
-	    else if (!isServerRendering() &&
-	        (Array.isArray(value) || isPlainObject(value)) &&
-	        Object.isExtensible(value) &&
-	        !value._isVue) {
-	        ob = new Observer(value);
-	    }
-	    if (asRootData && ob) {
-	        ob.vmCount++;
-	    }
-	    return ob;
-	}
-	/**
-	 * Define a reactive property on an Object.
-	 */
-	function defineReactive(obj, key, val, customSetter, shallow) {
-	    const dep = new Dep();
-	    const property = Object.getOwnPropertyDescriptor(obj, key);
-	    if (property && property.configurable === false) {
-	        return;
-	    }
-	    // cater for pre-defined getter/setters
-	    const getter = property && property.get;
-	    const setter = property && property.set;
-	    if ((!getter || setter) && arguments.length === 2) {
-	        val = obj[key];
-	    }
-	    let childOb = !shallow && observe(val);
-	    Object.defineProperty(obj, key, {
-	        enumerable: true,
-	        configurable: true,
-	        get: function reactiveGetter() {
-	            const value = getter ? getter.call(obj) : val;
-	            if (Dep.target) {
-	                dep.depend();
-	                if (childOb) {
-	                    childOb.dep.depend();
-	                    if (Array.isArray(value)) {
-	                        dependArray(value);
-	                    }
-	                }
-	            }
-	            return value;
-	        },
-	        set: function reactiveSetter(newVal) {
-	            const value = getter ? getter.call(obj) : val;
-	            /* eslint-disable no-self-compare */
-	            if (newVal === value || (newVal !== newVal && value !== value)) {
-	                return;
-	            }
-	            /* eslint-enable no-self-compare */
-	            if (customSetter) {
-	                customSetter();
-	            }
-	            // #7981: for accessor properties without setter
-	            if (getter && !setter)
-	                return;
-	            if (setter) {
-	                setter.call(obj, newVal);
-	            }
-	            else {
-	                val = newVal;
-	            }
-	            childOb = !shallow && observe(newVal);
-	            dep.notify();
-	        },
-	    });
-	}
-	/**
-	 * Set a property on an object. Adds the new property and
-	 * triggers change notification if the property doesn't
-	 * already exist.
-	 */
-	function set(target, key, val) {
-	    if ((isUndef(target) || isPrimitive(target))) {
-	        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-	    }
-	    if (Array.isArray(target) && isValidArrayIndex(key)) {
-	        target.length = Math.max(target.length, key);
-	        target.splice(key, 1, val);
-	        return val;
-	    }
-	    if (key in target && !(key in Object.prototype)) {
-	        target[key] = val;
-	        return val;
-	    }
-	    const ob = target.__ob__;
-	    if (target._isVue || (ob && ob.vmCount)) {
-	        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-	                'at runtime - declare it upfront in the data option.');
-	        return val;
-	    }
-	    if (!ob) {
-	        target[key] = val;
-	        return val;
-	    }
-	    defineReactive(ob.value, key, val);
-	    ob.dep.notify();
-	    return val;
-	}
-	/**
-	 * Collect dependencies on array elements when the array is touched, since
-	 * we cannot intercept array element access like property getters.
-	 */
-	function dependArray(value) {
-	    for (let e, i = 0, l = value.length; i < l; i++) {
-	        e = value[i];
-	        e && e.__ob__ && e.__ob__.dep.depend();
-	        if (Array.isArray(e)) {
-	            dependArray(e);
-	        }
-	    }
+	const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+	/**
+	 * Observer class that is attached to each observed
+	 * object. Once attached, the observer converts the target
+	 * object's property keys into getter/setters that
+	 * collect dependencies and dispatch updates.
+	 */
+	class Observer {
+	    value;
+	    dep;
+	    vmCount; // number of vms that have this object as root $data
+	    constructor(value) {
+	        this.value = value;
+	        this.dep = new Dep();
+	        this.vmCount = 0;
+	        def(value, '__ob__', this);
+	        if (Array.isArray(value)) {
+	            if (hasProto) {
+	                protoAugment(value, arrayMethods);
+	            }
+	            else {
+	                copyAugment(value, arrayMethods, arrayKeys);
+	            }
+	            this.observeArray(value);
+	        }
+	        else {
+	            this.walk(value);
+	        }
+	    }
+	    /**
+	     * Walk through all properties and convert them into
+	     * getter/setters. This method should only be called when
+	     * value type is Object.
+	     */
+	    walk(obj) {
+	        const keys = Object.keys(obj);
+	        for (let i = 0; i < keys.length; i++) {
+	            defineReactive(obj, keys[i]);
+	        }
+	    }
+	    /**
+	     * Observe a list of Array items.
+	     */
+	    observeArray(items) {
+	        for (let i = 0, l = items.length; i < l; i++) {
+	            observe(items[i]);
+	        }
+	    }
+	}
+	// helpers
+	/**
+	 * Augment a target Object or Array by intercepting
+	 * the prototype chain using __proto__
+	 */
+	function protoAugment(target, src) {
+	    /* eslint-disable no-proto */
+	    target.__proto__ = src;
+	    /* eslint-enable no-proto */
+	}
+	/**
+	 * Augment a target Object or Array by defining
+	 * hidden properties.
+	 */
+	/* istanbul ignore next */
+	function copyAugment(target, src, keys) {
+	    for (let i = 0, l = keys.length; i < l; i++) {
+	        const key = keys[i];
+	        def(target, key, src[key]);
+	    }
+	}
+	/**
+	 * Attempt to create an observer instance for a value,
+	 * returns the new observer if successfully observed,
+	 * or the existing observer if the value already has one.
+	 */
+	function observe(value, asRootData) {
+	    if (!isObject(value) || value instanceof VNode) {
+	        return;
+	    }
+	    let ob;
+	    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+	        ob = value.__ob__;
+	    }
+	    else if (!isServerRendering() &&
+	        (Array.isArray(value) || isPlainObject(value)) &&
+	        Object.isExtensible(value) &&
+	        !value._isVue) {
+	        ob = new Observer(value);
+	    }
+	    if (asRootData && ob) {
+	        ob.vmCount++;
+	    }
+	    return ob;
+	}
+	/**
+	 * Define a reactive property on an Object.
+	 */
+	function defineReactive(obj, key, val, customSetter, shallow) {
+	    const dep = new Dep();
+	    const property = Object.getOwnPropertyDescriptor(obj, key);
+	    if (property && property.configurable === false) {
+	        return;
+	    }
+	    // cater for pre-defined getter/setters
+	    const getter = property && property.get;
+	    const setter = property && property.set;
+	    if ((!getter || setter) && arguments.length === 2) {
+	        val = obj[key];
+	    }
+	    let childOb = !shallow && observe(val);
+	    Object.defineProperty(obj, key, {
+	        enumerable: true,
+	        configurable: true,
+	        get: function reactiveGetter() {
+	            const value = getter ? getter.call(obj) : val;
+	            if (Dep.target) {
+	                dep.depend();
+	                if (childOb) {
+	                    childOb.dep.depend();
+	                    if (Array.isArray(value)) {
+	                        dependArray(value);
+	                    }
+	                }
+	            }
+	            return value;
+	        },
+	        set: function reactiveSetter(newVal) {
+	            const value = getter ? getter.call(obj) : val;
+	            /* eslint-disable no-self-compare */
+	            if (newVal === value || (newVal !== newVal && value !== value)) {
+	                return;
+	            }
+	            /* eslint-enable no-self-compare */
+	            if (customSetter) {
+	                customSetter();
+	            }
+	            // #7981: for accessor properties without setter
+	            if (getter && !setter)
+	                return;
+	            if (setter) {
+	                setter.call(obj, newVal);
+	            }
+	            else {
+	                val = newVal;
+	            }
+	            childOb = !shallow && observe(newVal);
+	            dep.notify();
+	        },
+	    });
+	}
+	/**
+	 * Set a property on an object. Adds the new property and
+	 * triggers change notification if the property doesn't
+	 * already exist.
+	 */
+	function set(target, key, val) {
+	    if ((isUndef(target) || isPrimitive(target))) {
+	        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+	    }
+	    if (Array.isArray(target) && isValidArrayIndex(key)) {
+	        target.length = Math.max(target.length, key);
+	        target.splice(key, 1, val);
+	        return val;
+	    }
+	    if (key in target && !(key in Object.prototype)) {
+	        target[key] = val;
+	        return val;
+	    }
+	    const ob = target.__ob__;
+	    if (target._isVue || (ob && ob.vmCount)) {
+	        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+	                'at runtime - declare it upfront in the data option.');
+	        return val;
+	    }
+	    if (!ob) {
+	        target[key] = val;
+	        return val;
+	    }
+	    defineReactive(ob.value, key, val);
+	    ob.dep.notify();
+	    return val;
+	}
+	/**
+	 * Collect dependencies on array elements when the array is touched, since
+	 * we cannot intercept array element access like property getters.
+	 */
+	function dependArray(value) {
+	    for (let e, i = 0, l = value.length; i < l; i++) {
+	        e = value[i];
+	        e && e.__ob__ && e.__ob__.dep.depend();
+	        if (Array.isArray(e)) {
+	            dependArray(e);
+	        }
+	    }
 	}
 
-	/**
-	 * Option overwriting strategies are functions that handle
-	 * how to merge a parent option value and a child option
-	 * value into the final value.
-	 */
-	const strats = config.optionMergeStrategies;
-	/**
-	 * Options with restrictions
-	 */
-	{
-	    strats.el = strats.propsData = function (parent, child, vm, key) {
-	        if (!vm) {
-	            warn$2(`option "${key}" can only be used during instance ` +
-	                'creation with the `new` keyword.');
-	        }
-	        return defaultStrat(parent, child);
-	    };
-	}
-	/**
-	 * Helper that recursively merges two data objects together.
-	 */
-	function mergeData(to, from) {
-	    if (!from)
-	        return to;
-	    let key, toVal, fromVal;
-	    const keys = hasSymbol
-	        ? Reflect.ownKeys(from)
-	        : Object.keys(from);
-	    for (let i = 0; i < keys.length; i++) {
-	        key = keys[i];
-	        // in case the object is already observed...
-	        if (key === '__ob__')
-	            continue;
-	        toVal = to[key];
-	        fromVal = from[key];
-	        if (!hasOwn(to, key)) {
-	            set(to, key, fromVal);
-	        }
-	        else if (toVal !== fromVal &&
-	            isPlainObject(toVal) &&
-	            isPlainObject(fromVal)) {
-	            mergeData(toVal, fromVal);
-	        }
-	    }
-	    return to;
-	}
-	/**
-	 * Data
-	 */
-	function mergeDataOrFn(parentVal, childVal, vm) {
-	    if (!vm) {
-	        // in a Vue.extend merge, both should be functions
-	        if (!childVal) {
-	            return parentVal;
-	        }
-	        if (!parentVal) {
-	            return childVal;
-	        }
-	        // when parentVal & childVal are both present,
-	        // we need to return a function that returns the
-	        // merged result of both functions... no need to
-	        // check if parentVal is a function here because
-	        // it has to be a function to pass previous merges.
-	        return function mergedDataFn() {
-	            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-	        };
-	    }
-	    else {
-	        return function mergedInstanceDataFn() {
-	            // instance merge
-	            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-	            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-	            if (instanceData) {
-	                return mergeData(instanceData, defaultData);
-	            }
-	            else {
-	                return defaultData;
-	            }
-	        };
-	    }
-	}
-	strats.data = function (parentVal, childVal, vm) {
-	    if (!vm) {
-	        if (childVal && typeof childVal !== 'function') {
-	            warn$2('The "data" option should be a function ' +
-	                    'that returns a per-instance value in component ' +
-	                    'definitions.', vm);
-	            return parentVal;
-	        }
-	        return mergeDataOrFn(parentVal, childVal);
-	    }
-	    return mergeDataOrFn(parentVal, childVal, vm);
-	};
-	/**
-	 * Hooks and props are merged as arrays.
-	 */
-	function mergeHook(parentVal, childVal) {
-	    const res = childVal
-	        ? parentVal
-	            ? parentVal.concat(childVal)
-	            : Array.isArray(childVal)
-	                ? childVal
-	                : [childVal]
-	        : parentVal;
-	    return res ? dedupeHooks(res) : res;
-	}
-	function dedupeHooks(hooks) {
-	    const res = [];
-	    for (let i = 0; i < hooks.length; i++) {
-	        if (res.indexOf(hooks[i]) === -1) {
-	            res.push(hooks[i]);
-	        }
-	    }
-	    return res;
-	}
-	LIFECYCLE_HOOKS.forEach((hook) => {
-	    strats[hook] = mergeHook;
-	});
-	/**
-	 * Assets
-	 *
-	 * When a vm is present (instance creation), we need to do
-	 * a three-way merge between constructor options, instance
-	 * options and parent options.
-	 */
-	function mergeAssets(parentVal, childVal, vm, key) {
-	    const res = Object.create(parentVal || null);
-	    if (childVal) {
-	        assertObjectType(key, childVal, vm);
-	        return extend(res, childVal);
-	    }
-	    else {
-	        return res;
-	    }
-	}
-	ASSET_TYPES.forEach(function (type) {
-	    strats[type + 's'] = mergeAssets;
-	});
-	/**
-	 * Watchers.
-	 *
-	 * Watchers hashes should not overwrite one
-	 * another, so we merge them as arrays.
-	 */
-	strats.watch = function (parentVal, childVal, vm, key) {
-	    // work around Firefox's Object.prototype.watch...
-	    //@ts-expect-error work around
-	    if (parentVal === nativeWatch)
-	        parentVal = undefined;
-	    //@ts-expect-error work around
-	    if (childVal === nativeWatch)
-	        childVal = undefined;
-	    /* istanbul ignore if */
-	    if (!childVal)
-	        return Object.create(parentVal || null);
-	    {
-	        assertObjectType(key, childVal, vm);
-	    }
-	    if (!parentVal)
-	        return childVal;
-	    const ret = {};
-	    extend(ret, parentVal);
-	    for (const key in childVal) {
-	        let parent = ret[key];
-	        const child = childVal[key];
-	        if (parent && !Array.isArray(parent)) {
-	            parent = [parent];
-	        }
-	        ret[key] = parent
-	            ? parent.concat(child)
-	            : Array.isArray(child)
-	                ? child
-	                : [child];
-	    }
-	    return ret;
-	};
-	/**
-	 * Other object hashes.
-	 */
-	strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-	    if (childVal && "development" !== 'production') {
-	        assertObjectType(key, childVal, vm);
-	    }
-	    if (!parentVal)
-	        return childVal;
-	    const ret = Object.create(null);
-	    extend(ret, parentVal);
-	    if (childVal)
-	        extend(ret, childVal);
-	    return ret;
-	};
-	strats.provide = mergeDataOrFn;
-	/**
-	 * Default strategy.
-	 */
-	const defaultStrat = function (parentVal, childVal) {
-	    return childVal === undefined ? parentVal : childVal;
-	};
-	function assertObjectType(name, value, vm) {
-	    if (!isPlainObject(value)) {
-	        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-	            `but got ${toRawType(value)}.`, vm);
-	    }
+	/**
+	 * Option overwriting strategies are functions that handle
+	 * how to merge a parent option value and a child option
+	 * value into the final value.
+	 */
+	const strats = config.optionMergeStrategies;
+	/**
+	 * Options with restrictions
+	 */
+	{
+	    strats.el = strats.propsData = function (parent, child, vm, key) {
+	        if (!vm) {
+	            warn$2(`option "${key}" can only be used during instance ` +
+	                'creation with the `new` keyword.');
+	        }
+	        return defaultStrat(parent, child);
+	    };
+	}
+	/**
+	 * Helper that recursively merges two data objects together.
+	 */
+	function mergeData(to, from) {
+	    if (!from)
+	        return to;
+	    let key, toVal, fromVal;
+	    const keys = hasSymbol
+	        ? Reflect.ownKeys(from)
+	        : Object.keys(from);
+	    for (let i = 0; i < keys.length; i++) {
+	        key = keys[i];
+	        // in case the object is already observed...
+	        if (key === '__ob__')
+	            continue;
+	        toVal = to[key];
+	        fromVal = from[key];
+	        if (!hasOwn(to, key)) {
+	            set(to, key, fromVal);
+	        }
+	        else if (toVal !== fromVal &&
+	            isPlainObject(toVal) &&
+	            isPlainObject(fromVal)) {
+	            mergeData(toVal, fromVal);
+	        }
+	    }
+	    return to;
+	}
+	/**
+	 * Data
+	 */
+	function mergeDataOrFn(parentVal, childVal, vm) {
+	    if (!vm) {
+	        // in a Vue.extend merge, both should be functions
+	        if (!childVal) {
+	            return parentVal;
+	        }
+	        if (!parentVal) {
+	            return childVal;
+	        }
+	        // when parentVal & childVal are both present,
+	        // we need to return a function that returns the
+	        // merged result of both functions... no need to
+	        // check if parentVal is a function here because
+	        // it has to be a function to pass previous merges.
+	        return function mergedDataFn() {
+	            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+	        };
+	    }
+	    else {
+	        return function mergedInstanceDataFn() {
+	            // instance merge
+	            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+	            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+	            if (instanceData) {
+	                return mergeData(instanceData, defaultData);
+	            }
+	            else {
+	                return defaultData;
+	            }
+	        };
+	    }
+	}
+	strats.data = function (parentVal, childVal, vm) {
+	    if (!vm) {
+	        if (childVal && typeof childVal !== 'function') {
+	            warn$2('The "data" option should be a function ' +
+	                    'that returns a per-instance value in component ' +
+	                    'definitions.', vm);
+	            return parentVal;
+	        }
+	        return mergeDataOrFn(parentVal, childVal);
+	    }
+	    return mergeDataOrFn(parentVal, childVal, vm);
+	};
+	/**
+	 * Hooks and props are merged as arrays.
+	 */
+	function mergeHook(parentVal, childVal) {
+	    const res = childVal
+	        ? parentVal
+	            ? parentVal.concat(childVal)
+	            : Array.isArray(childVal)
+	                ? childVal
+	                : [childVal]
+	        : parentVal;
+	    return res ? dedupeHooks(res) : res;
+	}
+	function dedupeHooks(hooks) {
+	    const res = [];
+	    for (let i = 0; i < hooks.length; i++) {
+	        if (res.indexOf(hooks[i]) === -1) {
+	            res.push(hooks[i]);
+	        }
+	    }
+	    return res;
+	}
+	LIFECYCLE_HOOKS.forEach((hook) => {
+	    strats[hook] = mergeHook;
+	});
+	/**
+	 * Assets
+	 *
+	 * When a vm is present (instance creation), we need to do
+	 * a three-way merge between constructor options, instance
+	 * options and parent options.
+	 */
+	function mergeAssets(parentVal, childVal, vm, key) {
+	    const res = Object.create(parentVal || null);
+	    if (childVal) {
+	        assertObjectType(key, childVal, vm);
+	        return extend(res, childVal);
+	    }
+	    else {
+	        return res;
+	    }
+	}
+	ASSET_TYPES.forEach(function (type) {
+	    strats[type + 's'] = mergeAssets;
+	});
+	/**
+	 * Watchers.
+	 *
+	 * Watchers hashes should not overwrite one
+	 * another, so we merge them as arrays.
+	 */
+	strats.watch = function (parentVal, childVal, vm, key) {
+	    // work around Firefox's Object.prototype.watch...
+	    //@ts-expect-error work around
+	    if (parentVal === nativeWatch)
+	        parentVal = undefined;
+	    //@ts-expect-error work around
+	    if (childVal === nativeWatch)
+	        childVal = undefined;
+	    /* istanbul ignore if */
+	    if (!childVal)
+	        return Object.create(parentVal || null);
+	    {
+	        assertObjectType(key, childVal, vm);
+	    }
+	    if (!parentVal)
+	        return childVal;
+	    const ret = {};
+	    extend(ret, parentVal);
+	    for (const key in childVal) {
+	        let parent = ret[key];
+	        const child = childVal[key];
+	        if (parent && !Array.isArray(parent)) {
+	            parent = [parent];
+	        }
+	        ret[key] = parent
+	            ? parent.concat(child)
+	            : Array.isArray(child)
+	                ? child
+	                : [child];
+	    }
+	    return ret;
+	};
+	/**
+	 * Other object hashes.
+	 */
+	strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+	    if (childVal && "development" !== 'production') {
+	        assertObjectType(key, childVal, vm);
+	    }
+	    if (!parentVal)
+	        return childVal;
+	    const ret = Object.create(null);
+	    extend(ret, parentVal);
+	    if (childVal)
+	        extend(ret, childVal);
+	    return ret;
+	};
+	strats.provide = mergeDataOrFn;
+	/**
+	 * Default strategy.
+	 */
+	const defaultStrat = function (parentVal, childVal) {
+	    return childVal === undefined ? parentVal : childVal;
+	};
+	function assertObjectType(name, value, vm) {
+	    if (!isPlainObject(value)) {
+	        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+	            `but got ${toRawType(value)}.`, vm);
+	    }
 	}
 
-	/* globals MutationObserver */
-	const callbacks = [];
-	function flushCallbacks() {
-	    const copies = callbacks.slice(0);
-	    callbacks.length = 0;
-	    for (let i = 0; i < copies.length; i++) {
-	        copies[i]();
-	    }
-	}
-	// The nextTick behavior leverages the microtask queue, which can be accessed
-	// via either native Promise.then or MutationObserver.
-	// MutationObserver has wider support, however it is seriously bugged in
-	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-	// completely stops working after triggering a few times... so, if native
-	// Promise is available, we will use it:
-	/* istanbul ignore next, $flow-disable-line */
-	if (typeof Promise !== 'undefined' && isNative(Promise)) {
-	    Promise.resolve();
-	}
-	else if (!isIE &&
-	    typeof MutationObserver !== 'undefined' &&
-	    (isNative(MutationObserver) ||
-	        // PhantomJS and iOS 7.x
-	        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-	    // Use MutationObserver where native Promise is not available,
-	    // e.g. PhantomJS, iOS7, Android 4.4
-	    // (#6466 MutationObserver is unreliable in IE11)
-	    let counter = 1;
-	    const observer = new MutationObserver(flushCallbacks);
-	    const textNode = document.createTextNode(String(counter));
-	    observer.observe(textNode, {
-	        characterData: true,
-	    });
-	}
-	else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+	/* globals MutationObserver */
+	const callbacks = [];
+	function flushCallbacks() {
+	    const copies = callbacks.slice(0);
+	    callbacks.length = 0;
+	    for (let i = 0; i < copies.length; i++) {
+	        copies[i]();
+	    }
+	}
+	// The nextTick behavior leverages the microtask queue, which can be accessed
+	// via either native Promise.then or MutationObserver.
+	// MutationObserver has wider support, however it is seriously bugged in
+	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+	// completely stops working after triggering a few times... so, if native
+	// Promise is available, we will use it:
+	/* istanbul ignore next, $flow-disable-line */
+	if (typeof Promise !== 'undefined' && isNative(Promise)) {
+	    Promise.resolve();
+	}
+	else if (!isIE &&
+	    typeof MutationObserver !== 'undefined' &&
+	    (isNative(MutationObserver) ||
+	        // PhantomJS and iOS 7.x
+	        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+	    // Use MutationObserver where native Promise is not available,
+	    // e.g. PhantomJS, iOS7, Android 4.4
+	    // (#6466 MutationObserver is unreliable in IE11)
+	    let counter = 1;
+	    const observer = new MutationObserver(flushCallbacks);
+	    const textNode = document.createTextNode(String(counter));
+	    observer.observe(textNode, {
+	        characterData: true,
+	    });
+	}
+	else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 	else ;
 
-	// these are reserved for web because they are directly compiled away
-	// during template compilation
-	makeMap('style,class');
-	// attributes that should be using props for binding
-	const acceptValue = makeMap('input,textarea,option,select,progress');
-	const mustUseProp = (tag, type, attr) => {
-	    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-	        (attr === 'selected' && tag === 'option') ||
-	        (attr === 'checked' && tag === 'input') ||
-	        (attr === 'muted' && tag === 'video'));
-	};
-	const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-	makeMap('events,caret,typing,plaintext-only');
-	const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-	    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-	    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-	    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-	    'required,reversed,scoped,seamless,selected,sortable,' +
+	// these are reserved for web because they are directly compiled away
+	// during template compilation
+	makeMap('style,class');
+	// attributes that should be using props for binding
+	const acceptValue = makeMap('input,textarea,option,select,progress');
+	const mustUseProp = (tag, type, attr) => {
+	    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+	        (attr === 'selected' && tag === 'option') ||
+	        (attr === 'checked' && tag === 'input') ||
+	        (attr === 'muted' && tag === 'video'));
+	};
+	const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+	makeMap('events,caret,typing,plaintext-only');
+	const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+	    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+	    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+	    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+	    'required,reversed,scoped,seamless,selected,sortable,' +
 	    'truespeed,typemustmatch,visible');
 
-	const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-	    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-	    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-	    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-	    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-	    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-	    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-	    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-	    'output,progress,select,textarea,' +
-	    'details,dialog,menu,menuitem,summary,' +
-	    'content,element,shadow,template,blockquote,iframe,tfoot');
-	// this map is intentionally selective, only covering SVG elements that may
-	// contain child elements.
-	const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-	    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-	    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-	const isPreTag = (tag) => tag === 'pre';
-	const isReservedTag = (tag) => {
-	    return isHTMLTag(tag) || isSVG(tag);
-	};
-	function getTagNamespace(tag) {
-	    if (isSVG(tag)) {
-	        return 'svg';
-	    }
-	    // basic support for MathML
-	    // note it doesn't support other MathML elements being component roots
-	    if (tag === 'math') {
-	        return 'math';
-	    }
-	}
+	const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+	    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+	    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+	    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+	    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+	    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+	    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+	    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+	    'output,progress,select,textarea,' +
+	    'details,dialog,menu,menuitem,summary,' +
+	    'content,element,shadow,template,blockquote,iframe,tfoot');
+	// this map is intentionally selective, only covering SVG elements that may
+	// contain child elements.
+	const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+	    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+	    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+	const isPreTag = (tag) => tag === 'pre';
+	const isReservedTag = (tag) => {
+	    return isHTMLTag(tag) || isSVG(tag);
+	};
+	function getTagNamespace(tag) {
+	    if (isSVG(tag)) {
+	        return 'svg';
+	    }
+	    // basic support for MathML
+	    // note it doesn't support other MathML elements being component roots
+	    if (tag === 'math') {
+	        return 'math';
+	    }
+	}
 	makeMap('text,number,password,search,email,tel,url');
 
-	const validDivisionCharRE = /[\w).+\-_$\]]/;
-	function parseFilters(exp) {
-	    let inSingle = false;
-	    let inDouble = false;
-	    let inTemplateString = false;
-	    let inRegex = false;
-	    let curly = 0;
-	    let square = 0;
-	    let paren = 0;
-	    let lastFilterIndex = 0;
-	    let c, prev, i, expression, filters;
-	    for (i = 0; i < exp.length; i++) {
-	        prev = c;
-	        c = exp.charCodeAt(i);
-	        if (inSingle) {
-	            if (c === 0x27 && prev !== 0x5c)
-	                inSingle = false;
-	        }
-	        else if (inDouble) {
-	            if (c === 0x22 && prev !== 0x5c)
-	                inDouble = false;
-	        }
-	        else if (inTemplateString) {
-	            if (c === 0x60 && prev !== 0x5c)
-	                inTemplateString = false;
-	        }
-	        else if (inRegex) {
-	            if (c === 0x2f && prev !== 0x5c)
-	                inRegex = false;
-	        }
-	        else if (c === 0x7c && // pipe
-	            exp.charCodeAt(i + 1) !== 0x7c &&
-	            exp.charCodeAt(i - 1) !== 0x7c &&
-	            !curly &&
-	            !square &&
-	            !paren) {
-	            if (expression === undefined) {
-	                // first filter, end of expression
-	                lastFilterIndex = i + 1;
-	                expression = exp.slice(0, i).trim();
-	            }
-	            else {
-	                pushFilter();
-	            }
-	        }
-	        else {
-	            switch (c) {
-	                case 0x22:
-	                    inDouble = true;
-	                    break; // "
-	                case 0x27:
-	                    inSingle = true;
-	                    break; // '
-	                case 0x60:
-	                    inTemplateString = true;
-	                    break; // `
-	                case 0x28:
-	                    paren++;
-	                    break; // (
-	                case 0x29:
-	                    paren--;
-	                    break; // )
-	                case 0x5b:
-	                    square++;
-	                    break; // [
-	                case 0x5d:
-	                    square--;
-	                    break; // ]
-	                case 0x7b:
-	                    curly++;
-	                    break; // {
-	                case 0x7d:
-	                    curly--;
-	                    break; // }
-	            }
-	            if (c === 0x2f) {
-	                // /
-	                let j = i - 1;
-	                let p;
-	                // find first non-whitespace prev char
-	                for (; j >= 0; j--) {
-	                    p = exp.charAt(j);
-	                    if (p !== ' ')
-	                        break;
-	                }
-	                if (!p || !validDivisionCharRE.test(p)) {
-	                    inRegex = true;
-	                }
-	            }
-	        }
-	    }
-	    if (expression === undefined) {
-	        expression = exp.slice(0, i).trim();
-	    }
-	    else if (lastFilterIndex !== 0) {
-	        pushFilter();
-	    }
-	    function pushFilter() {
-	        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-	        lastFilterIndex = i + 1;
-	    }
-	    if (filters) {
-	        for (i = 0; i < filters.length; i++) {
-	            expression = wrapFilter(expression, filters[i]);
-	        }
-	    }
-	    return expression;
-	}
-	function wrapFilter(exp, filter) {
-	    const i = filter.indexOf('(');
-	    if (i < 0) {
-	        // _f: resolveFilter
-	        return `_f("${filter}")(${exp})`;
-	    }
-	    else {
-	        const name = filter.slice(0, i);
-	        const args = filter.slice(i + 1);
-	        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-	    }
+	const validDivisionCharRE = /[\w).+\-_$\]]/;
+	function parseFilters(exp) {
+	    let inSingle = false;
+	    let inDouble = false;
+	    let inTemplateString = false;
+	    let inRegex = false;
+	    let curly = 0;
+	    let square = 0;
+	    let paren = 0;
+	    let lastFilterIndex = 0;
+	    let c, prev, i, expression, filters;
+	    for (i = 0; i < exp.length; i++) {
+	        prev = c;
+	        c = exp.charCodeAt(i);
+	        if (inSingle) {
+	            if (c === 0x27 && prev !== 0x5c)
+	                inSingle = false;
+	        }
+	        else if (inDouble) {
+	            if (c === 0x22 && prev !== 0x5c)
+	                inDouble = false;
+	        }
+	        else if (inTemplateString) {
+	            if (c === 0x60 && prev !== 0x5c)
+	                inTemplateString = false;
+	        }
+	        else if (inRegex) {
+	            if (c === 0x2f && prev !== 0x5c)
+	                inRegex = false;
+	        }
+	        else if (c === 0x7c && // pipe
+	            exp.charCodeAt(i + 1) !== 0x7c &&
+	            exp.charCodeAt(i - 1) !== 0x7c &&
+	            !curly &&
+	            !square &&
+	            !paren) {
+	            if (expression === undefined) {
+	                // first filter, end of expression
+	                lastFilterIndex = i + 1;
+	                expression = exp.slice(0, i).trim();
+	            }
+	            else {
+	                pushFilter();
+	            }
+	        }
+	        else {
+	            switch (c) {
+	                case 0x22:
+	                    inDouble = true;
+	                    break; // "
+	                case 0x27:
+	                    inSingle = true;
+	                    break; // '
+	                case 0x60:
+	                    inTemplateString = true;
+	                    break; // `
+	                case 0x28:
+	                    paren++;
+	                    break; // (
+	                case 0x29:
+	                    paren--;
+	                    break; // )
+	                case 0x5b:
+	                    square++;
+	                    break; // [
+	                case 0x5d:
+	                    square--;
+	                    break; // ]
+	                case 0x7b:
+	                    curly++;
+	                    break; // {
+	                case 0x7d:
+	                    curly--;
+	                    break; // }
+	            }
+	            if (c === 0x2f) {
+	                // /
+	                let j = i - 1;
+	                let p;
+	                // find first non-whitespace prev char
+	                for (; j >= 0; j--) {
+	                    p = exp.charAt(j);
+	                    if (p !== ' ')
+	                        break;
+	                }
+	                if (!p || !validDivisionCharRE.test(p)) {
+	                    inRegex = true;
+	                }
+	            }
+	        }
+	    }
+	    if (expression === undefined) {
+	        expression = exp.slice(0, i).trim();
+	    }
+	    else if (lastFilterIndex !== 0) {
+	        pushFilter();
+	    }
+	    function pushFilter() {
+	        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+	        lastFilterIndex = i + 1;
+	    }
+	    if (filters) {
+	        for (i = 0; i < filters.length; i++) {
+	            expression = wrapFilter(expression, filters[i]);
+	        }
+	    }
+	    return expression;
+	}
+	function wrapFilter(exp, filter) {
+	    const i = filter.indexOf('(');
+	    if (i < 0) {
+	        // _f: resolveFilter
+	        return `_f("${filter}")(${exp})`;
+	    }
+	    else {
+	        const name = filter.slice(0, i);
+	        const args = filter.slice(i + 1);
+	        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+	    }
 	}
 
-	const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-	const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-	const buildRegex = cached((delimiters) => {
-	    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-	    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-	    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-	});
-	function parseText(text, delimiters) {
-	    //@ts-expect-error
-	    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-	    if (!tagRE.test(text)) {
-	        return;
-	    }
-	    const tokens = [];
-	    const rawTokens = [];
-	    let lastIndex = (tagRE.lastIndex = 0);
-	    let match, index, tokenValue;
-	    while ((match = tagRE.exec(text))) {
-	        index = match.index;
-	        // push text token
-	        if (index > lastIndex) {
-	            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-	            tokens.push(JSON.stringify(tokenValue));
-	        }
-	        // tag token
-	        const exp = parseFilters(match[1].trim());
-	        tokens.push(`_s(${exp})`);
-	        rawTokens.push({ '@binding': exp });
-	        lastIndex = index + match[0].length;
-	    }
-	    if (lastIndex < text.length) {
-	        rawTokens.push((tokenValue = text.slice(lastIndex)));
-	        tokens.push(JSON.stringify(tokenValue));
-	    }
-	    return {
-	        expression: tokens.join('+'),
-	        tokens: rawTokens,
-	    };
+	const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+	const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+	const buildRegex = cached((delimiters) => {
+	    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+	    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+	    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+	});
+	function parseText(text, delimiters) {
+	    //@ts-expect-error
+	    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+	    if (!tagRE.test(text)) {
+	        return;
+	    }
+	    const tokens = [];
+	    const rawTokens = [];
+	    let lastIndex = (tagRE.lastIndex = 0);
+	    let match, index, tokenValue;
+	    while ((match = tagRE.exec(text))) {
+	        index = match.index;
+	        // push text token
+	        if (index > lastIndex) {
+	            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+	            tokens.push(JSON.stringify(tokenValue));
+	        }
+	        // tag token
+	        const exp = parseFilters(match[1].trim());
+	        tokens.push(`_s(${exp})`);
+	        rawTokens.push({ '@binding': exp });
+	        lastIndex = index + match[0].length;
+	    }
+	    if (lastIndex < text.length) {
+	        rawTokens.push((tokenValue = text.slice(lastIndex)));
+	        tokens.push(JSON.stringify(tokenValue));
+	    }
+	    return {
+	        expression: tokens.join('+'),
+	        tokens: rawTokens,
+	    };
 	}
 
-	/* eslint-disable no-unused-vars */
-	function baseWarn(msg, range) {
-	    console.error(`[Vue compiler]: ${msg}`);
-	}
-	/* eslint-enable no-unused-vars */
-	function pluckModuleFunction(modules, key) {
-	    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-	}
-	function addProp(el, name, value, range, dynamic) {
-	    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-	    el.plain = false;
-	}
-	function addAttr(el, name, value, range, dynamic) {
-	    const attrs = dynamic
-	        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-	        : el.attrs || (el.attrs = []);
-	    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-	    el.plain = false;
-	}
-	// add a raw attr (use this in preTransforms)
-	function addRawAttr(el, name, value, range) {
-	    el.attrsMap[name] = value;
-	    el.attrsList.push(rangeSetItem({ name, value }, range));
-	}
-	function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-	    (el.directives || (el.directives = [])).push(rangeSetItem({
-	        name,
-	        rawName,
-	        value,
-	        arg,
-	        isDynamicArg,
-	        modifiers,
-	    }, range));
-	    el.plain = false;
-	}
-	function prependModifierMarker(symbol, name, dynamic) {
-	    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-	}
-	function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-	    modifiers = modifiers || emptyObject;
-	    // warn prevent and passive modifier
-	    /* istanbul ignore if */
-	    if (warn &&
-	        modifiers.prevent &&
-	        modifiers.passive) {
-	        warn("passive and prevent can't be used together. " +
-	            "Passive handler can't prevent default event.", range);
-	    }
-	    // normalize click.right and click.middle since they don't actually fire
-	    // this is technically browser-specific, but at least for now browsers are
-	    // the only target envs that have right/middle clicks.
-	    if (modifiers.right) {
-	        if (dynamic) {
-	            name = `(${name})==='click'?'contextmenu':(${name})`;
-	        }
-	        else if (name === 'click') {
-	            name = 'contextmenu';
-	            delete modifiers.right;
-	        }
-	    }
-	    else if (modifiers.middle) {
-	        if (dynamic) {
-	            name = `(${name})==='click'?'mouseup':(${name})`;
-	        }
-	        else if (name === 'click') {
-	            name = 'mouseup';
-	        }
-	    }
-	    // check capture modifier
-	    if (modifiers.capture) {
-	        delete modifiers.capture;
-	        name = prependModifierMarker('!', name, dynamic);
-	    }
-	    if (modifiers.once) {
-	        delete modifiers.once;
-	        name = prependModifierMarker('~', name, dynamic);
-	    }
-	    /* istanbul ignore if */
-	    if (modifiers.passive) {
-	        delete modifiers.passive;
-	        name = prependModifierMarker('&', name, dynamic);
-	    }
-	    let events;
-	    if (modifiers.native) {
-	        delete modifiers.native;
-	        events = el.nativeEvents || (el.nativeEvents = {});
-	    }
-	    else {
-	        events = el.events || (el.events = {});
-	    }
-	    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-	    if (modifiers !== emptyObject) {
-	        newHandler.modifiers = modifiers;
-	    }
-	    const handlers = events[name];
-	    /* istanbul ignore if */
-	    if (Array.isArray(handlers)) {
-	        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-	    }
-	    else if (handlers) {
-	        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-	    }
-	    else {
-	        events[name] = newHandler;
-	    }
-	    el.plain = false;
-	}
-	function getRawBindingAttr(el, name) {
-	    return (el.rawAttrsMap[':' + name] ||
-	        el.rawAttrsMap['v-bind:' + name] ||
-	        el.rawAttrsMap[name]);
-	}
-	function getBindingAttr(el, name, getStatic) {
-	    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-	    if (dynamicValue != null) {
-	        return parseFilters(dynamicValue);
-	    }
-	    else if (getStatic !== false) {
-	        const staticValue = getAndRemoveAttr(el, name);
-	        if (staticValue != null) {
-	            return JSON.stringify(staticValue);
-	        }
-	    }
-	}
-	// note: this only removes the attr from the Array (attrsList) so that it
-	// doesn't get processed by processAttrs.
-	// By default it does NOT remove it from the map (attrsMap) because the map is
-	// needed during codegen.
-	function getAndRemoveAttr(el, name, removeFromMap) {
-	    let val;
-	    if ((val = el.attrsMap[name]) != null) {
-	        const list = el.attrsList;
-	        for (let i = 0, l = list.length; i < l; i++) {
-	            if (list[i].name === name) {
-	                list.splice(i, 1);
-	                break;
-	            }
-	        }
-	    }
-	    if (removeFromMap) {
-	        delete el.attrsMap[name];
-	    }
-	    return val;
-	}
-	function getAndRemoveAttrByRegex(el, name) {
-	    const list = el.attrsList;
-	    for (let i = 0, l = list.length; i < l; i++) {
-	        const attr = list[i];
-	        if (name.test(attr.name)) {
-	            list.splice(i, 1);
-	            return attr;
-	        }
-	    }
-	}
-	function rangeSetItem(item, range) {
-	    if (range) {
-	        if (range.start != null) {
-	            item.start = range.start;
-	        }
-	        if (range.end != null) {
-	            item.end = range.end;
-	        }
-	    }
-	    return item;
+	/* eslint-disable no-unused-vars */
+	function baseWarn(msg, range) {
+	    console.error(`[Vue compiler]: ${msg}`);
+	}
+	/* eslint-enable no-unused-vars */
+	function pluckModuleFunction(modules, key) {
+	    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+	}
+	function addProp(el, name, value, range, dynamic) {
+	    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+	    el.plain = false;
+	}
+	function addAttr(el, name, value, range, dynamic) {
+	    const attrs = dynamic
+	        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+	        : el.attrs || (el.attrs = []);
+	    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+	    el.plain = false;
+	}
+	// add a raw attr (use this in preTransforms)
+	function addRawAttr(el, name, value, range) {
+	    el.attrsMap[name] = value;
+	    el.attrsList.push(rangeSetItem({ name, value }, range));
+	}
+	function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+	    (el.directives || (el.directives = [])).push(rangeSetItem({
+	        name,
+	        rawName,
+	        value,
+	        arg,
+	        isDynamicArg,
+	        modifiers,
+	    }, range));
+	    el.plain = false;
+	}
+	function prependModifierMarker(symbol, name, dynamic) {
+	    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+	}
+	function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+	    modifiers = modifiers || emptyObject;
+	    // warn prevent and passive modifier
+	    /* istanbul ignore if */
+	    if (warn &&
+	        modifiers.prevent &&
+	        modifiers.passive) {
+	        warn("passive and prevent can't be used together. " +
+	            "Passive handler can't prevent default event.", range);
+	    }
+	    // normalize click.right and click.middle since they don't actually fire
+	    // this is technically browser-specific, but at least for now browsers are
+	    // the only target envs that have right/middle clicks.
+	    if (modifiers.right) {
+	        if (dynamic) {
+	            name = `(${name})==='click'?'contextmenu':(${name})`;
+	        }
+	        else if (name === 'click') {
+	            name = 'contextmenu';
+	            delete modifiers.right;
+	        }
+	    }
+	    else if (modifiers.middle) {
+	        if (dynamic) {
+	            name = `(${name})==='click'?'mouseup':(${name})`;
+	        }
+	        else if (name === 'click') {
+	            name = 'mouseup';
+	        }
+	    }
+	    // check capture modifier
+	    if (modifiers.capture) {
+	        delete modifiers.capture;
+	        name = prependModifierMarker('!', name, dynamic);
+	    }
+	    if (modifiers.once) {
+	        delete modifiers.once;
+	        name = prependModifierMarker('~', name, dynamic);
+	    }
+	    /* istanbul ignore if */
+	    if (modifiers.passive) {
+	        delete modifiers.passive;
+	        name = prependModifierMarker('&', name, dynamic);
+	    }
+	    let events;
+	    if (modifiers.native) {
+	        delete modifiers.native;
+	        events = el.nativeEvents || (el.nativeEvents = {});
+	    }
+	    else {
+	        events = el.events || (el.events = {});
+	    }
+	    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+	    if (modifiers !== emptyObject) {
+	        newHandler.modifiers = modifiers;
+	    }
+	    const handlers = events[name];
+	    /* istanbul ignore if */
+	    if (Array.isArray(handlers)) {
+	        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+	    }
+	    else if (handlers) {
+	        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+	    }
+	    else {
+	        events[name] = newHandler;
+	    }
+	    el.plain = false;
+	}
+	function getRawBindingAttr(el, name) {
+	    return (el.rawAttrsMap[':' + name] ||
+	        el.rawAttrsMap['v-bind:' + name] ||
+	        el.rawAttrsMap[name]);
+	}
+	function getBindingAttr(el, name, getStatic) {
+	    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+	    if (dynamicValue != null) {
+	        return parseFilters(dynamicValue);
+	    }
+	    else if (getStatic !== false) {
+	        const staticValue = getAndRemoveAttr(el, name);
+	        if (staticValue != null) {
+	            return JSON.stringify(staticValue);
+	        }
+	    }
+	}
+	// note: this only removes the attr from the Array (attrsList) so that it
+	// doesn't get processed by processAttrs.
+	// By default it does NOT remove it from the map (attrsMap) because the map is
+	// needed during codegen.
+	function getAndRemoveAttr(el, name, removeFromMap) {
+	    let val;
+	    if ((val = el.attrsMap[name]) != null) {
+	        const list = el.attrsList;
+	        for (let i = 0, l = list.length; i < l; i++) {
+	            if (list[i].name === name) {
+	                list.splice(i, 1);
+	                break;
+	            }
+	        }
+	    }
+	    if (removeFromMap) {
+	        delete el.attrsMap[name];
+	    }
+	    return val;
+	}
+	function getAndRemoveAttrByRegex(el, name) {
+	    const list = el.attrsList;
+	    for (let i = 0, l = list.length; i < l; i++) {
+	        const attr = list[i];
+	        if (name.test(attr.name)) {
+	            list.splice(i, 1);
+	            return attr;
+	        }
+	    }
+	}
+	function rangeSetItem(item, range) {
+	    if (range) {
+	        if (range.start != null) {
+	            item.start = range.start;
+	        }
+	        if (range.end != null) {
+	            item.end = range.end;
+	        }
+	    }
+	    return item;
 	}
 
-	function transformNode$1(el, options) {
-	    const warn = options.warn || baseWarn;
-	    const staticClass = getAndRemoveAttr(el, 'class');
-	    if (staticClass) {
-	        const res = parseText(staticClass, options.delimiters);
-	        if (res) {
-	            warn(`class="${staticClass}": ` +
-	                'Interpolation inside attributes has been removed. ' +
-	                'Use v-bind or the colon shorthand instead. For example, ' +
-	                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-	        }
-	    }
-	    if (staticClass) {
-	        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-	    }
-	    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-	    if (classBinding) {
-	        el.classBinding = classBinding;
-	    }
-	}
-	function genData$2(el) {
-	    let data = '';
-	    if (el.staticClass) {
-	        data += `staticClass:${el.staticClass},`;
-	    }
-	    if (el.classBinding) {
-	        data += `class:${el.classBinding},`;
-	    }
-	    return data;
-	}
-	var klass = {
-	    staticKeys: ['staticClass'],
-	    transformNode: transformNode$1,
-	    genData: genData$2,
+	function transformNode$1(el, options) {
+	    const warn = options.warn || baseWarn;
+	    const staticClass = getAndRemoveAttr(el, 'class');
+	    if (staticClass) {
+	        const res = parseText(staticClass, options.delimiters);
+	        if (res) {
+	            warn(`class="${staticClass}": ` +
+	                'Interpolation inside attributes has been removed. ' +
+	                'Use v-bind or the colon shorthand instead. For example, ' +
+	                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+	        }
+	    }
+	    if (staticClass) {
+	        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+	    }
+	    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+	    if (classBinding) {
+	        el.classBinding = classBinding;
+	    }
+	}
+	function genData$2(el) {
+	    let data = '';
+	    if (el.staticClass) {
+	        data += `staticClass:${el.staticClass},`;
+	    }
+	    if (el.classBinding) {
+	        data += `class:${el.classBinding},`;
+	    }
+	    return data;
+	}
+	var klass = {
+	    staticKeys: ['staticClass'],
+	    transformNode: transformNode$1,
+	    genData: genData$2,
 	};
 
-	const parseStyleText = cached(function (cssText) {
-	    const res = {};
-	    const listDelimiter = /;(?![^(]*\))/g;
-	    const propertyDelimiter = /:(.+)/;
-	    cssText.split(listDelimiter).forEach(function (item) {
-	        if (item) {
-	            const tmp = item.split(propertyDelimiter);
-	            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-	        }
-	    });
-	    return res;
+	const parseStyleText = cached(function (cssText) {
+	    const res = {};
+	    const listDelimiter = /;(?![^(]*\))/g;
+	    const propertyDelimiter = /:(.+)/;
+	    cssText.split(listDelimiter).forEach(function (item) {
+	        if (item) {
+	            const tmp = item.split(propertyDelimiter);
+	            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+	        }
+	    });
+	    return res;
 	});
 
-	function transformNode(el, options) {
-	    const warn = options.warn || baseWarn;
-	    const staticStyle = getAndRemoveAttr(el, 'style');
-	    if (staticStyle) {
-	        /* istanbul ignore if */
-	        {
-	            const res = parseText(staticStyle, options.delimiters);
-	            if (res) {
-	                warn(`style="${staticStyle}": ` +
-	                    'Interpolation inside attributes has been removed. ' +
-	                    'Use v-bind or the colon shorthand instead. For example, ' +
-	                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-	            }
-	        }
-	        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-	    }
-	    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-	    if (styleBinding) {
-	        el.styleBinding = styleBinding;
-	    }
-	}
-	function genData$1(el) {
-	    let data = '';
-	    if (el.staticStyle) {
-	        data += `staticStyle:${el.staticStyle},`;
-	    }
-	    if (el.styleBinding) {
-	        data += `style:(${el.styleBinding}),`;
-	    }
-	    return data;
-	}
-	var style = {
-	    staticKeys: ['staticStyle'],
-	    transformNode,
-	    genData: genData$1,
+	function transformNode(el, options) {
+	    const warn = options.warn || baseWarn;
+	    const staticStyle = getAndRemoveAttr(el, 'style');
+	    if (staticStyle) {
+	        /* istanbul ignore if */
+	        {
+	            const res = parseText(staticStyle, options.delimiters);
+	            if (res) {
+	                warn(`style="${staticStyle}": ` +
+	                    'Interpolation inside attributes has been removed. ' +
+	                    'Use v-bind or the colon shorthand instead. For example, ' +
+	                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+	            }
+	        }
+	        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+	    }
+	    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+	    if (styleBinding) {
+	        el.styleBinding = styleBinding;
+	    }
+	}
+	function genData$1(el) {
+	    let data = '';
+	    if (el.staticStyle) {
+	        data += `staticStyle:${el.staticStyle},`;
+	    }
+	    if (el.styleBinding) {
+	        data += `style:(${el.styleBinding}),`;
+	    }
+	    return data;
+	}
+	var style = {
+	    staticKeys: ['staticStyle'],
+	    transformNode,
+	    genData: genData$1,
 	};
 
 	var he$1 = {exports: {}};
@@ -2240,2695 +2240,2695 @@
 
 	var he = he$1.exports;
 
-	/**
-	 * Cross-platform code generation for component v-model
-	 */
-	function genComponentModel(el, value, modifiers) {
-	    const { number, trim } = modifiers || {};
-	    const baseValueExpression = '$$v';
-	    let valueExpression = baseValueExpression;
-	    if (trim) {
-	        valueExpression =
-	            `(typeof ${baseValueExpression} === 'string'` +
-	                `? ${baseValueExpression}.trim()` +
-	                `: ${baseValueExpression})`;
-	    }
-	    if (number) {
-	        valueExpression = `_n(${valueExpression})`;
-	    }
-	    const assignment = genAssignmentCode(value, valueExpression);
-	    el.model = {
-	        value: `(${value})`,
-	        expression: JSON.stringify(value),
-	        callback: `function (${baseValueExpression}) {${assignment}}`,
-	    };
-	}
-	/**
-	 * Cross-platform codegen helper for generating v-model value assignment code.
-	 */
-	function genAssignmentCode(value, assignment) {
-	    const res = parseModel(value);
-	    if (res.key === null) {
-	        return `${value}=${assignment}`;
-	    }
-	    else {
-	        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-	    }
-	}
-	/**
-	 * Parse a v-model expression into a base path and a final key segment.
-	 * Handles both dot-path and possible square brackets.
-	 *
-	 * Possible cases:
-	 *
-	 * - test
-	 * - test[key]
-	 * - test[test1[key]]
-	 * - test["a"][key]
-	 * - xxx.test[a[a].test1[key]]
-	 * - test.xxx.a["asa"][test1[key]]
-	 *
-	 */
-	let len, str, chr, index, expressionPos, expressionEndPos;
-	function parseModel(val) {
-	    // Fix https://github.com/vuejs/vue/pull/7730
-	    // allow v-model="obj.val " (trailing whitespace)
-	    val = val.trim();
-	    len = val.length;
-	    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-	        index = val.lastIndexOf('.');
-	        if (index > -1) {
-	            return {
-	                exp: val.slice(0, index),
-	                key: '"' + val.slice(index + 1) + '"',
-	            };
-	        }
-	        else {
-	            return {
-	                exp: val,
-	                key: null,
-	            };
-	        }
-	    }
-	    str = val;
-	    index = expressionPos = expressionEndPos = 0;
-	    while (!eof()) {
-	        chr = next();
-	        /* istanbul ignore if */
-	        if (isStringStart(chr)) {
-	            parseString(chr);
-	        }
-	        else if (chr === 0x5b) {
-	            parseBracket(chr);
-	        }
-	    }
-	    return {
-	        exp: val.slice(0, expressionPos),
-	        key: val.slice(expressionPos + 1, expressionEndPos),
-	    };
-	}
-	function next() {
-	    return str.charCodeAt(++index);
-	}
-	function eof() {
-	    return index >= len;
-	}
-	function isStringStart(chr) {
-	    return chr === 0x22 || chr === 0x27;
-	}
-	function parseBracket(chr) {
-	    let inBracket = 1;
-	    expressionPos = index;
-	    while (!eof()) {
-	        chr = next();
-	        if (isStringStart(chr)) {
-	            parseString(chr);
-	            continue;
-	        }
-	        if (chr === 0x5b)
-	            inBracket++;
-	        if (chr === 0x5d)
-	            inBracket--;
-	        if (inBracket === 0) {
-	            expressionEndPos = index;
-	            break;
-	        }
-	    }
-	}
-	function parseString(chr) {
-	    const stringQuote = chr;
-	    while (!eof()) {
-	        chr = next();
-	        if (chr === stringQuote) {
-	            break;
-	        }
-	    }
-	}
-
-	const onRE = /^@|^v-on:/;
-	const dirRE = /^v-|^@|^:|^#/;
-	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-	const stripParensRE = /^\(|\)$/g;
-	const dynamicArgRE = /^\[.*\]$/;
-	const argRE = /:(.*)$/;
-	const bindRE = /^:|^\.|^v-bind:/;
-	const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-	const slotRE = /^v-slot(:|$)|^#/;
-	const lineBreakRE = /[\r\n]/;
-	const whitespaceRE = /[ \f\t\r\n]+/g;
-	const invalidAttributeRE = /[\s"'<>\/=]/;
-	const decodeHTMLCached = cached(he.decode);
-	const emptySlotScopeToken = `_empty_`;
-	// configurable state
-	let warn$1;
-	let delimiters;
-	let transforms;
-	let preTransforms;
-	let postTransforms;
-	let platformIsPreTag;
-	let platformMustUseProp;
-	let platformGetTagNamespace;
-	let maybeComponent;
-	function createASTElement(tag, attrs, parent) {
-	    return {
-	        type: 1,
-	        tag,
-	        attrsList: attrs,
-	        attrsMap: makeAttrsMap(attrs),
-	        rawAttrsMap: {},
-	        parent,
-	        children: [],
-	    };
-	}
-	/**
-	 * Convert HTML string to AST.
-	 */
-	function parse(template, options) {
-	    warn$1 = options.warn || baseWarn;
-	    platformIsPreTag = options.isPreTag || no;
-	    platformMustUseProp = options.mustUseProp || no;
-	    platformGetTagNamespace = options.getTagNamespace || no;
-	    const isReservedTag = options.isReservedTag || no;
-	    maybeComponent = (el) => !!(el.component ||
-	        el.attrsMap[':is'] ||
-	        el.attrsMap['v-bind:is'] ||
-	        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-	    transforms = pluckModuleFunction(options.modules, 'transformNode');
-	    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-	    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-	    delimiters = options.delimiters;
-	    const stack = [];
-	    const preserveWhitespace = options.preserveWhitespace !== false;
-	    const whitespaceOption = options.whitespace;
-	    let root;
-	    let currentParent;
-	    let inVPre = false;
-	    let inPre = false;
-	    let warned = false;
-	    function warnOnce(msg, range) {
-	        if (!warned) {
-	            warned = true;
-	            warn$1(msg, range);
-	        }
-	    }
-	    function closeElement(element) {
-	        trimEndingWhitespace(element);
-	        if (!inVPre && !element.processed) {
-	            element = processElement(element, options);
-	        }
-	        // tree management
-	        if (!stack.length && element !== root) {
-	            // allow root elements with v-if, v-else-if and v-else
-	            if (root.if && (element.elseif || element.else)) {
-	                {
-	                    checkRootConstraints(element);
-	                }
-	                addIfCondition(root, {
-	                    exp: element.elseif,
-	                    block: element,
-	                });
-	            }
-	            else {
-	                warnOnce(`Component template should contain exactly one root element. ` +
-	                    `If you are using v-if on multiple elements, ` +
-	                    `use v-else-if to chain them instead.`, { start: element.start });
-	            }
-	        }
-	        if (currentParent && !element.forbidden) {
-	            if (element.elseif || element.else) {
-	                processIfConditions(element, currentParent);
-	            }
-	            else {
-	                if (element.slotScope) {
-	                    // scoped slot
-	                    // keep it in the children list so that v-else(-if) conditions can
-	                    // find it as the prev node.
-	                    const name = element.slotTarget || '"default"';
-	                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-	                }
-	                currentParent.children.push(element);
-	                element.parent = currentParent;
-	            }
-	        }
-	        // final children cleanup
-	        // filter out scoped slots
-	        element.children = element.children.filter((c) => !c.slotScope);
-	        // remove trailing whitespace node again
-	        trimEndingWhitespace(element);
-	        // check pre state
-	        if (element.pre) {
-	            inVPre = false;
-	        }
-	        if (platformIsPreTag(element.tag)) {
-	            inPre = false;
-	        }
-	        // apply post-transforms
-	        for (let i = 0; i < postTransforms.length; i++) {
-	            postTransforms[i](element, options);
-	        }
-	    }
-	    function trimEndingWhitespace(el) {
-	        // remove trailing whitespace node
-	        if (!inPre) {
-	            let lastNode;
-	            while ((lastNode = el.children[el.children.length - 1]) &&
-	                lastNode.type === 3 &&
-	                lastNode.text === ' ') {
-	                el.children.pop();
-	            }
-	        }
-	    }
-	    function checkRootConstraints(el) {
-	        if (el.tag === 'slot' || el.tag === 'template') {
-	            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-	                'contain multiple nodes.', { start: el.start });
-	        }
-	        if (el.attrsMap.hasOwnProperty('v-for')) {
-	            warnOnce('Cannot use v-for on stateful component root element because ' +
-	                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-	        }
-	    }
-	    parseHTML(template, {
-	        warn: warn$1,
-	        expectHTML: options.expectHTML,
-	        isUnaryTag: options.isUnaryTag,
-	        canBeLeftOpenTag: options.canBeLeftOpenTag,
-	        shouldDecodeNewlines: options.shouldDecodeNewlines,
-	        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-	        shouldKeepComment: options.comments,
-	        outputSourceRange: options.outputSourceRange,
-	        start(tag, attrs, unary, start, end) {
-	            // check namespace.
-	            // inherit parent ns if there is one
-	            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-	            // handle IE svg bug
-	            /* istanbul ignore if */
-	            if (isIE && ns === 'svg') {
-	                attrs = guardIESVGBug(attrs);
-	            }
-	            let element = createASTElement(tag, attrs, currentParent);
-	            if (ns) {
-	                element.ns = ns;
-	            }
-	            {
-	                if (options.outputSourceRange) {
-	                    element.start = start;
-	                    element.end = end;
-	                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-	                        cumulated[attr.name] = attr;
-	                        return cumulated;
-	                    }, {});
-	                }
-	                attrs.forEach((attr) => {
-	                    if (invalidAttributeRE.test(attr.name)) {
-	                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-	                            `spaces, quotes, <, >, / or =.`, {
-	                            start: attr.start + attr.name.indexOf(`[`),
-	                            end: attr.start + attr.name.length,
-	                        });
-	                    }
-	                });
-	            }
-	            if (isForbiddenTag(element) && !isServerRendering()) {
-	                element.forbidden = true;
-	                warn$1('Templates should only be responsible for mapping the state to the ' +
-	                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-	                        `<${tag}>` +
-	                        ', as they will not be parsed.', { start: element.start });
-	            }
-	            // apply pre-transforms
-	            for (let i = 0; i < preTransforms.length; i++) {
-	                element = preTransforms[i](element, options) || element;
-	            }
-	            if (!inVPre) {
-	                processPre(element);
-	                if (element.pre) {
-	                    inVPre = true;
-	                }
-	            }
-	            if (platformIsPreTag(element.tag)) {
-	                inPre = true;
-	            }
-	            if (inVPre) {
-	                processRawAttrs(element);
-	            }
-	            else if (!element.processed) {
-	                // structural directives
-	                processFor(element);
-	                processIf(element);
-	                processOnce(element);
-	            }
-	            if (!root) {
-	                root = element;
-	                {
-	                    checkRootConstraints(root);
-	                }
-	            }
-	            if (!unary) {
-	                currentParent = element;
-	                stack.push(element);
-	            }
-	            else {
-	                closeElement(element);
-	            }
-	        },
-	        end(tag, start, end) {
-	            const element = stack[stack.length - 1];
-	            // pop stack
-	            stack.length -= 1;
-	            currentParent = stack[stack.length - 1];
-	            if (options.outputSourceRange) {
-	                element.end = end;
-	            }
-	            closeElement(element);
-	        },
-	        chars(text, start, end) {
-	            if (!currentParent) {
-	                {
-	                    if (text === template) {
-	                        warnOnce('Component template requires a root element, rather than just text.', { start });
-	                    }
-	                    else if ((text = text.trim())) {
-	                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-	                            start,
-	                        });
-	                    }
-	                }
-	                return;
-	            }
-	            // IE textarea placeholder bug
-	            /* istanbul ignore if */
-	            if (isIE &&
-	                currentParent.tag === 'textarea' &&
-	                currentParent.attrsMap.placeholder === text) {
-	                return;
-	            }
-	            const children = currentParent.children;
-	            if (inPre || text.trim()) {
-	                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-	            }
-	            else if (!children.length) {
-	                // remove the whitespace-only node right after an opening tag
-	                text = '';
-	            }
-	            else if (whitespaceOption) {
-	                if (whitespaceOption === 'condense') {
-	                    // in condense mode, remove the whitespace node if it contains
-	                    // line break, otherwise condense to a single space
-	                    text = lineBreakRE.test(text) ? '' : ' ';
-	                }
-	                else {
-	                    text = ' ';
-	                }
-	            }
-	            else {
-	                text = preserveWhitespace ? ' ' : '';
-	            }
-	            if (text) {
-	                if (!inPre && whitespaceOption === 'condense') {
-	                    // condense consecutive whitespaces into single space
-	                    text = text.replace(whitespaceRE, ' ');
-	                }
-	                let res;
-	                let child;
-	                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-	                    child = {
-	                        type: 2,
-	                        expression: res.expression,
-	                        tokens: res.tokens,
-	                        text,
-	                    };
-	                }
-	                else if (text !== ' ' ||
-	                    !children.length ||
-	                    children[children.length - 1].text !== ' ') {
-	                    child = {
-	                        type: 3,
-	                        text,
-	                    };
-	                }
-	                if (child) {
-	                    if (options.outputSourceRange) {
-	                        child.start = start;
-	                        child.end = end;
-	                    }
-	                    children.push(child);
-	                }
-	            }
-	        },
-	        comment(text, start, end) {
-	            // adding anything as a sibling to the root node is forbidden
-	            // comments should still be allowed, but ignored
-	            if (currentParent) {
-	                const child = {
-	                    type: 3,
-	                    text,
-	                    isComment: true,
-	                };
-	                if (options.outputSourceRange) {
-	                    child.start = start;
-	                    child.end = end;
-	                }
-	                currentParent.children.push(child);
-	            }
-	        },
-	    });
-	    return root;
-	}
-	function processPre(el) {
-	    if (getAndRemoveAttr(el, 'v-pre') != null) {
-	        el.pre = true;
-	    }
-	}
-	function processRawAttrs(el) {
-	    const list = el.attrsList;
-	    const len = list.length;
-	    if (len) {
-	        const attrs = (el.attrs = new Array(len));
-	        for (let i = 0; i < len; i++) {
-	            attrs[i] = {
-	                name: list[i].name,
-	                value: JSON.stringify(list[i].value),
-	            };
-	            if (list[i].start != null) {
-	                attrs[i].start = list[i].start;
-	                attrs[i].end = list[i].end;
-	            }
-	        }
-	    }
-	    else if (!el.pre) {
-	        // non root node in pre blocks with no attributes
-	        el.plain = true;
-	    }
-	}
-	function processElement(element, options) {
-	    processKey(element);
-	    // determine whether this is a plain element after
-	    // removing structural attributes
-	    element.plain =
-	        !element.key && !element.scopedSlots && !element.attrsList.length;
-	    processRef(element);
-	    processSlotContent(element);
-	    processSlotOutlet(element);
-	    processComponent(element);
-	    for (let i = 0; i < transforms.length; i++) {
-	        element = transforms[i](element, options) || element;
-	    }
-	    processAttrs(element);
-	    return element;
-	}
-	function processKey(el) {
-	    const exp = getBindingAttr(el, 'key');
-	    if (exp) {
-	        {
-	            if (el.tag === 'template') {
-	                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-	            }
-	            if (el.for) {
-	                const iterator = el.iterator2 || el.iterator1;
-	                const parent = el.parent;
-	                if (iterator &&
-	                    iterator === exp &&
-	                    parent &&
-	                    parent.tag === 'transition-group') {
-	                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-	                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-	                }
-	            }
-	        }
-	        el.key = exp;
-	    }
-	}
-	function processRef(el) {
-	    const ref = getBindingAttr(el, 'ref');
-	    if (ref) {
-	        el.ref = ref;
-	        el.refInFor = checkInFor(el);
-	    }
-	}
-	function processFor(el) {
-	    let exp;
-	    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-	        const res = parseFor(exp);
-	        if (res) {
-	            extend(el, res);
-	        }
-	        else {
-	            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-	        }
-	    }
-	}
-	function parseFor(exp) {
-	    const inMatch = exp.match(forAliasRE);
-	    if (!inMatch)
-	        return;
-	    const res = {};
-	    res.for = inMatch[2].trim();
-	    const alias = inMatch[1].trim().replace(stripParensRE, '');
-	    const iteratorMatch = alias.match(forIteratorRE);
-	    if (iteratorMatch) {
-	        res.alias = alias.replace(forIteratorRE, '').trim();
-	        res.iterator1 = iteratorMatch[1].trim();
-	        if (iteratorMatch[2]) {
-	            res.iterator2 = iteratorMatch[2].trim();
-	        }
-	    }
-	    else {
-	        res.alias = alias;
-	    }
-	    return res;
-	}
-	function processIf(el) {
-	    const exp = getAndRemoveAttr(el, 'v-if');
-	    if (exp) {
-	        el.if = exp;
-	        addIfCondition(el, {
-	            exp: exp,
-	            block: el,
-	        });
-	    }
-	    else {
-	        if (getAndRemoveAttr(el, 'v-else') != null) {
-	            el.else = true;
-	        }
-	        const elseif = getAndRemoveAttr(el, 'v-else-if');
-	        if (elseif) {
-	            el.elseif = elseif;
-	        }
-	    }
-	}
-	function processIfConditions(el, parent) {
-	    const prev = findPrevElement(parent.children);
-	    if (prev && prev.if) {
-	        addIfCondition(prev, {
-	            exp: el.elseif,
-	            block: el,
-	        });
-	    }
-	    else {
-	        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-	            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-	    }
-	}
-	function findPrevElement(children) {
-	    let i = children.length;
-	    while (i--) {
-	        if (children[i].type === 1) {
-	            return children[i];
-	        }
-	        else {
-	            if (children[i].text !== ' ') {
-	                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-	                    `will be ignored.`, children[i]);
-	            }
-	            children.pop();
-	        }
-	    }
-	}
-	function addIfCondition(el, condition) {
-	    if (!el.ifConditions) {
-	        el.ifConditions = [];
-	    }
-	    el.ifConditions.push(condition);
-	}
-	function processOnce(el) {
-	    const once = getAndRemoveAttr(el, 'v-once');
-	    if (once != null) {
-	        el.once = true;
-	    }
-	}
-	// handle content being passed to a component as slot,
-	// e.g. <template slot="xxx">, <div slot-scope="xxx">
-	function processSlotContent(el) {
-	    let slotScope;
-	    if (el.tag === 'template') {
-	        slotScope = getAndRemoveAttr(el, 'scope');
-	        /* istanbul ignore if */
-	        if (slotScope) {
-	            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-	                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-	                `can also be used on plain elements in addition to <template> to ` +
-	                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-	        }
-	        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-	    }
-	    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-	        /* istanbul ignore if */
-	        if (el.attrsMap['v-for']) {
-	            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-	                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-	                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-	        }
-	        el.slotScope = slotScope;
-	    }
-	    // slot="xxx"
-	    const slotTarget = getBindingAttr(el, 'slot');
-	    if (slotTarget) {
-	        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-	        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-	        // preserve slot as an attribute for native shadow DOM compat
-	        // only for non-scoped slots.
-	        if (el.tag !== 'template' && !el.slotScope) {
-	            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-	        }
-	    }
-	    // 2.6 v-slot syntax
-	    {
-	        if (el.tag === 'template') {
-	            // v-slot on <template>
-	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-	            if (slotBinding) {
-	                {
-	                    if (el.slotTarget || el.slotScope) {
-	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-	                    }
-	                    if (el.parent && !maybeComponent(el.parent)) {
-	                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-	                            `the receiving component`, el);
-	                    }
-	                }
-	                const { name, dynamic } = getSlotName(slotBinding);
-	                el.slotTarget = name;
-	                el.slotTargetDynamic = dynamic;
-	                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-	            }
-	        }
-	        else {
-	            // v-slot on component, denotes default slot
-	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-	            if (slotBinding) {
-	                {
-	                    if (!maybeComponent(el)) {
-	                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-	                    }
-	                    if (el.slotScope || el.slotTarget) {
-	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-	                    }
-	                    if (el.scopedSlots) {
-	                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-	                            `<template> syntax when there are other named slots.`, slotBinding);
-	                    }
-	                }
-	                // add the component's children to its default slot
-	                const slots = el.scopedSlots || (el.scopedSlots = {});
-	                const { name, dynamic } = getSlotName(slotBinding);
-	                const slotContainer = (slots[name] = createASTElement('template', [], el));
-	                slotContainer.slotTarget = name;
-	                slotContainer.slotTargetDynamic = dynamic;
-	                slotContainer.children = el.children.filter((c) => {
-	                    if (!c.slotScope) {
-	                        c.parent = slotContainer;
-	                        return true;
-	                    }
-	                });
-	                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-	                // remove children as they are returned from scopedSlots now
-	                el.children = [];
-	                // mark el non-plain so data gets generated
-	                el.plain = false;
-	            }
-	        }
-	    }
-	}
-	function getSlotName(binding) {
-	    let name = binding.name.replace(slotRE, '');
-	    if (!name) {
-	        if (binding.name[0] !== '#') {
-	            name = 'default';
-	        }
-	        else {
-	            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-	        }
-	    }
-	    return dynamicArgRE.test(name)
-	        ? // dynamic [name]
-	            { name: name.slice(1, -1), dynamic: true }
-	        : // static name
-	            { name: `"${name}"`, dynamic: false };
-	}
-	// handle <slot/> outlets
-	function processSlotOutlet(el) {
-	    if (el.tag === 'slot') {
-	        el.slotName = getBindingAttr(el, 'name');
-	        if (el.key) {
-	            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-	                `and can possibly expand into multiple elements. ` +
-	                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-	        }
-	    }
-	}
-	function processComponent(el) {
-	    let binding;
-	    if ((binding = getBindingAttr(el, 'is'))) {
-	        el.component = binding;
-	    }
-	    if (getAndRemoveAttr(el, 'inline-template') != null) {
-	        el.inlineTemplate = true;
-	    }
-	}
-	function processAttrs(el) {
-	    const list = el.attrsList;
-	    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-	    for (i = 0, l = list.length; i < l; i++) {
-	        name = rawName = list[i].name;
-	        value = list[i].value;
-	        if (dirRE.test(name)) {
-	            // mark element as dynamic
-	            el.hasBindings = true;
-	            // modifiers
-	            modifiers = parseModifiers(name.replace(dirRE, ''));
-	            // support .foo shorthand syntax for the .prop modifier
-	            if (modifiers) {
-	                name = name.replace(modifierRE, '');
-	            }
-	            if (bindRE.test(name)) {
-	                // v-bind
-	                name = name.replace(bindRE, '');
-	                value = parseFilters(value);
-	                isDynamic = dynamicArgRE.test(name);
-	                if (isDynamic) {
-	                    name = name.slice(1, -1);
-	                }
-	                if (value.trim().length === 0) {
-	                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-	                }
-	                if (modifiers) {
-	                    if (modifiers.prop && !isDynamic) {
-	                        name = camelize(name);
-	                        if (name === 'innerHtml')
-	                            name = 'innerHTML';
-	                    }
-	                    if (modifiers.camel && !isDynamic) {
-	                        name = camelize(name);
-	                    }
-	                    if (modifiers.sync) {
-	                        syncGen = genAssignmentCode(value, `$event`);
-	                        if (!isDynamic) {
-	                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-	                            if (hyphenate(name) !== camelize(name)) {
-	                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-	                            }
-	                        }
-	                        else {
-	                            // handler w/ dynamic event name
-	                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-	                            );
-	                        }
-	                    }
-	                }
-	                if ((modifiers && modifiers.prop) ||
-	                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-	                    addProp(el, name, value, list[i], isDynamic);
-	                }
-	                else {
-	                    addAttr(el, name, value, list[i], isDynamic);
-	                }
-	            }
-	            else if (onRE.test(name)) {
-	                // v-on
-	                name = name.replace(onRE, '');
-	                isDynamic = dynamicArgRE.test(name);
-	                if (isDynamic) {
-	                    name = name.slice(1, -1);
-	                }
-	                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-	            }
-	            else {
-	                // normal directives
-	                name = name.replace(dirRE, '');
-	                // parse arg
-	                const argMatch = name.match(argRE);
-	                let arg = argMatch && argMatch[1];
-	                isDynamic = false;
-	                if (arg) {
-	                    name = name.slice(0, -(arg.length + 1));
-	                    if (dynamicArgRE.test(arg)) {
-	                        arg = arg.slice(1, -1);
-	                        isDynamic = true;
-	                    }
-	                }
-	                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-	                if (name === 'model') {
-	                    checkForAliasModel(el, value);
-	                }
-	            }
-	        }
-	        else {
-	            // literal attribute
-	            {
-	                const res = parseText(value, delimiters);
-	                if (res) {
-	                    warn$1(`${name}="${value}": ` +
-	                        'Interpolation inside attributes has been removed. ' +
-	                        'Use v-bind or the colon shorthand instead. For example, ' +
-	                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-	                }
-	            }
-	            addAttr(el, name, JSON.stringify(value), list[i]);
-	            // #6887 firefox doesn't update muted state if set via attribute
-	            // even immediately after element creation
-	            if (!el.component &&
-	                name === 'muted' &&
-	                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-	                addProp(el, name, 'true', list[i]);
-	            }
-	        }
-	    }
-	}
-	function checkInFor(el) {
-	    let parent = el;
-	    while (parent) {
-	        if (parent.for !== undefined) {
-	            return true;
-	        }
-	        parent = parent.parent;
-	    }
-	    return false;
-	}
-	function parseModifiers(name) {
-	    const match = name.match(modifierRE);
-	    if (match) {
-	        const ret = {};
-	        match.forEach((m) => {
-	            ret[m.slice(1)] = true;
-	        });
-	        return ret;
-	    }
-	}
-	function makeAttrsMap(attrs) {
-	    const map = {};
-	    for (let i = 0, l = attrs.length; i < l; i++) {
-	        if (map[attrs[i].name] &&
-	            !isIE &&
-	            !isEdge) {
-	            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-	        }
-	        map[attrs[i].name] = attrs[i].value;
-	    }
-	    return map;
-	}
-	// for script (e.g. type="x/template") or style, do not decode content
-	function isTextTag(el) {
-	    return el.tag === 'script' || el.tag === 'style';
-	}
-	function isForbiddenTag(el) {
-	    return (el.tag === 'style' ||
-	        (el.tag === 'script' &&
-	            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-	}
-	const ieNSBug = /^xmlns:NS\d+/;
-	const ieNSPrefix = /^NS\d+:/;
-	/* istanbul ignore next */
-	function guardIESVGBug(attrs) {
-	    const res = [];
-	    for (let i = 0; i < attrs.length; i++) {
-	        const attr = attrs[i];
-	        if (!ieNSBug.test(attr.name)) {
-	            attr.name = attr.name.replace(ieNSPrefix, '');
-	            res.push(attr);
-	        }
-	    }
-	    return res;
-	}
-	function checkForAliasModel(el, value) {
-	    let _el = el;
-	    while (_el) {
-	        if (_el.for && _el.alias === value) {
-	            warn$1(`<${el.tag} v-model="${value}">: ` +
-	                `You are binding v-model directly to a v-for iteration alias. ` +
-	                `This will not be able to modify the v-for source array because ` +
-	                `writing to the alias is like modifying a function local variable. ` +
-	                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-	        }
-	        _el = _el.parent;
-	    }
-	}
-
-	/**
-	 * Expand input[v-model] with dynamic type bindings into v-if-else chains
-	 * Turn this:
-	 *   <input v-model="data[type]" :type="type">
-	 * into this:
-	 *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-	 *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-	 *   <input v-else :type="type" v-model="data[type]">
-	 */
-	function preTransformNode(el, options) {
-	    if (el.tag === 'input') {
-	        const map = el.attrsMap;
-	        if (!map['v-model']) {
-	            return;
-	        }
-	        let typeBinding;
-	        if (map[':type'] || map['v-bind:type']) {
-	            typeBinding = getBindingAttr(el, 'type');
-	        }
-	        if (!map.type && !typeBinding && map['v-bind']) {
-	            typeBinding = `(${map['v-bind']}).type`;
-	        }
-	        if (typeBinding) {
-	            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-	            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-	            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-	            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-	            // 1. checkbox
-	            const branch0 = cloneASTElement(el);
-	            // process for on the main node
-	            processFor(branch0);
-	            addRawAttr(branch0, 'type', 'checkbox');
-	            processElement(branch0, options);
-	            branch0.processed = true; // prevent it from double-processed
-	            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-	            addIfCondition(branch0, {
-	                exp: branch0.if,
-	                block: branch0,
-	            });
-	            // 2. add radio else-if condition
-	            const branch1 = cloneASTElement(el);
-	            getAndRemoveAttr(branch1, 'v-for', true);
-	            addRawAttr(branch1, 'type', 'radio');
-	            processElement(branch1, options);
-	            addIfCondition(branch0, {
-	                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-	                block: branch1,
-	            });
-	            // 3. other
-	            const branch2 = cloneASTElement(el);
-	            getAndRemoveAttr(branch2, 'v-for', true);
-	            addRawAttr(branch2, ':type', typeBinding);
-	            processElement(branch2, options);
-	            addIfCondition(branch0, {
-	                exp: ifCondition,
-	                block: branch2,
-	            });
-	            if (hasElse) {
-	                branch0.else = true;
-	            }
-	            else if (elseIfCondition) {
-	                branch0.elseif = elseIfCondition;
-	            }
-	            return branch0;
-	        }
-	    }
-	}
-	function cloneASTElement(el) {
-	    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-	}
-	var model$1 = {
-	    preTransformNode,
-	};
-
-	var modules = [klass, style, model$1];
-
-	let warn;
-	// in some cases, the event used has to be determined at runtime
-	// so we used some reserved tokens during compile.
-	const RANGE_TOKEN = '__r';
-	function model(el, dir, _warn) {
-	    warn = _warn;
-	    const value = dir.value;
-	    const modifiers = dir.modifiers;
-	    const tag = el.tag;
-	    const type = el.attrsMap.type;
-	    {
-	        // inputs with type="file" are read only and setting the input's
-	        // value will throw an error.
-	        if (tag === 'input' && type === 'file') {
-	            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-	                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-	        }
-	    }
-	    if (el.component) {
-	        genComponentModel(el, value, modifiers);
-	        // component v-model doesn't need extra runtime
-	        return false;
-	    }
-	    else if (tag === 'select') {
-	        genSelect(el, value, modifiers);
-	    }
-	    else if (tag === 'input' && type === 'checkbox') {
-	        genCheckboxModel(el, value, modifiers);
-	    }
-	    else if (tag === 'input' && type === 'radio') {
-	        genRadioModel(el, value, modifiers);
-	    }
-	    else if (tag === 'input' || tag === 'textarea') {
-	        genDefaultModel(el, value, modifiers);
-	    }
-	    else {
-	        genComponentModel(el, value, modifiers);
-	        // component v-model doesn't need extra runtime
-	        return false;
-	    }
-	    // ensure runtime directive metadata
-	    return true;
-	}
-	function genCheckboxModel(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    const valueBinding = getBindingAttr(el, 'value') || 'null';
-	    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-	    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-	    addProp(el, 'checked', `Array.isArray(${value})` +
-	        `?_i(${value},${valueBinding})>-1` +
-	        (trueValueBinding === 'true'
-	            ? `:(${value})`
-	            : `:_q(${value},${trueValueBinding})`));
-	    addHandler(el, 'change', `var $$a=${value},` +
-	        '$$el=$event.target,' +
-	        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-	        'if(Array.isArray($$a)){' +
-	        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-	        '$$i=_i($$a,$$v);' +
-	        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-	        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-	        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-	}
-	function genRadioModel(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    let valueBinding = getBindingAttr(el, 'value') || 'null';
-	    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-	    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-	    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-	}
-	function genSelect(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    const selectedVal = `Array.prototype.filter` +
-	        `.call($event.target.options,function(o){return o.selected})` +
-	        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-	        `return ${number ? '_n(val)' : 'val'}})`;
-	    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-	    let code = `var $$selectedVal = ${selectedVal};`;
-	    code = `${code} ${genAssignmentCode(value, assignment)}`;
-	    addHandler(el, 'change', code, null, true);
-	}
-	function genDefaultModel(el, value, modifiers) {
-	    const type = el.attrsMap.type;
-	    // warn if v-bind:value conflicts with v-model
-	    // except for inputs with v-bind:type
-	    {
-	        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-	        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-	        if (value && !typeBinding) {
-	            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-	            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-	                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-	        }
-	    }
-	    const { lazy, number, trim } = modifiers || {};
-	    const needCompositionGuard = !lazy && type !== 'range';
-	    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-	    let valueExpression = '$event.target.value';
-	    if (trim) {
-	        valueExpression = `$event.target.value.trim()`;
-	    }
-	    if (number) {
-	        valueExpression = `_n(${valueExpression})`;
-	    }
-	    let code = genAssignmentCode(value, valueExpression);
-	    if (needCompositionGuard) {
-	        code = `if($event.target.composing)return;${code}`;
-	    }
-	    addProp(el, 'value', `(${value})`);
-	    addHandler(el, event, code, null, true);
-	    if (trim || number) {
-	        addHandler(el, 'blur', '$forceUpdate()');
-	    }
-	}
-
-	function text(el, dir) {
-	    if (dir.value) {
-	        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-	    }
-	}
-
-	function html(el, dir) {
-	    if (dir.value) {
-	        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-	    }
+	/**
+	 * Cross-platform code generation for component v-model
+	 */
+	function genComponentModel(el, value, modifiers) {
+	    const { number, trim } = modifiers || {};
+	    const baseValueExpression = '$$v';
+	    let valueExpression = baseValueExpression;
+	    if (trim) {
+	        valueExpression =
+	            `(typeof ${baseValueExpression} === 'string'` +
+	                `? ${baseValueExpression}.trim()` +
+	                `: ${baseValueExpression})`;
+	    }
+	    if (number) {
+	        valueExpression = `_n(${valueExpression})`;
+	    }
+	    const assignment = genAssignmentCode(value, valueExpression);
+	    el.model = {
+	        value: `(${value})`,
+	        expression: JSON.stringify(value),
+	        callback: `function (${baseValueExpression}) {${assignment}}`,
+	    };
 	}
-
-	var directives = {
-	    model,
-	    text,
-	    html,
-	};
-
-	const baseOptions = {
-	    expectHTML: true,
-	    modules,
-	    directives,
-	    isPreTag,
-	    isUnaryTag,
-	    mustUseProp,
-	    canBeLeftOpenTag,
-	    isReservedTag,
-	    getTagNamespace,
-	    staticKeys: genStaticKeys$1(modules),
-	};
-
-	let isStaticKey;
-	let isPlatformReservedTag$1;
-	const genStaticKeysCached = cached(genStaticKeys);
-	/**
-	 * Goal of the optimizer: walk the generated template AST tree
-	 * and detect sub-trees that are purely static, i.e. parts of
-	 * the DOM that never needs to change.
-	 *
-	 * Once we detect these sub-trees, we can:
-	 *
-	 * 1. Hoist them into constants, so that we no longer need to
-	 *    create fresh nodes for them on each re-render;
-	 * 2. Completely skip them in the patching process.
-	 */
-	function optimize$1(root, options) {
-	    if (!root)
-	        return;
-	    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-	    isPlatformReservedTag$1 = options.isReservedTag || no;
-	    // first pass: mark all non-static nodes.
-	    markStatic(root);
-	    // second pass: mark static roots.
-	    markStaticRoots(root, false);
-	}
-	function genStaticKeys(keys) {
-	    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-	        (keys ? ',' + keys : ''));
-	}
-	function markStatic(node) {
-	    node.static = isStatic(node);
-	    if (node.type === 1) {
-	        // do not make component slot content static. this avoids
-	        // 1. components not able to mutate slot nodes
-	        // 2. static slot content fails for hot-reloading
-	        if (!isPlatformReservedTag$1(node.tag) &&
-	            node.tag !== 'slot' &&
-	            node.attrsMap['inline-template'] == null) {
-	            return;
-	        }
-	        for (let i = 0, l = node.children.length; i < l; i++) {
-	            const child = node.children[i];
-	            markStatic(child);
-	            if (!child.static) {
-	                node.static = false;
-	            }
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                const block = node.ifConditions[i].block;
-	                markStatic(block);
-	                if (!block.static) {
-	                    node.static = false;
-	                }
-	            }
-	        }
-	    }
-	}
-	function markStaticRoots(node, isInFor) {
-	    if (node.type === 1) {
-	        if (node.static || node.once) {
-	            node.staticInFor = isInFor;
-	        }
-	        // For a node to qualify as a static root, it should have children that
-	        // are not just static text. Otherwise the cost of hoisting out will
-	        // outweigh the benefits and it's better off to just always render it fresh.
-	        if (node.static &&
-	            node.children.length &&
-	            !(node.children.length === 1 && node.children[0].type === 3)) {
-	            node.staticRoot = true;
-	            return;
-	        }
-	        else {
-	            node.staticRoot = false;
-	        }
-	        if (node.children) {
-	            for (let i = 0, l = node.children.length; i < l; i++) {
-	                markStaticRoots(node.children[i], isInFor || !!node.for);
-	            }
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                markStaticRoots(node.ifConditions[i].block, isInFor);
-	            }
-	        }
-	    }
-	}
-	function isStatic(node) {
-	    if (node.type === 2) {
-	        // expression
-	        return false;
-	    }
-	    if (node.type === 3) {
-	        // text
-	        return true;
-	    }
-	    return !!(node.pre ||
-	        (!node.hasBindings && // no dynamic bindings
-	            !node.if &&
-	            !node.for && // not v-if or v-for or v-else
-	            !isBuiltInTag(node.tag) && // not a built-in
-	            isPlatformReservedTag$1(node.tag) && // not a component
-	            !isDirectChildOfTemplateFor(node) &&
-	            Object.keys(node).every(isStaticKey)));
-	}
-	function isDirectChildOfTemplateFor(node) {
-	    while (node.parent) {
-	        node = node.parent;
-	        if (node.tag !== 'template') {
-	            return false;
-	        }
-	        if (node.for) {
-	            return true;
-	        }
-	    }
-	    return false;
+	/**
+	 * Cross-platform codegen helper for generating v-model value assignment code.
+	 */
+	function genAssignmentCode(value, assignment) {
+	    const res = parseModel(value);
+	    if (res.key === null) {
+	        return `${value}=${assignment}`;
+	    }
+	    else {
+	        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+	    }
 	}
-
-	const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-	const fnInvokeRE = /\([^)]*?\);*$/;
-	const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-	// KeyboardEvent.keyCode aliases
-	const keyCodes = {
-	    esc: 27,
-	    tab: 9,
-	    enter: 13,
-	    space: 32,
-	    up: 38,
-	    left: 37,
-	    right: 39,
-	    down: 40,
-	    delete: [8, 46],
-	};
-	// KeyboardEvent.key aliases
-	const keyNames = {
-	    // #7880: IE11 and Edge use `Esc` for Escape key name.
-	    esc: ['Esc', 'Escape'],
-	    tab: 'Tab',
-	    enter: 'Enter',
-	    // #9112: IE11 uses `Spacebar` for Space key name.
-	    space: [' ', 'Spacebar'],
-	    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-	    up: ['Up', 'ArrowUp'],
-	    left: ['Left', 'ArrowLeft'],
-	    right: ['Right', 'ArrowRight'],
-	    down: ['Down', 'ArrowDown'],
-	    // #9112: IE11 uses `Del` for Delete key name.
-	    delete: ['Backspace', 'Delete', 'Del'],
-	};
-	// #4868: modifiers that prevent the execution of the listener
-	// need to explicitly return null so that we can determine whether to remove
-	// the listener for .once
-	const genGuard = (condition) => `if(${condition})return null;`;
-	const modifierCode = {
-	    stop: '$event.stopPropagation();',
-	    prevent: '$event.preventDefault();',
-	    self: genGuard(`$event.target !== $event.currentTarget`),
-	    ctrl: genGuard(`!$event.ctrlKey`),
-	    shift: genGuard(`!$event.shiftKey`),
-	    alt: genGuard(`!$event.altKey`),
-	    meta: genGuard(`!$event.metaKey`),
-	    left: genGuard(`'button' in $event && $event.button !== 0`),
-	    middle: genGuard(`'button' in $event && $event.button !== 1`),
-	    right: genGuard(`'button' in $event && $event.button !== 2`),
-	};
-	function genHandlers(events, isNative) {
-	    const prefix = isNative ? 'nativeOn:' : 'on:';
-	    let staticHandlers = ``;
-	    let dynamicHandlers = ``;
-	    for (const name in events) {
-	        const handlerCode = genHandler(events[name]);
-	        //@ts-expect-error
-	        if (events[name] && events[name].dynamic) {
-	            dynamicHandlers += `${name},${handlerCode},`;
-	        }
-	        else {
-	            staticHandlers += `"${name}":${handlerCode},`;
-	        }
-	    }
-	    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-	    if (dynamicHandlers) {
-	        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-	    }
-	    else {
-	        return prefix + staticHandlers;
-	    }
-	}
-	function genHandler(handler) {
-	    if (!handler) {
-	        return 'function(){}';
-	    }
-	    if (Array.isArray(handler)) {
-	        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-	    }
-	    const isMethodPath = simplePathRE.test(handler.value);
-	    const isFunctionExpression = fnExpRE.test(handler.value);
-	    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-	    if (!handler.modifiers) {
-	        if (isMethodPath || isFunctionExpression) {
-	            return handler.value;
-	        }
-	        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-	    }
-	    else {
-	        let code = '';
-	        let genModifierCode = '';
-	        const keys = [];
-	        for (const key in handler.modifiers) {
-	            if (modifierCode[key]) {
-	                genModifierCode += modifierCode[key];
-	                // left/right
-	                if (keyCodes[key]) {
-	                    keys.push(key);
-	                }
-	            }
-	            else if (key === 'exact') {
-	                const modifiers = handler.modifiers;
-	                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-	                    .filter((keyModifier) => !modifiers[keyModifier])
-	                    .map((keyModifier) => `$event.${keyModifier}Key`)
-	                    .join('||'));
-	            }
-	            else {
-	                keys.push(key);
-	            }
-	        }
-	        if (keys.length) {
-	            code += genKeyFilter(keys);
-	        }
-	        // Make sure modifiers like prevent and stop get executed after key filtering
-	        if (genModifierCode) {
-	            code += genModifierCode;
-	        }
-	        const handlerCode = isMethodPath
-	            ? `return ${handler.value}.apply(null, arguments)`
-	            : isFunctionExpression
-	                ? `return (${handler.value}).apply(null, arguments)`
-	                : isFunctionInvocation
-	                    ? `return ${handler.value}`
-	                    : handler.value;
-	        return `function($event){${code}${handlerCode}}`;
-	    }
-	}
-	function genKeyFilter(keys) {
-	    return (
-	    // make sure the key filters only apply to KeyboardEvents
-	    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-	    // key events that do not have keyCode property...
-	    `if(!$event.type.indexOf('key')&&` +
-	        `${keys.map(genFilterCode).join('&&')})return null;`);
-	}
-	function genFilterCode(key) {
-	    const keyVal = parseInt(key, 10);
-	    if (keyVal) {
-	        return `$event.keyCode!==${keyVal}`;
-	    }
-	    const keyCode = keyCodes[key];
-	    const keyName = keyNames[key];
-	    return (`_k($event.keyCode,` +
-	        `${JSON.stringify(key)},` +
-	        `${JSON.stringify(keyCode)},` +
-	        `$event.key,` +
-	        `${JSON.stringify(keyName)}` +
-	        `)`);
+	/**
+	 * Parse a v-model expression into a base path and a final key segment.
+	 * Handles both dot-path and possible square brackets.
+	 *
+	 * Possible cases:
+	 *
+	 * - test
+	 * - test[key]
+	 * - test[test1[key]]
+	 * - test["a"][key]
+	 * - xxx.test[a[a].test1[key]]
+	 * - test.xxx.a["asa"][test1[key]]
+	 *
+	 */
+	let len, str, chr, index, expressionPos, expressionEndPos;
+	function parseModel(val) {
+	    // Fix https://github.com/vuejs/vue/pull/7730
+	    // allow v-model="obj.val " (trailing whitespace)
+	    val = val.trim();
+	    len = val.length;
+	    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+	        index = val.lastIndexOf('.');
+	        if (index > -1) {
+	            return {
+	                exp: val.slice(0, index),
+	                key: '"' + val.slice(index + 1) + '"',
+	            };
+	        }
+	        else {
+	            return {
+	                exp: val,
+	                key: null,
+	            };
+	        }
+	    }
+	    str = val;
+	    index = expressionPos = expressionEndPos = 0;
+	    while (!eof()) {
+	        chr = next();
+	        /* istanbul ignore if */
+	        if (isStringStart(chr)) {
+	            parseString(chr);
+	        }
+	        else if (chr === 0x5b) {
+	            parseBracket(chr);
+	        }
+	    }
+	    return {
+	        exp: val.slice(0, expressionPos),
+	        key: val.slice(expressionPos + 1, expressionEndPos),
+	    };
 	}
-
-	function on(el, dir) {
-	    if (dir.modifiers) {
-	        warn$2(`v-on without argument does not support modifiers.`);
-	    }
-	    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+	function next() {
+	    return str.charCodeAt(++index);
 	}
-
-	function bind(el, dir) {
-	    el.wrapData = (code) => {
-	        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-	    };
+	function eof() {
+	    return index >= len;
 	}
-
-	var baseDirectives = {
-	    on,
-	    bind,
-	    cloak: noop,
-	};
-
-	class CodegenState {
-	    options;
-	    warn;
-	    transforms;
-	    dataGenFns;
-	    directives;
-	    maybeComponent;
-	    onceId;
-	    staticRenderFns;
-	    pre;
-	    constructor(options) {
-	        this.options = options;
-	        this.warn = options.warn || baseWarn;
-	        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-	        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-	        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-	        this.directives = extend(extend({}, baseDirectives), options.directives);
-	        const isReservedTag = options.isReservedTag || no;
-	        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-	        this.onceId = 0;
-	        this.staticRenderFns = [];
-	        this.pre = false;
-	    }
-	}
-	function generate$1(ast, options) {
-	    const state = new CodegenState(options);
-	    // fix #11483, Root level <script> tags should not be rendered.
-	    const code = ast
-	        ? ast.tag === 'script'
-	            ? 'null'
-	            : genElement(ast, state)
-	        : '_c("div")';
-	    return {
-	        render: `with(this){return ${code}}`,
-	        staticRenderFns: state.staticRenderFns,
-	    };
-	}
-	function genElement(el, state) {
-	    if (el.parent) {
-	        el.pre = el.pre || el.parent.pre;
-	    }
-	    if (el.staticRoot && !el.staticProcessed) {
-	        return genStatic(el, state);
-	    }
-	    else if (el.once && !el.onceProcessed) {
-	        return genOnce(el, state);
-	    }
-	    else if (el.for && !el.forProcessed) {
-	        return genFor(el, state);
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        return genIf(el, state);
-	    }
-	    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-	        return genChildren(el, state) || 'void 0';
-	    }
-	    else if (el.tag === 'slot') {
-	        return genSlot(el, state);
-	    }
-	    else {
-	        // component or element
-	        let code;
-	        if (el.component) {
-	            code = genComponent(el.component, el, state);
-	        }
-	        else {
-	            let data;
-	            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-	                data = genData(el, state);
-	            }
-	            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-	            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-	        }
-	        // module transforms
-	        for (let i = 0; i < state.transforms.length; i++) {
-	            code = state.transforms[i](el, code);
-	        }
-	        return code;
-	    }
-	}
-	// hoist static sub-trees out
-	function genStatic(el, state) {
-	    el.staticProcessed = true;
-	    // Some elements (templates) need to behave differently inside of a v-pre
-	    // node.  All pre nodes are static roots, so we can use this as a location to
-	    // wrap a state change and reset it upon exiting the pre node.
-	    const originalPreState = state.pre;
-	    if (el.pre) {
-	        state.pre = el.pre;
-	    }
-	    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-	    state.pre = originalPreState;
-	    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-	}
-	// v-once
-	function genOnce(el, state) {
-	    el.onceProcessed = true;
-	    if (el.if && !el.ifProcessed) {
-	        return genIf(el, state);
-	    }
-	    else if (el.staticInFor) {
-	        let key = '';
-	        let parent = el.parent;
-	        while (parent) {
-	            if (parent.for) {
-	                key = parent.key;
-	                break;
-	            }
-	            parent = parent.parent;
-	        }
-	        if (!key) {
-	            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-	            return genElement(el, state);
-	        }
-	        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-	    }
-	    else {
-	        return genStatic(el, state);
-	    }
-	}
-	function genIf(el, state, altGen, altEmpty) {
-	    el.ifProcessed = true; // avoid recursion
-	    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-	}
-	function genIfConditions(conditions, state, altGen, altEmpty) {
-	    if (!conditions.length) {
-	        return altEmpty || '_e()';
-	    }
-	    const condition = conditions.shift();
-	    if (condition.exp) {
-	        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-	    }
-	    else {
-	        return `${genTernaryExp(condition.block)}`;
-	    }
-	    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-	    function genTernaryExp(el) {
-	        return altGen
-	            ? altGen(el, state)
-	            : el.once
-	                ? genOnce(el, state)
-	                : genElement(el, state);
-	    }
-	}
-	function genFor(el, state, altGen, altHelper) {
-	    const exp = el.for;
-	    const alias = el.alias;
-	    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-	    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-	    if (state.maybeComponent(el) &&
-	        el.tag !== 'slot' &&
-	        el.tag !== 'template' &&
-	        !el.key) {
-	        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-	            `v-for should have explicit keys. ` +
-	            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-	    }
-	    el.forProcessed = true; // avoid recursion
-	    return (`${altHelper || '_l'}((${exp}),` +
-	        `function(${alias}${iterator1}${iterator2}){` +
-	        `return ${(altGen || genElement)(el, state)}` +
-	        '})');
-	}
-	function genData(el, state) {
-	    let data = '{';
-	    // directives first.
-	    // directives may mutate the el's other properties before they are generated.
-	    const dirs = genDirectives(el, state);
-	    if (dirs)
-	        data += dirs + ',';
-	    // key
-	    if (el.key) {
-	        data += `key:${el.key},`;
-	    }
-	    // ref
-	    if (el.ref) {
-	        data += `ref:${el.ref},`;
-	    }
-	    if (el.refInFor) {
-	        data += `refInFor:true,`;
-	    }
-	    // pre
-	    if (el.pre) {
-	        data += `pre:true,`;
-	    }
-	    // record original tag name for components using "is" attribute
-	    if (el.component) {
-	        data += `tag:"${el.tag}",`;
-	    }
-	    // module data generation functions
-	    for (let i = 0; i < state.dataGenFns.length; i++) {
-	        data += state.dataGenFns[i](el);
-	    }
-	    // attributes
-	    if (el.attrs) {
-	        data += `attrs:${genProps(el.attrs)},`;
-	    }
-	    // DOM props
-	    if (el.props) {
-	        data += `domProps:${genProps(el.props)},`;
-	    }
-	    // event handlers
-	    if (el.events) {
-	        data += `${genHandlers(el.events, false)},`;
-	    }
-	    if (el.nativeEvents) {
-	        data += `${genHandlers(el.nativeEvents, true)},`;
-	    }
-	    // slot target
-	    // only for non-scoped slots
-	    if (el.slotTarget && !el.slotScope) {
-	        data += `slot:${el.slotTarget},`;
-	    }
-	    // scoped slots
-	    if (el.scopedSlots) {
-	        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-	    }
-	    // component v-model
-	    if (el.model) {
-	        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-	    }
-	    // inline-template
-	    if (el.inlineTemplate) {
-	        const inlineTemplate = genInlineTemplate(el, state);
-	        if (inlineTemplate) {
-	            data += `${inlineTemplate},`;
-	        }
-	    }
-	    data = data.replace(/,$/, '') + '}';
-	    // v-bind dynamic argument wrap
-	    // v-bind with dynamic arguments must be applied using the same v-bind object
-	    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-	    if (el.dynamicAttrs) {
-	        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-	    }
-	    // v-bind data wrap
-	    if (el.wrapData) {
-	        data = el.wrapData(data);
-	    }
-	    // v-on data wrap
-	    if (el.wrapListeners) {
-	        data = el.wrapListeners(data);
-	    }
-	    return data;
-	}
-	function genDirectives(el, state) {
-	    const dirs = el.directives;
-	    if (!dirs)
-	        return;
-	    let res = 'directives:[';
-	    let hasRuntime = false;
-	    let i, l, dir, needRuntime;
-	    for (i = 0, l = dirs.length; i < l; i++) {
-	        dir = dirs[i];
-	        needRuntime = true;
-	        const gen = state.directives[dir.name];
-	        if (gen) {
-	            // compile-time directive that manipulates AST.
-	            // returns true if it also needs a runtime counterpart.
-	            needRuntime = !!gen(el, dir, state.warn);
-	        }
-	        if (needRuntime) {
-	            hasRuntime = true;
-	            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-	        }
-	    }
-	    if (hasRuntime) {
-	        return res.slice(0, -1) + ']';
-	    }
-	}
-	function genInlineTemplate(el, state) {
-	    const ast = el.children[0];
-	    if ((el.children.length !== 1 || ast.type !== 1)) {
-	        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-	    }
-	    if (ast && ast.type === 1) {
-	        const inlineRenderFns = generate$1(ast, state.options);
-	        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-	    }
-	}
-	function genScopedSlots(el, slots, state) {
-	    // by default scoped slots are considered "stable", this allows child
-	    // components with only scoped slots to skip forced updates from parent.
-	    // but in some cases we have to bail-out of this optimization
-	    // for example if the slot contains dynamic names, has v-if or v-for on them...
-	    let needsForceUpdate = el.for ||
-	        Object.keys(slots).some((key) => {
-	            const slot = slots[key];
-	            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-	            );
-	        });
-	    // #9534: if a component with scoped slots is inside a conditional branch,
-	    // it's possible for the same component to be reused but with different
-	    // compiled slot content. To avoid that, we generate a unique key based on
-	    // the generated code of all the slot contents.
-	    let needsKey = !!el.if;
-	    // OR when it is inside another scoped slot or v-for (the reactivity may be
-	    // disconnected due to the intermediate scope variable)
-	    // #9438, #9506
-	    // TODO: this can be further optimized by properly analyzing in-scope bindings
-	    // and skip force updating ones that do not actually use scope variables.
-	    if (!needsForceUpdate) {
-	        let parent = el.parent;
-	        while (parent) {
-	            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-	                parent.for) {
-	                needsForceUpdate = true;
-	                break;
-	            }
-	            if (parent.if) {
-	                needsKey = true;
-	            }
-	            parent = parent.parent;
-	        }
-	    }
-	    const generatedSlots = Object.keys(slots)
-	        .map((key) => genScopedSlot(slots[key], state))
-	        .join(',');
-	    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-	}
-	function hash(str) {
-	    let hash = 5381;
-	    let i = str.length;
-	    while (i) {
-	        hash = (hash * 33) ^ str.charCodeAt(--i);
-	    }
-	    return hash >>> 0;
-	}
-	function containsSlotChild(el) {
-	    if (el.type === 1) {
-	        if (el.tag === 'slot') {
-	            return true;
-	        }
-	        return el.children.some(containsSlotChild);
-	    }
-	    return false;
-	}
-	function genScopedSlot(el, state) {
-	    const isLegacySyntax = el.attrsMap['slot-scope'];
-	    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-	        return genIf(el, state, genScopedSlot, `null`);
-	    }
-	    if (el.for && !el.forProcessed) {
-	        return genFor(el, state, genScopedSlot);
-	    }
-	    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-	    const fn = `function(${slotScope}){` +
-	        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-	    // reverse proxy v-slot without scope on this.$slots
-	    const reverseProxy = slotScope ? `` : `,proxy:true`;
-	    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-	}
-	function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-	    const children = el.children;
-	    if (children.length) {
-	        const el = children[0];
-	        // optimize single v-for
-	        if (children.length === 1 &&
-	            el.for &&
-	            el.tag !== 'template' &&
-	            el.tag !== 'slot') {
-	            const normalizationType = checkSkip
-	                ? state.maybeComponent(el)
-	                    ? `,1`
-	                    : `,0`
-	                : ``;
-	            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-	        }
-	        const normalizationType = checkSkip
-	            ? getNormalizationType(children, state.maybeComponent)
-	            : 0;
-	        const gen = altGenNode || genNode;
-	        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-	    }
-	}
-	// determine the normalization needed for the children array.
-	// 0: no normalization needed
-	// 1: simple normalization needed (possible 1-level deep nested array)
-	// 2: full normalization needed
-	function getNormalizationType(children, maybeComponent) {
-	    let res = 0;
-	    for (let i = 0; i < children.length; i++) {
-	        const el = children[i];
-	        if (el.type !== 1) {
-	            continue;
-	        }
-	        if (needsNormalization(el) ||
-	            (el.ifConditions &&
-	                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-	            res = 2;
-	            break;
-	        }
-	        if (maybeComponent(el) ||
-	            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-	            res = 1;
-	        }
-	    }
-	    return res;
-	}
-	function needsNormalization(el) {
-	    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-	}
-	function genNode(node, state) {
-	    if (node.type === 1) {
-	        return genElement(node, state);
-	    }
-	    else if (node.type === 3 && node.isComment) {
-	        return genComment(node);
-	    }
-	    else {
-	        return genText(node);
-	    }
-	}
-	function genText(text) {
-	    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-	}
-	function genComment(comment) {
-	    return `_e(${JSON.stringify(comment.text)})`;
-	}
-	function genSlot(el, state) {
-	    const slotName = el.slotName || '"default"';
-	    const children = genChildren(el, state);
-	    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-	    const attrs = el.attrs || el.dynamicAttrs
-	        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-	            // slot props are camelized
-	            name: camelize(attr.name),
-	            value: attr.value,
-	            dynamic: attr.dynamic
-	        })))
-	        : null;
-	    const bind = el.attrsMap['v-bind'];
-	    if ((attrs || bind) && !children) {
-	        res += `,null`;
-	    }
-	    if (attrs) {
-	        res += `,${attrs}`;
-	    }
-	    if (bind) {
-	        res += `${attrs ? '' : ',null'},${bind}`;
-	    }
-	    return res + ')';
-	}
-	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-	function genComponent(componentName, el, state) {
-	    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-	    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-	}
-	function genProps(props) {
-	    let staticProps = ``;
-	    let dynamicProps = ``;
-	    for (let i = 0; i < props.length; i++) {
-	        const prop = props[i];
-	        const value = transformSpecialNewlines(prop.value);
-	        if (prop.dynamic) {
-	            dynamicProps += `${prop.name},${value},`;
-	        }
-	        else {
-	            staticProps += `"${prop.name}":${value},`;
-	        }
-	    }
-	    staticProps = `{${staticProps.slice(0, -1)}}`;
-	    if (dynamicProps) {
-	        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-	    }
-	    else {
-	        return staticProps;
-	    }
-	}
-	// #3895, #4268
-	function transformSpecialNewlines(text) {
-	    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+	function isStringStart(chr) {
+	    return chr === 0x22 || chr === 0x27;
 	}
-
-	// these keywords should not appear inside expressions, but operators like
-	// typeof, instanceof and in are allowed
-	const prohibitedKeywordRE = new RegExp('\\b' +
-	    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-	        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-	        'extends,finally,continue,debugger,function,arguments')
-	        .split(',')
-	        .join('\\b|\\b') +
-	    '\\b');
-	// these unary operators should not be used as property/method names
-	const unaryOperatorsRE = new RegExp('\\b' +
-	    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-	    '\\s*\\([^\\)]*\\)');
-	// strip strings in expressions
-	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-	// detect problematic expressions in a template
-	function detectErrors(ast, warn) {
-	    if (ast) {
-	        checkNode(ast, warn);
-	    }
-	}
-	function checkNode(node, warn) {
-	    if (node.type === 1) {
-	        for (const name in node.attrsMap) {
-	            if (dirRE.test(name)) {
-	                const value = node.attrsMap[name];
-	                if (value) {
-	                    const range = node.rawAttrsMap[name];
-	                    if (name === 'v-for') {
-	                        checkFor(node, `v-for="${value}"`, warn, range);
-	                    }
-	                    else if (name === 'v-slot' || name[0] === '#') {
-	                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-	                    }
-	                    else if (onRE.test(name)) {
-	                        checkEvent(value, `${name}="${value}"`, warn, range);
-	                    }
-	                    else {
-	                        checkExpression(value, `${name}="${value}"`, warn, range);
-	                    }
-	                }
-	            }
-	        }
-	        if (node.children) {
-	            for (let i = 0; i < node.children.length; i++) {
-	                checkNode(node.children[i], warn);
-	            }
-	        }
-	    }
-	    else if (node.type === 2) {
-	        checkExpression(node.expression, node.text, warn, node);
-	    }
-	}
-	function checkEvent(exp, text, warn, range) {
-	    const stripped = exp.replace(stripStringRE, '');
-	    const keywordMatch = stripped.match(unaryOperatorsRE);
-	    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-	        warn(`avoid using JavaScript unary operator as property name: ` +
-	            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-	    }
-	    checkExpression(exp, text, warn, range);
-	}
-	function checkFor(node, text, warn, range) {
-	    checkExpression(node.for || '', text, warn, range);
-	    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-	    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-	    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-	}
-	function checkIdentifier(ident, type, text, warn, range) {
-	    if (typeof ident === 'string') {
-	        try {
-	            new Function(`var ${ident}=_`);
-	        }
-	        catch (e) {
-	            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-	        }
-	    }
-	}
-	function checkExpression(exp, text, warn, range) {
-	    try {
-	        new Function(`return ${exp}`);
-	    }
-	    catch (e) {
-	        const keywordMatch = exp
-	            .replace(stripStringRE, '')
-	            .match(prohibitedKeywordRE);
-	        if (keywordMatch) {
-	            warn(`avoid using JavaScript keyword as property name: ` +
-	                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-	        }
-	        else {
-	            warn(`invalid expression: ${e.message} in\n\n` +
-	                `    ${exp}\n\n` +
-	                `  Raw expression: ${text.trim()}\n`, range);
-	        }
-	    }
-	}
-	function checkFunctionParameterExpression(exp, text, warn, range) {
-	    try {
-	        new Function(exp, '');
-	    }
-	    catch (e) {
-	        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-	            `    ${exp}\n\n` +
-	            `  Raw expression: ${text.trim()}\n`, range);
-	    }
+	function parseBracket(chr) {
+	    let inBracket = 1;
+	    expressionPos = index;
+	    while (!eof()) {
+	        chr = next();
+	        if (isStringStart(chr)) {
+	            parseString(chr);
+	            continue;
+	        }
+	        if (chr === 0x5b)
+	            inBracket++;
+	        if (chr === 0x5d)
+	            inBracket--;
+	        if (inBracket === 0) {
+	            expressionEndPos = index;
+	            break;
+	        }
+	    }
 	}
-
-	const range = 2;
-	function generateCodeFrame(source, start = 0, end = source.length) {
-	    const lines = source.split(/\r?\n/);
-	    let count = 0;
-	    const res = [];
-	    for (let i = 0; i < lines.length; i++) {
-	        count += lines[i].length + 1;
-	        if (count >= start) {
-	            for (let j = i - range; j <= i + range || end > count; j++) {
-	                if (j < 0 || j >= lines.length)
-	                    continue;
-	                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-	                const lineLength = lines[j].length;
-	                if (j === i) {
-	                    // push underline
-	                    const pad = start - (count - lineLength) + 1;
-	                    const length = end > count ? lineLength - pad : end - start;
-	                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-	                }
-	                else if (j > i) {
-	                    if (end > count) {
-	                        const length = Math.min(end - count, lineLength);
-	                        res.push(`   |  ` + repeat(`^`, length));
-	                    }
-	                    count += lineLength + 1;
-	                }
-	            }
-	            break;
-	        }
-	    }
-	    return res.join('\n');
-	}
-	function repeat(str, n) {
-	    let result = '';
-	    if (n > 0) {
-	        // eslint-disable-next-line no-constant-condition
-	        while (true) {
-	            // eslint-disable-line
-	            if (n & 1)
-	                result += str;
-	            n >>>= 1;
-	            if (n <= 0)
-	                break;
-	            str += str;
-	        }
-	    }
-	    return result;
+	function parseString(chr) {
+	    const stringQuote = chr;
+	    while (!eof()) {
+	        chr = next();
+	        if (chr === stringQuote) {
+	            break;
+	        }
+	    }
 	}
 
-	function createFunction(code, errors) {
-	    try {
-	        return new Function(code);
-	    }
-	    catch (err) {
-	        errors.push({ err, code });
-	        return noop;
-	    }
-	}
-	function createCompileToFunctionFn(compile) {
-	    const cache = Object.create(null);
-	    return function compileToFunctions(template, options, vm) {
-	        options = extend({}, options);
-	        const warn = options.warn || warn$2;
-	        delete options.warn;
-	        /* istanbul ignore if */
-	        {
-	            // detect possible CSP restriction
-	            try {
-	                new Function('return 1');
-	            }
-	            catch (e) {
-	                if (e.toString().match(/unsafe-eval|CSP/)) {
-	                    warn('It seems you are using the standalone build of Vue.js in an ' +
-	                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-	                        'The template compiler cannot work in this environment. Consider ' +
-	                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-	                        'templates into render functions.');
-	                }
-	            }
-	        }
-	        // check cache
-	        const key = options.delimiters
-	            ? String(options.delimiters) + template
-	            : template;
-	        if (cache[key]) {
-	            return cache[key];
-	        }
-	        // compile
-	        const compiled = compile(template, options);
-	        // check compilation errors/tips
-	        {
-	            if (compiled.errors && compiled.errors.length) {
-	                if (options.outputSourceRange) {
-	                    compiled.errors.forEach((e) => {
-	                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-	                            generateCodeFrame(template, e.start, e.end), vm);
-	                    });
-	                }
-	                else {
-	                    warn(`Error compiling template:\n\n${template}\n\n` +
-	                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-	                        '\n', vm);
-	                }
-	            }
-	            if (compiled.tips && compiled.tips.length) {
-	                if (options.outputSourceRange) {
-	                    compiled.tips.forEach((e) => tip(e.msg, vm));
-	                }
-	                else {
-	                    compiled.tips.forEach((msg) => tip(msg, vm));
-	                }
-	            }
-	        }
-	        // turn code into functions
-	        const res = {};
-	        const fnGenErrors = [];
-	        res.render = createFunction(compiled.render, fnGenErrors);
-	        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-	            return createFunction(code, fnGenErrors);
-	        });
-	        // check function generation errors.
-	        // this should only happen if there is a bug in the compiler itself.
-	        // mostly for codegen development use
-	        /* istanbul ignore if */
-	        {
-	            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-	                warn(`Failed to generate render function:\n\n` +
-	                    fnGenErrors
-	                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-	                        .join('\n'), vm);
-	            }
-	        }
-	        return (cache[key] = res);
-	    };
+	const onRE = /^@|^v-on:/;
+	const dirRE = /^v-|^@|^:|^#/;
+	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+	const stripParensRE = /^\(|\)$/g;
+	const dynamicArgRE = /^\[.*\]$/;
+	const argRE = /:(.*)$/;
+	const bindRE = /^:|^\.|^v-bind:/;
+	const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+	const slotRE = /^v-slot(:|$)|^#/;
+	const lineBreakRE = /[\r\n]/;
+	const whitespaceRE = /[ \f\t\r\n]+/g;
+	const invalidAttributeRE = /[\s"'<>\/=]/;
+	const decodeHTMLCached = cached(he.decode);
+	const emptySlotScopeToken = `_empty_`;
+	// configurable state
+	let warn$1;
+	let delimiters;
+	let transforms;
+	let preTransforms;
+	let postTransforms;
+	let platformIsPreTag;
+	let platformMustUseProp;
+	let platformGetTagNamespace;
+	let maybeComponent;
+	function createASTElement(tag, attrs, parent) {
+	    return {
+	        type: 1,
+	        tag,
+	        attrsList: attrs,
+	        attrsMap: makeAttrsMap(attrs),
+	        rawAttrsMap: {},
+	        parent,
+	        children: [],
+	    };
+	}
+	/**
+	 * Convert HTML string to AST.
+	 */
+	function parse(template, options) {
+	    warn$1 = options.warn || baseWarn;
+	    platformIsPreTag = options.isPreTag || no;
+	    platformMustUseProp = options.mustUseProp || no;
+	    platformGetTagNamespace = options.getTagNamespace || no;
+	    const isReservedTag = options.isReservedTag || no;
+	    maybeComponent = (el) => !!(el.component ||
+	        el.attrsMap[':is'] ||
+	        el.attrsMap['v-bind:is'] ||
+	        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+	    transforms = pluckModuleFunction(options.modules, 'transformNode');
+	    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+	    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+	    delimiters = options.delimiters;
+	    const stack = [];
+	    const preserveWhitespace = options.preserveWhitespace !== false;
+	    const whitespaceOption = options.whitespace;
+	    let root;
+	    let currentParent;
+	    let inVPre = false;
+	    let inPre = false;
+	    let warned = false;
+	    function warnOnce(msg, range) {
+	        if (!warned) {
+	            warned = true;
+	            warn$1(msg, range);
+	        }
+	    }
+	    function closeElement(element) {
+	        trimEndingWhitespace(element);
+	        if (!inVPre && !element.processed) {
+	            element = processElement(element, options);
+	        }
+	        // tree management
+	        if (!stack.length && element !== root) {
+	            // allow root elements with v-if, v-else-if and v-else
+	            if (root.if && (element.elseif || element.else)) {
+	                {
+	                    checkRootConstraints(element);
+	                }
+	                addIfCondition(root, {
+	                    exp: element.elseif,
+	                    block: element,
+	                });
+	            }
+	            else {
+	                warnOnce(`Component template should contain exactly one root element. ` +
+	                    `If you are using v-if on multiple elements, ` +
+	                    `use v-else-if to chain them instead.`, { start: element.start });
+	            }
+	        }
+	        if (currentParent && !element.forbidden) {
+	            if (element.elseif || element.else) {
+	                processIfConditions(element, currentParent);
+	            }
+	            else {
+	                if (element.slotScope) {
+	                    // scoped slot
+	                    // keep it in the children list so that v-else(-if) conditions can
+	                    // find it as the prev node.
+	                    const name = element.slotTarget || '"default"';
+	                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+	                }
+	                currentParent.children.push(element);
+	                element.parent = currentParent;
+	            }
+	        }
+	        // final children cleanup
+	        // filter out scoped slots
+	        element.children = element.children.filter((c) => !c.slotScope);
+	        // remove trailing whitespace node again
+	        trimEndingWhitespace(element);
+	        // check pre state
+	        if (element.pre) {
+	            inVPre = false;
+	        }
+	        if (platformIsPreTag(element.tag)) {
+	            inPre = false;
+	        }
+	        // apply post-transforms
+	        for (let i = 0; i < postTransforms.length; i++) {
+	            postTransforms[i](element, options);
+	        }
+	    }
+	    function trimEndingWhitespace(el) {
+	        // remove trailing whitespace node
+	        if (!inPre) {
+	            let lastNode;
+	            while ((lastNode = el.children[el.children.length - 1]) &&
+	                lastNode.type === 3 &&
+	                lastNode.text === ' ') {
+	                el.children.pop();
+	            }
+	        }
+	    }
+	    function checkRootConstraints(el) {
+	        if (el.tag === 'slot' || el.tag === 'template') {
+	            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+	                'contain multiple nodes.', { start: el.start });
+	        }
+	        if (el.attrsMap.hasOwnProperty('v-for')) {
+	            warnOnce('Cannot use v-for on stateful component root element because ' +
+	                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+	        }
+	    }
+	    parseHTML(template, {
+	        warn: warn$1,
+	        expectHTML: options.expectHTML,
+	        isUnaryTag: options.isUnaryTag,
+	        canBeLeftOpenTag: options.canBeLeftOpenTag,
+	        shouldDecodeNewlines: options.shouldDecodeNewlines,
+	        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+	        shouldKeepComment: options.comments,
+	        outputSourceRange: options.outputSourceRange,
+	        start(tag, attrs, unary, start, end) {
+	            // check namespace.
+	            // inherit parent ns if there is one
+	            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+	            // handle IE svg bug
+	            /* istanbul ignore if */
+	            if (isIE && ns === 'svg') {
+	                attrs = guardIESVGBug(attrs);
+	            }
+	            let element = createASTElement(tag, attrs, currentParent);
+	            if (ns) {
+	                element.ns = ns;
+	            }
+	            {
+	                if (options.outputSourceRange) {
+	                    element.start = start;
+	                    element.end = end;
+	                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+	                        cumulated[attr.name] = attr;
+	                        return cumulated;
+	                    }, {});
+	                }
+	                attrs.forEach((attr) => {
+	                    if (invalidAttributeRE.test(attr.name)) {
+	                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+	                            `spaces, quotes, <, >, / or =.`, {
+	                            start: attr.start + attr.name.indexOf(`[`),
+	                            end: attr.start + attr.name.length,
+	                        });
+	                    }
+	                });
+	            }
+	            if (isForbiddenTag(element) && !isServerRendering()) {
+	                element.forbidden = true;
+	                warn$1('Templates should only be responsible for mapping the state to the ' +
+	                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+	                        `<${tag}>` +
+	                        ', as they will not be parsed.', { start: element.start });
+	            }
+	            // apply pre-transforms
+	            for (let i = 0; i < preTransforms.length; i++) {
+	                element = preTransforms[i](element, options) || element;
+	            }
+	            if (!inVPre) {
+	                processPre(element);
+	                if (element.pre) {
+	                    inVPre = true;
+	                }
+	            }
+	            if (platformIsPreTag(element.tag)) {
+	                inPre = true;
+	            }
+	            if (inVPre) {
+	                processRawAttrs(element);
+	            }
+	            else if (!element.processed) {
+	                // structural directives
+	                processFor(element);
+	                processIf(element);
+	                processOnce(element);
+	            }
+	            if (!root) {
+	                root = element;
+	                {
+	                    checkRootConstraints(root);
+	                }
+	            }
+	            if (!unary) {
+	                currentParent = element;
+	                stack.push(element);
+	            }
+	            else {
+	                closeElement(element);
+	            }
+	        },
+	        end(tag, start, end) {
+	            const element = stack[stack.length - 1];
+	            // pop stack
+	            stack.length -= 1;
+	            currentParent = stack[stack.length - 1];
+	            if (options.outputSourceRange) {
+	                element.end = end;
+	            }
+	            closeElement(element);
+	        },
+	        chars(text, start, end) {
+	            if (!currentParent) {
+	                {
+	                    if (text === template) {
+	                        warnOnce('Component template requires a root element, rather than just text.', { start });
+	                    }
+	                    else if ((text = text.trim())) {
+	                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+	                            start,
+	                        });
+	                    }
+	                }
+	                return;
+	            }
+	            // IE textarea placeholder bug
+	            /* istanbul ignore if */
+	            if (isIE &&
+	                currentParent.tag === 'textarea' &&
+	                currentParent.attrsMap.placeholder === text) {
+	                return;
+	            }
+	            const children = currentParent.children;
+	            if (inPre || text.trim()) {
+	                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+	            }
+	            else if (!children.length) {
+	                // remove the whitespace-only node right after an opening tag
+	                text = '';
+	            }
+	            else if (whitespaceOption) {
+	                if (whitespaceOption === 'condense') {
+	                    // in condense mode, remove the whitespace node if it contains
+	                    // line break, otherwise condense to a single space
+	                    text = lineBreakRE.test(text) ? '' : ' ';
+	                }
+	                else {
+	                    text = ' ';
+	                }
+	            }
+	            else {
+	                text = preserveWhitespace ? ' ' : '';
+	            }
+	            if (text) {
+	                if (!inPre && whitespaceOption === 'condense') {
+	                    // condense consecutive whitespaces into single space
+	                    text = text.replace(whitespaceRE, ' ');
+	                }
+	                let res;
+	                let child;
+	                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+	                    child = {
+	                        type: 2,
+	                        expression: res.expression,
+	                        tokens: res.tokens,
+	                        text,
+	                    };
+	                }
+	                else if (text !== ' ' ||
+	                    !children.length ||
+	                    children[children.length - 1].text !== ' ') {
+	                    child = {
+	                        type: 3,
+	                        text,
+	                    };
+	                }
+	                if (child) {
+	                    if (options.outputSourceRange) {
+	                        child.start = start;
+	                        child.end = end;
+	                    }
+	                    children.push(child);
+	                }
+	            }
+	        },
+	        comment(text, start, end) {
+	            // adding anything as a sibling to the root node is forbidden
+	            // comments should still be allowed, but ignored
+	            if (currentParent) {
+	                const child = {
+	                    type: 3,
+	                    text,
+	                    isComment: true,
+	                };
+	                if (options.outputSourceRange) {
+	                    child.start = start;
+	                    child.end = end;
+	                }
+	                currentParent.children.push(child);
+	            }
+	        },
+	    });
+	    return root;
+	}
+	function processPre(el) {
+	    if (getAndRemoveAttr(el, 'v-pre') != null) {
+	        el.pre = true;
+	    }
+	}
+	function processRawAttrs(el) {
+	    const list = el.attrsList;
+	    const len = list.length;
+	    if (len) {
+	        const attrs = (el.attrs = new Array(len));
+	        for (let i = 0; i < len; i++) {
+	            attrs[i] = {
+	                name: list[i].name,
+	                value: JSON.stringify(list[i].value),
+	            };
+	            if (list[i].start != null) {
+	                attrs[i].start = list[i].start;
+	                attrs[i].end = list[i].end;
+	            }
+	        }
+	    }
+	    else if (!el.pre) {
+	        // non root node in pre blocks with no attributes
+	        el.plain = true;
+	    }
+	}
+	function processElement(element, options) {
+	    processKey(element);
+	    // determine whether this is a plain element after
+	    // removing structural attributes
+	    element.plain =
+	        !element.key && !element.scopedSlots && !element.attrsList.length;
+	    processRef(element);
+	    processSlotContent(element);
+	    processSlotOutlet(element);
+	    processComponent(element);
+	    for (let i = 0; i < transforms.length; i++) {
+	        element = transforms[i](element, options) || element;
+	    }
+	    processAttrs(element);
+	    return element;
+	}
+	function processKey(el) {
+	    const exp = getBindingAttr(el, 'key');
+	    if (exp) {
+	        {
+	            if (el.tag === 'template') {
+	                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+	            }
+	            if (el.for) {
+	                const iterator = el.iterator2 || el.iterator1;
+	                const parent = el.parent;
+	                if (iterator &&
+	                    iterator === exp &&
+	                    parent &&
+	                    parent.tag === 'transition-group') {
+	                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+	                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+	                }
+	            }
+	        }
+	        el.key = exp;
+	    }
+	}
+	function processRef(el) {
+	    const ref = getBindingAttr(el, 'ref');
+	    if (ref) {
+	        el.ref = ref;
+	        el.refInFor = checkInFor(el);
+	    }
+	}
+	function processFor(el) {
+	    let exp;
+	    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+	        const res = parseFor(exp);
+	        if (res) {
+	            extend(el, res);
+	        }
+	        else {
+	            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+	        }
+	    }
+	}
+	function parseFor(exp) {
+	    const inMatch = exp.match(forAliasRE);
+	    if (!inMatch)
+	        return;
+	    const res = {};
+	    res.for = inMatch[2].trim();
+	    const alias = inMatch[1].trim().replace(stripParensRE, '');
+	    const iteratorMatch = alias.match(forIteratorRE);
+	    if (iteratorMatch) {
+	        res.alias = alias.replace(forIteratorRE, '').trim();
+	        res.iterator1 = iteratorMatch[1].trim();
+	        if (iteratorMatch[2]) {
+	            res.iterator2 = iteratorMatch[2].trim();
+	        }
+	    }
+	    else {
+	        res.alias = alias;
+	    }
+	    return res;
+	}
+	function processIf(el) {
+	    const exp = getAndRemoveAttr(el, 'v-if');
+	    if (exp) {
+	        el.if = exp;
+	        addIfCondition(el, {
+	            exp: exp,
+	            block: el,
+	        });
+	    }
+	    else {
+	        if (getAndRemoveAttr(el, 'v-else') != null) {
+	            el.else = true;
+	        }
+	        const elseif = getAndRemoveAttr(el, 'v-else-if');
+	        if (elseif) {
+	            el.elseif = elseif;
+	        }
+	    }
+	}
+	function processIfConditions(el, parent) {
+	    const prev = findPrevElement(parent.children);
+	    if (prev && prev.if) {
+	        addIfCondition(prev, {
+	            exp: el.elseif,
+	            block: el,
+	        });
+	    }
+	    else {
+	        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+	            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+	    }
+	}
+	function findPrevElement(children) {
+	    let i = children.length;
+	    while (i--) {
+	        if (children[i].type === 1) {
+	            return children[i];
+	        }
+	        else {
+	            if (children[i].text !== ' ') {
+	                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+	                    `will be ignored.`, children[i]);
+	            }
+	            children.pop();
+	        }
+	    }
+	}
+	function addIfCondition(el, condition) {
+	    if (!el.ifConditions) {
+	        el.ifConditions = [];
+	    }
+	    el.ifConditions.push(condition);
+	}
+	function processOnce(el) {
+	    const once = getAndRemoveAttr(el, 'v-once');
+	    if (once != null) {
+	        el.once = true;
+	    }
+	}
+	// handle content being passed to a component as slot,
+	// e.g. <template slot="xxx">, <div slot-scope="xxx">
+	function processSlotContent(el) {
+	    let slotScope;
+	    if (el.tag === 'template') {
+	        slotScope = getAndRemoveAttr(el, 'scope');
+	        /* istanbul ignore if */
+	        if (slotScope) {
+	            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+	                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+	                `can also be used on plain elements in addition to <template> to ` +
+	                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+	        }
+	        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+	    }
+	    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+	        /* istanbul ignore if */
+	        if (el.attrsMap['v-for']) {
+	            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+	                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+	                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+	        }
+	        el.slotScope = slotScope;
+	    }
+	    // slot="xxx"
+	    const slotTarget = getBindingAttr(el, 'slot');
+	    if (slotTarget) {
+	        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+	        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+	        // preserve slot as an attribute for native shadow DOM compat
+	        // only for non-scoped slots.
+	        if (el.tag !== 'template' && !el.slotScope) {
+	            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+	        }
+	    }
+	    // 2.6 v-slot syntax
+	    {
+	        if (el.tag === 'template') {
+	            // v-slot on <template>
+	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+	            if (slotBinding) {
+	                {
+	                    if (el.slotTarget || el.slotScope) {
+	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+	                    }
+	                    if (el.parent && !maybeComponent(el.parent)) {
+	                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+	                            `the receiving component`, el);
+	                    }
+	                }
+	                const { name, dynamic } = getSlotName(slotBinding);
+	                el.slotTarget = name;
+	                el.slotTargetDynamic = dynamic;
+	                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+	            }
+	        }
+	        else {
+	            // v-slot on component, denotes default slot
+	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+	            if (slotBinding) {
+	                {
+	                    if (!maybeComponent(el)) {
+	                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+	                    }
+	                    if (el.slotScope || el.slotTarget) {
+	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+	                    }
+	                    if (el.scopedSlots) {
+	                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+	                            `<template> syntax when there are other named slots.`, slotBinding);
+	                    }
+	                }
+	                // add the component's children to its default slot
+	                const slots = el.scopedSlots || (el.scopedSlots = {});
+	                const { name, dynamic } = getSlotName(slotBinding);
+	                const slotContainer = (slots[name] = createASTElement('template', [], el));
+	                slotContainer.slotTarget = name;
+	                slotContainer.slotTargetDynamic = dynamic;
+	                slotContainer.children = el.children.filter((c) => {
+	                    if (!c.slotScope) {
+	                        c.parent = slotContainer;
+	                        return true;
+	                    }
+	                });
+	                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+	                // remove children as they are returned from scopedSlots now
+	                el.children = [];
+	                // mark el non-plain so data gets generated
+	                el.plain = false;
+	            }
+	        }
+	    }
+	}
+	function getSlotName(binding) {
+	    let name = binding.name.replace(slotRE, '');
+	    if (!name) {
+	        if (binding.name[0] !== '#') {
+	            name = 'default';
+	        }
+	        else {
+	            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+	        }
+	    }
+	    return dynamicArgRE.test(name)
+	        ? // dynamic [name]
+	            { name: name.slice(1, -1), dynamic: true }
+	        : // static name
+	            { name: `"${name}"`, dynamic: false };
+	}
+	// handle <slot/> outlets
+	function processSlotOutlet(el) {
+	    if (el.tag === 'slot') {
+	        el.slotName = getBindingAttr(el, 'name');
+	        if (el.key) {
+	            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+	                `and can possibly expand into multiple elements. ` +
+	                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+	        }
+	    }
+	}
+	function processComponent(el) {
+	    let binding;
+	    if ((binding = getBindingAttr(el, 'is'))) {
+	        el.component = binding;
+	    }
+	    if (getAndRemoveAttr(el, 'inline-template') != null) {
+	        el.inlineTemplate = true;
+	    }
+	}
+	function processAttrs(el) {
+	    const list = el.attrsList;
+	    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+	    for (i = 0, l = list.length; i < l; i++) {
+	        name = rawName = list[i].name;
+	        value = list[i].value;
+	        if (dirRE.test(name)) {
+	            // mark element as dynamic
+	            el.hasBindings = true;
+	            // modifiers
+	            modifiers = parseModifiers(name.replace(dirRE, ''));
+	            // support .foo shorthand syntax for the .prop modifier
+	            if (modifiers) {
+	                name = name.replace(modifierRE, '');
+	            }
+	            if (bindRE.test(name)) {
+	                // v-bind
+	                name = name.replace(bindRE, '');
+	                value = parseFilters(value);
+	                isDynamic = dynamicArgRE.test(name);
+	                if (isDynamic) {
+	                    name = name.slice(1, -1);
+	                }
+	                if (value.trim().length === 0) {
+	                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+	                }
+	                if (modifiers) {
+	                    if (modifiers.prop && !isDynamic) {
+	                        name = camelize(name);
+	                        if (name === 'innerHtml')
+	                            name = 'innerHTML';
+	                    }
+	                    if (modifiers.camel && !isDynamic) {
+	                        name = camelize(name);
+	                    }
+	                    if (modifiers.sync) {
+	                        syncGen = genAssignmentCode(value, `$event`);
+	                        if (!isDynamic) {
+	                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+	                            if (hyphenate(name) !== camelize(name)) {
+	                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+	                            }
+	                        }
+	                        else {
+	                            // handler w/ dynamic event name
+	                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+	                            );
+	                        }
+	                    }
+	                }
+	                if ((modifiers && modifiers.prop) ||
+	                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+	                    addProp(el, name, value, list[i], isDynamic);
+	                }
+	                else {
+	                    addAttr(el, name, value, list[i], isDynamic);
+	                }
+	            }
+	            else if (onRE.test(name)) {
+	                // v-on
+	                name = name.replace(onRE, '');
+	                isDynamic = dynamicArgRE.test(name);
+	                if (isDynamic) {
+	                    name = name.slice(1, -1);
+	                }
+	                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+	            }
+	            else {
+	                // normal directives
+	                name = name.replace(dirRE, '');
+	                // parse arg
+	                const argMatch = name.match(argRE);
+	                let arg = argMatch && argMatch[1];
+	                isDynamic = false;
+	                if (arg) {
+	                    name = name.slice(0, -(arg.length + 1));
+	                    if (dynamicArgRE.test(arg)) {
+	                        arg = arg.slice(1, -1);
+	                        isDynamic = true;
+	                    }
+	                }
+	                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+	                if (name === 'model') {
+	                    checkForAliasModel(el, value);
+	                }
+	            }
+	        }
+	        else {
+	            // literal attribute
+	            {
+	                const res = parseText(value, delimiters);
+	                if (res) {
+	                    warn$1(`${name}="${value}": ` +
+	                        'Interpolation inside attributes has been removed. ' +
+	                        'Use v-bind or the colon shorthand instead. For example, ' +
+	                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+	                }
+	            }
+	            addAttr(el, name, JSON.stringify(value), list[i]);
+	            // #6887 firefox doesn't update muted state if set via attribute
+	            // even immediately after element creation
+	            if (!el.component &&
+	                name === 'muted' &&
+	                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+	                addProp(el, name, 'true', list[i]);
+	            }
+	        }
+	    }
+	}
+	function checkInFor(el) {
+	    let parent = el;
+	    while (parent) {
+	        if (parent.for !== undefined) {
+	            return true;
+	        }
+	        parent = parent.parent;
+	    }
+	    return false;
+	}
+	function parseModifiers(name) {
+	    const match = name.match(modifierRE);
+	    if (match) {
+	        const ret = {};
+	        match.forEach((m) => {
+	            ret[m.slice(1)] = true;
+	        });
+	        return ret;
+	    }
+	}
+	function makeAttrsMap(attrs) {
+	    const map = {};
+	    for (let i = 0, l = attrs.length; i < l; i++) {
+	        if (map[attrs[i].name] &&
+	            !isIE &&
+	            !isEdge) {
+	            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+	        }
+	        map[attrs[i].name] = attrs[i].value;
+	    }
+	    return map;
+	}
+	// for script (e.g. type="x/template") or style, do not decode content
+	function isTextTag(el) {
+	    return el.tag === 'script' || el.tag === 'style';
+	}
+	function isForbiddenTag(el) {
+	    return (el.tag === 'style' ||
+	        (el.tag === 'script' &&
+	            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+	}
+	const ieNSBug = /^xmlns:NS\d+/;
+	const ieNSPrefix = /^NS\d+:/;
+	/* istanbul ignore next */
+	function guardIESVGBug(attrs) {
+	    const res = [];
+	    for (let i = 0; i < attrs.length; i++) {
+	        const attr = attrs[i];
+	        if (!ieNSBug.test(attr.name)) {
+	            attr.name = attr.name.replace(ieNSPrefix, '');
+	            res.push(attr);
+	        }
+	    }
+	    return res;
+	}
+	function checkForAliasModel(el, value) {
+	    let _el = el;
+	    while (_el) {
+	        if (_el.for && _el.alias === value) {
+	            warn$1(`<${el.tag} v-model="${value}">: ` +
+	                `You are binding v-model directly to a v-for iteration alias. ` +
+	                `This will not be able to modify the v-for source array because ` +
+	                `writing to the alias is like modifying a function local variable. ` +
+	                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+	        }
+	        _el = _el.parent;
+	    }
+	}
+
+	/**
+	 * Expand input[v-model] with dynamic type bindings into v-if-else chains
+	 * Turn this:
+	 *   <input v-model="data[type]" :type="type">
+	 * into this:
+	 *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+	 *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+	 *   <input v-else :type="type" v-model="data[type]">
+	 */
+	function preTransformNode(el, options) {
+	    if (el.tag === 'input') {
+	        const map = el.attrsMap;
+	        if (!map['v-model']) {
+	            return;
+	        }
+	        let typeBinding;
+	        if (map[':type'] || map['v-bind:type']) {
+	            typeBinding = getBindingAttr(el, 'type');
+	        }
+	        if (!map.type && !typeBinding && map['v-bind']) {
+	            typeBinding = `(${map['v-bind']}).type`;
+	        }
+	        if (typeBinding) {
+	            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+	            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+	            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+	            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+	            // 1. checkbox
+	            const branch0 = cloneASTElement(el);
+	            // process for on the main node
+	            processFor(branch0);
+	            addRawAttr(branch0, 'type', 'checkbox');
+	            processElement(branch0, options);
+	            branch0.processed = true; // prevent it from double-processed
+	            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+	            addIfCondition(branch0, {
+	                exp: branch0.if,
+	                block: branch0,
+	            });
+	            // 2. add radio else-if condition
+	            const branch1 = cloneASTElement(el);
+	            getAndRemoveAttr(branch1, 'v-for', true);
+	            addRawAttr(branch1, 'type', 'radio');
+	            processElement(branch1, options);
+	            addIfCondition(branch0, {
+	                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+	                block: branch1,
+	            });
+	            // 3. other
+	            const branch2 = cloneASTElement(el);
+	            getAndRemoveAttr(branch2, 'v-for', true);
+	            addRawAttr(branch2, ':type', typeBinding);
+	            processElement(branch2, options);
+	            addIfCondition(branch0, {
+	                exp: ifCondition,
+	                block: branch2,
+	            });
+	            if (hasElse) {
+	                branch0.else = true;
+	            }
+	            else if (elseIfCondition) {
+	                branch0.elseif = elseIfCondition;
+	            }
+	            return branch0;
+	        }
+	    }
+	}
+	function cloneASTElement(el) {
+	    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+	}
+	var model$1 = {
+	    preTransformNode,
+	};
+
+	var modules = [klass, style, model$1];
+
+	let warn;
+	// in some cases, the event used has to be determined at runtime
+	// so we used some reserved tokens during compile.
+	const RANGE_TOKEN = '__r';
+	function model(el, dir, _warn) {
+	    warn = _warn;
+	    const value = dir.value;
+	    const modifiers = dir.modifiers;
+	    const tag = el.tag;
+	    const type = el.attrsMap.type;
+	    {
+	        // inputs with type="file" are read only and setting the input's
+	        // value will throw an error.
+	        if (tag === 'input' && type === 'file') {
+	            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+	                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+	        }
+	    }
+	    if (el.component) {
+	        genComponentModel(el, value, modifiers);
+	        // component v-model doesn't need extra runtime
+	        return false;
+	    }
+	    else if (tag === 'select') {
+	        genSelect(el, value, modifiers);
+	    }
+	    else if (tag === 'input' && type === 'checkbox') {
+	        genCheckboxModel(el, value, modifiers);
+	    }
+	    else if (tag === 'input' && type === 'radio') {
+	        genRadioModel(el, value, modifiers);
+	    }
+	    else if (tag === 'input' || tag === 'textarea') {
+	        genDefaultModel(el, value, modifiers);
+	    }
+	    else {
+	        genComponentModel(el, value, modifiers);
+	        // component v-model doesn't need extra runtime
+	        return false;
+	    }
+	    // ensure runtime directive metadata
+	    return true;
+	}
+	function genCheckboxModel(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    const valueBinding = getBindingAttr(el, 'value') || 'null';
+	    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+	    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+	    addProp(el, 'checked', `Array.isArray(${value})` +
+	        `?_i(${value},${valueBinding})>-1` +
+	        (trueValueBinding === 'true'
+	            ? `:(${value})`
+	            : `:_q(${value},${trueValueBinding})`));
+	    addHandler(el, 'change', `var $$a=${value},` +
+	        '$$el=$event.target,' +
+	        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+	        'if(Array.isArray($$a)){' +
+	        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+	        '$$i=_i($$a,$$v);' +
+	        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+	        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+	        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+	}
+	function genRadioModel(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    let valueBinding = getBindingAttr(el, 'value') || 'null';
+	    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+	    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+	    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+	}
+	function genSelect(el, value, modifiers) {
+	    const number = modifiers && modifiers.number;
+	    const selectedVal = `Array.prototype.filter` +
+	        `.call($event.target.options,function(o){return o.selected})` +
+	        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+	        `return ${number ? '_n(val)' : 'val'}})`;
+	    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+	    let code = `var $$selectedVal = ${selectedVal};`;
+	    code = `${code} ${genAssignmentCode(value, assignment)}`;
+	    addHandler(el, 'change', code, null, true);
+	}
+	function genDefaultModel(el, value, modifiers) {
+	    const type = el.attrsMap.type;
+	    // warn if v-bind:value conflicts with v-model
+	    // except for inputs with v-bind:type
+	    {
+	        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+	        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+	        if (value && !typeBinding) {
+	            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+	            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+	                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+	        }
+	    }
+	    const { lazy, number, trim } = modifiers || {};
+	    const needCompositionGuard = !lazy && type !== 'range';
+	    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+	    let valueExpression = '$event.target.value';
+	    if (trim) {
+	        valueExpression = `$event.target.value.trim()`;
+	    }
+	    if (number) {
+	        valueExpression = `_n(${valueExpression})`;
+	    }
+	    let code = genAssignmentCode(value, valueExpression);
+	    if (needCompositionGuard) {
+	        code = `if($event.target.composing)return;${code}`;
+	    }
+	    addProp(el, 'value', `(${value})`);
+	    addHandler(el, event, code, null, true);
+	    if (trim || number) {
+	        addHandler(el, 'blur', '$forceUpdate()');
+	    }
+	}
+
+	function text(el, dir) {
+	    if (dir.value) {
+	        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+	    }
+	}
+
+	function html(el, dir) {
+	    if (dir.value) {
+	        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+	    }
+	}
+
+	var directives = {
+	    model,
+	    text,
+	    html,
+	};
+
+	const baseOptions = {
+	    expectHTML: true,
+	    modules,
+	    directives,
+	    isPreTag,
+	    isUnaryTag,
+	    mustUseProp,
+	    canBeLeftOpenTag,
+	    isReservedTag,
+	    getTagNamespace,
+	    staticKeys: genStaticKeys$1(modules),
+	};
+
+	let isStaticKey;
+	let isPlatformReservedTag$1;
+	const genStaticKeysCached = cached(genStaticKeys);
+	/**
+	 * Goal of the optimizer: walk the generated template AST tree
+	 * and detect sub-trees that are purely static, i.e. parts of
+	 * the DOM that never needs to change.
+	 *
+	 * Once we detect these sub-trees, we can:
+	 *
+	 * 1. Hoist them into constants, so that we no longer need to
+	 *    create fresh nodes for them on each re-render;
+	 * 2. Completely skip them in the patching process.
+	 */
+	function optimize$1(root, options) {
+	    if (!root)
+	        return;
+	    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+	    isPlatformReservedTag$1 = options.isReservedTag || no;
+	    // first pass: mark all non-static nodes.
+	    markStatic(root);
+	    // second pass: mark static roots.
+	    markStaticRoots(root, false);
+	}
+	function genStaticKeys(keys) {
+	    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+	        (keys ? ',' + keys : ''));
+	}
+	function markStatic(node) {
+	    node.static = isStatic(node);
+	    if (node.type === 1) {
+	        // do not make component slot content static. this avoids
+	        // 1. components not able to mutate slot nodes
+	        // 2. static slot content fails for hot-reloading
+	        if (!isPlatformReservedTag$1(node.tag) &&
+	            node.tag !== 'slot' &&
+	            node.attrsMap['inline-template'] == null) {
+	            return;
+	        }
+	        for (let i = 0, l = node.children.length; i < l; i++) {
+	            const child = node.children[i];
+	            markStatic(child);
+	            if (!child.static) {
+	                node.static = false;
+	            }
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                const block = node.ifConditions[i].block;
+	                markStatic(block);
+	                if (!block.static) {
+	                    node.static = false;
+	                }
+	            }
+	        }
+	    }
+	}
+	function markStaticRoots(node, isInFor) {
+	    if (node.type === 1) {
+	        if (node.static || node.once) {
+	            node.staticInFor = isInFor;
+	        }
+	        // For a node to qualify as a static root, it should have children that
+	        // are not just static text. Otherwise the cost of hoisting out will
+	        // outweigh the benefits and it's better off to just always render it fresh.
+	        if (node.static &&
+	            node.children.length &&
+	            !(node.children.length === 1 && node.children[0].type === 3)) {
+	            node.staticRoot = true;
+	            return;
+	        }
+	        else {
+	            node.staticRoot = false;
+	        }
+	        if (node.children) {
+	            for (let i = 0, l = node.children.length; i < l; i++) {
+	                markStaticRoots(node.children[i], isInFor || !!node.for);
+	            }
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                markStaticRoots(node.ifConditions[i].block, isInFor);
+	            }
+	        }
+	    }
+	}
+	function isStatic(node) {
+	    if (node.type === 2) {
+	        // expression
+	        return false;
+	    }
+	    if (node.type === 3) {
+	        // text
+	        return true;
+	    }
+	    return !!(node.pre ||
+	        (!node.hasBindings && // no dynamic bindings
+	            !node.if &&
+	            !node.for && // not v-if or v-for or v-else
+	            !isBuiltInTag(node.tag) && // not a built-in
+	            isPlatformReservedTag$1(node.tag) && // not a component
+	            !isDirectChildOfTemplateFor(node) &&
+	            Object.keys(node).every(isStaticKey)));
+	}
+	function isDirectChildOfTemplateFor(node) {
+	    while (node.parent) {
+	        node = node.parent;
+	        if (node.tag !== 'template') {
+	            return false;
+	        }
+	        if (node.for) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+
+	const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+	const fnInvokeRE = /\([^)]*?\);*$/;
+	const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+	// KeyboardEvent.keyCode aliases
+	const keyCodes = {
+	    esc: 27,
+	    tab: 9,
+	    enter: 13,
+	    space: 32,
+	    up: 38,
+	    left: 37,
+	    right: 39,
+	    down: 40,
+	    delete: [8, 46],
+	};
+	// KeyboardEvent.key aliases
+	const keyNames = {
+	    // #7880: IE11 and Edge use `Esc` for Escape key name.
+	    esc: ['Esc', 'Escape'],
+	    tab: 'Tab',
+	    enter: 'Enter',
+	    // #9112: IE11 uses `Spacebar` for Space key name.
+	    space: [' ', 'Spacebar'],
+	    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+	    up: ['Up', 'ArrowUp'],
+	    left: ['Left', 'ArrowLeft'],
+	    right: ['Right', 'ArrowRight'],
+	    down: ['Down', 'ArrowDown'],
+	    // #9112: IE11 uses `Del` for Delete key name.
+	    delete: ['Backspace', 'Delete', 'Del'],
+	};
+	// #4868: modifiers that prevent the execution of the listener
+	// need to explicitly return null so that we can determine whether to remove
+	// the listener for .once
+	const genGuard = (condition) => `if(${condition})return null;`;
+	const modifierCode = {
+	    stop: '$event.stopPropagation();',
+	    prevent: '$event.preventDefault();',
+	    self: genGuard(`$event.target !== $event.currentTarget`),
+	    ctrl: genGuard(`!$event.ctrlKey`),
+	    shift: genGuard(`!$event.shiftKey`),
+	    alt: genGuard(`!$event.altKey`),
+	    meta: genGuard(`!$event.metaKey`),
+	    left: genGuard(`'button' in $event && $event.button !== 0`),
+	    middle: genGuard(`'button' in $event && $event.button !== 1`),
+	    right: genGuard(`'button' in $event && $event.button !== 2`),
+	};
+	function genHandlers(events, isNative) {
+	    const prefix = isNative ? 'nativeOn:' : 'on:';
+	    let staticHandlers = ``;
+	    let dynamicHandlers = ``;
+	    for (const name in events) {
+	        const handlerCode = genHandler(events[name]);
+	        //@ts-expect-error
+	        if (events[name] && events[name].dynamic) {
+	            dynamicHandlers += `${name},${handlerCode},`;
+	        }
+	        else {
+	            staticHandlers += `"${name}":${handlerCode},`;
+	        }
+	    }
+	    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+	    if (dynamicHandlers) {
+	        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+	    }
+	    else {
+	        return prefix + staticHandlers;
+	    }
+	}
+	function genHandler(handler) {
+	    if (!handler) {
+	        return 'function(){}';
+	    }
+	    if (Array.isArray(handler)) {
+	        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+	    }
+	    const isMethodPath = simplePathRE.test(handler.value);
+	    const isFunctionExpression = fnExpRE.test(handler.value);
+	    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+	    if (!handler.modifiers) {
+	        if (isMethodPath || isFunctionExpression) {
+	            return handler.value;
+	        }
+	        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+	    }
+	    else {
+	        let code = '';
+	        let genModifierCode = '';
+	        const keys = [];
+	        for (const key in handler.modifiers) {
+	            if (modifierCode[key]) {
+	                genModifierCode += modifierCode[key];
+	                // left/right
+	                if (keyCodes[key]) {
+	                    keys.push(key);
+	                }
+	            }
+	            else if (key === 'exact') {
+	                const modifiers = handler.modifiers;
+	                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+	                    .filter((keyModifier) => !modifiers[keyModifier])
+	                    .map((keyModifier) => `$event.${keyModifier}Key`)
+	                    .join('||'));
+	            }
+	            else {
+	                keys.push(key);
+	            }
+	        }
+	        if (keys.length) {
+	            code += genKeyFilter(keys);
+	        }
+	        // Make sure modifiers like prevent and stop get executed after key filtering
+	        if (genModifierCode) {
+	            code += genModifierCode;
+	        }
+	        const handlerCode = isMethodPath
+	            ? `return ${handler.value}.apply(null, arguments)`
+	            : isFunctionExpression
+	                ? `return (${handler.value}).apply(null, arguments)`
+	                : isFunctionInvocation
+	                    ? `return ${handler.value}`
+	                    : handler.value;
+	        return `function($event){${code}${handlerCode}}`;
+	    }
+	}
+	function genKeyFilter(keys) {
+	    return (
+	    // make sure the key filters only apply to KeyboardEvents
+	    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+	    // key events that do not have keyCode property...
+	    `if(!$event.type.indexOf('key')&&` +
+	        `${keys.map(genFilterCode).join('&&')})return null;`);
+	}
+	function genFilterCode(key) {
+	    const keyVal = parseInt(key, 10);
+	    if (keyVal) {
+	        return `$event.keyCode!==${keyVal}`;
+	    }
+	    const keyCode = keyCodes[key];
+	    const keyName = keyNames[key];
+	    return (`_k($event.keyCode,` +
+	        `${JSON.stringify(key)},` +
+	        `${JSON.stringify(keyCode)},` +
+	        `$event.key,` +
+	        `${JSON.stringify(keyName)}` +
+	        `)`);
+	}
+
+	function on(el, dir) {
+	    if (dir.modifiers) {
+	        warn$2(`v-on without argument does not support modifiers.`);
+	    }
+	    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+	}
+
+	function bind(el, dir) {
+	    el.wrapData = (code) => {
+	        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+	    };
+	}
+
+	var baseDirectives = {
+	    on,
+	    bind,
+	    cloak: noop,
+	};
+
+	class CodegenState {
+	    options;
+	    warn;
+	    transforms;
+	    dataGenFns;
+	    directives;
+	    maybeComponent;
+	    onceId;
+	    staticRenderFns;
+	    pre;
+	    constructor(options) {
+	        this.options = options;
+	        this.warn = options.warn || baseWarn;
+	        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+	        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+	        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+	        this.directives = extend(extend({}, baseDirectives), options.directives);
+	        const isReservedTag = options.isReservedTag || no;
+	        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+	        this.onceId = 0;
+	        this.staticRenderFns = [];
+	        this.pre = false;
+	    }
+	}
+	function generate$1(ast, options) {
+	    const state = new CodegenState(options);
+	    // fix #11483, Root level <script> tags should not be rendered.
+	    const code = ast
+	        ? ast.tag === 'script'
+	            ? 'null'
+	            : genElement(ast, state)
+	        : '_c("div")';
+	    return {
+	        render: `with(this){return ${code}}`,
+	        staticRenderFns: state.staticRenderFns,
+	    };
+	}
+	function genElement(el, state) {
+	    if (el.parent) {
+	        el.pre = el.pre || el.parent.pre;
+	    }
+	    if (el.staticRoot && !el.staticProcessed) {
+	        return genStatic(el, state);
+	    }
+	    else if (el.once && !el.onceProcessed) {
+	        return genOnce(el, state);
+	    }
+	    else if (el.for && !el.forProcessed) {
+	        return genFor(el, state);
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        return genIf(el, state);
+	    }
+	    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+	        return genChildren(el, state) || 'void 0';
+	    }
+	    else if (el.tag === 'slot') {
+	        return genSlot(el, state);
+	    }
+	    else {
+	        // component or element
+	        let code;
+	        if (el.component) {
+	            code = genComponent(el.component, el, state);
+	        }
+	        else {
+	            let data;
+	            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+	                data = genData(el, state);
+	            }
+	            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+	            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+	        }
+	        // module transforms
+	        for (let i = 0; i < state.transforms.length; i++) {
+	            code = state.transforms[i](el, code);
+	        }
+	        return code;
+	    }
+	}
+	// hoist static sub-trees out
+	function genStatic(el, state) {
+	    el.staticProcessed = true;
+	    // Some elements (templates) need to behave differently inside of a v-pre
+	    // node.  All pre nodes are static roots, so we can use this as a location to
+	    // wrap a state change and reset it upon exiting the pre node.
+	    const originalPreState = state.pre;
+	    if (el.pre) {
+	        state.pre = el.pre;
+	    }
+	    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+	    state.pre = originalPreState;
+	    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+	}
+	// v-once
+	function genOnce(el, state) {
+	    el.onceProcessed = true;
+	    if (el.if && !el.ifProcessed) {
+	        return genIf(el, state);
+	    }
+	    else if (el.staticInFor) {
+	        let key = '';
+	        let parent = el.parent;
+	        while (parent) {
+	            if (parent.for) {
+	                key = parent.key;
+	                break;
+	            }
+	            parent = parent.parent;
+	        }
+	        if (!key) {
+	            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+	            return genElement(el, state);
+	        }
+	        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+	    }
+	    else {
+	        return genStatic(el, state);
+	    }
+	}
+	function genIf(el, state, altGen, altEmpty) {
+	    el.ifProcessed = true; // avoid recursion
+	    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+	}
+	function genIfConditions(conditions, state, altGen, altEmpty) {
+	    if (!conditions.length) {
+	        return altEmpty || '_e()';
+	    }
+	    const condition = conditions.shift();
+	    if (condition.exp) {
+	        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+	    }
+	    else {
+	        return `${genTernaryExp(condition.block)}`;
+	    }
+	    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+	    function genTernaryExp(el) {
+	        return altGen
+	            ? altGen(el, state)
+	            : el.once
+	                ? genOnce(el, state)
+	                : genElement(el, state);
+	    }
+	}
+	function genFor(el, state, altGen, altHelper) {
+	    const exp = el.for;
+	    const alias = el.alias;
+	    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+	    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+	    if (state.maybeComponent(el) &&
+	        el.tag !== 'slot' &&
+	        el.tag !== 'template' &&
+	        !el.key) {
+	        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+	            `v-for should have explicit keys. ` +
+	            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+	    }
+	    el.forProcessed = true; // avoid recursion
+	    return (`${altHelper || '_l'}((${exp}),` +
+	        `function(${alias}${iterator1}${iterator2}){` +
+	        `return ${(altGen || genElement)(el, state)}` +
+	        '})');
+	}
+	function genData(el, state) {
+	    let data = '{';
+	    // directives first.
+	    // directives may mutate the el's other properties before they are generated.
+	    const dirs = genDirectives(el, state);
+	    if (dirs)
+	        data += dirs + ',';
+	    // key
+	    if (el.key) {
+	        data += `key:${el.key},`;
+	    }
+	    // ref
+	    if (el.ref) {
+	        data += `ref:${el.ref},`;
+	    }
+	    if (el.refInFor) {
+	        data += `refInFor:true,`;
+	    }
+	    // pre
+	    if (el.pre) {
+	        data += `pre:true,`;
+	    }
+	    // record original tag name for components using "is" attribute
+	    if (el.component) {
+	        data += `tag:"${el.tag}",`;
+	    }
+	    // module data generation functions
+	    for (let i = 0; i < state.dataGenFns.length; i++) {
+	        data += state.dataGenFns[i](el);
+	    }
+	    // attributes
+	    if (el.attrs) {
+	        data += `attrs:${genProps(el.attrs)},`;
+	    }
+	    // DOM props
+	    if (el.props) {
+	        data += `domProps:${genProps(el.props)},`;
+	    }
+	    // event handlers
+	    if (el.events) {
+	        data += `${genHandlers(el.events, false)},`;
+	    }
+	    if (el.nativeEvents) {
+	        data += `${genHandlers(el.nativeEvents, true)},`;
+	    }
+	    // slot target
+	    // only for non-scoped slots
+	    if (el.slotTarget && !el.slotScope) {
+	        data += `slot:${el.slotTarget},`;
+	    }
+	    // scoped slots
+	    if (el.scopedSlots) {
+	        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+	    }
+	    // component v-model
+	    if (el.model) {
+	        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+	    }
+	    // inline-template
+	    if (el.inlineTemplate) {
+	        const inlineTemplate = genInlineTemplate(el, state);
+	        if (inlineTemplate) {
+	            data += `${inlineTemplate},`;
+	        }
+	    }
+	    data = data.replace(/,$/, '') + '}';
+	    // v-bind dynamic argument wrap
+	    // v-bind with dynamic arguments must be applied using the same v-bind object
+	    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+	    if (el.dynamicAttrs) {
+	        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+	    }
+	    // v-bind data wrap
+	    if (el.wrapData) {
+	        data = el.wrapData(data);
+	    }
+	    // v-on data wrap
+	    if (el.wrapListeners) {
+	        data = el.wrapListeners(data);
+	    }
+	    return data;
+	}
+	function genDirectives(el, state) {
+	    const dirs = el.directives;
+	    if (!dirs)
+	        return;
+	    let res = 'directives:[';
+	    let hasRuntime = false;
+	    let i, l, dir, needRuntime;
+	    for (i = 0, l = dirs.length; i < l; i++) {
+	        dir = dirs[i];
+	        needRuntime = true;
+	        const gen = state.directives[dir.name];
+	        if (gen) {
+	            // compile-time directive that manipulates AST.
+	            // returns true if it also needs a runtime counterpart.
+	            needRuntime = !!gen(el, dir, state.warn);
+	        }
+	        if (needRuntime) {
+	            hasRuntime = true;
+	            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+	        }
+	    }
+	    if (hasRuntime) {
+	        return res.slice(0, -1) + ']';
+	    }
+	}
+	function genInlineTemplate(el, state) {
+	    const ast = el.children[0];
+	    if ((el.children.length !== 1 || ast.type !== 1)) {
+	        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+	    }
+	    if (ast && ast.type === 1) {
+	        const inlineRenderFns = generate$1(ast, state.options);
+	        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+	    }
+	}
+	function genScopedSlots(el, slots, state) {
+	    // by default scoped slots are considered "stable", this allows child
+	    // components with only scoped slots to skip forced updates from parent.
+	    // but in some cases we have to bail-out of this optimization
+	    // for example if the slot contains dynamic names, has v-if or v-for on them...
+	    let needsForceUpdate = el.for ||
+	        Object.keys(slots).some((key) => {
+	            const slot = slots[key];
+	            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+	            );
+	        });
+	    // #9534: if a component with scoped slots is inside a conditional branch,
+	    // it's possible for the same component to be reused but with different
+	    // compiled slot content. To avoid that, we generate a unique key based on
+	    // the generated code of all the slot contents.
+	    let needsKey = !!el.if;
+	    // OR when it is inside another scoped slot or v-for (the reactivity may be
+	    // disconnected due to the intermediate scope variable)
+	    // #9438, #9506
+	    // TODO: this can be further optimized by properly analyzing in-scope bindings
+	    // and skip force updating ones that do not actually use scope variables.
+	    if (!needsForceUpdate) {
+	        let parent = el.parent;
+	        while (parent) {
+	            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+	                parent.for) {
+	                needsForceUpdate = true;
+	                break;
+	            }
+	            if (parent.if) {
+	                needsKey = true;
+	            }
+	            parent = parent.parent;
+	        }
+	    }
+	    const generatedSlots = Object.keys(slots)
+	        .map((key) => genScopedSlot(slots[key], state))
+	        .join(',');
+	    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+	}
+	function hash(str) {
+	    let hash = 5381;
+	    let i = str.length;
+	    while (i) {
+	        hash = (hash * 33) ^ str.charCodeAt(--i);
+	    }
+	    return hash >>> 0;
+	}
+	function containsSlotChild(el) {
+	    if (el.type === 1) {
+	        if (el.tag === 'slot') {
+	            return true;
+	        }
+	        return el.children.some(containsSlotChild);
+	    }
+	    return false;
+	}
+	function genScopedSlot(el, state) {
+	    const isLegacySyntax = el.attrsMap['slot-scope'];
+	    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+	        return genIf(el, state, genScopedSlot, `null`);
+	    }
+	    if (el.for && !el.forProcessed) {
+	        return genFor(el, state, genScopedSlot);
+	    }
+	    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+	    const fn = `function(${slotScope}){` +
+	        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+	    // reverse proxy v-slot without scope on this.$slots
+	    const reverseProxy = slotScope ? `` : `,proxy:true`;
+	    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+	}
+	function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+	    const children = el.children;
+	    if (children.length) {
+	        const el = children[0];
+	        // optimize single v-for
+	        if (children.length === 1 &&
+	            el.for &&
+	            el.tag !== 'template' &&
+	            el.tag !== 'slot') {
+	            const normalizationType = checkSkip
+	                ? state.maybeComponent(el)
+	                    ? `,1`
+	                    : `,0`
+	                : ``;
+	            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+	        }
+	        const normalizationType = checkSkip
+	            ? getNormalizationType(children, state.maybeComponent)
+	            : 0;
+	        const gen = altGenNode || genNode;
+	        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+	    }
+	}
+	// determine the normalization needed for the children array.
+	// 0: no normalization needed
+	// 1: simple normalization needed (possible 1-level deep nested array)
+	// 2: full normalization needed
+	function getNormalizationType(children, maybeComponent) {
+	    let res = 0;
+	    for (let i = 0; i < children.length; i++) {
+	        const el = children[i];
+	        if (el.type !== 1) {
+	            continue;
+	        }
+	        if (needsNormalization(el) ||
+	            (el.ifConditions &&
+	                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+	            res = 2;
+	            break;
+	        }
+	        if (maybeComponent(el) ||
+	            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+	            res = 1;
+	        }
+	    }
+	    return res;
+	}
+	function needsNormalization(el) {
+	    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+	}
+	function genNode(node, state) {
+	    if (node.type === 1) {
+	        return genElement(node, state);
+	    }
+	    else if (node.type === 3 && node.isComment) {
+	        return genComment(node);
+	    }
+	    else {
+	        return genText(node);
+	    }
+	}
+	function genText(text) {
+	    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+	}
+	function genComment(comment) {
+	    return `_e(${JSON.stringify(comment.text)})`;
+	}
+	function genSlot(el, state) {
+	    const slotName = el.slotName || '"default"';
+	    const children = genChildren(el, state);
+	    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+	    const attrs = el.attrs || el.dynamicAttrs
+	        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+	            // slot props are camelized
+	            name: camelize(attr.name),
+	            value: attr.value,
+	            dynamic: attr.dynamic
+	        })))
+	        : null;
+	    const bind = el.attrsMap['v-bind'];
+	    if ((attrs || bind) && !children) {
+	        res += `,null`;
+	    }
+	    if (attrs) {
+	        res += `,${attrs}`;
+	    }
+	    if (bind) {
+	        res += `${attrs ? '' : ',null'},${bind}`;
+	    }
+	    return res + ')';
+	}
+	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+	function genComponent(componentName, el, state) {
+	    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+	    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+	}
+	function genProps(props) {
+	    let staticProps = ``;
+	    let dynamicProps = ``;
+	    for (let i = 0; i < props.length; i++) {
+	        const prop = props[i];
+	        const value = transformSpecialNewlines(prop.value);
+	        if (prop.dynamic) {
+	            dynamicProps += `${prop.name},${value},`;
+	        }
+	        else {
+	            staticProps += `"${prop.name}":${value},`;
+	        }
+	    }
+	    staticProps = `{${staticProps.slice(0, -1)}}`;
+	    if (dynamicProps) {
+	        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+	    }
+	    else {
+	        return staticProps;
+	    }
+	}
+	// #3895, #4268
+	function transformSpecialNewlines(text) {
+	    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+	}
+
+	// these keywords should not appear inside expressions, but operators like
+	// typeof, instanceof and in are allowed
+	const prohibitedKeywordRE = new RegExp('\\b' +
+	    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+	        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+	        'extends,finally,continue,debugger,function,arguments')
+	        .split(',')
+	        .join('\\b|\\b') +
+	    '\\b');
+	// these unary operators should not be used as property/method names
+	const unaryOperatorsRE = new RegExp('\\b' +
+	    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+	    '\\s*\\([^\\)]*\\)');
+	// strip strings in expressions
+	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+	// detect problematic expressions in a template
+	function detectErrors(ast, warn) {
+	    if (ast) {
+	        checkNode(ast, warn);
+	    }
+	}
+	function checkNode(node, warn) {
+	    if (node.type === 1) {
+	        for (const name in node.attrsMap) {
+	            if (dirRE.test(name)) {
+	                const value = node.attrsMap[name];
+	                if (value) {
+	                    const range = node.rawAttrsMap[name];
+	                    if (name === 'v-for') {
+	                        checkFor(node, `v-for="${value}"`, warn, range);
+	                    }
+	                    else if (name === 'v-slot' || name[0] === '#') {
+	                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+	                    }
+	                    else if (onRE.test(name)) {
+	                        checkEvent(value, `${name}="${value}"`, warn, range);
+	                    }
+	                    else {
+	                        checkExpression(value, `${name}="${value}"`, warn, range);
+	                    }
+	                }
+	            }
+	        }
+	        if (node.children) {
+	            for (let i = 0; i < node.children.length; i++) {
+	                checkNode(node.children[i], warn);
+	            }
+	        }
+	    }
+	    else if (node.type === 2) {
+	        checkExpression(node.expression, node.text, warn, node);
+	    }
+	}
+	function checkEvent(exp, text, warn, range) {
+	    const stripped = exp.replace(stripStringRE, '');
+	    const keywordMatch = stripped.match(unaryOperatorsRE);
+	    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+	        warn(`avoid using JavaScript unary operator as property name: ` +
+	            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+	    }
+	    checkExpression(exp, text, warn, range);
+	}
+	function checkFor(node, text, warn, range) {
+	    checkExpression(node.for || '', text, warn, range);
+	    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+	    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+	    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+	}
+	function checkIdentifier(ident, type, text, warn, range) {
+	    if (typeof ident === 'string') {
+	        try {
+	            new Function(`var ${ident}=_`);
+	        }
+	        catch (e) {
+	            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+	        }
+	    }
+	}
+	function checkExpression(exp, text, warn, range) {
+	    try {
+	        new Function(`return ${exp}`);
+	    }
+	    catch (e) {
+	        const keywordMatch = exp
+	            .replace(stripStringRE, '')
+	            .match(prohibitedKeywordRE);
+	        if (keywordMatch) {
+	            warn(`avoid using JavaScript keyword as property name: ` +
+	                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+	        }
+	        else {
+	            warn(`invalid expression: ${e.message} in\n\n` +
+	                `    ${exp}\n\n` +
+	                `  Raw expression: ${text.trim()}\n`, range);
+	        }
+	    }
+	}
+	function checkFunctionParameterExpression(exp, text, warn, range) {
+	    try {
+	        new Function(exp, '');
+	    }
+	    catch (e) {
+	        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+	            `    ${exp}\n\n` +
+	            `  Raw expression: ${text.trim()}\n`, range);
+	    }
 	}
 
-	function createCompilerCreator(baseCompile) {
-	    return function createCompiler(baseOptions) {
-	        function compile(template, options) {
-	            const finalOptions = Object.create(baseOptions);
-	            const errors = [];
-	            const tips = [];
-	            let warn = (msg, range, tip) => {
-	                (tip ? tips : errors).push(msg);
-	            };
-	            if (options) {
-	                if (options.outputSourceRange) {
-	                    // $flow-disable-line
-	                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-	                    warn = (msg, range, tip) => {
-	                        const data = typeof (msg) === 'string' ? { msg } : msg;
-	                        if (range) {
-	                            if (range.start != null) {
-	                                data.start = range.start + leadingSpaceLength;
-	                            }
-	                            if (range.end != null) {
-	                                data.end = range.end + leadingSpaceLength;
-	                            }
-	                        }
-	                        (tip ? tips : errors).push(data);
-	                    };
-	                }
-	                // merge custom modules
-	                if (options.modules) {
-	                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-	                }
-	                // merge custom directives
-	                if (options.directives) {
-	                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-	                }
-	                // copy other options
-	                for (const key in options) {
-	                    if (key !== 'modules' && key !== 'directives') {
-	                        finalOptions[key] = options[key];
-	                    }
-	                }
-	            }
-	            finalOptions.warn = warn;
-	            const compiled = baseCompile(template.trim(), finalOptions);
-	            {
-	                detectErrors(compiled.ast, warn);
-	            }
-	            compiled.errors = errors;
-	            compiled.tips = tips;
-	            return compiled;
-	        }
-	        return {
-	            compile,
-	            compileToFunctions: createCompileToFunctionFn(compile),
-	        };
-	    };
+	const range = 2;
+	function generateCodeFrame(source, start = 0, end = source.length) {
+	    const lines = source.split(/\r?\n/);
+	    let count = 0;
+	    const res = [];
+	    for (let i = 0; i < lines.length; i++) {
+	        count += lines[i].length + 1;
+	        if (count >= start) {
+	            for (let j = i - range; j <= i + range || end > count; j++) {
+	                if (j < 0 || j >= lines.length)
+	                    continue;
+	                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+	                const lineLength = lines[j].length;
+	                if (j === i) {
+	                    // push underline
+	                    const pad = start - (count - lineLength) + 1;
+	                    const length = end > count ? lineLength - pad : end - start;
+	                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+	                }
+	                else if (j > i) {
+	                    if (end > count) {
+	                        const length = Math.min(end - count, lineLength);
+	                        res.push(`   |  ` + repeat(`^`, length));
+	                    }
+	                    count += lineLength + 1;
+	                }
+	            }
+	            break;
+	        }
+	    }
+	    return res.join('\n');
+	}
+	function repeat(str, n) {
+	    let result = '';
+	    if (n > 0) {
+	        // eslint-disable-next-line no-constant-condition
+	        while (true) {
+	            // eslint-disable-line
+	            if (n & 1)
+	                result += str;
+	            n >>>= 1;
+	            if (n <= 0)
+	                break;
+	            str += str;
+	        }
+	    }
+	    return result;
 	}
 
-	// `createCompilerCreator` allows creating compilers that use alternative
-	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-	// Here we just export a default compiler using the default parts.
-	const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
-	    const ast = parse(template.trim(), options);
-	    if (options.optimize !== false) {
-	        optimize$1(ast, options);
-	    }
-	    const code = generate$1(ast, options);
-	    return {
-	        ast,
-	        render: code.render,
-	        staticRenderFns: code.staticRenderFns,
-	    };
+	function createFunction(code, errors) {
+	    try {
+	        return new Function(code);
+	    }
+	    catch (err) {
+	        errors.push({ err, code });
+	        return noop;
+	    }
+	}
+	function createCompileToFunctionFn(compile) {
+	    const cache = Object.create(null);
+	    return function compileToFunctions(template, options, vm) {
+	        options = extend({}, options);
+	        const warn = options.warn || warn$2;
+	        delete options.warn;
+	        /* istanbul ignore if */
+	        {
+	            // detect possible CSP restriction
+	            try {
+	                new Function('return 1');
+	            }
+	            catch (e) {
+	                if (e.toString().match(/unsafe-eval|CSP/)) {
+	                    warn('It seems you are using the standalone build of Vue.js in an ' +
+	                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+	                        'The template compiler cannot work in this environment. Consider ' +
+	                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+	                        'templates into render functions.');
+	                }
+	            }
+	        }
+	        // check cache
+	        const key = options.delimiters
+	            ? String(options.delimiters) + template
+	            : template;
+	        if (cache[key]) {
+	            return cache[key];
+	        }
+	        // compile
+	        const compiled = compile(template, options);
+	        // check compilation errors/tips
+	        {
+	            if (compiled.errors && compiled.errors.length) {
+	                if (options.outputSourceRange) {
+	                    compiled.errors.forEach((e) => {
+	                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+	                            generateCodeFrame(template, e.start, e.end), vm);
+	                    });
+	                }
+	                else {
+	                    warn(`Error compiling template:\n\n${template}\n\n` +
+	                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+	                        '\n', vm);
+	                }
+	            }
+	            if (compiled.tips && compiled.tips.length) {
+	                if (options.outputSourceRange) {
+	                    compiled.tips.forEach((e) => tip(e.msg, vm));
+	                }
+	                else {
+	                    compiled.tips.forEach((msg) => tip(msg, vm));
+	                }
+	            }
+	        }
+	        // turn code into functions
+	        const res = {};
+	        const fnGenErrors = [];
+	        res.render = createFunction(compiled.render, fnGenErrors);
+	        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+	            return createFunction(code, fnGenErrors);
+	        });
+	        // check function generation errors.
+	        // this should only happen if there is a bug in the compiler itself.
+	        // mostly for codegen development use
+	        /* istanbul ignore if */
+	        {
+	            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+	                warn(`Failed to generate render function:\n\n` +
+	                    fnGenErrors
+	                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+	                        .join('\n'), vm);
+	            }
+	        }
+	        return (cache[key] = res);
+	    };
+	}
+
+	function createCompilerCreator(baseCompile) {
+	    return function createCompiler(baseOptions) {
+	        function compile(template, options) {
+	            const finalOptions = Object.create(baseOptions);
+	            const errors = [];
+	            const tips = [];
+	            let warn = (msg, range, tip) => {
+	                (tip ? tips : errors).push(msg);
+	            };
+	            if (options) {
+	                if (options.outputSourceRange) {
+	                    // $flow-disable-line
+	                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+	                    warn = (msg, range, tip) => {
+	                        const data = { msg };
+	                        if (range) {
+	                            if (range.start != null) {
+	                                data.start = range.start + leadingSpaceLength;
+	                            }
+	                            if (range.end != null) {
+	                                data.end = range.end + leadingSpaceLength;
+	                            }
+	                        }
+	                        (tip ? tips : errors).push(data);
+	                    };
+	                }
+	                // merge custom modules
+	                if (options.modules) {
+	                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+	                }
+	                // merge custom directives
+	                if (options.directives) {
+	                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+	                }
+	                // copy other options
+	                for (const key in options) {
+	                    if (key !== 'modules' && key !== 'directives') {
+	                        finalOptions[key] = options[key];
+	                    }
+	                }
+	            }
+	            finalOptions.warn = warn;
+	            const compiled = baseCompile(template.trim(), finalOptions);
+	            {
+	                detectErrors(compiled.ast, warn);
+	            }
+	            compiled.errors = errors;
+	            compiled.tips = tips;
+	            return compiled;
+	        }
+	        return {
+	            compile,
+	            compileToFunctions: createCompileToFunctionFn(compile),
+	        };
+	    };
+	}
+
+	// `createCompilerCreator` allows creating compilers that use alternative
+	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+	// Here we just export a default compiler using the default parts.
+	const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+	    const ast = parse(template.trim(), options);
+	    if (options.optimize !== false) {
+	        optimize$1(ast, options);
+	    }
+	    const code = generate$1(ast, options);
+	    return {
+	        ast,
+	        render: code.render,
+	        staticRenderFns: code.staticRenderFns,
+	    };
 	});
 
 	const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
 
-	const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-	    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-	    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-	    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-	    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-	    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-	    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-	    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-	    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-	    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-	    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-	    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-	    'target,title,usemap,value,width,wrap');
-	/* istanbul ignore next */
-	const isRenderableAttr = (name) => {
-	    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-	};
-	const propsToAttrMap = {
-	    acceptCharset: 'accept-charset',
-	    className: 'class',
-	    htmlFor: 'for',
-	    httpEquiv: 'http-equiv',
-	};
-	const ESC = {
-	    '<': '&lt;',
-	    '>': '&gt;',
-	    '"': '&quot;',
-	    '&': '&amp;',
-	};
-	function escape(s) {
-	    return s.replace(/[<>"&]/g, escapeChar);
-	}
-	function escapeChar(a) {
-	    return ESC[a] || a;
+	const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+	    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+	    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+	    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+	    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+	    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+	    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+	    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+	    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+	    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+	    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+	    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+	    'target,title,usemap,value,width,wrap');
+	/* istanbul ignore next */
+	const isRenderableAttr = (name) => {
+	    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+	};
+	const propsToAttrMap = {
+	    acceptCharset: 'accept-charset',
+	    className: 'class',
+	    htmlFor: 'for',
+	    httpEquiv: 'http-equiv',
+	};
+	const ESC = {
+	    '<': '&lt;',
+	    '>': '&gt;',
+	    '"': '&quot;',
+	    '&': '&amp;',
+	};
+	function escape(s) {
+	    return s.replace(/[<>"&]/g, escapeChar);
+	}
+	function escapeChar(a) {
+	    return ESC[a] || a;
 	}
 
-	const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-	// let the model AST transform translate v-model into appropriate
-	// props bindings
-	function applyModelTransform(el, state) {
-	    if (el.directives) {
-	        for (let i = 0; i < el.directives.length; i++) {
-	            const dir = el.directives[i];
-	            if (dir.name === 'model') {
-	                state.directives.model(el, dir, state.warn);
-	                // remove value for textarea as its converted to text
-	                if (el.tag === 'textarea' && el.props) {
-	                    el.props = el.props.filter((p) => p.name !== 'value');
-	                }
-	                break;
-	            }
-	        }
-	    }
-	}
-	function genAttrSegments(attrs) {
-	    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-	}
-	function genDOMPropSegments(props, attrs) {
-	    const segments = [];
-	    props.forEach(({ name, value }) => {
-	        name = propsToAttrMap[name] || name.toLowerCase();
-	        if (isRenderableAttr(name) &&
-	            !(attrs && attrs.some((a) => a.name === name))) {
-	            segments.push(genAttrSegment(name, value));
-	        }
-	    });
-	    return segments;
-	}
-	function genAttrSegment(name, value) {
-	    if (plainStringRE.test(value)) {
-	        // force double quote
-	        value = value.replace(/^'|'$/g, '"');
-	        // force enumerated attr to "true"
-	        if (isEnumeratedAttr(name) && value !== `"false"`) {
-	            value = `"true"`;
-	        }
-	        return {
-	            type: RAW,
-	            value: isBooleanAttr(name)
-	                ? ` ${name}="${name}"`
-	                : value === '""'
-	                    ? ` ${name}`
-	                    : ` ${name}="${JSON.parse(value)}"`,
-	        };
-	    }
-	    else {
-	        return {
-	            type: EXPRESSION,
-	            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-	        };
-	    }
-	}
-	function genClassSegments(staticClass, classBinding) {
-	    if (staticClass && !classBinding) {
-	        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-	    }
-	    else {
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-	            },
-	        ];
-	    }
-	}
-	function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-	    if (staticStyle && !styleBinding && !vShowExpression) {
-	        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-	    }
-	    else {
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-	            },
-	        ];
-	    }
+	const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+	// let the model AST transform translate v-model into appropriate
+	// props bindings
+	function applyModelTransform(el, state) {
+	    if (el.directives) {
+	        for (let i = 0; i < el.directives.length; i++) {
+	            const dir = el.directives[i];
+	            if (dir.name === 'model') {
+	                state.directives.model(el, dir, state.warn);
+	                // remove value for textarea as its converted to text
+	                if (el.tag === 'textarea' && el.props) {
+	                    el.props = el.props.filter((p) => p.name !== 'value');
+	                }
+	                break;
+	            }
+	        }
+	    }
+	}
+	function genAttrSegments(attrs) {
+	    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+	}
+	function genDOMPropSegments(props, attrs) {
+	    const segments = [];
+	    props.forEach(({ name, value }) => {
+	        name = propsToAttrMap[name] || name.toLowerCase();
+	        if (isRenderableAttr(name) &&
+	            !(attrs && attrs.some((a) => a.name === name))) {
+	            segments.push(genAttrSegment(name, value));
+	        }
+	    });
+	    return segments;
+	}
+	function genAttrSegment(name, value) {
+	    if (plainStringRE.test(value)) {
+	        // force double quote
+	        value = value.replace(/^'|'$/g, '"');
+	        // force enumerated attr to "true"
+	        if (isEnumeratedAttr(name) && value !== `"false"`) {
+	            value = `"true"`;
+	        }
+	        return {
+	            type: RAW,
+	            value: isBooleanAttr(name)
+	                ? ` ${name}="${name}"`
+	                : value === '""'
+	                    ? ` ${name}`
+	                    : ` ${name}="${JSON.parse(value)}"`,
+	        };
+	    }
+	    else {
+	        return {
+	            type: EXPRESSION,
+	            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+	        };
+	    }
+	}
+	function genClassSegments(staticClass, classBinding) {
+	    if (staticClass && !classBinding) {
+	        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+	    }
+	    else {
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+	            },
+	        ];
+	    }
+	}
+	function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+	    if (staticStyle && !styleBinding && !vShowExpression) {
+	        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+	    }
+	    else {
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+	            },
+	        ];
+	    }
 	}
 
-	/**
-	 * In SSR, the vdom tree is generated only once and never patched, so
-	 * we can optimize most element / trees into plain string render functions.
-	 * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-	 *
-	 * The criteria for SSR optimizability is quite a bit looser than static tree
-	 * detection (which is designed for client re-render). In SSR we bail only for
-	 * components/slots/custom directives.
-	 */
-	// optimizability constants
-	const optimizability = {
-	    FALSE: 0,
-	    FULL: 1,
-	    SELF: 2,
-	    CHILDREN: 3,
-	    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-	};
-	let isPlatformReservedTag;
-	function optimize(root, options) {
-	    if (!root)
-	        return;
-	    isPlatformReservedTag = options.isReservedTag || no;
-	    walk(root, true);
-	}
-	function walk(node, isRoot) {
-	    if (isUnOptimizableTree(node)) {
-	        node.ssrOptimizability = optimizability.FALSE;
-	        return;
-	    }
-	    // root node or nodes with custom directives should always be a VNode
-	    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-	    const check = (child) => {
-	        if (child.ssrOptimizability !== optimizability.FULL) {
-	            node.ssrOptimizability = selfUnoptimizable
-	                ? optimizability.PARTIAL
-	                : optimizability.SELF;
-	        }
-	    };
-	    if (selfUnoptimizable) {
-	        node.ssrOptimizability = optimizability.CHILDREN;
-	    }
-	    if (node.type === 1) {
-	        for (let i = 0, l = node.children.length; i < l; i++) {
-	            const child = node.children[i];
-	            walk(child);
-	            check(child);
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                const block = node.ifConditions[i].block;
-	                walk(block, isRoot);
-	                check(block);
-	            }
-	        }
-	        if (node.ssrOptimizability == null ||
-	            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-	            node.ssrOptimizability = optimizability.FULL;
-	        }
-	        else {
-	            node.children = optimizeSiblings(node);
-	        }
-	    }
-	    else {
-	        node.ssrOptimizability = optimizability.FULL;
-	    }
-	}
-	function optimizeSiblings(el) {
-	    const children = el.children;
-	    const optimizedChildren = [];
-	    let currentOptimizableGroup = [];
-	    const pushGroup = () => {
-	        if (currentOptimizableGroup.length) {
-	            optimizedChildren.push({
-	                type: 1,
-	                parent: el,
-	                tag: 'template',
-	                attrsList: [],
-	                attrsMap: {},
-	                rawAttrsMap: {},
-	                children: currentOptimizableGroup,
-	                ssrOptimizability: optimizability.FULL,
-	            });
-	        }
-	        currentOptimizableGroup = [];
-	    };
-	    for (let i = 0; i < children.length; i++) {
-	        const c = children[i];
-	        if (c.ssrOptimizability === optimizability.FULL) {
-	            currentOptimizableGroup.push(c);
-	        }
-	        else {
-	            // wrap fully-optimizable adjacent siblings inside a template tag
-	            // so that they can be optimized into a single ssrNode by codegen
-	            pushGroup();
-	            optimizedChildren.push(c);
-	        }
-	    }
-	    pushGroup();
-	    return optimizedChildren;
-	}
-	function isUnOptimizableTree(node) {
-	    if (node.type === 2 || node.type === 3) {
-	        // text or expression
-	        return false;
-	    }
-	    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-	        !isPlatformReservedTag(node.tag) || // custom component
-	        !!node.component || // "is" component
-	        isSelectWithModel(node) // <select v-model> requires runtime inspection
-	    );
-	}
-	const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-	function hasCustomDirective(node) {
-	    return (node.type === 1 &&
-	        node.directives &&
-	        node.directives.some((d) => !isBuiltInDir(d.name)));
-	}
-	// <select v-model> cannot be optimized because it requires a runtime check
-	// to determine proper selected option
-	function isSelectWithModel(node) {
-	    return (node.type === 1 &&
-	        node.tag === 'select' &&
-	        node.directives != null &&
-	        node.directives.some((d) => d.name === 'model'));
+	/**
+	 * In SSR, the vdom tree is generated only once and never patched, so
+	 * we can optimize most element / trees into plain string render functions.
+	 * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+	 *
+	 * The criteria for SSR optimizability is quite a bit looser than static tree
+	 * detection (which is designed for client re-render). In SSR we bail only for
+	 * components/slots/custom directives.
+	 */
+	// optimizability constants
+	const optimizability = {
+	    FALSE: 0,
+	    FULL: 1,
+	    SELF: 2,
+	    CHILDREN: 3,
+	    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+	};
+	let isPlatformReservedTag;
+	function optimize(root, options) {
+	    if (!root)
+	        return;
+	    isPlatformReservedTag = options.isReservedTag || no;
+	    walk(root, true);
+	}
+	function walk(node, isRoot) {
+	    if (isUnOptimizableTree(node)) {
+	        node.ssrOptimizability = optimizability.FALSE;
+	        return;
+	    }
+	    // root node or nodes with custom directives should always be a VNode
+	    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+	    const check = (child) => {
+	        if (child.ssrOptimizability !== optimizability.FULL) {
+	            node.ssrOptimizability = selfUnoptimizable
+	                ? optimizability.PARTIAL
+	                : optimizability.SELF;
+	        }
+	    };
+	    if (selfUnoptimizable) {
+	        node.ssrOptimizability = optimizability.CHILDREN;
+	    }
+	    if (node.type === 1) {
+	        for (let i = 0, l = node.children.length; i < l; i++) {
+	            const child = node.children[i];
+	            walk(child);
+	            check(child);
+	        }
+	        if (node.ifConditions) {
+	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+	                const block = node.ifConditions[i].block;
+	                walk(block, isRoot);
+	                check(block);
+	            }
+	        }
+	        if (node.ssrOptimizability == null ||
+	            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+	            node.ssrOptimizability = optimizability.FULL;
+	        }
+	        else {
+	            node.children = optimizeSiblings(node);
+	        }
+	    }
+	    else {
+	        node.ssrOptimizability = optimizability.FULL;
+	    }
+	}
+	function optimizeSiblings(el) {
+	    const children = el.children;
+	    const optimizedChildren = [];
+	    let currentOptimizableGroup = [];
+	    const pushGroup = () => {
+	        if (currentOptimizableGroup.length) {
+	            optimizedChildren.push({
+	                type: 1,
+	                parent: el,
+	                tag: 'template',
+	                attrsList: [],
+	                attrsMap: {},
+	                rawAttrsMap: {},
+	                children: currentOptimizableGroup,
+	                ssrOptimizability: optimizability.FULL,
+	            });
+	        }
+	        currentOptimizableGroup = [];
+	    };
+	    for (let i = 0; i < children.length; i++) {
+	        const c = children[i];
+	        if (c.ssrOptimizability === optimizability.FULL) {
+	            currentOptimizableGroup.push(c);
+	        }
+	        else {
+	            // wrap fully-optimizable adjacent siblings inside a template tag
+	            // so that they can be optimized into a single ssrNode by codegen
+	            pushGroup();
+	            optimizedChildren.push(c);
+	        }
+	    }
+	    pushGroup();
+	    return optimizedChildren;
+	}
+	function isUnOptimizableTree(node) {
+	    if (node.type === 2 || node.type === 3) {
+	        // text or expression
+	        return false;
+	    }
+	    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+	        !isPlatformReservedTag(node.tag) || // custom component
+	        !!node.component || // "is" component
+	        isSelectWithModel(node) // <select v-model> requires runtime inspection
+	    );
+	}
+	const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+	function hasCustomDirective(node) {
+	    return (node.type === 1 &&
+	        node.directives &&
+	        node.directives.some((d) => !isBuiltInDir(d.name)));
+	}
+	// <select v-model> cannot be optimized because it requires a runtime check
+	// to determine proper selected option
+	function isSelectWithModel(node) {
+	    return (node.type === 1 &&
+	        node.tag === 'select' &&
+	        node.directives != null &&
+	        node.directives.some((d) => d.name === 'model'));
 	}
 
-	// The SSR codegen is essentially extending the default codegen to handle
-	// segment types
-	const RAW = 0;
-	const INTERPOLATION = 1;
-	const EXPRESSION = 2;
-	function generate(ast, options) {
-	    const state = new CodegenState(options);
-	    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-	    return {
-	        render: `with(this){return ${code}}`,
-	        staticRenderFns: state.staticRenderFns,
-	    };
-	}
-	function genSSRElement(el, state) {
-	    if (el.for && !el.forProcessed) {
-	        return genFor(el, state, genSSRElement);
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        return genIf(el, state, genSSRElement);
-	    }
-	    else if (el.tag === 'template' && !el.slotTarget) {
-	        return el.ssrOptimizability === optimizability.FULL
-	            ? genChildrenAsStringNode(el, state)
-	            : genSSRChildren(el, state) || 'void 0';
-	    }
-	    switch (el.ssrOptimizability) {
-	        case optimizability.FULL:
-	            // stringify whole tree
-	            return genStringElement(el, state);
-	        case optimizability.SELF:
-	            // stringify self and check children
-	            return genStringElementWithChildren(el, state);
-	        case optimizability.CHILDREN:
-	            // generate self as VNode and stringify children
-	            return genNormalElement(el, state, true);
-	        case optimizability.PARTIAL:
-	            // generate self as VNode and check children
-	            return genNormalElement(el, state, false);
-	        default:
-	            // bail whole tree
-	            return genElement(el, state);
-	    }
-	}
-	function genNormalElement(el, state, stringifyChildren) {
-	    const data = el.plain ? undefined : genData(el, state);
-	    const children = stringifyChildren
-	        ? `[${genChildrenAsStringNode(el, state)}]`
-	        : genSSRChildren(el, state, true);
-	    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-	}
-	function genSSRChildren(el, state, checkSkip) {
-	    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-	}
-	function genSSRNode(el, state) {
-	    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-	}
-	function genChildrenAsStringNode(el, state) {
-	    return el.children.length
-	        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-	        : '';
-	}
-	function genStringElement(el, state) {
-	    return `_ssrNode(${elementToString(el, state)})`;
-	}
-	function genStringElementWithChildren(el, state) {
-	    const children = genSSRChildren(el, state, true);
-	    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-	}
-	function elementToString(el, state) {
-	    return `(${flattenSegments(elementToSegments(el, state))})`;
-	}
-	function elementToSegments(el, state) {
-	    // v-for / v-if
-	    if (el.for && !el.forProcessed) {
-	        el.forProcessed = true;
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: genFor(el, state, elementToString, '_ssrList'),
-	            },
-	        ];
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        el.ifProcessed = true;
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: genIf(el, state, elementToString, '"<!---->"'),
-	            },
-	        ];
-	    }
-	    else if (el.tag === 'template') {
-	        return childrenToSegments(el, state);
-	    }
-	    const openSegments = elementToOpenTagSegments(el, state);
-	    const childrenSegments = childrenToSegments(el, state);
-	    const { isUnaryTag } = state.options;
-	    const close = isUnaryTag && isUnaryTag(el.tag)
-	        ? []
-	        : [{ type: RAW, value: `</${el.tag}>` }];
-	    return openSegments.concat(childrenSegments, close);
-	}
-	function elementToOpenTagSegments(el, state) {
-	    applyModelTransform(el, state);
-	    let binding;
-	    const segments = [{ type: RAW, value: `<${el.tag}` }];
-	    // attrs
-	    if (el.attrs) {
-	        segments.push.apply(segments, genAttrSegments(el.attrs));
-	    }
-	    // domProps
-	    if (el.props) {
-	        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-	    }
-	    // v-bind="object"
-	    if ((binding = el.attrsMap['v-bind'])) {
-	        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-	    }
-	    // v-bind.prop="object"
-	    if ((binding = el.attrsMap['v-bind.prop'])) {
-	        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-	    }
-	    // class
-	    if (el.staticClass || el.classBinding) {
-	        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-	    }
-	    // style & v-show
-	    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-	        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-	    }
-	    // _scopedId
-	    if (state.options.scopeId) {
-	        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-	    }
-	    segments.push({ type: RAW, value: `>` });
-	    return segments;
-	}
-	function childrenToSegments(el, state) {
-	    let binding;
-	    if ((binding = el.attrsMap['v-html'])) {
-	        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-	    }
-	    if ((binding = el.attrsMap['v-text'])) {
-	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-	    }
-	    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-	    }
-	    return el.children ? nodesToSegments(el.children, state) : [];
-	}
-	function nodesToSegments(children, state) {
-	    const segments = [];
-	    for (let i = 0; i < children.length; i++) {
-	        const c = children[i];
-	        if (c.type === 1) {
-	            segments.push.apply(segments, elementToSegments(c, state));
-	        }
-	        else if (c.type === 2) {
-	            segments.push({ type: INTERPOLATION, value: c.expression });
-	        }
-	        else if (c.type === 3) {
-	            let text = escape(c.text);
-	            if (c.isComment) {
-	                text = '<!--' + text + '-->';
-	            }
-	            segments.push({ type: RAW, value: text });
-	        }
-	    }
-	    return segments;
-	}
-	function flattenSegments(segments) {
-	    const mergedSegments = [];
-	    let textBuffer = '';
-	    const pushBuffer = () => {
-	        if (textBuffer) {
-	            mergedSegments.push(JSON.stringify(textBuffer));
-	            textBuffer = '';
-	        }
-	    };
-	    for (let i = 0; i < segments.length; i++) {
-	        const s = segments[i];
-	        if (s.type === RAW) {
-	            textBuffer += s.value;
-	        }
-	        else if (s.type === INTERPOLATION) {
-	            pushBuffer();
-	            mergedSegments.push(`_ssrEscape(${s.value})`);
-	        }
-	        else if (s.type === EXPRESSION) {
-	            pushBuffer();
-	            mergedSegments.push(`(${s.value})`);
-	        }
-	    }
-	    pushBuffer();
-	    return mergedSegments.join('+');
+	// The SSR codegen is essentially extending the default codegen to handle
+	// segment types
+	const RAW = 0;
+	const INTERPOLATION = 1;
+	const EXPRESSION = 2;
+	function generate(ast, options) {
+	    const state = new CodegenState(options);
+	    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+	    return {
+	        render: `with(this){return ${code}}`,
+	        staticRenderFns: state.staticRenderFns,
+	    };
+	}
+	function genSSRElement(el, state) {
+	    if (el.for && !el.forProcessed) {
+	        return genFor(el, state, genSSRElement);
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        return genIf(el, state, genSSRElement);
+	    }
+	    else if (el.tag === 'template' && !el.slotTarget) {
+	        return el.ssrOptimizability === optimizability.FULL
+	            ? genChildrenAsStringNode(el, state)
+	            : genSSRChildren(el, state) || 'void 0';
+	    }
+	    switch (el.ssrOptimizability) {
+	        case optimizability.FULL:
+	            // stringify whole tree
+	            return genStringElement(el, state);
+	        case optimizability.SELF:
+	            // stringify self and check children
+	            return genStringElementWithChildren(el, state);
+	        case optimizability.CHILDREN:
+	            // generate self as VNode and stringify children
+	            return genNormalElement(el, state, true);
+	        case optimizability.PARTIAL:
+	            // generate self as VNode and check children
+	            return genNormalElement(el, state, false);
+	        default:
+	            // bail whole tree
+	            return genElement(el, state);
+	    }
+	}
+	function genNormalElement(el, state, stringifyChildren) {
+	    const data = el.plain ? undefined : genData(el, state);
+	    const children = stringifyChildren
+	        ? `[${genChildrenAsStringNode(el, state)}]`
+	        : genSSRChildren(el, state, true);
+	    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+	}
+	function genSSRChildren(el, state, checkSkip) {
+	    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+	}
+	function genSSRNode(el, state) {
+	    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+	}
+	function genChildrenAsStringNode(el, state) {
+	    return el.children.length
+	        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+	        : '';
+	}
+	function genStringElement(el, state) {
+	    return `_ssrNode(${elementToString(el, state)})`;
+	}
+	function genStringElementWithChildren(el, state) {
+	    const children = genSSRChildren(el, state, true);
+	    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+	}
+	function elementToString(el, state) {
+	    return `(${flattenSegments(elementToSegments(el, state))})`;
+	}
+	function elementToSegments(el, state) {
+	    // v-for / v-if
+	    if (el.for && !el.forProcessed) {
+	        el.forProcessed = true;
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: genFor(el, state, elementToString, '_ssrList'),
+	            },
+	        ];
+	    }
+	    else if (el.if && !el.ifProcessed) {
+	        el.ifProcessed = true;
+	        return [
+	            {
+	                type: EXPRESSION,
+	                value: genIf(el, state, elementToString, '"<!---->"'),
+	            },
+	        ];
+	    }
+	    else if (el.tag === 'template') {
+	        return childrenToSegments(el, state);
+	    }
+	    const openSegments = elementToOpenTagSegments(el, state);
+	    const childrenSegments = childrenToSegments(el, state);
+	    const { isUnaryTag } = state.options;
+	    const close = isUnaryTag && isUnaryTag(el.tag)
+	        ? []
+	        : [{ type: RAW, value: `</${el.tag}>` }];
+	    return openSegments.concat(childrenSegments, close);
+	}
+	function elementToOpenTagSegments(el, state) {
+	    applyModelTransform(el, state);
+	    let binding;
+	    const segments = [{ type: RAW, value: `<${el.tag}` }];
+	    // attrs
+	    if (el.attrs) {
+	        segments.push.apply(segments, genAttrSegments(el.attrs));
+	    }
+	    // domProps
+	    if (el.props) {
+	        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+	    }
+	    // v-bind="object"
+	    if ((binding = el.attrsMap['v-bind'])) {
+	        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+	    }
+	    // v-bind.prop="object"
+	    if ((binding = el.attrsMap['v-bind.prop'])) {
+	        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+	    }
+	    // class
+	    if (el.staticClass || el.classBinding) {
+	        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+	    }
+	    // style & v-show
+	    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+	        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+	    }
+	    // _scopedId
+	    if (state.options.scopeId) {
+	        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+	    }
+	    segments.push({ type: RAW, value: `>` });
+	    return segments;
+	}
+	function childrenToSegments(el, state) {
+	    let binding;
+	    if ((binding = el.attrsMap['v-html'])) {
+	        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+	    }
+	    if ((binding = el.attrsMap['v-text'])) {
+	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+	    }
+	    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+	    }
+	    return el.children ? nodesToSegments(el.children, state) : [];
+	}
+	function nodesToSegments(children, state) {
+	    const segments = [];
+	    for (let i = 0; i < children.length; i++) {
+	        const c = children[i];
+	        if (c.type === 1) {
+	            segments.push.apply(segments, elementToSegments(c, state));
+	        }
+	        else if (c.type === 2) {
+	            segments.push({ type: INTERPOLATION, value: c.expression });
+	        }
+	        else if (c.type === 3) {
+	            let text = escape(c.text);
+	            if (c.isComment) {
+	                text = '<!--' + text + '-->';
+	            }
+	            segments.push({ type: RAW, value: text });
+	        }
+	    }
+	    return segments;
+	}
+	function flattenSegments(segments) {
+	    const mergedSegments = [];
+	    let textBuffer = '';
+	    const pushBuffer = () => {
+	        if (textBuffer) {
+	            mergedSegments.push(JSON.stringify(textBuffer));
+	            textBuffer = '';
+	        }
+	    };
+	    for (let i = 0; i < segments.length; i++) {
+	        const s = segments[i];
+	        if (s.type === RAW) {
+	            textBuffer += s.value;
+	        }
+	        else if (s.type === INTERPOLATION) {
+	            pushBuffer();
+	            mergedSegments.push(`_ssrEscape(${s.value})`);
+	        }
+	        else if (s.type === EXPRESSION) {
+	            pushBuffer();
+	            mergedSegments.push(`(${s.value})`);
+	        }
+	    }
+	    pushBuffer();
+	    return mergedSegments.join('+');
 	}
 
-	const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-	    const ast = parse(template.trim(), options);
-	    optimize(ast, options);
-	    const code = generate(ast, options);
-	    return {
-	        ast,
-	        render: code.render,
-	        staticRenderFns: code.staticRenderFns,
-	    };
+	const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+	    const ast = parse(template.trim(), options);
+	    optimize(ast, options);
+	    const code = generate(ast, options);
+	    return {
+	        ast,
+	        render: code.render,
+	        staticRenderFns: code.staticRenderFns,
+	    };
 	});
 
 	const { compile, compileToFunctions } = createCompiler(baseOptions);
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
index 9be57952d57..d4394d72c73 100644
--- a/packages/vue-template-compiler/build.js
+++ b/packages/vue-template-compiler/build.js
@@ -10,4559 +10,4559 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
 var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
 
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
+const emptyObject = Object.freeze({});
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+    return v === undefined || v === null;
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        // $flow-disable-line
+        typeof value === 'symbol' ||
+        typeof value === 'boolean');
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+const _toString = Object.prototype.toString;
+function toRawType(value) {
+    return _toString.call(value).slice(8, -1);
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]';
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+    const n = parseFloat(String(val));
+    return n >= 0 && Math.floor(n) === n && isFinite(val);
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+    const map = Object.create(null);
+    const list = str.split(',');
+    for (let i = 0; i < list.length; i++) {
+        map[list[i]] = true;
+    }
+    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+const isBuiltInTag = makeMap('slot,component', true);
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+makeMap('key,ref,slot,slot-scope,is');
+/**
+ * Remove an item from an array.
+ */
+function remove(arr, item) {
+    if (arr.length) {
+        const index = arr.indexOf(item);
+        if (index > -1) {
+            return arr.splice(index, 1);
+        }
+    }
+}
+/**
+ * Check whether an object has the property.
+ */
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+    const cache = Object.create(null);
+    return function cachedFn(str) {
+        const hit = cache[str];
+        return hit || (cache[str] = fn(str));
+    };
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+const camelizeRE = /-(\w)/g;
+const camelize = cached((str) => {
+    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
+});
+/**
+ * Hyphenate a camelCase string.
+ */
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cached((str) => {
+    return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+    for (const key in _from) {
+        to[key] = _from[key];
+    }
+    return to;
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) { }
+/**
+ * Always return false.
+ */
+const no = (a, b, c) => false;
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+const identity = (_) => _;
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys$1(modules) {
+    return modules
+        .reduce((keys, m) => {
+        return keys.concat(m.staticKeys || []);
+    }, [])
+        .join(',');
 }
 
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr');
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
     'title,tr,track');
 
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+        value: val,
+        enumerable: !!enumerable,
+        writable: true,
+        configurable: true,
+    });
 }
 
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (process.env.NODE_ENV !== 'production' &&
-                !stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    (i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
+const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
+const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
+const startTagOpen = new RegExp(`^<${qnameCapture}`);
+const startTagClose = /^\s*(\/?)>/;
+const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
+const doctype = /^<!DOCTYPE [^>]+>/i;
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+const comment = /^<!\--/;
+const conditionalComment = /^<!\[/;
+// Special Elements (can contain anything)
+const isPlainTextElement = makeMap('script,style,textarea', true);
+const reCache = {};
+const decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'",
+};
+const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
+const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
+// #5992
+const isIgnoreNewlineTag = makeMap('pre,textarea', true);
+const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
+function decodeAttr(value, shouldDecodeNewlines) {
+    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
+    return value.replace(re, (match) => decodingMap[match]);
+}
+function parseHTML(html, options) {
+    const stack = [];
+    const expectHTML = options.expectHTML;
+    const isUnaryTag = options.isUnaryTag || no;
+    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
+    let index = 0;
+    let last, lastTag;
+    while (html) {
+        last = html;
+        // Make sure we're not in a plaintext content element like script/style
+        if (!lastTag || !isPlainTextElement(lastTag)) {
+            let textEnd = html.indexOf('<');
+            if (textEnd === 0) {
+                // Comment:
+                if (comment.test(html)) {
+                    const commentEnd = html.indexOf('-->');
+                    if (commentEnd >= 0) {
+                        if (options.shouldKeepComment) {
+                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
+                        }
+                        advance(commentEnd + 3);
+                        continue;
+                    }
+                }
+                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                if (conditionalComment.test(html)) {
+                    const conditionalEnd = html.indexOf(']>');
+                    if (conditionalEnd >= 0) {
+                        advance(conditionalEnd + 2);
+                        continue;
+                    }
+                }
+                // Doctype:
+                const doctypeMatch = html.match(doctype);
+                if (doctypeMatch) {
+                    advance(doctypeMatch[0].length);
+                    continue;
+                }
+                // End tag:
+                const endTagMatch = html.match(endTag);
+                if (endTagMatch) {
+                    const curIndex = index;
+                    advance(endTagMatch[0].length);
+                    parseEndTag(endTagMatch[1], curIndex, index);
+                    continue;
+                }
+                // Start tag:
+                const startTagMatch = parseStartTag();
+                if (startTagMatch) {
+                    handleStartTag(startTagMatch);
+                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+                        advance(1);
+                    }
+                    continue;
+                }
+            }
+            let text, rest, next;
+            if (textEnd >= 0) {
+                rest = html.slice(textEnd);
+                while (!endTag.test(rest) &&
+                    !startTagOpen.test(rest) &&
+                    !comment.test(rest) &&
+                    !conditionalComment.test(rest)) {
+                    // < in plain text, be forgiving and treat it as text
+                    next = rest.indexOf('<', 1);
+                    if (next < 0)
+                        break;
+                    textEnd += next;
+                    rest = html.slice(textEnd);
+                }
+                text = html.substring(0, textEnd);
+            }
+            if (textEnd < 0) {
+                text = html;
+            }
+            if (text) {
+                advance(text.length);
+            }
+            if (options.chars && text) {
+                options.chars(text, index - text.length, index);
+            }
+        }
+        else {
+            let endTagLength = 0;
+            const stackedTag = lastTag.toLowerCase();
+            const reStackedTag = reCache[stackedTag] ||
+                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
+            const rest = html.replace(reStackedTag, function (all, text, endTag) {
+                endTagLength = endTag.length;
+                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
+                    text = text
+                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+                }
+                if (shouldIgnoreFirstNewline(stackedTag, text)) {
+                    text = text.slice(1);
+                }
+                if (options.chars) {
+                    options.chars(text);
+                }
+                return '';
+            });
+            index += html.length - rest.length;
+            html = rest;
+            parseEndTag(stackedTag, index - endTagLength, index);
+        }
+        if (html === last) {
+            options.chars && options.chars(html);
+            if (process.env.NODE_ENV !== 'production' &&
+                !stack.length &&
+                options.warn) {
+                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
+                    start: index + html.length,
+                });
+            }
+            break;
+        }
+    }
+    // Clean up any remaining tags
+    parseEndTag();
+    function advance(n) {
+        index += n;
+        html = html.substring(n);
+    }
+    function parseStartTag() {
+        const start = html.match(startTagOpen);
+        if (start) {
+            const match = {
+                tagName: start[1],
+                attrs: [],
+                start: index,
+            };
+            advance(start[0].length);
+            let end, attr;
+            while (!(end = html.match(startTagClose)) &&
+                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
+                attr.start = index;
+                advance(attr[0].length);
+                attr.end = index;
+                match.attrs.push(attr);
+            }
+            if (end) {
+                match.unarySlash = end[1];
+                advance(end[0].length);
+                match.end = index;
+                return match;
+            }
+        }
+    }
+    function handleStartTag(match) {
+        const tagName = match.tagName;
+        const unarySlash = match.unarySlash;
+        if (expectHTML) {
+            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+                parseEndTag(lastTag);
+            }
+            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+                parseEndTag(tagName);
+            }
+        }
+        const unary = isUnaryTag(tagName) || !!unarySlash;
+        const l = match.attrs.length;
+        const attrs = new Array(l);
+        for (let i = 0; i < l; i++) {
+            const args = match.attrs[i];
+            const value = args[3] || args[4] || args[5] || '';
+            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
+                ? options.shouldDecodeNewlinesForHref
+                : options.shouldDecodeNewlines;
+            attrs[i] = {
+                name: args[1],
+                value: decodeAttr(value, shouldDecodeNewlines),
+            };
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                attrs[i].start = args.start + args[0].match(/^\s*/).length;
+                attrs[i].end = args.end;
+            }
+        }
+        if (!unary) {
+            stack.push({
+                tag: tagName,
+                lowerCasedTag: tagName.toLowerCase(),
+                attrs: attrs,
+                start: match.start,
+                end: match.end,
+            });
+            lastTag = tagName;
+        }
+        if (options.start) {
+            options.start(tagName, attrs, unary, match.start, match.end);
+        }
+    }
+    function parseEndTag(tagName, start, end) {
+        let pos, lowerCasedTagName;
+        if (start == null)
+            start = index;
+        if (end == null)
+            end = index;
+        // Find the closest opened tag of the same type
+        if (tagName) {
+            lowerCasedTagName = tagName.toLowerCase();
+            for (pos = stack.length - 1; pos >= 0; pos--) {
+                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+                    break;
+                }
+            }
+        }
+        else {
+            // If no tag name is provided, clean shop
+            pos = 0;
+        }
+        if (pos >= 0) {
+            // Close all the open elements, up the stack
+            for (let i = stack.length - 1; i >= pos; i--) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    (i > pos || !tagName) &&
+                    options.warn) {
+                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
+                        start: stack[i].start,
+                        end: stack[i].end,
+                    });
+                }
+                if (options.end) {
+                    options.end(stack[i].tag, start, end);
+                }
+            }
+            // Remove the open elements from the stack
+            stack.length = pos;
+            lastTag = pos && stack[pos - 1].tag;
+        }
+        else if (lowerCasedTagName === 'br') {
+            if (options.start) {
+                options.start(tagName, [], true, start, end);
+            }
+        }
+        else if (lowerCasedTagName === 'p') {
+            if (options.start) {
+                options.start(tagName, [], false, start, end);
+            }
+            if (options.end) {
+                options.end(tagName, start, end);
+            }
+        }
+    }
 }
 
-const splitRE = /\r?\n/g;
-const replaceRE = /./g;
-const isSpecialTag = makeMap('script,style,template', true);
-/**
- * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
- */
-function parseComponent(content, options = {}) {
-    const sfc = {
-        template: null,
-        script: null,
-        styles: [],
-        customBlocks: [],
-        errors: [],
-    };
-    let depth = 0;
-    let currentBlock = null;
-    let warn = (msg) => {
-        sfc.errors.push(msg);
-    };
-    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        warn = (msg, range) => {
-            const data = { msg };
-            if (range.start != null) {
-                data.start = range.start;
-            }
-            if (range.end != null) {
-                data.end = range.end;
-            }
-            sfc.errors.push(data);
-        };
-    }
-    function start(tag, attrs, unary, start, end) {
-        if (depth === 0) {
-            currentBlock = {
-                type: tag,
-                content: '',
-                start: end,
-                attrs: attrs.reduce((cumulated, { name, value }) => {
-                    cumulated[name] = value || true;
-                    return cumulated;
-                }, {}),
-            };
-            if (isSpecialTag(tag)) {
-                checkAttrs(currentBlock, attrs);
-                if (tag === 'style') {
-                    sfc.styles.push(currentBlock);
-                }
-                else {
-                    sfc[tag] = currentBlock;
-                }
-            }
-            else {
-                // custom blocks
-                sfc.customBlocks.push(currentBlock);
-            }
-        }
-        if (!unary) {
-            depth++;
-        }
-    }
-    function checkAttrs(block, attrs) {
-        for (let i = 0; i < attrs.length; i++) {
-            const attr = attrs[i];
-            if (attr.name === 'lang') {
-                block.lang = attr.value;
-            }
-            if (attr.name === 'scoped') {
-                block.scoped = true;
-            }
-            if (attr.name === 'module') {
-                block.module = attr.value || true;
-            }
-            if (attr.name === 'src') {
-                block.src = attr.value;
-            }
-        }
-    }
-    function end(tag, start) {
-        if (depth === 1 && currentBlock) {
-            currentBlock.end = start;
-            let text = content.slice(currentBlock.start, currentBlock.end);
-            if (options.deindent !== false) {
-                text = deindent__default["default"](text);
-            }
-            // pad content so that linters and pre-processors can output correct
-            // line numbers in errors and warnings
-            if (currentBlock.type !== 'template' && options.pad) {
-                text = padContent(currentBlock, options.pad) + text;
-            }
-            currentBlock.content = text;
-            currentBlock = null;
-        }
-        depth--;
-    }
-    function padContent(block, pad) {
-        if (pad === 'space') {
-            return content.slice(0, block.start).replace(replaceRE, ' ');
-        }
-        else {
-            const offset = content.slice(0, block.start).split(splitRE).length;
-            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
-            return Array(offset).join(padChar);
-        }
-    }
-    parseHTML(content, {
-        warn,
-        start,
-        end,
-        outputSourceRange: options.outputSourceRange,
-    });
-    return sfc;
+const splitRE = /\r?\n/g;
+const replaceRE = /./g;
+const isSpecialTag = makeMap('script,style,template', true);
+/**
+ * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+ */
+function parseComponent(content, options = {}) {
+    const sfc = {
+        template: null,
+        script: null,
+        styles: [],
+        customBlocks: [],
+        errors: [],
+    };
+    let depth = 0;
+    let currentBlock = null;
+    let warn = (msg) => {
+        sfc.errors.push(msg);
+    };
+    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        warn = (msg, range) => {
+            const data = { msg };
+            if (range.start != null) {
+                data.start = range.start;
+            }
+            if (range.end != null) {
+                data.end = range.end;
+            }
+            sfc.errors.push(data);
+        };
+    }
+    function start(tag, attrs, unary, start, end) {
+        if (depth === 0) {
+            currentBlock = {
+                type: tag,
+                content: '',
+                start: end,
+                attrs: attrs.reduce((cumulated, { name, value }) => {
+                    cumulated[name] = value || true;
+                    return cumulated;
+                }, {}),
+            };
+            if (isSpecialTag(tag)) {
+                checkAttrs(currentBlock, attrs);
+                if (tag === 'style') {
+                    sfc.styles.push(currentBlock);
+                }
+                else {
+                    sfc[tag] = currentBlock;
+                }
+            }
+            else {
+                // custom blocks
+                sfc.customBlocks.push(currentBlock);
+            }
+        }
+        if (!unary) {
+            depth++;
+        }
+    }
+    function checkAttrs(block, attrs) {
+        for (let i = 0; i < attrs.length; i++) {
+            const attr = attrs[i];
+            if (attr.name === 'lang') {
+                block.lang = attr.value;
+            }
+            if (attr.name === 'scoped') {
+                block.scoped = true;
+            }
+            if (attr.name === 'module') {
+                block.module = attr.value || true;
+            }
+            if (attr.name === 'src') {
+                block.src = attr.value;
+            }
+        }
+    }
+    function end(tag, start) {
+        if (depth === 1 && currentBlock) {
+            currentBlock.end = start;
+            let text = content.slice(currentBlock.start, currentBlock.end);
+            if (options.deindent !== false) {
+                text = deindent__default["default"](text);
+            }
+            // pad content so that linters and pre-processors can output correct
+            // line numbers in errors and warnings
+            if (currentBlock.type !== 'template' && options.pad) {
+                text = padContent(currentBlock, options.pad) + text;
+            }
+            currentBlock.content = text;
+            currentBlock = null;
+        }
+        depth--;
+    }
+    function padContent(block, pad) {
+        if (pad === 'space') {
+            return content.slice(0, block.start).replace(replaceRE, ' ');
+        }
+        else {
+            const offset = content.slice(0, block.start).split(splitRE).length;
+            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
+            return Array(offset).join(padChar);
+        }
+    }
+    parseHTML(content, {
+        warn,
+        start,
+        end,
+        outputSourceRange: options.outputSourceRange,
+    });
+    return sfc;
 }
 
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
+// can we use __proto__?
+const hasProto = '__proto__' in {};
+// Browser environment sniffing
+const inBrowser = typeof window !== 'undefined';
+const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
+const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
+const UA = inBrowser && window.navigator.userAgent.toLowerCase();
+const isIE = UA && /msie|trident/.test(UA);
+UA && UA.indexOf('msie 9.0') > 0;
+const isEdge = UA && UA.indexOf('edge/') > 0;
+(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
+(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
+UA && /chrome\/\d+/.test(UA) && !isEdge;
+UA && /phantomjs/.test(UA);
+UA && UA.match(/firefox\/(\d+)/);
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+const nativeWatch = {}.watch;
+let supportsPassive = false;
+if (inBrowser) {
+    try {
+        const opts = {};
+        Object.defineProperty(opts, 'passive', {
+            get() {
+                /* istanbul ignore next */
+                supportsPassive = true;
+            },
+        }); // https://github.com/facebook/flow/issues/285
+        window.addEventListener('test-passive', null, opts);
+    }
+    catch (e) { }
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+let _isServer;
+const isServerRendering = () => {
+    if (_isServer === undefined) {
+        /* istanbul ignore if */
+        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+            // detect presence of vue-server-renderer and avoid
+            // Webpack shimming the process
+            _isServer =
+                global['process'] && global['process'].env.VUE_ENV === 'server';
+        }
+        else {
+            _isServer = false;
+        }
+    }
+    return _isServer;
+};
+/* istanbul ignore next */
+function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+const hasSymbol = typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys);
 /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
 
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
+const ASSET_TYPES = ['component', 'directive', 'filter'];
+const LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch',
 ];
 
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
+var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: process.env.NODE_ENV !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS,
 };
 
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
+let warn$2 = noop;
+let tip = noop;
+let generateComponentTrace; // work around flow check
+let formatComponentName;
+if (process.env.NODE_ENV !== 'production') {
+    const hasConsole = typeof console !== 'undefined';
+    const classifyRE = /(?:^|[-_])(\w)/g;
+    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
+    warn$2 = (msg, vm) => {
+        const trace = vm ? generateComponentTrace(vm) : '';
+        if (hasConsole && !config.silent) {
+            console.error(`[Vue warn]: ${msg}${trace}`);
+        }
+    };
+    tip = (msg, vm) => {
+        if (hasConsole && !config.silent) {
+            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
+        }
+    };
+    formatComponentName = (vm, includeFile) => {
+        if (vm.$root === vm) {
+            return '<Root>';
+        }
+        const options = typeof vm === 'function' && vm.cid != null
+            ? vm.options
+            : vm._isVue
+                ? vm.$options || vm.constructor.options
+                : vm;
+        let name = options.name || options._componentTag;
+        const file = options.__file;
+        if (!name && file) {
+            const match = file.match(/([^/\\]+)\.vue$/);
+            name = match && match[1];
+        }
+        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
+            (file && includeFile !== false ? ` at ${file}` : ''));
+    };
+    const repeat = (str, n) => {
+        let res = '';
+        while (n) {
+            if (n % 2 === 1)
+                res += str;
+            if (n > 1)
+                str += str;
+            n >>= 1;
+        }
+        return res;
+    };
+    generateComponentTrace = (vm) => {
+        if (vm._isVue && vm.$parent) {
+            const tree = [];
+            let currentRecursiveSequence = 0;
+            while (vm) {
+                if (tree.length > 0) {
+                    const last = tree[tree.length - 1];
+                    if (last.constructor === vm.constructor) {
+                        currentRecursiveSequence++;
+                        vm = vm.$parent;
+                        continue;
+                    }
+                    else if (currentRecursiveSequence > 0) {
+                        tree[tree.length - 1] = [last, currentRecursiveSequence];
+                        currentRecursiveSequence = 0;
+                    }
+                }
+                tree.push(vm);
+                vm = vm.$parent;
+            }
+            return ('\n\nfound in\n\n' +
+                tree
+                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
+                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
+                    : formatComponentName(vm)}`)
+                    .join('\n'));
+        }
+        else {
+            return `\n\n(found in ${formatComponentName(vm)})`;
+        }
+    };
 }
 
-let uid = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
+let uid = 0;
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+class Dep {
+    static target;
+    id;
+    subs;
+    constructor() {
+        this.id = uid++;
+        this.subs = [];
+    }
+    addSub(sub) {
+        this.subs.push(sub);
+    }
+    removeSub(sub) {
+        remove(this.subs, sub);
+    }
+    depend() {
+        if (Dep.target) {
+            Dep.target.addDep(this);
+        }
+    }
+    notify() {
+        // stabilize the subscriber list first
+        const subs = this.subs.slice();
+        if (process.env.NODE_ENV !== 'production' && !config.async) {
+            // subs aren't sorted in scheduler if not running async
+            // we need to sort them now to make sure they fire in correct
+            // order
+            subs.sort((a, b) => a.id - b.id);
+        }
+        for (let i = 0, l = subs.length; i < l; i++) {
+            subs[i].update();
+        }
+    }
+}
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
 Dep.target = null;
 
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
+class VNode {
+    tag;
+    data;
+    children;
+    text;
+    elm;
+    ns;
+    context; // rendered in this component's scope
+    key;
+    componentOptions;
+    componentInstance; // component instance
+    parent; // component placeholder node
+    // strictly internal
+    raw; // contains raw HTML? (server only)
+    isStatic; // hoisted static node
+    isRootInsert; // necessary for enter transition check
+    isComment; // empty comment placeholder?
+    isCloned; // is a cloned node?
+    isOnce; // is a v-once node?
+    asyncFactory; // async component factory function
+    asyncMeta;
+    isAsyncPlaceholder;
+    ssrContext;
+    fnContext; // real context vm for functional nodes
+    fnOptions; // for SSR caching
+    devtoolsMeta; // used to store functional render context for devtools
+    fnScopeId; // functional scope id support
+    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
+        this.tag = tag;
+        this.data = data;
+        this.children = children;
+        this.text = text;
+        this.elm = elm;
+        this.ns = undefined;
+        this.context = context;
+        this.fnContext = undefined;
+        this.fnOptions = undefined;
+        this.fnScopeId = undefined;
+        this.key = data && data.key;
+        this.componentOptions = componentOptions;
+        this.componentInstance = undefined;
+        this.parent = undefined;
+        this.raw = false;
+        this.isStatic = false;
+        this.isRootInsert = true;
+        this.isComment = false;
+        this.isCloned = false;
+        this.isOnce = false;
+        this.asyncFactory = asyncFactory;
+        this.asyncMeta = undefined;
+        this.isAsyncPlaceholder = false;
+    }
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get child() {
+        return this.componentInstance;
+    }
 }
 
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+const arrayProto = Array.prototype;
+const arrayMethods = Object.create(arrayProto);
+const methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+];
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+    // cache original method
+    const original = arrayProto[method];
+    def(arrayMethods, method, function mutator(...args) {
+        const result = original.apply(this, args);
+        const ob = this.__ob__;
+        let inserted;
+        switch (method) {
+            case 'push':
+            case 'unshift':
+                inserted = args;
+                break;
+            case 'splice':
+                inserted = args.slice(2);
+                break;
+        }
+        if (inserted)
+            ob.observeArray(inserted);
+        // notify change
+        ob.dep.notify();
+        return result;
+    });
 });
 
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (!isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
+const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+class Observer {
+    value;
+    dep;
+    vmCount; // number of vms that have this object as root $data
+    constructor(value) {
+        this.value = value;
+        this.dep = new Dep();
+        this.vmCount = 0;
+        def(value, '__ob__', this);
+        if (Array.isArray(value)) {
+            if (hasProto) {
+                protoAugment(value, arrayMethods);
+            }
+            else {
+                copyAugment(value, arrayMethods, arrayKeys);
+            }
+            this.observeArray(value);
+        }
+        else {
+            this.walk(value);
+        }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    walk(obj) {
+        const keys = Object.keys(obj);
+        for (let i = 0; i < keys.length; i++) {
+            defineReactive(obj, keys[i]);
+        }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    observeArray(items) {
+        for (let i = 0, l = items.length; i < l; i++) {
+            observe(items[i]);
+        }
+    }
+}
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src;
+    /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        def(target, key, src[key]);
+    }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+        return;
+    }
+    let ob;
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+        ob = value.__ob__;
+    }
+    else if (!isServerRendering() &&
+        (Array.isArray(value) || isPlainObject(value)) &&
+        Object.isExtensible(value) &&
+        !value._isVue) {
+        ob = new Observer(value);
+    }
+    if (asRootData && ob) {
+        ob.vmCount++;
+    }
+    return ob;
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+    const dep = new Dep();
+    const property = Object.getOwnPropertyDescriptor(obj, key);
+    if (property && property.configurable === false) {
+        return;
+    }
+    // cater for pre-defined getter/setters
+    const getter = property && property.get;
+    const setter = property && property.set;
+    if ((!getter || setter) && arguments.length === 2) {
+        val = obj[key];
+    }
+    let childOb = !shallow && observe(val);
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        configurable: true,
+        get: function reactiveGetter() {
+            const value = getter ? getter.call(obj) : val;
+            if (Dep.target) {
+                dep.depend();
+                if (childOb) {
+                    childOb.dep.depend();
+                    if (Array.isArray(value)) {
+                        dependArray(value);
+                    }
+                }
+            }
+            return value;
+        },
+        set: function reactiveSetter(newVal) {
+            const value = getter ? getter.call(obj) : val;
+            /* eslint-disable no-self-compare */
+            if (newVal === value || (newVal !== newVal && value !== value)) {
+                return;
+            }
+            /* eslint-enable no-self-compare */
+            if (process.env.NODE_ENV !== 'production' && customSetter) {
+                customSetter();
+            }
+            // #7981: for accessor properties without setter
+            if (getter && !setter)
+                return;
+            if (setter) {
+                setter.call(obj, newVal);
+            }
+            else {
+                val = newVal;
+            }
+            childOb = !shallow && observe(newVal);
+            dep.notify();
+        },
+    });
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+    if (process.env.NODE_ENV !== 'production' &&
+        (isUndef(target) || isPrimitive(target))) {
+        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    if (key in target && !(key in Object.prototype)) {
+        target[key] = val;
+        return val;
+    }
+    const ob = target.__ob__;
+    if (target._isVue || (ob && ob.vmCount)) {
+        process.env.NODE_ENV !== 'production' &&
+            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
+                'at runtime - declare it upfront in the data option.');
+        return val;
+    }
+    if (!ob) {
+        target[key] = val;
+        return val;
+    }
+    defineReactive(ob.value, key, val);
+    ob.dep.notify();
+    return val;
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+    for (let e, i = 0, l = value.length; i < l; i++) {
+        e = value[i];
+        e && e.__ob__ && e.__ob__.dep.depend();
+        if (Array.isArray(e)) {
+            dependArray(e);
+        }
+    }
 }
 
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+const strats = config.optionMergeStrategies;
+/**
+ * Options with restrictions
+ */
+if (process.env.NODE_ENV !== 'production') {
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+        if (!vm) {
+            warn$2(`option "${key}" can only be used during instance ` +
+                'creation with the `new` keyword.');
+        }
+        return defaultStrat(parent, child);
+    };
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+    if (!from)
+        return to;
+    let key, toVal, fromVal;
+    const keys = hasSymbol
+        ? Reflect.ownKeys(from)
+        : Object.keys(from);
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        // in case the object is already observed...
+        if (key === '__ob__')
+            continue;
+        toVal = to[key];
+        fromVal = from[key];
+        if (!hasOwn(to, key)) {
+            set(to, key, fromVal);
+        }
+        else if (toVal !== fromVal &&
+            isPlainObject(toVal) &&
+            isPlainObject(fromVal)) {
+            mergeData(toVal, fromVal);
+        }
+    }
+    return to;
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+        // in a Vue.extend merge, both should be functions
+        if (!childVal) {
+            return parentVal;
+        }
+        if (!parentVal) {
+            return childVal;
+        }
+        // when parentVal & childVal are both present,
+        // we need to return a function that returns the
+        // merged result of both functions... no need to
+        // check if parentVal is a function here because
+        // it has to be a function to pass previous merges.
+        return function mergedDataFn() {
+            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
+        };
+    }
+    else {
+        return function mergedInstanceDataFn() {
+            // instance merge
+            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
+            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
+            if (instanceData) {
+                return mergeData(instanceData, defaultData);
+            }
+            else {
+                return defaultData;
+            }
+        };
+    }
+}
+strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+        if (childVal && typeof childVal !== 'function') {
+            process.env.NODE_ENV !== 'production' &&
+                warn$2('The "data" option should be a function ' +
+                    'that returns a per-instance value in component ' +
+                    'definitions.', vm);
+            return parentVal;
+        }
+        return mergeDataOrFn(parentVal, childVal);
+    }
+    return mergeDataOrFn(parentVal, childVal, vm);
+};
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : Array.isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+LIFECYCLE_HOOKS.forEach((hook) => {
+    strats[hook] = mergeHook;
+});
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+    const res = Object.create(parentVal || null);
+    if (childVal) {
+        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
+        return extend(res, childVal);
+    }
+    else {
+        return res;
+    }
+}
+ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets;
+});
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch)
+        parentVal = undefined;
+    //@ts-expect-error work around
+    if (childVal === nativeWatch)
+        childVal = undefined;
+    /* istanbul ignore if */
+    if (!childVal)
+        return Object.create(parentVal || null);
+    if (process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = {};
+    extend(ret, parentVal);
+    for (const key in childVal) {
+        let parent = ret[key];
+        const child = childVal[key];
+        if (parent && !Array.isArray(parent)) {
+            parent = [parent];
+        }
+        ret[key] = parent
+            ? parent.concat(child)
+            : Array.isArray(child)
+                ? child
+                : [child];
+    }
+    return ret;
+};
+/**
+ * Other object hashes.
+ */
+strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
+    if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm);
+    }
+    if (!parentVal)
+        return childVal;
+    const ret = Object.create(null);
+    extend(ret, parentVal);
+    if (childVal)
+        extend(ret, childVal);
+    return ret;
+};
+strats.provide = mergeDataOrFn;
+/**
+ * Default strategy.
+ */
+const defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal;
+};
+function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+        warn$2(`Invalid value for option "${name}": expected an Object, ` +
+            `but got ${toRawType(value)}.`, vm);
+    }
 }
 
-/* globals MutationObserver */
-const callbacks = [];
-function flushCallbacks() {
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve();
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
+/* globals MutationObserver */
+const callbacks = [];
+function flushCallbacks() {
+    const copies = callbacks.slice(0);
+    callbacks.length = 0;
+    for (let i = 0; i < copies.length; i++) {
+        copies[i]();
+    }
+}
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve();
+}
+else if (!isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+        // PhantomJS and iOS 7.x
+        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    let counter = 1;
+    const observer = new MutationObserver(flushCallbacks);
+    const textNode = document.createTextNode(String(counter));
+    observer.observe(textNode, {
+        characterData: true,
+    });
+}
+else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
 else ;
 
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-makeMap('events,caret,typing,plaintext-only');
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class');
+// attributes that should be using props for binding
+const acceptValue = makeMap('input,textarea,option,select,progress');
+const mustUseProp = (tag, type, attr) => {
+    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
+        (attr === 'selected' && tag === 'option') ||
+        (attr === 'checked' && tag === 'input') ||
+        (attr === 'muted' && tag === 'video'));
+};
+const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
+makeMap('events,caret,typing,plaintext-only');
+const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
     'truespeed,typemustmatch,visible');
 
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
+const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot');
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
+const isPreTag = (tag) => tag === 'pre';
+const isReservedTag = (tag) => {
+    return isHTMLTag(tag) || isSVG(tag);
+};
+function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+        return 'svg';
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+        return 'math';
+    }
+}
 makeMap('text,number,password,search,email,tel,url');
 
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
+const validDivisionCharRE = /[\w).+\-_$\]]/;
+function parseFilters(exp) {
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplateString = false;
+    let inRegex = false;
+    let curly = 0;
+    let square = 0;
+    let paren = 0;
+    let lastFilterIndex = 0;
+    let c, prev, i, expression, filters;
+    for (i = 0; i < exp.length; i++) {
+        prev = c;
+        c = exp.charCodeAt(i);
+        if (inSingle) {
+            if (c === 0x27 && prev !== 0x5c)
+                inSingle = false;
+        }
+        else if (inDouble) {
+            if (c === 0x22 && prev !== 0x5c)
+                inDouble = false;
+        }
+        else if (inTemplateString) {
+            if (c === 0x60 && prev !== 0x5c)
+                inTemplateString = false;
+        }
+        else if (inRegex) {
+            if (c === 0x2f && prev !== 0x5c)
+                inRegex = false;
+        }
+        else if (c === 0x7c && // pipe
+            exp.charCodeAt(i + 1) !== 0x7c &&
+            exp.charCodeAt(i - 1) !== 0x7c &&
+            !curly &&
+            !square &&
+            !paren) {
+            if (expression === undefined) {
+                // first filter, end of expression
+                lastFilterIndex = i + 1;
+                expression = exp.slice(0, i).trim();
+            }
+            else {
+                pushFilter();
+            }
+        }
+        else {
+            switch (c) {
+                case 0x22:
+                    inDouble = true;
+                    break; // "
+                case 0x27:
+                    inSingle = true;
+                    break; // '
+                case 0x60:
+                    inTemplateString = true;
+                    break; // `
+                case 0x28:
+                    paren++;
+                    break; // (
+                case 0x29:
+                    paren--;
+                    break; // )
+                case 0x5b:
+                    square++;
+                    break; // [
+                case 0x5d:
+                    square--;
+                    break; // ]
+                case 0x7b:
+                    curly++;
+                    break; // {
+                case 0x7d:
+                    curly--;
+                    break; // }
+            }
+            if (c === 0x2f) {
+                // /
+                let j = i - 1;
+                let p;
+                // find first non-whitespace prev char
+                for (; j >= 0; j--) {
+                    p = exp.charAt(j);
+                    if (p !== ' ')
+                        break;
+                }
+                if (!p || !validDivisionCharRE.test(p)) {
+                    inRegex = true;
+                }
+            }
+        }
+    }
+    if (expression === undefined) {
+        expression = exp.slice(0, i).trim();
+    }
+    else if (lastFilterIndex !== 0) {
+        pushFilter();
+    }
+    function pushFilter() {
+        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
+        lastFilterIndex = i + 1;
+    }
+    if (filters) {
+        for (i = 0; i < filters.length; i++) {
+            expression = wrapFilter(expression, filters[i]);
+        }
+    }
+    return expression;
+}
+function wrapFilter(exp, filter) {
+    const i = filter.indexOf('(');
+    if (i < 0) {
+        // _f: resolveFilter
+        return `_f("${filter}")(${exp})`;
+    }
+    else {
+        const name = filter.slice(0, i);
+        const args = filter.slice(i + 1);
+        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
+    }
 }
 
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
+const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
+const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
+const buildRegex = cached((delimiters) => {
+    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
+    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
+});
+function parseText(text, delimiters) {
+    //@ts-expect-error
+    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
+    if (!tagRE.test(text)) {
+        return;
+    }
+    const tokens = [];
+    const rawTokens = [];
+    let lastIndex = (tagRE.lastIndex = 0);
+    let match, index, tokenValue;
+    while ((match = tagRE.exec(text))) {
+        index = match.index;
+        // push text token
+        if (index > lastIndex) {
+            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
+            tokens.push(JSON.stringify(tokenValue));
+        }
+        // tag token
+        const exp = parseFilters(match[1].trim());
+        tokens.push(`_s(${exp})`);
+        rawTokens.push({ '@binding': exp });
+        lastIndex = index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        rawTokens.push((tokenValue = text.slice(lastIndex)));
+        tokens.push(JSON.stringify(tokenValue));
+    }
+    return {
+        expression: tokens.join('+'),
+        tokens: rawTokens,
+    };
 }
 
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' &&
-        warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+    console.error(`[Vue compiler]: ${msg}`);
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
+}
+function addProp(el, name, value, range, dynamic) {
+    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+function addAttr(el, name, value, range, dynamic) {
+    const attrs = dynamic
+        ? el.dynamicAttrs || (el.dynamicAttrs = [])
+        : el.attrs || (el.attrs = []);
+    attrs.push(rangeSetItem({ name, value, dynamic }, range));
+    el.plain = false;
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value;
+    el.attrsList.push(rangeSetItem({ name, value }, range));
+}
+function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
+    (el.directives || (el.directives = [])).push(rangeSetItem({
+        name,
+        rawName,
+        value,
+        arg,
+        isDynamicArg,
+        modifiers,
+    }, range));
+    el.plain = false;
+}
+function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
+}
+function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
+    modifiers = modifiers || emptyObject;
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' &&
+        warn &&
+        modifiers.prevent &&
+        modifiers.passive) {
+        warn("passive and prevent can't be used together. " +
+            "Passive handler can't prevent default event.", range);
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+        if (dynamic) {
+            name = `(${name})==='click'?'contextmenu':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'contextmenu';
+            delete modifiers.right;
+        }
+    }
+    else if (modifiers.middle) {
+        if (dynamic) {
+            name = `(${name})==='click'?'mouseup':(${name})`;
+        }
+        else if (name === 'click') {
+            name = 'mouseup';
+        }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+        delete modifiers.capture;
+        name = prependModifierMarker('!', name, dynamic);
+    }
+    if (modifiers.once) {
+        delete modifiers.once;
+        name = prependModifierMarker('~', name, dynamic);
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+        delete modifiers.passive;
+        name = prependModifierMarker('&', name, dynamic);
+    }
+    let events;
+    if (modifiers.native) {
+        delete modifiers.native;
+        events = el.nativeEvents || (el.nativeEvents = {});
+    }
+    else {
+        events = el.events || (el.events = {});
+    }
+    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
+    if (modifiers !== emptyObject) {
+        newHandler.modifiers = modifiers;
+    }
+    const handlers = events[name];
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
+    }
+    else if (handlers) {
+        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
+    }
+    else {
+        events[name] = newHandler;
+    }
+    el.plain = false;
+}
+function getRawBindingAttr(el, name) {
+    return (el.rawAttrsMap[':' + name] ||
+        el.rawAttrsMap['v-bind:' + name] ||
+        el.rawAttrsMap[name]);
+}
+function getBindingAttr(el, name, getStatic) {
+    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
+    if (dynamicValue != null) {
+        return parseFilters(dynamicValue);
+    }
+    else if (getStatic !== false) {
+        const staticValue = getAndRemoveAttr(el, name);
+        if (staticValue != null) {
+            return JSON.stringify(staticValue);
+        }
+    }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+    let val;
+    if ((val = el.attrsMap[name]) != null) {
+        const list = el.attrsList;
+        for (let i = 0, l = list.length; i < l; i++) {
+            if (list[i].name === name) {
+                list.splice(i, 1);
+                break;
+            }
+        }
+    }
+    if (removeFromMap) {
+        delete el.attrsMap[name];
+    }
+    return val;
+}
+function getAndRemoveAttrByRegex(el, name) {
+    const list = el.attrsList;
+    for (let i = 0, l = list.length; i < l; i++) {
+        const attr = list[i];
+        if (name.test(attr.name)) {
+            list.splice(i, 1);
+            return attr;
+        }
+    }
+}
+function rangeSetItem(item, range) {
+    if (range) {
+        if (range.start != null) {
+            item.start = range.start;
+        }
+        if (range.end != null) {
+            item.end = range.end;
+        }
+    }
+    return item;
 }
 
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (process.env.NODE_ENV !== 'production' && staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
+function transformNode$1(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticClass = getAndRemoveAttr(el, 'class');
+    if (process.env.NODE_ENV !== 'production' && staticClass) {
+        const res = parseText(staticClass, options.delimiters);
+        if (res) {
+            warn(`class="${staticClass}": ` +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
+        }
+    }
+    if (staticClass) {
+        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
+    }
+    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
+    if (classBinding) {
+        el.classBinding = classBinding;
+    }
+}
+function genData$2(el) {
+    let data = '';
+    if (el.staticClass) {
+        data += `staticClass:${el.staticClass},`;
+    }
+    if (el.classBinding) {
+        data += `class:${el.classBinding},`;
+    }
+    return data;
+}
+var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2,
 };
 
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
+const parseStyleText = cached(function (cssText) {
+    const res = {};
+    const listDelimiter = /;(?![^(]*\))/g;
+    const propertyDelimiter = /:(.+)/;
+    cssText.split(listDelimiter).forEach(function (item) {
+        if (item) {
+            const tmp = item.split(propertyDelimiter);
+            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
+        }
+    });
+    return res;
 });
 
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
+function transformNode(el, options) {
+    const warn = options.warn || baseWarn;
+    const staticStyle = getAndRemoveAttr(el, 'style');
+    if (staticStyle) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            const res = parseText(staticStyle, options.delimiters);
+            if (res) {
+                warn(`style="${staticStyle}": ` +
+                    'Interpolation inside attributes has been removed. ' +
+                    'Use v-bind or the colon shorthand instead. For example, ' +
+                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
+            }
+        }
+        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
+    }
+    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
+    if (styleBinding) {
+        el.styleBinding = styleBinding;
+    }
+}
+function genData$1(el) {
+    let data = '';
+    if (el.staticStyle) {
+        data += `staticStyle:${el.staticStyle},`;
+    }
+    if (el.styleBinding) {
+        data += `style:(${el.styleBinding}),`;
+    }
+    return data;
+}
+var style = {
+    staticKeys: ['staticStyle'],
+    transformNode,
+    genData: genData$1,
 };
 
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+    const { number, trim } = modifiers || {};
+    const baseValueExpression = '$$v';
+    let valueExpression = baseValueExpression;
+    if (trim) {
+        valueExpression =
+            `(typeof ${baseValueExpression} === 'string'` +
+                `? ${baseValueExpression}.trim()` +
+                `: ${baseValueExpression})`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    const assignment = genAssignmentCode(value, valueExpression);
+    el.model = {
+        value: `(${value})`,
+        expression: JSON.stringify(value),
+        callback: `function (${baseValueExpression}) {${assignment}}`,
+    };
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+    const res = parseModel(value);
+    if (res.key === null) {
+        return `${value}=${assignment}`;
+    }
+    else {
+        return `$set(${res.exp}, ${res.key}, ${assignment})`;
+    }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+let len, str, chr, index, expressionPos, expressionEndPos;
+function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim();
+    len = val.length;
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+        index = val.lastIndexOf('.');
+        if (index > -1) {
+            return {
+                exp: val.slice(0, index),
+                key: '"' + val.slice(index + 1) + '"',
+            };
+        }
+        else {
+            return {
+                exp: val,
+                key: null,
+            };
+        }
+    }
+    str = val;
+    index = expressionPos = expressionEndPos = 0;
+    while (!eof()) {
+        chr = next();
+        /* istanbul ignore if */
+        if (isStringStart(chr)) {
+            parseString(chr);
+        }
+        else if (chr === 0x5b) {
+            parseBracket(chr);
+        }
+    }
+    return {
+        exp: val.slice(0, expressionPos),
+        key: val.slice(expressionPos + 1, expressionEndPos),
+    };
+}
+function next() {
+    return str.charCodeAt(++index);
+}
+function eof() {
+    return index >= len;
+}
+function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27;
+}
+function parseBracket(chr) {
+    let inBracket = 1;
+    expressionPos = index;
+    while (!eof()) {
+        chr = next();
+        if (isStringStart(chr)) {
+            parseString(chr);
+            continue;
+        }
+        if (chr === 0x5b)
+            inBracket++;
+        if (chr === 0x5d)
+            inBracket--;
+        if (inBracket === 0) {
+            expressionEndPos = index;
+            break;
+        }
+    }
+}
+function parseString(chr) {
+    const stringQuote = chr;
+    while (!eof()) {
+        chr = next();
+        if (chr === stringQuote) {
+            break;
+        }
+    }
 }
 
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he__default["default"].decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn$1;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn$1(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn: warn$1,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                process.env.NODE_ENV !== 'production' &&
-                    warn$1('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (process.env.NODE_ENV !== 'production' &&
-                        options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (process.env.NODE_ENV !== 'production' &&
-                    value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (process.env.NODE_ENV !== 'production' && name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            if (process.env.NODE_ENV !== 'production') {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn$1(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (process.env.NODE_ENV !== 'production' &&
-            map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
+const onRE = /^@|^v-on:/;
+const dirRE = /^v-|^@|^:|^#/;
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+const stripParensRE = /^\(|\)$/g;
+const dynamicArgRE = /^\[.*\]$/;
+const argRE = /:(.*)$/;
+const bindRE = /^:|^\.|^v-bind:/;
+const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
+const slotRE = /^v-slot(:|$)|^#/;
+const lineBreakRE = /[\r\n]/;
+const whitespaceRE = /[ \f\t\r\n]+/g;
+const invalidAttributeRE = /[\s"'<>\/=]/;
+const decodeHTMLCached = cached(he__default["default"].decode);
+const emptySlotScopeToken = `_empty_`;
+// configurable state
+let warn$1;
+let delimiters;
+let transforms;
+let preTransforms;
+let postTransforms;
+let platformIsPreTag;
+let platformMustUseProp;
+let platformGetTagNamespace;
+let maybeComponent;
+function createASTElement(tag, attrs, parent) {
+    return {
+        type: 1,
+        tag,
+        attrsList: attrs,
+        attrsMap: makeAttrsMap(attrs),
+        rawAttrsMap: {},
+        parent,
+        children: [],
+    };
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+    warn$1 = options.warn || baseWarn;
+    platformIsPreTag = options.isPreTag || no;
+    platformMustUseProp = options.mustUseProp || no;
+    platformGetTagNamespace = options.getTagNamespace || no;
+    const isReservedTag = options.isReservedTag || no;
+    maybeComponent = (el) => !!(el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
+    transforms = pluckModuleFunction(options.modules, 'transformNode');
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
+    delimiters = options.delimiters;
+    const stack = [];
+    const preserveWhitespace = options.preserveWhitespace !== false;
+    const whitespaceOption = options.whitespace;
+    let root;
+    let currentParent;
+    let inVPre = false;
+    let inPre = false;
+    let warned = false;
+    function warnOnce(msg, range) {
+        if (!warned) {
+            warned = true;
+            warn$1(msg, range);
+        }
+    }
+    function closeElement(element) {
+        trimEndingWhitespace(element);
+        if (!inVPre && !element.processed) {
+            element = processElement(element, options);
+        }
+        // tree management
+        if (!stack.length && element !== root) {
+            // allow root elements with v-if, v-else-if and v-else
+            if (root.if && (element.elseif || element.else)) {
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(element);
+                }
+                addIfCondition(root, {
+                    exp: element.elseif,
+                    block: element,
+                });
+            }
+            else if (process.env.NODE_ENV !== 'production') {
+                warnOnce(`Component template should contain exactly one root element. ` +
+                    `If you are using v-if on multiple elements, ` +
+                    `use v-else-if to chain them instead.`, { start: element.start });
+            }
+        }
+        if (currentParent && !element.forbidden) {
+            if (element.elseif || element.else) {
+                processIfConditions(element, currentParent);
+            }
+            else {
+                if (element.slotScope) {
+                    // scoped slot
+                    // keep it in the children list so that v-else(-if) conditions can
+                    // find it as the prev node.
+                    const name = element.slotTarget || '"default"';
+                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
+                }
+                currentParent.children.push(element);
+                element.parent = currentParent;
+            }
+        }
+        // final children cleanup
+        // filter out scoped slots
+        element.children = element.children.filter((c) => !c.slotScope);
+        // remove trailing whitespace node again
+        trimEndingWhitespace(element);
+        // check pre state
+        if (element.pre) {
+            inVPre = false;
+        }
+        if (platformIsPreTag(element.tag)) {
+            inPre = false;
+        }
+        // apply post-transforms
+        for (let i = 0; i < postTransforms.length; i++) {
+            postTransforms[i](element, options);
+        }
+    }
+    function trimEndingWhitespace(el) {
+        // remove trailing whitespace node
+        if (!inPre) {
+            let lastNode;
+            while ((lastNode = el.children[el.children.length - 1]) &&
+                lastNode.type === 3 &&
+                lastNode.text === ' ') {
+                el.children.pop();
+            }
+        }
+    }
+    function checkRootConstraints(el) {
+        if (el.tag === 'slot' || el.tag === 'template') {
+            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
+                'contain multiple nodes.', { start: el.start });
+        }
+        if (el.attrsMap.hasOwnProperty('v-for')) {
+            warnOnce('Cannot use v-for on stateful component root element because ' +
+                'it renders multiple elements.', el.rawAttrsMap['v-for']);
+        }
+    }
+    parseHTML(template, {
+        warn: warn$1,
+        expectHTML: options.expectHTML,
+        isUnaryTag: options.isUnaryTag,
+        canBeLeftOpenTag: options.canBeLeftOpenTag,
+        shouldDecodeNewlines: options.shouldDecodeNewlines,
+        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+        shouldKeepComment: options.comments,
+        outputSourceRange: options.outputSourceRange,
+        start(tag, attrs, unary, start, end) {
+            // check namespace.
+            // inherit parent ns if there is one
+            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
+            // handle IE svg bug
+            /* istanbul ignore if */
+            if (isIE && ns === 'svg') {
+                attrs = guardIESVGBug(attrs);
+            }
+            let element = createASTElement(tag, attrs, currentParent);
+            if (ns) {
+                element.ns = ns;
+            }
+            if (process.env.NODE_ENV !== 'production') {
+                if (options.outputSourceRange) {
+                    element.start = start;
+                    element.end = end;
+                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
+                        cumulated[attr.name] = attr;
+                        return cumulated;
+                    }, {});
+                }
+                attrs.forEach((attr) => {
+                    if (invalidAttributeRE.test(attr.name)) {
+                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
+                            `spaces, quotes, <, >, / or =.`, {
+                            start: attr.start + attr.name.indexOf(`[`),
+                            end: attr.start + attr.name.length,
+                        });
+                    }
+                });
+            }
+            if (isForbiddenTag(element) && !isServerRendering()) {
+                element.forbidden = true;
+                process.env.NODE_ENV !== 'production' &&
+                    warn$1('Templates should only be responsible for mapping the state to the ' +
+                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
+                        `<${tag}>` +
+                        ', as they will not be parsed.', { start: element.start });
+            }
+            // apply pre-transforms
+            for (let i = 0; i < preTransforms.length; i++) {
+                element = preTransforms[i](element, options) || element;
+            }
+            if (!inVPre) {
+                processPre(element);
+                if (element.pre) {
+                    inVPre = true;
+                }
+            }
+            if (platformIsPreTag(element.tag)) {
+                inPre = true;
+            }
+            if (inVPre) {
+                processRawAttrs(element);
+            }
+            else if (!element.processed) {
+                // structural directives
+                processFor(element);
+                processIf(element);
+                processOnce(element);
+            }
+            if (!root) {
+                root = element;
+                if (process.env.NODE_ENV !== 'production') {
+                    checkRootConstraints(root);
+                }
+            }
+            if (!unary) {
+                currentParent = element;
+                stack.push(element);
+            }
+            else {
+                closeElement(element);
+            }
+        },
+        end(tag, start, end) {
+            const element = stack[stack.length - 1];
+            // pop stack
+            stack.length -= 1;
+            currentParent = stack[stack.length - 1];
+            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+                element.end = end;
+            }
+            closeElement(element);
+        },
+        chars(text, start, end) {
+            if (!currentParent) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (text === template) {
+                        warnOnce('Component template requires a root element, rather than just text.', { start });
+                    }
+                    else if ((text = text.trim())) {
+                        warnOnce(`text "${text}" outside root element will be ignored.`, {
+                            start,
+                        });
+                    }
+                }
+                return;
+            }
+            // IE textarea placeholder bug
+            /* istanbul ignore if */
+            if (isIE &&
+                currentParent.tag === 'textarea' &&
+                currentParent.attrsMap.placeholder === text) {
+                return;
+            }
+            const children = currentParent.children;
+            if (inPre || text.trim()) {
+                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
+            }
+            else if (!children.length) {
+                // remove the whitespace-only node right after an opening tag
+                text = '';
+            }
+            else if (whitespaceOption) {
+                if (whitespaceOption === 'condense') {
+                    // in condense mode, remove the whitespace node if it contains
+                    // line break, otherwise condense to a single space
+                    text = lineBreakRE.test(text) ? '' : ' ';
+                }
+                else {
+                    text = ' ';
+                }
+            }
+            else {
+                text = preserveWhitespace ? ' ' : '';
+            }
+            if (text) {
+                if (!inPre && whitespaceOption === 'condense') {
+                    // condense consecutive whitespaces into single space
+                    text = text.replace(whitespaceRE, ' ');
+                }
+                let res;
+                let child;
+                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+                    child = {
+                        type: 2,
+                        expression: res.expression,
+                        tokens: res.tokens,
+                        text,
+                    };
+                }
+                else if (text !== ' ' ||
+                    !children.length ||
+                    children[children.length - 1].text !== ' ') {
+                    child = {
+                        type: 3,
+                        text,
+                    };
+                }
+                if (child) {
+                    if (process.env.NODE_ENV !== 'production' &&
+                        options.outputSourceRange) {
+                        child.start = start;
+                        child.end = end;
+                    }
+                    children.push(child);
+                }
+            }
+        },
+        comment(text, start, end) {
+            // adding anything as a sibling to the root node is forbidden
+            // comments should still be allowed, but ignored
+            if (currentParent) {
+                const child = {
+                    type: 3,
+                    text,
+                    isComment: true,
+                };
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    child.start = start;
+                    child.end = end;
+                }
+                currentParent.children.push(child);
+            }
+        },
+    });
+    return root;
+}
+function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+        el.pre = true;
+    }
+}
+function processRawAttrs(el) {
+    const list = el.attrsList;
+    const len = list.length;
+    if (len) {
+        const attrs = (el.attrs = new Array(len));
+        for (let i = 0; i < len; i++) {
+            attrs[i] = {
+                name: list[i].name,
+                value: JSON.stringify(list[i].value),
+            };
+            if (list[i].start != null) {
+                attrs[i].start = list[i].start;
+                attrs[i].end = list[i].end;
+            }
+        }
+    }
+    else if (!el.pre) {
+        // non root node in pre blocks with no attributes
+        el.plain = true;
+    }
+}
+function processElement(element, options) {
+    processKey(element);
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+        !element.key && !element.scopedSlots && !element.attrsList.length;
+    processRef(element);
+    processSlotContent(element);
+    processSlotOutlet(element);
+    processComponent(element);
+    for (let i = 0; i < transforms.length; i++) {
+        element = transforms[i](element, options) || element;
+    }
+    processAttrs(element);
+    return element;
+}
+function processKey(el) {
+    const exp = getBindingAttr(el, 'key');
+    if (exp) {
+        if (process.env.NODE_ENV !== 'production') {
+            if (el.tag === 'template') {
+                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
+            }
+            if (el.for) {
+                const iterator = el.iterator2 || el.iterator1;
+                const parent = el.parent;
+                if (iterator &&
+                    iterator === exp &&
+                    parent &&
+                    parent.tag === 'transition-group') {
+                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
+                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
+                }
+            }
+        }
+        el.key = exp;
+    }
+}
+function processRef(el) {
+    const ref = getBindingAttr(el, 'ref');
+    if (ref) {
+        el.ref = ref;
+        el.refInFor = checkInFor(el);
+    }
+}
+function processFor(el) {
+    let exp;
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+        const res = parseFor(exp);
+        if (res) {
+            extend(el, res);
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
+        }
+    }
+}
+function parseFor(exp) {
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+        return;
+    const res = {};
+    res.for = inMatch[2].trim();
+    const alias = inMatch[1].trim().replace(stripParensRE, '');
+    const iteratorMatch = alias.match(forIteratorRE);
+    if (iteratorMatch) {
+        res.alias = alias.replace(forIteratorRE, '').trim();
+        res.iterator1 = iteratorMatch[1].trim();
+        if (iteratorMatch[2]) {
+            res.iterator2 = iteratorMatch[2].trim();
+        }
+    }
+    else {
+        res.alias = alias;
+    }
+    return res;
+}
+function processIf(el) {
+    const exp = getAndRemoveAttr(el, 'v-if');
+    if (exp) {
+        el.if = exp;
+        addIfCondition(el, {
+            exp: exp,
+            block: el,
+        });
+    }
+    else {
+        if (getAndRemoveAttr(el, 'v-else') != null) {
+            el.else = true;
+        }
+        const elseif = getAndRemoveAttr(el, 'v-else-if');
+        if (elseif) {
+            el.elseif = elseif;
+        }
+    }
+}
+function processIfConditions(el, parent) {
+    const prev = findPrevElement(parent.children);
+    if (prev && prev.if) {
+        addIfCondition(prev, {
+            exp: el.elseif,
+            block: el,
+        });
+    }
+    else if (process.env.NODE_ENV !== 'production') {
+        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
+            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
+    }
+}
+function findPrevElement(children) {
+    let i = children.length;
+    while (i--) {
+        if (children[i].type === 1) {
+            return children[i];
+        }
+        else {
+            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
+                    `will be ignored.`, children[i]);
+            }
+            children.pop();
+        }
+    }
+}
+function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+        el.ifConditions = [];
+    }
+    el.ifConditions.push(condition);
+}
+function processOnce(el) {
+    const once = getAndRemoveAttr(el, 'v-once');
+    if (once != null) {
+        el.once = true;
+    }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+    let slotScope;
+    if (el.tag === 'template') {
+        slotScope = getAndRemoveAttr(el, 'scope');
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && slotScope) {
+            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
+                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
+                `can also be used on plain elements in addition to <template> to ` +
+                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
+        }
+        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
+    }
+    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
+                `(v-for takes higher priority). Use a wrapper <template> for the ` +
+                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
+        }
+        el.slotScope = slotScope;
+    }
+    // slot="xxx"
+    const slotTarget = getBindingAttr(el, 'slot');
+    if (slotTarget) {
+        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
+        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
+        // preserve slot as an attribute for native shadow DOM compat
+        // only for non-scoped slots.
+        if (el.tag !== 'template' && !el.slotScope) {
+            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
+        }
+    }
+    // 2.6 v-slot syntax
+    {
+        if (el.tag === 'template') {
+            // v-slot on <template>
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (el.slotTarget || el.slotScope) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.parent && !maybeComponent(el.parent)) {
+                        warn$1(`<template v-slot> can only appear at the root level inside ` +
+                            `the receiving component`, el);
+                    }
+                }
+                const { name, dynamic } = getSlotName(slotBinding);
+                el.slotTarget = name;
+                el.slotTargetDynamic = dynamic;
+                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
+            }
+        }
+        else {
+            // v-slot on component, denotes default slot
+            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
+            if (slotBinding) {
+                if (process.env.NODE_ENV !== 'production') {
+                    if (!maybeComponent(el)) {
+                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
+                    }
+                    if (el.slotScope || el.slotTarget) {
+                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
+                    }
+                    if (el.scopedSlots) {
+                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
+                            `<template> syntax when there are other named slots.`, slotBinding);
+                    }
+                }
+                // add the component's children to its default slot
+                const slots = el.scopedSlots || (el.scopedSlots = {});
+                const { name, dynamic } = getSlotName(slotBinding);
+                const slotContainer = (slots[name] = createASTElement('template', [], el));
+                slotContainer.slotTarget = name;
+                slotContainer.slotTargetDynamic = dynamic;
+                slotContainer.children = el.children.filter((c) => {
+                    if (!c.slotScope) {
+                        c.parent = slotContainer;
+                        return true;
+                    }
+                });
+                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
+                // remove children as they are returned from scopedSlots now
+                el.children = [];
+                // mark el non-plain so data gets generated
+                el.plain = false;
+            }
+        }
+    }
+}
+function getSlotName(binding) {
+    let name = binding.name.replace(slotRE, '');
+    if (!name) {
+        if (binding.name[0] !== '#') {
+            name = 'default';
+        }
+        else if (process.env.NODE_ENV !== 'production') {
+            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
+        }
+    }
+    return dynamicArgRE.test(name)
+        ? // dynamic [name]
+            { name: name.slice(1, -1), dynamic: true }
+        : // static name
+            { name: `"${name}"`, dynamic: false };
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+        el.slotName = getBindingAttr(el, 'name');
+        if (process.env.NODE_ENV !== 'production' && el.key) {
+            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
+                `and can possibly expand into multiple elements. ` +
+                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
+        }
+    }
+}
+function processComponent(el) {
+    let binding;
+    if ((binding = getBindingAttr(el, 'is'))) {
+        el.component = binding;
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+        el.inlineTemplate = true;
+    }
+}
+function processAttrs(el) {
+    const list = el.attrsList;
+    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
+    for (i = 0, l = list.length; i < l; i++) {
+        name = rawName = list[i].name;
+        value = list[i].value;
+        if (dirRE.test(name)) {
+            // mark element as dynamic
+            el.hasBindings = true;
+            // modifiers
+            modifiers = parseModifiers(name.replace(dirRE, ''));
+            // support .foo shorthand syntax for the .prop modifier
+            if (modifiers) {
+                name = name.replace(modifierRE, '');
+            }
+            if (bindRE.test(name)) {
+                // v-bind
+                name = name.replace(bindRE, '');
+                value = parseFilters(value);
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                if (process.env.NODE_ENV !== 'production' &&
+                    value.trim().length === 0) {
+                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
+                }
+                if (modifiers) {
+                    if (modifiers.prop && !isDynamic) {
+                        name = camelize(name);
+                        if (name === 'innerHtml')
+                            name = 'innerHTML';
+                    }
+                    if (modifiers.camel && !isDynamic) {
+                        name = camelize(name);
+                    }
+                    if (modifiers.sync) {
+                        syncGen = genAssignmentCode(value, `$event`);
+                        if (!isDynamic) {
+                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
+                            if (hyphenate(name) !== camelize(name)) {
+                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
+                            }
+                        }
+                        else {
+                            // handler w/ dynamic event name
+                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
+                            );
+                        }
+                    }
+                }
+                if ((modifiers && modifiers.prop) ||
+                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
+                    addProp(el, name, value, list[i], isDynamic);
+                }
+                else {
+                    addAttr(el, name, value, list[i], isDynamic);
+                }
+            }
+            else if (onRE.test(name)) {
+                // v-on
+                name = name.replace(onRE, '');
+                isDynamic = dynamicArgRE.test(name);
+                if (isDynamic) {
+                    name = name.slice(1, -1);
+                }
+                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
+            }
+            else {
+                // normal directives
+                name = name.replace(dirRE, '');
+                // parse arg
+                const argMatch = name.match(argRE);
+                let arg = argMatch && argMatch[1];
+                isDynamic = false;
+                if (arg) {
+                    name = name.slice(0, -(arg.length + 1));
+                    if (dynamicArgRE.test(arg)) {
+                        arg = arg.slice(1, -1);
+                        isDynamic = true;
+                    }
+                }
+                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
+                if (process.env.NODE_ENV !== 'production' && name === 'model') {
+                    checkForAliasModel(el, value);
+                }
+            }
+        }
+        else {
+            // literal attribute
+            if (process.env.NODE_ENV !== 'production') {
+                const res = parseText(value, delimiters);
+                if (res) {
+                    warn$1(`${name}="${value}": ` +
+                        'Interpolation inside attributes has been removed. ' +
+                        'Use v-bind or the colon shorthand instead. For example, ' +
+                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
+                }
+            }
+            addAttr(el, name, JSON.stringify(value), list[i]);
+            // #6887 firefox doesn't update muted state if set via attribute
+            // even immediately after element creation
+            if (!el.component &&
+                name === 'muted' &&
+                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
+                addProp(el, name, 'true', list[i]);
+            }
+        }
+    }
+}
+function checkInFor(el) {
+    let parent = el;
+    while (parent) {
+        if (parent.for !== undefined) {
+            return true;
+        }
+        parent = parent.parent;
+    }
+    return false;
+}
+function parseModifiers(name) {
+    const match = name.match(modifierRE);
+    if (match) {
+        const ret = {};
+        match.forEach((m) => {
+            ret[m.slice(1)] = true;
+        });
+        return ret;
+    }
+}
+function makeAttrsMap(attrs) {
+    const map = {};
+    for (let i = 0, l = attrs.length; i < l; i++) {
+        if (process.env.NODE_ENV !== 'production' &&
+            map[attrs[i].name] &&
+            !isIE &&
+            !isEdge) {
+            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
+        }
+        map[attrs[i].name] = attrs[i].value;
+    }
+    return map;
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style';
+}
+function isForbiddenTag(el) {
+    return (el.tag === 'style' ||
+        (el.tag === 'script' &&
+            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
+}
+const ieNSBug = /^xmlns:NS\d+/;
+const ieNSPrefix = /^NS\d+:/;
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+    const res = [];
+    for (let i = 0; i < attrs.length; i++) {
+        const attr = attrs[i];
+        if (!ieNSBug.test(attr.name)) {
+            attr.name = attr.name.replace(ieNSPrefix, '');
+            res.push(attr);
+        }
+    }
+    return res;
+}
+function checkForAliasModel(el, value) {
+    let _el = el;
+    while (_el) {
+        if (_el.for && _el.alias === value) {
+            warn$1(`<${el.tag} v-model="${value}">: ` +
+                `You are binding v-model directly to a v-for iteration alias. ` +
+                `This will not be able to modify the v-for source array because ` +
+                `writing to the alias is like modifying a function local variable. ` +
+                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
+        }
+        _el = _el.parent;
+    }
 }
 
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model$1 = {
-    preTransformNode,
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+        const map = el.attrsMap;
+        if (!map['v-model']) {
+            return;
+        }
+        let typeBinding;
+        if (map[':type'] || map['v-bind:type']) {
+            typeBinding = getBindingAttr(el, 'type');
+        }
+        if (!map.type && !typeBinding && map['v-bind']) {
+            typeBinding = `(${map['v-bind']}).type`;
+        }
+        if (typeBinding) {
+            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
+            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
+            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
+            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
+            // 1. checkbox
+            const branch0 = cloneASTElement(el);
+            // process for on the main node
+            processFor(branch0);
+            addRawAttr(branch0, 'type', 'checkbox');
+            processElement(branch0, options);
+            branch0.processed = true; // prevent it from double-processed
+            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
+            addIfCondition(branch0, {
+                exp: branch0.if,
+                block: branch0,
+            });
+            // 2. add radio else-if condition
+            const branch1 = cloneASTElement(el);
+            getAndRemoveAttr(branch1, 'v-for', true);
+            addRawAttr(branch1, 'type', 'radio');
+            processElement(branch1, options);
+            addIfCondition(branch0, {
+                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
+                block: branch1,
+            });
+            // 3. other
+            const branch2 = cloneASTElement(el);
+            getAndRemoveAttr(branch2, 'v-for', true);
+            addRawAttr(branch2, ':type', typeBinding);
+            processElement(branch2, options);
+            addIfCondition(branch0, {
+                exp: ifCondition,
+                block: branch2,
+            });
+            if (hasElse) {
+                branch0.else = true;
+            }
+            else if (elseIfCondition) {
+                branch0.elseif = elseIfCondition;
+            }
+            return branch0;
+        }
+    }
+}
+function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
+}
+var model$1 = {
+    preTransformNode,
 };
 
 var modules = [klass, style, model$1];
 
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
+let warn;
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+const RANGE_TOKEN = '__r';
+function model(el, dir, _warn) {
+    warn = _warn;
+    const value = dir.value;
+    const modifiers = dir.modifiers;
+    const tag = el.tag;
+    const type = el.attrsMap.type;
+    if (process.env.NODE_ENV !== 'production') {
+        // inputs with type="file" are read only and setting the input's
+        // value will throw an error.
+        if (tag === 'input' && type === 'file') {
+            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
+                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
+        }
+    }
+    if (el.component) {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    else if (tag === 'select') {
+        genSelect(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'checkbox') {
+        genCheckboxModel(el, value, modifiers);
+    }
+    else if (tag === 'input' && type === 'radio') {
+        genRadioModel(el, value, modifiers);
+    }
+    else if (tag === 'input' || tag === 'textarea') {
+        genDefaultModel(el, value, modifiers);
+    }
+    else {
+        genComponentModel(el, value, modifiers);
+        // component v-model doesn't need extra runtime
+        return false;
+    }
+    // ensure runtime directive metadata
+    return true;
+}
+function genCheckboxModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const valueBinding = getBindingAttr(el, 'value') || 'null';
+    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
+    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
+    addProp(el, 'checked', `Array.isArray(${value})` +
+        `?_i(${value},${valueBinding})>-1` +
+        (trueValueBinding === 'true'
+            ? `:(${value})`
+            : `:_q(${value},${trueValueBinding})`));
+    addHandler(el, 'change', `var $$a=${value},` +
+        '$$el=$event.target,' +
+        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
+        'if(Array.isArray($$a)){' +
+        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
+        '$$i=_i($$a,$$v);' +
+        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
+        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
+        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
+}
+function genRadioModel(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    let valueBinding = getBindingAttr(el, 'value') || 'null';
+    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
+    addProp(el, 'checked', `_q(${value},${valueBinding})`);
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
+}
+function genSelect(el, value, modifiers) {
+    const number = modifiers && modifiers.number;
+    const selectedVal = `Array.prototype.filter` +
+        `.call($event.target.options,function(o){return o.selected})` +
+        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
+        `return ${number ? '_n(val)' : 'val'}})`;
+    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
+    let code = `var $$selectedVal = ${selectedVal};`;
+    code = `${code} ${genAssignmentCode(value, assignment)}`;
+    addHandler(el, 'change', code, null, true);
+}
+function genDefaultModel(el, value, modifiers) {
+    const type = el.attrsMap.type;
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    if (process.env.NODE_ENV !== 'production') {
+        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
+        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
+        if (value && !typeBinding) {
+            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
+            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
+                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
+        }
+    }
+    const { lazy, number, trim } = modifiers || {};
+    const needCompositionGuard = !lazy && type !== 'range';
+    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
+    let valueExpression = '$event.target.value';
+    if (trim) {
+        valueExpression = `$event.target.value.trim()`;
+    }
+    if (number) {
+        valueExpression = `_n(${valueExpression})`;
+    }
+    let code = genAssignmentCode(value, valueExpression);
+    if (needCompositionGuard) {
+        code = `if($event.target.composing)return;${code}`;
+    }
+    addProp(el, 'value', `(${value})`);
+    addHandler(el, event, code, null, true);
+    if (trim || number) {
+        addHandler(el, 'blur', '$forceUpdate()');
+    }
 }
 
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
+function text(el, dir) {
+    if (dir.value) {
+        addProp(el, 'textContent', `_s(${dir.value})`, dir);
+    }
 }
 
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
+function html(el, dir) {
+    if (dir.value) {
+        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
+    }
 }
 
-var directives = {
-    model,
-    text,
-    html,
+var directives = {
+    model,
+    text,
+    html,
 };
 
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
+const baseOptions = {
+    expectHTML: true,
+    modules,
+    directives,
+    isPreTag,
+    isUnaryTag,
+    mustUseProp,
+    canBeLeftOpenTag,
+    isReservedTag,
+    getTagNamespace,
+    staticKeys: genStaticKeys$1(modules),
 };
 
-let isStaticKey;
-let isPlatformReservedTag$1;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize$1(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag$1 = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag$1(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag$1(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
+let isStaticKey;
+let isPlatformReservedTag$1;
+const genStaticKeysCached = cached(genStaticKeys);
+/**
+ * Goal of the optimizer: walk the generated template AST tree
+ * and detect sub-trees that are purely static, i.e. parts of
+ * the DOM that never needs to change.
+ *
+ * Once we detect these sub-trees, we can:
+ *
+ * 1. Hoist them into constants, so that we no longer need to
+ *    create fresh nodes for them on each re-render;
+ * 2. Completely skip them in the patching process.
+ */
+function optimize$1(root, options) {
+    if (!root)
+        return;
+    isStaticKey = genStaticKeysCached(options.staticKeys || '');
+    isPlatformReservedTag$1 = options.isReservedTag || no;
+    // first pass: mark all non-static nodes.
+    markStatic(root);
+    // second pass: mark static roots.
+    markStaticRoots(root, false);
+}
+function genStaticKeys(keys) {
+    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : ''));
+}
+function markStatic(node) {
+    node.static = isStatic(node);
+    if (node.type === 1) {
+        // do not make component slot content static. this avoids
+        // 1. components not able to mutate slot nodes
+        // 2. static slot content fails for hot-reloading
+        if (!isPlatformReservedTag$1(node.tag) &&
+            node.tag !== 'slot' &&
+            node.attrsMap['inline-template'] == null) {
+            return;
+        }
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            markStatic(child);
+            if (!child.static) {
+                node.static = false;
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                markStatic(block);
+                if (!block.static) {
+                    node.static = false;
+                }
+            }
+        }
+    }
+}
+function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+        if (node.static || node.once) {
+            node.staticInFor = isInFor;
+        }
+        // For a node to qualify as a static root, it should have children that
+        // are not just static text. Otherwise the cost of hoisting out will
+        // outweigh the benefits and it's better off to just always render it fresh.
+        if (node.static &&
+            node.children.length &&
+            !(node.children.length === 1 && node.children[0].type === 3)) {
+            node.staticRoot = true;
+            return;
+        }
+        else {
+            node.staticRoot = false;
+        }
+        if (node.children) {
+            for (let i = 0, l = node.children.length; i < l; i++) {
+                markStaticRoots(node.children[i], isInFor || !!node.for);
+            }
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                markStaticRoots(node.ifConditions[i].block, isInFor);
+            }
+        }
+    }
+}
+function isStatic(node) {
+    if (node.type === 2) {
+        // expression
+        return false;
+    }
+    if (node.type === 3) {
+        // text
+        return true;
+    }
+    return !!(node.pre ||
+        (!node.hasBindings && // no dynamic bindings
+            !node.if &&
+            !node.for && // not v-if or v-for or v-else
+            !isBuiltInTag(node.tag) && // not a built-in
+            isPlatformReservedTag$1(node.tag) && // not a component
+            !isDirectChildOfTemplateFor(node) &&
+            Object.keys(node).every(isStaticKey)));
+}
+function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+        node = node.parent;
+        if (node.tag !== 'template') {
+            return false;
+        }
+        if (node.for) {
+            return true;
+        }
+    }
+    return false;
 }
 
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
+const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
+const fnInvokeRE = /\([^)]*?\);*$/;
+const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
+// KeyboardEvent.keyCode aliases
+const keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46],
+};
+// KeyboardEvent.key aliases
+const keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del'],
+};
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+const genGuard = (condition) => `if(${condition})return null;`;
+const modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard(`$event.target !== $event.currentTarget`),
+    ctrl: genGuard(`!$event.ctrlKey`),
+    shift: genGuard(`!$event.shiftKey`),
+    alt: genGuard(`!$event.altKey`),
+    meta: genGuard(`!$event.metaKey`),
+    left: genGuard(`'button' in $event && $event.button !== 0`),
+    middle: genGuard(`'button' in $event && $event.button !== 1`),
+    right: genGuard(`'button' in $event && $event.button !== 2`),
+};
+function genHandlers(events, isNative) {
+    const prefix = isNative ? 'nativeOn:' : 'on:';
+    let staticHandlers = ``;
+    let dynamicHandlers = ``;
+    for (const name in events) {
+        const handlerCode = genHandler(events[name]);
+        //@ts-expect-error
+        if (events[name] && events[name].dynamic) {
+            dynamicHandlers += `${name},${handlerCode},`;
+        }
+        else {
+            staticHandlers += `"${name}":${handlerCode},`;
+        }
+    }
+    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
+    if (dynamicHandlers) {
+        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
+    }
+    else {
+        return prefix + staticHandlers;
+    }
+}
+function genHandler(handler) {
+    if (!handler) {
+        return 'function(){}';
+    }
+    if (Array.isArray(handler)) {
+        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
+    }
+    const isMethodPath = simplePathRE.test(handler.value);
+    const isFunctionExpression = fnExpRE.test(handler.value);
+    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
+    if (!handler.modifiers) {
+        if (isMethodPath || isFunctionExpression) {
+            return handler.value;
+        }
+        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
+    }
+    else {
+        let code = '';
+        let genModifierCode = '';
+        const keys = [];
+        for (const key in handler.modifiers) {
+            if (modifierCode[key]) {
+                genModifierCode += modifierCode[key];
+                // left/right
+                if (keyCodes[key]) {
+                    keys.push(key);
+                }
+            }
+            else if (key === 'exact') {
+                const modifiers = handler.modifiers;
+                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
+                    .filter((keyModifier) => !modifiers[keyModifier])
+                    .map((keyModifier) => `$event.${keyModifier}Key`)
+                    .join('||'));
+            }
+            else {
+                keys.push(key);
+            }
+        }
+        if (keys.length) {
+            code += genKeyFilter(keys);
+        }
+        // Make sure modifiers like prevent and stop get executed after key filtering
+        if (genModifierCode) {
+            code += genModifierCode;
+        }
+        const handlerCode = isMethodPath
+            ? `return ${handler.value}.apply(null, arguments)`
+            : isFunctionExpression
+                ? `return (${handler.value}).apply(null, arguments)`
+                : isFunctionInvocation
+                    ? `return ${handler.value}`
+                    : handler.value;
+        return `function($event){${code}${handlerCode}}`;
+    }
+}
+function genKeyFilter(keys) {
+    return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    `if(!$event.type.indexOf('key')&&` +
+        `${keys.map(genFilterCode).join('&&')})return null;`);
+}
+function genFilterCode(key) {
+    const keyVal = parseInt(key, 10);
+    if (keyVal) {
+        return `$event.keyCode!==${keyVal}`;
+    }
+    const keyCode = keyCodes[key];
+    const keyName = keyNames[key];
+    return (`_k($event.keyCode,` +
+        `${JSON.stringify(key)},` +
+        `${JSON.stringify(keyCode)},` +
+        `$event.key,` +
+        `${JSON.stringify(keyName)}` +
+        `)`);
 }
 
-function on(el, dir) {
-    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
+function on(el, dir) {
+    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+        warn$2(`v-on without argument does not support modifiers.`);
+    }
+    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
 }
 
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
+function bind(el, dir) {
+    el.wrapData = (code) => {
+        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
+    };
 }
 
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
+var baseDirectives = {
+    on,
+    bind,
+    cloak: noop,
 };
 
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate$1(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            process.env.NODE_ENV !== 'production' &&
-                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (process.env.NODE_ENV !== 'production' &&
-        state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if (process.env.NODE_ENV !== 'production' &&
-        (el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate$1(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class CodegenState {
+    options;
+    warn;
+    transforms;
+    dataGenFns;
+    directives;
+    maybeComponent;
+    onceId;
+    staticRenderFns;
+    pre;
+    constructor(options) {
+        this.options = options;
+        this.warn = options.warn || baseWarn;
+        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
+        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
+        this.directives = extend(extend({}, baseDirectives), options.directives);
+        const isReservedTag = options.isReservedTag || no;
+        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
+        this.onceId = 0;
+        this.staticRenderFns = [];
+        this.pre = false;
+    }
+}
+function generate$1(ast, options) {
+    const state = new CodegenState(options);
+    // fix #11483, Root level <script> tags should not be rendered.
+    const code = ast
+        ? ast.tag === 'script'
+            ? 'null'
+            : genElement(ast, state)
+        : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genElement(el, state) {
+    if (el.parent) {
+        el.pre = el.pre || el.parent.pre;
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+        return genStatic(el, state);
+    }
+    else if (el.once && !el.onceProcessed) {
+        return genOnce(el, state);
+    }
+    else if (el.for && !el.forProcessed) {
+        return genFor(el, state);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+        return genChildren(el, state) || 'void 0';
+    }
+    else if (el.tag === 'slot') {
+        return genSlot(el, state);
+    }
+    else {
+        // component or element
+        let code;
+        if (el.component) {
+            code = genComponent(el.component, el, state);
+        }
+        else {
+            let data;
+            if (!el.plain || (el.pre && state.maybeComponent(el))) {
+                data = genData(el, state);
+            }
+            const children = el.inlineTemplate ? null : genChildren(el, state, true);
+            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
+            }${children ? `,${children}` : '' // children
+            })`;
+        }
+        // module transforms
+        for (let i = 0; i < state.transforms.length; i++) {
+            code = state.transforms[i](el, code);
+        }
+        return code;
+    }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+    el.staticProcessed = true;
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    const originalPreState = state.pre;
+    if (el.pre) {
+        state.pre = el.pre;
+    }
+    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
+    state.pre = originalPreState;
+    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
+}
+// v-once
+function genOnce(el, state) {
+    el.onceProcessed = true;
+    if (el.if && !el.ifProcessed) {
+        return genIf(el, state);
+    }
+    else if (el.staticInFor) {
+        let key = '';
+        let parent = el.parent;
+        while (parent) {
+            if (parent.for) {
+                key = parent.key;
+                break;
+            }
+            parent = parent.parent;
+        }
+        if (!key) {
+            process.env.NODE_ENV !== 'production' &&
+                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
+            return genElement(el, state);
+        }
+        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
+    }
+    else {
+        return genStatic(el, state);
+    }
+}
+function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true; // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+        return altEmpty || '_e()';
+    }
+    const condition = conditions.shift();
+    if (condition.exp) {
+        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
+    }
+    else {
+        return `${genTernaryExp(condition.block)}`;
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+        return altGen
+            ? altGen(el, state)
+            : el.once
+                ? genOnce(el, state)
+                : genElement(el, state);
+    }
+}
+function genFor(el, state, altGen, altHelper) {
+    const exp = el.for;
+    const alias = el.alias;
+    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
+    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
+    if (process.env.NODE_ENV !== 'production' &&
+        state.maybeComponent(el) &&
+        el.tag !== 'slot' &&
+        el.tag !== 'template' &&
+        !el.key) {
+        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
+            `v-for should have explicit keys. ` +
+            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
+    }
+    el.forProcessed = true; // avoid recursion
+    return (`${altHelper || '_l'}((${exp}),` +
+        `function(${alias}${iterator1}${iterator2}){` +
+        `return ${(altGen || genElement)(el, state)}` +
+        '})');
+}
+function genData(el, state) {
+    let data = '{';
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    const dirs = genDirectives(el, state);
+    if (dirs)
+        data += dirs + ',';
+    // key
+    if (el.key) {
+        data += `key:${el.key},`;
+    }
+    // ref
+    if (el.ref) {
+        data += `ref:${el.ref},`;
+    }
+    if (el.refInFor) {
+        data += `refInFor:true,`;
+    }
+    // pre
+    if (el.pre) {
+        data += `pre:true,`;
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+        data += `tag:"${el.tag}",`;
+    }
+    // module data generation functions
+    for (let i = 0; i < state.dataGenFns.length; i++) {
+        data += state.dataGenFns[i](el);
+    }
+    // attributes
+    if (el.attrs) {
+        data += `attrs:${genProps(el.attrs)},`;
+    }
+    // DOM props
+    if (el.props) {
+        data += `domProps:${genProps(el.props)},`;
+    }
+    // event handlers
+    if (el.events) {
+        data += `${genHandlers(el.events, false)},`;
+    }
+    if (el.nativeEvents) {
+        data += `${genHandlers(el.nativeEvents, true)},`;
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+        data += `slot:${el.slotTarget},`;
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
+    }
+    // component v-model
+    if (el.model) {
+        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+        const inlineTemplate = genInlineTemplate(el, state);
+        if (inlineTemplate) {
+            data += `${inlineTemplate},`;
+        }
+    }
+    data = data.replace(/,$/, '') + '}';
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+        data = el.wrapData(data);
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+        data = el.wrapListeners(data);
+    }
+    return data;
+}
+function genDirectives(el, state) {
+    const dirs = el.directives;
+    if (!dirs)
+        return;
+    let res = 'directives:[';
+    let hasRuntime = false;
+    let i, l, dir, needRuntime;
+    for (i = 0, l = dirs.length; i < l; i++) {
+        dir = dirs[i];
+        needRuntime = true;
+        const gen = state.directives[dir.name];
+        if (gen) {
+            // compile-time directive that manipulates AST.
+            // returns true if it also needs a runtime counterpart.
+            needRuntime = !!gen(el, dir, state.warn);
+        }
+        if (needRuntime) {
+            hasRuntime = true;
+            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
+                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
+                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
+        }
+    }
+    if (hasRuntime) {
+        return res.slice(0, -1) + ']';
+    }
+}
+function genInlineTemplate(el, state) {
+    const ast = el.children[0];
+    if (process.env.NODE_ENV !== 'production' &&
+        (el.children.length !== 1 || ast.type !== 1)) {
+        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
+    }
+    if (ast && ast.type === 1) {
+        const inlineRenderFns = generate$1(ast, state.options);
+        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
+            .map((code) => `function(){${code}}`)
+            .join(',')}]}`;
+    }
+}
+function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    let needsForceUpdate = el.for ||
+        Object.keys(slots).some((key) => {
+            const slot = slots[key];
+            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+            );
+        });
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    let needsKey = !!el.if;
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+        let parent = el.parent;
+        while (parent) {
+            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
+                parent.for) {
+                needsForceUpdate = true;
+                break;
+            }
+            if (parent.if) {
+                needsKey = true;
+            }
+            parent = parent.parent;
+        }
+    }
+    const generatedSlots = Object.keys(slots)
+        .map((key) => genScopedSlot(slots[key], state))
+        .join(',');
+    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
+}
+function hash(str) {
+    let hash = 5381;
+    let i = str.length;
+    while (i) {
+        hash = (hash * 33) ^ str.charCodeAt(--i);
+    }
+    return hash >>> 0;
+}
+function containsSlotChild(el) {
+    if (el.type === 1) {
+        if (el.tag === 'slot') {
+            return true;
+        }
+        return el.children.some(containsSlotChild);
+    }
+    return false;
+}
+function genScopedSlot(el, state) {
+    const isLegacySyntax = el.attrsMap['slot-scope'];
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+        return genIf(el, state, genScopedSlot, `null`);
+    }
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genScopedSlot);
+    }
+    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
+    const fn = `function(${slotScope}){` +
+        `return ${el.tag === 'template'
+            ? el.if && isLegacySyntax
+                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
+                : genChildren(el, state) || 'undefined'
+            : genElement(el, state)}}`;
+    // reverse proxy v-slot without scope on this.$slots
+    const reverseProxy = slotScope ? `` : `,proxy:true`;
+    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    const children = el.children;
+    if (children.length) {
+        const el = children[0];
+        // optimize single v-for
+        if (children.length === 1 &&
+            el.for &&
+            el.tag !== 'template' &&
+            el.tag !== 'slot') {
+            const normalizationType = checkSkip
+                ? state.maybeComponent(el)
+                    ? `,1`
+                    : `,0`
+                : ``;
+            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
+        }
+        const normalizationType = checkSkip
+            ? getNormalizationType(children, state.maybeComponent)
+            : 0;
+        const gen = altGenNode || genNode;
+        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
+    }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+    let res = 0;
+    for (let i = 0; i < children.length; i++) {
+        const el = children[i];
+        if (el.type !== 1) {
+            continue;
+        }
+        if (needsNormalization(el) ||
+            (el.ifConditions &&
+                el.ifConditions.some((c) => needsNormalization(c.block)))) {
+            res = 2;
+            break;
+        }
+        if (maybeComponent(el) ||
+            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
+            res = 1;
+        }
+    }
+    return res;
+}
+function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
+}
+function genNode(node, state) {
+    if (node.type === 1) {
+        return genElement(node, state);
+    }
+    else if (node.type === 3 && node.isComment) {
+        return genComment(node);
+    }
+    else {
+        return genText(node);
+    }
+}
+function genText(text) {
+    return `_v(${text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text))})`;
+}
+function genComment(comment) {
+    return `_e(${JSON.stringify(comment.text)})`;
+}
+function genSlot(el, state) {
+    const slotName = el.slotName || '"default"';
+    const children = genChildren(el, state);
+    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
+    const attrs = el.attrs || el.dynamicAttrs
+        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+        })))
+        : null;
+    const bind = el.attrsMap['v-bind'];
+    if ((attrs || bind) && !children) {
+        res += `,null`;
+    }
+    if (attrs) {
+        res += `,${attrs}`;
+    }
+    if (bind) {
+        res += `${attrs ? '' : ',null'},${bind}`;
+    }
+    return res + ')';
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+    const children = el.inlineTemplate ? null : genChildren(el, state, true);
+    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
+}
+function genProps(props) {
+    let staticProps = ``;
+    let dynamicProps = ``;
+    for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        const value = transformSpecialNewlines(prop.value);
+        if (prop.dynamic) {
+            dynamicProps += `${prop.name},${value},`;
+        }
+        else {
+            staticProps += `"${prop.name}":${value},`;
+        }
+    }
+    staticProps = `{${staticProps.slice(0, -1)}}`;
+    if (dynamicProps) {
+        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
+    }
+    else {
+        return staticProps;
+    }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
 }
 
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+const prohibitedKeywordRE = new RegExp('\\b' +
+    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments')
+        .split(',')
+        .join('\\b|\\b') +
+    '\\b');
+// these unary operators should not be used as property/method names
+const unaryOperatorsRE = new RegExp('\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)');
+// strip strings in expressions
+const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+    if (ast) {
+        checkNode(ast, warn);
+    }
+}
+function checkNode(node, warn) {
+    if (node.type === 1) {
+        for (const name in node.attrsMap) {
+            if (dirRE.test(name)) {
+                const value = node.attrsMap[name];
+                if (value) {
+                    const range = node.rawAttrsMap[name];
+                    if (name === 'v-for') {
+                        checkFor(node, `v-for="${value}"`, warn, range);
+                    }
+                    else if (name === 'v-slot' || name[0] === '#') {
+                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                    else if (onRE.test(name)) {
+                        checkEvent(value, `${name}="${value}"`, warn, range);
+                    }
+                    else {
+                        checkExpression(value, `${name}="${value}"`, warn, range);
+                    }
+                }
+            }
+        }
+        if (node.children) {
+            for (let i = 0; i < node.children.length; i++) {
+                checkNode(node.children[i], warn);
+            }
+        }
+    }
+    else if (node.type === 2) {
+        checkExpression(node.expression, node.text, warn, node);
+    }
+}
+function checkEvent(exp, text, warn, range) {
+    const stripped = exp.replace(stripStringRE, '');
+    const keywordMatch = stripped.match(unaryOperatorsRE);
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+        warn(`avoid using JavaScript unary operator as property name: ` +
+            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
+    }
+    checkExpression(exp, text, warn, range);
+}
+function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range);
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
+}
+function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+        try {
+            new Function(`var ${ident}=_`);
+        }
+        catch (e) {
+            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
+        }
+    }
+}
+function checkExpression(exp, text, warn, range) {
+    try {
+        new Function(`return ${exp}`);
+    }
+    catch (e) {
+        const keywordMatch = exp
+            .replace(stripStringRE, '')
+            .match(prohibitedKeywordRE);
+        if (keywordMatch) {
+            warn(`avoid using JavaScript keyword as property name: ` +
+                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
+        }
+        else {
+            warn(`invalid expression: ${e.message} in\n\n` +
+                `    ${exp}\n\n` +
+                `  Raw expression: ${text.trim()}\n`, range);
+        }
+    }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+        new Function(exp, '');
+    }
+    catch (e) {
+        warn(`invalid function parameter expression: ${e.message} in\n\n` +
+            `    ${exp}\n\n` +
+            `  Raw expression: ${text.trim()}\n`, range);
+    }
 }
 
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
+const range = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = end > count ? lineLength - pad : end - start;
+                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.min(end - count, lineLength);
+                        res.push(`   |  ` + repeat(`^`, length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+function repeat(str, n) {
+    let result = '';
+    if (n > 0) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // eslint-disable-line
+            if (n & 1)
+                result += str;
+            n >>>= 1;
+            if (n <= 0)
+                break;
+            str += str;
+        }
+    }
+    return result;
 }
 
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        if (process.env.NODE_ENV !== 'production') {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
+function createFunction(code, errors) {
+    try {
+        return new Function(code);
+    }
+    catch (err) {
+        errors.push({ err, code });
+        return noop;
+    }
+}
+function createCompileToFunctionFn(compile) {
+    const cache = Object.create(null);
+    return function compileToFunctions(template, options, vm) {
+        options = extend({}, options);
+        const warn = options.warn || warn$2;
+        delete options.warn;
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            // detect possible CSP restriction
+            try {
+                new Function('return 1');
+            }
+            catch (e) {
+                if (e.toString().match(/unsafe-eval|CSP/)) {
+                    warn('It seems you are using the standalone build of Vue.js in an ' +
+                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                        'The template compiler cannot work in this environment. Consider ' +
+                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                        'templates into render functions.');
+                }
+            }
+        }
+        // check cache
+        const key = options.delimiters
+            ? String(options.delimiters) + template
+            : template;
+        if (cache[key]) {
+            return cache[key];
+        }
+        // compile
+        const compiled = compile(template, options);
+        // check compilation errors/tips
+        if (process.env.NODE_ENV !== 'production') {
+            if (compiled.errors && compiled.errors.length) {
+                if (options.outputSourceRange) {
+                    compiled.errors.forEach((e) => {
+                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
+                            generateCodeFrame(template, e.start, e.end), vm);
+                    });
+                }
+                else {
+                    warn(`Error compiling template:\n\n${template}\n\n` +
+                        compiled.errors.map((e) => `- ${e}`).join('\n') +
+                        '\n', vm);
+                }
+            }
+            if (compiled.tips && compiled.tips.length) {
+                if (options.outputSourceRange) {
+                    compiled.tips.forEach((e) => tip(e.msg, vm));
+                }
+                else {
+                    compiled.tips.forEach((msg) => tip(msg, vm));
+                }
+            }
+        }
+        // turn code into functions
+        const res = {};
+        const fnGenErrors = [];
+        res.render = createFunction(compiled.render, fnGenErrors);
+        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+            return createFunction(code, fnGenErrors);
+        });
+        // check function generation errors.
+        // this should only happen if there is a bug in the compiler itself.
+        // mostly for codegen development use
+        /* istanbul ignore if */
+        if (process.env.NODE_ENV !== 'production') {
+            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+                warn(`Failed to generate render function:\n\n` +
+                    fnGenErrors
+                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
+                        .join('\n'), vm);
+            }
+        }
+        return (cache[key] = res);
+    };
 }
 
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = typeof (msg) === 'string' ? { msg } : msg;
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            if (process.env.NODE_ENV !== 'production') {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
+function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+        function compile(template, options) {
+            const finalOptions = Object.create(baseOptions);
+            const errors = [];
+            const tips = [];
+            let warn = (msg, range, tip) => {
+                (tip ? tips : errors).push(msg);
+            };
+            if (options) {
+                if (process.env.NODE_ENV !== 'production' &&
+                    options.outputSourceRange) {
+                    // $flow-disable-line
+                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
+                    warn = (msg, range, tip) => {
+                        const data = { msg };
+                        if (range) {
+                            if (range.start != null) {
+                                data.start = range.start + leadingSpaceLength;
+                            }
+                            if (range.end != null) {
+                                data.end = range.end + leadingSpaceLength;
+                            }
+                        }
+                        (tip ? tips : errors).push(data);
+                    };
+                }
+                // merge custom modules
+                if (options.modules) {
+                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
+                }
+                // merge custom directives
+                if (options.directives) {
+                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
+                }
+                // copy other options
+                for (const key in options) {
+                    if (key !== 'modules' && key !== 'directives') {
+                        finalOptions[key] = options[key];
+                    }
+                }
+            }
+            finalOptions.warn = warn;
+            const compiled = baseCompile(template.trim(), finalOptions);
+            if (process.env.NODE_ENV !== 'production') {
+                detectErrors(compiled.ast, warn);
+            }
+            compiled.errors = errors;
+            compiled.tips = tips;
+            return compiled;
+        }
+        return {
+            compile,
+            compileToFunctions: createCompileToFunctionFn(compile),
+        };
+    };
 }
 
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize$1(ast, options);
-    }
-    const code = generate$1(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    if (options.optimize !== false) {
+        optimize$1(ast, options);
+    }
+    const code = generate$1(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
 
-const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap');
-/* istanbul ignore next */
-const isRenderableAttr = (name) => {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-};
-const propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv',
-};
-const ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;',
-};
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
-}
-function escapeChar(a) {
-    return ESC[a] || a;
+const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap');
+/* istanbul ignore next */
+const isRenderableAttr = (name) => {
+    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
+};
+const propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv',
+};
+const ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;',
+};
+function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar);
+}
+function escapeChar(a) {
+    return ESC[a] || a;
 }
 
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-    if (el.directives) {
-        for (let i = 0; i < el.directives.length; i++) {
-            const dir = el.directives[i];
-            if (dir.name === 'model') {
-                state.directives.model(el, dir, state.warn);
-                // remove value for textarea as its converted to text
-                if (el.tag === 'textarea' && el.props) {
-                    el.props = el.props.filter((p) => p.name !== 'value');
-                }
-                break;
-            }
-        }
-    }
-}
-function genAttrSegments(attrs) {
-    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-}
-function genDOMPropSegments(props, attrs) {
-    const segments = [];
-    props.forEach(({ name, value }) => {
-        name = propsToAttrMap[name] || name.toLowerCase();
-        if (isRenderableAttr(name) &&
-            !(attrs && attrs.some((a) => a.name === name))) {
-            segments.push(genAttrSegment(name, value));
-        }
-    });
-    return segments;
-}
-function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-        // force double quote
-        value = value.replace(/^'|'$/g, '"');
-        // force enumerated attr to "true"
-        if (isEnumeratedAttr(name) && value !== `"false"`) {
-            value = `"true"`;
-        }
-        return {
-            type: RAW,
-            value: isBooleanAttr(name)
-                ? ` ${name}="${name}"`
-                : value === '""'
-                    ? ` ${name}`
-                    : ` ${name}="${JSON.parse(value)}"`,
-        };
-    }
-    else {
-        return {
-            type: EXPRESSION,
-            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-        };
-    }
-}
-function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-            },
-        ];
-    }
-}
-function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-            },
-        ];
-    }
+const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
+// let the model AST transform translate v-model into appropriate
+// props bindings
+function applyModelTransform(el, state) {
+    if (el.directives) {
+        for (let i = 0; i < el.directives.length; i++) {
+            const dir = el.directives[i];
+            if (dir.name === 'model') {
+                state.directives.model(el, dir, state.warn);
+                // remove value for textarea as its converted to text
+                if (el.tag === 'textarea' && el.props) {
+                    el.props = el.props.filter((p) => p.name !== 'value');
+                }
+                break;
+            }
+        }
+    }
+}
+function genAttrSegments(attrs) {
+    return attrs.map(({ name, value }) => genAttrSegment(name, value));
+}
+function genDOMPropSegments(props, attrs) {
+    const segments = [];
+    props.forEach(({ name, value }) => {
+        name = propsToAttrMap[name] || name.toLowerCase();
+        if (isRenderableAttr(name) &&
+            !(attrs && attrs.some((a) => a.name === name))) {
+            segments.push(genAttrSegment(name, value));
+        }
+    });
+    return segments;
+}
+function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+        // force double quote
+        value = value.replace(/^'|'$/g, '"');
+        // force enumerated attr to "true"
+        if (isEnumeratedAttr(name) && value !== `"false"`) {
+            value = `"true"`;
+        }
+        return {
+            type: RAW,
+            value: isBooleanAttr(name)
+                ? ` ${name}="${name}"`
+                : value === '""'
+                    ? ` ${name}`
+                    : ` ${name}="${JSON.parse(value)}"`,
+        };
+    }
+    else {
+        return {
+            type: EXPRESSION,
+            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+        };
+    }
+}
+function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
+            },
+        ];
+    }
+}
+function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
+    }
+    else {
+        return [
+            {
+                type: EXPRESSION,
+                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
+                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
+                    : 'null'})`,
+            },
+        ];
+    }
 }
 
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-const optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-};
-let isPlatformReservedTag;
-function optimize(root, options) {
-    if (!root)
-        return;
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-}
-function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-        node.ssrOptimizability = optimizability.FALSE;
-        return;
-    }
-    // root node or nodes with custom directives should always be a VNode
-    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-    const check = (child) => {
-        if (child.ssrOptimizability !== optimizability.FULL) {
-            node.ssrOptimizability = selfUnoptimizable
-                ? optimizability.PARTIAL
-                : optimizability.SELF;
-        }
-    };
-    if (selfUnoptimizable) {
-        node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            walk(child);
-            check(child);
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                walk(block, isRoot);
-                check(block);
-            }
-        }
-        if (node.ssrOptimizability == null ||
-            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-            node.ssrOptimizability = optimizability.FULL;
-        }
-        else {
-            node.children = optimizeSiblings(node);
-        }
-    }
-    else {
-        node.ssrOptimizability = optimizability.FULL;
-    }
-}
-function optimizeSiblings(el) {
-    const children = el.children;
-    const optimizedChildren = [];
-    let currentOptimizableGroup = [];
-    const pushGroup = () => {
-        if (currentOptimizableGroup.length) {
-            optimizedChildren.push({
-                type: 1,
-                parent: el,
-                tag: 'template',
-                attrsList: [],
-                attrsMap: {},
-                rawAttrsMap: {},
-                children: currentOptimizableGroup,
-                ssrOptimizability: optimizability.FULL,
-            });
-        }
-        currentOptimizableGroup = [];
-    };
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.ssrOptimizability === optimizability.FULL) {
-            currentOptimizableGroup.push(c);
-        }
-        else {
-            // wrap fully-optimizable adjacent siblings inside a template tag
-            // so that they can be optimized into a single ssrNode by codegen
-            pushGroup();
-            optimizedChildren.push(c);
-        }
-    }
-    pushGroup();
-    return optimizedChildren;
-}
-function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-        // text or expression
-        return false;
-    }
-    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag(node.tag) || // custom component
-        !!node.component || // "is" component
-        isSelectWithModel(node) // <select v-model> requires runtime inspection
-    );
-}
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-function hasCustomDirective(node) {
-    return (node.type === 1 &&
-        node.directives &&
-        node.directives.some((d) => !isBuiltInDir(d.name)));
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-    return (node.type === 1 &&
-        node.tag === 'select' &&
-        node.directives != null &&
-        node.directives.some((d) => d.name === 'model'));
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
+// optimizability constants
+const optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4, // self un-optimizable with some un-optimizable children
+};
+let isPlatformReservedTag;
+function optimize(root, options) {
+    if (!root)
+        return;
+    isPlatformReservedTag = options.isReservedTag || no;
+    walk(root, true);
+}
+function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+        node.ssrOptimizability = optimizability.FALSE;
+        return;
+    }
+    // root node or nodes with custom directives should always be a VNode
+    const selfUnoptimizable = isRoot || hasCustomDirective(node);
+    const check = (child) => {
+        if (child.ssrOptimizability !== optimizability.FULL) {
+            node.ssrOptimizability = selfUnoptimizable
+                ? optimizability.PARTIAL
+                : optimizability.SELF;
+        }
+    };
+    if (selfUnoptimizable) {
+        node.ssrOptimizability = optimizability.CHILDREN;
+    }
+    if (node.type === 1) {
+        for (let i = 0, l = node.children.length; i < l; i++) {
+            const child = node.children[i];
+            walk(child);
+            check(child);
+        }
+        if (node.ifConditions) {
+            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+                const block = node.ifConditions[i].block;
+                walk(block, isRoot);
+                check(block);
+            }
+        }
+        if (node.ssrOptimizability == null ||
+            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
+            node.ssrOptimizability = optimizability.FULL;
+        }
+        else {
+            node.children = optimizeSiblings(node);
+        }
+    }
+    else {
+        node.ssrOptimizability = optimizability.FULL;
+    }
+}
+function optimizeSiblings(el) {
+    const children = el.children;
+    const optimizedChildren = [];
+    let currentOptimizableGroup = [];
+    const pushGroup = () => {
+        if (currentOptimizableGroup.length) {
+            optimizedChildren.push({
+                type: 1,
+                parent: el,
+                tag: 'template',
+                attrsList: [],
+                attrsMap: {},
+                rawAttrsMap: {},
+                children: currentOptimizableGroup,
+                ssrOptimizability: optimizability.FULL,
+            });
+        }
+        currentOptimizableGroup = [];
+    };
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.ssrOptimizability === optimizability.FULL) {
+            currentOptimizableGroup.push(c);
+        }
+        else {
+            // wrap fully-optimizable adjacent siblings inside a template tag
+            // so that they can be optimized into a single ssrNode by codegen
+            pushGroup();
+            optimizedChildren.push(c);
+        }
+    }
+    pushGroup();
+    return optimizedChildren;
+}
+function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+        // text or expression
+        return false;
+    }
+    return (isBuiltInTag(node.tag) || // built-in (slot, component)
+        !isPlatformReservedTag(node.tag) || // custom component
+        !!node.component || // "is" component
+        isSelectWithModel(node) // <select v-model> requires runtime inspection
+    );
+}
+const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
+function hasCustomDirective(node) {
+    return (node.type === 1 &&
+        node.directives &&
+        node.directives.some((d) => !isBuiltInDir(d.name)));
+}
+// <select v-model> cannot be optimized because it requires a runtime check
+// to determine proper selected option
+function isSelectWithModel(node) {
+    return (node.type === 1 &&
+        node.tag === 'select' &&
+        node.directives != null &&
+        node.directives.some((d) => d.name === 'model'));
 }
 
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-const RAW = 0;
-const INTERPOLATION = 1;
-const EXPRESSION = 2;
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genSSRElement);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state, genSSRElement);
-    }
-    else if (el.tag === 'template' && !el.slotTarget) {
-        return el.ssrOptimizability === optimizability.FULL
-            ? genChildrenAsStringNode(el, state)
-            : genSSRChildren(el, state) || 'void 0';
-    }
-    switch (el.ssrOptimizability) {
-        case optimizability.FULL:
-            // stringify whole tree
-            return genStringElement(el, state);
-        case optimizability.SELF:
-            // stringify self and check children
-            return genStringElementWithChildren(el, state);
-        case optimizability.CHILDREN:
-            // generate self as VNode and stringify children
-            return genNormalElement(el, state, true);
-        case optimizability.PARTIAL:
-            // generate self as VNode and check children
-            return genNormalElement(el, state, false);
-        default:
-            // bail whole tree
-            return genElement(el, state);
-    }
-}
-function genNormalElement(el, state, stringifyChildren) {
-    const data = el.plain ? undefined : genData(el, state);
-    const children = stringifyChildren
-        ? `[${genChildrenAsStringNode(el, state)}]`
-        : genSSRChildren(el, state, true);
-    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-}
-function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-}
-function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-}
-function genChildrenAsStringNode(el, state) {
-    return el.children.length
-        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-        : '';
-}
-function genStringElement(el, state) {
-    return `_ssrNode(${elementToString(el, state)})`;
-}
-function genStringElementWithChildren(el, state) {
-    const children = genSSRChildren(el, state, true);
-    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-}
-function elementToString(el, state) {
-    return `(${flattenSegments(elementToSegments(el, state))})`;
-}
-function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-        el.forProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genFor(el, state, elementToString, '_ssrList'),
-            },
-        ];
-    }
-    else if (el.if && !el.ifProcessed) {
-        el.ifProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genIf(el, state, elementToString, '"<!---->"'),
-            },
-        ];
-    }
-    else if (el.tag === 'template') {
-        return childrenToSegments(el, state);
-    }
-    const openSegments = elementToOpenTagSegments(el, state);
-    const childrenSegments = childrenToSegments(el, state);
-    const { isUnaryTag } = state.options;
-    const close = isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: `</${el.tag}>` }];
-    return openSegments.concat(childrenSegments, close);
-}
-function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state);
-    let binding;
-    const segments = [{ type: RAW, value: `<${el.tag}` }];
-    // attrs
-    if (el.attrs) {
-        segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-    }
-    segments.push({ type: RAW, value: `>` });
-    return segments;
-}
-function childrenToSegments(el, state) {
-    let binding;
-    if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    return el.children ? nodesToSegments(el.children, state) : [];
-}
-function nodesToSegments(children, state) {
-    const segments = [];
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.type === 1) {
-            segments.push.apply(segments, elementToSegments(c, state));
-        }
-        else if (c.type === 2) {
-            segments.push({ type: INTERPOLATION, value: c.expression });
-        }
-        else if (c.type === 3) {
-            let text = escape(c.text);
-            if (c.isComment) {
-                text = '<!--' + text + '-->';
-            }
-            segments.push({ type: RAW, value: text });
-        }
-    }
-    return segments;
-}
-function flattenSegments(segments) {
-    const mergedSegments = [];
-    let textBuffer = '';
-    const pushBuffer = () => {
-        if (textBuffer) {
-            mergedSegments.push(JSON.stringify(textBuffer));
-            textBuffer = '';
-        }
-    };
-    for (let i = 0; i < segments.length; i++) {
-        const s = segments[i];
-        if (s.type === RAW) {
-            textBuffer += s.value;
-        }
-        else if (s.type === INTERPOLATION) {
-            pushBuffer();
-            mergedSegments.push(`_ssrEscape(${s.value})`);
-        }
-        else if (s.type === EXPRESSION) {
-            pushBuffer();
-            mergedSegments.push(`(${s.value})`);
-        }
-    }
-    pushBuffer();
-    return mergedSegments.join('+');
+// The SSR codegen is essentially extending the default codegen to handle
+// segment types
+const RAW = 0;
+const INTERPOLATION = 1;
+const EXPRESSION = 2;
+function generate(ast, options) {
+    const state = new CodegenState(options);
+    const code = ast ? genSSRElement(ast, state) : '_c("div")';
+    return {
+        render: `with(this){return ${code}}`,
+        staticRenderFns: state.staticRenderFns,
+    };
+}
+function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+        return genFor(el, state, genSSRElement);
+    }
+    else if (el.if && !el.ifProcessed) {
+        return genIf(el, state, genSSRElement);
+    }
+    else if (el.tag === 'template' && !el.slotTarget) {
+        return el.ssrOptimizability === optimizability.FULL
+            ? genChildrenAsStringNode(el, state)
+            : genSSRChildren(el, state) || 'void 0';
+    }
+    switch (el.ssrOptimizability) {
+        case optimizability.FULL:
+            // stringify whole tree
+            return genStringElement(el, state);
+        case optimizability.SELF:
+            // stringify self and check children
+            return genStringElementWithChildren(el, state);
+        case optimizability.CHILDREN:
+            // generate self as VNode and stringify children
+            return genNormalElement(el, state, true);
+        case optimizability.PARTIAL:
+            // generate self as VNode and check children
+            return genNormalElement(el, state, false);
+        default:
+            // bail whole tree
+            return genElement(el, state);
+    }
+}
+function genNormalElement(el, state, stringifyChildren) {
+    const data = el.plain ? undefined : genData(el, state);
+    const children = stringifyChildren
+        ? `[${genChildrenAsStringNode(el, state)}]`
+        : genSSRChildren(el, state, true);
+    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
+}
+function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
+}
+function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el);
+}
+function genChildrenAsStringNode(el, state) {
+    return el.children.length
+        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
+        : '';
+}
+function genStringElement(el, state) {
+    return `_ssrNode(${elementToString(el, state)})`;
+}
+function genStringElementWithChildren(el, state) {
+    const children = genSSRChildren(el, state, true);
+    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
+}
+function elementToString(el, state) {
+    return `(${flattenSegments(elementToSegments(el, state))})`;
+}
+function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+        el.forProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genFor(el, state, elementToString, '_ssrList'),
+            },
+        ];
+    }
+    else if (el.if && !el.ifProcessed) {
+        el.ifProcessed = true;
+        return [
+            {
+                type: EXPRESSION,
+                value: genIf(el, state, elementToString, '"<!---->"'),
+            },
+        ];
+    }
+    else if (el.tag === 'template') {
+        return childrenToSegments(el, state);
+    }
+    const openSegments = elementToOpenTagSegments(el, state);
+    const childrenSegments = childrenToSegments(el, state);
+    const { isUnaryTag } = state.options;
+    const close = isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: `</${el.tag}>` }];
+    return openSegments.concat(childrenSegments, close);
+}
+function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state);
+    let binding;
+    const segments = [{ type: RAW, value: `<${el.tag}` }];
+    // attrs
+    if (el.attrs) {
+        segments.push.apply(segments, genAttrSegments(el.attrs));
+    }
+    // domProps
+    if (el.props) {
+        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
+    }
+    segments.push({ type: RAW, value: `>` });
+    return segments;
+}
+function childrenToSegments(el, state) {
+    let binding;
+    if ((binding = el.attrsMap['v-html'])) {
+        return [{ type: EXPRESSION, value: `_s(${binding})` }];
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
+    }
+    return el.children ? nodesToSegments(el.children, state) : [];
+}
+function nodesToSegments(children, state) {
+    const segments = [];
+    for (let i = 0; i < children.length; i++) {
+        const c = children[i];
+        if (c.type === 1) {
+            segments.push.apply(segments, elementToSegments(c, state));
+        }
+        else if (c.type === 2) {
+            segments.push({ type: INTERPOLATION, value: c.expression });
+        }
+        else if (c.type === 3) {
+            let text = escape(c.text);
+            if (c.isComment) {
+                text = '<!--' + text + '-->';
+            }
+            segments.push({ type: RAW, value: text });
+        }
+    }
+    return segments;
+}
+function flattenSegments(segments) {
+    const mergedSegments = [];
+    let textBuffer = '';
+    const pushBuffer = () => {
+        if (textBuffer) {
+            mergedSegments.push(JSON.stringify(textBuffer));
+            textBuffer = '';
+        }
+    };
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        if (s.type === RAW) {
+            textBuffer += s.value;
+        }
+        else if (s.type === INTERPOLATION) {
+            pushBuffer();
+            mergedSegments.push(`_ssrEscape(${s.value})`);
+        }
+        else if (s.type === EXPRESSION) {
+            pushBuffer();
+            mergedSegments.push(`(${s.value})`);
+        }
+    }
+    pushBuffer();
+    return mergedSegments.join('+');
 }
 
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    optimize(ast, options);
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
+const createCompiler = createCompilerCreator(function baseCompile(template, options) {
+    const ast = parse(template.trim(), options);
+    optimize(ast, options);
+    const code = generate(ast, options);
+    return {
+        ast,
+        render: code.render,
+        staticRenderFns: code.staticRenderFns,
+    };
 });
 
 const { compile, compileToFunctions } = createCompiler(baseOptions);
diff --git a/test/e2e/specs/svg.ts b/test/e2e/specs/svg.ts
index 59d4b3c0ef0..38f81b6be91 100644
--- a/test/e2e/specs/svg.ts
+++ b/test/e2e/specs/svg.ts
@@ -1,5 +1,3 @@
-/* globals */
-
 declare const stats: any
 declare const valueToPoint: Function
 
@@ -45,7 +43,7 @@ module.exports = {
         const point = valueToPoint(stat.value, i, 6)
           return point.x + ',' + point.y
         }).join(' ')
-        return document.querySelector('polygon').attributes[0].value === points
+        return document.querySelector('polygon')!.attributes[0].value === points
       })
       .end()
   }
diff --git a/test/helpers/to-have-been-warned.ts b/test/helpers/to-have-been-warned.ts
index 2a462814597..c7e0aba8b61 100644
--- a/test/helpers/to-have-been-warned.ts
+++ b/test/helpers/to-have-been-warned.ts
@@ -52,10 +52,10 @@ beforeEach(() => {
   spyOn(console, 'error')
   jasmine.addMatchers({
     toHaveBeenWarned: () => 
-      // @ts-ignore
+      // @ts-expect-error
       createCompareFn(console.error),
     toHaveBeenTipped: () => 
-      // @ts-ignore
+      // @ts-expect-error
       createCompareFn(console.warn)
   })
 })
diff --git a/test/helpers/trigger-event.ts b/test/helpers/trigger-event.ts
index 8fb5a2274ee..69cbce55dd2 100644
--- a/test/helpers/trigger-event.ts
+++ b/test/helpers/trigger-event.ts
@@ -1,4 +1,4 @@
-global.triggerEvent = function triggerEvent (target, event, process) {
+window.triggerEvent = function triggerEvent (target, event, process) {
   const e = document.createEvent('HTMLEvents')
   e.initEvent(event, true, true)
   if (event === 'click') {
diff --git a/test/helpers/wait-for-update.ts b/test/helpers/wait-for-update.ts
index 28a97ef5f68..d3499c6a228 100644
--- a/test/helpers/wait-for-update.ts
+++ b/test/helpers/wait-for-update.ts
@@ -12,7 +12,7 @@ import Vue from 'vue'
 //   // more assertions...
 // })
 // .then(done)
-// @ts-expect-error
+
 window.waitForUpdate = initialCb => {
   let end
   const queue = initialCb ? [initialCb] : []
@@ -30,7 +30,7 @@ window.waitForUpdate = initialCb => {
           done.fail(e)
         }
       }
-      if (!hasError && !job?.wait) {
+      if (!hasError && !job!.wait) {
         if (queue.length) {
           Vue.nextTick(shift)
         }
@@ -41,7 +41,7 @@ window.waitForUpdate = initialCb => {
   }
 
   Vue.nextTick(() => {
-    if (!queue.length || (!end && !queue[queue.length - 1]?.fail)) {
+    if (!queue.length || (!end && !queue[queue.length - 1]!.fail)) {
       throw new Error('waitForUpdate chain is missing .then(done)')
     }
     shift()
diff --git a/test/ssr/compile-with-webpack.ts b/test/ssr/compile-with-webpack.ts
index 62c5a81cca3..6e648c8b489 100644
--- a/test/ssr/compile-with-webpack.ts
+++ b/test/ssr/compile-with-webpack.ts
@@ -3,9 +3,6 @@ import webpack from 'webpack'
 import MemoryFS from 'memory-fs'
 
 export function compileWithWebpack (file, extraConfig, cb) {
-  if( process.env.FOOBAR !== 'blah') {
-    throw new Error('die')
-  }
   const config = Object.assign({
     mode: 'development',
     entry: path.resolve(__dirname, 'fixtures', file),
diff --git a/test/unit/features/debug.spec.ts b/test/unit/features/debug.spec.ts
index 222964babb0..6f04b18d917 100644
--- a/test/unit/features/debug.spec.ts
+++ b/test/unit/features/debug.spec.ts
@@ -3,7 +3,8 @@ import { formatComponentName, warn } from 'core/util/debug'
 
 describe('Debug utilities', () => {
   it('properly format component names', () => {
-    const vm = new Vue('div')
+    // @ts-expect-error
+    const vm = new Vue()
     expect(formatComponentName(vm)).toBe('<Root>')
 
     vm.$root = null
@@ -83,7 +84,8 @@ found in
 
   describe('warn', () => {
     const msg = 'message'
-    const vm = new Vue('div')
+    // @ts-expect-error
+    const vm = new Vue()
 
     it('calls warnHandler if warnHandler is set', () => {
       Vue.config.warnHandler = jasmine.createSpy()
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index bfabb21bc37..cf838b2feec 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -170,7 +170,8 @@ describe('Error handling', () => {
     Vue.nextTick(() => {
       expect(spy).toHaveBeenCalledWith(err1, undefined, 'nextTick')
 
-      const vm = new Vue('div')
+      // @ts-expect-error
+      const vm = new Vue()
       vm.$nextTick(() => { throw err2 })
       Vue.nextTick(() => {
         // should be called with correct instance info
diff --git a/test/unit/features/instance/init.spec.ts b/test/unit/features/instance/init.spec.ts
index a11d0fd5004..5fda9407c78 100644
--- a/test/unit/features/instance/init.spec.ts
+++ b/test/unit/features/instance/init.spec.ts
@@ -2,11 +2,13 @@ import Vue from 'vue'
 
 describe('Initialization', () => {
   it('without new', () => {
-    try { Vue('div') } catch (e) {}
+    // @ts-expect-error
+    try { Vue() } catch (e) {}
     expect('Vue is a constructor and should be called with the `new` keyword').toHaveBeenWarned()
   })
 
   it('with new', () => {
-    expect(new Vue('div') instanceof Vue).toBe(true)
+    // @ts-expect-error
+    expect(new Vue() instanceof Vue).toBe(true)
   })
 })
diff --git a/test/unit/features/instance/methods-events.spec.ts b/test/unit/features/instance/methods-events.spec.ts
index db66f74a4e9..b35a35ccec5 100644
--- a/test/unit/features/instance/methods-events.spec.ts
+++ b/test/unit/features/instance/methods-events.spec.ts
@@ -3,7 +3,8 @@ import Vue from 'vue'
 describe('Instance methods events', () => {
   let vm, spy
   beforeEach(() => {
-    vm = new Vue('div')
+    // @ts-expect-error
+    const vm = new Vue()
     spy = jasmine.createSpy('emitter')
   })
 
diff --git a/test/unit/features/instance/properties.spec.ts b/test/unit/features/instance/properties.spec.ts
index 1aaa8110b1a..2f06223b6ab 100644
--- a/test/unit/features/instance/properties.spec.ts
+++ b/test/unit/features/instance/properties.spec.ts
@@ -161,7 +161,8 @@ describe('Instance properties', () => {
   })
 
   it('warn mutating $attrs', () => {
-    const vm = new Vue('div')
+    // @ts-expect-error
+    const vm = new Vue()
     vm.$attrs = {}
     expect(`$attrs is readonly`).toHaveBeenWarned()
   })
@@ -196,7 +197,8 @@ describe('Instance properties', () => {
   })
 
   it('warn mutating $listeners', () => {
-    const vm = new Vue('div')
+    // @ts-expect-error
+    const vm = new Vue()
     vm.$listeners = {}
     expect(`$listeners is readonly`).toHaveBeenWarned()
   })
diff --git a/test/unit/features/options/lifecycle.spec.ts b/test/unit/features/options/lifecycle.spec.ts
index 23b9071d0ba..245ef197202 100644
--- a/test/unit/features/options/lifecycle.spec.ts
+++ b/test/unit/features/options/lifecycle.spec.ts
@@ -78,7 +78,8 @@ describe('Options lifecycle hooks', () => {
 
     // #3898
     it('should call for manually mounted instance with parent', () => {
-      const parent = new Vue('div')
+      // @ts-expect-error
+      const vm = new Vue()
       expect(spy).not.toHaveBeenCalled()
       new Vue({
         parent,
diff --git a/test/unit/features/options/render.spec.ts b/test/unit/features/options/render.spec.ts
index 2e16b808c81..3b73d029dca 100644
--- a/test/unit/features/options/render.spec.ts
+++ b/test/unit/features/options/render.spec.ts
@@ -33,7 +33,8 @@ describe('Options render', () => {
   })
 
   it('should warn non `render` option and non `template` option', () => {
-    new Vue('div').$mount()
+    // @ts-expect-error
+    new Vue().$mount()
     expect('Failed to mount component: template or render function not defined.').toHaveBeenWarned()
   })
 })
diff --git a/test/unit/features/transition/transition.spec.ts b/test/unit/features/transition/transition.spec.ts
index aa3bdee579f..c258ae711ff 100644
--- a/test/unit/features/transition/transition.spec.ts
+++ b/test/unit/features/transition/transition.spec.ts
@@ -23,7 +23,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index f17d5b535f2..f175ae3d878 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -14,7 +14,8 @@ describe('Observer', () => {
     const ob1 = observe(1)
     expect(ob1).toBeUndefined()
     // avoid vue instance
-    const ob2 = observe(new Vue('div'))
+    // @ts-expect-error
+    const ob2 = observe(new Vue())
     expect(ob2).toBeUndefined()
     // avoid frozen objects
     const ob3 = observe(Object.freeze({}))

From 19a5a355296fedbb5f20f55126079b38089905ab Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:08:46 +0800
Subject: [PATCH 030/317] build: target es5

---
 .gitignore                      |     1 +
 dist/README.md                  |   122 -
 dist/vue.common.dev.js          | 10448 -----------------------------
 dist/vue.common.js              |     5 -
 dist/vue.common.prod.js         |    11 -
 dist/vue.esm.browser.js         | 10446 -----------------------------
 dist/vue.esm.browser.min.js     |    11 -
 dist/vue.esm.js                 | 10500 ------------------------------
 dist/vue.js                     | 10454 -----------------------------
 dist/vue.min.js                 |    11 -
 dist/vue.runtime.common.dev.js  |  7404 ---------------------
 dist/vue.runtime.common.js      |     5 -
 dist/vue.runtime.common.prod.js |    11 -
 dist/vue.runtime.esm.js         |  7443 ---------------------
 dist/vue.runtime.js             |  7410 ---------------------
 dist/vue.runtime.min.js         |    11 -
 package.json                    |     3 +-
 scripts/config.js               |    50 +-
 tsconfig.json                   |     4 +-
 yarn.lock                       |    25 +-
 20 files changed, 37 insertions(+), 64338 deletions(-)
 delete mode 100644 dist/README.md
 delete mode 100644 dist/vue.common.dev.js
 delete mode 100644 dist/vue.common.js
 delete mode 100644 dist/vue.common.prod.js
 delete mode 100644 dist/vue.esm.browser.js
 delete mode 100644 dist/vue.esm.browser.min.js
 delete mode 100644 dist/vue.esm.js
 delete mode 100644 dist/vue.js
 delete mode 100644 dist/vue.min.js
 delete mode 100644 dist/vue.runtime.common.dev.js
 delete mode 100644 dist/vue.runtime.common.js
 delete mode 100644 dist/vue.runtime.common.prod.js
 delete mode 100644 dist/vue.runtime.esm.js
 delete mode 100644 dist/vue.runtime.js
 delete mode 100644 dist/vue.runtime.min.js

diff --git a/.gitignore b/.gitignore
index 370a6eddbc0..6e7a5edfb77 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,3 +17,4 @@ packages/vue-server-renderer/server-plugin.js
 packages/vue-server-renderer/client-plugin.js
 packages/vue-template-compiler/build.js
 .vscode
+dist
diff --git a/dist/README.md b/dist/README.md
deleted file mode 100644
index 19386ecf311..00000000000
--- a/dist/README.md
+++ /dev/null
@@ -1,122 +0,0 @@
-## Explanation of Build Files
-
-| | UMD | CommonJS | ES Module |
-| --- | --- | --- | --- |
-| **Full** | vue.js | vue.common.js | vue.esm.js |
-| **Runtime-only** | vue.runtime.js | vue.runtime.common.js | vue.runtime.esm.js |
-| **Full (production)** | vue.min.js | | |
-| **Runtime-only (production)** | vue.runtime.min.js | | |
-
-### Terms
-
-- **Full**: builds that contain both the compiler and the runtime.
-
-- **Compiler**: code that is responsible for compiling template strings into JavaScript render functions.
-
-- **Runtime**: code that is responsible for creating Vue instances, rendering and patching virtual DOM, etc. Basically everything minus the compiler.
-
-- **[UMD](https://github.com/umdjs/umd)**: UMD builds can be used directly in the browser via a `<script>` tag. The default file from Unpkg CDN at [https://unpkg.com/vue](https://unpkg.com/vue) is the Runtime + Compiler UMD build (`vue.js`).
-
-- **[CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1)**: CommonJS builds are intended for use with older bundlers like [browserify](http://browserify.org/) or [webpack 1](https://webpack.github.io). The default file for these bundlers (`pkg.main`) is the Runtime only CommonJS build (`vue.runtime.common.js`).
-
-- **[ES Module](http://exploringjs.com/es6/ch_modules.html)**: ES module builds are intended for use with modern bundlers like [webpack 2](https://webpack.js.org) or [rollup](http://rollupjs.org/). The default file for these bundlers (`pkg.module`) is the Runtime only ES Module build (`vue.runtime.esm.js`).
-
-### Runtime + Compiler vs. Runtime-only
-
-If you need to compile templates on the fly (e.g. passing a string to the `template` option, or mounting to an element using its in-DOM HTML as the template), you will need the compiler and thus the full build.
-
-When using `vue-loader` or `vueify`, templates inside `*.vue` files are compiled into JavaScript at build time. You don't really need the compiler in the final bundle, and can therefore, use the runtime-only build.
-
-Since the runtime-only builds are roughly 30% lighter-weight than their full-build counterparts, you should use it whenever you can. If you wish to use the full build instead, you need to configure an alias in your bundler.
-
-#### Webpack
-
-``` js
-module.exports = {
-  // ...
-  resolve: {
-    alias: {
-      'vue$': 'vue/dist/vue.esm.js' // 'vue/dist/vue.common.js' for webpack 1
-    }
-  }
-}
-```
-
-#### Rollup
-
-``` js
-const alias = require('rollup-plugin-alias')
-
-rollup({
-  // ...
-  plugins: [
-    alias({
-      'vue': 'vue/dist/vue.esm.js'
-    })
-  ]
-})
-```
-
-#### Browserify
-
-Add to your project's `package.json`:
-
-``` js
-{
-  // ...
-  "browser": {
-    "vue": "vue/dist/vue.common.js"
-  }
-}
-```
-
-### Development vs. Production Mode
-
-Development/production modes are hard-coded for the UMD builds: the un-minified files are for development, and the minified files are for production.
-
-CommonJS and ES Module builds are intended for bundlers, therefore we don't provide minified versions for them. You will be responsible for minifying the final bundle yourself.
-
-CommonJS and ES Module builds also preserve raw checks for `process.env.NODE_ENV` to determine the mode they should run in. You should use appropriate bundler configurations to replace these environment variables in order to control which mode Vue will run in. Replacing `process.env.NODE_ENV` with string literals also allows minifiers like UglifyJS to completely drop the development-only code blocks, reducing final file size.
-
-#### Webpack
-
-Use Webpack's [DefinePlugin](https://webpack.js.org/plugins/define-plugin/):
-
-``` js
-var webpack = require('webpack')
-
-module.exports = {
-  // ...
-  plugins: [
-    // ...
-    new webpack.DefinePlugin({
-      'process.env.NODE_ENV': JSON.stringify('production')
-    })
-  ]
-}
-```
-
-#### Rollup
-
-Use [rollup-plugin-replace](https://github.com/rollup/rollup-plugin-replace):
-
-``` js
-const replace = require('rollup-plugin-replace')
-
-rollup({
-  // ...
-  plugins: [
-    replace({
-      'process.env.NODE_ENV': JSON.stringify('production')
-    })
-  ]
-}).then(...)
-```
-
-#### Browserify
-
-Apply a global [envify](https://github.com/hughsk/envify) transform to your bundle.
-
-``` bash
-NODE_ENV=production browserify -g envify -e main.js | uglifyjs -c -m > build.js
-```
diff --git a/dist/vue.common.dev.js b/dist/vue.common.dev.js
deleted file mode 100644
index a68fe89f2bc..00000000000
--- a/dist/vue.common.dev.js
+++ /dev/null
@@ -1,10448 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-'use strict';
-
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
-
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
-}
-
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
-}
-
-let mark;
-let measure;
-{
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-{
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn$2(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
-}
-
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
-}
-
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            {
-                defineReactive(vm, key, result[key], () => {
-                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic$1(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic$1(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-        }, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (Array.isArray(vnode)) {
-                warn$2('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
-}
-
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            warn$2(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`
-                                );
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
-}
-
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
-}
-
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
-}
-
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn$2("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn$2("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
-}
-
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index$1 = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index$1 = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index$1 = 0; index$1 < queue.length; index$1++) {
-        watcher = queue[index$1];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn$2('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index$1 && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (!config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
-}
-
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = expOrFn.toString()
-            ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn$2(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
-}
-
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        warn$2("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        {
-            if (methods && hasOwn(methods, key)) {
-                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            warn$2(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (getter == null) {
-            warn$2(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else {
-            if (key in vm.$data) {
-                warn$2(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        {
-            if (typeof methods[key] !== "function") {
-                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    {
-        dataDef.set = function () {
-            warn$2("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn$2(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
-}
-
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        {
-            initProxy(vm);
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function Vue(options) {
-    if (!(this instanceof Vue)) {
-        warn$2("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
-renderMixin(Vue);
-
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
-}
-
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
-}
-
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
-}
-
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
-}
-
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
-};
-
-var builtInComponents = {
-    KeepAlive,
-};
-
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    {
-        configDef.set = () => {
-            warn$2('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn$2,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
-}
-
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
-Vue.version = '2.6.14';
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
-};
-
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
-}
-
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
-const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
-}
-
-var nodeOps = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createElement: createElement,
-  createElementNS: createElementNS,
-  createTextNode: createTextNode,
-  createComment: createComment,
-  insertBefore: insertBefore,
-  removeChild: removeChild,
-  appendChild: appendChild,
-  parentNode: parentNode,
-  nextSibling: nextSibling,
-  tagName: tagName,
-  setTextContent: setTextContent,
-  setStyleScope: setStyleScope
-});
-
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
-}
-
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn$2('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else {
-                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
-}
-
-var directives$1 = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
-}
-
-var baseModules = [ref, directives$1];
-
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
-};
-
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass$1 = {
-    create: updateClass,
-    update: updateClass,
-};
-
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
-}
-
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
-}
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
-}
-
-let warn$1;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
-
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-};
-
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
-};
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
-}
-
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style$1 = {
-    create: updateStyle,
-    update: updateStyle,
-};
-
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
-    : {};
-
-var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules$1 = platformModules.concat(baseModules);
-const patch = createPatchFunction({ nodeOps, modules: modules$1 });
-
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
-}
-
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
-};
-
-var platformDirectives = {
-    model: directive,
-    show,
-};
-
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (children.length > 1) {
-            warn$2('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn$2('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
-};
-
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn$2(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
-}
-
-var platformComponents = {
-    Transition,
-    TransitionGroup,
-};
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
-}
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
-}
-
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
-};
-
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
-};
-
-let decoder;
-var he = {
-    decode(html) {
-        decoder = decoder || document.createElement('div');
-        decoder.innerHTML = html;
-        return decoder.textContent;
-    },
-};
-
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
-}
-
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he.decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
-}
-
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model = {
-    preTransformNode,
-};
-
-var modules = [klass, style, model];
-
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
-}
-
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
-}
-
-var directives = {
-    model: model$1,
-    text,
-    html,
-};
-
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
-};
-
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
-}
-
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
-}
-
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-}
-
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
-}
-
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
-};
-
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-}
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
-}
-
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
-}
-
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
-}
-
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = typeof (msg) === 'string' ? { msg } : msg;
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
-}
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize(ast, options);
-    }
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
-});
-
-const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-// check whether current browser encodes a char inside attribute values
-let div;
-function getShouldDecode(href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-    return div.innerHTML.indexOf('&#10;') > 0;
-}
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-// #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
-    ? getShouldDecode(true)
-    : false;
-
-const idToTemplate = cached((id) => {
-    const el = query(id);
-    return el && el.innerHTML;
-});
-const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && query(el);
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-        return this;
-    }
-    const options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-        let template = options.template;
-        if (template) {
-            if (typeof template === 'string') {
-                if (template.charAt(0) === '#') {
-                    template = idToTemplate(template);
-                    /* istanbul ignore if */
-                    if (!template) {
-                        warn$2(`Template element not found or is empty: ${options.template}`, this);
-                    }
-                }
-            }
-            else if (template.nodeType) {
-                template = template.innerHTML;
-            }
-            else {
-                {
-                    warn$2('invalid template option:' + template, this);
-                }
-                return this;
-            }
-        }
-        else if (el) {
-            // @ts-expect-error
-            template = getOuterHTML(el);
-        }
-        if (template) {
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile');
-            }
-            const { render, staticRenderFns } = compileToFunctions(template, {
-                outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
-                delimiters: options.delimiters,
-                comments: options.comments,
-            }, this);
-            options.render = render;
-            options.staticRenderFns = staticRenderFns;
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
-            }
-        }
-    }
-    return mount.call(this, el, hydrating);
-};
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el) {
-    if (el.outerHTML) {
-        return el.outerHTML;
-    }
-    else {
-        const container = document.createElement('div');
-        container.appendChild(el.cloneNode(true));
-        return container.innerHTML;
-    }
-}
-Vue.compile = compileToFunctions;
-
-module.exports = Vue;
diff --git a/dist/vue.common.js b/dist/vue.common.js
deleted file mode 100644
index 3bbc37c95fc..00000000000
--- a/dist/vue.common.js
+++ /dev/null
@@ -1,5 +0,0 @@
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./vue.common.prod.js')
-} else {
-  module.exports = require('./vue.common.dev.js')
-}
diff --git a/dist/vue.common.prod.js b/dist/vue.common.prod.js
deleted file mode 100644
index d0d8ad0320e..00000000000
--- a/dist/vue.common.prod.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const I=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const G=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const Z=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let st=S,it=0;class at{static target;id;subs;constructor(){this.id=it++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{value;dep;vmCount;constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const s=new at,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function kt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}const At=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=ot?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Nt(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{At[t]=Tt})),I.forEach((function(t){At[t+"s"]=Nt})),At.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function It(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Lt(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(i),$t(e)}return i}const Mt=/^\s*function (\w+)/;function Lt(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return Lt(t)===Lt(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Rt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Rt(t,o,r)}return s}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,Jt=!1;function qt(){Jt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(qt),G&&setTimeout(S)},zt=!0}else if(J||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(qt)}:()=>{setTimeout(qt,0)};else{let t=1;const e=new MutationObserver(qt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),Jt||(Jt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Gt=new rt;function Zt(t){Xt(t,Gt),Gt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),s(f.name,n[c],f.capture))}function ee(t,r,s){let i;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ne(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?se(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=se(c,`${s||""}_${a}`),re(c[0])&&re(u)&&(i[l]=pt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?re(u)?i[l]=pt(u.text+c):""!==c&&i.push(pt(c)):re(c)&&re(u)?i[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ie(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(t){return t.isComment&&t.asyncFactory}function ue(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=fe(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=de(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",i),R(r,"$key",a),R(r,"$hasNormal",s),r}function fe(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!le(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function de(t,e){return()=>t[e]}function pe(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function he(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function me(t){return Dt(this.$options,"filters",t)||N}function ye(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ge(t,e,n,o,r){const s=L.keyCodes[e]||n;return r&&o&&!L.keyCodes[e]?ye(r,o):s?ye(s,t):o?C(o)!==e:void 0===t}function ve(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||L.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function $e(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),be(o,`__static__${t}`,!1)),o}function _e(t,e,n){return be(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function be(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&we(t[o],`${e}_${o}`,n);else we(t,e,n)}function we(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Ce(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function xe(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?xe(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function ke(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=u,t._l=pe,t._t=he,t._q=E,t._i=j,t._m=$e,t._f=me,t._k=ge,t._b=ve,t._v=pt,t._e=dt,t._u=xe,t._g=Ce,t._d=ke,t._p=Ae}function Se(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ie(a.inject,s),this.slots=()=>(this.$slots||ue(e.scopedSlots,this.$slots=ae(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Me(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Me(c,t,e,n,o,u)}function Te(t,e,n,o,r){const s=ht(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ne(t,e){for(const n in e)t[_(n)]=e[n]}Oe(Se.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=It(s,i,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ze(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ge(e,!0):e.$destroy())}},je=Object.keys(Ee);function De(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Pe;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=Re(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Re(h.error,r)),n(h.loading)&&(t.loadingComp=Re(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=dt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ne(i,c,t,e,!0)||ne(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=It(e,l,o||t);else n(r.attrs)&&Ne(c,r.attrs),n(r.props)&&Ne(c,r.props);const u=new Se(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Te(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Te(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<je.length;t++){const n=je[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?Ie(r,o):r)}}(i);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Ie(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Me(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=oe(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),a=L.isReservedTag(e)?new ft(L.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=Dt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):De(s,o,t,r,e)}else a=De(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Le(a,c),n(o)&&function(t){s(t.style)&&Zt(t.style);s(t.class)&&Zt(t.class)}(o),a):dt()}(t,e,i,a,c)}function Le(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Le(a,r,s)}}let Fe,Pe=null;function Re(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||le(o)))return o}}function Be(t,e){Fe.$on(t,e)}function Ue(t,e){Fe.$off(t,e)}function ze(t,e){const n=Fe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Fe=t,te(e,n||{},Be,Ue,ze,t),Fe=void 0}let Ke=null;function Je(t){const e=Ke;return Ke=t,()=>{Ke=e}}function qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ze(t,"activated")}}function Ge(t,e){if(!(e&&(t._directInactive=!0,qe(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ge(t.$children[e]);Ze(t,"deactivated")}}function Ze(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!J){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ze(o,"updated")}}(o),et&&L.devtools&&et.emit("flush")}let an=0;class cn{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Zt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Ht(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const s in e){r.push(s);wt(o,s,It(s,e,n,t)),s in t||un(t,"_props",s)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new cn(t,i||S,S,dn)),r in t||pn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=jt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,I.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Me(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Me(e,t,n,o,r,!0);const s=o&&o.data;wt(e,"$attrs",s&&s.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){const e=ie(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;lt(),Ht(e,o,[r.value],o,t),ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=Je(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ue(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Pe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Pe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const kn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:bn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&xn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>L};Object.defineProperty(t,"config",e),t.util={warn:st,extend:A,mergeOptions:jt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),I.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),_n(t),function(t){I.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Se}),$n.version="2.6.14";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,Nn=d("contenteditable,draggable,spellcheck"),En=d("events,caret,typing,plaintext-only"),jn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Dn="http://www.w3.org/1999/xlink",In=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Mn=t=>In(t)?t.slice(6,t.length):"",Ln=t=>null==t||!1===t;function Fn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Pn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Pn(e,o.data));return function(t,e){if(n(t)||n(e))return Rn(t,Hn(e));return""}(e.staticClass,e.class)}function Pn(t,e){return{staticClass:Rn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Rn(t,e){return t?e?t+" "+e:t:e||""}function Hn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Hn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Un=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Vn=t=>Un(t)||zn(t);function Kn(t){return zn(t)?"svg":"math"===t?"math":void 0}const Jn=Object.create(null);const qn=d("text,number,password,search,email,tel,url");function Wn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var Gn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create(t,e){Xn(e)},update(t,e){t.data.ref!==e.data.ref&&(Xn(t,!0),Xn(e))},destroy(t){Xn(t,!0)}};function Xn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?m(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Yn=new ft("",{},[]),Qn=["create","activate","update","remove","destroy"];function to(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||qn(r)&&qn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function eo(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var no={create:oo,update:oo,destroy:function(t){oo(t,Yn)}};function oo(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Yn,o=e===Yn,r=so(t.data.directives,t.context),s=so(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ao(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ao(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)ao(i[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ao(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||ao(r[c],"unbind",t,t,o)}(t,e)}const ro=Object.create(null);function so(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=ro),n[io(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function io(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ao(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var co=[Zn,no];function lo(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&uo(c,s,i,o.data.pre);for(s in(J||W)&&u.value!==l.value&&uo(c,"value",u.value),l)e(u[s])&&(In(s)?c.removeAttributeNS(Dn,Mn(s)):Nn(s)||c.removeAttribute(s))}function uo(t,e,n,o){o||t.tagName.indexOf("-")>-1?fo(t,e,n):jn(e)?Ln(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,((t,e)=>Ln(e)||"false"===e?"false":"contenteditable"===t&&En(e)?e:"true")(e,n)):In(e)?Ln(n)?t.removeAttributeNS(Dn,Mn(e)):t.setAttributeNS(Dn,e,n):fo(t,e,n)}function fo(t,e,n){if(Ln(n))t.removeAttribute(e);else{if(J&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var po={create:lo,update:lo};function ho(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Fn(o);const c=r._transitionClasses;n(c)&&(a=Rn(a,Hn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var mo={create:ho,update:ho};const yo=/[\w).+\-_$\]]/;function go(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&yo.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=vo(r,s[o]);return r}function vo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function $o(t,e){console.error(`[Vue compiler]: ${t}`)}function _o(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function bo(t,e,n,o,r){(t.props||(t.props=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function wo(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function Co(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(No({name:e,value:n},o))}function xo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(No({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function ko(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Ao(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=ko("!",n,c)),r.once&&(delete r.once,n=ko("~",n,c)),r.passive&&(delete r.passive,n=ko("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=No({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function Oo(t,e,n){const o=So(t,":"+e)||So(t,"v-bind:"+e);if(null!=o)return go(o);if(!1!==n){const n=So(t,e);if(null!=n)return JSON.stringify(n)}}function So(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function To(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function No(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function Eo(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=jo(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function jo(t,e){const n=function(t){if(t=t.trim(),Do=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Do-1)return Lo=t.lastIndexOf("."),Lo>-1?{exp:t.slice(0,Lo),key:'"'+t.slice(Lo+1)+'"'}:{exp:t,key:null};Io=t,Lo=Fo=Po=0;for(;!Ho();)Mo=Ro(),Bo(Mo)?zo(Mo):91===Mo&&Uo(Mo);return{exp:t.slice(0,Fo),key:t.slice(Fo+1,Po)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Do,Io,Mo,Lo,Fo,Po;function Ro(){return Io.charCodeAt(++Lo)}function Ho(){return Lo>=Do}function Bo(t){return 34===t||39===t}function Uo(t){let e=1;for(Fo=Lo;!Ho();)if(Bo(t=Ro()))zo(t);else if(91===t&&e++,93===t&&e--,0===e){Po=Lo;break}}function zo(t){const e=t;for(;!Ho()&&(t=Ro())!==e;);}let Vo;function Ko(t,e,n){const o=Vo;return function r(){const s=e.apply(null,arguments);null!==s&&Wo(t,r,n,o)}}const Jo=zt&&!(Z&&Number(Z[1])<=53);function qo(t,e,n,o){if(Jo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Vo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Wo(t,e,n,o){(o||Vo).removeEventListener(t,e._wrapper||e,n)}function Go(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Vo=o.elm||t.elm,function(t){if(n(t.__r)){const e=J?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,s,qo,Wo,Ko,o.context),Vo=void 0}var Zo={create:Go,update:Go,destroy:t=>Go(t,Yn)};let Xo;function Yo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Qo(i,t)&&(i.value=t)}else if("innerHTML"===r&&zn(i.tagName)&&e(i.innerHTML)){Xo=Xo||document.createElement("div"),Xo.innerHTML=`<svg>${s}</svg>`;const t=Xo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Qo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var tr={create:Yo,update:Yo};const er=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function nr(t){const e=or(t.style);return t.staticStyle?A(t.staticStyle,e):e}function or(t){return Array.isArray(t)?O(t):"string"==typeof t?er(t):t}const rr=/^--/,sr=/\s*!important$/,ir=(t,e,n)=>{if(rr.test(e))t.style.setProperty(e,n);else if(sr.test(n))t.style.setProperty(C(e),n.replace(sr,""),"important");else{const o=lr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},ar=["Webkit","Moz","ms"];let cr;const lr=v((function(t){if(cr=cr||document.createElement("div").style,"filter"!==(t=_(t))&&t in cr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<ar.length;t++){const n=ar[t]+e;if(n in cr)return n}}));function ur(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=or(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=nr(e.data))&&A(n,o)}(o=nr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=nr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&ir(c,a,"");for(a in p)i=p[a],i!==f[a]&&ir(c,a,null==i?"":i)}var fr={create:ur,update:ur};const dr=/\s+/;function pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function mr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,yr(t.name||"v")),A(e,t),e}return"string"==typeof t?yr(t):void 0}}const yr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),gr=U&&!q;let vr="transition",$r="transitionend",_r="animation",br="animationend";gr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(vr="WebkitTransition",$r="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(_r="WebkitAnimation",br="webkitAnimationEnd"));const wr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Cr(t){wr((()=>{wr(t)}))}function xr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pr(t,e))}function kr(t,e){t._transitionClasses&&m(t._transitionClasses,e),hr(t,e)}function Ar(t,e,n){const{type:o,timeout:r,propCount:s}=Sr(t,e);if(!o)return n();const i="transition"===o?$r:br;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Or=/\b(transform|all)(,|$)/;function Sr(t,e){const n=window.getComputedStyle(t),o=(n[vr+"Delay"]||"").split(", "),r=(n[vr+"Duration"]||"").split(", "),s=Tr(o,r),i=(n[_r+"Delay"]||"").split(", "),a=(n[_r+"Duration"]||"").split(", "),c=Tr(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Or.test(n[vr+"Property"])}}function Tr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Nr(e)+Nr(t[n]))))}function Nr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Er(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=mr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Ke,A=Ke.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,j=O&&"function"==typeof b?b:g,I=O&&w||v,M=O&&C||$,L=f(s(x)?x.enter:x),F=!1!==a&&!q,P=Ir(j),R=r._enterCb=D((()=>{F&&(kr(r,N),kr(r,T)),R.cancelled?(F&&kr(r,S),M&&M(r)):I&&I(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),E&&E(r),F&&(xr(r,S),xr(r,T),Cr((()=>{kr(r,S),R.cancelled||(xr(r,N),P||(Dr(L)?setTimeout(R,L):Ar(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function jr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=mr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!q,_=Ir(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(kr(r,u),kr(r,d)),w.cancelled?($&&kr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(xr(r,l),xr(r,d),Cr((()=>{kr(r,l),w.cancelled||(xr(r,u),_||(Dr(b)?setTimeout(w,b):Ar(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Dr(t){return"number"==typeof t&&!isNaN(t)}function Ir(t){if(e(t))return!1;const o=t.fns;return n(o)?Ir(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Mr(t,e){!0!==e.data.show&&Er(e)}const Lr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Qn.length;++s)for(a[Qn[s]]=[],i=0;i<c.length;++i)n(c[i][Qn[s]])&&a[Qn[s]].push(c[i][Qn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Yn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Xn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Yn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&to(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:to(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):to(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):to(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):to(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=eo(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],to(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Zt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&to(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Xn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:Gn,modules:[po,mo,Zo,tr,fr,U?{create:Mr,activate:Mr,remove(t,e){!0!==t.data.show?jr(t,e):e()}}:{}].concat(co)});q&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Vr(t,"input")}));const Fr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Fr.componentUpdated(t,e,n)})):Pr(t,e,n.context),t._vOptions=[].map.call(t.options,Br)):("textarea"===n.tag||qn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Ur),t.addEventListener("compositionend",zr),t.addEventListener("change",zr),q&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Pr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Br);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>Hr(t,r))):e.value!==e.oldValue&&Hr(e.value,r))&&Vr(t,"change")}}}};function Pr(t,e,n){Rr(t,e),(J||W)&&setTimeout((()=>{Rr(t,e)}),0)}function Rr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Br(i))>-1,i.selected!==s&&(i.selected=s);else if(E(Br(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Hr(t,e){return e.every((e=>!E(e,t)))}function Br(t){return"_value"in t?t._value:t.value}function Ur(t){t.target.composing=!0}function zr(t){t.target.composing&&(t.target.composing=!1,Vr(t.target,"input"))}function Vr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Kr(t){return!t.componentInstance||t.data&&t.data.transition?t:Kr(t.componentInstance._vnode)}var Jr={bind(t,{value:e},n){const o=(n=Kr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Er(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Kr(o)).data&&o.data.transition?(o.data.show=!0,e?Er(o,(()=>{t.style.display=t.__vOriginalDisplay})):jr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},qr={model:Fr,show:Jr};const Wr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Gr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Gr(He(e.children)):t}function Zr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Xr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Yr=t=>t.tag||le(t),Qr=t=>"show"===t.name;var ts={name:"transition",props:Wr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Yr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Gr(o);if(!s)return o;if(this._leaving)return Xr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=Zr(this),c=this._vnode,l=Gr(c);if(s.data.directives&&s.data.directives.some(Qr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!le(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),Xr(t,o);if("in-out"===n){if(le(s))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const es=A({tag:String,moveClass:String},Wr);function ns(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function os(t){t.data.newPos=t.elm.getBoundingClientRect()}function rs(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete es.mode;var ss={Transition:ts,TransitionGroup:{props:es,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=Je(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=Zr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(ns),t.forEach(os),t.forEach(rs),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;xr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener($r,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener($r,t),n._moveCb=null,kr(n,e))})}})))},methods:{hasMove(t,e){if(!gr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{hr(n,t)})),pr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Sr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=Tn,$n.config.isReservedTag=Vn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=Kn,$n.config.isUnknownElement=function(t){if(!U)return!0;if(Vn(t))return!1;if(t=t.toLowerCase(),null!=Jn[t])return Jn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Jn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Jn[t]=/HTMLUnknownElement/.test(e.toString())},A($n.options.directives,qr),A($n.options.components,ss),$n.prototype.__patch__=U?Lr:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ze(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?Wn(t):void 0,e)},U&&setTimeout((()=>{L.devtools&&et&&et.emit("init",$n)}),0);const is=/\{\{((?:.|\r?\n)+?)\}\}/g,as=/[-.*+?^${}()|[\]\/\\]/g,cs=v((t=>{const e=t[0].replace(as,"\\$&"),n=t[1].replace(as,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ls={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=So(t,"class");n&&(t.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const o=Oo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var us={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=So(t,"style");n&&(t.staticStyle=JSON.stringify(er(n)));const o=Oo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let fs;var ds={decode:t=>(fs=fs||document.createElement("div"),fs.innerHTML=t,fs.textContent)};const ps=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),hs=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ms=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ys=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,gs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,vs=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,$s=`((?:${vs}\\:)?${vs})`,_s=new RegExp(`^<${$s}`),bs=/^\s*(\/?)>/,ws=new RegExp(`^<\\/${$s}[^>]*>`),Cs=/^<!DOCTYPE [^>]+>/i,xs=/^<!\--/,ks=/^<!\[/,As=d("script,style,textarea",!0),Os={},Ss={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ts=/&(?:lt|gt|quot|amp|#39);/g,Ns=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Es=d("pre,textarea",!0),js=(t,e)=>t&&Es(t)&&"\n"===e[0];function Ds(t,e){const n=e?Ns:Ts;return t.replace(n,(t=>Ss[t]))}const Is=/^@|^v-on:/,Ms=/^v-|^@|^:|^#/,Ls=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Ps=/^\(|\)$/g,Rs=/^\[.*\]$/,Hs=/:(.*)$/,Bs=/^:|^\.|^v-bind:/,Us=/\.[^.\]]+(?=[^\]]*$)/g,zs=/^v-slot(:|$)|^#/,Vs=/[\r\n]/,Ks=/[ \f\t\r\n]+/g,Js=v(ds.decode);let qs,Ws,Gs,Zs,Xs,Ys,Qs,ti;function ei(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ci(e),rawAttrsMap:{},parent:n,children:[]}}function ni(t,e){qs=e.warn||$o,Ys=e.isPreTag||T,Qs=e.mustUseProp||T,ti=e.getTagNamespace||T,e.isReservedTag,Gs=_o(e.modules,"transformNode"),Zs=_o(e.modules,"preTransformNode"),Xs=_o(e.modules,"postTransformNode"),Ws=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=oi(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&si(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&si(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),Ys(t.tag)&&(c=!1);for(let n=0;n<Xs.length;n++)Xs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&As(a)){let n=0;const o=a.toLowerCase(),r=Os[o]||(Os[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,As(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),js(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(xs.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(ks.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Cs);if(n){l(n[0].length);continue}const o=t.match(ws);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),js(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(ws.test(o)||_s.test(o)||xs.test(o)||ks.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(_s);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(bs))&&(r=t.match(gs)||t.match(ys));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ms(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ds(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:qs,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||ti(t);J&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];li.test(o.name)||(o.name=o.name.replace(ui,""),e.push(o))}return e}(o));let p=ei(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<Zs.length;t++)p=Zs[t](p,e)||p;a||(!function(t){null!=So(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),Ys(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ri(p),function(t){const e=So(t,"v-if");if(e)t.if=e,si(t,{exp:e,block:t});else{null!=So(t,"v-else")&&(t.else=!0);const e=So(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=So(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(J&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Js(t):s.length?r?"condense"===r&&Vs.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Ks," ")),!a&&" "!==t&&(e=function(t,e){const n=e?cs(e):is;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=go(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Ws))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function oi(t,e){var n;!function(t){const e=Oo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=Oo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=So(t,"scope"),t.slotScope=e||So(t,"slot-scope")):(e=So(t,"slot-scope"))&&(t.slotScope=e);const n=Oo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||wo(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=To(t,zs);if(e){const{name:n,dynamic:o}=ii(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=To(t,zs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ii(e),s=n[o]=ei("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=Oo(n,"name")),function(t){let e;(e=Oo(t,"is"))&&(t.component=e);null!=So(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Gs.length;n++)t=Gs[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Ms.test(r))if(t.hasBindings=!0,a=ai(r.replace(Ms,"")),a&&(r=r.replace(Us,"")),Bs.test(r))r=r.replace(Bs,""),i=go(i),l=Rs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=jo(i,"$event"),l?Ao(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Ao(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Ao(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&Qs(t.tag,t.attrsMap.type,r)?bo(t,r,i,e[n],l):wo(t,r,i,e[n],l);else if(Is.test(r))r=r.replace(Is,""),l=Rs.test(r),l&&(r=r.slice(1,-1)),Ao(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Ms,"");const o=r.match(Hs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Rs.test(c)&&(c=c.slice(1,-1),l=!0)),xo(t,r,s,i,c,l,a,e[n])}else wo(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&Qs(t.tag,t.attrsMap.type,r)&&bo(t,r,"true",e[n])}(t),t}function ri(t){let e;if(e=So(t,"v-for")){const n=function(t){const e=t.match(Ls);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Ps,""),r=o.match(Fs);r?(n.alias=o.replace(Fs,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function si(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ii(t){let e=t.name.replace(zs,"");return e||"#"!==t.name[0]&&(e="default"),Rs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function ai(t){const e=t.match(Us);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ci(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const li=/^xmlns:NS\d+/,ui=/^NS\d+:/;function fi(t){return ei(t.tag,t.attrsList.slice(),t.parent)}var di=[ls,us,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=Oo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=So(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=So(t,"v-else",!0),i=So(t,"v-else-if",!0),a=fi(t);ri(a),Co(a,"type","checkbox"),oi(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,si(a,{exp:a.if,block:a});const c=fi(t);So(c,"v-for",!0),Co(c,"type","radio"),oi(c,e),si(a,{exp:`(${o})==='radio'`+r,block:c});const l=fi(t);return So(l,"v-for",!0),Co(l,":type",o),oi(l,e),si(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const pi={expectHTML:!0,modules:di,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return Eo(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${jo(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Ao(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=Oo(t,"value")||"null",s=Oo(t,"true-value")||"true",i=Oo(t,"false-value")||"false";bo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Ao(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${jo(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${jo(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${jo(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=Oo(t,"value")||"null";r=o?`_n(${r})`:r,bo(t,"checked",`_q(${e},${r})`),Ao(t,"change",jo(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=jo(e,l);a&&(u=`if($event.target.composing)return;${u}`);bo(t,"value",`(${e})`),Ao(t,c,u,null,!0),(i||s)&&Ao(t,"blur","$forceUpdate()")}(t,o,r);else if(!L.isReservedTag(s))return Eo(t,o,r),!1;return!0},text:function(t,e){e.value&&bo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&bo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:ps,mustUseProp:Tn,canBeLeftOpenTag:hs,isReservedTag:Vn,getTagNamespace:Kn,staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(di)};let hi,mi;const yi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function gi(t,e){t&&(hi=yi(e.staticKeys||""),mi=e.isReservedTag||T,vi(t),$i(t,!1))}function vi(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!mi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(hi)))}(t),1===t.type){if(!mi(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];vi(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;vi(n),n.static||(t.static=!1)}}}function $i(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)$i(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)$i(t.ifConditions[n].block,e)}}const _i=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,bi=/\([^)]*?\);*$/,wi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},ki=t=>`if(${t})return null;`,Ai={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:ki("$event.target !== $event.currentTarget"),ctrl:ki("!$event.ctrlKey"),shift:ki("!$event.shiftKey"),alt:ki("!$event.altKey"),meta:ki("!$event.metaKey"),left:ki("'button' in $event && $event.button !== 0"),middle:ki("'button' in $event && $event.button !== 1"),right:ki("'button' in $event && $event.button !== 2")};function Oi(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Si(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Si(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Si(t))).join(",")}]`;const e=wi.test(t.value),n=_i.test(t.value),o=wi.test(t.value.replace(bi,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ai[e])s+=Ai[e],Ci[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=ki(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Ti).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ti(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Ci[t],o=xi[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Ni={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ei{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(t){this.options=t,this.warn=t.warn||$o,this.transforms=_o(t.modules,"transformCode"),this.dataGenFns=_o(t.modules,"genData"),this.directives=A(A({},Ni),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function ji(t,e){const n=new Ei(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Di(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Di(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ii(t,e);if(t.once&&!t.onceProcessed)return Mi(t,e);if(t.for&&!t.forProcessed)return Pi(t,e);if(t.if&&!t.ifProcessed)return Li(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Ui(t,e);let r=`_t(${n}${o?`,function(){return ${o}}`:""}`;const s=t.attrs||t.dynamicAttrs?Ki((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Ui(e,n,!0);return`_c(${t},${Ri(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Ri(t,e));const r=t.inlineTemplate?null:Ui(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Ui(t,e)||"void 0"}function Ii(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Di(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Mi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Li(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Di(t,e)},${e.onceId++},${n})`:Di(t,e)}return Ii(t,e)}function Li(t,e,n,o){return t.ifProcessed=!0,Fi(t.ifConditions.slice(),e,n,o)}function Fi(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Fi(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Mi(t,e):Di(t,e)}}function Pi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Di)(t,e)}})`}function Ri(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Ki(t.attrs)},`),t.props&&(n+=`domProps:${Ki(t.props)},`),t.events&&(n+=`${Oi(t.events,!1)},`),t.nativeEvents&&(n+=`${Oi(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Hi(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Bi(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=ji(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Ki(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Hi(t){return 1===t.type&&("slot"===t.tag||t.children.some(Hi))}function Bi(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Li(t,e,Bi,"null");if(t.for&&!t.forProcessed)return Pi(t,e,Bi);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${Ui(t,e)||"undefined"}:undefined`:Ui(t,e)||"undefined":Di(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Ui(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Di)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(zi(r)||r.ifConditions&&r.ifConditions.some((t=>zi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Vi;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function zi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Vi(t,e){return 1===t.type?Di(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Ji(JSON.stringify(t.text))})`}(t)}function Ki(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Ji(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Ji(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function qi(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function Wi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=qi(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>qi(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const Gi=(Zi=function(t,e){const n=ni(t.trim(),e);!1!==e.optimize&&gi(n,e);const o=ji(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=Zi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:Wi(e)}});var Zi;const{compile:Xi,compileToFunctions:Yi}=Gi(pi);let Qi;function ta(t){return Qi=Qi||document.createElement("div"),Qi.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Qi.innerHTML.indexOf("&#10;")>0}const ea=!!U&&ta(!1),na=!!U&&ta(!0),oa=v((t=>{const e=Wn(t);return e&&e.innerHTML})),ra=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&Wn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=oa(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Yi(e,{outputSourceRange:!1,shouldDecodeNewlines:ea,shouldDecodeNewlinesForHref:na,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return ra.call(this,t,e)},$n.compile=Yi,module.exports=$n;
\ No newline at end of file
diff --git a/dist/vue.esm.browser.js b/dist/vue.esm.browser.js
deleted file mode 100644
index 3f78b4d1bbd..00000000000
--- a/dist/vue.esm.browser.js
+++ /dev/null
@@ -1,10446 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
-
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
-}
-
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
-}
-
-let mark;
-let measure;
-{
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-{
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn$2(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
-}
-
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
-}
-
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            {
-                defineReactive(vm, key, result[key], () => {
-                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic$1(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic$1(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-        }, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (Array.isArray(vnode)) {
-                warn$2('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
-}
-
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            warn$2(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`
-                                );
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
-}
-
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
-}
-
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
-}
-
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn$2("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn$2("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
-}
-
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index$1 = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index$1 = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index$1 = 0; index$1 < queue.length; index$1++) {
-        watcher = queue[index$1];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn$2('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index$1 && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (!config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
-}
-
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = expOrFn.toString()
-            ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn$2(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
-}
-
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        warn$2("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        {
-            if (methods && hasOwn(methods, key)) {
-                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            warn$2(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (getter == null) {
-            warn$2(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else {
-            if (key in vm.$data) {
-                warn$2(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        {
-            if (typeof methods[key] !== "function") {
-                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    {
-        dataDef.set = function () {
-            warn$2("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn$2(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
-}
-
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        {
-            initProxy(vm);
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function Vue(options) {
-    if (!(this instanceof Vue)) {
-        warn$2("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
-renderMixin(Vue);
-
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
-}
-
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
-}
-
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
-}
-
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
-}
-
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
-};
-
-var builtInComponents = {
-    KeepAlive,
-};
-
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    {
-        configDef.set = () => {
-            warn$2('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn$2,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
-}
-
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
-Vue.version = '2.6.14';
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
-};
-
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
-}
-
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
-const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
-}
-
-var nodeOps = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createElement: createElement,
-  createElementNS: createElementNS,
-  createTextNode: createTextNode,
-  createComment: createComment,
-  insertBefore: insertBefore,
-  removeChild: removeChild,
-  appendChild: appendChild,
-  parentNode: parentNode,
-  nextSibling: nextSibling,
-  tagName: tagName,
-  setTextContent: setTextContent,
-  setStyleScope: setStyleScope
-});
-
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
-}
-
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn$2('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else {
-                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
-}
-
-var directives$1 = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
-}
-
-var baseModules = [ref, directives$1];
-
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
-};
-
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass$1 = {
-    create: updateClass,
-    update: updateClass,
-};
-
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
-}
-
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
-}
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
-}
-
-let warn$1;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
-
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-};
-
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
-};
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
-}
-
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style$1 = {
-    create: updateStyle,
-    update: updateStyle,
-};
-
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
-    : {};
-
-var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules$1 = platformModules.concat(baseModules);
-const patch = createPatchFunction({ nodeOps, modules: modules$1 });
-
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
-}
-
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
-};
-
-var platformDirectives = {
-    model: directive,
-    show,
-};
-
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (children.length > 1) {
-            warn$2('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn$2('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
-};
-
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn$2(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
-}
-
-var platformComponents = {
-    Transition,
-    TransitionGroup,
-};
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
-}
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
-}
-
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
-};
-
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
-};
-
-let decoder;
-var he = {
-    decode(html) {
-        decoder = decoder || document.createElement('div');
-        decoder.innerHTML = html;
-        return decoder.textContent;
-    },
-};
-
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
-}
-
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he.decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
-}
-
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model = {
-    preTransformNode,
-};
-
-var modules = [klass, style, model];
-
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
-}
-
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
-}
-
-var directives = {
-    model: model$1,
-    text,
-    html,
-};
-
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
-};
-
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
-}
-
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
-}
-
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-}
-
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
-}
-
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
-};
-
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-}
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
-}
-
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
-}
-
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
-}
-
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = typeof (msg) === 'string' ? { msg } : msg;
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
-}
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize(ast, options);
-    }
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
-});
-
-const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-// check whether current browser encodes a char inside attribute values
-let div;
-function getShouldDecode(href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-    return div.innerHTML.indexOf('&#10;') > 0;
-}
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-// #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
-    ? getShouldDecode(true)
-    : false;
-
-const idToTemplate = cached((id) => {
-    const el = query(id);
-    return el && el.innerHTML;
-});
-const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && query(el);
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-        warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-        return this;
-    }
-    const options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-        let template = options.template;
-        if (template) {
-            if (typeof template === 'string') {
-                if (template.charAt(0) === '#') {
-                    template = idToTemplate(template);
-                    /* istanbul ignore if */
-                    if (!template) {
-                        warn$2(`Template element not found or is empty: ${options.template}`, this);
-                    }
-                }
-            }
-            else if (template.nodeType) {
-                template = template.innerHTML;
-            }
-            else {
-                {
-                    warn$2('invalid template option:' + template, this);
-                }
-                return this;
-            }
-        }
-        else if (el) {
-            // @ts-expect-error
-            template = getOuterHTML(el);
-        }
-        if (template) {
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile');
-            }
-            const { render, staticRenderFns } = compileToFunctions(template, {
-                outputSourceRange: "development" !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
-                delimiters: options.delimiters,
-                comments: options.comments,
-            }, this);
-            options.render = render;
-            options.staticRenderFns = staticRenderFns;
-            /* istanbul ignore if */
-            if (config.performance && mark) {
-                mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
-            }
-        }
-    }
-    return mount.call(this, el, hydrating);
-};
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el) {
-    if (el.outerHTML) {
-        return el.outerHTML;
-    }
-    else {
-        const container = document.createElement('div');
-        container.appendChild(el.cloneNode(true));
-        return container.innerHTML;
-    }
-}
-Vue.compile = compileToFunctions;
-
-export { Vue as default };
diff --git a/dist/vue.esm.browser.min.js b/dist/vue.esm.browser.min.js
deleted file mode 100644
index 552fbd0e84b..00000000000
--- a/dist/vue.esm.browser.min.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const I=["component","directive","filter"],M=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:M};const F=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function P(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function R(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const H=new RegExp(`[^${F.source}.$_\\d]`);const B="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,V=z&&WXEnvironment.platform.toLowerCase(),K=U&&window.navigator.userAgent.toLowerCase(),J=K&&/msie|trident/.test(K),q=K&&K.indexOf("msie 9.0")>0,W=K&&K.indexOf("edge/")>0;K&&K.indexOf("android");const G=K&&/iphone|ipad|ipod|ios/.test(K)||"ios"===V;K&&/chrome\/\d+/.test(K),K&&/phantomjs/.test(K);const Z=K&&K.match(/firefox\/(\d+)/),X={}.watch;let Y,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const tt=()=>(void 0===Y&&(Y=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Y),et=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function nt(t){return"function"==typeof t&&/native code/.test(t.toString())}const ot="undefined"!=typeof Symbol&&nt(Symbol)&&"undefined"!=typeof Reflect&&nt(Reflect.ownKeys);let rt;rt="undefined"!=typeof Set&&nt(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let st=S,it=0;class at{static target;id;subs;constructor(){this.id=it++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){at.target&&at.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}at.target=null;const ct=[];function lt(t){ct.push(t),at.target=t}function ut(){ct.pop(),at.target=ct[ct.length-1]}class ft{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const dt=(t="")=>{const e=new ft;return e.text=t,e.isComment=!0,e};function pt(t){return new ft(void 0,void 0,void 0,String(t))}function ht(t){const e=new ft(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const mt=Array.prototype,yt=Object.create(mt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=mt[t];R(yt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const gt=Object.getOwnPropertyNames(yt);let vt=!0;function $t(t){vt=t}class _t{value;dep;vmCount;constructor(t){this.value=t,this.dep=new at,this.vmCount=0,R(t,"__ob__",this),Array.isArray(t)?(B?function(t,e){t.__proto__=e}(t,yt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];R(t,r,e[r])}}(t,yt,gt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)wt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ft)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!tt()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function wt(t,e,n,o,r){const s=new at,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return at.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&kt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(wt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function xt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function kt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&kt(e)}const At=L.optionMergeStrategies;function Ot(t,e){if(!e)return t;let n,o,r;const s=ot?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&Ot(o,r):Ct(t,n,r));return t}function St(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?Ot(o,r):r}:e?t?function(){return Ot("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Tt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Nt(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}At.data=function(t,e,n){return n?St(t,e,n):e&&"function"!=typeof e?t:St(t,e)},M.forEach((t=>{At[t]=Tt})),I.forEach((function(t){At[t+"s"]=Nt})),At.watch=function(t,e,n,o){if(t===X&&(t=void 0),e===X&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},At.provide=St;const Et=function(t,e){return void 0===e?t:e};function jt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=jt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=jt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=At[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function Dt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function It(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Pt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Pt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Lt(e.type)?o.call(t):o}(o,r,t);const e=vt;$t(!0),bt(i),$t(e)}return i}const Mt=/^\s*function (\w+)/;function Lt(t){const e=t&&t.toString().match(Mt);return e?e[1]:""}function Ft(t,e){return Lt(t)===Lt(e)}function Pt(t,e){if(!Array.isArray(e))return Ft(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Ft(e[n],t))return n;return-1}function Rt(t,e,n){lt();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Bt(t,o,"errorCaptured hook")}}}Bt(t,e,n)}finally{ut()}}function Ht(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Rt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Rt(t,o,r)}return s}function Bt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Vt=[];let Kt,Jt=!1;function qt(){Jt=!1;const t=Vt.slice(0);Vt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&nt(Promise)){const t=Promise.resolve();Kt=()=>{t.then(qt),G&&setTimeout(S)},zt=!0}else if(J||"undefined"==typeof MutationObserver||!nt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Kt="undefined"!=typeof setImmediate&&nt(setImmediate)?()=>{setImmediate(qt)}:()=>{setTimeout(qt,0)};else{let t=1;const e=new MutationObserver(qt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Kt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Wt(t,e){let n;if(Vt.push((()=>{if(t)try{t.call(e)}catch(t){Rt(t,e,"nextTick")}else n&&n(e)})),Jt||(Jt=!0,Kt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Gt=new rt;function Zt(t){Xt(t,Gt),Gt.clear()}function Xt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ft)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Xt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Xt(t[o[n]],e)}}const Yt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ht(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ht(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function te(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Yt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Yt(c),s(f.name,n[c],f.capture))}function ee(t,r,s){let i;t instanceof ft&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ne(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function oe(t){return r(t)?[pt(t)]:Array.isArray(t)?se(t):void 0}function re(t){return n(t)&&n(t.text)&&!1===t.isComment}function se(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=se(c,`${s||""}_${a}`),re(c[0])&&re(u)&&(i[l]=pt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?re(u)?i[l]=pt(u.text+c):""!==c&&i.push(pt(c)):re(c)&&re(u)?i[l]=pt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ie(t,e){if(t){const n=Object.create(null),o=ot?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ae(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ce)&&delete n[t];return n}function ce(t){return t.isComment&&!t.asyncFactory||" "===t.text}function le(t){return t.isComment&&t.asyncFactory}function ue(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=fe(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=de(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),R(r,"$stable",i),R(r,"$key",a),R(r,"$hasNormal",s),r}function fe(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:oe(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!le(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function de(t,e){return()=>t[e]}function pe(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(ot&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function he(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function me(t){return Dt(this.$options,"filters",t)||N}function ye(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ge(t,e,n,o,r){const s=L.keyCodes[e]||n;return r&&o&&!L.keyCodes[e]?ye(r,o):s?ye(s,t):o?C(o)!==e:void 0===t}function ve(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||L.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function $e(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),be(o,`__static__${t}`,!1)),o}function _e(t,e,n){return be(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function be(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&we(t[o],`${e}_${o}`,n);else we(t,e,n)}function we(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Ce(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function xe(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?xe(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function ke(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function Oe(t){t._o=_e,t._n=f,t._s=u,t._l=pe,t._t=he,t._q=E,t._i=j,t._m=$e,t._f=me,t._k=ge,t._b=ve,t._v=pt,t._e=dt,t._u=xe,t._g=Ce,t._d=ke,t._p=Ae}function Se(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ie(a.inject,s),this.slots=()=>(this.$slots||ue(e.scopedSlots,this.$slots=ae(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ue(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ue(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Me(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Me(c,t,e,n,o,u)}function Te(t,e,n,o,r){const s=ht(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ne(t,e){for(const n in e)t[_(n)]=e[n]}Oe(Se.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Ke)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){$t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=It(s,i,n,e)}$t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ve(e,o,u),l&&(e.$slots=ae(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ze(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ye.push(o)):We(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ge(e,!0):e.$destroy())}},je=Object.keys(Ee);function De(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Pe;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=Re(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=Re(h.error,r)),n(h.loading)&&(t.loadingComp=Re(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=dt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ne(i,c,t,e,!0)||ne(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=It(e,l,o||t);else n(r.attrs)&&Ne(c,r.attrs),n(r.props)&&Ne(c,r.props);const u=new Se(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ft)return Te(f,r,u.parent,a);if(Array.isArray(f)){const t=oe(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Te(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<je.length;t++){const n=je[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?Ie(r,o):r)}}(i);const y=r.options.name||u;return new ft(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Ie(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Me(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return dt();n(o)&&n(o.is)&&(e=o.is);if(!e)return dt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=oe(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),a=L.isReservedTag(e)?new ft(L.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=Dt(t.$options,"components",e))?new ft(e,o,r,void 0,void 0,t):De(s,o,t,r,e)}else a=De(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Le(a,c),n(o)&&function(t){s(t.style)&&Zt(t.style);s(t.class)&&Zt(t.class)}(o),a):dt()}(t,e,i,a,c)}function Le(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Le(a,r,s)}}let Fe,Pe=null;function Re(t,e){return(t.__esModule||ot&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function He(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||le(o)))return o}}function Be(t,e){Fe.$on(t,e)}function Ue(t,e){Fe.$off(t,e)}function ze(t,e){const n=Fe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ve(t,e,n){Fe=t,te(e,n||{},Be,Ue,ze,t),Fe=void 0}let Ke=null;function Je(t){const e=Ke;return Ke=t,()=>{Ke=e}}function qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function We(t,e){if(e){if(t._directInactive=!1,qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)We(t.$children[e]);Ze(t,"activated")}}function Ge(t,e){if(!(e&&(t._directInactive=!0,qe(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ge(t.$children[e]);Ze(t,"deactivated")}}function Ze(t,e){lt();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ht(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ut()}const Xe=[],Ye=[];let Qe={},tn=!1,en=!1,nn=0;let on=0,rn=Date.now;if(U&&!J){const t=window.performance;t&&"function"==typeof t.now&&rn()>document.createEvent("Event").timeStamp&&(rn=()=>t.now())}function sn(){let t,e;for(on=rn(),en=!0,Xe.sort(((t,e)=>t.id-e.id)),nn=0;nn<Xe.length;nn++)t=Xe[nn],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Ye.slice(),o=Xe.slice();nn=Xe.length=Ye.length=0,Qe={},tn=en=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,We(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ze(o,"updated")}}(o),et&&L.devtools&&et.emit("flush")}let an=0;class cn{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++an,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new rt,this.newDepIds=new rt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(H.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;lt(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Rt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Zt(t),ut(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,en){let e=Xe.length-1;for(;e>nn&&Xe[e].id>t.id;)e--;Xe.splice(e+1,0,t)}else Xe.push(t);tn||(tn=!0,Wt(sn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Ht(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const ln={enumerable:!0,configurable:!0,get:S,set:S};function un(t,e,n){ln.get=function(){return this[e][n]},ln.set=function(t){this[e][n]=t},Object.defineProperty(t,n,ln)}function fn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&$t(!1);for(const s in e){r.push(s);wt(o,s,It(s,e,n,t)),s in t||un(t,"_props",s)}$t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){lt();try{return t.call(e,e)}catch(t){return Rt(t,e,"data()"),{}}finally{ut()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||P(e)||un(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=tt();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new cn(t,i||S,S,dn)),r in t||pn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==X&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)yn(t,n,o[e]);else yn(t,n,o)}}(t,e.watch)}const dn={lazy:!0};function pn(t,e,n){const o=!tt();"function"==typeof n?(ln.get=o?hn(e):mn(n),ln.set=S):(ln.get=n.get?o&&!1!==n.cache?hn(e):mn(n.get):S,ln.set=n.set||S),Object.defineProperty(t,e,ln)}function hn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),at.target&&e.depend(),e.value}}function mn(t){return function(){return t.call(this,this)}}function yn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let gn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=jt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function $n(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=jt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)un(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)pn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,I.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function wn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&xn(n,t,o,r)}}}function xn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=gn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=jt(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ve(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ae(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Me(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Me(e,t,n,o,r,!0);const s=o&&o.data;wt(e,"$attrs",s&&s.attrs||t,null,!0),wt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ze(n,"beforeCreate"),function(t){const e=ie(t.$options.inject,t);e&&($t(!1),Object.keys(e).forEach((n=>{wt(t,n,e[n])})),$t(!0))}(n),fn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ze(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}($n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=xt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return yn(o,t,e,n);(n=n||{}).user=!0;const r=new cn(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;lt(),Ht(e,o,[r.value],o,t),ut()}return function(){r.teardown()}}}($n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ht(n[t],e,o,e,r)}return e}}($n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=Je(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ze(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ze(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}($n),function(t){Oe(t.prototype),t.prototype.$nextTick=function(t){return Wt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ue(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Pe=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Rt(e,t,"render"),o=t._vnode}finally{Pe=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ft||(o=dt()),o.parent=n,o}}($n);const kn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:kn,exclude:kn,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:bn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&xn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)xn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{Cn(this,(e=>wn(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!wn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=He(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!wn(o,t))||r&&t&&wn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>L};Object.defineProperty(t,"config",e),t.util={warn:st,extend:A,mergeOptions:jt,defineReactive:wt},t.set=Ct,t.delete=xt,t.nextTick=Wt,t.observable=t=>(bt(t),t),t.options=Object.create(null),I.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=jt(this.options,t),this}}(t),_n(t),function(t){I.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}($n),Object.defineProperty($n.prototype,"$isServer",{get:tt}),Object.defineProperty($n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty($n,"FunctionalRenderContext",{value:Se}),$n.version="2.6.14";const On=d("style,class"),Sn=d("input,textarea,option,select,progress"),Tn=(t,e,n)=>"value"===n&&Sn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,Nn=d("contenteditable,draggable,spellcheck"),En=d("events,caret,typing,plaintext-only"),jn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Dn="http://www.w3.org/1999/xlink",In=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Mn=t=>In(t)?t.slice(6,t.length):"",Ln=t=>null==t||!1===t;function Fn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Pn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Pn(e,o.data));return function(t,e){if(n(t)||n(e))return Rn(t,Hn(e));return""}(e.staticClass,e.class)}function Pn(t,e){return{staticClass:Rn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Rn(t,e){return t?e?t+" "+e:t:e||""}function Hn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Hn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Bn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Un=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Vn=t=>Un(t)||zn(t);function Kn(t){return zn(t)?"svg":"math"===t?"math":void 0}const Jn=Object.create(null);const qn=d("text,number,password,search,email,tel,url");function Wn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var Gn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Bn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Zn={create(t,e){Xn(e)},update(t,e){t.data.ref!==e.data.ref&&(Xn(t,!0),Xn(e))},destroy(t){Xn(t,!0)}};function Xn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?m(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Yn=new ft("",{},[]),Qn=["create","activate","update","remove","destroy"];function to(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||qn(r)&&qn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function eo(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var no={create:oo,update:oo,destroy:function(t){oo(t,Yn)}};function oo(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Yn,o=e===Yn,r=so(t.data.directives,t.context),s=so(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,ao(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(ao(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)ao(i[n],"inserted",e,t)};n?ee(e,"insert",o):o()}a.length&&ee(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)ao(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||ao(r[c],"unbind",t,t,o)}(t,e)}const ro=Object.create(null);function so(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=ro),n[io(r)]=r,r.def=Dt(e.$options,"directives",r.name);return n}function io(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function ao(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Rt(o,n.context,`directive ${t.name} ${e} hook`)}}var co=[Zn,no];function lo(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&uo(c,s,i,o.data.pre);for(s in(J||W)&&u.value!==l.value&&uo(c,"value",u.value),l)e(u[s])&&(In(s)?c.removeAttributeNS(Dn,Mn(s)):Nn(s)||c.removeAttribute(s))}function uo(t,e,n,o){o||t.tagName.indexOf("-")>-1?fo(t,e,n):jn(e)?Ln(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Nn(e)?t.setAttribute(e,((t,e)=>Ln(e)||"false"===e?"false":"contenteditable"===t&&En(e)?e:"true")(e,n)):In(e)?Ln(n)?t.removeAttributeNS(Dn,Mn(e)):t.setAttributeNS(Dn,e,n):fo(t,e,n)}function fo(t,e,n){if(Ln(n))t.removeAttribute(e);else{if(J&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var po={create:lo,update:lo};function ho(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Fn(o);const c=r._transitionClasses;n(c)&&(a=Rn(a,Hn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var mo={create:ho,update:ho};const yo=/[\w).+\-_$\]]/;function go(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&yo.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=vo(r,s[o]);return r}function vo(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function $o(t,e){console.error(`[Vue compiler]: ${t}`)}function _o(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function bo(t,e,n,o,r){(t.props||(t.props=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function wo(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(No({name:e,value:n,dynamic:r},o)),t.plain=!1}function Co(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(No({name:e,value:n},o))}function xo(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(No({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function ko(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Ao(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=ko("!",n,c)),r.once&&(delete r.once,n=ko("~",n,c)),r.passive&&(delete r.passive,n=ko("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=No({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function Oo(t,e,n){const o=So(t,":"+e)||So(t,"v-bind:"+e);if(null!=o)return go(o);if(!1!==n){const n=So(t,e);if(null!=n)return JSON.stringify(n)}}function So(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function To(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function No(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function Eo(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=jo(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function jo(t,e){const n=function(t){if(t=t.trim(),Do=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Do-1)return Lo=t.lastIndexOf("."),Lo>-1?{exp:t.slice(0,Lo),key:'"'+t.slice(Lo+1)+'"'}:{exp:t,key:null};Io=t,Lo=Fo=Po=0;for(;!Ho();)Mo=Ro(),Bo(Mo)?zo(Mo):91===Mo&&Uo(Mo);return{exp:t.slice(0,Fo),key:t.slice(Fo+1,Po)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Do,Io,Mo,Lo,Fo,Po;function Ro(){return Io.charCodeAt(++Lo)}function Ho(){return Lo>=Do}function Bo(t){return 34===t||39===t}function Uo(t){let e=1;for(Fo=Lo;!Ho();)if(Bo(t=Ro()))zo(t);else if(91===t&&e++,93===t&&e--,0===e){Po=Lo;break}}function zo(t){const e=t;for(;!Ho()&&(t=Ro())!==e;);}let Vo;function Ko(t,e,n){const o=Vo;return function r(){const s=e.apply(null,arguments);null!==s&&Wo(t,r,n,o)}}const Jo=zt&&!(Z&&Number(Z[1])<=53);function qo(t,e,n,o){if(Jo){const t=on,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Vo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function Wo(t,e,n,o){(o||Vo).removeEventListener(t,e._wrapper||e,n)}function Go(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Vo=o.elm||t.elm,function(t){if(n(t.__r)){const e=J?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),te(r,s,qo,Wo,Ko,o.context),Vo=void 0}var Zo={create:Go,update:Go,destroy:t=>Go(t,Yn)};let Xo;function Yo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);Qo(i,t)&&(i.value=t)}else if("innerHTML"===r&&zn(i.tagName)&&e(i.innerHTML)){Xo=Xo||document.createElement("div"),Xo.innerHTML=`<svg>${s}</svg>`;const t=Xo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function Qo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var tr={create:Yo,update:Yo};const er=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function nr(t){const e=or(t.style);return t.staticStyle?A(t.staticStyle,e):e}function or(t){return Array.isArray(t)?O(t):"string"==typeof t?er(t):t}const rr=/^--/,sr=/\s*!important$/,ir=(t,e,n)=>{if(rr.test(e))t.style.setProperty(e,n);else if(sr.test(n))t.style.setProperty(C(e),n.replace(sr,""),"important");else{const o=lr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},ar=["Webkit","Moz","ms"];let cr;const lr=v((function(t){if(cr=cr||document.createElement("div").style,"filter"!==(t=_(t))&&t in cr)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<ar.length;t++){const n=ar[t]+e;if(n in cr)return n}}));function ur(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=or(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=nr(e.data))&&A(n,o)}(o=nr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=nr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&ir(c,a,"");for(a in p)i=p[a],i!==f[a]&&ir(c,a,null==i?"":i)}var fr={create:ur,update:ur};const dr=/\s+/;function pr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function hr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(dr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function mr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,yr(t.name||"v")),A(e,t),e}return"string"==typeof t?yr(t):void 0}}const yr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),gr=U&&!q;let vr="transition",$r="transitionend",_r="animation",br="animationend";gr&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(vr="WebkitTransition",$r="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(_r="WebkitAnimation",br="webkitAnimationEnd"));const wr=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Cr(t){wr((()=>{wr(t)}))}function xr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),pr(t,e))}function kr(t,e){t._transitionClasses&&m(t._transitionClasses,e),hr(t,e)}function Ar(t,e,n){const{type:o,timeout:r,propCount:s}=Sr(t,e);if(!o)return n();const i="transition"===o?$r:br;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Or=/\b(transform|all)(,|$)/;function Sr(t,e){const n=window.getComputedStyle(t),o=(n[vr+"Delay"]||"").split(", "),r=(n[vr+"Duration"]||"").split(", "),s=Tr(o,r),i=(n[_r+"Delay"]||"").split(", "),a=(n[_r+"Duration"]||"").split(", "),c=Tr(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Or.test(n[vr+"Property"])}}function Tr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Nr(e)+Nr(t[n]))))}function Nr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Er(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=mr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Ke,A=Ke.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,j=O&&"function"==typeof b?b:g,I=O&&w||v,M=O&&C||$,L=f(s(x)?x.enter:x),F=!1!==a&&!q,P=Ir(j),R=r._enterCb=D((()=>{F&&(kr(r,N),kr(r,T)),R.cancelled?(F&&kr(r,S),M&&M(r)):I&&I(r),r._enterCb=null}));t.data.show||ee(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),E&&E(r),F&&(xr(r,S),xr(r,T),Cr((()=>{kr(r,S),R.cancelled||(xr(r,N),P||(Dr(L)?setTimeout(R,L):Ar(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function jr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=mr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!q,_=Ir(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(kr(r,u),kr(r,d)),w.cancelled?($&&kr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(xr(r,l),xr(r,d),Cr((()=>{kr(r,l),w.cancelled||(xr(r,u),_||(Dr(b)?setTimeout(w,b):Ar(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Dr(t){return"number"==typeof t&&!isNaN(t)}function Ir(t){if(e(t))return!1;const o=t.fns;return n(o)?Ir(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Mr(t,e){!0!==e.data.show&&Er(e)}const Lr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Qn.length;++s)for(a[Qn[s]]=[],i=0;i<c.length;++i)n(c[i][Qn[s]])&&a[Qn[s]].push(c[i][Qn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=ht(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Yn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Xn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Yn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Ke)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&to(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=ht(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:to(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):to(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):to(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):to(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=eo(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],to(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Zt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&to(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new ft(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Yn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Xn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:Gn,modules:[po,mo,Zo,tr,fr,U?{create:Mr,activate:Mr,remove(t,e){!0!==t.data.show?jr(t,e):e()}}:{}].concat(co)});q&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Vr(t,"input")}));const Fr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ee(n,"postpatch",(()=>{Fr.componentUpdated(t,e,n)})):Pr(t,e,n.context),t._vOptions=[].map.call(t.options,Br)):("textarea"===n.tag||qn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Ur),t.addEventListener("compositionend",zr),t.addEventListener("change",zr),q&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Pr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Br);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>Hr(t,r))):e.value!==e.oldValue&&Hr(e.value,r))&&Vr(t,"change")}}}};function Pr(t,e,n){Rr(t,e),(J||W)&&setTimeout((()=>{Rr(t,e)}),0)}function Rr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Br(i))>-1,i.selected!==s&&(i.selected=s);else if(E(Br(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function Hr(t,e){return e.every((e=>!E(e,t)))}function Br(t){return"_value"in t?t._value:t.value}function Ur(t){t.target.composing=!0}function zr(t){t.target.composing&&(t.target.composing=!1,Vr(t.target,"input"))}function Vr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Kr(t){return!t.componentInstance||t.data&&t.data.transition?t:Kr(t.componentInstance._vnode)}var Jr={bind(t,{value:e},n){const o=(n=Kr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Er(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Kr(o)).data&&o.data.transition?(o.data.show=!0,e?Er(o,(()=>{t.style.display=t.__vOriginalDisplay})):jr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},qr={model:Fr,show:Jr};const Wr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Gr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Gr(He(e.children)):t}function Zr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function Xr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Yr=t=>t.tag||le(t),Qr=t=>"show"===t.name;var ts={name:"transition",props:Wr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Yr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Gr(o);if(!s)return o;if(this._leaving)return Xr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=Zr(this),c=this._vnode,l=Gr(c);if(s.data.directives&&s.data.directives.some(Qr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!le(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ee(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),Xr(t,o);if("in-out"===n){if(le(s))return c;let t;const n=()=>{t()};ee(a,"afterEnter",n),ee(a,"enterCancelled",n),ee(e,"delayLeave",(e=>{t=e}))}}return o}};const es=A({tag:String,moveClass:String},Wr);function ns(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function os(t){t.data.newPos=t.elm.getBoundingClientRect()}function rs(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete es.mode;var ss={Transition:ts,TransitionGroup:{props:es,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=Je(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=Zr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(ns),t.forEach(os),t.forEach(rs),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;xr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener($r,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener($r,t),n._moveCb=null,kr(n,e))})}})))},methods:{hasMove(t,e){if(!gr)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{hr(n,t)})),pr(n,e),n.style.display="none",this.$el.appendChild(n);const o=Sr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};$n.config.mustUseProp=Tn,$n.config.isReservedTag=Vn,$n.config.isReservedAttr=On,$n.config.getTagNamespace=Kn,$n.config.isUnknownElement=function(t){if(!U)return!0;if(Vn(t))return!1;if(t=t.toLowerCase(),null!=Jn[t])return Jn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Jn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Jn[t]=/HTMLUnknownElement/.test(e.toString())},A($n.options.directives,qr),A($n.options.components,ss),$n.prototype.__patch__=U?Lr:S,$n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=dt),Ze(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new cn(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Ze(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ze(t,"mounted")),t}(this,t=t&&U?Wn(t):void 0,e)},U&&setTimeout((()=>{L.devtools&&et&&et.emit("init",$n)}),0);const is=/\{\{((?:.|\r?\n)+?)\}\}/g,as=/[-.*+?^${}()|[\]\/\\]/g,cs=v((t=>{const e=t[0].replace(as,"\\$&"),n=t[1].replace(as,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ls={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=So(t,"class");n&&(t.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const o=Oo(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var us={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=So(t,"style");n&&(t.staticStyle=JSON.stringify(er(n)));const o=Oo(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let fs;var ds={decode:t=>(fs=fs||document.createElement("div"),fs.innerHTML=t,fs.textContent)};const ps=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),hs=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),ms=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ys=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,gs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,vs=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${F.source}]*`,$s=`((?:${vs}\\:)?${vs})`,_s=new RegExp(`^<${$s}`),bs=/^\s*(\/?)>/,ws=new RegExp(`^<\\/${$s}[^>]*>`),Cs=/^<!DOCTYPE [^>]+>/i,xs=/^<!\--/,ks=/^<!\[/,As=d("script,style,textarea",!0),Os={},Ss={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ts=/&(?:lt|gt|quot|amp|#39);/g,Ns=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Es=d("pre,textarea",!0),js=(t,e)=>t&&Es(t)&&"\n"===e[0];function Ds(t,e){const n=e?Ns:Ts;return t.replace(n,(t=>Ss[t]))}const Is=/^@|^v-on:/,Ms=/^v-|^@|^:|^#/,Ls=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Fs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Ps=/^\(|\)$/g,Rs=/^\[.*\]$/,Hs=/:(.*)$/,Bs=/^:|^\.|^v-bind:/,Us=/\.[^.\]]+(?=[^\]]*$)/g,zs=/^v-slot(:|$)|^#/,Vs=/[\r\n]/,Ks=/[ \f\t\r\n]+/g,Js=v(ds.decode);let qs,Ws,Gs,Zs,Xs,Ys,Qs,ti;function ei(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:ci(e),rawAttrsMap:{},parent:n,children:[]}}function ni(t,e){qs=e.warn||$o,Ys=e.isPreTag||T,Qs=e.mustUseProp||T,ti=e.getTagNamespace||T,e.isReservedTag,Gs=_o(e.modules,"transformNode"),Zs=_o(e.modules,"preTransformNode"),Xs=_o(e.modules,"postTransformNode"),Ws=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=oi(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&si(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&si(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),Ys(t.tag)&&(c=!1);for(let n=0;n<Xs.length;n++)Xs[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&As(a)){let n=0;const o=a.toLowerCase(),r=Os[o]||(Os[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,As(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),js(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(xs.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(ks.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Cs);if(n){l(n[0].length);continue}const o=t.match(ws);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),js(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(ws.test(o)||_s.test(o)||xs.test(o)||ks.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(_s);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(bs))&&(r=t.match(gs)||t.match(ys));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&ms(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Ds(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:qs,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||ti(t);J&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];li.test(o.name)||(o.name=o.name.replace(ui,""),e.push(o))}return e}(o));let p=ei(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||tt()||(p.forbidden=!0);for(let t=0;t<Zs.length;t++)p=Zs[t](p,e)||p;a||(!function(t){null!=So(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),Ys(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(ri(p),function(t){const e=So(t,"v-if");if(e)t.if=e,si(t,{exp:e,block:t});else{null!=So(t,"v-else")&&(t.else=!0);const e=So(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=So(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(J&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Js(t):s.length?r?"condense"===r&&Vs.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Ks," ")),!a&&" "!==t&&(e=function(t,e){const n=e?cs(e):is;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=go(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Ws))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function oi(t,e){var n;!function(t){const e=Oo(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=Oo(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=So(t,"scope"),t.slotScope=e||So(t,"slot-scope")):(e=So(t,"slot-scope"))&&(t.slotScope=e);const n=Oo(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||wo(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=To(t,zs);if(e){const{name:n,dynamic:o}=ii(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||"_empty_"}}else{const e=To(t,zs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=ii(e),s=n[o]=ei("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||"_empty_",t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=Oo(n,"name")),function(t){let e;(e=Oo(t,"is"))&&(t.component=e);null!=So(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<Gs.length;n++)t=Gs[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Ms.test(r))if(t.hasBindings=!0,a=ai(r.replace(Ms,"")),a&&(r=r.replace(Us,"")),Bs.test(r))r=r.replace(Bs,""),i=go(i),l=Rs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=jo(i,"$event"),l?Ao(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Ao(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Ao(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&Qs(t.tag,t.attrsMap.type,r)?bo(t,r,i,e[n],l):wo(t,r,i,e[n],l);else if(Is.test(r))r=r.replace(Is,""),l=Rs.test(r),l&&(r=r.slice(1,-1)),Ao(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Ms,"");const o=r.match(Hs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Rs.test(c)&&(c=c.slice(1,-1),l=!0)),xo(t,r,s,i,c,l,a,e[n])}else wo(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&Qs(t.tag,t.attrsMap.type,r)&&bo(t,r,"true",e[n])}(t),t}function ri(t){let e;if(e=So(t,"v-for")){const n=function(t){const e=t.match(Ls);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Ps,""),r=o.match(Fs);r?(n.alias=o.replace(Fs,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function si(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function ii(t){let e=t.name.replace(zs,"");return e||"#"!==t.name[0]&&(e="default"),Rs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function ai(t){const e=t.match(Us);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function ci(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const li=/^xmlns:NS\d+/,ui=/^NS\d+:/;function fi(t){return ei(t.tag,t.attrsList.slice(),t.parent)}var di=[ls,us,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=Oo(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=So(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=So(t,"v-else",!0),i=So(t,"v-else-if",!0),a=fi(t);ri(a),Co(a,"type","checkbox"),oi(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,si(a,{exp:a.if,block:a});const c=fi(t);So(c,"v-for",!0),Co(c,"type","radio"),oi(c,e),si(a,{exp:`(${o})==='radio'`+r,block:c});const l=fi(t);return So(l,"v-for",!0),Co(l,":type",o),oi(l,e),si(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const pi={expectHTML:!0,modules:di,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return Eo(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${jo(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Ao(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=Oo(t,"value")||"null",s=Oo(t,"true-value")||"true",i=Oo(t,"false-value")||"false";bo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Ao(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${jo(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${jo(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${jo(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=Oo(t,"value")||"null";r=o?`_n(${r})`:r,bo(t,"checked",`_q(${e},${r})`),Ao(t,"change",jo(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=jo(e,l);a&&(u=`if($event.target.composing)return;${u}`);bo(t,"value",`(${e})`),Ao(t,c,u,null,!0),(i||s)&&Ao(t,"blur","$forceUpdate()")}(t,o,r);else if(!L.isReservedTag(s))return Eo(t,o,r),!1;return!0},text:function(t,e){e.value&&bo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&bo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:ps,mustUseProp:Tn,canBeLeftOpenTag:hs,isReservedTag:Vn,getTagNamespace:Kn,staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(di)};let hi,mi;const yi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function gi(t,e){t&&(hi=yi(e.staticKeys||""),mi=e.isReservedTag||T,vi(t),$i(t,!1))}function vi(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!mi(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every(hi)))}(t),1===t.type){if(!mi(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];vi(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;vi(n),n.static||(t.static=!1)}}}function $i(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)$i(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)$i(t.ifConditions[n].block,e)}}const _i=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,bi=/\([^)]*?\);*$/,wi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Ci={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},xi={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},ki=t=>`if(${t})return null;`,Ai={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:ki("$event.target !== $event.currentTarget"),ctrl:ki("!$event.ctrlKey"),shift:ki("!$event.shiftKey"),alt:ki("!$event.altKey"),meta:ki("!$event.metaKey"),left:ki("'button' in $event && $event.button !== 0"),middle:ki("'button' in $event && $event.button !== 1"),right:ki("'button' in $event && $event.button !== 2")};function Oi(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Si(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Si(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Si(t))).join(",")}]`;const e=wi.test(t.value),n=_i.test(t.value),o=wi.test(t.value.replace(bi,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ai[e])s+=Ai[e],Ci[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=ki(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Ti).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ti(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Ci[t],o=xi[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Ni={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Ei{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(t){this.options=t,this.warn=t.warn||$o,this.transforms=_o(t.modules,"transformCode"),this.dataGenFns=_o(t.modules,"genData"),this.directives=A(A({},Ni),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function ji(t,e){const n=new Ei(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Di(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Di(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ii(t,e);if(t.once&&!t.onceProcessed)return Mi(t,e);if(t.for&&!t.forProcessed)return Pi(t,e);if(t.if&&!t.ifProcessed)return Li(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=Ui(t,e);let r=`_t(${n}${o?`,function(){return ${o}}`:""}`;const s=t.attrs||t.dynamicAttrs?Ki((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:Ui(e,n,!0);return`_c(${t},${Ri(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=Ri(t,e));const r=t.inlineTemplate?null:Ui(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return Ui(t,e)||"void 0"}function Ii(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Di(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Mi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Li(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Di(t,e)},${e.onceId++},${n})`:Di(t,e)}return Ii(t,e)}function Li(t,e,n,o){return t.ifProcessed=!0,Fi(t.ifConditions.slice(),e,n,o)}function Fi(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Fi(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Mi(t,e):Di(t,e)}}function Pi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Di)(t,e)}})`}function Ri(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Ki(t.attrs)},`),t.props&&(n+=`domProps:${Ki(t.props)},`),t.events&&(n+=`${Oi(t.events,!1)},`),t.nativeEvents&&(n+=`${Oi(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Hi(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&"_empty_"!==e.slotScope||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Bi(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=ji(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Ki(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Hi(t){return 1===t.type&&("slot"===t.tag||t.children.some(Hi))}function Bi(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Li(t,e,Bi,"null");if(t.for&&!t.forProcessed)return Pi(t,e,Bi);const o="_empty_"===t.slotScope?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${Ui(t,e)||"undefined"}:undefined`:Ui(t,e)||"undefined":Di(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function Ui(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Di)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(zi(r)||r.ifConditions&&r.ifConditions.some((t=>zi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Vi;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function zi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Vi(t,e){return 1===t.type?Di(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Ji(JSON.stringify(t.text))})`}(t)}function Ki(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Ji(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Ji(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function qi(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function Wi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=qi(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>qi(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const Gi=(Zi=function(t,e){const n=ni(t.trim(),e);!1!==e.optimize&&gi(n,e);const o=ji(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=Zi(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:Wi(e)}});var Zi;const{compile:Xi,compileToFunctions:Yi}=Gi(pi);let Qi;function ta(t){return Qi=Qi||document.createElement("div"),Qi.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',Qi.innerHTML.indexOf("&#10;")>0}const ea=!!U&&ta(!1),na=!!U&&ta(!0),oa=v((t=>{const e=Wn(t);return e&&e.innerHTML})),ra=$n.prototype.$mount;$n.prototype.$mount=function(t,e){if((t=t&&Wn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=oa(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=Yi(e,{outputSourceRange:!1,shouldDecodeNewlines:ea,shouldDecodeNewlinesForHref:na,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return ra.call(this,t,e)},$n.compile=Yi;export{$n as default};
\ No newline at end of file
diff --git a/dist/vue.esm.js b/dist/vue.esm.js
deleted file mode 100644
index b986f24df11..00000000000
--- a/dist/vue.esm.js
+++ /dev/null
@@ -1,10500 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
-
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
-}
-
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-        // skip validation for weex recycle-list child component props
-        !(false  )) {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    if (process.env.NODE_ENV !== 'production') {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
-}
-
-let mark;
-let measure;
-if (process.env.NODE_ENV !== 'production') {
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-if (process.env.NODE_ENV !== 'production') {
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn$2(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
-}
-
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
-}
-
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            if (process.env.NODE_ENV !== 'production') {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], () => {
-                    warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-            else {
-                defineReactive(vm, key, result[key]);
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else if (process.env.NODE_ENV !== 'production') {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic$1(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic$1(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (process.env.NODE_ENV !== 'production' &&
-            key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    if (process.env.NODE_ENV !== 'production') {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        if (process.env.NODE_ENV !== 'production') {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (process.env.NODE_ENV !== 'production' &&
-        isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (process.env.NODE_ENV !== 'production' &&
-                isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-        }, true);
-    }
-    else {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-                warn$2('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
-}
-
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(process.env.NODE_ENV !== 'production'
-                                ? `timeout (${res.timeout}ms)`
-                                : null);
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
-}
-
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
-}
-
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        if (process.env.NODE_ENV !== 'production') {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
-}
-
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== "production") {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn$2("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn$2("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
-}
-
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index$1 = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index$1 = queue.length = activatedChildren.length = 0;
-    has = {};
-    if (process.env.NODE_ENV !== 'production') {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index$1 = 0; index$1 < queue.length; index$1++) {
-        watcher = queue[index$1];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn$2('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index$1 && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (process.env.NODE_ENV !== 'production' && !config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
-}
-
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = process.env.NODE_ENV !== 'production'
-            ? expOrFn.toString()
-            : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' && warn$2(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
-}
-
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== "production") {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn$2(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        else {
-            defineReactive(props, key, value);
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        process.env.NODE_ENV !== "production" &&
-            warn$2("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        if (process.env.NODE_ENV !== "production") {
-            if (methods && hasOwn(methods, key)) {
-                warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== "production" &&
-                warn$2(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== "production" && getter == null) {
-            warn$2(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else if (process.env.NODE_ENV !== "production") {
-            if (key in vm.$data) {
-                warn$2(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (process.env.NODE_ENV !== "production" &&
-        sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        if (process.env.NODE_ENV !== "production") {
-            if (typeof methods[key] !== "function") {
-                warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    if (process.env.NODE_ENV !== "production") {
-        dataDef.set = function () {
-            warn$2("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn$2(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
-}
-
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            initProxy(vm);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function Vue(options) {
-    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
-        warn$2("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
-renderMixin(Vue);
-
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
-}
-
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
-}
-
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (process.env.NODE_ENV !== 'production' && name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
-}
-
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (process.env.NODE_ENV !== 'production' && type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
-}
-
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
-};
-
-var builtInComponents = {
-    KeepAlive,
-};
-
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    if (process.env.NODE_ENV !== 'production') {
-        configDef.set = () => {
-            warn$2('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn$2,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
-}
-
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
-Vue.version = '2.6.14';
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
-};
-
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
-}
-
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
-const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
-}
-
-var nodeOps = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createElement: createElement,
-  createElementNS: createElementNS,
-  createTextNode: createTextNode,
-  createComment: createComment,
-  insertBefore: insertBefore,
-  removeChild: removeChild,
-  appendChild: appendChild,
-  parentNode: parentNode,
-  nextSibling: nextSibling,
-  tagName: tagName,
-  setTextContent: setTextContent,
-  setStyleScope: setStyleScope
-});
-
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
-}
-
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            if (process.env.NODE_ENV !== 'production') {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn$2('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            if (process.env.NODE_ENV !== 'production') {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        if (process.env.NODE_ENV !== 'production') {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        if (process.env.NODE_ENV !== 'production') {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else if (process.env.NODE_ENV !== 'production') {
-                            warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
-}
-
-var directives$1 = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
-}
-
-var baseModules = [ref, directives$1];
-
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
-};
-
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass$1 = {
-    create: updateClass,
-    update: updateClass,
-};
-
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
-}
-
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' &&
-        warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
-}
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
-}
-
-let warn$1;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-function model$1(el, dir, _warn) {
-    warn$1 = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else if (!config.isReservedTag(tag)) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$1(`<${el.tag} v-model="${value}">: ` +
-            `v-model is not supported on this element type. ` +
-            "If you are working with contenteditable, it's recommended to " +
-            'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
-
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-};
-
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
-};
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
-}
-
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style$1 = {
-    create: updateStyle,
-    update: updateStyle,
-};
-
-const whitespaceRE$1 = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn$2(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
-    : {};
-
-var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules$1 = platformModules.concat(baseModules);
-const patch = createPatchFunction({ nodeOps, modules: modules$1 });
-
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
-}
-
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
-};
-
-var platformDirectives = {
-    model: directive,
-    show,
-};
-
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-            warn$2('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (process.env.NODE_ENV !== 'production' &&
-            mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn$2('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
-};
-
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else if (process.env.NODE_ENV !== "production") {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn$2(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
-}
-
-var platformComponents = {
-    Transition,
-    TransitionGroup,
-};
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else if (process.env.NODE_ENV !== 'production' &&
-                process.env.NODE_ENV !== 'test') {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (process.env.NODE_ENV !== 'production' &&
-            process.env.NODE_ENV !== 'test' &&
-            config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
-}
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
-}
-
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (process.env.NODE_ENV !== 'production' && staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
-};
-
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
-};
-
-let decoder;
-var he = {
-    decode(html) {
-        decoder = decoder || document.createElement('div');
-        decoder.innerHTML = html;
-        return decoder.textContent;
-    },
-};
-
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (process.env.NODE_ENV !== 'production' &&
-                !stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    (i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
-}
-
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he.decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                process.env.NODE_ENV !== 'production' &&
-                    warn('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (process.env.NODE_ENV !== 'production' &&
-                        options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (el.tag === 'template') {
-                warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (el.slotTarget || el.slotScope) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (!maybeComponent(el)) {
-                        warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (process.env.NODE_ENV !== 'production' &&
-                    value.trim().length === 0) {
-                    warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (process.env.NODE_ENV !== 'production' && name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            if (process.env.NODE_ENV !== 'production') {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (process.env.NODE_ENV !== 'production' &&
-            map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
-}
-
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model = {
-    preTransformNode,
-};
-
-var modules = [klass, style, model];
-
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
-}
-
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
-}
-
-var directives = {
-    model: model$1,
-    text,
-    html,
-};
-
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
-};
-
-let isStaticKey;
-let isPlatformReservedTag;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
-}
-
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
-}
-
-function on(el, dir) {
-    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-}
-
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
-}
-
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
-};
-
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            process.env.NODE_ENV !== 'production' &&
-                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (process.env.NODE_ENV !== 'production' &&
-        state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if (process.env.NODE_ENV !== 'production' &&
-        (el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-}
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
-}
-
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
-}
-
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        if (process.env.NODE_ENV !== 'production') {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
-}
-
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = typeof (msg) === 'string' ? { msg } : msg;
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            if (process.env.NODE_ENV !== 'production') {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
-}
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize(ast, options);
-    }
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
-});
-
-const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-// check whether current browser encodes a char inside attribute values
-let div;
-function getShouldDecode(href) {
-    div = div || document.createElement('div');
-    div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-    return div.innerHTML.indexOf('&#10;') > 0;
-}
-// #3663: IE encodes newlines inside attribute values while other browsers don't
-const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-// #6828: chrome encodes content in a[href]
-const shouldDecodeNewlinesForHref = inBrowser
-    ? getShouldDecode(true)
-    : false;
-
-const idToTemplate = cached((id) => {
-    const el = query(id);
-    return el && el.innerHTML;
-});
-const mount = Vue.prototype.$mount;
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && query(el);
-    /* istanbul ignore if */
-    if (el === document.body || el === document.documentElement) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-        return this;
-    }
-    const options = this.$options;
-    // resolve template/el and convert to render function
-    if (!options.render) {
-        let template = options.template;
-        if (template) {
-            if (typeof template === 'string') {
-                if (template.charAt(0) === '#') {
-                    template = idToTemplate(template);
-                    /* istanbul ignore if */
-                    if (process.env.NODE_ENV !== 'production' && !template) {
-                        warn$2(`Template element not found or is empty: ${options.template}`, this);
-                    }
-                }
-            }
-            else if (template.nodeType) {
-                template = template.innerHTML;
-            }
-            else {
-                if (process.env.NODE_ENV !== 'production') {
-                    warn$2('invalid template option:' + template, this);
-                }
-                return this;
-            }
-        }
-        else if (el) {
-            // @ts-expect-error
-            template = getOuterHTML(el);
-        }
-        if (template) {
-            /* istanbul ignore if */
-            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-                mark('compile');
-            }
-            const { render, staticRenderFns } = compileToFunctions(template, {
-                outputSourceRange: process.env.NODE_ENV !== 'production',
-                shouldDecodeNewlines,
-                shouldDecodeNewlinesForHref,
-                delimiters: options.delimiters,
-                comments: options.comments,
-            }, this);
-            options.render = render;
-            options.staticRenderFns = staticRenderFns;
-            /* istanbul ignore if */
-            if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-                mark('compile end');
-                measure(`vue ${this._name} compile`, 'compile', 'compile end');
-            }
-        }
-    }
-    return mount.call(this, el, hydrating);
-};
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el) {
-    if (el.outerHTML) {
-        return el.outerHTML;
-    }
-    else {
-        const container = document.createElement('div');
-        container.appendChild(el.cloneNode(true));
-        return container.innerHTML;
-    }
-}
-Vue.compile = compileToFunctions;
-
-export { Vue as default };
diff --git a/dist/vue.js b/dist/vue.js
deleted file mode 100644
index 58b38d0e024..00000000000
--- a/dist/vue.js
+++ /dev/null
@@ -1,10454 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
-})(this, (function () { 'use strict';
-
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  function isRegExp(v) {
-      return _toString.call(v) === '[object RegExp]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$2(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-  /* istanbul ignore next */
-  function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          const l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
-  }
-  function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
-  }
-  // @ts-expect-error bind cannot be `undefined`
-  const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind;
-  /**
-   * Convert an Array-like object to a real Array.
-   */
-  function toArray(list, start) {
-      start = start || 0;
-      let i = list.length - start;
-      const ret = new Array(i);
-      while (i--) {
-          ret[i] = list[i + start];
-      }
-      return ret;
-  }
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys$1(modules) {
-      return modules
-          .reduce((keys, m) => {
-          return keys.concat(m.staticKeys || []);
-      }, [])
-          .join(',');
-  }
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-  /**
-   * Ensure a function is called only once.
-   */
-  function once(fn) {
-      let called = false;
-      return function () {
-          if (!called) {
-              called = true;
-              fn.apply(this, arguments);
-          }
-      };
-  }
-
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
-  ];
-
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
-  };
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Check if a string starts with $ or _
-   */
-  function isReserved(str) {
-      const c = (str + '').charCodeAt(0);
-      return c === 0x24 || c === 0x5f;
-  }
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-  /**
-   * Parse simple path.
-   */
-  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-  function parsePath(path) {
-      if (bailRE.test(path)) {
-          return;
-      }
-      const segments = path.split('.');
-      return function (obj) {
-          for (let i = 0; i < segments.length; i++) {
-              if (!obj)
-                  return;
-              obj = obj[segments[i]];
-          }
-          return obj;
-      };
-  }
-
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  const isFF = UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
-  };
-  // detect devtools
-  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
-  }
-
-  let warn$2 = noop;
-  let tip = noop;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn$2 = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (config.warnHandler) {
-              config.warnHandler.call(null, msg, vm, trace);
-          }
-          else if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
-  }
-
-  let uid$2 = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid$2++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$2(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          if (!config.async) {
-              // subs aren't sorted in scheduler if not running async
-              // we need to sort them now to make sure they fire in correct
-              // order
-              subs.sort((a, b) => a.id - b.id);
-          }
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
-  }
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
-  });
-
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Delete a property and trigger change if necessary.
-   */
-  function del(target, key) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.splice(key, 1);
-          return;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid deleting properties on a Vue instance or its root $data ' +
-                  '- just set it to null.');
-          return;
-      }
-      if (!hasOwn(target, key)) {
-          return;
-      }
-      delete target[key];
-      if (!ob) {
-          return;
-      }
-      ob.dep.notify();
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn$2(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn$2('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
-  });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn$2('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn$2('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn$2('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives$1(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn$2(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives$1(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
-  }
-
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn$2('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn$2('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
-  }
-
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      if (config.errorHandler) {
-          try {
-              return config.errorHandler.call(null, err, vm, info);
-          }
-          catch (e) {
-              // if the user intentionally throws the original error in the handler,
-              // do not log it twice
-              if (e !== err) {
-                  logError(e, null, 'config.errorHandler');
-              }
-          }
-      }
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
-  }
-
-  /* globals MutationObserver */
-  let isUsingMicroTask = false;
-  const callbacks = [];
-  let pending = false;
-  function flushCallbacks() {
-      pending = false;
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // Here we have async deferring wrappers using microtasks.
-  // In 2.5 we used (macro) tasks (in combination with microtasks).
-  // However, it has subtle problems when state is changed right before repaint
-  // (e.g. #6813, out-in transitions).
-  // Also, using (macro) tasks in event handler would cause some weird behaviors
-  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-  // So we now use microtasks everywhere, again.
-  // A major drawback of this tradeoff is that there are some scenarios
-  // where microtasks have too high a priority and fire in between supposedly
-  // sequential events (e.g. #4521, #6690, which have workarounds)
-  // or even between bubbling of the same event (#6566).
-  let timerFunc;
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      const p = Promise.resolve();
-      timerFunc = () => {
-          p.then(flushCallbacks);
-          // In problematic UIWebViews, Promise.then doesn't completely break, but
-          // it can get stuck in a weird state where callbacks are pushed into the
-          // microtask queue but the queue isn't being flushed, until the browser
-          // needs to do some other work, e.g. handle a timer. Therefore we can
-          // "force" the microtask queue to be flushed by adding an empty timer.
-          if (isIOS)
-              setTimeout(noop);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-      timerFunc = () => {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-      // Fallback to setImmediate.
-      // Technically it leverages the (macro) task queue,
-      // but it is still a better choice than setTimeout.
-      timerFunc = () => {
-          setImmediate(flushCallbacks);
-      };
-  }
-  else {
-      // Fallback to setTimeout.
-      timerFunc = () => {
-          setTimeout(flushCallbacks, 0);
-      };
-  }
-  function nextTick(cb, ctx) {
-      let _resolve;
-      callbacks.push(() => {
-          if (cb) {
-              try {
-                  cb.call(ctx);
-              }
-              catch (e) {
-                  handleError(e, ctx, 'nextTick');
-              }
-          }
-          else if (_resolve) {
-              _resolve(ctx);
-          }
-      });
-      if (!pending) {
-          pending = true;
-          timerFunc();
-      }
-      // $flow-disable-line
-      if (!cb && typeof Promise !== 'undefined') {
-          return new Promise((resolve) => {
-              _resolve = resolve;
-          });
-      }
-  }
-
-  let mark;
-  let measure;
-  {
-      const perf = inBrowser && window.performance;
-      /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = (tag) => perf.mark(tag);
-          measure = (name, startTag, endTag) => {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
-              // perf.clearMeasures(name)
-          };
-      }
-  }
-
-  /* not type checking this file because flow doesn't play well with Proxy */
-  let initProxy;
-  {
-      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const warnNonPresent = (target, key) => {
-          warn$2(`Property or method "${key}" is not defined on the instance but ` +
-              'referenced during render. Make sure that this property is reactive, ' +
-              'either in the data option, or for class-based components, by ' +
-              'initializing the property. ' +
-              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-      };
-      const warnReservedPrefix = (target, key) => {
-          warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` +
-              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-              'prevent conflicts with Vue internals. ' +
-              'See: https://vuejs.org/v2/api/#data', target);
-      };
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-      const hasHandler = {
-          has(target, key) {
-              const has = key in target;
-              const isAllowed = allowedGlobals(key) ||
-                  (typeof key === 'string' &&
-                      key.charAt(0) === '_' &&
-                      !(key in target.$data));
-              if (!has && !isAllowed) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return has || !isAllowed;
-          },
-      };
-      const getHandler = {
-          get(target, key) {
-              if (typeof key === 'string' && !(key in target)) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return target[key];
-          },
-      };
-      initProxy = function initProxy(vm) {
-          if (hasProxy) {
-              // determine which proxy handler to use
-              const options = vm.$options;
-              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-              vm._renderProxy = new Proxy(vm, handlers);
-          }
-          else {
-              vm._renderProxy = vm;
-          }
-      };
-  }
-
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
-  }
-
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
-  }
-
-  function mergeVNodeHook(def, hookKey, hook) {
-      if (def instanceof VNode) {
-          def = def.data.hook || (def.data.hook = {});
-      }
-      let invoker;
-      const oldHook = def[hookKey];
-      function wrappedHook() {
-          hook.apply(this, arguments);
-          // important: remove merged hook to ensure it's called only once
-          // and prevent memory leak
-          remove$2(invoker.fns, wrappedHook);
-      }
-      if (isUndef(oldHook)) {
-          // no existing hook
-          invoker = createFnInvoker([wrappedHook]);
-      }
-      else {
-          /* istanbul ignore if */
-          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-              // already a merged invoker
-              invoker = oldHook;
-              invoker.fns.push(wrappedHook);
-          }
-          else {
-              // existing plain hook
-              invoker = createFnInvoker([oldHook, wrappedHook]);
-          }
-      }
-      invoker.merged = true;
-      def[hookKey] = invoker;
-  }
-
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
-  }
-
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
-  }
-
-  function initProvide(vm) {
-      const provide = vm.$options.provide;
-      if (provide) {
-          vm._provided =
-              typeof provide === 'function'
-                  ? // @ts-expect-error typing not correct
-                      provide.call(vm)
-                  : provide;
-      }
-  }
-  function initInjections(vm) {
-      const result = resolveInject(vm.$options.inject, vm);
-      if (result) {
-          toggleObserving(false);
-          Object.keys(result).forEach((key) => {
-              /* istanbul ignore else */
-              {
-                  defineReactive(vm, key, result[key], () => {
-                      warn$2(`Avoid mutating an injected value directly since the changes will be ` +
-                          `overwritten whenever the provided component re-renders. ` +
-                          `injection being mutated: "${key}"`, vm);
-                  });
-              }
-          });
-          toggleObserving(true);
-      }
-  }
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn$2(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
-  }
-
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
-  }
-
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
-  }
-
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn$2("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
-  }
-
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
-  }
-
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn$2('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
-  }
-
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic$1(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic$1(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic$1(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
-  }
-
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn$2('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
-  }
-
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
-  }
-
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
-  }
-
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
-  }
-
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
-  }
-
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook$1(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
-  }
-
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn$2('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if (config.isReservedTag(tag)) {
-              // platform built-in elements
-              if (isDef(data) &&
-                  isDef(data.nativeOn) &&
-                  data.tag !== 'component') {
-                  warn$2(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-              }
-              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-          }
-          else if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
-  }
-
-  function initRender(vm) {
-      vm._vnode = null; // the root of the child tree
-      vm._staticTrees = null; // v-once cached trees
-      const options = vm.$options;
-      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      const renderContext = parentVnode && parentVnode.context;
-      vm.$slots = resolveSlots(options._renderChildren, renderContext);
-      vm.$scopedSlots = emptyObject;
-      // bind the createElement fn to this instance
-      // so that we get proper render context inside it.
-      // args order: tag, data, children, normalizationType, alwaysNormalize
-      // internal version is used by render functions compiled from templates
-      // @ts-expect-error
-      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-      // normalization is always applied for the public version, used in
-      // user-written render functions.
-      // @ts-expect-error
-      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-      // $attrs & $listeners are exposed for easier HOC creation.
-      // they need to be reactive so that HOCs using them are always updated
-      const parentData = parentVnode && parentVnode.data;
-      /* istanbul ignore else */
-      {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-              !isUpdatingChildComponent && warn$2(`$attrs is readonly.`, vm);
-          }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-              !isUpdatingChildComponent && warn$2(`$listeners is readonly.`, vm);
-          }, true);
-      }
-  }
-  let currentRenderingInstance = null;
-  function renderMixin(Vue) {
-      // install runtime convenience helpers
-      installRenderHelpers(Vue.prototype);
-      Vue.prototype.$nextTick = function (fn) {
-          return nextTick(fn, this);
-      };
-      Vue.prototype._render = function () {
-          const vm = this;
-          const { render, _parentVnode } = vm.$options;
-          if (_parentVnode) {
-              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-          }
-          // set parent vnode. this allows render functions to have access
-          // to the data on the placeholder node.
-          vm.$vnode = _parentVnode;
-          // render self
-          let vnode;
-          try {
-              // There's no need to maintain a stack because all render fns are called
-              // separately from one another. Nested component's render fns are called
-              // when parent component is patched.
-              currentRenderingInstance = vm;
-              vnode = render.call(vm._renderProxy, vm.$createElement);
-          }
-          catch (e) {
-              handleError(e, vm, `render`);
-              // return error render result,
-              // or previous vnode to prevent render error causing blank component
-              /* istanbul ignore else */
-              if (vm.$options.renderError) {
-                  try {
-                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                  }
-                  catch (e) {
-                      handleError(e, vm, `renderError`);
-                      vnode = vm._vnode;
-                  }
-              }
-              else {
-                  vnode = vm._vnode;
-              }
-          }
-          finally {
-              currentRenderingInstance = null;
-          }
-          // if the returned array contains only a single node, allow it
-          if (Array.isArray(vnode) && vnode.length === 1) {
-              vnode = vnode[0];
-          }
-          // return empty vnode in case the render function errored out
-          if (!(vnode instanceof VNode)) {
-              if (Array.isArray(vnode)) {
-                  warn$2('Multiple root nodes returned from render function. Render function ' +
-                      'should return a single root node.', vm);
-              }
-              vnode = createEmptyVNode();
-          }
-          // set parent
-          vnode.parent = _parentVnode;
-          return vnode;
-      };
-  }
-
-  function ensureCtor(comp, base) {
-      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-          comp = comp.default;
-      }
-      return isObject(comp) ? base.extend(comp) : comp;
-  }
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      const owner = currentRenderingInstance;
-      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-          // already pending
-          factory.owners.push(owner);
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-      if (owner && !isDef(factory.owners)) {
-          const owners = (factory.owners = [owner]);
-          let sync = true;
-          let timerLoading = null;
-          let timerTimeout = null;
-          owner.$on('hook:destroyed', () => remove$2(owners, owner));
-          const forceRender = (renderCompleted) => {
-              for (let i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
-              }
-              if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
-                  }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
-                  }
-              }
-          };
-          const resolve = once((res) => {
-              // cache resolved
-              factory.resolved = ensureCtor(res, baseCtor);
-              // invoke callbacks only if this is not a synchronous resolve
-              // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
-              }
-              else {
-                  owners.length = 0;
-              }
-          });
-          const reject = once((reason) => {
-              warn$2(`Failed to resolve async component: ${String(factory)}` +
-                      (reason ? `\nReason: ${reason}` : ''));
-              if (isDef(factory.errorComp)) {
-                  factory.error = true;
-                  forceRender(true);
-              }
-          });
-          const res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
-                  // () => Promise
-                  if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
-                  }
-              }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
-                  }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
-                          factory.loading = true;
-                      }
-                      else {
-                          // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(() => {
-                              timerLoading = null;
-                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                  factory.loading = true;
-                                  forceRender(false);
-                              }
-                          }, res.delay || 200);
-                      }
-                  }
-                  if (isDef(res.timeout)) {
-                      // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(() => {
-                          timerTimeout = null;
-                          if (isUndef(factory.resolved)) {
-                              reject(`timeout (${res.timeout}ms)`
-                                  );
-                          }
-                      }, res.timeout);
-                  }
-              }
-          }
-          sync = false;
-          // return in case resolved synchronously
-          return factory.loading ? factory.loadingComp : factory.resolved;
-      }
-  }
-
-  function getFirstComponentChild(children) {
-      if (Array.isArray(children)) {
-          for (let i = 0; i < children.length; i++) {
-              const c = children[i];
-              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                  return c;
-              }
-          }
-      }
-  }
-
-  function initEvents(vm) {
-      vm._events = Object.create(null);
-      vm._hasHookEvent = false;
-      // init parent attached events
-      const listeners = vm.$options._parentListeners;
-      if (listeners) {
-          updateComponentListeners(vm, listeners);
-      }
-  }
-  let target$1;
-  function add$1(event, fn) {
-      target$1.$on(event, fn);
-  }
-  function remove$1(event, fn) {
-      target$1.$off(event, fn);
-  }
-  function createOnceHandler$1(event, fn) {
-      const _target = target$1;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target$1 = vm;
-      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-      target$1 = undefined;
-  }
-  function eventsMixin(Vue) {
-      const hookRE = /^hook:/;
-      Vue.prototype.$on = function (event, fn) {
-          const vm = this;
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$on(event[i], fn);
-              }
-          }
-          else {
-              (vm._events[event] || (vm._events[event] = [])).push(fn);
-              // optimize hook:event cost by using a boolean flag marked at registration
-              // instead of a hash lookup
-              if (hookRE.test(event)) {
-                  vm._hasHookEvent = true;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$once = function (event, fn) {
-          const vm = this;
-          function on() {
-              vm.$off(event, on);
-              fn.apply(vm, arguments);
-          }
-          on.fn = fn;
-          vm.$on(event, on);
-          return vm;
-      };
-      Vue.prototype.$off = function (event, fn) {
-          const vm = this;
-          // all
-          if (!arguments.length) {
-              vm._events = Object.create(null);
-              return vm;
-          }
-          // array of events
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$off(event[i], fn);
-              }
-              return vm;
-          }
-          // specific event
-          const cbs = vm._events[event];
-          if (!cbs) {
-              return vm;
-          }
-          if (!fn) {
-              vm._events[event] = null;
-              return vm;
-          }
-          // specific handler
-          let cb;
-          let i = cbs.length;
-          while (i--) {
-              cb = cbs[i];
-              if (cb === fn || cb.fn === fn) {
-                  cbs.splice(i, 1);
-                  break;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$emit = function (event) {
-          const vm = this;
-          {
-              const lowerCaseEvent = event.toLowerCase();
-              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                      `Note that HTML attributes are case-insensitive and you cannot use ` +
-                      `v-on to listen to camelCase events when using in-DOM templates. ` +
-                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-              }
-          }
-          let cbs = vm._events[event];
-          if (cbs) {
-              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              const args = toArray(arguments, 1);
-              const info = `event handler for "${event}"`;
-              for (let i = 0, l = cbs.length; i < l; i++) {
-                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-              }
-          }
-          return vm;
-      };
-  }
-
-  let activeInstance = null;
-  let isUpdatingChildComponent = false;
-  function setActiveInstance(vm) {
-      const prevActiveInstance = activeInstance;
-      activeInstance = vm;
-      return () => {
-          activeInstance = prevActiveInstance;
-      };
-  }
-  function initLifecycle(vm) {
-      const options = vm.$options;
-      // locate first non-abstract parent
-      let parent = options.parent;
-      if (parent && !options.abstract) {
-          while (parent.$options.abstract && parent.$parent) {
-              parent = parent.$parent;
-          }
-          parent.$children.push(vm);
-      }
-      vm.$parent = parent;
-      vm.$root = parent ? parent.$root : vm;
-      vm.$children = [];
-      vm.$refs = {};
-      vm._watcher = null;
-      vm._inactive = null;
-      vm._directInactive = false;
-      vm._isMounted = false;
-      vm._isDestroyed = false;
-      vm._isBeingDestroyed = false;
-  }
-  function lifecycleMixin(Vue) {
-      Vue.prototype._update = function (vnode, hydrating) {
-          const vm = this;
-          const prevEl = vm.$el;
-          const prevVnode = vm._vnode;
-          const restoreActiveInstance = setActiveInstance(vm);
-          vm._vnode = vnode;
-          // Vue.prototype.__patch__ is injected in entry points
-          // based on the rendering backend used.
-          if (!prevVnode) {
-              // initial render
-              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-          }
-          else {
-              // updates
-              vm.$el = vm.__patch__(prevVnode, vnode);
-          }
-          restoreActiveInstance();
-          // update __vue__ reference
-          if (prevEl) {
-              prevEl.__vue__ = null;
-          }
-          if (vm.$el) {
-              vm.$el.__vue__ = vm;
-          }
-          // if parent is an HOC, update its $el as well
-          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-              vm.$parent.$el = vm.$el;
-          }
-          // updated hook is called by the scheduler to ensure that children are
-          // updated in a parent's updated hook.
-      };
-      Vue.prototype.$forceUpdate = function () {
-          const vm = this;
-          if (vm._watcher) {
-              vm._watcher.update();
-          }
-      };
-      Vue.prototype.$destroy = function () {
-          const vm = this;
-          if (vm._isBeingDestroyed) {
-              return;
-          }
-          callHook$1(vm, "beforeDestroy");
-          vm._isBeingDestroyed = true;
-          // remove self from parent
-          const parent = vm.$parent;
-          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove$2(parent.$children, vm);
-          }
-          // teardown watchers
-          if (vm._watcher) {
-              vm._watcher.teardown();
-          }
-          let i = vm._watchers.length;
-          while (i--) {
-              vm._watchers[i].teardown();
-          }
-          // remove reference from data ob
-          // frozen object may not have observer.
-          if (vm._data.__ob__) {
-              vm._data.__ob__.vmCount--;
-          }
-          // call the last hook...
-          vm._isDestroyed = true;
-          // invoke destroy hooks on current rendered tree
-          vm.__patch__(vm._vnode, null);
-          // fire destroyed hook
-          callHook$1(vm, "destroyed");
-          // turn off all instance listeners.
-          vm.$off();
-          // remove __vue__ reference
-          if (vm.$el) {
-              vm.$el.__vue__ = null;
-          }
-          // release circular reference (#6759)
-          if (vm.$vnode) {
-              vm.$vnode.parent = null;
-          }
-      };
-  }
-  function mountComponent(vm, el, hydrating) {
-      vm.$el = el;
-      if (!vm.$options.render) {
-          // @ts-expect-error invalid type
-          vm.$options.render = createEmptyVNode;
-          {
-              /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                  vm.$options.el ||
-                  el) {
-                  warn$2("You are using the runtime-only build of Vue where the template " +
-                      "compiler is not available. Either pre-compile the templates into " +
-                      "render functions, or use the compiler-included build.", vm);
-              }
-              else {
-                  warn$2("Failed to mount component: template or render function not defined.", vm);
-              }
-          }
-      }
-      callHook$1(vm, "beforeMount");
-      let updateComponent;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-          updateComponent = () => {
-              const name = vm._name;
-              const id = vm._uid;
-              const startTag = `vue-perf-start:${id}`;
-              const endTag = `vue-perf-end:${id}`;
-              mark(startTag);
-              const vnode = vm._render();
-              mark(endTag);
-              measure(`vue ${name} render`, startTag, endTag);
-              mark(startTag);
-              vm._update(vnode, hydrating);
-              mark(endTag);
-              measure(`vue ${name} patch`, startTag, endTag);
-          };
-      }
-      else {
-          updateComponent = () => {
-              vm._update(vm._render(), hydrating);
-          };
-      }
-      // we set this to vm._watcher inside the watcher's constructor
-      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-      // component's mounted hook), which relies on vm._watcher being already defined
-      new Watcher(vm, updateComponent, noop, {
-          before() {
-              if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, "beforeUpdate");
-              }
-          },
-      }, true /* isRenderWatcher */);
-      hydrating = false;
-      // manually mounted instance, call mounted on self
-      // mounted is called for render-created child components in its inserted hook
-      if (vm.$vnode == null) {
-          vm._isMounted = true;
-          callHook$1(vm, "mounted");
-      }
-      return vm;
-  }
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      {
-          isUpdatingChildComponent = true;
-      }
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-      {
-          isUpdatingChildComponent = false;
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "deactivated");
-      }
-  }
-  function callHook$1(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
-  }
-
-  const MAX_UPDATE_COUNT = 100;
-  const queue = [];
-  const activatedChildren = [];
-  let has = {};
-  let circular = {};
-  let waiting = false;
-  let flushing = false;
-  let index$1 = 0;
-  /**
-   * Reset the scheduler's state.
-   */
-  function resetSchedulerState() {
-      index$1 = queue.length = activatedChildren.length = 0;
-      has = {};
-      {
-          circular = {};
-      }
-      waiting = flushing = false;
-  }
-  // Async edge case #6566 requires saving the timestamp when event listeners are
-  // attached. However, calling performance.now() has a perf overhead especially
-  // if the page has thousands of event listeners. Instead, we take a timestamp
-  // every time the scheduler flushes and use that for all event listeners
-  // attached during that flush.
-  let currentFlushTimestamp = 0;
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Flush both queues and run the watchers.
-   */
-  function flushSchedulerQueue() {
-      currentFlushTimestamp = getNow();
-      flushing = true;
-      let watcher, id;
-      // Sort queue before flush.
-      // This ensures that:
-      // 1. Components are updated from parent to child. (because parent is always
-      //    created before the child)
-      // 2. A component's user watchers are run before its render watcher (because
-      //    user watchers are created before the render watcher)
-      // 3. If a component is destroyed during a parent component's watcher run,
-      //    its watchers can be skipped.
-      queue.sort((a, b) => a.id - b.id);
-      // do not cache length because more watchers might be pushed
-      // as we run existing watchers
-      for (index$1 = 0; index$1 < queue.length; index$1++) {
-          watcher = queue[index$1];
-          if (watcher.before) {
-              watcher.before();
-          }
-          id = watcher.id;
-          has[id] = null;
-          watcher.run();
-          // in dev build, check and stop circular updates.
-          if (has[id] != null) {
-              circular[id] = (circular[id] || 0) + 1;
-              if (circular[id] > MAX_UPDATE_COUNT) {
-                  warn$2('You may have an infinite update loop ' +
-                      (watcher.user
-                          ? `in watcher with expression "${watcher.expression}"`
-                          : `in a component render function.`), watcher.vm);
-                  break;
-              }
-          }
-      }
-      // keep copies of post queues before resetting state
-      const activatedQueue = activatedChildren.slice();
-      const updatedQueue = queue.slice();
-      resetSchedulerState();
-      // call component updated and activated hooks
-      callActivatedHooks(activatedQueue);
-      callUpdatedHooks(updatedQueue);
-      // devtool hook
-      /* istanbul ignore if */
-      if (devtools && config.devtools) {
-          devtools.emit('flush');
-      }
-  }
-  function callUpdatedHooks(queue) {
-      let i = queue.length;
-      while (i--) {
-          const watcher = queue[i];
-          const vm = watcher.vm;
-          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook$1(vm, 'updated');
-          }
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-      activatedChildren.push(vm);
-  }
-  function callActivatedHooks(queue) {
-      for (let i = 0; i < queue.length; i++) {
-          queue[i]._inactive = true;
-          activateChildComponent(queue[i], true /* true */);
-      }
-  }
-  /**
-   * Push a watcher into the watcher queue.
-   * Jobs with duplicate IDs will be skipped unless it's
-   * pushed when the queue is being flushed.
-   */
-  function queueWatcher(watcher) {
-      const id = watcher.id;
-      if (has[id] == null) {
-          has[id] = true;
-          if (!flushing) {
-              queue.push(watcher);
-          }
-          else {
-              // if already flushing, splice the watcher based on its id
-              // if already past its id, it will be run next immediately.
-              let i = queue.length - 1;
-              while (i > index$1 && queue[i].id > watcher.id) {
-                  i--;
-              }
-              queue.splice(i + 1, 0, watcher);
-          }
-          // queue the flush
-          if (!waiting) {
-              waiting = true;
-              if (!config.async) {
-                  flushSchedulerQueue();
-                  return;
-              }
-              nextTick(flushSchedulerQueue);
-          }
-      }
-  }
-
-  let uid$1 = 0;
-  /**
-   * A watcher parses an expression, collects dependencies,
-   * and fires callback when the expression value changes.
-   * This is used for both the $watch() api and directives.
-   */
-  class Watcher {
-      vm;
-      expression;
-      cb;
-      id;
-      deep;
-      user;
-      lazy;
-      sync;
-      dirty;
-      active;
-      deps;
-      newDeps;
-      depIds;
-      newDepIds;
-      before;
-      getter;
-      value;
-      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-          this.vm = vm;
-          if (isRenderWatcher) {
-              vm._watcher = this;
-          }
-          vm._watchers.push(this);
-          // options
-          if (options) {
-              this.deep = !!options.deep;
-              this.user = !!options.user;
-              this.lazy = !!options.lazy;
-              this.sync = !!options.sync;
-              this.before = options.before;
-          }
-          else {
-              this.deep = this.user = this.lazy = this.sync = false;
-          }
-          this.cb = cb;
-          this.id = ++uid$1; // uid for batching
-          this.active = true;
-          this.dirty = this.lazy; // for lazy watchers
-          this.deps = [];
-          this.newDeps = [];
-          this.depIds = new _Set();
-          this.newDepIds = new _Set();
-          this.expression = expOrFn.toString()
-              ;
-          // parse expression for getter
-          if (typeof expOrFn === 'function') {
-              this.getter = expOrFn;
-          }
-          else {
-              this.getter = parsePath(expOrFn);
-              if (!this.getter) {
-                  this.getter = noop;
-                  warn$2(`Failed watching path: "${expOrFn}" ` +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
-              }
-          }
-          this.value = this.lazy
-              ? undefined
-              : this.get();
-      }
-      /**
-       * Evaluate the getter, and re-collect dependencies.
-       */
-      get() {
-          pushTarget(this);
-          let value;
-          const vm = this.vm;
-          try {
-              value = this.getter.call(vm, vm);
-          }
-          catch (e) {
-              if (this.user) {
-                  handleError(e, vm, `getter for watcher "${this.expression}"`);
-              }
-              else {
-                  throw e;
-              }
-          }
-          finally {
-              // "touch" every property so they are all tracked as
-              // dependencies for deep watching
-              if (this.deep) {
-                  traverse(value);
-              }
-              popTarget();
-              this.cleanupDeps();
-          }
-          return value;
-      }
-      /**
-       * Add a dependency to this directive.
-       */
-      addDep(dep) {
-          const id = dep.id;
-          if (!this.newDepIds.has(id)) {
-              this.newDepIds.add(id);
-              this.newDeps.push(dep);
-              if (!this.depIds.has(id)) {
-                  dep.addSub(this);
-              }
-          }
-      }
-      /**
-       * Clean up for dependency collection.
-       */
-      cleanupDeps() {
-          let i = this.deps.length;
-          while (i--) {
-              const dep = this.deps[i];
-              if (!this.newDepIds.has(dep.id)) {
-                  dep.removeSub(this);
-              }
-          }
-          let tmp = this.depIds;
-          this.depIds = this.newDepIds;
-          this.newDepIds = tmp;
-          this.newDepIds.clear();
-          tmp = this.deps;
-          this.deps = this.newDeps;
-          this.newDeps = tmp;
-          this.newDeps.length = 0;
-      }
-      /**
-       * Subscriber interface.
-       * Will be called when a dependency changes.
-       */
-      update() {
-          /* istanbul ignore else */
-          if (this.lazy) {
-              this.dirty = true;
-          }
-          else if (this.sync) {
-              this.run();
-          }
-          else {
-              queueWatcher(this);
-          }
-      }
-      /**
-       * Scheduler job interface.
-       * Will be called by the scheduler.
-       */
-      run() {
-          if (this.active) {
-              const value = this.get();
-              if (value !== this.value ||
-                  // Deep watchers and watchers on Object/Arrays should fire even
-                  // when the value is the same, because the value may
-                  // have mutated.
-                  isObject(value) ||
-                  this.deep) {
-                  // set new value
-                  const oldValue = this.value;
-                  this.value = value;
-                  if (this.user) {
-                      const info = `callback for watcher "${this.expression}"`;
-                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                  }
-                  else {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-              }
-          }
-      }
-      /**
-       * Evaluate the value of the watcher.
-       * This only gets called for lazy watchers.
-       */
-      evaluate() {
-          this.value = this.get();
-          this.dirty = false;
-      }
-      /**
-       * Depend on all deps collected by this watcher.
-       */
-      depend() {
-          let i = this.deps.length;
-          while (i--) {
-              this.deps[i].depend();
-          }
-      }
-      /**
-       * Remove self from all dependencies' subscriber list.
-       */
-      teardown() {
-          if (this.active) {
-              // remove self from vm's watcher list
-              // this is a somewhat expensive operation so we skip it
-              // if the vm is being destroyed.
-              if (!this.vm._isBeingDestroyed) {
-                  remove$2(this.vm._watchers, this);
-              }
-              let i = this.deps.length;
-              while (i--) {
-                  this.deps[i].removeSub(this);
-              }
-              this.active = false;
-          }
-      }
-  }
-
-  const sharedPropertyDefinition = {
-      enumerable: true,
-      configurable: true,
-      get: noop,
-      set: noop,
-  };
-  function proxy(target, sourceKey, key) {
-      sharedPropertyDefinition.get = function proxyGetter() {
-          return this[sourceKey][key];
-      };
-      sharedPropertyDefinition.set = function proxySetter(val) {
-          this[sourceKey][key] = val;
-      };
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function initState(vm) {
-      vm._watchers = [];
-      const opts = vm.$options;
-      if (opts.props)
-          initProps$1(vm, opts.props);
-      if (opts.methods)
-          initMethods(vm, opts.methods);
-      if (opts.data) {
-          initData(vm);
-      }
-      else {
-          observe((vm._data = {}), true /* asRootData */);
-      }
-      if (opts.computed)
-          initComputed$1(vm, opts.computed);
-      if (opts.watch && opts.watch !== nativeWatch) {
-          initWatch(vm, opts.watch);
-      }
-  }
-  function initProps$1(vm, propsOptions) {
-      const propsData = vm.$options.propsData || {};
-      const props = (vm._props = {});
-      // cache prop keys so that future props updates can iterate using Array
-      // instead of dynamic object key enumeration.
-      const keys = (vm.$options._propKeys = []);
-      const isRoot = !vm.$parent;
-      // root instance props should be converted
-      if (!isRoot) {
-          toggleObserving(false);
-      }
-      for (const key in propsOptions) {
-          keys.push(key);
-          const value = validateProp(key, propsOptions, propsData, vm);
-          /* istanbul ignore else */
-          {
-              const hyphenatedKey = hyphenate(key);
-              if (isReservedAttribute(hyphenatedKey) ||
-                  config.isReservedAttr(hyphenatedKey)) {
-                  warn$2(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-              }
-              defineReactive(props, key, value, () => {
-                  if (!isRoot && !isUpdatingChildComponent) {
-                      warn$2(`Avoid mutating a prop directly since the value will be ` +
-                          `overwritten whenever the parent component re-renders. ` +
-                          `Instead, use a data or computed property based on the prop's ` +
-                          `value. Prop being mutated: "${key}"`, vm);
-                  }
-              });
-          }
-          // static props are already proxied on the component's prototype
-          // during Vue.extend(). We only need to proxy props defined at
-          // instantiation here.
-          if (!(key in vm)) {
-              proxy(vm, `_props`, key);
-          }
-      }
-      toggleObserving(true);
-  }
-  function initData(vm) {
-      let data = vm.$options.data;
-      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-      if (!isPlainObject(data)) {
-          data = {};
-          warn$2("data functions should return an object:\n" +
-                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-      }
-      // proxy data on instance
-      const keys = Object.keys(data);
-      const props = vm.$options.props;
-      const methods = vm.$options.methods;
-      let i = keys.length;
-      while (i--) {
-          const key = keys[i];
-          {
-              if (methods && hasOwn(methods, key)) {
-                  warn$2(`Method "${key}" has already been defined as a data property.`, vm);
-              }
-          }
-          if (props && hasOwn(props, key)) {
-              warn$2(`The data property "${key}" is already declared as a prop. ` +
-                      `Use prop default value instead.`, vm);
-          }
-          else if (!isReserved(key)) {
-              proxy(vm, `_data`, key);
-          }
-      }
-      // observe data
-      observe(data, true /* asRootData */);
-  }
-  function getData(data, vm) {
-      // #7573 disable dep collection when invoking data getters
-      pushTarget();
-      try {
-          return data.call(vm, vm);
-      }
-      catch (e) {
-          handleError(e, vm, `data()`);
-          return {};
-      }
-      finally {
-          popTarget();
-      }
-  }
-  const computedWatcherOptions = { lazy: true };
-  function initComputed$1(vm, computed) {
-      // $flow-disable-line
-      const watchers = (vm._computedWatchers = Object.create(null));
-      // computed properties are just getters during SSR
-      const isSSR = isServerRendering();
-      for (const key in computed) {
-          const userDef = computed[key];
-          const getter = typeof userDef === "function" ? userDef : userDef.get;
-          if (getter == null) {
-              warn$2(`Getter is missing for computed property "${key}".`, vm);
-          }
-          if (!isSSR) {
-              // create internal watcher for the computed property.
-              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-          }
-          // component-defined computed properties are already defined on the
-          // component prototype. We only need to define computed properties defined
-          // at instantiation here.
-          if (!(key in vm)) {
-              defineComputed(vm, key, userDef);
-          }
-          else {
-              if (key in vm.$data) {
-                  warn$2(`The computed property "${key}" is already defined in data.`, vm);
-              }
-              else if (vm.$options.props && key in vm.$options.props) {
-                  warn$2(`The computed property "${key}" is already defined as a prop.`, vm);
-              }
-              else if (vm.$options.methods && key in vm.$options.methods) {
-                  warn$2(`The computed property "${key}" is already defined as a method.`, vm);
-              }
-          }
-      }
-  }
-  function defineComputed(target, key, userDef) {
-      const shouldCache = !isServerRendering();
-      if (typeof userDef === "function") {
-          sharedPropertyDefinition.get = shouldCache
-              ? createComputedGetter(key)
-              : createGetterInvoker(userDef);
-          sharedPropertyDefinition.set = noop;
-      }
-      else {
-          sharedPropertyDefinition.get = userDef.get
-              ? shouldCache && userDef.cache !== false
-                  ? createComputedGetter(key)
-                  : createGetterInvoker(userDef.get)
-              : noop;
-          sharedPropertyDefinition.set = userDef.set || noop;
-      }
-      if (sharedPropertyDefinition.set === noop) {
-          sharedPropertyDefinition.set = function () {
-              warn$2(`Computed property "${key}" was assigned to but it has no setter.`, this);
-          };
-      }
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function createComputedGetter(key) {
-      return function computedGetter() {
-          const watcher = this._computedWatchers && this._computedWatchers[key];
-          if (watcher) {
-              if (watcher.dirty) {
-                  watcher.evaluate();
-              }
-              if (Dep.target) {
-                  watcher.depend();
-              }
-              return watcher.value;
-          }
-      };
-  }
-  function createGetterInvoker(fn) {
-      return function computedGetter() {
-          return fn.call(this, this);
-      };
-  }
-  function initMethods(vm, methods) {
-      const props = vm.$options.props;
-      for (const key in methods) {
-          {
-              if (typeof methods[key] !== "function") {
-                  warn$2(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                      `Did you reference the function correctly?`, vm);
-              }
-              if (props && hasOwn(props, key)) {
-                  warn$2(`Method "${key}" has already been defined as a prop.`, vm);
-              }
-              if (key in vm && isReserved(key)) {
-                  warn$2(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                      `Avoid defining component methods that start with _ or $.`);
-              }
-          }
-          vm[key] =
-              typeof methods[key] !== "function" ? noop : bind$1(methods[key], vm);
-      }
-  }
-  function initWatch(vm, watch) {
-      for (const key in watch) {
-          const handler = watch[key];
-          if (Array.isArray(handler)) {
-              for (let i = 0; i < handler.length; i++) {
-                  createWatcher(vm, key, handler[i]);
-              }
-          }
-          else {
-              createWatcher(vm, key, handler);
-          }
-      }
-  }
-  function createWatcher(vm, expOrFn, handler, options) {
-      if (isPlainObject(handler)) {
-          options = handler;
-          handler = handler.handler;
-      }
-      if (typeof handler === "string") {
-          handler = vm[handler];
-      }
-      return vm.$watch(expOrFn, handler, options);
-  }
-  function stateMixin(Vue) {
-      // flow somehow has problems with directly declared definition object
-      // when using Object.defineProperty, so we have to procedurally build up
-      // the object here.
-      const dataDef = {};
-      dataDef.get = function () {
-          return this._data;
-      };
-      const propsDef = {};
-      propsDef.get = function () {
-          return this._props;
-      };
-      {
-          dataDef.set = function () {
-              warn$2("Avoid replacing instance root $data. " +
-                  "Use nested data properties instead.", this);
-          };
-          propsDef.set = function () {
-              warn$2(`$props is readonly.`, this);
-          };
-      }
-      Object.defineProperty(Vue.prototype, "$data", dataDef);
-      Object.defineProperty(Vue.prototype, "$props", propsDef);
-      Vue.prototype.$set = set;
-      Vue.prototype.$delete = del;
-      Vue.prototype.$watch = function (expOrFn, cb, options) {
-          const vm = this;
-          if (isPlainObject(cb)) {
-              return createWatcher(vm, expOrFn, cb, options);
-          }
-          options = options || {};
-          options.user = true;
-          const watcher = new Watcher(vm, expOrFn, cb, options);
-          if (options.immediate) {
-              const info = `callback for immediate watcher "${watcher.expression}"`;
-              pushTarget();
-              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-              popTarget();
-          }
-          return function unwatchFn() {
-              watcher.teardown();
-          };
-      };
-  }
-
-  let uid = 0;
-  function initMixin$1(Vue) {
-      Vue.prototype._init = function (options) {
-          const vm = this;
-          // a uid
-          vm._uid = uid++;
-          let startTag, endTag;
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              startTag = `vue-perf-start:${vm._uid}`;
-              endTag = `vue-perf-end:${vm._uid}`;
-              mark(startTag);
-          }
-          // a flag to avoid this being observed
-          vm._isVue = true;
-          // merge options
-          if (options && options._isComponent) {
-              // optimize internal component instantiation
-              // since dynamic options merging is pretty slow, and none of the
-              // internal component options needs special treatment.
-              initInternalComponent(vm, options);
-          }
-          else {
-              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-          }
-          /* istanbul ignore else */
-          {
-              initProxy(vm);
-          }
-          // expose real self
-          vm._self = vm;
-          initLifecycle(vm);
-          initEvents(vm);
-          initRender(vm);
-          callHook$1(vm, 'beforeCreate');
-          initInjections(vm); // resolve injections before data/props
-          initState(vm);
-          initProvide(vm); // resolve provide after data/props
-          callHook$1(vm, 'created');
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              vm._name = formatComponentName(vm, false);
-              mark(endTag);
-              measure(`vue ${vm._name} init`, startTag, endTag);
-          }
-          if (vm.$options.el) {
-              vm.$mount(vm.$options.el);
-          }
-      };
-  }
-  function initInternalComponent(vm, options) {
-      const opts = (vm.$options = Object.create(vm.constructor.options));
-      // doing this because it's faster than dynamic enumeration.
-      const parentVnode = options._parentVnode;
-      opts.parent = options.parent;
-      opts._parentVnode = parentVnode;
-      const vnodeComponentOptions = parentVnode.componentOptions;
-      opts.propsData = vnodeComponentOptions.propsData;
-      opts._parentListeners = vnodeComponentOptions.listeners;
-      opts._renderChildren = vnodeComponentOptions.children;
-      opts._componentTag = vnodeComponentOptions.tag;
-      if (options.render) {
-          opts.render = options.render;
-          opts.staticRenderFns = options.staticRenderFns;
-      }
-  }
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
-  }
-
-  function Vue(options) {
-      if (!(this instanceof Vue)) {
-          warn$2("Vue is a constructor and should be called with the `new` keyword");
-      }
-      this._init(options);
-  }
-  //@ts-expect-error Vue has function type
-  initMixin$1(Vue);
-  //@ts-expect-error Vue has function type
-  stateMixin(Vue);
-  //@ts-expect-error Vue has function type
-  eventsMixin(Vue);
-  //@ts-expect-error Vue has function type
-  lifecycleMixin(Vue);
-  //@ts-expect-error Vue has function type
-  renderMixin(Vue);
-
-  function initUse(Vue) {
-      Vue.use = function (plugin) {
-          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-          if (installedPlugins.indexOf(plugin) > -1) {
-              return this;
-          }
-          // additional parameters
-          const args = toArray(arguments, 1);
-          args.unshift(this);
-          if (typeof plugin.install === 'function') {
-              plugin.install.apply(plugin, args);
-          }
-          else if (typeof plugin === 'function') {
-              plugin.apply(null, args);
-          }
-          installedPlugins.push(plugin);
-          return this;
-      };
-  }
-
-  function initMixin(Vue) {
-      Vue.mixin = function (mixin) {
-          this.options = mergeOptions(this.options, mixin);
-          return this;
-      };
-  }
-
-  function initExtend(Vue) {
-      /**
-       * Each instance constructor, including Vue, has a unique
-       * cid. This enables us to create wrapped "child
-       * constructors" for prototypal inheritance and cache them.
-       */
-      Vue.cid = 0;
-      let cid = 1;
-      /**
-       * Class inheritance
-       */
-      Vue.extend = function (extendOptions) {
-          extendOptions = extendOptions || {};
-          const Super = this;
-          const SuperId = Super.cid;
-          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-          if (cachedCtors[SuperId]) {
-              return cachedCtors[SuperId];
-          }
-          const name = extendOptions.name || Super.options.name;
-          if (name) {
-              validateComponentName(name);
-          }
-          const Sub = function VueComponent(options) {
-              this._init(options);
-          };
-          Sub.prototype = Object.create(Super.prototype);
-          Sub.prototype.constructor = Sub;
-          Sub.cid = cid++;
-          Sub.options = mergeOptions(Super.options, extendOptions);
-          Sub['super'] = Super;
-          // For props and computed properties, we define the proxy getters on
-          // the Vue instances at extension time, on the extended prototype. This
-          // avoids Object.defineProperty calls for each instance created.
-          if (Sub.options.props) {
-              initProps(Sub);
-          }
-          if (Sub.options.computed) {
-              initComputed(Sub);
-          }
-          // allow further extension/mixin/plugin usage
-          Sub.extend = Super.extend;
-          Sub.mixin = Super.mixin;
-          Sub.use = Super.use;
-          // create asset registers, so extended classes
-          // can have their private assets too.
-          ASSET_TYPES.forEach(function (type) {
-              Sub[type] = Super[type];
-          });
-          // enable recursive self-lookup
-          if (name) {
-              Sub.options.components[name] = Sub;
-          }
-          // keep a reference to the super options at extension time.
-          // later at instantiation we can check if Super's options have
-          // been updated.
-          Sub.superOptions = Super.options;
-          Sub.extendOptions = extendOptions;
-          Sub.sealedOptions = extend({}, Sub.options);
-          // cache constructor
-          cachedCtors[SuperId] = Sub;
-          return Sub;
-      };
-  }
-  function initProps(Comp) {
-      const props = Comp.options.props;
-      for (const key in props) {
-          proxy(Comp.prototype, `_props`, key);
-      }
-  }
-  function initComputed(Comp) {
-      const computed = Comp.options.computed;
-      for (const key in computed) {
-          defineComputed(Comp.prototype, key, computed[key]);
-      }
-  }
-
-  function initAssetRegisters(Vue) {
-      /**
-       * Create asset registration methods.
-       */
-      ASSET_TYPES.forEach((type) => {
-          // @ts-expect-error function is not exact same type
-          Vue[type] = function (id, definition) {
-              if (!definition) {
-                  return this.options[type + 's'][id];
-              }
-              else {
-                  /* istanbul ignore if */
-                  if (type === 'component') {
-                      validateComponentName(id);
-                  }
-                  if (type === 'component' && isPlainObject(definition)) {
-                      // @ts-expect-error
-                      definition.name = definition.name || id;
-                      definition = this.options._base.extend(definition);
-                  }
-                  if (type === 'directive' && typeof definition === 'function') {
-                      definition = { bind: definition, update: definition };
-                  }
-                  this.options[type + 's'][id] = definition;
-                  return definition;
-              }
-          };
-      });
-  }
-
-  /* @flow */
-  function getComponentName(opts) {
-      return opts && (opts.Ctor.options.name || opts.tag);
-  }
-  function matches(pattern, name) {
-      if (Array.isArray(pattern)) {
-          return pattern.indexOf(name) > -1;
-      }
-      else if (typeof pattern === "string") {
-          return pattern.split(",").indexOf(name) > -1;
-      }
-      else if (isRegExp(pattern)) {
-          return pattern.test(name);
-      }
-      /* istanbul ignore next */
-      return false;
-  }
-  function pruneCache(keepAliveInstance, filter) {
-      const { cache, keys, _vnode } = keepAliveInstance;
-      for (const key in cache) {
-          const entry = cache[key];
-          if (entry) {
-              const name = entry.name;
-              if (name && !filter(name)) {
-                  pruneCacheEntry(cache, key, keys, _vnode);
-              }
-          }
-      }
-  }
-  function pruneCacheEntry(cache, key, keys, current) {
-      const entry = cache[key];
-      if (entry && (!current || entry.tag !== current.tag)) {
-          // @ts-expect-error can be undefined
-          entry.componentInstance.$destroy();
-      }
-      cache[key] = null;
-      remove$2(keys, key);
-  }
-  const patternTypes = [String, RegExp, Array];
-  // TODO defineComponent
-  var KeepAlive = {
-      name: "keep-alive",
-      abstract: true,
-      props: {
-          include: patternTypes,
-          exclude: patternTypes,
-          max: [String, Number],
-      },
-      methods: {
-          cacheVNode() {
-              const { cache, keys, vnodeToCache, keyToCache } = this;
-              if (vnodeToCache) {
-                  const { tag, componentInstance, componentOptions } = vnodeToCache;
-                  cache[keyToCache] = {
-                      name: getComponentName(componentOptions),
-                      tag,
-                      componentInstance,
-                  };
-                  keys.push(keyToCache);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
-                  this.vnodeToCache = null;
-              }
-          },
-      },
-      created() {
-          this.cache = Object.create(null);
-          this.keys = [];
-      },
-      destroyed() {
-          for (const key in this.cache) {
-              pruneCacheEntry(this.cache, key, this.keys);
-          }
-      },
-      mounted() {
-          this.cacheVNode();
-          this.$watch("include", (val) => {
-              pruneCache(this, (name) => matches(val, name));
-          });
-          this.$watch("exclude", (val) => {
-              pruneCache(this, (name) => !matches(val, name));
-          });
-      },
-      updated() {
-          this.cacheVNode();
-      },
-      render() {
-          const slot = this.$slots.default;
-          const vnode = getFirstComponentChild(slot);
-          const componentOptions = vnode && vnode.componentOptions;
-          if (componentOptions) {
-              // check pattern
-              const name = getComponentName(componentOptions);
-              const { include, exclude } = this;
-              if (
-              // not included
-              (include && (!name || !matches(include, name))) ||
-                  // excluded
-                  (exclude && name && matches(exclude, name))) {
-                  return vnode;
-              }
-              const { cache, keys } = this;
-              const key = vnode.key == null
-                  ? // same constructor may get registered as different local components
-                      // so cid alone is not enough (#3269)
-                      componentOptions.Ctor.cid +
-                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                  : vnode.key;
-              if (cache[key]) {
-                  vnode.componentInstance = cache[key].componentInstance;
-                  // make current key freshest
-                  remove$2(keys, key);
-                  keys.push(key);
-              }
-              else {
-                  // delay setting the cache until update
-                  this.vnodeToCache = vnode;
-                  this.keyToCache = key;
-              }
-              // @ts-expect-error can vnode.data can be undefined
-              vnode.data.keepAlive = true;
-          }
-          return vnode || (slot && slot[0]);
-      },
-  };
-
-  var builtInComponents = {
-      KeepAlive,
-  };
-
-  function initGlobalAPI(Vue) {
-      // config
-      const configDef = {};
-      configDef.get = () => config;
-      {
-          configDef.set = () => {
-              warn$2('Do not replace the Vue.config object, set individual fields instead.');
-          };
-      }
-      Object.defineProperty(Vue, 'config', configDef);
-      // exposed util methods.
-      // NOTE: these are not considered part of the public API - avoid relying on
-      // them unless you are aware of the risk.
-      Vue.util = {
-          warn: warn$2,
-          extend,
-          mergeOptions,
-          defineReactive,
-      };
-      Vue.set = set;
-      Vue.delete = del;
-      Vue.nextTick = nextTick;
-      // 2.6 explicit observable API
-      Vue.observable = (obj) => {
-          observe(obj);
-          return obj;
-      };
-      Vue.options = Object.create(null);
-      ASSET_TYPES.forEach((type) => {
-          Vue.options[type + 's'] = Object.create(null);
-      });
-      // this is used to identify the "base" constructor to extend all plain-object
-      // components with in Weex's multi-instance scenarios.
-      Vue.options._base = Vue;
-      extend(Vue.options.components, builtInComponents);
-      initUse(Vue);
-      initMixin(Vue);
-      initExtend(Vue);
-      initAssetRegisters(Vue);
-  }
-
-  initGlobalAPI(Vue);
-  Object.defineProperty(Vue.prototype, '$isServer', {
-      get: isServerRendering,
-  });
-  Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get() {
-          /* istanbul ignore next */
-          return this.$vnode && this.$vnode.ssrContext;
-      },
-  });
-  // expose FunctionalRenderContext for ssr runtime helper installation
-  Object.defineProperty(Vue, 'FunctionalRenderContext', {
-      value: FunctionalRenderContext,
-  });
-  Vue.version = '2.6.14';
-
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  const isReservedAttr = makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const xlinkNS = 'http://www.w3.org/1999/xlink';
-  const isXlink = (name) => {
-      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-  };
-  const getXlinkProp = (name) => {
-      return isXlink(name) ? name.slice(6, name.length) : '';
-  };
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
-  };
-
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
-  }
-
-  const namespaceMap = {
-      svg: 'http://www.w3.org/2000/svg',
-      math: 'http://www.w3.org/1998/Math/MathML',
-  };
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isPreTag = (tag) => tag === 'pre';
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
-  const unknownElementCache = Object.create(null);
-  function isUnknownElement(tag) {
-      /* istanbul ignore if */
-      if (!inBrowser) {
-          return true;
-      }
-      if (isReservedTag(tag)) {
-          return false;
-      }
-      tag = tag.toLowerCase();
-      /* istanbul ignore if */
-      if (unknownElementCache[tag] != null) {
-          return unknownElementCache[tag];
-      }
-      const el = document.createElement(tag);
-      if (tag.indexOf('-') > -1) {
-          // http://stackoverflow.com/a/28210364/1070244
-          return (unknownElementCache[tag] =
-              el.constructor === window.HTMLUnknownElement ||
-                  el.constructor === window.HTMLElement);
-      }
-      else {
-          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-      }
-  }
-  const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-  /**
-   * Query an element selector if it's not an element already.
-   */
-  function query(el) {
-      if (typeof el === 'string') {
-          const selected = document.querySelector(el);
-          if (!selected) {
-              warn$2('Cannot find element: ' + el);
-              return document.createElement('div');
-          }
-          return selected;
-      }
-      else {
-          return el;
-      }
-  }
-
-  function createElement(tagName, vnode) {
-      const elm = document.createElement(tagName);
-      if (tagName !== 'select') {
-          return elm;
-      }
-      // false or null will remove the attribute but undefined will not
-      if (vnode.data &&
-          vnode.data.attrs &&
-          vnode.data.attrs.multiple !== undefined) {
-          elm.setAttribute('multiple', 'multiple');
-      }
-      return elm;
-  }
-  function createElementNS(namespace, tagName) {
-      return document.createElementNS(namespaceMap[namespace], tagName);
-  }
-  function createTextNode(text) {
-      return document.createTextNode(text);
-  }
-  function createComment(text) {
-      return document.createComment(text);
-  }
-  function insertBefore(parentNode, newNode, referenceNode) {
-      parentNode.insertBefore(newNode, referenceNode);
-  }
-  function removeChild(node, child) {
-      node.removeChild(child);
-  }
-  function appendChild(node, child) {
-      node.appendChild(child);
-  }
-  function parentNode(node) {
-      return node.parentNode;
-  }
-  function nextSibling(node) {
-      return node.nextSibling;
-  }
-  function tagName(node) {
-      return node.tagName;
-  }
-  function setTextContent(node, text) {
-      node.textContent = text;
-  }
-  function setStyleScope(node, scopeId) {
-      node.setAttribute(scopeId, '');
-  }
-
-  var nodeOps = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createElement: createElement,
-    createElementNS: createElementNS,
-    createTextNode: createTextNode,
-    createComment: createComment,
-    insertBefore: insertBefore,
-    removeChild: removeChild,
-    appendChild: appendChild,
-    parentNode: parentNode,
-    nextSibling: nextSibling,
-    tagName: tagName,
-    setTextContent: setTextContent,
-    setStyleScope: setStyleScope
-  });
-
-  var ref = {
-      create(_, vnode) {
-          registerRef(vnode);
-      },
-      update(oldVnode, vnode) {
-          if (oldVnode.data.ref !== vnode.data.ref) {
-              registerRef(oldVnode, true);
-              registerRef(vnode);
-          }
-      },
-      destroy(vnode) {
-          registerRef(vnode, true);
-      },
-  };
-  function registerRef(vnode, isRemoval) {
-      const key = vnode.data.ref;
-      if (!isDef(key))
-          return;
-      const vm = vnode.context;
-      const ref = vnode.componentInstance || vnode.elm;
-      const refs = vm.$refs;
-      const obj = refs[key];
-      if (isRemoval) {
-          if (Array.isArray(obj)) {
-              remove$2(obj, ref);
-          }
-          else if (obj === ref) {
-              refs[key] = undefined;
-          }
-      }
-      else {
-          if (vnode.data.refInFor) {
-              if (!Array.isArray(obj)) {
-                  refs[key] = [ref];
-              }
-              else if (obj.indexOf(ref) < 0) {
-                  obj.push(ref);
-              }
-          }
-          else {
-              refs[key] = ref;
-          }
-      }
-  }
-
-  /**
-   * Virtual DOM patching algorithm based on Snabbdom by
-   * Simon Friis Vindum (@paldepind)
-   * Licensed under the MIT License
-   * https://github.com/paldepind/snabbdom/blob/master/LICENSE
-   *
-   * modified by Evan You (@yyx990803)
-   *
-   * Not type-checking this because this file is perf-critical and the cost
-   * of making flow understand it is not worth it.
-   */
-  const emptyNode = new VNode('', {}, []);
-  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-  function sameVnode(a, b) {
-      return (a.key === b.key &&
-          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-          a.isComment === b.isComment &&
-          isDef(a.data) === isDef(b.data) &&
-          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-          isUndef(b.asyncFactory.error))));
-  }
-  function sameInputType(a, b) {
-      if (a.tag !== 'input')
-          return true;
-      let i;
-      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-  }
-  function createKeyToOldIdx(children, beginIdx, endIdx) {
-      let i, key;
-      const map = {};
-      for (i = beginIdx; i <= endIdx; ++i) {
-          key = children[i].key;
-          if (isDef(key))
-              map[key] = i;
-      }
-      return map;
-  }
-  function createPatchFunction(backend) {
-      let i, j;
-      const cbs = {};
-      const { modules, nodeOps } = backend;
-      for (i = 0; i < hooks.length; ++i) {
-          cbs[hooks[i]] = [];
-          for (j = 0; j < modules.length; ++j) {
-              if (isDef(modules[j][hooks[i]])) {
-                  cbs[hooks[i]].push(modules[j][hooks[i]]);
-              }
-          }
-      }
-      function emptyNodeAt(elm) {
-          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-      }
-      function createRmCb(childElm, listeners) {
-          function remove() {
-              if (--remove.listeners === 0) {
-                  removeNode(childElm);
-              }
-          }
-          remove.listeners = listeners;
-          return remove;
-      }
-      function removeNode(el) {
-          const parent = nodeOps.parentNode(el);
-          // element may have already been removed due to v-html / v-text
-          if (isDef(parent)) {
-              nodeOps.removeChild(parent, el);
-          }
-      }
-      function isUnknownElement(vnode, inVPre) {
-          return (!inVPre &&
-              !vnode.ns &&
-              !(config.ignoredElements.length &&
-                  config.ignoredElements.some((ignore) => {
-                      return isRegExp(ignore)
-                          ? ignore.test(vnode.tag)
-                          : ignore === vnode.tag;
-                  })) &&
-              config.isUnknownElement(vnode.tag));
-      }
-      let creatingElmInVPre = 0;
-      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // This vnode was used in a previous render!
-              // now it's used as a new node, overwriting its elm would cause
-              // potential patch errors down the road when it's used as an insertion
-              // reference node. Instead, we clone the node on-demand before creating
-              // associated DOM element for it.
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          vnode.isRootInsert = !nested; // for transition enter check
-          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-              return;
-          }
-          const data = vnode.data;
-          const children = vnode.children;
-          const tag = vnode.tag;
-          if (isDef(tag)) {
-              {
-                  if (data && data.pre) {
-                      creatingElmInVPre++;
-                  }
-                  if (isUnknownElement(vnode, creatingElmInVPre)) {
-                      warn$2('Unknown custom element: <' +
-                          tag +
-                          '> - did you ' +
-                          'register the component correctly? For recursive components, ' +
-                          'make sure to provide the "name" option.', vnode.context);
-                  }
-              }
-              vnode.elm = vnode.ns
-                  ? nodeOps.createElementNS(vnode.ns, tag)
-                  : nodeOps.createElement(tag, vnode);
-              setScope(vnode);
-              /* istanbul ignore if */
-              {
-                  createChildren(vnode, children, insertedVnodeQueue);
-                  if (isDef(data)) {
-                      invokeCreateHooks(vnode, insertedVnodeQueue);
-                  }
-                  insert(parentElm, vnode.elm, refElm);
-              }
-              if (data && data.pre) {
-                  creatingElmInVPre--;
-              }
-          }
-          else if (isTrue(vnode.isComment)) {
-              vnode.elm = nodeOps.createComment(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-          else {
-              vnode.elm = nodeOps.createTextNode(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-      }
-      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i = vnode.data;
-          if (isDef(i)) {
-              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-              if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                  i(vnode, false /* hydrating */);
-              }
-              // after calling the init hook, if the vnode is a child component
-              // it should've created a child instance and mounted it. the child
-              // component also has set the placeholder vnode's elm.
-              // in that case we can just return the element and be done.
-              if (isDef(vnode.componentInstance)) {
-                  initComponent(vnode, insertedVnodeQueue);
-                  insert(parentElm, vnode.elm, refElm);
-                  if (isTrue(isReactivated)) {
-                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                  }
-                  return true;
-              }
-          }
-      }
-      function initComponent(vnode, insertedVnodeQueue) {
-          if (isDef(vnode.data.pendingInsert)) {
-              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-              vnode.data.pendingInsert = null;
-          }
-          vnode.elm = vnode.componentInstance.$el;
-          if (isPatchable(vnode)) {
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              setScope(vnode);
-          }
-          else {
-              // empty component root.
-              // skip all element-related modules except for ref (#3455)
-              registerRef(vnode);
-              // make sure to invoke the insert hook
-              insertedVnodeQueue.push(vnode);
-          }
-      }
-      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i;
-          // hack for #4339: a reactivated component with inner transition
-          // does not trigger because the inner node's created hooks are not called
-          // again. It's not ideal to involve module-specific logic in here but
-          // there doesn't seem to be a better way to do it.
-          let innerNode = vnode;
-          while (innerNode.componentInstance) {
-              innerNode = innerNode.componentInstance._vnode;
-              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                  for (i = 0; i < cbs.activate.length; ++i) {
-                      cbs.activate[i](emptyNode, innerNode);
-                  }
-                  insertedVnodeQueue.push(innerNode);
-                  break;
-              }
-          }
-          // unlike a newly created component,
-          // a reactivated keep-alive component doesn't insert itself
-          insert(parentElm, vnode.elm, refElm);
-      }
-      function insert(parent, elm, ref) {
-          if (isDef(parent)) {
-              if (isDef(ref)) {
-                  if (nodeOps.parentNode(ref) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref);
-                  }
-              }
-              else {
-                  nodeOps.appendChild(parent, elm);
-              }
-          }
-      }
-      function createChildren(vnode, children, insertedVnodeQueue) {
-          if (Array.isArray(children)) {
-              {
-                  checkDuplicateKeys(children);
-              }
-              for (let i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-              }
-          }
-          else if (isPrimitive(vnode.text)) {
-              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-          }
-      }
-      function isPatchable(vnode) {
-          while (vnode.componentInstance) {
-              vnode = vnode.componentInstance._vnode;
-          }
-          return isDef(vnode.tag);
-      }
-      function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (let i = 0; i < cbs.create.length; ++i) {
-              cbs.create[i](emptyNode, vnode);
-          }
-          i = vnode.data.hook; // Reuse variable
-          if (isDef(i)) {
-              if (isDef(i.create))
-                  i.create(emptyNode, vnode);
-              if (isDef(i.insert))
-                  insertedVnodeQueue.push(vnode);
-          }
-      }
-      // set scope id attribute for scoped CSS.
-      // this is implemented as a special case to avoid the overhead
-      // of going through the normal attribute patching process.
-      function setScope(vnode) {
-          let i;
-          if (isDef((i = vnode.fnScopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-          else {
-              let ancestor = vnode;
-              while (ancestor) {
-                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                      nodeOps.setStyleScope(vnode.elm, i);
-                  }
-                  ancestor = ancestor.parent;
-              }
-          }
-          // for slot content they should also get the scopeId from the host instance.
-          if (isDef((i = activeInstance)) &&
-              i !== vnode.context &&
-              i !== vnode.fnContext &&
-              isDef((i = i.$options._scopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-      }
-      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-          }
-      }
-      function invokeDestroyHook(vnode) {
-          let i, j;
-          const data = vnode.data;
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  i(vnode);
-              for (i = 0; i < cbs.destroy.length; ++i)
-                  cbs.destroy[i](vnode);
-          }
-          if (isDef((i = vnode.children))) {
-              for (j = 0; j < vnode.children.length; ++j) {
-                  invokeDestroyHook(vnode.children[j]);
-              }
-          }
-      }
-      function removeVnodes(vnodes, startIdx, endIdx) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              const ch = vnodes[startIdx];
-              if (isDef(ch)) {
-                  if (isDef(ch.tag)) {
-                      removeAndInvokeRemoveHook(ch);
-                      invokeDestroyHook(ch);
-                  }
-                  else {
-                      // Text node
-                      removeNode(ch.elm);
-                  }
-              }
-          }
-      }
-      function removeAndInvokeRemoveHook(vnode, rm) {
-          if (isDef(rm) || isDef(vnode.data)) {
-              let i;
-              const listeners = cbs.remove.length + 1;
-              if (isDef(rm)) {
-                  // we have a recursively passed down rm callback
-                  // increase the listeners count
-                  rm.listeners += listeners;
-              }
-              else {
-                  // directly removing
-                  rm = createRmCb(vnode.elm, listeners);
-              }
-              // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
-              }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
-              }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          }
-          else {
-              removeNode(vnode.elm);
-          }
-      }
-      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          let oldStartIdx = 0;
-          let newStartIdx = 0;
-          let oldEndIdx = oldCh.length - 1;
-          let oldStartVnode = oldCh[0];
-          let oldEndVnode = oldCh[oldEndIdx];
-          let newEndIdx = newCh.length - 1;
-          let newStartVnode = newCh[0];
-          let newEndVnode = newCh[newEndIdx];
-          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-          // removeOnly is a special flag used only by <transition-group>
-          // to ensure removed elements stay in correct relative positions
-          // during leaving transitions
-          const canMove = !removeOnly;
-          {
-              checkDuplicateKeys(newCh);
-          }
-          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-              if (isUndef(oldStartVnode)) {
-                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-              }
-              else if (isUndef(oldEndVnode)) {
-                  oldEndVnode = oldCh[--oldEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newStartVnode)) {
-                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else if (sameVnode(oldEndVnode, newEndVnode)) {
-                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newEndVnode)) {
-                  // Vnode moved right
-                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldEndVnode, newStartVnode)) {
-                  // Vnode moved left
-                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else {
-                  if (isUndef(oldKeyToIdx))
-                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                  idxInOld = isDef(newStartVnode.key)
-                      ? oldKeyToIdx[newStartVnode.key]
-                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                  if (isUndef(idxInOld)) {
-                      // New element
-                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                  }
-                  else {
-                      vnodeToMove = oldCh[idxInOld];
-                      if (sameVnode(vnodeToMove, newStartVnode)) {
-                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                          oldCh[idxInOld] = undefined;
-                          canMove &&
-                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                      }
-                      else {
-                          // same key but different element. treat as new element
-                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                      }
-                  }
-                  newStartVnode = newCh[++newStartIdx];
-              }
-          }
-          if (oldStartIdx > oldEndIdx) {
-              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-          }
-          else if (newStartIdx > newEndIdx) {
-              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-          }
-      }
-      function checkDuplicateKeys(children) {
-          const seenKeys = {};
-          for (let i = 0; i < children.length; i++) {
-              const vnode = children[i];
-              const key = vnode.key;
-              if (isDef(key)) {
-                  if (seenKeys[key]) {
-                      warn$2(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                  }
-                  else {
-                      seenKeys[key] = true;
-                  }
-              }
-          }
-      }
-      function findIdxInOld(node, oldCh, start, end) {
-          for (let i = start; i < end; i++) {
-              const c = oldCh[i];
-              if (isDef(c) && sameVnode(node, c))
-                  return i;
-          }
-      }
-      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-          if (oldVnode === vnode) {
-              return;
-          }
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // clone reused vnode
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          const elm = (vnode.elm = oldVnode.elm);
-          if (isTrue(oldVnode.isAsyncPlaceholder)) {
-              if (isDef(vnode.asyncFactory.resolved)) {
-                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-              }
-              else {
-                  vnode.isAsyncPlaceholder = true;
-              }
-              return;
-          }
-          // reuse element for static trees.
-          // note we only do this if the vnode is cloned -
-          // if the new node is not cloned it means the render functions have been
-          // reset by the hot-reload-api and we need to do a proper re-render.
-          if (isTrue(vnode.isStatic) &&
-              isTrue(oldVnode.isStatic) &&
-              vnode.key === oldVnode.key &&
-              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-              vnode.componentInstance = oldVnode.componentInstance;
-              return;
-          }
-          let i;
-          const data = vnode.data;
-          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-              i(oldVnode, vnode);
-          }
-          const oldCh = oldVnode.children;
-          const ch = vnode.children;
-          if (isDef(data) && isPatchable(vnode)) {
-              for (i = 0; i < cbs.update.length; ++i)
-                  cbs.update[i](oldVnode, vnode);
-              if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  i(oldVnode, vnode);
-          }
-          if (isUndef(vnode.text)) {
-              if (isDef(oldCh) && isDef(ch)) {
-                  if (oldCh !== ch)
-                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-              }
-              else if (isDef(ch)) {
-                  {
-                      checkDuplicateKeys(ch);
-                  }
-                  if (isDef(oldVnode.text))
-                      nodeOps.setTextContent(elm, '');
-                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-              }
-              else if (isDef(oldCh)) {
-                  removeVnodes(oldCh, 0, oldCh.length - 1);
-              }
-              else if (isDef(oldVnode.text)) {
-                  nodeOps.setTextContent(elm, '');
-              }
-          }
-          else if (oldVnode.text !== vnode.text) {
-              nodeOps.setTextContent(elm, vnode.text);
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  i(oldVnode, vnode);
-          }
-      }
-      function invokeInsertHook(vnode, queue, initial) {
-          // delay insert hooks for component root nodes, invoke them after the
-          // element is really inserted
-          if (isTrue(initial) && isDef(vnode.parent)) {
-              vnode.parent.data.pendingInsert = queue;
-          }
-          else {
-              for (let i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
-              }
-          }
-      }
-      let hydrationBailed = false;
-      // list of modules that can skip create hook during hydration because they
-      // are already rendered on the client or has no need for initialization
-      // Note: style is excluded because it relies on initial clone for future
-      // deep updates (#7063).
-      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-      // Note: this is a browser-only function so we can assume elms are DOM nodes.
-      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          let i;
-          const { tag, data, children } = vnode;
-          inVPre = inVPre || (data && data.pre);
-          vnode.elm = elm;
-          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-              vnode.isAsyncPlaceholder = true;
-              return true;
-          }
-          // assert node match
-          {
-              if (!assertNodeMatch(elm, vnode, inVPre)) {
-                  return false;
-              }
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  i(vnode, true /* hydrating */);
-              if (isDef((i = vnode.componentInstance))) {
-                  // child component. it should have hydrated its own tree.
-                  initComponent(vnode, insertedVnodeQueue);
-                  return true;
-              }
-          }
-          if (isDef(tag)) {
-              if (isDef(children)) {
-                  // empty element, allow client to pick up and populate children
-                  if (!elm.hasChildNodes()) {
-                      createChildren(vnode, children, insertedVnodeQueue);
-                  }
-                  else {
-                      // v-html and domProps: innerHTML
-                      if (isDef((i = data)) &&
-                          isDef((i = i.domProps)) &&
-                          isDef((i = i.innerHTML))) {
-                          if (i !== elm.innerHTML) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('server innerHTML: ', i);
-                                  console.warn('client innerHTML: ', elm.innerHTML);
-                              }
-                              return false;
-                          }
-                      }
-                      else {
-                          // iterate and compare children lists
-                          let childrenMatch = true;
-                          let childNode = elm.firstChild;
-                          for (let i = 0; i < children.length; i++) {
-                              if (!childNode ||
-                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                  childrenMatch = false;
-                                  break;
-                              }
-                              childNode = childNode.nextSibling;
-                          }
-                          // if childNode is not null, it means the actual childNodes list is
-                          // longer than the virtual children list.
-                          if (!childrenMatch || childNode) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                              }
-                              return false;
-                          }
-                      }
-                  }
-              }
-              if (isDef(data)) {
-                  let fullInvoke = false;
-                  for (const key in data) {
-                      if (!isRenderedModule(key)) {
-                          fullInvoke = true;
-                          invokeCreateHooks(vnode, insertedVnodeQueue);
-                          break;
-                      }
-                  }
-                  if (!fullInvoke && data['class']) {
-                      // ensure collecting deps for deep class bindings for future updates
-                      traverse(data['class']);
-                  }
-              }
-          }
-          else if (elm.data !== vnode.text) {
-              elm.data = vnode.text;
-          }
-          return true;
-      }
-      function assertNodeMatch(node, vnode, inVPre) {
-          if (isDef(vnode.tag)) {
-              return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement(vnode, inVPre) &&
-                      vnode.tag.toLowerCase() ===
-                          (node.tagName && node.tagName.toLowerCase())));
-          }
-          else {
-              return node.nodeType === (vnode.isComment ? 8 : 3);
-          }
-      }
-      return function patch(oldVnode, vnode, hydrating, removeOnly) {
-          if (isUndef(vnode)) {
-              if (isDef(oldVnode))
-                  invokeDestroyHook(oldVnode);
-              return;
-          }
-          let isInitialPatch = false;
-          const insertedVnodeQueue = [];
-          if (isUndef(oldVnode)) {
-              // empty mount (likely as component), create new root element
-              isInitialPatch = true;
-              createElm(vnode, insertedVnodeQueue);
-          }
-          else {
-              const isRealElement = isDef(oldVnode.nodeType);
-              if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                  // patch existing root node
-                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-              }
-              else {
-                  if (isRealElement) {
-                      // mounting to a real element
-                      // check if this is server-rendered content and if we can perform
-                      // a successful hydration.
-                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                          oldVnode.removeAttribute(SSR_ATTR);
-                          hydrating = true;
-                      }
-                      if (isTrue(hydrating)) {
-                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                              invokeInsertHook(vnode, insertedVnodeQueue, true);
-                              return oldVnode;
-                          }
-                          else {
-                              warn$2('The client-side rendered virtual DOM tree is not matching ' +
-                                  'server-rendered content. This is likely caused by incorrect ' +
-                                  'HTML markup, for example nesting block-level elements inside ' +
-                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                  'full client-side render.');
-                          }
-                      }
-                      // either not server-rendered, or hydration failed.
-                      // create an empty node and replace it
-                      oldVnode = emptyNodeAt(oldVnode);
-                  }
-                  // replacing existing element
-                  const oldElm = oldVnode.elm;
-                  const parentElm = nodeOps.parentNode(oldElm);
-                  // create new node
-                  createElm(vnode, insertedVnodeQueue, 
-                  // extremely rare edge case: do not insert if old element is in a
-                  // leaving transition. Only happens when combining transition +
-                  // keep-alive + HOCs. (#4590)
-                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                  // update parent placeholder node element, recursively
-                  if (isDef(vnode.parent)) {
-                      let ancestor = vnode.parent;
-                      const patchable = isPatchable(vnode);
-                      while (ancestor) {
-                          for (let i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
-                          }
-                          ancestor.elm = vnode.elm;
-                          if (patchable) {
-                              for (let i = 0; i < cbs.create.length; ++i) {
-                                  cbs.create[i](emptyNode, ancestor);
-                              }
-                              // #6513
-                              // invoke insert hooks that may have been merged by create hooks.
-                              // e.g. for directives that uses the "inserted" hook.
-                              const insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
-                                  // start at index 1 to avoid re-invoking component mounted hook
-                                  for (let i = 1; i < insert.fns.length; i++) {
-                                      insert.fns[i]();
-                                  }
-                              }
-                          }
-                          else {
-                              registerRef(ancestor);
-                          }
-                          ancestor = ancestor.parent;
-                      }
-                  }
-                  // destroy old node
-                  if (isDef(parentElm)) {
-                      removeVnodes([oldVnode], 0, 0);
-                  }
-                  else if (isDef(oldVnode.tag)) {
-                      invokeDestroyHook(oldVnode);
-                  }
-              }
-          }
-          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-          return vnode.elm;
-      };
-  }
-
-  var directives$1 = {
-      create: updateDirectives,
-      update: updateDirectives,
-      destroy: function unbindDirectives(vnode) {
-          // @ts-expect-error emptyNode is not VNodeWithData
-          updateDirectives(vnode, emptyNode);
-      },
-  };
-  function updateDirectives(oldVnode, vnode) {
-      if (oldVnode.data.directives || vnode.data.directives) {
-          _update(oldVnode, vnode);
-      }
-  }
-  function _update(oldVnode, vnode) {
-      const isCreate = oldVnode === emptyNode;
-      const isDestroy = vnode === emptyNode;
-      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      const dirsWithInsert = [];
-      const dirsWithPostpatch = [];
-      let key, oldDir, dir;
-      for (key in newDirs) {
-          oldDir = oldDirs[key];
-          dir = newDirs[key];
-          if (!oldDir) {
-              // new directive, bind
-              callHook(dir, 'bind', vnode, oldVnode);
-              if (dir.def && dir.def.inserted) {
-                  dirsWithInsert.push(dir);
-              }
-          }
-          else {
-              // existing directive, update
-              dir.oldValue = oldDir.value;
-              dir.oldArg = oldDir.arg;
-              callHook(dir, 'update', vnode, oldVnode);
-              if (dir.def && dir.def.componentUpdated) {
-                  dirsWithPostpatch.push(dir);
-              }
-          }
-      }
-      if (dirsWithInsert.length) {
-          const callInsert = () => {
-              for (let i = 0; i < dirsWithInsert.length; i++) {
-                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-              }
-          };
-          if (isCreate) {
-              mergeVNodeHook(vnode, 'insert', callInsert);
-          }
-          else {
-              callInsert();
-          }
-      }
-      if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', () => {
-              for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-              }
-          });
-      }
-      if (!isCreate) {
-          for (key in oldDirs) {
-              if (!newDirs[key]) {
-                  // no longer present, unbind
-                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-              }
-          }
-      }
-  }
-  const emptyModifiers = Object.create(null);
-  function normalizeDirectives(dirs, vm) {
-      const res = Object.create(null);
-      if (!dirs) {
-          // $flow-disable-line
-          return res;
-      }
-      let i, dir;
-      for (i = 0; i < dirs.length; i++) {
-          dir = dirs[i];
-          if (!dir.modifiers) {
-              // $flow-disable-line
-              dir.modifiers = emptyModifiers;
-          }
-          res[getRawDirName(dir)] = dir;
-          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-      }
-      // $flow-disable-line
-      return res;
-  }
-  function getRawDirName(dir) {
-      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-  }
-  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      const fn = dir.def && dir.def[hook];
-      if (fn) {
-          try {
-              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-          }
-          catch (e) {
-              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-          }
-      }
-  }
-
-  var baseModules = [ref, directives$1];
-
-  function updateAttrs(oldVnode, vnode) {
-      const opts = vnode.componentOptions;
-      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-          return;
-      }
-      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-          return;
-      }
-      let key, cur, old;
-      const elm = vnode.elm;
-      const oldAttrs = oldVnode.data.attrs || {};
-      let attrs = vnode.data.attrs || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(attrs.__ob__)) {
-          attrs = vnode.data.attrs = extend({}, attrs);
-      }
-      for (key in attrs) {
-          cur = attrs[key];
-          old = oldAttrs[key];
-          if (old !== cur) {
-              setAttr(elm, key, cur, vnode.data.pre);
-          }
-      }
-      // #4391: in IE9, setting type can reset value for input[type=radio]
-      // #6666: IE/Edge forces progress value down to 1 before setting a max
-      /* istanbul ignore if */
-      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-          setAttr(elm, 'value', attrs.value);
-      }
-      for (key in oldAttrs) {
-          if (isUndef(attrs[key])) {
-              if (isXlink(key)) {
-                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-              }
-              else if (!isEnumeratedAttr(key)) {
-                  elm.removeAttribute(key);
-              }
-          }
-      }
-  }
-  function setAttr(el, key, value, isInPre) {
-      if (isInPre || el.tagName.indexOf('-') > -1) {
-          baseSetAttr(el, key, value);
-      }
-      else if (isBooleanAttr(key)) {
-          // set attribute for blank value
-          // e.g. <option disabled>Select one</option>
-          if (isFalsyAttrValue(value)) {
-              el.removeAttribute(key);
-          }
-          else {
-              // technically allowfullscreen is a boolean attribute for <iframe>,
-              // but Flash expects a value of "true" when used on <embed> tag
-              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-              el.setAttribute(key, value);
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          el.setAttribute(key, convertEnumeratedValue(key, value));
-      }
-      else if (isXlink(key)) {
-          if (isFalsyAttrValue(value)) {
-              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-          }
-          else {
-              el.setAttributeNS(xlinkNS, key, value);
-          }
-      }
-      else {
-          baseSetAttr(el, key, value);
-      }
-  }
-  function baseSetAttr(el, key, value) {
-      if (isFalsyAttrValue(value)) {
-          el.removeAttribute(key);
-      }
-      else {
-          // #7138: IE10 & 11 fires input event when setting placeholder on
-          // <textarea>... block the first input event and remove the blocker
-          // immediately.
-          /* istanbul ignore if */
-          if (isIE &&
-              !isIE9 &&
-              el.tagName === 'TEXTAREA' &&
-              key === 'placeholder' &&
-              value !== '' &&
-              !el.__ieph) {
-              const blocker = (e) => {
-                  e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
-              };
-              el.addEventListener('input', blocker);
-              // $flow-disable-line
-              el.__ieph = true; /* IE placeholder patched */
-          }
-          el.setAttribute(key, value);
-      }
-  }
-  var attrs = {
-      create: updateAttrs,
-      update: updateAttrs,
-  };
-
-  function updateClass(oldVnode, vnode) {
-      const el = vnode.elm;
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticClass) &&
-          isUndef(data.class) &&
-          (isUndef(oldData) ||
-              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-          return;
-      }
-      let cls = genClassForVnode(vnode);
-      // handle transition classes
-      const transitionClass = el._transitionClasses;
-      if (isDef(transitionClass)) {
-          cls = concat(cls, stringifyClass(transitionClass));
-      }
-      // set the class
-      if (cls !== el._prevClass) {
-          el.setAttribute('class', cls);
-          el._prevClass = cls;
-      }
-  }
-  var klass$1 = {
-      create: updateClass,
-      update: updateClass,
-  };
-
-  const validDivisionCharRE = /[\w).+\-_$\]]/;
-  function parseFilters(exp) {
-      let inSingle = false;
-      let inDouble = false;
-      let inTemplateString = false;
-      let inRegex = false;
-      let curly = 0;
-      let square = 0;
-      let paren = 0;
-      let lastFilterIndex = 0;
-      let c, prev, i, expression, filters;
-      for (i = 0; i < exp.length; i++) {
-          prev = c;
-          c = exp.charCodeAt(i);
-          if (inSingle) {
-              if (c === 0x27 && prev !== 0x5c)
-                  inSingle = false;
-          }
-          else if (inDouble) {
-              if (c === 0x22 && prev !== 0x5c)
-                  inDouble = false;
-          }
-          else if (inTemplateString) {
-              if (c === 0x60 && prev !== 0x5c)
-                  inTemplateString = false;
-          }
-          else if (inRegex) {
-              if (c === 0x2f && prev !== 0x5c)
-                  inRegex = false;
-          }
-          else if (c === 0x7c && // pipe
-              exp.charCodeAt(i + 1) !== 0x7c &&
-              exp.charCodeAt(i - 1) !== 0x7c &&
-              !curly &&
-              !square &&
-              !paren) {
-              if (expression === undefined) {
-                  // first filter, end of expression
-                  lastFilterIndex = i + 1;
-                  expression = exp.slice(0, i).trim();
-              }
-              else {
-                  pushFilter();
-              }
-          }
-          else {
-              switch (c) {
-                  case 0x22:
-                      inDouble = true;
-                      break; // "
-                  case 0x27:
-                      inSingle = true;
-                      break; // '
-                  case 0x60:
-                      inTemplateString = true;
-                      break; // `
-                  case 0x28:
-                      paren++;
-                      break; // (
-                  case 0x29:
-                      paren--;
-                      break; // )
-                  case 0x5b:
-                      square++;
-                      break; // [
-                  case 0x5d:
-                      square--;
-                      break; // ]
-                  case 0x7b:
-                      curly++;
-                      break; // {
-                  case 0x7d:
-                      curly--;
-                      break; // }
-              }
-              if (c === 0x2f) {
-                  // /
-                  let j = i - 1;
-                  let p;
-                  // find first non-whitespace prev char
-                  for (; j >= 0; j--) {
-                      p = exp.charAt(j);
-                      if (p !== ' ')
-                          break;
-                  }
-                  if (!p || !validDivisionCharRE.test(p)) {
-                      inRegex = true;
-                  }
-              }
-          }
-      }
-      if (expression === undefined) {
-          expression = exp.slice(0, i).trim();
-      }
-      else if (lastFilterIndex !== 0) {
-          pushFilter();
-      }
-      function pushFilter() {
-          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-          lastFilterIndex = i + 1;
-      }
-      if (filters) {
-          for (i = 0; i < filters.length; i++) {
-              expression = wrapFilter(expression, filters[i]);
-          }
-      }
-      return expression;
-  }
-  function wrapFilter(exp, filter) {
-      const i = filter.indexOf('(');
-      if (i < 0) {
-          // _f: resolveFilter
-          return `_f("${filter}")(${exp})`;
-      }
-      else {
-          const name = filter.slice(0, i);
-          const args = filter.slice(i + 1);
-          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-      }
-  }
-
-  /* eslint-disable no-unused-vars */
-  function baseWarn(msg, range) {
-      console.error(`[Vue compiler]: ${msg}`);
-  }
-  /* eslint-enable no-unused-vars */
-  function pluckModuleFunction(modules, key) {
-      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-  }
-  function addProp(el, name, value, range, dynamic) {
-      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  function addAttr(el, name, value, range, dynamic) {
-      const attrs = dynamic
-          ? el.dynamicAttrs || (el.dynamicAttrs = [])
-          : el.attrs || (el.attrs = []);
-      attrs.push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr(el, name, value, range) {
-      el.attrsMap[name] = value;
-      el.attrsList.push(rangeSetItem({ name, value }, range));
-  }
-  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-      (el.directives || (el.directives = [])).push(rangeSetItem({
-          name,
-          rawName,
-          value,
-          arg,
-          isDynamicArg,
-          modifiers,
-      }, range));
-      el.plain = false;
-  }
-  function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-  }
-  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-      modifiers = modifiers || emptyObject;
-      // warn prevent and passive modifier
-      /* istanbul ignore if */
-      if (warn &&
-          modifiers.prevent &&
-          modifiers.passive) {
-          warn("passive and prevent can't be used together. " +
-              "Passive handler can't prevent default event.", range);
-      }
-      // normalize click.right and click.middle since they don't actually fire
-      // this is technically browser-specific, but at least for now browsers are
-      // the only target envs that have right/middle clicks.
-      if (modifiers.right) {
-          if (dynamic) {
-              name = `(${name})==='click'?'contextmenu':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'contextmenu';
-              delete modifiers.right;
-          }
-      }
-      else if (modifiers.middle) {
-          if (dynamic) {
-              name = `(${name})==='click'?'mouseup':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'mouseup';
-          }
-      }
-      // check capture modifier
-      if (modifiers.capture) {
-          delete modifiers.capture;
-          name = prependModifierMarker('!', name, dynamic);
-      }
-      if (modifiers.once) {
-          delete modifiers.once;
-          name = prependModifierMarker('~', name, dynamic);
-      }
-      /* istanbul ignore if */
-      if (modifiers.passive) {
-          delete modifiers.passive;
-          name = prependModifierMarker('&', name, dynamic);
-      }
-      let events;
-      if (modifiers.native) {
-          delete modifiers.native;
-          events = el.nativeEvents || (el.nativeEvents = {});
-      }
-      else {
-          events = el.events || (el.events = {});
-      }
-      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-      if (modifiers !== emptyObject) {
-          newHandler.modifiers = modifiers;
-      }
-      const handlers = events[name];
-      /* istanbul ignore if */
-      if (Array.isArray(handlers)) {
-          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-      }
-      else if (handlers) {
-          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-      }
-      else {
-          events[name] = newHandler;
-      }
-      el.plain = false;
-  }
-  function getRawBindingAttr(el, name) {
-      return (el.rawAttrsMap[':' + name] ||
-          el.rawAttrsMap['v-bind:' + name] ||
-          el.rawAttrsMap[name]);
-  }
-  function getBindingAttr(el, name, getStatic) {
-      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-      if (dynamicValue != null) {
-          return parseFilters(dynamicValue);
-      }
-      else if (getStatic !== false) {
-          const staticValue = getAndRemoveAttr(el, name);
-          if (staticValue != null) {
-              return JSON.stringify(staticValue);
-          }
-      }
-  }
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr(el, name, removeFromMap) {
-      let val;
-      if ((val = el.attrsMap[name]) != null) {
-          const list = el.attrsList;
-          for (let i = 0, l = list.length; i < l; i++) {
-              if (list[i].name === name) {
-                  list.splice(i, 1);
-                  break;
-              }
-          }
-      }
-      if (removeFromMap) {
-          delete el.attrsMap[name];
-      }
-      return val;
-  }
-  function getAndRemoveAttrByRegex(el, name) {
-      const list = el.attrsList;
-      for (let i = 0, l = list.length; i < l; i++) {
-          const attr = list[i];
-          if (name.test(attr.name)) {
-              list.splice(i, 1);
-              return attr;
-          }
-      }
-  }
-  function rangeSetItem(item, range) {
-      if (range) {
-          if (range.start != null) {
-              item.start = range.start;
-          }
-          if (range.end != null) {
-              item.end = range.end;
-          }
-      }
-      return item;
-  }
-
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel(el, value, modifiers) {
-      const { number, trim } = modifiers || {};
-      const baseValueExpression = '$$v';
-      let valueExpression = baseValueExpression;
-      if (trim) {
-          valueExpression =
-              `(typeof ${baseValueExpression} === 'string'` +
-                  `? ${baseValueExpression}.trim()` +
-                  `: ${baseValueExpression})`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      const assignment = genAssignmentCode(value, valueExpression);
-      el.model = {
-          value: `(${value})`,
-          expression: JSON.stringify(value),
-          callback: `function (${baseValueExpression}) {${assignment}}`,
-      };
-  }
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode(value, assignment) {
-      const res = parseModel(value);
-      if (res.key === null) {
-          return `${value}=${assignment}`;
-      }
-      else {
-          return `$set(${res.exp}, ${res.key}, ${assignment})`;
-      }
-  }
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-  let len, str, chr, index, expressionPos, expressionEndPos;
-  function parseModel(val) {
-      // Fix https://github.com/vuejs/vue/pull/7730
-      // allow v-model="obj.val " (trailing whitespace)
-      val = val.trim();
-      len = val.length;
-      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-          index = val.lastIndexOf('.');
-          if (index > -1) {
-              return {
-                  exp: val.slice(0, index),
-                  key: '"' + val.slice(index + 1) + '"',
-              };
-          }
-          else {
-              return {
-                  exp: val,
-                  key: null,
-              };
-          }
-      }
-      str = val;
-      index = expressionPos = expressionEndPos = 0;
-      while (!eof()) {
-          chr = next();
-          /* istanbul ignore if */
-          if (isStringStart(chr)) {
-              parseString(chr);
-          }
-          else if (chr === 0x5b) {
-              parseBracket(chr);
-          }
-      }
-      return {
-          exp: val.slice(0, expressionPos),
-          key: val.slice(expressionPos + 1, expressionEndPos),
-      };
-  }
-  function next() {
-      return str.charCodeAt(++index);
-  }
-  function eof() {
-      return index >= len;
-  }
-  function isStringStart(chr) {
-      return chr === 0x22 || chr === 0x27;
-  }
-  function parseBracket(chr) {
-      let inBracket = 1;
-      expressionPos = index;
-      while (!eof()) {
-          chr = next();
-          if (isStringStart(chr)) {
-              parseString(chr);
-              continue;
-          }
-          if (chr === 0x5b)
-              inBracket++;
-          if (chr === 0x5d)
-              inBracket--;
-          if (inBracket === 0) {
-              expressionEndPos = index;
-              break;
-          }
-      }
-  }
-  function parseString(chr) {
-      const stringQuote = chr;
-      while (!eof()) {
-          chr = next();
-          if (chr === stringQuote) {
-              break;
-          }
-      }
-  }
-
-  let warn$1;
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
-  const CHECKBOX_RADIO_TOKEN = '__c';
-  function model$1(el, dir, _warn) {
-      warn$1 = _warn;
-      const value = dir.value;
-      const modifiers = dir.modifiers;
-      const tag = el.tag;
-      const type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn$1(`<${el.tag} v-model="${value}" type="file">:\n` +
-                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else if (!config.isReservedTag(tag)) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else {
-          warn$1(`<${el.tag} v-model="${value}">: ` +
-              `v-model is not supported on this element type. ` +
-              "If you are working with contenteditable, it's recommended to " +
-              'wrap a library dedicated for that purpose inside a custom component.', el.rawAttrsMap['v-model']);
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const valueBinding = getBindingAttr(el, 'value') || 'null';
-      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', `Array.isArray(${value})` +
-          `?_i(${value},${valueBinding})>-1` +
-          (trueValueBinding === 'true'
-              ? `:(${value})`
-              : `:_q(${value},${trueValueBinding})`));
-      addHandler(el, 'change', `var $$a=${value},` +
-          '$$el=$event.target,' +
-          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-          'if(Array.isArray($$a)){' +
-          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      let valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-      addProp(el, 'checked', `_q(${value},${valueBinding})`);
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const selectedVal = `Array.prototype.filter` +
-          `.call($event.target.options,function(o){return o.selected})` +
-          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-          `return ${number ? '_n(val)' : 'val'}})`;
-      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      let code = `var $$selectedVal = ${selectedVal};`;
-      code = `${code} ${genAssignmentCode(value, assignment)}`;
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      const type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value && !typeBinding) {
-              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn$1(`${binding}="${value}" conflicts with v-model on the same element ` +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      const { lazy, number, trim } = modifiers || {};
-      const needCompositionGuard = !lazy && type !== 'range';
-      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      let valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = `$event.target.value.trim()`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      let code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = `if($event.target.composing)return;${code}`;
-      }
-      addProp(el, 'value', `(${value})`);
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
-  }
-
-  // normalize v-model event tokens that can only be determined at runtime.
-  // it's important to place the event as the first in the array because
-  // the whole point is ensuring the v-model callback gets called before
-  // user-attached handlers.
-  function normalizeEvents(on) {
-      /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN])) {
-          // IE input[type=range] only supports `change` event
-          const event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-          delete on[RANGE_TOKEN];
-      }
-      // This was originally intended to fix #4521 but no longer necessary
-      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-      /* istanbul ignore if */
-      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-          delete on[CHECKBOX_RADIO_TOKEN];
-      }
-  }
-  let target;
-  function createOnceHandler(event, handler, capture) {
-      const _target = target; // save current target element in closure
-      return function onceHandler() {
-          const res = handler.apply(null, arguments);
-          if (res !== null) {
-              remove(event, onceHandler, capture, _target);
-          }
-      };
-  }
-  // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-  // implementation and does not fire microtasks in between event propagation, so
-  // safe to exclude.
-  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-  function add(name, handler, capture, passive) {
-      // async edge case #6566: inner click event triggers patch, event handler
-      // attached to outer element during patch, and triggered again. This
-      // happens because browsers fire microtask ticks between event propagation.
-      // the solution is simple: we save the timestamp when a handler is attached,
-      // and the handler would only fire if the event passed to it was fired
-      // AFTER it was attached.
-      if (useMicrotaskFix) {
-          const attachedTimestamp = currentFlushTimestamp;
-          const original = handler;
-          //@ts-expect-error 
-          handler = original._wrapper = function (e) {
-              if (
-              // no bubbling, should always fire.
-              // this is just a safety net in case event.timeStamp is unreliable in
-              // certain weird environments...
-              e.target === e.currentTarget ||
-                  // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
-                  // bail for environments that have buggy event.timeStamp implementations
-                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                  // #9681 QtWebEngine event.timeStamp is negative value
-                  e.timeStamp <= 0 ||
-                  // #9448 bail if event is fired in another document in a multi-page
-                  // electron/nw.js app, since event.timeStamp will be using a different
-                  // starting reference
-                  e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
-              }
-          };
-      }
-      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-  }
-  function remove(name, handler, capture, _target) {
-      (_target || target).removeEventListener(name, 
-      //@ts-expect-error
-      handler._wrapper || handler, capture);
-  }
-  function updateDOMListeners(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-          return;
-      }
-      const on = vnode.data.on || {};
-      const oldOn = oldVnode.data.on || {};
-      // vnode is empty when removing all listeners,
-      // and use old vnode dom element
-      target = vnode.elm || oldVnode.elm;
-      normalizeEvents(on);
-      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-      target = undefined;
-  }
-  var events = {
-      create: updateDOMListeners,
-      update: updateDOMListeners,
-      // @ts-expect-error emptyNode has actually data
-      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-  };
-
-  let svgContainer;
-  function updateDOMProps(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-          return;
-      }
-      let key, cur;
-      const elm = vnode.elm;
-      const oldProps = oldVnode.data.domProps || {};
-      let props = vnode.data.domProps || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(props.__ob__)) {
-          props = vnode.data.domProps = extend({}, props);
-      }
-      for (key in oldProps) {
-          if (!(key in props)) {
-              elm[key] = '';
-          }
-      }
-      for (key in props) {
-          cur = props[key];
-          // ignore children if the node has textContent or innerHTML,
-          // as these will throw away existing DOM nodes and cause removal errors
-          // on subsequent patches (#3360)
-          if (key === 'textContent' || key === 'innerHTML') {
-              if (vnode.children)
-                  vnode.children.length = 0;
-              if (cur === oldProps[key])
-                  continue;
-              // #6601 work around Chrome version <= 55 bug where single textNode
-              // replaced by innerHTML/textContent retains its parentNode property
-              if (elm.childNodes.length === 1) {
-                  elm.removeChild(elm.childNodes[0]);
-              }
-          }
-          if (key === 'value' && elm.tagName !== 'PROGRESS') {
-              // store value as _value as well since
-              // non-string values will be stringified
-              elm._value = cur;
-              // avoid resetting cursor position when value is the same
-              const strCur = isUndef(cur) ? '' : String(cur);
-              if (shouldUpdateValue(elm, strCur)) {
-                  elm.value = strCur;
-              }
-          }
-          else if (key === 'innerHTML' &&
-              isSVG(elm.tagName) &&
-              isUndef(elm.innerHTML)) {
-              // IE doesn't support innerHTML for SVG elements
-              svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = `<svg>${cur}</svg>`;
-              const svg = svgContainer.firstChild;
-              while (elm.firstChild) {
-                  elm.removeChild(elm.firstChild);
-              }
-              while (svg.firstChild) {
-                  elm.appendChild(svg.firstChild);
-              }
-          }
-          else if (
-          // skip the update if old and new VDOM state is the same.
-          // `value` is handled separately because the DOM value may be temporarily
-          // out of sync with VDOM state due to focus, composition and modifiers.
-          // This  #4521 by skipping the unnecessary `checked` update.
-          cur !== oldProps[key]) {
-              // some property updates can throw
-              // e.g. `value` on <progress> w/ non-finite value
-              try {
-                  elm[key] = cur;
-              }
-              catch (e) { }
-          }
-      }
-  }
-  function shouldUpdateValue(elm, checkVal) {
-      return (
-      //@ts-expect-error
-      !elm.composing &&
-          (elm.tagName === 'OPTION' ||
-              isNotInFocusAndDirty(elm, checkVal) ||
-              isDirtyWithModifiers(elm, checkVal)));
-  }
-  function isNotInFocusAndDirty(elm, checkVal) {
-      // return true when textbox (.number and .trim) loses focus and its value is
-      // not equal to the updated value
-      let notInFocus = true;
-      // #6157
-      // work around IE bug when accessing document.activeElement in an iframe
-      try {
-          notInFocus = document.activeElement !== elm;
-      }
-      catch (e) { }
-      return notInFocus && elm.value !== checkVal;
-  }
-  function isDirtyWithModifiers(elm, newVal) {
-      const value = elm.value;
-      const modifiers = elm._vModifiers; // injected by v-model runtime
-      if (isDef(modifiers)) {
-          if (modifiers.number) {
-              return toNumber(value) !== toNumber(newVal);
-          }
-          if (modifiers.trim) {
-              return value.trim() !== newVal.trim();
-          }
-      }
-      return value !== newVal;
-  }
-  var domProps = {
-      create: updateDOMProps,
-      update: updateDOMProps,
-  };
-
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
-  }
-
-  const cssVarRE = /^--/;
-  const importantRE = /\s*!important$/;
-  const setProp = (el, name, val) => {
-      /* istanbul ignore if */
-      if (cssVarRE.test(name)) {
-          el.style.setProperty(name, val);
-      }
-      else if (importantRE.test(val)) {
-          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-      }
-      else {
-          const normalizedName = normalize(name);
-          if (Array.isArray(val)) {
-              // Support values array created by autoprefixer, e.g.
-              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-              // Set them one by one, and the browser will only set those it can recognize
-              for (let i = 0, len = val.length; i < len; i++) {
-                  el.style[normalizedName] = val[i];
-              }
-          }
-          else {
-              el.style[normalizedName] = val;
-          }
-      }
-  };
-  const vendorNames = ['Webkit', 'Moz', 'ms'];
-  let emptyStyle;
-  const normalize = cached(function (prop) {
-      emptyStyle = emptyStyle || document.createElement('div').style;
-      prop = camelize(prop);
-      if (prop !== 'filter' && prop in emptyStyle) {
-          return prop;
-      }
-      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (let i = 0; i < vendorNames.length; i++) {
-          const name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
-          }
-      }
-  });
-  function updateStyle(oldVnode, vnode) {
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticStyle) &&
-          isUndef(data.style) &&
-          isUndef(oldData.staticStyle) &&
-          isUndef(oldData.style)) {
-          return;
-      }
-      let cur, name;
-      const el = vnode.elm;
-      const oldStaticStyle = oldData.staticStyle;
-      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      const oldStyle = oldStaticStyle || oldStyleBinding;
-      const style = normalizeStyleBinding(vnode.data.style) || {};
-      // store normalized style under a different key for next diff
-      // make sure to clone it if it's reactive, since the user likely wants
-      // to mutate it.
-      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      const newStyle = getStyle(vnode, true);
-      for (name in oldStyle) {
-          if (isUndef(newStyle[name])) {
-              setProp(el, name, '');
-          }
-      }
-      for (name in newStyle) {
-          cur = newStyle[name];
-          if (cur !== oldStyle[name]) {
-              // ie9 setting to null has no effect, must use empty string
-              setProp(el, name, cur == null ? '' : cur);
-          }
-      }
-  }
-  var style$1 = {
-      create: updateStyle,
-      update: updateStyle,
-  };
-
-  const whitespaceRE$1 = /\s+/;
-  /**
-   * Add class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function addClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach((c) => el.classList.add(c));
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          const cur = ` ${el.getAttribute('class') || ''} `;
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
-  }
-  /**
-   * Remove class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function removeClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE$1).forEach((c) => el.classList.remove(c));
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          let cur = ` ${el.getAttribute('class') || ''} `;
-          const tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
-  }
-
-  function resolveTransition(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          const res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition(def);
-      }
-  }
-  const autoCssTransition = cached((name) => {
-      return {
-          enterClass: `${name}-enter`,
-          enterToClass: `${name}-enter-to`,
-          enterActiveClass: `${name}-enter-active`,
-          leaveClass: `${name}-leave`,
-          leaveToClass: `${name}-leave-to`,
-          leaveActiveClass: `${name}-leave-active`,
-      };
-  });
-  const hasTransition = inBrowser && !isIE9;
-  const TRANSITION = 'transition';
-  const ANIMATION = 'animation';
-  // Transition property/event sniffing
-  let transitionProp = 'transition';
-  let transitionEndEvent = 'transitionend';
-  let animationProp = 'animation';
-  let animationEndEvent = 'animationend';
-  if (hasTransition) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
-      }
-  }
-  // binding to window is necessary to make hot reload work in IE in strict mode
-  const raf = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ (fn) => fn();
-  function nextFrame(fn) {
-      raf(() => {
-          // @ts-expect-error
-          raf(fn);
-      });
-  }
-  function addTransitionClass(el, cls) {
-      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass(el, cls);
-      }
-  }
-  function removeTransitionClass(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass(el, cls);
-  }
-  function whenTransitionEnds(el, expectedType, cb) {
-      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-      if (!type)
-          return cb();
-      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      let ended = 0;
-      const end = () => {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      const onEnd = (e) => {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(() => {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
-  }
-  const transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
-      const styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      const animationTimeout = getTimeout(animationDelays, animationDurations);
-      let type;
-      let timeout = 0;
-      let propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION) {
-          if (animationTimeout > 0) {
-              type = ANIMATION;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
-                  : null;
-          propCount = type
-              ? type === TRANSITION
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-      return {
-          type,
-          timeout,
-          propCount,
-          hasTransform,
-      };
-  }
-  function getTimeout(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map((d, i) => {
-          return toMs(d) + toMs(delays[i]);
-      }));
-  }
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-  }
-
-  function enter(vnode, toggleDisplay) {
-      const el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      let context = activeInstance;
-      let transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      const isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      const startClass = isAppear && appearClass ? appearClass : enterClass;
-      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      const enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      const enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
-      }
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(enterHook);
-      const cb = (el._enterCb = once(() => {
-          if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', () => {
-              const parent = el.parentNode;
-              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
-      if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(() => {
-              removeTransitionClass(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
-      }
-  }
-  function leave(vnode, rm) {
-      const el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
-      }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
-      }
-      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(leave);
-      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
-      }
-      const cb = (el._leaveCb = once(() => {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
-              }
-              leaveCancelled && leaveCancelled(el);
-          }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
-      }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(() => {
-                  removeTransitionClass(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
-      }
-  }
-  // only used in dev mode
-  function checkDuration(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn$2(`<transition> explicit ${name} duration is not a valid number - ` +
-              `got ${JSON.stringify(val)}.`, vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn$2(`<transition> explicit ${name} duration is NaN - ` +
-              'the duration expression might be incorrect.', vnode.context);
-      }
-  }
-  function isValidDuration(val) {
-      return typeof val === 'number' && !isNaN(val);
-  }
-  /**
-   * Normalize a transition hook's argument length. The hook may be:
-   * - a merged hook (invoker) with the original in .fns
-   * - a wrapped component method (check ._length)
-   * - a plain function (.length)
-   */
-  function getHookArgumentsLength(fn) {
-      if (isUndef(fn)) {
-          return false;
-      }
-      // @ts-expect-error
-      const invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-      }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
-      }
-  }
-  function _enter(_, vnode) {
-      if (vnode.data.show !== true) {
-          enter(vnode);
-      }
-  }
-  var transition = inBrowser
-      ? {
-          create: _enter,
-          activate: _enter,
-          remove(vnode, rm) {
-              /* istanbul ignore else */
-              if (vnode.data.show !== true) {
-                  // @ts-expect-error
-                  leave(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          },
-      }
-      : {};
-
-  var platformModules = [attrs, klass$1, events, domProps, style$1, transition];
-
-  // the directive module should be applied last, after all
-  // built-in modules have been applied.
-  const modules$1 = platformModules.concat(baseModules);
-  const patch = createPatchFunction({ nodeOps, modules: modules$1 });
-
-  /**
-   * Not type checking this file because flow doesn't like attaching
-   * properties to Elements.
-   */
-  /* istanbul ignore if */
-  if (isIE9) {
-      // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', () => {
-          const el = document.activeElement;
-          // @ts-expect-error
-          if (el && el.vmodel) {
-              trigger(el, 'input');
-          }
-      });
-  }
-  const directive = {
-      inserted(el, binding, vnode, oldVnode) {
-          if (vnode.tag === 'select') {
-              // #6903
-              if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', () => {
-                      directive.componentUpdated(el, binding, vnode);
-                  });
-              }
-              else {
-                  setSelected(el, binding, vnode.context);
-              }
-              el._vOptions = [].map.call(el.options, getValue);
-          }
-          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-              el._vModifiers = binding.modifiers;
-              if (!binding.modifiers.lazy) {
-                  el.addEventListener('compositionstart', onCompositionStart);
-                  el.addEventListener('compositionend', onCompositionEnd);
-                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                  // switching focus before confirming composition choice
-                  // this also fixes the issue where some browsers e.g. iOS Chrome
-                  // fires "change" instead of "input" on autocomplete.
-                  el.addEventListener('change', onCompositionEnd);
-                  /* istanbul ignore if */
-                  if (isIE9) {
-                      el.vmodel = true;
-                  }
-              }
-          }
-      },
-      componentUpdated(el, binding, vnode) {
-          if (vnode.tag === 'select') {
-              setSelected(el, binding, vnode.context);
-              // in case the options rendered by v-for have changed,
-              // it's possible that the value is out-of-sync with the rendered options.
-              // detect such cases and filter out values that no longer has a matching
-              // option in the DOM.
-              const prevOptions = el._vOptions;
-              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                  // trigger change event if
-                  // no matching option found for at least one value
-                  const needReset = el.multiple
-                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                      : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
-                  if (needReset) {
-                      trigger(el, 'change');
-                  }
-              }
-          }
-      },
-  };
-  function setSelected(el, binding, vm) {
-      actuallySetSelected(el, binding, vm);
-      /* istanbul ignore if */
-      if (isIE || isEdge) {
-          setTimeout(() => {
-              actuallySetSelected(el, binding, vm);
-          }, 0);
-      }
-  }
-  function actuallySetSelected(el, binding, vm) {
-      const value = binding.value;
-      const isMultiple = el.multiple;
-      if (isMultiple && !Array.isArray(value)) {
-          warn$2(`<select multiple v-model="${binding.expression}"> ` +
-                  `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-          return;
-      }
-      let selected, option;
-      for (let i = 0, l = el.options.length; i < l; i++) {
-          option = el.options[i];
-          if (isMultiple) {
-              selected = looseIndexOf(value, getValue(option)) > -1;
-              if (option.selected !== selected) {
-                  option.selected = selected;
-              }
-          }
-          else {
-              if (looseEqual(getValue(option), value)) {
-                  if (el.selectedIndex !== i) {
-                      el.selectedIndex = i;
-                  }
-                  return;
-              }
-          }
-      }
-      if (!isMultiple) {
-          el.selectedIndex = -1;
-      }
-  }
-  function hasNoMatchingOption(value, options) {
-      return options.every((o) => !looseEqual(o, value));
-  }
-  function getValue(option) {
-      return '_value' in option ? option._value : option.value;
-  }
-  function onCompositionStart(e) {
-      e.target.composing = true;
-  }
-  function onCompositionEnd(e) {
-      // prevent triggering an input event for no reason
-      if (!e.target.composing)
-          return;
-      e.target.composing = false;
-      trigger(e.target, 'input');
-  }
-  function trigger(el, type) {
-      const e = document.createEvent('HTMLEvents');
-      e.initEvent(type, true, true);
-      el.dispatchEvent(e);
-  }
-
-  // recursively search for possible transition defined inside the component root
-  function locateNode(vnode) {
-      // @ts-expect-error
-      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-          ? locateNode(vnode.componentInstance._vnode)
-          : vnode;
-  }
-  var show = {
-      bind(el, { value }, vnode) {
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          const originalDisplay = (el.__vOriginalDisplay =
-              el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition) {
-              vnode.data.show = true;
-              enter(vnode, () => {
-                  el.style.display = originalDisplay;
-              });
-          }
-          else {
-              el.style.display = value ? originalDisplay : 'none';
-          }
-      },
-      update(el, { value, oldValue }, vnode) {
-          /* istanbul ignore if */
-          if (!value === !oldValue)
-              return;
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          if (transition) {
-              vnode.data.show = true;
-              if (value) {
-                  enter(vnode, () => {
-                      el.style.display = el.__vOriginalDisplay;
-                  });
-              }
-              else {
-                  leave(vnode, () => {
-                      el.style.display = 'none';
-                  });
-              }
-          }
-          else {
-              el.style.display = value ? el.__vOriginalDisplay : 'none';
-          }
-      },
-      unbind(el, binding, vnode, oldVnode, isDestroy) {
-          if (!isDestroy) {
-              el.style.display = el.__vOriginalDisplay;
-          }
-      },
-  };
-
-  var platformDirectives = {
-      model: directive,
-      show,
-  };
-
-  // Provides transition support for a single element/component.
-  const transitionProps = {
-      name: String,
-      appear: Boolean,
-      css: Boolean,
-      mode: String,
-      type: String,
-      enterClass: String,
-      leaveClass: String,
-      enterToClass: String,
-      leaveToClass: String,
-      enterActiveClass: String,
-      leaveActiveClass: String,
-      appearClass: String,
-      appearActiveClass: String,
-      appearToClass: String,
-      duration: [Number, String, Object],
-  };
-  // in case the child is also an abstract component, e.g. <keep-alive>
-  // we want to recursively retrieve the real component to be rendered
-  function getRealChild(vnode) {
-      const compOptions = vnode && vnode.componentOptions;
-      if (compOptions && compOptions.Ctor.options.abstract) {
-          return getRealChild(getFirstComponentChild(compOptions.children));
-      }
-      else {
-          return vnode;
-      }
-  }
-  function extractTransitionData(comp) {
-      const data = {};
-      const options = comp.$options;
-      // props
-      for (const key in options.propsData) {
-          data[key] = comp[key];
-      }
-      // events.
-      // extract listeners and pass them directly to the transition methods
-      const listeners = options._parentListeners;
-      for (const key in listeners) {
-          data[camelize(key)] = listeners[key];
-      }
-      return data;
-  }
-  function placeholder(h, rawChild) {
-      // @ts-expect-error
-      if (/\d-keep-alive$/.test(rawChild.tag)) {
-          return h('keep-alive', {
-              props: rawChild.componentOptions.propsData,
-          });
-      }
-  }
-  function hasParentTransition(vnode) {
-      while ((vnode = vnode.parent)) {
-          if (vnode.data.transition) {
-              return true;
-          }
-      }
-  }
-  function isSameChild(child, oldChild) {
-      return oldChild.key === child.key && oldChild.tag === child.tag;
-  }
-  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-  const isVShowDirective = (d) => d.name === 'show';
-  var Transition = {
-      name: 'transition',
-      props: transitionProps,
-      abstract: true,
-      render(h) {
-          let children = this.$slots.default;
-          if (!children) {
-              return;
-          }
-          // filter out text nodes (possible whitespaces)
-          children = children.filter(isNotTextNode);
-          /* istanbul ignore if */
-          if (!children.length) {
-              return;
-          }
-          // warn multiple elements
-          if (children.length > 1) {
-              warn$2('<transition> can only be used on a single element. Use ' +
-                  '<transition-group> for lists.', this.$parent);
-          }
-          const mode = this.mode;
-          // warn invalid mode
-          if (mode &&
-              mode !== 'in-out' &&
-              mode !== 'out-in') {
-              warn$2('invalid <transition> mode: ' + mode, this.$parent);
-          }
-          const rawChild = children[0];
-          // if this is a component root node and the component's
-          // parent container node also has transition, skip.
-          if (hasParentTransition(this.$vnode)) {
-              return rawChild;
-          }
-          // apply transition data to child
-          // use getRealChild() to ignore abstract components e.g. keep-alive
-          const child = getRealChild(rawChild);
-          /* istanbul ignore if */
-          if (!child) {
-              return rawChild;
-          }
-          if (this._leaving) {
-              return placeholder(h, rawChild);
-          }
-          // ensure a key that is unique to the vnode type and to this transition
-          // component instance. This key will be used to remove pending leaving nodes
-          // during entering.
-          const id = `__transition-${this._uid}-`;
-          child.key =
-              child.key == null
-                  ? child.isComment
-                      ? id + 'comment'
-                      : id + child.tag
-                  : isPrimitive(child.key)
-                      ? String(child.key).indexOf(id) === 0
-                          ? child.key
-                          : id + child.key
-                      : child.key;
-          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          const oldRawChild = this._vnode;
-          const oldChild = getRealChild(oldRawChild);
-          // mark v-show
-          // so that the transition module can hand over the control to the directive
-          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-              child.data.show = true;
-          }
-          if (oldChild &&
-              oldChild.data &&
-              !isSameChild(child, oldChild) &&
-              !isAsyncPlaceholder(oldChild) &&
-              // #6687 component root is a comment node
-              !(oldChild.componentInstance &&
-                  oldChild.componentInstance._vnode.isComment)) {
-              // replace old child transition data with fresh one
-              // important for dynamic transitions!
-              const oldData = (oldChild.data.transition = extend({}, data));
-              // handle transition mode
-              if (mode === 'out-in') {
-                  // return placeholder node and queue update when leave finishes
-                  this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', () => {
-                      this._leaving = false;
-                      this.$forceUpdate();
-                  });
-                  return placeholder(h, rawChild);
-              }
-              else if (mode === 'in-out') {
-                  if (isAsyncPlaceholder(child)) {
-                      return oldRawChild;
-                  }
-                  let delayedLeave;
-                  const performLeave = () => {
-                      delayedLeave();
-                  };
-                  mergeVNodeHook(data, 'afterEnter', performLeave);
-                  mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                      delayedLeave = leave;
-                  });
-              }
-          }
-          return rawChild;
-      },
-  };
-
-  // Provides transition support for list items.
-  const props = extend({
-      tag: String,
-      moveClass: String,
-  }, transitionProps);
-  delete props.mode;
-  var TransitionGroup = {
-      props,
-      beforeMount() {
-          const update = this._update;
-          this._update = (vnode, hydrating) => {
-              const restoreActiveInstance = setActiveInstance(this);
-              // force removing pass
-              this.__patch__(this._vnode, this.kept, false, // hydrating
-              true // removeOnly (!important, avoids unnecessary moves)
-              );
-              this._vnode = this.kept;
-              restoreActiveInstance();
-              update.call(this, vnode, hydrating);
-          };
-      },
-      render(h) {
-          const tag = this.tag || this.$vnode.data.tag || "span";
-          const map = Object.create(null);
-          const prevChildren = (this.prevChildren = this.children);
-          const rawChildren = this.$slots.default || [];
-          const children = (this.children = []);
-          const transitionData = extractTransitionData(this);
-          for (let i = 0; i < rawChildren.length; i++) {
-              const c = rawChildren[i];
-              if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                      children.push(c);
-                      map[c.key] = c;
-                      (c.data || (c.data = {})).transition = transitionData;
-                  }
-                  else {
-                      const opts = c.componentOptions;
-                      const name = opts
-                          ? opts.Ctor.options.name || opts.tag || ""
-                          : c.tag;
-                      warn$2(`<transition-group> children must be keyed: <${name}>`);
-                  }
-              }
-          }
-          if (prevChildren) {
-              const kept = [];
-              const removed = [];
-              for (let i = 0; i < prevChildren.length; i++) {
-                  const c = prevChildren[i];
-                  c.data.transition = transitionData;
-                  // @ts-expect-error .getBoundingClientRect is not typed in Node
-                  c.data.pos = c.elm.getBoundingClientRect();
-                  if (map[c.key]) {
-                      kept.push(c);
-                  }
-                  else {
-                      removed.push(c);
-                  }
-              }
-              this.kept = h(tag, null, kept);
-              this.removed = removed;
-          }
-          return h(tag, null, children);
-      },
-      updated() {
-          const children = this.prevChildren;
-          const moveClass = this.moveClass || (this.name || "v") + "-move";
-          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-              return;
-          }
-          // we divide the work into three loops to avoid mixing DOM reads and writes
-          // in each iteration - which helps prevent layout thrashing.
-          children.forEach(callPendingCbs);
-          children.forEach(recordPosition);
-          children.forEach(applyTranslation);
-          // force reflow to put everything in position
-          // assign to this to avoid being removed in tree-shaking
-          // $flow-disable-line
-          this._reflow = document.body.offsetHeight;
-          children.forEach((c) => {
-              if (c.data.moved) {
-                  const el = c.elm;
-                  const s = el.style;
-                  addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = "";
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
-                          return;
-                      }
-                      if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
-                      }
-                  }));
-              }
-          });
-      },
-      methods: {
-          hasMove(el, moveClass) {
-              /* istanbul ignore if */
-              if (!hasTransition) {
-                  return false;
-              }
-              /* istanbul ignore if */
-              if (this._hasMove) {
-                  return this._hasMove;
-              }
-              // Detect whether an element with the move class applied has
-              // CSS transitions. Since the element may be inside an entering
-              // transition at this very moment, we make a clone of it and remove
-              // all other transition classes applied to ensure only the move class
-              // is applied.
-              const clone = el.cloneNode();
-              if (el._transitionClasses) {
-                  el._transitionClasses.forEach((cls) => {
-                      removeClass(clone, cls);
-                  });
-              }
-              addClass(clone, moveClass);
-              clone.style.display = "none";
-              this.$el.appendChild(clone);
-              const info = getTransitionInfo(clone);
-              this.$el.removeChild(clone);
-              return (this._hasMove = info.hasTransform);
-          },
-      },
-  };
-  function callPendingCbs(c) {
-      /* istanbul ignore if */
-      if (c.elm._moveCb) {
-          c.elm._moveCb();
-      }
-      /* istanbul ignore if */
-      if (c.elm._enterCb) {
-          c.elm._enterCb();
-      }
-  }
-  function recordPosition(c) {
-      c.data.newPos = c.elm.getBoundingClientRect();
-  }
-  function applyTranslation(c) {
-      const oldPos = c.data.pos;
-      const newPos = c.data.newPos;
-      const dx = oldPos.left - newPos.left;
-      const dy = oldPos.top - newPos.top;
-      if (dx || dy) {
-          c.data.moved = true;
-          const s = c.elm.style;
-          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-          s.transitionDuration = "0s";
-      }
-  }
-
-  var platformComponents = {
-      Transition,
-      TransitionGroup,
-  };
-
-  // install platform specific utils
-  Vue.config.mustUseProp = mustUseProp;
-  Vue.config.isReservedTag = isReservedTag;
-  Vue.config.isReservedAttr = isReservedAttr;
-  Vue.config.getTagNamespace = getTagNamespace;
-  Vue.config.isUnknownElement = isUnknownElement;
-  // install platform runtime directives & components
-  extend(Vue.options.directives, platformDirectives);
-  extend(Vue.options.components, platformComponents);
-  // install platform patch function
-  Vue.prototype.__patch__ = inBrowser ? patch : noop;
-  // public mount method
-  Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query(el) : undefined;
-      return mountComponent(this, el, hydrating);
-  };
-  // devtools global hook
-  /* istanbul ignore next */
-  if (inBrowser) {
-      setTimeout(() => {
-          if (config.devtools) {
-              if (devtools) {
-                  devtools.emit('init', Vue);
-              }
-              else {
-                  // @ts-expect-error
-                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                      'https://github.com/vuejs/vue-devtools');
-              }
-          }
-          if (config.productionTip !== false &&
-              typeof console !== 'undefined') {
-              // @ts-expect-error
-              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                  `Make sure to turn on production mode when deploying for production.\n` +
-                  `See more tips at https://vuejs.org/guide/deployment.html`);
-          }
-      }, 0);
-  }
-
-  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  const buildRegex = cached((delimiters) => {
-      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-  });
-  function parseText(text, delimiters) {
-      //@ts-expect-error
-      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-      if (!tagRE.test(text)) {
-          return;
-      }
-      const tokens = [];
-      const rawTokens = [];
-      let lastIndex = (tagRE.lastIndex = 0);
-      let match, index, tokenValue;
-      while ((match = tagRE.exec(text))) {
-          index = match.index;
-          // push text token
-          if (index > lastIndex) {
-              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-              tokens.push(JSON.stringify(tokenValue));
-          }
-          // tag token
-          const exp = parseFilters(match[1].trim());
-          tokens.push(`_s(${exp})`);
-          rawTokens.push({ '@binding': exp });
-          lastIndex = index + match[0].length;
-      }
-      if (lastIndex < text.length) {
-          rawTokens.push((tokenValue = text.slice(lastIndex)));
-          tokens.push(JSON.stringify(tokenValue));
-      }
-      return {
-          expression: tokens.join('+'),
-          tokens: rawTokens,
-      };
-  }
-
-  function transformNode$1(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticClass = getAndRemoveAttr(el, 'class');
-      if (staticClass) {
-          const res = parseText(staticClass, options.delimiters);
-          if (res) {
-              warn(`class="${staticClass}": ` +
-                  'Interpolation inside attributes has been removed. ' +
-                  'Use v-bind or the colon shorthand instead. For example, ' +
-                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-          }
-      }
-      if (staticClass) {
-          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-      }
-      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-      if (classBinding) {
-          el.classBinding = classBinding;
-      }
-  }
-  function genData$2(el) {
-      let data = '';
-      if (el.staticClass) {
-          data += `staticClass:${el.staticClass},`;
-      }
-      if (el.classBinding) {
-          data += `class:${el.classBinding},`;
-      }
-      return data;
-  }
-  var klass = {
-      staticKeys: ['staticClass'],
-      transformNode: transformNode$1,
-      genData: genData$2,
-  };
-
-  function transformNode(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticStyle = getAndRemoveAttr(el, 'style');
-      if (staticStyle) {
-          /* istanbul ignore if */
-          {
-              const res = parseText(staticStyle, options.delimiters);
-              if (res) {
-                  warn(`style="${staticStyle}": ` +
-                      'Interpolation inside attributes has been removed. ' +
-                      'Use v-bind or the colon shorthand instead. For example, ' +
-                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-              }
-          }
-          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-      }
-      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-      if (styleBinding) {
-          el.styleBinding = styleBinding;
-      }
-  }
-  function genData$1(el) {
-      let data = '';
-      if (el.staticStyle) {
-          data += `staticStyle:${el.staticStyle},`;
-      }
-      if (el.styleBinding) {
-          data += `style:(${el.styleBinding}),`;
-      }
-      return data;
-  }
-  var style = {
-      staticKeys: ['staticStyle'],
-      transformNode,
-      genData: genData$1,
-  };
-
-  let decoder;
-  var he = {
-      decode(html) {
-          decoder = decoder || document.createElement('div');
-          decoder.innerHTML = html;
-          return decoder.textContent;
-      },
-  };
-
-  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr');
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-      'title,tr,track');
-
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-  // Regular Expressions for parsing tags and attributes
-  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-  const startTagOpen = new RegExp(`^<${qnameCapture}`);
-  const startTagClose = /^\s*(\/?)>/;
-  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-  const doctype = /^<!DOCTYPE [^>]+>/i;
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  const comment = /^<!\--/;
-  const conditionalComment = /^<!\[/;
-  // Special Elements (can contain anything)
-  const isPlainTextElement = makeMap('script,style,textarea', true);
-  const reCache = {};
-  const decodingMap = {
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&amp;': '&',
-      '&#10;': '\n',
-      '&#9;': '\t',
-      '&#39;': "'",
-  };
-  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-  // #5992
-  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  function decodeAttr(value, shouldDecodeNewlines) {
-      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-      return value.replace(re, (match) => decodingMap[match]);
-  }
-  function parseHTML(html, options) {
-      const stack = [];
-      const expectHTML = options.expectHTML;
-      const isUnaryTag = options.isUnaryTag || no;
-      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-      let index = 0;
-      let last, lastTag;
-      while (html) {
-          last = html;
-          // Make sure we're not in a plaintext content element like script/style
-          if (!lastTag || !isPlainTextElement(lastTag)) {
-              let textEnd = html.indexOf('<');
-              if (textEnd === 0) {
-                  // Comment:
-                  if (comment.test(html)) {
-                      const commentEnd = html.indexOf('-->');
-                      if (commentEnd >= 0) {
-                          if (options.shouldKeepComment) {
-                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                          }
-                          advance(commentEnd + 3);
-                          continue;
-                      }
-                  }
-                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                  if (conditionalComment.test(html)) {
-                      const conditionalEnd = html.indexOf(']>');
-                      if (conditionalEnd >= 0) {
-                          advance(conditionalEnd + 2);
-                          continue;
-                      }
-                  }
-                  // Doctype:
-                  const doctypeMatch = html.match(doctype);
-                  if (doctypeMatch) {
-                      advance(doctypeMatch[0].length);
-                      continue;
-                  }
-                  // End tag:
-                  const endTagMatch = html.match(endTag);
-                  if (endTagMatch) {
-                      const curIndex = index;
-                      advance(endTagMatch[0].length);
-                      parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
-                  }
-                  // Start tag:
-                  const startTagMatch = parseStartTag();
-                  if (startTagMatch) {
-                      handleStartTag(startTagMatch);
-                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                          advance(1);
-                      }
-                      continue;
-                  }
-              }
-              let text, rest, next;
-              if (textEnd >= 0) {
-                  rest = html.slice(textEnd);
-                  while (!endTag.test(rest) &&
-                      !startTagOpen.test(rest) &&
-                      !comment.test(rest) &&
-                      !conditionalComment.test(rest)) {
-                      // < in plain text, be forgiving and treat it as text
-                      next = rest.indexOf('<', 1);
-                      if (next < 0)
-                          break;
-                      textEnd += next;
-                      rest = html.slice(textEnd);
-                  }
-                  text = html.substring(0, textEnd);
-              }
-              if (textEnd < 0) {
-                  text = html;
-              }
-              if (text) {
-                  advance(text.length);
-              }
-              if (options.chars && text) {
-                  options.chars(text, index - text.length, index);
-              }
-          }
-          else {
-              let endTagLength = 0;
-              const stackedTag = lastTag.toLowerCase();
-              const reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                      text = text
-                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                  }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                      text = text.slice(1);
-                  }
-                  if (options.chars) {
-                      options.chars(text);
-                  }
-                  return '';
-              });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag, index - endTagLength, index);
-          }
-          if (html === last) {
-              options.chars && options.chars(html);
-              if (!stack.length &&
-                  options.warn) {
-                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                      start: index + html.length,
-                  });
-              }
-              break;
-          }
-      }
-      // Clean up any remaining tags
-      parseEndTag();
-      function advance(n) {
-          index += n;
-          html = html.substring(n);
-      }
-      function parseStartTag() {
-          const start = html.match(startTagOpen);
-          if (start) {
-              const match = {
-                  tagName: start[1],
-                  attrs: [],
-                  start: index,
-              };
-              advance(start[0].length);
-              let end, attr;
-              while (!(end = html.match(startTagClose)) &&
-                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                  attr.start = index;
-                  advance(attr[0].length);
-                  attr.end = index;
-                  match.attrs.push(attr);
-              }
-              if (end) {
-                  match.unarySlash = end[1];
-                  advance(end[0].length);
-                  match.end = index;
-                  return match;
-              }
-          }
-      }
-      function handleStartTag(match) {
-          const tagName = match.tagName;
-          const unarySlash = match.unarySlash;
-          if (expectHTML) {
-              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                  parseEndTag(lastTag);
-              }
-              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                  parseEndTag(tagName);
-              }
-          }
-          const unary = isUnaryTag(tagName) || !!unarySlash;
-          const l = match.attrs.length;
-          const attrs = new Array(l);
-          for (let i = 0; i < l; i++) {
-              const args = match.attrs[i];
-              const value = args[3] || args[4] || args[5] || '';
-              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                  ? options.shouldDecodeNewlinesForHref
-                  : options.shouldDecodeNewlines;
-              attrs[i] = {
-                  name: args[1],
-                  value: decodeAttr(value, shouldDecodeNewlines),
-              };
-              if (options.outputSourceRange) {
-                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                  attrs[i].end = args.end;
-              }
-          }
-          if (!unary) {
-              stack.push({
-                  tag: tagName,
-                  lowerCasedTag: tagName.toLowerCase(),
-                  attrs: attrs,
-                  start: match.start,
-                  end: match.end,
-              });
-              lastTag = tagName;
-          }
-          if (options.start) {
-              options.start(tagName, attrs, unary, match.start, match.end);
-          }
-      }
-      function parseEndTag(tagName, start, end) {
-          let pos, lowerCasedTagName;
-          if (start == null)
-              start = index;
-          if (end == null)
-              end = index;
-          // Find the closest opened tag of the same type
-          if (tagName) {
-              lowerCasedTagName = tagName.toLowerCase();
-              for (pos = stack.length - 1; pos >= 0; pos--) {
-                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                      break;
-                  }
-              }
-          }
-          else {
-              // If no tag name is provided, clean shop
-              pos = 0;
-          }
-          if (pos >= 0) {
-              // Close all the open elements, up the stack
-              for (let i = stack.length - 1; i >= pos; i--) {
-                  if ((i > pos || !tagName) &&
-                      options.warn) {
-                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                          start: stack[i].start,
-                          end: stack[i].end,
-                      });
-                  }
-                  if (options.end) {
-                      options.end(stack[i].tag, start, end);
-                  }
-              }
-              // Remove the open elements from the stack
-              stack.length = pos;
-              lastTag = pos && stack[pos - 1].tag;
-          }
-          else if (lowerCasedTagName === 'br') {
-              if (options.start) {
-                  options.start(tagName, [], true, start, end);
-              }
-          }
-          else if (lowerCasedTagName === 'p') {
-              if (options.start) {
-                  options.start(tagName, [], false, start, end);
-              }
-              if (options.end) {
-                  options.end(tagName, start, end);
-              }
-          }
-      }
-  }
-
-  const onRE = /^@|^v-on:/;
-  const dirRE = /^v-|^@|^:|^#/;
-  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  const stripParensRE = /^\(|\)$/g;
-  const dynamicArgRE = /^\[.*\]$/;
-  const argRE = /:(.*)$/;
-  const bindRE = /^:|^\.|^v-bind:/;
-  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-  const slotRE = /^v-slot(:|$)|^#/;
-  const lineBreakRE = /[\r\n]/;
-  const whitespaceRE = /[ \f\t\r\n]+/g;
-  const invalidAttributeRE = /[\s"'<>\/=]/;
-  const decodeHTMLCached = cached(he.decode);
-  const emptySlotScopeToken = `_empty_`;
-  // configurable state
-  let warn;
-  let delimiters;
-  let transforms;
-  let preTransforms;
-  let postTransforms;
-  let platformIsPreTag;
-  let platformMustUseProp;
-  let platformGetTagNamespace;
-  let maybeComponent;
-  function createASTElement(tag, attrs, parent) {
-      return {
-          type: 1,
-          tag,
-          attrsList: attrs,
-          attrsMap: makeAttrsMap(attrs),
-          rawAttrsMap: {},
-          parent,
-          children: [],
-      };
-  }
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse(template, options) {
-      warn = options.warn || baseWarn;
-      platformIsPreTag = options.isPreTag || no;
-      platformMustUseProp = options.mustUseProp || no;
-      platformGetTagNamespace = options.getTagNamespace || no;
-      const isReservedTag = options.isReservedTag || no;
-      maybeComponent = (el) => !!(el.component ||
-          el.attrsMap[':is'] ||
-          el.attrsMap['v-bind:is'] ||
-          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-      transforms = pluckModuleFunction(options.modules, 'transformNode');
-      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-      delimiters = options.delimiters;
-      const stack = [];
-      const preserveWhitespace = options.preserveWhitespace !== false;
-      const whitespaceOption = options.whitespace;
-      let root;
-      let currentParent;
-      let inVPre = false;
-      let inPre = false;
-      let warned = false;
-      function warnOnce(msg, range) {
-          if (!warned) {
-              warned = true;
-              warn(msg, range);
-          }
-      }
-      function closeElement(element) {
-          trimEndingWhitespace(element);
-          if (!inVPre && !element.processed) {
-              element = processElement(element, options);
-          }
-          // tree management
-          if (!stack.length && element !== root) {
-              // allow root elements with v-if, v-else-if and v-else
-              if (root.if && (element.elseif || element.else)) {
-                  {
-                      checkRootConstraints(element);
-                  }
-                  addIfCondition(root, {
-                      exp: element.elseif,
-                      block: element,
-                  });
-              }
-              else {
-                  warnOnce(`Component template should contain exactly one root element. ` +
-                      `If you are using v-if on multiple elements, ` +
-                      `use v-else-if to chain them instead.`, { start: element.start });
-              }
-          }
-          if (currentParent && !element.forbidden) {
-              if (element.elseif || element.else) {
-                  processIfConditions(element, currentParent);
-              }
-              else {
-                  if (element.slotScope) {
-                      // scoped slot
-                      // keep it in the children list so that v-else(-if) conditions can
-                      // find it as the prev node.
-                      const name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                  }
-                  currentParent.children.push(element);
-                  element.parent = currentParent;
-              }
-          }
-          // final children cleanup
-          // filter out scoped slots
-          element.children = element.children.filter((c) => !c.slotScope);
-          // remove trailing whitespace node again
-          trimEndingWhitespace(element);
-          // check pre state
-          if (element.pre) {
-              inVPre = false;
-          }
-          if (platformIsPreTag(element.tag)) {
-              inPre = false;
-          }
-          // apply post-transforms
-          for (let i = 0; i < postTransforms.length; i++) {
-              postTransforms[i](element, options);
-          }
-      }
-      function trimEndingWhitespace(el) {
-          // remove trailing whitespace node
-          if (!inPre) {
-              let lastNode;
-              while ((lastNode = el.children[el.children.length - 1]) &&
-                  lastNode.type === 3 &&
-                  lastNode.text === ' ') {
-                  el.children.pop();
-              }
-          }
-      }
-      function checkRootConstraints(el) {
-          if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                  'contain multiple nodes.', { start: el.start });
-          }
-          if (el.attrsMap.hasOwnProperty('v-for')) {
-              warnOnce('Cannot use v-for on stateful component root element because ' +
-                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
-          }
-      }
-      parseHTML(template, {
-          warn,
-          expectHTML: options.expectHTML,
-          isUnaryTag: options.isUnaryTag,
-          canBeLeftOpenTag: options.canBeLeftOpenTag,
-          shouldDecodeNewlines: options.shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-          shouldKeepComment: options.comments,
-          outputSourceRange: options.outputSourceRange,
-          start(tag, attrs, unary, start, end) {
-              // check namespace.
-              // inherit parent ns if there is one
-              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-              // handle IE svg bug
-              /* istanbul ignore if */
-              if (isIE && ns === 'svg') {
-                  attrs = guardIESVGBug(attrs);
-              }
-              let element = createASTElement(tag, attrs, currentParent);
-              if (ns) {
-                  element.ns = ns;
-              }
-              {
-                  if (options.outputSourceRange) {
-                      element.start = start;
-                      element.end = end;
-                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                          cumulated[attr.name] = attr;
-                          return cumulated;
-                      }, {});
-                  }
-                  attrs.forEach((attr) => {
-                      if (invalidAttributeRE.test(attr.name)) {
-                          warn(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                              `spaces, quotes, <, >, / or =.`, {
-                              start: attr.start + attr.name.indexOf(`[`),
-                              end: attr.start + attr.name.length,
-                          });
-                      }
-                  });
-              }
-              if (isForbiddenTag(element) && !isServerRendering()) {
-                  element.forbidden = true;
-                  warn('Templates should only be responsible for mapping the state to the ' +
-                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          `<${tag}>` +
-                          ', as they will not be parsed.', { start: element.start });
-              }
-              // apply pre-transforms
-              for (let i = 0; i < preTransforms.length; i++) {
-                  element = preTransforms[i](element, options) || element;
-              }
-              if (!inVPre) {
-                  processPre(element);
-                  if (element.pre) {
-                      inVPre = true;
-                  }
-              }
-              if (platformIsPreTag(element.tag)) {
-                  inPre = true;
-              }
-              if (inVPre) {
-                  processRawAttrs(element);
-              }
-              else if (!element.processed) {
-                  // structural directives
-                  processFor(element);
-                  processIf(element);
-                  processOnce(element);
-              }
-              if (!root) {
-                  root = element;
-                  {
-                      checkRootConstraints(root);
-                  }
-              }
-              if (!unary) {
-                  currentParent = element;
-                  stack.push(element);
-              }
-              else {
-                  closeElement(element);
-              }
-          },
-          end(tag, start, end) {
-              const element = stack[stack.length - 1];
-              // pop stack
-              stack.length -= 1;
-              currentParent = stack[stack.length - 1];
-              if (options.outputSourceRange) {
-                  element.end = end;
-              }
-              closeElement(element);
-          },
-          chars(text, start, end) {
-              if (!currentParent) {
-                  {
-                      if (text === template) {
-                          warnOnce('Component template requires a root element, rather than just text.', { start });
-                      }
-                      else if ((text = text.trim())) {
-                          warnOnce(`text "${text}" outside root element will be ignored.`, {
-                              start,
-                          });
-                      }
-                  }
-                  return;
-              }
-              // IE textarea placeholder bug
-              /* istanbul ignore if */
-              if (isIE &&
-                  currentParent.tag === 'textarea' &&
-                  currentParent.attrsMap.placeholder === text) {
-                  return;
-              }
-              const children = currentParent.children;
-              if (inPre || text.trim()) {
-                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-              }
-              else if (!children.length) {
-                  // remove the whitespace-only node right after an opening tag
-                  text = '';
-              }
-              else if (whitespaceOption) {
-                  if (whitespaceOption === 'condense') {
-                      // in condense mode, remove the whitespace node if it contains
-                      // line break, otherwise condense to a single space
-                      text = lineBreakRE.test(text) ? '' : ' ';
-                  }
-                  else {
-                      text = ' ';
-                  }
-              }
-              else {
-                  text = preserveWhitespace ? ' ' : '';
-              }
-              if (text) {
-                  if (!inPre && whitespaceOption === 'condense') {
-                      // condense consecutive whitespaces into single space
-                      text = text.replace(whitespaceRE, ' ');
-                  }
-                  let res;
-                  let child;
-                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                      child = {
-                          type: 2,
-                          expression: res.expression,
-                          tokens: res.tokens,
-                          text,
-                      };
-                  }
-                  else if (text !== ' ' ||
-                      !children.length ||
-                      children[children.length - 1].text !== ' ') {
-                      child = {
-                          type: 3,
-                          text,
-                      };
-                  }
-                  if (child) {
-                      if (options.outputSourceRange) {
-                          child.start = start;
-                          child.end = end;
-                      }
-                      children.push(child);
-                  }
-              }
-          },
-          comment(text, start, end) {
-              // adding anything as a sibling to the root node is forbidden
-              // comments should still be allowed, but ignored
-              if (currentParent) {
-                  const child = {
-                      type: 3,
-                      text,
-                      isComment: true,
-                  };
-                  if (options.outputSourceRange) {
-                      child.start = start;
-                      child.end = end;
-                  }
-                  currentParent.children.push(child);
-              }
-          },
-      });
-      return root;
-  }
-  function processPre(el) {
-      if (getAndRemoveAttr(el, 'v-pre') != null) {
-          el.pre = true;
-      }
-  }
-  function processRawAttrs(el) {
-      const list = el.attrsList;
-      const len = list.length;
-      if (len) {
-          const attrs = (el.attrs = new Array(len));
-          for (let i = 0; i < len; i++) {
-              attrs[i] = {
-                  name: list[i].name,
-                  value: JSON.stringify(list[i].value),
-              };
-              if (list[i].start != null) {
-                  attrs[i].start = list[i].start;
-                  attrs[i].end = list[i].end;
-              }
-          }
-      }
-      else if (!el.pre) {
-          // non root node in pre blocks with no attributes
-          el.plain = true;
-      }
-  }
-  function processElement(element, options) {
-      processKey(element);
-      // determine whether this is a plain element after
-      // removing structural attributes
-      element.plain =
-          !element.key && !element.scopedSlots && !element.attrsList.length;
-      processRef(element);
-      processSlotContent(element);
-      processSlotOutlet(element);
-      processComponent(element);
-      for (let i = 0; i < transforms.length; i++) {
-          element = transforms[i](element, options) || element;
-      }
-      processAttrs(element);
-      return element;
-  }
-  function processKey(el) {
-      const exp = getBindingAttr(el, 'key');
-      if (exp) {
-          {
-              if (el.tag === 'template') {
-                  warn(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-              }
-              if (el.for) {
-                  const iterator = el.iterator2 || el.iterator1;
-                  const parent = el.parent;
-                  if (iterator &&
-                      iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
-                      warn(`Do not use v-for index as key on <transition-group> children, ` +
-                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                  }
-              }
-          }
-          el.key = exp;
-      }
-  }
-  function processRef(el) {
-      const ref = getBindingAttr(el, 'ref');
-      if (ref) {
-          el.ref = ref;
-          el.refInFor = checkInFor(el);
-      }
-  }
-  function processFor(el) {
-      let exp;
-      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-          const res = parseFor(exp);
-          if (res) {
-              extend(el, res);
-          }
-          else {
-              warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-          }
-      }
-  }
-  function parseFor(exp) {
-      const inMatch = exp.match(forAliasRE);
-      if (!inMatch)
-          return;
-      const res = {};
-      res.for = inMatch[2].trim();
-      const alias = inMatch[1].trim().replace(stripParensRE, '');
-      const iteratorMatch = alias.match(forIteratorRE);
-      if (iteratorMatch) {
-          res.alias = alias.replace(forIteratorRE, '').trim();
-          res.iterator1 = iteratorMatch[1].trim();
-          if (iteratorMatch[2]) {
-              res.iterator2 = iteratorMatch[2].trim();
-          }
-      }
-      else {
-          res.alias = alias;
-      }
-      return res;
-  }
-  function processIf(el) {
-      const exp = getAndRemoveAttr(el, 'v-if');
-      if (exp) {
-          el.if = exp;
-          addIfCondition(el, {
-              exp: exp,
-              block: el,
-          });
-      }
-      else {
-          if (getAndRemoveAttr(el, 'v-else') != null) {
-              el.else = true;
-          }
-          const elseif = getAndRemoveAttr(el, 'v-else-if');
-          if (elseif) {
-              el.elseif = elseif;
-          }
-      }
-  }
-  function processIfConditions(el, parent) {
-      const prev = findPrevElement(parent.children);
-      if (prev && prev.if) {
-          addIfCondition(prev, {
-              exp: el.elseif,
-              block: el,
-          });
-      }
-      else {
-          warn(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-      }
-  }
-  function findPrevElement(children) {
-      let i = children.length;
-      while (i--) {
-          if (children[i].type === 1) {
-              return children[i];
-          }
-          else {
-              if (children[i].text !== ' ') {
-                  warn(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                      `will be ignored.`, children[i]);
-              }
-              children.pop();
-          }
-      }
-  }
-  function addIfCondition(el, condition) {
-      if (!el.ifConditions) {
-          el.ifConditions = [];
-      }
-      el.ifConditions.push(condition);
-  }
-  function processOnce(el) {
-      const once = getAndRemoveAttr(el, 'v-once');
-      if (once != null) {
-          el.once = true;
-      }
-  }
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent(el) {
-      let slotScope;
-      if (el.tag === 'template') {
-          slotScope = getAndRemoveAttr(el, 'scope');
-          /* istanbul ignore if */
-          if (slotScope) {
-              warn(`the "scope" attribute for scoped slots have been deprecated and ` +
-                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                  `can also be used on plain elements in addition to <template> to ` +
-                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-          }
-          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-      }
-      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-          /* istanbul ignore if */
-          if (el.attrsMap['v-for']) {
-              warn(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-          }
-          el.slotScope = slotScope;
-      }
-      // slot="xxx"
-      const slotTarget = getBindingAttr(el, 'slot');
-      if (slotTarget) {
-          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-          // preserve slot as an attribute for native shadow DOM compat
-          // only for non-scoped slots.
-          if (el.tag !== 'template' && !el.slotScope) {
-              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-          }
-      }
-      // 2.6 v-slot syntax
-      {
-          if (el.tag === 'template') {
-              // v-slot on <template>
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (el.slotTarget || el.slotScope) {
-                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.parent && !maybeComponent(el.parent)) {
-                          warn(`<template v-slot> can only appear at the root level inside ` +
-                              `the receiving component`, el);
-                      }
-                  }
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  el.slotTarget = name;
-                  el.slotTargetDynamic = dynamic;
-                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-              }
-          }
-          else {
-              // v-slot on component, denotes default slot
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (!maybeComponent(el)) {
-                          warn(`v-slot can only be used on components or <template>.`, slotBinding);
-                      }
-                      if (el.slotScope || el.slotTarget) {
-                          warn(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.scopedSlots) {
-                          warn(`To avoid scope ambiguity, the default slot should also use ` +
-                              `<template> syntax when there are other named slots.`, slotBinding);
-                      }
-                  }
-                  // add the component's children to its default slot
-                  const slots = el.scopedSlots || (el.scopedSlots = {});
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  const slotContainer = (slots[name] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name;
-                  slotContainer.slotTargetDynamic = dynamic;
-                  slotContainer.children = el.children.filter((c) => {
-                      if (!c.slotScope) {
-                          c.parent = slotContainer;
-                          return true;
-                      }
-                  });
-                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                  // remove children as they are returned from scopedSlots now
-                  el.children = [];
-                  // mark el non-plain so data gets generated
-                  el.plain = false;
-              }
-          }
-      }
-  }
-  function getSlotName(binding) {
-      let name = binding.name.replace(slotRE, '');
-      if (!name) {
-          if (binding.name[0] !== '#') {
-              name = 'default';
-          }
-          else {
-              warn(`v-slot shorthand syntax requires a slot name.`, binding);
-          }
-      }
-      return dynamicArgRE.test(name)
-          ? // dynamic [name]
-              { name: name.slice(1, -1), dynamic: true }
-          : // static name
-              { name: `"${name}"`, dynamic: false };
-  }
-  // handle <slot/> outlets
-  function processSlotOutlet(el) {
-      if (el.tag === 'slot') {
-          el.slotName = getBindingAttr(el, 'name');
-          if (el.key) {
-              warn(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                  `and can possibly expand into multiple elements. ` +
-                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-          }
-      }
-  }
-  function processComponent(el) {
-      let binding;
-      if ((binding = getBindingAttr(el, 'is'))) {
-          el.component = binding;
-      }
-      if (getAndRemoveAttr(el, 'inline-template') != null) {
-          el.inlineTemplate = true;
-      }
-  }
-  function processAttrs(el) {
-      const list = el.attrsList;
-      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-      for (i = 0, l = list.length; i < l; i++) {
-          name = rawName = list[i].name;
-          value = list[i].value;
-          if (dirRE.test(name)) {
-              // mark element as dynamic
-              el.hasBindings = true;
-              // modifiers
-              modifiers = parseModifiers(name.replace(dirRE, ''));
-              // support .foo shorthand syntax for the .prop modifier
-              if (modifiers) {
-                  name = name.replace(modifierRE, '');
-              }
-              if (bindRE.test(name)) {
-                  // v-bind
-                  name = name.replace(bindRE, '');
-                  value = parseFilters(value);
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  if (value.trim().length === 0) {
-                      warn(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                  }
-                  if (modifiers) {
-                      if (modifiers.prop && !isDynamic) {
-                          name = camelize(name);
-                          if (name === 'innerHtml')
-                              name = 'innerHTML';
-                      }
-                      if (modifiers.camel && !isDynamic) {
-                          name = camelize(name);
-                      }
-                      if (modifiers.sync) {
-                          syncGen = genAssignmentCode(value, `$event`);
-                          if (!isDynamic) {
-                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn, list[i]);
-                              if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn, list[i]);
-                              }
-                          }
-                          else {
-                              // handler w/ dynamic event name
-                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn, list[i], true // dynamic
-                              );
-                          }
-                      }
-                  }
-                  if ((modifiers && modifiers.prop) ||
-                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                      addProp(el, name, value, list[i], isDynamic);
-                  }
-                  else {
-                      addAttr(el, name, value, list[i], isDynamic);
-                  }
-              }
-              else if (onRE.test(name)) {
-                  // v-on
-                  name = name.replace(onRE, '');
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-              }
-              else {
-                  // normal directives
-                  name = name.replace(dirRE, '');
-                  // parse arg
-                  const argMatch = name.match(argRE);
-                  let arg = argMatch && argMatch[1];
-                  isDynamic = false;
-                  if (arg) {
-                      name = name.slice(0, -(arg.length + 1));
-                      if (dynamicArgRE.test(arg)) {
-                          arg = arg.slice(1, -1);
-                          isDynamic = true;
-                      }
-                  }
-                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                  if (name === 'model') {
-                      checkForAliasModel(el, value);
-                  }
-              }
-          }
-          else {
-              // literal attribute
-              {
-                  const res = parseText(value, delimiters);
-                  if (res) {
-                      warn(`${name}="${value}": ` +
-                          'Interpolation inside attributes has been removed. ' +
-                          'Use v-bind or the colon shorthand instead. For example, ' +
-                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                  }
-              }
-              addAttr(el, name, JSON.stringify(value), list[i]);
-              // #6887 firefox doesn't update muted state if set via attribute
-              // even immediately after element creation
-              if (!el.component &&
-                  name === 'muted' &&
-                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                  addProp(el, name, 'true', list[i]);
-              }
-          }
-      }
-  }
-  function checkInFor(el) {
-      let parent = el;
-      while (parent) {
-          if (parent.for !== undefined) {
-              return true;
-          }
-          parent = parent.parent;
-      }
-      return false;
-  }
-  function parseModifiers(name) {
-      const match = name.match(modifierRE);
-      if (match) {
-          const ret = {};
-          match.forEach((m) => {
-              ret[m.slice(1)] = true;
-          });
-          return ret;
-      }
-  }
-  function makeAttrsMap(attrs) {
-      const map = {};
-      for (let i = 0, l = attrs.length; i < l; i++) {
-          if (map[attrs[i].name] &&
-              !isIE &&
-              !isEdge) {
-              warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-          }
-          map[attrs[i].name] = attrs[i].value;
-      }
-      return map;
-  }
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag(el) {
-      return el.tag === 'script' || el.tag === 'style';
-  }
-  function isForbiddenTag(el) {
-      return (el.tag === 'style' ||
-          (el.tag === 'script' &&
-              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-  }
-  const ieNSBug = /^xmlns:NS\d+/;
-  const ieNSPrefix = /^NS\d+:/;
-  /* istanbul ignore next */
-  function guardIESVGBug(attrs) {
-      const res = [];
-      for (let i = 0; i < attrs.length; i++) {
-          const attr = attrs[i];
-          if (!ieNSBug.test(attr.name)) {
-              attr.name = attr.name.replace(ieNSPrefix, '');
-              res.push(attr);
-          }
-      }
-      return res;
-  }
-  function checkForAliasModel(el, value) {
-      let _el = el;
-      while (_el) {
-          if (_el.for && _el.alias === value) {
-              warn(`<${el.tag} v-model="${value}">: ` +
-                  `You are binding v-model directly to a v-for iteration alias. ` +
-                  `This will not be able to modify the v-for source array because ` +
-                  `writing to the alias is like modifying a function local variable. ` +
-                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-          }
-          _el = _el.parent;
-      }
-  }
-
-  /**
-   * Expand input[v-model] with dynamic type bindings into v-if-else chains
-   * Turn this:
-   *   <input v-model="data[type]" :type="type">
-   * into this:
-   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-   *   <input v-else :type="type" v-model="data[type]">
-   */
-  function preTransformNode(el, options) {
-      if (el.tag === 'input') {
-          const map = el.attrsMap;
-          if (!map['v-model']) {
-              return;
-          }
-          let typeBinding;
-          if (map[':type'] || map['v-bind:type']) {
-              typeBinding = getBindingAttr(el, 'type');
-          }
-          if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = `(${map['v-bind']}).type`;
-          }
-          if (typeBinding) {
-              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-              // 1. checkbox
-              const branch0 = cloneASTElement(el);
-              // process for on the main node
-              processFor(branch0);
-              addRawAttr(branch0, 'type', 'checkbox');
-              processElement(branch0, options);
-              branch0.processed = true; // prevent it from double-processed
-              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-              addIfCondition(branch0, {
-                  exp: branch0.if,
-                  block: branch0,
-              });
-              // 2. add radio else-if condition
-              const branch1 = cloneASTElement(el);
-              getAndRemoveAttr(branch1, 'v-for', true);
-              addRawAttr(branch1, 'type', 'radio');
-              processElement(branch1, options);
-              addIfCondition(branch0, {
-                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                  block: branch1,
-              });
-              // 3. other
-              const branch2 = cloneASTElement(el);
-              getAndRemoveAttr(branch2, 'v-for', true);
-              addRawAttr(branch2, ':type', typeBinding);
-              processElement(branch2, options);
-              addIfCondition(branch0, {
-                  exp: ifCondition,
-                  block: branch2,
-              });
-              if (hasElse) {
-                  branch0.else = true;
-              }
-              else if (elseIfCondition) {
-                  branch0.elseif = elseIfCondition;
-              }
-              return branch0;
-          }
-      }
-  }
-  function cloneASTElement(el) {
-      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-  }
-  var model = {
-      preTransformNode,
-  };
-
-  var modules = [klass, style, model];
-
-  function text(el, dir) {
-      if (dir.value) {
-          addProp(el, 'textContent', `_s(${dir.value})`, dir);
-      }
-  }
-
-  function html(el, dir) {
-      if (dir.value) {
-          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-      }
-  }
-
-  var directives = {
-      model: model$1,
-      text,
-      html,
-  };
-
-  const baseOptions = {
-      expectHTML: true,
-      modules,
-      directives,
-      isPreTag,
-      isUnaryTag,
-      mustUseProp,
-      canBeLeftOpenTag,
-      isReservedTag,
-      getTagNamespace,
-      staticKeys: genStaticKeys$1(modules),
-  };
-
-  let isStaticKey;
-  let isPlatformReservedTag;
-  const genStaticKeysCached = cached(genStaticKeys);
-  /**
-   * Goal of the optimizer: walk the generated template AST tree
-   * and detect sub-trees that are purely static, i.e. parts of
-   * the DOM that never needs to change.
-   *
-   * Once we detect these sub-trees, we can:
-   *
-   * 1. Hoist them into constants, so that we no longer need to
-   *    create fresh nodes for them on each re-render;
-   * 2. Completely skip them in the patching process.
-   */
-  function optimize(root, options) {
-      if (!root)
-          return;
-      isStaticKey = genStaticKeysCached(options.staticKeys || '');
-      isPlatformReservedTag = options.isReservedTag || no;
-      // first pass: mark all non-static nodes.
-      markStatic(root);
-      // second pass: mark static roots.
-      markStaticRoots(root, false);
-  }
-  function genStaticKeys(keys) {
-      return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-          (keys ? ',' + keys : ''));
-  }
-  function markStatic(node) {
-      node.static = isStatic(node);
-      if (node.type === 1) {
-          // do not make component slot content static. this avoids
-          // 1. components not able to mutate slot nodes
-          // 2. static slot content fails for hot-reloading
-          if (!isPlatformReservedTag(node.tag) &&
-              node.tag !== 'slot' &&
-              node.attrsMap['inline-template'] == null) {
-              return;
-          }
-          for (let i = 0, l = node.children.length; i < l; i++) {
-              const child = node.children[i];
-              markStatic(child);
-              if (!child.static) {
-                  node.static = false;
-              }
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  const block = node.ifConditions[i].block;
-                  markStatic(block);
-                  if (!block.static) {
-                      node.static = false;
-                  }
-              }
-          }
-      }
-  }
-  function markStaticRoots(node, isInFor) {
-      if (node.type === 1) {
-          if (node.static || node.once) {
-              node.staticInFor = isInFor;
-          }
-          // For a node to qualify as a static root, it should have children that
-          // are not just static text. Otherwise the cost of hoisting out will
-          // outweigh the benefits and it's better off to just always render it fresh.
-          if (node.static &&
-              node.children.length &&
-              !(node.children.length === 1 && node.children[0].type === 3)) {
-              node.staticRoot = true;
-              return;
-          }
-          else {
-              node.staticRoot = false;
-          }
-          if (node.children) {
-              for (let i = 0, l = node.children.length; i < l; i++) {
-                  markStaticRoots(node.children[i], isInFor || !!node.for);
-              }
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  markStaticRoots(node.ifConditions[i].block, isInFor);
-              }
-          }
-      }
-  }
-  function isStatic(node) {
-      if (node.type === 2) {
-          // expression
-          return false;
-      }
-      if (node.type === 3) {
-          // text
-          return true;
-      }
-      return !!(node.pre ||
-          (!node.hasBindings && // no dynamic bindings
-              !node.if &&
-              !node.for && // not v-if or v-for or v-else
-              !isBuiltInTag(node.tag) && // not a built-in
-              isPlatformReservedTag(node.tag) && // not a component
-              !isDirectChildOfTemplateFor(node) &&
-              Object.keys(node).every(isStaticKey)));
-  }
-  function isDirectChildOfTemplateFor(node) {
-      while (node.parent) {
-          node = node.parent;
-          if (node.tag !== 'template') {
-              return false;
-          }
-          if (node.for) {
-              return true;
-          }
-      }
-      return false;
-  }
-
-  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  const fnInvokeRE = /\([^)]*?\);*$/;
-  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-  // KeyboardEvent.keyCode aliases
-  const keyCodes = {
-      esc: 27,
-      tab: 9,
-      enter: 13,
-      space: 32,
-      up: 38,
-      left: 37,
-      right: 39,
-      down: 40,
-      delete: [8, 46],
-  };
-  // KeyboardEvent.key aliases
-  const keyNames = {
-      // #7880: IE11 and Edge use `Esc` for Escape key name.
-      esc: ['Esc', 'Escape'],
-      tab: 'Tab',
-      enter: 'Enter',
-      // #9112: IE11 uses `Spacebar` for Space key name.
-      space: [' ', 'Spacebar'],
-      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-      up: ['Up', 'ArrowUp'],
-      left: ['Left', 'ArrowLeft'],
-      right: ['Right', 'ArrowRight'],
-      down: ['Down', 'ArrowDown'],
-      // #9112: IE11 uses `Del` for Delete key name.
-      delete: ['Backspace', 'Delete', 'Del'],
-  };
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  const genGuard = (condition) => `if(${condition})return null;`;
-  const modifierCode = {
-      stop: '$event.stopPropagation();',
-      prevent: '$event.preventDefault();',
-      self: genGuard(`$event.target !== $event.currentTarget`),
-      ctrl: genGuard(`!$event.ctrlKey`),
-      shift: genGuard(`!$event.shiftKey`),
-      alt: genGuard(`!$event.altKey`),
-      meta: genGuard(`!$event.metaKey`),
-      left: genGuard(`'button' in $event && $event.button !== 0`),
-      middle: genGuard(`'button' in $event && $event.button !== 1`),
-      right: genGuard(`'button' in $event && $event.button !== 2`),
-  };
-  function genHandlers(events, isNative) {
-      const prefix = isNative ? 'nativeOn:' : 'on:';
-      let staticHandlers = ``;
-      let dynamicHandlers = ``;
-      for (const name in events) {
-          const handlerCode = genHandler(events[name]);
-          //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += `${name},${handlerCode},`;
-          }
-          else {
-              staticHandlers += `"${name}":${handlerCode},`;
-          }
-      }
-      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-      if (dynamicHandlers) {
-          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-      }
-      else {
-          return prefix + staticHandlers;
-      }
-  }
-  function genHandler(handler) {
-      if (!handler) {
-          return 'function(){}';
-      }
-      if (Array.isArray(handler)) {
-          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-      }
-      const isMethodPath = simplePathRE.test(handler.value);
-      const isFunctionExpression = fnExpRE.test(handler.value);
-      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-      if (!handler.modifiers) {
-          if (isMethodPath || isFunctionExpression) {
-              return handler.value;
-          }
-          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-      }
-      else {
-          let code = '';
-          let genModifierCode = '';
-          const keys = [];
-          for (const key in handler.modifiers) {
-              if (modifierCode[key]) {
-                  genModifierCode += modifierCode[key];
-                  // left/right
-                  if (keyCodes[key]) {
-                      keys.push(key);
-                  }
-              }
-              else if (key === 'exact') {
-                  const modifiers = handler.modifiers;
-                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter((keyModifier) => !modifiers[keyModifier])
-                      .map((keyModifier) => `$event.${keyModifier}Key`)
-                      .join('||'));
-              }
-              else {
-                  keys.push(key);
-              }
-          }
-          if (keys.length) {
-              code += genKeyFilter(keys);
-          }
-          // Make sure modifiers like prevent and stop get executed after key filtering
-          if (genModifierCode) {
-              code += genModifierCode;
-          }
-          const handlerCode = isMethodPath
-              ? `return ${handler.value}.apply(null, arguments)`
-              : isFunctionExpression
-                  ? `return (${handler.value}).apply(null, arguments)`
-                  : isFunctionInvocation
-                      ? `return ${handler.value}`
-                      : handler.value;
-          return `function($event){${code}${handlerCode}}`;
-      }
-  }
-  function genKeyFilter(keys) {
-      return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      `if(!$event.type.indexOf('key')&&` +
-          `${keys.map(genFilterCode).join('&&')})return null;`);
-  }
-  function genFilterCode(key) {
-      const keyVal = parseInt(key, 10);
-      if (keyVal) {
-          return `$event.keyCode!==${keyVal}`;
-      }
-      const keyCode = keyCodes[key];
-      const keyName = keyNames[key];
-      return (`_k($event.keyCode,` +
-          `${JSON.stringify(key)},` +
-          `${JSON.stringify(keyCode)},` +
-          `$event.key,` +
-          `${JSON.stringify(keyName)}` +
-          `)`);
-  }
-
-  function on(el, dir) {
-      if (dir.modifiers) {
-          warn$2(`v-on without argument does not support modifiers.`);
-      }
-      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-  }
-
-  function bind(el, dir) {
-      el.wrapData = (code) => {
-          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-      };
-  }
-
-  var baseDirectives = {
-      on,
-      bind,
-      cloak: noop,
-  };
-
-  class CodegenState {
-      options;
-      warn;
-      transforms;
-      dataGenFns;
-      directives;
-      maybeComponent;
-      onceId;
-      staticRenderFns;
-      pre;
-      constructor(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          const isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-  }
-  function generate(ast, options) {
-      const state = new CodegenState(options);
-      // fix #11483, Root level <script> tags should not be rendered.
-      const code = ast
-          ? ast.tag === 'script'
-              ? 'null'
-              : genElement(ast, state)
-          : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genElement(el, state) {
-      if (el.parent) {
-          el.pre = el.pre || el.parent.pre;
-      }
-      if (el.staticRoot && !el.staticProcessed) {
-          return genStatic(el, state);
-      }
-      else if (el.once && !el.onceProcessed) {
-          return genOnce(el, state);
-      }
-      else if (el.for && !el.forProcessed) {
-          return genFor(el, state);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-          return genChildren(el, state) || 'void 0';
-      }
-      else if (el.tag === 'slot') {
-          return genSlot(el, state);
-      }
-      else {
-          // component or element
-          let code;
-          if (el.component) {
-              code = genComponent(el.component, el, state);
-          }
-          else {
-              let data;
-              if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData(el, state);
-              }
-              const children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-          }
-          // module transforms
-          for (let i = 0; i < state.transforms.length; i++) {
-              code = state.transforms[i](el, code);
-          }
-          return code;
-      }
-  }
-  // hoist static sub-trees out
-  function genStatic(el, state) {
-      el.staticProcessed = true;
-      // Some elements (templates) need to behave differently inside of a v-pre
-      // node.  All pre nodes are static roots, so we can use this as a location to
-      // wrap a state change and reset it upon exiting the pre node.
-      const originalPreState = state.pre;
-      if (el.pre) {
-          state.pre = el.pre;
-      }
-      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-      state.pre = originalPreState;
-      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-  }
-  // v-once
-  function genOnce(el, state) {
-      el.onceProcessed = true;
-      if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.staticInFor) {
-          let key = '';
-          let parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
-                  break;
-              }
-              parent = parent.parent;
-          }
-          if (!key) {
-              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-              return genElement(el, state);
-          }
-          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-      }
-      else {
-          return genStatic(el, state);
-      }
-  }
-  function genIf(el, state, altGen, altEmpty) {
-      el.ifProcessed = true; // avoid recursion
-      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-  }
-  function genIfConditions(conditions, state, altGen, altEmpty) {
-      if (!conditions.length) {
-          return altEmpty || '_e()';
-      }
-      const condition = conditions.shift();
-      if (condition.exp) {
-          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-      }
-      else {
-          return `${genTernaryExp(condition.block)}`;
-      }
-      // v-if with v-once should generate code like (a)?_m(0):_m(1)
-      function genTernaryExp(el) {
-          return altGen
-              ? altGen(el, state)
-              : el.once
-                  ? genOnce(el, state)
-                  : genElement(el, state);
-      }
-  }
-  function genFor(el, state, altGen, altHelper) {
-      const exp = el.for;
-      const alias = el.alias;
-      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-      if (state.maybeComponent(el) &&
-          el.tag !== 'slot' &&
-          el.tag !== 'template' &&
-          !el.key) {
-          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-              `v-for should have explicit keys. ` +
-              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-      }
-      el.forProcessed = true; // avoid recursion
-      return (`${altHelper || '_l'}((${exp}),` +
-          `function(${alias}${iterator1}${iterator2}){` +
-          `return ${(altGen || genElement)(el, state)}` +
-          '})');
-  }
-  function genData(el, state) {
-      let data = '{';
-      // directives first.
-      // directives may mutate the el's other properties before they are generated.
-      const dirs = genDirectives(el, state);
-      if (dirs)
-          data += dirs + ',';
-      // key
-      if (el.key) {
-          data += `key:${el.key},`;
-      }
-      // ref
-      if (el.ref) {
-          data += `ref:${el.ref},`;
-      }
-      if (el.refInFor) {
-          data += `refInFor:true,`;
-      }
-      // pre
-      if (el.pre) {
-          data += `pre:true,`;
-      }
-      // record original tag name for components using "is" attribute
-      if (el.component) {
-          data += `tag:"${el.tag}",`;
-      }
-      // module data generation functions
-      for (let i = 0; i < state.dataGenFns.length; i++) {
-          data += state.dataGenFns[i](el);
-      }
-      // attributes
-      if (el.attrs) {
-          data += `attrs:${genProps(el.attrs)},`;
-      }
-      // DOM props
-      if (el.props) {
-          data += `domProps:${genProps(el.props)},`;
-      }
-      // event handlers
-      if (el.events) {
-          data += `${genHandlers(el.events, false)},`;
-      }
-      if (el.nativeEvents) {
-          data += `${genHandlers(el.nativeEvents, true)},`;
-      }
-      // slot target
-      // only for non-scoped slots
-      if (el.slotTarget && !el.slotScope) {
-          data += `slot:${el.slotTarget},`;
-      }
-      // scoped slots
-      if (el.scopedSlots) {
-          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-      }
-      // component v-model
-      if (el.model) {
-          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-      }
-      // inline-template
-      if (el.inlineTemplate) {
-          const inlineTemplate = genInlineTemplate(el, state);
-          if (inlineTemplate) {
-              data += `${inlineTemplate},`;
-          }
-      }
-      data = data.replace(/,$/, '') + '}';
-      // v-bind dynamic argument wrap
-      // v-bind with dynamic arguments must be applied using the same v-bind object
-      // merge helper so that class/style/mustUseProp attrs are handled correctly.
-      if (el.dynamicAttrs) {
-          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-      }
-      // v-bind data wrap
-      if (el.wrapData) {
-          data = el.wrapData(data);
-      }
-      // v-on data wrap
-      if (el.wrapListeners) {
-          data = el.wrapListeners(data);
-      }
-      return data;
-  }
-  function genDirectives(el, state) {
-      const dirs = el.directives;
-      if (!dirs)
-          return;
-      let res = 'directives:[';
-      let hasRuntime = false;
-      let i, l, dir, needRuntime;
-      for (i = 0, l = dirs.length; i < l; i++) {
-          dir = dirs[i];
-          needRuntime = true;
-          const gen = state.directives[dir.name];
-          if (gen) {
-              // compile-time directive that manipulates AST.
-              // returns true if it also needs a runtime counterpart.
-              needRuntime = !!gen(el, dir, state.warn);
-          }
-          if (needRuntime) {
-              hasRuntime = true;
-              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-          }
-      }
-      if (hasRuntime) {
-          return res.slice(0, -1) + ']';
-      }
-  }
-  function genInlineTemplate(el, state) {
-      const ast = el.children[0];
-      if ((el.children.length !== 1 || ast.type !== 1)) {
-          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-      }
-      if (ast && ast.type === 1) {
-          const inlineRenderFns = generate(ast, state.options);
-          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-      }
-  }
-  function genScopedSlots(el, slots, state) {
-      // by default scoped slots are considered "stable", this allows child
-      // components with only scoped slots to skip forced updates from parent.
-      // but in some cases we have to bail-out of this optimization
-      // for example if the slot contains dynamic names, has v-if or v-for on them...
-      let needsForceUpdate = el.for ||
-          Object.keys(slots).some((key) => {
-              const slot = slots[key];
-              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-              );
-          });
-      // #9534: if a component with scoped slots is inside a conditional branch,
-      // it's possible for the same component to be reused but with different
-      // compiled slot content. To avoid that, we generate a unique key based on
-      // the generated code of all the slot contents.
-      let needsKey = !!el.if;
-      // OR when it is inside another scoped slot or v-for (the reactivity may be
-      // disconnected due to the intermediate scope variable)
-      // #9438, #9506
-      // TODO: this can be further optimized by properly analyzing in-scope bindings
-      // and skip force updating ones that do not actually use scope variables.
-      if (!needsForceUpdate) {
-          let parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
-                  needsForceUpdate = true;
-                  break;
-              }
-              if (parent.if) {
-                  needsKey = true;
-              }
-              parent = parent.parent;
-          }
-      }
-      const generatedSlots = Object.keys(slots)
-          .map((key) => genScopedSlot(slots[key], state))
-          .join(',');
-      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-  }
-  function hash(str) {
-      let hash = 5381;
-      let i = str.length;
-      while (i) {
-          hash = (hash * 33) ^ str.charCodeAt(--i);
-      }
-      return hash >>> 0;
-  }
-  function containsSlotChild(el) {
-      if (el.type === 1) {
-          if (el.tag === 'slot') {
-              return true;
-          }
-          return el.children.some(containsSlotChild);
-      }
-      return false;
-  }
-  function genScopedSlot(el, state) {
-      const isLegacySyntax = el.attrsMap['slot-scope'];
-      if (el.if && !el.ifProcessed && !isLegacySyntax) {
-          return genIf(el, state, genScopedSlot, `null`);
-      }
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genScopedSlot);
-      }
-      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-      const fn = `function(${slotScope}){` +
-          `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-      // reverse proxy v-slot without scope on this.$slots
-      const reverseProxy = slotScope ? `` : `,proxy:true`;
-      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-  }
-  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-      const children = el.children;
-      if (children.length) {
-          const el = children[0];
-          // optimize single v-for
-          if (children.length === 1 &&
-              el.for &&
-              el.tag !== 'template' &&
-              el.tag !== 'slot') {
-              const normalizationType = checkSkip
-                  ? state.maybeComponent(el)
-                      ? `,1`
-                      : `,0`
-                  : ``;
-              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-          }
-          const normalizationType = checkSkip
-              ? getNormalizationType(children, state.maybeComponent)
-              : 0;
-          const gen = altGenNode || genNode;
-          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-      }
-  }
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType(children, maybeComponent) {
-      let res = 0;
-      for (let i = 0; i < children.length; i++) {
-          const el = children[i];
-          if (el.type !== 1) {
-              continue;
-          }
-          if (needsNormalization(el) ||
-              (el.ifConditions &&
-                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
-              res = 2;
-              break;
-          }
-          if (maybeComponent(el) ||
-              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-              res = 1;
-          }
-      }
-      return res;
-  }
-  function needsNormalization(el) {
-      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-  }
-  function genNode(node, state) {
-      if (node.type === 1) {
-          return genElement(node, state);
-      }
-      else if (node.type === 3 && node.isComment) {
-          return genComment(node);
-      }
-      else {
-          return genText(node);
-      }
-  }
-  function genText(text) {
-      return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-  }
-  function genComment(comment) {
-      return `_e(${JSON.stringify(comment.text)})`;
-  }
-  function genSlot(el, state) {
-      const slotName = el.slotName || '"default"';
-      const children = genChildren(el, state);
-      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-      const attrs = el.attrs || el.dynamicAttrs
-          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-              // slot props are camelized
-              name: camelize(attr.name),
-              value: attr.value,
-              dynamic: attr.dynamic
-          })))
-          : null;
-      const bind = el.attrsMap['v-bind'];
-      if ((attrs || bind) && !children) {
-          res += `,null`;
-      }
-      if (attrs) {
-          res += `,${attrs}`;
-      }
-      if (bind) {
-          res += `${attrs ? '' : ',null'},${bind}`;
-      }
-      return res + ')';
-  }
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent(componentName, el, state) {
-      const children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-  }
-  function genProps(props) {
-      let staticProps = ``;
-      let dynamicProps = ``;
-      for (let i = 0; i < props.length; i++) {
-          const prop = props[i];
-          const value = transformSpecialNewlines(prop.value);
-          if (prop.dynamic) {
-              dynamicProps += `${prop.name},${value},`;
-          }
-          else {
-              staticProps += `"${prop.name}":${value},`;
-          }
-      }
-      staticProps = `{${staticProps.slice(0, -1)}}`;
-      if (dynamicProps) {
-          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-      }
-      else {
-          return staticProps;
-      }
-  }
-  // #3895, #4268
-  function transformSpecialNewlines(text) {
-      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-  }
-
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  const prohibitedKeywordRE = new RegExp('\\b' +
-      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-          'super,throw,while,yield,delete,export,import,return,switch,default,' +
-          'extends,finally,continue,debugger,function,arguments')
-          .split(',')
-          .join('\\b|\\b') +
-      '\\b');
-  // these unary operators should not be used as property/method names
-  const unaryOperatorsRE = new RegExp('\\b' +
-      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-      '\\s*\\([^\\)]*\\)');
-  // strip strings in expressions
-  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-  // detect problematic expressions in a template
-  function detectErrors(ast, warn) {
-      if (ast) {
-          checkNode(ast, warn);
-      }
-  }
-  function checkNode(node, warn) {
-      if (node.type === 1) {
-          for (const name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  const value = node.attrsMap[name];
-                  if (value) {
-                      const range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, `v-for="${value}"`, warn, range);
-                      }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, `${name}="${value}"`, warn, range);
-                      }
-                      else {
-                          checkExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                  }
-              }
-          }
-          if (node.children) {
-              for (let i = 0; i < node.children.length; i++) {
-                  checkNode(node.children[i], warn);
-              }
-          }
-      }
-      else if (node.type === 2) {
-          checkExpression(node.expression, node.text, warn, node);
-      }
-  }
-  function checkEvent(exp, text, warn, range) {
-      const stripped = exp.replace(stripStringRE, '');
-      const keywordMatch = stripped.match(unaryOperatorsRE);
-      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-          warn(`avoid using JavaScript unary operator as property name: ` +
-              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-      }
-      checkExpression(exp, text, warn, range);
-  }
-  function checkFor(node, text, warn, range) {
-      checkExpression(node.for || '', text, warn, range);
-      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-  }
-  function checkIdentifier(ident, type, text, warn, range) {
-      if (typeof ident === 'string') {
-          try {
-              new Function(`var ${ident}=_`);
-          }
-          catch (e) {
-              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-          }
-      }
-  }
-  function checkExpression(exp, text, warn, range) {
-      try {
-          new Function(`return ${exp}`);
-      }
-      catch (e) {
-          const keywordMatch = exp
-              .replace(stripStringRE, '')
-              .match(prohibitedKeywordRE);
-          if (keywordMatch) {
-              warn(`avoid using JavaScript keyword as property name: ` +
-                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-          }
-          else {
-              warn(`invalid expression: ${e.message} in\n\n` +
-                  `    ${exp}\n\n` +
-                  `  Raw expression: ${text.trim()}\n`, range);
-          }
-      }
-  }
-  function checkFunctionParameterExpression(exp, text, warn, range) {
-      try {
-          new Function(exp, '');
-      }
-      catch (e) {
-          warn(`invalid function parameter expression: ${e.message} in\n\n` +
-              `    ${exp}\n\n` +
-              `  Raw expression: ${text.trim()}\n`, range);
-      }
-  }
-
-  const range = 2;
-  function generateCodeFrame(source, start = 0, end = source.length) {
-      const lines = source.split(/\r?\n/);
-      let count = 0;
-      const res = [];
-      for (let i = 0; i < lines.length; i++) {
-          count += lines[i].length + 1;
-          if (count >= start) {
-              for (let j = i - range; j <= i + range || end > count; j++) {
-                  if (j < 0 || j >= lines.length)
-                      continue;
-                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                  const lineLength = lines[j].length;
-                  if (j === i) {
-                      // push underline
-                      const pad = start - (count - lineLength) + 1;
-                      const length = end > count ? lineLength - pad : end - start;
-                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                  }
-                  else if (j > i) {
-                      if (end > count) {
-                          const length = Math.min(end - count, lineLength);
-                          res.push(`   |  ` + repeat(`^`, length));
-                      }
-                      count += lineLength + 1;
-                  }
-              }
-              break;
-          }
-      }
-      return res.join('\n');
-  }
-  function repeat(str, n) {
-      let result = '';
-      if (n > 0) {
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-              // eslint-disable-line
-              if (n & 1)
-                  result += str;
-              n >>>= 1;
-              if (n <= 0)
-                  break;
-              str += str;
-          }
-      }
-      return result;
-  }
-
-  function createFunction(code, errors) {
-      try {
-          return new Function(code);
-      }
-      catch (err) {
-          errors.push({ err, code });
-          return noop;
-      }
-  }
-  function createCompileToFunctionFn(compile) {
-      const cache = Object.create(null);
-      return function compileToFunctions(template, options, vm) {
-          options = extend({}, options);
-          const warn = options.warn || warn$2;
-          delete options.warn;
-          /* istanbul ignore if */
-          {
-              // detect possible CSP restriction
-              try {
-                  new Function('return 1');
-              }
-              catch (e) {
-                  if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn('It seems you are using the standalone build of Vue.js in an ' +
-                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                          'The template compiler cannot work in this environment. Consider ' +
-                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                          'templates into render functions.');
-                  }
-              }
-          }
-          // check cache
-          const key = options.delimiters
-              ? String(options.delimiters) + template
-              : template;
-          if (cache[key]) {
-              return cache[key];
-          }
-          // compile
-          const compiled = compile(template, options);
-          // check compilation errors/tips
-          {
-              if (compiled.errors && compiled.errors.length) {
-                  if (options.outputSourceRange) {
-                      compiled.errors.forEach((e) => {
-                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                              generateCodeFrame(template, e.start, e.end), vm);
-                      });
-                  }
-                  else {
-                      warn(`Error compiling template:\n\n${template}\n\n` +
-                          compiled.errors.map((e) => `- ${e}`).join('\n') +
-                          '\n', vm);
-                  }
-              }
-              if (compiled.tips && compiled.tips.length) {
-                  if (options.outputSourceRange) {
-                      compiled.tips.forEach((e) => tip(e.msg, vm));
-                  }
-                  else {
-                      compiled.tips.forEach((msg) => tip(msg, vm));
-                  }
-              }
-          }
-          // turn code into functions
-          const res = {};
-          const fnGenErrors = [];
-          res.render = createFunction(compiled.render, fnGenErrors);
-          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-              return createFunction(code, fnGenErrors);
-          });
-          // check function generation errors.
-          // this should only happen if there is a bug in the compiler itself.
-          // mostly for codegen development use
-          /* istanbul ignore if */
-          {
-              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn(`Failed to generate render function:\n\n` +
-                      fnGenErrors
-                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                          .join('\n'), vm);
-              }
-          }
-          return (cache[key] = res);
-      };
-  }
-
-  function createCompilerCreator(baseCompile) {
-      return function createCompiler(baseOptions) {
-          function compile(template, options) {
-              const finalOptions = Object.create(baseOptions);
-              const errors = [];
-              const tips = [];
-              let warn = (msg, range, tip) => {
-                  (tip ? tips : errors).push(msg);
-              };
-              if (options) {
-                  if (options.outputSourceRange) {
-                      // $flow-disable-line
-                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                      warn = (msg, range, tip) => {
-                          const data = typeof (msg) === 'string' ? { msg } : msg;
-                          if (range) {
-                              if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
-                              }
-                              if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
-                              }
-                          }
-                          (tip ? tips : errors).push(data);
-                      };
-                  }
-                  // merge custom modules
-                  if (options.modules) {
-                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                  }
-                  // merge custom directives
-                  if (options.directives) {
-                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                  }
-                  // copy other options
-                  for (const key in options) {
-                      if (key !== 'modules' && key !== 'directives') {
-                          finalOptions[key] = options[key];
-                      }
-                  }
-              }
-              finalOptions.warn = warn;
-              const compiled = baseCompile(template.trim(), finalOptions);
-              {
-                  detectErrors(compiled.ast, warn);
-              }
-              compiled.errors = errors;
-              compiled.tips = tips;
-              return compiled;
-          }
-          return {
-              compile,
-              compileToFunctions: createCompileToFunctionFn(compile),
-          };
-      };
-  }
-
-  // `createCompilerCreator` allows creating compilers that use alternative
-  // parser/optimizer/codegen, e.g the SSR optimizing compiler.
-  // Here we just export a default compiler using the default parts.
-  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-      const ast = parse(template.trim(), options);
-      if (options.optimize !== false) {
-          optimize(ast, options);
-      }
-      const code = generate(ast, options);
-      return {
-          ast,
-          render: code.render,
-          staticRenderFns: code.staticRenderFns,
-      };
-  });
-
-  const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-  // check whether current browser encodes a char inside attribute values
-  let div;
-  function getShouldDecode(href) {
-      div = div || document.createElement('div');
-      div.innerHTML = href ? `<a href="\n"/>` : `<div a="\n"/>`;
-      return div.innerHTML.indexOf('&#10;') > 0;
-  }
-  // #3663: IE encodes newlines inside attribute values while other browsers don't
-  const shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;
-  // #6828: chrome encodes content in a[href]
-  const shouldDecodeNewlinesForHref = inBrowser
-      ? getShouldDecode(true)
-      : false;
-
-  const idToTemplate = cached((id) => {
-      const el = query(id);
-      return el && el.innerHTML;
-  });
-  const mount = Vue.prototype.$mount;
-  Vue.prototype.$mount = function (el, hydrating) {
-      el = el && query(el);
-      /* istanbul ignore if */
-      if (el === document.body || el === document.documentElement) {
-          warn$2(`Do not mount Vue to <html> or <body> - mount to normal elements instead.`);
-          return this;
-      }
-      const options = this.$options;
-      // resolve template/el and convert to render function
-      if (!options.render) {
-          let template = options.template;
-          if (template) {
-              if (typeof template === 'string') {
-                  if (template.charAt(0) === '#') {
-                      template = idToTemplate(template);
-                      /* istanbul ignore if */
-                      if (!template) {
-                          warn$2(`Template element not found or is empty: ${options.template}`, this);
-                      }
-                  }
-              }
-              else if (template.nodeType) {
-                  template = template.innerHTML;
-              }
-              else {
-                  {
-                      warn$2('invalid template option:' + template, this);
-                  }
-                  return this;
-              }
-          }
-          else if (el) {
-              // @ts-expect-error
-              template = getOuterHTML(el);
-          }
-          if (template) {
-              /* istanbul ignore if */
-              if (config.performance && mark) {
-                  mark('compile');
-              }
-              const { render, staticRenderFns } = compileToFunctions(template, {
-                  outputSourceRange: "development" !== 'production',
-                  shouldDecodeNewlines,
-                  shouldDecodeNewlinesForHref,
-                  delimiters: options.delimiters,
-                  comments: options.comments,
-              }, this);
-              options.render = render;
-              options.staticRenderFns = staticRenderFns;
-              /* istanbul ignore if */
-              if (config.performance && mark) {
-                  mark('compile end');
-                  measure(`vue ${this._name} compile`, 'compile', 'compile end');
-              }
-          }
-      }
-      return mount.call(this, el, hydrating);
-  };
-  /**
-   * Get outerHTML of elements, taking care
-   * of SVG elements in IE as well.
-   */
-  function getOuterHTML(el) {
-      if (el.outerHTML) {
-          return el.outerHTML;
-      }
-      else {
-          const container = document.createElement('div');
-          container.appendChild(el.cloneNode(true));
-          return container.innerHTML;
-      }
-  }
-  Vue.compile = compileToFunctions;
-
-  return Vue;
-
-}));
diff --git a/dist/vue.min.js b/dist/vue.min.js
deleted file mode 100644
index 97b782345a9..00000000000
--- a/dist/vue.min.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("slot,component",!0),h=d("key,ref,slot,slot-scope,is");function m(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const y=Object.prototype.hasOwnProperty;function g(t,e){return y.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const $=/-(\w)/g,_=v((t=>t.replace($,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),w=/\B([A-Z])/g,C=v((t=>t.replace(w,"-$1").toLowerCase()));const x=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function k(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function A(t,e){for(const n in e)t[n]=e[n];return t}function O(t){const e={};for(let n=0;n<t.length;n++)t[n]&&A(e,t[n]);return e}function S(t,e,n){}const T=(t,e,n)=>!1,N=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function j(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function D(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const I="data-server-rendered",M=["component","directive","filter"],L=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var F={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:T,isReservedAttr:T,isUnknownElement:T,getTagNamespace:S,parsePlatformTagName:N,mustUseProp:T,async:!0,_lifecycleHooks:L};const P=/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;function R(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function H(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const B=new RegExp(`[^${P.source}.$_\\d]`);const U="__proto__"in{},V="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,K=z&&WXEnvironment.platform.toLowerCase(),J=V&&window.navigator.userAgent.toLowerCase(),q=J&&/msie|trident/.test(J),W=J&&J.indexOf("msie 9.0")>0,G=J&&J.indexOf("edge/")>0;J&&J.indexOf("android");const Z=J&&/iphone|ipad|ipod|ios/.test(J)||"ios"===K;J&&/chrome\/\d+/.test(J),J&&/phantomjs/.test(J);const X=J&&J.match(/firefox\/(\d+)/),Y={}.watch;let Q,tt=!1;if(V)try{const t={};Object.defineProperty(t,"passive",{get(){tt=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const et=()=>(void 0===Q&&(Q=!V&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Q),nt=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function ot(t){return"function"==typeof t&&/native code/.test(t.toString())}const rt="undefined"!=typeof Symbol&&ot(Symbol)&&"undefined"!=typeof Reflect&&ot(Reflect.ownKeys);let st;st="undefined"!=typeof Set&&ot(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let it=S,at=0;class ct{static target;id;subs;constructor(){this.id=at++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){m(this.subs,t)}depend(){ct.target&&ct.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}ct.target=null;const lt=[];function ut(t){lt.push(t),ct.target=t}function ft(){lt.pop(),ct.target=lt[lt.length-1]}class dt{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const pt=(t="")=>{const e=new dt;return e.text=t,e.isComment=!0,e};function ht(t){return new dt(void 0,void 0,void 0,String(t))}function mt(t){const e=new dt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const yt=Array.prototype,gt=Object.create(yt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=yt[t];H(gt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const vt=Object.getOwnPropertyNames(gt);let $t=!0;function _t(t){$t=t}class bt{value;dep;vmCount;constructor(t){this.value=t,this.dep=new ct,this.vmCount=0,H(t,"__ob__",this),Array.isArray(t)?(U?function(t,e){t.__proto__=e}(t,gt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];H(t,r,e[r])}}(t,gt,vt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)Ct(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)wt(t[e])}}function wt(t,e){if(!s(t)||t instanceof dt)return;let n;return g(t,"__ob__")&&t.__ob__ instanceof bt?n=t.__ob__:$t&&!et()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new bt(t)),e&&n&&n.vmCount++,n}function Ct(t,e,n,o,r){const s=new ct,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&wt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return ct.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&At(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&wt(e),s.notify())}})}function xt(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(Ct(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function kt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||g(t,e)&&(delete t[e],n&&n.dep.notify())}function At(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&At(e)}const Ot=F.optionMergeStrategies;function St(t,e){if(!e)return t;let n,o,r;const s=rt?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],g(t,n)?o!==r&&a(o)&&a(r)&&St(o,r):xt(t,n,r));return t}function Tt(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?St(o,r):r}:e?t?function(){return St("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Nt(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Et(t,e,n,o){const r=Object.create(t||null);return e?A(r,e):r}Ot.data=function(t,e,n){return n?Tt(t,e,n):e&&"function"!=typeof e?t:Tt(t,e)},L.forEach((t=>{Ot[t]=Nt})),M.forEach((function(t){Ot[t+"s"]=Et})),Ot.watch=function(t,e,n,o){if(t===Y&&(t=void 0),e===Y&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};A(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},Ot.props=Ot.methods=Ot.inject=Ot.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return A(r,t),e&&A(r,e),r},Ot.provide=Tt;const jt=function(t,e){return void 0===e?t:e};function Dt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?A({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=Dt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=Dt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)g(t,r)||s(r);function s(r){const s=Ot[r]||jt;o[r]=s(t[r],e[r],n,r)}return o}function It(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(g(r,n))return r[n];const s=_(n);if(g(r,s))return r[s];const i=b(s);if(g(r,i))return r[i];return r[n]||r[s]||r[i]}function Mt(t,e,n,o){const r=e[t],s=!g(n,t);let i=n[t];const a=Rt(Boolean,r.type);if(a>-1)if(s&&!g(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Rt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!g(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Ft(e.type)?o.call(t):o}(o,r,t);const e=$t;_t(!0),wt(i),_t(e)}return i}const Lt=/^\s*function (\w+)/;function Ft(t){const e=t&&t.toString().match(Lt);return e?e[1]:""}function Pt(t,e){return Ft(t)===Ft(e)}function Rt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Pt(e[n],t))return n;return-1}function Ht(t,e,n){ut();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Ut(t,o,"errorCaptured hook")}}}Ut(t,e,n)}finally{ft()}}function Bt(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Ht(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Ht(t,o,r)}return s}function Ut(t,e,n){if(F.errorHandler)try{return F.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Vt(e)}Vt(t)}function Vt(t,e,n){if(!V&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Kt=[];let Jt,qt=!1;function Wt(){qt=!1;const t=Kt.slice(0);Kt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&ot(Promise)){const t=Promise.resolve();Jt=()=>{t.then(Wt),Z&&setTimeout(S)},zt=!0}else if(q||"undefined"==typeof MutationObserver||!ot(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Jt="undefined"!=typeof setImmediate&&ot(setImmediate)?()=>{setImmediate(Wt)}:()=>{setTimeout(Wt,0)};else{let t=1;const e=new MutationObserver(Wt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Jt=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Gt(t,e){let n;if(Kt.push((()=>{if(t)try{t.call(e)}catch(t){Ht(t,e,"nextTick")}else n&&n(e)})),qt||(qt=!0,Jt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Zt=new st;function Xt(t){Yt(t,Zt),Zt.clear()}function Yt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof dt)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Yt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Yt(t[o[n]],e)}}const Qt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function te(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Bt(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Bt(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function ee(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Qt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=te(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Qt(c),s(f.name,n[c],f.capture))}function ne(t,r,s){let i;t instanceof dt&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),m(i.fns,c)}e(a)?i=te([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=te([a,c]),i.merged=!0,t[r]=i}function oe(t,e,o,r,s){if(n(e)){if(g(e,o))return t[o]=e[o],s||delete e[o],!0;if(g(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function re(t){return r(t)?[ht(t)]:Array.isArray(t)?ie(t):void 0}function se(t){return n(t)&&n(t.text)&&!1===t.isComment}function ie(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=ie(c,`${s||""}_${a}`),se(c[0])&&se(u)&&(i[l]=ht(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?se(u)?i[l]=ht(u.text+c):""!==c&&i.push(ht(c)):se(c)&&se(u)?i[l]=ht(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function ae(t,e){if(t){const n=Object.create(null),o=rt?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&g(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ce(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(le)&&delete n[t];return n}function le(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ue(t){return t.isComment&&t.asyncFactory}function fe(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=de(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=pe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),H(r,"$stable",i),H(r,"$key",a),H(r,"$hasNormal",s),r}function de(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:re(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!ue(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function pe(t,e){return()=>t[e]}function he(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(rt&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function me(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=A(A({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function ye(t){return It(this.$options,"filters",t)||N}function ge(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ve(t,e,n,o,r){const s=F.keyCodes[e]||n;return r&&o&&!F.keyCodes[e]?ge(r,o):s?ge(s,t):o?C(o)!==e:void 0===t}function $e(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=O(n));for(const i in n){if("class"===i||"style"===i||h(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||F.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function _e(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),we(o,`__static__${t}`,!1)),o}function be(t,e,n){return we(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function we(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&Ce(t[o],`${e}_${o}`,n);else Ce(t,e,n)}function Ce(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function xe(t,e){if(e)if(a(e)){const n=t.on=t.on?A({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function ke(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?ke(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function Ae(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Oe(t,e){return"string"==typeof t?e+t:t}function Se(t){t._o=be,t._n=f,t._s=u,t._l=he,t._t=me,t._q=E,t._i=j,t._m=_e,t._f=ye,t._k=ve,t._b=$e,t._v=ht,t._e=pt,t._u=ke,t._g=xe,t._d=Ae,t._p=Oe}function Te(e,n,r,s,i){const a=i.options;let c;g(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=ae(a.inject,s),this.slots=()=>(this.$slots||fe(e.scopedSlots,this.$slots=ce(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return fe(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=fe(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Le(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Le(c,t,e,n,o,u)}function Ne(t,e,n,o,r){const s=mt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Ee(t,e){for(const n in e)t[_(n)]=e[n]}Se(Te.prototype);const je={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;je.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Je)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){_t(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Mt(s,i,n,e)}_t(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Ke(e,o,u),l&&(e.$slots=ce(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Xe(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Qe.push(o)):Ge(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ze(e,!0):e.$destroy())}},De=Object.keys(je);function Ie(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Re;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>m(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=D((e=>{t.resolved=He(e,r),a?o.length=0:f(!0)})),p=D((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),h=t(d,p);return s(h)&&(l(h)?e(t.resolved)&&h.then(d,p):l(h.component)&&(h.component.then(d,p),n(h.error)&&(t.errorComp=He(h.error,r)),n(h.loading)&&(t.loadingComp=He(h.loading,r),0===h.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),h.delay||200)),n(h.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),h.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=pt();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},$n(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);oe(i,c,t,e,!0)||oe(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Mt(e,l,o||t);else n(r.attrs)&&Ee(c,r.attrs),n(r.props)&&Ee(c,r.props);const u=new Te(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof dt)return Ne(f,r,u.parent,a);if(Array.isArray(f)){const t=re(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Ne(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const h=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<De.length;t++){const n=De[t],o=e[n],r=je[n];o===r||o&&o._merged||(e[n]=o?Me(r,o):r)}}(i);const y=r.options.name||u;return new dt(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:h,tag:u,children:c},d)}function Me(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Le(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return pt();n(o)&&n(o.is)&&(e=o.is);if(!e)return pt();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=re(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||F.getTagNamespace(e),a=F.isReservedTag(e)?new dt(F.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=It(t.$options,"components",e))?new dt(e,o,r,void 0,void 0,t):Ie(s,o,t,r,e)}else a=Ie(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Fe(a,c),n(o)&&function(t){s(t.style)&&Xt(t.style);s(t.class)&&Xt(t.class)}(o),a):pt()}(t,e,i,a,c)}function Fe(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Fe(a,r,s)}}let Pe,Re=null;function He(t,e){return(t.__esModule||rt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Be(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||ue(o)))return o}}function Ue(t,e){Pe.$on(t,e)}function Ve(t,e){Pe.$off(t,e)}function ze(t,e){const n=Pe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Ke(t,e,n){Pe=t,ee(e,n||{},Ue,Ve,ze,t),Pe=void 0}let Je=null;function qe(t){const e=Je;return Je=t,()=>{Je=e}}function We(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ge(t,e){if(e){if(t._directInactive=!1,We(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)Ge(t.$children[e]);Xe(t,"activated")}}function Ze(t,e){if(!(e&&(t._directInactive=!0,We(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ze(t.$children[e]);Xe(t,"deactivated")}}function Xe(t,e){ut();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Bt(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ft()}const Ye=[],Qe=[];let tn={},en=!1,nn=!1,on=0;let rn=0,sn=Date.now;if(V&&!q){const t=window.performance;t&&"function"==typeof t.now&&sn()>document.createEvent("Event").timeStamp&&(sn=()=>t.now())}function an(){let t,e;for(rn=sn(),nn=!0,Ye.sort(((t,e)=>t.id-e.id)),on=0;on<Ye.length;on++)t=Ye[on],t.before&&t.before(),e=t.id,tn[e]=null,t.run();const n=Qe.slice(),o=Ye.slice();on=Ye.length=Qe.length=0,tn={},en=nn=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,Ge(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Xe(o,"updated")}}(o),nt&&F.devtools&&nt.emit("flush")}let cn=0;class ln{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++cn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new st,this.newDepIds=new st,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(B.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=S)),this.value=this.lazy?void 0:this.get()}get(){let t;ut(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ht(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Xt(t),ft(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==tn[e]){if(tn[e]=!0,nn){let e=Ye.length-1;for(;e>on&&Ye[e].id>t.id;)e--;Ye.splice(e+1,0,t)}else Ye.push(t);en||(en=!0,Gt(an))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Bt(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||m(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const un={enumerable:!0,configurable:!0,get:S,set:S};function fn(t,e,n){un.get=function(){return this[e][n]},un.set=function(t){this[e][n]=t},Object.defineProperty(t,n,un)}function dn(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&_t(!1);for(const s in e){r.push(s);Ct(o,s,Mt(s,e,n,t)),s in t||fn(t,"_props",s)}_t(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?S:x(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){ut();try{return t.call(e,e)}catch(t){return Ht(t,e,"data()"),{}}finally{ft()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&g(o,e)||R(e)||fn(t,"_data",e)}wt(e,!0)}(t):wt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=et();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new ln(t,i||S,S,pn)),r in t||hn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==Y&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)gn(t,n,o[e]);else gn(t,n,o)}}(t,e.watch)}const pn={lazy:!0};function hn(t,e,n){const o=!et();"function"==typeof n?(un.get=o?mn(e):yn(n),un.set=S):(un.get=n.get?o&&!1!==n.cache?mn(e):yn(n.get):S,un.set=n.set||S),Object.defineProperty(t,e,un)}function mn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),ct.target&&e.depend(),e.value}}function yn(t){return function(){return t.call(this,this)}}function gn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let vn=0;function $n(t){let e=t.options;if(t.super){const n=$n(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&A(t.extendOptions,o),e=t.options=Dt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function _n(t){this._init(t)}function bn(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=Dt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)fn(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)hn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,M.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=A({},i.options),r[o]=i,i}}function wn(t){return t&&(t.Ctor.options.name||t.tag)}function Cn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function xn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&kn(n,t,o,r)}}}function kn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,m(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=vn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Dt($n(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Ke(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ce(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Le(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Le(e,t,n,o,r,!0);const s=o&&o.data;Ct(e,"$attrs",s&&s.attrs||t,null,!0),Ct(e,"$listeners",n._parentListeners||t,null,!0)}(n),Xe(n,"beforeCreate"),function(t){const e=ae(t.$options.inject,t);e&&(_t(!1),Object.keys(e).forEach((n=>{Ct(t,n,e[n])})),_t(!0))}(n),dn(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Xe(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(_n),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=xt,t.prototype.$delete=kt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return gn(o,t,e,n);(n=n||{}).user=!0;const r=new ln(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;ut(),Bt(e,o,[r.value],o,t),ft()}return function(){r.teardown()}}}(_n),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?k(n):n;const o=k(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Bt(n[t],e,o,e,r)}return e}}(_n),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=qe(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Xe(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||m(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Xe(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(_n),function(t){Se(t.prototype),t.prototype.$nextTick=function(t){return Gt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=fe(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Re=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Ht(e,t,"render"),o=t._vnode}finally{Re=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof dt||(o=pt()),o.parent=n,o}}(_n);const An=[String,RegExp,Array];var On={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:An,exclude:An,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:wn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&kn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)kn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{xn(this,(e=>Cn(t,e)))})),this.$watch("exclude",(t=>{xn(this,(e=>!Cn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=Be(t),n=e&&e.componentOptions;if(n){const t=wn(n),{include:o,exclude:r}=this;if(o&&(!t||!Cn(o,t))||r&&t&&Cn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,m(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>F};Object.defineProperty(t,"config",e),t.util={warn:it,extend:A,mergeOptions:Dt,defineReactive:Ct},t.set=xt,t.delete=kt,t.nextTick=Gt,t.observable=t=>(wt(t),t),t.options=Object.create(null),M.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,A(t.options.components,On),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=k(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Dt(this.options,t),this}}(t),bn(t),function(t){M.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(_n),Object.defineProperty(_n.prototype,"$isServer",{get:et}),Object.defineProperty(_n.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(_n,"FunctionalRenderContext",{value:Te}),_n.version="2.6.14";const Sn=d("style,class"),Tn=d("input,textarea,option,select,progress"),Nn=(t,e,n)=>"value"===n&&Tn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,En=d("contenteditable,draggable,spellcheck"),jn=d("events,caret,typing,plaintext-only"),Dn=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",Mn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Ln=t=>Mn(t)?t.slice(6,t.length):"",Fn=t=>null==t||!1===t;function Pn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Rn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Rn(e,o.data));return function(t,e){if(n(t)||n(e))return Hn(t,Bn(e));return""}(e.staticClass,e.class)}function Rn(t,e){return{staticClass:Hn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Hn(t,e){return t?e?t+" "+e:t:e||""}function Bn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Bn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Un={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),zn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Kn=t=>Vn(t)||zn(t);function Jn(t){return zn(t)?"svg":"math"===t?"math":void 0}const qn=Object.create(null);const Wn=d("text,number,password,search,email,tel,url");function Gn(t){if("string"==typeof t){const e=document.querySelector(t);return e||document.createElement("div")}return t}var Zn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Un[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Xn={create(t,e){Yn(e)},update(t,e){t.data.ref!==e.data.ref&&(Yn(t,!0),Yn(e))},destroy(t){Yn(t,!0)}};function Yn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?m(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Qn=new dt("",{},[]),to=["create","activate","update","remove","destroy"];function eo(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Wn(r)&&Wn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function no(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var oo={create:ro,update:ro,destroy:function(t){ro(t,Qn)}};function ro(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Qn,o=e===Qn,r=io(t.data.directives,t.context),s=io(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,co(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(co(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)co(i[n],"inserted",e,t)};n?ne(e,"insert",o):o()}a.length&&ne(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)co(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||co(r[c],"unbind",t,t,o)}(t,e)}const so=Object.create(null);function io(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=so),n[ao(r)]=r,r.def=It(e.$options,"directives",r.name);return n}function ao(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function co(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Ht(o,n.context,`directive ${t.name} ${e} hook`)}}var lo=[Xn,oo];function uo(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=A({},u)),u)i=u[s],a=l[s],a!==i&&fo(c,s,i,o.data.pre);for(s in(q||G)&&u.value!==l.value&&fo(c,"value",u.value),l)e(u[s])&&(Mn(s)?c.removeAttributeNS(In,Ln(s)):En(s)||c.removeAttribute(s))}function fo(t,e,n,o){o||t.tagName.indexOf("-")>-1?po(t,e,n):Dn(e)?Fn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):En(e)?t.setAttribute(e,((t,e)=>Fn(e)||"false"===e?"false":"contenteditable"===t&&jn(e)?e:"true")(e,n)):Mn(e)?Fn(n)?t.removeAttributeNS(In,Ln(e)):t.setAttributeNS(In,e,n):po(t,e,n)}function po(t,e,n){if(Fn(n))t.removeAttribute(e);else{if(q&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var ho={create:uo,update:uo};function mo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Pn(o);const c=r._transitionClasses;n(c)&&(a=Hn(a,Bn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var yo={create:mo,update:mo};const go=/[\w).+\-_$\]]/;function vo(t){let e,n,o,r,s,i=!1,a=!1,c=!1,l=!1,u=0,f=0,d=0,p=0;for(o=0;o<t.length;o++)if(n=e,e=t.charCodeAt(o),i)39===e&&92!==n&&(i=!1);else if(a)34===e&&92!==n&&(a=!1);else if(c)96===e&&92!==n&&(c=!1);else if(l)47===e&&92!==n&&(l=!1);else if(124!==e||124===t.charCodeAt(o+1)||124===t.charCodeAt(o-1)||u||f||d){switch(e){case 34:a=!0;break;case 39:i=!0;break;case 96:c=!0;break;case 40:d++;break;case 41:d--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===e){let e,n=o-1;for(;n>=0&&(e=t.charAt(n)," "===e);n--);e&&go.test(e)||(l=!0)}}else void 0===r?(p=o+1,r=t.slice(0,o).trim()):h();function h(){(s||(s=[])).push(t.slice(p,o).trim()),p=o+1}if(void 0===r?r=t.slice(0,o).trim():0!==p&&h(),s)for(o=0;o<s.length;o++)r=$o(r,s[o]);return r}function $o(t,e){const n=e.indexOf("(");if(n<0)return`_f("${e}")(${t})`;{const o=e.slice(0,n),r=e.slice(n+1);return`_f("${o}")(${t}${")"!==r?","+r:r}`}}function _o(t,e){console.error(`[Vue compiler]: ${t}`)}function bo(t,e){return t?t.map((t=>t[e])).filter((t=>t)):[]}function wo(t,e,n,o,r){(t.props||(t.props=[])).push(Eo({name:e,value:n,dynamic:r},o)),t.plain=!1}function Co(t,e,n,o,r){(r?t.dynamicAttrs||(t.dynamicAttrs=[]):t.attrs||(t.attrs=[])).push(Eo({name:e,value:n,dynamic:r},o)),t.plain=!1}function xo(t,e,n,o){t.attrsMap[e]=n,t.attrsList.push(Eo({name:e,value:n},o))}function ko(t,e,n,o,r,s,i,a){(t.directives||(t.directives=[])).push(Eo({name:e,rawName:n,value:o,arg:r,isDynamicArg:s,modifiers:i},a)),t.plain=!1}function Ao(t,e,n){return n?`_p(${e},"${t}")`:t+e}function Oo(e,n,o,r,s,i,a,c){let l;(r=r||t).right?c?n=`(${n})==='click'?'contextmenu':(${n})`:"click"===n&&(n="contextmenu",delete r.right):r.middle&&(c?n=`(${n})==='click'?'mouseup':(${n})`:"click"===n&&(n="mouseup")),r.capture&&(delete r.capture,n=Ao("!",n,c)),r.once&&(delete r.once,n=Ao("~",n,c)),r.passive&&(delete r.passive,n=Ao("&",n,c)),r.native?(delete r.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=Eo({value:o.trim(),dynamic:c},a);r!==t&&(u.modifiers=r);const f=l[n];Array.isArray(f)?s?f.unshift(u):f.push(u):l[n]=f?s?[u,f]:[f,u]:u,e.plain=!1}function So(t,e,n){const o=To(t,":"+e)||To(t,"v-bind:"+e);if(null!=o)return vo(o);if(!1!==n){const n=To(t,e);if(null!=n)return JSON.stringify(n)}}function To(t,e,n){let o;if(null!=(o=t.attrsMap[e])){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++)if(n[t].name===e){n.splice(t,1);break}}return n&&delete t.attrsMap[e],o}function No(t,e){const n=t.attrsList;for(let t=0,o=n.length;t<o;t++){const o=n[t];if(e.test(o.name))return n.splice(t,1),o}}function Eo(t,e){return e&&(null!=e.start&&(t.start=e.start),null!=e.end&&(t.end=e.end)),t}function jo(t,e,n){const{number:o,trim:r}=n||{},s="$$v";let i=s;r&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),o&&(i=`_n(${i})`);const a=Do(e,i);t.model={value:`(${e})`,expression:JSON.stringify(e),callback:`function ($$v) {${a}}`}}function Do(t,e){const n=function(t){if(t=t.trim(),Io=t.length,t.indexOf("[")<0||t.lastIndexOf("]")<Io-1)return Fo=t.lastIndexOf("."),Fo>-1?{exp:t.slice(0,Fo),key:'"'+t.slice(Fo+1)+'"'}:{exp:t,key:null};Mo=t,Fo=Po=Ro=0;for(;!Bo();)Lo=Ho(),Uo(Lo)?zo(Lo):91===Lo&&Vo(Lo);return{exp:t.slice(0,Po),key:t.slice(Po+1,Ro)}}(t);return null===n.key?`${t}=${e}`:`$set(${n.exp}, ${n.key}, ${e})`}let Io,Mo,Lo,Fo,Po,Ro;function Ho(){return Mo.charCodeAt(++Fo)}function Bo(){return Fo>=Io}function Uo(t){return 34===t||39===t}function Vo(t){let e=1;for(Po=Fo;!Bo();)if(Uo(t=Ho()))zo(t);else if(91===t&&e++,93===t&&e--,0===e){Ro=Fo;break}}function zo(t){const e=t;for(;!Bo()&&(t=Ho())!==e;);}const Ko="__r";let Jo;function qo(t,e,n){const o=Jo;return function r(){const s=e.apply(null,arguments);null!==s&&Zo(t,r,n,o)}}const Wo=zt&&!(X&&Number(X[1])<=53);function Go(t,e,n,o){if(Wo){const t=rn,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}Jo.addEventListener(t,e,tt?{capture:n,passive:o}:n)}function Zo(t,e,n,o){(o||Jo).removeEventListener(t,e._wrapper||e,n)}function Xo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};Jo=o.elm||t.elm,function(t){if(n(t.__r)){const e=q?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),ee(r,s,Go,Zo,qo,o.context),Jo=void 0}var Yo={create:Xo,update:Xo,destroy:t=>Xo(t,Qn)};let Qo;function tr(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=A({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);er(i,t)&&(i.value=t)}else if("innerHTML"===r&&zn(i.tagName)&&e(i.innerHTML)){Qo=Qo||document.createElement("div"),Qo.innerHTML=`<svg>${s}</svg>`;const t=Qo.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function er(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var nr={create:tr,update:tr};const or=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function rr(t){const e=sr(t.style);return t.staticStyle?A(t.staticStyle,e):e}function sr(t){return Array.isArray(t)?O(t):"string"==typeof t?or(t):t}const ir=/^--/,ar=/\s*!important$/,cr=(t,e,n)=>{if(ir.test(e))t.style.setProperty(e,n);else if(ar.test(n))t.style.setProperty(C(e),n.replace(ar,""),"important");else{const o=fr(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},lr=["Webkit","Moz","ms"];let ur;const fr=v((function(t){if(ur=ur||document.createElement("div").style,"filter"!==(t=_(t))&&t in ur)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<lr.length;t++){const n=lr[t]+e;if(n in ur)return n}}));function dr(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=sr(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?A({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=rr(e.data))&&A(n,o)}(o=rr(t.data))&&A(n,o);let r=t;for(;r=r.parent;)r.data&&(o=rr(r.data))&&A(n,o);return n}(o,!0);for(a in f)e(p[a])&&cr(c,a,"");for(a in p)i=p[a],i!==f[a]&&cr(c,a,null==i?"":i)}var pr={create:dr,update:dr};const hr=/\s+/;function mr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(hr).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function yr(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(hr).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function gr(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&A(e,vr(t.name||"v")),A(e,t),e}return"string"==typeof t?vr(t):void 0}}const vr=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),$r=V&&!W,_r="transition",br="animation";let wr="transition",Cr="transitionend",xr="animation",kr="animationend";$r&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(wr="WebkitTransition",Cr="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(xr="WebkitAnimation",kr="webkitAnimationEnd"));const Ar=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Or(t){Ar((()=>{Ar(t)}))}function Sr(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),mr(t,e))}function Tr(t,e){t._transitionClasses&&m(t._transitionClasses,e),yr(t,e)}function Nr(t,e,n){const{type:o,timeout:r,propCount:s}=jr(t,e);if(!o)return n();const i=o===_r?Cr:kr;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Er=/\b(transform|all)(,|$)/;function jr(t,e){const n=window.getComputedStyle(t),o=(n[wr+"Delay"]||"").split(", "),r=(n[wr+"Duration"]||"").split(", "),s=Dr(o,r),i=(n[xr+"Delay"]||"").split(", "),a=(n[xr+"Duration"]||"").split(", "),c=Dr(i,a);let l,u=0,f=0;e===_r?s>0&&(l=_r,u=s,f=r.length):e===br?c>0&&(l=br,u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?_r:br:null,f=l?l===_r?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:l===_r&&Er.test(n[wr+"Property"])}}function Dr(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Ir(e)+Ir(t[n]))))}function Ir(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Mr(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=gr(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:g,afterEnter:v,enterCancelled:$,beforeAppear:_,appear:b,afterAppear:w,appearCancelled:C,duration:x}=i;let k=Je,A=Je.$vnode;for(;A&&A.parent;)k=A.context,A=A.parent;const O=!k._isMounted||!t.isRootInsert;if(O&&!b&&""!==b)return;const S=O&&p?p:l,T=O&&m?m:d,N=O&&h?h:u,E=O&&_||y,j=O&&"function"==typeof b?b:g,I=O&&w||v,M=O&&C||$,L=f(s(x)?x.enter:x),F=!1!==a&&!W,P=Pr(j),R=r._enterCb=D((()=>{F&&(Tr(r,N),Tr(r,T)),R.cancelled?(F&&Tr(r,S),M&&M(r)):I&&I(r),r._enterCb=null}));t.data.show||ne(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),j&&j(r,R)})),E&&E(r),F&&(Sr(r,S),Sr(r,T),Or((()=>{Tr(r,S),R.cancelled||(Sr(r,N),P||(Fr(L)?setTimeout(R,L):Nr(r,c,R)))}))),t.data.show&&(o&&o(),j&&j(r,R)),F||P||R()}function Lr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=gr(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:g,duration:v}=i,$=!1!==a&&!W,_=Pr(h),b=f(s(v)?v.leave:v),w=r._leaveCb=D((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),$&&(Tr(r,u),Tr(r,d)),w.cancelled?($&&Tr(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function C(){w.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),$&&(Sr(r,l),Sr(r,d),Or((()=>{Tr(r,l),w.cancelled||(Sr(r,u),_||(Fr(b)?setTimeout(w,b):Nr(r,c,w)))}))),h&&h(r,w),$||_||w())}g?g(C):C()}function Fr(t){return"number"==typeof t&&!isNaN(t)}function Pr(t){if(e(t))return!1;const o=t.fns;return n(o)?Pr(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function Rr(t,e){!0!==e.data.show&&Mr(e)}const Hr=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<to.length;++s)for(a[to[s]]=[],i=0;i<c.length;++i)n(c[i][to[s]])&&a[to[s]].push(c[i][to[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=mt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Qn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),v(t),m(t,d,e),n(f)&&g(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(g(t,e),v(t)):(Yn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function g(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Qn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Qn,t),n(s.insert)&&e.push(t))}function v(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Je)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function $(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function _(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)_(t.children[o])}function b(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(w(o),_(o)):u(o.elm))}}function w(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&w(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function C(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&eo(t,o))return s}}function x(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=mt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,g=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(g)?m!==g&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],g=o[m],v=r.length-1,_=r[0],w=r[v];const k=!i;for(;p<=m&&h<=v;)e(y)?y=o[++p]:e(g)?g=o[--m]:eo(y,_)?(x(y,_,s,r,h),y=o[++p],_=r[++h]):eo(g,w)?(x(g,w,s,r,v),g=o[--m],w=r[--v]):eo(y,w)?(x(y,w,s,r,v),k&&l.insertBefore(t,y.elm,l.nextSibling(g.elm)),y=o[++p],w=r[--v]):eo(g,_)?(x(g,_,s,r,h),k&&l.insertBefore(t,g.elm,y.elm),g=o[--m],_=r[++h]):(e(a)&&(a=no(o,p,m)),c=n(_.key)?a[_.key]:C(_,o,p,m),e(c)?f(_,s,t,y.elm,!1,r,h):(u=o[c],eo(u,_)?(x(u,_,s,r,h),o[c]=void 0,k&&l.insertBefore(t,u.elm,y.elm)):f(_,s,t,y.elm,!1,r,h)),_=r[++h]);p>m?(d=e(r[v+1])?null:r[v+1].elm,$(t,d,r,h,v,s)):h>v&&b(o,p,m)}(d,m,g,s,u):n(g)?(n(t.text)&&l.setTextContent(d,""),$(d,null,g,0,g.length-1,s)):n(m)?b(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function k(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const A=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!A(n)){t=!0,g(e,r);break}!t&&c.class&&Xt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&_(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&eo(t,r))x(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute(I)&&(t.removeAttribute(I),s=!0),o(s)&&O(t,r,u))return k(r,u,!0),t;d=t,t=new dt(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Qn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Yn(t);t=t.parent}}n(c)?b([t],0,0):n(t.tag)&&_(t)}}var d;return k(r,u,c),r.elm}}({nodeOps:Zn,modules:[ho,yo,Yo,nr,pr,V?{create:Rr,activate:Rr,remove(t,e){!0!==t.data.show?Lr(t,e):e()}}:{}].concat(lo)});W&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&Wr(t,"input")}));const Br={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?ne(n,"postpatch",(()=>{Br.componentUpdated(t,e,n)})):Ur(t,e,n.context),t._vOptions=[].map.call(t.options,Kr)):("textarea"===n.tag||Wn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",Jr),t.addEventListener("compositionend",qr),t.addEventListener("change",qr),W&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){Ur(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,Kr);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>zr(t,r))):e.value!==e.oldValue&&zr(e.value,r))&&Wr(t,"change")}}}};function Ur(t,e,n){Vr(t,e),(q||G)&&setTimeout((()=>{Vr(t,e)}),0)}function Vr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=j(o,Kr(i))>-1,i.selected!==s&&(i.selected=s);else if(E(Kr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function zr(t,e){return e.every((e=>!E(e,t)))}function Kr(t){return"_value"in t?t._value:t.value}function Jr(t){t.target.composing=!0}function qr(t){t.target.composing&&(t.target.composing=!1,Wr(t.target,"input"))}function Wr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function Gr(t){return!t.componentInstance||t.data&&t.data.transition?t:Gr(t.componentInstance._vnode)}var Zr={bind(t,{value:e},n){const o=(n=Gr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Mr(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=Gr(o)).data&&o.data.transition?(o.data.show=!0,e?Mr(o,(()=>{t.style.display=t.__vOriginalDisplay})):Lr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},Xr={model:Br,show:Zr};const Yr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function Qr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?Qr(Be(e.children)):t}function ts(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function es(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const ns=t=>t.tag||ue(t),os=t=>"show"===t.name;var rs={name:"transition",props:Yr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(ns),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=Qr(o);if(!s)return o;if(this._leaving)return es(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=ts(this),c=this._vnode,l=Qr(c);if(s.data.directives&&s.data.directives.some(os)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!ue(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=A({},a);if("out-in"===n)return this._leaving=!0,ne(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),es(t,o);if("in-out"===n){if(ue(s))return c;let t;const n=()=>{t()};ne(a,"afterEnter",n),ne(a,"enterCancelled",n),ne(e,"delayLeave",(e=>{t=e}))}}return o}};const ss=A({tag:String,moveClass:String},Yr);function is(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function as(t){t.data.newPos=t.elm.getBoundingClientRect()}function cs(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete ss.mode;var ls={Transition:rs,TransitionGroup:{props:ss,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=qe(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=ts(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(is),t.forEach(as),t.forEach(cs),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Sr(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(Cr,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(Cr,t),n._moveCb=null,Tr(n,e))})}})))},methods:{hasMove(t,e){if(!$r)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{yr(n,t)})),mr(n,e),n.style.display="none",this.$el.appendChild(n);const o=jr(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};_n.config.mustUseProp=Nn,_n.config.isReservedTag=Kn,_n.config.isReservedAttr=Sn,_n.config.getTagNamespace=Jn,_n.config.isUnknownElement=function(t){if(!V)return!0;if(Kn(t))return!1;if(t=t.toLowerCase(),null!=qn[t])return qn[t];const e=document.createElement(t);return t.indexOf("-")>-1?qn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:qn[t]=/HTMLUnknownElement/.test(e.toString())},A(_n.options.directives,Xr),A(_n.options.components,ls),_n.prototype.__patch__=V?Hr:S,_n.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=pt),Xe(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new ln(t,o,S,{before(){t._isMounted&&!t._isDestroyed&&Xe(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Xe(t,"mounted")),t}(this,t=t&&V?Gn(t):void 0,e)},V&&setTimeout((()=>{F.devtools&&nt&&nt.emit("init",_n)}),0);const us=/\{\{((?:.|\r?\n)+?)\}\}/g,fs=/[-.*+?^${}()|[\]\/\\]/g,ds=v((t=>{const e=t[0].replace(fs,"\\$&"),n=t[1].replace(fs,"\\$&");return new RegExp(e+"((?:.|\\n)+?)"+n,"g")}));var ps={staticKeys:["staticClass"],transformNode:function(t,e){e.warn;const n=To(t,"class");n&&(t.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const o=So(t,"class",!1);o&&(t.classBinding=o)},genData:function(t){let e="";return t.staticClass&&(e+=`staticClass:${t.staticClass},`),t.classBinding&&(e+=`class:${t.classBinding},`),e}};var hs={staticKeys:["staticStyle"],transformNode:function(t,e){e.warn;const n=To(t,"style");n&&(t.staticStyle=JSON.stringify(or(n)));const o=So(t,"style",!1);o&&(t.styleBinding=o)},genData:function(t){let e="";return t.staticStyle&&(e+=`staticStyle:${t.staticStyle},`),t.styleBinding&&(e+=`style:(${t.styleBinding}),`),e}};let ms;var ys={decode:t=>(ms=ms||document.createElement("div"),ms.innerHTML=t,ms.textContent)};const gs=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),vs=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),$s=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),_s=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,bs=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,ws=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${P.source}]*`,Cs=`((?:${ws}\\:)?${ws})`,xs=new RegExp(`^<${Cs}`),ks=/^\s*(\/?)>/,As=new RegExp(`^<\\/${Cs}[^>]*>`),Os=/^<!DOCTYPE [^>]+>/i,Ss=/^<!\--/,Ts=/^<!\[/,Ns=d("script,style,textarea",!0),Es={},js={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ds=/&(?:lt|gt|quot|amp|#39);/g,Is=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Ms=d("pre,textarea",!0),Ls=(t,e)=>t&&Ms(t)&&"\n"===e[0];function Fs(t,e){const n=e?Is:Ds;return t.replace(n,(t=>js[t]))}const Ps=/^@|^v-on:/,Rs=/^v-|^@|^:|^#/,Hs=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,Bs=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,Us=/^\(|\)$/g,Vs=/^\[.*\]$/,zs=/:(.*)$/,Ks=/^:|^\.|^v-bind:/,Js=/\.[^.\]]+(?=[^\]]*$)/g,qs=/^v-slot(:|$)|^#/,Ws=/[\r\n]/,Gs=/[ \f\t\r\n]+/g,Zs=v(ys.decode),Xs="_empty_";let Ys,Qs,ti,ei,ni,oi,ri,si;function ii(t,e,n){return{type:1,tag:t,attrsList:e,attrsMap:pi(e),rawAttrsMap:{},parent:n,children:[]}}function ai(t,e){Ys=e.warn||_o,oi=e.isPreTag||T,ri=e.mustUseProp||T,si=e.getTagNamespace||T,e.isReservedTag,ti=bo(e.modules,"transformNode"),ei=bo(e.modules,"preTransformNode"),ni=bo(e.modules,"postTransformNode"),Qs=e.delimiters;const n=[],o=!1!==e.preserveWhitespace,r=e.whitespace;let s,i,a=!1,c=!1;function l(t){if(u(t),a||t.processed||(t=ci(t,e)),n.length||t===s||s.if&&(t.elseif||t.else)&&ui(s,{exp:t.elseif,block:t}),i&&!t.forbidden)if(t.elseif||t.else)!function(t,e){const n=function(t){let e=t.length;for(;e--;){if(1===t[e].type)return t[e];t.pop()}}(e.children);n&&n.if&&ui(n,{exp:t.elseif,block:t})}(t,i);else{if(t.slotScope){const e=t.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[e]=t}i.children.push(t),t.parent=i}t.children=t.children.filter((t=>!t.slotScope)),u(t),t.pre&&(a=!1),oi(t.tag)&&(c=!1);for(let n=0;n<ni.length;n++)ni[n](t,e)}function u(t){if(!c){let e;for(;(e=t.children[t.children.length-1])&&3===e.type&&" "===e.text;)t.children.pop()}}return function(t,e){const n=[],o=e.expectHTML,r=e.isUnaryTag||T,s=e.canBeLeftOpenTag||T;let i,a,c=0;for(;t;){if(i=t,a&&Ns(a)){let n=0;const o=a.toLowerCase(),r=Es[o]||(Es[o]=new RegExp("([\\s\\S]*?)(</"+o+"[^>]*>)","i")),s=t.replace(r,(function(t,r,s){return n=s.length,Ns(o)||"noscript"===o||(r=r.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Ls(o,r)&&(r=r.slice(1)),e.chars&&e.chars(r),""}));c+=t.length-s.length,t=s,d(o,c-n,c)}else{let n,o,r,s=t.indexOf("<");if(0===s){if(Ss.test(t)){const n=t.indexOf("--\x3e");if(n>=0){e.shouldKeepComment&&e.comment(t.substring(4,n),c,c+n+3),l(n+3);continue}}if(Ts.test(t)){const e=t.indexOf("]>");if(e>=0){l(e+2);continue}}const n=t.match(Os);if(n){l(n[0].length);continue}const o=t.match(As);if(o){const t=c;l(o[0].length),d(o[1],t,c);continue}const r=u();if(r){f(r),Ls(r.tagName,t)&&l(1);continue}}if(s>=0){for(o=t.slice(s);!(As.test(o)||xs.test(o)||Ss.test(o)||Ts.test(o)||(r=o.indexOf("<",1),r<0));)s+=r,o=t.slice(s);n=t.substring(0,s)}s<0&&(n=t),n&&l(n.length),e.chars&&n&&e.chars(n,c-n.length,c)}if(t===i){e.chars&&e.chars(t);break}}function l(e){c+=e,t=t.substring(e)}function u(){const e=t.match(xs);if(e){const n={tagName:e[1],attrs:[],start:c};let o,r;for(l(e[0].length);!(o=t.match(ks))&&(r=t.match(bs)||t.match(_s));)r.start=c,l(r[0].length),r.end=c,n.attrs.push(r);if(o)return n.unarySlash=o[1],l(o[0].length),n.end=c,n}}function f(t){const i=t.tagName,c=t.unarySlash;o&&("p"===a&&$s(i)&&d(a),s(i)&&a===i&&d(i));const l=r(i)||!!c,u=t.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const o=t.attrs[n],r=o[3]||o[4]||o[5]||"",s="a"===i&&"href"===o[1]?e.shouldDecodeNewlinesForHref:e.shouldDecodeNewlines;f[n]={name:o[1],value:Fs(r,s)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:t.start,end:t.end}),a=i),e.start&&e.start(i,f,l,t.start,t.end)}function d(t,o,r){let s,i;if(null==o&&(o=c),null==r&&(r=c),t)for(i=t.toLowerCase(),s=n.length-1;s>=0&&n[s].lowerCasedTag!==i;s--);else s=0;if(s>=0){for(let t=n.length-1;t>=s;t--)e.end&&e.end(n[t].tag,o,r);n.length=s,a=s&&n[s-1].tag}else"br"===i?e.start&&e.start(t,[],!0,o,r):"p"===i&&(e.start&&e.start(t,[],!1,o,r),e.end&&e.end(t,o,r))}d()}(t,{warn:Ys,expectHTML:e.expectHTML,isUnaryTag:e.isUnaryTag,canBeLeftOpenTag:e.canBeLeftOpenTag,shouldDecodeNewlines:e.shouldDecodeNewlines,shouldDecodeNewlinesForHref:e.shouldDecodeNewlinesForHref,shouldKeepComment:e.comments,outputSourceRange:e.outputSourceRange,start(t,o,r,u,f){const d=i&&i.ns||si(t);q&&"svg"===d&&(o=function(t){const e=[];for(let n=0;n<t.length;n++){const o=t[n];hi.test(o.name)||(o.name=o.name.replace(mi,""),e.push(o))}return e}(o));let p=ii(t,o,i);var h;d&&(p.ns=d),"style"!==(h=p).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||et()||(p.forbidden=!0);for(let t=0;t<ei.length;t++)p=ei[t](p,e)||p;a||(!function(t){null!=To(t,"v-pre")&&(t.pre=!0)}(p),p.pre&&(a=!0)),oi(p.tag)&&(c=!0),a?function(t){const e=t.attrsList,n=e.length;if(n){const o=t.attrs=new Array(n);for(let t=0;t<n;t++)o[t]={name:e[t].name,value:JSON.stringify(e[t].value)},null!=e[t].start&&(o[t].start=e[t].start,o[t].end=e[t].end)}else t.pre||(t.plain=!0)}(p):p.processed||(li(p),function(t){const e=To(t,"v-if");if(e)t.if=e,ui(t,{exp:e,block:t});else{null!=To(t,"v-else")&&(t.else=!0);const e=To(t,"v-else-if");e&&(t.elseif=e)}}(p),function(t){null!=To(t,"v-once")&&(t.once=!0)}(p)),s||(s=p),r?l(p):(i=p,n.push(p))},end(t,e,o){const r=n[n.length-1];n.length-=1,i=n[n.length-1],l(r)},chars(t,e,n){if(!i)return;if(q&&"textarea"===i.tag&&i.attrsMap.placeholder===t)return;const s=i.children;var l;if(t=c||t.trim()?"script"===(l=i).tag||"style"===l.tag?t:Zs(t):s.length?r?"condense"===r&&Ws.test(t)?"":" ":o?" ":"":""){let e,n;c||"condense"!==r||(t=t.replace(Gs," ")),!a&&" "!==t&&(e=function(t,e){const n=e?ds(e):us;if(!n.test(t))return;const o=[],r=[];let s,i,a,c=n.lastIndex=0;for(;s=n.exec(t);){i=s.index,i>c&&(r.push(a=t.slice(c,i)),o.push(JSON.stringify(a)));const e=vo(s[1].trim());o.push(`_s(${e})`),r.push({"@binding":e}),c=i+s[0].length}return c<t.length&&(r.push(a=t.slice(c)),o.push(JSON.stringify(a))),{expression:o.join("+"),tokens:r}}(t,Qs))?n={type:2,expression:e.expression,tokens:e.tokens,text:t}:" "===t&&s.length&&" "===s[s.length-1].text||(n={type:3,text:t}),n&&s.push(n)}},comment(t,e,n){if(i){const e={type:3,text:t,isComment:!0};i.children.push(e)}}}),s}function ci(t,e){var n;!function(t){const e=So(t,"key");e&&(t.key=e)}(t),t.plain=!t.key&&!t.scopedSlots&&!t.attrsList.length,function(t){const e=So(t,"ref");e&&(t.ref=e,t.refInFor=function(t){let e=t;for(;e;){if(void 0!==e.for)return!0;e=e.parent}return!1}(t))}(t),function(t){let e;"template"===t.tag?(e=To(t,"scope"),t.slotScope=e||To(t,"slot-scope")):(e=To(t,"slot-scope"))&&(t.slotScope=e);const n=So(t,"slot");n&&(t.slotTarget='""'===n?'"default"':n,t.slotTargetDynamic=!(!t.attrsMap[":slot"]&&!t.attrsMap["v-bind:slot"]),"template"===t.tag||t.slotScope||Co(t,"slot",n,function(t,e){return t.rawAttrsMap[":"+e]||t.rawAttrsMap["v-bind:"+e]||t.rawAttrsMap[e]}(t,"slot")));if("template"===t.tag){const e=No(t,qs);if(e){const{name:n,dynamic:o}=fi(e);t.slotTarget=n,t.slotTargetDynamic=o,t.slotScope=e.value||Xs}}else{const e=No(t,qs);if(e){const n=t.scopedSlots||(t.scopedSlots={}),{name:o,dynamic:r}=fi(e),s=n[o]=ii("template",[],t);s.slotTarget=o,s.slotTargetDynamic=r,s.children=t.children.filter((t=>{if(!t.slotScope)return t.parent=s,!0})),s.slotScope=e.value||Xs,t.children=[],t.plain=!1}}}(t),"slot"===(n=t).tag&&(n.slotName=So(n,"name")),function(t){let e;(e=So(t,"is"))&&(t.component=e);null!=To(t,"inline-template")&&(t.inlineTemplate=!0)}(t);for(let n=0;n<ti.length;n++)t=ti[n](t,e)||t;return function(t){const e=t.attrsList;let n,o,r,s,i,a,c,l;for(n=0,o=e.length;n<o;n++)if(r=s=e[n].name,i=e[n].value,Rs.test(r))if(t.hasBindings=!0,a=di(r.replace(Rs,"")),a&&(r=r.replace(Js,"")),Ks.test(r))r=r.replace(Ks,""),i=vo(i),l=Vs.test(r),l&&(r=r.slice(1,-1)),a&&(a.prop&&!l&&(r=_(r),"innerHtml"===r&&(r="innerHTML")),a.camel&&!l&&(r=_(r)),a.sync&&(c=Do(i,"$event"),l?Oo(t,`"update:"+(${r})`,c,null,!1,0,e[n],!0):(Oo(t,`update:${_(r)}`,c,null,!1,0,e[n]),C(r)!==_(r)&&Oo(t,`update:${C(r)}`,c,null,!1,0,e[n])))),a&&a.prop||!t.component&&ri(t.tag,t.attrsMap.type,r)?wo(t,r,i,e[n],l):Co(t,r,i,e[n],l);else if(Ps.test(r))r=r.replace(Ps,""),l=Vs.test(r),l&&(r=r.slice(1,-1)),Oo(t,r,i,a,!1,0,e[n],l);else{r=r.replace(Rs,"");const o=r.match(zs);let c=o&&o[1];l=!1,c&&(r=r.slice(0,-(c.length+1)),Vs.test(c)&&(c=c.slice(1,-1),l=!0)),ko(t,r,s,i,c,l,a,e[n])}else Co(t,r,JSON.stringify(i),e[n]),!t.component&&"muted"===r&&ri(t.tag,t.attrsMap.type,r)&&wo(t,r,"true",e[n])}(t),t}function li(t){let e;if(e=To(t,"v-for")){const n=function(t){const e=t.match(Hs);if(!e)return;const n={};n.for=e[2].trim();const o=e[1].trim().replace(Us,""),r=o.match(Bs);r?(n.alias=o.replace(Bs,"").trim(),n.iterator1=r[1].trim(),r[2]&&(n.iterator2=r[2].trim())):n.alias=o;return n}(e);n&&A(t,n)}}function ui(t,e){t.ifConditions||(t.ifConditions=[]),t.ifConditions.push(e)}function fi(t){let e=t.name.replace(qs,"");return e||"#"!==t.name[0]&&(e="default"),Vs.test(e)?{name:e.slice(1,-1),dynamic:!0}:{name:`"${e}"`,dynamic:!1}}function di(t){const e=t.match(Js);if(e){const t={};return e.forEach((e=>{t[e.slice(1)]=!0})),t}}function pi(t){const e={};for(let n=0,o=t.length;n<o;n++)e[t[n].name]=t[n].value;return e}const hi=/^xmlns:NS\d+/,mi=/^NS\d+:/;function yi(t){return ii(t.tag,t.attrsList.slice(),t.parent)}var gi=[ps,hs,{preTransformNode:function(t,e){if("input"===t.tag){const n=t.attrsMap;if(!n["v-model"])return;let o;if((n[":type"]||n["v-bind:type"])&&(o=So(t,"type")),n.type||o||!n["v-bind"]||(o=`(${n["v-bind"]}).type`),o){const n=To(t,"v-if",!0),r=n?`&&(${n})`:"",s=null!=To(t,"v-else",!0),i=To(t,"v-else-if",!0),a=yi(t);li(a),xo(a,"type","checkbox"),ci(a,e),a.processed=!0,a.if=`(${o})==='checkbox'`+r,ui(a,{exp:a.if,block:a});const c=yi(t);To(c,"v-for",!0),xo(c,"type","radio"),ci(c,e),ui(a,{exp:`(${o})==='radio'`+r,block:c});const l=yi(t);return To(l,"v-for",!0),xo(l,":type",o),ci(l,e),ui(a,{exp:n,block:l}),s?a.else=!0:i&&(a.elseif=i),a}}}}];const vi={expectHTML:!0,modules:gi,directives:{model:function(t,e,n){const o=e.value,r=e.modifiers,s=t.tag,i=t.attrsMap.type;if(t.component)return jo(t,o,r),!1;if("select"===s)!function(t,e,n){const o=n&&n.number;let r=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${o?"_n(val)":"val"}});`;r=`${r} ${Do(e,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,Oo(t,"change",r,null,!0)}(t,o,r);else if("input"===s&&"checkbox"===i)!function(t,e,n){const o=n&&n.number,r=So(t,"value")||"null",s=So(t,"true-value")||"true",i=So(t,"false-value")||"false";wo(t,"checked",`Array.isArray(${e})?_i(${e},${r})>-1`+("true"===s?`:(${e})`:`:_q(${e},${s})`)),Oo(t,"change",`var $$a=${e},$$el=$event.target,$$c=$$el.checked?(${s}):(${i});if(Array.isArray($$a)){var $$v=${o?"_n("+r+")":r},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${Do(e,"$$a.concat([$$v])")})}else{$$i>-1&&(${Do(e,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${Do(e,"$$c")}}`,null,!0)}(t,o,r);else if("input"===s&&"radio"===i)!function(t,e,n){const o=n&&n.number;let r=So(t,"value")||"null";r=o?`_n(${r})`:r,wo(t,"checked",`_q(${e},${r})`),Oo(t,"change",Do(e,r),null,!0)}(t,o,r);else if("input"===s||"textarea"===s)!function(t,e,n){const o=t.attrsMap.type,{lazy:r,number:s,trim:i}=n||{},a=!r&&"range"!==o,c=r?"change":"range"===o?Ko:"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");s&&(l=`_n(${l})`);let u=Do(e,l);a&&(u=`if($event.target.composing)return;${u}`);wo(t,"value",`(${e})`),Oo(t,c,u,null,!0),(i||s)&&Oo(t,"blur","$forceUpdate()")}(t,o,r);else if(!F.isReservedTag(s))return jo(t,o,r),!1;return!0},text:function(t,e){e.value&&wo(t,"textContent",`_s(${e.value})`,e)},html:function(t,e){e.value&&wo(t,"innerHTML",`_s(${e.value})`,e)}},isPreTag:t=>"pre"===t,isUnaryTag:gs,mustUseProp:Nn,canBeLeftOpenTag:vs,isReservedTag:Kn,getTagNamespace:Jn,staticKeys:function(t){return t.reduce(((t,e)=>t.concat(e.staticKeys||[])),[]).join(",")}(gi)};let $i,_i;const bi=v((function(t){return d("type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap"+(t?","+t:""))}));function wi(t,e){t&&($i=bi(e.staticKeys||""),_i=e.isReservedTag||T,Ci(t),xi(t,!1))}function Ci(t){if(t.static=function(t){if(2===t.type)return!1;if(3===t.type)return!0;return!(!t.pre&&(t.hasBindings||t.if||t.for||p(t.tag)||!_i(t.tag)||function(t){for(;t.parent;){if("template"!==(t=t.parent).tag)return!1;if(t.for)return!0}return!1}(t)||!Object.keys(t).every($i)))}(t),1===t.type){if(!_i(t.tag)&&"slot"!==t.tag&&null==t.attrsMap["inline-template"])return;for(let e=0,n=t.children.length;e<n;e++){const n=t.children[e];Ci(n),n.static||(t.static=!1)}if(t.ifConditions)for(let e=1,n=t.ifConditions.length;e<n;e++){const n=t.ifConditions[e].block;Ci(n),n.static||(t.static=!1)}}}function xi(t,e){if(1===t.type){if((t.static||t.once)&&(t.staticInFor=e),t.static&&t.children.length&&(1!==t.children.length||3!==t.children[0].type))return void(t.staticRoot=!0);if(t.staticRoot=!1,t.children)for(let n=0,o=t.children.length;n<o;n++)xi(t.children[n],e||!!t.for);if(t.ifConditions)for(let n=1,o=t.ifConditions.length;n<o;n++)xi(t.ifConditions[n].block,e)}}const ki=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Ai=/\([^)]*?\);*$/,Oi=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Si={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Ti={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Ni=t=>`if(${t})return null;`,Ei={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Ni("$event.target !== $event.currentTarget"),ctrl:Ni("!$event.ctrlKey"),shift:Ni("!$event.shiftKey"),alt:Ni("!$event.altKey"),meta:Ni("!$event.metaKey"),left:Ni("'button' in $event && $event.button !== 0"),middle:Ni("'button' in $event && $event.button !== 1"),right:Ni("'button' in $event && $event.button !== 2")};function ji(t,e){const n=e?"nativeOn:":"on:";let o="",r="";for(const e in t){const n=Di(t[e]);t[e]&&t[e].dynamic?r+=`${e},${n},`:o+=`"${e}":${n},`}return o=`{${o.slice(0,-1)}}`,r?n+`_d(${o},[${r.slice(0,-1)}])`:n+o}function Di(t){if(!t)return"function(){}";if(Array.isArray(t))return`[${t.map((t=>Di(t))).join(",")}]`;const e=Oi.test(t.value),n=ki.test(t.value),o=Oi.test(t.value.replace(Ai,""));if(t.modifiers){let r="",s="";const i=[];for(const e in t.modifiers)if(Ei[e])s+=Ei[e],Si[e]&&i.push(e);else if("exact"===e){const e=t.modifiers;s+=Ni(["ctrl","shift","alt","meta"].filter((t=>!e[t])).map((t=>`$event.${t}Key`)).join("||"))}else i.push(e);i.length&&(r+=function(t){return`if(!$event.type.indexOf('key')&&${t.map(Ii).join("&&")})return null;`}(i)),s&&(r+=s);return`function($event){${r}${e?`return ${t.value}.apply(null, arguments)`:n?`return (${t.value}).apply(null, arguments)`:o?`return ${t.value}`:t.value}}`}return e||n?t.value:`function($event){${o?`return ${t.value}`:t.value}}`}function Ii(t){const e=parseInt(t,10);if(e)return`$event.keyCode!==${e}`;const n=Si[t],o=Ti[t];return`_k($event.keyCode,${JSON.stringify(t)},${JSON.stringify(n)},$event.key,${JSON.stringify(o)})`}var Mi={on:function(t,e){t.wrapListeners=t=>`_g(${t},${e.value})`},bind:function(t,e){t.wrapData=n=>`_b(${n},'${t.tag}',${e.value},${e.modifiers&&e.modifiers.prop?"true":"false"}${e.modifiers&&e.modifiers.sync?",true":""})`},cloak:S};class Li{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(t){this.options=t,this.warn=t.warn||_o,this.transforms=bo(t.modules,"transformCode"),this.dataGenFns=bo(t.modules,"genData"),this.directives=A(A({},Mi),t.directives);const e=t.isReservedTag||T;this.maybeComponent=t=>!!t.component||!e(t.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function Fi(t,e){const n=new Li(e);return{render:`with(this){return ${t?"script"===t.tag?"null":Pi(t,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}function Pi(t,e){if(t.parent&&(t.pre=t.pre||t.parent.pre),t.staticRoot&&!t.staticProcessed)return Ri(t,e);if(t.once&&!t.onceProcessed)return Hi(t,e);if(t.for&&!t.forProcessed)return Vi(t,e);if(t.if&&!t.ifProcessed)return Bi(t,e);if("template"!==t.tag||t.slotTarget||e.pre){if("slot"===t.tag)return function(t,e){const n=t.slotName||'"default"',o=qi(t,e);let r=`_t(${n}${o?`,function(){return ${o}}`:""}`;const s=t.attrs||t.dynamicAttrs?Zi((t.attrs||[]).concat(t.dynamicAttrs||[]).map((t=>({name:_(t.name),value:t.value,dynamic:t.dynamic})))):null,i=t.attrsMap["v-bind"];!s&&!i||o||(r+=",null");s&&(r+=`,${s}`);i&&(r+=`${s?"":",null"},${i}`);return r+")"}(t,e);{let n;if(t.component)n=function(t,e,n){const o=e.inlineTemplate?null:qi(e,n,!0);return`_c(${t},${zi(e,n)}${o?`,${o}`:""})`}(t.component,t,e);else{let o;(!t.plain||t.pre&&e.maybeComponent(t))&&(o=zi(t,e));const r=t.inlineTemplate?null:qi(t,e,!0);n=`_c('${t.tag}'${o?`,${o}`:""}${r?`,${r}`:""})`}for(let o=0;o<e.transforms.length;o++)n=e.transforms[o](t,n);return n}}return qi(t,e)||"void 0"}function Ri(t,e){t.staticProcessed=!0;const n=e.pre;return t.pre&&(e.pre=t.pre),e.staticRenderFns.push(`with(this){return ${Pi(t,e)}}`),e.pre=n,`_m(${e.staticRenderFns.length-1}${t.staticInFor?",true":""})`}function Hi(t,e){if(t.onceProcessed=!0,t.if&&!t.ifProcessed)return Bi(t,e);if(t.staticInFor){let n="",o=t.parent;for(;o;){if(o.for){n=o.key;break}o=o.parent}return n?`_o(${Pi(t,e)},${e.onceId++},${n})`:Pi(t,e)}return Ri(t,e)}function Bi(t,e,n,o){return t.ifProcessed=!0,Ui(t.ifConditions.slice(),e,n,o)}function Ui(t,e,n,o){if(!t.length)return o||"_e()";const r=t.shift();return r.exp?`(${r.exp})?${s(r.block)}:${Ui(t,e,n,o)}`:`${s(r.block)}`;function s(t){return n?n(t,e):t.once?Hi(t,e):Pi(t,e)}}function Vi(t,e,n,o){const r=t.for,s=t.alias,i=t.iterator1?`,${t.iterator1}`:"",a=t.iterator2?`,${t.iterator2}`:"";return t.forProcessed=!0,`${o||"_l"}((${r}),function(${s}${i}${a}){return ${(n||Pi)(t,e)}})`}function zi(t,e){let n="{";const o=function(t,e){const n=t.directives;if(!n)return;let o,r,s,i,a="directives:[",c=!1;for(o=0,r=n.length;o<r;o++){s=n[o],i=!0;const r=e.directives[s.name];r&&(i=!!r(t,s,e.warn)),i&&(c=!0,a+=`{name:"${s.name}",rawName:"${s.rawName}"${s.value?`,value:(${s.value}),expression:${JSON.stringify(s.value)}`:""}${s.arg?`,arg:${s.isDynamicArg?s.arg:`"${s.arg}"`}`:""}${s.modifiers?`,modifiers:${JSON.stringify(s.modifiers)}`:""}},`)}if(c)return a.slice(0,-1)+"]"}(t,e);o&&(n+=o+","),t.key&&(n+=`key:${t.key},`),t.ref&&(n+=`ref:${t.ref},`),t.refInFor&&(n+="refInFor:true,"),t.pre&&(n+="pre:true,"),t.component&&(n+=`tag:"${t.tag}",`);for(let o=0;o<e.dataGenFns.length;o++)n+=e.dataGenFns[o](t);if(t.attrs&&(n+=`attrs:${Zi(t.attrs)},`),t.props&&(n+=`domProps:${Zi(t.props)},`),t.events&&(n+=`${ji(t.events,!1)},`),t.nativeEvents&&(n+=`${ji(t.nativeEvents,!0)},`),t.slotTarget&&!t.slotScope&&(n+=`slot:${t.slotTarget},`),t.scopedSlots&&(n+=`${function(t,e,n){let o=t.for||Object.keys(e).some((t=>{const n=e[t];return n.slotTargetDynamic||n.if||n.for||Ki(n)})),r=!!t.if;if(!o){let e=t.parent;for(;e;){if(e.slotScope&&e.slotScope!==Xs||e.for){o=!0;break}e.if&&(r=!0),e=e.parent}}const s=Object.keys(e).map((t=>Ji(e[t],n))).join(",");return`scopedSlots:_u([${s}]${o?",null,true":""}${!o&&r?`,null,false,${function(t){let e=5381,n=t.length;for(;n;)e=33*e^t.charCodeAt(--n);return e>>>0}(s)}`:""})`}(t,t.scopedSlots,e)},`),t.model&&(n+=`model:{value:${t.model.value},callback:${t.model.callback},expression:${t.model.expression}},`),t.inlineTemplate){const o=function(t,e){const n=t.children[0];if(n&&1===n.type){const t=Fi(n,e.options);return`inlineTemplate:{render:function(){${t.render}},staticRenderFns:[${t.staticRenderFns.map((t=>`function(){${t}}`)).join(",")}]}`}}(t,e);o&&(n+=`${o},`)}return n=n.replace(/,$/,"")+"}",t.dynamicAttrs&&(n=`_b(${n},"${t.tag}",${Zi(t.dynamicAttrs)})`),t.wrapData&&(n=t.wrapData(n)),t.wrapListeners&&(n=t.wrapListeners(n)),n}function Ki(t){return 1===t.type&&("slot"===t.tag||t.children.some(Ki))}function Ji(t,e){const n=t.attrsMap["slot-scope"];if(t.if&&!t.ifProcessed&&!n)return Bi(t,e,Ji,"null");if(t.for&&!t.forProcessed)return Vi(t,e,Ji);const o=t.slotScope===Xs?"":String(t.slotScope),r=`function(${o}){return ${"template"===t.tag?t.if&&n?`(${t.if})?${qi(t,e)||"undefined"}:undefined`:qi(t,e)||"undefined":Pi(t,e)}}`,s=o?"":",proxy:true";return`{key:${t.slotTarget||'"default"'},fn:${r}${s}}`}function qi(t,e,n,o,r){const s=t.children;if(s.length){const t=s[0];if(1===s.length&&t.for&&"template"!==t.tag&&"slot"!==t.tag){const r=n?e.maybeComponent(t)?",1":",0":"";return`${(o||Pi)(t,e)}${r}`}const i=n?function(t,e){let n=0;for(let o=0;o<t.length;o++){const r=t[o];if(1===r.type){if(Wi(r)||r.ifConditions&&r.ifConditions.some((t=>Wi(t.block)))){n=2;break}(e(r)||r.ifConditions&&r.ifConditions.some((t=>e(t.block))))&&(n=1)}}return n}(s,e.maybeComponent):0,a=r||Gi;return`[${s.map((t=>a(t,e))).join(",")}]${i?`,${i}`:""}`}}function Wi(t){return void 0!==t.for||"template"===t.tag||"slot"===t.tag}function Gi(t,e){return 1===t.type?Pi(t,e):3===t.type&&t.isComment?function(t){return`_e(${JSON.stringify(t.text)})`}(t):function(t){return`_v(${2===t.type?t.expression:Xi(JSON.stringify(t.text))})`}(t)}function Zi(t){let e="",n="";for(let o=0;o<t.length;o++){const r=t[o],s=Xi(r.value);r.dynamic?n+=`${r.name},${s},`:e+=`"${r.name}":${s},`}return e=`{${e.slice(0,-1)}}`,n?`_d(${e},[${n.slice(0,-1)}])`:e}function Xi(t){return t.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}function Yi(t,e){try{return new Function(t)}catch(n){return e.push({err:n,code:t}),S}}function Qi(t){const e=Object.create(null);return function(n,o,r){(o=A({},o)).warn,delete o.warn;const s=o.delimiters?String(o.delimiters)+n:n;if(e[s])return e[s];const i=t(n,o),a={},c=[];return a.render=Yi(i.render,c),a.staticRenderFns=i.staticRenderFns.map((t=>Yi(t,c))),e[s]=a}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const ta=(ea=function(t,e){const n=ai(t.trim(),e);!1!==e.optimize&&wi(n,e);const o=Fi(n,e);return{ast:n,render:o.render,staticRenderFns:o.staticRenderFns}},function(t){function e(e,n){const o=Object.create(t),r=[],s=[];if(n){n.modules&&(o.modules=(t.modules||[]).concat(n.modules)),n.directives&&(o.directives=A(Object.create(t.directives||null),n.directives));for(const t in n)"modules"!==t&&"directives"!==t&&(o[t]=n[t])}o.warn=(t,e,n)=>{(n?s:r).push(t)};const i=ea(e.trim(),o);return i.errors=r,i.tips=s,i}return{compile:e,compileToFunctions:Qi(e)}});var ea;const{compile:na,compileToFunctions:oa}=ta(vi);let ra;function sa(t){return ra=ra||document.createElement("div"),ra.innerHTML=t?'<a href="\n"/>':'<div a="\n"/>',ra.innerHTML.indexOf("&#10;")>0}const ia=!!V&&sa(!1),aa=!!V&&sa(!0),ca=v((t=>{const e=Gn(t);return e&&e.innerHTML})),la=_n.prototype.$mount;return _n.prototype.$mount=function(t,e){if((t=t&&Gn(t))===document.body||t===document.documentElement)return this;const n=this.$options;if(!n.render){let e=n.template;if(e)if("string"==typeof e)"#"===e.charAt(0)&&(e=ca(e));else{if(!e.nodeType)return this;e=e.innerHTML}else t&&(e=function(t){if(t.outerHTML)return t.outerHTML;{const e=document.createElement("div");return e.appendChild(t.cloneNode(!0)),e.innerHTML}}(t));if(e){const{render:t,staticRenderFns:o}=oa(e,{outputSourceRange:!1,shouldDecodeNewlines:ia,shouldDecodeNewlinesForHref:aa,delimiters:n.delimiters,comments:n.comments},this);n.render=t,n.staticRenderFns=o}}return la.call(this,t,e)},_n.compile=oa,_n}));
\ No newline at end of file
diff --git a/dist/vue.runtime.common.dev.js b/dist/vue.runtime.common.dev.js
deleted file mode 100644
index ac55f353bdc..00000000000
--- a/dist/vue.runtime.common.dev.js
+++ /dev/null
@@ -1,7404 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-'use strict';
-
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
-
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
-}
-
-let warn = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (!config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-{
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
-}
-
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
-}
-
-let mark;
-let measure;
-{
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
-}
-
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            {
-                defineReactive(vm, key, result[key], () => {
-                    warn(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-        }, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
-}
-
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            warn(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(`timeout (${res.timeout}ms)`
-                                );
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
-}
-
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
-}
-
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
-}
-
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
-}
-
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (!config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
-}
-
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = expOrFn.toString()
-            ;
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                warn(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
-}
-
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        warn("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        {
-            if (methods && hasOwn(methods, key)) {
-                warn(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            warn(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (getter == null) {
-            warn(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else {
-            if (key in vm.$data) {
-                warn(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        {
-            if (typeof methods[key] !== "function") {
-                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    {
-        dataDef.set = function () {
-            warn("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
-}
-
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        {
-            initProxy(vm);
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function Vue(options) {
-    if (!(this instanceof Vue)) {
-        warn("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
-renderMixin(Vue);
-
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
-}
-
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
-}
-
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
-}
-
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
-}
-
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
-};
-
-var builtInComponents = {
-    KeepAlive,
-};
-
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    {
-        configDef.set = () => {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
-}
-
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
-Vue.version = '2.6.14';
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
-};
-
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
-}
-
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
-const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            warn('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
-}
-
-var nodeOps = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createElement: createElement,
-  createElementNS: createElementNS,
-  createTextNode: createTextNode,
-  createComment: createComment,
-  insertBefore: insertBefore,
-  removeChild: removeChild,
-  appendChild: appendChild,
-  parentNode: parentNode,
-  nextSibling: nextSibling,
-  tagName: tagName,
-  setTextContent: setTextContent,
-  setStyleScope: setStyleScope
-});
-
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
-}
-
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
-}
-
-var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
-}
-
-var baseModules = [ref, directives];
-
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
-};
-
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass = {
-    create: updateClass,
-    update: updateClass,
-};
-
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-};
-
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
-};
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
-}
-
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style = {
-    create: updateStyle,
-    update: updateStyle,
-};
-
-const whitespaceRE = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
-    : {};
-
-var platformModules = [attrs, klass, events, domProps, style, transition];
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules);
-const patch = createPatchFunction({ nodeOps, modules });
-
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        warn(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
-}
-
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
-};
-
-var platformDirectives = {
-    model: directive,
-    show,
-};
-
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
-};
-
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
-}
-
-var platformComponents = {
-    Transition,
-    TransitionGroup,
-};
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
-}
-
-module.exports = Vue;
diff --git a/dist/vue.runtime.common.js b/dist/vue.runtime.common.js
deleted file mode 100644
index 07ddaa2ccba..00000000000
--- a/dist/vue.runtime.common.js
+++ /dev/null
@@ -1,5 +0,0 @@
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./vue.runtime.common.prod.js')
-} else {
-  module.exports = require('./vue.runtime.common.dev.js')
-}
diff --git a/dist/vue.runtime.common.prod.js b/dist/vue.runtime.common.prod.js
deleted file mode 100644
index 4f83392cd33..00000000000
--- a/dist/vue.runtime.common.prod.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("key,ref,slot,slot-scope,is");function h(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const m=Object.prototype.hasOwnProperty;function y(t,e){return m.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const g=/-(\w)/g,_=v((t=>t.replace(g,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),$=/\B([A-Z])/g,C=v((t=>t.replace($,"-$1").toLowerCase()));const w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function x(t,e){for(const n in e)t[n]=e[n];return t}function k(t){const e={};for(let n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}const S=(t,e,n)=>!1,E=t=>t;function T(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>T(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>T(t[n],e[n])))}}catch(t){return!1}}function I(t,e){for(let n=0;n<t.length;n++)if(T(t[n],e))return n;return-1}function j(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const D=["component","directive","filter"],N=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var P={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:E,mustUseProp:S,async:!0,_lifecycleHooks:N};function L(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function M(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const F=new RegExp(`[^${/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source}.$_\\d]`);const R="__proto__"in{},V="undefined"!=typeof window,U="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,z=U&&WXEnvironment.platform.toLowerCase(),B=V&&window.navigator.userAgent.toLowerCase(),H=B&&/msie|trident/.test(B),W=B&&B.indexOf("msie 9.0")>0,q=B&&B.indexOf("edge/")>0;B&&B.indexOf("android");const K=B&&/iphone|ipad|ipod|ios/.test(B)||"ios"===z;B&&/chrome\/\d+/.test(B),B&&/phantomjs/.test(B);const X=B&&B.match(/firefox\/(\d+)/),G={}.watch;let Z,J=!1;if(V)try{const t={};Object.defineProperty(t,"passive",{get(){J=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const Q=()=>(void 0===Z&&(Z=!V&&!U&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),Z),Y=V&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function tt(t){return"function"==typeof t&&/native code/.test(t.toString())}const et="undefined"!=typeof Symbol&&tt(Symbol)&&"undefined"!=typeof Reflect&&tt(Reflect.ownKeys);let nt;nt="undefined"!=typeof Set&&tt(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let ot=O,rt=0;class st{static target;id;subs;constructor(){this.id=rt++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){h(this.subs,t)}depend(){st.target&&st.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}st.target=null;const it=[];function at(t){it.push(t),st.target=t}function ct(){it.pop(),st.target=it[it.length-1]}class lt{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const ut=(t="")=>{const e=new lt;return e.text=t,e.isComment=!0,e};function ft(t){return new lt(void 0,void 0,void 0,String(t))}function dt(t){const e=new lt(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const pt=Array.prototype,ht=Object.create(pt);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=pt[t];M(ht,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const mt=Object.getOwnPropertyNames(ht);let yt=!0;function vt(t){yt=t}class gt{value;dep;vmCount;constructor(t){this.value=t,this.dep=new st,this.vmCount=0,M(t,"__ob__",this),Array.isArray(t)?(R?function(t,e){t.__proto__=e}(t,ht):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];M(t,r,e[r])}}(t,ht,mt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)bt(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)_t(t[e])}}function _t(t,e){if(!s(t)||t instanceof lt)return;let n;return y(t,"__ob__")&&t.__ob__ instanceof gt?n=t.__ob__:yt&&!Q()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new gt(t)),e&&n&&n.vmCount++,n}function bt(t,e,n,o,r){const s=new st,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&_t(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return st.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&wt(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&_t(e),s.notify())}})}function $t(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?(bt(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function Ct(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||y(t,e)&&(delete t[e],n&&n.dep.notify())}function wt(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&wt(e)}const At=P.optionMergeStrategies;function xt(t,e){if(!e)return t;let n,o,r;const s=et?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],y(t,n)?o!==r&&a(o)&&a(r)&&xt(o,r):$t(t,n,r));return t}function kt(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?xt(o,r):r}:e?t?function(){return xt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function Ot(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function St(t,e,n,o){const r=Object.create(t||null);return e?x(r,e):r}At.data=function(t,e,n){return n?kt(t,e,n):e&&"function"!=typeof e?t:kt(t,e)},N.forEach((t=>{At[t]=Ot})),D.forEach((function(t){At[t+"s"]=St})),At.watch=function(t,e,n,o){if(t===G&&(t=void 0),e===G&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};x(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},At.props=At.methods=At.inject=At.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return x(r,t),e&&x(r,e),r},At.provide=kt;const Et=function(t,e){return void 0===e?t:e};function Tt(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?x({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=Tt(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=Tt(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)y(t,r)||s(r);function s(r){const s=At[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function It(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(y(r,n))return r[n];const s=_(n);if(y(r,s))return r[s];const i=b(s);if(y(r,i))return r[i];return r[n]||r[s]||r[i]}function jt(t,e,n,o){const r=e[t],s=!y(n,t);let i=n[t];const a=Lt(Boolean,r.type);if(a>-1)if(s&&!y(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Lt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!y(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Nt(e.type)?o.call(t):o}(o,r,t);const e=yt;vt(!0),_t(i),vt(e)}return i}const Dt=/^\s*function (\w+)/;function Nt(t){const e=t&&t.toString().match(Dt);return e?e[1]:""}function Pt(t,e){return Nt(t)===Nt(e)}function Lt(t,e){if(!Array.isArray(e))return Pt(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Pt(e[n],t))return n;return-1}function Mt(t,e,n){at();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Rt(t,o,"errorCaptured hook")}}}Rt(t,e,n)}finally{ct()}}function Ft(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Mt(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Mt(t,o,r)}return s}function Rt(t,e,n){if(P.errorHandler)try{return P.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Vt(e)}Vt(t)}function Vt(t,e,n){if(!V&&!U||"undefined"==typeof console)throw t;console.error(t)}let Ut=!1;const zt=[];let Bt,Ht=!1;function Wt(){Ht=!1;const t=zt.slice(0);zt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&tt(Promise)){const t=Promise.resolve();Bt=()=>{t.then(Wt),K&&setTimeout(O)},Ut=!0}else if(H||"undefined"==typeof MutationObserver||!tt(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Bt="undefined"!=typeof setImmediate&&tt(setImmediate)?()=>{setImmediate(Wt)}:()=>{setTimeout(Wt,0)};else{let t=1;const e=new MutationObserver(Wt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Bt=()=>{t=(t+1)%2,n.data=String(t)},Ut=!0}function qt(t,e){let n;if(zt.push((()=>{if(t)try{t.call(e)}catch(t){Mt(t,e,"nextTick")}else n&&n(e)})),Ht||(Ht=!0,Bt()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Kt=new nt;function Xt(t){Gt(t,Kt),Kt.clear()}function Gt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof lt)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Gt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Gt(t[o[n]],e)}}const Zt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Jt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Ft(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Ft(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function Qt(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Zt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Jt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Zt(c),s(f.name,n[c],f.capture))}function Yt(t,r,s){let i;t instanceof lt&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),h(i.fns,c)}e(a)?i=Jt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Jt([a,c]),i.merged=!0,t[r]=i}function te(t,e,o,r,s){if(n(e)){if(y(e,o))return t[o]=e[o],s||delete e[o],!0;if(y(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function ee(t){return r(t)?[ft(t)]:Array.isArray(t)?oe(t):void 0}function ne(t){return n(t)&&n(t.text)&&!1===t.isComment}function oe(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=oe(c,`${s||""}_${a}`),ne(c[0])&&ne(u)&&(i[l]=ft(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?ne(u)?i[l]=ft(u.text+c):""!==c&&i.push(ft(c)):ne(c)&&ne(u)?i[l]=ft(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function re(t,e){if(t){const n=Object.create(null),o=et?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&y(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function se(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ie)&&delete n[t];return n}function ie(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ae(t){return t.isComment&&t.asyncFactory}function ce(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=le(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=ue(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),M(r,"$stable",i),M(r,"$key",a),M(r,"$hasNormal",s),r}function le(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ee(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!ae(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function ue(t,e){return()=>t[e]}function fe(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(et&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function de(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=x(x({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function pe(t){return It(this.$options,"filters",t)||E}function he(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function me(t,e,n,o,r){const s=P.keyCodes[e]||n;return r&&o&&!P.keyCodes[e]?he(r,o):s?he(s,t):o?C(o)!==e:void 0===t}function ye(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=k(n));for(const i in n){if("class"===i||"style"===i||p(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||P.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function ve(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),_e(o,`__static__${t}`,!1)),o}function ge(t,e,n){return _e(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function _e(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&be(t[o],`${e}_${o}`,n);else be(t,e,n)}function be(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function $e(t,e){if(e)if(a(e)){const n=t.on=t.on?x({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function Ce(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?Ce(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function we(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function Ae(t,e){return"string"==typeof t?e+t:t}function xe(t){t._o=ge,t._n=f,t._s=u,t._l=fe,t._t=de,t._q=T,t._i=I,t._m=ve,t._f=pe,t._k=me,t._b=ye,t._v=ft,t._e=ut,t._u=Ce,t._g=$e,t._d=we,t._p=Ae}function ke(e,n,r,s,i){const a=i.options;let c;y(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=re(a.inject,s),this.slots=()=>(this.$slots||ce(e.scopedSlots,this.$slots=se(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return ce(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=ce(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=De(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>De(c,t,e,n,o,u)}function Oe(t,e,n,o,r){const s=dt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Se(t,e){for(const n in e)t[_(n)]=e[n]}xe(ke.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,Be)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){vt(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=jt(s,i,n,e)}vt(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,ze(e,o,u),l&&(e.$slots=se(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Xe(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Ze.push(o)):qe(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Ke(e,!0):e.$destroy())}},Te=Object.keys(Ee);function Ie(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Le;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>h(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=j((e=>{t.resolved=Me(e,r),a?o.length=0:f(!0)})),p=j((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),m=t(d,p);return s(m)&&(l(m)?e(t.resolved)&&m.then(d,p):l(m.component)&&(m.component.then(d,p),n(m.error)&&(t.errorComp=Me(m.error,r)),n(m.loading)&&(t.loadingComp=Me(m.loading,r),0===m.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),m.delay||200)),n(m.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),m.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=ut();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},yn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);te(i,c,t,e,!0)||te(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=jt(e,l,o||t);else n(r.attrs)&&Se(c,r.attrs),n(r.props)&&Se(c,r.props);const u=new ke(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof lt)return Oe(f,r,u.parent,a);if(Array.isArray(f)){const t=ee(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Oe(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const m=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Te.length;t++){const n=Te[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?je(r,o):r)}}(i);const y=r.options.name||u;return new lt(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:m,tag:u,children:c},d)}function je(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function De(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return ut();n(o)&&n(o.is)&&(e=o.is);if(!e)return ut();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=ee(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||P.getTagNamespace(e),a=P.isReservedTag(e)?new lt(P.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=It(t.$options,"components",e))?new lt(e,o,r,void 0,void 0,t):Ie(s,o,t,r,e)}else a=Ie(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Ne(a,c),n(o)&&function(t){s(t.style)&&Xt(t.style);s(t.class)&&Xt(t.class)}(o),a):ut()}(t,e,i,a,c)}function Ne(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Ne(a,r,s)}}let Pe,Le=null;function Me(t,e){return(t.__esModule||et&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Fe(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||ae(o)))return o}}function Re(t,e){Pe.$on(t,e)}function Ve(t,e){Pe.$off(t,e)}function Ue(t,e){const n=Pe;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function ze(t,e,n){Pe=t,Qt(e,n||{},Re,Ve,Ue,t),Pe=void 0}let Be=null;function He(t){const e=Be;return Be=t,()=>{Be=e}}function We(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function qe(t,e){if(e){if(t._directInactive=!1,We(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)qe(t.$children[e]);Xe(t,"activated")}}function Ke(t,e){if(!(e&&(t._directInactive=!0,We(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Ke(t.$children[e]);Xe(t,"deactivated")}}function Xe(t,e){at();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Ft(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),ct()}const Ge=[],Ze=[];let Je={},Qe=!1,Ye=!1,tn=0;let en=0,nn=Date.now;if(V&&!H){const t=window.performance;t&&"function"==typeof t.now&&nn()>document.createEvent("Event").timeStamp&&(nn=()=>t.now())}function on(){let t,e;for(en=nn(),Ye=!0,Ge.sort(((t,e)=>t.id-e.id)),tn=0;tn<Ge.length;tn++)t=Ge[tn],t.before&&t.before(),e=t.id,Je[e]=null,t.run();const n=Ze.slice(),o=Ge.slice();tn=Ge.length=Ze.length=0,Je={},Qe=Ye=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,qe(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Xe(o,"updated")}}(o),Y&&P.devtools&&Y.emit("flush")}let rn=0;class sn{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++rn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new nt,this.newDepIds=new nt,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(F.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}get(){let t;at(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Mt(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Xt(t),ct(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Je[e]){if(Je[e]=!0,Ye){let e=Ge.length-1;for(;e>tn&&Ge[e].id>t.id;)e--;Ge.splice(e+1,0,t)}else Ge.push(t);Qe||(Qe=!0,qt(on))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Ft(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const an={enumerable:!0,configurable:!0,get:O,set:O};function cn(t,e,n){an.get=function(){return this[e][n]},an.set=function(t){this[e][n]=t},Object.defineProperty(t,n,an)}function ln(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&vt(!1);for(const s in e){r.push(s);bt(o,s,jt(s,e,n,t)),s in t||cn(t,"_props",s)}vt(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?O:w(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){at();try{return t.call(e,e)}catch(t){return Mt(t,e,"data()"),{}}finally{ct()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&y(o,e)||L(e)||cn(t,"_data",e)}_t(e,!0)}(t):_t(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=Q();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new sn(t,i||O,O,un)),r in t||fn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==G&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)hn(t,n,o[e]);else hn(t,n,o)}}(t,e.watch)}const un={lazy:!0};function fn(t,e,n){const o=!Q();"function"==typeof n?(an.get=o?dn(e):pn(n),an.set=O):(an.get=n.get?o&&!1!==n.cache?dn(e):pn(n.get):O,an.set=n.set||O),Object.defineProperty(t,e,an)}function dn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),st.target&&e.depend(),e.value}}function pn(t){return function(){return t.call(this,this)}}function hn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let mn=0;function yn(t){let e=t.options;if(t.super){const n=yn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&x(t.extendOptions,o),e=t.options=Tt(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function vn(t){this._init(t)}function gn(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=Tt(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)cn(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)fn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,D.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=x({},i.options),r[o]=i,i}}function _n(t){return t&&(t.Ctor.options.name||t.tag)}function bn(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function $n(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&Cn(n,t,o,r)}}}function Cn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,h(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=mn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=Tt(yn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&ze(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=se(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>De(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>De(e,t,n,o,r,!0);const s=o&&o.data;bt(e,"$attrs",s&&s.attrs||t,null,!0),bt(e,"$listeners",n._parentListeners||t,null,!0)}(n),Xe(n,"beforeCreate"),function(t){const e=re(t.$options.inject,t);e&&(vt(!1),Object.keys(e).forEach((n=>{bt(t,n,e[n])})),vt(!0))}(n),ln(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Xe(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(vn),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=$t,t.prototype.$delete=Ct,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return hn(o,t,e,n);(n=n||{}).user=!0;const r=new sn(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;at(),Ft(e,o,[r.value],o,t),ct()}return function(){r.teardown()}}}(vn),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?A(n):n;const o=A(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Ft(n[t],e,o,e,r)}return e}}(vn),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=He(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Xe(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||h(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Xe(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(vn),function(t){xe(t.prototype),t.prototype.$nextTick=function(t){return qt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=ce(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Le=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Mt(e,t,"render"),o=t._vnode}finally{Le=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof lt||(o=ut()),o.parent=n,o}}(vn);const wn=[String,RegExp,Array];var An={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:wn,exclude:wn,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:_n(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&Cn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)Cn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{$n(this,(e=>bn(t,e)))})),this.$watch("exclude",(t=>{$n(this,(e=>!bn(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=Fe(t),n=e&&e.componentOptions;if(n){const t=_n(n),{include:o,exclude:r}=this;if(o&&(!t||!bn(o,t))||r&&t&&bn(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,h(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>P};Object.defineProperty(t,"config",e),t.util={warn:ot,extend:x,mergeOptions:Tt,defineReactive:bt},t.set=$t,t.delete=Ct,t.nextTick=qt,t.observable=t=>(_t(t),t),t.options=Object.create(null),D.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,An),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=Tt(this.options,t),this}}(t),gn(t),function(t){D.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(vn),Object.defineProperty(vn.prototype,"$isServer",{get:Q}),Object.defineProperty(vn.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(vn,"FunctionalRenderContext",{value:ke}),vn.version="2.6.14";const xn=d("style,class"),kn=d("input,textarea,option,select,progress"),On=d("contenteditable,draggable,spellcheck"),Sn=d("events,caret,typing,plaintext-only"),En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),Tn="http://www.w3.org/1999/xlink",In=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),jn=t=>In(t)?t.slice(6,t.length):"",Dn=t=>null==t||!1===t;function Nn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Pn(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Pn(e,o.data));return function(t,e){if(n(t)||n(e))return Ln(t,Mn(e));return""}(e.staticClass,e.class)}function Pn(t,e){return{staticClass:Ln(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Ln(t,e){return t?e?t+" "+e:t:e||""}function Mn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Mn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Fn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Rn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Vn=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),Un=t=>Rn(t)||Vn(t);const zn=Object.create(null);const Bn=d("text,number,password,search,email,tel,url");var Hn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Fn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),Wn={create(t,e){qn(e)},update(t,e){t.data.ref!==e.data.ref&&(qn(t,!0),qn(e))},destroy(t){qn(t,!0)}};function qn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?h(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Kn=new lt("",{},[]),Xn=["create","activate","update","remove","destroy"];function Gn(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Bn(r)&&Bn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function Zn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var Jn={create:Qn,update:Qn,destroy:function(t){Qn(t,Kn)}};function Qn(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Kn,o=e===Kn,r=to(t.data.directives,t.context),s=to(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,no(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(no(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)no(i[n],"inserted",e,t)};n?Yt(e,"insert",o):o()}a.length&&Yt(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)no(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||no(r[c],"unbind",t,t,o)}(t,e)}const Yn=Object.create(null);function to(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=Yn),n[eo(r)]=r,r.def=It(e.$options,"directives",r.name);return n}function eo(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function no(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Mt(o,n.context,`directive ${t.name} ${e} hook`)}}var oo=[Wn,Jn];function ro(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=x({},u)),u)i=u[s],a=l[s],a!==i&&so(c,s,i,o.data.pre);for(s in(H||q)&&u.value!==l.value&&so(c,"value",u.value),l)e(u[s])&&(In(s)?c.removeAttributeNS(Tn,jn(s)):On(s)||c.removeAttribute(s))}function so(t,e,n,o){o||t.tagName.indexOf("-")>-1?io(t,e,n):En(e)?Dn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):On(e)?t.setAttribute(e,((t,e)=>Dn(e)||"false"===e?"false":"contenteditable"===t&&Sn(e)?e:"true")(e,n)):In(e)?Dn(n)?t.removeAttributeNS(Tn,jn(e)):t.setAttributeNS(Tn,e,n):io(t,e,n)}function io(t,e,n){if(Dn(n))t.removeAttribute(e);else{if(H&&!W&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var ao={create:ro,update:ro};function co(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Nn(o);const c=r._transitionClasses;n(c)&&(a=Ln(a,Mn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var lo={create:co,update:co};let uo;function fo(t,e,n){const o=uo;return function r(){const s=e.apply(null,arguments);null!==s&&mo(t,r,n,o)}}const po=Ut&&!(X&&Number(X[1])<=53);function ho(t,e,n,o){if(po){const t=en,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}uo.addEventListener(t,e,J?{capture:n,passive:o}:n)}function mo(t,e,n,o){(o||uo).removeEventListener(t,e._wrapper||e,n)}function yo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};uo=o.elm||t.elm,function(t){if(n(t.__r)){const e=H?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),Qt(r,s,ho,mo,fo,o.context),uo=void 0}var vo={create:yo,update:yo,destroy:t=>yo(t,Kn)};let go;function _o(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=x({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);bo(i,t)&&(i.value=t)}else if("innerHTML"===r&&Vn(i.tagName)&&e(i.innerHTML)){go=go||document.createElement("div"),go.innerHTML=`<svg>${s}</svg>`;const t=go.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function bo(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var $o={create:_o,update:_o};const Co=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function wo(t){const e=Ao(t.style);return t.staticStyle?x(t.staticStyle,e):e}function Ao(t){return Array.isArray(t)?k(t):"string"==typeof t?Co(t):t}const xo=/^--/,ko=/\s*!important$/,Oo=(t,e,n)=>{if(xo.test(e))t.style.setProperty(e,n);else if(ko.test(n))t.style.setProperty(C(e),n.replace(ko,""),"important");else{const o=To(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},So=["Webkit","Moz","ms"];let Eo;const To=v((function(t){if(Eo=Eo||document.createElement("div").style,"filter"!==(t=_(t))&&t in Eo)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<So.length;t++){const n=So[t]+e;if(n in Eo)return n}}));function Io(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=Ao(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?x({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=wo(e.data))&&x(n,o)}(o=wo(t.data))&&x(n,o);let r=t;for(;r=r.parent;)r.data&&(o=wo(r.data))&&x(n,o);return n}(o,!0);for(a in f)e(p[a])&&Oo(c,a,"");for(a in p)i=p[a],i!==f[a]&&Oo(c,a,null==i?"":i)}var jo={create:Io,update:Io};const Do=/\s+/;function No(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Do).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Po(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(Do).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function Lo(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&x(e,Mo(t.name||"v")),x(e,t),e}return"string"==typeof t?Mo(t):void 0}}const Mo=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),Fo=V&&!W;let Ro="transition",Vo="transitionend",Uo="animation",zo="animationend";Fo&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(Ro="WebkitTransition",Vo="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Uo="WebkitAnimation",zo="webkitAnimationEnd"));const Bo=V?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Ho(t){Bo((()=>{Bo(t)}))}function Wo(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),No(t,e))}function qo(t,e){t._transitionClasses&&h(t._transitionClasses,e),Po(t,e)}function Ko(t,e,n){const{type:o,timeout:r,propCount:s}=Go(t,e);if(!o)return n();const i="transition"===o?Vo:zo;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Xo=/\b(transform|all)(,|$)/;function Go(t,e){const n=window.getComputedStyle(t),o=(n[Ro+"Delay"]||"").split(", "),r=(n[Ro+"Duration"]||"").split(", "),s=Zo(o,r),i=(n[Uo+"Delay"]||"").split(", "),a=(n[Uo+"Duration"]||"").split(", "),c=Zo(i,a);let l,u=0,f=0;"transition"===e?s>0&&(l="transition",u=s,f=r.length):"animation"===e?c>0&&(l="animation",u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?"transition":"animation":null,f=l?"transition"===l?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:"transition"===l&&Xo.test(n[Ro+"Property"])}}function Zo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>Jo(e)+Jo(t[n]))))}function Jo(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function Qo(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=Lo(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:v,afterEnter:g,enterCancelled:_,beforeAppear:b,appear:$,afterAppear:C,appearCancelled:w,duration:A}=i;let x=Be,k=Be.$vnode;for(;k&&k.parent;)x=k.context,k=k.parent;const O=!x._isMounted||!t.isRootInsert;if(O&&!$&&""!==$)return;const S=O&&p?p:l,E=O&&m?m:d,T=O&&h?h:u,I=O&&b||y,D=O&&"function"==typeof $?$:v,N=O&&C||g,P=O&&w||_,L=f(s(A)?A.enter:A),M=!1!==a&&!W,F=er(D),R=r._enterCb=j((()=>{M&&(qo(r,T),qo(r,E)),R.cancelled?(M&&qo(r,S),P&&P(r)):N&&N(r),r._enterCb=null}));t.data.show||Yt(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(r,R)})),I&&I(r),M&&(Wo(r,S),Wo(r,E),Ho((()=>{qo(r,S),R.cancelled||(Wo(r,T),F||(tr(L)?setTimeout(R,L):Ko(r,c,R)))}))),t.data.show&&(o&&o(),D&&D(r,R)),M||F||R()}function Yo(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=Lo(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:v,duration:g}=i,_=!1!==a&&!W,b=er(h),$=f(s(g)?g.leave:g),C=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),_&&(qo(r,u),qo(r,d)),C.cancelled?(_&&qo(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function w(){C.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),_&&(Wo(r,l),Wo(r,d),Ho((()=>{qo(r,l),C.cancelled||(Wo(r,u),b||(tr($)?setTimeout(C,$):Ko(r,c,C)))}))),h&&h(r,C),_||b||C())}v?v(w):w()}function tr(t){return"number"==typeof t&&!isNaN(t)}function er(t){if(e(t))return!1;const o=t.fns;return n(o)?er(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function nr(t,e){!0!==e.data.show&&Qo(e)}const or=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Xn.length;++s)for(a[Xn[s]]=[],i=0;i<c.length;++i)n(c[i][Xn[s]])&&a[Xn[s]].push(c[i][Xn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=dt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Kn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),g(t),m(t,d,e),n(f)&&v(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(v(t,e),g(t)):(qn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function v(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Kn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Kn,t),n(s.insert)&&e.push(t))}function g(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=Be)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function _(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function b(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)b(t.children[o])}function $(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(C(o),b(o)):u(o.elm))}}function C(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&C(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function w(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Gn(t,o))return s}}function A(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=dt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,v=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(v)?m!==v&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],v=o[m],g=r.length-1,b=r[0],C=r[g];const x=!i;for(;p<=m&&h<=g;)e(y)?y=o[++p]:e(v)?v=o[--m]:Gn(y,b)?(A(y,b,s,r,h),y=o[++p],b=r[++h]):Gn(v,C)?(A(v,C,s,r,g),v=o[--m],C=r[--g]):Gn(y,C)?(A(y,C,s,r,g),x&&l.insertBefore(t,y.elm,l.nextSibling(v.elm)),y=o[++p],C=r[--g]):Gn(v,b)?(A(v,b,s,r,h),x&&l.insertBefore(t,v.elm,y.elm),v=o[--m],b=r[++h]):(e(a)&&(a=Zn(o,p,m)),c=n(b.key)?a[b.key]:w(b,o,p,m),e(c)?f(b,s,t,y.elm,!1,r,h):(u=o[c],Gn(u,b)?(A(u,b,s,r,h),o[c]=void 0,x&&l.insertBefore(t,u.elm,y.elm)):f(b,s,t,y.elm,!1,r,h)),b=r[++h]);p>m?(d=e(r[g+1])?null:r[g+1].elm,_(t,d,r,h,g,s)):h>g&&$(o,p,m)}(d,m,v,s,u):n(v)?(n(t.text)&&l.setTextContent(d,""),_(d,null,v,0,v.length-1,s)):n(m)?$(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function x(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!k(n)){t=!0,v(e,r);break}!t&&c.class&&Xt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&b(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Gn(t,r))A(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute("data-server-rendered")&&(t.removeAttribute("data-server-rendered"),s=!0),o(s)&&O(t,r,u))return x(r,u,!0),t;d=t,t=new lt(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Kn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else qn(t);t=t.parent}}n(c)?$([t],0,0):n(t.tag)&&b(t)}}var d;return x(r,u,c),r.elm}}({nodeOps:Hn,modules:[ao,lo,vo,$o,jo,V?{create:nr,activate:nr,remove(t,e){!0!==t.data.show?Yo(t,e):e()}}:{}].concat(oo)});W&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&fr(t,"input")}));const rr={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?Yt(n,"postpatch",(()=>{rr.componentUpdated(t,e,n)})):sr(t,e,n.context),t._vOptions=[].map.call(t.options,cr)):("textarea"===n.tag||Bn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",lr),t.addEventListener("compositionend",ur),t.addEventListener("change",ur),W&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){sr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,cr);if(r.some(((t,e)=>!T(t,o[e])))){(t.multiple?e.value.some((t=>ar(t,r))):e.value!==e.oldValue&&ar(e.value,r))&&fr(t,"change")}}}};function sr(t,e,n){ir(t,e),(H||q)&&setTimeout((()=>{ir(t,e)}),0)}function ir(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=I(o,cr(i))>-1,i.selected!==s&&(i.selected=s);else if(T(cr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function ar(t,e){return e.every((e=>!T(e,t)))}function cr(t){return"_value"in t?t._value:t.value}function lr(t){t.target.composing=!0}function ur(t){t.target.composing&&(t.target.composing=!1,fr(t.target,"input"))}function fr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function dr(t){return!t.componentInstance||t.data&&t.data.transition?t:dr(t.componentInstance._vnode)}var pr={bind(t,{value:e},n){const o=(n=dr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,Qo(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=dr(o)).data&&o.data.transition?(o.data.show=!0,e?Qo(o,(()=>{t.style.display=t.__vOriginalDisplay})):Yo(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},hr={model:rr,show:pr};const mr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function yr(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?yr(Fe(e.children)):t}function vr(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function gr(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const _r=t=>t.tag||ae(t),br=t=>"show"===t.name;var $r={name:"transition",props:mr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(_r),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=yr(o);if(!s)return o;if(this._leaving)return gr(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=vr(this),c=this._vnode,l=yr(c);if(s.data.directives&&s.data.directives.some(br)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!ae(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=x({},a);if("out-in"===n)return this._leaving=!0,Yt(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),gr(t,o);if("in-out"===n){if(ae(s))return c;let t;const n=()=>{t()};Yt(a,"afterEnter",n),Yt(a,"enterCancelled",n),Yt(e,"delayLeave",(e=>{t=e}))}}return o}};const Cr=x({tag:String,moveClass:String},mr);function wr(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Ar(t){t.data.newPos=t.elm.getBoundingClientRect()}function xr(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete Cr.mode;var kr={Transition:$r,TransitionGroup:{props:Cr,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=He(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=vr(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(wr),t.forEach(Ar),t.forEach(xr),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Wo(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(Vo,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(Vo,t),n._moveCb=null,qo(n,e))})}})))},methods:{hasMove(t,e){if(!Fo)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{Po(n,t)})),No(n,e),n.style.display="none",this.$el.appendChild(n);const o=Go(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};vn.config.mustUseProp=(t,e,n)=>"value"===n&&kn(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,vn.config.isReservedTag=Un,vn.config.isReservedAttr=xn,vn.config.getTagNamespace=function(t){return Vn(t)?"svg":"math"===t?"math":void 0},vn.config.isUnknownElement=function(t){if(!V)return!0;if(Un(t))return!1;if(t=t.toLowerCase(),null!=zn[t])return zn[t];const e=document.createElement(t);return t.indexOf("-")>-1?zn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:zn[t]=/HTMLUnknownElement/.test(e.toString())},x(vn.options.directives,hr),x(vn.options.components,kr),vn.prototype.__patch__=V?or:O,vn.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=ut),Xe(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new sn(t,o,O,{before(){t._isMounted&&!t._isDestroyed&&Xe(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Xe(t,"mounted")),t}(this,t=t&&V?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},V&&setTimeout((()=>{P.devtools&&Y&&Y.emit("init",vn)}),0),module.exports=vn;
\ No newline at end of file
diff --git a/dist/vue.runtime.esm.js b/dist/vue.runtime.esm.js
deleted file mode 100644
index f7fa9715b81..00000000000
--- a/dist/vue.runtime.esm.js
+++ /dev/null
@@ -1,7443 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        const l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-const bind = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    let i = list.length - start;
-    const ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    let called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
-
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    const c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    const segments = path.split('.');
-    return function (obj) {
-        for (let i = 0; i < segments.length; i++) {
-            if (!obj)
-                return;
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-const isFF = UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
-}
-
-let warn = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid$2 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid$2++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$2(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warn('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-        // skip validation for weex recycle-list child component props
-        !(false  )) {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-        warn('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    if (process.env.NODE_ENV !== 'production') {
-        warn(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-let isUsingMicroTask = false;
-const callbacks = [];
-let pending = false;
-function flushCallbacks() {
-    pending = false;
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-let timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    const p = Promise.resolve();
-    timerFunc = () => {
-        p.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            setTimeout(noop);
-    };
-    isUsingMicroTask = true;
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-    timerFunc = () => {
-        counter = (counter + 1) % 2;
-        textNode.data = String(counter);
-    };
-    isUsingMicroTask = true;
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = () => {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = () => {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    let _resolve;
-    callbacks.push(() => {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise((resolve) => {
-            _resolve = resolve;
-        });
-    }
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-let initProxy;
-if (process.env.NODE_ENV !== 'production') {
-    const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const warnNonPresent = (target, key) => {
-        warn(`Property or method "${key}" is not defined on the instance but ` +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    const warnReservedPrefix = (target, key) => {
-        warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    const hasHandler = {
-        has(target, key) {
-            const has = key in target;
-            const isAllowed = allowedGlobals(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return has || !isAllowed;
-        },
-    };
-    const getHandler = {
-        get(target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    warnReservedPrefix(target, key);
-                else
-                    warnNonPresent(target, key);
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy) {
-            // determine which proxy handler to use
-            const options = vm.$options;
-            const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
-}
-
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
-}
-
-let mark;
-let measure;
-if (process.env.NODE_ENV !== 'production') {
-    const perf = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf &&
-        perf.mark &&
-        perf.measure &&
-        perf.clearMarks &&
-        perf.clearMeasures) {
-        mark = (tag) => perf.mark(tag);
-        measure = (name, startTag, endTag) => {
-            perf.measure(name, startTag, endTag);
-            perf.clearMarks(startTag);
-            perf.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
-}
-
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    let invoker;
-    const oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            if (process.env.NODE_ENV !== 'production') {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-function initProvide(vm) {
-    const provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    const result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach((key) => {
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], () => {
-                    warn(`Avoid mutating an injected value directly since the changes will be ` +
-                        `overwritten whenever the provided component re-renders. ` +
-                        `injection being mutated: "${key}"`, vm);
-                });
-            }
-            else {
-                defineReactive(vm, key, result[key]);
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else if (process.env.NODE_ENV !== 'production') {
-                    warn(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
-                warn("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (process.env.NODE_ENV !== 'production' &&
-            key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    if (process.env.NODE_ENV !== 'production') {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        if (process.env.NODE_ENV !== 'production') {
-            warn(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (process.env.NODE_ENV !== 'production' &&
-        isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (process.env.NODE_ENV !== 'production' &&
-                isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    const options = vm.$options;
-    const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    const renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    const parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-            !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-        }, true);
-    }
-    else {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-    }
-}
-let currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        const vm = this;
-        const { render, _parentVnode } = vm.$options;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        let vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, `render`);
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e) {
-                    handleError(e, vm, `renderError`);
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
-}
-
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    const owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        const owners = (factory.owners = [owner]);
-        let sync = true;
-        let timerLoading = null;
-        let timerTimeout = null;
-        owner.$on('hook:destroyed', () => remove$2(owners, owner));
-        const forceRender = (renderCompleted) => {
-            for (let i = 0, l = owners.length; i < l; i++) {
-                owners[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners.length = 0;
-                if (timerLoading !== null) {
-                    clearTimeout(timerLoading);
-                    timerLoading = null;
-                }
-                if (timerTimeout !== null) {
-                    clearTimeout(timerTimeout);
-                    timerTimeout = null;
-                }
-            }
-        };
-        const resolve = once((res) => {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync) {
-                forceRender(true);
-            }
-            else {
-                owners.length = 0;
-            }
-        });
-        const reject = once((reason) => {
-            process.env.NODE_ENV !== 'production' &&
-                warn(`Failed to resolve async component: ${String(factory)}` +
-                    (reason ? `\nReason: ${reason}` : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender(true);
-            }
-        });
-        const res = factory(resolve, reject);
-        if (isObject(res)) {
-            if (isPromise(res)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res.then(resolve, reject);
-                }
-            }
-            else if (isPromise(res.component)) {
-                res.component.then(resolve, reject);
-                if (isDef(res.error)) {
-                    factory.errorComp = ensureCtor(res.error, baseCtor);
-                }
-                if (isDef(res.loading)) {
-                    factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                    if (res.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading = setTimeout(() => {
-                            timerLoading = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender(false);
-                            }
-                        }, res.delay || 200);
-                    }
-                }
-                if (isDef(res.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout = setTimeout(() => {
-                        timerTimeout = null;
-                        if (isUndef(factory.resolved)) {
-                            reject(process.env.NODE_ENV !== 'production'
-                                ? `timeout (${res.timeout}ms)`
-                                : null);
-                        }
-                    }, res.timeout);
-                }
-            }
-        }
-        sync = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
-}
-
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
-}
-
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    const listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-let target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    const _target = target$1;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    const hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        const vm = this;
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        const vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        const vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (let i = 0, l = event.length; i < l; i++) {
-                vm.$off(event[i], fn);
-            }
-            return vm;
-        }
-        // specific event
-        const cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        let cb;
-        let i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        const vm = this;
-        if (process.env.NODE_ENV !== 'production') {
-            const lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                    `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                    `Note that HTML attributes are case-insensitive and you cannot use ` +
-                    `v-on to listen to camelCase events when using in-DOM templates. ` +
-                    `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-            }
-        }
-        let cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            const args = toArray(arguments, 1);
-            const info = `event handler for "${event}"`;
-            for (let i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
-}
-
-let activeInstance = null;
-let isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    const prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return () => {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    const options = vm.$options;
-    // locate first non-abstract parent
-    let parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        const vm = this;
-        const prevEl = vm.$el;
-        const prevVnode = vm._vnode;
-        const restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        const vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        const vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, "beforeDestroy");
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        const parent = vm.$parent;
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        let i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, "destroyed");
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== "production") {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                vm.$options.el ||
-                el) {
-                warn("You are using the runtime-only build of Vue where the template " +
-                    "compiler is not available. Either pre-compile the templates into " +
-                    "render functions, or use the compiler-included build.", vm);
-            }
-            else {
-                warn("Failed to mount component: template or render function not defined.", vm);
-            }
-        }
-    }
-    callHook$1(vm, "beforeMount");
-    let updateComponent;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
-        updateComponent = () => {
-            const name = vm._name;
-            const id = vm._uid;
-            const startTag = `vue-perf-start:${id}`;
-            const endTag = `vue-perf-end:${id}`;
-            mark(startTag);
-            const vnode = vm._render();
-            mark(endTag);
-            measure(`vue ${name} render`, startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure(`vue ${name} patch`, startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = () => {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before() {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, "beforeUpdate");
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, "mounted");
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    if (process.env.NODE_ENV !== "production") {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, "deactivated");
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
-}
-
-const MAX_UPDATE_COUNT = 100;
-const queue = [];
-const activatedChildren = [];
-let has = {};
-let circular = {};
-let waiting = false;
-let flushing = false;
-let index = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    if (process.env.NODE_ENV !== 'production') {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case #6566 requires saving the timestamp when event listeners are
-// attached. However, calling performance.now() has a perf overhead especially
-// if the page has thousands of event listeners. Instead, we take a timestamp
-// every time the scheduler flushes and use that for all event listeners
-// attached during that flush.
-let currentFlushTimestamp = 0;
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    currentFlushTimestamp = getNow();
-    flushing = true;
-    let watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort((a, b) => a.id - b.id);
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? `in watcher with expression "${watcher.expression}"`
-                        : `in a component render function.`), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    const activatedQueue = activatedChildren.slice();
-    const updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    let i = queue.length;
-    while (i--) {
-        const watcher = queue[i];
-        const vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (let i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    const id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            let i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (process.env.NODE_ENV !== 'production' && !config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
-}
-
-let uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-class Watcher {
-    vm;
-    expression;
-    cb;
-    id;
-    deep;
-    user;
-    lazy;
-    sync;
-    dirty;
-    active;
-    deps;
-    newDeps;
-    depIds;
-    newDepIds;
-    before;
-    getter;
-    value;
-    constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression = process.env.NODE_ENV !== 'production'
-            ? expOrFn.toString()
-            : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' && warn(`Failed watching path: "${expOrFn}" ` +
-                    'Watcher only accepts simple dot-delimited paths. ' +
-                    'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy
-            ? undefined
-            : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    get() {
-        pushTarget(this);
-        let value;
-        const vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                handleError(e, vm, `getter for watcher "${this.expression}"`);
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    }
-    /**
-     * Add a dependency to this directive.
-     */
-    addDep(dep) {
-        const id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    }
-    /**
-     * Clean up for dependency collection.
-     */
-    cleanupDeps() {
-        let i = this.deps.length;
-        while (i--) {
-            const dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        let tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    }
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    update() {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    }
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    run() {
-        if (this.active) {
-            const value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                const oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    const info = `callback for watcher "${this.expression}"`;
-                    invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    }
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    evaluate() {
-        this.value = this.get();
-        this.dirty = false;
-    }
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    depend() {
-        let i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    }
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    teardown() {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            let i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    }
-}
-
-const sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    const opts = vm.$options;
-    if (opts.props)
-        initProps$1(vm, opts.props);
-    if (opts.methods)
-        initMethods(vm, opts.methods);
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        initComputed$1(vm, opts.computed);
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    const propsData = vm.$options.propsData || {};
-    const props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    const keys = (vm.$options._propKeys = []);
-    const isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    for (const key in propsOptions) {
-        keys.push(key);
-        const value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== "production") {
-            const hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-            }
-            defineReactive(props, key, value, () => {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn(`Avoid mutating a prop directly since the value will be ` +
-                        `overwritten whenever the parent component re-renders. ` +
-                        `Instead, use a data or computed property based on the prop's ` +
-                        `value. Prop being mutated: "${key}"`, vm);
-                }
-            });
-        }
-        else {
-            defineReactive(props, key, value);
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, `_props`, key);
-        }
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    let data = vm.$options.data;
-    data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        process.env.NODE_ENV !== "production" &&
-            warn("data functions should return an object:\n" +
-                "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-    }
-    // proxy data on instance
-    const keys = Object.keys(data);
-    const props = vm.$options.props;
-    const methods = vm.$options.methods;
-    let i = keys.length;
-    while (i--) {
-        const key = keys[i];
-        if (process.env.NODE_ENV !== "production") {
-            if (methods && hasOwn(methods, key)) {
-                warn(`Method "${key}" has already been defined as a data property.`, vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== "production" &&
-                warn(`The data property "${key}" is already declared as a prop. ` +
-                    `Use prop default value instead.`, vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, `_data`, key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, `data()`);
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-const computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    const watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    const isSSR = isServerRendering();
-    for (const key in computed) {
-        const userDef = computed[key];
-        const getter = typeof userDef === "function" ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== "production" && getter == null) {
-            warn(`Getter is missing for computed property "${key}".`, vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else if (process.env.NODE_ENV !== "production") {
-            if (key in vm.$data) {
-                warn(`The computed property "${key}" is already defined in data.`, vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn(`The computed property "${key}" is already defined as a prop.`, vm);
-            }
-            else if (vm.$options.methods && key in vm.$options.methods) {
-                warn(`The computed property "${key}" is already defined as a method.`, vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    const shouldCache = !isServerRendering();
-    if (typeof userDef === "function") {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (process.env.NODE_ENV !== "production" &&
-        sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        const watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    const props = vm.$options.props;
-    for (const key in methods) {
-        if (process.env.NODE_ENV !== "production") {
-            if (typeof methods[key] !== "function") {
-                warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                    `Did you reference the function correctly?`, vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn(`Method "${key}" has already been defined as a prop.`, vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                    `Avoid defining component methods that start with _ or $.`);
-            }
-        }
-        vm[key] =
-            typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (const key in watch) {
-        const handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (let i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === "string") {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    const dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    const propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    if (process.env.NODE_ENV !== "production") {
-        dataDef.set = function () {
-            warn("Avoid replacing instance root $data. " +
-                "Use nested data properties instead.", this);
-        };
-        propsDef.set = function () {
-            warn(`$props is readonly.`, this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, "$data", dataDef);
-    Object.defineProperty(Vue.prototype, "$props", propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        const vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        const watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            const info = `callback for immediate watcher "${watcher.expression}"`;
-            pushTarget();
-            invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
-}
-
-let uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        const vm = this;
-        // a uid
-        vm._uid = uid++;
-        let startTag, endTag;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = `vue-perf-start:${vm._uid}`;
-            endTag = `vue-perf-end:${vm._uid}`;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            initProxy(vm);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure(`vue ${vm._name} init`, startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    const opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    const parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    const vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function Vue(options) {
-    if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
-        warn("Vue is a constructor and should be called with the `new` keyword");
-    }
-    this._init(options);
-}
-//@ts-expect-error Vue has function type
-initMixin$1(Vue);
-//@ts-expect-error Vue has function type
-stateMixin(Vue);
-//@ts-expect-error Vue has function type
-eventsMixin(Vue);
-//@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
-//@ts-expect-error Vue has function type
-renderMixin(Vue);
-
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        const args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
-}
-
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
-}
-
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    let cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        const Super = this;
-        const SuperId = Super.cid;
-        const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        const name = extendOptions.name || Super.options.name;
-        if (process.env.NODE_ENV !== 'production' && name) {
-            validateComponentName(name);
-        }
-        const Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    const props = Comp.options.props;
-    for (const key in props) {
-        proxy(Comp.prototype, `_props`, key);
-    }
-}
-function initComputed(Comp) {
-    const computed = Comp.options.computed;
-    for (const key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
-}
-
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach((type) => {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (process.env.NODE_ENV !== 'production' && type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
-}
-
-/* @flow */
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === "string") {
-        return pattern.split(",").indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    const { cache, keys, _vnode } = keepAliveInstance;
-    for (const key in cache) {
-        const entry = cache[key];
-        if (entry) {
-            const name = entry.name;
-            if (name && !filter(name)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    const entry = cache[key];
-    if (entry && (!current || entry.tag !== current.tag)) {
-        // @ts-expect-error can be undefined
-        entry.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-const patternTypes = [String, RegExp, Array];
-// TODO defineComponent
-var KeepAlive = {
-    name: "keep-alive",
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    methods: {
-        cacheVNode() {
-            const { cache, keys, vnodeToCache, keyToCache } = this;
-            if (vnodeToCache) {
-                const { tag, componentInstance, componentOptions } = vnodeToCache;
-                cache[keyToCache] = {
-                    name: getComponentName(componentOptions),
-                    tag,
-                    componentInstance,
-                };
-                keys.push(keyToCache);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-                this.vnodeToCache = null;
-            }
-        },
-    },
-    created() {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed() {
-        for (const key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted() {
-        this.cacheVNode();
-        this.$watch("include", (val) => {
-            pruneCache(this, (name) => matches(val, name));
-        });
-        this.$watch("exclude", (val) => {
-            pruneCache(this, (name) => !matches(val, name));
-        });
-    },
-    updated() {
-        this.cacheVNode();
-    },
-    render() {
-        const slot = this.$slots.default;
-        const vnode = getFirstComponentChild(slot);
-        const componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            const name = getComponentName(componentOptions);
-            const { include, exclude } = this;
-            if (
-            // not included
-            (include && (!name || !matches(include, name))) ||
-                // excluded
-                (exclude && name && matches(exclude, name))) {
-                return vnode;
-            }
-            const { cache, keys } = this;
-            const key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                // delay setting the cache until update
-                this.vnodeToCache = vnode;
-                this.keyToCache = key;
-            }
-            // @ts-expect-error can vnode.data can be undefined
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
-};
-
-var builtInComponents = {
-    KeepAlive,
-};
-
-function initGlobalAPI(Vue) {
-    // config
-    const configDef = {};
-    configDef.get = () => config;
-    if (process.env.NODE_ENV !== 'production') {
-        configDef.set = () => {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn,
-        extend,
-        mergeOptions,
-        defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = (obj) => {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach((type) => {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
-}
-
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get() {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
-Vue.version = '2.6.14';
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-const isReservedAttr = makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const xlinkNS = 'http://www.w3.org/1999/xlink';
-const isXlink = (name) => {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-};
-const getXlinkProp = (name) => {
-    return isXlink(name) ? name.slice(6, name.length) : '';
-};
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
-};
-
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
-}
-
-const namespaceMap = {
-    svg: 'http://www.w3.org/2000/svg',
-    math: 'http://www.w3.org/1998/Math/MathML',
-};
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-const unknownElementCache = Object.create(null);
-function isUnknownElement(tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-        return true;
-    }
-    if (isReservedTag(tag)) {
-        return false;
-    }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-        return unknownElementCache[tag];
-    }
-    const el = document.createElement(tag);
-    if (tag.indexOf('-') > -1) {
-        // http://stackoverflow.com/a/28210364/1070244
-        return (unknownElementCache[tag] =
-            el.constructor === window.HTMLUnknownElement ||
-                el.constructor === window.HTMLElement);
-    }
-    else {
-        return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-    }
-}
-const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Query an element selector if it's not an element already.
- */
-function query(el) {
-    if (typeof el === 'string') {
-        const selected = document.querySelector(el);
-        if (!selected) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('Cannot find element: ' + el);
-            return document.createElement('div');
-        }
-        return selected;
-    }
-    else {
-        return el;
-    }
-}
-
-function createElement(tagName, vnode) {
-    const elm = document.createElement(tagName);
-    if (tagName !== 'select') {
-        return elm;
-    }
-    // false or null will remove the attribute but undefined will not
-    if (vnode.data &&
-        vnode.data.attrs &&
-        vnode.data.attrs.multiple !== undefined) {
-        elm.setAttribute('multiple', 'multiple');
-    }
-    return elm;
-}
-function createElementNS(namespace, tagName) {
-    return document.createElementNS(namespaceMap[namespace], tagName);
-}
-function createTextNode(text) {
-    return document.createTextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(parentNode, newNode, referenceNode) {
-    parentNode.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.tagName;
-}
-function setTextContent(node, text) {
-    node.textContent = text;
-}
-function setStyleScope(node, scopeId) {
-    node.setAttribute(scopeId, '');
-}
-
-var nodeOps = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createElement: createElement,
-  createElementNS: createElementNS,
-  createTextNode: createTextNode,
-  createComment: createComment,
-  insertBefore: insertBefore,
-  removeChild: removeChild,
-  appendChild: appendChild,
-  parentNode: parentNode,
-  nextSibling: nextSibling,
-  tagName: tagName,
-  setTextContent: setTextContent,
-  setStyleScope: setStyleScope
-});
-
-var ref = {
-    create(_, vnode) {
-        registerRef(vnode);
-    },
-    update(oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy(vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    const key = vnode.data.ref;
-    if (!isDef(key))
-        return;
-    const vm = vnode.context;
-    const ref = vnode.componentInstance || vnode.elm;
-    const refs = vm.$refs;
-    const obj = refs[key];
-    if (isRemoval) {
-        if (Array.isArray(obj)) {
-            remove$2(obj, ref);
-        }
-        else if (obj === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(obj)) {
-                refs[key] = [ref];
-            }
-            else if (obj.indexOf(ref) < 0) {
-                obj.push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
-}
-
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-const emptyNode = new VNode('', {}, []);
-const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        return true;
-    let i;
-    const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    let i, key;
-    const map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            map[key] = i;
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    let i, j;
-    const cbs = {};
-    const { modules, nodeOps } = backend;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        const parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some((ignore) => {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    let creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        const data = vnode.data;
-        const children = vnode.children;
-        const tag = vnode.tag;
-        if (isDef(tag)) {
-            if (process.env.NODE_ENV !== 'production') {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (isDef(data)) {
-                    invokeCreateHooks(vnode, insertedVnodeQueue);
-                }
-                insert(parentElm, vnode.elm, refElm);
-            }
-            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i = vnode.data;
-        if (isDef(i)) {
-            const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        let i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        let innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            if (process.env.NODE_ENV !== 'production') {
-                checkDuplicateKeys(children);
-            }
-            for (let i = 0; i < children.length; ++i) {
-                createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (let i = 0; i < cbs.create.length; ++i) {
-            cbs.create[i](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                i.create(emptyNode, vnode);
-            if (isDef(i.insert))
-                insertedVnodeQueue.push(vnode);
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        let i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            let ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        let i, j;
-        const data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                i(vnode);
-            for (i = 0; i < cbs.destroy.length; ++i)
-                cbs.destroy[i](vnode);
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            const ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            let i;
-            const listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i = vnode.componentInstance)) &&
-                isDef((i = i._vnode)) &&
-                isDef(i.data)) {
-                removeAndInvokeRemoveHook(i, rm);
-            }
-            for (i = 0; i < cbs.remove.length; ++i) {
-                cbs.remove[i](vnode, rm);
-            }
-            if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                i(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        let oldStartIdx = 0;
-        let newStartIdx = 0;
-        let oldEndIdx = oldCh.length - 1;
-        let oldStartVnode = oldCh[0];
-        let oldEndVnode = oldCh[oldEndIdx];
-        let newEndIdx = newCh.length - 1;
-        let newStartVnode = newCh[0];
-        let newEndVnode = newCh[newEndIdx];
-        let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        const canMove = !removeOnly;
-        if (process.env.NODE_ENV !== 'production') {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        const seenKeys = {};
-        for (let i = 0; i < children.length; i++) {
-            const vnode = children[i];
-            const key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (let i = start; i < end; i++) {
-            const c = oldCh[i];
-            if (isDef(c) && sameVnode(node, c))
-                return i;
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        const elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        let i;
-        const data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        const oldCh = oldVnode.children;
-        const ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                cbs.update[i](oldVnode, vnode);
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                i(oldVnode, vnode);
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-            }
-            else if (isDef(ch)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    nodeOps.setTextContent(elm, '');
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                i(oldVnode, vnode);
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (let i = 0; i < queue.length; ++i) {
-                queue[i].data.hook.insert(queue[i]);
-            }
-        }
-    }
-    let hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        let i;
-        const { tag, data, children } = vnode;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        if (process.env.NODE_ENV !== 'production') {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                i(vnode, true /* hydrating */);
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        let childrenMatch = true;
-                        let childNode = elm.firstChild;
-                        for (let i = 0; i < children.length; i++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                let fullInvoke = false;
-                for (const key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                invokeDestroyHook(oldVnode);
-            return;
-        }
-        let isInitialPatch = false;
-        const insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            const isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else if (process.env.NODE_ENV !== 'production') {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                const oldElm = oldVnode.elm;
-                const parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    let ancestor = vnode.parent;
-                    const patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (let i = 0; i < cbs.destroy.length; ++i) {
-                            cbs.destroy[i](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (let i = 0; i < cbs.create.length; ++i) {
-                                cbs.create[i](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            const insert = ancestor.data.hook.insert;
-                            if (insert.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (let i = 1; i < insert.fns.length; i++) {
-                                    insert.fns[i]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
-}
-
-var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    const isCreate = oldVnode === emptyNode;
-    const isDestroy = vnode === emptyNode;
-    const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    const dirsWithInsert = [];
-    const dirsWithPostpatch = [];
-    let key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        const callInsert = () => {
-            for (let i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', () => {
-            for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-const emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    const res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    let i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    const fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-        }
-    }
-}
-
-var baseModules = [ref, directives];
-
-function updateAttrs(oldVnode, vnode) {
-    const opts = vnode.componentOptions;
-    if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-        return;
-    }
-    if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-        return;
-    }
-    let key, cur, old;
-    const elm = vnode.elm;
-    const oldAttrs = oldVnode.data.attrs || {};
-    let attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(attrs.__ob__)) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            setAttr(elm, key, cur, vnode.data.pre);
-        }
-    }
-    // #4391: in IE9, setting type can reset value for input[type=radio]
-    // #6666: IE/Edge forces progress value down to 1 before setting a max
-    /* istanbul ignore if */
-    if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-        setAttr(elm, 'value', attrs.value);
-    }
-    for (key in oldAttrs) {
-        if (isUndef(attrs[key])) {
-            if (isXlink(key)) {
-                elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-            }
-            else if (!isEnumeratedAttr(key)) {
-                elm.removeAttribute(key);
-            }
-        }
-    }
-}
-function setAttr(el, key, value, isInPre) {
-    if (isInPre || el.tagName.indexOf('-') > -1) {
-        baseSetAttr(el, key, value);
-    }
-    else if (isBooleanAttr(key)) {
-        // set attribute for blank value
-        // e.g. <option disabled>Select one</option>
-        if (isFalsyAttrValue(value)) {
-            el.removeAttribute(key);
-        }
-        else {
-            // technically allowfullscreen is a boolean attribute for <iframe>,
-            // but Flash expects a value of "true" when used on <embed> tag
-            value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-            el.setAttribute(key, value);
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        el.setAttribute(key, convertEnumeratedValue(key, value));
-    }
-    else if (isXlink(key)) {
-        if (isFalsyAttrValue(value)) {
-            el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        }
-        else {
-            el.setAttributeNS(xlinkNS, key, value);
-        }
-    }
-    else {
-        baseSetAttr(el, key, value);
-    }
-}
-function baseSetAttr(el, key, value) {
-    if (isFalsyAttrValue(value)) {
-        el.removeAttribute(key);
-    }
-    else {
-        // #7138: IE10 & 11 fires input event when setting placeholder on
-        // <textarea>... block the first input event and remove the blocker
-        // immediately.
-        /* istanbul ignore if */
-        if (isIE &&
-            !isIE9 &&
-            el.tagName === 'TEXTAREA' &&
-            key === 'placeholder' &&
-            value !== '' &&
-            !el.__ieph) {
-            const blocker = (e) => {
-                e.stopImmediatePropagation();
-                el.removeEventListener('input', blocker);
-            };
-            el.addEventListener('input', blocker);
-            // $flow-disable-line
-            el.__ieph = true; /* IE placeholder patched */
-        }
-        el.setAttribute(key, value);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
-};
-
-function updateClass(oldVnode, vnode) {
-    const el = vnode.elm;
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticClass) &&
-        isUndef(data.class) &&
-        (isUndef(oldData) ||
-            (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-        return;
-    }
-    let cls = genClassForVnode(vnode);
-    // handle transition classes
-    const transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-        cls = concat(cls, stringifyClass(transitionClass));
-    }
-    // set the class
-    if (cls !== el._prevClass) {
-        el.setAttribute('class', cls);
-        el._prevClass = cls;
-    }
-}
-var klass = {
-    create: updateClass,
-    update: updateClass,
-};
-
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-const CHECKBOX_RADIO_TOKEN = '__c';
-
-// normalize v-model event tokens that can only be determined at runtime.
-// it's important to place the event as the first in the array because
-// the whole point is ensuring the v-model callback gets called before
-// user-attached handlers.
-function normalizeEvents(on) {
-    /* istanbul ignore if */
-    if (isDef(on[RANGE_TOKEN])) {
-        // IE input[type=range] only supports `change` event
-        const event = isIE ? 'change' : 'input';
-        on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-        delete on[RANGE_TOKEN];
-    }
-    // This was originally intended to fix #4521 but no longer necessary
-    // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-    /* istanbul ignore if */
-    if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-        on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-        delete on[CHECKBOX_RADIO_TOKEN];
-    }
-}
-let target;
-function createOnceHandler(event, handler, capture) {
-    const _target = target; // save current target element in closure
-    return function onceHandler() {
-        const res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-// implementation and does not fire microtasks in between event propagation, so
-// safe to exclude.
-const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-function add(name, handler, capture, passive) {
-    // async edge case #6566: inner click event triggers patch, event handler
-    // attached to outer element during patch, and triggered again. This
-    // happens because browsers fire microtask ticks between event propagation.
-    // the solution is simple: we save the timestamp when a handler is attached,
-    // and the handler would only fire if the event passed to it was fired
-    // AFTER it was attached.
-    if (useMicrotaskFix) {
-        const attachedTimestamp = currentFlushTimestamp;
-        const original = handler;
-        //@ts-expect-error 
-        handler = original._wrapper = function (e) {
-            if (
-            // no bubbling, should always fire.
-            // this is just a safety net in case event.timeStamp is unreliable in
-            // certain weird environments...
-            e.target === e.currentTarget ||
-                // event is fired after handler attachment
-                e.timeStamp >= attachedTimestamp ||
-                // bail for environments that have buggy event.timeStamp implementations
-                // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                // #9681 QtWebEngine event.timeStamp is negative value
-                e.timeStamp <= 0 ||
-                // #9448 bail if event is fired in another document in a multi-page
-                // electron/nw.js app, since event.timeStamp will be using a different
-                // starting reference
-                e.target.ownerDocument !== document) {
-                return original.apply(this, arguments);
-            }
-        };
-    }
-    target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-}
-function remove(name, handler, capture, _target) {
-    (_target || target).removeEventListener(name, 
-    //@ts-expect-error
-    handler._wrapper || handler, capture);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-        return;
-    }
-    const on = vnode.data.on || {};
-    const oldOn = oldVnode.data.on || {};
-    // vnode is empty when removing all listeners,
-    // and use old vnode dom element
-    target = vnode.elm || oldVnode.elm;
-    normalizeEvents(on);
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-    // @ts-expect-error emptyNode has actually data
-    destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-};
-
-let svgContainer;
-function updateDOMProps(oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-        return;
-    }
-    let key, cur;
-    const elm = vnode.elm;
-    const oldProps = oldVnode.data.domProps || {};
-    let props = vnode.data.domProps || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (isDef(props.__ob__)) {
-        props = vnode.data.domProps = extend({}, props);
-    }
-    for (key in oldProps) {
-        if (!(key in props)) {
-            elm[key] = '';
-        }
-    }
-    for (key in props) {
-        cur = props[key];
-        // ignore children if the node has textContent or innerHTML,
-        // as these will throw away existing DOM nodes and cause removal errors
-        // on subsequent patches (#3360)
-        if (key === 'textContent' || key === 'innerHTML') {
-            if (vnode.children)
-                vnode.children.length = 0;
-            if (cur === oldProps[key])
-                continue;
-            // #6601 work around Chrome version <= 55 bug where single textNode
-            // replaced by innerHTML/textContent retains its parentNode property
-            if (elm.childNodes.length === 1) {
-                elm.removeChild(elm.childNodes[0]);
-            }
-        }
-        if (key === 'value' && elm.tagName !== 'PROGRESS') {
-            // store value as _value as well since
-            // non-string values will be stringified
-            elm._value = cur;
-            // avoid resetting cursor position when value is the same
-            const strCur = isUndef(cur) ? '' : String(cur);
-            if (shouldUpdateValue(elm, strCur)) {
-                elm.value = strCur;
-            }
-        }
-        else if (key === 'innerHTML' &&
-            isSVG(elm.tagName) &&
-            isUndef(elm.innerHTML)) {
-            // IE doesn't support innerHTML for SVG elements
-            svgContainer = svgContainer || document.createElement('div');
-            svgContainer.innerHTML = `<svg>${cur}</svg>`;
-            const svg = svgContainer.firstChild;
-            while (elm.firstChild) {
-                elm.removeChild(elm.firstChild);
-            }
-            while (svg.firstChild) {
-                elm.appendChild(svg.firstChild);
-            }
-        }
-        else if (
-        // skip the update if old and new VDOM state is the same.
-        // `value` is handled separately because the DOM value may be temporarily
-        // out of sync with VDOM state due to focus, composition and modifiers.
-        // This  #4521 by skipping the unnecessary `checked` update.
-        cur !== oldProps[key]) {
-            // some property updates can throw
-            // e.g. `value` on <progress> w/ non-finite value
-            try {
-                elm[key] = cur;
-            }
-            catch (e) { }
-        }
-    }
-}
-function shouldUpdateValue(elm, checkVal) {
-    return (
-    //@ts-expect-error
-    !elm.composing &&
-        (elm.tagName === 'OPTION' ||
-            isNotInFocusAndDirty(elm, checkVal) ||
-            isDirtyWithModifiers(elm, checkVal)));
-}
-function isNotInFocusAndDirty(elm, checkVal) {
-    // return true when textbox (.number and .trim) loses focus and its value is
-    // not equal to the updated value
-    let notInFocus = true;
-    // #6157
-    // work around IE bug when accessing document.activeElement in an iframe
-    try {
-        notInFocus = document.activeElement !== elm;
-    }
-    catch (e) { }
-    return notInFocus && elm.value !== checkVal;
-}
-function isDirtyWithModifiers(elm, newVal) {
-    const value = elm.value;
-    const modifiers = elm._vModifiers; // injected by v-model runtime
-    if (isDef(modifiers)) {
-        if (modifiers.number) {
-            return toNumber(value) !== toNumber(newVal);
-        }
-        if (modifiers.trim) {
-            return value.trim() !== newVal.trim();
-        }
-    }
-    return value !== newVal;
-}
-var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps,
-};
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
-}
-
-const cssVarRE = /^--/;
-const importantRE = /\s*!important$/;
-const setProp = (el, name, val) => {
-    /* istanbul ignore if */
-    if (cssVarRE.test(name)) {
-        el.style.setProperty(name, val);
-    }
-    else if (importantRE.test(val)) {
-        el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-    }
-    else {
-        const normalizedName = normalize(name);
-        if (Array.isArray(val)) {
-            // Support values array created by autoprefixer, e.g.
-            // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-            // Set them one by one, and the browser will only set those it can recognize
-            for (let i = 0, len = val.length; i < len; i++) {
-                el.style[normalizedName] = val[i];
-            }
-        }
-        else {
-            el.style[normalizedName] = val;
-        }
-    }
-};
-const vendorNames = ['Webkit', 'Moz', 'ms'];
-let emptyStyle;
-const normalize = cached(function (prop) {
-    emptyStyle = emptyStyle || document.createElement('div').style;
-    prop = camelize(prop);
-    if (prop !== 'filter' && prop in emptyStyle) {
-        return prop;
-    }
-    const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-    for (let i = 0; i < vendorNames.length; i++) {
-        const name = vendorNames[i] + capName;
-        if (name in emptyStyle) {
-            return name;
-        }
-    }
-});
-function updateStyle(oldVnode, vnode) {
-    const data = vnode.data;
-    const oldData = oldVnode.data;
-    if (isUndef(data.staticStyle) &&
-        isUndef(data.style) &&
-        isUndef(oldData.staticStyle) &&
-        isUndef(oldData.style)) {
-        return;
-    }
-    let cur, name;
-    const el = vnode.elm;
-    const oldStaticStyle = oldData.staticStyle;
-    const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-    // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-    const oldStyle = oldStaticStyle || oldStyleBinding;
-    const style = normalizeStyleBinding(vnode.data.style) || {};
-    // store normalized style under a different key for next diff
-    // make sure to clone it if it's reactive, since the user likely wants
-    // to mutate it.
-    vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-    const newStyle = getStyle(vnode, true);
-    for (name in oldStyle) {
-        if (isUndef(newStyle[name])) {
-            setProp(el, name, '');
-        }
-    }
-    for (name in newStyle) {
-        cur = newStyle[name];
-        if (cur !== oldStyle[name]) {
-            // ie9 setting to null has no effect, must use empty string
-            setProp(el, name, cur == null ? '' : cur);
-        }
-    }
-}
-var style = {
-    create: updateStyle,
-    update: updateStyle,
-};
-
-const whitespaceRE = /\s+/;
-/**
- * Add class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function addClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
-        }
-        else {
-            el.classList.add(cls);
-        }
-    }
-    else {
-        const cur = ` ${el.getAttribute('class') || ''} `;
-        if (cur.indexOf(' ' + cls + ' ') < 0) {
-            el.setAttribute('class', (cur + cls).trim());
-        }
-    }
-}
-/**
- * Remove class with compatibility for SVG since classList is not supported on
- * SVG elements in IE
- */
-function removeClass(el, cls) {
-    /* istanbul ignore if */
-    if (!cls || !(cls = cls.trim())) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (el.classList) {
-        if (cls.indexOf(' ') > -1) {
-            cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
-        }
-        else {
-            el.classList.remove(cls);
-        }
-        if (!el.classList.length) {
-            el.removeAttribute('class');
-        }
-    }
-    else {
-        let cur = ` ${el.getAttribute('class') || ''} `;
-        const tar = ' ' + cls + ' ';
-        while (cur.indexOf(tar) >= 0) {
-            cur = cur.replace(tar, ' ');
-        }
-        cur = cur.trim();
-        if (cur) {
-            el.setAttribute('class', cur);
-        }
-        else {
-            el.removeAttribute('class');
-        }
-    }
-}
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        const res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-const autoCssTransition = cached((name) => {
-    return {
-        enterClass: `${name}-enter`,
-        enterToClass: `${name}-enter-to`,
-        enterActiveClass: `${name}-enter-active`,
-        leaveClass: `${name}-leave`,
-        leaveToClass: `${name}-leave-to`,
-        leaveActiveClass: `${name}-leave-active`,
-    };
-});
-const hasTransition = inBrowser && !isIE9;
-const TRANSITION = 'transition';
-const ANIMATION = 'animation';
-// Transition property/event sniffing
-let transitionProp = 'transition';
-let transitionEndEvent = 'transitionend';
-let animationProp = 'animation';
-let animationEndEvent = 'animationend';
-if (hasTransition) {
-    /* istanbul ignore if */
-    if (window.ontransitionend === undefined &&
-        window.onwebkittransitionend !== undefined) {
-        transitionProp = 'WebkitTransition';
-        transitionEndEvent = 'webkitTransitionEnd';
-    }
-    if (window.onanimationend === undefined &&
-        window.onwebkitanimationend !== undefined) {
-        animationProp = 'WebkitAnimation';
-        animationEndEvent = 'webkitAnimationEnd';
-    }
-}
-// binding to window is necessary to make hot reload work in IE in strict mode
-const raf = inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ (fn) => fn();
-function nextFrame(fn) {
-    raf(() => {
-        // @ts-expect-error
-        raf(fn);
-    });
-}
-function addTransitionClass(el, cls) {
-    const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-        transitionClasses.push(cls);
-        addClass(el, cls);
-    }
-}
-function removeTransitionClass(el, cls) {
-    if (el._transitionClasses) {
-        remove$2(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
-}
-function whenTransitionEnds(el, expectedType, cb) {
-    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-    if (!type)
-        return cb();
-    const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-    let ended = 0;
-    const end = () => {
-        el.removeEventListener(event, onEnd);
-        cb();
-    };
-    const onEnd = (e) => {
-        if (e.target === el) {
-            if (++ended >= propCount) {
-                end();
-            }
-        }
-    };
-    setTimeout(() => {
-        if (ended < propCount) {
-            end();
-        }
-    }, timeout + 1);
-    el.addEventListener(event, onEnd);
-}
-const transformRE = /\b(transform|all)(,|$)/;
-function getTransitionInfo(el, expectedType) {
-    const styles = window.getComputedStyle(el);
-    // JSDOM may return undefined for transition properties
-    const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-    const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-    const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-    const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-    const animationTimeout = getTimeout(animationDelays, animationDurations);
-    let type;
-    let timeout = 0;
-    let propCount = 0;
-    /* istanbul ignore if */
-    if (expectedType === TRANSITION) {
-        if (transitionTimeout > 0) {
-            type = TRANSITION;
-            timeout = transitionTimeout;
-            propCount = transitionDurations.length;
-        }
-    }
-    else if (expectedType === ANIMATION) {
-        if (animationTimeout > 0) {
-            type = ANIMATION;
-            timeout = animationTimeout;
-            propCount = animationDurations.length;
-        }
-    }
-    else {
-        timeout = Math.max(transitionTimeout, animationTimeout);
-        type =
-            timeout > 0
-                ? transitionTimeout > animationTimeout
-                    ? TRANSITION
-                    : ANIMATION
-                : null;
-        propCount = type
-            ? type === TRANSITION
-                ? transitionDurations.length
-                : animationDurations.length
-            : 0;
-    }
-    const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-    return {
-        type,
-        timeout,
-        propCount,
-        hasTransform,
-    };
-}
-function getTimeout(delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-        delays = delays.concat(delays);
-    }
-    return Math.max.apply(null, durations.map((d, i) => {
-        return toMs(d) + toMs(delays[i]);
-    }));
-}
-// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-// in a locale-dependent way, using a comma instead of a dot.
-// If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-// as a floor function) causing unexpected behaviors
-function toMs(s) {
-    return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-}
-
-function enter(vnode, toggleDisplay) {
-    const el = vnode.elm;
-    // call leave callback now
-    if (isDef(el._leaveCb)) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data)) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (isDef(el._enterCb) || el.nodeType !== 1) {
-        return;
-    }
-    const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-    // activeInstance will always be the <transition> component managing this
-    // transition. One edge case to check is when the <transition> is placed
-    // as the root node of a child component. In that case we need to check
-    // <transition>'s parent for appear check.
-    let context = activeInstance;
-    let transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        context = transitionNode.context;
-        transitionNode = transitionNode.parent;
-    }
-    const isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    const startClass = isAppear && appearClass ? appearClass : enterClass;
-    const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-    const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-    const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    const enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    const enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-    if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
-        checkDuration(explicitEnterDuration, 'enter', vnode);
-    }
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(enterHook);
-    const cb = (el._enterCb = once(() => {
-        if (expectsCSS) {
-            removeTransitionClass(el, toClass);
-            removeTransitionClass(el, activeClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, startClass);
-            }
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    if (!vnode.data.show) {
-        // remove pending leave element on enter by injecting an insert hook
-        mergeVNodeHook(vnode, 'insert', () => {
-            const parent = el.parentNode;
-            const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-            if (pendingNode &&
-                pendingNode.tag === vnode.tag &&
-                pendingNode.elm._leaveCb) {
-                pendingNode.elm._leaveCb();
-            }
-            enterHook && enterHook(el, cb);
-        });
-    }
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (expectsCSS) {
-        addTransitionClass(el, startClass);
-        addTransitionClass(el, activeClass);
-        nextFrame(() => {
-            removeTransitionClass(el, startClass);
-            // @ts-expect-error
-            if (!cb.cancelled) {
-                addTransitionClass(el, toClass);
-                if (!userWantsControl) {
-                    if (isValidDuration(explicitEnterDuration)) {
-                        setTimeout(cb, explicitEnterDuration);
-                    }
-                    else {
-                        whenTransitionEnds(el, type, cb);
-                    }
-                }
-            }
-        });
-    }
-    if (vnode.data.show) {
-        toggleDisplay && toggleDisplay();
-        enterHook && enterHook(el, cb);
-    }
-    if (!expectsCSS && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    const el = vnode.elm;
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    const data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-        return rm();
-    }
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-        return;
-    }
-    const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-    const expectsCSS = css !== false && !isIE9;
-    const userWantsControl = getHookArgumentsLength(leave);
-    const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-    if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
-        checkDuration(explicitLeaveDuration, 'leave', vnode);
-    }
-    const cb = (el._leaveCb = once(() => {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        if (expectsCSS) {
-            removeTransitionClass(el, leaveToClass);
-            removeTransitionClass(el, leaveActiveClass);
-        }
-        // @ts-expect-error
-        if (cb.cancelled) {
-            if (expectsCSS) {
-                removeTransitionClass(el, leaveClass);
-            }
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        // the delayed leave may have already been cancelled
-        // @ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show && el.parentNode) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (expectsCSS) {
-            addTransitionClass(el, leaveClass);
-            addTransitionClass(el, leaveActiveClass);
-            nextFrame(() => {
-                removeTransitionClass(el, leaveClass);
-                // @ts-expect-error
-                if (!cb.cancelled) {
-                    addTransitionClass(el, leaveToClass);
-                    if (!userWantsControl) {
-                        if (isValidDuration(explicitLeaveDuration)) {
-                            setTimeout(cb, explicitLeaveDuration);
-                        }
-                        else {
-                            whenTransitionEnds(el, type, cb);
-                        }
-                    }
-                }
-            });
-        }
-        leave && leave(el, cb);
-        if (!expectsCSS && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// only used in dev mode
-function checkDuration(val, name, vnode) {
-    if (typeof val !== 'number') {
-        warn(`<transition> explicit ${name} duration is not a valid number - ` +
-            `got ${JSON.stringify(val)}.`, vnode.context);
-    }
-    else if (isNaN(val)) {
-        warn(`<transition> explicit ${name} duration is NaN - ` +
-            'the duration expression might be incorrect.', vnode.context);
-    }
-}
-function isValidDuration(val) {
-    return typeof val === 'number' && !isNaN(val);
-}
-/**
- * Normalize a transition hook's argument length. The hook may be:
- * - a merged hook (invoker) with the original in .fns
- * - a wrapped component method (check ._length)
- * - a plain function (.length)
- */
-function getHookArgumentsLength(fn) {
-    if (isUndef(fn)) {
-        return false;
-    }
-    // @ts-expect-error
-    const invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-        // invoker
-        return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-    }
-    else {
-        // @ts-expect-error
-        return (fn._length || fn.length) > 1;
-    }
-}
-function _enter(_, vnode) {
-    if (vnode.data.show !== true) {
-        enter(vnode);
-    }
-}
-var transition = inBrowser
-    ? {
-        create: _enter,
-        activate: _enter,
-        remove(vnode, rm) {
-            /* istanbul ignore else */
-            if (vnode.data.show !== true) {
-                // @ts-expect-error
-                leave(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        },
-    }
-    : {};
-
-var platformModules = [attrs, klass, events, domProps, style, transition];
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules);
-const patch = createPatchFunction({ nodeOps, modules });
-
-/**
- * Not type checking this file because flow doesn't like attaching
- * properties to Elements.
- */
-/* istanbul ignore if */
-if (isIE9) {
-    // http://www.matts411.com/post/internet-explorer-9-oninput/
-    document.addEventListener('selectionchange', () => {
-        const el = document.activeElement;
-        // @ts-expect-error
-        if (el && el.vmodel) {
-            trigger(el, 'input');
-        }
-    });
-}
-const directive = {
-    inserted(el, binding, vnode, oldVnode) {
-        if (vnode.tag === 'select') {
-            // #6903
-            if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                mergeVNodeHook(vnode, 'postpatch', () => {
-                    directive.componentUpdated(el, binding, vnode);
-                });
-            }
-            else {
-                setSelected(el, binding, vnode.context);
-            }
-            el._vOptions = [].map.call(el.options, getValue);
-        }
-        else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-            el._vModifiers = binding.modifiers;
-            if (!binding.modifiers.lazy) {
-                el.addEventListener('compositionstart', onCompositionStart);
-                el.addEventListener('compositionend', onCompositionEnd);
-                // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                // switching focus before confirming composition choice
-                // this also fixes the issue where some browsers e.g. iOS Chrome
-                // fires "change" instead of "input" on autocomplete.
-                el.addEventListener('change', onCompositionEnd);
-                /* istanbul ignore if */
-                if (isIE9) {
-                    el.vmodel = true;
-                }
-            }
-        }
-    },
-    componentUpdated(el, binding, vnode) {
-        if (vnode.tag === 'select') {
-            setSelected(el, binding, vnode.context);
-            // in case the options rendered by v-for have changed,
-            // it's possible that the value is out-of-sync with the rendered options.
-            // detect such cases and filter out values that no longer has a matching
-            // option in the DOM.
-            const prevOptions = el._vOptions;
-            const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-            if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                // trigger change event if
-                // no matching option found for at least one value
-                const needReset = el.multiple
-                    ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                    : binding.value !== binding.oldValue &&
-                        hasNoMatchingOption(binding.value, curOptions);
-                if (needReset) {
-                    trigger(el, 'change');
-                }
-            }
-        }
-    },
-};
-function setSelected(el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-        setTimeout(() => {
-            actuallySetSelected(el, binding, vm);
-        }, 0);
-    }
-}
-function actuallySetSelected(el, binding, vm) {
-    const value = binding.value;
-    const isMultiple = el.multiple;
-    if (isMultiple && !Array.isArray(value)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn(`<select multiple v-model="${binding.expression}"> ` +
-                `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-        return;
-    }
-    let selected, option;
-    for (let i = 0, l = el.options.length; i < l; i++) {
-        option = el.options[i];
-        if (isMultiple) {
-            selected = looseIndexOf(value, getValue(option)) > -1;
-            if (option.selected !== selected) {
-                option.selected = selected;
-            }
-        }
-        else {
-            if (looseEqual(getValue(option), value)) {
-                if (el.selectedIndex !== i) {
-                    el.selectedIndex = i;
-                }
-                return;
-            }
-        }
-    }
-    if (!isMultiple) {
-        el.selectedIndex = -1;
-    }
-}
-function hasNoMatchingOption(value, options) {
-    return options.every((o) => !looseEqual(o, value));
-}
-function getValue(option) {
-    return '_value' in option ? option._value : option.value;
-}
-function onCompositionStart(e) {
-    e.target.composing = true;
-}
-function onCompositionEnd(e) {
-    // prevent triggering an input event for no reason
-    if (!e.target.composing)
-        return;
-    e.target.composing = false;
-    trigger(e.target, 'input');
-}
-function trigger(el, type) {
-    const e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
-}
-
-// recursively search for possible transition defined inside the component root
-function locateNode(vnode) {
-    // @ts-expect-error
-    return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-        ? locateNode(vnode.componentInstance._vnode)
-        : vnode;
-}
-var show = {
-    bind(el, { value }, vnode) {
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        const originalDisplay = (el.__vOriginalDisplay =
-            el.style.display === 'none' ? '' : el.style.display);
-        if (value && transition) {
-            vnode.data.show = true;
-            enter(vnode, () => {
-                el.style.display = originalDisplay;
-            });
-        }
-        else {
-            el.style.display = value ? originalDisplay : 'none';
-        }
-    },
-    update(el, { value, oldValue }, vnode) {
-        /* istanbul ignore if */
-        if (!value === !oldValue)
-            return;
-        vnode = locateNode(vnode);
-        const transition = vnode.data && vnode.data.transition;
-        if (transition) {
-            vnode.data.show = true;
-            if (value) {
-                enter(vnode, () => {
-                    el.style.display = el.__vOriginalDisplay;
-                });
-            }
-            else {
-                leave(vnode, () => {
-                    el.style.display = 'none';
-                });
-            }
-        }
-        else {
-            el.style.display = value ? el.__vOriginalDisplay : 'none';
-        }
-    },
-    unbind(el, binding, vnode, oldVnode, isDestroy) {
-        if (!isDestroy) {
-            el.style.display = el.__vOriginalDisplay;
-        }
-    },
-};
-
-var platformDirectives = {
-    model: directive,
-    show,
-};
-
-// Provides transition support for a single element/component.
-const transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    const compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    const data = {};
-    const options = comp.$options;
-    // props
-    for (const key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    const listeners = options._parentListeners;
-    for (const key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-const isVShowDirective = (d) => d.name === 'show';
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render(h) {
-        let children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        const mode = this.mode;
-        // warn invalid mode
-        if (process.env.NODE_ENV !== 'production' &&
-            mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        const rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        const child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        const id = `__transition-${this._uid}-`;
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        const oldRawChild = this._vnode;
-        const oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            const oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', () => {
-                    this._leaving = false;
-                    this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                let delayedLeave;
-                const performLeave = () => {
-                    delayedLeave();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                    delayedLeave = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
-};
-
-// Provides transition support for list items.
-const props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props,
-    beforeMount() {
-        const update = this._update;
-        this._update = (vnode, hydrating) => {
-            const restoreActiveInstance = setActiveInstance(this);
-            // force removing pass
-            this.__patch__(this._vnode, this.kept, false, // hydrating
-            true // removeOnly (!important, avoids unnecessary moves)
-            );
-            this._vnode = this.kept;
-            restoreActiveInstance();
-            update.call(this, vnode, hydrating);
-        };
-    },
-    render(h) {
-        const tag = this.tag || this.$vnode.data.tag || "span";
-        const map = Object.create(null);
-        const prevChildren = (this.prevChildren = this.children);
-        const rawChildren = this.$slots.default || [];
-        const children = (this.children = []);
-        const transitionData = extractTransitionData(this);
-        for (let i = 0; i < rawChildren.length; i++) {
-            const c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else if (process.env.NODE_ENV !== "production") {
-                    const opts = c.componentOptions;
-                    const name = opts
-                        ? opts.Ctor.options.name || opts.tag || ""
-                        : c.tag;
-                    warn(`<transition-group> children must be keyed: <${name}>`);
-                }
-            }
-        }
-        if (prevChildren) {
-            const kept = [];
-            const removed = [];
-            for (let i = 0; i < prevChildren.length; i++) {
-                const c = prevChildren[i];
-                c.data.transition = transitionData;
-                // @ts-expect-error .getBoundingClientRect is not typed in Node
-                c.data.pos = c.elm.getBoundingClientRect();
-                if (map[c.key]) {
-                    kept.push(c);
-                }
-                else {
-                    removed.push(c);
-                }
-            }
-            this.kept = h(tag, null, kept);
-            this.removed = removed;
-        }
-        return h(tag, null, children);
-    },
-    updated() {
-        const children = this.prevChildren;
-        const moveClass = this.moveClass || (this.name || "v") + "-move";
-        if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-            return;
-        }
-        // we divide the work into three loops to avoid mixing DOM reads and writes
-        // in each iteration - which helps prevent layout thrashing.
-        children.forEach(callPendingCbs);
-        children.forEach(recordPosition);
-        children.forEach(applyTranslation);
-        // force reflow to put everything in position
-        // assign to this to avoid being removed in tree-shaking
-        // $flow-disable-line
-        this._reflow = document.body.offsetHeight;
-        children.forEach((c) => {
-            if (c.data.moved) {
-                const el = c.elm;
-                const s = el.style;
-                addTransitionClass(el, moveClass);
-                s.transform = s.WebkitTransform = s.transitionDuration = "";
-                el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                    if (e && e.target !== el) {
-                        return;
-                    }
-                    if (!e || /transform$/.test(e.propertyName)) {
-                        el.removeEventListener(transitionEndEvent, cb);
-                        el._moveCb = null;
-                        removeTransitionClass(el, moveClass);
-                    }
-                }));
-            }
-        });
-    },
-    methods: {
-        hasMove(el, moveClass) {
-            /* istanbul ignore if */
-            if (!hasTransition) {
-                return false;
-            }
-            /* istanbul ignore if */
-            if (this._hasMove) {
-                return this._hasMove;
-            }
-            // Detect whether an element with the move class applied has
-            // CSS transitions. Since the element may be inside an entering
-            // transition at this very moment, we make a clone of it and remove
-            // all other transition classes applied to ensure only the move class
-            // is applied.
-            const clone = el.cloneNode();
-            if (el._transitionClasses) {
-                el._transitionClasses.forEach((cls) => {
-                    removeClass(clone, cls);
-                });
-            }
-            addClass(clone, moveClass);
-            clone.style.display = "none";
-            this.$el.appendChild(clone);
-            const info = getTransitionInfo(clone);
-            this.$el.removeChild(clone);
-            return (this._hasMove = info.hasTransform);
-        },
-    },
-};
-function callPendingCbs(c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-        c.elm._moveCb();
-    }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-        c.elm._enterCb();
-    }
-}
-function recordPosition(c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
-}
-function applyTranslation(c) {
-    const oldPos = c.data.pos;
-    const newPos = c.data.newPos;
-    const dx = oldPos.left - newPos.left;
-    const dy = oldPos.top - newPos.top;
-    if (dx || dy) {
-        c.data.moved = true;
-        const s = c.elm.style;
-        s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-        s.transitionDuration = "0s";
-    }
-}
-
-var platformComponents = {
-    Transition,
-    TransitionGroup,
-};
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isReservedAttr = isReservedAttr;
-Vue.config.getTagNamespace = getTagNamespace;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives & components
-extend(Vue.options.directives, platformDirectives);
-extend(Vue.options.components, platformComponents);
-// install platform patch function
-Vue.prototype.__patch__ = inBrowser ? patch : noop;
-// public mount method
-Vue.prototype.$mount = function (el, hydrating) {
-    el = el && inBrowser ? query(el) : undefined;
-    return mountComponent(this, el, hydrating);
-};
-// devtools global hook
-/* istanbul ignore next */
-if (inBrowser) {
-    setTimeout(() => {
-        if (config.devtools) {
-            if (devtools) {
-                devtools.emit('init', Vue);
-            }
-            else if (process.env.NODE_ENV !== 'production' &&
-                process.env.NODE_ENV !== 'test') {
-                // @ts-expect-error
-                console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                    'https://github.com/vuejs/vue-devtools');
-            }
-        }
-        if (process.env.NODE_ENV !== 'production' &&
-            process.env.NODE_ENV !== 'test' &&
-            config.productionTip !== false &&
-            typeof console !== 'undefined') {
-            // @ts-expect-error
-            console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                `Make sure to turn on production mode when deploying for production.\n` +
-                `See more tips at https://vuejs.org/guide/deployment.html`);
-        }
-    }, 0);
-}
-
-export { Vue as default };
diff --git a/dist/vue.runtime.js b/dist/vue.runtime.js
deleted file mode 100644
index bdf6b208b4d..00000000000
--- a/dist/vue.runtime.js
+++ /dev/null
@@ -1,7410 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Vue = factory());
-})(this, (function () { 'use strict';
-
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  function isRegExp(v) {
-      return _toString.call(v) === '[object RegExp]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$2(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Simple bind polyfill for environments that do not support it,
-   * e.g., PhantomJS 1.x. Technically, we don't need this anymore
-   * since native bind is now performant enough in most browsers.
-   * But removing it would mean breaking code that was able to run in
-   * PhantomJS 1.x, so this must be kept for backward compatibility.
-   */
-  /* istanbul ignore next */
-  function polyfillBind(fn, ctx) {
-      function boundFn(a) {
-          const l = arguments.length;
-          return l
-              ? l > 1
-                  ? fn.apply(ctx, arguments)
-                  : fn.call(ctx, a)
-              : fn.call(ctx);
-      }
-      boundFn._length = fn.length;
-      return boundFn;
-  }
-  function nativeBind(fn, ctx) {
-      return fn.bind(ctx);
-  }
-  // @ts-expect-error bind cannot be `undefined`
-  const bind = Function.prototype.bind ? nativeBind : polyfillBind;
-  /**
-   * Convert an Array-like object to a real Array.
-   */
-  function toArray(list, start) {
-      start = start || 0;
-      let i = list.length - start;
-      const ret = new Array(i);
-      while (i--) {
-          ret[i] = list[i + start];
-      }
-      return ret;
-  }
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-  /**
-   * Ensure a function is called only once.
-   */
-  function once(fn) {
-      let called = false;
-      return function () {
-          if (!called) {
-              called = true;
-              fn.apply(this, arguments);
-          }
-      };
-  }
-
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
-  ];
-
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
-  };
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Check if a string starts with $ or _
-   */
-  function isReserved(str) {
-      const c = (str + '').charCodeAt(0);
-      return c === 0x24 || c === 0x5f;
-  }
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-  /**
-   * Parse simple path.
-   */
-  const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`);
-  function parsePath(path) {
-      if (bailRE.test(path)) {
-          return;
-      }
-      const segments = path.split('.');
-      return function (obj) {
-          for (let i = 0; i < segments.length; i++) {
-              if (!obj)
-                  return;
-              obj = obj[segments[i]];
-          }
-          return obj;
-      };
-  }
-
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  const isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  const isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  const isFF = UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
-  };
-  // detect devtools
-  const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
-  }
-
-  let warn = noop;
-  let tip = noop;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (config.warnHandler) {
-              config.warnHandler.call(null, msg, vm, trace);
-          }
-          else if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
-  }
-
-  let uid$2 = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid$2++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$2(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          if (!config.async) {
-              // subs aren't sorted in scheduler if not running async
-              // we need to sort them now to make sure they fire in correct
-              // order
-              subs.sort((a, b) => a.id - b.id);
-          }
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
-  }
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
-  });
-
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Delete a property and trigger change if necessary.
-   */
-  function del(target, key) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.splice(key, 1);
-          return;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                  '- just set it to null.');
-          return;
-      }
-      if (!hasOwn(target, key)) {
-          return;
-      }
-      delete target[key];
-      if (!ob) {
-          return;
-      }
-      ob.dep.notify();
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
-  });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives$1(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives$1(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
-  }
-
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
-  }
-
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      if (config.errorHandler) {
-          try {
-              return config.errorHandler.call(null, err, vm, info);
-          }
-          catch (e) {
-              // if the user intentionally throws the original error in the handler,
-              // do not log it twice
-              if (e !== err) {
-                  logError(e, null, 'config.errorHandler');
-              }
-          }
-      }
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
-  }
-
-  /* globals MutationObserver */
-  let isUsingMicroTask = false;
-  const callbacks = [];
-  let pending = false;
-  function flushCallbacks() {
-      pending = false;
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // Here we have async deferring wrappers using microtasks.
-  // In 2.5 we used (macro) tasks (in combination with microtasks).
-  // However, it has subtle problems when state is changed right before repaint
-  // (e.g. #6813, out-in transitions).
-  // Also, using (macro) tasks in event handler would cause some weird behaviors
-  // that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-  // So we now use microtasks everywhere, again.
-  // A major drawback of this tradeoff is that there are some scenarios
-  // where microtasks have too high a priority and fire in between supposedly
-  // sequential events (e.g. #4521, #6690, which have workarounds)
-  // or even between bubbling of the same event (#6566).
-  let timerFunc;
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      const p = Promise.resolve();
-      timerFunc = () => {
-          p.then(flushCallbacks);
-          // In problematic UIWebViews, Promise.then doesn't completely break, but
-          // it can get stuck in a weird state where callbacks are pushed into the
-          // microtask queue but the queue isn't being flushed, until the browser
-          // needs to do some other work, e.g. handle a timer. Therefore we can
-          // "force" the microtask queue to be flushed by adding an empty timer.
-          if (isIOS)
-              setTimeout(noop);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-      timerFunc = () => {
-          counter = (counter + 1) % 2;
-          textNode.data = String(counter);
-      };
-      isUsingMicroTask = true;
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-      // Fallback to setImmediate.
-      // Technically it leverages the (macro) task queue,
-      // but it is still a better choice than setTimeout.
-      timerFunc = () => {
-          setImmediate(flushCallbacks);
-      };
-  }
-  else {
-      // Fallback to setTimeout.
-      timerFunc = () => {
-          setTimeout(flushCallbacks, 0);
-      };
-  }
-  function nextTick(cb, ctx) {
-      let _resolve;
-      callbacks.push(() => {
-          if (cb) {
-              try {
-                  cb.call(ctx);
-              }
-              catch (e) {
-                  handleError(e, ctx, 'nextTick');
-              }
-          }
-          else if (_resolve) {
-              _resolve(ctx);
-          }
-      });
-      if (!pending) {
-          pending = true;
-          timerFunc();
-      }
-      // $flow-disable-line
-      if (!cb && typeof Promise !== 'undefined') {
-          return new Promise((resolve) => {
-              _resolve = resolve;
-          });
-      }
-  }
-
-  /* not type checking this file because flow doesn't play well with Proxy */
-  let initProxy;
-  {
-      const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const warnNonPresent = (target, key) => {
-          warn(`Property or method "${key}" is not defined on the instance but ` +
-              'referenced during render. Make sure that this property is reactive, ' +
-              'either in the data option, or for class-based components, by ' +
-              'initializing the property. ' +
-              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-      };
-      const warnReservedPrefix = (target, key) => {
-          warn(`Property "${key}" must be accessed with "$data.${key}" because ` +
-              'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-              'prevent conflicts with Vue internals. ' +
-              'See: https://vuejs.org/v2/api/#data', target);
-      };
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-      const hasHandler = {
-          has(target, key) {
-              const has = key in target;
-              const isAllowed = allowedGlobals(key) ||
-                  (typeof key === 'string' &&
-                      key.charAt(0) === '_' &&
-                      !(key in target.$data));
-              if (!has && !isAllowed) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return has || !isAllowed;
-          },
-      };
-      const getHandler = {
-          get(target, key) {
-              if (typeof key === 'string' && !(key in target)) {
-                  if (key in target.$data)
-                      warnReservedPrefix(target, key);
-                  else
-                      warnNonPresent(target, key);
-              }
-              return target[key];
-          },
-      };
-      initProxy = function initProxy(vm) {
-          if (hasProxy) {
-              // determine which proxy handler to use
-              const options = vm.$options;
-              const handlers = options.render && options.render._withStripped ? getHandler : hasHandler;
-              vm._renderProxy = new Proxy(vm, handlers);
-          }
-          else {
-              vm._renderProxy = vm;
-          }
-      };
-  }
-
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
-  }
-
-  let mark;
-  let measure;
-  {
-      const perf = inBrowser && window.performance;
-      /* istanbul ignore if */
-      if (perf &&
-          perf.mark &&
-          perf.measure &&
-          perf.clearMarks &&
-          perf.clearMeasures) {
-          mark = (tag) => perf.mark(tag);
-          measure = (name, startTag, endTag) => {
-              perf.measure(name, startTag, endTag);
-              perf.clearMarks(startTag);
-              perf.clearMarks(endTag);
-              // perf.clearMeasures(name)
-          };
-      }
-  }
-
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
-  }
-
-  function mergeVNodeHook(def, hookKey, hook) {
-      if (def instanceof VNode) {
-          def = def.data.hook || (def.data.hook = {});
-      }
-      let invoker;
-      const oldHook = def[hookKey];
-      function wrappedHook() {
-          hook.apply(this, arguments);
-          // important: remove merged hook to ensure it's called only once
-          // and prevent memory leak
-          remove$2(invoker.fns, wrappedHook);
-      }
-      if (isUndef(oldHook)) {
-          // no existing hook
-          invoker = createFnInvoker([wrappedHook]);
-      }
-      else {
-          /* istanbul ignore if */
-          if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-              // already a merged invoker
-              invoker = oldHook;
-              invoker.fns.push(wrappedHook);
-          }
-          else {
-              // existing plain hook
-              invoker = createFnInvoker([oldHook, wrappedHook]);
-          }
-      }
-      invoker.merged = true;
-      def[hookKey] = invoker;
-  }
-
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
-  }
-
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
-  }
-
-  function initProvide(vm) {
-      const provide = vm.$options.provide;
-      if (provide) {
-          vm._provided =
-              typeof provide === 'function'
-                  ? // @ts-expect-error typing not correct
-                      provide.call(vm)
-                  : provide;
-      }
-  }
-  function initInjections(vm) {
-      const result = resolveInject(vm.$options.inject, vm);
-      if (result) {
-          toggleObserving(false);
-          Object.keys(result).forEach((key) => {
-              /* istanbul ignore else */
-              {
-                  defineReactive(vm, key, result[key], () => {
-                      warn(`Avoid mutating an injected value directly since the changes will be ` +
-                          `overwritten whenever the provided component re-renders. ` +
-                          `injection being mutated: "${key}"`, vm);
-                  });
-              }
-          });
-          toggleObserving(true);
-      }
-  }
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
-  }
-
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
-  }
-
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
-  }
-
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
-  }
-
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
-  }
-
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
-  }
-
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
-  }
-
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
-  }
-
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
-  }
-
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
-  }
-
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
-  }
-
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement$1(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
-  }
-
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook$1(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
-  }
-
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if (config.isReservedTag(tag)) {
-              // platform built-in elements
-              if (isDef(data) &&
-                  isDef(data.nativeOn) &&
-                  data.tag !== 'component') {
-                  warn(`The .native modifier for v-on is only valid on components but it was used on <${tag}>.`, context);
-              }
-              vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-          }
-          else if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
-  }
-
-  function initRender(vm) {
-      vm._vnode = null; // the root of the child tree
-      vm._staticTrees = null; // v-once cached trees
-      const options = vm.$options;
-      const parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-      const renderContext = parentVnode && parentVnode.context;
-      vm.$slots = resolveSlots(options._renderChildren, renderContext);
-      vm.$scopedSlots = emptyObject;
-      // bind the createElement fn to this instance
-      // so that we get proper render context inside it.
-      // args order: tag, data, children, normalizationType, alwaysNormalize
-      // internal version is used by render functions compiled from templates
-      // @ts-expect-error
-      vm._c = (a, b, c, d) => createElement$1(vm, a, b, c, d, false);
-      // normalization is always applied for the public version, used in
-      // user-written render functions.
-      // @ts-expect-error
-      vm.$createElement = (a, b, c, d) => createElement$1(vm, a, b, c, d, true);
-      // $attrs & $listeners are exposed for easier HOC creation.
-      // they need to be reactive so that HOCs using them are always updated
-      const parentData = parentVnode && parentVnode.data;
-      /* istanbul ignore else */
-      {
-          defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, () => {
-              !isUpdatingChildComponent && warn(`$attrs is readonly.`, vm);
-          }, true);
-          defineReactive(vm, '$listeners', options._parentListeners || emptyObject, () => {
-              !isUpdatingChildComponent && warn(`$listeners is readonly.`, vm);
-          }, true);
-      }
-  }
-  let currentRenderingInstance = null;
-  function renderMixin(Vue) {
-      // install runtime convenience helpers
-      installRenderHelpers(Vue.prototype);
-      Vue.prototype.$nextTick = function (fn) {
-          return nextTick(fn, this);
-      };
-      Vue.prototype._render = function () {
-          const vm = this;
-          const { render, _parentVnode } = vm.$options;
-          if (_parentVnode) {
-              vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-          }
-          // set parent vnode. this allows render functions to have access
-          // to the data on the placeholder node.
-          vm.$vnode = _parentVnode;
-          // render self
-          let vnode;
-          try {
-              // There's no need to maintain a stack because all render fns are called
-              // separately from one another. Nested component's render fns are called
-              // when parent component is patched.
-              currentRenderingInstance = vm;
-              vnode = render.call(vm._renderProxy, vm.$createElement);
-          }
-          catch (e) {
-              handleError(e, vm, `render`);
-              // return error render result,
-              // or previous vnode to prevent render error causing blank component
-              /* istanbul ignore else */
-              if (vm.$options.renderError) {
-                  try {
-                      vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                  }
-                  catch (e) {
-                      handleError(e, vm, `renderError`);
-                      vnode = vm._vnode;
-                  }
-              }
-              else {
-                  vnode = vm._vnode;
-              }
-          }
-          finally {
-              currentRenderingInstance = null;
-          }
-          // if the returned array contains only a single node, allow it
-          if (Array.isArray(vnode) && vnode.length === 1) {
-              vnode = vnode[0];
-          }
-          // return empty vnode in case the render function errored out
-          if (!(vnode instanceof VNode)) {
-              if (Array.isArray(vnode)) {
-                  warn('Multiple root nodes returned from render function. Render function ' +
-                      'should return a single root node.', vm);
-              }
-              vnode = createEmptyVNode();
-          }
-          // set parent
-          vnode.parent = _parentVnode;
-          return vnode;
-      };
-  }
-
-  function ensureCtor(comp, base) {
-      if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-          comp = comp.default;
-      }
-      return isObject(comp) ? base.extend(comp) : comp;
-  }
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      const owner = currentRenderingInstance;
-      if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-          // already pending
-          factory.owners.push(owner);
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-      if (owner && !isDef(factory.owners)) {
-          const owners = (factory.owners = [owner]);
-          let sync = true;
-          let timerLoading = null;
-          let timerTimeout = null;
-          owner.$on('hook:destroyed', () => remove$2(owners, owner));
-          const forceRender = (renderCompleted) => {
-              for (let i = 0, l = owners.length; i < l; i++) {
-                  owners[i].$forceUpdate();
-              }
-              if (renderCompleted) {
-                  owners.length = 0;
-                  if (timerLoading !== null) {
-                      clearTimeout(timerLoading);
-                      timerLoading = null;
-                  }
-                  if (timerTimeout !== null) {
-                      clearTimeout(timerTimeout);
-                      timerTimeout = null;
-                  }
-              }
-          };
-          const resolve = once((res) => {
-              // cache resolved
-              factory.resolved = ensureCtor(res, baseCtor);
-              // invoke callbacks only if this is not a synchronous resolve
-              // (async resolves are shimmed as synchronous during SSR)
-              if (!sync) {
-                  forceRender(true);
-              }
-              else {
-                  owners.length = 0;
-              }
-          });
-          const reject = once((reason) => {
-              warn(`Failed to resolve async component: ${String(factory)}` +
-                      (reason ? `\nReason: ${reason}` : ''));
-              if (isDef(factory.errorComp)) {
-                  factory.error = true;
-                  forceRender(true);
-              }
-          });
-          const res = factory(resolve, reject);
-          if (isObject(res)) {
-              if (isPromise(res)) {
-                  // () => Promise
-                  if (isUndef(factory.resolved)) {
-                      res.then(resolve, reject);
-                  }
-              }
-              else if (isPromise(res.component)) {
-                  res.component.then(resolve, reject);
-                  if (isDef(res.error)) {
-                      factory.errorComp = ensureCtor(res.error, baseCtor);
-                  }
-                  if (isDef(res.loading)) {
-                      factory.loadingComp = ensureCtor(res.loading, baseCtor);
-                      if (res.delay === 0) {
-                          factory.loading = true;
-                      }
-                      else {
-                          // @ts-expect-error NodeJS timeout type
-                          timerLoading = setTimeout(() => {
-                              timerLoading = null;
-                              if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                  factory.loading = true;
-                                  forceRender(false);
-                              }
-                          }, res.delay || 200);
-                      }
-                  }
-                  if (isDef(res.timeout)) {
-                      // @ts-expect-error NodeJS timeout type
-                      timerTimeout = setTimeout(() => {
-                          timerTimeout = null;
-                          if (isUndef(factory.resolved)) {
-                              reject(`timeout (${res.timeout}ms)`
-                                  );
-                          }
-                      }, res.timeout);
-                  }
-              }
-          }
-          sync = false;
-          // return in case resolved synchronously
-          return factory.loading ? factory.loadingComp : factory.resolved;
-      }
-  }
-
-  function getFirstComponentChild(children) {
-      if (Array.isArray(children)) {
-          for (let i = 0; i < children.length; i++) {
-              const c = children[i];
-              if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                  return c;
-              }
-          }
-      }
-  }
-
-  function initEvents(vm) {
-      vm._events = Object.create(null);
-      vm._hasHookEvent = false;
-      // init parent attached events
-      const listeners = vm.$options._parentListeners;
-      if (listeners) {
-          updateComponentListeners(vm, listeners);
-      }
-  }
-  let target$1;
-  function add$1(event, fn) {
-      target$1.$on(event, fn);
-  }
-  function remove$1(event, fn) {
-      target$1.$off(event, fn);
-  }
-  function createOnceHandler$1(event, fn) {
-      const _target = target$1;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target$1 = vm;
-      updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-      target$1 = undefined;
-  }
-  function eventsMixin(Vue) {
-      const hookRE = /^hook:/;
-      Vue.prototype.$on = function (event, fn) {
-          const vm = this;
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$on(event[i], fn);
-              }
-          }
-          else {
-              (vm._events[event] || (vm._events[event] = [])).push(fn);
-              // optimize hook:event cost by using a boolean flag marked at registration
-              // instead of a hash lookup
-              if (hookRE.test(event)) {
-                  vm._hasHookEvent = true;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$once = function (event, fn) {
-          const vm = this;
-          function on() {
-              vm.$off(event, on);
-              fn.apply(vm, arguments);
-          }
-          on.fn = fn;
-          vm.$on(event, on);
-          return vm;
-      };
-      Vue.prototype.$off = function (event, fn) {
-          const vm = this;
-          // all
-          if (!arguments.length) {
-              vm._events = Object.create(null);
-              return vm;
-          }
-          // array of events
-          if (Array.isArray(event)) {
-              for (let i = 0, l = event.length; i < l; i++) {
-                  vm.$off(event[i], fn);
-              }
-              return vm;
-          }
-          // specific event
-          const cbs = vm._events[event];
-          if (!cbs) {
-              return vm;
-          }
-          if (!fn) {
-              vm._events[event] = null;
-              return vm;
-          }
-          // specific handler
-          let cb;
-          let i = cbs.length;
-          while (i--) {
-              cb = cbs[i];
-              if (cb === fn || cb.fn === fn) {
-                  cbs.splice(i, 1);
-                  break;
-              }
-          }
-          return vm;
-      };
-      Vue.prototype.$emit = function (event) {
-          const vm = this;
-          {
-              const lowerCaseEvent = event.toLowerCase();
-              if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                  tip(`Event "${lowerCaseEvent}" is emitted in component ` +
-                      `${formatComponentName(vm)} but the handler is registered for "${event}". ` +
-                      `Note that HTML attributes are case-insensitive and you cannot use ` +
-                      `v-on to listen to camelCase events when using in-DOM templates. ` +
-                      `You should probably use "${hyphenate(event)}" instead of "${event}".`);
-              }
-          }
-          let cbs = vm._events[event];
-          if (cbs) {
-              cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-              const args = toArray(arguments, 1);
-              const info = `event handler for "${event}"`;
-              for (let i = 0, l = cbs.length; i < l; i++) {
-                  invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-              }
-          }
-          return vm;
-      };
-  }
-
-  let activeInstance = null;
-  let isUpdatingChildComponent = false;
-  function setActiveInstance(vm) {
-      const prevActiveInstance = activeInstance;
-      activeInstance = vm;
-      return () => {
-          activeInstance = prevActiveInstance;
-      };
-  }
-  function initLifecycle(vm) {
-      const options = vm.$options;
-      // locate first non-abstract parent
-      let parent = options.parent;
-      if (parent && !options.abstract) {
-          while (parent.$options.abstract && parent.$parent) {
-              parent = parent.$parent;
-          }
-          parent.$children.push(vm);
-      }
-      vm.$parent = parent;
-      vm.$root = parent ? parent.$root : vm;
-      vm.$children = [];
-      vm.$refs = {};
-      vm._watcher = null;
-      vm._inactive = null;
-      vm._directInactive = false;
-      vm._isMounted = false;
-      vm._isDestroyed = false;
-      vm._isBeingDestroyed = false;
-  }
-  function lifecycleMixin(Vue) {
-      Vue.prototype._update = function (vnode, hydrating) {
-          const vm = this;
-          const prevEl = vm.$el;
-          const prevVnode = vm._vnode;
-          const restoreActiveInstance = setActiveInstance(vm);
-          vm._vnode = vnode;
-          // Vue.prototype.__patch__ is injected in entry points
-          // based on the rendering backend used.
-          if (!prevVnode) {
-              // initial render
-              vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-          }
-          else {
-              // updates
-              vm.$el = vm.__patch__(prevVnode, vnode);
-          }
-          restoreActiveInstance();
-          // update __vue__ reference
-          if (prevEl) {
-              prevEl.__vue__ = null;
-          }
-          if (vm.$el) {
-              vm.$el.__vue__ = vm;
-          }
-          // if parent is an HOC, update its $el as well
-          if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-              vm.$parent.$el = vm.$el;
-          }
-          // updated hook is called by the scheduler to ensure that children are
-          // updated in a parent's updated hook.
-      };
-      Vue.prototype.$forceUpdate = function () {
-          const vm = this;
-          if (vm._watcher) {
-              vm._watcher.update();
-          }
-      };
-      Vue.prototype.$destroy = function () {
-          const vm = this;
-          if (vm._isBeingDestroyed) {
-              return;
-          }
-          callHook$1(vm, "beforeDestroy");
-          vm._isBeingDestroyed = true;
-          // remove self from parent
-          const parent = vm.$parent;
-          if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-              remove$2(parent.$children, vm);
-          }
-          // teardown watchers
-          if (vm._watcher) {
-              vm._watcher.teardown();
-          }
-          let i = vm._watchers.length;
-          while (i--) {
-              vm._watchers[i].teardown();
-          }
-          // remove reference from data ob
-          // frozen object may not have observer.
-          if (vm._data.__ob__) {
-              vm._data.__ob__.vmCount--;
-          }
-          // call the last hook...
-          vm._isDestroyed = true;
-          // invoke destroy hooks on current rendered tree
-          vm.__patch__(vm._vnode, null);
-          // fire destroyed hook
-          callHook$1(vm, "destroyed");
-          // turn off all instance listeners.
-          vm.$off();
-          // remove __vue__ reference
-          if (vm.$el) {
-              vm.$el.__vue__ = null;
-          }
-          // release circular reference (#6759)
-          if (vm.$vnode) {
-              vm.$vnode.parent = null;
-          }
-      };
-  }
-  function mountComponent(vm, el, hydrating) {
-      vm.$el = el;
-      if (!vm.$options.render) {
-          // @ts-expect-error invalid type
-          vm.$options.render = createEmptyVNode;
-          {
-              /* istanbul ignore if */
-              if ((vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
-                  vm.$options.el ||
-                  el) {
-                  warn("You are using the runtime-only build of Vue where the template " +
-                      "compiler is not available. Either pre-compile the templates into " +
-                      "render functions, or use the compiler-included build.", vm);
-              }
-              else {
-                  warn("Failed to mount component: template or render function not defined.", vm);
-              }
-          }
-      }
-      callHook$1(vm, "beforeMount");
-      let updateComponent;
-      /* istanbul ignore if */
-      if (config.performance && mark) {
-          updateComponent = () => {
-              const name = vm._name;
-              const id = vm._uid;
-              const startTag = `vue-perf-start:${id}`;
-              const endTag = `vue-perf-end:${id}`;
-              mark(startTag);
-              const vnode = vm._render();
-              mark(endTag);
-              measure(`vue ${name} render`, startTag, endTag);
-              mark(startTag);
-              vm._update(vnode, hydrating);
-              mark(endTag);
-              measure(`vue ${name} patch`, startTag, endTag);
-          };
-      }
-      else {
-          updateComponent = () => {
-              vm._update(vm._render(), hydrating);
-          };
-      }
-      // we set this to vm._watcher inside the watcher's constructor
-      // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-      // component's mounted hook), which relies on vm._watcher being already defined
-      new Watcher(vm, updateComponent, noop, {
-          before() {
-              if (vm._isMounted && !vm._isDestroyed) {
-                  callHook$1(vm, "beforeUpdate");
-              }
-          },
-      }, true /* isRenderWatcher */);
-      hydrating = false;
-      // manually mounted instance, call mounted on self
-      // mounted is called for render-created child components in its inserted hook
-      if (vm.$vnode == null) {
-          vm._isMounted = true;
-          callHook$1(vm, "mounted");
-      }
-      return vm;
-  }
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      {
-          isUpdatingChildComponent = true;
-      }
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-      {
-          isUpdatingChildComponent = false;
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook$1(vm, "deactivated");
-      }
-  }
-  function callHook$1(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
-  }
-
-  const MAX_UPDATE_COUNT = 100;
-  const queue = [];
-  const activatedChildren = [];
-  let has = {};
-  let circular = {};
-  let waiting = false;
-  let flushing = false;
-  let index = 0;
-  /**
-   * Reset the scheduler's state.
-   */
-  function resetSchedulerState() {
-      index = queue.length = activatedChildren.length = 0;
-      has = {};
-      {
-          circular = {};
-      }
-      waiting = flushing = false;
-  }
-  // Async edge case #6566 requires saving the timestamp when event listeners are
-  // attached. However, calling performance.now() has a perf overhead especially
-  // if the page has thousands of event listeners. Instead, we take a timestamp
-  // every time the scheduler flushes and use that for all event listeners
-  // attached during that flush.
-  let currentFlushTimestamp = 0;
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Flush both queues and run the watchers.
-   */
-  function flushSchedulerQueue() {
-      currentFlushTimestamp = getNow();
-      flushing = true;
-      let watcher, id;
-      // Sort queue before flush.
-      // This ensures that:
-      // 1. Components are updated from parent to child. (because parent is always
-      //    created before the child)
-      // 2. A component's user watchers are run before its render watcher (because
-      //    user watchers are created before the render watcher)
-      // 3. If a component is destroyed during a parent component's watcher run,
-      //    its watchers can be skipped.
-      queue.sort((a, b) => a.id - b.id);
-      // do not cache length because more watchers might be pushed
-      // as we run existing watchers
-      for (index = 0; index < queue.length; index++) {
-          watcher = queue[index];
-          if (watcher.before) {
-              watcher.before();
-          }
-          id = watcher.id;
-          has[id] = null;
-          watcher.run();
-          // in dev build, check and stop circular updates.
-          if (has[id] != null) {
-              circular[id] = (circular[id] || 0) + 1;
-              if (circular[id] > MAX_UPDATE_COUNT) {
-                  warn('You may have an infinite update loop ' +
-                      (watcher.user
-                          ? `in watcher with expression "${watcher.expression}"`
-                          : `in a component render function.`), watcher.vm);
-                  break;
-              }
-          }
-      }
-      // keep copies of post queues before resetting state
-      const activatedQueue = activatedChildren.slice();
-      const updatedQueue = queue.slice();
-      resetSchedulerState();
-      // call component updated and activated hooks
-      callActivatedHooks(activatedQueue);
-      callUpdatedHooks(updatedQueue);
-      // devtool hook
-      /* istanbul ignore if */
-      if (devtools && config.devtools) {
-          devtools.emit('flush');
-      }
-  }
-  function callUpdatedHooks(queue) {
-      let i = queue.length;
-      while (i--) {
-          const watcher = queue[i];
-          const vm = watcher.vm;
-          if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-              callHook$1(vm, 'updated');
-          }
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-      activatedChildren.push(vm);
-  }
-  function callActivatedHooks(queue) {
-      for (let i = 0; i < queue.length; i++) {
-          queue[i]._inactive = true;
-          activateChildComponent(queue[i], true /* true */);
-      }
-  }
-  /**
-   * Push a watcher into the watcher queue.
-   * Jobs with duplicate IDs will be skipped unless it's
-   * pushed when the queue is being flushed.
-   */
-  function queueWatcher(watcher) {
-      const id = watcher.id;
-      if (has[id] == null) {
-          has[id] = true;
-          if (!flushing) {
-              queue.push(watcher);
-          }
-          else {
-              // if already flushing, splice the watcher based on its id
-              // if already past its id, it will be run next immediately.
-              let i = queue.length - 1;
-              while (i > index && queue[i].id > watcher.id) {
-                  i--;
-              }
-              queue.splice(i + 1, 0, watcher);
-          }
-          // queue the flush
-          if (!waiting) {
-              waiting = true;
-              if (!config.async) {
-                  flushSchedulerQueue();
-                  return;
-              }
-              nextTick(flushSchedulerQueue);
-          }
-      }
-  }
-
-  let uid$1 = 0;
-  /**
-   * A watcher parses an expression, collects dependencies,
-   * and fires callback when the expression value changes.
-   * This is used for both the $watch() api and directives.
-   */
-  class Watcher {
-      vm;
-      expression;
-      cb;
-      id;
-      deep;
-      user;
-      lazy;
-      sync;
-      dirty;
-      active;
-      deps;
-      newDeps;
-      depIds;
-      newDepIds;
-      before;
-      getter;
-      value;
-      constructor(vm, expOrFn, cb, options, isRenderWatcher) {
-          this.vm = vm;
-          if (isRenderWatcher) {
-              vm._watcher = this;
-          }
-          vm._watchers.push(this);
-          // options
-          if (options) {
-              this.deep = !!options.deep;
-              this.user = !!options.user;
-              this.lazy = !!options.lazy;
-              this.sync = !!options.sync;
-              this.before = options.before;
-          }
-          else {
-              this.deep = this.user = this.lazy = this.sync = false;
-          }
-          this.cb = cb;
-          this.id = ++uid$1; // uid for batching
-          this.active = true;
-          this.dirty = this.lazy; // for lazy watchers
-          this.deps = [];
-          this.newDeps = [];
-          this.depIds = new _Set();
-          this.newDepIds = new _Set();
-          this.expression = expOrFn.toString()
-              ;
-          // parse expression for getter
-          if (typeof expOrFn === 'function') {
-              this.getter = expOrFn;
-          }
-          else {
-              this.getter = parsePath(expOrFn);
-              if (!this.getter) {
-                  this.getter = noop;
-                  warn(`Failed watching path: "${expOrFn}" ` +
-                      'Watcher only accepts simple dot-delimited paths. ' +
-                      'For full control, use a function instead.', vm);
-              }
-          }
-          this.value = this.lazy
-              ? undefined
-              : this.get();
-      }
-      /**
-       * Evaluate the getter, and re-collect dependencies.
-       */
-      get() {
-          pushTarget(this);
-          let value;
-          const vm = this.vm;
-          try {
-              value = this.getter.call(vm, vm);
-          }
-          catch (e) {
-              if (this.user) {
-                  handleError(e, vm, `getter for watcher "${this.expression}"`);
-              }
-              else {
-                  throw e;
-              }
-          }
-          finally {
-              // "touch" every property so they are all tracked as
-              // dependencies for deep watching
-              if (this.deep) {
-                  traverse(value);
-              }
-              popTarget();
-              this.cleanupDeps();
-          }
-          return value;
-      }
-      /**
-       * Add a dependency to this directive.
-       */
-      addDep(dep) {
-          const id = dep.id;
-          if (!this.newDepIds.has(id)) {
-              this.newDepIds.add(id);
-              this.newDeps.push(dep);
-              if (!this.depIds.has(id)) {
-                  dep.addSub(this);
-              }
-          }
-      }
-      /**
-       * Clean up for dependency collection.
-       */
-      cleanupDeps() {
-          let i = this.deps.length;
-          while (i--) {
-              const dep = this.deps[i];
-              if (!this.newDepIds.has(dep.id)) {
-                  dep.removeSub(this);
-              }
-          }
-          let tmp = this.depIds;
-          this.depIds = this.newDepIds;
-          this.newDepIds = tmp;
-          this.newDepIds.clear();
-          tmp = this.deps;
-          this.deps = this.newDeps;
-          this.newDeps = tmp;
-          this.newDeps.length = 0;
-      }
-      /**
-       * Subscriber interface.
-       * Will be called when a dependency changes.
-       */
-      update() {
-          /* istanbul ignore else */
-          if (this.lazy) {
-              this.dirty = true;
-          }
-          else if (this.sync) {
-              this.run();
-          }
-          else {
-              queueWatcher(this);
-          }
-      }
-      /**
-       * Scheduler job interface.
-       * Will be called by the scheduler.
-       */
-      run() {
-          if (this.active) {
-              const value = this.get();
-              if (value !== this.value ||
-                  // Deep watchers and watchers on Object/Arrays should fire even
-                  // when the value is the same, because the value may
-                  // have mutated.
-                  isObject(value) ||
-                  this.deep) {
-                  // set new value
-                  const oldValue = this.value;
-                  this.value = value;
-                  if (this.user) {
-                      const info = `callback for watcher "${this.expression}"`;
-                      invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info);
-                  }
-                  else {
-                      this.cb.call(this.vm, value, oldValue);
-                  }
-              }
-          }
-      }
-      /**
-       * Evaluate the value of the watcher.
-       * This only gets called for lazy watchers.
-       */
-      evaluate() {
-          this.value = this.get();
-          this.dirty = false;
-      }
-      /**
-       * Depend on all deps collected by this watcher.
-       */
-      depend() {
-          let i = this.deps.length;
-          while (i--) {
-              this.deps[i].depend();
-          }
-      }
-      /**
-       * Remove self from all dependencies' subscriber list.
-       */
-      teardown() {
-          if (this.active) {
-              // remove self from vm's watcher list
-              // this is a somewhat expensive operation so we skip it
-              // if the vm is being destroyed.
-              if (!this.vm._isBeingDestroyed) {
-                  remove$2(this.vm._watchers, this);
-              }
-              let i = this.deps.length;
-              while (i--) {
-                  this.deps[i].removeSub(this);
-              }
-              this.active = false;
-          }
-      }
-  }
-
-  const sharedPropertyDefinition = {
-      enumerable: true,
-      configurable: true,
-      get: noop,
-      set: noop,
-  };
-  function proxy(target, sourceKey, key) {
-      sharedPropertyDefinition.get = function proxyGetter() {
-          return this[sourceKey][key];
-      };
-      sharedPropertyDefinition.set = function proxySetter(val) {
-          this[sourceKey][key] = val;
-      };
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function initState(vm) {
-      vm._watchers = [];
-      const opts = vm.$options;
-      if (opts.props)
-          initProps$1(vm, opts.props);
-      if (opts.methods)
-          initMethods(vm, opts.methods);
-      if (opts.data) {
-          initData(vm);
-      }
-      else {
-          observe((vm._data = {}), true /* asRootData */);
-      }
-      if (opts.computed)
-          initComputed$1(vm, opts.computed);
-      if (opts.watch && opts.watch !== nativeWatch) {
-          initWatch(vm, opts.watch);
-      }
-  }
-  function initProps$1(vm, propsOptions) {
-      const propsData = vm.$options.propsData || {};
-      const props = (vm._props = {});
-      // cache prop keys so that future props updates can iterate using Array
-      // instead of dynamic object key enumeration.
-      const keys = (vm.$options._propKeys = []);
-      const isRoot = !vm.$parent;
-      // root instance props should be converted
-      if (!isRoot) {
-          toggleObserving(false);
-      }
-      for (const key in propsOptions) {
-          keys.push(key);
-          const value = validateProp(key, propsOptions, propsData, vm);
-          /* istanbul ignore else */
-          {
-              const hyphenatedKey = hyphenate(key);
-              if (isReservedAttribute(hyphenatedKey) ||
-                  config.isReservedAttr(hyphenatedKey)) {
-                  warn(`"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`, vm);
-              }
-              defineReactive(props, key, value, () => {
-                  if (!isRoot && !isUpdatingChildComponent) {
-                      warn(`Avoid mutating a prop directly since the value will be ` +
-                          `overwritten whenever the parent component re-renders. ` +
-                          `Instead, use a data or computed property based on the prop's ` +
-                          `value. Prop being mutated: "${key}"`, vm);
-                  }
-              });
-          }
-          // static props are already proxied on the component's prototype
-          // during Vue.extend(). We only need to proxy props defined at
-          // instantiation here.
-          if (!(key in vm)) {
-              proxy(vm, `_props`, key);
-          }
-      }
-      toggleObserving(true);
-  }
-  function initData(vm) {
-      let data = vm.$options.data;
-      data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
-      if (!isPlainObject(data)) {
-          data = {};
-          warn("data functions should return an object:\n" +
-                  "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function", vm);
-      }
-      // proxy data on instance
-      const keys = Object.keys(data);
-      const props = vm.$options.props;
-      const methods = vm.$options.methods;
-      let i = keys.length;
-      while (i--) {
-          const key = keys[i];
-          {
-              if (methods && hasOwn(methods, key)) {
-                  warn(`Method "${key}" has already been defined as a data property.`, vm);
-              }
-          }
-          if (props && hasOwn(props, key)) {
-              warn(`The data property "${key}" is already declared as a prop. ` +
-                      `Use prop default value instead.`, vm);
-          }
-          else if (!isReserved(key)) {
-              proxy(vm, `_data`, key);
-          }
-      }
-      // observe data
-      observe(data, true /* asRootData */);
-  }
-  function getData(data, vm) {
-      // #7573 disable dep collection when invoking data getters
-      pushTarget();
-      try {
-          return data.call(vm, vm);
-      }
-      catch (e) {
-          handleError(e, vm, `data()`);
-          return {};
-      }
-      finally {
-          popTarget();
-      }
-  }
-  const computedWatcherOptions = { lazy: true };
-  function initComputed$1(vm, computed) {
-      // $flow-disable-line
-      const watchers = (vm._computedWatchers = Object.create(null));
-      // computed properties are just getters during SSR
-      const isSSR = isServerRendering();
-      for (const key in computed) {
-          const userDef = computed[key];
-          const getter = typeof userDef === "function" ? userDef : userDef.get;
-          if (getter == null) {
-              warn(`Getter is missing for computed property "${key}".`, vm);
-          }
-          if (!isSSR) {
-              // create internal watcher for the computed property.
-              watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-          }
-          // component-defined computed properties are already defined on the
-          // component prototype. We only need to define computed properties defined
-          // at instantiation here.
-          if (!(key in vm)) {
-              defineComputed(vm, key, userDef);
-          }
-          else {
-              if (key in vm.$data) {
-                  warn(`The computed property "${key}" is already defined in data.`, vm);
-              }
-              else if (vm.$options.props && key in vm.$options.props) {
-                  warn(`The computed property "${key}" is already defined as a prop.`, vm);
-              }
-              else if (vm.$options.methods && key in vm.$options.methods) {
-                  warn(`The computed property "${key}" is already defined as a method.`, vm);
-              }
-          }
-      }
-  }
-  function defineComputed(target, key, userDef) {
-      const shouldCache = !isServerRendering();
-      if (typeof userDef === "function") {
-          sharedPropertyDefinition.get = shouldCache
-              ? createComputedGetter(key)
-              : createGetterInvoker(userDef);
-          sharedPropertyDefinition.set = noop;
-      }
-      else {
-          sharedPropertyDefinition.get = userDef.get
-              ? shouldCache && userDef.cache !== false
-                  ? createComputedGetter(key)
-                  : createGetterInvoker(userDef.get)
-              : noop;
-          sharedPropertyDefinition.set = userDef.set || noop;
-      }
-      if (sharedPropertyDefinition.set === noop) {
-          sharedPropertyDefinition.set = function () {
-              warn(`Computed property "${key}" was assigned to but it has no setter.`, this);
-          };
-      }
-      Object.defineProperty(target, key, sharedPropertyDefinition);
-  }
-  function createComputedGetter(key) {
-      return function computedGetter() {
-          const watcher = this._computedWatchers && this._computedWatchers[key];
-          if (watcher) {
-              if (watcher.dirty) {
-                  watcher.evaluate();
-              }
-              if (Dep.target) {
-                  watcher.depend();
-              }
-              return watcher.value;
-          }
-      };
-  }
-  function createGetterInvoker(fn) {
-      return function computedGetter() {
-          return fn.call(this, this);
-      };
-  }
-  function initMethods(vm, methods) {
-      const props = vm.$options.props;
-      for (const key in methods) {
-          {
-              if (typeof methods[key] !== "function") {
-                  warn(`Method "${key}" has type "${typeof methods[key]}" in the component definition. ` +
-                      `Did you reference the function correctly?`, vm);
-              }
-              if (props && hasOwn(props, key)) {
-                  warn(`Method "${key}" has already been defined as a prop.`, vm);
-              }
-              if (key in vm && isReserved(key)) {
-                  warn(`Method "${key}" conflicts with an existing Vue instance method. ` +
-                      `Avoid defining component methods that start with _ or $.`);
-              }
-          }
-          vm[key] =
-              typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
-      }
-  }
-  function initWatch(vm, watch) {
-      for (const key in watch) {
-          const handler = watch[key];
-          if (Array.isArray(handler)) {
-              for (let i = 0; i < handler.length; i++) {
-                  createWatcher(vm, key, handler[i]);
-              }
-          }
-          else {
-              createWatcher(vm, key, handler);
-          }
-      }
-  }
-  function createWatcher(vm, expOrFn, handler, options) {
-      if (isPlainObject(handler)) {
-          options = handler;
-          handler = handler.handler;
-      }
-      if (typeof handler === "string") {
-          handler = vm[handler];
-      }
-      return vm.$watch(expOrFn, handler, options);
-  }
-  function stateMixin(Vue) {
-      // flow somehow has problems with directly declared definition object
-      // when using Object.defineProperty, so we have to procedurally build up
-      // the object here.
-      const dataDef = {};
-      dataDef.get = function () {
-          return this._data;
-      };
-      const propsDef = {};
-      propsDef.get = function () {
-          return this._props;
-      };
-      {
-          dataDef.set = function () {
-              warn("Avoid replacing instance root $data. " +
-                  "Use nested data properties instead.", this);
-          };
-          propsDef.set = function () {
-              warn(`$props is readonly.`, this);
-          };
-      }
-      Object.defineProperty(Vue.prototype, "$data", dataDef);
-      Object.defineProperty(Vue.prototype, "$props", propsDef);
-      Vue.prototype.$set = set;
-      Vue.prototype.$delete = del;
-      Vue.prototype.$watch = function (expOrFn, cb, options) {
-          const vm = this;
-          if (isPlainObject(cb)) {
-              return createWatcher(vm, expOrFn, cb, options);
-          }
-          options = options || {};
-          options.user = true;
-          const watcher = new Watcher(vm, expOrFn, cb, options);
-          if (options.immediate) {
-              const info = `callback for immediate watcher "${watcher.expression}"`;
-              pushTarget();
-              invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-              popTarget();
-          }
-          return function unwatchFn() {
-              watcher.teardown();
-          };
-      };
-  }
-
-  let uid = 0;
-  function initMixin$1(Vue) {
-      Vue.prototype._init = function (options) {
-          const vm = this;
-          // a uid
-          vm._uid = uid++;
-          let startTag, endTag;
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              startTag = `vue-perf-start:${vm._uid}`;
-              endTag = `vue-perf-end:${vm._uid}`;
-              mark(startTag);
-          }
-          // a flag to avoid this being observed
-          vm._isVue = true;
-          // merge options
-          if (options && options._isComponent) {
-              // optimize internal component instantiation
-              // since dynamic options merging is pretty slow, and none of the
-              // internal component options needs special treatment.
-              initInternalComponent(vm, options);
-          }
-          else {
-              vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-          }
-          /* istanbul ignore else */
-          {
-              initProxy(vm);
-          }
-          // expose real self
-          vm._self = vm;
-          initLifecycle(vm);
-          initEvents(vm);
-          initRender(vm);
-          callHook$1(vm, 'beforeCreate');
-          initInjections(vm); // resolve injections before data/props
-          initState(vm);
-          initProvide(vm); // resolve provide after data/props
-          callHook$1(vm, 'created');
-          /* istanbul ignore if */
-          if (config.performance && mark) {
-              vm._name = formatComponentName(vm, false);
-              mark(endTag);
-              measure(`vue ${vm._name} init`, startTag, endTag);
-          }
-          if (vm.$options.el) {
-              vm.$mount(vm.$options.el);
-          }
-      };
-  }
-  function initInternalComponent(vm, options) {
-      const opts = (vm.$options = Object.create(vm.constructor.options));
-      // doing this because it's faster than dynamic enumeration.
-      const parentVnode = options._parentVnode;
-      opts.parent = options.parent;
-      opts._parentVnode = parentVnode;
-      const vnodeComponentOptions = parentVnode.componentOptions;
-      opts.propsData = vnodeComponentOptions.propsData;
-      opts._parentListeners = vnodeComponentOptions.listeners;
-      opts._renderChildren = vnodeComponentOptions.children;
-      opts._componentTag = vnodeComponentOptions.tag;
-      if (options.render) {
-          opts.render = options.render;
-          opts.staticRenderFns = options.staticRenderFns;
-      }
-  }
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
-  }
-
-  function Vue(options) {
-      if (!(this instanceof Vue)) {
-          warn("Vue is a constructor and should be called with the `new` keyword");
-      }
-      this._init(options);
-  }
-  //@ts-expect-error Vue has function type
-  initMixin$1(Vue);
-  //@ts-expect-error Vue has function type
-  stateMixin(Vue);
-  //@ts-expect-error Vue has function type
-  eventsMixin(Vue);
-  //@ts-expect-error Vue has function type
-  lifecycleMixin(Vue);
-  //@ts-expect-error Vue has function type
-  renderMixin(Vue);
-
-  function initUse(Vue) {
-      Vue.use = function (plugin) {
-          const installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-          if (installedPlugins.indexOf(plugin) > -1) {
-              return this;
-          }
-          // additional parameters
-          const args = toArray(arguments, 1);
-          args.unshift(this);
-          if (typeof plugin.install === 'function') {
-              plugin.install.apply(plugin, args);
-          }
-          else if (typeof plugin === 'function') {
-              plugin.apply(null, args);
-          }
-          installedPlugins.push(plugin);
-          return this;
-      };
-  }
-
-  function initMixin(Vue) {
-      Vue.mixin = function (mixin) {
-          this.options = mergeOptions(this.options, mixin);
-          return this;
-      };
-  }
-
-  function initExtend(Vue) {
-      /**
-       * Each instance constructor, including Vue, has a unique
-       * cid. This enables us to create wrapped "child
-       * constructors" for prototypal inheritance and cache them.
-       */
-      Vue.cid = 0;
-      let cid = 1;
-      /**
-       * Class inheritance
-       */
-      Vue.extend = function (extendOptions) {
-          extendOptions = extendOptions || {};
-          const Super = this;
-          const SuperId = Super.cid;
-          const cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-          if (cachedCtors[SuperId]) {
-              return cachedCtors[SuperId];
-          }
-          const name = extendOptions.name || Super.options.name;
-          if (name) {
-              validateComponentName(name);
-          }
-          const Sub = function VueComponent(options) {
-              this._init(options);
-          };
-          Sub.prototype = Object.create(Super.prototype);
-          Sub.prototype.constructor = Sub;
-          Sub.cid = cid++;
-          Sub.options = mergeOptions(Super.options, extendOptions);
-          Sub['super'] = Super;
-          // For props and computed properties, we define the proxy getters on
-          // the Vue instances at extension time, on the extended prototype. This
-          // avoids Object.defineProperty calls for each instance created.
-          if (Sub.options.props) {
-              initProps(Sub);
-          }
-          if (Sub.options.computed) {
-              initComputed(Sub);
-          }
-          // allow further extension/mixin/plugin usage
-          Sub.extend = Super.extend;
-          Sub.mixin = Super.mixin;
-          Sub.use = Super.use;
-          // create asset registers, so extended classes
-          // can have their private assets too.
-          ASSET_TYPES.forEach(function (type) {
-              Sub[type] = Super[type];
-          });
-          // enable recursive self-lookup
-          if (name) {
-              Sub.options.components[name] = Sub;
-          }
-          // keep a reference to the super options at extension time.
-          // later at instantiation we can check if Super's options have
-          // been updated.
-          Sub.superOptions = Super.options;
-          Sub.extendOptions = extendOptions;
-          Sub.sealedOptions = extend({}, Sub.options);
-          // cache constructor
-          cachedCtors[SuperId] = Sub;
-          return Sub;
-      };
-  }
-  function initProps(Comp) {
-      const props = Comp.options.props;
-      for (const key in props) {
-          proxy(Comp.prototype, `_props`, key);
-      }
-  }
-  function initComputed(Comp) {
-      const computed = Comp.options.computed;
-      for (const key in computed) {
-          defineComputed(Comp.prototype, key, computed[key]);
-      }
-  }
-
-  function initAssetRegisters(Vue) {
-      /**
-       * Create asset registration methods.
-       */
-      ASSET_TYPES.forEach((type) => {
-          // @ts-expect-error function is not exact same type
-          Vue[type] = function (id, definition) {
-              if (!definition) {
-                  return this.options[type + 's'][id];
-              }
-              else {
-                  /* istanbul ignore if */
-                  if (type === 'component') {
-                      validateComponentName(id);
-                  }
-                  if (type === 'component' && isPlainObject(definition)) {
-                      // @ts-expect-error
-                      definition.name = definition.name || id;
-                      definition = this.options._base.extend(definition);
-                  }
-                  if (type === 'directive' && typeof definition === 'function') {
-                      definition = { bind: definition, update: definition };
-                  }
-                  this.options[type + 's'][id] = definition;
-                  return definition;
-              }
-          };
-      });
-  }
-
-  /* @flow */
-  function getComponentName(opts) {
-      return opts && (opts.Ctor.options.name || opts.tag);
-  }
-  function matches(pattern, name) {
-      if (Array.isArray(pattern)) {
-          return pattern.indexOf(name) > -1;
-      }
-      else if (typeof pattern === "string") {
-          return pattern.split(",").indexOf(name) > -1;
-      }
-      else if (isRegExp(pattern)) {
-          return pattern.test(name);
-      }
-      /* istanbul ignore next */
-      return false;
-  }
-  function pruneCache(keepAliveInstance, filter) {
-      const { cache, keys, _vnode } = keepAliveInstance;
-      for (const key in cache) {
-          const entry = cache[key];
-          if (entry) {
-              const name = entry.name;
-              if (name && !filter(name)) {
-                  pruneCacheEntry(cache, key, keys, _vnode);
-              }
-          }
-      }
-  }
-  function pruneCacheEntry(cache, key, keys, current) {
-      const entry = cache[key];
-      if (entry && (!current || entry.tag !== current.tag)) {
-          // @ts-expect-error can be undefined
-          entry.componentInstance.$destroy();
-      }
-      cache[key] = null;
-      remove$2(keys, key);
-  }
-  const patternTypes = [String, RegExp, Array];
-  // TODO defineComponent
-  var KeepAlive = {
-      name: "keep-alive",
-      abstract: true,
-      props: {
-          include: patternTypes,
-          exclude: patternTypes,
-          max: [String, Number],
-      },
-      methods: {
-          cacheVNode() {
-              const { cache, keys, vnodeToCache, keyToCache } = this;
-              if (vnodeToCache) {
-                  const { tag, componentInstance, componentOptions } = vnodeToCache;
-                  cache[keyToCache] = {
-                      name: getComponentName(componentOptions),
-                      tag,
-                      componentInstance,
-                  };
-                  keys.push(keyToCache);
-                  // prune oldest entry
-                  if (this.max && keys.length > parseInt(this.max)) {
-                      pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                  }
-                  this.vnodeToCache = null;
-              }
-          },
-      },
-      created() {
-          this.cache = Object.create(null);
-          this.keys = [];
-      },
-      destroyed() {
-          for (const key in this.cache) {
-              pruneCacheEntry(this.cache, key, this.keys);
-          }
-      },
-      mounted() {
-          this.cacheVNode();
-          this.$watch("include", (val) => {
-              pruneCache(this, (name) => matches(val, name));
-          });
-          this.$watch("exclude", (val) => {
-              pruneCache(this, (name) => !matches(val, name));
-          });
-      },
-      updated() {
-          this.cacheVNode();
-      },
-      render() {
-          const slot = this.$slots.default;
-          const vnode = getFirstComponentChild(slot);
-          const componentOptions = vnode && vnode.componentOptions;
-          if (componentOptions) {
-              // check pattern
-              const name = getComponentName(componentOptions);
-              const { include, exclude } = this;
-              if (
-              // not included
-              (include && (!name || !matches(include, name))) ||
-                  // excluded
-                  (exclude && name && matches(exclude, name))) {
-                  return vnode;
-              }
-              const { cache, keys } = this;
-              const key = vnode.key == null
-                  ? // same constructor may get registered as different local components
-                      // so cid alone is not enough (#3269)
-                      componentOptions.Ctor.cid +
-                          (componentOptions.tag ? `::${componentOptions.tag}` : "")
-                  : vnode.key;
-              if (cache[key]) {
-                  vnode.componentInstance = cache[key].componentInstance;
-                  // make current key freshest
-                  remove$2(keys, key);
-                  keys.push(key);
-              }
-              else {
-                  // delay setting the cache until update
-                  this.vnodeToCache = vnode;
-                  this.keyToCache = key;
-              }
-              // @ts-expect-error can vnode.data can be undefined
-              vnode.data.keepAlive = true;
-          }
-          return vnode || (slot && slot[0]);
-      },
-  };
-
-  var builtInComponents = {
-      KeepAlive,
-  };
-
-  function initGlobalAPI(Vue) {
-      // config
-      const configDef = {};
-      configDef.get = () => config;
-      {
-          configDef.set = () => {
-              warn('Do not replace the Vue.config object, set individual fields instead.');
-          };
-      }
-      Object.defineProperty(Vue, 'config', configDef);
-      // exposed util methods.
-      // NOTE: these are not considered part of the public API - avoid relying on
-      // them unless you are aware of the risk.
-      Vue.util = {
-          warn,
-          extend,
-          mergeOptions,
-          defineReactive,
-      };
-      Vue.set = set;
-      Vue.delete = del;
-      Vue.nextTick = nextTick;
-      // 2.6 explicit observable API
-      Vue.observable = (obj) => {
-          observe(obj);
-          return obj;
-      };
-      Vue.options = Object.create(null);
-      ASSET_TYPES.forEach((type) => {
-          Vue.options[type + 's'] = Object.create(null);
-      });
-      // this is used to identify the "base" constructor to extend all plain-object
-      // components with in Weex's multi-instance scenarios.
-      Vue.options._base = Vue;
-      extend(Vue.options.components, builtInComponents);
-      initUse(Vue);
-      initMixin(Vue);
-      initExtend(Vue);
-      initAssetRegisters(Vue);
-  }
-
-  initGlobalAPI(Vue);
-  Object.defineProperty(Vue.prototype, '$isServer', {
-      get: isServerRendering,
-  });
-  Object.defineProperty(Vue.prototype, '$ssrContext', {
-      get() {
-          /* istanbul ignore next */
-          return this.$vnode && this.$vnode.ssrContext;
-      },
-  });
-  // expose FunctionalRenderContext for ssr runtime helper installation
-  Object.defineProperty(Vue, 'FunctionalRenderContext', {
-      value: FunctionalRenderContext,
-  });
-  Vue.version = '2.6.14';
-
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  const isReservedAttr = makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const xlinkNS = 'http://www.w3.org/1999/xlink';
-  const isXlink = (name) => {
-      return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink';
-  };
-  const getXlinkProp = (name) => {
-      return isXlink(name) ? name.slice(6, name.length) : '';
-  };
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
-  };
-
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
-  }
-
-  const namespaceMap = {
-      svg: 'http://www.w3.org/2000/svg',
-      math: 'http://www.w3.org/1998/Math/MathML',
-  };
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
-  const unknownElementCache = Object.create(null);
-  function isUnknownElement(tag) {
-      /* istanbul ignore if */
-      if (!inBrowser) {
-          return true;
-      }
-      if (isReservedTag(tag)) {
-          return false;
-      }
-      tag = tag.toLowerCase();
-      /* istanbul ignore if */
-      if (unknownElementCache[tag] != null) {
-          return unknownElementCache[tag];
-      }
-      const el = document.createElement(tag);
-      if (tag.indexOf('-') > -1) {
-          // http://stackoverflow.com/a/28210364/1070244
-          return (unknownElementCache[tag] =
-              el.constructor === window.HTMLUnknownElement ||
-                  el.constructor === window.HTMLElement);
-      }
-      else {
-          return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()));
-      }
-  }
-  const isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-  /**
-   * Query an element selector if it's not an element already.
-   */
-  function query(el) {
-      if (typeof el === 'string') {
-          const selected = document.querySelector(el);
-          if (!selected) {
-              warn('Cannot find element: ' + el);
-              return document.createElement('div');
-          }
-          return selected;
-      }
-      else {
-          return el;
-      }
-  }
-
-  function createElement(tagName, vnode) {
-      const elm = document.createElement(tagName);
-      if (tagName !== 'select') {
-          return elm;
-      }
-      // false or null will remove the attribute but undefined will not
-      if (vnode.data &&
-          vnode.data.attrs &&
-          vnode.data.attrs.multiple !== undefined) {
-          elm.setAttribute('multiple', 'multiple');
-      }
-      return elm;
-  }
-  function createElementNS(namespace, tagName) {
-      return document.createElementNS(namespaceMap[namespace], tagName);
-  }
-  function createTextNode(text) {
-      return document.createTextNode(text);
-  }
-  function createComment(text) {
-      return document.createComment(text);
-  }
-  function insertBefore(parentNode, newNode, referenceNode) {
-      parentNode.insertBefore(newNode, referenceNode);
-  }
-  function removeChild(node, child) {
-      node.removeChild(child);
-  }
-  function appendChild(node, child) {
-      node.appendChild(child);
-  }
-  function parentNode(node) {
-      return node.parentNode;
-  }
-  function nextSibling(node) {
-      return node.nextSibling;
-  }
-  function tagName(node) {
-      return node.tagName;
-  }
-  function setTextContent(node, text) {
-      node.textContent = text;
-  }
-  function setStyleScope(node, scopeId) {
-      node.setAttribute(scopeId, '');
-  }
-
-  var nodeOps = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    createElement: createElement,
-    createElementNS: createElementNS,
-    createTextNode: createTextNode,
-    createComment: createComment,
-    insertBefore: insertBefore,
-    removeChild: removeChild,
-    appendChild: appendChild,
-    parentNode: parentNode,
-    nextSibling: nextSibling,
-    tagName: tagName,
-    setTextContent: setTextContent,
-    setStyleScope: setStyleScope
-  });
-
-  var ref = {
-      create(_, vnode) {
-          registerRef(vnode);
-      },
-      update(oldVnode, vnode) {
-          if (oldVnode.data.ref !== vnode.data.ref) {
-              registerRef(oldVnode, true);
-              registerRef(vnode);
-          }
-      },
-      destroy(vnode) {
-          registerRef(vnode, true);
-      },
-  };
-  function registerRef(vnode, isRemoval) {
-      const key = vnode.data.ref;
-      if (!isDef(key))
-          return;
-      const vm = vnode.context;
-      const ref = vnode.componentInstance || vnode.elm;
-      const refs = vm.$refs;
-      const obj = refs[key];
-      if (isRemoval) {
-          if (Array.isArray(obj)) {
-              remove$2(obj, ref);
-          }
-          else if (obj === ref) {
-              refs[key] = undefined;
-          }
-      }
-      else {
-          if (vnode.data.refInFor) {
-              if (!Array.isArray(obj)) {
-                  refs[key] = [ref];
-              }
-              else if (obj.indexOf(ref) < 0) {
-                  obj.push(ref);
-              }
-          }
-          else {
-              refs[key] = ref;
-          }
-      }
-  }
-
-  /**
-   * Virtual DOM patching algorithm based on Snabbdom by
-   * Simon Friis Vindum (@paldepind)
-   * Licensed under the MIT License
-   * https://github.com/paldepind/snabbdom/blob/master/LICENSE
-   *
-   * modified by Evan You (@yyx990803)
-   *
-   * Not type-checking this because this file is perf-critical and the cost
-   * of making flow understand it is not worth it.
-   */
-  const emptyNode = new VNode('', {}, []);
-  const hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-  function sameVnode(a, b) {
-      return (a.key === b.key &&
-          a.asyncFactory === b.asyncFactory && ((a.tag === b.tag &&
-          a.isComment === b.isComment &&
-          isDef(a.data) === isDef(b.data) &&
-          sameInputType(a, b)) || (isTrue(a.isAsyncPlaceholder) &&
-          isUndef(b.asyncFactory.error))));
-  }
-  function sameInputType(a, b) {
-      if (a.tag !== 'input')
-          return true;
-      let i;
-      const typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-      const typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-      return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-  }
-  function createKeyToOldIdx(children, beginIdx, endIdx) {
-      let i, key;
-      const map = {};
-      for (i = beginIdx; i <= endIdx; ++i) {
-          key = children[i].key;
-          if (isDef(key))
-              map[key] = i;
-      }
-      return map;
-  }
-  function createPatchFunction(backend) {
-      let i, j;
-      const cbs = {};
-      const { modules, nodeOps } = backend;
-      for (i = 0; i < hooks.length; ++i) {
-          cbs[hooks[i]] = [];
-          for (j = 0; j < modules.length; ++j) {
-              if (isDef(modules[j][hooks[i]])) {
-                  cbs[hooks[i]].push(modules[j][hooks[i]]);
-              }
-          }
-      }
-      function emptyNodeAt(elm) {
-          return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-      }
-      function createRmCb(childElm, listeners) {
-          function remove() {
-              if (--remove.listeners === 0) {
-                  removeNode(childElm);
-              }
-          }
-          remove.listeners = listeners;
-          return remove;
-      }
-      function removeNode(el) {
-          const parent = nodeOps.parentNode(el);
-          // element may have already been removed due to v-html / v-text
-          if (isDef(parent)) {
-              nodeOps.removeChild(parent, el);
-          }
-      }
-      function isUnknownElement(vnode, inVPre) {
-          return (!inVPre &&
-              !vnode.ns &&
-              !(config.ignoredElements.length &&
-                  config.ignoredElements.some((ignore) => {
-                      return isRegExp(ignore)
-                          ? ignore.test(vnode.tag)
-                          : ignore === vnode.tag;
-                  })) &&
-              config.isUnknownElement(vnode.tag));
-      }
-      let creatingElmInVPre = 0;
-      function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // This vnode was used in a previous render!
-              // now it's used as a new node, overwriting its elm would cause
-              // potential patch errors down the road when it's used as an insertion
-              // reference node. Instead, we clone the node on-demand before creating
-              // associated DOM element for it.
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          vnode.isRootInsert = !nested; // for transition enter check
-          if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-              return;
-          }
-          const data = vnode.data;
-          const children = vnode.children;
-          const tag = vnode.tag;
-          if (isDef(tag)) {
-              {
-                  if (data && data.pre) {
-                      creatingElmInVPre++;
-                  }
-                  if (isUnknownElement(vnode, creatingElmInVPre)) {
-                      warn('Unknown custom element: <' +
-                          tag +
-                          '> - did you ' +
-                          'register the component correctly? For recursive components, ' +
-                          'make sure to provide the "name" option.', vnode.context);
-                  }
-              }
-              vnode.elm = vnode.ns
-                  ? nodeOps.createElementNS(vnode.ns, tag)
-                  : nodeOps.createElement(tag, vnode);
-              setScope(vnode);
-              /* istanbul ignore if */
-              {
-                  createChildren(vnode, children, insertedVnodeQueue);
-                  if (isDef(data)) {
-                      invokeCreateHooks(vnode, insertedVnodeQueue);
-                  }
-                  insert(parentElm, vnode.elm, refElm);
-              }
-              if (data && data.pre) {
-                  creatingElmInVPre--;
-              }
-          }
-          else if (isTrue(vnode.isComment)) {
-              vnode.elm = nodeOps.createComment(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-          else {
-              vnode.elm = nodeOps.createTextNode(vnode.text);
-              insert(parentElm, vnode.elm, refElm);
-          }
-      }
-      function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i = vnode.data;
-          if (isDef(i)) {
-              const isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-              if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                  i(vnode, false /* hydrating */);
-              }
-              // after calling the init hook, if the vnode is a child component
-              // it should've created a child instance and mounted it. the child
-              // component also has set the placeholder vnode's elm.
-              // in that case we can just return the element and be done.
-              if (isDef(vnode.componentInstance)) {
-                  initComponent(vnode, insertedVnodeQueue);
-                  insert(parentElm, vnode.elm, refElm);
-                  if (isTrue(isReactivated)) {
-                      reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                  }
-                  return true;
-              }
-          }
-      }
-      function initComponent(vnode, insertedVnodeQueue) {
-          if (isDef(vnode.data.pendingInsert)) {
-              insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-              vnode.data.pendingInsert = null;
-          }
-          vnode.elm = vnode.componentInstance.$el;
-          if (isPatchable(vnode)) {
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              setScope(vnode);
-          }
-          else {
-              // empty component root.
-              // skip all element-related modules except for ref (#3455)
-              registerRef(vnode);
-              // make sure to invoke the insert hook
-              insertedVnodeQueue.push(vnode);
-          }
-      }
-      function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-          let i;
-          // hack for #4339: a reactivated component with inner transition
-          // does not trigger because the inner node's created hooks are not called
-          // again. It's not ideal to involve module-specific logic in here but
-          // there doesn't seem to be a better way to do it.
-          let innerNode = vnode;
-          while (innerNode.componentInstance) {
-              innerNode = innerNode.componentInstance._vnode;
-              if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                  for (i = 0; i < cbs.activate.length; ++i) {
-                      cbs.activate[i](emptyNode, innerNode);
-                  }
-                  insertedVnodeQueue.push(innerNode);
-                  break;
-              }
-          }
-          // unlike a newly created component,
-          // a reactivated keep-alive component doesn't insert itself
-          insert(parentElm, vnode.elm, refElm);
-      }
-      function insert(parent, elm, ref) {
-          if (isDef(parent)) {
-              if (isDef(ref)) {
-                  if (nodeOps.parentNode(ref) === parent) {
-                      nodeOps.insertBefore(parent, elm, ref);
-                  }
-              }
-              else {
-                  nodeOps.appendChild(parent, elm);
-              }
-          }
-      }
-      function createChildren(vnode, children, insertedVnodeQueue) {
-          if (Array.isArray(children)) {
-              {
-                  checkDuplicateKeys(children);
-              }
-              for (let i = 0; i < children.length; ++i) {
-                  createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);
-              }
-          }
-          else if (isPrimitive(vnode.text)) {
-              nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-          }
-      }
-      function isPatchable(vnode) {
-          while (vnode.componentInstance) {
-              vnode = vnode.componentInstance._vnode;
-          }
-          return isDef(vnode.tag);
-      }
-      function invokeCreateHooks(vnode, insertedVnodeQueue) {
-          for (let i = 0; i < cbs.create.length; ++i) {
-              cbs.create[i](emptyNode, vnode);
-          }
-          i = vnode.data.hook; // Reuse variable
-          if (isDef(i)) {
-              if (isDef(i.create))
-                  i.create(emptyNode, vnode);
-              if (isDef(i.insert))
-                  insertedVnodeQueue.push(vnode);
-          }
-      }
-      // set scope id attribute for scoped CSS.
-      // this is implemented as a special case to avoid the overhead
-      // of going through the normal attribute patching process.
-      function setScope(vnode) {
-          let i;
-          if (isDef((i = vnode.fnScopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-          else {
-              let ancestor = vnode;
-              while (ancestor) {
-                  if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                      nodeOps.setStyleScope(vnode.elm, i);
-                  }
-                  ancestor = ancestor.parent;
-              }
-          }
-          // for slot content they should also get the scopeId from the host instance.
-          if (isDef((i = activeInstance)) &&
-              i !== vnode.context &&
-              i !== vnode.fnContext &&
-              isDef((i = i.$options._scopeId))) {
-              nodeOps.setStyleScope(vnode.elm, i);
-          }
-      }
-      function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-          }
-      }
-      function invokeDestroyHook(vnode) {
-          let i, j;
-          const data = vnode.data;
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                  i(vnode);
-              for (i = 0; i < cbs.destroy.length; ++i)
-                  cbs.destroy[i](vnode);
-          }
-          if (isDef((i = vnode.children))) {
-              for (j = 0; j < vnode.children.length; ++j) {
-                  invokeDestroyHook(vnode.children[j]);
-              }
-          }
-      }
-      function removeVnodes(vnodes, startIdx, endIdx) {
-          for (; startIdx <= endIdx; ++startIdx) {
-              const ch = vnodes[startIdx];
-              if (isDef(ch)) {
-                  if (isDef(ch.tag)) {
-                      removeAndInvokeRemoveHook(ch);
-                      invokeDestroyHook(ch);
-                  }
-                  else {
-                      // Text node
-                      removeNode(ch.elm);
-                  }
-              }
-          }
-      }
-      function removeAndInvokeRemoveHook(vnode, rm) {
-          if (isDef(rm) || isDef(vnode.data)) {
-              let i;
-              const listeners = cbs.remove.length + 1;
-              if (isDef(rm)) {
-                  // we have a recursively passed down rm callback
-                  // increase the listeners count
-                  rm.listeners += listeners;
-              }
-              else {
-                  // directly removing
-                  rm = createRmCb(vnode.elm, listeners);
-              }
-              // recursively invoke hooks on child component root node
-              if (isDef((i = vnode.componentInstance)) &&
-                  isDef((i = i._vnode)) &&
-                  isDef(i.data)) {
-                  removeAndInvokeRemoveHook(i, rm);
-              }
-              for (i = 0; i < cbs.remove.length; ++i) {
-                  cbs.remove[i](vnode, rm);
-              }
-              if (isDef((i = vnode.data.hook)) && isDef((i = i.remove))) {
-                  i(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          }
-          else {
-              removeNode(vnode.elm);
-          }
-      }
-      function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-          let oldStartIdx = 0;
-          let newStartIdx = 0;
-          let oldEndIdx = oldCh.length - 1;
-          let oldStartVnode = oldCh[0];
-          let oldEndVnode = oldCh[oldEndIdx];
-          let newEndIdx = newCh.length - 1;
-          let newStartVnode = newCh[0];
-          let newEndVnode = newCh[newEndIdx];
-          let oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-          // removeOnly is a special flag used only by <transition-group>
-          // to ensure removed elements stay in correct relative positions
-          // during leaving transitions
-          const canMove = !removeOnly;
-          {
-              checkDuplicateKeys(newCh);
-          }
-          while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-              if (isUndef(oldStartVnode)) {
-                  oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-              }
-              else if (isUndef(oldEndVnode)) {
-                  oldEndVnode = oldCh[--oldEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newStartVnode)) {
-                  patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else if (sameVnode(oldEndVnode, newEndVnode)) {
-                  patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldStartVnode, newEndVnode)) {
-                  // Vnode moved right
-                  patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                  oldStartVnode = oldCh[++oldStartIdx];
-                  newEndVnode = newCh[--newEndIdx];
-              }
-              else if (sameVnode(oldEndVnode, newStartVnode)) {
-                  // Vnode moved left
-                  patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                  canMove &&
-                      nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                  oldEndVnode = oldCh[--oldEndIdx];
-                  newStartVnode = newCh[++newStartIdx];
-              }
-              else {
-                  if (isUndef(oldKeyToIdx))
-                      oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx);
-                  idxInOld = isDef(newStartVnode.key)
-                      ? oldKeyToIdx[newStartVnode.key]
-                      : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                  if (isUndef(idxInOld)) {
-                      // New element
-                      createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                  }
-                  else {
-                      vnodeToMove = oldCh[idxInOld];
-                      if (sameVnode(vnodeToMove, newStartVnode)) {
-                          patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                          oldCh[idxInOld] = undefined;
-                          canMove &&
-                              nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                      }
-                      else {
-                          // same key but different element. treat as new element
-                          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                      }
-                  }
-                  newStartVnode = newCh[++newStartIdx];
-              }
-          }
-          if (oldStartIdx > oldEndIdx) {
-              refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-              addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-          }
-          else if (newStartIdx > newEndIdx) {
-              removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-          }
-      }
-      function checkDuplicateKeys(children) {
-          const seenKeys = {};
-          for (let i = 0; i < children.length; i++) {
-              const vnode = children[i];
-              const key = vnode.key;
-              if (isDef(key)) {
-                  if (seenKeys[key]) {
-                      warn(`Duplicate keys detected: '${key}'. This may cause an update error.`, vnode.context);
-                  }
-                  else {
-                      seenKeys[key] = true;
-                  }
-              }
-          }
-      }
-      function findIdxInOld(node, oldCh, start, end) {
-          for (let i = start; i < end; i++) {
-              const c = oldCh[i];
-              if (isDef(c) && sameVnode(node, c))
-                  return i;
-          }
-      }
-      function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-          if (oldVnode === vnode) {
-              return;
-          }
-          if (isDef(vnode.elm) && isDef(ownerArray)) {
-              // clone reused vnode
-              vnode = ownerArray[index] = cloneVNode(vnode);
-          }
-          const elm = (vnode.elm = oldVnode.elm);
-          if (isTrue(oldVnode.isAsyncPlaceholder)) {
-              if (isDef(vnode.asyncFactory.resolved)) {
-                  hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-              }
-              else {
-                  vnode.isAsyncPlaceholder = true;
-              }
-              return;
-          }
-          // reuse element for static trees.
-          // note we only do this if the vnode is cloned -
-          // if the new node is not cloned it means the render functions have been
-          // reset by the hot-reload-api and we need to do a proper re-render.
-          if (isTrue(vnode.isStatic) &&
-              isTrue(oldVnode.isStatic) &&
-              vnode.key === oldVnode.key &&
-              (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-              vnode.componentInstance = oldVnode.componentInstance;
-              return;
-          }
-          let i;
-          const data = vnode.data;
-          if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-              i(oldVnode, vnode);
-          }
-          const oldCh = oldVnode.children;
-          const ch = vnode.children;
-          if (isDef(data) && isPatchable(vnode)) {
-              for (i = 0; i < cbs.update.length; ++i)
-                  cbs.update[i](oldVnode, vnode);
-              if (isDef((i = data.hook)) && isDef((i = i.update)))
-                  i(oldVnode, vnode);
-          }
-          if (isUndef(vnode.text)) {
-              if (isDef(oldCh) && isDef(ch)) {
-                  if (oldCh !== ch)
-                      updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly);
-              }
-              else if (isDef(ch)) {
-                  {
-                      checkDuplicateKeys(ch);
-                  }
-                  if (isDef(oldVnode.text))
-                      nodeOps.setTextContent(elm, '');
-                  addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-              }
-              else if (isDef(oldCh)) {
-                  removeVnodes(oldCh, 0, oldCh.length - 1);
-              }
-              else if (isDef(oldVnode.text)) {
-                  nodeOps.setTextContent(elm, '');
-              }
-          }
-          else if (oldVnode.text !== vnode.text) {
-              nodeOps.setTextContent(elm, vnode.text);
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                  i(oldVnode, vnode);
-          }
-      }
-      function invokeInsertHook(vnode, queue, initial) {
-          // delay insert hooks for component root nodes, invoke them after the
-          // element is really inserted
-          if (isTrue(initial) && isDef(vnode.parent)) {
-              vnode.parent.data.pendingInsert = queue;
-          }
-          else {
-              for (let i = 0; i < queue.length; ++i) {
-                  queue[i].data.hook.insert(queue[i]);
-              }
-          }
-      }
-      let hydrationBailed = false;
-      // list of modules that can skip create hook during hydration because they
-      // are already rendered on the client or has no need for initialization
-      // Note: style is excluded because it relies on initial clone for future
-      // deep updates (#7063).
-      const isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-      // Note: this is a browser-only function so we can assume elms are DOM nodes.
-      function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-          let i;
-          const { tag, data, children } = vnode;
-          inVPre = inVPre || (data && data.pre);
-          vnode.elm = elm;
-          if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-              vnode.isAsyncPlaceholder = true;
-              return true;
-          }
-          // assert node match
-          {
-              if (!assertNodeMatch(elm, vnode, inVPre)) {
-                  return false;
-              }
-          }
-          if (isDef(data)) {
-              if (isDef((i = data.hook)) && isDef((i = i.init)))
-                  i(vnode, true /* hydrating */);
-              if (isDef((i = vnode.componentInstance))) {
-                  // child component. it should have hydrated its own tree.
-                  initComponent(vnode, insertedVnodeQueue);
-                  return true;
-              }
-          }
-          if (isDef(tag)) {
-              if (isDef(children)) {
-                  // empty element, allow client to pick up and populate children
-                  if (!elm.hasChildNodes()) {
-                      createChildren(vnode, children, insertedVnodeQueue);
-                  }
-                  else {
-                      // v-html and domProps: innerHTML
-                      if (isDef((i = data)) &&
-                          isDef((i = i.domProps)) &&
-                          isDef((i = i.innerHTML))) {
-                          if (i !== elm.innerHTML) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('server innerHTML: ', i);
-                                  console.warn('client innerHTML: ', elm.innerHTML);
-                              }
-                              return false;
-                          }
-                      }
-                      else {
-                          // iterate and compare children lists
-                          let childrenMatch = true;
-                          let childNode = elm.firstChild;
-                          for (let i = 0; i < children.length; i++) {
-                              if (!childNode ||
-                                  !hydrate(childNode, children[i], insertedVnodeQueue, inVPre)) {
-                                  childrenMatch = false;
-                                  break;
-                              }
-                              childNode = childNode.nextSibling;
-                          }
-                          // if childNode is not null, it means the actual childNodes list is
-                          // longer than the virtual children list.
-                          if (!childrenMatch || childNode) {
-                              /* istanbul ignore if */
-                              if (typeof console !== 'undefined' &&
-                                  !hydrationBailed) {
-                                  hydrationBailed = true;
-                                  console.warn('Parent: ', elm);
-                                  console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                              }
-                              return false;
-                          }
-                      }
-                  }
-              }
-              if (isDef(data)) {
-                  let fullInvoke = false;
-                  for (const key in data) {
-                      if (!isRenderedModule(key)) {
-                          fullInvoke = true;
-                          invokeCreateHooks(vnode, insertedVnodeQueue);
-                          break;
-                      }
-                  }
-                  if (!fullInvoke && data['class']) {
-                      // ensure collecting deps for deep class bindings for future updates
-                      traverse(data['class']);
-                  }
-              }
-          }
-          else if (elm.data !== vnode.text) {
-              elm.data = vnode.text;
-          }
-          return true;
-      }
-      function assertNodeMatch(node, vnode, inVPre) {
-          if (isDef(vnode.tag)) {
-              return (vnode.tag.indexOf('vue-component') === 0 ||
-                  (!isUnknownElement(vnode, inVPre) &&
-                      vnode.tag.toLowerCase() ===
-                          (node.tagName && node.tagName.toLowerCase())));
-          }
-          else {
-              return node.nodeType === (vnode.isComment ? 8 : 3);
-          }
-      }
-      return function patch(oldVnode, vnode, hydrating, removeOnly) {
-          if (isUndef(vnode)) {
-              if (isDef(oldVnode))
-                  invokeDestroyHook(oldVnode);
-              return;
-          }
-          let isInitialPatch = false;
-          const insertedVnodeQueue = [];
-          if (isUndef(oldVnode)) {
-              // empty mount (likely as component), create new root element
-              isInitialPatch = true;
-              createElm(vnode, insertedVnodeQueue);
-          }
-          else {
-              const isRealElement = isDef(oldVnode.nodeType);
-              if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                  // patch existing root node
-                  patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-              }
-              else {
-                  if (isRealElement) {
-                      // mounting to a real element
-                      // check if this is server-rendered content and if we can perform
-                      // a successful hydration.
-                      if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                          oldVnode.removeAttribute(SSR_ATTR);
-                          hydrating = true;
-                      }
-                      if (isTrue(hydrating)) {
-                          if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                              invokeInsertHook(vnode, insertedVnodeQueue, true);
-                              return oldVnode;
-                          }
-                          else {
-                              warn('The client-side rendered virtual DOM tree is not matching ' +
-                                  'server-rendered content. This is likely caused by incorrect ' +
-                                  'HTML markup, for example nesting block-level elements inside ' +
-                                  '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                  'full client-side render.');
-                          }
-                      }
-                      // either not server-rendered, or hydration failed.
-                      // create an empty node and replace it
-                      oldVnode = emptyNodeAt(oldVnode);
-                  }
-                  // replacing existing element
-                  const oldElm = oldVnode.elm;
-                  const parentElm = nodeOps.parentNode(oldElm);
-                  // create new node
-                  createElm(vnode, insertedVnodeQueue, 
-                  // extremely rare edge case: do not insert if old element is in a
-                  // leaving transition. Only happens when combining transition +
-                  // keep-alive + HOCs. (#4590)
-                  oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                  // update parent placeholder node element, recursively
-                  if (isDef(vnode.parent)) {
-                      let ancestor = vnode.parent;
-                      const patchable = isPatchable(vnode);
-                      while (ancestor) {
-                          for (let i = 0; i < cbs.destroy.length; ++i) {
-                              cbs.destroy[i](ancestor);
-                          }
-                          ancestor.elm = vnode.elm;
-                          if (patchable) {
-                              for (let i = 0; i < cbs.create.length; ++i) {
-                                  cbs.create[i](emptyNode, ancestor);
-                              }
-                              // #6513
-                              // invoke insert hooks that may have been merged by create hooks.
-                              // e.g. for directives that uses the "inserted" hook.
-                              const insert = ancestor.data.hook.insert;
-                              if (insert.merged) {
-                                  // start at index 1 to avoid re-invoking component mounted hook
-                                  for (let i = 1; i < insert.fns.length; i++) {
-                                      insert.fns[i]();
-                                  }
-                              }
-                          }
-                          else {
-                              registerRef(ancestor);
-                          }
-                          ancestor = ancestor.parent;
-                      }
-                  }
-                  // destroy old node
-                  if (isDef(parentElm)) {
-                      removeVnodes([oldVnode], 0, 0);
-                  }
-                  else if (isDef(oldVnode.tag)) {
-                      invokeDestroyHook(oldVnode);
-                  }
-              }
-          }
-          invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-          return vnode.elm;
-      };
-  }
-
-  var directives = {
-      create: updateDirectives,
-      update: updateDirectives,
-      destroy: function unbindDirectives(vnode) {
-          // @ts-expect-error emptyNode is not VNodeWithData
-          updateDirectives(vnode, emptyNode);
-      },
-  };
-  function updateDirectives(oldVnode, vnode) {
-      if (oldVnode.data.directives || vnode.data.directives) {
-          _update(oldVnode, vnode);
-      }
-  }
-  function _update(oldVnode, vnode) {
-      const isCreate = oldVnode === emptyNode;
-      const isDestroy = vnode === emptyNode;
-      const oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-      const newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-      const dirsWithInsert = [];
-      const dirsWithPostpatch = [];
-      let key, oldDir, dir;
-      for (key in newDirs) {
-          oldDir = oldDirs[key];
-          dir = newDirs[key];
-          if (!oldDir) {
-              // new directive, bind
-              callHook(dir, 'bind', vnode, oldVnode);
-              if (dir.def && dir.def.inserted) {
-                  dirsWithInsert.push(dir);
-              }
-          }
-          else {
-              // existing directive, update
-              dir.oldValue = oldDir.value;
-              dir.oldArg = oldDir.arg;
-              callHook(dir, 'update', vnode, oldVnode);
-              if (dir.def && dir.def.componentUpdated) {
-                  dirsWithPostpatch.push(dir);
-              }
-          }
-      }
-      if (dirsWithInsert.length) {
-          const callInsert = () => {
-              for (let i = 0; i < dirsWithInsert.length; i++) {
-                  callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-              }
-          };
-          if (isCreate) {
-              mergeVNodeHook(vnode, 'insert', callInsert);
-          }
-          else {
-              callInsert();
-          }
-      }
-      if (dirsWithPostpatch.length) {
-          mergeVNodeHook(vnode, 'postpatch', () => {
-              for (let i = 0; i < dirsWithPostpatch.length; i++) {
-                  callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-              }
-          });
-      }
-      if (!isCreate) {
-          for (key in oldDirs) {
-              if (!newDirs[key]) {
-                  // no longer present, unbind
-                  callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-              }
-          }
-      }
-  }
-  const emptyModifiers = Object.create(null);
-  function normalizeDirectives(dirs, vm) {
-      const res = Object.create(null);
-      if (!dirs) {
-          // $flow-disable-line
-          return res;
-      }
-      let i, dir;
-      for (i = 0; i < dirs.length; i++) {
-          dir = dirs[i];
-          if (!dir.modifiers) {
-              // $flow-disable-line
-              dir.modifiers = emptyModifiers;
-          }
-          res[getRawDirName(dir)] = dir;
-          dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-      }
-      // $flow-disable-line
-      return res;
-  }
-  function getRawDirName(dir) {
-      return (dir.rawName || `${dir.name}.${Object.keys(dir.modifiers || {}).join('.')}`);
-  }
-  function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-      const fn = dir.def && dir.def[hook];
-      if (fn) {
-          try {
-              fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-          }
-          catch (e) {
-              handleError(e, vnode.context, `directive ${dir.name} ${hook} hook`);
-          }
-      }
-  }
-
-  var baseModules = [ref, directives];
-
-  function updateAttrs(oldVnode, vnode) {
-      const opts = vnode.componentOptions;
-      if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
-          return;
-      }
-      if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
-          return;
-      }
-      let key, cur, old;
-      const elm = vnode.elm;
-      const oldAttrs = oldVnode.data.attrs || {};
-      let attrs = vnode.data.attrs || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(attrs.__ob__)) {
-          attrs = vnode.data.attrs = extend({}, attrs);
-      }
-      for (key in attrs) {
-          cur = attrs[key];
-          old = oldAttrs[key];
-          if (old !== cur) {
-              setAttr(elm, key, cur, vnode.data.pre);
-          }
-      }
-      // #4391: in IE9, setting type can reset value for input[type=radio]
-      // #6666: IE/Edge forces progress value down to 1 before setting a max
-      /* istanbul ignore if */
-      if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {
-          setAttr(elm, 'value', attrs.value);
-      }
-      for (key in oldAttrs) {
-          if (isUndef(attrs[key])) {
-              if (isXlink(key)) {
-                  elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-              }
-              else if (!isEnumeratedAttr(key)) {
-                  elm.removeAttribute(key);
-              }
-          }
-      }
-  }
-  function setAttr(el, key, value, isInPre) {
-      if (isInPre || el.tagName.indexOf('-') > -1) {
-          baseSetAttr(el, key, value);
-      }
-      else if (isBooleanAttr(key)) {
-          // set attribute for blank value
-          // e.g. <option disabled>Select one</option>
-          if (isFalsyAttrValue(value)) {
-              el.removeAttribute(key);
-          }
-          else {
-              // technically allowfullscreen is a boolean attribute for <iframe>,
-              // but Flash expects a value of "true" when used on <embed> tag
-              value = key === 'allowfullscreen' && el.tagName === 'EMBED' ? 'true' : key;
-              el.setAttribute(key, value);
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          el.setAttribute(key, convertEnumeratedValue(key, value));
-      }
-      else if (isXlink(key)) {
-          if (isFalsyAttrValue(value)) {
-              el.removeAttributeNS(xlinkNS, getXlinkProp(key));
-          }
-          else {
-              el.setAttributeNS(xlinkNS, key, value);
-          }
-      }
-      else {
-          baseSetAttr(el, key, value);
-      }
-  }
-  function baseSetAttr(el, key, value) {
-      if (isFalsyAttrValue(value)) {
-          el.removeAttribute(key);
-      }
-      else {
-          // #7138: IE10 & 11 fires input event when setting placeholder on
-          // <textarea>... block the first input event and remove the blocker
-          // immediately.
-          /* istanbul ignore if */
-          if (isIE &&
-              !isIE9 &&
-              el.tagName === 'TEXTAREA' &&
-              key === 'placeholder' &&
-              value !== '' &&
-              !el.__ieph) {
-              const blocker = (e) => {
-                  e.stopImmediatePropagation();
-                  el.removeEventListener('input', blocker);
-              };
-              el.addEventListener('input', blocker);
-              // $flow-disable-line
-              el.__ieph = true; /* IE placeholder patched */
-          }
-          el.setAttribute(key, value);
-      }
-  }
-  var attrs = {
-      create: updateAttrs,
-      update: updateAttrs,
-  };
-
-  function updateClass(oldVnode, vnode) {
-      const el = vnode.elm;
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticClass) &&
-          isUndef(data.class) &&
-          (isUndef(oldData) ||
-              (isUndef(oldData.staticClass) && isUndef(oldData.class)))) {
-          return;
-      }
-      let cls = genClassForVnode(vnode);
-      // handle transition classes
-      const transitionClass = el._transitionClasses;
-      if (isDef(transitionClass)) {
-          cls = concat(cls, stringifyClass(transitionClass));
-      }
-      // set the class
-      if (cls !== el._prevClass) {
-          el.setAttribute('class', cls);
-          el._prevClass = cls;
-      }
-  }
-  var klass = {
-      create: updateClass,
-      update: updateClass,
-  };
-
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
-  const CHECKBOX_RADIO_TOKEN = '__c';
-
-  // normalize v-model event tokens that can only be determined at runtime.
-  // it's important to place the event as the first in the array because
-  // the whole point is ensuring the v-model callback gets called before
-  // user-attached handlers.
-  function normalizeEvents(on) {
-      /* istanbul ignore if */
-      if (isDef(on[RANGE_TOKEN])) {
-          // IE input[type=range] only supports `change` event
-          const event = isIE ? 'change' : 'input';
-          on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);
-          delete on[RANGE_TOKEN];
-      }
-      // This was originally intended to fix #4521 but no longer necessary
-      // after 2.5. Keeping it for backwards compat with generated code from < 2.4
-      /* istanbul ignore if */
-      if (isDef(on[CHECKBOX_RADIO_TOKEN])) {
-          on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);
-          delete on[CHECKBOX_RADIO_TOKEN];
-      }
-  }
-  let target;
-  function createOnceHandler(event, handler, capture) {
-      const _target = target; // save current target element in closure
-      return function onceHandler() {
-          const res = handler.apply(null, arguments);
-          if (res !== null) {
-              remove(event, onceHandler, capture, _target);
-          }
-      };
-  }
-  // #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp
-  // implementation and does not fire microtasks in between event propagation, so
-  // safe to exclude.
-  const useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);
-  function add(name, handler, capture, passive) {
-      // async edge case #6566: inner click event triggers patch, event handler
-      // attached to outer element during patch, and triggered again. This
-      // happens because browsers fire microtask ticks between event propagation.
-      // the solution is simple: we save the timestamp when a handler is attached,
-      // and the handler would only fire if the event passed to it was fired
-      // AFTER it was attached.
-      if (useMicrotaskFix) {
-          const attachedTimestamp = currentFlushTimestamp;
-          const original = handler;
-          //@ts-expect-error 
-          handler = original._wrapper = function (e) {
-              if (
-              // no bubbling, should always fire.
-              // this is just a safety net in case event.timeStamp is unreliable in
-              // certain weird environments...
-              e.target === e.currentTarget ||
-                  // event is fired after handler attachment
-                  e.timeStamp >= attachedTimestamp ||
-                  // bail for environments that have buggy event.timeStamp implementations
-                  // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState
-                  // #9681 QtWebEngine event.timeStamp is negative value
-                  e.timeStamp <= 0 ||
-                  // #9448 bail if event is fired in another document in a multi-page
-                  // electron/nw.js app, since event.timeStamp will be using a different
-                  // starting reference
-                  e.target.ownerDocument !== document) {
-                  return original.apply(this, arguments);
-              }
-          };
-      }
-      target.addEventListener(name, handler, supportsPassive ? { capture, passive } : capture);
-  }
-  function remove(name, handler, capture, _target) {
-      (_target || target).removeEventListener(name, 
-      //@ts-expect-error
-      handler._wrapper || handler, capture);
-  }
-  function updateDOMListeners(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-          return;
-      }
-      const on = vnode.data.on || {};
-      const oldOn = oldVnode.data.on || {};
-      // vnode is empty when removing all listeners,
-      // and use old vnode dom element
-      target = vnode.elm || oldVnode.elm;
-      normalizeEvents(on);
-      updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-      target = undefined;
-  }
-  var events = {
-      create: updateDOMListeners,
-      update: updateDOMListeners,
-      // @ts-expect-error emptyNode has actually data
-      destroy: (vnode) => updateDOMListeners(vnode, emptyNode)
-  };
-
-  let svgContainer;
-  function updateDOMProps(oldVnode, vnode) {
-      if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-          return;
-      }
-      let key, cur;
-      const elm = vnode.elm;
-      const oldProps = oldVnode.data.domProps || {};
-      let props = vnode.data.domProps || {};
-      // clone observed objects, as the user probably wants to mutate it
-      if (isDef(props.__ob__)) {
-          props = vnode.data.domProps = extend({}, props);
-      }
-      for (key in oldProps) {
-          if (!(key in props)) {
-              elm[key] = '';
-          }
-      }
-      for (key in props) {
-          cur = props[key];
-          // ignore children if the node has textContent or innerHTML,
-          // as these will throw away existing DOM nodes and cause removal errors
-          // on subsequent patches (#3360)
-          if (key === 'textContent' || key === 'innerHTML') {
-              if (vnode.children)
-                  vnode.children.length = 0;
-              if (cur === oldProps[key])
-                  continue;
-              // #6601 work around Chrome version <= 55 bug where single textNode
-              // replaced by innerHTML/textContent retains its parentNode property
-              if (elm.childNodes.length === 1) {
-                  elm.removeChild(elm.childNodes[0]);
-              }
-          }
-          if (key === 'value' && elm.tagName !== 'PROGRESS') {
-              // store value as _value as well since
-              // non-string values will be stringified
-              elm._value = cur;
-              // avoid resetting cursor position when value is the same
-              const strCur = isUndef(cur) ? '' : String(cur);
-              if (shouldUpdateValue(elm, strCur)) {
-                  elm.value = strCur;
-              }
-          }
-          else if (key === 'innerHTML' &&
-              isSVG(elm.tagName) &&
-              isUndef(elm.innerHTML)) {
-              // IE doesn't support innerHTML for SVG elements
-              svgContainer = svgContainer || document.createElement('div');
-              svgContainer.innerHTML = `<svg>${cur}</svg>`;
-              const svg = svgContainer.firstChild;
-              while (elm.firstChild) {
-                  elm.removeChild(elm.firstChild);
-              }
-              while (svg.firstChild) {
-                  elm.appendChild(svg.firstChild);
-              }
-          }
-          else if (
-          // skip the update if old and new VDOM state is the same.
-          // `value` is handled separately because the DOM value may be temporarily
-          // out of sync with VDOM state due to focus, composition and modifiers.
-          // This  #4521 by skipping the unnecessary `checked` update.
-          cur !== oldProps[key]) {
-              // some property updates can throw
-              // e.g. `value` on <progress> w/ non-finite value
-              try {
-                  elm[key] = cur;
-              }
-              catch (e) { }
-          }
-      }
-  }
-  function shouldUpdateValue(elm, checkVal) {
-      return (
-      //@ts-expect-error
-      !elm.composing &&
-          (elm.tagName === 'OPTION' ||
-              isNotInFocusAndDirty(elm, checkVal) ||
-              isDirtyWithModifiers(elm, checkVal)));
-  }
-  function isNotInFocusAndDirty(elm, checkVal) {
-      // return true when textbox (.number and .trim) loses focus and its value is
-      // not equal to the updated value
-      let notInFocus = true;
-      // #6157
-      // work around IE bug when accessing document.activeElement in an iframe
-      try {
-          notInFocus = document.activeElement !== elm;
-      }
-      catch (e) { }
-      return notInFocus && elm.value !== checkVal;
-  }
-  function isDirtyWithModifiers(elm, newVal) {
-      const value = elm.value;
-      const modifiers = elm._vModifiers; // injected by v-model runtime
-      if (isDef(modifiers)) {
-          if (modifiers.number) {
-              return toNumber(value) !== toNumber(newVal);
-          }
-          if (modifiers.trim) {
-              return value.trim() !== newVal.trim();
-          }
-      }
-      return value !== newVal;
-  }
-  var domProps = {
-      create: updateDOMProps,
-      update: updateDOMProps,
-  };
-
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
-  }
-
-  const cssVarRE = /^--/;
-  const importantRE = /\s*!important$/;
-  const setProp = (el, name, val) => {
-      /* istanbul ignore if */
-      if (cssVarRE.test(name)) {
-          el.style.setProperty(name, val);
-      }
-      else if (importantRE.test(val)) {
-          el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');
-      }
-      else {
-          const normalizedName = normalize(name);
-          if (Array.isArray(val)) {
-              // Support values array created by autoprefixer, e.g.
-              // {display: ["-webkit-box", "-ms-flexbox", "flex"]}
-              // Set them one by one, and the browser will only set those it can recognize
-              for (let i = 0, len = val.length; i < len; i++) {
-                  el.style[normalizedName] = val[i];
-              }
-          }
-          else {
-              el.style[normalizedName] = val;
-          }
-      }
-  };
-  const vendorNames = ['Webkit', 'Moz', 'ms'];
-  let emptyStyle;
-  const normalize = cached(function (prop) {
-      emptyStyle = emptyStyle || document.createElement('div').style;
-      prop = camelize(prop);
-      if (prop !== 'filter' && prop in emptyStyle) {
-          return prop;
-      }
-      const capName = prop.charAt(0).toUpperCase() + prop.slice(1);
-      for (let i = 0; i < vendorNames.length; i++) {
-          const name = vendorNames[i] + capName;
-          if (name in emptyStyle) {
-              return name;
-          }
-      }
-  });
-  function updateStyle(oldVnode, vnode) {
-      const data = vnode.data;
-      const oldData = oldVnode.data;
-      if (isUndef(data.staticStyle) &&
-          isUndef(data.style) &&
-          isUndef(oldData.staticStyle) &&
-          isUndef(oldData.style)) {
-          return;
-      }
-      let cur, name;
-      const el = vnode.elm;
-      const oldStaticStyle = oldData.staticStyle;
-      const oldStyleBinding = oldData.normalizedStyle || oldData.style || {};
-      // if static style exists, stylebinding already merged into it when doing normalizeStyleData
-      const oldStyle = oldStaticStyle || oldStyleBinding;
-      const style = normalizeStyleBinding(vnode.data.style) || {};
-      // store normalized style under a different key for next diff
-      // make sure to clone it if it's reactive, since the user likely wants
-      // to mutate it.
-      vnode.data.normalizedStyle = isDef(style.__ob__) ? extend({}, style) : style;
-      const newStyle = getStyle(vnode, true);
-      for (name in oldStyle) {
-          if (isUndef(newStyle[name])) {
-              setProp(el, name, '');
-          }
-      }
-      for (name in newStyle) {
-          cur = newStyle[name];
-          if (cur !== oldStyle[name]) {
-              // ie9 setting to null has no effect, must use empty string
-              setProp(el, name, cur == null ? '' : cur);
-          }
-      }
-  }
-  var style = {
-      create: updateStyle,
-      update: updateStyle,
-  };
-
-  const whitespaceRE = /\s+/;
-  /**
-   * Add class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function addClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach((c) => el.classList.add(c));
-          }
-          else {
-              el.classList.add(cls);
-          }
-      }
-      else {
-          const cur = ` ${el.getAttribute('class') || ''} `;
-          if (cur.indexOf(' ' + cls + ' ') < 0) {
-              el.setAttribute('class', (cur + cls).trim());
-          }
-      }
-  }
-  /**
-   * Remove class with compatibility for SVG since classList is not supported on
-   * SVG elements in IE
-   */
-  function removeClass(el, cls) {
-      /* istanbul ignore if */
-      if (!cls || !(cls = cls.trim())) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (el.classList) {
-          if (cls.indexOf(' ') > -1) {
-              cls.split(whitespaceRE).forEach((c) => el.classList.remove(c));
-          }
-          else {
-              el.classList.remove(cls);
-          }
-          if (!el.classList.length) {
-              el.removeAttribute('class');
-          }
-      }
-      else {
-          let cur = ` ${el.getAttribute('class') || ''} `;
-          const tar = ' ' + cls + ' ';
-          while (cur.indexOf(tar) >= 0) {
-              cur = cur.replace(tar, ' ');
-          }
-          cur = cur.trim();
-          if (cur) {
-              el.setAttribute('class', cur);
-          }
-          else {
-              el.removeAttribute('class');
-          }
-      }
-  }
-
-  function resolveTransition(def) {
-      if (!def) {
-          return;
-      }
-      /* istanbul ignore else */
-      if (typeof def === 'object') {
-          const res = {};
-          if (def.css !== false) {
-              extend(res, autoCssTransition(def.name || 'v'));
-          }
-          extend(res, def);
-          return res;
-      }
-      else if (typeof def === 'string') {
-          return autoCssTransition(def);
-      }
-  }
-  const autoCssTransition = cached((name) => {
-      return {
-          enterClass: `${name}-enter`,
-          enterToClass: `${name}-enter-to`,
-          enterActiveClass: `${name}-enter-active`,
-          leaveClass: `${name}-leave`,
-          leaveToClass: `${name}-leave-to`,
-          leaveActiveClass: `${name}-leave-active`,
-      };
-  });
-  const hasTransition = inBrowser && !isIE9;
-  const TRANSITION = 'transition';
-  const ANIMATION = 'animation';
-  // Transition property/event sniffing
-  let transitionProp = 'transition';
-  let transitionEndEvent = 'transitionend';
-  let animationProp = 'animation';
-  let animationEndEvent = 'animationend';
-  if (hasTransition) {
-      /* istanbul ignore if */
-      if (window.ontransitionend === undefined &&
-          window.onwebkittransitionend !== undefined) {
-          transitionProp = 'WebkitTransition';
-          transitionEndEvent = 'webkitTransitionEnd';
-      }
-      if (window.onanimationend === undefined &&
-          window.onwebkitanimationend !== undefined) {
-          animationProp = 'WebkitAnimation';
-          animationEndEvent = 'webkitAnimationEnd';
-      }
-  }
-  // binding to window is necessary to make hot reload work in IE in strict mode
-  const raf = inBrowser
-      ? window.requestAnimationFrame
-          ? window.requestAnimationFrame.bind(window)
-          : setTimeout
-      : /* istanbul ignore next */ (fn) => fn();
-  function nextFrame(fn) {
-      raf(() => {
-          // @ts-expect-error
-          raf(fn);
-      });
-  }
-  function addTransitionClass(el, cls) {
-      const transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-      if (transitionClasses.indexOf(cls) < 0) {
-          transitionClasses.push(cls);
-          addClass(el, cls);
-      }
-  }
-  function removeTransitionClass(el, cls) {
-      if (el._transitionClasses) {
-          remove$2(el._transitionClasses, cls);
-      }
-      removeClass(el, cls);
-  }
-  function whenTransitionEnds(el, expectedType, cb) {
-      const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
-      if (!type)
-          return cb();
-      const event = type === TRANSITION ? transitionEndEvent : animationEndEvent;
-      let ended = 0;
-      const end = () => {
-          el.removeEventListener(event, onEnd);
-          cb();
-      };
-      const onEnd = (e) => {
-          if (e.target === el) {
-              if (++ended >= propCount) {
-                  end();
-              }
-          }
-      };
-      setTimeout(() => {
-          if (ended < propCount) {
-              end();
-          }
-      }, timeout + 1);
-      el.addEventListener(event, onEnd);
-  }
-  const transformRE = /\b(transform|all)(,|$)/;
-  function getTransitionInfo(el, expectedType) {
-      const styles = window.getComputedStyle(el);
-      // JSDOM may return undefined for transition properties
-      const transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');
-      const transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');
-      const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
-      const animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');
-      const animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');
-      const animationTimeout = getTimeout(animationDelays, animationDurations);
-      let type;
-      let timeout = 0;
-      let propCount = 0;
-      /* istanbul ignore if */
-      if (expectedType === TRANSITION) {
-          if (transitionTimeout > 0) {
-              type = TRANSITION;
-              timeout = transitionTimeout;
-              propCount = transitionDurations.length;
-          }
-      }
-      else if (expectedType === ANIMATION) {
-          if (animationTimeout > 0) {
-              type = ANIMATION;
-              timeout = animationTimeout;
-              propCount = animationDurations.length;
-          }
-      }
-      else {
-          timeout = Math.max(transitionTimeout, animationTimeout);
-          type =
-              timeout > 0
-                  ? transitionTimeout > animationTimeout
-                      ? TRANSITION
-                      : ANIMATION
-                  : null;
-          propCount = type
-              ? type === TRANSITION
-                  ? transitionDurations.length
-                  : animationDurations.length
-              : 0;
-      }
-      const hasTransform = type === TRANSITION && transformRE.test(styles[transitionProp + 'Property']);
-      return {
-          type,
-          timeout,
-          propCount,
-          hasTransform,
-      };
-  }
-  function getTimeout(delays, durations) {
-      /* istanbul ignore next */
-      while (delays.length < durations.length) {
-          delays = delays.concat(delays);
-      }
-      return Math.max.apply(null, durations.map((d, i) => {
-          return toMs(d) + toMs(delays[i]);
-      }));
-  }
-  // Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers
-  // in a locale-dependent way, using a comma instead of a dot.
-  // If comma is not replaced with a dot, the input will be rounded down (i.e. acting
-  // as a floor function) causing unexpected behaviors
-  function toMs(s) {
-      return Number(s.slice(0, -1).replace(',', '.')) * 1000;
-  }
-
-  function enter(vnode, toggleDisplay) {
-      const el = vnode.elm;
-      // call leave callback now
-      if (isDef(el._leaveCb)) {
-          el._leaveCb.cancelled = true;
-          el._leaveCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data)) {
-          return;
-      }
-      /* istanbul ignore if */
-      if (isDef(el._enterCb) || el.nodeType !== 1) {
-          return;
-      }
-      const { css, type, enterClass, enterToClass, enterActiveClass, appearClass, appearToClass, appearActiveClass, beforeEnter, enter, afterEnter, enterCancelled, beforeAppear, appear, afterAppear, appearCancelled, duration, } = data;
-      // activeInstance will always be the <transition> component managing this
-      // transition. One edge case to check is when the <transition> is placed
-      // as the root node of a child component. In that case we need to check
-      // <transition>'s parent for appear check.
-      let context = activeInstance;
-      let transitionNode = activeInstance.$vnode;
-      while (transitionNode && transitionNode.parent) {
-          context = transitionNode.context;
-          transitionNode = transitionNode.parent;
-      }
-      const isAppear = !context._isMounted || !vnode.isRootInsert;
-      if (isAppear && !appear && appear !== '') {
-          return;
-      }
-      const startClass = isAppear && appearClass ? appearClass : enterClass;
-      const activeClass = isAppear && appearActiveClass ? appearActiveClass : enterActiveClass;
-      const toClass = isAppear && appearToClass ? appearToClass : enterToClass;
-      const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-      const enterHook = isAppear
-          ? typeof appear === 'function'
-              ? appear
-              : enter
-          : enter;
-      const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-      const enterCancelledHook = isAppear
-          ? appearCancelled || enterCancelled
-          : enterCancelled;
-      const explicitEnterDuration = toNumber(isObject(duration) ? duration.enter : duration);
-      if (explicitEnterDuration != null) {
-          checkDuration(explicitEnterDuration, 'enter', vnode);
-      }
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(enterHook);
-      const cb = (el._enterCb = once(() => {
-          if (expectsCSS) {
-              removeTransitionClass(el, toClass);
-              removeTransitionClass(el, activeClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, startClass);
-              }
-              enterCancelledHook && enterCancelledHook(el);
-          }
-          else {
-              afterEnterHook && afterEnterHook(el);
-          }
-          el._enterCb = null;
-      }));
-      if (!vnode.data.show) {
-          // remove pending leave element on enter by injecting an insert hook
-          mergeVNodeHook(vnode, 'insert', () => {
-              const parent = el.parentNode;
-              const pendingNode = parent && parent._pending && parent._pending[vnode.key];
-              if (pendingNode &&
-                  pendingNode.tag === vnode.tag &&
-                  pendingNode.elm._leaveCb) {
-                  pendingNode.elm._leaveCb();
-              }
-              enterHook && enterHook(el, cb);
-          });
-      }
-      // start enter transition
-      beforeEnterHook && beforeEnterHook(el);
-      if (expectsCSS) {
-          addTransitionClass(el, startClass);
-          addTransitionClass(el, activeClass);
-          nextFrame(() => {
-              removeTransitionClass(el, startClass);
-              // @ts-expect-error
-              if (!cb.cancelled) {
-                  addTransitionClass(el, toClass);
-                  if (!userWantsControl) {
-                      if (isValidDuration(explicitEnterDuration)) {
-                          setTimeout(cb, explicitEnterDuration);
-                      }
-                      else {
-                          whenTransitionEnds(el, type, cb);
-                      }
-                  }
-              }
-          });
-      }
-      if (vnode.data.show) {
-          toggleDisplay && toggleDisplay();
-          enterHook && enterHook(el, cb);
-      }
-      if (!expectsCSS && !userWantsControl) {
-          cb();
-      }
-  }
-  function leave(vnode, rm) {
-      const el = vnode.elm;
-      // call enter callback now
-      if (isDef(el._enterCb)) {
-          el._enterCb.cancelled = true;
-          el._enterCb();
-      }
-      const data = resolveTransition(vnode.data.transition);
-      if (isUndef(data) || el.nodeType !== 1) {
-          return rm();
-      }
-      /* istanbul ignore if */
-      if (isDef(el._leaveCb)) {
-          return;
-      }
-      const { css, type, leaveClass, leaveToClass, leaveActiveClass, beforeLeave, leave, afterLeave, leaveCancelled, delayLeave, duration, } = data;
-      const expectsCSS = css !== false && !isIE9;
-      const userWantsControl = getHookArgumentsLength(leave);
-      const explicitLeaveDuration = toNumber(isObject(duration) ? duration.leave : duration);
-      if (isDef(explicitLeaveDuration)) {
-          checkDuration(explicitLeaveDuration, 'leave', vnode);
-      }
-      const cb = (el._leaveCb = once(() => {
-          if (el.parentNode && el.parentNode._pending) {
-              el.parentNode._pending[vnode.key] = null;
-          }
-          if (expectsCSS) {
-              removeTransitionClass(el, leaveToClass);
-              removeTransitionClass(el, leaveActiveClass);
-          }
-          // @ts-expect-error
-          if (cb.cancelled) {
-              if (expectsCSS) {
-                  removeTransitionClass(el, leaveClass);
-              }
-              leaveCancelled && leaveCancelled(el);
-          }
-          else {
-              rm();
-              afterLeave && afterLeave(el);
-          }
-          el._leaveCb = null;
-      }));
-      if (delayLeave) {
-          delayLeave(performLeave);
-      }
-      else {
-          performLeave();
-      }
-      function performLeave() {
-          // the delayed leave may have already been cancelled
-          // @ts-expect-error
-          if (cb.cancelled) {
-              return;
-          }
-          // record leaving element
-          if (!vnode.data.show && el.parentNode) {
-              (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-          }
-          beforeLeave && beforeLeave(el);
-          if (expectsCSS) {
-              addTransitionClass(el, leaveClass);
-              addTransitionClass(el, leaveActiveClass);
-              nextFrame(() => {
-                  removeTransitionClass(el, leaveClass);
-                  // @ts-expect-error
-                  if (!cb.cancelled) {
-                      addTransitionClass(el, leaveToClass);
-                      if (!userWantsControl) {
-                          if (isValidDuration(explicitLeaveDuration)) {
-                              setTimeout(cb, explicitLeaveDuration);
-                          }
-                          else {
-                              whenTransitionEnds(el, type, cb);
-                          }
-                      }
-                  }
-              });
-          }
-          leave && leave(el, cb);
-          if (!expectsCSS && !userWantsControl) {
-              cb();
-          }
-      }
-  }
-  // only used in dev mode
-  function checkDuration(val, name, vnode) {
-      if (typeof val !== 'number') {
-          warn(`<transition> explicit ${name} duration is not a valid number - ` +
-              `got ${JSON.stringify(val)}.`, vnode.context);
-      }
-      else if (isNaN(val)) {
-          warn(`<transition> explicit ${name} duration is NaN - ` +
-              'the duration expression might be incorrect.', vnode.context);
-      }
-  }
-  function isValidDuration(val) {
-      return typeof val === 'number' && !isNaN(val);
-  }
-  /**
-   * Normalize a transition hook's argument length. The hook may be:
-   * - a merged hook (invoker) with the original in .fns
-   * - a wrapped component method (check ._length)
-   * - a plain function (.length)
-   */
-  function getHookArgumentsLength(fn) {
-      if (isUndef(fn)) {
-          return false;
-      }
-      // @ts-expect-error
-      const invokerFns = fn.fns;
-      if (isDef(invokerFns)) {
-          // invoker
-          return getHookArgumentsLength(Array.isArray(invokerFns) ? invokerFns[0] : invokerFns);
-      }
-      else {
-          // @ts-expect-error
-          return (fn._length || fn.length) > 1;
-      }
-  }
-  function _enter(_, vnode) {
-      if (vnode.data.show !== true) {
-          enter(vnode);
-      }
-  }
-  var transition = inBrowser
-      ? {
-          create: _enter,
-          activate: _enter,
-          remove(vnode, rm) {
-              /* istanbul ignore else */
-              if (vnode.data.show !== true) {
-                  // @ts-expect-error
-                  leave(vnode, rm);
-              }
-              else {
-                  rm();
-              }
-          },
-      }
-      : {};
-
-  var platformModules = [attrs, klass, events, domProps, style, transition];
-
-  // the directive module should be applied last, after all
-  // built-in modules have been applied.
-  const modules = platformModules.concat(baseModules);
-  const patch = createPatchFunction({ nodeOps, modules });
-
-  /**
-   * Not type checking this file because flow doesn't like attaching
-   * properties to Elements.
-   */
-  /* istanbul ignore if */
-  if (isIE9) {
-      // http://www.matts411.com/post/internet-explorer-9-oninput/
-      document.addEventListener('selectionchange', () => {
-          const el = document.activeElement;
-          // @ts-expect-error
-          if (el && el.vmodel) {
-              trigger(el, 'input');
-          }
-      });
-  }
-  const directive = {
-      inserted(el, binding, vnode, oldVnode) {
-          if (vnode.tag === 'select') {
-              // #6903
-              if (oldVnode.elm && !oldVnode.elm._vOptions) {
-                  mergeVNodeHook(vnode, 'postpatch', () => {
-                      directive.componentUpdated(el, binding, vnode);
-                  });
-              }
-              else {
-                  setSelected(el, binding, vnode.context);
-              }
-              el._vOptions = [].map.call(el.options, getValue);
-          }
-          else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {
-              el._vModifiers = binding.modifiers;
-              if (!binding.modifiers.lazy) {
-                  el.addEventListener('compositionstart', onCompositionStart);
-                  el.addEventListener('compositionend', onCompositionEnd);
-                  // Safari < 10.2 & UIWebView doesn't fire compositionend when
-                  // switching focus before confirming composition choice
-                  // this also fixes the issue where some browsers e.g. iOS Chrome
-                  // fires "change" instead of "input" on autocomplete.
-                  el.addEventListener('change', onCompositionEnd);
-                  /* istanbul ignore if */
-                  if (isIE9) {
-                      el.vmodel = true;
-                  }
-              }
-          }
-      },
-      componentUpdated(el, binding, vnode) {
-          if (vnode.tag === 'select') {
-              setSelected(el, binding, vnode.context);
-              // in case the options rendered by v-for have changed,
-              // it's possible that the value is out-of-sync with the rendered options.
-              // detect such cases and filter out values that no longer has a matching
-              // option in the DOM.
-              const prevOptions = el._vOptions;
-              const curOptions = (el._vOptions = [].map.call(el.options, getValue));
-              if (curOptions.some((o, i) => !looseEqual(o, prevOptions[i]))) {
-                  // trigger change event if
-                  // no matching option found for at least one value
-                  const needReset = el.multiple
-                      ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
-                      : binding.value !== binding.oldValue &&
-                          hasNoMatchingOption(binding.value, curOptions);
-                  if (needReset) {
-                      trigger(el, 'change');
-                  }
-              }
-          }
-      },
-  };
-  function setSelected(el, binding, vm) {
-      actuallySetSelected(el, binding, vm);
-      /* istanbul ignore if */
-      if (isIE || isEdge) {
-          setTimeout(() => {
-              actuallySetSelected(el, binding, vm);
-          }, 0);
-      }
-  }
-  function actuallySetSelected(el, binding, vm) {
-      const value = binding.value;
-      const isMultiple = el.multiple;
-      if (isMultiple && !Array.isArray(value)) {
-          warn(`<select multiple v-model="${binding.expression}"> ` +
-                  `expects an Array value for its binding, but got ${Object.prototype.toString
-                    .call(value)
-                    .slice(8, -1)}`, vm);
-          return;
-      }
-      let selected, option;
-      for (let i = 0, l = el.options.length; i < l; i++) {
-          option = el.options[i];
-          if (isMultiple) {
-              selected = looseIndexOf(value, getValue(option)) > -1;
-              if (option.selected !== selected) {
-                  option.selected = selected;
-              }
-          }
-          else {
-              if (looseEqual(getValue(option), value)) {
-                  if (el.selectedIndex !== i) {
-                      el.selectedIndex = i;
-                  }
-                  return;
-              }
-          }
-      }
-      if (!isMultiple) {
-          el.selectedIndex = -1;
-      }
-  }
-  function hasNoMatchingOption(value, options) {
-      return options.every((o) => !looseEqual(o, value));
-  }
-  function getValue(option) {
-      return '_value' in option ? option._value : option.value;
-  }
-  function onCompositionStart(e) {
-      e.target.composing = true;
-  }
-  function onCompositionEnd(e) {
-      // prevent triggering an input event for no reason
-      if (!e.target.composing)
-          return;
-      e.target.composing = false;
-      trigger(e.target, 'input');
-  }
-  function trigger(el, type) {
-      const e = document.createEvent('HTMLEvents');
-      e.initEvent(type, true, true);
-      el.dispatchEvent(e);
-  }
-
-  // recursively search for possible transition defined inside the component root
-  function locateNode(vnode) {
-      // @ts-expect-error
-      return vnode.componentInstance && (!vnode.data || !vnode.data.transition)
-          ? locateNode(vnode.componentInstance._vnode)
-          : vnode;
-  }
-  var show = {
-      bind(el, { value }, vnode) {
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          const originalDisplay = (el.__vOriginalDisplay =
-              el.style.display === 'none' ? '' : el.style.display);
-          if (value && transition) {
-              vnode.data.show = true;
-              enter(vnode, () => {
-                  el.style.display = originalDisplay;
-              });
-          }
-          else {
-              el.style.display = value ? originalDisplay : 'none';
-          }
-      },
-      update(el, { value, oldValue }, vnode) {
-          /* istanbul ignore if */
-          if (!value === !oldValue)
-              return;
-          vnode = locateNode(vnode);
-          const transition = vnode.data && vnode.data.transition;
-          if (transition) {
-              vnode.data.show = true;
-              if (value) {
-                  enter(vnode, () => {
-                      el.style.display = el.__vOriginalDisplay;
-                  });
-              }
-              else {
-                  leave(vnode, () => {
-                      el.style.display = 'none';
-                  });
-              }
-          }
-          else {
-              el.style.display = value ? el.__vOriginalDisplay : 'none';
-          }
-      },
-      unbind(el, binding, vnode, oldVnode, isDestroy) {
-          if (!isDestroy) {
-              el.style.display = el.__vOriginalDisplay;
-          }
-      },
-  };
-
-  var platformDirectives = {
-      model: directive,
-      show,
-  };
-
-  // Provides transition support for a single element/component.
-  const transitionProps = {
-      name: String,
-      appear: Boolean,
-      css: Boolean,
-      mode: String,
-      type: String,
-      enterClass: String,
-      leaveClass: String,
-      enterToClass: String,
-      leaveToClass: String,
-      enterActiveClass: String,
-      leaveActiveClass: String,
-      appearClass: String,
-      appearActiveClass: String,
-      appearToClass: String,
-      duration: [Number, String, Object],
-  };
-  // in case the child is also an abstract component, e.g. <keep-alive>
-  // we want to recursively retrieve the real component to be rendered
-  function getRealChild(vnode) {
-      const compOptions = vnode && vnode.componentOptions;
-      if (compOptions && compOptions.Ctor.options.abstract) {
-          return getRealChild(getFirstComponentChild(compOptions.children));
-      }
-      else {
-          return vnode;
-      }
-  }
-  function extractTransitionData(comp) {
-      const data = {};
-      const options = comp.$options;
-      // props
-      for (const key in options.propsData) {
-          data[key] = comp[key];
-      }
-      // events.
-      // extract listeners and pass them directly to the transition methods
-      const listeners = options._parentListeners;
-      for (const key in listeners) {
-          data[camelize(key)] = listeners[key];
-      }
-      return data;
-  }
-  function placeholder(h, rawChild) {
-      // @ts-expect-error
-      if (/\d-keep-alive$/.test(rawChild.tag)) {
-          return h('keep-alive', {
-              props: rawChild.componentOptions.propsData,
-          });
-      }
-  }
-  function hasParentTransition(vnode) {
-      while ((vnode = vnode.parent)) {
-          if (vnode.data.transition) {
-              return true;
-          }
-      }
-  }
-  function isSameChild(child, oldChild) {
-      return oldChild.key === child.key && oldChild.tag === child.tag;
-  }
-  const isNotTextNode = (c) => c.tag || isAsyncPlaceholder(c);
-  const isVShowDirective = (d) => d.name === 'show';
-  var Transition = {
-      name: 'transition',
-      props: transitionProps,
-      abstract: true,
-      render(h) {
-          let children = this.$slots.default;
-          if (!children) {
-              return;
-          }
-          // filter out text nodes (possible whitespaces)
-          children = children.filter(isNotTextNode);
-          /* istanbul ignore if */
-          if (!children.length) {
-              return;
-          }
-          // warn multiple elements
-          if (children.length > 1) {
-              warn('<transition> can only be used on a single element. Use ' +
-                  '<transition-group> for lists.', this.$parent);
-          }
-          const mode = this.mode;
-          // warn invalid mode
-          if (mode &&
-              mode !== 'in-out' &&
-              mode !== 'out-in') {
-              warn('invalid <transition> mode: ' + mode, this.$parent);
-          }
-          const rawChild = children[0];
-          // if this is a component root node and the component's
-          // parent container node also has transition, skip.
-          if (hasParentTransition(this.$vnode)) {
-              return rawChild;
-          }
-          // apply transition data to child
-          // use getRealChild() to ignore abstract components e.g. keep-alive
-          const child = getRealChild(rawChild);
-          /* istanbul ignore if */
-          if (!child) {
-              return rawChild;
-          }
-          if (this._leaving) {
-              return placeholder(h, rawChild);
-          }
-          // ensure a key that is unique to the vnode type and to this transition
-          // component instance. This key will be used to remove pending leaving nodes
-          // during entering.
-          const id = `__transition-${this._uid}-`;
-          child.key =
-              child.key == null
-                  ? child.isComment
-                      ? id + 'comment'
-                      : id + child.tag
-                  : isPrimitive(child.key)
-                      ? String(child.key).indexOf(id) === 0
-                          ? child.key
-                          : id + child.key
-                      : child.key;
-          const data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-          const oldRawChild = this._vnode;
-          const oldChild = getRealChild(oldRawChild);
-          // mark v-show
-          // so that the transition module can hand over the control to the directive
-          if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-              child.data.show = true;
-          }
-          if (oldChild &&
-              oldChild.data &&
-              !isSameChild(child, oldChild) &&
-              !isAsyncPlaceholder(oldChild) &&
-              // #6687 component root is a comment node
-              !(oldChild.componentInstance &&
-                  oldChild.componentInstance._vnode.isComment)) {
-              // replace old child transition data with fresh one
-              // important for dynamic transitions!
-              const oldData = (oldChild.data.transition = extend({}, data));
-              // handle transition mode
-              if (mode === 'out-in') {
-                  // return placeholder node and queue update when leave finishes
-                  this._leaving = true;
-                  mergeVNodeHook(oldData, 'afterLeave', () => {
-                      this._leaving = false;
-                      this.$forceUpdate();
-                  });
-                  return placeholder(h, rawChild);
-              }
-              else if (mode === 'in-out') {
-                  if (isAsyncPlaceholder(child)) {
-                      return oldRawChild;
-                  }
-                  let delayedLeave;
-                  const performLeave = () => {
-                      delayedLeave();
-                  };
-                  mergeVNodeHook(data, 'afterEnter', performLeave);
-                  mergeVNodeHook(data, 'enterCancelled', performLeave);
-                  mergeVNodeHook(oldData, 'delayLeave', (leave) => {
-                      delayedLeave = leave;
-                  });
-              }
-          }
-          return rawChild;
-      },
-  };
-
-  // Provides transition support for list items.
-  const props = extend({
-      tag: String,
-      moveClass: String,
-  }, transitionProps);
-  delete props.mode;
-  var TransitionGroup = {
-      props,
-      beforeMount() {
-          const update = this._update;
-          this._update = (vnode, hydrating) => {
-              const restoreActiveInstance = setActiveInstance(this);
-              // force removing pass
-              this.__patch__(this._vnode, this.kept, false, // hydrating
-              true // removeOnly (!important, avoids unnecessary moves)
-              );
-              this._vnode = this.kept;
-              restoreActiveInstance();
-              update.call(this, vnode, hydrating);
-          };
-      },
-      render(h) {
-          const tag = this.tag || this.$vnode.data.tag || "span";
-          const map = Object.create(null);
-          const prevChildren = (this.prevChildren = this.children);
-          const rawChildren = this.$slots.default || [];
-          const children = (this.children = []);
-          const transitionData = extractTransitionData(this);
-          for (let i = 0; i < rawChildren.length; i++) {
-              const c = rawChildren[i];
-              if (c.tag) {
-                  if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-                      children.push(c);
-                      map[c.key] = c;
-                      (c.data || (c.data = {})).transition = transitionData;
-                  }
-                  else {
-                      const opts = c.componentOptions;
-                      const name = opts
-                          ? opts.Ctor.options.name || opts.tag || ""
-                          : c.tag;
-                      warn(`<transition-group> children must be keyed: <${name}>`);
-                  }
-              }
-          }
-          if (prevChildren) {
-              const kept = [];
-              const removed = [];
-              for (let i = 0; i < prevChildren.length; i++) {
-                  const c = prevChildren[i];
-                  c.data.transition = transitionData;
-                  // @ts-expect-error .getBoundingClientRect is not typed in Node
-                  c.data.pos = c.elm.getBoundingClientRect();
-                  if (map[c.key]) {
-                      kept.push(c);
-                  }
-                  else {
-                      removed.push(c);
-                  }
-              }
-              this.kept = h(tag, null, kept);
-              this.removed = removed;
-          }
-          return h(tag, null, children);
-      },
-      updated() {
-          const children = this.prevChildren;
-          const moveClass = this.moveClass || (this.name || "v") + "-move";
-          if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-              return;
-          }
-          // we divide the work into three loops to avoid mixing DOM reads and writes
-          // in each iteration - which helps prevent layout thrashing.
-          children.forEach(callPendingCbs);
-          children.forEach(recordPosition);
-          children.forEach(applyTranslation);
-          // force reflow to put everything in position
-          // assign to this to avoid being removed in tree-shaking
-          // $flow-disable-line
-          this._reflow = document.body.offsetHeight;
-          children.forEach((c) => {
-              if (c.data.moved) {
-                  const el = c.elm;
-                  const s = el.style;
-                  addTransitionClass(el, moveClass);
-                  s.transform = s.WebkitTransform = s.transitionDuration = "";
-                  el.addEventListener(transitionEndEvent, (el._moveCb = function cb(e) {
-                      if (e && e.target !== el) {
-                          return;
-                      }
-                      if (!e || /transform$/.test(e.propertyName)) {
-                          el.removeEventListener(transitionEndEvent, cb);
-                          el._moveCb = null;
-                          removeTransitionClass(el, moveClass);
-                      }
-                  }));
-              }
-          });
-      },
-      methods: {
-          hasMove(el, moveClass) {
-              /* istanbul ignore if */
-              if (!hasTransition) {
-                  return false;
-              }
-              /* istanbul ignore if */
-              if (this._hasMove) {
-                  return this._hasMove;
-              }
-              // Detect whether an element with the move class applied has
-              // CSS transitions. Since the element may be inside an entering
-              // transition at this very moment, we make a clone of it and remove
-              // all other transition classes applied to ensure only the move class
-              // is applied.
-              const clone = el.cloneNode();
-              if (el._transitionClasses) {
-                  el._transitionClasses.forEach((cls) => {
-                      removeClass(clone, cls);
-                  });
-              }
-              addClass(clone, moveClass);
-              clone.style.display = "none";
-              this.$el.appendChild(clone);
-              const info = getTransitionInfo(clone);
-              this.$el.removeChild(clone);
-              return (this._hasMove = info.hasTransform);
-          },
-      },
-  };
-  function callPendingCbs(c) {
-      /* istanbul ignore if */
-      if (c.elm._moveCb) {
-          c.elm._moveCb();
-      }
-      /* istanbul ignore if */
-      if (c.elm._enterCb) {
-          c.elm._enterCb();
-      }
-  }
-  function recordPosition(c) {
-      c.data.newPos = c.elm.getBoundingClientRect();
-  }
-  function applyTranslation(c) {
-      const oldPos = c.data.pos;
-      const newPos = c.data.newPos;
-      const dx = oldPos.left - newPos.left;
-      const dy = oldPos.top - newPos.top;
-      if (dx || dy) {
-          c.data.moved = true;
-          const s = c.elm.style;
-          s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-          s.transitionDuration = "0s";
-      }
-  }
-
-  var platformComponents = {
-      Transition,
-      TransitionGroup,
-  };
-
-  // install platform specific utils
-  Vue.config.mustUseProp = mustUseProp;
-  Vue.config.isReservedTag = isReservedTag;
-  Vue.config.isReservedAttr = isReservedAttr;
-  Vue.config.getTagNamespace = getTagNamespace;
-  Vue.config.isUnknownElement = isUnknownElement;
-  // install platform runtime directives & components
-  extend(Vue.options.directives, platformDirectives);
-  extend(Vue.options.components, platformComponents);
-  // install platform patch function
-  Vue.prototype.__patch__ = inBrowser ? patch : noop;
-  // public mount method
-  Vue.prototype.$mount = function (el, hydrating) {
-      el = el && inBrowser ? query(el) : undefined;
-      return mountComponent(this, el, hydrating);
-  };
-  // devtools global hook
-  /* istanbul ignore next */
-  if (inBrowser) {
-      setTimeout(() => {
-          if (config.devtools) {
-              if (devtools) {
-                  devtools.emit('init', Vue);
-              }
-              else {
-                  // @ts-expect-error
-                  console[console.info ? 'info' : 'log']('Download the Vue Devtools extension for a better development experience:\n' +
-                      'https://github.com/vuejs/vue-devtools');
-              }
-          }
-          if (config.productionTip !== false &&
-              typeof console !== 'undefined') {
-              // @ts-expect-error
-              console[console.info ? 'info' : 'log'](`You are running Vue in development mode.\n` +
-                  `Make sure to turn on production mode when deploying for production.\n` +
-                  `See more tips at https://vuejs.org/guide/deployment.html`);
-          }
-      }, 0);
-  }
-
-  return Vue;
-
-}));
diff --git a/dist/vue.runtime.min.js b/dist/vue.runtime.min.js
deleted file mode 100644
index 308dc809ffc..00000000000
--- a/dist/vue.runtime.min.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-/*!
- * Vue.js v2.6.14
- * (c) 2014-2022 Evan You
- * Released under the MIT License.
- */
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).Vue=e()}(this,(function(){"use strict";const t=Object.freeze({});function e(t){return null==t}function n(t){return null!=t}function o(t){return!0===t}function r(t){return"string"==typeof t||"number"==typeof t||"symbol"==typeof t||"boolean"==typeof t}function s(t){return null!==t&&"object"==typeof t}const i=Object.prototype.toString;function a(t){return"[object Object]"===i.call(t)}function c(t){const e=parseFloat(String(t));return e>=0&&Math.floor(e)===e&&isFinite(t)}function l(t){return n(t)&&"function"==typeof t.then&&"function"==typeof t.catch}function u(t){return null==t?"":Array.isArray(t)||a(t)&&t.toString===i?JSON.stringify(t,null,2):String(t)}function f(t){const e=parseFloat(t);return isNaN(e)?t:e}function d(t,e){const n=Object.create(null),o=t.split(",");for(let t=0;t<o.length;t++)n[o[t]]=!0;return e?t=>n[t.toLowerCase()]:t=>n[t]}const p=d("key,ref,slot,slot-scope,is");function h(t,e){if(t.length){const n=t.indexOf(e);if(n>-1)return t.splice(n,1)}}const m=Object.prototype.hasOwnProperty;function y(t,e){return m.call(t,e)}function v(t){const e=Object.create(null);return function(n){return e[n]||(e[n]=t(n))}}const g=/-(\w)/g,_=v((t=>t.replace(g,((t,e)=>e?e.toUpperCase():"")))),b=v((t=>t.charAt(0).toUpperCase()+t.slice(1))),$=/\B([A-Z])/g,C=v((t=>t.replace($,"-$1").toLowerCase()));const w=Function.prototype.bind?function(t,e){return t.bind(e)}:function(t,e){function n(n){const o=arguments.length;return o?o>1?t.apply(e,arguments):t.call(e,n):t.call(e)}return n._length=t.length,n};function A(t,e){e=e||0;let n=t.length-e;const o=new Array(n);for(;n--;)o[n]=t[n+e];return o}function x(t,e){for(const n in e)t[n]=e[n];return t}function k(t){const e={};for(let n=0;n<t.length;n++)t[n]&&x(e,t[n]);return e}function O(t,e,n){}const S=(t,e,n)=>!1,T=t=>t;function E(t,e){if(t===e)return!0;const n=s(t),o=s(e);if(!n||!o)return!n&&!o&&String(t)===String(e);try{const n=Array.isArray(t),o=Array.isArray(e);if(n&&o)return t.length===e.length&&t.every(((t,n)=>E(t,e[n])));if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(n||o)return!1;{const n=Object.keys(t),o=Object.keys(e);return n.length===o.length&&n.every((n=>E(t[n],e[n])))}}catch(t){return!1}}function I(t,e){for(let n=0;n<t.length;n++)if(E(t[n],e))return n;return-1}function j(t){let e=!1;return function(){e||(e=!0,t.apply(this,arguments))}}const D="data-server-rendered",N=["component","directive","filter"],P=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var L={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:S,isReservedAttr:S,isUnknownElement:S,getTagNamespace:O,parsePlatformTagName:T,mustUseProp:S,async:!0,_lifecycleHooks:P};function M(t){const e=(t+"").charCodeAt(0);return 36===e||95===e}function F(t,e,n,o){Object.defineProperty(t,e,{value:n,enumerable:!!o,writable:!0,configurable:!0})}const R=new RegExp(`[^${/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source}.$_\\d]`);const V="__proto__"in{},U="undefined"!=typeof window,z="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,B=z&&WXEnvironment.platform.toLowerCase(),H=U&&window.navigator.userAgent.toLowerCase(),W=H&&/msie|trident/.test(H),q=H&&H.indexOf("msie 9.0")>0,K=H&&H.indexOf("edge/")>0;H&&H.indexOf("android");const X=H&&/iphone|ipad|ipod|ios/.test(H)||"ios"===B;H&&/chrome\/\d+/.test(H),H&&/phantomjs/.test(H);const G=H&&H.match(/firefox\/(\d+)/),Z={}.watch;let J,Q=!1;if(U)try{const t={};Object.defineProperty(t,"passive",{get(){Q=!0}}),window.addEventListener("test-passive",null,t)}catch(t){}const Y=()=>(void 0===J&&(J=!U&&!z&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),J),tt=U&&window.__VUE_DEVTOOLS_GLOBAL_HOOK__;function et(t){return"function"==typeof t&&/native code/.test(t.toString())}const nt="undefined"!=typeof Symbol&&et(Symbol)&&"undefined"!=typeof Reflect&&et(Reflect.ownKeys);let ot;ot="undefined"!=typeof Set&&et(Set)?Set:class{set=Object.create(null);has(t){return!0===this.set[t]}add(t){this.set[t]=!0}clear(){this.set=Object.create(null)}};let rt=O,st=0;class it{static target;id;subs;constructor(){this.id=st++,this.subs=[]}addSub(t){this.subs.push(t)}removeSub(t){h(this.subs,t)}depend(){it.target&&it.target.addDep(this)}notify(){const t=this.subs.slice();for(let e=0,n=t.length;e<n;e++)t[e].update()}}it.target=null;const at=[];function ct(t){at.push(t),it.target=t}function lt(){at.pop(),it.target=at[at.length-1]}class ut{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(t,e,n,o,r,s,i,a){this.tag=t,this.data=e,this.children=n,this.text=o,this.elm=r,this.ns=void 0,this.context=s,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=e&&e.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=a,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const ft=(t="")=>{const e=new ut;return e.text=t,e.isComment=!0,e};function dt(t){return new ut(void 0,void 0,void 0,String(t))}function pt(t){const e=new ut(t.tag,t.data,t.children&&t.children.slice(),t.text,t.elm,t.context,t.componentOptions,t.asyncFactory);return e.ns=t.ns,e.isStatic=t.isStatic,e.key=t.key,e.isComment=t.isComment,e.fnContext=t.fnContext,e.fnOptions=t.fnOptions,e.fnScopeId=t.fnScopeId,e.asyncMeta=t.asyncMeta,e.isCloned=!0,e}const ht=Array.prototype,mt=Object.create(ht);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(t){const e=ht[t];F(mt,t,(function(...n){const o=e.apply(this,n),r=this.__ob__;let s;switch(t){case"push":case"unshift":s=n;break;case"splice":s=n.slice(2)}return s&&r.observeArray(s),r.dep.notify(),o}))}));const yt=Object.getOwnPropertyNames(mt);let vt=!0;function gt(t){vt=t}class _t{value;dep;vmCount;constructor(t){this.value=t,this.dep=new it,this.vmCount=0,F(t,"__ob__",this),Array.isArray(t)?(V?function(t,e){t.__proto__=e}(t,mt):function(t,e,n){for(let o=0,r=n.length;o<r;o++){const r=n[o];F(t,r,e[r])}}(t,mt,yt),this.observeArray(t)):this.walk(t)}walk(t){const e=Object.keys(t);for(let n=0;n<e.length;n++)$t(t,e[n])}observeArray(t){for(let e=0,n=t.length;e<n;e++)bt(t[e])}}function bt(t,e){if(!s(t)||t instanceof ut)return;let n;return y(t,"__ob__")&&t.__ob__ instanceof _t?n=t.__ob__:vt&&!Y()&&(Array.isArray(t)||a(t))&&Object.isExtensible(t)&&!t._isVue&&(n=new _t(t)),e&&n&&n.vmCount++,n}function $t(t,e,n,o,r){const s=new it,i=Object.getOwnPropertyDescriptor(t,e);if(i&&!1===i.configurable)return;const a=i&&i.get,c=i&&i.set;a&&!c||2!==arguments.length||(n=t[e]);let l=!r&&bt(n);Object.defineProperty(t,e,{enumerable:!0,configurable:!0,get:function(){const e=a?a.call(t):n;return it.target&&(s.depend(),l&&(l.dep.depend(),Array.isArray(e)&&At(e))),e},set:function(e){const o=a?a.call(t):n;e===o||e!=e&&o!=o||a&&!c||(c?c.call(t,e):n=e,l=!r&&bt(e),s.notify())}})}function Ct(t,e,n){if(Array.isArray(t)&&c(e))return t.length=Math.max(t.length,e),t.splice(e,1,n),n;if(e in t&&!(e in Object.prototype))return t[e]=n,n;const o=t.__ob__;return t._isVue||o&&o.vmCount?n:o?($t(o.value,e,n),o.dep.notify(),n):(t[e]=n,n)}function wt(t,e){if(Array.isArray(t)&&c(e))return void t.splice(e,1);const n=t.__ob__;t._isVue||n&&n.vmCount||y(t,e)&&(delete t[e],n&&n.dep.notify())}function At(t){for(let e,n=0,o=t.length;n<o;n++)e=t[n],e&&e.__ob__&&e.__ob__.dep.depend(),Array.isArray(e)&&At(e)}const xt=L.optionMergeStrategies;function kt(t,e){if(!e)return t;let n,o,r;const s=nt?Reflect.ownKeys(e):Object.keys(e);for(let i=0;i<s.length;i++)n=s[i],"__ob__"!==n&&(o=t[n],r=e[n],y(t,n)?o!==r&&a(o)&&a(r)&&kt(o,r):Ct(t,n,r));return t}function Ot(t,e,n){return n?function(){const o="function"==typeof e?e.call(n,n):e,r="function"==typeof t?t.call(n,n):t;return o?kt(o,r):r}:e?t?function(){return kt("function"==typeof e?e.call(this,this):e,"function"==typeof t?t.call(this,this):t)}:e:t}function St(t,e){const n=e?t?t.concat(e):Array.isArray(e)?e:[e]:t;return n?function(t){const e=[];for(let n=0;n<t.length;n++)-1===e.indexOf(t[n])&&e.push(t[n]);return e}(n):n}function Tt(t,e,n,o){const r=Object.create(t||null);return e?x(r,e):r}xt.data=function(t,e,n){return n?Ot(t,e,n):e&&"function"!=typeof e?t:Ot(t,e)},P.forEach((t=>{xt[t]=St})),N.forEach((function(t){xt[t+"s"]=Tt})),xt.watch=function(t,e,n,o){if(t===Z&&(t=void 0),e===Z&&(e=void 0),!e)return Object.create(t||null);if(!t)return e;const r={};x(r,t);for(const t in e){let n=r[t];const o=e[t];n&&!Array.isArray(n)&&(n=[n]),r[t]=n?n.concat(o):Array.isArray(o)?o:[o]}return r},xt.props=xt.methods=xt.inject=xt.computed=function(t,e,n,o){if(!t)return e;const r=Object.create(null);return x(r,t),e&&x(r,e),r},xt.provide=Ot;const Et=function(t,e){return void 0===e?t:e};function It(t,e,n){if("function"==typeof e&&(e=e.options),function(t,e){const n=t.props;if(!n)return;const o={};let r,s,i;if(Array.isArray(n))for(r=n.length;r--;)s=n[r],"string"==typeof s&&(i=_(s),o[i]={type:null});else if(a(n))for(const t in n)s=n[t],i=_(t),o[i]=a(s)?s:{type:s};t.props=o}(e),function(t,e){const n=t.inject;if(!n)return;const o=t.inject={};if(Array.isArray(n))for(let t=0;t<n.length;t++)o[n[t]]={from:n[t]};else if(a(n))for(const t in n){const e=n[t];o[t]=a(e)?x({from:t},e):{from:e}}}(e),function(t){const e=t.directives;if(e)for(const t in e){const n=e[t];"function"==typeof n&&(e[t]={bind:n,update:n})}}(e),!e._base&&(e.extends&&(t=It(t,e.extends,n)),e.mixins))for(let o=0,r=e.mixins.length;o<r;o++)t=It(t,e.mixins[o],n);const o={};let r;for(r in t)s(r);for(r in e)y(t,r)||s(r);function s(r){const s=xt[r]||Et;o[r]=s(t[r],e[r],n,r)}return o}function jt(t,e,n,o){if("string"!=typeof n)return;const r=t[e];if(y(r,n))return r[n];const s=_(n);if(y(r,s))return r[s];const i=b(s);if(y(r,i))return r[i];return r[n]||r[s]||r[i]}function Dt(t,e,n,o){const r=e[t],s=!y(n,t);let i=n[t];const a=Mt(Boolean,r.type);if(a>-1)if(s&&!y(r,"default"))i=!1;else if(""===i||i===C(t)){const t=Mt(String,r.type);(t<0||a<t)&&(i=!0)}if(void 0===i){i=function(t,e,n){if(!y(e,"default"))return;const o=e.default;if(t&&t.$options.propsData&&void 0===t.$options.propsData[n]&&void 0!==t._props[n])return t._props[n];return"function"==typeof o&&"Function"!==Pt(e.type)?o.call(t):o}(o,r,t);const e=vt;gt(!0),bt(i),gt(e)}return i}const Nt=/^\s*function (\w+)/;function Pt(t){const e=t&&t.toString().match(Nt);return e?e[1]:""}function Lt(t,e){return Pt(t)===Pt(e)}function Mt(t,e){if(!Array.isArray(e))return Lt(e,t)?0:-1;for(let n=0,o=e.length;n<o;n++)if(Lt(e[n],t))return n;return-1}function Ft(t,e,n){ct();try{if(e){let o=e;for(;o=o.$parent;){const r=o.$options.errorCaptured;if(r)for(let s=0;s<r.length;s++)try{if(!1===r[s].call(o,t,e,n))return}catch(t){Vt(t,o,"errorCaptured hook")}}}Vt(t,e,n)}finally{lt()}}function Rt(t,e,n,o,r){let s;try{s=n?t.apply(e,n):t.call(e),s&&!s._isVue&&l(s)&&!s._handled&&(s.catch((t=>Ft(t,o,r+" (Promise/async)"))),s._handled=!0)}catch(t){Ft(t,o,r)}return s}function Vt(t,e,n){if(L.errorHandler)try{return L.errorHandler.call(null,t,e,n)}catch(e){e!==t&&Ut(e)}Ut(t)}function Ut(t,e,n){if(!U&&!z||"undefined"==typeof console)throw t;console.error(t)}let zt=!1;const Bt=[];let Ht,Wt=!1;function qt(){Wt=!1;const t=Bt.slice(0);Bt.length=0;for(let e=0;e<t.length;e++)t[e]()}if("undefined"!=typeof Promise&&et(Promise)){const t=Promise.resolve();Ht=()=>{t.then(qt),X&&setTimeout(O)},zt=!0}else if(W||"undefined"==typeof MutationObserver||!et(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())Ht="undefined"!=typeof setImmediate&&et(setImmediate)?()=>{setImmediate(qt)}:()=>{setTimeout(qt,0)};else{let t=1;const e=new MutationObserver(qt),n=document.createTextNode(String(t));e.observe(n,{characterData:!0}),Ht=()=>{t=(t+1)%2,n.data=String(t)},zt=!0}function Kt(t,e){let n;if(Bt.push((()=>{if(t)try{t.call(e)}catch(t){Ft(t,e,"nextTick")}else n&&n(e)})),Wt||(Wt=!0,Ht()),!t&&"undefined"!=typeof Promise)return new Promise((t=>{n=t}))}const Xt=new ot;function Gt(t){Zt(t,Xt),Xt.clear()}function Zt(t,e){let n,o;const r=Array.isArray(t);if(!(!r&&!s(t)||Object.isFrozen(t)||t instanceof ut)){if(t.__ob__){const n=t.__ob__.dep.id;if(e.has(n))return;e.add(n)}if(r)for(n=t.length;n--;)Zt(t[n],e);else for(o=Object.keys(t),n=o.length;n--;)Zt(t[o[n]],e)}}const Jt=v((t=>{const e="&"===t.charAt(0),n="~"===(t=e?t.slice(1):t).charAt(0),o="!"===(t=n?t.slice(1):t).charAt(0);return{name:t=o?t.slice(1):t,once:n,capture:o,passive:e}}));function Qt(t,e){function n(){const t=n.fns;if(!Array.isArray(t))return Rt(t,null,arguments,e,"v-on handler");{const n=t.slice();for(let t=0;t<n.length;t++)Rt(n[t],null,arguments,e,"v-on handler")}}return n.fns=t,n}function Yt(t,n,r,s,i,a){let c,l,u,f;for(c in t)l=t[c],u=n[c],f=Jt(c),e(l)||(e(u)?(e(l.fns)&&(l=t[c]=Qt(l,a)),o(f.once)&&(l=t[c]=i(f.name,l,f.capture)),r(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,t[c]=u));for(c in n)e(t[c])&&(f=Jt(c),s(f.name,n[c],f.capture))}function te(t,r,s){let i;t instanceof ut&&(t=t.data.hook||(t.data.hook={}));const a=t[r];function c(){s.apply(this,arguments),h(i.fns,c)}e(a)?i=Qt([c]):n(a.fns)&&o(a.merged)?(i=a,i.fns.push(c)):i=Qt([a,c]),i.merged=!0,t[r]=i}function ee(t,e,o,r,s){if(n(e)){if(y(e,o))return t[o]=e[o],s||delete e[o],!0;if(y(e,r))return t[o]=e[r],s||delete e[r],!0}return!1}function ne(t){return r(t)?[dt(t)]:Array.isArray(t)?re(t):void 0}function oe(t){return n(t)&&n(t.text)&&!1===t.isComment}function re(t,s){const i=[];let a,c,l,u;for(a=0;a<t.length;a++)c=t[a],e(c)||"boolean"==typeof c||(l=i.length-1,u=i[l],Array.isArray(c)?c.length>0&&(c=re(c,`${s||""}_${a}`),oe(c[0])&&oe(u)&&(i[l]=dt(u.text+c[0].text),c.shift()),i.push.apply(i,c)):r(c)?oe(u)?i[l]=dt(u.text+c):""!==c&&i.push(dt(c)):oe(c)&&oe(u)?i[l]=dt(u.text+c.text):(o(t._isVList)&&n(c.tag)&&e(c.key)&&n(s)&&(c.key=`__vlist${s}_${a}__`),i.push(c)));return i}function se(t,e){if(t){const n=Object.create(null),o=nt?Reflect.ownKeys(t):Object.keys(t);for(let r=0;r<o.length;r++){const s=o[r];if("__ob__"===s)continue;const i=t[s].from;let a=e;for(;a;){if(a._provided&&y(a._provided,i)){n[s]=a._provided[i];break}a=a.$parent}if(!a&&"default"in t[s]){const o=t[s].default;n[s]="function"==typeof o?o.call(e):o}}return n}}function ie(t,e){if(!t||!t.length)return{};const n={};for(let o=0,r=t.length;o<r;o++){const r=t[o],s=r.data;if(s&&s.attrs&&s.attrs.slot&&delete s.attrs.slot,r.context!==e&&r.fnContext!==e||!s||null==s.slot)(n.default||(n.default=[])).push(r);else{const t=s.slot,e=n[t]||(n[t]=[]);"template"===r.tag?e.push.apply(e,r.children||[]):e.push(r)}}for(const t in n)n[t].every(ae)&&delete n[t];return n}function ae(t){return t.isComment&&!t.asyncFactory||" "===t.text}function ce(t){return t.isComment&&t.asyncFactory}function le(e,n,o){let r;const s=Object.keys(n).length>0,i=e?!!e.$stable:!s,a=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&o&&o!==t&&a===o.$key&&!s&&!o.$hasNormal)return o;r={};for(const t in e)e[t]&&"$"!==t[0]&&(r[t]=ue(n,t,e[t]))}else r={};for(const t in n)t in r||(r[t]=fe(n,t));return e&&Object.isExtensible(e)&&(e._normalized=r),F(r,"$stable",i),F(r,"$key",a),F(r,"$hasNormal",s),r}function ue(t,e,n){const o=function(){let t=arguments.length?n.apply(null,arguments):n({});t=t&&"object"==typeof t&&!Array.isArray(t)?[t]:ne(t);const e=t&&t[0];return t&&(!e||1===t.length&&e.isComment&&!ce(e))?void 0:t};return n.proxy&&Object.defineProperty(t,e,{get:o,enumerable:!0,configurable:!0}),o}function fe(t,e){return()=>t[e]}function de(t,e){let o,r,i,a,c=null;if(Array.isArray(t)||"string"==typeof t)for(c=new Array(t.length),o=0,r=t.length;o<r;o++)c[o]=e(t[o],o);else if("number"==typeof t)for(c=new Array(t),o=0;o<t;o++)c[o]=e(o+1,o);else if(s(t))if(nt&&t[Symbol.iterator]){c=[];const n=t[Symbol.iterator]();let o=n.next();for(;!o.done;)c.push(e(o.value,c.length)),o=n.next()}else for(i=Object.keys(t),c=new Array(i.length),o=0,r=i.length;o<r;o++)a=i[o],c[o]=e(t[a],a,o);return n(c)||(c=[]),c._isVList=!0,c}function pe(t,e,n,o){const r=this.$scopedSlots[t];let s;r?(n=n||{},o&&(n=x(x({},o),n)),s=r(n)||("function"==typeof e?e():e)):s=this.$slots[t]||("function"==typeof e?e():e);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},s):s}function he(t){return jt(this.$options,"filters",t)||T}function me(t,e){return Array.isArray(t)?-1===t.indexOf(e):t!==e}function ye(t,e,n,o,r){const s=L.keyCodes[e]||n;return r&&o&&!L.keyCodes[e]?me(r,o):s?me(s,t):o?C(o)!==e:void 0===t}function ve(t,e,n,o,r){if(n)if(s(n)){let s;Array.isArray(n)&&(n=k(n));for(const i in n){if("class"===i||"style"===i||p(i))s=t;else{const n=t.attrs&&t.attrs.type;s=o||L.mustUseProp(e,n,i)?t.domProps||(t.domProps={}):t.attrs||(t.attrs={})}const a=_(i),c=C(i);if(!(a in s)&&!(c in s)&&(s[i]=n[i],r)){(t.on||(t.on={}))[`update:${i}`]=function(t){n[i]=t}}}}else;return t}function ge(t,e){const n=this._staticTrees||(this._staticTrees=[]);let o=n[t];return o&&!e||(o=n[t]=this.$options.staticRenderFns[t].call(this._renderProxy,null,this),be(o,`__static__${t}`,!1)),o}function _e(t,e,n){return be(t,`__once__${e}${n?`_${n}`:""}`,!0),t}function be(t,e,n){if(Array.isArray(t))for(let o=0;o<t.length;o++)t[o]&&"string"!=typeof t[o]&&$e(t[o],`${e}_${o}`,n);else $e(t,e,n)}function $e(t,e,n){t.isStatic=!0,t.key=e,t.isOnce=n}function Ce(t,e){if(e)if(a(e)){const n=t.on=t.on?x({},t.on):{};for(const t in e){const o=n[t],r=e[t];n[t]=o?[].concat(o,r):r}}else;return t}function we(t,e,n,o){e=e||{$stable:!n};for(let o=0;o<t.length;o++){const r=t[o];Array.isArray(r)?we(r,e,n):r&&(r.proxy&&(r.fn.proxy=!0),e[r.key]=r.fn)}return o&&(e.$key=o),e}function Ae(t,e){for(let n=0;n<e.length;n+=2){const o=e[n];"string"==typeof o&&o&&(t[e[n]]=e[n+1])}return t}function xe(t,e){return"string"==typeof t?e+t:t}function ke(t){t._o=_e,t._n=f,t._s=u,t._l=de,t._t=pe,t._q=E,t._i=I,t._m=ge,t._f=he,t._k=ye,t._b=ve,t._v=dt,t._e=ft,t._u=we,t._g=Ce,t._d=Ae,t._p=xe}function Oe(e,n,r,s,i){const a=i.options;let c;y(s,"_uid")?(c=Object.create(s),c._original=s):(c=s,s=s._original);const l=o(a._compiled),u=!l;this.data=e,this.props=n,this.children=r,this.parent=s,this.listeners=e.on||t,this.injections=se(a.inject,s),this.slots=()=>(this.$slots||le(e.scopedSlots,this.$slots=ie(r,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return le(e.scopedSlots,this.slots())}}),l&&(this.$options=a,this.$slots=this.slots(),this.$scopedSlots=le(e.scopedSlots,this.$slots)),a._scopeId?this._c=(t,e,n,o)=>{const r=Ne(c,t,e,n,o,u);return r&&!Array.isArray(r)&&(r.fnScopeId=a._scopeId,r.fnContext=s),r}:this._c=(t,e,n,o)=>Ne(c,t,e,n,o,u)}function Se(t,e,n,o,r){const s=pt(t);return s.fnContext=n,s.fnOptions=o,e.slot&&((s.data||(s.data={})).slot=e.slot),s}function Te(t,e){for(const n in e)t[_(n)]=e[n]}ke(Oe.prototype);const Ee={init(t,e){if(t.componentInstance&&!t.componentInstance._isDestroyed&&t.data.keepAlive){const e=t;Ee.prepatch(e,e)}else{(t.componentInstance=function(t,e){const o={_isComponent:!0,_parentVnode:t,parent:e},r=t.data.inlineTemplate;n(r)&&(o.render=r.render,o.staticRenderFns=r.staticRenderFns);return new t.componentOptions.Ctor(o)}(t,He)).$mount(e?t.elm:void 0,e)}},prepatch(e,n){const o=n.componentOptions;!function(e,n,o,r,s){const i=r.data.scopedSlots,a=e.$scopedSlots,c=!!(i&&!i.$stable||a!==t&&!a.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(s||e.$options._renderChildren||c);e.$options._parentVnode=r,e.$vnode=r,e._vnode&&(e._vnode.parent=r);if(e.$options._renderChildren=s,e.$attrs=r.data.attrs||t,e.$listeners=o||t,n&&e.$options.props){gt(!1);const t=e._props,o=e.$options._propKeys||[];for(let r=0;r<o.length;r++){const s=o[r],i=e.$options.props;t[s]=Dt(s,i,n,e)}gt(!0),e.$options.propsData=n}o=o||t;const u=e.$options._parentListeners;e.$options._parentListeners=o,Be(e,o,u),l&&(e.$slots=ie(s,r.context),e.$forceUpdate())}(n.componentInstance=e.componentInstance,o.propsData,o.listeners,n,o.children)},insert(t){const{context:e,componentInstance:n}=t;var o;n._isMounted||(n._isMounted=!0,Ge(n,"mounted")),t.data.keepAlive&&(e._isMounted?((o=n)._inactive=!1,Je.push(o)):Ke(n,!0))},destroy(t){const{componentInstance:e}=t;e._isDestroyed||(t.data.keepAlive?Xe(e,!0):e.$destroy())}},Ie=Object.keys(Ee);function je(r,i,a,c,u){if(e(r))return;const f=a.$options._base;if(s(r)&&(r=f.extend(r)),"function"!=typeof r)return;let d;if(e(r.cid)&&(d=r,r=function(t,r){if(o(t.error)&&n(t.errorComp))return t.errorComp;if(n(t.resolved))return t.resolved;const i=Me;i&&n(t.owners)&&-1===t.owners.indexOf(i)&&t.owners.push(i);if(o(t.loading)&&n(t.loadingComp))return t.loadingComp;if(i&&!n(t.owners)){const o=t.owners=[i];let a=!0,c=null,u=null;i.$on("hook:destroyed",(()=>h(o,i)));const f=t=>{for(let t=0,e=o.length;t<e;t++)o[t].$forceUpdate();t&&(o.length=0,null!==c&&(clearTimeout(c),c=null),null!==u&&(clearTimeout(u),u=null))},d=j((e=>{t.resolved=Fe(e,r),a?o.length=0:f(!0)})),p=j((e=>{n(t.errorComp)&&(t.error=!0,f(!0))})),m=t(d,p);return s(m)&&(l(m)?e(t.resolved)&&m.then(d,p):l(m.component)&&(m.component.then(d,p),n(m.error)&&(t.errorComp=Fe(m.error,r)),n(m.loading)&&(t.loadingComp=Fe(m.loading,r),0===m.delay?t.loading=!0:c=setTimeout((()=>{c=null,e(t.resolved)&&e(t.error)&&(t.loading=!0,f(!1))}),m.delay||200)),n(m.timeout)&&(u=setTimeout((()=>{u=null,e(t.resolved)&&p(null)}),m.timeout)))),a=!1,t.loading?t.loadingComp:t.resolved}}(d,f),void 0===r))return function(t,e,n,o,r){const s=ft();return s.asyncFactory=t,s.asyncMeta={data:e,context:n,children:o,tag:r},s}(d,i,a,c,u);i=i||{},vn(r),n(i.model)&&function(t,e){const o=t.model&&t.model.prop||"value",r=t.model&&t.model.event||"input";(e.attrs||(e.attrs={}))[o]=e.model.value;const s=e.on||(e.on={}),i=s[r],a=e.model.callback;n(i)?(Array.isArray(i)?-1===i.indexOf(a):i!==a)&&(s[r]=[a].concat(i)):s[r]=a}(r.options,i);const p=function(t,o,r){const s=o.options.props;if(e(s))return;const i={},{attrs:a,props:c}=t;if(n(a)||n(c))for(const t in s){const e=C(t);ee(i,c,t,e,!0)||ee(i,a,t,e,!1)}return i}(i,r);if(o(r.options.functional))return function(e,o,r,s,i){const a=e.options,c={},l=a.props;if(n(l))for(const e in l)c[e]=Dt(e,l,o||t);else n(r.attrs)&&Te(c,r.attrs),n(r.props)&&Te(c,r.props);const u=new Oe(r,c,i,s,e),f=a.render.call(null,u._c,u);if(f instanceof ut)return Se(f,r,u.parent,a);if(Array.isArray(f)){const t=ne(f)||[],e=new Array(t.length);for(let n=0;n<t.length;n++)e[n]=Se(t[n],r,u.parent,a);return e}}(r,p,i,a,c);const m=i.on;if(i.on=i.nativeOn,o(r.options.abstract)){const t=i.slot;i={},t&&(i.slot=t)}!function(t){const e=t.hook||(t.hook={});for(let t=0;t<Ie.length;t++){const n=Ie[t],o=e[n],r=Ee[n];o===r||o&&o._merged||(e[n]=o?De(r,o):r)}}(i);const y=r.options.name||u;return new ut(`vue-component-${r.cid}${y?`-${y}`:""}`,i,void 0,void 0,void 0,a,{Ctor:r,propsData:p,listeners:m,tag:u,children:c},d)}function De(t,e){const n=(n,o)=>{t(n,o),e(n,o)};return n._merged=!0,n}function Ne(t,e,i,a,c,l){return(Array.isArray(i)||r(i))&&(c=a,a=i,i=void 0),o(l)&&(c=2),function(t,e,o,r,i){if(n(o)&&n(o.__ob__))return ft();n(o)&&n(o.is)&&(e=o.is);if(!e)return ft();Array.isArray(r)&&"function"==typeof r[0]&&((o=o||{}).scopedSlots={default:r[0]},r.length=0);2===i?r=ne(r):1===i&&(r=function(t){for(let e=0;e<t.length;e++)if(Array.isArray(t[e]))return Array.prototype.concat.apply([],t);return t}(r));let a,c;if("string"==typeof e){let s;c=t.$vnode&&t.$vnode.ns||L.getTagNamespace(e),a=L.isReservedTag(e)?new ut(L.parsePlatformTagName(e),o,r,void 0,void 0,t):o&&o.pre||!n(s=jt(t.$options,"components",e))?new ut(e,o,r,void 0,void 0,t):je(s,o,t,r,e)}else a=je(e,o,t,r);return Array.isArray(a)?a:n(a)?(n(c)&&Pe(a,c),n(o)&&function(t){s(t.style)&&Gt(t.style);s(t.class)&&Gt(t.class)}(o),a):ft()}(t,e,i,a,c)}function Pe(t,r,s){if(t.ns=r,"foreignObject"===t.tag&&(r=void 0,s=!0),n(t.children))for(let i=0,a=t.children.length;i<a;i++){const a=t.children[i];n(a.tag)&&(e(a.ns)||o(s)&&"svg"!==a.tag)&&Pe(a,r,s)}}let Le,Me=null;function Fe(t,e){return(t.__esModule||nt&&"Module"===t[Symbol.toStringTag])&&(t=t.default),s(t)?e.extend(t):t}function Re(t){if(Array.isArray(t))for(let e=0;e<t.length;e++){const o=t[e];if(n(o)&&(n(o.componentOptions)||ce(o)))return o}}function Ve(t,e){Le.$on(t,e)}function Ue(t,e){Le.$off(t,e)}function ze(t,e){const n=Le;return function o(){const r=e.apply(null,arguments);null!==r&&n.$off(t,o)}}function Be(t,e,n){Le=t,Yt(e,n||{},Ve,Ue,ze,t),Le=void 0}let He=null;function We(t){const e=He;return He=t,()=>{He=e}}function qe(t){for(;t&&(t=t.$parent);)if(t._inactive)return!0;return!1}function Ke(t,e){if(e){if(t._directInactive=!1,qe(t))return}else if(t._directInactive)return;if(t._inactive||null===t._inactive){t._inactive=!1;for(let e=0;e<t.$children.length;e++)Ke(t.$children[e]);Ge(t,"activated")}}function Xe(t,e){if(!(e&&(t._directInactive=!0,qe(t))||t._inactive)){t._inactive=!0;for(let e=0;e<t.$children.length;e++)Xe(t.$children[e]);Ge(t,"deactivated")}}function Ge(t,e){ct();const n=t.$options[e],o=`${e} hook`;if(n)for(let e=0,r=n.length;e<r;e++)Rt(n[e],t,null,t,o);t._hasHookEvent&&t.$emit("hook:"+e),lt()}const Ze=[],Je=[];let Qe={},Ye=!1,tn=!1,en=0;let nn=0,on=Date.now;if(U&&!W){const t=window.performance;t&&"function"==typeof t.now&&on()>document.createEvent("Event").timeStamp&&(on=()=>t.now())}function rn(){let t,e;for(nn=on(),tn=!0,Ze.sort(((t,e)=>t.id-e.id)),en=0;en<Ze.length;en++)t=Ze[en],t.before&&t.before(),e=t.id,Qe[e]=null,t.run();const n=Je.slice(),o=Ze.slice();en=Ze.length=Je.length=0,Qe={},Ye=tn=!1,function(t){for(let e=0;e<t.length;e++)t[e]._inactive=!0,Ke(t[e],!0)}(n),function(t){let e=t.length;for(;e--;){const n=t[e],o=n.vm;o._watcher===n&&o._isMounted&&!o._isDestroyed&&Ge(o,"updated")}}(o),tt&&L.devtools&&tt.emit("flush")}let sn=0;class an{vm;expression;cb;id;deep;user;lazy;sync;dirty;active;deps;newDeps;depIds;newDepIds;before;getter;value;constructor(t,e,n,o,r){this.vm=t,r&&(t._watcher=this),t._watchers.push(this),o?(this.deep=!!o.deep,this.user=!!o.user,this.lazy=!!o.lazy,this.sync=!!o.sync,this.before=o.before):this.deep=this.user=this.lazy=this.sync=!1,this.cb=n,this.id=++sn,this.active=!0,this.dirty=this.lazy,this.deps=[],this.newDeps=[],this.depIds=new ot,this.newDepIds=new ot,this.expression="","function"==typeof e?this.getter=e:(this.getter=function(t){if(R.test(t))return;const e=t.split(".");return function(t){for(let n=0;n<e.length;n++){if(!t)return;t=t[e[n]]}return t}}(e),this.getter||(this.getter=O)),this.value=this.lazy?void 0:this.get()}get(){let t;ct(this);const e=this.vm;try{t=this.getter.call(e,e)}catch(t){if(!this.user)throw t;Ft(t,e,`getter for watcher "${this.expression}"`)}finally{this.deep&&Gt(t),lt(),this.cleanupDeps()}return t}addDep(t){const e=t.id;this.newDepIds.has(e)||(this.newDepIds.add(e),this.newDeps.push(t),this.depIds.has(e)||t.addSub(this))}cleanupDeps(){let t=this.deps.length;for(;t--;){const e=this.deps[t];this.newDepIds.has(e.id)||e.removeSub(this)}let e=this.depIds;this.depIds=this.newDepIds,this.newDepIds=e,this.newDepIds.clear(),e=this.deps,this.deps=this.newDeps,this.newDeps=e,this.newDeps.length=0}update(){this.lazy?this.dirty=!0:this.sync?this.run():function(t){const e=t.id;if(null==Qe[e]){if(Qe[e]=!0,tn){let e=Ze.length-1;for(;e>en&&Ze[e].id>t.id;)e--;Ze.splice(e+1,0,t)}else Ze.push(t);Ye||(Ye=!0,Kt(rn))}}(this)}run(){if(this.active){const t=this.get();if(t!==this.value||s(t)||this.deep){const e=this.value;if(this.value=t,this.user){const n=`callback for watcher "${this.expression}"`;Rt(this.cb,this.vm,[t,e],this.vm,n)}else this.cb.call(this.vm,t,e)}}}evaluate(){this.value=this.get(),this.dirty=!1}depend(){let t=this.deps.length;for(;t--;)this.deps[t].depend()}teardown(){if(this.active){this.vm._isBeingDestroyed||h(this.vm._watchers,this);let t=this.deps.length;for(;t--;)this.deps[t].removeSub(this);this.active=!1}}}const cn={enumerable:!0,configurable:!0,get:O,set:O};function ln(t,e,n){cn.get=function(){return this[e][n]},cn.set=function(t){this[e][n]=t},Object.defineProperty(t,n,cn)}function un(t){t._watchers=[];const e=t.$options;e.props&&function(t,e){const n=t.$options.propsData||{},o=t._props={},r=t.$options._propKeys=[];t.$parent&&gt(!1);for(const s in e){r.push(s);$t(o,s,Dt(s,e,n,t)),s in t||ln(t,"_props",s)}gt(!0)}(t,e.props),e.methods&&function(t,e){t.$options.props;for(const n in e)t[n]="function"!=typeof e[n]?O:w(e[n],t)}(t,e.methods),e.data?function(t){let e=t.$options.data;e=t._data="function"==typeof e?function(t,e){ct();try{return t.call(e,e)}catch(t){return Ft(t,e,"data()"),{}}finally{lt()}}(e,t):e||{},a(e)||(e={});const n=Object.keys(e),o=t.$options.props;t.$options.methods;let r=n.length;for(;r--;){const e=n[r];o&&y(o,e)||M(e)||ln(t,"_data",e)}bt(e,!0)}(t):bt(t._data={},!0),e.computed&&function(t,e){const n=t._computedWatchers=Object.create(null),o=Y();for(const r in e){const s=e[r],i="function"==typeof s?s:s.get;o||(n[r]=new an(t,i||O,O,fn)),r in t||dn(t,r,s)}}(t,e.computed),e.watch&&e.watch!==Z&&function(t,e){for(const n in e){const o=e[n];if(Array.isArray(o))for(let e=0;e<o.length;e++)mn(t,n,o[e]);else mn(t,n,o)}}(t,e.watch)}const fn={lazy:!0};function dn(t,e,n){const o=!Y();"function"==typeof n?(cn.get=o?pn(e):hn(n),cn.set=O):(cn.get=n.get?o&&!1!==n.cache?pn(e):hn(n.get):O,cn.set=n.set||O),Object.defineProperty(t,e,cn)}function pn(t){return function(){const e=this._computedWatchers&&this._computedWatchers[t];if(e)return e.dirty&&e.evaluate(),it.target&&e.depend(),e.value}}function hn(t){return function(){return t.call(this,this)}}function mn(t,e,n,o){return a(n)&&(o=n,n=n.handler),"string"==typeof n&&(n=t[n]),t.$watch(e,n,o)}let yn=0;function vn(t){let e=t.options;if(t.super){const n=vn(t.super);if(n!==t.superOptions){t.superOptions=n;const o=function(t){let e;const n=t.options,o=t.sealedOptions;for(const t in n)n[t]!==o[t]&&(e||(e={}),e[t]=n[t]);return e}(t);o&&x(t.extendOptions,o),e=t.options=It(n,t.extendOptions),e.name&&(e.components[e.name]=t)}}return e}function gn(t){this._init(t)}function _n(t){t.cid=0;let e=1;t.extend=function(t){t=t||{};const n=this,o=n.cid,r=t._Ctor||(t._Ctor={});if(r[o])return r[o];const s=t.name||n.options.name,i=function(t){this._init(t)};return(i.prototype=Object.create(n.prototype)).constructor=i,i.cid=e++,i.options=It(n.options,t),i.super=n,i.options.props&&function(t){const e=t.options.props;for(const n in e)ln(t.prototype,"_props",n)}(i),i.options.computed&&function(t){const e=t.options.computed;for(const n in e)dn(t.prototype,n,e[n])}(i),i.extend=n.extend,i.mixin=n.mixin,i.use=n.use,N.forEach((function(t){i[t]=n[t]})),s&&(i.options.components[s]=i),i.superOptions=n.options,i.extendOptions=t,i.sealedOptions=x({},i.options),r[o]=i,i}}function bn(t){return t&&(t.Ctor.options.name||t.tag)}function $n(t,e){return Array.isArray(t)?t.indexOf(e)>-1:"string"==typeof t?t.split(",").indexOf(e)>-1:(n=t,"[object RegExp]"===i.call(n)&&t.test(e));var n}function Cn(t,e){const{cache:n,keys:o,_vnode:r}=t;for(const t in n){const s=n[t];if(s){const i=s.name;i&&!e(i)&&wn(n,t,o,r)}}}function wn(t,e,n,o){const r=t[e];!r||o&&r.tag===o.tag||r.componentInstance.$destroy(),t[e]=null,h(n,e)}!function(e){e.prototype._init=function(e){const n=this;n._uid=yn++,n._isVue=!0,e&&e._isComponent?function(t,e){const n=t.$options=Object.create(t.constructor.options),o=e._parentVnode;n.parent=e.parent,n._parentVnode=o;const r=o.componentOptions;n.propsData=r.propsData,n._parentListeners=r.listeners,n._renderChildren=r.children,n._componentTag=r.tag,e.render&&(n.render=e.render,n.staticRenderFns=e.staticRenderFns)}(n,e):n.$options=It(vn(n.constructor),e||{},n),n._renderProxy=n,n._self=n,function(t){const e=t.$options;let n=e.parent;if(n&&!e.abstract){for(;n.$options.abstract&&n.$parent;)n=n.$parent;n.$children.push(t)}t.$parent=n,t.$root=n?n.$root:t,t.$children=[],t.$refs={},t._watcher=null,t._inactive=null,t._directInactive=!1,t._isMounted=!1,t._isDestroyed=!1,t._isBeingDestroyed=!1}(n),function(t){t._events=Object.create(null),t._hasHookEvent=!1;const e=t.$options._parentListeners;e&&Be(t,e)}(n),function(e){e._vnode=null,e._staticTrees=null;const n=e.$options,o=e.$vnode=n._parentVnode,r=o&&o.context;e.$slots=ie(n._renderChildren,r),e.$scopedSlots=t,e._c=(t,n,o,r)=>Ne(e,t,n,o,r,!1),e.$createElement=(t,n,o,r)=>Ne(e,t,n,o,r,!0);const s=o&&o.data;$t(e,"$attrs",s&&s.attrs||t,null,!0),$t(e,"$listeners",n._parentListeners||t,null,!0)}(n),Ge(n,"beforeCreate"),function(t){const e=se(t.$options.inject,t);e&&(gt(!1),Object.keys(e).forEach((n=>{$t(t,n,e[n])})),gt(!0))}(n),un(n),function(t){const e=t.$options.provide;e&&(t._provided="function"==typeof e?e.call(t):e)}(n),Ge(n,"created"),n.$options.el&&n.$mount(n.$options.el)}}(gn),function(t){const e={get:function(){return this._data}},n={get:function(){return this._props}};Object.defineProperty(t.prototype,"$data",e),Object.defineProperty(t.prototype,"$props",n),t.prototype.$set=Ct,t.prototype.$delete=wt,t.prototype.$watch=function(t,e,n){const o=this;if(a(e))return mn(o,t,e,n);(n=n||{}).user=!0;const r=new an(o,t,e,n);if(n.immediate){const t=`callback for immediate watcher "${r.expression}"`;ct(),Rt(e,o,[r.value],o,t),lt()}return function(){r.teardown()}}}(gn),function(t){const e=/^hook:/;t.prototype.$on=function(t,n){const o=this;if(Array.isArray(t))for(let e=0,r=t.length;e<r;e++)o.$on(t[e],n);else(o._events[t]||(o._events[t]=[])).push(n),e.test(t)&&(o._hasHookEvent=!0);return o},t.prototype.$once=function(t,e){const n=this;function o(){n.$off(t,o),e.apply(n,arguments)}return o.fn=e,n.$on(t,o),n},t.prototype.$off=function(t,e){const n=this;if(!arguments.length)return n._events=Object.create(null),n;if(Array.isArray(t)){for(let o=0,r=t.length;o<r;o++)n.$off(t[o],e);return n}const o=n._events[t];if(!o)return n;if(!e)return n._events[t]=null,n;let r,s=o.length;for(;s--;)if(r=o[s],r===e||r.fn===e){o.splice(s,1);break}return n},t.prototype.$emit=function(t){const e=this;let n=e._events[t];if(n){n=n.length>1?A(n):n;const o=A(arguments,1),r=`event handler for "${t}"`;for(let t=0,s=n.length;t<s;t++)Rt(n[t],e,o,e,r)}return e}}(gn),function(t){t.prototype._update=function(t,e){const n=this,o=n.$el,r=n._vnode,s=We(n);n._vnode=t,n.$el=r?n.__patch__(r,t):n.__patch__(n.$el,t,e,!1),s(),o&&(o.__vue__=null),n.$el&&(n.$el.__vue__=n),n.$vnode&&n.$parent&&n.$vnode===n.$parent._vnode&&(n.$parent.$el=n.$el)},t.prototype.$forceUpdate=function(){const t=this;t._watcher&&t._watcher.update()},t.prototype.$destroy=function(){const t=this;if(t._isBeingDestroyed)return;Ge(t,"beforeDestroy"),t._isBeingDestroyed=!0;const e=t.$parent;!e||e._isBeingDestroyed||t.$options.abstract||h(e.$children,t),t._watcher&&t._watcher.teardown();let n=t._watchers.length;for(;n--;)t._watchers[n].teardown();t._data.__ob__&&t._data.__ob__.vmCount--,t._isDestroyed=!0,t.__patch__(t._vnode,null),Ge(t,"destroyed"),t.$off(),t.$el&&(t.$el.__vue__=null),t.$vnode&&(t.$vnode.parent=null)}}(gn),function(t){ke(t.prototype),t.prototype.$nextTick=function(t){return Kt(t,this)},t.prototype._render=function(){const t=this,{render:e,_parentVnode:n}=t.$options;let o;n&&(t.$scopedSlots=le(n.data.scopedSlots,t.$slots,t.$scopedSlots)),t.$vnode=n;try{Me=t,o=e.call(t._renderProxy,t.$createElement)}catch(e){Ft(e,t,"render"),o=t._vnode}finally{Me=null}return Array.isArray(o)&&1===o.length&&(o=o[0]),o instanceof ut||(o=ft()),o.parent=n,o}}(gn);const An=[String,RegExp,Array];var xn={KeepAlive:{name:"keep-alive",abstract:!0,props:{include:An,exclude:An,max:[String,Number]},methods:{cacheVNode(){const{cache:t,keys:e,vnodeToCache:n,keyToCache:o}=this;if(n){const{tag:r,componentInstance:s,componentOptions:i}=n;t[o]={name:bn(i),tag:r,componentInstance:s},e.push(o),this.max&&e.length>parseInt(this.max)&&wn(t,e[0],e,this._vnode),this.vnodeToCache=null}}},created(){this.cache=Object.create(null),this.keys=[]},destroyed(){for(const t in this.cache)wn(this.cache,t,this.keys)},mounted(){this.cacheVNode(),this.$watch("include",(t=>{Cn(this,(e=>$n(t,e)))})),this.$watch("exclude",(t=>{Cn(this,(e=>!$n(t,e)))}))},updated(){this.cacheVNode()},render(){const t=this.$slots.default,e=Re(t),n=e&&e.componentOptions;if(n){const t=bn(n),{include:o,exclude:r}=this;if(o&&(!t||!$n(o,t))||r&&t&&$n(r,t))return e;const{cache:s,keys:i}=this,a=null==e.key?n.Ctor.cid+(n.tag?`::${n.tag}`:""):e.key;s[a]?(e.componentInstance=s[a].componentInstance,h(i,a),i.push(a)):(this.vnodeToCache=e,this.keyToCache=a),e.data.keepAlive=!0}return e||t&&t[0]}}};!function(t){const e={get:()=>L};Object.defineProperty(t,"config",e),t.util={warn:rt,extend:x,mergeOptions:It,defineReactive:$t},t.set=Ct,t.delete=wt,t.nextTick=Kt,t.observable=t=>(bt(t),t),t.options=Object.create(null),N.forEach((e=>{t.options[e+"s"]=Object.create(null)})),t.options._base=t,x(t.options.components,xn),function(t){t.use=function(t){const e=this._installedPlugins||(this._installedPlugins=[]);if(e.indexOf(t)>-1)return this;const n=A(arguments,1);return n.unshift(this),"function"==typeof t.install?t.install.apply(t,n):"function"==typeof t&&t.apply(null,n),e.push(t),this}}(t),function(t){t.mixin=function(t){return this.options=It(this.options,t),this}}(t),_n(t),function(t){N.forEach((e=>{t[e]=function(t,n){return n?("component"===e&&a(n)&&(n.name=n.name||t,n=this.options._base.extend(n)),"directive"===e&&"function"==typeof n&&(n={bind:n,update:n}),this.options[e+"s"][t]=n,n):this.options[e+"s"][t]}}))}(t)}(gn),Object.defineProperty(gn.prototype,"$isServer",{get:Y}),Object.defineProperty(gn.prototype,"$ssrContext",{get(){return this.$vnode&&this.$vnode.ssrContext}}),Object.defineProperty(gn,"FunctionalRenderContext",{value:Oe}),gn.version="2.6.14";const kn=d("style,class"),On=d("input,textarea,option,select,progress"),Sn=d("contenteditable,draggable,spellcheck"),Tn=d("events,caret,typing,plaintext-only"),En=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),In="http://www.w3.org/1999/xlink",jn=t=>":"===t.charAt(5)&&"xlink"===t.slice(0,5),Dn=t=>jn(t)?t.slice(6,t.length):"",Nn=t=>null==t||!1===t;function Pn(t){let e=t.data,o=t,r=t;for(;n(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(e=Ln(r.data,e));for(;n(o=o.parent);)o&&o.data&&(e=Ln(e,o.data));return function(t,e){if(n(t)||n(e))return Mn(t,Fn(e));return""}(e.staticClass,e.class)}function Ln(t,e){return{staticClass:Mn(t.staticClass,e.staticClass),class:n(t.class)?[t.class,e.class]:e.class}}function Mn(t,e){return t?e?t+" "+e:t:e||""}function Fn(t){return Array.isArray(t)?function(t){let e,o="";for(let r=0,s=t.length;r<s;r++)n(e=Fn(t[r]))&&""!==e&&(o&&(o+=" "),o+=e);return o}(t):s(t)?function(t){let e="";for(const n in t)t[n]&&(e&&(e+=" "),e+=n);return e}(t):"string"==typeof t?t:""}const Rn={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},Vn=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),Un=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0),zn=t=>Vn(t)||Un(t);const Bn=Object.create(null);const Hn=d("text,number,password,search,email,tel,url");var Wn=Object.freeze({__proto__:null,createElement:function(t,e){const n=document.createElement(t);return"select"!==t||e.data&&e.data.attrs&&void 0!==e.data.attrs.multiple&&n.setAttribute("multiple","multiple"),n},createElementNS:function(t,e){return document.createElementNS(Rn[t],e)},createTextNode:function(t){return document.createTextNode(t)},createComment:function(t){return document.createComment(t)},insertBefore:function(t,e,n){t.insertBefore(e,n)},removeChild:function(t,e){t.removeChild(e)},appendChild:function(t,e){t.appendChild(e)},parentNode:function(t){return t.parentNode},nextSibling:function(t){return t.nextSibling},tagName:function(t){return t.tagName},setTextContent:function(t,e){t.textContent=e},setStyleScope:function(t,e){t.setAttribute(e,"")}}),qn={create(t,e){Kn(e)},update(t,e){t.data.ref!==e.data.ref&&(Kn(t,!0),Kn(e))},destroy(t){Kn(t,!0)}};function Kn(t,e){const o=t.data.ref;if(!n(o))return;const r=t.context,s=t.componentInstance||t.elm,i=r.$refs,a=i[o];e?Array.isArray(a)?h(a,s):a===s&&(i[o]=void 0):t.data.refInFor?Array.isArray(a)?a.indexOf(s)<0&&a.push(s):i[o]=[s]:i[o]=s}const Xn=new ut("",{},[]),Gn=["create","activate","update","remove","destroy"];function Zn(t,r){return t.key===r.key&&t.asyncFactory===r.asyncFactory&&(t.tag===r.tag&&t.isComment===r.isComment&&n(t.data)===n(r.data)&&function(t,e){if("input"!==t.tag)return!0;let o;const r=n(o=t.data)&&n(o=o.attrs)&&o.type,s=n(o=e.data)&&n(o=o.attrs)&&o.type;return r===s||Hn(r)&&Hn(s)}(t,r)||o(t.isAsyncPlaceholder)&&e(r.asyncFactory.error))}function Jn(t,e,o){let r,s;const i={};for(r=e;r<=o;++r)s=t[r].key,n(s)&&(i[s]=r);return i}var Qn={create:Yn,update:Yn,destroy:function(t){Yn(t,Xn)}};function Yn(t,e){(t.data.directives||e.data.directives)&&function(t,e){const n=t===Xn,o=e===Xn,r=eo(t.data.directives,t.context),s=eo(e.data.directives,e.context),i=[],a=[];let c,l,u;for(c in s)l=r[c],u=s[c],l?(u.oldValue=l.value,u.oldArg=l.arg,oo(u,"update",e,t),u.def&&u.def.componentUpdated&&a.push(u)):(oo(u,"bind",e,t),u.def&&u.def.inserted&&i.push(u));if(i.length){const o=()=>{for(let n=0;n<i.length;n++)oo(i[n],"inserted",e,t)};n?te(e,"insert",o):o()}a.length&&te(e,"postpatch",(()=>{for(let n=0;n<a.length;n++)oo(a[n],"componentUpdated",e,t)}));if(!n)for(c in r)s[c]||oo(r[c],"unbind",t,t,o)}(t,e)}const to=Object.create(null);function eo(t,e){const n=Object.create(null);if(!t)return n;let o,r;for(o=0;o<t.length;o++)r=t[o],r.modifiers||(r.modifiers=to),n[no(r)]=r,r.def=jt(e.$options,"directives",r.name);return n}function no(t){return t.rawName||`${t.name}.${Object.keys(t.modifiers||{}).join(".")}`}function oo(t,e,n,o,r){const s=t.def&&t.def[e];if(s)try{s(n.elm,t,n,o,r)}catch(o){Ft(o,n.context,`directive ${t.name} ${e} hook`)}}var ro=[qn,Qn];function so(t,o){const r=o.componentOptions;if(n(r)&&!1===r.Ctor.options.inheritAttrs)return;if(e(t.data.attrs)&&e(o.data.attrs))return;let s,i,a;const c=o.elm,l=t.data.attrs||{};let u=o.data.attrs||{};for(s in n(u.__ob__)&&(u=o.data.attrs=x({},u)),u)i=u[s],a=l[s],a!==i&&io(c,s,i,o.data.pre);for(s in(W||K)&&u.value!==l.value&&io(c,"value",u.value),l)e(u[s])&&(jn(s)?c.removeAttributeNS(In,Dn(s)):Sn(s)||c.removeAttribute(s))}function io(t,e,n,o){o||t.tagName.indexOf("-")>-1?ao(t,e,n):En(e)?Nn(n)?t.removeAttribute(e):(n="allowfullscreen"===e&&"EMBED"===t.tagName?"true":e,t.setAttribute(e,n)):Sn(e)?t.setAttribute(e,((t,e)=>Nn(e)||"false"===e?"false":"contenteditable"===t&&Tn(e)?e:"true")(e,n)):jn(e)?Nn(n)?t.removeAttributeNS(In,Dn(e)):t.setAttributeNS(In,e,n):ao(t,e,n)}function ao(t,e,n){if(Nn(n))t.removeAttribute(e);else{if(W&&!q&&"TEXTAREA"===t.tagName&&"placeholder"===e&&""!==n&&!t.__ieph){const e=n=>{n.stopImmediatePropagation(),t.removeEventListener("input",e)};t.addEventListener("input",e),t.__ieph=!0}t.setAttribute(e,n)}}var co={create:so,update:so};function lo(t,o){const r=o.elm,s=o.data,i=t.data;if(e(s.staticClass)&&e(s.class)&&(e(i)||e(i.staticClass)&&e(i.class)))return;let a=Pn(o);const c=r._transitionClasses;n(c)&&(a=Mn(a,Fn(c))),a!==r._prevClass&&(r.setAttribute("class",a),r._prevClass=a)}var uo={create:lo,update:lo};let fo;function po(t,e,n){const o=fo;return function r(){const s=e.apply(null,arguments);null!==s&&yo(t,r,n,o)}}const ho=zt&&!(G&&Number(G[1])<=53);function mo(t,e,n,o){if(ho){const t=nn,n=e;e=n._wrapper=function(e){if(e.target===e.currentTarget||e.timeStamp>=t||e.timeStamp<=0||e.target.ownerDocument!==document)return n.apply(this,arguments)}}fo.addEventListener(t,e,Q?{capture:n,passive:o}:n)}function yo(t,e,n,o){(o||fo).removeEventListener(t,e._wrapper||e,n)}function vo(t,o){if(e(t.data.on)&&e(o.data.on))return;const r=o.data.on||{},s=t.data.on||{};fo=o.elm||t.elm,function(t){if(n(t.__r)){const e=W?"change":"input";t[e]=[].concat(t.__r,t[e]||[]),delete t.__r}n(t.__c)&&(t.change=[].concat(t.__c,t.change||[]),delete t.__c)}(r),Yt(r,s,mo,yo,po,o.context),fo=void 0}var go={create:vo,update:vo,destroy:t=>vo(t,Xn)};let _o;function bo(t,o){if(e(t.data.domProps)&&e(o.data.domProps))return;let r,s;const i=o.elm,a=t.data.domProps||{};let c=o.data.domProps||{};for(r in n(c.__ob__)&&(c=o.data.domProps=x({},c)),a)r in c||(i[r]="");for(r in c){if(s=c[r],"textContent"===r||"innerHTML"===r){if(o.children&&(o.children.length=0),s===a[r])continue;1===i.childNodes.length&&i.removeChild(i.childNodes[0])}if("value"===r&&"PROGRESS"!==i.tagName){i._value=s;const t=e(s)?"":String(s);$o(i,t)&&(i.value=t)}else if("innerHTML"===r&&Un(i.tagName)&&e(i.innerHTML)){_o=_o||document.createElement("div"),_o.innerHTML=`<svg>${s}</svg>`;const t=_o.firstChild;for(;i.firstChild;)i.removeChild(i.firstChild);for(;t.firstChild;)i.appendChild(t.firstChild)}else if(s!==a[r])try{i[r]=s}catch(t){}}}function $o(t,e){return!t.composing&&("OPTION"===t.tagName||function(t,e){let n=!0;try{n=document.activeElement!==t}catch(t){}return n&&t.value!==e}(t,e)||function(t,e){const o=t.value,r=t._vModifiers;if(n(r)){if(r.number)return f(o)!==f(e);if(r.trim)return o.trim()!==e.trim()}return o!==e}(t,e))}var Co={create:bo,update:bo};const wo=v((function(t){const e={},n=/:(.+)/;return t.split(/;(?![^(]*\))/g).forEach((function(t){if(t){const o=t.split(n);o.length>1&&(e[o[0].trim()]=o[1].trim())}})),e}));function Ao(t){const e=xo(t.style);return t.staticStyle?x(t.staticStyle,e):e}function xo(t){return Array.isArray(t)?k(t):"string"==typeof t?wo(t):t}const ko=/^--/,Oo=/\s*!important$/,So=(t,e,n)=>{if(ko.test(e))t.style.setProperty(e,n);else if(Oo.test(n))t.style.setProperty(C(e),n.replace(Oo,""),"important");else{const o=Io(e);if(Array.isArray(n))for(let e=0,r=n.length;e<r;e++)t.style[o]=n[e];else t.style[o]=n}},To=["Webkit","Moz","ms"];let Eo;const Io=v((function(t){if(Eo=Eo||document.createElement("div").style,"filter"!==(t=_(t))&&t in Eo)return t;const e=t.charAt(0).toUpperCase()+t.slice(1);for(let t=0;t<To.length;t++){const n=To[t]+e;if(n in Eo)return n}}));function jo(t,o){const r=o.data,s=t.data;if(e(r.staticStyle)&&e(r.style)&&e(s.staticStyle)&&e(s.style))return;let i,a;const c=o.elm,l=s.staticStyle,u=s.normalizedStyle||s.style||{},f=l||u,d=xo(o.data.style)||{};o.data.normalizedStyle=n(d.__ob__)?x({},d):d;const p=function(t,e){const n={};let o;if(e){let e=t;for(;e.componentInstance;)e=e.componentInstance._vnode,e&&e.data&&(o=Ao(e.data))&&x(n,o)}(o=Ao(t.data))&&x(n,o);let r=t;for(;r=r.parent;)r.data&&(o=Ao(r.data))&&x(n,o);return n}(o,!0);for(a in f)e(p[a])&&So(c,a,"");for(a in p)i=p[a],i!==f[a]&&So(c,a,null==i?"":i)}var Do={create:jo,update:jo};const No=/\s+/;function Po(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(No).forEach((e=>t.classList.add(e))):t.classList.add(e);else{const n=` ${t.getAttribute("class")||""} `;n.indexOf(" "+e+" ")<0&&t.setAttribute("class",(n+e).trim())}}function Lo(t,e){if(e&&(e=e.trim()))if(t.classList)e.indexOf(" ")>-1?e.split(No).forEach((e=>t.classList.remove(e))):t.classList.remove(e),t.classList.length||t.removeAttribute("class");else{let n=` ${t.getAttribute("class")||""} `;const o=" "+e+" ";for(;n.indexOf(o)>=0;)n=n.replace(o," ");n=n.trim(),n?t.setAttribute("class",n):t.removeAttribute("class")}}function Mo(t){if(t){if("object"==typeof t){const e={};return!1!==t.css&&x(e,Fo(t.name||"v")),x(e,t),e}return"string"==typeof t?Fo(t):void 0}}const Fo=v((t=>({enterClass:`${t}-enter`,enterToClass:`${t}-enter-to`,enterActiveClass:`${t}-enter-active`,leaveClass:`${t}-leave`,leaveToClass:`${t}-leave-to`,leaveActiveClass:`${t}-leave-active`}))),Ro=U&&!q,Vo="transition",Uo="animation";let zo="transition",Bo="transitionend",Ho="animation",Wo="animationend";Ro&&(void 0===window.ontransitionend&&void 0!==window.onwebkittransitionend&&(zo="WebkitTransition",Bo="webkitTransitionEnd"),void 0===window.onanimationend&&void 0!==window.onwebkitanimationend&&(Ho="WebkitAnimation",Wo="webkitAnimationEnd"));const qo=U?window.requestAnimationFrame?window.requestAnimationFrame.bind(window):setTimeout:t=>t();function Ko(t){qo((()=>{qo(t)}))}function Xo(t,e){const n=t._transitionClasses||(t._transitionClasses=[]);n.indexOf(e)<0&&(n.push(e),Po(t,e))}function Go(t,e){t._transitionClasses&&h(t._transitionClasses,e),Lo(t,e)}function Zo(t,e,n){const{type:o,timeout:r,propCount:s}=Qo(t,e);if(!o)return n();const i=o===Vo?Bo:Wo;let a=0;const c=()=>{t.removeEventListener(i,l),n()},l=e=>{e.target===t&&++a>=s&&c()};setTimeout((()=>{a<s&&c()}),r+1),t.addEventListener(i,l)}const Jo=/\b(transform|all)(,|$)/;function Qo(t,e){const n=window.getComputedStyle(t),o=(n[zo+"Delay"]||"").split(", "),r=(n[zo+"Duration"]||"").split(", "),s=Yo(o,r),i=(n[Ho+"Delay"]||"").split(", "),a=(n[Ho+"Duration"]||"").split(", "),c=Yo(i,a);let l,u=0,f=0;e===Vo?s>0&&(l=Vo,u=s,f=r.length):e===Uo?c>0&&(l=Uo,u=c,f=a.length):(u=Math.max(s,c),l=u>0?s>c?Vo:Uo:null,f=l?l===Vo?r.length:a.length:0);return{type:l,timeout:u,propCount:f,hasTransform:l===Vo&&Jo.test(n[zo+"Property"])}}function Yo(t,e){for(;t.length<e.length;)t=t.concat(t);return Math.max.apply(null,e.map(((e,n)=>tr(e)+tr(t[n]))))}function tr(t){return 1e3*Number(t.slice(0,-1).replace(",","."))}function er(t,o){const r=t.elm;n(r._leaveCb)&&(r._leaveCb.cancelled=!0,r._leaveCb());const i=Mo(t.data.transition);if(e(i))return;if(n(r._enterCb)||1!==r.nodeType)return;const{css:a,type:c,enterClass:l,enterToClass:u,enterActiveClass:d,appearClass:p,appearToClass:h,appearActiveClass:m,beforeEnter:y,enter:v,afterEnter:g,enterCancelled:_,beforeAppear:b,appear:$,afterAppear:C,appearCancelled:w,duration:A}=i;let x=He,k=He.$vnode;for(;k&&k.parent;)x=k.context,k=k.parent;const O=!x._isMounted||!t.isRootInsert;if(O&&!$&&""!==$)return;const S=O&&p?p:l,T=O&&m?m:d,E=O&&h?h:u,I=O&&b||y,D=O&&"function"==typeof $?$:v,N=O&&C||g,P=O&&w||_,L=f(s(A)?A.enter:A),M=!1!==a&&!q,F=rr(D),R=r._enterCb=j((()=>{M&&(Go(r,E),Go(r,T)),R.cancelled?(M&&Go(r,S),P&&P(r)):N&&N(r),r._enterCb=null}));t.data.show||te(t,"insert",(()=>{const e=r.parentNode,n=e&&e._pending&&e._pending[t.key];n&&n.tag===t.tag&&n.elm._leaveCb&&n.elm._leaveCb(),D&&D(r,R)})),I&&I(r),M&&(Xo(r,S),Xo(r,T),Ko((()=>{Go(r,S),R.cancelled||(Xo(r,E),F||(or(L)?setTimeout(R,L):Zo(r,c,R)))}))),t.data.show&&(o&&o(),D&&D(r,R)),M||F||R()}function nr(t,o){const r=t.elm;n(r._enterCb)&&(r._enterCb.cancelled=!0,r._enterCb());const i=Mo(t.data.transition);if(e(i)||1!==r.nodeType)return o();if(n(r._leaveCb))return;const{css:a,type:c,leaveClass:l,leaveToClass:u,leaveActiveClass:d,beforeLeave:p,leave:h,afterLeave:m,leaveCancelled:y,delayLeave:v,duration:g}=i,_=!1!==a&&!q,b=rr(h),$=f(s(g)?g.leave:g),C=r._leaveCb=j((()=>{r.parentNode&&r.parentNode._pending&&(r.parentNode._pending[t.key]=null),_&&(Go(r,u),Go(r,d)),C.cancelled?(_&&Go(r,l),y&&y(r)):(o(),m&&m(r)),r._leaveCb=null}));function w(){C.cancelled||(!t.data.show&&r.parentNode&&((r.parentNode._pending||(r.parentNode._pending={}))[t.key]=t),p&&p(r),_&&(Xo(r,l),Xo(r,d),Ko((()=>{Go(r,l),C.cancelled||(Xo(r,u),b||(or($)?setTimeout(C,$):Zo(r,c,C)))}))),h&&h(r,C),_||b||C())}v?v(w):w()}function or(t){return"number"==typeof t&&!isNaN(t)}function rr(t){if(e(t))return!1;const o=t.fns;return n(o)?rr(Array.isArray(o)?o[0]:o):(t._length||t.length)>1}function sr(t,e){!0!==e.data.show&&er(e)}const ir=function(t){let s,i;const a={},{modules:c,nodeOps:l}=t;for(s=0;s<Gn.length;++s)for(a[Gn[s]]=[],i=0;i<c.length;++i)n(c[i][Gn[s]])&&a[Gn[s]].push(c[i][Gn[s]]);function u(t){const e=l.parentNode(t);n(e)&&l.removeChild(e,t)}function f(t,e,r,s,i,c,u){if(n(t.elm)&&n(c)&&(t=c[u]=pt(t)),t.isRootInsert=!i,function(t,e,r,s){let i=t.data;if(n(i)){const c=n(t.componentInstance)&&i.keepAlive;if(n(i=i.hook)&&n(i=i.init)&&i(t,!1),n(t.componentInstance))return p(t,e),h(r,t.elm,s),o(c)&&function(t,e,o,r){let s,i=t;for(;i.componentInstance;)if(i=i.componentInstance._vnode,n(s=i.data)&&n(s=s.transition)){for(s=0;s<a.activate.length;++s)a.activate[s](Xn,i);e.push(i);break}h(o,t.elm,r)}(t,e,r,s),!0}}(t,e,r,s))return;const f=t.data,d=t.children,y=t.tag;n(y)?(t.elm=t.ns?l.createElementNS(t.ns,y):l.createElement(y,t),g(t),m(t,d,e),n(f)&&v(t,e),h(r,t.elm,s)):o(t.isComment)?(t.elm=l.createComment(t.text),h(r,t.elm,s)):(t.elm=l.createTextNode(t.text),h(r,t.elm,s))}function p(t,e){n(t.data.pendingInsert)&&(e.push.apply(e,t.data.pendingInsert),t.data.pendingInsert=null),t.elm=t.componentInstance.$el,y(t)?(v(t,e),g(t)):(Kn(t),e.push(t))}function h(t,e,o){n(t)&&(n(o)?l.parentNode(o)===t&&l.insertBefore(t,e,o):l.appendChild(t,e))}function m(t,e,n){if(Array.isArray(e))for(let o=0;o<e.length;++o)f(e[o],n,t.elm,null,!0,e,o);else r(t.text)&&l.appendChild(t.elm,l.createTextNode(String(t.text)))}function y(t){for(;t.componentInstance;)t=t.componentInstance._vnode;return n(t.tag)}function v(t,e){for(let e=0;e<a.create.length;++e)a.create[e](Xn,t);s=t.data.hook,n(s)&&(n(s.create)&&s.create(Xn,t),n(s.insert)&&e.push(t))}function g(t){let e;if(n(e=t.fnScopeId))l.setStyleScope(t.elm,e);else{let o=t;for(;o;)n(e=o.context)&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e),o=o.parent}n(e=He)&&e!==t.context&&e!==t.fnContext&&n(e=e.$options._scopeId)&&l.setStyleScope(t.elm,e)}function _(t,e,n,o,r,s){for(;o<=r;++o)f(n[o],s,t,e,!1,n,o)}function b(t){let e,o;const r=t.data;if(n(r))for(n(e=r.hook)&&n(e=e.destroy)&&e(t),e=0;e<a.destroy.length;++e)a.destroy[e](t);if(n(e=t.children))for(o=0;o<t.children.length;++o)b(t.children[o])}function $(t,e,o){for(;e<=o;++e){const o=t[e];n(o)&&(n(o.tag)?(C(o),b(o)):u(o.elm))}}function C(t,e){if(n(e)||n(t.data)){let o;const r=a.remove.length+1;for(n(e)?e.listeners+=r:e=function(t,e){function n(){0==--n.listeners&&u(t)}return n.listeners=e,n}(t.elm,r),n(o=t.componentInstance)&&n(o=o._vnode)&&n(o.data)&&C(o,e),o=0;o<a.remove.length;++o)a.remove[o](t,e);n(o=t.data.hook)&&n(o=o.remove)?o(t,e):e()}else u(t.elm)}function w(t,e,o,r){for(let s=o;s<r;s++){const o=e[s];if(n(o)&&Zn(t,o))return s}}function A(t,r,s,i,c,u){if(t===r)return;n(r.elm)&&n(i)&&(r=i[c]=pt(r));const d=r.elm=t.elm;if(o(t.isAsyncPlaceholder))return void(n(r.asyncFactory.resolved)?O(t.elm,r,s):r.isAsyncPlaceholder=!0);if(o(r.isStatic)&&o(t.isStatic)&&r.key===t.key&&(o(r.isCloned)||o(r.isOnce)))return void(r.componentInstance=t.componentInstance);let p;const h=r.data;n(h)&&n(p=h.hook)&&n(p=p.prepatch)&&p(t,r);const m=t.children,v=r.children;if(n(h)&&y(r)){for(p=0;p<a.update.length;++p)a.update[p](t,r);n(p=h.hook)&&n(p=p.update)&&p(t,r)}e(r.text)?n(m)&&n(v)?m!==v&&function(t,o,r,s,i){let a,c,u,d,p=0,h=0,m=o.length-1,y=o[0],v=o[m],g=r.length-1,b=r[0],C=r[g];const x=!i;for(;p<=m&&h<=g;)e(y)?y=o[++p]:e(v)?v=o[--m]:Zn(y,b)?(A(y,b,s,r,h),y=o[++p],b=r[++h]):Zn(v,C)?(A(v,C,s,r,g),v=o[--m],C=r[--g]):Zn(y,C)?(A(y,C,s,r,g),x&&l.insertBefore(t,y.elm,l.nextSibling(v.elm)),y=o[++p],C=r[--g]):Zn(v,b)?(A(v,b,s,r,h),x&&l.insertBefore(t,v.elm,y.elm),v=o[--m],b=r[++h]):(e(a)&&(a=Jn(o,p,m)),c=n(b.key)?a[b.key]:w(b,o,p,m),e(c)?f(b,s,t,y.elm,!1,r,h):(u=o[c],Zn(u,b)?(A(u,b,s,r,h),o[c]=void 0,x&&l.insertBefore(t,u.elm,y.elm)):f(b,s,t,y.elm,!1,r,h)),b=r[++h]);p>m?(d=e(r[g+1])?null:r[g+1].elm,_(t,d,r,h,g,s)):h>g&&$(o,p,m)}(d,m,v,s,u):n(v)?(n(t.text)&&l.setTextContent(d,""),_(d,null,v,0,v.length-1,s)):n(m)?$(m,0,m.length-1):n(t.text)&&l.setTextContent(d,""):t.text!==r.text&&l.setTextContent(d,r.text),n(h)&&n(p=h.hook)&&n(p=p.postpatch)&&p(t,r)}function x(t,e,r){if(o(r)&&n(t.parent))t.parent.data.pendingInsert=e;else for(let t=0;t<e.length;++t)e[t].data.hook.insert(e[t])}const k=d("attrs,class,staticClass,staticStyle,key");function O(t,e,r,s){let i;const{tag:a,data:c,children:l}=e;if(s=s||c&&c.pre,e.elm=t,o(e.isComment)&&n(e.asyncFactory))return e.isAsyncPlaceholder=!0,!0;if(n(c)&&(n(i=c.hook)&&n(i=i.init)&&i(e,!0),n(i=e.componentInstance)))return p(e,r),!0;if(n(a)){if(n(l))if(t.hasChildNodes())if(n(i=c)&&n(i=i.domProps)&&n(i=i.innerHTML)){if(i!==t.innerHTML)return!1}else{let e=!0,n=t.firstChild;for(let t=0;t<l.length;t++){if(!n||!O(n,l[t],r,s)){e=!1;break}n=n.nextSibling}if(!e||n)return!1}else m(e,l,r);if(n(c)){let t=!1;for(const n in c)if(!k(n)){t=!0,v(e,r);break}!t&&c.class&&Gt(c.class)}}else t.data!==e.text&&(t.data=e.text);return!0}return function(t,r,s,i){if(e(r))return void(n(t)&&b(t));let c=!1;const u=[];if(e(t))c=!0,f(r,u);else{const e=n(t.nodeType);if(!e&&Zn(t,r))A(t,r,u,null,null,i);else{if(e){if(1===t.nodeType&&t.hasAttribute(D)&&(t.removeAttribute(D),s=!0),o(s)&&O(t,r,u))return x(r,u,!0),t;d=t,t=new ut(l.tagName(d).toLowerCase(),{},[],void 0,d)}const i=t.elm,c=l.parentNode(i);if(f(r,u,i._leaveCb?null:c,l.nextSibling(i)),n(r.parent)){let t=r.parent;const e=y(r);for(;t;){for(let e=0;e<a.destroy.length;++e)a.destroy[e](t);if(t.elm=r.elm,e){for(let e=0;e<a.create.length;++e)a.create[e](Xn,t);const e=t.data.hook.insert;if(e.merged)for(let t=1;t<e.fns.length;t++)e.fns[t]()}else Kn(t);t=t.parent}}n(c)?$([t],0,0):n(t.tag)&&b(t)}}var d;return x(r,u,c),r.elm}}({nodeOps:Wn,modules:[co,uo,go,Co,Do,U?{create:sr,activate:sr,remove(t,e){!0!==t.data.show?nr(t,e):e()}}:{}].concat(ro)});q&&document.addEventListener("selectionchange",(()=>{const t=document.activeElement;t&&t.vmodel&&hr(t,"input")}));const ar={inserted(t,e,n,o){"select"===n.tag?(o.elm&&!o.elm._vOptions?te(n,"postpatch",(()=>{ar.componentUpdated(t,e,n)})):cr(t,e,n.context),t._vOptions=[].map.call(t.options,fr)):("textarea"===n.tag||Hn(t.type))&&(t._vModifiers=e.modifiers,e.modifiers.lazy||(t.addEventListener("compositionstart",dr),t.addEventListener("compositionend",pr),t.addEventListener("change",pr),q&&(t.vmodel=!0)))},componentUpdated(t,e,n){if("select"===n.tag){cr(t,e,n.context);const o=t._vOptions,r=t._vOptions=[].map.call(t.options,fr);if(r.some(((t,e)=>!E(t,o[e])))){(t.multiple?e.value.some((t=>ur(t,r))):e.value!==e.oldValue&&ur(e.value,r))&&hr(t,"change")}}}};function cr(t,e,n){lr(t,e),(W||K)&&setTimeout((()=>{lr(t,e)}),0)}function lr(t,e,n){const o=e.value,r=t.multiple;if(r&&!Array.isArray(o))return;let s,i;for(let e=0,n=t.options.length;e<n;e++)if(i=t.options[e],r)s=I(o,fr(i))>-1,i.selected!==s&&(i.selected=s);else if(E(fr(i),o))return void(t.selectedIndex!==e&&(t.selectedIndex=e));r||(t.selectedIndex=-1)}function ur(t,e){return e.every((e=>!E(e,t)))}function fr(t){return"_value"in t?t._value:t.value}function dr(t){t.target.composing=!0}function pr(t){t.target.composing&&(t.target.composing=!1,hr(t.target,"input"))}function hr(t,e){const n=document.createEvent("HTMLEvents");n.initEvent(e,!0,!0),t.dispatchEvent(n)}function mr(t){return!t.componentInstance||t.data&&t.data.transition?t:mr(t.componentInstance._vnode)}var yr={bind(t,{value:e},n){const o=(n=mr(n)).data&&n.data.transition,r=t.__vOriginalDisplay="none"===t.style.display?"":t.style.display;e&&o?(n.data.show=!0,er(n,(()=>{t.style.display=r}))):t.style.display=e?r:"none"},update(t,{value:e,oldValue:n},o){if(!e==!n)return;(o=mr(o)).data&&o.data.transition?(o.data.show=!0,e?er(o,(()=>{t.style.display=t.__vOriginalDisplay})):nr(o,(()=>{t.style.display="none"}))):t.style.display=e?t.__vOriginalDisplay:"none"},unbind(t,e,n,o,r){r||(t.style.display=t.__vOriginalDisplay)}},vr={model:ar,show:yr};const gr={name:String,appear:Boolean,css:Boolean,mode:String,type:String,enterClass:String,leaveClass:String,enterToClass:String,leaveToClass:String,enterActiveClass:String,leaveActiveClass:String,appearClass:String,appearActiveClass:String,appearToClass:String,duration:[Number,String,Object]};function _r(t){const e=t&&t.componentOptions;return e&&e.Ctor.options.abstract?_r(Re(e.children)):t}function br(t){const e={},n=t.$options;for(const o in n.propsData)e[o]=t[o];const o=n._parentListeners;for(const t in o)e[_(t)]=o[t];return e}function $r(t,e){if(/\d-keep-alive$/.test(e.tag))return t("keep-alive",{props:e.componentOptions.propsData})}const Cr=t=>t.tag||ce(t),wr=t=>"show"===t.name;var Ar={name:"transition",props:gr,abstract:!0,render(t){let e=this.$slots.default;if(!e)return;if(e=e.filter(Cr),!e.length)return;const n=this.mode,o=e[0];if(function(t){for(;t=t.parent;)if(t.data.transition)return!0}(this.$vnode))return o;const s=_r(o);if(!s)return o;if(this._leaving)return $r(t,o);const i=`__transition-${this._uid}-`;s.key=null==s.key?s.isComment?i+"comment":i+s.tag:r(s.key)?0===String(s.key).indexOf(i)?s.key:i+s.key:s.key;const a=(s.data||(s.data={})).transition=br(this),c=this._vnode,l=_r(c);if(s.data.directives&&s.data.directives.some(wr)&&(s.data.show=!0),l&&l.data&&!function(t,e){return e.key===t.key&&e.tag===t.tag}(s,l)&&!ce(l)&&(!l.componentInstance||!l.componentInstance._vnode.isComment)){const e=l.data.transition=x({},a);if("out-in"===n)return this._leaving=!0,te(e,"afterLeave",(()=>{this._leaving=!1,this.$forceUpdate()})),$r(t,o);if("in-out"===n){if(ce(s))return c;let t;const n=()=>{t()};te(a,"afterEnter",n),te(a,"enterCancelled",n),te(e,"delayLeave",(e=>{t=e}))}}return o}};const xr=x({tag:String,moveClass:String},gr);function kr(t){t.elm._moveCb&&t.elm._moveCb(),t.elm._enterCb&&t.elm._enterCb()}function Or(t){t.data.newPos=t.elm.getBoundingClientRect()}function Sr(t){const e=t.data.pos,n=t.data.newPos,o=e.left-n.left,r=e.top-n.top;if(o||r){t.data.moved=!0;const e=t.elm.style;e.transform=e.WebkitTransform=`translate(${o}px,${r}px)`,e.transitionDuration="0s"}}delete xr.mode;var Tr={Transition:Ar,TransitionGroup:{props:xr,beforeMount(){const t=this._update;this._update=(e,n)=>{const o=We(this);this.__patch__(this._vnode,this.kept,!1,!0),this._vnode=this.kept,o(),t.call(this,e,n)}},render(t){const e=this.tag||this.$vnode.data.tag||"span",n=Object.create(null),o=this.prevChildren=this.children,r=this.$slots.default||[],s=this.children=[],i=br(this);for(let t=0;t<r.length;t++){const e=r[t];e.tag&&null!=e.key&&0!==String(e.key).indexOf("__vlist")&&(s.push(e),n[e.key]=e,(e.data||(e.data={})).transition=i)}if(o){const r=[],s=[];for(let t=0;t<o.length;t++){const e=o[t];e.data.transition=i,e.data.pos=e.elm.getBoundingClientRect(),n[e.key]?r.push(e):s.push(e)}this.kept=t(e,null,r),this.removed=s}return t(e,null,s)},updated(){const t=this.prevChildren,e=this.moveClass||(this.name||"v")+"-move";t.length&&this.hasMove(t[0].elm,e)&&(t.forEach(kr),t.forEach(Or),t.forEach(Sr),this._reflow=document.body.offsetHeight,t.forEach((t=>{if(t.data.moved){const n=t.elm,o=n.style;Xo(n,e),o.transform=o.WebkitTransform=o.transitionDuration="",n.addEventListener(Bo,n._moveCb=function t(o){o&&o.target!==n||o&&!/transform$/.test(o.propertyName)||(n.removeEventListener(Bo,t),n._moveCb=null,Go(n,e))})}})))},methods:{hasMove(t,e){if(!Ro)return!1;if(this._hasMove)return this._hasMove;const n=t.cloneNode();t._transitionClasses&&t._transitionClasses.forEach((t=>{Lo(n,t)})),Po(n,e),n.style.display="none",this.$el.appendChild(n);const o=Qo(n);return this.$el.removeChild(n),this._hasMove=o.hasTransform}}}};return gn.config.mustUseProp=(t,e,n)=>"value"===n&&On(t)&&"button"!==e||"selected"===n&&"option"===t||"checked"===n&&"input"===t||"muted"===n&&"video"===t,gn.config.isReservedTag=zn,gn.config.isReservedAttr=kn,gn.config.getTagNamespace=function(t){return Un(t)?"svg":"math"===t?"math":void 0},gn.config.isUnknownElement=function(t){if(!U)return!0;if(zn(t))return!1;if(t=t.toLowerCase(),null!=Bn[t])return Bn[t];const e=document.createElement(t);return t.indexOf("-")>-1?Bn[t]=e.constructor===window.HTMLUnknownElement||e.constructor===window.HTMLElement:Bn[t]=/HTMLUnknownElement/.test(e.toString())},x(gn.options.directives,vr),x(gn.options.components,Tr),gn.prototype.__patch__=U?ir:O,gn.prototype.$mount=function(t,e){return function(t,e,n){let o;return t.$el=e,t.$options.render||(t.$options.render=ft),Ge(t,"beforeMount"),o=()=>{t._update(t._render(),n)},new an(t,o,O,{before(){t._isMounted&&!t._isDestroyed&&Ge(t,"beforeUpdate")}},!0),n=!1,null==t.$vnode&&(t._isMounted=!0,Ge(t,"mounted")),t}(this,t=t&&U?function(t){if("string"==typeof t){return document.querySelector(t)||document.createElement("div")}return t}(t):void 0,e)},U&&setTimeout((()=>{L.devtools&&tt&&tt.emit("init",gn)}),0),gn}));
\ No newline at end of file
diff --git a/package.json b/package.json
index 6c71dcc7d28..4636d402066 100644
--- a/package.json
+++ b/package.json
@@ -77,7 +77,6 @@
     "@babel/preset-typescript": "^7.16.7",
     "@babel/register": "^7.17.7",
     "@rollup/plugin-alias": "^3.1.9",
-    "@rollup/plugin-buble": "^0.21.3",
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-node-resolve": "^13.2.1",
     "@rollup/plugin-replace": "^4.0.0",
@@ -98,7 +97,7 @@
     "babel-plugin-transform-vue-jsx": "^4.0.1",
     "babel-preset-flow-vue": "^1.0.0",
     "buble": "^0.20.0",
-    "chalk": "^5.0.1",
+    "chalk": "^4.0.0",
     "chromedriver": "^100.0.0",
     "codecov": "^3.8.3",
     "commitizen": "^4.2.4",
diff --git a/scripts/config.js b/scripts/config.js
index 0b030893407..65cc8b4cfc4 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -1,5 +1,4 @@
 const path = require('path')
-const buble = require('@rollup/plugin-buble')
 const alias = require('@rollup/plugin-alias')
 const cjs = require('@rollup/plugin-commonjs')
 const replace = require('@rollup/plugin-replace')
@@ -7,7 +6,9 @@ const node = require('@rollup/plugin-node-resolve').nodeResolve
 const ts = require('rollup-plugin-typescript2')
 
 const version = process.env.VERSION || require('../package.json').version
-const weexVersion = process.env.WEEX_VERSION || require('../packages/weex-vue-framework/package.json').version
+const weexVersion =
+  process.env.WEEX_VERSION ||
+  require('../packages/weex-vue-framework/package.json').version
 const featureFlags = require('./feature-flags')
 
 const banner =
@@ -18,16 +19,16 @@ const banner =
   ' */'
 
 const weexFactoryPlugin = {
-  intro () {
+  intro() {
     return 'module.exports = function weexFactory (exports, document) {'
   },
-  outro () {
+  outro() {
     return '}'
   }
 }
 
 const aliases = require('./alias')
-const resolve = p => {
+const resolve = (p) => {
   const base = p.split('/')[0]
   if (aliases[base]) {
     return path.resolve(aliases[base], p.slice(base.length + 1))
@@ -143,7 +144,9 @@ const builds = {
     entry: resolve('web/entry-compiler.ts'),
     dest: resolve('packages/vue-template-compiler/build.js'),
     format: 'cjs',
-    external: Object.keys(require('../packages/vue-template-compiler/package.json').dependencies)
+    external: Object.keys(
+      require('../packages/vue-template-compiler/package.json').dependencies
+    )
   },
   // Web compiler (UMD for in-browser use).
   'web-compiler-browser': {
@@ -160,14 +163,18 @@ const builds = {
     dest: resolve('packages/vue-server-renderer/build.dev.js'),
     format: 'cjs',
     env: 'development',
-    external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
+    external: Object.keys(
+      require('../packages/vue-server-renderer/package.json').dependencies
+    )
   },
   'web-server-renderer-prod': {
     entry: resolve('web/entry-server-renderer.ts'),
     dest: resolve('packages/vue-server-renderer/build.prod.js'),
     format: 'cjs',
     env: 'production',
-    external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
+    external: Object.keys(
+      require('../packages/vue-server-renderer/package.json').dependencies
+    )
   },
   'web-server-renderer-basic': {
     entry: resolve('web/entry-server-basic-renderer.ts'),
@@ -181,13 +188,17 @@ const builds = {
     entry: resolve('server/webpack-plugin/server.ts'),
     dest: resolve('packages/vue-server-renderer/server-plugin.js'),
     format: 'cjs',
-    external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
+    external: Object.keys(
+      require('../packages/vue-server-renderer/package.json').dependencies
+    )
   },
   'web-server-renderer-webpack-client-plugin': {
     entry: resolve('server/webpack-plugin/client.ts'),
     dest: resolve('packages/vue-server-renderer/client-plugin.js'),
     format: 'cjs',
-    external: Object.keys(require('../packages/vue-server-renderer/package.json').dependencies)
+    external: Object.keys(
+      require('../packages/vue-server-renderer/package.json').dependencies
+    )
   },
   // Weex runtime factory
   'weex-factory': {
@@ -210,11 +221,13 @@ const builds = {
     entry: resolve('weex/entry-compiler.ts'),
     dest: resolve('packages/weex-template-compiler/build.js'),
     format: 'cjs',
-    external: Object.keys(require('../packages/weex-template-compiler/package.json').dependencies)
+    external: Object.keys(
+      require('../packages/weex-template-compiler/package.json').dependencies
+    )
   }
 }
 
-function genConfig (name) {
+function genConfig(name) {
   const opts = builds[name]
 
   // console.log('__dir', __dirname)
@@ -227,11 +240,14 @@ function genConfig (name) {
       }),
       ts({
         tsconfig: path.resolve(__dirname, '../', 'tsconfig.json'),
-        cacheRoot: path.resolve(__dirname, '../','node_modules/.rts2_cache'),
+        cacheRoot: path.resolve(__dirname, '../', 'node_modules/.rts2_cache'),
         tsconfigOverride: {
+          compilerOptions: {
+            target: opts.transpile === false ? 'esnext' : 'es5'
+          },
           exclude: ['test', 'test-dts']
         }
-      }),
+      })
     ].concat(opts.plugins || []),
     output: {
       file: opts.dest,
@@ -256,7 +272,7 @@ function genConfig (name) {
     __VERSION__: version
   }
   // feature flags
-  Object.keys(featureFlags).forEach(key => {
+  Object.keys(featureFlags).forEach((key) => {
     vars[`process.env.${key}`] = featureFlags[key]
   })
   // build-specific env
@@ -267,10 +283,6 @@ function genConfig (name) {
   vars.preventAssignment = true
   config.plugins.push(replace(vars))
 
-  // if (opts.transpile !== false) {
-  //   config.plugins.push(buble())
-  // }
-
   Object.defineProperty(config, '_name', {
     enumerable: false,
     value: name
diff --git a/tsconfig.json b/tsconfig.json
index 89587580854..b7acb2a804c 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,11 +3,11 @@
     "baseUrl": ".",
     "outDir": "dist",
     "sourceMap": true,
-    "target": "ESNext",
+    "target": "es5",
     "module": "ESNext",
     "moduleResolution": "node",
     "strict": true,
-    
+
     "allowJs": true,
     "noImplicitAny": false,
     "noImplicitThis": false,
diff --git a/yarn.lock b/yarn.lock
index d17ee146c82..1fed6b75bd0 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1138,15 +1138,6 @@
   dependencies:
     slash "^3.0.0"
 
-"@rollup/plugin-buble@^0.21.3":
-  version "0.21.3"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-buble/-/plugin-buble-0.21.3.tgz#1649a915b1d051a4f430d40e7734a7f67a69b33e"
-  integrity sha512-Iv8cCuFPnMdqV4pcyU+OrfjOfagPArRQ1PyQjx5KgHk3dARedI+8PNTLSMpJts0lQJr8yF2pAU4GxpxCBJ9HYw==
-  dependencies:
-    "@rollup/pluginutils" "^3.0.8"
-    "@types/buble" "^0.19.2"
-    buble "^0.20.0"
-
 "@rollup/plugin-commonjs@^22.0.0":
   version "22.0.0"
   resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.0.tgz#f4d87016e2fbf187a593ab9f46626fe05b59e8bd"
@@ -1180,7 +1171,7 @@
     "@rollup/pluginutils" "^3.1.0"
     magic-string "^0.25.7"
 
-"@rollup/pluginutils@^3.0.8", "@rollup/pluginutils@^3.1.0":
+"@rollup/pluginutils@^3.1.0":
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-3.1.0.tgz#706b4524ee6dc8b103b3c995533e5ad680c02b9b"
   integrity sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==
@@ -1244,13 +1235,6 @@
   resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.2.tgz#423c77877d0569db20e1fc80885ac4118314010e"
   integrity sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==
 
-"@types/buble@^0.19.2":
-  version "0.19.2"
-  resolved "https://registry.yarnpkg.com/@types/buble/-/buble-0.19.2.tgz#a4289d20b175b3c206aaad80caabdabe3ecdfdd1"
-  integrity sha512-uUD8zIfXMKThmFkahTXDGI3CthFH1kMg2dOm3KLi4GlC5cbARA64bEcUMbbWdWdE73eoc/iBB9PiTMqH0dNS2Q==
-  dependencies:
-    magic-string "^0.25.0"
-
 "@types/cacheable-request@^6.0.1":
   version "6.0.2"
   resolved "https://registry.yarnpkg.com/@types/cacheable-request/-/cacheable-request-6.0.2.tgz#c324da0197de0a98a2312156536ae262429ff6b9"
@@ -2664,11 +2648,6 @@ chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-5.0.1.tgz#ca57d71e82bb534a296df63bbacc4a1c22b2a4b6"
-  integrity sha512-Fo07WOYGqMfCWHOzSXOt2CxDbC6skS/jO9ynEcmpANMoPrD+W1r1K6Vx7iNm+AQmETU1Xr2t+n8nzkV9t6xh3w==
-
 change-case@^4.1.1:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/change-case/-/change-case-4.1.2.tgz#fedfc5f136045e2398c0410ee441f95704641e12"
@@ -6517,7 +6496,7 @@ lru-cache@^7.8.1:
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.9.0.tgz#29c2a989b6c10f32ceccc66ff44059e1490af3e1"
   integrity sha512-lkcNMUKqdJk96TuIXUidxaPuEg5sJo/+ZyVE2BDFnuZGzwXem7d8582eG8vbu4todLfT14snP6iHriCHXXi5Rw==
 
-magic-string@^0.25.0, magic-string@^0.25.7:
+magic-string@^0.25.7:
   version "0.25.9"
   resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.9.tgz#de7f9faf91ef8a1c91d02c2e5314c8277dbcdd1c"
   integrity sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==

From de1fd98284965403850a9fcc0204e77a5e6d2a4e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:09:22 +0800
Subject: [PATCH 031/317] chore: remove git add from lint-staged script

---
 package.json | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 4636d402066..581efd65365 100644
--- a/package.json
+++ b/package.json
@@ -50,8 +50,7 @@
   },
   "lint-staged": {
     "*.js": [
-      "eslint --fix",
-      "git add"
+      "eslint --fix"
     ]
   },
   "repository": {

From 7a8284d900a945a6660e2ac3fa18b6fe56c8a996 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:12:48 +0800
Subject: [PATCH 032/317] build: ignore dist files for server-renderer and
 template-compiler

---
 .gitignore                                    |    4 +-
 packages/vue-server-renderer/basic.js         | 7631 ---------------
 packages/vue-server-renderer/build.dev.js     | 8150 -----------------
 packages/vue-server-renderer/build.prod.js    |    1 -
 packages/vue-server-renderer/client-plugin.js |  113 -
 packages/vue-server-renderer/server-plugin.js |  118 -
 packages/vue-template-compiler/browser.js     | 4945 ----------
 packages/vue-template-compiler/build.js       | 4575 ---------
 8 files changed, 3 insertions(+), 25534 deletions(-)
 delete mode 100644 packages/vue-server-renderer/basic.js
 delete mode 100644 packages/vue-server-renderer/build.dev.js
 delete mode 100644 packages/vue-server-renderer/build.prod.js
 delete mode 100644 packages/vue-server-renderer/client-plugin.js
 delete mode 100644 packages/vue-server-renderer/server-plugin.js
 delete mode 100644 packages/vue-template-compiler/browser.js
 delete mode 100644 packages/vue-template-compiler/build.js

diff --git a/.gitignore b/.gitignore
index 6e7a5edfb77..1dd81e3fe8b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,9 +12,11 @@ coverage
 RELEASE_NOTE*.md
 dist/*.js
 packages/vue-server-renderer/basic.js
-packages/vue-server-renderer/build.js
+packages/vue-server-renderer/build.dev.js
+packages/vue-server-renderer/build.prod.js
 packages/vue-server-renderer/server-plugin.js
 packages/vue-server-renderer/client-plugin.js
 packages/vue-template-compiler/build.js
+packages/vue-template-compiler/browser.js
 .vscode
 dist
diff --git a/packages/vue-server-renderer/basic.js b/packages/vue-server-renderer/basic.js
deleted file mode 100644
index 96c1dceb156..00000000000
--- a/packages/vue-server-renderer/basic.js
+++ /dev/null
@@ -1,7631 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-  typeof define === 'function' && define.amd ? define(factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.renderVueComponentToString = factory());
-})(this, (function () { 'use strict';
-
-  const emptyObject = Object.freeze({});
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-      return v === undefined || v === null;
-  }
-  function isDef(v) {
-      return v !== undefined && v !== null;
-  }
-  function isTrue(v) {
-      return v === true;
-  }
-  function isFalse(v) {
-      return v === false;
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-      return (typeof value === 'string' ||
-          typeof value === 'number' ||
-          // $flow-disable-line
-          typeof value === 'symbol' ||
-          typeof value === 'boolean');
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-      return obj !== null && typeof obj === 'object';
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  const _toString = Object.prototype.toString;
-  function toRawType(value) {
-      return _toString.call(value).slice(8, -1);
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-      return _toString.call(obj) === '[object Object]';
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-      const n = parseFloat(String(val));
-      return n >= 0 && Math.floor(n) === n && isFinite(val);
-  }
-  function isPromise(val) {
-      return (isDef(val) &&
-          typeof val.then === 'function' &&
-          typeof val.catch === 'function');
-  }
-  /**
-   * Convert a value to a string that is actually rendered.
-   */
-  function toString(val) {
-      return val == null
-          ? ''
-          : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-              ? JSON.stringify(val, null, 2)
-              : String(val);
-  }
-  /**
-   * Convert an input value to a number for persistence.
-   * If the conversion fails, return original string.
-   */
-  function toNumber(val) {
-      const n = parseFloat(val);
-      return isNaN(n) ? val : n;
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-      const map = Object.create(null);
-      const list = str.split(',');
-      for (let i = 0; i < list.length; i++) {
-          map[list[i]] = true;
-      }
-      return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  const isBuiltInTag = makeMap('slot,component', true);
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-  /**
-   * Remove an item from an array.
-   */
-  function remove$1(arr, item) {
-      if (arr.length) {
-          const index = arr.indexOf(item);
-          if (index > -1) {
-              return arr.splice(index, 1);
-          }
-      }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  function hasOwn(obj, key) {
-      return hasOwnProperty.call(obj, key);
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-      const cache = Object.create(null);
-      return function cachedFn(str) {
-          const hit = cache[str];
-          return hit || (cache[str] = fn(str));
-      };
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  const camelizeRE = /-(\w)/g;
-  const camelize = cached((str) => {
-      return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-  });
-  /**
-   * Capitalize a string.
-   */
-  const capitalize = cached((str) => {
-      return str.charAt(0).toUpperCase() + str.slice(1);
-  });
-  /**
-   * Hyphenate a camelCase string.
-   */
-  const hyphenateRE = /\B([A-Z])/g;
-  const hyphenate = cached((str) => {
-      return str.replace(hyphenateRE, '-$1').toLowerCase();
-  });
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-      for (const key in _from) {
-          to[key] = _from[key];
-      }
-      return to;
-  }
-  /**
-   * Merge an Array of Objects into a single Object.
-   */
-  function toObject(arr) {
-      const res = {};
-      for (let i = 0; i < arr.length; i++) {
-          if (arr[i]) {
-              extend(res, arr[i]);
-          }
-      }
-      return res;
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop$1(a, b, c) { }
-  /**
-   * Always return false.
-   */
-  const no = (a, b, c) => false;
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  const identity = (_) => _;
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys(modules) {
-      return modules
-          .reduce((keys, m) => {
-          return keys.concat(m.staticKeys || []);
-      }, [])
-          .join(',');
-  }
-  /**
-   * Check if two values are loosely equal - that is,
-   * if they are plain objects, do they have the same shape?
-   */
-  function looseEqual(a, b) {
-      if (a === b)
-          return true;
-      const isObjectA = isObject(a);
-      const isObjectB = isObject(b);
-      if (isObjectA && isObjectB) {
-          try {
-              const isArrayA = Array.isArray(a);
-              const isArrayB = Array.isArray(b);
-              if (isArrayA && isArrayB) {
-                  return (a.length === b.length &&
-                      a.every((e, i) => {
-                          return looseEqual(e, b[i]);
-                      }));
-              }
-              else if (a instanceof Date && b instanceof Date) {
-                  return a.getTime() === b.getTime();
-              }
-              else if (!isArrayA && !isArrayB) {
-                  const keysA = Object.keys(a);
-                  const keysB = Object.keys(b);
-                  return (keysA.length === keysB.length &&
-                      keysA.every((key) => {
-                          return looseEqual(a[key], b[key]);
-                      }));
-              }
-              else {
-                  /* istanbul ignore next */
-                  return false;
-              }
-          }
-          catch (e) {
-              /* istanbul ignore next */
-              return false;
-          }
-      }
-      else if (!isObjectA && !isObjectB) {
-          return String(a) === String(b);
-      }
-      else {
-          return false;
-      }
-  }
-  /**
-   * Return the first index at which a loosely equal value can be
-   * found in the array (if value is a plain object, the array must
-   * contain an object of the same shape), or -1 if it is not present.
-   */
-  function looseIndexOf(arr, val) {
-      for (let i = 0; i < arr.length; i++) {
-          if (looseEqual(arr[i], val))
-              return i;
-      }
-      return -1;
-  }
-
-  const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-      'target,title,usemap,value,width,wrap');
-  const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-  const isSSRUnsafeAttr = (name) => {
-      return unsafeAttrCharRE.test(name);
-  };
-  /* istanbul ignore next */
-  const isRenderableAttr = (name) => {
-      return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-  };
-  const propsToAttrMap = {
-      acceptCharset: 'accept-charset',
-      className: 'class',
-      htmlFor: 'for',
-      httpEquiv: 'http-equiv',
-  };
-  const ESC = {
-      '<': '&lt;',
-      '>': '&gt;',
-      '"': '&quot;',
-      '&': '&amp;',
-  };
-  function escape(s) {
-      return s.replace(/[<>"&]/g, escapeChar);
-  }
-  function escapeChar(a) {
-      return ESC[a] || a;
-  }
-  const noUnitNumericStyleProps = {
-      'animation-iteration-count': true,
-      'border-image-outset': true,
-      'border-image-slice': true,
-      'border-image-width': true,
-      'box-flex': true,
-      'box-flex-group': true,
-      'box-ordinal-group': true,
-      'column-count': true,
-      columns: true,
-      flex: true,
-      'flex-grow': true,
-      'flex-positive': true,
-      'flex-shrink': true,
-      'flex-negative': true,
-      'flex-order': true,
-      'grid-row': true,
-      'grid-row-end': true,
-      'grid-row-span': true,
-      'grid-row-start': true,
-      'grid-column': true,
-      'grid-column-end': true,
-      'grid-column-span': true,
-      'grid-column-start': true,
-      'font-weight': true,
-      'line-clamp': true,
-      'line-height': true,
-      opacity: true,
-      order: true,
-      orphans: true,
-      'tab-size': true,
-      widows: true,
-      'z-index': true,
-      zoom: true,
-      // SVG
-      'fill-opacity': true,
-      'flood-opacity': true,
-      'stop-opacity': true,
-      'stroke-dasharray': true,
-      'stroke-dashoffset': true,
-      'stroke-miterlimit': true,
-      'stroke-opacity': true,
-      'stroke-width': true,
-  };
-
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  makeMap('style,class');
-  // attributes that should be using props for binding
-  const acceptValue = makeMap('input,textarea,option,select,progress');
-  const mustUseProp = (tag, type, attr) => {
-      return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-          (attr === 'selected' && tag === 'option') ||
-          (attr === 'checked' && tag === 'input') ||
-          (attr === 'muted' && tag === 'video'));
-  };
-  const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-  const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-  const convertEnumeratedValue = (key, value) => {
-      return isFalsyAttrValue(value) || value === 'false'
-          ? 'false'
-          : // allow arbitrary string value for contenteditable
-              key === 'contenteditable' && isValidContentEditableValue(value)
-                  ? value
-                  : 'true';
-  };
-  const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible');
-  const isFalsyAttrValue = (val) => {
-      return val == null || val === false;
-  };
-
-  function renderAttrs$1(node) {
-      let attrs = node.data.attrs;
-      let res = '';
-      const opts = node.parent && node.parent.componentOptions;
-      if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-          let parent = node.parent;
-          while (isDef(parent)) {
-              // Stop fallthrough in case parent has inheritAttrs option set to false
-              if (parent.componentOptions &&
-                  parent.componentOptions.Ctor.options.inheritAttrs === false) {
-                  break;
-              }
-              if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                  attrs = extend(extend({}, attrs), parent.data.attrs);
-              }
-              parent = parent.parent;
-          }
-      }
-      if (isUndef(attrs)) {
-          return res;
-      }
-      for (const key in attrs) {
-          if (isSSRUnsafeAttr(key)) {
-              continue;
-          }
-          if (key === 'style') {
-              // leave it to the style module
-              continue;
-          }
-          res += renderAttr(key, attrs[key]);
-      }
-      return res;
-  }
-  function renderAttr(key, value) {
-      if (isBooleanAttr(key)) {
-          if (!isFalsyAttrValue(value)) {
-              return ` ${key}="${key}"`;
-          }
-      }
-      else if (isEnumeratedAttr(key)) {
-          return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
-      }
-      else if (!isFalsyAttrValue(value)) {
-          return ` ${key}="${escape(String(value))}"`;
-      }
-      return '';
-  }
-
-  class VNode {
-      tag;
-      data;
-      children;
-      text;
-      elm;
-      ns;
-      context; // rendered in this component's scope
-      key;
-      componentOptions;
-      componentInstance; // component instance
-      parent; // component placeholder node
-      // strictly internal
-      raw; // contains raw HTML? (server only)
-      isStatic; // hoisted static node
-      isRootInsert; // necessary for enter transition check
-      isComment; // empty comment placeholder?
-      isCloned; // is a cloned node?
-      isOnce; // is a v-once node?
-      asyncFactory; // async component factory function
-      asyncMeta;
-      isAsyncPlaceholder;
-      ssrContext;
-      fnContext; // real context vm for functional nodes
-      fnOptions; // for SSR caching
-      devtoolsMeta; // used to store functional render context for devtools
-      fnScopeId; // functional scope id support
-      constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-          this.tag = tag;
-          this.data = data;
-          this.children = children;
-          this.text = text;
-          this.elm = elm;
-          this.ns = undefined;
-          this.context = context;
-          this.fnContext = undefined;
-          this.fnOptions = undefined;
-          this.fnScopeId = undefined;
-          this.key = data && data.key;
-          this.componentOptions = componentOptions;
-          this.componentInstance = undefined;
-          this.parent = undefined;
-          this.raw = false;
-          this.isStatic = false;
-          this.isRootInsert = true;
-          this.isComment = false;
-          this.isCloned = false;
-          this.isOnce = false;
-          this.asyncFactory = asyncFactory;
-          this.asyncMeta = undefined;
-          this.isAsyncPlaceholder = false;
-      }
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get child() {
-          return this.componentInstance;
-      }
-  }
-  const createEmptyVNode = (text = "") => {
-      const node = new VNode();
-      node.text = text;
-      node.isComment = true;
-      return node;
-  };
-  function createTextVNode(val) {
-      return new VNode(undefined, undefined, undefined, String(val));
-  }
-  // optimized shallow clone
-  // used for static nodes and slot nodes because they may be reused across
-  // multiple renders, cloning them avoids errors when DOM manipulations rely
-  // on their elm reference.
-  function cloneVNode(vnode) {
-      const cloned = new VNode(vnode.tag, vnode.data, 
-      // #7975
-      // clone children array to avoid mutating original in case of cloning
-      // a child.
-      vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-      cloned.ns = vnode.ns;
-      cloned.isStatic = vnode.isStatic;
-      cloned.key = vnode.key;
-      cloned.isComment = vnode.isComment;
-      cloned.fnContext = vnode.fnContext;
-      cloned.fnOptions = vnode.fnOptions;
-      cloned.fnScopeId = vnode.fnScopeId;
-      cloned.asyncMeta = vnode.asyncMeta;
-      cloned.isCloned = true;
-      return cloned;
-  }
-
-  function renderDOMProps$1(node) {
-      let props = node.data.domProps;
-      let res = '';
-      let parent = node.parent;
-      while (isDef(parent)) {
-          if (parent.data && parent.data.domProps) {
-              props = extend(extend({}, props), parent.data.domProps);
-          }
-          parent = parent.parent;
-      }
-      if (isUndef(props)) {
-          return res;
-      }
-      const attrs = node.data.attrs;
-      for (const key in props) {
-          if (key === 'innerHTML') {
-              setText(node, props[key], true);
-          }
-          else if (key === 'textContent') {
-              setText(node, props[key], false);
-          }
-          else if (key === 'value' && node.tag === 'textarea') {
-              setText(node, toString(props[key]), false);
-          }
-          else {
-              // $flow-disable-line (WTF?)
-              const attr = propsToAttrMap[key] || key.toLowerCase();
-              if (isRenderableAttr(attr) &&
-                  // avoid rendering double-bound props/attrs twice
-                  !(isDef(attrs) && isDef(attrs[attr]))) {
-                  res += renderAttr(attr, props[key]);
-              }
-          }
-      }
-      return res;
-  }
-  function setText(node, text, raw) {
-      const child = new VNode(undefined, undefined, undefined, text);
-      child.raw = raw;
-      node.children = [child];
-  }
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-      Object.defineProperty(obj, key, {
-          value: val,
-          enumerable: !!enumerable,
-          writable: true,
-          configurable: true,
-      });
-  }
-
-  // can we use __proto__?
-  const hasProto = '__proto__' in {};
-  // Browser environment sniffing
-  const inBrowser = typeof window !== 'undefined';
-  const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-  const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-  const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-  const isIE = UA && /msie|trident/.test(UA);
-  UA && UA.indexOf('msie 9.0') > 0;
-  const isEdge = UA && UA.indexOf('edge/') > 0;
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-  UA && /chrome\/\d+/.test(UA) && !isEdge;
-  UA && /phantomjs/.test(UA);
-  UA && UA.match(/firefox\/(\d+)/);
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  const nativeWatch = {}.watch;
-  let supportsPassive = false;
-  if (inBrowser) {
-      try {
-          const opts = {};
-          Object.defineProperty(opts, 'passive', {
-              get() {
-                  /* istanbul ignore next */
-                  supportsPassive = true;
-              },
-          }); // https://github.com/facebook/flow/issues/285
-          window.addEventListener('test-passive', null, opts);
-      }
-      catch (e) { }
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  let _isServer;
-  const isServerRendering = () => {
-      if (_isServer === undefined) {
-          /* istanbul ignore if */
-          if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-              // detect presence of vue-server-renderer and avoid
-              // Webpack shimming the process
-              _isServer =
-                  global['process'] && global['process'].env.VUE_ENV === 'server';
-          }
-          else {
-              _isServer = false;
-          }
-      }
-      return _isServer;
-  };
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-      return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-  }
-  const hasSymbol = typeof Symbol !== 'undefined' &&
-      isNative(Symbol) &&
-      typeof Reflect !== 'undefined' &&
-      isNative(Reflect.ownKeys);
-  let _Set; // $flow-disable-line
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-      // use native Set when available.
-      _Set = Set;
-  }
-  else {
-      // a non-standard Set polyfill that only works with primitive keys.
-      _Set = class Set {
-          set = Object.create(null);
-          has(key) {
-              return this.set[key] === true;
-          }
-          add(key) {
-              this.set[key] = true;
-          }
-          clear() {
-              this.set = Object.create(null);
-          }
-      };
-  }
-
-  const SSR_ATTR = 'data-server-rendered';
-  const ASSET_TYPES = ['component', 'directive', 'filter'];
-  const LIFECYCLE_HOOKS = [
-      'beforeCreate',
-      'created',
-      'beforeMount',
-      'mounted',
-      'beforeUpdate',
-      'updated',
-      'beforeDestroy',
-      'destroyed',
-      'activated',
-      'deactivated',
-      'errorCaptured',
-      'serverPrefetch',
-  ];
-
-  var config = {
-      /**
-       * Option merge strategies (used in core/util/options)
-       */
-      // $flow-disable-line
-      optionMergeStrategies: Object.create(null),
-      /**
-       * Whether to suppress warnings.
-       */
-      silent: false,
-      /**
-       * Show production mode tip message on boot?
-       */
-      productionTip: "development" !== 'production',
-      /**
-       * Whether to enable devtools
-       */
-      devtools: "development" !== 'production',
-      /**
-       * Whether to record perf
-       */
-      performance: false,
-      /**
-       * Error handler for watcher errors
-       */
-      errorHandler: null,
-      /**
-       * Warn handler for watcher warns
-       */
-      warnHandler: null,
-      /**
-       * Ignore certain custom elements
-       */
-      ignoredElements: [],
-      /**
-       * Custom user key aliases for v-on
-       */
-      // $flow-disable-line
-      keyCodes: Object.create(null),
-      /**
-       * Check if a tag is reserved so that it cannot be registered as a
-       * component. This is platform-dependent and may be overwritten.
-       */
-      isReservedTag: no,
-      /**
-       * Check if an attribute is reserved so that it cannot be used as a component
-       * prop. This is platform-dependent and may be overwritten.
-       */
-      isReservedAttr: no,
-      /**
-       * Check if a tag is an unknown element.
-       * Platform-dependent.
-       */
-      isUnknownElement: no,
-      /**
-       * Get the namespace of an element
-       */
-      getTagNamespace: noop$1,
-      /**
-       * Parse the real tag name for the specific platform.
-       */
-      parsePlatformTagName: identity,
-      /**
-       * Check if an attribute must be bound using property, e.g. value
-       * Platform-dependent.
-       */
-      mustUseProp: no,
-      /**
-       * Perform updates asynchronously. Intended to be used by Vue Test Utils
-       * This will significantly reduce performance if set to false.
-       */
-      async: true,
-      /**
-       * Exposed for legacy reasons
-       */
-      _lifecycleHooks: LIFECYCLE_HOOKS,
-  };
-
-  let warn$2 = noop$1;
-  let tip = noop$1;
-  let generateComponentTrace; // work around flow check
-  let formatComponentName;
-  {
-      const hasConsole = typeof console !== 'undefined';
-      const classifyRE = /(?:^|[-_])(\w)/g;
-      const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-      warn$2 = (msg, vm) => {
-          const trace = vm ? generateComponentTrace(vm) : '';
-          if (hasConsole && !config.silent) {
-              console.error(`[Vue warn]: ${msg}${trace}`);
-          }
-      };
-      tip = (msg, vm) => {
-          if (hasConsole && !config.silent) {
-              console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-          }
-      };
-      formatComponentName = (vm, includeFile) => {
-          if (vm.$root === vm) {
-              return '<Root>';
-          }
-          const options = typeof vm === 'function' && vm.cid != null
-              ? vm.options
-              : vm._isVue
-                  ? vm.$options || vm.constructor.options
-                  : vm;
-          let name = options.name || options._componentTag;
-          const file = options.__file;
-          if (!name && file) {
-              const match = file.match(/([^/\\]+)\.vue$/);
-              name = match && match[1];
-          }
-          return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-              (file && includeFile !== false ? ` at ${file}` : ''));
-      };
-      const repeat = (str, n) => {
-          let res = '';
-          while (n) {
-              if (n % 2 === 1)
-                  res += str;
-              if (n > 1)
-                  str += str;
-              n >>= 1;
-          }
-          return res;
-      };
-      generateComponentTrace = (vm) => {
-          if (vm._isVue && vm.$parent) {
-              const tree = [];
-              let currentRecursiveSequence = 0;
-              while (vm) {
-                  if (tree.length > 0) {
-                      const last = tree[tree.length - 1];
-                      if (last.constructor === vm.constructor) {
-                          currentRecursiveSequence++;
-                          vm = vm.$parent;
-                          continue;
-                      }
-                      else if (currentRecursiveSequence > 0) {
-                          tree[tree.length - 1] = [last, currentRecursiveSequence];
-                          currentRecursiveSequence = 0;
-                      }
-                  }
-                  tree.push(vm);
-                  vm = vm.$parent;
-              }
-              return ('\n\nfound in\n\n' +
-                  tree
-                      .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                      .join('\n'));
-          }
-          else {
-              return `\n\n(found in ${formatComponentName(vm)})`;
-          }
-      };
-  }
-
-  let uid = 0;
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  class Dep {
-      static target;
-      id;
-      subs;
-      constructor() {
-          this.id = uid++;
-          this.subs = [];
-      }
-      addSub(sub) {
-          this.subs.push(sub);
-      }
-      removeSub(sub) {
-          remove$1(this.subs, sub);
-      }
-      depend() {
-          if (Dep.target) {
-              Dep.target.addDep(this);
-          }
-      }
-      notify() {
-          // stabilize the subscriber list first
-          const subs = this.subs.slice();
-          for (let i = 0, l = subs.length; i < l; i++) {
-              subs[i].update();
-          }
-      }
-  }
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null;
-  const targetStack = [];
-  function pushTarget(target) {
-      targetStack.push(target);
-      Dep.target = target;
-  }
-  function popTarget() {
-      targetStack.pop();
-      Dep.target = targetStack[targetStack.length - 1];
-  }
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  const arrayProto = Array.prototype;
-  const arrayMethods = Object.create(arrayProto);
-  const methodsToPatch = [
-      'push',
-      'pop',
-      'shift',
-      'unshift',
-      'splice',
-      'sort',
-      'reverse',
-  ];
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-      // cache original method
-      const original = arrayProto[method];
-      def(arrayMethods, method, function mutator(...args) {
-          const result = original.apply(this, args);
-          const ob = this.__ob__;
-          let inserted;
-          switch (method) {
-              case 'push':
-              case 'unshift':
-                  inserted = args;
-                  break;
-              case 'splice':
-                  inserted = args.slice(2);
-                  break;
-          }
-          if (inserted)
-              ob.observeArray(inserted);
-          // notify change
-          ob.dep.notify();
-          return result;
-      });
-  });
-
-  const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  /**
-   * In some cases we may want to disable observation inside a component's
-   * update computation.
-   */
-  let shouldObserve = true;
-  function toggleObserving(value) {
-      shouldObserve = value;
-  }
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  class Observer {
-      value;
-      dep;
-      vmCount; // number of vms that have this object as root $data
-      constructor(value) {
-          this.value = value;
-          this.dep = new Dep();
-          this.vmCount = 0;
-          def(value, '__ob__', this);
-          if (Array.isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
-              }
-              this.observeArray(value);
-          }
-          else {
-              this.walk(value);
-          }
-      }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      walk(obj) {
-          const keys = Object.keys(obj);
-          for (let i = 0; i < keys.length; i++) {
-              defineReactive(obj, keys[i]);
-          }
-      }
-      /**
-       * Observe a list of Array items.
-       */
-      observeArray(items) {
-          for (let i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
-          }
-      }
-  }
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (let i = 0, l = keys.length; i < l; i++) {
-          const key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-      if (!isObject(value) || value instanceof VNode) {
-          return;
-      }
-      let ob;
-      if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-          ob = value.__ob__;
-      }
-      else if (shouldObserve &&
-          !isServerRendering() &&
-          (Array.isArray(value) || isPlainObject(value)) &&
-          Object.isExtensible(value) &&
-          !value._isVue) {
-          ob = new Observer(value);
-      }
-      if (asRootData && ob) {
-          ob.vmCount++;
-      }
-      return ob;
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-      const dep = new Dep();
-      const property = Object.getOwnPropertyDescriptor(obj, key);
-      if (property && property.configurable === false) {
-          return;
-      }
-      // cater for pre-defined getter/setters
-      const getter = property && property.get;
-      const setter = property && property.set;
-      if ((!getter || setter) && arguments.length === 2) {
-          val = obj[key];
-      }
-      let childOb = !shallow && observe(val);
-      Object.defineProperty(obj, key, {
-          enumerable: true,
-          configurable: true,
-          get: function reactiveGetter() {
-              const value = getter ? getter.call(obj) : val;
-              if (Dep.target) {
-                  dep.depend();
-                  if (childOb) {
-                      childOb.dep.depend();
-                      if (Array.isArray(value)) {
-                          dependArray(value);
-                      }
-                  }
-              }
-              return value;
-          },
-          set: function reactiveSetter(newVal) {
-              const value = getter ? getter.call(obj) : val;
-              /* eslint-disable no-self-compare */
-              if (newVal === value || (newVal !== newVal && value !== value)) {
-                  return;
-              }
-              /* eslint-enable no-self-compare */
-              if (customSetter) {
-                  customSetter();
-              }
-              // #7981: for accessor properties without setter
-              if (getter && !setter)
-                  return;
-              if (setter) {
-                  setter.call(obj, newVal);
-              }
-              else {
-                  val = newVal;
-              }
-              childOb = !shallow && observe(newVal);
-              dep.notify();
-          },
-      });
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-      if ((isUndef(target) || isPrimitive(target))) {
-          warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-      }
-      if (Array.isArray(target) && isValidArrayIndex(key)) {
-          target.length = Math.max(target.length, key);
-          target.splice(key, 1, val);
-          return val;
-      }
-      if (key in target && !(key in Object.prototype)) {
-          target[key] = val;
-          return val;
-      }
-      const ob = target.__ob__;
-      if (target._isVue || (ob && ob.vmCount)) {
-          warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                  'at runtime - declare it upfront in the data option.');
-          return val;
-      }
-      if (!ob) {
-          target[key] = val;
-          return val;
-      }
-      defineReactive(ob.value, key, val);
-      ob.dep.notify();
-      return val;
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-      for (let e, i = 0, l = value.length; i < l; i++) {
-          e = value[i];
-          e && e.__ob__ && e.__ob__.dep.depend();
-          if (Array.isArray(e)) {
-              dependArray(e);
-          }
-      }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  const strats = config.optionMergeStrategies;
-  /**
-   * Options with restrictions
-   */
-  {
-      strats.el = strats.propsData = function (parent, child, vm, key) {
-          if (!vm) {
-              warn$2(`option "${key}" can only be used during instance ` +
-                  'creation with the `new` keyword.');
-          }
-          return defaultStrat(parent, child);
-      };
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-      if (!from)
-          return to;
-      let key, toVal, fromVal;
-      const keys = hasSymbol
-          ? Reflect.ownKeys(from)
-          : Object.keys(from);
-      for (let i = 0; i < keys.length; i++) {
-          key = keys[i];
-          // in case the object is already observed...
-          if (key === '__ob__')
-              continue;
-          toVal = to[key];
-          fromVal = from[key];
-          if (!hasOwn(to, key)) {
-              set(to, key, fromVal);
-          }
-          else if (toVal !== fromVal &&
-              isPlainObject(toVal) &&
-              isPlainObject(fromVal)) {
-              mergeData(toVal, fromVal);
-          }
-      }
-      return to;
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-      if (!vm) {
-          // in a Vue.extend merge, both should be functions
-          if (!childVal) {
-              return parentVal;
-          }
-          if (!parentVal) {
-              return childVal;
-          }
-          // when parentVal & childVal are both present,
-          // we need to return a function that returns the
-          // merged result of both functions... no need to
-          // check if parentVal is a function here because
-          // it has to be a function to pass previous merges.
-          return function mergedDataFn() {
-              return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-          };
-      }
-      else {
-          return function mergedInstanceDataFn() {
-              // instance merge
-              const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-              const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-              if (instanceData) {
-                  return mergeData(instanceData, defaultData);
-              }
-              else {
-                  return defaultData;
-              }
-          };
-      }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-      if (!vm) {
-          if (childVal && typeof childVal !== 'function') {
-              warn$2('The "data" option should be a function ' +
-                      'that returns a per-instance value in component ' +
-                      'definitions.', vm);
-              return parentVal;
-          }
-          return mergeDataOrFn(parentVal, childVal);
-      }
-      return mergeDataOrFn(parentVal, childVal, vm);
-  };
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook$1(parentVal, childVal) {
-      const res = childVal
-          ? parentVal
-              ? parentVal.concat(childVal)
-              : Array.isArray(childVal)
-                  ? childVal
-                  : [childVal]
-          : parentVal;
-      return res ? dedupeHooks(res) : res;
-  }
-  function dedupeHooks(hooks) {
-      const res = [];
-      for (let i = 0; i < hooks.length; i++) {
-          if (res.indexOf(hooks[i]) === -1) {
-              res.push(hooks[i]);
-          }
-      }
-      return res;
-  }
-  LIFECYCLE_HOOKS.forEach((hook) => {
-      strats[hook] = mergeHook$1;
-  });
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-      const res = Object.create(parentVal || null);
-      if (childVal) {
-          assertObjectType(key, childVal, vm);
-          return extend(res, childVal);
-      }
-      else {
-          return res;
-      }
-  }
-  ASSET_TYPES.forEach(function (type) {
-      strats[type + 's'] = mergeAssets;
-  });
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-      // work around Firefox's Object.prototype.watch...
-      //@ts-expect-error work around
-      if (parentVal === nativeWatch)
-          parentVal = undefined;
-      //@ts-expect-error work around
-      if (childVal === nativeWatch)
-          childVal = undefined;
-      /* istanbul ignore if */
-      if (!childVal)
-          return Object.create(parentVal || null);
-      {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = {};
-      extend(ret, parentVal);
-      for (const key in childVal) {
-          let parent = ret[key];
-          const child = childVal[key];
-          if (parent && !Array.isArray(parent)) {
-              parent = [parent];
-          }
-          ret[key] = parent
-              ? parent.concat(child)
-              : Array.isArray(child)
-                  ? child
-                  : [child];
-      }
-      return ret;
-  };
-  /**
-   * Other object hashes.
-   */
-  strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-      if (childVal && "development" !== 'production') {
-          assertObjectType(key, childVal, vm);
-      }
-      if (!parentVal)
-          return childVal;
-      const ret = Object.create(null);
-      extend(ret, parentVal);
-      if (childVal)
-          extend(ret, childVal);
-      return ret;
-  };
-  strats.provide = mergeDataOrFn;
-  /**
-   * Default strategy.
-   */
-  const defaultStrat = function (parentVal, childVal) {
-      return childVal === undefined ? parentVal : childVal;
-  };
-  /**
-   * Validate component names
-   */
-  function checkComponents(options) {
-      for (const key in options.components) {
-          validateComponentName(key);
-      }
-  }
-  function validateComponentName(name) {
-      if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-          warn$2('Invalid component name: "' +
-              name +
-              '". Component names ' +
-              'should conform to valid custom element name in html5 specification.');
-      }
-      if (isBuiltInTag(name) || config.isReservedTag(name)) {
-          warn$2('Do not use built-in or reserved HTML elements as component ' +
-              'id: ' +
-              name);
-      }
-  }
-  /**
-   * Ensure all props option syntax are normalized into the
-   * Object-based format.
-   */
-  function normalizeProps(options, vm) {
-      const props = options.props;
-      if (!props)
-          return;
-      const res = {};
-      let i, val, name;
-      if (Array.isArray(props)) {
-          i = props.length;
-          while (i--) {
-              val = props[i];
-              if (typeof val === 'string') {
-                  name = camelize(val);
-                  res[name] = { type: null };
-              }
-              else {
-                  warn$2('props must be strings when using array syntax.');
-              }
-          }
-      }
-      else if (isPlainObject(props)) {
-          for (const key in props) {
-              val = props[key];
-              name = camelize(key);
-              res[name] = isPlainObject(val) ? val : { type: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-              `but got ${toRawType(props)}.`, vm);
-      }
-      options.props = res;
-  }
-  /**
-   * Normalize all injections into Object-based format
-   */
-  function normalizeInject(options, vm) {
-      const inject = options.inject;
-      if (!inject)
-          return;
-      const normalized = (options.inject = {});
-      if (Array.isArray(inject)) {
-          for (let i = 0; i < inject.length; i++) {
-              normalized[inject[i]] = { from: inject[i] };
-          }
-      }
-      else if (isPlainObject(inject)) {
-          for (const key in inject) {
-              const val = inject[key];
-              normalized[key] = isPlainObject(val)
-                  ? extend({ from: key }, val)
-                  : { from: val };
-          }
-      }
-      else {
-          warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-              `but got ${toRawType(inject)}.`, vm);
-      }
-  }
-  /**
-   * Normalize raw function directives into object format.
-   */
-  function normalizeDirectives(options) {
-      const dirs = options.directives;
-      if (dirs) {
-          for (const key in dirs) {
-              const def = dirs[key];
-              if (typeof def === 'function') {
-                  dirs[key] = { bind: def, update: def };
-              }
-          }
-      }
-  }
-  function assertObjectType(name, value, vm) {
-      if (!isPlainObject(value)) {
-          warn$2(`Invalid value for option "${name}": expected an Object, ` +
-              `but got ${toRawType(value)}.`, vm);
-      }
-  }
-  /**
-   * Merge two option objects into a new one.
-   * Core utility used in both instantiation and inheritance.
-   */
-  function mergeOptions(parent, child, vm) {
-      {
-          checkComponents(child);
-      }
-      if (typeof child === 'function') {
-          // @ts-expect-error
-          child = child.options;
-      }
-      normalizeProps(child, vm);
-      normalizeInject(child, vm);
-      normalizeDirectives(child);
-      // Apply extends and mixins on the child options,
-      // but only if it is a raw options object that isn't
-      // the result of another mergeOptions call.
-      // Only merged options has the _base property.
-      if (!child._base) {
-          if (child.extends) {
-              parent = mergeOptions(parent, child.extends, vm);
-          }
-          if (child.mixins) {
-              for (let i = 0, l = child.mixins.length; i < l; i++) {
-                  parent = mergeOptions(parent, child.mixins[i], vm);
-              }
-          }
-      }
-      const options = {};
-      let key;
-      for (key in parent) {
-          mergeField(key);
-      }
-      for (key in child) {
-          if (!hasOwn(parent, key)) {
-              mergeField(key);
-          }
-      }
-      function mergeField(key) {
-          const strat = strats[key] || defaultStrat;
-          options[key] = strat(parent[key], child[key], vm, key);
-      }
-      return options;
-  }
-  /**
-   * Resolve an asset.
-   * This function is used because child instances need access
-   * to assets defined in its ancestor chain.
-   */
-  function resolveAsset(options, type, id, warnMissing) {
-      /* istanbul ignore if */
-      if (typeof id !== 'string') {
-          return;
-      }
-      const assets = options[type];
-      // check local registration variations first
-      if (hasOwn(assets, id))
-          return assets[id];
-      const camelizedId = camelize(id);
-      if (hasOwn(assets, camelizedId))
-          return assets[camelizedId];
-      const PascalCaseId = capitalize(camelizedId);
-      if (hasOwn(assets, PascalCaseId))
-          return assets[PascalCaseId];
-      // fallback to prototype chain
-      const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-      if (warnMissing && !res) {
-          warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-      }
-      return res;
-  }
-
-  function validateProp(key, propOptions, propsData, vm) {
-      const prop = propOptions[key];
-      const absent = !hasOwn(propsData, key);
-      let value = propsData[key];
-      // boolean casting
-      const booleanIndex = getTypeIndex(Boolean, prop.type);
-      if (booleanIndex > -1) {
-          if (absent && !hasOwn(prop, 'default')) {
-              value = false;
-          }
-          else if (value === '' || value === hyphenate(key)) {
-              // only cast empty string / same name to boolean if
-              // boolean has higher priority
-              const stringIndex = getTypeIndex(String, prop.type);
-              if (stringIndex < 0 || booleanIndex < stringIndex) {
-                  value = true;
-              }
-          }
-      }
-      // check default value
-      if (value === undefined) {
-          value = getPropDefaultValue(vm, prop, key);
-          // since the default value is a fresh copy,
-          // make sure to observe it.
-          const prevShouldObserve = shouldObserve;
-          toggleObserving(true);
-          observe(value);
-          toggleObserving(prevShouldObserve);
-      }
-      {
-          assertProp(prop, key, value, vm, absent);
-      }
-      return value;
-  }
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue(vm, prop, key) {
-      // no default, return undefined
-      if (!hasOwn(prop, 'default')) {
-          return undefined;
-      }
-      const def = prop.default;
-      // warn against non-factory defaults for Object & Array
-      if (isObject(def)) {
-          warn$2('Invalid default value for prop "' +
-              key +
-              '": ' +
-              'Props with type Object/Array must use a factory function ' +
-              'to return the default value.', vm);
-      }
-      // the raw prop value was also undefined from previous render,
-      // return previous default value to avoid unnecessary watcher trigger
-      if (vm &&
-          vm.$options.propsData &&
-          vm.$options.propsData[key] === undefined &&
-          vm._props[key] !== undefined) {
-          return vm._props[key];
-      }
-      // call factory function for non-Function types
-      // a value is Function if its prototype is function even across different execution context
-      return typeof def === 'function' && getType(prop.type) !== 'Function'
-          ? def.call(vm)
-          : def;
-  }
-  /**
-   * Assert whether a prop is valid.
-   */
-  function assertProp(prop, name, value, vm, absent) {
-      if (prop.required && absent) {
-          warn$2('Missing required prop: "' + name + '"', vm);
-          return;
-      }
-      if (value == null && !prop.required) {
-          return;
-      }
-      let type = prop.type;
-      let valid = !type || type === true;
-      const expectedTypes = [];
-      if (type) {
-          if (!Array.isArray(type)) {
-              type = [type];
-          }
-          for (let i = 0; i < type.length && !valid; i++) {
-              const assertedType = assertType(value, type[i], vm);
-              expectedTypes.push(assertedType.expectedType || '');
-              valid = assertedType.valid;
-          }
-      }
-      const haveExpectedTypes = expectedTypes.some((t) => t);
-      if (!valid && haveExpectedTypes) {
-          warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-          return;
-      }
-      const validator = prop.validator;
-      if (validator) {
-          if (!validator(value)) {
-              warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-          }
-      }
-  }
-  const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-  function assertType(value, type, vm) {
-      let valid;
-      const expectedType = getType(type);
-      if (simpleCheckRE.test(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
-          }
-      }
-      else if (expectedType === 'Object') {
-          valid = isPlainObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = Array.isArray(value);
-      }
-      else {
-          try {
-              valid = value instanceof type;
-          }
-          catch (e) {
-              warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-              valid = false;
-          }
-      }
-      return {
-          valid,
-          expectedType,
-      };
-  }
-  const functionTypeCheckRE = /^\s*function (\w+)/;
-  /**
-   * Use function string name to check built-in types,
-   * because a simple equality check will fail when running
-   * across different vms / iframes.
-   */
-  function getType(fn) {
-      const match = fn && fn.toString().match(functionTypeCheckRE);
-      return match ? match[1] : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
-  }
-  function getTypeIndex(type, expectedTypes) {
-      if (!Array.isArray(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
-      }
-      for (let i = 0, len = expectedTypes.length; i < len; i++) {
-          if (isSameType(expectedTypes[i], type)) {
-              return i;
-          }
-      }
-      return -1;
-  }
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          isExplicable(typeof value) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${styleValue(value, expectedType)}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${styleValue(value, receivedType)}.`;
-      }
-      return message;
-  }
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
-      }
-      else {
-          return `${value}`;
-      }
-  }
-  const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-  function isExplicable(value) {
-      return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-      return args.some((elem) => elem.toLowerCase() === 'boolean');
-  }
-
-  function handleError(err, vm, info) {
-      // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-      // See: https://github.com/vuejs/vuex/issues/1505
-      pushTarget();
-      try {
-          if (vm) {
-              let cur = vm;
-              while ((cur = cur.$parent)) {
-                  const hooks = cur.$options.errorCaptured;
-                  if (hooks) {
-                      for (let i = 0; i < hooks.length; i++) {
-                          try {
-                              const capture = hooks[i].call(cur, err, vm, info) === false;
-                              if (capture)
-                                  return;
-                          }
-                          catch (e) {
-                              globalHandleError(e, cur, 'errorCaptured hook');
-                          }
-                      }
-                  }
-              }
-          }
-          globalHandleError(err, vm, info);
-      }
-      finally {
-          popTarget();
-      }
-  }
-  function invokeWithErrorHandling(handler, context, args, vm, info) {
-      let res;
-      try {
-          res = args ? handler.apply(context, args) : handler.call(context);
-          if (res && !res._isVue && isPromise(res) && !res._handled) {
-              res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-              // issue #9511
-              // avoid catch triggering multiple times when nested calls
-              res._handled = true;
-          }
-      }
-      catch (e) {
-          // @ts-expect-error should it be any?
-          handleError(e, vm, info);
-      }
-      return res;
-  }
-  function globalHandleError(err, vm, info) {
-      logError(err, vm, info);
-  }
-  function logError(err, vm, info) {
-      {
-          warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-      }
-      /* istanbul ignore else */
-      if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-          console.error(err);
-      }
-      else {
-          throw err;
-      }
-  }
-
-  /* globals MutationObserver */
-  const callbacks = [];
-  function flushCallbacks() {
-      const copies = callbacks.slice(0);
-      callbacks.length = 0;
-      for (let i = 0; i < copies.length; i++) {
-          copies[i]();
-      }
-  }
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-      Promise.resolve();
-  }
-  else if (!isIE &&
-      typeof MutationObserver !== 'undefined' &&
-      (isNative(MutationObserver) ||
-          // PhantomJS and iOS 7.x
-          MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-      // Use MutationObserver where native Promise is not available,
-      // e.g. PhantomJS, iOS7, Android 4.4
-      // (#6466 MutationObserver is unreliable in IE11)
-      let counter = 1;
-      const observer = new MutationObserver(flushCallbacks);
-      const textNode = document.createTextNode(String(counter));
-      observer.observe(textNode, {
-          characterData: true,
-      });
-  }
-  else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-  else ;
-
-  function genClassForVnode(vnode) {
-      let data = vnode.data;
-      let parentNode = vnode;
-      let childNode = vnode;
-      while (isDef(childNode.componentInstance)) {
-          childNode = childNode.componentInstance._vnode;
-          if (childNode && childNode.data) {
-              data = mergeClassData(childNode.data, data);
-          }
-      }
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while (isDef((parentNode = parentNode.parent))) {
-          if (parentNode && parentNode.data) {
-              data = mergeClassData(data, parentNode.data);
-          }
-      }
-      return renderClass$1(data.staticClass, data.class);
-  }
-  function mergeClassData(child, parent) {
-      return {
-          staticClass: concat(child.staticClass, parent.staticClass),
-          class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-      };
-  }
-  function renderClass$1(staticClass, dynamicClass) {
-      if (isDef(staticClass) || isDef(dynamicClass)) {
-          return concat(staticClass, stringifyClass(dynamicClass));
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function concat(a, b) {
-      return a ? (b ? a + ' ' + b : a) : b || '';
-  }
-  function stringifyClass(value) {
-      if (Array.isArray(value)) {
-          return stringifyArray(value);
-      }
-      if (isObject(value)) {
-          return stringifyObject(value);
-      }
-      if (typeof value === 'string') {
-          return value;
-      }
-      /* istanbul ignore next */
-      return '';
-  }
-  function stringifyArray(value) {
-      let res = '';
-      let stringified;
-      for (let i = 0, l = value.length; i < l; i++) {
-          if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-              if (res)
-                  res += ' ';
-              res += stringified;
-          }
-      }
-      return res;
-  }
-  function stringifyObject(value) {
-      let res = '';
-      for (const key in value) {
-          if (value[key]) {
-              if (res)
-                  res += ' ';
-              res += key;
-          }
-      }
-      return res;
-  }
-
-  const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot');
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-  const isPreTag = (tag) => tag === 'pre';
-  const isReservedTag = (tag) => {
-      return isHTMLTag(tag) || isSVG(tag);
-  };
-  function getTagNamespace(tag) {
-      if (isSVG(tag)) {
-          return 'svg';
-      }
-      // basic support for MathML
-      // note it doesn't support other MathML elements being component roots
-      if (tag === 'math') {
-          return 'math';
-      }
-  }
-  makeMap('text,number,password,search,email,tel,url');
-
-  function renderClass(node) {
-      const classList = genClassForVnode(node);
-      if (classList !== '') {
-          return ` class="${escape(classList)}"`;
-      }
-  }
-
-  const parseStyleText = cached(function (cssText) {
-      const res = {};
-      const listDelimiter = /;(?![^(]*\))/g;
-      const propertyDelimiter = /:(.+)/;
-      cssText.split(listDelimiter).forEach(function (item) {
-          if (item) {
-              const tmp = item.split(propertyDelimiter);
-              tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-          }
-      });
-      return res;
-  });
-  // merge static and dynamic style data on the same vnode
-  function normalizeStyleData(data) {
-      const style = normalizeStyleBinding(data.style);
-      // static style is pre-processed into an object during compilation
-      // and is always a fresh object, so it's safe to merge into it
-      return data.staticStyle ? extend(data.staticStyle, style) : style;
-  }
-  // normalize possible array / string values into Object
-  function normalizeStyleBinding(bindingStyle) {
-      if (Array.isArray(bindingStyle)) {
-          return toObject(bindingStyle);
-      }
-      if (typeof bindingStyle === 'string') {
-          return parseStyleText(bindingStyle);
-      }
-      return bindingStyle;
-  }
-  /**
-   * parent component style should be after child's
-   * so that parent component's style could override it
-   */
-  function getStyle(vnode, checkChild) {
-      const res = {};
-      let styleData;
-      if (checkChild) {
-          let childNode = vnode;
-          while (childNode.componentInstance) {
-              childNode = childNode.componentInstance._vnode;
-              if (childNode &&
-                  childNode.data &&
-                  (styleData = normalizeStyleData(childNode.data))) {
-                  extend(res, styleData);
-              }
-          }
-      }
-      if ((styleData = normalizeStyleData(vnode.data))) {
-          extend(res, styleData);
-      }
-      let parentNode = vnode;
-      // @ts-expect-error parentNode.parent not VNodeWithData
-      while ((parentNode = parentNode.parent)) {
-          if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-              extend(res, styleData);
-          }
-      }
-      return res;
-  }
-
-  function genStyle(style) {
-      let styleText = '';
-      for (const key in style) {
-          const value = style[key];
-          const hyphenatedKey = hyphenate(key);
-          if (Array.isArray(value)) {
-              for (let i = 0, len = value.length; i < len; i++) {
-                  styleText += normalizeValue(hyphenatedKey, value[i]);
-              }
-          }
-          else {
-              styleText += normalizeValue(hyphenatedKey, value);
-          }
-      }
-      return styleText;
-  }
-  function normalizeValue(key, value) {
-      if (typeof value === 'string' ||
-          (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-          value === 0) {
-          return `${key}:${value};`;
-      }
-      else {
-          // invalid values
-          return ``;
-      }
-  }
-  function renderStyle(vnode) {
-      const styleText = genStyle(getStyle(vnode, false));
-      if (styleText !== '') {
-          return ` style=${JSON.stringify(escape(styleText))}`;
-      }
-  }
-
-  var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
-
-  function show(node, dir) {
-      if (!dir.value) {
-          const style = node.data.style || (node.data.style = {});
-          if (Array.isArray(style)) {
-              style.push({ display: 'none' });
-          }
-          else {
-              style.display = 'none';
-          }
-      }
-  }
-
-  // this is only applied for <select v-model> because it is the only edge case
-  // that must be done at runtime instead of compile time.
-  function model$2(node, dir) {
-      if (!node.children)
-          return;
-      const value = dir.value;
-      const isMultiple = node.data.attrs && node.data.attrs.multiple;
-      for (let i = 0, l = node.children.length; i < l; i++) {
-          const option = node.children[i];
-          if (option.tag === 'option') {
-              if (isMultiple) {
-                  const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
-                  if (selected) {
-                      setSelected(option);
-                  }
-              }
-              else {
-                  if (looseEqual(value, getValue(option))) {
-                      setSelected(option);
-                      return;
-                  }
-              }
-          }
-      }
-  }
-  function getValue(option) {
-      const data = option.data || {};
-      return ((data.attrs && data.attrs.value) ||
-          (data.domProps && data.domProps.value) ||
-          (option.children && option.children[0] && option.children[0].text));
-  }
-  function setSelected(option) {
-      const data = option.data || (option.data = {});
-      const attrs = data.attrs || (data.attrs = {});
-      attrs.selected = '';
-  }
-
-  var directives$1 = {
-      show,
-      model: model$2,
-  };
-
-  const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr');
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-      'title,tr,track');
-
-  const MAX_STACK_DEPTH = 800;
-  const noop = (_) => _;
-  const defer = typeof process !== 'undefined' && process.nextTick
-      ? process.nextTick
-      : typeof Promise !== 'undefined'
-          ? (fn) => Promise.resolve().then(fn)
-          : typeof setTimeout !== 'undefined'
-              ? setTimeout
-              : noop;
-  if (defer === noop) {
-      throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
-          'that are required by vue-server-renderer. Please use a polyfill for ' +
-          'either Promise or setTimeout.');
-  }
-  function createWriteFunction(write, onError) {
-      let stackDepth = 0;
-      const cachedWrite = (text, next) => {
-          if (text && cachedWrite.caching) {
-              cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-          }
-          const waitForNext = write(text, next);
-          if (waitForNext !== true) {
-              if (stackDepth >= MAX_STACK_DEPTH) {
-                  defer(() => {
-                      try {
-                          next();
-                      }
-                      catch (e) {
-                          onError(e);
-                      }
-                  });
-              }
-              else {
-                  stackDepth++;
-                  next();
-                  stackDepth--;
-              }
-          }
-      };
-      cachedWrite.caching = false;
-      cachedWrite.cacheBuffer = [];
-      cachedWrite.componentBuffer = [];
-      return cachedWrite;
-  }
-
-  class RenderContext {
-      userContext;
-      activeInstance;
-      renderStates;
-      write;
-      renderNode;
-      //@ts-expect-error
-      next;
-      done;
-      modules;
-      directives;
-      isUnaryTag;
-      cache;
-      get;
-      has;
-      constructor(options) {
-          this.userContext = options.userContext;
-          this.activeInstance = options.activeInstance;
-          this.renderStates = [];
-          this.write = options.write;
-          this.done = options.done;
-          this.renderNode = options.renderNode;
-          this.isUnaryTag = options.isUnaryTag;
-          this.modules = options.modules;
-          this.directives = options.directives;
-          const cache = options.cache;
-          if (cache && (!cache.get || !cache.set)) {
-              throw new Error('renderer cache must implement at least get & set.');
-          }
-          this.cache = cache;
-          this.get = cache && normalizeAsync(cache, 'get');
-          this.has = cache && normalizeAsync(cache, 'has');
-          //@ts-expect-error
-          this.next = this.next.bind(this);
-      }
-      //@ts-expect-error
-      next() {
-          // eslint-disable-next-line
-          while (true) {
-              const lastState = this.renderStates[this.renderStates.length - 1];
-              if (isUndef(lastState)) {
-                  return this.done();
-              }
-              /* eslint-disable no-case-declarations */
-              switch (lastState.type) {
-                  case 'Element':
-                  case 'Fragment':
-                      const { children, total } = lastState;
-                      const rendered = lastState.rendered++;
-                      if (rendered < total) {
-                          return this.renderNode(children[rendered], false, this);
-                      }
-                      else {
-                          this.renderStates.pop();
-                          if (lastState.type === 'Element') {
-                              return this.write(lastState.endTag, this.next);
-                          }
-                      }
-                      break;
-                  case 'Component':
-                      this.renderStates.pop();
-                      this.activeInstance = lastState.prevActive;
-                      break;
-                  case 'ComponentWithCache':
-                      this.renderStates.pop();
-                      const { buffer, bufferIndex, componentBuffer, key } = lastState;
-                      const result = {
-                          html: buffer[bufferIndex],
-                          components: componentBuffer[bufferIndex],
-                      };
-                      this.cache.set(key, result);
-                      if (bufferIndex === 0) {
-                          // this is a top-level cached component,
-                          // exit caching mode.
-                          //@ts-expect-error
-                          this.write.caching = false;
-                      }
-                      else {
-                          // parent component is also being cached,
-                          // merge self into parent's result
-                          buffer[bufferIndex - 1] += result.html;
-                          const prev = componentBuffer[bufferIndex - 1];
-                          result.components.forEach((c) => prev.add(c));
-                      }
-                      buffer.length = bufferIndex;
-                      componentBuffer.length = bufferIndex;
-                      break;
-              }
-          }
-      }
-  }
-  function normalizeAsync(cache, method) {
-      const fn = cache[method];
-      if (isUndef(fn)) {
-          return;
-      }
-      else if (fn.length > 1) {
-          return (key, cb) => fn.call(cache, key, cb);
-      }
-      else {
-          return (key, cb) => cb(fn.call(cache, key));
-      }
-  }
-
-  const validDivisionCharRE = /[\w).+\-_$\]]/;
-  function parseFilters(exp) {
-      let inSingle = false;
-      let inDouble = false;
-      let inTemplateString = false;
-      let inRegex = false;
-      let curly = 0;
-      let square = 0;
-      let paren = 0;
-      let lastFilterIndex = 0;
-      let c, prev, i, expression, filters;
-      for (i = 0; i < exp.length; i++) {
-          prev = c;
-          c = exp.charCodeAt(i);
-          if (inSingle) {
-              if (c === 0x27 && prev !== 0x5c)
-                  inSingle = false;
-          }
-          else if (inDouble) {
-              if (c === 0x22 && prev !== 0x5c)
-                  inDouble = false;
-          }
-          else if (inTemplateString) {
-              if (c === 0x60 && prev !== 0x5c)
-                  inTemplateString = false;
-          }
-          else if (inRegex) {
-              if (c === 0x2f && prev !== 0x5c)
-                  inRegex = false;
-          }
-          else if (c === 0x7c && // pipe
-              exp.charCodeAt(i + 1) !== 0x7c &&
-              exp.charCodeAt(i - 1) !== 0x7c &&
-              !curly &&
-              !square &&
-              !paren) {
-              if (expression === undefined) {
-                  // first filter, end of expression
-                  lastFilterIndex = i + 1;
-                  expression = exp.slice(0, i).trim();
-              }
-              else {
-                  pushFilter();
-              }
-          }
-          else {
-              switch (c) {
-                  case 0x22:
-                      inDouble = true;
-                      break; // "
-                  case 0x27:
-                      inSingle = true;
-                      break; // '
-                  case 0x60:
-                      inTemplateString = true;
-                      break; // `
-                  case 0x28:
-                      paren++;
-                      break; // (
-                  case 0x29:
-                      paren--;
-                      break; // )
-                  case 0x5b:
-                      square++;
-                      break; // [
-                  case 0x5d:
-                      square--;
-                      break; // ]
-                  case 0x7b:
-                      curly++;
-                      break; // {
-                  case 0x7d:
-                      curly--;
-                      break; // }
-              }
-              if (c === 0x2f) {
-                  // /
-                  let j = i - 1;
-                  let p;
-                  // find first non-whitespace prev char
-                  for (; j >= 0; j--) {
-                      p = exp.charAt(j);
-                      if (p !== ' ')
-                          break;
-                  }
-                  if (!p || !validDivisionCharRE.test(p)) {
-                      inRegex = true;
-                  }
-              }
-          }
-      }
-      if (expression === undefined) {
-          expression = exp.slice(0, i).trim();
-      }
-      else if (lastFilterIndex !== 0) {
-          pushFilter();
-      }
-      function pushFilter() {
-          (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-          lastFilterIndex = i + 1;
-      }
-      if (filters) {
-          for (i = 0; i < filters.length; i++) {
-              expression = wrapFilter(expression, filters[i]);
-          }
-      }
-      return expression;
-  }
-  function wrapFilter(exp, filter) {
-      const i = filter.indexOf('(');
-      if (i < 0) {
-          // _f: resolveFilter
-          return `_f("${filter}")(${exp})`;
-      }
-      else {
-          const name = filter.slice(0, i);
-          const args = filter.slice(i + 1);
-          return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-      }
-  }
-
-  const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-  const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-  const buildRegex = cached((delimiters) => {
-      const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-      const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-      return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-  });
-  function parseText(text, delimiters) {
-      //@ts-expect-error
-      const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-      if (!tagRE.test(text)) {
-          return;
-      }
-      const tokens = [];
-      const rawTokens = [];
-      let lastIndex = (tagRE.lastIndex = 0);
-      let match, index, tokenValue;
-      while ((match = tagRE.exec(text))) {
-          index = match.index;
-          // push text token
-          if (index > lastIndex) {
-              rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-              tokens.push(JSON.stringify(tokenValue));
-          }
-          // tag token
-          const exp = parseFilters(match[1].trim());
-          tokens.push(`_s(${exp})`);
-          rawTokens.push({ '@binding': exp });
-          lastIndex = index + match[0].length;
-      }
-      if (lastIndex < text.length) {
-          rawTokens.push((tokenValue = text.slice(lastIndex)));
-          tokens.push(JSON.stringify(tokenValue));
-      }
-      return {
-          expression: tokens.join('+'),
-          tokens: rawTokens,
-      };
-  }
-
-  /* eslint-disable no-unused-vars */
-  function baseWarn(msg, range) {
-      console.error(`[Vue compiler]: ${msg}`);
-  }
-  /* eslint-enable no-unused-vars */
-  function pluckModuleFunction(modules, key) {
-      return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-  }
-  function addProp(el, name, value, range, dynamic) {
-      (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  function addAttr(el, name, value, range, dynamic) {
-      const attrs = dynamic
-          ? el.dynamicAttrs || (el.dynamicAttrs = [])
-          : el.attrs || (el.attrs = []);
-      attrs.push(rangeSetItem({ name, value, dynamic }, range));
-      el.plain = false;
-  }
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr(el, name, value, range) {
-      el.attrsMap[name] = value;
-      el.attrsList.push(rangeSetItem({ name, value }, range));
-  }
-  function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-      (el.directives || (el.directives = [])).push(rangeSetItem({
-          name,
-          rawName,
-          value,
-          arg,
-          isDynamicArg,
-          modifiers,
-      }, range));
-      el.plain = false;
-  }
-  function prependModifierMarker(symbol, name, dynamic) {
-      return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-  }
-  function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-      modifiers = modifiers || emptyObject;
-      // warn prevent and passive modifier
-      /* istanbul ignore if */
-      if (warn &&
-          modifiers.prevent &&
-          modifiers.passive) {
-          warn("passive and prevent can't be used together. " +
-              "Passive handler can't prevent default event.", range);
-      }
-      // normalize click.right and click.middle since they don't actually fire
-      // this is technically browser-specific, but at least for now browsers are
-      // the only target envs that have right/middle clicks.
-      if (modifiers.right) {
-          if (dynamic) {
-              name = `(${name})==='click'?'contextmenu':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'contextmenu';
-              delete modifiers.right;
-          }
-      }
-      else if (modifiers.middle) {
-          if (dynamic) {
-              name = `(${name})==='click'?'mouseup':(${name})`;
-          }
-          else if (name === 'click') {
-              name = 'mouseup';
-          }
-      }
-      // check capture modifier
-      if (modifiers.capture) {
-          delete modifiers.capture;
-          name = prependModifierMarker('!', name, dynamic);
-      }
-      if (modifiers.once) {
-          delete modifiers.once;
-          name = prependModifierMarker('~', name, dynamic);
-      }
-      /* istanbul ignore if */
-      if (modifiers.passive) {
-          delete modifiers.passive;
-          name = prependModifierMarker('&', name, dynamic);
-      }
-      let events;
-      if (modifiers.native) {
-          delete modifiers.native;
-          events = el.nativeEvents || (el.nativeEvents = {});
-      }
-      else {
-          events = el.events || (el.events = {});
-      }
-      const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-      if (modifiers !== emptyObject) {
-          newHandler.modifiers = modifiers;
-      }
-      const handlers = events[name];
-      /* istanbul ignore if */
-      if (Array.isArray(handlers)) {
-          important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-      }
-      else if (handlers) {
-          events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-      }
-      else {
-          events[name] = newHandler;
-      }
-      el.plain = false;
-  }
-  function getRawBindingAttr(el, name) {
-      return (el.rawAttrsMap[':' + name] ||
-          el.rawAttrsMap['v-bind:' + name] ||
-          el.rawAttrsMap[name]);
-  }
-  function getBindingAttr(el, name, getStatic) {
-      const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-      if (dynamicValue != null) {
-          return parseFilters(dynamicValue);
-      }
-      else if (getStatic !== false) {
-          const staticValue = getAndRemoveAttr(el, name);
-          if (staticValue != null) {
-              return JSON.stringify(staticValue);
-          }
-      }
-  }
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr(el, name, removeFromMap) {
-      let val;
-      if ((val = el.attrsMap[name]) != null) {
-          const list = el.attrsList;
-          for (let i = 0, l = list.length; i < l; i++) {
-              if (list[i].name === name) {
-                  list.splice(i, 1);
-                  break;
-              }
-          }
-      }
-      if (removeFromMap) {
-          delete el.attrsMap[name];
-      }
-      return val;
-  }
-  function getAndRemoveAttrByRegex(el, name) {
-      const list = el.attrsList;
-      for (let i = 0, l = list.length; i < l; i++) {
-          const attr = list[i];
-          if (name.test(attr.name)) {
-              list.splice(i, 1);
-              return attr;
-          }
-      }
-  }
-  function rangeSetItem(item, range) {
-      if (range) {
-          if (range.start != null) {
-              item.start = range.start;
-          }
-          if (range.end != null) {
-              item.end = range.end;
-          }
-      }
-      return item;
-  }
-
-  function transformNode$1(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticClass = getAndRemoveAttr(el, 'class');
-      if (staticClass) {
-          const res = parseText(staticClass, options.delimiters);
-          if (res) {
-              warn(`class="${staticClass}": ` +
-                  'Interpolation inside attributes has been removed. ' +
-                  'Use v-bind or the colon shorthand instead. For example, ' +
-                  'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-          }
-      }
-      if (staticClass) {
-          el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-      }
-      const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-      if (classBinding) {
-          el.classBinding = classBinding;
-      }
-  }
-  function genData$2(el) {
-      let data = '';
-      if (el.staticClass) {
-          data += `staticClass:${el.staticClass},`;
-      }
-      if (el.classBinding) {
-          data += `class:${el.classBinding},`;
-      }
-      return data;
-  }
-  var klass = {
-      staticKeys: ['staticClass'],
-      transformNode: transformNode$1,
-      genData: genData$2,
-  };
-
-  function transformNode(el, options) {
-      const warn = options.warn || baseWarn;
-      const staticStyle = getAndRemoveAttr(el, 'style');
-      if (staticStyle) {
-          /* istanbul ignore if */
-          {
-              const res = parseText(staticStyle, options.delimiters);
-              if (res) {
-                  warn(`style="${staticStyle}": ` +
-                      'Interpolation inside attributes has been removed. ' +
-                      'Use v-bind or the colon shorthand instead. For example, ' +
-                      'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-              }
-          }
-          el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-      }
-      const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-      if (styleBinding) {
-          el.styleBinding = styleBinding;
-      }
-  }
-  function genData$1(el) {
-      let data = '';
-      if (el.staticStyle) {
-          data += `staticStyle:${el.staticStyle},`;
-      }
-      if (el.styleBinding) {
-          data += `style:(${el.styleBinding}),`;
-      }
-      return data;
-  }
-  var style = {
-      staticKeys: ['staticStyle'],
-      transformNode,
-      genData: genData$1,
-  };
-
-  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  var he$1 = {exports: {}};
-
-  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-
-  (function (module, exports) {
-  (function(root) {
-
-  		// Detect free variables `exports`.
-  		var freeExports = exports;
-
-  		// Detect free variable `module`.
-  		var freeModule = module &&
-  			module.exports == freeExports && module;
-
-  		// Detect free variable `global`, from Node.js or Browserified code,
-  		// and use it as `root`.
-  		var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-  		if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-  			root = freeGlobal;
-  		}
-
-  		/*--------------------------------------------------------------------------*/
-
-  		// All astral symbols.
-  		var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-  		// All ASCII symbols (not just printable ASCII) except those listed in the
-  		// first column of the overrides table.
-  		// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-  		var regexAsciiWhitelist = /[\x01-\x7F]/g;
-  		// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-  		// code points listed in the first column of the overrides table on
-  		// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-  		var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-  		var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-  		var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-  		var regexEscape = /["&'<>`]/g;
-  		var escapeMap = {
-  			'"': '&quot;',
-  			'&': '&amp;',
-  			'\'': '&#x27;',
-  			'<': '&lt;',
-  			// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-  			// following is not strictly necessary unless it’s part of a tag or an
-  			// unquoted attribute value. We’re only escaping it to support those
-  			// situations, and for XML support.
-  			'>': '&gt;',
-  			// In Internet Explorer ≤ 8, the backtick character can be used
-  			// to break out of (un)quoted attribute values or HTML comments.
-  			// See http://html5sec.org/#102, http://html5sec.org/#108, and
-  			// http://html5sec.org/#133.
-  			'`': '&#x60;'
-  		};
-
-  		var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-  		var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-  		var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-  		var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-  		var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-  		var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-  		var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-  		/*--------------------------------------------------------------------------*/
-
-  		var stringFromCharCode = String.fromCharCode;
-
-  		var object = {};
-  		var hasOwnProperty = object.hasOwnProperty;
-  		var has = function(object, propertyName) {
-  			return hasOwnProperty.call(object, propertyName);
-  		};
-
-  		var contains = function(array, value) {
-  			var index = -1;
-  			var length = array.length;
-  			while (++index < length) {
-  				if (array[index] == value) {
-  					return true;
-  				}
-  			}
-  			return false;
-  		};
-
-  		var merge = function(options, defaults) {
-  			if (!options) {
-  				return defaults;
-  			}
-  			var result = {};
-  			var key;
-  			for (key in defaults) {
-  				// A `hasOwnProperty` check is not needed here, since only recognized
-  				// option names are used anyway. Any others are ignored.
-  				result[key] = has(options, key) ? options[key] : defaults[key];
-  			}
-  			return result;
-  		};
-
-  		// Modified version of `ucs2encode`; see https://mths.be/punycode.
-  		var codePointToSymbol = function(codePoint, strict) {
-  			var output = '';
-  			if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-  				// See issue #4:
-  				// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-  				// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-  				// REPLACEMENT CHARACTER.”
-  				if (strict) {
-  					parseError('character reference outside the permissible Unicode range');
-  				}
-  				return '\uFFFD';
-  			}
-  			if (has(decodeMapNumeric, codePoint)) {
-  				if (strict) {
-  					parseError('disallowed character reference');
-  				}
-  				return decodeMapNumeric[codePoint];
-  			}
-  			if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-  				parseError('disallowed character reference');
-  			}
-  			if (codePoint > 0xFFFF) {
-  				codePoint -= 0x10000;
-  				output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-  				codePoint = 0xDC00 | codePoint & 0x3FF;
-  			}
-  			output += stringFromCharCode(codePoint);
-  			return output;
-  		};
-
-  		var hexEscape = function(codePoint) {
-  			return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-  		};
-
-  		var decEscape = function(codePoint) {
-  			return '&#' + codePoint + ';';
-  		};
-
-  		var parseError = function(message) {
-  			throw Error('Parse error: ' + message);
-  		};
-
-  		/*--------------------------------------------------------------------------*/
-
-  		var encode = function(string, options) {
-  			options = merge(options, encode.options);
-  			var strict = options.strict;
-  			if (strict && regexInvalidRawCodePoint.test(string)) {
-  				parseError('forbidden code point');
-  			}
-  			var encodeEverything = options.encodeEverything;
-  			var useNamedReferences = options.useNamedReferences;
-  			var allowUnsafeSymbols = options.allowUnsafeSymbols;
-  			var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-  			var escapeBmpSymbol = function(symbol) {
-  				return escapeCodePoint(symbol.charCodeAt(0));
-  			};
-
-  			if (encodeEverything) {
-  				// Encode ASCII symbols.
-  				string = string.replace(regexAsciiWhitelist, function(symbol) {
-  					// Use named references if requested & possible.
-  					if (useNamedReferences && has(encodeMap, symbol)) {
-  						return '&' + encodeMap[symbol] + ';';
-  					}
-  					return escapeBmpSymbol(symbol);
-  				});
-  				// Shorten a few escapes that represent two symbols, of which at least one
-  				// is within the ASCII range.
-  				if (useNamedReferences) {
-  					string = string
-  						.replace(/&gt;\u20D2/g, '&nvgt;')
-  						.replace(/&lt;\u20D2/g, '&nvlt;')
-  						.replace(/&#x66;&#x6A;/g, '&fjlig;');
-  				}
-  				// Encode non-ASCII symbols.
-  				if (useNamedReferences) {
-  					// Encode non-ASCII symbols that can be replaced with a named reference.
-  					string = string.replace(regexEncodeNonAscii, function(string) {
-  						// Note: there is no need to check `has(encodeMap, string)` here.
-  						return '&' + encodeMap[string] + ';';
-  					});
-  				}
-  				// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-  			} else if (useNamedReferences) {
-  				// Apply named character references.
-  				// Encode `<>"'&` using named character references.
-  				if (!allowUnsafeSymbols) {
-  					string = string.replace(regexEscape, function(string) {
-  						return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-  					});
-  				}
-  				// Shorten escapes that represent two symbols, of which at least one is
-  				// `<>"'&`.
-  				string = string
-  					.replace(/&gt;\u20D2/g, '&nvgt;')
-  					.replace(/&lt;\u20D2/g, '&nvlt;');
-  				// Encode non-ASCII symbols that can be replaced with a named reference.
-  				string = string.replace(regexEncodeNonAscii, function(string) {
-  					// Note: there is no need to check `has(encodeMap, string)` here.
-  					return '&' + encodeMap[string] + ';';
-  				});
-  			} else if (!allowUnsafeSymbols) {
-  				// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-  				// using named character references.
-  				string = string.replace(regexEscape, escapeBmpSymbol);
-  			}
-  			return string
-  				// Encode astral symbols.
-  				.replace(regexAstralSymbols, function($0) {
-  					// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-  					var high = $0.charCodeAt(0);
-  					var low = $0.charCodeAt(1);
-  					var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-  					return escapeCodePoint(codePoint);
-  				})
-  				// Encode any remaining BMP symbols that are not printable ASCII symbols
-  				// using a hexadecimal escape.
-  				.replace(regexBmpWhitelist, escapeBmpSymbol);
-  		};
-  		// Expose default options (so they can be overridden globally).
-  		encode.options = {
-  			'allowUnsafeSymbols': false,
-  			'encodeEverything': false,
-  			'strict': false,
-  			'useNamedReferences': false,
-  			'decimal' : false
-  		};
-
-  		var decode = function(html, options) {
-  			options = merge(options, decode.options);
-  			var strict = options.strict;
-  			if (strict && regexInvalidEntity.test(html)) {
-  				parseError('malformed character reference');
-  			}
-  			return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-  				var codePoint;
-  				var semicolon;
-  				var decDigits;
-  				var hexDigits;
-  				var reference;
-  				var next;
-
-  				if ($1) {
-  					reference = $1;
-  					// Note: there is no need to check `has(decodeMap, reference)`.
-  					return decodeMap[reference];
-  				}
-
-  				if ($2) {
-  					// Decode named character references without trailing `;`, e.g. `&amp`.
-  					// This is only a parse error if it gets converted to `&`, or if it is
-  					// followed by `=` in an attribute context.
-  					reference = $2;
-  					next = $3;
-  					if (next && options.isAttributeValue) {
-  						if (strict && next == '=') {
-  							parseError('`&` did not start a character reference');
-  						}
-  						return $0;
-  					} else {
-  						if (strict) {
-  							parseError(
-  								'named character reference was not terminated by a semicolon'
-  							);
-  						}
-  						// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-  						return decodeMapLegacy[reference] + (next || '');
-  					}
-  				}
-
-  				if ($4) {
-  					// Decode decimal escapes, e.g. `&#119558;`.
-  					decDigits = $4;
-  					semicolon = $5;
-  					if (strict && !semicolon) {
-  						parseError('character reference was not terminated by a semicolon');
-  					}
-  					codePoint = parseInt(decDigits, 10);
-  					return codePointToSymbol(codePoint, strict);
-  				}
-
-  				if ($6) {
-  					// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-  					hexDigits = $6;
-  					semicolon = $7;
-  					if (strict && !semicolon) {
-  						parseError('character reference was not terminated by a semicolon');
-  					}
-  					codePoint = parseInt(hexDigits, 16);
-  					return codePointToSymbol(codePoint, strict);
-  				}
-
-  				// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-  				// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-  				if (strict) {
-  					parseError(
-  						'named character reference was not terminated by a semicolon'
-  					);
-  				}
-  				return $0;
-  			});
-  		};
-  		// Expose default options (so they can be overridden globally).
-  		decode.options = {
-  			'isAttributeValue': false,
-  			'strict': false
-  		};
-
-  		var escape = function(string) {
-  			return string.replace(regexEscape, function($0) {
-  				// Note: there is no need to check `has(escapeMap, $0)` here.
-  				return escapeMap[$0];
-  			});
-  		};
-
-  		/*--------------------------------------------------------------------------*/
-
-  		var he = {
-  			'version': '1.2.0',
-  			'encode': encode,
-  			'decode': decode,
-  			'escape': escape,
-  			'unescape': decode
-  		};
-
-  		// Some AMD build optimizers, like r.js, check for specific condition patterns
-  		// like the following:
-  		if (freeExports && !freeExports.nodeType) {
-  			if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-  				freeModule.exports = he;
-  			} else { // in Narwhal or RingoJS v0.7.0-
-  				for (var key in he) {
-  					has(he, key) && (freeExports[key] = he[key]);
-  				}
-  			}
-  		} else { // in Rhino or a web browser
-  			root.he = he;
-  		}
-
-  	}(commonjsGlobal));
-  } (he$1, he$1.exports));
-
-  var he = he$1.exports;
-
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-  // Regular Expressions for parsing tags and attributes
-  const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-  const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-  const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-  const startTagOpen = new RegExp(`^<${qnameCapture}`);
-  const startTagClose = /^\s*(\/?)>/;
-  const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-  const doctype = /^<!DOCTYPE [^>]+>/i;
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  const comment = /^<!\--/;
-  const conditionalComment = /^<!\[/;
-  // Special Elements (can contain anything)
-  const isPlainTextElement = makeMap('script,style,textarea', true);
-  const reCache = {};
-  const decodingMap = {
-      '&lt;': '<',
-      '&gt;': '>',
-      '&quot;': '"',
-      '&amp;': '&',
-      '&#10;': '\n',
-      '&#9;': '\t',
-      '&#39;': "'",
-  };
-  const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-  const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-  // #5992
-  const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-  const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-  function decodeAttr(value, shouldDecodeNewlines) {
-      const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-      return value.replace(re, (match) => decodingMap[match]);
-  }
-  function parseHTML(html, options) {
-      const stack = [];
-      const expectHTML = options.expectHTML;
-      const isUnaryTag = options.isUnaryTag || no;
-      const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-      let index = 0;
-      let last, lastTag;
-      while (html) {
-          last = html;
-          // Make sure we're not in a plaintext content element like script/style
-          if (!lastTag || !isPlainTextElement(lastTag)) {
-              let textEnd = html.indexOf('<');
-              if (textEnd === 0) {
-                  // Comment:
-                  if (comment.test(html)) {
-                      const commentEnd = html.indexOf('-->');
-                      if (commentEnd >= 0) {
-                          if (options.shouldKeepComment) {
-                              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                          }
-                          advance(commentEnd + 3);
-                          continue;
-                      }
-                  }
-                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                  if (conditionalComment.test(html)) {
-                      const conditionalEnd = html.indexOf(']>');
-                      if (conditionalEnd >= 0) {
-                          advance(conditionalEnd + 2);
-                          continue;
-                      }
-                  }
-                  // Doctype:
-                  const doctypeMatch = html.match(doctype);
-                  if (doctypeMatch) {
-                      advance(doctypeMatch[0].length);
-                      continue;
-                  }
-                  // End tag:
-                  const endTagMatch = html.match(endTag);
-                  if (endTagMatch) {
-                      const curIndex = index;
-                      advance(endTagMatch[0].length);
-                      parseEndTag(endTagMatch[1], curIndex, index);
-                      continue;
-                  }
-                  // Start tag:
-                  const startTagMatch = parseStartTag();
-                  if (startTagMatch) {
-                      handleStartTag(startTagMatch);
-                      if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                          advance(1);
-                      }
-                      continue;
-                  }
-              }
-              let text, rest, next;
-              if (textEnd >= 0) {
-                  rest = html.slice(textEnd);
-                  while (!endTag.test(rest) &&
-                      !startTagOpen.test(rest) &&
-                      !comment.test(rest) &&
-                      !conditionalComment.test(rest)) {
-                      // < in plain text, be forgiving and treat it as text
-                      next = rest.indexOf('<', 1);
-                      if (next < 0)
-                          break;
-                      textEnd += next;
-                      rest = html.slice(textEnd);
-                  }
-                  text = html.substring(0, textEnd);
-              }
-              if (textEnd < 0) {
-                  text = html;
-              }
-              if (text) {
-                  advance(text.length);
-              }
-              if (options.chars && text) {
-                  options.chars(text, index - text.length, index);
-              }
-          }
-          else {
-              let endTagLength = 0;
-              const stackedTag = lastTag.toLowerCase();
-              const reStackedTag = reCache[stackedTag] ||
-                  (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-              const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                  endTagLength = endTag.length;
-                  if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                      text = text
-                          .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                          .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                  }
-                  if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                      text = text.slice(1);
-                  }
-                  if (options.chars) {
-                      options.chars(text);
-                  }
-                  return '';
-              });
-              index += html.length - rest.length;
-              html = rest;
-              parseEndTag(stackedTag, index - endTagLength, index);
-          }
-          if (html === last) {
-              options.chars && options.chars(html);
-              if (!stack.length &&
-                  options.warn) {
-                  options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                      start: index + html.length,
-                  });
-              }
-              break;
-          }
-      }
-      // Clean up any remaining tags
-      parseEndTag();
-      function advance(n) {
-          index += n;
-          html = html.substring(n);
-      }
-      function parseStartTag() {
-          const start = html.match(startTagOpen);
-          if (start) {
-              const match = {
-                  tagName: start[1],
-                  attrs: [],
-                  start: index,
-              };
-              advance(start[0].length);
-              let end, attr;
-              while (!(end = html.match(startTagClose)) &&
-                  (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                  attr.start = index;
-                  advance(attr[0].length);
-                  attr.end = index;
-                  match.attrs.push(attr);
-              }
-              if (end) {
-                  match.unarySlash = end[1];
-                  advance(end[0].length);
-                  match.end = index;
-                  return match;
-              }
-          }
-      }
-      function handleStartTag(match) {
-          const tagName = match.tagName;
-          const unarySlash = match.unarySlash;
-          if (expectHTML) {
-              if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                  parseEndTag(lastTag);
-              }
-              if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                  parseEndTag(tagName);
-              }
-          }
-          const unary = isUnaryTag(tagName) || !!unarySlash;
-          const l = match.attrs.length;
-          const attrs = new Array(l);
-          for (let i = 0; i < l; i++) {
-              const args = match.attrs[i];
-              const value = args[3] || args[4] || args[5] || '';
-              const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                  ? options.shouldDecodeNewlinesForHref
-                  : options.shouldDecodeNewlines;
-              attrs[i] = {
-                  name: args[1],
-                  value: decodeAttr(value, shouldDecodeNewlines),
-              };
-              if (options.outputSourceRange) {
-                  attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                  attrs[i].end = args.end;
-              }
-          }
-          if (!unary) {
-              stack.push({
-                  tag: tagName,
-                  lowerCasedTag: tagName.toLowerCase(),
-                  attrs: attrs,
-                  start: match.start,
-                  end: match.end,
-              });
-              lastTag = tagName;
-          }
-          if (options.start) {
-              options.start(tagName, attrs, unary, match.start, match.end);
-          }
-      }
-      function parseEndTag(tagName, start, end) {
-          let pos, lowerCasedTagName;
-          if (start == null)
-              start = index;
-          if (end == null)
-              end = index;
-          // Find the closest opened tag of the same type
-          if (tagName) {
-              lowerCasedTagName = tagName.toLowerCase();
-              for (pos = stack.length - 1; pos >= 0; pos--) {
-                  if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                      break;
-                  }
-              }
-          }
-          else {
-              // If no tag name is provided, clean shop
-              pos = 0;
-          }
-          if (pos >= 0) {
-              // Close all the open elements, up the stack
-              for (let i = stack.length - 1; i >= pos; i--) {
-                  if ((i > pos || !tagName) &&
-                      options.warn) {
-                      options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                          start: stack[i].start,
-                          end: stack[i].end,
-                      });
-                  }
-                  if (options.end) {
-                      options.end(stack[i].tag, start, end);
-                  }
-              }
-              // Remove the open elements from the stack
-              stack.length = pos;
-              lastTag = pos && stack[pos - 1].tag;
-          }
-          else if (lowerCasedTagName === 'br') {
-              if (options.start) {
-                  options.start(tagName, [], true, start, end);
-              }
-          }
-          else if (lowerCasedTagName === 'p') {
-              if (options.start) {
-                  options.start(tagName, [], false, start, end);
-              }
-              if (options.end) {
-                  options.end(tagName, start, end);
-              }
-          }
-      }
-  }
-
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel(el, value, modifiers) {
-      const { number, trim } = modifiers || {};
-      const baseValueExpression = '$$v';
-      let valueExpression = baseValueExpression;
-      if (trim) {
-          valueExpression =
-              `(typeof ${baseValueExpression} === 'string'` +
-                  `? ${baseValueExpression}.trim()` +
-                  `: ${baseValueExpression})`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      const assignment = genAssignmentCode(value, valueExpression);
-      el.model = {
-          value: `(${value})`,
-          expression: JSON.stringify(value),
-          callback: `function (${baseValueExpression}) {${assignment}}`,
-      };
-  }
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode(value, assignment) {
-      const res = parseModel(value);
-      if (res.key === null) {
-          return `${value}=${assignment}`;
-      }
-      else {
-          return `$set(${res.exp}, ${res.key}, ${assignment})`;
-      }
-  }
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-  let len, str, chr, index, expressionPos, expressionEndPos;
-  function parseModel(val) {
-      // Fix https://github.com/vuejs/vue/pull/7730
-      // allow v-model="obj.val " (trailing whitespace)
-      val = val.trim();
-      len = val.length;
-      if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-          index = val.lastIndexOf('.');
-          if (index > -1) {
-              return {
-                  exp: val.slice(0, index),
-                  key: '"' + val.slice(index + 1) + '"',
-              };
-          }
-          else {
-              return {
-                  exp: val,
-                  key: null,
-              };
-          }
-      }
-      str = val;
-      index = expressionPos = expressionEndPos = 0;
-      while (!eof()) {
-          chr = next();
-          /* istanbul ignore if */
-          if (isStringStart(chr)) {
-              parseString(chr);
-          }
-          else if (chr === 0x5b) {
-              parseBracket(chr);
-          }
-      }
-      return {
-          exp: val.slice(0, expressionPos),
-          key: val.slice(expressionPos + 1, expressionEndPos),
-      };
-  }
-  function next() {
-      return str.charCodeAt(++index);
-  }
-  function eof() {
-      return index >= len;
-  }
-  function isStringStart(chr) {
-      return chr === 0x22 || chr === 0x27;
-  }
-  function parseBracket(chr) {
-      let inBracket = 1;
-      expressionPos = index;
-      while (!eof()) {
-          chr = next();
-          if (isStringStart(chr)) {
-              parseString(chr);
-              continue;
-          }
-          if (chr === 0x5b)
-              inBracket++;
-          if (chr === 0x5d)
-              inBracket--;
-          if (inBracket === 0) {
-              expressionEndPos = index;
-              break;
-          }
-      }
-  }
-  function parseString(chr) {
-      const stringQuote = chr;
-      while (!eof()) {
-          chr = next();
-          if (chr === stringQuote) {
-              break;
-          }
-      }
-  }
-
-  const onRE = /^@|^v-on:/;
-  const dirRE = /^v-|^@|^:|^#/;
-  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  const stripParensRE = /^\(|\)$/g;
-  const dynamicArgRE = /^\[.*\]$/;
-  const argRE = /:(.*)$/;
-  const bindRE = /^:|^\.|^v-bind:/;
-  const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-  const slotRE = /^v-slot(:|$)|^#/;
-  const lineBreakRE = /[\r\n]/;
-  const whitespaceRE = /[ \f\t\r\n]+/g;
-  const invalidAttributeRE = /[\s"'<>\/=]/;
-  const decodeHTMLCached = cached(he.decode);
-  const emptySlotScopeToken = `_empty_`;
-  // configurable state
-  let warn$1;
-  let delimiters;
-  let transforms;
-  let preTransforms;
-  let postTransforms;
-  let platformIsPreTag;
-  let platformMustUseProp;
-  let platformGetTagNamespace;
-  let maybeComponent;
-  function createASTElement(tag, attrs, parent) {
-      return {
-          type: 1,
-          tag,
-          attrsList: attrs,
-          attrsMap: makeAttrsMap(attrs),
-          rawAttrsMap: {},
-          parent,
-          children: [],
-      };
-  }
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse(template, options) {
-      warn$1 = options.warn || baseWarn;
-      platformIsPreTag = options.isPreTag || no;
-      platformMustUseProp = options.mustUseProp || no;
-      platformGetTagNamespace = options.getTagNamespace || no;
-      const isReservedTag = options.isReservedTag || no;
-      maybeComponent = (el) => !!(el.component ||
-          el.attrsMap[':is'] ||
-          el.attrsMap['v-bind:is'] ||
-          !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-      transforms = pluckModuleFunction(options.modules, 'transformNode');
-      preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-      postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-      delimiters = options.delimiters;
-      const stack = [];
-      const preserveWhitespace = options.preserveWhitespace !== false;
-      const whitespaceOption = options.whitespace;
-      let root;
-      let currentParent;
-      let inVPre = false;
-      let inPre = false;
-      let warned = false;
-      function warnOnce(msg, range) {
-          if (!warned) {
-              warned = true;
-              warn$1(msg, range);
-          }
-      }
-      function closeElement(element) {
-          trimEndingWhitespace(element);
-          if (!inVPre && !element.processed) {
-              element = processElement(element, options);
-          }
-          // tree management
-          if (!stack.length && element !== root) {
-              // allow root elements with v-if, v-else-if and v-else
-              if (root.if && (element.elseif || element.else)) {
-                  {
-                      checkRootConstraints(element);
-                  }
-                  addIfCondition(root, {
-                      exp: element.elseif,
-                      block: element,
-                  });
-              }
-              else {
-                  warnOnce(`Component template should contain exactly one root element. ` +
-                      `If you are using v-if on multiple elements, ` +
-                      `use v-else-if to chain them instead.`, { start: element.start });
-              }
-          }
-          if (currentParent && !element.forbidden) {
-              if (element.elseif || element.else) {
-                  processIfConditions(element, currentParent);
-              }
-              else {
-                  if (element.slotScope) {
-                      // scoped slot
-                      // keep it in the children list so that v-else(-if) conditions can
-                      // find it as the prev node.
-                      const name = element.slotTarget || '"default"';
-                      (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                  }
-                  currentParent.children.push(element);
-                  element.parent = currentParent;
-              }
-          }
-          // final children cleanup
-          // filter out scoped slots
-          element.children = element.children.filter((c) => !c.slotScope);
-          // remove trailing whitespace node again
-          trimEndingWhitespace(element);
-          // check pre state
-          if (element.pre) {
-              inVPre = false;
-          }
-          if (platformIsPreTag(element.tag)) {
-              inPre = false;
-          }
-          // apply post-transforms
-          for (let i = 0; i < postTransforms.length; i++) {
-              postTransforms[i](element, options);
-          }
-      }
-      function trimEndingWhitespace(el) {
-          // remove trailing whitespace node
-          if (!inPre) {
-              let lastNode;
-              while ((lastNode = el.children[el.children.length - 1]) &&
-                  lastNode.type === 3 &&
-                  lastNode.text === ' ') {
-                  el.children.pop();
-              }
-          }
-      }
-      function checkRootConstraints(el) {
-          if (el.tag === 'slot' || el.tag === 'template') {
-              warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                  'contain multiple nodes.', { start: el.start });
-          }
-          if (el.attrsMap.hasOwnProperty('v-for')) {
-              warnOnce('Cannot use v-for on stateful component root element because ' +
-                  'it renders multiple elements.', el.rawAttrsMap['v-for']);
-          }
-      }
-      parseHTML(template, {
-          warn: warn$1,
-          expectHTML: options.expectHTML,
-          isUnaryTag: options.isUnaryTag,
-          canBeLeftOpenTag: options.canBeLeftOpenTag,
-          shouldDecodeNewlines: options.shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-          shouldKeepComment: options.comments,
-          outputSourceRange: options.outputSourceRange,
-          start(tag, attrs, unary, start, end) {
-              // check namespace.
-              // inherit parent ns if there is one
-              const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-              // handle IE svg bug
-              /* istanbul ignore if */
-              if (isIE && ns === 'svg') {
-                  attrs = guardIESVGBug(attrs);
-              }
-              let element = createASTElement(tag, attrs, currentParent);
-              if (ns) {
-                  element.ns = ns;
-              }
-              {
-                  if (options.outputSourceRange) {
-                      element.start = start;
-                      element.end = end;
-                      element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                          cumulated[attr.name] = attr;
-                          return cumulated;
-                      }, {});
-                  }
-                  attrs.forEach((attr) => {
-                      if (invalidAttributeRE.test(attr.name)) {
-                          warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                              `spaces, quotes, <, >, / or =.`, {
-                              start: attr.start + attr.name.indexOf(`[`),
-                              end: attr.start + attr.name.length,
-                          });
-                      }
-                  });
-              }
-              if (isForbiddenTag(element) && !isServerRendering()) {
-                  element.forbidden = true;
-                  warn$1('Templates should only be responsible for mapping the state to the ' +
-                          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                          `<${tag}>` +
-                          ', as they will not be parsed.', { start: element.start });
-              }
-              // apply pre-transforms
-              for (let i = 0; i < preTransforms.length; i++) {
-                  element = preTransforms[i](element, options) || element;
-              }
-              if (!inVPre) {
-                  processPre(element);
-                  if (element.pre) {
-                      inVPre = true;
-                  }
-              }
-              if (platformIsPreTag(element.tag)) {
-                  inPre = true;
-              }
-              if (inVPre) {
-                  processRawAttrs(element);
-              }
-              else if (!element.processed) {
-                  // structural directives
-                  processFor(element);
-                  processIf(element);
-                  processOnce(element);
-              }
-              if (!root) {
-                  root = element;
-                  {
-                      checkRootConstraints(root);
-                  }
-              }
-              if (!unary) {
-                  currentParent = element;
-                  stack.push(element);
-              }
-              else {
-                  closeElement(element);
-              }
-          },
-          end(tag, start, end) {
-              const element = stack[stack.length - 1];
-              // pop stack
-              stack.length -= 1;
-              currentParent = stack[stack.length - 1];
-              if (options.outputSourceRange) {
-                  element.end = end;
-              }
-              closeElement(element);
-          },
-          chars(text, start, end) {
-              if (!currentParent) {
-                  {
-                      if (text === template) {
-                          warnOnce('Component template requires a root element, rather than just text.', { start });
-                      }
-                      else if ((text = text.trim())) {
-                          warnOnce(`text "${text}" outside root element will be ignored.`, {
-                              start,
-                          });
-                      }
-                  }
-                  return;
-              }
-              // IE textarea placeholder bug
-              /* istanbul ignore if */
-              if (isIE &&
-                  currentParent.tag === 'textarea' &&
-                  currentParent.attrsMap.placeholder === text) {
-                  return;
-              }
-              const children = currentParent.children;
-              if (inPre || text.trim()) {
-                  text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-              }
-              else if (!children.length) {
-                  // remove the whitespace-only node right after an opening tag
-                  text = '';
-              }
-              else if (whitespaceOption) {
-                  if (whitespaceOption === 'condense') {
-                      // in condense mode, remove the whitespace node if it contains
-                      // line break, otherwise condense to a single space
-                      text = lineBreakRE.test(text) ? '' : ' ';
-                  }
-                  else {
-                      text = ' ';
-                  }
-              }
-              else {
-                  text = preserveWhitespace ? ' ' : '';
-              }
-              if (text) {
-                  if (!inPre && whitespaceOption === 'condense') {
-                      // condense consecutive whitespaces into single space
-                      text = text.replace(whitespaceRE, ' ');
-                  }
-                  let res;
-                  let child;
-                  if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                      child = {
-                          type: 2,
-                          expression: res.expression,
-                          tokens: res.tokens,
-                          text,
-                      };
-                  }
-                  else if (text !== ' ' ||
-                      !children.length ||
-                      children[children.length - 1].text !== ' ') {
-                      child = {
-                          type: 3,
-                          text,
-                      };
-                  }
-                  if (child) {
-                      if (options.outputSourceRange) {
-                          child.start = start;
-                          child.end = end;
-                      }
-                      children.push(child);
-                  }
-              }
-          },
-          comment(text, start, end) {
-              // adding anything as a sibling to the root node is forbidden
-              // comments should still be allowed, but ignored
-              if (currentParent) {
-                  const child = {
-                      type: 3,
-                      text,
-                      isComment: true,
-                  };
-                  if (options.outputSourceRange) {
-                      child.start = start;
-                      child.end = end;
-                  }
-                  currentParent.children.push(child);
-              }
-          },
-      });
-      return root;
-  }
-  function processPre(el) {
-      if (getAndRemoveAttr(el, 'v-pre') != null) {
-          el.pre = true;
-      }
-  }
-  function processRawAttrs(el) {
-      const list = el.attrsList;
-      const len = list.length;
-      if (len) {
-          const attrs = (el.attrs = new Array(len));
-          for (let i = 0; i < len; i++) {
-              attrs[i] = {
-                  name: list[i].name,
-                  value: JSON.stringify(list[i].value),
-              };
-              if (list[i].start != null) {
-                  attrs[i].start = list[i].start;
-                  attrs[i].end = list[i].end;
-              }
-          }
-      }
-      else if (!el.pre) {
-          // non root node in pre blocks with no attributes
-          el.plain = true;
-      }
-  }
-  function processElement(element, options) {
-      processKey(element);
-      // determine whether this is a plain element after
-      // removing structural attributes
-      element.plain =
-          !element.key && !element.scopedSlots && !element.attrsList.length;
-      processRef(element);
-      processSlotContent(element);
-      processSlotOutlet(element);
-      processComponent(element);
-      for (let i = 0; i < transforms.length; i++) {
-          element = transforms[i](element, options) || element;
-      }
-      processAttrs(element);
-      return element;
-  }
-  function processKey(el) {
-      const exp = getBindingAttr(el, 'key');
-      if (exp) {
-          {
-              if (el.tag === 'template') {
-                  warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-              }
-              if (el.for) {
-                  const iterator = el.iterator2 || el.iterator1;
-                  const parent = el.parent;
-                  if (iterator &&
-                      iterator === exp &&
-                      parent &&
-                      parent.tag === 'transition-group') {
-                      warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                          `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                  }
-              }
-          }
-          el.key = exp;
-      }
-  }
-  function processRef(el) {
-      const ref = getBindingAttr(el, 'ref');
-      if (ref) {
-          el.ref = ref;
-          el.refInFor = checkInFor(el);
-      }
-  }
-  function processFor(el) {
-      let exp;
-      if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-          const res = parseFor(exp);
-          if (res) {
-              extend(el, res);
-          }
-          else {
-              warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-          }
-      }
-  }
-  function parseFor(exp) {
-      const inMatch = exp.match(forAliasRE);
-      if (!inMatch)
-          return;
-      const res = {};
-      res.for = inMatch[2].trim();
-      const alias = inMatch[1].trim().replace(stripParensRE, '');
-      const iteratorMatch = alias.match(forIteratorRE);
-      if (iteratorMatch) {
-          res.alias = alias.replace(forIteratorRE, '').trim();
-          res.iterator1 = iteratorMatch[1].trim();
-          if (iteratorMatch[2]) {
-              res.iterator2 = iteratorMatch[2].trim();
-          }
-      }
-      else {
-          res.alias = alias;
-      }
-      return res;
-  }
-  function processIf(el) {
-      const exp = getAndRemoveAttr(el, 'v-if');
-      if (exp) {
-          el.if = exp;
-          addIfCondition(el, {
-              exp: exp,
-              block: el,
-          });
-      }
-      else {
-          if (getAndRemoveAttr(el, 'v-else') != null) {
-              el.else = true;
-          }
-          const elseif = getAndRemoveAttr(el, 'v-else-if');
-          if (elseif) {
-              el.elseif = elseif;
-          }
-      }
-  }
-  function processIfConditions(el, parent) {
-      const prev = findPrevElement(parent.children);
-      if (prev && prev.if) {
-          addIfCondition(prev, {
-              exp: el.elseif,
-              block: el,
-          });
-      }
-      else {
-          warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-              `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-      }
-  }
-  function findPrevElement(children) {
-      let i = children.length;
-      while (i--) {
-          if (children[i].type === 1) {
-              return children[i];
-          }
-          else {
-              if (children[i].text !== ' ') {
-                  warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                      `will be ignored.`, children[i]);
-              }
-              children.pop();
-          }
-      }
-  }
-  function addIfCondition(el, condition) {
-      if (!el.ifConditions) {
-          el.ifConditions = [];
-      }
-      el.ifConditions.push(condition);
-  }
-  function processOnce(el) {
-      const once = getAndRemoveAttr(el, 'v-once');
-      if (once != null) {
-          el.once = true;
-      }
-  }
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent(el) {
-      let slotScope;
-      if (el.tag === 'template') {
-          slotScope = getAndRemoveAttr(el, 'scope');
-          /* istanbul ignore if */
-          if (slotScope) {
-              warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                  `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                  `can also be used on plain elements in addition to <template> to ` +
-                  `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-          }
-          el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-      }
-      else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-          /* istanbul ignore if */
-          if (el.attrsMap['v-for']) {
-              warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                  `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                  `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-          }
-          el.slotScope = slotScope;
-      }
-      // slot="xxx"
-      const slotTarget = getBindingAttr(el, 'slot');
-      if (slotTarget) {
-          el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-          el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-          // preserve slot as an attribute for native shadow DOM compat
-          // only for non-scoped slots.
-          if (el.tag !== 'template' && !el.slotScope) {
-              addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-          }
-      }
-      // 2.6 v-slot syntax
-      {
-          if (el.tag === 'template') {
-              // v-slot on <template>
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (el.slotTarget || el.slotScope) {
-                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.parent && !maybeComponent(el.parent)) {
-                          warn$1(`<template v-slot> can only appear at the root level inside ` +
-                              `the receiving component`, el);
-                      }
-                  }
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  el.slotTarget = name;
-                  el.slotTargetDynamic = dynamic;
-                  el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-              }
-          }
-          else {
-              // v-slot on component, denotes default slot
-              const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-              if (slotBinding) {
-                  {
-                      if (!maybeComponent(el)) {
-                          warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                      }
-                      if (el.slotScope || el.slotTarget) {
-                          warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                      }
-                      if (el.scopedSlots) {
-                          warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                              `<template> syntax when there are other named slots.`, slotBinding);
-                      }
-                  }
-                  // add the component's children to its default slot
-                  const slots = el.scopedSlots || (el.scopedSlots = {});
-                  const { name, dynamic } = getSlotName(slotBinding);
-                  const slotContainer = (slots[name] = createASTElement('template', [], el));
-                  slotContainer.slotTarget = name;
-                  slotContainer.slotTargetDynamic = dynamic;
-                  slotContainer.children = el.children.filter((c) => {
-                      if (!c.slotScope) {
-                          c.parent = slotContainer;
-                          return true;
-                      }
-                  });
-                  slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                  // remove children as they are returned from scopedSlots now
-                  el.children = [];
-                  // mark el non-plain so data gets generated
-                  el.plain = false;
-              }
-          }
-      }
-  }
-  function getSlotName(binding) {
-      let name = binding.name.replace(slotRE, '');
-      if (!name) {
-          if (binding.name[0] !== '#') {
-              name = 'default';
-          }
-          else {
-              warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-          }
-      }
-      return dynamicArgRE.test(name)
-          ? // dynamic [name]
-              { name: name.slice(1, -1), dynamic: true }
-          : // static name
-              { name: `"${name}"`, dynamic: false };
-  }
-  // handle <slot/> outlets
-  function processSlotOutlet(el) {
-      if (el.tag === 'slot') {
-          el.slotName = getBindingAttr(el, 'name');
-          if (el.key) {
-              warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                  `and can possibly expand into multiple elements. ` +
-                  `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-          }
-      }
-  }
-  function processComponent(el) {
-      let binding;
-      if ((binding = getBindingAttr(el, 'is'))) {
-          el.component = binding;
-      }
-      if (getAndRemoveAttr(el, 'inline-template') != null) {
-          el.inlineTemplate = true;
-      }
-  }
-  function processAttrs(el) {
-      const list = el.attrsList;
-      let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-      for (i = 0, l = list.length; i < l; i++) {
-          name = rawName = list[i].name;
-          value = list[i].value;
-          if (dirRE.test(name)) {
-              // mark element as dynamic
-              el.hasBindings = true;
-              // modifiers
-              modifiers = parseModifiers(name.replace(dirRE, ''));
-              // support .foo shorthand syntax for the .prop modifier
-              if (modifiers) {
-                  name = name.replace(modifierRE, '');
-              }
-              if (bindRE.test(name)) {
-                  // v-bind
-                  name = name.replace(bindRE, '');
-                  value = parseFilters(value);
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  if (value.trim().length === 0) {
-                      warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                  }
-                  if (modifiers) {
-                      if (modifiers.prop && !isDynamic) {
-                          name = camelize(name);
-                          if (name === 'innerHtml')
-                              name = 'innerHTML';
-                      }
-                      if (modifiers.camel && !isDynamic) {
-                          name = camelize(name);
-                      }
-                      if (modifiers.sync) {
-                          syncGen = genAssignmentCode(value, `$event`);
-                          if (!isDynamic) {
-                              addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                              if (hyphenate(name) !== camelize(name)) {
-                                  addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                              }
-                          }
-                          else {
-                              // handler w/ dynamic event name
-                              addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                              );
-                          }
-                      }
-                  }
-                  if ((modifiers && modifiers.prop) ||
-                      (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                      addProp(el, name, value, list[i], isDynamic);
-                  }
-                  else {
-                      addAttr(el, name, value, list[i], isDynamic);
-                  }
-              }
-              else if (onRE.test(name)) {
-                  // v-on
-                  name = name.replace(onRE, '');
-                  isDynamic = dynamicArgRE.test(name);
-                  if (isDynamic) {
-                      name = name.slice(1, -1);
-                  }
-                  addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-              }
-              else {
-                  // normal directives
-                  name = name.replace(dirRE, '');
-                  // parse arg
-                  const argMatch = name.match(argRE);
-                  let arg = argMatch && argMatch[1];
-                  isDynamic = false;
-                  if (arg) {
-                      name = name.slice(0, -(arg.length + 1));
-                      if (dynamicArgRE.test(arg)) {
-                          arg = arg.slice(1, -1);
-                          isDynamic = true;
-                      }
-                  }
-                  addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                  if (name === 'model') {
-                      checkForAliasModel(el, value);
-                  }
-              }
-          }
-          else {
-              // literal attribute
-              {
-                  const res = parseText(value, delimiters);
-                  if (res) {
-                      warn$1(`${name}="${value}": ` +
-                          'Interpolation inside attributes has been removed. ' +
-                          'Use v-bind or the colon shorthand instead. For example, ' +
-                          'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                  }
-              }
-              addAttr(el, name, JSON.stringify(value), list[i]);
-              // #6887 firefox doesn't update muted state if set via attribute
-              // even immediately after element creation
-              if (!el.component &&
-                  name === 'muted' &&
-                  platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                  addProp(el, name, 'true', list[i]);
-              }
-          }
-      }
-  }
-  function checkInFor(el) {
-      let parent = el;
-      while (parent) {
-          if (parent.for !== undefined) {
-              return true;
-          }
-          parent = parent.parent;
-      }
-      return false;
-  }
-  function parseModifiers(name) {
-      const match = name.match(modifierRE);
-      if (match) {
-          const ret = {};
-          match.forEach((m) => {
-              ret[m.slice(1)] = true;
-          });
-          return ret;
-      }
-  }
-  function makeAttrsMap(attrs) {
-      const map = {};
-      for (let i = 0, l = attrs.length; i < l; i++) {
-          if (map[attrs[i].name] &&
-              !isIE &&
-              !isEdge) {
-              warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-          }
-          map[attrs[i].name] = attrs[i].value;
-      }
-      return map;
-  }
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag(el) {
-      return el.tag === 'script' || el.tag === 'style';
-  }
-  function isForbiddenTag(el) {
-      return (el.tag === 'style' ||
-          (el.tag === 'script' &&
-              (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-  }
-  const ieNSBug = /^xmlns:NS\d+/;
-  const ieNSPrefix = /^NS\d+:/;
-  /* istanbul ignore next */
-  function guardIESVGBug(attrs) {
-      const res = [];
-      for (let i = 0; i < attrs.length; i++) {
-          const attr = attrs[i];
-          if (!ieNSBug.test(attr.name)) {
-              attr.name = attr.name.replace(ieNSPrefix, '');
-              res.push(attr);
-          }
-      }
-      return res;
-  }
-  function checkForAliasModel(el, value) {
-      let _el = el;
-      while (_el) {
-          if (_el.for && _el.alias === value) {
-              warn$1(`<${el.tag} v-model="${value}">: ` +
-                  `You are binding v-model directly to a v-for iteration alias. ` +
-                  `This will not be able to modify the v-for source array because ` +
-                  `writing to the alias is like modifying a function local variable. ` +
-                  `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-          }
-          _el = _el.parent;
-      }
-  }
-
-  /**
-   * Expand input[v-model] with dynamic type bindings into v-if-else chains
-   * Turn this:
-   *   <input v-model="data[type]" :type="type">
-   * into this:
-   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-   *   <input v-else :type="type" v-model="data[type]">
-   */
-  function preTransformNode(el, options) {
-      if (el.tag === 'input') {
-          const map = el.attrsMap;
-          if (!map['v-model']) {
-              return;
-          }
-          let typeBinding;
-          if (map[':type'] || map['v-bind:type']) {
-              typeBinding = getBindingAttr(el, 'type');
-          }
-          if (!map.type && !typeBinding && map['v-bind']) {
-              typeBinding = `(${map['v-bind']}).type`;
-          }
-          if (typeBinding) {
-              const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-              const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-              const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-              const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-              // 1. checkbox
-              const branch0 = cloneASTElement(el);
-              // process for on the main node
-              processFor(branch0);
-              addRawAttr(branch0, 'type', 'checkbox');
-              processElement(branch0, options);
-              branch0.processed = true; // prevent it from double-processed
-              branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-              addIfCondition(branch0, {
-                  exp: branch0.if,
-                  block: branch0,
-              });
-              // 2. add radio else-if condition
-              const branch1 = cloneASTElement(el);
-              getAndRemoveAttr(branch1, 'v-for', true);
-              addRawAttr(branch1, 'type', 'radio');
-              processElement(branch1, options);
-              addIfCondition(branch0, {
-                  exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                  block: branch1,
-              });
-              // 3. other
-              const branch2 = cloneASTElement(el);
-              getAndRemoveAttr(branch2, 'v-for', true);
-              addRawAttr(branch2, ':type', typeBinding);
-              processElement(branch2, options);
-              addIfCondition(branch0, {
-                  exp: ifCondition,
-                  block: branch2,
-              });
-              if (hasElse) {
-                  branch0.else = true;
-              }
-              else if (elseIfCondition) {
-                  branch0.elseif = elseIfCondition;
-              }
-              return branch0;
-          }
-      }
-  }
-  function cloneASTElement(el) {
-      return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-  }
-  var model$1 = {
-      preTransformNode,
-  };
-
-  var modules = [klass, style, model$1];
-
-  let warn;
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  const RANGE_TOKEN = '__r';
-  function model(el, dir, _warn) {
-      warn = _warn;
-      const value = dir.value;
-      const modifiers = dir.modifiers;
-      const tag = el.tag;
-      const type = el.attrsMap.type;
-      {
-          // inputs with type="file" are read only and setting the input's
-          // value will throw an error.
-          if (tag === 'input' && type === 'file') {
-              warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                  `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-          }
-      }
-      if (el.component) {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      else if (tag === 'select') {
-          genSelect(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'checkbox') {
-          genCheckboxModel(el, value, modifiers);
-      }
-      else if (tag === 'input' && type === 'radio') {
-          genRadioModel(el, value, modifiers);
-      }
-      else if (tag === 'input' || tag === 'textarea') {
-          genDefaultModel(el, value, modifiers);
-      }
-      else {
-          genComponentModel(el, value, modifiers);
-          // component v-model doesn't need extra runtime
-          return false;
-      }
-      // ensure runtime directive metadata
-      return true;
-  }
-  function genCheckboxModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const valueBinding = getBindingAttr(el, 'value') || 'null';
-      const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-      const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-      addProp(el, 'checked', `Array.isArray(${value})` +
-          `?_i(${value},${valueBinding})>-1` +
-          (trueValueBinding === 'true'
-              ? `:(${value})`
-              : `:_q(${value},${trueValueBinding})`));
-      addHandler(el, 'change', `var $$a=${value},` +
-          '$$el=$event.target,' +
-          `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-          'if(Array.isArray($$a)){' +
-          `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-          '$$i=_i($$a,$$v);' +
-          `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-          `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-          `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-  }
-  function genRadioModel(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      let valueBinding = getBindingAttr(el, 'value') || 'null';
-      valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-      addProp(el, 'checked', `_q(${value},${valueBinding})`);
-      addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-  }
-  function genSelect(el, value, modifiers) {
-      const number = modifiers && modifiers.number;
-      const selectedVal = `Array.prototype.filter` +
-          `.call($event.target.options,function(o){return o.selected})` +
-          `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-          `return ${number ? '_n(val)' : 'val'}})`;
-      const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-      let code = `var $$selectedVal = ${selectedVal};`;
-      code = `${code} ${genAssignmentCode(value, assignment)}`;
-      addHandler(el, 'change', code, null, true);
-  }
-  function genDefaultModel(el, value, modifiers) {
-      const type = el.attrsMap.type;
-      // warn if v-bind:value conflicts with v-model
-      // except for inputs with v-bind:type
-      {
-          const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-          const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-          if (value && !typeBinding) {
-              const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-              warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                  'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-          }
-      }
-      const { lazy, number, trim } = modifiers || {};
-      const needCompositionGuard = !lazy && type !== 'range';
-      const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-      let valueExpression = '$event.target.value';
-      if (trim) {
-          valueExpression = `$event.target.value.trim()`;
-      }
-      if (number) {
-          valueExpression = `_n(${valueExpression})`;
-      }
-      let code = genAssignmentCode(value, valueExpression);
-      if (needCompositionGuard) {
-          code = `if($event.target.composing)return;${code}`;
-      }
-      addProp(el, 'value', `(${value})`);
-      addHandler(el, event, code, null, true);
-      if (trim || number) {
-          addHandler(el, 'blur', '$forceUpdate()');
-      }
-  }
-
-  function text(el, dir) {
-      if (dir.value) {
-          addProp(el, 'textContent', `_s(${dir.value})`, dir);
-      }
-  }
-
-  function html(el, dir) {
-      if (dir.value) {
-          addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-      }
-  }
-
-  var directives = {
-      model,
-      text,
-      html,
-  };
-
-  const baseOptions = {
-      expectHTML: true,
-      modules,
-      directives,
-      isPreTag,
-      isUnaryTag,
-      mustUseProp,
-      canBeLeftOpenTag,
-      isReservedTag,
-      getTagNamespace,
-      staticKeys: genStaticKeys(modules),
-  };
-
-  const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-  const fnInvokeRE = /\([^)]*?\);*$/;
-  const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-  // KeyboardEvent.keyCode aliases
-  const keyCodes = {
-      esc: 27,
-      tab: 9,
-      enter: 13,
-      space: 32,
-      up: 38,
-      left: 37,
-      right: 39,
-      down: 40,
-      delete: [8, 46],
-  };
-  // KeyboardEvent.key aliases
-  const keyNames = {
-      // #7880: IE11 and Edge use `Esc` for Escape key name.
-      esc: ['Esc', 'Escape'],
-      tab: 'Tab',
-      enter: 'Enter',
-      // #9112: IE11 uses `Spacebar` for Space key name.
-      space: [' ', 'Spacebar'],
-      // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-      up: ['Up', 'ArrowUp'],
-      left: ['Left', 'ArrowLeft'],
-      right: ['Right', 'ArrowRight'],
-      down: ['Down', 'ArrowDown'],
-      // #9112: IE11 uses `Del` for Delete key name.
-      delete: ['Backspace', 'Delete', 'Del'],
-  };
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  const genGuard = (condition) => `if(${condition})return null;`;
-  const modifierCode = {
-      stop: '$event.stopPropagation();',
-      prevent: '$event.preventDefault();',
-      self: genGuard(`$event.target !== $event.currentTarget`),
-      ctrl: genGuard(`!$event.ctrlKey`),
-      shift: genGuard(`!$event.shiftKey`),
-      alt: genGuard(`!$event.altKey`),
-      meta: genGuard(`!$event.metaKey`),
-      left: genGuard(`'button' in $event && $event.button !== 0`),
-      middle: genGuard(`'button' in $event && $event.button !== 1`),
-      right: genGuard(`'button' in $event && $event.button !== 2`),
-  };
-  function genHandlers(events, isNative) {
-      const prefix = isNative ? 'nativeOn:' : 'on:';
-      let staticHandlers = ``;
-      let dynamicHandlers = ``;
-      for (const name in events) {
-          const handlerCode = genHandler(events[name]);
-          //@ts-expect-error
-          if (events[name] && events[name].dynamic) {
-              dynamicHandlers += `${name},${handlerCode},`;
-          }
-          else {
-              staticHandlers += `"${name}":${handlerCode},`;
-          }
-      }
-      staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-      if (dynamicHandlers) {
-          return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-      }
-      else {
-          return prefix + staticHandlers;
-      }
-  }
-  function genHandler(handler) {
-      if (!handler) {
-          return 'function(){}';
-      }
-      if (Array.isArray(handler)) {
-          return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-      }
-      const isMethodPath = simplePathRE.test(handler.value);
-      const isFunctionExpression = fnExpRE.test(handler.value);
-      const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-      if (!handler.modifiers) {
-          if (isMethodPath || isFunctionExpression) {
-              return handler.value;
-          }
-          return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-      }
-      else {
-          let code = '';
-          let genModifierCode = '';
-          const keys = [];
-          for (const key in handler.modifiers) {
-              if (modifierCode[key]) {
-                  genModifierCode += modifierCode[key];
-                  // left/right
-                  if (keyCodes[key]) {
-                      keys.push(key);
-                  }
-              }
-              else if (key === 'exact') {
-                  const modifiers = handler.modifiers;
-                  genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                      .filter((keyModifier) => !modifiers[keyModifier])
-                      .map((keyModifier) => `$event.${keyModifier}Key`)
-                      .join('||'));
-              }
-              else {
-                  keys.push(key);
-              }
-          }
-          if (keys.length) {
-              code += genKeyFilter(keys);
-          }
-          // Make sure modifiers like prevent and stop get executed after key filtering
-          if (genModifierCode) {
-              code += genModifierCode;
-          }
-          const handlerCode = isMethodPath
-              ? `return ${handler.value}.apply(null, arguments)`
-              : isFunctionExpression
-                  ? `return (${handler.value}).apply(null, arguments)`
-                  : isFunctionInvocation
-                      ? `return ${handler.value}`
-                      : handler.value;
-          return `function($event){${code}${handlerCode}}`;
-      }
-  }
-  function genKeyFilter(keys) {
-      return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      `if(!$event.type.indexOf('key')&&` +
-          `${keys.map(genFilterCode).join('&&')})return null;`);
-  }
-  function genFilterCode(key) {
-      const keyVal = parseInt(key, 10);
-      if (keyVal) {
-          return `$event.keyCode!==${keyVal}`;
-      }
-      const keyCode = keyCodes[key];
-      const keyName = keyNames[key];
-      return (`_k($event.keyCode,` +
-          `${JSON.stringify(key)},` +
-          `${JSON.stringify(keyCode)},` +
-          `$event.key,` +
-          `${JSON.stringify(keyName)}` +
-          `)`);
-  }
-
-  function on(el, dir) {
-      if (dir.modifiers) {
-          warn$2(`v-on without argument does not support modifiers.`);
-      }
-      el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-  }
-
-  function bind(el, dir) {
-      el.wrapData = (code) => {
-          return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-      };
-  }
-
-  var baseDirectives = {
-      on,
-      bind,
-      cloak: noop$1,
-  };
-
-  class CodegenState {
-      options;
-      warn;
-      transforms;
-      dataGenFns;
-      directives;
-      maybeComponent;
-      onceId;
-      staticRenderFns;
-      pre;
-      constructor(options) {
-          this.options = options;
-          this.warn = options.warn || baseWarn;
-          //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-          this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-          this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-          this.directives = extend(extend({}, baseDirectives), options.directives);
-          const isReservedTag = options.isReservedTag || no;
-          this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-          this.onceId = 0;
-          this.staticRenderFns = [];
-          this.pre = false;
-      }
-  }
-  function generate$1(ast, options) {
-      const state = new CodegenState(options);
-      // fix #11483, Root level <script> tags should not be rendered.
-      const code = ast
-          ? ast.tag === 'script'
-              ? 'null'
-              : genElement(ast, state)
-          : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genElement(el, state) {
-      if (el.parent) {
-          el.pre = el.pre || el.parent.pre;
-      }
-      if (el.staticRoot && !el.staticProcessed) {
-          return genStatic(el, state);
-      }
-      else if (el.once && !el.onceProcessed) {
-          return genOnce(el, state);
-      }
-      else if (el.for && !el.forProcessed) {
-          return genFor(el, state);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-          return genChildren(el, state) || 'void 0';
-      }
-      else if (el.tag === 'slot') {
-          return genSlot(el, state);
-      }
-      else {
-          // component or element
-          let code;
-          if (el.component) {
-              code = genComponent(el.component, el, state);
-          }
-          else {
-              let data;
-              if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                  data = genData(el, state);
-              }
-              const children = el.inlineTemplate ? null : genChildren(el, state, true);
-              code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-          }
-          // module transforms
-          for (let i = 0; i < state.transforms.length; i++) {
-              code = state.transforms[i](el, code);
-          }
-          return code;
-      }
-  }
-  // hoist static sub-trees out
-  function genStatic(el, state) {
-      el.staticProcessed = true;
-      // Some elements (templates) need to behave differently inside of a v-pre
-      // node.  All pre nodes are static roots, so we can use this as a location to
-      // wrap a state change and reset it upon exiting the pre node.
-      const originalPreState = state.pre;
-      if (el.pre) {
-          state.pre = el.pre;
-      }
-      state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-      state.pre = originalPreState;
-      return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-  }
-  // v-once
-  function genOnce(el, state) {
-      el.onceProcessed = true;
-      if (el.if && !el.ifProcessed) {
-          return genIf(el, state);
-      }
-      else if (el.staticInFor) {
-          let key = '';
-          let parent = el.parent;
-          while (parent) {
-              if (parent.for) {
-                  key = parent.key;
-                  break;
-              }
-              parent = parent.parent;
-          }
-          if (!key) {
-              state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-              return genElement(el, state);
-          }
-          return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-      }
-      else {
-          return genStatic(el, state);
-      }
-  }
-  function genIf(el, state, altGen, altEmpty) {
-      el.ifProcessed = true; // avoid recursion
-      return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-  }
-  function genIfConditions(conditions, state, altGen, altEmpty) {
-      if (!conditions.length) {
-          return altEmpty || '_e()';
-      }
-      const condition = conditions.shift();
-      if (condition.exp) {
-          return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-      }
-      else {
-          return `${genTernaryExp(condition.block)}`;
-      }
-      // v-if with v-once should generate code like (a)?_m(0):_m(1)
-      function genTernaryExp(el) {
-          return altGen
-              ? altGen(el, state)
-              : el.once
-                  ? genOnce(el, state)
-                  : genElement(el, state);
-      }
-  }
-  function genFor(el, state, altGen, altHelper) {
-      const exp = el.for;
-      const alias = el.alias;
-      const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-      const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-      if (state.maybeComponent(el) &&
-          el.tag !== 'slot' &&
-          el.tag !== 'template' &&
-          !el.key) {
-          state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-              `v-for should have explicit keys. ` +
-              `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-      }
-      el.forProcessed = true; // avoid recursion
-      return (`${altHelper || '_l'}((${exp}),` +
-          `function(${alias}${iterator1}${iterator2}){` +
-          `return ${(altGen || genElement)(el, state)}` +
-          '})');
-  }
-  function genData(el, state) {
-      let data = '{';
-      // directives first.
-      // directives may mutate the el's other properties before they are generated.
-      const dirs = genDirectives(el, state);
-      if (dirs)
-          data += dirs + ',';
-      // key
-      if (el.key) {
-          data += `key:${el.key},`;
-      }
-      // ref
-      if (el.ref) {
-          data += `ref:${el.ref},`;
-      }
-      if (el.refInFor) {
-          data += `refInFor:true,`;
-      }
-      // pre
-      if (el.pre) {
-          data += `pre:true,`;
-      }
-      // record original tag name for components using "is" attribute
-      if (el.component) {
-          data += `tag:"${el.tag}",`;
-      }
-      // module data generation functions
-      for (let i = 0; i < state.dataGenFns.length; i++) {
-          data += state.dataGenFns[i](el);
-      }
-      // attributes
-      if (el.attrs) {
-          data += `attrs:${genProps(el.attrs)},`;
-      }
-      // DOM props
-      if (el.props) {
-          data += `domProps:${genProps(el.props)},`;
-      }
-      // event handlers
-      if (el.events) {
-          data += `${genHandlers(el.events, false)},`;
-      }
-      if (el.nativeEvents) {
-          data += `${genHandlers(el.nativeEvents, true)},`;
-      }
-      // slot target
-      // only for non-scoped slots
-      if (el.slotTarget && !el.slotScope) {
-          data += `slot:${el.slotTarget},`;
-      }
-      // scoped slots
-      if (el.scopedSlots) {
-          data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-      }
-      // component v-model
-      if (el.model) {
-          data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-      }
-      // inline-template
-      if (el.inlineTemplate) {
-          const inlineTemplate = genInlineTemplate(el, state);
-          if (inlineTemplate) {
-              data += `${inlineTemplate},`;
-          }
-      }
-      data = data.replace(/,$/, '') + '}';
-      // v-bind dynamic argument wrap
-      // v-bind with dynamic arguments must be applied using the same v-bind object
-      // merge helper so that class/style/mustUseProp attrs are handled correctly.
-      if (el.dynamicAttrs) {
-          data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-      }
-      // v-bind data wrap
-      if (el.wrapData) {
-          data = el.wrapData(data);
-      }
-      // v-on data wrap
-      if (el.wrapListeners) {
-          data = el.wrapListeners(data);
-      }
-      return data;
-  }
-  function genDirectives(el, state) {
-      const dirs = el.directives;
-      if (!dirs)
-          return;
-      let res = 'directives:[';
-      let hasRuntime = false;
-      let i, l, dir, needRuntime;
-      for (i = 0, l = dirs.length; i < l; i++) {
-          dir = dirs[i];
-          needRuntime = true;
-          const gen = state.directives[dir.name];
-          if (gen) {
-              // compile-time directive that manipulates AST.
-              // returns true if it also needs a runtime counterpart.
-              needRuntime = !!gen(el, dir, state.warn);
-          }
-          if (needRuntime) {
-              hasRuntime = true;
-              res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-          }
-      }
-      if (hasRuntime) {
-          return res.slice(0, -1) + ']';
-      }
-  }
-  function genInlineTemplate(el, state) {
-      const ast = el.children[0];
-      if ((el.children.length !== 1 || ast.type !== 1)) {
-          state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-      }
-      if (ast && ast.type === 1) {
-          const inlineRenderFns = generate$1(ast, state.options);
-          return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-      }
-  }
-  function genScopedSlots(el, slots, state) {
-      // by default scoped slots are considered "stable", this allows child
-      // components with only scoped slots to skip forced updates from parent.
-      // but in some cases we have to bail-out of this optimization
-      // for example if the slot contains dynamic names, has v-if or v-for on them...
-      let needsForceUpdate = el.for ||
-          Object.keys(slots).some((key) => {
-              const slot = slots[key];
-              return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-              );
-          });
-      // #9534: if a component with scoped slots is inside a conditional branch,
-      // it's possible for the same component to be reused but with different
-      // compiled slot content. To avoid that, we generate a unique key based on
-      // the generated code of all the slot contents.
-      let needsKey = !!el.if;
-      // OR when it is inside another scoped slot or v-for (the reactivity may be
-      // disconnected due to the intermediate scope variable)
-      // #9438, #9506
-      // TODO: this can be further optimized by properly analyzing in-scope bindings
-      // and skip force updating ones that do not actually use scope variables.
-      if (!needsForceUpdate) {
-          let parent = el.parent;
-          while (parent) {
-              if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                  parent.for) {
-                  needsForceUpdate = true;
-                  break;
-              }
-              if (parent.if) {
-                  needsKey = true;
-              }
-              parent = parent.parent;
-          }
-      }
-      const generatedSlots = Object.keys(slots)
-          .map((key) => genScopedSlot(slots[key], state))
-          .join(',');
-      return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-  }
-  function hash(str) {
-      let hash = 5381;
-      let i = str.length;
-      while (i) {
-          hash = (hash * 33) ^ str.charCodeAt(--i);
-      }
-      return hash >>> 0;
-  }
-  function containsSlotChild(el) {
-      if (el.type === 1) {
-          if (el.tag === 'slot') {
-              return true;
-          }
-          return el.children.some(containsSlotChild);
-      }
-      return false;
-  }
-  function genScopedSlot(el, state) {
-      const isLegacySyntax = el.attrsMap['slot-scope'];
-      if (el.if && !el.ifProcessed && !isLegacySyntax) {
-          return genIf(el, state, genScopedSlot, `null`);
-      }
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genScopedSlot);
-      }
-      const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-      const fn = `function(${slotScope}){` +
-          `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-      // reverse proxy v-slot without scope on this.$slots
-      const reverseProxy = slotScope ? `` : `,proxy:true`;
-      return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-  }
-  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-      const children = el.children;
-      if (children.length) {
-          const el = children[0];
-          // optimize single v-for
-          if (children.length === 1 &&
-              el.for &&
-              el.tag !== 'template' &&
-              el.tag !== 'slot') {
-              const normalizationType = checkSkip
-                  ? state.maybeComponent(el)
-                      ? `,1`
-                      : `,0`
-                  : ``;
-              return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-          }
-          const normalizationType = checkSkip
-              ? getNormalizationType(children, state.maybeComponent)
-              : 0;
-          const gen = altGenNode || genNode;
-          return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-      }
-  }
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType(children, maybeComponent) {
-      let res = 0;
-      for (let i = 0; i < children.length; i++) {
-          const el = children[i];
-          if (el.type !== 1) {
-              continue;
-          }
-          if (needsNormalization(el) ||
-              (el.ifConditions &&
-                  el.ifConditions.some((c) => needsNormalization(c.block)))) {
-              res = 2;
-              break;
-          }
-          if (maybeComponent(el) ||
-              (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-              res = 1;
-          }
-      }
-      return res;
-  }
-  function needsNormalization(el) {
-      return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-  }
-  function genNode(node, state) {
-      if (node.type === 1) {
-          return genElement(node, state);
-      }
-      else if (node.type === 3 && node.isComment) {
-          return genComment(node);
-      }
-      else {
-          return genText(node);
-      }
-  }
-  function genText(text) {
-      return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-  }
-  function genComment(comment) {
-      return `_e(${JSON.stringify(comment.text)})`;
-  }
-  function genSlot(el, state) {
-      const slotName = el.slotName || '"default"';
-      const children = genChildren(el, state);
-      let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-      const attrs = el.attrs || el.dynamicAttrs
-          ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-              // slot props are camelized
-              name: camelize(attr.name),
-              value: attr.value,
-              dynamic: attr.dynamic
-          })))
-          : null;
-      const bind = el.attrsMap['v-bind'];
-      if ((attrs || bind) && !children) {
-          res += `,null`;
-      }
-      if (attrs) {
-          res += `,${attrs}`;
-      }
-      if (bind) {
-          res += `${attrs ? '' : ',null'},${bind}`;
-      }
-      return res + ')';
-  }
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent(componentName, el, state) {
-      const children = el.inlineTemplate ? null : genChildren(el, state, true);
-      return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-  }
-  function genProps(props) {
-      let staticProps = ``;
-      let dynamicProps = ``;
-      for (let i = 0; i < props.length; i++) {
-          const prop = props[i];
-          const value = transformSpecialNewlines(prop.value);
-          if (prop.dynamic) {
-              dynamicProps += `${prop.name},${value},`;
-          }
-          else {
-              staticProps += `"${prop.name}":${value},`;
-          }
-      }
-      staticProps = `{${staticProps.slice(0, -1)}}`;
-      if (dynamicProps) {
-          return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-      }
-      else {
-          return staticProps;
-      }
-  }
-  // #3895, #4268
-  function transformSpecialNewlines(text) {
-      return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-  }
-
-  const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-  // let the model AST transform translate v-model into appropriate
-  // props bindings
-  function applyModelTransform(el, state) {
-      if (el.directives) {
-          for (let i = 0; i < el.directives.length; i++) {
-              const dir = el.directives[i];
-              if (dir.name === 'model') {
-                  state.directives.model(el, dir, state.warn);
-                  // remove value for textarea as its converted to text
-                  if (el.tag === 'textarea' && el.props) {
-                      el.props = el.props.filter((p) => p.name !== 'value');
-                  }
-                  break;
-              }
-          }
-      }
-  }
-  function genAttrSegments(attrs) {
-      return attrs.map(({ name, value }) => genAttrSegment(name, value));
-  }
-  function genDOMPropSegments(props, attrs) {
-      const segments = [];
-      props.forEach(({ name, value }) => {
-          name = propsToAttrMap[name] || name.toLowerCase();
-          if (isRenderableAttr(name) &&
-              !(attrs && attrs.some((a) => a.name === name))) {
-              segments.push(genAttrSegment(name, value));
-          }
-      });
-      return segments;
-  }
-  function genAttrSegment(name, value) {
-      if (plainStringRE.test(value)) {
-          // force double quote
-          value = value.replace(/^'|'$/g, '"');
-          // force enumerated attr to "true"
-          if (isEnumeratedAttr(name) && value !== `"false"`) {
-              value = `"true"`;
-          }
-          return {
-              type: RAW,
-              value: isBooleanAttr(name)
-                  ? ` ${name}="${name}"`
-                  : value === '""'
-                      ? ` ${name}`
-                      : ` ${name}="${JSON.parse(value)}"`,
-          };
-      }
-      else {
-          return {
-              type: EXPRESSION,
-              value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-          };
-      }
-  }
-  function genClassSegments(staticClass, classBinding) {
-      if (staticClass && !classBinding) {
-          return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-      }
-      else {
-          return [
-              {
-                  type: EXPRESSION,
-                  value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-              },
-          ];
-      }
-  }
-  function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-      if (staticStyle && !styleBinding && !vShowExpression) {
-          return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-      }
-      else {
-          return [
-              {
-                  type: EXPRESSION,
-                  value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-              },
-          ];
-      }
-  }
-
-  /**
-   * In SSR, the vdom tree is generated only once and never patched, so
-   * we can optimize most element / trees into plain string render functions.
-   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-   *
-   * The criteria for SSR optimizability is quite a bit looser than static tree
-   * detection (which is designed for client re-render). In SSR we bail only for
-   * components/slots/custom directives.
-   */
-  // optimizability constants
-  const optimizability = {
-      FALSE: 0,
-      FULL: 1,
-      SELF: 2,
-      CHILDREN: 3,
-      PARTIAL: 4, // self un-optimizable with some un-optimizable children
-  };
-  let isPlatformReservedTag;
-  function optimize(root, options) {
-      if (!root)
-          return;
-      isPlatformReservedTag = options.isReservedTag || no;
-      walk(root, true);
-  }
-  function walk(node, isRoot) {
-      if (isUnOptimizableTree(node)) {
-          node.ssrOptimizability = optimizability.FALSE;
-          return;
-      }
-      // root node or nodes with custom directives should always be a VNode
-      const selfUnoptimizable = isRoot || hasCustomDirective(node);
-      const check = (child) => {
-          if (child.ssrOptimizability !== optimizability.FULL) {
-              node.ssrOptimizability = selfUnoptimizable
-                  ? optimizability.PARTIAL
-                  : optimizability.SELF;
-          }
-      };
-      if (selfUnoptimizable) {
-          node.ssrOptimizability = optimizability.CHILDREN;
-      }
-      if (node.type === 1) {
-          for (let i = 0, l = node.children.length; i < l; i++) {
-              const child = node.children[i];
-              walk(child);
-              check(child);
-          }
-          if (node.ifConditions) {
-              for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                  const block = node.ifConditions[i].block;
-                  walk(block, isRoot);
-                  check(block);
-              }
-          }
-          if (node.ssrOptimizability == null ||
-              (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-              node.ssrOptimizability = optimizability.FULL;
-          }
-          else {
-              node.children = optimizeSiblings(node);
-          }
-      }
-      else {
-          node.ssrOptimizability = optimizability.FULL;
-      }
-  }
-  function optimizeSiblings(el) {
-      const children = el.children;
-      const optimizedChildren = [];
-      let currentOptimizableGroup = [];
-      const pushGroup = () => {
-          if (currentOptimizableGroup.length) {
-              optimizedChildren.push({
-                  type: 1,
-                  parent: el,
-                  tag: 'template',
-                  attrsList: [],
-                  attrsMap: {},
-                  rawAttrsMap: {},
-                  children: currentOptimizableGroup,
-                  ssrOptimizability: optimizability.FULL,
-              });
-          }
-          currentOptimizableGroup = [];
-      };
-      for (let i = 0; i < children.length; i++) {
-          const c = children[i];
-          if (c.ssrOptimizability === optimizability.FULL) {
-              currentOptimizableGroup.push(c);
-          }
-          else {
-              // wrap fully-optimizable adjacent siblings inside a template tag
-              // so that they can be optimized into a single ssrNode by codegen
-              pushGroup();
-              optimizedChildren.push(c);
-          }
-      }
-      pushGroup();
-      return optimizedChildren;
-  }
-  function isUnOptimizableTree(node) {
-      if (node.type === 2 || node.type === 3) {
-          // text or expression
-          return false;
-      }
-      return (isBuiltInTag(node.tag) || // built-in (slot, component)
-          !isPlatformReservedTag(node.tag) || // custom component
-          !!node.component || // "is" component
-          isSelectWithModel(node) // <select v-model> requires runtime inspection
-      );
-  }
-  const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-  function hasCustomDirective(node) {
-      return (node.type === 1 &&
-          node.directives &&
-          node.directives.some((d) => !isBuiltInDir(d.name)));
-  }
-  // <select v-model> cannot be optimized because it requires a runtime check
-  // to determine proper selected option
-  function isSelectWithModel(node) {
-      return (node.type === 1 &&
-          node.tag === 'select' &&
-          node.directives != null &&
-          node.directives.some((d) => d.name === 'model'));
-  }
-
-  // The SSR codegen is essentially extending the default codegen to handle
-  // segment types
-  const RAW = 0;
-  const INTERPOLATION = 1;
-  const EXPRESSION = 2;
-  function generate(ast, options) {
-      const state = new CodegenState(options);
-      const code = ast ? genSSRElement(ast, state) : '_c("div")';
-      return {
-          render: `with(this){return ${code}}`,
-          staticRenderFns: state.staticRenderFns,
-      };
-  }
-  function genSSRElement(el, state) {
-      if (el.for && !el.forProcessed) {
-          return genFor(el, state, genSSRElement);
-      }
-      else if (el.if && !el.ifProcessed) {
-          return genIf(el, state, genSSRElement);
-      }
-      else if (el.tag === 'template' && !el.slotTarget) {
-          return el.ssrOptimizability === optimizability.FULL
-              ? genChildrenAsStringNode(el, state)
-              : genSSRChildren(el, state) || 'void 0';
-      }
-      switch (el.ssrOptimizability) {
-          case optimizability.FULL:
-              // stringify whole tree
-              return genStringElement(el, state);
-          case optimizability.SELF:
-              // stringify self and check children
-              return genStringElementWithChildren(el, state);
-          case optimizability.CHILDREN:
-              // generate self as VNode and stringify children
-              return genNormalElement(el, state, true);
-          case optimizability.PARTIAL:
-              // generate self as VNode and check children
-              return genNormalElement(el, state, false);
-          default:
-              // bail whole tree
-              return genElement(el, state);
-      }
-  }
-  function genNormalElement(el, state, stringifyChildren) {
-      const data = el.plain ? undefined : genData(el, state);
-      const children = stringifyChildren
-          ? `[${genChildrenAsStringNode(el, state)}]`
-          : genSSRChildren(el, state, true);
-      return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-  }
-  function genSSRChildren(el, state, checkSkip) {
-      return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-  }
-  function genSSRNode(el, state) {
-      return el.type === 1 ? genSSRElement(el, state) : genText(el);
-  }
-  function genChildrenAsStringNode(el, state) {
-      return el.children.length
-          ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-          : '';
-  }
-  function genStringElement(el, state) {
-      return `_ssrNode(${elementToString(el, state)})`;
-  }
-  function genStringElementWithChildren(el, state) {
-      const children = genSSRChildren(el, state, true);
-      return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-  }
-  function elementToString(el, state) {
-      return `(${flattenSegments(elementToSegments(el, state))})`;
-  }
-  function elementToSegments(el, state) {
-      // v-for / v-if
-      if (el.for && !el.forProcessed) {
-          el.forProcessed = true;
-          return [
-              {
-                  type: EXPRESSION,
-                  value: genFor(el, state, elementToString, '_ssrList'),
-              },
-          ];
-      }
-      else if (el.if && !el.ifProcessed) {
-          el.ifProcessed = true;
-          return [
-              {
-                  type: EXPRESSION,
-                  value: genIf(el, state, elementToString, '"<!---->"'),
-              },
-          ];
-      }
-      else if (el.tag === 'template') {
-          return childrenToSegments(el, state);
-      }
-      const openSegments = elementToOpenTagSegments(el, state);
-      const childrenSegments = childrenToSegments(el, state);
-      const { isUnaryTag } = state.options;
-      const close = isUnaryTag && isUnaryTag(el.tag)
-          ? []
-          : [{ type: RAW, value: `</${el.tag}>` }];
-      return openSegments.concat(childrenSegments, close);
-  }
-  function elementToOpenTagSegments(el, state) {
-      applyModelTransform(el, state);
-      let binding;
-      const segments = [{ type: RAW, value: `<${el.tag}` }];
-      // attrs
-      if (el.attrs) {
-          segments.push.apply(segments, genAttrSegments(el.attrs));
-      }
-      // domProps
-      if (el.props) {
-          segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-      }
-      // v-bind="object"
-      if ((binding = el.attrsMap['v-bind'])) {
-          segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-      }
-      // v-bind.prop="object"
-      if ((binding = el.attrsMap['v-bind.prop'])) {
-          segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-      }
-      // class
-      if (el.staticClass || el.classBinding) {
-          segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-      }
-      // style & v-show
-      if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-          segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-      }
-      // _scopedId
-      if (state.options.scopeId) {
-          segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-      }
-      segments.push({ type: RAW, value: `>` });
-      return segments;
-  }
-  function childrenToSegments(el, state) {
-      let binding;
-      if ((binding = el.attrsMap['v-html'])) {
-          return [{ type: EXPRESSION, value: `_s(${binding})` }];
-      }
-      if ((binding = el.attrsMap['v-text'])) {
-          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-      }
-      if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-          return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-      }
-      return el.children ? nodesToSegments(el.children, state) : [];
-  }
-  function nodesToSegments(children, state) {
-      const segments = [];
-      for (let i = 0; i < children.length; i++) {
-          const c = children[i];
-          if (c.type === 1) {
-              segments.push.apply(segments, elementToSegments(c, state));
-          }
-          else if (c.type === 2) {
-              segments.push({ type: INTERPOLATION, value: c.expression });
-          }
-          else if (c.type === 3) {
-              let text = escape(c.text);
-              if (c.isComment) {
-                  text = '<!--' + text + '-->';
-              }
-              segments.push({ type: RAW, value: text });
-          }
-      }
-      return segments;
-  }
-  function flattenSegments(segments) {
-      const mergedSegments = [];
-      let textBuffer = '';
-      const pushBuffer = () => {
-          if (textBuffer) {
-              mergedSegments.push(JSON.stringify(textBuffer));
-              textBuffer = '';
-          }
-      };
-      for (let i = 0; i < segments.length; i++) {
-          const s = segments[i];
-          if (s.type === RAW) {
-              textBuffer += s.value;
-          }
-          else if (s.type === INTERPOLATION) {
-              pushBuffer();
-              mergedSegments.push(`_ssrEscape(${s.value})`);
-          }
-          else if (s.type === EXPRESSION) {
-              pushBuffer();
-              mergedSegments.push(`(${s.value})`);
-          }
-      }
-      pushBuffer();
-      return mergedSegments.join('+');
-  }
-
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  const prohibitedKeywordRE = new RegExp('\\b' +
-      ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-          'super,throw,while,yield,delete,export,import,return,switch,default,' +
-          'extends,finally,continue,debugger,function,arguments')
-          .split(',')
-          .join('\\b|\\b') +
-      '\\b');
-  // these unary operators should not be used as property/method names
-  const unaryOperatorsRE = new RegExp('\\b' +
-      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-      '\\s*\\([^\\)]*\\)');
-  // strip strings in expressions
-  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-  // detect problematic expressions in a template
-  function detectErrors(ast, warn) {
-      if (ast) {
-          checkNode(ast, warn);
-      }
-  }
-  function checkNode(node, warn) {
-      if (node.type === 1) {
-          for (const name in node.attrsMap) {
-              if (dirRE.test(name)) {
-                  const value = node.attrsMap[name];
-                  if (value) {
-                      const range = node.rawAttrsMap[name];
-                      if (name === 'v-for') {
-                          checkFor(node, `v-for="${value}"`, warn, range);
-                      }
-                      else if (name === 'v-slot' || name[0] === '#') {
-                          checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                      else if (onRE.test(name)) {
-                          checkEvent(value, `${name}="${value}"`, warn, range);
-                      }
-                      else {
-                          checkExpression(value, `${name}="${value}"`, warn, range);
-                      }
-                  }
-              }
-          }
-          if (node.children) {
-              for (let i = 0; i < node.children.length; i++) {
-                  checkNode(node.children[i], warn);
-              }
-          }
-      }
-      else if (node.type === 2) {
-          checkExpression(node.expression, node.text, warn, node);
-      }
-  }
-  function checkEvent(exp, text, warn, range) {
-      const stripped = exp.replace(stripStringRE, '');
-      const keywordMatch = stripped.match(unaryOperatorsRE);
-      if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-          warn(`avoid using JavaScript unary operator as property name: ` +
-              `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-      }
-      checkExpression(exp, text, warn, range);
-  }
-  function checkFor(node, text, warn, range) {
-      checkExpression(node.for || '', text, warn, range);
-      checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-      checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-      checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-  }
-  function checkIdentifier(ident, type, text, warn, range) {
-      if (typeof ident === 'string') {
-          try {
-              new Function(`var ${ident}=_`);
-          }
-          catch (e) {
-              warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-          }
-      }
-  }
-  function checkExpression(exp, text, warn, range) {
-      try {
-          new Function(`return ${exp}`);
-      }
-      catch (e) {
-          const keywordMatch = exp
-              .replace(stripStringRE, '')
-              .match(prohibitedKeywordRE);
-          if (keywordMatch) {
-              warn(`avoid using JavaScript keyword as property name: ` +
-                  `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-          }
-          else {
-              warn(`invalid expression: ${e.message} in\n\n` +
-                  `    ${exp}\n\n` +
-                  `  Raw expression: ${text.trim()}\n`, range);
-          }
-      }
-  }
-  function checkFunctionParameterExpression(exp, text, warn, range) {
-      try {
-          new Function(exp, '');
-      }
-      catch (e) {
-          warn(`invalid function parameter expression: ${e.message} in\n\n` +
-              `    ${exp}\n\n` +
-              `  Raw expression: ${text.trim()}\n`, range);
-      }
-  }
-
-  const range = 2;
-  function generateCodeFrame(source, start = 0, end = source.length) {
-      const lines = source.split(/\r?\n/);
-      let count = 0;
-      const res = [];
-      for (let i = 0; i < lines.length; i++) {
-          count += lines[i].length + 1;
-          if (count >= start) {
-              for (let j = i - range; j <= i + range || end > count; j++) {
-                  if (j < 0 || j >= lines.length)
-                      continue;
-                  res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                  const lineLength = lines[j].length;
-                  if (j === i) {
-                      // push underline
-                      const pad = start - (count - lineLength) + 1;
-                      const length = end > count ? lineLength - pad : end - start;
-                      res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                  }
-                  else if (j > i) {
-                      if (end > count) {
-                          const length = Math.min(end - count, lineLength);
-                          res.push(`   |  ` + repeat(`^`, length));
-                      }
-                      count += lineLength + 1;
-                  }
-              }
-              break;
-          }
-      }
-      return res.join('\n');
-  }
-  function repeat(str, n) {
-      let result = '';
-      if (n > 0) {
-          // eslint-disable-next-line no-constant-condition
-          while (true) {
-              // eslint-disable-line
-              if (n & 1)
-                  result += str;
-              n >>>= 1;
-              if (n <= 0)
-                  break;
-              str += str;
-          }
-      }
-      return result;
-  }
-
-  function createFunction(code, errors) {
-      try {
-          return new Function(code);
-      }
-      catch (err) {
-          errors.push({ err, code });
-          return noop$1;
-      }
-  }
-  function createCompileToFunctionFn(compile) {
-      const cache = Object.create(null);
-      return function compileToFunctions(template, options, vm) {
-          options = extend({}, options);
-          const warn = options.warn || warn$2;
-          delete options.warn;
-          /* istanbul ignore if */
-          {
-              // detect possible CSP restriction
-              try {
-                  new Function('return 1');
-              }
-              catch (e) {
-                  if (e.toString().match(/unsafe-eval|CSP/)) {
-                      warn('It seems you are using the standalone build of Vue.js in an ' +
-                          'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                          'The template compiler cannot work in this environment. Consider ' +
-                          'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                          'templates into render functions.');
-                  }
-              }
-          }
-          // check cache
-          const key = options.delimiters
-              ? String(options.delimiters) + template
-              : template;
-          if (cache[key]) {
-              return cache[key];
-          }
-          // compile
-          const compiled = compile(template, options);
-          // check compilation errors/tips
-          {
-              if (compiled.errors && compiled.errors.length) {
-                  if (options.outputSourceRange) {
-                      compiled.errors.forEach((e) => {
-                          warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                              generateCodeFrame(template, e.start, e.end), vm);
-                      });
-                  }
-                  else {
-                      warn(`Error compiling template:\n\n${template}\n\n` +
-                          compiled.errors.map((e) => `- ${e}`).join('\n') +
-                          '\n', vm);
-                  }
-              }
-              if (compiled.tips && compiled.tips.length) {
-                  if (options.outputSourceRange) {
-                      compiled.tips.forEach((e) => tip(e.msg, vm));
-                  }
-                  else {
-                      compiled.tips.forEach((msg) => tip(msg, vm));
-                  }
-              }
-          }
-          // turn code into functions
-          const res = {};
-          const fnGenErrors = [];
-          res.render = createFunction(compiled.render, fnGenErrors);
-          res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-              return createFunction(code, fnGenErrors);
-          });
-          // check function generation errors.
-          // this should only happen if there is a bug in the compiler itself.
-          // mostly for codegen development use
-          /* istanbul ignore if */
-          {
-              if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                  warn(`Failed to generate render function:\n\n` +
-                      fnGenErrors
-                          .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                          .join('\n'), vm);
-              }
-          }
-          return (cache[key] = res);
-      };
-  }
-
-  function createCompilerCreator(baseCompile) {
-      return function createCompiler(baseOptions) {
-          function compile(template, options) {
-              const finalOptions = Object.create(baseOptions);
-              const errors = [];
-              const tips = [];
-              let warn = (msg, range, tip) => {
-                  (tip ? tips : errors).push(msg);
-              };
-              if (options) {
-                  if (options.outputSourceRange) {
-                      // $flow-disable-line
-                      const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                      warn = (msg, range, tip) => {
-                          const data = { msg };
-                          if (range) {
-                              if (range.start != null) {
-                                  data.start = range.start + leadingSpaceLength;
-                              }
-                              if (range.end != null) {
-                                  data.end = range.end + leadingSpaceLength;
-                              }
-                          }
-                          (tip ? tips : errors).push(data);
-                      };
-                  }
-                  // merge custom modules
-                  if (options.modules) {
-                      finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                  }
-                  // merge custom directives
-                  if (options.directives) {
-                      finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                  }
-                  // copy other options
-                  for (const key in options) {
-                      if (key !== 'modules' && key !== 'directives') {
-                          finalOptions[key] = options[key];
-                      }
-                  }
-              }
-              finalOptions.warn = warn;
-              const compiled = baseCompile(template.trim(), finalOptions);
-              {
-                  detectErrors(compiled.ast, warn);
-              }
-              compiled.errors = errors;
-              compiled.tips = tips;
-              return compiled;
-          }
-          return {
-              compile,
-              compileToFunctions: createCompileToFunctionFn(compile),
-          };
-      };
-  }
-
-  const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-      const ast = parse(template.trim(), options);
-      optimize(ast, options);
-      const code = generate(ast, options);
-      return {
-          ast,
-          render: code.render,
-          staticRenderFns: code.staticRenderFns,
-      };
-  });
-
-  const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-  // The template compiler attempts to minimize the need for normalization by
-  // statically analyzing the template at compile time.
-  //
-  // For plain HTML markup, normalization can be completely skipped because the
-  // generated render function is guaranteed to return Array<VNode>. There are
-  // two cases where extra normalization is needed:
-  // 1. When the children contains components - because a functional component
-  // may return an Array instead of a single root. In this case, just a simple
-  // normalization is needed - if any child is an Array, we flatten the whole
-  // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-  // because functional components already normalize their own children.
-  function simpleNormalizeChildren(children) {
-      for (let i = 0; i < children.length; i++) {
-          if (Array.isArray(children[i])) {
-              return Array.prototype.concat.apply([], children);
-          }
-      }
-      return children;
-  }
-  // 2. When the children contains constructs that always generated nested Arrays,
-  // e.g. <template>, <slot>, v-for, or when the children is provided by user
-  // with hand-written render functions / JSX. In such cases a full normalization
-  // is needed to cater to all possible types of children values.
-  function normalizeChildren(children) {
-      return isPrimitive(children)
-          ? [createTextVNode(children)]
-          : Array.isArray(children)
-              ? normalizeArrayChildren(children)
-              : undefined;
-  }
-  function isTextNode(node) {
-      return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-  }
-  function normalizeArrayChildren(children, nestedIndex) {
-      const res = [];
-      let i, c, lastIndex, last;
-      for (i = 0; i < children.length; i++) {
-          c = children[i];
-          if (isUndef(c) || typeof c === 'boolean')
-              continue;
-          lastIndex = res.length - 1;
-          last = res[lastIndex];
-          //  nested
-          if (Array.isArray(c)) {
-              if (c.length > 0) {
-                  c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                  // merge adjacent text nodes
-                  if (isTextNode(c[0]) && isTextNode(last)) {
-                      res[lastIndex] = createTextVNode(last.text + c[0].text);
-                      c.shift();
-                  }
-                  res.push.apply(res, c);
-              }
-          }
-          else if (isPrimitive(c)) {
-              if (isTextNode(last)) {
-                  // merge adjacent text nodes
-                  // this is necessary for SSR hydration because text nodes are
-                  // essentially merged when rendered to HTML strings
-                  res[lastIndex] = createTextVNode(last.text + c);
-              }
-              else if (c !== '') {
-                  // convert primitive to vnode
-                  res.push(createTextVNode(c));
-              }
-          }
-          else {
-              if (isTextNode(c) && isTextNode(last)) {
-                  // merge adjacent text nodes
-                  res[lastIndex] = createTextVNode(last.text + c.text);
-              }
-              else {
-                  // default key for nested array children (likely generated by v-for)
-                  if (isTrue(children._isVList) &&
-                      isDef(c.tag) &&
-                      isUndef(c.key) &&
-                      isDef(nestedIndex)) {
-                      c.key = `__vlist${nestedIndex}_${i}__`;
-                  }
-                  res.push(c);
-              }
-          }
-      }
-      return res;
-  }
-
-  const ssrHelpers = {
-      _ssrEscape: escape,
-      _ssrNode: renderStringNode$1,
-      _ssrList: renderStringList,
-      _ssrAttr: renderAttr,
-      _ssrAttrs: renderAttrs,
-      _ssrDOMProps: renderDOMProps,
-      _ssrClass: renderSSRClass,
-      _ssrStyle: renderSSRStyle,
-  };
-  function installSSRHelpers(vm) {
-      if (vm._ssrNode) {
-          return;
-      }
-      let Vue = vm.constructor;
-      // @ts-expect-error
-      while (Vue.super) {
-          // @ts-expect-error
-          Vue = Vue.super;
-      }
-      extend(Vue.prototype, ssrHelpers);
-      // @ts-expect-error
-      if (Vue.FunctionalRenderContext) {
-          // @ts-expect-error
-          extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-      }
-  }
-  class StringNode {
-      isString;
-      open;
-      close;
-      children;
-      constructor(open, close, children, normalizationType) {
-          this.isString = true;
-          this.open = open;
-          this.close = close;
-          if (children) {
-              this.children =
-                  normalizationType === 1
-                      ? simpleNormalizeChildren(children)
-                      : normalizationType === 2
-                          ? normalizeChildren(children)
-                          : children;
-          }
-          else {
-              this.children = void 0;
-          }
-      }
-  }
-  function renderStringNode$1(open, close, children, normalizationType) {
-      return new StringNode(open, close, children, normalizationType);
-  }
-  function renderStringList(val, render) {
-      let ret = '';
-      let i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          for (i = 0, l = val.length; i < l; i++) {
-              ret += render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          for (i = 0; i < val; i++) {
-              ret += render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          keys = Object.keys(val);
-          for (i = 0, l = keys.length; i < l; i++) {
-              key = keys[i];
-              ret += render(val[key], key, i);
-          }
-      }
-      return ret;
-  }
-  function renderAttrs(obj) {
-      let res = '';
-      for (const key in obj) {
-          if (isSSRUnsafeAttr(key)) {
-              continue;
-          }
-          res += renderAttr(key, obj[key]);
-      }
-      return res;
-  }
-  function renderDOMProps(obj) {
-      let res = '';
-      for (const key in obj) {
-          const attr = propsToAttrMap[key] || key.toLowerCase();
-          if (isRenderableAttr(attr)) {
-              res += renderAttr(attr, obj[key]);
-          }
-      }
-      return res;
-  }
-  function renderSSRClass(staticClass, dynamic) {
-      const res = renderClass$1(staticClass, dynamic);
-      return res === '' ? res : ` class="${escape(res)}"`;
-  }
-  function renderSSRStyle(staticStyle, dynamic, extra) {
-      const style = {};
-      if (staticStyle)
-          extend(style, staticStyle);
-      if (dynamic)
-          extend(style, normalizeStyleBinding(dynamic));
-      if (extra)
-          extend(style, extra);
-      const res = genStyle(style);
-      return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
-  }
-
-  /* not type checking this file because flow doesn't play well with Proxy */
-  {
-      makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-          'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-          'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-          'require' // for Webpack/Browserify
-      );
-      const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-      if (hasProxy) {
-          const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-          config.keyCodes = new Proxy(config.keyCodes, {
-              set(target, key, value) {
-                  if (isBuiltInModifier(key)) {
-                      warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                      return false;
-                  }
-                  else {
-                      target[key] = value;
-                      return true;
-                  }
-              },
-          });
-      }
-  }
-
-  const seenObjects = new _Set();
-  /**
-   * Recursively traverse an object to evoke all converted
-   * getters, so that every nested property inside the object
-   * is collected as a "deep" dependency.
-   */
-  function traverse(val) {
-      _traverse(val, seenObjects);
-      seenObjects.clear();
-  }
-  function _traverse(val, seen) {
-      let i, keys;
-      const isA = Array.isArray(val);
-      if ((!isA && !isObject(val)) ||
-          Object.isFrozen(val) ||
-          val instanceof VNode) {
-          return;
-      }
-      if (val.__ob__) {
-          const depId = val.__ob__.dep.id;
-          if (seen.has(depId)) {
-              return;
-          }
-          seen.add(depId);
-      }
-      if (isA) {
-          i = val.length;
-          while (i--)
-              _traverse(val[i], seen);
-      }
-      else {
-          keys = Object.keys(val);
-          i = keys.length;
-          while (i--)
-              _traverse(val[keys[i]], seen);
-      }
-  }
-
-  const normalizeEvent = cached((name) => {
-      const passive = name.charAt(0) === '&';
-      name = passive ? name.slice(1) : name;
-      const once = name.charAt(0) === '~'; // Prefixed last, checked first
-      name = once ? name.slice(1) : name;
-      const capture = name.charAt(0) === '!';
-      name = capture ? name.slice(1) : name;
-      return {
-          name,
-          once,
-          capture,
-          passive,
-      };
-  });
-  function createFnInvoker(fns, vm) {
-      function invoker() {
-          const fns = invoker.fns;
-          if (Array.isArray(fns)) {
-              const cloned = fns.slice();
-              for (let i = 0; i < cloned.length; i++) {
-                  invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-              }
-          }
-          else {
-              // return handler return value for single handlers
-              return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-          }
-      }
-      invoker.fns = fns;
-      return invoker;
-  }
-  function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-      let name, cur, old, event;
-      for (name in on) {
-          cur = on[name];
-          old = oldOn[name];
-          event = normalizeEvent(name);
-          if (isUndef(cur)) {
-              warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-          }
-          else if (isUndef(old)) {
-              if (isUndef(cur.fns)) {
-                  cur = on[name] = createFnInvoker(cur, vm);
-              }
-              if (isTrue(event.once)) {
-                  cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-              }
-              add(event.name, cur, event.capture, event.passive, event.params);
-          }
-          else if (cur !== old) {
-              old.fns = cur;
-              on[name] = old;
-          }
-      }
-      for (name in oldOn) {
-          if (isUndef(on[name])) {
-              event = normalizeEvent(name);
-              remove(event.name, oldOn[name], event.capture);
-          }
-      }
-  }
-
-  function extractPropsFromVNodeData(data, Ctor, tag) {
-      // we are only extracting raw values here.
-      // validation and default values are handled in the child
-      // component itself.
-      const propOptions = Ctor.options.props;
-      if (isUndef(propOptions)) {
-          return;
-      }
-      const res = {};
-      const { attrs, props } = data;
-      if (isDef(attrs) || isDef(props)) {
-          for (const key in propOptions) {
-              const altKey = hyphenate(key);
-              {
-                  const keyInLowerCase = key.toLowerCase();
-                  if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                      tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                          `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                          ` "${key}". ` +
-                          `Note that HTML attributes are case-insensitive and camelCased ` +
-                          `props need to use their kebab-case equivalents when using in-DOM ` +
-                          `templates. You should probably use "${altKey}" instead of "${key}".`);
-                  }
-              }
-              checkProp(res, props, key, altKey, true) ||
-                  checkProp(res, attrs, key, altKey, false);
-          }
-      }
-      return res;
-  }
-  function checkProp(res, hash, key, altKey, preserve) {
-      if (isDef(hash)) {
-          if (hasOwn(hash, key)) {
-              res[key] = hash[key];
-              if (!preserve) {
-                  delete hash[key];
-              }
-              return true;
-          }
-          else if (hasOwn(hash, altKey)) {
-              res[key] = hash[altKey];
-              if (!preserve) {
-                  delete hash[altKey];
-              }
-              return true;
-          }
-      }
-      return false;
-  }
-
-  const SIMPLE_NORMALIZE = 1;
-  const ALWAYS_NORMALIZE = 2;
-  // wrapper function for providing a more flexible interface
-  // without getting yelled at by flow
-  function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
-      if (Array.isArray(data) || isPrimitive(data)) {
-          normalizationType = children;
-          children = data;
-          data = undefined;
-      }
-      if (isTrue(alwaysNormalize)) {
-          normalizationType = ALWAYS_NORMALIZE;
-      }
-      return _createElement(context, tag, data, children, normalizationType);
-  }
-  function _createElement(context, tag, data, children, normalizationType) {
-      if (isDef(data) && isDef(data.__ob__)) {
-          warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-          return createEmptyVNode();
-      }
-      // object syntax in v-bind
-      if (isDef(data) && isDef(data.is)) {
-          tag = data.is;
-      }
-      if (!tag) {
-          // in case of component :is set to falsy value
-          return createEmptyVNode();
-      }
-      // warn against non-primitive key
-      if (isDef(data) &&
-          isDef(data.key) &&
-          !isPrimitive(data.key)) {
-          // @ts-expect-error
-          {
-              warn$2('Avoid using non-primitive value as key, ' +
-                  'use string/number value instead.', context);
-          }
-      }
-      // support single function children as default scoped slot
-      if (Array.isArray(children) && typeof children[0] === 'function') {
-          data = data || {};
-          data.scopedSlots = { default: children[0] };
-          children.length = 0;
-      }
-      if (normalizationType === ALWAYS_NORMALIZE) {
-          children = normalizeChildren(children);
-      }
-      else if (normalizationType === SIMPLE_NORMALIZE) {
-          children = simpleNormalizeChildren(children);
-      }
-      let vnode, ns;
-      if (typeof tag === 'string') {
-          let Ctor;
-          ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-          if ((!data || !data.pre) &&
-              isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-              // component
-              vnode = createComponent(Ctor, data, context, children, tag);
-          }
-          else {
-              // unknown or unlisted namespaced elements
-              // check at runtime because it may get assigned a namespace when its
-              // parent normalizes children
-              vnode = new VNode(tag, data, children, undefined, undefined, context);
-          }
-      }
-      else {
-          // direct component options / constructor
-          vnode = createComponent(tag, data, context, children);
-      }
-      if (Array.isArray(vnode)) {
-          return vnode;
-      }
-      else if (isDef(vnode)) {
-          if (isDef(ns))
-              applyNS(vnode, ns);
-          if (isDef(data))
-              registerDeepBindings(data);
-          return vnode;
-      }
-      else {
-          return createEmptyVNode();
-      }
-  }
-  function applyNS(vnode, ns, force) {
-      vnode.ns = ns;
-      if (vnode.tag === 'foreignObject') {
-          // use default namespace inside foreignObject
-          ns = undefined;
-          force = true;
-      }
-      if (isDef(vnode.children)) {
-          for (let i = 0, l = vnode.children.length; i < l; i++) {
-              const child = vnode.children[i];
-              if (isDef(child.tag) &&
-                  (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                  applyNS(child, ns, force);
-              }
-          }
-      }
-  }
-  // ref #5318
-  // necessary to ensure parent re-render when deep bindings like :style and
-  // :class are used on slot nodes
-  function registerDeepBindings(data) {
-      if (isObject(data.style)) {
-          traverse(data.style);
-      }
-      if (isObject(data.class)) {
-          traverse(data.class);
-      }
-  }
-
-  /**
-   * Runtime helper for rendering v-for lists.
-   */
-  function renderList(val, render) {
-      let ret = null, i, l, keys, key;
-      if (Array.isArray(val) || typeof val === 'string') {
-          ret = new Array(val.length);
-          for (i = 0, l = val.length; i < l; i++) {
-              ret[i] = render(val[i], i);
-          }
-      }
-      else if (typeof val === 'number') {
-          ret = new Array(val);
-          for (i = 0; i < val; i++) {
-              ret[i] = render(i + 1, i);
-          }
-      }
-      else if (isObject(val)) {
-          if (hasSymbol && val[Symbol.iterator]) {
-              ret = [];
-              const iterator = val[Symbol.iterator]();
-              let result = iterator.next();
-              while (!result.done) {
-                  ret.push(render(result.value, ret.length));
-                  result = iterator.next();
-              }
-          }
-          else {
-              keys = Object.keys(val);
-              ret = new Array(keys.length);
-              for (i = 0, l = keys.length; i < l; i++) {
-                  key = keys[i];
-                  ret[i] = render(val[key], key, i);
-              }
-          }
-      }
-      if (!isDef(ret)) {
-          ret = [];
-      }
-      ret._isVList = true;
-      return ret;
-  }
-
-  /**
-   * Runtime helper for rendering <slot>
-   */
-  function renderSlot(name, fallbackRender, props, bindObject) {
-      const scopedSlotFn = this.$scopedSlots[name];
-      let nodes;
-      if (scopedSlotFn) {
-          // scoped slot
-          props = props || {};
-          if (bindObject) {
-              if (!isObject(bindObject)) {
-                  warn$2("slot v-bind without argument expects an Object", this);
-              }
-              props = extend(extend({}, bindObject), props);
-          }
-          nodes =
-              scopedSlotFn(props) ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      else {
-          nodes =
-              this.$slots[name] ||
-                  (typeof fallbackRender === "function"
-                      ? fallbackRender()
-                      : fallbackRender);
-      }
-      const target = props && props.slot;
-      if (target) {
-          return this.$createElement("template", { slot: target }, nodes);
-      }
-      else {
-          return nodes;
-      }
-  }
-
-  /**
-   * Runtime helper for resolving filters
-   */
-  function resolveFilter(id) {
-      return resolveAsset(this.$options, 'filters', id, true) || identity;
-  }
-
-  function isKeyNotMatch(expect, actual) {
-      if (Array.isArray(expect)) {
-          return expect.indexOf(actual) === -1;
-      }
-      else {
-          return expect !== actual;
-      }
-  }
-  /**
-   * Runtime helper for checking keyCodes from config.
-   * exposed as Vue.prototype._k
-   * passing in eventKeyName as last argument separately for backwards compat
-   */
-  function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-      const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-      if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-          return isKeyNotMatch(builtInKeyName, eventKeyName);
-      }
-      else if (mappedKeyCode) {
-          return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-      }
-      else if (eventKeyName) {
-          return hyphenate(eventKeyName) !== key;
-      }
-      return eventKeyCode === undefined;
-  }
-
-  /**
-   * Runtime helper for merging v-bind="object" into a VNode's data.
-   */
-  function bindObjectProps(data, tag, value, asProp, isSync) {
-      if (value) {
-          if (!isObject(value)) {
-              warn$2('v-bind without argument expects an Object or Array value', this);
-          }
-          else {
-              if (Array.isArray(value)) {
-                  value = toObject(value);
-              }
-              let hash;
-              for (const key in value) {
-                  if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                      hash = data;
-                  }
-                  else {
-                      const type = data.attrs && data.attrs.type;
-                      hash =
-                          asProp || config.mustUseProp(tag, type, key)
-                              ? data.domProps || (data.domProps = {})
-                              : data.attrs || (data.attrs = {});
-                  }
-                  const camelizedKey = camelize(key);
-                  const hyphenatedKey = hyphenate(key);
-                  if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                      hash[key] = value[key];
-                      if (isSync) {
-                          const on = data.on || (data.on = {});
-                          on[`update:${key}`] = function ($event) {
-                              value[key] = $event;
-                          };
-                      }
-                  }
-              }
-          }
-      }
-      return data;
-  }
-
-  /**
-   * Runtime helper for rendering static trees.
-   */
-  function renderStatic(index, isInFor) {
-      const cached = this._staticTrees || (this._staticTrees = []);
-      let tree = cached[index];
-      // if has already-rendered static tree and not inside v-for,
-      // we can reuse the same tree.
-      if (tree && !isInFor) {
-          return tree;
-      }
-      // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-      );
-      markStatic(tree, `__static__${index}`, false);
-      return tree;
-  }
-  /**
-   * Runtime helper for v-once.
-   * Effectively it means marking the node as static with a unique key.
-   */
-  function markOnce(tree, index, key) {
-      markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-      return tree;
-  }
-  function markStatic(tree, key, isOnce) {
-      if (Array.isArray(tree)) {
-          for (let i = 0; i < tree.length; i++) {
-              if (tree[i] && typeof tree[i] !== 'string') {
-                  markStaticNode(tree[i], `${key}_${i}`, isOnce);
-              }
-          }
-      }
-      else {
-          markStaticNode(tree, key, isOnce);
-      }
-  }
-  function markStaticNode(node, key, isOnce) {
-      node.isStatic = true;
-      node.key = key;
-      node.isOnce = isOnce;
-  }
-
-  function bindObjectListeners(data, value) {
-      if (value) {
-          if (!isPlainObject(value)) {
-              warn$2('v-on without argument expects an Object value', this);
-          }
-          else {
-              const on = (data.on = data.on ? extend({}, data.on) : {});
-              for (const key in value) {
-                  const existing = on[key];
-                  const ours = value[key];
-                  on[key] = existing ? [].concat(existing, ours) : ours;
-              }
-          }
-      }
-      return data;
-  }
-
-  function resolveScopedSlots(fns, res, 
-  // the following are added in 2.6
-  hasDynamicKeys, contentHashKey) {
-      res = res || { $stable: !hasDynamicKeys };
-      for (let i = 0; i < fns.length; i++) {
-          const slot = fns[i];
-          if (Array.isArray(slot)) {
-              resolveScopedSlots(slot, res, hasDynamicKeys);
-          }
-          else if (slot) {
-              // marker for reverse proxying v-slot without scope on this.$slots
-              // @ts-expect-error
-              if (slot.proxy) {
-                  // @ts-expect-error
-                  slot.fn.proxy = true;
-              }
-              res[slot.key] = slot.fn;
-          }
-      }
-      if (contentHashKey) {
-          res.$key = contentHashKey;
-      }
-      return res;
-  }
-
-  // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-  function bindDynamicKeys(baseObj, values) {
-      for (let i = 0; i < values.length; i += 2) {
-          const key = values[i];
-          if (typeof key === 'string' && key) {
-              baseObj[values[i]] = values[i + 1];
-          }
-          else if (key !== '' &&
-              key !== null) {
-              // null is a special value for explicitly removing a binding
-              warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-          }
-      }
-      return baseObj;
-  }
-  // helper to dynamically append modifier runtime markers to event names.
-  // ensure only append when value is already string, otherwise it will be cast
-  // to string and cause the type check to miss.
-  function prependModifier(value, symbol) {
-      return typeof value === 'string' ? symbol + value : value;
-  }
-
-  function installRenderHelpers(target) {
-      target._o = markOnce;
-      target._n = toNumber;
-      target._s = toString;
-      target._l = renderList;
-      target._t = renderSlot;
-      target._q = looseEqual;
-      target._i = looseIndexOf;
-      target._m = renderStatic;
-      target._f = resolveFilter;
-      target._k = checkKeyCodes;
-      target._b = bindObjectProps;
-      target._v = createTextVNode;
-      target._e = createEmptyVNode;
-      target._u = resolveScopedSlots;
-      target._g = bindObjectListeners;
-      target._d = bindDynamicKeys;
-      target._p = prependModifier;
-  }
-
-  /**
-   * Runtime helper for resolving raw children VNodes into a slot object.
-   */
-  function resolveSlots(children, context) {
-      if (!children || !children.length) {
-          return {};
-      }
-      const slots = {};
-      for (let i = 0, l = children.length; i < l; i++) {
-          const child = children[i];
-          const data = child.data;
-          // remove slot attribute if the node is resolved as a Vue slot node
-          if (data && data.attrs && data.attrs.slot) {
-              delete data.attrs.slot;
-          }
-          // named slots should only be respected if the vnode was rendered in the
-          // same context.
-          if ((child.context === context || child.fnContext === context) &&
-              data &&
-              data.slot != null) {
-              const name = data.slot;
-              const slot = slots[name] || (slots[name] = []);
-              if (child.tag === 'template') {
-                  slot.push.apply(slot, child.children || []);
-              }
-              else {
-                  slot.push(child);
-              }
-          }
-          else {
-              (slots.default || (slots.default = [])).push(child);
-          }
-      }
-      // ignore slots that contains only whitespace
-      for (const name in slots) {
-          if (slots[name].every(isWhitespace)) {
-              delete slots[name];
-          }
-      }
-      return slots;
-  }
-  function isWhitespace(node) {
-      return (node.isComment && !node.asyncFactory) || node.text === ' ';
-  }
-
-  function isAsyncPlaceholder(node) {
-      // @ts-expect-error not really boolean type
-      return node.isComment && node.asyncFactory;
-  }
-
-  function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-      let res;
-      const hasNormalSlots = Object.keys(normalSlots).length > 0;
-      const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-      const key = slots && slots.$key;
-      if (!slots) {
-          res = {};
-      }
-      else if (slots._normalized) {
-          // fast path 1: child component re-render only, parent did not change
-          return slots._normalized;
-      }
-      else if (isStable &&
-          prevSlots &&
-          prevSlots !== emptyObject &&
-          key === prevSlots.$key &&
-          !hasNormalSlots &&
-          !prevSlots.$hasNormal) {
-          // fast path 2: stable scoped slots w/ no normal slots to proxy,
-          // only need to normalize once
-          return prevSlots;
-      }
-      else {
-          res = {};
-          for (const key in slots) {
-              if (slots[key] && key[0] !== "$") {
-                  res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-              }
-          }
-      }
-      // expose normal slots on scopedSlots
-      for (const key in normalSlots) {
-          if (!(key in res)) {
-              res[key] = proxyNormalSlot(normalSlots, key);
-          }
-      }
-      // avoriaz seems to mock a non-extensible $scopedSlots object
-      // and when that is passed down this would cause an error
-      if (slots && Object.isExtensible(slots)) {
-          slots._normalized = res;
-      }
-      def(res, "$stable", isStable);
-      def(res, "$key", key);
-      def(res, "$hasNormal", hasNormalSlots);
-      return res;
-  }
-  function normalizeScopedSlot(normalSlots, key, fn) {
-      const normalized = function () {
-          let res = arguments.length ? fn.apply(null, arguments) : fn({});
-          res =
-              res && typeof res === "object" && !Array.isArray(res)
-                  ? [res] // single vnode
-                  : normalizeChildren(res);
-          const vnode = res && res[0];
-          return res &&
-              (!vnode ||
-                  (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-              ? undefined
-              : res;
-      };
-      // this is a slot using the new v-slot syntax without scope. although it is
-      // compiled as a scoped slot, render fn users would expect it to be present
-      // on this.$slots because the usage is semantically a normal slot.
-      if (fn.proxy) {
-          Object.defineProperty(normalSlots, key, {
-              get: normalized,
-              enumerable: true,
-              configurable: true,
-          });
-      }
-      return normalized;
-  }
-  function proxyNormalSlot(slots, key) {
-      return () => slots[key];
-  }
-
-  function createAsyncPlaceholder(factory, data, context, children, tag) {
-      const node = createEmptyVNode();
-      node.asyncFactory = factory;
-      node.asyncMeta = { data, context, children, tag };
-      return node;
-  }
-  function resolveAsyncComponent(factory, baseCtor) {
-      if (isTrue(factory.error) && isDef(factory.errorComp)) {
-          return factory.errorComp;
-      }
-      if (isDef(factory.resolved)) {
-          return factory.resolved;
-      }
-      if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-          return factory.loadingComp;
-      }
-  }
-
-  let target;
-  function add(event, fn) {
-      target.$on(event, fn);
-  }
-  function remove(event, fn) {
-      target.$off(event, fn);
-  }
-  function createOnceHandler(event, fn) {
-      const _target = target;
-      return function onceHandler() {
-          const res = fn.apply(null, arguments);
-          if (res !== null) {
-              _target.$off(event, onceHandler);
-          }
-      };
-  }
-  function updateComponentListeners(vm, listeners, oldListeners) {
-      target = vm;
-      updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
-      target = undefined;
-  }
-
-  let activeInstance = null;
-  function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-      // determine whether component has slot children
-      // we need to do this before overwriting $options._renderChildren.
-      // check if there are dynamic scopedSlots (hand-written or compiled but with
-      // dynamic slot names). Static scoped slots compiled from template has the
-      // "$stable" marker.
-      const newScopedSlots = parentVnode.data.scopedSlots;
-      const oldScopedSlots = vm.$scopedSlots;
-      const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-          (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-          (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-          (!newScopedSlots && vm.$scopedSlots.$key));
-      // Any static slot children from the parent may have changed during parent's
-      // update. Dynamic scoped slots may also have changed. In such cases, a forced
-      // update is necessary to ensure correctness.
-      const needsForceUpdate = !!(renderChildren || // has new static slots
-          vm.$options._renderChildren || // has old static slots
-          hasDynamicScopedSlot);
-      vm.$options._parentVnode = parentVnode;
-      vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-      if (vm._vnode) {
-          // update child tree's parent
-          vm._vnode.parent = parentVnode;
-      }
-      vm.$options._renderChildren = renderChildren;
-      // update $attrs and $listeners hash
-      // these are also reactive so they may trigger child update if the child
-      // used them during render
-      vm.$attrs = parentVnode.data.attrs || emptyObject;
-      vm.$listeners = listeners || emptyObject;
-      // update props
-      if (propsData && vm.$options.props) {
-          toggleObserving(false);
-          const props = vm._props;
-          const propKeys = vm.$options._propKeys || [];
-          for (let i = 0; i < propKeys.length; i++) {
-              const key = propKeys[i];
-              const propOptions = vm.$options.props; // wtf flow?
-              props[key] = validateProp(key, propOptions, propsData, vm);
-          }
-          toggleObserving(true);
-          // keep a copy of raw propsData
-          vm.$options.propsData = propsData;
-      }
-      // update listeners
-      listeners = listeners || emptyObject;
-      const oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
-      // resolve slots + force update if has children
-      if (needsForceUpdate) {
-          vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-          vm.$forceUpdate();
-      }
-  }
-  function isInInactiveTree(vm) {
-      while (vm && (vm = vm.$parent)) {
-          if (vm._inactive)
-              return true;
-      }
-      return false;
-  }
-  function activateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = false;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      else if (vm._directInactive) {
-          return;
-      }
-      if (vm._inactive || vm._inactive === null) {
-          vm._inactive = false;
-          for (let i = 0; i < vm.$children.length; i++) {
-              activateChildComponent(vm.$children[i]);
-          }
-          callHook(vm, "activated");
-      }
-  }
-  function deactivateChildComponent(vm, direct) {
-      if (direct) {
-          vm._directInactive = true;
-          if (isInInactiveTree(vm)) {
-              return;
-          }
-      }
-      if (!vm._inactive) {
-          vm._inactive = true;
-          for (let i = 0; i < vm.$children.length; i++) {
-              deactivateChildComponent(vm.$children[i]);
-          }
-          callHook(vm, "deactivated");
-      }
-  }
-  function callHook(vm, hook) {
-      // #7573 disable dep collection when invoking lifecycle hooks
-      pushTarget();
-      const handlers = vm.$options[hook];
-      const info = `${hook} hook`;
-      if (handlers) {
-          for (let i = 0, j = handlers.length; i < j; i++) {
-              invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-          }
-      }
-      if (vm._hasHookEvent) {
-          vm.$emit("hook:" + hook);
-      }
-      popTarget();
-  }
-
-  // Async edge case fix requires storing an event listener's attach timestamp.
-  let getNow = Date.now;
-  // Determine what event timestamp the browser is using. Annoyingly, the
-  // timestamp can either be hi-res (relative to page load) or low-res
-  // (relative to UNIX epoch), so in order to compare time we have to use the
-  // same timestamp type when saving the flush timestamp.
-  // All IE versions use low-res event timestamps, and have problematic clock
-  // implementations (#9632)
-  if (inBrowser && !isIE) {
-      const performance = window.performance;
-      if (performance &&
-          typeof performance.now === 'function' &&
-          getNow() > document.createEvent('Event').timeStamp) {
-          // if the event timestamp, although evaluated AFTER the Date.now(), is
-          // smaller than it, it means the event is using a hi-res timestamp,
-          // and we need to use the hi-res version for event listener timestamps as
-          // well.
-          getNow = () => performance.now();
-      }
-  }
-  /**
-   * Queue a kept-alive component that was activated during patch.
-   * The queue will be processed after the entire tree has been patched.
-   */
-  function queueActivatedComponent(vm) {
-      // setting _inactive to false here so that a render function can
-      // rely on checking whether it's in an inactive tree (e.g. router-view)
-      vm._inactive = false;
-  }
-
-  function resolveInject(inject, vm) {
-      if (inject) {
-          // inject is :any because flow is not smart enough to figure out cached
-          const result = Object.create(null);
-          const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-          for (let i = 0; i < keys.length; i++) {
-              const key = keys[i];
-              // #6574 in case the inject object is observed...
-              if (key === '__ob__')
-                  continue;
-              const provideKey = inject[key].from;
-              let source = vm;
-              while (source) {
-                  if (source._provided && hasOwn(source._provided, provideKey)) {
-                      result[key] = source._provided[provideKey];
-                      break;
-                  }
-                  // @ts-expect-error
-                  source = source.$parent;
-              }
-              if (!source) {
-                  if ('default' in inject[key]) {
-                      const provideDefault = inject[key].default;
-                      result[key] =
-                          typeof provideDefault === 'function'
-                              ? provideDefault.call(vm)
-                              : provideDefault;
-                  }
-                  else {
-                      warn$2(`Injection "${key}" not found`, vm);
-                  }
-              }
-          }
-          return result;
-      }
-  }
-
-  function resolveConstructorOptions(Ctor) {
-      let options = Ctor.options;
-      if (Ctor.super) {
-          const superOptions = resolveConstructorOptions(Ctor.super);
-          const cachedSuperOptions = Ctor.superOptions;
-          if (superOptions !== cachedSuperOptions) {
-              // super option changed,
-              // need to resolve new options.
-              Ctor.superOptions = superOptions;
-              // check if there are any late-modified/attached options (#4976)
-              const modifiedOptions = resolveModifiedOptions(Ctor);
-              // update base extend options
-              if (modifiedOptions) {
-                  extend(Ctor.extendOptions, modifiedOptions);
-              }
-              options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-              if (options.name) {
-                  options.components[options.name] = Ctor;
-              }
-          }
-      }
-      return options;
-  }
-  function resolveModifiedOptions(Ctor) {
-      let modified;
-      const latest = Ctor.options;
-      const sealed = Ctor.sealedOptions;
-      for (const key in latest) {
-          if (latest[key] !== sealed[key]) {
-              if (!modified)
-                  modified = {};
-              modified[key] = latest[key];
-          }
-      }
-      return modified;
-  }
-
-  function FunctionalRenderContext(data, props, children, parent, Ctor) {
-      const options = Ctor.options;
-      // ensure the createElement function in functional components
-      // gets a unique context - this is necessary for correct named slot check
-      let contextVm;
-      if (hasOwn(parent, '_uid')) {
-          contextVm = Object.create(parent);
-          // $flow-disable-line
-          contextVm._original = parent;
-      }
-      else {
-          // the context vm passed in is a functional context as well.
-          // in this case we want to make sure we are able to get a hold to the
-          // real context instance.
-          contextVm = parent;
-          // $flow-disable-line
-          parent = parent._original;
-      }
-      const isCompiled = isTrue(options._compiled);
-      const needNormalization = !isCompiled;
-      this.data = data;
-      this.props = props;
-      this.children = children;
-      this.parent = parent;
-      this.listeners = data.on || emptyObject;
-      this.injections = resolveInject(options.inject, parent);
-      this.slots = () => {
-          if (!this.$slots) {
-              normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-          }
-          return this.$slots;
-      };
-      Object.defineProperty(this, 'scopedSlots', {
-          enumerable: true,
-          get() {
-              return normalizeScopedSlots(data.scopedSlots, this.slots());
-          },
-      });
-      // support for compiled functional template
-      if (isCompiled) {
-          // exposing $options for renderStatic()
-          this.$options = options;
-          // pre-resolve slots for renderSlot()
-          this.$slots = this.slots();
-          this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-      }
-      if (options._scopeId) {
-          this._c = (a, b, c, d) => {
-              const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-              if (vnode && !Array.isArray(vnode)) {
-                  vnode.fnScopeId = options._scopeId;
-                  vnode.fnContext = parent;
-              }
-              return vnode;
-          };
-      }
-      else {
-          this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-      }
-  }
-  installRenderHelpers(FunctionalRenderContext.prototype);
-  function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-      const options = Ctor.options;
-      const props = {};
-      const propOptions = options.props;
-      if (isDef(propOptions)) {
-          for (const key in propOptions) {
-              props[key] = validateProp(key, propOptions, propsData || emptyObject);
-          }
-      }
-      else {
-          if (isDef(data.attrs))
-              mergeProps(props, data.attrs);
-          if (isDef(data.props))
-              mergeProps(props, data.props);
-      }
-      const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-      const vnode = options.render.call(null, renderContext._c, renderContext);
-      if (vnode instanceof VNode) {
-          return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-      }
-      else if (Array.isArray(vnode)) {
-          const vnodes = normalizeChildren(vnode) || [];
-          const res = new Array(vnodes.length);
-          for (let i = 0; i < vnodes.length; i++) {
-              res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-          }
-          return res;
-      }
-  }
-  function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-      // #7817 clone node before setting fnContext, otherwise if the node is reused
-      // (e.g. it was from a cached normal slot) the fnContext causes named slots
-      // that should not be matched to match.
-      const clone = cloneVNode(vnode);
-      clone.fnContext = contextVm;
-      clone.fnOptions = options;
-      {
-          (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-      }
-      if (data.slot) {
-          (clone.data || (clone.data = {})).slot = data.slot;
-      }
-      return clone;
-  }
-  function mergeProps(to, from) {
-      for (const key in from) {
-          to[camelize(key)] = from[key];
-      }
-  }
-
-  // inline hooks to be invoked on component VNodes during patch
-  const componentVNodeHooks = {
-      init(vnode, hydrating) {
-          if (vnode.componentInstance &&
-              !vnode.componentInstance._isDestroyed &&
-              vnode.data.keepAlive) {
-              // kept-alive components, treat as a patch
-              const mountedNode = vnode; // work around flow
-              componentVNodeHooks.prepatch(mountedNode, mountedNode);
-          }
-          else {
-              const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-              child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-          }
-      },
-      prepatch(oldVnode, vnode) {
-          const options = vnode.componentOptions;
-          const child = (vnode.componentInstance = oldVnode.componentInstance);
-          updateChildComponent(child, options.propsData, // updated props
-          options.listeners, // updated listeners
-          vnode, // new parent vnode
-          options.children // new children
-          );
-      },
-      insert(vnode) {
-          const { context, componentInstance } = vnode;
-          if (!componentInstance._isMounted) {
-              componentInstance._isMounted = true;
-              callHook(componentInstance, 'mounted');
-          }
-          if (vnode.data.keepAlive) {
-              if (context._isMounted) {
-                  // vue-router#1212
-                  // During updates, a kept-alive component's child components may
-                  // change, so directly walking the tree here may call activated hooks
-                  // on incorrect children. Instead we push them into a queue which will
-                  // be processed after the whole patch process ended.
-                  queueActivatedComponent(componentInstance);
-              }
-              else {
-                  activateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-      destroy(vnode) {
-          const { componentInstance } = vnode;
-          if (!componentInstance._isDestroyed) {
-              if (!vnode.data.keepAlive) {
-                  componentInstance.$destroy();
-              }
-              else {
-                  deactivateChildComponent(componentInstance, true /* direct */);
-              }
-          }
-      },
-  };
-  const hooksToMerge = Object.keys(componentVNodeHooks);
-  function createComponent(Ctor, data, context, children, tag) {
-      if (isUndef(Ctor)) {
-          return;
-      }
-      const baseCtor = context.$options._base;
-      // plain options object: turn it into a constructor
-      if (isObject(Ctor)) {
-          Ctor = baseCtor.extend(Ctor);
-      }
-      // if at this stage it's not a constructor or an async component factory,
-      // reject.
-      if (typeof Ctor !== 'function') {
-          {
-              warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-          }
-          return;
-      }
-      // async component
-      let asyncFactory;
-      // @ts-expect-error
-      if (isUndef(Ctor.cid)) {
-          asyncFactory = Ctor;
-          Ctor = resolveAsyncComponent(asyncFactory);
-          if (Ctor === undefined) {
-              // return a placeholder node for async component, which is rendered
-              // as a comment node but preserves all the raw information for the node.
-              // the information will be used for async server-rendering and hydration.
-              return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-          }
-      }
-      data = data || {};
-      // resolve constructor options in case global mixins are applied after
-      // component constructor creation
-      resolveConstructorOptions(Ctor);
-      // transform component v-model data into props & events
-      if (isDef(data.model)) {
-          // @ts-expect-error
-          transformModel(Ctor.options, data);
-      }
-      // extract props
-      // @ts-expect-error
-      const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-      // functional component
-      // @ts-expect-error
-      if (isTrue(Ctor.options.functional)) {
-          return createFunctionalComponent(Ctor, propsData, data, context, children);
-      }
-      // extract listeners, since these needs to be treated as
-      // child component listeners instead of DOM listeners
-      const listeners = data.on;
-      // replace with listeners with .native modifier
-      // so it gets processed during parent component patch.
-      data.on = data.nativeOn;
-      // @ts-expect-error
-      if (isTrue(Ctor.options.abstract)) {
-          // abstract components do not keep anything
-          // other than props & listeners & slot
-          // work around flow
-          const slot = data.slot;
-          data = {};
-          if (slot) {
-              data.slot = slot;
-          }
-      }
-      // install component management hooks onto the placeholder node
-      installComponentHooks(data);
-      // return a placeholder vnode
-      // @ts-expect-error
-      const name = Ctor.options.name || tag;
-      const vnode = new VNode(
-      // @ts-expect-error
-      `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-      // @ts-expect-error
-      { Ctor, propsData, listeners, tag, children }, asyncFactory);
-      return vnode;
-  }
-  function createComponentInstanceForVnode(
-  // we know it's MountedComponentVNode but flow doesn't
-  vnode, 
-  // activeInstance in lifecycle state
-  parent) {
-      const options = {
-          _isComponent: true,
-          _parentVnode: vnode,
-          parent,
-      };
-      // check inline-template render functions
-      const inlineTemplate = vnode.data.inlineTemplate;
-      if (isDef(inlineTemplate)) {
-          options.render = inlineTemplate.render;
-          options.staticRenderFns = inlineTemplate.staticRenderFns;
-      }
-      return new vnode.componentOptions.Ctor(options);
-  }
-  function installComponentHooks(data) {
-      const hooks = data.hook || (data.hook = {});
-      for (let i = 0; i < hooksToMerge.length; i++) {
-          const key = hooksToMerge[i];
-          const existing = hooks[key];
-          const toMerge = componentVNodeHooks[key];
-          // @ts-expect-error
-          if (existing !== toMerge && !(existing && existing._merged)) {
-              hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-          }
-      }
-  }
-  function mergeHook(f1, f2) {
-      const merged = (a, b) => {
-          // flow complains about extra args which is why we use any
-          f1(a, b);
-          f2(a, b);
-      };
-      merged._merged = true;
-      return merged;
-  }
-  // transform component v-model info (value and callback) into
-  // prop and event handler respectively.
-  function transformModel(options, data) {
-      const prop = (options.model && options.model.prop) || 'value';
-      const event = (options.model && options.model.event) || 'input';
-      (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-      const on = data.on || (data.on = {});
-      const existing = on[event];
-      const callback = data.model.callback;
-      if (isDef(existing)) {
-          if (Array.isArray(existing)
-              ? existing.indexOf(callback) === -1
-              : existing !== callback) {
-              on[event] = [callback].concat(existing);
-          }
-      }
-      else {
-          on[event] = callback;
-      }
-  }
-
-  let warned = Object.create(null);
-  const warnOnce = (msg) => {
-      if (!warned[msg]) {
-          warned[msg] = true;
-          // eslint-disable-next-line no-console
-          console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
-      }
-  };
-  const onCompilationError = (err, vm) => {
-      const trace = vm ? generateComponentTrace(vm) : '';
-      throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
-  };
-  const normalizeRender = (vm) => {
-      const { render, template, _scopeId } = vm.$options;
-      if (isUndef(render)) {
-          if (template) {
-              const compiled = compileToFunctions(template, {
-                  scopeId: _scopeId,
-                  warn: onCompilationError,
-              }, vm);
-              vm.$options.render = compiled.render;
-              vm.$options.staticRenderFns = compiled.staticRenderFns;
-          }
-          else {
-              throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
-          }
-      }
-  };
-  function waitForServerPrefetch(vm, resolve, reject) {
-      let handlers = vm.$options.serverPrefetch;
-      if (isDef(handlers)) {
-          if (!Array.isArray(handlers))
-              handlers = [handlers];
-          try {
-              const promises = [];
-              for (let i = 0, j = handlers.length; i < j; i++) {
-                  const result = handlers[i].call(vm, vm);
-                  if (result && typeof result.then === 'function') {
-                      promises.push(result);
-                  }
-              }
-              Promise.all(promises).then(resolve).catch(reject);
-              return;
-          }
-          catch (e) {
-              reject(e);
-          }
-      }
-      resolve();
-  }
-  function renderNode(node, isRoot, context) {
-      if (node.isString) {
-          renderStringNode(node, context);
-      }
-      else if (isDef(node.componentOptions)) {
-          renderComponent(node, isRoot, context);
-      }
-      else if (isDef(node.tag)) {
-          renderElement(node, isRoot, context);
-      }
-      else if (isTrue(node.isComment)) {
-          if (isDef(node.asyncFactory)) {
-              // async component
-              renderAsyncComponent(node, isRoot, context);
-          }
-          else {
-              context.write(`<!--${node.text}-->`, context.next);
-          }
-      }
-      else {
-          context.write(node.raw ? node.text : escape(String(node.text)), context.next);
-      }
-  }
-  function registerComponentForCache(options, write) {
-      // exposed by vue-loader, need to call this if cache hit because
-      // component lifecycle hooks will not be called.
-      const register = options._ssrRegister;
-      if (write.caching && isDef(register)) {
-          write.componentBuffer[write.componentBuffer.length - 1].add(register);
-      }
-      return register;
-  }
-  function renderComponent(node, isRoot, context) {
-      const { write, next, userContext } = context;
-      // check cache hit
-      const Ctor = node.componentOptions.Ctor;
-      const getKey = Ctor.options.serverCacheKey;
-      const name = Ctor.options.name;
-      const cache = context.cache;
-      const registerComponent = registerComponentForCache(Ctor.options, write);
-      if (isDef(getKey) && isDef(cache) && isDef(name)) {
-          const rawKey = getKey(node.componentOptions.propsData);
-          if (rawKey === false) {
-              renderComponentInner(node, isRoot, context);
-              return;
-          }
-          const key = name + '::' + rawKey;
-          const { has, get } = context;
-          if (isDef(has)) {
-              has(key, (hit) => {
-                  if (hit === true && isDef(get)) {
-                      get(key, (res) => {
-                          if (isDef(registerComponent)) {
-                              registerComponent(userContext);
-                          }
-                          res.components.forEach((register) => register(userContext));
-                          write(res.html, next);
-                      });
-                  }
-                  else {
-                      renderComponentWithCache(node, isRoot, key, context);
-                  }
-              });
-          }
-          else if (isDef(get)) {
-              get(key, (res) => {
-                  if (isDef(res)) {
-                      if (isDef(registerComponent)) {
-                          registerComponent(userContext);
-                      }
-                      res.components.forEach((register) => register(userContext));
-                      write(res.html, next);
-                  }
-                  else {
-                      renderComponentWithCache(node, isRoot, key, context);
-                  }
-              });
-          }
-      }
-      else {
-          if (isDef(getKey) && isUndef(cache)) {
-              warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
-                  'but no cache was provided to the renderer.');
-          }
-          if (isDef(getKey) && isUndef(name)) {
-              warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
-                  `must also define a unique "name" option.`);
-          }
-          renderComponentInner(node, isRoot, context);
-      }
-  }
-  function renderComponentWithCache(node, isRoot, key, context) {
-      const write = context.write;
-      write.caching = true;
-      const buffer = write.cacheBuffer;
-      const bufferIndex = buffer.push('') - 1;
-      const componentBuffer = write.componentBuffer;
-      componentBuffer.push(new Set());
-      context.renderStates.push({
-          type: 'ComponentWithCache',
-          key,
-          buffer,
-          bufferIndex,
-          componentBuffer,
-      });
-      renderComponentInner(node, isRoot, context);
-  }
-  function renderComponentInner(node, isRoot, context) {
-      const prevActive = context.activeInstance;
-      // expose userContext on vnode
-      node.ssrContext = context.userContext;
-      const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
-      normalizeRender(child);
-      const resolve = () => {
-          const childNode = child._render();
-          childNode.parent = node;
-          context.renderStates.push({
-              type: 'Component',
-              prevActive,
-          });
-          renderNode(childNode, isRoot, context);
-      };
-      const reject = context.done;
-      waitForServerPrefetch(child, resolve, reject);
-  }
-  function renderAsyncComponent(node, isRoot, context) {
-      const factory = node.asyncFactory;
-      const resolve = (comp) => {
-          if (comp.__esModule && comp.default) {
-              comp = comp.default;
-          }
-          const { data, children, tag } = node.asyncMeta;
-          const nodeContext = node.asyncMeta.context;
-          const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
-          if (resolvedNode) {
-              if (resolvedNode.componentOptions) {
-                  // normal component
-                  renderComponent(resolvedNode, isRoot, context);
-              }
-              else if (!Array.isArray(resolvedNode)) {
-                  // single return node from functional component
-                  renderNode(resolvedNode, isRoot, context);
-              }
-              else {
-                  // multiple return nodes from functional component
-                  context.renderStates.push({
-                      type: 'Fragment',
-                      children: resolvedNode,
-                      rendered: 0,
-                      total: resolvedNode.length,
-                  });
-                  context.next();
-              }
-          }
-          else {
-              // invalid component, but this does not throw on the client
-              // so render empty comment node
-              context.write(`<!---->`, context.next);
-          }
-      };
-      if (factory.resolved) {
-          resolve(factory.resolved);
-          return;
-      }
-      const reject = context.done;
-      let res;
-      try {
-          res = factory(resolve, reject);
-      }
-      catch (e) {
-          reject(e);
-      }
-      if (res) {
-          if (typeof res.then === 'function') {
-              res.then(resolve, reject).catch(reject);
-          }
-          else {
-              // new syntax in 2.3
-              const comp = res.component;
-              if (comp && typeof comp.then === 'function') {
-                  comp.then(resolve, reject).catch(reject);
-              }
-          }
-      }
-  }
-  function renderStringNode(el, context) {
-      const { write, next } = context;
-      if (isUndef(el.children) || el.children.length === 0) {
-          write(el.open + (el.close || ''), next);
-      }
-      else {
-          const children = el.children;
-          context.renderStates.push({
-              type: 'Element',
-              children,
-              rendered: 0,
-              total: children.length,
-              endTag: el.close,
-          });
-          write(el.open, next);
-      }
-  }
-  function renderElement(el, isRoot, context) {
-      const { write, next } = context;
-      if (isTrue(isRoot)) {
-          if (!el.data)
-              el.data = {};
-          if (!el.data.attrs)
-              el.data.attrs = {};
-          el.data.attrs[SSR_ATTR] = 'true';
-      }
-      if (el.fnOptions) {
-          registerComponentForCache(el.fnOptions, write);
-      }
-      const startTag = renderStartingTag(el, context);
-      const endTag = `</${el.tag}>`;
-      if (context.isUnaryTag(el.tag)) {
-          write(startTag, next);
-      }
-      else if (isUndef(el.children) || el.children.length === 0) {
-          write(startTag + endTag, next);
-      }
-      else {
-          const children = el.children;
-          context.renderStates.push({
-              type: 'Element',
-              children,
-              rendered: 0,
-              total: children.length,
-              endTag,
-          });
-          write(startTag, next);
-      }
-  }
-  function hasAncestorData(node) {
-      const parentNode = node.parent;
-      return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
-  }
-  function getVShowDirectiveInfo(node) {
-      let dir;
-      let tmp;
-      while (isDef(node)) {
-          if (node.data && node.data.directives) {
-              tmp = node.data.directives.find((dir) => dir.name === 'show');
-              if (tmp) {
-                  dir = tmp;
-              }
-          }
-          node = node.parent;
-      }
-      //@ts-expect-error
-      return dir;
-  }
-  function renderStartingTag(node, context) {
-      let markup = `<${node.tag}`;
-      const { directives, modules } = context;
-      // construct synthetic data for module processing
-      // because modules like style also produce code by parent VNode data
-      if (isUndef(node.data) && hasAncestorData(node)) {
-          node.data = {};
-      }
-      if (isDef(node.data)) {
-          // check directives
-          const dirs = node.data.directives;
-          if (dirs) {
-              for (let i = 0; i < dirs.length; i++) {
-                  const name = dirs[i].name;
-                  if (name !== 'show') {
-                      const dirRenderer = resolveAsset(context, 'directives', name);
-                      if (dirRenderer) {
-                          // directives mutate the node's data
-                          // which then gets rendered by modules
-                          dirRenderer(node, dirs[i]);
-                      }
-                  }
-              }
-          }
-          // v-show directive needs to be merged from parent to child
-          const vshowDirectiveInfo = getVShowDirectiveInfo(node);
-          if (vshowDirectiveInfo) {
-              directives.show(node, vshowDirectiveInfo);
-          }
-          // apply other modules
-          for (let i = 0; i < modules.length; i++) {
-              const res = modules[i](node);
-              if (res) {
-                  markup += res;
-              }
-          }
-      }
-      // attach scoped CSS ID
-      let scopeId;
-      const activeInstance = context.activeInstance;
-      if (isDef(activeInstance) &&
-          activeInstance !== node.context &&
-          isDef((scopeId = activeInstance.$options._scopeId))) {
-          markup += ` ${scopeId}`;
-      }
-      if (isDef(node.fnScopeId)) {
-          markup += ` ${node.fnScopeId}`;
-      }
-      else {
-          while (isDef(node)) {
-              //@ts-expect-error
-              if (isDef((scopeId = node.context.$options._scopeId))) {
-                  markup += ` ${scopeId}`;
-              }
-              node = node.parent;
-          }
-      }
-      return markup + '>';
-  }
-  function createRenderFunction(modules, directives, isUnaryTag, cache) {
-      return function render(component, write, userContext, done) {
-          warned = Object.create(null);
-          const context = new RenderContext({
-              activeInstance: component,
-              userContext,
-              write,
-              done,
-              renderNode,
-              isUnaryTag,
-              modules,
-              directives,
-              cache,
-          });
-          installSSRHelpers(component);
-          normalizeRender(component);
-          const resolve = () => {
-              renderNode(component._render(), true, context);
-          };
-          waitForServerPrefetch(component, resolve, done);
-      };
-  }
-
-  function createBasicRenderer({ modules = [], directives = {}, isUnaryTag = () => false, cache, } = {}) {
-      const render = createRenderFunction(modules, directives, isUnaryTag, cache);
-      return function renderToString(component, context, done) {
-          if (typeof context === 'function') {
-              done = context;
-              context = {};
-          }
-          let result = '';
-          const write = createWriteFunction((text) => {
-              result += text;
-              return false;
-          }, done);
-          try {
-              //@ts-expect-error
-              render(component, write, context, () => {
-                  done(null, result);
-              });
-          }
-          catch (e) {
-              done(e);
-          }
-      };
-  }
-
-  var entryServerBasicRenderer = createBasicRenderer({
-      // @ts-expect-error
-      modules: modules$1,
-      directives: directives$1,
-      isUnaryTag,
-      canBeLeftOpenTag,
-  });
-
-  return entryServerBasicRenderer;
-
-}));
diff --git a/packages/vue-server-renderer/build.dev.js b/packages/vue-server-renderer/build.dev.js
deleted file mode 100644
index bb2bebb9468..00000000000
--- a/packages/vue-server-renderer/build.dev.js
+++ /dev/null
@@ -1,8150 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var stream = require('stream');
-var he = require('he');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
-
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    const n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$1(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Capitalize a string.
- */
-const capitalize = cached((str) => {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject(arr) {
-    const res = {};
-    for (let i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop$1(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        return true;
-    const isObjectA = isObject(a);
-    const isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            const isArrayA = Array.isArray(a);
-            const isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every((e, i) => {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                const keysA = Object.keys(a);
-                const keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every((key) => {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (let i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            return i;
-    }
-    return -1;
-}
-
-const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap');
-const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/; // eslint-disable-line no-control-regex
-const isSSRUnsafeAttr = (name) => {
-    return unsafeAttrCharRE.test(name);
-};
-/* istanbul ignore next */
-const isRenderableAttr = (name) => {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-};
-const propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv',
-};
-const ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;',
-};
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
-}
-function escapeChar(a) {
-    return ESC[a] || a;
-}
-const noUnitNumericStyleProps = {
-    'animation-iteration-count': true,
-    'border-image-outset': true,
-    'border-image-slice': true,
-    'border-image-width': true,
-    'box-flex': true,
-    'box-flex-group': true,
-    'box-ordinal-group': true,
-    'column-count': true,
-    columns: true,
-    flex: true,
-    'flex-grow': true,
-    'flex-positive': true,
-    'flex-shrink': true,
-    'flex-negative': true,
-    'flex-order': true,
-    'grid-row': true,
-    'grid-row-end': true,
-    'grid-row-span': true,
-    'grid-row-start': true,
-    'grid-column': true,
-    'grid-column-end': true,
-    'grid-column-span': true,
-    'grid-column-start': true,
-    'font-weight': true,
-    'line-clamp': true,
-    'line-height': true,
-    opacity: true,
-    order: true,
-    orphans: true,
-    'tab-size': true,
-    widows: true,
-    'z-index': true,
-    zoom: true,
-    // SVG
-    'fill-opacity': true,
-    'flood-opacity': true,
-    'stop-opacity': true,
-    'stroke-dasharray': true,
-    'stroke-dashoffset': true,
-    'stroke-miterlimit': true,
-    'stroke-opacity': true,
-    'stroke-width': true,
-};
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-const isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');
-const convertEnumeratedValue = (key, value) => {
-    return isFalsyAttrValue(value) || value === 'false'
-        ? 'false'
-        : // allow arbitrary string value for contenteditable
-            key === 'contenteditable' && isValidContentEditableValue(value)
-                ? value
-                : 'true';
-};
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-const isFalsyAttrValue = (val) => {
-    return val == null || val === false;
-};
-
-function renderAttrs$1(node) {
-    let attrs = node.data.attrs;
-    let res = '';
-    const opts = node.parent && node.parent.componentOptions;
-    if (isUndef(opts) || opts.Ctor.options.inheritAttrs !== false) {
-        let parent = node.parent;
-        while (isDef(parent)) {
-            // Stop fallthrough in case parent has inheritAttrs option set to false
-            if (parent.componentOptions &&
-                parent.componentOptions.Ctor.options.inheritAttrs === false) {
-                break;
-            }
-            if (isDef(parent.data) && isDef(parent.data.attrs)) {
-                attrs = extend(extend({}, attrs), parent.data.attrs);
-            }
-            parent = parent.parent;
-        }
-    }
-    if (isUndef(attrs)) {
-        return res;
-    }
-    for (const key in attrs) {
-        if (isSSRUnsafeAttr(key)) {
-            continue;
-        }
-        if (key === 'style') {
-            // leave it to the style module
-            continue;
-        }
-        res += renderAttr(key, attrs[key]);
-    }
-    return res;
-}
-function renderAttr(key, value) {
-    if (isBooleanAttr(key)) {
-        if (!isFalsyAttrValue(value)) {
-            return ` ${key}="${key}"`;
-        }
-    }
-    else if (isEnumeratedAttr(key)) {
-        return ` ${key}="${escape(convertEnumeratedValue(key, value))}"`;
-    }
-    else if (!isFalsyAttrValue(value)) {
-        return ` ${key}="${escape(String(value))}"`;
-    }
-    return '';
-}
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-const createEmptyVNode = (text = "") => {
-    const node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    const cloned = new VNode(vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-function renderDOMProps$1(node) {
-    let props = node.data.domProps;
-    let res = '';
-    let parent = node.parent;
-    while (isDef(parent)) {
-        if (parent.data && parent.data.domProps) {
-            props = extend(extend({}, props), parent.data.domProps);
-        }
-        parent = parent.parent;
-    }
-    if (isUndef(props)) {
-        return res;
-    }
-    const attrs = node.data.attrs;
-    for (const key in props) {
-        if (key === 'innerHTML') {
-            setText(node, props[key], true);
-        }
-        else if (key === 'textContent') {
-            setText(node, props[key], false);
-        }
-        else if (key === 'value' && node.tag === 'textarea') {
-            setText(node, toString(props[key]), false);
-        }
-        else {
-            // $flow-disable-line (WTF?)
-            const attr = propsToAttrMap[key] || key.toLowerCase();
-            if (isRenderableAttr(attr) &&
-                // avoid rendering double-bound props/attrs twice
-                !(isDef(attrs) && isDef(attrs[attr]))) {
-                res += renderAttr(attr, props[key]);
-            }
-        }
-    }
-    return res;
-}
-function setText(node, text, raw) {
-    const child = new VNode(undefined, undefined, undefined, text);
-    child.raw = raw;
-    node.children = [child];
-}
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-let _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = class Set {
-        set = Object.create(null);
-        has(key) {
-            return this.set[key] === true;
-        }
-        add(key) {
-            this.set[key] = true;
-        }
-        clear() {
-            this.set = Object.create(null);
-        }
-    };
-}
-
-const SSR_ATTR = 'data-server-rendered';
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: "development" !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: "development" !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop$1,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-let warn$2 = noop$1;
-let tip = noop$1;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-{
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove$1(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-const targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-let shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if ((isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-{
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && "development" !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (const key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp(`^[a-zA-Z][\\-\\.0-9_${unicodeRegExp.source}]*$`).test(name)) {
-        warn$2('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn$2('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    const props = options.props;
-    if (!props)
-        return;
-    const res = {};
-    let i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else {
-                warn$2('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (const key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "props": expected an Array or an Object, ` +
-            `but got ${toRawType(props)}.`, vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    const inject = options.inject;
-    if (!inject)
-        return;
-    const normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (let i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (const key in inject) {
-            const val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else {
-        warn$2(`Invalid value for option "inject": expected an Array or an Object, ` +
-            `but got ${toRawType(inject)}.`, vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives(options) {
-    const dirs = options.directives;
-    if (dirs) {
-        for (const key in dirs) {
-            const def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (let i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    const options = {};
-    let key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        const strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    const assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        return assets[id];
-    const camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        return assets[camelizedId];
-    const PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        return assets[PascalCaseId];
-    // fallback to prototype chain
-    const res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (warnMissing && !res) {
-        warn$2('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    const prop = propOptions[key];
-    const absent = !hasOwn(propsData, key);
-    let value = propsData[key];
-    // boolean casting
-    const booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            const stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        const prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    const def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (isObject(def)) {
-        warn$2('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn$2('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    let type = prop.type;
-    let valid = !type || type === true;
-    const expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (let i = 0; i < type.length && !valid; i++) {
-            const assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    const haveExpectedTypes = expectedTypes.some((t) => t);
-    if (!valid && haveExpectedTypes) {
-        warn$2(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    const validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn$2('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-const simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    let valid;
-    const expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        const t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn$2('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid,
-        expectedType,
-    };
-}
-const functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    const match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (let i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    let message = `Invalid prop: type check failed for prop "${name}".` +
-        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
-    const expectedType = expectedTypes[0];
-    const receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += ` with value ${styleValue(value, expectedType)}`;
-    }
-    message += `, got ${receivedType} `;
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += `with value ${styleValue(value, receivedType)}.`;
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return `"${value}"`;
-    }
-    else if (type === 'Number') {
-        return `${Number(value)}`;
-    }
-    else {
-        return `${value}`;
-    }
-}
-const EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem);
-}
-function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === 'boolean');
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            let cur = vm;
-            while ((cur = cur.$parent)) {
-                const hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (let i = 0; i < hooks.length; i++) {
-                        try {
-                            const capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                return;
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    let res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch((e) => handleError(e, vm, info + ` (Promise/async)`));
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        // @ts-expect-error should it be any?
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    {
-        warn$2(`Error in ${info}: "${err.toString()}"`, vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-const callbacks = [];
-function flushCallbacks() {
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve();
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-else ;
-
-function genClassForVnode(vnode) {
-    let data = vnode.data;
-    let parentNode = vnode;
-    let childNode = vnode;
-    while (isDef(childNode.componentInstance)) {
-        childNode = childNode.componentInstance._vnode;
-        if (childNode && childNode.data) {
-            data = mergeClassData(childNode.data, data);
-        }
-    }
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while (isDef((parentNode = parentNode.parent))) {
-        if (parentNode && parentNode.data) {
-            data = mergeClassData(data, parentNode.data);
-        }
-    }
-    return renderClass$1(data.staticClass, data.class);
-}
-function mergeClassData(child, parent) {
-    return {
-        staticClass: concat(child.staticClass, parent.staticClass),
-        class: isDef(child.class) ? [child.class, parent.class] : parent.class,
-    };
-}
-function renderClass$1(staticClass, dynamicClass) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-        return concat(staticClass, stringifyClass(dynamicClass));
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function concat(a, b) {
-    return a ? (b ? a + ' ' + b : a) : b || '';
-}
-function stringifyClass(value) {
-    if (Array.isArray(value)) {
-        return stringifyArray(value);
-    }
-    if (isObject(value)) {
-        return stringifyObject(value);
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    /* istanbul ignore next */
-    return '';
-}
-function stringifyArray(value) {
-    let res = '';
-    let stringified;
-    for (let i = 0, l = value.length; i < l; i++) {
-        if (isDef((stringified = stringifyClass(value[i]))) && stringified !== '') {
-            if (res)
-                res += ' ';
-            res += stringified;
-        }
-    }
-    return res;
-}
-function stringifyObject(value) {
-    let res = '';
-    for (const key in value) {
-        if (value[key]) {
-            if (res)
-                res += ' ';
-            res += key;
-        }
-    }
-    return res;
-}
-
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-makeMap('text,number,password,search,email,tel,url');
-
-function renderClass(node) {
-    const classList = genClassForVnode(node);
-    if (classList !== '') {
-        return ` class="${escape(classList)}"`;
-    }
-}
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-// merge static and dynamic style data on the same vnode
-function normalizeStyleData(data) {
-    const style = normalizeStyleBinding(data.style);
-    // static style is pre-processed into an object during compilation
-    // and is always a fresh object, so it's safe to merge into it
-    return data.staticStyle ? extend(data.staticStyle, style) : style;
-}
-// normalize possible array / string values into Object
-function normalizeStyleBinding(bindingStyle) {
-    if (Array.isArray(bindingStyle)) {
-        return toObject(bindingStyle);
-    }
-    if (typeof bindingStyle === 'string') {
-        return parseStyleText(bindingStyle);
-    }
-    return bindingStyle;
-}
-/**
- * parent component style should be after child's
- * so that parent component's style could override it
- */
-function getStyle(vnode, checkChild) {
-    const res = {};
-    let styleData;
-    if (checkChild) {
-        let childNode = vnode;
-        while (childNode.componentInstance) {
-            childNode = childNode.componentInstance._vnode;
-            if (childNode &&
-                childNode.data &&
-                (styleData = normalizeStyleData(childNode.data))) {
-                extend(res, styleData);
-            }
-        }
-    }
-    if ((styleData = normalizeStyleData(vnode.data))) {
-        extend(res, styleData);
-    }
-    let parentNode = vnode;
-    // @ts-expect-error parentNode.parent not VNodeWithData
-    while ((parentNode = parentNode.parent)) {
-        if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-            extend(res, styleData);
-        }
-    }
-    return res;
-}
-
-function genStyle(style) {
-    let styleText = '';
-    for (const key in style) {
-        const value = style[key];
-        const hyphenatedKey = hyphenate(key);
-        if (Array.isArray(value)) {
-            for (let i = 0, len = value.length; i < len; i++) {
-                styleText += normalizeValue(hyphenatedKey, value[i]);
-            }
-        }
-        else {
-            styleText += normalizeValue(hyphenatedKey, value);
-        }
-    }
-    return styleText;
-}
-function normalizeValue(key, value) {
-    if (typeof value === 'string' ||
-        (typeof value === 'number' && noUnitNumericStyleProps[key]) ||
-        value === 0) {
-        return `${key}:${value};`;
-    }
-    else {
-        // invalid values
-        return ``;
-    }
-}
-function renderStyle(vnode) {
-    const styleText = genStyle(getStyle(vnode, false));
-    if (styleText !== '') {
-        return ` style=${JSON.stringify(escape(styleText))}`;
-    }
-}
-
-var modules$1 = [renderAttrs$1, renderDOMProps$1, renderClass, renderStyle];
-
-function show(node, dir) {
-    if (!dir.value) {
-        const style = node.data.style || (node.data.style = {});
-        if (Array.isArray(style)) {
-            style.push({ display: 'none' });
-        }
-        else {
-            style.display = 'none';
-        }
-    }
-}
-
-// this is only applied for <select v-model> because it is the only edge case
-// that must be done at runtime instead of compile time.
-function model$2(node, dir) {
-    if (!node.children)
-        return;
-    const value = dir.value;
-    const isMultiple = node.data.attrs && node.data.attrs.multiple;
-    for (let i = 0, l = node.children.length; i < l; i++) {
-        const option = node.children[i];
-        if (option.tag === 'option') {
-            if (isMultiple) {
-                const selected = Array.isArray(value) && looseIndexOf(value, getValue(option)) > -1;
-                if (selected) {
-                    setSelected(option);
-                }
-            }
-            else {
-                if (looseEqual(value, getValue(option))) {
-                    setSelected(option);
-                    return;
-                }
-            }
-        }
-    }
-}
-function getValue(option) {
-    const data = option.data || {};
-    return ((data.attrs && data.attrs.value) ||
-        (data.domProps && data.domProps.value) ||
-        (option.children && option.children[0] && option.children[0].text));
-}
-function setSelected(option) {
-    const data = option.data || (option.data = {});
-    const attrs = data.attrs || (data.attrs = {});
-    attrs.selected = '';
-}
-
-var baseDirectives$1 = {
-    show,
-    model: model$2,
-};
-
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-const MAX_STACK_DEPTH = 800;
-const noop = (_) => _;
-const defer = typeof process !== 'undefined' && process.nextTick
-    ? process.nextTick
-    : typeof Promise !== 'undefined'
-        ? (fn) => Promise.resolve().then(fn)
-        : typeof setTimeout !== 'undefined'
-            ? setTimeout
-            : noop;
-if (defer === noop) {
-    throw new Error('Your JavaScript runtime does not support any asynchronous primitives ' +
-        'that are required by vue-server-renderer. Please use a polyfill for ' +
-        'either Promise or setTimeout.');
-}
-function createWriteFunction(write, onError) {
-    let stackDepth = 0;
-    const cachedWrite = (text, next) => {
-        if (text && cachedWrite.caching) {
-            cachedWrite.cacheBuffer[cachedWrite.cacheBuffer.length - 1] += text;
-        }
-        const waitForNext = write(text, next);
-        if (waitForNext !== true) {
-            if (stackDepth >= MAX_STACK_DEPTH) {
-                defer(() => {
-                    try {
-                        next();
-                    }
-                    catch (e) {
-                        onError(e);
-                    }
-                });
-            }
-            else {
-                stackDepth++;
-                next();
-                stackDepth--;
-            }
-        }
-    };
-    cachedWrite.caching = false;
-    cachedWrite.cacheBuffer = [];
-    cachedWrite.componentBuffer = [];
-    return cachedWrite;
-}
-
-/**
- * Original RenderStream implementation by Sasha Aickin (@aickin)
- * Licensed under the Apache License, Version 2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Modified by Evan You (@yyx990803)
- */
-class RenderStream extends stream.Readable {
-    buffer;
-    render;
-    expectedSize;
-    write;
-    //@ts-expect-error
-    next;
-    end;
-    //@ts-expect-error
-    done;
-    constructor(render) {
-        super();
-        this.buffer = '';
-        //@ts-expect-error
-        this.render = render;
-        this.expectedSize = 0;
-        this.write = createWriteFunction((text, next) => {
-            const n = this.expectedSize;
-            this.buffer += text;
-            if (this.buffer.length >= n) {
-                this.next = next;
-                this.pushBySize(n);
-                return true; // we will decide when to call next
-            }
-            return false;
-        }, (err) => {
-            this.emit('error', err);
-        });
-        this.end = () => {
-            this.emit('beforeEnd');
-            // the rendering is finished; we should push out the last of the buffer.
-            this.done = true;
-            this.push(this.buffer);
-        };
-    }
-    pushBySize(n) {
-        const bufferToPush = this.buffer.substring(0, n);
-        this.buffer = this.buffer.substring(n);
-        this.push(bufferToPush);
-    }
-    tryRender() {
-        try {
-            this.render(this.write, this.end);
-        }
-        catch (e) {
-            this.emit('error', e);
-        }
-    }
-    tryNext() {
-        try {
-            this.next();
-        }
-        catch (e) {
-            this.emit('error', e);
-        }
-    }
-    _read(n) {
-        this.expectedSize = n;
-        // it's possible that the last chunk added bumped the buffer up to > 2 * n,
-        // which means we will need to go through multiple read calls to drain it
-        // down to < n.
-        if (isTrue(this.done)) {
-            this.push(null);
-            return;
-        }
-        if (this.buffer.length >= n) {
-            this.pushBySize(n);
-            return;
-        }
-        if (isUndef(this.next)) {
-            // start the rendering chain.
-            this.tryRender();
-        }
-        else {
-            // continue with the rendering.
-            this.tryNext();
-        }
-    }
-}
-
-class RenderContext {
-    userContext;
-    activeInstance;
-    renderStates;
-    write;
-    renderNode;
-    //@ts-expect-error
-    next;
-    done;
-    modules;
-    directives;
-    isUnaryTag;
-    cache;
-    get;
-    has;
-    constructor(options) {
-        this.userContext = options.userContext;
-        this.activeInstance = options.activeInstance;
-        this.renderStates = [];
-        this.write = options.write;
-        this.done = options.done;
-        this.renderNode = options.renderNode;
-        this.isUnaryTag = options.isUnaryTag;
-        this.modules = options.modules;
-        this.directives = options.directives;
-        const cache = options.cache;
-        if (cache && (!cache.get || !cache.set)) {
-            throw new Error('renderer cache must implement at least get & set.');
-        }
-        this.cache = cache;
-        this.get = cache && normalizeAsync(cache, 'get');
-        this.has = cache && normalizeAsync(cache, 'has');
-        //@ts-expect-error
-        this.next = this.next.bind(this);
-    }
-    //@ts-expect-error
-    next() {
-        // eslint-disable-next-line
-        while (true) {
-            const lastState = this.renderStates[this.renderStates.length - 1];
-            if (isUndef(lastState)) {
-                return this.done();
-            }
-            /* eslint-disable no-case-declarations */
-            switch (lastState.type) {
-                case 'Element':
-                case 'Fragment':
-                    const { children, total } = lastState;
-                    const rendered = lastState.rendered++;
-                    if (rendered < total) {
-                        return this.renderNode(children[rendered], false, this);
-                    }
-                    else {
-                        this.renderStates.pop();
-                        if (lastState.type === 'Element') {
-                            return this.write(lastState.endTag, this.next);
-                        }
-                    }
-                    break;
-                case 'Component':
-                    this.renderStates.pop();
-                    this.activeInstance = lastState.prevActive;
-                    break;
-                case 'ComponentWithCache':
-                    this.renderStates.pop();
-                    const { buffer, bufferIndex, componentBuffer, key } = lastState;
-                    const result = {
-                        html: buffer[bufferIndex],
-                        components: componentBuffer[bufferIndex],
-                    };
-                    this.cache.set(key, result);
-                    if (bufferIndex === 0) {
-                        // this is a top-level cached component,
-                        // exit caching mode.
-                        //@ts-expect-error
-                        this.write.caching = false;
-                    }
-                    else {
-                        // parent component is also being cached,
-                        // merge self into parent's result
-                        buffer[bufferIndex - 1] += result.html;
-                        const prev = componentBuffer[bufferIndex - 1];
-                        result.components.forEach((c) => prev.add(c));
-                    }
-                    buffer.length = bufferIndex;
-                    componentBuffer.length = bufferIndex;
-                    break;
-            }
-        }
-    }
-}
-function normalizeAsync(cache, method) {
-    const fn = cache[method];
-    if (isUndef(fn)) {
-        return;
-    }
-    else if (fn.length > 1) {
-        return (key, cb) => fn.call(cache, key, cb);
-    }
-    else {
-        return (key, cb) => cb(fn.call(cache, key));
-    }
-}
-
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
-}
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
-}
-
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
-}
-
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
-};
-
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
-};
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (!stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if ((i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
-}
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
-}
-
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he__default["default"].decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn$1;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn$1(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn: warn$1,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                warn$1('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        {
-            if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                {
-                    if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn$1(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
-}
-
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model$1 = {
-    preTransformNode,
-};
-
-var modules = [klass, style, model$1];
-
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
-
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
-}
-
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
-}
-
-var directives = {
-    model,
-    text,
-    html,
-};
-
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys(modules),
-};
-
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
-}
-
-function on(el, dir) {
-    if (dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-}
-
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
-}
-
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop$1,
-};
-
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate$1(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if ((el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate$1(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-}
-
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-    if (el.directives) {
-        for (let i = 0; i < el.directives.length; i++) {
-            const dir = el.directives[i];
-            if (dir.name === 'model') {
-                state.directives.model(el, dir, state.warn);
-                // remove value for textarea as its converted to text
-                if (el.tag === 'textarea' && el.props) {
-                    el.props = el.props.filter((p) => p.name !== 'value');
-                }
-                break;
-            }
-        }
-    }
-}
-function genAttrSegments(attrs) {
-    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-}
-function genDOMPropSegments(props, attrs) {
-    const segments = [];
-    props.forEach(({ name, value }) => {
-        name = propsToAttrMap[name] || name.toLowerCase();
-        if (isRenderableAttr(name) &&
-            !(attrs && attrs.some((a) => a.name === name))) {
-            segments.push(genAttrSegment(name, value));
-        }
-    });
-    return segments;
-}
-function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-        // force double quote
-        value = value.replace(/^'|'$/g, '"');
-        // force enumerated attr to "true"
-        if (isEnumeratedAttr(name) && value !== `"false"`) {
-            value = `"true"`;
-        }
-        return {
-            type: RAW,
-            value: isBooleanAttr(name)
-                ? ` ${name}="${name}"`
-                : value === '""'
-                    ? ` ${name}`
-                    : ` ${name}="${JSON.parse(value)}"`,
-        };
-    }
-    else {
-        return {
-            type: EXPRESSION,
-            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-        };
-    }
-}
-function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-            },
-        ];
-    }
-}
-function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-            },
-        ];
-    }
-}
-
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-const optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-};
-let isPlatformReservedTag;
-function optimize(root, options) {
-    if (!root)
-        return;
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-}
-function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-        node.ssrOptimizability = optimizability.FALSE;
-        return;
-    }
-    // root node or nodes with custom directives should always be a VNode
-    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-    const check = (child) => {
-        if (child.ssrOptimizability !== optimizability.FULL) {
-            node.ssrOptimizability = selfUnoptimizable
-                ? optimizability.PARTIAL
-                : optimizability.SELF;
-        }
-    };
-    if (selfUnoptimizable) {
-        node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            walk(child);
-            check(child);
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                walk(block, isRoot);
-                check(block);
-            }
-        }
-        if (node.ssrOptimizability == null ||
-            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-            node.ssrOptimizability = optimizability.FULL;
-        }
-        else {
-            node.children = optimizeSiblings(node);
-        }
-    }
-    else {
-        node.ssrOptimizability = optimizability.FULL;
-    }
-}
-function optimizeSiblings(el) {
-    const children = el.children;
-    const optimizedChildren = [];
-    let currentOptimizableGroup = [];
-    const pushGroup = () => {
-        if (currentOptimizableGroup.length) {
-            optimizedChildren.push({
-                type: 1,
-                parent: el,
-                tag: 'template',
-                attrsList: [],
-                attrsMap: {},
-                rawAttrsMap: {},
-                children: currentOptimizableGroup,
-                ssrOptimizability: optimizability.FULL,
-            });
-        }
-        currentOptimizableGroup = [];
-    };
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.ssrOptimizability === optimizability.FULL) {
-            currentOptimizableGroup.push(c);
-        }
-        else {
-            // wrap fully-optimizable adjacent siblings inside a template tag
-            // so that they can be optimized into a single ssrNode by codegen
-            pushGroup();
-            optimizedChildren.push(c);
-        }
-    }
-    pushGroup();
-    return optimizedChildren;
-}
-function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-        // text or expression
-        return false;
-    }
-    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag(node.tag) || // custom component
-        !!node.component || // "is" component
-        isSelectWithModel(node) // <select v-model> requires runtime inspection
-    );
-}
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-function hasCustomDirective(node) {
-    return (node.type === 1 &&
-        node.directives &&
-        node.directives.some((d) => !isBuiltInDir(d.name)));
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-    return (node.type === 1 &&
-        node.tag === 'select' &&
-        node.directives != null &&
-        node.directives.some((d) => d.name === 'model'));
-}
-
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-const RAW = 0;
-const INTERPOLATION = 1;
-const EXPRESSION = 2;
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genSSRElement);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state, genSSRElement);
-    }
-    else if (el.tag === 'template' && !el.slotTarget) {
-        return el.ssrOptimizability === optimizability.FULL
-            ? genChildrenAsStringNode(el, state)
-            : genSSRChildren(el, state) || 'void 0';
-    }
-    switch (el.ssrOptimizability) {
-        case optimizability.FULL:
-            // stringify whole tree
-            return genStringElement(el, state);
-        case optimizability.SELF:
-            // stringify self and check children
-            return genStringElementWithChildren(el, state);
-        case optimizability.CHILDREN:
-            // generate self as VNode and stringify children
-            return genNormalElement(el, state, true);
-        case optimizability.PARTIAL:
-            // generate self as VNode and check children
-            return genNormalElement(el, state, false);
-        default:
-            // bail whole tree
-            return genElement(el, state);
-    }
-}
-function genNormalElement(el, state, stringifyChildren) {
-    const data = el.plain ? undefined : genData(el, state);
-    const children = stringifyChildren
-        ? `[${genChildrenAsStringNode(el, state)}]`
-        : genSSRChildren(el, state, true);
-    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-}
-function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-}
-function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-}
-function genChildrenAsStringNode(el, state) {
-    return el.children.length
-        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-        : '';
-}
-function genStringElement(el, state) {
-    return `_ssrNode(${elementToString(el, state)})`;
-}
-function genStringElementWithChildren(el, state) {
-    const children = genSSRChildren(el, state, true);
-    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-}
-function elementToString(el, state) {
-    return `(${flattenSegments(elementToSegments(el, state))})`;
-}
-function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-        el.forProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genFor(el, state, elementToString, '_ssrList'),
-            },
-        ];
-    }
-    else if (el.if && !el.ifProcessed) {
-        el.ifProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genIf(el, state, elementToString, '"<!---->"'),
-            },
-        ];
-    }
-    else if (el.tag === 'template') {
-        return childrenToSegments(el, state);
-    }
-    const openSegments = elementToOpenTagSegments(el, state);
-    const childrenSegments = childrenToSegments(el, state);
-    const { isUnaryTag } = state.options;
-    const close = isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: `</${el.tag}>` }];
-    return openSegments.concat(childrenSegments, close);
-}
-function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state);
-    let binding;
-    const segments = [{ type: RAW, value: `<${el.tag}` }];
-    // attrs
-    if (el.attrs) {
-        segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-    }
-    segments.push({ type: RAW, value: `>` });
-    return segments;
-}
-function childrenToSegments(el, state) {
-    let binding;
-    if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    return el.children ? nodesToSegments(el.children, state) : [];
-}
-function nodesToSegments(children, state) {
-    const segments = [];
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.type === 1) {
-            segments.push.apply(segments, elementToSegments(c, state));
-        }
-        else if (c.type === 2) {
-            segments.push({ type: INTERPOLATION, value: c.expression });
-        }
-        else if (c.type === 3) {
-            let text = escape(c.text);
-            if (c.isComment) {
-                text = '<!--' + text + '-->';
-            }
-            segments.push({ type: RAW, value: text });
-        }
-    }
-    return segments;
-}
-function flattenSegments(segments) {
-    const mergedSegments = [];
-    let textBuffer = '';
-    const pushBuffer = () => {
-        if (textBuffer) {
-            mergedSegments.push(JSON.stringify(textBuffer));
-            textBuffer = '';
-        }
-    };
-    for (let i = 0; i < segments.length; i++) {
-        const s = segments[i];
-        if (s.type === RAW) {
-            textBuffer += s.value;
-        }
-        else if (s.type === INTERPOLATION) {
-            pushBuffer();
-            mergedSegments.push(`_ssrEscape(${s.value})`);
-        }
-        else if (s.type === EXPRESSION) {
-            pushBuffer();
-            mergedSegments.push(`(${s.value})`);
-        }
-    }
-    pushBuffer();
-    return mergedSegments.join('+');
-}
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
-}
-
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
-}
-
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop$1;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
-}
-
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
-}
-
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    optimize(ast, options);
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
-});
-
-const { compile: compile$1, compileToFunctions } = createCompiler(baseOptions);
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (let i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    const res = [];
-    let i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            continue;
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = `__vlist${nestedIndex}_${i}__`;
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-const ssrHelpers = {
-    _ssrEscape: escape,
-    _ssrNode: renderStringNode$1,
-    _ssrList: renderStringList,
-    _ssrAttr: renderAttr,
-    _ssrAttrs: renderAttrs,
-    _ssrDOMProps: renderDOMProps,
-    _ssrClass: renderSSRClass,
-    _ssrStyle: renderSSRStyle,
-};
-function installSSRHelpers(vm) {
-    if (vm._ssrNode) {
-        return;
-    }
-    let Vue = vm.constructor;
-    // @ts-expect-error
-    while (Vue.super) {
-        // @ts-expect-error
-        Vue = Vue.super;
-    }
-    extend(Vue.prototype, ssrHelpers);
-    // @ts-expect-error
-    if (Vue.FunctionalRenderContext) {
-        // @ts-expect-error
-        extend(Vue.FunctionalRenderContext.prototype, ssrHelpers);
-    }
-}
-class StringNode {
-    isString;
-    open;
-    close;
-    children;
-    constructor(open, close, children, normalizationType) {
-        this.isString = true;
-        this.open = open;
-        this.close = close;
-        if (children) {
-            this.children =
-                normalizationType === 1
-                    ? simpleNormalizeChildren(children)
-                    : normalizationType === 2
-                        ? normalizeChildren(children)
-                        : children;
-        }
-        else {
-            this.children = void 0;
-        }
-    }
-}
-function renderStringNode$1(open, close, children, normalizationType) {
-    return new StringNode(open, close, children, normalizationType);
-}
-function renderStringList(val, render) {
-    let ret = '';
-    let i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        for (i = 0, l = val.length; i < l; i++) {
-            ret += render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        for (i = 0; i < val; i++) {
-            ret += render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        keys = Object.keys(val);
-        for (i = 0, l = keys.length; i < l; i++) {
-            key = keys[i];
-            ret += render(val[key], key, i);
-        }
-    }
-    return ret;
-}
-function renderAttrs(obj) {
-    let res = '';
-    for (const key in obj) {
-        if (isSSRUnsafeAttr(key)) {
-            continue;
-        }
-        res += renderAttr(key, obj[key]);
-    }
-    return res;
-}
-function renderDOMProps(obj) {
-    let res = '';
-    for (const key in obj) {
-        const attr = propsToAttrMap[key] || key.toLowerCase();
-        if (isRenderableAttr(attr)) {
-            res += renderAttr(attr, obj[key]);
-        }
-    }
-    return res;
-}
-function renderSSRClass(staticClass, dynamic) {
-    const res = renderClass$1(staticClass, dynamic);
-    return res === '' ? res : ` class="${escape(res)}"`;
-}
-function renderSSRStyle(staticStyle, dynamic, extra) {
-    const style = {};
-    if (staticStyle)
-        extend(style, staticStyle);
-    if (dynamic)
-        extend(style, normalizeStyleBinding(dynamic));
-    if (extra)
-        extend(style, extra);
-    const res = genStyle(style);
-    return res === '' ? res : ` style=${JSON.stringify(escape(res))}`;
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-{
-    makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy) {
-        const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set(target, key, value) {
-                if (isBuiltInModifier(key)) {
-                    warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-}
-
-const seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    let i, keys;
-    const isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        const depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            _traverse(val[i], seen);
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            _traverse(val[keys[i]], seen);
-    }
-}
-
-const normalizeEvent = cached((name) => {
-    const passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    const once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    const capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name,
-        once,
-        capture,
-        passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        const fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            const cloned = fns.slice();
-            for (let i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`);
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`);
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    let name, cur, old, event;
-    for (name in on) {
-        cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        if (isUndef(cur)) {
-            warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    const propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    const res = {};
-    const { attrs, props } = data;
-    if (isDef(attrs) || isDef(props)) {
-        for (const key in propOptions) {
-            const altKey = hyphenate(key);
-            {
-                const keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip(`Prop "${keyInLowerCase}" is passed to component ` +
-                        `${formatComponentName(
-                        // @ts-expect-error tag is string
-                        tag || Ctor)}, but the declared prop name is` +
-                        ` "${key}". ` +
-                        `Note that HTML attributes are case-insensitive and camelCased ` +
-                        `props need to use their kebab-case equivalents when using in-DOM ` +
-                        `templates. You should probably use "${altKey}" instead of "${key}".`);
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-const SIMPLE_NORMALIZE = 1;
-const ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        warn$2(`Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        {
-            warn$2('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    let vnode, ns;
-    if (typeof tag === 'string') {
-        let Ctor;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            applyNS(vnode, ns);
-        if (isDef(data))
-            registerDeepBindings(data);
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (let i = 0, l = vnode.children.length; i < l; i++) {
-            const child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    let ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            const iterator = val[Symbol.iterator]();
-            let result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallbackRender, props, bindObject) {
-    const scopedSlotFn = this.$scopedSlots[name];
-    let nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (!isObject(bindObject)) {
-                warn$2("slot v-bind without argument expects an Object", this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes =
-            scopedSlotFn(props) ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    else {
-        nodes =
-            this.$slots[name] ||
-                (typeof fallbackRender === "function"
-                    ? fallbackRender()
-                    : fallbackRender);
-    }
-    const target = props && props.slot;
-    if (target) {
-        return this.$createElement("template", { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    const mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-    return eventKeyCode === undefined;
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            warn$2('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject(value);
-            }
-            let hash;
-            for (const key in value) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    const type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                const camelizedKey = camelize(key);
-                const hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        const on = data.on || (data.on = {});
-                        on[`update:${key}`] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    const cached = this._staticTrees || (this._staticTrees = []);
-    let tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, `__static__${index}`, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, `__once__${index}${key ? `_${key}` : ``}`, true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (let i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], `${key}_${i}`, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            warn$2('v-on without argument expects an Object value', this);
-        }
-        else {
-            const on = (data.on = data.on ? extend({}, data.on) : {});
-            for (const key in value) {
-                const existing = on[key];
-                const ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (let i = 0; i < fns.length; i++) {
-        const slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (let i = 0; i < values.length; i += 2) {
-        const key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn$2(`Invalid value for dynamic directive argument (expected string or null): ${key}`, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    const slots = {};
-    for (let i = 0, l = children.length; i < l; i++) {
-        const child = children[i];
-        const data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            const name = data.slot;
-            const slot = slots[name] || (slots[name] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (const name in slots) {
-        if (slots[name].every(isWhitespace)) {
-            delete slots[name];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    let res;
-    const hasNormalSlots = Object.keys(normalSlots).length > 0;
-    const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    const key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (const key in slots) {
-            if (slots[key] && key[0] !== "$") {
-                res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (const key in normalSlots) {
-        if (!(key in res)) {
-            res[key] = proxyNormalSlot(normalSlots, key);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, "$stable", isStable);
-    def(res, "$key", key);
-    def(res, "$hasNormal", hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    const normalized = function () {
-        let res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === "object" && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        const vnode = res && res[0];
-        return res &&
-            (!vnode ||
-                (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return () => slots[key];
-}
-
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    const node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data, context, children, tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-}
-
-let target;
-function add(event, fn) {
-    target.$on(event, fn);
-}
-function remove(event, fn) {
-    target.$off(event, fn);
-}
-function createOnceHandler(event, fn) {
-    const _target = target;
-    return function onceHandler() {
-        const res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target = vm;
-    updateListeners(listeners, oldListeners || {}, add, remove, createOnceHandler, vm);
-    target = undefined;
-}
-
-let activeInstance = null;
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    const newScopedSlots = parentVnode.data.scopedSlots;
-    const oldScopedSlots = vm.$scopedSlots;
-    const hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
-        (!newScopedSlots && vm.$scopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    const needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    vm.$options._parentVnode = parentVnode;
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        const props = vm._props;
-        const propKeys = vm.$options._propKeys || [];
-        for (let i = 0; i < propKeys.length; i++) {
-            const key = propKeys[i];
-            const propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    const oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            return true;
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (let i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook(vm, "activated");
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (let i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook(vm, "deactivated");
-    }
-}
-function callHook(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    const handlers = vm.$options[hook];
-    const info = `${hook} hook`;
-    if (handlers) {
-        for (let i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit("hook:" + hook);
-    }
-    popTarget();
-}
-
-// Async edge case fix requires storing an event listener's attach timestamp.
-let getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    const performance = window.performance;
-    if (performance &&
-        typeof performance.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = () => performance.now();
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-}
-
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        const result = Object.create(null);
-        const keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                continue;
-            const provideKey = inject[key].from;
-            let source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    const provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else {
-                    warn$2(`Injection "${key}" not found`, vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-function resolveConstructorOptions(Ctor) {
-    let options = Ctor.options;
-    if (Ctor.super) {
-        const superOptions = resolveConstructorOptions(Ctor.super);
-        const cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            const modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    let modified;
-    const latest = Ctor.options;
-    const sealed = Ctor.sealedOptions;
-    for (const key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                modified = {};
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    const options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    let contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    const isCompiled = isTrue(options._compiled);
-    const needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = () => {
-        if (!this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (this.$slots = resolveSlots(children, parent)));
-        }
-        return this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get() {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = (a, b, c, d) => {
-            const vnode = createElement(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = (a, b, c, d) => createElement(contextVm, a, b, c, d, needNormalization);
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    const options = Ctor.options;
-    const props = {};
-    const propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (const key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            mergeProps(props, data.attrs);
-        if (isDef(data.props))
-            mergeProps(props, data.props);
-    }
-    const renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    const vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        const vnodes = normalizeChildren(vnode) || [];
-        const res = new Array(vnodes.length);
-        for (let i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    const clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (const key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-const componentVNodeHooks = {
-    init(vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            const mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            const child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch(oldVnode, vnode) {
-        const options = vnode.componentOptions;
-        const child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert(vnode) {
-        const { context, componentInstance } = vnode;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy(vnode) {
-        const { componentInstance } = vnode;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-const hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    const baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        {
-            warn$2(`Invalid Component definition: ${String(Ctor)}`, context);
-        }
-        return;
-    }
-    // async component
-    let asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    const propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    const listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        const slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    const name = Ctor.options.name || tag;
-    const vnode = new VNode(
-    // @ts-expect-error
-    `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`, data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor, propsData, listeners, tag, children }, asyncFactory);
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    const options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent,
-    };
-    // check inline-template render functions
-    const inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    const hooks = data.hook || (data.hook = {});
-    for (let i = 0; i < hooksToMerge.length; i++) {
-        const key = hooksToMerge[i];
-        const existing = hooks[key];
-        const toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    const merged = (a, b) => {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    const prop = (options.model && options.model.prop) || 'value';
-    const event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    const on = data.on || (data.on = {});
-    const existing = on[event];
-    const callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-let warned = Object.create(null);
-const warnOnce = (msg) => {
-    if (!warned[msg]) {
-        warned[msg] = true;
-        // eslint-disable-next-line no-console
-        console.warn(`\n\u001b[31m${msg}\u001b[39m\n`);
-    }
-};
-const onCompilationError = (err, vm) => {
-    const trace = vm ? generateComponentTrace(vm) : '';
-    throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`);
-};
-const normalizeRender = (vm) => {
-    const { render, template, _scopeId } = vm.$options;
-    if (isUndef(render)) {
-        if (template) {
-            const compiled = compileToFunctions(template, {
-                scopeId: _scopeId,
-                warn: onCompilationError,
-            }, vm);
-            vm.$options.render = compiled.render;
-            vm.$options.staticRenderFns = compiled.staticRenderFns;
-        }
-        else {
-            throw new Error(`render function or template not defined in component: ${vm.$options.name || vm.$options._componentTag || 'anonymous'}`);
-        }
-    }
-};
-function waitForServerPrefetch(vm, resolve, reject) {
-    let handlers = vm.$options.serverPrefetch;
-    if (isDef(handlers)) {
-        if (!Array.isArray(handlers))
-            handlers = [handlers];
-        try {
-            const promises = [];
-            for (let i = 0, j = handlers.length; i < j; i++) {
-                const result = handlers[i].call(vm, vm);
-                if (result && typeof result.then === 'function') {
-                    promises.push(result);
-                }
-            }
-            Promise.all(promises).then(resolve).catch(reject);
-            return;
-        }
-        catch (e) {
-            reject(e);
-        }
-    }
-    resolve();
-}
-function renderNode(node, isRoot, context) {
-    if (node.isString) {
-        renderStringNode(node, context);
-    }
-    else if (isDef(node.componentOptions)) {
-        renderComponent(node, isRoot, context);
-    }
-    else if (isDef(node.tag)) {
-        renderElement(node, isRoot, context);
-    }
-    else if (isTrue(node.isComment)) {
-        if (isDef(node.asyncFactory)) {
-            // async component
-            renderAsyncComponent(node, isRoot, context);
-        }
-        else {
-            context.write(`<!--${node.text}-->`, context.next);
-        }
-    }
-    else {
-        context.write(node.raw ? node.text : escape(String(node.text)), context.next);
-    }
-}
-function registerComponentForCache(options, write) {
-    // exposed by vue-loader, need to call this if cache hit because
-    // component lifecycle hooks will not be called.
-    const register = options._ssrRegister;
-    if (write.caching && isDef(register)) {
-        write.componentBuffer[write.componentBuffer.length - 1].add(register);
-    }
-    return register;
-}
-function renderComponent(node, isRoot, context) {
-    const { write, next, userContext } = context;
-    // check cache hit
-    const Ctor = node.componentOptions.Ctor;
-    const getKey = Ctor.options.serverCacheKey;
-    const name = Ctor.options.name;
-    const cache = context.cache;
-    const registerComponent = registerComponentForCache(Ctor.options, write);
-    if (isDef(getKey) && isDef(cache) && isDef(name)) {
-        const rawKey = getKey(node.componentOptions.propsData);
-        if (rawKey === false) {
-            renderComponentInner(node, isRoot, context);
-            return;
-        }
-        const key = name + '::' + rawKey;
-        const { has, get } = context;
-        if (isDef(has)) {
-            has(key, (hit) => {
-                if (hit === true && isDef(get)) {
-                    get(key, (res) => {
-                        if (isDef(registerComponent)) {
-                            registerComponent(userContext);
-                        }
-                        res.components.forEach((register) => register(userContext));
-                        write(res.html, next);
-                    });
-                }
-                else {
-                    renderComponentWithCache(node, isRoot, key, context);
-                }
-            });
-        }
-        else if (isDef(get)) {
-            get(key, (res) => {
-                if (isDef(res)) {
-                    if (isDef(registerComponent)) {
-                        registerComponent(userContext);
-                    }
-                    res.components.forEach((register) => register(userContext));
-                    write(res.html, next);
-                }
-                else {
-                    renderComponentWithCache(node, isRoot, key, context);
-                }
-            });
-        }
-    }
-    else {
-        if (isDef(getKey) && isUndef(cache)) {
-            warnOnce(`[vue-server-renderer] Component ${Ctor.options.name || '(anonymous)'} implemented serverCacheKey, ` +
-                'but no cache was provided to the renderer.');
-        }
-        if (isDef(getKey) && isUndef(name)) {
-            warnOnce(`[vue-server-renderer] Components that implement "serverCacheKey" ` +
-                `must also define a unique "name" option.`);
-        }
-        renderComponentInner(node, isRoot, context);
-    }
-}
-function renderComponentWithCache(node, isRoot, key, context) {
-    const write = context.write;
-    write.caching = true;
-    const buffer = write.cacheBuffer;
-    const bufferIndex = buffer.push('') - 1;
-    const componentBuffer = write.componentBuffer;
-    componentBuffer.push(new Set());
-    context.renderStates.push({
-        type: 'ComponentWithCache',
-        key,
-        buffer,
-        bufferIndex,
-        componentBuffer,
-    });
-    renderComponentInner(node, isRoot, context);
-}
-function renderComponentInner(node, isRoot, context) {
-    const prevActive = context.activeInstance;
-    // expose userContext on vnode
-    node.ssrContext = context.userContext;
-    const child = (context.activeInstance = createComponentInstanceForVnode(node, context.activeInstance));
-    normalizeRender(child);
-    const resolve = () => {
-        const childNode = child._render();
-        childNode.parent = node;
-        context.renderStates.push({
-            type: 'Component',
-            prevActive,
-        });
-        renderNode(childNode, isRoot, context);
-    };
-    const reject = context.done;
-    waitForServerPrefetch(child, resolve, reject);
-}
-function renderAsyncComponent(node, isRoot, context) {
-    const factory = node.asyncFactory;
-    const resolve = (comp) => {
-        if (comp.__esModule && comp.default) {
-            comp = comp.default;
-        }
-        const { data, children, tag } = node.asyncMeta;
-        const nodeContext = node.asyncMeta.context;
-        const resolvedNode = createComponent(comp, data, nodeContext, children, tag);
-        if (resolvedNode) {
-            if (resolvedNode.componentOptions) {
-                // normal component
-                renderComponent(resolvedNode, isRoot, context);
-            }
-            else if (!Array.isArray(resolvedNode)) {
-                // single return node from functional component
-                renderNode(resolvedNode, isRoot, context);
-            }
-            else {
-                // multiple return nodes from functional component
-                context.renderStates.push({
-                    type: 'Fragment',
-                    children: resolvedNode,
-                    rendered: 0,
-                    total: resolvedNode.length,
-                });
-                context.next();
-            }
-        }
-        else {
-            // invalid component, but this does not throw on the client
-            // so render empty comment node
-            context.write(`<!---->`, context.next);
-        }
-    };
-    if (factory.resolved) {
-        resolve(factory.resolved);
-        return;
-    }
-    const reject = context.done;
-    let res;
-    try {
-        res = factory(resolve, reject);
-    }
-    catch (e) {
-        reject(e);
-    }
-    if (res) {
-        if (typeof res.then === 'function') {
-            res.then(resolve, reject).catch(reject);
-        }
-        else {
-            // new syntax in 2.3
-            const comp = res.component;
-            if (comp && typeof comp.then === 'function') {
-                comp.then(resolve, reject).catch(reject);
-            }
-        }
-    }
-}
-function renderStringNode(el, context) {
-    const { write, next } = context;
-    if (isUndef(el.children) || el.children.length === 0) {
-        write(el.open + (el.close || ''), next);
-    }
-    else {
-        const children = el.children;
-        context.renderStates.push({
-            type: 'Element',
-            children,
-            rendered: 0,
-            total: children.length,
-            endTag: el.close,
-        });
-        write(el.open, next);
-    }
-}
-function renderElement(el, isRoot, context) {
-    const { write, next } = context;
-    if (isTrue(isRoot)) {
-        if (!el.data)
-            el.data = {};
-        if (!el.data.attrs)
-            el.data.attrs = {};
-        el.data.attrs[SSR_ATTR] = 'true';
-    }
-    if (el.fnOptions) {
-        registerComponentForCache(el.fnOptions, write);
-    }
-    const startTag = renderStartingTag(el, context);
-    const endTag = `</${el.tag}>`;
-    if (context.isUnaryTag(el.tag)) {
-        write(startTag, next);
-    }
-    else if (isUndef(el.children) || el.children.length === 0) {
-        write(startTag + endTag, next);
-    }
-    else {
-        const children = el.children;
-        context.renderStates.push({
-            type: 'Element',
-            children,
-            rendered: 0,
-            total: children.length,
-            endTag,
-        });
-        write(startTag, next);
-    }
-}
-function hasAncestorData(node) {
-    const parentNode = node.parent;
-    return (isDef(parentNode) && (isDef(parentNode.data) || hasAncestorData(parentNode)));
-}
-function getVShowDirectiveInfo(node) {
-    let dir;
-    let tmp;
-    while (isDef(node)) {
-        if (node.data && node.data.directives) {
-            tmp = node.data.directives.find((dir) => dir.name === 'show');
-            if (tmp) {
-                dir = tmp;
-            }
-        }
-        node = node.parent;
-    }
-    //@ts-expect-error
-    return dir;
-}
-function renderStartingTag(node, context) {
-    let markup = `<${node.tag}`;
-    const { directives, modules } = context;
-    // construct synthetic data for module processing
-    // because modules like style also produce code by parent VNode data
-    if (isUndef(node.data) && hasAncestorData(node)) {
-        node.data = {};
-    }
-    if (isDef(node.data)) {
-        // check directives
-        const dirs = node.data.directives;
-        if (dirs) {
-            for (let i = 0; i < dirs.length; i++) {
-                const name = dirs[i].name;
-                if (name !== 'show') {
-                    const dirRenderer = resolveAsset(context, 'directives', name);
-                    if (dirRenderer) {
-                        // directives mutate the node's data
-                        // which then gets rendered by modules
-                        dirRenderer(node, dirs[i]);
-                    }
-                }
-            }
-        }
-        // v-show directive needs to be merged from parent to child
-        const vshowDirectiveInfo = getVShowDirectiveInfo(node);
-        if (vshowDirectiveInfo) {
-            directives.show(node, vshowDirectiveInfo);
-        }
-        // apply other modules
-        for (let i = 0; i < modules.length; i++) {
-            const res = modules[i](node);
-            if (res) {
-                markup += res;
-            }
-        }
-    }
-    // attach scoped CSS ID
-    let scopeId;
-    const activeInstance = context.activeInstance;
-    if (isDef(activeInstance) &&
-        activeInstance !== node.context &&
-        isDef((scopeId = activeInstance.$options._scopeId))) {
-        markup += ` ${scopeId}`;
-    }
-    if (isDef(node.fnScopeId)) {
-        markup += ` ${node.fnScopeId}`;
-    }
-    else {
-        while (isDef(node)) {
-            //@ts-expect-error
-            if (isDef((scopeId = node.context.$options._scopeId))) {
-                markup += ` ${scopeId}`;
-            }
-            node = node.parent;
-        }
-    }
-    return markup + '>';
-}
-function createRenderFunction(modules, directives, isUnaryTag, cache) {
-    return function render(component, write, userContext, done) {
-        warned = Object.create(null);
-        const context = new RenderContext({
-            activeInstance: component,
-            userContext,
-            write,
-            done,
-            renderNode,
-            isUnaryTag,
-            modules,
-            directives,
-            cache,
-        });
-        installSSRHelpers(component);
-        normalizeRender(component);
-        const resolve = () => {
-            renderNode(component._render(), true, context);
-        };
-        waitForServerPrefetch(component, resolve, done);
-    };
-}
-
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
-const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
-function createPromiseCallback() {
-    let resolve, reject;
-    const promise = new Promise((_resolve, _reject) => {
-        resolve = _resolve;
-        reject = _reject;
-    });
-    const cb = (err, res) => {
-        if (err)
-            return reject(err);
-        resolve(res || '');
-    };
-    return { promise, cb };
-}
-
-class TemplateStream extends stream.Transform {
-    started;
-    renderer;
-    template;
-    context;
-    inject;
-    constructor(renderer, template, context) {
-        super();
-        this.started = false;
-        this.renderer = renderer;
-        this.template = template;
-        this.context = context || {};
-        this.inject = renderer.inject;
-    }
-    _transform(data, encoding, done) {
-        if (!this.started) {
-            this.emit('beforeStart');
-            this.start();
-        }
-        this.push(data);
-        done();
-    }
-    start() {
-        this.started = true;
-        this.push(this.template.head(this.context));
-        if (this.inject) {
-            // inline server-rendered head meta information
-            if (this.context.head) {
-                this.push(this.context.head);
-            }
-            // inline preload/prefetch directives for initial/async chunks
-            const links = this.renderer.renderResourceHints(this.context);
-            if (links) {
-                this.push(links);
-            }
-            // CSS files and inline server-rendered CSS collected by vue-style-loader
-            const styles = this.renderer.renderStyles(this.context);
-            if (styles) {
-                this.push(styles);
-            }
-        }
-        this.push(this.template.neck(this.context));
-    }
-    _flush(done) {
-        this.emit('beforeEnd');
-        if (this.inject) {
-            // inline initial store state
-            const state = this.renderer.renderState(this.context);
-            if (state) {
-                this.push(state);
-            }
-            // embed scripts needed
-            const scripts = this.renderer.renderScripts(this.context);
-            if (scripts) {
-                this.push(scripts);
-            }
-        }
-        this.push(this.template.tail(this.context));
-        done();
-    }
-}
-
-const compile = require('lodash.template');
-const compileOptions = {
-    escape: /{{([^{][\s\S]+?[^}])}}/g,
-    interpolate: /{{{([\s\S]+?)}}}/g,
-};
-function parseTemplate(template, contentPlaceholder = '<!--vue-ssr-outlet-->') {
-    if (typeof template === 'object') {
-        return template;
-    }
-    let i = template.indexOf('</head>');
-    const j = template.indexOf(contentPlaceholder);
-    if (j < 0) {
-        throw new Error(`Content placeholder not found in template.`);
-    }
-    if (i < 0) {
-        i = template.indexOf('<body>');
-        if (i < 0) {
-            i = j;
-        }
-    }
-    return {
-        head: compile(template.slice(0, i), compileOptions),
-        neck: compile(template.slice(i, j), compileOptions),
-        tail: compile(template.slice(j + contentPlaceholder.length), compileOptions),
-    };
-}
-
-/**
- * Creates a mapper that maps components used during a server-side render
- * to async chunk files in the client-side build, so that we can inline them
- * directly in the rendered HTML to avoid waterfall requests.
- */
-function createMapper(clientManifest) {
-    const map = createMap(clientManifest);
-    // map server-side moduleIds to client-side files
-    return function mapper(moduleIds) {
-        const res = new Set();
-        for (let i = 0; i < moduleIds.length; i++) {
-            const mapped = map.get(moduleIds[i]);
-            if (mapped) {
-                for (let j = 0; j < mapped.length; j++) {
-                    res.add(mapped[j]);
-                }
-            }
-        }
-        return Array.from(res);
-    };
-}
-function createMap(clientManifest) {
-    const map = new Map();
-    Object.keys(clientManifest.modules).forEach((id) => {
-        map.set(id, mapIdToFile(id, clientManifest));
-    });
-    return map;
-}
-function mapIdToFile(id, clientManifest) {
-    const files = [];
-    const fileIndices = clientManifest.modules[id];
-    if (fileIndices) {
-        fileIndices.forEach((index) => {
-            const file = clientManifest.all[index];
-            // only include async files or non-js, non-css assets
-            if (file &&
-                (clientManifest.async.indexOf(file) > -1 ||
-                    !/\.(js|css)($|\?)/.test(file))) {
-                files.push(file);
-            }
-        });
-    }
-    return files;
-}
-
-const path$2 = require('path');
-const serialize = require('serialize-javascript');
-class TemplateRenderer {
-    options;
-    inject;
-    parsedTemplate;
-    //@ts-expect-error
-    publicPath;
-    //@ts-expect-error
-    clientManifest;
-    //@ts-expect-error
-    preloadFiles;
-    //@ts-expect-error
-    prefetchFiles;
-    //@ts-expect-error
-    mapFiles;
-    serialize;
-    constructor(options) {
-        this.options = options;
-        this.inject = options.inject !== false;
-        // if no template option is provided, the renderer is created
-        // as a utility object for rendering assets like preload links and scripts.
-        const { template } = options;
-        this.parsedTemplate = template
-            ? typeof template === 'string'
-                ? parseTemplate(template)
-                : template
-            : null;
-        // function used to serialize initial state JSON
-        this.serialize =
-            options.serializer ||
-                ((state) => {
-                    return serialize(state, { isJSON: true });
-                });
-        // extra functionality with client manifest
-        if (options.clientManifest) {
-            const clientManifest = (this.clientManifest = options.clientManifest);
-            // ensure publicPath ends with /
-            this.publicPath =
-                clientManifest.publicPath === ''
-                    ? ''
-                    : clientManifest.publicPath.replace(/([^\/])$/, '$1/');
-            // preload/prefetch directives
-            this.preloadFiles = (clientManifest.initial || []).map(normalizeFile);
-            this.prefetchFiles = (clientManifest.async || []).map(normalizeFile);
-            // initial async chunk mapping
-            this.mapFiles = createMapper(clientManifest);
-        }
-    }
-    bindRenderFns(context) {
-        const renderer = this;
-        ['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
-            context[`render${type}`] = renderer[`render${type}`].bind(renderer, context);
-        });
-        // also expose getPreloadFiles, useful for HTTP/2 push
-        context.getPreloadFiles = renderer.getPreloadFiles.bind(renderer, context);
-    }
-    // render synchronously given rendered app content and render context
-    render(content, context) {
-        const template = this.parsedTemplate;
-        if (!template) {
-            throw new Error('render cannot be called without a template.');
-        }
-        context = context || {};
-        if (typeof template === 'function') {
-            return template(content, context);
-        }
-        if (this.inject) {
-            return (template.head(context) +
-                (context.head || '') +
-                this.renderResourceHints(context) +
-                this.renderStyles(context) +
-                template.neck(context) +
-                content +
-                this.renderState(context) +
-                this.renderScripts(context) +
-                template.tail(context));
-        }
-        else {
-            return (template.head(context) +
-                template.neck(context) +
-                content +
-                template.tail(context));
-        }
-    }
-    renderStyles(context) {
-        const initial = this.preloadFiles || [];
-        const async = this.getUsedAsyncFiles(context) || [];
-        const cssFiles = initial.concat(async).filter(({ file }) => isCSS(file));
-        return (
-        // render links for css files
-        (cssFiles.length
-            ? cssFiles
-                .map(({ file }) => `<link rel="stylesheet" href="${this.publicPath}${file}">`)
-                .join('')
-            : '') +
-            // context.styles is a getter exposed by vue-style-loader which contains
-            // the inline component styles collected during SSR
-            (context.styles || ''));
-    }
-    renderResourceHints(context) {
-        return this.renderPreloadLinks(context) + this.renderPrefetchLinks(context);
-    }
-    getPreloadFiles(context) {
-        const usedAsyncFiles = this.getUsedAsyncFiles(context);
-        if (this.preloadFiles || usedAsyncFiles) {
-            return (this.preloadFiles || []).concat(usedAsyncFiles || []);
-        }
-        else {
-            return [];
-        }
-    }
-    renderPreloadLinks(context) {
-        const files = this.getPreloadFiles(context);
-        const shouldPreload = this.options.shouldPreload;
-        if (files.length) {
-            return files
-                .map(({ file, extension, fileWithoutQuery, asType }) => {
-                let extra = '';
-                // by default, we only preload scripts or css
-                if (!shouldPreload && asType !== 'script' && asType !== 'style') {
-                    return '';
-                }
-                // user wants to explicitly control what to preload
-                if (shouldPreload && !shouldPreload(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (asType === 'font') {
-                    extra = ` type="font/${extension}" crossorigin`;
-                }
-                return `<link rel="preload" href="${this.publicPath}${file}"${asType !== '' ? ` as="${asType}"` : ''}${extra}>`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    renderPrefetchLinks(context) {
-        const shouldPrefetch = this.options.shouldPrefetch;
-        if (this.prefetchFiles) {
-            const usedAsyncFiles = this.getUsedAsyncFiles(context);
-            const alreadyRendered = (file) => {
-                return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file);
-            };
-            return this.prefetchFiles
-                .map(({ file, fileWithoutQuery, asType }) => {
-                if (shouldPrefetch && !shouldPrefetch(fileWithoutQuery, asType)) {
-                    return '';
-                }
-                if (alreadyRendered(file)) {
-                    return '';
-                }
-                return `<link rel="prefetch" href="${this.publicPath}${file}">`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    renderState(context, options) {
-        const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } = options || {};
-        const state = this.serialize(context[contextKey]);
-        const autoRemove = '';
-        const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : '';
-        return context[contextKey]
-            ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
-            : '';
-    }
-    renderScripts(context) {
-        if (this.clientManifest) {
-            const initial = this.preloadFiles.filter(({ file }) => isJS(file));
-            const async = (this.getUsedAsyncFiles(context) || []).filter(({ file }) => isJS(file));
-            const needed = [initial[0]].concat(async, initial.slice(1));
-            return needed
-                .map(({ file }) => {
-                return `<script src="${this.publicPath}${file}" defer></script>`;
-            })
-                .join('');
-        }
-        else {
-            return '';
-        }
-    }
-    getUsedAsyncFiles(context) {
-        if (!context._mappedFiles &&
-            context._registeredComponents &&
-            this.mapFiles) {
-            const registered = Array.from(context._registeredComponents);
-            context._mappedFiles = this.mapFiles(registered).map(normalizeFile);
-        }
-        return context._mappedFiles;
-    }
-    // create a transform stream
-    createStream(context) {
-        if (!this.parsedTemplate) {
-            throw new Error('createStream cannot be called without a template.');
-        }
-        //@ts-expect-error
-        return new TemplateStream(this, this.parsedTemplate, context || {});
-    }
-}
-function normalizeFile(file) {
-    const withoutQuery = file.replace(/\?.*/, '');
-    const extension = path$2.extname(withoutQuery).slice(1);
-    return {
-        file,
-        extension,
-        fileWithoutQuery: withoutQuery,
-        asType: getPreloadType(extension),
-    };
-}
-function getPreloadType(ext) {
-    if (ext === 'js') {
-        return 'script';
-    }
-    else if (ext === 'css') {
-        return 'style';
-    }
-    else if (/jpe?g|png|svg|gif|webp|ico/.test(ext)) {
-        return 'image';
-    }
-    else if (/woff2?|ttf|otf|eot/.test(ext)) {
-        return 'font';
-    }
-    else {
-        // not exhausting all possibilities here, but above covers common cases
-        return '';
-    }
-}
-
-function createRenderer$1({ modules = [], directives = {}, isUnaryTag = () => false, template, inject, cache, shouldPreload, shouldPrefetch, clientManifest, serializer, } = {}) {
-    const render = createRenderFunction(modules, directives, isUnaryTag, cache);
-    const templateRenderer = new TemplateRenderer({
-        template,
-        inject,
-        // @ts-expect-error
-        shouldPreload,
-        // @ts-expect-error
-        shouldPrefetch,
-        clientManifest,
-        serializer,
-    });
-    return {
-        renderToString(component, context, cb) {
-            if (typeof context === 'function') {
-                cb = context;
-                context = {};
-            }
-            if (context) {
-                templateRenderer.bindRenderFns(context);
-            }
-            // no callback, return Promise
-            let promise;
-            if (!cb) {
-                ({ promise, cb } = createPromiseCallback());
-            }
-            let result = '';
-            const write = createWriteFunction((text) => {
-                result += text;
-                return false;
-            }, cb);
-            try {
-                // @ts-expect-error TODO improve
-                render(component, write, context, (err) => {
-                    if (err) {
-                        return cb(err);
-                    }
-                    if (context && context.rendered) {
-                        context.rendered(context);
-                    }
-                    if (template) {
-                        try {
-                            const res = templateRenderer.render(result, context);
-                            if (typeof res !== 'string') {
-                                // function template returning promise
-                                res.then((html) => cb(null, html)).catch(cb);
-                            }
-                            else {
-                                cb(null, res);
-                            }
-                        }
-                        catch (e) {
-                            cb(e);
-                        }
-                    }
-                    else {
-                        cb(null, result);
-                    }
-                });
-            }
-            catch (e) {
-                cb(e);
-            }
-            return promise;
-        },
-        renderToStream(component, context) {
-            if (context) {
-                templateRenderer.bindRenderFns(context);
-            }
-            const renderStream = new RenderStream((write, done) => {
-                // @ts-expect-error
-                render(component, write, context, done);
-            });
-            if (!template) {
-                // @ts-expect-error
-                if (context && context.rendered) {
-                    // @ts-expect-error
-                    const rendered = context.rendered;
-                    renderStream.once('beforeEnd', () => {
-                        rendered(context);
-                    });
-                }
-                return renderStream;
-            }
-            else if (typeof template === 'function') {
-                throw new Error(`function template is only supported in renderToString.`);
-            }
-            else {
-                const templateStream = templateRenderer.createStream(context);
-                renderStream.on('error', (err) => {
-                    templateStream.emit('error', err);
-                });
-                renderStream.pipe(templateStream);
-                //@ts-expect-error
-                if (context && context.rendered) {
-                    //@ts-expect-error
-                    const rendered = context.rendered;
-                    renderStream.once('beforeEnd', () => {
-                        rendered(context);
-                    });
-                }
-                return templateStream;
-            }
-        },
-    };
-}
-
-const vm = require('vm');
-const path$1 = require('path');
-const resolve = require('resolve');
-const NativeModule = require('module');
-function createSandbox(context) {
-    const sandbox = {
-        Buffer,
-        console,
-        process,
-        setTimeout,
-        setInterval,
-        setImmediate,
-        clearTimeout,
-        clearInterval,
-        clearImmediate,
-        __VUE_SSR_CONTEXT__: context,
-    };
-    // @ts-expect-error
-    sandbox.global = sandbox;
-    return sandbox;
-}
-function compileModule(files, basedir, runInNewContext) {
-    const compiledScripts = {};
-    const resolvedModules = {};
-    function getCompiledScript(filename) {
-        if (compiledScripts[filename]) {
-            return compiledScripts[filename];
-        }
-        const code = files[filename];
-        const wrapper = NativeModule.wrap(code);
-        const script = new vm.Script(wrapper, {
-            filename,
-            displayErrors: true,
-        });
-        compiledScripts[filename] = script;
-        return script;
-    }
-    function evaluateModule(filename, sandbox, evaluatedFiles = {}) {
-        if (evaluatedFiles[filename]) {
-            return evaluatedFiles[filename];
-        }
-        const script = getCompiledScript(filename);
-        const compiledWrapper = runInNewContext === false
-            ? script.runInThisContext()
-            : script.runInNewContext(sandbox);
-        const m = { exports: {} };
-        const r = (file) => {
-            file = path$1.posix.join('.', file);
-            if (files[file]) {
-                return evaluateModule(file, sandbox, evaluatedFiles);
-            }
-            else if (basedir) {
-                return require(resolvedModules[file] ||
-                    (resolvedModules[file] = resolve.sync(file, { basedir })));
-            }
-            else {
-                return require(file);
-            }
-        };
-        compiledWrapper.call(m.exports, m.exports, r, m);
-        const res = Object.prototype.hasOwnProperty.call(m.exports, 'default')
-            ? // @ts-expect-error
-                m.exports.default
-            : m.exports;
-        evaluatedFiles[filename] = res;
-        return res;
-    }
-    return evaluateModule;
-}
-function deepClone(val) {
-    if (isPlainObject(val)) {
-        const res = {};
-        for (const key in val) {
-            res[key] = deepClone(val[key]);
-        }
-        return res;
-    }
-    else if (Array.isArray(val)) {
-        return val.slice();
-    }
-    else {
-        return val;
-    }
-}
-function createBundleRunner(entry, files, basedir, runInNewContext) {
-    const evaluate = compileModule(files, basedir, runInNewContext);
-    if (runInNewContext !== false && runInNewContext !== 'once') {
-        // new context mode: creates a fresh context and re-evaluate the bundle
-        // on each render. Ensures entire application state is fresh for each
-        // render, but incurs extra evaluation cost.
-        return (userContext = {}) => new Promise((resolve) => {
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            const res = evaluate(entry, createSandbox(userContext));
-            resolve(typeof res === 'function' ? res(userContext) : res);
-        });
-    }
-    else {
-        // direct mode: instead of re-evaluating the whole bundle on
-        // each render, it simply calls the exported function. This avoids the
-        // module evaluation costs but requires the source code to be structured
-        // slightly differently.
-        let runner; // lazy creation so that errors can be caught by user
-        let initialContext;
-        return (userContext = {}) => new Promise((resolve) => {
-            if (!runner) {
-                const sandbox = runInNewContext === 'once' ? createSandbox() : global;
-                // the initial context is only used for collecting possible non-component
-                // styles injected by vue-style-loader.
-                // @ts-expect-error
-                initialContext = sandbox.__VUE_SSR_CONTEXT__ = {};
-                runner = evaluate(entry, sandbox);
-                // On subsequent renders, __VUE_SSR_CONTEXT__ will not be available
-                // to prevent cross-request pollution.
-                // @ts-expect-error
-                delete sandbox.__VUE_SSR_CONTEXT__;
-                if (typeof runner !== 'function') {
-                    throw new Error('bundle export should be a function when using ' +
-                        '{ runInNewContext: false }.');
-                }
-            }
-            // @ts-expect-error
-            userContext._registeredComponents = new Set();
-            // vue-style-loader styles imported outside of component lifecycle hooks
-            if (initialContext._styles) {
-                // @ts-expect-error
-                userContext._styles = deepClone(initialContext._styles);
-                // #6353 ensure "styles" is exposed even if no styles are injected
-                // in component lifecycles.
-                // the renderStyles fn is exposed by vue-style-loader >= 3.0.3
-                const renderStyles = initialContext._renderStyles;
-                if (renderStyles) {
-                    Object.defineProperty(userContext, 'styles', {
-                        enumerable: true,
-                        get() {
-                            // @ts-expect-error
-                            return renderStyles(userContext._styles);
-                        },
-                    });
-                }
-            }
-            resolve(runner(userContext));
-        });
-    }
-}
-
-const SourceMapConsumer = require('source-map').SourceMapConsumer;
-const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/;
-function createSourceMapConsumers(rawMaps) {
-    const maps = {};
-    Object.keys(rawMaps).forEach((file) => {
-        maps[file] = new SourceMapConsumer(rawMaps[file]);
-    });
-    return maps;
-}
-function rewriteErrorTrace(e, mapConsumers) {
-    if (e && typeof e.stack === 'string') {
-        e.stack = e.stack
-            .split('\n')
-            .map((line) => {
-            return rewriteTraceLine(line, mapConsumers);
-        })
-            .join('\n');
-    }
-}
-function rewriteTraceLine(trace, mapConsumers) {
-    const m = trace.match(filenameRE);
-    const map = m && mapConsumers[m[1]];
-    if (m != null && map) {
-        const originalPosition = map.originalPositionFor({
-            line: Number(m[2]),
-            column: Number(m[3]),
-        });
-        if (originalPosition.source != null) {
-            const { source, line, column } = originalPosition;
-            const mappedPosition = `(${source.replace(/^webpack:\/\/\//, '')}:${String(line)}:${String(column)})`;
-            return trace.replace(filenameRE, mappedPosition);
-        }
-        else {
-            return trace;
-        }
-    }
-    else {
-        return trace;
-    }
-}
-
-const fs = require('fs');
-const path = require('path');
-const PassThrough = require('stream').PassThrough;
-const INVALID_MSG = 'Invalid server-rendering bundle format. Should be a string ' +
-    'or a bundle Object of type:\n\n' +
-    `{
-  entry: string;
-  files: { [filename: string]: string; };
-  maps: { [filename: string]: string; };
-}\n`;
-function createBundleRendererCreator(createRenderer) {
-    return function createBundleRenderer(bundle, rendererOptions = {}) {
-        let files, entry, maps;
-        let basedir = rendererOptions.basedir;
-        // load bundle if given filepath
-        if (typeof bundle === 'string' &&
-            /\.js(on)?$/.test(bundle) &&
-            path.isAbsolute(bundle)) {
-            if (fs.existsSync(bundle)) {
-                const isJSON = /\.json$/.test(bundle);
-                basedir = basedir || path.dirname(bundle);
-                bundle = fs.readFileSync(bundle, 'utf-8');
-                if (isJSON) {
-                    try {
-                        // @ts-expect-error
-                        bundle = JSON.parse(bundle);
-                    }
-                    catch (e) {
-                        throw new Error(`Invalid JSON bundle file: ${bundle}`);
-                    }
-                }
-            }
-            else {
-                throw new Error(`Cannot locate bundle file: ${bundle}`);
-            }
-        }
-        if (typeof bundle === 'object') {
-            entry = bundle.entry;
-            files = bundle.files;
-            basedir = basedir || bundle.basedir;
-            maps = createSourceMapConsumers(bundle.maps);
-            if (typeof entry !== 'string' || typeof files !== 'object') {
-                throw new Error(INVALID_MSG);
-            }
-        }
-        else if (typeof bundle === 'string') {
-            entry = '__vue_ssr_bundle__';
-            files = { __vue_ssr_bundle__: bundle };
-            maps = {};
-        }
-        else {
-            throw new Error(INVALID_MSG);
-        }
-        const renderer = createRenderer(rendererOptions);
-        const run = createBundleRunner(entry, files, basedir, rendererOptions.runInNewContext);
-        return {
-            renderToString: (context, cb) => {
-                if (typeof context === 'function') {
-                    cb = context;
-                    context = {};
-                }
-                let promise;
-                if (!cb) {
-                    ({ promise, cb } = createPromiseCallback());
-                }
-                run(context)
-                    .catch((err) => {
-                    rewriteErrorTrace(err, maps);
-                    cb(err);
-                })
-                    .then((app) => {
-                    if (app) {
-                        //@ts-expect-error
-                        renderer.renderToString(app, context, (err, res) => {
-                            rewriteErrorTrace(err, maps);
-                            cb(err, res);
-                        });
-                    }
-                });
-                return promise;
-            },
-            renderToStream: (context) => {
-                const res = new PassThrough();
-                run(context)
-                    .catch((err) => {
-                    rewriteErrorTrace(err, maps);
-                    // avoid emitting synchronously before user can
-                    // attach error listener
-                    process.nextTick(() => {
-                        res.emit('error', err);
-                    });
-                })
-                    .then((app) => {
-                    if (app) {
-                        //@ts-expect-error
-                        const renderStream = renderer.renderToStream(app, context);
-                        renderStream.on('error', (err) => {
-                            rewriteErrorTrace(err, maps);
-                            res.emit('error', err);
-                        });
-                        // relay HTMLStream special events
-                        if (rendererOptions && rendererOptions.template) {
-                            renderStream.on('beforeStart', () => {
-                                res.emit('beforeStart');
-                            });
-                            renderStream.on('beforeEnd', () => {
-                                res.emit('beforeEnd');
-                            });
-                        }
-                        renderStream.pipe(res);
-                    }
-                });
-                return res;
-            },
-        };
-    };
-}
-
-process.env.VUE_ENV = 'server';
-function createRenderer(options = {}) {
-    return createRenderer$1(extend(extend({}, options), {
-        isUnaryTag,
-        canBeLeftOpenTag,
-        modules: modules$1,
-        // user can provide server-side implementations for custom directives
-        // when creating the renderer.
-        directives: extend(baseDirectives$1, options.directives),
-    }));
-}
-const createBundleRenderer = createBundleRendererCreator(createRenderer);
-
-exports.createBundleRenderer = createBundleRenderer;
-exports.createRenderer = createRenderer;
diff --git a/packages/vue-server-renderer/build.prod.js b/packages/vue-server-renderer/build.prod.js
deleted file mode 100644
index 76d741da6b6..00000000000
--- a/packages/vue-server-renderer/build.prod.js
+++ /dev/null
@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("stream");function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var n=t(require("he"));const r=Object.freeze({});function s(e){return null==e}function o(e){return null!=e}function i(e){return!0===e}function c(e){return"string"==typeof e||"number"==typeof e||"symbol"==typeof e||"boolean"==typeof e}function a(e){return null!==e&&"object"==typeof e}const l=Object.prototype.toString;function u(e){return"[object Object]"===l.call(e)}function f(e){return null==e?"":Array.isArray(e)||u(e)&&e.toString===l?JSON.stringify(e,null,2):String(e)}function p(e){const t=parseFloat(e);return isNaN(t)?e:t}function d(e,t){const n=Object.create(null),r=e.split(",");for(let e=0;e<r.length;e++)n[r[e]]=!0;return t?e=>n[e.toLowerCase()]:e=>n[e]}const h=d("slot,component",!0),m=d("key,ref,slot,slot-scope,is");const y=Object.prototype.hasOwnProperty;function g(e,t){return y.call(e,t)}function $(e){const t=Object.create(null);return function(n){return t[n]||(t[n]=e(n))}}const v=/-(\w)/g,b=$((e=>e.replace(v,((e,t)=>t?t.toUpperCase():"")))),_=$((e=>e.charAt(0).toUpperCase()+e.slice(1))),x=/\B([A-Z])/g,w=$((e=>e.replace(x,"-$1").toLowerCase()));function S(e,t){for(const n in t)e[n]=t[n];return e}function k(e){const t={};for(let n=0;n<e.length;n++)e[n]&&S(t,e[n]);return t}function A(e,t,n){}const O=(e,t,n)=>!1,C=e=>e;function T(e,t){if(e===t)return!0;const n=a(e),r=a(t);if(!n||!r)return!n&&!r&&String(e)===String(t);try{const n=Array.isArray(e),r=Array.isArray(t);if(n&&r)return e.length===t.length&&e.every(((e,n)=>T(e,t[n])));if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(n||r)return!1;{const n=Object.keys(e),r=Object.keys(t);return n.length===r.length&&n.every((n=>T(e[n],t[n])))}}catch(e){return!1}}function j(e,t){for(let n=0;n<e.length;n++)if(T(e[n],t))return n;return-1}const F=d("accept,accept-charset,accesskey,action,align,alt,async,autocomplete,autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,data,datetime,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,usemap,value,width,wrap"),P=/[>/="'\u0009\u000a\u000c\u0020]/,N=e=>P.test(e),E=e=>F(e)||0===e.indexOf("data-")||0===e.indexOf("aria-"),I={acceptCharset:"accept-charset",className:"class",htmlFor:"for",httpEquiv:"http-equiv"},M={"<":"&lt;",">":"&gt;",'"':"&quot;","&":"&amp;"};function R(e){return e.replace(/[<>"&]/g,D)}function D(e){return M[e]||e}const L={"animation-iteration-count":!0,"border-image-outset":!0,"border-image-slice":!0,"border-image-width":!0,"box-flex":!0,"box-flex-group":!0,"box-ordinal-group":!0,"column-count":!0,columns:!0,flex:!0,"flex-grow":!0,"flex-positive":!0,"flex-shrink":!0,"flex-negative":!0,"flex-order":!0,"grid-row":!0,"grid-row-end":!0,"grid-row-span":!0,"grid-row-start":!0,"grid-column":!0,"grid-column-end":!0,"grid-column-span":!0,"grid-column-start":!0,"font-weight":!0,"line-clamp":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"tab-size":!0,widows:!0,"z-index":!0,zoom:!0,"fill-opacity":!0,"flood-opacity":!0,"stop-opacity":!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,"stroke-miterlimit":!0,"stroke-opacity":!0,"stroke-width":!0},z=d("input,textarea,option,select,progress"),B=d("contenteditable,draggable,spellcheck"),U=d("events,caret,typing,plaintext-only"),q=d("allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,defaultchecked,defaultmuted,defaultselected,defer,disabled,enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,truespeed,typemustmatch,visible"),J=e=>null==e||!1===e;function K(e,t){if(q(e)){if(!J(t))return` ${e}="${e}"`}else{if(B(e))return` ${e}="${R(((e,t)=>J(t)||"false"===t?"false":"contenteditable"===e&&U(t)?t:"true")(e,t))}"`;if(!J(t))return` ${e}="${R(String(t))}"`}return""}class H{tag;data;children;text;elm;ns;context;key;componentOptions;componentInstance;parent;raw;isStatic;isRootInsert;isComment;isCloned;isOnce;asyncFactory;asyncMeta;isAsyncPlaceholder;ssrContext;fnContext;fnOptions;devtoolsMeta;fnScopeId;constructor(e,t,n,r,s,o,i,c){this.tag=e,this.data=t,this.children=n,this.text=r,this.elm=s,this.ns=void 0,this.context=o,this.fnContext=void 0,this.fnOptions=void 0,this.fnScopeId=void 0,this.key=t&&t.key,this.componentOptions=i,this.componentInstance=void 0,this.parent=void 0,this.raw=!1,this.isStatic=!1,this.isRootInsert=!0,this.isComment=!1,this.isCloned=!1,this.isOnce=!1,this.asyncFactory=c,this.asyncMeta=void 0,this.isAsyncPlaceholder=!1}get child(){return this.componentInstance}}const V=(e="")=>{const t=new H;return t.text=e,t.isComment=!0,t};function W(e){return new H(void 0,void 0,void 0,String(e))}function Z(e,t,n){const r=new H(void 0,void 0,void 0,t);r.raw=n,e.children=[r]}function X(e,t,n,r){Object.defineProperty(e,t,{value:n,enumerable:!!r,writable:!0,configurable:!0})}const G="__proto__"in{},Q="undefined"!=typeof window,Y="undefined"!=typeof WXEnvironment&&!!WXEnvironment.platform,ee=(Y&&WXEnvironment.platform.toLowerCase(),Q&&window.navigator.userAgent.toLowerCase()),te=ee&&/msie|trident/.test(ee);ee&&ee.indexOf("msie 9.0");ee&&ee.indexOf("edge/");ee&&ee.indexOf("android"),ee&&/iphone|ipad|ipod|ios/.test(ee),ee&&/chrome\/\d+/.test(ee),ee&&/phantomjs/.test(ee),ee&&ee.match(/firefox\/(\d+)/);const ne={}.watch;let re,se=!1;if(Q)try{const e={};Object.defineProperty(e,"passive",{get(){se=!0}}),window.addEventListener("test-passive",null,e)}catch(e){}const oe=()=>(void 0===re&&(re=!Q&&!Y&&"undefined"!=typeof global&&(global.process&&"server"===global.process.env.VUE_ENV)),re);function ie(e){return"function"==typeof e&&/native code/.test(e.toString())}const ce="undefined"!=typeof Symbol&&ie(Symbol)&&"undefined"!=typeof Reflect&&ie(Reflect.ownKeys);let ae;ae="undefined"!=typeof Set&&ie(Set)?Set:class{set=Object.create(null);has(e){return!0===this.set[e]}add(e){this.set[e]=!0}clear(){this.set=Object.create(null)}};const le=["beforeCreate","created","beforeMount","mounted","beforeUpdate","updated","beforeDestroy","destroyed","activated","deactivated","errorCaptured","serverPrefetch"];var ue={optionMergeStrategies:Object.create(null),silent:!1,productionTip:!1,devtools:!1,performance:!1,errorHandler:null,warnHandler:null,ignoredElements:[],keyCodes:Object.create(null),isReservedTag:O,isReservedAttr:O,isUnknownElement:O,getTagNamespace:A,parsePlatformTagName:C,mustUseProp:O,async:!0,_lifecycleHooks:le};let fe=0;class pe{static target;id;subs;constructor(){this.id=fe++,this.subs=[]}addSub(e){this.subs.push(e)}removeSub(e){!function(e,t){if(e.length){const n=e.indexOf(t);if(n>-1)e.splice(n,1)}}(this.subs,e)}depend(){pe.target&&pe.target.addDep(this)}notify(){const e=this.subs.slice();for(let t=0,n=e.length;t<n;t++)e[t].update()}}pe.target=null;const de=[];function he(e){de.push(e),pe.target=e}function me(){de.pop(),pe.target=de[de.length-1]}const ye=Array.prototype,ge=Object.create(ye);["push","pop","shift","unshift","splice","sort","reverse"].forEach((function(e){const t=ye[e];X(ge,e,(function(...n){const r=t.apply(this,n),s=this.__ob__;let o;switch(e){case"push":case"unshift":o=n;break;case"splice":o=n.slice(2)}return o&&s.observeArray(o),s.dep.notify(),r}))}));const $e=Object.getOwnPropertyNames(ge);let ve=!0;function be(e){ve=e}class _e{value;dep;vmCount;constructor(e){this.value=e,this.dep=new pe,this.vmCount=0,X(e,"__ob__",this),Array.isArray(e)?(G?function(e,t){e.__proto__=t}(e,ge):function(e,t,n){for(let r=0,s=n.length;r<s;r++){const s=n[r];X(e,s,t[s])}}(e,ge,$e),this.observeArray(e)):this.walk(e)}walk(e){const t=Object.keys(e);for(let n=0;n<t.length;n++)we(e,t[n])}observeArray(e){for(let t=0,n=e.length;t<n;t++)xe(e[t])}}function xe(e,t){if(!a(e)||e instanceof H)return;let n;return g(e,"__ob__")&&e.__ob__ instanceof _e?n=e.__ob__:ve&&!oe()&&(Array.isArray(e)||u(e))&&Object.isExtensible(e)&&!e._isVue&&(n=new _e(e)),t&&n&&n.vmCount++,n}function we(e,t,n,r,s){const o=new pe,i=Object.getOwnPropertyDescriptor(e,t);if(i&&!1===i.configurable)return;const c=i&&i.get,a=i&&i.set;c&&!a||2!==arguments.length||(n=e[t]);let l=!s&&xe(n);Object.defineProperty(e,t,{enumerable:!0,configurable:!0,get:function(){const t=c?c.call(e):n;return pe.target&&(o.depend(),l&&(l.dep.depend(),Array.isArray(t)&&ke(t))),t},set:function(t){const r=c?c.call(e):n;t===r||t!=t&&r!=r||c&&!a||(a?a.call(e,t):n=t,l=!s&&xe(t),o.notify())}})}function Se(e,t,n){if(Array.isArray(e)&&function(e){const t=parseFloat(String(e));return t>=0&&Math.floor(t)===t&&isFinite(e)}(t))return e.length=Math.max(e.length,t),e.splice(t,1,n),n;if(t in e&&!(t in Object.prototype))return e[t]=n,n;const r=e.__ob__;return e._isVue||r&&r.vmCount?n:r?(we(r.value,t,n),r.dep.notify(),n):(e[t]=n,n)}function ke(e){for(let t,n=0,r=e.length;n<r;n++)t=e[n],t&&t.__ob__&&t.__ob__.dep.depend(),Array.isArray(t)&&ke(t)}const Ae=ue.optionMergeStrategies;function Oe(e,t){if(!t)return e;let n,r,s;const o=ce?Reflect.ownKeys(t):Object.keys(t);for(let i=0;i<o.length;i++)n=o[i],"__ob__"!==n&&(r=e[n],s=t[n],g(e,n)?r!==s&&u(r)&&u(s)&&Oe(r,s):Se(e,n,s));return e}function Ce(e,t,n){return n?function(){const r="function"==typeof t?t.call(n,n):t,s="function"==typeof e?e.call(n,n):e;return r?Oe(r,s):s}:t?e?function(){return Oe("function"==typeof t?t.call(this,this):t,"function"==typeof e?e.call(this,this):e)}:t:e}function Te(e,t){const n=t?e?e.concat(t):Array.isArray(t)?t:[t]:e;return n?function(e){const t=[];for(let n=0;n<e.length;n++)-1===t.indexOf(e[n])&&t.push(e[n]);return t}(n):n}function je(e,t,n,r){const s=Object.create(e||null);return t?S(s,t):s}Ae.data=function(e,t,n){return n?Ce(e,t,n):t&&"function"!=typeof t?e:Ce(e,t)},le.forEach((e=>{Ae[e]=Te})),["component","directive","filter"].forEach((function(e){Ae[e+"s"]=je})),Ae.watch=function(e,t,n,r){if(e===ne&&(e=void 0),t===ne&&(t=void 0),!t)return Object.create(e||null);if(!e)return t;const s={};S(s,e);for(const e in t){let n=s[e];const r=t[e];n&&!Array.isArray(n)&&(n=[n]),s[e]=n?n.concat(r):Array.isArray(r)?r:[r]}return s},Ae.props=Ae.methods=Ae.inject=Ae.computed=function(e,t,n,r){if(!e)return t;const s=Object.create(null);return S(s,e),t&&S(s,t),s},Ae.provide=Ce;const Fe=function(e,t){return void 0===t?e:t};function Pe(e,t,n){if("function"==typeof t&&(t=t.options),function(e,t){const n=e.props;if(!n)return;const r={};let s,o,i;if(Array.isArray(n))for(s=n.length;s--;)o=n[s],"string"==typeof o&&(i=b(o),r[i]={type:null});else if(u(n))for(const e in n)o=n[e],i=b(e),r[i]=u(o)?o:{type:o};e.props=r}(t),function(e,t){const n=e.inject;if(!n)return;const r=e.inject={};if(Array.isArray(n))for(let e=0;e<n.length;e++)r[n[e]]={from:n[e]};else if(u(n))for(const e in n){const t=n[e];r[e]=u(t)?S({from:e},t):{from:t}}}(t),function(e){const t=e.directives;if(t)for(const e in t){const n=t[e];"function"==typeof n&&(t[e]={bind:n,update:n})}}(t),!t._base&&(t.extends&&(e=Pe(e,t.extends,n)),t.mixins))for(let r=0,s=t.mixins.length;r<s;r++)e=Pe(e,t.mixins[r],n);const r={};let s;for(s in e)o(s);for(s in t)g(e,s)||o(s);function o(s){const o=Ae[s]||Fe;r[s]=o(e[s],t[s],n,s)}return r}function Ne(e,t,n,r){if("string"!=typeof n)return;const s=e[t];if(g(s,n))return s[n];const o=b(n);if(g(s,o))return s[o];const i=_(o);if(g(s,i))return s[i];return s[n]||s[o]||s[i]}function Ee(e,t,n,r){const s=t[e],o=!g(n,e);let i=n[e];const c=De(Boolean,s.type);if(c>-1)if(o&&!g(s,"default"))i=!1;else if(""===i||i===w(e)){const e=De(String,s.type);(e<0||c<e)&&(i=!0)}if(void 0===i){i=function(e,t,n){if(!g(t,"default"))return;const r=t.default;if(e&&e.$options.propsData&&void 0===e.$options.propsData[n]&&void 0!==e._props[n])return e._props[n];return"function"==typeof r&&"Function"!==Me(t.type)?r.call(e):r}(r,s,e);const t=ve;be(!0),xe(i),be(t)}return i}const Ie=/^\s*function (\w+)/;function Me(e){const t=e&&e.toString().match(Ie);return t?t[1]:""}function Re(e,t){return Me(e)===Me(t)}function De(e,t){if(!Array.isArray(t))return Re(t,e)?0:-1;for(let n=0,r=t.length;n<r;n++)if(Re(t[n],e))return n;return-1}function Le(e,t,n){he();try{if(t){let r=t;for(;r=r.$parent;){const s=r.$options.errorCaptured;if(s)for(let o=0;o<s.length;o++)try{if(!1===s[o].call(r,e,t,n))return}catch(e){Be(e,r,"errorCaptured hook")}}}Be(e,t,n)}finally{me()}}function ze(e,t,n,r,s){let i;try{i=n?e.apply(t,n):e.call(t),i&&!i._isVue&&(o(c=i)&&"function"==typeof c.then&&"function"==typeof c.catch)&&!i._handled&&(i.catch((e=>Le(e,r,s+" (Promise/async)"))),i._handled=!0)}catch(e){Le(e,r,s)}var c;return i}function Be(e,t,n){!function(e,t,n){if(!Q&&!Y||"undefined"==typeof console)throw e;console.error(e)}(e)}const Ue=[];if("undefined"!=typeof Promise&&ie(Promise))Promise.resolve();else if(te||"undefined"==typeof MutationObserver||!ie(MutationObserver)&&"[object MutationObserverConstructor]"!==MutationObserver.toString())"undefined"!=typeof setImmediate&&ie(setImmediate);else{let e=1;const t=new MutationObserver((function(){const e=Ue.slice(0);Ue.length=0;for(let t=0;t<e.length;t++)e[t]()})),n=document.createTextNode(String(e));t.observe(n,{characterData:!0})}function qe(e,t){return{staticClass:Ke(e.staticClass,t.staticClass),class:o(e.class)?[e.class,t.class]:t.class}}function Je(e,t){return o(e)||o(t)?Ke(e,He(t)):""}function Ke(e,t){return e?t?e+" "+t:e:t||""}function He(e){return Array.isArray(e)?function(e){let t,n="";for(let r=0,s=e.length;r<s;r++)o(t=He(e[r]))&&""!==t&&(n&&(n+=" "),n+=t);return n}(e):a(e)?function(e){let t="";for(const n in e)e[n]&&(t&&(t+=" "),t+=n);return t}(e):"string"==typeof e?e:""}const Ve=d("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,menuitem,summary,content,element,shadow,template,blockquote,iframe,tfoot"),We=d("svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view",!0);const Ze=$((function(e){const t={},n=/:(.+)/;return e.split(/;(?![^(]*\))/g).forEach((function(e){if(e){const r=e.split(n);r.length>1&&(t[r[0].trim()]=r[1].trim())}})),t}));function Xe(e){const t=Ge(e.style);return e.staticStyle?S(e.staticStyle,t):t}function Ge(e){return Array.isArray(e)?k(e):"string"==typeof e?Ze(e):e}function Qe(e){let t="";for(const n in e){const r=e[n],s=w(n);if(Array.isArray(r))for(let e=0,n=r.length;e<n;e++)t+=Ye(s,r[e]);else t+=Ye(s,r)}return t}function Ye(e,t){return"string"==typeof t||"number"==typeof t&&L[e]||0===t?`${e}:${t};`:""}var et=[function(e){let t=e.data.attrs,n="";const r=e.parent&&e.parent.componentOptions;if(s(r)||!1!==r.Ctor.options.inheritAttrs){let n=e.parent;for(;o(n)&&(!n.componentOptions||!1!==n.componentOptions.Ctor.options.inheritAttrs);)o(n.data)&&o(n.data.attrs)&&(t=S(S({},t),n.data.attrs)),n=n.parent}if(s(t))return n;for(const e in t)N(e)||"style"!==e&&(n+=K(e,t[e]));return n},function(e){let t=e.data.domProps,n="",r=e.parent;for(;o(r);)r.data&&r.data.domProps&&(t=S(S({},t),r.data.domProps)),r=r.parent;if(s(t))return n;const i=e.data.attrs;for(const r in t)if("innerHTML"===r)Z(e,t[r],!0);else if("textContent"===r)Z(e,t[r],!1);else if("value"===r&&"textarea"===e.tag)Z(e,f(t[r]),!1);else{const e=I[r]||r.toLowerCase();!E(e)||o(i)&&o(i[e])||(n+=K(e,t[r]))}return n},function(e){const t=function(e){let t=e.data,n=e,r=e;for(;o(r.componentInstance);)r=r.componentInstance._vnode,r&&r.data&&(t=qe(r.data,t));for(;o(n=n.parent);)n&&n.data&&(t=qe(t,n.data));return Je(t.staticClass,t.class)}(e);if(""!==t)return` class="${R(t)}"`},function(e){const t=Qe(function(e,t){const n={};let r;if(t){let t=e;for(;t.componentInstance;)t=t.componentInstance._vnode,t&&t.data&&(r=Xe(t.data))&&S(n,r)}(r=Xe(e.data))&&S(n,r);let s=e;for(;s=s.parent;)s.data&&(r=Xe(s.data))&&S(n,r);return n}(e,!1));if(""!==t)return` style=${JSON.stringify(R(t))}`}];function tt(e){const t=e.data||{};return t.attrs&&t.attrs.value||t.domProps&&t.domProps.value||e.children&&e.children[0]&&e.children[0].text}function nt(e){const t=e.data||(e.data={});(t.attrs||(t.attrs={})).selected=""}var rt={show:function(e,t){if(!t.value){const t=e.data.style||(e.data.style={});Array.isArray(t)?t.push({display:"none"}):t.display="none"}},model:function(e,t){if(!e.children)return;const n=t.value,r=e.data.attrs&&e.data.attrs.multiple;for(let t=0,s=e.children.length;t<s;t++){const s=e.children[t];if("option"===s.tag)if(r){Array.isArray(n)&&j(n,tt(s))>-1&&nt(s)}else if(T(n,tt(s)))return void nt(s)}}};const st=d("area,base,br,col,embed,frame,hr,img,input,isindex,keygen,link,meta,param,source,track,wbr"),ot=d("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source"),it=d("address,article,aside,base,blockquote,body,caption,col,colgroup,dd,details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,title,tr,track"),ct=e=>e,at="undefined"!=typeof process&&process.nextTick?process.nextTick:"undefined"!=typeof Promise?e=>Promise.resolve().then(e):"undefined"!=typeof setTimeout?setTimeout:ct;if(at===ct)throw new Error("Your JavaScript runtime does not support any asynchronous primitives that are required by vue-server-renderer. Please use a polyfill for either Promise or setTimeout.");function lt(e,t){let n=0;const r=(s,o)=>{s&&r.caching&&(r.cacheBuffer[r.cacheBuffer.length-1]+=s);!0!==e(s,o)&&(n>=800?at((()=>{try{o()}catch(e){t(e)}})):(n++,o(),n--))};return r.caching=!1,r.cacheBuffer=[],r.componentBuffer=[],r}class ut extends e.Readable{buffer;render;expectedSize;write;next;end;done;constructor(e){super(),this.buffer="",this.render=e,this.expectedSize=0,this.write=lt(((e,t)=>{const n=this.expectedSize;return this.buffer+=e,this.buffer.length>=n&&(this.next=t,this.pushBySize(n),!0)}),(e=>{this.emit("error",e)})),this.end=()=>{this.emit("beforeEnd"),this.done=!0,this.push(this.buffer)}}pushBySize(e){const t=this.buffer.substring(0,e);this.buffer=this.buffer.substring(e),this.push(t)}tryRender(){try{this.render(this.write,this.end)}catch(e){this.emit("error",e)}}tryNext(){try{this.next()}catch(e){this.emit("error",e)}}_read(e){this.expectedSize=e,i(this.done)?this.push(null):this.buffer.length>=e?this.pushBySize(e):s(this.next)?this.tryRender():this.tryNext()}}class ft{userContext;activeInstance;renderStates;write;renderNode;next;done;modules;directives;isUnaryTag;cache;get;has;constructor(e){this.userContext=e.userContext,this.activeInstance=e.activeInstance,this.renderStates=[],this.write=e.write,this.done=e.done,this.renderNode=e.renderNode,this.isUnaryTag=e.isUnaryTag,this.modules=e.modules,this.directives=e.directives;const t=e.cache;if(t&&(!t.get||!t.set))throw new Error("renderer cache must implement at least get & set.");this.cache=t,this.get=t&&pt(t,"get"),this.has=t&&pt(t,"has"),this.next=this.next.bind(this)}next(){for(;;){const e=this.renderStates[this.renderStates.length-1];if(s(e))return this.done();switch(e.type){case"Element":case"Fragment":const{children:t,total:n}=e,r=e.rendered++;if(r<n)return this.renderNode(t[r],!1,this);if(this.renderStates.pop(),"Element"===e.type)return this.write(e.endTag,this.next);break;case"Component":this.renderStates.pop(),this.activeInstance=e.prevActive;break;case"ComponentWithCache":this.renderStates.pop();const{buffer:s,bufferIndex:o,componentBuffer:i,key:c}=e,a={html:s[o],components:i[o]};if(this.cache.set(c,a),0===o)this.write.caching=!1;else{s[o-1]+=a.html;const e=i[o-1];a.components.forEach((t=>e.add(t)))}s.length=o,i.length=o}}}}function pt(e,t){const n=e[t];return s(n)?void 0:n.length>1?(t,r)=>n.call(e,t,r):(t,r)=>r(n.call(e,t))}const dt=/[\w).+\-_$\]]/;function ht(e){let t,n,r,s,o,i=!1,c=!1,a=!1,l=!1,u=0,f=0,p=0,d=0;for(r=0;r<e.length;r++)if(n=t,t=e.charCodeAt(r),i)39===t&&92!==n&&(i=!1);else if(c)34===t&&92!==n&&(c=!1);else if(a)96===t&&92!==n&&(a=!1);else if(l)47===t&&92!==n&&(l=!1);else if(124!==t||124===e.charCodeAt(r+1)||124===e.charCodeAt(r-1)||u||f||p){switch(t){case 34:c=!0;break;case 39:i=!0;break;case 96:a=!0;break;case 40:p++;break;case 41:p--;break;case 91:f++;break;case 93:f--;break;case 123:u++;break;case 125:u--}if(47===t){let t,n=r-1;for(;n>=0&&(t=e.charAt(n)," "===t);n--);t&&dt.test(t)||(l=!0)}}else void 0===s?(d=r+1,s=e.slice(0,r).trim()):h();function h(){(o||(o=[])).push(e.slice(d,r).trim()),d=r+1}if(void 0===s?s=e.slice(0,r).trim():0!==d&&h(),o)for(r=0;r<o.length;r++)s=mt(s,o[r]);return s}function mt(e,t){const n=t.indexOf("(");if(n<0)return`_f("${t}")(${e})`;{const r=t.slice(0,n),s=t.slice(n+1);return`_f("${r}")(${e}${")"!==s?","+s:s}`}}const yt=/\{\{((?:.|\r?\n)+?)\}\}/g,gt=/[-.*+?^${}()|[\]\/\\]/g,$t=$((e=>{const t=e[0].replace(gt,"\\$&"),n=e[1].replace(gt,"\\$&");return new RegExp(t+"((?:.|\\n)+?)"+n,"g")}));function vt(e,t){console.error(`[Vue compiler]: ${e}`)}function bt(e,t){return e?e.map((e=>e[t])).filter((e=>e)):[]}function _t(e,t,n,r,s){(e.props||(e.props=[])).push(jt({name:t,value:n,dynamic:s},r)),e.plain=!1}function xt(e,t,n,r,s){(s?e.dynamicAttrs||(e.dynamicAttrs=[]):e.attrs||(e.attrs=[])).push(jt({name:t,value:n,dynamic:s},r)),e.plain=!1}function wt(e,t,n,r){e.attrsMap[t]=n,e.attrsList.push(jt({name:t,value:n},r))}function St(e,t,n,r,s,o,i,c){(e.directives||(e.directives=[])).push(jt({name:t,rawName:n,value:r,arg:s,isDynamicArg:o,modifiers:i},c)),e.plain=!1}function kt(e,t,n){return n?`_p(${t},"${e}")`:e+t}function At(e,t,n,s,o,i,c,a){let l;(s=s||r).right?a?t=`(${t})==='click'?'contextmenu':(${t})`:"click"===t&&(t="contextmenu",delete s.right):s.middle&&(a?t=`(${t})==='click'?'mouseup':(${t})`:"click"===t&&(t="mouseup")),s.capture&&(delete s.capture,t=kt("!",t,a)),s.once&&(delete s.once,t=kt("~",t,a)),s.passive&&(delete s.passive,t=kt("&",t,a)),s.native?(delete s.native,l=e.nativeEvents||(e.nativeEvents={})):l=e.events||(e.events={});const u=jt({value:n.trim(),dynamic:a},c);s!==r&&(u.modifiers=s);const f=l[t];Array.isArray(f)?o?f.unshift(u):f.push(u):l[t]=f?o?[u,f]:[f,u]:u,e.plain=!1}function Ot(e,t,n){const r=Ct(e,":"+t)||Ct(e,"v-bind:"+t);if(null!=r)return ht(r);if(!1!==n){const n=Ct(e,t);if(null!=n)return JSON.stringify(n)}}function Ct(e,t,n){let r;if(null!=(r=e.attrsMap[t])){const n=e.attrsList;for(let e=0,r=n.length;e<r;e++)if(n[e].name===t){n.splice(e,1);break}}return n&&delete e.attrsMap[t],r}function Tt(e,t){const n=e.attrsList;for(let e=0,r=n.length;e<r;e++){const r=n[e];if(t.test(r.name))return n.splice(e,1),r}}function jt(e,t){return t&&(null!=t.start&&(e.start=t.start),null!=t.end&&(e.end=t.end)),e}var Ft={staticKeys:["staticClass"],transformNode:function(e,t){t.warn;const n=Ct(e,"class");n&&(e.staticClass=JSON.stringify(n.replace(/\s+/g," ").trim()));const r=Ot(e,"class",!1);r&&(e.classBinding=r)},genData:function(e){let t="";return e.staticClass&&(t+=`staticClass:${e.staticClass},`),e.classBinding&&(t+=`class:${e.classBinding},`),t}};var Pt={staticKeys:["staticStyle"],transformNode:function(e,t){t.warn;const n=Ct(e,"style");n&&(e.staticStyle=JSON.stringify(Ze(n)));const r=Ot(e,"style",!1);r&&(e.styleBinding=r)},genData:function(e){let t="";return e.staticStyle&&(t+=`staticStyle:${e.staticStyle},`),e.styleBinding&&(t+=`style:(${e.styleBinding}),`),t}};const Nt=/^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,Et=/^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/,It=`[a-zA-Z_][\\-\\.0-9_a-zA-Z${/a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/.source}]*`,Mt=`((?:${It}\\:)?${It})`,Rt=new RegExp(`^<${Mt}`),Dt=/^\s*(\/?)>/,Lt=new RegExp(`^<\\/${Mt}[^>]*>`),zt=/^<!DOCTYPE [^>]+>/i,Bt=/^<!\--/,Ut=/^<!\[/,qt=d("script,style,textarea",!0),Jt={},Kt={"&lt;":"<","&gt;":">","&quot;":'"',"&amp;":"&","&#10;":"\n","&#9;":"\t","&#39;":"'"},Ht=/&(?:lt|gt|quot|amp|#39);/g,Vt=/&(?:lt|gt|quot|amp|#39|#10|#9);/g,Wt=d("pre,textarea",!0),Zt=(e,t)=>e&&Wt(e)&&"\n"===t[0];function Xt(e,t){const n=t?Vt:Ht;return e.replace(n,(e=>Kt[e]))}function Gt(e,t,n){const{number:r,trim:s}=n||{},o="$$v";let i=o;s&&(i="(typeof $$v === 'string'? $$v.trim(): $$v)"),r&&(i=`_n(${i})`);const c=Qt(t,i);e.model={value:`(${t})`,expression:JSON.stringify(t),callback:`function ($$v) {${c}}`}}function Qt(e,t){const n=function(e){if(e=e.trim(),Yt=e.length,e.indexOf("[")<0||e.lastIndexOf("]")<Yt-1)return nn=e.lastIndexOf("."),nn>-1?{exp:e.slice(0,nn),key:'"'+e.slice(nn+1)+'"'}:{exp:e,key:null};en=e,nn=rn=sn=0;for(;!cn();)tn=on(),an(tn)?un(tn):91===tn&&ln(tn);return{exp:e.slice(0,rn),key:e.slice(rn+1,sn)}}(e);return null===n.key?`${e}=${t}`:`$set(${n.exp}, ${n.key}, ${t})`}let Yt,en,tn,nn,rn,sn;function on(){return en.charCodeAt(++nn)}function cn(){return nn>=Yt}function an(e){return 34===e||39===e}function ln(e){let t=1;for(rn=nn;!cn();)if(an(e=on()))un(e);else if(91===e&&t++,93===e&&t--,0===t){sn=nn;break}}function un(e){const t=e;for(;!cn()&&(e=on())!==t;);}const fn=/^@|^v-on:/,pn=/^v-|^@|^:|^#/,dn=/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/,hn=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,mn=/^\(|\)$/g,yn=/^\[.*\]$/,gn=/:(.*)$/,$n=/^:|^\.|^v-bind:/,vn=/\.[^.\]]+(?=[^\]]*$)/g,bn=/^v-slot(:|$)|^#/,_n=/[\r\n]/,xn=/[ \f\t\r\n]+/g,wn=$(n.default.decode);let Sn,kn,An,On,Cn,Tn,jn,Fn;function Pn(e,t,n){return{type:1,tag:e,attrsList:t,attrsMap:Ln(t),rawAttrsMap:{},parent:n,children:[]}}function Nn(e,t){Sn=t.warn||vt,Tn=t.isPreTag||O,jn=t.mustUseProp||O,Fn=t.getTagNamespace||O,t.isReservedTag,An=bt(t.modules,"transformNode"),On=bt(t.modules,"preTransformNode"),Cn=bt(t.modules,"postTransformNode"),kn=t.delimiters;const n=[],r=!1!==t.preserveWhitespace,s=t.whitespace;let o,i,c=!1,a=!1;function l(e){if(u(e),c||e.processed||(e=En(e,t)),n.length||e===o||o.if&&(e.elseif||e.else)&&Mn(o,{exp:e.elseif,block:e}),i&&!e.forbidden)if(e.elseif||e.else)!function(e,t){const n=function(e){let t=e.length;for(;t--;){if(1===e[t].type)return e[t];e.pop()}}(t.children);n&&n.if&&Mn(n,{exp:e.elseif,block:e})}(e,i);else{if(e.slotScope){const t=e.slotTarget||'"default"';(i.scopedSlots||(i.scopedSlots={}))[t]=e}i.children.push(e),e.parent=i}e.children=e.children.filter((e=>!e.slotScope)),u(e),e.pre&&(c=!1),Tn(e.tag)&&(a=!1);for(let n=0;n<Cn.length;n++)Cn[n](e,t)}function u(e){if(!a){let t;for(;(t=e.children[e.children.length-1])&&3===t.type&&" "===t.text;)e.children.pop()}}return function(e,t){const n=[],r=t.expectHTML,s=t.isUnaryTag||O,o=t.canBeLeftOpenTag||O;let i,c,a=0;for(;e;){if(i=e,c&&qt(c)){let n=0;const r=c.toLowerCase(),s=Jt[r]||(Jt[r]=new RegExp("([\\s\\S]*?)(</"+r+"[^>]*>)","i")),o=e.replace(s,(function(e,s,o){return n=o.length,qt(r)||"noscript"===r||(s=s.replace(/<!\--([\s\S]*?)-->/g,"$1").replace(/<!\[CDATA\[([\s\S]*?)]]>/g,"$1")),Zt(r,s)&&(s=s.slice(1)),t.chars&&t.chars(s),""}));a+=e.length-o.length,e=o,p(r,a-n,a)}else{let n,r,s,o=e.indexOf("<");if(0===o){if(Bt.test(e)){const n=e.indexOf("--\x3e");if(n>=0){t.shouldKeepComment&&t.comment(e.substring(4,n),a,a+n+3),l(n+3);continue}}if(Ut.test(e)){const t=e.indexOf("]>");if(t>=0){l(t+2);continue}}const n=e.match(zt);if(n){l(n[0].length);continue}const r=e.match(Lt);if(r){const e=a;l(r[0].length),p(r[1],e,a);continue}const s=u();if(s){f(s),Zt(s.tagName,e)&&l(1);continue}}if(o>=0){for(r=e.slice(o);!(Lt.test(r)||Rt.test(r)||Bt.test(r)||Ut.test(r)||(s=r.indexOf("<",1),s<0));)o+=s,r=e.slice(o);n=e.substring(0,o)}o<0&&(n=e),n&&l(n.length),t.chars&&n&&t.chars(n,a-n.length,a)}if(e===i){t.chars&&t.chars(e);break}}function l(t){a+=t,e=e.substring(t)}function u(){const t=e.match(Rt);if(t){const n={tagName:t[1],attrs:[],start:a};let r,s;for(l(t[0].length);!(r=e.match(Dt))&&(s=e.match(Et)||e.match(Nt));)s.start=a,l(s[0].length),s.end=a,n.attrs.push(s);if(r)return n.unarySlash=r[1],l(r[0].length),n.end=a,n}}function f(e){const i=e.tagName,a=e.unarySlash;r&&("p"===c&&it(i)&&p(c),o(i)&&c===i&&p(i));const l=s(i)||!!a,u=e.attrs.length,f=new Array(u);for(let n=0;n<u;n++){const r=e.attrs[n],s=r[3]||r[4]||r[5]||"",o="a"===i&&"href"===r[1]?t.shouldDecodeNewlinesForHref:t.shouldDecodeNewlines;f[n]={name:r[1],value:Xt(s,o)}}l||(n.push({tag:i,lowerCasedTag:i.toLowerCase(),attrs:f,start:e.start,end:e.end}),c=i),t.start&&t.start(i,f,l,e.start,e.end)}function p(e,r,s){let o,i;if(null==r&&(r=a),null==s&&(s=a),e)for(i=e.toLowerCase(),o=n.length-1;o>=0&&n[o].lowerCasedTag!==i;o--);else o=0;if(o>=0){for(let e=n.length-1;e>=o;e--)t.end&&t.end(n[e].tag,r,s);n.length=o,c=o&&n[o-1].tag}else"br"===i?t.start&&t.start(e,[],!0,r,s):"p"===i&&(t.start&&t.start(e,[],!1,r,s),t.end&&t.end(e,r,s))}p()}(e,{warn:Sn,expectHTML:t.expectHTML,isUnaryTag:t.isUnaryTag,canBeLeftOpenTag:t.canBeLeftOpenTag,shouldDecodeNewlines:t.shouldDecodeNewlines,shouldDecodeNewlinesForHref:t.shouldDecodeNewlinesForHref,shouldKeepComment:t.comments,outputSourceRange:t.outputSourceRange,start(e,r,s,u,f){const p=i&&i.ns||Fn(e);te&&"svg"===p&&(r=function(e){const t=[];for(let n=0;n<e.length;n++){const r=e[n];zn.test(r.name)||(r.name=r.name.replace(Bn,""),t.push(r))}return t}(r));let d=Pn(e,r,i);var h;p&&(d.ns=p),"style"!==(h=d).tag&&("script"!==h.tag||h.attrsMap.type&&"text/javascript"!==h.attrsMap.type)||oe()||(d.forbidden=!0);for(let e=0;e<On.length;e++)d=On[e](d,t)||d;c||(!function(e){null!=Ct(e,"v-pre")&&(e.pre=!0)}(d),d.pre&&(c=!0)),Tn(d.tag)&&(a=!0),c?function(e){const t=e.attrsList,n=t.length;if(n){const r=e.attrs=new Array(n);for(let e=0;e<n;e++)r[e]={name:t[e].name,value:JSON.stringify(t[e].value)},null!=t[e].start&&(r[e].start=t[e].start,r[e].end=t[e].end)}else e.pre||(e.plain=!0)}(d):d.processed||(In(d),function(e){const t=Ct(e,"v-if");if(t)e.if=t,Mn(e,{exp:t,block:e});else{null!=Ct(e,"v-else")&&(e.else=!0);const t=Ct(e,"v-else-if");t&&(e.elseif=t)}}(d),function(e){null!=Ct(e,"v-once")&&(e.once=!0)}(d)),o||(o=d),s?l(d):(i=d,n.push(d))},end(e,t,r){const s=n[n.length-1];n.length-=1,i=n[n.length-1],l(s)},chars(e,t,n){if(!i)return;if(te&&"textarea"===i.tag&&i.attrsMap.placeholder===e)return;const o=i.children;var l;if(e=a||e.trim()?"script"===(l=i).tag||"style"===l.tag?e:wn(e):o.length?s?"condense"===s&&_n.test(e)?"":" ":r?" ":"":""){let t,n;a||"condense"!==s||(e=e.replace(xn," ")),!c&&" "!==e&&(t=function(e,t){const n=t?$t(t):yt;if(!n.test(e))return;const r=[],s=[];let o,i,c,a=n.lastIndex=0;for(;o=n.exec(e);){i=o.index,i>a&&(s.push(c=e.slice(a,i)),r.push(JSON.stringify(c)));const t=ht(o[1].trim());r.push(`_s(${t})`),s.push({"@binding":t}),a=i+o[0].length}return a<e.length&&(s.push(c=e.slice(a)),r.push(JSON.stringify(c))),{expression:r.join("+"),tokens:s}}(e,kn))?n={type:2,expression:t.expression,tokens:t.tokens,text:e}:" "===e&&o.length&&" "===o[o.length-1].text||(n={type:3,text:e}),n&&o.push(n)}},comment(e,t,n){if(i){const t={type:3,text:e,isComment:!0};i.children.push(t)}}}),o}function En(e,t){var n;!function(e){const t=Ot(e,"key");t&&(e.key=t)}(e),e.plain=!e.key&&!e.scopedSlots&&!e.attrsList.length,function(e){const t=Ot(e,"ref");t&&(e.ref=t,e.refInFor=function(e){let t=e;for(;t;){if(void 0!==t.for)return!0;t=t.parent}return!1}(e))}(e),function(e){let t;"template"===e.tag?(t=Ct(e,"scope"),e.slotScope=t||Ct(e,"slot-scope")):(t=Ct(e,"slot-scope"))&&(e.slotScope=t);const n=Ot(e,"slot");n&&(e.slotTarget='""'===n?'"default"':n,e.slotTargetDynamic=!(!e.attrsMap[":slot"]&&!e.attrsMap["v-bind:slot"]),"template"===e.tag||e.slotScope||xt(e,"slot",n,function(e,t){return e.rawAttrsMap[":"+t]||e.rawAttrsMap["v-bind:"+t]||e.rawAttrsMap[t]}(e,"slot")));if("template"===e.tag){const t=Tt(e,bn);if(t){const{name:n,dynamic:r}=Rn(t);e.slotTarget=n,e.slotTargetDynamic=r,e.slotScope=t.value||"_empty_"}}else{const t=Tt(e,bn);if(t){const n=e.scopedSlots||(e.scopedSlots={}),{name:r,dynamic:s}=Rn(t),o=n[r]=Pn("template",[],e);o.slotTarget=r,o.slotTargetDynamic=s,o.children=e.children.filter((e=>{if(!e.slotScope)return e.parent=o,!0})),o.slotScope=t.value||"_empty_",e.children=[],e.plain=!1}}}(e),"slot"===(n=e).tag&&(n.slotName=Ot(n,"name")),function(e){let t;(t=Ot(e,"is"))&&(e.component=t);null!=Ct(e,"inline-template")&&(e.inlineTemplate=!0)}(e);for(let n=0;n<An.length;n++)e=An[n](e,t)||e;return function(e){const t=e.attrsList;let n,r,s,o,i,c,a,l;for(n=0,r=t.length;n<r;n++)if(s=o=t[n].name,i=t[n].value,pn.test(s))if(e.hasBindings=!0,c=Dn(s.replace(pn,"")),c&&(s=s.replace(vn,"")),$n.test(s))s=s.replace($n,""),i=ht(i),l=yn.test(s),l&&(s=s.slice(1,-1)),c&&(c.prop&&!l&&(s=b(s),"innerHtml"===s&&(s="innerHTML")),c.camel&&!l&&(s=b(s)),c.sync&&(a=Qt(i,"$event"),l?At(e,`"update:"+(${s})`,a,null,!1,0,t[n],!0):(At(e,`update:${b(s)}`,a,null,!1,0,t[n]),w(s)!==b(s)&&At(e,`update:${w(s)}`,a,null,!1,0,t[n])))),c&&c.prop||!e.component&&jn(e.tag,e.attrsMap.type,s)?_t(e,s,i,t[n],l):xt(e,s,i,t[n],l);else if(fn.test(s))s=s.replace(fn,""),l=yn.test(s),l&&(s=s.slice(1,-1)),At(e,s,i,c,!1,0,t[n],l);else{s=s.replace(pn,"");const r=s.match(gn);let a=r&&r[1];l=!1,a&&(s=s.slice(0,-(a.length+1)),yn.test(a)&&(a=a.slice(1,-1),l=!0)),St(e,s,o,i,a,l,c,t[n])}else xt(e,s,JSON.stringify(i),t[n]),!e.component&&"muted"===s&&jn(e.tag,e.attrsMap.type,s)&&_t(e,s,"true",t[n])}(e),e}function In(e){let t;if(t=Ct(e,"v-for")){const n=function(e){const t=e.match(dn);if(!t)return;const n={};n.for=t[2].trim();const r=t[1].trim().replace(mn,""),s=r.match(hn);s?(n.alias=r.replace(hn,"").trim(),n.iterator1=s[1].trim(),s[2]&&(n.iterator2=s[2].trim())):n.alias=r;return n}(t);n&&S(e,n)}}function Mn(e,t){e.ifConditions||(e.ifConditions=[]),e.ifConditions.push(t)}function Rn(e){let t=e.name.replace(bn,"");return t||"#"!==e.name[0]&&(t="default"),yn.test(t)?{name:t.slice(1,-1),dynamic:!0}:{name:`"${t}"`,dynamic:!1}}function Dn(e){const t=e.match(vn);if(t){const e={};return t.forEach((t=>{e[t.slice(1)]=!0})),e}}function Ln(e){const t={};for(let n=0,r=e.length;n<r;n++)t[e[n].name]=e[n].value;return t}const zn=/^xmlns:NS\d+/,Bn=/^NS\d+:/;function Un(e){return Pn(e.tag,e.attrsList.slice(),e.parent)}var qn=[Ft,Pt,{preTransformNode:function(e,t){if("input"===e.tag){const n=e.attrsMap;if(!n["v-model"])return;let r;if((n[":type"]||n["v-bind:type"])&&(r=Ot(e,"type")),n.type||r||!n["v-bind"]||(r=`(${n["v-bind"]}).type`),r){const n=Ct(e,"v-if",!0),s=n?`&&(${n})`:"",o=null!=Ct(e,"v-else",!0),i=Ct(e,"v-else-if",!0),c=Un(e);In(c),wt(c,"type","checkbox"),En(c,t),c.processed=!0,c.if=`(${r})==='checkbox'`+s,Mn(c,{exp:c.if,block:c});const a=Un(e);Ct(a,"v-for",!0),wt(a,"type","radio"),En(a,t),Mn(c,{exp:`(${r})==='radio'`+s,block:a});const l=Un(e);return Ct(l,"v-for",!0),wt(l,":type",r),En(l,t),Mn(c,{exp:n,block:l}),o?c.else=!0:i&&(c.elseif=i),c}}}}];const Jn={expectHTML:!0,modules:qn,directives:{model:function(e,t,n){const r=t.value,s=t.modifiers,o=e.tag,i=e.attrsMap.type;if(e.component)return Gt(e,r,s),!1;if("select"===o)!function(e,t,n){const r=n&&n.number;let s=`var $$selectedVal = Array.prototype.filter.call($event.target.options,function(o){return o.selected}).map(function(o){var val = "_value" in o ? o._value : o.value;return ${r?"_n(val)":"val"}});`;s=`${s} ${Qt(t,"$event.target.multiple ? $$selectedVal : $$selectedVal[0]")}`,At(e,"change",s,null,!0)}(e,r,s);else if("input"===o&&"checkbox"===i)!function(e,t,n){const r=n&&n.number,s=Ot(e,"value")||"null",o=Ot(e,"true-value")||"true",i=Ot(e,"false-value")||"false";_t(e,"checked",`Array.isArray(${t})?_i(${t},${s})>-1`+("true"===o?`:(${t})`:`:_q(${t},${o})`)),At(e,"change",`var $$a=${t},$$el=$event.target,$$c=$$el.checked?(${o}):(${i});if(Array.isArray($$a)){var $$v=${r?"_n("+s+")":s},$$i=_i($$a,$$v);if($$el.checked){$$i<0&&(${Qt(t,"$$a.concat([$$v])")})}else{$$i>-1&&(${Qt(t,"$$a.slice(0,$$i).concat($$a.slice($$i+1))")})}}else{${Qt(t,"$$c")}}`,null,!0)}(e,r,s);else if("input"===o&&"radio"===i)!function(e,t,n){const r=n&&n.number;let s=Ot(e,"value")||"null";s=r?`_n(${s})`:s,_t(e,"checked",`_q(${t},${s})`),At(e,"change",Qt(t,s),null,!0)}(e,r,s);else{if("input"!==o&&"textarea"!==o)return Gt(e,r,s),!1;!function(e,t,n){const r=e.attrsMap.type,{lazy:s,number:o,trim:i}=n||{},c=!s&&"range"!==r,a=s?"change":"range"===r?"__r":"input";let l="$event.target.value";i&&(l="$event.target.value.trim()");o&&(l=`_n(${l})`);let u=Qt(t,l);c&&(u=`if($event.target.composing)return;${u}`);_t(e,"value",`(${t})`),At(e,a,u,null,!0),(i||o)&&At(e,"blur","$forceUpdate()")}(e,r,s)}return!0},text:function(e,t){t.value&&_t(e,"textContent",`_s(${t.value})`,t)},html:function(e,t){t.value&&_t(e,"innerHTML",`_s(${t.value})`,t)}},isPreTag:e=>"pre"===e,isUnaryTag:st,mustUseProp:(e,t,n)=>"value"===n&&z(e)&&"button"!==t||"selected"===n&&"option"===e||"checked"===n&&"input"===e||"muted"===n&&"video"===e,canBeLeftOpenTag:ot,isReservedTag:e=>Ve(e)||We(e),getTagNamespace:function(e){return We(e)?"svg":"math"===e?"math":void 0},staticKeys:function(e){return e.reduce(((e,t)=>e.concat(t.staticKeys||[])),[]).join(",")}(qn)},Kn=/^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/,Hn=/\([^)]*?\);*$/,Vn=/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/,Wn={esc:27,tab:9,enter:13,space:32,up:38,left:37,right:39,down:40,delete:[8,46]},Zn={esc:["Esc","Escape"],tab:"Tab",enter:"Enter",space:[" ","Spacebar"],up:["Up","ArrowUp"],left:["Left","ArrowLeft"],right:["Right","ArrowRight"],down:["Down","ArrowDown"],delete:["Backspace","Delete","Del"]},Xn=e=>`if(${e})return null;`,Gn={stop:"$event.stopPropagation();",prevent:"$event.preventDefault();",self:Xn("$event.target !== $event.currentTarget"),ctrl:Xn("!$event.ctrlKey"),shift:Xn("!$event.shiftKey"),alt:Xn("!$event.altKey"),meta:Xn("!$event.metaKey"),left:Xn("'button' in $event && $event.button !== 0"),middle:Xn("'button' in $event && $event.button !== 1"),right:Xn("'button' in $event && $event.button !== 2")};function Qn(e,t){const n=t?"nativeOn:":"on:";let r="",s="";for(const t in e){const n=Yn(e[t]);e[t]&&e[t].dynamic?s+=`${t},${n},`:r+=`"${t}":${n},`}return r=`{${r.slice(0,-1)}}`,s?n+`_d(${r},[${s.slice(0,-1)}])`:n+r}function Yn(e){if(!e)return"function(){}";if(Array.isArray(e))return`[${e.map((e=>Yn(e))).join(",")}]`;const t=Vn.test(e.value),n=Kn.test(e.value),r=Vn.test(e.value.replace(Hn,""));if(e.modifiers){let s="",o="";const i=[];for(const t in e.modifiers)if(Gn[t])o+=Gn[t],Wn[t]&&i.push(t);else if("exact"===t){const t=e.modifiers;o+=Xn(["ctrl","shift","alt","meta"].filter((e=>!t[e])).map((e=>`$event.${e}Key`)).join("||"))}else i.push(t);i.length&&(s+=function(e){return`if(!$event.type.indexOf('key')&&${e.map(er).join("&&")})return null;`}(i)),o&&(s+=o);return`function($event){${s}${t?`return ${e.value}.apply(null, arguments)`:n?`return (${e.value}).apply(null, arguments)`:r?`return ${e.value}`:e.value}}`}return t||n?e.value:`function($event){${r?`return ${e.value}`:e.value}}`}function er(e){const t=parseInt(e,10);if(t)return`$event.keyCode!==${t}`;const n=Wn[e],r=Zn[e];return`_k($event.keyCode,${JSON.stringify(e)},${JSON.stringify(n)},$event.key,${JSON.stringify(r)})`}var tr={on:function(e,t){e.wrapListeners=e=>`_g(${e},${t.value})`},bind:function(e,t){e.wrapData=n=>`_b(${n},'${e.tag}',${t.value},${t.modifiers&&t.modifiers.prop?"true":"false"}${t.modifiers&&t.modifiers.sync?",true":""})`},cloak:A};class nr{options;warn;transforms;dataGenFns;directives;maybeComponent;onceId;staticRenderFns;pre;constructor(e){this.options=e,this.warn=e.warn||vt,this.transforms=bt(e.modules,"transformCode"),this.dataGenFns=bt(e.modules,"genData"),this.directives=S(S({},tr),e.directives);const t=e.isReservedTag||O;this.maybeComponent=e=>!!e.component||!t(e.tag),this.onceId=0,this.staticRenderFns=[],this.pre=!1}}function rr(e,t){if(e.parent&&(e.pre=e.pre||e.parent.pre),e.staticRoot&&!e.staticProcessed)return sr(e,t);if(e.once&&!e.onceProcessed)return or(e,t);if(e.for&&!e.forProcessed)return ar(e,t);if(e.if&&!e.ifProcessed)return ir(e,t);if("template"!==e.tag||e.slotTarget||t.pre){if("slot"===e.tag)return function(e,t){const n=e.slotName||'"default"',r=pr(e,t);let s=`_t(${n}${r?`,function(){return ${r}}`:""}`;const o=e.attrs||e.dynamicAttrs?yr((e.attrs||[]).concat(e.dynamicAttrs||[]).map((e=>({name:b(e.name),value:e.value,dynamic:e.dynamic})))):null,i=e.attrsMap["v-bind"];!o&&!i||r||(s+=",null");o&&(s+=`,${o}`);i&&(s+=`${o?"":",null"},${i}`);return s+")"}(e,t);{let n;if(e.component)n=function(e,t,n){const r=t.inlineTemplate?null:pr(t,n,!0);return`_c(${e},${lr(t,n)}${r?`,${r}`:""})`}(e.component,e,t);else{let r;(!e.plain||e.pre&&t.maybeComponent(e))&&(r=lr(e,t));const s=e.inlineTemplate?null:pr(e,t,!0);n=`_c('${e.tag}'${r?`,${r}`:""}${s?`,${s}`:""})`}for(let r=0;r<t.transforms.length;r++)n=t.transforms[r](e,n);return n}}return pr(e,t)||"void 0"}function sr(e,t){e.staticProcessed=!0;const n=t.pre;return e.pre&&(t.pre=e.pre),t.staticRenderFns.push(`with(this){return ${rr(e,t)}}`),t.pre=n,`_m(${t.staticRenderFns.length-1}${e.staticInFor?",true":""})`}function or(e,t){if(e.onceProcessed=!0,e.if&&!e.ifProcessed)return ir(e,t);if(e.staticInFor){let n="",r=e.parent;for(;r;){if(r.for){n=r.key;break}r=r.parent}return n?`_o(${rr(e,t)},${t.onceId++},${n})`:rr(e,t)}return sr(e,t)}function ir(e,t,n,r){return e.ifProcessed=!0,cr(e.ifConditions.slice(),t,n,r)}function cr(e,t,n,r){if(!e.length)return r||"_e()";const s=e.shift();return s.exp?`(${s.exp})?${o(s.block)}:${cr(e,t,n,r)}`:`${o(s.block)}`;function o(e){return n?n(e,t):e.once?or(e,t):rr(e,t)}}function ar(e,t,n,r){const s=e.for,o=e.alias,i=e.iterator1?`,${e.iterator1}`:"",c=e.iterator2?`,${e.iterator2}`:"";return e.forProcessed=!0,`${r||"_l"}((${s}),function(${o}${i}${c}){return ${(n||rr)(e,t)}})`}function lr(e,t){let n="{";const r=function(e,t){const n=e.directives;if(!n)return;let r,s,o,i,c="directives:[",a=!1;for(r=0,s=n.length;r<s;r++){o=n[r],i=!0;const s=t.directives[o.name];s&&(i=!!s(e,o,t.warn)),i&&(a=!0,c+=`{name:"${o.name}",rawName:"${o.rawName}"${o.value?`,value:(${o.value}),expression:${JSON.stringify(o.value)}`:""}${o.arg?`,arg:${o.isDynamicArg?o.arg:`"${o.arg}"`}`:""}${o.modifiers?`,modifiers:${JSON.stringify(o.modifiers)}`:""}},`)}if(a)return c.slice(0,-1)+"]"}(e,t);r&&(n+=r+","),e.key&&(n+=`key:${e.key},`),e.ref&&(n+=`ref:${e.ref},`),e.refInFor&&(n+="refInFor:true,"),e.pre&&(n+="pre:true,"),e.component&&(n+=`tag:"${e.tag}",`);for(let r=0;r<t.dataGenFns.length;r++)n+=t.dataGenFns[r](e);if(e.attrs&&(n+=`attrs:${yr(e.attrs)},`),e.props&&(n+=`domProps:${yr(e.props)},`),e.events&&(n+=`${Qn(e.events,!1)},`),e.nativeEvents&&(n+=`${Qn(e.nativeEvents,!0)},`),e.slotTarget&&!e.slotScope&&(n+=`slot:${e.slotTarget},`),e.scopedSlots&&(n+=`${function(e,t,n){let r=e.for||Object.keys(t).some((e=>{const n=t[e];return n.slotTargetDynamic||n.if||n.for||ur(n)})),s=!!e.if;if(!r){let t=e.parent;for(;t;){if(t.slotScope&&"_empty_"!==t.slotScope||t.for){r=!0;break}t.if&&(s=!0),t=t.parent}}const o=Object.keys(t).map((e=>fr(t[e],n))).join(",");return`scopedSlots:_u([${o}]${r?",null,true":""}${!r&&s?`,null,false,${function(e){let t=5381,n=e.length;for(;n;)t=33*t^e.charCodeAt(--n);return t>>>0}(o)}`:""})`}(e,e.scopedSlots,t)},`),e.model&&(n+=`model:{value:${e.model.value},callback:${e.model.callback},expression:${e.model.expression}},`),e.inlineTemplate){const r=function(e,t){const n=e.children[0];if(n&&1===n.type){const e=function(e,t){const n=new nr(t);return{render:`with(this){return ${e?"script"===e.tag?"null":rr(e,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}(n,t.options);return`inlineTemplate:{render:function(){${e.render}},staticRenderFns:[${e.staticRenderFns.map((e=>`function(){${e}}`)).join(",")}]}`}}(e,t);r&&(n+=`${r},`)}return n=n.replace(/,$/,"")+"}",e.dynamicAttrs&&(n=`_b(${n},"${e.tag}",${yr(e.dynamicAttrs)})`),e.wrapData&&(n=e.wrapData(n)),e.wrapListeners&&(n=e.wrapListeners(n)),n}function ur(e){return 1===e.type&&("slot"===e.tag||e.children.some(ur))}function fr(e,t){const n=e.attrsMap["slot-scope"];if(e.if&&!e.ifProcessed&&!n)return ir(e,t,fr,"null");if(e.for&&!e.forProcessed)return ar(e,t,fr);const r="_empty_"===e.slotScope?"":String(e.slotScope),s=`function(${r}){return ${"template"===e.tag?e.if&&n?`(${e.if})?${pr(e,t)||"undefined"}:undefined`:pr(e,t)||"undefined":rr(e,t)}}`,o=r?"":",proxy:true";return`{key:${e.slotTarget||'"default"'},fn:${s}${o}}`}function pr(e,t,n,r,s){const o=e.children;if(o.length){const e=o[0];if(1===o.length&&e.for&&"template"!==e.tag&&"slot"!==e.tag){const s=n?t.maybeComponent(e)?",1":",0":"";return`${(r||rr)(e,t)}${s}`}const i=n?function(e,t){let n=0;for(let r=0;r<e.length;r++){const s=e[r];if(1===s.type){if(dr(s)||s.ifConditions&&s.ifConditions.some((e=>dr(e.block)))){n=2;break}(t(s)||s.ifConditions&&s.ifConditions.some((e=>t(e.block))))&&(n=1)}}return n}(o,t.maybeComponent):0,c=s||hr;return`[${o.map((e=>c(e,t))).join(",")}]${i?`,${i}`:""}`}}function dr(e){return void 0!==e.for||"template"===e.tag||"slot"===e.tag}function hr(e,t){return 1===e.type?rr(e,t):3===e.type&&e.isComment?function(e){return`_e(${JSON.stringify(e.text)})`}(e):mr(e)}function mr(e){return`_v(${2===e.type?e.expression:gr(JSON.stringify(e.text))})`}function yr(e){let t="",n="";for(let r=0;r<e.length;r++){const s=e[r],o=gr(s.value);s.dynamic?n+=`${s.name},${o},`:t+=`"${s.name}":${o},`}return t=`{${t.slice(0,-1)}}`,n?`_d(${t},[${n.slice(0,-1)}])`:t}function gr(e){return e.replace(/\u2028/g,"\\u2028").replace(/\u2029/g,"\\u2029")}const $r=/^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;function vr(e,t){return $r.test(t)?(t=t.replace(/^'|'$/g,'"'),B(e)&&'"false"'!==t&&(t='"true"'),{type:Tr,value:q(e)?` ${e}="${e}"`:'""'===t?` ${e}`:` ${e}="${JSON.parse(t)}"`}):{type:jr,value:`_ssrAttr(${JSON.stringify(e)},${t})`}}const br=0,_r=1,xr=2,wr=3,Sr=4;let kr;function Ar(e,t){e&&(kr=t.isReservedTag||O,Or(e,!0))}function Or(e,t){if(function(e){if(2===e.type||3===e.type)return!1;return h(e.tag)||!kr(e.tag)||!!e.component||function(e){return 1===e.type&&"select"===e.tag&&null!=e.directives&&e.directives.some((e=>"model"===e.name))}(e)}(e))return void(e.ssrOptimizability=br);const n=t||function(e){return 1===e.type&&e.directives&&e.directives.some((e=>!Cr(e.name)))}(e),r=t=>{t.ssrOptimizability!==_r&&(e.ssrOptimizability=n?Sr:xr)};if(n&&(e.ssrOptimizability=wr),1===e.type){for(let t=0,n=e.children.length;t<n;t++){const n=e.children[t];Or(n),r(n)}if(e.ifConditions)for(let n=1,s=e.ifConditions.length;n<s;n++){const s=e.ifConditions[n].block;Or(s,t),r(s)}null==e.ssrOptimizability||!t&&(e.attrsMap["v-html"]||e.attrsMap["v-text"])?e.ssrOptimizability=_r:e.children=function(e){const t=e.children,n=[];let r=[];const s=()=>{r.length&&n.push({type:1,parent:e,tag:"template",attrsList:[],attrsMap:{},rawAttrsMap:{},children:r,ssrOptimizability:_r}),r=[]};for(let e=0;e<t.length;e++){const o=t[e];o.ssrOptimizability===_r?r.push(o):(s(),n.push(o))}return s(),n}(e)}else e.ssrOptimizability=_r}const Cr=d("text,html,show,on,bind,model,pre,cloak,once");const Tr=0,jr=2;function Fr(e,t){if(e.for&&!e.forProcessed)return ar(e,t,Fr);if(e.if&&!e.ifProcessed)return ir(e,t,Fr);if("template"===e.tag&&!e.slotTarget)return e.ssrOptimizability===_r?Ir(e,t):Nr(e,t)||"void 0";switch(e.ssrOptimizability){case _r:return function(e,t){return`_ssrNode(${Mr(e,t)})`}(e,t);case xr:return function(e,t){const n=Nr(e,t,!0);return`_ssrNode(${zr(Dr(e,t))},"</${e.tag}>"${n?`,${n}`:""})`}(e,t);case wr:return Pr(e,t,!0);case Sr:return Pr(e,t,!1);default:return rr(e,t)}}function Pr(e,t,n){const r=e.plain?void 0:lr(e,t),s=n?`[${Ir(e,t)}]`:Nr(e,t,!0);return`_c('${e.tag}'${r?`,${r}`:""}${s?`,${s}`:""})`}function Nr(e,t,n){return pr(e,t,n,Fr,Er)}function Er(e,t){return 1===e.type?Fr(e,t):mr(e)}function Ir(e,t){return e.children.length?`_ssrNode(${zr(Lr(e,t))})`:""}function Mr(e,t){return`(${zr(Rr(e,t))})`}function Rr(e,t){if(e.for&&!e.forProcessed)return e.forProcessed=!0,[{type:jr,value:ar(e,t,Mr,"_ssrList")}];if(e.if&&!e.ifProcessed)return e.ifProcessed=!0,[{type:jr,value:ir(e,t,Mr,'"\x3c!----\x3e"')}];if("template"===e.tag)return Lr(e,t);const n=Dr(e,t),r=Lr(e,t),{isUnaryTag:s}=t.options,o=s&&s(e.tag)?[]:[{type:Tr,value:`</${e.tag}>`}];return n.concat(r,o)}function Dr(e,t){let n;!function(e,t){if(e.directives)for(let n=0;n<e.directives.length;n++){const r=e.directives[n];if("model"===r.name){t.directives.model(e,r,t.warn),"textarea"===e.tag&&e.props&&(e.props=e.props.filter((e=>"value"!==e.name)));break}}}(e,t);const r=[{type:Tr,value:`<${e.tag}`}];var s,o,i,c,a,l;return e.attrs&&r.push.apply(r,e.attrs.map((({name:e,value:t})=>vr(e,t)))),e.props&&r.push.apply(r,function(e,t){const n=[];return e.forEach((({name:e,value:r})=>{e=I[e]||e.toLowerCase(),!E(e)||t&&t.some((t=>t.name===e))||n.push(vr(e,r))})),n}(e.props,e.attrs)),(n=e.attrsMap["v-bind"])&&r.push({type:jr,value:`_ssrAttrs(${n})`}),(n=e.attrsMap["v-bind.prop"])&&r.push({type:jr,value:`_ssrDOMProps(${n})`}),(e.staticClass||e.classBinding)&&r.push.apply(r,(s=e.staticClass,o=e.classBinding,s&&!o?[{type:Tr,value:` class="${JSON.parse(s)}"`}]:[{type:jr,value:`_ssrClass(${s||"null"},${o||"null"})`}])),(e.staticStyle||e.styleBinding||e.attrsMap["v-show"])&&r.push.apply(r,(i=e.attrsMap.style,c=e.staticStyle,a=e.styleBinding,l=e.attrsMap["v-show"],!i||a||l?[{type:jr,value:`_ssrStyle(${c||"null"},${a||"null"}, ${l?`{ display: (${l}) ? '' : 'none' }`:"null"})`}]:[{type:Tr,value:` style=${JSON.stringify(i)}`}])),t.options.scopeId&&r.push({type:Tr,value:` ${t.options.scopeId}`}),r.push({type:Tr,value:">"}),r}function Lr(e,t){let n;return(n=e.attrsMap["v-html"])?[{type:jr,value:`_s(${n})`}]:(n=e.attrsMap["v-text"])||"textarea"===e.tag&&(n=e.attrsMap["v-model"])?[{type:1,value:`_s(${n})`}]:e.children?function(e,t){const n=[];for(let r=0;r<e.length;r++){const s=e[r];if(1===s.type)n.push.apply(n,Rr(s,t));else if(2===s.type)n.push({type:1,value:s.expression});else if(3===s.type){let e=R(s.text);s.isComment&&(e="\x3c!--"+e+"--\x3e"),n.push({type:Tr,value:e})}}return n}(e.children,t):[]}function zr(e){const t=[];let n="";const r=()=>{n&&(t.push(JSON.stringify(n)),n="")};for(let s=0;s<e.length;s++){const o=e[s];o.type===Tr?n+=o.value:1===o.type?(r(),t.push(`_ssrEscape(${o.value})`)):o.type===jr&&(r(),t.push(`(${o.value})`))}return r(),t.join("+")}function Br(e,t){try{return new Function(e)}catch(n){return t.push({err:n,code:e}),A}}function Ur(e){const t=Object.create(null);return function(n,r,s){(r=S({},r)).warn,delete r.warn;const o=r.delimiters?String(r.delimiters)+n:n;if(t[o])return t[o];const i=e(n,r),c={},a=[];return c.render=Br(i.render,a),c.staticRenderFns=i.staticRenderFns.map((e=>Br(e,a))),t[o]=c}}new RegExp("\\b"+"do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,super,throw,while,yield,delete,export,import,return,switch,default,extends,finally,continue,debugger,function,arguments".split(",").join("\\b|\\b")+"\\b"),new RegExp("\\b"+"delete,typeof,void".split(",").join("\\s*\\([^\\)]*\\)|\\b")+"\\s*\\([^\\)]*\\)");const qr=(Jr=function(e,t){const n=Nn(e.trim(),t);Ar(n,t);const r=function(e,t){const n=new nr(t);return{render:`with(this){return ${e?Fr(e,n):'_c("div")'}}`,staticRenderFns:n.staticRenderFns}}(n,t);return{ast:n,render:r.render,staticRenderFns:r.staticRenderFns}},function(e){function t(t,n){const r=Object.create(e),s=[],o=[];if(n){n.modules&&(r.modules=(e.modules||[]).concat(n.modules)),n.directives&&(r.directives=S(Object.create(e.directives||null),n.directives));for(const e in n)"modules"!==e&&"directives"!==e&&(r[e]=n[e])}r.warn=(e,t,n)=>{(n?o:s).push(e)};const i=Jr(t.trim(),r);return i.errors=s,i.tips=o,i}return{compile:t,compileToFunctions:Ur(t)}});var Jr;const{compile:Kr,compileToFunctions:Hr}=qr(Jn);function Vr(e){for(let t=0;t<e.length;t++)if(Array.isArray(e[t]))return Array.prototype.concat.apply([],e);return e}function Wr(e){return c(e)?[W(e)]:Array.isArray(e)?Xr(e):void 0}function Zr(e){return o(e)&&o(e.text)&&!1===e.isComment}function Xr(e,t){const n=[];let r,a,l,u;for(r=0;r<e.length;r++)a=e[r],s(a)||"boolean"==typeof a||(l=n.length-1,u=n[l],Array.isArray(a)?a.length>0&&(a=Xr(a,`${t||""}_${r}`),Zr(a[0])&&Zr(u)&&(n[l]=W(u.text+a[0].text),a.shift()),n.push.apply(n,a)):c(a)?Zr(u)?n[l]=W(u.text+a):""!==a&&n.push(W(a)):Zr(a)&&Zr(u)?n[l]=W(u.text+a.text):(i(e._isVList)&&o(a.tag)&&s(a.key)&&o(t)&&(a.key=`__vlist${t}_${r}__`),n.push(a)));return n}const Gr={_ssrEscape:R,_ssrNode:function(e,t,n,r){return new Qr(e,t,n,r)},_ssrList:function(e,t){let n,r,s,o,i="";if(Array.isArray(e)||"string"==typeof e)for(n=0,r=e.length;n<r;n++)i+=t(e[n],n);else if("number"==typeof e)for(n=0;n<e;n++)i+=t(n+1,n);else if(a(e))for(s=Object.keys(e),n=0,r=s.length;n<r;n++)o=s[n],i+=t(e[o],o,n);return i},_ssrAttr:K,_ssrAttrs:function(e){let t="";for(const n in e)N(n)||(t+=K(n,e[n]));return t},_ssrDOMProps:function(e){let t="";for(const n in e){const r=I[n]||n.toLowerCase();E(r)&&(t+=K(r,e[n]))}return t},_ssrClass:function(e,t){const n=Je(e,t);return""===n?n:` class="${R(n)}"`},_ssrStyle:function(e,t,n){const r={};e&&S(r,e);t&&S(r,Ge(t));n&&S(r,n);const s=Qe(r);return""===s?s:` style=${JSON.stringify(R(s))}`}};class Qr{isString;open;close;children;constructor(e,t,n,r){this.isString=!0,this.open=e,this.close=t,this.children=n?1===r?Vr(n):2===r?Wr(n):n:void 0}}const Yr=new ae;function es(e){ts(e,Yr),Yr.clear()}function ts(e,t){let n,r;const s=Array.isArray(e);if(!(!s&&!a(e)||Object.isFrozen(e)||e instanceof H)){if(e.__ob__){const n=e.__ob__.dep.id;if(t.has(n))return;t.add(n)}if(s)for(n=e.length;n--;)ts(e[n],t);else for(r=Object.keys(e),n=r.length;n--;)ts(e[r[n]],t)}}const ns=$((e=>{const t="&"===e.charAt(0),n="~"===(e=t?e.slice(1):e).charAt(0),r="!"===(e=n?e.slice(1):e).charAt(0);return{name:e=r?e.slice(1):e,once:n,capture:r,passive:t}}));function rs(e,t){function n(){const e=n.fns;if(!Array.isArray(e))return ze(e,null,arguments,t,"v-on handler");{const n=e.slice();for(let e=0;e<n.length;e++)ze(n[e],null,arguments,t,"v-on handler")}}return n.fns=e,n}function ss(e,t,n,r,s){if(o(t)){if(g(t,n))return e[n]=t[n],s||delete t[n],!0;if(g(t,r))return e[n]=t[r],s||delete t[r],!0}return!1}function os(e,t,n,r,s,l){return(Array.isArray(n)||c(n))&&(s=r,r=n,n=void 0),i(l)&&(s=2),function(e,t,n,r,s){if(o(n)&&o(n.__ob__))return V();o(n)&&o(n.is)&&(t=n.is);if(!t)return V();Array.isArray(r)&&"function"==typeof r[0]&&((n=n||{}).scopedSlots={default:r[0]},r.length=0);2===s?r=Wr(r):1===s&&(r=Vr(r));let i,c;if("string"==typeof t){let s;c=e.$vnode&&e.$vnode.ns||ue.getTagNamespace(t),i=n&&n.pre||!o(s=Ne(e.$options,"components",t))?new H(t,n,r,void 0,void 0,e):qs(s,n,e,r,t)}else i=qs(t,n,e,r);return Array.isArray(i)?i:o(i)?(o(c)&&is(i,c),o(n)&&function(e){a(e.style)&&es(e.style);a(e.class)&&es(e.class)}(n),i):V()}(e,t,n,r,s)}function is(e,t,n){if(e.ns=t,"foreignObject"===e.tag&&(t=void 0,n=!0),o(e.children))for(let r=0,c=e.children.length;r<c;r++){const c=e.children[r];o(c.tag)&&(s(c.ns)||i(n)&&"svg"!==c.tag)&&is(c,t,n)}}function cs(e,t){let n,r,s,i,c=null;if(Array.isArray(e)||"string"==typeof e)for(c=new Array(e.length),n=0,r=e.length;n<r;n++)c[n]=t(e[n],n);else if("number"==typeof e)for(c=new Array(e),n=0;n<e;n++)c[n]=t(n+1,n);else if(a(e))if(ce&&e[Symbol.iterator]){c=[];const n=e[Symbol.iterator]();let r=n.next();for(;!r.done;)c.push(t(r.value,c.length)),r=n.next()}else for(s=Object.keys(e),c=new Array(s.length),n=0,r=s.length;n<r;n++)i=s[n],c[n]=t(e[i],i,n);return o(c)||(c=[]),c._isVList=!0,c}function as(e,t,n,r){const s=this.$scopedSlots[e];let o;s?(n=n||{},r&&(n=S(S({},r),n)),o=s(n)||("function"==typeof t?t():t)):o=this.$slots[e]||("function"==typeof t?t():t);const i=n&&n.slot;return i?this.$createElement("template",{slot:i},o):o}function ls(e){return Ne(this.$options,"filters",e)||C}function us(e,t){return Array.isArray(e)?-1===e.indexOf(t):e!==t}function fs(e,t,n,r,s){const o=ue.keyCodes[t]||n;return s&&r&&!ue.keyCodes[t]?us(s,r):o?us(o,e):r?w(r)!==t:void 0===e}function ps(e,t,n,r,s){if(n)if(a(n)){let o;Array.isArray(n)&&(n=k(n));for(const i in n){if("class"===i||"style"===i||m(i))o=e;else{const n=e.attrs&&e.attrs.type;o=r||ue.mustUseProp(t,n,i)?e.domProps||(e.domProps={}):e.attrs||(e.attrs={})}const c=b(i),a=w(i);if(!(c in o)&&!(a in o)&&(o[i]=n[i],s)){(e.on||(e.on={}))[`update:${i}`]=function(e){n[i]=e}}}}else;return e}function ds(e,t){const n=this._staticTrees||(this._staticTrees=[]);let r=n[e];return r&&!t||(r=n[e]=this.$options.staticRenderFns[e].call(this._renderProxy,null,this),ms(r,`__static__${e}`,!1)),r}function hs(e,t,n){return ms(e,`__once__${t}${n?`_${n}`:""}`,!0),e}function ms(e,t,n){if(Array.isArray(e))for(let r=0;r<e.length;r++)e[r]&&"string"!=typeof e[r]&&ys(e[r],`${t}_${r}`,n);else ys(e,t,n)}function ys(e,t,n){e.isStatic=!0,e.key=t,e.isOnce=n}function gs(e,t){if(t)if(u(t)){const n=e.on=e.on?S({},e.on):{};for(const e in t){const r=n[e],s=t[e];n[e]=r?[].concat(r,s):s}}else;return e}function $s(e,t,n,r){t=t||{$stable:!n};for(let r=0;r<e.length;r++){const s=e[r];Array.isArray(s)?$s(s,t,n):s&&(s.proxy&&(s.fn.proxy=!0),t[s.key]=s.fn)}return r&&(t.$key=r),t}function vs(e,t){for(let n=0;n<t.length;n+=2){const r=t[n];"string"==typeof r&&r&&(e[t[n]]=t[n+1])}return e}function bs(e,t){return"string"==typeof e?t+e:e}function _s(e,t){if(!e||!e.length)return{};const n={};for(let r=0,s=e.length;r<s;r++){const s=e[r],o=s.data;if(o&&o.attrs&&o.attrs.slot&&delete o.attrs.slot,s.context!==t&&s.fnContext!==t||!o||null==o.slot)(n.default||(n.default=[])).push(s);else{const e=o.slot,t=n[e]||(n[e]=[]);"template"===s.tag?t.push.apply(t,s.children||[]):t.push(s)}}for(const e in n)n[e].every(xs)&&delete n[e];return n}function xs(e){return e.isComment&&!e.asyncFactory||" "===e.text}function ws(e){return e.isComment&&e.asyncFactory}function Ss(e,t,n){let s;const o=Object.keys(t).length>0,i=e?!!e.$stable:!o,c=e&&e.$key;if(e){if(e._normalized)return e._normalized;if(i&&n&&n!==r&&c===n.$key&&!o&&!n.$hasNormal)return n;s={};for(const n in e)e[n]&&"$"!==n[0]&&(s[n]=ks(t,n,e[n]))}else s={};for(const e in t)e in s||(s[e]=As(t,e));return e&&Object.isExtensible(e)&&(e._normalized=s),X(s,"$stable",i),X(s,"$key",c),X(s,"$hasNormal",o),s}function ks(e,t,n){const r=function(){let e=arguments.length?n.apply(null,arguments):n({});e=e&&"object"==typeof e&&!Array.isArray(e)?[e]:Wr(e);const t=e&&e[0];return e&&(!t||1===e.length&&t.isComment&&!ws(t))?void 0:e};return n.proxy&&Object.defineProperty(e,t,{get:r,enumerable:!0,configurable:!0}),r}function As(e,t){return()=>e[t]}let Os;function Cs(e,t){Os.$on(e,t)}function Ts(e,t){Os.$off(e,t)}function js(e,t){const n=Os;return function r(){const s=t.apply(null,arguments);null!==s&&n.$off(e,r)}}function Fs(e,t,n){Os=e,function(e,t,n,r,o,c){let a,l,u,f;for(a in e)l=e[a],u=t[a],f=ns(a),s(l)||(s(u)?(s(l.fns)&&(l=e[a]=rs(l,c)),i(f.once)&&(l=e[a]=o(f.name,l,f.capture)),n(f.name,l,f.capture,f.passive,f.params)):l!==u&&(u.fns=l,e[a]=u));for(a in t)s(e[a])&&(f=ns(a),r(f.name,t[a],f.capture))}(t,n||{},Cs,Ts,js,e),Os=void 0}function Ps(e){for(;e&&(e=e.$parent);)if(e._inactive)return!0;return!1}function Ns(e,t){if(t){if(e._directInactive=!1,Ps(e))return}else if(e._directInactive)return;if(e._inactive||null===e._inactive){e._inactive=!1;for(let t=0;t<e.$children.length;t++)Ns(e.$children[t]);Is(e,"activated")}}function Es(e,t){if(!(t&&(e._directInactive=!0,Ps(e))||e._inactive)){e._inactive=!0;for(let t=0;t<e.$children.length;t++)Es(e.$children[t]);Is(e,"deactivated")}}function Is(e,t){he();const n=e.$options[t],r=`${t} hook`;if(n)for(let t=0,s=n.length;t<s;t++)ze(n[t],e,null,e,r);e._hasHookEvent&&e.$emit("hook:"+t),me()}let Ms=Date.now;if(Q&&!te){const e=window.performance;e&&"function"==typeof e.now&&Ms()>document.createEvent("Event").timeStamp&&(Ms=()=>e.now())}function Rs(e){let t=e.options;if(e.super){const n=Rs(e.super);if(n!==e.superOptions){e.superOptions=n;const r=function(e){let t;const n=e.options,r=e.sealedOptions;for(const e in n)n[e]!==r[e]&&(t||(t={}),t[e]=n[e]);return t}(e);r&&S(e.extendOptions,r),t=e.options=Pe(n,e.extendOptions),t.name&&(t.components[t.name]=e)}}return t}function Ds(e,t,n,s,o){const c=o.options;let a;g(s,"_uid")?(a=Object.create(s),a._original=s):(a=s,s=s._original);const l=i(c._compiled),u=!l;this.data=e,this.props=t,this.children=n,this.parent=s,this.listeners=e.on||r,this.injections=function(e,t){if(e){const n=Object.create(null),r=ce?Reflect.ownKeys(e):Object.keys(e);for(let s=0;s<r.length;s++){const o=r[s];if("__ob__"===o)continue;const i=e[o].from;let c=t;for(;c;){if(c._provided&&g(c._provided,i)){n[o]=c._provided[i];break}c=c.$parent}if(!c&&"default"in e[o]){const r=e[o].default;n[o]="function"==typeof r?r.call(t):r}}return n}}(c.inject,s),this.slots=()=>(this.$slots||Ss(e.scopedSlots,this.$slots=_s(n,s)),this.$slots),Object.defineProperty(this,"scopedSlots",{enumerable:!0,get(){return Ss(e.scopedSlots,this.slots())}}),l&&(this.$options=c,this.$slots=this.slots(),this.$scopedSlots=Ss(e.scopedSlots,this.$slots)),c._scopeId?this._c=(e,t,n,r)=>{const o=os(a,e,t,n,r,u);return o&&!Array.isArray(o)&&(o.fnScopeId=c._scopeId,o.fnContext=s),o}:this._c=(e,t,n,r)=>os(a,e,t,n,r,u)}function Ls(e,t,n,r,s){const o=function(e){const t=new H(e.tag,e.data,e.children&&e.children.slice(),e.text,e.elm,e.context,e.componentOptions,e.asyncFactory);return t.ns=e.ns,t.isStatic=e.isStatic,t.key=e.key,t.isComment=e.isComment,t.fnContext=e.fnContext,t.fnOptions=e.fnOptions,t.fnScopeId=e.fnScopeId,t.asyncMeta=e.asyncMeta,t.isCloned=!0,t}(e);return o.fnContext=n,o.fnOptions=r,t.slot&&((o.data||(o.data={})).slot=t.slot),o}function zs(e,t){for(const n in t)e[b(n)]=t[n]}!function(e){e._o=hs,e._n=p,e._s=f,e._l=cs,e._t=as,e._q=T,e._i=j,e._m=ds,e._f=ls,e._k=fs,e._b=ps,e._v=W,e._e=V,e._u=$s,e._g=gs,e._d=vs,e._p=bs}(Ds.prototype);const Bs={init(e,t){if(e.componentInstance&&!e.componentInstance._isDestroyed&&e.data.keepAlive){const t=e;Bs.prepatch(t,t)}else{(e.componentInstance=Js(e,null)).$mount(t?e.elm:void 0,t)}},prepatch(e,t){const n=t.componentOptions;!function(e,t,n,s,o){const i=s.data.scopedSlots,c=e.$scopedSlots,a=!!(i&&!i.$stable||c!==r&&!c.$stable||i&&e.$scopedSlots.$key!==i.$key||!i&&e.$scopedSlots.$key),l=!!(o||e.$options._renderChildren||a);if(e.$options._parentVnode=s,e.$vnode=s,e._vnode&&(e._vnode.parent=s),e.$options._renderChildren=o,e.$attrs=s.data.attrs||r,e.$listeners=n||r,t&&e.$options.props){be(!1);const n=e._props,r=e.$options._propKeys||[];for(let s=0;s<r.length;s++){const o=r[s],i=e.$options.props;n[o]=Ee(o,i,t,e)}be(!0),e.$options.propsData=t}n=n||r;const u=e.$options._parentListeners;e.$options._parentListeners=n,Fs(e,n,u),l&&(e.$slots=_s(o,s.context),e.$forceUpdate())}(t.componentInstance=e.componentInstance,n.propsData,n.listeners,t,n.children)},insert(e){const{context:t,componentInstance:n}=e;n._isMounted||(n._isMounted=!0,Is(n,"mounted")),e.data.keepAlive&&(t._isMounted?function(e){e._inactive=!1}(n):Ns(n,!0))},destroy(e){const{componentInstance:t}=e;t._isDestroyed||(e.data.keepAlive?Es(t,!0):t.$destroy())}},Us=Object.keys(Bs);function qs(e,t,n,c,l){if(s(e))return;const u=n.$options._base;if(a(e)&&(e=u.extend(e)),"function"!=typeof e)return;let f;if(s(e.cid)&&(f=e,void 0===(e=i((p=f).error)&&o(p.errorComp)?p.errorComp:o(p.resolved)?p.resolved:i(p.loading)&&o(p.loadingComp)?p.loadingComp:void 0)))return function(e,t,n,r,s){const o=V();return o.asyncFactory=e,o.asyncMeta={data:t,context:n,children:r,tag:s},o}(f,t,n,c,l);var p;t=t||{},Rs(e),o(t.model)&&function(e,t){const n=e.model&&e.model.prop||"value",r=e.model&&e.model.event||"input";(t.attrs||(t.attrs={}))[n]=t.model.value;const s=t.on||(t.on={}),i=s[r],c=t.model.callback;o(i)?(Array.isArray(i)?-1===i.indexOf(c):i!==c)&&(s[r]=[c].concat(i)):s[r]=c}(e.options,t);const d=function(e,t,n){const r=t.options.props;if(s(r))return;const i={},{attrs:c,props:a}=e;if(o(c)||o(a))for(const e in r){const t=w(e);ss(i,a,e,t,!0)||ss(i,c,e,t,!1)}return i}(t,e);if(i(e.options.functional))return function(e,t,n,s,i){const c=e.options,a={},l=c.props;if(o(l))for(const e in l)a[e]=Ee(e,l,t||r);else o(n.attrs)&&zs(a,n.attrs),o(n.props)&&zs(a,n.props);const u=new Ds(n,a,i,s,e),f=c.render.call(null,u._c,u);if(f instanceof H)return Ls(f,n,u.parent,c);if(Array.isArray(f)){const e=Wr(f)||[],t=new Array(e.length);for(let r=0;r<e.length;r++)t[r]=Ls(e[r],n,u.parent,c);return t}}(e,d,t,n,c);const h=t.on;if(t.on=t.nativeOn,i(e.options.abstract)){const e=t.slot;t={},e&&(t.slot=e)}!function(e){const t=e.hook||(e.hook={});for(let e=0;e<Us.length;e++){const n=Us[e],r=t[n],s=Bs[n];r===s||r&&r._merged||(t[n]=r?Ks(s,r):s)}}(t);const m=e.options.name||l;return new H(`vue-component-${e.cid}${m?`-${m}`:""}`,t,void 0,void 0,void 0,n,{Ctor:e,propsData:d,listeners:h,tag:l,children:c},f)}function Js(e,t){const n={_isComponent:!0,_parentVnode:e,parent:t},r=e.data.inlineTemplate;return o(r)&&(n.render=r.render,n.staticRenderFns=r.staticRenderFns),new e.componentOptions.Ctor(n)}function Ks(e,t){const n=(n,r)=>{e(n,r),t(n,r)};return n._merged=!0,n}let Hs=Object.create(null);const Vs=e=>{Hs[e]||(Hs[e]=!0,console.warn(`\n\x1b[31m${e}\x1b[39m\n`))},Ws=(e,t)=>{const n=t?undefined(t):"";throw new Error(`\n\x1b[31m${e}${n}\x1b[39m\n`)},Zs=e=>{const{render:t,template:n,_scopeId:r}=e.$options;if(s(t)){if(!n)throw new Error(`render function or template not defined in component: ${e.$options.name||e.$options._componentTag||"anonymous"}`);{const t=Hr(n,{scopeId:r,warn:Ws},e);e.$options.render=t.render,e.$options.staticRenderFns=t.staticRenderFns}}};function Xs(e,t,n){let r=e.$options.serverPrefetch;if(o(r)){Array.isArray(r)||(r=[r]);try{const s=[];for(let t=0,n=r.length;t<n;t++){const n=r[t].call(e,e);n&&"function"==typeof n.then&&s.push(n)}return void Promise.all(s).then(t).catch(n)}catch(e){n(e)}}t()}function Gs(e,t,n){e.isString?function(e,t){const{write:n,next:r}=t;if(s(e.children)||0===e.children.length)n(e.open+(e.close||""),r);else{const s=e.children;t.renderStates.push({type:"Element",children:s,rendered:0,total:s.length,endTag:e.close}),n(e.open,r)}}(e,n):o(e.componentOptions)?Ys(e,t,n):o(e.tag)?function(e,t,n){const{write:r,next:c}=n;i(t)&&(e.data||(e.data={}),e.data.attrs||(e.data.attrs={}),e.data.attrs["data-server-rendered"]="true");e.fnOptions&&Qs(e.fnOptions,r);const a=function(e,t){let n=`<${e.tag}`;const{directives:r,modules:i}=t;s(e.data)&&no(e)&&(e.data={});if(o(e.data)){const s=e.data.directives;if(s)for(let n=0;n<s.length;n++){const r=s[n].name;if("show"!==r){const o=Ne(t,"directives",r);o&&o(e,s[n])}}const c=function(e){let t,n;for(;o(e);)e.data&&e.data.directives&&(n=e.data.directives.find((e=>"show"===e.name)),n&&(t=n)),e=e.parent;return t}(e);c&&r.show(e,c);for(let t=0;t<i.length;t++){const r=i[t](e);r&&(n+=r)}}let c;const a=t.activeInstance;o(a)&&a!==e.context&&o(c=a.$options._scopeId)&&(n+=` ${c}`);if(o(e.fnScopeId))n+=` ${e.fnScopeId}`;else for(;o(e);)o(c=e.context.$options._scopeId)&&(n+=` ${c}`),e=e.parent;return n+">"}(e,n),l=`</${e.tag}>`;if(n.isUnaryTag(e.tag))r(a,c);else if(s(e.children)||0===e.children.length)r(a+l,c);else{const t=e.children;n.renderStates.push({type:"Element",children:t,rendered:0,total:t.length,endTag:l}),r(a,c)}}(e,t,n):i(e.isComment)?o(e.asyncFactory)?function(e,t,n){const r=e.asyncFactory,s=r=>{r.__esModule&&r.default&&(r=r.default);const{data:s,children:o,tag:i}=e.asyncMeta,c=qs(r,s,e.asyncMeta.context,o,i);c?c.componentOptions?Ys(c,t,n):Array.isArray(c)?(n.renderStates.push({type:"Fragment",children:c,rendered:0,total:c.length}),n.next()):Gs(c,t,n):n.write("\x3c!----\x3e",n.next)};if(r.resolved)return void s(r.resolved);const o=n.done;let i;try{i=r(s,o)}catch(e){o(e)}if(i)if("function"==typeof i.then)i.then(s,o).catch(o);else{const e=i.component;e&&"function"==typeof e.then&&e.then(s,o).catch(o)}}(e,t,n):n.write(`\x3c!--${e.text}--\x3e`,n.next):n.write(e.raw?e.text:R(String(e.text)),n.next)}function Qs(e,t){const n=e._ssrRegister;return t.caching&&o(n)&&t.componentBuffer[t.componentBuffer.length-1].add(n),n}function Ys(e,t,n){const{write:r,next:i,userContext:c}=n,a=e.componentOptions.Ctor,l=a.options.serverCacheKey,u=a.options.name,f=n.cache,p=Qs(a.options,r);if(o(l)&&o(f)&&o(u)){const s=l(e.componentOptions.propsData);if(!1===s)return void to(e,t,n);const a=u+"::"+s,{has:f,get:d}=n;o(f)?f(a,(s=>{!0===s&&o(d)?d(a,(e=>{o(p)&&p(c),e.components.forEach((e=>e(c))),r(e.html,i)})):eo(e,t,a,n)})):o(d)&&d(a,(s=>{o(s)?(o(p)&&p(c),s.components.forEach((e=>e(c))),r(s.html,i)):eo(e,t,a,n)}))}else o(l)&&s(f)&&Vs(`[vue-server-renderer] Component ${a.options.name||"(anonymous)"} implemented serverCacheKey, but no cache was provided to the renderer.`),o(l)&&s(u)&&Vs('[vue-server-renderer] Components that implement "serverCacheKey" must also define a unique "name" option.'),to(e,t,n)}function eo(e,t,n,r){const s=r.write;s.caching=!0;const o=s.cacheBuffer,i=o.push("")-1,c=s.componentBuffer;c.push(new Set),r.renderStates.push({type:"ComponentWithCache",key:n,buffer:o,bufferIndex:i,componentBuffer:c}),to(e,t,r)}function to(e,t,n){const r=n.activeInstance;e.ssrContext=n.userContext;const s=n.activeInstance=Js(e,n.activeInstance);Zs(s);const o=n.done;Xs(s,(()=>{const o=s._render();o.parent=e,n.renderStates.push({type:"Component",prevActive:r}),Gs(o,t,n)}),o)}function no(e){const t=e.parent;return o(t)&&(o(t.data)||no(t))}function ro(e,t,n,r){return function(s,o,i,c){Hs=Object.create(null);const a=new ft({activeInstance:s,userContext:i,write:o,done:c,renderNode:Gs,isUnaryTag:n,modules:e,directives:t,cache:r});!function(e){if(e._ssrNode)return;let t=e.constructor;for(;t.super;)t=t.super;S(t.prototype,Gr),t.FunctionalRenderContext&&S(t.FunctionalRenderContext.prototype,Gr)}(s),Zs(s);Xs(s,(()=>{Gs(s._render(),!0,a)}),c)}}const so=e=>/\.js(\?[^.]+)?$/.test(e);function oo(){let e,t;return{promise:new Promise(((n,r)=>{e=n,t=r})),cb:(n,r)=>{if(n)return t(n);e(r||"")}}}class io extends e.Transform{started;renderer;template;context;inject;constructor(e,t,n){super(),this.started=!1,this.renderer=e,this.template=t,this.context=n||{},this.inject=e.inject}_transform(e,t,n){this.started||(this.emit("beforeStart"),this.start()),this.push(e),n()}start(){if(this.started=!0,this.push(this.template.head(this.context)),this.inject){this.context.head&&this.push(this.context.head);const e=this.renderer.renderResourceHints(this.context);e&&this.push(e);const t=this.renderer.renderStyles(this.context);t&&this.push(t)}this.push(this.template.neck(this.context))}_flush(e){if(this.emit("beforeEnd"),this.inject){const e=this.renderer.renderState(this.context);e&&this.push(e);const t=this.renderer.renderScripts(this.context);t&&this.push(t)}this.push(this.template.tail(this.context)),e()}}const co=require("lodash.template"),ao={escape:/{{([^{][\s\S]+?[^}])}}/g,interpolate:/{{{([\s\S]+?)}}}/g};function lo(e){const t=function(e){const t=new Map;return Object.keys(e.modules).forEach((n=>{t.set(n,function(e,t){const n=[],r=t.modules[e];r&&r.forEach((e=>{const r=t.all[e];r&&(t.async.indexOf(r)>-1||!/\.(js|css)($|\?)/.test(r))&&n.push(r)}));return n}(n,e))})),t}(e);return function(e){const n=new Set;for(let r=0;r<e.length;r++){const s=t.get(e[r]);if(s)for(let e=0;e<s.length;e++)n.add(s[e])}return Array.from(n)}}const uo=require("path"),fo=require("serialize-javascript");class po{options;inject;parsedTemplate;publicPath;clientManifest;preloadFiles;prefetchFiles;mapFiles;serialize;constructor(e){this.options=e,this.inject=!1!==e.inject;const{template:t}=e;if(this.parsedTemplate=t?"string"==typeof t?function(e,t="\x3c!--vue-ssr-outlet--\x3e"){if("object"==typeof e)return e;let n=e.indexOf("</head>");const r=e.indexOf(t);if(r<0)throw new Error("Content placeholder not found in template.");return n<0&&(n=e.indexOf("<body>"),n<0&&(n=r)),{head:co(e.slice(0,n),ao),neck:co(e.slice(n,r),ao),tail:co(e.slice(r+t.length),ao)}}(t):t:null,this.serialize=e.serializer||(e=>fo(e,{isJSON:!0})),e.clientManifest){const t=this.clientManifest=e.clientManifest;this.publicPath=""===t.publicPath?"":t.publicPath.replace(/([^\/])$/,"$1/"),this.preloadFiles=(t.initial||[]).map(ho),this.prefetchFiles=(t.async||[]).map(ho),this.mapFiles=lo(t)}}bindRenderFns(e){const t=this;["ResourceHints","State","Scripts","Styles"].forEach((n=>{e[`render${n}`]=t[`render${n}`].bind(t,e)})),e.getPreloadFiles=t.getPreloadFiles.bind(t,e)}render(e,t){const n=this.parsedTemplate;if(!n)throw new Error("render cannot be called without a template.");return t=t||{},"function"==typeof n?n(e,t):this.inject?n.head(t)+(t.head||"")+this.renderResourceHints(t)+this.renderStyles(t)+n.neck(t)+e+this.renderState(t)+this.renderScripts(t)+n.tail(t):n.head(t)+n.neck(t)+e+n.tail(t)}renderStyles(e){const t=this.preloadFiles||[],n=this.getUsedAsyncFiles(e)||[],r=t.concat(n).filter((({file:e})=>(e=>/\.css(\?[^.]+)?$/.test(e))(e)));return(r.length?r.map((({file:e})=>`<link rel="stylesheet" href="${this.publicPath}${e}">`)).join(""):"")+(e.styles||"")}renderResourceHints(e){return this.renderPreloadLinks(e)+this.renderPrefetchLinks(e)}getPreloadFiles(e){const t=this.getUsedAsyncFiles(e);return this.preloadFiles||t?(this.preloadFiles||[]).concat(t||[]):[]}renderPreloadLinks(e){const t=this.getPreloadFiles(e),n=this.options.shouldPreload;return t.length?t.map((({file:e,extension:t,fileWithoutQuery:r,asType:s})=>{let o="";return n||"script"===s||"style"===s?n&&!n(r,s)?"":("font"===s&&(o=` type="font/${t}" crossorigin`),`<link rel="preload" href="${this.publicPath}${e}"${""!==s?` as="${s}"`:""}${o}>`):""})).join(""):""}renderPrefetchLinks(e){const t=this.options.shouldPrefetch;if(this.prefetchFiles){const n=this.getUsedAsyncFiles(e),r=e=>n&&n.some((t=>t.file===e));return this.prefetchFiles.map((({file:e,fileWithoutQuery:n,asType:s})=>t&&!t(n,s)||r(e)?"":`<link rel="prefetch" href="${this.publicPath}${e}">`)).join("")}return""}renderState(e,t){const{contextKey:n="state",windowKey:r="__INITIAL_STATE__"}=t||{},s=this.serialize(e[n]),o=e.nonce?` nonce="${e.nonce}"`:"";return e[n]?`<script${o}>window.${r}=${s};(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());<\/script>`:""}renderScripts(e){if(this.clientManifest){const t=this.preloadFiles.filter((({file:e})=>so(e))),n=(this.getUsedAsyncFiles(e)||[]).filter((({file:e})=>so(e)));return[t[0]].concat(n,t.slice(1)).map((({file:e})=>`<script src="${this.publicPath}${e}" defer><\/script>`)).join("")}return""}getUsedAsyncFiles(e){if(!e._mappedFiles&&e._registeredComponents&&this.mapFiles){const t=Array.from(e._registeredComponents);e._mappedFiles=this.mapFiles(t).map(ho)}return e._mappedFiles}createStream(e){if(!this.parsedTemplate)throw new Error("createStream cannot be called without a template.");return new io(this,this.parsedTemplate,e||{})}}function ho(e){const t=e.replace(/\?.*/,""),n=uo.extname(t).slice(1);return{file:e,extension:n,fileWithoutQuery:t,asType:mo(n)}}function mo(e){return"js"===e?"script":"css"===e?"style":/jpe?g|png|svg|gif|webp|ico/.test(e)?"image":/woff2?|ttf|otf|eot/.test(e)?"font":""}const yo=require("vm"),go=require("path"),$o=require("resolve"),vo=require("module");function bo(e){const t={Buffer:Buffer,console:console,process:process,setTimeout:setTimeout,setInterval:setInterval,setImmediate:setImmediate,clearTimeout:clearTimeout,clearInterval:clearInterval,clearImmediate:clearImmediate,__VUE_SSR_CONTEXT__:e};return t.global=t,t}function _o(e,t,n){const r={},s={};return function o(i,c,a={}){if(a[i])return a[i];const l=function(t){if(r[t])return r[t];const n=e[t],s=vo.wrap(n),o=new yo.Script(s,{filename:t,displayErrors:!0});return r[t]=o,o}(i),u={exports:{}};(!1===n?l.runInThisContext():l.runInNewContext(c)).call(u.exports,u.exports,(n=>(n=go.posix.join(".",n),e[n]?o(n,c,a):t?require(s[n]||(s[n]=$o.sync(n,{basedir:t}))):require(n))),u);const f=Object.prototype.hasOwnProperty.call(u.exports,"default")?u.exports.default:u.exports;return a[i]=f,f}}function xo(e){if(u(e)){const t={};for(const n in e)t[n]=xo(e[n]);return t}return Array.isArray(e)?e.slice():e}function wo(e,t,n,r){const s=_o(t,n,r);if(!1!==r&&"once"!==r)return(t={})=>new Promise((n=>{t._registeredComponents=new Set;const r=s(e,bo(t));n("function"==typeof r?r(t):r)}));{let t,n;return(o={})=>new Promise((i=>{if(!t){const o="once"===r?bo():global;if(n=o.__VUE_SSR_CONTEXT__={},t=s(e,o),delete o.__VUE_SSR_CONTEXT__,"function"!=typeof t)throw new Error("bundle export should be a function when using { runInNewContext: false }.")}if(o._registeredComponents=new Set,n._styles){o._styles=xo(n._styles);const e=n._renderStyles;e&&Object.defineProperty(o,"styles",{enumerable:!0,get:()=>e(o._styles)})}i(t(o))}))}}const So=require("source-map").SourceMapConsumer,ko=/\(([^)]+\.js):(\d+):(\d+)\)$/;function Ao(e,t){e&&"string"==typeof e.stack&&(e.stack=e.stack.split("\n").map((e=>function(e,t){const n=e.match(ko),r=n&&t[n[1]];if(null!=n&&r){const t=r.originalPositionFor({line:Number(n[2]),column:Number(n[3])});if(null!=t.source){const{source:n,line:r,column:s}=t,o=`(${n.replace(/^webpack:\/\/\//,"")}:${String(r)}:${String(s)})`;return e.replace(ko,o)}return e}return e}(e,t))).join("\n"))}const Oo=require("fs"),Co=require("path"),To=require("stream").PassThrough,jo="Invalid server-rendering bundle format. Should be a string or a bundle Object of type:\n\n{\n  entry: string;\n  files: { [filename: string]: string; };\n  maps: { [filename: string]: string; };\n}\n";function Fo(e={}){return function({modules:e=[],directives:t={},isUnaryTag:n=(()=>!1),template:r,inject:s,cache:o,shouldPreload:i,shouldPrefetch:c,clientManifest:a,serializer:l}={}){const u=ro(e,t,n,o),f=new po({template:r,inject:s,shouldPreload:i,shouldPrefetch:c,clientManifest:a,serializer:l});return{renderToString(e,t,n){let s;"function"==typeof t&&(n=t,t={}),t&&f.bindRenderFns(t),n||({promise:s,cb:n}=oo());let o="";const i=lt((e=>(o+=e,!1)),n);try{u(e,i,t,(e=>{if(e)return n(e);if(t&&t.rendered&&t.rendered(t),r)try{const e=f.render(o,t);"string"!=typeof e?e.then((e=>n(null,e))).catch(n):n(null,e)}catch(e){n(e)}else n(null,o)}))}catch(e){n(e)}return s},renderToStream(e,t){t&&f.bindRenderFns(t);const n=new ut(((n,r)=>{u(e,n,t,r)}));if(r){if("function"==typeof r)throw new Error("function template is only supported in renderToString.");{const e=f.createStream(t);if(n.on("error",(t=>{e.emit("error",t)})),n.pipe(e),t&&t.rendered){const e=t.rendered;n.once("beforeEnd",(()=>{e(t)}))}return e}}if(t&&t.rendered){const e=t.rendered;n.once("beforeEnd",(()=>{e(t)}))}return n}}}(S(S({},e),{isUnaryTag:st,canBeLeftOpenTag:ot,modules:et,directives:S(rt,e.directives)}))}process.env.VUE_ENV="server";const Po=function(e){return function(t,n={}){let r,s,o,i=n.basedir;if("string"==typeof t&&/\.js(on)?$/.test(t)&&Co.isAbsolute(t)){if(!Oo.existsSync(t))throw new Error(`Cannot locate bundle file: ${t}`);{const e=/\.json$/.test(t);if(i=i||Co.dirname(t),t=Oo.readFileSync(t,"utf-8"),e)try{t=JSON.parse(t)}catch(e){throw new Error(`Invalid JSON bundle file: ${t}`)}}}if("object"==typeof t){if(s=t.entry,r=t.files,i=i||t.basedir,o=function(e){const t={};return Object.keys(e).forEach((n=>{t[n]=new So(e[n])})),t}(t.maps),"string"!=typeof s||"object"!=typeof r)throw new Error(jo)}else{if("string"!=typeof t)throw new Error(jo);s="__vue_ssr_bundle__",r={__vue_ssr_bundle__:t},o={}}const c=e(n),a=wo(s,r,i,n.runInNewContext);return{renderToString:(e,t)=>{let n;return"function"==typeof e&&(t=e,e={}),t||({promise:n,cb:t}=oo()),a(e).catch((e=>{Ao(e,o),t(e)})).then((n=>{n&&c.renderToString(n,e,((e,n)=>{Ao(e,o),t(e,n)}))})),n},renderToStream:e=>{const t=new To;return a(e).catch((e=>{Ao(e,o),process.nextTick((()=>{t.emit("error",e)}))})).then((r=>{if(r){const s=c.renderToStream(r,e);s.on("error",(e=>{Ao(e,o),t.emit("error",e)})),n&&n.template&&(s.on("beforeStart",(()=>{t.emit("beforeStart")})),s.on("beforeEnd",(()=>{t.emit("beforeEnd")}))),s.pipe(t)}})),t}}}}(Fo);exports.createBundleRenderer=Po,exports.createRenderer=Fo;
\ No newline at end of file
diff --git a/packages/vue-server-renderer/client-plugin.js b/packages/vue-server-renderer/client-plugin.js
deleted file mode 100644
index 40af65818a0..00000000000
--- a/packages/vue-server-renderer/client-plugin.js
+++ /dev/null
@@ -1,113 +0,0 @@
-'use strict';
-
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
-const isCSS = (file) => /\.css(\?[^.]+)?$/.test(file);
-
-const { red, yellow } = require('chalk');
-const webpack = require('webpack');
-const prefix = `[vue-server-renderer-webpack-plugin]`;
-exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
-exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
-const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-const onEmit = (compiler, name, stageName, hook) => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        compiler.hooks.compilation.tap(name, compilation => {
-            if (compilation.compiler !== compiler) {
-                // Ignore child compilers
-                return;
-            }
-            const stage = webpack.Compilation[stageName];
-            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-                hook(compilation, cb);
-            });
-        });
-    }
-    else if (compiler.hooks) {
-        // Webpack >= 4.0.0
-        compiler.hooks.emit.tapAsync(name, hook);
-    }
-    else {
-        // Webpack < 4.0.0
-        compiler.plugin('emit', hook);
-    }
-};
-const stripModuleIdHash = id => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        return id.replace(/\|\w+$/, '');
-    }
-    // Webpack < 5.0.0
-    return id.replace(/\s\w+$/, '');
-};
-const getAssetName = asset => {
-    if (typeof asset === 'string') {
-        return asset;
-    }
-    return asset.name;
-};
-
-const hash = require("hash-sum");
-const uniq = require("lodash.uniq");
-class VueSSRClientPlugin {
-    constructor(options = {}) {
-        //@ts-expect-error no type on options
-        this.options = Object.assign({
-            filename: "vue-ssr-client-manifest.json",
-        }, options);
-    }
-    apply(compiler) {
-        const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
-        onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
-            const stats = compilation.getStats().toJson();
-            const allFiles = uniq(stats.assets.map((a) => a.name));
-            const initialFiles = uniq(Object.keys(stats.entrypoints)
-                .map((name) => stats.entrypoints[name].assets)
-                .reduce((assets, all) => all.concat(assets), [])
-                .map(getAssetName)
-                .filter((file) => isJS(file) || isCSS(file)));
-            const asyncFiles = allFiles
-                .filter((file) => isJS(file) || isCSS(file))
-                .filter((file) => initialFiles.indexOf(file) < 0);
-            const manifest = {
-                publicPath: stats.publicPath,
-                all: allFiles,
-                initial: initialFiles,
-                async: asyncFiles,
-                modules: {
-                /* [identifier: string]: Array<index: number> */
-                },
-            };
-            const assetModules = stats.modules.filter((m) => m.assets.length);
-            const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
-            stats.modules.forEach((m) => {
-                // ignore modules duplicated in multiple chunks
-                if (m.chunks.length === 1) {
-                    const cid = m.chunks[0];
-                    const chunk = stats.chunks.find((c) => c.id === cid);
-                    if (!chunk || !chunk.files) {
-                        return;
-                    }
-                    const id = stripModuleIdHash(m.identifier);
-                    const files = (manifest.modules[hash(id)] =
-                        chunk.files.map(fileToIndex));
-                    // find all asset modules associated with the same chunk
-                    assetModules.forEach((m) => {
-                        if (m.chunks.some((id) => id === cid)) {
-                            files.push.apply(files, m.assets.map(fileToIndex));
-                        }
-                    });
-                }
-            });
-            const json = JSON.stringify(manifest, null, 2);
-            //@ts-expect-error no type on options
-            compilation.assets[this.options.filename] = {
-                source: () => json,
-                size: () => json.length,
-            };
-            cb();
-        });
-    }
-}
-
-module.exports = VueSSRClientPlugin;
diff --git a/packages/vue-server-renderer/server-plugin.js b/packages/vue-server-renderer/server-plugin.js
deleted file mode 100644
index d8682e73387..00000000000
--- a/packages/vue-server-renderer/server-plugin.js
+++ /dev/null
@@ -1,118 +0,0 @@
-'use strict';
-
-const isJS = (file) => /\.js(\?[^.]+)?$/.test(file);
-
-const { red, yellow } = require('chalk');
-const webpack = require('webpack');
-const prefix = `[vue-server-renderer-webpack-plugin]`;
-const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`));
-const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`));
-const isWebpack5 = !!(webpack.version && webpack.version[0] > 4);
-const validate = compiler => {
-    if (compiler.options.target !== 'node') {
-        warn('webpack config `target` should be "node".');
-    }
-    if (compiler.options.output) {
-        if (compiler.options.output.library) {
-            // Webpack >= 5.0.0
-            if (compiler.options.output.library.type !== 'commonjs2') {
-                warn('webpack config `output.library.type` should be "commonjs2".');
-            }
-        }
-        else if (compiler.options.output.libraryTarget !== 'commonjs2') {
-            // Webpack < 5.0.0
-            warn('webpack config `output.libraryTarget` should be "commonjs2".');
-        }
-    }
-    if (!compiler.options.externals) {
-        tip('It is recommended to externalize dependencies in the server build for ' +
-            'better build performance.');
-    }
-};
-const onEmit = (compiler, name, stageName, hook) => {
-    if (isWebpack5) {
-        // Webpack >= 5.0.0
-        compiler.hooks.compilation.tap(name, compilation => {
-            if (compilation.compiler !== compiler) {
-                // Ignore child compilers
-                return;
-            }
-            const stage = webpack.Compilation[stageName];
-            compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-                hook(compilation, cb);
-            });
-        });
-    }
-    else if (compiler.hooks) {
-        // Webpack >= 4.0.0
-        compiler.hooks.emit.tapAsync(name, hook);
-    }
-    else {
-        // Webpack < 4.0.0
-        compiler.plugin('emit', hook);
-    }
-};
-const getAssetName = asset => {
-    if (typeof asset === 'string') {
-        return asset;
-    }
-    return asset.name;
-};
-
-class VueSSRServerPlugin {
-    constructor(options = {}) {
-        //@ts-expect-error
-        this.options = Object.assign({
-            filename: 'vue-ssr-server-bundle.json',
-        }, options);
-    }
-    apply(compiler) {
-        validate(compiler);
-        const stage = 'PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER';
-        onEmit(compiler, 'vue-server-plugin', stage, (compilation, cb) => {
-            const stats = compilation.getStats().toJson();
-            const entryName = Object.keys(stats.entrypoints)[0];
-            const entryInfo = stats.entrypoints[entryName];
-            if (!entryInfo) {
-                // #5553
-                return cb();
-            }
-            const entryAssets = entryInfo.assets
-                .map(getAssetName)
-                .filter(isJS);
-            if (entryAssets.length > 1) {
-                throw new Error(`Server-side bundle should have one single entry file. ` +
-                    `Avoid using CommonsChunkPlugin in the server config.`);
-            }
-            const entry = entryAssets[0];
-            if (!entry || typeof entry !== 'string') {
-                throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
-            }
-            const bundle = {
-                entry,
-                files: {},
-                maps: {},
-            };
-            Object.keys(compilation.assets).forEach(name => {
-                if (isJS(name)) {
-                    bundle.files[name] = compilation.assets[name].source();
-                }
-                else if (name.match(/\.js\.map$/)) {
-                    bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source());
-                }
-                // do not emit anything else for server
-                delete compilation.assets[name];
-            });
-            const json = JSON.stringify(bundle, null, 2);
-            //@ts-expect-error
-            const filename = this.options.filename;
-            compilation.assets[filename] = {
-                source: () => json,
-                size: () => json.length,
-            };
-            cb();
-        });
-    }
-}
-
-module.exports = VueSSRServerPlugin;
diff --git a/packages/vue-template-compiler/browser.js b/packages/vue-template-compiler/browser.js
deleted file mode 100644
index 5a1007309da..00000000000
--- a/packages/vue-template-compiler/browser.js
+++ /dev/null
@@ -1,4945 +0,0 @@
-(function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-	typeof define === 'function' && define.amd ? define(['exports'], factory) :
-	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.VueTemplateCompiler = {}));
-})(this, (function (exports) { 'use strict';
-
-	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-	var splitRE$1 = /\r?\n/g;
-	var emptyRE = /^\s*$/;
-	var needFixRE = /^(\r?\n)*[\t\s]/;
-
-	var deIndent = function deindent (str) {
-	  if (!needFixRE.test(str)) {
-	    return str
-	  }
-	  var lines = str.split(splitRE$1);
-	  var min = Infinity;
-	  var type, cur, c;
-	  for (var i = 0; i < lines.length; i++) {
-	    var line = lines[i];
-	    if (!emptyRE.test(line)) {
-	      if (!type) {
-	        c = line.charAt(0);
-	        if (c === ' ' || c === '\t') {
-	          type = c;
-	          cur = count(line, type);
-	          if (cur < min) {
-	            min = cur;
-	          }
-	        } else {
-	          return str
-	        }
-	      } else {
-	        cur = count(line, type);
-	        if (cur < min) {
-	          min = cur;
-	        }
-	      }
-	    }
-	  }
-	  return lines.map(function (line) {
-	    return line.slice(min)
-	  }).join('\n')
-	};
-
-	function count (line, type) {
-	  var i = 0;
-	  while (line.charAt(i) === type) {
-	    i++;
-	  }
-	  return i
-	}
-
-	const emptyObject = Object.freeze({});
-	// These helpers produce better VM code in JS engines due to their
-	// explicitness and function inlining.
-	function isUndef(v) {
-	    return v === undefined || v === null;
-	}
-	/**
-	 * Check if value is primitive.
-	 */
-	function isPrimitive(value) {
-	    return (typeof value === 'string' ||
-	        typeof value === 'number' ||
-	        // $flow-disable-line
-	        typeof value === 'symbol' ||
-	        typeof value === 'boolean');
-	}
-	/**
-	 * Quick object check - this is primarily used to tell
-	 * objects from primitive values when we know the value
-	 * is a JSON-compliant type.
-	 */
-	function isObject(obj) {
-	    return obj !== null && typeof obj === 'object';
-	}
-	/**
-	 * Get the raw type string of a value, e.g., [object Object].
-	 */
-	const _toString = Object.prototype.toString;
-	function toRawType(value) {
-	    return _toString.call(value).slice(8, -1);
-	}
-	/**
-	 * Strict object type check. Only returns true
-	 * for plain JavaScript objects.
-	 */
-	function isPlainObject(obj) {
-	    return _toString.call(obj) === '[object Object]';
-	}
-	/**
-	 * Check if val is a valid array index.
-	 */
-	function isValidArrayIndex(val) {
-	    const n = parseFloat(String(val));
-	    return n >= 0 && Math.floor(n) === n && isFinite(val);
-	}
-	/**
-	 * Make a map and return a function for checking if a key
-	 * is in that map.
-	 */
-	function makeMap(str, expectsLowerCase) {
-	    const map = Object.create(null);
-	    const list = str.split(',');
-	    for (let i = 0; i < list.length; i++) {
-	        map[list[i]] = true;
-	    }
-	    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-	}
-	/**
-	 * Check if a tag is a built-in tag.
-	 */
-	const isBuiltInTag = makeMap('slot,component', true);
-	/**
-	 * Check if an attribute is a reserved attribute.
-	 */
-	makeMap('key,ref,slot,slot-scope,is');
-	/**
-	 * Remove an item from an array.
-	 */
-	function remove(arr, item) {
-	    if (arr.length) {
-	        const index = arr.indexOf(item);
-	        if (index > -1) {
-	            return arr.splice(index, 1);
-	        }
-	    }
-	}
-	/**
-	 * Check whether an object has the property.
-	 */
-	const hasOwnProperty = Object.prototype.hasOwnProperty;
-	function hasOwn(obj, key) {
-	    return hasOwnProperty.call(obj, key);
-	}
-	/**
-	 * Create a cached version of a pure function.
-	 */
-	function cached(fn) {
-	    const cache = Object.create(null);
-	    return function cachedFn(str) {
-	        const hit = cache[str];
-	        return hit || (cache[str] = fn(str));
-	    };
-	}
-	/**
-	 * Camelize a hyphen-delimited string.
-	 */
-	const camelizeRE = /-(\w)/g;
-	const camelize = cached((str) => {
-	    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-	});
-	/**
-	 * Hyphenate a camelCase string.
-	 */
-	const hyphenateRE = /\B([A-Z])/g;
-	const hyphenate = cached((str) => {
-	    return str.replace(hyphenateRE, '-$1').toLowerCase();
-	});
-	/**
-	 * Mix properties into target object.
-	 */
-	function extend(to, _from) {
-	    for (const key in _from) {
-	        to[key] = _from[key];
-	    }
-	    return to;
-	}
-	/* eslint-disable no-unused-vars */
-	/**
-	 * Perform no operation.
-	 * Stubbing args to make Flow happy without leaving useless transpiled code
-	 * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-	 */
-	function noop(a, b, c) { }
-	/**
-	 * Always return false.
-	 */
-	const no = (a, b, c) => false;
-	/* eslint-enable no-unused-vars */
-	/**
-	 * Return the same value.
-	 */
-	const identity = (_) => _;
-	/**
-	 * Generate a string containing static keys from compiler modules.
-	 */
-	function genStaticKeys$1(modules) {
-	    return modules
-	        .reduce((keys, m) => {
-	        return keys.concat(m.staticKeys || []);
-	    }, [])
-	        .join(',');
-	}
-
-	const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-	    'link,meta,param,source,track,wbr');
-	// Elements that you can, intentionally, leave open
-	// (and which close themselves)
-	const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-	// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-	// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-	const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-	    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-	    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-	    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-	    'title,tr,track');
-
-	/**
-	 * unicode letters used for parsing html tags, component names and property paths.
-	 * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-	 * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-	 */
-	const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-	/**
-	 * Define a property.
-	 */
-	function def(obj, key, val, enumerable) {
-	    Object.defineProperty(obj, key, {
-	        value: val,
-	        enumerable: !!enumerable,
-	        writable: true,
-	        configurable: true,
-	    });
-	}
-
-	/**
-	 * Not type-checking this file because it's mostly vendor code.
-	 */
-	// Regular Expressions for parsing tags and attributes
-	const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-	const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-	const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-	const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-	const startTagOpen = new RegExp(`^<${qnameCapture}`);
-	const startTagClose = /^\s*(\/?)>/;
-	const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-	const doctype = /^<!DOCTYPE [^>]+>/i;
-	// #7298: escape - to avoid being passed as HTML comment when inlined in page
-	const comment = /^<!\--/;
-	const conditionalComment = /^<!\[/;
-	// Special Elements (can contain anything)
-	const isPlainTextElement = makeMap('script,style,textarea', true);
-	const reCache = {};
-	const decodingMap = {
-	    '&lt;': '<',
-	    '&gt;': '>',
-	    '&quot;': '"',
-	    '&amp;': '&',
-	    '&#10;': '\n',
-	    '&#9;': '\t',
-	    '&#39;': "'",
-	};
-	const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-	const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-	// #5992
-	const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-	const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-	function decodeAttr(value, shouldDecodeNewlines) {
-	    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-	    return value.replace(re, (match) => decodingMap[match]);
-	}
-	function parseHTML(html, options) {
-	    const stack = [];
-	    const expectHTML = options.expectHTML;
-	    const isUnaryTag = options.isUnaryTag || no;
-	    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-	    let index = 0;
-	    let last, lastTag;
-	    while (html) {
-	        last = html;
-	        // Make sure we're not in a plaintext content element like script/style
-	        if (!lastTag || !isPlainTextElement(lastTag)) {
-	            let textEnd = html.indexOf('<');
-	            if (textEnd === 0) {
-	                // Comment:
-	                if (comment.test(html)) {
-	                    const commentEnd = html.indexOf('-->');
-	                    if (commentEnd >= 0) {
-	                        if (options.shouldKeepComment) {
-	                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-	                        }
-	                        advance(commentEnd + 3);
-	                        continue;
-	                    }
-	                }
-	                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-	                if (conditionalComment.test(html)) {
-	                    const conditionalEnd = html.indexOf(']>');
-	                    if (conditionalEnd >= 0) {
-	                        advance(conditionalEnd + 2);
-	                        continue;
-	                    }
-	                }
-	                // Doctype:
-	                const doctypeMatch = html.match(doctype);
-	                if (doctypeMatch) {
-	                    advance(doctypeMatch[0].length);
-	                    continue;
-	                }
-	                // End tag:
-	                const endTagMatch = html.match(endTag);
-	                if (endTagMatch) {
-	                    const curIndex = index;
-	                    advance(endTagMatch[0].length);
-	                    parseEndTag(endTagMatch[1], curIndex, index);
-	                    continue;
-	                }
-	                // Start tag:
-	                const startTagMatch = parseStartTag();
-	                if (startTagMatch) {
-	                    handleStartTag(startTagMatch);
-	                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-	                        advance(1);
-	                    }
-	                    continue;
-	                }
-	            }
-	            let text, rest, next;
-	            if (textEnd >= 0) {
-	                rest = html.slice(textEnd);
-	                while (!endTag.test(rest) &&
-	                    !startTagOpen.test(rest) &&
-	                    !comment.test(rest) &&
-	                    !conditionalComment.test(rest)) {
-	                    // < in plain text, be forgiving and treat it as text
-	                    next = rest.indexOf('<', 1);
-	                    if (next < 0)
-	                        break;
-	                    textEnd += next;
-	                    rest = html.slice(textEnd);
-	                }
-	                text = html.substring(0, textEnd);
-	            }
-	            if (textEnd < 0) {
-	                text = html;
-	            }
-	            if (text) {
-	                advance(text.length);
-	            }
-	            if (options.chars && text) {
-	                options.chars(text, index - text.length, index);
-	            }
-	        }
-	        else {
-	            let endTagLength = 0;
-	            const stackedTag = lastTag.toLowerCase();
-	            const reStackedTag = reCache[stackedTag] ||
-	                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-	            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-	                endTagLength = endTag.length;
-	                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-	                    text = text
-	                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-	                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-	                }
-	                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-	                    text = text.slice(1);
-	                }
-	                if (options.chars) {
-	                    options.chars(text);
-	                }
-	                return '';
-	            });
-	            index += html.length - rest.length;
-	            html = rest;
-	            parseEndTag(stackedTag, index - endTagLength, index);
-	        }
-	        if (html === last) {
-	            options.chars && options.chars(html);
-	            if (!stack.length &&
-	                options.warn) {
-	                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-	                    start: index + html.length,
-	                });
-	            }
-	            break;
-	        }
-	    }
-	    // Clean up any remaining tags
-	    parseEndTag();
-	    function advance(n) {
-	        index += n;
-	        html = html.substring(n);
-	    }
-	    function parseStartTag() {
-	        const start = html.match(startTagOpen);
-	        if (start) {
-	            const match = {
-	                tagName: start[1],
-	                attrs: [],
-	                start: index,
-	            };
-	            advance(start[0].length);
-	            let end, attr;
-	            while (!(end = html.match(startTagClose)) &&
-	                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-	                attr.start = index;
-	                advance(attr[0].length);
-	                attr.end = index;
-	                match.attrs.push(attr);
-	            }
-	            if (end) {
-	                match.unarySlash = end[1];
-	                advance(end[0].length);
-	                match.end = index;
-	                return match;
-	            }
-	        }
-	    }
-	    function handleStartTag(match) {
-	        const tagName = match.tagName;
-	        const unarySlash = match.unarySlash;
-	        if (expectHTML) {
-	            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-	                parseEndTag(lastTag);
-	            }
-	            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-	                parseEndTag(tagName);
-	            }
-	        }
-	        const unary = isUnaryTag(tagName) || !!unarySlash;
-	        const l = match.attrs.length;
-	        const attrs = new Array(l);
-	        for (let i = 0; i < l; i++) {
-	            const args = match.attrs[i];
-	            const value = args[3] || args[4] || args[5] || '';
-	            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-	                ? options.shouldDecodeNewlinesForHref
-	                : options.shouldDecodeNewlines;
-	            attrs[i] = {
-	                name: args[1],
-	                value: decodeAttr(value, shouldDecodeNewlines),
-	            };
-	            if (options.outputSourceRange) {
-	                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-	                attrs[i].end = args.end;
-	            }
-	        }
-	        if (!unary) {
-	            stack.push({
-	                tag: tagName,
-	                lowerCasedTag: tagName.toLowerCase(),
-	                attrs: attrs,
-	                start: match.start,
-	                end: match.end,
-	            });
-	            lastTag = tagName;
-	        }
-	        if (options.start) {
-	            options.start(tagName, attrs, unary, match.start, match.end);
-	        }
-	    }
-	    function parseEndTag(tagName, start, end) {
-	        let pos, lowerCasedTagName;
-	        if (start == null)
-	            start = index;
-	        if (end == null)
-	            end = index;
-	        // Find the closest opened tag of the same type
-	        if (tagName) {
-	            lowerCasedTagName = tagName.toLowerCase();
-	            for (pos = stack.length - 1; pos >= 0; pos--) {
-	                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-	                    break;
-	                }
-	            }
-	        }
-	        else {
-	            // If no tag name is provided, clean shop
-	            pos = 0;
-	        }
-	        if (pos >= 0) {
-	            // Close all the open elements, up the stack
-	            for (let i = stack.length - 1; i >= pos; i--) {
-	                if ((i > pos || !tagName) &&
-	                    options.warn) {
-	                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-	                        start: stack[i].start,
-	                        end: stack[i].end,
-	                    });
-	                }
-	                if (options.end) {
-	                    options.end(stack[i].tag, start, end);
-	                }
-	            }
-	            // Remove the open elements from the stack
-	            stack.length = pos;
-	            lastTag = pos && stack[pos - 1].tag;
-	        }
-	        else if (lowerCasedTagName === 'br') {
-	            if (options.start) {
-	                options.start(tagName, [], true, start, end);
-	            }
-	        }
-	        else if (lowerCasedTagName === 'p') {
-	            if (options.start) {
-	                options.start(tagName, [], false, start, end);
-	            }
-	            if (options.end) {
-	                options.end(tagName, start, end);
-	            }
-	        }
-	    }
-	}
-
-	const splitRE = /\r?\n/g;
-	const replaceRE = /./g;
-	const isSpecialTag = makeMap('script,style,template', true);
-	/**
-	 * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
-	 */
-	function parseComponent(content, options = {}) {
-	    const sfc = {
-	        template: null,
-	        script: null,
-	        styles: [],
-	        customBlocks: [],
-	        errors: [],
-	    };
-	    let depth = 0;
-	    let currentBlock = null;
-	    let warn = (msg) => {
-	        sfc.errors.push(msg);
-	    };
-	    if (options.outputSourceRange) {
-	        warn = (msg, range) => {
-	            const data = { msg };
-	            if (range.start != null) {
-	                data.start = range.start;
-	            }
-	            if (range.end != null) {
-	                data.end = range.end;
-	            }
-	            sfc.errors.push(data);
-	        };
-	    }
-	    function start(tag, attrs, unary, start, end) {
-	        if (depth === 0) {
-	            currentBlock = {
-	                type: tag,
-	                content: '',
-	                start: end,
-	                attrs: attrs.reduce((cumulated, { name, value }) => {
-	                    cumulated[name] = value || true;
-	                    return cumulated;
-	                }, {}),
-	            };
-	            if (isSpecialTag(tag)) {
-	                checkAttrs(currentBlock, attrs);
-	                if (tag === 'style') {
-	                    sfc.styles.push(currentBlock);
-	                }
-	                else {
-	                    sfc[tag] = currentBlock;
-	                }
-	            }
-	            else {
-	                // custom blocks
-	                sfc.customBlocks.push(currentBlock);
-	            }
-	        }
-	        if (!unary) {
-	            depth++;
-	        }
-	    }
-	    function checkAttrs(block, attrs) {
-	        for (let i = 0; i < attrs.length; i++) {
-	            const attr = attrs[i];
-	            if (attr.name === 'lang') {
-	                block.lang = attr.value;
-	            }
-	            if (attr.name === 'scoped') {
-	                block.scoped = true;
-	            }
-	            if (attr.name === 'module') {
-	                block.module = attr.value || true;
-	            }
-	            if (attr.name === 'src') {
-	                block.src = attr.value;
-	            }
-	        }
-	    }
-	    function end(tag, start) {
-	        if (depth === 1 && currentBlock) {
-	            currentBlock.end = start;
-	            let text = content.slice(currentBlock.start, currentBlock.end);
-	            if (options.deindent !== false) {
-	                text = deIndent(text);
-	            }
-	            // pad content so that linters and pre-processors can output correct
-	            // line numbers in errors and warnings
-	            if (currentBlock.type !== 'template' && options.pad) {
-	                text = padContent(currentBlock, options.pad) + text;
-	            }
-	            currentBlock.content = text;
-	            currentBlock = null;
-	        }
-	        depth--;
-	    }
-	    function padContent(block, pad) {
-	        if (pad === 'space') {
-	            return content.slice(0, block.start).replace(replaceRE, ' ');
-	        }
-	        else {
-	            const offset = content.slice(0, block.start).split(splitRE).length;
-	            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
-	            return Array(offset).join(padChar);
-	        }
-	    }
-	    parseHTML(content, {
-	        warn,
-	        start,
-	        end,
-	        outputSourceRange: options.outputSourceRange,
-	    });
-	    return sfc;
-	}
-
-	// can we use __proto__?
-	const hasProto = '__proto__' in {};
-	// Browser environment sniffing
-	const inBrowser = typeof window !== 'undefined';
-	const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-	const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-	const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-	const isIE = UA && /msie|trident/.test(UA);
-	UA && UA.indexOf('msie 9.0') > 0;
-	const isEdge = UA && UA.indexOf('edge/') > 0;
-	(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-	(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-	UA && /chrome\/\d+/.test(UA) && !isEdge;
-	UA && /phantomjs/.test(UA);
-	UA && UA.match(/firefox\/(\d+)/);
-	// Firefox has a "watch" function on Object.prototype...
-	// @ts-expect-error firebox support
-	const nativeWatch = {}.watch;
-	let supportsPassive = false;
-	if (inBrowser) {
-	    try {
-	        const opts = {};
-	        Object.defineProperty(opts, 'passive', {
-	            get() {
-	                /* istanbul ignore next */
-	                supportsPassive = true;
-	            },
-	        }); // https://github.com/facebook/flow/issues/285
-	        window.addEventListener('test-passive', null, opts);
-	    }
-	    catch (e) { }
-	}
-	// this needs to be lazy-evaled because vue may be required before
-	// vue-server-renderer can set VUE_ENV
-	let _isServer;
-	const isServerRendering = () => {
-	    if (_isServer === undefined) {
-	        /* istanbul ignore if */
-	        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-	            // detect presence of vue-server-renderer and avoid
-	            // Webpack shimming the process
-	            _isServer =
-	                global['process'] && global['process'].env.VUE_ENV === 'server';
-	        }
-	        else {
-	            _isServer = false;
-	        }
-	    }
-	    return _isServer;
-	};
-	/* istanbul ignore next */
-	function isNative(Ctor) {
-	    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-	}
-	const hasSymbol = typeof Symbol !== 'undefined' &&
-	    isNative(Symbol) &&
-	    typeof Reflect !== 'undefined' &&
-	    isNative(Reflect.ownKeys);
-	/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
-
-	const ASSET_TYPES = ['component', 'directive', 'filter'];
-	const LIFECYCLE_HOOKS = [
-	    'beforeCreate',
-	    'created',
-	    'beforeMount',
-	    'mounted',
-	    'beforeUpdate',
-	    'updated',
-	    'beforeDestroy',
-	    'destroyed',
-	    'activated',
-	    'deactivated',
-	    'errorCaptured',
-	    'serverPrefetch',
-	];
-
-	var config = {
-	    /**
-	     * Option merge strategies (used in core/util/options)
-	     */
-	    // $flow-disable-line
-	    optionMergeStrategies: Object.create(null),
-	    /**
-	     * Whether to suppress warnings.
-	     */
-	    silent: false,
-	    /**
-	     * Show production mode tip message on boot?
-	     */
-	    productionTip: "development" !== 'production',
-	    /**
-	     * Whether to enable devtools
-	     */
-	    devtools: "development" !== 'production',
-	    /**
-	     * Whether to record perf
-	     */
-	    performance: false,
-	    /**
-	     * Error handler for watcher errors
-	     */
-	    errorHandler: null,
-	    /**
-	     * Warn handler for watcher warns
-	     */
-	    warnHandler: null,
-	    /**
-	     * Ignore certain custom elements
-	     */
-	    ignoredElements: [],
-	    /**
-	     * Custom user key aliases for v-on
-	     */
-	    // $flow-disable-line
-	    keyCodes: Object.create(null),
-	    /**
-	     * Check if a tag is reserved so that it cannot be registered as a
-	     * component. This is platform-dependent and may be overwritten.
-	     */
-	    isReservedTag: no,
-	    /**
-	     * Check if an attribute is reserved so that it cannot be used as a component
-	     * prop. This is platform-dependent and may be overwritten.
-	     */
-	    isReservedAttr: no,
-	    /**
-	     * Check if a tag is an unknown element.
-	     * Platform-dependent.
-	     */
-	    isUnknownElement: no,
-	    /**
-	     * Get the namespace of an element
-	     */
-	    getTagNamespace: noop,
-	    /**
-	     * Parse the real tag name for the specific platform.
-	     */
-	    parsePlatformTagName: identity,
-	    /**
-	     * Check if an attribute must be bound using property, e.g. value
-	     * Platform-dependent.
-	     */
-	    mustUseProp: no,
-	    /**
-	     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-	     * This will significantly reduce performance if set to false.
-	     */
-	    async: true,
-	    /**
-	     * Exposed for legacy reasons
-	     */
-	    _lifecycleHooks: LIFECYCLE_HOOKS,
-	};
-
-	let warn$2 = noop;
-	let tip = noop;
-	let generateComponentTrace; // work around flow check
-	let formatComponentName;
-	{
-	    const hasConsole = typeof console !== 'undefined';
-	    const classifyRE = /(?:^|[-_])(\w)/g;
-	    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-	    warn$2 = (msg, vm) => {
-	        const trace = vm ? generateComponentTrace(vm) : '';
-	        if (hasConsole && !config.silent) {
-	            console.error(`[Vue warn]: ${msg}${trace}`);
-	        }
-	    };
-	    tip = (msg, vm) => {
-	        if (hasConsole && !config.silent) {
-	            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-	        }
-	    };
-	    formatComponentName = (vm, includeFile) => {
-	        if (vm.$root === vm) {
-	            return '<Root>';
-	        }
-	        const options = typeof vm === 'function' && vm.cid != null
-	            ? vm.options
-	            : vm._isVue
-	                ? vm.$options || vm.constructor.options
-	                : vm;
-	        let name = options.name || options._componentTag;
-	        const file = options.__file;
-	        if (!name && file) {
-	            const match = file.match(/([^/\\]+)\.vue$/);
-	            name = match && match[1];
-	        }
-	        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-	            (file && includeFile !== false ? ` at ${file}` : ''));
-	    };
-	    const repeat = (str, n) => {
-	        let res = '';
-	        while (n) {
-	            if (n % 2 === 1)
-	                res += str;
-	            if (n > 1)
-	                str += str;
-	            n >>= 1;
-	        }
-	        return res;
-	    };
-	    generateComponentTrace = (vm) => {
-	        if (vm._isVue && vm.$parent) {
-	            const tree = [];
-	            let currentRecursiveSequence = 0;
-	            while (vm) {
-	                if (tree.length > 0) {
-	                    const last = tree[tree.length - 1];
-	                    if (last.constructor === vm.constructor) {
-	                        currentRecursiveSequence++;
-	                        vm = vm.$parent;
-	                        continue;
-	                    }
-	                    else if (currentRecursiveSequence > 0) {
-	                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-	                        currentRecursiveSequence = 0;
-	                    }
-	                }
-	                tree.push(vm);
-	                vm = vm.$parent;
-	            }
-	            return ('\n\nfound in\n\n' +
-	                tree
-	                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-	                    .join('\n'));
-	        }
-	        else {
-	            return `\n\n(found in ${formatComponentName(vm)})`;
-	        }
-	    };
-	}
-
-	let uid = 0;
-	/**
-	 * A dep is an observable that can have multiple
-	 * directives subscribing to it.
-	 */
-	class Dep {
-	    static target;
-	    id;
-	    subs;
-	    constructor() {
-	        this.id = uid++;
-	        this.subs = [];
-	    }
-	    addSub(sub) {
-	        this.subs.push(sub);
-	    }
-	    removeSub(sub) {
-	        remove(this.subs, sub);
-	    }
-	    depend() {
-	        if (Dep.target) {
-	            Dep.target.addDep(this);
-	        }
-	    }
-	    notify() {
-	        // stabilize the subscriber list first
-	        const subs = this.subs.slice();
-	        for (let i = 0, l = subs.length; i < l; i++) {
-	            subs[i].update();
-	        }
-	    }
-	}
-	// The current target watcher being evaluated.
-	// This is globally unique because only one watcher
-	// can be evaluated at a time.
-	Dep.target = null;
-
-	class VNode {
-	    tag;
-	    data;
-	    children;
-	    text;
-	    elm;
-	    ns;
-	    context; // rendered in this component's scope
-	    key;
-	    componentOptions;
-	    componentInstance; // component instance
-	    parent; // component placeholder node
-	    // strictly internal
-	    raw; // contains raw HTML? (server only)
-	    isStatic; // hoisted static node
-	    isRootInsert; // necessary for enter transition check
-	    isComment; // empty comment placeholder?
-	    isCloned; // is a cloned node?
-	    isOnce; // is a v-once node?
-	    asyncFactory; // async component factory function
-	    asyncMeta;
-	    isAsyncPlaceholder;
-	    ssrContext;
-	    fnContext; // real context vm for functional nodes
-	    fnOptions; // for SSR caching
-	    devtoolsMeta; // used to store functional render context for devtools
-	    fnScopeId; // functional scope id support
-	    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-	        this.tag = tag;
-	        this.data = data;
-	        this.children = children;
-	        this.text = text;
-	        this.elm = elm;
-	        this.ns = undefined;
-	        this.context = context;
-	        this.fnContext = undefined;
-	        this.fnOptions = undefined;
-	        this.fnScopeId = undefined;
-	        this.key = data && data.key;
-	        this.componentOptions = componentOptions;
-	        this.componentInstance = undefined;
-	        this.parent = undefined;
-	        this.raw = false;
-	        this.isStatic = false;
-	        this.isRootInsert = true;
-	        this.isComment = false;
-	        this.isCloned = false;
-	        this.isOnce = false;
-	        this.asyncFactory = asyncFactory;
-	        this.asyncMeta = undefined;
-	        this.isAsyncPlaceholder = false;
-	    }
-	    // DEPRECATED: alias for componentInstance for backwards compat.
-	    /* istanbul ignore next */
-	    get child() {
-	        return this.componentInstance;
-	    }
-	}
-
-	/*
-	 * not type checking this file because flow doesn't play well with
-	 * dynamically accessing methods on Array prototype
-	 */
-	const arrayProto = Array.prototype;
-	const arrayMethods = Object.create(arrayProto);
-	const methodsToPatch = [
-	    'push',
-	    'pop',
-	    'shift',
-	    'unshift',
-	    'splice',
-	    'sort',
-	    'reverse',
-	];
-	/**
-	 * Intercept mutating methods and emit events
-	 */
-	methodsToPatch.forEach(function (method) {
-	    // cache original method
-	    const original = arrayProto[method];
-	    def(arrayMethods, method, function mutator(...args) {
-	        const result = original.apply(this, args);
-	        const ob = this.__ob__;
-	        let inserted;
-	        switch (method) {
-	            case 'push':
-	            case 'unshift':
-	                inserted = args;
-	                break;
-	            case 'splice':
-	                inserted = args.slice(2);
-	                break;
-	        }
-	        if (inserted)
-	            ob.observeArray(inserted);
-	        // notify change
-	        ob.dep.notify();
-	        return result;
-	    });
-	});
-
-	const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-	/**
-	 * Observer class that is attached to each observed
-	 * object. Once attached, the observer converts the target
-	 * object's property keys into getter/setters that
-	 * collect dependencies and dispatch updates.
-	 */
-	class Observer {
-	    value;
-	    dep;
-	    vmCount; // number of vms that have this object as root $data
-	    constructor(value) {
-	        this.value = value;
-	        this.dep = new Dep();
-	        this.vmCount = 0;
-	        def(value, '__ob__', this);
-	        if (Array.isArray(value)) {
-	            if (hasProto) {
-	                protoAugment(value, arrayMethods);
-	            }
-	            else {
-	                copyAugment(value, arrayMethods, arrayKeys);
-	            }
-	            this.observeArray(value);
-	        }
-	        else {
-	            this.walk(value);
-	        }
-	    }
-	    /**
-	     * Walk through all properties and convert them into
-	     * getter/setters. This method should only be called when
-	     * value type is Object.
-	     */
-	    walk(obj) {
-	        const keys = Object.keys(obj);
-	        for (let i = 0; i < keys.length; i++) {
-	            defineReactive(obj, keys[i]);
-	        }
-	    }
-	    /**
-	     * Observe a list of Array items.
-	     */
-	    observeArray(items) {
-	        for (let i = 0, l = items.length; i < l; i++) {
-	            observe(items[i]);
-	        }
-	    }
-	}
-	// helpers
-	/**
-	 * Augment a target Object or Array by intercepting
-	 * the prototype chain using __proto__
-	 */
-	function protoAugment(target, src) {
-	    /* eslint-disable no-proto */
-	    target.__proto__ = src;
-	    /* eslint-enable no-proto */
-	}
-	/**
-	 * Augment a target Object or Array by defining
-	 * hidden properties.
-	 */
-	/* istanbul ignore next */
-	function copyAugment(target, src, keys) {
-	    for (let i = 0, l = keys.length; i < l; i++) {
-	        const key = keys[i];
-	        def(target, key, src[key]);
-	    }
-	}
-	/**
-	 * Attempt to create an observer instance for a value,
-	 * returns the new observer if successfully observed,
-	 * or the existing observer if the value already has one.
-	 */
-	function observe(value, asRootData) {
-	    if (!isObject(value) || value instanceof VNode) {
-	        return;
-	    }
-	    let ob;
-	    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-	        ob = value.__ob__;
-	    }
-	    else if (!isServerRendering() &&
-	        (Array.isArray(value) || isPlainObject(value)) &&
-	        Object.isExtensible(value) &&
-	        !value._isVue) {
-	        ob = new Observer(value);
-	    }
-	    if (asRootData && ob) {
-	        ob.vmCount++;
-	    }
-	    return ob;
-	}
-	/**
-	 * Define a reactive property on an Object.
-	 */
-	function defineReactive(obj, key, val, customSetter, shallow) {
-	    const dep = new Dep();
-	    const property = Object.getOwnPropertyDescriptor(obj, key);
-	    if (property && property.configurable === false) {
-	        return;
-	    }
-	    // cater for pre-defined getter/setters
-	    const getter = property && property.get;
-	    const setter = property && property.set;
-	    if ((!getter || setter) && arguments.length === 2) {
-	        val = obj[key];
-	    }
-	    let childOb = !shallow && observe(val);
-	    Object.defineProperty(obj, key, {
-	        enumerable: true,
-	        configurable: true,
-	        get: function reactiveGetter() {
-	            const value = getter ? getter.call(obj) : val;
-	            if (Dep.target) {
-	                dep.depend();
-	                if (childOb) {
-	                    childOb.dep.depend();
-	                    if (Array.isArray(value)) {
-	                        dependArray(value);
-	                    }
-	                }
-	            }
-	            return value;
-	        },
-	        set: function reactiveSetter(newVal) {
-	            const value = getter ? getter.call(obj) : val;
-	            /* eslint-disable no-self-compare */
-	            if (newVal === value || (newVal !== newVal && value !== value)) {
-	                return;
-	            }
-	            /* eslint-enable no-self-compare */
-	            if (customSetter) {
-	                customSetter();
-	            }
-	            // #7981: for accessor properties without setter
-	            if (getter && !setter)
-	                return;
-	            if (setter) {
-	                setter.call(obj, newVal);
-	            }
-	            else {
-	                val = newVal;
-	            }
-	            childOb = !shallow && observe(newVal);
-	            dep.notify();
-	        },
-	    });
-	}
-	/**
-	 * Set a property on an object. Adds the new property and
-	 * triggers change notification if the property doesn't
-	 * already exist.
-	 */
-	function set(target, key, val) {
-	    if ((isUndef(target) || isPrimitive(target))) {
-	        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-	    }
-	    if (Array.isArray(target) && isValidArrayIndex(key)) {
-	        target.length = Math.max(target.length, key);
-	        target.splice(key, 1, val);
-	        return val;
-	    }
-	    if (key in target && !(key in Object.prototype)) {
-	        target[key] = val;
-	        return val;
-	    }
-	    const ob = target.__ob__;
-	    if (target._isVue || (ob && ob.vmCount)) {
-	        warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-	                'at runtime - declare it upfront in the data option.');
-	        return val;
-	    }
-	    if (!ob) {
-	        target[key] = val;
-	        return val;
-	    }
-	    defineReactive(ob.value, key, val);
-	    ob.dep.notify();
-	    return val;
-	}
-	/**
-	 * Collect dependencies on array elements when the array is touched, since
-	 * we cannot intercept array element access like property getters.
-	 */
-	function dependArray(value) {
-	    for (let e, i = 0, l = value.length; i < l; i++) {
-	        e = value[i];
-	        e && e.__ob__ && e.__ob__.dep.depend();
-	        if (Array.isArray(e)) {
-	            dependArray(e);
-	        }
-	    }
-	}
-
-	/**
-	 * Option overwriting strategies are functions that handle
-	 * how to merge a parent option value and a child option
-	 * value into the final value.
-	 */
-	const strats = config.optionMergeStrategies;
-	/**
-	 * Options with restrictions
-	 */
-	{
-	    strats.el = strats.propsData = function (parent, child, vm, key) {
-	        if (!vm) {
-	            warn$2(`option "${key}" can only be used during instance ` +
-	                'creation with the `new` keyword.');
-	        }
-	        return defaultStrat(parent, child);
-	    };
-	}
-	/**
-	 * Helper that recursively merges two data objects together.
-	 */
-	function mergeData(to, from) {
-	    if (!from)
-	        return to;
-	    let key, toVal, fromVal;
-	    const keys = hasSymbol
-	        ? Reflect.ownKeys(from)
-	        : Object.keys(from);
-	    for (let i = 0; i < keys.length; i++) {
-	        key = keys[i];
-	        // in case the object is already observed...
-	        if (key === '__ob__')
-	            continue;
-	        toVal = to[key];
-	        fromVal = from[key];
-	        if (!hasOwn(to, key)) {
-	            set(to, key, fromVal);
-	        }
-	        else if (toVal !== fromVal &&
-	            isPlainObject(toVal) &&
-	            isPlainObject(fromVal)) {
-	            mergeData(toVal, fromVal);
-	        }
-	    }
-	    return to;
-	}
-	/**
-	 * Data
-	 */
-	function mergeDataOrFn(parentVal, childVal, vm) {
-	    if (!vm) {
-	        // in a Vue.extend merge, both should be functions
-	        if (!childVal) {
-	            return parentVal;
-	        }
-	        if (!parentVal) {
-	            return childVal;
-	        }
-	        // when parentVal & childVal are both present,
-	        // we need to return a function that returns the
-	        // merged result of both functions... no need to
-	        // check if parentVal is a function here because
-	        // it has to be a function to pass previous merges.
-	        return function mergedDataFn() {
-	            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-	        };
-	    }
-	    else {
-	        return function mergedInstanceDataFn() {
-	            // instance merge
-	            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-	            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-	            if (instanceData) {
-	                return mergeData(instanceData, defaultData);
-	            }
-	            else {
-	                return defaultData;
-	            }
-	        };
-	    }
-	}
-	strats.data = function (parentVal, childVal, vm) {
-	    if (!vm) {
-	        if (childVal && typeof childVal !== 'function') {
-	            warn$2('The "data" option should be a function ' +
-	                    'that returns a per-instance value in component ' +
-	                    'definitions.', vm);
-	            return parentVal;
-	        }
-	        return mergeDataOrFn(parentVal, childVal);
-	    }
-	    return mergeDataOrFn(parentVal, childVal, vm);
-	};
-	/**
-	 * Hooks and props are merged as arrays.
-	 */
-	function mergeHook(parentVal, childVal) {
-	    const res = childVal
-	        ? parentVal
-	            ? parentVal.concat(childVal)
-	            : Array.isArray(childVal)
-	                ? childVal
-	                : [childVal]
-	        : parentVal;
-	    return res ? dedupeHooks(res) : res;
-	}
-	function dedupeHooks(hooks) {
-	    const res = [];
-	    for (let i = 0; i < hooks.length; i++) {
-	        if (res.indexOf(hooks[i]) === -1) {
-	            res.push(hooks[i]);
-	        }
-	    }
-	    return res;
-	}
-	LIFECYCLE_HOOKS.forEach((hook) => {
-	    strats[hook] = mergeHook;
-	});
-	/**
-	 * Assets
-	 *
-	 * When a vm is present (instance creation), we need to do
-	 * a three-way merge between constructor options, instance
-	 * options and parent options.
-	 */
-	function mergeAssets(parentVal, childVal, vm, key) {
-	    const res = Object.create(parentVal || null);
-	    if (childVal) {
-	        assertObjectType(key, childVal, vm);
-	        return extend(res, childVal);
-	    }
-	    else {
-	        return res;
-	    }
-	}
-	ASSET_TYPES.forEach(function (type) {
-	    strats[type + 's'] = mergeAssets;
-	});
-	/**
-	 * Watchers.
-	 *
-	 * Watchers hashes should not overwrite one
-	 * another, so we merge them as arrays.
-	 */
-	strats.watch = function (parentVal, childVal, vm, key) {
-	    // work around Firefox's Object.prototype.watch...
-	    //@ts-expect-error work around
-	    if (parentVal === nativeWatch)
-	        parentVal = undefined;
-	    //@ts-expect-error work around
-	    if (childVal === nativeWatch)
-	        childVal = undefined;
-	    /* istanbul ignore if */
-	    if (!childVal)
-	        return Object.create(parentVal || null);
-	    {
-	        assertObjectType(key, childVal, vm);
-	    }
-	    if (!parentVal)
-	        return childVal;
-	    const ret = {};
-	    extend(ret, parentVal);
-	    for (const key in childVal) {
-	        let parent = ret[key];
-	        const child = childVal[key];
-	        if (parent && !Array.isArray(parent)) {
-	            parent = [parent];
-	        }
-	        ret[key] = parent
-	            ? parent.concat(child)
-	            : Array.isArray(child)
-	                ? child
-	                : [child];
-	    }
-	    return ret;
-	};
-	/**
-	 * Other object hashes.
-	 */
-	strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-	    if (childVal && "development" !== 'production') {
-	        assertObjectType(key, childVal, vm);
-	    }
-	    if (!parentVal)
-	        return childVal;
-	    const ret = Object.create(null);
-	    extend(ret, parentVal);
-	    if (childVal)
-	        extend(ret, childVal);
-	    return ret;
-	};
-	strats.provide = mergeDataOrFn;
-	/**
-	 * Default strategy.
-	 */
-	const defaultStrat = function (parentVal, childVal) {
-	    return childVal === undefined ? parentVal : childVal;
-	};
-	function assertObjectType(name, value, vm) {
-	    if (!isPlainObject(value)) {
-	        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-	            `but got ${toRawType(value)}.`, vm);
-	    }
-	}
-
-	/* globals MutationObserver */
-	const callbacks = [];
-	function flushCallbacks() {
-	    const copies = callbacks.slice(0);
-	    callbacks.length = 0;
-	    for (let i = 0; i < copies.length; i++) {
-	        copies[i]();
-	    }
-	}
-	// The nextTick behavior leverages the microtask queue, which can be accessed
-	// via either native Promise.then or MutationObserver.
-	// MutationObserver has wider support, however it is seriously bugged in
-	// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-	// completely stops working after triggering a few times... so, if native
-	// Promise is available, we will use it:
-	/* istanbul ignore next, $flow-disable-line */
-	if (typeof Promise !== 'undefined' && isNative(Promise)) {
-	    Promise.resolve();
-	}
-	else if (!isIE &&
-	    typeof MutationObserver !== 'undefined' &&
-	    (isNative(MutationObserver) ||
-	        // PhantomJS and iOS 7.x
-	        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-	    // Use MutationObserver where native Promise is not available,
-	    // e.g. PhantomJS, iOS7, Android 4.4
-	    // (#6466 MutationObserver is unreliable in IE11)
-	    let counter = 1;
-	    const observer = new MutationObserver(flushCallbacks);
-	    const textNode = document.createTextNode(String(counter));
-	    observer.observe(textNode, {
-	        characterData: true,
-	    });
-	}
-	else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-	else ;
-
-	// these are reserved for web because they are directly compiled away
-	// during template compilation
-	makeMap('style,class');
-	// attributes that should be using props for binding
-	const acceptValue = makeMap('input,textarea,option,select,progress');
-	const mustUseProp = (tag, type, attr) => {
-	    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-	        (attr === 'selected' && tag === 'option') ||
-	        (attr === 'checked' && tag === 'input') ||
-	        (attr === 'muted' && tag === 'video'));
-	};
-	const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-	makeMap('events,caret,typing,plaintext-only');
-	const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-	    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-	    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-	    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-	    'required,reversed,scoped,seamless,selected,sortable,' +
-	    'truespeed,typemustmatch,visible');
-
-	const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-	    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-	    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-	    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-	    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-	    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-	    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-	    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-	    'output,progress,select,textarea,' +
-	    'details,dialog,menu,menuitem,summary,' +
-	    'content,element,shadow,template,blockquote,iframe,tfoot');
-	// this map is intentionally selective, only covering SVG elements that may
-	// contain child elements.
-	const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-	    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-	    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-	const isPreTag = (tag) => tag === 'pre';
-	const isReservedTag = (tag) => {
-	    return isHTMLTag(tag) || isSVG(tag);
-	};
-	function getTagNamespace(tag) {
-	    if (isSVG(tag)) {
-	        return 'svg';
-	    }
-	    // basic support for MathML
-	    // note it doesn't support other MathML elements being component roots
-	    if (tag === 'math') {
-	        return 'math';
-	    }
-	}
-	makeMap('text,number,password,search,email,tel,url');
-
-	const validDivisionCharRE = /[\w).+\-_$\]]/;
-	function parseFilters(exp) {
-	    let inSingle = false;
-	    let inDouble = false;
-	    let inTemplateString = false;
-	    let inRegex = false;
-	    let curly = 0;
-	    let square = 0;
-	    let paren = 0;
-	    let lastFilterIndex = 0;
-	    let c, prev, i, expression, filters;
-	    for (i = 0; i < exp.length; i++) {
-	        prev = c;
-	        c = exp.charCodeAt(i);
-	        if (inSingle) {
-	            if (c === 0x27 && prev !== 0x5c)
-	                inSingle = false;
-	        }
-	        else if (inDouble) {
-	            if (c === 0x22 && prev !== 0x5c)
-	                inDouble = false;
-	        }
-	        else if (inTemplateString) {
-	            if (c === 0x60 && prev !== 0x5c)
-	                inTemplateString = false;
-	        }
-	        else if (inRegex) {
-	            if (c === 0x2f && prev !== 0x5c)
-	                inRegex = false;
-	        }
-	        else if (c === 0x7c && // pipe
-	            exp.charCodeAt(i + 1) !== 0x7c &&
-	            exp.charCodeAt(i - 1) !== 0x7c &&
-	            !curly &&
-	            !square &&
-	            !paren) {
-	            if (expression === undefined) {
-	                // first filter, end of expression
-	                lastFilterIndex = i + 1;
-	                expression = exp.slice(0, i).trim();
-	            }
-	            else {
-	                pushFilter();
-	            }
-	        }
-	        else {
-	            switch (c) {
-	                case 0x22:
-	                    inDouble = true;
-	                    break; // "
-	                case 0x27:
-	                    inSingle = true;
-	                    break; // '
-	                case 0x60:
-	                    inTemplateString = true;
-	                    break; // `
-	                case 0x28:
-	                    paren++;
-	                    break; // (
-	                case 0x29:
-	                    paren--;
-	                    break; // )
-	                case 0x5b:
-	                    square++;
-	                    break; // [
-	                case 0x5d:
-	                    square--;
-	                    break; // ]
-	                case 0x7b:
-	                    curly++;
-	                    break; // {
-	                case 0x7d:
-	                    curly--;
-	                    break; // }
-	            }
-	            if (c === 0x2f) {
-	                // /
-	                let j = i - 1;
-	                let p;
-	                // find first non-whitespace prev char
-	                for (; j >= 0; j--) {
-	                    p = exp.charAt(j);
-	                    if (p !== ' ')
-	                        break;
-	                }
-	                if (!p || !validDivisionCharRE.test(p)) {
-	                    inRegex = true;
-	                }
-	            }
-	        }
-	    }
-	    if (expression === undefined) {
-	        expression = exp.slice(0, i).trim();
-	    }
-	    else if (lastFilterIndex !== 0) {
-	        pushFilter();
-	    }
-	    function pushFilter() {
-	        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-	        lastFilterIndex = i + 1;
-	    }
-	    if (filters) {
-	        for (i = 0; i < filters.length; i++) {
-	            expression = wrapFilter(expression, filters[i]);
-	        }
-	    }
-	    return expression;
-	}
-	function wrapFilter(exp, filter) {
-	    const i = filter.indexOf('(');
-	    if (i < 0) {
-	        // _f: resolveFilter
-	        return `_f("${filter}")(${exp})`;
-	    }
-	    else {
-	        const name = filter.slice(0, i);
-	        const args = filter.slice(i + 1);
-	        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-	    }
-	}
-
-	const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-	const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-	const buildRegex = cached((delimiters) => {
-	    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-	    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-	    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-	});
-	function parseText(text, delimiters) {
-	    //@ts-expect-error
-	    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-	    if (!tagRE.test(text)) {
-	        return;
-	    }
-	    const tokens = [];
-	    const rawTokens = [];
-	    let lastIndex = (tagRE.lastIndex = 0);
-	    let match, index, tokenValue;
-	    while ((match = tagRE.exec(text))) {
-	        index = match.index;
-	        // push text token
-	        if (index > lastIndex) {
-	            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-	            tokens.push(JSON.stringify(tokenValue));
-	        }
-	        // tag token
-	        const exp = parseFilters(match[1].trim());
-	        tokens.push(`_s(${exp})`);
-	        rawTokens.push({ '@binding': exp });
-	        lastIndex = index + match[0].length;
-	    }
-	    if (lastIndex < text.length) {
-	        rawTokens.push((tokenValue = text.slice(lastIndex)));
-	        tokens.push(JSON.stringify(tokenValue));
-	    }
-	    return {
-	        expression: tokens.join('+'),
-	        tokens: rawTokens,
-	    };
-	}
-
-	/* eslint-disable no-unused-vars */
-	function baseWarn(msg, range) {
-	    console.error(`[Vue compiler]: ${msg}`);
-	}
-	/* eslint-enable no-unused-vars */
-	function pluckModuleFunction(modules, key) {
-	    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-	}
-	function addProp(el, name, value, range, dynamic) {
-	    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-	    el.plain = false;
-	}
-	function addAttr(el, name, value, range, dynamic) {
-	    const attrs = dynamic
-	        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-	        : el.attrs || (el.attrs = []);
-	    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-	    el.plain = false;
-	}
-	// add a raw attr (use this in preTransforms)
-	function addRawAttr(el, name, value, range) {
-	    el.attrsMap[name] = value;
-	    el.attrsList.push(rangeSetItem({ name, value }, range));
-	}
-	function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-	    (el.directives || (el.directives = [])).push(rangeSetItem({
-	        name,
-	        rawName,
-	        value,
-	        arg,
-	        isDynamicArg,
-	        modifiers,
-	    }, range));
-	    el.plain = false;
-	}
-	function prependModifierMarker(symbol, name, dynamic) {
-	    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-	}
-	function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-	    modifiers = modifiers || emptyObject;
-	    // warn prevent and passive modifier
-	    /* istanbul ignore if */
-	    if (warn &&
-	        modifiers.prevent &&
-	        modifiers.passive) {
-	        warn("passive and prevent can't be used together. " +
-	            "Passive handler can't prevent default event.", range);
-	    }
-	    // normalize click.right and click.middle since they don't actually fire
-	    // this is technically browser-specific, but at least for now browsers are
-	    // the only target envs that have right/middle clicks.
-	    if (modifiers.right) {
-	        if (dynamic) {
-	            name = `(${name})==='click'?'contextmenu':(${name})`;
-	        }
-	        else if (name === 'click') {
-	            name = 'contextmenu';
-	            delete modifiers.right;
-	        }
-	    }
-	    else if (modifiers.middle) {
-	        if (dynamic) {
-	            name = `(${name})==='click'?'mouseup':(${name})`;
-	        }
-	        else if (name === 'click') {
-	            name = 'mouseup';
-	        }
-	    }
-	    // check capture modifier
-	    if (modifiers.capture) {
-	        delete modifiers.capture;
-	        name = prependModifierMarker('!', name, dynamic);
-	    }
-	    if (modifiers.once) {
-	        delete modifiers.once;
-	        name = prependModifierMarker('~', name, dynamic);
-	    }
-	    /* istanbul ignore if */
-	    if (modifiers.passive) {
-	        delete modifiers.passive;
-	        name = prependModifierMarker('&', name, dynamic);
-	    }
-	    let events;
-	    if (modifiers.native) {
-	        delete modifiers.native;
-	        events = el.nativeEvents || (el.nativeEvents = {});
-	    }
-	    else {
-	        events = el.events || (el.events = {});
-	    }
-	    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-	    if (modifiers !== emptyObject) {
-	        newHandler.modifiers = modifiers;
-	    }
-	    const handlers = events[name];
-	    /* istanbul ignore if */
-	    if (Array.isArray(handlers)) {
-	        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-	    }
-	    else if (handlers) {
-	        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-	    }
-	    else {
-	        events[name] = newHandler;
-	    }
-	    el.plain = false;
-	}
-	function getRawBindingAttr(el, name) {
-	    return (el.rawAttrsMap[':' + name] ||
-	        el.rawAttrsMap['v-bind:' + name] ||
-	        el.rawAttrsMap[name]);
-	}
-	function getBindingAttr(el, name, getStatic) {
-	    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-	    if (dynamicValue != null) {
-	        return parseFilters(dynamicValue);
-	    }
-	    else if (getStatic !== false) {
-	        const staticValue = getAndRemoveAttr(el, name);
-	        if (staticValue != null) {
-	            return JSON.stringify(staticValue);
-	        }
-	    }
-	}
-	// note: this only removes the attr from the Array (attrsList) so that it
-	// doesn't get processed by processAttrs.
-	// By default it does NOT remove it from the map (attrsMap) because the map is
-	// needed during codegen.
-	function getAndRemoveAttr(el, name, removeFromMap) {
-	    let val;
-	    if ((val = el.attrsMap[name]) != null) {
-	        const list = el.attrsList;
-	        for (let i = 0, l = list.length; i < l; i++) {
-	            if (list[i].name === name) {
-	                list.splice(i, 1);
-	                break;
-	            }
-	        }
-	    }
-	    if (removeFromMap) {
-	        delete el.attrsMap[name];
-	    }
-	    return val;
-	}
-	function getAndRemoveAttrByRegex(el, name) {
-	    const list = el.attrsList;
-	    for (let i = 0, l = list.length; i < l; i++) {
-	        const attr = list[i];
-	        if (name.test(attr.name)) {
-	            list.splice(i, 1);
-	            return attr;
-	        }
-	    }
-	}
-	function rangeSetItem(item, range) {
-	    if (range) {
-	        if (range.start != null) {
-	            item.start = range.start;
-	        }
-	        if (range.end != null) {
-	            item.end = range.end;
-	        }
-	    }
-	    return item;
-	}
-
-	function transformNode$1(el, options) {
-	    const warn = options.warn || baseWarn;
-	    const staticClass = getAndRemoveAttr(el, 'class');
-	    if (staticClass) {
-	        const res = parseText(staticClass, options.delimiters);
-	        if (res) {
-	            warn(`class="${staticClass}": ` +
-	                'Interpolation inside attributes has been removed. ' +
-	                'Use v-bind or the colon shorthand instead. For example, ' +
-	                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-	        }
-	    }
-	    if (staticClass) {
-	        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-	    }
-	    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-	    if (classBinding) {
-	        el.classBinding = classBinding;
-	    }
-	}
-	function genData$2(el) {
-	    let data = '';
-	    if (el.staticClass) {
-	        data += `staticClass:${el.staticClass},`;
-	    }
-	    if (el.classBinding) {
-	        data += `class:${el.classBinding},`;
-	    }
-	    return data;
-	}
-	var klass = {
-	    staticKeys: ['staticClass'],
-	    transformNode: transformNode$1,
-	    genData: genData$2,
-	};
-
-	const parseStyleText = cached(function (cssText) {
-	    const res = {};
-	    const listDelimiter = /;(?![^(]*\))/g;
-	    const propertyDelimiter = /:(.+)/;
-	    cssText.split(listDelimiter).forEach(function (item) {
-	        if (item) {
-	            const tmp = item.split(propertyDelimiter);
-	            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-	        }
-	    });
-	    return res;
-	});
-
-	function transformNode(el, options) {
-	    const warn = options.warn || baseWarn;
-	    const staticStyle = getAndRemoveAttr(el, 'style');
-	    if (staticStyle) {
-	        /* istanbul ignore if */
-	        {
-	            const res = parseText(staticStyle, options.delimiters);
-	            if (res) {
-	                warn(`style="${staticStyle}": ` +
-	                    'Interpolation inside attributes has been removed. ' +
-	                    'Use v-bind or the colon shorthand instead. For example, ' +
-	                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-	            }
-	        }
-	        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-	    }
-	    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-	    if (styleBinding) {
-	        el.styleBinding = styleBinding;
-	    }
-	}
-	function genData$1(el) {
-	    let data = '';
-	    if (el.staticStyle) {
-	        data += `staticStyle:${el.staticStyle},`;
-	    }
-	    if (el.styleBinding) {
-	        data += `style:(${el.styleBinding}),`;
-	    }
-	    return data;
-	}
-	var style = {
-	    staticKeys: ['staticStyle'],
-	    transformNode,
-	    genData: genData$1,
-	};
-
-	var he$1 = {exports: {}};
-
-	/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-
-	(function (module, exports) {
-	(function(root) {
-
-			// Detect free variables `exports`.
-			var freeExports = exports;
-
-			// Detect free variable `module`.
-			var freeModule = module &&
-				module.exports == freeExports && module;
-
-			// Detect free variable `global`, from Node.js or Browserified code,
-			// and use it as `root`.
-			var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
-			if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
-				root = freeGlobal;
-			}
-
-			/*--------------------------------------------------------------------------*/
-
-			// All astral symbols.
-			var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
-			// All ASCII symbols (not just printable ASCII) except those listed in the
-			// first column of the overrides table.
-			// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-			var regexAsciiWhitelist = /[\x01-\x7F]/g;
-			// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-			// code points listed in the first column of the overrides table on
-			// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-			var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
-
-			var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
-			var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
-
-			var regexEscape = /["&'<>`]/g;
-			var escapeMap = {
-				'"': '&quot;',
-				'&': '&amp;',
-				'\'': '&#x27;',
-				'<': '&lt;',
-				// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-				// following is not strictly necessary unless it’s part of a tag or an
-				// unquoted attribute value. We’re only escaping it to support those
-				// situations, and for XML support.
-				'>': '&gt;',
-				// In Internet Explorer ≤ 8, the backtick character can be used
-				// to break out of (un)quoted attribute values or HTML comments.
-				// See http://html5sec.org/#102, http://html5sec.org/#108, and
-				// http://html5sec.org/#133.
-				'`': '&#x60;'
-			};
-
-			var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
-			var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-			var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
-			var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
-			var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
-			var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
-			var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
-
-			/*--------------------------------------------------------------------------*/
-
-			var stringFromCharCode = String.fromCharCode;
-
-			var object = {};
-			var hasOwnProperty = object.hasOwnProperty;
-			var has = function(object, propertyName) {
-				return hasOwnProperty.call(object, propertyName);
-			};
-
-			var contains = function(array, value) {
-				var index = -1;
-				var length = array.length;
-				while (++index < length) {
-					if (array[index] == value) {
-						return true;
-					}
-				}
-				return false;
-			};
-
-			var merge = function(options, defaults) {
-				if (!options) {
-					return defaults;
-				}
-				var result = {};
-				var key;
-				for (key in defaults) {
-					// A `hasOwnProperty` check is not needed here, since only recognized
-					// option names are used anyway. Any others are ignored.
-					result[key] = has(options, key) ? options[key] : defaults[key];
-				}
-				return result;
-			};
-
-			// Modified version of `ucs2encode`; see https://mths.be/punycode.
-			var codePointToSymbol = function(codePoint, strict) {
-				var output = '';
-				if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
-					// See issue #4:
-					// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-					// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-					// REPLACEMENT CHARACTER.”
-					if (strict) {
-						parseError('character reference outside the permissible Unicode range');
-					}
-					return '\uFFFD';
-				}
-				if (has(decodeMapNumeric, codePoint)) {
-					if (strict) {
-						parseError('disallowed character reference');
-					}
-					return decodeMapNumeric[codePoint];
-				}
-				if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-					parseError('disallowed character reference');
-				}
-				if (codePoint > 0xFFFF) {
-					codePoint -= 0x10000;
-					output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
-					codePoint = 0xDC00 | codePoint & 0x3FF;
-				}
-				output += stringFromCharCode(codePoint);
-				return output;
-			};
-
-			var hexEscape = function(codePoint) {
-				return '&#x' + codePoint.toString(16).toUpperCase() + ';';
-			};
-
-			var decEscape = function(codePoint) {
-				return '&#' + codePoint + ';';
-			};
-
-			var parseError = function(message) {
-				throw Error('Parse error: ' + message);
-			};
-
-			/*--------------------------------------------------------------------------*/
-
-			var encode = function(string, options) {
-				options = merge(options, encode.options);
-				var strict = options.strict;
-				if (strict && regexInvalidRawCodePoint.test(string)) {
-					parseError('forbidden code point');
-				}
-				var encodeEverything = options.encodeEverything;
-				var useNamedReferences = options.useNamedReferences;
-				var allowUnsafeSymbols = options.allowUnsafeSymbols;
-				var escapeCodePoint = options.decimal ? decEscape : hexEscape;
-
-				var escapeBmpSymbol = function(symbol) {
-					return escapeCodePoint(symbol.charCodeAt(0));
-				};
-
-				if (encodeEverything) {
-					// Encode ASCII symbols.
-					string = string.replace(regexAsciiWhitelist, function(symbol) {
-						// Use named references if requested & possible.
-						if (useNamedReferences && has(encodeMap, symbol)) {
-							return '&' + encodeMap[symbol] + ';';
-						}
-						return escapeBmpSymbol(symbol);
-					});
-					// Shorten a few escapes that represent two symbols, of which at least one
-					// is within the ASCII range.
-					if (useNamedReferences) {
-						string = string
-							.replace(/&gt;\u20D2/g, '&nvgt;')
-							.replace(/&lt;\u20D2/g, '&nvlt;')
-							.replace(/&#x66;&#x6A;/g, '&fjlig;');
-					}
-					// Encode non-ASCII symbols.
-					if (useNamedReferences) {
-						// Encode non-ASCII symbols that can be replaced with a named reference.
-						string = string.replace(regexEncodeNonAscii, function(string) {
-							// Note: there is no need to check `has(encodeMap, string)` here.
-							return '&' + encodeMap[string] + ';';
-						});
-					}
-					// Note: any remaining non-ASCII symbols are handled outside of the `if`.
-				} else if (useNamedReferences) {
-					// Apply named character references.
-					// Encode `<>"'&` using named character references.
-					if (!allowUnsafeSymbols) {
-						string = string.replace(regexEscape, function(string) {
-							return '&' + encodeMap[string] + ';'; // no need to check `has()` here
-						});
-					}
-					// Shorten escapes that represent two symbols, of which at least one is
-					// `<>"'&`.
-					string = string
-						.replace(/&gt;\u20D2/g, '&nvgt;')
-						.replace(/&lt;\u20D2/g, '&nvlt;');
-					// Encode non-ASCII symbols that can be replaced with a named reference.
-					string = string.replace(regexEncodeNonAscii, function(string) {
-						// Note: there is no need to check `has(encodeMap, string)` here.
-						return '&' + encodeMap[string] + ';';
-					});
-				} else if (!allowUnsafeSymbols) {
-					// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-					// using named character references.
-					string = string.replace(regexEscape, escapeBmpSymbol);
-				}
-				return string
-					// Encode astral symbols.
-					.replace(regexAstralSymbols, function($0) {
-						// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-						var high = $0.charCodeAt(0);
-						var low = $0.charCodeAt(1);
-						var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
-						return escapeCodePoint(codePoint);
-					})
-					// Encode any remaining BMP symbols that are not printable ASCII symbols
-					// using a hexadecimal escape.
-					.replace(regexBmpWhitelist, escapeBmpSymbol);
-			};
-			// Expose default options (so they can be overridden globally).
-			encode.options = {
-				'allowUnsafeSymbols': false,
-				'encodeEverything': false,
-				'strict': false,
-				'useNamedReferences': false,
-				'decimal' : false
-			};
-
-			var decode = function(html, options) {
-				options = merge(options, decode.options);
-				var strict = options.strict;
-				if (strict && regexInvalidEntity.test(html)) {
-					parseError('malformed character reference');
-				}
-				return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-					var codePoint;
-					var semicolon;
-					var decDigits;
-					var hexDigits;
-					var reference;
-					var next;
-
-					if ($1) {
-						reference = $1;
-						// Note: there is no need to check `has(decodeMap, reference)`.
-						return decodeMap[reference];
-					}
-
-					if ($2) {
-						// Decode named character references without trailing `;`, e.g. `&amp`.
-						// This is only a parse error if it gets converted to `&`, or if it is
-						// followed by `=` in an attribute context.
-						reference = $2;
-						next = $3;
-						if (next && options.isAttributeValue) {
-							if (strict && next == '=') {
-								parseError('`&` did not start a character reference');
-							}
-							return $0;
-						} else {
-							if (strict) {
-								parseError(
-									'named character reference was not terminated by a semicolon'
-								);
-							}
-							// Note: there is no need to check `has(decodeMapLegacy, reference)`.
-							return decodeMapLegacy[reference] + (next || '');
-						}
-					}
-
-					if ($4) {
-						// Decode decimal escapes, e.g. `&#119558;`.
-						decDigits = $4;
-						semicolon = $5;
-						if (strict && !semicolon) {
-							parseError('character reference was not terminated by a semicolon');
-						}
-						codePoint = parseInt(decDigits, 10);
-						return codePointToSymbol(codePoint, strict);
-					}
-
-					if ($6) {
-						// Decode hexadecimal escapes, e.g. `&#x1D306;`.
-						hexDigits = $6;
-						semicolon = $7;
-						if (strict && !semicolon) {
-							parseError('character reference was not terminated by a semicolon');
-						}
-						codePoint = parseInt(hexDigits, 16);
-						return codePointToSymbol(codePoint, strict);
-					}
-
-					// If we’re still here, `if ($7)` is implied; it’s an ambiguous
-					// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-					if (strict) {
-						parseError(
-							'named character reference was not terminated by a semicolon'
-						);
-					}
-					return $0;
-				});
-			};
-			// Expose default options (so they can be overridden globally).
-			decode.options = {
-				'isAttributeValue': false,
-				'strict': false
-			};
-
-			var escape = function(string) {
-				return string.replace(regexEscape, function($0) {
-					// Note: there is no need to check `has(escapeMap, $0)` here.
-					return escapeMap[$0];
-				});
-			};
-
-			/*--------------------------------------------------------------------------*/
-
-			var he = {
-				'version': '1.2.0',
-				'encode': encode,
-				'decode': decode,
-				'escape': escape,
-				'unescape': decode
-			};
-
-			// Some AMD build optimizers, like r.js, check for specific condition patterns
-			// like the following:
-			if (freeExports && !freeExports.nodeType) {
-				if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
-					freeModule.exports = he;
-				} else { // in Narwhal or RingoJS v0.7.0-
-					for (var key in he) {
-						has(he, key) && (freeExports[key] = he[key]);
-					}
-				}
-			} else { // in Rhino or a web browser
-				root.he = he;
-			}
-
-		}(commonjsGlobal));
-	} (he$1, he$1.exports));
-
-	var he = he$1.exports;
-
-	/**
-	 * Cross-platform code generation for component v-model
-	 */
-	function genComponentModel(el, value, modifiers) {
-	    const { number, trim } = modifiers || {};
-	    const baseValueExpression = '$$v';
-	    let valueExpression = baseValueExpression;
-	    if (trim) {
-	        valueExpression =
-	            `(typeof ${baseValueExpression} === 'string'` +
-	                `? ${baseValueExpression}.trim()` +
-	                `: ${baseValueExpression})`;
-	    }
-	    if (number) {
-	        valueExpression = `_n(${valueExpression})`;
-	    }
-	    const assignment = genAssignmentCode(value, valueExpression);
-	    el.model = {
-	        value: `(${value})`,
-	        expression: JSON.stringify(value),
-	        callback: `function (${baseValueExpression}) {${assignment}}`,
-	    };
-	}
-	/**
-	 * Cross-platform codegen helper for generating v-model value assignment code.
-	 */
-	function genAssignmentCode(value, assignment) {
-	    const res = parseModel(value);
-	    if (res.key === null) {
-	        return `${value}=${assignment}`;
-	    }
-	    else {
-	        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-	    }
-	}
-	/**
-	 * Parse a v-model expression into a base path and a final key segment.
-	 * Handles both dot-path and possible square brackets.
-	 *
-	 * Possible cases:
-	 *
-	 * - test
-	 * - test[key]
-	 * - test[test1[key]]
-	 * - test["a"][key]
-	 * - xxx.test[a[a].test1[key]]
-	 * - test.xxx.a["asa"][test1[key]]
-	 *
-	 */
-	let len, str, chr, index, expressionPos, expressionEndPos;
-	function parseModel(val) {
-	    // Fix https://github.com/vuejs/vue/pull/7730
-	    // allow v-model="obj.val " (trailing whitespace)
-	    val = val.trim();
-	    len = val.length;
-	    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-	        index = val.lastIndexOf('.');
-	        if (index > -1) {
-	            return {
-	                exp: val.slice(0, index),
-	                key: '"' + val.slice(index + 1) + '"',
-	            };
-	        }
-	        else {
-	            return {
-	                exp: val,
-	                key: null,
-	            };
-	        }
-	    }
-	    str = val;
-	    index = expressionPos = expressionEndPos = 0;
-	    while (!eof()) {
-	        chr = next();
-	        /* istanbul ignore if */
-	        if (isStringStart(chr)) {
-	            parseString(chr);
-	        }
-	        else if (chr === 0x5b) {
-	            parseBracket(chr);
-	        }
-	    }
-	    return {
-	        exp: val.slice(0, expressionPos),
-	        key: val.slice(expressionPos + 1, expressionEndPos),
-	    };
-	}
-	function next() {
-	    return str.charCodeAt(++index);
-	}
-	function eof() {
-	    return index >= len;
-	}
-	function isStringStart(chr) {
-	    return chr === 0x22 || chr === 0x27;
-	}
-	function parseBracket(chr) {
-	    let inBracket = 1;
-	    expressionPos = index;
-	    while (!eof()) {
-	        chr = next();
-	        if (isStringStart(chr)) {
-	            parseString(chr);
-	            continue;
-	        }
-	        if (chr === 0x5b)
-	            inBracket++;
-	        if (chr === 0x5d)
-	            inBracket--;
-	        if (inBracket === 0) {
-	            expressionEndPos = index;
-	            break;
-	        }
-	    }
-	}
-	function parseString(chr) {
-	    const stringQuote = chr;
-	    while (!eof()) {
-	        chr = next();
-	        if (chr === stringQuote) {
-	            break;
-	        }
-	    }
-	}
-
-	const onRE = /^@|^v-on:/;
-	const dirRE = /^v-|^@|^:|^#/;
-	const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-	const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-	const stripParensRE = /^\(|\)$/g;
-	const dynamicArgRE = /^\[.*\]$/;
-	const argRE = /:(.*)$/;
-	const bindRE = /^:|^\.|^v-bind:/;
-	const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-	const slotRE = /^v-slot(:|$)|^#/;
-	const lineBreakRE = /[\r\n]/;
-	const whitespaceRE = /[ \f\t\r\n]+/g;
-	const invalidAttributeRE = /[\s"'<>\/=]/;
-	const decodeHTMLCached = cached(he.decode);
-	const emptySlotScopeToken = `_empty_`;
-	// configurable state
-	let warn$1;
-	let delimiters;
-	let transforms;
-	let preTransforms;
-	let postTransforms;
-	let platformIsPreTag;
-	let platformMustUseProp;
-	let platformGetTagNamespace;
-	let maybeComponent;
-	function createASTElement(tag, attrs, parent) {
-	    return {
-	        type: 1,
-	        tag,
-	        attrsList: attrs,
-	        attrsMap: makeAttrsMap(attrs),
-	        rawAttrsMap: {},
-	        parent,
-	        children: [],
-	    };
-	}
-	/**
-	 * Convert HTML string to AST.
-	 */
-	function parse(template, options) {
-	    warn$1 = options.warn || baseWarn;
-	    platformIsPreTag = options.isPreTag || no;
-	    platformMustUseProp = options.mustUseProp || no;
-	    platformGetTagNamespace = options.getTagNamespace || no;
-	    const isReservedTag = options.isReservedTag || no;
-	    maybeComponent = (el) => !!(el.component ||
-	        el.attrsMap[':is'] ||
-	        el.attrsMap['v-bind:is'] ||
-	        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-	    transforms = pluckModuleFunction(options.modules, 'transformNode');
-	    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-	    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-	    delimiters = options.delimiters;
-	    const stack = [];
-	    const preserveWhitespace = options.preserveWhitespace !== false;
-	    const whitespaceOption = options.whitespace;
-	    let root;
-	    let currentParent;
-	    let inVPre = false;
-	    let inPre = false;
-	    let warned = false;
-	    function warnOnce(msg, range) {
-	        if (!warned) {
-	            warned = true;
-	            warn$1(msg, range);
-	        }
-	    }
-	    function closeElement(element) {
-	        trimEndingWhitespace(element);
-	        if (!inVPre && !element.processed) {
-	            element = processElement(element, options);
-	        }
-	        // tree management
-	        if (!stack.length && element !== root) {
-	            // allow root elements with v-if, v-else-if and v-else
-	            if (root.if && (element.elseif || element.else)) {
-	                {
-	                    checkRootConstraints(element);
-	                }
-	                addIfCondition(root, {
-	                    exp: element.elseif,
-	                    block: element,
-	                });
-	            }
-	            else {
-	                warnOnce(`Component template should contain exactly one root element. ` +
-	                    `If you are using v-if on multiple elements, ` +
-	                    `use v-else-if to chain them instead.`, { start: element.start });
-	            }
-	        }
-	        if (currentParent && !element.forbidden) {
-	            if (element.elseif || element.else) {
-	                processIfConditions(element, currentParent);
-	            }
-	            else {
-	                if (element.slotScope) {
-	                    // scoped slot
-	                    // keep it in the children list so that v-else(-if) conditions can
-	                    // find it as the prev node.
-	                    const name = element.slotTarget || '"default"';
-	                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-	                }
-	                currentParent.children.push(element);
-	                element.parent = currentParent;
-	            }
-	        }
-	        // final children cleanup
-	        // filter out scoped slots
-	        element.children = element.children.filter((c) => !c.slotScope);
-	        // remove trailing whitespace node again
-	        trimEndingWhitespace(element);
-	        // check pre state
-	        if (element.pre) {
-	            inVPre = false;
-	        }
-	        if (platformIsPreTag(element.tag)) {
-	            inPre = false;
-	        }
-	        // apply post-transforms
-	        for (let i = 0; i < postTransforms.length; i++) {
-	            postTransforms[i](element, options);
-	        }
-	    }
-	    function trimEndingWhitespace(el) {
-	        // remove trailing whitespace node
-	        if (!inPre) {
-	            let lastNode;
-	            while ((lastNode = el.children[el.children.length - 1]) &&
-	                lastNode.type === 3 &&
-	                lastNode.text === ' ') {
-	                el.children.pop();
-	            }
-	        }
-	    }
-	    function checkRootConstraints(el) {
-	        if (el.tag === 'slot' || el.tag === 'template') {
-	            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-	                'contain multiple nodes.', { start: el.start });
-	        }
-	        if (el.attrsMap.hasOwnProperty('v-for')) {
-	            warnOnce('Cannot use v-for on stateful component root element because ' +
-	                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-	        }
-	    }
-	    parseHTML(template, {
-	        warn: warn$1,
-	        expectHTML: options.expectHTML,
-	        isUnaryTag: options.isUnaryTag,
-	        canBeLeftOpenTag: options.canBeLeftOpenTag,
-	        shouldDecodeNewlines: options.shouldDecodeNewlines,
-	        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-	        shouldKeepComment: options.comments,
-	        outputSourceRange: options.outputSourceRange,
-	        start(tag, attrs, unary, start, end) {
-	            // check namespace.
-	            // inherit parent ns if there is one
-	            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-	            // handle IE svg bug
-	            /* istanbul ignore if */
-	            if (isIE && ns === 'svg') {
-	                attrs = guardIESVGBug(attrs);
-	            }
-	            let element = createASTElement(tag, attrs, currentParent);
-	            if (ns) {
-	                element.ns = ns;
-	            }
-	            {
-	                if (options.outputSourceRange) {
-	                    element.start = start;
-	                    element.end = end;
-	                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-	                        cumulated[attr.name] = attr;
-	                        return cumulated;
-	                    }, {});
-	                }
-	                attrs.forEach((attr) => {
-	                    if (invalidAttributeRE.test(attr.name)) {
-	                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-	                            `spaces, quotes, <, >, / or =.`, {
-	                            start: attr.start + attr.name.indexOf(`[`),
-	                            end: attr.start + attr.name.length,
-	                        });
-	                    }
-	                });
-	            }
-	            if (isForbiddenTag(element) && !isServerRendering()) {
-	                element.forbidden = true;
-	                warn$1('Templates should only be responsible for mapping the state to the ' +
-	                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-	                        `<${tag}>` +
-	                        ', as they will not be parsed.', { start: element.start });
-	            }
-	            // apply pre-transforms
-	            for (let i = 0; i < preTransforms.length; i++) {
-	                element = preTransforms[i](element, options) || element;
-	            }
-	            if (!inVPre) {
-	                processPre(element);
-	                if (element.pre) {
-	                    inVPre = true;
-	                }
-	            }
-	            if (platformIsPreTag(element.tag)) {
-	                inPre = true;
-	            }
-	            if (inVPre) {
-	                processRawAttrs(element);
-	            }
-	            else if (!element.processed) {
-	                // structural directives
-	                processFor(element);
-	                processIf(element);
-	                processOnce(element);
-	            }
-	            if (!root) {
-	                root = element;
-	                {
-	                    checkRootConstraints(root);
-	                }
-	            }
-	            if (!unary) {
-	                currentParent = element;
-	                stack.push(element);
-	            }
-	            else {
-	                closeElement(element);
-	            }
-	        },
-	        end(tag, start, end) {
-	            const element = stack[stack.length - 1];
-	            // pop stack
-	            stack.length -= 1;
-	            currentParent = stack[stack.length - 1];
-	            if (options.outputSourceRange) {
-	                element.end = end;
-	            }
-	            closeElement(element);
-	        },
-	        chars(text, start, end) {
-	            if (!currentParent) {
-	                {
-	                    if (text === template) {
-	                        warnOnce('Component template requires a root element, rather than just text.', { start });
-	                    }
-	                    else if ((text = text.trim())) {
-	                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-	                            start,
-	                        });
-	                    }
-	                }
-	                return;
-	            }
-	            // IE textarea placeholder bug
-	            /* istanbul ignore if */
-	            if (isIE &&
-	                currentParent.tag === 'textarea' &&
-	                currentParent.attrsMap.placeholder === text) {
-	                return;
-	            }
-	            const children = currentParent.children;
-	            if (inPre || text.trim()) {
-	                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-	            }
-	            else if (!children.length) {
-	                // remove the whitespace-only node right after an opening tag
-	                text = '';
-	            }
-	            else if (whitespaceOption) {
-	                if (whitespaceOption === 'condense') {
-	                    // in condense mode, remove the whitespace node if it contains
-	                    // line break, otherwise condense to a single space
-	                    text = lineBreakRE.test(text) ? '' : ' ';
-	                }
-	                else {
-	                    text = ' ';
-	                }
-	            }
-	            else {
-	                text = preserveWhitespace ? ' ' : '';
-	            }
-	            if (text) {
-	                if (!inPre && whitespaceOption === 'condense') {
-	                    // condense consecutive whitespaces into single space
-	                    text = text.replace(whitespaceRE, ' ');
-	                }
-	                let res;
-	                let child;
-	                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-	                    child = {
-	                        type: 2,
-	                        expression: res.expression,
-	                        tokens: res.tokens,
-	                        text,
-	                    };
-	                }
-	                else if (text !== ' ' ||
-	                    !children.length ||
-	                    children[children.length - 1].text !== ' ') {
-	                    child = {
-	                        type: 3,
-	                        text,
-	                    };
-	                }
-	                if (child) {
-	                    if (options.outputSourceRange) {
-	                        child.start = start;
-	                        child.end = end;
-	                    }
-	                    children.push(child);
-	                }
-	            }
-	        },
-	        comment(text, start, end) {
-	            // adding anything as a sibling to the root node is forbidden
-	            // comments should still be allowed, but ignored
-	            if (currentParent) {
-	                const child = {
-	                    type: 3,
-	                    text,
-	                    isComment: true,
-	                };
-	                if (options.outputSourceRange) {
-	                    child.start = start;
-	                    child.end = end;
-	                }
-	                currentParent.children.push(child);
-	            }
-	        },
-	    });
-	    return root;
-	}
-	function processPre(el) {
-	    if (getAndRemoveAttr(el, 'v-pre') != null) {
-	        el.pre = true;
-	    }
-	}
-	function processRawAttrs(el) {
-	    const list = el.attrsList;
-	    const len = list.length;
-	    if (len) {
-	        const attrs = (el.attrs = new Array(len));
-	        for (let i = 0; i < len; i++) {
-	            attrs[i] = {
-	                name: list[i].name,
-	                value: JSON.stringify(list[i].value),
-	            };
-	            if (list[i].start != null) {
-	                attrs[i].start = list[i].start;
-	                attrs[i].end = list[i].end;
-	            }
-	        }
-	    }
-	    else if (!el.pre) {
-	        // non root node in pre blocks with no attributes
-	        el.plain = true;
-	    }
-	}
-	function processElement(element, options) {
-	    processKey(element);
-	    // determine whether this is a plain element after
-	    // removing structural attributes
-	    element.plain =
-	        !element.key && !element.scopedSlots && !element.attrsList.length;
-	    processRef(element);
-	    processSlotContent(element);
-	    processSlotOutlet(element);
-	    processComponent(element);
-	    for (let i = 0; i < transforms.length; i++) {
-	        element = transforms[i](element, options) || element;
-	    }
-	    processAttrs(element);
-	    return element;
-	}
-	function processKey(el) {
-	    const exp = getBindingAttr(el, 'key');
-	    if (exp) {
-	        {
-	            if (el.tag === 'template') {
-	                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-	            }
-	            if (el.for) {
-	                const iterator = el.iterator2 || el.iterator1;
-	                const parent = el.parent;
-	                if (iterator &&
-	                    iterator === exp &&
-	                    parent &&
-	                    parent.tag === 'transition-group') {
-	                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-	                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-	                }
-	            }
-	        }
-	        el.key = exp;
-	    }
-	}
-	function processRef(el) {
-	    const ref = getBindingAttr(el, 'ref');
-	    if (ref) {
-	        el.ref = ref;
-	        el.refInFor = checkInFor(el);
-	    }
-	}
-	function processFor(el) {
-	    let exp;
-	    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-	        const res = parseFor(exp);
-	        if (res) {
-	            extend(el, res);
-	        }
-	        else {
-	            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-	        }
-	    }
-	}
-	function parseFor(exp) {
-	    const inMatch = exp.match(forAliasRE);
-	    if (!inMatch)
-	        return;
-	    const res = {};
-	    res.for = inMatch[2].trim();
-	    const alias = inMatch[1].trim().replace(stripParensRE, '');
-	    const iteratorMatch = alias.match(forIteratorRE);
-	    if (iteratorMatch) {
-	        res.alias = alias.replace(forIteratorRE, '').trim();
-	        res.iterator1 = iteratorMatch[1].trim();
-	        if (iteratorMatch[2]) {
-	            res.iterator2 = iteratorMatch[2].trim();
-	        }
-	    }
-	    else {
-	        res.alias = alias;
-	    }
-	    return res;
-	}
-	function processIf(el) {
-	    const exp = getAndRemoveAttr(el, 'v-if');
-	    if (exp) {
-	        el.if = exp;
-	        addIfCondition(el, {
-	            exp: exp,
-	            block: el,
-	        });
-	    }
-	    else {
-	        if (getAndRemoveAttr(el, 'v-else') != null) {
-	            el.else = true;
-	        }
-	        const elseif = getAndRemoveAttr(el, 'v-else-if');
-	        if (elseif) {
-	            el.elseif = elseif;
-	        }
-	    }
-	}
-	function processIfConditions(el, parent) {
-	    const prev = findPrevElement(parent.children);
-	    if (prev && prev.if) {
-	        addIfCondition(prev, {
-	            exp: el.elseif,
-	            block: el,
-	        });
-	    }
-	    else {
-	        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-	            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-	    }
-	}
-	function findPrevElement(children) {
-	    let i = children.length;
-	    while (i--) {
-	        if (children[i].type === 1) {
-	            return children[i];
-	        }
-	        else {
-	            if (children[i].text !== ' ') {
-	                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-	                    `will be ignored.`, children[i]);
-	            }
-	            children.pop();
-	        }
-	    }
-	}
-	function addIfCondition(el, condition) {
-	    if (!el.ifConditions) {
-	        el.ifConditions = [];
-	    }
-	    el.ifConditions.push(condition);
-	}
-	function processOnce(el) {
-	    const once = getAndRemoveAttr(el, 'v-once');
-	    if (once != null) {
-	        el.once = true;
-	    }
-	}
-	// handle content being passed to a component as slot,
-	// e.g. <template slot="xxx">, <div slot-scope="xxx">
-	function processSlotContent(el) {
-	    let slotScope;
-	    if (el.tag === 'template') {
-	        slotScope = getAndRemoveAttr(el, 'scope');
-	        /* istanbul ignore if */
-	        if (slotScope) {
-	            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-	                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-	                `can also be used on plain elements in addition to <template> to ` +
-	                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-	        }
-	        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-	    }
-	    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-	        /* istanbul ignore if */
-	        if (el.attrsMap['v-for']) {
-	            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-	                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-	                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-	        }
-	        el.slotScope = slotScope;
-	    }
-	    // slot="xxx"
-	    const slotTarget = getBindingAttr(el, 'slot');
-	    if (slotTarget) {
-	        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-	        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-	        // preserve slot as an attribute for native shadow DOM compat
-	        // only for non-scoped slots.
-	        if (el.tag !== 'template' && !el.slotScope) {
-	            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-	        }
-	    }
-	    // 2.6 v-slot syntax
-	    {
-	        if (el.tag === 'template') {
-	            // v-slot on <template>
-	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-	            if (slotBinding) {
-	                {
-	                    if (el.slotTarget || el.slotScope) {
-	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-	                    }
-	                    if (el.parent && !maybeComponent(el.parent)) {
-	                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-	                            `the receiving component`, el);
-	                    }
-	                }
-	                const { name, dynamic } = getSlotName(slotBinding);
-	                el.slotTarget = name;
-	                el.slotTargetDynamic = dynamic;
-	                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-	            }
-	        }
-	        else {
-	            // v-slot on component, denotes default slot
-	            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-	            if (slotBinding) {
-	                {
-	                    if (!maybeComponent(el)) {
-	                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-	                    }
-	                    if (el.slotScope || el.slotTarget) {
-	                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-	                    }
-	                    if (el.scopedSlots) {
-	                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-	                            `<template> syntax when there are other named slots.`, slotBinding);
-	                    }
-	                }
-	                // add the component's children to its default slot
-	                const slots = el.scopedSlots || (el.scopedSlots = {});
-	                const { name, dynamic } = getSlotName(slotBinding);
-	                const slotContainer = (slots[name] = createASTElement('template', [], el));
-	                slotContainer.slotTarget = name;
-	                slotContainer.slotTargetDynamic = dynamic;
-	                slotContainer.children = el.children.filter((c) => {
-	                    if (!c.slotScope) {
-	                        c.parent = slotContainer;
-	                        return true;
-	                    }
-	                });
-	                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-	                // remove children as they are returned from scopedSlots now
-	                el.children = [];
-	                // mark el non-plain so data gets generated
-	                el.plain = false;
-	            }
-	        }
-	    }
-	}
-	function getSlotName(binding) {
-	    let name = binding.name.replace(slotRE, '');
-	    if (!name) {
-	        if (binding.name[0] !== '#') {
-	            name = 'default';
-	        }
-	        else {
-	            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-	        }
-	    }
-	    return dynamicArgRE.test(name)
-	        ? // dynamic [name]
-	            { name: name.slice(1, -1), dynamic: true }
-	        : // static name
-	            { name: `"${name}"`, dynamic: false };
-	}
-	// handle <slot/> outlets
-	function processSlotOutlet(el) {
-	    if (el.tag === 'slot') {
-	        el.slotName = getBindingAttr(el, 'name');
-	        if (el.key) {
-	            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-	                `and can possibly expand into multiple elements. ` +
-	                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-	        }
-	    }
-	}
-	function processComponent(el) {
-	    let binding;
-	    if ((binding = getBindingAttr(el, 'is'))) {
-	        el.component = binding;
-	    }
-	    if (getAndRemoveAttr(el, 'inline-template') != null) {
-	        el.inlineTemplate = true;
-	    }
-	}
-	function processAttrs(el) {
-	    const list = el.attrsList;
-	    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-	    for (i = 0, l = list.length; i < l; i++) {
-	        name = rawName = list[i].name;
-	        value = list[i].value;
-	        if (dirRE.test(name)) {
-	            // mark element as dynamic
-	            el.hasBindings = true;
-	            // modifiers
-	            modifiers = parseModifiers(name.replace(dirRE, ''));
-	            // support .foo shorthand syntax for the .prop modifier
-	            if (modifiers) {
-	                name = name.replace(modifierRE, '');
-	            }
-	            if (bindRE.test(name)) {
-	                // v-bind
-	                name = name.replace(bindRE, '');
-	                value = parseFilters(value);
-	                isDynamic = dynamicArgRE.test(name);
-	                if (isDynamic) {
-	                    name = name.slice(1, -1);
-	                }
-	                if (value.trim().length === 0) {
-	                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-	                }
-	                if (modifiers) {
-	                    if (modifiers.prop && !isDynamic) {
-	                        name = camelize(name);
-	                        if (name === 'innerHtml')
-	                            name = 'innerHTML';
-	                    }
-	                    if (modifiers.camel && !isDynamic) {
-	                        name = camelize(name);
-	                    }
-	                    if (modifiers.sync) {
-	                        syncGen = genAssignmentCode(value, `$event`);
-	                        if (!isDynamic) {
-	                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-	                            if (hyphenate(name) !== camelize(name)) {
-	                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-	                            }
-	                        }
-	                        else {
-	                            // handler w/ dynamic event name
-	                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-	                            );
-	                        }
-	                    }
-	                }
-	                if ((modifiers && modifiers.prop) ||
-	                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-	                    addProp(el, name, value, list[i], isDynamic);
-	                }
-	                else {
-	                    addAttr(el, name, value, list[i], isDynamic);
-	                }
-	            }
-	            else if (onRE.test(name)) {
-	                // v-on
-	                name = name.replace(onRE, '');
-	                isDynamic = dynamicArgRE.test(name);
-	                if (isDynamic) {
-	                    name = name.slice(1, -1);
-	                }
-	                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-	            }
-	            else {
-	                // normal directives
-	                name = name.replace(dirRE, '');
-	                // parse arg
-	                const argMatch = name.match(argRE);
-	                let arg = argMatch && argMatch[1];
-	                isDynamic = false;
-	                if (arg) {
-	                    name = name.slice(0, -(arg.length + 1));
-	                    if (dynamicArgRE.test(arg)) {
-	                        arg = arg.slice(1, -1);
-	                        isDynamic = true;
-	                    }
-	                }
-	                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-	                if (name === 'model') {
-	                    checkForAliasModel(el, value);
-	                }
-	            }
-	        }
-	        else {
-	            // literal attribute
-	            {
-	                const res = parseText(value, delimiters);
-	                if (res) {
-	                    warn$1(`${name}="${value}": ` +
-	                        'Interpolation inside attributes has been removed. ' +
-	                        'Use v-bind or the colon shorthand instead. For example, ' +
-	                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-	                }
-	            }
-	            addAttr(el, name, JSON.stringify(value), list[i]);
-	            // #6887 firefox doesn't update muted state if set via attribute
-	            // even immediately after element creation
-	            if (!el.component &&
-	                name === 'muted' &&
-	                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-	                addProp(el, name, 'true', list[i]);
-	            }
-	        }
-	    }
-	}
-	function checkInFor(el) {
-	    let parent = el;
-	    while (parent) {
-	        if (parent.for !== undefined) {
-	            return true;
-	        }
-	        parent = parent.parent;
-	    }
-	    return false;
-	}
-	function parseModifiers(name) {
-	    const match = name.match(modifierRE);
-	    if (match) {
-	        const ret = {};
-	        match.forEach((m) => {
-	            ret[m.slice(1)] = true;
-	        });
-	        return ret;
-	    }
-	}
-	function makeAttrsMap(attrs) {
-	    const map = {};
-	    for (let i = 0, l = attrs.length; i < l; i++) {
-	        if (map[attrs[i].name] &&
-	            !isIE &&
-	            !isEdge) {
-	            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-	        }
-	        map[attrs[i].name] = attrs[i].value;
-	    }
-	    return map;
-	}
-	// for script (e.g. type="x/template") or style, do not decode content
-	function isTextTag(el) {
-	    return el.tag === 'script' || el.tag === 'style';
-	}
-	function isForbiddenTag(el) {
-	    return (el.tag === 'style' ||
-	        (el.tag === 'script' &&
-	            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-	}
-	const ieNSBug = /^xmlns:NS\d+/;
-	const ieNSPrefix = /^NS\d+:/;
-	/* istanbul ignore next */
-	function guardIESVGBug(attrs) {
-	    const res = [];
-	    for (let i = 0; i < attrs.length; i++) {
-	        const attr = attrs[i];
-	        if (!ieNSBug.test(attr.name)) {
-	            attr.name = attr.name.replace(ieNSPrefix, '');
-	            res.push(attr);
-	        }
-	    }
-	    return res;
-	}
-	function checkForAliasModel(el, value) {
-	    let _el = el;
-	    while (_el) {
-	        if (_el.for && _el.alias === value) {
-	            warn$1(`<${el.tag} v-model="${value}">: ` +
-	                `You are binding v-model directly to a v-for iteration alias. ` +
-	                `This will not be able to modify the v-for source array because ` +
-	                `writing to the alias is like modifying a function local variable. ` +
-	                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-	        }
-	        _el = _el.parent;
-	    }
-	}
-
-	/**
-	 * Expand input[v-model] with dynamic type bindings into v-if-else chains
-	 * Turn this:
-	 *   <input v-model="data[type]" :type="type">
-	 * into this:
-	 *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-	 *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-	 *   <input v-else :type="type" v-model="data[type]">
-	 */
-	function preTransformNode(el, options) {
-	    if (el.tag === 'input') {
-	        const map = el.attrsMap;
-	        if (!map['v-model']) {
-	            return;
-	        }
-	        let typeBinding;
-	        if (map[':type'] || map['v-bind:type']) {
-	            typeBinding = getBindingAttr(el, 'type');
-	        }
-	        if (!map.type && !typeBinding && map['v-bind']) {
-	            typeBinding = `(${map['v-bind']}).type`;
-	        }
-	        if (typeBinding) {
-	            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-	            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-	            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-	            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-	            // 1. checkbox
-	            const branch0 = cloneASTElement(el);
-	            // process for on the main node
-	            processFor(branch0);
-	            addRawAttr(branch0, 'type', 'checkbox');
-	            processElement(branch0, options);
-	            branch0.processed = true; // prevent it from double-processed
-	            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-	            addIfCondition(branch0, {
-	                exp: branch0.if,
-	                block: branch0,
-	            });
-	            // 2. add radio else-if condition
-	            const branch1 = cloneASTElement(el);
-	            getAndRemoveAttr(branch1, 'v-for', true);
-	            addRawAttr(branch1, 'type', 'radio');
-	            processElement(branch1, options);
-	            addIfCondition(branch0, {
-	                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-	                block: branch1,
-	            });
-	            // 3. other
-	            const branch2 = cloneASTElement(el);
-	            getAndRemoveAttr(branch2, 'v-for', true);
-	            addRawAttr(branch2, ':type', typeBinding);
-	            processElement(branch2, options);
-	            addIfCondition(branch0, {
-	                exp: ifCondition,
-	                block: branch2,
-	            });
-	            if (hasElse) {
-	                branch0.else = true;
-	            }
-	            else if (elseIfCondition) {
-	                branch0.elseif = elseIfCondition;
-	            }
-	            return branch0;
-	        }
-	    }
-	}
-	function cloneASTElement(el) {
-	    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-	}
-	var model$1 = {
-	    preTransformNode,
-	};
-
-	var modules = [klass, style, model$1];
-
-	let warn;
-	// in some cases, the event used has to be determined at runtime
-	// so we used some reserved tokens during compile.
-	const RANGE_TOKEN = '__r';
-	function model(el, dir, _warn) {
-	    warn = _warn;
-	    const value = dir.value;
-	    const modifiers = dir.modifiers;
-	    const tag = el.tag;
-	    const type = el.attrsMap.type;
-	    {
-	        // inputs with type="file" are read only and setting the input's
-	        // value will throw an error.
-	        if (tag === 'input' && type === 'file') {
-	            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-	                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-	        }
-	    }
-	    if (el.component) {
-	        genComponentModel(el, value, modifiers);
-	        // component v-model doesn't need extra runtime
-	        return false;
-	    }
-	    else if (tag === 'select') {
-	        genSelect(el, value, modifiers);
-	    }
-	    else if (tag === 'input' && type === 'checkbox') {
-	        genCheckboxModel(el, value, modifiers);
-	    }
-	    else if (tag === 'input' && type === 'radio') {
-	        genRadioModel(el, value, modifiers);
-	    }
-	    else if (tag === 'input' || tag === 'textarea') {
-	        genDefaultModel(el, value, modifiers);
-	    }
-	    else {
-	        genComponentModel(el, value, modifiers);
-	        // component v-model doesn't need extra runtime
-	        return false;
-	    }
-	    // ensure runtime directive metadata
-	    return true;
-	}
-	function genCheckboxModel(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    const valueBinding = getBindingAttr(el, 'value') || 'null';
-	    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-	    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-	    addProp(el, 'checked', `Array.isArray(${value})` +
-	        `?_i(${value},${valueBinding})>-1` +
-	        (trueValueBinding === 'true'
-	            ? `:(${value})`
-	            : `:_q(${value},${trueValueBinding})`));
-	    addHandler(el, 'change', `var $$a=${value},` +
-	        '$$el=$event.target,' +
-	        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-	        'if(Array.isArray($$a)){' +
-	        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-	        '$$i=_i($$a,$$v);' +
-	        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-	        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-	        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-	}
-	function genRadioModel(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    let valueBinding = getBindingAttr(el, 'value') || 'null';
-	    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-	    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-	    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-	}
-	function genSelect(el, value, modifiers) {
-	    const number = modifiers && modifiers.number;
-	    const selectedVal = `Array.prototype.filter` +
-	        `.call($event.target.options,function(o){return o.selected})` +
-	        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-	        `return ${number ? '_n(val)' : 'val'}})`;
-	    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-	    let code = `var $$selectedVal = ${selectedVal};`;
-	    code = `${code} ${genAssignmentCode(value, assignment)}`;
-	    addHandler(el, 'change', code, null, true);
-	}
-	function genDefaultModel(el, value, modifiers) {
-	    const type = el.attrsMap.type;
-	    // warn if v-bind:value conflicts with v-model
-	    // except for inputs with v-bind:type
-	    {
-	        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-	        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-	        if (value && !typeBinding) {
-	            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-	            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-	                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-	        }
-	    }
-	    const { lazy, number, trim } = modifiers || {};
-	    const needCompositionGuard = !lazy && type !== 'range';
-	    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-	    let valueExpression = '$event.target.value';
-	    if (trim) {
-	        valueExpression = `$event.target.value.trim()`;
-	    }
-	    if (number) {
-	        valueExpression = `_n(${valueExpression})`;
-	    }
-	    let code = genAssignmentCode(value, valueExpression);
-	    if (needCompositionGuard) {
-	        code = `if($event.target.composing)return;${code}`;
-	    }
-	    addProp(el, 'value', `(${value})`);
-	    addHandler(el, event, code, null, true);
-	    if (trim || number) {
-	        addHandler(el, 'blur', '$forceUpdate()');
-	    }
-	}
-
-	function text(el, dir) {
-	    if (dir.value) {
-	        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-	    }
-	}
-
-	function html(el, dir) {
-	    if (dir.value) {
-	        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-	    }
-	}
-
-	var directives = {
-	    model,
-	    text,
-	    html,
-	};
-
-	const baseOptions = {
-	    expectHTML: true,
-	    modules,
-	    directives,
-	    isPreTag,
-	    isUnaryTag,
-	    mustUseProp,
-	    canBeLeftOpenTag,
-	    isReservedTag,
-	    getTagNamespace,
-	    staticKeys: genStaticKeys$1(modules),
-	};
-
-	let isStaticKey;
-	let isPlatformReservedTag$1;
-	const genStaticKeysCached = cached(genStaticKeys);
-	/**
-	 * Goal of the optimizer: walk the generated template AST tree
-	 * and detect sub-trees that are purely static, i.e. parts of
-	 * the DOM that never needs to change.
-	 *
-	 * Once we detect these sub-trees, we can:
-	 *
-	 * 1. Hoist them into constants, so that we no longer need to
-	 *    create fresh nodes for them on each re-render;
-	 * 2. Completely skip them in the patching process.
-	 */
-	function optimize$1(root, options) {
-	    if (!root)
-	        return;
-	    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-	    isPlatformReservedTag$1 = options.isReservedTag || no;
-	    // first pass: mark all non-static nodes.
-	    markStatic(root);
-	    // second pass: mark static roots.
-	    markStaticRoots(root, false);
-	}
-	function genStaticKeys(keys) {
-	    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-	        (keys ? ',' + keys : ''));
-	}
-	function markStatic(node) {
-	    node.static = isStatic(node);
-	    if (node.type === 1) {
-	        // do not make component slot content static. this avoids
-	        // 1. components not able to mutate slot nodes
-	        // 2. static slot content fails for hot-reloading
-	        if (!isPlatformReservedTag$1(node.tag) &&
-	            node.tag !== 'slot' &&
-	            node.attrsMap['inline-template'] == null) {
-	            return;
-	        }
-	        for (let i = 0, l = node.children.length; i < l; i++) {
-	            const child = node.children[i];
-	            markStatic(child);
-	            if (!child.static) {
-	                node.static = false;
-	            }
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                const block = node.ifConditions[i].block;
-	                markStatic(block);
-	                if (!block.static) {
-	                    node.static = false;
-	                }
-	            }
-	        }
-	    }
-	}
-	function markStaticRoots(node, isInFor) {
-	    if (node.type === 1) {
-	        if (node.static || node.once) {
-	            node.staticInFor = isInFor;
-	        }
-	        // For a node to qualify as a static root, it should have children that
-	        // are not just static text. Otherwise the cost of hoisting out will
-	        // outweigh the benefits and it's better off to just always render it fresh.
-	        if (node.static &&
-	            node.children.length &&
-	            !(node.children.length === 1 && node.children[0].type === 3)) {
-	            node.staticRoot = true;
-	            return;
-	        }
-	        else {
-	            node.staticRoot = false;
-	        }
-	        if (node.children) {
-	            for (let i = 0, l = node.children.length; i < l; i++) {
-	                markStaticRoots(node.children[i], isInFor || !!node.for);
-	            }
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                markStaticRoots(node.ifConditions[i].block, isInFor);
-	            }
-	        }
-	    }
-	}
-	function isStatic(node) {
-	    if (node.type === 2) {
-	        // expression
-	        return false;
-	    }
-	    if (node.type === 3) {
-	        // text
-	        return true;
-	    }
-	    return !!(node.pre ||
-	        (!node.hasBindings && // no dynamic bindings
-	            !node.if &&
-	            !node.for && // not v-if or v-for or v-else
-	            !isBuiltInTag(node.tag) && // not a built-in
-	            isPlatformReservedTag$1(node.tag) && // not a component
-	            !isDirectChildOfTemplateFor(node) &&
-	            Object.keys(node).every(isStaticKey)));
-	}
-	function isDirectChildOfTemplateFor(node) {
-	    while (node.parent) {
-	        node = node.parent;
-	        if (node.tag !== 'template') {
-	            return false;
-	        }
-	        if (node.for) {
-	            return true;
-	        }
-	    }
-	    return false;
-	}
-
-	const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-	const fnInvokeRE = /\([^)]*?\);*$/;
-	const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-	// KeyboardEvent.keyCode aliases
-	const keyCodes = {
-	    esc: 27,
-	    tab: 9,
-	    enter: 13,
-	    space: 32,
-	    up: 38,
-	    left: 37,
-	    right: 39,
-	    down: 40,
-	    delete: [8, 46],
-	};
-	// KeyboardEvent.key aliases
-	const keyNames = {
-	    // #7880: IE11 and Edge use `Esc` for Escape key name.
-	    esc: ['Esc', 'Escape'],
-	    tab: 'Tab',
-	    enter: 'Enter',
-	    // #9112: IE11 uses `Spacebar` for Space key name.
-	    space: [' ', 'Spacebar'],
-	    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-	    up: ['Up', 'ArrowUp'],
-	    left: ['Left', 'ArrowLeft'],
-	    right: ['Right', 'ArrowRight'],
-	    down: ['Down', 'ArrowDown'],
-	    // #9112: IE11 uses `Del` for Delete key name.
-	    delete: ['Backspace', 'Delete', 'Del'],
-	};
-	// #4868: modifiers that prevent the execution of the listener
-	// need to explicitly return null so that we can determine whether to remove
-	// the listener for .once
-	const genGuard = (condition) => `if(${condition})return null;`;
-	const modifierCode = {
-	    stop: '$event.stopPropagation();',
-	    prevent: '$event.preventDefault();',
-	    self: genGuard(`$event.target !== $event.currentTarget`),
-	    ctrl: genGuard(`!$event.ctrlKey`),
-	    shift: genGuard(`!$event.shiftKey`),
-	    alt: genGuard(`!$event.altKey`),
-	    meta: genGuard(`!$event.metaKey`),
-	    left: genGuard(`'button' in $event && $event.button !== 0`),
-	    middle: genGuard(`'button' in $event && $event.button !== 1`),
-	    right: genGuard(`'button' in $event && $event.button !== 2`),
-	};
-	function genHandlers(events, isNative) {
-	    const prefix = isNative ? 'nativeOn:' : 'on:';
-	    let staticHandlers = ``;
-	    let dynamicHandlers = ``;
-	    for (const name in events) {
-	        const handlerCode = genHandler(events[name]);
-	        //@ts-expect-error
-	        if (events[name] && events[name].dynamic) {
-	            dynamicHandlers += `${name},${handlerCode},`;
-	        }
-	        else {
-	            staticHandlers += `"${name}":${handlerCode},`;
-	        }
-	    }
-	    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-	    if (dynamicHandlers) {
-	        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-	    }
-	    else {
-	        return prefix + staticHandlers;
-	    }
-	}
-	function genHandler(handler) {
-	    if (!handler) {
-	        return 'function(){}';
-	    }
-	    if (Array.isArray(handler)) {
-	        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-	    }
-	    const isMethodPath = simplePathRE.test(handler.value);
-	    const isFunctionExpression = fnExpRE.test(handler.value);
-	    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-	    if (!handler.modifiers) {
-	        if (isMethodPath || isFunctionExpression) {
-	            return handler.value;
-	        }
-	        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-	    }
-	    else {
-	        let code = '';
-	        let genModifierCode = '';
-	        const keys = [];
-	        for (const key in handler.modifiers) {
-	            if (modifierCode[key]) {
-	                genModifierCode += modifierCode[key];
-	                // left/right
-	                if (keyCodes[key]) {
-	                    keys.push(key);
-	                }
-	            }
-	            else if (key === 'exact') {
-	                const modifiers = handler.modifiers;
-	                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-	                    .filter((keyModifier) => !modifiers[keyModifier])
-	                    .map((keyModifier) => `$event.${keyModifier}Key`)
-	                    .join('||'));
-	            }
-	            else {
-	                keys.push(key);
-	            }
-	        }
-	        if (keys.length) {
-	            code += genKeyFilter(keys);
-	        }
-	        // Make sure modifiers like prevent and stop get executed after key filtering
-	        if (genModifierCode) {
-	            code += genModifierCode;
-	        }
-	        const handlerCode = isMethodPath
-	            ? `return ${handler.value}.apply(null, arguments)`
-	            : isFunctionExpression
-	                ? `return (${handler.value}).apply(null, arguments)`
-	                : isFunctionInvocation
-	                    ? `return ${handler.value}`
-	                    : handler.value;
-	        return `function($event){${code}${handlerCode}}`;
-	    }
-	}
-	function genKeyFilter(keys) {
-	    return (
-	    // make sure the key filters only apply to KeyboardEvents
-	    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-	    // key events that do not have keyCode property...
-	    `if(!$event.type.indexOf('key')&&` +
-	        `${keys.map(genFilterCode).join('&&')})return null;`);
-	}
-	function genFilterCode(key) {
-	    const keyVal = parseInt(key, 10);
-	    if (keyVal) {
-	        return `$event.keyCode!==${keyVal}`;
-	    }
-	    const keyCode = keyCodes[key];
-	    const keyName = keyNames[key];
-	    return (`_k($event.keyCode,` +
-	        `${JSON.stringify(key)},` +
-	        `${JSON.stringify(keyCode)},` +
-	        `$event.key,` +
-	        `${JSON.stringify(keyName)}` +
-	        `)`);
-	}
-
-	function on(el, dir) {
-	    if (dir.modifiers) {
-	        warn$2(`v-on without argument does not support modifiers.`);
-	    }
-	    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-	}
-
-	function bind(el, dir) {
-	    el.wrapData = (code) => {
-	        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-	    };
-	}
-
-	var baseDirectives = {
-	    on,
-	    bind,
-	    cloak: noop,
-	};
-
-	class CodegenState {
-	    options;
-	    warn;
-	    transforms;
-	    dataGenFns;
-	    directives;
-	    maybeComponent;
-	    onceId;
-	    staticRenderFns;
-	    pre;
-	    constructor(options) {
-	        this.options = options;
-	        this.warn = options.warn || baseWarn;
-	        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-	        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-	        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-	        this.directives = extend(extend({}, baseDirectives), options.directives);
-	        const isReservedTag = options.isReservedTag || no;
-	        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-	        this.onceId = 0;
-	        this.staticRenderFns = [];
-	        this.pre = false;
-	    }
-	}
-	function generate$1(ast, options) {
-	    const state = new CodegenState(options);
-	    // fix #11483, Root level <script> tags should not be rendered.
-	    const code = ast
-	        ? ast.tag === 'script'
-	            ? 'null'
-	            : genElement(ast, state)
-	        : '_c("div")';
-	    return {
-	        render: `with(this){return ${code}}`,
-	        staticRenderFns: state.staticRenderFns,
-	    };
-	}
-	function genElement(el, state) {
-	    if (el.parent) {
-	        el.pre = el.pre || el.parent.pre;
-	    }
-	    if (el.staticRoot && !el.staticProcessed) {
-	        return genStatic(el, state);
-	    }
-	    else if (el.once && !el.onceProcessed) {
-	        return genOnce(el, state);
-	    }
-	    else if (el.for && !el.forProcessed) {
-	        return genFor(el, state);
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        return genIf(el, state);
-	    }
-	    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-	        return genChildren(el, state) || 'void 0';
-	    }
-	    else if (el.tag === 'slot') {
-	        return genSlot(el, state);
-	    }
-	    else {
-	        // component or element
-	        let code;
-	        if (el.component) {
-	            code = genComponent(el.component, el, state);
-	        }
-	        else {
-	            let data;
-	            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-	                data = genData(el, state);
-	            }
-	            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-	            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-	        }
-	        // module transforms
-	        for (let i = 0; i < state.transforms.length; i++) {
-	            code = state.transforms[i](el, code);
-	        }
-	        return code;
-	    }
-	}
-	// hoist static sub-trees out
-	function genStatic(el, state) {
-	    el.staticProcessed = true;
-	    // Some elements (templates) need to behave differently inside of a v-pre
-	    // node.  All pre nodes are static roots, so we can use this as a location to
-	    // wrap a state change and reset it upon exiting the pre node.
-	    const originalPreState = state.pre;
-	    if (el.pre) {
-	        state.pre = el.pre;
-	    }
-	    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-	    state.pre = originalPreState;
-	    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-	}
-	// v-once
-	function genOnce(el, state) {
-	    el.onceProcessed = true;
-	    if (el.if && !el.ifProcessed) {
-	        return genIf(el, state);
-	    }
-	    else if (el.staticInFor) {
-	        let key = '';
-	        let parent = el.parent;
-	        while (parent) {
-	            if (parent.for) {
-	                key = parent.key;
-	                break;
-	            }
-	            parent = parent.parent;
-	        }
-	        if (!key) {
-	            state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-	            return genElement(el, state);
-	        }
-	        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-	    }
-	    else {
-	        return genStatic(el, state);
-	    }
-	}
-	function genIf(el, state, altGen, altEmpty) {
-	    el.ifProcessed = true; // avoid recursion
-	    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-	}
-	function genIfConditions(conditions, state, altGen, altEmpty) {
-	    if (!conditions.length) {
-	        return altEmpty || '_e()';
-	    }
-	    const condition = conditions.shift();
-	    if (condition.exp) {
-	        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-	    }
-	    else {
-	        return `${genTernaryExp(condition.block)}`;
-	    }
-	    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-	    function genTernaryExp(el) {
-	        return altGen
-	            ? altGen(el, state)
-	            : el.once
-	                ? genOnce(el, state)
-	                : genElement(el, state);
-	    }
-	}
-	function genFor(el, state, altGen, altHelper) {
-	    const exp = el.for;
-	    const alias = el.alias;
-	    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-	    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-	    if (state.maybeComponent(el) &&
-	        el.tag !== 'slot' &&
-	        el.tag !== 'template' &&
-	        !el.key) {
-	        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-	            `v-for should have explicit keys. ` +
-	            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-	    }
-	    el.forProcessed = true; // avoid recursion
-	    return (`${altHelper || '_l'}((${exp}),` +
-	        `function(${alias}${iterator1}${iterator2}){` +
-	        `return ${(altGen || genElement)(el, state)}` +
-	        '})');
-	}
-	function genData(el, state) {
-	    let data = '{';
-	    // directives first.
-	    // directives may mutate the el's other properties before they are generated.
-	    const dirs = genDirectives(el, state);
-	    if (dirs)
-	        data += dirs + ',';
-	    // key
-	    if (el.key) {
-	        data += `key:${el.key},`;
-	    }
-	    // ref
-	    if (el.ref) {
-	        data += `ref:${el.ref},`;
-	    }
-	    if (el.refInFor) {
-	        data += `refInFor:true,`;
-	    }
-	    // pre
-	    if (el.pre) {
-	        data += `pre:true,`;
-	    }
-	    // record original tag name for components using "is" attribute
-	    if (el.component) {
-	        data += `tag:"${el.tag}",`;
-	    }
-	    // module data generation functions
-	    for (let i = 0; i < state.dataGenFns.length; i++) {
-	        data += state.dataGenFns[i](el);
-	    }
-	    // attributes
-	    if (el.attrs) {
-	        data += `attrs:${genProps(el.attrs)},`;
-	    }
-	    // DOM props
-	    if (el.props) {
-	        data += `domProps:${genProps(el.props)},`;
-	    }
-	    // event handlers
-	    if (el.events) {
-	        data += `${genHandlers(el.events, false)},`;
-	    }
-	    if (el.nativeEvents) {
-	        data += `${genHandlers(el.nativeEvents, true)},`;
-	    }
-	    // slot target
-	    // only for non-scoped slots
-	    if (el.slotTarget && !el.slotScope) {
-	        data += `slot:${el.slotTarget},`;
-	    }
-	    // scoped slots
-	    if (el.scopedSlots) {
-	        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-	    }
-	    // component v-model
-	    if (el.model) {
-	        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-	    }
-	    // inline-template
-	    if (el.inlineTemplate) {
-	        const inlineTemplate = genInlineTemplate(el, state);
-	        if (inlineTemplate) {
-	            data += `${inlineTemplate},`;
-	        }
-	    }
-	    data = data.replace(/,$/, '') + '}';
-	    // v-bind dynamic argument wrap
-	    // v-bind with dynamic arguments must be applied using the same v-bind object
-	    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-	    if (el.dynamicAttrs) {
-	        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-	    }
-	    // v-bind data wrap
-	    if (el.wrapData) {
-	        data = el.wrapData(data);
-	    }
-	    // v-on data wrap
-	    if (el.wrapListeners) {
-	        data = el.wrapListeners(data);
-	    }
-	    return data;
-	}
-	function genDirectives(el, state) {
-	    const dirs = el.directives;
-	    if (!dirs)
-	        return;
-	    let res = 'directives:[';
-	    let hasRuntime = false;
-	    let i, l, dir, needRuntime;
-	    for (i = 0, l = dirs.length; i < l; i++) {
-	        dir = dirs[i];
-	        needRuntime = true;
-	        const gen = state.directives[dir.name];
-	        if (gen) {
-	            // compile-time directive that manipulates AST.
-	            // returns true if it also needs a runtime counterpart.
-	            needRuntime = !!gen(el, dir, state.warn);
-	        }
-	        if (needRuntime) {
-	            hasRuntime = true;
-	            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-	        }
-	    }
-	    if (hasRuntime) {
-	        return res.slice(0, -1) + ']';
-	    }
-	}
-	function genInlineTemplate(el, state) {
-	    const ast = el.children[0];
-	    if ((el.children.length !== 1 || ast.type !== 1)) {
-	        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-	    }
-	    if (ast && ast.type === 1) {
-	        const inlineRenderFns = generate$1(ast, state.options);
-	        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-	    }
-	}
-	function genScopedSlots(el, slots, state) {
-	    // by default scoped slots are considered "stable", this allows child
-	    // components with only scoped slots to skip forced updates from parent.
-	    // but in some cases we have to bail-out of this optimization
-	    // for example if the slot contains dynamic names, has v-if or v-for on them...
-	    let needsForceUpdate = el.for ||
-	        Object.keys(slots).some((key) => {
-	            const slot = slots[key];
-	            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-	            );
-	        });
-	    // #9534: if a component with scoped slots is inside a conditional branch,
-	    // it's possible for the same component to be reused but with different
-	    // compiled slot content. To avoid that, we generate a unique key based on
-	    // the generated code of all the slot contents.
-	    let needsKey = !!el.if;
-	    // OR when it is inside another scoped slot or v-for (the reactivity may be
-	    // disconnected due to the intermediate scope variable)
-	    // #9438, #9506
-	    // TODO: this can be further optimized by properly analyzing in-scope bindings
-	    // and skip force updating ones that do not actually use scope variables.
-	    if (!needsForceUpdate) {
-	        let parent = el.parent;
-	        while (parent) {
-	            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-	                parent.for) {
-	                needsForceUpdate = true;
-	                break;
-	            }
-	            if (parent.if) {
-	                needsKey = true;
-	            }
-	            parent = parent.parent;
-	        }
-	    }
-	    const generatedSlots = Object.keys(slots)
-	        .map((key) => genScopedSlot(slots[key], state))
-	        .join(',');
-	    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-	}
-	function hash(str) {
-	    let hash = 5381;
-	    let i = str.length;
-	    while (i) {
-	        hash = (hash * 33) ^ str.charCodeAt(--i);
-	    }
-	    return hash >>> 0;
-	}
-	function containsSlotChild(el) {
-	    if (el.type === 1) {
-	        if (el.tag === 'slot') {
-	            return true;
-	        }
-	        return el.children.some(containsSlotChild);
-	    }
-	    return false;
-	}
-	function genScopedSlot(el, state) {
-	    const isLegacySyntax = el.attrsMap['slot-scope'];
-	    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-	        return genIf(el, state, genScopedSlot, `null`);
-	    }
-	    if (el.for && !el.forProcessed) {
-	        return genFor(el, state, genScopedSlot);
-	    }
-	    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-	    const fn = `function(${slotScope}){` +
-	        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-	    // reverse proxy v-slot without scope on this.$slots
-	    const reverseProxy = slotScope ? `` : `,proxy:true`;
-	    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-	}
-	function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-	    const children = el.children;
-	    if (children.length) {
-	        const el = children[0];
-	        // optimize single v-for
-	        if (children.length === 1 &&
-	            el.for &&
-	            el.tag !== 'template' &&
-	            el.tag !== 'slot') {
-	            const normalizationType = checkSkip
-	                ? state.maybeComponent(el)
-	                    ? `,1`
-	                    : `,0`
-	                : ``;
-	            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-	        }
-	        const normalizationType = checkSkip
-	            ? getNormalizationType(children, state.maybeComponent)
-	            : 0;
-	        const gen = altGenNode || genNode;
-	        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-	    }
-	}
-	// determine the normalization needed for the children array.
-	// 0: no normalization needed
-	// 1: simple normalization needed (possible 1-level deep nested array)
-	// 2: full normalization needed
-	function getNormalizationType(children, maybeComponent) {
-	    let res = 0;
-	    for (let i = 0; i < children.length; i++) {
-	        const el = children[i];
-	        if (el.type !== 1) {
-	            continue;
-	        }
-	        if (needsNormalization(el) ||
-	            (el.ifConditions &&
-	                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-	            res = 2;
-	            break;
-	        }
-	        if (maybeComponent(el) ||
-	            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-	            res = 1;
-	        }
-	    }
-	    return res;
-	}
-	function needsNormalization(el) {
-	    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-	}
-	function genNode(node, state) {
-	    if (node.type === 1) {
-	        return genElement(node, state);
-	    }
-	    else if (node.type === 3 && node.isComment) {
-	        return genComment(node);
-	    }
-	    else {
-	        return genText(node);
-	    }
-	}
-	function genText(text) {
-	    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-	}
-	function genComment(comment) {
-	    return `_e(${JSON.stringify(comment.text)})`;
-	}
-	function genSlot(el, state) {
-	    const slotName = el.slotName || '"default"';
-	    const children = genChildren(el, state);
-	    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-	    const attrs = el.attrs || el.dynamicAttrs
-	        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-	            // slot props are camelized
-	            name: camelize(attr.name),
-	            value: attr.value,
-	            dynamic: attr.dynamic
-	        })))
-	        : null;
-	    const bind = el.attrsMap['v-bind'];
-	    if ((attrs || bind) && !children) {
-	        res += `,null`;
-	    }
-	    if (attrs) {
-	        res += `,${attrs}`;
-	    }
-	    if (bind) {
-	        res += `${attrs ? '' : ',null'},${bind}`;
-	    }
-	    return res + ')';
-	}
-	// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-	function genComponent(componentName, el, state) {
-	    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-	    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-	}
-	function genProps(props) {
-	    let staticProps = ``;
-	    let dynamicProps = ``;
-	    for (let i = 0; i < props.length; i++) {
-	        const prop = props[i];
-	        const value = transformSpecialNewlines(prop.value);
-	        if (prop.dynamic) {
-	            dynamicProps += `${prop.name},${value},`;
-	        }
-	        else {
-	            staticProps += `"${prop.name}":${value},`;
-	        }
-	    }
-	    staticProps = `{${staticProps.slice(0, -1)}}`;
-	    if (dynamicProps) {
-	        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-	    }
-	    else {
-	        return staticProps;
-	    }
-	}
-	// #3895, #4268
-	function transformSpecialNewlines(text) {
-	    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-	}
-
-	// these keywords should not appear inside expressions, but operators like
-	// typeof, instanceof and in are allowed
-	const prohibitedKeywordRE = new RegExp('\\b' +
-	    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-	        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-	        'extends,finally,continue,debugger,function,arguments')
-	        .split(',')
-	        .join('\\b|\\b') +
-	    '\\b');
-	// these unary operators should not be used as property/method names
-	const unaryOperatorsRE = new RegExp('\\b' +
-	    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-	    '\\s*\\([^\\)]*\\)');
-	// strip strings in expressions
-	const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-	// detect problematic expressions in a template
-	function detectErrors(ast, warn) {
-	    if (ast) {
-	        checkNode(ast, warn);
-	    }
-	}
-	function checkNode(node, warn) {
-	    if (node.type === 1) {
-	        for (const name in node.attrsMap) {
-	            if (dirRE.test(name)) {
-	                const value = node.attrsMap[name];
-	                if (value) {
-	                    const range = node.rawAttrsMap[name];
-	                    if (name === 'v-for') {
-	                        checkFor(node, `v-for="${value}"`, warn, range);
-	                    }
-	                    else if (name === 'v-slot' || name[0] === '#') {
-	                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-	                    }
-	                    else if (onRE.test(name)) {
-	                        checkEvent(value, `${name}="${value}"`, warn, range);
-	                    }
-	                    else {
-	                        checkExpression(value, `${name}="${value}"`, warn, range);
-	                    }
-	                }
-	            }
-	        }
-	        if (node.children) {
-	            for (let i = 0; i < node.children.length; i++) {
-	                checkNode(node.children[i], warn);
-	            }
-	        }
-	    }
-	    else if (node.type === 2) {
-	        checkExpression(node.expression, node.text, warn, node);
-	    }
-	}
-	function checkEvent(exp, text, warn, range) {
-	    const stripped = exp.replace(stripStringRE, '');
-	    const keywordMatch = stripped.match(unaryOperatorsRE);
-	    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-	        warn(`avoid using JavaScript unary operator as property name: ` +
-	            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-	    }
-	    checkExpression(exp, text, warn, range);
-	}
-	function checkFor(node, text, warn, range) {
-	    checkExpression(node.for || '', text, warn, range);
-	    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-	    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-	    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-	}
-	function checkIdentifier(ident, type, text, warn, range) {
-	    if (typeof ident === 'string') {
-	        try {
-	            new Function(`var ${ident}=_`);
-	        }
-	        catch (e) {
-	            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-	        }
-	    }
-	}
-	function checkExpression(exp, text, warn, range) {
-	    try {
-	        new Function(`return ${exp}`);
-	    }
-	    catch (e) {
-	        const keywordMatch = exp
-	            .replace(stripStringRE, '')
-	            .match(prohibitedKeywordRE);
-	        if (keywordMatch) {
-	            warn(`avoid using JavaScript keyword as property name: ` +
-	                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-	        }
-	        else {
-	            warn(`invalid expression: ${e.message} in\n\n` +
-	                `    ${exp}\n\n` +
-	                `  Raw expression: ${text.trim()}\n`, range);
-	        }
-	    }
-	}
-	function checkFunctionParameterExpression(exp, text, warn, range) {
-	    try {
-	        new Function(exp, '');
-	    }
-	    catch (e) {
-	        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-	            `    ${exp}\n\n` +
-	            `  Raw expression: ${text.trim()}\n`, range);
-	    }
-	}
-
-	const range = 2;
-	function generateCodeFrame(source, start = 0, end = source.length) {
-	    const lines = source.split(/\r?\n/);
-	    let count = 0;
-	    const res = [];
-	    for (let i = 0; i < lines.length; i++) {
-	        count += lines[i].length + 1;
-	        if (count >= start) {
-	            for (let j = i - range; j <= i + range || end > count; j++) {
-	                if (j < 0 || j >= lines.length)
-	                    continue;
-	                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-	                const lineLength = lines[j].length;
-	                if (j === i) {
-	                    // push underline
-	                    const pad = start - (count - lineLength) + 1;
-	                    const length = end > count ? lineLength - pad : end - start;
-	                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-	                }
-	                else if (j > i) {
-	                    if (end > count) {
-	                        const length = Math.min(end - count, lineLength);
-	                        res.push(`   |  ` + repeat(`^`, length));
-	                    }
-	                    count += lineLength + 1;
-	                }
-	            }
-	            break;
-	        }
-	    }
-	    return res.join('\n');
-	}
-	function repeat(str, n) {
-	    let result = '';
-	    if (n > 0) {
-	        // eslint-disable-next-line no-constant-condition
-	        while (true) {
-	            // eslint-disable-line
-	            if (n & 1)
-	                result += str;
-	            n >>>= 1;
-	            if (n <= 0)
-	                break;
-	            str += str;
-	        }
-	    }
-	    return result;
-	}
-
-	function createFunction(code, errors) {
-	    try {
-	        return new Function(code);
-	    }
-	    catch (err) {
-	        errors.push({ err, code });
-	        return noop;
-	    }
-	}
-	function createCompileToFunctionFn(compile) {
-	    const cache = Object.create(null);
-	    return function compileToFunctions(template, options, vm) {
-	        options = extend({}, options);
-	        const warn = options.warn || warn$2;
-	        delete options.warn;
-	        /* istanbul ignore if */
-	        {
-	            // detect possible CSP restriction
-	            try {
-	                new Function('return 1');
-	            }
-	            catch (e) {
-	                if (e.toString().match(/unsafe-eval|CSP/)) {
-	                    warn('It seems you are using the standalone build of Vue.js in an ' +
-	                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-	                        'The template compiler cannot work in this environment. Consider ' +
-	                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-	                        'templates into render functions.');
-	                }
-	            }
-	        }
-	        // check cache
-	        const key = options.delimiters
-	            ? String(options.delimiters) + template
-	            : template;
-	        if (cache[key]) {
-	            return cache[key];
-	        }
-	        // compile
-	        const compiled = compile(template, options);
-	        // check compilation errors/tips
-	        {
-	            if (compiled.errors && compiled.errors.length) {
-	                if (options.outputSourceRange) {
-	                    compiled.errors.forEach((e) => {
-	                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-	                            generateCodeFrame(template, e.start, e.end), vm);
-	                    });
-	                }
-	                else {
-	                    warn(`Error compiling template:\n\n${template}\n\n` +
-	                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-	                        '\n', vm);
-	                }
-	            }
-	            if (compiled.tips && compiled.tips.length) {
-	                if (options.outputSourceRange) {
-	                    compiled.tips.forEach((e) => tip(e.msg, vm));
-	                }
-	                else {
-	                    compiled.tips.forEach((msg) => tip(msg, vm));
-	                }
-	            }
-	        }
-	        // turn code into functions
-	        const res = {};
-	        const fnGenErrors = [];
-	        res.render = createFunction(compiled.render, fnGenErrors);
-	        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-	            return createFunction(code, fnGenErrors);
-	        });
-	        // check function generation errors.
-	        // this should only happen if there is a bug in the compiler itself.
-	        // mostly for codegen development use
-	        /* istanbul ignore if */
-	        {
-	            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-	                warn(`Failed to generate render function:\n\n` +
-	                    fnGenErrors
-	                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-	                        .join('\n'), vm);
-	            }
-	        }
-	        return (cache[key] = res);
-	    };
-	}
-
-	function createCompilerCreator(baseCompile) {
-	    return function createCompiler(baseOptions) {
-	        function compile(template, options) {
-	            const finalOptions = Object.create(baseOptions);
-	            const errors = [];
-	            const tips = [];
-	            let warn = (msg, range, tip) => {
-	                (tip ? tips : errors).push(msg);
-	            };
-	            if (options) {
-	                if (options.outputSourceRange) {
-	                    // $flow-disable-line
-	                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-	                    warn = (msg, range, tip) => {
-	                        const data = { msg };
-	                        if (range) {
-	                            if (range.start != null) {
-	                                data.start = range.start + leadingSpaceLength;
-	                            }
-	                            if (range.end != null) {
-	                                data.end = range.end + leadingSpaceLength;
-	                            }
-	                        }
-	                        (tip ? tips : errors).push(data);
-	                    };
-	                }
-	                // merge custom modules
-	                if (options.modules) {
-	                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-	                }
-	                // merge custom directives
-	                if (options.directives) {
-	                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-	                }
-	                // copy other options
-	                for (const key in options) {
-	                    if (key !== 'modules' && key !== 'directives') {
-	                        finalOptions[key] = options[key];
-	                    }
-	                }
-	            }
-	            finalOptions.warn = warn;
-	            const compiled = baseCompile(template.trim(), finalOptions);
-	            {
-	                detectErrors(compiled.ast, warn);
-	            }
-	            compiled.errors = errors;
-	            compiled.tips = tips;
-	            return compiled;
-	        }
-	        return {
-	            compile,
-	            compileToFunctions: createCompileToFunctionFn(compile),
-	        };
-	    };
-	}
-
-	// `createCompilerCreator` allows creating compilers that use alternative
-	// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-	// Here we just export a default compiler using the default parts.
-	const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
-	    const ast = parse(template.trim(), options);
-	    if (options.optimize !== false) {
-	        optimize$1(ast, options);
-	    }
-	    const code = generate$1(ast, options);
-	    return {
-	        ast,
-	        render: code.render,
-	        staticRenderFns: code.staticRenderFns,
-	    };
-	});
-
-	const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
-
-	const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-	    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-	    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-	    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-	    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-	    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-	    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-	    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-	    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-	    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-	    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-	    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-	    'target,title,usemap,value,width,wrap');
-	/* istanbul ignore next */
-	const isRenderableAttr = (name) => {
-	    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-	};
-	const propsToAttrMap = {
-	    acceptCharset: 'accept-charset',
-	    className: 'class',
-	    htmlFor: 'for',
-	    httpEquiv: 'http-equiv',
-	};
-	const ESC = {
-	    '<': '&lt;',
-	    '>': '&gt;',
-	    '"': '&quot;',
-	    '&': '&amp;',
-	};
-	function escape(s) {
-	    return s.replace(/[<>"&]/g, escapeChar);
-	}
-	function escapeChar(a) {
-	    return ESC[a] || a;
-	}
-
-	const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-	// let the model AST transform translate v-model into appropriate
-	// props bindings
-	function applyModelTransform(el, state) {
-	    if (el.directives) {
-	        for (let i = 0; i < el.directives.length; i++) {
-	            const dir = el.directives[i];
-	            if (dir.name === 'model') {
-	                state.directives.model(el, dir, state.warn);
-	                // remove value for textarea as its converted to text
-	                if (el.tag === 'textarea' && el.props) {
-	                    el.props = el.props.filter((p) => p.name !== 'value');
-	                }
-	                break;
-	            }
-	        }
-	    }
-	}
-	function genAttrSegments(attrs) {
-	    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-	}
-	function genDOMPropSegments(props, attrs) {
-	    const segments = [];
-	    props.forEach(({ name, value }) => {
-	        name = propsToAttrMap[name] || name.toLowerCase();
-	        if (isRenderableAttr(name) &&
-	            !(attrs && attrs.some((a) => a.name === name))) {
-	            segments.push(genAttrSegment(name, value));
-	        }
-	    });
-	    return segments;
-	}
-	function genAttrSegment(name, value) {
-	    if (plainStringRE.test(value)) {
-	        // force double quote
-	        value = value.replace(/^'|'$/g, '"');
-	        // force enumerated attr to "true"
-	        if (isEnumeratedAttr(name) && value !== `"false"`) {
-	            value = `"true"`;
-	        }
-	        return {
-	            type: RAW,
-	            value: isBooleanAttr(name)
-	                ? ` ${name}="${name}"`
-	                : value === '""'
-	                    ? ` ${name}`
-	                    : ` ${name}="${JSON.parse(value)}"`,
-	        };
-	    }
-	    else {
-	        return {
-	            type: EXPRESSION,
-	            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-	        };
-	    }
-	}
-	function genClassSegments(staticClass, classBinding) {
-	    if (staticClass && !classBinding) {
-	        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-	    }
-	    else {
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-	            },
-	        ];
-	    }
-	}
-	function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-	    if (staticStyle && !styleBinding && !vShowExpression) {
-	        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-	    }
-	    else {
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-	            },
-	        ];
-	    }
-	}
-
-	/**
-	 * In SSR, the vdom tree is generated only once and never patched, so
-	 * we can optimize most element / trees into plain string render functions.
-	 * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-	 *
-	 * The criteria for SSR optimizability is quite a bit looser than static tree
-	 * detection (which is designed for client re-render). In SSR we bail only for
-	 * components/slots/custom directives.
-	 */
-	// optimizability constants
-	const optimizability = {
-	    FALSE: 0,
-	    FULL: 1,
-	    SELF: 2,
-	    CHILDREN: 3,
-	    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-	};
-	let isPlatformReservedTag;
-	function optimize(root, options) {
-	    if (!root)
-	        return;
-	    isPlatformReservedTag = options.isReservedTag || no;
-	    walk(root, true);
-	}
-	function walk(node, isRoot) {
-	    if (isUnOptimizableTree(node)) {
-	        node.ssrOptimizability = optimizability.FALSE;
-	        return;
-	    }
-	    // root node or nodes with custom directives should always be a VNode
-	    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-	    const check = (child) => {
-	        if (child.ssrOptimizability !== optimizability.FULL) {
-	            node.ssrOptimizability = selfUnoptimizable
-	                ? optimizability.PARTIAL
-	                : optimizability.SELF;
-	        }
-	    };
-	    if (selfUnoptimizable) {
-	        node.ssrOptimizability = optimizability.CHILDREN;
-	    }
-	    if (node.type === 1) {
-	        for (let i = 0, l = node.children.length; i < l; i++) {
-	            const child = node.children[i];
-	            walk(child);
-	            check(child);
-	        }
-	        if (node.ifConditions) {
-	            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-	                const block = node.ifConditions[i].block;
-	                walk(block, isRoot);
-	                check(block);
-	            }
-	        }
-	        if (node.ssrOptimizability == null ||
-	            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-	            node.ssrOptimizability = optimizability.FULL;
-	        }
-	        else {
-	            node.children = optimizeSiblings(node);
-	        }
-	    }
-	    else {
-	        node.ssrOptimizability = optimizability.FULL;
-	    }
-	}
-	function optimizeSiblings(el) {
-	    const children = el.children;
-	    const optimizedChildren = [];
-	    let currentOptimizableGroup = [];
-	    const pushGroup = () => {
-	        if (currentOptimizableGroup.length) {
-	            optimizedChildren.push({
-	                type: 1,
-	                parent: el,
-	                tag: 'template',
-	                attrsList: [],
-	                attrsMap: {},
-	                rawAttrsMap: {},
-	                children: currentOptimizableGroup,
-	                ssrOptimizability: optimizability.FULL,
-	            });
-	        }
-	        currentOptimizableGroup = [];
-	    };
-	    for (let i = 0; i < children.length; i++) {
-	        const c = children[i];
-	        if (c.ssrOptimizability === optimizability.FULL) {
-	            currentOptimizableGroup.push(c);
-	        }
-	        else {
-	            // wrap fully-optimizable adjacent siblings inside a template tag
-	            // so that they can be optimized into a single ssrNode by codegen
-	            pushGroup();
-	            optimizedChildren.push(c);
-	        }
-	    }
-	    pushGroup();
-	    return optimizedChildren;
-	}
-	function isUnOptimizableTree(node) {
-	    if (node.type === 2 || node.type === 3) {
-	        // text or expression
-	        return false;
-	    }
-	    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-	        !isPlatformReservedTag(node.tag) || // custom component
-	        !!node.component || // "is" component
-	        isSelectWithModel(node) // <select v-model> requires runtime inspection
-	    );
-	}
-	const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-	function hasCustomDirective(node) {
-	    return (node.type === 1 &&
-	        node.directives &&
-	        node.directives.some((d) => !isBuiltInDir(d.name)));
-	}
-	// <select v-model> cannot be optimized because it requires a runtime check
-	// to determine proper selected option
-	function isSelectWithModel(node) {
-	    return (node.type === 1 &&
-	        node.tag === 'select' &&
-	        node.directives != null &&
-	        node.directives.some((d) => d.name === 'model'));
-	}
-
-	// The SSR codegen is essentially extending the default codegen to handle
-	// segment types
-	const RAW = 0;
-	const INTERPOLATION = 1;
-	const EXPRESSION = 2;
-	function generate(ast, options) {
-	    const state = new CodegenState(options);
-	    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-	    return {
-	        render: `with(this){return ${code}}`,
-	        staticRenderFns: state.staticRenderFns,
-	    };
-	}
-	function genSSRElement(el, state) {
-	    if (el.for && !el.forProcessed) {
-	        return genFor(el, state, genSSRElement);
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        return genIf(el, state, genSSRElement);
-	    }
-	    else if (el.tag === 'template' && !el.slotTarget) {
-	        return el.ssrOptimizability === optimizability.FULL
-	            ? genChildrenAsStringNode(el, state)
-	            : genSSRChildren(el, state) || 'void 0';
-	    }
-	    switch (el.ssrOptimizability) {
-	        case optimizability.FULL:
-	            // stringify whole tree
-	            return genStringElement(el, state);
-	        case optimizability.SELF:
-	            // stringify self and check children
-	            return genStringElementWithChildren(el, state);
-	        case optimizability.CHILDREN:
-	            // generate self as VNode and stringify children
-	            return genNormalElement(el, state, true);
-	        case optimizability.PARTIAL:
-	            // generate self as VNode and check children
-	            return genNormalElement(el, state, false);
-	        default:
-	            // bail whole tree
-	            return genElement(el, state);
-	    }
-	}
-	function genNormalElement(el, state, stringifyChildren) {
-	    const data = el.plain ? undefined : genData(el, state);
-	    const children = stringifyChildren
-	        ? `[${genChildrenAsStringNode(el, state)}]`
-	        : genSSRChildren(el, state, true);
-	    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-	}
-	function genSSRChildren(el, state, checkSkip) {
-	    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-	}
-	function genSSRNode(el, state) {
-	    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-	}
-	function genChildrenAsStringNode(el, state) {
-	    return el.children.length
-	        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-	        : '';
-	}
-	function genStringElement(el, state) {
-	    return `_ssrNode(${elementToString(el, state)})`;
-	}
-	function genStringElementWithChildren(el, state) {
-	    const children = genSSRChildren(el, state, true);
-	    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-	}
-	function elementToString(el, state) {
-	    return `(${flattenSegments(elementToSegments(el, state))})`;
-	}
-	function elementToSegments(el, state) {
-	    // v-for / v-if
-	    if (el.for && !el.forProcessed) {
-	        el.forProcessed = true;
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: genFor(el, state, elementToString, '_ssrList'),
-	            },
-	        ];
-	    }
-	    else if (el.if && !el.ifProcessed) {
-	        el.ifProcessed = true;
-	        return [
-	            {
-	                type: EXPRESSION,
-	                value: genIf(el, state, elementToString, '"<!---->"'),
-	            },
-	        ];
-	    }
-	    else if (el.tag === 'template') {
-	        return childrenToSegments(el, state);
-	    }
-	    const openSegments = elementToOpenTagSegments(el, state);
-	    const childrenSegments = childrenToSegments(el, state);
-	    const { isUnaryTag } = state.options;
-	    const close = isUnaryTag && isUnaryTag(el.tag)
-	        ? []
-	        : [{ type: RAW, value: `</${el.tag}>` }];
-	    return openSegments.concat(childrenSegments, close);
-	}
-	function elementToOpenTagSegments(el, state) {
-	    applyModelTransform(el, state);
-	    let binding;
-	    const segments = [{ type: RAW, value: `<${el.tag}` }];
-	    // attrs
-	    if (el.attrs) {
-	        segments.push.apply(segments, genAttrSegments(el.attrs));
-	    }
-	    // domProps
-	    if (el.props) {
-	        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-	    }
-	    // v-bind="object"
-	    if ((binding = el.attrsMap['v-bind'])) {
-	        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-	    }
-	    // v-bind.prop="object"
-	    if ((binding = el.attrsMap['v-bind.prop'])) {
-	        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-	    }
-	    // class
-	    if (el.staticClass || el.classBinding) {
-	        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-	    }
-	    // style & v-show
-	    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-	        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-	    }
-	    // _scopedId
-	    if (state.options.scopeId) {
-	        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-	    }
-	    segments.push({ type: RAW, value: `>` });
-	    return segments;
-	}
-	function childrenToSegments(el, state) {
-	    let binding;
-	    if ((binding = el.attrsMap['v-html'])) {
-	        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-	    }
-	    if ((binding = el.attrsMap['v-text'])) {
-	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-	    }
-	    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-	        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-	    }
-	    return el.children ? nodesToSegments(el.children, state) : [];
-	}
-	function nodesToSegments(children, state) {
-	    const segments = [];
-	    for (let i = 0; i < children.length; i++) {
-	        const c = children[i];
-	        if (c.type === 1) {
-	            segments.push.apply(segments, elementToSegments(c, state));
-	        }
-	        else if (c.type === 2) {
-	            segments.push({ type: INTERPOLATION, value: c.expression });
-	        }
-	        else if (c.type === 3) {
-	            let text = escape(c.text);
-	            if (c.isComment) {
-	                text = '<!--' + text + '-->';
-	            }
-	            segments.push({ type: RAW, value: text });
-	        }
-	    }
-	    return segments;
-	}
-	function flattenSegments(segments) {
-	    const mergedSegments = [];
-	    let textBuffer = '';
-	    const pushBuffer = () => {
-	        if (textBuffer) {
-	            mergedSegments.push(JSON.stringify(textBuffer));
-	            textBuffer = '';
-	        }
-	    };
-	    for (let i = 0; i < segments.length; i++) {
-	        const s = segments[i];
-	        if (s.type === RAW) {
-	            textBuffer += s.value;
-	        }
-	        else if (s.type === INTERPOLATION) {
-	            pushBuffer();
-	            mergedSegments.push(`_ssrEscape(${s.value})`);
-	        }
-	        else if (s.type === EXPRESSION) {
-	            pushBuffer();
-	            mergedSegments.push(`(${s.value})`);
-	        }
-	    }
-	    pushBuffer();
-	    return mergedSegments.join('+');
-	}
-
-	const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-	    const ast = parse(template.trim(), options);
-	    optimize(ast, options);
-	    const code = generate(ast, options);
-	    return {
-	        ast,
-	        render: code.render,
-	        staticRenderFns: code.staticRenderFns,
-	    };
-	});
-
-	const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-	exports.compile = compile$1;
-	exports.compileToFunctions = compileToFunctions$1;
-	exports.generateCodeFrame = generateCodeFrame;
-	exports.parseComponent = parseComponent;
-	exports.ssrCompile = compile;
-	exports.ssrCompileToFunctions = compileToFunctions;
-
-	Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
diff --git a/packages/vue-template-compiler/build.js b/packages/vue-template-compiler/build.js
deleted file mode 100644
index d4394d72c73..00000000000
--- a/packages/vue-template-compiler/build.js
+++ /dev/null
@@ -1,4575 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var deindent = require('de-indent');
-var he = require('he');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var deindent__default = /*#__PURE__*/_interopDefaultLegacy(deindent);
-var he__default = /*#__PURE__*/_interopDefaultLegacy(he);
-
-const emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    const n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    const map = Object.create(null);
-    const list = str.split(',');
-    for (let i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val];
-}
-/**
- * Check if a tag is a built-in tag.
- */
-const isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove(arr, item) {
-    if (arr.length) {
-        const index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    const cache = Object.create(null);
-    return function cachedFn(str) {
-        const hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g;
-const camelize = cached((str) => {
-    return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g;
-const hyphenate = cached((str) => {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (const key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-const no = (a, b, c) => false;
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-const identity = (_) => _;
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-    return modules
-        .reduce((keys, m) => {
-        return keys.concat(m.staticKeys || []);
-    }, [])
-        .join(',');
-}
-
-const isUnaryTag = makeMap('area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr');
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-const canBeLeftOpenTag = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source');
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const isNonPhrasingTag = makeMap('address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track');
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`;
-const qnameCapture = `((?:${ncname}\\:)?${ncname})`;
-const startTagOpen = new RegExp(`^<${qnameCapture}`);
-const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp(`^<\\/${qnameCapture}[^>]*>`);
-const doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-const comment = /^<!\--/;
-const conditionalComment = /^<!\[/;
-// Special Elements (can contain anything)
-const isPlainTextElement = makeMap('script,style,textarea', true);
-const reCache = {};
-const decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'",
-};
-const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-// #5992
-const isIgnoreNewlineTag = makeMap('pre,textarea', true);
-const shouldIgnoreFirstNewline = (tag, html) => tag && isIgnoreNewlineTag(tag) && html[0] === '\n';
-function decodeAttr(value, shouldDecodeNewlines) {
-    const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-    return value.replace(re, (match) => decodingMap[match]);
-}
-function parseHTML(html, options) {
-    const stack = [];
-    const expectHTML = options.expectHTML;
-    const isUnaryTag = options.isUnaryTag || no;
-    const canBeLeftOpenTag = options.canBeLeftOpenTag || no;
-    let index = 0;
-    let last, lastTag;
-    while (html) {
-        last = html;
-        // Make sure we're not in a plaintext content element like script/style
-        if (!lastTag || !isPlainTextElement(lastTag)) {
-            let textEnd = html.indexOf('<');
-            if (textEnd === 0) {
-                // Comment:
-                if (comment.test(html)) {
-                    const commentEnd = html.indexOf('-->');
-                    if (commentEnd >= 0) {
-                        if (options.shouldKeepComment) {
-                            options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-                        }
-                        advance(commentEnd + 3);
-                        continue;
-                    }
-                }
-                // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-                if (conditionalComment.test(html)) {
-                    const conditionalEnd = html.indexOf(']>');
-                    if (conditionalEnd >= 0) {
-                        advance(conditionalEnd + 2);
-                        continue;
-                    }
-                }
-                // Doctype:
-                const doctypeMatch = html.match(doctype);
-                if (doctypeMatch) {
-                    advance(doctypeMatch[0].length);
-                    continue;
-                }
-                // End tag:
-                const endTagMatch = html.match(endTag);
-                if (endTagMatch) {
-                    const curIndex = index;
-                    advance(endTagMatch[0].length);
-                    parseEndTag(endTagMatch[1], curIndex, index);
-                    continue;
-                }
-                // Start tag:
-                const startTagMatch = parseStartTag();
-                if (startTagMatch) {
-                    handleStartTag(startTagMatch);
-                    if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-                        advance(1);
-                    }
-                    continue;
-                }
-            }
-            let text, rest, next;
-            if (textEnd >= 0) {
-                rest = html.slice(textEnd);
-                while (!endTag.test(rest) &&
-                    !startTagOpen.test(rest) &&
-                    !comment.test(rest) &&
-                    !conditionalComment.test(rest)) {
-                    // < in plain text, be forgiving and treat it as text
-                    next = rest.indexOf('<', 1);
-                    if (next < 0)
-                        break;
-                    textEnd += next;
-                    rest = html.slice(textEnd);
-                }
-                text = html.substring(0, textEnd);
-            }
-            if (textEnd < 0) {
-                text = html;
-            }
-            if (text) {
-                advance(text.length);
-            }
-            if (options.chars && text) {
-                options.chars(text, index - text.length, index);
-            }
-        }
-        else {
-            let endTagLength = 0;
-            const stackedTag = lastTag.toLowerCase();
-            const reStackedTag = reCache[stackedTag] ||
-                (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-            const rest = html.replace(reStackedTag, function (all, text, endTag) {
-                endTagLength = endTag.length;
-                if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-                    text = text
-                        .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-                        .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-                }
-                if (shouldIgnoreFirstNewline(stackedTag, text)) {
-                    text = text.slice(1);
-                }
-                if (options.chars) {
-                    options.chars(text);
-                }
-                return '';
-            });
-            index += html.length - rest.length;
-            html = rest;
-            parseEndTag(stackedTag, index - endTagLength, index);
-        }
-        if (html === last) {
-            options.chars && options.chars(html);
-            if (process.env.NODE_ENV !== 'production' &&
-                !stack.length &&
-                options.warn) {
-                options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-                    start: index + html.length,
-                });
-            }
-            break;
-        }
-    }
-    // Clean up any remaining tags
-    parseEndTag();
-    function advance(n) {
-        index += n;
-        html = html.substring(n);
-    }
-    function parseStartTag() {
-        const start = html.match(startTagOpen);
-        if (start) {
-            const match = {
-                tagName: start[1],
-                attrs: [],
-                start: index,
-            };
-            advance(start[0].length);
-            let end, attr;
-            while (!(end = html.match(startTagClose)) &&
-                (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-                attr.start = index;
-                advance(attr[0].length);
-                attr.end = index;
-                match.attrs.push(attr);
-            }
-            if (end) {
-                match.unarySlash = end[1];
-                advance(end[0].length);
-                match.end = index;
-                return match;
-            }
-        }
-    }
-    function handleStartTag(match) {
-        const tagName = match.tagName;
-        const unarySlash = match.unarySlash;
-        if (expectHTML) {
-            if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-                parseEndTag(lastTag);
-            }
-            if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-                parseEndTag(tagName);
-            }
-        }
-        const unary = isUnaryTag(tagName) || !!unarySlash;
-        const l = match.attrs.length;
-        const attrs = new Array(l);
-        for (let i = 0; i < l; i++) {
-            const args = match.attrs[i];
-            const value = args[3] || args[4] || args[5] || '';
-            const shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-                ? options.shouldDecodeNewlinesForHref
-                : options.shouldDecodeNewlines;
-            attrs[i] = {
-                name: args[1],
-                value: decodeAttr(value, shouldDecodeNewlines),
-            };
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                attrs[i].start = args.start + args[0].match(/^\s*/).length;
-                attrs[i].end = args.end;
-            }
-        }
-        if (!unary) {
-            stack.push({
-                tag: tagName,
-                lowerCasedTag: tagName.toLowerCase(),
-                attrs: attrs,
-                start: match.start,
-                end: match.end,
-            });
-            lastTag = tagName;
-        }
-        if (options.start) {
-            options.start(tagName, attrs, unary, match.start, match.end);
-        }
-    }
-    function parseEndTag(tagName, start, end) {
-        let pos, lowerCasedTagName;
-        if (start == null)
-            start = index;
-        if (end == null)
-            end = index;
-        // Find the closest opened tag of the same type
-        if (tagName) {
-            lowerCasedTagName = tagName.toLowerCase();
-            for (pos = stack.length - 1; pos >= 0; pos--) {
-                if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-                    break;
-                }
-            }
-        }
-        else {
-            // If no tag name is provided, clean shop
-            pos = 0;
-        }
-        if (pos >= 0) {
-            // Close all the open elements, up the stack
-            for (let i = stack.length - 1; i >= pos; i--) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    (i > pos || !tagName) &&
-                    options.warn) {
-                    options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
-                        start: stack[i].start,
-                        end: stack[i].end,
-                    });
-                }
-                if (options.end) {
-                    options.end(stack[i].tag, start, end);
-                }
-            }
-            // Remove the open elements from the stack
-            stack.length = pos;
-            lastTag = pos && stack[pos - 1].tag;
-        }
-        else if (lowerCasedTagName === 'br') {
-            if (options.start) {
-                options.start(tagName, [], true, start, end);
-            }
-        }
-        else if (lowerCasedTagName === 'p') {
-            if (options.start) {
-                options.start(tagName, [], false, start, end);
-            }
-            if (options.end) {
-                options.end(tagName, start, end);
-            }
-        }
-    }
-}
-
-const splitRE = /\r?\n/g;
-const replaceRE = /./g;
-const isSpecialTag = makeMap('script,style,template', true);
-/**
- * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
- */
-function parseComponent(content, options = {}) {
-    const sfc = {
-        template: null,
-        script: null,
-        styles: [],
-        customBlocks: [],
-        errors: [],
-    };
-    let depth = 0;
-    let currentBlock = null;
-    let warn = (msg) => {
-        sfc.errors.push(msg);
-    };
-    if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        warn = (msg, range) => {
-            const data = { msg };
-            if (range.start != null) {
-                data.start = range.start;
-            }
-            if (range.end != null) {
-                data.end = range.end;
-            }
-            sfc.errors.push(data);
-        };
-    }
-    function start(tag, attrs, unary, start, end) {
-        if (depth === 0) {
-            currentBlock = {
-                type: tag,
-                content: '',
-                start: end,
-                attrs: attrs.reduce((cumulated, { name, value }) => {
-                    cumulated[name] = value || true;
-                    return cumulated;
-                }, {}),
-            };
-            if (isSpecialTag(tag)) {
-                checkAttrs(currentBlock, attrs);
-                if (tag === 'style') {
-                    sfc.styles.push(currentBlock);
-                }
-                else {
-                    sfc[tag] = currentBlock;
-                }
-            }
-            else {
-                // custom blocks
-                sfc.customBlocks.push(currentBlock);
-            }
-        }
-        if (!unary) {
-            depth++;
-        }
-    }
-    function checkAttrs(block, attrs) {
-        for (let i = 0; i < attrs.length; i++) {
-            const attr = attrs[i];
-            if (attr.name === 'lang') {
-                block.lang = attr.value;
-            }
-            if (attr.name === 'scoped') {
-                block.scoped = true;
-            }
-            if (attr.name === 'module') {
-                block.module = attr.value || true;
-            }
-            if (attr.name === 'src') {
-                block.src = attr.value;
-            }
-        }
-    }
-    function end(tag, start) {
-        if (depth === 1 && currentBlock) {
-            currentBlock.end = start;
-            let text = content.slice(currentBlock.start, currentBlock.end);
-            if (options.deindent !== false) {
-                text = deindent__default["default"](text);
-            }
-            // pad content so that linters and pre-processors can output correct
-            // line numbers in errors and warnings
-            if (currentBlock.type !== 'template' && options.pad) {
-                text = padContent(currentBlock, options.pad) + text;
-            }
-            currentBlock.content = text;
-            currentBlock = null;
-        }
-        depth--;
-    }
-    function padContent(block, pad) {
-        if (pad === 'space') {
-            return content.slice(0, block.start).replace(replaceRE, ' ');
-        }
-        else {
-            const offset = content.slice(0, block.start).split(splitRE).length;
-            const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n';
-            return Array(offset).join(padChar);
-        }
-    }
-    parseHTML(content, {
-        warn,
-        start,
-        end,
-        outputSourceRange: options.outputSourceRange,
-    });
-    return sfc;
-}
-
-// can we use __proto__?
-const hasProto = '__proto__' in {};
-// Browser environment sniffing
-const inBrowser = typeof window !== 'undefined';
-const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-const UA = inBrowser && window.navigator.userAgent.toLowerCase();
-const isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-const isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-(UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-const nativeWatch = {}.watch;
-let supportsPassive = false;
-if (inBrowser) {
-    try {
-        const opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get() {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-let _isServer;
-const isServerRendering = () => {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-const hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) ;
-
-const ASSET_TYPES = ['component', 'directive', 'filter'];
-const LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch',
-];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-let warn$2 = noop;
-let tip = noop;
-let generateComponentTrace; // work around flow check
-let formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    const hasConsole = typeof console !== 'undefined';
-    const classifyRE = /(?:^|[-_])(\w)/g;
-    const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '');
-    warn$2 = (msg, vm) => {
-        const trace = vm ? generateComponentTrace(vm) : '';
-        if (hasConsole && !config.silent) {
-            console.error(`[Vue warn]: ${msg}${trace}`);
-        }
-    };
-    tip = (msg, vm) => {
-        if (hasConsole && !config.silent) {
-            console.warn(`[Vue tip]: ${msg}` + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = (vm, includeFile) => {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        const options = typeof vm === 'function' && vm.cid != null
-            ? vm.options
-            : vm._isVue
-                ? vm.$options || vm.constructor.options
-                : vm;
-        let name = options.name || options._componentTag;
-        const file = options.__file;
-        if (!name && file) {
-            const match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? `<${classify(name)}>` : `<Anonymous>`) +
-            (file && includeFile !== false ? ` at ${file}` : ''));
-    };
-    const repeat = (str, n) => {
-        let res = '';
-        while (n) {
-            if (n % 2 === 1)
-                res += str;
-            if (n > 1)
-                str += str;
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = (vm) => {
-        if (vm._isVue && vm.$parent) {
-            const tree = [];
-            let currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    const last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map((vm, i) => `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${Array.isArray(vm)
-                    ? `${formatComponentName(vm[0])}... (${vm[1]} recursive calls)`
-                    : formatComponentName(vm)}`)
-                    .join('\n'));
-        }
-        else {
-            return `\n\n(found in ${formatComponentName(vm)})`;
-        }
-    };
-}
-
-let uid = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-class Dep {
-    static target;
-    id;
-    subs;
-    constructor() {
-        this.id = uid++;
-        this.subs = [];
-    }
-    addSub(sub) {
-        this.subs.push(sub);
-    }
-    removeSub(sub) {
-        remove(this.subs, sub);
-    }
-    depend() {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    }
-    notify() {
-        // stabilize the subscriber list first
-        const subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort((a, b) => a.id - b.id);
-        }
-        for (let i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    }
-}
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-
-class VNode {
-    tag;
-    data;
-    children;
-    text;
-    elm;
-    ns;
-    context; // rendered in this component's scope
-    key;
-    componentOptions;
-    componentInstance; // component instance
-    parent; // component placeholder node
-    // strictly internal
-    raw; // contains raw HTML? (server only)
-    isStatic; // hoisted static node
-    isRootInsert; // necessary for enter transition check
-    isComment; // empty comment placeholder?
-    isCloned; // is a cloned node?
-    isOnce; // is a v-once node?
-    asyncFactory; // async component factory function
-    asyncMeta;
-    isAsyncPlaceholder;
-    ssrContext;
-    fnContext; // real context vm for functional nodes
-    fnOptions; // for SSR caching
-    devtoolsMeta; // used to store functional render context for devtools
-    fnScopeId; // functional scope id support
-    constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get child() {
-        return this.componentInstance;
-    }
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-const arrayProto = Array.prototype;
-const arrayMethods = Object.create(arrayProto);
-const methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse',
-];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    const original = arrayProto[method];
-    def(arrayMethods, method, function mutator(...args) {
-        const result = original.apply(this, args);
-        const ob = this.__ob__;
-        let inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            ob.observeArray(inserted);
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-const arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-class Observer {
-    value;
-    dep;
-    vmCount; // number of vms that have this object as root $data
-    constructor(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    walk(obj) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    }
-}
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (let i = 0, l = keys.length; i < l; i++) {
-        const key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    let ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (!isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    const dep = new Dep();
-    const property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    const getter = property && property.get;
-    const setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    let childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            const value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            const value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                return;
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    const ob = target.__ob__;
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (let e, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-const strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn$2(`option "${key}" can only be used during instance ` +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        return to;
-    let key, toVal, fromVal;
-    const keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (let i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            continue;
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(typeof childVal === 'function' ? childVal.call(this, this) : childVal, typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            const instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            const defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn$2('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook(parentVal, childVal) {
-    const res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    const res = [];
-    for (let i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach((hook) => {
-    strats[hook] = mergeHook;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    const res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        parentVal = undefined;
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        childVal = undefined;
-    /* istanbul ignore if */
-    if (!childVal)
-        return Object.create(parentVal || null);
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = {};
-    extend(ret, parentVal);
-    for (const key in childVal) {
-        let parent = ret[key];
-        const child = childVal[key];
-        if (parent && !Array.isArray(parent)) {
-            parent = [parent];
-        }
-        ret[key] = parent
-            ? parent.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        return childVal;
-    const ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        extend(ret, childVal);
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-const defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn$2(`Invalid value for option "${name}": expected an Object, ` +
-            `but got ${toRawType(value)}.`, vm);
-    }
-}
-
-/* globals MutationObserver */
-const callbacks = [];
-function flushCallbacks() {
-    const copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (let i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve();
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    let counter = 1;
-    const observer = new MutationObserver(flushCallbacks);
-    const textNode = document.createTextNode(String(counter));
-    observer.observe(textNode, {
-        characterData: true,
-    });
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-else ;
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class');
-// attributes that should be using props for binding
-const acceptValue = makeMap('input,textarea,option,select,progress');
-const mustUseProp = (tag, type, attr) => {
-    return ((attr === 'value' && acceptValue(tag) && type !== 'button') ||
-        (attr === 'selected' && tag === 'option') ||
-        (attr === 'checked' && tag === 'input') ||
-        (attr === 'muted' && tag === 'video'));
-};
-const isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
-makeMap('events,caret,typing,plaintext-only');
-const isBooleanAttr = makeMap('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible');
-
-const isHTMLTag = makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-const isSVG = makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-const isPreTag = (tag) => tag === 'pre';
-const isReservedTag = (tag) => {
-    return isHTMLTag(tag) || isSVG(tag);
-};
-function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-        return 'svg';
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-        return 'math';
-    }
-}
-makeMap('text,number,password,search,email,tel,url');
-
-const validDivisionCharRE = /[\w).+\-_$\]]/;
-function parseFilters(exp) {
-    let inSingle = false;
-    let inDouble = false;
-    let inTemplateString = false;
-    let inRegex = false;
-    let curly = 0;
-    let square = 0;
-    let paren = 0;
-    let lastFilterIndex = 0;
-    let c, prev, i, expression, filters;
-    for (i = 0; i < exp.length; i++) {
-        prev = c;
-        c = exp.charCodeAt(i);
-        if (inSingle) {
-            if (c === 0x27 && prev !== 0x5c)
-                inSingle = false;
-        }
-        else if (inDouble) {
-            if (c === 0x22 && prev !== 0x5c)
-                inDouble = false;
-        }
-        else if (inTemplateString) {
-            if (c === 0x60 && prev !== 0x5c)
-                inTemplateString = false;
-        }
-        else if (inRegex) {
-            if (c === 0x2f && prev !== 0x5c)
-                inRegex = false;
-        }
-        else if (c === 0x7c && // pipe
-            exp.charCodeAt(i + 1) !== 0x7c &&
-            exp.charCodeAt(i - 1) !== 0x7c &&
-            !curly &&
-            !square &&
-            !paren) {
-            if (expression === undefined) {
-                // first filter, end of expression
-                lastFilterIndex = i + 1;
-                expression = exp.slice(0, i).trim();
-            }
-            else {
-                pushFilter();
-            }
-        }
-        else {
-            switch (c) {
-                case 0x22:
-                    inDouble = true;
-                    break; // "
-                case 0x27:
-                    inSingle = true;
-                    break; // '
-                case 0x60:
-                    inTemplateString = true;
-                    break; // `
-                case 0x28:
-                    paren++;
-                    break; // (
-                case 0x29:
-                    paren--;
-                    break; // )
-                case 0x5b:
-                    square++;
-                    break; // [
-                case 0x5d:
-                    square--;
-                    break; // ]
-                case 0x7b:
-                    curly++;
-                    break; // {
-                case 0x7d:
-                    curly--;
-                    break; // }
-            }
-            if (c === 0x2f) {
-                // /
-                let j = i - 1;
-                let p;
-                // find first non-whitespace prev char
-                for (; j >= 0; j--) {
-                    p = exp.charAt(j);
-                    if (p !== ' ')
-                        break;
-                }
-                if (!p || !validDivisionCharRE.test(p)) {
-                    inRegex = true;
-                }
-            }
-        }
-    }
-    if (expression === undefined) {
-        expression = exp.slice(0, i).trim();
-    }
-    else if (lastFilterIndex !== 0) {
-        pushFilter();
-    }
-    function pushFilter() {
-        (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-        lastFilterIndex = i + 1;
-    }
-    if (filters) {
-        for (i = 0; i < filters.length; i++) {
-            expression = wrapFilter(expression, filters[i]);
-        }
-    }
-    return expression;
-}
-function wrapFilter(exp, filter) {
-    const i = filter.indexOf('(');
-    if (i < 0) {
-        // _f: resolveFilter
-        return `_f("${filter}")(${exp})`;
-    }
-    else {
-        const name = filter.slice(0, i);
-        const args = filter.slice(i + 1);
-        return `_f("${name}")(${exp}${args !== ')' ? ',' + args : args}`;
-    }
-}
-
-const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-const buildRegex = cached((delimiters) => {
-    const open = delimiters[0].replace(regexEscapeRE, '\\$&');
-    const close = delimiters[1].replace(regexEscapeRE, '\\$&');
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g');
-});
-function parseText(text, delimiters) {
-    //@ts-expect-error
-    const tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-    if (!tagRE.test(text)) {
-        return;
-    }
-    const tokens = [];
-    const rawTokens = [];
-    let lastIndex = (tagRE.lastIndex = 0);
-    let match, index, tokenValue;
-    while ((match = tagRE.exec(text))) {
-        index = match.index;
-        // push text token
-        if (index > lastIndex) {
-            rawTokens.push((tokenValue = text.slice(lastIndex, index)));
-            tokens.push(JSON.stringify(tokenValue));
-        }
-        // tag token
-        const exp = parseFilters(match[1].trim());
-        tokens.push(`_s(${exp})`);
-        rawTokens.push({ '@binding': exp });
-        lastIndex = index + match[0].length;
-    }
-    if (lastIndex < text.length) {
-        rawTokens.push((tokenValue = text.slice(lastIndex)));
-        tokens.push(JSON.stringify(tokenValue));
-    }
-    return {
-        expression: tokens.join('+'),
-        tokens: rawTokens,
-    };
-}
-
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-    console.error(`[Vue compiler]: ${msg}`);
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-    return modules ? modules.map((m) => m[key]).filter((_) => _) : [];
-}
-function addProp(el, name, value, range, dynamic) {
-    (el.props || (el.props = [])).push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-function addAttr(el, name, value, range, dynamic) {
-    const attrs = dynamic
-        ? el.dynamicAttrs || (el.dynamicAttrs = [])
-        : el.attrs || (el.attrs = []);
-    attrs.push(rangeSetItem({ name, value, dynamic }, range));
-    el.plain = false;
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value;
-    el.attrsList.push(rangeSetItem({ name, value }, range));
-}
-function addDirective(el, name, rawName, value, arg, isDynamicArg, modifiers, range) {
-    (el.directives || (el.directives = [])).push(rangeSetItem({
-        name,
-        rawName,
-        value,
-        arg,
-        isDynamicArg,
-        modifiers,
-    }, range));
-    el.plain = false;
-}
-function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic ? `_p(${name},"${symbol}")` : symbol + name; // mark the event as captured
-}
-function addHandler(el, name, value, modifiers, important, warn, range, dynamic) {
-    modifiers = modifiers || emptyObject;
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' &&
-        warn &&
-        modifiers.prevent &&
-        modifiers.passive) {
-        warn("passive and prevent can't be used together. " +
-            "Passive handler can't prevent default event.", range);
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-        if (dynamic) {
-            name = `(${name})==='click'?'contextmenu':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'contextmenu';
-            delete modifiers.right;
-        }
-    }
-    else if (modifiers.middle) {
-        if (dynamic) {
-            name = `(${name})==='click'?'mouseup':(${name})`;
-        }
-        else if (name === 'click') {
-            name = 'mouseup';
-        }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-        delete modifiers.capture;
-        name = prependModifierMarker('!', name, dynamic);
-    }
-    if (modifiers.once) {
-        delete modifiers.once;
-        name = prependModifierMarker('~', name, dynamic);
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-        delete modifiers.passive;
-        name = prependModifierMarker('&', name, dynamic);
-    }
-    let events;
-    if (modifiers.native) {
-        delete modifiers.native;
-        events = el.nativeEvents || (el.nativeEvents = {});
-    }
-    else {
-        events = el.events || (el.events = {});
-    }
-    const newHandler = rangeSetItem({ value: value.trim(), dynamic }, range);
-    if (modifiers !== emptyObject) {
-        newHandler.modifiers = modifiers;
-    }
-    const handlers = events[name];
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-        important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-    }
-    else if (handlers) {
-        events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-    }
-    else {
-        events[name] = newHandler;
-    }
-    el.plain = false;
-}
-function getRawBindingAttr(el, name) {
-    return (el.rawAttrsMap[':' + name] ||
-        el.rawAttrsMap['v-bind:' + name] ||
-        el.rawAttrsMap[name]);
-}
-function getBindingAttr(el, name, getStatic) {
-    const dynamicValue = getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name);
-    if (dynamicValue != null) {
-        return parseFilters(dynamicValue);
-    }
-    else if (getStatic !== false) {
-        const staticValue = getAndRemoveAttr(el, name);
-        if (staticValue != null) {
-            return JSON.stringify(staticValue);
-        }
-    }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-    let val;
-    if ((val = el.attrsMap[name]) != null) {
-        const list = el.attrsList;
-        for (let i = 0, l = list.length; i < l; i++) {
-            if (list[i].name === name) {
-                list.splice(i, 1);
-                break;
-            }
-        }
-    }
-    if (removeFromMap) {
-        delete el.attrsMap[name];
-    }
-    return val;
-}
-function getAndRemoveAttrByRegex(el, name) {
-    const list = el.attrsList;
-    for (let i = 0, l = list.length; i < l; i++) {
-        const attr = list[i];
-        if (name.test(attr.name)) {
-            list.splice(i, 1);
-            return attr;
-        }
-    }
-}
-function rangeSetItem(item, range) {
-    if (range) {
-        if (range.start != null) {
-            item.start = range.start;
-        }
-        if (range.end != null) {
-            item.end = range.end;
-        }
-    }
-    return item;
-}
-
-function transformNode$1(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticClass = getAndRemoveAttr(el, 'class');
-    if (process.env.NODE_ENV !== 'production' && staticClass) {
-        const res = parseText(staticClass, options.delimiters);
-        if (res) {
-            warn(`class="${staticClass}": ` +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div class="{{ val }}">, use <div :class="val">.', el.rawAttrsMap['class']);
-        }
-    }
-    if (staticClass) {
-        el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim());
-    }
-    const classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-        el.classBinding = classBinding;
-    }
-}
-function genData$2(el) {
-    let data = '';
-    if (el.staticClass) {
-        data += `staticClass:${el.staticClass},`;
-    }
-    if (el.classBinding) {
-        data += `class:${el.classBinding},`;
-    }
-    return data;
-}
-var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2,
-};
-
-const parseStyleText = cached(function (cssText) {
-    const res = {};
-    const listDelimiter = /;(?![^(]*\))/g;
-    const propertyDelimiter = /:(.+)/;
-    cssText.split(listDelimiter).forEach(function (item) {
-        if (item) {
-            const tmp = item.split(propertyDelimiter);
-            tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());
-        }
-    });
-    return res;
-});
-
-function transformNode(el, options) {
-    const warn = options.warn || baseWarn;
-    const staticStyle = getAndRemoveAttr(el, 'style');
-    if (staticStyle) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            const res = parseText(staticStyle, options.delimiters);
-            if (res) {
-                warn(`style="${staticStyle}": ` +
-                    'Interpolation inside attributes has been removed. ' +
-                    'Use v-bind or the colon shorthand instead. For example, ' +
-                    'instead of <div style="{{ val }}">, use <div :style="val">.', el.rawAttrsMap['style']);
-            }
-        }
-        el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
-    }
-    const styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-        el.styleBinding = styleBinding;
-    }
-}
-function genData$1(el) {
-    let data = '';
-    if (el.staticStyle) {
-        data += `staticStyle:${el.staticStyle},`;
-    }
-    if (el.styleBinding) {
-        data += `style:(${el.styleBinding}),`;
-    }
-    return data;
-}
-var style = {
-    staticKeys: ['staticStyle'],
-    transformNode,
-    genData: genData$1,
-};
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-    const { number, trim } = modifiers || {};
-    const baseValueExpression = '$$v';
-    let valueExpression = baseValueExpression;
-    if (trim) {
-        valueExpression =
-            `(typeof ${baseValueExpression} === 'string'` +
-                `? ${baseValueExpression}.trim()` +
-                `: ${baseValueExpression})`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    const assignment = genAssignmentCode(value, valueExpression);
-    el.model = {
-        value: `(${value})`,
-        expression: JSON.stringify(value),
-        callback: `function (${baseValueExpression}) {${assignment}}`,
-    };
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-    const res = parseModel(value);
-    if (res.key === null) {
-        return `${value}=${assignment}`;
-    }
-    else {
-        return `$set(${res.exp}, ${res.key}, ${assignment})`;
-    }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-let len, str, chr, index, expressionPos, expressionEndPos;
-function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim();
-    len = val.length;
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-        index = val.lastIndexOf('.');
-        if (index > -1) {
-            return {
-                exp: val.slice(0, index),
-                key: '"' + val.slice(index + 1) + '"',
-            };
-        }
-        else {
-            return {
-                exp: val,
-                key: null,
-            };
-        }
-    }
-    str = val;
-    index = expressionPos = expressionEndPos = 0;
-    while (!eof()) {
-        chr = next();
-        /* istanbul ignore if */
-        if (isStringStart(chr)) {
-            parseString(chr);
-        }
-        else if (chr === 0x5b) {
-            parseBracket(chr);
-        }
-    }
-    return {
-        exp: val.slice(0, expressionPos),
-        key: val.slice(expressionPos + 1, expressionEndPos),
-    };
-}
-function next() {
-    return str.charCodeAt(++index);
-}
-function eof() {
-    return index >= len;
-}
-function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27;
-}
-function parseBracket(chr) {
-    let inBracket = 1;
-    expressionPos = index;
-    while (!eof()) {
-        chr = next();
-        if (isStringStart(chr)) {
-            parseString(chr);
-            continue;
-        }
-        if (chr === 0x5b)
-            inBracket++;
-        if (chr === 0x5d)
-            inBracket--;
-        if (inBracket === 0) {
-            expressionEndPos = index;
-            break;
-        }
-    }
-}
-function parseString(chr) {
-    const stringQuote = chr;
-    while (!eof()) {
-        chr = next();
-        if (chr === stringQuote) {
-            break;
-        }
-    }
-}
-
-const onRE = /^@|^v-on:/;
-const dirRE = /^v-|^@|^:|^#/;
-const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-const stripParensRE = /^\(|\)$/g;
-const dynamicArgRE = /^\[.*\]$/;
-const argRE = /:(.*)$/;
-const bindRE = /^:|^\.|^v-bind:/;
-const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-const slotRE = /^v-slot(:|$)|^#/;
-const lineBreakRE = /[\r\n]/;
-const whitespaceRE = /[ \f\t\r\n]+/g;
-const invalidAttributeRE = /[\s"'<>\/=]/;
-const decodeHTMLCached = cached(he__default["default"].decode);
-const emptySlotScopeToken = `_empty_`;
-// configurable state
-let warn$1;
-let delimiters;
-let transforms;
-let preTransforms;
-let postTransforms;
-let platformIsPreTag;
-let platformMustUseProp;
-let platformGetTagNamespace;
-let maybeComponent;
-function createASTElement(tag, attrs, parent) {
-    return {
-        type: 1,
-        tag,
-        attrsList: attrs,
-        attrsMap: makeAttrsMap(attrs),
-        rawAttrsMap: {},
-        parent,
-        children: [],
-    };
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-    warn$1 = options.warn || baseWarn;
-    platformIsPreTag = options.isPreTag || no;
-    platformMustUseProp = options.mustUseProp || no;
-    platformGetTagNamespace = options.getTagNamespace || no;
-    const isReservedTag = options.isReservedTag || no;
-    maybeComponent = (el) => !!(el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag)));
-    transforms = pluckModuleFunction(options.modules, 'transformNode');
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-    delimiters = options.delimiters;
-    const stack = [];
-    const preserveWhitespace = options.preserveWhitespace !== false;
-    const whitespaceOption = options.whitespace;
-    let root;
-    let currentParent;
-    let inVPre = false;
-    let inPre = false;
-    let warned = false;
-    function warnOnce(msg, range) {
-        if (!warned) {
-            warned = true;
-            warn$1(msg, range);
-        }
-    }
-    function closeElement(element) {
-        trimEndingWhitespace(element);
-        if (!inVPre && !element.processed) {
-            element = processElement(element, options);
-        }
-        // tree management
-        if (!stack.length && element !== root) {
-            // allow root elements with v-if, v-else-if and v-else
-            if (root.if && (element.elseif || element.else)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(element);
-                }
-                addIfCondition(root, {
-                    exp: element.elseif,
-                    block: element,
-                });
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warnOnce(`Component template should contain exactly one root element. ` +
-                    `If you are using v-if on multiple elements, ` +
-                    `use v-else-if to chain them instead.`, { start: element.start });
-            }
-        }
-        if (currentParent && !element.forbidden) {
-            if (element.elseif || element.else) {
-                processIfConditions(element, currentParent);
-            }
-            else {
-                if (element.slotScope) {
-                    // scoped slot
-                    // keep it in the children list so that v-else(-if) conditions can
-                    // find it as the prev node.
-                    const name = element.slotTarget || '"default"';
-                    (currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-                }
-                currentParent.children.push(element);
-                element.parent = currentParent;
-            }
-        }
-        // final children cleanup
-        // filter out scoped slots
-        element.children = element.children.filter((c) => !c.slotScope);
-        // remove trailing whitespace node again
-        trimEndingWhitespace(element);
-        // check pre state
-        if (element.pre) {
-            inVPre = false;
-        }
-        if (platformIsPreTag(element.tag)) {
-            inPre = false;
-        }
-        // apply post-transforms
-        for (let i = 0; i < postTransforms.length; i++) {
-            postTransforms[i](element, options);
-        }
-    }
-    function trimEndingWhitespace(el) {
-        // remove trailing whitespace node
-        if (!inPre) {
-            let lastNode;
-            while ((lastNode = el.children[el.children.length - 1]) &&
-                lastNode.type === 3 &&
-                lastNode.text === ' ') {
-                el.children.pop();
-            }
-        }
-    }
-    function checkRootConstraints(el) {
-        if (el.tag === 'slot' || el.tag === 'template') {
-            warnOnce(`Cannot use <${el.tag}> as component root element because it may ` +
-                'contain multiple nodes.', { start: el.start });
-        }
-        if (el.attrsMap.hasOwnProperty('v-for')) {
-            warnOnce('Cannot use v-for on stateful component root element because ' +
-                'it renders multiple elements.', el.rawAttrsMap['v-for']);
-        }
-    }
-    parseHTML(template, {
-        warn: warn$1,
-        expectHTML: options.expectHTML,
-        isUnaryTag: options.isUnaryTag,
-        canBeLeftOpenTag: options.canBeLeftOpenTag,
-        shouldDecodeNewlines: options.shouldDecodeNewlines,
-        shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-        shouldKeepComment: options.comments,
-        outputSourceRange: options.outputSourceRange,
-        start(tag, attrs, unary, start, end) {
-            // check namespace.
-            // inherit parent ns if there is one
-            const ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-            // handle IE svg bug
-            /* istanbul ignore if */
-            if (isIE && ns === 'svg') {
-                attrs = guardIESVGBug(attrs);
-            }
-            let element = createASTElement(tag, attrs, currentParent);
-            if (ns) {
-                element.ns = ns;
-            }
-            if (process.env.NODE_ENV !== 'production') {
-                if (options.outputSourceRange) {
-                    element.start = start;
-                    element.end = end;
-                    element.rawAttrsMap = element.attrsList.reduce((cumulated, attr) => {
-                        cumulated[attr.name] = attr;
-                        return cumulated;
-                    }, {});
-                }
-                attrs.forEach((attr) => {
-                    if (invalidAttributeRE.test(attr.name)) {
-                        warn$1(`Invalid dynamic argument expression: attribute names cannot contain ` +
-                            `spaces, quotes, <, >, / or =.`, {
-                            start: attr.start + attr.name.indexOf(`[`),
-                            end: attr.start + attr.name.length,
-                        });
-                    }
-                });
-            }
-            if (isForbiddenTag(element) && !isServerRendering()) {
-                element.forbidden = true;
-                process.env.NODE_ENV !== 'production' &&
-                    warn$1('Templates should only be responsible for mapping the state to the ' +
-                        'UI. Avoid placing tags with side-effects in your templates, such as ' +
-                        `<${tag}>` +
-                        ', as they will not be parsed.', { start: element.start });
-            }
-            // apply pre-transforms
-            for (let i = 0; i < preTransforms.length; i++) {
-                element = preTransforms[i](element, options) || element;
-            }
-            if (!inVPre) {
-                processPre(element);
-                if (element.pre) {
-                    inVPre = true;
-                }
-            }
-            if (platformIsPreTag(element.tag)) {
-                inPre = true;
-            }
-            if (inVPre) {
-                processRawAttrs(element);
-            }
-            else if (!element.processed) {
-                // structural directives
-                processFor(element);
-                processIf(element);
-                processOnce(element);
-            }
-            if (!root) {
-                root = element;
-                if (process.env.NODE_ENV !== 'production') {
-                    checkRootConstraints(root);
-                }
-            }
-            if (!unary) {
-                currentParent = element;
-                stack.push(element);
-            }
-            else {
-                closeElement(element);
-            }
-        },
-        end(tag, start, end) {
-            const element = stack[stack.length - 1];
-            // pop stack
-            stack.length -= 1;
-            currentParent = stack[stack.length - 1];
-            if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-                element.end = end;
-            }
-            closeElement(element);
-        },
-        chars(text, start, end) {
-            if (!currentParent) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (text === template) {
-                        warnOnce('Component template requires a root element, rather than just text.', { start });
-                    }
-                    else if ((text = text.trim())) {
-                        warnOnce(`text "${text}" outside root element will be ignored.`, {
-                            start,
-                        });
-                    }
-                }
-                return;
-            }
-            // IE textarea placeholder bug
-            /* istanbul ignore if */
-            if (isIE &&
-                currentParent.tag === 'textarea' &&
-                currentParent.attrsMap.placeholder === text) {
-                return;
-            }
-            const children = currentParent.children;
-            if (inPre || text.trim()) {
-                text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-            }
-            else if (!children.length) {
-                // remove the whitespace-only node right after an opening tag
-                text = '';
-            }
-            else if (whitespaceOption) {
-                if (whitespaceOption === 'condense') {
-                    // in condense mode, remove the whitespace node if it contains
-                    // line break, otherwise condense to a single space
-                    text = lineBreakRE.test(text) ? '' : ' ';
-                }
-                else {
-                    text = ' ';
-                }
-            }
-            else {
-                text = preserveWhitespace ? ' ' : '';
-            }
-            if (text) {
-                if (!inPre && whitespaceOption === 'condense') {
-                    // condense consecutive whitespaces into single space
-                    text = text.replace(whitespaceRE, ' ');
-                }
-                let res;
-                let child;
-                if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-                    child = {
-                        type: 2,
-                        expression: res.expression,
-                        tokens: res.tokens,
-                        text,
-                    };
-                }
-                else if (text !== ' ' ||
-                    !children.length ||
-                    children[children.length - 1].text !== ' ') {
-                    child = {
-                        type: 3,
-                        text,
-                    };
-                }
-                if (child) {
-                    if (process.env.NODE_ENV !== 'production' &&
-                        options.outputSourceRange) {
-                        child.start = start;
-                        child.end = end;
-                    }
-                    children.push(child);
-                }
-            }
-        },
-        comment(text, start, end) {
-            // adding anything as a sibling to the root node is forbidden
-            // comments should still be allowed, but ignored
-            if (currentParent) {
-                const child = {
-                    type: 3,
-                    text,
-                    isComment: true,
-                };
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    child.start = start;
-                    child.end = end;
-                }
-                currentParent.children.push(child);
-            }
-        },
-    });
-    return root;
-}
-function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-        el.pre = true;
-    }
-}
-function processRawAttrs(el) {
-    const list = el.attrsList;
-    const len = list.length;
-    if (len) {
-        const attrs = (el.attrs = new Array(len));
-        for (let i = 0; i < len; i++) {
-            attrs[i] = {
-                name: list[i].name,
-                value: JSON.stringify(list[i].value),
-            };
-            if (list[i].start != null) {
-                attrs[i].start = list[i].start;
-                attrs[i].end = list[i].end;
-            }
-        }
-    }
-    else if (!el.pre) {
-        // non root node in pre blocks with no attributes
-        el.plain = true;
-    }
-}
-function processElement(element, options) {
-    processKey(element);
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-        !element.key && !element.scopedSlots && !element.attrsList.length;
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (let i = 0; i < transforms.length; i++) {
-        element = transforms[i](element, options) || element;
-    }
-    processAttrs(element);
-    return element;
-}
-function processKey(el) {
-    const exp = getBindingAttr(el, 'key');
-    if (exp) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (el.tag === 'template') {
-                warn$1(`<template> cannot be keyed. Place the key on real elements instead.`, getRawBindingAttr(el, 'key'));
-            }
-            if (el.for) {
-                const iterator = el.iterator2 || el.iterator1;
-                const parent = el.parent;
-                if (iterator &&
-                    iterator === exp &&
-                    parent &&
-                    parent.tag === 'transition-group') {
-                    warn$1(`Do not use v-for index as key on <transition-group> children, ` +
-                        `this is the same as not using keys.`, getRawBindingAttr(el, 'key'), true /* tip */);
-                }
-            }
-        }
-        el.key = exp;
-    }
-}
-function processRef(el) {
-    const ref = getBindingAttr(el, 'ref');
-    if (ref) {
-        el.ref = ref;
-        el.refInFor = checkInFor(el);
-    }
-}
-function processFor(el) {
-    let exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-        const res = parseFor(exp);
-        if (res) {
-            extend(el, res);
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn$1(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for']);
-        }
-    }
-}
-function parseFor(exp) {
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
-        return;
-    const res = {};
-    res.for = inMatch[2].trim();
-    const alias = inMatch[1].trim().replace(stripParensRE, '');
-    const iteratorMatch = alias.match(forIteratorRE);
-    if (iteratorMatch) {
-        res.alias = alias.replace(forIteratorRE, '').trim();
-        res.iterator1 = iteratorMatch[1].trim();
-        if (iteratorMatch[2]) {
-            res.iterator2 = iteratorMatch[2].trim();
-        }
-    }
-    else {
-        res.alias = alias;
-    }
-    return res;
-}
-function processIf(el) {
-    const exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-        el.if = exp;
-        addIfCondition(el, {
-            exp: exp,
-            block: el,
-        });
-    }
-    else {
-        if (getAndRemoveAttr(el, 'v-else') != null) {
-            el.else = true;
-        }
-        const elseif = getAndRemoveAttr(el, 'v-else-if');
-        if (elseif) {
-            el.elseif = elseif;
-        }
-    }
-}
-function processIfConditions(el, parent) {
-    const prev = findPrevElement(parent.children);
-    if (prev && prev.if) {
-        addIfCondition(prev, {
-            exp: el.elseif,
-            block: el,
-        });
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn$1(`v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
-            `used on element <${el.tag}> without corresponding v-if.`, el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']);
-    }
-}
-function findPrevElement(children) {
-    let i = children.length;
-    while (i--) {
-        if (children[i].type === 1) {
-            return children[i];
-        }
-        else {
-            if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-                warn$1(`text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
-                    `will be ignored.`, children[i]);
-            }
-            children.pop();
-        }
-    }
-}
-function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-        el.ifConditions = [];
-    }
-    el.ifConditions.push(condition);
-}
-function processOnce(el) {
-    const once = getAndRemoveAttr(el, 'v-once');
-    if (once != null) {
-        el.once = true;
-    }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-    let slotScope;
-    if (el.tag === 'template') {
-        slotScope = getAndRemoveAttr(el, 'scope');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && slotScope) {
-            warn$1(`the "scope" attribute for scoped slots have been deprecated and ` +
-                `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
-                `can also be used on plain elements in addition to <template> to ` +
-                `denote scoped slots.`, el.rawAttrsMap['scope'], true);
-        }
-        el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-    }
-    else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-            warn$1(`Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
-                `(v-for takes higher priority). Use a wrapper <template> for the ` +
-                `scoped slot to make it clearer.`, el.rawAttrsMap['slot-scope'], true);
-        }
-        el.slotScope = slotScope;
-    }
-    // slot="xxx"
-    const slotTarget = getBindingAttr(el, 'slot');
-    if (slotTarget) {
-        el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-        el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-        // preserve slot as an attribute for native shadow DOM compat
-        // only for non-scoped slots.
-        if (el.tag !== 'template' && !el.slotScope) {
-            addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-        }
-    }
-    // 2.6 v-slot syntax
-    {
-        if (el.tag === 'template') {
-            // v-slot on <template>
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (el.slotTarget || el.slotScope) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.parent && !maybeComponent(el.parent)) {
-                        warn$1(`<template v-slot> can only appear at the root level inside ` +
-                            `the receiving component`, el);
-                    }
-                }
-                const { name, dynamic } = getSlotName(slotBinding);
-                el.slotTarget = name;
-                el.slotTargetDynamic = dynamic;
-                el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-            }
-        }
-        else {
-            // v-slot on component, denotes default slot
-            const slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-            if (slotBinding) {
-                if (process.env.NODE_ENV !== 'production') {
-                    if (!maybeComponent(el)) {
-                        warn$1(`v-slot can only be used on components or <template>.`, slotBinding);
-                    }
-                    if (el.slotScope || el.slotTarget) {
-                        warn$1(`Unexpected mixed usage of different slot syntaxes.`, el);
-                    }
-                    if (el.scopedSlots) {
-                        warn$1(`To avoid scope ambiguity, the default slot should also use ` +
-                            `<template> syntax when there are other named slots.`, slotBinding);
-                    }
-                }
-                // add the component's children to its default slot
-                const slots = el.scopedSlots || (el.scopedSlots = {});
-                const { name, dynamic } = getSlotName(slotBinding);
-                const slotContainer = (slots[name] = createASTElement('template', [], el));
-                slotContainer.slotTarget = name;
-                slotContainer.slotTargetDynamic = dynamic;
-                slotContainer.children = el.children.filter((c) => {
-                    if (!c.slotScope) {
-                        c.parent = slotContainer;
-                        return true;
-                    }
-                });
-                slotContainer.slotScope = slotBinding.value || emptySlotScopeToken;
-                // remove children as they are returned from scopedSlots now
-                el.children = [];
-                // mark el non-plain so data gets generated
-                el.plain = false;
-            }
-        }
-    }
-}
-function getSlotName(binding) {
-    let name = binding.name.replace(slotRE, '');
-    if (!name) {
-        if (binding.name[0] !== '#') {
-            name = 'default';
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            warn$1(`v-slot shorthand syntax requires a slot name.`, binding);
-        }
-    }
-    return dynamicArgRE.test(name)
-        ? // dynamic [name]
-            { name: name.slice(1, -1), dynamic: true }
-        : // static name
-            { name: `"${name}"`, dynamic: false };
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-        el.slotName = getBindingAttr(el, 'name');
-        if (process.env.NODE_ENV !== 'production' && el.key) {
-            warn$1(`\`key\` does not work on <slot> because slots are abstract outlets ` +
-                `and can possibly expand into multiple elements. ` +
-                `Use the key on a wrapping element instead.`, getRawBindingAttr(el, 'key'));
-        }
-    }
-}
-function processComponent(el) {
-    let binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-        el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-        el.inlineTemplate = true;
-    }
-}
-function processAttrs(el) {
-    const list = el.attrsList;
-    let i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-    for (i = 0, l = list.length; i < l; i++) {
-        name = rawName = list[i].name;
-        value = list[i].value;
-        if (dirRE.test(name)) {
-            // mark element as dynamic
-            el.hasBindings = true;
-            // modifiers
-            modifiers = parseModifiers(name.replace(dirRE, ''));
-            // support .foo shorthand syntax for the .prop modifier
-            if (modifiers) {
-                name = name.replace(modifierRE, '');
-            }
-            if (bindRE.test(name)) {
-                // v-bind
-                name = name.replace(bindRE, '');
-                value = parseFilters(value);
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                if (process.env.NODE_ENV !== 'production' &&
-                    value.trim().length === 0) {
-                    warn$1(`The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`);
-                }
-                if (modifiers) {
-                    if (modifiers.prop && !isDynamic) {
-                        name = camelize(name);
-                        if (name === 'innerHtml')
-                            name = 'innerHTML';
-                    }
-                    if (modifiers.camel && !isDynamic) {
-                        name = camelize(name);
-                    }
-                    if (modifiers.sync) {
-                        syncGen = genAssignmentCode(value, `$event`);
-                        if (!isDynamic) {
-                            addHandler(el, `update:${camelize(name)}`, syncGen, null, false, warn$1, list[i]);
-                            if (hyphenate(name) !== camelize(name)) {
-                                addHandler(el, `update:${hyphenate(name)}`, syncGen, null, false, warn$1, list[i]);
-                            }
-                        }
-                        else {
-                            // handler w/ dynamic event name
-                            addHandler(el, `"update:"+(${name})`, syncGen, null, false, warn$1, list[i], true // dynamic
-                            );
-                        }
-                    }
-                }
-                if ((modifiers && modifiers.prop) ||
-                    (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))) {
-                    addProp(el, name, value, list[i], isDynamic);
-                }
-                else {
-                    addAttr(el, name, value, list[i], isDynamic);
-                }
-            }
-            else if (onRE.test(name)) {
-                // v-on
-                name = name.replace(onRE, '');
-                isDynamic = dynamicArgRE.test(name);
-                if (isDynamic) {
-                    name = name.slice(1, -1);
-                }
-                addHandler(el, name, value, modifiers, false, warn$1, list[i], isDynamic);
-            }
-            else {
-                // normal directives
-                name = name.replace(dirRE, '');
-                // parse arg
-                const argMatch = name.match(argRE);
-                let arg = argMatch && argMatch[1];
-                isDynamic = false;
-                if (arg) {
-                    name = name.slice(0, -(arg.length + 1));
-                    if (dynamicArgRE.test(arg)) {
-                        arg = arg.slice(1, -1);
-                        isDynamic = true;
-                    }
-                }
-                addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-                if (process.env.NODE_ENV !== 'production' && name === 'model') {
-                    checkForAliasModel(el, value);
-                }
-            }
-        }
-        else {
-            // literal attribute
-            if (process.env.NODE_ENV !== 'production') {
-                const res = parseText(value, delimiters);
-                if (res) {
-                    warn$1(`${name}="${value}": ` +
-                        'Interpolation inside attributes has been removed. ' +
-                        'Use v-bind or the colon shorthand instead. For example, ' +
-                        'instead of <div id="{{ val }}">, use <div :id="val">.', list[i]);
-                }
-            }
-            addAttr(el, name, JSON.stringify(value), list[i]);
-            // #6887 firefox doesn't update muted state if set via attribute
-            // even immediately after element creation
-            if (!el.component &&
-                name === 'muted' &&
-                platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-                addProp(el, name, 'true', list[i]);
-            }
-        }
-    }
-}
-function checkInFor(el) {
-    let parent = el;
-    while (parent) {
-        if (parent.for !== undefined) {
-            return true;
-        }
-        parent = parent.parent;
-    }
-    return false;
-}
-function parseModifiers(name) {
-    const match = name.match(modifierRE);
-    if (match) {
-        const ret = {};
-        match.forEach((m) => {
-            ret[m.slice(1)] = true;
-        });
-        return ret;
-    }
-}
-function makeAttrsMap(attrs) {
-    const map = {};
-    for (let i = 0, l = attrs.length; i < l; i++) {
-        if (process.env.NODE_ENV !== 'production' &&
-            map[attrs[i].name] &&
-            !isIE &&
-            !isEdge) {
-            warn$1('duplicate attribute: ' + attrs[i].name, attrs[i]);
-        }
-        map[attrs[i].name] = attrs[i].value;
-    }
-    return map;
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style';
-}
-function isForbiddenTag(el) {
-    return (el.tag === 'style' ||
-        (el.tag === 'script' &&
-            (!el.attrsMap.type || el.attrsMap.type === 'text/javascript')));
-}
-const ieNSBug = /^xmlns:NS\d+/;
-const ieNSPrefix = /^NS\d+:/;
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-    const res = [];
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ieNSBug.test(attr.name)) {
-            attr.name = attr.name.replace(ieNSPrefix, '');
-            res.push(attr);
-        }
-    }
-    return res;
-}
-function checkForAliasModel(el, value) {
-    let _el = el;
-    while (_el) {
-        if (_el.for && _el.alias === value) {
-            warn$1(`<${el.tag} v-model="${value}">: ` +
-                `You are binding v-model directly to a v-for iteration alias. ` +
-                `This will not be able to modify the v-for source array because ` +
-                `writing to the alias is like modifying a function local variable. ` +
-                `Consider using an array of objects and use v-model on an object property instead.`, el.rawAttrsMap['v-model']);
-        }
-        _el = _el.parent;
-    }
-}
-
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-        const map = el.attrsMap;
-        if (!map['v-model']) {
-            return;
-        }
-        let typeBinding;
-        if (map[':type'] || map['v-bind:type']) {
-            typeBinding = getBindingAttr(el, 'type');
-        }
-        if (!map.type && !typeBinding && map['v-bind']) {
-            typeBinding = `(${map['v-bind']}).type`;
-        }
-        if (typeBinding) {
-            const ifCondition = getAndRemoveAttr(el, 'v-if', true);
-            const ifConditionExtra = ifCondition ? `&&(${ifCondition})` : ``;
-            const hasElse = getAndRemoveAttr(el, 'v-else', true) != null;
-            const elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);
-            // 1. checkbox
-            const branch0 = cloneASTElement(el);
-            // process for on the main node
-            processFor(branch0);
-            addRawAttr(branch0, 'type', 'checkbox');
-            processElement(branch0, options);
-            branch0.processed = true; // prevent it from double-processed
-            branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra;
-            addIfCondition(branch0, {
-                exp: branch0.if,
-                block: branch0,
-            });
-            // 2. add radio else-if condition
-            const branch1 = cloneASTElement(el);
-            getAndRemoveAttr(branch1, 'v-for', true);
-            addRawAttr(branch1, 'type', 'radio');
-            processElement(branch1, options);
-            addIfCondition(branch0, {
-                exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-                block: branch1,
-            });
-            // 3. other
-            const branch2 = cloneASTElement(el);
-            getAndRemoveAttr(branch2, 'v-for', true);
-            addRawAttr(branch2, ':type', typeBinding);
-            processElement(branch2, options);
-            addIfCondition(branch0, {
-                exp: ifCondition,
-                block: branch2,
-            });
-            if (hasElse) {
-                branch0.else = true;
-            }
-            else if (elseIfCondition) {
-                branch0.elseif = elseIfCondition;
-            }
-            return branch0;
-        }
-    }
-}
-function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent);
-}
-var model$1 = {
-    preTransformNode,
-};
-
-var modules = [klass, style, model$1];
-
-let warn;
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-const RANGE_TOKEN = '__r';
-function model(el, dir, _warn) {
-    warn = _warn;
-    const value = dir.value;
-    const modifiers = dir.modifiers;
-    const tag = el.tag;
-    const type = el.attrsMap.type;
-    if (process.env.NODE_ENV !== 'production') {
-        // inputs with type="file" are read only and setting the input's
-        // value will throw an error.
-        if (tag === 'input' && type === 'file') {
-            warn(`<${el.tag} v-model="${value}" type="file">:\n` +
-                `File inputs are read only. Use a v-on:change listener instead.`, el.rawAttrsMap['v-model']);
-        }
-    }
-    if (el.component) {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    else if (tag === 'select') {
-        genSelect(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'checkbox') {
-        genCheckboxModel(el, value, modifiers);
-    }
-    else if (tag === 'input' && type === 'radio') {
-        genRadioModel(el, value, modifiers);
-    }
-    else if (tag === 'input' || tag === 'textarea') {
-        genDefaultModel(el, value, modifiers);
-    }
-    else {
-        genComponentModel(el, value, modifiers);
-        // component v-model doesn't need extra runtime
-        return false;
-    }
-    // ensure runtime directive metadata
-    return true;
-}
-function genCheckboxModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const valueBinding = getBindingAttr(el, 'value') || 'null';
-    const trueValueBinding = getBindingAttr(el, 'true-value') || 'true';
-    const falseValueBinding = getBindingAttr(el, 'false-value') || 'false';
-    addProp(el, 'checked', `Array.isArray(${value})` +
-        `?_i(${value},${valueBinding})>-1` +
-        (trueValueBinding === 'true'
-            ? `:(${value})`
-            : `:_q(${value},${trueValueBinding})`));
-    addHandler(el, 'change', `var $$a=${value},` +
-        '$$el=$event.target,' +
-        `$$c=$$el.checked?(${trueValueBinding}):(${falseValueBinding});` +
-        'if(Array.isArray($$a)){' +
-        `var $$v=${number ? '_n(' + valueBinding + ')' : valueBinding},` +
-        '$$i=_i($$a,$$v);' +
-        `if($$el.checked){$$i<0&&(${genAssignmentCode(value, '$$a.concat([$$v])')})}` +
-        `else{$$i>-1&&(${genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')})}` +
-        `}else{${genAssignmentCode(value, '$$c')}}`, null, true);
-}
-function genRadioModel(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    let valueBinding = getBindingAttr(el, 'value') || 'null';
-    valueBinding = number ? `_n(${valueBinding})` : valueBinding;
-    addProp(el, 'checked', `_q(${value},${valueBinding})`);
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);
-}
-function genSelect(el, value, modifiers) {
-    const number = modifiers && modifiers.number;
-    const selectedVal = `Array.prototype.filter` +
-        `.call($event.target.options,function(o){return o.selected})` +
-        `.map(function(o){var val = "_value" in o ? o._value : o.value;` +
-        `return ${number ? '_n(val)' : 'val'}})`;
-    const assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';
-    let code = `var $$selectedVal = ${selectedVal};`;
-    code = `${code} ${genAssignmentCode(value, assignment)}`;
-    addHandler(el, 'change', code, null, true);
-}
-function genDefaultModel(el, value, modifiers) {
-    const type = el.attrsMap.type;
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    if (process.env.NODE_ENV !== 'production') {
-        const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];
-        const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];
-        if (value && !typeBinding) {
-            const binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';
-            warn(`${binding}="${value}" conflicts with v-model on the same element ` +
-                'because the latter already expands to a value binding internally', el.rawAttrsMap[binding]);
-        }
-    }
-    const { lazy, number, trim } = modifiers || {};
-    const needCompositionGuard = !lazy && type !== 'range';
-    const event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input';
-    let valueExpression = '$event.target.value';
-    if (trim) {
-        valueExpression = `$event.target.value.trim()`;
-    }
-    if (number) {
-        valueExpression = `_n(${valueExpression})`;
-    }
-    let code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-        code = `if($event.target.composing)return;${code}`;
-    }
-    addProp(el, 'value', `(${value})`);
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-        addHandler(el, 'blur', '$forceUpdate()');
-    }
-}
-
-function text(el, dir) {
-    if (dir.value) {
-        addProp(el, 'textContent', `_s(${dir.value})`, dir);
-    }
-}
-
-function html(el, dir) {
-    if (dir.value) {
-        addProp(el, 'innerHTML', `_s(${dir.value})`, dir);
-    }
-}
-
-var directives = {
-    model,
-    text,
-    html,
-};
-
-const baseOptions = {
-    expectHTML: true,
-    modules,
-    directives,
-    isPreTag,
-    isUnaryTag,
-    mustUseProp,
-    canBeLeftOpenTag,
-    isReservedTag,
-    getTagNamespace,
-    staticKeys: genStaticKeys$1(modules),
-};
-
-let isStaticKey;
-let isPlatformReservedTag$1;
-const genStaticKeysCached = cached(genStaticKeys);
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize$1(root, options) {
-    if (!root)
-        return;
-    isStaticKey = genStaticKeysCached(options.staticKeys || '');
-    isPlatformReservedTag$1 = options.isReservedTag || no;
-    // first pass: mark all non-static nodes.
-    markStatic(root);
-    // second pass: mark static roots.
-    markStaticRoots(root, false);
-}
-function genStaticKeys(keys) {
-    return makeMap('type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : ''));
-}
-function markStatic(node) {
-    node.static = isStatic(node);
-    if (node.type === 1) {
-        // do not make component slot content static. this avoids
-        // 1. components not able to mutate slot nodes
-        // 2. static slot content fails for hot-reloading
-        if (!isPlatformReservedTag$1(node.tag) &&
-            node.tag !== 'slot' &&
-            node.attrsMap['inline-template'] == null) {
-            return;
-        }
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            markStatic(child);
-            if (!child.static) {
-                node.static = false;
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                markStatic(block);
-                if (!block.static) {
-                    node.static = false;
-                }
-            }
-        }
-    }
-}
-function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-        if (node.static || node.once) {
-            node.staticInFor = isInFor;
-        }
-        // For a node to qualify as a static root, it should have children that
-        // are not just static text. Otherwise the cost of hoisting out will
-        // outweigh the benefits and it's better off to just always render it fresh.
-        if (node.static &&
-            node.children.length &&
-            !(node.children.length === 1 && node.children[0].type === 3)) {
-            node.staticRoot = true;
-            return;
-        }
-        else {
-            node.staticRoot = false;
-        }
-        if (node.children) {
-            for (let i = 0, l = node.children.length; i < l; i++) {
-                markStaticRoots(node.children[i], isInFor || !!node.for);
-            }
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                markStaticRoots(node.ifConditions[i].block, isInFor);
-            }
-        }
-    }
-}
-function isStatic(node) {
-    if (node.type === 2) {
-        // expression
-        return false;
-    }
-    if (node.type === 3) {
-        // text
-        return true;
-    }
-    return !!(node.pre ||
-        (!node.hasBindings && // no dynamic bindings
-            !node.if &&
-            !node.for && // not v-if or v-for or v-else
-            !isBuiltInTag(node.tag) && // not a built-in
-            isPlatformReservedTag$1(node.tag) && // not a component
-            !isDirectChildOfTemplateFor(node) &&
-            Object.keys(node).every(isStaticKey)));
-}
-function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-        node = node.parent;
-        if (node.tag !== 'template') {
-            return false;
-        }
-        if (node.for) {
-            return true;
-        }
-    }
-    return false;
-}
-
-const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-const fnInvokeRE = /\([^)]*?\);*$/;
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-// KeyboardEvent.keyCode aliases
-const keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46],
-};
-// KeyboardEvent.key aliases
-const keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del'],
-};
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`;
-const modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard(`$event.target !== $event.currentTarget`),
-    ctrl: genGuard(`!$event.ctrlKey`),
-    shift: genGuard(`!$event.shiftKey`),
-    alt: genGuard(`!$event.altKey`),
-    meta: genGuard(`!$event.metaKey`),
-    left: genGuard(`'button' in $event && $event.button !== 0`),
-    middle: genGuard(`'button' in $event && $event.button !== 1`),
-    right: genGuard(`'button' in $event && $event.button !== 2`),
-};
-function genHandlers(events, isNative) {
-    const prefix = isNative ? 'nativeOn:' : 'on:';
-    let staticHandlers = ``;
-    let dynamicHandlers = ``;
-    for (const name in events) {
-        const handlerCode = genHandler(events[name]);
-        //@ts-expect-error
-        if (events[name] && events[name].dynamic) {
-            dynamicHandlers += `${name},${handlerCode},`;
-        }
-        else {
-            staticHandlers += `"${name}":${handlerCode},`;
-        }
-    }
-    staticHandlers = `{${staticHandlers.slice(0, -1)}}`;
-    if (dynamicHandlers) {
-        return prefix + `_d(${staticHandlers},[${dynamicHandlers.slice(0, -1)}])`;
-    }
-    else {
-        return prefix + staticHandlers;
-    }
-}
-function genHandler(handler) {
-    if (!handler) {
-        return 'function(){}';
-    }
-    if (Array.isArray(handler)) {
-        return `[${handler.map((handler) => genHandler(handler)).join(',')}]`;
-    }
-    const isMethodPath = simplePathRE.test(handler.value);
-    const isFunctionExpression = fnExpRE.test(handler.value);
-    const isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-    if (!handler.modifiers) {
-        if (isMethodPath || isFunctionExpression) {
-            return handler.value;
-        }
-        return `function($event){${isFunctionInvocation ? `return ${handler.value}` : handler.value}}`; // inline statement
-    }
-    else {
-        let code = '';
-        let genModifierCode = '';
-        const keys = [];
-        for (const key in handler.modifiers) {
-            if (modifierCode[key]) {
-                genModifierCode += modifierCode[key];
-                // left/right
-                if (keyCodes[key]) {
-                    keys.push(key);
-                }
-            }
-            else if (key === 'exact') {
-                const modifiers = handler.modifiers;
-                genModifierCode += genGuard(['ctrl', 'shift', 'alt', 'meta']
-                    .filter((keyModifier) => !modifiers[keyModifier])
-                    .map((keyModifier) => `$event.${keyModifier}Key`)
-                    .join('||'));
-            }
-            else {
-                keys.push(key);
-            }
-        }
-        if (keys.length) {
-            code += genKeyFilter(keys);
-        }
-        // Make sure modifiers like prevent and stop get executed after key filtering
-        if (genModifierCode) {
-            code += genModifierCode;
-        }
-        const handlerCode = isMethodPath
-            ? `return ${handler.value}.apply(null, arguments)`
-            : isFunctionExpression
-                ? `return (${handler.value}).apply(null, arguments)`
-                : isFunctionInvocation
-                    ? `return ${handler.value}`
-                    : handler.value;
-        return `function($event){${code}${handlerCode}}`;
-    }
-}
-function genKeyFilter(keys) {
-    return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    `if(!$event.type.indexOf('key')&&` +
-        `${keys.map(genFilterCode).join('&&')})return null;`);
-}
-function genFilterCode(key) {
-    const keyVal = parseInt(key, 10);
-    if (keyVal) {
-        return `$event.keyCode!==${keyVal}`;
-    }
-    const keyCode = keyCodes[key];
-    const keyName = keyNames[key];
-    return (`_k($event.keyCode,` +
-        `${JSON.stringify(key)},` +
-        `${JSON.stringify(keyCode)},` +
-        `$event.key,` +
-        `${JSON.stringify(keyName)}` +
-        `)`);
-}
-
-function on(el, dir) {
-    if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-        warn$2(`v-on without argument does not support modifiers.`);
-    }
-    el.wrapListeners = (code) => `_g(${code},${dir.value})`;
-}
-
-function bind(el, dir) {
-    el.wrapData = (code) => {
-        return `_b(${code},'${el.tag}',${dir.value},${dir.modifiers && dir.modifiers.prop ? 'true' : 'false'}${dir.modifiers && dir.modifiers.sync ? ',true' : ''})`;
-    };
-}
-
-var baseDirectives = {
-    on,
-    bind,
-    cloak: noop,
-};
-
-class CodegenState {
-    options;
-    warn;
-    transforms;
-    dataGenFns;
-    directives;
-    maybeComponent;
-    onceId;
-    staticRenderFns;
-    pre;
-    constructor(options) {
-        this.options = options;
-        this.warn = options.warn || baseWarn;
-        //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-        this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-        this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-        this.directives = extend(extend({}, baseDirectives), options.directives);
-        const isReservedTag = options.isReservedTag || no;
-        this.maybeComponent = (el) => !!el.component || !isReservedTag(el.tag);
-        this.onceId = 0;
-        this.staticRenderFns = [];
-        this.pre = false;
-    }
-}
-function generate$1(ast, options) {
-    const state = new CodegenState(options);
-    // fix #11483, Root level <script> tags should not be rendered.
-    const code = ast
-        ? ast.tag === 'script'
-            ? 'null'
-            : genElement(ast, state)
-        : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genElement(el, state) {
-    if (el.parent) {
-        el.pre = el.pre || el.parent.pre;
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-        return genStatic(el, state);
-    }
-    else if (el.once && !el.onceProcessed) {
-        return genOnce(el, state);
-    }
-    else if (el.for && !el.forProcessed) {
-        return genFor(el, state);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-        return genChildren(el, state) || 'void 0';
-    }
-    else if (el.tag === 'slot') {
-        return genSlot(el, state);
-    }
-    else {
-        // component or element
-        let code;
-        if (el.component) {
-            code = genComponent(el.component, el, state);
-        }
-        else {
-            let data;
-            if (!el.plain || (el.pre && state.maybeComponent(el))) {
-                data = genData(el, state);
-            }
-            const children = el.inlineTemplate ? null : genChildren(el, state, true);
-            code = `_c('${el.tag}'${data ? `,${data}` : '' // data
-            }${children ? `,${children}` : '' // children
-            })`;
-        }
-        // module transforms
-        for (let i = 0; i < state.transforms.length; i++) {
-            code = state.transforms[i](el, code);
-        }
-        return code;
-    }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-    el.staticProcessed = true;
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    const originalPreState = state.pre;
-    if (el.pre) {
-        state.pre = el.pre;
-    }
-    state.staticRenderFns.push(`with(this){return ${genElement(el, state)}}`);
-    state.pre = originalPreState;
-    return `_m(${state.staticRenderFns.length - 1}${el.staticInFor ? ',true' : ''})`;
-}
-// v-once
-function genOnce(el, state) {
-    el.onceProcessed = true;
-    if (el.if && !el.ifProcessed) {
-        return genIf(el, state);
-    }
-    else if (el.staticInFor) {
-        let key = '';
-        let parent = el.parent;
-        while (parent) {
-            if (parent.for) {
-                key = parent.key;
-                break;
-            }
-            parent = parent.parent;
-        }
-        if (!key) {
-            process.env.NODE_ENV !== 'production' &&
-                state.warn(`v-once can only be used inside v-for that is keyed. `, el.rawAttrsMap['v-once']);
-            return genElement(el, state);
-        }
-        return `_o(${genElement(el, state)},${state.onceId++},${key})`;
-    }
-    else {
-        return genStatic(el, state);
-    }
-}
-function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true; // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty);
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-        return altEmpty || '_e()';
-    }
-    const condition = conditions.shift();
-    if (condition.exp) {
-        return `(${condition.exp})?${genTernaryExp(condition.block)}:${genIfConditions(conditions, state, altGen, altEmpty)}`;
-    }
-    else {
-        return `${genTernaryExp(condition.block)}`;
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-        return altGen
-            ? altGen(el, state)
-            : el.once
-                ? genOnce(el, state)
-                : genElement(el, state);
-    }
-}
-function genFor(el, state, altGen, altHelper) {
-    const exp = el.for;
-    const alias = el.alias;
-    const iterator1 = el.iterator1 ? `,${el.iterator1}` : '';
-    const iterator2 = el.iterator2 ? `,${el.iterator2}` : '';
-    if (process.env.NODE_ENV !== 'production' &&
-        state.maybeComponent(el) &&
-        el.tag !== 'slot' &&
-        el.tag !== 'template' &&
-        !el.key) {
-        state.warn(`<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
-            `v-for should have explicit keys. ` +
-            `See https://vuejs.org/guide/list.html#key for more info.`, el.rawAttrsMap['v-for'], true /* tip */);
-    }
-    el.forProcessed = true; // avoid recursion
-    return (`${altHelper || '_l'}((${exp}),` +
-        `function(${alias}${iterator1}${iterator2}){` +
-        `return ${(altGen || genElement)(el, state)}` +
-        '})');
-}
-function genData(el, state) {
-    let data = '{';
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    const dirs = genDirectives(el, state);
-    if (dirs)
-        data += dirs + ',';
-    // key
-    if (el.key) {
-        data += `key:${el.key},`;
-    }
-    // ref
-    if (el.ref) {
-        data += `ref:${el.ref},`;
-    }
-    if (el.refInFor) {
-        data += `refInFor:true,`;
-    }
-    // pre
-    if (el.pre) {
-        data += `pre:true,`;
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-        data += `tag:"${el.tag}",`;
-    }
-    // module data generation functions
-    for (let i = 0; i < state.dataGenFns.length; i++) {
-        data += state.dataGenFns[i](el);
-    }
-    // attributes
-    if (el.attrs) {
-        data += `attrs:${genProps(el.attrs)},`;
-    }
-    // DOM props
-    if (el.props) {
-        data += `domProps:${genProps(el.props)},`;
-    }
-    // event handlers
-    if (el.events) {
-        data += `${genHandlers(el.events, false)},`;
-    }
-    if (el.nativeEvents) {
-        data += `${genHandlers(el.nativeEvents, true)},`;
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-        data += `slot:${el.slotTarget},`;
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-        data += `${genScopedSlots(el, el.scopedSlots, state)},`;
-    }
-    // component v-model
-    if (el.model) {
-        data += `model:{value:${el.model.value},callback:${el.model.callback},expression:${el.model.expression}},`;
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-        const inlineTemplate = genInlineTemplate(el, state);
-        if (inlineTemplate) {
-            data += `${inlineTemplate},`;
-        }
-    }
-    data = data.replace(/,$/, '') + '}';
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-        data = `_b(${data},"${el.tag}",${genProps(el.dynamicAttrs)})`;
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-        data = el.wrapData(data);
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-        data = el.wrapListeners(data);
-    }
-    return data;
-}
-function genDirectives(el, state) {
-    const dirs = el.directives;
-    if (!dirs)
-        return;
-    let res = 'directives:[';
-    let hasRuntime = false;
-    let i, l, dir, needRuntime;
-    for (i = 0, l = dirs.length; i < l; i++) {
-        dir = dirs[i];
-        needRuntime = true;
-        const gen = state.directives[dir.name];
-        if (gen) {
-            // compile-time directive that manipulates AST.
-            // returns true if it also needs a runtime counterpart.
-            needRuntime = !!gen(el, dir, state.warn);
-        }
-        if (needRuntime) {
-            hasRuntime = true;
-            res += `{name:"${dir.name}",rawName:"${dir.rawName}"${dir.value
-                ? `,value:(${dir.value}),expression:${JSON.stringify(dir.value)}`
-                : ''}${dir.arg ? `,arg:${dir.isDynamicArg ? dir.arg : `"${dir.arg}"`}` : ''}${dir.modifiers ? `,modifiers:${JSON.stringify(dir.modifiers)}` : ''}},`;
-        }
-    }
-    if (hasRuntime) {
-        return res.slice(0, -1) + ']';
-    }
-}
-function genInlineTemplate(el, state) {
-    const ast = el.children[0];
-    if (process.env.NODE_ENV !== 'production' &&
-        (el.children.length !== 1 || ast.type !== 1)) {
-        state.warn('Inline-template components must have exactly one child element.', { start: el.start });
-    }
-    if (ast && ast.type === 1) {
-        const inlineRenderFns = generate$1(ast, state.options);
-        return `inlineTemplate:{render:function(){${inlineRenderFns.render}},staticRenderFns:[${inlineRenderFns.staticRenderFns
-            .map((code) => `function(){${code}}`)
-            .join(',')}]}`;
-    }
-}
-function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    let needsForceUpdate = el.for ||
-        Object.keys(slots).some((key) => {
-            const slot = slots[key];
-            return (slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-            );
-        });
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    let needsKey = !!el.if;
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-        let parent = el.parent;
-        while (parent) {
-            if ((parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-                parent.for) {
-                needsForceUpdate = true;
-                break;
-            }
-            if (parent.if) {
-                needsKey = true;
-            }
-            parent = parent.parent;
-        }
-    }
-    const generatedSlots = Object.keys(slots)
-        .map((key) => genScopedSlot(slots[key], state))
-        .join(',');
-    return `scopedSlots:_u([${generatedSlots}]${needsForceUpdate ? `,null,true` : ``}${!needsForceUpdate && needsKey ? `,null,false,${hash(generatedSlots)}` : ``})`;
-}
-function hash(str) {
-    let hash = 5381;
-    let i = str.length;
-    while (i) {
-        hash = (hash * 33) ^ str.charCodeAt(--i);
-    }
-    return hash >>> 0;
-}
-function containsSlotChild(el) {
-    if (el.type === 1) {
-        if (el.tag === 'slot') {
-            return true;
-        }
-        return el.children.some(containsSlotChild);
-    }
-    return false;
-}
-function genScopedSlot(el, state) {
-    const isLegacySyntax = el.attrsMap['slot-scope'];
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-        return genIf(el, state, genScopedSlot, `null`);
-    }
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genScopedSlot);
-    }
-    const slotScope = el.slotScope === emptySlotScopeToken ? `` : String(el.slotScope);
-    const fn = `function(${slotScope}){` +
-        `return ${el.tag === 'template'
-            ? el.if && isLegacySyntax
-                ? `(${el.if})?${genChildren(el, state) || 'undefined'}:undefined`
-                : genChildren(el, state) || 'undefined'
-            : genElement(el, state)}}`;
-    // reverse proxy v-slot without scope on this.$slots
-    const reverseProxy = slotScope ? `` : `,proxy:true`;
-    return `{key:${el.slotTarget || `"default"`},fn:${fn}${reverseProxy}}`;
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    const children = el.children;
-    if (children.length) {
-        const el = children[0];
-        // optimize single v-for
-        if (children.length === 1 &&
-            el.for &&
-            el.tag !== 'template' &&
-            el.tag !== 'slot') {
-            const normalizationType = checkSkip
-                ? state.maybeComponent(el)
-                    ? `,1`
-                    : `,0`
-                : ``;
-            return `${(altGenElement || genElement)(el, state)}${normalizationType}`;
-        }
-        const normalizationType = checkSkip
-            ? getNormalizationType(children, state.maybeComponent)
-            : 0;
-        const gen = altGenNode || genNode;
-        return `[${children.map((c) => gen(c, state)).join(',')}]${normalizationType ? `,${normalizationType}` : ''}`;
-    }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-    let res = 0;
-    for (let i = 0; i < children.length; i++) {
-        const el = children[i];
-        if (el.type !== 1) {
-            continue;
-        }
-        if (needsNormalization(el) ||
-            (el.ifConditions &&
-                el.ifConditions.some((c) => needsNormalization(c.block)))) {
-            res = 2;
-            break;
-        }
-        if (maybeComponent(el) ||
-            (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))) {
-            res = 1;
-        }
-    }
-    return res;
-}
-function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot';
-}
-function genNode(node, state) {
-    if (node.type === 1) {
-        return genElement(node, state);
-    }
-    else if (node.type === 3 && node.isComment) {
-        return genComment(node);
-    }
-    else {
-        return genText(node);
-    }
-}
-function genText(text) {
-    return `_v(${text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text))})`;
-}
-function genComment(comment) {
-    return `_e(${JSON.stringify(comment.text)})`;
-}
-function genSlot(el, state) {
-    const slotName = el.slotName || '"default"';
-    const children = genChildren(el, state);
-    let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`;
-    const attrs = el.attrs || el.dynamicAttrs
-        ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-            // slot props are camelized
-            name: camelize(attr.name),
-            value: attr.value,
-            dynamic: attr.dynamic
-        })))
-        : null;
-    const bind = el.attrsMap['v-bind'];
-    if ((attrs || bind) && !children) {
-        res += `,null`;
-    }
-    if (attrs) {
-        res += `,${attrs}`;
-    }
-    if (bind) {
-        res += `${attrs ? '' : ',null'},${bind}`;
-    }
-    return res + ')';
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-    const children = el.inlineTemplate ? null : genChildren(el, state, true);
-    return `_c(${componentName},${genData(el, state)}${children ? `,${children}` : ''})`;
-}
-function genProps(props) {
-    let staticProps = ``;
-    let dynamicProps = ``;
-    for (let i = 0; i < props.length; i++) {
-        const prop = props[i];
-        const value = transformSpecialNewlines(prop.value);
-        if (prop.dynamic) {
-            dynamicProps += `${prop.name},${value},`;
-        }
-        else {
-            staticProps += `"${prop.name}":${value},`;
-        }
-    }
-    staticProps = `{${staticProps.slice(0, -1)}}`;
-    if (dynamicProps) {
-        return `_d(${staticProps},[${dynamicProps.slice(0, -1)}])`;
-    }
-    else {
-        return staticProps;
-    }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
-}
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-const prohibitedKeywordRE = new RegExp('\\b' +
-    ('do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments')
-        .split(',')
-        .join('\\b|\\b') +
-    '\\b');
-// these unary operators should not be used as property/method names
-const unaryOperatorsRE = new RegExp('\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)');
-// strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-    if (ast) {
-        checkNode(ast, warn);
-    }
-}
-function checkNode(node, warn) {
-    if (node.type === 1) {
-        for (const name in node.attrsMap) {
-            if (dirRE.test(name)) {
-                const value = node.attrsMap[name];
-                if (value) {
-                    const range = node.rawAttrsMap[name];
-                    if (name === 'v-for') {
-                        checkFor(node, `v-for="${value}"`, warn, range);
-                    }
-                    else if (name === 'v-slot' || name[0] === '#') {
-                        checkFunctionParameterExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                    else if (onRE.test(name)) {
-                        checkEvent(value, `${name}="${value}"`, warn, range);
-                    }
-                    else {
-                        checkExpression(value, `${name}="${value}"`, warn, range);
-                    }
-                }
-            }
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                checkNode(node.children[i], warn);
-            }
-        }
-    }
-    else if (node.type === 2) {
-        checkExpression(node.expression, node.text, warn, node);
-    }
-}
-function checkEvent(exp, text, warn, range) {
-    const stripped = exp.replace(stripStringRE, '');
-    const keywordMatch = stripped.match(unaryOperatorsRE);
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-        warn(`avoid using JavaScript unary operator as property name: ` +
-            `"${keywordMatch[0]}" in expression ${text.trim()}`, range);
-    }
-    checkExpression(exp, text, warn, range);
-}
-function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range);
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range);
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);
-}
-function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-        try {
-            new Function(`var ${ident}=_`);
-        }
-        catch (e) {
-            warn(`invalid ${type} "${ident}" in expression: ${text.trim()}`, range);
-        }
-    }
-}
-function checkExpression(exp, text, warn, range) {
-    try {
-        new Function(`return ${exp}`);
-    }
-    catch (e) {
-        const keywordMatch = exp
-            .replace(stripStringRE, '')
-            .match(prohibitedKeywordRE);
-        if (keywordMatch) {
-            warn(`avoid using JavaScript keyword as property name: ` +
-                `"${keywordMatch[0]}"\n  Raw expression: ${text.trim()}`, range);
-        }
-        else {
-            warn(`invalid expression: ${e.message} in\n\n` +
-                `    ${exp}\n\n` +
-                `  Raw expression: ${text.trim()}\n`, range);
-        }
-    }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-        new Function(exp, '');
-    }
-    catch (e) {
-        warn(`invalid function parameter expression: ${e.message} in\n\n` +
-            `    ${exp}\n\n` +
-            `  Raw expression: ${text.trim()}\n`, range);
-    }
-}
-
-const range = 2;
-function generateCodeFrame(source, start = 0, end = source.length) {
-    const lines = source.split(/\r?\n/);
-    let count = 0;
-    const res = [];
-    for (let i = 0; i < lines.length; i++) {
-        count += lines[i].length + 1;
-        if (count >= start) {
-            for (let j = i - range; j <= i + range || end > count; j++) {
-                if (j < 0 || j >= lines.length)
-                    continue;
-                res.push(`${j + 1}${repeat(` `, 3 - String(j + 1).length)}|  ${lines[j]}`);
-                const lineLength = lines[j].length;
-                if (j === i) {
-                    // push underline
-                    const pad = start - (count - lineLength) + 1;
-                    const length = end > count ? lineLength - pad : end - start;
-                    res.push(`   |  ` + repeat(` `, pad) + repeat(`^`, length));
-                }
-                else if (j > i) {
-                    if (end > count) {
-                        const length = Math.min(end - count, lineLength);
-                        res.push(`   |  ` + repeat(`^`, length));
-                    }
-                    count += lineLength + 1;
-                }
-            }
-            break;
-        }
-    }
-    return res.join('\n');
-}
-function repeat(str, n) {
-    let result = '';
-    if (n > 0) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // eslint-disable-line
-            if (n & 1)
-                result += str;
-            n >>>= 1;
-            if (n <= 0)
-                break;
-            str += str;
-        }
-    }
-    return result;
-}
-
-function createFunction(code, errors) {
-    try {
-        return new Function(code);
-    }
-    catch (err) {
-        errors.push({ err, code });
-        return noop;
-    }
-}
-function createCompileToFunctionFn(compile) {
-    const cache = Object.create(null);
-    return function compileToFunctions(template, options, vm) {
-        options = extend({}, options);
-        const warn = options.warn || warn$2;
-        delete options.warn;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            // detect possible CSP restriction
-            try {
-                new Function('return 1');
-            }
-            catch (e) {
-                if (e.toString().match(/unsafe-eval|CSP/)) {
-                    warn('It seems you are using the standalone build of Vue.js in an ' +
-                        'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                        'The template compiler cannot work in this environment. Consider ' +
-                        'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                        'templates into render functions.');
-                }
-            }
-        }
-        // check cache
-        const key = options.delimiters
-            ? String(options.delimiters) + template
-            : template;
-        if (cache[key]) {
-            return cache[key];
-        }
-        // compile
-        const compiled = compile(template, options);
-        // check compilation errors/tips
-        if (process.env.NODE_ENV !== 'production') {
-            if (compiled.errors && compiled.errors.length) {
-                if (options.outputSourceRange) {
-                    compiled.errors.forEach((e) => {
-                        warn(`Error compiling template:\n\n${e.msg}\n\n` +
-                            generateCodeFrame(template, e.start, e.end), vm);
-                    });
-                }
-                else {
-                    warn(`Error compiling template:\n\n${template}\n\n` +
-                        compiled.errors.map((e) => `- ${e}`).join('\n') +
-                        '\n', vm);
-                }
-            }
-            if (compiled.tips && compiled.tips.length) {
-                if (options.outputSourceRange) {
-                    compiled.tips.forEach((e) => tip(e.msg, vm));
-                }
-                else {
-                    compiled.tips.forEach((msg) => tip(msg, vm));
-                }
-            }
-        }
-        // turn code into functions
-        const res = {};
-        const fnGenErrors = [];
-        res.render = createFunction(compiled.render, fnGenErrors);
-        res.staticRenderFns = compiled.staticRenderFns.map((code) => {
-            return createFunction(code, fnGenErrors);
-        });
-        // check function generation errors.
-        // this should only happen if there is a bug in the compiler itself.
-        // mostly for codegen development use
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production') {
-            if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-                warn(`Failed to generate render function:\n\n` +
-                    fnGenErrors
-                        .map(({ err, code }) => `${err.toString()} in\n\n${code}\n`)
-                        .join('\n'), vm);
-            }
-        }
-        return (cache[key] = res);
-    };
-}
-
-function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-        function compile(template, options) {
-            const finalOptions = Object.create(baseOptions);
-            const errors = [];
-            const tips = [];
-            let warn = (msg, range, tip) => {
-                (tip ? tips : errors).push(msg);
-            };
-            if (options) {
-                if (process.env.NODE_ENV !== 'production' &&
-                    options.outputSourceRange) {
-                    // $flow-disable-line
-                    const leadingSpaceLength = template.match(/^\s*/)[0].length;
-                    warn = (msg, range, tip) => {
-                        const data = { msg };
-                        if (range) {
-                            if (range.start != null) {
-                                data.start = range.start + leadingSpaceLength;
-                            }
-                            if (range.end != null) {
-                                data.end = range.end + leadingSpaceLength;
-                            }
-                        }
-                        (tip ? tips : errors).push(data);
-                    };
-                }
-                // merge custom modules
-                if (options.modules) {
-                    finalOptions.modules = (baseOptions.modules || []).concat(options.modules);
-                }
-                // merge custom directives
-                if (options.directives) {
-                    finalOptions.directives = extend(Object.create(baseOptions.directives || null), options.directives);
-                }
-                // copy other options
-                for (const key in options) {
-                    if (key !== 'modules' && key !== 'directives') {
-                        finalOptions[key] = options[key];
-                    }
-                }
-            }
-            finalOptions.warn = warn;
-            const compiled = baseCompile(template.trim(), finalOptions);
-            if (process.env.NODE_ENV !== 'production') {
-                detectErrors(compiled.ast, warn);
-            }
-            compiled.errors = errors;
-            compiled.tips = tips;
-            return compiled;
-        }
-        return {
-            compile,
-            compileToFunctions: createCompileToFunctionFn(compile),
-        };
-    };
-}
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-const createCompiler$1 = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    if (options.optimize !== false) {
-        optimize$1(ast, options);
-    }
-    const code = generate$1(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
-});
-
-const { compile: compile$1, compileToFunctions: compileToFunctions$1 } = createCompiler$1(baseOptions);
-
-const isAttr = makeMap('accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap');
-/* istanbul ignore next */
-const isRenderableAttr = (name) => {
-    return (isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0);
-};
-const propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv',
-};
-const ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;',
-};
-function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar);
-}
-function escapeChar(a) {
-    return ESC[a] || a;
-}
-
-const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/;
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-    if (el.directives) {
-        for (let i = 0; i < el.directives.length; i++) {
-            const dir = el.directives[i];
-            if (dir.name === 'model') {
-                state.directives.model(el, dir, state.warn);
-                // remove value for textarea as its converted to text
-                if (el.tag === 'textarea' && el.props) {
-                    el.props = el.props.filter((p) => p.name !== 'value');
-                }
-                break;
-            }
-        }
-    }
-}
-function genAttrSegments(attrs) {
-    return attrs.map(({ name, value }) => genAttrSegment(name, value));
-}
-function genDOMPropSegments(props, attrs) {
-    const segments = [];
-    props.forEach(({ name, value }) => {
-        name = propsToAttrMap[name] || name.toLowerCase();
-        if (isRenderableAttr(name) &&
-            !(attrs && attrs.some((a) => a.name === name))) {
-            segments.push(genAttrSegment(name, value));
-        }
-    });
-    return segments;
-}
-function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-        // force double quote
-        value = value.replace(/^'|'$/g, '"');
-        // force enumerated attr to "true"
-        if (isEnumeratedAttr(name) && value !== `"false"`) {
-            value = `"true"`;
-        }
-        return {
-            type: RAW,
-            value: isBooleanAttr(name)
-                ? ` ${name}="${name}"`
-                : value === '""'
-                    ? ` ${name}`
-                    : ` ${name}="${JSON.parse(value)}"`,
-        };
-    }
-    else {
-        return {
-            type: EXPRESSION,
-            value: `_ssrAttr(${JSON.stringify(name)},${value})`,
-        };
-    }
-}
-function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-        return [{ type: RAW, value: ` class="${JSON.parse(staticClass)}"` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-            },
-        ];
-    }
-}
-function genStyleSegments(staticStyle, parsedStaticStyle, styleBinding, vShowExpression) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-        return [{ type: RAW, value: ` style=${JSON.stringify(staticStyle)}` }];
-    }
-    else {
-        return [
-            {
-                type: EXPRESSION,
-                value: `_ssrStyle(${parsedStaticStyle || 'null'},${styleBinding || 'null'}, ${vShowExpression
-                    ? `{ display: (${vShowExpression}) ? '' : 'none' }`
-                    : 'null'})`,
-            },
-        ];
-    }
-}
-
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-const optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4, // self un-optimizable with some un-optimizable children
-};
-let isPlatformReservedTag;
-function optimize(root, options) {
-    if (!root)
-        return;
-    isPlatformReservedTag = options.isReservedTag || no;
-    walk(root, true);
-}
-function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-        node.ssrOptimizability = optimizability.FALSE;
-        return;
-    }
-    // root node or nodes with custom directives should always be a VNode
-    const selfUnoptimizable = isRoot || hasCustomDirective(node);
-    const check = (child) => {
-        if (child.ssrOptimizability !== optimizability.FULL) {
-            node.ssrOptimizability = selfUnoptimizable
-                ? optimizability.PARTIAL
-                : optimizability.SELF;
-        }
-    };
-    if (selfUnoptimizable) {
-        node.ssrOptimizability = optimizability.CHILDREN;
-    }
-    if (node.type === 1) {
-        for (let i = 0, l = node.children.length; i < l; i++) {
-            const child = node.children[i];
-            walk(child);
-            check(child);
-        }
-        if (node.ifConditions) {
-            for (let i = 1, l = node.ifConditions.length; i < l; i++) {
-                const block = node.ifConditions[i].block;
-                walk(block, isRoot);
-                check(block);
-            }
-        }
-        if (node.ssrOptimizability == null ||
-            (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))) {
-            node.ssrOptimizability = optimizability.FULL;
-        }
-        else {
-            node.children = optimizeSiblings(node);
-        }
-    }
-    else {
-        node.ssrOptimizability = optimizability.FULL;
-    }
-}
-function optimizeSiblings(el) {
-    const children = el.children;
-    const optimizedChildren = [];
-    let currentOptimizableGroup = [];
-    const pushGroup = () => {
-        if (currentOptimizableGroup.length) {
-            optimizedChildren.push({
-                type: 1,
-                parent: el,
-                tag: 'template',
-                attrsList: [],
-                attrsMap: {},
-                rawAttrsMap: {},
-                children: currentOptimizableGroup,
-                ssrOptimizability: optimizability.FULL,
-            });
-        }
-        currentOptimizableGroup = [];
-    };
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.ssrOptimizability === optimizability.FULL) {
-            currentOptimizableGroup.push(c);
-        }
-        else {
-            // wrap fully-optimizable adjacent siblings inside a template tag
-            // so that they can be optimized into a single ssrNode by codegen
-            pushGroup();
-            optimizedChildren.push(c);
-        }
-    }
-    pushGroup();
-    return optimizedChildren;
-}
-function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-        // text or expression
-        return false;
-    }
-    return (isBuiltInTag(node.tag) || // built-in (slot, component)
-        !isPlatformReservedTag(node.tag) || // custom component
-        !!node.component || // "is" component
-        isSelectWithModel(node) // <select v-model> requires runtime inspection
-    );
-}
-const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once');
-function hasCustomDirective(node) {
-    return (node.type === 1 &&
-        node.directives &&
-        node.directives.some((d) => !isBuiltInDir(d.name)));
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-    return (node.type === 1 &&
-        node.tag === 'select' &&
-        node.directives != null &&
-        node.directives.some((d) => d.name === 'model'));
-}
-
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-const RAW = 0;
-const INTERPOLATION = 1;
-const EXPRESSION = 2;
-function generate(ast, options) {
-    const state = new CodegenState(options);
-    const code = ast ? genSSRElement(ast, state) : '_c("div")';
-    return {
-        render: `with(this){return ${code}}`,
-        staticRenderFns: state.staticRenderFns,
-    };
-}
-function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-        return genFor(el, state, genSSRElement);
-    }
-    else if (el.if && !el.ifProcessed) {
-        return genIf(el, state, genSSRElement);
-    }
-    else if (el.tag === 'template' && !el.slotTarget) {
-        return el.ssrOptimizability === optimizability.FULL
-            ? genChildrenAsStringNode(el, state)
-            : genSSRChildren(el, state) || 'void 0';
-    }
-    switch (el.ssrOptimizability) {
-        case optimizability.FULL:
-            // stringify whole tree
-            return genStringElement(el, state);
-        case optimizability.SELF:
-            // stringify self and check children
-            return genStringElementWithChildren(el, state);
-        case optimizability.CHILDREN:
-            // generate self as VNode and stringify children
-            return genNormalElement(el, state, true);
-        case optimizability.PARTIAL:
-            // generate self as VNode and check children
-            return genNormalElement(el, state, false);
-        default:
-            // bail whole tree
-            return genElement(el, state);
-    }
-}
-function genNormalElement(el, state, stringifyChildren) {
-    const data = el.plain ? undefined : genData(el, state);
-    const children = stringifyChildren
-        ? `[${genChildrenAsStringNode(el, state)}]`
-        : genSSRChildren(el, state, true);
-    return `_c('${el.tag}'${data ? `,${data}` : ''}${children ? `,${children}` : ''})`;
-}
-function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode);
-}
-function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el);
-}
-function genChildrenAsStringNode(el, state) {
-    return el.children.length
-        ? `_ssrNode(${flattenSegments(childrenToSegments(el, state))})`
-        : '';
-}
-function genStringElement(el, state) {
-    return `_ssrNode(${elementToString(el, state)})`;
-}
-function genStringElementWithChildren(el, state) {
-    const children = genSSRChildren(el, state, true);
-    return `_ssrNode(${flattenSegments(elementToOpenTagSegments(el, state))},"</${el.tag}>"${children ? `,${children}` : ''})`;
-}
-function elementToString(el, state) {
-    return `(${flattenSegments(elementToSegments(el, state))})`;
-}
-function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-        el.forProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genFor(el, state, elementToString, '_ssrList'),
-            },
-        ];
-    }
-    else if (el.if && !el.ifProcessed) {
-        el.ifProcessed = true;
-        return [
-            {
-                type: EXPRESSION,
-                value: genIf(el, state, elementToString, '"<!---->"'),
-            },
-        ];
-    }
-    else if (el.tag === 'template') {
-        return childrenToSegments(el, state);
-    }
-    const openSegments = elementToOpenTagSegments(el, state);
-    const childrenSegments = childrenToSegments(el, state);
-    const { isUnaryTag } = state.options;
-    const close = isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: `</${el.tag}>` }];
-    return openSegments.concat(childrenSegments, close);
-}
-function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state);
-    let binding;
-    const segments = [{ type: RAW, value: `<${el.tag}` }];
-    // attrs
-    if (el.attrs) {
-        segments.push.apply(segments, genAttrSegments(el.attrs));
-    }
-    // domProps
-    if (el.props) {
-        segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs));
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrAttrs(${binding})` });
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-        segments.push({ type: EXPRESSION, value: `_ssrDOMProps(${binding})` });
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-        segments.push.apply(segments, genClassSegments(el.staticClass, el.classBinding));
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-        segments.push.apply(segments, genStyleSegments(el.attrsMap.style, el.staticStyle, el.styleBinding, el.attrsMap['v-show']));
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-        segments.push({ type: RAW, value: ` ${state.options.scopeId}` });
-    }
-    segments.push({ type: RAW, value: `>` });
-    return segments;
-}
-function childrenToSegments(el, state) {
-    let binding;
-    if ((binding = el.attrsMap['v-html'])) {
-        return [{ type: EXPRESSION, value: `_s(${binding})` }];
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-        return [{ type: INTERPOLATION, value: `_s(${binding})` }];
-    }
-    return el.children ? nodesToSegments(el.children, state) : [];
-}
-function nodesToSegments(children, state) {
-    const segments = [];
-    for (let i = 0; i < children.length; i++) {
-        const c = children[i];
-        if (c.type === 1) {
-            segments.push.apply(segments, elementToSegments(c, state));
-        }
-        else if (c.type === 2) {
-            segments.push({ type: INTERPOLATION, value: c.expression });
-        }
-        else if (c.type === 3) {
-            let text = escape(c.text);
-            if (c.isComment) {
-                text = '<!--' + text + '-->';
-            }
-            segments.push({ type: RAW, value: text });
-        }
-    }
-    return segments;
-}
-function flattenSegments(segments) {
-    const mergedSegments = [];
-    let textBuffer = '';
-    const pushBuffer = () => {
-        if (textBuffer) {
-            mergedSegments.push(JSON.stringify(textBuffer));
-            textBuffer = '';
-        }
-    };
-    for (let i = 0; i < segments.length; i++) {
-        const s = segments[i];
-        if (s.type === RAW) {
-            textBuffer += s.value;
-        }
-        else if (s.type === INTERPOLATION) {
-            pushBuffer();
-            mergedSegments.push(`_ssrEscape(${s.value})`);
-        }
-        else if (s.type === EXPRESSION) {
-            pushBuffer();
-            mergedSegments.push(`(${s.value})`);
-        }
-    }
-    pushBuffer();
-    return mergedSegments.join('+');
-}
-
-const createCompiler = createCompilerCreator(function baseCompile(template, options) {
-    const ast = parse(template.trim(), options);
-    optimize(ast, options);
-    const code = generate(ast, options);
-    return {
-        ast,
-        render: code.render,
-        staticRenderFns: code.staticRenderFns,
-    };
-});
-
-const { compile, compileToFunctions } = createCompiler(baseOptions);
-
-exports.compile = compile$1;
-exports.compileToFunctions = compileToFunctions$1;
-exports.generateCodeFrame = generateCodeFrame;
-exports.parseComponent = parseComponent;
-exports.ssrCompile = compile;
-exports.ssrCompileToFunctions = compileToFunctions;

From c19fabd9302ad4f6fba2b79de5e5cd623014a481 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:15:57 +0800
Subject: [PATCH 033/317] build: remove flow deps

---
 package.json                      |   5 -
 src/core/components/keep-alive.ts |   2 -
 yarn.lock                         | 320 +-----------------------------
 3 files changed, 5 insertions(+), 322 deletions(-)

diff --git a/package.json b/package.json
index 581efd65365..5bbb9aedb1e 100644
--- a/package.json
+++ b/package.json
@@ -71,7 +71,6 @@
     "@babel/plugin-proposal-class-properties": "^7.16.7",
     "@babel/plugin-syntax-dynamic-import": "^7.8.3",
     "@babel/plugin-syntax-jsx": "^7.16.7",
-    "@babel/plugin-transform-flow-strip-types": "^7.16.7",
     "@babel/preset-env": "^7.17.10",
     "@babel/preset-typescript": "^7.16.7",
     "@babel/register": "^7.17.7",
@@ -94,8 +93,6 @@
     "babel-plugin-istanbul": "^6.1.1",
     "babel-plugin-transform-require-context": "^0.1.1",
     "babel-plugin-transform-vue-jsx": "^4.0.1",
-    "babel-preset-flow-vue": "^1.0.0",
-    "buble": "^0.20.0",
     "chalk": "^4.0.0",
     "chromedriver": "^100.0.0",
     "codecov": "^3.8.3",
@@ -107,10 +104,8 @@
     "es6-promise": "^4.2.8",
     "escodegen": "^2.0.0",
     "eslint": "^8.14.0",
-    "eslint-plugin-flowtype": "^8.0.3",
     "eslint-plugin-jasmine": "^4.1.3",
     "file-loader": "^6.2.0",
-    "flow-bin": "^0.176.3",
     "fsevents": "2.3.2",
     "hash-sum": "^2.0.0",
     "he": "^1.1.1",
diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index 9bfc2db8db1..6e03c1e990a 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -1,5 +1,3 @@
-/* @flow */
-
 import { isRegExp, remove } from "shared/util";
 import { getFirstComponentChild } from "core/vdom/helpers/index";
 import type VNode from "core/vdom/vnode";
diff --git a/yarn.lock b/yarn.lock
index 1fed6b75bd0..18a82afac79 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -444,13 +444,6 @@
   dependencies:
     "@babel/helper-plugin-utils" "^7.8.3"
 
-"@babel/plugin-syntax-flow@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.16.7.tgz#202b147e5892b8452bbb0bb269c7ed2539ab8832"
-  integrity sha512-UDo3YGQO0jH6ytzVwgSLv9i/CzMcUjbKenL67dTrAZPPv6GFAtDhe6jqnvmoKzC/7htNTohhos+onPtDMqJwaQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
 "@babel/plugin-syntax-json-strings@^7.8.3":
   version "7.8.3"
   resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
@@ -609,14 +602,6 @@
     "@babel/helper-builder-binary-assignment-operator-visitor" "^7.16.7"
     "@babel/helper-plugin-utils" "^7.16.7"
 
-"@babel/plugin-transform-flow-strip-types@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.16.7.tgz#291fb140c78dabbf87f2427e7c7c332b126964b8"
-  integrity sha512-mzmCq3cNsDpZZu9FADYYyfZJIOrSONmHcop2XEKPdBNMa4PDC4eEvcOvzZaCNcjKu72v0XQlA5y1g58aLRXdYg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-flow" "^7.16.7"
-
 "@babel/plugin-transform-for-of@^7.16.7":
   version "7.16.7"
   resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.16.7.tgz#649d639d4617dff502a9a158c479b3b556728d8c"
@@ -1671,17 +1656,12 @@ accepts@~1.3.4:
     mime-types "~2.1.34"
     negotiator "0.6.3"
 
-acorn-dynamic-import@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz#482210140582a36b83c3e342e1cfebcaa9240948"
-  integrity sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==
-
 acorn-import-assertions@^1.7.6:
   version "1.8.0"
   resolved "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.8.0.tgz#ba2b5939ce62c238db6d93d81c9b111b29b855e9"
   integrity sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==
 
-acorn-jsx@^5.2.0, acorn-jsx@^5.3.1:
+acorn-jsx@^5.3.1:
   version "5.3.2"
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
@@ -1691,11 +1671,6 @@ acorn-walk@^8.0.2, acorn-walk@^8.1.1, acorn-walk@^8.2.0:
   resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
   integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
 
-acorn@^6.4.1:
-  version "6.4.2"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6"
-  integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==
-
 acorn@^8.1.0, acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
   version "8.7.1"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30"
@@ -1765,11 +1740,6 @@ ansi-escapes@^4.3.0:
   dependencies:
     type-fest "^0.21.3"
 
-ansi-regex@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df"
-  integrity sha1-w7M6te42DYbg5ijwRorn7yfWVN8=
-
 ansi-regex@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.1.tgz#123d6479e92ad45ad897d4054e3c7ca7db4944e1"
@@ -1790,11 +1760,6 @@ ansi-regex@^6.0.1:
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
   integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
 
-ansi-styles@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
-  integrity sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=
-
 ansi-styles@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
@@ -1991,15 +1956,6 @@ axios@^0.24.0:
   dependencies:
     follow-redirects "^1.14.4"
 
-babel-code-frame@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
-  integrity sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=
-  dependencies:
-    chalk "^1.1.3"
-    esutils "^2.0.2"
-    js-tokens "^3.0.2"
-
 babel-eslint@^10.1.0:
   version "10.1.0"
   resolved "https://registry.yarnpkg.com/babel-eslint/-/babel-eslint-10.1.0.tgz#6968e568a910b78fb3779cdd8b6ac2f479943232"
@@ -2012,25 +1968,6 @@ babel-eslint@^10.1.0:
     eslint-visitor-keys "^1.0.0"
     resolve "^1.12.0"
 
-babel-helper-function-name@^6.24.1:
-  version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz#d3475b8c03ed98242a25b48351ab18399d3580a9"
-  integrity sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=
-  dependencies:
-    babel-helper-get-function-arity "^6.24.1"
-    babel-runtime "^6.22.0"
-    babel-template "^6.24.1"
-    babel-traverse "^6.24.1"
-    babel-types "^6.24.1"
-
-babel-helper-get-function-arity@^6.24.1:
-  version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz#8f7782aa93407c41d3aa50908f89b031b1b6853d"
-  integrity sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=
-  dependencies:
-    babel-runtime "^6.22.0"
-    babel-types "^6.24.1"
-
 babel-helper-vue-jsx-merge-props@^2.0.3:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/babel-helper-vue-jsx-merge-props/-/babel-helper-vue-jsx-merge-props-2.0.3.tgz#22aebd3b33902328e513293a8e4992b384f9f1b6"
@@ -2046,13 +1983,6 @@ babel-loader@^8.2.5:
     make-dir "^3.1.0"
     schema-utils "^2.6.5"
 
-babel-messages@^6.23.0:
-  version "6.23.0"
-  resolved "https://registry.yarnpkg.com/babel-messages/-/babel-messages-6.23.0.tgz#f3cdf4703858035b2a2951c6ec5edf6c62f2630e"
-  integrity sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=
-  dependencies:
-    babel-runtime "^6.22.0"
-
 babel-plugin-dynamic-import-node@^2.3.3:
   version "2.3.3"
   resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz#84fda19c976ec5c6defef57f9427b3def66e17a3"
@@ -2095,34 +2025,6 @@ babel-plugin-polyfill-regenerator@^0.3.0:
   dependencies:
     "@babel/helper-define-polyfill-provider" "^0.3.1"
 
-babel-plugin-syntax-class-properties@^6.8.0:
-  version "6.13.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-syntax-class-properties/-/babel-plugin-syntax-class-properties-6.13.0.tgz#d7eb23b79a317f8543962c505b827c7d6cac27de"
-  integrity sha1-1+sjt5oxf4VDlixQW4J8fWysJ94=
-
-babel-plugin-syntax-flow@^6.18.0, babel-plugin-syntax-flow@^6.8.0:
-  version "6.18.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz#4c3ab20a2af26aa20cd25995c398c4eb70310c8d"
-  integrity sha1-TDqyCiryaqIM0lmVw5jE63AxDI0=
-
-babel-plugin-transform-class-properties@^6.8.0:
-  version "6.24.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-class-properties/-/babel-plugin-transform-class-properties-6.24.1.tgz#6a79763ea61d33d36f37b611aa9def81a81b46ac"
-  integrity sha1-anl2PqYdM9NvN7YRqp3vgagbRqw=
-  dependencies:
-    babel-helper-function-name "^6.24.1"
-    babel-plugin-syntax-class-properties "^6.8.0"
-    babel-runtime "^6.22.0"
-    babel-template "^6.24.1"
-
-babel-plugin-transform-flow-strip-types@^6.8.0:
-  version "6.22.0"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz#84cb672935d43714fdc32bce84568d87441cf7cf"
-  integrity sha1-hMtnKTXUNxT9wyvOhFaNh0Qc988=
-  dependencies:
-    babel-plugin-syntax-flow "^6.18.0"
-    babel-runtime "^6.22.0"
-
 babel-plugin-transform-require-context@^0.1.1:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/babel-plugin-transform-require-context/-/babel-plugin-transform-require-context-0.1.1.tgz#319b545ca83080b5062776b46cc9b8b346fea9a6"
@@ -2137,64 +2039,6 @@ babel-plugin-transform-vue-jsx@^4.0.1:
   dependencies:
     esutils "^2.0.2"
 
-babel-preset-flow-vue@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/babel-preset-flow-vue/-/babel-preset-flow-vue-1.0.0.tgz#bd28eb64b53d65f9c47262b32ce6c6033fe70671"
-  integrity sha1-vSjrZLU9ZfnEcmKzLObGAz/nBnE=
-  dependencies:
-    babel-plugin-syntax-flow "^6.8.0"
-    babel-plugin-transform-class-properties "^6.8.0"
-    babel-plugin-transform-flow-strip-types "^6.8.0"
-
-babel-runtime@^6.22.0, babel-runtime@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.26.0.tgz#965c7058668e82b55d7bfe04ff2337bc8b5647fe"
-  integrity sha1-llxwWGaOgrVde/4E/yM3vItWR/4=
-  dependencies:
-    core-js "^2.4.0"
-    regenerator-runtime "^0.11.0"
-
-babel-template@^6.24.1:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-template/-/babel-template-6.26.0.tgz#de03e2d16396b069f46dd9fff8521fb1a0e35e02"
-  integrity sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=
-  dependencies:
-    babel-runtime "^6.26.0"
-    babel-traverse "^6.26.0"
-    babel-types "^6.26.0"
-    babylon "^6.18.0"
-    lodash "^4.17.4"
-
-babel-traverse@^6.24.1, babel-traverse@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-traverse/-/babel-traverse-6.26.0.tgz#46a9cbd7edcc62c8e5c064e2d2d8d0f4035766ee"
-  integrity sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=
-  dependencies:
-    babel-code-frame "^6.26.0"
-    babel-messages "^6.23.0"
-    babel-runtime "^6.26.0"
-    babel-types "^6.26.0"
-    babylon "^6.18.0"
-    debug "^2.6.8"
-    globals "^9.18.0"
-    invariant "^2.2.2"
-    lodash "^4.17.4"
-
-babel-types@^6.24.1, babel-types@^6.26.0:
-  version "6.26.0"
-  resolved "https://registry.yarnpkg.com/babel-types/-/babel-types-6.26.0.tgz#a3b073f94ab49eb6fa55cd65227a334380632497"
-  integrity sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=
-  dependencies:
-    babel-runtime "^6.26.0"
-    esutils "^2.0.2"
-    lodash "^4.17.4"
-    to-fast-properties "^1.0.3"
-
-babylon@^6.18.0:
-  version "6.18.0"
-  resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.18.0.tgz#af2f3b88fa6f5c1e4c634d1a0f8eac4f55b395e3"
-  integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==
-
 balanced-match@^1.0.0:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
@@ -2439,19 +2283,6 @@ browserslist@^4.14.5, browserslist@^4.20.2, browserslist@^4.20.3:
     node-releases "^2.0.3"
     picocolors "^1.0.0"
 
-buble@^0.20.0:
-  version "0.20.0"
-  resolved "https://registry.yarnpkg.com/buble/-/buble-0.20.0.tgz#a143979a8d968b7f76b57f38f2e7ce7cfe938d1f"
-  integrity sha512-/1gnaMQE8xvd5qsNBl+iTuyjJ9XxeaVxAMF86dQ4EyxFJOZtsgOS8Ra+7WHgZTam5IFDtt4BguN0sH0tVTKrOw==
-  dependencies:
-    acorn "^6.4.1"
-    acorn-dynamic-import "^4.0.0"
-    acorn-jsx "^5.2.0"
-    chalk "^2.4.2"
-    magic-string "^0.25.7"
-    minimist "^1.2.5"
-    regexpu-core "4.5.4"
-
 buffer-alloc-unsafe@^1.1.0:
   version "1.1.0"
   resolved "https://registry.yarnpkg.com/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz#bd7dc26ae2972d0eda253be061dba992349c19f0"
@@ -2620,17 +2451,6 @@ chai-nightwatch@0.5.3:
   dependencies:
     assertion-error "1.1.0"
 
-chalk@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98"
-  integrity sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=
-  dependencies:
-    ansi-styles "^2.2.1"
-    escape-string-regexp "^1.0.2"
-    has-ansi "^2.0.0"
-    strip-ansi "^3.0.0"
-    supports-color "^2.0.0"
-
 chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.4.1, chalk@^2.4.2:
   version "2.4.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
@@ -3185,11 +3005,6 @@ core-js-compat@^3.21.0, core-js-compat@^3.22.1:
     browserslist "^4.20.3"
     semver "7.0.0"
 
-core-js@^2.4.0:
-  version "2.6.12"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.12.tgz#d9333dfa7b065e347cc5682219d6f690859cc2ec"
-  integrity sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==
-
 core-js@^3.6.5:
   version "3.22.3"
   resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.22.3.tgz#498c41d997654cb00e81c7a54b44f0ab21ab01d5"
@@ -3419,7 +3234,7 @@ de-indent@^1.0.2:
   resolved "https://registry.yarnpkg.com/de-indent/-/de-indent-1.0.2.tgz#b2038e846dc33baa5796128d0804b455b8c1e21d"
   integrity sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=
 
-debug@2.6.9, debug@^2.6.8, debug@^2.6.9:
+debug@2.6.9, debug@^2.6.9:
   version "2.6.9"
   resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
   integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
@@ -3968,14 +3783,6 @@ escodegen@^2.0.0:
   optionalDependencies:
     source-map "~0.6.1"
 
-eslint-plugin-flowtype@^8.0.3:
-  version "8.0.3"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-flowtype/-/eslint-plugin-flowtype-8.0.3.tgz#e1557e37118f24734aa3122e7536a038d34a4912"
-  integrity sha512-dX8l6qUL6O+fYPtpNRideCFSpmWOUVx5QcaGLVqe/vlDiBSe4vYljDWDETwnyFzpl7By/WVIu6rcrniCgH9BqQ==
-  dependencies:
-    lodash "^4.17.21"
-    string-natural-compare "^3.0.1"
-
 eslint-plugin-jasmine@^4.1.3:
   version "4.1.3"
   resolved "https://registry.yarnpkg.com/eslint-plugin-jasmine/-/eslint-plugin-jasmine-4.1.3.tgz#c4ced986a61dd5b180982bafe6da1cbac0941c52"
@@ -4488,11 +4295,6 @@ flatted@^3.1.0, flatted@^3.2.5:
   resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.5.tgz#76c8584f4fc843db64702a6bd04ab7a8bd666da3"
   integrity sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==
 
-flow-bin@^0.176.3:
-  version "0.176.3"
-  resolved "https://registry.yarnpkg.com/flow-bin/-/flow-bin-0.176.3.tgz#d32de04e044ab474afe543b9fd245608bb6a6ac8"
-  integrity sha512-lbNqgjr2GlGLAEVp5+dhG4LdnFE7ekbvVNifAdlvTx58/nE8GrCOMiUwEQy4dLnfL2NIRMk2dbEVTrugeQJ3mA==
-
 follow-redirects@^1.0.0, follow-redirects@^1.14.4:
   version "1.14.9"
   resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.9.tgz#dd4ea157de7bfaf9ea9b3fbd85aa16951f78d8d7"
@@ -4823,11 +4625,6 @@ globals@^13.6.0, globals@^13.9.0:
   dependencies:
     type-fest "^0.20.2"
 
-globals@^9.18.0:
-  version "9.18.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-9.18.0.tgz#aa3896b3e69b487f17e31ed2143d69a8e30c2d8a"
-  integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==
-
 globalthis@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/globalthis/-/globalthis-1.0.2.tgz#2a235d34f4d8036219f7e34929b5de9e18166b8b"
@@ -4932,13 +4729,6 @@ hard-rejection@^2.1.0:
   resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
   integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==
 
-has-ansi@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91"
-  integrity sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=
-  dependencies:
-    ansi-regex "^2.0.0"
-
 has-bigints@^1.0.1, has-bigints@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa"
@@ -5301,13 +5091,6 @@ into-stream@^3.1.0:
     from2 "^2.1.1"
     p-is-promise "^1.1.0"
 
-invariant@^2.2.2:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.4.tgz#610f3c92c9359ce1db616e538008d23ff35158e6"
-  integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==
-  dependencies:
-    loose-envify "^1.0.0"
-
 ip-regex@^4.1.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-4.3.0.tgz#687275ab0f57fa76978ff8f4dddc8a23d5990db5"
@@ -5728,16 +5511,11 @@ jest-worker@^27.4.5:
     merge-stream "^2.0.0"
     supports-color "^8.0.0"
 
-"js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0:
+js-tokens@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
   integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
 
-js-tokens@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.2.tgz#9866df395102130e38f7f996bceb65443209c25b"
-  integrity sha1-mGbfOVECEw449/mWvOtlRDIJwls=
-
 js-yaml@3.14.1, js-yaml@^3.13.1:
   version "3.14.1"
   resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
@@ -6384,7 +6162,7 @@ lodash.zip@^4.2.0:
   resolved "https://registry.yarnpkg.com/lodash.zip/-/lodash.zip-4.2.0.tgz#ec6662e4896408ed4ab6c542a3990b72cc080020"
   integrity sha1-7GZi5IlkCO1KtsVCo5kLcswIACA=
 
-lodash@^4.0.1, lodash@^4.17.12, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21, lodash@^4.17.4:
+lodash@^4.0.1, lodash@^4.17.12, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21:
   version "4.17.21"
   resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
   integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
@@ -6440,13 +6218,6 @@ longest@^2.0.1:
   resolved "https://registry.yarnpkg.com/longest/-/longest-2.0.1.tgz#781e183296aa94f6d4d916dc335d0d17aefa23f8"
   integrity sha1-eB4YMpaqlPbU2RbcM10NF676I/g=
 
-loose-envify@^1.0.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf"
-  integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==
-  dependencies:
-    js-tokens "^3.0.0 || ^4.0.0"
-
 loupe@2.3.4:
   version "2.3.4"
   resolved "https://registry.yarnpkg.com/loupe/-/loupe-2.3.4.tgz#7e0b9bffc76f148f9be769cb1321d3dcf3cb25f3"
@@ -7728,23 +7499,11 @@ regenerate-unicode-properties@^10.0.1:
   dependencies:
     regenerate "^1.4.2"
 
-regenerate-unicode-properties@^8.0.2:
-  version "8.2.0"
-  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz#e5de7111d655e7ba60c057dbe9ff37c87e65cdec"
-  integrity sha512-F9DjY1vKLo/tPePDycuH3dn9H1OTPIkVD9Kz4LODu+F2C75mgjAJ7x/gwy6ZcSNRAAkhNlJSOHRe8k3p+K9WhA==
-  dependencies:
-    regenerate "^1.4.0"
-
-regenerate@^1.4.0, regenerate@^1.4.2:
+regenerate@^1.4.2:
   version "1.4.2"
   resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
   integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
 
-regenerator-runtime@^0.11.0:
-  version "0.11.1"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz#be05ad7f9bf7d22e056f9726cee5017fbf19e2e9"
-  integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==
-
 regenerator-runtime@^0.13.4:
   version "0.13.9"
   resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz#8925742a98ffd90814988d7566ad30ca3b263b52"
@@ -7762,18 +7521,6 @@ regexpp@^3.2.0:
   resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
   integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==
 
-regexpu-core@4.5.4:
-  version "4.5.4"
-  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-4.5.4.tgz#080d9d02289aa87fe1667a4f5136bc98a6aebaae"
-  integrity sha512-BtizvGtFQKGPUcTy56o3nk1bGRp4SZOTYrDtGNlqCQufptV5IkkLN6Emw+yunAJjzf+C9FQFtvq7IoA3+oMYHQ==
-  dependencies:
-    regenerate "^1.4.0"
-    regenerate-unicode-properties "^8.0.2"
-    regjsgen "^0.5.0"
-    regjsparser "^0.6.0"
-    unicode-match-property-ecmascript "^1.0.4"
-    unicode-match-property-value-ecmascript "^1.1.0"
-
 regexpu-core@^5.0.1:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-5.0.1.tgz#c531122a7840de743dcf9c83e923b5560323ced3"
@@ -7786,23 +7533,11 @@ regexpu-core@^5.0.1:
     unicode-match-property-ecmascript "^2.0.0"
     unicode-match-property-value-ecmascript "^2.0.0"
 
-regjsgen@^0.5.0:
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.5.2.tgz#92ff295fb1deecbf6ecdab2543d207e91aa33733"
-  integrity sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==
-
 regjsgen@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.6.0.tgz#83414c5354afd7d6627b16af5f10f41c4e71808d"
   integrity sha512-ozE883Uigtqj3bx7OhL1KNbCzGyW2NQZPl6Hs09WTvCuZD5sTI4JY58bkbQWa/Y9hxIsvJ3M8Nbf7j54IqeZbA==
 
-regjsparser@^0.6.0:
-  version "0.6.9"
-  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.6.9.tgz#b489eef7c9a2ce43727627011429cf833a7183e6"
-  integrity sha512-ZqbNRz1SNjLAiYuwY0zoXW8Ne675IX5q+YHioAGbCw4X96Mjl2+dcX9B2ciaeyYjViDAfvIjFpQjJgLttTEERQ==
-  dependencies:
-    jsesc "~0.5.0"
-
 regjsparser@^0.8.2:
   version "0.8.4"
   resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.8.4.tgz#8a14285ffcc5de78c5b95d62bbf413b6bc132d5f"
@@ -8509,11 +8244,6 @@ string-argv@^0.3.1:
   resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.3.1.tgz#95e2fbec0427ae19184935f816d74aaa4c5c19da"
   integrity sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==
 
-string-natural-compare@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/string-natural-compare/-/string-natural-compare-3.0.1.tgz#7a42d58474454963759e8e8b7ae63d71c1e7fdf4"
-  integrity sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw==
-
 string-width@^2.1.0:
   version "2.1.1"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
@@ -8577,13 +8307,6 @@ strip-ansi@6.0.1, strip-ansi@^6.0.0, strip-ansi@^6.0.1:
   dependencies:
     ansi-regex "^5.0.1"
 
-strip-ansi@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf"
-  integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=
-  dependencies:
-    ansi-regex "^2.0.0"
-
 strip-ansi@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
@@ -8673,11 +8396,6 @@ supports-color@8.1.1, supports-color@^8.0.0:
   dependencies:
     has-flag "^4.0.0"
 
-supports-color@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
-  integrity sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=
-
 supports-color@^5.3.0:
   version "5.5.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
@@ -8856,11 +8574,6 @@ to-buffer@^1.1.1:
   resolved "https://registry.yarnpkg.com/to-buffer/-/to-buffer-1.1.1.tgz#493bd48f62d7c43fcded313a03dcadb2e1213a80"
   integrity sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==
 
-to-fast-properties@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-1.0.3.tgz#b83571fa4d8c25b82e231b06e3a3055de4ca1a47"
-  integrity sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=
-
 to-fast-properties@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
@@ -9078,24 +8791,11 @@ unbzip2-stream@1.4.3, unbzip2-stream@^1.0.9, unbzip2-stream@^1.3.3:
     buffer "^5.2.1"
     through "^2.3.8"
 
-unicode-canonical-property-names-ecmascript@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-1.0.4.tgz#2619800c4c825800efdd8343af7dd9933cbe2818"
-  integrity sha512-jDrNnXWHd4oHiTZnx/ZG7gtUTVp+gCcTTKr8L0HjlwphROEW3+Him+IpvC+xcJEFegapiMZyZe02CyuOnRmbnQ==
-
 unicode-canonical-property-names-ecmascript@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz#301acdc525631670d39f6146e0e77ff6bbdebddc"
   integrity sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==
 
-unicode-match-property-ecmascript@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-1.0.4.tgz#8ed2a32569961bce9227d09cd3ffbb8fed5f020c"
-  integrity sha512-L4Qoh15vTfntsn4P1zqnHulG0LdXgjSO035fEpdtp6YxXhMT51Q6vgM5lYdG/5X3MjS+k/Y9Xw4SFCY9IkR0rg==
-  dependencies:
-    unicode-canonical-property-names-ecmascript "^1.0.4"
-    unicode-property-aliases-ecmascript "^1.0.4"
-
 unicode-match-property-ecmascript@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz#54fd16e0ecb167cf04cf1f756bdcc92eba7976c3"
@@ -9104,21 +8804,11 @@ unicode-match-property-ecmascript@^2.0.0:
     unicode-canonical-property-names-ecmascript "^2.0.0"
     unicode-property-aliases-ecmascript "^2.0.0"
 
-unicode-match-property-value-ecmascript@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz#0d91f600eeeb3096aa962b1d6fc88876e64ea531"
-  integrity sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==
-
 unicode-match-property-value-ecmascript@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.0.0.tgz#1a01aa57247c14c568b89775a54938788189a714"
   integrity sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==
 
-unicode-property-aliases-ecmascript@^1.0.4:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz#dd57a99f6207bedff4628abefb94c50db941c8f4"
-  integrity sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==
-
 unicode-property-aliases-ecmascript@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.0.0.tgz#0a36cb9a585c4f6abd51ad1deddb285c165297c8"

From 4d1d0f0a82c5aa109a74b52782daabb442f8ead3 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:18:36 +0800
Subject: [PATCH 034/317] chore: fix dev scripts

---
 package.json | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/package.json b/package.json
index 5bbb9aedb1e..15e3e3c8b05 100644
--- a/package.json
+++ b/package.json
@@ -14,15 +14,15 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "dev": "rollup -w -c scripts/config.ts --environment TARGET:web-full-dev",
-    "dev:cjs": "rollup -w -c scripts/config.ts --environment TARGET:web-runtime-cjs-dev",
-    "dev:esm": "rollup -w -c scripts/config.ts --environment TARGET:web-runtime-esm",
+    "dev": "rollup -w -c scripts/config.js --environment TARGET:web-full-dev",
+    "dev:cjs": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-cjs-dev",
+    "dev:esm": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-esm",
     "dev:test": "karma start test/unit/karma.dev.config.ts",
-    "dev:ssr": "rollup -w -c scripts/config.ts --environment TARGET:web-server-renderer",
-    "dev:compiler": "rollup -w -c scripts/config.ts --environment TARGET:web-compiler ",
-    "dev:weex": "rollup -w -c scripts/config.ts --environment TARGET:weex-framework",
-    "dev:weex:factory": "rollup -w -c scripts/config.ts --environment TARGET:weex-factory",
-    "dev:weex:compiler": "rollup -w -c scripts/config.ts --environment TARGET:weex-compiler ",
+    "dev:ssr": "rollup -w -c scripts/config.js --environment TARGET:web-server-renderer",
+    "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:web-compiler ",
+    "dev:weex": "rollup -w -c scripts/config.js --environment TARGET:weex-framework",
+    "dev:weex:factory": "rollup -w -c scripts/config.js --environment TARGET:weex-factory",
+    "dev:weex:compiler": "rollup -w -c scripts/config.js --environment TARGET:weex-compiler ",
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
     "build:weex": "npm run build -- weex",

From 0b560770806b1da0ea2bfdc4c01dbceded7b6e96 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:29:22 +0800
Subject: [PATCH 035/317] build: remove deps

---
 package.json                                  |   45 +-
 pnpm-lock.yaml                                | 4033 +++++++
 .../component/component-async.spec.ts         |    1 -
 tsconfig.json                                 |    8 +-
 yarn.lock                                     | 9337 -----------------
 5 files changed, 4036 insertions(+), 9388 deletions(-)
 create mode 100644 pnpm-lock.yaml
 delete mode 100644 yarn.lock

diff --git a/package.json b/package.json
index 15e3e3c8b05..424115ec7d9 100644
--- a/package.json
+++ b/package.json
@@ -67,87 +67,44 @@
   },
   "homepage": "https://github.com/vuejs/vue#readme",
   "devDependencies": {
-    "@babel/core": "^7.17.10",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-syntax-jsx": "^7.16.7",
-    "@babel/preset-env": "^7.17.10",
-    "@babel/preset-typescript": "^7.16.7",
-    "@babel/register": "^7.17.7",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-node-resolve": "^13.2.1",
     "@rollup/plugin-replace": "^4.0.0",
     "@types/he": "^1.1.2",
-    "@types/jasmine": "^4.0.3",
     "@types/node": "^17.0.30",
-    "@types/webpack": "^5.28.0",
-    "@types/webpack-env": "^1.16.4",
     "@typescript-eslint/eslint-plugin": "^5.21.0",
     "@typescript-eslint/parser": "^5.21.0",
     "acorn": "^8.7.1",
     "acorn-walk": "^8.2.0",
-    "babel-eslint": "^10.1.0",
-    "babel-helper-vue-jsx-merge-props": "^2.0.3",
-    "babel-loader": "^8.2.5",
-    "babel-plugin-istanbul": "^6.1.1",
-    "babel-plugin-transform-require-context": "^0.1.1",
-    "babel-plugin-transform-vue-jsx": "^4.0.1",
     "chalk": "^4.0.0",
-    "chromedriver": "^100.0.0",
-    "codecov": "^3.8.3",
     "commitizen": "^4.2.4",
     "conventional-changelog": "^3.1.25",
     "cross-spawn": "^7.0.3",
     "cz-conventional-changelog": "^3.3.0",
     "de-indent": "^1.0.2",
-    "es6-promise": "^4.2.8",
     "escodegen": "^2.0.0",
     "eslint": "^8.14.0",
-    "eslint-plugin-jasmine": "^4.1.3",
-    "file-loader": "^6.2.0",
     "fsevents": "2.3.2",
     "hash-sum": "^2.0.0",
     "he": "^1.1.1",
     "http-server": "^14.1.0",
-    "jasmine": "^4.1.0",
-    "jasmine-core": "^4.1.0",
-    "jasmine-ts": "^0.4.0",
-    "karma": "^6.3.19",
-    "karma-chrome-launcher": "^3.1.1",
-    "karma-coverage": "^2.2.0",
-    "karma-firefox-launcher": "^2.1.2",
-    "karma-jasmine": "^5.0.0",
-    "karma-mocha-reporter": "^2.2.3",
-    "karma-phantomjs-launcher": "^1.0.4",
-    "karma-safari-launcher": "^1.0.0",
-    "karma-sauce-launcher": "^4.3.6",
-    "karma-sourcemap-loader": "^0.3.8",
-    "karma-typescript": "^5.5.3",
-    "karma-typescript-es6-transform": "^5.5.3",
-    "karma-webpack": "^5.0.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
     "lodash.template": "^4.4.0",
     "lodash.uniq": "^4.5.0",
     "lru-cache": "^7.8.1",
-    "nightwatch": "^2.1.3",
-    "nightwatch-helpers": "^1.2.0",
-    "phantomjs-prebuilt": "^2.1.14",
-    "puppeteer": "^13.7.0",
     "resolve": "^1.22.0",
     "rollup": "^2.70.2",
     "rollup-plugin-typescript2": "^0.31.2",
-    "selenium-server": "^3.141.59",
     "serialize-javascript": "^6.0.0",
     "shelljs": "^0.8.5",
     "stream-browserify": "^3.0.0",
     "terser": "^5.13.1",
-    "ts-loader": "^9.2.9",
     "ts-node": "^10.7.0",
     "tslib": "^2.4.0",
     "typescript": "^4.6.4",
-    "webpack": "~5.72.0",
+    "vitest": "^0.12.6",
     "weex-js-runtime": "^0.23.6",
     "weex-styler": "^0.3.0",
     "yorkie": "^2.0.0"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
new file mode 100644
index 00000000000..850f9c23dfc
--- /dev/null
+++ b/pnpm-lock.yaml
@@ -0,0 +1,4033 @@
+lockfileVersion: 5.4
+
+specifiers:
+  '@rollup/plugin-alias': ^3.1.9
+  '@rollup/plugin-commonjs': ^22.0.0
+  '@rollup/plugin-node-resolve': ^13.2.1
+  '@rollup/plugin-replace': ^4.0.0
+  '@types/he': ^1.1.2
+  '@types/node': ^17.0.30
+  '@typescript-eslint/eslint-plugin': ^5.21.0
+  '@typescript-eslint/parser': ^5.21.0
+  acorn: ^8.7.1
+  acorn-walk: ^8.2.0
+  chalk: ^4.0.0
+  commitizen: ^4.2.4
+  conventional-changelog: ^3.1.25
+  cross-spawn: ^7.0.3
+  cz-conventional-changelog: ^3.3.0
+  de-indent: ^1.0.2
+  escodegen: ^2.0.0
+  eslint: ^8.14.0
+  fsevents: 2.3.2
+  hash-sum: ^2.0.0
+  he: ^1.1.1
+  http-server: ^14.1.0
+  lint-staged: ^12.4.1
+  lodash: ^4.17.21
+  lodash.template: ^4.4.0
+  lodash.uniq: ^4.5.0
+  lru-cache: ^7.8.1
+  resolve: ^1.22.0
+  rollup: ^2.70.2
+  rollup-plugin-typescript2: ^0.31.2
+  serialize-javascript: ^6.0.0
+  shelljs: ^0.8.5
+  stream-browserify: ^3.0.0
+  terser: ^5.13.1
+  ts-node: ^10.7.0
+  tslib: ^2.4.0
+  typescript: ^4.6.4
+  vitest: ^0.12.6
+  weex-js-runtime: ^0.23.6
+  weex-styler: ^0.3.0
+  yorkie: ^2.0.0
+
+devDependencies:
+  '@rollup/plugin-alias': 3.1.9_rollup@2.74.0
+  '@rollup/plugin-commonjs': 22.0.0_rollup@2.74.0
+  '@rollup/plugin-node-resolve': 13.3.0_rollup@2.74.0
+  '@rollup/plugin-replace': 4.0.0_rollup@2.74.0
+  '@types/he': 1.1.2
+  '@types/node': 17.0.34
+  '@typescript-eslint/eslint-plugin': 5.25.0_qo2hgs5jt7x2a3p77h2rutcdae
+  '@typescript-eslint/parser': 5.25.0_hcfsmds2fshutdssjqluwm76uu
+  acorn: 8.7.1
+  acorn-walk: 8.2.0
+  chalk: 4.1.2
+  commitizen: 4.2.4
+  conventional-changelog: 3.1.25
+  cross-spawn: 7.0.3
+  cz-conventional-changelog: 3.3.0
+  de-indent: 1.0.2
+  escodegen: 2.0.0
+  eslint: 8.15.0
+  fsevents: 2.3.2
+  hash-sum: 2.0.0
+  he: 1.2.0
+  http-server: 14.1.0
+  lint-staged: 12.4.1
+  lodash: 4.17.21
+  lodash.template: 4.5.0
+  lodash.uniq: 4.5.0
+  lru-cache: 7.10.1
+  resolve: 1.22.0
+  rollup: 2.74.0
+  rollup-plugin-typescript2: 0.31.2_dyu3set7imqii5ytavmnwecwpy
+  serialize-javascript: 6.0.0
+  shelljs: 0.8.5
+  stream-browserify: 3.0.0
+  terser: 5.13.1
+  ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
+  tslib: 2.4.0
+  typescript: 4.6.4
+  vitest: 0.12.6
+  weex-js-runtime: 0.23.7
+  weex-styler: 0.3.1
+  yorkie: 2.0.0
+
+packages:
+
+  /@babel/code-frame/7.16.7:
+    resolution: {integrity: sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/highlight': 7.17.12
+    dev: true
+
+  /@babel/helper-validator-identifier/7.16.7:
+    resolution: {integrity: sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/highlight/7.17.12:
+    resolution: {integrity: sha512-7yykMVF3hfZY2jsHZEEgLc+3x4o1O+fYyULu11GynEUQNwB6lua+IIQn1FiJxNucd5UlyJryrwsOh8PL9Sn8Qg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.16.7
+      chalk: 2.4.2
+      js-tokens: 4.0.0
+    dev: true
+
+  /@commitlint/config-validator/17.0.0:
+    resolution: {integrity: sha512-78IQjoZWR4kDHp/U5y17euEWzswJpPkA9TDL5F6oZZZaLIEreWzrDZD5PWtM8MsSRl/K2LDU/UrzYju2bKLMpA==}
+    engines: {node: '>=v14'}
+    dependencies:
+      '@commitlint/types': 17.0.0
+      ajv: 6.12.6
+    dev: true
+    optional: true
+
+  /@commitlint/execute-rule/17.0.0:
+    resolution: {integrity: sha512-nVjL/w/zuqjCqSJm8UfpNaw66V9WzuJtQvEnCrK4jDw6qKTmZB+1JQ8m6BQVZbNBcwfYdDNKnhIhqI0Rk7lgpQ==}
+    engines: {node: '>=v14'}
+    dev: true
+    optional: true
+
+  /@commitlint/load/17.0.0:
+    resolution: {integrity: sha512-XaiHF4yWQOPAI0O6wXvk+NYLtJn/Xb7jgZEeKd4C1ZWd7vR7u8z5h0PkWxSr0uLZGQsElGxv3fiZ32C5+q6M8w==}
+    engines: {node: '>=v14'}
+    requiresBuild: true
+    dependencies:
+      '@commitlint/config-validator': 17.0.0
+      '@commitlint/execute-rule': 17.0.0
+      '@commitlint/resolve-extends': 17.0.0
+      '@commitlint/types': 17.0.0
+      '@types/node': 17.0.34
+      chalk: 4.1.2
+      cosmiconfig: 7.0.1
+      cosmiconfig-typescript-loader: 2.0.0_3smuweqyuzdazdnyhhezld6mfa
+      lodash: 4.17.21
+      resolve-from: 5.0.0
+      typescript: 4.6.4
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+    dev: true
+    optional: true
+
+  /@commitlint/resolve-extends/17.0.0:
+    resolution: {integrity: sha512-wi60WiJmwaQ7lzMXK8Vbc18Hq9tE2j/6iv2AFfPUGV7fvfY6Sf1iNKuUHirSqR0fquUyufIXe4y/K9A6LVIIvw==}
+    engines: {node: '>=v14'}
+    dependencies:
+      '@commitlint/config-validator': 17.0.0
+      '@commitlint/types': 17.0.0
+      import-fresh: 3.3.0
+      lodash: 4.17.21
+      resolve-from: 5.0.0
+      resolve-global: 1.0.0
+    dev: true
+    optional: true
+
+  /@commitlint/types/17.0.0:
+    resolution: {integrity: sha512-hBAw6U+SkAT5h47zDMeOu3HSiD0SODw4Aq7rRNh1ceUmL7GyLKYhPbUvlRWqZ65XjBLPHZhFyQlRaPNz8qvUyQ==}
+    engines: {node: '>=v14'}
+    dependencies:
+      chalk: 4.1.2
+    dev: true
+    optional: true
+
+  /@cspotcode/source-map-consumer/0.8.0:
+    resolution: {integrity: sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg==}
+    engines: {node: '>= 12'}
+    dev: true
+
+  /@cspotcode/source-map-support/0.7.0:
+    resolution: {integrity: sha512-X4xqRHqN8ACt2aHVe51OxeA2HjbcL4MqFqXkrmQszJ1NOUuUu5u6Vqx/0lZSVNku7velL5FC/s5uEAj1lsBMhA==}
+    engines: {node: '>=12'}
+    dependencies:
+      '@cspotcode/source-map-consumer': 0.8.0
+    dev: true
+
+  /@eslint/eslintrc/1.2.3:
+    resolution: {integrity: sha512-uGo44hIwoLGNyduRpjdEpovcbMdd+Nv7amtmJxnKmI8xj6yd5LncmSwDa5NgX/41lIFJtkjD6YdVfgEzPfJ5UA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dependencies:
+      ajv: 6.12.6
+      debug: 4.3.4
+      espree: 9.3.2
+      globals: 13.15.0
+      ignore: 5.2.0
+      import-fresh: 3.3.0
+      js-yaml: 4.1.0
+      minimatch: 3.1.2
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@humanwhocodes/config-array/0.9.5:
+    resolution: {integrity: sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==}
+    engines: {node: '>=10.10.0'}
+    dependencies:
+      '@humanwhocodes/object-schema': 1.2.1
+      debug: 4.3.4
+      minimatch: 3.1.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@humanwhocodes/object-schema/1.2.1:
+    resolution: {integrity: sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==}
+    dev: true
+
+  /@hutson/parse-repository-url/3.0.2:
+    resolution: {integrity: sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@nodelib/fs.scandir/2.1.5:
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+    dev: true
+
+  /@nodelib/fs.stat/2.0.5:
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+    dev: true
+
+  /@nodelib/fs.walk/1.2.8:
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.13.0
+    dev: true
+
+  /@rollup/plugin-alias/3.1.9_rollup@2.74.0:
+    resolution: {integrity: sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==}
+    engines: {node: '>=8.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0||^2.0.0
+    dependencies:
+      rollup: 2.74.0
+      slash: 3.0.0
+    dev: true
+
+  /@rollup/plugin-commonjs/22.0.0_rollup@2.74.0:
+    resolution: {integrity: sha512-Ktvf2j+bAO+30awhbYoCaXpBcyPmJbaEUYClQns/+6SNCYFURbvBiNbWgHITEsIgDDWCDUclWRKEuf8cwZCFoQ==}
+    engines: {node: '>= 12.0.0'}
+    peerDependencies:
+      rollup: ^2.68.0
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.74.0
+      commondir: 1.0.1
+      estree-walker: 2.0.2
+      glob: 7.2.3
+      is-reference: 1.2.1
+      magic-string: 0.25.9
+      resolve: 1.22.0
+      rollup: 2.74.0
+    dev: true
+
+  /@rollup/plugin-node-resolve/13.3.0_rollup@2.74.0:
+    resolution: {integrity: sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==}
+    engines: {node: '>= 10.0.0'}
+    peerDependencies:
+      rollup: ^2.42.0
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.74.0
+      '@types/resolve': 1.17.1
+      deepmerge: 4.2.2
+      is-builtin-module: 3.1.0
+      is-module: 1.0.0
+      resolve: 1.22.0
+      rollup: 2.74.0
+    dev: true
+
+  /@rollup/plugin-replace/4.0.0_rollup@2.74.0:
+    resolution: {integrity: sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==}
+    peerDependencies:
+      rollup: ^1.20.0 || ^2.0.0
+    dependencies:
+      '@rollup/pluginutils': 3.1.0_rollup@2.74.0
+      magic-string: 0.25.9
+      rollup: 2.74.0
+    dev: true
+
+  /@rollup/pluginutils/3.1.0_rollup@2.74.0:
+    resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==}
+    engines: {node: '>= 8.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0||^2.0.0
+    dependencies:
+      '@types/estree': 0.0.39
+      estree-walker: 1.0.1
+      picomatch: 2.3.1
+      rollup: 2.74.0
+    dev: true
+
+  /@rollup/pluginutils/4.2.1:
+    resolution: {integrity: sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==}
+    engines: {node: '>= 8.0.0'}
+    dependencies:
+      estree-walker: 2.0.2
+      picomatch: 2.3.1
+    dev: true
+
+  /@tsconfig/node10/1.0.8:
+    resolution: {integrity: sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg==}
+    dev: true
+
+  /@tsconfig/node12/1.0.9:
+    resolution: {integrity: sha512-/yBMcem+fbvhSREH+s14YJi18sp7J9jpuhYByADT2rypfajMZZN4WQ6zBGgBKp53NKmqI36wFYDb3yaMPurITw==}
+    dev: true
+
+  /@tsconfig/node14/1.0.1:
+    resolution: {integrity: sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg==}
+    dev: true
+
+  /@tsconfig/node16/1.0.2:
+    resolution: {integrity: sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==}
+    dev: true
+
+  /@types/chai-subset/1.3.3:
+    resolution: {integrity: sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==}
+    dependencies:
+      '@types/chai': 4.3.1
+    dev: true
+
+  /@types/chai/4.3.1:
+    resolution: {integrity: sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ==}
+    dev: true
+
+  /@types/estree/0.0.39:
+    resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==}
+    dev: true
+
+  /@types/estree/0.0.51:
+    resolution: {integrity: sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==}
+    dev: true
+
+  /@types/he/1.1.2:
+    resolution: {integrity: sha512-kSJPcLO1x+oolc0R89pUl2kozldQ/fVQ1C1p5mp8fPoLdF/ZcBvckaTC2M8xXh3GYendXvCpy5m/a2eSbfgNgw==}
+    dev: true
+
+  /@types/json-schema/7.0.11:
+    resolution: {integrity: sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==}
+    dev: true
+
+  /@types/minimist/1.2.2:
+    resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==}
+    dev: true
+
+  /@types/node/17.0.34:
+    resolution: {integrity: sha512-XImEz7XwTvDBtzlTnm8YvMqGW/ErMWBsKZ+hMTvnDIjGCKxwK5Xpc+c/oQjOauwq8M4OS11hEkpjX8rrI/eEgA==}
+    dev: true
+
+  /@types/normalize-package-data/2.4.1:
+    resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
+    dev: true
+
+  /@types/parse-json/4.0.0:
+    resolution: {integrity: sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==}
+    dev: true
+    optional: true
+
+  /@types/resolve/1.17.1:
+    resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==}
+    dependencies:
+      '@types/node': 17.0.34
+    dev: true
+
+  /@typescript-eslint/eslint-plugin/5.25.0_qo2hgs5jt7x2a3p77h2rutcdae:
+    resolution: {integrity: sha512-icYrFnUzvm+LhW0QeJNKkezBu6tJs9p/53dpPLFH8zoM9w1tfaKzVurkPotEpAqQ8Vf8uaFyL5jHd0Vs6Z0ZQg==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      '@typescript-eslint/parser': ^5.0.0
+      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/parser': 5.25.0_hcfsmds2fshutdssjqluwm76uu
+      '@typescript-eslint/scope-manager': 5.25.0
+      '@typescript-eslint/type-utils': 5.25.0_hcfsmds2fshutdssjqluwm76uu
+      '@typescript-eslint/utils': 5.25.0_hcfsmds2fshutdssjqluwm76uu
+      debug: 4.3.4
+      eslint: 8.15.0
+      functional-red-black-tree: 1.0.1
+      ignore: 5.2.0
+      regexpp: 3.2.0
+      semver: 7.3.7
+      tsutils: 3.21.0_typescript@4.6.4
+      typescript: 4.6.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@typescript-eslint/parser/5.25.0_hcfsmds2fshutdssjqluwm76uu:
+    resolution: {integrity: sha512-r3hwrOWYbNKP1nTcIw/aZoH+8bBnh/Lh1iDHoFpyG4DnCpvEdctrSl6LOo19fZbzypjQMHdajolxs6VpYoChgA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/scope-manager': 5.25.0
+      '@typescript-eslint/types': 5.25.0
+      '@typescript-eslint/typescript-estree': 5.25.0_typescript@4.6.4
+      debug: 4.3.4
+      eslint: 8.15.0
+      typescript: 4.6.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@typescript-eslint/scope-manager/5.25.0:
+    resolution: {integrity: sha512-p4SKTFWj+2VpreUZ5xMQsBMDdQ9XdRvODKXN4EksyBjFp2YvQdLkyHqOffakYZPuWJUDNu3jVXtHALDyTv3cww==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dependencies:
+      '@typescript-eslint/types': 5.25.0
+      '@typescript-eslint/visitor-keys': 5.25.0
+    dev: true
+
+  /@typescript-eslint/type-utils/5.25.0_hcfsmds2fshutdssjqluwm76uu:
+    resolution: {integrity: sha512-B6nb3GK3Gv1Rsb2pqalebe/RyQoyG/WDy9yhj8EE0Ikds4Xa8RR28nHz+wlt4tMZk5bnAr0f3oC8TuDAd5CPrw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: '*'
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/utils': 5.25.0_hcfsmds2fshutdssjqluwm76uu
+      debug: 4.3.4
+      eslint: 8.15.0
+      tsutils: 3.21.0_typescript@4.6.4
+      typescript: 4.6.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@typescript-eslint/types/5.25.0:
+    resolution: {integrity: sha512-7fWqfxr0KNHj75PFqlGX24gWjdV/FDBABXL5dyvBOWHpACGyveok8Uj4ipPX/1fGU63fBkzSIycEje4XsOxUFA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dev: true
+
+  /@typescript-eslint/typescript-estree/5.25.0_typescript@4.6.4:
+    resolution: {integrity: sha512-MrPODKDych/oWs/71LCnuO7NyR681HuBly2uLnX3r5i4ME7q/yBqC4hW33kmxtuauLTM0OuBOhhkFaxCCOjEEw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/types': 5.25.0
+      '@typescript-eslint/visitor-keys': 5.25.0
+      debug: 4.3.4
+      globby: 11.1.0
+      is-glob: 4.0.3
+      semver: 7.3.7
+      tsutils: 3.21.0_typescript@4.6.4
+      typescript: 4.6.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@typescript-eslint/utils/5.25.0_hcfsmds2fshutdssjqluwm76uu:
+    resolution: {integrity: sha512-qNC9bhnz/n9Kba3yI6HQgQdBLuxDoMgdjzdhSInZh6NaDnFpTUlwNGxplUFWfY260Ya0TRPvkg9dd57qxrJI9g==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+    dependencies:
+      '@types/json-schema': 7.0.11
+      '@typescript-eslint/scope-manager': 5.25.0
+      '@typescript-eslint/types': 5.25.0
+      '@typescript-eslint/typescript-estree': 5.25.0_typescript@4.6.4
+      eslint: 8.15.0
+      eslint-scope: 5.1.1
+      eslint-utils: 3.0.0_eslint@8.15.0
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+    dev: true
+
+  /@typescript-eslint/visitor-keys/5.25.0:
+    resolution: {integrity: sha512-yd26vFgMsC4h2dgX4+LR+GeicSKIfUvZREFLf3DDjZPtqgLx5AJZr6TetMNwFP9hcKreTTeztQYBTNbNoOycwA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dependencies:
+      '@typescript-eslint/types': 5.25.0
+      eslint-visitor-keys: 3.3.0
+    dev: true
+
+  /@yarn-tool/resolve-package/1.0.47:
+    resolution: {integrity: sha512-Zaw58gQxjQceJqhqybJi1oUDaORT8i2GTgwICPs8v/X/Pkx35FXQba69ldHVg5pQZ6YLKpROXgyHvBaCJOFXiA==}
+    dependencies:
+      pkg-dir: 5.0.0
+      tslib: 2.4.0
+      upath2: 3.1.13
+    dev: true
+
+  /JSONStream/1.3.5:
+    resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==}
+    hasBin: true
+    dependencies:
+      jsonparse: 1.3.1
+      through: 2.3.8
+    dev: true
+
+  /acorn-jsx/5.3.2_acorn@8.7.1:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+    dependencies:
+      acorn: 8.7.1
+    dev: true
+
+  /acorn-walk/8.2.0:
+    resolution: {integrity: sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==}
+    engines: {node: '>=0.4.0'}
+    dev: true
+
+  /acorn/8.7.1:
+    resolution: {integrity: sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+    dev: true
+
+  /add-stream/1.0.0:
+    resolution: {integrity: sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ==}
+    dev: true
+
+  /aggregate-error/3.1.0:
+    resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==}
+    engines: {node: '>=8'}
+    dependencies:
+      clean-stack: 2.2.0
+      indent-string: 4.0.0
+    dev: true
+
+  /ajv/6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+    dev: true
+
+  /ansi-escapes/3.2.0:
+    resolution: {integrity: sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /ansi-escapes/4.3.2:
+    resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      type-fest: 0.21.3
+    dev: true
+
+  /ansi-regex/3.0.1:
+    resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /ansi-regex/4.1.1:
+    resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /ansi-regex/5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /ansi-regex/6.0.1:
+    resolution: {integrity: sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /ansi-styles/3.2.1:
+    resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
+    engines: {node: '>=4'}
+    dependencies:
+      color-convert: 1.9.3
+    dev: true
+
+  /ansi-styles/4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+    dependencies:
+      color-convert: 2.0.1
+    dev: true
+
+  /ansi-styles/6.1.0:
+    resolution: {integrity: sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /arg/4.1.3:
+    resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
+    dev: true
+
+  /argparse/2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+    dev: true
+
+  /array-ify/1.0.0:
+    resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}
+    dev: true
+
+  /array-union/2.1.0:
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /arrify/1.0.1:
+    resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /assertion-error/1.1.0:
+    resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==}
+    dev: true
+
+  /astral-regex/2.0.0:
+    resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /async/2.6.4:
+    resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==}
+    dependencies:
+      lodash: 4.17.21
+    dev: true
+
+  /atob/2.1.2:
+    resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
+    engines: {node: '>= 4.5.0'}
+    hasBin: true
+    dev: true
+
+  /balanced-match/1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+    dev: true
+
+  /basic-auth/2.0.1:
+    resolution: {integrity: sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      safe-buffer: 5.1.2
+    dev: true
+
+  /brace-expansion/1.1.11:
+    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+    dev: true
+
+  /braces/3.0.2:
+    resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}
+    engines: {node: '>=8'}
+    dependencies:
+      fill-range: 7.0.1
+    dev: true
+
+  /buffer-from/1.1.2:
+    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
+    dev: true
+
+  /builtin-modules/3.3.0:
+    resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /cachedir/2.2.0:
+    resolution: {integrity: sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /call-bind/1.0.2:
+    resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
+    dependencies:
+      function-bind: 1.1.1
+      get-intrinsic: 1.1.1
+    dev: true
+
+  /callsites/3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /camelcase-keys/6.2.2:
+    resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==}
+    engines: {node: '>=8'}
+    dependencies:
+      camelcase: 5.3.1
+      map-obj: 4.3.0
+      quick-lru: 4.0.1
+    dev: true
+
+  /camelcase/5.3.1:
+    resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /chai/4.3.6:
+    resolution: {integrity: sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==}
+    engines: {node: '>=4'}
+    dependencies:
+      assertion-error: 1.1.0
+      check-error: 1.0.2
+      deep-eql: 3.0.1
+      get-func-name: 2.0.0
+      loupe: 2.3.4
+      pathval: 1.1.1
+      type-detect: 4.0.8
+    dev: true
+
+  /chalk/2.4.2:
+    resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
+    engines: {node: '>=4'}
+    dependencies:
+      ansi-styles: 3.2.1
+      escape-string-regexp: 1.0.5
+      supports-color: 5.5.0
+    dev: true
+
+  /chalk/4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+    dev: true
+
+  /chardet/0.7.0:
+    resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==}
+    dev: true
+
+  /check-error/1.0.2:
+    resolution: {integrity: sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==}
+    dev: true
+
+  /ci-info/1.6.0:
+    resolution: {integrity: sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==}
+    dev: true
+
+  /clean-stack/2.2.0:
+    resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /cli-cursor/2.1.0:
+    resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==}
+    engines: {node: '>=4'}
+    dependencies:
+      restore-cursor: 2.0.0
+    dev: true
+
+  /cli-cursor/3.1.0:
+    resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==}
+    engines: {node: '>=8'}
+    dependencies:
+      restore-cursor: 3.1.0
+    dev: true
+
+  /cli-truncate/2.1.0:
+    resolution: {integrity: sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==}
+    engines: {node: '>=8'}
+    dependencies:
+      slice-ansi: 3.0.0
+      string-width: 4.2.3
+    dev: true
+
+  /cli-truncate/3.1.0:
+    resolution: {integrity: sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    dependencies:
+      slice-ansi: 5.0.0
+      string-width: 5.1.2
+    dev: true
+
+  /cli-width/2.2.1:
+    resolution: {integrity: sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==}
+    dev: true
+
+  /cliui/7.0.4:
+    resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
+    dependencies:
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      wrap-ansi: 7.0.0
+    dev: true
+
+  /color-convert/1.9.3:
+    resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
+    dependencies:
+      color-name: 1.1.3
+    dev: true
+
+  /color-convert/2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+    dependencies:
+      color-name: 1.1.4
+    dev: true
+
+  /color-name/1.1.3:
+    resolution: {integrity: sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=}
+    dev: true
+
+  /color-name/1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+    dev: true
+
+  /colorette/2.0.16:
+    resolution: {integrity: sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==}
+    dev: true
+
+  /commander/2.20.3:
+    resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
+    dev: true
+
+  /commander/8.3.0:
+    resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==}
+    engines: {node: '>= 12'}
+    dev: true
+
+  /commitizen/4.2.4:
+    resolution: {integrity: sha512-LlZChbDzg3Ir3O2S7jSo/cgWp5/QwylQVr59K4xayVq8S4/RdKzSyJkghAiZZHfhh5t4pxunUoyeg0ml1q/7aw==}
+    engines: {node: '>= 10'}
+    hasBin: true
+    dependencies:
+      cachedir: 2.2.0
+      cz-conventional-changelog: 3.2.0
+      dedent: 0.7.0
+      detect-indent: 6.0.0
+      find-node-modules: 2.1.3
+      find-root: 1.1.0
+      fs-extra: 8.1.0
+      glob: 7.1.4
+      inquirer: 6.5.2
+      is-utf8: 0.2.1
+      lodash: 4.17.21
+      minimist: 1.2.5
+      strip-bom: 4.0.0
+      strip-json-comments: 3.0.1
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+    dev: true
+
+  /commondir/1.0.1:
+    resolution: {integrity: sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=}
+    dev: true
+
+  /compare-func/2.0.0:
+    resolution: {integrity: sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==}
+    dependencies:
+      array-ify: 1.0.0
+      dot-prop: 5.3.0
+    dev: true
+
+  /concat-map/0.0.1:
+    resolution: {integrity: sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=}
+    dev: true
+
+  /conventional-changelog-angular/5.0.13:
+    resolution: {integrity: sha512-i/gipMxs7s8L/QeuavPF2hLnJgH6pEZAttySB6aiQLWcX3puWDL3ACVmvBhJGxnAy52Qc15ua26BufY6KpmrVA==}
+    engines: {node: '>=10'}
+    dependencies:
+      compare-func: 2.0.0
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-atom/2.0.8:
+    resolution: {integrity: sha512-xo6v46icsFTK3bb7dY/8m2qvc8sZemRgdqLb/bjpBsH2UyOS8rKNTgcb5025Hri6IpANPApbXMg15QLb1LJpBw==}
+    engines: {node: '>=10'}
+    dependencies:
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-codemirror/2.0.8:
+    resolution: {integrity: sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw==}
+    engines: {node: '>=10'}
+    dependencies:
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-conventionalcommits/4.6.3:
+    resolution: {integrity: sha512-LTTQV4fwOM4oLPad317V/QNQ1FY4Hju5qeBIM1uTHbrnCE+Eg4CdRZ3gO2pUeR+tzWdp80M2j3qFFEDWVqOV4g==}
+    engines: {node: '>=10'}
+    dependencies:
+      compare-func: 2.0.0
+      lodash: 4.17.21
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-core/4.2.4:
+    resolution: {integrity: sha512-gDVS+zVJHE2v4SLc6B0sLsPiloR0ygU7HaDW14aNJE1v4SlqJPILPl/aJC7YdtRE4CybBf8gDwObBvKha8Xlyg==}
+    engines: {node: '>=10'}
+    dependencies:
+      add-stream: 1.0.0
+      conventional-changelog-writer: 5.0.1
+      conventional-commits-parser: 3.2.4
+      dateformat: 3.0.3
+      get-pkg-repo: 4.2.1
+      git-raw-commits: 2.0.11
+      git-remote-origin-url: 2.0.0
+      git-semver-tags: 4.1.1
+      lodash: 4.17.21
+      normalize-package-data: 3.0.3
+      q: 1.5.1
+      read-pkg: 3.0.0
+      read-pkg-up: 3.0.0
+      through2: 4.0.2
+    dev: true
+
+  /conventional-changelog-ember/2.0.9:
+    resolution: {integrity: sha512-ulzIReoZEvZCBDhcNYfDIsLTHzYHc7awh+eI44ZtV5cx6LVxLlVtEmcO+2/kGIHGtw+qVabJYjdI5cJOQgXh1A==}
+    engines: {node: '>=10'}
+    dependencies:
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-eslint/3.0.9:
+    resolution: {integrity: sha512-6NpUCMgU8qmWmyAMSZO5NrRd7rTgErjrm4VASam2u5jrZS0n38V7Y9CzTtLT2qwz5xEChDR4BduoWIr8TfwvXA==}
+    engines: {node: '>=10'}
+    dependencies:
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-express/2.0.6:
+    resolution: {integrity: sha512-SDez2f3iVJw6V563O3pRtNwXtQaSmEfTCaTBPCqn0oG0mfkq0rX4hHBq5P7De2MncoRixrALj3u3oQsNK+Q0pQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-jquery/3.0.11:
+    resolution: {integrity: sha512-x8AWz5/Td55F7+o/9LQ6cQIPwrCjfJQ5Zmfqi8thwUEKHstEn4kTIofXub7plf1xvFA2TqhZlq7fy5OmV6BOMw==}
+    engines: {node: '>=10'}
+    dependencies:
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-jshint/2.0.9:
+    resolution: {integrity: sha512-wMLdaIzq6TNnMHMy31hql02OEQ8nCQfExw1SE0hYL5KvU+JCTuPaDO+7JiogGT2gJAxiUGATdtYYfh+nT+6riA==}
+    engines: {node: '>=10'}
+    dependencies:
+      compare-func: 2.0.0
+      q: 1.5.1
+    dev: true
+
+  /conventional-changelog-preset-loader/2.3.4:
+    resolution: {integrity: sha512-GEKRWkrSAZeTq5+YjUZOYxdHq+ci4dNwHvpaBC3+ENalzFWuCWa9EZXSuZBpkr72sMdKB+1fyDV4takK1Lf58g==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /conventional-changelog-writer/5.0.1:
+    resolution: {integrity: sha512-5WsuKUfxW7suLblAbFnxAcrvf6r+0b7GvNaWUwUIk0bXMnENP/PEieGKVUQrjPqwPT4o3EPAASBXiY6iHooLOQ==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      conventional-commits-filter: 2.0.7
+      dateformat: 3.0.3
+      handlebars: 4.7.7
+      json-stringify-safe: 5.0.1
+      lodash: 4.17.21
+      meow: 8.1.2
+      semver: 6.3.0
+      split: 1.0.1
+      through2: 4.0.2
+    dev: true
+
+  /conventional-changelog/3.1.25:
+    resolution: {integrity: sha512-ryhi3fd1mKf3fSjbLXOfK2D06YwKNic1nC9mWqybBHdObPd8KJ2vjaXZfYj1U23t+V8T8n0d7gwnc9XbIdFbyQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      conventional-changelog-angular: 5.0.13
+      conventional-changelog-atom: 2.0.8
+      conventional-changelog-codemirror: 2.0.8
+      conventional-changelog-conventionalcommits: 4.6.3
+      conventional-changelog-core: 4.2.4
+      conventional-changelog-ember: 2.0.9
+      conventional-changelog-eslint: 3.0.9
+      conventional-changelog-express: 2.0.6
+      conventional-changelog-jquery: 3.0.11
+      conventional-changelog-jshint: 2.0.9
+      conventional-changelog-preset-loader: 2.3.4
+    dev: true
+
+  /conventional-commit-types/3.0.0:
+    resolution: {integrity: sha512-SmmCYnOniSsAa9GqWOeLqc179lfr5TRu5b4QFDkbsrJ5TZjPJx85wtOr3zn+1dbeNiXDKGPbZ72IKbPhLXh/Lg==}
+    dev: true
+
+  /conventional-commits-filter/2.0.7:
+    resolution: {integrity: sha512-ASS9SamOP4TbCClsRHxIHXRfcGCnIoQqkvAzCSbZzTFLfcTqJVugB0agRgsEELsqaeWgsXv513eS116wnlSSPA==}
+    engines: {node: '>=10'}
+    dependencies:
+      lodash.ismatch: 4.4.0
+      modify-values: 1.0.1
+    dev: true
+
+  /conventional-commits-parser/3.2.4:
+    resolution: {integrity: sha512-nK7sAtfi+QXbxHCYfhpZsfRtaitZLIA6889kFIouLvz6repszQDgxBu7wf2WbU+Dco7sAnNCJYERCwt54WPC2Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      is-text-path: 1.0.1
+      JSONStream: 1.3.5
+      lodash: 4.17.21
+      meow: 8.1.2
+      split2: 3.2.2
+      through2: 4.0.2
+    dev: true
+
+  /core-util-is/1.0.3:
+    resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
+    dev: true
+
+  /corser/2.0.1:
+    resolution: {integrity: sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=}
+    engines: {node: '>= 0.4.0'}
+    dev: true
+
+  /cosmiconfig-typescript-loader/2.0.0_3smuweqyuzdazdnyhhezld6mfa:
+    resolution: {integrity: sha512-2NlGul/E3vTQEANqPziqkA01vfiuUU8vT0jZAuUIjEW8u3eCcnCQWLggapCjhbF76s7KQF0fM0kXSKmzaDaG1g==}
+    engines: {node: '>=12', npm: '>=6'}
+    peerDependencies:
+      '@types/node': '*'
+      typescript: '>=3'
+    dependencies:
+      '@types/node': 17.0.34
+      cosmiconfig: 7.0.1
+      ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
+      typescript: 4.6.4
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+    dev: true
+    optional: true
+
+  /cosmiconfig/7.0.1:
+    resolution: {integrity: sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@types/parse-json': 4.0.0
+      import-fresh: 3.3.0
+      parse-json: 5.2.0
+      path-type: 4.0.0
+      yaml: 1.10.2
+    dev: true
+    optional: true
+
+  /create-require/1.1.1:
+    resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
+    dev: true
+
+  /cross-spawn/5.1.0:
+    resolution: {integrity: sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=}
+    dependencies:
+      lru-cache: 4.1.5
+      shebang-command: 1.2.0
+      which: 1.3.1
+    dev: true
+
+  /cross-spawn/7.0.3:
+    resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
+    engines: {node: '>= 8'}
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+    dev: true
+
+  /css/2.2.4:
+    resolution: {integrity: sha512-oUnjmWpy0niI3x/mPL8dVEI1l7MnG3+HHyRPHf+YFSbK+svOhXpmSOcDURUh2aOCgl2grzrOPt1nHLuCVFULLw==}
+    dependencies:
+      inherits: 2.0.4
+      source-map: 0.6.1
+      source-map-resolve: 0.5.3
+      urix: 0.1.0
+    dev: true
+
+  /cz-conventional-changelog/3.2.0:
+    resolution: {integrity: sha512-yAYxeGpVi27hqIilG1nh4A9Bnx4J3Ov+eXy4koL3drrR+IO9GaWPsKjik20ht608Asqi8TQPf0mczhEeyAtMzg==}
+    engines: {node: '>= 10'}
+    dependencies:
+      chalk: 2.4.2
+      commitizen: 4.2.4
+      conventional-commit-types: 3.0.0
+      lodash.map: 4.6.0
+      longest: 2.0.1
+      word-wrap: 1.2.3
+    optionalDependencies:
+      '@commitlint/load': 17.0.0
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+    dev: true
+
+  /cz-conventional-changelog/3.3.0:
+    resolution: {integrity: sha512-U466fIzU5U22eES5lTNiNbZ+d8dfcHcssH4o7QsdWaCcRs/feIPCxKYSWkYBNs5mny7MvEfwpTLWjvbm94hecw==}
+    engines: {node: '>= 10'}
+    dependencies:
+      chalk: 2.4.2
+      commitizen: 4.2.4
+      conventional-commit-types: 3.0.0
+      lodash.map: 4.6.0
+      longest: 2.0.1
+      word-wrap: 1.2.3
+    optionalDependencies:
+      '@commitlint/load': 17.0.0
+    transitivePeerDependencies:
+      - '@swc/core'
+      - '@swc/wasm'
+    dev: true
+
+  /dargs/7.0.0:
+    resolution: {integrity: sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /dateformat/3.0.3:
+    resolution: {integrity: sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==}
+    dev: true
+
+  /de-indent/1.0.2:
+    resolution: {integrity: sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=}
+    dev: true
+
+  /debug/3.2.7:
+    resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.3
+    dev: true
+
+  /debug/4.3.4:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.2
+    dev: true
+
+  /debug/4.3.4_supports-color@9.2.2:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.2
+      supports-color: 9.2.2
+    dev: true
+
+  /decamelize-keys/1.1.0:
+    resolution: {integrity: sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      decamelize: 1.2.0
+      map-obj: 1.0.1
+    dev: true
+
+  /decamelize/1.2.0:
+    resolution: {integrity: sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /decode-uri-component/0.2.0:
+    resolution: {integrity: sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=}
+    engines: {node: '>=0.10'}
+    dev: true
+
+  /dedent/0.7.0:
+    resolution: {integrity: sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=}
+    dev: true
+
+  /deep-eql/3.0.1:
+    resolution: {integrity: sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw==}
+    engines: {node: '>=0.12'}
+    dependencies:
+      type-detect: 4.0.8
+    dev: true
+
+  /deep-is/0.1.4:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+    dev: true
+
+  /deepmerge/4.2.2:
+    resolution: {integrity: sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /detect-file/1.0.0:
+    resolution: {integrity: sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /detect-indent/6.0.0:
+    resolution: {integrity: sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /diff/4.0.2:
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+    engines: {node: '>=0.3.1'}
+    dev: true
+
+  /dir-glob/3.0.1:
+    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
+    engines: {node: '>=8'}
+    dependencies:
+      path-type: 4.0.0
+    dev: true
+
+  /doctrine/3.0.0:
+    resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==}
+    engines: {node: '>=6.0.0'}
+    dependencies:
+      esutils: 2.0.3
+    dev: true
+
+  /dot-prop/5.3.0:
+    resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==}
+    engines: {node: '>=8'}
+    dependencies:
+      is-obj: 2.0.0
+    dev: true
+
+  /eastasianwidth/0.2.0:
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
+    dev: true
+
+  /emoji-regex/8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+    dev: true
+
+  /emoji-regex/9.2.2:
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
+    dev: true
+
+  /error-ex/1.3.2:
+    resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
+    dependencies:
+      is-arrayish: 0.2.1
+    dev: true
+
+  /esbuild-android-64/0.14.39:
+    resolution: {integrity: sha512-EJOu04p9WgZk0UoKTqLId9VnIsotmI/Z98EXrKURGb3LPNunkeffqQIkjS2cAvidh+OK5uVrXaIP229zK6GvhQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-android-arm64/0.14.39:
+    resolution: {integrity: sha512-+twajJqO7n3MrCz9e+2lVOnFplRsaGRwsq1KL/uOy7xK7QdRSprRQcObGDeDZUZsacD5gUkk6OiHiYp6RzU3CA==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-darwin-64/0.14.39:
+    resolution: {integrity: sha512-ImT6eUw3kcGcHoUxEcdBpi6LfTRWaV6+qf32iYYAfwOeV+XaQ/Xp5XQIBiijLeo+LpGci9M0FVec09nUw41a5g==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-darwin-arm64/0.14.39:
+    resolution: {integrity: sha512-/fcQ5UhE05OiT+bW5v7/up1bDsnvaRZPJxXwzXsMRrr7rZqPa85vayrD723oWMT64dhrgWeA3FIneF8yER0XTw==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-freebsd-64/0.14.39:
+    resolution: {integrity: sha512-oMNH8lJI4wtgN5oxuFP7BQ22vgB/e3Tl5Woehcd6i2r6F3TszpCnNl8wo2d/KvyQ4zvLvCWAlRciumhQg88+kQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-freebsd-arm64/0.14.39:
+    resolution: {integrity: sha512-1GHK7kwk57ukY2yI4ILWKJXaxfr+8HcM/r/JKCGCPziIVlL+Wi7RbJ2OzMcTKZ1HpvEqCTBT/J6cO4ZEwW4Ypg==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-32/0.14.39:
+    resolution: {integrity: sha512-g97Sbb6g4zfRLIxHgW2pc393DjnkTRMeq3N1rmjDUABxpx8SjocK4jLen+/mq55G46eE2TA0MkJ4R3SpKMu7dg==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-64/0.14.39:
+    resolution: {integrity: sha512-4tcgFDYWdI+UbNMGlua9u1Zhu0N5R6u9tl5WOM8aVnNX143JZoBZLpCuUr5lCKhnD0SCO+5gUyMfupGrHtfggQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-arm/0.14.39:
+    resolution: {integrity: sha512-t0Hn1kWVx5UpCzAJkKRfHeYOLyFnXwYynIkK54/h3tbMweGI7dj400D1k0Vvtj2u1P+JTRT9tx3AjtLEMmfVBQ==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-arm64/0.14.39:
+    resolution: {integrity: sha512-23pc8MlD2D6Px1mV8GMglZlKgwgNKAO8gsgsLLcXWSs9lQsCYkIlMo/2Ycfo5JrDIbLdwgP8D2vpfH2KcBqrDQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-mips64le/0.14.39:
+    resolution: {integrity: sha512-epwlYgVdbmkuRr5n4es3B+yDI0I2e/nxhKejT9H0OLxFAlMkeQZxSpxATpDc9m8NqRci6Kwyb/SfmD1koG2Zuw==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-ppc64le/0.14.39:
+    resolution: {integrity: sha512-W/5ezaq+rQiQBThIjLMNjsuhPHg+ApVAdTz2LvcuesZFMsJoQAW2hutoyg47XxpWi7aEjJGrkS26qCJKhRn3QQ==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-riscv64/0.14.39:
+    resolution: {integrity: sha512-IS48xeokcCTKeQIOke2O0t9t14HPvwnZcy+5baG13Z1wxs9ZrC5ig5ypEQQh4QMKxURD5TpCLHw2W42CLuVZaA==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-linux-s390x/0.14.39:
+    resolution: {integrity: sha512-zEfunpqR8sMomqXhNTFEKDs+ik7HC01m3M60MsEjZOqaywHu5e5682fMsqOlZbesEAAaO9aAtRBsU7CHnSZWyA==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-netbsd-64/0.14.39:
+    resolution: {integrity: sha512-Uo2suJBSIlrZCe4E0k75VDIFJWfZy+bOV6ih3T4MVMRJh1lHJ2UyGoaX4bOxomYN3t+IakHPyEoln1+qJ1qYaA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-openbsd-64/0.14.39:
+    resolution: {integrity: sha512-secQU+EpgUPpYjJe3OecoeGKVvRMLeKUxSMGHnK+aK5uQM3n1FPXNJzyz1LHFOo0WOyw+uoCxBYdM4O10oaCAA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-sunos-64/0.14.39:
+    resolution: {integrity: sha512-qHq0t5gePEDm2nqZLb+35p/qkaXVS7oIe32R0ECh2HOdiXXkj/1uQI9IRogGqKkK+QjDG+DhwiUw7QoHur/Rwg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-windows-32/0.14.39:
+    resolution: {integrity: sha512-XPjwp2OgtEX0JnOlTgT6E5txbRp6Uw54Isorm3CwOtloJazeIWXuiwK0ONJBVb/CGbiCpS7iP2UahGgd2p1x+Q==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-windows-64/0.14.39:
+    resolution: {integrity: sha512-E2wm+5FwCcLpKsBHRw28bSYQw0Ikxb7zIMxw3OPAkiaQhLVr3dnVO8DofmbWhhf6b97bWzg37iSZ45ZDpLw7Ow==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild-windows-arm64/0.14.39:
+    resolution: {integrity: sha512-sBZQz5D+Gd0EQ09tZRnz/PpVdLwvp/ufMtJ1iDFYddDaPpZXKqPyaxfYBLs3ueiaksQ26GGa7sci0OqFzNs7KA==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /esbuild/0.14.39:
+    resolution: {integrity: sha512-2kKujuzvRWYtwvNjYDY444LQIA3TyJhJIX3Yo4+qkFlDDtGlSicWgeHVJqMUP/2sSfH10PGwfsj+O2ro1m10xQ==}
+    engines: {node: '>=12'}
+    hasBin: true
+    requiresBuild: true
+    optionalDependencies:
+      esbuild-android-64: 0.14.39
+      esbuild-android-arm64: 0.14.39
+      esbuild-darwin-64: 0.14.39
+      esbuild-darwin-arm64: 0.14.39
+      esbuild-freebsd-64: 0.14.39
+      esbuild-freebsd-arm64: 0.14.39
+      esbuild-linux-32: 0.14.39
+      esbuild-linux-64: 0.14.39
+      esbuild-linux-arm: 0.14.39
+      esbuild-linux-arm64: 0.14.39
+      esbuild-linux-mips64le: 0.14.39
+      esbuild-linux-ppc64le: 0.14.39
+      esbuild-linux-riscv64: 0.14.39
+      esbuild-linux-s390x: 0.14.39
+      esbuild-netbsd-64: 0.14.39
+      esbuild-openbsd-64: 0.14.39
+      esbuild-sunos-64: 0.14.39
+      esbuild-windows-32: 0.14.39
+      esbuild-windows-64: 0.14.39
+      esbuild-windows-arm64: 0.14.39
+    dev: true
+
+  /escalade/3.1.1:
+    resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /escape-string-regexp/1.0.5:
+    resolution: {integrity: sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=}
+    engines: {node: '>=0.8.0'}
+    dev: true
+
+  /escape-string-regexp/4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /escodegen/2.0.0:
+    resolution: {integrity: sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw==}
+    engines: {node: '>=6.0'}
+    hasBin: true
+    dependencies:
+      esprima: 4.0.1
+      estraverse: 5.3.0
+      esutils: 2.0.3
+      optionator: 0.8.3
+    optionalDependencies:
+      source-map: 0.6.1
+    dev: true
+
+  /eslint-scope/5.1.1:
+    resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==}
+    engines: {node: '>=8.0.0'}
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 4.3.0
+    dev: true
+
+  /eslint-scope/7.1.1:
+    resolution: {integrity: sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+    dev: true
+
+  /eslint-utils/3.0.0_eslint@8.15.0:
+    resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==}
+    engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0}
+    peerDependencies:
+      eslint: '>=5'
+    dependencies:
+      eslint: 8.15.0
+      eslint-visitor-keys: 2.1.0
+    dev: true
+
+  /eslint-visitor-keys/2.1.0:
+    resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /eslint-visitor-keys/3.3.0:
+    resolution: {integrity: sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dev: true
+
+  /eslint/8.15.0:
+    resolution: {integrity: sha512-GG5USZ1jhCu8HJkzGgeK8/+RGnHaNYZGrGDzUtigK3BsGESW/rs2az23XqE0WVwDxy1VRvvjSSGu5nB0Bu+6SA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    hasBin: true
+    dependencies:
+      '@eslint/eslintrc': 1.2.3
+      '@humanwhocodes/config-array': 0.9.5
+      ajv: 6.12.6
+      chalk: 4.1.2
+      cross-spawn: 7.0.3
+      debug: 4.3.4
+      doctrine: 3.0.0
+      escape-string-regexp: 4.0.0
+      eslint-scope: 7.1.1
+      eslint-utils: 3.0.0_eslint@8.15.0
+      eslint-visitor-keys: 3.3.0
+      espree: 9.3.2
+      esquery: 1.4.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 6.0.1
+      functional-red-black-tree: 1.0.1
+      glob-parent: 6.0.2
+      globals: 13.15.0
+      ignore: 5.2.0
+      import-fresh: 3.3.0
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      js-yaml: 4.1.0
+      json-stable-stringify-without-jsonify: 1.0.1
+      levn: 0.4.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
+      natural-compare: 1.4.0
+      optionator: 0.9.1
+      regexpp: 3.2.0
+      strip-ansi: 6.0.1
+      strip-json-comments: 3.1.1
+      text-table: 0.2.0
+      v8-compile-cache: 2.3.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /espree/9.3.2:
+    resolution: {integrity: sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dependencies:
+      acorn: 8.7.1
+      acorn-jsx: 5.3.2_acorn@8.7.1
+      eslint-visitor-keys: 3.3.0
+    dev: true
+
+  /esprima/4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+    dev: true
+
+  /esquery/1.4.0:
+    resolution: {integrity: sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==}
+    engines: {node: '>=0.10'}
+    dependencies:
+      estraverse: 5.3.0
+    dev: true
+
+  /esrecurse/4.3.0:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+    dependencies:
+      estraverse: 5.3.0
+    dev: true
+
+  /estraverse/4.3.0:
+    resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==}
+    engines: {node: '>=4.0'}
+    dev: true
+
+  /estraverse/5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+    dev: true
+
+  /estree-walker/1.0.1:
+    resolution: {integrity: sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==}
+    dev: true
+
+  /estree-walker/2.0.2:
+    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
+    dev: true
+
+  /esutils/2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /eventemitter3/4.0.7:
+    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
+    dev: true
+
+  /execa/0.8.0:
+    resolution: {integrity: sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=}
+    engines: {node: '>=4'}
+    dependencies:
+      cross-spawn: 5.1.0
+      get-stream: 3.0.0
+      is-stream: 1.1.0
+      npm-run-path: 2.0.2
+      p-finally: 1.0.0
+      signal-exit: 3.0.7
+      strip-eof: 1.0.0
+    dev: true
+
+  /execa/5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+    dependencies:
+      cross-spawn: 7.0.3
+      get-stream: 6.0.1
+      human-signals: 2.1.0
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+    dev: true
+
+  /expand-tilde/2.0.2:
+    resolution: {integrity: sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      homedir-polyfill: 1.0.3
+    dev: true
+
+  /external-editor/3.1.0:
+    resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
+    engines: {node: '>=4'}
+    dependencies:
+      chardet: 0.7.0
+      iconv-lite: 0.4.24
+      tmp: 0.0.33
+    dev: true
+
+  /fast-deep-equal/3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+    dev: true
+
+  /fast-glob/3.2.11:
+    resolution: {integrity: sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==}
+    engines: {node: '>=8.6.0'}
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.5
+    dev: true
+
+  /fast-json-stable-stringify/2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+    dev: true
+
+  /fast-levenshtein/2.0.6:
+    resolution: {integrity: sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=}
+    dev: true
+
+  /fastq/1.13.0:
+    resolution: {integrity: sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==}
+    dependencies:
+      reusify: 1.0.4
+    dev: true
+
+  /figures/2.0.0:
+    resolution: {integrity: sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=}
+    engines: {node: '>=4'}
+    dependencies:
+      escape-string-regexp: 1.0.5
+    dev: true
+
+  /file-entry-cache/6.0.1:
+    resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==}
+    engines: {node: ^10.12.0 || >=12.0.0}
+    dependencies:
+      flat-cache: 3.0.4
+    dev: true
+
+  /fill-range/7.0.1:
+    resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      to-regex-range: 5.0.1
+    dev: true
+
+  /find-cache-dir/3.3.2:
+    resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==}
+    engines: {node: '>=8'}
+    dependencies:
+      commondir: 1.0.1
+      make-dir: 3.1.0
+      pkg-dir: 4.2.0
+    dev: true
+
+  /find-node-modules/2.1.3:
+    resolution: {integrity: sha512-UC2I2+nx1ZuOBclWVNdcnbDR5dlrOdVb7xNjmT/lHE+LsgztWks3dG7boJ37yTS/venXw84B/mAW9uHVoC5QRg==}
+    dependencies:
+      findup-sync: 4.0.0
+      merge: 2.1.1
+    dev: true
+
+  /find-root/1.1.0:
+    resolution: {integrity: sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==}
+    dev: true
+
+  /find-up/2.1.0:
+    resolution: {integrity: sha1-RdG35QbHF93UgndaK3eSCjwMV6c=}
+    engines: {node: '>=4'}
+    dependencies:
+      locate-path: 2.0.0
+    dev: true
+
+  /find-up/4.1.0:
+    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
+    engines: {node: '>=8'}
+    dependencies:
+      locate-path: 5.0.0
+      path-exists: 4.0.0
+    dev: true
+
+  /find-up/5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+    dev: true
+
+  /findup-sync/4.0.0:
+    resolution: {integrity: sha512-6jvvn/12IC4quLBL1KNokxC7wWTvYncaVUYSoxWw7YykPLuRrnv4qdHcSOywOI5RpkOVGeQRtWM8/q+G6W6qfQ==}
+    engines: {node: '>= 8'}
+    dependencies:
+      detect-file: 1.0.0
+      is-glob: 4.0.3
+      micromatch: 4.0.5
+      resolve-dir: 1.0.1
+    dev: true
+
+  /flat-cache/3.0.4:
+    resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==}
+    engines: {node: ^10.12.0 || >=12.0.0}
+    dependencies:
+      flatted: 3.2.5
+      rimraf: 3.0.2
+    dev: true
+
+  /flatted/3.2.5:
+    resolution: {integrity: sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==}
+    dev: true
+
+  /follow-redirects/1.15.0:
+    resolution: {integrity: sha512-aExlJShTV4qOUOL7yF1U5tvLCB0xQuudbf6toyYA0E/acBNw71mvjFTnLaRp50aQaYocMR0a/RMMBIHeZnGyjQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+    dev: true
+
+  /fs-extra/10.1.0:
+    resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      graceful-fs: 4.2.10
+      jsonfile: 6.1.0
+      universalify: 2.0.0
+    dev: true
+
+  /fs-extra/8.1.0:
+    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
+    engines: {node: '>=6 <7 || >=8'}
+    dependencies:
+      graceful-fs: 4.2.10
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+    dev: true
+
+  /fs.realpath/1.0.0:
+    resolution: {integrity: sha1-FQStJSMVjKpA20onh8sBQRmU6k8=}
+    dev: true
+
+  /fsevents/2.3.2:
+    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+    dev: true
+
+  /function-bind/1.1.1:
+    resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==}
+    dev: true
+
+  /functional-red-black-tree/1.0.1:
+    resolution: {integrity: sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=}
+    dev: true
+
+  /get-caller-file/2.0.5:
+    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
+    engines: {node: 6.* || 8.* || >= 10.*}
+    dev: true
+
+  /get-func-name/2.0.0:
+    resolution: {integrity: sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=}
+    dev: true
+
+  /get-intrinsic/1.1.1:
+    resolution: {integrity: sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==}
+    dependencies:
+      function-bind: 1.1.1
+      has: 1.0.3
+      has-symbols: 1.0.3
+    dev: true
+
+  /get-pkg-repo/4.2.1:
+    resolution: {integrity: sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==}
+    engines: {node: '>=6.9.0'}
+    hasBin: true
+    dependencies:
+      '@hutson/parse-repository-url': 3.0.2
+      hosted-git-info: 4.1.0
+      through2: 2.0.5
+      yargs: 16.2.0
+    dev: true
+
+  /get-stream/3.0.0:
+    resolution: {integrity: sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /get-stream/6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /git-raw-commits/2.0.11:
+    resolution: {integrity: sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      dargs: 7.0.0
+      lodash: 4.17.21
+      meow: 8.1.2
+      split2: 3.2.2
+      through2: 4.0.2
+    dev: true
+
+  /git-remote-origin-url/2.0.0:
+    resolution: {integrity: sha1-UoJlna4hBxRaERJhEq0yFuxfpl8=}
+    engines: {node: '>=4'}
+    dependencies:
+      gitconfiglocal: 1.0.0
+      pify: 2.3.0
+    dev: true
+
+  /git-semver-tags/4.1.1:
+    resolution: {integrity: sha512-OWyMt5zBe7xFs8vglMmhM9lRQzCWL3WjHtxNNfJTMngGym7pC1kh8sP6jevfydJ6LP3ZvGxfb6ABYgPUM0mtsA==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      meow: 8.1.2
+      semver: 6.3.0
+    dev: true
+
+  /gitconfiglocal/1.0.0:
+    resolution: {integrity: sha1-QdBF84UaXqiPA/JMocYXgRRGS5s=}
+    dependencies:
+      ini: 1.3.8
+    dev: true
+
+  /glob-parent/5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+    dependencies:
+      is-glob: 4.0.3
+    dev: true
+
+  /glob-parent/6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+    dependencies:
+      is-glob: 4.0.3
+    dev: true
+
+  /glob/7.1.4:
+    resolution: {integrity: sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==}
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.2
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+    dev: true
+
+  /glob/7.2.3:
+    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.2
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+    dev: true
+
+  /global-dirs/0.1.1:
+    resolution: {integrity: sha1-sxnA3UYH81PzvpzKTHL8FIxJ9EU=}
+    engines: {node: '>=4'}
+    dependencies:
+      ini: 1.3.8
+    dev: true
+    optional: true
+
+  /global-modules/1.0.0:
+    resolution: {integrity: sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      global-prefix: 1.0.2
+      is-windows: 1.0.2
+      resolve-dir: 1.0.1
+    dev: true
+
+  /global-prefix/1.0.2:
+    resolution: {integrity: sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      expand-tilde: 2.0.2
+      homedir-polyfill: 1.0.3
+      ini: 1.3.8
+      is-windows: 1.0.2
+      which: 1.3.1
+    dev: true
+
+  /globals/13.15.0:
+    resolution: {integrity: sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==}
+    engines: {node: '>=8'}
+    dependencies:
+      type-fest: 0.20.2
+    dev: true
+
+  /globby/11.1.0:
+    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
+    engines: {node: '>=10'}
+    dependencies:
+      array-union: 2.1.0
+      dir-glob: 3.0.1
+      fast-glob: 3.2.11
+      ignore: 5.2.0
+      merge2: 1.4.1
+      slash: 3.0.0
+    dev: true
+
+  /graceful-fs/4.2.10:
+    resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==}
+    dev: true
+
+  /handlebars/4.7.7:
+    resolution: {integrity: sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==}
+    engines: {node: '>=0.4.7'}
+    hasBin: true
+    dependencies:
+      minimist: 1.2.6
+      neo-async: 2.6.2
+      source-map: 0.6.1
+      wordwrap: 1.0.0
+    optionalDependencies:
+      uglify-js: 3.15.5
+    dev: true
+
+  /hard-rejection/2.1.0:
+    resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /has-flag/3.0.0:
+    resolution: {integrity: sha1-tdRU3CGZriJWmfNGfloH87lVuv0=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /has-flag/4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /has-symbols/1.0.3:
+    resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /has/1.0.3:
+    resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==}
+    engines: {node: '>= 0.4.0'}
+    dependencies:
+      function-bind: 1.1.1
+    dev: true
+
+  /hash-sum/2.0.0:
+    resolution: {integrity: sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==}
+    dev: true
+
+  /he/1.2.0:
+    resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
+    hasBin: true
+    dev: true
+
+  /homedir-polyfill/1.0.3:
+    resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      parse-passwd: 1.0.0
+    dev: true
+
+  /hosted-git-info/2.8.9:
+    resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
+    dev: true
+
+  /hosted-git-info/4.1.0:
+    resolution: {integrity: sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==}
+    engines: {node: '>=10'}
+    dependencies:
+      lru-cache: 6.0.0
+    dev: true
+
+  /html-encoding-sniffer/3.0.0:
+    resolution: {integrity: sha512-oWv4T4yJ52iKrufjnyZPkrN0CH3QnrUqdB6In1g5Fe1mia8GmF36gnfNySxoZtxD5+NmYw1EElVXiBk93UeskA==}
+    engines: {node: '>=12'}
+    dependencies:
+      whatwg-encoding: 2.0.0
+    dev: true
+
+  /http-proxy/1.18.1:
+    resolution: {integrity: sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==}
+    engines: {node: '>=8.0.0'}
+    dependencies:
+      eventemitter3: 4.0.7
+      follow-redirects: 1.15.0
+      requires-port: 1.0.0
+    transitivePeerDependencies:
+      - debug
+    dev: true
+
+  /http-server/14.1.0:
+    resolution: {integrity: sha512-5lYsIcZtf6pdR8tCtzAHTWrAveo4liUlJdWc7YafwK/maPgYHs+VNP6KpCClmUnSorJrARVMXqtT055zBv11Yg==}
+    engines: {node: '>=12'}
+    hasBin: true
+    dependencies:
+      basic-auth: 2.0.1
+      chalk: 4.1.2
+      corser: 2.0.1
+      he: 1.2.0
+      html-encoding-sniffer: 3.0.0
+      http-proxy: 1.18.1
+      mime: 1.6.0
+      minimist: 1.2.6
+      opener: 1.5.2
+      portfinder: 1.0.28
+      secure-compare: 3.0.1
+      union: 0.5.0
+      url-join: 4.0.1
+    transitivePeerDependencies:
+      - debug
+      - supports-color
+    dev: true
+
+  /human-signals/2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+    dev: true
+
+  /iconv-lite/0.4.24:
+    resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      safer-buffer: 2.1.2
+    dev: true
+
+  /iconv-lite/0.6.3:
+    resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      safer-buffer: 2.1.2
+    dev: true
+
+  /ignore/5.2.0:
+    resolution: {integrity: sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==}
+    engines: {node: '>= 4'}
+    dev: true
+
+  /import-fresh/3.3.0:
+    resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==}
+    engines: {node: '>=6'}
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+    dev: true
+
+  /imurmurhash/0.1.4:
+    resolution: {integrity: sha1-khi5srkoojixPcT7a21XbyMUU+o=}
+    engines: {node: '>=0.8.19'}
+    dev: true
+
+  /indent-string/4.0.0:
+    resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /inflight/1.0.6:
+    resolution: {integrity: sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=}
+    dependencies:
+      once: 1.4.0
+      wrappy: 1.0.2
+    dev: true
+
+  /inherits/2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+    dev: true
+
+  /ini/1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+    dev: true
+
+  /inquirer/6.5.2:
+    resolution: {integrity: sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==}
+    engines: {node: '>=6.0.0'}
+    dependencies:
+      ansi-escapes: 3.2.0
+      chalk: 2.4.2
+      cli-cursor: 2.1.0
+      cli-width: 2.2.1
+      external-editor: 3.1.0
+      figures: 2.0.0
+      lodash: 4.17.21
+      mute-stream: 0.0.7
+      run-async: 2.4.1
+      rxjs: 6.6.7
+      string-width: 2.1.1
+      strip-ansi: 5.2.0
+      through: 2.3.8
+    dev: true
+
+  /interpret/1.4.0:
+    resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==}
+    engines: {node: '>= 0.10'}
+    dev: true
+
+  /is-arrayish/0.2.1:
+    resolution: {integrity: sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=}
+    dev: true
+
+  /is-builtin-module/3.1.0:
+    resolution: {integrity: sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==}
+    engines: {node: '>=6'}
+    dependencies:
+      builtin-modules: 3.3.0
+    dev: true
+
+  /is-ci/1.2.1:
+    resolution: {integrity: sha512-s6tfsaQaQi3JNciBH6shVqEDvhGut0SUXr31ag8Pd8BBbVVlcGfWhpPmEOoM6RJ5TFhbypvf5yyRw/VXW1IiWg==}
+    hasBin: true
+    dependencies:
+      ci-info: 1.6.0
+    dev: true
+
+  /is-core-module/2.9.0:
+    resolution: {integrity: sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==}
+    dependencies:
+      has: 1.0.3
+    dev: true
+
+  /is-extglob/2.1.1:
+    resolution: {integrity: sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /is-fullwidth-code-point/2.0.0:
+    resolution: {integrity: sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /is-fullwidth-code-point/3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /is-fullwidth-code-point/4.0.0:
+    resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /is-glob/4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-extglob: 2.1.1
+    dev: true
+
+  /is-module/1.0.0:
+    resolution: {integrity: sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=}
+    dev: true
+
+  /is-number/7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+    dev: true
+
+  /is-obj/2.0.0:
+    resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /is-plain-obj/1.1.0:
+    resolution: {integrity: sha1-caUMhCnfync8kqOQpKA7OfzVHT4=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /is-reference/1.2.1:
+    resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
+    dependencies:
+      '@types/estree': 0.0.51
+    dev: true
+
+  /is-stream/1.1.0:
+    resolution: {integrity: sha1-EtSj3U5o4Lec6428hBc66A2RykQ=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /is-stream/2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /is-text-path/1.0.1:
+    resolution: {integrity: sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      text-extensions: 1.9.0
+    dev: true
+
+  /is-utf8/0.2.1:
+    resolution: {integrity: sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=}
+    dev: true
+
+  /is-windows/1.0.2:
+    resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /isarray/1.0.0:
+    resolution: {integrity: sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=}
+    dev: true
+
+  /isexe/2.0.0:
+    resolution: {integrity: sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=}
+    dev: true
+
+  /js-tokens/4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+    dev: true
+
+  /js-yaml/4.1.0:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+    dependencies:
+      argparse: 2.0.1
+    dev: true
+
+  /json-parse-better-errors/1.0.2:
+    resolution: {integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==}
+    dev: true
+
+  /json-parse-even-better-errors/2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+    dev: true
+
+  /json-schema-traverse/0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+    dev: true
+
+  /json-stable-stringify-without-jsonify/1.0.1:
+    resolution: {integrity: sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=}
+    dev: true
+
+  /json-stringify-safe/5.0.1:
+    resolution: {integrity: sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=}
+    dev: true
+
+  /jsonfile/4.0.0:
+    resolution: {integrity: sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=}
+    optionalDependencies:
+      graceful-fs: 4.2.10
+    dev: true
+
+  /jsonfile/6.1.0:
+    resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==}
+    dependencies:
+      universalify: 2.0.0
+    optionalDependencies:
+      graceful-fs: 4.2.10
+    dev: true
+
+  /jsonparse/1.3.1:
+    resolution: {integrity: sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=}
+    engines: {'0': node >= 0.2.0}
+    dev: true
+
+  /kind-of/6.0.3:
+    resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /levn/0.3.0:
+    resolution: {integrity: sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      prelude-ls: 1.1.2
+      type-check: 0.3.2
+    dev: true
+
+  /levn/0.4.1:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+    dev: true
+
+  /lilconfig/2.0.4:
+    resolution: {integrity: sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /lines-and-columns/1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+    dev: true
+
+  /lint-staged/12.4.1:
+    resolution: {integrity: sha512-PTXgzpflrQ+pODQTG116QNB+Q6uUTDg5B5HqGvNhoQSGt8Qy+MA/6zSnR8n38+sxP5TapzeQGTvoKni0KRS8Vg==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    hasBin: true
+    dependencies:
+      cli-truncate: 3.1.0
+      colorette: 2.0.16
+      commander: 8.3.0
+      debug: 4.3.4_supports-color@9.2.2
+      execa: 5.1.1
+      lilconfig: 2.0.4
+      listr2: 4.0.5
+      micromatch: 4.0.5
+      normalize-path: 3.0.0
+      object-inspect: 1.12.0
+      pidtree: 0.5.0
+      string-argv: 0.3.1
+      supports-color: 9.2.2
+      yaml: 1.10.2
+    transitivePeerDependencies:
+      - enquirer
+    dev: true
+
+  /listr2/4.0.5:
+    resolution: {integrity: sha512-juGHV1doQdpNT3GSTs9IUN43QJb7KHdF9uqg7Vufs/tG9VTzpFphqF4pm/ICdAABGQxsyNn9CiYA3StkI6jpwA==}
+    engines: {node: '>=12'}
+    peerDependencies:
+      enquirer: '>= 2.3.0 < 3'
+    peerDependenciesMeta:
+      enquirer:
+        optional: true
+    dependencies:
+      cli-truncate: 2.1.0
+      colorette: 2.0.16
+      log-update: 4.0.0
+      p-map: 4.0.0
+      rfdc: 1.3.0
+      rxjs: 7.5.5
+      through: 2.3.8
+      wrap-ansi: 7.0.0
+    dev: true
+
+  /load-json-file/4.0.0:
+    resolution: {integrity: sha1-L19Fq5HjMhYjT9U62rZo607AmTs=}
+    engines: {node: '>=4'}
+    dependencies:
+      graceful-fs: 4.2.10
+      parse-json: 4.0.0
+      pify: 3.0.0
+      strip-bom: 3.0.0
+    dev: true
+
+  /local-pkg/0.4.1:
+    resolution: {integrity: sha512-lL87ytIGP2FU5PWwNDo0w3WhIo2gopIAxPg9RxDYF7m4rr5ahuZxP22xnJHIvaLTe4Z9P6uKKY2UHiwyB4pcrw==}
+    engines: {node: '>=14'}
+    dev: true
+
+  /locate-path/2.0.0:
+    resolution: {integrity: sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=}
+    engines: {node: '>=4'}
+    dependencies:
+      p-locate: 2.0.0
+      path-exists: 3.0.0
+    dev: true
+
+  /locate-path/5.0.0:
+    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
+    engines: {node: '>=8'}
+    dependencies:
+      p-locate: 4.1.0
+    dev: true
+
+  /locate-path/6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+    dependencies:
+      p-locate: 5.0.0
+    dev: true
+
+  /lodash._reinterpolate/3.0.0:
+    resolution: {integrity: sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=}
+    dev: true
+
+  /lodash.ismatch/4.4.0:
+    resolution: {integrity: sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc=}
+    dev: true
+
+  /lodash.map/4.6.0:
+    resolution: {integrity: sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=}
+    dev: true
+
+  /lodash.merge/4.6.2:
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
+    dev: true
+
+  /lodash.sortby/4.7.0:
+    resolution: {integrity: sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=}
+    dev: true
+
+  /lodash.template/4.5.0:
+    resolution: {integrity: sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==}
+    dependencies:
+      lodash._reinterpolate: 3.0.0
+      lodash.templatesettings: 4.2.0
+    dev: true
+
+  /lodash.templatesettings/4.2.0:
+    resolution: {integrity: sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==}
+    dependencies:
+      lodash._reinterpolate: 3.0.0
+    dev: true
+
+  /lodash.uniq/4.5.0:
+    resolution: {integrity: sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=}
+    dev: true
+
+  /lodash/4.17.21:
+    resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
+    dev: true
+
+  /log-update/4.0.0:
+    resolution: {integrity: sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-escapes: 4.3.2
+      cli-cursor: 3.1.0
+      slice-ansi: 4.0.0
+      wrap-ansi: 6.2.0
+    dev: true
+
+  /longest/2.0.1:
+    resolution: {integrity: sha1-eB4YMpaqlPbU2RbcM10NF676I/g=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /loupe/2.3.4:
+    resolution: {integrity: sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==}
+    dependencies:
+      get-func-name: 2.0.0
+    dev: true
+
+  /lru-cache/4.1.5:
+    resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==}
+    dependencies:
+      pseudomap: 1.0.2
+      yallist: 2.1.2
+    dev: true
+
+  /lru-cache/6.0.0:
+    resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
+    engines: {node: '>=10'}
+    dependencies:
+      yallist: 4.0.0
+    dev: true
+
+  /lru-cache/7.10.1:
+    resolution: {integrity: sha512-BQuhQxPuRl79J5zSXRP+uNzPOyZw2oFI9JLRQ80XswSvg21KMKNtQza9eF42rfI/3Z40RvzBdXgziEkudzjo8A==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /magic-string/0.25.9:
+    resolution: {integrity: sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==}
+    dependencies:
+      sourcemap-codec: 1.4.8
+    dev: true
+
+  /make-dir/3.1.0:
+    resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
+    engines: {node: '>=8'}
+    dependencies:
+      semver: 6.3.0
+    dev: true
+
+  /make-error/1.3.6:
+    resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
+    dev: true
+
+  /map-obj/1.0.1:
+    resolution: {integrity: sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /map-obj/4.3.0:
+    resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /meow/8.1.2:
+    resolution: {integrity: sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@types/minimist': 1.2.2
+      camelcase-keys: 6.2.2
+      decamelize-keys: 1.1.0
+      hard-rejection: 2.1.0
+      minimist-options: 4.1.0
+      normalize-package-data: 3.0.3
+      read-pkg-up: 7.0.1
+      redent: 3.0.0
+      trim-newlines: 3.0.1
+      type-fest: 0.18.1
+      yargs-parser: 20.2.9
+    dev: true
+
+  /merge-stream/2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+    dev: true
+
+  /merge/2.1.1:
+    resolution: {integrity: sha512-jz+Cfrg9GWOZbQAnDQ4hlVnQky+341Yk5ru8bZSe6sIDTCIg8n9i/u7hSQGSVOF3C7lH6mGtqjkiT9G4wFLL0w==}
+    dev: true
+
+  /merge2/1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+    dev: true
+
+  /micromatch/4.0.5:
+    resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==}
+    engines: {node: '>=8.6'}
+    dependencies:
+      braces: 3.0.2
+      picomatch: 2.3.1
+    dev: true
+
+  /mime/1.6.0:
+    resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
+    engines: {node: '>=4'}
+    hasBin: true
+    dev: true
+
+  /mimic-fn/1.2.0:
+    resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /mimic-fn/2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /min-indent/1.0.1:
+    resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /minimatch/3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+    dependencies:
+      brace-expansion: 1.1.11
+    dev: true
+
+  /minimist-options/4.1.0:
+    resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==}
+    engines: {node: '>= 6'}
+    dependencies:
+      arrify: 1.0.1
+      is-plain-obj: 1.1.0
+      kind-of: 6.0.3
+    dev: true
+
+  /minimist/1.2.5:
+    resolution: {integrity: sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==}
+    dev: true
+
+  /minimist/1.2.6:
+    resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==}
+    dev: true
+
+  /mkdirp/0.5.6:
+    resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
+    hasBin: true
+    dependencies:
+      minimist: 1.2.6
+    dev: true
+
+  /modify-values/1.0.1:
+    resolution: {integrity: sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /ms/2.1.2:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+    dev: true
+
+  /ms/2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+    dev: true
+
+  /mute-stream/0.0.7:
+    resolution: {integrity: sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=}
+    dev: true
+
+  /nanoid/3.3.4:
+    resolution: {integrity: sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+    dev: true
+
+  /natural-compare/1.4.0:
+    resolution: {integrity: sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=}
+    dev: true
+
+  /neo-async/2.6.2:
+    resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
+    dev: true
+
+  /normalize-package-data/2.5.0:
+    resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
+    dependencies:
+      hosted-git-info: 2.8.9
+      resolve: 1.22.0
+      semver: 5.7.1
+      validate-npm-package-license: 3.0.4
+    dev: true
+
+  /normalize-package-data/3.0.3:
+    resolution: {integrity: sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==}
+    engines: {node: '>=10'}
+    dependencies:
+      hosted-git-info: 4.1.0
+      is-core-module: 2.9.0
+      semver: 7.3.7
+      validate-npm-package-license: 3.0.4
+    dev: true
+
+  /normalize-path/1.0.0:
+    resolution: {integrity: sha1-MtDkcvkf80VwHBWoMRAY07CpA3k=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /normalize-path/3.0.0:
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /npm-run-path/2.0.2:
+    resolution: {integrity: sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=}
+    engines: {node: '>=4'}
+    dependencies:
+      path-key: 2.0.1
+    dev: true
+
+  /npm-run-path/4.0.1:
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
+    dependencies:
+      path-key: 3.1.1
+    dev: true
+
+  /object-inspect/1.12.0:
+    resolution: {integrity: sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==}
+    dev: true
+
+  /once/1.4.0:
+    resolution: {integrity: sha1-WDsap3WWHUsROsF9nFC6753Xa9E=}
+    dependencies:
+      wrappy: 1.0.2
+    dev: true
+
+  /onetime/2.0.1:
+    resolution: {integrity: sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=}
+    engines: {node: '>=4'}
+    dependencies:
+      mimic-fn: 1.2.0
+    dev: true
+
+  /onetime/5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+    dependencies:
+      mimic-fn: 2.1.0
+    dev: true
+
+  /opener/1.5.2:
+    resolution: {integrity: sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==}
+    hasBin: true
+    dev: true
+
+  /optionator/0.8.3:
+    resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.3.0
+      prelude-ls: 1.1.2
+      type-check: 0.3.2
+      word-wrap: 1.2.3
+    dev: true
+
+  /optionator/0.9.1:
+    resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.3
+    dev: true
+
+  /os-tmpdir/1.0.2:
+    resolution: {integrity: sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /p-finally/1.0.0:
+    resolution: {integrity: sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /p-limit/1.3.0:
+    resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==}
+    engines: {node: '>=4'}
+    dependencies:
+      p-try: 1.0.0
+    dev: true
+
+  /p-limit/2.3.0:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+    dependencies:
+      p-try: 2.2.0
+    dev: true
+
+  /p-limit/3.1.0:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      yocto-queue: 0.1.0
+    dev: true
+
+  /p-locate/2.0.0:
+    resolution: {integrity: sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=}
+    engines: {node: '>=4'}
+    dependencies:
+      p-limit: 1.3.0
+    dev: true
+
+  /p-locate/4.1.0:
+    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
+    engines: {node: '>=8'}
+    dependencies:
+      p-limit: 2.3.0
+    dev: true
+
+  /p-locate/5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+    dependencies:
+      p-limit: 3.1.0
+    dev: true
+
+  /p-map/4.0.0:
+    resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      aggregate-error: 3.1.0
+    dev: true
+
+  /p-try/1.0.0:
+    resolution: {integrity: sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /p-try/2.2.0:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /parent-module/1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+    dependencies:
+      callsites: 3.1.0
+    dev: true
+
+  /parse-json/4.0.0:
+    resolution: {integrity: sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=}
+    engines: {node: '>=4'}
+    dependencies:
+      error-ex: 1.3.2
+      json-parse-better-errors: 1.0.2
+    dev: true
+
+  /parse-json/5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+    dependencies:
+      '@babel/code-frame': 7.16.7
+      error-ex: 1.3.2
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+    dev: true
+
+  /parse-passwd/1.0.0:
+    resolution: {integrity: sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /path-exists/3.0.0:
+    resolution: {integrity: sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /path-exists/4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /path-is-absolute/1.0.1:
+    resolution: {integrity: sha1-F0uSaHNVNP+8es5r9TpanhtcX18=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /path-is-network-drive/1.0.15:
+    resolution: {integrity: sha512-bJGs1SxUne+q29P1xCLMkNBhMetku+vPN+yVQu8FGL/7diHesCSSIKoF4Wq42tcbwm7rK72XrGfK8FUXN00LLQ==}
+    dependencies:
+      tslib: 2.4.0
+    dev: true
+
+  /path-key/2.0.1:
+    resolution: {integrity: sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /path-key/3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /path-parse/1.0.7:
+    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
+    dev: true
+
+  /path-strip-sep/1.0.12:
+    resolution: {integrity: sha512-EJZSC5WBjVlA9XHLCiluiyisYg6yzeMJ4nY3BQVCuedyEHA/I2crcHWdwuQ74h3V599U9nEbEZUTvvSxOK3vbQ==}
+    dependencies:
+      tslib: 2.4.0
+    dev: true
+
+  /path-type/3.0.0:
+    resolution: {integrity: sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==}
+    engines: {node: '>=4'}
+    dependencies:
+      pify: 3.0.0
+    dev: true
+
+  /path-type/4.0.0:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /pathval/1.1.1:
+    resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
+    dev: true
+
+  /picocolors/1.0.0:
+    resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}
+    dev: true
+
+  /picomatch/2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+    dev: true
+
+  /pidtree/0.5.0:
+    resolution: {integrity: sha512-9nxspIM7OpZuhBxPg73Zvyq7j1QMPMPsGKTqRc2XOaFQauDvoNz9fM1Wdkjmeo7l9GXOZiRs97sPkuayl39wjA==}
+    engines: {node: '>=0.10'}
+    hasBin: true
+    dev: true
+
+  /pify/2.3.0:
+    resolution: {integrity: sha1-7RQaasBDqEnqWISY59yosVMw6Qw=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /pify/3.0.0:
+    resolution: {integrity: sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /pkg-dir/4.2.0:
+    resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      find-up: 4.1.0
+    dev: true
+
+  /pkg-dir/5.0.0:
+    resolution: {integrity: sha512-NPE8TDbzl/3YQYY7CSS228s3g2ollTFnc+Qi3tqmqJp9Vg2ovUpixcJEo2HJScN2Ez+kEaal6y70c0ehqJBJeA==}
+    engines: {node: '>=10'}
+    dependencies:
+      find-up: 5.0.0
+    dev: true
+
+  /portfinder/1.0.28:
+    resolution: {integrity: sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==}
+    engines: {node: '>= 0.12.0'}
+    dependencies:
+      async: 2.6.4
+      debug: 3.2.7
+      mkdirp: 0.5.6
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /postcss/8.4.14:
+    resolution: {integrity: sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==}
+    engines: {node: ^10 || ^12 || >=14}
+    dependencies:
+      nanoid: 3.3.4
+      picocolors: 1.0.0
+      source-map-js: 1.0.2
+    dev: true
+
+  /prelude-ls/1.1.2:
+    resolution: {integrity: sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=}
+    engines: {node: '>= 0.8.0'}
+    dev: true
+
+  /prelude-ls/1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+    dev: true
+
+  /process-nextick-args/2.0.1:
+    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
+    dev: true
+
+  /pseudomap/1.0.2:
+    resolution: {integrity: sha1-8FKijacOYYkX7wqKw0wa5aaChrM=}
+    dev: true
+
+  /punycode/2.1.1:
+    resolution: {integrity: sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /q/1.5.1:
+    resolution: {integrity: sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=}
+    engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
+    dev: true
+
+  /qs/6.10.3:
+    resolution: {integrity: sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==}
+    engines: {node: '>=0.6'}
+    dependencies:
+      side-channel: 1.0.4
+    dev: true
+
+  /queue-microtask/1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+    dev: true
+
+  /quick-lru/4.0.1:
+    resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /randombytes/2.1.0:
+    resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: true
+
+  /read-pkg-up/3.0.0:
+    resolution: {integrity: sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=}
+    engines: {node: '>=4'}
+    dependencies:
+      find-up: 2.1.0
+      read-pkg: 3.0.0
+    dev: true
+
+  /read-pkg-up/7.0.1:
+    resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==}
+    engines: {node: '>=8'}
+    dependencies:
+      find-up: 4.1.0
+      read-pkg: 5.2.0
+      type-fest: 0.8.1
+    dev: true
+
+  /read-pkg/3.0.0:
+    resolution: {integrity: sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=}
+    engines: {node: '>=4'}
+    dependencies:
+      load-json-file: 4.0.0
+      normalize-package-data: 2.5.0
+      path-type: 3.0.0
+    dev: true
+
+  /read-pkg/5.2.0:
+    resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==}
+    engines: {node: '>=8'}
+    dependencies:
+      '@types/normalize-package-data': 2.4.1
+      normalize-package-data: 2.5.0
+      parse-json: 5.2.0
+      type-fest: 0.6.0
+    dev: true
+
+  /readable-stream/2.3.7:
+    resolution: {integrity: sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==}
+    dependencies:
+      core-util-is: 1.0.3
+      inherits: 2.0.4
+      isarray: 1.0.0
+      process-nextick-args: 2.0.1
+      safe-buffer: 5.1.2
+      string_decoder: 1.1.1
+      util-deprecate: 1.0.2
+    dev: true
+
+  /readable-stream/3.6.0:
+    resolution: {integrity: sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==}
+    engines: {node: '>= 6'}
+    dependencies:
+      inherits: 2.0.4
+      string_decoder: 1.3.0
+      util-deprecate: 1.0.2
+    dev: true
+
+  /rechoir/0.6.2:
+    resolution: {integrity: sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=}
+    engines: {node: '>= 0.10'}
+    dependencies:
+      resolve: 1.22.0
+    dev: true
+
+  /redent/3.0.0:
+    resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==}
+    engines: {node: '>=8'}
+    dependencies:
+      indent-string: 4.0.0
+      strip-indent: 3.0.0
+    dev: true
+
+  /regexpp/3.2.0:
+    resolution: {integrity: sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /require-directory/2.1.1:
+    resolution: {integrity: sha1-jGStX9MNqxyXbiNE/+f3kqam30I=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /requires-port/1.0.0:
+    resolution: {integrity: sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=}
+    dev: true
+
+  /resolve-dir/1.0.1:
+    resolution: {integrity: sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      expand-tilde: 2.0.2
+      global-modules: 1.0.0
+    dev: true
+
+  /resolve-from/4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /resolve-from/5.0.0:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+    dev: true
+    optional: true
+
+  /resolve-global/1.0.0:
+    resolution: {integrity: sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==}
+    engines: {node: '>=8'}
+    dependencies:
+      global-dirs: 0.1.1
+    dev: true
+    optional: true
+
+  /resolve-url/0.2.1:
+    resolution: {integrity: sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=}
+    deprecated: https://github.com/lydell/resolve-url#deprecated
+    dev: true
+
+  /resolve/1.22.0:
+    resolution: {integrity: sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==}
+    hasBin: true
+    dependencies:
+      is-core-module: 2.9.0
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
+    dev: true
+
+  /restore-cursor/2.0.0:
+    resolution: {integrity: sha1-n37ih/gv0ybU/RYpI9YhKe7g368=}
+    engines: {node: '>=4'}
+    dependencies:
+      onetime: 2.0.1
+      signal-exit: 3.0.7
+    dev: true
+
+  /restore-cursor/3.1.0:
+    resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==}
+    engines: {node: '>=8'}
+    dependencies:
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+    dev: true
+
+  /reusify/1.0.4:
+    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+    dev: true
+
+  /rfdc/1.3.0:
+    resolution: {integrity: sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==}
+    dev: true
+
+  /rimraf/3.0.2:
+    resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
+    hasBin: true
+    dependencies:
+      glob: 7.2.3
+    dev: true
+
+  /rollup-plugin-typescript2/0.31.2_dyu3set7imqii5ytavmnwecwpy:
+    resolution: {integrity: sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==}
+    peerDependencies:
+      rollup: '>=1.26.3'
+      typescript: '>=2.4.0'
+    dependencies:
+      '@rollup/pluginutils': 4.2.1
+      '@yarn-tool/resolve-package': 1.0.47
+      find-cache-dir: 3.3.2
+      fs-extra: 10.1.0
+      resolve: 1.22.0
+      rollup: 2.74.0
+      tslib: 2.4.0
+      typescript: 4.6.4
+    dev: true
+
+  /rollup/2.74.0:
+    resolution: {integrity: sha512-RRwXTX5+ObPJhcMV6zP3RdHvy90/lBOUfbzL7IKkFjMJGAqeBGZiv9nZWm/DoTESaTE3GBkkzbU9QVN2AuCkjw==}
+    engines: {node: '>=10.0.0'}
+    hasBin: true
+    optionalDependencies:
+      fsevents: 2.3.2
+    dev: true
+
+  /run-async/2.4.1:
+    resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==}
+    engines: {node: '>=0.12.0'}
+    dev: true
+
+  /run-parallel/1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+    dependencies:
+      queue-microtask: 1.2.3
+    dev: true
+
+  /rxjs/6.6.7:
+    resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==}
+    engines: {npm: '>=2.0.0'}
+    dependencies:
+      tslib: 1.14.1
+    dev: true
+
+  /rxjs/7.5.5:
+    resolution: {integrity: sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==}
+    dependencies:
+      tslib: 2.4.0
+    dev: true
+
+  /safe-buffer/5.1.2:
+    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
+    dev: true
+
+  /safe-buffer/5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+    dev: true
+
+  /safer-buffer/2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+    dev: true
+
+  /secure-compare/3.0.1:
+    resolution: {integrity: sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=}
+    dev: true
+
+  /semver/5.7.1:
+    resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==}
+    hasBin: true
+    dev: true
+
+  /semver/6.3.0:
+    resolution: {integrity: sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==}
+    hasBin: true
+    dev: true
+
+  /semver/7.3.7:
+    resolution: {integrity: sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      lru-cache: 6.0.0
+    dev: true
+
+  /serialize-javascript/6.0.0:
+    resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==}
+    dependencies:
+      randombytes: 2.1.0
+    dev: true
+
+  /shebang-command/1.2.0:
+    resolution: {integrity: sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      shebang-regex: 1.0.0
+    dev: true
+
+  /shebang-command/2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+    dependencies:
+      shebang-regex: 3.0.0
+    dev: true
+
+  /shebang-regex/1.0.0:
+    resolution: {integrity: sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /shebang-regex/3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /shelljs/0.8.5:
+    resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==}
+    engines: {node: '>=4'}
+    hasBin: true
+    dependencies:
+      glob: 7.2.3
+      interpret: 1.4.0
+      rechoir: 0.6.2
+    dev: true
+
+  /side-channel/1.0.4:
+    resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
+    dependencies:
+      call-bind: 1.0.2
+      get-intrinsic: 1.1.1
+      object-inspect: 1.12.0
+    dev: true
+
+  /signal-exit/3.0.7:
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
+    dev: true
+
+  /slash/3.0.0:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /slice-ansi/3.0.0:
+    resolution: {integrity: sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      ansi-styles: 4.3.0
+      astral-regex: 2.0.0
+      is-fullwidth-code-point: 3.0.0
+    dev: true
+
+  /slice-ansi/4.0.0:
+    resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-styles: 4.3.0
+      astral-regex: 2.0.0
+      is-fullwidth-code-point: 3.0.0
+    dev: true
+
+  /slice-ansi/5.0.0:
+    resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      ansi-styles: 6.1.0
+      is-fullwidth-code-point: 4.0.0
+    dev: true
+
+  /source-map-js/1.0.2:
+    resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /source-map-resolve/0.5.3:
+    resolution: {integrity: sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==}
+    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
+    dependencies:
+      atob: 2.1.2
+      decode-uri-component: 0.2.0
+      resolve-url: 0.2.1
+      source-map-url: 0.4.1
+      urix: 0.1.0
+    dev: true
+
+  /source-map-support/0.5.21:
+    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
+    dependencies:
+      buffer-from: 1.1.2
+      source-map: 0.6.1
+    dev: true
+
+  /source-map-url/0.4.1:
+    resolution: {integrity: sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==}
+    deprecated: See https://github.com/lydell/source-map-url#deprecated
+    dev: true
+
+  /source-map/0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /source-map/0.8.0-beta.0:
+    resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==}
+    engines: {node: '>= 8'}
+    dependencies:
+      whatwg-url: 7.1.0
+    dev: true
+
+  /sourcemap-codec/1.4.8:
+    resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==}
+    dev: true
+
+  /spdx-correct/3.1.1:
+    resolution: {integrity: sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==}
+    dependencies:
+      spdx-expression-parse: 3.0.1
+      spdx-license-ids: 3.0.11
+    dev: true
+
+  /spdx-exceptions/2.3.0:
+    resolution: {integrity: sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==}
+    dev: true
+
+  /spdx-expression-parse/3.0.1:
+    resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==}
+    dependencies:
+      spdx-exceptions: 2.3.0
+      spdx-license-ids: 3.0.11
+    dev: true
+
+  /spdx-license-ids/3.0.11:
+    resolution: {integrity: sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==}
+    dev: true
+
+  /split/1.0.1:
+    resolution: {integrity: sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==}
+    dependencies:
+      through: 2.3.8
+    dev: true
+
+  /split2/3.2.2:
+    resolution: {integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==}
+    dependencies:
+      readable-stream: 3.6.0
+    dev: true
+
+  /stream-browserify/3.0.0:
+    resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==}
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 3.6.0
+    dev: true
+
+  /string-argv/0.3.1:
+    resolution: {integrity: sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==}
+    engines: {node: '>=0.6.19'}
+    dev: true
+
+  /string-width/2.1.1:
+    resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==}
+    engines: {node: '>=4'}
+    dependencies:
+      is-fullwidth-code-point: 2.0.0
+      strip-ansi: 4.0.0
+    dev: true
+
+  /string-width/4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+    dev: true
+
+  /string-width/5.1.2:
+    resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
+    engines: {node: '>=12'}
+    dependencies:
+      eastasianwidth: 0.2.0
+      emoji-regex: 9.2.2
+      strip-ansi: 7.0.1
+    dev: true
+
+  /string_decoder/1.1.1:
+    resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
+    dependencies:
+      safe-buffer: 5.1.2
+    dev: true
+
+  /string_decoder/1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: true
+
+  /strip-ansi/4.0.0:
+    resolution: {integrity: sha1-qEeQIusaw2iocTibY1JixQXuNo8=}
+    engines: {node: '>=4'}
+    dependencies:
+      ansi-regex: 3.0.1
+    dev: true
+
+  /strip-ansi/5.2.0:
+    resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==}
+    engines: {node: '>=6'}
+    dependencies:
+      ansi-regex: 4.1.1
+    dev: true
+
+  /strip-ansi/6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+    dependencies:
+      ansi-regex: 5.0.1
+    dev: true
+
+  /strip-ansi/7.0.1:
+    resolution: {integrity: sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw==}
+    engines: {node: '>=12'}
+    dependencies:
+      ansi-regex: 6.0.1
+    dev: true
+
+  /strip-bom/3.0.0:
+    resolution: {integrity: sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /strip-bom/4.0.0:
+    resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /strip-eof/1.0.0:
+    resolution: {integrity: sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /strip-final-newline/2.0.0:
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /strip-indent/2.0.0:
+    resolution: {integrity: sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=}
+    engines: {node: '>=4'}
+    dev: true
+
+  /strip-indent/3.0.0:
+    resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      min-indent: 1.0.1
+    dev: true
+
+  /strip-json-comments/3.0.1:
+    resolution: {integrity: sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /strip-json-comments/3.1.1:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /supports-color/5.5.0:
+    resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
+    engines: {node: '>=4'}
+    dependencies:
+      has-flag: 3.0.0
+    dev: true
+
+  /supports-color/7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+    dependencies:
+      has-flag: 4.0.0
+    dev: true
+
+  /supports-color/9.2.2:
+    resolution: {integrity: sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /supports-preserve-symlinks-flag/1.0.0:
+    resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /terser/5.13.1:
+    resolution: {integrity: sha512-hn4WKOfwnwbYfe48NgrQjqNOH9jzLqRcIfbYytOXCOv46LBfWr9bDS17MQqOi+BWGD0sJK3Sj5NC/gJjiojaoA==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      acorn: 8.7.1
+      commander: 2.20.3
+      source-map: 0.8.0-beta.0
+      source-map-support: 0.5.21
+    dev: true
+
+  /text-extensions/1.9.0:
+    resolution: {integrity: sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==}
+    engines: {node: '>=0.10'}
+    dev: true
+
+  /text-table/0.2.0:
+    resolution: {integrity: sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=}
+    dev: true
+
+  /through/2.3.8:
+    resolution: {integrity: sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=}
+    dev: true
+
+  /through2/2.0.5:
+    resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==}
+    dependencies:
+      readable-stream: 2.3.7
+      xtend: 4.0.2
+    dev: true
+
+  /through2/4.0.2:
+    resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==}
+    dependencies:
+      readable-stream: 3.6.0
+    dev: true
+
+  /tinypool/0.1.3:
+    resolution: {integrity: sha512-2IfcQh7CP46XGWGGbdyO4pjcKqsmVqFAPcXfPxcPXmOWt9cYkTP9HcDmGgsfijYoAEc4z9qcpM/BaBz46Y9/CQ==}
+    engines: {node: '>=14.0.0'}
+    dev: true
+
+  /tinyspy/0.3.2:
+    resolution: {integrity: sha512-2+40EP4D3sFYy42UkgkFFB+kiX2Tg3URG/lVvAZFfLxgGpnWl5qQJuBw1gaLttq8UOS+2p3C0WrhJnQigLTT2Q==}
+    engines: {node: '>=14.0.0'}
+    dev: true
+
+  /tmp/0.0.33:
+    resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
+    engines: {node: '>=0.6.0'}
+    dependencies:
+      os-tmpdir: 1.0.2
+    dev: true
+
+  /to-regex-range/5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+    dependencies:
+      is-number: 7.0.0
+    dev: true
+
+  /tr46/1.0.1:
+    resolution: {integrity: sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=}
+    dependencies:
+      punycode: 2.1.1
+    dev: true
+
+  /trim-newlines/3.0.1:
+    resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /ts-node/10.7.0_3smuweqyuzdazdnyhhezld6mfa:
+    resolution: {integrity: sha512-TbIGS4xgJoX2i3do417KSaep1uRAW/Lu+WAL2doDHC0D6ummjirVOXU5/7aiZotbQ5p1Zp9tP7U6cYhA0O7M8A==}
+    hasBin: true
+    peerDependencies:
+      '@swc/core': '>=1.2.50'
+      '@swc/wasm': '>=1.2.50'
+      '@types/node': '*'
+      typescript: '>=2.7'
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      '@swc/wasm':
+        optional: true
+    dependencies:
+      '@cspotcode/source-map-support': 0.7.0
+      '@tsconfig/node10': 1.0.8
+      '@tsconfig/node12': 1.0.9
+      '@tsconfig/node14': 1.0.1
+      '@tsconfig/node16': 1.0.2
+      '@types/node': 17.0.34
+      acorn: 8.7.1
+      acorn-walk: 8.2.0
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 4.6.4
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+    dev: true
+
+  /tslib/1.14.1:
+    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+    dev: true
+
+  /tslib/2.4.0:
+    resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==}
+    dev: true
+
+  /tsutils/3.21.0_typescript@4.6.4:
+    resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
+    engines: {node: '>= 6'}
+    peerDependencies:
+      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
+    dependencies:
+      tslib: 1.14.1
+      typescript: 4.6.4
+    dev: true
+
+  /type-check/0.3.2:
+    resolution: {integrity: sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      prelude-ls: 1.1.2
+    dev: true
+
+  /type-check/0.4.0:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      prelude-ls: 1.2.1
+    dev: true
+
+  /type-detect/4.0.8:
+    resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /type-fest/0.18.1:
+    resolution: {integrity: sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /type-fest/0.20.2:
+    resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /type-fest/0.21.3:
+    resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /type-fest/0.6.0:
+    resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /type-fest/0.8.1:
+    resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /typescript/4.6.4:
+    resolution: {integrity: sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg==}
+    engines: {node: '>=4.2.0'}
+    hasBin: true
+    dev: true
+
+  /uglify-js/3.15.5:
+    resolution: {integrity: sha512-hNM5q5GbBRB5xB+PMqVRcgYe4c8jbyZ1pzZhS6jbq54/4F2gFK869ZheiE5A8/t+W5jtTNpWef/5Q9zk639FNQ==}
+    engines: {node: '>=0.8.0'}
+    hasBin: true
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /union/0.5.0:
+    resolution: {integrity: sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      qs: 6.10.3
+    dev: true
+
+  /universalify/0.1.2:
+    resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
+    engines: {node: '>= 4.0.0'}
+    dev: true
+
+  /universalify/2.0.0:
+    resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==}
+    engines: {node: '>= 10.0.0'}
+    dev: true
+
+  /upath2/3.1.13:
+    resolution: {integrity: sha512-M88uBoqgzrkXvXrF/+oSIPsTmL21uRwGhPVJKODrl+3lXkQ5NPKrTYuSBZVa+lgPGFoI6qYyHlSKACFHO0AoNw==}
+    dependencies:
+      '@types/node': 17.0.34
+      path-is-network-drive: 1.0.15
+      path-strip-sep: 1.0.12
+      tslib: 2.4.0
+    dev: true
+
+  /uri-js/4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+    dependencies:
+      punycode: 2.1.1
+    dev: true
+
+  /urix/0.1.0:
+    resolution: {integrity: sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=}
+    deprecated: Please see https://github.com/lydell/urix#deprecated
+    dev: true
+
+  /url-join/4.0.1:
+    resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
+    dev: true
+
+  /util-deprecate/1.0.2:
+    resolution: {integrity: sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=}
+    dev: true
+
+  /v8-compile-cache-lib/3.0.1:
+    resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
+    dev: true
+
+  /v8-compile-cache/2.3.0:
+    resolution: {integrity: sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==}
+    dev: true
+
+  /validate-npm-package-license/3.0.4:
+    resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
+    dependencies:
+      spdx-correct: 3.1.1
+      spdx-expression-parse: 3.0.1
+    dev: true
+
+  /vite/2.9.9:
+    resolution: {integrity: sha512-ffaam+NgHfbEmfw/Vuh6BHKKlI/XIAhxE5QSS7gFLIngxg171mg1P3a4LSRME0z2ZU1ScxoKzphkipcYwSD5Ew==}
+    engines: {node: '>=12.2.0'}
+    hasBin: true
+    peerDependencies:
+      less: '*'
+      sass: '*'
+      stylus: '*'
+    peerDependenciesMeta:
+      less:
+        optional: true
+      sass:
+        optional: true
+      stylus:
+        optional: true
+    dependencies:
+      esbuild: 0.14.39
+      postcss: 8.4.14
+      resolve: 1.22.0
+      rollup: 2.74.0
+    optionalDependencies:
+      fsevents: 2.3.2
+    dev: true
+
+  /vitest/0.12.6:
+    resolution: {integrity: sha512-YWbCTv0XKBuBw5YtuW/iufuguoi8QhGpYyi2g57Oo7akpscMkkWTAaZGgY0ux1oJJtO/pc/8GFt0EF32WFBUUQ==}
+    engines: {node: '>=v14.16.0'}
+    hasBin: true
+    peerDependencies:
+      '@vitest/ui': '*'
+      c8: '*'
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@vitest/ui':
+        optional: true
+      c8:
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+    dependencies:
+      '@types/chai': 4.3.1
+      '@types/chai-subset': 1.3.3
+      chai: 4.3.6
+      local-pkg: 0.4.1
+      tinypool: 0.1.3
+      tinyspy: 0.3.2
+      vite: 2.9.9
+    transitivePeerDependencies:
+      - less
+      - sass
+      - stylus
+    dev: true
+
+  /webidl-conversions/4.0.2:
+    resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
+    dev: true
+
+  /weex-js-runtime/0.23.7:
+    resolution: {integrity: sha512-3BFd5GXTo0X/GWh0KjzXDpIcPJuSwYuc9fE9llgez35IfVHs/nUmfkFBjifzxOJS2YLhtKf0Cy8eTQ00CJDWZA==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /weex-styler/0.3.1:
+    resolution: {integrity: sha512-xkX5/wS/QLiJXKwbdpeytbLN0kHviQwj9CLdvBxqu+RRZABZpTniKZr1oxjh9Q0+n/aRC+smwFpQpUKvXh9V1g==}
+    dependencies:
+      css: 2.2.4
+    dev: true
+
+  /whatwg-encoding/2.0.0:
+    resolution: {integrity: sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg==}
+    engines: {node: '>=12'}
+    dependencies:
+      iconv-lite: 0.6.3
+    dev: true
+
+  /whatwg-url/7.1.0:
+    resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==}
+    dependencies:
+      lodash.sortby: 4.7.0
+      tr46: 1.0.1
+      webidl-conversions: 4.0.2
+    dev: true
+
+  /which/1.3.1:
+    resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==}
+    hasBin: true
+    dependencies:
+      isexe: 2.0.0
+    dev: true
+
+  /which/2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+    dependencies:
+      isexe: 2.0.0
+    dev: true
+
+  /word-wrap/1.2.3:
+    resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /wordwrap/1.0.0:
+    resolution: {integrity: sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=}
+    dev: true
+
+  /wrap-ansi/6.2.0:
+    resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
+    engines: {node: '>=8'}
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+    dev: true
+
+  /wrap-ansi/7.0.0:
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+    dev: true
+
+  /wrappy/1.0.2:
+    resolution: {integrity: sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=}
+    dev: true
+
+  /xtend/4.0.2:
+    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
+    engines: {node: '>=0.4'}
+    dev: true
+
+  /y18n/5.0.8:
+    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /yallist/2.1.2:
+    resolution: {integrity: sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=}
+    dev: true
+
+  /yallist/4.0.0:
+    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+    dev: true
+
+  /yaml/1.10.2:
+    resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==}
+    engines: {node: '>= 6'}
+    dev: true
+
+  /yargs-parser/20.2.9:
+    resolution: {integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /yargs/16.2.0:
+    resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==}
+    engines: {node: '>=10'}
+    dependencies:
+      cliui: 7.0.4
+      escalade: 3.1.1
+      get-caller-file: 2.0.5
+      require-directory: 2.1.1
+      string-width: 4.2.3
+      y18n: 5.0.8
+      yargs-parser: 20.2.9
+    dev: true
+
+  /yn/3.1.1:
+    resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /yocto-queue/0.1.0:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /yorkie/2.0.0:
+    resolution: {integrity: sha512-jcKpkthap6x63MB4TxwCyuIGkV0oYP/YRyuQU5UO0Yz/E/ZAu+653/uov+phdmO54n6BcvFRyyt0RRrWdN2mpw==}
+    engines: {node: '>=4'}
+    requiresBuild: true
+    dependencies:
+      execa: 0.8.0
+      is-ci: 1.2.1
+      normalize-path: 1.0.0
+      strip-indent: 2.0.0
+    dev: true
diff --git a/test/unit/features/component/component-async.spec.ts b/test/unit/features/component/component-async.spec.ts
index f4f6cf14cf1..2b5e9500715 100644
--- a/test/unit/features/component/component-async.spec.ts
+++ b/test/unit/features/component/component-async.spec.ts
@@ -1,5 +1,4 @@
 import Vue from 'vue'
-import { Promise } from 'es6-promise'
 
 describe('Component async', () => {
 
diff --git a/tsconfig.json b/tsconfig.json
index b7acb2a804c..552510a7d64 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,11 +19,7 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": [
-      "node",
-      "jasmine",
-      "webpack-env"
-    ],
+    "types": ["node"],
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
@@ -40,5 +36,5 @@
   },
   "include": ["src", "test-dts", "typescript", "test"],
 
-  "exclude": ["flow", "node_modules", "packages", "types"]
+  "exclude": ["node_modules", "packages", "types"]
 }
diff --git a/yarn.lock b/yarn.lock
deleted file mode 100644
index 18a82afac79..00000000000
--- a/yarn.lock
+++ /dev/null
@@ -1,9337 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-"@ampproject/remapping@^2.1.0":
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.0.tgz#56c133824780de3174aed5ab6834f3026790154d"
-  integrity sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w==
-  dependencies:
-    "@jridgewell/gen-mapping" "^0.1.0"
-    "@jridgewell/trace-mapping" "^0.3.9"
-
-"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.16.7.tgz#44416b6bd7624b998f5b1af5d470856c40138789"
-  integrity sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg==
-  dependencies:
-    "@babel/highlight" "^7.16.7"
-
-"@babel/compat-data@^7.13.11", "@babel/compat-data@^7.17.0", "@babel/compat-data@^7.17.10":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.17.10.tgz#711dc726a492dfc8be8220028b1b92482362baab"
-  integrity sha512-GZt/TCsG70Ms19gfZO1tM4CVnXsPgEPBCpJu+Qz3L0LUDsY5nZqFZglIoPC1kIYOtNBZlrnFT+klg12vFGZXrw==
-
-"@babel/core@^7.11.1", "@babel/core@^7.12.3", "@babel/core@^7.17.10", "@babel/core@^7.7.5":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.17.10.tgz#74ef0fbf56b7dfc3f198fc2d927f4f03e12f4b05"
-  integrity sha512-liKoppandF3ZcBnIYFjfSDHZLKdLHGJRkoWtG8zQyGJBQfIYobpnVGI5+pLBNtS6psFLDzyq8+h5HiVljW9PNA==
-  dependencies:
-    "@ampproject/remapping" "^2.1.0"
-    "@babel/code-frame" "^7.16.7"
-    "@babel/generator" "^7.17.10"
-    "@babel/helper-compilation-targets" "^7.17.10"
-    "@babel/helper-module-transforms" "^7.17.7"
-    "@babel/helpers" "^7.17.9"
-    "@babel/parser" "^7.17.10"
-    "@babel/template" "^7.16.7"
-    "@babel/traverse" "^7.17.10"
-    "@babel/types" "^7.17.10"
-    convert-source-map "^1.7.0"
-    debug "^4.1.0"
-    gensync "^1.0.0-beta.2"
-    json5 "^2.2.1"
-    semver "^6.3.0"
-
-"@babel/generator@^7.17.10":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.17.10.tgz#c281fa35b0c349bbe9d02916f4ae08fc85ed7189"
-  integrity sha512-46MJZZo9y3o4kmhBVc7zW7i8dtR1oIK/sdO5NcfcZRhTGYi+KKJRtHNgsU6c4VUcJmUNV/LQdebD/9Dlv4K+Tg==
-  dependencies:
-    "@babel/types" "^7.17.10"
-    "@jridgewell/gen-mapping" "^0.1.0"
-    jsesc "^2.5.1"
-
-"@babel/helper-annotate-as-pure@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.16.7.tgz#bb2339a7534a9c128e3102024c60760a3a7f3862"
-  integrity sha512-s6t2w/IPQVTAET1HitoowRGXooX8mCgtuP5195wD/QJPV6wYjpujCGF7JuMODVX2ZAJOf1GT6DT9MHEZvLOFSw==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-builder-binary-assignment-operator-visitor@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.16.7.tgz#38d138561ea207f0f69eb1626a418e4f7e6a580b"
-  integrity sha512-C6FdbRaxYjwVu/geKW4ZeQ0Q31AftgRcdSnZ5/jsH6BzCJbtvXvhpfkbkThYSuutZA7nCXpPR6AD9zd1dprMkA==
-  dependencies:
-    "@babel/helper-explode-assignable-expression" "^7.16.7"
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-compilation-targets@^7.13.0", "@babel/helper-compilation-targets@^7.16.7", "@babel/helper-compilation-targets@^7.17.10":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.17.10.tgz#09c63106d47af93cf31803db6bc49fef354e2ebe"
-  integrity sha512-gh3RxjWbauw/dFiU/7whjd0qN9K6nPJMqe6+Er7rOavFh0CQUSwhAE3IcTho2rywPJFxej6TUUHDkWcYI6gGqQ==
-  dependencies:
-    "@babel/compat-data" "^7.17.10"
-    "@babel/helper-validator-option" "^7.16.7"
-    browserslist "^4.20.2"
-    semver "^6.3.0"
-
-"@babel/helper-create-class-features-plugin@^7.16.10", "@babel/helper-create-class-features-plugin@^7.16.7", "@babel/helper-create-class-features-plugin@^7.17.6":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.17.9.tgz#71835d7fb9f38bd9f1378e40a4c0902fdc2ea49d"
-  integrity sha512-kUjip3gruz6AJKOq5i3nC6CoCEEF/oHH3cp6tOZhB+IyyyPyW0g1Gfsxn3mkk6S08pIA2y8GQh609v9G/5sHVQ==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.16.7"
-    "@babel/helper-environment-visitor" "^7.16.7"
-    "@babel/helper-function-name" "^7.17.9"
-    "@babel/helper-member-expression-to-functions" "^7.17.7"
-    "@babel/helper-optimise-call-expression" "^7.16.7"
-    "@babel/helper-replace-supers" "^7.16.7"
-    "@babel/helper-split-export-declaration" "^7.16.7"
-
-"@babel/helper-create-regexp-features-plugin@^7.16.7", "@babel/helper-create-regexp-features-plugin@^7.17.0":
-  version "7.17.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.17.0.tgz#1dcc7d40ba0c6b6b25618997c5dbfd310f186fe1"
-  integrity sha512-awO2So99wG6KnlE+TPs6rn83gCz5WlEePJDTnLEqbchMVrBeAujURVphRdigsk094VhvZehFoNOihSlcBjwsXA==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.16.7"
-    regexpu-core "^5.0.1"
-
-"@babel/helper-define-polyfill-provider@^0.3.1":
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.3.1.tgz#52411b445bdb2e676869e5a74960d2d3826d2665"
-  integrity sha512-J9hGMpJQmtWmj46B3kBHmL38UhJGhYX7eqkcq+2gsstyYt341HmPeWspihX43yVRA0mS+8GGk2Gckc7bY/HCmA==
-  dependencies:
-    "@babel/helper-compilation-targets" "^7.13.0"
-    "@babel/helper-module-imports" "^7.12.13"
-    "@babel/helper-plugin-utils" "^7.13.0"
-    "@babel/traverse" "^7.13.0"
-    debug "^4.1.1"
-    lodash.debounce "^4.0.8"
-    resolve "^1.14.2"
-    semver "^6.1.2"
-
-"@babel/helper-environment-visitor@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.16.7.tgz#ff484094a839bde9d89cd63cba017d7aae80ecd7"
-  integrity sha512-SLLb0AAn6PkUeAfKJCCOl9e1R53pQlGAfc4y4XuMRZfqeMYLE0dM1LMhqbGAlGQY0lfw5/ohoYWAe9V1yibRag==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-explode-assignable-expression@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.16.7.tgz#12a6d8522fdd834f194e868af6354e8650242b7a"
-  integrity sha512-KyUenhWMC8VrxzkGP0Jizjo4/Zx+1nNZhgocs+gLzyZyB8SHidhoq9KK/8Ato4anhwsivfkBLftky7gvzbZMtQ==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-function-name@^7.16.7", "@babel/helper-function-name@^7.17.9":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.17.9.tgz#136fcd54bc1da82fcb47565cf16fd8e444b1ff12"
-  integrity sha512-7cRisGlVtiVqZ0MW0/yFB4atgpGLWEHUVYnb448hZK4x+vih0YO5UoS11XIYtZYqHd0dIPMdUSv8q5K4LdMnIg==
-  dependencies:
-    "@babel/template" "^7.16.7"
-    "@babel/types" "^7.17.0"
-
-"@babel/helper-hoist-variables@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.16.7.tgz#86bcb19a77a509c7b77d0e22323ef588fa58c246"
-  integrity sha512-m04d/0Op34H5v7pbZw6pSKP7weA6lsMvfiIAMeIvkY/R4xQtBSMFEigu9QTZ2qB/9l22vsxtM8a+Q8CzD255fg==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-member-expression-to-functions@^7.16.7", "@babel/helper-member-expression-to-functions@^7.17.7":
-  version "7.17.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.17.7.tgz#a34013b57d8542a8c4ff8ba3f747c02452a4d8c4"
-  integrity sha512-thxXgnQ8qQ11W2wVUObIqDL4p148VMxkt5T/qpN5k2fboRyzFGFmKsTGViquyM5QHKUy48OZoca8kw4ajaDPyw==
-  dependencies:
-    "@babel/types" "^7.17.0"
-
-"@babel/helper-module-imports@^7.12.13", "@babel/helper-module-imports@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.16.7.tgz#25612a8091a999704461c8a222d0efec5d091437"
-  integrity sha512-LVtS6TqjJHFc+nYeITRo6VLXve70xmq7wPhWTqDJusJEgGmkAACWwMiTNrvfoQo6hEhFwAIixNkvB0jPXDL8Wg==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-module-transforms@^7.16.7", "@babel/helper-module-transforms@^7.17.7":
-  version "7.17.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.17.7.tgz#3943c7f777139e7954a5355c815263741a9c1cbd"
-  integrity sha512-VmZD99F3gNTYB7fJRDTi+u6l/zxY0BE6OIxPSU7a50s6ZUQkHwSDmV92FfM+oCG0pZRVojGYhkR8I0OGeCVREw==
-  dependencies:
-    "@babel/helper-environment-visitor" "^7.16.7"
-    "@babel/helper-module-imports" "^7.16.7"
-    "@babel/helper-simple-access" "^7.17.7"
-    "@babel/helper-split-export-declaration" "^7.16.7"
-    "@babel/helper-validator-identifier" "^7.16.7"
-    "@babel/template" "^7.16.7"
-    "@babel/traverse" "^7.17.3"
-    "@babel/types" "^7.17.0"
-
-"@babel/helper-optimise-call-expression@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.16.7.tgz#a34e3560605abbd31a18546bd2aad3e6d9a174f2"
-  integrity sha512-EtgBhg7rd/JcnpZFXpBy0ze1YRfdm7BnBX4uKMBd3ixa3RGAE002JZB66FJyNH7g0F38U05pXmA5P8cBh7z+1w==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.10.4", "@babel/helper-plugin-utils@^7.12.13", "@babel/helper-plugin-utils@^7.13.0", "@babel/helper-plugin-utils@^7.14.5", "@babel/helper-plugin-utils@^7.16.7", "@babel/helper-plugin-utils@^7.8.0", "@babel/helper-plugin-utils@^7.8.3":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.16.7.tgz#aa3a8ab4c3cceff8e65eb9e73d87dc4ff320b2f5"
-  integrity sha512-Qg3Nk7ZxpgMrsox6HreY1ZNKdBq7K72tDSliA6dCl5f007jR4ne8iD5UzuNnCJH2xBf2BEEVGr+/OL6Gdp7RxA==
-
-"@babel/helper-remap-async-to-generator@^7.16.8":
-  version "7.16.8"
-  resolved "https://registry.yarnpkg.com/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.16.8.tgz#29ffaade68a367e2ed09c90901986918d25e57e3"
-  integrity sha512-fm0gH7Flb8H51LqJHy3HJ3wnE1+qtYR2A99K06ahwrawLdOFsCEWjZOrYricXJHoPSudNKxrMBUPEIPxiIIvBw==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.16.7"
-    "@babel/helper-wrap-function" "^7.16.8"
-    "@babel/types" "^7.16.8"
-
-"@babel/helper-replace-supers@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.16.7.tgz#e9f5f5f32ac90429c1a4bdec0f231ef0c2838ab1"
-  integrity sha512-y9vsWilTNaVnVh6xiJfABzsNpgDPKev9HnAgz6Gb1p6UUwf9NepdlsV7VXGCftJM+jqD5f7JIEubcpLjZj5dBw==
-  dependencies:
-    "@babel/helper-environment-visitor" "^7.16.7"
-    "@babel/helper-member-expression-to-functions" "^7.16.7"
-    "@babel/helper-optimise-call-expression" "^7.16.7"
-    "@babel/traverse" "^7.16.7"
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-simple-access@^7.17.7":
-  version "7.17.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.17.7.tgz#aaa473de92b7987c6dfa7ce9a7d9674724823367"
-  integrity sha512-txyMCGroZ96i+Pxr3Je3lzEJjqwaRC9buMUgtomcrLe5Nd0+fk1h0LLA+ixUF5OW7AhHuQ7Es1WcQJZmZsz2XA==
-  dependencies:
-    "@babel/types" "^7.17.0"
-
-"@babel/helper-skip-transparent-expression-wrappers@^7.16.0":
-  version "7.16.0"
-  resolved "https://registry.yarnpkg.com/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.16.0.tgz#0ee3388070147c3ae051e487eca3ebb0e2e8bb09"
-  integrity sha512-+il1gTy0oHwUsBQZyJvukbB4vPMdcYBrFHa0Uc4AizLxbq6BOYC51Rv4tWocX9BLBDLZ4kc6qUFpQ6HRgL+3zw==
-  dependencies:
-    "@babel/types" "^7.16.0"
-
-"@babel/helper-split-export-declaration@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.16.7.tgz#0b648c0c42da9d3920d85ad585f2778620b8726b"
-  integrity sha512-xbWoy/PFoxSWazIToT9Sif+jJTlrMcndIsaOKvTA6u7QEo7ilkRZpjew18/W3c7nm8fXdUDXh02VXTbZ0pGDNw==
-  dependencies:
-    "@babel/types" "^7.16.7"
-
-"@babel/helper-validator-identifier@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.16.7.tgz#e8c602438c4a8195751243da9031d1607d247cad"
-  integrity sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw==
-
-"@babel/helper-validator-option@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.16.7.tgz#b203ce62ce5fe153899b617c08957de860de4d23"
-  integrity sha512-TRtenOuRUVo9oIQGPC5G9DgK4743cdxvtOw0weQNpZXaS16SCBi5MNjZF8vba3ETURjZpTbVn7Vvcf2eAwFozQ==
-
-"@babel/helper-wrap-function@^7.16.8":
-  version "7.16.8"
-  resolved "https://registry.yarnpkg.com/@babel/helper-wrap-function/-/helper-wrap-function-7.16.8.tgz#58afda087c4cd235de92f7ceedebca2c41274200"
-  integrity sha512-8RpyRVIAW1RcDDGTA+GpPAwV22wXCfKOoM9bet6TLkGIFTkRQSkH1nMQ5Yet4MpoXe1ZwHPVtNasc2w0uZMqnw==
-  dependencies:
-    "@babel/helper-function-name" "^7.16.7"
-    "@babel/template" "^7.16.7"
-    "@babel/traverse" "^7.16.8"
-    "@babel/types" "^7.16.8"
-
-"@babel/helpers@^7.17.9":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.17.9.tgz#b2af120821bfbe44f9907b1826e168e819375a1a"
-  integrity sha512-cPCt915ShDWUEzEp3+UNRktO2n6v49l5RSnG9M5pS24hA+2FAc5si+Pn1i4VVbQQ+jh+bIZhPFQOJOzbrOYY1Q==
-  dependencies:
-    "@babel/template" "^7.16.7"
-    "@babel/traverse" "^7.17.9"
-    "@babel/types" "^7.17.0"
-
-"@babel/highlight@^7.16.7":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.17.9.tgz#61b2ee7f32ea0454612def4fccdae0de232b73e3"
-  integrity sha512-J9PfEKCbFIv2X5bjTMiZu6Vf341N05QIY+d6FvVKynkG1S7G0j3I0QoRtWIrXhZ+/Nlb5Q0MzqL7TokEJ5BNHg==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.16.7"
-    chalk "^2.0.0"
-    js-tokens "^4.0.0"
-
-"@babel/parser@^7.14.7", "@babel/parser@^7.16.7", "@babel/parser@^7.17.10", "@babel/parser@^7.7.0":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.17.10.tgz#873b16db82a8909e0fbd7f115772f4b739f6ce78"
-  integrity sha512-n2Q6i+fnJqzOaq2VkdXxy2TCPCWQZHiCo0XqmrCvDWcZQKRyZzYi4Z0yxlBuN0w+r2ZHmre+Q087DSrw3pbJDQ==
-
-"@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.16.7.tgz#4eda6d6c2a0aa79c70fa7b6da67763dfe2141050"
-  integrity sha512-anv/DObl7waiGEnC24O9zqL0pSuI9hljihqiDuFHC8d7/bjr/4RLGPWuc8rYOff/QPzbEPSkzG8wGG9aDuhHRg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.16.7.tgz#cc001234dfc139ac45f6bcf801866198c8c72ff9"
-  integrity sha512-di8vUHRdf+4aJ7ltXhaDbPoszdkh59AQtJM5soLsuHpQJdFQZOA4uGj0V2u/CZ8bJ/u8ULDL5yq6FO/bCXnKHw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.16.0"
-    "@babel/plugin-proposal-optional-chaining" "^7.16.7"
-
-"@babel/plugin-proposal-async-generator-functions@^7.16.8":
-  version "7.16.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.16.8.tgz#3bdd1ebbe620804ea9416706cd67d60787504bc8"
-  integrity sha512-71YHIvMuiuqWJQkebWJtdhQTfd4Q4mF76q2IX37uZPkG9+olBxsX+rH1vkhFto4UeJZ9dPY2s+mDvhDm1u2BGQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-remap-async-to-generator" "^7.16.8"
-    "@babel/plugin-syntax-async-generators" "^7.8.4"
-
-"@babel/plugin-proposal-class-properties@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.16.7.tgz#925cad7b3b1a2fcea7e59ecc8eb5954f961f91b0"
-  integrity sha512-IobU0Xme31ewjYOShSIqd/ZGM/r/cuOz2z0MDbNrhF5FW+ZVgi0f2lyeoj9KFPDOAqsYxmLWZte1WOwlvY9aww==
-  dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-proposal-class-static-block@^7.17.6":
-  version "7.17.6"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.17.6.tgz#164e8fd25f0d80fa48c5a4d1438a6629325ad83c"
-  integrity sha512-X/tididvL2zbs7jZCeeRJ8167U/+Ac135AM6jCAx6gYXDUviZV5Ku9UDvWS2NCuWlFjIRXklYhwo6HhAC7ETnA==
-  dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.17.6"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-class-static-block" "^7.14.5"
-
-"@babel/plugin-proposal-dynamic-import@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.16.7.tgz#c19c897eaa46b27634a00fee9fb7d829158704b2"
-  integrity sha512-I8SW9Ho3/8DRSdmDdH3gORdyUuYnk1m4cMxUAdu5oy4n3OfN8flDEH+d60iG7dUfi0KkYwSvoalHzzdRzpWHTg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
-
-"@babel/plugin-proposal-export-namespace-from@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.16.7.tgz#09de09df18445a5786a305681423ae63507a6163"
-  integrity sha512-ZxdtqDXLRGBL64ocZcs7ovt71L3jhC1RGSyR996svrCi3PYqHNkb3SwPJCs8RIzD86s+WPpt2S73+EHCGO+NUA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
-
-"@babel/plugin-proposal-json-strings@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.16.7.tgz#9732cb1d17d9a2626a08c5be25186c195b6fa6e8"
-  integrity sha512-lNZ3EEggsGY78JavgbHsK9u5P3pQaW7k4axlgFLYkMd7UBsiNahCITShLjNQschPyjtO6dADrL24757IdhBrsQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-json-strings" "^7.8.3"
-
-"@babel/plugin-proposal-logical-assignment-operators@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.16.7.tgz#be23c0ba74deec1922e639832904be0bea73cdea"
-  integrity sha512-K3XzyZJGQCr00+EtYtrDjmwX7o7PLK6U9bi1nCwkQioRFVUv6dJoxbQjtWVtP+bCPy82bONBKG8NPyQ4+i6yjg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
-
-"@babel/plugin-proposal-nullish-coalescing-operator@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.16.7.tgz#141fc20b6857e59459d430c850a0011e36561d99"
-  integrity sha512-aUOrYU3EVtjf62jQrCj63pYZ7k6vns2h/DQvHPWGmsJRYzWXZ6/AsfgpiRy6XiuIDADhJzP2Q9MwSMKauBQ+UQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
-
-"@babel/plugin-proposal-numeric-separator@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.16.7.tgz#d6b69f4af63fb38b6ca2558442a7fb191236eba9"
-  integrity sha512-vQgPMknOIgiuVqbokToyXbkY/OmmjAzr/0lhSIbG/KmnzXPGwW/AdhdKpi+O4X/VkWiWjnkKOBiqJrTaC98VKw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
-
-"@babel/plugin-proposal-object-rest-spread@^7.17.3":
-  version "7.17.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.17.3.tgz#d9eb649a54628a51701aef7e0ea3d17e2b9dd390"
-  integrity sha512-yuL5iQA/TbZn+RGAfxQXfi7CNLmKi1f8zInn4IgobuCWcAb7i+zj4TYzQ9l8cEzVyJ89PDGuqxK1xZpUDISesw==
-  dependencies:
-    "@babel/compat-data" "^7.17.0"
-    "@babel/helper-compilation-targets" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-transform-parameters" "^7.16.7"
-
-"@babel/plugin-proposal-optional-catch-binding@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.16.7.tgz#c623a430674ffc4ab732fd0a0ae7722b67cb74cf"
-  integrity sha512-eMOH/L4OvWSZAE1VkHbr1vckLG1WUcHGJSLqqQwl2GaUqG6QjddvrOaTUMNYiv77H5IKPMZ9U9P7EaHwvAShfA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
-
-"@babel/plugin-proposal-optional-chaining@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.16.7.tgz#7cd629564724816c0e8a969535551f943c64c39a"
-  integrity sha512-eC3xy+ZrUcBtP7x+sq62Q/HYd674pPTb/77XZMb5wbDPGWIdUbSr4Agr052+zaUPSb+gGRnjxXfKFvx5iMJ+DA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.16.0"
-    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
-
-"@babel/plugin-proposal-private-methods@^7.16.11":
-  version "7.16.11"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.16.11.tgz#e8df108288555ff259f4527dbe84813aac3a1c50"
-  integrity sha512-F/2uAkPlXDr8+BHpZvo19w3hLFKge+k75XUprE6jaqKxjGkSYcK+4c+bup5PdW/7W/Rpjwql7FTVEDW+fRAQsw==
-  dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.16.10"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-proposal-private-property-in-object@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.16.7.tgz#b0b8cef543c2c3d57e59e2c611994861d46a3fce"
-  integrity sha512-rMQkjcOFbm+ufe3bTZLyOfsOUOxyvLXZJCTARhJr+8UMSoZmqTe1K1BgkFcrW37rAchWg57yI69ORxiWvUINuQ==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.16.7"
-    "@babel/helper-create-class-features-plugin" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
-
-"@babel/plugin-proposal-unicode-property-regex@^7.16.7", "@babel/plugin-proposal-unicode-property-regex@^7.4.4":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.16.7.tgz#635d18eb10c6214210ffc5ff4932552de08188a2"
-  integrity sha512-QRK0YI/40VLhNVGIjRNAAQkEHws0cswSdFFjpFyt943YmJIU1da9uW63Iu6NFV6CxTZW5eTDCrwZUstBWgp/Rg==
-  dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-syntax-async-generators@^7.8.4":
-  version "7.8.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz#a983fb1aeb2ec3f6ed042a210f640e90e786fe0d"
-  integrity sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-class-properties@^7.12.13":
-  version "7.12.13"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz#b5c987274c4a3a82b89714796931a6b53544ae10"
-  integrity sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.12.13"
-
-"@babel/plugin-syntax-class-static-block@^7.14.5":
-  version "7.14.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz#195df89b146b4b78b3bf897fd7a257c84659d406"
-  integrity sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.14.5"
-
-"@babel/plugin-syntax-dynamic-import@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz#62bf98b2da3cd21d626154fc96ee5b3cb68eacb3"
-  integrity sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-export-namespace-from@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz#028964a9ba80dbc094c915c487ad7c4e7a66465a"
-  integrity sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.3"
-
-"@babel/plugin-syntax-json-strings@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz#01ca21b668cd8218c9e640cb6dd88c5412b2c96a"
-  integrity sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-jsx@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.16.7.tgz#50b6571d13f764266a113d77c82b4a6508bbe665"
-  integrity sha512-Esxmk7YjA8QysKeT3VhTXvF6y77f/a91SIs4pWb4H2eWGQkCKFgQaG6hdoEVZtGsrAcb2K5BW66XsOErD4WU3Q==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-syntax-logical-assignment-operators@^7.10.4":
-  version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz#ca91ef46303530448b906652bac2e9fe9941f699"
-  integrity sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.10.4"
-
-"@babel/plugin-syntax-nullish-coalescing-operator@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz#167ed70368886081f74b5c36c65a88c03b66d1a9"
-  integrity sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-numeric-separator@^7.10.4":
-  version "7.10.4"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz#b9b070b3e33570cd9fd07ba7fa91c0dd37b9af97"
-  integrity sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.10.4"
-
-"@babel/plugin-syntax-object-rest-spread@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz#60e225edcbd98a640332a2e72dd3e66f1af55871"
-  integrity sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-optional-catch-binding@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz#6111a265bcfb020eb9efd0fdfd7d26402b9ed6c1"
-  integrity sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-optional-chaining@^7.8.3":
-  version "7.8.3"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz#4f69c2ab95167e0180cd5336613f8c5788f7d48a"
-  integrity sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.8.0"
-
-"@babel/plugin-syntax-private-property-in-object@^7.14.5":
-  version "7.14.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz#0dc6671ec0ea22b6e94a1114f857970cd39de1ad"
-  integrity sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.14.5"
-
-"@babel/plugin-syntax-top-level-await@^7.14.5":
-  version "7.14.5"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz#c1cfdadc35a646240001f06138247b741c34d94c"
-  integrity sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.14.5"
-
-"@babel/plugin-syntax-typescript@^7.16.7":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.17.10.tgz#80031e6042cad6a95ed753f672ebd23c30933195"
-  integrity sha512-xJefea1DWXW09pW4Tm9bjwVlPDyYA2it3fWlmEjpYz6alPvTUjL0EOzNzI/FEOyI3r4/J7uVH5UqKgl1TQ5hqQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-arrow-functions@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.16.7.tgz#44125e653d94b98db76369de9c396dc14bef4154"
-  integrity sha512-9ffkFFMbvzTvv+7dTp/66xvZAWASuPD5Tl9LK3Z9vhOmANo6j94rik+5YMBt4CwHVMWLWpMsriIc2zsa3WW3xQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-async-to-generator@^7.16.8":
-  version "7.16.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.16.8.tgz#b83dff4b970cf41f1b819f8b49cc0cfbaa53a808"
-  integrity sha512-MtmUmTJQHCnyJVrScNzNlofQJ3dLFuobYn3mwOTKHnSCMtbNsqvF71GQmJfFjdrXSsAA7iysFmYWw4bXZ20hOg==
-  dependencies:
-    "@babel/helper-module-imports" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-remap-async-to-generator" "^7.16.8"
-
-"@babel/plugin-transform-block-scoped-functions@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.16.7.tgz#4d0d57d9632ef6062cdf354bb717102ee042a620"
-  integrity sha512-JUuzlzmF40Z9cXyytcbZEZKckgrQzChbQJw/5PuEHYeqzCsvebDx0K0jWnIIVcmmDOAVctCgnYs0pMcrYj2zJg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-block-scoping@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.16.7.tgz#f50664ab99ddeaee5bc681b8f3a6ea9d72ab4f87"
-  integrity sha512-ObZev2nxVAYA4bhyusELdo9hb3H+A56bxH3FZMbEImZFiEDYVHXQSJ1hQKFlDnlt8G9bBrCZ5ZpURZUrV4G5qQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-classes@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-classes/-/plugin-transform-classes-7.16.7.tgz#8f4b9562850cd973de3b498f1218796eb181ce00"
-  integrity sha512-WY7og38SFAGYRe64BrjKf8OrE6ulEHtr5jEYaZMwox9KebgqPi67Zqz8K53EKk1fFEJgm96r32rkKZ3qA2nCWQ==
-  dependencies:
-    "@babel/helper-annotate-as-pure" "^7.16.7"
-    "@babel/helper-environment-visitor" "^7.16.7"
-    "@babel/helper-function-name" "^7.16.7"
-    "@babel/helper-optimise-call-expression" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-replace-supers" "^7.16.7"
-    "@babel/helper-split-export-declaration" "^7.16.7"
-    globals "^11.1.0"
-
-"@babel/plugin-transform-computed-properties@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.16.7.tgz#66dee12e46f61d2aae7a73710f591eb3df616470"
-  integrity sha512-gN72G9bcmenVILj//sv1zLNaPyYcOzUho2lIJBMh/iakJ9ygCo/hEF9cpGb61SCMEDxbbyBoVQxrt+bWKu5KGw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-destructuring@^7.17.7":
-  version "7.17.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.17.7.tgz#49dc2675a7afa9a5e4c6bdee636061136c3408d1"
-  integrity sha512-XVh0r5yq9sLR4vZ6eVZe8FKfIcSgaTBxVBRSYokRj2qksf6QerYnTxz9/GTuKTH/n/HwLP7t6gtlybHetJ/6hQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-dotall-regex@^7.16.7", "@babel/plugin-transform-dotall-regex@^7.4.4":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.16.7.tgz#6b2d67686fab15fb6a7fd4bd895d5982cfc81241"
-  integrity sha512-Lyttaao2SjZF6Pf4vk1dVKv8YypMpomAbygW+mU5cYP3S5cWTfCJjG8xV6CFdzGFlfWK81IjL9viiTvpb6G7gQ==
-  dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-duplicate-keys@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.16.7.tgz#2207e9ca8f82a0d36a5a67b6536e7ef8b08823c9"
-  integrity sha512-03DvpbRfvWIXyK0/6QiR1KMTWeT6OcQ7tbhjrXyFS02kjuX/mu5Bvnh5SDSWHxyawit2g5aWhKwI86EE7GUnTw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-exponentiation-operator@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.16.7.tgz#efa9862ef97e9e9e5f653f6ddc7b665e8536fe9b"
-  integrity sha512-8UYLSlyLgRixQvlYH3J2ekXFHDFLQutdy7FfFAMm3CPZ6q9wHCwnUyiXpQCe3gVVnQlHc5nsuiEVziteRNTXEA==
-  dependencies:
-    "@babel/helper-builder-binary-assignment-operator-visitor" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-for-of@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.16.7.tgz#649d639d4617dff502a9a158c479b3b556728d8c"
-  integrity sha512-/QZm9W92Ptpw7sjI9Nx1mbcsWz33+l8kuMIQnDwgQBG5s3fAfQvkRjQ7NqXhtNcKOnPkdICmUHyCaWW06HCsqg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-function-name@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.16.7.tgz#5ab34375c64d61d083d7d2f05c38d90b97ec65cf"
-  integrity sha512-SU/C68YVwTRxqWj5kgsbKINakGag0KTgq9f2iZEXdStoAbOzLHEBRYzImmA6yFo8YZhJVflvXmIHUO7GWHmxxA==
-  dependencies:
-    "@babel/helper-compilation-targets" "^7.16.7"
-    "@babel/helper-function-name" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-literals@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-literals/-/plugin-transform-literals-7.16.7.tgz#254c9618c5ff749e87cb0c0cef1a0a050c0bdab1"
-  integrity sha512-6tH8RTpTWI0s2sV6uq3e/C9wPo4PTqqZps4uF0kzQ9/xPLFQtipynvmT1g/dOfEJ+0EQsHhkQ/zyRId8J2b8zQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-member-expression-literals@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.16.7.tgz#6e5dcf906ef8a098e630149d14c867dd28f92384"
-  integrity sha512-mBruRMbktKQwbxaJof32LT9KLy2f3gH+27a5XSuXo6h7R3vqltl0PgZ80C8ZMKw98Bf8bqt6BEVi3svOh2PzMw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-modules-amd@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.16.7.tgz#b28d323016a7daaae8609781d1f8c9da42b13186"
-  integrity sha512-KaaEtgBL7FKYwjJ/teH63oAmE3lP34N3kshz8mm4VMAw7U3PxjVwwUmxEFksbgsNUaO3wId9R2AVQYSEGRa2+g==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    babel-plugin-dynamic-import-node "^2.3.3"
-
-"@babel/plugin-transform-modules-commonjs@^7.17.9":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.17.9.tgz#274be1a2087beec0254d4abd4d86e52442e1e5b6"
-  integrity sha512-2TBFd/r2I6VlYn0YRTz2JdazS+FoUuQ2rIFHoAxtyP/0G3D82SBLaRq9rnUkpqlLg03Byfl/+M32mpxjO6KaPw==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.17.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-simple-access" "^7.17.7"
-    babel-plugin-dynamic-import-node "^2.3.3"
-
-"@babel/plugin-transform-modules-systemjs@^7.17.8":
-  version "7.17.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.17.8.tgz#81fd834024fae14ea78fbe34168b042f38703859"
-  integrity sha512-39reIkMTUVagzgA5x88zDYXPCMT6lcaRKs1+S9K6NKBPErbgO/w/kP8GlNQTC87b412ZTlmNgr3k2JrWgHH+Bw==
-  dependencies:
-    "@babel/helper-hoist-variables" "^7.16.7"
-    "@babel/helper-module-transforms" "^7.17.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-validator-identifier" "^7.16.7"
-    babel-plugin-dynamic-import-node "^2.3.3"
-
-"@babel/plugin-transform-modules-umd@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.16.7.tgz#23dad479fa585283dbd22215bff12719171e7618"
-  integrity sha512-EMh7uolsC8O4xhudF2F6wedbSHm1HHZ0C6aJ7K67zcDNidMzVcxWdGr+htW9n21klm+bOn+Rx4CBsAntZd3rEQ==
-  dependencies:
-    "@babel/helper-module-transforms" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-named-capturing-groups-regex@^7.17.10":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.17.10.tgz#715dbcfafdb54ce8bccd3d12e8917296a4ba66a4"
-  integrity sha512-v54O6yLaJySCs6mGzaVOUw9T967GnH38T6CQSAtnzdNPwu84l2qAjssKzo/WSO8Yi7NF+7ekm5cVbF/5qiIgNA==
-  dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.17.0"
-
-"@babel/plugin-transform-new-target@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.16.7.tgz#9967d89a5c243818e0800fdad89db22c5f514244"
-  integrity sha512-xiLDzWNMfKoGOpc6t3U+etCE2yRnn3SM09BXqWPIZOBpL2gvVrBWUKnsJx0K/ADi5F5YC5f8APFfWrz25TdlGg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-object-super@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.16.7.tgz#ac359cf8d32cf4354d27a46867999490b6c32a94"
-  integrity sha512-14J1feiQVWaGvRxj2WjyMuXS2jsBkgB3MdSN5HuC2G5nRspa5RK9COcs82Pwy5BuGcjb+fYaUj94mYcOj7rCvw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-replace-supers" "^7.16.7"
-
-"@babel/plugin-transform-parameters@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.16.7.tgz#a1721f55b99b736511cb7e0152f61f17688f331f"
-  integrity sha512-AT3MufQ7zZEhU2hwOA11axBnExW0Lszu4RL/tAlUJBuNoRak+wehQW8h6KcXOcgjY42fHtDxswuMhMjFEuv/aw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-property-literals@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.16.7.tgz#2dadac85155436f22c696c4827730e0fe1057a55"
-  integrity sha512-z4FGr9NMGdoIl1RqavCqGG+ZuYjfZ/hkCIeuH6Do7tXmSm0ls11nYVSJqFEUOSJbDab5wC6lRE/w6YjVcr6Hqw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-regenerator@^7.17.9":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.17.9.tgz#0a33c3a61cf47f45ed3232903683a0afd2d3460c"
-  integrity sha512-Lc2TfbxR1HOyn/c6b4Y/b6NHoTb67n/IoWLxTu4kC7h4KQnWlhCq2S8Tx0t2SVvv5Uu87Hs+6JEJ5kt2tYGylQ==
-  dependencies:
-    regenerator-transform "^0.15.0"
-
-"@babel/plugin-transform-reserved-words@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.16.7.tgz#1d798e078f7c5958eec952059c460b220a63f586"
-  integrity sha512-KQzzDnZ9hWQBjwi5lpY5v9shmm6IVG0U9pB18zvMu2i4H90xpT4gmqwPYsn8rObiadYe2M0gmgsiOIF5A/2rtg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-shorthand-properties@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.16.7.tgz#e8549ae4afcf8382f711794c0c7b6b934c5fbd2a"
-  integrity sha512-hah2+FEnoRoATdIb05IOXf+4GzXYTq75TVhIn1PewihbpyrNWUt2JbudKQOETWw6QpLe+AIUpJ5MVLYTQbeeUg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-spread@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-spread/-/plugin-transform-spread-7.16.7.tgz#a303e2122f9f12e0105daeedd0f30fb197d8ff44"
-  integrity sha512-+pjJpgAngb53L0iaA5gU/1MLXJIfXcYepLgXB3esVRf4fqmj8f2cxM3/FKaHsZms08hFQJkFccEWuIpm429TXg==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-skip-transparent-expression-wrappers" "^7.16.0"
-
-"@babel/plugin-transform-sticky-regex@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.16.7.tgz#c84741d4f4a38072b9a1e2e3fd56d359552e8660"
-  integrity sha512-NJa0Bd/87QV5NZZzTuZG5BPJjLYadeSZ9fO6oOUoL4iQx+9EEuw/eEM92SrsT19Yc2jgB1u1hsjqDtH02c3Drw==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-template-literals@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.16.7.tgz#f3d1c45d28967c8e80f53666fc9c3e50618217ab"
-  integrity sha512-VwbkDDUeenlIjmfNeDX/V0aWrQH2QiVyJtwymVQSzItFDTpxfyJh3EVaQiS0rIN/CqbLGr0VcGmuwyTdZtdIsA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-typeof-symbol@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.16.7.tgz#9cdbe622582c21368bd482b660ba87d5545d4f7e"
-  integrity sha512-p2rOixCKRJzpg9JB4gjnG4gjWkWa89ZoYUnl9snJ1cWIcTH/hvxZqfO+WjG6T8DRBpctEol5jw1O5rA8gkCokQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-typescript@^7.16.7":
-  version "7.16.8"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.16.8.tgz#591ce9b6b83504903fa9dd3652c357c2ba7a1ee0"
-  integrity sha512-bHdQ9k7YpBDO2d0NVfkj51DpQcvwIzIusJ7mEUaMlbZq3Kt/U47j24inXZHQ5MDiYpCs+oZiwnXyKedE8+q7AQ==
-  dependencies:
-    "@babel/helper-create-class-features-plugin" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/plugin-syntax-typescript" "^7.16.7"
-
-"@babel/plugin-transform-unicode-escapes@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.16.7.tgz#da8717de7b3287a2c6d659750c964f302b31ece3"
-  integrity sha512-TAV5IGahIz3yZ9/Hfv35TV2xEm+kaBDaZQCn2S/hG9/CZ0DktxJv9eKfPc7yYCvOYR4JGx1h8C+jcSOvgaaI/Q==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/plugin-transform-unicode-regex@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.16.7.tgz#0f7aa4a501198976e25e82702574c34cfebe9ef2"
-  integrity sha512-oC5tYYKw56HO75KZVLQ+R/Nl3Hro9kf8iG0hXoaHP7tjAyCpvqBiSNe6vGrZni1Z6MggmUOC6A7VP7AVmw225Q==
-  dependencies:
-    "@babel/helper-create-regexp-features-plugin" "^7.16.7"
-    "@babel/helper-plugin-utils" "^7.16.7"
-
-"@babel/preset-env@^7.11.0", "@babel/preset-env@^7.17.10":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/preset-env/-/preset-env-7.17.10.tgz#a81b093669e3eb6541bb81a23173c5963c5de69c"
-  integrity sha512-YNgyBHZQpeoBSRBg0xixsZzfT58Ze1iZrajvv0lJc70qDDGuGfonEnMGfWeSY0mQ3JTuCWFbMkzFRVafOyJx4g==
-  dependencies:
-    "@babel/compat-data" "^7.17.10"
-    "@babel/helper-compilation-targets" "^7.17.10"
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-validator-option" "^7.16.7"
-    "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression" "^7.16.7"
-    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining" "^7.16.7"
-    "@babel/plugin-proposal-async-generator-functions" "^7.16.8"
-    "@babel/plugin-proposal-class-properties" "^7.16.7"
-    "@babel/plugin-proposal-class-static-block" "^7.17.6"
-    "@babel/plugin-proposal-dynamic-import" "^7.16.7"
-    "@babel/plugin-proposal-export-namespace-from" "^7.16.7"
-    "@babel/plugin-proposal-json-strings" "^7.16.7"
-    "@babel/plugin-proposal-logical-assignment-operators" "^7.16.7"
-    "@babel/plugin-proposal-nullish-coalescing-operator" "^7.16.7"
-    "@babel/plugin-proposal-numeric-separator" "^7.16.7"
-    "@babel/plugin-proposal-object-rest-spread" "^7.17.3"
-    "@babel/plugin-proposal-optional-catch-binding" "^7.16.7"
-    "@babel/plugin-proposal-optional-chaining" "^7.16.7"
-    "@babel/plugin-proposal-private-methods" "^7.16.11"
-    "@babel/plugin-proposal-private-property-in-object" "^7.16.7"
-    "@babel/plugin-proposal-unicode-property-regex" "^7.16.7"
-    "@babel/plugin-syntax-async-generators" "^7.8.4"
-    "@babel/plugin-syntax-class-properties" "^7.12.13"
-    "@babel/plugin-syntax-class-static-block" "^7.14.5"
-    "@babel/plugin-syntax-dynamic-import" "^7.8.3"
-    "@babel/plugin-syntax-export-namespace-from" "^7.8.3"
-    "@babel/plugin-syntax-json-strings" "^7.8.3"
-    "@babel/plugin-syntax-logical-assignment-operators" "^7.10.4"
-    "@babel/plugin-syntax-nullish-coalescing-operator" "^7.8.3"
-    "@babel/plugin-syntax-numeric-separator" "^7.10.4"
-    "@babel/plugin-syntax-object-rest-spread" "^7.8.3"
-    "@babel/plugin-syntax-optional-catch-binding" "^7.8.3"
-    "@babel/plugin-syntax-optional-chaining" "^7.8.3"
-    "@babel/plugin-syntax-private-property-in-object" "^7.14.5"
-    "@babel/plugin-syntax-top-level-await" "^7.14.5"
-    "@babel/plugin-transform-arrow-functions" "^7.16.7"
-    "@babel/plugin-transform-async-to-generator" "^7.16.8"
-    "@babel/plugin-transform-block-scoped-functions" "^7.16.7"
-    "@babel/plugin-transform-block-scoping" "^7.16.7"
-    "@babel/plugin-transform-classes" "^7.16.7"
-    "@babel/plugin-transform-computed-properties" "^7.16.7"
-    "@babel/plugin-transform-destructuring" "^7.17.7"
-    "@babel/plugin-transform-dotall-regex" "^7.16.7"
-    "@babel/plugin-transform-duplicate-keys" "^7.16.7"
-    "@babel/plugin-transform-exponentiation-operator" "^7.16.7"
-    "@babel/plugin-transform-for-of" "^7.16.7"
-    "@babel/plugin-transform-function-name" "^7.16.7"
-    "@babel/plugin-transform-literals" "^7.16.7"
-    "@babel/plugin-transform-member-expression-literals" "^7.16.7"
-    "@babel/plugin-transform-modules-amd" "^7.16.7"
-    "@babel/plugin-transform-modules-commonjs" "^7.17.9"
-    "@babel/plugin-transform-modules-systemjs" "^7.17.8"
-    "@babel/plugin-transform-modules-umd" "^7.16.7"
-    "@babel/plugin-transform-named-capturing-groups-regex" "^7.17.10"
-    "@babel/plugin-transform-new-target" "^7.16.7"
-    "@babel/plugin-transform-object-super" "^7.16.7"
-    "@babel/plugin-transform-parameters" "^7.16.7"
-    "@babel/plugin-transform-property-literals" "^7.16.7"
-    "@babel/plugin-transform-regenerator" "^7.17.9"
-    "@babel/plugin-transform-reserved-words" "^7.16.7"
-    "@babel/plugin-transform-shorthand-properties" "^7.16.7"
-    "@babel/plugin-transform-spread" "^7.16.7"
-    "@babel/plugin-transform-sticky-regex" "^7.16.7"
-    "@babel/plugin-transform-template-literals" "^7.16.7"
-    "@babel/plugin-transform-typeof-symbol" "^7.16.7"
-    "@babel/plugin-transform-unicode-escapes" "^7.16.7"
-    "@babel/plugin-transform-unicode-regex" "^7.16.7"
-    "@babel/preset-modules" "^0.1.5"
-    "@babel/types" "^7.17.10"
-    babel-plugin-polyfill-corejs2 "^0.3.0"
-    babel-plugin-polyfill-corejs3 "^0.5.0"
-    babel-plugin-polyfill-regenerator "^0.3.0"
-    core-js-compat "^3.22.1"
-    semver "^6.3.0"
-
-"@babel/preset-modules@^0.1.5":
-  version "0.1.5"
-  resolved "https://registry.yarnpkg.com/@babel/preset-modules/-/preset-modules-0.1.5.tgz#ef939d6e7f268827e1841638dc6ff95515e115d9"
-  integrity sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@babel/plugin-proposal-unicode-property-regex" "^7.4.4"
-    "@babel/plugin-transform-dotall-regex" "^7.4.4"
-    "@babel/types" "^7.4.4"
-    esutils "^2.0.2"
-
-"@babel/preset-typescript@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/preset-typescript/-/preset-typescript-7.16.7.tgz#ab114d68bb2020afc069cd51b37ff98a046a70b9"
-  integrity sha512-WbVEmgXdIyvzB77AQjGBEyYPZx+8tTsO50XtfozQrkW8QB2rLJpH2lgx0TRw5EJrBxOZQ+wCcyPVQvS8tjEHpQ==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.16.7"
-    "@babel/helper-validator-option" "^7.16.7"
-    "@babel/plugin-transform-typescript" "^7.16.7"
-
-"@babel/register@^7.17.7":
-  version "7.17.7"
-  resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.17.7.tgz#5eef3e0f4afc07e25e847720e7b987ae33f08d0b"
-  integrity sha512-fg56SwvXRifootQEDQAu1mKdjh5uthPzdO0N6t358FktfL4XjAVXuH58ULoiW8mesxiOgNIrxiImqEwv0+hRRA==
-  dependencies:
-    clone-deep "^4.0.1"
-    find-cache-dir "^2.0.0"
-    make-dir "^2.1.0"
-    pirates "^4.0.5"
-    source-map-support "^0.5.16"
-
-"@babel/runtime@^7.8.4":
-  version "7.17.9"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.17.9.tgz#d19fbf802d01a8cb6cf053a64e472d42c434ba72"
-  integrity sha512-lSiBBvodq29uShpWGNbgFdKYNiFDo5/HIYsaCEY9ff4sb10x9jizo2+pRrSyF4jKZCXqgzuqBOQKbUm90gQwJg==
-  dependencies:
-    regenerator-runtime "^0.13.4"
-
-"@babel/template@7", "@babel/template@^7.16.7":
-  version "7.16.7"
-  resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.16.7.tgz#8d126c8701fde4d66b264b3eba3d96f07666d155"
-  integrity sha512-I8j/x8kHUrbYRTUxXrrMbfCa7jxkE7tZre39x3kjr9hvI82cK1FfqLygotcWN5kdPGWcLdWMHpSBavse5tWw3w==
-  dependencies:
-    "@babel/code-frame" "^7.16.7"
-    "@babel/parser" "^7.16.7"
-    "@babel/types" "^7.16.7"
-
-"@babel/traverse@^7.13.0", "@babel/traverse@^7.16.7", "@babel/traverse@^7.16.8", "@babel/traverse@^7.17.10", "@babel/traverse@^7.17.3", "@babel/traverse@^7.17.9", "@babel/traverse@^7.7.0":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.17.10.tgz#1ee1a5ac39f4eac844e6cf855b35520e5eb6f8b5"
-  integrity sha512-VmbrTHQteIdUUQNTb+zE12SHS/xQVIShmBPhlNP12hD5poF2pbITW1Z4172d03HegaQWhLffdkRJYtAzp0AGcw==
-  dependencies:
-    "@babel/code-frame" "^7.16.7"
-    "@babel/generator" "^7.17.10"
-    "@babel/helper-environment-visitor" "^7.16.7"
-    "@babel/helper-function-name" "^7.17.9"
-    "@babel/helper-hoist-variables" "^7.16.7"
-    "@babel/helper-split-export-declaration" "^7.16.7"
-    "@babel/parser" "^7.17.10"
-    "@babel/types" "^7.17.10"
-    debug "^4.1.0"
-    globals "^11.1.0"
-
-"@babel/types@^7.16.0", "@babel/types@^7.16.7", "@babel/types@^7.16.8", "@babel/types@^7.17.0", "@babel/types@^7.17.10", "@babel/types@^7.4.4", "@babel/types@^7.7.0":
-  version "7.17.10"
-  resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.17.10.tgz#d35d7b4467e439fcf06d195f8100e0fea7fc82c4"
-  integrity sha512-9O26jG0mBYfGkUYCYZRnBwbVLd1UZOICEr2Em6InB6jVfsAv1GKgwXHmrSg+WFWDmeKTA6vyTZiN8tCSM5Oo3A==
-  dependencies:
-    "@babel/helper-validator-identifier" "^7.16.7"
-    to-fast-properties "^2.0.0"
-
-"@colors/colors@1.5.0":
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/@colors/colors/-/colors-1.5.0.tgz#bb504579c1cae923e6576a4f5da43d25f97bdbd9"
-  integrity sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==
-
-"@commitlint/config-validator@^16.2.1":
-  version "16.2.1"
-  resolved "https://registry.yarnpkg.com/@commitlint/config-validator/-/config-validator-16.2.1.tgz#794e769afd4756e4cf1bfd823b6612932e39c56d"
-  integrity sha512-hogSe0WGg7CKmp4IfNbdNES3Rq3UEI4XRPB8JL4EPgo/ORq5nrGTVzxJh78omibNuB8Ho4501Czb1Er1MoDWpw==
-  dependencies:
-    "@commitlint/types" "^16.2.1"
-    ajv "^6.12.6"
-
-"@commitlint/execute-rule@^16.2.1":
-  version "16.2.1"
-  resolved "https://registry.yarnpkg.com/@commitlint/execute-rule/-/execute-rule-16.2.1.tgz#60be73be4b9af97a41546e7ce59fdd33787c65f8"
-  integrity sha512-oSls82fmUTLM6cl5V3epdVo4gHhbmBFvCvQGHBRdQ50H/690Uq1Dyd7hXMuKITCIdcnr9umyDkr8r5C6HZDF3g==
-
-"@commitlint/load@>6.1.1":
-  version "16.2.4"
-  resolved "https://registry.yarnpkg.com/@commitlint/load/-/load-16.2.4.tgz#32c9f4c6538b21cf48cf40266312bb1adb65f435"
-  integrity sha512-HjANm3/29ROV+zt4yfaY/K6gpr9Dbzgtlp0kSwZGW0poDXlD/yqVYgPQ6JolJzZii5FUz5R4yVLC15hVL/w60w==
-  dependencies:
-    "@commitlint/config-validator" "^16.2.1"
-    "@commitlint/execute-rule" "^16.2.1"
-    "@commitlint/resolve-extends" "^16.2.1"
-    "@commitlint/types" "^16.2.1"
-    "@types/node" ">=12"
-    chalk "^4.0.0"
-    cosmiconfig "^7.0.0"
-    cosmiconfig-typescript-loader "^1.0.0"
-    lodash "^4.17.19"
-    resolve-from "^5.0.0"
-    typescript "^4.4.3"
-
-"@commitlint/resolve-extends@^16.2.1":
-  version "16.2.1"
-  resolved "https://registry.yarnpkg.com/@commitlint/resolve-extends/-/resolve-extends-16.2.1.tgz#2f7833a5a3a7aa79f508e59fcb0f1d33c45ed360"
-  integrity sha512-NbbCMPKTFf2J805kwfP9EO+vV+XvnaHRcBy6ud5dF35dxMsvdJqke54W3XazXF1ZAxC4a3LBy4i/GNVBAthsEg==
-  dependencies:
-    "@commitlint/config-validator" "^16.2.1"
-    "@commitlint/types" "^16.2.1"
-    import-fresh "^3.0.0"
-    lodash "^4.17.19"
-    resolve-from "^5.0.0"
-    resolve-global "^1.0.0"
-
-"@commitlint/types@^16.2.1":
-  version "16.2.1"
-  resolved "https://registry.yarnpkg.com/@commitlint/types/-/types-16.2.1.tgz#f25d373b88b01e51fc3fa44488101361945a61bd"
-  integrity sha512-7/z7pA7BM0i8XvMSBynO7xsB3mVQPUZbVn6zMIlp/a091XJ3qAXRXc+HwLYhiIdzzS5fuxxNIHZMGHVD4HJxdA==
-  dependencies:
-    chalk "^4.0.0"
-
-"@cspotcode/source-map-consumer@0.8.0":
-  version "0.8.0"
-  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz#33bf4b7b39c178821606f669bbc447a6a629786b"
-  integrity sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg==
-
-"@cspotcode/source-map-support@0.7.0":
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.7.0.tgz#4789840aa859e46d2f3173727ab707c66bf344f5"
-  integrity sha512-X4xqRHqN8ACt2aHVe51OxeA2HjbcL4MqFqXkrmQszJ1NOUuUu5u6Vqx/0lZSVNku7velL5FC/s5uEAj1lsBMhA==
-  dependencies:
-    "@cspotcode/source-map-consumer" "0.8.0"
-
-"@eslint/eslintrc@^1.2.2":
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-1.2.2.tgz#4989b9e8c0216747ee7cca314ae73791bb281aae"
-  integrity sha512-lTVWHs7O2hjBFZunXTZYnYqtB9GakA1lnxIf+gKq2nY5gxkkNi/lQvveW6t8gFdOHTg6nG50Xs95PrLqVpcaLg==
-  dependencies:
-    ajv "^6.12.4"
-    debug "^4.3.2"
-    espree "^9.3.1"
-    globals "^13.9.0"
-    ignore "^5.2.0"
-    import-fresh "^3.2.1"
-    js-yaml "^4.1.0"
-    minimatch "^3.0.4"
-    strip-json-comments "^3.1.1"
-
-"@humanwhocodes/config-array@^0.9.2":
-  version "0.9.5"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.9.5.tgz#2cbaf9a89460da24b5ca6531b8bbfc23e1df50c7"
-  integrity sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==
-  dependencies:
-    "@humanwhocodes/object-schema" "^1.2.1"
-    debug "^4.1.1"
-    minimatch "^3.0.4"
-
-"@humanwhocodes/object-schema@^1.2.1":
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45"
-  integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==
-
-"@hutson/parse-repository-url@^3.0.0":
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/@hutson/parse-repository-url/-/parse-repository-url-3.0.2.tgz#98c23c950a3d9b6c8f0daed06da6c3af06981340"
-  integrity sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==
-
-"@istanbuljs/load-nyc-config@^1.0.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz#fd3db1d59ecf7cf121e80650bb86712f9b55eced"
-  integrity sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==
-  dependencies:
-    camelcase "^5.3.1"
-    find-up "^4.1.0"
-    get-package-type "^0.1.0"
-    js-yaml "^3.13.1"
-    resolve-from "^5.0.0"
-
-"@istanbuljs/schema@^0.1.2":
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/@istanbuljs/schema/-/schema-0.1.3.tgz#e45e384e4b8ec16bce2fd903af78450f6bf7ec98"
-  integrity sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==
-
-"@jridgewell/gen-mapping@^0.1.0":
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz#e5d2e450306a9491e3bd77e323e38d7aff315996"
-  integrity sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w==
-  dependencies:
-    "@jridgewell/set-array" "^1.0.0"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
-
-"@jridgewell/resolve-uri@^3.0.3":
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.0.6.tgz#4ac237f4dabc8dd93330386907b97591801f7352"
-  integrity sha512-R7xHtBSNm+9SyvpJkdQl+qrM3Hm2fea3Ef197M3mUug+v+yR+Rhfbs7PBtcBUVnIWJ4JcAdjvij+c8hXS9p5aw==
-
-"@jridgewell/set-array@^1.0.0":
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.0.tgz#1179863356ac8fbea64a5a4bcde93a4871012c01"
-  integrity sha512-SfJxIxNVYLTsKwzB3MoOQ1yxf4w/E6MdkvTgrgAt1bfxjSrLUoHMKrDOykwN14q65waezZIdqDneUIPh4/sKxg==
-
-"@jridgewell/sourcemap-codec@^1.4.10":
-  version "1.4.11"
-  resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.11.tgz#771a1d8d744eeb71b6adb35808e1a6c7b9b8c8ec"
-  integrity sha512-Fg32GrJo61m+VqYSdRSjRXMjQ06j8YIYfcTqndLYVAaHmroZHLJZCydsWBOTDqXS2v+mjxohBWEMfg97GXmYQg==
-
-"@jridgewell/trace-mapping@^0.3.9":
-  version "0.3.9"
-  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
-  integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
-  dependencies:
-    "@jridgewell/resolve-uri" "^3.0.3"
-    "@jridgewell/sourcemap-codec" "^1.4.10"
-
-"@nightwatch/chai@5.0.2":
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/@nightwatch/chai/-/chai-5.0.2.tgz#86b20908fc090dffd5c9567c0392bc6a494cc2e6"
-  integrity sha512-yzILJFCcE75OPoRfBlJ80Y3Ky06ljsdrK4Ld92yhmM477vxO2GEguwnd+ldl7pdSYTcg1gSJ1bPPQrA+/Hrn+A==
-  dependencies:
-    assertion-error "1.1.0"
-    check-error "1.0.2"
-    deep-eql "4.0.1"
-    loupe "2.3.4"
-    pathval "1.1.1"
-    type-detect "4.0.8"
-
-"@nightwatch/ejs@3.2.0":
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/@nightwatch/ejs/-/ejs-3.2.0.tgz#cc9a069d7f7fe35d94b21c346b031af10bff4570"
-  integrity sha512-NbJzBXGjh7gzG9nCYtbpdHrqQ3CnMt1FUBj8PomVyc1q5+qBFS8z3aLvBGWPt1leHmRK6d4TZn/jsS0XKmVGQQ==
-
-"@nodelib/fs.scandir@2.1.5":
-  version "2.1.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
-  integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==
-  dependencies:
-    "@nodelib/fs.stat" "2.0.5"
-    run-parallel "^1.1.9"
-
-"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2":
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b"
-  integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==
-
-"@nodelib/fs.walk@^1.2.3":
-  version "1.2.8"
-  resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a"
-  integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==
-  dependencies:
-    "@nodelib/fs.scandir" "2.1.5"
-    fastq "^1.6.0"
-
-"@rollup/plugin-alias@^3.1.9":
-  version "3.1.9"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-alias/-/plugin-alias-3.1.9.tgz#a5d267548fe48441f34be8323fb64d1d4a1b3fdf"
-  integrity sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==
-  dependencies:
-    slash "^3.0.0"
-
-"@rollup/plugin-commonjs@^22.0.0":
-  version "22.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-commonjs/-/plugin-commonjs-22.0.0.tgz#f4d87016e2fbf187a593ab9f46626fe05b59e8bd"
-  integrity sha512-Ktvf2j+bAO+30awhbYoCaXpBcyPmJbaEUYClQns/+6SNCYFURbvBiNbWgHITEsIgDDWCDUclWRKEuf8cwZCFoQ==
-  dependencies:
-    "@rollup/pluginutils" "^3.1.0"
-    commondir "^1.0.1"
-    estree-walker "^2.0.1"
-    glob "^7.1.6"
-    is-reference "^1.2.1"
-    magic-string "^0.25.7"
-    resolve "^1.17.0"
-
-"@rollup/plugin-node-resolve@^13.2.1":
-  version "13.3.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-node-resolve/-/plugin-node-resolve-13.3.0.tgz#da1c5c5ce8316cef96a2f823d111c1e4e498801c"
-  integrity sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==
-  dependencies:
-    "@rollup/pluginutils" "^3.1.0"
-    "@types/resolve" "1.17.1"
-    deepmerge "^4.2.2"
-    is-builtin-module "^3.1.0"
-    is-module "^1.0.0"
-    resolve "^1.19.0"
-
-"@rollup/plugin-replace@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/@rollup/plugin-replace/-/plugin-replace-4.0.0.tgz#e34c457d6a285f0213359740b43f39d969b38a67"
-  integrity sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==
-  dependencies:
-    "@rollup/pluginutils" "^3.1.0"
-    magic-string "^0.25.7"
-
-"@rollup/pluginutils@^3.1.0":
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-3.1.0.tgz#706b4524ee6dc8b103b3c995533e5ad680c02b9b"
-  integrity sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==
-  dependencies:
-    "@types/estree" "0.0.39"
-    estree-walker "^1.0.1"
-    picomatch "^2.2.2"
-
-"@rollup/pluginutils@^4.1.2":
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/@rollup/pluginutils/-/pluginutils-4.2.1.tgz#e6c6c3aba0744edce3fb2074922d3776c0af2a6d"
-  integrity sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==
-  dependencies:
-    estree-walker "^2.0.1"
-    picomatch "^2.2.2"
-
-"@sindresorhus/is@^0.7.0":
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.7.0.tgz#9a06f4f137ee84d7df0460c1fdb1135ffa6c50fd"
-  integrity sha512-ONhaKPIufzzrlNbqtWFFd+jlnemX6lJAgq9ZeiZtS7I1PIf/la7CW4m83rTXRnVnsMbW2k56pGYu7AUFJD9Pow==
-
-"@sindresorhus/is@^4.0.0":
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-4.6.0.tgz#3c7c9c46e678feefe7a2e5bb609d3dbd665ffb3f"
-  integrity sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==
-
-"@szmarczak/http-timer@^4.0.5":
-  version "4.0.6"
-  resolved "https://registry.yarnpkg.com/@szmarczak/http-timer/-/http-timer-4.0.6.tgz#b4a914bb62e7c272d4e5989fe4440f812ab1d807"
-  integrity sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==
-  dependencies:
-    defer-to-connect "^2.0.0"
-
-"@testim/chrome-version@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@testim/chrome-version/-/chrome-version-1.1.2.tgz#092005c5b77bd3bb6576a4677110a11485e11864"
-  integrity sha512-1c4ZOETSRpI0iBfIFUqU4KqwBAB2lHUAlBjZz/YqOHqwM9dTTzjV6Km0ZkiEiSCx/tLr1BtESIKyWWMww+RUqw==
-
-"@tootallnate/once@1":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-1.1.2.tgz#ccb91445360179a04e7fe6aff78c00ffc1eeaf82"
-  integrity sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==
-
-"@tsconfig/node10@^1.0.7":
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.8.tgz#c1e4e80d6f964fbecb3359c43bd48b40f7cadad9"
-  integrity sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg==
-
-"@tsconfig/node12@^1.0.7":
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.9.tgz#62c1f6dee2ebd9aead80dc3afa56810e58e1a04c"
-  integrity sha512-/yBMcem+fbvhSREH+s14YJi18sp7J9jpuhYByADT2rypfajMZZN4WQ6zBGgBKp53NKmqI36wFYDb3yaMPurITw==
-
-"@tsconfig/node14@^1.0.0":
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.1.tgz#95f2d167ffb9b8d2068b0b235302fafd4df711f2"
-  integrity sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg==
-
-"@tsconfig/node16@^1.0.2":
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.2.tgz#423c77877d0569db20e1fc80885ac4118314010e"
-  integrity sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==
-
-"@types/cacheable-request@^6.0.1":
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/@types/cacheable-request/-/cacheable-request-6.0.2.tgz#c324da0197de0a98a2312156536ae262429ff6b9"
-  integrity sha512-B3xVo+dlKM6nnKTcmm5ZtY/OL8bOAOd2Olee9M1zft65ox50OzjEHW91sDiU9j6cvW8Ejg1/Qkf4xd2kugApUA==
-  dependencies:
-    "@types/http-cache-semantics" "*"
-    "@types/keyv" "*"
-    "@types/node" "*"
-    "@types/responselike" "*"
-
-"@types/component-emitter@^1.2.10":
-  version "1.2.11"
-  resolved "https://registry.yarnpkg.com/@types/component-emitter/-/component-emitter-1.2.11.tgz#50d47d42b347253817a39709fef03ce66a108506"
-  integrity sha512-SRXjM+tfsSlA9VuG8hGO2nft2p8zjXCK1VcC6N4NXbBbYbSia9kzCChYQajIjzIqOOOuh5Ock6MmV2oux4jDZQ==
-
-"@types/cookie@^0.4.1":
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/@types/cookie/-/cookie-0.4.1.tgz#bfd02c1f2224567676c1545199f87c3a861d878d"
-  integrity sha512-XW/Aa8APYr6jSVVA1y/DEIZX0/GMKLEVekNG727R8cs56ahETkRAy/3DR7+fJyh7oUgGwNQaRfXCun0+KbWY7Q==
-
-"@types/cors@^2.8.12":
-  version "2.8.12"
-  resolved "https://registry.yarnpkg.com/@types/cors/-/cors-2.8.12.tgz#6b2c510a7ad7039e98e7b8d3d6598f4359e5c080"
-  integrity sha512-vt+kDhq/M2ayberEtJcIN/hxXy1Pk+59g2FV/ZQceeaTyCtCucjL2Q7FXlFjtWn4n15KCr1NE2lNNFhp0lEThw==
-
-"@types/eslint-scope@^3.7.3":
-  version "3.7.3"
-  resolved "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.3.tgz#125b88504b61e3c8bc6f870882003253005c3224"
-  integrity sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==
-  dependencies:
-    "@types/eslint" "*"
-    "@types/estree" "*"
-
-"@types/eslint@*":
-  version "8.4.1"
-  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.4.1.tgz#c48251553e8759db9e656de3efc846954ac32304"
-  integrity sha512-GE44+DNEyxxh2Kc6ro/VkIj+9ma0pO0bwv9+uHSyBrikYOHr8zYcdPvnBOp1aw8s+CjRvuSx7CyWqRrNFQ59mA==
-  dependencies:
-    "@types/estree" "*"
-    "@types/json-schema" "*"
-
-"@types/estree@*", "@types/estree@^0.0.51":
-  version "0.0.51"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.51.tgz#cfd70924a25a3fd32b218e5e420e6897e1ac4f40"
-  integrity sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==
-
-"@types/estree@0.0.39":
-  version "0.0.39"
-  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-0.0.39.tgz#e177e699ee1b8c22d23174caaa7422644389509f"
-  integrity sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==
-
-"@types/he@^1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@types/he/-/he-1.1.2.tgz#0c8b275f36d2b8b651104638e4d45693349c3953"
-  integrity sha512-kSJPcLO1x+oolc0R89pUl2kozldQ/fVQ1C1p5mp8fPoLdF/ZcBvckaTC2M8xXh3GYendXvCpy5m/a2eSbfgNgw==
-
-"@types/http-cache-semantics@*":
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/@types/http-cache-semantics/-/http-cache-semantics-4.0.1.tgz#0ea7b61496902b95890dc4c3a116b60cb8dae812"
-  integrity sha512-SZs7ekbP8CN0txVG2xVRH6EgKmEm31BOxA07vkFaETzZz1xh+cbt8BcI0slpymvwhx5dlFnQG2rTlPVQn+iRPQ==
-
-"@types/jasmine@^4.0.3":
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/@types/jasmine/-/jasmine-4.0.3.tgz#097ce710d70eb7f3662e96c1f75824dd22c27d5c"
-  integrity sha512-Opp1LvvEuZdk8fSSvchK2mZwhVrsNT0JgJE9Di6MjnaIpmEXM8TLCPPrVtNTYh8+5MPdY8j9bAHMu2SSfwpZJg==
-
-"@types/json-buffer@~3.0.0":
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/@types/json-buffer/-/json-buffer-3.0.0.tgz#85c1ff0f0948fc159810d4b5be35bf8c20875f64"
-  integrity sha512-3YP80IxxFJB4b5tYC2SUPwkg0XQLiu0nWvhRgEatgjf+29IcWO9X1k8xRv5DGssJ/lCrjYTjQPcobJr2yWIVuQ==
-
-"@types/json-schema@*", "@types/json-schema@^7.0.5", "@types/json-schema@^7.0.8", "@types/json-schema@^7.0.9":
-  version "7.0.11"
-  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3"
-  integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==
-
-"@types/keyv@*":
-  version "3.1.4"
-  resolved "https://registry.yarnpkg.com/@types/keyv/-/keyv-3.1.4.tgz#3ccdb1c6751b0c7e52300bcdacd5bcbf8faa75b6"
-  integrity sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==
-  dependencies:
-    "@types/node" "*"
-
-"@types/minimist@^1.2.0":
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c"
-  integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==
-
-"@types/node@*", "@types/node@>=10.0.0", "@types/node@>=12", "@types/node@^17.0.30":
-  version "17.0.31"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-17.0.31.tgz#a5bb84ecfa27eec5e1c802c6bbf8139bdb163a5d"
-  integrity sha512-AR0x5HbXGqkEx9CadRH3EBYx/VkiUgZIhP4wvPn/+5KIsgpNoyFaRlVe0Zlx9gRtg8fA06a9tskE2MSN7TcG4Q==
-
-"@types/normalize-package-data@^2.4.0":
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301"
-  integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==
-
-"@types/parse-json@^4.0.0":
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/@types/parse-json/-/parse-json-4.0.0.tgz#2f8bb441434d163b35fb8ffdccd7138927ffb8c0"
-  integrity sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==
-
-"@types/puppeteer-core@^5.4.0":
-  version "5.4.0"
-  resolved "https://registry.yarnpkg.com/@types/puppeteer-core/-/puppeteer-core-5.4.0.tgz#880a7917b4ede95cbfe2d5e81a558cfcb072c0fb"
-  integrity sha512-yqRPuv4EFcSkTyin6Yy17pN6Qz2vwVwTCJIDYMXbE3j8vTPhv0nCQlZOl5xfi0WHUkqvQsjAR8hAfjeMCoetwg==
-  dependencies:
-    "@types/puppeteer" "*"
-
-"@types/puppeteer@*":
-  version "5.4.6"
-  resolved "https://registry.yarnpkg.com/@types/puppeteer/-/puppeteer-5.4.6.tgz#afc438e41dcbc27ca1ba0235ea464a372db2b21c"
-  integrity sha512-98Kghehs7+/GD9b56qryhqdqVCXUTbetTv3PlvDnmFRTHQH0j9DIp1f7rkAW3BAj4U3yoeSEQnKgdW8bDq0Y0Q==
-  dependencies:
-    "@types/node" "*"
-
-"@types/resolve@1.17.1":
-  version "1.17.1"
-  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.17.1.tgz#3afd6ad8967c77e4376c598a82ddd58f46ec45d6"
-  integrity sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==
-  dependencies:
-    "@types/node" "*"
-
-"@types/responselike@*", "@types/responselike@^1.0.0":
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/@types/responselike/-/responselike-1.0.0.tgz#251f4fe7d154d2bad125abe1b429b23afd262e29"
-  integrity sha512-85Y2BjiufFzaMIlvJDvTTB8Fxl2xfLo4HgmHzVBz08w4wDePCTjYw66PdrolO0kzli3yam/YCgRufyo1DdQVTA==
-  dependencies:
-    "@types/node" "*"
-
-"@types/webpack-env@^1.16.4":
-  version "1.16.4"
-  resolved "https://registry.yarnpkg.com/@types/webpack-env/-/webpack-env-1.16.4.tgz#1f4969042bf76d7ef7b5914f59b3b60073f4e1f4"
-  integrity sha512-llS8qveOUX3wxHnSykP5hlYFFuMfJ9p5JvIyCiBgp7WTfl6K5ZcyHj8r8JsN/J6QODkAsRRCLIcTuOCu8etkUw==
-
-"@types/webpack@^5.28.0":
-  version "5.28.0"
-  resolved "https://registry.yarnpkg.com/@types/webpack/-/webpack-5.28.0.tgz#78dde06212f038d77e54116cfe69e88ae9ed2c03"
-  integrity sha512-8cP0CzcxUiFuA9xGJkfeVpqmWTk9nx6CWwamRGCj95ph1SmlRRk9KlCZ6avhCbZd4L68LvYT6l1kpdEnQXrF8w==
-  dependencies:
-    "@types/node" "*"
-    tapable "^2.2.0"
-    webpack "^5"
-
-"@types/which@^1.3.2":
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/@types/which/-/which-1.3.2.tgz#9c246fc0c93ded311c8512df2891fb41f6227fdf"
-  integrity sha512-8oDqyLC7eD4HM307boe2QWKyuzdzWBj56xI/imSl2cpL+U3tCMaTAkMJ4ee5JBZ/FsOJlvRGeIShiZDAl1qERA==
-
-"@types/yauzl@^2.9.1":
-  version "2.10.0"
-  resolved "https://registry.yarnpkg.com/@types/yauzl/-/yauzl-2.10.0.tgz#b3248295276cf8c6f153ebe6a9aba0c988cb2599"
-  integrity sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==
-  dependencies:
-    "@types/node" "*"
-
-"@typescript-eslint/eslint-plugin@^5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.21.0.tgz#bfc22e0191e6404ab1192973b3b4ea0461c1e878"
-  integrity sha512-fTU85q8v5ZLpoZEyn/u1S2qrFOhi33Edo2CZ0+q1gDaWWm0JuPh3bgOyU8lM0edIEYgKLDkPFiZX2MOupgjlyg==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.21.0"
-    "@typescript-eslint/type-utils" "5.21.0"
-    "@typescript-eslint/utils" "5.21.0"
-    debug "^4.3.2"
-    functional-red-black-tree "^1.0.1"
-    ignore "^5.1.8"
-    regexpp "^3.2.0"
-    semver "^7.3.5"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/parser@^5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-5.21.0.tgz#6cb72673dbf3e1905b9c432175a3c86cdaf2071f"
-  integrity sha512-8RUwTO77hstXUr3pZoWZbRQUxXcSXafZ8/5gpnQCfXvgmP9gpNlRGlWzvfbEQ14TLjmtU8eGnONkff8U2ui2Eg==
-  dependencies:
-    "@typescript-eslint/scope-manager" "5.21.0"
-    "@typescript-eslint/types" "5.21.0"
-    "@typescript-eslint/typescript-estree" "5.21.0"
-    debug "^4.3.2"
-
-"@typescript-eslint/scope-manager@5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-5.21.0.tgz#a4b7ed1618f09f95e3d17d1c0ff7a341dac7862e"
-  integrity sha512-XTX0g0IhvzcH/e3393SvjRCfYQxgxtYzL3UREteUneo72EFlt7UNoiYnikUtmGVobTbhUDByhJ4xRBNe+34kOQ==
-  dependencies:
-    "@typescript-eslint/types" "5.21.0"
-    "@typescript-eslint/visitor-keys" "5.21.0"
-
-"@typescript-eslint/type-utils@5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-5.21.0.tgz#ff89668786ad596d904c21b215e5285da1b6262e"
-  integrity sha512-MxmLZj0tkGlkcZCSE17ORaHl8Th3JQwBzyXL/uvC6sNmu128LsgjTX0NIzy+wdH2J7Pd02GN8FaoudJntFvSOw==
-  dependencies:
-    "@typescript-eslint/utils" "5.21.0"
-    debug "^4.3.2"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/types@5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-5.21.0.tgz#8cdb9253c0dfce3f2ab655b9d36c03f72e684017"
-  integrity sha512-XnOOo5Wc2cBlq8Lh5WNvAgHzpjnEzxn4CJBwGkcau7b/tZ556qrWXQz4DJyChYg8JZAD06kczrdgFPpEQZfDsA==
-
-"@typescript-eslint/typescript-estree@5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-5.21.0.tgz#9f0c233e28be2540eaed3df050f0d54fb5aa52de"
-  integrity sha512-Y8Y2T2FNvm08qlcoSMoNchh9y2Uj3QmjtwNMdRQkcFG7Muz//wfJBGBxh8R7HAGQFpgYpdHqUpEoPQk+q9Kjfg==
-  dependencies:
-    "@typescript-eslint/types" "5.21.0"
-    "@typescript-eslint/visitor-keys" "5.21.0"
-    debug "^4.3.2"
-    globby "^11.0.4"
-    is-glob "^4.0.3"
-    semver "^7.3.5"
-    tsutils "^3.21.0"
-
-"@typescript-eslint/utils@5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-5.21.0.tgz#51d7886a6f0575e23706e5548c7e87bce42d7c18"
-  integrity sha512-q/emogbND9wry7zxy7VYri+7ydawo2HDZhRZ5k6yggIvXa7PvBbAAZ4PFH/oZLem72ezC4Pr63rJvDK/sTlL8Q==
-  dependencies:
-    "@types/json-schema" "^7.0.9"
-    "@typescript-eslint/scope-manager" "5.21.0"
-    "@typescript-eslint/types" "5.21.0"
-    "@typescript-eslint/typescript-estree" "5.21.0"
-    eslint-scope "^5.1.1"
-    eslint-utils "^3.0.0"
-
-"@typescript-eslint/visitor-keys@5.21.0":
-  version "5.21.0"
-  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-5.21.0.tgz#453fb3662409abaf2f8b1f65d515699c888dd8ae"
-  integrity sha512-SX8jNN+iHqAF0riZQMkm7e8+POXa/fXw5cxL+gjpyP+FI+JVNhii53EmQgDAfDcBpFekYSlO0fGytMQwRiMQCA==
-  dependencies:
-    "@typescript-eslint/types" "5.21.0"
-    eslint-visitor-keys "^3.0.0"
-
-"@ungap/promise-all-settled@1.1.2":
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz#aa58042711d6e3275dd37dc597e5d31e8c290a44"
-  integrity sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q==
-
-"@wdio/config@6.12.1":
-  version "6.12.1"
-  resolved "https://registry.yarnpkg.com/@wdio/config/-/config-6.12.1.tgz#86d987b505d8ca85ec11471830d2ba296dab3bcf"
-  integrity sha512-V5hTIW5FNlZ1W33smHF4Rd5BKjGW2KeYhyXDQfXHjqLCeRiirZ9fABCo9plaVQDnwWSUMWYaAaIAifV82/oJCQ==
-  dependencies:
-    "@wdio/logger" "6.10.10"
-    deepmerge "^4.0.0"
-    glob "^7.1.2"
-
-"@wdio/logger@6.10.10":
-  version "6.10.10"
-  resolved "https://registry.yarnpkg.com/@wdio/logger/-/logger-6.10.10.tgz#1e07cf32a69606ddb94fa9fd4b0171cb839a5980"
-  integrity sha512-2nh0hJz9HeZE0VIEMI+oPgjr/Q37ohrR9iqsl7f7GW5ik+PnKYCT9Eab5mR1GNMG60askwbskgGC1S9ygtvrSw==
-  dependencies:
-    chalk "^4.0.0"
-    loglevel "^1.6.0"
-    loglevel-plugin-prefix "^0.8.4"
-    strip-ansi "^6.0.0"
-
-"@wdio/protocols@6.12.0":
-  version "6.12.0"
-  resolved "https://registry.yarnpkg.com/@wdio/protocols/-/protocols-6.12.0.tgz#e40850be62c42c82dd2c486655d6419cd9ec1e3e"
-  integrity sha512-UhTBZxClCsM3VjaiDp4DoSCnsa7D1QNmI2kqEBfIpyNkT3GcZhJb7L+nL0fTkzCwi7+/uLastb3/aOwH99gt0A==
-
-"@wdio/repl@6.11.0":
-  version "6.11.0"
-  resolved "https://registry.yarnpkg.com/@wdio/repl/-/repl-6.11.0.tgz#5b1eab574b6b89f7f7c383e7295c06af23c3818e"
-  integrity sha512-FxrFKiTkFyELNGGVEH1uijyvNY7lUpmff6x+FGskFGZB4uSRs0rxkOMaEjxnxw7QP1zgQKr2xC7GyO03gIGRGg==
-  dependencies:
-    "@wdio/utils" "6.11.0"
-
-"@wdio/utils@6.11.0":
-  version "6.11.0"
-  resolved "https://registry.yarnpkg.com/@wdio/utils/-/utils-6.11.0.tgz#878c2500efb1a325bf5a66d2ff3d08162f976e8c"
-  integrity sha512-vf0sOQzd28WbI26d6/ORrQ4XKWTzSlWLm9W/K/eJO0NASKPEzR+E+Q2kaa+MJ4FKXUpjbt+Lxfo+C26TzBk7tg==
-  dependencies:
-    "@wdio/logger" "6.10.10"
-
-"@webassemblyjs/ast@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.1.tgz#2bfd767eae1a6996f432ff7e8d7fc75679c0b6a7"
-  integrity sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==
-  dependencies:
-    "@webassemblyjs/helper-numbers" "1.11.1"
-    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
-
-"@webassemblyjs/floating-point-hex-parser@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.1.tgz#f6c61a705f0fd7a6aecaa4e8198f23d9dc179e4f"
-  integrity sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==
-
-"@webassemblyjs/helper-api-error@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.1.tgz#1a63192d8788e5c012800ba6a7a46c705288fd16"
-  integrity sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==
-
-"@webassemblyjs/helper-buffer@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.1.tgz#832a900eb444884cde9a7cad467f81500f5e5ab5"
-  integrity sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==
-
-"@webassemblyjs/helper-numbers@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.1.tgz#64d81da219fbbba1e3bd1bfc74f6e8c4e10a62ae"
-  integrity sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==
-  dependencies:
-    "@webassemblyjs/floating-point-hex-parser" "1.11.1"
-    "@webassemblyjs/helper-api-error" "1.11.1"
-    "@xtuc/long" "4.2.2"
-
-"@webassemblyjs/helper-wasm-bytecode@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.1.tgz#f328241e41e7b199d0b20c18e88429c4433295e1"
-  integrity sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==
-
-"@webassemblyjs/helper-wasm-section@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.1.tgz#21ee065a7b635f319e738f0dd73bfbda281c097a"
-  integrity sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==
-  dependencies:
-    "@webassemblyjs/ast" "1.11.1"
-    "@webassemblyjs/helper-buffer" "1.11.1"
-    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
-    "@webassemblyjs/wasm-gen" "1.11.1"
-
-"@webassemblyjs/ieee754@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.1.tgz#963929e9bbd05709e7e12243a099180812992614"
-  integrity sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==
-  dependencies:
-    "@xtuc/ieee754" "^1.2.0"
-
-"@webassemblyjs/leb128@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.1.tgz#ce814b45574e93d76bae1fb2644ab9cdd9527aa5"
-  integrity sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==
-  dependencies:
-    "@xtuc/long" "4.2.2"
-
-"@webassemblyjs/utf8@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.1.tgz#d1f8b764369e7c6e6bae350e854dec9a59f0a3ff"
-  integrity sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==
-
-"@webassemblyjs/wasm-edit@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.1.tgz#ad206ebf4bf95a058ce9880a8c092c5dec8193d6"
-  integrity sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==
-  dependencies:
-    "@webassemblyjs/ast" "1.11.1"
-    "@webassemblyjs/helper-buffer" "1.11.1"
-    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
-    "@webassemblyjs/helper-wasm-section" "1.11.1"
-    "@webassemblyjs/wasm-gen" "1.11.1"
-    "@webassemblyjs/wasm-opt" "1.11.1"
-    "@webassemblyjs/wasm-parser" "1.11.1"
-    "@webassemblyjs/wast-printer" "1.11.1"
-
-"@webassemblyjs/wasm-gen@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.1.tgz#86c5ea304849759b7d88c47a32f4f039ae3c8f76"
-  integrity sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==
-  dependencies:
-    "@webassemblyjs/ast" "1.11.1"
-    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
-    "@webassemblyjs/ieee754" "1.11.1"
-    "@webassemblyjs/leb128" "1.11.1"
-    "@webassemblyjs/utf8" "1.11.1"
-
-"@webassemblyjs/wasm-opt@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.1.tgz#657b4c2202f4cf3b345f8a4c6461c8c2418985f2"
-  integrity sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==
-  dependencies:
-    "@webassemblyjs/ast" "1.11.1"
-    "@webassemblyjs/helper-buffer" "1.11.1"
-    "@webassemblyjs/wasm-gen" "1.11.1"
-    "@webassemblyjs/wasm-parser" "1.11.1"
-
-"@webassemblyjs/wasm-parser@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.1.tgz#86ca734534f417e9bd3c67c7a1c75d8be41fb199"
-  integrity sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==
-  dependencies:
-    "@webassemblyjs/ast" "1.11.1"
-    "@webassemblyjs/helper-api-error" "1.11.1"
-    "@webassemblyjs/helper-wasm-bytecode" "1.11.1"
-    "@webassemblyjs/ieee754" "1.11.1"
-    "@webassemblyjs/leb128" "1.11.1"
-    "@webassemblyjs/utf8" "1.11.1"
-
-"@webassemblyjs/wast-printer@1.11.1":
-  version "1.11.1"
-  resolved "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.1.tgz#d0c73beda8eec5426f10ae8ef55cee5e7084c2f0"
-  integrity sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==
-  dependencies:
-    "@webassemblyjs/ast" "1.11.1"
-    "@xtuc/long" "4.2.2"
-
-"@xtuc/ieee754@^1.2.0":
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
-  integrity sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==
-
-"@xtuc/long@4.2.2":
-  version "4.2.2"
-  resolved "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d"
-  integrity sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==
-
-"@yarn-tool/resolve-package@^1.0.40":
-  version "1.0.46"
-  resolved "https://registry.yarnpkg.com/@yarn-tool/resolve-package/-/resolve-package-1.0.46.tgz#db7354380e5ca7682294af59e5ab0f7fce640ac1"
-  integrity sha512-RJcBGTVywUqYGRtGkPSgJC/ozf0wK/xjUy66tXkbpL35U0o1oef4S0v23euxA/CiukqBWr2fRGtGY6FidESdTg==
-  dependencies:
-    pkg-dir "< 6 >= 5"
-    tslib "^2.3.1"
-    upath2 "^3.1.12"
-
-JSONStream@^1.0.4:
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
-  integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==
-  dependencies:
-    jsonparse "^1.2.0"
-    through ">=2.2.7 <3"
-
-accepts@~1.3.4:
-  version "1.3.8"
-  resolved "https://registry.yarnpkg.com/accepts/-/accepts-1.3.8.tgz#0bf0be125b67014adcb0b0921e62db7bffe16b2e"
-  integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==
-  dependencies:
-    mime-types "~2.1.34"
-    negotiator "0.6.3"
-
-acorn-import-assertions@^1.7.6:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.8.0.tgz#ba2b5939ce62c238db6d93d81c9b111b29b855e9"
-  integrity sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==
-
-acorn-jsx@^5.3.1:
-  version "5.3.2"
-  resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
-  integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
-
-acorn-walk@^8.0.2, acorn-walk@^8.1.1, acorn-walk@^8.2.0:
-  version "8.2.0"
-  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
-  integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
-
-acorn@^8.1.0, acorn@^8.4.1, acorn@^8.5.0, acorn@^8.7.0, acorn@^8.7.1:
-  version "8.7.1"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.7.1.tgz#0197122c843d1bf6d0a5e83220a788f278f63c30"
-  integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==
-
-add-stream@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/add-stream/-/add-stream-1.0.0.tgz#6a7990437ca736d5e1288db92bd3266d5f5cb2aa"
-  integrity sha1-anmQQ3ynNtXhKI25K9MmbV9csqo=
-
-agent-base@5:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-5.1.1.tgz#e8fb3f242959db44d63be665db7a8e739537a32c"
-  integrity sha512-TMeqbNl2fMW0nMjTEPOwe3J/PRFP4vqeoNuQMG0HlMrtm5QxKqdvAkZ1pRBQ/ulIyDD5Yq0nJ7YbdD8ey0TO3g==
-
-agent-base@6:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-6.0.2.tgz#49fff58577cfee3f37176feab4c22e00f86d7f77"
-  integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==
-  dependencies:
-    debug "4"
-
-aggregate-error@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/aggregate-error/-/aggregate-error-3.1.0.tgz#92670ff50f5359bdb7a3e0d40d0ec30c5737687a"
-  integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==
-  dependencies:
-    clean-stack "^2.0.0"
-    indent-string "^4.0.0"
-
-ajv-keywords@^3.5.2:
-  version "3.5.2"
-  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d"
-  integrity sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==
-
-ajv@^6.10.0, ajv@^6.12.3, ajv@^6.12.4, ajv@^6.12.5, ajv@^6.12.6:
-  version "6.12.6"
-  resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
-  integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==
-  dependencies:
-    fast-deep-equal "^3.1.1"
-    fast-json-stable-stringify "^2.0.0"
-    json-schema-traverse "^0.4.1"
-    uri-js "^4.2.2"
-
-ansi-align@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59"
-  integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==
-  dependencies:
-    string-width "^4.1.0"
-
-ansi-colors@4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348"
-  integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==
-
-ansi-escapes@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
-  integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
-
-ansi-escapes@^4.3.0:
-  version "4.3.2"
-  resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
-  integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
-  dependencies:
-    type-fest "^0.21.3"
-
-ansi-regex@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.1.tgz#123d6479e92ad45ad897d4054e3c7ca7db4944e1"
-  integrity sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==
-
-ansi-regex@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.1.tgz#164daac87ab2d6f6db3a29875e2d1766582dabed"
-  integrity sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==
-
-ansi-regex@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
-  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
-
-ansi-regex@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
-  integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
-
-ansi-styles@^3.2.1:
-  version "3.2.1"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
-  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
-  dependencies:
-    color-convert "^1.9.0"
-
-ansi-styles@^4.0.0, ansi-styles@^4.1.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
-  integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
-  dependencies:
-    color-convert "^2.0.1"
-
-ansi-styles@^6.0.0:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-6.1.0.tgz#87313c102b8118abd57371afab34618bf7350ed3"
-  integrity sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ==
-
-anymatch@~3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.2.tgz#c0557c096af32f106198f4f4e2a383537e378716"
-  integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==
-  dependencies:
-    normalize-path "^3.0.0"
-    picomatch "^2.0.4"
-
-arch@^2.1.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/arch/-/arch-2.2.0.tgz#1bc47818f305764f23ab3306b0bfc086c5a29d11"
-  integrity sha512-Of/R0wqp83cgHozfIYLbBMnej79U/SVGOOyuB3VVFv1NRM/PSFMK12x9KVtiYzJqmnU5WR2qp0Z5rHb7sWGnFQ==
-
-archive-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/archive-type/-/archive-type-4.0.0.tgz#f92e72233056dfc6969472749c267bdb046b1d70"
-  integrity sha1-+S5yIzBW38aWlHJ0nCZ72wRrHXA=
-  dependencies:
-    file-type "^4.2.0"
-
-archiver-utils@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/archiver-utils/-/archiver-utils-2.1.0.tgz#e8a460e94b693c3e3da182a098ca6285ba9249e2"
-  integrity sha512-bEL/yUb/fNNiNTuUz979Z0Yg5L+LzLxGJz8x79lYmR54fmTIb6ob/hNQgkQnIUDWIFjZVQwl9Xs356I6BAMHfw==
-  dependencies:
-    glob "^7.1.4"
-    graceful-fs "^4.2.0"
-    lazystream "^1.0.0"
-    lodash.defaults "^4.2.0"
-    lodash.difference "^4.5.0"
-    lodash.flatten "^4.4.0"
-    lodash.isplainobject "^4.0.6"
-    lodash.union "^4.6.0"
-    normalize-path "^3.0.0"
-    readable-stream "^2.0.0"
-
-archiver@^5.0.0:
-  version "5.3.1"
-  resolved "https://registry.yarnpkg.com/archiver/-/archiver-5.3.1.tgz#21e92811d6f09ecfce649fbefefe8c79e57cbbb6"
-  integrity sha512-8KyabkmbYrH+9ibcTScQ1xCJC/CGcugdVIwB+53f5sZziXgwUh3iXlAlANMxcZyDEfTHMe6+Z5FofV8nopXP7w==
-  dependencies:
-    archiver-utils "^2.1.0"
-    async "^3.2.3"
-    buffer-crc32 "^0.2.1"
-    readable-stream "^3.6.0"
-    readdir-glob "^1.0.0"
-    tar-stream "^2.2.0"
-    zip-stream "^4.1.0"
-
-arg@^4.1.0:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
-  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
-
-argparse@^1.0.7:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.10.tgz#bcd6791ea5ae09725e17e5ad988134cd40b3d911"
-  integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==
-  dependencies:
-    sprintf-js "~1.0.2"
-
-argparse@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/argparse/-/argparse-2.0.1.tgz#246f50f3ca78a3240f6c997e8a9bd1eac49e4b38"
-  integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==
-
-argv@0.0.2:
-  version "0.0.2"
-  resolved "https://registry.yarnpkg.com/argv/-/argv-0.0.2.tgz#ecbd16f8949b157183711b1bda334f37840185ab"
-  integrity sha1-7L0W+JSbFXGDcRsb2jNPN4QBhas=
-
-array-ify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
-  integrity sha1-nlKHYrSpBmrRY6aWKjZEGOlibs4=
-
-array-union@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/array-union/-/array-union-2.1.0.tgz#b798420adbeb1de828d84acd8a2e23d3efe85e8d"
-  integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==
-
-arrify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
-  integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=
-
-asn1.js@^5.2.0:
-  version "5.4.1"
-  resolved "https://registry.yarnpkg.com/asn1.js/-/asn1.js-5.4.1.tgz#11a980b84ebb91781ce35b0fdc2ee294e3783f07"
-  integrity sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==
-  dependencies:
-    bn.js "^4.0.0"
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-    safer-buffer "^2.1.0"
-
-asn1@~0.2.3:
-  version "0.2.6"
-  resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.6.tgz#0d3a7bb6e64e02a90c0303b31f292868ea09a08d"
-  integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==
-  dependencies:
-    safer-buffer "~2.1.0"
-
-assert-plus@1.0.0, assert-plus@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525"
-  integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=
-
-assert@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/assert/-/assert-2.0.0.tgz#95fc1c616d48713510680f2eaf2d10dd22e02d32"
-  integrity sha512-se5Cd+js9dXJnu6Ag2JFc00t+HmHOen+8Q+L7O9zI0PqQXr20uk2J0XQqMxZEeo5U50o8Nvmmx7dZrl+Ufr35A==
-  dependencies:
-    es6-object-assign "^1.1.0"
-    is-nan "^1.2.1"
-    object-is "^1.0.1"
-    util "^0.12.0"
-
-assertion-error@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.1.0.tgz#e60b6b0e8f301bd97e5375215bda406c85118c0b"
-  integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==
-
-astral-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31"
-  integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==
-
-async@^2.6.2:
-  version "2.6.4"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.4.tgz#706b7ff6084664cd7eae713f6f965433b5504221"
-  integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==
-  dependencies:
-    lodash "^4.17.14"
-
-async@^3.0.1, async@^3.2.3:
-  version "3.2.3"
-  resolved "https://registry.yarnpkg.com/async/-/async-3.2.3.tgz#ac53dafd3f4720ee9e8a160628f18ea91df196c9"
-  integrity sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g==
-
-asynckit@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
-  integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
-
-at-least-node@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/at-least-node/-/at-least-node-1.0.0.tgz#602cd4b46e844ad4effc92a8011a3c46e0238dc2"
-  integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==
-
-atob@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/atob/-/atob-2.1.2.tgz#6d9517eb9e030d2436666651e86bd9f6f13533c9"
-  integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==
-
-available-typed-arrays@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz#92f95616501069d07d10edb2fc37d3e1c65123b7"
-  integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==
-
-aws-sign2@~0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8"
-  integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=
-
-aws4@^1.8.0:
-  version "1.11.0"
-  resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59"
-  integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
-
-axios@^0.24.0:
-  version "0.24.0"
-  resolved "https://registry.yarnpkg.com/axios/-/axios-0.24.0.tgz#804e6fa1e4b9c5288501dd9dff56a7a0940d20d6"
-  integrity sha512-Q6cWsys88HoPgAaFAVUb0WpPk0O8iTeisR9IMqy9G8AbO4NlpVknrnQS03zzF9PGAWgO3cgletO3VjV/P7VztA==
-  dependencies:
-    follow-redirects "^1.14.4"
-
-babel-eslint@^10.1.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/babel-eslint/-/babel-eslint-10.1.0.tgz#6968e568a910b78fb3779cdd8b6ac2f479943232"
-  integrity sha512-ifWaTHQ0ce+448CYop8AdrQiBsGrnC+bMgfyKFdi6EsPLTAWG+QfyDeM6OH+FmWnKvEq5NnBMLvlBUPKQZoDSg==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    "@babel/parser" "^7.7.0"
-    "@babel/traverse" "^7.7.0"
-    "@babel/types" "^7.7.0"
-    eslint-visitor-keys "^1.0.0"
-    resolve "^1.12.0"
-
-babel-helper-vue-jsx-merge-props@^2.0.3:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/babel-helper-vue-jsx-merge-props/-/babel-helper-vue-jsx-merge-props-2.0.3.tgz#22aebd3b33902328e513293a8e4992b384f9f1b6"
-  integrity sha512-gsLiKK7Qrb7zYJNgiXKpXblxbV5ffSwR0f5whkPAaBAR4fhi6bwRZxX9wBlIc5M/v8CCkXUbXZL4N/nSE97cqg==
-
-babel-loader@^8.2.5:
-  version "8.2.5"
-  resolved "https://registry.yarnpkg.com/babel-loader/-/babel-loader-8.2.5.tgz#d45f585e654d5a5d90f5350a779d7647c5ed512e"
-  integrity sha512-OSiFfH89LrEMiWd4pLNqGz4CwJDtbs2ZVc+iGu2HrkRfPxId9F2anQj38IxWpmRfsUY0aBZYi1EFcd3mhtRMLQ==
-  dependencies:
-    find-cache-dir "^3.3.1"
-    loader-utils "^2.0.0"
-    make-dir "^3.1.0"
-    schema-utils "^2.6.5"
-
-babel-plugin-dynamic-import-node@^2.3.3:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz#84fda19c976ec5c6defef57f9427b3def66e17a3"
-  integrity sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==
-  dependencies:
-    object.assign "^4.1.0"
-
-babel-plugin-istanbul@^6.1.1:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz#fa88ec59232fd9b4e36dbbc540a8ec9a9b47da73"
-  integrity sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==
-  dependencies:
-    "@babel/helper-plugin-utils" "^7.0.0"
-    "@istanbuljs/load-nyc-config" "^1.0.0"
-    "@istanbuljs/schema" "^0.1.2"
-    istanbul-lib-instrument "^5.0.4"
-    test-exclude "^6.0.0"
-
-babel-plugin-polyfill-corejs2@^0.3.0:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.3.1.tgz#440f1b70ccfaabc6b676d196239b138f8a2cfba5"
-  integrity sha512-v7/T6EQcNfVLfcN2X8Lulb7DjprieyLWJK/zOWH5DUYcAgex9sP3h25Q+DLsX9TloXe3y1O8l2q2Jv9q8UVB9w==
-  dependencies:
-    "@babel/compat-data" "^7.13.11"
-    "@babel/helper-define-polyfill-provider" "^0.3.1"
-    semver "^6.1.1"
-
-babel-plugin-polyfill-corejs3@^0.5.0:
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.5.2.tgz#aabe4b2fa04a6e038b688c5e55d44e78cd3a5f72"
-  integrity sha512-G3uJih0XWiID451fpeFaYGVuxHEjzKTHtc9uGFEjR6hHrvNzeS/PX+LLLcetJcytsB5m4j+K3o/EpXJNb/5IEQ==
-  dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.3.1"
-    core-js-compat "^3.21.0"
-
-babel-plugin-polyfill-regenerator@^0.3.0:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.3.1.tgz#2c0678ea47c75c8cc2fbb1852278d8fb68233990"
-  integrity sha512-Y2B06tvgHYt1x0yz17jGkGeeMr5FeKUu+ASJ+N6nB5lQ8Dapfg42i0OVrf8PNGJ3zKL4A23snMi1IRwrqqND7A==
-  dependencies:
-    "@babel/helper-define-polyfill-provider" "^0.3.1"
-
-babel-plugin-transform-require-context@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-require-context/-/babel-plugin-transform-require-context-0.1.1.tgz#319b545ca83080b5062776b46cc9b8b346fea9a6"
-  integrity sha512-4ceqYOtzgmq4/QsB8dP7pUrUOCjY/jrRYdt7YkIOWHxtGDQbcf6YZDyLCiPQf6KsEIcIbSQiTRXOsbLiuJfgNQ==
-  dependencies:
-    "@babel/template" "7"
-
-babel-plugin-transform-vue-jsx@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/babel-plugin-transform-vue-jsx/-/babel-plugin-transform-vue-jsx-4.0.1.tgz#2c8bddce87a6ef09eaa59869ff1bfbeeafc5f88d"
-  integrity sha512-wbOz7ITB5cloLSjKUU1hWn8zhR+Dwah/RZiTiJY/CQliCwhowmzu6m7NEF+y5EJX/blDzGjRtZvC10Vdb3Q7vw==
-  dependencies:
-    esutils "^2.0.2"
-
-balanced-match@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee"
-  integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==
-
-base64-js@^1.3.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
-  integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
-
-base64id@2.0.0, base64id@~2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/base64id/-/base64id-2.0.0.tgz#2770ac6bc47d312af97a8bf9a634342e0cd25cb6"
-  integrity sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==
-
-basic-auth@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/basic-auth/-/basic-auth-2.0.1.tgz#b998279bf47ce38344b4f3cf916d4679bbf51e3a"
-  integrity sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==
-  dependencies:
-    safe-buffer "5.1.2"
-
-bcrypt-pbkdf@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e"
-  integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=
-  dependencies:
-    tweetnacl "^0.14.3"
-
-big.js@^5.2.2:
-  version "5.2.2"
-  resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
-  integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
-
-bin-check@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/bin-check/-/bin-check-4.1.0.tgz#fc495970bdc88bb1d5a35fc17e65c4a149fc4a49"
-  integrity sha512-b6weQyEUKsDGFlACWSIOfveEnImkJyK/FGW6FAG42loyoquvjdtOIqO6yBFzHyqyVVhNgNkQxxx09SFLK28YnA==
-  dependencies:
-    execa "^0.7.0"
-    executable "^4.1.0"
-
-bin-version-check@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/bin-version-check/-/bin-version-check-4.0.0.tgz#7d819c62496991f80d893e6e02a3032361608f71"
-  integrity sha512-sR631OrhC+1f8Cvs8WyVWOA33Y8tgwjETNPyyD/myRBXLkfS/vl74FmH/lFcRl9KY3zwGh7jFhvyk9vV3/3ilQ==
-  dependencies:
-    bin-version "^3.0.0"
-    semver "^5.6.0"
-    semver-truncate "^1.1.2"
-
-bin-version@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/bin-version/-/bin-version-3.1.0.tgz#5b09eb280752b1bd28f0c9db3f96f2f43b6c0839"
-  integrity sha512-Mkfm4iE1VFt4xd4vH+gx+0/71esbfus2LsnCGe8Pi4mndSPyT+NGES/Eg99jx8/lUGWfu3z2yuB/bt5UB+iVbQ==
-  dependencies:
-    execa "^1.0.0"
-    find-versions "^3.0.0"
-
-bin-wrapper@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/bin-wrapper/-/bin-wrapper-4.1.0.tgz#99348f2cf85031e3ef7efce7e5300aeaae960605"
-  integrity sha512-hfRmo7hWIXPkbpi0ZltboCMVrU+0ClXR/JgbCKKjlDjQf6igXa7OwdqNcFWQZPZTgiY7ZpzE3+LjjkLiTN2T7Q==
-  dependencies:
-    bin-check "^4.1.0"
-    bin-version-check "^4.0.0"
-    download "^7.1.0"
-    import-lazy "^3.1.0"
-    os-filter-obj "^2.0.0"
-    pify "^4.0.1"
-
-binary-extensions@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.2.0.tgz#75f502eeaf9ffde42fc98829645be4ea76bd9e2d"
-  integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==
-
-bl@^1.0.0:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-1.2.3.tgz#1e8dd80142eac80d7158c9dccc047fb620e035e7"
-  integrity sha512-pvcNpa0UU69UT341rO6AYy4FVAIkUHuZXRIWbq+zHnsVcRzDDjIAhGuuYoi0d//cwIwtt4pkpKycWEfjdV+vww==
-  dependencies:
-    readable-stream "^2.3.5"
-    safe-buffer "^5.1.1"
-
-bl@^4.0.3, bl@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
-  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
-  dependencies:
-    buffer "^5.5.0"
-    inherits "^2.0.4"
-    readable-stream "^3.4.0"
-
-bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.11.9:
-  version "4.12.0"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
-  integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
-
-bn.js@^5.0.0, bn.js@^5.1.1:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.0.tgz#358860674396c6997771a9d051fcc1b57d4ae002"
-  integrity sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==
-
-body-parser@^1.19.0:
-  version "1.20.0"
-  resolved "https://registry.yarnpkg.com/body-parser/-/body-parser-1.20.0.tgz#3de69bd89011c11573d7bfee6a64f11b6bd27cc5"
-  integrity sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg==
-  dependencies:
-    bytes "3.1.2"
-    content-type "~1.0.4"
-    debug "2.6.9"
-    depd "2.0.0"
-    destroy "1.2.0"
-    http-errors "2.0.0"
-    iconv-lite "0.4.24"
-    on-finished "2.4.1"
-    qs "6.10.3"
-    raw-body "2.5.1"
-    type-is "~1.6.18"
-    unpipe "1.0.0"
-
-boolean@^3.0.1:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/boolean/-/boolean-3.2.0.tgz#9e5294af4e98314494cbb17979fa54ca159f116b"
-  integrity sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==
-
-boxen@5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/boxen/-/boxen-5.1.2.tgz#788cb686fc83c1f486dfa8a40c68fc2b831d2b50"
-  integrity sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==
-  dependencies:
-    ansi-align "^3.0.0"
-    camelcase "^6.2.0"
-    chalk "^4.1.0"
-    cli-boxes "^2.2.1"
-    string-width "^4.2.2"
-    type-fest "^0.20.2"
-    widest-line "^3.1.0"
-    wrap-ansi "^7.0.0"
-
-brace-expansion@^1.1.7:
-  version "1.1.11"
-  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
-  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
-  dependencies:
-    balanced-match "^1.0.0"
-    concat-map "0.0.1"
-
-braces@^3.0.2, braces@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
-  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
-  dependencies:
-    fill-range "^7.0.1"
-
-brorand@^1.0.1, brorand@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
-  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
-
-browser-resolve@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/browser-resolve/-/browser-resolve-2.0.0.tgz#99b7304cb392f8d73dba741bb2d7da28c6d7842b"
-  integrity sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==
-  dependencies:
-    resolve "^1.17.0"
-
-browser-stdout@1.3.1:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/browser-stdout/-/browser-stdout-1.3.1.tgz#baa559ee14ced73452229bad7326467c61fabd60"
-  integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==
-
-browserify-aes@^1.0.0, browserify-aes@^1.0.4:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48"
-  integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==
-  dependencies:
-    buffer-xor "^1.0.3"
-    cipher-base "^1.0.0"
-    create-hash "^1.1.0"
-    evp_bytestokey "^1.0.3"
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-browserify-cipher@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/browserify-cipher/-/browserify-cipher-1.0.1.tgz#8d6474c1b870bfdabcd3bcfcc1934a10e94f15f0"
-  integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==
-  dependencies:
-    browserify-aes "^1.0.4"
-    browserify-des "^1.0.0"
-    evp_bytestokey "^1.0.0"
-
-browserify-des@^1.0.0:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/browserify-des/-/browserify-des-1.0.2.tgz#3af4f1f59839403572f1c66204375f7a7f703e9c"
-  integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==
-  dependencies:
-    cipher-base "^1.0.1"
-    des.js "^1.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
-
-browserify-rsa@^4.0.0, browserify-rsa@^4.0.1:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/browserify-rsa/-/browserify-rsa-4.1.0.tgz#b2fd06b5b75ae297f7ce2dc651f918f5be158c8d"
-  integrity sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==
-  dependencies:
-    bn.js "^5.0.0"
-    randombytes "^2.0.1"
-
-browserify-sign@^4.0.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/browserify-sign/-/browserify-sign-4.2.1.tgz#eaf4add46dd54be3bb3b36c0cf15abbeba7956c3"
-  integrity sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==
-  dependencies:
-    bn.js "^5.1.1"
-    browserify-rsa "^4.0.1"
-    create-hash "^1.2.0"
-    create-hmac "^1.1.7"
-    elliptic "^6.5.3"
-    inherits "^2.0.4"
-    parse-asn1 "^5.1.5"
-    readable-stream "^3.6.0"
-    safe-buffer "^5.2.0"
-
-browserify-zlib@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/browserify-zlib/-/browserify-zlib-0.2.0.tgz#2869459d9aa3be245fe8fe2ca1f46e2e7f54d73f"
-  integrity sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==
-  dependencies:
-    pako "~1.0.5"
-
-browserslist@^4.14.5, browserslist@^4.20.2, browserslist@^4.20.3:
-  version "4.20.3"
-  resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.20.3.tgz#eb7572f49ec430e054f56d52ff0ebe9be915f8bf"
-  integrity sha512-NBhymBQl1zM0Y5dQT/O+xiLP9/rzOIQdKM/eMJBAq7yBgaB6krIYLGejrwVYnSHZdqjscB1SPuAjHwxjvN6Wdg==
-  dependencies:
-    caniuse-lite "^1.0.30001332"
-    electron-to-chromium "^1.4.118"
-    escalade "^3.1.1"
-    node-releases "^2.0.3"
-    picocolors "^1.0.0"
-
-buffer-alloc-unsafe@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz#bd7dc26ae2972d0eda253be061dba992349c19f0"
-  integrity sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==
-
-buffer-alloc@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/buffer-alloc/-/buffer-alloc-1.2.0.tgz#890dd90d923a873e08e10e5fd51a57e5b7cce0ec"
-  integrity sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==
-  dependencies:
-    buffer-alloc-unsafe "^1.1.0"
-    buffer-fill "^1.0.0"
-
-buffer-crc32@^0.2.1, buffer-crc32@^0.2.13, buffer-crc32@~0.2.3:
-  version "0.2.13"
-  resolved "https://registry.yarnpkg.com/buffer-crc32/-/buffer-crc32-0.2.13.tgz#0d333e3f00eac50aa1454abd30ef8c2a5d9a7242"
-  integrity sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=
-
-buffer-fill@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/buffer-fill/-/buffer-fill-1.0.0.tgz#f8f78b76789888ef39f205cd637f68e702122b2c"
-  integrity sha1-+PeLdniYiO858gXNY39o5wISKyw=
-
-buffer-from@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
-  integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
-
-buffer-xor@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9"
-  integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=
-
-buffer@^5.2.1, buffer@^5.4.3, buffer@^5.5.0:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/buffer/-/buffer-5.7.1.tgz#ba62e7c13133053582197160851a8f648e99eed0"
-  integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==
-  dependencies:
-    base64-js "^1.3.1"
-    ieee754 "^1.1.13"
-
-builtin-modules@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-3.2.0.tgz#45d5db99e7ee5e6bc4f362e008bf917ab5049887"
-  integrity sha512-lGzLKcioL90C7wMczpkY0n/oART3MbBa8R9OFGE1rJxoVI86u4WAGfEk8Wjv10eKSyTHVGkSo3bvBylCEtk7LA==
-
-builtin-status-codes@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
-  integrity sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=
-
-bytes@3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/bytes/-/bytes-3.1.2.tgz#8b0beeb98605adf1b128fa4386403c009e0221a5"
-  integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==
-
-cacheable-lookup@^5.0.3:
-  version "5.0.4"
-  resolved "https://registry.yarnpkg.com/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz#5a6b865b2c44357be3d5ebc2a467b032719a7005"
-  integrity sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==
-
-cacheable-request@^2.1.1:
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-2.1.4.tgz#0d808801b6342ad33c91df9d0b44dc09b91e5c3d"
-  integrity sha1-DYCIAbY0KtM8kd+dC0TcCbkeXD0=
-  dependencies:
-    clone-response "1.0.2"
-    get-stream "3.0.0"
-    http-cache-semantics "3.8.1"
-    keyv "3.0.0"
-    lowercase-keys "1.0.0"
-    normalize-url "2.0.1"
-    responselike "1.0.2"
-
-cacheable-request@^7.0.2:
-  version "7.0.2"
-  resolved "https://registry.yarnpkg.com/cacheable-request/-/cacheable-request-7.0.2.tgz#ea0d0b889364a25854757301ca12b2da77f91d27"
-  integrity sha512-pouW8/FmiPQbuGpkXQ9BAPv/Mo5xDGANgSNXzTzJ8DrKGuXOssM4wIQRjfanNRh3Yu5cfYPvcorqbhg2KIJtew==
-  dependencies:
-    clone-response "^1.0.2"
-    get-stream "^5.1.0"
-    http-cache-semantics "^4.0.0"
-    keyv "^4.0.0"
-    lowercase-keys "^2.0.0"
-    normalize-url "^6.0.1"
-    responselike "^2.0.0"
-
-cachedir@2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/cachedir/-/cachedir-2.2.0.tgz#19afa4305e05d79e417566882e0c8f960f62ff0e"
-  integrity sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==
-
-call-bind@^1.0.0, call-bind@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c"
-  integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==
-  dependencies:
-    function-bind "^1.1.1"
-    get-intrinsic "^1.0.2"
-
-callsites@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73"
-  integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==
-
-camel-case@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/camel-case/-/camel-case-4.1.2.tgz#9728072a954f805228225a6deea6b38461e1bd5a"
-  integrity sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==
-  dependencies:
-    pascal-case "^3.1.2"
-    tslib "^2.0.3"
-
-camelcase-keys@^6.2.2:
-  version "6.2.2"
-  resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0"
-  integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==
-  dependencies:
-    camelcase "^5.3.1"
-    map-obj "^4.0.0"
-    quick-lru "^4.0.1"
-
-camelcase@^5.3.1:
-  version "5.3.1"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
-  integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
-
-camelcase@^6.0.0, camelcase@^6.2.0:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-6.3.0.tgz#5685b95eb209ac9c0c177467778c9c84df58ba9a"
-  integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==
-
-caniuse-lite@^1.0.30001332:
-  version "1.0.30001335"
-  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001335.tgz#899254a0b70579e5a957c32dced79f0727c61f2a"
-  integrity sha512-ddP1Tgm7z2iIxu6QTtbZUv6HJxSaV/PZeSrWFZtbY4JZ69tOeNhBCl3HyRQgeNZKE5AOn1kpV7fhljigy0Ty3w==
-
-capital-case@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/capital-case/-/capital-case-1.0.4.tgz#9d130292353c9249f6b00fa5852bee38a717e669"
-  integrity sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A==
-  dependencies:
-    no-case "^3.0.4"
-    tslib "^2.0.3"
-    upper-case-first "^2.0.2"
-
-caseless@~0.12.0:
-  version "0.12.0"
-  resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc"
-  integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=
-
-caw@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/caw/-/caw-2.0.1.tgz#6c3ca071fc194720883c2dc5da9b074bfc7e9e95"
-  integrity sha512-Cg8/ZSBEa8ZVY9HspcGUYaK63d/bN7rqS3CYCzEGUxuYv6UlmcjzDUz2fCFFHyTvUW5Pk0I+3hkA3iXlIj6guA==
-  dependencies:
-    get-proxy "^2.0.0"
-    isurl "^1.0.0-alpha5"
-    tunnel-agent "^0.6.0"
-    url-to-options "^1.0.1"
-
-chai-nightwatch@0.5.3:
-  version "0.5.3"
-  resolved "https://registry.yarnpkg.com/chai-nightwatch/-/chai-nightwatch-0.5.3.tgz#980ecf63dde5a04e7f3524370682c7ff01178ffb"
-  integrity sha512-38ixH/mqpY6IwnZkz6xPqx8aB5/KVR+j6VPugcir3EGOsphnWXrPH/mUt8Jp+ninL6ghY0AaJDQ10hSfCPGy/g==
-  dependencies:
-    assertion-error "1.1.0"
-
-chalk@^2.0.0, chalk@^2.0.1, chalk@^2.1.0, chalk@^2.4.1, chalk@^2.4.2:
-  version "2.4.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
-  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
-  dependencies:
-    ansi-styles "^3.2.1"
-    escape-string-regexp "^1.0.5"
-    supports-color "^5.3.0"
-
-chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
-  integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
-  dependencies:
-    ansi-styles "^4.1.0"
-    supports-color "^7.1.0"
-
-change-case@^4.1.1:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/change-case/-/change-case-4.1.2.tgz#fedfc5f136045e2398c0410ee441f95704641e12"
-  integrity sha512-bSxY2ws9OtviILG1EiY5K7NNxkqg/JnRnFxLtKQ96JaviiIxi7djMrSd0ECT9AC+lttClmYwKw53BWpOMblo7A==
-  dependencies:
-    camel-case "^4.1.2"
-    capital-case "^1.0.4"
-    constant-case "^3.0.4"
-    dot-case "^3.0.4"
-    header-case "^2.0.4"
-    no-case "^3.0.4"
-    param-case "^3.0.4"
-    pascal-case "^3.1.2"
-    path-case "^3.0.4"
-    sentence-case "^3.0.4"
-    snake-case "^3.0.4"
-    tslib "^2.0.3"
-
-chardet@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
-  integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
-
-check-error@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82"
-  integrity sha1-V00xLt2Iu13YkS6Sht1sCu1KrII=
-
-chokidar@3.5.3, chokidar@^3.5.1:
-  version "3.5.3"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.3.tgz#1cf37c8707b932bd1af1ae22c0432e2acd1903bd"
-  integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==
-  dependencies:
-    anymatch "~3.1.2"
-    braces "~3.0.2"
-    glob-parent "~5.1.2"
-    is-binary-path "~2.1.0"
-    is-glob "~4.0.1"
-    normalize-path "~3.0.0"
-    readdirp "~3.6.0"
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-chownr@^1.1.1:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b"
-  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
-
-chrome-launcher@^0.13.1:
-  version "0.13.4"
-  resolved "https://registry.yarnpkg.com/chrome-launcher/-/chrome-launcher-0.13.4.tgz#4c7d81333c98282899c4e38256da23e00ed32f73"
-  integrity sha512-nnzXiDbGKjDSK6t2I+35OAPBy5Pw/39bgkb/ZAFwMhwJbdYBp6aH+vW28ZgtjdU890Q7D+3wN/tB8N66q5Gi2A==
-  dependencies:
-    "@types/node" "*"
-    escape-string-regexp "^1.0.5"
-    is-wsl "^2.2.0"
-    lighthouse-logger "^1.0.0"
-    mkdirp "^0.5.3"
-    rimraf "^3.0.2"
-
-chrome-trace-event@^1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac"
-  integrity sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==
-
-chromedriver@^100.0.0:
-  version "100.0.0"
-  resolved "https://registry.yarnpkg.com/chromedriver/-/chromedriver-100.0.0.tgz#1b4bf5c89cea12c79f53bc94d8f5bb5aa79ed7be"
-  integrity sha512-oLfB0IgFEGY9qYpFQO/BNSXbPw7bgfJUN5VX8Okps9W2qNT4IqKh5hDwKWtpUIQNI6K3ToWe2/J5NdpurTY02g==
-  dependencies:
-    "@testim/chrome-version" "^1.1.2"
-    axios "^0.24.0"
-    del "^6.0.0"
-    extract-zip "^2.0.1"
-    https-proxy-agent "^5.0.0"
-    proxy-from-env "^1.1.0"
-    tcp-port-used "^1.0.1"
-
-ci-info@3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-3.3.0.tgz#b4ed1fb6818dea4803a55c623041f9165d2066b2"
-  integrity sha512-riT/3vI5YpVH6/qomlDnJow6TBee2PBKSEpx3O32EGPYbWGIRsIlGRms3Sm74wYE1JMo8RnO04Hb12+v1J5ICw==
-
-ci-info@^1.5.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-1.6.0.tgz#2ca20dbb9ceb32d4524a683303313f0304b1e497"
-  integrity sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==
-
-cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
-  integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-clean-stack@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/clean-stack/-/clean-stack-2.2.0.tgz#ee8472dbb129e727b31e8a10a427dee9dfe4008b"
-  integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==
-
-cli-boxes@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-2.2.1.tgz#ddd5035d25094fce220e9cab40a45840a440318f"
-  integrity sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==
-
-cli-cursor@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-2.1.0.tgz#b35dac376479facc3e94747d41d0d0f5238ffcb5"
-  integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=
-  dependencies:
-    restore-cursor "^2.0.0"
-
-cli-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-3.1.0.tgz#264305a7ae490d1d03bf0c9ba7c925d1753af307"
-  integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==
-  dependencies:
-    restore-cursor "^3.1.0"
-
-cli-spinners@^2.5.0:
-  version "2.6.1"
-  resolved "https://registry.yarnpkg.com/cli-spinners/-/cli-spinners-2.6.1.tgz#adc954ebe281c37a6319bfa401e6dd2488ffb70d"
-  integrity sha512-x/5fWmGMnbKQAaNwN+UZlV79qBLM9JFnJuJ03gIi5whrob0xV0ofNVHy9DhwGdsMJQc2OKv0oGmLzvaqvAVv+g==
-
-cli-truncate@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-2.1.0.tgz#c39e28bf05edcde5be3b98992a22deed5a2b93c7"
-  integrity sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==
-  dependencies:
-    slice-ansi "^3.0.0"
-    string-width "^4.2.0"
-
-cli-truncate@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-3.1.0.tgz#3f23ab12535e3d73e839bb43e73c9de487db1389"
-  integrity sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==
-  dependencies:
-    slice-ansi "^5.0.0"
-    string-width "^5.0.0"
-
-cli-width@^2.0.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.2.1.tgz#b0433d0b4e9c847ef18868a4ef16fd5fc8271c48"
-  integrity sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==
-
-cliui@^7.0.2:
-  version "7.0.4"
-  resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
-  integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
-  dependencies:
-    string-width "^4.2.0"
-    strip-ansi "^6.0.0"
-    wrap-ansi "^7.0.0"
-
-clone-deep@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
-  integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
-  dependencies:
-    is-plain-object "^2.0.4"
-    kind-of "^6.0.2"
-    shallow-clone "^3.0.0"
-
-clone-response@1.0.2, clone-response@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/clone-response/-/clone-response-1.0.2.tgz#d1dc973920314df67fbeb94223b4ee350239e96b"
-  integrity sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws=
-  dependencies:
-    mimic-response "^1.0.0"
-
-clone@^1.0.2:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"
-  integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=
-
-codecov@^3.8.3:
-  version "3.8.3"
-  resolved "https://registry.yarnpkg.com/codecov/-/codecov-3.8.3.tgz#9c3e364b8a700c597346ae98418d09880a3fdbe7"
-  integrity sha512-Y8Hw+V3HgR7V71xWH2vQ9lyS358CbGCldWlJFR0JirqoGtOoas3R3/OclRTvgUYFK29mmJICDPauVKmpqbwhOA==
-  dependencies:
-    argv "0.0.2"
-    ignore-walk "3.0.4"
-    js-yaml "3.14.1"
-    teeny-request "7.1.1"
-    urlgrey "1.0.0"
-
-color-convert@^1.9.0:
-  version "1.9.3"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
-  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
-  dependencies:
-    color-name "1.1.3"
-
-color-convert@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
-  integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
-  dependencies:
-    color-name "~1.1.4"
-
-color-name@1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
-  integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
-
-color-name@~1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
-  integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
-
-colorette@^2.0.16:
-  version "2.0.16"
-  resolved "https://registry.yarnpkg.com/colorette/-/colorette-2.0.16.tgz#713b9af84fdb000139f04546bd4a93f62a5085da"
-  integrity sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==
-
-combine-source-map@^0.8.0:
-  version "0.8.0"
-  resolved "https://registry.yarnpkg.com/combine-source-map/-/combine-source-map-0.8.0.tgz#a58d0df042c186fcf822a8e8015f5450d2d79a8b"
-  integrity sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=
-  dependencies:
-    convert-source-map "~1.1.0"
-    inline-source-map "~0.6.0"
-    lodash.memoize "~3.0.3"
-    source-map "~0.5.3"
-
-combined-stream@^1.0.6, combined-stream@^1.0.8, combined-stream@~1.0.6:
-  version "1.0.8"
-  resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
-  integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
-  dependencies:
-    delayed-stream "~1.0.0"
-
-commander@^2.20.0, commander@^2.8.1:
-  version "2.20.3"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
-  integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
-
-commander@^8.3.0:
-  version "8.3.0"
-  resolved "https://registry.yarnpkg.com/commander/-/commander-8.3.0.tgz#4837ea1b2da67b9c616a67afbb0fafee567bca66"
-  integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==
-
-commitizen@^4.0.3, commitizen@^4.2.4:
-  version "4.2.4"
-  resolved "https://registry.yarnpkg.com/commitizen/-/commitizen-4.2.4.tgz#a3e5b36bd7575f6bf6e7aa19dbbf06b0d8f37165"
-  integrity sha512-LlZChbDzg3Ir3O2S7jSo/cgWp5/QwylQVr59K4xayVq8S4/RdKzSyJkghAiZZHfhh5t4pxunUoyeg0ml1q/7aw==
-  dependencies:
-    cachedir "2.2.0"
-    cz-conventional-changelog "3.2.0"
-    dedent "0.7.0"
-    detect-indent "6.0.0"
-    find-node-modules "^2.1.2"
-    find-root "1.1.0"
-    fs-extra "8.1.0"
-    glob "7.1.4"
-    inquirer "6.5.2"
-    is-utf8 "^0.2.1"
-    lodash "^4.17.20"
-    minimist "1.2.5"
-    strip-bom "4.0.0"
-    strip-json-comments "3.0.1"
-
-commondir@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
-  integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=
-
-compare-func@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-2.0.0.tgz#fb65e75edbddfd2e568554e8b5b05fff7a51fcb3"
-  integrity sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA==
-  dependencies:
-    array-ify "^1.0.0"
-    dot-prop "^5.1.0"
-
-component-emitter@~1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/component-emitter/-/component-emitter-1.3.0.tgz#16e4070fba8ae29b679f2215853ee181ab2eabc0"
-  integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==
-
-compress-brotli@^1.3.6:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/compress-brotli/-/compress-brotli-1.3.6.tgz#64bd6f21f4f3e9841dbac392f4c29218caf5e9d9"
-  integrity sha512-au99/GqZtUtiCBliqLFbWlhnCxn+XSYjwZ77q6mKN4La4qOXDoLVPZ50iXr0WmAyMxl8yqoq3Yq4OeQNPPkyeQ==
-  dependencies:
-    "@types/json-buffer" "~3.0.0"
-    json-buffer "~3.0.1"
-
-compress-commons@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/compress-commons/-/compress-commons-4.1.1.tgz#df2a09a7ed17447642bad10a85cc9a19e5c42a7d"
-  integrity sha512-QLdDLCKNV2dtoTorqgxngQCMA+gWXkM/Nwu7FpeBhk/RdkzimqC3jueb/FDmaZeXh+uby1jkBqE3xArsLBE5wQ==
-  dependencies:
-    buffer-crc32 "^0.2.13"
-    crc32-stream "^4.0.2"
-    normalize-path "^3.0.0"
-    readable-stream "^3.6.0"
-
-concat-map@0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
-  integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
-
-concat-stream@^1.6.2:
-  version "1.6.2"
-  resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.2.tgz#904bdf194cd3122fc675c77fc4ac3d4ff0fd1a34"
-  integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==
-  dependencies:
-    buffer-from "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^2.2.2"
-    typedarray "^0.0.6"
-
-config-chain@^1.1.11:
-  version "1.1.13"
-  resolved "https://registry.yarnpkg.com/config-chain/-/config-chain-1.1.13.tgz#fad0795aa6a6cdaff9ed1b68e9dff94372c232f4"
-  integrity sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==
-  dependencies:
-    ini "^1.3.4"
-    proto-list "~1.2.1"
-
-connect@^3.7.0:
-  version "3.7.0"
-  resolved "https://registry.yarnpkg.com/connect/-/connect-3.7.0.tgz#5d49348910caa5e07a01800b030d0c35f20484f8"
-  integrity sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==
-  dependencies:
-    debug "2.6.9"
-    finalhandler "1.1.2"
-    parseurl "~1.3.3"
-    utils-merge "1.0.1"
-
-console-browserify@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/console-browserify/-/console-browserify-1.2.0.tgz#67063cef57ceb6cf4993a2ab3a55840ae8c49336"
-  integrity sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==
-
-constant-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/constant-case/-/constant-case-3.0.4.tgz#3b84a9aeaf4cf31ec45e6bf5de91bdfb0589faf1"
-  integrity sha512-I2hSBi7Vvs7BEuJDr5dDHfzb/Ruj3FyvFyh7KLilAjNQw3Be+xgqUBA2W6scVEcL0hL1dwPRtIqEPVUCKkSsyQ==
-  dependencies:
-    no-case "^3.0.4"
-    tslib "^2.0.3"
-    upper-case "^2.0.2"
-
-constants-browserify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/constants-browserify/-/constants-browserify-1.0.0.tgz#c20b96d8c617748aaf1c16021760cd27fcb8cb75"
-  integrity sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=
-
-content-disposition@^0.5.2:
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/content-disposition/-/content-disposition-0.5.4.tgz#8b82b4efac82512a02bb0b1dcec9d2c5e8eb5bfe"
-  integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==
-  dependencies:
-    safe-buffer "5.2.1"
-
-content-type@~1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/content-type/-/content-type-1.0.4.tgz#e138cc75e040c727b1966fe5e5f8c9aee256fe3b"
-  integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==
-
-conventional-changelog-angular@^5.0.12:
-  version "5.0.13"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-5.0.13.tgz#896885d63b914a70d4934b59d2fe7bde1832b28c"
-  integrity sha512-i/gipMxs7s8L/QeuavPF2hLnJgH6pEZAttySB6aiQLWcX3puWDL3ACVmvBhJGxnAy52Qc15ua26BufY6KpmrVA==
-  dependencies:
-    compare-func "^2.0.0"
-    q "^1.5.1"
-
-conventional-changelog-atom@^2.0.8:
-  version "2.0.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-atom/-/conventional-changelog-atom-2.0.8.tgz#a759ec61c22d1c1196925fca88fe3ae89fd7d8de"
-  integrity sha512-xo6v46icsFTK3bb7dY/8m2qvc8sZemRgdqLb/bjpBsH2UyOS8rKNTgcb5025Hri6IpANPApbXMg15QLb1LJpBw==
-  dependencies:
-    q "^1.5.1"
-
-conventional-changelog-codemirror@^2.0.8:
-  version "2.0.8"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-codemirror/-/conventional-changelog-codemirror-2.0.8.tgz#398e9530f08ce34ec4640af98eeaf3022eb1f7dc"
-  integrity sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw==
-  dependencies:
-    q "^1.5.1"
-
-conventional-changelog-conventionalcommits@^4.5.0:
-  version "4.6.3"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-4.6.3.tgz#0765490f56424b46f6cb4db9135902d6e5a36dc2"
-  integrity sha512-LTTQV4fwOM4oLPad317V/QNQ1FY4Hju5qeBIM1uTHbrnCE+Eg4CdRZ3gO2pUeR+tzWdp80M2j3qFFEDWVqOV4g==
-  dependencies:
-    compare-func "^2.0.0"
-    lodash "^4.17.15"
-    q "^1.5.1"
-
-conventional-changelog-core@^4.2.1:
-  version "4.2.4"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-core/-/conventional-changelog-core-4.2.4.tgz#e50d047e8ebacf63fac3dc67bf918177001e1e9f"
-  integrity sha512-gDVS+zVJHE2v4SLc6B0sLsPiloR0ygU7HaDW14aNJE1v4SlqJPILPl/aJC7YdtRE4CybBf8gDwObBvKha8Xlyg==
-  dependencies:
-    add-stream "^1.0.0"
-    conventional-changelog-writer "^5.0.0"
-    conventional-commits-parser "^3.2.0"
-    dateformat "^3.0.0"
-    get-pkg-repo "^4.0.0"
-    git-raw-commits "^2.0.8"
-    git-remote-origin-url "^2.0.0"
-    git-semver-tags "^4.1.1"
-    lodash "^4.17.15"
-    normalize-package-data "^3.0.0"
-    q "^1.5.1"
-    read-pkg "^3.0.0"
-    read-pkg-up "^3.0.0"
-    through2 "^4.0.0"
-
-conventional-changelog-ember@^2.0.9:
-  version "2.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-ember/-/conventional-changelog-ember-2.0.9.tgz#619b37ec708be9e74a220f4dcf79212ae1c92962"
-  integrity sha512-ulzIReoZEvZCBDhcNYfDIsLTHzYHc7awh+eI44ZtV5cx6LVxLlVtEmcO+2/kGIHGtw+qVabJYjdI5cJOQgXh1A==
-  dependencies:
-    q "^1.5.1"
-
-conventional-changelog-eslint@^3.0.9:
-  version "3.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-eslint/-/conventional-changelog-eslint-3.0.9.tgz#689bd0a470e02f7baafe21a495880deea18b7cdb"
-  integrity sha512-6NpUCMgU8qmWmyAMSZO5NrRd7rTgErjrm4VASam2u5jrZS0n38V7Y9CzTtLT2qwz5xEChDR4BduoWIr8TfwvXA==
-  dependencies:
-    q "^1.5.1"
-
-conventional-changelog-express@^2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-express/-/conventional-changelog-express-2.0.6.tgz#420c9d92a347b72a91544750bffa9387665a6ee8"
-  integrity sha512-SDez2f3iVJw6V563O3pRtNwXtQaSmEfTCaTBPCqn0oG0mfkq0rX4hHBq5P7De2MncoRixrALj3u3oQsNK+Q0pQ==
-  dependencies:
-    q "^1.5.1"
-
-conventional-changelog-jquery@^3.0.11:
-  version "3.0.11"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jquery/-/conventional-changelog-jquery-3.0.11.tgz#d142207400f51c9e5bb588596598e24bba8994bf"
-  integrity sha512-x8AWz5/Td55F7+o/9LQ6cQIPwrCjfJQ5Zmfqi8thwUEKHstEn4kTIofXub7plf1xvFA2TqhZlq7fy5OmV6BOMw==
-  dependencies:
-    q "^1.5.1"
-
-conventional-changelog-jshint@^2.0.9:
-  version "2.0.9"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-jshint/-/conventional-changelog-jshint-2.0.9.tgz#f2d7f23e6acd4927a238555d92c09b50fe3852ff"
-  integrity sha512-wMLdaIzq6TNnMHMy31hql02OEQ8nCQfExw1SE0hYL5KvU+JCTuPaDO+7JiogGT2gJAxiUGATdtYYfh+nT+6riA==
-  dependencies:
-    compare-func "^2.0.0"
-    q "^1.5.1"
-
-conventional-changelog-preset-loader@^2.3.4:
-  version "2.3.4"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-2.3.4.tgz#14a855abbffd59027fd602581f1f34d9862ea44c"
-  integrity sha512-GEKRWkrSAZeTq5+YjUZOYxdHq+ci4dNwHvpaBC3+ENalzFWuCWa9EZXSuZBpkr72sMdKB+1fyDV4takK1Lf58g==
-
-conventional-changelog-writer@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/conventional-changelog-writer/-/conventional-changelog-writer-5.0.1.tgz#e0757072f045fe03d91da6343c843029e702f359"
-  integrity sha512-5WsuKUfxW7suLblAbFnxAcrvf6r+0b7GvNaWUwUIk0bXMnENP/PEieGKVUQrjPqwPT4o3EPAASBXiY6iHooLOQ==
-  dependencies:
-    conventional-commits-filter "^2.0.7"
-    dateformat "^3.0.0"
-    handlebars "^4.7.7"
-    json-stringify-safe "^5.0.1"
-    lodash "^4.17.15"
-    meow "^8.0.0"
-    semver "^6.0.0"
-    split "^1.0.0"
-    through2 "^4.0.0"
-
-conventional-changelog@^3.1.25:
-  version "3.1.25"
-  resolved "https://registry.yarnpkg.com/conventional-changelog/-/conventional-changelog-3.1.25.tgz#3e227a37d15684f5aa1fb52222a6e9e2536ccaff"
-  integrity sha512-ryhi3fd1mKf3fSjbLXOfK2D06YwKNic1nC9mWqybBHdObPd8KJ2vjaXZfYj1U23t+V8T8n0d7gwnc9XbIdFbyQ==
-  dependencies:
-    conventional-changelog-angular "^5.0.12"
-    conventional-changelog-atom "^2.0.8"
-    conventional-changelog-codemirror "^2.0.8"
-    conventional-changelog-conventionalcommits "^4.5.0"
-    conventional-changelog-core "^4.2.1"
-    conventional-changelog-ember "^2.0.9"
-    conventional-changelog-eslint "^3.0.9"
-    conventional-changelog-express "^2.0.6"
-    conventional-changelog-jquery "^3.0.11"
-    conventional-changelog-jshint "^2.0.9"
-    conventional-changelog-preset-loader "^2.3.4"
-
-conventional-commit-types@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/conventional-commit-types/-/conventional-commit-types-3.0.0.tgz#7c9214e58eae93e85dd66dbfbafe7e4fffa2365b"
-  integrity sha512-SmmCYnOniSsAa9GqWOeLqc179lfr5TRu5b4QFDkbsrJ5TZjPJx85wtOr3zn+1dbeNiXDKGPbZ72IKbPhLXh/Lg==
-
-conventional-commits-filter@^2.0.7:
-  version "2.0.7"
-  resolved "https://registry.yarnpkg.com/conventional-commits-filter/-/conventional-commits-filter-2.0.7.tgz#f8d9b4f182fce00c9af7139da49365b136c8a0b3"
-  integrity sha512-ASS9SamOP4TbCClsRHxIHXRfcGCnIoQqkvAzCSbZzTFLfcTqJVugB0agRgsEELsqaeWgsXv513eS116wnlSSPA==
-  dependencies:
-    lodash.ismatch "^4.4.0"
-    modify-values "^1.0.0"
-
-conventional-commits-parser@^3.2.0:
-  version "3.2.4"
-  resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-3.2.4.tgz#a7d3b77758a202a9b2293d2112a8d8052c740972"
-  integrity sha512-nK7sAtfi+QXbxHCYfhpZsfRtaitZLIA6889kFIouLvz6repszQDgxBu7wf2WbU+Dco7sAnNCJYERCwt54WPC2Q==
-  dependencies:
-    JSONStream "^1.0.4"
-    is-text-path "^1.0.1"
-    lodash "^4.17.15"
-    meow "^8.0.0"
-    split2 "^3.0.0"
-    through2 "^4.0.0"
-
-convert-source-map@^1.7.0:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.8.0.tgz#f3373c32d21b4d780dd8004514684fb791ca4369"
-  integrity sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==
-  dependencies:
-    safe-buffer "~5.1.1"
-
-convert-source-map@~1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.1.3.tgz#4829c877e9fe49b3161f3bf3673888e204699860"
-  integrity sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=
-
-cookie@~0.4.1:
-  version "0.4.2"
-  resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.2.tgz#0e41f24de5ecf317947c82fc789e06a884824432"
-  integrity sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==
-
-core-js-compat@^3.21.0, core-js-compat@^3.22.1:
-  version "3.22.3"
-  resolved "https://registry.yarnpkg.com/core-js-compat/-/core-js-compat-3.22.3.tgz#9b10d786052d042bc97ee8df9c0d1fb6a49c2005"
-  integrity sha512-wliMbvPI2idgFWpFe7UEyHMvu6HWgW8WA+HnDRtgzoSDYvXFMpoGX1H3tPDDXrcfUSyXafCLDd7hOeMQHEZxGw==
-  dependencies:
-    browserslist "^4.20.3"
-    semver "7.0.0"
-
-core-js@^3.6.5:
-  version "3.22.3"
-  resolved "https://registry.yarnpkg.com/core-js/-/core-js-3.22.3.tgz#498c41d997654cb00e81c7a54b44f0ab21ab01d5"
-  integrity sha512-1t+2a/d2lppW1gkLXx3pKPVGbBdxXAkqztvWb1EJ8oF8O2gIGiytzflNiFEehYwVK/t2ryUsGBoOFFvNx95mbg==
-
-core-util-is@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
-  integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
-
-core-util-is@~1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85"
-  integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==
-
-cors@~2.8.5:
-  version "2.8.5"
-  resolved "https://registry.yarnpkg.com/cors/-/cors-2.8.5.tgz#eac11da51592dd86b9f06f6e7ac293b3df875d29"
-  integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==
-  dependencies:
-    object-assign "^4"
-    vary "^1"
-
-corser@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/corser/-/corser-2.0.1.tgz#8eda252ecaab5840dcd975ceb90d9370c819ff87"
-  integrity sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=
-
-cosmiconfig-typescript-loader@^1.0.0:
-  version "1.0.9"
-  resolved "https://registry.yarnpkg.com/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-1.0.9.tgz#69c523f7e8c3d9f27f563d02bbeadaf2f27212d3"
-  integrity sha512-tRuMRhxN4m1Y8hP9SNYfz7jRwt8lZdWxdjg/ohg5esKmsndJIn4yT96oJVcf5x0eA11taXl+sIp+ielu529k6g==
-  dependencies:
-    cosmiconfig "^7"
-    ts-node "^10.7.0"
-
-cosmiconfig@^7, cosmiconfig@^7.0.0:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/cosmiconfig/-/cosmiconfig-7.0.1.tgz#714d756522cace867867ccb4474c5d01bbae5d6d"
-  integrity sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==
-  dependencies:
-    "@types/parse-json" "^4.0.0"
-    import-fresh "^3.2.1"
-    parse-json "^5.0.0"
-    path-type "^4.0.0"
-    yaml "^1.10.0"
-
-crc-32@^1.2.0:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/crc-32/-/crc-32-1.2.2.tgz#3cad35a934b8bf71f25ca524b6da51fb7eace2ff"
-  integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==
-
-crc32-stream@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/crc32-stream/-/crc32-stream-4.0.2.tgz#c922ad22b38395abe9d3870f02fa8134ed709007"
-  integrity sha512-DxFZ/Hk473b/muq1VJ///PMNLj0ZMnzye9thBpmjpJKCc5eMgB95aK8zCGrGfQ90cWo561Te6HK9D+j4KPdM6w==
-  dependencies:
-    crc-32 "^1.2.0"
-    readable-stream "^3.4.0"
-
-create-ecdh@^4.0.0:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/create-ecdh/-/create-ecdh-4.0.4.tgz#d6e7f4bffa66736085a0762fd3a632684dabcc4e"
-  integrity sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==
-  dependencies:
-    bn.js "^4.1.0"
-    elliptic "^6.5.3"
-
-create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
-  integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
-  dependencies:
-    cipher-base "^1.0.1"
-    inherits "^2.0.1"
-    md5.js "^1.3.4"
-    ripemd160 "^2.0.1"
-    sha.js "^2.4.0"
-
-create-hmac@^1.1.0, create-hmac@^1.1.4, create-hmac@^1.1.7:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff"
-  integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==
-  dependencies:
-    cipher-base "^1.0.3"
-    create-hash "^1.1.0"
-    inherits "^2.0.1"
-    ripemd160 "^2.0.0"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-create-require@^1.1.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
-  integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
-
-cross-fetch@3.1.5:
-  version "3.1.5"
-  resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.1.5.tgz#e1389f44d9e7ba767907f7af8454787952ab534f"
-  integrity sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==
-  dependencies:
-    node-fetch "2.6.7"
-
-cross-spawn@^5.0.1:
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-5.1.0.tgz#e8bd0efee58fcff6f8f94510a0a554bbfa235449"
-  integrity sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=
-  dependencies:
-    lru-cache "^4.0.1"
-    shebang-command "^1.2.0"
-    which "^1.2.9"
-
-cross-spawn@^6.0.0:
-  version "6.0.5"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-6.0.5.tgz#4a5ec7c64dfae22c3a14124dbacdee846d80cbc4"
-  integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==
-  dependencies:
-    nice-try "^1.0.4"
-    path-key "^2.0.1"
-    semver "^5.5.0"
-    shebang-command "^1.2.0"
-    which "^1.2.9"
-
-cross-spawn@^7.0.2, cross-spawn@^7.0.3:
-  version "7.0.3"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
-  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
-  dependencies:
-    path-key "^3.1.0"
-    shebang-command "^2.0.0"
-    which "^2.0.1"
-
-crypto-browserify@^3.12.0:
-  version "3.12.0"
-  resolved "https://registry.yarnpkg.com/crypto-browserify/-/crypto-browserify-3.12.0.tgz#396cf9f3137f03e4b8e532c58f698254e00f80ec"
-  integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==
-  dependencies:
-    browserify-cipher "^1.0.0"
-    browserify-sign "^4.0.0"
-    create-ecdh "^4.0.0"
-    create-hash "^1.1.0"
-    create-hmac "^1.1.0"
-    diffie-hellman "^5.0.0"
-    inherits "^2.0.1"
-    pbkdf2 "^3.0.3"
-    public-encrypt "^4.0.0"
-    randombytes "^2.0.0"
-    randomfill "^1.0.3"
-
-css-shorthand-properties@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/css-shorthand-properties/-/css-shorthand-properties-1.1.1.tgz#1c808e63553c283f289f2dd56fcee8f3337bd935"
-  integrity sha512-Md+Juc7M3uOdbAFwOYlTrccIZ7oCFuzrhKYQjdeUEW/sE1hv17Jp/Bws+ReOPpGVBTYCBoYo+G17V5Qo8QQ75A==
-
-css-value@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/css-value/-/css-value-0.0.1.tgz#5efd6c2eea5ea1fd6b6ac57ec0427b18452424ea"
-  integrity sha1-Xv1sLupeof1rasV+wEJ7GEUkJOo=
-
-css@~2.2.1:
-  version "2.2.4"
-  resolved "https://registry.yarnpkg.com/css/-/css-2.2.4.tgz#c646755c73971f2bba6a601e2cf2fd71b1298929"
-  integrity sha512-oUnjmWpy0niI3x/mPL8dVEI1l7MnG3+HHyRPHf+YFSbK+svOhXpmSOcDURUh2aOCgl2grzrOPt1nHLuCVFULLw==
-  dependencies:
-    inherits "^2.0.3"
-    source-map "^0.6.1"
-    source-map-resolve "^0.5.2"
-    urix "^0.1.0"
-
-custom-event@~1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/custom-event/-/custom-event-1.0.1.tgz#5d02a46850adf1b4a317946a3928fccb5bfd0425"
-  integrity sha1-XQKkaFCt8bSjF5RqOSj8y1v9BCU=
-
-cz-conventional-changelog@3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-3.2.0.tgz#6aef1f892d64113343d7e455529089ac9f20e477"
-  integrity sha512-yAYxeGpVi27hqIilG1nh4A9Bnx4J3Ov+eXy4koL3drrR+IO9GaWPsKjik20ht608Asqi8TQPf0mczhEeyAtMzg==
-  dependencies:
-    chalk "^2.4.1"
-    commitizen "^4.0.3"
-    conventional-commit-types "^3.0.0"
-    lodash.map "^4.5.1"
-    longest "^2.0.1"
-    word-wrap "^1.0.3"
-  optionalDependencies:
-    "@commitlint/load" ">6.1.1"
-
-cz-conventional-changelog@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-3.3.0.tgz#9246947c90404149b3fe2cf7ee91acad3b7d22d2"
-  integrity sha512-U466fIzU5U22eES5lTNiNbZ+d8dfcHcssH4o7QsdWaCcRs/feIPCxKYSWkYBNs5mny7MvEfwpTLWjvbm94hecw==
-  dependencies:
-    chalk "^2.4.1"
-    commitizen "^4.0.3"
-    conventional-commit-types "^3.0.0"
-    lodash.map "^4.5.1"
-    longest "^2.0.1"
-    word-wrap "^1.0.3"
-  optionalDependencies:
-    "@commitlint/load" ">6.1.1"
-
-dargs@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc"
-  integrity sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==
-
-dashdash@^1.12.0:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0"
-  integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=
-  dependencies:
-    assert-plus "^1.0.0"
-
-date-format@^4.0.9:
-  version "4.0.9"
-  resolved "https://registry.yarnpkg.com/date-format/-/date-format-4.0.9.tgz#4788015ac56dedebe83b03bc361f00c1ddcf1923"
-  integrity sha512-+8J+BOUpSrlKLQLeF8xJJVTxS8QfRSuJgwxSVvslzgO3E6khbI0F5mMEPf5mTYhCCm4h99knYP6H3W9n3BQFrg==
-
-dateformat@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae"
-  integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==
-
-de-indent@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/de-indent/-/de-indent-1.0.2.tgz#b2038e846dc33baa5796128d0804b455b8c1e21d"
-  integrity sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=
-
-debug@2.6.9, debug@^2.6.9:
-  version "2.6.9"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
-  integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
-  dependencies:
-    ms "2.0.0"
-
-debug@4, debug@4.3.4, debug@^4.1.0, debug@^4.1.1, debug@^4.3.2, debug@^4.3.3, debug@^4.3.4, debug@~4.3.1, debug@~4.3.2:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865"
-  integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==
-  dependencies:
-    ms "2.1.2"
-
-debug@4.3.1:
-  version "4.3.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
-  integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
-  dependencies:
-    ms "2.1.2"
-
-debug@4.3.3:
-  version "4.3.3"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.3.tgz#04266e0b70a98d4462e6e288e38259213332b664"
-  integrity sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q==
-  dependencies:
-    ms "2.1.2"
-
-debug@^3.1.1:
-  version "3.2.7"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
-  integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
-  dependencies:
-    ms "^2.1.1"
-
-decamelize-keys@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9"
-  integrity sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=
-  dependencies:
-    decamelize "^1.1.0"
-    map-obj "^1.0.0"
-
-decamelize@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
-  integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
-
-decamelize@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-4.0.0.tgz#aa472d7bf660eb15f3494efd531cab7f2a709837"
-  integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==
-
-decode-uri-component@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545"
-  integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=
-
-decompress-response@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-3.3.0.tgz#80a4dd323748384bfa248083622aedec982adff3"
-  integrity sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=
-  dependencies:
-    mimic-response "^1.0.0"
-
-decompress-response@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/decompress-response/-/decompress-response-6.0.0.tgz#ca387612ddb7e104bd16d85aab00d5ecf09c66fc"
-  integrity sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==
-  dependencies:
-    mimic-response "^3.1.0"
-
-decompress-tar@^4.0.0, decompress-tar@^4.1.0, decompress-tar@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/decompress-tar/-/decompress-tar-4.1.1.tgz#718cbd3fcb16209716e70a26b84e7ba4592e5af1"
-  integrity sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==
-  dependencies:
-    file-type "^5.2.0"
-    is-stream "^1.1.0"
-    tar-stream "^1.5.2"
-
-decompress-tarbz2@^4.0.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz#3082a5b880ea4043816349f378b56c516be1a39b"
-  integrity sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==
-  dependencies:
-    decompress-tar "^4.1.0"
-    file-type "^6.1.0"
-    is-stream "^1.1.0"
-    seek-bzip "^1.0.5"
-    unbzip2-stream "^1.0.9"
-
-decompress-targz@^4.0.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/decompress-targz/-/decompress-targz-4.1.1.tgz#c09bc35c4d11f3de09f2d2da53e9de23e7ce1eee"
-  integrity sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==
-  dependencies:
-    decompress-tar "^4.1.1"
-    file-type "^5.2.0"
-    is-stream "^1.1.0"
-
-decompress-unzip@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/decompress-unzip/-/decompress-unzip-4.0.1.tgz#deaaccdfd14aeaf85578f733ae8210f9b4848f69"
-  integrity sha1-3qrM39FK6vhVePczroIQ+bSEj2k=
-  dependencies:
-    file-type "^3.8.0"
-    get-stream "^2.2.0"
-    pify "^2.3.0"
-    yauzl "^2.4.2"
-
-decompress@^4.2.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/decompress/-/decompress-4.2.1.tgz#007f55cc6a62c055afa37c07eb6a4ee1b773f118"
-  integrity sha512-e48kc2IjU+2Zw8cTb6VZcJQ3lgVbS4uuB1TfCHbiZIP/haNXm+SVyhu+87jts5/3ROpd82GSVCoNs/z8l4ZOaQ==
-  dependencies:
-    decompress-tar "^4.0.0"
-    decompress-tarbz2 "^4.0.0"
-    decompress-targz "^4.0.0"
-    decompress-unzip "^4.0.1"
-    graceful-fs "^4.1.10"
-    make-dir "^1.0.0"
-    pify "^2.3.0"
-    strip-dirs "^2.0.0"
-
-dedent@0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/dedent/-/dedent-0.7.0.tgz#2495ddbaf6eb874abb0e1be9df22d2e5a544326c"
-  integrity sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=
-
-deep-eql@4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-4.0.1.tgz#2b65bc89491d193780c452edee2144a91bb0a445"
-  integrity sha512-D/Oxqobjr+kxaHsgiQBZq9b6iAWdEj5W/JdJm8deNduAPc9CwXQ3BJJCuEqlrPXcy45iOMkGPZ0T81Dnz7UDCA==
-  dependencies:
-    type-detect "^4.0.0"
-
-deep-is@^0.1.3, deep-is@~0.1.3:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
-  integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==
-
-deepmerge@^4.0.0, deepmerge@^4.2.2:
-  version "4.2.2"
-  resolved "https://registry.yarnpkg.com/deepmerge/-/deepmerge-4.2.2.tgz#44d2ea3679b8f4d4ffba33f03d865fc1e7bf4955"
-  integrity sha512-FJ3UgI4gIl+PHZm53knsuSFpE+nESMr7M4v9QcgB7S63Kj/6WqMiFQJpBBYz1Pt+66bZpP3Q7Lye0Oo9MPKEdg==
-
-defaults@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/defaults/-/defaults-1.0.3.tgz#c656051e9817d9ff08ed881477f3fe4019f3ef7d"
-  integrity sha1-xlYFHpgX2f8I7YgUd/P+QBnz730=
-  dependencies:
-    clone "^1.0.2"
-
-defer-to-connect@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/defer-to-connect/-/defer-to-connect-2.0.1.tgz#8016bdb4143e4632b77a3449c6236277de520587"
-  integrity sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==
-
-define-properties@^1.1.3:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.4.tgz#0b14d7bd7fbeb2f3572c3a7eda80ea5d57fb05b1"
-  integrity sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA==
-  dependencies:
-    has-property-descriptors "^1.0.0"
-    object-keys "^1.1.1"
-
-del@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/del/-/del-6.0.0.tgz#0b40d0332cea743f1614f818be4feb717714c952"
-  integrity sha512-1shh9DQ23L16oXSZKB2JxpL7iMy2E0S9d517ptA1P8iw0alkPtQcrKH7ru31rYtKwF499HkTu+DRzq3TCKDFRQ==
-  dependencies:
-    globby "^11.0.1"
-    graceful-fs "^4.2.4"
-    is-glob "^4.0.1"
-    is-path-cwd "^2.2.0"
-    is-path-inside "^3.0.2"
-    p-map "^4.0.0"
-    rimraf "^3.0.2"
-    slash "^3.0.0"
-
-delayed-stream@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
-  integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
-
-depd@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df"
-  integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==
-
-des.js@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/des.js/-/des.js-1.0.1.tgz#5382142e1bdc53f85d86d53e5f4aa7deb91e0843"
-  integrity sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==
-  dependencies:
-    inherits "^2.0.1"
-    minimalistic-assert "^1.0.0"
-
-destroy@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/destroy/-/destroy-1.2.0.tgz#4803735509ad8be552934c67df614f94e66fa015"
-  integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==
-
-detect-file@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-1.0.0.tgz#f0d66d03672a825cb1b73bdb3fe62310c8e552b7"
-  integrity sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=
-
-detect-indent@6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-6.0.0.tgz#0abd0f549f69fc6659a254fe96786186b6f528fd"
-  integrity sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==
-
-detect-node@^2.0.4:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz#c9c70775a49c3d03bc2c06d9a73be550f978f8b1"
-  integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
-
-devtools-protocol@0.0.818844:
-  version "0.0.818844"
-  resolved "https://registry.yarnpkg.com/devtools-protocol/-/devtools-protocol-0.0.818844.tgz#d1947278ec85b53e4c8ca598f607a28fa785ba9e"
-  integrity sha512-AD1hi7iVJ8OD0aMLQU5VK0XH9LDlA1+BcPIgrAxPfaibx2DbWucuyOhc4oyQCbnvDDO68nN6/LcKfqTP343Jjg==
-
-devtools-protocol@0.0.981744:
-  version "0.0.981744"
-  resolved "https://registry.yarnpkg.com/devtools-protocol/-/devtools-protocol-0.0.981744.tgz#9960da0370284577d46c28979a0b32651022bacf"
-  integrity sha512-0cuGS8+jhR67Fy7qG3i3Pc7Aw494sb9yG9QgpG97SFVWwolgYjlhJg7n+UaHxOQT30d1TYu/EYe9k01ivLErIg==
-
-devtools@6.12.1:
-  version "6.12.1"
-  resolved "https://registry.yarnpkg.com/devtools/-/devtools-6.12.1.tgz#f0298c6d6f46d8d3b751dd8fa4a0c7bc76e1268f"
-  integrity sha512-JyG46suEiZmld7/UVeogkCWM0zYGt+2ML/TI+SkEp+bTv9cs46cDb0pKF3glYZJA7wVVL2gC07Ic0iCxyJEnCQ==
-  dependencies:
-    "@wdio/config" "6.12.1"
-    "@wdio/logger" "6.10.10"
-    "@wdio/protocols" "6.12.0"
-    "@wdio/utils" "6.11.0"
-    chrome-launcher "^0.13.1"
-    edge-paths "^2.1.0"
-    puppeteer-core "^5.1.0"
-    ua-parser-js "^0.7.21"
-    uuid "^8.0.0"
-
-di@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/di/-/di-0.0.1.tgz#806649326ceaa7caa3306d75d985ea2748ba913c"
-  integrity sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=
-
-didyoumean@1.2.2:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/didyoumean/-/didyoumean-1.2.2.tgz#989346ffe9e839b4555ecf5666edea0d3e8ad037"
-  integrity sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==
-
-diff@5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-5.0.0.tgz#7ed6ad76d859d030787ec35855f5b1daf31d852b"
-  integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==
-
-diff@^4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
-  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
-
-diffie-hellman@^5.0.0:
-  version "5.0.3"
-  resolved "https://registry.yarnpkg.com/diffie-hellman/-/diffie-hellman-5.0.3.tgz#40e8ee98f55a2149607146921c63e1ae5f3d2875"
-  integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==
-  dependencies:
-    bn.js "^4.1.0"
-    miller-rabin "^4.0.0"
-    randombytes "^2.0.0"
-
-dir-glob@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
-  integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==
-  dependencies:
-    path-type "^4.0.0"
-
-doctrine@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
-  integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==
-  dependencies:
-    esutils "^2.0.2"
-
-dom-serialize@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/dom-serialize/-/dom-serialize-2.2.1.tgz#562ae8999f44be5ea3076f5419dcd59eb43ac95b"
-  integrity sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=
-  dependencies:
-    custom-event "~1.0.0"
-    ent "~2.2.0"
-    extend "^3.0.0"
-    void-elements "^2.0.0"
-
-domain-browser@^4.16.0:
-  version "4.22.0"
-  resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-4.22.0.tgz#6ddd34220ec281f9a65d3386d267ddd35c491f9f"
-  integrity sha512-IGBwjF7tNk3cwypFNH/7bfzBcgSCbaMOD3GsaY1AU/JRrnHnYgEM0+9kQt52iZxjNsjBtJYtao146V+f8jFZNw==
-
-dot-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751"
-  integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==
-  dependencies:
-    no-case "^3.0.4"
-    tslib "^2.0.3"
-
-dot-prop@^5.1.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88"
-  integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==
-  dependencies:
-    is-obj "^2.0.0"
-
-dotenv@10.0.0:
-  version "10.0.0"
-  resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-10.0.0.tgz#3d4227b8fb95f81096cdd2b66653fb2c7085ba81"
-  integrity sha512-rlBi9d8jpv9Sf1klPjNfFAuWDjKLwTIJJ/VxtoTwIR6hnZxcEOQCZg2oIL3MWBYw5GpUDKOEnND7LXTbIpQ03Q==
-
-download@^7.1.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/download/-/download-7.1.0.tgz#9059aa9d70b503ee76a132897be6dec8e5587233"
-  integrity sha512-xqnBTVd/E+GxJVrX5/eUJiLYjCGPwMpdL+jGhGU57BvtcA7wwhtHVbXBeUk51kOpW3S7Jn3BQbN9Q1R1Km2qDQ==
-  dependencies:
-    archive-type "^4.0.0"
-    caw "^2.0.1"
-    content-disposition "^0.5.2"
-    decompress "^4.2.0"
-    ext-name "^5.0.0"
-    file-type "^8.1.0"
-    filenamify "^2.0.0"
-    get-stream "^3.0.0"
-    got "^8.3.1"
-    make-dir "^1.2.0"
-    p-event "^2.1.0"
-    pify "^3.0.0"
-
-duplexer3@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/duplexer3/-/duplexer3-0.1.4.tgz#ee01dd1cac0ed3cbc7fdbea37dc0a8f1ce002ce2"
-  integrity sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=
-
-eastasianwidth@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/eastasianwidth/-/eastasianwidth-0.2.0.tgz#696ce2ec0aa0e6ea93a397ffcf24aa7840c827cb"
-  integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==
-
-ecc-jsbn@~0.1.1:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9"
-  integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=
-  dependencies:
-    jsbn "~0.1.0"
-    safer-buffer "^2.1.0"
-
-edge-paths@^2.1.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/edge-paths/-/edge-paths-2.2.1.tgz#d2d91513225c06514aeac9843bfce546abbf4391"
-  integrity sha512-AI5fC7dfDmCdKo3m5y7PkYE8m6bMqR6pvVpgtrZkkhcJXFLelUgkjrhk3kXXx8Kbw2cRaTT4LkOR7hqf39KJdw==
-  dependencies:
-    "@types/which" "^1.3.2"
-    which "^2.0.2"
-
-ee-first@1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/ee-first/-/ee-first-1.1.1.tgz#590c61156b0ae2f4f0255732a158b266bc56b21d"
-  integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=
-
-electron-to-chromium@^1.4.118:
-  version "1.4.129"
-  resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.129.tgz#c675793885721beefff99da50f57c6525c2cd238"
-  integrity sha512-GgtN6bsDtHdtXJtlMYZWGB/uOyjZWjmRDumXTas7dGBaB9zUyCjzHet1DY2KhyHN8R0GLbzZWqm4efeddqqyRQ==
-
-elliptic@^6.5.3:
-  version "6.5.4"
-  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
-  integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
-  dependencies:
-    bn.js "^4.11.9"
-    brorand "^1.1.0"
-    hash.js "^1.0.0"
-    hmac-drbg "^1.0.1"
-    inherits "^2.0.4"
-    minimalistic-assert "^1.0.1"
-    minimalistic-crypto-utils "^1.0.1"
-
-emoji-regex@^8.0.0:
-  version "8.0.0"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
-  integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
-
-emoji-regex@^9.2.2:
-  version "9.2.2"
-  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
-  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
-
-emojis-list@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-3.0.0.tgz#5570662046ad29e2e916e71aae260abdff4f6a78"
-  integrity sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==
-
-encodeurl@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/encodeurl/-/encodeurl-1.0.2.tgz#ad3ff4c86ec2d029322f5a02c3a9a606c95b3f59"
-  integrity sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=
-
-end-of-stream@^1.0.0, end-of-stream@^1.1.0, end-of-stream@^1.4.1:
-  version "1.4.4"
-  resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-1.4.4.tgz#5ae64a5f45057baf3626ec14da0ca5e4b2431eb0"
-  integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==
-  dependencies:
-    once "^1.4.0"
-
-engine.io-parser@~5.0.3:
-  version "5.0.4"
-  resolved "https://registry.yarnpkg.com/engine.io-parser/-/engine.io-parser-5.0.4.tgz#0b13f704fa9271b3ec4f33112410d8f3f41d0fc0"
-  integrity sha512-+nVFp+5z1E3HcToEnO7ZIj3g+3k9389DvWtvJZz0T6/eOCPIyyxehFcedoYrZQrp0LgQbD9pPXhpMBKMd5QURg==
-
-engine.io@~6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/engine.io/-/engine.io-6.2.0.tgz#003bec48f6815926f2b1b17873e576acd54f41d0"
-  integrity sha512-4KzwW3F3bk+KlzSOY57fj/Jx6LyRQ1nbcyIadehl+AnXjKT7gDO0ORdRi/84ixvMKTym6ZKuxvbzN62HDDU1Lg==
-  dependencies:
-    "@types/cookie" "^0.4.1"
-    "@types/cors" "^2.8.12"
-    "@types/node" ">=10.0.0"
-    accepts "~1.3.4"
-    base64id "2.0.0"
-    cookie "~0.4.1"
-    cors "~2.8.5"
-    debug "~4.3.1"
-    engine.io-parser "~5.0.3"
-    ws "~8.2.3"
-
-enhanced-resolve@^5.0.0, enhanced-resolve@^5.9.2:
-  version "5.9.3"
-  resolved "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.9.3.tgz#44a342c012cbc473254af5cc6ae20ebd0aae5d88"
-  integrity sha512-Bq9VSor+kjvW3f9/MiiR4eE3XYgOl7/rS8lnSxbRbF3kS0B2r+Y9w5krBWxZgDxASVZbdYrn5wT4j/Wb0J9qow==
-  dependencies:
-    graceful-fs "^4.2.4"
-    tapable "^2.2.0"
-
-ent@~2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/ent/-/ent-2.2.0.tgz#e964219325a21d05f44466a2f686ed6ce5f5dd1d"
-  integrity sha1-6WQhkyWiHQX0RGai9obtbOX13R0=
-
-envinfo@7.8.1:
-  version "7.8.1"
-  resolved "https://registry.yarnpkg.com/envinfo/-/envinfo-7.8.1.tgz#06377e3e5f4d379fea7ac592d5ad8927e0c4d475"
-  integrity sha512-/o+BXHmB7ocbHEAs6F2EnG0ogybVVUdkRunTT2glZU9XAaGmhqskrvKwqXuDfNjEO0LZKWdejEEpnq8aM0tOaw==
-
-error-ex@^1.3.1:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
-  integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==
-  dependencies:
-    is-arrayish "^0.2.1"
-
-es-abstract@^1.18.5:
-  version "1.19.5"
-  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.19.5.tgz#a2cb01eb87f724e815b278b0dd0d00f36ca9a7f1"
-  integrity sha512-Aa2G2+Rd3b6kxEUKTF4TaW67czBLyAv3z7VOhYRU50YBx+bbsYZ9xQP4lMNazePuFlybXI0V4MruPos7qUo5fA==
-  dependencies:
-    call-bind "^1.0.2"
-    es-to-primitive "^1.2.1"
-    function-bind "^1.1.1"
-    get-intrinsic "^1.1.1"
-    get-symbol-description "^1.0.0"
-    has "^1.0.3"
-    has-symbols "^1.0.3"
-    internal-slot "^1.0.3"
-    is-callable "^1.2.4"
-    is-negative-zero "^2.0.2"
-    is-regex "^1.1.4"
-    is-shared-array-buffer "^1.0.2"
-    is-string "^1.0.7"
-    is-weakref "^1.0.2"
-    object-inspect "^1.12.0"
-    object-keys "^1.1.1"
-    object.assign "^4.1.2"
-    string.prototype.trimend "^1.0.4"
-    string.prototype.trimstart "^1.0.4"
-    unbox-primitive "^1.0.1"
-
-es-module-lexer@^0.9.0:
-  version "0.9.3"
-  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-0.9.3.tgz#6f13db00cc38417137daf74366f535c8eb438f19"
-  integrity sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==
-
-es-to-primitive@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.2.1.tgz#e55cd4c9cdc188bcefb03b366c736323fc5c898a"
-  integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==
-  dependencies:
-    is-callable "^1.1.4"
-    is-date-object "^1.0.1"
-    is-symbol "^1.0.2"
-
-es6-error@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"
-  integrity sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==
-
-es6-object-assign@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/es6-object-assign/-/es6-object-assign-1.1.0.tgz#c2c3582656247c39ea107cb1e6652b6f9f24523c"
-  integrity sha1-wsNYJlYkfDnqEHyx5mUrb58kUjw=
-
-es6-promise@^4.0.3, es6-promise@^4.2.8:
-  version "4.2.8"
-  resolved "https://registry.yarnpkg.com/es6-promise/-/es6-promise-4.2.8.tgz#4eb21594c972bc40553d276e510539143db53e0a"
-  integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==
-
-escalade@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
-  integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
-
-escape-html@~1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/escape-html/-/escape-html-1.0.3.tgz#0258eae4d3d0c0974de1c169188ef0051d1d1988"
-  integrity sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=
-
-escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34"
-  integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==
-
-escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
-  integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
-
-escodegen@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.0.0.tgz#5e32b12833e8aa8fa35e1bf0befa89380484c7dd"
-  integrity sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw==
-  dependencies:
-    esprima "^4.0.1"
-    estraverse "^5.2.0"
-    esutils "^2.0.2"
-    optionator "^0.8.1"
-  optionalDependencies:
-    source-map "~0.6.1"
-
-eslint-plugin-jasmine@^4.1.3:
-  version "4.1.3"
-  resolved "https://registry.yarnpkg.com/eslint-plugin-jasmine/-/eslint-plugin-jasmine-4.1.3.tgz#c4ced986a61dd5b180982bafe6da1cbac0941c52"
-  integrity sha512-q8j8KnLH/4uwmPELFZvEyfEcuCuGxXScJaRdqHjOjz064GcfX6aoFbzy5VohZ5QYk2+WvoqMoqDSb9nRLf89GQ==
-
-eslint-scope@5.1.1, eslint-scope@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
-  integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^4.1.1"
-
-eslint-scope@^7.1.1:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-7.1.1.tgz#fff34894c2f65e5226d3041ac480b4513a163642"
-  integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==
-  dependencies:
-    esrecurse "^4.3.0"
-    estraverse "^5.2.0"
-
-eslint-utils@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-3.0.0.tgz#8aebaface7345bb33559db0a1f13a1d2d48c3672"
-  integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==
-  dependencies:
-    eslint-visitor-keys "^2.0.0"
-
-eslint-visitor-keys@^1.0.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e"
-  integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==
-
-eslint-visitor-keys@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303"
-  integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==
-
-eslint-visitor-keys@^3.0.0, eslint-visitor-keys@^3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz#f6480fa6b1f30efe2d1968aa8ac745b862469826"
-  integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==
-
-eslint@^8.14.0:
-  version "8.14.0"
-  resolved "https://registry.yarnpkg.com/eslint/-/eslint-8.14.0.tgz#62741f159d9eb4a79695b28ec4989fcdec623239"
-  integrity sha512-3/CE4aJX7LNEiE3i6FeodHmI/38GZtWCsAtsymScmzYapx8q1nVVb+eLcLSzATmCPXw5pT4TqVs1E0OmxAd9tw==
-  dependencies:
-    "@eslint/eslintrc" "^1.2.2"
-    "@humanwhocodes/config-array" "^0.9.2"
-    ajv "^6.10.0"
-    chalk "^4.0.0"
-    cross-spawn "^7.0.2"
-    debug "^4.3.2"
-    doctrine "^3.0.0"
-    escape-string-regexp "^4.0.0"
-    eslint-scope "^7.1.1"
-    eslint-utils "^3.0.0"
-    eslint-visitor-keys "^3.3.0"
-    espree "^9.3.1"
-    esquery "^1.4.0"
-    esutils "^2.0.2"
-    fast-deep-equal "^3.1.3"
-    file-entry-cache "^6.0.1"
-    functional-red-black-tree "^1.0.1"
-    glob-parent "^6.0.1"
-    globals "^13.6.0"
-    ignore "^5.2.0"
-    import-fresh "^3.0.0"
-    imurmurhash "^0.1.4"
-    is-glob "^4.0.0"
-    js-yaml "^4.1.0"
-    json-stable-stringify-without-jsonify "^1.0.1"
-    levn "^0.4.1"
-    lodash.merge "^4.6.2"
-    minimatch "^3.0.4"
-    natural-compare "^1.4.0"
-    optionator "^0.9.1"
-    regexpp "^3.2.0"
-    strip-ansi "^6.0.1"
-    strip-json-comments "^3.1.0"
-    text-table "^0.2.0"
-    v8-compile-cache "^2.0.3"
-
-espree@^9.3.1:
-  version "9.3.1"
-  resolved "https://registry.yarnpkg.com/espree/-/espree-9.3.1.tgz#8793b4bc27ea4c778c19908e0719e7b8f4115bcd"
-  integrity sha512-bvdyLmJMfwkV3NCRl5ZhJf22zBFo1y8bYh3VYb+bfzqNB4Je68P2sSuXyuFquzWLebHpNd2/d5uv7yoP9ISnGQ==
-  dependencies:
-    acorn "^8.7.0"
-    acorn-jsx "^5.3.1"
-    eslint-visitor-keys "^3.3.0"
-
-esprima@^4.0.0, esprima@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
-  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
-
-esquery@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5"
-  integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==
-  dependencies:
-    estraverse "^5.1.0"
-
-esrecurse@^4.3.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921"
-  integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==
-  dependencies:
-    estraverse "^5.2.0"
-
-estraverse@^4.1.1:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
-  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
-
-estraverse@^5.1.0, estraverse@^5.2.0:
-  version "5.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
-  integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
-
-estree-walker@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-1.0.1.tgz#31bc5d612c96b704106b477e6dd5d8aa138cb700"
-  integrity sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==
-
-estree-walker@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac"
-  integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==
-
-esutils@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
-  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
-
-eventemitter3@^4.0.0:
-  version "4.0.7"
-  resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
-  integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
-
-events@^3.2.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400"
-  integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==
-
-evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02"
-  integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==
-  dependencies:
-    md5.js "^1.3.4"
-    safe-buffer "^5.1.1"
-
-execa@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-0.7.0.tgz#944becd34cc41ee32a63a9faf27ad5a65fc59777"
-  integrity sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=
-  dependencies:
-    cross-spawn "^5.0.1"
-    get-stream "^3.0.0"
-    is-stream "^1.1.0"
-    npm-run-path "^2.0.0"
-    p-finally "^1.0.0"
-    signal-exit "^3.0.0"
-    strip-eof "^1.0.0"
-
-execa@^0.8.0:
-  version "0.8.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-0.8.0.tgz#d8d76bbc1b55217ed190fd6dd49d3c774ecfc8da"
-  integrity sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=
-  dependencies:
-    cross-spawn "^5.0.1"
-    get-stream "^3.0.0"
-    is-stream "^1.1.0"
-    npm-run-path "^2.0.0"
-    p-finally "^1.0.0"
-    signal-exit "^3.0.0"
-    strip-eof "^1.0.0"
-
-execa@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-1.0.0.tgz#c6236a5bb4df6d6f15e88e7f017798216749ddd8"
-  integrity sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==
-  dependencies:
-    cross-spawn "^6.0.0"
-    get-stream "^4.0.0"
-    is-stream "^1.1.0"
-    npm-run-path "^2.0.0"
-    p-finally "^1.0.0"
-    signal-exit "^3.0.0"
-    strip-eof "^1.0.0"
-
-execa@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/execa/-/execa-5.1.1.tgz#f80ad9cbf4298f7bd1d4c9555c21e93741c411dd"
-  integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==
-  dependencies:
-    cross-spawn "^7.0.3"
-    get-stream "^6.0.0"
-    human-signals "^2.1.0"
-    is-stream "^2.0.0"
-    merge-stream "^2.0.0"
-    npm-run-path "^4.0.1"
-    onetime "^5.1.2"
-    signal-exit "^3.0.3"
-    strip-final-newline "^2.0.0"
-
-executable@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/executable/-/executable-4.1.1.tgz#41532bff361d3e57af4d763b70582db18f5d133c"
-  integrity sha512-8iA79xD3uAch729dUG8xaaBBFGaEa0wdD2VkYLFHwlqosEj/jT66AzcreRDSgV7ehnNLBW2WR5jIXwGKjVdTLg==
-  dependencies:
-    pify "^2.2.0"
-
-expand-tilde@^2.0.0, expand-tilde@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-2.0.2.tgz#97e801aa052df02454de46b02bf621642cdc8502"
-  integrity sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=
-  dependencies:
-    homedir-polyfill "^1.0.1"
-
-ext-list@^2.0.0:
-  version "2.2.2"
-  resolved "https://registry.yarnpkg.com/ext-list/-/ext-list-2.2.2.tgz#0b98e64ed82f5acf0f2931babf69212ef52ddd37"
-  integrity sha512-u+SQgsubraE6zItfVA0tBuCBhfU9ogSRnsvygI7wht9TS510oLkBRXBsqopeUG/GBOIQyKZO9wjTqIu/sf5zFA==
-  dependencies:
-    mime-db "^1.28.0"
-
-ext-name@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/ext-name/-/ext-name-5.0.0.tgz#70781981d183ee15d13993c8822045c506c8f0a6"
-  integrity sha512-yblEwXAbGv1VQDmow7s38W77hzAgJAO50ztBLMcUyUBfxv1HC+LGwtiEN+Co6LtlqT/5uwVOxsD4TNIilWhwdQ==
-  dependencies:
-    ext-list "^2.0.0"
-    sort-keys-length "^1.0.0"
-
-extend@^3.0.0, extend@~3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.2.tgz#f8b1136b4071fbd8eb140aff858b1019ec2915fa"
-  integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==
-
-external-editor@^3.0.3:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/external-editor/-/external-editor-3.1.0.tgz#cb03f740befae03ea4d283caed2741a83f335495"
-  integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==
-  dependencies:
-    chardet "^0.7.0"
-    iconv-lite "^0.4.24"
-    tmp "^0.0.33"
-
-extract-zip@2.0.1, extract-zip@^2.0.0, extract-zip@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-2.0.1.tgz#663dca56fe46df890d5f131ef4a06d22bb8ba13a"
-  integrity sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==
-  dependencies:
-    debug "^4.1.1"
-    get-stream "^5.1.0"
-    yauzl "^2.10.0"
-  optionalDependencies:
-    "@types/yauzl" "^2.9.1"
-
-extract-zip@^1.6.5:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-1.7.0.tgz#556cc3ae9df7f452c493a0cfb51cc30277940927"
-  integrity sha512-xoh5G1W/PB0/27lXgMQyIhP5DSY/LhoCsOyZgb+6iMmRtCwVBo55uKaMoEYrDCKQhWvqEip5ZPKAc6eFNyf/MA==
-  dependencies:
-    concat-stream "^1.6.2"
-    debug "^2.6.9"
-    mkdirp "^0.5.4"
-    yauzl "^2.10.0"
-
-extsprintf@1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05"
-  integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=
-
-extsprintf@^1.2.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.1.tgz#8d172c064867f235c0c84a596806d279bf4bcc07"
-  integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==
-
-fast-deep-equal@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz#7b05218ddf9667bf7f370bf7fdb2cb15fdd0aa49"
-  integrity sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=
-
-fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3:
-  version "3.1.3"
-  resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525"
-  integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==
-
-fast-glob@^3.2.9:
-  version "3.2.11"
-  resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.2.11.tgz#a1172ad95ceb8a16e20caa5c5e56480e5129c1d9"
-  integrity sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==
-  dependencies:
-    "@nodelib/fs.stat" "^2.0.2"
-    "@nodelib/fs.walk" "^1.2.3"
-    glob-parent "^5.1.2"
-    merge2 "^1.3.0"
-    micromatch "^4.0.4"
-
-fast-json-stable-stringify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633"
-  integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==
-
-fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-  integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
-
-fast-url-parser@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/fast-url-parser/-/fast-url-parser-1.1.3.tgz#f4af3ea9f34d8a271cf58ad2b3759f431f0b318d"
-  integrity sha1-9K8+qfNNiicc9YrSs3WfQx8LMY0=
-  dependencies:
-    punycode "^1.3.2"
-
-fastq@^1.6.0:
-  version "1.13.0"
-  resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.13.0.tgz#616760f88a7526bdfc596b7cab8c18938c36b98c"
-  integrity sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==
-  dependencies:
-    reusify "^1.0.4"
-
-fd-slicer@~1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/fd-slicer/-/fd-slicer-1.1.0.tgz#25c7c89cb1f9077f8891bbe61d8f390eae256f1e"
-  integrity sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=
-  dependencies:
-    pend "~1.2.0"
-
-figures@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/figures/-/figures-2.0.0.tgz#3ab1a2d2a62c8bfb431a0c94cb797a2fce27c962"
-  integrity sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=
-  dependencies:
-    escape-string-regexp "^1.0.5"
-
-file-entry-cache@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027"
-  integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==
-  dependencies:
-    flat-cache "^3.0.4"
-
-file-loader@^6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/file-loader/-/file-loader-6.2.0.tgz#baef7cf8e1840df325e4390b4484879480eebe4d"
-  integrity sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==
-  dependencies:
-    loader-utils "^2.0.0"
-    schema-utils "^3.0.0"
-
-file-type@^3.8.0:
-  version "3.9.0"
-  resolved "https://registry.yarnpkg.com/file-type/-/file-type-3.9.0.tgz#257a078384d1db8087bc449d107d52a52672b9e9"
-  integrity sha1-JXoHg4TR24CHvESdEH1SpSZyuek=
-
-file-type@^4.2.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/file-type/-/file-type-4.4.0.tgz#1b600e5fca1fbdc6e80c0a70c71c8dba5f7906c5"
-  integrity sha1-G2AOX8ofvcboDApwxxyNul95BsU=
-
-file-type@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/file-type/-/file-type-5.2.0.tgz#2ddbea7c73ffe36368dfae49dc338c058c2b8ad6"
-  integrity sha1-LdvqfHP/42No365J3DOMBYwritY=
-
-file-type@^6.1.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/file-type/-/file-type-6.2.0.tgz#e50cd75d356ffed4e306dc4f5bcf52a79903a919"
-  integrity sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==
-
-file-type@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/file-type/-/file-type-8.1.0.tgz#244f3b7ef641bbe0cca196c7276e4b332399f68c"
-  integrity sha512-qyQ0pzAy78gVoJsmYeNgl8uH8yKhr1lVhW7JbzJmnlRi0I4R2eEDEJZVKG8agpDnLpacwNbDhLNG/LMdxHD2YQ==
-
-filename-reserved-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/filename-reserved-regex/-/filename-reserved-regex-2.0.0.tgz#abf73dfab735d045440abfea2d91f389ebbfa229"
-  integrity sha1-q/c9+rc10EVECr/qLZHzieu/oik=
-
-filenamify@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/filenamify/-/filenamify-2.1.0.tgz#88faf495fb1b47abfd612300002a16228c677ee9"
-  integrity sha512-ICw7NTT6RsDp2rnYKVd8Fu4cr6ITzGy3+u4vUujPkabyaz+03F24NWEX7fs5fp+kBonlaqPH8fAO2NM+SXt/JA==
-  dependencies:
-    filename-reserved-regex "^2.0.0"
-    strip-outer "^1.0.0"
-    trim-repeated "^1.0.0"
-
-fill-range@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
-  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
-  dependencies:
-    to-regex-range "^5.0.1"
-
-finalhandler@1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/finalhandler/-/finalhandler-1.1.2.tgz#b7e7d000ffd11938d0fdb053506f6ebabe9f587d"
-  integrity sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==
-  dependencies:
-    debug "2.6.9"
-    encodeurl "~1.0.2"
-    escape-html "~1.0.3"
-    on-finished "~2.3.0"
-    parseurl "~1.3.3"
-    statuses "~1.5.0"
-    unpipe "~1.0.0"
-
-find-cache-dir@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-2.1.0.tgz#8d0f94cd13fe43c6c7c261a0d86115ca918c05f7"
-  integrity sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==
-  dependencies:
-    commondir "^1.0.1"
-    make-dir "^2.0.0"
-    pkg-dir "^3.0.0"
-
-find-cache-dir@^3.3.1, find-cache-dir@^3.3.2:
-  version "3.3.2"
-  resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-3.3.2.tgz#b30c5b6eff0730731aea9bbd9dbecbd80256d64b"
-  integrity sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==
-  dependencies:
-    commondir "^1.0.1"
-    make-dir "^3.0.2"
-    pkg-dir "^4.1.0"
-
-find-node-modules@^2.1.2:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/find-node-modules/-/find-node-modules-2.1.3.tgz#3c976cff2ca29ee94b4f9eafc613987fc4c0ee44"
-  integrity sha512-UC2I2+nx1ZuOBclWVNdcnbDR5dlrOdVb7xNjmT/lHE+LsgztWks3dG7boJ37yTS/venXw84B/mAW9uHVoC5QRg==
-  dependencies:
-    findup-sync "^4.0.0"
-    merge "^2.1.1"
-
-find-root@1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/find-root/-/find-root-1.1.0.tgz#abcfc8ba76f708c42a97b3d685b7e9450bfb9ce4"
-  integrity sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==
-
-find-up@5.0.0, find-up@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc"
-  integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==
-  dependencies:
-    locate-path "^6.0.0"
-    path-exists "^4.0.0"
-
-find-up@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7"
-  integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c=
-  dependencies:
-    locate-path "^2.0.0"
-
-find-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
-  integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
-  dependencies:
-    locate-path "^3.0.0"
-
-find-up@^4.0.0, find-up@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19"
-  integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==
-  dependencies:
-    locate-path "^5.0.0"
-    path-exists "^4.0.0"
-
-find-versions@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/find-versions/-/find-versions-3.2.0.tgz#10297f98030a786829681690545ef659ed1d254e"
-  integrity sha512-P8WRou2S+oe222TOCHitLy8zj+SIsVJh52VP4lvXkaFVnOFFdoWv1H1Jjvel1aI6NCFOAaeAVm8qrI0odiLcww==
-  dependencies:
-    semver-regex "^2.0.0"
-
-findup-sync@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-4.0.0.tgz#956c9cdde804052b881b428512905c4a5f2cdef0"
-  integrity sha512-6jvvn/12IC4quLBL1KNokxC7wWTvYncaVUYSoxWw7YykPLuRrnv4qdHcSOywOI5RpkOVGeQRtWM8/q+G6W6qfQ==
-  dependencies:
-    detect-file "^1.0.0"
-    is-glob "^4.0.0"
-    micromatch "^4.0.2"
-    resolve-dir "^1.0.1"
-
-flat-cache@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11"
-  integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==
-  dependencies:
-    flatted "^3.1.0"
-    rimraf "^3.0.2"
-
-flat@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241"
-  integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==
-
-flatted@^3.1.0, flatted@^3.2.5:
-  version "3.2.5"
-  resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.5.tgz#76c8584f4fc843db64702a6bd04ab7a8bd666da3"
-  integrity sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==
-
-follow-redirects@^1.0.0, follow-redirects@^1.14.4:
-  version "1.14.9"
-  resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.14.9.tgz#dd4ea157de7bfaf9ea9b3fbd85aa16951f78d8d7"
-  integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==
-
-foreach@^2.0.5:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
-  integrity sha1-C+4AUBiusmDQo6865ljdATbsG5k=
-
-forever-agent@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
-  integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=
-
-form-data@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.1.tgz#ebd53791b78356a99af9a300d4282c4d5eb9755f"
-  integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.8"
-    mime-types "^2.1.12"
-
-form-data@~2.3.2:
-  version "2.3.3"
-  resolved "https://registry.yarnpkg.com/form-data/-/form-data-2.3.3.tgz#dcce52c05f644f298c6a7ab936bd724ceffbf3a6"
-  integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==
-  dependencies:
-    asynckit "^0.4.0"
-    combined-stream "^1.0.6"
-    mime-types "^2.1.12"
-
-from2@^2.1.1:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/from2/-/from2-2.3.0.tgz#8bfb5502bde4a4d36cfdeea007fcca21d7e382af"
-  integrity sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=
-  dependencies:
-    inherits "^2.0.1"
-    readable-stream "^2.0.0"
-
-fs-constants@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs-constants/-/fs-constants-1.0.0.tgz#6be0de9be998ce16af8afc24497b9ee9b7ccd9ad"
-  integrity sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==
-
-fs-extra@8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-8.1.0.tgz#49d43c45a88cd9677668cb7be1b46efdb8d2e1c0"
-  integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==
-  dependencies:
-    graceful-fs "^4.2.0"
-    jsonfile "^4.0.0"
-    universalify "^0.1.0"
-
-fs-extra@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-1.0.0.tgz#cd3ce5f7e7cb6145883fcae3191e9877f8587950"
-  integrity sha1-zTzl9+fLYUWIP8rjGR6Yd/hYeVA=
-  dependencies:
-    graceful-fs "^4.1.2"
-    jsonfile "^2.1.0"
-    klaw "^1.0.0"
-
-fs-extra@^10.0.0, fs-extra@^10.1.0:
-  version "10.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf"
-  integrity sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==
-  dependencies:
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs-extra@^9.0.1:
-  version "9.1.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.1.0.tgz#5954460c764a8da2094ba3554bf839e6b9a7c86d"
-  integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^2.0.0"
-
-fs.realpath@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
-  integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
-
-fsevents@2.3.2, fsevents@~2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a"
-  integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==
-
-function-bind@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
-  integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
-
-functional-red-black-tree@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
-  integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=
-
-gensync@^1.0.0-beta.2:
-  version "1.0.0-beta.2"
-  resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
-  integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
-
-get-caller-file@^2.0.5:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
-  integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
-
-get-func-name@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/get-func-name/-/get-func-name-2.0.0.tgz#ead774abee72e20409433a066366023dd6887a41"
-  integrity sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=
-
-get-intrinsic@^1.0.2, get-intrinsic@^1.1.0, get-intrinsic@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.1.tgz#15f59f376f855c446963948f0d24cd3637b4abc6"
-  integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==
-  dependencies:
-    function-bind "^1.1.1"
-    has "^1.0.3"
-    has-symbols "^1.0.1"
-
-get-package-type@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/get-package-type/-/get-package-type-0.1.0.tgz#8de2d803cff44df3bc6c456e6668b36c3926e11a"
-  integrity sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==
-
-get-pkg-repo@^4.0.0:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/get-pkg-repo/-/get-pkg-repo-4.2.1.tgz#75973e1c8050c73f48190c52047c4cee3acbf385"
-  integrity sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==
-  dependencies:
-    "@hutson/parse-repository-url" "^3.0.0"
-    hosted-git-info "^4.0.0"
-    through2 "^2.0.0"
-    yargs "^16.2.0"
-
-get-port@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/get-port/-/get-port-5.1.1.tgz#0469ed07563479de6efb986baf053dcd7d4e3193"
-  integrity sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==
-
-get-proxy@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/get-proxy/-/get-proxy-2.1.0.tgz#349f2b4d91d44c4d4d4e9cba2ad90143fac5ef93"
-  integrity sha512-zmZIaQTWnNQb4R4fJUEp/FC51eZsc6EkErspy3xtIYStaq8EB/hDIWipxsal+E8rz0qD7f2sL/NA9Xee4RInJw==
-  dependencies:
-    npm-conf "^1.1.0"
-
-get-stream@3.0.0, get-stream@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-3.0.0.tgz#8e943d1358dc37555054ecbe2edb05aa174ede14"
-  integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=
-
-get-stream@^2.2.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-2.3.1.tgz#5f38f93f346009666ee0150a054167f91bdd95de"
-  integrity sha1-Xzj5PzRgCWZu4BUKBUFn+Rvdld4=
-  dependencies:
-    object-assign "^4.0.1"
-    pinkie-promise "^2.0.0"
-
-get-stream@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-4.1.0.tgz#c1b255575f3dc21d59bfc79cd3d2b46b1c3a54b5"
-  integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w==
-  dependencies:
-    pump "^3.0.0"
-
-get-stream@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-5.2.0.tgz#4966a1795ee5ace65e706c4b7beb71257d6e22d3"
-  integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==
-  dependencies:
-    pump "^3.0.0"
-
-get-stream@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/get-stream/-/get-stream-6.0.1.tgz#a262d8eef67aced57c2852ad6167526a43cbf7b7"
-  integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==
-
-get-symbol-description@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.0.tgz#7fdb81c900101fbd564dd5f1a30af5aadc1e58d6"
-  integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==
-  dependencies:
-    call-bind "^1.0.2"
-    get-intrinsic "^1.1.1"
-
-getpass@^0.1.1:
-  version "0.1.7"
-  resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa"
-  integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=
-  dependencies:
-    assert-plus "^1.0.0"
-
-git-raw-commits@^2.0.8:
-  version "2.0.11"
-  resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-2.0.11.tgz#bc3576638071d18655e1cc60d7f524920008d723"
-  integrity sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==
-  dependencies:
-    dargs "^7.0.0"
-    lodash "^4.17.15"
-    meow "^8.0.0"
-    split2 "^3.0.0"
-    through2 "^4.0.0"
-
-git-remote-origin-url@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz#5282659dae2107145a11126112ad3216ec5fa65f"
-  integrity sha1-UoJlna4hBxRaERJhEq0yFuxfpl8=
-  dependencies:
-    gitconfiglocal "^1.0.0"
-    pify "^2.3.0"
-
-git-semver-tags@^4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/git-semver-tags/-/git-semver-tags-4.1.1.tgz#63191bcd809b0ec3e151ba4751c16c444e5b5780"
-  integrity sha512-OWyMt5zBe7xFs8vglMmhM9lRQzCWL3WjHtxNNfJTMngGym7pC1kh8sP6jevfydJ6LP3ZvGxfb6ABYgPUM0mtsA==
-  dependencies:
-    meow "^8.0.0"
-    semver "^6.0.0"
-
-gitconfiglocal@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz#41d045f3851a5ea88f03f24ca1c6178114464b9b"
-  integrity sha1-QdBF84UaXqiPA/JMocYXgRRGS5s=
-  dependencies:
-    ini "^1.3.2"
-
-glob-parent@^5.1.2, glob-parent@~5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
-  integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==
-  dependencies:
-    is-glob "^4.0.1"
-
-glob-parent@^6.0.1:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-6.0.2.tgz#6d237d99083950c79290f24c7642a3de9a28f9e3"
-  integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==
-  dependencies:
-    is-glob "^4.0.3"
-
-glob-to-regexp@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e"
-  integrity sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==
-
-glob@7.1.4:
-  version "7.1.4"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.4.tgz#aa608a2f6c577ad357e1ae5a5c26d9a8d1969255"
-  integrity sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.4"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-glob@7.2.0, glob@^7.0.0, glob@^7.1.2, glob@^7.1.3, glob@^7.1.4, glob@^7.1.6, glob@^7.1.7:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.0.tgz#d15535af7732e02e948f4c41628bd910293f6023"
-  integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==
-  dependencies:
-    fs.realpath "^1.0.0"
-    inflight "^1.0.4"
-    inherits "2"
-    minimatch "^3.0.4"
-    once "^1.3.0"
-    path-is-absolute "^1.0.0"
-
-global-agent@^2.1.12:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/global-agent/-/global-agent-2.2.0.tgz#566331b0646e6bf79429a16877685c4a1fbf76dc"
-  integrity sha512-+20KpaW6DDLqhG7JDiJpD1JvNvb8ts+TNl7BPOYcURqCrXqnN1Vf+XVOrkKJAFPqfX+oEhsdzOj1hLWkBTdNJg==
-  dependencies:
-    boolean "^3.0.1"
-    core-js "^3.6.5"
-    es6-error "^4.1.1"
-    matcher "^3.0.0"
-    roarr "^2.15.3"
-    semver "^7.3.2"
-    serialize-error "^7.0.1"
-
-global-dirs@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/global-dirs/-/global-dirs-0.1.1.tgz#b319c0dd4607f353f3be9cca4c72fc148c49f445"
-  integrity sha1-sxnA3UYH81PzvpzKTHL8FIxJ9EU=
-  dependencies:
-    ini "^1.3.4"
-
-global-modules@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-1.0.0.tgz#6d770f0eb523ac78164d72b5e71a8877265cc3ea"
-  integrity sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==
-  dependencies:
-    global-prefix "^1.0.1"
-    is-windows "^1.0.1"
-    resolve-dir "^1.0.0"
-
-global-prefix@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-1.0.2.tgz#dbf743c6c14992593c655568cb66ed32c0122ebe"
-  integrity sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=
-  dependencies:
-    expand-tilde "^2.0.2"
-    homedir-polyfill "^1.0.1"
-    ini "^1.3.4"
-    is-windows "^1.0.1"
-    which "^1.2.14"
-
-globals@^11.1.0:
-  version "11.12.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
-  integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
-
-globals@^13.6.0, globals@^13.9.0:
-  version "13.13.0"
-  resolved "https://registry.yarnpkg.com/globals/-/globals-13.13.0.tgz#ac32261060d8070e2719dd6998406e27d2b5727b"
-  integrity sha512-EQ7Q18AJlPwp3vUDL4mKA0KXrXyNIQyWon6T6XQiBQF0XHvRsiCSrWmmeATpUzdJN2HhWZU6Pdl0a9zdep5p6A==
-  dependencies:
-    type-fest "^0.20.2"
-
-globalthis@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/globalthis/-/globalthis-1.0.2.tgz#2a235d34f4d8036219f7e34929b5de9e18166b8b"
-  integrity sha512-ZQnSFO1la8P7auIOQECnm0sSuoMeaSq0EEdXMBFF2QJO4uNcwbyhSgG3MruWNbFTqCLmxVwGOl7LZ9kASvHdeQ==
-  dependencies:
-    define-properties "^1.1.3"
-
-globby@^11.0.1, globby@^11.0.4:
-  version "11.1.0"
-  resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
-  integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
-  dependencies:
-    array-union "^2.1.0"
-    dir-glob "^3.0.1"
-    fast-glob "^3.2.9"
-    ignore "^5.2.0"
-    merge2 "^1.4.1"
-    slash "^3.0.0"
-
-got@^11.0.2, got@^11.7.0:
-  version "11.8.3"
-  resolved "https://registry.yarnpkg.com/got/-/got-11.8.3.tgz#f496c8fdda5d729a90b4905d2b07dbd148170770"
-  integrity sha512-7gtQ5KiPh1RtGS9/Jbv1ofDpBFuq42gyfEib+ejaRBJuj/3tQFeR5+gw57e4ipaU8c/rCjvX6fkQz2lyDlGAOg==
-  dependencies:
-    "@sindresorhus/is" "^4.0.0"
-    "@szmarczak/http-timer" "^4.0.5"
-    "@types/cacheable-request" "^6.0.1"
-    "@types/responselike" "^1.0.0"
-    cacheable-lookup "^5.0.3"
-    cacheable-request "^7.0.2"
-    decompress-response "^6.0.0"
-    http2-wrapper "^1.0.0-beta.5.2"
-    lowercase-keys "^2.0.0"
-    p-cancelable "^2.0.0"
-    responselike "^2.0.0"
-
-got@^8.3.1:
-  version "8.3.2"
-  resolved "https://registry.yarnpkg.com/got/-/got-8.3.2.tgz#1d23f64390e97f776cac52e5b936e5f514d2e937"
-  integrity sha512-qjUJ5U/hawxosMryILofZCkm3C84PLJS/0grRIpjAwu+Lkxxj5cxeCU25BG0/3mDSpXKTyZr8oh8wIgLaH0QCw==
-  dependencies:
-    "@sindresorhus/is" "^0.7.0"
-    cacheable-request "^2.1.1"
-    decompress-response "^3.3.0"
-    duplexer3 "^0.1.4"
-    get-stream "^3.0.0"
-    into-stream "^3.1.0"
-    is-retry-allowed "^1.1.0"
-    isurl "^1.0.0-alpha5"
-    lowercase-keys "^1.0.0"
-    mimic-response "^1.0.0"
-    p-cancelable "^0.4.0"
-    p-timeout "^2.0.1"
-    pify "^3.0.0"
-    safe-buffer "^5.1.1"
-    timed-out "^4.0.1"
-    url-parse-lax "^3.0.0"
-    url-to-options "^1.0.1"
-
-graceful-fs@^4.1.10, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0, graceful-fs@^4.2.4, graceful-fs@^4.2.6, graceful-fs@^4.2.9:
-  version "4.2.10"
-  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c"
-  integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==
-
-grapheme-splitter@^1.0.2:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz#9cf3a665c6247479896834af35cf1dbb4400767e"
-  integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==
-
-growl@1.10.5:
-  version "1.10.5"
-  resolved "https://registry.yarnpkg.com/growl/-/growl-1.10.5.tgz#f2735dc2283674fa67478b10181059355c369e5e"
-  integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==
-
-handlebars@^4.7.7:
-  version "4.7.7"
-  resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.7.tgz#9ce33416aad02dbd6c8fafa8240d5d98004945a1"
-  integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==
-  dependencies:
-    minimist "^1.2.5"
-    neo-async "^2.6.0"
-    source-map "^0.6.1"
-    wordwrap "^1.0.0"
-  optionalDependencies:
-    uglify-js "^3.1.4"
-
-har-schema@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92"
-  integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=
-
-har-validator@~5.1.3:
-  version "5.1.5"
-  resolved "https://registry.yarnpkg.com/har-validator/-/har-validator-5.1.5.tgz#1f0803b9f8cb20c0fa13822df1ecddb36bde1efd"
-  integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==
-  dependencies:
-    ajv "^6.12.3"
-    har-schema "^2.0.0"
-
-hard-rejection@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883"
-  integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==
-
-has-bigints@^1.0.1, has-bigints@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa"
-  integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==
-
-has-flag@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
-  integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
-
-has-flag@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b"
-  integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==
-
-has-property-descriptors@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861"
-  integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==
-  dependencies:
-    get-intrinsic "^1.1.1"
-
-has-symbol-support-x@^1.4.1:
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz#1409f98bc00247da45da67cee0a36f282ff26455"
-  integrity sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==
-
-has-symbols@^1.0.1, has-symbols@^1.0.2, has-symbols@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8"
-  integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==
-
-has-to-string-tag-x@^1.2.0:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz#a045ab383d7b4b2012a00148ab0aa5f290044d4d"
-  integrity sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==
-  dependencies:
-    has-symbol-support-x "^1.4.1"
-
-has-tostringtag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.0.tgz#7e133818a7d394734f941e73c3d3f9291e658b25"
-  integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==
-  dependencies:
-    has-symbols "^1.0.2"
-
-has@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796"
-  integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==
-  dependencies:
-    function-bind "^1.1.1"
-
-hash-base@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.1.0.tgz#55c381d9e06e1d2997a883b4a3fddfe7f0d3af33"
-  integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==
-  dependencies:
-    inherits "^2.0.4"
-    readable-stream "^3.6.0"
-    safe-buffer "^5.2.0"
-
-hash-sum@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/hash-sum/-/hash-sum-2.0.0.tgz#81d01bb5de8ea4a214ad5d6ead1b523460b0b45a"
-  integrity sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==
-
-hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
-  integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
-  dependencies:
-    inherits "^2.0.3"
-    minimalistic-assert "^1.0.1"
-
-hasha@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/hasha/-/hasha-2.2.0.tgz#78d7cbfc1e6d66303fe79837365984517b2f6ee1"
-  integrity sha1-eNfL/B5tZjA/55g3NlmEUXsvbuE=
-  dependencies:
-    is-stream "^1.0.1"
-    pinkie-promise "^2.0.0"
-
-he@1.2.0, he@^1.1.1, he@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
-  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
-
-header-case@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/header-case/-/header-case-2.0.4.tgz#5a42e63b55177349cf405beb8d775acabb92c063"
-  integrity sha512-H/vuk5TEEVZwrR0lp2zed9OCo1uAILMlx0JEMgC26rzyJJ3N1v6XkwHHXJQdR2doSjcGPM6OKPYoJgf0plJ11Q==
-  dependencies:
-    capital-case "^1.0.4"
-    tslib "^2.0.3"
-
-hmac-drbg@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
-  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
-  dependencies:
-    hash.js "^1.0.3"
-    minimalistic-assert "^1.0.0"
-    minimalistic-crypto-utils "^1.0.1"
-
-homedir-polyfill@^1.0.1:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz#743298cef4e5af3e194161fbadcc2151d3a058e8"
-  integrity sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==
-  dependencies:
-    parse-passwd "^1.0.0"
-
-hosted-git-info@^2.1.4:
-  version "2.8.9"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
-  integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==
-
-hosted-git-info@^4.0.0, hosted-git-info@^4.0.1:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224"
-  integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==
-  dependencies:
-    lru-cache "^6.0.0"
-
-html-encoding-sniffer@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-3.0.0.tgz#2cb1a8cf0db52414776e5b2a7a04d5dd98158de9"
-  integrity sha512-oWv4T4yJ52iKrufjnyZPkrN0CH3QnrUqdB6In1g5Fe1mia8GmF36gnfNySxoZtxD5+NmYw1EElVXiBk93UeskA==
-  dependencies:
-    whatwg-encoding "^2.0.0"
-
-html-escaper@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
-  integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
-
-http-cache-semantics@3.8.1:
-  version "3.8.1"
-  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-3.8.1.tgz#39b0e16add9b605bf0a9ef3d9daaf4843b4cacd2"
-  integrity sha512-5ai2iksyV8ZXmnZhHH4rWPoxxistEexSi5936zIQ1bnNTW5VnA85B6P/VpXiRM017IgRvb2kKo1a//y+0wSp3w==
-
-http-cache-semantics@^4.0.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz#49e91c5cbf36c9b94bcfcd71c23d5249ec74e390"
-  integrity sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ==
-
-http-errors@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-2.0.0.tgz#b7774a1486ef73cf7667ac9ae0858c012c57b9d3"
-  integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==
-  dependencies:
-    depd "2.0.0"
-    inherits "2.0.4"
-    setprototypeof "1.2.0"
-    statuses "2.0.1"
-    toidentifier "1.0.1"
-
-http-proxy-agent@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz#8a8c8ef7f5932ccf953c296ca8291b95aa74aa3a"
-  integrity sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==
-  dependencies:
-    "@tootallnate/once" "1"
-    agent-base "6"
-    debug "4"
-
-http-proxy@^1.18.1:
-  version "1.18.1"
-  resolved "https://registry.yarnpkg.com/http-proxy/-/http-proxy-1.18.1.tgz#401541f0534884bbf95260334e72f88ee3976549"
-  integrity sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==
-  dependencies:
-    eventemitter3 "^4.0.0"
-    follow-redirects "^1.0.0"
-    requires-port "^1.0.0"
-
-http-server@^14.1.0:
-  version "14.1.0"
-  resolved "https://registry.yarnpkg.com/http-server/-/http-server-14.1.0.tgz#51d43e03cdbb94f328b24821cad2cefc6c6a2eed"
-  integrity sha512-5lYsIcZtf6pdR8tCtzAHTWrAveo4liUlJdWc7YafwK/maPgYHs+VNP6KpCClmUnSorJrARVMXqtT055zBv11Yg==
-  dependencies:
-    basic-auth "^2.0.1"
-    chalk "^4.1.2"
-    corser "^2.0.1"
-    he "^1.2.0"
-    html-encoding-sniffer "^3.0.0"
-    http-proxy "^1.18.1"
-    mime "^1.6.0"
-    minimist "^1.2.5"
-    opener "^1.5.1"
-    portfinder "^1.0.28"
-    secure-compare "3.0.1"
-    union "~0.5.0"
-    url-join "^4.0.1"
-
-http-signature@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1"
-  integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=
-  dependencies:
-    assert-plus "^1.0.0"
-    jsprim "^1.2.2"
-    sshpk "^1.7.0"
-
-http2-wrapper@^1.0.0-beta.5.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/http2-wrapper/-/http2-wrapper-1.0.3.tgz#b8f55e0c1f25d4ebd08b3b0c2c079f9590800b3d"
-  integrity sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==
-  dependencies:
-    quick-lru "^5.1.1"
-    resolve-alpn "^1.0.0"
-
-https-browserify@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/https-browserify/-/https-browserify-1.0.0.tgz#ec06c10e0a34c0f2faf199f7fd7fc78fffd03c73"
-  integrity sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=
-
-https-proxy-agent@5.0.1, https-proxy-agent@^5.0.0:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz#c59ef224a04fe8b754f3db0063a25ea30d0005d6"
-  integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==
-  dependencies:
-    agent-base "6"
-    debug "4"
-
-https-proxy-agent@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-4.0.0.tgz#702b71fb5520a132a66de1f67541d9e62154d82b"
-  integrity sha512-zoDhWrkR3of1l9QAL8/scJZyLu8j/gBkcwcaQOZh7Gyh/+uJQzGVETdgT30akuwkpL8HTRfssqI3BZuV18teDg==
-  dependencies:
-    agent-base "5"
-    debug "4"
-
-human-signals@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/human-signals/-/human-signals-2.1.0.tgz#dc91fcba42e4d06e4abaed33b3e7a3c02f514ea0"
-  integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==
-
-iconv-lite@0.4.24, iconv-lite@^0.4.24:
-  version "0.4.24"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
-  integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3"
-
-iconv-lite@0.6.3:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.6.3.tgz#a52f80bf38da1952eb5c681790719871a1a72501"
-  integrity sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==
-  dependencies:
-    safer-buffer ">= 2.1.2 < 3.0.0"
-
-ieee754@^1.1.13:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352"
-  integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==
-
-ignore-walk@3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/ignore-walk/-/ignore-walk-3.0.4.tgz#c9a09f69b7c7b479a5d74ac1a3c0d4236d2a6335"
-  integrity sha512-PY6Ii8o1jMRA1z4F2hRkH/xN59ox43DavKvD3oDpfurRlOJyAHpifIwpbdv1n4jt4ov0jSpw3kQ4GhJnpBL6WQ==
-  dependencies:
-    minimatch "^3.0.4"
-
-ignore@^5.1.8, ignore@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.2.0.tgz#6d3bac8fa7fe0d45d9f9be7bac2fc279577e345a"
-  integrity sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==
-
-immediate@~3.0.5:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/immediate/-/immediate-3.0.6.tgz#9db1dbd0faf8de6fbe0f5dd5e56bb606280de69b"
-  integrity sha1-nbHb0Pr43m++D13V5Wu2BigN5ps=
-
-import-fresh@^3.0.0, import-fresh@^3.2.1:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
-  integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==
-  dependencies:
-    parent-module "^1.0.0"
-    resolve-from "^4.0.0"
-
-import-lazy@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/import-lazy/-/import-lazy-3.1.0.tgz#891279202c8a2280fdbd6674dbd8da1a1dfc67cc"
-  integrity sha512-8/gvXvX2JMn0F+CDlSC4l6kOmVaLOO3XLkksI7CI3Ud95KDYJuYur2b9P/PUt/i/pDAMd/DulQsNbbbmRRsDIQ==
-
-imurmurhash@^0.1.4:
-  version "0.1.4"
-  resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea"
-  integrity sha1-khi5srkoojixPcT7a21XbyMUU+o=
-
-indent-string@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
-  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
-
-inflight@^1.0.4:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
-  integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=
-  dependencies:
-    once "^1.3.0"
-    wrappy "1"
-
-inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.3, inherits@~2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
-  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
-
-ini@^1.3.2, ini@^1.3.4:
-  version "1.3.8"
-  resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
-  integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
-
-inline-source-map@~0.6.0:
-  version "0.6.2"
-  resolved "https://registry.yarnpkg.com/inline-source-map/-/inline-source-map-0.6.2.tgz#f9393471c18a79d1724f863fa38b586370ade2a5"
-  integrity sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=
-  dependencies:
-    source-map "~0.5.3"
-
-inquirer@6.5.2:
-  version "6.5.2"
-  resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-6.5.2.tgz#ad50942375d036d327ff528c08bd5fab089928ca"
-  integrity sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==
-  dependencies:
-    ansi-escapes "^3.2.0"
-    chalk "^2.4.2"
-    cli-cursor "^2.1.0"
-    cli-width "^2.0.0"
-    external-editor "^3.0.3"
-    figures "^2.0.0"
-    lodash "^4.17.12"
-    mute-stream "0.0.7"
-    run-async "^2.2.0"
-    rxjs "^6.4.0"
-    string-width "^2.1.0"
-    strip-ansi "^5.1.0"
-    through "^2.3.6"
-
-internal-slot@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.3.tgz#7347e307deeea2faac2ac6205d4bc7d34967f59c"
-  integrity sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==
-  dependencies:
-    get-intrinsic "^1.1.0"
-    has "^1.0.3"
-    side-channel "^1.0.4"
-
-interpret@^1.0.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
-  integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==
-
-into-stream@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/into-stream/-/into-stream-3.1.0.tgz#96fb0a936c12babd6ff1752a17d05616abd094c6"
-  integrity sha1-lvsKk2wSur1v8XUqF9BWFqvQlMY=
-  dependencies:
-    from2 "^2.1.1"
-    p-is-promise "^1.1.0"
-
-ip-regex@^4.1.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-4.3.0.tgz#687275ab0f57fa76978ff8f4dddc8a23d5990db5"
-  integrity sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==
-
-is-arguments@^1.0.4:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/is-arguments/-/is-arguments-1.1.1.tgz#15b3f88fda01f2a97fec84ca761a560f123efa9b"
-  integrity sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-arrayish@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
-  integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=
-
-is-bigint@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.4.tgz#08147a1875bc2b32005d41ccd8291dffc6691df3"
-  integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==
-  dependencies:
-    has-bigints "^1.0.1"
-
-is-binary-path@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
-  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
-  dependencies:
-    binary-extensions "^2.0.0"
-
-is-boolean-object@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.2.tgz#5c6dc200246dd9321ae4b885a114bb1f75f63719"
-  integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-builtin-module@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/is-builtin-module/-/is-builtin-module-3.1.0.tgz#6fdb24313b1c03b75f8b9711c0feb8c30b903b00"
-  integrity sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==
-  dependencies:
-    builtin-modules "^3.0.0"
-
-is-callable@^1.1.4, is-callable@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.4.tgz#47301d58dd0259407865547853df6d61fe471945"
-  integrity sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w==
-
-is-ci@^1.0.10:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/is-ci/-/is-ci-1.2.1.tgz#e3779c8ee17fccf428488f6e281187f2e632841c"
-  integrity sha512-s6tfsaQaQi3JNciBH6shVqEDvhGut0SUXr31ag8Pd8BBbVVlcGfWhpPmEOoM6RJ5TFhbypvf5yyRw/VXW1IiWg==
-  dependencies:
-    ci-info "^1.5.0"
-
-is-core-module@^2.5.0, is-core-module@^2.8.1:
-  version "2.9.0"
-  resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.9.0.tgz#e1c34429cd51c6dd9e09e0799e396e27b19a9c69"
-  integrity sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==
-  dependencies:
-    has "^1.0.3"
-
-is-date-object@^1.0.1:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f"
-  integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-docker@^2.0.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/is-docker/-/is-docker-2.2.1.tgz#33eeabe23cfe86f14bde4408a02c0cfb853acdaa"
-  integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==
-
-is-extglob@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
-  integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
-
-is-fullwidth-code-point@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f"
-  integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=
-
-is-fullwidth-code-point@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
-  integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
-
-is-fullwidth-code-point@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz#fae3167c729e7463f8461ce512b080a49268aa88"
-  integrity sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==
-
-is-generator-function@^1.0.7:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/is-generator-function/-/is-generator-function-1.0.10.tgz#f1558baf1ac17e0deea7c0415c438351ff2b3c72"
-  integrity sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084"
-  integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==
-  dependencies:
-    is-extglob "^2.1.1"
-
-is-interactive@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-interactive/-/is-interactive-1.0.0.tgz#cea6e6ae5c870a7b0a0004070b7b587e0252912e"
-  integrity sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==
-
-is-module@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-module/-/is-module-1.0.0.tgz#3258fb69f78c14d5b815d664336b4cffb6441591"
-  integrity sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=
-
-is-nan@^1.2.1:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/is-nan/-/is-nan-1.3.2.tgz#043a54adea31748b55b6cd4e09aadafa69bd9e1d"
-  integrity sha512-E+zBKpQ2t6MEo1VsonYmluk9NxGrbzpeeLC2xIViuO2EjU2xsXsBPwTr3Ykv9l08UYEVEdWeRZNouaZqF6RN0w==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-
-is-natural-number@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/is-natural-number/-/is-natural-number-4.0.1.tgz#ab9d76e1db4ced51e35de0c72ebecf09f734cde8"
-  integrity sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=
-
-is-negative-zero@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150"
-  integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==
-
-is-number-object@^1.0.4:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc"
-  integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-number@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
-  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
-
-is-obj@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982"
-  integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==
-
-is-object@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-object/-/is-object-1.0.2.tgz#a56552e1c665c9e950b4a025461da87e72f86fcf"
-  integrity sha512-2rRIahhZr2UWb45fIOuvZGpFtz0TyOZLf32KxBbSoUCeZR495zCKlWUKKUByk3geS2eAs7ZAABt0Y/Rx0GiQGA==
-
-is-path-cwd@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-2.2.0.tgz#67d43b82664a7b5191fd9119127eb300048a9fdb"
-  integrity sha512-w942bTcih8fdJPJmQHFzkS76NEP8Kzzvmw92cXsazb8intwLqPibPPdXf4ANdKV3rYMuuQYGIWtvz9JilB3NFQ==
-
-is-path-inside@^3.0.2:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-3.0.3.tgz#d231362e53a07ff2b0e0ea7fed049161ffd16283"
-  integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==
-
-is-plain-obj@^1.0.0, is-plain-obj@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e"
-  integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4=
-
-is-plain-obj@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-2.1.0.tgz#45e42e37fccf1f40da8e5f76ee21515840c09287"
-  integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==
-
-is-plain-object@^2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
-  integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
-  dependencies:
-    isobject "^3.0.1"
-
-is-reference@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/is-reference/-/is-reference-1.2.1.tgz#8b2dac0b371f4bc994fdeaba9eb542d03002d0b7"
-  integrity sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==
-  dependencies:
-    "@types/estree" "*"
-
-is-regex@^1.1.4:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958"
-  integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==
-  dependencies:
-    call-bind "^1.0.2"
-    has-tostringtag "^1.0.0"
-
-is-retry-allowed@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz#d778488bd0a4666a3be8a1482b9f2baafedea8b4"
-  integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg==
-
-is-shared-array-buffer@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz#8f259c573b60b6a32d4058a1a07430c0a7344c79"
-  integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==
-  dependencies:
-    call-bind "^1.0.2"
-
-is-stream@^1.0.1, is-stream@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44"
-  integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ=
-
-is-stream@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-2.0.1.tgz#fac1e3d53b97ad5a9d0ae9cef2389f5810a5c077"
-  integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==
-
-is-string@^1.0.5, is-string@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd"
-  integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==
-  dependencies:
-    has-tostringtag "^1.0.0"
-
-is-symbol@^1.0.2, is-symbol@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.4.tgz#a6dac93b635b063ca6872236de88910a57af139c"
-  integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==
-  dependencies:
-    has-symbols "^1.0.2"
-
-is-text-path@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e"
-  integrity sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4=
-  dependencies:
-    text-extensions "^1.0.0"
-
-is-typed-array@^1.1.3, is-typed-array@^1.1.7:
-  version "1.1.8"
-  resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.8.tgz#cbaa6585dc7db43318bc5b89523ea384a6f65e79"
-  integrity sha512-HqH41TNZq2fgtGT8WHVFVJhBVGuY3AnP3Q36K8JKXUxSxRgk/d+7NjmwG2vo2mYmXK8UYZKu0qH8bVP5gEisjA==
-  dependencies:
-    available-typed-arrays "^1.0.5"
-    call-bind "^1.0.2"
-    es-abstract "^1.18.5"
-    foreach "^2.0.5"
-    has-tostringtag "^1.0.0"
-
-is-typedarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
-  integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
-
-is-unicode-supported@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7"
-  integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==
-
-is-url@^1.2.4:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/is-url/-/is-url-1.2.4.tgz#04a4df46d28c4cff3d73d01ff06abeb318a1aa52"
-  integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==
-
-is-utf8@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
-  integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
-
-is-weakref@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.2.tgz#9529f383a9338205e89765e0392efc2f100f06f2"
-  integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==
-  dependencies:
-    call-bind "^1.0.2"
-
-is-windows@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-1.0.2.tgz#d1850eb9791ecd18e6182ce12a30f396634bb19d"
-  integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==
-
-is-wsl@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
-  integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==
-  dependencies:
-    is-docker "^2.0.0"
-
-is2@^2.0.6:
-  version "2.0.7"
-  resolved "https://registry.yarnpkg.com/is2/-/is2-2.0.7.tgz#d084e10cab3bd45d6c9dfde7a48599fcbb93fcac"
-  integrity sha512-4vBQoURAXC6hnLFxD4VW7uc04XiwTTl/8ydYJxKvPwkWQrSjInkuM5VZVg6BGr1/natq69zDuvO9lGpLClJqvA==
-  dependencies:
-    deep-is "^0.1.3"
-    ip-regex "^4.1.0"
-    is-url "^1.2.4"
-
-isarray@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
-  integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
-
-isbinaryfile@^4.0.8:
-  version "4.0.10"
-  resolved "https://registry.yarnpkg.com/isbinaryfile/-/isbinaryfile-4.0.10.tgz#0c5b5e30c2557a2f06febd37b7322946aaee42b3"
-  integrity sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==
-
-isexe@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10"
-  integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=
-
-isobject@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
-  integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
-
-isstream@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a"
-  integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=
-
-istanbul-lib-coverage@^3.0.0, istanbul-lib-coverage@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.0.tgz#189e7909d0a39fa5a3dfad5b03f71947770191d3"
-  integrity sha512-eOeJ5BHCmHYvQK7xt9GkdHuzuCGS1Y6g9Gvnx3Ym33fz/HpLRYxiS0wHNr+m/MBC8B647Xt608vCDEvhl9c6Mw==
-
-istanbul-lib-instrument@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-4.0.3.tgz#873c6fff897450118222774696a3f28902d77c1d"
-  integrity sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==
-  dependencies:
-    "@babel/core" "^7.7.5"
-    "@istanbuljs/schema" "^0.1.2"
-    istanbul-lib-coverage "^3.0.0"
-    semver "^6.3.0"
-
-istanbul-lib-instrument@^5.0.4, istanbul-lib-instrument@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.0.tgz#31d18bdd127f825dd02ea7bfdfd906f8ab840e9f"
-  integrity sha512-6Lthe1hqXHBNsqvgDzGO6l03XNeu3CrG4RqQ1KM9+l5+jNGpEJfIELx1NS3SEHmJQA8np/u+E4EPRKRiu6m19A==
-  dependencies:
-    "@babel/core" "^7.12.3"
-    "@babel/parser" "^7.14.7"
-    "@istanbuljs/schema" "^0.1.2"
-    istanbul-lib-coverage "^3.2.0"
-    semver "^6.3.0"
-
-istanbul-lib-report@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-report/-/istanbul-lib-report-3.0.0.tgz#7518fe52ea44de372f460a76b5ecda9ffb73d8a6"
-  integrity sha512-wcdi+uAKzfiGT2abPpKZ0hSU1rGQjUQnLvtY5MpQ7QCTahD3VODhcu4wcfY1YtkGaDD5yuydOLINXsfbus9ROw==
-  dependencies:
-    istanbul-lib-coverage "^3.0.0"
-    make-dir "^3.0.0"
-    supports-color "^7.1.0"
-
-istanbul-lib-source-maps@^4.0.0, istanbul-lib-source-maps@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz#895f3a709fcfba34c6de5a42939022f3e4358551"
-  integrity sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==
-  dependencies:
-    debug "^4.1.1"
-    istanbul-lib-coverage "^3.0.0"
-    source-map "^0.6.1"
-
-istanbul-reports@^3.0.0, istanbul-reports@^3.0.5:
-  version "3.1.4"
-  resolved "https://registry.yarnpkg.com/istanbul-reports/-/istanbul-reports-3.1.4.tgz#1b6f068ecbc6c331040aab5741991273e609e40c"
-  integrity sha512-r1/DshN4KSE7xWEknZLLLLDn5CJybV3nw01VTkp6D5jzLuELlcbudfj/eSQFvrKsJuTVCGnePO7ho82Nw9zzfw==
-  dependencies:
-    html-escaper "^2.0.0"
-    istanbul-lib-report "^3.0.0"
-
-isurl@^1.0.0-alpha5:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/isurl/-/isurl-1.0.0.tgz#b27f4f49f3cdaa3ea44a0a5b7f3462e6edc39d67"
-  integrity sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==
-  dependencies:
-    has-to-string-tag-x "^1.2.0"
-    is-object "^1.0.1"
-
-jasmine-core@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/jasmine-core/-/jasmine-core-4.1.0.tgz#2377349b0e8bfd3fbdb36c9e4f09e3b1a17cf5c2"
-  integrity sha512-8E8BiffCL8sBwK1zU9cbavLe8xpJAgOduSJ6N8PJVv8VosQ/nxVTuXj2kUeHxTlZBVvh24G19ga7xdiaxlceKg==
-
-jasmine-ts@^0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/jasmine-ts/-/jasmine-ts-0.4.0.tgz#b228c450cb70471344ce154c0e47d2f588f4a479"
-  integrity sha512-bIAWJKUwxfuZfGI1ctEbny7+dsyFzsN0eLzOokxh0qIUCofai2WUEKoe3MMllkGEBXJzbEVYr2IyhJBv4j7SBA==
-  dependencies:
-    yargs "^17.0.1"
-
-jasmine@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/jasmine/-/jasmine-4.1.0.tgz#0de347ca8bb6cc764b0ed186ae4cfc45bd64bdc4"
-  integrity sha512-4VhjbUgwfNS9CBnUMoSWr9tdNgOoOhNIjAD8YRxTn+PmOf4qTSC0Uqhk66dWGnz2vJxtNIU0uBjiwnsp4Ud9VA==
-  dependencies:
-    glob "^7.1.6"
-    jasmine-core "^4.1.0"
-
-jest-worker@^27.4.5:
-  version "27.5.1"
-  resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0"
-  integrity sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==
-  dependencies:
-    "@types/node" "*"
-    merge-stream "^2.0.0"
-    supports-color "^8.0.0"
-
-js-tokens@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
-  integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
-
-js-yaml@3.14.1, js-yaml@^3.13.1:
-  version "3.14.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537"
-  integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-js-yaml@4.1.0, js-yaml@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-4.1.0.tgz#c1fb65f8f5017901cdd2c951864ba18458a10602"
-  integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==
-  dependencies:
-    argparse "^2.0.1"
-
-jsbn@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
-  integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM=
-
-jsesc@^2.5.1:
-  version "2.5.2"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
-  integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
-
-jsesc@~0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d"
-  integrity sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=
-
-json-buffer@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.0.tgz#5b1f397afc75d677bde8bcfc0e47e1f9a3d9a898"
-  integrity sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg=
-
-json-buffer@3.0.1, json-buffer@~3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/json-buffer/-/json-buffer-3.0.1.tgz#9338802a30d3b6605fbe0613e094008ca8c05a13"
-  integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==
-
-json-parse-better-errors@^1.0.1, json-parse-better-errors@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz#bb867cfb3450e69107c131d1c514bab3dc8bcaa9"
-  integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==
-
-json-parse-even-better-errors@^2.3.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d"
-  integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==
-
-json-schema-traverse@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660"
-  integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==
-
-json-schema@0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.4.0.tgz#f7de4cf6efab838ebaeb3236474cbba5a1930ab5"
-  integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==
-
-json-stable-stringify-without-jsonify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651"
-  integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=
-
-json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
-  integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=
-
-json5@^2.1.2, json5@^2.2.1:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.1.tgz#655d50ed1e6f95ad1a3caababd2b0efda10b395c"
-  integrity sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA==
-
-jsonfile@^2.1.0:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-2.4.0.tgz#3736a2b428b87bbda0cc83b53fa3d633a35c2ae8"
-  integrity sha1-NzaitCi4e72gzIO1P6PWM6NcKug=
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonfile@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
-  integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonfile@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae"
-  integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==
-  dependencies:
-    universalify "^2.0.0"
-  optionalDependencies:
-    graceful-fs "^4.1.6"
-
-jsonparse@^1.2.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280"
-  integrity sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=
-
-jsprim@^1.2.2:
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.2.tgz#712c65533a15c878ba59e9ed5f0e26d5b77c5feb"
-  integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==
-  dependencies:
-    assert-plus "1.0.0"
-    extsprintf "1.3.0"
-    json-schema "0.4.0"
-    verror "1.10.0"
-
-jszip@^3.6.0:
-  version "3.9.1"
-  resolved "https://registry.yarnpkg.com/jszip/-/jszip-3.9.1.tgz#784e87f328450d1e8151003a9c67733e2b901051"
-  integrity sha512-H9A60xPqJ1CuC4Ka6qxzXZeU8aNmgOeP5IFqwJbQQwtu2EUYxota3LdsiZWplF7Wgd9tkAd0mdu36nceSaPuYw==
-  dependencies:
-    lie "~3.3.0"
-    pako "~1.0.2"
-    readable-stream "~2.3.6"
-    set-immediate-shim "~1.0.1"
-
-karma-chrome-launcher@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/karma-chrome-launcher/-/karma-chrome-launcher-3.1.1.tgz#baca9cc071b1562a1db241827257bfe5cab597ea"
-  integrity sha512-hsIglcq1vtboGPAN+DGCISCFOxW+ZVnIqhDQcCMqqCp+4dmJ0Qpq5QAjkbA0X2L9Mi6OBkHi2Srrbmm7pUKkzQ==
-  dependencies:
-    which "^1.2.1"
-
-karma-coverage@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/karma-coverage/-/karma-coverage-2.2.0.tgz#64f838b66b71327802e7f6f6c39d569b7024e40c"
-  integrity sha512-gPVdoZBNDZ08UCzdMHHhEImKrw1+PAOQOIiffv1YsvxFhBjqvo/SVXNk4tqn1SYqX0BJZT6S/59zgxiBe+9OuA==
-  dependencies:
-    istanbul-lib-coverage "^3.2.0"
-    istanbul-lib-instrument "^5.1.0"
-    istanbul-lib-report "^3.0.0"
-    istanbul-lib-source-maps "^4.0.1"
-    istanbul-reports "^3.0.5"
-    minimatch "^3.0.4"
-
-karma-firefox-launcher@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/karma-firefox-launcher/-/karma-firefox-launcher-2.1.2.tgz#9a38cc783c579a50f3ed2a82b7386186385cfc2d"
-  integrity sha512-VV9xDQU1QIboTrjtGVD4NCfzIH7n01ZXqy/qpBhnOeGVOkG5JYPEm8kuSd7psHE6WouZaQ9Ool92g8LFweSNMA==
-  dependencies:
-    is-wsl "^2.2.0"
-    which "^2.0.1"
-
-karma-jasmine@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/karma-jasmine/-/karma-jasmine-5.0.0.tgz#e270c86214b5390df77ebe1b6eaab79664d87d9f"
-  integrity sha512-dsFkCoTwyoNyQnMgegS72wIA/2xPDJG5yzTry0448U6lAY7P60Wgg4UuLlbdLv8YHbimgNpDXjjmfPdc99EDWQ==
-  dependencies:
-    jasmine-core "^4.1.0"
-
-karma-mocha-reporter@^2.2.3:
-  version "2.2.5"
-  resolved "https://registry.yarnpkg.com/karma-mocha-reporter/-/karma-mocha-reporter-2.2.5.tgz#15120095e8ed819186e47a0b012f3cd741895560"
-  integrity sha1-FRIAlejtgZGG5HoLAS8810GJVWA=
-  dependencies:
-    chalk "^2.1.0"
-    log-symbols "^2.1.0"
-    strip-ansi "^4.0.0"
-
-karma-phantomjs-launcher@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/karma-phantomjs-launcher/-/karma-phantomjs-launcher-1.0.4.tgz#d23ca34801bda9863ad318e3bb4bd4062b13acd2"
-  integrity sha1-0jyjSAG9qYY60xjju0vUBisTrNI=
-  dependencies:
-    lodash "^4.0.1"
-    phantomjs-prebuilt "^2.1.7"
-
-karma-safari-launcher@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/karma-safari-launcher/-/karma-safari-launcher-1.0.0.tgz#96982a2cc47d066aae71c553babb28319115a2ce"
-  integrity sha1-lpgqLMR9BmquccVTursoMZEVos4=
-
-karma-sauce-launcher@^4.3.6:
-  version "4.3.6"
-  resolved "https://registry.yarnpkg.com/karma-sauce-launcher/-/karma-sauce-launcher-4.3.6.tgz#274f999ce5a3bc76577a438839cb0dbbf2746a48"
-  integrity sha512-Ej62q4mUPFktyAm8g0g8J5qhwEkXwdHrwtiV4pZjKNHNnSs+4qgDyzs3VkpOy3AmNTsTqQXUN/lpiy0tZpDJZQ==
-  dependencies:
-    global-agent "^2.1.12"
-    saucelabs "^4.6.3"
-    webdriverio "^6.7.0"
-
-karma-sourcemap-loader@^0.3.8:
-  version "0.3.8"
-  resolved "https://registry.yarnpkg.com/karma-sourcemap-loader/-/karma-sourcemap-loader-0.3.8.tgz#d4bae72fb7a8397328a62b75013d2df937bdcf9c"
-  integrity sha512-zorxyAakYZuBcHRJE+vbrK2o2JXLFWK8VVjiT/6P+ltLBUGUvqTEkUiQ119MGdOrK7mrmxXHZF1/pfT6GgIZ6g==
-  dependencies:
-    graceful-fs "^4.1.2"
-
-karma-typescript-es6-transform@^5.5.3:
-  version "5.5.3"
-  resolved "https://registry.yarnpkg.com/karma-typescript-es6-transform/-/karma-typescript-es6-transform-5.5.3.tgz#5396da512c20b69d49e3e362a41f250342da5c03"
-  integrity sha512-vB1Cv8z9yxyR2KQuvks5soNKASyS2RPApdMsB3Ad55RqFJeag9G+xyGIwxOdyCHtgOwa4yn1rngMwaN7WBQTbQ==
-  dependencies:
-    "@babel/core" "^7.11.1"
-    "@babel/preset-env" "^7.11.0"
-    acorn "^8.1.0"
-    acorn-walk "^8.0.2"
-    log4js "^6.3.0"
-    magic-string "^0.25.7"
-
-karma-typescript@^5.5.3:
-  version "5.5.3"
-  resolved "https://registry.yarnpkg.com/karma-typescript/-/karma-typescript-5.5.3.tgz#29c04d9677f8bd78dfacd89e8fa6f475dd25aba2"
-  integrity sha512-l1FHurolXEBIzRa9ExpNtjzysAhsi/vLpTazpwLHWWK86mknvVpqor6pRZ5Nid7jvOPrTBqAq0JRuLgiCdRkFw==
-  dependencies:
-    acorn "^8.1.0"
-    acorn-walk "^8.0.2"
-    assert "^2.0.0"
-    async "^3.0.1"
-    browser-resolve "^2.0.0"
-    browserify-zlib "^0.2.0"
-    buffer "^5.4.3"
-    combine-source-map "^0.8.0"
-    console-browserify "^1.2.0"
-    constants-browserify "^1.0.0"
-    convert-source-map "^1.7.0"
-    crypto-browserify "^3.12.0"
-    diff "^4.0.1"
-    domain-browser "^4.16.0"
-    events "^3.2.0"
-    glob "^7.1.6"
-    https-browserify "^1.0.0"
-    istanbul-lib-coverage "^3.0.0"
-    istanbul-lib-instrument "^4.0.0"
-    istanbul-lib-report "^3.0.0"
-    istanbul-lib-source-maps "^4.0.0"
-    istanbul-reports "^3.0.0"
-    json-stringify-safe "^5.0.1"
-    lodash "^4.17.19"
-    log4js "^6.3.0"
-    minimatch "^3.0.4"
-    os-browserify "^0.3.0"
-    pad "^3.2.0"
-    path-browserify "^1.0.0"
-    process "^0.11.10"
-    punycode "^2.1.1"
-    querystring-es3 "^0.2.1"
-    readable-stream "^3.1.1"
-    source-map "^0.7.3"
-    stream-browserify "^3.0.0"
-    stream-http "^3.1.0"
-    string_decoder "^1.3.0"
-    timers-browserify "^2.0.11"
-    tmp "^0.2.1"
-    tty-browserify "^0.0.1"
-    url "^0.11.0"
-    util "^0.12.1"
-    vm-browserify "^1.1.2"
-
-karma-webpack@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/karma-webpack/-/karma-webpack-5.0.0.tgz#2a2c7b80163fe7ffd1010f83f5507f95ef39f840"
-  integrity sha512-+54i/cd3/piZuP3dr54+NcFeKOPnys5QeM1IY+0SPASwrtHsliXUiCL50iW+K9WWA7RvamC4macvvQ86l3KtaA==
-  dependencies:
-    glob "^7.1.3"
-    minimatch "^3.0.4"
-    webpack-merge "^4.1.5"
-
-karma@^6.3.19:
-  version "6.3.19"
-  resolved "https://registry.yarnpkg.com/karma/-/karma-6.3.19.tgz#e50759667b0b9c6ad758655db0547d3ab4d2abf5"
-  integrity sha512-NDhWckzES/Y9xMiddyU1RzaKL76/scCsu8Mp0vR0Z3lQRvC3p72+Ab4ppoxs36S9tyPNX5V48yvaV++RNEBPZw==
-  dependencies:
-    "@colors/colors" "1.5.0"
-    body-parser "^1.19.0"
-    braces "^3.0.2"
-    chokidar "^3.5.1"
-    connect "^3.7.0"
-    di "^0.0.1"
-    dom-serialize "^2.2.1"
-    glob "^7.1.7"
-    graceful-fs "^4.2.6"
-    http-proxy "^1.18.1"
-    isbinaryfile "^4.0.8"
-    lodash "^4.17.21"
-    log4js "^6.4.1"
-    mime "^2.5.2"
-    minimatch "^3.0.4"
-    mkdirp "^0.5.5"
-    qjobs "^1.2.0"
-    range-parser "^1.2.1"
-    rimraf "^3.0.2"
-    socket.io "^4.4.1"
-    source-map "^0.6.1"
-    tmp "^0.2.1"
-    ua-parser-js "^0.7.30"
-    yargs "^16.1.1"
-
-kew@^0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/kew/-/kew-0.7.0.tgz#79d93d2d33363d6fdd2970b335d9141ad591d79b"
-  integrity sha1-edk9LTM2PW/dKXCzNdkUGtWR15s=
-
-keyv@3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/keyv/-/keyv-3.0.0.tgz#44923ba39e68b12a7cec7df6c3268c031f2ef373"
-  integrity sha512-eguHnq22OE3uVoSYG0LVWNP+4ppamWr9+zWBe1bsNcovIMy6huUJFPgy4mGwCd/rnl3vOLGW1MTlu4c57CT1xA==
-  dependencies:
-    json-buffer "3.0.0"
-
-keyv@^4.0.0:
-  version "4.2.2"
-  resolved "https://registry.yarnpkg.com/keyv/-/keyv-4.2.2.tgz#4b6f602c0228ef4d8214c03c520bef469ed6b768"
-  integrity sha512-uYS0vKTlBIjNCAUqrjlxmruxOEiZxZIHXyp32sdcGmP+ukFrmWUnE//RcPXJH3Vxrni1H2gsQbjHE0bH7MtMQQ==
-  dependencies:
-    compress-brotli "^1.3.6"
-    json-buffer "3.0.1"
-
-kind-of@^6.0.2, kind-of@^6.0.3:
-  version "6.0.3"
-  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
-  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
-
-klaw@^1.0.0:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/klaw/-/klaw-1.3.1.tgz#4088433b46b3b1ba259d78785d8e96f73ba02439"
-  integrity sha1-QIhDO0azsbolnXh4XY6W9zugJDk=
-  optionalDependencies:
-    graceful-fs "^4.1.9"
-
-lazystream@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/lazystream/-/lazystream-1.0.1.tgz#494c831062f1f9408251ec44db1cba29242a2638"
-  integrity sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==
-  dependencies:
-    readable-stream "^2.0.5"
-
-levn@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.4.1.tgz#ae4562c007473b932a6200d403268dd2fffc6ade"
-  integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==
-  dependencies:
-    prelude-ls "^1.2.1"
-    type-check "~0.4.0"
-
-levn@~0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
-  integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=
-  dependencies:
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-
-lie@~3.3.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/lie/-/lie-3.3.0.tgz#dcf82dee545f46074daf200c7c1c5a08e0f40f6a"
-  integrity sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==
-  dependencies:
-    immediate "~3.0.5"
-
-lighthouse-logger@^1.0.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/lighthouse-logger/-/lighthouse-logger-1.3.0.tgz#ba6303e739307c4eee18f08249524e7dafd510db"
-  integrity sha512-BbqAKApLb9ywUli+0a+PcV04SyJ/N1q/8qgCNe6U97KbPCS1BTksEuHFLYdvc8DltuhfxIUBqDZsC0bBGtl3lA==
-  dependencies:
-    debug "^2.6.9"
-    marky "^1.2.2"
-
-lilconfig@2.0.4:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/lilconfig/-/lilconfig-2.0.4.tgz#f4507d043d7058b380b6a8f5cb7bcd4b34cee082"
-  integrity sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA==
-
-lines-and-columns@^1.1.6:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632"
-  integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==
-
-lint-staged@^12.4.1:
-  version "12.4.1"
-  resolved "https://registry.yarnpkg.com/lint-staged/-/lint-staged-12.4.1.tgz#63fa27bfc8a33515f6902f63f6670864f1fb233c"
-  integrity sha512-PTXgzpflrQ+pODQTG116QNB+Q6uUTDg5B5HqGvNhoQSGt8Qy+MA/6zSnR8n38+sxP5TapzeQGTvoKni0KRS8Vg==
-  dependencies:
-    cli-truncate "^3.1.0"
-    colorette "^2.0.16"
-    commander "^8.3.0"
-    debug "^4.3.3"
-    execa "^5.1.1"
-    lilconfig "2.0.4"
-    listr2 "^4.0.1"
-    micromatch "^4.0.4"
-    normalize-path "^3.0.0"
-    object-inspect "^1.12.0"
-    pidtree "^0.5.0"
-    string-argv "^0.3.1"
-    supports-color "^9.2.1"
-    yaml "^1.10.2"
-
-listr2@^4.0.1:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/listr2/-/listr2-4.0.5.tgz#9dcc50221583e8b4c71c43f9c7dfd0ef546b75d5"
-  integrity sha512-juGHV1doQdpNT3GSTs9IUN43QJb7KHdF9uqg7Vufs/tG9VTzpFphqF4pm/ICdAABGQxsyNn9CiYA3StkI6jpwA==
-  dependencies:
-    cli-truncate "^2.1.0"
-    colorette "^2.0.16"
-    log-update "^4.0.0"
-    p-map "^4.0.0"
-    rfdc "^1.3.0"
-    rxjs "^7.5.5"
-    through "^2.3.8"
-    wrap-ansi "^7.0.0"
-
-load-json-file@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b"
-  integrity sha1-L19Fq5HjMhYjT9U62rZo607AmTs=
-  dependencies:
-    graceful-fs "^4.1.2"
-    parse-json "^4.0.0"
-    pify "^3.0.0"
-    strip-bom "^3.0.0"
-
-loader-runner@^4.2.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1"
-  integrity sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==
-
-loader-utils@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/loader-utils/-/loader-utils-2.0.2.tgz#d6e3b4fb81870721ae4e0868ab11dd638368c129"
-  integrity sha512-TM57VeHptv569d/GKh6TAYdzKblwDNiumOdkFnejjD0XwTH87K90w3O7AiJRqdQoXygvi1VQTJTLGhJl7WqA7A==
-  dependencies:
-    big.js "^5.2.2"
-    emojis-list "^3.0.0"
-    json5 "^2.1.2"
-
-locate-path@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e"
-  integrity sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=
-  dependencies:
-    p-locate "^2.0.0"
-    path-exists "^3.0.0"
-
-locate-path@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
-  integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
-  dependencies:
-    p-locate "^3.0.0"
-    path-exists "^3.0.0"
-
-locate-path@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0"
-  integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==
-  dependencies:
-    p-locate "^4.1.0"
-
-locate-path@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286"
-  integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==
-  dependencies:
-    p-locate "^5.0.0"
-
-lodash._arraycopy@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._arraycopy/-/lodash._arraycopy-3.0.0.tgz#76e7b7c1f1fb92547374878a562ed06a3e50f6e1"
-  integrity sha1-due3wfH7klRzdIeKVi7Qaj5Q9uE=
-
-lodash._arrayeach@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._arrayeach/-/lodash._arrayeach-3.0.0.tgz#bab156b2a90d3f1bbd5c653403349e5e5933ef9e"
-  integrity sha1-urFWsqkNPxu9XGU0AzSeXlkz754=
-
-lodash._baseassign@^3.0.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/lodash._baseassign/-/lodash._baseassign-3.2.0.tgz#8c38a099500f215ad09e59f1722fd0c52bfe0a4e"
-  integrity sha1-jDigmVAPIVrQnlnxci/QxSv+Ck4=
-  dependencies:
-    lodash._basecopy "^3.0.0"
-    lodash.keys "^3.0.0"
-
-lodash._baseclone@^3.0.0:
-  version "3.3.0"
-  resolved "https://registry.yarnpkg.com/lodash._baseclone/-/lodash._baseclone-3.3.0.tgz#303519bf6393fe7e42f34d8b630ef7794e3542b7"
-  integrity sha1-MDUZv2OT/n5C802LYw73eU41Qrc=
-  dependencies:
-    lodash._arraycopy "^3.0.0"
-    lodash._arrayeach "^3.0.0"
-    lodash._baseassign "^3.0.0"
-    lodash._basefor "^3.0.0"
-    lodash.isarray "^3.0.0"
-    lodash.keys "^3.0.0"
-
-lodash._basecopy@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz#8da0e6a876cf344c0ad8a54882111dd3c5c7ca36"
-  integrity sha1-jaDmqHbPNEwK2KVIghEd08XHyjY=
-
-lodash._basefor@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/lodash._basefor/-/lodash._basefor-3.0.3.tgz#7550b4e9218ef09fad24343b612021c79b4c20c2"
-  integrity sha1-dVC06SGO8J+tJDQ7YSAhx5tMIMI=
-
-lodash._bindcallback@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/lodash._bindcallback/-/lodash._bindcallback-3.0.1.tgz#e531c27644cf8b57a99e17ed95b35c748789392e"
-  integrity sha1-5THCdkTPi1epnhftlbNcdIeJOS4=
-
-lodash._getnative@^3.0.0:
-  version "3.9.1"
-  resolved "https://registry.yarnpkg.com/lodash._getnative/-/lodash._getnative-3.9.1.tgz#570bc7dede46d61cdcde687d65d3eecbaa3aaff5"
-  integrity sha1-VwvH3t5G1hzc3mh9ZdPuy6o6r/U=
-
-lodash._isiterateecall@^3.0.0:
-  version "3.0.9"
-  resolved "https://registry.yarnpkg.com/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz#5203ad7ba425fae842460e696db9cf3e6aac057c"
-  integrity sha1-UgOte6Ql+uhCRg5pbbnPPmqsBXw=
-
-lodash._reinterpolate@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d"
-  integrity sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=
-
-lodash.clone@3.0.3:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/lodash.clone/-/lodash.clone-3.0.3.tgz#84688c73d32b5a90ca25616963f189252a997043"
-  integrity sha1-hGiMc9MrWpDKJWFpY/GJJSqZcEM=
-  dependencies:
-    lodash._baseclone "^3.0.0"
-    lodash._bindcallback "^3.0.0"
-    lodash._isiterateecall "^3.0.0"
-
-lodash.clonedeep@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz#e23f3f9c4f8fbdde872529c1071857a086e5ccef"
-  integrity sha1-4j8/nE+Pvd6HJSnBBxhXoIblzO8=
-
-lodash.debounce@^4.0.8:
-  version "4.0.8"
-  resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
-  integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168=
-
-lodash.defaults@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.defaults/-/lodash.defaults-4.2.0.tgz#d09178716ffea4dde9e5fb7b37f6f0802274580c"
-  integrity sha1-0JF4cW/+pN3p5ft7N/bwgCJ0WAw=
-
-lodash.defaultsdeep@4.6.1:
-  version "4.6.1"
-  resolved "https://registry.yarnpkg.com/lodash.defaultsdeep/-/lodash.defaultsdeep-4.6.1.tgz#512e9bd721d272d94e3d3a63653fa17516741ca6"
-  integrity sha512-3j8wdDzYuWO3lM3Reg03MuQR957t287Rpcxp1njpEa8oDrikb+FwGdW3n+FELh/A6qib6yPit0j/pv9G/yeAqA==
-
-lodash.difference@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.difference/-/lodash.difference-4.5.0.tgz#9ccb4e505d486b91651345772885a2df27fd017c"
-  integrity sha1-nMtOUF1Ia5FlE0V3KIWi3yf9AXw=
-
-lodash.flatten@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.flatten/-/lodash.flatten-4.4.0.tgz#f31c22225a9632d2bbf8e4addbef240aa765a61f"
-  integrity sha1-8xwiIlqWMtK7+OSt2+8kCqdlph8=
-
-lodash.isarguments@^3.0.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz#2f573d85c6a24289ff00663b491c1d338ff3458a"
-  integrity sha1-L1c9hcaiQon/AGY7SRwdM4/zRYo=
-
-lodash.isarray@^3.0.0:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/lodash.isarray/-/lodash.isarray-3.0.4.tgz#79e4eb88c36a8122af86f844aa9bcd851b5fbb55"
-  integrity sha1-eeTriMNqgSKvhvhEqpvNhRtfu1U=
-
-lodash.ismatch@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.ismatch/-/lodash.ismatch-4.4.0.tgz#756cb5150ca3ba6f11085a78849645f188f85f37"
-  integrity sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc=
-
-lodash.isobject@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/lodash.isobject/-/lodash.isobject-3.0.2.tgz#3c8fb8d5b5bf4bf90ae06e14f2a530a4ed935e1d"
-  integrity sha1-PI+41bW/S/kK4G4U8qUwpO2TXh0=
-
-lodash.isplainobject@^4.0.6:
-  version "4.0.6"
-  resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb"
-  integrity sha1-fFJqUtibRcRcxpC4gWO+BJf1UMs=
-
-lodash.keys@^3.0.0:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/lodash.keys/-/lodash.keys-3.1.2.tgz#4dbc0472b156be50a0b286855d1bd0b0c656098a"
-  integrity sha1-TbwEcrFWvlCgsoaFXRvQsMZWCYo=
-  dependencies:
-    lodash._getnative "^3.0.0"
-    lodash.isarguments "^3.0.0"
-    lodash.isarray "^3.0.0"
-
-lodash.map@^4.5.1:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/lodash.map/-/lodash.map-4.6.0.tgz#771ec7839e3473d9c4cde28b19394c3562f4f6d3"
-  integrity sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=
-
-lodash.memoize@~3.0.3:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-3.0.4.tgz#2dcbd2c287cbc0a55cc42328bd0c736150d53e3f"
-  integrity sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=
-
-lodash.merge@4.6.2, lodash.merge@^4.6.1, lodash.merge@^4.6.2:
-  version "4.6.2"
-  resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a"
-  integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==
-
-lodash.sortby@^4.7.0:
-  version "4.7.0"
-  resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438"
-  integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=
-
-lodash.template@^4.4.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.template/-/lodash.template-4.5.0.tgz#f976195cf3f347d0d5f52483569fe8031ccce8ab"
-  integrity sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==
-  dependencies:
-    lodash._reinterpolate "^3.0.0"
-    lodash.templatesettings "^4.0.0"
-
-lodash.templatesettings@^4.0.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz#e481310f049d3cf6d47e912ad09313b154f0fb33"
-  integrity sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==
-  dependencies:
-    lodash._reinterpolate "^3.0.0"
-
-lodash.union@^4.6.0:
-  version "4.6.0"
-  resolved "https://registry.yarnpkg.com/lodash.union/-/lodash.union-4.6.0.tgz#48bb5088409f16f1821666641c44dd1aaae3cd88"
-  integrity sha1-SLtQiECfFvGCFmZkHETdGqrjzYg=
-
-lodash.uniq@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.uniq/-/lodash.uniq-4.5.0.tgz#d0225373aeb652adc1bc82e4945339a842754773"
-  integrity sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=
-
-lodash.zip@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/lodash.zip/-/lodash.zip-4.2.0.tgz#ec6662e4896408ed4ab6c542a3990b72cc080020"
-  integrity sha1-7GZi5IlkCO1KtsVCo5kLcswIACA=
-
-lodash@^4.0.1, lodash@^4.17.12, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.20, lodash@^4.17.21:
-  version "4.17.21"
-  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c"
-  integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==
-
-log-symbols@4.1.0, log-symbols@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503"
-  integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==
-  dependencies:
-    chalk "^4.1.0"
-    is-unicode-supported "^0.1.0"
-
-log-symbols@^2.1.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-2.2.0.tgz#5740e1c5d6f0dfda4ad9323b5332107ef6b4c40a"
-  integrity sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==
-  dependencies:
-    chalk "^2.0.1"
-
-log-update@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
-  integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==
-  dependencies:
-    ansi-escapes "^4.3.0"
-    cli-cursor "^3.1.0"
-    slice-ansi "^4.0.0"
-    wrap-ansi "^6.2.0"
-
-log4js@^6.3.0, log4js@^6.4.1:
-  version "6.4.6"
-  resolved "https://registry.yarnpkg.com/log4js/-/log4js-6.4.6.tgz#1878aa3f09973298ecb441345fe9dd714e355c15"
-  integrity sha512-1XMtRBZszmVZqPAOOWczH+Q94AI42mtNWjvjA5RduKTSWjEc56uOBbyM1CJnfN4Ym0wSd8cQ43zOojlSHgRDAw==
-  dependencies:
-    date-format "^4.0.9"
-    debug "^4.3.4"
-    flatted "^3.2.5"
-    rfdc "^1.3.0"
-    streamroller "^3.0.8"
-
-loglevel-plugin-prefix@^0.8.4:
-  version "0.8.4"
-  resolved "https://registry.yarnpkg.com/loglevel-plugin-prefix/-/loglevel-plugin-prefix-0.8.4.tgz#2fe0e05f1a820317d98d8c123e634c1bd84ff644"
-  integrity sha512-WpG9CcFAOjz/FtNht+QJeGpvVl/cdR6P0z6OcXSkr8wFJOsV2GRj2j10JLfjuA4aYkcKCNIEqRGCyTife9R8/g==
-
-loglevel@^1.6.0:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/loglevel/-/loglevel-1.8.0.tgz#e7ec73a57e1e7b419cb6c6ac06bf050b67356114"
-  integrity sha512-G6A/nJLRgWOuuwdNuA6koovfEV1YpqqAG4pRUlFaz3jj2QNZ8M4vBqnVA+HBTmU/AMNUtlOsMmSpF6NyOjztbA==
-
-longest@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/longest/-/longest-2.0.1.tgz#781e183296aa94f6d4d916dc335d0d17aefa23f8"
-  integrity sha1-eB4YMpaqlPbU2RbcM10NF676I/g=
-
-loupe@2.3.4:
-  version "2.3.4"
-  resolved "https://registry.yarnpkg.com/loupe/-/loupe-2.3.4.tgz#7e0b9bffc76f148f9be769cb1321d3dcf3cb25f3"
-  integrity sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==
-  dependencies:
-    get-func-name "^2.0.0"
-
-lower-case@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28"
-  integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==
-  dependencies:
-    tslib "^2.0.3"
-
-lowercase-keys@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.0.tgz#4e3366b39e7f5457e35f1324bdf6f88d0bfc7306"
-  integrity sha1-TjNms55/VFfjXxMkvfb4jQv8cwY=
-
-lowercase-keys@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-1.0.1.tgz#6f9e30b47084d971a7c820ff15a6c5167b74c26f"
-  integrity sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==
-
-lowercase-keys@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/lowercase-keys/-/lowercase-keys-2.0.0.tgz#2603e78b7b4b0006cbca2fbcc8a3202558ac9479"
-  integrity sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==
-
-lru-cache@^4.0.1:
-  version "4.1.5"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-4.1.5.tgz#8bbe50ea85bed59bc9e33dcab8235ee9bcf443cd"
-  integrity sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==
-  dependencies:
-    pseudomap "^1.0.2"
-    yallist "^2.1.2"
-
-lru-cache@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
-  integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
-  dependencies:
-    yallist "^4.0.0"
-
-lru-cache@^7.8.1:
-  version "7.9.0"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.9.0.tgz#29c2a989b6c10f32ceccc66ff44059e1490af3e1"
-  integrity sha512-lkcNMUKqdJk96TuIXUidxaPuEg5sJo/+ZyVE2BDFnuZGzwXem7d8582eG8vbu4todLfT14snP6iHriCHXXi5Rw==
-
-magic-string@^0.25.7:
-  version "0.25.9"
-  resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.9.tgz#de7f9faf91ef8a1c91d02c2e5314c8277dbcdd1c"
-  integrity sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==
-  dependencies:
-    sourcemap-codec "^1.4.8"
-
-make-dir@^1.0.0, make-dir@^1.2.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-1.3.0.tgz#79c1033b80515bd6d24ec9933e860ca75ee27f0c"
-  integrity sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==
-  dependencies:
-    pify "^3.0.0"
-
-make-dir@^2.0.0, make-dir@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
-  integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
-  dependencies:
-    pify "^4.0.1"
-    semver "^5.6.0"
-
-make-dir@^3.0.0, make-dir@^3.0.2, make-dir@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-3.1.0.tgz#415e967046b3a7f1d185277d84aa58203726a13f"
-  integrity sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==
-  dependencies:
-    semver "^6.0.0"
-
-make-error@^1.1.1:
-  version "1.3.6"
-  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
-  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
-
-map-obj@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d"
-  integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=
-
-map-obj@^4.0.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
-  integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
-
-marky@^1.2.2:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/marky/-/marky-1.2.4.tgz#d02bb4c08be2366687c778ecd2a328971ce23d7f"
-  integrity sha512-zd2/GiSn6U3/jeFVZ0J9CA1LzQ8RfIVvXkb/U0swFHF/zT+dVohTAWjmo2DcIuofmIIIROlwTbd+shSeXmxr0w==
-
-matcher@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/matcher/-/matcher-3.0.0.tgz#bd9060f4c5b70aa8041ccc6f80368760994f30ca"
-  integrity sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==
-  dependencies:
-    escape-string-regexp "^4.0.0"
-
-md5.js@^1.3.4:
-  version "1.3.5"
-  resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
-  integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-    safe-buffer "^5.1.2"
-
-media-typer@0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
-  integrity sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=
-
-meow@^8.0.0:
-  version "8.1.2"
-  resolved "https://registry.yarnpkg.com/meow/-/meow-8.1.2.tgz#bcbe45bda0ee1729d350c03cffc8395a36c4e897"
-  integrity sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==
-  dependencies:
-    "@types/minimist" "^1.2.0"
-    camelcase-keys "^6.2.2"
-    decamelize-keys "^1.1.0"
-    hard-rejection "^2.1.0"
-    minimist-options "4.1.0"
-    normalize-package-data "^3.0.0"
-    read-pkg-up "^7.0.1"
-    redent "^3.0.0"
-    trim-newlines "^3.0.0"
-    type-fest "^0.18.0"
-    yargs-parser "^20.2.3"
-
-merge-stream@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60"
-  integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==
-
-merge2@^1.3.0, merge2@^1.4.1:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
-  integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
-
-merge@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/merge/-/merge-2.1.1.tgz#59ef4bf7e0b3e879186436e8481c06a6c162ca98"
-  integrity sha512-jz+Cfrg9GWOZbQAnDQ4hlVnQky+341Yk5ru8bZSe6sIDTCIg8n9i/u7hSQGSVOF3C7lH6mGtqjkiT9G4wFLL0w==
-
-micromatch@^4.0.0, micromatch@^4.0.2, micromatch@^4.0.4:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.5.tgz#bc8999a7cbbf77cdc89f132f6e467051b49090c6"
-  integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==
-  dependencies:
-    braces "^3.0.2"
-    picomatch "^2.3.1"
-
-miller-rabin@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/miller-rabin/-/miller-rabin-4.0.1.tgz#f080351c865b0dc562a8462966daa53543c78a4d"
-  integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==
-  dependencies:
-    bn.js "^4.0.0"
-    brorand "^1.0.1"
-
-mime-db@1.52.0, mime-db@^1.28.0:
-  version "1.52.0"
-  resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70"
-  integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==
-
-mime-types@^2.1.12, mime-types@^2.1.27, mime-types@~2.1.19, mime-types@~2.1.24, mime-types@~2.1.34:
-  version "2.1.35"
-  resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a"
-  integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==
-  dependencies:
-    mime-db "1.52.0"
-
-mime@^1.6.0:
-  version "1.6.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-1.6.0.tgz#32cd9e5c64553bd58d19a568af452acff04981b1"
-  integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==
-
-mime@^2.5.2:
-  version "2.6.0"
-  resolved "https://registry.yarnpkg.com/mime/-/mime-2.6.0.tgz#a2a682a95cd4d0cb1d6257e28f83da7e35800367"
-  integrity sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==
-
-mimic-fn@^1.0.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-1.2.0.tgz#820c86a39334640e99516928bd03fca88057d022"
-  integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==
-
-mimic-fn@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/mimic-fn/-/mimic-fn-2.1.0.tgz#7ed2c2ccccaf84d3ffcb7a69b57711fc2083401b"
-  integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==
-
-mimic-response@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-1.0.1.tgz#4923538878eef42063cb8a3e3b0798781487ab1b"
-  integrity sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==
-
-mimic-response@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-3.1.0.tgz#2d1d59af9c1b129815accc2c46a022a5ce1fa3c9"
-  integrity sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==
-
-min-indent@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
-  integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
-
-minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
-  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
-
-minimalistic-crypto-utils@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
-  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
-
-minimatch@3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
-  integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimatch@4.2.1:
-  version "4.2.1"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-4.2.1.tgz#40d9d511a46bdc4e563c22c3080cde9c0d8299b4"
-  integrity sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimatch@^3.0.4:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b"
-  integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==
-  dependencies:
-    brace-expansion "^1.1.7"
-
-minimist-options@4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619"
-  integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==
-  dependencies:
-    arrify "^1.0.1"
-    is-plain-obj "^1.1.0"
-    kind-of "^6.0.3"
-
-minimist@1.2.5:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
-  integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
-
-minimist@1.2.6, minimist@^1.2.5, minimist@^1.2.6:
-  version "1.2.6"
-  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.6.tgz#8637a5b759ea0d6e98702cfb3a9283323c93af44"
-  integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==
-
-mkdirp-classic@^0.5.2:
-  version "0.5.3"
-  resolved "https://registry.yarnpkg.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz#fa10c9115cc6d8865be221ba47ee9bed78601113"
-  integrity sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==
-
-mkdirp@^0.5.3, mkdirp@^0.5.4, mkdirp@^0.5.5:
-  version "0.5.6"
-  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6"
-  integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==
-  dependencies:
-    minimist "^1.2.6"
-
-mkpath@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/mkpath/-/mkpath-1.0.0.tgz#ebb3a977e7af1c683ae6fda12b545a6ba6c5853d"
-  integrity sha1-67Opd+evHGg65v2hK1Raa6bFhT0=
-
-mocha@9.2.2:
-  version "9.2.2"
-  resolved "https://registry.yarnpkg.com/mocha/-/mocha-9.2.2.tgz#d70db46bdb93ca57402c809333e5a84977a88fb9"
-  integrity sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g==
-  dependencies:
-    "@ungap/promise-all-settled" "1.1.2"
-    ansi-colors "4.1.1"
-    browser-stdout "1.3.1"
-    chokidar "3.5.3"
-    debug "4.3.3"
-    diff "5.0.0"
-    escape-string-regexp "4.0.0"
-    find-up "5.0.0"
-    glob "7.2.0"
-    growl "1.10.5"
-    he "1.2.0"
-    js-yaml "4.1.0"
-    log-symbols "4.1.0"
-    minimatch "4.2.1"
-    ms "2.1.3"
-    nanoid "3.3.1"
-    serialize-javascript "6.0.0"
-    strip-json-comments "3.1.1"
-    supports-color "8.1.1"
-    which "2.0.2"
-    workerpool "6.2.0"
-    yargs "16.2.0"
-    yargs-parser "20.2.4"
-    yargs-unparser "2.0.0"
-
-modify-values@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022"
-  integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
-
-ms@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
-  integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
-
-ms@2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
-  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
-
-ms@2.1.3, ms@^2.1.1:
-  version "2.1.3"
-  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.3.tgz#574c8138ce1d2b5861f0b44579dbadd60c6615b2"
-  integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==
-
-mute-stream@0.0.7:
-  version "0.0.7"
-  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.7.tgz#3075ce93bc21b8fab43e1bc4da7e8115ed1e7bab"
-  integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=
-
-nanoid@3.3.1:
-  version "3.3.1"
-  resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.1.tgz#6347a18cac88af88f58af0b3594b723d5e99bb35"
-  integrity sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw==
-
-natural-compare@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
-  integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=
-
-negotiator@0.6.3:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/negotiator/-/negotiator-0.6.3.tgz#58e323a72fedc0d6f9cd4d31fe49f51479590ccd"
-  integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==
-
-neo-async@^2.6.0, neo-async@^2.6.2:
-  version "2.6.2"
-  resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
-  integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
-
-nice-try@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/nice-try/-/nice-try-1.0.5.tgz#a3378a7696ce7d223e88fc9b764bd7ef1089e366"
-  integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ==
-
-nightwatch-helpers@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/nightwatch-helpers/-/nightwatch-helpers-1.2.0.tgz#cdefeb7635074a141825a7b6d1b955b6d7810a0f"
-  integrity sha1-ze/rdjUHShQYJae20blVtteBCg8=
-
-nightwatch@^2.1.3:
-  version "2.1.4"
-  resolved "https://registry.yarnpkg.com/nightwatch/-/nightwatch-2.1.4.tgz#5363cf8fb3abc886f00cb4523339c71a85a015bf"
-  integrity sha512-IozG45KPn2Rth3vbm6/KBlrK+G4f4ut711aaMcCIX+QKrunLuMGWziM4708DYqgToZ65muMTfd3QsNm2SYqHkQ==
-  dependencies:
-    "@nightwatch/chai" "5.0.2"
-    "@nightwatch/ejs" "3.2.0"
-    assertion-error "1.1.0"
-    boxen "5.1.2"
-    chai-nightwatch "0.5.3"
-    ci-info "3.3.0"
-    didyoumean "1.2.2"
-    dotenv "10.0.0"
-    envinfo "7.8.1"
-    glob "7.2.0"
-    lodash.clone "3.0.3"
-    lodash.defaultsdeep "4.6.1"
-    lodash.merge "4.6.2"
-    minimatch "3.0.4"
-    minimist "1.2.6"
-    mkpath "1.0.0"
-    mocha "9.2.2"
-    ora "5.4.1"
-    selenium-webdriver "4.1.1"
-    semver "7.3.5"
-    stacktrace-parser "0.1.10"
-    strip-ansi "6.0.1"
-
-no-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d"
-  integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==
-  dependencies:
-    lower-case "^2.0.2"
-    tslib "^2.0.3"
-
-node-fetch@2.6.7, node-fetch@^2.6.1:
-  version "2.6.7"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.7.tgz#24de9fba827e3b4ae44dc8b20256a379160052ad"
-  integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-node-releases@^2.0.3:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.4.tgz#f38252370c43854dc48aa431c766c6c398f40476"
-  integrity sha512-gbMzqQtTtDz/00jQzZ21PQzdI9PyLYqUSvD0p3naOhX4odFji0ZxYdnVwPTxmSwkmxhcFImpozceidSG+AgoPQ==
-
-normalize-package-data@^2.3.2, normalize-package-data@^2.5.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8"
-  integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==
-  dependencies:
-    hosted-git-info "^2.1.4"
-    resolve "^1.10.0"
-    semver "2 || 3 || 4 || 5"
-    validate-npm-package-license "^3.0.1"
-
-normalize-package-data@^3.0.0:
-  version "3.0.3"
-  resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e"
-  integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==
-  dependencies:
-    hosted-git-info "^4.0.1"
-    is-core-module "^2.5.0"
-    semver "^7.3.4"
-    validate-npm-package-license "^3.0.1"
-
-normalize-path@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-1.0.0.tgz#32d0e472f91ff345701c15a8311018d3b0a90379"
-  integrity sha1-MtDkcvkf80VwHBWoMRAY07CpA3k=
-
-normalize-path@^3.0.0, normalize-path@~3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
-  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
-
-normalize-url@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-2.0.1.tgz#835a9da1551fa26f70e92329069a23aa6574d7e6"
-  integrity sha512-D6MUW4K/VzoJ4rJ01JFKxDrtY1v9wrgzCX5f2qj/lzH1m/lW6MhUZFKerVsnyjOhOsYzI9Kqqak+10l4LvLpMw==
-  dependencies:
-    prepend-http "^2.0.0"
-    query-string "^5.0.1"
-    sort-keys "^2.0.0"
-
-normalize-url@^6.0.1:
-  version "6.1.0"
-  resolved "https://registry.yarnpkg.com/normalize-url/-/normalize-url-6.1.0.tgz#40d0885b535deffe3f3147bec877d05fe4c5668a"
-  integrity sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==
-
-npm-conf@^1.1.0:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/npm-conf/-/npm-conf-1.1.3.tgz#256cc47bd0e218c259c4e9550bf413bc2192aff9"
-  integrity sha512-Yic4bZHJOt9RCFbRP3GgpqhScOY4HH3V2P8yBj6CeYq118Qr+BLXqT2JvpJ00mryLESpgOxf5XlFv4ZjXxLScw==
-  dependencies:
-    config-chain "^1.1.11"
-    pify "^3.0.0"
-
-npm-run-path@^2.0.0:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f"
-  integrity sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=
-  dependencies:
-    path-key "^2.0.0"
-
-npm-run-path@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-4.0.1.tgz#b7ecd1e5ed53da8e37a55e1c2269e0b97ed748ea"
-  integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==
-  dependencies:
-    path-key "^3.0.0"
-
-oauth-sign@~0.9.0:
-  version "0.9.0"
-  resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455"
-  integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==
-
-object-assign@^4, object-assign@^4.0.1, object-assign@^4.1.0:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
-  integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
-
-object-inspect@^1.12.0, object-inspect@^1.9.0:
-  version "1.12.0"
-  resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.0.tgz#6e2c120e868fd1fd18cb4f18c31741d0d6e776f0"
-  integrity sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==
-
-object-is@^1.0.1:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/object-is/-/object-is-1.1.5.tgz#b9deeaa5fc7f1846a0faecdceec138e5778f53ac"
-  integrity sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-
-object-keys@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
-  integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==
-
-object.assign@^4.1.0, object.assign@^4.1.2:
-  version "4.1.2"
-  resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.2.tgz#0ed54a342eceb37b38ff76eb831a0e788cb63940"
-  integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    has-symbols "^1.0.1"
-    object-keys "^1.1.1"
-
-on-finished@2.4.1:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.4.1.tgz#58c8c44116e54845ad57f14ab10b03533184ac3f"
-  integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==
-  dependencies:
-    ee-first "1.1.1"
-
-on-finished@~2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.3.0.tgz#20f1336481b083cd75337992a16971aa2d906947"
-  integrity sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=
-  dependencies:
-    ee-first "1.1.1"
-
-once@^1.3.0, once@^1.3.1, once@^1.4.0:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
-  integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
-  dependencies:
-    wrappy "1"
-
-onetime@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-2.0.1.tgz#067428230fd67443b2794b22bba528b6867962d4"
-  integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=
-  dependencies:
-    mimic-fn "^1.0.0"
-
-onetime@^5.1.0, onetime@^5.1.2:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/onetime/-/onetime-5.1.2.tgz#d0e96ebb56b07476df1dd9c4806e5237985ca45e"
-  integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==
-  dependencies:
-    mimic-fn "^2.1.0"
-
-opener@^1.5.1:
-  version "1.5.2"
-  resolved "https://registry.yarnpkg.com/opener/-/opener-1.5.2.tgz#5d37e1f35077b9dcac4301372271afdeb2a13598"
-  integrity sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==
-
-optionator@^0.8.1:
-  version "0.8.3"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495"
-  integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==
-  dependencies:
-    deep-is "~0.1.3"
-    fast-levenshtein "~2.0.6"
-    levn "~0.3.0"
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-    word-wrap "~1.2.3"
-
-optionator@^0.9.1:
-  version "0.9.1"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.1.tgz#4f236a6373dae0566a6d43e1326674f50c291499"
-  integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==
-  dependencies:
-    deep-is "^0.1.3"
-    fast-levenshtein "^2.0.6"
-    levn "^0.4.1"
-    prelude-ls "^1.2.1"
-    type-check "^0.4.0"
-    word-wrap "^1.2.3"
-
-ora@5.4.1:
-  version "5.4.1"
-  resolved "https://registry.yarnpkg.com/ora/-/ora-5.4.1.tgz#1b2678426af4ac4a509008e5e4ac9e9959db9e18"
-  integrity sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==
-  dependencies:
-    bl "^4.1.0"
-    chalk "^4.1.0"
-    cli-cursor "^3.1.0"
-    cli-spinners "^2.5.0"
-    is-interactive "^1.0.0"
-    is-unicode-supported "^0.1.0"
-    log-symbols "^4.1.0"
-    strip-ansi "^6.0.0"
-    wcwidth "^1.0.1"
-
-os-browserify@^0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/os-browserify/-/os-browserify-0.3.0.tgz#854373c7f5c2315914fc9bfc6bd8238fdda1ec27"
-  integrity sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=
-
-os-filter-obj@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/os-filter-obj/-/os-filter-obj-2.0.0.tgz#1c0b62d5f3a2442749a2d139e6dddee6e81d8d16"
-  integrity sha512-uksVLsqG3pVdzzPvmAHpBK0wKxYItuzZr7SziusRPoz67tGV8rL1szZ6IdeUrbqLjGDwApBtN29eEE3IqGHOjg==
-  dependencies:
-    arch "^2.1.0"
-
-os-tmpdir@~1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274"
-  integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=
-
-p-cancelable@^0.4.0:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-0.4.1.tgz#35f363d67d52081c8d9585e37bcceb7e0bbcb2a0"
-  integrity sha512-HNa1A8LvB1kie7cERyy21VNeHb2CWJJYqyyC2o3klWFfMGlFmWv2Z7sFgZH8ZiaYL95ydToKTFVXgMV/Os0bBQ==
-
-p-cancelable@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/p-cancelable/-/p-cancelable-2.1.1.tgz#aab7fbd416582fa32a3db49859c122487c5ed2cf"
-  integrity sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==
-
-p-event@^2.1.0:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/p-event/-/p-event-2.3.1.tgz#596279ef169ab2c3e0cae88c1cfbb08079993ef6"
-  integrity sha512-NQCqOFhbpVTMX4qMe8PF8lbGtzZ+LCiN7pcNrb/413Na7+TRoe1xkKUzuWa/YEJdGQ0FvKtj35EEbDoVPO2kbA==
-  dependencies:
-    p-timeout "^2.0.1"
-
-p-finally@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae"
-  integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=
-
-p-is-promise@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/p-is-promise/-/p-is-promise-1.1.0.tgz#9c9456989e9f6588017b0434d56097675c3da05e"
-  integrity sha1-nJRWmJ6fZYgBewQ01WCXZ1w9oF4=
-
-p-limit@^1.1.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8"
-  integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==
-  dependencies:
-    p-try "^1.0.0"
-
-p-limit@^2.0.0, p-limit@^2.2.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
-  integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
-  dependencies:
-    p-try "^2.0.0"
-
-p-limit@^3.0.2:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b"
-  integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==
-  dependencies:
-    yocto-queue "^0.1.0"
-
-p-locate@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43"
-  integrity sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=
-  dependencies:
-    p-limit "^1.1.0"
-
-p-locate@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
-  integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
-  dependencies:
-    p-limit "^2.0.0"
-
-p-locate@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07"
-  integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==
-  dependencies:
-    p-limit "^2.2.0"
-
-p-locate@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834"
-  integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==
-  dependencies:
-    p-limit "^3.0.2"
-
-p-map@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/p-map/-/p-map-4.0.0.tgz#bb2f95a5eda2ec168ec9274e06a747c3e2904d2b"
-  integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==
-  dependencies:
-    aggregate-error "^3.0.0"
-
-p-timeout@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/p-timeout/-/p-timeout-2.0.1.tgz#d8dd1979595d2dc0139e1fe46b8b646cb3cdf038"
-  integrity sha512-88em58dDVB/KzPEx1X0N3LwFfYZPyDc4B6eF38M1rk9VTZMbxXXgjugz8mmwpS9Ox4BDZ+t6t3QP5+/gazweIA==
-  dependencies:
-    p-finally "^1.0.0"
-
-p-try@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3"
-  integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=
-
-p-try@^2.0.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
-  integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
-
-pad@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/pad/-/pad-3.2.0.tgz#be7a1d1cb6757049b4ad5b70e71977158fea95d1"
-  integrity sha512-2u0TrjcGbOjBTJpyewEl4hBO3OeX5wWue7eIFPzQTg6wFSvoaHcBTTUY5m+n0hd04gmTCPuY0kCpVIVuw5etwg==
-  dependencies:
-    wcwidth "^1.0.1"
-
-pako@~1.0.2, pako@~1.0.5:
-  version "1.0.11"
-  resolved "https://registry.yarnpkg.com/pako/-/pako-1.0.11.tgz#6c9599d340d54dfd3946380252a35705a6b992bf"
-  integrity sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==
-
-param-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/param-case/-/param-case-3.0.4.tgz#7d17fe4aa12bde34d4a77d91acfb6219caad01c5"
-  integrity sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==
-  dependencies:
-    dot-case "^3.0.4"
-    tslib "^2.0.3"
-
-parent-module@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/parent-module/-/parent-module-1.0.1.tgz#691d2709e78c79fae3a156622452d00762caaaa2"
-  integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==
-  dependencies:
-    callsites "^3.0.0"
-
-parse-asn1@^5.0.0, parse-asn1@^5.1.5:
-  version "5.1.6"
-  resolved "https://registry.yarnpkg.com/parse-asn1/-/parse-asn1-5.1.6.tgz#385080a3ec13cb62a62d39409cb3e88844cdaed4"
-  integrity sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==
-  dependencies:
-    asn1.js "^5.2.0"
-    browserify-aes "^1.0.0"
-    evp_bytestokey "^1.0.0"
-    pbkdf2 "^3.0.3"
-    safe-buffer "^5.1.1"
-
-parse-json@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0"
-  integrity sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=
-  dependencies:
-    error-ex "^1.3.1"
-    json-parse-better-errors "^1.0.1"
-
-parse-json@^5.0.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd"
-  integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==
-  dependencies:
-    "@babel/code-frame" "^7.0.0"
-    error-ex "^1.3.1"
-    json-parse-even-better-errors "^2.3.0"
-    lines-and-columns "^1.1.6"
-
-parse-passwd@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6"
-  integrity sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=
-
-parseurl@~1.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/parseurl/-/parseurl-1.3.3.tgz#9da19e7bee8d12dff0513ed5b76957793bc2e8d4"
-  integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==
-
-pascal-case@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz#b48e0ef2b98e205e7c1dae747d0b1508237660eb"
-  integrity sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==
-  dependencies:
-    no-case "^3.0.4"
-    tslib "^2.0.3"
-
-path-browserify@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd"
-  integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==
-
-path-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/path-case/-/path-case-3.0.4.tgz#9168645334eb942658375c56f80b4c0cb5f82c6f"
-  integrity sha512-qO4qCFjXqVTrcbPt/hQfhTQ+VhFsqNKOPtytgNKkKxSoEp3XPUQ8ObFuePylOIok5gjn69ry8XiULxCwot3Wfg==
-  dependencies:
-    dot-case "^3.0.4"
-    tslib "^2.0.3"
-
-path-exists@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
-  integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=
-
-path-exists@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3"
-  integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==
-
-path-is-absolute@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
-  integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
-
-path-is-network-drive@^1.0.13:
-  version "1.0.13"
-  resolved "https://registry.yarnpkg.com/path-is-network-drive/-/path-is-network-drive-1.0.13.tgz#c9aa0183eb72c328aa83f43def93ddcb9d7ec4d4"
-  integrity sha512-Hg74mRN6mmXV+gTm3INjFK40ncAmC/Lo4qoQaSZ+GT3hZzlKdWQSqAjqyPeW0SvObP2W073WyYEBWY9d3wOm3A==
-  dependencies:
-    tslib "^2.3.1"
-
-path-key@^2.0.0, path-key@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40"
-  integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=
-
-path-key@^3.0.0, path-key@^3.1.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
-  integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
-
-path-parse@^1.0.7:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
-  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
-
-path-strip-sep@^1.0.10:
-  version "1.0.10"
-  resolved "https://registry.yarnpkg.com/path-strip-sep/-/path-strip-sep-1.0.10.tgz#2be4e789406b298af8709ff79af716134b733b98"
-  integrity sha512-JpCy+8LAJQQTO1bQsb/84s1g+/Stm3h39aOpPRBQ/paMUGVPPZChLTOTKHoaCkc/6sKuF7yVsnq5Pe1S6xQGcA==
-  dependencies:
-    tslib "^2.3.1"
-
-path-type@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-3.0.0.tgz#cef31dc8e0a1a3bb0d105c0cd97cf3bf47f4e36f"
-  integrity sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==
-  dependencies:
-    pify "^3.0.0"
-
-path-type@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/path-type/-/path-type-4.0.0.tgz#84ed01c0a7ba380afe09d90a8c180dcd9d03043b"
-  integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==
-
-pathval@1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/pathval/-/pathval-1.1.1.tgz#8534e77a77ce7ac5a2512ea21e0fdb8fcf6c3d8d"
-  integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==
-
-pbkdf2@^3.0.3:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.2.tgz#dd822aa0887580e52f1a039dc3eda108efae3075"
-  integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==
-  dependencies:
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-    ripemd160 "^2.0.1"
-    safe-buffer "^5.0.1"
-    sha.js "^2.4.8"
-
-pend@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/pend/-/pend-1.2.0.tgz#7a57eb550a6783f9115331fcf4663d5c8e007a50"
-  integrity sha1-elfrVQpng/kRUzH89GY9XI4AelA=
-
-performance-now@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b"
-  integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=
-
-phantomjs-prebuilt@^2.1.14, phantomjs-prebuilt@^2.1.7:
-  version "2.1.16"
-  resolved "https://registry.yarnpkg.com/phantomjs-prebuilt/-/phantomjs-prebuilt-2.1.16.tgz#efd212a4a3966d3647684ea8ba788549be2aefef"
-  integrity sha1-79ISpKOWbTZHaE6ouniFSb4q7+8=
-  dependencies:
-    es6-promise "^4.0.3"
-    extract-zip "^1.6.5"
-    fs-extra "^1.0.0"
-    hasha "^2.2.0"
-    kew "^0.7.0"
-    progress "^1.1.8"
-    request "^2.81.0"
-    request-progress "^2.0.1"
-    which "^1.2.10"
-
-picocolors@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c"
-  integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
-
-picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.2, picomatch@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
-  integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
-
-pidtree@^0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/pidtree/-/pidtree-0.5.0.tgz#ad5fbc1de78b8a5f99d6fbdd4f6e4eee21d1aca1"
-  integrity sha512-9nxspIM7OpZuhBxPg73Zvyq7j1QMPMPsGKTqRc2XOaFQauDvoNz9fM1Wdkjmeo7l9GXOZiRs97sPkuayl39wjA==
-
-pify@^2.2.0, pify@^2.3.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
-  integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw=
-
-pify@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176"
-  integrity sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=
-
-pify@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
-  integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
-
-pinkie-promise@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
-  integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o=
-  dependencies:
-    pinkie "^2.0.0"
-
-pinkie@^2.0.0:
-  version "2.0.4"
-  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
-  integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
-
-pirates@^4.0.5:
-  version "4.0.5"
-  resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.5.tgz#feec352ea5c3268fb23a37c702ab1699f35a5f3b"
-  integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ==
-
-pkg-dir@4.2.0, pkg-dir@^4.1.0, pkg-dir@^4.2.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3"
-  integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==
-  dependencies:
-    find-up "^4.0.0"
-
-"pkg-dir@< 6 >= 5":
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-5.0.0.tgz#a02d6aebe6ba133a928f74aec20bafdfe6b8e760"
-  integrity sha512-NPE8TDbzl/3YQYY7CSS228s3g2ollTFnc+Qi3tqmqJp9Vg2ovUpixcJEo2HJScN2Ez+kEaal6y70c0ehqJBJeA==
-  dependencies:
-    find-up "^5.0.0"
-
-pkg-dir@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
-  integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
-  dependencies:
-    find-up "^3.0.0"
-
-portfinder@^1.0.28:
-  version "1.0.28"
-  resolved "https://registry.yarnpkg.com/portfinder/-/portfinder-1.0.28.tgz#67c4622852bd5374dd1dd900f779f53462fac778"
-  integrity sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==
-  dependencies:
-    async "^2.6.2"
-    debug "^3.1.1"
-    mkdirp "^0.5.5"
-
-prelude-ls@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
-  integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==
-
-prelude-ls@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
-  integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=
-
-prepend-http@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/prepend-http/-/prepend-http-2.0.0.tgz#e92434bfa5ea8c19f41cdfd401d741a3c819d897"
-  integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc=
-
-process-nextick-args@~2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
-  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
-
-process@^0.11.10:
-  version "0.11.10"
-  resolved "https://registry.yarnpkg.com/process/-/process-0.11.10.tgz#7332300e840161bda3e69a1d1d91a7d4bc16f182"
-  integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI=
-
-progress@2.0.3, progress@^2.0.1:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/progress/-/progress-2.0.3.tgz#7e8cf8d8f5b8f239c1bc68beb4eb78567d572ef8"
-  integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==
-
-progress@^1.1.8:
-  version "1.1.8"
-  resolved "https://registry.yarnpkg.com/progress/-/progress-1.1.8.tgz#e260c78f6161cdd9b0e56cc3e0a85de17c7a57be"
-  integrity sha1-4mDHj2Fhzdmw5WzD4Khd4Xx6V74=
-
-proto-list@~1.2.1:
-  version "1.2.4"
-  resolved "https://registry.yarnpkg.com/proto-list/-/proto-list-1.2.4.tgz#212d5bfe1318306a420f6402b8e26ff39647a849"
-  integrity sha1-IS1b/hMYMGpCD2QCuOJv85ZHqEk=
-
-proxy-from-env@1.1.0, proxy-from-env@^1.0.0, proxy-from-env@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/proxy-from-env/-/proxy-from-env-1.1.0.tgz#e102f16ca355424865755d2c9e8ea4f24d58c3e2"
-  integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==
-
-pseudomap@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/pseudomap/-/pseudomap-1.0.2.tgz#f052a28da70e618917ef0a8ac34c1ae5a68286b3"
-  integrity sha1-8FKijacOYYkX7wqKw0wa5aaChrM=
-
-psl@^1.1.28:
-  version "1.8.0"
-  resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24"
-  integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==
-
-public-encrypt@^4.0.0:
-  version "4.0.3"
-  resolved "https://registry.yarnpkg.com/public-encrypt/-/public-encrypt-4.0.3.tgz#4fcc9d77a07e48ba7527e7cbe0de33d0701331e0"
-  integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==
-  dependencies:
-    bn.js "^4.1.0"
-    browserify-rsa "^4.0.0"
-    create-hash "^1.1.0"
-    parse-asn1 "^5.0.0"
-    randombytes "^2.0.1"
-    safe-buffer "^5.1.2"
-
-pump@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/pump/-/pump-3.0.0.tgz#b4a2116815bde2f4e1ea602354e8c75565107a64"
-  integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==
-  dependencies:
-    end-of-stream "^1.1.0"
-    once "^1.3.1"
-
-punycode@1.3.2:
-  version "1.3.2"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.3.2.tgz#9653a036fb7c1ee42342f2325cceefea3926c48d"
-  integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=
-
-punycode@^1.3.2:
-  version "1.4.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-1.4.1.tgz#c0d5a63b2718800ad8e1eb0fa5269c84dd41845e"
-  integrity sha1-wNWmOycYgArY4esPpSachN1BhF4=
-
-punycode@^2.1.0, punycode@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
-  integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
-
-puppeteer-core@^5.1.0:
-  version "5.5.0"
-  resolved "https://registry.yarnpkg.com/puppeteer-core/-/puppeteer-core-5.5.0.tgz#dfb6266efe5a933cbf1a368d27025a6fd4f5a884"
-  integrity sha512-tlA+1n+ziW/Db03hVV+bAecDKse8ihFRXYiEypBe9IlLRvOCzYFG6qrCMBYK34HO/Q/Ecjc+tvkHRAfLVH+NgQ==
-  dependencies:
-    debug "^4.1.0"
-    devtools-protocol "0.0.818844"
-    extract-zip "^2.0.0"
-    https-proxy-agent "^4.0.0"
-    node-fetch "^2.6.1"
-    pkg-dir "^4.2.0"
-    progress "^2.0.1"
-    proxy-from-env "^1.0.0"
-    rimraf "^3.0.2"
-    tar-fs "^2.0.0"
-    unbzip2-stream "^1.3.3"
-    ws "^7.2.3"
-
-puppeteer@^13.7.0:
-  version "13.7.0"
-  resolved "https://registry.yarnpkg.com/puppeteer/-/puppeteer-13.7.0.tgz#18e16f83e397cf02f7a0804c67c1603d381cfb0b"
-  integrity sha512-U1uufzBjz3+PkpCxFrWzh4OrMIdIb2ztzCu0YEPfRHjHswcSwHZswnK+WdsOQJsRV8WeTg3jLhJR4D867+fjsA==
-  dependencies:
-    cross-fetch "3.1.5"
-    debug "4.3.4"
-    devtools-protocol "0.0.981744"
-    extract-zip "2.0.1"
-    https-proxy-agent "5.0.1"
-    pkg-dir "4.2.0"
-    progress "2.0.3"
-    proxy-from-env "1.1.0"
-    rimraf "3.0.2"
-    tar-fs "2.1.1"
-    unbzip2-stream "1.4.3"
-    ws "8.5.0"
-
-q@^1.5.1:
-  version "1.5.1"
-  resolved "https://registry.yarnpkg.com/q/-/q-1.5.1.tgz#7e32f75b41381291d04611f1bf14109ac00651d7"
-  integrity sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=
-
-qjobs@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/qjobs/-/qjobs-1.2.0.tgz#c45e9c61800bd087ef88d7e256423bdd49e5d071"
-  integrity sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==
-
-qs@6.10.3, qs@^6.4.0:
-  version "6.10.3"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.3.tgz#d6cde1b2ffca87b5aa57889816c5f81535e22e8e"
-  integrity sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==
-  dependencies:
-    side-channel "^1.0.4"
-
-qs@~6.5.2:
-  version "6.5.3"
-  resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.3.tgz#3aeeffc91967ef6e35c0e488ef46fb296ab76aad"
-  integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==
-
-query-string@^5.0.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/query-string/-/query-string-5.1.1.tgz#a78c012b71c17e05f2e3fa2319dd330682efb3cb"
-  integrity sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==
-  dependencies:
-    decode-uri-component "^0.2.0"
-    object-assign "^4.1.0"
-    strict-uri-encode "^1.0.0"
-
-querystring-es3@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/querystring-es3/-/querystring-es3-0.2.1.tgz#9ec61f79049875707d69414596fd907a4d711e73"
-  integrity sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=
-
-querystring@0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/querystring/-/querystring-0.2.0.tgz#b209849203bb25df820da756e747005878521620"
-  integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=
-
-queue-microtask@^1.2.2:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
-  integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
-
-quick-lru@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
-  integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==
-
-quick-lru@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
-  integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
-
-randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5, randombytes@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
-  integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==
-  dependencies:
-    safe-buffer "^5.1.0"
-
-randomfill@^1.0.3:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/randomfill/-/randomfill-1.0.4.tgz#c92196fc86ab42be983f1bf31778224931d61458"
-  integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==
-  dependencies:
-    randombytes "^2.0.5"
-    safe-buffer "^5.1.0"
-
-range-parser@^1.2.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/range-parser/-/range-parser-1.2.1.tgz#3cf37023d199e1c24d1a55b84800c2f3e6468031"
-  integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==
-
-raw-body@2.5.1:
-  version "2.5.1"
-  resolved "https://registry.yarnpkg.com/raw-body/-/raw-body-2.5.1.tgz#fe1b1628b181b700215e5fd42389f98b71392857"
-  integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==
-  dependencies:
-    bytes "3.1.2"
-    http-errors "2.0.0"
-    iconv-lite "0.4.24"
-    unpipe "1.0.0"
-
-read-pkg-up@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07"
-  integrity sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=
-  dependencies:
-    find-up "^2.0.0"
-    read-pkg "^3.0.0"
-
-read-pkg-up@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
-  integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==
-  dependencies:
-    find-up "^4.1.0"
-    read-pkg "^5.2.0"
-    type-fest "^0.8.1"
-
-read-pkg@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-3.0.0.tgz#9cbc686978fee65d16c00e2b19c237fcf6e38389"
-  integrity sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=
-  dependencies:
-    load-json-file "^4.0.0"
-    normalize-package-data "^2.3.2"
-    path-type "^3.0.0"
-
-read-pkg@^5.2.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc"
-  integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==
-  dependencies:
-    "@types/normalize-package-data" "^2.4.0"
-    normalize-package-data "^2.5.0"
-    parse-json "^5.0.0"
-    type-fest "^0.6.0"
-
-readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.1.1, readable-stream@^3.4.0, readable-stream@^3.5.0, readable-stream@^3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
-  integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
-  dependencies:
-    inherits "^2.0.3"
-    string_decoder "^1.1.1"
-    util-deprecate "^1.0.1"
-
-readable-stream@^2.0.0, readable-stream@^2.0.5, readable-stream@^2.2.2, readable-stream@^2.3.0, readable-stream@^2.3.5, readable-stream@~2.3.6:
-  version "2.3.7"
-  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
-  integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
-  dependencies:
-    core-util-is "~1.0.0"
-    inherits "~2.0.3"
-    isarray "~1.0.0"
-    process-nextick-args "~2.0.0"
-    safe-buffer "~5.1.1"
-    string_decoder "~1.1.1"
-    util-deprecate "~1.0.1"
-
-readdir-glob@^1.0.0:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/readdir-glob/-/readdir-glob-1.1.1.tgz#f0e10bb7bf7bfa7e0add8baffdc54c3f7dbee6c4"
-  integrity sha512-91/k1EzZwDx6HbERR+zucygRFfiPl2zkIYZtv3Jjr6Mn7SkKcVct8aVO+sSRiGMc6fLf72du3d92/uY63YPdEA==
-  dependencies:
-    minimatch "^3.0.4"
-
-readdirp@~3.6.0:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7"
-  integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==
-  dependencies:
-    picomatch "^2.2.1"
-
-rechoir@^0.6.2:
-  version "0.6.2"
-  resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384"
-  integrity sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=
-  dependencies:
-    resolve "^1.1.6"
-
-redent@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f"
-  integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==
-  dependencies:
-    indent-string "^4.0.0"
-    strip-indent "^3.0.0"
-
-regenerate-unicode-properties@^10.0.1:
-  version "10.0.1"
-  resolved "https://registry.yarnpkg.com/regenerate-unicode-properties/-/regenerate-unicode-properties-10.0.1.tgz#7f442732aa7934a3740c779bb9b3340dccc1fb56"
-  integrity sha512-vn5DU6yg6h8hP/2OkQo3K7uVILvY4iu0oI4t3HFa81UPkhGJwkRwM10JEc3upjdhHjs/k8GJY1sRBhk5sr69Bw==
-  dependencies:
-    regenerate "^1.4.2"
-
-regenerate@^1.4.2:
-  version "1.4.2"
-  resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.4.2.tgz#b9346d8827e8f5a32f7ba29637d398b69014848a"
-  integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==
-
-regenerator-runtime@^0.13.4:
-  version "0.13.9"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz#8925742a98ffd90814988d7566ad30ca3b263b52"
-  integrity sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==
-
-regenerator-transform@^0.15.0:
-  version "0.15.0"
-  resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.15.0.tgz#cbd9ead5d77fae1a48d957cf889ad0586adb6537"
-  integrity sha512-LsrGtPmbYg19bcPHwdtmXwbW+TqNvtY4riE3P83foeHRroMbH6/2ddFBfab3t7kbzc7v7p4wbkIecHImqt0QNg==
-  dependencies:
-    "@babel/runtime" "^7.8.4"
-
-regexpp@^3.2.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2"
-  integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==
-
-regexpu-core@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-5.0.1.tgz#c531122a7840de743dcf9c83e923b5560323ced3"
-  integrity sha512-CriEZlrKK9VJw/xQGJpQM5rY88BtuL8DM+AEwvcThHilbxiTAy8vq4iJnd2tqq8wLmjbGZzP7ZcKFjbGkmEFrw==
-  dependencies:
-    regenerate "^1.4.2"
-    regenerate-unicode-properties "^10.0.1"
-    regjsgen "^0.6.0"
-    regjsparser "^0.8.2"
-    unicode-match-property-ecmascript "^2.0.0"
-    unicode-match-property-value-ecmascript "^2.0.0"
-
-regjsgen@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.6.0.tgz#83414c5354afd7d6627b16af5f10f41c4e71808d"
-  integrity sha512-ozE883Uigtqj3bx7OhL1KNbCzGyW2NQZPl6Hs09WTvCuZD5sTI4JY58bkbQWa/Y9hxIsvJ3M8Nbf7j54IqeZbA==
-
-regjsparser@^0.8.2:
-  version "0.8.4"
-  resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.8.4.tgz#8a14285ffcc5de78c5b95d62bbf413b6bc132d5f"
-  integrity sha512-J3LABycON/VNEu3abOviqGHuB/LOtOQj8SKmfP9anY5GfAVw/SPjwzSjxGjbZXIxbGfqTHtJw58C2Li/WkStmA==
-  dependencies:
-    jsesc "~0.5.0"
-
-request-progress@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/request-progress/-/request-progress-2.0.1.tgz#5d36bb57961c673aa5b788dbc8141fdf23b44e08"
-  integrity sha1-XTa7V5YcZzqlt4jbyBQf3yO0Tgg=
-  dependencies:
-    throttleit "^1.0.0"
-
-request@^2.81.0:
-  version "2.88.2"
-  resolved "https://registry.yarnpkg.com/request/-/request-2.88.2.tgz#d73c918731cb5a87da047e207234146f664d12b3"
-  integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==
-  dependencies:
-    aws-sign2 "~0.7.0"
-    aws4 "^1.8.0"
-    caseless "~0.12.0"
-    combined-stream "~1.0.6"
-    extend "~3.0.2"
-    forever-agent "~0.6.1"
-    form-data "~2.3.2"
-    har-validator "~5.1.3"
-    http-signature "~1.2.0"
-    is-typedarray "~1.0.0"
-    isstream "~0.1.2"
-    json-stringify-safe "~5.0.1"
-    mime-types "~2.1.19"
-    oauth-sign "~0.9.0"
-    performance-now "^2.1.0"
-    qs "~6.5.2"
-    safe-buffer "^5.1.2"
-    tough-cookie "~2.5.0"
-    tunnel-agent "^0.6.0"
-    uuid "^3.3.2"
-
-require-directory@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
-  integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
-
-requires-port@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/requires-port/-/requires-port-1.0.0.tgz#925d2601d39ac485e091cf0da5c6e694dc3dcaff"
-  integrity sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=
-
-resolve-alpn@^1.0.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/resolve-alpn/-/resolve-alpn-1.2.1.tgz#b7adbdac3546aaaec20b45e7d8265927072726f9"
-  integrity sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==
-
-resolve-dir@^1.0.0, resolve-dir@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-1.0.1.tgz#79a40644c362be82f26effe739c9bb5382046f43"
-  integrity sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=
-  dependencies:
-    expand-tilde "^2.0.0"
-    global-modules "^1.0.0"
-
-resolve-from@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-4.0.0.tgz#4abcd852ad32dd7baabfe9b40e00a36db5f392e6"
-  integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==
-
-resolve-from@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
-  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==
-
-resolve-global@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/resolve-global/-/resolve-global-1.0.0.tgz#a2a79df4af2ca3f49bf77ef9ddacd322dad19255"
-  integrity sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==
-  dependencies:
-    global-dirs "^0.1.1"
-
-resolve-url@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a"
-  integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
-
-resolve@^1.1.6, resolve@^1.10.0, resolve@^1.12.0, resolve@^1.14.2, resolve@^1.17.0, resolve@^1.19.0, resolve@^1.20.0, resolve@^1.22.0:
-  version "1.22.0"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.0.tgz#5e0b8c67c15df57a89bdbabe603a002f21731198"
-  integrity sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==
-  dependencies:
-    is-core-module "^2.8.1"
-    path-parse "^1.0.7"
-    supports-preserve-symlinks-flag "^1.0.0"
-
-responselike@1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/responselike/-/responselike-1.0.2.tgz#918720ef3b631c5642be068f15ade5a46f4ba1e7"
-  integrity sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec=
-  dependencies:
-    lowercase-keys "^1.0.0"
-
-responselike@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/responselike/-/responselike-2.0.0.tgz#26391bcc3174f750f9a79eacc40a12a5c42d7723"
-  integrity sha512-xH48u3FTB9VsZw7R+vvgaKeLKzT6jOogbQhEe/jewwnZgzPcnyWui2Av6JpoYZF/91uueC+lqhWqeURw5/qhCw==
-  dependencies:
-    lowercase-keys "^2.0.0"
-
-resq@^1.9.1:
-  version "1.10.2"
-  resolved "https://registry.yarnpkg.com/resq/-/resq-1.10.2.tgz#cedf4f20d53f6e574b1e12afbda446ad9576c193"
-  integrity sha512-HmgVS3j+FLrEDBTDYysPdPVF9/hioDMJ/otOiQDKqk77YfZeeLOj0qi34yObumcud1gBpk+wpBTEg4kMicD++A==
-  dependencies:
-    fast-deep-equal "^2.0.1"
-
-restore-cursor@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-2.0.0.tgz#9f7ee287f82fd326d4fd162923d62129eee0dfaf"
-  integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368=
-  dependencies:
-    onetime "^2.0.0"
-    signal-exit "^3.0.2"
-
-restore-cursor@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-3.1.0.tgz#39f67c54b3a7a58cea5236d95cf0034239631f7e"
-  integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==
-  dependencies:
-    onetime "^5.1.0"
-    signal-exit "^3.0.2"
-
-reusify@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76"
-  integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==
-
-rfdc@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/rfdc/-/rfdc-1.3.0.tgz#d0b7c441ab2720d05dc4cf26e01c89631d9da08b"
-  integrity sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==
-
-rgb2hex@0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/rgb2hex/-/rgb2hex-0.2.3.tgz#8aa464c517b8a26c7a79d767dabaec2b49ee78ec"
-  integrity sha512-clEe0m1xv+Tva1B/TOepuIcvLAxP0U+sCDfgt1SX1HmI2Ahr5/Cd/nzJM1e78NKVtWdoo0s33YehpFA8UfIShQ==
-
-rimraf@3.0.2, rimraf@^3.0.0, rimraf@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a"
-  integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==
-  dependencies:
-    glob "^7.1.3"
-
-ripemd160@^2.0.0, ripemd160@^2.0.1:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
-  integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
-  dependencies:
-    hash-base "^3.0.0"
-    inherits "^2.0.1"
-
-roarr@^2.15.3:
-  version "2.15.4"
-  resolved "https://registry.yarnpkg.com/roarr/-/roarr-2.15.4.tgz#f5fe795b7b838ccfe35dc608e0282b9eba2e7afd"
-  integrity sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==
-  dependencies:
-    boolean "^3.0.1"
-    detect-node "^2.0.4"
-    globalthis "^1.0.1"
-    json-stringify-safe "^5.0.1"
-    semver-compare "^1.0.0"
-    sprintf-js "^1.1.2"
-
-rollup-plugin-typescript2@^0.31.2:
-  version "0.31.2"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-typescript2/-/rollup-plugin-typescript2-0.31.2.tgz#463aa713a7e2bf85b92860094b9f7fb274c5a4d8"
-  integrity sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==
-  dependencies:
-    "@rollup/pluginutils" "^4.1.2"
-    "@yarn-tool/resolve-package" "^1.0.40"
-    find-cache-dir "^3.3.2"
-    fs-extra "^10.0.0"
-    resolve "^1.20.0"
-    tslib "^2.3.1"
-
-rollup@^2.70.2:
-  version "2.71.1"
-  resolved "https://registry.yarnpkg.com/rollup/-/rollup-2.71.1.tgz#82b259af7733dfd1224a8171013aaaad02971a22"
-  integrity sha512-lMZk3XfUBGjrrZQpvPSoXcZSfKcJ2Bgn+Z0L1MoW2V8Wh7BVM+LOBJTPo16yul2MwL59cXedzW1ruq3rCjSRgw==
-  optionalDependencies:
-    fsevents "~2.3.2"
-
-run-async@^2.2.0:
-  version "2.4.1"
-  resolved "https://registry.yarnpkg.com/run-async/-/run-async-2.4.1.tgz#8440eccf99ea3e70bd409d49aab88e10c189a455"
-  integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==
-
-run-parallel@^1.1.9:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee"
-  integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==
-  dependencies:
-    queue-microtask "^1.2.2"
-
-rxjs@^6.4.0:
-  version "6.6.7"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.6.7.tgz#90ac018acabf491bf65044235d5863c4dab804c9"
-  integrity sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==
-  dependencies:
-    tslib "^1.9.0"
-
-rxjs@^7.5.5:
-  version "7.5.5"
-  resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.5.5.tgz#2ebad89af0f560f460ad5cc4213219e1f7dd4e9f"
-  integrity sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==
-  dependencies:
-    tslib "^2.1.0"
-
-safe-buffer@5.1.2, safe-buffer@~5.1.0, safe-buffer@~5.1.1:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
-  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
-
-safe-buffer@5.2.1, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0:
-  version "5.2.1"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
-  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
-
-"safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
-  integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
-
-saucelabs@^4.6.3:
-  version "4.7.8"
-  resolved "https://registry.yarnpkg.com/saucelabs/-/saucelabs-4.7.8.tgz#099a7ddacee297b34420acd5ddc155eb1ad0efde"
-  integrity sha512-K2qaRUixc7+8JiAwpTvEsIQVzzUkYwa0mAfs0akGagRlWXUR1JrsmgJRyz28qkwpERW1KDuByn3Ju96BuW1V7Q==
-  dependencies:
-    bin-wrapper "^4.1.0"
-    change-case "^4.1.1"
-    form-data "^3.0.0"
-    got "^11.7.0"
-    hash.js "^1.1.7"
-    tunnel "0.0.6"
-    yargs "^16.0.3"
-
-schema-utils@^2.6.5:
-  version "2.7.1"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-2.7.1.tgz#1ca4f32d1b24c590c203b8e7a50bf0ea4cd394d7"
-  integrity sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==
-  dependencies:
-    "@types/json-schema" "^7.0.5"
-    ajv "^6.12.4"
-    ajv-keywords "^3.5.2"
-
-schema-utils@^3.0.0, schema-utils@^3.1.0, schema-utils@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.1.1.tgz#bc74c4b6b6995c1d88f76a8b77bea7219e0c8281"
-  integrity sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==
-  dependencies:
-    "@types/json-schema" "^7.0.8"
-    ajv "^6.12.5"
-    ajv-keywords "^3.5.2"
-
-secure-compare@3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/secure-compare/-/secure-compare-3.0.1.tgz#f1a0329b308b221fae37b9974f3d578d0ca999e3"
-  integrity sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=
-
-seek-bzip@^1.0.5:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/seek-bzip/-/seek-bzip-1.0.6.tgz#35c4171f55a680916b52a07859ecf3b5857f21c4"
-  integrity sha512-e1QtP3YL5tWww8uKaOCQ18UxIT2laNBXHjV/S2WYCiK4udiv8lkG89KRIoCjUagnAmCBurjF4zEVX2ByBbnCjQ==
-  dependencies:
-    commander "^2.8.1"
-
-selenium-server@^3.141.59:
-  version "3.141.59"
-  resolved "https://registry.yarnpkg.com/selenium-server/-/selenium-server-3.141.59.tgz#cbefdf50aae636ee4c67b819532a8233ce3fd6b0"
-  integrity sha512-pL7T1YtAqOEXiBbTx0KdZMkE2U7PYucemd7i0nDLcxcR1APXYZlJfNr5hrvL3mZgwXb7AJEZPINzC6mDU3eP5g==
-
-selenium-webdriver@4.1.1:
-  version "4.1.1"
-  resolved "https://registry.yarnpkg.com/selenium-webdriver/-/selenium-webdriver-4.1.1.tgz#da083177d811f36614950e809e2982570f67d02e"
-  integrity sha512-Fr9e9LC6zvD6/j7NO8M1M/NVxFX67abHcxDJoP5w2KN/Xb1SyYLjMVPGgD14U2TOiKe4XKHf42OmFw9g2JgCBQ==
-  dependencies:
-    jszip "^3.6.0"
-    tmp "^0.2.1"
-    ws ">=7.4.6"
-
-semver-compare@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/semver-compare/-/semver-compare-1.0.0.tgz#0dee216a1c941ab37e9efb1788f6afc5ff5537fc"
-  integrity sha1-De4hahyUGrN+nvsXiPavxf9VN/w=
-
-semver-regex@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/semver-regex/-/semver-regex-2.0.0.tgz#a93c2c5844539a770233379107b38c7b4ac9d338"
-  integrity sha512-mUdIBBvdn0PLOeP3TEkMH7HHeUP3GjsXCwKarjv/kGmUFOYg1VqEemKhoQpWMu6X2I8kHeuVdGibLGkVK+/5Qw==
-
-semver-truncate@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/semver-truncate/-/semver-truncate-1.1.2.tgz#57f41de69707a62709a7e0104ba2117109ea47e8"
-  integrity sha1-V/Qd5pcHpicJp+AQS6IRcQnqR+g=
-  dependencies:
-    semver "^5.3.0"
-
-"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0, semver@^5.6.0:
-  version "5.7.1"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
-  integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
-
-semver@7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.0.0.tgz#5f3ca35761e47e05b206c6daff2cf814f0316b8e"
-  integrity sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==
-
-semver@7.3.5:
-  version "7.3.5"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.5.tgz#0b621c879348d8998e4b0e4be94b3f12e6018ef7"
-  integrity sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==
-  dependencies:
-    lru-cache "^6.0.0"
-
-semver@^6.0.0, semver@^6.1.1, semver@^6.1.2, semver@^6.3.0:
-  version "6.3.0"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
-  integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
-
-semver@^7.3.2, semver@^7.3.4, semver@^7.3.5:
-  version "7.3.7"
-  resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.7.tgz#12c5b649afdbf9049707796e22a4028814ce523f"
-  integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==
-  dependencies:
-    lru-cache "^6.0.0"
-
-sentence-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/sentence-case/-/sentence-case-3.0.4.tgz#3645a7b8c117c787fde8702056225bb62a45131f"
-  integrity sha512-8LS0JInaQMCRoQ7YUytAo/xUu5W2XnQxV2HI/6uM6U7CITS1RqPElr30V6uIqyMKM9lJGRVFy5/4CuzcixNYSg==
-  dependencies:
-    no-case "^3.0.4"
-    tslib "^2.0.3"
-    upper-case-first "^2.0.2"
-
-serialize-error@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/serialize-error/-/serialize-error-7.0.1.tgz#f1360b0447f61ffb483ec4157c737fab7d778e18"
-  integrity sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==
-  dependencies:
-    type-fest "^0.13.1"
-
-serialize-error@^8.0.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/serialize-error/-/serialize-error-8.1.0.tgz#3a069970c712f78634942ddd50fbbc0eaebe2f67"
-  integrity sha512-3NnuWfM6vBYoy5gZFvHiYsVbafvI9vZv/+jlIigFn4oP4zjNPK3LhcY0xSCgeb1a5L8jO71Mit9LlNoi2UfDDQ==
-  dependencies:
-    type-fest "^0.20.2"
-
-serialize-javascript@6.0.0, serialize-javascript@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.0.tgz#efae5d88f45d7924141da8b5c3a7a7e663fefeb8"
-  integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==
-  dependencies:
-    randombytes "^2.1.0"
-
-set-immediate-shim@~1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz#4b2b1b27eb808a9f8dcc481a58e5e56f599f3f61"
-  integrity sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=
-
-setimmediate@^1.0.4:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285"
-  integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=
-
-setprototypeof@1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424"
-  integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==
-
-sha.js@^2.4.0, sha.js@^2.4.8:
-  version "2.4.11"
-  resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
-  integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
-  dependencies:
-    inherits "^2.0.1"
-    safe-buffer "^5.0.1"
-
-shallow-clone@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
-  integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
-  dependencies:
-    kind-of "^6.0.2"
-
-shebang-command@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea"
-  integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=
-  dependencies:
-    shebang-regex "^1.0.0"
-
-shebang-command@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea"
-  integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==
-  dependencies:
-    shebang-regex "^3.0.0"
-
-shebang-regex@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3"
-  integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=
-
-shebang-regex@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
-  integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
-
-shelljs@^0.8.5:
-  version "0.8.5"
-  resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c"
-  integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==
-  dependencies:
-    glob "^7.0.0"
-    interpret "^1.0.0"
-    rechoir "^0.6.2"
-
-side-channel@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf"
-  integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==
-  dependencies:
-    call-bind "^1.0.0"
-    get-intrinsic "^1.0.2"
-    object-inspect "^1.9.0"
-
-signal-exit@^3.0.0, signal-exit@^3.0.2, signal-exit@^3.0.3:
-  version "3.0.7"
-  resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9"
-  integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==
-
-slash@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slash/-/slash-3.0.0.tgz#6539be870c165adbd5240220dbe361f1bc4d4634"
-  integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==
-
-slice-ansi@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-3.0.0.tgz#31ddc10930a1b7e0b67b08c96c2f49b77a789787"
-  integrity sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==
-  dependencies:
-    ansi-styles "^4.0.0"
-    astral-regex "^2.0.0"
-    is-fullwidth-code-point "^3.0.0"
-
-slice-ansi@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
-  integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==
-  dependencies:
-    ansi-styles "^4.0.0"
-    astral-regex "^2.0.0"
-    is-fullwidth-code-point "^3.0.0"
-
-slice-ansi@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-5.0.0.tgz#b73063c57aa96f9cd881654b15294d95d285c42a"
-  integrity sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==
-  dependencies:
-    ansi-styles "^6.0.0"
-    is-fullwidth-code-point "^4.0.0"
-
-snake-case@^3.0.4:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz#4f2bbd568e9935abdfd593f34c691dadb49c452c"
-  integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg==
-  dependencies:
-    dot-case "^3.0.4"
-    tslib "^2.0.3"
-
-socket.io-adapter@~2.4.0:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/socket.io-adapter/-/socket.io-adapter-2.4.0.tgz#b50a4a9ecdd00c34d4c8c808224daa1a786152a6"
-  integrity sha512-W4N+o69rkMEGVuk2D/cvca3uYsvGlMwsySWV447y99gUPghxq42BxqLNMndb+a1mm/5/7NeXVQS7RLa2XyXvYg==
-
-socket.io-parser@~4.0.4:
-  version "4.0.4"
-  resolved "https://registry.yarnpkg.com/socket.io-parser/-/socket.io-parser-4.0.4.tgz#9ea21b0d61508d18196ef04a2c6b9ab630f4c2b0"
-  integrity sha512-t+b0SS+IxG7Rxzda2EVvyBZbvFPBCjJoyHuE0P//7OAsN23GItzDRdWa6ALxZI/8R5ygK7jAR6t028/z+7295g==
-  dependencies:
-    "@types/component-emitter" "^1.2.10"
-    component-emitter "~1.3.0"
-    debug "~4.3.1"
-
-socket.io@^4.4.1:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/socket.io/-/socket.io-4.5.0.tgz#78ae2e84784c29267086a416620c18ef95b37186"
-  integrity sha512-slTYqU2jCgMjXwresG8grhUi/cC6GjzmcfqArzaH3BN/9I/42eZk9yamNvZJdBfTubkjEdKAKs12NEztId+bUA==
-  dependencies:
-    accepts "~1.3.4"
-    base64id "~2.0.0"
-    debug "~4.3.2"
-    engine.io "~6.2.0"
-    socket.io-adapter "~2.4.0"
-    socket.io-parser "~4.0.4"
-
-sort-keys-length@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/sort-keys-length/-/sort-keys-length-1.0.1.tgz#9cb6f4f4e9e48155a6aa0671edd336ff1479a188"
-  integrity sha1-nLb09OnkgVWmqgZx7dM2/xR5oYg=
-  dependencies:
-    sort-keys "^1.0.0"
-
-sort-keys@^1.0.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/sort-keys/-/sort-keys-1.1.2.tgz#441b6d4d346798f1b4e49e8920adfba0e543f9ad"
-  integrity sha1-RBttTTRnmPG05J6JIK37oOVD+a0=
-  dependencies:
-    is-plain-obj "^1.0.0"
-
-sort-keys@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/sort-keys/-/sort-keys-2.0.0.tgz#658535584861ec97d730d6cf41822e1f56684128"
-  integrity sha1-ZYU1WEhh7JfXMNbPQYIuH1ZoQSg=
-  dependencies:
-    is-plain-obj "^1.0.0"
-
-source-map-resolve@^0.5.2:
-  version "0.5.3"
-  resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.5.3.tgz#190866bece7553e1f8f267a2ee82c606b5509a1a"
-  integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==
-  dependencies:
-    atob "^2.1.2"
-    decode-uri-component "^0.2.0"
-    resolve-url "^0.2.1"
-    source-map-url "^0.4.0"
-    urix "^0.1.0"
-
-source-map-support@^0.5.16, source-map-support@~0.5.20:
-  version "0.5.21"
-  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
-  integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
-  dependencies:
-    buffer-from "^1.0.0"
-    source-map "^0.6.0"
-
-source-map-url@^0.4.0:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56"
-  integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==
-
-source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
-source-map@^0.7.3:
-  version "0.7.3"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.7.3.tgz#5302f8169031735226544092e64981f751750383"
-  integrity sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==
-
-source-map@~0.5.3:
-  version "0.5.7"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
-  integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
-
-source-map@~0.8.0-beta.0:
-  version "0.8.0-beta.0"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.8.0-beta.0.tgz#d4c1bb42c3f7ee925f005927ba10709e0d1d1f11"
-  integrity sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==
-  dependencies:
-    whatwg-url "^7.0.0"
-
-sourcemap-codec@^1.4.8:
-  version "1.4.8"
-  resolved "https://registry.yarnpkg.com/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz#ea804bd94857402e6992d05a38ef1ae35a9ab4c4"
-  integrity sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==
-
-spdx-correct@^3.0.0:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/spdx-correct/-/spdx-correct-3.1.1.tgz#dece81ac9c1e6713e5f7d1b6f17d468fa53d89a9"
-  integrity sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==
-  dependencies:
-    spdx-expression-parse "^3.0.0"
-    spdx-license-ids "^3.0.0"
-
-spdx-exceptions@^2.1.0:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz#3f28ce1a77a00372683eade4a433183527a2163d"
-  integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==
-
-spdx-expression-parse@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz#cf70f50482eefdc98e3ce0a6833e4a53ceeba679"
-  integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==
-  dependencies:
-    spdx-exceptions "^2.1.0"
-    spdx-license-ids "^3.0.0"
-
-spdx-license-ids@^3.0.0:
-  version "3.0.11"
-  resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz#50c0d8c40a14ec1bf449bae69a0ea4685a9d9f95"
-  integrity sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==
-
-split2@^3.0.0:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f"
-  integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==
-  dependencies:
-    readable-stream "^3.0.0"
-
-split@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9"
-  integrity sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==
-  dependencies:
-    through "2"
-
-sprintf-js@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.1.2.tgz#da1765262bf8c0f571749f2ad6c26300207ae673"
-  integrity sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==
-
-sprintf-js@~1.0.2:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c"
-  integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=
-
-sshpk@^1.7.0:
-  version "1.17.0"
-  resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.17.0.tgz#578082d92d4fe612b13007496e543fa0fbcbe4c5"
-  integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ==
-  dependencies:
-    asn1 "~0.2.3"
-    assert-plus "^1.0.0"
-    bcrypt-pbkdf "^1.0.0"
-    dashdash "^1.12.0"
-    ecc-jsbn "~0.1.1"
-    getpass "^0.1.1"
-    jsbn "~0.1.0"
-    safer-buffer "^2.0.2"
-    tweetnacl "~0.14.0"
-
-stacktrace-parser@0.1.10:
-  version "0.1.10"
-  resolved "https://registry.yarnpkg.com/stacktrace-parser/-/stacktrace-parser-0.1.10.tgz#29fb0cae4e0d0b85155879402857a1639eb6051a"
-  integrity sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==
-  dependencies:
-    type-fest "^0.7.1"
-
-statuses@2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-2.0.1.tgz#55cb000ccf1d48728bd23c685a063998cf1a1b63"
-  integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==
-
-statuses@~1.5.0:
-  version "1.5.0"
-  resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c"
-  integrity sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=
-
-stream-browserify@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/stream-browserify/-/stream-browserify-3.0.0.tgz#22b0a2850cdf6503e73085da1fc7b7d0c2122f2f"
-  integrity sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==
-  dependencies:
-    inherits "~2.0.4"
-    readable-stream "^3.5.0"
-
-stream-events@^1.0.5:
-  version "1.0.5"
-  resolved "https://registry.yarnpkg.com/stream-events/-/stream-events-1.0.5.tgz#bbc898ec4df33a4902d892333d47da9bf1c406d5"
-  integrity sha512-E1GUzBSgvct8Jsb3v2X15pjzN1tYebtbLaMg+eBOUOAxgbLoSbT2NS91ckc5lJD1KfLjId+jXJRgo0qnV5Nerg==
-  dependencies:
-    stubs "^3.0.0"
-
-stream-http@^3.1.0:
-  version "3.2.0"
-  resolved "https://registry.yarnpkg.com/stream-http/-/stream-http-3.2.0.tgz#1872dfcf24cb15752677e40e5c3f9cc1926028b5"
-  integrity sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==
-  dependencies:
-    builtin-status-codes "^3.0.0"
-    inherits "^2.0.4"
-    readable-stream "^3.6.0"
-    xtend "^4.0.2"
-
-streamroller@^3.0.8:
-  version "3.0.8"
-  resolved "https://registry.yarnpkg.com/streamroller/-/streamroller-3.0.8.tgz#84b190e4080ee311ca1ebe0444e30ac8eedd028d"
-  integrity sha512-VI+ni3czbFZrd1MrlybxykWZ8sMDCMtTU7YJyhgb9M5X6d1DDxLdJr+gSnmRpXPMnIWxWKMaAE8K0WumBp3lDg==
-  dependencies:
-    date-format "^4.0.9"
-    debug "^4.3.4"
-    fs-extra "^10.1.0"
-
-strict-uri-encode@^1.0.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz#279b225df1d582b1f54e65addd4352e18faa0713"
-  integrity sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=
-
-string-argv@^0.3.1:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/string-argv/-/string-argv-0.3.1.tgz#95e2fbec0427ae19184935f816d74aaa4c5c19da"
-  integrity sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==
-
-string-width@^2.1.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.1.1.tgz#ab93f27a8dc13d28cac815c462143a6d9012ae9e"
-  integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==
-  dependencies:
-    is-fullwidth-code-point "^2.0.0"
-    strip-ansi "^4.0.0"
-
-string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.2, string-width@^4.2.3:
-  version "4.2.3"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
-  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.1"
-
-string-width@^5.0.0:
-  version "5.1.2"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
-  integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==
-  dependencies:
-    eastasianwidth "^0.2.0"
-    emoji-regex "^9.2.2"
-    strip-ansi "^7.0.1"
-
-string.prototype.trimend@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz#e75ae90c2942c63504686c18b287b4a0b1a45f80"
-  integrity sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-
-string.prototype.trimstart@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz#b36399af4ab2999b4c9c648bd7a3fb2bb26feeed"
-  integrity sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==
-  dependencies:
-    call-bind "^1.0.2"
-    define-properties "^1.1.3"
-
-string_decoder@^1.1.1, string_decoder@^1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
-  integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
-  dependencies:
-    safe-buffer "~5.2.0"
-
-string_decoder@~1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
-  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
-  dependencies:
-    safe-buffer "~5.1.0"
-
-strip-ansi@6.0.1, strip-ansi@^6.0.0, strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
-strip-ansi@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f"
-  integrity sha1-qEeQIusaw2iocTibY1JixQXuNo8=
-  dependencies:
-    ansi-regex "^3.0.0"
-
-strip-ansi@^5.1.0:
-  version "5.2.0"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-5.2.0.tgz#8c9a536feb6afc962bdfa5b104a5091c1ad9c0ae"
-  integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==
-  dependencies:
-    ansi-regex "^4.1.0"
-
-strip-ansi@^7.0.1:
-  version "7.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.0.1.tgz#61740a08ce36b61e50e65653f07060d000975fb2"
-  integrity sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw==
-  dependencies:
-    ansi-regex "^6.0.1"
-
-strip-bom@4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-4.0.0.tgz#9c3505c1db45bcedca3d9cf7a16f5c5aa3901878"
-  integrity sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==
-
-strip-bom@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3"
-  integrity sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=
-
-strip-dirs@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/strip-dirs/-/strip-dirs-2.1.0.tgz#4987736264fc344cf20f6c34aca9d13d1d4ed6c5"
-  integrity sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==
-  dependencies:
-    is-natural-number "^4.0.1"
-
-strip-eof@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf"
-  integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=
-
-strip-final-newline@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-final-newline/-/strip-final-newline-2.0.0.tgz#89b852fb2fcbe936f6f4b3187afb0a12c1ab58ad"
-  integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==
-
-strip-indent@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
-  integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
-
-strip-indent@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
-  integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==
-  dependencies:
-    min-indent "^1.0.0"
-
-strip-json-comments@3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.0.1.tgz#85713975a91fb87bf1b305cca77395e40d2a64a7"
-  integrity sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==
-
-strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
-  integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
-
-strip-outer@^1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/strip-outer/-/strip-outer-1.0.1.tgz#b2fd2abf6604b9d1e6013057195df836b8a9d631"
-  integrity sha512-k55yxKHwaXnpYGsOzg4Vl8+tDrWylxDEpknGjhTiZB8dFRU5rTo9CAzeycivxV3s+zlTKwrs6WxMxR95n26kwg==
-  dependencies:
-    escape-string-regexp "^1.0.2"
-
-stubs@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/stubs/-/stubs-3.0.0.tgz#e8d2ba1fa9c90570303c030b6900f7d5f89abe5b"
-  integrity sha1-6NK6H6nJBXAwPAMLaQD31fiavls=
-
-supports-color@8.1.1, supports-color@^8.0.0:
-  version "8.1.1"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c"
-  integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-color@^5.3.0:
-  version "5.5.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
-  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
-  dependencies:
-    has-flag "^3.0.0"
-
-supports-color@^7.1.0:
-  version "7.2.0"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da"
-  integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==
-  dependencies:
-    has-flag "^4.0.0"
-
-supports-color@^9.2.1:
-  version "9.2.2"
-  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-9.2.2.tgz#502acaf82f2b7ee78eb7c83dcac0f89694e5a7bb"
-  integrity sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==
-
-supports-preserve-symlinks-flag@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09"
-  integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==
-
-tapable@^2.1.1, tapable@^2.2.0:
-  version "2.2.1"
-  resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0"
-  integrity sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==
-
-tar-fs@2.1.1, tar-fs@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-2.1.1.tgz#489a15ab85f1f0befabb370b7de4f9eb5cbe8784"
-  integrity sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==
-  dependencies:
-    chownr "^1.1.1"
-    mkdirp-classic "^0.5.2"
-    pump "^3.0.0"
-    tar-stream "^2.1.4"
-
-tar-stream@^1.5.2:
-  version "1.6.2"
-  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-1.6.2.tgz#8ea55dab37972253d9a9af90fdcd559ae435c555"
-  integrity sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==
-  dependencies:
-    bl "^1.0.0"
-    buffer-alloc "^1.2.0"
-    end-of-stream "^1.0.0"
-    fs-constants "^1.0.0"
-    readable-stream "^2.3.0"
-    to-buffer "^1.1.1"
-    xtend "^4.0.0"
-
-tar-stream@^2.1.4, tar-stream@^2.2.0:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287"
-  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
-  dependencies:
-    bl "^4.0.3"
-    end-of-stream "^1.4.1"
-    fs-constants "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^3.1.1"
-
-tcp-port-used@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/tcp-port-used/-/tcp-port-used-1.0.2.tgz#9652b7436eb1f4cfae111c79b558a25769f6faea"
-  integrity sha512-l7ar8lLUD3XS1V2lfoJlCBaeoaWo/2xfYt81hM7VlvR4RrMVFqfmzfhLVk40hAb368uitje5gPtBRL1m/DGvLA==
-  dependencies:
-    debug "4.3.1"
-    is2 "^2.0.6"
-
-teeny-request@7.1.1:
-  version "7.1.1"
-  resolved "https://registry.yarnpkg.com/teeny-request/-/teeny-request-7.1.1.tgz#2b0d156f4a8ad81de44303302ba8d7f1f05e20e6"
-  integrity sha512-iwY6rkW5DDGq8hE2YgNQlKbptYpY5Nn2xecjQiNjOXWbKzPGUfmeUBCSQbbr306d7Z7U2N0TPl+/SwYRfua1Dg==
-  dependencies:
-    http-proxy-agent "^4.0.0"
-    https-proxy-agent "^5.0.0"
-    node-fetch "^2.6.1"
-    stream-events "^1.0.5"
-    uuid "^8.0.0"
-
-terser-webpack-plugin@^5.1.3:
-  version "5.3.1"
-  resolved "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.3.1.tgz#0320dcc270ad5372c1e8993fabbd927929773e54"
-  integrity sha512-GvlZdT6wPQKbDNW/GDQzZFg/j4vKU96yl2q6mcUkzKOgW4gwf1Z8cZToUCrz31XHlPWH8MVb1r2tFtdDtTGJ7g==
-  dependencies:
-    jest-worker "^27.4.5"
-    schema-utils "^3.1.1"
-    serialize-javascript "^6.0.0"
-    source-map "^0.6.1"
-    terser "^5.7.2"
-
-terser@^5.13.1, terser@^5.7.2:
-  version "5.13.1"
-  resolved "https://registry.yarnpkg.com/terser/-/terser-5.13.1.tgz#66332cdc5a01b04a224c9fad449fc1a18eaa1799"
-  integrity sha512-hn4WKOfwnwbYfe48NgrQjqNOH9jzLqRcIfbYytOXCOv46LBfWr9bDS17MQqOi+BWGD0sJK3Sj5NC/gJjiojaoA==
-  dependencies:
-    acorn "^8.5.0"
-    commander "^2.20.0"
-    source-map "~0.8.0-beta.0"
-    source-map-support "~0.5.20"
-
-test-exclude@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-6.0.0.tgz#04a8698661d805ea6fa293b6cb9e63ac044ef15e"
-  integrity sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==
-  dependencies:
-    "@istanbuljs/schema" "^0.1.2"
-    glob "^7.1.4"
-    minimatch "^3.0.4"
-
-text-extensions@^1.0.0:
-  version "1.9.0"
-  resolved "https://registry.yarnpkg.com/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26"
-  integrity sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==
-
-text-table@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4"
-  integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=
-
-throttleit@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/throttleit/-/throttleit-1.0.0.tgz#9e785836daf46743145a5984b6268d828528ac6c"
-  integrity sha1-nnhYNtr0Z0MUWlmEtiaNgoUorGw=
-
-through2@^2.0.0:
-  version "2.0.5"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd"
-  integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==
-  dependencies:
-    readable-stream "~2.3.6"
-    xtend "~4.0.1"
-
-through2@^4.0.0:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764"
-  integrity sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==
-  dependencies:
-    readable-stream "3"
-
-through@2, "through@>=2.2.7 <3", through@^2.3.6, through@^2.3.8:
-  version "2.3.8"
-  resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
-  integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=
-
-timed-out@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/timed-out/-/timed-out-4.0.1.tgz#f32eacac5a175bea25d7fab565ab3ed8741ef56f"
-  integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=
-
-timers-browserify@^2.0.11:
-  version "2.0.12"
-  resolved "https://registry.yarnpkg.com/timers-browserify/-/timers-browserify-2.0.12.tgz#44a45c11fbf407f34f97bccd1577c652361b00ee"
-  integrity sha512-9phl76Cqm6FhSX9Xe1ZUAMLtm1BLkKj2Qd5ApyWkXzsMRaA7dgr81kf4wJmQf/hAvg8EEyJxDo3du/0KlhPiKQ==
-  dependencies:
-    setimmediate "^1.0.4"
-
-tmp@^0.0.33:
-  version "0.0.33"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.0.33.tgz#6d34335889768d21b2bcda0aa277ced3b1bfadf9"
-  integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==
-  dependencies:
-    os-tmpdir "~1.0.2"
-
-tmp@^0.2.1:
-  version "0.2.1"
-  resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14"
-  integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==
-  dependencies:
-    rimraf "^3.0.0"
-
-to-buffer@^1.1.1:
-  version "1.1.1"
-  resolved "https://registry.yarnpkg.com/to-buffer/-/to-buffer-1.1.1.tgz#493bd48f62d7c43fcded313a03dcadb2e1213a80"
-  integrity sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==
-
-to-fast-properties@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
-  integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=
-
-to-regex-range@^5.0.1:
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
-  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
-  dependencies:
-    is-number "^7.0.0"
-
-toidentifier@1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35"
-  integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==
-
-tough-cookie@~2.5.0:
-  version "2.5.0"
-  resolved "https://registry.yarnpkg.com/tough-cookie/-/tough-cookie-2.5.0.tgz#cd9fb2a0aa1d5a12b473bd9fb96fa3dcff65ade2"
-  integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==
-  dependencies:
-    psl "^1.1.28"
-    punycode "^2.1.1"
-
-tr46@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/tr46/-/tr46-1.0.1.tgz#a8b13fd6bfd2489519674ccde55ba3693b706d09"
-  integrity sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=
-  dependencies:
-    punycode "^2.1.0"
-
-tr46@~0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a"
-  integrity sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=
-
-trim-newlines@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144"
-  integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==
-
-trim-repeated@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/trim-repeated/-/trim-repeated-1.0.0.tgz#e3646a2ea4e891312bf7eace6cfb05380bc01c21"
-  integrity sha1-42RqLqTokTEr9+rObPsFOAvAHCE=
-  dependencies:
-    escape-string-regexp "^1.0.2"
-
-ts-loader@^9.2.9:
-  version "9.3.0"
-  resolved "https://registry.yarnpkg.com/ts-loader/-/ts-loader-9.3.0.tgz#980f4dbfb60e517179e15e10ed98e454b132159f"
-  integrity sha512-2kLLAdAD+FCKijvGKi9sS0OzoqxLCF3CxHpok7rVgCZ5UldRzH0TkbwG9XECKjBzHsAewntC5oDaI/FwKzEUog==
-  dependencies:
-    chalk "^4.1.0"
-    enhanced-resolve "^5.0.0"
-    micromatch "^4.0.0"
-    semver "^7.3.4"
-
-ts-node@^10.7.0:
-  version "10.7.0"
-  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.7.0.tgz#35d503d0fab3e2baa672a0e94f4b40653c2463f5"
-  integrity sha512-TbIGS4xgJoX2i3do417KSaep1uRAW/Lu+WAL2doDHC0D6ummjirVOXU5/7aiZotbQ5p1Zp9tP7U6cYhA0O7M8A==
-  dependencies:
-    "@cspotcode/source-map-support" "0.7.0"
-    "@tsconfig/node10" "^1.0.7"
-    "@tsconfig/node12" "^1.0.7"
-    "@tsconfig/node14" "^1.0.0"
-    "@tsconfig/node16" "^1.0.2"
-    acorn "^8.4.1"
-    acorn-walk "^8.1.1"
-    arg "^4.1.0"
-    create-require "^1.1.0"
-    diff "^4.0.1"
-    make-error "^1.1.1"
-    v8-compile-cache-lib "^3.0.0"
-    yn "3.1.1"
-
-tslib@^1.8.1, tslib@^1.9.0:
-  version "1.14.1"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"
-  integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==
-
-tslib@^2.0.3, tslib@^2.1.0, tslib@^2.3.1, tslib@^2.4.0:
-  version "2.4.0"
-  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.4.0.tgz#7cecaa7f073ce680a05847aa77be941098f36dc3"
-  integrity sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==
-
-tsutils@^3.21.0:
-  version "3.21.0"
-  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
-  integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
-  dependencies:
-    tslib "^1.8.1"
-
-tty-browserify@^0.0.1:
-  version "0.0.1"
-  resolved "https://registry.yarnpkg.com/tty-browserify/-/tty-browserify-0.0.1.tgz#3f05251ee17904dfd0677546670db9651682b811"
-  integrity sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==
-
-tunnel-agent@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
-  integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=
-  dependencies:
-    safe-buffer "^5.0.1"
-
-tunnel@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/tunnel/-/tunnel-0.0.6.tgz#72f1314b34a5b192db012324df2cc587ca47f92c"
-  integrity sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==
-
-tweetnacl@^0.14.3, tweetnacl@~0.14.0:
-  version "0.14.5"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
-  integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=
-
-type-check@^0.4.0, type-check@~0.4.0:
-  version "0.4.0"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
-  integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==
-  dependencies:
-    prelude-ls "^1.2.1"
-
-type-check@~0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
-  integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=
-  dependencies:
-    prelude-ls "~1.1.2"
-
-type-detect@4.0.8, type-detect@^4.0.0:
-  version "4.0.8"
-  resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-4.0.8.tgz#7646fb5f18871cfbb7749e69bd39a6388eb7450c"
-  integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==
-
-type-fest@^0.13.1:
-  version "0.13.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.13.1.tgz#0172cb5bce80b0bd542ea348db50c7e21834d934"
-  integrity sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==
-
-type-fest@^0.18.0:
-  version "0.18.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f"
-  integrity sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==
-
-type-fest@^0.20.2:
-  version "0.20.2"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4"
-  integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==
-
-type-fest@^0.21.3:
-  version "0.21.3"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
-  integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
-
-type-fest@^0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b"
-  integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==
-
-type-fest@^0.7.1:
-  version "0.7.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.7.1.tgz#8dda65feaf03ed78f0a3f9678f1869147f7c5c48"
-  integrity sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==
-
-type-fest@^0.8.1:
-  version "0.8.1"
-  resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.8.1.tgz#09e249ebde851d3b1e48d27c105444667f17b83d"
-  integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==
-
-type-is@~1.6.18:
-  version "1.6.18"
-  resolved "https://registry.yarnpkg.com/type-is/-/type-is-1.6.18.tgz#4e552cd05df09467dcbc4ef739de89f2cf37c131"
-  integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==
-  dependencies:
-    media-typer "0.3.0"
-    mime-types "~2.1.24"
-
-typedarray@^0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
-  integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
-
-typescript@^4.4.3, typescript@^4.6.4:
-  version "4.6.4"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.6.4.tgz#caa78bbc3a59e6a5c510d35703f6a09877ce45e9"
-  integrity sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg==
-
-ua-parser-js@^0.7.21, ua-parser-js@^0.7.30:
-  version "0.7.31"
-  resolved "https://registry.yarnpkg.com/ua-parser-js/-/ua-parser-js-0.7.31.tgz#649a656b191dffab4f21d5e053e27ca17cbff5c6"
-  integrity sha512-qLK/Xe9E2uzmYI3qLeOmI0tEOt+TBBQyUIAh4aAgU05FVYzeZrKUdkAZfBNVGRaHVgV0TDkdEngJSw/SyQchkQ==
-
-uglify-js@^3.1.4:
-  version "3.15.4"
-  resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.15.4.tgz#fa95c257e88f85614915b906204b9623d4fa340d"
-  integrity sha512-vMOPGDuvXecPs34V74qDKk4iJ/SN4vL3Ow/23ixafENYvtrNvtbcgUeugTcUGRGsOF/5fU8/NYSL5Hyb3l1OJA==
-
-unbox-primitive@^1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e"
-  integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==
-  dependencies:
-    call-bind "^1.0.2"
-    has-bigints "^1.0.2"
-    has-symbols "^1.0.3"
-    which-boxed-primitive "^1.0.2"
-
-unbzip2-stream@1.4.3, unbzip2-stream@^1.0.9, unbzip2-stream@^1.3.3:
-  version "1.4.3"
-  resolved "https://registry.yarnpkg.com/unbzip2-stream/-/unbzip2-stream-1.4.3.tgz#b0da04c4371311df771cdc215e87f2130991ace7"
-  integrity sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==
-  dependencies:
-    buffer "^5.2.1"
-    through "^2.3.8"
-
-unicode-canonical-property-names-ecmascript@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.0.tgz#301acdc525631670d39f6146e0e77ff6bbdebddc"
-  integrity sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==
-
-unicode-match-property-ecmascript@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz#54fd16e0ecb167cf04cf1f756bdcc92eba7976c3"
-  integrity sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==
-  dependencies:
-    unicode-canonical-property-names-ecmascript "^2.0.0"
-    unicode-property-aliases-ecmascript "^2.0.0"
-
-unicode-match-property-value-ecmascript@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.0.0.tgz#1a01aa57247c14c568b89775a54938788189a714"
-  integrity sha512-7Yhkc0Ye+t4PNYzOGKedDhXbYIBe1XEQYQxOPyhcXNMJ0WCABqqj6ckydd6pWRZTHV4GuCPKdBAUiMc60tsKVw==
-
-unicode-property-aliases-ecmascript@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.0.0.tgz#0a36cb9a585c4f6abd51ad1deddb285c165297c8"
-  integrity sha512-5Zfuy9q/DFr4tfO7ZPeVXb1aPoeQSdeFMLpYuFebehDAhbuevLs5yxSZmIFN1tP5F9Wl4IpJrYojg85/zgyZHQ==
-
-union@~0.5.0:
-  version "0.5.0"
-  resolved "https://registry.yarnpkg.com/union/-/union-0.5.0.tgz#b2c11be84f60538537b846edb9ba266ba0090075"
-  integrity sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==
-  dependencies:
-    qs "^6.4.0"
-
-universalify@^0.1.0:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
-  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
-
-universalify@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.0.tgz#75a4984efedc4b08975c5aeb73f530d02df25717"
-  integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==
-
-unpipe@1.0.0, unpipe@~1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unpipe/-/unpipe-1.0.0.tgz#b2bf4ee8514aae6165b4817829d21b2ef49904ec"
-  integrity sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=
-
-upath2@^3.1.12:
-  version "3.1.12"
-  resolved "https://registry.yarnpkg.com/upath2/-/upath2-3.1.12.tgz#441b3dfbadde21731017bd1b7beb169498efd0a9"
-  integrity sha512-yC3eZeCyCXFWjy7Nu4pgjLhXNYjuzuUmJiRgSSw6TJp8Emc+E4951HGPJf+bldFC5SL7oBLeNbtm1fGzXn2gxw==
-  dependencies:
-    path-is-network-drive "^1.0.13"
-    path-strip-sep "^1.0.10"
-    tslib "^2.3.1"
-
-upper-case-first@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/upper-case-first/-/upper-case-first-2.0.2.tgz#992c3273f882abd19d1e02894cc147117f844324"
-  integrity sha512-514ppYHBaKwfJRK/pNC6c/OxfGa0obSnAl106u97Ed0I625Nin96KAjttZF6ZL3e1XLtphxnqrOi9iWgm+u+bg==
-  dependencies:
-    tslib "^2.0.3"
-
-upper-case@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/upper-case/-/upper-case-2.0.2.tgz#d89810823faab1df1549b7d97a76f8662bae6f7a"
-  integrity sha512-KgdgDGJt2TpuwBUIjgG6lzw2GWFRCW9Qkfkiv0DxqHHLYJHmtmdUIKcZd8rHgFSjopVTlw6ggzCm1b8MFQwikg==
-  dependencies:
-    tslib "^2.0.3"
-
-uri-js@^4.2.2:
-  version "4.4.1"
-  resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e"
-  integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==
-  dependencies:
-    punycode "^2.1.0"
-
-urix@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72"
-  integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=
-
-url-join@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/url-join/-/url-join-4.0.1.tgz#b642e21a2646808ffa178c4c5fda39844e12cde7"
-  integrity sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==
-
-url-parse-lax@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/url-parse-lax/-/url-parse-lax-3.0.0.tgz#16b5cafc07dbe3676c1b1999177823d6503acb0c"
-  integrity sha1-FrXK/Afb42dsGxmZF3gj1lA6yww=
-  dependencies:
-    prepend-http "^2.0.0"
-
-url-to-options@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/url-to-options/-/url-to-options-1.0.1.tgz#1505a03a289a48cbd7a434efbaeec5055f5633a9"
-  integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=
-
-url@^0.11.0:
-  version "0.11.0"
-  resolved "https://registry.yarnpkg.com/url/-/url-0.11.0.tgz#3838e97cfc60521eb73c525a8e55bfdd9e2e28f1"
-  integrity sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=
-  dependencies:
-    punycode "1.3.2"
-    querystring "0.2.0"
-
-urlgrey@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/urlgrey/-/urlgrey-1.0.0.tgz#72d2f904482d0b602e3c7fa599343d699bbe1017"
-  integrity sha512-hJfIzMPJmI9IlLkby8QrsCykQ+SXDeO2W5Q9QTW3QpqZVTx4a/K7p8/5q+/isD8vsbVaFgql/gvAoQCRQ2Cb5w==
-  dependencies:
-    fast-url-parser "^1.1.3"
-
-util-deprecate@^1.0.1, util-deprecate@~1.0.1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
-  integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
-
-util@^0.12.0, util@^0.12.1:
-  version "0.12.4"
-  resolved "https://registry.yarnpkg.com/util/-/util-0.12.4.tgz#66121a31420df8f01ca0c464be15dfa1d1850253"
-  integrity sha512-bxZ9qtSlGUWSOy9Qa9Xgk11kSslpuZwaxCg4sNIDj6FLucDab2JxnHwyNTCpHMtK1MjoQiWQ6DiUMZYbSrO+Sw==
-  dependencies:
-    inherits "^2.0.3"
-    is-arguments "^1.0.4"
-    is-generator-function "^1.0.7"
-    is-typed-array "^1.1.3"
-    safe-buffer "^5.1.2"
-    which-typed-array "^1.1.2"
-
-utils-merge@1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/utils-merge/-/utils-merge-1.0.1.tgz#9f95710f50a267947b2ccc124741c1028427e713"
-  integrity sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=
-
-uuid@^3.3.2:
-  version "3.4.0"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-3.4.0.tgz#b23e4358afa8a202fe7a100af1f5f883f02007ee"
-  integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==
-
-uuid@^8.0.0:
-  version "8.3.2"
-  resolved "https://registry.yarnpkg.com/uuid/-/uuid-8.3.2.tgz#80d5b5ced271bb9af6c445f21a1a04c606cefbe2"
-  integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==
-
-v8-compile-cache-lib@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
-  integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
-
-v8-compile-cache@^2.0.3:
-  version "2.3.0"
-  resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
-  integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==
-
-validate-npm-package-license@^3.0.1:
-  version "3.0.4"
-  resolved "https://registry.yarnpkg.com/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz#fc91f6b9c7ba15c857f4cb2c5defeec39d4f410a"
-  integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==
-  dependencies:
-    spdx-correct "^3.0.0"
-    spdx-expression-parse "^3.0.0"
-
-vary@^1:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/vary/-/vary-1.1.2.tgz#2299f02c6ded30d4a5961b0b9f74524a18f634fc"
-  integrity sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=
-
-verror@1.10.0:
-  version "1.10.0"
-  resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400"
-  integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=
-  dependencies:
-    assert-plus "^1.0.0"
-    core-util-is "1.0.2"
-    extsprintf "^1.2.0"
-
-vm-browserify@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0"
-  integrity sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==
-
-void-elements@^2.0.0:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/void-elements/-/void-elements-2.0.1.tgz#c066afb582bb1cb4128d60ea92392e94d5e9dbec"
-  integrity sha1-wGavtYK7HLQSjWDqkjkulNXp2+w=
-
-watchpack@^2.3.1:
-  version "2.3.1"
-  resolved "https://registry.yarnpkg.com/watchpack/-/watchpack-2.3.1.tgz#4200d9447b401156eeca7767ee610f8809bc9d25"
-  integrity sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==
-  dependencies:
-    glob-to-regexp "^0.4.1"
-    graceful-fs "^4.1.2"
-
-wcwidth@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/wcwidth/-/wcwidth-1.0.1.tgz#f0b0dcf915bc5ff1528afadb2c0e17b532da2fe8"
-  integrity sha1-8LDc+RW8X/FSivrbLA4XtTLaL+g=
-  dependencies:
-    defaults "^1.0.3"
-
-webdriver@6.12.1:
-  version "6.12.1"
-  resolved "https://registry.yarnpkg.com/webdriver/-/webdriver-6.12.1.tgz#30eee65340ea5124aa564f99a4dbc7d2f965b308"
-  integrity sha512-3rZgAj9o2XHp16FDTzvUYaHelPMSPbO1TpLIMUT06DfdZjNYIzZiItpIb/NbQDTPmNhzd9cuGmdI56WFBGY2BA==
-  dependencies:
-    "@wdio/config" "6.12.1"
-    "@wdio/logger" "6.10.10"
-    "@wdio/protocols" "6.12.0"
-    "@wdio/utils" "6.11.0"
-    got "^11.0.2"
-    lodash.merge "^4.6.1"
-
-webdriverio@^6.7.0:
-  version "6.12.1"
-  resolved "https://registry.yarnpkg.com/webdriverio/-/webdriverio-6.12.1.tgz#5b6f1167373bd7a154419d8a930ef1ffda9d0537"
-  integrity sha512-Nx7ge0vTWHVIRUbZCT+IuMwB5Q0Q5nLlYdgnmmJviUKLuc3XtaEBkYPTbhHWHgSBXsPZMIc023vZKNkn+6iyeQ==
-  dependencies:
-    "@types/puppeteer-core" "^5.4.0"
-    "@wdio/config" "6.12.1"
-    "@wdio/logger" "6.10.10"
-    "@wdio/repl" "6.11.0"
-    "@wdio/utils" "6.11.0"
-    archiver "^5.0.0"
-    atob "^2.1.2"
-    css-shorthand-properties "^1.1.1"
-    css-value "^0.0.1"
-    devtools "6.12.1"
-    fs-extra "^9.0.1"
-    get-port "^5.1.1"
-    grapheme-splitter "^1.0.2"
-    lodash.clonedeep "^4.5.0"
-    lodash.isobject "^3.0.2"
-    lodash.isplainobject "^4.0.6"
-    lodash.zip "^4.2.0"
-    minimatch "^3.0.4"
-    puppeteer-core "^5.1.0"
-    resq "^1.9.1"
-    rgb2hex "0.2.3"
-    serialize-error "^8.0.0"
-    webdriver "6.12.1"
-
-webidl-conversions@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871"
-  integrity sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=
-
-webidl-conversions@^4.0.2:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-4.0.2.tgz#a855980b1f0b6b359ba1d5d9fb39ae941faa63ad"
-  integrity sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==
-
-webpack-merge@^4.1.5:
-  version "4.2.2"
-  resolved "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-4.2.2.tgz#a27c52ea783d1398afd2087f547d7b9d2f43634d"
-  integrity sha512-TUE1UGoTX2Cd42j3krGYqObZbOD+xF7u28WB7tfUordytSjbWTIjK/8V0amkBfTYN4/pB/GIDlJZZ657BGG19g==
-  dependencies:
-    lodash "^4.17.15"
-
-webpack-sources@^3.2.3:
-  version "3.2.3"
-  resolved "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.2.3.tgz#2d4daab8451fd4b240cc27055ff6a0c2ccea0cde"
-  integrity sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==
-
-webpack@^5, webpack@~5.72.0:
-  version "5.72.0"
-  resolved "https://registry.yarnpkg.com/webpack/-/webpack-5.72.0.tgz#f8bc40d9c6bb489a4b7a8a685101d6022b8b6e28"
-  integrity sha512-qmSmbspI0Qo5ld49htys8GY9XhS9CGqFoHTsOVAnjBdg0Zn79y135R+k4IR4rKK6+eKaabMhJwiVB7xw0SJu5w==
-  dependencies:
-    "@types/eslint-scope" "^3.7.3"
-    "@types/estree" "^0.0.51"
-    "@webassemblyjs/ast" "1.11.1"
-    "@webassemblyjs/wasm-edit" "1.11.1"
-    "@webassemblyjs/wasm-parser" "1.11.1"
-    acorn "^8.4.1"
-    acorn-import-assertions "^1.7.6"
-    browserslist "^4.14.5"
-    chrome-trace-event "^1.0.2"
-    enhanced-resolve "^5.9.2"
-    es-module-lexer "^0.9.0"
-    eslint-scope "5.1.1"
-    events "^3.2.0"
-    glob-to-regexp "^0.4.1"
-    graceful-fs "^4.2.9"
-    json-parse-better-errors "^1.0.2"
-    loader-runner "^4.2.0"
-    mime-types "^2.1.27"
-    neo-async "^2.6.2"
-    schema-utils "^3.1.0"
-    tapable "^2.1.1"
-    terser-webpack-plugin "^5.1.3"
-    watchpack "^2.3.1"
-    webpack-sources "^3.2.3"
-
-weex-js-runtime@^0.23.6:
-  version "0.23.7"
-  resolved "https://registry.yarnpkg.com/weex-js-runtime/-/weex-js-runtime-0.23.7.tgz#c9d3427f2debf1d638ab4e41bb4f0e539a51915c"
-  integrity sha512-3BFd5GXTo0X/GWh0KjzXDpIcPJuSwYuc9fE9llgez35IfVHs/nUmfkFBjifzxOJS2YLhtKf0Cy8eTQ00CJDWZA==
-
-weex-styler@^0.3.0:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/weex-styler/-/weex-styler-0.3.1.tgz#47d0188cc70aff97ccaa3a63b98733d549848680"
-  integrity sha512-xkX5/wS/QLiJXKwbdpeytbLN0kHviQwj9CLdvBxqu+RRZABZpTniKZr1oxjh9Q0+n/aRC+smwFpQpUKvXh9V1g==
-  dependencies:
-    css "~2.2.1"
-
-whatwg-encoding@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/whatwg-encoding/-/whatwg-encoding-2.0.0.tgz#e7635f597fd87020858626805a2729fa7698ac53"
-  integrity sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg==
-  dependencies:
-    iconv-lite "0.6.3"
-
-whatwg-url@^5.0.0:
-  version "5.0.0"
-  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d"
-  integrity sha1-lmRU6HZUYuN2RNNib2dCzotwll0=
-  dependencies:
-    tr46 "~0.0.3"
-    webidl-conversions "^3.0.0"
-
-whatwg-url@^7.0.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-7.1.0.tgz#c2c492f1eca612988efd3d2266be1b9fc6170d06"
-  integrity sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==
-  dependencies:
-    lodash.sortby "^4.7.0"
-    tr46 "^1.0.1"
-    webidl-conversions "^4.0.2"
-
-which-boxed-primitive@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6"
-  integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==
-  dependencies:
-    is-bigint "^1.0.1"
-    is-boolean-object "^1.1.0"
-    is-number-object "^1.0.4"
-    is-string "^1.0.5"
-    is-symbol "^1.0.3"
-
-which-typed-array@^1.1.2:
-  version "1.1.7"
-  resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.7.tgz#2761799b9a22d4b8660b3c1b40abaa7739691793"
-  integrity sha512-vjxaB4nfDqwKI0ws7wZpxIlde1XrLX5uB0ZjpfshgmapJMD7jJWhZI+yToJTqaFByF0eNBcYxbjmCzoRP7CfEw==
-  dependencies:
-    available-typed-arrays "^1.0.5"
-    call-bind "^1.0.2"
-    es-abstract "^1.18.5"
-    foreach "^2.0.5"
-    has-tostringtag "^1.0.0"
-    is-typed-array "^1.1.7"
-
-which@2.0.2, which@^2.0.1, which@^2.0.2:
-  version "2.0.2"
-  resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
-  integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==
-  dependencies:
-    isexe "^2.0.0"
-
-which@^1.2.1, which@^1.2.10, which@^1.2.14, which@^1.2.9:
-  version "1.3.1"
-  resolved "https://registry.yarnpkg.com/which/-/which-1.3.1.tgz#a45043d54f5805316da8d62f9f50918d3da70b0a"
-  integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==
-  dependencies:
-    isexe "^2.0.0"
-
-widest-line@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-3.1.0.tgz#8292333bbf66cb45ff0de1603b136b7ae1496eca"
-  integrity sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==
-  dependencies:
-    string-width "^4.0.0"
-
-word-wrap@^1.0.3, word-wrap@^1.2.3, word-wrap@~1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
-  integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==
-
-wordwrap@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
-  integrity sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=
-
-workerpool@6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.0.tgz#827d93c9ba23ee2019c3ffaff5c27fccea289e8b"
-  integrity sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A==
-
-wrap-ansi@^6.2.0:
-  version "6.2.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
-  integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrap-ansi@^7.0.0:
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
-  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrappy@1:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
-  integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
-
-ws@8.5.0:
-  version "8.5.0"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-8.5.0.tgz#bfb4be96600757fe5382de12c670dab984a1ed4f"
-  integrity sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==
-
-ws@>=7.4.6:
-  version "8.6.0"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-8.6.0.tgz#e5e9f1d9e7ff88083d0c0dd8281ea662a42c9c23"
-  integrity sha512-AzmM3aH3gk0aX7/rZLYvjdvZooofDu3fFOzGqcSnQ1tOcTWwhM/o+q++E8mAyVVIyUdajrkzWUGftaVSDLn1bw==
-
-ws@^7.2.3:
-  version "7.5.7"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.7.tgz#9e0ac77ee50af70d58326ecff7e85eb3fa375e67"
-  integrity sha512-KMvVuFzpKBuiIXW3E4u3mySRO2/mCHSyZDJQM5NQ9Q9KHWHWh0NHgfbRMLLrceUK5qAL4ytALJbpRMjixFZh8A==
-
-ws@~8.2.3:
-  version "8.2.3"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-8.2.3.tgz#63a56456db1b04367d0b721a0b80cae6d8becbba"
-  integrity sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==
-
-xtend@^4.0.0, xtend@^4.0.2, xtend@~4.0.1:
-  version "4.0.2"
-  resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
-  integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
-
-y18n@^5.0.5:
-  version "5.0.8"
-  resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
-  integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
-
-yallist@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-2.1.2.tgz#1c11f9218f076089a47dd512f93c6699a6a81d52"
-  integrity sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=
-
-yallist@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
-  integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
-
-yaml@^1.10.0, yaml@^1.10.2:
-  version "1.10.2"
-  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.2.tgz#2301c5ffbf12b467de8da2333a459e29e7920e4b"
-  integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==
-
-yargs-parser@20.2.4:
-  version "20.2.4"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.4.tgz#b42890f14566796f85ae8e3a25290d205f154a54"
-  integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==
-
-yargs-parser@^20.2.2, yargs-parser@^20.2.3:
-  version "20.2.9"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
-  integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
-
-yargs-parser@^21.0.0:
-  version "21.0.1"
-  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.0.1.tgz#0267f286c877a4f0f728fceb6f8a3e4cb95c6e35"
-  integrity sha512-9BK1jFpLzJROCI5TzwZL/TU4gqjK5xiHV/RfWLOahrjAko/e4DJkRDZQXfvqAsiZzzYhgAzbgz6lg48jcm4GLg==
-
-yargs-unparser@2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/yargs-unparser/-/yargs-unparser-2.0.0.tgz#f131f9226911ae5d9ad38c432fe809366c2325eb"
-  integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==
-  dependencies:
-    camelcase "^6.0.0"
-    decamelize "^4.0.0"
-    flat "^5.0.2"
-    is-plain-obj "^2.1.0"
-
-yargs@16.2.0, yargs@^16.0.3, yargs@^16.1.1, yargs@^16.2.0:
-  version "16.2.0"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66"
-  integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==
-  dependencies:
-    cliui "^7.0.2"
-    escalade "^3.1.1"
-    get-caller-file "^2.0.5"
-    require-directory "^2.1.1"
-    string-width "^4.2.0"
-    y18n "^5.0.5"
-    yargs-parser "^20.2.2"
-
-yargs@^17.0.1:
-  version "17.4.1"
-  resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.4.1.tgz#ebe23284207bb75cee7c408c33e722bfb27b5284"
-  integrity sha512-WSZD9jgobAg3ZKuCQZSa3g9QOJeCCqLoLAykiWgmXnDo9EPnn4RPf5qVTtzgOx66o6/oqhcA5tHtJXpG8pMt3g==
-  dependencies:
-    cliui "^7.0.2"
-    escalade "^3.1.1"
-    get-caller-file "^2.0.5"
-    require-directory "^2.1.1"
-    string-width "^4.2.3"
-    y18n "^5.0.5"
-    yargs-parser "^21.0.0"
-
-yauzl@^2.10.0, yauzl@^2.4.2:
-  version "2.10.0"
-  resolved "https://registry.yarnpkg.com/yauzl/-/yauzl-2.10.0.tgz#c7eb17c93e112cb1086fa6d8e51fb0667b79a5f9"
-  integrity sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=
-  dependencies:
-    buffer-crc32 "~0.2.3"
-    fd-slicer "~1.1.0"
-
-yn@3.1.1:
-  version "3.1.1"
-  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
-  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
-
-yocto-queue@^0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
-  integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
-
-yorkie@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/yorkie/-/yorkie-2.0.0.tgz#92411912d435214e12c51c2ae1093e54b6bb83d9"
-  integrity sha512-jcKpkthap6x63MB4TxwCyuIGkV0oYP/YRyuQU5UO0Yz/E/ZAu+653/uov+phdmO54n6BcvFRyyt0RRrWdN2mpw==
-  dependencies:
-    execa "^0.8.0"
-    is-ci "^1.0.10"
-    normalize-path "^1.0.0"
-    strip-indent "^2.0.0"
-
-zip-stream@^4.1.0:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/zip-stream/-/zip-stream-4.1.0.tgz#51dd326571544e36aa3f756430b313576dc8fc79"
-  integrity sha512-zshzwQW7gG7hjpBlgeQP9RuyPGNxvJdzR8SUM3QhxCnLjWN2E7j3dOvpeDcQoETfHx0urRS7EtmVToql7YpU4A==
-  dependencies:
-    archiver-utils "^2.1.0"
-    compress-commons "^4.1.0"
-    readable-stream "^3.6.0"

From 3421db3b3c9f582a2ab2236286ae7e7e494d96a4 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 16:39:05 +0800
Subject: [PATCH 036/317] build: sort deps again

---
 package.json                                |  2 +-
 packages/vue-server-renderer/package.json   | 10 +++++-----
 packages/vue-template-compiler/package.json |  2 +-
 pnpm-lock.yaml                              |  2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/package.json b/package.json
index 424115ec7d9..ab4d16c9dd8 100644
--- a/package.json
+++ b/package.json
@@ -87,7 +87,7 @@
     "eslint": "^8.14.0",
     "fsevents": "2.3.2",
     "hash-sum": "^2.0.0",
-    "he": "^1.1.1",
+    "he": "^1.2.0",
     "http-server": "^14.1.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
diff --git a/packages/vue-server-renderer/package.json b/packages/vue-server-renderer/package.json
index 307ebb69cd5..cfe59dd3156 100644
--- a/packages/vue-server-renderer/package.json
+++ b/packages/vue-server-renderer/package.json
@@ -19,13 +19,13 @@
     "url": "https://github.com/vuejs/vue/issues"
   },
   "dependencies": {
-    "chalk": "^1.1.3",
-    "hash-sum": "^1.0.2",
-    "he": "^1.1.0",
+    "chalk": "^4.0.0",
+    "hash-sum": "^2.0.0",
+    "he": "^1.2.0",
     "lodash.template": "^4.5.0",
     "lodash.uniq": "^4.5.0",
-    "resolve": "^1.2.0",
-    "serialize-javascript": "^3.1.0",
+    "resolve": "^1.22.0",
+    "serialize-javascript": "^6.0.0",
     "source-map": "0.5.6"
   },
   "devDependencies": {
diff --git a/packages/vue-template-compiler/package.json b/packages/vue-template-compiler/package.json
index c8fff729bc2..4c5068bbab9 100644
--- a/packages/vue-template-compiler/package.json
+++ b/packages/vue-template-compiler/package.json
@@ -22,7 +22,7 @@
   },
   "homepage": "https://github.com/vuejs/vue/tree/dev/packages/vue-template-compiler#readme",
   "dependencies": {
-    "he": "^1.1.0",
+    "he": "^1.2.0",
     "de-indent": "^1.0.2"
   },
   "devDependencies": {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 850f9c23dfc..8b6428e46a3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -21,7 +21,7 @@ specifiers:
   eslint: ^8.14.0
   fsevents: 2.3.2
   hash-sum: ^2.0.0
-  he: ^1.1.1
+  he: ^1.2.0
   http-server: ^14.1.0
   lint-staged: ^12.4.1
   lodash: ^4.17.21

From fe132124560eae83810458519819add8653abff8 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 18:19:58 +0800
Subject: [PATCH 037/317] build: remove stale lockfile

---
 packages/weex-template-compiler/yarn.lock | 97 -----------------------
 1 file changed, 97 deletions(-)
 delete mode 100644 packages/weex-template-compiler/yarn.lock

diff --git a/packages/weex-template-compiler/yarn.lock b/packages/weex-template-compiler/yarn.lock
deleted file mode 100644
index 3c4f9004f0d..00000000000
--- a/packages/weex-template-compiler/yarn.lock
+++ /dev/null
@@ -1,97 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
-acorn-walk@^8.0.2:
-  version "8.0.2"
-  resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.0.2.tgz#d4632bfc63fd93d0f15fd05ea0e984ffd3f5a8c3"
-  integrity sha512-+bpA9MJsHdZ4bgfDcpk0ozQyhhVct7rzOmO0s1IIr0AGGgKBljss8n2zp11rRP2wid5VGeh04CgeKzgat5/25A==
-
-acorn@^8.1.0:
-  version "8.1.0"
-  resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.1.0.tgz#52311fd7037ae119cbb134309e901aa46295b3fe"
-  integrity sha512-LWCF/Wn0nfHOmJ9rzQApGnxnvgfROzGilS8936rqN/lfcYkY9MYZzdMqN+2NJ4SlTc+m5HiSa+kNfDtI64dwUA==
-
-deep-is@~0.1.3:
-  version "0.1.3"
-  resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34"
-  integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=
-
-escodegen@^1.8.1:
-  version "1.14.3"
-  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-1.14.3.tgz#4e7b81fba61581dc97582ed78cab7f0e8d63f503"
-  integrity sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==
-  dependencies:
-    esprima "^4.0.1"
-    estraverse "^4.2.0"
-    esutils "^2.0.2"
-    optionator "^0.8.1"
-  optionalDependencies:
-    source-map "~0.6.1"
-
-esprima@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
-  integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
-
-estraverse@^4.2.0:
-  version "4.3.0"
-  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d"
-  integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==
-
-esutils@^2.0.2:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
-  integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
-
-fast-levenshtein@~2.0.6:
-  version "2.0.6"
-  resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917"
-  integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=
-
-he@^1.1.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f"
-  integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==
-
-levn@~0.3.0:
-  version "0.3.0"
-  resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee"
-  integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=
-  dependencies:
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-
-optionator@^0.8.1:
-  version "0.8.3"
-  resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.3.tgz#84fa1d036fe9d3c7e21d99884b601167ec8fb495"
-  integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==
-  dependencies:
-    deep-is "~0.1.3"
-    fast-levenshtein "~2.0.6"
-    levn "~0.3.0"
-    prelude-ls "~1.1.2"
-    type-check "~0.3.2"
-    word-wrap "~1.2.3"
-
-prelude-ls@~1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54"
-  integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=
-
-source-map@~0.6.1:
-  version "0.6.1"
-  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
-  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
-
-type-check@~0.3.2:
-  version "0.3.2"
-  resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"
-  integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=
-  dependencies:
-    prelude-ls "~1.1.2"
-
-word-wrap@~1.2.3:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
-  integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==

From 972d8066d7be0fd5d10e4f1ba5e08c148c851e6b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 19 May 2022 18:21:26 +0800
Subject: [PATCH 038/317] test: migrate tests to vitest (wip)

---
 package.json                                  |   1 +
 pnpm-lock.yaml                                | 286 +++++++++++++++++-
 test/helpers/to-have-been-warned.ts           |  75 -----
 .../component/component-async.spec.ts         | 161 ++++++----
 test/unit/global.d.ts                         |  17 +-
 test/unit/index.js                            |  10 -
 test/unit/karma.base.config.ts                | 112 -------
 test/unit/karma.cover.config.ts               |  42 ---
 test/unit/karma.dev.config.ts                 |  13 -
 test/unit/karma.sauce.config.ts               | 106 -------
 test/unit/karma.unit.config.ts                |  14 -
 test/unit/modules/observer/dep.spec.ts        |   6 +-
 test/vitest.setup.ts                          | 185 +++++++++++
 tsconfig.json                                 |   4 +-
 vitest.config.ts                              |  27 ++
 15 files changed, 612 insertions(+), 447 deletions(-)
 delete mode 100644 test/helpers/to-have-been-warned.ts
 delete mode 100644 test/unit/index.js
 delete mode 100644 test/unit/karma.base.config.ts
 delete mode 100644 test/unit/karma.cover.config.ts
 delete mode 100644 test/unit/karma.dev.config.ts
 delete mode 100644 test/unit/karma.sauce.config.ts
 delete mode 100644 test/unit/karma.unit.config.ts
 create mode 100644 test/vitest.setup.ts
 create mode 100644 vitest.config.ts

diff --git a/package.json b/package.json
index ab4d16c9dd8..ecbbb77a66d 100644
--- a/package.json
+++ b/package.json
@@ -89,6 +89,7 @@
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
     "http-server": "^14.1.0",
+    "jsdom": "^19.0.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
     "lodash.template": "^4.4.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8b6428e46a3..f2a3fe8bdbb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -23,6 +23,7 @@ specifiers:
   hash-sum: ^2.0.0
   he: ^1.2.0
   http-server: ^14.1.0
+  jsdom: ^19.0.0
   lint-staged: ^12.4.1
   lodash: ^4.17.21
   lodash.template: ^4.4.0
@@ -66,6 +67,7 @@ devDependencies:
   hash-sum: 2.0.0
   he: 1.2.0
   http-server: 14.1.0
+  jsdom: 19.0.0
   lint-staged: 12.4.1
   lodash: 4.17.21
   lodash.template: 4.5.0
@@ -81,7 +83,7 @@ devDependencies:
   ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
   tslib: 2.4.0
   typescript: 4.6.4
-  vitest: 0.12.6
+  vitest: 0.12.6_jsdom@19.0.0
   weex-js-runtime: 0.23.7
   weex-styler: 0.3.1
   yorkie: 2.0.0
@@ -308,6 +310,11 @@ packages:
       picomatch: 2.3.1
     dev: true
 
+  /@tootallnate/once/2.0.0:
+    resolution: {integrity: sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==}
+    engines: {node: '>= 10'}
+    dev: true
+
   /@tsconfig/node10/1.0.8:
     resolution: {integrity: sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg==}
     dev: true
@@ -515,6 +522,17 @@ packages:
       through: 2.3.8
     dev: true
 
+  /abab/2.0.6:
+    resolution: {integrity: sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA==}
+    dev: true
+
+  /acorn-globals/6.0.0:
+    resolution: {integrity: sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==}
+    dependencies:
+      acorn: 7.4.1
+      acorn-walk: 7.2.0
+    dev: true
+
   /acorn-jsx/5.3.2_acorn@8.7.1:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -523,11 +541,22 @@ packages:
       acorn: 8.7.1
     dev: true
 
+  /acorn-walk/7.2.0:
+    resolution: {integrity: sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==}
+    engines: {node: '>=0.4.0'}
+    dev: true
+
   /acorn-walk/8.2.0:
     resolution: {integrity: sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==}
     engines: {node: '>=0.4.0'}
     dev: true
 
+  /acorn/7.4.1:
+    resolution: {integrity: sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+    dev: true
+
   /acorn/8.7.1:
     resolution: {integrity: sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==}
     engines: {node: '>=0.4.0'}
@@ -538,6 +567,15 @@ packages:
     resolution: {integrity: sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ==}
     dev: true
 
+  /agent-base/6.0.2:
+    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
+    engines: {node: '>= 6.0.0'}
+    dependencies:
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /aggregate-error/3.1.0:
     resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==}
     engines: {node: '>=8'}
@@ -643,6 +681,10 @@ packages:
       lodash: 4.17.21
     dev: true
 
+  /asynckit/0.4.0:
+    resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
+    dev: true
+
   /atob/2.1.2:
     resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
     engines: {node: '>= 4.5.0'}
@@ -674,6 +716,10 @@ packages:
       fill-range: 7.0.1
     dev: true
 
+  /browser-process-hrtime/1.0.0:
+    resolution: {integrity: sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==}
+    dev: true
+
   /buffer-from/1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
     dev: true
@@ -828,6 +874,13 @@ packages:
     resolution: {integrity: sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==}
     dev: true
 
+  /combined-stream/1.0.8:
+    resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      delayed-stream: 1.0.0
+    dev: true
+
   /commander/2.20.3:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
     dev: true
@@ -1094,6 +1147,21 @@ packages:
       urix: 0.1.0
     dev: true
 
+  /cssom/0.3.8:
+    resolution: {integrity: sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==}
+    dev: true
+
+  /cssom/0.5.0:
+    resolution: {integrity: sha512-iKuQcq+NdHqlAcwUY0o/HL69XQrUaQdMjmStJ8JFmUaiiQErlhrmuigkg/CU4E2J0IyUKUrMAgl36TvN67MqTw==}
+    dev: true
+
+  /cssstyle/2.3.0:
+    resolution: {integrity: sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==}
+    engines: {node: '>=8'}
+    dependencies:
+      cssom: 0.3.8
+    dev: true
+
   /cz-conventional-changelog/3.2.0:
     resolution: {integrity: sha512-yAYxeGpVi27hqIilG1nh4A9Bnx4J3Ov+eXy4koL3drrR+IO9GaWPsKjik20ht608Asqi8TQPf0mczhEeyAtMzg==}
     engines: {node: '>= 10'}
@@ -1133,6 +1201,15 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /data-urls/3.0.2:
+    resolution: {integrity: sha512-Jy/tj3ldjZJo63sVAvg6LHt2mHvl4V6AgRAmNDtLdm7faqtsx+aJG42rsyCo9JCoRVKwPFzKlIPx3DIibwSIaQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      abab: 2.0.6
+      whatwg-mimetype: 3.0.0
+      whatwg-url: 11.0.0
+    dev: true
+
   /dateformat/3.0.3:
     resolution: {integrity: sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==}
     dev: true
@@ -1190,6 +1267,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /decimal.js/10.3.1:
+    resolution: {integrity: sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ==}
+    dev: true
+
   /decode-uri-component/0.2.0:
     resolution: {integrity: sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=}
     engines: {node: '>=0.10'}
@@ -1215,6 +1296,11 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /delayed-stream/1.0.0:
+    resolution: {integrity: sha1-3zrhmayt+31ECqrgsp4icrJOxhk=}
+    engines: {node: '>=0.4.0'}
+    dev: true
+
   /detect-file/1.0.0:
     resolution: {integrity: sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=}
     engines: {node: '>=0.10.0'}
@@ -1244,6 +1330,13 @@ packages:
       esutils: 2.0.3
     dev: true
 
+  /domexception/4.0.0:
+    resolution: {integrity: sha512-A2is4PLG+eeSfoTMA95/s4pvAoSo2mKtiM5jlHkAVewmiO8ISFTFKZjH7UAM1Atli/OT/7JHOrJRJiMKUZKYBw==}
+    engines: {node: '>=12'}
+    dependencies:
+      webidl-conversions: 7.0.0
+    dev: true
+
   /dot-prop/5.3.0:
     resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==}
     engines: {node: '>=8'}
@@ -1810,6 +1903,15 @@ packages:
         optional: true
     dev: true
 
+  /form-data/4.0.0:
+    resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==}
+    engines: {node: '>= 6'}
+    dependencies:
+      asynckit: 0.4.0
+      combined-stream: 1.0.8
+      mime-types: 2.1.35
+    dev: true
+
   /fs-extra/10.1.0:
     resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==}
     engines: {node: '>=12'}
@@ -2080,6 +2182,17 @@ packages:
       whatwg-encoding: 2.0.0
     dev: true
 
+  /http-proxy-agent/5.0.0:
+    resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==}
+    engines: {node: '>= 6'}
+    dependencies:
+      '@tootallnate/once': 2.0.0
+      agent-base: 6.0.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /http-proxy/1.18.1:
     resolution: {integrity: sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==}
     engines: {node: '>=8.0.0'}
@@ -2114,6 +2227,16 @@ packages:
       - supports-color
     dev: true
 
+  /https-proxy-agent/5.0.1:
+    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
+    engines: {node: '>= 6'}
+    dependencies:
+      agent-base: 6.0.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /human-signals/2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
@@ -2265,6 +2388,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /is-potential-custom-element-name/1.0.1:
+    resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
+    dev: true
+
   /is-reference/1.2.1:
     resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
     dependencies:
@@ -2316,6 +2443,48 @@ packages:
       argparse: 2.0.1
     dev: true
 
+  /jsdom/19.0.0:
+    resolution: {integrity: sha512-RYAyjCbxy/vri/CfnjUWJQQtZ3LKlLnDqj+9XLNnJPgEGeirZs3hllKR20re8LUZ6o1b1X4Jat+Qd26zmP41+A==}
+    engines: {node: '>=12'}
+    peerDependencies:
+      canvas: ^2.5.0
+    peerDependenciesMeta:
+      canvas:
+        optional: true
+    dependencies:
+      abab: 2.0.6
+      acorn: 8.7.1
+      acorn-globals: 6.0.0
+      cssom: 0.5.0
+      cssstyle: 2.3.0
+      data-urls: 3.0.2
+      decimal.js: 10.3.1
+      domexception: 4.0.0
+      escodegen: 2.0.0
+      form-data: 4.0.0
+      html-encoding-sniffer: 3.0.0
+      http-proxy-agent: 5.0.0
+      https-proxy-agent: 5.0.1
+      is-potential-custom-element-name: 1.0.1
+      nwsapi: 2.2.0
+      parse5: 6.0.1
+      saxes: 5.0.1
+      symbol-tree: 3.2.4
+      tough-cookie: 4.0.0
+      w3c-hr-time: 1.0.2
+      w3c-xmlserializer: 3.0.0
+      webidl-conversions: 7.0.0
+      whatwg-encoding: 2.0.0
+      whatwg-mimetype: 3.0.0
+      whatwg-url: 10.0.0
+      ws: 8.6.0
+      xml-name-validator: 4.0.0
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    dev: true
+
   /json-parse-better-errors/1.0.2:
     resolution: {integrity: sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==}
     dev: true
@@ -2610,6 +2779,18 @@ packages:
       picomatch: 2.3.1
     dev: true
 
+  /mime-db/1.52.0:
+    resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
+    engines: {node: '>= 0.6'}
+    dev: true
+
+  /mime-types/2.1.35:
+    resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      mime-db: 1.52.0
+    dev: true
+
   /mime/1.6.0:
     resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
     engines: {node: '>=4'}
@@ -2735,6 +2916,10 @@ packages:
       path-key: 3.1.1
     dev: true
 
+  /nwsapi/2.2.0:
+    resolution: {integrity: sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ==}
+    dev: true
+
   /object-inspect/1.12.0:
     resolution: {integrity: sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==}
     dev: true
@@ -2887,6 +3072,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /parse5/6.0.1:
+    resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
+    dev: true
+
   /path-exists/3.0.0:
     resolution: {integrity: sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=}
     engines: {node: '>=4'}
@@ -3021,6 +3210,10 @@ packages:
     resolution: {integrity: sha1-8FKijacOYYkX7wqKw0wa5aaChrM=}
     dev: true
 
+  /psl/1.8.0:
+    resolution: {integrity: sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==}
+    dev: true
+
   /punycode/2.1.1:
     resolution: {integrity: sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==}
     engines: {node: '>=6'}
@@ -3272,6 +3465,13 @@ packages:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
     dev: true
 
+  /saxes/5.0.1:
+    resolution: {integrity: sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==}
+    engines: {node: '>=10'}
+    dependencies:
+      xmlchars: 2.2.0
+    dev: true
+
   /secure-compare/3.0.1:
     resolution: {integrity: sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=}
     dev: true
@@ -3599,6 +3799,10 @@ packages:
     engines: {node: '>= 0.4'}
     dev: true
 
+  /symbol-tree/3.2.4:
+    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
+    dev: true
+
   /terser/5.13.1:
     resolution: {integrity: sha512-hn4WKOfwnwbYfe48NgrQjqNOH9jzLqRcIfbYytOXCOv46LBfWr9bDS17MQqOi+BWGD0sJK3Sj5NC/gJjiojaoA==}
     engines: {node: '>=10'}
@@ -3660,12 +3864,28 @@ packages:
       is-number: 7.0.0
     dev: true
 
+  /tough-cookie/4.0.0:
+    resolution: {integrity: sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==}
+    engines: {node: '>=6'}
+    dependencies:
+      psl: 1.8.0
+      punycode: 2.1.1
+      universalify: 0.1.2
+    dev: true
+
   /tr46/1.0.1:
     resolution: {integrity: sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=}
     dependencies:
       punycode: 2.1.1
     dev: true
 
+  /tr46/3.0.0:
+    resolution: {integrity: sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==}
+    engines: {node: '>=12'}
+    dependencies:
+      punycode: 2.1.1
+    dev: true
+
   /trim-newlines/3.0.1:
     resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==}
     engines: {node: '>=8'}
@@ -3862,7 +4082,7 @@ packages:
       fsevents: 2.3.2
     dev: true
 
-  /vitest/0.12.6:
+  /vitest/0.12.6_jsdom@19.0.0:
     resolution: {integrity: sha512-YWbCTv0XKBuBw5YtuW/iufuguoi8QhGpYyi2g57Oo7akpscMkkWTAaZGgY0ux1oJJtO/pc/8GFt0EF32WFBUUQ==}
     engines: {node: '>=v14.16.0'}
     hasBin: true
@@ -3884,6 +4104,7 @@ packages:
       '@types/chai': 4.3.1
       '@types/chai-subset': 1.3.3
       chai: 4.3.6
+      jsdom: 19.0.0
       local-pkg: 0.4.1
       tinypool: 0.1.3
       tinyspy: 0.3.2
@@ -3894,10 +4115,28 @@ packages:
       - stylus
     dev: true
 
+  /w3c-hr-time/1.0.2:
+    resolution: {integrity: sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==}
+    dependencies:
+      browser-process-hrtime: 1.0.0
+    dev: true
+
+  /w3c-xmlserializer/3.0.0:
+    resolution: {integrity: sha512-3WFqGEgSXIyGhOmAFtlicJNMjEps8b1MG31NCA0/vOF9+nKMUW1ckhi9cnNHmf88Rzw5V+dwIwsm2C7X8k9aQg==}
+    engines: {node: '>=12'}
+    dependencies:
+      xml-name-validator: 4.0.0
+    dev: true
+
   /webidl-conversions/4.0.2:
     resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
     dev: true
 
+  /webidl-conversions/7.0.0:
+    resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
+    engines: {node: '>=12'}
+    dev: true
+
   /weex-js-runtime/0.23.7:
     resolution: {integrity: sha512-3BFd5GXTo0X/GWh0KjzXDpIcPJuSwYuc9fE9llgez35IfVHs/nUmfkFBjifzxOJS2YLhtKf0Cy8eTQ00CJDWZA==}
     engines: {node: '>=4'}
@@ -3916,6 +4155,27 @@ packages:
       iconv-lite: 0.6.3
     dev: true
 
+  /whatwg-mimetype/3.0.0:
+    resolution: {integrity: sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /whatwg-url/10.0.0:
+    resolution: {integrity: sha512-CLxxCmdUby142H5FZzn4D8ikO1cmypvXVQktsgosNy4a4BHrDHeciBBGZhb0bNoR5/MltoCatso+vFjjGx8t0w==}
+    engines: {node: '>=12'}
+    dependencies:
+      tr46: 3.0.0
+      webidl-conversions: 7.0.0
+    dev: true
+
+  /whatwg-url/11.0.0:
+    resolution: {integrity: sha512-RKT8HExMpoYx4igMiVMY83lN6UeITKJlBQ+vR/8ZJ8OCdSiN3RwCq+9gH0+Xzj0+5IrM6i4j/6LuvzbZIQgEcQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      tr46: 3.0.0
+      webidl-conversions: 7.0.0
+    dev: true
+
   /whatwg-url/7.1.0:
     resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==}
     dependencies:
@@ -3970,6 +4230,28 @@ packages:
     resolution: {integrity: sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=}
     dev: true
 
+  /ws/8.6.0:
+    resolution: {integrity: sha512-AzmM3aH3gk0aX7/rZLYvjdvZooofDu3fFOzGqcSnQ1tOcTWwhM/o+q++E8mAyVVIyUdajrkzWUGftaVSDLn1bw==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+    dev: true
+
+  /xml-name-validator/4.0.0:
+    resolution: {integrity: sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /xmlchars/2.2.0:
+    resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
+    dev: true
+
   /xtend/4.0.2:
     resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
     engines: {node: '>=0.4'}
diff --git a/test/helpers/to-have-been-warned.ts b/test/helpers/to-have-been-warned.ts
deleted file mode 100644
index c7e0aba8b61..00000000000
--- a/test/helpers/to-have-been-warned.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-function noop () {}
-
-if (typeof console === 'undefined') {
-  // @ts-expect-error
-  window.console = {
-    warn: noop,
-    error: noop
-  }
-}
-
-// avoid info messages during test
-console.info = noop
-
-let asserted
-
-function createCompareFn (spy) {
-  const hasWarned = msg => {
-    let count = spy.calls.count()
-    let args
-    while (count--) {
-      args = spy.calls.argsFor(count)
-      if (args.some(containsMsg)) {
-        return true
-      }
-    }
-
-    function containsMsg (arg) {
-      return arg.toString().indexOf(msg) > -1
-    }
-  }
-
-  return {
-    compare: msg => {
-      asserted = asserted.concat(msg)
-      const warned = Array.isArray(msg)
-        ? msg.some(hasWarned)
-        : hasWarned(msg)
-      return {
-        pass: warned,
-        message: warned
-          ? 'Expected message "' + msg + '" not to have been warned'
-          : 'Expected message "' + msg + '" to have been warned'
-      }
-    }
-  }
-}
-
-// define custom matcher for warnings
-beforeEach(() => {
-  asserted = []
-  spyOn(console, 'warn')
-  spyOn(console, 'error')
-  jasmine.addMatchers({
-    toHaveBeenWarned: () => 
-      // @ts-expect-error
-      createCompareFn(console.error),
-    toHaveBeenTipped: () => 
-      // @ts-expect-error
-      createCompareFn(console.warn)
-  })
-})
-
-afterEach(done => {
-  const warned = msg => asserted.some(assertedMsg => msg.toString().indexOf(assertedMsg) > -1)
-  let count = console.error.calls.count()
-  let args
-  while (count--) {
-    args = console.error.calls.argsFor(count)
-    if (!warned(args[0])) {
-      done.fail(`Unexpected console.error message: ${args[0]}`)
-      return
-    }
-  }
-  done()
-})
diff --git a/test/unit/features/component/component-async.spec.ts b/test/unit/features/component/component-async.spec.ts
index 2b5e9500715..8ac77244979 100644
--- a/test/unit/features/component/component-async.spec.ts
+++ b/test/unit/features/component/component-async.spec.ts
@@ -1,44 +1,57 @@
 import Vue from 'vue'
 
-describe('Component async', () => {
+function wait(): [() => void, Promise<void>] {
+  let done
+  const p = new Promise<void>((resolve, reject) => {
+    done = resolve
+    done.fail = reject
+  })
+  return [done, p]
+}
 
-  const oldSetTimeout = window.setTimeout;
-  const oldClearTimeout = window.clearTimeout;
+describe('Component async', () => {
+  const oldSetTimeout = setTimeout
+  const oldClearTimeout = clearTimeout
 
   // will contain pending timeouts set during the test iteration
   // will contain the id of the timeout as the key, and the millisecond timeout as the value
   // this helps to identify the timeout that is still pending
-  let timeoutsPending = {};
-
-  beforeEach(function () {
-    // reset the timeouts for this iteration
-    timeoutsPending = {};
+  let timeoutsPending = {}
 
+  beforeAll(function () {
     // @ts-expect-error
-    global.setTimeout = function(func, delay) {
-      const id = oldSetTimeout(function() {
-        delete timeoutsPending[id];
-        func();
-      }, delay);
-      timeoutsPending[id] = delay;
+    global.setTimeout = function (func, delay) {
+      const id = oldSetTimeout(function () {
+        delete timeoutsPending[id]
+        func()
+      }, delay) as any
+      timeoutsPending[id] = delay
       return id
-    };
+    }
+
+    global.clearTimeout = function (id) {
+      oldClearTimeout(id)
+      delete timeoutsPending[id]
+    }
+  })
+
+  afterAll(function () {
+    global.setTimeout = oldSetTimeout
+    global.clearTimeout = oldClearTimeout
+  })
 
-    window.clearTimeout = function(id) {
-      oldClearTimeout(id);
-      delete timeoutsPending[id];
-    };
+  beforeEach(() => {
+    // reset the timeouts for this iteration
+    timeoutsPending = {}
   })
 
-  afterEach(function () {
-    window.setTimeout = oldSetTimeout;
-    window.clearTimeout = oldClearTimeout;
+  afterEach(() => {
     // after the test is complete no timeouts that have been set up during the test should still be active
     // compare stringified JSON for better error message containing ID and millisecond timeout
     expect(JSON.stringify(timeoutsPending)).toEqual(JSON.stringify({}))
   })
 
-  it('normal', done => {
+  it('normal', () => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
@@ -55,14 +68,17 @@ describe('Component async', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<!---->')
     expect(vm.$children.length).toBe(0)
-    function next () {
+
+    const [done, p] = wait()
+    function next() {
       expect(vm.$el.innerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
+    return p
   })
 
-  it('resolve ES module default', done => {
+  it('resolve ES module default', () => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
@@ -82,18 +98,21 @@ describe('Component async', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<!---->')
     expect(vm.$children.length).toBe(0)
-    function next () {
+
+    const [done, p] = wait()
+    function next() {
       expect(vm.$el.innerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
+    return p
   })
 
-  it('as root', done => {
+  it('as root', () => {
     const vm = new Vue({
       template: '<test></test>',
       components: {
-        test: resolve => {
+        test: (resolve) => {
           setTimeout(() => {
             resolve({
               template: '<div>hi</div>'
@@ -106,22 +125,25 @@ describe('Component async', () => {
     }).$mount()
     expect(vm.$el.nodeType).toBe(8)
     expect(vm.$children.length).toBe(0)
-    function next () {
+
+    const [done, p] = wait()
+    function next() {
       expect(vm.$el.nodeType).toBe(1)
       expect(vm.$el.outerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
+    return p
   })
 
-  it('dynamic', done => {
+  it('dynamic', () => {
     const vm = new Vue({
       template: '<component :is="view"></component>',
       data: {
         view: 'view-a'
       },
       components: {
-        'view-a': resolve => {
+        'view-a': (resolve) => {
           setTimeout(() => {
             resolve({
               template: '<div>A</div>'
@@ -129,7 +151,7 @@ describe('Component async', () => {
             Vue.nextTick(step1)
           }, 0)
         },
-        'view-b': resolve => {
+        'view-b': (resolve) => {
           setTimeout(() => {
             resolve({
               template: '<p>B</p>'
@@ -140,7 +162,7 @@ describe('Component async', () => {
       }
     }).$mount()
     let aCalled = false
-    function step1 () {
+    function step1() {
       // ensure A is resolved only once
       expect(aCalled).toBe(false)
       aCalled = true
@@ -148,15 +170,18 @@ describe('Component async', () => {
       expect(vm.$el.textContent).toBe('A')
       vm.view = 'view-b'
     }
-    function step2 () {
+    const [done, p] = wait()
+    function step2() {
       expect(vm.$el.tagName).toBe('P')
       expect(vm.$el.textContent).toBe('B')
       vm.view = 'view-a'
-      global.waitForUpdate(function () {
+
+      waitForUpdate(() => {
         expect(vm.$el.tagName).toBe('DIV')
         expect(vm.$el.textContent).toBe('A')
       }).then(done)
     }
+    return p
   })
 
   it('warn reject', () => {
@@ -171,14 +196,14 @@ describe('Component async', () => {
     expect('Reason: nooooo').toHaveBeenWarned()
   })
 
-  it('with v-for', done => {
+  it('with v-for', () => {
     const vm = new Vue({
       template: '<div><test v-for="n in list" :key="n" :n="n"></test></div>',
       data: {
         list: [1, 2, 3]
       },
       components: {
-        test: resolve => {
+        test: (resolve) => {
           setTimeout(() => {
             resolve({
               props: ['n'],
@@ -189,18 +214,20 @@ describe('Component async', () => {
         }
       }
     }).$mount()
-    function next () {
+    const [done, p] = wait()
+    function next() {
       expect(vm.$el.innerHTML).toBe('<div>1</div><div>2</div><div>3</div>')
       done()
     }
+    return p
   })
 
-  it('returning Promise', done => {
+  it('returning Promise', () => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
         test: () => {
-          return new Promise(resolve => {
+          return new Promise((resolve) => {
             setTimeout(() => {
               resolve({
                 template: '<div>hi</div>'
@@ -216,20 +243,23 @@ describe('Component async', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<!---->')
     expect(vm.$children.length).toBe(0)
-    function next () {
+
+    const [done, p] = wait()
+    function next() {
       expect(vm.$el.innerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
+    return p
   })
 
   describe('loading/error/timeout', () => {
-    it('with loading component', done => {
+    it('with loading component', () => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
           test: () => ({
-            component: new Promise(resolve => {
+            component: new Promise((resolve) => {
               setTimeout(() => {
                 resolve({ template: '<div>hi</div>' })
                 // wait for promise resolve and then parent update
@@ -254,19 +284,21 @@ describe('Component async', () => {
         })
       }, 1)
 
-      function next () {
+      const [done, p] = wait()
+      function next() {
         expect(loadingAsserted).toBe(true)
         expect(vm.$el.textContent).toBe('hi')
         done()
       }
+      return p
     })
 
-    it('with loading component (0 delay)', done => {
+    it('with loading component (0 delay)', () => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
           test: () => ({
-            component: new Promise(resolve => {
+            component: new Promise((resolve) => {
               setTimeout(() => {
                 resolve({ template: '<div>hi</div>' })
                 // wait for promise resolve and then parent update
@@ -283,13 +315,15 @@ describe('Component async', () => {
 
       expect(vm.$el.textContent).toBe('loading')
 
-      function next () {
+      const [done, p] = wait()
+      function next() {
         expect(vm.$el.textContent).toBe('hi')
         done()
       }
+      return p
     })
 
-    it('with error component', done => {
+    it('with error component', () => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -312,14 +346,16 @@ describe('Component async', () => {
 
       expect(vm.$el.textContent).toBe('loading')
 
-      function next () {
+      const [done, p] = wait()
+      function next() {
         expect(`Failed to resolve async component`).toHaveBeenWarned()
         expect(vm.$el.textContent).toBe('error')
         done()
       }
+      return p
     })
 
-    it('with error component + timeout', done => {
+    it('with error component + timeout', () => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -350,13 +386,15 @@ describe('Component async', () => {
         })
       }, 1)
 
-      function next () {
+      const [done, p] = wait()
+      function next() {
         expect(vm.$el.textContent).toBe('error') // late resolve ignored
         done()
       }
+      return p
     })
 
-    it('should not trigger timeout if resolved', done => {
+    it('should not trigger timeout if resolved', () => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -372,14 +410,16 @@ describe('Component async', () => {
         }
       }).$mount()
 
+      const [done, p] = wait()
       setTimeout(() => {
         expect(vm.$el.textContent).toBe('hi')
         expect(`Failed to resolve async component`).not.toHaveBeenWarned()
         done()
       }, 50)
+      return p
     })
 
-    it('should not have running timeout/loading if resolved', done => {
+    it('should not have running timeout/loading if resolved', () => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -400,15 +440,17 @@ describe('Component async', () => {
         }
       }).$mount()
 
-      function next () {
+      const [done, p] = wait()
+      function next() {
         expect(vm.$el.textContent).toBe('hi')
         // the afterEach() will ensure that the timeouts for delay and timeout have been cleared
         done()
       }
+      return p
     })
 
     // #7107
-    it(`should work when resolving sync in sibling component's mounted hook`, done => {
+    it(`should work when resolving sync in sibling component's mounted hook`, () => {
       let resolveTwo
 
       const vm = new Vue({
@@ -416,11 +458,11 @@ describe('Component async', () => {
         components: {
           one: {
             template: `<div>one</div>`,
-            mounted () {
+            mounted() {
               resolveTwo()
             }
           },
-          two: resolve => {
+          two: (resolve) => {
             resolveTwo = () => {
               resolve({
                 template: `<div>two</div>`
@@ -431,9 +473,12 @@ describe('Component async', () => {
       }).$mount()
 
       expect(vm.$el.textContent).toBe('one ')
-      global.waitForUpdate(() => {
+
+      const [done, p] = wait()
+      waitForUpdate(() => {
         expect(vm.$el.textContent).toBe('one two')
       }).then(done)
+      return p
     })
   })
 })
diff --git a/test/unit/global.d.ts b/test/unit/global.d.ts
index 8c7cccc51ac..ef3ed19af82 100644
--- a/test/unit/global.d.ts
+++ b/test/unit/global.d.ts
@@ -6,14 +6,11 @@ declare function createTextVNode(
   arg?: any
 ): any;
 
-declare namespace jasmine {
-  interface Matchers<T> {
-    toHaveBeenWarned(): void;
-    toHaveBeenTipped(): void;
+// vitest extends jest namespace so we can just extend jest.Matchers
+declare namespace jest {
+  interface Matchers<R, T> {
+    toHaveBeenWarned(): R
+    toHaveBeenWarnedLast(): R
+    toHaveBeenWarnedTimes(n: number): R
   }
-
-  interface ArrayLikeMatchers<T> {
-    toHaveBeenWarned(): void;
-    toHaveBeenTipped(): void;
-  }
-}
\ No newline at end of file
+}
diff --git a/test/unit/index.js b/test/unit/index.js
deleted file mode 100644
index 19bd294ee78..00000000000
--- a/test/unit/index.js
+++ /dev/null
@@ -1,10 +0,0 @@
-// NOTE: do not convert this to typescript (or karma will be unhappy)
-require('es6-promise/auto')
-
-// import all helpers
-const helpersContext = require.context('../helpers', true)
-helpersContext.keys().forEach(helpersContext)
-
-// require all test files
-const testsContext = require.context('./', true, /\.spec$/)
-testsContext.keys().forEach(testsContext)
\ No newline at end of file
diff --git a/test/unit/karma.base.config.ts b/test/unit/karma.base.config.ts
deleted file mode 100644
index 0d37e02435e..00000000000
--- a/test/unit/karma.base.config.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-const alias = require('../../scripts/alias')
-const featureFlags = require('../../scripts/feature-flags')
-const webpack = require('webpack')
-
-const webpackConfig = {
-  mode: 'development',
-  module: {
-    rules: [
-      {
-        test: /\.js$/,
-        loader: 'babel-loader',
-        exclude: /node_modules/
-      },
-      {
-        test: /\.tsx?$/,
-        exclude: /node_modules/,
-        // loader: 'ts-loader',
-        // loader: 'babel-loader!ts-loader',
-        use: ['babel-loader', 'ts-loader']
-      },
-    ]
-  },
-  resolve: {
-    alias: alias,
-    extensions: ['.tsx', '.ts', '.js'],
-    fallback: {
-      'stream': require.resolve("stream-browserify")
-    }
-  },
-  plugins: [
-    new webpack.DefinePlugin({
-      __WEEX__: false,
-      'process.env': {
-        TRANSITION_DURATION: process.env.CI ? 100 : 50,
-        TRANSITION_BUFFER: 10,
-        ...featureFlags
-      }
-    })
-  ],
-  devtool: 'inline-source-map'
-}
-
-// shared config for all unit tests
-module.exports = {
-  frameworks: ['jasmine', 'webpack', 'karma-typescript'],
-  files: [
-    './index.js',
-    "../../src/**/*.ts" // *.tsx for React Jsx
-  ],
-  preprocessors: {
-    './index.js': ['webpack', 'sourcemap'],
-    "**/*.ts": ["karma-typescript", 'webpack', 'sourcemap'] // *.tsx for React Jsx
-  },
-  webpack: webpackConfig,
-  webpackMiddleware: {
-    noInfo: true
-  },
-  plugins: [
-    'karma-jasmine',
-    'karma-mocha-reporter',
-    'karma-sourcemap-loader',
-    'karma-webpack',
-    'karma-typescript'
-  ],
-  karmaTypescriptConfig: {
-  //   "compilerOptions": {
-  //     "baseUrl": ".",
-  //     "outDir": "dist",
-  //     "sourceMap": true,
-  //     "target": "ESNext",
-  //     "module": "ESNext",
-  //     "moduleResolution": "node",
-  //     "strict": true,
-      
-  //     "allowJs": true,
-  //     "noImplicitAny": false,
-  //     "noImplicitThis": false,
-  
-  //     "noUnusedLocals": true,
-  //     "experimentalDecorators": true,
-  //     "resolveJsonModule": true,
-  //     "esModuleInterop": true,
-  //     "removeComments": false,
-  //     "jsx": "preserve",
-  //     "lib": ["esnext", "dom"],
-  //     "types": [
-  //       "node",
-  //       "jasmine",
-  //       "webpack-env"
-  //     ],
-  //     "paths": {
-  //       "compiler/*": ["../../src/compiler/*"],
-  //       "core/*": ["../../src/core/*"],
-  
-  //       "server/*": ["../../src/server/*"],
-  //       "sfc/*": ["../../src/sfc/*"],
-  //       "shared/*": ["../../src/shared/*"],
-  
-  //       "web/*": ["../../src/platforms/web/*"],
-  //       "weex/*": ["../../src/platforms/weex/*"],
-  
-  //       "vue": ["../../src/platforms/web/entry-runtime-with-compiler"]
-  //     }
-  //   },
-    "include": ["./global.d.ts"],
-  
-  //   "exclude": ["flow", "node_modules", "packages", "types"]
-  // //   bundlerOptions: {
-  // //     transforms: [require("karma-typescript-es6-transform")()]
-  // //   }
-  }
-}
diff --git a/test/unit/karma.cover.config.ts b/test/unit/karma.cover.config.ts
deleted file mode 100644
index 6a06a1b97b8..00000000000
--- a/test/unit/karma.cover.config.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-const base = require('./karma.base.config.ts')
-
-process.env.CHROME_BIN = require('puppeteer').executablePath()
-
-module.exports = function (config: any) {
-  const options = Object.assign(base, {
-    browsers: ['ChromeHeadlessCI'],
-    customLaunchers: {
-      'ChromeHeadlessCI': {
-        base: 'ChromeHeadless',
-        flags: ['--no-sandbox']
-      }
-    },
-    reporters: ['mocha', 'coverage', 'karma-typescript'],
-    coverageReporter: {
-      reporters: [
-        { type: 'lcov', dir: '../../coverage', subdir: '.' },
-        { type: 'text-summary', dir: '../../coverage', subdir: '.' }
-      ]
-    },
-    singleRun: true,
-    plugins: base.plugins.concat([
-      'karma-coverage',
-      'karma-chrome-launcher'
-    ])
-  })
-
-  // add babel-plugin-istanbul for code instrumentation
-  options.webpack.module.rules[0].options = {
-    plugins: [['istanbul', {
-      exclude: [
-        'test/',
-        'src/compiler/parser/html-parser.ts',
-        'src/core/instance/proxy.ts',
-        'src/sfc/deindent.ts',
-        'src/platforms/weex/'
-      ]
-    }]]
-  }
-
-  config.set(options)
-}
diff --git a/test/unit/karma.dev.config.ts b/test/unit/karma.dev.config.ts
deleted file mode 100644
index e04e13561ae..00000000000
--- a/test/unit/karma.dev.config.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-const base = require('./karma.base.config.ts')
-
-process.env.CHROME_BIN = require('puppeteer').executablePath()
-
-module.exports = function (config) {
-  config.set(Object.assign(base, {
-    browsers: ['ChromeHeadless'],
-    reporters: ['progress'],
-    plugins: base.plugins.concat([
-      'karma-chrome-launcher'
-    ])
-  }))
-}
diff --git a/test/unit/karma.sauce.config.ts b/test/unit/karma.sauce.config.ts
deleted file mode 100644
index a3bc8a61185..00000000000
--- a/test/unit/karma.sauce.config.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-const webpack = require('webpack')
-const base = require('./karma.base.config.ts')
-
-base.webpack.plugins = [
-  new webpack.DefinePlugin({
-    __WEEX__: false,
-    'process.env': {
-      NODE_ENV: '"development"',
-      // sauce lab vms are slow!
-      TRANSITION_DURATION: 500,
-      TRANSITION_BUFFER: 50
-    }
-  })
-]
-
-/**
- * Having too many tests running concurrently on saucelabs
- * causes timeouts and errors, so we have to run them in
- * smaller batches.
- */
-
-const batches = [
-  // the cool kids
-  {
-    sl_chrome: {
-      base: 'SauceLabs',
-      browserName: 'chrome',
-      platform: 'Windows 7'
-    },
-    sl_firefox: {
-      base: 'SauceLabs',
-      browserName: 'firefox'
-    },
-    sl_mac_safari: {
-      base: 'SauceLabs',
-      browserName: 'safari',
-      platform: 'OS X 10.10'
-    }
-  },
-  // ie family
-  {
-    sl_ie_9: {
-      base: 'SauceLabs',
-      browserName: 'internet explorer',
-      platform: 'Windows 7',
-      version: '9'
-    },
-    sl_ie_10: {
-      base: 'SauceLabs',
-      browserName: 'internet explorer',
-      platform: 'Windows 8',
-      version: '10'
-    },
-    sl_ie_11: {
-      base: 'SauceLabs',
-      browserName: 'internet explorer',
-      platform: 'Windows 8.1',
-      version: '11'
-    },
-    sl_edge: {
-      base: 'SauceLabs',
-      browserName: 'MicrosoftEdge',
-      platform: 'Windows 10'
-    }
-  },
-  // mobile
-  {
-    sl_ios_safari_9: {
-      base: 'SauceLabs',
-      browserName: 'iphone',
-      version: '10.3'
-    },
-    sl_android_6_0: {
-      base: 'SauceLabs',
-      browserName: 'android',
-      version: '6.0'
-    }
-  }
-]
-
-module.exports = function (config) {
-  const batch = batches[process.argv[4] || 0]
-
-  config.set(Object.assign(base, {
-    singleRun: true,
-    browsers: Object.keys(batch),
-    customLaunchers: batch,
-    reporters: process.env.CI
-      ? ['dots', 'saucelabs'] // avoid spamming CI output
-      : ['progress', 'saucelabs'],
-    sauceLabs: {
-      testName: 'Vue.js unit tests',
-      recordScreenshots: false,
-      connectOptions: {
-        'no-ssl-bump-domains': 'all' // Ignore SSL error on Android emulator
-      },
-      build: process.env.CIRCLE_BUILD_NUM || process.env.SAUCE_BUILD_ID || Date.now()
-    },
-    // mobile emulators are really slow
-    captureTimeout: 300000,
-    browserNoActivityTimeout: 300000,
-    plugins: base.plugins.concat([
-      'karma-sauce-launcher'
-    ])
-  }))
-}
diff --git a/test/unit/karma.unit.config.ts b/test/unit/karma.unit.config.ts
deleted file mode 100644
index 49867dfb4a7..00000000000
--- a/test/unit/karma.unit.config.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-const base = require('./karma.base.config.ts')
-
-module.exports = function (config) {
-  config.set(Object.assign(base, {
-    browsers: ['Chrome', 'Firefox', 'Safari'],
-    reporters: ['progress'],
-    singleRun: true,
-    plugins: base.plugins.concat([
-      'karma-chrome-launcher',
-      'karma-firefox-launcher',
-      'karma-safari-launcher'
-    ])
-  }))
-}
diff --git a/test/unit/modules/observer/dep.spec.ts b/test/unit/modules/observer/dep.spec.ts
index 02809f8a4d9..b851ccb2a49 100644
--- a/test/unit/modules/observer/dep.spec.ts
+++ b/test/unit/modules/observer/dep.spec.ts
@@ -47,15 +47,15 @@ describe('Dep', () => {
     })
 
     it('should add itself to target', () => {
-      Dep.target = jasmine.createSpyObj('TARGET', ['addDep'])
+      Dep.target = { addDep: vi.fn() } as any
       dep.depend()
-      expect(Dep.target.addDep).toHaveBeenCalledWith(dep)
+      expect(Dep.target!.addDep).toHaveBeenCalledWith(dep)
     })
   })
 
   describe('notify()', () => {
     it('should notify subs', () => {
-      dep.subs.push(jasmine.createSpyObj('SUB', ['update']))
+      dep.subs.push({ update: vi.fn() })
       dep.notify()
       expect(dep.subs[0].update).toHaveBeenCalled()
     })
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
new file mode 100644
index 00000000000..aff6dd1d301
--- /dev/null
+++ b/test/vitest.setup.ts
@@ -0,0 +1,185 @@
+import { SpyInstance } from 'vitest'
+
+expect.extend({
+  toHaveBeenWarned(received: string) {
+    asserted.add(received)
+    const passed = warn.mock.calls.some((args) => args[0].includes(received))
+    if (passed) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" not to have been warned.`
+      }
+    } else {
+      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been warned` +
+          (msgs.length
+            ? `.\n\nActual messages:\n\n - ${msgs}`
+            : ` but no warning was recorded.`)
+      }
+    }
+  },
+
+  toHaveBeenWarnedLast(received: string) {
+    asserted.add(received)
+    const passed =
+      warn.mock.calls[warn.mock.calls.length - 1][0].includes(received)
+    if (passed) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" not to have been warned last.`
+      }
+    } else {
+      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been warned last.\n\nActual messages:\n\n - ${msgs}`
+      }
+    }
+  },
+
+  toHaveBeenWarnedTimes(received: string, n: number) {
+    asserted.add(received)
+    let found = 0
+    warn.mock.calls.forEach((args) => {
+      if (args[0].includes(received)) {
+        found++
+      }
+    })
+
+    if (found === n) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" to have been warned ${n} times.`
+      }
+    } else {
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been warned ${n} times but got ${found}.`
+      }
+    }
+  }
+})
+
+let warn: SpyInstance
+const asserted: Set<string> = new Set()
+
+beforeEach(() => {
+  asserted.clear()
+  warn = vi.spyOn(console, 'error')
+  warn.mockImplementation(() => {})
+})
+
+afterEach(() => {
+  const assertedArray = Array.from(asserted)
+  const nonAssertedWarnings = warn.mock.calls
+    .map((args) => args[0])
+    .filter((received) => {
+      return !assertedArray.some((assertedMsg) => {
+        return received.includes(assertedMsg)
+      })
+    })
+  warn.mockRestore()
+  if (nonAssertedWarnings.length) {
+    throw new Error(
+      `test case threw unexpected warnings:\n - ${nonAssertedWarnings.join(
+        '\n - '
+      )}`
+    )
+  }
+})
+
+import Vue from 'vue'
+
+// helper for async assertions.
+// Use like this:
+//
+// vm.a = 123
+// waitForUpdate(() => {
+//   expect(vm.$el.textContent).toBe('123')
+//   vm.a = 234
+// })
+// .then(() => {
+//   // more assertions...
+// })
+// .then(done)
+
+interface Job extends Function {
+  wait?: boolean
+  fail?: (e: any) => void
+}
+
+global.waitForUpdate = (initialCb: Job) => {
+  let end
+  let reject
+  const queue: Job[] = initialCb ? [initialCb] : []
+
+  function shift() {
+    const job = queue.shift()
+    if (queue.length) {
+      let hasError = false
+      try {
+        job!.wait ? job!(shift) : job!()
+      } catch (e) {
+        hasError = true
+        if (reject) {
+          reject()
+        } else {
+          const done = queue[queue.length - 1]
+          if (done && done.fail) {
+            done.fail(e)
+          }
+        }
+      }
+      if (!hasError && !job!.wait) {
+        if (queue.length) {
+          Vue.nextTick(shift)
+        }
+      }
+    } else if (job && (job.fail || job === end)) {
+      job() // done
+    }
+  }
+
+  Vue.nextTick(() => {
+    if (!queue.length || (!end && !queue[queue.length - 1]!.fail)) {
+      throw new Error('waitForUpdate chain is missing .then(done)')
+    }
+    shift()
+  })
+
+  const chainer = {
+    then: (nextCb) => {
+      queue.push(nextCb)
+      return chainer
+    },
+    thenWaitFor: (wait) => {
+      if (typeof wait === 'number') {
+        wait = timeout(wait)
+      }
+      wait.wait = true
+      queue.push(wait)
+      return chainer
+    },
+    end: (endFn) => {
+      queue.push(endFn)
+      end = endFn
+    },
+    promise() {
+      return new Promise((resolve, rej) => {
+        end = resolve
+        reject = rej
+      })
+    }
+  }
+
+  return chainer
+}
+
+function timeout(n) {
+  return (next) => setTimeout(next, n)
+}
diff --git a/tsconfig.json b/tsconfig.json
index 552510a7d64..97a1c51f9bb 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,7 +3,7 @@
     "baseUrl": ".",
     "outDir": "dist",
     "sourceMap": true,
-    "target": "es5",
+    "target": "esnext",
     "module": "ESNext",
     "moduleResolution": "node",
     "strict": true,
@@ -19,7 +19,7 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": ["node"],
+    "types": ["node", "vitest/globals"],
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 00000000000..27d49297958
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,27 @@
+import { resolve as _resolve } from 'path'
+import { defineConfig } from 'vitest/config'
+
+const resolve = (p: string) => _resolve(__dirname, p)
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      compiler: resolve('src/compiler'),
+      core: resolve('src/core'),
+      server: resolve('src/server'),
+      sfc: resolve('src/sfc'),
+      shared: resolve('src/shared'),
+      web: resolve('src/platforms/web'),
+      weex: resolve('src/platforms/weex'),
+      vue: resolve('src/platforms/web/entry-runtime-with-compiler')
+    }
+  },
+  define: {
+    __WEEX__: false
+  },
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: resolve('test/vitest.setup.ts')
+  }
+})

From 8e672c4251a15c1a65a0b0108ab750e0ab440750 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 07:29:25 +0800
Subject: [PATCH 039/317] test: first full test suite passing

---
 test/unit/features/component/component-async.spec.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/unit/features/component/component-async.spec.ts b/test/unit/features/component/component-async.spec.ts
index 8ac77244979..6708673d101 100644
--- a/test/unit/features/component/component-async.spec.ts
+++ b/test/unit/features/component/component-async.spec.ts
@@ -21,6 +21,10 @@ describe('Component async', () => {
   beforeAll(function () {
     // @ts-expect-error
     global.setTimeout = function (func, delay) {
+      if (delay >= 1000) {
+        // skip vitest internal timeouts
+        return
+      }
       const id = oldSetTimeout(function () {
         delete timeoutsPending[id]
         func()

From 52627b95ce3f91916237619da4ca5bdfdbbcfc34 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 07:56:02 +0800
Subject: [PATCH 040/317] test: jasmine.createSpy -> vi.fn

---
 test/ssr/ssr-bundle-render.spec.ts            |  32 +--
 .../component/component-keep-alive.spec.ts    | 100 ++++----
 .../component/component-scoped-slot.spec.ts   |  14 +-
 .../features/component/component-slot.spec.ts |   4 +-
 .../unit/features/component/component.spec.ts |   2 +-
 test/unit/features/debug.spec.ts              |   2 +-
 test/unit/features/directives/for.spec.ts     |   2 +-
 test/unit/features/directives/if.spec.ts      |   8 +-
 .../directives/model-component.spec.ts        |   2 +-
 .../features/directives/model-radio.spec.ts   |   2 +-
 .../features/directives/model-select.spec.ts  |  10 +-
 .../features/directives/model-text.spec.ts    |  20 +-
 test/unit/features/directives/on.spec.ts      | 236 +++++++++---------
 test/unit/features/error-handling.spec.ts     |   4 +-
 test/unit/features/global-api/config.spec.ts  |  10 +-
 test/unit/features/global-api/mixin.spec.ts   |  24 +-
 .../features/instance/methods-data.spec.ts    |  14 +-
 .../features/instance/methods-events.spec.ts  |  18 +-
 .../instance/methods-lifecycle.spec.ts        |   6 +-
 .../unit/features/instance/properties.spec.ts |  12 +-
 test/unit/features/options/computed.spec.ts   |  18 +-
 test/unit/features/options/directives.spec.ts |  66 ++---
 .../features/options/errorCaptured.spec.ts    |  14 +-
 test/unit/features/options/extends.spec.ts    |   2 +-
 test/unit/features/options/functional.spec.ts |   6 +-
 test/unit/features/options/lifecycle.spec.ts  |  20 +-
 test/unit/features/options/mixins.spec.ts     |   4 +-
 test/unit/features/options/props.spec.ts      |  68 ++---
 .../unit/features/options/renderError.spec.ts |   2 +-
 test/unit/features/options/watch.spec.ts      |   8 +-
 .../transition/transition-group.spec.ts       |  12 +-
 .../features/transition/transition.spec.ts    |  42 ++--
 test/unit/modules/compiler/codegen.spec.ts    |   2 +-
 test/unit/modules/compiler/parser.spec.ts     |   4 +-
 test/unit/modules/observer/observer.spec.ts   |  30 +--
 test/unit/modules/observer/scheduler.spec.ts  |   8 +-
 test/unit/modules/observer/watcher.spec.ts    |  16 +-
 test/unit/modules/util/error.spec.ts          |   6 +-
 test/unit/modules/util/next-tick.spec.ts      |   2 +-
 .../modules/vdom/modules/directive.spec.ts    |   6 +-
 test/unit/modules/vdom/modules/events.spec.ts |  72 +++---
 .../modules/vdom/patch/edge-cases.spec.ts     |   8 +-
 42 files changed, 469 insertions(+), 469 deletions(-)

diff --git a/test/ssr/ssr-bundle-render.spec.ts b/test/ssr/ssr-bundle-render.spec.ts
index 184eb98be5c..a44bc8e1d31 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/test/ssr/ssr-bundle-render.spec.ts
@@ -106,8 +106,8 @@ function createAssertions (runInNewContext) {
 
   it('render with cache (get/set)', done => {
     const cache = {}
-    const get = jasmine.createSpy('get')
-    const set = jasmine.createSpy('set')
+    const get = vi.fn()
+    const set = vi.fn()
     const options = {
       runInNewContext,
       cache: {
@@ -138,8 +138,8 @@ function createAssertions (runInNewContext) {
         renderer.renderToString((err, res) => {
           expect(err).toBeNull()
           expect(res).toBe(expected)
-          expect(get.calls.count()).toBe(2)
-          expect(set.calls.count()).toBe(1)
+          expect(get.mock.calls.length).toBe(2)
+          expect(set.mock.calls.length).toBe(1)
           done()
         })
       })
@@ -148,9 +148,9 @@ function createAssertions (runInNewContext) {
 
   it('render with cache (get/set/has)', done => {
     const cache = {}
-    const has = jasmine.createSpy('has')
-    const get = jasmine.createSpy('get')
-    const set = jasmine.createSpy('set')
+    const has = vi.fn()
+    const get = vi.fn()
+    const set = vi.fn()
     const options = {
       runInNewContext,
       cache: {
@@ -185,9 +185,9 @@ function createAssertions (runInNewContext) {
         renderer.renderToString((err, res) => {
           expect(err).toBeNull()
           expect(res).toBe(expected)
-          expect(has.calls.count()).toBe(2)
-          expect(get.calls.count()).toBe(1)
-          expect(set.calls.count()).toBe(1)
+          expect(has.mock.calls.length).toBe(2)
+          expect(get.mock.calls.length).toBe(1)
+          expect(set.mock.calls.length).toBe(1)
           done()
         })
       })
@@ -210,10 +210,10 @@ function createAssertions (runInNewContext) {
       renderer.renderToString(context1, (err, res) => {
         expect(err).toBeNull()
         expect(res).toBe(expected)
-        expect(cache.set.calls.count()).toBe(3) // 3 nested components cached
+        expect(cache.set.mock.calls.length).toBe(3) // 3 nested components cached
         const cached = cache.get(key)
         expect(cached.html).toBe(expected)
-        expect(cache.get.calls.count()).toBe(1)
+        expect(cache.get.mock.calls.length).toBe(1)
 
         // assert component usage registration for nested children
         expect(context1.registered).toEqual(['app', 'child', 'grandchild'])
@@ -221,8 +221,8 @@ function createAssertions (runInNewContext) {
         renderer.renderToString(context2, (err, res) => {
           expect(err).toBeNull()
           expect(res).toBe(expected)
-          expect(cache.set.calls.count()).toBe(3) // no new cache sets
-          expect(cache.get.calls.count()).toBe(2) // 1 get for root
+          expect(cache.set.mock.calls.length).toBe(3) // no new cache sets
+          expect(cache.get.mock.calls.length).toBe(2) // 1 get for root
 
           expect(context2.registered).toEqual(['app', 'child', 'grandchild'])
           done()
@@ -233,8 +233,8 @@ function createAssertions (runInNewContext) {
 
   it('render with cache (opt-out)', done => {
     const cache = {}
-    const get = jasmine.createSpy('get')
-    const set = jasmine.createSpy('set')
+    const get = vi.fn()
+    const set = vi.fn()
     const options = {
       runInNewContext,
       cache: {
diff --git a/test/unit/features/component/component-keep-alive.spec.ts b/test/unit/features/component/component-keep-alive.spec.ts
index 9044a969113..b55f5270df2 100644
--- a/test/unit/features/component/component-keep-alive.spec.ts
+++ b/test/unit/features/component/component-keep-alive.spec.ts
@@ -9,19 +9,19 @@ describe('Component keep-alive', () => {
   beforeEach(() => {
     one = {
       template: '<div>one</div>',
-      created: jasmine.createSpy('one created'),
-      mounted: jasmine.createSpy('one mounted'),
-      activated: jasmine.createSpy('one activated'),
-      deactivated: jasmine.createSpy('one deactivated'),
-      destroyed: jasmine.createSpy('one destroyed')
+      created: vi.fn(),
+      mounted: vi.fn(),
+      activated: vi.fn(),
+      deactivated: vi.fn(),
+      destroyed: vi.fn()
     }
     two = {
       template: '<div>two</div>',
-      created: jasmine.createSpy('two created'),
-      mounted: jasmine.createSpy('two mounted'),
-      activated: jasmine.createSpy('two activated'),
-      deactivated: jasmine.createSpy('two deactivated'),
-      destroyed: jasmine.createSpy('two destroyed')
+      created: vi.fn(),
+      mounted: vi.fn(),
+      activated: vi.fn(),
+      deactivated: vi.fn(),
+      destroyed: vi.fn()
     }
     components = {
       one,
@@ -33,11 +33,11 @@ describe('Component keep-alive', () => {
 
   function assertHookCalls (component, callCounts) {
     expect([
-      component.created.calls.count(),
-      component.mounted.calls.count(),
-      component.activated.calls.count(),
-      component.deactivated.calls.count(),
-      component.destroyed.calls.count()
+      component.created.mock.calls.length,
+      component.mounted.mock.calls.length,
+      component.activated.mock.calls.length,
+      component.deactivated.mock.calls.length,
+      component.destroyed.mock.calls.length
     ]).toEqual(callCounts)
   }
 
@@ -507,21 +507,21 @@ describe('Component keep-alive', () => {
   })
 
   it('max', done => {
-    const spyA = jasmine.createSpy()
-    const spyB = jasmine.createSpy()
-    const spyC = jasmine.createSpy()
-    const spyAD = jasmine.createSpy()
-    const spyBD = jasmine.createSpy()
-    const spyCD = jasmine.createSpy()
+    const spyA = vi.fn()
+    const spyB = vi.fn()
+    const spyC = vi.fn()
+    const spyAD = vi.fn()
+    const spyBD = vi.fn()
+    const spyCD = vi.fn()
 
     function assertCount (calls) {
       expect([
-        spyA.calls.count(),
-        spyAD.calls.count(),
-        spyB.calls.count(),
-        spyBD.calls.count(),
-        spyC.calls.count(),
-        spyCD.calls.count()
+        spyA.mock.calls.length,
+        spyAD.mock.calls.length,
+        spyB.mock.calls.length,
+        spyBD.mock.calls.length,
+        spyC.mock.calls.length,
+        spyCD.mock.calls.length
       ]).toEqual(calls)
     }
 
@@ -573,21 +573,21 @@ describe('Component keep-alive', () => {
   })
 
   it('max=1', done => {
-    const spyA = jasmine.createSpy()
-    const spyB = jasmine.createSpy()
-    const spyC = jasmine.createSpy()
-    const spyAD = jasmine.createSpy()
-    const spyBD = jasmine.createSpy()
-    const spyCD = jasmine.createSpy()
+    const spyA = vi.fn()
+    const spyB = vi.fn()
+    const spyC = vi.fn()
+    const spyAD = vi.fn()
+    const spyBD = vi.fn()
+    const spyCD = vi.fn()
 
     function assertCount (calls) {
       expect([
-        spyA.calls.count(),
-        spyAD.calls.count(),
-        spyB.calls.count(),
-        spyBD.calls.count(),
-        spyC.calls.count(),
-        spyCD.calls.count()
+        spyA.mock.calls.length,
+        spyAD.mock.calls.length,
+        spyB.mock.calls.length,
+        spyBD.mock.calls.length,
+        spyC.mock.calls.length,
+        spyCD.mock.calls.length
       ]).toEqual(calls)
     }
 
@@ -651,12 +651,12 @@ describe('Component keep-alive', () => {
     const Foo = {
       name: 'foo',
       template: `<div>foo</div>`,
-      created: jasmine.createSpy('foo')
+      created: vi.fn()
     }
 
     const Bar = {
       template: `<div>bar</div>`,
-      created: jasmine.createSpy('bar')
+      created: vi.fn()
     }
 
     const Child = {
@@ -679,8 +679,8 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     function assert (foo, bar) {
-      expect(Foo.created.calls.count()).toBe(foo)
-      expect(Bar.created.calls.count()).toBe(bar)
+      expect(Foo.created.mock.calls.length).toBe(foo)
+      expect(Bar.created.mock.calls.length).toBe(bar)
     }
 
     expect(vm.$el.textContent).toBe('foo')
@@ -703,12 +703,12 @@ describe('Component keep-alive', () => {
   it('should cache anonymous components if include is not specified', done => {
     const Foo = {
       template: `<div>foo</div>`,
-      created: jasmine.createSpy('foo')
+      created: vi.fn()
     }
 
     const Bar = {
       template: `<div>bar</div>`,
-      created: jasmine.createSpy('bar')
+      created: vi.fn()
     }
 
     const Child = {
@@ -731,8 +731,8 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     function assert (foo, bar) {
-      expect(Foo.created.calls.count()).toBe(foo)
-      expect(Bar.created.calls.count()).toBe(bar)
+      expect(Foo.created.mock.calls.length).toBe(foo)
+      expect(Bar.created.mock.calls.length).toBe(bar)
     }
 
     expect(vm.$el.textContent).toBe('foo')
@@ -756,7 +756,7 @@ describe('Component keep-alive', () => {
   it('should not destroy active instance when pruning cache', done => {
     const Foo = {
       template: `<div>foo</div>`,
-      destroyed: jasmine.createSpy('destroyed')
+      destroyed: vi.fn()
     }
     const vm = new Vue({
       template: `
@@ -1167,7 +1167,7 @@ describe('Component keep-alive', () => {
     })
 
     it('async components with transition-mode out-in', done => {
-      const barResolve = jasmine.createSpy('bar resolved')
+      const barResolve = vi.fn()
       let next
       const foo = (resolve) => {
         setTimeout(() => {
@@ -1231,7 +1231,7 @@ describe('Component keep-alive', () => {
         }).thenWaitFor(_next => { next = _next }).then(() => {
           // foo afterLeave get called
           // and bar has already been resolved before afterLeave get called
-          expect(barResolve.calls.count()).toBe(1)
+          expect(barResolve.mock.calls.length).toBe(1)
           expect(vm.$el.innerHTML).toBe('<!---->')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.innerHTML).toBe(
diff --git a/test/unit/features/component/component-scoped-slot.spec.ts b/test/unit/features/component/component-scoped-slot.spec.ts
index daf99928025..4ee111d3725 100644
--- a/test/unit/features/component/component-scoped-slot.spec.ts
+++ b/test/unit/features/component/component-scoped-slot.spec.ts
@@ -899,8 +899,8 @@ describe('Component scoped slot', () => {
 
   // 2.6 scoped slot perf optimization
   it('should have accurate tracking for scoped slots', done => {
-    const parentUpdate = jasmine.createSpy()
-    const childUpdate = jasmine.createSpy()
+    const parentUpdate = vi.fn()
+    const childUpdate = vi.fn()
     const vm = new Vue({
       template: `
         <div>{{ parentCount }}<foo #default>{{ childCount }}</foo></div>
@@ -923,15 +923,15 @@ describe('Component scoped slot', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toMatch(`1<div>0</div>`)
       // should only trigger parent update
-      expect(parentUpdate.calls.count()).toBe(1)
-      expect(childUpdate.calls.count()).toBe(0)
+      expect(parentUpdate.mock.calls.length).toBe(1)
+      expect(childUpdate.mock.calls.length).toBe(0)
 
       vm.childCount++
     }).then(() => {
       expect(vm.$el.innerHTML).toMatch(`1<div>1</div>`)
       // should only trigger child update
-      expect(parentUpdate.calls.count()).toBe(1)
-      expect(childUpdate.calls.count()).toBe(1)
+      expect(parentUpdate.mock.calls.length).toBe(1)
+      expect(childUpdate.mock.calls.length).toBe(1)
     }).then(done)
   })
 
@@ -972,7 +972,7 @@ describe('Component scoped slot', () => {
   // regression #9396
   it('should not force update child with no slot content', done => {
     const Child = {
-      updated: jasmine.createSpy(),
+      updated: vi.fn(),
       template: `<div></div>`
     }
 
diff --git a/test/unit/features/component/component-slot.spec.ts b/test/unit/features/component/component-slot.spec.ts
index 16fae86815f..ae2f7929eab 100644
--- a/test/unit/features/component/component-slot.spec.ts
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -131,7 +131,7 @@ describe('Component slot', () => {
   })
 
   it('fallback content should not be evaluated when the parent is providing it', () => {
-    const test = jasmine.createSpy('test')
+    const test = vi.fn()
     const vm = new Vue({
       template: '<test>slot default</test>',
       components: {
@@ -567,7 +567,7 @@ describe('Component slot', () => {
 
   // #3518
   it('events should not break when slot is toggled by v-if', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       template: `<test><div class="click" @click="test">hi</div></test>`,
       methods: {
diff --git a/test/unit/features/component/component.spec.ts b/test/unit/features/component/component.spec.ts
index 49d4ea53d91..587b0eec931 100644
--- a/test/unit/features/component/component.spec.ts
+++ b/test/unit/features/component/component.spec.ts
@@ -360,7 +360,7 @@ describe('Component', () => {
   })
 
   it('catch component render error and preserve previous vnode', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     Vue.config.errorHandler = spy
     const vm = new Vue({
       data: {
diff --git a/test/unit/features/debug.spec.ts b/test/unit/features/debug.spec.ts
index 6f04b18d917..4f510e79c77 100644
--- a/test/unit/features/debug.spec.ts
+++ b/test/unit/features/debug.spec.ts
@@ -88,7 +88,7 @@ found in
     const vm = new Vue()
 
     it('calls warnHandler if warnHandler is set', () => {
-      Vue.config.warnHandler = jasmine.createSpy()
+      Vue.config.warnHandler = vi.fn()
 
       warn(msg, vm)
 
diff --git a/test/unit/features/directives/for.spec.ts b/test/unit/features/directives/for.spec.ts
index eb28b09ca8d..384c722fe3a 100644
--- a/test/unit/features/directives/for.spec.ts
+++ b/test/unit/features/directives/for.spec.ts
@@ -627,7 +627,7 @@ describe('Directive v-for', () => {
 
   it('should warn component v-for without keys', () => {
     const warn = console.warn
-    console.warn = jasmine.createSpy()
+    console.warn = vi.fn()
     new Vue({
       template: `<div><test v-for="i in 3"></test></div>`,
       components: {
diff --git a/test/unit/features/directives/if.spec.ts b/test/unit/features/directives/if.spec.ts
index 458f1f92484..17851d2d6b0 100644
--- a/test/unit/features/directives/if.spec.ts
+++ b/test/unit/features/directives/if.spec.ts
@@ -243,8 +243,8 @@ describe('Directive v-if', () => {
   })
 
   it('should maintain stable list to avoid unnecessary patches', done => {
-    const created = jasmine.createSpy()
-    const destroyed = jasmine.createSpy()
+    const created = vi.fn()
+    const destroyed = vi.fn()
     const vm = new Vue({
       data: {
         ok: true
@@ -266,10 +266,10 @@ describe('Directive v-if', () => {
       }
     }).$mount()
 
-    expect(created.calls.count()).toBe(1)
+    expect(created.mock.calls.length).toBe(1)
     vm.ok = false
     waitForUpdate(() => {
-      expect(created.calls.count()).toBe(1)
+      expect(created.mock.calls.length).toBe(1)
       expect(destroyed).not.toHaveBeenCalled()
     }).then(done)
   })
diff --git a/test/unit/features/directives/model-component.spec.ts b/test/unit/features/directives/model-component.spec.ts
index 49ff4ddb138..52ccc9ad751 100644
--- a/test/unit/features/directives/model-component.spec.ts
+++ b/test/unit/features/directives/model-component.spec.ts
@@ -72,7 +72,7 @@ describe('Directive v-model component', () => {
   })
 
   it('should support customization via model option', done => {
-    const spy = jasmine.createSpy('update')
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         msg: 'hello'
diff --git a/test/unit/features/directives/model-radio.spec.ts b/test/unit/features/directives/model-radio.spec.ts
index 3ff4e50bca5..9c5198e5ef4 100644
--- a/test/unit/features/directives/model-radio.spec.ts
+++ b/test/unit/features/directives/model-radio.spec.ts
@@ -86,7 +86,7 @@ describe('Directive v-model radio', () => {
   })
 
   it('multiple radios ', (done) => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         selections: ['a', '1'],
diff --git a/test/unit/features/directives/model-select.spec.ts b/test/unit/features/directives/model-select.spec.ts
index 4fffe73a4f3..ba8439344ec 100644
--- a/test/unit/features/directives/model-select.spec.ts
+++ b/test/unit/features/directives/model-select.spec.ts
@@ -207,7 +207,7 @@ describe('Directive v-model select', () => {
   })
 
   it('should work with select which has no default selected options', (done) => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         id: 4,
@@ -228,7 +228,7 @@ describe('Directive v-model select', () => {
     document.body.appendChild(vm.$el)
     vm.testChange = 10
     waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(0)
+      expect(spy.mock.calls.length).toBe(0)
     }).then(done)
   })
 
@@ -296,7 +296,7 @@ describe('Directive v-model select', () => {
   }
 
   it('should work with multiple binding', (done) => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         isMultiple: true,
@@ -352,7 +352,7 @@ describe('Directive v-model select', () => {
   })
 
   it('multiple selects', (done) => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         selections: ['', ''],
@@ -520,7 +520,7 @@ describe('Directive v-model select', () => {
 
   // #6193
   it('should not trigger change event when matching option can be found for each value', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         options: ['1']
diff --git a/test/unit/features/directives/model-text.spec.ts b/test/unit/features/directives/model-text.spec.ts
index 7cf5167461f..9b0a7445831 100644
--- a/test/unit/features/directives/model-text.spec.ts
+++ b/test/unit/features/directives/model-text.spec.ts
@@ -136,7 +136,7 @@ describe('Directive v-model text', () => {
   })
 
   it('multiple inputs', (done) => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         selections: [[1, 2, 3], [4, 5]],
@@ -230,7 +230,7 @@ describe('Directive v-model text', () => {
 
   // #3468
   it('should have higher priority than user v-on events', () => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         a: 'a'
@@ -317,7 +317,7 @@ describe('Directive v-model text', () => {
 
   if (!isAndroid) {
     it('does not trigger extra input events with single compositionend', () => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         data: {
           a: 'a'
@@ -329,16 +329,16 @@ describe('Directive v-model text', () => {
           }
         }
       }).$mount()
-      expect(spy.calls.count()).toBe(0)
+      expect(spy.mock.calls.length).toBe(0)
       vm.$el.value = 'b'
       triggerEvent(vm.$el, 'input')
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       triggerEvent(vm.$el, 'compositionend')
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     })
 
     it('triggers extra input on compositionstart + end', () => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         data: {
           a: 'a'
@@ -350,13 +350,13 @@ describe('Directive v-model text', () => {
           }
         }
       }).$mount()
-      expect(spy.calls.count()).toBe(0)
+      expect(spy.mock.calls.length).toBe(0)
       vm.$el.value = 'b'
       triggerEvent(vm.$el, 'input')
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       triggerEvent(vm.$el, 'compositionstart')
       triggerEvent(vm.$el, 'compositionend')
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
     })
 
     // #4392
diff --git a/test/unit/features/directives/on.spec.ts b/test/unit/features/directives/on.spec.ts
index 46f0f9a9881..2f8771be94a 100644
--- a/test/unit/features/directives/on.spec.ts
+++ b/test/unit/features/directives/on.spec.ts
@@ -6,7 +6,7 @@ describe('Directive v-on', () => {
 
   beforeEach(() => {
     vm = null
-    spy = jasmine.createSpy()
+    spy = vi.fn()
     el = document.createElement('div')
     document.body.appendChild(el)
   })
@@ -24,7 +24,7 @@ describe('Directive v-on', () => {
       methods: { foo: spy }
     })
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
 
     const args = spy.calls.allArgs()
     const event = args[0] && args[0][0] || {}
@@ -38,7 +38,7 @@ describe('Directive v-on', () => {
       methods: { foo: spy }
     })
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
 
     const args = spy.calls.allArgs()
     const firstArgs = args[0]
@@ -50,7 +50,7 @@ describe('Directive v-on', () => {
   })
 
   it('should support inline function expression', () => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     vm = new Vue({
       el,
       template: `<div class="test" @click="function (e) { log(e.target.className) }"></div>`,
@@ -69,7 +69,7 @@ describe('Directive v-on', () => {
       methods: { foo: spy }
     })
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 
   it('should support stop propagation', () => {
@@ -130,9 +130,9 @@ describe('Directive v-on', () => {
       methods: { foo: spy }
     })
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1) // should no longer trigger
+    expect(spy.mock.calls.length).toBe(1) // should no longer trigger
   })
 
   // #4655
@@ -148,14 +148,14 @@ describe('Directive v-on', () => {
       methods: { foo: spy }
     })
     triggerEvent(vm.$refs.one, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$refs.one, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$refs.two, 'click')
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
     triggerEvent(vm.$refs.one, 'click')
     triggerEvent(vm.$refs.two, 'click')
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
   })
 
   it('should support capture and once', () => {
@@ -190,7 +190,7 @@ describe('Directive v-on', () => {
     triggerEvent(vm.$el, 'click')
     expect(spy).toHaveBeenCalled()
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 
   it('should support keyCode', () => {
@@ -233,24 +233,24 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$refs.ctrl, 'keyup')
-    expect(spy.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(0)
     triggerEvent(vm.$refs.ctrl, 'keyup', e => { e.ctrlKey = true })
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
 
     triggerEvent(vm.$refs.shift, 'keyup')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$refs.shift, 'keyup', e => { e.shiftKey = true })
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
 
     triggerEvent(vm.$refs.alt, 'keyup')
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
     triggerEvent(vm.$refs.alt, 'keyup', e => { e.altKey = true })
-    expect(spy.calls.count()).toBe(3)
+    expect(spy.mock.calls.length).toBe(3)
 
     triggerEvent(vm.$refs.meta, 'keyup')
-    expect(spy.calls.count()).toBe(3)
+    expect(spy.mock.calls.length).toBe(3)
     triggerEvent(vm.$refs.meta, 'keyup', e => { e.metaKey = true })
-    expect(spy.calls.count()).toBe(4)
+    expect(spy.mock.calls.length).toBe(4)
   })
 
   it('should support exact modifier', () => {
@@ -265,19 +265,19 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$refs.ctrl, 'keyup')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
 
     triggerEvent(vm.$refs.ctrl, 'keyup', e => {
       e.ctrlKey = true
     })
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
 
     // should not trigger if has other system modifiers
     triggerEvent(vm.$refs.ctrl, 'keyup', e => {
       e.ctrlKey = true
       e.altKey = true
     })
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 
   it('should support system modifiers with exact', () => {
@@ -292,19 +292,19 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$refs.ctrl, 'keyup')
-    expect(spy.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(0)
 
     triggerEvent(vm.$refs.ctrl, 'keyup', e => {
       e.ctrlKey = true
     })
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
 
     // should not trigger if has other system modifiers
     triggerEvent(vm.$refs.ctrl, 'keyup', e => {
       e.ctrlKey = true
       e.altKey = true
     })
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 
   it('should support number keyCode', () => {
@@ -323,9 +323,9 @@ describe('Directive v-on', () => {
     const left = 0
     const middle = 1
     const right = 2
-    const spyLeft = jasmine.createSpy()
-    const spyMiddle = jasmine.createSpy()
-    const spyRight = jasmine.createSpy()
+    const spyLeft = vi.fn()
+    const spyMiddle = vi.fn()
+    const spyRight = vi.fn()
 
     vm = new Vue({
       el,
@@ -378,17 +378,17 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$refs.enter, 'keyup', e => { e.key = 'Enter' })
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$refs.space, 'keyup', e => { e.key = ' ' })
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
     triggerEvent(vm.$refs.esc, 'keyup', e => { e.key = 'Escape' })
-    expect(spy.calls.count()).toBe(3)
+    expect(spy.mock.calls.length).toBe(3)
     triggerEvent(vm.$refs.left, 'keyup', e => { e.key = 'ArrowLeft' })
-    expect(spy.calls.count()).toBe(4)
+    expect(spy.mock.calls.length).toBe(4)
     triggerEvent(vm.$refs.delete, 'keyup', e => { e.key = 'Backspace' })
-    expect(spy.calls.count()).toBe(5)
+    expect(spy.mock.calls.length).toBe(5)
     triggerEvent(vm.$refs.delete, 'keyup', e => { e.key = 'Delete' })
-    expect(spy.calls.count()).toBe(6)
+    expect(spy.mock.calls.length).toBe(6)
   })
 
   it('should support custom keyCode', () => {
@@ -471,7 +471,7 @@ describe('Directive v-on', () => {
 
     triggerEvent(vm.$el, 'click')
     expect(`The .native modifier for v-on is only valid on components but it was used on <button>.`).toHaveBeenWarned()
-    expect(spy.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(0)
   })
 
   it('should not throw a warning if native modifier is used on a dynamic component', () => {
@@ -500,13 +500,13 @@ describe('Directive v-on', () => {
       }
     })
     vm.$children[0].$emit('custom')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     vm.$children[0].$emit('custom')
-    expect(spy.calls.count()).toBe(1) // should not be called again
+    expect(spy.mock.calls.length).toBe(1) // should not be called again
   })
 
   it('remove listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
+    const spy2 = vi.fn()
     vm = new Vue({
       el,
       methods: { foo: spy, bar: spy2 },
@@ -520,19 +520,19 @@ describe('Directive v-on', () => {
       }
     })
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
-    expect(spy2.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(1)
+    expect(spy2.mock.calls.length).toBe(0)
     vm.ok = false
     waitForUpdate(() => {
       triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
+      expect(spy.mock.calls.length).toBe(1) // should no longer trigger
       triggerEvent(vm.$el, 'input')
-      expect(spy2.calls.count()).toBe(1)
+      expect(spy2.mock.calls.length).toBe(1)
     }).then(done)
   })
 
   it('remove capturing listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
+    const spy2 = vi.fn()
     vm = new Vue({
       el,
       methods: { foo: spy, bar: spy2, stopped (ev) { ev.stopPropagation() } },
@@ -546,19 +546,19 @@ describe('Directive v-on', () => {
       }
     })
     triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy.calls.count()).toBe(1)
-    expect(spy2.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(1)
+    expect(spy2.mock.calls.length).toBe(0)
     vm.ok = false
     waitForUpdate(() => {
       triggerEvent(vm.$el.firstChild, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
+      expect(spy.mock.calls.length).toBe(1) // should no longer trigger
       triggerEvent(vm.$el, 'mouseOver')
-      expect(spy2.calls.count()).toBe(1)
+      expect(spy2.mock.calls.length).toBe(1)
     }).then(done)
   })
 
   it('remove once listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
+    const spy2 = vi.fn()
     vm = new Vue({
       el,
       methods: { foo: spy, bar: spy2 },
@@ -572,21 +572,21 @@ describe('Directive v-on', () => {
       }
     })
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$el, 'click')
-    expect(spy.calls.count()).toBe(1) // should no longer trigger
-    expect(spy2.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(1) // should no longer trigger
+    expect(spy2.mock.calls.length).toBe(0)
     vm.ok = false
     waitForUpdate(() => {
       triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
+      expect(spy.mock.calls.length).toBe(1) // should no longer trigger
       triggerEvent(vm.$el, 'input')
-      expect(spy2.calls.count()).toBe(1)
+      expect(spy2.mock.calls.length).toBe(1)
     }).then(done)
   })
 
   it('remove capturing and once listener', done => {
-    const spy2 = jasmine.createSpy('remove listener')
+    const spy2 = vi.fn()
     vm = new Vue({
       el,
       methods: { foo: spy, bar: spy2, stopped (ev) { ev.stopPropagation() } },
@@ -600,21 +600,21 @@ describe('Directive v-on', () => {
       }
     })
     triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     triggerEvent(vm.$el.firstChild, 'click')
-    expect(spy.calls.count()).toBe(1) // should no longer trigger
-    expect(spy2.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(1) // should no longer trigger
+    expect(spy2.mock.calls.length).toBe(0)
     vm.ok = false
     waitForUpdate(() => {
       triggerEvent(vm.$el.firstChild, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
+      expect(spy.mock.calls.length).toBe(1) // should no longer trigger
       triggerEvent(vm.$el, 'mouseOver')
-      expect(spy2.calls.count()).toBe(1)
+      expect(spy2.mock.calls.length).toBe(1)
     }).then(done)
   })
 
   it('remove listener on child component', done => {
-    const spy2 = jasmine.createSpy('remove listener')
+    const spy2 = vi.fn()
     vm = new Vue({
       el,
       methods: { foo: spy, bar: spy2 },
@@ -633,14 +633,14 @@ describe('Directive v-on', () => {
       }
     })
     vm.$children[0].$emit('foo')
-    expect(spy.calls.count()).toBe(1)
-    expect(spy2.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(1)
+    expect(spy2.mock.calls.length).toBe(0)
     vm.ok = false
     waitForUpdate(() => {
       vm.$children[0].$emit('foo')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
+      expect(spy.mock.calls.length).toBe(1) // should no longer trigger
       vm.$children[0].$emit('bar')
-      expect(spy2.calls.count()).toBe(1)
+      expect(spy2.mock.calls.length).toBe(1)
     }).then(done)
   })
 
@@ -658,10 +658,10 @@ describe('Directive v-on', () => {
 
   // Github Issue #5046
   it('should support keyboard modifier for direction keys', () => {
-    const spyLeft = jasmine.createSpy()
-    const spyRight = jasmine.createSpy()
-    const spyUp = jasmine.createSpy()
-    const spyDown = jasmine.createSpy()
+    const spyLeft = vi.fn()
+    const spyRight = vi.fn()
+    const spyUp = vi.fn()
+    const spyDown = vi.fn()
     vm = new Vue({
       el,
       template: `
@@ -691,10 +691,10 @@ describe('Directive v-on', () => {
     triggerEvent(vm.$refs.down, 'keydown', e => { e.keyCode = 40 })
     triggerEvent(vm.$refs.down, 'keydown', e => { e.keyCode = 39 })
 
-    expect(spyLeft.calls.count()).toBe(1)
-    expect(spyRight.calls.count()).toBe(1)
-    expect(spyUp.calls.count()).toBe(1)
-    expect(spyDown.calls.count()).toBe(1)
+    expect(spyLeft.mock.calls.length).toBe(1)
+    expect(spyRight.mock.calls.length).toBe(1)
+    expect(spyUp.mock.calls.length).toBe(1)
+    expect(spyDown.mock.calls.length).toBe(1)
   })
 
   // This test case should only run when the test browser supports passive.
@@ -751,7 +751,7 @@ describe('Directive v-on', () => {
   })
 
   it('should transform click.right to contextmenu', () => {
-    const spy = jasmine.createSpy('click.right')
+    const spy = vi.fn()
     const vm = new Vue({
       template: `<div @click.right="foo"></div>`,
       methods: { foo: spy }
@@ -762,7 +762,7 @@ describe('Directive v-on', () => {
   })
 
   it('should transform click.middle to mouseup', () => {
-    const spy = jasmine.createSpy('click.middle')
+    const spy = vi.fn()
     vm = new Vue({
       el,
       template: `<div @click.middle="foo"></div>`,
@@ -775,8 +775,8 @@ describe('Directive v-on', () => {
   })
 
   it('object syntax (no argument)', () => {
-    const click = jasmine.createSpy('click')
-    const mouseup = jasmine.createSpy('mouseup')
+    const click = vi.fn()
+    const mouseup = vi.fn()
     vm = new Vue({
       el,
       template: `<button v-on="listeners">foo</button>`,
@@ -789,18 +789,18 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$el, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(0)
+    expect(click.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(0)
 
     triggerEvent(vm.$el, 'mouseup')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(1)
   })
 
   it('object syntax (no argument, mixed with normal listeners)', () => {
-    const click1 = jasmine.createSpy('click1')
-    const click2 = jasmine.createSpy('click2')
-    const mouseup = jasmine.createSpy('mouseup')
+    const click1 = vi.fn()
+    const click2 = vi.fn()
+    const mouseup = vi.fn()
     vm = new Vue({
       el,
       template: `<button v-on="listeners" @click="click2">foo</button>`,
@@ -816,20 +816,20 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$el, 'click')
-    expect(click1.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(0)
+    expect(click1.mock.calls.length).toBe(1)
+    expect(click2.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(0)
 
     triggerEvent(vm.$el, 'mouseup')
-    expect(click1.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
+    expect(click1.mock.calls.length).toBe(1)
+    expect(click2.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(1)
   })
 
   it('object syntax (usage in HOC, mixed with native listeners)', () => {
-    const click = jasmine.createSpy('click')
-    const mouseup = jasmine.createSpy('mouseup')
-    const mousedown = jasmine.createSpy('mousedown')
+    const click = vi.fn()
+    const mouseup = vi.fn()
+    const mousedown = vi.fn()
 
     vm = new Vue({
       el,
@@ -855,19 +855,19 @@ describe('Directive v-on', () => {
     })
 
     triggerEvent(vm.$el, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(0)
-    expect(mousedown.calls.count()).toBe(0)
+    expect(click.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(0)
+    expect(mousedown.mock.calls.length).toBe(0)
 
     triggerEvent(vm.$el, 'mouseup')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
-    expect(mousedown.calls.count()).toBe(0)
+    expect(click.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(1)
+    expect(mousedown.mock.calls.length).toBe(0)
 
     triggerEvent(vm.$el, 'mousedown')
-    expect(click.calls.count()).toBe(1)
-    expect(mouseup.calls.count()).toBe(1)
-    expect(mousedown.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
+    expect(mouseup.mock.calls.length).toBe(1)
+    expect(mousedown.mock.calls.length).toBe(1)
   })
 
   // #6805 (v-on="object" bind order problem)
@@ -948,7 +948,7 @@ describe('Directive v-on', () => {
     vm.ok = false
     waitForUpdate(() => {
       triggerEvent(vm.$el.childNodes[0], 'click')
-      expect(spy.calls.count()).toBe(0)
+      expect(spy.mock.calls.length).toBe(0)
     }).then(done)
   })
 
@@ -984,12 +984,12 @@ describe('Directive v-on', () => {
     })
     // simulating autocomplete event (Event object with type keyup but without keyCode)
     triggerEvent(vm.$el, 'keyup')
-    expect(spy.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(0)
   })
 
   describe('dynamic arguments', () => {
     it('basic', done => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         template: `<div v-on:[key]="spy"></div>`,
         data: {
@@ -1000,25 +1000,25 @@ describe('Directive v-on', () => {
         }
       }).$mount()
       triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       vm.key = 'mouseup'
       waitForUpdate(() => {
         triggerEvent(vm.$el, 'click')
-        expect(spy.calls.count()).toBe(1)
+        expect(spy.mock.calls.length).toBe(1)
         triggerEvent(vm.$el, 'mouseup')
-        expect(spy.calls.count()).toBe(2)
+        expect(spy.mock.calls.length).toBe(2)
         // explicit null value
         vm.key = null
       }).then(() => {
         triggerEvent(vm.$el, 'click')
-        expect(spy.calls.count()).toBe(2)
+        expect(spy.mock.calls.length).toBe(2)
         triggerEvent(vm.$el, 'mouseup')
-        expect(spy.calls.count()).toBe(2)
+        expect(spy.mock.calls.length).toBe(2)
       }).then(done)
     })
 
     it('shorthand', done => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         template: `<div @[key]="spy"></div>`,
         data: {
@@ -1029,18 +1029,18 @@ describe('Directive v-on', () => {
         }
       }).$mount()
       triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       vm.key = 'mouseup'
       waitForUpdate(() => {
         triggerEvent(vm.$el, 'click')
-        expect(spy.calls.count()).toBe(1)
+        expect(spy.mock.calls.length).toBe(1)
         triggerEvent(vm.$el, 'mouseup')
-        expect(spy.calls.count()).toBe(2)
+        expect(spy.mock.calls.length).toBe(2)
       }).then(done)
     })
 
     it('with .middle modifier', () => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         template: `<div @[key].middle="spy"></div>`,
         data: {
@@ -1057,7 +1057,7 @@ describe('Directive v-on', () => {
     })
 
     it('with .right modifier', () => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         template: `<div @[key].right="spy"></div>`,
         data: {
@@ -1098,9 +1098,9 @@ describe('Directive v-on', () => {
         methods: { foo: spy }
       }).$mount()
       triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       triggerEvent(vm.$el, 'click')
-      expect(spy.calls.count()).toBe(1) // should no longer trigger
+      expect(spy.mock.calls.length).toBe(1) // should no longer trigger
     })
   })
 })
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index cf838b2feec..ea1903ac7e0 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -149,7 +149,7 @@ describe('Error handling', () => {
   })
 
   it('config.errorHandler should capture render errors', done => {
-    const spy = Vue.config.errorHandler = jasmine.createSpy('errorHandler')
+    const spy = Vue.config.errorHandler = vi.fn()
     const vm = createTestInstance(components.render)
 
     const args = spy.calls.argsFor(0)
@@ -165,7 +165,7 @@ describe('Error handling', () => {
   it('should capture and recover from nextTick errors', done => {
     const err1 = new Error('nextTick')
     const err2 = new Error('nextTick2')
-    const spy = Vue.config.errorHandler = jasmine.createSpy('errorHandler')
+    const spy = Vue.config.errorHandler = vi.fn()
     Vue.nextTick(() => { throw err1 })
     Vue.nextTick(() => {
       expect(spy).toHaveBeenCalledWith(err1, undefined, 'nextTick')
diff --git a/test/unit/features/global-api/config.spec.ts b/test/unit/features/global-api/config.spec.ts
index f2e5074ce72..fb8f45d2152 100644
--- a/test/unit/features/global-api/config.spec.ts
+++ b/test/unit/features/global-api/config.spec.ts
@@ -25,7 +25,7 @@ describe('Global config', () => {
 
   describe('optionMergeStrategies', () => {
     it('should allow defining custom option merging strategies', () => {
-      const spy = jasmine.createSpy('option merging')
+      const spy = vi.fn()
       Vue.config.optionMergeStrategies.__test__ = (parent, child, vm) => {
         spy(parent, child, vm)
         return child + 1
@@ -33,13 +33,13 @@ describe('Global config', () => {
       const Test = Vue.extend({
         __test__: 1
       })
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       expect(spy).toHaveBeenCalledWith(undefined, 1, undefined)
       expect(Test.options.__test__).toBe(2)
       const test = new Test({
         __test__: 2
       })
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
       expect(spy).toHaveBeenCalledWith(2, 2, test)
       expect(test.$options.__test__).toBe(3)
     })
@@ -58,7 +58,7 @@ describe('Global config', () => {
 
   describe('async', () => {
     it('does not update synchronously when true', () => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       const vm = new Vue({
         template: `<div :class="value"></div>`,
         updated: spy,
@@ -69,7 +69,7 @@ describe('Global config', () => {
     })
 
     it('updates synchronously when false', () => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       Vue.config.async = false
       const vm = new Vue({
         template: `<div :class="value"></div>`,
diff --git a/test/unit/features/global-api/mixin.spec.ts b/test/unit/features/global-api/mixin.spec.ts
index 503b1ff157b..23edf82b49b 100644
--- a/test/unit/features/global-api/mixin.spec.ts
+++ b/test/unit/features/global-api/mixin.spec.ts
@@ -6,7 +6,7 @@ describe('Global API: mixin', () => {
   afterEach(() => { Vue.options = options })
 
   it('should work', () => {
-    const spy = jasmine.createSpy('global mixin')
+    const spy = vi.fn()
     Vue.mixin({
       created () {
         spy(this.$options.myOption)
@@ -87,7 +87,7 @@ describe('Global API: mixin', () => {
 
   // #4976
   it('should not drop late-attached custom options on existing constructors', () => {
-    const baseSpy = jasmine.createSpy('base')
+    const baseSpy = vi.fn()
     const Base = Vue.extend({
       beforeCreate: baseSpy
     })
@@ -100,11 +100,11 @@ describe('Global API: mixin', () => {
       $style: () => 123
     }
 
-    const spy = jasmine.createSpy('late attached')
+    const spy = vi.fn()
     Test.options.beforeCreate = Test.options.beforeCreate.concat(spy)
 
     // Update super constructor's options
-    const mixinSpy = jasmine.createSpy('mixin')
+    const mixinSpy = vi.fn()
     Vue.mixin({
       beforeCreate: mixinSpy
     })
@@ -114,9 +114,9 @@ describe('Global API: mixin', () => {
       template: '<div>{{ $style }}</div>'
     }).$mount()
 
-    expect(spy.calls.count()).toBe(1)
-    expect(baseSpy.calls.count()).toBe(1)
-    expect(mixinSpy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
+    expect(baseSpy.mock.calls.length).toBe(1)
+    expect(mixinSpy.mock.calls.length).toBe(1)
     expect(vm.$el.textContent).toBe('123')
     expect(vm.$style).toBe(123)
 
@@ -127,7 +127,7 @@ describe('Global API: mixin', () => {
 
   // vue-class-component#83
   it('should work for a constructor mixin', () => {
-    const spy = jasmine.createSpy('global mixin')
+    const spy = vi.fn()
     const Mixin = Vue.extend({
       created () {
         spy(this.$options.myOption)
@@ -144,13 +144,13 @@ describe('Global API: mixin', () => {
 
   // vue-class-component#87
   it('should not drop original lifecycle hooks', () => {
-    const base = jasmine.createSpy('base')
+    const base = vi.fn()
 
     const Base = Vue.extend({
       beforeCreate: base
     })
 
-    const injected = jasmine.createSpy('injected')
+    const injected = vi.fn()
 
     // inject a function
     Base.options.beforeCreate = Base.options.beforeCreate.concat(injected)
@@ -170,7 +170,7 @@ describe('Global API: mixin', () => {
 
   // #9198
   it('should not mix global mixin lifecycle hook twice', () => {
-    const spy = jasmine.createSpy('global mixed in lifecycle hook')
+    const spy = vi.fn()
     Vue.mixin({
       created: spy
     })
@@ -192,6 +192,6 @@ describe('Global API: mixin', () => {
     const vm = new Child()
 
     expect(typeof vm.$options.methods.a).toBe('function')
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 })
diff --git a/test/unit/features/instance/methods-data.spec.ts b/test/unit/features/instance/methods-data.spec.ts
index 64050397abe..616d5295aa9 100644
--- a/test/unit/features/instance/methods-data.spec.ts
+++ b/test/unit/features/instance/methods-data.spec.ts
@@ -21,7 +21,7 @@ describe('Instance methods data', () => {
   describe('$watch', () => {
     let vm, spy
     beforeEach(() => {
-      spy = jasmine.createSpy('watch')
+      spy = vi.fn()
       vm = new Vue({
         data: {
           a: {
@@ -41,18 +41,18 @@ describe('Instance methods data', () => {
       vm.$watch('a.b', spy)
       vm.a.b = 2
       waitForUpdate(() => {
-        expect(spy.calls.count()).toBe(1)
+        expect(spy.mock.calls.length).toBe(1)
         expect(spy).toHaveBeenCalledWith(2, 1)
         vm.a = { b: 3 }
       }).then(() => {
-        expect(spy.calls.count()).toBe(2)
+        expect(spy.mock.calls.length).toBe(2)
         expect(spy).toHaveBeenCalledWith(3, 2)
       }).then(done)
     })
 
     it('immediate', () => {
       vm.$watch('a.b', spy, { immediate: true })
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       expect(spy).toHaveBeenCalledWith(1)
     })
 
@@ -61,7 +61,7 @@ describe('Instance methods data', () => {
       unwatch()
       vm.a.b = 2
       waitForUpdate(() => {
-        expect(spy.calls.count()).toBe(0)
+        expect(spy.mock.calls.length).toBe(0)
       }).then(done)
     })
 
@@ -107,7 +107,7 @@ describe('Instance methods data', () => {
         handler: 'foo',
         immediate: true
       })
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       expect(spy).toHaveBeenCalledWith(1)
     })
 
@@ -116,7 +116,7 @@ describe('Instance methods data', () => {
         handler: 'foo',
         immediate: true
       })
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       expect(spy).toHaveBeenCalledWith('ok')
     })
 
diff --git a/test/unit/features/instance/methods-events.spec.ts b/test/unit/features/instance/methods-events.spec.ts
index b35a35ccec5..09aa52825f4 100644
--- a/test/unit/features/instance/methods-events.spec.ts
+++ b/test/unit/features/instance/methods-events.spec.ts
@@ -5,7 +5,7 @@ describe('Instance methods events', () => {
   beforeEach(() => {
     // @ts-expect-error
     const vm = new Vue()
-    spy = jasmine.createSpy('emitter')
+    spy = vi.fn()
   })
 
   it('$on', () => {
@@ -15,7 +15,7 @@ describe('Instance methods events', () => {
       spy.apply(this, arguments)
     })
     vm.$emit('test', 1, 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     expect(spy).toHaveBeenCalledWith(1, 2, 3, 4)
   })
 
@@ -25,10 +25,10 @@ describe('Instance methods events', () => {
       spy.apply(this, arguments)
     })
     vm.$emit('test1', 1, 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     expect(spy).toHaveBeenCalledWith(1, 2, 3, 4)
     vm.$emit('test2', 5, 6, 7, 8)
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
     expect(spy).toHaveBeenCalledWith(5, 6, 7, 8)
   })
 
@@ -39,7 +39,7 @@ describe('Instance methods events', () => {
     vm.$emit('test2')
     expect(spy).not.toHaveBeenCalled()
     vm.$emit('test3', 1, 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 
   it('$off multi event without callback', () => {
@@ -53,7 +53,7 @@ describe('Instance methods events', () => {
     vm.$once('test', spy)
     vm.$emit('test', 1, 2, 3)
     vm.$emit('test', 2, 3, 4)
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     expect(spy).toHaveBeenCalledWith(1, 2, 3)
   })
 
@@ -80,18 +80,18 @@ describe('Instance methods events', () => {
     vm.$off('test1') // test off something that's already off
     vm.$emit('test1', 1)
     vm.$emit('test2', 2)
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     expect(spy).toHaveBeenCalledWith(2)
   })
 
   it('$off event + fn', () => {
-    const spy2 = jasmine.createSpy('emitter')
+    const spy2 = vi.fn()
     vm.$on('test', spy)
     vm.$on('test', spy2)
     vm.$off('test', spy)
     vm.$emit('test', 1, 2, 3)
     expect(spy).not.toHaveBeenCalled()
-    expect(spy2.calls.count()).toBe(1)
+    expect(spy2.mock.calls.length).toBe(1)
     expect(spy2).toHaveBeenCalledWith(1, 2, 3)
   })
 })
diff --git a/test/unit/features/instance/methods-lifecycle.spec.ts b/test/unit/features/instance/methods-lifecycle.spec.ts
index a2c5b86e920..3af73efbb69 100644
--- a/test/unit/features/instance/methods-lifecycle.spec.ts
+++ b/test/unit/features/instance/methods-lifecycle.spec.ts
@@ -57,7 +57,7 @@ describe('Instance methods lifecycle', () => {
     it('Dep.target should be undefined during invocation of child immediate watcher', done => {
       let calls = 0
       const childData = { a: 1 }
-      const parentUpdate = jasmine.createSpy()
+      const parentUpdate = vi.fn()
       new Vue({
         template: '<div><my-component></my-component></div>',
         updated: parentUpdate,
@@ -117,13 +117,13 @@ describe('Instance methods lifecycle', () => {
     })
 
     it('avoid duplicate calls', () => {
-      const spy = jasmine.createSpy('destroy')
+      const spy = vi.fn()
       const vm = new Vue({
         beforeDestroy: spy
       })
       vm.$destroy()
       vm.$destroy()
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     })
   })
 
diff --git a/test/unit/features/instance/properties.spec.ts b/test/unit/features/instance/properties.spec.ts
index 2f06223b6ab..3e4f365335e 100644
--- a/test/unit/features/instance/properties.spec.ts
+++ b/test/unit/features/instance/properties.spec.ts
@@ -168,8 +168,8 @@ describe('Instance properties', () => {
   })
 
   it('$listeners', done => {
-    const spyA = jasmine.createSpy('A')
-    const spyB = jasmine.createSpy('B')
+    const spyA = vi.fn()
+    const spyB = vi.fn()
     const vm = new Vue({
       template: `<foo @click="foo"/>`,
       data: { foo: spyA },
@@ -184,14 +184,14 @@ describe('Instance properties', () => {
     document.body.appendChild(vm.$el)
 
     triggerEvent(vm.$el, 'click')
-    expect(spyA.calls.count()).toBe(1)
-    expect(spyB.calls.count()).toBe(0)
+    expect(spyA.mock.calls.length).toBe(1)
+    expect(spyB.mock.calls.length).toBe(0)
 
     vm.foo = spyB
     waitForUpdate(() => {
       triggerEvent(vm.$el, 'click')
-      expect(spyA.calls.count()).toBe(1)
-      expect(spyB.calls.count()).toBe(1)
+      expect(spyA.mock.calls.length).toBe(1)
+      expect(spyB.mock.calls.length).toBe(1)
       document.body.removeChild(vm.$el)
     }).then(done)
   })
diff --git a/test/unit/features/options/computed.spec.ts b/test/unit/features/options/computed.spec.ts
index 17cd9516640..b2616b1382c 100644
--- a/test/unit/features/options/computed.spec.ts
+++ b/test/unit/features/options/computed.spec.ts
@@ -91,7 +91,7 @@ describe('Options computed', () => {
   })
 
   it('watching computed', done => {
-    const spy = jasmine.createSpy('watch computed')
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         a: 1
@@ -108,7 +108,7 @@ describe('Options computed', () => {
   })
 
   it('caching', () => {
-    const spy = jasmine.createSpy('cached computed')
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         a: 1
@@ -120,15 +120,15 @@ describe('Options computed', () => {
         }
       }
     })
-    expect(spy.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(0)
     vm.b
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     vm.b
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
   })
 
   it('cache: false', () => {
-    const spy = jasmine.createSpy('cached computed')
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         a: 1
@@ -143,11 +143,11 @@ describe('Options computed', () => {
         }
       }
     })
-    expect(spy.calls.count()).toBe(0)
+    expect(spy.mock.calls.length).toBe(0)
     vm.b
-    expect(spy.calls.count()).toBe(1)
+    expect(spy.mock.calls.length).toBe(1)
     vm.b
-    expect(spy.calls.count()).toBe(2)
+    expect(spy.mock.calls.length).toBe(2)
   })
 
   it('as component', done => {
diff --git a/test/unit/features/options/directives.spec.ts b/test/unit/features/options/directives.spec.ts
index f7a69402d0b..6560e1146a4 100644
--- a/test/unit/features/options/directives.spec.ts
+++ b/test/unit/features/options/directives.spec.ts
@@ -2,11 +2,11 @@ import Vue from 'vue'
 
 describe('Options directives', () => {
   it('basic usage', done => {
-    const bindSpy = jasmine.createSpy('bind')
-    const insertedSpy = jasmine.createSpy('inserted')
-    const updateSpy = jasmine.createSpy('update')
-    const componentUpdatedSpy = jasmine.createSpy('componentUpdated')
-    const unbindSpy = jasmine.createSpy('unbind')
+    const bindSpy = vi.fn()
+    const insertedSpy = vi.fn()
+    const updateSpy = vi.fn()
+    const componentUpdatedSpy = vi.fn()
+    const unbindSpy = vi.fn()
 
     const assertContext = (el, binding, vnode) => {
       expect(vnode.context).toBe(vm)
@@ -75,7 +75,7 @@ describe('Options directives', () => {
       expect(unbindSpy).not.toHaveBeenCalled()
       vm.msg = 'bye'
     }).then(() => {
-      expect(componentUpdatedSpy.calls.count()).toBe(2)
+      expect(componentUpdatedSpy.mock.calls.length).toBe(2)
       vm.ok = false
     }).then(() => {
       expect(unbindSpy).toHaveBeenCalled()
@@ -83,7 +83,7 @@ describe('Options directives', () => {
   })
 
   it('function shorthand', done => {
-    const spy = jasmine.createSpy('directive')
+    const spy = vi.fn()
     const vm = new Vue({
       template: '<div v-test:arg.hello="a"></div>',
       data: { a: 'foo' },
@@ -105,7 +105,7 @@ describe('Options directives', () => {
   })
 
   it('function shorthand (global)', done => {
-    const spy = jasmine.createSpy('directive')
+    const spy = vi.fn()
     Vue.directive('test', function (el, binding, vnode) {
       expect(vnode.context).toBe(vm)
       expect(binding.arg).toBe('arg')
@@ -153,7 +153,7 @@ describe('Options directives', () => {
 
   it('should properly handle same node with different directive sets', done => {
     const spies = {}
-    const createSpy = name => (spies[name] = jasmine.createSpy(name))
+    const createSpy = name => (spies[name] = vi.fn())
     const vm = new Vue({
       data: {
         ok: true,
@@ -183,41 +183,41 @@ describe('Options directives', () => {
       }
     }).$mount()
 
-    expect(spies.bind1.calls.count()).toBe(2)
-    expect(spies.inserted1.calls.count()).toBe(2)
-    expect(spies.bind2.calls.count()).toBe(0)
-    expect(spies.inserted2.calls.count()).toBe(0)
+    expect(spies.bind1.mock.calls.length).toBe(2)
+    expect(spies.inserted1.mock.calls.length).toBe(2)
+    expect(spies.bind2.mock.calls.length).toBe(0)
+    expect(spies.inserted2.mock.calls.length).toBe(0)
 
     vm.ok = false
     waitForUpdate(() => {
       // v-test with modifier should be updated
-      expect(spies.update1.calls.count()).toBe(1)
-      expect(spies.componentUpdated1.calls.count()).toBe(1)
+      expect(spies.update1.mock.calls.length).toBe(1)
+      expect(spies.componentUpdated1.mock.calls.length).toBe(1)
 
       // v-test without modifier should be unbound
-      expect(spies.unbind1.calls.count()).toBe(1)
+      expect(spies.unbind1.mock.calls.length).toBe(1)
 
       // v-test2 should be bound
-      expect(spies.bind2.calls.count()).toBe(1)
-      expect(spies.inserted2.calls.count()).toBe(1)
+      expect(spies.bind2.mock.calls.length).toBe(1)
+      expect(spies.inserted2.mock.calls.length).toBe(1)
 
       vm.ok = true
     }).then(() => {
       // v-test without modifier should be bound again
-      expect(spies.bind1.calls.count()).toBe(3)
-      expect(spies.inserted1.calls.count()).toBe(3)
+      expect(spies.bind1.mock.calls.length).toBe(3)
+      expect(spies.inserted1.mock.calls.length).toBe(3)
 
       // v-test2 should be unbound
-      expect(spies.unbind2.calls.count()).toBe(1)
+      expect(spies.unbind2.mock.calls.length).toBe(1)
 
       // v-test with modifier should be updated again
-      expect(spies.update1.calls.count()).toBe(2)
-      expect(spies.componentUpdated1.calls.count()).toBe(2)
+      expect(spies.update1.mock.calls.length).toBe(2)
+      expect(spies.componentUpdated1.mock.calls.length).toBe(2)
 
       vm.val = 234
     }).then(() => {
-      expect(spies.update1.calls.count()).toBe(4)
-      expect(spies.componentUpdated1.calls.count()).toBe(4)
+      expect(spies.update1.mock.calls.length).toBe(4)
+      expect(spies.componentUpdated1.mock.calls.length).toBe(4)
     }).then(done)
   })
 
@@ -231,9 +231,9 @@ describe('Options directives', () => {
   // #6513
   it('should invoke unbind & inserted on inner component root element change', done => {
     const dir = {
-      bind: jasmine.createSpy('bind'),
-      inserted: jasmine.createSpy('inserted'),
-      unbind: jasmine.createSpy('unbind')
+      bind: vi.fn(),
+      inserted: vi.fn(),
+      unbind: vi.fn()
     }
 
     const Child = {
@@ -248,20 +248,20 @@ describe('Options directives', () => {
     }).$mount()
 
     const oldEl = vm.$el
-    expect(dir.bind.calls.count()).toBe(1)
+    expect(dir.bind.mock.calls.length).toBe(1)
     expect(dir.bind.calls.argsFor(0)[0]).toBe(oldEl)
-    expect(dir.inserted.calls.count()).toBe(1)
+    expect(dir.inserted.mock.calls.length).toBe(1)
     expect(dir.inserted.calls.argsFor(0)[0]).toBe(oldEl)
     expect(dir.unbind).not.toHaveBeenCalled()
 
     vm.$refs.child.ok = false
     waitForUpdate(() => {
       expect(vm.$el.tagName).toBe('SPAN')
-      expect(dir.bind.calls.count()).toBe(2)
+      expect(dir.bind.mock.calls.length).toBe(2)
       expect(dir.bind.calls.argsFor(1)[0]).toBe(vm.$el)
-      expect(dir.inserted.calls.count()).toBe(2)
+      expect(dir.inserted.mock.calls.length).toBe(2)
       expect(dir.inserted.calls.argsFor(1)[0]).toBe(vm.$el)
-      expect(dir.unbind.calls.count()).toBe(1)
+      expect(dir.unbind.mock.calls.length).toBe(1)
       expect(dir.unbind.calls.argsFor(0)[0]).toBe(oldEl)
     }).then(done)
   })
diff --git a/test/unit/features/options/errorCaptured.spec.ts b/test/unit/features/options/errorCaptured.spec.ts
index bf87144a5fb..bcda50b6e21 100644
--- a/test/unit/features/options/errorCaptured.spec.ts
+++ b/test/unit/features/options/errorCaptured.spec.ts
@@ -4,7 +4,7 @@ describe('Options errorCaptured', () => {
   let globalSpy
 
   beforeEach(() => {
-    globalSpy = Vue.config.errorHandler = jasmine.createSpy()
+    globalSpy = Vue.config.errorHandler = vi.fn()
   })
 
   afterEach(() => {
@@ -12,7 +12,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should capture error from child component', () => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
 
     let child
     let err
@@ -68,7 +68,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should not propagate to global handler when returning true', () => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
 
     let child
     let err
@@ -249,7 +249,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should capture error from watcher', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
 
     let child
     let err
@@ -285,7 +285,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should capture promise error from watcher', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
 
     let child
     let err
@@ -323,7 +323,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should capture error from immediate watcher', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
 
     let child
     let err
@@ -360,7 +360,7 @@ describe('Options errorCaptured', () => {
   })
 
   it('should capture promise error from immediate watcher', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
 
     let child
     let err
diff --git a/test/unit/features/options/extends.spec.ts b/test/unit/features/options/extends.spec.ts
index 1734640202e..3ea9c4624af 100644
--- a/test/unit/features/options/extends.spec.ts
+++ b/test/unit/features/options/extends.spec.ts
@@ -52,7 +52,7 @@ describe('Options extends', () => {
     it('should work with global mixins + Object.prototype.watch', done => {
       Vue.mixin({})
 
-      const spy = jasmine.createSpy('watch')
+      const spy = vi.fn()
       const A = Vue.extend({
         data: function () {
           return { a: 1 }
diff --git a/test/unit/features/options/functional.spec.ts b/test/unit/features/options/functional.spec.ts
index ea85eea8a7f..eb4c52a7b20 100644
--- a/test/unit/features/options/functional.spec.ts
+++ b/test/unit/features/options/functional.spec.ts
@@ -51,8 +51,8 @@ describe('Options functional', () => {
   })
 
   it('should expose data.on as listeners', () => {
-    const foo = jasmine.createSpy('foo')
-    const bar = jasmine.createSpy('bar')
+    const foo = vi.fn()
+    const bar = vi.fn()
     const vm = new Vue({
       template: '<div><wrap @click="foo" @test="bar"/></div>',
       methods: { foo, bar },
@@ -134,7 +134,7 @@ describe('Options functional', () => {
   })
 
   it('should let vnode raw data pass through', done => {
-    const onValid = jasmine.createSpy('valid')
+    const onValid = vi.fn()
     const vm = new Vue({
       data: { msg: 'hello' },
       template: `<div>
diff --git a/test/unit/features/options/lifecycle.spec.ts b/test/unit/features/options/lifecycle.spec.ts
index 245ef197202..03f1dec9317 100644
--- a/test/unit/features/options/lifecycle.spec.ts
+++ b/test/unit/features/options/lifecycle.spec.ts
@@ -3,7 +3,7 @@ import Vue from 'vue'
 describe('Options lifecycle hooks', () => {
   let spy
   beforeEach(() => {
-    spy = jasmine.createSpy('hook')
+    spy = vi.fn()
   })
 
   describe('beforeCreate', () => {
@@ -156,8 +156,8 @@ describe('Options lifecycle hooks', () => {
 
     // #8076
     it('should not be called after destroy', done => {
-      const beforeUpdate = jasmine.createSpy('beforeUpdate')
-      const destroyed = jasmine.createSpy('destroyed')
+      const beforeUpdate = vi.fn()
+      const destroyed = vi.fn()
 
       Vue.component('todo', {
         template: '<div>{{todo.done}}</div>',
@@ -240,8 +240,8 @@ describe('Options lifecycle hooks', () => {
 
     // #8076
     it('should not be called after destroy', done => {
-      const updated = jasmine.createSpy('updated')
-      const destroyed = jasmine.createSpy('destroyed')
+      const updated = vi.fn()
+      const destroyed = vi.fn()
 
       Vue.component('todo', {
         template: '<div>{{todo.done}}</div>',
@@ -290,7 +290,7 @@ describe('Options lifecycle hooks', () => {
       vm.$destroy()
       vm.$destroy()
       expect(spy).toHaveBeenCalled()
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     })
   })
 
@@ -308,14 +308,14 @@ describe('Options lifecycle hooks', () => {
       vm.$destroy()
       vm.$destroy()
       expect(spy).toHaveBeenCalled()
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     })
   })
 
   it('should emit hook events', () => {
-    const created = jasmine.createSpy()
-    const mounted = jasmine.createSpy()
-    const destroyed = jasmine.createSpy()
+    const created = vi.fn()
+    const mounted = vi.fn()
+    const destroyed = vi.fn()
     const vm = new Vue({
       render () {},
       beforeCreate () {
diff --git a/test/unit/features/options/mixins.spec.ts b/test/unit/features/options/mixins.spec.ts
index 373f8867091..09be22903f1 100644
--- a/test/unit/features/options/mixins.spec.ts
+++ b/test/unit/features/options/mixins.spec.ts
@@ -111,8 +111,8 @@ describe('Options mixins', () => {
   })
 
   it('should accept further extended constructors as mixins', () => {
-    const spy1 = jasmine.createSpy('mixinA')
-    const spy2 = jasmine.createSpy('mixinB')
+    const spy1 = vi.fn()
+    const spy2 = vi.fn()
 
     const mixinA = Vue.extend({
       created: spy1,
diff --git a/test/unit/features/options/props.spec.ts b/test/unit/features/options/props.spec.ts
index 2ada45a0553..6a6c1ffde75 100644
--- a/test/unit/features/options/props.spec.ts
+++ b/test/unit/features/options/props.spec.ts
@@ -169,56 +169,56 @@ describe('Options props', () => {
 
     it('string', () => {
       makeInstance('hello', String)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(123, String)
       expect('Expected String with value "123", got Number with value 123').toHaveBeenWarned()
     })
 
     it('number', () => {
       makeInstance(123, Number)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance('123', Number)
       expect('Expected Number with value 123, got String with value "123"').toHaveBeenWarned()
     })
 
     it('number & boolean', () => {
       makeInstance(123, Number)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(false, Number)
       expect('Expected Number, got Boolean with value false').toHaveBeenWarned()
     })
 
     it('string & boolean', () => {
       makeInstance('hello', String)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(true, String)
       expect('Expected String, got Boolean with value true').toHaveBeenWarned()
     })
 
     it('boolean', () => {
       makeInstance(true, Boolean)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance('123', Boolean)
       expect('Expected Boolean, got String with value "123"').toHaveBeenWarned()
     })
 
     it('function', () => {
       makeInstance(() => {}, Function)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(123, Function)
       expect('Expected Function, got Number with value 123').toHaveBeenWarned()
     })
 
     it('object', () => {
       makeInstance({}, Object)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance([], Object)
       expect('Expected Object, got Array').toHaveBeenWarned()
     })
 
     it('array', () => {
       makeInstance([], Array)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance({}, Array)
       expect('Expected Array, got Object').toHaveBeenWarned()
     })
@@ -226,18 +226,18 @@ describe('Options props', () => {
     it('primitive wrapper objects', () => {
       /* eslint-disable no-new-wrappers */
       makeInstance(new String('s'), String)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(new Number(1), Number)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(new Boolean(true), Boolean)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       /* eslint-enable no-new-wrappers */
     })
 
     if (hasSymbol) {
       it('symbol', () => {
         makeInstance(Symbol('foo'), Symbol)
-        expect(console.error.calls.count()).toBe(0)
+        expect(console.error.mock.calls.length).toBe(0)
         makeInstance({}, Symbol)
         expect('Expected Symbol, got Object').toHaveBeenWarned()
       })
@@ -252,12 +252,12 @@ describe('Options props', () => {
         expect('Expected String, Number, got Symbol').toHaveBeenWarned()
       })
     }
-	
+
     if (typeof BigInt !== 'undefined') {
       /* global BigInt */
       it('bigint', () => {
         makeInstance(BigInt(100), BigInt)
-        expect(console.error.calls.count()).toBe(0)
+        expect(console.error.mock.calls.length).toBe(0)
         makeInstance({}, BigInt)
         expect('Expected BigInt, got Object').toHaveBeenWarned()
       })
@@ -266,28 +266,28 @@ describe('Options props', () => {
     it('custom constructor', () => {
       function Class () {}
       makeInstance(new Class(), Class)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance({}, Class)
       expect('type check failed').toHaveBeenWarned()
     })
 
     it('multiple types', () => {
       makeInstance([], [Array, Number, Boolean])
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance({}, [Array, Number, Boolean])
       expect('Expected Array, Number, Boolean, got Object').toHaveBeenWarned()
     })
 
     it('custom validator', () => {
       makeInstance(123, null, v => v === 123)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(123, null, v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
     })
 
     it('type check + custom validator', () => {
       makeInstance(123, Number, v => v === 123)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(123, Number, v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
       makeInstance(123, String, v => v === 123)
@@ -296,7 +296,7 @@ describe('Options props', () => {
 
     it('multiple types + custom validator', () => {
       makeInstance(123, [Number, String, Boolean], v => v === 123)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(123, [Number, String, Boolean], v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
       makeInstance(123, [String, Boolean], v => v === 123)
@@ -305,31 +305,31 @@ describe('Options props', () => {
 
     it('optional with type + null/undefined', () => {
       makeInstance(undefined, String)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(null, String)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
     })
 
     it('required with type + null/undefined', () => {
       makeInstance(undefined, String, null, true)
-      expect(console.error.calls.count()).toBe(1)
+      expect(console.error.mock.calls.length).toBe(1)
       expect('Expected String').toHaveBeenWarned()
       makeInstance(null, Boolean, null, true)
-      expect(console.error.calls.count()).toBe(2)
+      expect(console.error.mock.calls.length).toBe(2)
       expect('Expected Boolean').toHaveBeenWarned()
     })
 
     it('optional prop of any type (type: true or prop: true)', () => {
       makeInstance(1, true)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance('any', true)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance({}, true)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(undefined, true)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
       makeInstance(null, true)
-      expect(console.error.calls.count()).toBe(0)
+      expect(console.error.mock.calls.length).toBe(0)
     })
   })
 
@@ -468,12 +468,12 @@ describe('Options props', () => {
         }
       }
     }).$mount()
-    expect(console.error.calls.count()).toBe(0)
+    expect(console.error.mock.calls.length).toBe(0)
   })
 
   // #3453
   it('should not fire watcher on object/array props when parent re-renders', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         arr: []
@@ -497,7 +497,7 @@ describe('Options props', () => {
 
   // #4090
   it('should not trigger watcher on default value', done => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       template: `<test :value="a" :test="b"></test>`,
       data: {
@@ -526,14 +526,14 @@ describe('Options props', () => {
       expect(spy).not.toHaveBeenCalled()
       vm.b = {}
     }).then(() => {
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     }).then(() => {
       vm.b = undefined
     }).then(() => {
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
       vm.a++
     }).then(() => {
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
     }).then(done)
   })
 
diff --git a/test/unit/features/options/renderError.spec.ts b/test/unit/features/options/renderError.spec.ts
index 4b4b04be801..d25c4f48a5c 100644
--- a/test/unit/features/options/renderError.spec.ts
+++ b/test/unit/features/options/renderError.spec.ts
@@ -27,7 +27,7 @@ describe('Options renderError', () => {
   })
 
   it('should pass on errors in renderError to global handler', () => {
-    const spy = Vue.config.errorHandler = jasmine.createSpy()
+    const spy = Vue.config.errorHandler = vi.fn()
     const err = new Error('renderError')
     const vm = new Vue({
       render () {
diff --git a/test/unit/features/options/watch.spec.ts b/test/unit/features/options/watch.spec.ts
index 3938bd33c92..234852a038b 100644
--- a/test/unit/features/options/watch.spec.ts
+++ b/test/unit/features/options/watch.spec.ts
@@ -5,7 +5,7 @@ import { finished } from 'stream';
 describe('Options watch', () => {
   let spy
   beforeEach(() => {
-    spy = jasmine.createSpy('watch')
+    spy = vi.fn()
   })
 
   testObjectOption('watch')
@@ -48,7 +48,7 @@ describe('Options watch', () => {
   })
 
   it('multiple cbs (after option merge)', done => {
-    const spy1 = jasmine.createSpy('watch')
+    const spy1 = vi.fn()
     const Test = Vue.extend({
       watch: {
         a: spy1
@@ -107,8 +107,8 @@ describe('Options watch', () => {
   })
 
   it('correctly merges multiple extends', done => {
-    const spy2 = jasmine.createSpy('A')
-    const spy3 = jasmine.createSpy('B')
+    const spy2 = vi.fn()
+    const spy3 = vi.fn()
     const A = Vue.extend({
       data: function () {
         return {
diff --git a/test/unit/features/transition/transition-group.spec.ts b/test/unit/features/transition/transition-group.spec.ts
index 2988d5bff4a..f109a8c26b7 100644
--- a/test/unit/features/transition/transition-group.spec.ts
+++ b/test/unit/features/transition/transition-group.spec.ts
@@ -177,9 +177,9 @@ if (!isIE9) {
 
     it('events', done => {
       let next
-      const beforeEnterSpy = jasmine.createSpy()
-      const afterEnterSpy = jasmine.createSpy()
-      const afterLeaveSpy = jasmine.createSpy()
+      const beforeEnterSpy = vi.fn()
+      const afterEnterSpy = vi.fn()
+      const afterLeaveSpy = vi.fn()
       const vm = new Vue({
         template: `
           <div>
@@ -219,7 +219,7 @@ if (!isIE9) {
             `<div class="test v-enter v-enter-active">d</div>` +
           `</span>`
         )
-        expect(beforeEnterSpy.calls.count()).toBe(1)
+        expect(beforeEnterSpy.mock.calls.length).toBe(1)
       }).thenWaitFor(_next => { next = _next }).then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
@@ -229,7 +229,7 @@ if (!isIE9) {
             `<div class="test">d</div>` +
           `</span>`
         )
-        expect(afterEnterSpy.calls.count()).toBe(1)
+        expect(afterEnterSpy.mock.calls.length).toBe(1)
         vm.items.shift()
       }).thenWaitFor(_next => { next = _next }).then(() => {
         expect(vm.$el.innerHTML).toBe(
@@ -239,7 +239,7 @@ if (!isIE9) {
             `<div class="test">d</div>` +
           `</span>`
         )
-        expect(afterLeaveSpy.calls.count()).toBe(1)
+        expect(afterLeaveSpy.mock.calls.length).toBe(1)
       }).then(done)
     })
 
diff --git a/test/unit/features/transition/transition.spec.ts b/test/unit/features/transition/transition.spec.ts
index c258ae711ff..dc992e753c0 100644
--- a/test/unit/features/transition/transition.spec.ts
+++ b/test/unit/features/transition/transition.spec.ts
@@ -137,8 +137,8 @@ if (!isIE9) {
     })
 
     it('inline transition object', done => {
-      const enter = jasmine.createSpy('enter')
-      const leave = jasmine.createSpy('leave')
+      const enter = vi.fn()
+      const leave = vi.fn()
       const vm = new Vue({
         render (h) {
           return h('div', null, [
@@ -184,12 +184,12 @@ if (!isIE9) {
     })
 
     it('transition events', done => {
-      const onLeaveSpy = jasmine.createSpy('leave')
-      const onEnterSpy = jasmine.createSpy('enter')
-      const beforeLeaveSpy = jasmine.createSpy('beforeLeave')
-      const beforeEnterSpy = jasmine.createSpy('beforeEnter')
-      const afterLeaveSpy = jasmine.createSpy('afterLeave')
-      const afterEnterSpy = jasmine.createSpy('afterEnter')
+      const onLeaveSpy = vi.fn()
+      const onEnterSpy = vi.fn()
+      const beforeLeaveSpy = vi.fn()
+      const beforeEnterSpy = vi.fn()
+      const afterLeaveSpy = vi.fn()
+      const afterEnterSpy = vi.fn()
 
       const vm = new Vue({
         template: `
@@ -259,12 +259,12 @@ if (!isIE9) {
     })
 
     it('transition events (v-show)', done => {
-      const onLeaveSpy = jasmine.createSpy('leave')
-      const onEnterSpy = jasmine.createSpy('enter')
-      const beforeLeaveSpy = jasmine.createSpy('beforeLeave')
-      const beforeEnterSpy = jasmine.createSpy('beforeEnter')
-      const afterLeaveSpy = jasmine.createSpy('afterLeave')
-      const afterEnterSpy = jasmine.createSpy('afterEnter')
+      const onLeaveSpy = vi.fn()
+      const onEnterSpy = vi.fn()
+      const beforeLeaveSpy = vi.fn()
+      const beforeEnterSpy = vi.fn()
+      const afterLeaveSpy = vi.fn()
+      const afterEnterSpy = vi.fn()
 
       const vm = new Vue({
         template: `
@@ -386,8 +386,8 @@ if (!isIE9) {
     })
 
     it('css: false', done => {
-      const enterSpy = jasmine.createSpy('enter')
-      const leaveSpy = jasmine.createSpy('leave')
+      const enterSpy = vi.fn()
+      const leaveSpy = vi.fn()
       const vm = new Vue({
         template: `
           <div>
@@ -415,8 +415,8 @@ if (!isIE9) {
     })
 
     it('no transition detected', done => {
-      const enterSpy = jasmine.createSpy('enter')
-      const leaveSpy = jasmine.createSpy('leave')
+      const enterSpy = vi.fn()
+      const leaveSpy = vi.fn()
       const vm = new Vue({
         template: '<div><transition name="nope" @enter="enter" @leave="leave"><div v-if="ok">foo</div></transition></div>',
         data: { ok: true },
@@ -442,7 +442,7 @@ if (!isIE9) {
     })
 
     it('enterCancelled', done => {
-      const spy = jasmine.createSpy('enterCancelled')
+      const spy = vi.fn()
       const vm = new Vue({
         template: `
           <div>
@@ -476,7 +476,7 @@ if (!isIE9) {
     })
 
     it('should remove stale leaving elements', done => {
-      const spy = jasmine.createSpy('afterLeave')
+      const spy = vi.fn()
       const vm = new Vue({
         template: `
           <div>
@@ -579,7 +579,7 @@ if (!isIE9) {
     })
 
     it('leaveCancelled (v-show only)', done => {
-      const spy = jasmine.createSpy('leaveCancelled')
+      const spy = vi.fn()
       const vm = new Vue({
         template: `
           <div>
diff --git a/test/unit/modules/compiler/codegen.spec.ts b/test/unit/modules/compiler/codegen.spec.ts
index a31f751d64e..5c18388d6e0 100644
--- a/test/unit/modules/compiler/codegen.spec.ts
+++ b/test/unit/modules/compiler/codegen.spec.ts
@@ -622,7 +622,7 @@ describe('codegen', () => {
       `with(this){return _c("myComponent",{tag:"div"})}`
     )
     expect('Inline-template components must have exactly one child element.').toHaveBeenWarned()
-    expect(console.error.calls.count()).toBe(3)
+    expect(console.error.mock.calls.length).toBe(3)
   })
 
   it('generate static trees inside v-for', () => {
diff --git a/test/unit/modules/compiler/parser.spec.ts b/test/unit/modules/compiler/parser.spec.ts
index b47de581396..1e6f1567335 100644
--- a/test/unit/modules/compiler/parser.spec.ts
+++ b/test/unit/modules/compiler/parser.spec.ts
@@ -676,8 +676,8 @@ describe('parser', () => {
 
   it('pre/post transforms', () => {
     const options = extend({}, baseOptions)
-    const spy1 = jasmine.createSpy('preTransform')
-    const spy2 = jasmine.createSpy('postTransform')
+    const spy1 = vi.fn()
+    const spy2 = vi.fn()
     options.modules = options.modules.concat([{
       preTransformNode (el) {
         spy1(el.tag)
diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index f175ae3d878..698931dcee4 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -187,7 +187,7 @@ describe('Observer', () => {
         this.deps.push(dep)
         dep.addSub(this)
       },
-      update: jasmine.createSpy()
+      update: vi.fn()
     }
     // collect dep
     Dep.target = watcher
@@ -195,10 +195,10 @@ describe('Observer', () => {
     Dep.target = null
     expect(watcher.deps.length).toBe(3) // obj.a + a + a.b
     obj.a.b = 3
-    expect(watcher.update.calls.count()).toBe(1)
+    expect(watcher.update.mock.calls.length).toBe(1)
     // swap object
     obj.a = { b: 4 }
-    expect(watcher.update.calls.count()).toBe(2)
+    expect(watcher.update.mock.calls.length).toBe(2)
     watcher.deps = []
 
     Dep.target = watcher
@@ -208,10 +208,10 @@ describe('Observer', () => {
     expect(watcher.deps.length).toBe(4)
     // set on the swapped object
     obj.a.b = 5
-    expect(watcher.update.calls.count()).toBe(3)
+    expect(watcher.update.mock.calls.length).toBe(3)
     // should not trigger on NaN -> NaN set
     obj.c = NaN
-    expect(watcher.update.calls.count()).toBe(3)
+    expect(watcher.update.mock.calls.length).toBe(3)
   })
 
   it('observing object prop change on defined property', () => {
@@ -242,22 +242,22 @@ describe('Observer', () => {
     spyOn(dep1, 'notify')
     setProp(obj1, 'b', 2)
     expect(obj1.b).toBe(2)
-    expect(dep1.notify.calls.count()).toBe(1)
+    expect(dep1.notify.mock.calls.length).toBe(1)
     delProp(obj1, 'a')
     expect(hasOwn(obj1, 'a')).toBe(false)
-    expect(dep1.notify.calls.count()).toBe(2)
+    expect(dep1.notify.mock.calls.length).toBe(2)
     // set existing key, should be a plain set and not
     // trigger own ob's notify
     setProp(obj1, 'b', 3)
     expect(obj1.b).toBe(3)
-    expect(dep1.notify.calls.count()).toBe(2)
+    expect(dep1.notify.mock.calls.length).toBe(2)
     // set non-existing key
     setProp(obj1, 'c', 1)
     expect(obj1.c).toBe(1)
-    expect(dep1.notify.calls.count()).toBe(3)
+    expect(dep1.notify.mock.calls.length).toBe(3)
     // should ignore deleting non-existing key
     delProp(obj1, 'a')
-    expect(dep1.notify.calls.count()).toBe(3)
+    expect(dep1.notify.mock.calls.length).toBe(3)
     // should work on non-observed objects
     const obj2 = { a: 1 }
     delProp(obj2, 'a')
@@ -270,10 +270,10 @@ describe('Observer', () => {
     spyOn(dep3, 'notify')
     setProp(obj3, 'b', 2)
     expect(obj3.b).toBe(2)
-    expect(dep3.notify.calls.count()).toBe(1)
+    expect(dep3.notify.mock.calls.length).toBe(1)
     delProp(obj3, 'a')
     expect(hasOwn(obj3, 'a')).toBe(false)
-    expect(dep3.notify.calls.count()).toBe(2)
+    expect(dep3.notify.mock.calls.length).toBe(2)
     // set and delete non-numeric key on array
     const arr2 = ['a']
     const ob2 = observe(arr2)
@@ -281,10 +281,10 @@ describe('Observer', () => {
     spyOn(dep2, 'notify')
     setProp(arr2, 'b', 2)
     expect(arr2.b).toBe(2)
-    expect(dep2.notify.calls.count()).toBe(1)
+    expect(dep2.notify.mock.calls.length).toBe(1)
     delProp(arr2, 'b')
     expect(hasOwn(arr2, 'b')).toBe(false)
-    expect(dep2.notify.calls.count()).toBe(2)
+    expect(dep2.notify.mock.calls.length).toBe(2)
   })
 
   it('warning set/delete on a Vue instance', done => {
@@ -339,7 +339,7 @@ describe('Observer', () => {
     arr.splice(0, 0, objs[2])
     arr.sort()
     arr.reverse()
-    expect(dep.notify.calls.count()).toBe(7)
+    expect(dep.notify.mock.calls.length).toBe(7)
     // inserted elements should be observed
     objs.forEach(obj => {
       expect(obj.__ob__ instanceof Observer).toBe(true)
diff --git a/test/unit/modules/observer/scheduler.spec.ts b/test/unit/modules/observer/scheduler.spec.ts
index 20409957e7f..f17f75f94ec 100644
--- a/test/unit/modules/observer/scheduler.spec.ts
+++ b/test/unit/modules/observer/scheduler.spec.ts
@@ -12,7 +12,7 @@ function queueWatcher (watcher) {
 describe('Scheduler', () => {
   let spy
   beforeEach(() => {
-    spy = jasmine.createSpy('scheduler')
+    spy = vi.fn()
   })
 
   it('queueWatcher', done => {
@@ -20,7 +20,7 @@ describe('Scheduler', () => {
       run: spy
     })
     waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     }).then(done)
   })
 
@@ -34,7 +34,7 @@ describe('Scheduler', () => {
       run: spy
     })
     waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
     }).then(done)
   })
 
@@ -49,7 +49,7 @@ describe('Scheduler', () => {
       run () { queueWatcher(job) }
     })
     waitForUpdate(() => {
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
     }).then(done)
   })
 
diff --git a/test/unit/modules/observer/watcher.spec.ts b/test/unit/modules/observer/watcher.spec.ts
index 724a3cc8637..810a72b6dc7 100644
--- a/test/unit/modules/observer/watcher.spec.ts
+++ b/test/unit/modules/observer/watcher.spec.ts
@@ -16,7 +16,7 @@ describe('Watcher', () => {
         msg: 'yo'
       }
     }).$mount()
-    spy = jasmine.createSpy('watcher')
+    spy = vi.fn()
   })
 
   it('path', done => {
@@ -44,7 +44,7 @@ describe('Watcher', () => {
     waitForUpdate(() => {
       expect(watcher1.value).toBe(123)
       expect(watcher2.value).toBeUndefined()
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       expect(spy).toHaveBeenCalledWith(123, undefined)
     }).then(done)
   })
@@ -85,11 +85,11 @@ describe('Watcher', () => {
       vm.b = { c: [{ a: 1 }] }
     }).then(() => {
       expect(spy).toHaveBeenCalledWith(vm.b, oldB)
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
       vm.b.c[0].a = 2
     }).then(() => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(3)
+      expect(spy.mock.calls.length).toBe(3)
     }).then(done)
   })
 
@@ -110,11 +110,11 @@ describe('Watcher', () => {
     Vue.set(vm.b, '_', vm.b)
     waitForUpdate(() => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       vm.b._.c = 1
     }).then(() => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
     }).then(done)
   })
 
@@ -123,10 +123,10 @@ describe('Watcher', () => {
     Vue.set(vm.b, 'e', 123)
     waitForUpdate(() => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.calls.count()).toBe(1)
+      expect(spy.mock.calls.length).toBe(1)
       Vue.delete(vm.b, 'e')
     }).then(() => {
-      expect(spy.calls.count()).toBe(2)
+      expect(spy.mock.calls.length).toBe(2)
     }).then(done)
   })
 
diff --git a/test/unit/modules/util/error.spec.ts b/test/unit/modules/util/error.spec.ts
index c9152bbb7bc..2db5e7531ab 100644
--- a/test/unit/modules/util/error.spec.ts
+++ b/test/unit/modules/util/error.spec.ts
@@ -5,8 +5,8 @@ describe('invokeWithErrorHandling', () => {
   if (typeof Promise !== 'undefined') {
     it('should errorHandler call once when nested calls return rejected promise', done => {
       const originalHandler = Vue.config.errorHandler
-      const handler = Vue.config.errorHandler = jasmine.createSpy()
-      const userCatch = jasmine.createSpy()
+      const handler = Vue.config.errorHandler = vi.fn()
+      const userCatch = vi.fn()
       const err = new Error('fake error')
 
       invokeWithErrorHandling(() => {
@@ -15,7 +15,7 @@ describe('invokeWithErrorHandling', () => {
         })
       }).catch(userCatch).then(() => {
         Vue.config.errorHandler = originalHandler
-        expect(handler.calls.count()).toBe(1)
+        expect(handler.mock.calls.length).toBe(1)
         expect(userCatch).toHaveBeenCalledWith(err)
         done()
       })
diff --git a/test/unit/modules/util/next-tick.spec.ts b/test/unit/modules/util/next-tick.spec.ts
index 53f6124c1bb..353848b488f 100644
--- a/test/unit/modules/util/next-tick.spec.ts
+++ b/test/unit/modules/util/next-tick.spec.ts
@@ -23,7 +23,7 @@ describe('nextTick', () => {
     })
 
     it('returned Promise should resolve correctly vs callback', done => {
-      const spy = jasmine.createSpy()
+      const spy = vi.fn()
       nextTick(spy)
       nextTick().then(() => {
         expect(spy).toHaveBeenCalled()
diff --git a/test/unit/modules/vdom/modules/directive.spec.ts b/test/unit/modules/vdom/modules/directive.spec.ts
index 38c53186891..c19b316f0eb 100644
--- a/test/unit/modules/vdom/modules/directive.spec.ts
+++ b/test/unit/modules/vdom/modules/directive.spec.ts
@@ -5,9 +5,9 @@ import VNode from 'core/vdom/vnode'
 describe('vdom directive module', () => {
   it('should work', () => {
     const directive1 = {
-      bind: jasmine.createSpy('bind'),
-      update: jasmine.createSpy('update'),
-      unbind: jasmine.createSpy('unbind')
+      bind: vi.fn(),
+      update: vi.fn(),
+      unbind: vi.fn()
     }
     const vm = new Vue({ directives: { directive1 }})
     // create
diff --git a/test/unit/modules/vdom/modules/events.spec.ts b/test/unit/modules/vdom/modules/events.spec.ts
index b59935adbf8..7ee6169f10c 100644
--- a/test/unit/modules/vdom/modules/events.spec.ts
+++ b/test/unit/modules/vdom/modules/events.spec.ts
@@ -3,17 +3,17 @@ import VNode from 'core/vdom/vnode'
 
 describe('vdom events module', () => {
   it('should attach event handler to element', () => {
-    const click = jasmine.createSpy()
+    const click = vi.fn()
     const vnode = new VNode('a', { on: { click }})
 
     const elm = patch(null, vnode)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
   })
 
   it('should not duplicate the same listener', () => {
-    const click = jasmine.createSpy()
+    const click = vi.fn()
     const vnode1 = new VNode('a', { on: { click }})
     const vnode2 = new VNode('a', { on: { click }})
 
@@ -21,90 +21,90 @@ describe('vdom events module', () => {
     patch(vnode1, vnode2)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
   })
 
   it('should update different listener', () => {
-    const click = jasmine.createSpy()
-    const click2 = jasmine.createSpy()
+    const click = vi.fn()
+    const click2 = vi.fn()
     const vnode1 = new VNode('a', { on: { click }})
     const vnode2 = new VNode('a', { on: { click: click2 }})
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(0)
+    expect(click.mock.calls.length).toBe(1)
+    expect(click2.mock.calls.length).toBe(0)
 
     patch(vnode1, vnode2)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
+    expect(click2.mock.calls.length).toBe(1)
   })
 
   it('should attach Array of multiple handlers', () => {
-    const click = jasmine.createSpy()
+    const click = vi.fn()
     const vnode = new VNode('a', { on: { click: [click, click] }})
 
     const elm = patch(null, vnode)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
+    expect(click.mock.calls.length).toBe(2)
   })
 
   it('should update Array of multiple handlers', () => {
-    const click = jasmine.createSpy()
-    const click2 = jasmine.createSpy()
+    const click = vi.fn()
+    const click2 = vi.fn()
     const vnode1 = new VNode('a', { on: { click: [click, click2] }})
     const vnode2 = new VNode('a', { on: { click: [click] }})
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
+    expect(click2.mock.calls.length).toBe(1)
 
     patch(vnode1, vnode2)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-    expect(click2.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(2)
+    expect(click2.mock.calls.length).toBe(1)
   })
 
   it('should remove handlers that are no longer present', () => {
-    const click = jasmine.createSpy()
+    const click = vi.fn()
     const vnode1 = new VNode('a', { on: { click }})
     const vnode2 = new VNode('a', {})
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
 
     patch(vnode1, vnode2)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(1)
   })
 
   it('should remove Array handlers that are no longer present', () => {
-    const click = jasmine.createSpy()
+    const click = vi.fn()
     const vnode1 = new VNode('a', { on: { click: [click, click] }})
     const vnode2 = new VNode('a', {})
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
+    expect(click.mock.calls.length).toBe(2)
 
     patch(vnode1, vnode2)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
+    expect(click.mock.calls.length).toBe(2)
   })
 
   // #4650
   it('should handle single -> array or array -> single handler changes', () => {
-    const click = jasmine.createSpy()
-    const click2 = jasmine.createSpy()
-    const click3 = jasmine.createSpy()
+    const click = vi.fn()
+    const click2 = vi.fn()
+    const click3 = vi.fn()
     const vnode0 = new VNode('a', { on: { click: click }})
     const vnode1 = new VNode('a', { on: { click: [click, click2] }})
     const vnode2 = new VNode('a', { on: { click: click }})
@@ -113,23 +113,23 @@ describe('vdom events module', () => {
     const elm = patch(null, vnode0)
     document.body.appendChild(elm)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(1)
-    expect(click2.calls.count()).toBe(0)
+    expect(click.mock.calls.length).toBe(1)
+    expect(click2.mock.calls.length).toBe(0)
 
     patch(vnode0, vnode1)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(2)
-    expect(click2.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(2)
+    expect(click2.mock.calls.length).toBe(1)
 
     patch(vnode1, vnode2)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(3)
-    expect(click2.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(3)
+    expect(click2.mock.calls.length).toBe(1)
 
     patch(vnode2, vnode3)
     global.triggerEvent(elm, 'click')
-    expect(click.calls.count()).toBe(3)
-    expect(click2.calls.count()).toBe(2)
-    expect(click3.calls.count()).toBe(1)
+    expect(click.mock.calls.length).toBe(3)
+    expect(click2.mock.calls.length).toBe(2)
+    expect(click3.mock.calls.length).toBe(1)
   })
 })
diff --git a/test/unit/modules/vdom/patch/edge-cases.spec.ts b/test/unit/modules/vdom/patch/edge-cases.spec.ts
index 294ab9cd9ba..4342532b6b1 100644
--- a/test/unit/modules/vdom/patch/edge-cases.spec.ts
+++ b/test/unit/modules/vdom/patch/edge-cases.spec.ts
@@ -270,7 +270,7 @@ describe('vdom patch: edge cases', () => {
 
   // #6803
   it('backwards compat with checkbox code generated before 2.4', () => {
-    const spy = jasmine.createSpy()
+    const spy = vi.fn()
     const vm = new Vue({
       data: {
         label: 'foobar',
@@ -339,7 +339,7 @@ describe('vdom patch: edge cases', () => {
 
   // #7294
   it('should cleanup component inline events on patch when no events are present', done => {
-    const log = jasmine.createSpy()
+    const log = vi.fn()
     const vm = new Vue({
       data: { ok: true },
       template: `
@@ -393,7 +393,7 @@ describe('vdom patch: edge cases', () => {
 
     // sometimes we do need to tap into these internal hooks (e.g. in vue-router)
     // so make sure it does work
-    const inlineHookSpy = jasmine.createSpy('inlineInit')
+    const inlineHookSpy = vi.fn()
 
     const vm = new Vue({
       render (h) {
@@ -409,7 +409,7 @@ describe('vdom patch: edge cases', () => {
     }).$mount()
 
     expect(vm.$el.textContent).toBe('FooBar')
-    expect(inlineHookSpy.calls.count()).toBe(2)
+    expect(inlineHookSpy.mock.calls.length).toBe(2)
   })
 
   // #9549

From 63e7d59a0366237678bcae3f92a2ac7b1b34116b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 07:57:07 +0800
Subject: [PATCH 041/317] test: remove global before waitForUpdate

---
 .../component/component-keep-alive.spec.ts    | 42 +++++------
 .../features/component/component-slot.spec.ts | 14 ++--
 test/unit/features/error-handling.spec.ts     | 12 ++--
 .../features/transition/transition.spec.ts    | 70 +++++++++----------
 .../modules/vdom/modules/dom-props.spec.ts    |  2 +-
 .../modules/vdom/patch/edge-cases.spec.ts     |  2 +-
 6 files changed, 71 insertions(+), 71 deletions(-)

diff --git a/test/unit/features/component/component-keep-alive.spec.ts b/test/unit/features/component/component-keep-alive.spec.ts
index b55f5270df2..15240d1b511 100644
--- a/test/unit/features/component/component-keep-alive.spec.ts
+++ b/test/unit/features/component/component-keep-alive.spec.ts
@@ -60,7 +60,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [0, 0, 0, 0, 0])
     vm.view = 'two'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('two')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
@@ -104,7 +104,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [1, 1, 1, 0, 0])
     vm.ok = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 1, 0])
@@ -145,7 +145,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [1, 1, 1, 0, 0])
     vm.ok = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 1, 0])
@@ -214,7 +214,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [0, 0, 0, 0, 0])
     vm.view = 'two'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('two')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 0, 0, 0])
@@ -379,7 +379,7 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     vm.view = 'two'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.include = 'two'
@@ -410,7 +410,7 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     vm.view = 'two'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.include = 'one'
@@ -439,7 +439,7 @@ describe('Component keep-alive', () => {
     }).$mount()
 
     vm.include = 'two'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
@@ -468,7 +468,7 @@ describe('Component keep-alive', () => {
     assertHookCalls(two, [1, 1, 1, 0, 0])
 
     vm.ok = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       assertHookCalls(one, [1, 1, 1, 1, 1])
       assertHookCalls(two, [1, 1, 1, 1, 1])
     }).then(done)
@@ -498,7 +498,7 @@ describe('Component keep-alive', () => {
 
     expect(vm.$el.textContent).toBe('one 1')
     vm.n++
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('one 2')
       vm.view = 'two'
     }).then(() => {
@@ -555,7 +555,7 @@ describe('Component keep-alive', () => {
 
     assertCount([1, 0, 0, 0, 0, 0])
     vm.n = 'bb'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       assertCount([1, 0, 1, 0, 0, 0])
       vm.n = 'cc'
     }).then(() => {
@@ -621,7 +621,7 @@ describe('Component keep-alive', () => {
 
     assertCount([1, 0, 0, 0, 0, 0])
     vm.n = 'bb'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       // should prune A because max cache reached
       assertCount([1, 1, 1, 0, 0, 0])
       vm.n = 'cc'
@@ -686,7 +686,7 @@ describe('Component keep-alive', () => {
     expect(vm.$el.textContent).toBe('foo')
     assert(1, 0)
     vm.view = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('bar')
       assert(1, 1)
       vm.view = true
@@ -738,7 +738,7 @@ describe('Component keep-alive', () => {
     expect(vm.$el.textContent).toBe('foo')
     assert(1, 0)
     vm.view = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('bar')
       assert(1, 1)
       vm.view = true
@@ -773,7 +773,7 @@ describe('Component keep-alive', () => {
     }).$mount()
     // condition: a render where a previous component is reused
     vm.include = ['foo']
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       vm.include = ['']
     }).then(() => {
       expect(Foo.destroyed).not.toHaveBeenCalled()
@@ -805,7 +805,7 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">one</div><!---->'
         )
@@ -890,7 +890,7 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">one</div><!---->'
         )
@@ -975,7 +975,7 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
@@ -1066,7 +1066,7 @@ describe('Component keep-alive', () => {
       }).$mount(el)
       expect(vm.$el.textContent).toBe('one')
       vm.view = 'two'
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
@@ -1134,7 +1134,7 @@ describe('Component keep-alive', () => {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.view = 'bar'
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test v-leave v-leave-active">foo</div>' +
           '<div class="test test-enter test-enter-active">bar</div>'
@@ -1210,7 +1210,7 @@ describe('Component keep-alive', () => {
       next = () => {
         assertHookCalls(one, [1, 1, 1, 0, 0])
         assertHookCalls(two, [0, 0, 0, 0, 0])
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(vm.$el.innerHTML).toBe(
             '<div class="test test-enter test-enter-active">one</div>'
           )
@@ -1274,7 +1274,7 @@ describe('Component keep-alive', () => {
       btn.click()
       expect(vm.n).toBe(1)
       vm.showBtn = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         vm.showBtn = true
       }).then(() => {
         btn.click()
diff --git a/test/unit/features/component/component-slot.spec.ts b/test/unit/features/component/component-slot.spec.ts
index ae2f7929eab..e1004ba8dea 100644
--- a/test/unit/features/component/component-slot.spec.ts
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -218,7 +218,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.textContent).toBe('12')
     vm.a = 2
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('22')
       vm.show = false
     }).then(() => {
@@ -255,7 +255,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<div><p>foo</p></div>')
     vm.msg = 'bar'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('<div><p>bar</p></div>')
     }).then(done)
   })
@@ -275,7 +275,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<p>hi</p>')
     vm.ok = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('fallback')
       vm.ok = true
       vm.msg = 'bye'
@@ -475,7 +475,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.textContent).toBe('foo1')
     vm.$children[0].a = 2
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('foo2')
     }).then(done)
   })
@@ -512,7 +512,7 @@ describe('Component slot', () => {
 
     expect(calls).toEqual([1])
     vm.$refs.child.ok = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(calls).toEqual([1, 2])
       vm.$refs.child.ok = true
     }).then(() => {
@@ -550,7 +550,7 @@ describe('Component slot', () => {
     }).$mount()
     expect(vm.$el.innerHTML).toBe(`<div>1</div> <div>1</div> <pre><div>1</div></pre>`)
     vm.n++
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe(`<div>2</div> <div>2</div> <pre><div>2</div></pre>`)
       vm.n++
     }).then(() => {
@@ -586,7 +586,7 @@ describe('Component slot', () => {
     document.body.appendChild(vm.$el)
     expect(vm.$el.textContent).toBe('hi')
     vm.$children[0].toggle = false
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       vm.$children[0].toggle = true
     }).then(() => {
       global.triggerEvent(vm.$el.querySelector('.click'), 'click')
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index ea1903ac7e0..7ef5f84ccc5 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -32,7 +32,7 @@ describe('Error handling', () => {
   ].forEach(([type, description]) => {
     it(`should recover from promise errors in ${type}`, done => {
       createTestInstance(components[`${type}Async`])
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
         expect(`Error: ${type}`).toHaveBeenWarned()
       }).then(done)
@@ -84,7 +84,7 @@ describe('Error handling', () => {
     it(`should recover from errors in ${type} hook`, done => {
       const vm = createTestInstance(components[type])
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(`Error in ${description}`).toHaveBeenWarned()
         expect(`Error: ${type}`).toHaveBeenWarned()
       }).thenWaitFor(next => {
@@ -111,7 +111,7 @@ describe('Error handling', () => {
   it('should recover from errors in user watcher getter', done => {
     const vm = createTestInstance(components.userWatcherGetter)
     vm.n++
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(`Error in getter for watcher`).toHaveBeenWarned()
       function getErrorMsg () {
         try {
@@ -226,7 +226,7 @@ describe('Error handling', () => {
       }).$mount()
       document.body.appendChild(vm.$el)
       global.triggerEvent(vm.$el, 'click')
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect('Error in v-on handler (Promise/async)').toHaveBeenWarned()
         expect('Error: v-on').toHaveBeenWarned()
         document.body.removeChild(vm.$el)
@@ -435,14 +435,14 @@ function createTestInstance (Comp) {
 function assertRootInstanceActive (vm) {
   expect(vm.$el.innerHTML).toContain('n:0\n')
   vm.n++
-  return global.waitForUpdate(() => {
+  return waitForUpdate(() => {
     expect(vm.$el.innerHTML).toContain('n:1\n')
   })
 }
 
 function assertBothInstancesActive (vm) {
   vm.n = 0
-  return global.waitForUpdate(() => {
+  return waitForUpdate(() => {
     expect(vm.$refs.child.$el.innerHTML).toContain('0')
   }).thenWaitFor(next => {
     assertRootInstanceActive(vm).then(() => {
diff --git a/test/unit/features/transition/transition.spec.ts b/test/unit/features/transition/transition.spec.ts
index dc992e753c0..8646a2d0985 100644
--- a/test/unit/features/transition/transition.spec.ts
+++ b/test/unit/features/transition/transition.spec.ts
@@ -48,7 +48,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -85,7 +85,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test bye byebye active more')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test byebye active more bye-to')
@@ -119,7 +119,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -165,7 +165,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test bye byebye active')
         expect(leave).toHaveBeenCalled()
       }).thenWaitFor(nextFrame).then(() => {
@@ -233,7 +233,7 @@ if (!isIE9) {
 
       let _el = vm.$el.children[0]
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
         expect(onLeaveSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
@@ -318,7 +318,7 @@ if (!isIE9) {
 
       let _el = vm.$el.children[0]
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
         expect(onLeaveSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
@@ -362,7 +362,7 @@ if (!isIE9) {
         }
       }).$mount(el)
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -404,7 +404,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(leaveSpy).toHaveBeenCalled()
         expect(vm.$el.innerHTML).toBe('<!---->')
         vm.ok = true
@@ -427,7 +427,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(leaveSpy).toHaveBeenCalled()
         expect(vm.$el.innerHTML).toBe('<div class="nope-leave nope-leave-active">foo</div><!---->')
       }).thenWaitFor(nextFrame).then(() => {
@@ -459,7 +459,7 @@ if (!isIE9) {
 
       expect(vm.$el.innerHTML).toBe('<!---->')
       vm.ok = true
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
@@ -493,7 +493,7 @@ if (!isIE9) {
 
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(duration / 2).then(() => {
         vm.ok = true
@@ -525,7 +525,7 @@ if (!isIE9) {
       expect(vm.$el.children[0].style.display).toBe('')
       expect(vm.$el.children[0].className).toBe('test')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -561,7 +561,7 @@ if (!isIE9) {
       expect(vm.$el.textContent).toBe('foo')
       expect(vm.$el.children[0].style.display).toBe('')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -596,7 +596,7 @@ if (!isIE9) {
 
       expect(vm.$el.children[0].style.display).toBe('')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -625,7 +625,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         vm.ok = true
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
@@ -647,7 +647,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = true
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         vm.ok = false
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -671,7 +671,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div>foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
@@ -702,7 +702,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-anim-long-leave test-anim-long-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-anim-long-leave-active test-anim-long-leave-to')
@@ -739,7 +739,7 @@ if (!isIE9) {
         data: { ok: true }
       }).$mount(el)
 
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
@@ -760,7 +760,7 @@ if (!isIE9) {
         data: { ok: true }
       }).$mount(el)
 
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
@@ -784,7 +784,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave-active v-leave-to')
@@ -826,7 +826,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -864,7 +864,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -898,7 +898,7 @@ if (!isIE9) {
         }
       }).$mount(el)
 
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
@@ -937,7 +937,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -976,7 +976,7 @@ if (!isIE9) {
         }
       }).$mount(el)
 
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
@@ -1010,7 +1010,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
@@ -1048,7 +1048,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1078,7 +1078,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1108,7 +1108,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1141,7 +1141,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1180,7 +1180,7 @@ if (!isIE9) {
 
         vm.ok = false
 
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
         }).thenWaitFor(nextFrame).then(() => {
           expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
@@ -1228,7 +1228,7 @@ if (!isIE9) {
         }).$mount(el)
 
         vm.ok = false
-        global.waitForUpdate(() => {
+        waitForUpdate(() => {
           expect(`<transition> explicit leave duration is not a valid number - got "foo"`).toHaveBeenWarned()
         }).thenWaitFor(duration + buffer).then(() => {
           vm.ok = true
@@ -1262,7 +1262,7 @@ if (!isIE9) {
       // should not apply transition on initial render by default
       expect(vm.$el.innerHTML).toBe('<!---->')
       vm.view = 'two'
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe('<div class="test v-enter v-enter-active">two</div>')
       }).thenWaitFor(nextFrame).then(() => {
         expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
@@ -1297,7 +1297,7 @@ if (!isIE9) {
       }).$mount(el)
 
       vm.ok = false
-      global.waitForUpdate(() => {
+      waitForUpdate(() => {
         expect(vm.$el.children[0].innerHTML).toBe('false')
       }).then(done)
     })
diff --git a/test/unit/modules/vdom/modules/dom-props.spec.ts b/test/unit/modules/vdom/modules/dom-props.spec.ts
index 1fd098a022f..90176759ab3 100644
--- a/test/unit/modules/vdom/modules/dom-props.spec.ts
+++ b/test/unit/modules/vdom/modules/dom-props.spec.ts
@@ -80,7 +80,7 @@ describe('vdom domProps module', () => {
 
     expect(vm.$el.id).toBe('foo')
     vm.props.id = 'bar'
-    global.waitForUpdate(() => {
+    waitForUpdate(() => {
       expect(vm.$el.id).toBe('bar')
       vm.props = { id: 'baz' }
     }).then(() => {
diff --git a/test/unit/modules/vdom/patch/edge-cases.spec.ts b/test/unit/modules/vdom/patch/edge-cases.spec.ts
index 4342532b6b1..60ebca54b4e 100644
--- a/test/unit/modules/vdom/patch/edge-cases.spec.ts
+++ b/test/unit/modules/vdom/patch/edge-cases.spec.ts
@@ -48,7 +48,7 @@ describe('vdom patch: edge cases', () => {
       directives: {
         test: {
           bind (el, binding, vnode) {
-            global.waitForUpdate(() => {
+            waitForUpdate(() => {
               expect(vnode.children[0].data.on.click()).toBe(5)
               expect(vnode.children[2].data.on.click(dummyEvt)).toBe(5)
               expect(vnode.children[4].data.on.click()).toBe(10)

From 5ec77f32be74c427b95a5b045b506b91171fdb24 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 08:22:26 +0800
Subject: [PATCH 042/317] test: shim done interface for tests

---
 test/helpers/classlist.ts                     |  26 +--
 test/helpers/shim-done.ts                     |  33 +++
 test/helpers/to-equal.ts                      |  19 --
 test/helpers/to-have-warned.ts                |  94 +++++++++
 test/helpers/trigger-event.ts                 |   2 +-
 test/helpers/wait-for-update.ts               |  21 +-
 test/test-env.d.ts                            |  25 +++
 .../component/component-async.spec.ts         |  63 ++----
 test/unit/global.d.ts                         |  16 --
 test/vitest.setup.ts                          | 191 +-----------------
 10 files changed, 197 insertions(+), 293 deletions(-)
 create mode 100644 test/helpers/shim-done.ts
 delete mode 100644 test/helpers/to-equal.ts
 create mode 100644 test/helpers/to-have-warned.ts
 create mode 100644 test/test-env.d.ts
 delete mode 100644 test/unit/global.d.ts

diff --git a/test/helpers/classlist.ts b/test/helpers/classlist.ts
index 29e04b84ed0..2e617e6b255 100644
--- a/test/helpers/classlist.ts
+++ b/test/helpers/classlist.ts
@@ -1,18 +1,12 @@
-beforeEach(() => {
-  jasmine.addMatchers({
-    // since classList may not be supported in all browsers
-    toHaveClass: () => {
-      return {
-        compare: (el, cls) => {
-          const pass = el.classList
-            ? el.classList.contains(cls)
-            : el.getAttribute('class').split(/\s+/g).indexOf(cls) > -1
-          return {
-            pass,
-            message: `Expected element${pass ? ' ' : ' not '}to have class ${cls}`
-          }
-        }
-      }
+expect.extend({
+  toHaveClass(el: Element, cls: string) {
+    const pass = el.classList
+      ? el.classList.contains(cls)
+      : (el.getAttribute('class') || '').split(/\s+/g).indexOf(cls) > -1
+    return {
+      pass,
+      message: () =>
+        `Expected element${pass ? ' ' : ' not '}to have class ${cls}`
     }
-  })
+  }
 })
diff --git a/test/helpers/shim-done.ts b/test/helpers/shim-done.ts
new file mode 100644
index 00000000000..9d71ebfda34
--- /dev/null
+++ b/test/helpers/shim-done.ts
@@ -0,0 +1,33 @@
+// wrap tests to support test('foo', done => {...}) interface
+const _test = test
+
+const wait = (): [() => void, Promise<void>] => {
+  let done
+  const p = new Promise<void>((resolve, reject) => {
+    done = resolve
+    done.fail = reject
+  })
+  return [done, p]
+}
+
+;(global as any).it = (global as any).test = (
+  desc: string,
+  fn?: any,
+  timeout?: number
+) => {
+  if (fn && fn.length > 0) {
+    _test(
+      desc,
+      () => {
+        const [done, p] = wait()
+        fn(done)
+        return p
+      },
+      timeout
+    )
+  } else {
+    _test(desc, fn, timeout)
+  }
+}
+
+export {}
diff --git a/test/helpers/to-equal.ts b/test/helpers/to-equal.ts
deleted file mode 100644
index 33308bdc25f..00000000000
--- a/test/helpers/to-equal.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { isEqual } from 'lodash'
-
-beforeEach(() => {
-  jasmine.addMatchers({
-    // override built-in toEqual because it behaves incorrectly
-    // on Vue-observed arrays in Safari
-    toEqual: () => {
-      return {
-        compare: (a, b) => {
-          const pass = isEqual(a, b)
-          return {
-            pass,
-            message: `Expected ${a} to equal ${b}`
-          }
-        }
-      }
-    }
-  })
-})
diff --git a/test/helpers/to-have-warned.ts b/test/helpers/to-have-warned.ts
new file mode 100644
index 00000000000..8edf9583c8e
--- /dev/null
+++ b/test/helpers/to-have-warned.ts
@@ -0,0 +1,94 @@
+import { SpyInstance } from 'vitest'
+
+expect.extend({
+  toHaveBeenWarned(received: string) {
+    asserted.add(received)
+    const passed = warn.mock.calls.some((args) => args[0].includes(received))
+    if (passed) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" not to have been warned.`
+      }
+    } else {
+      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been warned` +
+          (msgs.length
+            ? `.\n\nActual messages:\n\n - ${msgs}`
+            : ` but no warning was recorded.`)
+      }
+    }
+  },
+
+  toHaveBeenWarnedLast(received: string) {
+    asserted.add(received)
+    const passed =
+      warn.mock.calls[warn.mock.calls.length - 1][0].includes(received)
+    if (passed) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" not to have been warned last.`
+      }
+    } else {
+      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been warned last.\n\nActual messages:\n\n - ${msgs}`
+      }
+    }
+  },
+
+  toHaveBeenWarnedTimes(received: string, n: number) {
+    asserted.add(received)
+    let found = 0
+    warn.mock.calls.forEach((args) => {
+      if (args[0].includes(received)) {
+        found++
+      }
+    })
+
+    if (found === n) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" to have been warned ${n} times.`
+      }
+    } else {
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been warned ${n} times but got ${found}.`
+      }
+    }
+  }
+})
+
+let warn: SpyInstance
+const asserted: Set<string> = new Set()
+
+beforeEach(() => {
+  asserted.clear()
+  warn = vi.spyOn(console, 'error')
+  warn.mockImplementation(() => {})
+})
+
+afterEach(() => {
+  const assertedArray = Array.from(asserted)
+  const nonAssertedWarnings = warn.mock.calls
+    .map((args) => args[0])
+    .filter((received) => {
+      return !assertedArray.some((assertedMsg) => {
+        return received.includes(assertedMsg)
+      })
+    })
+  warn.mockRestore()
+  if (nonAssertedWarnings.length) {
+    throw new Error(
+      `test case threw unexpected warnings:\n - ${nonAssertedWarnings.join(
+        '\n - '
+      )}`
+    )
+  }
+})
diff --git a/test/helpers/trigger-event.ts b/test/helpers/trigger-event.ts
index 69cbce55dd2..8fb5a2274ee 100644
--- a/test/helpers/trigger-event.ts
+++ b/test/helpers/trigger-event.ts
@@ -1,4 +1,4 @@
-window.triggerEvent = function triggerEvent (target, event, process) {
+global.triggerEvent = function triggerEvent (target, event, process) {
   const e = document.createEvent('HTMLEvents')
   e.initEvent(event, true, true)
   if (event === 'click') {
diff --git a/test/helpers/wait-for-update.ts b/test/helpers/wait-for-update.ts
index d3499c6a228..0d643f8439a 100644
--- a/test/helpers/wait-for-update.ts
+++ b/test/helpers/wait-for-update.ts
@@ -13,16 +13,21 @@ import Vue from 'vue'
 // })
 // .then(done)
 
-window.waitForUpdate = initialCb => {
+interface Job extends Function {
+  wait?: boolean
+  fail?: (e: any) => void
+}
+
+global.waitForUpdate = (initialCb: Job) => {
   let end
-  const queue = initialCb ? [initialCb] : []
+  const queue: Job[] = initialCb ? [initialCb] : []
 
-  function shift () {
+  function shift() {
     const job = queue.shift()
     if (queue.length) {
       let hasError = false
       try {
-        job.wait ? job(shift) : job()
+        job!.wait ? job!(shift) : job!()
       } catch (e) {
         hasError = true
         const done = queue[queue.length - 1]
@@ -48,7 +53,7 @@ window.waitForUpdate = initialCb => {
   })
 
   const chainer = {
-    then: nextCb => {
+    then: (nextCb) => {
       queue.push(nextCb)
       return chainer
     },
@@ -60,7 +65,7 @@ window.waitForUpdate = initialCb => {
       queue.push(wait)
       return chainer
     },
-    end: endFn => {
+    end: (endFn) => {
       queue.push(endFn)
       end = endFn
     }
@@ -69,6 +74,6 @@ window.waitForUpdate = initialCb => {
   return chainer
 }
 
-function timeout (n) {
-  return next => setTimeout(next, n)
+function timeout(n) {
+  return (next) => setTimeout(next, n)
 }
diff --git a/test/test-env.d.ts b/test/test-env.d.ts
new file mode 100644
index 00000000000..ab57f5301d2
--- /dev/null
+++ b/test/test-env.d.ts
@@ -0,0 +1,25 @@
+interface Chainer {
+  then(next: Function): this
+  thenWaitFor(n: number): this
+  end(endFn: Function): void
+}
+
+declare function waitForUpdate(cb: Function): Chainer
+
+declare function createTextVNode(arg?: string): any
+
+declare function triggerEvent(
+  target: Element,
+  event: string,
+  process?: (e: Event) => void
+): void
+
+// vitest extends jest namespace so we can just extend jest.Matchers
+declare namespace jest {
+  interface Matchers<R, T> {
+    toHaveBeenWarned(): R
+    toHaveBeenWarnedLast(): R
+    toHaveBeenWarnedTimes(n: number): R
+    toHaveClass(cls: string): R
+  }
+}
diff --git a/test/unit/features/component/component-async.spec.ts b/test/unit/features/component/component-async.spec.ts
index 6708673d101..9e08cfa59db 100644
--- a/test/unit/features/component/component-async.spec.ts
+++ b/test/unit/features/component/component-async.spec.ts
@@ -1,14 +1,5 @@
 import Vue from 'vue'
 
-function wait(): [() => void, Promise<void>] {
-  let done
-  const p = new Promise<void>((resolve, reject) => {
-    done = resolve
-    done.fail = reject
-  })
-  return [done, p]
-}
-
 describe('Component async', () => {
   const oldSetTimeout = setTimeout
   const oldClearTimeout = clearTimeout
@@ -55,7 +46,7 @@ describe('Component async', () => {
     expect(JSON.stringify(timeoutsPending)).toEqual(JSON.stringify({}))
   })
 
-  it('normal', () => {
+  it('normal', (done) => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
@@ -73,16 +64,14 @@ describe('Component async', () => {
     expect(vm.$el.innerHTML).toBe('<!---->')
     expect(vm.$children.length).toBe(0)
 
-    const [done, p] = wait()
     function next() {
       expect(vm.$el.innerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
-    return p
   })
 
-  it('resolve ES module default', () => {
+  it('resolve ES module default', (done) => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
@@ -103,16 +92,14 @@ describe('Component async', () => {
     expect(vm.$el.innerHTML).toBe('<!---->')
     expect(vm.$children.length).toBe(0)
 
-    const [done, p] = wait()
     function next() {
       expect(vm.$el.innerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
-    return p
   })
 
-  it('as root', () => {
+  it('as root', (done) => {
     const vm = new Vue({
       template: '<test></test>',
       components: {
@@ -130,17 +117,15 @@ describe('Component async', () => {
     expect(vm.$el.nodeType).toBe(8)
     expect(vm.$children.length).toBe(0)
 
-    const [done, p] = wait()
     function next() {
       expect(vm.$el.nodeType).toBe(1)
       expect(vm.$el.outerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
-    return p
   })
 
-  it('dynamic', () => {
+  it('dynamic', (done) => {
     const vm = new Vue({
       template: '<component :is="view"></component>',
       data: {
@@ -174,7 +159,7 @@ describe('Component async', () => {
       expect(vm.$el.textContent).toBe('A')
       vm.view = 'view-b'
     }
-    const [done, p] = wait()
+
     function step2() {
       expect(vm.$el.tagName).toBe('P')
       expect(vm.$el.textContent).toBe('B')
@@ -185,7 +170,6 @@ describe('Component async', () => {
         expect(vm.$el.textContent).toBe('A')
       }).then(done)
     }
-    return p
   })
 
   it('warn reject', () => {
@@ -200,7 +184,7 @@ describe('Component async', () => {
     expect('Reason: nooooo').toHaveBeenWarned()
   })
 
-  it('with v-for', () => {
+  it('with v-for', (done) => {
     const vm = new Vue({
       template: '<div><test v-for="n in list" :key="n" :n="n"></test></div>',
       data: {
@@ -218,15 +202,14 @@ describe('Component async', () => {
         }
       }
     }).$mount()
-    const [done, p] = wait()
+
     function next() {
       expect(vm.$el.innerHTML).toBe('<div>1</div><div>2</div><div>3</div>')
       done()
     }
-    return p
   })
 
-  it('returning Promise', () => {
+  it('returning Promise', (done) => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
@@ -248,17 +231,15 @@ describe('Component async', () => {
     expect(vm.$el.innerHTML).toBe('<!---->')
     expect(vm.$children.length).toBe(0)
 
-    const [done, p] = wait()
     function next() {
       expect(vm.$el.innerHTML).toBe('<div>hi</div>')
       expect(vm.$children.length).toBe(1)
       done()
     }
-    return p
   })
 
   describe('loading/error/timeout', () => {
-    it('with loading component', () => {
+    it('with loading component', (done) => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -288,16 +269,14 @@ describe('Component async', () => {
         })
       }, 1)
 
-      const [done, p] = wait()
       function next() {
         expect(loadingAsserted).toBe(true)
         expect(vm.$el.textContent).toBe('hi')
         done()
       }
-      return p
     })
 
-    it('with loading component (0 delay)', () => {
+    it('with loading component (0 delay)', (done) => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -319,15 +298,13 @@ describe('Component async', () => {
 
       expect(vm.$el.textContent).toBe('loading')
 
-      const [done, p] = wait()
       function next() {
         expect(vm.$el.textContent).toBe('hi')
         done()
       }
-      return p
     })
 
-    it('with error component', () => {
+    it('with error component', (done) => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -350,16 +327,14 @@ describe('Component async', () => {
 
       expect(vm.$el.textContent).toBe('loading')
 
-      const [done, p] = wait()
       function next() {
         expect(`Failed to resolve async component`).toHaveBeenWarned()
         expect(vm.$el.textContent).toBe('error')
         done()
       }
-      return p
     })
 
-    it('with error component + timeout', () => {
+    it('with error component + timeout', (done) => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -390,15 +365,13 @@ describe('Component async', () => {
         })
       }, 1)
 
-      const [done, p] = wait()
       function next() {
         expect(vm.$el.textContent).toBe('error') // late resolve ignored
         done()
       }
-      return p
     })
 
-    it('should not trigger timeout if resolved', () => {
+    it('should not trigger timeout if resolved', (done) => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -414,16 +387,14 @@ describe('Component async', () => {
         }
       }).$mount()
 
-      const [done, p] = wait()
       setTimeout(() => {
         expect(vm.$el.textContent).toBe('hi')
         expect(`Failed to resolve async component`).not.toHaveBeenWarned()
         done()
       }, 50)
-      return p
     })
 
-    it('should not have running timeout/loading if resolved', () => {
+    it('should not have running timeout/loading if resolved', (done) => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -444,17 +415,15 @@ describe('Component async', () => {
         }
       }).$mount()
 
-      const [done, p] = wait()
       function next() {
         expect(vm.$el.textContent).toBe('hi')
         // the afterEach() will ensure that the timeouts for delay and timeout have been cleared
         done()
       }
-      return p
     })
 
     // #7107
-    it(`should work when resolving sync in sibling component's mounted hook`, () => {
+    it(`should work when resolving sync in sibling component's mounted hook`, (done) => {
       let resolveTwo
 
       const vm = new Vue({
@@ -478,11 +447,9 @@ describe('Component async', () => {
 
       expect(vm.$el.textContent).toBe('one ')
 
-      const [done, p] = wait()
       waitForUpdate(() => {
         expect(vm.$el.textContent).toBe('one two')
       }).then(done)
-      return p
     })
   })
 })
diff --git a/test/unit/global.d.ts b/test/unit/global.d.ts
deleted file mode 100644
index ef3ed19af82..00000000000
--- a/test/unit/global.d.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-declare function waitForUpdate(
-  cb: Function
-): any;
-
-declare function createTextVNode(
-  arg?: any
-): any;
-
-// vitest extends jest namespace so we can just extend jest.Matchers
-declare namespace jest {
-  interface Matchers<R, T> {
-    toHaveBeenWarned(): R
-    toHaveBeenWarnedLast(): R
-    toHaveBeenWarnedTimes(n: number): R
-  }
-}
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index aff6dd1d301..1ffa54fed8e 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -1,185 +1,6 @@
-import { SpyInstance } from 'vitest'
-
-expect.extend({
-  toHaveBeenWarned(received: string) {
-    asserted.add(received)
-    const passed = warn.mock.calls.some((args) => args[0].includes(received))
-    if (passed) {
-      return {
-        pass: true,
-        message: () => `expected "${received}" not to have been warned.`
-      }
-    } else {
-      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
-      return {
-        pass: false,
-        message: () =>
-          `expected "${received}" to have been warned` +
-          (msgs.length
-            ? `.\n\nActual messages:\n\n - ${msgs}`
-            : ` but no warning was recorded.`)
-      }
-    }
-  },
-
-  toHaveBeenWarnedLast(received: string) {
-    asserted.add(received)
-    const passed =
-      warn.mock.calls[warn.mock.calls.length - 1][0].includes(received)
-    if (passed) {
-      return {
-        pass: true,
-        message: () => `expected "${received}" not to have been warned last.`
-      }
-    } else {
-      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
-      return {
-        pass: false,
-        message: () =>
-          `expected "${received}" to have been warned last.\n\nActual messages:\n\n - ${msgs}`
-      }
-    }
-  },
-
-  toHaveBeenWarnedTimes(received: string, n: number) {
-    asserted.add(received)
-    let found = 0
-    warn.mock.calls.forEach((args) => {
-      if (args[0].includes(received)) {
-        found++
-      }
-    })
-
-    if (found === n) {
-      return {
-        pass: true,
-        message: () => `expected "${received}" to have been warned ${n} times.`
-      }
-    } else {
-      return {
-        pass: false,
-        message: () =>
-          `expected "${received}" to have been warned ${n} times but got ${found}.`
-      }
-    }
-  }
-})
-
-let warn: SpyInstance
-const asserted: Set<string> = new Set()
-
-beforeEach(() => {
-  asserted.clear()
-  warn = vi.spyOn(console, 'error')
-  warn.mockImplementation(() => {})
-})
-
-afterEach(() => {
-  const assertedArray = Array.from(asserted)
-  const nonAssertedWarnings = warn.mock.calls
-    .map((args) => args[0])
-    .filter((received) => {
-      return !assertedArray.some((assertedMsg) => {
-        return received.includes(assertedMsg)
-      })
-    })
-  warn.mockRestore()
-  if (nonAssertedWarnings.length) {
-    throw new Error(
-      `test case threw unexpected warnings:\n - ${nonAssertedWarnings.join(
-        '\n - '
-      )}`
-    )
-  }
-})
-
-import Vue from 'vue'
-
-// helper for async assertions.
-// Use like this:
-//
-// vm.a = 123
-// waitForUpdate(() => {
-//   expect(vm.$el.textContent).toBe('123')
-//   vm.a = 234
-// })
-// .then(() => {
-//   // more assertions...
-// })
-// .then(done)
-
-interface Job extends Function {
-  wait?: boolean
-  fail?: (e: any) => void
-}
-
-global.waitForUpdate = (initialCb: Job) => {
-  let end
-  let reject
-  const queue: Job[] = initialCb ? [initialCb] : []
-
-  function shift() {
-    const job = queue.shift()
-    if (queue.length) {
-      let hasError = false
-      try {
-        job!.wait ? job!(shift) : job!()
-      } catch (e) {
-        hasError = true
-        if (reject) {
-          reject()
-        } else {
-          const done = queue[queue.length - 1]
-          if (done && done.fail) {
-            done.fail(e)
-          }
-        }
-      }
-      if (!hasError && !job!.wait) {
-        if (queue.length) {
-          Vue.nextTick(shift)
-        }
-      }
-    } else if (job && (job.fail || job === end)) {
-      job() // done
-    }
-  }
-
-  Vue.nextTick(() => {
-    if (!queue.length || (!end && !queue[queue.length - 1]!.fail)) {
-      throw new Error('waitForUpdate chain is missing .then(done)')
-    }
-    shift()
-  })
-
-  const chainer = {
-    then: (nextCb) => {
-      queue.push(nextCb)
-      return chainer
-    },
-    thenWaitFor: (wait) => {
-      if (typeof wait === 'number') {
-        wait = timeout(wait)
-      }
-      wait.wait = true
-      queue.push(wait)
-      return chainer
-    },
-    end: (endFn) => {
-      queue.push(endFn)
-      end = endFn
-    },
-    promise() {
-      return new Promise((resolve, rej) => {
-        end = resolve
-        reject = rej
-      })
-    }
-  }
-
-  return chainer
-}
-
-function timeout(n) {
-  return (next) => setTimeout(next, n)
-}
+import './helpers/shim-done'
+import './helpers/to-have-warned'
+import './helpers/wait-for-update'
+import './helpers/trigger-event'
+import './helpers/vdom'
+import './helpers/classlist'

From 69edc9aec6da6ac82dd2589fe7c0593cc8b4928d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 08:24:05 +0800
Subject: [PATCH 043/317] test: move __WEEX__ flag to runtime for tests

---
 test/vitest.setup.ts | 2 ++
 vitest.config.ts     | 3 ---
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index 1ffa54fed8e..a57a38bf4c2 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -1,3 +1,5 @@
+(global as any).__WEEX__ = false
+
 import './helpers/shim-done'
 import './helpers/to-have-warned'
 import './helpers/wait-for-update'
diff --git a/vitest.config.ts b/vitest.config.ts
index 27d49297958..de4938c069e 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -16,9 +16,6 @@ export default defineConfig({
       vue: resolve('src/platforms/web/entry-runtime-with-compiler')
     }
   },
-  define: {
-    __WEEX__: false
-  },
   test: {
     globals: true,
     environment: 'jsdom',

From 29989a10745aa82322569e01d879cad90d3fbb3a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 08:30:41 +0800
Subject: [PATCH 044/317] test: move transition + keep alive test cases

---
 test/test-env.d.ts                            |   2 +-
 .../component/component-keep-alive.spec.ts    | 940 +++++-------------
 .../transition-with-keep-alive.spec.ts        | 658 ++++++++++++
 3 files changed, 903 insertions(+), 697 deletions(-)
 create mode 100644 test/unit/features/transition/transition-with-keep-alive.spec.ts

diff --git a/test/test-env.d.ts b/test/test-env.d.ts
index ab57f5301d2..3142ef628e1 100644
--- a/test/test-env.d.ts
+++ b/test/test-env.d.ts
@@ -1,6 +1,6 @@
 interface Chainer {
   then(next: Function): this
-  thenWaitFor(n: number): this
+  thenWaitFor(n: number | Function): this
   end(endFn: Function): void
 }
 
diff --git a/test/unit/features/component/component-keep-alive.spec.ts b/test/unit/features/component/component-keep-alive.spec.ts
index 15240d1b511..833a33ea9f1 100644
--- a/test/unit/features/component/component-keep-alive.spec.ts
+++ b/test/unit/features/component/component-keep-alive.spec.ts
@@ -1,10 +1,6 @@
 import Vue from 'vue'
-import injectStyles from '../transition/inject-styles'
-import { isIE9 } from 'core/util/env'
-import { nextFrame } from 'web/runtime/transition-util'
 
 describe('Component keep-alive', () => {
-  const { duration, buffer } = injectStyles()
   let components, one, two, el
   beforeEach(() => {
     one = {
@@ -31,7 +27,7 @@ describe('Component keep-alive', () => {
     document.body.appendChild(el)
   })
 
-  function assertHookCalls (component, callCounts) {
+  function assertHookCalls(component, callCounts) {
     expect([
       component.created.mock.calls.length,
       component.mounted.mock.calls.length,
@@ -41,7 +37,7 @@ describe('Component keep-alive', () => {
     ]).toEqual(callCounts)
   }
 
-  it('should work', done => {
+  it('should work', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -65,24 +61,28 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.view = 'one'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 1, 1, 0])
-      vm.view = 'two'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 2, 1, 0])
-      vm.ok = false // teardown
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 1])
-      assertHookCalls(two, [1, 1, 2, 2, 1])
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('one')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+        vm.view = 'two'
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two')
+        assertHookCalls(one, [1, 1, 2, 2, 0])
+        assertHookCalls(two, [1, 1, 2, 1, 0])
+        vm.ok = false // teardown
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 2, 1])
+        assertHookCalls(two, [1, 1, 2, 2, 1])
+      })
+      .then(done)
   })
 
-  it('should invoke hooks on the entire sub tree', done => {
+  it('should invoke hooks on the entire sub tree', (done) => {
     one.template = '<two/>'
     one.components = { two }
 
@@ -109,19 +109,22 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 1, 0])
       vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 2, 1, 0])
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 2, 2, 0])
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 2, 1, 0])
+        vm.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 2, 0])
+        assertHookCalls(two, [1, 1, 2, 2, 0])
+      })
+      .then(done)
   })
 
-  it('should handle nested keep-alive hooks properly', done => {
+  it('should handle nested keep-alive hooks properly', (done) => {
     one.template = '<keep-alive><two v-if="ok" /></keep-alive>'
     one.data = () => ({ ok: true })
     one.components = { two }
@@ -149,67 +152,86 @@ describe('Component keep-alive', () => {
       expect(vm.$el.textContent).toBe('')
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 1, 0])
-    }).then(() => {
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 2, 1, 0])
-    }).then(() => {
-      // toggle sub component when activated
-      oneInstance.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 2, 2, 0])
-    }).then(() => {
-      oneInstance.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 3, 2, 0])
-    }).then(() => {
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 3, 3, 0])
-    }).then(() => {
-      // toggle sub component when parent is deactivated
-      oneInstance.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 3, 3, 0]) // should not be affected
-    }).then(() => {
-      oneInstance.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [1, 1, 3, 3, 0]) // should not be affected
-    }).then(() => {
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 3, 2, 0])
-      assertHookCalls(two, [1, 1, 4, 3, 0])
-    }).then(() => {
-      oneInstance.ok = false
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 3, 3, 0])
-      assertHookCalls(two, [1, 1, 4, 4, 0])
-    }).then(() => {
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 4, 3, 0])
-      assertHookCalls(two, [1, 1, 4, 4, 0]) // should remain inactive
-    }).then(done)
+    })
+      .then(() => {
+        vm.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 2, 1, 0])
+      })
+      .then(() => {
+        // toggle sub component when activated
+        oneInstance.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 2, 2, 0])
+      })
+      .then(() => {
+        oneInstance.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 3, 2, 0])
+      })
+      .then(() => {
+        vm.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 2, 0])
+        assertHookCalls(two, [1, 1, 3, 3, 0])
+      })
+      .then(() => {
+        // toggle sub component when parent is deactivated
+        oneInstance.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 2, 0])
+        assertHookCalls(two, [1, 1, 3, 3, 0]) // should not be affected
+      })
+      .then(() => {
+        oneInstance.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 2, 0])
+        assertHookCalls(two, [1, 1, 3, 3, 0]) // should not be affected
+      })
+      .then(() => {
+        vm.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two')
+        assertHookCalls(one, [1, 1, 3, 2, 0])
+        assertHookCalls(two, [1, 1, 4, 3, 0])
+      })
+      .then(() => {
+        oneInstance.ok = false
+        vm.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 3, 3, 0])
+        assertHookCalls(two, [1, 1, 4, 4, 0])
+      })
+      .then(() => {
+        vm.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 4, 3, 0])
+        assertHookCalls(two, [1, 1, 4, 4, 0]) // should remain inactive
+      })
+      .then(done)
   })
 
-  function sharedAssertions (vm, done) {
+  function sharedAssertions(vm, done) {
     expect(vm.$el.textContent).toBe('one')
     assertHookCalls(one, [1, 1, 1, 0, 0])
     assertHookCalls(two, [0, 0, 0, 0, 0])
@@ -219,24 +241,28 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 0, 0, 0])
       vm.view = 'one'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      assertHookCalls(two, [1, 1, 0, 0, 1])
-      vm.view = 'two'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two')
-      assertHookCalls(one, [1, 1, 2, 2, 0])
-      assertHookCalls(two, [2, 2, 0, 0, 1])
-      vm.ok = false // teardown
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      assertHookCalls(one, [1, 1, 2, 2, 1])
-      assertHookCalls(two, [2, 2, 0, 0, 2])
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('one')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 0, 0, 1])
+        vm.view = 'two'
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two')
+        assertHookCalls(one, [1, 1, 2, 2, 0])
+        assertHookCalls(two, [2, 2, 0, 0, 1])
+        vm.ok = false // teardown
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        assertHookCalls(one, [1, 1, 2, 2, 1])
+        assertHookCalls(two, [2, 2, 0, 0, 2])
+      })
+      .then(done)
   }
 
-  it('include (string)', done => {
+  it('include (string)', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -254,7 +280,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('include (regex)', done => {
+  it('include (regex)', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -272,7 +298,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('include (array)', done => {
+  it('include (array)', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -290,7 +316,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('exclude (string)', done => {
+  it('exclude (string)', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -308,7 +334,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('exclude (regex)', done => {
+  it('exclude (regex)', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -326,7 +352,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('exclude (array)', done => {
+  it('exclude (array)', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -344,7 +370,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('include + exclude', done => {
+  it('include + exclude', (done) => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -362,7 +388,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('prune cache on include/exclude change', done => {
+  it('prune cache on include/exclude change', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -383,17 +409,20 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.include = 'two'
-    }).then(() => {
-      assertHookCalls(one, [1, 1, 1, 1, 1])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-      vm.view = 'one'
-    }).then(() => {
-      assertHookCalls(one, [2, 2, 1, 1, 1])
-      assertHookCalls(two, [1, 1, 1, 1, 0])
-    }).then(done)
+    })
+      .then(() => {
+        assertHookCalls(one, [1, 1, 1, 1, 1])
+        assertHookCalls(two, [1, 1, 1, 0, 0])
+        vm.view = 'one'
+      })
+      .then(() => {
+        assertHookCalls(one, [2, 2, 1, 1, 1])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+      })
+      .then(done)
   })
 
-  it('prune cache on include/exclude change + view switch', done => {
+  it('prune cache on include/exclude change + view switch', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -415,14 +444,16 @@ describe('Component keep-alive', () => {
       assertHookCalls(two, [1, 1, 1, 0, 0])
       vm.include = 'one'
       vm.view = 'one'
-    }).then(() => {
-      assertHookCalls(one, [1, 1, 2, 1, 0])
-      // two should be pruned
-      assertHookCalls(two, [1, 1, 1, 1, 1])
-    }).then(done)
+    })
+      .then(() => {
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        // two should be pruned
+        assertHookCalls(two, [1, 1, 1, 1, 1])
+      })
+      .then(done)
   })
 
-  it('should not prune currently active instance', done => {
+  it('should not prune currently active instance', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -443,14 +474,16 @@ describe('Component keep-alive', () => {
       assertHookCalls(one, [1, 1, 1, 0, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
       vm.view = 'two'
-    }).then(() => {
-      assertHookCalls(one, [1, 1, 1, 0, 1])
-      assertHookCalls(two, [1, 1, 1, 0, 0])
-    }).then(done)
+    })
+      .then(() => {
+        assertHookCalls(one, [1, 1, 1, 0, 1])
+        assertHookCalls(two, [1, 1, 1, 0, 0])
+      })
+      .then(done)
   })
 
   // #3882
-  it('deeply nested keep-alive should be destroyed properly', done => {
+  it('deeply nested keep-alive should be destroyed properly', (done) => {
     one.template = `<div><keep-alive><two></two></keep-alive></div>`
     one.components = { two }
     const vm = new Vue({
@@ -475,7 +508,7 @@ describe('Component keep-alive', () => {
   })
 
   // #4237
-  it('should update latest props/listeners for a re-activated component', done => {
+  it('should update latest props/listeners for a re-activated component', (done) => {
     const one = {
       props: ['prop'],
       template: `<div>one {{ prop }}</div>`
@@ -501,12 +534,14 @@ describe('Component keep-alive', () => {
     waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('one 2')
       vm.view = 'two'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('two 2')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('two 2')
+      })
+      .then(done)
   })
 
-  it('max', done => {
+  it('max', (done) => {
     const spyA = vi.fn()
     const spyB = vi.fn()
     const spyC = vi.fn()
@@ -514,7 +549,7 @@ describe('Component keep-alive', () => {
     const spyBD = vi.fn()
     const spyCD = vi.fn()
 
-    function assertCount (calls) {
+    function assertCount(calls) {
       expect([
         spyA.mock.calls.length,
         spyAD.mock.calls.length,
@@ -558,21 +593,25 @@ describe('Component keep-alive', () => {
     waitForUpdate(() => {
       assertCount([1, 0, 1, 0, 0, 0])
       vm.n = 'cc'
-    }).then(() => {
-      // should prune A because max cache reached
-      assertCount([1, 1, 1, 0, 1, 0])
-      vm.n = 'bb'
-    }).then(() => {
-      // B should be reused, and made latest
-      assertCount([1, 1, 1, 0, 1, 0])
-      vm.n = 'aa'
-    }).then(() => {
-      // C should be pruned because B was used last so C is the oldest cached
-      assertCount([2, 1, 1, 0, 1, 1])
-    }).then(done)
+    })
+      .then(() => {
+        // should prune A because max cache reached
+        assertCount([1, 1, 1, 0, 1, 0])
+        vm.n = 'bb'
+      })
+      .then(() => {
+        // B should be reused, and made latest
+        assertCount([1, 1, 1, 0, 1, 0])
+        vm.n = 'aa'
+      })
+      .then(() => {
+        // C should be pruned because B was used last so C is the oldest cached
+        assertCount([2, 1, 1, 0, 1, 1])
+      })
+      .then(done)
   })
 
-  it('max=1', done => {
+  it('max=1', (done) => {
     const spyA = vi.fn()
     const spyB = vi.fn()
     const spyC = vi.fn()
@@ -580,7 +619,7 @@ describe('Component keep-alive', () => {
     const spyBD = vi.fn()
     const spyCD = vi.fn()
 
-    function assertCount (calls) {
+    function assertCount(calls) {
       expect([
         spyA.mock.calls.length,
         spyAD.mock.calls.length,
@@ -625,18 +664,22 @@ describe('Component keep-alive', () => {
       // should prune A because max cache reached
       assertCount([1, 1, 1, 0, 0, 0])
       vm.n = 'cc'
-    }).then(() => {
-      // should prune B because max cache reached
-      assertCount([1, 1, 1, 1, 1, 0])
-      vm.n = 'bb'
-    }).then(() => {
-      // B is recreated
-      assertCount([1, 1, 2, 1, 1, 1])
-      vm.n = 'aa'
-    }).then(() => {
-      // B is destroyed and A recreated
-      assertCount([2, 1, 2, 2, 1, 1])
-    }).then(done)
+    })
+      .then(() => {
+        // should prune B because max cache reached
+        assertCount([1, 1, 1, 1, 1, 0])
+        vm.n = 'bb'
+      })
+      .then(() => {
+        // B is recreated
+        assertCount([1, 1, 2, 1, 1, 1])
+        vm.n = 'aa'
+      })
+      .then(() => {
+        // B is destroyed and A recreated
+        assertCount([2, 1, 2, 2, 1, 1])
+      })
+      .then(done)
   })
 
   it('should warn unknown component inside', () => {
@@ -647,7 +690,7 @@ describe('Component keep-alive', () => {
   })
 
   // #6938
-  it('should not cache anonymous component when include is specified', done => {
+  it('should not cache anonymous component when include is specified', (done) => {
     const Foo = {
       name: 'foo',
       template: `<div>foo</div>`,
@@ -661,7 +704,7 @@ describe('Component keep-alive', () => {
 
     const Child = {
       functional: true,
-      render (h, ctx) {
+      render(h, ctx) {
         return h(ctx.props.view ? Foo : Bar)
       }
     }
@@ -678,7 +721,7 @@ describe('Component keep-alive', () => {
       components: { Child }
     }).$mount()
 
-    function assert (foo, bar) {
+    function assert(foo, bar) {
       expect(Foo.created.mock.calls.length).toBe(foo)
       expect(Bar.created.mock.calls.length).toBe(bar)
     }
@@ -690,17 +733,20 @@ describe('Component keep-alive', () => {
       expect(vm.$el.textContent).toBe('bar')
       assert(1, 1)
       vm.view = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('foo')
-      assert(1, 1)
-      vm.view = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('bar')
-      assert(1, 2)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('foo')
+        assert(1, 1)
+        vm.view = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('bar')
+        assert(1, 2)
+      })
+      .then(done)
   })
 
-  it('should cache anonymous components if include is not specified', done => {
+  it('should cache anonymous components if include is not specified', (done) => {
     const Foo = {
       template: `<div>foo</div>`,
       created: vi.fn()
@@ -713,7 +759,7 @@ describe('Component keep-alive', () => {
 
     const Child = {
       functional: true,
-      render (h, ctx) {
+      render(h, ctx) {
         return h(ctx.props.view ? Foo : Bar)
       }
     }
@@ -730,7 +776,7 @@ describe('Component keep-alive', () => {
       components: { Child }
     }).$mount()
 
-    function assert (foo, bar) {
+    function assert(foo, bar) {
       expect(Foo.created.mock.calls.length).toBe(foo)
       expect(Bar.created.mock.calls.length).toBe(bar)
     }
@@ -742,18 +788,21 @@ describe('Component keep-alive', () => {
       expect(vm.$el.textContent).toBe('bar')
       assert(1, 1)
       vm.view = true
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('foo')
-      assert(1, 1)
-      vm.view = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('bar')
-      assert(1, 1)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('foo')
+        assert(1, 1)
+        vm.view = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('bar')
+        assert(1, 1)
+      })
+      .then(done)
   })
 
   // #7105
-  it('should not destroy active instance when pruning cache', done => {
+  it('should not destroy active instance when pruning cache', (done) => {
     const Foo = {
       template: `<div>foo</div>`,
       destroyed: vi.fn()
@@ -775,511 +824,10 @@ describe('Component keep-alive', () => {
     vm.include = ['foo']
     waitForUpdate(() => {
       vm.include = ['']
-    }).then(() => {
-      expect(Foo.destroyed).not.toHaveBeenCalled()
-    }).then(done)
-  })
-
-  if (!isIE9) {
-    it('with transition-mode out-in', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).then(() => {
-        vm.view = 'one'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).then(done)
-    })
-
-    it('with transition-mode out-in + include', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-leave="afterLeave">
-            <keep-alive include="one">
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 0])
-      }).then(() => {
-        vm.view = 'one'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div><!---->'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 1])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div><!---->'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 1])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 0, 0, 1])
-      }).then(done)
-    })
-
-    it('with transition-mode in-out', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-        assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 0, 0])
-      }).then(() => {
-        vm.view = 'one'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-        assertHookCalls(one, [1, 1, 2, 1, 0])
-        assertHookCalls(two, [1, 1, 1, 1, 0])
-      }).then(done)
-    })
-
-    it('dynamic components, in-out with early cancel', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="in-out" @after-enter="afterEnter">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
-        )
-        // switch again before enter finishes,
-        // this cancels both enter and leave.
-        vm.view = 'one'
-      }).then(() => {
-        // 1. the pending leaving "one" should be removed instantly.
-        // 2. the entering "two" should be placed into its final state instantly.
-        // 3. a new "one" is created and entering
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter test-enter-active">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test test-enter-active test-enter-to">one</div>'
-        )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-      }).then(done)
     })
-
-    // #4339
-    it('component with inner transition', done => {
-      const vm = new Vue({
-        template: `
-          <div>
-            <keep-alive>
-              <component ref="test" :is="view"></component>
-            </keep-alive>
-          </div>
-        `,
-        data: { view: 'foo' },
-        components: {
-          foo: { template: '<transition><div class="test">foo</div></transition>' },
-          bar: { template: '<transition name="test"><div class="test">bar</div></transition>' }
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.view = 'bar'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">foo</div>' +
-          '<div class="test test-enter test-enter-active">bar</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave-active v-leave-to">foo</div>' +
-          '<div class="test test-enter-active test-enter-to">bar</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">bar</div>'
-        )
-        vm.view = 'foo'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">bar</div>' +
-          '<div class="test v-enter v-enter-active">foo</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave-active test-leave-to">bar</div>' +
-          '<div class="test v-enter-active v-enter-to">foo</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">foo</div>'
-        )
-      }).then(done)
-    })
-
-    it('async components with transition-mode out-in', done => {
-      const barResolve = vi.fn()
-      let next
-      const foo = (resolve) => {
-        setTimeout(() => {
-          resolve(one)
-          Vue.nextTick(next)
-        }, duration / 2)
-      }
-      const bar = (resolve) => {
-        setTimeout(() => {
-          resolve(two)
-          barResolve()
-        }, duration / 2)
-      }
-      components = {
-        foo,
-        bar
-      }
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-enter="afterEnter" @after-leave="afterLeave">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'foo'
-        },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          },
-          afterLeave () {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('')
-      next = () => {
-        assertHookCalls(one, [1, 1, 1, 0, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-        waitForUpdate(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">one</div>'
-          )
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">one</div>'
-          )
-        }).thenWaitFor(_next => { next = _next }).then(() => {
-          // foo afterEnter get called
-          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-          vm.view = 'bar'
-        }).thenWaitFor(nextFrame).then(() => {
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [0, 0, 0, 0, 0])
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">one</div><!---->'
-          )
-        }).thenWaitFor(_next => { next = _next }).then(() => {
-          // foo afterLeave get called
-          // and bar has already been resolved before afterLeave get called
-          expect(barResolve.mock.calls.length).toBe(1)
-          expect(vm.$el.innerHTML).toBe('<!---->')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">two</div>'
-          )
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 0, 0])
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">two</div>'
-          )
-        }).thenWaitFor(_next => { next = _next }).then(() => {
-          // bar afterEnter get called
-          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
-        }).then(done)
-      }
-    })
-
-    // #10083
-    it('should not attach event handler repeatedly', done => {
-      const vm = new Vue({
-        template: `
-          <keep-alive>
-            <btn v-if="showBtn" @click.native="add" />
-          </keep-alive>
-        `,
-        data: { showBtn: true, n: 0 },
-        methods: {
-          add () {
-            this.n++
-          }
-        },
-        components: {
-          btn: { template: '<button>add 1</button>' }
-        }
-      }).$mount()
-
-      const btn = vm.$el
-      expect(vm.n).toBe(0)
-      btn.click()
-      expect(vm.n).toBe(1)
-      vm.showBtn = false
-      waitForUpdate(() => {
-        vm.showBtn = true
-      }).then(() => {
-        btn.click()
-        expect(vm.n).toBe(2)
-      }).then(done)
-    })
-  }
+      .then(() => {
+        expect(Foo.destroyed).not.toHaveBeenCalled()
+      })
+      .then(done)
+  })
 })
diff --git a/test/unit/features/transition/transition-with-keep-alive.spec.ts b/test/unit/features/transition/transition-with-keep-alive.spec.ts
new file mode 100644
index 00000000000..0b7a5c01693
--- /dev/null
+++ b/test/unit/features/transition/transition-with-keep-alive.spec.ts
@@ -0,0 +1,658 @@
+import Vue from 'vue'
+import injectStyles from '../transition/inject-styles'
+import { isIE9 } from 'core/util/env'
+import { nextFrame } from 'web/runtime/transition-util'
+
+if (!isIE9) {
+  describe('Transition w/ KeepAlive', () => {
+    const { duration, buffer } = injectStyles()
+
+    let components, one, two, el
+    beforeEach(() => {
+      one = {
+        template: '<div>one</div>',
+        created: vi.fn(),
+        mounted: vi.fn(),
+        activated: vi.fn(),
+        deactivated: vi.fn(),
+        destroyed: vi.fn()
+      }
+      two = {
+        template: '<div>two</div>',
+        created: vi.fn(),
+        mounted: vi.fn(),
+        activated: vi.fn(),
+        deactivated: vi.fn(),
+        destroyed: vi.fn()
+      }
+      components = {
+        one,
+        two
+      }
+      el = document.createElement('div')
+      document.body.appendChild(el)
+    })
+
+    function assertHookCalls(component, callCounts) {
+      expect([
+        component.created.mock.calls.length,
+        component.mounted.mock.calls.length,
+        component.activated.mock.calls.length,
+        component.deactivated.mock.calls.length,
+        component.destroyed.mock.calls.length
+      ]).toEqual(callCounts)
+    }
+
+    it('with transition-mode out-in', (done) => {
+      let next
+      const vm = new Vue({
+        template: `<div>
+          <transition name="test" mode="out-in" @after-leave="afterLeave">
+            <keep-alive>
+              <component :is="view" class="test"></component>
+            </keep-alive>
+          </transition>
+        </div>`,
+        data: {
+          view: 'one'
+        },
+        components,
+        methods: {
+          afterLeave() {
+            next()
+          }
+        }
+      }).$mount(el)
+      expect(vm.$el.textContent).toBe('one')
+      assertHookCalls(one, [1, 1, 1, 0, 0])
+      assertHookCalls(two, [0, 0, 0, 0, 0])
+      vm.view = 'two'
+      waitForUpdate(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">one</div><!---->'
+        )
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [0, 0, 0, 0, 0])
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">one</div><!---->'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<!---->')
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter test-enter-active">two</div>'
+          )
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 0, 0])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter-active test-enter-to">two</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 0, 0])
+        })
+        .then(() => {
+          vm.view = 'one'
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave test-leave-active">two</div><!---->'
+          )
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 1, 0])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">two</div><!---->'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<!---->')
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter test-enter-active">one</div>'
+          )
+          assertHookCalls(one, [1, 1, 2, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 1, 0])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter-active test-enter-to">one</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+          assertHookCalls(one, [1, 1, 2, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 1, 0])
+        })
+        .then(done)
+    })
+
+    it('with transition-mode out-in + include', (done) => {
+      let next
+      const vm = new Vue({
+        template: `<div>
+          <transition name="test" mode="out-in" @after-leave="afterLeave">
+            <keep-alive include="one">
+              <component :is="view" class="test"></component>
+            </keep-alive>
+          </transition>
+        </div>`,
+        data: {
+          view: 'one'
+        },
+        components,
+        methods: {
+          afterLeave() {
+            next()
+          }
+        }
+      }).$mount(el)
+      expect(vm.$el.textContent).toBe('one')
+      assertHookCalls(one, [1, 1, 1, 0, 0])
+      assertHookCalls(two, [0, 0, 0, 0, 0])
+      vm.view = 'two'
+      waitForUpdate(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">one</div><!---->'
+        )
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [0, 0, 0, 0, 0])
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">one</div><!---->'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<!---->')
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter test-enter-active">two</div>'
+          )
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 0, 0, 0])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter-active test-enter-to">two</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 0, 0, 0])
+        })
+        .then(() => {
+          vm.view = 'one'
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave test-leave-active">two</div><!---->'
+          )
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 0, 0, 1])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">two</div><!---->'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<!---->')
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter test-enter-active">one</div>'
+          )
+          assertHookCalls(one, [1, 1, 2, 1, 0])
+          assertHookCalls(two, [1, 1, 0, 0, 1])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter-active test-enter-to">one</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+          assertHookCalls(one, [1, 1, 2, 1, 0])
+          assertHookCalls(two, [1, 1, 0, 0, 1])
+        })
+        .then(done)
+    })
+
+    it('with transition-mode in-out', (done) => {
+      let next
+      const vm = new Vue({
+        template: `<div>
+          <transition name="test" mode="in-out" @after-enter="afterEnter">
+            <keep-alive>
+              <component :is="view" class="test"></component>
+            </keep-alive>
+          </transition>
+        </div>`,
+        data: {
+          view: 'one'
+        },
+        components,
+        methods: {
+          afterEnter() {
+            next()
+          }
+        }
+      }).$mount(el)
+      expect(vm.$el.textContent).toBe('one')
+      assertHookCalls(one, [1, 1, 1, 0, 0])
+      assertHookCalls(two, [0, 0, 0, 0, 0])
+      vm.view = 'two'
+      waitForUpdate(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">one</div>' +
+            '<div class="test test-enter test-enter-active">two</div>'
+        )
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 0, 0])
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">one</div>' +
+              '<div class="test test-enter-active test-enter-to">two</div>'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">one</div>' + '<div class="test">two</div>'
+          )
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave test-leave-active">one</div>' +
+              '<div class="test">two</div>'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">one</div>' +
+              '<div class="test">two</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 0, 0])
+        })
+        .then(() => {
+          vm.view = 'one'
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">two</div>' +
+              '<div class="test test-enter test-enter-active">one</div>'
+          )
+          assertHookCalls(one, [1, 1, 2, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 1, 0])
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">two</div>' +
+              '<div class="test test-enter-active test-enter-to">one</div>'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">two</div>' + '<div class="test">one</div>'
+          )
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave test-leave-active">two</div>' +
+              '<div class="test">one</div>'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">two</div>' +
+              '<div class="test">one</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+          assertHookCalls(one, [1, 1, 2, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 1, 0])
+        })
+        .then(done)
+    })
+
+    it('dynamic components, in-out with early cancel', (done) => {
+      let next
+      const vm = new Vue({
+        template: `<div>
+          <transition name="test" mode="in-out" @after-enter="afterEnter">
+            <keep-alive>
+              <component :is="view" class="test"></component>
+            </keep-alive>
+          </transition>
+        </div>`,
+        data: { view: 'one' },
+        components,
+        methods: {
+          afterEnter() {
+            next()
+          }
+        }
+      }).$mount(el)
+      expect(vm.$el.textContent).toBe('one')
+      vm.view = 'two'
+      waitForUpdate(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">one</div>' +
+            '<div class="test test-enter test-enter-active">two</div>'
+        )
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">one</div>' +
+              '<div class="test test-enter-active test-enter-to">two</div>'
+          )
+          // switch again before enter finishes,
+          // this cancels both enter and leave.
+          vm.view = 'one'
+        })
+        .then(() => {
+          // 1. the pending leaving "one" should be removed instantly.
+          // 2. the entering "two" should be placed into its final state instantly.
+          // 3. a new "one" is created and entering
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">two</div>' +
+              '<div class="test test-enter test-enter-active">one</div>'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">two</div>' +
+              '<div class="test test-enter-active test-enter-to">one</div>'
+          )
+        })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test">two</div>' + '<div class="test">one</div>'
+          )
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave test-leave-active">two</div>' +
+              '<div class="test">one</div>'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">two</div>' +
+              '<div class="test">one</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+        })
+        .then(done)
+    })
+
+    // #4339
+    it('component with inner transition', (done) => {
+      const vm = new Vue({
+        template: `
+          <div>
+            <keep-alive>
+              <component ref="test" :is="view"></component>
+            </keep-alive>
+          </div>
+        `,
+        data: { view: 'foo' },
+        components: {
+          foo: {
+            template: '<transition><div class="test">foo</div></transition>'
+          },
+          bar: {
+            template:
+              '<transition name="test"><div class="test">bar</div></transition>'
+          }
+        }
+      }).$mount(el)
+
+      // should not apply transition on initial render by default
+      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+      vm.view = 'bar'
+      waitForUpdate(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test v-leave v-leave-active">foo</div>' +
+            '<div class="test test-enter test-enter-active">bar</div>'
+        )
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test v-leave-active v-leave-to">foo</div>' +
+              '<div class="test test-enter-active test-enter-to">bar</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">bar</div>')
+          vm.view = 'foo'
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave test-leave-active">bar</div>' +
+              '<div class="test v-enter v-enter-active">foo</div>'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-leave-active test-leave-to">bar</div>' +
+              '<div class="test v-enter-active v-enter-to">foo</div>'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+        })
+        .then(done)
+    })
+
+    it('async components with transition-mode out-in', (done) => {
+      const barResolve = vi.fn()
+      let next
+      const foo = (resolve) => {
+        setTimeout(() => {
+          resolve(one)
+          Vue.nextTick(next)
+        }, duration / 2)
+      }
+      const bar = (resolve) => {
+        setTimeout(() => {
+          resolve(two)
+          barResolve()
+        }, duration / 2)
+      }
+      components = {
+        foo,
+        bar
+      }
+      const vm = new Vue({
+        template: `<div>
+          <transition name="test" mode="out-in" @after-enter="afterEnter" @after-leave="afterLeave">
+            <keep-alive>
+              <component :is="view" class="test"></component>
+            </keep-alive>
+          </transition>
+        </div>`,
+        data: {
+          view: 'foo'
+        },
+        components,
+        methods: {
+          afterEnter() {
+            next()
+          },
+          afterLeave() {
+            next()
+          }
+        }
+      }).$mount(el)
+      expect(vm.$el.textContent).toBe('')
+      next = () => {
+        assertHookCalls(one, [1, 1, 1, 0, 0])
+        assertHookCalls(two, [0, 0, 0, 0, 0])
+        waitForUpdate(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div class="test test-enter test-enter-active">one</div>'
+          )
+        })
+          .thenWaitFor(nextFrame)
+          .then(() => {
+            expect(vm.$el.innerHTML).toBe(
+              '<div class="test test-enter-active test-enter-to">one</div>'
+            )
+          })
+          .thenWaitFor((_next) => {
+            next = _next
+          })
+          .then(() => {
+            // foo afterEnter get called
+            expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+            vm.view = 'bar'
+          })
+          .thenWaitFor(nextFrame)
+          .then(() => {
+            assertHookCalls(one, [1, 1, 1, 1, 0])
+            assertHookCalls(two, [0, 0, 0, 0, 0])
+            expect(vm.$el.innerHTML).toBe(
+              '<div class="test test-leave-active test-leave-to">one</div><!---->'
+            )
+          })
+          .thenWaitFor((_next) => {
+            next = _next
+          })
+          .then(() => {
+            // foo afterLeave get called
+            // and bar has already been resolved before afterLeave get called
+            expect(barResolve.mock.calls.length).toBe(1)
+            expect(vm.$el.innerHTML).toBe('<!---->')
+          })
+          .thenWaitFor(nextFrame)
+          .then(() => {
+            expect(vm.$el.innerHTML).toBe(
+              '<div class="test test-enter test-enter-active">two</div>'
+            )
+            assertHookCalls(one, [1, 1, 1, 1, 0])
+            assertHookCalls(two, [1, 1, 1, 0, 0])
+          })
+          .thenWaitFor(nextFrame)
+          .then(() => {
+            expect(vm.$el.innerHTML).toBe(
+              '<div class="test test-enter-active test-enter-to">two</div>'
+            )
+          })
+          .thenWaitFor((_next) => {
+            next = _next
+          })
+          .then(() => {
+            // bar afterEnter get called
+            expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+          })
+          .then(done)
+      }
+    })
+
+    // #10083
+    it('should not attach event handler repeatedly', (done) => {
+      const vm = new Vue({
+        template: `
+          <keep-alive>
+            <btn v-if="showBtn" @click.native="add" />
+          </keep-alive>
+        `,
+        data: { showBtn: true, n: 0 },
+        methods: {
+          add() {
+            this.n++
+          }
+        },
+        components: {
+          btn: { template: '<button>add 1</button>' }
+        }
+      }).$mount()
+
+      const btn = vm.$el
+      expect(vm.n).toBe(0)
+      btn.click()
+      expect(vm.n).toBe(1)
+      vm.showBtn = false
+      waitForUpdate(() => {
+        vm.showBtn = true
+      })
+        .then(() => {
+          btn.click()
+          expect(vm.n).toBe(2)
+        })
+        .then(done)
+    })
+  })
+}

From 250bc17d51d746992aac57960ad1268c43fb3e2d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 08:46:15 +0800
Subject: [PATCH 045/317] test: unit/features/component passing

---
 test/helpers/to-have-warned.ts                | 22 +++++++++++++++++++
 test/test-env.d.ts                            |  1 +
 .../component/component-scoped-slot.spec.ts   |  7 +++---
 test/vitest.setup.ts                          |  3 ++-
 4 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/test/helpers/to-have-warned.ts b/test/helpers/to-have-warned.ts
index 8edf9583c8e..97eecfd1f34 100644
--- a/test/helpers/to-have-warned.ts
+++ b/test/helpers/to-have-warned.ts
@@ -62,15 +62,37 @@ expect.extend({
           `expected "${received}" to have been warned ${n} times but got ${found}.`
       }
     }
+  },
+
+  toHaveBeenTipped(received: string) {
+    const passed = tip.mock.calls.some((args) => args[0].includes(received))
+    if (passed) {
+      return {
+        pass: true,
+        message: () => `expected "${received}" not to have been tipped.`
+      }
+    } else {
+      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      return {
+        pass: false,
+        message: () =>
+          `expected "${received}" to have been tipped` +
+          (msgs.length
+            ? `.\n\nActual messages:\n\n - ${msgs}`
+            : ` but no tip was recorded.`)
+      }
+    }
   }
 })
 
 let warn: SpyInstance
+let tip: SpyInstance
 const asserted: Set<string> = new Set()
 
 beforeEach(() => {
   asserted.clear()
   warn = vi.spyOn(console, 'error')
+  tip = vi.spyOn(console, 'warn').mockImplementation(() => {})
   warn.mockImplementation(() => {})
 })
 
diff --git a/test/test-env.d.ts b/test/test-env.d.ts
index 3142ef628e1..7ce47ebcf42 100644
--- a/test/test-env.d.ts
+++ b/test/test-env.d.ts
@@ -20,6 +20,7 @@ declare namespace jest {
     toHaveBeenWarned(): R
     toHaveBeenWarnedLast(): R
     toHaveBeenWarnedTimes(n: number): R
+    toHaveBeenTipped(): R
     toHaveClass(cls: string): R
   }
 }
diff --git a/test/unit/features/component/component-scoped-slot.spec.ts b/test/unit/features/component/component-scoped-slot.spec.ts
index 4ee111d3725..21b7d8e0db3 100644
--- a/test/unit/features/component/component-scoped-slot.spec.ts
+++ b/test/unit/features/component/component-scoped-slot.spec.ts
@@ -746,14 +746,14 @@ describe('Component scoped slot', () => {
       })
 
       it('should warn v-slot usage on non-component elements', () => {
-        const vm = new Vue({
+        new Vue({
           template: `<div ${syntax}="foo"/>`
         }).$mount()
         expect(`v-slot can only be used on components or <template>`).toHaveBeenWarned()
       })
 
       it('should warn mixed usage', () => {
-        const vm = new Vue({
+        new Vue({
           template: `<foo><bar slot="one" slot-scope="bar" ${syntax}="bar"></bar></foo>`,
           components: { Foo, Bar }
         }).$mount()
@@ -802,7 +802,7 @@ describe('Component scoped slot', () => {
     })
 
     it('should warn mixed root-default and named slots', () => {
-      const vm = new Vue({
+      new Vue({
         template: `
           <foo #default="foo">
             {{ foo }}
@@ -938,7 +938,6 @@ describe('Component scoped slot', () => {
   // #9432: async components inside a scoped slot should trigger update of the
   // component that invoked the scoped slot, not the lexical context component.
   it('async component inside scoped slot', done => {
-    let p
     const vm = new Vue({
       template: `
         <foo>
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index a57a38bf4c2..10ddc9b9399 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -1,4 +1,5 @@
-(global as any).__WEEX__ = false
+;(global as any).__WEEX__ = false
+process.env.NEW_SLOT_SYNTAX = 'true'
 
 import './helpers/shim-done'
 import './helpers/to-have-warned'

From 906907f88def66c2f0cc74c2e049e61666ec8f83 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 09:34:55 +0800
Subject: [PATCH 046/317] test: all directive tests passing

---
 .gitignore                                  |   1 +
 test/test-env.d.ts                          |   2 +-
 test/unit/features/directives/for.spec.ts   | 584 ++++++++++++--------
 test/unit/features/directives/on.spec.ts    |   9 +-
 test/unit/features/directives/style.spec.ts | 234 ++++----
 5 files changed, 486 insertions(+), 344 deletions(-)

diff --git a/.gitignore b/.gitignore
index 1dd81e3fe8b..6778e3ad772 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,4 @@ packages/vue-template-compiler/build.js
 packages/vue-template-compiler/browser.js
 .vscode
 dist
+debug.spec.ts
diff --git a/test/test-env.d.ts b/test/test-env.d.ts
index 7ce47ebcf42..035caba5c36 100644
--- a/test/test-env.d.ts
+++ b/test/test-env.d.ts
@@ -11,7 +11,7 @@ declare function createTextVNode(arg?: string): any
 declare function triggerEvent(
   target: Element,
   event: string,
-  process?: (e: Event) => void
+  process?: (e: any) => void
 ): void
 
 // vitest extends jest namespace so we can just extend jest.Matchers
diff --git a/test/unit/features/directives/for.spec.ts b/test/unit/features/directives/for.spec.ts
index 384c722fe3a..9b4ffb22db2 100644
--- a/test/unit/features/directives/for.spec.ts
+++ b/test/unit/features/directives/for.spec.ts
@@ -2,7 +2,7 @@ import Vue from 'vue'
 import { hasSymbol } from 'core/util/env'
 
 describe('Directive v-for', () => {
-  it('should render array of primitive values', done => {
+  it('should render array of primitive values', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -16,20 +16,28 @@ describe('Directive v-for', () => {
     expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
     Vue.set(vm.list, 0, 'd')
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>d</span><span>b</span><span>c</span>'
+      )
       vm.list.push('d')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span><span>d</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>d</span>')
-      vm.list = ['x', 'y']
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>d</span><span>b</span><span>c</span><span>d</span>'
+        )
+        vm.list.splice(1, 2)
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>d</span><span>d</span>')
+        vm.list = ['x', 'y']
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
+      })
+      .then(done)
   })
 
-  it('should render array of primitive values with index', done => {
+  it('should render array of primitive values with index', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -40,23 +48,33 @@ describe('Directive v-for', () => {
         list: ['a', 'b', 'c']
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>0-a</span><span>1-b</span><span>2-c</span>'
+    )
     Vue.set(vm.list, 0, 'd')
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>0-d</span><span>1-b</span><span>2-c</span>'
+      )
       vm.list.push('d')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span><span>3-d</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-d</span>')
-      vm.list = ['x', 'y']
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>0-d</span><span>1-b</span><span>2-c</span><span>3-d</span>'
+        )
+        vm.list.splice(1, 2)
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-d</span>')
+        vm.list = ['x', 'y']
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
+      })
+      .then(done)
   })
 
-  it('should render array of object values', done => {
+  it('should render array of object values', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -64,33 +82,40 @@ describe('Directive v-for', () => {
         </div>
       `,
       data: {
-        list: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ]
+        list: [{ value: 'a' }, { value: 'b' }, { value: 'c' }]
       }
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
     Vue.set(vm.list, 0, { value: 'd' })
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>d</span><span>b</span><span>c</span>'
+      )
       vm.list[0].value = 'e'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span>')
-      vm.list.push({})
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span><span></span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>e</span><span></span>')
-      vm.list = [{ value: 'x' }, { value: 'y' }]
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>e</span><span>b</span><span>c</span>'
+        )
+        vm.list.push({})
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>e</span><span>b</span><span>c</span><span></span>'
+        )
+        vm.list.splice(1, 2)
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>e</span><span></span>')
+        vm.list = [{ value: 'x' }, { value: 'y' }]
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
+      })
+      .then(done)
   })
 
-  it('should render array of object values with index', done => {
+  it('should render array of object values with index', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -98,30 +123,39 @@ describe('Directive v-for', () => {
         </div>
       `,
       data: {
-        list: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ]
+        list: [{ value: 'a' }, { value: 'b' }, { value: 'c' }]
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>0-a</span><span>1-b</span><span>2-c</span>'
+    )
     Vue.set(vm.list, 0, { value: 'd' })
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>0-d</span><span>1-b</span><span>2-c</span>'
+      )
       vm.list[0].value = 'e'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span>')
-      vm.list.push({})
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span><span>3-</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-</span>')
-      vm.list = [{ value: 'x' }, { value: 'y' }]
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>0-e</span><span>1-b</span><span>2-c</span>'
+        )
+        vm.list.push({})
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>0-e</span><span>1-b</span><span>2-c</span><span>3-</span>'
+        )
+        vm.list.splice(1, 2)
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-</span>')
+        vm.list = [{ value: 'x' }, { value: 'y' }]
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
+      })
+      .then(done)
   })
 
   if (hasSymbol) {
@@ -129,7 +163,10 @@ describe('Directive v-for', () => {
       const vm = new Vue({
         template: `<div><span v-for="[key, val] in list">{{key}},{{val}}</span></div>`,
         data: {
-          list: new Map([[1, 'foo'], [2, 'bar']])
+          list: new Map([
+            [1, 'foo'],
+            [2, 'bar']
+          ])
         }
       }).$mount()
       expect(vm.$el.innerHTML).toBe(`<span>1,foo</span><span>2,bar</span>`)
@@ -142,18 +179,20 @@ describe('Directive v-for', () => {
           list: new Set([1, 2, 3])
         }
       }).$mount()
-      expect(vm.$el.innerHTML).toBe(`<span>1</span><span>2</span><span>3</span>`)
+      expect(vm.$el.innerHTML).toBe(
+        `<span>1</span><span>2</span><span>3</span>`
+      )
     })
 
-    it('should render iterable of primitive values', done => {
+    it('should render iterable of primitive values', (done) => {
       const iterable = {
         models: ['a', 'b', 'c'],
         index: 0,
-        [Symbol.iterator] () {
+        [Symbol.iterator]() {
           const iterator = {
             index: 0,
             models: this.models,
-            next () {
+            next() {
               if (this.index < this.models.length) {
                 return { value: this.models[this.index++] }
               } else {
@@ -174,31 +213,41 @@ describe('Directive v-for', () => {
           list: iterable
         }
       }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>a</span><span>b</span><span>c</span>'
+      )
       Vue.set(vm.list.models, 0, 'd')
       waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
+        expect(vm.$el.innerHTML).toBe(
+          '<span>d</span><span>b</span><span>c</span>'
+        )
         vm.list.models.push('d')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span><span>d</span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>d</span>')
-        vm.list.models = ['x', 'y']
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<span>d</span><span>b</span><span>c</span><span>d</span>'
+          )
+          vm.list.models.splice(1, 2)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>d</span><span>d</span>')
+          vm.list.models = ['x', 'y']
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
+        })
+        .then(done)
     })
 
-    it('should render iterable of primitive values with index', done => {
+    it('should render iterable of primitive values with index', (done) => {
       const iterable = {
         models: ['a', 'b', 'c'],
         index: 0,
-        [Symbol.iterator] () {
+        [Symbol.iterator]() {
           const iterator = {
             index: 0,
             models: this.models,
-            next () {
+            next() {
               if (this.index < this.models.length) {
                 return { value: this.models[this.index++] }
               } else {
@@ -220,35 +269,41 @@ describe('Directive v-for', () => {
           list: iterable
         }
       }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>0-a</span><span>1-b</span><span>2-c</span>'
+      )
       Vue.set(vm.list.models, 0, 'd')
       waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
+        expect(vm.$el.innerHTML).toBe(
+          '<span>0-d</span><span>1-b</span><span>2-c</span>'
+        )
         vm.list.models.push('d')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span><span>3-d</span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-d</span>')
-        vm.list.models = ['x', 'y']
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<span>0-d</span><span>1-b</span><span>2-c</span><span>3-d</span>'
+          )
+          vm.list.models.splice(1, 2)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-d</span>')
+          vm.list.models = ['x', 'y']
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
+        })
+        .then(done)
     })
 
-    it('should render iterable of object values', done => {
+    it('should render iterable of object values', (done) => {
       const iterable = {
-        models: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ],
+        models: [{ value: 'a' }, { value: 'b' }, { value: 'c' }],
         index: 0,
-        [Symbol.iterator] () {
+        [Symbol.iterator]() {
           const iterator = {
             index: 0,
             models: this.models,
-            next () {
+            next() {
               if (this.index < this.models.length) {
                 return { value: this.models[this.index++] }
               } else {
@@ -270,38 +325,47 @@ describe('Directive v-for', () => {
           list: iterable
         }
       }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>a</span><span>b</span><span>c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>a</span><span>b</span><span>c</span>'
+      )
       Vue.set(vm.list.models, 0, { value: 'd' })
       waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>d</span><span>b</span><span>c</span>')
+        expect(vm.$el.innerHTML).toBe(
+          '<span>d</span><span>b</span><span>c</span>'
+        )
         vm.list.models[0].value = 'e'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span>')
-        vm.list.models.push({})
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>e</span><span>b</span><span>c</span><span></span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>e</span><span></span>')
-        vm.list.models = [{ value: 'x' }, { value: 'y' }]
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<span>e</span><span>b</span><span>c</span>'
+          )
+          vm.list.models.push({})
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<span>e</span><span>b</span><span>c</span><span></span>'
+          )
+          vm.list.models.splice(1, 2)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>e</span><span></span>')
+          vm.list.models = [{ value: 'x' }, { value: 'y' }]
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>x</span><span>y</span>')
+        })
+        .then(done)
     })
 
-    it('should render iterable of object values with index', done => {
+    it('should render iterable of object values with index', (done) => {
       const iterable = {
-        models: [
-          { value: 'a' },
-          { value: 'b' },
-          { value: 'c' }
-        ],
+        models: [{ value: 'a' }, { value: 'b' }, { value: 'c' }],
         index: 0,
-        [Symbol.iterator] () {
+        [Symbol.iterator]() {
           const iterator = {
             index: 0,
             models: this.models,
-            next () {
+            next() {
               if (this.index < this.models.length) {
                 return { value: this.models[this.index++] }
               } else {
@@ -323,27 +387,40 @@ describe('Directive v-for', () => {
           list: iterable
         }
       }).$mount()
-      expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>0-a</span><span>1-b</span><span>2-c</span>'
+      )
       Vue.set(vm.list.models, 0, { value: 'd' })
       waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-d</span><span>1-b</span><span>2-c</span>')
+        expect(vm.$el.innerHTML).toBe(
+          '<span>0-d</span><span>1-b</span><span>2-c</span>'
+        )
         vm.list.models[0].value = 'e'
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span>')
-        vm.list.models.push({})
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-b</span><span>2-c</span><span>3-</span>')
-        vm.list.models.splice(1, 2)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-</span>')
-        vm.list.models = [{ value: 'x' }, { value: 'y' }]
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<span>0-e</span><span>1-b</span><span>2-c</span>'
+          )
+          vm.list.models.push({})
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<span>0-e</span><span>1-b</span><span>2-c</span><span>3-</span>'
+          )
+          vm.list.models.splice(1, 2)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>0-e</span><span>1-</span>')
+          vm.list.models = [{ value: 'x' }, { value: 'y' }]
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<span>0-x</span><span>1-y</span>')
+        })
+        .then(done)
     })
   }
 
-  it('should render an Object', done => {
+  it('should render an Object', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -357,17 +434,26 @@ describe('Directive v-for', () => {
     expect(vm.$el.innerHTML).toBe('<span>0</span><span>1</span><span>2</span>')
     vm.obj.a = 3
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3</span><span>1</span><span>2</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>3</span><span>1</span><span>2</span>'
+      )
       Vue.set(vm.obj, 'd', 4)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3</span><span>1</span><span>2</span><span>4</span>')
-      Vue.delete(vm.obj, 'a')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>1</span><span>2</span><span>4</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>3</span><span>1</span><span>2</span><span>4</span>'
+        )
+        Vue.delete(vm.obj, 'a')
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>1</span><span>2</span><span>4</span>'
+        )
+      })
+      .then(done)
   })
 
-  it('should render an Object with key', done => {
+  it('should render an Object with key', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -378,20 +464,31 @@ describe('Directive v-for', () => {
         obj: { a: 0, b: 1, c: 2 }
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>0-a</span><span>1-b</span><span>2-c</span>'
+    )
     vm.obj.a = 3
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a</span><span>1-b</span><span>2-c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>3-a</span><span>1-b</span><span>2-c</span>'
+      )
       Vue.set(vm.obj, 'd', 4)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a</span><span>1-b</span><span>2-c</span><span>4-d</span>')
-      Vue.delete(vm.obj, 'a')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>1-b</span><span>2-c</span><span>4-d</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>3-a</span><span>1-b</span><span>2-c</span><span>4-d</span>'
+        )
+        Vue.delete(vm.obj, 'a')
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>1-b</span><span>2-c</span><span>4-d</span>'
+        )
+      })
+      .then(done)
   })
 
-  it('should render an Object with key and index', done => {
+  it('should render an Object with key and index', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -402,20 +499,31 @@ describe('Directive v-for', () => {
         obj: { a: 0, b: 1, c: 2 }
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a-0</span><span>1-b-1</span><span>2-c-2</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>0-a-0</span><span>1-b-1</span><span>2-c-2</span>'
+    )
     vm.obj.a = 3
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a-0</span><span>1-b-1</span><span>2-c-2</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>3-a-0</span><span>1-b-1</span><span>2-c-2</span>'
+      )
       Vue.set(vm.obj, 'd', 4)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a-0</span><span>1-b-1</span><span>2-c-2</span><span>4-d-3</span>')
-      Vue.delete(vm.obj, 'a')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>1-b-0</span><span>2-c-1</span><span>4-d-2</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>3-a-0</span><span>1-b-1</span><span>2-c-2</span><span>4-d-3</span>'
+        )
+        Vue.delete(vm.obj, 'a')
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>1-b-0</span><span>2-c-1</span><span>4-d-2</span>'
+        )
+      })
+      .then(done)
   })
 
-  it('should render each key of data', done => {
+  it('should render each key of data', (done) => {
     const vm = new Vue({
       template: `
         <div>
@@ -424,10 +532,14 @@ describe('Directive v-for', () => {
       `,
       data: { a: 0, b: 1, c: 2 }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>0-a</span><span>1-b</span><span>2-c</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>0-a</span><span>1-b</span><span>2-c</span>'
+    )
     vm.a = 3
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>3-a</span><span>1-b</span><span>2-c</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>3-a</span><span>1-b</span><span>2-c</span>'
+      )
     }).then(done)
   })
 
@@ -436,7 +548,8 @@ describe('Directive v-for', () => {
       data: {
         items: [1, 2, 3]
       },
-      template: '<div><div v-if="item < 3" v-for="item in items">{{item}}</div></div>'
+      template:
+        '<div><div v-if="item < 3" v-for="item in items">{{item}}</div></div>'
     }).$mount()
     expect(vm.$el.textContent).toBe('12')
   })
@@ -446,7 +559,8 @@ describe('Directive v-for', () => {
       data: {
         items: [1, 2, 3]
       },
-      template: '<div><div v-for="item in items" v-if="item < 3">{{item}}</div></div>'
+      template:
+        '<div><div v-for="item in items" v-if="item < 3">{{item}}</div></div>'
     }).$mount()
     expect(vm.$el.textContent).toBe('12')
   })
@@ -458,7 +572,7 @@ describe('Directive v-for', () => {
     expect(vm.$el.textContent).toBe('123')
   })
 
-  it('without key', done => {
+  it('without key', (done) => {
     const vm = new Vue({
       data: {
         items: [
@@ -479,7 +593,7 @@ describe('Directive v-for', () => {
     }).then(done)
   })
 
-  it('with key', done => {
+  it('with key', (done) => {
     const vm = new Vue({
       data: {
         items: [
@@ -488,7 +602,8 @@ describe('Directive v-for', () => {
           { id: 3, msg: 'c' }
         ]
       },
-      template: '<div><div v-for="item in items" :key="item.id">{{ item.msg }}</div></div>'
+      template:
+        '<div><div v-for="item in items" :key="item.id">{{ item.msg }}</div></div>'
     }).$mount()
     expect(vm.$el.textContent).toBe('abc')
     const first = vm.$el.children[0]
@@ -511,32 +626,28 @@ describe('Directive v-for', () => {
       },
       template:
         '<div>' +
-          '<div v-for="(item, i) in items">' +
-            '<p v-for="(subItem, j) in item.items">{{j}} {{subItem.a}} {{i}} {{item.a}}</p>' +
-          '</div>' +
+        '<div v-for="(item, i) in items">' +
+        '<p v-for="(subItem, j) in item.items">{{j}} {{subItem.a}} {{i}} {{item.a}}</p>' +
+        '</div>' +
         '</div>'
     }).$mount()
     expect(vm.$el.innerHTML).toBe(
       '<div><p>0 1 0 1</p><p>1 2 0 1</p></div>' +
-      '<div><p>0 3 1 2</p><p>1 4 1 2</p></div>'
+        '<div><p>0 3 1 2</p><p>1 4 1 2</p></div>'
     )
   })
 
-  it('template v-for', done => {
+  it('template v-for', (done) => {
     const vm = new Vue({
       data: {
-        list: [
-          { a: 1 },
-          { a: 2 },
-          { a: 3 }
-        ]
+        list: [{ a: 1 }, { a: 2 }, { a: 3 }]
       },
       template:
         '<div>' +
-          '<template v-for="item in list">' +
-            '<p>{{item.a}}</p>' +
-            '<p>{{item.a + 1}}</p>' +
-          '</template>' +
+        '<template v-for="item in list">' +
+        '<p>{{item.a}}</p>' +
+        '<p>{{item.a + 1}}</p>' +
+        '</template>' +
         '</div>'
     }).$mount()
     assertMarkup()
@@ -544,33 +655,33 @@ describe('Directive v-for', () => {
     waitForUpdate(() => {
       assertMarkup()
       vm.list.splice(1, 1)
-    }).then(() => {
-      assertMarkup()
-      vm.list.splice(1, 0, { a: 2 })
-    }).then(done)
-
-    function assertMarkup () {
-      const markup = vm.list.map(function (item) {
-        return '<p>' + item.a + '</p><p>' + (item.a + 1) + '</p>'
-      }).join('')
+    })
+      .then(() => {
+        assertMarkup()
+        vm.list.splice(1, 0, { a: 2 })
+      })
+      .then(done)
+
+    function assertMarkup() {
+      const markup = vm.list
+        .map(function (item) {
+          return '<p>' + item.a + '</p><p>' + (item.a + 1) + '</p>'
+        })
+        .join('')
       expect(vm.$el.innerHTML).toBe(markup)
     }
   })
 
-  it('component v-for', done => {
+  it('component v-for', (done) => {
     const vm = new Vue({
       data: {
-        list: [
-          { a: 1 },
-          { a: 2 },
-          { a: 3 }
-        ]
+        list: [{ a: 1 }, { a: 2 }, { a: 3 }]
       },
       template:
         '<div>' +
-          '<test v-for="item in list" :msg="item.a" :key="item.a">' +
-            '<span>{{item.a}}</span>' +
-          '</test>' +
+        '<test v-for="item in list" :msg="item.a" :key="item.a">' +
+        '<span>{{item.a}}</span>' +
+        '</test>' +
         '</div>',
       components: {
         test: {
@@ -584,30 +695,31 @@ describe('Directive v-for', () => {
     waitForUpdate(() => {
       assertMarkup()
       vm.list.splice(1, 1)
-    }).then(() => {
-      assertMarkup()
-      vm.list.splice(1, 0, { a: 2 })
-    }).then(done)
-
-    function assertMarkup () {
-      const markup = vm.list.map(function (item) {
-        return `<p>${item.a}<span>${item.a}</span></p>`
-      }).join('')
+    })
+      .then(() => {
+        assertMarkup()
+        vm.list.splice(1, 0, { a: 2 })
+      })
+      .then(done)
+
+    function assertMarkup() {
+      const markup = vm.list
+        .map(function (item) {
+          return `<p>${item.a}<span>${item.a}</span></p>`
+        })
+        .join('')
       expect(vm.$el.innerHTML).toBe(markup)
     }
   })
 
-  it('dynamic component v-for', done => {
+  it('dynamic component v-for', (done) => {
     const vm = new Vue({
       data: {
-        list: [
-          { type: 'one' },
-          { type: 'two' }
-        ]
+        list: [{ type: 'one' }, { type: 'two' }]
       },
       template:
         '<div>' +
-          '<component v-for="item in list" :key="item.type" :is="item.type"></component>' +
+        '<component v-for="item in list" :key="item.type" :is="item.type"></component>' +
         '</div>',
       components: {
         one: {
@@ -626,23 +738,20 @@ describe('Directive v-for', () => {
   })
 
   it('should warn component v-for without keys', () => {
-    const warn = console.warn
-    console.warn = vi.fn()
     new Vue({
       template: `<div><test v-for="i in 3"></test></div>`,
       components: {
         test: {
-          render () {}
+          render() {}
         }
       }
     }).$mount()
-    expect(console.warn.calls.argsFor(0)[0]).toContain(
+    expect(
       `<test v-for="i in 3">: component lists rendered with v-for should have explicit keys`
-    )
-    console.warn = warn
+    ).toHaveBeenTipped()
   })
 
-  it('multi nested array reactivity', done => {
+  it('multi nested array reactivity', (done) => {
     const vm = new Vue({
       data: {
         list: [[['foo']]]
@@ -666,7 +775,7 @@ describe('Directive v-for', () => {
     }).then(done)
   })
 
-  it('should work with strings', done => {
+  it('should work with strings', (done) => {
     const vm = new Vue({
       data: {
         text: 'foo'
@@ -705,11 +814,11 @@ describe('Directive v-for', () => {
   })
 
   // #9181
-  it('components with v-for and empty list', done => {
+  it('components with v-for and empty list', (done) => {
     const vm = new Vue({
       template:
         '<div attr>' +
-          '<foo v-for="item in list" :key="item">{{ item }}</foo>' +
+        '<foo v-for="item in list" :key="item">{{ item }}</foo>' +
         '</div>',
       data: {
         list: undefined
@@ -717,7 +826,7 @@ describe('Directive v-for', () => {
       components: {
         foo: {
           template: '<div><slot></slot></div>'
-        },
+        }
       }
     }).$mount()
     expect(vm.$el.innerHTML).toBe('')
@@ -727,12 +836,10 @@ describe('Directive v-for', () => {
     }).then(done)
   })
 
-  it('elements with v-for and empty list', done => {
+  it('elements with v-for and empty list', (done) => {
     const vm = new Vue({
       template:
-        '<div attr>' +
-          '<div v-for="item in list">{{ item }}</div>' +
-        '</div>',
+        '<div attr>' + '<div v-for="item in list">{{ item }}</div>' + '</div>',
       data: {
         list: undefined
       }
@@ -755,15 +862,22 @@ describe('Directive v-for', () => {
     it('should support destructuring syntax in alias position (object)', () => {
       const vm = new Vue({
         data: { list: [{ foo: 'hi', bar: 'ho' }] },
-        template: '<div><div v-for="({ foo, bar }, i) in list">{{ foo }} {{ bar }} {{ i }}</div></div>'
+        template:
+          '<div><div v-for="({ foo, bar }, i) in list">{{ foo }} {{ bar }} {{ i }}</div></div>'
       }).$mount()
       expect(vm.$el.textContent).toBe('hi ho 0')
     })
 
     it('should support destructuring syntax in alias position (array)', () => {
       const vm = new Vue({
-        data: { list: [[1, 2], [3, 4]] },
-        template: '<div><div v-for="([ foo, bar ], i) in list">{{ foo }} {{ bar }} {{ i }}</div></div>'
+        data: {
+          list: [
+            [1, 2],
+            [3, 4]
+          ]
+        },
+        template:
+          '<div><div v-for="([ foo, bar ], i) in list">{{ foo }} {{ bar }} {{ i }}</div></div>'
       }).$mount()
       expect(vm.$el.textContent).toBe('1 2 03 4 1')
     })
diff --git a/test/unit/features/directives/on.spec.ts b/test/unit/features/directives/on.spec.ts
index 2f8771be94a..12c6bb5cc63 100644
--- a/test/unit/features/directives/on.spec.ts
+++ b/test/unit/features/directives/on.spec.ts
@@ -1,8 +1,9 @@
 import Vue from 'vue'
 import { supportsPassive } from 'core/util/env'
+import { SpyInstanceFn } from 'vitest'
 
 describe('Directive v-on', () => {
-  let vm, spy, el
+  let vm, spy: SpyInstanceFn, el: HTMLElement
 
   beforeEach(() => {
     vm = null
@@ -26,7 +27,7 @@ describe('Directive v-on', () => {
     triggerEvent(vm.$el, 'click')
     expect(spy.mock.calls.length).toBe(1)
 
-    const args = spy.calls.allArgs()
+    const args = spy.mock.calls
     const event = args[0] && args[0][0] || {}
     expect(event.type).toBe('click')
   })
@@ -40,7 +41,7 @@ describe('Directive v-on', () => {
     triggerEvent(vm.$el, 'click')
     expect(spy.mock.calls.length).toBe(1)
 
-    const args = spy.calls.allArgs()
+    const args = spy.mock.calls
     const firstArgs = args[0]
     expect(firstArgs.length).toBe(4)
     expect(firstArgs[0]).toBe(1)
@@ -485,7 +486,7 @@ describe('Directive v-on', () => {
 
     triggerEvent(vm.$el, 'click')
     expect(`The .native modifier for v-on is only valid on components but it was used on <div>.`).not.toHaveBeenWarned()
-    expect(spy.calls.allArgs()).toEqual([['regular']]); // Regular @click should work for dynamic components resolved to native HTML elements.
+    expect(spy.mock.calls).toEqual([['regular']]); // Regular @click should work for dynamic components resolved to native HTML elements.
   })
 
   it('.once modifier should work with child components', () => {
diff --git a/test/unit/features/directives/style.spec.ts b/test/unit/features/directives/style.spec.ts
index d611ca4a4fc..5e6f435b295 100644
--- a/test/unit/features/directives/style.spec.ts
+++ b/test/unit/features/directives/style.spec.ts
@@ -1,13 +1,13 @@
 import Vue from 'vue'
 
-function checkPrefixedProp (prop) {
+function checkPrefixedProp(prop) {
   const el = document.createElement('div')
   const upper = prop.charAt(0).toUpperCase() + prop.slice(1)
   if (!(prop in el.style)) {
     const prefixes = ['Webkit', 'Moz', 'ms']
     let i = prefixes.length
     while (i--) {
-      if ((prefixes[i] + upper) in el.style) {
+      if (prefixes[i] + upper in el.style) {
         prop = prefixes[i] + upper
       }
     }
@@ -21,7 +21,7 @@ describe('Directive v-bind:style', () => {
   beforeEach(() => {
     vm = new Vue({
       template: '<div :style="styles"></div>',
-      data () {
+      data() {
         return {
           styles: {},
           fontSize: 16
@@ -30,51 +30,53 @@ describe('Directive v-bind:style', () => {
     }).$mount()
   })
 
-  it('string', done => {
+  it('string', (done) => {
     vm.styles = 'color:red;'
     waitForUpdate(() => {
       expect(vm.$el.style.cssText.replace(/\s/g, '')).toBe('color:red;')
     }).then(done)
   })
 
-  it('falsy number', done => {
+  it('falsy number', (done) => {
     vm.styles = { opacity: 0 }
     waitForUpdate(() => {
       expect(vm.$el.style.opacity).toBe('0')
     }).then(done)
   })
 
-  it('plain object', done => {
+  it('plain object', (done) => {
     vm.styles = { color: 'red' }
     waitForUpdate(() => {
       expect(vm.$el.style.cssText.replace(/\s/g, '')).toBe('color:red;')
     }).then(done)
   })
 
-  it('camelCase', done => {
+  it('camelCase', (done) => {
     vm.styles = { marginRight: '10px' }
     waitForUpdate(() => {
       expect(vm.$el.style.marginRight).toBe('10px')
     }).then(done)
   })
 
-  it('remove if falsy value', done => {
+  it('remove if falsy value', (done) => {
     vm.$el.style.color = 'red'
     waitForUpdate(() => {
       vm.styles = { color: null }
-    }).then(() => {
-      expect(vm.$el.style.color).toBe('')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.style.color).toBe('')
+      })
+      .then(done)
   })
 
-  it('ignore unsupported property', done => {
+  it('ignore unsupported property', (done) => {
     vm.styles = { foo: 'bar' }
     waitForUpdate(() => {
       expect(vm.$el.style.foo).not.toBe('bar')
     }).then(done)
   })
 
-  it('auto prefix', done => {
+  it('auto prefix', (done) => {
     const prop = checkPrefixedProp('transform')
     const val = 'scale(0.5)'
     vm.styles = { transform: val }
@@ -83,10 +85,10 @@ describe('Directive v-bind:style', () => {
     }).then(done)
   })
 
-  it('auto-prefixed style value as array', done => {
+  it('auto-prefixed style value as array', (done) => {
     vm.styles = { display: ['-webkit-box', '-ms-flexbox', 'flex'] }
     const testEl = document.createElement('div')
-    vm.styles.display.forEach(value => {
+    vm.styles.display.forEach((value) => {
       testEl.style.display = value
     })
     waitForUpdate(() => {
@@ -94,83 +96,91 @@ describe('Directive v-bind:style', () => {
     }).then(done)
   })
 
-  it('!important', done => {
+  it('!important', (done) => {
     vm.styles = { display: 'block !important' }
     waitForUpdate(() => {
       expect(vm.$el.style.getPropertyPriority('display')).toBe('important')
     }).then(done)
   })
 
-  it('camelCase with !important', done => {
+  it('camelCase with !important', (done) => {
     vm.styles = { zIndex: '100 !important' }
     waitForUpdate(() => {
       expect(vm.$el.style.getPropertyPriority('z-index')).toBe('important')
     }).then(done)
   })
 
-  it('object with multiple entries', done => {
+  it('object with multiple entries', (done) => {
     vm.$el.style.color = 'red'
     vm.styles = {
-      marginLeft: '10px',
-      marginRight: '15px'
+      fontSize: '10px'
     }
     waitForUpdate(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('red')
-      expect(vm.$el.style.getPropertyValue('margin-left')).toBe('10px')
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBe('15px')
+      expect(vm.$el.style.color).toBe('red')
+      expect(vm.$el.style.fontSize).toBe('10px')
+      expect(vm.$el.style.getPropertyValue('font-size')).toBe('10px')
       vm.styles = {
         color: 'blue',
         padding: null
       }
-    }).then(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('blue')
-      expect(vm.$el.style.getPropertyValue('padding')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-left')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBeFalsy()
-      // handle falsy value
-      vm.styles = null
-    }).then(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('padding')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-left')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBeFalsy()
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.style.color).toBe('blue')
+        expect(vm.$el.style.padding).toBeFalsy()
+        expect(vm.$el.style.fontSize).toBeFalsy()
+        expect(vm.$el.style.getPropertyValue('font-size')).toBeFalsy()
+        // handle falsy value
+        vm.styles = null
+      })
+      .then(() => {
+        expect(vm.$el.style.color).toBeFalsy()
+        expect(vm.$el.style.padding).toBeFalsy()
+        expect(vm.$el.style.fontSize).toBeFalsy()
+        expect(vm.$el.style.getPropertyValue('font-size')).toBeFalsy()
+      })
+      .then(done)
   })
 
-  it('array of objects', done => {
+  it('array of objects', (done) => {
     vm.$el.style.padding = '10px'
-    vm.styles = [{ color: 'red' }, { marginRight: '20px' }]
+    vm.styles = [{ color: 'red' }, { fontSize: '20px' }]
 
     waitForUpdate(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('red')
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBe('20px')
-      expect(vm.$el.style.getPropertyValue('padding')).toBe('10px')
+      expect(vm.$el.style.color).toBe('red')
+      expect(vm.$el.style.fontSize).toBe('20px')
+      expect(vm.$el.style.padding).toBe('10px')
       vm.styles = [{ color: 'blue' }, { padding: null }]
-    }).then(() => {
-      expect(vm.$el.style.getPropertyValue('color')).toBe('blue')
-      expect(vm.$el.style.getPropertyValue('margin-right')).toBeFalsy()
-      expect(vm.$el.style.getPropertyValue('padding')).toBeFalsy()
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.style.color).toBe('blue')
+        expect(vm.$el.style.fontSize).toBeFalsy()
+        expect(vm.$el.style.padding).toBeFalsy()
+      })
+      .then(done)
   })
 
-  it('updates objects deeply', done => {
+  it('updates objects deeply', (done) => {
     vm.styles = { display: 'none' }
     waitForUpdate(() => {
       expect(vm.$el.style.display).toBe('none')
       vm.styles.display = 'block'
-    }).then(() => {
-      expect(vm.$el.style.display).toBe('block')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.style.display).toBe('block')
+      })
+      .then(done)
   })
 
-  it('background size with only one value', done => {
+  it('background size with only one value', (done) => {
     vm.styles = { backgroundSize: '100%' }
     waitForUpdate(() => {
-      expect(vm.$el.style.cssText.replace(/\s/g, '')).toMatch(/background-size:100%(auto)?;/)
+      expect(vm.$el.style.cssText.replace(/\s/g, '')).toMatch(
+        /background-size:100%(auto)?;/
+      )
     }).then(done)
   })
 
-  it('should work with interpolation', done => {
+  it('should work with interpolation', (done) => {
     vm.styles = { fontSize: `${vm.fontSize}px` }
     waitForUpdate(() => {
       expect(vm.$el.style.fontSize).toBe('16px')
@@ -184,7 +194,7 @@ describe('Directive v-bind:style', () => {
   }
 
   if (supportCssVariable()) {
-    it('CSS variables', done => {
+    it('CSS variables', (done) => {
       vm.styles = { '--color': 'red' }
       waitForUpdate(() => {
         expect(vm.$el.style.getPropertyValue('--color')).toBe('red')
@@ -194,26 +204,29 @@ describe('Directive v-bind:style', () => {
 
   it('should merge static style with binding style', () => {
     const vm = new Vue({
-      template: '<div style="background: url(https://vuejs.org/images/logo.png);color: blue" :style="test"></div>',
+      template:
+        '<div style="background: url(https://vuejs.org/images/logo.png);color: blue" :style="test"></div>',
       data: {
         test: { color: 'red', fontSize: '12px' }
       }
     }).$mount()
     const style = vm.$el.style
-    expect(style.getPropertyValue('background-image')).toMatch('https://vuejs.org/images/logo.png')
-    expect(style.getPropertyValue('color')).toBe('red')
-    expect(style.getPropertyValue('font-size')).toBe('12px')
+    expect(style.backgroundImage).toMatch('https://vuejs.org/images/logo.png')
+    expect(style.color).toBe('red')
+    expect(style.fontSize).toBe('12px')
   })
 
-  it('should merge between parent and child', done => {
+  it('should merge between parent and child', (done) => {
     const vm = new Vue({
-      template: '<child style="text-align: left;margin-right:20px" :style="test"></child>',
+      template:
+        '<child style="text-align: left;margin-right:20px" :style="test"></child>',
       data: {
         test: { color: 'red', fontSize: '12px' }
       },
       components: {
         child: {
-          template: '<div style="margin-right:10px;" :style="{marginLeft: marginLeft}"></div>',
+          template:
+            '<div style="margin-right:10px;" :style="{marginLeft: marginLeft}"></div>',
           data: () => ({ marginLeft: '16px' })
         }
       }
@@ -232,12 +245,15 @@ describe('Directive v-bind:style', () => {
     waitForUpdate(() => {
       expect(style.color).toBe('blue')
       child.marginLeft = '30px'
-    }).then(() => {
-      expect(style.marginLeft).toBe('30px')
-      child.fontSize = '30px'
-    }).then(() => {
-      expect(style.fontSize).toBe('12px')
-    }).then(done)
+    })
+      .then(() => {
+        expect(style.marginLeft).toBe('30px')
+        child.fontSize = '30px'
+      })
+      .then(() => {
+        expect(style.fontSize).toBe('12px')
+      })
+      .then(done)
   })
 
   it('should not pass to child root element', () => {
@@ -248,7 +264,8 @@ describe('Directive v-bind:style', () => {
       },
       components: {
         child: {
-          template: '<div><nested ref="nested" style="color: blue;text-align:left"></nested></div>',
+          template:
+            '<div><nested ref="nested" style="color: blue;text-align:left"></nested></div>',
           components: {
             nested: {
               template: '<div></div>'
@@ -275,8 +292,9 @@ describe('Directive v-bind:style', () => {
           template: '<nested style="color: blue;text-align:left"></nested>',
           components: {
             nested: {
-              template: '<div style="margin-left: 12px;" :style="nestedStyle"></div>',
-              data: () => ({ nestedStyle: { marginLeft: '30px' }})
+              template:
+                '<div style="margin-left: 12px;" :style="nestedStyle"></div>',
+              data: () => ({ nestedStyle: { marginLeft: '30px' } })
             }
           }
         }
@@ -291,25 +309,28 @@ describe('Directive v-bind:style', () => {
     vm.test.color = 'yellow'
     waitForUpdate(() => {
       child.nestedStyle.marginLeft = '60px'
-    }).then(() => {
-      expect(style.marginLeft).toBe('60px')
-      child.nestedStyle = {
-        fontSize: '14px',
-        marginLeft: '40px'
-      }
-    }).then(() => {
-      expect(style.fontSize).toBe('12px')
-      expect(style.marginLeft).toBe('40px')
-    }).then(done)
+    })
+      .then(() => {
+        expect(style.marginLeft).toBe('60px')
+        child.nestedStyle = {
+          fontSize: '14px',
+          marginLeft: '40px'
+        }
+      })
+      .then(() => {
+        expect(style.fontSize).toBe('12px')
+        expect(style.marginLeft).toBe('40px')
+      })
+      .then(done)
   })
 
   it('should not merge for different adjacent elements', (done) => {
     const vm = new Vue({
       template:
         '<div>' +
-          '<section style="color: blue" :style="style" v-if="!bool"></section>' +
-          '<div></div>' +
-          '<section style="margin-top: 12px" v-if="bool"></section>' +
+        '<section style="color: blue" :style="style" v-if="!bool"></section>' +
+        '<div></div>' +
+        '<section style="margin-top: 12px" v-if="bool"></section>' +
         '</div>',
       data: {
         bool: false,
@@ -323,21 +344,23 @@ describe('Directive v-bind:style', () => {
     expect(style.color).toBe('blue')
     waitForUpdate(() => {
       vm.bool = true
-    }).then(() => {
-      expect(style.color).toBe('')
-      expect(style.fontSize).toBe('')
-      expect(style.marginTop).toBe('12px')
-    }).then(done)
+    })
+      .then(() => {
+        expect(style.color).toBe('')
+        expect(style.fontSize).toBe('')
+        expect(style.marginTop).toBe('12px')
+      })
+      .then(done)
   })
 
   it('should not merge for v-if, v-else-if and v-else elements', (done) => {
     const vm = new Vue({
       template:
         '<div>' +
-          '<section style="color: blue" :style="style" v-if="foo"></section>' +
-          '<section style="margin-top: 12px" v-else-if="bar"></section>' +
-          '<section style="margin-bottom: 24px" v-else></section>' +
-          '<div></div>' +
+        '<section style="color: blue" :style="style" v-if="foo"></section>' +
+        '<section style="margin: 12px" v-else-if="bar"></section>' +
+        '<section style="padding: 24px" v-else></section>' +
+        '<div></div>' +
         '</div>',
       data: {
         foo: true,
@@ -352,21 +375,24 @@ describe('Directive v-bind:style', () => {
     expect(style.color).toBe('blue')
     waitForUpdate(() => {
       vm.foo = false
-    }).then(() => {
-      expect(style.color).toBe('')
-      expect(style.fontSize).toBe('')
-      expect(style.marginBottom).toBe('24px')
-      vm.bar = true
-    }).then(() => {
-      expect(style.color).toBe('')
-      expect(style.fontSize).toBe('')
-      expect(style.marginBottom).toBe('')
-      expect(style.marginTop).toBe('12px')
-    }).then(done)
+    })
+      .then(() => {
+        expect(style.color).toBe('')
+        expect(style.fontSize).toBe('')
+        expect(style.padding).toBe('24px')
+        vm.bar = true
+      })
+      .then(() => {
+        expect(style.color).toBe('')
+        expect(style.fontSize).toBe('')
+        expect(style.padding).toBe('')
+        expect(style.margin).toBe('12px')
+      })
+      .then(done)
   })
 
   // #5318
-  it('should work for elements passed down as a slot', done => {
+  it('should work for elements passed down as a slot', (done) => {
     const vm = new Vue({
       template: `<test><div :style="style"/></test>`,
       data: {

From 73bcd0719447070c05789fffd457cfc167c38d88 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 10:12:40 +0800
Subject: [PATCH 047/317] test: all features except transition pass

---
 .gitignore                                    |   1 -
 test/helpers/to-have-warned.ts                |   6 +-
 test/ssr/ssr-bundle-render.spec.ts            |   4 +-
 test/unit/features/debug.spec.ts              |   7 +-
 test/unit/features/error-handling.spec.ts     |   3 +-
 test/unit/features/instance/init.spec.ts      |   2 -
 .../features/instance/methods-events.spec.ts  |   3 +-
 .../instance/methods-lifecycle.spec.ts        |   4 +-
 .../unit/features/instance/properties.spec.ts |   6 +-
 test/unit/features/options/data.spec.ts       |   2 +-
 test/unit/features/options/directives.spec.ts |  13 +-
 test/unit/features/options/functional.spec.ts |   2 +-
 test/unit/features/options/lifecycle.spec.ts  |   3 +-
 test/unit/features/options/mixins.spec.ts     |  14 +-
 test/unit/features/options/name.spec.ts       |   2 +-
 test/unit/features/options/props.spec.ts      |  60 +++---
 test/unit/features/options/render.spec.ts     |   1 -
 test/unit/features/options/watch.spec.ts      |   3 +-
 test/unit/modules/observer/observer.spec.ts   |   1 -
 types/tsconfig.json                           |  20 +-
 typescript/component.d.ts                     | 187 +++++++++---------
 typescript/global-api.d.ts                    |  47 +++--
 typescript/options.d.ts                       |   2 +
 23 files changed, 191 insertions(+), 202 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6778e3ad772..1dd81e3fe8b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,4 +20,3 @@ packages/vue-template-compiler/build.js
 packages/vue-template-compiler/browser.js
 .vscode
 dist
-debug.spec.ts
diff --git a/test/helpers/to-have-warned.ts b/test/helpers/to-have-warned.ts
index 97eecfd1f34..1a931595eaa 100644
--- a/test/helpers/to-have-warned.ts
+++ b/test/helpers/to-have-warned.ts
@@ -3,7 +3,9 @@ import { SpyInstance } from 'vitest'
 expect.extend({
   toHaveBeenWarned(received: string) {
     asserted.add(received)
-    const passed = warn.mock.calls.some((args) => args[0].includes(received))
+    const passed = warn.mock.calls.some((args) =>
+      String(args[0]).includes(received)
+    )
     if (passed) {
       return {
         pass: true,
@@ -102,7 +104,7 @@ afterEach(() => {
     .map((args) => args[0])
     .filter((received) => {
       return !assertedArray.some((assertedMsg) => {
-        return received.includes(assertedMsg)
+        return String(received).includes(assertedMsg)
       })
     })
   warn.mockRestore()
diff --git a/test/ssr/ssr-bundle-render.spec.ts b/test/ssr/ssr-bundle-render.spec.ts
index a44bc8e1d31..530b5f321f2 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/test/ssr/ssr-bundle-render.spec.ts
@@ -131,7 +131,7 @@ function createAssertions (runInNewContext) {
         expect(err).toBeNull()
         expect(res).toBe(expected)
         expect(get).toHaveBeenCalledWith(key)
-        const setArgs = set.calls.argsFor(0)
+        const setArgs = set.mock.calls[0]
         expect(setArgs[0]).toBe(key)
         expect(setArgs[1].html).toBe(expected)
         expect(cache[key].html).toBe(expected)
@@ -178,7 +178,7 @@ function createAssertions (runInNewContext) {
         expect(res).toBe(expected)
         expect(has).toHaveBeenCalledWith(key)
         expect(get).not.toHaveBeenCalled()
-        const setArgs = set.calls.argsFor(0)
+        const setArgs = set.mock.calls[0]
         expect(setArgs[0]).toBe(key)
         expect(setArgs[1].html).toBe(expected)
         expect(cache[key].html).toBe(expected)
diff --git a/test/unit/features/debug.spec.ts b/test/unit/features/debug.spec.ts
index 4f510e79c77..6e206c0d356 100644
--- a/test/unit/features/debug.spec.ts
+++ b/test/unit/features/debug.spec.ts
@@ -3,7 +3,6 @@ import { formatComponentName, warn } from 'core/util/debug'
 
 describe('Debug utilities', () => {
   it('properly format component names', () => {
-    // @ts-expect-error
     const vm = new Vue()
     expect(formatComponentName(vm)).toBe('<Root>')
 
@@ -84,15 +83,15 @@ found in
 
   describe('warn', () => {
     const msg = 'message'
-    // @ts-expect-error
     const vm = new Vue()
 
     it('calls warnHandler if warnHandler is set', () => {
-      Vue.config.warnHandler = vi.fn()
+      const spy = Vue.config.warnHandler = vi.fn()
 
       warn(msg, vm)
 
-      expect(Vue.config.warnHandler).toHaveBeenCalledWith(msg, vm, jasmine.any(String))
+      expect(spy.mock.calls[0][0]).toBe(msg)
+      expect(spy.mock.calls[0][1]).toBe(vm)
 
       // @ts-expect-error
       Vue.config.warnHandler = null
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index 7ef5f84ccc5..ba737e616ec 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -152,7 +152,7 @@ describe('Error handling', () => {
     const spy = Vue.config.errorHandler = vi.fn()
     const vm = createTestInstance(components.render)
 
-    const args = spy.calls.argsFor(0)
+    const args = spy.mock.calls[0]
     expect(args[0].toString()).toContain('Error: render') // error
     expect(args[1]).toBe(vm.$refs.child) // vm
     expect(args[2]).toContain('render') // description
@@ -170,7 +170,6 @@ describe('Error handling', () => {
     Vue.nextTick(() => {
       expect(spy).toHaveBeenCalledWith(err1, undefined, 'nextTick')
 
-      // @ts-expect-error
       const vm = new Vue()
       vm.$nextTick(() => { throw err2 })
       Vue.nextTick(() => {
diff --git a/test/unit/features/instance/init.spec.ts b/test/unit/features/instance/init.spec.ts
index 5fda9407c78..62cc06dc22d 100644
--- a/test/unit/features/instance/init.spec.ts
+++ b/test/unit/features/instance/init.spec.ts
@@ -2,13 +2,11 @@ import Vue from 'vue'
 
 describe('Initialization', () => {
   it('without new', () => {
-    // @ts-expect-error
     try { Vue() } catch (e) {}
     expect('Vue is a constructor and should be called with the `new` keyword').toHaveBeenWarned()
   })
 
   it('with new', () => {
-    // @ts-expect-error
     expect(new Vue() instanceof Vue).toBe(true)
   })
 })
diff --git a/test/unit/features/instance/methods-events.spec.ts b/test/unit/features/instance/methods-events.spec.ts
index 09aa52825f4..a9dd77b219d 100644
--- a/test/unit/features/instance/methods-events.spec.ts
+++ b/test/unit/features/instance/methods-events.spec.ts
@@ -3,8 +3,7 @@ import Vue from 'vue'
 describe('Instance methods events', () => {
   let vm, spy
   beforeEach(() => {
-    // @ts-expect-error
-    const vm = new Vue()
+    vm = new Vue({})
     spy = vi.fn()
   })
 
diff --git a/test/unit/features/instance/methods-lifecycle.spec.ts b/test/unit/features/instance/methods-lifecycle.spec.ts
index 3af73efbb69..19b4727a358 100644
--- a/test/unit/features/instance/methods-lifecycle.spec.ts
+++ b/test/unit/features/instance/methods-lifecycle.spec.ts
@@ -35,13 +35,13 @@ describe('Instance methods lifecycle', () => {
     })
 
     it('Dep.target should be undefined in lifecycle', () => {
-      const vm = new Vue({
+      new Vue({
         template: '<div><my-component></my-component></div>',
         components: {
           myComponent: {
             template: '<div>hi</div>',
             mounted () {
-              const _msg = this.msg
+              this.msg
               expect(Dep.target).toBe(undefined)
             },
             computed: {
diff --git a/test/unit/features/instance/properties.spec.ts b/test/unit/features/instance/properties.spec.ts
index 3e4f365335e..fc426ba4ed0 100644
--- a/test/unit/features/instance/properties.spec.ts
+++ b/test/unit/features/instance/properties.spec.ts
@@ -27,8 +27,8 @@ describe('Instance properties', () => {
         b () {}
       }
     })
-    expect(typeof vm.$options.methods.a).toBe('function')
-    expect(typeof vm.$options.methods.b).toBe('function')
+    expect(typeof vm.$options.methods?.a).toBe('function')
+    expect(typeof vm.$options.methods?.b).toBe('function')
   })
 
   it('$root/$children', done => {
@@ -161,7 +161,6 @@ describe('Instance properties', () => {
   })
 
   it('warn mutating $attrs', () => {
-    // @ts-expect-error
     const vm = new Vue()
     vm.$attrs = {}
     expect(`$attrs is readonly`).toHaveBeenWarned()
@@ -197,7 +196,6 @@ describe('Instance properties', () => {
   })
 
   it('warn mutating $listeners', () => {
-    // @ts-expect-error
     const vm = new Vue()
     vm.$listeners = {}
     expect(`$listeners is readonly`).toHaveBeenWarned()
diff --git a/test/unit/features/options/data.spec.ts b/test/unit/features/options/data.spec.ts
index 0f543b2a9fb..ac431bbd939 100644
--- a/test/unit/features/options/data.spec.ts
+++ b/test/unit/features/options/data.spec.ts
@@ -16,7 +16,7 @@ describe('Options data', () => {
   })
 
   it('should merge data properly', () => {
-    const Test: Vue = Vue.extend({
+    const Test = Vue.extend({
       data () {
         return { a: 1 }
       }
diff --git a/test/unit/features/options/directives.spec.ts b/test/unit/features/options/directives.spec.ts
index 6560e1146a4..824377b3bb9 100644
--- a/test/unit/features/options/directives.spec.ts
+++ b/test/unit/features/options/directives.spec.ts
@@ -1,3 +1,4 @@
+import { SpyInstanceFn } from 'vitest'
 import Vue from 'vue'
 
 describe('Options directives', () => {
@@ -152,7 +153,7 @@ describe('Options directives', () => {
   })
 
   it('should properly handle same node with different directive sets', done => {
-    const spies = {}
+    const spies: Record<string, SpyInstanceFn> = {}
     const createSpy = name => (spies[name] = vi.fn())
     const vm = new Vue({
       data: {
@@ -249,20 +250,20 @@ describe('Options directives', () => {
 
     const oldEl = vm.$el
     expect(dir.bind.mock.calls.length).toBe(1)
-    expect(dir.bind.calls.argsFor(0)[0]).toBe(oldEl)
+    expect(dir.bind.mock.calls[0][0]).toBe(oldEl)
     expect(dir.inserted.mock.calls.length).toBe(1)
-    expect(dir.inserted.calls.argsFor(0)[0]).toBe(oldEl)
+    expect(dir.inserted.mock.calls[0][0]).toBe(oldEl)
     expect(dir.unbind).not.toHaveBeenCalled()
 
     vm.$refs.child.ok = false
     waitForUpdate(() => {
       expect(vm.$el.tagName).toBe('SPAN')
       expect(dir.bind.mock.calls.length).toBe(2)
-      expect(dir.bind.calls.argsFor(1)[0]).toBe(vm.$el)
+      expect(dir.bind.mock.calls[1][0]).toBe(vm.$el)
       expect(dir.inserted.mock.calls.length).toBe(2)
-      expect(dir.inserted.calls.argsFor(1)[0]).toBe(vm.$el)
+      expect(dir.inserted.mock.calls[1][0]).toBe(vm.$el)
       expect(dir.unbind.mock.calls.length).toBe(1)
-      expect(dir.unbind.calls.argsFor(0)[0]).toBe(oldEl)
+      expect(dir.unbind.mock.calls[0][0]).toBe(oldEl)
     }).then(done)
   })
 
diff --git a/test/unit/features/options/functional.spec.ts b/test/unit/features/options/functional.spec.ts
index eb4c52a7b20..723ba1b6a4c 100644
--- a/test/unit/features/options/functional.spec.ts
+++ b/test/unit/features/options/functional.spec.ts
@@ -73,7 +73,7 @@ describe('Options functional', () => {
     document.body.appendChild(vm.$el)
     triggerEvent(vm.$el.children[0], 'click')
     expect(foo).toHaveBeenCalled()
-    expect(foo.calls.argsFor(0)[0].type).toBe('click') // should have click event
+    expect(foo.mock.calls[0][0].type).toBe('click') // should have click event
     triggerEvent(vm.$el.children[0], 'mousedown')
     expect(bar).toHaveBeenCalledWith('bar')
     document.body.removeChild(vm.$el)
diff --git a/test/unit/features/options/lifecycle.spec.ts b/test/unit/features/options/lifecycle.spec.ts
index 03f1dec9317..dd4b3e87ad2 100644
--- a/test/unit/features/options/lifecycle.spec.ts
+++ b/test/unit/features/options/lifecycle.spec.ts
@@ -78,8 +78,7 @@ describe('Options lifecycle hooks', () => {
 
     // #3898
     it('should call for manually mounted instance with parent', () => {
-      // @ts-expect-error
-      const vm = new Vue()
+      const parent = new Vue()
       expect(spy).not.toHaveBeenCalled()
       new Vue({
         parent,
diff --git a/test/unit/features/options/mixins.spec.ts b/test/unit/features/options/mixins.spec.ts
index 09be22903f1..8b71b0f355e 100644
--- a/test/unit/features/options/mixins.spec.ts
+++ b/test/unit/features/options/mixins.spec.ts
@@ -56,12 +56,12 @@ describe('Options mixins', () => {
     })
     expect(result.a).toBe(1)
     expect(result.b).toBe(1)
-    expect(result.directives.a).toBe(a)
-    expect(result.directives.b).toBe(b)
-    expect(result.directives.c).toBe(c)
-    expect(result.created[0]).toBe(f1)
-    expect(result.created[1]).toBe(f2)
-    expect(result.created[2]).toBe(f3)
+    expect(result.directives?.a).toBe(a)
+    expect(result.directives?.b).toBe(b)
+    expect(result.directives?.c).toBe(c)
+    expect(result.created?.[0]).toBe(f1)
+    expect(result.created?.[1]).toBe(f2)
+    expect(result.created?.[2]).toBe(f3)
     expect(result.template).toBe('bar')
   })
 
@@ -85,7 +85,7 @@ describe('Options mixins', () => {
         xyz: f3
       }
     })
-    expect(result.methods.xyz).toBe(f3)
+    expect(result.methods?.xyz).toBe(f3)
   })
 
   it('should accept constructors as mixins', () => {
diff --git a/test/unit/features/options/name.spec.ts b/test/unit/features/options/name.spec.ts
index 051ea403064..b982c9fba0e 100644
--- a/test/unit/features/options/name.spec.ts
+++ b/test/unit/features/options/name.spec.ts
@@ -32,7 +32,7 @@ describe('Options name', () => {
   it('id should not override given name when using Vue.component', () => {
     const SuperComponent = Vue.component('super-component', {
       name: 'SuperVue'
-    })
+    })!
 
     expect(SuperComponent.options.components['SuperVue']).toEqual(SuperComponent)
     expect(SuperComponent.options.components['super-component']).toEqual(SuperComponent)
diff --git a/test/unit/features/options/props.spec.ts b/test/unit/features/options/props.spec.ts
index 6a6c1ffde75..6d1978f112c 100644
--- a/test/unit/features/options/props.spec.ts
+++ b/test/unit/features/options/props.spec.ts
@@ -146,7 +146,7 @@ describe('Options props', () => {
   })
 
   describe('assertions', () => {
-    function makeInstance (value, type, validator, required) {
+    function makeInstance (value, type, validator?, required?) {
       return new Vue({
         template: '<test :test="val"></test>',
         data: {
@@ -169,56 +169,56 @@ describe('Options props', () => {
 
     it('string', () => {
       makeInstance('hello', String)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(123, String)
       expect('Expected String with value "123", got Number with value 123').toHaveBeenWarned()
     })
 
     it('number', () => {
       makeInstance(123, Number)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance('123', Number)
       expect('Expected Number with value 123, got String with value "123"').toHaveBeenWarned()
     })
 
     it('number & boolean', () => {
       makeInstance(123, Number)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(false, Number)
       expect('Expected Number, got Boolean with value false').toHaveBeenWarned()
     })
 
     it('string & boolean', () => {
       makeInstance('hello', String)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(true, String)
       expect('Expected String, got Boolean with value true').toHaveBeenWarned()
     })
 
     it('boolean', () => {
       makeInstance(true, Boolean)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance('123', Boolean)
       expect('Expected Boolean, got String with value "123"').toHaveBeenWarned()
     })
 
     it('function', () => {
       makeInstance(() => {}, Function)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(123, Function)
       expect('Expected Function, got Number with value 123').toHaveBeenWarned()
     })
 
     it('object', () => {
       makeInstance({}, Object)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance([], Object)
       expect('Expected Object, got Array').toHaveBeenWarned()
     })
 
     it('array', () => {
       makeInstance([], Array)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance({}, Array)
       expect('Expected Array, got Object').toHaveBeenWarned()
     })
@@ -226,18 +226,18 @@ describe('Options props', () => {
     it('primitive wrapper objects', () => {
       /* eslint-disable no-new-wrappers */
       makeInstance(new String('s'), String)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(new Number(1), Number)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(new Boolean(true), Boolean)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       /* eslint-enable no-new-wrappers */
     })
 
     if (hasSymbol) {
       it('symbol', () => {
         makeInstance(Symbol('foo'), Symbol)
-        expect(console.error.mock.calls.length).toBe(0)
+        expect((console.error as any).mock.calls.length).toBe(0)
         makeInstance({}, Symbol)
         expect('Expected Symbol, got Object').toHaveBeenWarned()
       })
@@ -257,7 +257,7 @@ describe('Options props', () => {
       /* global BigInt */
       it('bigint', () => {
         makeInstance(BigInt(100), BigInt)
-        expect(console.error.mock.calls.length).toBe(0)
+        expect((console.error as any).mock.calls.length).toBe(0)
         makeInstance({}, BigInt)
         expect('Expected BigInt, got Object').toHaveBeenWarned()
       })
@@ -266,28 +266,28 @@ describe('Options props', () => {
     it('custom constructor', () => {
       function Class () {}
       makeInstance(new Class(), Class)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance({}, Class)
       expect('type check failed').toHaveBeenWarned()
     })
 
     it('multiple types', () => {
       makeInstance([], [Array, Number, Boolean])
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance({}, [Array, Number, Boolean])
       expect('Expected Array, Number, Boolean, got Object').toHaveBeenWarned()
     })
 
     it('custom validator', () => {
       makeInstance(123, null, v => v === 123)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(123, null, v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
     })
 
     it('type check + custom validator', () => {
       makeInstance(123, Number, v => v === 123)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(123, Number, v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
       makeInstance(123, String, v => v === 123)
@@ -296,7 +296,7 @@ describe('Options props', () => {
 
     it('multiple types + custom validator', () => {
       makeInstance(123, [Number, String, Boolean], v => v === 123)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(123, [Number, String, Boolean], v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
       makeInstance(123, [String, Boolean], v => v === 123)
@@ -305,31 +305,31 @@ describe('Options props', () => {
 
     it('optional with type + null/undefined', () => {
       makeInstance(undefined, String)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(null, String)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
     })
 
     it('required with type + null/undefined', () => {
       makeInstance(undefined, String, null, true)
-      expect(console.error.mock.calls.length).toBe(1)
+      expect((console.error as any).mock.calls.length).toBe(1)
       expect('Expected String').toHaveBeenWarned()
       makeInstance(null, Boolean, null, true)
-      expect(console.error.mock.calls.length).toBe(2)
+      expect((console.error as any).mock.calls.length).toBe(2)
       expect('Expected Boolean').toHaveBeenWarned()
     })
 
     it('optional prop of any type (type: true or prop: true)', () => {
       makeInstance(1, true)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance('any', true)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance({}, true)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(undefined, true)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(null, true)
-      expect(console.error.mock.calls.length).toBe(0)
+      expect((console.error as any).mock.calls.length).toBe(0)
     })
   })
 
@@ -468,7 +468,7 @@ describe('Options props', () => {
         }
       }
     }).$mount()
-    expect(console.error.mock.calls.length).toBe(0)
+    expect((console.error as any).mock.calls.length).toBe(0)
   })
 
   // #3453
@@ -565,7 +565,7 @@ describe('Options props', () => {
   })
 
   it('should warn when a prop type is not a constructor', () => {
-    const vm = new Vue({
+    new Vue({
       template: '<div>{{a}}</div>',
       props: {
         a: {
diff --git a/test/unit/features/options/render.spec.ts b/test/unit/features/options/render.spec.ts
index 3b73d029dca..736afa2ca4d 100644
--- a/test/unit/features/options/render.spec.ts
+++ b/test/unit/features/options/render.spec.ts
@@ -33,7 +33,6 @@ describe('Options render', () => {
   })
 
   it('should warn non `render` option and non `template` option', () => {
-    // @ts-expect-error
     new Vue().$mount()
     expect('Failed to mount component: template or render function not defined.').toHaveBeenWarned()
   })
diff --git a/test/unit/features/options/watch.spec.ts b/test/unit/features/options/watch.spec.ts
index 234852a038b..edd298066b9 100644
--- a/test/unit/features/options/watch.spec.ts
+++ b/test/unit/features/options/watch.spec.ts
@@ -1,6 +1,5 @@
 import Vue from 'vue'
 import testObjectOption from '../../../helpers/test-object-option'
-import { finished } from 'stream';
 
 describe('Options watch', () => {
   let spy
@@ -163,7 +162,7 @@ describe('Options watch', () => {
   })
 
   it('should not warn proper usage', () => {
-    const vm = new Vue({
+    new Vue({
       data: {
         foo: { _bar: 1 }, // element has such watchers...
         prop1: 123
diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index 698931dcee4..f8341c1719c 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -14,7 +14,6 @@ describe('Observer', () => {
     const ob1 = observe(1)
     expect(ob1).toBeUndefined()
     // avoid vue instance
-    // @ts-expect-error
     const ob2 = observe(new Vue())
     expect(ob2).toBeUndefined()
     // avoid frozen objects
diff --git a/types/tsconfig.json b/types/tsconfig.json
index 57d9919cc76..ffccdfc70d3 100644
--- a/types/tsconfig.json
+++ b/types/tsconfig.json
@@ -2,26 +2,16 @@
   "compilerOptions": {
     "target": "es5",
     "experimentalDecorators": true,
-    "lib": [
-      "dom",
-      "es2015"
-    ],
-    "types": [
-      "node",
-      "jasmine",
-      "webpack-env"
-    ],
+    "lib": ["dom", "es2015"],
+    "types": ["node"],
     "module": "commonjs",
     "strict": true,
     "noEmit": true,
     "baseUrl": ".",
     "paths": {
       "vue": ["../index.d.ts"]
-    },
+    }
   },
-  "include": [
-    "./*.d.ts",
-    "*.ts"
-  ],
+  "include": ["./*.d.ts", "*.ts"],
   "compileOnSave": false
-}
\ No newline at end of file
+}
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index c0a0bc9b0c0..0f9c4c616a8 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -1,113 +1,114 @@
-import type VNode from "../src/core/vdom/vnode";
-import type Watcher from "../src/core/observer/watcher";
-import { ComponentOptions } from "./options";
-import { ScopedSlotsData, VNodeChildren, VNodeData } from "./vnode";
+import type VNode from '../src/core/vdom/vnode'
+import type Watcher from '../src/core/observer/watcher'
+import { ComponentOptions } from './options'
+import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
 
 // TODO this should be using the same as /component/
 
-declare class Component {
+export declare class Component {
+  constructor(options?: any)
   // constructor information
-  static cid: number;
-  static options: Record<string, any>;
+  static cid: number
+  static options: Record<string, any>
   // extend
-  static extend: (options: Record<string, any>) => Function;
-  static superOptions: Record<string, any>;
-  static extendOptions: Record<string, any>;
-  static sealedOptions: Record<string, any>;
-  static super: Component;
+  static extend: (options: Record<string, any>) => typeof Component
+  static superOptions: Record<string, any>
+  static extendOptions: Record<string, any>
+  static sealedOptions: Record<string, any>
+  static super: Component
   // assets
   static directive: (
     id: string,
     def?: Function | Record<string, any>
-  ) => Function | Record<string, any> | void;
+  ) => Function | Record<string, any> | void
   static component: (
     id: string,
     def?: Component | Record<string, any>
-  ) => Component;
-  static filter: (id: string, def?: Function) => Function | void;
+  ) => Component
+  static filter: (id: string, def?: Function) => Function | void
   // functional context constructor
-  static FunctionalRenderContext: Function;
+  static FunctionalRenderContext: Function
 
   // public properties
-  $el: any; // so that we can attach __vue__ to it
-  $data: Record<string, any>;
-  $props: Record<string, any>;
-  $options: ComponentOptions;
-  $parent: Component | undefined;
-  $root: Component;
-  $children: Array<Component>;
+  $el: any // so that we can attach __vue__ to it
+  $data: Record<string, any>
+  $props: Record<string, any>
+  $options: ComponentOptions
+  $parent: Component | undefined
+  $root: Component
+  $children: Array<Component>
   $refs: {
-    [key: string]: Component | Element | Array<Component | Element> | undefined;
-  };
-  $slots: { [key: string]: Array<VNode> };
-  $scopedSlots: { [key: string]: () => VNodeChildren };
-  $vnode: VNode; // the placeholder node for the component in parent's render tree
-  $attrs: { [key: string]: string };
-  $listeners: Record<string, Function | Array<Function>>;
-  $isServer: boolean;
+    [key: string]: Component | Element | Array<Component | Element> | undefined
+  }
+  $slots: { [key: string]: Array<VNode> }
+  $scopedSlots: { [key: string]: () => VNodeChildren }
+  $vnode: VNode // the placeholder node for the component in parent's render tree
+  $attrs: { [key: string]: string }
+  $listeners: Record<string, Function | Array<Function>>
+  $isServer: boolean
 
   // public methods
-  $mount: (el?: Element | string, hydrating?: boolean) => Component;
-  $forceUpdate: () => void;
-  $destroy: () => void;
+  $mount: (el?: Element | string, hydrating?: boolean) => Component
+  $forceUpdate: () => void
+  $destroy: () => void
   $set: <T>(
     target: Record<string, any> | Array<T>,
     key: string | number,
     val: T
-  ) => T;
+  ) => T
   $delete: <T>(
     target: Record<string, any> | Array<T>,
     key: string | number
-  ) => void;
+  ) => void
   $watch: (
     expOrFn: string | Function,
     cb: Function,
     options?: Record<string, any>
-  ) => Function;
-  $on: (event: string | Array<string>, fn: Function) => Component;
-  $once: (event: string, fn: Function) => Component;
-  $off: (event?: string | Array<string>, fn?: Function) => Component;
-  $emit: (event: string, ...args: Array<any>) => Component;
-  $nextTick: (fn: Function) => void | Promise<any>;
+  ) => Function
+  $on: (event: string | Array<string>, fn: Function) => Component
+  $once: (event: string, fn: Function) => Component
+  $off: (event?: string | Array<string>, fn?: Function) => Component
+  $emit: (event: string, ...args: Array<any>) => Component
+  $nextTick: (fn: Function) => void | Promise<any>
   $createElement: (
     tag?: string | Component,
     data?: Record<string, any>,
     children?: VNodeChildren
-  ) => VNode;
+  ) => VNode
 
   // private properties
-  _uid: number | string;
-  _name: string; // this only exists in dev mode
-  _isVue: true;
-  _self: Component;
-  _renderProxy: Component;
-  _renderContext?: Component;
-  _watcher: Watcher | null;
-  _watchers: Array<Watcher>;
-  _computedWatchers: { [key: string]: Watcher };
-  _data: Record<string, any>;
-  _props: Record<string, any>;
-  _events: Record<string, any>;
-  _inactive: boolean | null;
-  _directInactive: boolean;
-  _isMounted: boolean;
-  _isDestroyed: boolean;
-  _isBeingDestroyed: boolean;
-  _vnode?: VNode | null; // self root node
-  _staticTrees?: Array<VNode> | null; // v-once cached trees
-  _hasHookEvent: boolean;
-  _provided?: Record<string, any>;
+  _uid: number | string
+  _name: string // this only exists in dev mode
+  _isVue: true
+  _self: Component
+  _renderProxy: Component
+  _renderContext?: Component
+  _watcher: Watcher | null
+  _watchers: Array<Watcher>
+  _computedWatchers: { [key: string]: Watcher }
+  _data: Record<string, any>
+  _props: Record<string, any>
+  _events: Record<string, any>
+  _inactive: boolean | null
+  _directInactive: boolean
+  _isMounted: boolean
+  _isDestroyed: boolean
+  _isBeingDestroyed: boolean
+  _vnode?: VNode | null // self root node
+  _staticTrees?: Array<VNode> | null // v-once cached trees
+  _hasHookEvent: boolean
+  _provided?: Record<string, any>
   // _virtualComponents?: { [key: string]: Component };
 
   // private methods
 
   // lifecycle
-  _init: Function;
-  _mount: (el?: Element | void, hydrating?: boolean) => Component;
-  _update: (vnode: VNode, hydrating?: boolean) => void;
+  _init: Function
+  _mount: (el?: Element | void, hydrating?: boolean) => Component
+  _update: (vnode: VNode, hydrating?: boolean) => void
 
   // rendering
-  _render: () => VNode;
+  _render: () => VNode
 
   __patch__: (
     a: Element | VNode | void | null,
@@ -116,7 +117,7 @@ declare class Component {
     removeOnly?: boolean,
     parentElm?: any,
     refElm?: any
-  ) => any;
+  ) => any
 
   // createElement
 
@@ -126,38 +127,38 @@ declare class Component {
     data?: VNodeData,
     children?: VNodeChildren,
     normalizationType?: number
-  ) => VNode | void;
+  ) => VNode | void
 
   // renderStatic
-  _m: (index: number, isInFor?: boolean) => VNode | VNodeChildren;
+  _m: (index: number, isInFor?: boolean) => VNode | VNodeChildren
   // markOnce
   _o: (
     vnode: VNode | Array<VNode>,
     index: number,
     key: string
-  ) => VNode | VNodeChildren;
+  ) => VNode | VNodeChildren
   // toString
-  _s: (value: any) => string;
+  _s: (value: any) => string
   // text to VNode
-  _v: (value: string | number) => VNode;
+  _v: (value: string | number) => VNode
   // toNumber
-  _n: (value: string) => number | string;
+  _n: (value: string) => number | string
   // empty vnode
-  _e: () => VNode;
+  _e: () => VNode
   // loose equal
-  _q: (a: any, b: any) => boolean;
+  _q: (a: any, b: any) => boolean
   // loose indexOf
-  _i: (arr: Array<any>, val: any) => number;
+  _i: (arr: Array<any>, val: any) => number
   // resolveFilter
-  _f: (id: string) => Function;
+  _f: (id: string) => Function
   // renderList
-  _l: (val: any, render: Function) => Array<VNode> | null;
+  _l: (val: any, render: Function) => Array<VNode> | null
   // renderSlot
   _t: (
     name: string,
     fallback?: Array<VNode>,
     props?: Record<string, any>
-  ) => Array<VNode> | null;
+  ) => Array<VNode> | null
   // apply v-bind object
   _b: (
     data: any,
@@ -165,32 +166,32 @@ declare class Component {
     value: any,
     asProp: boolean,
     isSync?: boolean
-  ) => VNodeData;
+  ) => VNodeData
   // apply v-on object
-  _g: (data: any, value: any) => VNodeData;
+  _g: (data: any, value: any) => VNodeData
   // check custom keyCode
   _k: (
     eventKeyCode: number,
     key: string,
     builtInAlias?: number | Array<number>,
     eventKeyName?: string
-  ) => boolean | null;
+  ) => boolean | null
   // resolve scoped slots
   _u: (
     scopedSlots: ScopedSlotsData,
     res?: Record<string, any>
-  ) => { [key: string]: Function };
+  ) => { [key: string]: Function }
 
   // SSR specific
-  _ssrNode: Function;
-  _ssrList: Function;
-  _ssrEscape: Function;
-  _ssrAttr: Function;
-  _ssrAttrs: Function;
-  _ssrDOMProps: Function;
-  _ssrClass: Function;
+  _ssrNode: Function
+  _ssrList: Function
+  _ssrEscape: Function
+  _ssrAttr: Function
+  _ssrAttrs: Function
+  _ssrDOMProps: Function
+  _ssrClass: Function
   _ssrStyle: Function;
 
   // allow dynamic method registration
-  [key: string]: any;
+  [key: string]: any
 }
diff --git a/typescript/global-api.d.ts b/typescript/global-api.d.ts
index d484c8a99c0..eab61b82b2a 100644
--- a/typescript/global-api.d.ts
+++ b/typescript/global-api.d.ts
@@ -1,29 +1,34 @@
-import { Config } from "../src/core/config";
-import { Component } from "./component";
+import { Config } from '../src/core/config'
+import { Component } from './component'
 
 declare interface GlobalAPI {
-  (options: any): void;
-  cid: number;
-  options: Record<string, any>;
-  config: Config;
-  util: Object;
+  // new(options?: any): Component
+  (options?: any): void
+  cid: number
+  options: Record<string, any>
+  config: Config
+  util: Object
 
-  extend: (options: Object) => Component;
-  set: <T>(target: Object | Array<T>, key: string | number, value: T) => T;
-  delete: <T>(target: Object | Array<T>, key: string | number) => void;
-  nextTick: (fn: Function, context?: Object) => void | Promise<any>;
-  use: (plugin: Function | Object) => GlobalAPI;
-  mixin: (mixin: Object) => GlobalAPI;
-  compile: (
-    template: string
-  ) => { render: Function; staticRenderFns: Array<Function> };
+  extend: (options: Object) => typeof Component
+  set: <T>(target: Object | Array<T>, key: string | number, value: T) => T
+  delete: <T>(target: Object | Array<T>, key: string | number) => void
+  nextTick: (fn: Function, context?: Object) => void | Promise<any>
+  use: (plugin: Function | Object) => GlobalAPI
+  mixin: (mixin: Object) => GlobalAPI
+  compile: (template: string) => {
+    render: Function
+    staticRenderFns: Array<Function>
+  }
 
-  directive: (id: string, def?: Function | Object) => Function | Object | void;
-  component: (id: string, def?: Component | Object) => Component;
-  filter: (id: string, def?: Function) => Function | void;
+  directive: (id: string, def?: Function | Object) => Function | Object | void
+  component: (
+    id: string,
+    def?: typeof Component | Object
+  ) => typeof Component | void
+  filter: (id: string, def?: Function) => Function | void
 
-  observable: <T>(value: T) => T;
+  observable: <T>(value: T) => T
 
   // allow dynamic method registration
-  [key: string]: any;
+  [key: string]: any
 }
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
index c06aa595454..b562a913235 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.d.ts
@@ -12,6 +12,8 @@ declare type InternalComponentOptions = {
 type InjectKey = string | Symbol;
 
 declare type ComponentOptions = {
+  [key: string]: any
+
   componentId?: string;
 
   // data

From fed8c3bfd260d3a5a5d33797f1e84f819ee53696 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 10:27:57 +0800
Subject: [PATCH 048/317] test: all unit tests except transition passing

---
 test/unit/modules/observer/observer.spec.ts   | 80 ++++++++++---------
 .../modules/server-compiler/optimizer.spec.ts |  0
 test/unit/modules/sfc/sfc-parser.spec.ts      | 36 ++++-----
 .../modules/vdom/create-component.spec.ts     |  8 +-
 4 files changed, 63 insertions(+), 61 deletions(-)
 delete mode 100644 test/unit/modules/server-compiler/optimizer.spec.ts

diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index f8341c1719c..18d71780ef2 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -23,11 +23,11 @@ describe('Observer', () => {
 
   it('create on object', () => {
     // on object
-    const obj = {
+    const obj: any = {
       a: {},
       b: {}
     }
-    const ob1 = observe(obj)
+    const ob1 = observe(obj)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(obj)
     expect(obj.__ob__).toBe(ob1)
@@ -35,16 +35,16 @@ describe('Observer', () => {
     expect(obj.a.__ob__ instanceof Observer).toBe(true)
     expect(obj.b.__ob__ instanceof Observer).toBe(true)
     // should return existing ob on already observed objects
-    const ob2 = observe(obj)
+    const ob2 = observe(obj)!
     expect(ob2).toBe(ob1)
   })
 
   it('create on null', () => {
     // on null
-    const obj = Object.create(null)
+    const obj: any =Object.create(null)
     obj.a = {}
     obj.b = {}
-    const ob1 = observe(obj)
+    const ob1 = observe(obj)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(obj)
     expect(obj.__ob__).toBe(ob1)
@@ -52,13 +52,13 @@ describe('Observer', () => {
     expect(obj.a.__ob__ instanceof Observer).toBe(true)
     expect(obj.b.__ob__ instanceof Observer).toBe(true)
     // should return existing ob on already observed objects
-    const ob2 = observe(obj)
+    const ob2 = observe(obj)!
     expect(ob2).toBe(ob1)
   })
 
   it('create on already observed object', () => {
     // on object
-    const obj = {}
+    const obj: any = {}
     let val = 0
     let getCount = 0
     Object.defineProperty(obj, 'a', {
@@ -71,7 +71,7 @@ describe('Observer', () => {
       set (v) { val = v }
     })
 
-    const ob1 = observe(obj)
+    const ob1 = observe(obj)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(obj)
     expect(obj.__ob__).toBe(ob1)
@@ -84,7 +84,7 @@ describe('Observer', () => {
     expect(getCount).toBe(2)
 
     // should return existing ob on already observed objects
-    const ob2 = observe(obj)
+    const ob2 = observe(obj)!
     expect(ob2).toBe(ob1)
 
     // should call underlying setter
@@ -94,14 +94,14 @@ describe('Observer', () => {
 
   it('create on property with only getter', () => {
     // on object
-    const obj = {}
+    const obj: any = {}
     Object.defineProperty(obj, 'a', {
       configurable: true,
       enumerable: true,
       get () { return 123 }
     })
 
-    const ob1 = observe(obj)
+    const ob1 = observe(obj)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(obj)
     expect(obj.__ob__).toBe(ob1)
@@ -110,7 +110,7 @@ describe('Observer', () => {
     expect(obj.a).toBe(123)
 
     // should return existing ob on already observed objects
-    const ob2 = observe(obj)
+    const ob2 = observe(obj)!
     expect(ob2).toBe(ob1)
 
     // since there is no setter, you shouldn't be able to write to it
@@ -124,7 +124,7 @@ describe('Observer', () => {
 
   it('create on property with only setter', () => {
     // on object
-    const obj = {}
+    const obj: any ={}
     let val = 10
     Object.defineProperty(obj, 'a', { // eslint-disable-line accessor-pairs
       configurable: true,
@@ -132,7 +132,7 @@ describe('Observer', () => {
       set (v) { val = v }
     })
 
-    const ob1 = observe(obj)
+    const ob1 = observe(obj)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(obj)
     expect(obj.__ob__).toBe(ob1)
@@ -141,7 +141,7 @@ describe('Observer', () => {
     expect(obj.a).toBe(undefined)
 
     // should return existing ob on already observed objects
-    const ob2 = observe(obj)
+    const ob2 = observe(obj)!
     expect(ob2).toBe(ob1)
 
     // writes should call the set function
@@ -151,14 +151,14 @@ describe('Observer', () => {
 
   it('create on property which is marked not configurable', () => {
     // on object
-    const obj = {}
+    const obj: any ={}
     Object.defineProperty(obj, 'a', {
       configurable: false,
       enumerable: true,
-      val: 10
+      value: 10
     })
 
-    const ob1 = observe(obj)
+    const ob1 = observe(obj)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(obj)
     expect(obj.__ob__).toBe(ob1)
@@ -166,8 +166,8 @@ describe('Observer', () => {
 
   it('create on array', () => {
     // on object
-    const arr = [{}, {}]
-    const ob1 = observe(arr)
+    const arr: any = [{}, {}]
+    const ob1 = observe(arr)!
     expect(ob1 instanceof Observer).toBe(true)
     expect(ob1.value).toBe(arr)
     expect(arr.__ob__).toBe(ob1)
@@ -177,10 +177,10 @@ describe('Observer', () => {
   })
 
   it('observing object prop change', () => {
-    const obj = { a: { b: 2 }, c: NaN }
-    observe(obj)
+    const obj: any ={ a: { b: 2 }, c: NaN }
+    observe(obj)!
     // mock a watcher!
-    const watcher = {
+    const watcher: any = {
       deps: [],
       addDep (dep) {
         this.deps.push(dep)
@@ -214,7 +214,7 @@ describe('Observer', () => {
   })
 
   it('observing object prop change on defined property', () => {
-    const obj = { val: 2 }
+    const obj: any ={ val: 2 }
     Object.defineProperty(obj, 'a', {
       configurable: true,
       enumerable: true,
@@ -226,7 +226,7 @@ describe('Observer', () => {
       }
     })
 
-    observe(obj)
+    observe(obj)!
     expect(obj.a).toBe(2) // Make sure 'this' is preserved
     obj.a = 3
     expect(obj.val).toBe(3) // make sure 'setter' was called
@@ -235,10 +235,10 @@ describe('Observer', () => {
   })
 
   it('observing set/delete', () => {
-    const obj1 = { a: 1 }
-    const ob1 = observe(obj1)
+    const obj1: any = { a: 1 }
+    const ob1 = observe(obj1) as any
     const dep1 = ob1.dep
-    spyOn(dep1, 'notify')
+    vi.spyOn(dep1, 'notify')
     setProp(obj1, 'b', 2)
     expect(obj1.b).toBe(2)
     expect(dep1.notify.mock.calls.length).toBe(1)
@@ -262,11 +262,11 @@ describe('Observer', () => {
     delProp(obj2, 'a')
     expect(hasOwn(obj2, 'a')).toBe(false)
     // should work on Object.create(null)
-    const obj3 = Object.create(null)
+    const obj3: any = Object.create(null)
     obj3.a = 1
-    const ob3 = observe(obj3)
+    const ob3 = observe(obj3) as any
     const dep3 = ob3.dep
-    spyOn(dep3, 'notify')
+    vi.spyOn(dep3, 'notify')
     setProp(obj3, 'b', 2)
     expect(obj3.b).toBe(2)
     expect(dep3.notify.mock.calls.length).toBe(1)
@@ -274,10 +274,10 @@ describe('Observer', () => {
     expect(hasOwn(obj3, 'a')).toBe(false)
     expect(dep3.notify.mock.calls.length).toBe(2)
     // set and delete non-numeric key on array
-    const arr2 = ['a']
-    const ob2 = observe(arr2)
+    const arr2: any = ['a']
+    const ob2 = observe(arr2) as any
     const dep2 = ob2.dep
-    spyOn(dep2, 'notify')
+    vi.spyOn(dep2, 'notify')
     setProp(arr2, 'b', 2)
     expect(arr2.b).toBe(2)
     expect(dep2.notify.mock.calls.length).toBe(1)
@@ -327,9 +327,9 @@ describe('Observer', () => {
 
   it('observing array mutation', () => {
     const arr: any[] = []
-    const ob = observe(arr)
+    const ob = observe(arr) as any
     const dep = ob.dep
-    spyOn(dep, 'notify')
+    vi.spyOn(dep, 'notify')
     const objs = [{}, {}, {}]
     arr.push(objs[0])
     arr.pop()
@@ -340,25 +340,27 @@ describe('Observer', () => {
     arr.reverse()
     expect(dep.notify.mock.calls.length).toBe(7)
     // inserted elements should be observed
-    objs.forEach(obj => {
+    objs.forEach((obj: any) => {
       expect(obj.__ob__ instanceof Observer).toBe(true)
     })
   })
 
   it('warn set/delete on non valid values', () => {
     try {
+      // @ts-expect-error
       setProp(null, 'foo', 1)
     } catch (e) {}
     expect(`Cannot set reactive property on undefined, null, or primitive value`).toHaveBeenWarned()
 
     try {
+      // @ts-expect-error
       delProp(null, 'foo')
     } catch (e) {}
     expect(`Cannot delete reactive property on undefined, null, or primitive value`).toHaveBeenWarned()
   })
 
   it('should lazy invoke existing getters', () => {
-    const obj = {}
+    const obj: any ={}
     let called = false
     Object.defineProperty(obj, 'getterProp', {
       enumerable: true,
@@ -367,7 +369,7 @@ describe('Observer', () => {
         return 'some value'
       }
     })
-    observe(obj)
+    observe(obj)!
     expect(called).toBe(false)
   })
 })
diff --git a/test/unit/modules/server-compiler/optimizer.spec.ts b/test/unit/modules/server-compiler/optimizer.spec.ts
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/test/unit/modules/sfc/sfc-parser.spec.ts b/test/unit/modules/sfc/sfc-parser.spec.ts
index 1072b7bb3cf..ff4c9b1b4f2 100644
--- a/test/unit/modules/sfc/sfc-parser.spec.ts
+++ b/test/unit/modules/sfc/sfc-parser.spec.ts
@@ -24,7 +24,7 @@ describe('Single File Component parser', () => {
         <style>nested should be ignored</style>
       </div>
     `)
-    expect(res.template.content.trim()).toBe('<div>hi</div>')
+    expect(res.template!.content.trim()).toBe('<div>hi</div>')
     expect(res.styles.length).toBe(4)
     expect(res.styles[0].src).toBe('./test.css')
     expect(res.styles[1].lang).toBe('stylus')
@@ -33,7 +33,7 @@ describe('Single File Component parser', () => {
     expect(res.styles[2].module).toBe(true)
     expect(res.styles[3].attrs['bool-attr']).toBe(true)
     expect(res.styles[3].attrs['val-attr']).toBe('test')
-    expect(res.script.content.trim()).toBe('export default {}')
+    expect(res.script!.content.trim()).toBe('export default {}')
   })
 
   it('should parse template with closed input', () => {
@@ -43,7 +43,7 @@ describe('Single File Component parser', () => {
       </template>
     `)
 
-    expect(res.template.content.trim()).toBe('<input type="text"/>')
+    expect(res.template!.content.trim()).toBe('<input type="text"/>')
   })
 
   it('should handle nested template', () => {
@@ -52,7 +52,7 @@ describe('Single File Component parser', () => {
         <div><template v-if="ok">hi</template></div>
       </template>
     `)
-    expect(res.template.content.trim()).toBe('<div><template v-if="ok">hi</template></div>')
+    expect(res.template!.content.trim()).toBe('<div><template v-if="ok">hi</template></div>')
   })
 
   it('deindent content', () => {
@@ -71,14 +71,14 @@ describe('Single File Component parser', () => {
     const deindentEnabled = parseComponent(content.trim(), { pad: false, deindent: true })
     const deindentDisabled = parseComponent(content.trim(), { pad: false, deindent: false })
 
-    expect(deindentDefault.template.content).toBe('\n<div></div>\n')
-    expect(deindentDefault.script.content).toBe('\nexport default {}\n')
+    expect(deindentDefault.template!.content).toBe('\n<div></div>\n')
+    expect(deindentDefault.script!.content).toBe('\nexport default {}\n')
     expect(deindentDefault.styles[0].content).toBe('\nh1 { color: red }\n')
-    expect(deindentEnabled.template.content).toBe('\n<div></div>\n')
-    expect(deindentEnabled.script.content).toBe('\nexport default {}\n')
+    expect(deindentEnabled.template!.content).toBe('\n<div></div>\n')
+    expect(deindentEnabled.script!.content).toBe('\nexport default {}\n')
     expect(deindentEnabled.styles[0].content).toBe('\nh1 { color: red }\n')
-    expect(deindentDisabled.template.content).toBe('\n        <div></div>\n      ')
-    expect(deindentDisabled.script.content).toBe('\n        export default {}\n      ')
+    expect(deindentDisabled.template!.content).toBe('\n        <div></div>\n      ')
+    expect(deindentDisabled.script!.content).toBe('\n        export default {}\n      ')
     expect(deindentDisabled.styles[0].content).toBe('\n        h1 { color: red }\n      ')
   })
 
@@ -98,11 +98,11 @@ describe('Single File Component parser', () => {
     const padLine = parseComponent(content.trim(), { pad: 'line' })
     const padSpace = parseComponent(content.trim(), { pad: 'space' })
 
-    expect(padDefault.script.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
+    expect(padDefault.script!.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
     expect(padDefault.styles[0].content).toBe(Array(6 + 1).join('\n') + '\nh1 { color: red }\n')
-    expect(padLine.script.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
+    expect(padLine.script!.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
     expect(padLine.styles[0].content).toBe(Array(6 + 1).join('\n') + '\nh1 { color: red }\n')
-    expect(padSpace.script.content).toBe(`<template>
+    expect(padSpace.script!.content).toBe(`<template>
         <div></div>
       </template>
       <script>`.replace(/./g, ' ') + '\nexport default {}\n')
@@ -122,7 +122,7 @@ describe('Single File Component parser', () => {
           h1(v-if='1 < 2') hello
       </template>
     `)
-    expect(res.template.content.trim()).toBe(`div\n  h1(v-if='1 < 2') hello`)
+    expect(res.template!.content.trim()).toBe(`div\n  h1(v-if='1 < 2') hello`)
   })
 
   it('should handle component contains "<" only', () => {
@@ -131,7 +131,7 @@ describe('Single File Component parser', () => {
         <span><</span>
       </template>
     `)
-    expect(res.template.content.trim()).toBe(`<span><</span>`)
+    expect(res.template!.content.trim()).toBe(`<span><</span>`)
   })
 
   it('should handle custom blocks without parsing them', () => {
@@ -195,17 +195,17 @@ describe('Single File Component parser', () => {
       </template>
     </div>`
     const res = parseComponent(`<template>${raw}</template>`)
-    expect(res.template.content.trim()).toBe(raw)
+    expect(res.template!.content.trim()).toBe(raw)
   })
 
   it('should not hang on trailing text', () => {
     const res = parseComponent(`<template>hi</`)
-    expect(res.template.content).toBe('hi')
+    expect(res.template!.content).toBe('hi')
   })
 
   it('should collect errors with source range', () => {
     const res = parseComponent(`<template>hi</`, { outputSourceRange: true })
     expect(res.errors.length).toBe(1)
-    expect(res.errors[0].start).toBe(0)
+    expect((res.errors[0] as WarningMessage).start).toBe(0)
   })
 })
diff --git a/test/unit/modules/vdom/create-component.spec.ts b/test/unit/modules/vdom/create-component.spec.ts
index 37f8226545b..bb082caf008 100644
--- a/test/unit/modules/vdom/create-component.spec.ts
+++ b/test/unit/modules/vdom/create-component.spec.ts
@@ -4,14 +4,14 @@ import { setCurrentRenderingInstance } from 'core/instance/render'
 
 describe('create-component', () => {
   let vm
-  beforeEach(done => {
+  beforeEach(() => {
     vm = new Vue({
       template: '<p>{{msg}}</p>',
       data () {
         return { msg: 'hello, my children' }
       }
     }).$mount()
-    Vue.nextTick(done)
+    return new Promise(r => Vue.nextTick(r))
   })
 
   it('create a component basically', () => {
@@ -45,7 +45,7 @@ describe('create-component', () => {
       props: {},
       staticAttrs: { class: 'foo' }
     }
-    spyOn(vm, '$forceUpdate')
+    vi.spyOn(vm, '$forceUpdate')
     function async (resolve, reject) {
       setTimeout(() => {
         resolve({
@@ -86,7 +86,7 @@ describe('create-component', () => {
       props: {},
       staticAttrs: { class: 'bar' }
     }
-    spyOn(vm, '$forceUpdate')
+    vi.spyOn(vm, '$forceUpdate')
     function async (resolve, reject) {
       resolve({
         name: 'child',

From 23b1fb550373e4784f0ac4c25219f4df25f1f527 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 10:30:13 +0800
Subject: [PATCH 049/317] test: skip transition tests for now

---
 .../transition/transition-group.spec.ts       |  465 ++--
 .../transition/transition-mode.spec.ts        |  857 ++++---
 .../transition-with-keep-alive.spec.ts        | 1115 ++++----
 .../features/transition/transition.spec.ts    | 2238 ++++++++++-------
 4 files changed, 2689 insertions(+), 1986 deletions(-)

diff --git a/test/unit/features/transition/transition-group.spec.ts b/test/unit/features/transition/transition-group.spec.ts
index f109a8c26b7..7f2499bd93f 100644
--- a/test/unit/features/transition/transition-group.spec.ts
+++ b/test/unit/features/transition/transition-group.spec.ts
@@ -1,344 +1,395 @@
 import Vue from 'vue'
 import injectStyles from './inject-styles'
-import { isIE9 } from 'core/util/env'
 import { nextFrame } from 'web/runtime/transition-util'
 
-if (!isIE9) {
-  describe('Transition group', () => {
-    const { duration, buffer } = injectStyles()
+describe.skip('Transition group', () => {
+  const { duration, buffer } = injectStyles()
 
-    let el
-    beforeEach(() => {
-      el = document.createElement('div')
-      document.body.appendChild(el)
-    })
+  let el
+  beforeEach(() => {
+    el = document.createElement('div')
+    document.body.appendChild(el)
+  })
 
-    function createBasicVM (useIs, appear) {
-      const vm = new Vue({
-        template: `
+  function createBasicVM(useIs?, appear = false) {
+    const vm = new Vue({
+      template: `
           <div>
-            ${useIs ? `<span is="transition-group">` : `<transition-group${appear ? ` appear` : ``}>`}
+            ${
+              useIs
+                ? `<span is="transition-group">`
+                : `<transition-group${appear ? ` appear` : ``}>`
+            }
               <div v-for="item in items" :key="item" class="test">{{ item }}</div>
             ${useIs ? `</span>` : `</transition-group>`}
           </div>
         `,
-        data: {
-          items: ['a', 'b', 'c']
-        }
-      }).$mount(el)
-      if (!appear) {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
-        )
+      data: {
+        items: ['a', 'b', 'c']
       }
-      return vm
+    }).$mount(el)
+    if (!appear) {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+          `</span>`
+      )
     }
+    return vm
+  }
 
-    it('enter', done => {
-      const vm = createBasicVM()
-      vm.items.push('d', 'e')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            ['a', 'b', 'c'].map(i => `<div class="test">${i}</div>`).join('') +
-            `<div class="test v-enter v-enter-active">d</div>` +
-            `<div class="test v-enter v-enter-active">e</div>` +
+  it('enter', (done) => {
+    const vm = createBasicVM()
+    vm.items.push('d', 'e')
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          ['a', 'b', 'c'].map((i) => `<div class="test">${i}</div>`).join('') +
+          `<div class="test v-enter v-enter-active">d</div>` +
+          `<div class="test v-enter v-enter-active">e</div>` +
           `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            ['a', 'b', 'c'].map(i => `<div class="test">${i}</div>`).join('') +
+            ['a', 'b', 'c']
+              .map((i) => `<div class="test">${i}</div>`)
+              .join('') +
             `<div class="test v-enter-active v-enter-to">d</div>` +
             `<div class="test v-enter-active v-enter-to">e</div>` +
-          `</span>`
+            `</span>`
         )
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
+            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('leave', done => {
-      const vm = createBasicVM()
-      vm.items = ['b']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave v-leave-active">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test v-leave v-leave-active">c</div>` +
+  it('leave', (done) => {
+    const vm = createBasicVM()
+    vm.items = ['b']
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          `<div class="test v-leave v-leave-active">a</div>` +
+          `<div class="test">b</div>` +
+          `<div class="test v-leave v-leave-active">c</div>` +
           `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
             `<div class="test v-leave-active v-leave-to">a</div>` +
             `<div class="test">b</div>` +
             `<div class="test v-leave-active v-leave-to">c</div>` +
-          `</span>`
+            `</span>`
         )
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
+            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('enter + leave', done => {
-      const vm = createBasicVM()
-      vm.items = ['b', 'c', 'd']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave v-leave-active">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter v-enter-active">d</div>` +
+  it('enter + leave', (done) => {
+    const vm = createBasicVM()
+    vm.items = ['b', 'c', 'd']
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          `<div class="test v-leave v-leave-active">a</div>` +
+          `<div class="test">b</div>` +
+          `<div class="test">c</div>` +
+          `<div class="test v-enter v-enter-active">d</div>` +
           `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
             `<div class="test v-leave-active v-leave-to">a</div>` +
             `<div class="test">b</div>` +
             `<div class="test">c</div>` +
             `<div class="test v-enter-active v-enter-to">d</div>` +
-          `</span>`
+            `</span>`
         )
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
+            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('use with "is" attribute', done => {
-      const vm = createBasicVM(true)
-      vm.items = ['b', 'c', 'd']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test v-leave v-leave-active">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter v-enter-active">d</div>` +
+  it('use with "is" attribute', (done) => {
+    const vm = createBasicVM(true)
+    vm.items = ['b', 'c', 'd']
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          `<div class="test v-leave v-leave-active">a</div>` +
+          `<div class="test">b</div>` +
+          `<div class="test">c</div>` +
+          `<div class="test v-enter v-enter-active">d</div>` +
           `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
             `<div class="test v-leave-active v-leave-to">a</div>` +
             `<div class="test">b</div>` +
             `<div class="test">c</div>` +
             `<div class="test v-enter-active v-enter-to">d</div>` +
-          `</span>`
+            `</span>`
         )
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
+            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('appear', done => {
-      const vm = createBasicVM(false, true /* appear */)
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            vm.items.map(i => `<div class="test v-enter v-enter-active">${i}</div>`).join('') +
+  it('appear', (done) => {
+    const vm = createBasicVM(false, true /* appear */)
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          vm.items
+            .map((i) => `<div class="test v-enter v-enter-active">${i}</div>`)
+            .join('') +
           `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map(i => `<div class="test v-enter-active v-enter-to">${i}</div>`).join('') +
-          `</span>`
+            vm.items
+              .map(
+                (i) => `<div class="test v-enter-active v-enter-to">${i}</div>`
+              )
+              .join('') +
+            `</span>`
         )
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
-          `</span>`
+            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('events', done => {
-      let next
-      const beforeEnterSpy = vi.fn()
-      const afterEnterSpy = vi.fn()
-      const afterLeaveSpy = vi.fn()
-      const vm = new Vue({
-        template: `
+  it('events', (done) => {
+    let next
+    const beforeEnterSpy = vi.fn()
+    const afterEnterSpy = vi.fn()
+    const afterLeaveSpy = vi.fn()
+    const vm = new Vue({
+      template: `
           <div>
             <transition-group @before-enter="beforeEnter" @after-enter="afterEnter" @after-leave="afterLeave">
               <div v-for="item in items" :key="item" class="test">{{ item }}</div>
             </transition-group>
           </div>
         `,
-        data: {
-          items: ['a', 'b', 'c']
+      data: {
+        items: ['a', 'b', 'c']
+      },
+      methods: {
+        beforeEnter(el) {
+          expect(el.textContent).toBe('d')
+          beforeEnterSpy()
         },
-        methods: {
-          beforeEnter (el) {
-            expect(el.textContent).toBe('d')
-            beforeEnterSpy()
-          },
-          afterEnter (el) {
-            expect(el.textContent).toBe('d')
-            afterEnterSpy()
-            next()
-          },
-          afterLeave (el) {
-            expect(el.textContent).toBe('a')
-            afterLeaveSpy()
-            next()
-          }
+        afterEnter(el) {
+          expect(el.textContent).toBe('d')
+          afterEnterSpy()
+          next()
+        },
+        afterLeave(el) {
+          expect(el.textContent).toBe('a')
+          afterLeaveSpy()
+          next()
         }
-      }).$mount(el)
+      }
+    }).$mount(el)
 
-      vm.items.push('d')
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          `<span>` +
-            `<div class="test">a</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test">c</div>` +
-            `<div class="test v-enter v-enter-active">d</div>` +
+    vm.items.push('d')
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        `<span>` +
+          `<div class="test">a</div>` +
+          `<div class="test">b</div>` +
+          `<div class="test">c</div>` +
+          `<div class="test v-enter v-enter-active">d</div>` +
           `</span>`
-        )
-        expect(beforeEnterSpy.mock.calls.length).toBe(1)
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      )
+      expect(beforeEnterSpy.mock.calls.length).toBe(1)
+    })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
             `<div class="test">a</div>` +
             `<div class="test">b</div>` +
             `<div class="test">c</div>` +
             `<div class="test">d</div>` +
-          `</span>`
+            `</span>`
         )
         expect(afterEnterSpy.mock.calls.length).toBe(1)
         vm.items.shift()
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
             `<div class="test">b</div>` +
             `<div class="test">c</div>` +
             `<div class="test">d</div>` +
-          `</span>`
+            `</span>`
         )
         expect(afterLeaveSpy.mock.calls.length).toBe(1)
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('move', done => {
-      const vm = new Vue({
-        template: `
+  it('move', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition-group name="group">
               <div v-for="item in items" :key="item" class="test">{{ item }}</div>
             </transition-group>
           </div>
         `,
-        data: {
-          items: ['a', 'b', 'c']
-        }
-      }).$mount(el)
+      data: {
+        items: ['a', 'b', 'c']
+      }
+    }).$mount(el)
 
-      vm.items = ['d', 'b', 'a']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div class="test group-enter group-enter-active">d</div>` +
-            `<div class="test">b</div>` +
-            `<div class="test group-move">a</div>` +
-            `<div class="test group-leave group-leave-active group-move">c</div>` +
+    vm.items = ['d', 'b', 'a']
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
+        `<span>` +
+          `<div class="test group-enter group-enter-active">d</div>` +
+          `<div class="test">b</div>` +
+          `<div class="test group-move">a</div>` +
+          `<div class="test group-leave group-leave-active group-move">c</div>` +
           `</span>`
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
           `<span>` +
             `<div class="test group-enter-active group-enter-to">d</div>` +
             `<div class="test">b</div>` +
             `<div class="test group-move">a</div>` +
             `<div class="test group-leave-active group-move group-leave-to">c</div>` +
-          `</span>`
+            `</span>`
         )
-      }).thenWaitFor(duration * 2).then(() => {
+      })
+      .thenWaitFor(duration * 2)
+      .then(() => {
         expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
           `<span>` +
             `<div class="test">d</div>` +
             `<div class="test">b</div>` +
             `<div class="test">a</div>` +
-          `</span>`
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('warn unkeyed children', () => {
-      new Vue({
-        template: `<div><transition-group><div v-for="i in 3"></div></transition-group></div>`
-      }).$mount()
-      expect('<transition-group> children must be keyed: <div>').toHaveBeenWarned()
-    })
+  it('warn unkeyed children', () => {
+    new Vue({
+      template: `<div><transition-group><div v-for="i in 3"></div></transition-group></div>`
+    }).$mount()
+    expect(
+      '<transition-group> children must be keyed: <div>'
+    ).toHaveBeenWarned()
+  })
 
-    // GitHub issue #6006
-    it('should work with dynamic name', done => {
-      const vm = new Vue({
-        template: `
+  // GitHub issue #6006
+  it('should work with dynamic name', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition-group :name="name">
               <div v-for="item in items" :key="item">{{ item }}</div>
             </transition-group>
           </div>
         `,
-        data: {
-          items: ['a', 'b', 'c'],
-          name: 'group'
-        }
-      }).$mount(el)
+      data: {
+        items: ['a', 'b', 'c'],
+        name: 'group'
+      }
+    }).$mount(el)
 
-      vm.name = 'invalid-name'
-      vm.items = ['b', 'c', 'a']
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
-          `<span>` +
-            `<div>b</div>` +
-            `<div>c</div>` +
-            `<div>a</div>` +
-          `</span>`
-        )
-        vm.name = 'group'
-        vm.items = ['a', 'b', 'c']
-      }).thenWaitFor(nextFrame).then(() => {
+    vm.name = 'invalid-name'
+    vm.items = ['b', 'c', 'a']
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
+        `<span>` + `<div>b</div>` + `<div>c</div>` + `<div>a</div>` + `</span>`
+      )
+      vm.name = 'group'
+      vm.items = ['a', 'b', 'c']
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
           `<span>` +
             `<div class="group-move">a</div>` +
             `<div class="group-move">b</div>` +
             `<div class="group-move">c</div>` +
-          `</span>`
+            `</span>`
         )
-      }).thenWaitFor(duration * 2 + buffer).then(() => {
+      })
+      .thenWaitFor(duration * 2 + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML.replace(/\s?style=""(\s?)/g, '$1')).toBe(
           `<span>` +
             `<div>a</div>` +
             `<div>b</div>` +
             `<div>c</div>` +
-          `</span>`
+            `</span>`
         )
-      }).then(done)
-    })
+      })
+      .then(done)
   })
-}
+})
diff --git a/test/unit/features/transition/transition-mode.spec.ts b/test/unit/features/transition/transition-mode.spec.ts
index a67efe9ed96..1e92911b924 100644
--- a/test/unit/features/transition/transition-mode.spec.ts
+++ b/test/unit/features/transition/transition-mode.spec.ts
@@ -1,386 +1,453 @@
 import Vue from 'vue'
 import injectStyles from './inject-styles'
-import { isIE9 } from 'core/util/env'
 import { nextFrame } from 'web/runtime/transition-util'
 
-if (!isIE9) {
-  describe('Transition mode', () => {
-    const { duration, buffer } = injectStyles()
-    const components = {
-      one: { template: '<div>one</div>' },
-      two: { template: '<div>two</div>' }
-    }
+describe.skip('Transition mode', () => {
+  const { duration, buffer } = injectStyles()
+  const components = {
+    one: { template: '<div>one</div>' },
+    two: { template: '<div>two</div>' }
+  }
 
-    let el
-    beforeEach(() => {
-      el = document.createElement('div')
-      document.body.appendChild(el)
-    })
+  let el
+  beforeEach(() => {
+    el = document.createElement('div')
+    document.body.appendChild(el)
+  })
 
-    it('dynamic components, simultaneous', done => {
-      const vm = new Vue({
-        template: `<div>
+  it('dynamic components, simultaneous', (done) => {
+    const vm = new Vue({
+      template: `<div>
           <transition>
             <component :is="view" class="test">
             </component>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">one</div>' +
+      data: { view: 'one' },
+      components
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test v-leave v-leave-active">one</div>' +
           '<div class="test v-enter v-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test v-leave-active v-leave-to">one</div>' +
-          '<div class="test v-enter-active v-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+            '<div class="test v-enter-active v-enter-to">two</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    it('dynamic components, out-in', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('dynamic components, out-in', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="out-in" @after-leave="afterLeave">
             <component :is="view" class="test">
             </component>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterLeave() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test test-leave test-leave-active">one</div><!---->'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-enter test-enter-active">two</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-enter-active test-enter-to">two</div>'
         )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    // #3440
-    it('dynamic components, out-in (with extra re-render)', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  // #3440
+  it('dynamic components, out-in (with extra re-render)', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="out-in" @after-leave="afterLeave">
             <component :is="view" class="test">
             </component>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterLeave() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test test-leave test-leave-active">one</div><!---->'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
         // Force re-render before the element finishes leaving
         // this should not cause the incoming element to enter early
         vm.$forceUpdate()
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-enter test-enter-active">two</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-enter-active test-enter-to">two</div>'
         )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    it('dynamic components, in-out', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('dynamic components, in-out', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="in-out" @after-enter="afterEnter">
             <component :is="view" class="test">
             </component>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterEnter() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
+            '<div class="test test-enter-active test-enter-to">two</div>'
         )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test">two</div>'
+          '<div class="test">one</div>' + '<div class="test">two</div>'
         )
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">one</div>' +
-          '<div class="test">two</div>'
+            '<div class="test">two</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave-active test-leave-to">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+            '<div class="test">two</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    it('dynamic components, in-out with early cancel', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('dynamic components, in-out with early cancel', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="in-out" @after-enter="afterEnter">
             <component :is="view" class="test"></component>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterEnter() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
+            '<div class="test test-enter-active test-enter-to">two</div>'
         )
         // switch again before enter finishes,
         // this cancels both enter and leave.
         vm.view = 'one'
-      }).then(() => {
+      })
+      .then(() => {
         // 1. the pending leaving "one" should be removed instantly.
         // 2. the entering "two" should be placed into its final state instantly.
         // 3. a new "one" is created and entering
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">two</div>' +
-          '<div class="test test-enter test-enter-active">one</div>'
+            '<div class="test test-enter test-enter-active">one</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">two</div>' +
-          '<div class="test test-enter-active test-enter-to">one</div>'
+            '<div class="test test-enter-active test-enter-to">one</div>'
         )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>' +
-          '<div class="test">one</div>'
+          '<div class="test">two</div>' + '<div class="test">one</div>'
         )
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">two</div>' +
-          '<div class="test">one</div>'
+            '<div class="test">one</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave-active test-leave-to">two</div>' +
-          '<div class="test">one</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>'
-        )
-      }).then(done)
-    })
+            '<div class="test">one</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+      })
+      .then(done)
+  })
 
-    it('normal elements with different keys, simultaneous', done => {
-      const vm = new Vue({
-        template: `<div>
+  it('normal elements with different keys, simultaneous', (done) => {
+    const vm = new Vue({
+      template: `<div>
           <transition>
             <div :key="view" class="test">{{view}}</div>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">one</div>' +
+      data: { view: 'one' },
+      components
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test v-leave v-leave-active">one</div>' +
           '<div class="test v-enter v-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test v-leave-active v-leave-to">one</div>' +
-          '<div class="test v-enter-active v-enter-to">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+            '<div class="test v-enter-active v-enter-to">two</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    it('normal elements with different keys, out-in', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('normal elements with different keys, out-in', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="out-in" @after-leave="afterLeave">
             <div :key="view" class="test">{{view}}</div>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterLeave () {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterLeave() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test test-leave test-leave-active">one</div><!---->'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-enter test-enter-active">two</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-enter-active test-enter-to">two</div>'
         )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    it('normal elements with different keys, in-out', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('normal elements with different keys, in-out', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="in-out" @after-enter="afterEnter">
             <div :key="view" class="test">{{view}}</div>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter () {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterEnter() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test">one</div>' +
           '<div class="test test-enter test-enter-active">two</div>'
-        )
-      }).thenWaitFor(nextFrame).then(() => {
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
-          '<div class="test test-enter-active test-enter-to">two</div>'
+            '<div class="test test-enter-active test-enter-to">two</div>'
         )
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
-          '<div class="test">one</div>' +
-          '<div class="test">two</div>'
+          '<div class="test">one</div>' + '<div class="test">two</div>'
         )
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave test-leave-active">one</div>' +
-          '<div class="test">two</div>'
+            '<div class="test">two</div>'
         )
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test test-leave-active test-leave-to">one</div>' +
-          '<div class="test">two</div>'
-        )
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.innerHTML).toBe(
-          '<div class="test">two</div>'
-        )
-      }).then(done)
-    })
+            '<div class="test">two</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+      })
+      .then(done)
+  })
 
-    it('transition out-in on async component (resolve before leave complete)', done => {
-      const vm = new Vue({
-        template: `
+  it('transition out-in on async component (resolve before leave complete)', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test-anim" mode="out-in">
               <component-a v-if="ok"></component-a>
@@ -388,62 +455,77 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        components: {
-          componentA: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component A</h1></div>' })
-              next1()
-            }, duration / 2)
-          },
-          componentB: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component B</h1></div>' })
-            }, duration / 2)
-          }
+      components: {
+        componentA: (resolve) => {
+          setTimeout(() => {
+            resolve({ template: '<div><h1>component A</h1></div>' })
+            next1()
+          }, duration / 2)
         },
-        data: {
-          ok: true
+        componentB: (resolve) => {
+          setTimeout(() => {
+            resolve({ template: '<div><h1>component B</h1></div>' })
+          }, duration / 2)
         }
-      }).$mount(el)
+      },
+      data: {
+        ok: true
+      }
+    }).$mount(el)
 
-      expect(vm.$el.innerHTML).toBe('<!---->')
+    expect(vm.$el.innerHTML).toBe('<!---->')
 
-      function next1 () {
-        Vue.nextTick(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component A')
-          expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-          nextFrame(() => {
-            expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-            setTimeout(() => {
-              expect(vm.$el.children[0].className).toBe('')
-              vm.ok = false
-              next2()
-            }, duration + buffer)
-          })
+    function next1() {
+      Vue.nextTick(() => {
+        expect(vm.$el.children.length).toBe(1)
+        expect(vm.$el.textContent).toBe('component A')
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-enter test-anim-enter-active'
+        )
+        nextFrame(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test-anim-enter-active test-anim-enter-to'
+          )
+          setTimeout(() => {
+            expect(vm.$el.children[0].className).toBe('')
+            vm.ok = false
+            next2()
+          }, duration + buffer)
         })
-      }
+      })
+    }
 
-      function next2 () {
-        waitForUpdate(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component A')
-          expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
-        }).thenWaitFor(duration + buffer).then(() => {
+    function next2() {
+      waitForUpdate(() => {
+        expect(vm.$el.children.length).toBe(1)
+        expect(vm.$el.textContent).toBe('component A')
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-leave test-anim-leave-active'
+        )
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test-anim-leave-active test-anim-leave-to'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(1)
           expect(vm.$el.textContent).toBe('component B')
           expect(vm.$el.children[0].className).toMatch('test-anim-enter-active')
-        }).thenWaitFor(duration * 2).then(() => {
+        })
+        .thenWaitFor(duration * 2)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('')
-        }).then(done)
-      }
-    })
+        })
+        .then(done)
+    }
+  })
 
-    it('transition out-in on async component (resolve after leave complete)', done => {
-      const vm = new Vue({
-        template: `
+  it('transition out-in on async component (resolve after leave complete)', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test-anim" mode="out-in">
               <component-a v-if="ok"></component-a>
@@ -451,50 +533,71 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        components: {
-          componentA: { template: '<div><h1>component A</h1></div>' },
-          componentB: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component B</h1></div>' })
-              Vue.nextTick(next)
-            }, (duration + buffer) * 1.7)
-          }
-        },
-        data: {
-          ok: true
+      components: {
+        componentA: { template: '<div><h1>component A</h1></div>' },
+        componentB: (resolve) => {
+          setTimeout(() => {
+            resolve({ template: '<div><h1>component B</h1></div>' })
+            Vue.nextTick(next)
+          }, (duration + buffer) * 1.7)
         }
-      }).$mount(el)
+      },
+      data: {
+        ok: true
+      }
+    }).$mount(el)
 
-      expect(vm.$el.innerHTML).toBe('<div><h1>component A</h1></div>')
+    expect(vm.$el.innerHTML).toBe('<div><h1>component A</h1></div>')
 
-      let next
+    let next
 
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children.length).toBe(1)
-        expect(vm.$el.textContent).toBe('component A')
-        expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children.length).toBe(1)
+      expect(vm.$el.textContent).toBe('component A')
+      expect(vm.$el.children[0].className).toBe(
+        'test-anim-leave test-anim-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-leave-active test-anim-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         expect(vm.$el.innerHTML).toBe('<!---->')
-      }).thenWaitFor(_next => { next = _next }).then(() => {
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
         expect(vm.$el.children.length).toBe(1)
         expect(vm.$el.textContent).toBe('component B')
-        expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-enter test-anim-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-enter-active test-anim-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(1)
         expect(vm.$el.textContent).toBe('component B')
         expect(vm.$el.children[0].className).toBe('')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition in-out on async component', done => {
-      const vm = new Vue({
-        template: `
+  it('transition in-out on async component', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test-anim" mode="in-out">
               <component-a v-if="ok"></component-a>
@@ -502,68 +605,82 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        components: {
-          componentA: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component A</h1></div>' })
-              next1()
-            }, duration / 2)
-          },
-          componentB: resolve => {
-            setTimeout(() => {
-              resolve({ template: '<div><h1>component B</h1></div>' })
-              next2()
-            }, duration / 2)
-          }
+      components: {
+        componentA: (resolve) => {
+          setTimeout(() => {
+            resolve({ template: '<div><h1>component A</h1></div>' })
+            next1()
+          }, duration / 2)
         },
-        data: {
-          ok: true
+        componentB: (resolve) => {
+          setTimeout(() => {
+            resolve({ template: '<div><h1>component B</h1></div>' })
+            next2()
+          }, duration / 2)
         }
-      }).$mount(el)
+      },
+      data: {
+        ok: true
+      }
+    }).$mount(el)
 
-      expect(vm.$el.innerHTML).toBe('<!---->')
+    expect(vm.$el.innerHTML).toBe('<!---->')
 
-      function next1 () {
-        Vue.nextTick(() => {
-          expect(vm.$el.children.length).toBe(1)
-          expect(vm.$el.textContent).toBe('component A')
-          expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-          nextFrame(() => {
-            expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-            setTimeout(() => {
-              expect(vm.$el.children[0].className).toBe('')
-              vm.ok = false
-            }, duration + buffer)
-          })
+    function next1() {
+      Vue.nextTick(() => {
+        expect(vm.$el.children.length).toBe(1)
+        expect(vm.$el.textContent).toBe('component A')
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-enter test-anim-enter-active'
+        )
+        nextFrame(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test-anim-enter-active test-anim-enter-to'
+          )
+          setTimeout(() => {
+            expect(vm.$el.children[0].className).toBe('')
+            vm.ok = false
+          }, duration + buffer)
         })
-      }
+      })
+    }
 
-      function next2 () {
-        waitForUpdate(() => {
-          expect(vm.$el.children.length).toBe(2)
-          expect(vm.$el.textContent).toBe('component Acomponent B')
-          expect(vm.$el.children[0].className).toBe('')
-          expect(vm.$el.children[1].className).toBe('test-anim-enter test-anim-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[1].className).toBe('test-anim-enter-active test-anim-enter-to')
-        }).thenWaitFor(duration + buffer).then(() => {
+    function next2() {
+      waitForUpdate(() => {
+        expect(vm.$el.children.length).toBe(2)
+        expect(vm.$el.textContent).toBe('component Acomponent B')
+        expect(vm.$el.children[0].className).toBe('')
+        expect(vm.$el.children[1].className).toBe(
+          'test-anim-enter test-anim-enter-active'
+        )
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[1].className).toBe(
+            'test-anim-enter-active test-anim-enter-to'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(2)
           expect(vm.$el.textContent).toBe('component Acomponent B')
           expect(vm.$el.children[0].className).toMatch('test-anim-leave-active')
           expect(vm.$el.children[1].className).toBe('')
-        }).thenWaitFor(duration + buffer).then(() => {
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(1)
           expect(vm.$el.textContent).toBe('component B')
           expect(vm.$el.children[0].className).toBe('')
-        }).then(done)
-      }
-    })
+        })
+        .then(done)
+    }
+  })
 
-    it('warn invalid mode', () => {
-      new Vue({
-        template: '<transition mode="foo"><div>123</div></transition>'
-      }).$mount()
-      expect('invalid <transition> mode: foo').toHaveBeenWarned()
-    })
+  it('warn invalid mode', () => {
+    new Vue({
+      template: '<transition mode="foo"><div>123</div></transition>'
+    }).$mount()
+    expect('invalid <transition> mode: foo').toHaveBeenWarned()
   })
-}
+})
diff --git a/test/unit/features/transition/transition-with-keep-alive.spec.ts b/test/unit/features/transition/transition-with-keep-alive.spec.ts
index 0b7a5c01693..92caaaf122c 100644
--- a/test/unit/features/transition/transition-with-keep-alive.spec.ts
+++ b/test/unit/features/transition/transition-with-keep-alive.spec.ts
@@ -1,658 +1,655 @@
 import Vue from 'vue'
-import injectStyles from '../transition/inject-styles'
-import { isIE9 } from 'core/util/env'
+import injectStyles from './inject-styles'
 import { nextFrame } from 'web/runtime/transition-util'
 
-if (!isIE9) {
-  describe('Transition w/ KeepAlive', () => {
-    const { duration, buffer } = injectStyles()
+describe.skip('Transition w/ KeepAlive', () => {
+  const { duration, buffer } = injectStyles()
 
-    let components, one, two, el
-    beforeEach(() => {
-      one = {
-        template: '<div>one</div>',
-        created: vi.fn(),
-        mounted: vi.fn(),
-        activated: vi.fn(),
-        deactivated: vi.fn(),
-        destroyed: vi.fn()
-      }
-      two = {
-        template: '<div>two</div>',
-        created: vi.fn(),
-        mounted: vi.fn(),
-        activated: vi.fn(),
-        deactivated: vi.fn(),
-        destroyed: vi.fn()
-      }
-      components = {
-        one,
-        two
-      }
-      el = document.createElement('div')
-      document.body.appendChild(el)
-    })
-
-    function assertHookCalls(component, callCounts) {
-      expect([
-        component.created.mock.calls.length,
-        component.mounted.mock.calls.length,
-        component.activated.mock.calls.length,
-        component.deactivated.mock.calls.length,
-        component.destroyed.mock.calls.length
-      ]).toEqual(callCounts)
+  let components, one, two, el
+  beforeEach(() => {
+    one = {
+      template: '<div>one</div>',
+      created: vi.fn(),
+      mounted: vi.fn(),
+      activated: vi.fn(),
+      deactivated: vi.fn(),
+      destroyed: vi.fn()
+    }
+    two = {
+      template: '<div>two</div>',
+      created: vi.fn(),
+      mounted: vi.fn(),
+      activated: vi.fn(),
+      deactivated: vi.fn(),
+      destroyed: vi.fn()
     }
+    components = {
+      one,
+      two
+    }
+    el = document.createElement('div')
+    document.body.appendChild(el)
+  })
 
-    it('with transition-mode out-in', (done) => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  function assertHookCalls(component, callCounts) {
+    expect([
+      component.created.mock.calls.length,
+      component.mounted.mock.calls.length,
+      component.activated.mock.calls.length,
+      component.deactivated.mock.calls.length,
+      component.destroyed.mock.calls.length
+    ]).toEqual(callCounts)
+  }
+
+  it('with transition-mode out-in', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="out-in" @after-leave="afterLeave">
             <keep-alive>
               <component :is="view" class="test"></component>
             </keep-alive>
           </transition>
         </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterLeave() {
-            next()
-          }
+      data: {
+        view: 'one'
+      },
+      components,
+      methods: {
+        afterLeave() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    assertHookCalls(one, [1, 1, 1, 0, 0])
+    assertHookCalls(two, [0, 0, 0, 0, 0])
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test test-leave test-leave-active">one</div><!---->'
+      )
+      assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
+          '<div class="test test-leave-active test-leave-to">one</div><!---->'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter test-enter-active">two</div>'
         )
         assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
+        assertHookCalls(two, [1, 1, 1, 0, 0])
       })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">one</div><!---->'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<!---->')
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">two</div>'
-          )
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 0, 0])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">two</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 0, 0])
-        })
-        .then(() => {
-          vm.view = 'one'
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave test-leave-active">two</div><!---->'
-          )
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 1, 0])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">two</div><!---->'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<!---->')
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">one</div>'
-          )
-          assertHookCalls(one, [1, 1, 2, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 1, 0])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">one</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-          assertHookCalls(one, [1, 1, 2, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 1, 0])
-        })
-        .then(done)
-    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter-active test-enter-to">two</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 0, 0])
+      })
+      .then(() => {
+        vm.view = 'one'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">two</div><!---->'
+        )
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">two</div><!---->'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter test-enter-active">one</div>'
+        )
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter-active test-enter-to">one</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+      })
+      .then(done)
+  })
 
-    it('with transition-mode out-in + include', (done) => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('with transition-mode out-in + include', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="out-in" @after-leave="afterLeave">
             <keep-alive include="one">
               <component :is="view" class="test"></component>
             </keep-alive>
           </transition>
         </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterLeave() {
-            next()
-          }
+      data: {
+        view: 'one'
+      },
+      components,
+      methods: {
+        afterLeave() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    assertHookCalls(one, [1, 1, 1, 0, 0])
+    assertHookCalls(two, [0, 0, 0, 0, 0])
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test test-leave test-leave-active">one</div><!---->'
+      )
+      assertHookCalls(one, [1, 1, 1, 1, 0])
       assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">one</div><!---->'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
-          '<div class="test test-leave test-leave-active">one</div><!---->'
+          '<div class="test test-enter test-enter-active">two</div>'
         )
         assertHookCalls(one, [1, 1, 1, 1, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
+        assertHookCalls(two, [1, 1, 0, 0, 0])
       })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">one</div><!---->'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<!---->')
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">two</div>'
-          )
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 0, 0, 0])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">two</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 0, 0, 0])
-        })
-        .then(() => {
-          vm.view = 'one'
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave test-leave-active">two</div><!---->'
-          )
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 0, 0, 1])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">two</div><!---->'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<!---->')
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">one</div>'
-          )
-          assertHookCalls(one, [1, 1, 2, 1, 0])
-          assertHookCalls(two, [1, 1, 0, 0, 1])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter-active test-enter-to">one</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-          assertHookCalls(one, [1, 1, 2, 1, 0])
-          assertHookCalls(two, [1, 1, 0, 0, 1])
-        })
-        .then(done)
-    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter-active test-enter-to">two</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [1, 1, 0, 0, 0])
+      })
+      .then(() => {
+        vm.view = 'one'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">two</div><!---->'
+        )
+        assertHookCalls(one, [1, 1, 1, 1, 0])
+        assertHookCalls(two, [1, 1, 0, 0, 1])
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">two</div><!---->'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter test-enter-active">one</div>'
+        )
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 0, 0, 1])
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-enter-active test-enter-to">one</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 0, 0, 1])
+      })
+      .then(done)
+  })
 
-    it('with transition-mode in-out', (done) => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('with transition-mode in-out', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="in-out" @after-enter="afterEnter">
             <keep-alive>
               <component :is="view" class="test"></component>
             </keep-alive>
           </transition>
         </div>`,
-        data: {
-          view: 'one'
-        },
-        components,
-        methods: {
-          afterEnter() {
-            next()
-          }
+      data: {
+        view: 'one'
+      },
+      components,
+      methods: {
+        afterEnter() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      assertHookCalls(one, [1, 1, 1, 0, 0])
-      assertHookCalls(two, [0, 0, 0, 0, 0])
-      vm.view = 'two'
-      waitForUpdate(() => {
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    assertHookCalls(one, [1, 1, 1, 0, 0])
+    assertHookCalls(two, [0, 0, 0, 0, 0])
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test">one</div>' +
+          '<div class="test test-enter test-enter-active">two</div>'
+      )
+      assertHookCalls(one, [1, 1, 1, 1, 0])
+      assertHookCalls(two, [1, 1, 1, 0, 0])
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
-            '<div class="test test-enter test-enter-active">two</div>'
+            '<div class="test test-enter-active test-enter-to">two</div>'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">one</div>' + '<div class="test">two</div>'
+        )
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">one</div>' +
+            '<div class="test">two</div>'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">one</div>' +
+            '<div class="test">two</div>'
         )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
         assertHookCalls(one, [1, 1, 1, 1, 0])
         assertHookCalls(two, [1, 1, 1, 0, 0])
       })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">one</div>' +
-              '<div class="test test-enter-active test-enter-to">two</div>'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">one</div>' + '<div class="test">two</div>'
-          )
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave test-leave-active">one</div>' +
-              '<div class="test">two</div>'
-          )
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">one</div>' +
-              '<div class="test">two</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
-          assertHookCalls(one, [1, 1, 1, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 0, 0])
-        })
-        .then(() => {
-          vm.view = 'one'
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">two</div>' +
-              '<div class="test test-enter test-enter-active">one</div>'
-          )
-          assertHookCalls(one, [1, 1, 2, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 1, 0])
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">two</div>' +
-              '<div class="test test-enter-active test-enter-to">one</div>'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">two</div>' + '<div class="test">one</div>'
-          )
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave test-leave-active">two</div>' +
-              '<div class="test">one</div>'
-          )
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">two</div>' +
-              '<div class="test">one</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-          assertHookCalls(one, [1, 1, 2, 1, 0])
-          assertHookCalls(two, [1, 1, 1, 1, 0])
-        })
-        .then(done)
-    })
+      .then(() => {
+        vm.view = 'one'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">two</div>' +
+            '<div class="test test-enter test-enter-active">one</div>'
+        )
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">two</div>' +
+            '<div class="test test-enter-active test-enter-to">one</div>'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">two</div>' + '<div class="test">one</div>'
+        )
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">two</div>' +
+            '<div class="test">one</div>'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">two</div>' +
+            '<div class="test">one</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+        assertHookCalls(one, [1, 1, 2, 1, 0])
+        assertHookCalls(two, [1, 1, 1, 1, 0])
+      })
+      .then(done)
+  })
 
-    it('dynamic components, in-out with early cancel', (done) => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('dynamic components, in-out with early cancel', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" mode="in-out" @after-enter="afterEnter">
             <keep-alive>
               <component :is="view" class="test"></component>
             </keep-alive>
           </transition>
         </div>`,
-        data: { view: 'one' },
-        components,
-        methods: {
-          afterEnter() {
-            next()
-          }
+      data: { view: 'one' },
+      components,
+      methods: {
+        afterEnter() {
+          next()
         }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('one')
-      vm.view = 'two'
-      waitForUpdate(() => {
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('one')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test">one</div>' +
+          '<div class="test test-enter test-enter-active">two</div>'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe(
           '<div class="test">one</div>' +
-            '<div class="test test-enter test-enter-active">two</div>'
+            '<div class="test test-enter-active test-enter-to">two</div>'
         )
+        // switch again before enter finishes,
+        // this cancels both enter and leave.
+        vm.view = 'one'
       })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">one</div>' +
-              '<div class="test test-enter-active test-enter-to">two</div>'
-          )
-          // switch again before enter finishes,
-          // this cancels both enter and leave.
-          vm.view = 'one'
-        })
-        .then(() => {
-          // 1. the pending leaving "one" should be removed instantly.
-          // 2. the entering "two" should be placed into its final state instantly.
-          // 3. a new "one" is created and entering
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">two</div>' +
-              '<div class="test test-enter test-enter-active">one</div>'
-          )
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">two</div>' +
-              '<div class="test test-enter-active test-enter-to">one</div>'
-          )
-        })
-        .thenWaitFor((_next) => {
-          next = _next
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test">two</div>' + '<div class="test">one</div>'
-          )
-        })
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave test-leave-active">two</div>' +
-              '<div class="test">one</div>'
-          )
-        })
-        .thenWaitFor(nextFrame)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">two</div>' +
-              '<div class="test">one</div>'
-          )
-        })
-        .thenWaitFor(duration + buffer)
-        .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-        })
-        .then(done)
-    })
+      .then(() => {
+        // 1. the pending leaving "one" should be removed instantly.
+        // 2. the entering "two" should be placed into its final state instantly.
+        // 3. a new "one" is created and entering
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">two</div>' +
+            '<div class="test test-enter test-enter-active">one</div>'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">two</div>' +
+            '<div class="test test-enter-active test-enter-to">one</div>'
+        )
+      })
+      .thenWaitFor((_next) => {
+        next = _next
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test">two</div>' + '<div class="test">one</div>'
+        )
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">two</div>' +
+            '<div class="test">one</div>'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">two</div>' +
+            '<div class="test">one</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+      })
+      .then(done)
+  })
 
-    // #4339
-    it('component with inner transition', (done) => {
-      const vm = new Vue({
-        template: `
+  // #4339
+  it('component with inner transition', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <keep-alive>
               <component ref="test" :is="view"></component>
             </keep-alive>
           </div>
         `,
-        data: { view: 'foo' },
-        components: {
-          foo: {
-            template: '<transition><div class="test">foo</div></transition>'
-          },
-          bar: {
-            template:
-              '<transition name="test"><div class="test">bar</div></transition>'
-          }
+      data: { view: 'foo' },
+      components: {
+        foo: {
+          template: '<transition><div class="test">foo</div></transition>'
+        },
+        bar: {
+          template:
+            '<transition name="test"><div class="test">bar</div></transition>'
         }
-      }).$mount(el)
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.view = 'bar'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test v-leave v-leave-active">foo</div>' +
+          '<div class="test test-enter test-enter-active">bar</div>'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test v-leave-active v-leave-to">foo</div>' +
+            '<div class="test test-enter-active test-enter-to">bar</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">bar</div>')
+        vm.view = 'foo'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave test-leave-active">bar</div>' +
+            '<div class="test v-enter v-enter-active">foo</div>'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test test-leave-active test-leave-to">bar</div>' +
+            '<div class="test v-enter-active v-enter-to">foo</div>'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+      })
+      .then(done)
+  })
 
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.view = 'bar'
+  it('async components with transition-mode out-in', (done) => {
+    const barResolve = vi.fn()
+    let next
+    const foo = (resolve) => {
+      setTimeout(() => {
+        resolve(one)
+        Vue.nextTick(next)
+      }, duration / 2)
+    }
+    const bar = (resolve) => {
+      setTimeout(() => {
+        resolve(two)
+        barResolve()
+      }, duration / 2)
+    }
+    components = {
+      foo,
+      bar
+    }
+    const vm = new Vue({
+      template: `<div>
+          <transition name="test" mode="out-in" @after-enter="afterEnter" @after-leave="afterLeave">
+            <keep-alive>
+              <component :is="view" class="test"></component>
+            </keep-alive>
+          </transition>
+        </div>`,
+      data: {
+        view: 'foo'
+      },
+      components,
+      methods: {
+        afterEnter() {
+          next()
+        },
+        afterLeave() {
+          next()
+        }
+      }
+    }).$mount(el)
+    expect(vm.$el.textContent).toBe('')
+    next = () => {
+      assertHookCalls(one, [1, 1, 1, 0, 0])
+      assertHookCalls(two, [0, 0, 0, 0, 0])
       waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe(
-          '<div class="test v-leave v-leave-active">foo</div>' +
-            '<div class="test test-enter test-enter-active">bar</div>'
+          '<div class="test test-enter test-enter-active">one</div>'
         )
       })
         .thenWaitFor(nextFrame)
         .then(() => {
           expect(vm.$el.innerHTML).toBe(
-            '<div class="test v-leave-active v-leave-to">foo</div>' +
-              '<div class="test test-enter-active test-enter-to">bar</div>'
+            '<div class="test test-enter-active test-enter-to">one</div>'
           )
         })
-        .thenWaitFor(duration + buffer)
+        .thenWaitFor((_next) => {
+          next = _next
+        })
         .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">bar</div>')
-          vm.view = 'foo'
+          // foo afterEnter get called
+          expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
+          vm.view = 'bar'
         })
+        .thenWaitFor(nextFrame)
         .then(() => {
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [0, 0, 0, 0, 0])
           expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave test-leave-active">bar</div>' +
-              '<div class="test v-enter v-enter-active">foo</div>'
+            '<div class="test test-leave-active test-leave-to">one</div><!---->'
           )
         })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          // foo afterLeave get called
+          // and bar has already been resolved before afterLeave get called
+          expect(barResolve.mock.calls.length).toBe(1)
+          expect(vm.$el.innerHTML).toBe('<!---->')
+        })
         .thenWaitFor(nextFrame)
         .then(() => {
           expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-leave-active test-leave-to">bar</div>' +
-              '<div class="test v-enter-active v-enter-to">foo</div>'
+            '<div class="test test-enter test-enter-active">two</div>'
           )
+          assertHookCalls(one, [1, 1, 1, 1, 0])
+          assertHookCalls(two, [1, 1, 1, 0, 0])
         })
-        .thenWaitFor(duration + buffer)
+        .thenWaitFor(nextFrame)
         .then(() => {
-          expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-        })
-        .then(done)
-    })
-
-    it('async components with transition-mode out-in', (done) => {
-      const barResolve = vi.fn()
-      let next
-      const foo = (resolve) => {
-        setTimeout(() => {
-          resolve(one)
-          Vue.nextTick(next)
-        }, duration / 2)
-      }
-      const bar = (resolve) => {
-        setTimeout(() => {
-          resolve(two)
-          barResolve()
-        }, duration / 2)
-      }
-      components = {
-        foo,
-        bar
-      }
-      const vm = new Vue({
-        template: `<div>
-          <transition name="test" mode="out-in" @after-enter="afterEnter" @after-leave="afterLeave">
-            <keep-alive>
-              <component :is="view" class="test"></component>
-            </keep-alive>
-          </transition>
-        </div>`,
-        data: {
-          view: 'foo'
-        },
-        components,
-        methods: {
-          afterEnter() {
-            next()
-          },
-          afterLeave() {
-            next()
-          }
-        }
-      }).$mount(el)
-      expect(vm.$el.textContent).toBe('')
-      next = () => {
-        assertHookCalls(one, [1, 1, 1, 0, 0])
-        assertHookCalls(two, [0, 0, 0, 0, 0])
-        waitForUpdate(() => {
           expect(vm.$el.innerHTML).toBe(
-            '<div class="test test-enter test-enter-active">one</div>'
+            '<div class="test test-enter-active test-enter-to">two</div>'
           )
         })
-          .thenWaitFor(nextFrame)
-          .then(() => {
-            expect(vm.$el.innerHTML).toBe(
-              '<div class="test test-enter-active test-enter-to">one</div>'
-            )
-          })
-          .thenWaitFor((_next) => {
-            next = _next
-          })
-          .then(() => {
-            // foo afterEnter get called
-            expect(vm.$el.innerHTML).toBe('<div class="test">one</div>')
-            vm.view = 'bar'
-          })
-          .thenWaitFor(nextFrame)
-          .then(() => {
-            assertHookCalls(one, [1, 1, 1, 1, 0])
-            assertHookCalls(two, [0, 0, 0, 0, 0])
-            expect(vm.$el.innerHTML).toBe(
-              '<div class="test test-leave-active test-leave-to">one</div><!---->'
-            )
-          })
-          .thenWaitFor((_next) => {
-            next = _next
-          })
-          .then(() => {
-            // foo afterLeave get called
-            // and bar has already been resolved before afterLeave get called
-            expect(barResolve.mock.calls.length).toBe(1)
-            expect(vm.$el.innerHTML).toBe('<!---->')
-          })
-          .thenWaitFor(nextFrame)
-          .then(() => {
-            expect(vm.$el.innerHTML).toBe(
-              '<div class="test test-enter test-enter-active">two</div>'
-            )
-            assertHookCalls(one, [1, 1, 1, 1, 0])
-            assertHookCalls(two, [1, 1, 1, 0, 0])
-          })
-          .thenWaitFor(nextFrame)
-          .then(() => {
-            expect(vm.$el.innerHTML).toBe(
-              '<div class="test test-enter-active test-enter-to">two</div>'
-            )
-          })
-          .thenWaitFor((_next) => {
-            next = _next
-          })
-          .then(() => {
-            // bar afterEnter get called
-            expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
-          })
-          .then(done)
-      }
-    })
+        .thenWaitFor((_next) => {
+          next = _next
+        })
+        .then(() => {
+          // bar afterEnter get called
+          expect(vm.$el.innerHTML).toBe('<div class="test">two</div>')
+        })
+        .then(done)
+    }
+  })
 
-    // #10083
-    it('should not attach event handler repeatedly', (done) => {
-      const vm = new Vue({
-        template: `
+  // #10083
+  it('should not attach event handler repeatedly', (done) => {
+    const vm = new Vue({
+      template: `
           <keep-alive>
             <btn v-if="showBtn" @click.native="add" />
           </keep-alive>
         `,
-        data: { showBtn: true, n: 0 },
-        methods: {
-          add() {
-            this.n++
-          }
-        },
-        components: {
-          btn: { template: '<button>add 1</button>' }
+      data: { showBtn: true, n: 0 },
+      methods: {
+        add() {
+          this.n++
         }
-      }).$mount()
+      },
+      components: {
+        btn: { template: '<button>add 1</button>' }
+      }
+    }).$mount()
 
-      const btn = vm.$el
-      expect(vm.n).toBe(0)
-      btn.click()
-      expect(vm.n).toBe(1)
-      vm.showBtn = false
-      waitForUpdate(() => {
-        vm.showBtn = true
-      })
-        .then(() => {
-          btn.click()
-          expect(vm.n).toBe(2)
-        })
-        .then(done)
+    const btn = vm.$el
+    expect(vm.n).toBe(0)
+    btn.click()
+    expect(vm.n).toBe(1)
+    vm.showBtn = false
+    waitForUpdate(() => {
+      vm.showBtn = true
     })
+      .then(() => {
+        btn.click()
+        expect(vm.n).toBe(2)
+      })
+      .then(done)
   })
-}
+})
diff --git a/test/unit/features/transition/transition.spec.ts b/test/unit/features/transition/transition.spec.ts
index 8646a2d0985..534e06d1a7e 100644
--- a/test/unit/features/transition/transition.spec.ts
+++ b/test/unit/features/transition/transition.spec.ts
@@ -1,72 +1,107 @@
 import Vue from 'vue'
 import injectStyles from './inject-styles'
-import { isIE9 } from 'core/util/env'
 import { nextFrame } from 'web/runtime/transition-util'
 
-if (!isIE9) {
-  describe('Transition basic', () => {
-    const { duration, buffer } = injectStyles() as { duration: number, buffer: number }
-    const explicitDuration = duration * 2
+describe.skip('Transition basic', () => {
+  const { duration, buffer } = injectStyles() as {
+    duration: number
+    buffer: number
+  }
+  const explicitDuration = duration * 2
+
+  let el
+  beforeEach(() => {
+    el = document.createElement('div')
+    document.body.appendChild(el)
+  })
 
-    let el
-    beforeEach(() => {
-      el = document.createElement('div')
-      document.body.appendChild(el)
+  it('basic transition', (done) => {
+    const vm = new Vue({
+      template:
+        '<div><transition><div v-if="ok" class="test">foo</div></transition></div>',
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
     })
-
-    it('basic transition', done => {
-      const vm = new Vue({
-        template: '<div><transition><div v-if="ok" class="test">foo</div></transition></div>',
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-enter-active v-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
-
-    it('named transition', done => {
-      const vm = new Vue({
-        template: '<div><transition name="test"><div v-if="ok" class="test">foo</div></transition></div>',
-        data: { ok: true }
-      }).$mount(el)
+      })
+      .then(done)
+  })
 
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+  it('named transition', (done) => {
+    const vm = new Vue({
+      template:
+        '<div><transition name="test"><div v-if="ok" class="test">foo</div></transition></div>',
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('custom transition classes', done => {
-      const vm = new Vue({
-        template: `
+  it('custom transition classes', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition
               enter-class="hello"
@@ -79,70 +114,102 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test bye byebye active more')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test byebye active more bye-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe('test bye byebye active more')
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test byebye active more bye-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test hello hello-active')
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test hello-active hello-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('dynamic transition', done => {
-      const vm = new Vue({
-        template: `
+  it('dynamic transition', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition :name="trans">
               <div v-if="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: {
-          ok: true,
-          trans: 'test'
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      data: {
+        ok: true,
+        trans: 'test'
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
         vm.trans = 'changed'
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test changed-enter changed-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test changed-enter-active changed-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test changed-enter changed-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test changed-enter-active changed-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('inline transition object', done => {
-      const enter = vi.fn()
-      const leave = vi.fn()
-      const vm = new Vue({
-        render (h) {
-          return h('div', null, [
-            h('transition', {
+  it('inline transition object', (done) => {
+    const enter = vi.fn()
+    const leave = vi.fn()
+    const vm = new Vue({
+      render(h) {
+        return h('div', null, [
+          h(
+            'transition',
+            {
               props: {
                 name: 'inline',
                 enterClass: 'hello',
@@ -156,43 +223,55 @@ if (!isIE9) {
                 enter,
                 leave
               }
-            }, this.ok ? [h('div', { class: 'test' }, 'foo')] : undefined)
-          ])
-        },
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test bye byebye active')
-        expect(leave).toHaveBeenCalled()
-      }).thenWaitFor(nextFrame).then(() => {
+            },
+            this.ok ? [h('div', { class: 'test' }, 'foo')] : undefined
+          )
+        ])
+      },
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe('test bye byebye active')
+      expect(leave).toHaveBeenCalled()
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test byebye active bye-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test hello hello-active')
         expect(enter).toHaveBeenCalled()
-      }).thenWaitFor(nextFrame).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test hello-active hello-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition events', done => {
-      const onLeaveSpy = vi.fn()
-      const onEnterSpy = vi.fn()
-      const beforeLeaveSpy = vi.fn()
-      const beforeEnterSpy = vi.fn()
-      const afterLeaveSpy = vi.fn()
-      const afterEnterSpy = vi.fn()
+  it('transition events', (done) => {
+    const onLeaveSpy = vi.fn()
+    const onEnterSpy = vi.fn()
+    const beforeLeaveSpy = vi.fn()
+    const beforeEnterSpy = vi.fn()
+    const afterLeaveSpy = vi.fn()
+    const afterEnterSpy = vi.fn()
 
-      const vm = new Vue({
-        template: `
+    const vm = new Vue({
+      template: `
           <div>
             <transition
               name="test"
@@ -206,68 +285,86 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        data: { ok: true },
-        methods: {
-          beforeLeave: (el) => {
-            expect(el).toBe(vm.$el.children[0])
-            expect(el.className).toBe('test')
-            beforeLeaveSpy(el)
-          },
-          leave: (el) => onLeaveSpy(el),
-          afterLeave: (el) => afterLeaveSpy(el),
-          beforeEnter: (el) => {
-            expect(vm.$el.contains(el)).toBe(false)
-            expect(el.className).toBe('test')
-            beforeEnterSpy(el)
-          },
-          enter: (el) => {
-            expect(vm.$el.contains(el)).toBe(true)
-            onEnterSpy(el)
-          },
-          afterEnter: (el) => afterEnterSpy(el)
-        }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-
-      let _el = vm.$el.children[0]
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(onLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
+      data: { ok: true },
+      methods: {
+        beforeLeave: (el) => {
+          expect(el).toBe(vm.$el.children[0])
+          expect(el.className).toBe('test')
+          beforeLeaveSpy(el)
+        },
+        leave: (el) => onLeaveSpy(el),
+        afterLeave: (el) => afterLeaveSpy(el),
+        beforeEnter: (el) => {
+          expect(vm.$el.contains(el)).toBe(false)
+          expect(el.className).toBe('test')
+          beforeEnterSpy(el)
+        },
+        enter: (el) => {
+          expect(vm.$el.contains(el)).toBe(true)
+          onEnterSpy(el)
+        },
+        afterEnter: (el) => afterEnterSpy(el)
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+
+    let _el = vm.$el.children[0]
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
+      expect(onLeaveSpy).toHaveBeenCalledWith(_el)
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(afterLeaveSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(afterLeaveSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         _el = vm.$el.children[0]
         expect(beforeEnterSpy).toHaveBeenCalledWith(_el)
         expect(onEnterSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(afterEnterSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(afterEnterSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition events (v-show)', done => {
-      const onLeaveSpy = vi.fn()
-      const onEnterSpy = vi.fn()
-      const beforeLeaveSpy = vi.fn()
-      const beforeEnterSpy = vi.fn()
-      const afterLeaveSpy = vi.fn()
-      const afterEnterSpy = vi.fn()
+  it('transition events (v-show)', (done) => {
+    const onLeaveSpy = vi.fn()
+    const onEnterSpy = vi.fn()
+    const beforeLeaveSpy = vi.fn()
+    const beforeEnterSpy = vi.fn()
+    const afterLeaveSpy = vi.fn()
+    const afterEnterSpy = vi.fn()
 
-      const vm = new Vue({
-        template: `
+    const vm = new Vue({
+      template: `
           <div>
             <transition
               name="test"
@@ -281,451 +378,649 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        data: { ok: true },
-        methods: {
-          beforeLeave: (el) => {
-            expect(el.style.display).toBe('')
-            expect(el).toBe(vm.$el.children[0])
-            expect(el.className).toBe('test')
-            beforeLeaveSpy(el)
-          },
-          leave: (el) => {
-            expect(el.style.display).toBe('')
-            onLeaveSpy(el)
-          },
-          afterLeave: (el) => {
-            expect(el.style.display).toBe('none')
-            afterLeaveSpy(el)
-          },
-          beforeEnter: (el) => {
-            expect(el.className).toBe('test')
-            expect(el.style.display).toBe('none')
-            beforeEnterSpy(el)
-          },
-          enter: (el) => {
-            expect(el.style.display).toBe('')
-            onEnterSpy(el)
-          },
-          afterEnter: (el) => {
-            expect(el.style.display).toBe('')
-            afterEnterSpy(el)
-          }
+      data: { ok: true },
+      methods: {
+        beforeLeave: (el) => {
+          expect(el.style.display).toBe('')
+          expect(el).toBe(vm.$el.children[0])
+          expect(el.className).toBe('test')
+          beforeLeaveSpy(el)
+        },
+        leave: (el) => {
+          expect(el.style.display).toBe('')
+          onLeaveSpy(el)
+        },
+        afterLeave: (el) => {
+          expect(el.style.display).toBe('none')
+          afterLeaveSpy(el)
+        },
+        beforeEnter: (el) => {
+          expect(el.className).toBe('test')
+          expect(el.style.display).toBe('none')
+          beforeEnterSpy(el)
+        },
+        enter: (el) => {
+          expect(el.style.display).toBe('')
+          onEnterSpy(el)
+        },
+        afterEnter: (el) => {
+          expect(el.style.display).toBe('')
+          afterEnterSpy(el)
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-
-      let _el = vm.$el.children[0]
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(onLeaveSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+
+    let _el = vm.$el.children[0]
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(beforeLeaveSpy).toHaveBeenCalledWith(_el)
+      expect(onLeaveSpy).toHaveBeenCalledWith(_el)
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(afterLeaveSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(afterLeaveSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].style.display).toBe('none')
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         _el = vm.$el.children[0]
         expect(beforeEnterSpy).toHaveBeenCalledWith(_el)
         expect(onEnterSpy).toHaveBeenCalledWith(_el)
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(afterEnterSpy).not.toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(afterEnterSpy).toHaveBeenCalledWith(_el)
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('explicit user callback in JavaScript hooks', done => {
-      let next
-      const vm = new Vue({
-        template: `<div>
+  it('explicit user callback in JavaScript hooks', (done) => {
+    let next
+    const vm = new Vue({
+      template: `<div>
           <transition name="test" @enter="enter" @leave="leave">
             <div v-if="ok" class="test">foo</div>
           </transition>
         </div>`,
-        data: { ok: true },
-        methods: {
-          enter: (el, cb) => {
-            next = cb
-          },
-          leave: (el, cb) => {
-            next = cb
-          }
+      data: { ok: true },
+      methods: {
+        enter: (el, cb) => {
+          next = cb
+        },
+        leave: (el, cb) => {
+          next = cb
         }
-      }).$mount(el)
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
+      }
+    }).$mount(el)
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
         expect(next).toBeTruthy()
         next()
         expect(vm.$el.children.length).toBe(0)
-      }).then(() => {
+      })
+      .then(() => {
         vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
+      })
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
         expect(next).toBeTruthy()
         next()
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('css: false', done => {
-      const enterSpy = vi.fn()
-      const leaveSpy = vi.fn()
-      const vm = new Vue({
-        template: `
+  it('css: false', (done) => {
+    const enterSpy = vi.fn()
+    const leaveSpy = vi.fn()
+    const vm = new Vue({
+      template: `
           <div>
             <transition :css="false" name="test" @enter="enter" @leave="leave">
               <div v-if="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true },
-        methods: {
-          enter: enterSpy,
-          leave: leaveSpy
-        }
-      }).$mount(el)
-
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(leaveSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<!---->')
-        vm.ok = true
-      }).then(() => {
+      data: { ok: true },
+      methods: {
+        enter: enterSpy,
+        leave: leaveSpy
+      }
+    }).$mount(el)
+
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(leaveSpy).toHaveBeenCalled()
+      expect(vm.$el.innerHTML).toBe('<!---->')
+      vm.ok = true
+    })
+      .then(() => {
         expect(enterSpy).toHaveBeenCalled()
         expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      }).then(done)
-    })
-
-    it('no transition detected', done => {
-      const enterSpy = vi.fn()
-      const leaveSpy = vi.fn()
-      const vm = new Vue({
-        template: '<div><transition name="nope" @enter="enter" @leave="leave"><div v-if="ok">foo</div></transition></div>',
-        data: { ok: true },
-        methods: {
-          enter: enterSpy,
-          leave: leaveSpy
-        }
-      }).$mount(el)
+      })
+      .then(done)
+  })
 
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(leaveSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<div class="nope-leave nope-leave-active">foo</div><!---->')
-      }).thenWaitFor(nextFrame).then(() => {
+  it('no transition detected', (done) => {
+    const enterSpy = vi.fn()
+    const leaveSpy = vi.fn()
+    const vm = new Vue({
+      template:
+        '<div><transition name="nope" @enter="enter" @leave="leave"><div v-if="ok">foo</div></transition></div>',
+      data: { ok: true },
+      methods: {
+        enter: enterSpy,
+        leave: leaveSpy
+      }
+    }).$mount(el)
+
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(leaveSpy).toHaveBeenCalled()
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="nope-leave nope-leave-active">foo</div><!---->'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<!---->')
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(enterSpy).toHaveBeenCalled()
-        expect(vm.$el.innerHTML).toBe('<div class="nope-enter nope-enter-active">foo</div>')
-      }).thenWaitFor(nextFrame).then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="nope-enter nope-enter-active">foo</div>'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<div>foo</div>')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('enterCancelled', done => {
-      const spy = vi.fn()
-      const vm = new Vue({
-        template: `
+  it('enterCancelled', (done) => {
+    const spy = vi.fn()
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test" @enter-cancelled="enterCancelled">
               <div v-if="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: false },
-        methods: {
-          enterCancelled: spy
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.ok = true
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration / 2).then(() => {
+      data: { ok: false },
+      methods: {
+        enterCancelled: spy
+      }
+    }).$mount(el)
+
+    expect(vm.$el.innerHTML).toBe('<!---->')
+    vm.ok = true
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-enter test-enter-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration / 2)
+      .then(() => {
         vm.ok = false
-      }).then(() => {
+      })
+      .then(() => {
         expect(spy).toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave test-leave-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('should remove stale leaving elements', done => {
-      const spy = vi.fn()
-      const vm = new Vue({
-        template: `
+  it('should remove stale leaving elements', (done) => {
+    const spy = vi.fn()
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test" @after-leave="afterLeave">
               <div v-if="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true },
-        methods: {
-          afterLeave: spy
-        }
-      }).$mount(el)
-
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(duration / 2).then(() => {
+      data: { ok: true },
+      methods: {
+        afterLeave: spy
+      }
+    }).$mount(el)
+
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(duration / 2)
+      .then(() => {
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(spy).toHaveBeenCalled()
         expect(vm.$el.children.length).toBe(1) // should have removed leaving element
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition with v-show', done => {
-      const vm = new Vue({
-        template: `
+  it('transition with v-show', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test">
               <div v-show="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.textContent).toBe('foo')
-      expect(vm.$el.children[0].style.display).toBe('')
-      expect(vm.$el.children[0].className).toBe('test')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.textContent).toBe('foo')
+    expect(vm.$el.children[0].style.display).toBe('')
+    expect(vm.$el.children[0].className).toBe('test')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].style.display).toBe('none')
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].style.display).toBe('')
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition with v-show, inside child component', done => {
-      const vm = new Vue({
-        template: `
+  it('transition with v-show, inside child component', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <test v-show="ok"></test>
           </div>
         `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `<transition name="test"><div class="test">foo</div></transition>`
-          }
+      data: { ok: true },
+      components: {
+        test: {
+          template: `<transition name="test"><div class="test">foo</div></transition>`
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.textContent).toBe('foo')
-      expect(vm.$el.children[0].style.display).toBe('')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.textContent).toBe('foo')
+    expect(vm.$el.children[0].style.display).toBe('')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].style.display).toBe('none')
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].style.display).toBe('')
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('leaveCancelled (v-show only)', done => {
-      const spy = vi.fn()
-      const vm = new Vue({
-        template: `
+  it('leaveCancelled (v-show only)', (done) => {
+    const spy = vi.fn()
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test" @leave-cancelled="leaveCancelled">
               <div v-show="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true },
-        methods: {
-          leaveCancelled: spy
-        }
-      }).$mount(el)
-
-      expect(vm.$el.children[0].style.display).toBe('')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(10).then(() => {
+      data: { ok: true },
+      methods: {
+        leaveCancelled: spy
+      }
+    }).$mount(el)
+
+    expect(vm.$el.children[0].style.display).toBe('')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(10)
+      .then(() => {
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(spy).toHaveBeenCalled()
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].style.display).toBe('')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('leave transition with v-show: cancelled on next frame', done => {
-      const vm = new Vue({
-        template: `
+  it('leave transition with v-show: cancelled on next frame', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test">
               <div v-show="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
+      data: { ok: true }
+    }).$mount(el)
 
-      vm.ok = false
-      waitForUpdate(() => {
-        vm.ok = true
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
+    vm.ok = false
+    waitForUpdate(() => {
+      vm.ok = true
     })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe('test')
+      })
+      .then(done)
+  })
 
-    it('enter transition with v-show: cancelled on next frame', done => {
-      const vm = new Vue({
-        template: `
+  it('enter transition with v-show: cancelled on next frame', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test">
               <div v-show="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: false }
-      }).$mount(el)
+      data: { ok: false }
+    }).$mount(el)
 
-      vm.ok = true
-      waitForUpdate(() => {
-        vm.ok = false
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
+    vm.ok = true
+    waitForUpdate(() => {
+      vm.ok = false
     })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe('test')
+      })
+      .then(done)
+  })
 
-    it('animations', done => {
-      const vm = new Vue({
-        template: `
+  it('animations', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test-anim">
               <div v-if="ok">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div>foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-leave test-anim-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-leave-active test-anim-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div>foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test-anim-leave test-anim-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-leave-active test-anim-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-enter test-anim-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test-anim-enter-active test-anim-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-enter test-anim-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test-anim-enter-active test-anim-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('explicit transition type', done => {
-      const vm = new Vue({
-        template: `
+  it('explicit transition type', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test-anim-long" type="animation">
               <div v-if="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-leave test-anim-long-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-leave-active test-anim-long-leave-to')
-      }).thenWaitFor(duration + 5).then(() => {
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-anim-long-leave test-anim-long-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-anim-long-leave-active test-anim-long-leave-to'
+        )
+      })
+      .thenWaitFor(duration + 5)
+      .then(() => {
         // should not end early due to transition presence
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-leave-active test-anim-long-leave-to')
-      }).thenWaitFor(duration + 5).then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-anim-long-leave-active test-anim-long-leave-to'
+        )
+      })
+      .thenWaitFor(duration + 5)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-enter test-anim-long-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-enter-active test-anim-long-enter-to')
-      }).thenWaitFor(duration + 5).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-anim-long-enter-active test-anim-long-enter-to')
-      }).thenWaitFor(duration + 5).then(() => {
+      })
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-anim-long-enter test-anim-long-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-anim-long-enter-active test-anim-long-enter-to'
+        )
+      })
+      .thenWaitFor(duration + 5)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-anim-long-enter-active test-anim-long-enter-to'
+        )
+      })
+      .thenWaitFor(duration + 5)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition on appear', done => {
-      const vm = new Vue({
-        template: `
+  it('transition on appear', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test"
               appear
@@ -736,157 +1031,215 @@ if (!isIE9) {
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
+      data: { ok: true }
+    }).$mount(el)
 
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-appear test-appear-active'
+      )
     })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-appear-active test-appear-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe('test')
+      })
+      .then(done)
+  })
 
-    it('transition on appear with v-show', done => {
-      const vm = new Vue({
-        template: `
+  it('transition on appear with v-show', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition name="test" appear>
               <div v-show="ok" class="test">foo</div>
             </transition>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
+      data: { ok: true }
+    }).$mount(el)
 
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
-        expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-enter test-enter-active'
+      )
     })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe('test')
+      })
+      .then(done)
+  })
 
-    it('transition on SVG elements', done => {
-      const vm = new Vue({
-        template: `
+  it('transition on SVG elements', (done) => {
+    const vm = new Vue({
+      template: `
           <svg>
             <transition>
               <circle cx="0" cy="0" r="10" v-if="ok" class="test"></circle>
             </transition>
           </svg>
         `,
-        data: { ok: true }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      data: { ok: true }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.childNodes[0].getAttribute('class')).toBe(
+        'test v-leave v-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.childNodes[0].getAttribute('class')).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.childNodes.length).toBe(1)
         expect(vm.$el.childNodes[0].nodeType).toBe(8) // should be an empty comment node
         expect(vm.$el.childNodes[0].textContent).toBe('')
         vm.ok = true
-      }).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-enter v-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .then(() => {
+        expect(vm.$el.childNodes[0].getAttribute('class')).toBe(
+          'test v-enter v-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.childNodes[0].getAttribute('class')).toBe(
+          'test v-enter-active v-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.childNodes[0].getAttribute('class')).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition on child components', done => {
-      const vm = new Vue({
-        template: `
+  it('transition on child components', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition>
               <test v-if="ok" class="test"></test>
             </transition>
           </div>
         `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `
+      data: { ok: true },
+      components: {
+        test: {
+          template: `
               <transition name="test">
                 <div>foo</div>
               </transition>
             ` // test transition override from parent
-          }
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-enter-active v-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition inside child component with v-if', done => {
-      const vm = new Vue({
-        template: `
+  it('transition inside child component with v-if', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <test v-if="ok" class="test"></test>
           </div>
         `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `
+      data: { ok: true },
+      components: {
+        test: {
+          template: `
               <transition>
                 <div>foo</div>
               </transition>
             `
-          }
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition with appear inside child component with v-if', done => {
-      const vm = new Vue({
-        template: `
+  it('transition with appear inside child component with v-if', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <test v-if="ok" class="test"></test>
           </div>
         `,
-        data: { ok: true },
-        components: {
-          test: {
-            template: `
+      data: { ok: true },
+      components: {
+        test: {
+          template: `
               <transition appear
                 appear-class="test-appear"
                 appear-to-class="test-appear-to"
@@ -894,75 +1247,99 @@ if (!isIE9) {
                 <div>foo</div>
               </transition>
             `
-          }
         }
-      }).$mount(el)
+      }
+    }).$mount(el)
 
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-appear test-appear-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-appear-active test-appear-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
         vm.ok = false
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition inside nested child component with v-if', done => {
-      const vm = new Vue({
-        template: `
+  it('transition inside nested child component with v-if', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <foo v-if="ok" class="test"></foo>
           </div>
         `,
-        data: { ok: true },
-        components: {
-          foo: {
-            template: '<bar></bar>',
-            components: {
-              bar: {
-                template: '<transition><div>foo</div></transition>'
-              }
+      data: { ok: true },
+      components: {
+        foo: {
+          template: '<bar></bar>',
+          components: {
+            bar: {
+              template: '<transition><div>foo</div></transition>'
             }
           }
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('transition with appear inside nested child component with v-if', done => {
-      const vm = new Vue({
-        template: `
+  it('transition with appear inside nested child component with v-if', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <foo v-if="ok" class="test"></foo>
           </div>
         `,
-        data: { ok: true },
-        components: {
-          foo: {
-            template: '<bar></bar>',
-            components: {
-              bar: {
-                template: `
+      data: { ok: true },
+      components: {
+        foo: {
+          template: '<bar></bar>',
+          components: {
+            bar: {
+              template: `
                   <transition appear
                     appear-class="test-appear"
                     appear-to-class="test-appear-to"
@@ -970,320 +1347,482 @@ if (!isIE9) {
                     <div>foo</div>
                   </transition>
                 `
-              }
             }
           }
         }
-      }).$mount(el)
+      }
+    }).$mount(el)
 
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear test-appear-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-appear-active test-appear-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-appear test-appear-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-appear-active test-appear-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
         vm.ok = false
-      }).then(() => {
+      })
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('custom transition higher-order component', done => {
-      const vm = new Vue({
-        template: '<div><my-transition><div v-if="ok" class="test">foo</div></my-transition></div>',
-        data: { ok: true },
-        components: {
-          'my-transition': {
-            functional: true,
-            render (h, { data, children }) {
-              (data.props || (data.props = {})).name = 'test'
-              return h('transition', data, children)
-            }
+  it('custom transition higher-order component', (done) => {
+    const vm = new Vue({
+      template:
+        '<div><my-transition><div v-if="ok" class="test">foo</div></my-transition></div>',
+      data: { ok: true },
+      components: {
+        'my-transition': {
+          functional: true,
+          render(h, { data, children }) {
+            ;(data.props || (data.props = {})).name = 'test'
+            return h('transition', data, children)
           }
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave test-leave-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-leave-active test-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<div class="test">foo</div>')
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].className).toBe(
+        'test test-leave test-leave-active'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-leave-active test-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children.length).toBe(0)
         vm.ok = true
-      }).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter test-enter-active')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test test-enter-active test-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      })
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter test-enter-active'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test test-enter-active test-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    it('warn when used on multiple elements', () => {
-      new Vue({
-        template: `<transition><p>1</p><p>2</p></transition>`
-      }).$mount()
-      expect(`<transition> can only be used on a single element`).toHaveBeenWarned()
-    })
+  it('warn when used on multiple elements', () => {
+    new Vue({
+      template: `<transition><p>1</p><p>2</p></transition>`
+    }).$mount()
+    expect(
+      `<transition> can only be used on a single element`
+    ).toHaveBeenWarned()
+  })
 
-    describe('explicit durations -', () => {
-      it('single value', done => {
-        const vm = new Vue({
-          template: `
+  describe('explicit durations -', () => {
+    it('single value', (done) => {
+      const vm = new Vue({
+        template: `
             <div>
               <transition duration="${explicitDuration}">
                 <div v-if="ok" class="test">foo</div>
               </transition>
             </div>
           `,
-          data: { ok: true }
-        }).$mount(el)
+        data: { ok: true }
+      }).$mount(el)
 
-        vm.ok = false
+      vm.ok = false
 
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
+      waitForUpdate(() => {
+        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave-active v-leave-to'
+          )
+        })
+        .thenWaitFor(explicitDuration + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(0)
           vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter v-enter-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter-active v-enter-to'
+          )
+        })
+        .thenWaitFor(explicitDuration + buffer)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
+        })
+        .then(done)
+    })
 
-      it('enter and auto leave', done => {
-        const vm = new Vue({
-          template: `
+    it('enter and auto leave', (done) => {
+      const vm = new Vue({
+        template: `
             <div>
               <transition :duration="{ enter: ${explicitDuration} }">
                 <div v-if="ok" class="test">foo</div>
               </transition>
             </div>
           `,
-          data: { ok: true }
-        }).$mount(el)
+        data: { ok: true }
+      }).$mount(el)
 
-        vm.ok = false
+      vm.ok = false
 
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(duration + buffer).then(() => {
+      waitForUpdate(() => {
+        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave-active v-leave-to'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(0)
           vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter v-enter-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter-active v-enter-to'
+          )
+        })
+        .thenWaitFor(explicitDuration + buffer)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
+        })
+        .then(done)
+    })
 
-      it('leave and auto enter', done => {
-        const vm = new Vue({
-          template: `
+    it('leave and auto enter', (done) => {
+      const vm = new Vue({
+        template: `
             <div>
               <transition :duration="{ leave: ${explicitDuration} }">
                 <div v-if="ok" class="test">foo</div>
               </transition>
             </div>
           `,
-          data: { ok: true }
-        }).$mount(el)
+        data: { ok: true }
+      }).$mount(el)
 
-        vm.ok = false
+      vm.ok = false
 
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(explicitDuration + buffer).then(() => {
+      waitForUpdate(() => {
+        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave-active v-leave-to'
+          )
+        })
+        .thenWaitFor(explicitDuration + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(0)
           vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(duration + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter v-enter-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter-active v-enter-to'
+          )
+        })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
+        })
+        .then(done)
+    })
 
-      it('separate enter and leave', done => {
-        const enter = explicitDuration
-        const leave = explicitDuration * 2
+    it('separate enter and leave', (done) => {
+      const enter = explicitDuration
+      const leave = explicitDuration * 2
 
-        const vm = new Vue({
-          template: `
+      const vm = new Vue({
+        template: `
             <div>
               <transition :duration="{ enter: ${enter}, leave: ${leave} }">
                 <div v-if="ok" class="test">foo</div>
               </transition>
             </div>
           `,
-          data: { ok: true }
-        }).$mount(el)
+        data: { ok: true }
+      }).$mount(el)
 
-        vm.ok = false
+      vm.ok = false
 
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(leave + buffer).then(() => {
+      waitForUpdate(() => {
+        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave-active v-leave-to'
+          )
+        })
+        .thenWaitFor(leave + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(0)
           vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(enter + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter v-enter-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter-active v-enter-to'
+          )
+        })
+        .thenWaitFor(enter + buffer)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      })
+        })
+        .then(done)
+    })
 
-      it('enter and leave + duration change', done => {
-        const enter1 = explicitDuration * 2
-        const enter2 = explicitDuration
-        const leave1 = explicitDuration * 0.5
-        const leave2 = explicitDuration * 3
+    it('enter and leave + duration change', (done) => {
+      const enter1 = explicitDuration * 2
+      const enter2 = explicitDuration
+      const leave1 = explicitDuration * 0.5
+      const leave2 = explicitDuration * 3
 
-        const vm = new Vue({
-          template: `
+      const vm = new Vue({
+        template: `
             <div>
               <transition :duration="{ enter: enter, leave: leave }">
                 <div v-if="ok" class="test">foo</div>
               </transition>
             </div>
           `,
-          data: {
-            ok: true,
-            enter: enter1,
-            leave: leave1
-          }
-        }).$mount(el)
+        data: {
+          ok: true,
+          enter: enter1,
+          leave: leave1
+        }
+      }).$mount(el)
 
-        vm.ok = false
+      vm.ok = false
 
-        waitForUpdate(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(leave1 + buffer).then(() => {
+      waitForUpdate(() => {
+        expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
+      })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave-active v-leave-to'
+          )
+        })
+        .thenWaitFor(leave1 + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(0)
           vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(enter1 + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter v-enter-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter-active v-enter-to'
+          )
+        })
+        .thenWaitFor(enter1 + buffer)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('test')
           vm.enter = enter2
           vm.leave = leave2
-        }).then(() => {
+        })
+        .then(() => {
           vm.ok = false
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave v-leave-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-        }).thenWaitFor(leave2 + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave v-leave-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-leave-active v-leave-to'
+          )
+        })
+        .thenWaitFor(leave2 + buffer)
+        .then(() => {
           expect(vm.$el.children.length).toBe(0)
           vm.ok = true
-        }).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter v-enter-active')
-        }).thenWaitFor(nextFrame).then(() => {
-          expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-        }).thenWaitFor(enter2 + buffer).then(() => {
+        })
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter v-enter-active'
+          )
+        })
+        .thenWaitFor(nextFrame)
+        .then(() => {
+          expect(vm.$el.children[0].className).toBe(
+            'test v-enter-active v-enter-to'
+          )
+        })
+        .thenWaitFor(enter2 + buffer)
+        .then(() => {
           expect(vm.$el.children[0].className).toBe('test')
-        }).then(done)
-      }, 10000)
+        })
+        .then(done)
+    }, 10000)
 
-      it('warn invalid durations', done => {
-        const vm = new Vue({
-          template: `
+    it('warn invalid durations', (done) => {
+      const vm = new Vue({
+        template: `
             <div>
               <transition :duration="{ enter: NaN, leave: 'foo' }">
                 <div v-if="ok" class="test">foo</div>
               </transition>
             </div>
           `,
-          data: {
-            ok: true
-          }
-        }).$mount(el)
+        data: {
+          ok: true
+        }
+      }).$mount(el)
 
-        vm.ok = false
-        waitForUpdate(() => {
-          expect(`<transition> explicit leave duration is not a valid number - got "foo"`).toHaveBeenWarned()
-        }).thenWaitFor(duration + buffer).then(() => {
-          vm.ok = true
-        }).then(() => {
-          expect(`<transition> explicit enter duration is NaN`).toHaveBeenWarned()
-        }).then(done)
+      vm.ok = false
+      waitForUpdate(() => {
+        expect(
+          `<transition> explicit leave duration is not a valid number - got "foo"`
+        ).toHaveBeenWarned()
       })
+        .thenWaitFor(duration + buffer)
+        .then(() => {
+          vm.ok = true
+        })
+        .then(() => {
+          expect(
+            `<transition> explicit enter duration is NaN`
+          ).toHaveBeenWarned()
+        })
+        .then(done)
     })
+  })
 
-    // #6687
-    it('transition on child components with empty root node', done => {
-      const vm = new Vue({
-        template: `
+  // #6687
+  it('transition on child components with empty root node', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <transition mode="out-in">
               <component class="test" :is="view"></component>
             </transition>
           </div>
         `,
-        data: { view: 'one' },
-        components: {
-          'one': {
-            template: '<div v-if="false">one</div>'
-          },
-          'two': {
-            template: '<div>two</div>'
-          }
+      data: { view: 'one' },
+      components: {
+        one: {
+          template: '<div v-if="false">one</div>'
+        },
+        two: {
+          template: '<div>two</div>'
         }
-      }).$mount(el)
-
-      // should not apply transition on initial render by default
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.view = 'two'
-      waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<div class="test v-enter v-enter-active">two</div>')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-enter-active v-enter-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+      }
+    }).$mount(el)
+
+    // should not apply transition on initial render by default
+    expect(vm.$el.innerHTML).toBe('<!---->')
+    vm.view = 'two'
+    waitForUpdate(() => {
+      expect(vm.$el.innerHTML).toBe(
+        '<div class="test v-enter v-enter-active">two</div>'
+      )
+    })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-enter-active v-enter-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.children[0].className).toBe('test')
         vm.view = 'one'
-      }).then(() => {
+      })
+      .then(() => {
         // incoming comment node is appended instantly because it doesn't have
         // data and therefore doesn't go through the transition module.
-        expect(vm.$el.innerHTML).toBe('<div class="test v-leave v-leave-active">two</div><!---->')
-      }).thenWaitFor(nextFrame).then(() => {
-        expect(vm.$el.children[0].className).toBe('test v-leave-active v-leave-to')
-      }).thenWaitFor(duration + buffer).then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<div class="test v-leave v-leave-active">two</div><!---->'
+        )
+      })
+      .thenWaitFor(nextFrame)
+      .then(() => {
+        expect(vm.$el.children[0].className).toBe(
+          'test v-leave-active v-leave-to'
+        )
+      })
+      .thenWaitFor(duration + buffer)
+      .then(() => {
         expect(vm.$el.innerHTML).toBe('<!---->')
-      }).then(done)
-    })
+      })
+      .then(done)
+  })
 
-    // #8199
-    it('should not throw error when replaced by v-html contents', (done) => {
-      const vm = new Vue({
-        template: `
+  // #8199
+  it('should not throw error when replaced by v-html contents', (done) => {
+    const vm = new Vue({
+      template: `
           <div>
             <div v-if="ok" :class="ok">
               <transition>
@@ -1293,13 +1832,12 @@ if (!isIE9) {
             <div v-else v-html="ok"></div>
           </div>
         `,
-        data: { ok: true }
-      }).$mount(el)
+      data: { ok: true }
+    }).$mount(el)
 
-      vm.ok = false
-      waitForUpdate(() => {
-        expect(vm.$el.children[0].innerHTML).toBe('false')
-      }).then(done)
-    })
+    vm.ok = false
+    waitForUpdate(() => {
+      expect(vm.$el.children[0].innerHTML).toBe('false')
+    }).then(done)
   })
-}
+})

From 23bd3b2ca31a193f79a5d1a03f89131b4977e41b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 11:11:47 +0800
Subject: [PATCH 050/317] types: fix types

---
 src/core/global-api/extend.ts      |  8 ++++----
 src/global.d.ts                    |  2 +-
 src/platforms/web/runtime/index.ts |  2 +-
 typescript/component.d.ts          | 17 +++++++----------
 4 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index bcb210b97ff..f1ca45aedd7 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -17,7 +17,7 @@ export function initExtend(Vue: GlobalAPI) {
   /**
    * Class inheritance
    */
-  Vue.extend = function (extendOptions: any): Component {
+  Vue.extend = function (extendOptions: any): typeof Component {
     extendOptions = extendOptions || {}
     const Super = this
     const SuperId = Super.cid
@@ -33,7 +33,7 @@ export function initExtend(Vue: GlobalAPI) {
 
     const Sub = (function VueComponent(this: any, options: any) {
       this._init(options)
-    } as unknown) as Component
+    } as unknown) as typeof Component
     Sub.prototype = Object.create(Super.prototype)
     Sub.prototype.constructor = Sub
     Sub.cid = cid++
@@ -78,14 +78,14 @@ export function initExtend(Vue: GlobalAPI) {
   }
 }
 
-function initProps(Comp: Component) {
+function initProps(Comp: typeof Component) {
   const props = Comp.options.props
   for (const key in props) {
     proxy(Comp.prototype, `_props`, key)
   }
 }
 
-function initComputed(Comp: Component) {
+function initComputed(Comp: typeof Component) {
   const computed = Comp.options.computed
   for (const key in computed) {
     defineComputed(Comp.prototype, key, computed[key])
diff --git a/src/global.d.ts b/src/global.d.ts
index f51385c7da0..e16e3609f33 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -34,4 +34,4 @@ interface DevtoolsHook {
   off: (event?: string, handler?: Function) => void
   Vue?: any
   // apps: AppRecordOptions[]
-}
\ No newline at end of file
+}
diff --git a/src/platforms/web/runtime/index.ts b/src/platforms/web/runtime/index.ts
index f1fda1e99f6..28a55ce9053 100644
--- a/src/platforms/web/runtime/index.ts
+++ b/src/platforms/web/runtime/index.ts
@@ -10,7 +10,7 @@ import {
   isReservedTag,
   isReservedAttr,
   getTagNamespace,
-  isUnknownElement,
+  isUnknownElement
 } from 'web/util/index'
 
 import { patch } from './patch'
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index 0f9c4c616a8..89366cc4b3a 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -2,6 +2,7 @@ import type VNode from '../src/core/vdom/vnode'
 import type Watcher from '../src/core/observer/watcher'
 import { ComponentOptions } from './options'
 import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
+import { GlobalAPI } from './global-api'
 
 // TODO this should be using the same as /component/
 
@@ -11,23 +12,19 @@ export declare class Component {
   static cid: number
   static options: Record<string, any>
   // extend
-  static extend: (options: Record<string, any>) => typeof Component
+  static extend: GlobalAPI['extend']
   static superOptions: Record<string, any>
   static extendOptions: Record<string, any>
   static sealedOptions: Record<string, any>
   static super: Component
   // assets
-  static directive: (
-    id: string,
-    def?: Function | Record<string, any>
-  ) => Function | Record<string, any> | void
-  static component: (
-    id: string,
-    def?: Component | Record<string, any>
-  ) => Component
-  static filter: (id: string, def?: Function) => Function | void
+  static directive: GlobalAPI['directive']
+  static component: GlobalAPI['component']
+  static filter: GlobalAPI['filter']
   // functional context constructor
   static FunctionalRenderContext: Function
+  static mixin: GlobalAPI['mixin']
+  static use: GlobalAPI['use']
 
   // public properties
   $el: any // so that we can attach __vue__ to it

From 2d019e4e2549576766c43ffde08122587ee88912 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 12:01:16 +0800
Subject: [PATCH 051/317] test: partial ssr tests passing

---
 .eslintrc.js                                  |   3 +-
 package.json                                  |   4 +
 pnpm-lock.yaml                                | 373 ++++++++++++++++++
 scripts/config.js                             |   3 +-
 src/core/util/error.ts                        |   6 +-
 src/global.d.ts                               |   1 +
 src/server/create-basic-renderer.ts           |   4 +-
 src/server/create-renderer.ts                 |   8 +-
 test/helpers/shim-done.ts                     |  41 +-
 test/ssr/.eslintrc                            |   9 -
 test/ssr/{async-loader.ts => async-loader.js} |   0
 test/ssr/compile-with-webpack.ts              |   4 -
 test/ssr/jasmine.ts                           |  10 -
 test/ssr/ssr-basic-renderer.spec.ts           |   6 +-
 test/ssr/ssr-bundle-render.spec.ts            |   4 +-
 test/ssr/ssr-stream.spec.ts                   |   9 +-
 test/ssr/ssr-string.spec.ts                   |  43 +-
 test/ssr/ssr-template.spec.ts                 |   4 +-
 test/unit/.eslintrc.json                      |   8 -
 test/vitest.setup.ts                          |   1 +
 test/weex/.eslintrc                           |   9 -
 test/weex/jasmine.ts                          |   9 -
 22 files changed, 451 insertions(+), 108 deletions(-)
 delete mode 100644 test/ssr/.eslintrc
 rename test/ssr/{async-loader.ts => async-loader.js} (100%)
 delete mode 100644 test/ssr/jasmine.ts
 delete mode 100644 test/weex/.eslintrc
 delete mode 100644 test/weex/jasmine.ts

diff --git a/.eslintrc.js b/.eslintrc.js
index e1739e9cfbd..c1e2b4d03e4 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -18,7 +18,7 @@ module.exports = {
     "plugin:@typescript-eslint/eslint-recommended",
   ],
   globals: {
-    __WEEX__: true,
+    __TEST__: true,
     WXEnvironment: true,
   },
   rules: {
@@ -34,5 +34,6 @@ module.exports = {
     "no-console": process.env.NODE_ENV !== "production" ? 0 : 2,
     "no-useless-escape": 0,
     "no-empty": 0,
+    "no-extra-semi": 0
   },
 };
diff --git a/package.json b/package.json
index ecbbb77a66d..59aacd5df7c 100644
--- a/package.json
+++ b/package.json
@@ -85,6 +85,7 @@
     "de-indent": "^1.0.2",
     "escodegen": "^2.0.0",
     "eslint": "^8.14.0",
+    "file-loader": "^6.2.0",
     "fsevents": "2.3.2",
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
@@ -95,17 +96,20 @@
     "lodash.template": "^4.4.0",
     "lodash.uniq": "^4.5.0",
     "lru-cache": "^7.8.1",
+    "memory-fs": "^0.5.0",
     "resolve": "^1.22.0",
     "rollup": "^2.70.2",
     "rollup-plugin-typescript2": "^0.31.2",
     "serialize-javascript": "^6.0.0",
     "shelljs": "^0.8.5",
+    "source-map": "0.5.6",
     "stream-browserify": "^3.0.0",
     "terser": "^5.13.1",
     "ts-node": "^10.7.0",
     "tslib": "^2.4.0",
     "typescript": "^4.6.4",
     "vitest": "^0.12.6",
+    "webpack": "^5.72.1",
     "weex-js-runtime": "^0.23.6",
     "weex-styler": "^0.3.0",
     "yorkie": "^2.0.0"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f2a3fe8bdbb..386d3aa1a1e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -19,6 +19,7 @@ specifiers:
   de-indent: ^1.0.2
   escodegen: ^2.0.0
   eslint: ^8.14.0
+  file-loader: ^6.2.0
   fsevents: 2.3.2
   hash-sum: ^2.0.0
   he: ^1.2.0
@@ -29,17 +30,20 @@ specifiers:
   lodash.template: ^4.4.0
   lodash.uniq: ^4.5.0
   lru-cache: ^7.8.1
+  memory-fs: ^0.5.0
   resolve: ^1.22.0
   rollup: ^2.70.2
   rollup-plugin-typescript2: ^0.31.2
   serialize-javascript: ^6.0.0
   shelljs: ^0.8.5
+  source-map: 0.5.6
   stream-browserify: ^3.0.0
   terser: ^5.13.1
   ts-node: ^10.7.0
   tslib: ^2.4.0
   typescript: ^4.6.4
   vitest: ^0.12.6
+  webpack: ^5.72.1
   weex-js-runtime: ^0.23.6
   weex-styler: ^0.3.0
   yorkie: ^2.0.0
@@ -63,6 +67,7 @@ devDependencies:
   de-indent: 1.0.2
   escodegen: 2.0.0
   eslint: 8.15.0
+  file-loader: 6.2.0_webpack@5.72.1
   fsevents: 2.3.2
   hash-sum: 2.0.0
   he: 1.2.0
@@ -73,17 +78,20 @@ devDependencies:
   lodash.template: 4.5.0
   lodash.uniq: 4.5.0
   lru-cache: 7.10.1
+  memory-fs: 0.5.0
   resolve: 1.22.0
   rollup: 2.74.0
   rollup-plugin-typescript2: 0.31.2_dyu3set7imqii5ytavmnwecwpy
   serialize-javascript: 6.0.0
   shelljs: 0.8.5
+  source-map: 0.5.6
   stream-browserify: 3.0.0
   terser: 5.13.1
   ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
   tslib: 2.4.0
   typescript: 4.6.4
   vitest: 0.12.6_jsdom@19.0.0
+  webpack: 5.72.1
   weex-js-runtime: 0.23.7
   weex-styler: 0.3.1
   yorkie: 2.0.0
@@ -341,6 +349,20 @@ packages:
     resolution: {integrity: sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ==}
     dev: true
 
+  /@types/eslint-scope/3.7.3:
+    resolution: {integrity: sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==}
+    dependencies:
+      '@types/eslint': 8.4.2
+      '@types/estree': 0.0.51
+    dev: true
+
+  /@types/eslint/8.4.2:
+    resolution: {integrity: sha512-Z1nseZON+GEnFjJc04sv4NSALGjhFwy6K0HXt7qsn5ArfAKtb63dXNJHf+1YW6IpOIYRBGUbu3GwJdj8DGnCjA==}
+    dependencies:
+      '@types/estree': 0.0.51
+      '@types/json-schema': 7.0.11
+    dev: true
+
   /@types/estree/0.0.39:
     resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==}
     dev: true
@@ -506,6 +528,120 @@ packages:
       eslint-visitor-keys: 3.3.0
     dev: true
 
+  /@webassemblyjs/ast/1.11.1:
+    resolution: {integrity: sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==}
+    dependencies:
+      '@webassemblyjs/helper-numbers': 1.11.1
+      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
+    dev: true
+
+  /@webassemblyjs/floating-point-hex-parser/1.11.1:
+    resolution: {integrity: sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==}
+    dev: true
+
+  /@webassemblyjs/helper-api-error/1.11.1:
+    resolution: {integrity: sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==}
+    dev: true
+
+  /@webassemblyjs/helper-buffer/1.11.1:
+    resolution: {integrity: sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==}
+    dev: true
+
+  /@webassemblyjs/helper-numbers/1.11.1:
+    resolution: {integrity: sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==}
+    dependencies:
+      '@webassemblyjs/floating-point-hex-parser': 1.11.1
+      '@webassemblyjs/helper-api-error': 1.11.1
+      '@xtuc/long': 4.2.2
+    dev: true
+
+  /@webassemblyjs/helper-wasm-bytecode/1.11.1:
+    resolution: {integrity: sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==}
+    dev: true
+
+  /@webassemblyjs/helper-wasm-section/1.11.1:
+    resolution: {integrity: sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==}
+    dependencies:
+      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/helper-buffer': 1.11.1
+      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
+      '@webassemblyjs/wasm-gen': 1.11.1
+    dev: true
+
+  /@webassemblyjs/ieee754/1.11.1:
+    resolution: {integrity: sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==}
+    dependencies:
+      '@xtuc/ieee754': 1.2.0
+    dev: true
+
+  /@webassemblyjs/leb128/1.11.1:
+    resolution: {integrity: sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==}
+    dependencies:
+      '@xtuc/long': 4.2.2
+    dev: true
+
+  /@webassemblyjs/utf8/1.11.1:
+    resolution: {integrity: sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==}
+    dev: true
+
+  /@webassemblyjs/wasm-edit/1.11.1:
+    resolution: {integrity: sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==}
+    dependencies:
+      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/helper-buffer': 1.11.1
+      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
+      '@webassemblyjs/helper-wasm-section': 1.11.1
+      '@webassemblyjs/wasm-gen': 1.11.1
+      '@webassemblyjs/wasm-opt': 1.11.1
+      '@webassemblyjs/wasm-parser': 1.11.1
+      '@webassemblyjs/wast-printer': 1.11.1
+    dev: true
+
+  /@webassemblyjs/wasm-gen/1.11.1:
+    resolution: {integrity: sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==}
+    dependencies:
+      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
+      '@webassemblyjs/ieee754': 1.11.1
+      '@webassemblyjs/leb128': 1.11.1
+      '@webassemblyjs/utf8': 1.11.1
+    dev: true
+
+  /@webassemblyjs/wasm-opt/1.11.1:
+    resolution: {integrity: sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==}
+    dependencies:
+      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/helper-buffer': 1.11.1
+      '@webassemblyjs/wasm-gen': 1.11.1
+      '@webassemblyjs/wasm-parser': 1.11.1
+    dev: true
+
+  /@webassemblyjs/wasm-parser/1.11.1:
+    resolution: {integrity: sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==}
+    dependencies:
+      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/helper-api-error': 1.11.1
+      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
+      '@webassemblyjs/ieee754': 1.11.1
+      '@webassemblyjs/leb128': 1.11.1
+      '@webassemblyjs/utf8': 1.11.1
+    dev: true
+
+  /@webassemblyjs/wast-printer/1.11.1:
+    resolution: {integrity: sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==}
+    dependencies:
+      '@webassemblyjs/ast': 1.11.1
+      '@xtuc/long': 4.2.2
+    dev: true
+
+  /@xtuc/ieee754/1.2.0:
+    resolution: {integrity: sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==}
+    dev: true
+
+  /@xtuc/long/4.2.2:
+    resolution: {integrity: sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==}
+    dev: true
+
   /@yarn-tool/resolve-package/1.0.47:
     resolution: {integrity: sha512-Zaw58gQxjQceJqhqybJi1oUDaORT8i2GTgwICPs8v/X/Pkx35FXQba69ldHVg5pQZ6YLKpROXgyHvBaCJOFXiA==}
     dependencies:
@@ -533,6 +669,14 @@ packages:
       acorn-walk: 7.2.0
     dev: true
 
+  /acorn-import-assertions/1.8.0_acorn@8.7.1:
+    resolution: {integrity: sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==}
+    peerDependencies:
+      acorn: ^8
+    dependencies:
+      acorn: 8.7.1
+    dev: true
+
   /acorn-jsx/5.3.2_acorn@8.7.1:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -584,6 +728,14 @@ packages:
       indent-string: 4.0.0
     dev: true
 
+  /ajv-keywords/3.5.2_ajv@6.12.6:
+    resolution: {integrity: sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==}
+    peerDependencies:
+      ajv: ^6.9.1
+    dependencies:
+      ajv: 6.12.6
+    dev: true
+
   /ajv/6.12.6:
     resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
     dependencies:
@@ -702,6 +854,10 @@ packages:
       safe-buffer: 5.1.2
     dev: true
 
+  /big.js/5.2.2:
+    resolution: {integrity: sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==}
+    dev: true
+
   /brace-expansion/1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
     dependencies:
@@ -720,6 +876,18 @@ packages:
     resolution: {integrity: sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==}
     dev: true
 
+  /browserslist/4.20.3:
+    resolution: {integrity: sha512-NBhymBQl1zM0Y5dQT/O+xiLP9/rzOIQdKM/eMJBAq7yBgaB6krIYLGejrwVYnSHZdqjscB1SPuAjHwxjvN6Wdg==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+    dependencies:
+      caniuse-lite: 1.0.30001341
+      electron-to-chromium: 1.4.137
+      escalade: 3.1.1
+      node-releases: 2.0.4
+      picocolors: 1.0.0
+    dev: true
+
   /buffer-from/1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
     dev: true
@@ -760,6 +928,10 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /caniuse-lite/1.0.30001341:
+    resolution: {integrity: sha512-2SodVrFFtvGENGCv0ChVJIDQ0KPaS1cg7/qtfMaICgeMolDdo/Z2OD32F0Aq9yl6F4YFwGPBS5AaPqNYiW4PoA==}
+    dev: true
+
   /chai/4.3.6:
     resolution: {integrity: sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==}
     engines: {node: '>=4'}
@@ -798,6 +970,11 @@ packages:
     resolution: {integrity: sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==}
     dev: true
 
+  /chrome-trace-event/1.0.3:
+    resolution: {integrity: sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==}
+    engines: {node: '>=6.0'}
+    dev: true
+
   /ci-info/1.6.0:
     resolution: {integrity: sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==}
     dev: true
@@ -1348,6 +1525,10 @@ packages:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
     dev: true
 
+  /electron-to-chromium/1.4.137:
+    resolution: {integrity: sha512-0Rcpald12O11BUogJagX3HsCN3FE83DSqWjgXoHo5a72KUKMSfI39XBgJpgNNxS9fuGzytaFjE06kZkiVFy2qA==}
+    dev: true
+
   /emoji-regex/8.0.0:
     resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
     dev: true
@@ -1356,12 +1537,36 @@ packages:
     resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
     dev: true
 
+  /emojis-list/3.0.0:
+    resolution: {integrity: sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==}
+    engines: {node: '>= 4'}
+    dev: true
+
+  /enhanced-resolve/5.9.3:
+    resolution: {integrity: sha512-Bq9VSor+kjvW3f9/MiiR4eE3XYgOl7/rS8lnSxbRbF3kS0B2r+Y9w5krBWxZgDxASVZbdYrn5wT4j/Wb0J9qow==}
+    engines: {node: '>=10.13.0'}
+    dependencies:
+      graceful-fs: 4.2.10
+      tapable: 2.2.1
+    dev: true
+
+  /errno/0.1.8:
+    resolution: {integrity: sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A==}
+    hasBin: true
+    dependencies:
+      prr: 1.0.1
+    dev: true
+
   /error-ex/1.3.2:
     resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==}
     dependencies:
       is-arrayish: 0.2.1
     dev: true
 
+  /es-module-lexer/0.9.3:
+    resolution: {integrity: sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==}
+    dev: true
+
   /esbuild-android-64/0.14.39:
     resolution: {integrity: sha512-EJOu04p9WgZk0UoKTqLId9VnIsotmI/Z98EXrKURGb3LPNunkeffqQIkjS2cAvidh+OK5uVrXaIP229zK6GvhQ==}
     engines: {node: '>=12'}
@@ -1734,6 +1939,11 @@ packages:
     resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
     dev: true
 
+  /events/3.3.0:
+    resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
+    engines: {node: '>=0.8.x'}
+    dev: true
+
   /execa/0.8.0:
     resolution: {integrity: sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=}
     engines: {node: '>=4'}
@@ -1821,6 +2031,17 @@ packages:
       flat-cache: 3.0.4
     dev: true
 
+  /file-loader/6.2.0_webpack@5.72.1:
+    resolution: {integrity: sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==}
+    engines: {node: '>= 10.13.0'}
+    peerDependencies:
+      webpack: ^4.0.0 || ^5.0.0
+    dependencies:
+      loader-utils: 2.0.2
+      schema-utils: 3.1.1
+      webpack: 5.72.1
+    dev: true
+
   /fill-range/7.0.1:
     resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==}
     engines: {node: '>=8'}
@@ -2035,6 +2256,10 @@ packages:
       is-glob: 4.0.3
     dev: true
 
+  /glob-to-regexp/0.4.1:
+    resolution: {integrity: sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==}
+    dev: true
+
   /glob/7.1.4:
     resolution: {integrity: sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==}
     dependencies:
@@ -2432,6 +2657,15 @@ packages:
     resolution: {integrity: sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=}
     dev: true
 
+  /jest-worker/27.5.1:
+    resolution: {integrity: sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==}
+    engines: {node: '>= 10.13.0'}
+    dependencies:
+      '@types/node': 17.0.34
+      merge-stream: 2.0.0
+      supports-color: 8.1.1
+    dev: true
+
   /js-tokens/4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
     dev: true
@@ -2505,6 +2739,12 @@ packages:
     resolution: {integrity: sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=}
     dev: true
 
+  /json5/2.2.1:
+    resolution: {integrity: sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA==}
+    engines: {node: '>=6'}
+    hasBin: true
+    dev: true
+
   /jsonfile/4.0.0:
     resolution: {integrity: sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=}
     optionalDependencies:
@@ -2606,6 +2846,20 @@ packages:
       strip-bom: 3.0.0
     dev: true
 
+  /loader-runner/4.3.0:
+    resolution: {integrity: sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==}
+    engines: {node: '>=6.11.5'}
+    dev: true
+
+  /loader-utils/2.0.2:
+    resolution: {integrity: sha512-TM57VeHptv569d/GKh6TAYdzKblwDNiumOdkFnejjD0XwTH87K90w3O7AiJRqdQoXygvi1VQTJTLGhJl7WqA7A==}
+    engines: {node: '>=8.9.0'}
+    dependencies:
+      big.js: 5.2.2
+      emojis-list: 3.0.0
+      json5: 2.2.1
+    dev: true
+
   /local-pkg/0.4.1:
     resolution: {integrity: sha512-lL87ytIGP2FU5PWwNDo0w3WhIo2gopIAxPg9RxDYF7m4rr5ahuZxP22xnJHIvaLTe4Z9P6uKKY2UHiwyB4pcrw==}
     engines: {node: '>=14'}
@@ -2741,6 +2995,14 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /memory-fs/0.5.0:
+    resolution: {integrity: sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==}
+    engines: {node: '>=4.3.0 <5.0.0 || >=5.10'}
+    dependencies:
+      errno: 0.1.8
+      readable-stream: 2.3.7
+    dev: true
+
   /meow/8.1.2:
     resolution: {integrity: sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q==}
     engines: {node: '>=10'}
@@ -2873,6 +3135,10 @@ packages:
     resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
     dev: true
 
+  /node-releases/2.0.4:
+    resolution: {integrity: sha512-gbMzqQtTtDz/00jQzZ21PQzdI9PyLYqUSvD0p3naOhX4odFji0ZxYdnVwPTxmSwkmxhcFImpozceidSG+AgoPQ==}
+    dev: true
+
   /normalize-package-data/2.5.0:
     resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
     dependencies:
@@ -3206,6 +3472,10 @@ packages:
     resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
     dev: true
 
+  /prr/1.0.1:
+    resolution: {integrity: sha1-0/wRS6BplaRexok/SEzrHXj19HY=}
+    dev: true
+
   /pseudomap/1.0.2:
     resolution: {integrity: sha1-8FKijacOYYkX7wqKw0wa5aaChrM=}
     dev: true
@@ -3472,6 +3742,15 @@ packages:
       xmlchars: 2.2.0
     dev: true
 
+  /schema-utils/3.1.1:
+    resolution: {integrity: sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==}
+    engines: {node: '>= 10.13.0'}
+    dependencies:
+      '@types/json-schema': 7.0.11
+      ajv: 6.12.6
+      ajv-keywords: 3.5.2_ajv@6.12.6
+    dev: true
+
   /secure-compare/3.0.1:
     resolution: {integrity: sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=}
     dev: true
@@ -3605,6 +3884,11 @@ packages:
     deprecated: See https://github.com/lydell/source-map-url#deprecated
     dev: true
 
+  /source-map/0.5.6:
+    resolution: {integrity: sha1-dc449SvwczxafwwRjYEzSiu19BI=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /source-map/0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
@@ -3789,6 +4073,13 @@ packages:
       has-flag: 4.0.0
     dev: true
 
+  /supports-color/8.1.1:
+    resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      has-flag: 4.0.0
+    dev: true
+
   /supports-color/9.2.2:
     resolution: {integrity: sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==}
     engines: {node: '>=12'}
@@ -3803,6 +4094,35 @@ packages:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
     dev: true
 
+  /tapable/2.2.1:
+    resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /terser-webpack-plugin/5.3.1_webpack@5.72.1:
+    resolution: {integrity: sha512-GvlZdT6wPQKbDNW/GDQzZFg/j4vKU96yl2q6mcUkzKOgW4gwf1Z8cZToUCrz31XHlPWH8MVb1r2tFtdDtTGJ7g==}
+    engines: {node: '>= 10.13.0'}
+    peerDependencies:
+      '@swc/core': '*'
+      esbuild: '*'
+      uglify-js: '*'
+      webpack: ^5.1.0
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      esbuild:
+        optional: true
+      uglify-js:
+        optional: true
+    dependencies:
+      jest-worker: 27.5.1
+      schema-utils: 3.1.1
+      serialize-javascript: 6.0.0
+      source-map: 0.6.1
+      terser: 5.13.1
+      webpack: 5.72.1
+    dev: true
+
   /terser/5.13.1:
     resolution: {integrity: sha512-hn4WKOfwnwbYfe48NgrQjqNOH9jzLqRcIfbYytOXCOv46LBfWr9bDS17MQqOi+BWGD0sJK3Sj5NC/gJjiojaoA==}
     engines: {node: '>=10'}
@@ -4128,6 +4448,14 @@ packages:
       xml-name-validator: 4.0.0
     dev: true
 
+  /watchpack/2.3.1:
+    resolution: {integrity: sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==}
+    engines: {node: '>=10.13.0'}
+    dependencies:
+      glob-to-regexp: 0.4.1
+      graceful-fs: 4.2.10
+    dev: true
+
   /webidl-conversions/4.0.2:
     resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
     dev: true
@@ -4137,6 +4465,51 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
+  /webpack-sources/3.2.3:
+    resolution: {integrity: sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==}
+    engines: {node: '>=10.13.0'}
+    dev: true
+
+  /webpack/5.72.1:
+    resolution: {integrity: sha512-dXG5zXCLspQR4krZVR6QgajnZOjW2K/djHvdcRaDQvsjV9z9vaW6+ja5dZOYbqBBjF6kGXka/2ZyxNdc+8Jung==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+    peerDependencies:
+      webpack-cli: '*'
+    peerDependenciesMeta:
+      webpack-cli:
+        optional: true
+    dependencies:
+      '@types/eslint-scope': 3.7.3
+      '@types/estree': 0.0.51
+      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/wasm-edit': 1.11.1
+      '@webassemblyjs/wasm-parser': 1.11.1
+      acorn: 8.7.1
+      acorn-import-assertions: 1.8.0_acorn@8.7.1
+      browserslist: 4.20.3
+      chrome-trace-event: 1.0.3
+      enhanced-resolve: 5.9.3
+      es-module-lexer: 0.9.3
+      eslint-scope: 5.1.1
+      events: 3.3.0
+      glob-to-regexp: 0.4.1
+      graceful-fs: 4.2.10
+      json-parse-even-better-errors: 2.3.1
+      loader-runner: 4.3.0
+      mime-types: 2.1.35
+      neo-async: 2.6.2
+      schema-utils: 3.1.1
+      tapable: 2.2.1
+      terser-webpack-plugin: 5.3.1_webpack@5.72.1
+      watchpack: 2.3.1
+      webpack-sources: 3.2.3
+    transitivePeerDependencies:
+      - '@swc/core'
+      - esbuild
+      - uglify-js
+    dev: true
+
   /weex-js-runtime/0.23.7:
     resolution: {integrity: sha512-3BFd5GXTo0X/GWh0KjzXDpIcPJuSwYuc9fE9llgez35IfVHs/nUmfkFBjifzxOJS2YLhtKf0Cy8eTQ00CJDWZA==}
     engines: {node: '>=4'}
diff --git a/scripts/config.js b/scripts/config.js
index 65cc8b4cfc4..c62f3021220 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -269,7 +269,8 @@ function genConfig(name) {
   const vars = {
     __WEEX__: !!opts.weex,
     __WEEX_VERSION__: weexVersion,
-    __VERSION__: version
+    __VERSION__: version,
+    __SSR_TEST__: false
   }
   // feature flags
   Object.keys(featureFlags).forEach((key) => {
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index f7f7665e18f..48de9b40142 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -73,7 +73,11 @@ function logError(err, vm, info) {
     warn(`Error in ${info}: "${err.toString()}"`, vm)
   }
   /* istanbul ignore else */
-  if ((inBrowser || inWeex) && typeof console !== 'undefined') {
+  if (
+    (inBrowser || inWeex) &&
+    typeof console !== 'undefined' &&
+    !__SSR_TEST__
+  ) {
     console.error(err)
   } else {
     throw err
diff --git a/src/global.d.ts b/src/global.d.ts
index e16e3609f33..cdb70d0f9cb 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,4 +1,5 @@
 declare const __WEEX__: boolean;
+declare const __SSR_TEST__: boolean;
 declare type WeexEnvironment = {
   platform: string; // could be "Web", "iOS", "Android"
   weexVersion: string; // the version of WeexSDK
diff --git a/src/server/create-basic-renderer.ts b/src/server/create-basic-renderer.ts
index dd7173372d7..733b3e320f1 100644
--- a/src/server/create-basic-renderer.ts
+++ b/src/server/create-basic-renderer.ts
@@ -14,8 +14,8 @@ export function createBasicRenderer({
 
   return function renderToString(
     component: Component,
-    context: any,
-    done: any
+    context?: any,
+    done?: any
   ): void {
     if (typeof context === 'function') {
       done = context
diff --git a/src/server/create-renderer.ts b/src/server/create-renderer.ts
index e9d022621ce..ea1d6a5d7c1 100644
--- a/src/server/create-renderer.ts
+++ b/src/server/create-renderer.ts
@@ -12,8 +12,8 @@ import { Readable } from 'stream'
 export type Renderer = {
   renderToString: (
     component: Component,
-    context: any,
-    cb: any
+    context?: any,
+    cb?: any
   ) => Promise<string> | undefined
   renderToStream: (component: Component, context?: Object) => Readable
 }
@@ -66,8 +66,8 @@ export function createRenderer({
   return {
     renderToString(
       component: Component,
-      context: any,
-      cb: any
+      context?: any,
+      cb?: any
     ): Promise<string> {
       if (typeof context === 'function') {
         cb = context
diff --git a/test/helpers/shim-done.ts b/test/helpers/shim-done.ts
index 9d71ebfda34..902d46a31bb 100644
--- a/test/helpers/shim-done.ts
+++ b/test/helpers/shim-done.ts
@@ -10,24 +10,27 @@ const wait = (): [() => void, Promise<void>] => {
   return [done, p]
 }
 
-;(global as any).it = (global as any).test = (
-  desc: string,
-  fn?: any,
-  timeout?: number
-) => {
-  if (fn && fn.length > 0) {
-    _test(
-      desc,
-      () => {
-        const [done, p] = wait()
-        fn(done)
-        return p
-      },
-      timeout
-    )
-  } else {
-    _test(desc, fn, timeout)
-  }
-}
+const shimmed =
+  ((global as any).it =
+  (global as any).test =
+    (desc: string, fn?: any, timeout?: number) => {
+      if (fn && fn.length > 0) {
+        _test(
+          desc,
+          () => {
+            const [done, p] = wait()
+            fn(done)
+            return p
+          },
+          timeout
+        )
+      } else {
+        _test(desc, fn, timeout)
+      }
+    })
+
+;['skip', 'only', 'todo', 'concurrent'].forEach(key => {
+  shimmed[key] = _test[key]
+})
 
 export {}
diff --git a/test/ssr/.eslintrc b/test/ssr/.eslintrc
deleted file mode 100644
index dab5d0ea656..00000000000
--- a/test/ssr/.eslintrc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "plugins": ["jasmine"],
-  "rules": {
-    "jasmine/no-focused-tests": 2
-  }
-}
diff --git a/test/ssr/async-loader.ts b/test/ssr/async-loader.js
similarity index 100%
rename from test/ssr/async-loader.ts
rename to test/ssr/async-loader.js
diff --git a/test/ssr/compile-with-webpack.ts b/test/ssr/compile-with-webpack.ts
index 6e648c8b489..2b6b0b326d2 100644
--- a/test/ssr/compile-with-webpack.ts
+++ b/test/ssr/compile-with-webpack.ts
@@ -8,10 +8,6 @@ export function compileWithWebpack (file, extraConfig, cb) {
     entry: path.resolve(__dirname, 'fixtures', file),
     module: {
       rules: [
-        {
-          test: /\.js$/,
-          loader: 'babel-loader'
-        },
         {
           test: /async-.*\.js$/,
           loader: require.resolve('./async-loader')
diff --git a/test/ssr/jasmine.ts b/test/ssr/jasmine.ts
deleted file mode 100644
index b632601642d..00000000000
--- a/test/ssr/jasmine.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-module.exports = {
-  spec_dir: 'test/ssr',
-  spec_files: [
-    '*.spec.js'
-  ],
-  helpers: [
-    require.resolve('@babel/register'),
-    '../helpers/to-have-been-warned.js'
-  ]
-}
diff --git a/test/ssr/ssr-basic-renderer.spec.ts b/test/ssr/ssr-basic-renderer.spec.ts
index 04c8d80e6a7..3a91fd40e96 100644
--- a/test/ssr/ssr-basic-renderer.spec.ts
+++ b/test/ssr/ssr-basic-renderer.spec.ts
@@ -1,5 +1,7 @@
-import Vue from '../../dist/vue.runtime.common.js'
-import renderToString from '../../packages/vue-server-renderer/basic'
+import Vue from 'vue'
+import renderToString from 'web/entry-server-basic-renderer'
+
+;(global as any).__SSR_TEST__ = true
 
 describe('SSR: basicRenderer', () => {
   it('should work', done => {
diff --git a/test/ssr/ssr-bundle-render.spec.ts b/test/ssr/ssr-bundle-render.spec.ts
index 530b5f321f2..28d82d872e5 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/test/ssr/ssr-bundle-render.spec.ts
@@ -3,6 +3,8 @@ import { compileWithWebpack } from './compile-with-webpack'
 import { createBundleRenderer } from '../../packages/vue-server-renderer'
 import VueSSRServerPlugin from '../../packages/vue-server-renderer/server-plugin'
 
+;(global as any).__SSR_TEST__ = true
+
 export function createRenderer (file, options, cb) {
   if (typeof options === 'function') {
     cb = options
@@ -32,7 +34,7 @@ export function createRenderer (file, options, cb) {
   })
 }
 
-describe('SSR: bundle renderer', () => {
+describe.skip('SSR: bundle renderer', () => {
   createAssertions(true)
   createAssertions(false)
 })
diff --git a/test/ssr/ssr-stream.spec.ts b/test/ssr/ssr-stream.spec.ts
index 04e79658984..000d201a1a7 100644
--- a/test/ssr/ssr-stream.spec.ts
+++ b/test/ssr/ssr-stream.spec.ts
@@ -1,7 +1,9 @@
-import Vue from '../../dist/vue.runtime.common.js'
-import { createRenderer } from '../../packages/vue-server-renderer'
+import Vue from 'vue'
+import { createRenderer } from 'web/entry-server-renderer'
 const { renderToStream } = createRenderer()
 
+;(global as any).__SSR_TEST__ = true
+
 describe('SSR: renderToStream', () => {
   it('should render to a stream', done => {
     const stream = renderToStream(new Vue({
@@ -65,7 +67,6 @@ describe('SSR: renderToStream', () => {
   })
 
   it('should catch error', done => {
-    Vue.config.silent = true
     const stream = renderToStream(new Vue({
       render () {
         throw new Error('oops')
@@ -73,7 +74,7 @@ describe('SSR: renderToStream', () => {
     }))
     stream.on('error', err => {
       expect(err.toString()).toMatch(/oops/)
-      Vue.config.silent = false
+      expect(`oops`).toHaveBeenWarned()
       done()
     })
     stream.on('data', _ => _)
diff --git a/test/ssr/ssr-string.spec.ts b/test/ssr/ssr-string.spec.ts
index 33094be9c33..ffa4a390195 100644
--- a/test/ssr/ssr-string.spec.ts
+++ b/test/ssr/ssr-string.spec.ts
@@ -1,8 +1,10 @@
-import Vue from '../../dist/vue.runtime.common.js'
+import Vue from 'vue'
 import VM from 'vm'
-import { createRenderer } from '../../packages/vue-server-renderer'
+import { createRenderer } from 'web/entry-server-renderer'
 const { renderToString } = createRenderer()
 
+;(global as any).__SSR_TEST__ = true
+
 describe('SSR: renderToString', () => {
   it('static attributes', done => {
     renderVmWithOptions({
@@ -676,7 +678,6 @@ describe('SSR: renderToString', () => {
   })
 
   it('should catch async component error', done => {
-    Vue.config.silent = true
     renderToString(new Vue({
       template: '<test-async></test-async>',
       components: {
@@ -687,9 +688,9 @@ describe('SSR: renderToString', () => {
         })
       }
     }), (err, result) => {
-      Vue.config.silent = false
       expect(err).toBeTruthy()
       expect(result).toBeUndefined()
+      expect('foo').toHaveBeenWarned()
       done()
     })
   })
@@ -963,14 +964,13 @@ describe('SSR: renderToString', () => {
   })
 
   it('should catch error', done => {
-    Vue.config.silent = true
     renderToString(new Vue({
       render () {
         throw new Error('oops')
       }
     }), err => {
       expect(err instanceof Error).toBe(true)
-      Vue.config.silent = false
+      expect(`oops`).toHaveBeenWarned()
       done()
     })
   })
@@ -1173,26 +1173,23 @@ describe('SSR: renderToString', () => {
     })
   })
 
-  it('return Promise', done => {
-    renderToString(new Vue({
+  it('return Promise', async () => {
+    await renderToString(new Vue({
       template: `<div>{{ foo }}</div>`,
       data: { foo: 'bar' }
-    })).then(res => {
+    }))!.then(res => {
       expect(res).toBe(`<div data-server-rendered="true">bar</div>`)
-      done()
     })
   })
 
-  it('return Promise (error)', done => {
-    Vue.config.silent = true
-    renderToString(new Vue({
+  it('return Promise (error)', async () => {
+    await renderToString(new Vue({
       render () {
         throw new Error('foobar')
       }
-    })).catch(err => {
+    }))!.catch(err => {
+      expect('foobar').toHaveBeenWarned()
       expect(err.toString()).toContain(`foobar`)
-      Vue.config.silent = false
-      done()
     })
   })
 
@@ -1384,7 +1381,7 @@ describe('SSR: renderToString', () => {
         count: 0
       },
       serverPrefetch () {
-        return new Promise((resolve) => {
+        return new Promise<void>((resolve) => {
           setTimeout(() => {
             this.count = 42
             resolve()
@@ -1409,7 +1406,7 @@ describe('SSR: renderToString', () => {
         count: 0
       },
       serverPrefetch () {
-        return new Promise((resolve) => {
+        return new Promise<void>((resolve) => {
           setTimeout(() => {
             this.count = 42
             resolve()
@@ -1427,7 +1424,7 @@ describe('SSR: renderToString', () => {
             }
           },
           serverPrefetch () {
-            return new Promise((resolve) => {
+            return new Promise<void>((resolve) => {
               setTimeout(() => {
                 this.message = 'vue.js'
                 resolve()
@@ -1454,7 +1451,7 @@ describe('SSR: renderToString', () => {
         count: 0
       },
       serverPrefetch () {
-        return new Promise((resolve) => {
+        return new Promise<void>((resolve) => {
           setTimeout(() => {
             this.count = 42
             resolve()
@@ -1473,7 +1470,7 @@ describe('SSR: renderToString', () => {
               }
             },
             serverPrefetch () {
-              return new Promise((resolve) => {
+              return new Promise<void>((resolve) => {
                 setTimeout(() => {
                   this.message = 'vue.js'
                   resolve()
@@ -1495,7 +1492,7 @@ describe('SSR: renderToString', () => {
         message: ''
       },
       serverPrefetch () {
-        return new Promise((resolve) => {
+        return new Promise<void>((resolve) => {
           setTimeout(() => {
             this.message = 'vue.js'
             resolve()
@@ -1515,7 +1512,7 @@ describe('SSR: renderToString', () => {
         count: 0
       },
       serverPrefetch () {
-        return new Promise((resolve) => {
+        return new Promise<void>((resolve) => {
           setTimeout(() => {
             this.count = 42
             resolve()
diff --git a/test/ssr/ssr-template.spec.ts b/test/ssr/ssr-template.spec.ts
index d30f096668a..dc9267d9b90 100644
--- a/test/ssr/ssr-template.spec.ts
+++ b/test/ssr/ssr-template.spec.ts
@@ -4,6 +4,8 @@ import { createRenderer } from '../../packages/vue-server-renderer'
 import VueSSRClientPlugin from '../../packages/vue-server-renderer/client-plugin'
 import { createRenderer as createBundleRenderer } from './ssr-bundle-render.spec.js'
 
+;(global as any).__SSR_TEST__ = true
+
 const defaultTemplate = `<html><head></head><body><!--vue-ssr-outlet--></body></html>`
 const interpolateTemplate = `<html><head><title>{{ title }}</title></head><body><!--vue-ssr-outlet-->{{{ snippet }}}</body></html>`
 
@@ -41,7 +43,7 @@ function createRendererWithManifest (file, options, cb) {
   })
 }
 
-describe('SSR: template option', () => {
+describe.skip('SSR: template option', () => {
   it('renderToString', done => {
     const renderer = createRenderer({
       template: defaultTemplate
diff --git a/test/unit/.eslintrc.json b/test/unit/.eslintrc.json
index d1ccc04e195..5973f4d4b0c 100644
--- a/test/unit/.eslintrc.json
+++ b/test/unit/.eslintrc.json
@@ -1,15 +1,7 @@
 {
-  "env": {
-    "jasmine": true
-  },
   "globals": {
     "waitForUpdate": true,
     "triggerEvent": true,
     "createTextVNode": true
-  },
-  "plugins": ["jasmine"],
-  "rules": {
-    "jasmine/no-focused-tests": 2,
-    "no-unused-vars": 0
   }
 }
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index 10ddc9b9399..8b097694523 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -1,4 +1,5 @@
 ;(global as any).__WEEX__ = false
+;(global as any).__SSR_TEST__ = false
 process.env.NEW_SLOT_SYNTAX = 'true'
 
 import './helpers/shim-done'
diff --git a/test/weex/.eslintrc b/test/weex/.eslintrc
deleted file mode 100644
index dab5d0ea656..00000000000
--- a/test/weex/.eslintrc
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "plugins": ["jasmine"],
-  "rules": {
-    "jasmine/no-focused-tests": 2
-  }
-}
diff --git a/test/weex/jasmine.ts b/test/weex/jasmine.ts
deleted file mode 100644
index eaac3099a24..00000000000
--- a/test/weex/jasmine.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-module.exports = {
-  spec_dir: 'test/weex',
-  spec_files: [
-    '**/*[sS]pec.js'
-  ],
-  helpers: [
-    require.resolve('@babel/register')
-  ]
-}

From d8c3bbfa443dc9855cae844e0e8b60d65c5a837d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 12:17:13 +0800
Subject: [PATCH 052/317] refactor: remove weex from codebase

---
 .circleci/config.yml                          |  131 -
 .flowconfig                                   |   23 -
 package.json                                  |   17 +-
 .../vue-template-compiler/types/index.d.ts    |    3 -
 packages/weex-template-compiler/README.md     |    3 -
 packages/weex-template-compiler/build.js      | 4958 ------------
 packages/weex-template-compiler/index.js      |   17 -
 packages/weex-template-compiler/package.json  |   26 -
 packages/weex-vue-framework/README.md         |    3 -
 packages/weex-vue-framework/factory.js        | 6858 -----------------
 packages/weex-vue-framework/index.js          |  203 -
 packages/weex-vue-framework/package.json      |   20 -
 pnpm-lock.yaml                                |   61 -
 scripts/alias.js                              |    1 -
 scripts/build.js                              |    5 -
 scripts/config.js                             |   39 -
 scripts/get-weex-version.js                   |   24 -
 scripts/release-weex.sh                       |   38 -
 src/compiler/codegen/events.ts                |   40 +-
 src/compiler/codegen/index.ts                 |   34 +-
 src/core/util/env.ts                          |   13 +-
 src/core/util/props.ts                        |   11 +-
 src/core/vdom/create-component.ts             |   12 -
 src/core/vdom/create-element.ts               |   16 +-
 src/core/vdom/helpers/update-listeners.ts     |    7 +-
 src/core/vdom/patch.ts                        |   29 +-
 src/global.d.ts                               |   23 -
 .../weex/compiler/directives/index.ts         |    5 -
 .../weex/compiler/directives/model.ts         |   29 -
 src/platforms/weex/compiler/index.ts          |   52 -
 src/platforms/weex/compiler/modules/append.ts |   29 -
 src/platforms/weex/compiler/modules/class.ts  |   75 -
 src/platforms/weex/compiler/modules/index.ts  |    7 -
 src/platforms/weex/compiler/modules/props.ts  |   36 -
 .../modules/recycle-list/component-root.ts    |   12 -
 .../modules/recycle-list/component.ts         |   16 -
 .../compiler/modules/recycle-list/index.ts    |   59 -
 .../modules/recycle-list/recycle-list.ts      |   50 -
 .../compiler/modules/recycle-list/text.ts     |   23 -
 .../compiler/modules/recycle-list/v-bind.ts   |   20 -
 .../compiler/modules/recycle-list/v-for.ts    |   33 -
 .../compiler/modules/recycle-list/v-if.ts     |   61 -
 .../compiler/modules/recycle-list/v-on.ts     |   24 -
 .../compiler/modules/recycle-list/v-once.ts   |   18 -
 src/platforms/weex/compiler/modules/style.ts  |   87 -
 src/platforms/weex/entry-compiler.ts          |    2 -
 src/platforms/weex/entry-framework.ts         |  196 -
 src/platforms/weex/entry-runtime-factory.ts   |    6 -
 .../weex/runtime/components/index.ts          |    9 -
 .../weex/runtime/components/richtext.ts       |   89 -
 .../runtime/components/transition-group.ts    |  152 -
 .../weex/runtime/components/transition.ts     |    9 -
 .../weex/runtime/directives/index.ts          |    1 -
 src/platforms/weex/runtime/index.ts           |   35 -
 src/platforms/weex/runtime/modules/attrs.ts   |   40 -
 src/platforms/weex/runtime/modules/class.ts   |   86 -
 src/platforms/weex/runtime/modules/events.ts  |   49 -
 src/platforms/weex/runtime/modules/index.ts   |    7 -
 src/platforms/weex/runtime/modules/style.ts   |   84 -
 .../weex/runtime/modules/transition.ts        |  310 -
 src/platforms/weex/runtime/node-ops.ts        |   94 -
 src/platforms/weex/runtime/patch.ts           |   15 -
 .../recycle-list/render-component-template.ts |   35 -
 .../runtime/recycle-list/virtual-component.ts |  142 -
 src/platforms/weex/runtime/text-node.ts       |    9 -
 src/platforms/weex/types.d.ts                 |    7 -
 src/platforms/weex/util/element.ts            |   48 -
 src/platforms/weex/util/index.ts              |   40 -
 src/platforms/weex/util/parser.ts             |   60 -
 test/vitest.setup.ts                          |    2 +-
 test/weex/cases/cases.spec.ts                 |  238 -
 test/weex/cases/event/click.after.vdom.ts     |   10 -
 test/weex/cases/event/click.before.vdom.ts    |   10 -
 test/weex/cases/event/click.vue               |   20 -
 test/weex/cases/recycle-list/attrs.vdom.ts    |   34 -
 test/weex/cases/recycle-list/attrs.vue        |   23 -
 .../weex/cases/recycle-list/classname.vdom.ts |   27 -
 test/weex/cases/recycle-list/classname.vue    |   37 -
 .../cases/recycle-list/components/banner.vue  |   19 -
 .../cases/recycle-list/components/counter.vue |   36 -
 .../cases/recycle-list/components/editor.vue  |   31 -
 .../cases/recycle-list/components/footer.vue  |   18 -
 .../recycle-list/components/lifecycle.vue     |   39 -
 .../cases/recycle-list/components/poster.vue  |   33 -
 .../components/stateful-lifecycle.vdom.ts     |   29 -
 .../components/stateful-lifecycle.vue         |   21 -
 .../components/stateful-v-model.vdom.ts       |   40 -
 .../components/stateful-v-model.vue           |   21 -
 .../recycle-list/components/stateful.vdom.ts  |   40 -
 .../recycle-list/components/stateful.vue      |   22 -
 .../stateless-multi-components.vdom.ts        |   83 -
 .../components/stateless-multi-components.vue |   30 -
 .../components/stateless-with-props.vdom.ts   |   44 -
 .../components/stateless-with-props.vue       |   22 -
 .../recycle-list/components/stateless.vdom.ts |   36 -
 .../recycle-list/components/stateless.vue     |   22 -
 .../cases/recycle-list/inline-style.vdom.ts   |   29 -
 test/weex/cases/recycle-list/inline-style.vue |   21 -
 .../weex/cases/recycle-list/text-node.vdom.ts |   38 -
 test/weex/cases/recycle-list/text-node.vue    |   23 -
 .../weex/cases/recycle-list/v-else-if.vdom.ts |   35 -
 test/weex/cases/recycle-list/v-else-if.vue    |   23 -
 test/weex/cases/recycle-list/v-else.vdom.ts   |   29 -
 test/weex/cases/recycle-list/v-else.vue       |   22 -
 .../cases/recycle-list/v-for-iterator.vdom.ts |   47 -
 .../cases/recycle-list/v-for-iterator.vue     |   24 -
 test/weex/cases/recycle-list/v-for.vdom.ts    |   33 -
 test/weex/cases/recycle-list/v-for.vue        |   23 -
 test/weex/cases/recycle-list/v-if.vdom.ts     |   29 -
 test/weex/cases/recycle-list/v-if.vue         |   22 -
 .../cases/recycle-list/v-on-inline.vdom.ts    |   37 -
 test/weex/cases/recycle-list/v-on-inline.vue  |   28 -
 test/weex/cases/recycle-list/v-on.vdom.ts     |   25 -
 test/weex/cases/recycle-list/v-on.vue         |   26 -
 test/weex/cases/recycle-list/v-once.vdom.ts   |   22 -
 test/weex/cases/recycle-list/v-once.vue       |   21 -
 test/weex/cases/render/class.vdom.ts          |   19 -
 test/weex/cases/render/class.vue              |   56 -
 test/weex/cases/render/sample.vdom.ts         |   13 -
 test/weex/cases/render/sample.vue             |   23 -
 test/weex/compiler/append.spec.ts             |   47 -
 test/weex/compiler/class.spec.ts              |   56 -
 test/weex/compiler/compile.spec.ts            |   76 -
 test/weex/compiler/parser.spec.ts             |  105 -
 test/weex/compiler/props.spec.ts              |   22 -
 test/weex/compiler/style.spec.ts              |   83 -
 test/weex/compiler/v-model.spec.ts            |   41 -
 test/weex/helpers/index.ts                    |  233 -
 test/weex/runtime/attrs.spec.ts               |   89 -
 test/weex/runtime/class.spec.ts               |  161 -
 test/weex/runtime/components/richtext.spec.ts |  692 --
 test/weex/runtime/events.spec.ts              |   98 -
 test/weex/runtime/framework.spec.ts           |  194 -
 test/weex/runtime/node.spec.ts                |  513 --
 test/weex/runtime/style.spec.ts               |  129 -
 tsconfig.json                                 |    1 -
 typescript/compiler.d.ts                      |    3 -
 typescript/weex.d.ts                          |  125 -
 vitest.config.ts                              |    1 -
 139 files changed, 39 insertions(+), 19061 deletions(-)
 delete mode 100644 .circleci/config.yml
 delete mode 100644 .flowconfig
 delete mode 100644 packages/weex-template-compiler/README.md
 delete mode 100644 packages/weex-template-compiler/build.js
 delete mode 100644 packages/weex-template-compiler/index.js
 delete mode 100644 packages/weex-template-compiler/package.json
 delete mode 100644 packages/weex-vue-framework/README.md
 delete mode 100644 packages/weex-vue-framework/factory.js
 delete mode 100644 packages/weex-vue-framework/index.js
 delete mode 100644 packages/weex-vue-framework/package.json
 delete mode 100644 scripts/get-weex-version.js
 delete mode 100644 scripts/release-weex.sh
 delete mode 100644 src/platforms/weex/compiler/directives/index.ts
 delete mode 100644 src/platforms/weex/compiler/directives/model.ts
 delete mode 100644 src/platforms/weex/compiler/index.ts
 delete mode 100644 src/platforms/weex/compiler/modules/append.ts
 delete mode 100644 src/platforms/weex/compiler/modules/class.ts
 delete mode 100644 src/platforms/weex/compiler/modules/index.ts
 delete mode 100644 src/platforms/weex/compiler/modules/props.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/component-root.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/component.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/index.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/text.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/v-for.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/v-if.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/v-on.ts
 delete mode 100644 src/platforms/weex/compiler/modules/recycle-list/v-once.ts
 delete mode 100644 src/platforms/weex/compiler/modules/style.ts
 delete mode 100644 src/platforms/weex/entry-compiler.ts
 delete mode 100644 src/platforms/weex/entry-framework.ts
 delete mode 100644 src/platforms/weex/entry-runtime-factory.ts
 delete mode 100644 src/platforms/weex/runtime/components/index.ts
 delete mode 100644 src/platforms/weex/runtime/components/richtext.ts
 delete mode 100644 src/platforms/weex/runtime/components/transition-group.ts
 delete mode 100644 src/platforms/weex/runtime/components/transition.ts
 delete mode 100644 src/platforms/weex/runtime/directives/index.ts
 delete mode 100644 src/platforms/weex/runtime/index.ts
 delete mode 100644 src/platforms/weex/runtime/modules/attrs.ts
 delete mode 100644 src/platforms/weex/runtime/modules/class.ts
 delete mode 100644 src/platforms/weex/runtime/modules/events.ts
 delete mode 100644 src/platforms/weex/runtime/modules/index.ts
 delete mode 100644 src/platforms/weex/runtime/modules/style.ts
 delete mode 100644 src/platforms/weex/runtime/modules/transition.ts
 delete mode 100644 src/platforms/weex/runtime/node-ops.ts
 delete mode 100644 src/platforms/weex/runtime/patch.ts
 delete mode 100644 src/platforms/weex/runtime/recycle-list/render-component-template.ts
 delete mode 100644 src/platforms/weex/runtime/recycle-list/virtual-component.ts
 delete mode 100644 src/platforms/weex/runtime/text-node.ts
 delete mode 100644 src/platforms/weex/types.d.ts
 delete mode 100644 src/platforms/weex/util/element.ts
 delete mode 100644 src/platforms/weex/util/index.ts
 delete mode 100644 src/platforms/weex/util/parser.ts
 delete mode 100644 test/weex/cases/cases.spec.ts
 delete mode 100644 test/weex/cases/event/click.after.vdom.ts
 delete mode 100644 test/weex/cases/event/click.before.vdom.ts
 delete mode 100644 test/weex/cases/event/click.vue
 delete mode 100644 test/weex/cases/recycle-list/attrs.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/attrs.vue
 delete mode 100644 test/weex/cases/recycle-list/classname.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/classname.vue
 delete mode 100644 test/weex/cases/recycle-list/components/banner.vue
 delete mode 100644 test/weex/cases/recycle-list/components/counter.vue
 delete mode 100644 test/weex/cases/recycle-list/components/editor.vue
 delete mode 100644 test/weex/cases/recycle-list/components/footer.vue
 delete mode 100644 test/weex/cases/recycle-list/components/lifecycle.vue
 delete mode 100644 test/weex/cases/recycle-list/components/poster.vue
 delete mode 100644 test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/components/stateful-lifecycle.vue
 delete mode 100644 test/weex/cases/recycle-list/components/stateful-v-model.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/components/stateful-v-model.vue
 delete mode 100644 test/weex/cases/recycle-list/components/stateful.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/components/stateful.vue
 delete mode 100644 test/weex/cases/recycle-list/components/stateless-multi-components.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/components/stateless-multi-components.vue
 delete mode 100644 test/weex/cases/recycle-list/components/stateless-with-props.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/components/stateless-with-props.vue
 delete mode 100644 test/weex/cases/recycle-list/components/stateless.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/components/stateless.vue
 delete mode 100644 test/weex/cases/recycle-list/inline-style.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/inline-style.vue
 delete mode 100644 test/weex/cases/recycle-list/text-node.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/text-node.vue
 delete mode 100644 test/weex/cases/recycle-list/v-else-if.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-else-if.vue
 delete mode 100644 test/weex/cases/recycle-list/v-else.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-else.vue
 delete mode 100644 test/weex/cases/recycle-list/v-for-iterator.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-for-iterator.vue
 delete mode 100644 test/weex/cases/recycle-list/v-for.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-for.vue
 delete mode 100644 test/weex/cases/recycle-list/v-if.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-if.vue
 delete mode 100644 test/weex/cases/recycle-list/v-on-inline.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-on-inline.vue
 delete mode 100644 test/weex/cases/recycle-list/v-on.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-on.vue
 delete mode 100644 test/weex/cases/recycle-list/v-once.vdom.ts
 delete mode 100644 test/weex/cases/recycle-list/v-once.vue
 delete mode 100644 test/weex/cases/render/class.vdom.ts
 delete mode 100644 test/weex/cases/render/class.vue
 delete mode 100644 test/weex/cases/render/sample.vdom.ts
 delete mode 100644 test/weex/cases/render/sample.vue
 delete mode 100644 test/weex/compiler/append.spec.ts
 delete mode 100644 test/weex/compiler/class.spec.ts
 delete mode 100644 test/weex/compiler/compile.spec.ts
 delete mode 100644 test/weex/compiler/parser.spec.ts
 delete mode 100644 test/weex/compiler/props.spec.ts
 delete mode 100644 test/weex/compiler/style.spec.ts
 delete mode 100644 test/weex/compiler/v-model.spec.ts
 delete mode 100644 test/weex/helpers/index.ts
 delete mode 100644 test/weex/runtime/attrs.spec.ts
 delete mode 100644 test/weex/runtime/class.spec.ts
 delete mode 100644 test/weex/runtime/components/richtext.spec.ts
 delete mode 100644 test/weex/runtime/events.spec.ts
 delete mode 100644 test/weex/runtime/framework.spec.ts
 delete mode 100644 test/weex/runtime/node.spec.ts
 delete mode 100644 test/weex/runtime/style.spec.ts
 delete mode 100644 typescript/weex.d.ts

diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index 347a369b2fb..00000000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,131 +0,0 @@
-version: 2
-
-defaults: &defaults
-  working_directory: ~/project/vue
-  docker:
-    - image: node:lts
-
-jobs:
-  install:
-    <<: *defaults
-    steps:
-      - checkout
-      - restore_cache:
-          keys:
-            - v1-vue-{{ .Branch }}-{{ checksum "yarn.lock" }}
-            - v1-vue-{{ .Branch }}-
-            - v1-vue-
-
-      - run: npm install
-      - save_cache:
-          key: v1-vue-{{ .Branch }}-{{ checksum "yarn.lock" }}
-          paths:
-            - node_modules/
-      - persist_to_workspace:
-          root: ~/project
-          paths:
-            - vue
-
-  lint-ts-types:
-    <<: *defaults
-    steps:
-      - attach_workspace:
-          at: ~/project
-      - run: npm run lint
-      - run: npm run ts-check
-      - run: npm run test:types
-
-  test-cover:
-    <<: *defaults
-    steps:
-      - attach_workspace:
-          at: ~/project
-      - run: npm run test:cover
-      - run:
-          name: report coverage stats for non-PRs
-          command: |
-            if [[ -z $CI_PULL_REQUEST ]]; then
-              ./node_modules/.bin/codecov
-            fi
-
-  test-e2e:
-    <<: *defaults
-    steps:
-      - attach_workspace:
-          at: ~/project
-      - run: npm run test:e2e -- --env phantomjs
-
-  test-ssr-weex:
-    <<: *defaults
-    steps:
-      - attach_workspace:
-          at: ~/project
-      - run: npm run test:ssr
-      - run: npm run test:weex
-
-  trigger-regression-test:
-    <<: *defaults
-    steps:
-      - run:
-          command: |
-            curl --user ${CIRCLE_TOKEN}: \
-            --data build_parameters[CIRCLE_JOB]=update \
-            --data build_parameters[VUE_REVISION]=${CIRCLE_SHA1} \
-            https://circleci.com/api/v1.1/project/github/vuejs/regression-testing/tree/master
-
-workflows:
-  version: 2
-  install-and-parallel-test:
-    jobs:
-      - install
-      - test-cover:
-          requires:
-            - install
-      - lint-ts-types:
-          requires:
-            - install
-      - test-e2e:
-          requires:
-            - install
-      - test-ssr-weex:
-          requires:
-            - install
-      - trigger-regression-test:
-          filters:
-            branches:
-              only:
-                - "2.6"
-                - regression-test
-          requires:
-            - test-cover
-            - lint-ts-types
-            - test-e2e
-            - test-ssr-weex
-  weekly_regression_test:
-    triggers:
-      - schedule:
-          # At 13:00 UTC (9:00 EDT) on every Monday
-          cron: "0 13 * * 1"
-          filters:
-            branches:
-              only: dev
-    jobs:
-      - install
-      - test-cover:
-          requires:
-            - install
-      - lint-ts-types:
-          requires:
-            - install
-      - test-e2e:
-          requires:
-            - install
-      - test-ssr-weex:
-          requires:
-            - install
-      - trigger-regression-test:
-          requires:
-            - test-cover
-            - lint-ts-types
-            - test-e2e
-            - test-ssr-weex
diff --git a/.flowconfig b/.flowconfig
deleted file mode 100644
index 9be4d7f3ee9..00000000000
--- a/.flowconfig
+++ /dev/null
@@ -1,23 +0,0 @@
-[ignore]
-.*/node_modules/.*
-.*/test/.*
-.*/scripts/.*
-.*/examples/.*
-.*/benchmarks/.*
-
-[include]
-
-[libs]
-flow
-
-[options]
-# unsafe.enable_getters_and_setters=true
-module.name_mapper='^compiler/\(.*\)$' -> '<PROJECT_ROOT>/src/compiler/\1'
-module.name_mapper='^core/\(.*\)$' -> '<PROJECT_ROOT>/src/core/\1'
-module.name_mapper='^shared/\(.*\)$' -> '<PROJECT_ROOT>/src/shared/\1'
-module.name_mapper='^web/\(.*\)$' -> '<PROJECT_ROOT>/src/platforms/web/\1'
-module.name_mapper='^weex/\(.*\)$' -> '<PROJECT_ROOT>/src/platforms/weex/\1'
-module.name_mapper='^server/\(.*\)$' -> '<PROJECT_ROOT>/src/server/\1'
-module.name_mapper='^entries/\(.*\)$' -> '<PROJECT_ROOT>/src/entries/\1'
-module.name_mapper='^sfc/\(.*\)$' -> '<PROJECT_ROOT>/src/sfc/\1'
-# suppress_comment= \\(.\\|\n\\)*\\$flow-disable-line
diff --git a/package.json b/package.json
index 59aacd5df7c..cbf67b2f71d 100644
--- a/package.json
+++ b/package.json
@@ -20,27 +20,16 @@
     "dev:test": "karma start test/unit/karma.dev.config.ts",
     "dev:ssr": "rollup -w -c scripts/config.js --environment TARGET:web-server-renderer",
     "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:web-compiler ",
-    "dev:weex": "rollup -w -c scripts/config.js --environment TARGET:weex-framework",
-    "dev:weex:factory": "rollup -w -c scripts/config.js --environment TARGET:weex-factory",
-    "dev:weex:compiler": "rollup -w -c scripts/config.js --environment TARGET:weex-compiler ",
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
-    "build:weex": "npm run build -- weex",
-    "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
-    "test:dtw": "npm run lint && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr && npm run test:weex",
-    "test:unit": "karma start test/unit/karma.unit.config.ts",
-    "test:cover": "karma start test/unit/karma.cover.config.ts",
+    "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr",
+    "test:unit": "vitest run",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.ts",
-    "test:weex": "npm run build:weex && jasmine-ts JASMINE_CONFIG_PATH=test/weex/jasmine.ts",
-    "test:ssr": "npm run build:ssr && jasmine JASMINE_CONFIG_PATH=test/ssr/jasmine.ts",
-    "test:sauce": "npm run sauce -- 0 && npm run sauce -- 1 && npm run sauce -- 2",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
     "ts-check": "tsc --noEmit",
-    "sauce": "karma start test/unit/karma.sauce.config.ts",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
     "release": "bash scripts/release.sh",
-    "release:weex": "bash scripts/release-weex.sh",
     "release:note": "node scripts/gen-release-note.js",
     "commit": "git-cz"
   },
@@ -110,8 +99,6 @@
     "typescript": "^4.6.4",
     "vitest": "^0.12.6",
     "webpack": "^5.72.1",
-    "weex-js-runtime": "^0.23.6",
-    "weex-styler": "^0.3.0",
     "yorkie": "^2.0.0"
   },
   "config": {
diff --git a/packages/vue-template-compiler/types/index.d.ts b/packages/vue-template-compiler/types/index.d.ts
index d84b3af678e..e2b603f025b 100644
--- a/packages/vue-template-compiler/types/index.d.ts
+++ b/packages/vue-template-compiler/types/index.d.ts
@@ -160,9 +160,6 @@ export interface ASTElement {
 
   // 2.4 ssr optimization
   ssrOptimizability?: SSROptimizability;
-
-  // weex specific
-  appendAsTree?: boolean;
 }
 
 export interface ASTExpression {
diff --git a/packages/weex-template-compiler/README.md b/packages/weex-template-compiler/README.md
deleted file mode 100644
index 6ebca962fcc..00000000000
--- a/packages/weex-template-compiler/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# weex-template-compiler
-
-> This package is auto-generated. For pull requests please see [src/platforms/weex/entry-compiler.js](https://github.com/vuejs/vue/tree/dev/src/platforms/weex/entry-compiler.js).
diff --git a/packages/weex-template-compiler/build.js b/packages/weex-template-compiler/build.js
deleted file mode 100644
index 68976949e79..00000000000
--- a/packages/weex-template-compiler/build.js
+++ /dev/null
@@ -1,4958 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var he = _interopDefault(require('he'));
-
-/*  */
-
-var emptyObject = Object.freeze({});
-
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef (v) {
-  return v === undefined || v === null
-}
-
-/**
- * Check if value is primitive.
- */
-function isPrimitive (value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
-}
-
-/**
- * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject (obj) {
-  return obj !== null && typeof obj === 'object'
-}
-
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-var _toString = Object.prototype.toString;
-
-function toRawType (value) {
-  return _toString.call(value).slice(8, -1)
-}
-
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject (obj) {
-  return _toString.call(obj) === '[object Object]'
-}
-
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex (val) {
-  var n = parseFloat(String(val));
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
-}
-
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap (
-  str,
-  expectsLowerCase
-) {
-  var map = Object.create(null);
-  var list = str.split(',');
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase
-    ? function (val) { return map[val.toLowerCase()]; }
-    : function (val) { return map[val]; }
-}
-
-/**
- * Check if a tag is a built-in tag.
- */
-var isBuiltInTag = makeMap('slot,component', true);
-
-/**
- * Check if an attribute is a reserved attribute.
- */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-
-/**
- * Remove an item from an array.
- */
-function remove (arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item);
-    if (index > -1) {
-      return arr.splice(index, 1)
-    }
-  }
-}
-
-/**
- * Check whether an object has the property.
- */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn (obj, key) {
-  return hasOwnProperty.call(obj, key)
-}
-
-/**
- * Create a cached version of a pure function.
- */
-function cached (fn) {
-  var cache = Object.create(null);
-  return (function cachedFn (str) {
-    var hit = cache[str];
-    return hit || (cache[str] = fn(str))
-  })
-}
-
-/**
- * Camelize a hyphen-delimited string.
- */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
-});
-
-/**
- * Hyphenate a camelCase string.
- */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
-});
-
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-
-/* istanbul ignore next */
-function polyfillBind (fn, ctx) {
-  function boundFn (a) {
-    var l = arguments.length;
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length;
-  return boundFn
-}
-
-function nativeBind (fn, ctx) {
-  return fn.bind(ctx)
-}
-
-var bind = Function.prototype.bind
-  ? nativeBind
-  : polyfillBind;
-
-/**
- * Mix properties into target object.
- */
-function extend (to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key];
-  }
-  return to
-}
-
-/* eslint-disable no-unused-vars */
-
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop (a, b, c) {}
-
-/**
- * Always return false.
- */
-var no = function (a, b, c) { return false; };
-
-/* eslint-enable no-unused-vars */
-
-/**
- * Return the same value.
- */
-var identity = function (_) { return _; };
-
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys (modules) {
-  return modules.reduce(function (keys, m) {
-    return keys.concat(m.staticKeys || [])
-  }, []).join(',')
-}
-
-/*  */
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-  'link,meta,param,source,track,wbr'
-);
-
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-);
-
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-  'title,tr,track'
-);
-
-/*  */
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-
-/**
- * Define a property.
- */
-function def (obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  });
-}
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-
-// Regular Expressions for parsing tags and attributes
-var attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/;
-var ncname = "[a-zA-Z_][\\-\\.0-9_a-zA-Z" + (unicodeRegExp.source) + "]*";
-var qnameCapture = "((?:" + ncname + "\\:)?" + ncname + ")";
-var startTagOpen = new RegExp(("^<" + qnameCapture));
-var startTagClose = /^\s*(\/?)>/;
-var endTag = new RegExp(("^<\\/" + qnameCapture + "[^>]*>"));
-var doctype = /^<!DOCTYPE [^>]+>/i;
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/;
-var conditionalComment = /^<!\[/;
-
-// Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true);
-var reCache = {};
-
-var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
-};
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;
-
-// #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true);
-var shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'; };
-
-function decodeAttr (value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;
-  return value.replace(re, function (match) { return decodingMap[match]; })
-}
-
-function parseHTML (html, options) {
-  var stack = [];
-  var expectHTML = options.expectHTML;
-  var isUnaryTag$$1 = options.isUnaryTag || no;
-  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;
-  var index = 0;
-  var last, lastTag;
-  while (html) {
-    last = html;
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<');
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->');
-
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);
-            }
-            advance(commentEnd + 3);
-            continue
-          }
-        }
-
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>');
-
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2);
-            continue
-          }
-        }
-
-        // Doctype:
-        var doctypeMatch = html.match(doctype);
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length);
-          continue
-        }
-
-        // End tag:
-        var endTagMatch = html.match(endTag);
-        if (endTagMatch) {
-          var curIndex = index;
-          advance(endTagMatch[0].length);
-          parseEndTag(endTagMatch[1], curIndex, index);
-          continue
-        }
-
-        // Start tag:
-        var startTagMatch = parseStartTag();
-        if (startTagMatch) {
-          handleStartTag(startTagMatch);
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1);
-          }
-          continue
-        }
-      }
-
-      var text = (void 0), rest = (void 0), next = (void 0);
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd);
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1);
-          if (next < 0) { break }
-          textEnd += next;
-          rest = html.slice(textEnd);
-        }
-        text = html.substring(0, textEnd);
-      }
-
-      if (textEnd < 0) {
-        text = html;
-      }
-
-      if (text) {
-        advance(text.length);
-      }
-
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index);
-      }
-    } else {
-      var endTagLength = 0;
-      var stackedTag = lastTag.toLowerCase();
-      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));
-      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength = endTag.length;
-        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
-        }
-        if (shouldIgnoreFirstNewline(stackedTag, text)) {
-          text = text.slice(1);
-        }
-        if (options.chars) {
-          options.chars(text);
-        }
-        return ''
-      });
-      index += html.length - rest$1.length;
-      html = rest$1;
-      parseEndTag(stackedTag, index - endTagLength, index);
-    }
-
-    if (html === last) {
-      options.chars && options.chars(html);
-      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {
-        options.warn(("Mal-formatted tag at end of template: \"" + html + "\""), { start: index + html.length });
-      }
-      break
-    }
-  }
-
-  // Clean up any remaining tags
-  parseEndTag();
-
-  function advance (n) {
-    index += n;
-    html = html.substring(n);
-  }
-
-  function parseStartTag () {
-    var start = html.match(startTagOpen);
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      };
-      advance(start[0].length);
-      var end, attr;
-      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {
-        attr.start = index;
-        advance(attr[0].length);
-        attr.end = index;
-        match.attrs.push(attr);
-      }
-      if (end) {
-        match.unarySlash = end[1];
-        advance(end[0].length);
-        match.end = index;
-        return match
-      }
-    }
-  }
-
-  function handleStartTag (match) {
-    var tagName = match.tagName;
-    var unarySlash = match.unarySlash;
-
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag);
-      }
-      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-        parseEndTag(tagName);
-      }
-    }
-
-    var unary = isUnaryTag$$1(tagName) || !!unarySlash;
-
-    var l = match.attrs.length;
-    var attrs = new Array(l);
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i];
-      var value = args[3] || args[4] || args[5] || '';
-      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'
-        ? options.shouldDecodeNewlinesForHref
-        : options.shouldDecodeNewlines;
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      };
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length;
-        attrs[i].end = args.end;
-      }
-    }
-
-    if (!unary) {
-      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-      lastTag = tagName;
-    }
-
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end);
-    }
-  }
-
-  function parseEndTag (tagName, start, end) {
-    var pos, lowerCasedTagName;
-    if (start == null) { start = index; }
-    if (end == null) { end = index; }
-
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase();
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0;
-    }
-
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            ("tag <" + (stack[i].tag) + "> has no matching end tag."),
-            { start: stack[i].start, end: stack[i].end }
-          );
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end);
-        }
-      }
-
-      // Remove the open elements from the stack
-      stack.length = pos;
-      lastTag = pos && stack[pos - 1].tag;
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end);
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end);
-      }
-      if (options.end) {
-        options.end(tagName, start, end);
-      }
-    }
-  }
-}
-
-/*  */
-
-var validDivisionCharRE = /[\w).+\-_$\]]/;
-
-function parseFilters (exp) {
-  var inSingle = false;
-  var inDouble = false;
-  var inTemplateString = false;
-  var inRegex = false;
-  var curly = 0;
-  var square = 0;
-  var paren = 0;
-  var lastFilterIndex = 0;
-  var c, prev, i, expression, filters;
-
-  for (i = 0; i < exp.length; i++) {
-    prev = c;
-    c = exp.charCodeAt(i);
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }
-    } else if (
-      c === 0x7C && // pipe
-      exp.charCodeAt(i + 1) !== 0x7C &&
-      exp.charCodeAt(i - 1) !== 0x7C &&
-      !curly && !square && !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1;
-        expression = exp.slice(0, i).trim();
-      } else {
-        pushFilter();
-      }
-    } else {
-      switch (c) {
-        case 0x22: inDouble = true; break         // "
-        case 0x27: inSingle = true; break         // '
-        case 0x60: inTemplateString = true; break // `
-        case 0x28: paren++; break                 // (
-        case 0x29: paren--; break                 // )
-        case 0x5B: square++; break                // [
-        case 0x5D: square--; break                // ]
-        case 0x7B: curly++; break                 // {
-        case 0x7D: curly--; break                 // }
-      }
-      if (c === 0x2f) { // /
-        var j = i - 1;
-        var p = (void 0);
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j);
-          if (p !== ' ') { break }
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true;
-        }
-      }
-    }
-  }
-
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim();
-  } else if (lastFilterIndex !== 0) {
-    pushFilter();
-  }
-
-  function pushFilter () {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-    lastFilterIndex = i + 1;
-  }
-
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i]);
-    }
-  }
-
-  return expression
-}
-
-function wrapFilter (exp, filter) {
-  var i = filter.indexOf('(');
-  if (i < 0) {
-    // _f: resolveFilter
-    return ("_f(\"" + filter + "\")(" + exp + ")")
-  } else {
-    var name = filter.slice(0, i);
-    var args = filter.slice(i + 1);
-    return ("_f(\"" + name + "\")(" + exp + (args !== ')' ? ',' + args : args))
-  }
-}
-
-/*  */
-
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g;
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g;
-
-var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&');
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&');
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-});
-
-
-
-function parseText (
-  text,
-  delimiters
-) {
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = [];
-  var rawTokens = [];
-  var lastIndex = tagRE.lastIndex = 0;
-  var match, index, tokenValue;
-  while ((match = tagRE.exec(text))) {
-    index = match.index;
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push(tokenValue = text.slice(lastIndex, index));
-      tokens.push(JSON.stringify(tokenValue));
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim());
-    tokens.push(("_s(" + exp + ")"));
-    rawTokens.push({ '@binding': exp });
-    lastIndex = index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push(tokenValue = text.slice(lastIndex));
-    tokens.push(JSON.stringify(tokenValue));
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
-
-/*  */
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var number = ref.number;
-  var trim = ref.trim;
-
-  var baseValueExpression = '$$v';
-  var valueExpression = baseValueExpression;
-  if (trim) {
-    valueExpression =
-      "(typeof " + baseValueExpression + " === 'string'" +
-      "? " + baseValueExpression + ".trim()" +
-      ": " + baseValueExpression + ")";
-  }
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-  var assignment = genAssignmentCode(value, valueExpression);
-
-  el.model = {
-    value: ("(" + value + ")"),
-    expression: JSON.stringify(value),
-    callback: ("function (" + baseValueExpression + ") {" + assignment + "}")
-  };
-}
-
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode (
-  value,
-  assignment
-) {
-  var res = parseModel(value);
-  if (res.key === null) {
-    return (value + "=" + assignment)
-  } else {
-    return ("$set(" + (res.exp) + ", " + (res.key) + ", " + assignment + ")")
-  }
-}
-
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-
-var len, str, chr, index, expressionPos, expressionEndPos;
-
-
-
-function parseModel (val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim();
-  len = val.length;
-
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.');
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-
-  str = val;
-  index = expressionPos = expressionEndPos = 0;
-
-  while (!eof()) {
-    chr = next();
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr);
-    } else if (chr === 0x5B) {
-      parseBracket(chr);
-    }
-  }
-
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
-}
-
-function next () {
-  return str.charCodeAt(++index)
-}
-
-function eof () {
-  return index >= len
-}
-
-function isStringStart (chr) {
-  return chr === 0x22 || chr === 0x27
-}
-
-function parseBracket (chr) {
-  var inBracket = 1;
-  expressionPos = index;
-  while (!eof()) {
-    chr = next();
-    if (isStringStart(chr)) {
-      parseString(chr);
-      continue
-    }
-    if (chr === 0x5B) { inBracket++; }
-    if (chr === 0x5D) { inBracket--; }
-    if (inBracket === 0) {
-      expressionEndPos = index;
-      break
-    }
-  }
-}
-
-function parseString (chr) {
-  var stringQuote = chr;
-  while (!eof()) {
-    chr = next();
-    if (chr === stringQuote) {
-      break
-    }
-  }
-}
-
-/*  */
-
-// can we use __proto__?
-var hasProto = '__proto__' in {};
-
-// Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-var inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
-var isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');
-var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
-var isPhantomJS = UA && /phantomjs/.test(UA);
-var isFF = UA && UA.match(/firefox\/(\d+)/);
-
-// Firefox has a "watch" function on Object.prototype...
-var nativeWatch = ({}).watch;
-if (inBrowser) {
-  try {
-    var opts = {};
-    Object.defineProperty(opts, 'passive', ({
-      get: function get () {
-      }
-    })); // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts);
-  } catch (e) {}
-}
-
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';
-    } else {
-      _isServer = false;
-    }
-  }
-  return _isServer
-};
-
-// detect devtools
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-
-/* istanbul ignore next */
-function isNative (Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-
-var hasSymbol =
-  typeof Symbol !== 'undefined' && isNative(Symbol) &&
-  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
-
-var _Set;
-/* istanbul ignore if */ // $flow-disable-line
-if (typeof Set !== 'undefined' && isNative(Set)) {
-  // use native Set when available.
-  _Set = Set;
-} else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  _Set = /*@__PURE__*/(function () {
-    function Set () {
-      this.set = Object.create(null);
-    }
-    Set.prototype.has = function has (key) {
-      return this.set[key] === true
-    };
-    Set.prototype.add = function add (key) {
-      this.set[key] = true;
-    };
-    Set.prototype.clear = function clear () {
-      this.set = Object.create(null);
-    };
-
-    return Set;
-  }());
-}
-
-/*  */
-
-
-
-/* eslint-disable no-unused-vars */
-function baseWarn (msg, range) {
-  console.error(("[Vue compiler]: " + msg));
-}
-/* eslint-enable no-unused-vars */
-
-function pluckModuleFunction (
-  modules,
-  key
-) {
-  return modules
-    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })
-    : []
-}
-
-function addProp (el, name, value, range, dynamic) {
-  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
-}
-
-function addAttr (el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? (el.dynamicAttrs || (el.dynamicAttrs = []))
-    : (el.attrs || (el.attrs = []));
-  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));
-  el.plain = false;
-}
-
-// add a raw attr (use this in preTransforms)
-function addRawAttr (el, name, value, range) {
-  el.attrsMap[name] = value;
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));
-}
-
-function addDirective (
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  (el.directives || (el.directives = [])).push(rangeSetItem({
-    name: name,
-    rawName: rawName,
-    value: value,
-    arg: arg,
-    isDynamicArg: isDynamicArg,
-    modifiers: modifiers
-  }, range));
-  el.plain = false;
-}
-
-function prependModifierMarker (symbol, name, dynamic) {
-  return dynamic
-    ? ("_p(" + name + ",\"" + symbol + "\")")
-    : symbol + name // mark the event as captured
-}
-
-function addHandler (
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject;
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' && warn &&
-    modifiers.prevent && modifiers.passive
-  ) {
-    warn(
-      'passive and prevent can\'t be used together. ' +
-      'Passive handler can\'t prevent default event.',
-      range
-    );
-  }
-
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'contextmenu':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'contextmenu';
-      delete modifiers.right;
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-    } else if (name === 'click') {
-      name = 'mouseup';
-    }
-  }
-
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture;
-    name = prependModifierMarker('!', name, dynamic);
-  }
-  if (modifiers.once) {
-    delete modifiers.once;
-    name = prependModifierMarker('~', name, dynamic);
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive;
-    name = prependModifierMarker('&', name, dynamic);
-  }
-
-  var events;
-  if (modifiers.native) {
-    delete modifiers.native;
-    events = el.nativeEvents || (el.nativeEvents = {});
-  } else {
-    events = el.events || (el.events = {});
-  }
-
-  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers;
-  }
-
-  var handlers = events[name];
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler);
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];
-  } else {
-    events[name] = newHandler;
-  }
-
-  el.plain = false;
-}
-
-function getRawBindingAttr (
-  el,
-  name
-) {
-  return el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-}
-
-function getBindingAttr (
-  el,
-  name,
-  getStatic
-) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) ||
-    getAndRemoveAttr(el, 'v-bind:' + name);
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name);
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
-}
-
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr (
-  el,
-  name,
-  removeFromMap
-) {
-  var val;
-  if ((val = el.attrsMap[name]) != null) {
-    var list = el.attrsList;
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1);
-        break
-      }
-    }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name];
-  }
-  return val
-}
-
-function getAndRemoveAttrByRegex (
-  el,
-  name
-) {
-  var list = el.attrsList;
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i];
-    if (name.test(attr.name)) {
-      list.splice(i, 1);
-      return attr
-    }
-  }
-}
-
-function rangeSetItem (
-  item,
-  range
-) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start;
-    }
-    if (range.end != null) {
-      item.end = range.end;
-    }
-  }
-  return item
-}
-
-/*  */
-
-var onRE = /^@|^v-on:/;
-var dirRE = /^v-|^@|^:|^#/;
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-var stripParensRE = /^\(|\)$/g;
-var dynamicArgRE = /^\[.*\]$/;
-
-var argRE = /:(.*)$/;
-var bindRE = /^:|^\.|^v-bind:/;
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g;
-
-var slotRE = /^v-slot(:|$)|^#/;
-
-var lineBreakRE = /[\r\n]/;
-var whitespaceRE = /\s+/g;
-
-var invalidAttributeRE = /[\s"'<>\/=]/;
-
-var decodeHTMLCached = cached(he.decode);
-
-var emptySlotScopeToken = "_empty_";
-
-// configurable state
-var warn;
-var delimiters;
-var transforms;
-var preTransforms;
-var postTransforms;
-var platformIsPreTag;
-var platformMustUseProp;
-var platformGetTagNamespace;
-var maybeComponent;
-
-function createASTElement (
-  tag,
-  attrs,
-  parent
-) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
-}
-
-/**
- * Convert HTML string to AST.
- */
-function parse (
-  template,
-  options
-) {
-  warn = options.warn || baseWarn;
-
-  platformIsPreTag = options.isPreTag || no;
-  platformMustUseProp = options.mustUseProp || no;
-  platformGetTagNamespace = options.getTagNamespace || no;
-  var isReservedTag = options.isReservedTag || no;
-  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-
-  transforms = pluckModuleFunction(options.modules, 'transformNode');
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');
-
-  delimiters = options.delimiters;
-
-  var stack = [];
-  var preserveWhitespace = options.preserveWhitespace !== false;
-  var whitespaceOption = options.whitespace;
-  var root;
-  var currentParent;
-  var inVPre = false;
-  var inPre = false;
-  var warned = false;
-
-  function warnOnce (msg, range) {
-    if (!warned) {
-      warned = true;
-      warn(msg, range);
-    }
-  }
-
-  function closeElement (element) {
-    trimEndingWhitespace(element);
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options);
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element);
-        }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        });
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          "Component template should contain exactly one root element. " +
-          "If you are using v-if on multiple elements, " +
-          "use v-else-if to chain them instead.",
-          { start: element.start }
-        );
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent);
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;
-        }
-        currentParent.children.push(element);
-        element.parent = currentParent;
-      }
-    }
-
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) { return !(c).slotScope; });
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element);
-
-    // check pre state
-    if (element.pre) {
-      inVPre = false;
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false;
-    }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options);
-    }
-  }
-
-  function trimEndingWhitespace (el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode;
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop();
-      }
-    }
-  }
-
-  function checkRootConstraints (el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        "Cannot use <" + (el.tag) + "> as component root element because it may " +
-        'contain multiple nodes.',
-        { start: el.start }
-      );
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-        'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-
-  parseHTML(template, {
-    warn: warn,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function start (tag, attrs, unary, start$1, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);
-
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs);
-      }
-
-      var element = createASTElement(tag, attrs, currentParent);
-      if (ns) {
-        element.ns = ns;
-      }
-
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start$1;
-          element.end = end;
-          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {
-            cumulated[attr.name] = attr;
-            return cumulated
-          }, {});
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn(
-              "Invalid dynamic argument expression: attribute names cannot contain " +
-              "spaces, quotes, <, >, / or =.",
-              {
-                start: attr.start + attr.name.indexOf("["),
-                end: attr.start + attr.name.length
-              }
-            );
-          }
-        });
-      }
-
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true;
-        process.env.NODE_ENV !== 'production' && warn(
-          'Templates should only be responsible for mapping the state to the ' +
-          'UI. Avoid placing tags with side-effects in your templates, such as ' +
-          "<" + tag + ">" + ', as they will not be parsed.',
-          { start: element.start }
-        );
-      }
-
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element;
-      }
-
-      if (!inVPre) {
-        processPre(element);
-        if (element.pre) {
-          inVPre = true;
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true;
-      }
-      if (inVPre) {
-        processRawAttrs(element);
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element);
-        processIf(element);
-        processOnce(element);
-      }
-
-      if (!root) {
-        root = element;
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root);
-        }
-      }
-
-      if (!unary) {
-        currentParent = element;
-        stack.push(element);
-      } else {
-        closeElement(element);
-      }
-    },
-
-    end: function end (tag, start, end$1) {
-      var element = stack[stack.length - 1];
-      // pop stack
-      stack.length -= 1;
-      currentParent = stack[stack.length - 1];
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end$1;
-      }
-      closeElement(element);
-    },
-
-    chars: function chars (text, start, end) {
-      if (!currentParent) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            );
-          } else if ((text = text.trim())) {
-            warnOnce(
-              ("text \"" + text + "\" outside root element will be ignored."),
-              { start: start }
-            );
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children;
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = '';
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' ';
-        } else {
-          text = ' ';
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : '';
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ');
-        }
-        var res;
-        var child;
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          };
-        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {
-          child = {
-            type: 3,
-            text: text
-          };
-        }
-        if (child) {
-          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          children.push(child);
-        }
-      }
-    },
-    comment: function comment (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        };
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          child.start = start;
-          child.end = end;
-        }
-        currentParent.children.push(child);
-      }
-    }
-  });
-  return root
-}
-
-function processPre (el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true;
-  }
-}
-
-function processRawAttrs (el) {
-  var list = el.attrsList;
-  var len = list.length;
-  if (len) {
-    var attrs = el.attrs = new Array(len);
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      };
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start;
-        attrs[i].end = list[i].end;
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true;
-  }
-}
-
-function processElement (
-  element,
-  options
-) {
-  processKey(element);
-
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain = (
-    !element.key &&
-    !element.scopedSlots &&
-    !element.attrsList.length
-  );
-
-  processRef(element);
-  processSlotContent(element);
-  processSlotOutlet(element);
-  processComponent(element);
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element;
-  }
-  processAttrs(element);
-  return element
-}
-
-function processKey (el) {
-  var exp = getBindingAttr(el, 'key');
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn(
-          "<template> cannot be keyed. Place the key on real elements instead.",
-          getRawBindingAttr(el, 'key')
-        );
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1;
-        var parent = el.parent;
-        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {
-          warn(
-            "Do not use v-for index as key on <transition-group> children, " +
-            "this is the same as not using keys.",
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          );
-        }
-      }
-    }
-    el.key = exp;
-  }
-}
-
-function processRef (el) {
-  var ref = getBindingAttr(el, 'ref');
-  if (ref) {
-    el.ref = ref;
-    el.refInFor = checkInFor(el);
-  }
-}
-
-function processFor (el) {
-  var exp;
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp);
-    if (res) {
-      extend(el, res);
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        ("Invalid v-for expression: " + exp),
-        el.rawAttrsMap['v-for']
-      );
-    }
-  }
-}
-
-
-
-function parseFor (exp) {
-  var inMatch = exp.match(forAliasRE);
-  if (!inMatch) { return }
-  var res = {};
-  res.for = inMatch[2].trim();
-  var alias = inMatch[1].trim().replace(stripParensRE, '');
-  var iteratorMatch = alias.match(forIteratorRE);
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim();
-    res.iterator1 = iteratorMatch[1].trim();
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim();
-    }
-  } else {
-    res.alias = alias;
-  }
-  return res
-}
-
-function processIf (el) {
-  var exp = getAndRemoveAttr(el, 'v-if');
-  if (exp) {
-    el.if = exp;
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    });
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true;
-    }
-    var elseif = getAndRemoveAttr(el, 'v-else-if');
-    if (elseif) {
-      el.elseif = elseif;
-    }
-  }
-}
-
-function processIfConditions (el, parent) {
-  var prev = findPrevElement(parent.children);
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    });
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn(
-      "v-" + (el.elseif ? ('else-if="' + el.elseif + '"') : 'else') + " " +
-      "used on element <" + (el.tag) + "> without corresponding v-if.",
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    );
-  }
-}
-
-function findPrevElement (children) {
-  var i = children.length;
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn(
-          "text \"" + (children[i].text.trim()) + "\" between v-if and v-else(-if) " +
-          "will be ignored.",
-          children[i]
-        );
-      }
-      children.pop();
-    }
-  }
-}
-
-function addIfCondition (el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = [];
-  }
-  el.ifConditions.push(condition);
-}
-
-function processOnce (el) {
-  var once$$1 = getAndRemoveAttr(el, 'v-once');
-  if (once$$1 != null) {
-    el.once = true;
-  }
-}
-
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent (el) {
-  var slotScope;
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope');
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn(
-        "the \"scope\" attribute for scoped slots have been deprecated and " +
-        "replaced by \"slot-scope\" since 2.5. The new \"slot-scope\" attribute " +
-        "can also be used on plain elements in addition to <template> to " +
-        "denote scoped slots.",
-        el.rawAttrsMap['scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn(
-        "Ambiguous combined usage of slot-scope and v-for on <" + (el.tag) + "> " +
-        "(v-for takes higher priority). Use a wrapper <template> for the " +
-        "scoped slot to make it clearer.",
-        el.rawAttrsMap['slot-scope'],
-        true
-      );
-    }
-    el.slotScope = slotScope;
-  }
-
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot');
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget;
-    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));
-    }
-  }
-
-  // 2.6 v-slot syntax
-  {
-    if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn(
-              "<template v-slot> can only appear at the root level inside " +
-              "the receiving component",
-              el
-            );
-          }
-        }
-        var ref = getSlotName(slotBinding);
-        var name = ref.name;
-        var dynamic = ref.dynamic;
-        el.slotTarget = name;
-        el.slotTargetDynamic = dynamic;
-        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);
-      if (slotBinding$1) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn(
-              "v-slot can only be used on components or <template>.",
-              slotBinding$1
-            );
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn(
-              "Unexpected mixed usage of different slot syntaxes.",
-              el
-            );
-          }
-          if (el.scopedSlots) {
-            warn(
-              "To avoid scope ambiguity, the default slot should also use " +
-              "<template> syntax when there are other named slots.",
-              slotBinding$1
-            );
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {});
-        var ref$1 = getSlotName(slotBinding$1);
-        var name$1 = ref$1.name;
-        var dynamic$1 = ref$1.dynamic;
-        var slotContainer = slots[name$1] = createASTElement('template', [], el);
-        slotContainer.slotTarget = name$1;
-        slotContainer.slotTargetDynamic = dynamic$1;
-        slotContainer.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer;
-            return true
-          }
-        });
-        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;
-        // remove children as they are returned from scopedSlots now
-        el.children = [];
-        // mark el non-plain so data gets generated
-        el.plain = false;
-      }
-    }
-  }
-}
-
-function getSlotName (binding) {
-  var name = binding.name.replace(slotRE, '');
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default';
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn(
-        "v-slot shorthand syntax requires a slot name.",
-        binding
-      );
-    }
-  }
-  return dynamicArgRE.test(name)
-    // dynamic [name]
-    ? { name: name.slice(1, -1), dynamic: true }
-    // static name
-    : { name: ("\"" + name + "\""), dynamic: false }
-}
-
-// handle <slot/> outlets
-function processSlotOutlet (el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name');
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn(
-        "`key` does not work on <slot> because slots are abstract outlets " +
-        "and can possibly expand into multiple elements. " +
-        "Use the key on a wrapping element instead.",
-        getRawBindingAttr(el, 'key')
-      );
-    }
-  }
-}
-
-function processComponent (el) {
-  var binding;
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding;
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true;
-  }
-}
-
-function processAttrs (el) {
-  var list = el.attrsList;
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name;
-    value = list[i].value;
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true;
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''));
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '');
-      }
-      if (bindRE.test(name)) { // v-bind
-        name = name.replace(bindRE, '');
-        value = parseFilters(value);
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn(
-            ("The value for a v-bind expression cannot be empty. Found in \"v-bind:" + name + "\"")
-          );
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name);
-            if (name === 'innerHtml') { name = 'innerHTML'; }
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name);
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, "$event");
-            if (!isDynamic) {
-              addHandler(
-                el,
-                ("update:" + (camelize(name))),
-                syncGen,
-                null,
-                false,
-                warn,
-                list[i]
-              );
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  ("update:" + (hyphenate(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn,
-                  list[i]
-                );
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                ("\"update:\"+(" + name + ")"),
-                syncGen,
-                null,
-                false,
-                warn,
-                list[i],
-                true // dynamic
-              );
-            }
-          }
-        }
-        if ((modifiers && modifiers.prop) || (
-          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)
-        )) {
-          addProp(el, name, value, list[i], isDynamic);
-        } else {
-          addAttr(el, name, value, list[i], isDynamic);
-        }
-      } else if (onRE.test(name)) { // v-on
-        name = name.replace(onRE, '');
-        isDynamic = dynamicArgRE.test(name);
-        if (isDynamic) {
-          name = name.slice(1, -1);
-        }
-        addHandler(el, name, value, modifiers, false, warn, list[i], isDynamic);
-      } else { // normal directives
-        name = name.replace(dirRE, '');
-        // parse arg
-        var argMatch = name.match(argRE);
-        var arg = argMatch && argMatch[1];
-        isDynamic = false;
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1));
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1);
-            isDynamic = true;
-          }
-        }
-        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value);
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        var res = parseText(value, delimiters);
-        if (res) {
-          warn(
-            name + "=\"" + value + "\": " +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          );
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i]);
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (!el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)) {
-        addProp(el, name, 'true', list[i]);
-      }
-    }
-  }
-}
-
-function checkInFor (el) {
-  var parent = el;
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent;
-  }
-  return false
-}
-
-function parseModifiers (name) {
-  var match = name.match(modifierRE);
-  if (match) {
-    var ret = {};
-    match.forEach(function (m) { ret[m.slice(1)] = true; });
-    return ret
-  }
-}
-
-function makeAttrsMap (attrs) {
-  var map = {};
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] && !isIE && !isEdge
-    ) {
-      warn('duplicate attribute: ' + attrs[i].name, attrs[i]);
-    }
-    map[attrs[i].name] = attrs[i].value;
-  }
-  return map
-}
-
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag (el) {
-  return el.tag === 'script' || el.tag === 'style'
-}
-
-function isForbiddenTag (el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' && (
-      !el.attrsMap.type ||
-      el.attrsMap.type === 'text/javascript'
-    ))
-  )
-}
-
-var ieNSBug = /^xmlns:NS\d+/;
-var ieNSPrefix = /^NS\d+:/;
-
-/* istanbul ignore next */
-function guardIESVGBug (attrs) {
-  var res = [];
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i];
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '');
-      res.push(attr);
-    }
-  }
-  return res
-}
-
-function checkForAliasModel (el, value) {
-  var _el = el;
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn(
-        "<" + (el.tag) + " v-model=\"" + value + "\">: " +
-        "You are binding v-model directly to a v-for iteration alias. " +
-        "This will not be able to modify the v-for source array because " +
-        "writing to the alias is like modifying a function local variable. " +
-        "Consider using an array of objects and use v-model on an object property instead.",
-        el.rawAttrsMap['v-model']
-      );
-    }
-    _el = _el.parent;
-  }
-}
-
-/*  */
-
-var isStaticKey;
-var isPlatformReservedTag;
-
-var genStaticKeysCached = cached(genStaticKeys$1);
-
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize (root, options) {
-  if (!root) { return }
-  isStaticKey = genStaticKeysCached(options.staticKeys || '');
-  isPlatformReservedTag = options.isReservedTag || no;
-  // first pass: mark all non-static nodes.
-  markStatic(root);
-  // second pass: mark static roots.
-  markStaticRoots(root, false);
-}
-
-function genStaticKeys$1 (keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-    (keys ? ',' + keys : '')
-  )
-}
-
-function markStatic (node) {
-  node.static = isStatic(node);
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i];
-      markStatic(child);
-      if (!child.static) {
-        node.static = false;
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        var block = node.ifConditions[i$1].block;
-        markStatic(block);
-        if (!block.static) {
-          node.static = false;
-        }
-      }
-    }
-  }
-}
-
-function markStaticRoots (node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor;
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (node.static && node.children.length && !(
-      node.children.length === 1 &&
-      node.children[0].type === 3
-    )) {
-      node.staticRoot = true;
-      return
-    } else {
-      node.staticRoot = false;
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for);
-      }
-    }
-    if (node.ifConditions) {
-      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {
-        markStaticRoots(node.ifConditions[i$1].block, isInFor);
-      }
-    }
-  }
-}
-
-function isStatic (node) {
-  if (node.type === 2) { // expression
-    return false
-  }
-  if (node.type === 3) { // text
-    return true
-  }
-  return !!(node.pre || (
-    !node.hasBindings && // no dynamic bindings
-    !node.if && !node.for && // not v-if or v-for or v-else
-    !isBuiltInTag(node.tag) && // not a built-in
-    isPlatformReservedTag(node.tag) && // not a component
-    !isDirectChildOfTemplateFor(node) &&
-    Object.keys(node).every(isStaticKey)
-  ))
-}
-
-function isDirectChildOfTemplateFor (node) {
-  while (node.parent) {
-    node = node.parent;
-    if (node.tag !== 'template') {
-      return false
-    }
-    if (node.for) {
-      return true
-    }
-  }
-  return false
-}
-
-/*  */
-
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/;
-var fnInvokeRE = /\([^)]*?\);*$/;
-var simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/;
-
-// KeyboardEvent.keyCode aliases
-var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  'delete': [8, 46]
-};
-
-// KeyboardEvent.key aliases
-var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  'delete': ['Backspace', 'Delete', 'Del']
-};
-
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-var genGuard = function (condition) { return ("if(" + condition + ")return null;"); };
-
-var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard("$event.target !== $event.currentTarget"),
-  ctrl: genGuard("!$event.ctrlKey"),
-  shift: genGuard("!$event.shiftKey"),
-  alt: genGuard("!$event.altKey"),
-  meta: genGuard("!$event.metaKey"),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
-};
-
-function genHandlers (
-  events,
-  isNative
-) {
-  var prefix = isNative ? 'nativeOn:' : 'on:';
-  var staticHandlers = "";
-  var dynamicHandlers = "";
-  for (var name in events) {
-    var handlerCode = genHandler(events[name]);
-    if (events[name] && events[name].dynamic) {
-      dynamicHandlers += name + "," + handlerCode + ",";
-    } else {
-      staticHandlers += "\"" + name + "\":" + handlerCode + ",";
-    }
-  }
-  staticHandlers = "{" + (staticHandlers.slice(0, -1)) + "}";
-  if (dynamicHandlers) {
-    return prefix + "_d(" + staticHandlers + ",[" + (dynamicHandlers.slice(0, -1)) + "])"
-  } else {
-    return prefix + staticHandlers
-  }
-}
-
-// Generate handler code with binding params on Weex
-/* istanbul ignore next */
-function genWeexHandler (params, handlerCode) {
-  var innerHandlerCode = handlerCode;
-  var exps = params.filter(function (exp) { return simplePathRE.test(exp) && exp !== '$event'; });
-  var bindings = exps.map(function (exp) { return ({ '@binding': exp }); });
-  var args = exps.map(function (exp, i) {
-    var key = "$_" + (i + 1);
-    innerHandlerCode = innerHandlerCode.replace(exp, key);
-    return key
-  });
-  args.push('$event');
-  return '{\n' +
-    "handler:function(" + (args.join(',')) + "){" + innerHandlerCode + "},\n" +
-    "params:" + (JSON.stringify(bindings)) + "\n" +
-    '}'
-}
-
-function genHandler (handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-
-  if (Array.isArray(handler)) {
-    return ("[" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + "]")
-  }
-
-  var isMethodPath = simplePathRE.test(handler.value);
-  var isFunctionExpression = fnExpRE.test(handler.value);
-  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));
-
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    /* istanbul ignore if */
-    if (handler.params) {
-      return genWeexHandler(handler.params, handler.value)
-    }
-    return ("function($event){" + (isFunctionInvocation ? ("return " + (handler.value)) : handler.value) + "}") // inline statement
-  } else {
-    var code = '';
-    var genModifierCode = '';
-    var keys = [];
-    for (var key in handler.modifiers) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key];
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key);
-        }
-      } else if (key === 'exact') {
-        var modifiers = (handler.modifiers);
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) { return !modifiers[keyModifier]; })
-            .map(function (keyModifier) { return ("$event." + keyModifier + "Key"); })
-            .join('||')
-        );
-      } else {
-        keys.push(key);
-      }
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys);
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode;
-    }
-    var handlerCode = isMethodPath
-      ? ("return " + (handler.value) + "($event)")
-      : isFunctionExpression
-        ? ("return (" + (handler.value) + ")($event)")
-        : isFunctionInvocation
-          ? ("return " + (handler.value))
-          : handler.value;
-    /* istanbul ignore if */
-    if (handler.params) {
-      return genWeexHandler(handler.params, code + handlerCode)
-    }
-    return ("function($event){" + code + handlerCode + "}")
-  }
-}
-
-function genKeyFilter (keys) {
-  return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-    (keys.map(genFilterCode).join('&&')) + ")return null;"
-  )
-}
-
-function genFilterCode (key) {
-  var keyVal = parseInt(key, 10);
-  if (keyVal) {
-    return ("$event.keyCode!==" + keyVal)
-  }
-  var keyCode = keyCodes[key];
-  var keyName = keyNames[key];
-  return (
-    "_k($event.keyCode," +
-    (JSON.stringify(key)) + "," +
-    (JSON.stringify(keyCode)) + "," +
-    "$event.key," +
-    "" + (JSON.stringify(keyName)) +
-    ")"
-  )
-}
-
-var ASSET_TYPES = [
-  'component',
-  'directive',
-  'filter'
-];
-
-var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-];
-
-/*  */
-
-
-
-var config = ({
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-});
-
-/*  */
-
-var warn$1 = noop;
-var tip = noop;
-var generateComponentTrace = (noop); // work around flow check
-var formatComponentName = (noop);
-
-if (process.env.NODE_ENV !== 'production') {
-  var hasConsole = typeof console !== 'undefined';
-  var classifyRE = /(?:^|[-_])(\w)/g;
-  var classify = function (str) { return str
-    .replace(classifyRE, function (c) { return c.toUpperCase(); })
-    .replace(/[-_]/g, ''); };
-
-  warn$1 = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : '';
-
-    if (hasConsole && (!config.silent)) {
-      console.error(("[Vue warn]: " + msg + trace));
-    }
-  };
-
-  tip = function (msg, vm) {
-    if (hasConsole && (!config.silent)) {
-      console.warn("[Vue tip]: " + msg + (
-        vm ? generateComponentTrace(vm) : ''
-      ));
-    }
-  };
-
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options = typeof vm === 'function' && vm.cid != null
-      ? vm.options
-      : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm;
-    var name = options.name || options._componentTag;
-    var file = options.__file;
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/);
-      name = match && match[1];
-    }
-
-    return (
-      (name ? ("<" + (classify(name)) + ">") : "<Anonymous>") +
-      (file && includeFile !== false ? (" at " + file) : '')
-    )
-  };
-
-  var repeat = function (str, n) {
-    var res = '';
-    while (n) {
-      if (n % 2 === 1) { res += str; }
-      if (n > 1) { str += str; }
-      n >>= 1;
-    }
-    return res
-  };
-
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = [];
-      var currentRecursiveSequence = 0;
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1];
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++;
-            vm = vm.$parent;
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence];
-            currentRecursiveSequence = 0;
-          }
-        }
-        tree.push(vm);
-        vm = vm.$parent;
-      }
-      return '\n\nfound in\n\n' + tree
-        .map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
-            ? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
-            : formatComponentName(vm))); })
-        .join('\n')
-    } else {
-      return ("\n\n(found in " + (formatComponentName(vm)) + ")")
-    }
-  };
-}
-
-/*  */
-
-var uid = 0;
-
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-var Dep = function Dep () {
-  this.id = uid++;
-  this.subs = [];
-};
-
-Dep.prototype.addSub = function addSub (sub) {
-  this.subs.push(sub);
-};
-
-Dep.prototype.removeSub = function removeSub (sub) {
-  remove(this.subs, sub);
-};
-
-Dep.prototype.depend = function depend () {
-  if (Dep.target) {
-    Dep.target.addDep(this);
-  }
-};
-
-Dep.prototype.notify = function notify () {
-  // stabilize the subscriber list first
-  var subs = this.subs.slice();
-  if (process.env.NODE_ENV !== 'production' && !config.async) {
-    // subs aren't sorted in scheduler if not running async
-    // we need to sort them now to make sure they fire in correct
-    // order
-    subs.sort(function (a, b) { return a.id - b.id; });
-  }
-  for (var i = 0, l = subs.length; i < l; i++) {
-    subs[i].update();
-  }
-};
-
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-
-/*  */
-
-var VNode = function VNode (
-  tag,
-  data,
-  children,
-  text,
-  elm,
-  context,
-  componentOptions,
-  asyncFactory
-) {
-  this.tag = tag;
-  this.data = data;
-  this.children = children;
-  this.text = text;
-  this.elm = elm;
-  this.ns = undefined;
-  this.context = context;
-  this.fnContext = undefined;
-  this.fnOptions = undefined;
-  this.fnScopeId = undefined;
-  this.key = data && data.key;
-  this.componentOptions = componentOptions;
-  this.componentInstance = undefined;
-  this.parent = undefined;
-  this.raw = false;
-  this.isStatic = false;
-  this.isRootInsert = true;
-  this.isComment = false;
-  this.isCloned = false;
-  this.isOnce = false;
-  this.asyncFactory = asyncFactory;
-  this.asyncMeta = undefined;
-  this.isAsyncPlaceholder = false;
-};
-
-var prototypeAccessors = { child: { configurable: true } };
-
-// DEPRECATED: alias for componentInstance for backwards compat.
-/* istanbul ignore next */
-prototypeAccessors.child.get = function () {
-  return this.componentInstance
-};
-
-Object.defineProperties( VNode.prototype, prototypeAccessors );
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-
-var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-];
-
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method];
-  def(arrayMethods, method, function mutator () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    var result = original.apply(this, args);
-    var ob = this.__ob__;
-    var inserted;
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args;
-        break
-      case 'splice':
-        inserted = args.slice(2);
-        break
-    }
-    if (inserted) { ob.observeArray(inserted); }
-    // notify change
-    ob.dep.notify();
-    return result
-  });
-});
-
-/*  */
-
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-var shouldObserve = true;
-
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-var Observer = function Observer (value) {
-  this.value = value;
-  this.dep = new Dep();
-  this.vmCount = 0;
-  def(value, '__ob__', this);
-  if (Array.isArray(value)) {
-    if (hasProto) {
-      protoAugment(value, arrayMethods);
-    } else {
-      copyAugment(value, arrayMethods, arrayKeys);
-    }
-    this.observeArray(value);
-  } else {
-    this.walk(value);
-  }
-};
-
-/**
- * Walk through all properties and convert them into
- * getter/setters. This method should only be called when
- * value type is Object.
- */
-Observer.prototype.walk = function walk (obj) {
-  var keys = Object.keys(obj);
-  for (var i = 0; i < keys.length; i++) {
-    defineReactive$$1(obj, keys[i]);
-  }
-};
-
-/**
- * Observe a list of Array items.
- */
-Observer.prototype.observeArray = function observeArray (items) {
-  for (var i = 0, l = items.length; i < l; i++) {
-    observe(items[i]);
-  }
-};
-
-// helpers
-
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment (target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src;
-  /* eslint-enable no-proto */
-}
-
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment (target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i];
-    def(target, key, src[key]);
-  }
-}
-
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe (value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob;
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__;
-  } else if (
-    shouldObserve &&
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value);
-  }
-  if (asRootData && ob) {
-    ob.vmCount++;
-  }
-  return ob
-}
-
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive$$1 (
-  obj,
-  key,
-  val,
-  customSetter,
-  shallow
-) {
-  var dep = new Dep();
-
-  var property = Object.getOwnPropertyDescriptor(obj, key);
-  if (property && property.configurable === false) {
-    return
-  }
-
-  // cater for pre-defined getter/setters
-  var getter = property && property.get;
-  var setter = property && property.set;
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key];
-  }
-
-  var childOb = !shallow && observe(val);
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter () {
-      var value = getter ? getter.call(obj) : val;
-      if (Dep.target) {
-        dep.depend();
-        if (childOb) {
-          childOb.dep.depend();
-          if (Array.isArray(value)) {
-            dependArray(value);
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter (newVal) {
-      var value = getter ? getter.call(obj) : val;
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter();
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) { return }
-      if (setter) {
-        setter.call(obj, newVal);
-      } else {
-        val = newVal;
-      }
-      childOb = !shallow && observe(newVal);
-      dep.notify();
-    }
-  });
-}
-
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set (target, key, val) {
-  if (process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn$1(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key);
-    target.splice(key, 1, val);
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val;
-    return val
-  }
-  var ob = (target).__ob__;
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' && warn$1(
-      'Avoid adding reactive properties to a Vue instance or its root $data ' +
-      'at runtime - declare it upfront in the data option.'
-    );
-    return val
-  }
-  if (!ob) {
-    target[key] = val;
-    return val
-  }
-  defineReactive$$1(ob.value, key, val);
-  ob.dep.notify();
-  return val
-}
-
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray (value) {
-  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
-    e = value[i];
-    e && e.__ob__ && e.__ob__.dep.depend();
-    if (Array.isArray(e)) {
-      dependArray(e);
-    }
-  }
-}
-
-/*  */
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-var strats = config.optionMergeStrategies;
-
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn$1(
-        "option \"" + key + "\" can only be used during instance " +
-        'creation with the `new` keyword.'
-      );
-    }
-    return defaultStrat(parent, child)
-  };
-}
-
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData (to, from) {
-  if (!from) { return to }
-  var key, toVal, fromVal;
-
-  var keys = hasSymbol
-    ? Reflect.ownKeys(from)
-    : Object.keys(from);
-
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i];
-    // in case the object is already observed...
-    if (key === '__ob__') { continue }
-    toVal = to[key];
-    fromVal = from[key];
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal);
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal);
-    }
-  }
-  return to
-}
-
-/**
- * Data
- */
-function mergeDataOrFn (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn () {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn () {
-      // instance merge
-      var instanceData = typeof childVal === 'function'
-        ? childVal.call(vm, vm)
-        : childVal;
-      var defaultData = typeof parentVal === 'function'
-        ? parentVal.call(vm, vm)
-        : parentVal;
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-
-strats.data = function (
-  parentVal,
-  childVal,
-  vm
-) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' && warn$1(
-        'The "data" option should be a function ' +
-        'that returns a per-instance value in component ' +
-        'definitions.',
-        vm
-      );
-
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-
-  return mergeDataOrFn(parentVal, childVal, vm)
-};
-
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook (
-  parentVal,
-  childVal
-) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-    : parentVal;
-  return res
-    ? dedupeHooks(res)
-    : res
-}
-
-function dedupeHooks (hooks) {
-  var res = [];
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i]);
-    }
-  }
-  return res
-}
-
-LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook;
-});
-
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  var res = Object.create(parentVal || null);
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-    return extend(res, childVal)
-  } else {
-    return res
-  }
-}
-
-ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets;
-});
-
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  // work around Firefox's Object.prototype.watch...
-  if (parentVal === nativeWatch) { parentVal = undefined; }
-  if (childVal === nativeWatch) { childVal = undefined; }
-  /* istanbul ignore if */
-  if (!childVal) { return Object.create(parentVal || null) }
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = {};
-  extend(ret, parentVal);
-  for (var key$1 in childVal) {
-    var parent = ret[key$1];
-    var child = childVal[key$1];
-    if (parent && !Array.isArray(parent)) {
-      parent = [parent];
-    }
-    ret[key$1] = parent
-      ? parent.concat(child)
-      : Array.isArray(child) ? child : [child];
-  }
-  return ret
-};
-
-/**
- * Other object hashes.
- */
-strats.props =
-strats.methods =
-strats.inject =
-strats.computed = function (
-  parentVal,
-  childVal,
-  vm,
-  key
-) {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm);
-  }
-  if (!parentVal) { return childVal }
-  var ret = Object.create(null);
-  extend(ret, parentVal);
-  if (childVal) { extend(ret, childVal); }
-  return ret
-};
-strats.provide = mergeDataOrFn;
-
-/**
- * Default strategy.
- */
-var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined
-    ? parentVal
-    : childVal
-};
-
-function assertObjectType (name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn$1(
-      "Invalid value for option \"" + name + "\": expected an Object, " +
-      "but got " + (toRawType(value)) + ".",
-      vm
-    );
-  }
-}
-
-/*  */
-
-/*  */
-
-/*  */
-
-var callbacks = [];
-
-function flushCallbacks () {
-  var copies = callbacks.slice(0);
-  callbacks.length = 0;
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]();
-  }
-}
-
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) ; else if (!isIE && typeof MutationObserver !== 'undefined' && (
-  isNative(MutationObserver) ||
-  // PhantomJS and iOS 7.x
-  MutationObserver.toString() === '[object MutationObserverConstructor]'
-)) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter = 1;
-  var observer = new MutationObserver(flushCallbacks);
-  var textNode = document.createTextNode(String(counter));
-  observer.observe(textNode, {
-    characterData: true
-  });
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) ;
-
-/*  */
-
-/*  */
-
-function on (el, dir) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn$1("v-on without argument does not support modifiers.");
-  }
-  el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
-}
-
-/*  */
-
-function bind$1 (el, dir) {
-  el.wrapData = function (code) {
-    return ("_b(" + code + ",'" + (el.tag) + "'," + (dir.value) + "," + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + ")")
-  };
-}
-
-/*  */
-
-var baseDirectives = {
-  on: on,
-  bind: bind$1,
-  cloak: noop
-};
-
-/*  */
-
-
-
-
-
-var CodegenState = function CodegenState (options) {
-  this.options = options;
-  this.warn = options.warn || baseWarn;
-  this.transforms = pluckModuleFunction(options.modules, 'transformCode');
-  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');
-  this.directives = extend(extend({}, baseDirectives), options.directives);
-  var isReservedTag = options.isReservedTag || no;
-  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };
-  this.onceId = 0;
-  this.staticRenderFns = [];
-  this.pre = false;
-};
-
-
-
-function generate (
-  ast,
-  options
-) {
-  var state = new CodegenState(options);
-  var code = ast ? genElement(ast, state) : '_c("div")';
-  return {
-    render: ("with(this){return " + code + "}"),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-
-function genElement (el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre;
-  }
-
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code;
-    if (el.component) {
-      code = genComponent(el.component, el, state);
-    } else {
-      var data;
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData(el, state);
-      }
-
-      var children = el.inlineTemplate ? null : genChildren(el, state, true);
-      code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
-    }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code);
-    }
-    return code
-  }
-}
-
-// hoist static sub-trees out
-function genStatic (el, state) {
-  el.staticProcessed = true;
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre;
-  if (el.pre) {
-    state.pre = el.pre;
-  }
-  state.staticRenderFns.push(("with(this){return " + (genElement(el, state)) + "}"));
-  state.pre = originalPreState;
-  return ("_m(" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + ")")
-}
-
-// v-once
-function genOnce (el, state) {
-  el.onceProcessed = true;
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = '';
-    var parent = el.parent;
-    while (parent) {
-      if (parent.for) {
-        key = parent.key;
-        break
-      }
-      parent = parent.parent;
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' && state.warn(
-        "v-once can only be used inside v-for that is keyed. ",
-        el.rawAttrsMap['v-once']
-      );
-      return genElement(el, state)
-    }
-    return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
-  } else {
-    return genStatic(el, state)
-  }
-}
-
-function genIf (
-  el,
-  state,
-  altGen,
-  altEmpty
-) {
-  el.ifProcessed = true; // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-
-function genIfConditions (
-  conditions,
-  state,
-  altGen,
-  altEmpty
-) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-
-  var condition = conditions.shift();
-  if (condition.exp) {
-    return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
-  } else {
-    return ("" + (genTernaryExp(condition.block)))
-  }
-
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp (el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-  }
-}
-
-function genFor (
-  el,
-  state,
-  altGen,
-  altHelper
-) {
-  var exp = el.for;
-  var alias = el.alias;
-  var iterator1 = el.iterator1 ? ("," + (el.iterator1)) : '';
-  var iterator2 = el.iterator2 ? ("," + (el.iterator2)) : '';
-
-  if (process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      "<" + (el.tag) + " v-for=\"" + alias + " in " + exp + "\">: component lists rendered with " +
-      "v-for should have explicit keys. " +
-      "See https://vuejs.org/guide/list.html#key for more info.",
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    );
-  }
-
-  el.forProcessed = true; // avoid recursion
-  return (altHelper || '_l') + "((" + exp + ")," +
-    "function(" + alias + iterator1 + iterator2 + "){" +
-      "return " + ((altGen || genElement)(el, state)) +
-    '})'
-}
-
-function genData (el, state) {
-  var data = '{';
-
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state);
-  if (dirs) { data += dirs + ','; }
-
-  // key
-  if (el.key) {
-    data += "key:" + (el.key) + ",";
-  }
-  // ref
-  if (el.ref) {
-    data += "ref:" + (el.ref) + ",";
-  }
-  if (el.refInFor) {
-    data += "refInFor:true,";
-  }
-  // pre
-  if (el.pre) {
-    data += "pre:true,";
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += "tag:\"" + (el.tag) + "\",";
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el);
-  }
-  // attributes
-  if (el.attrs) {
-    data += "attrs:" + (genProps(el.attrs)) + ",";
-  }
-  // DOM props
-  if (el.props) {
-    data += "domProps:" + (genProps(el.props)) + ",";
-  }
-  // event handlers
-  if (el.events) {
-    data += (genHandlers(el.events, false)) + ",";
-  }
-  if (el.nativeEvents) {
-    data += (genHandlers(el.nativeEvents, true)) + ",";
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += "slot:" + (el.slotTarget) + ",";
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += (genScopedSlots(el, el.scopedSlots, state)) + ",";
-  }
-  // component v-model
-  if (el.model) {
-    data += "model:{value:" + (el.model.value) + ",callback:" + (el.model.callback) + ",expression:" + (el.model.expression) + "},";
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state);
-    if (inlineTemplate) {
-      data += inlineTemplate + ",";
-    }
-  }
-  data = data.replace(/,$/, '') + '}';
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = "_b(" + data + ",\"" + (el.tag) + "\"," + (genProps(el.dynamicAttrs)) + ")";
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data);
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data);
-  }
-  return data
-}
-
-function genDirectives (el, state) {
-  var dirs = el.directives;
-  if (!dirs) { return }
-  var res = 'directives:[';
-  var hasRuntime = false;
-  var i, l, dir, needRuntime;
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i];
-    needRuntime = true;
-    var gen = state.directives[dir.name];
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn);
-    }
-    if (needRuntime) {
-      hasRuntime = true;
-      res += "{name:\"" + (dir.name) + "\",rawName:\"" + (dir.rawName) + "\"" + (dir.value ? (",value:(" + (dir.value) + "),expression:" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (",arg:" + (dir.isDynamicArg ? dir.arg : ("\"" + (dir.arg) + "\""))) : '') + (dir.modifiers ? (",modifiers:" + (JSON.stringify(dir.modifiers))) : '') + "},";
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-
-function genInlineTemplate (el, state) {
-  var ast = el.children[0];
-  if (process.env.NODE_ENV !== 'production' && (
-    el.children.length !== 1 || ast.type !== 1
-  )) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    );
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate(ast, state.options);
-    return ("inlineTemplate:{render:function(){" + (inlineRenderFns.render) + "},staticRenderFns:[" + (inlineRenderFns.staticRenderFns.map(function (code) { return ("function(){" + code + "}"); }).join(',')) + "]}")
-  }
-}
-
-function genScopedSlots (
-  el,
-  slots,
-  state
-) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {
-    var slot = slots[key];
-    return (
-      slot.slotTargetDynamic ||
-      slot.if ||
-      slot.for ||
-      containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-    )
-  });
-
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if;
-
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent = el.parent;
-    while (parent) {
-      if (
-        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||
-        parent.for
-      ) {
-        needsForceUpdate = true;
-        break
-      }
-      if (parent.if) {
-        needsKey = true;
-      }
-      parent = parent.parent;
-    }
-  }
-
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) { return genScopedSlot(slots[key], state); })
-    .join(',');
-
-  return ("scopedSlots:_u([" + generatedSlots + "]" + (needsForceUpdate ? ",null,true" : "") + (!needsForceUpdate && needsKey ? (",null,false," + (hash(generatedSlots))) : "") + ")")
-}
-
-function hash(str) {
-  var hash = 5381;
-  var i = str.length;
-  while(i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i);
-  }
-  return hash >>> 0
-}
-
-function containsSlotChild (el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-
-function genScopedSlot (
-  el,
-  state
-) {
-  var isLegacySyntax = el.attrsMap['slot-scope'];
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, "null")
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope = el.slotScope === emptySlotScopeToken
-    ? ""
-    : String(el.slotScope);
-  var fn = "function(" + slotScope + "){" +
-    "return " + (el.tag === 'template'
-      ? el.if && isLegacySyntax
-        ? ("(" + (el.if) + ")?" + (genChildren(el, state) || 'undefined') + ":undefined")
-        : genChildren(el, state) || 'undefined'
-      : genElement(el, state)) + "}";
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? "" : ",proxy:true";
-  return ("{key:" + (el.slotTarget || "\"default\"") + ",fn:" + fn + reverseProxy + "}")
-}
-
-function genChildren (
-  el,
-  state,
-  checkSkip,
-  altGenElement,
-  altGenNode
-) {
-  var children = el.children;
-  if (children.length) {
-    var el$1 = children[0];
-    // optimize single v-for
-    if (children.length === 1 &&
-      el$1.for &&
-      el$1.tag !== 'template' &&
-      el$1.tag !== 'slot'
-    ) {
-      var normalizationType = checkSkip
-        ? state.maybeComponent(el$1) ? ",1" : ",0"
-        : "";
-      return ("" + ((altGenElement || genElement)(el$1, state)) + normalizationType)
-    }
-    var normalizationType$1 = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0;
-    var gen = altGenNode || genNode;
-    return ("[" + (children.map(function (c) { return gen(c, state); }).join(',')) + "]" + (normalizationType$1 ? ("," + normalizationType$1) : ''))
-  }
-}
-
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType (
-  children,
-  maybeComponent
-) {
-  var res = 0;
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i];
-    if (el.type !== 1) {
-      continue
-    }
-    if (needsNormalization(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {
-      res = 2;
-      break
-    }
-    if (maybeComponent(el) ||
-        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {
-      res = 1;
-    }
-  }
-  return res
-}
-
-function needsNormalization (el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-
-function genNode (node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-
-function genText (text) {
-  return ("_v(" + (text.type === 2
-    ? text.expression // no need for () because already wrapped in _s()
-    : transformSpecialNewlines(JSON.stringify(text.text))) + ")")
-}
-
-function genComment (comment) {
-  return ("_e(" + (JSON.stringify(comment.text)) + ")")
-}
-
-function genSlot (el, state) {
-  var slotName = el.slotName || '"default"';
-  var children = genChildren(el, state);
-  var res = "_t(" + slotName + (children ? ("," + children) : '');
-  var attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      }); }))
-    : null;
-  var bind$$1 = el.attrsMap['v-bind'];
-  if ((attrs || bind$$1) && !children) {
-    res += ",null";
-  }
-  if (attrs) {
-    res += "," + attrs;
-  }
-  if (bind$$1) {
-    res += (attrs ? '' : ',null') + "," + bind$$1;
-  }
-  return res + ')'
-}
-
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent (
-  componentName,
-  el,
-  state
-) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true);
-  return ("_c(" + componentName + "," + (genData(el, state)) + (children ? ("," + children) : '') + ")")
-}
-
-function genProps (props) {
-  var staticProps = "";
-  var dynamicProps = "";
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i];
-    var value = generateValue(prop.value);
-    if (prop.dynamic) {
-      dynamicProps += (prop.name) + "," + value + ",";
-    } else {
-      staticProps += "\"" + (prop.name) + "\":" + value + ",";
-    }
-  }
-  staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-  if (dynamicProps) {
-    return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
-  } else {
-    return staticProps
-  }
-}
-
-/* istanbul ignore next */
-function generateValue (value) {
-  if (typeof value === 'string') {
-    return transformSpecialNewlines(value)
-  }
-  return JSON.stringify(value)
-}
-
-// #3895, #4268
-function transformSpecialNewlines (text) {
-  return text
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029')
-}
-
-/*  */
-
-
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp('\\b' + (
-  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-  'super,throw,while,yield,delete,export,import,return,switch,default,' +
-  'extends,finally,continue,debugger,function,arguments'
-).split(',').join('\\b|\\b') + '\\b');
-
-// these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp('\\b' + (
-  'delete,typeof,void'
-).split(',').join('\\s*\\([^\\)]*\\)|\\b') + '\\s*\\([^\\)]*\\)');
-
-// strip strings in expressions
-var stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
-
-// detect problematic expressions in a template
-function detectErrors (ast, warn$$1) {
-  if (ast) {
-    checkNode(ast, warn$$1);
-  }
-}
-
-function checkNode (node, warn$$1) {
-  if (node.type === 1) {
-    for (var name in node.attrsMap) {
-      if (dirRE.test(name)) {
-        var value = node.attrsMap[name];
-        if (value) {
-          var range = node.rawAttrsMap[name];
-          if (name === 'v-for') {
-            checkFor(node, ("v-for=\"" + value + "\""), warn$$1, range);
-          } else if (name === 'v-slot' || name[0] === '#') {
-            checkFunctionParameterExpression(value, (name + "=\"" + value + "\""), warn$$1, range);
-          } else if (onRE.test(name)) {
-            checkEvent(value, (name + "=\"" + value + "\""), warn$$1, range);
-          } else {
-            checkExpression(value, (name + "=\"" + value + "\""), warn$$1, range);
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn$$1);
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn$$1, node);
-  }
-}
-
-function checkEvent (exp, text, warn$$1, range) {
-  var stripped = exp.replace(stripStringRE, '');
-  var keywordMatch = stripped.match(unaryOperatorsRE);
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn$$1(
-      "avoid using JavaScript unary operator as property name: " +
-      "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-      range
-    );
-  }
-  checkExpression(exp, text, warn$$1, range);
-}
-
-function checkFor (node, text, warn$$1, range) {
-  checkExpression(node.for || '', text, warn$$1, range);
-  checkIdentifier(node.alias, 'v-for alias', text, warn$$1, range);
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn$$1, range);
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn$$1, range);
-}
-
-function checkIdentifier (
-  ident,
-  type,
-  text,
-  warn$$1,
-  range
-) {
-  if (typeof ident === 'string') {
-    try {
-      new Function(("var " + ident + "=_"));
-    } catch (e) {
-      warn$$1(("invalid " + type + " \"" + ident + "\" in expression: " + (text.trim())), range);
-    }
-  }
-}
-
-function checkExpression (exp, text, warn$$1, range) {
-  try {
-    new Function(("return " + exp));
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);
-    if (keywordMatch) {
-      warn$$1(
-        "avoid using JavaScript keyword as property name: " +
-        "\"" + (keywordMatch[0]) + "\"\n  Raw expression: " + (text.trim()),
-        range
-      );
-    } else {
-      warn$$1(
-        "invalid expression: " + (e.message) + " in\n\n" +
-        "    " + exp + "\n\n" +
-        "  Raw expression: " + (text.trim()) + "\n",
-        range
-      );
-    }
-  }
-}
-
-function checkFunctionParameterExpression (exp, text, warn$$1, range) {
-  try {
-    new Function(exp, '');
-  } catch (e) {
-    warn$$1(
-      "invalid function parameter expression: " + (e.message) + " in\n\n" +
-      "    " + exp + "\n\n" +
-      "  Raw expression: " + (text.trim()) + "\n",
-      range
-    );
-  }
-}
-
-/*  */
-
-var range = 2;
-
-function generateCodeFrame (
-  source,
-  start,
-  end
-) {
-  if ( start === void 0 ) start = 0;
-  if ( end === void 0 ) end = source.length;
-
-  var lines = source.split(/\r?\n/);
-  var count = 0;
-  var res = [];
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1;
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) { continue }
-        res.push(("" + (j + 1) + (repeat$1(" ", 3 - String(j + 1).length)) + "|  " + (lines[j])));
-        var lineLength = lines[j].length;
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1;
-          var length = end > count ? lineLength - pad : end - start;
-          res.push("   |  " + repeat$1(" ", pad) + repeat$1("^", length));
-        } else if (j > i) {
-          if (end > count) {
-            var length$1 = Math.min(end - count, lineLength);
-            res.push("   |  " + repeat$1("^", length$1));
-          }
-          count += lineLength + 1;
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-
-function repeat$1 (str, n) {
-  var result = '';
-  if (n > 0) {
-    while (true) { // eslint-disable-line
-      if (n & 1) { result += str; }
-      n >>>= 1;
-      if (n <= 0) { break }
-      str += str;
-    }
-  }
-  return result
-}
-
-/*  */
-
-
-
-function createFunction (code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code });
-    return noop
-  }
-}
-
-function createCompileToFunctionFn (compile) {
-  var cache = Object.create(null);
-
-  return function compileToFunctions (
-    template,
-    options,
-    vm
-  ) {
-    options = extend({}, options);
-    var warn$$1 = options.warn || warn$1;
-    delete options.warn;
-
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1');
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn$$1(
-            'It seems you are using the standalone build of Vue.js in an ' +
-            'environment with Content Security Policy that prohibits unsafe-eval. ' +
-            'The template compiler cannot work in this environment. Consider ' +
-            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-            'templates into render functions.'
-          );
-        }
-      }
-    }
-
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template;
-    if (cache[key]) {
-      return cache[key]
-    }
-
-    // compile
-    var compiled = compile(template, options);
-
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn$$1(
-              "Error compiling template:\n\n" + (e.msg) + "\n\n" +
-              generateCodeFrame(template, e.start, e.end),
-              vm
-            );
-          });
-        } else {
-          warn$$1(
-            "Error compiling template:\n\n" + template + "\n\n" +
-            compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-            vm
-          );
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
-        } else {
-          compiled.tips.forEach(function (msg) { return tip(msg, vm); });
-        }
-      }
-    }
-
-    // turn code into functions
-    var res = {};
-    var fnGenErrors = [];
-    res.render = createFunction(compiled.render, fnGenErrors);
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    });
-
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn$$1(
-          "Failed to generate render function:\n\n" +
-          fnGenErrors.map(function (ref) {
-            var err = ref.err;
-            var code = ref.code;
-
-            return ((err.toString()) + " in\n\n" + code + "\n");
-        }).join('\n'),
-          vm
-        );
-      }
-    }
-
-    return (cache[key] = res)
-  }
-}
-
-/*  */
-
-function createCompilerCreator (baseCompile) {
-  return function createCompiler (baseOptions) {
-    function compile (
-      template,
-      options
-    ) {
-      var finalOptions = Object.create(baseOptions);
-      var errors = [];
-      var tips = [];
-
-      var warn = function (msg, range, tip) {
-        (tip ? tips : errors).push(msg);
-      };
-
-      if (options) {
-        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-          // $flow-disable-line
-          var leadingSpaceLength = template.match(/^\s*/)[0].length;
-
-          warn = function (msg, range, tip) {
-            var data = { msg: msg };
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength;
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength;
-              }
-            }
-            (tip ? tips : errors).push(data);
-          };
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules =
-            (baseOptions.modules || []).concat(options.modules);
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          );
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key];
-          }
-        }
-      }
-
-      finalOptions.warn = warn;
-
-      var compiled = baseCompile(template.trim(), finalOptions);
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn);
-      }
-      compiled.errors = errors;
-      compiled.tips = tips;
-      return compiled
-    }
-
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
-}
-
-/*  */
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-var createCompiler = createCompilerCreator(function baseCompile (
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options);
-  if (options.optimize !== false) {
-    optimize(ast, options);
-  }
-  var code = generate(ast, options);
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
-});
-
-/*  */
-
-
-
-function transformNode (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticClass = getAndRemoveAttr(el, 'class');
-  var ref = parseStaticClass(staticClass, options);
-  var dynamic = ref.dynamic;
-  var classResult = ref.classResult;
-  if (process.env.NODE_ENV !== 'production' && dynamic && staticClass) {
-    warn(
-      "class=\"" + staticClass + "\": " +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['class']
-    );
-  }
-  if (!dynamic && classResult) {
-    el.staticClass = classResult;
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-  if (classBinding) {
-    el.classBinding = classBinding;
-  } else if (dynamic) {
-    el.classBinding = classResult;
-  }
-}
-
-function genData$1 (el) {
-  var data = '';
-  if (el.staticClass) {
-    data += "staticClass:" + (el.staticClass) + ",";
-  }
-  if (el.classBinding) {
-    data += "class:" + (el.classBinding) + ",";
-  }
-  return data
-}
-
-function parseStaticClass (staticClass, options) {
-  // "a b c" -> ["a", "b", "c"] => staticClass: ["a", "b", "c"]
-  // "a {{x}} c" -> ["a", x, "c"] => classBinding: '["a", x, "c"]'
-  var dynamic = false;
-  var classResult = '';
-  if (staticClass) {
-    var classList = staticClass.trim().split(' ').map(function (name) {
-      var result = parseText(name, options.delimiters);
-      if (result) {
-        dynamic = true;
-        return result.expression
-      }
-      return JSON.stringify(name)
-    });
-    if (classList.length) {
-      classResult = '[' + classList.join(',') + ']';
-    }
-  }
-  return { dynamic: dynamic, classResult: classResult }
-}
-
-var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode,
-  genData: genData$1
-};
-
-/*  */
-
-
-
-var normalize = cached(camelize);
-
-function transformNode$1 (el, options) {
-  var warn = options.warn || baseWarn;
-  var staticStyle = getAndRemoveAttr(el, 'style');
-  var ref = parseStaticStyle(staticStyle, options);
-  var dynamic = ref.dynamic;
-  var styleResult = ref.styleResult;
-  if (process.env.NODE_ENV !== 'production' && dynamic) {
-    warn(
-      "style=\"" + (String(staticStyle)) + "\": " +
-      'Interpolation inside attributes has been deprecated. ' +
-      'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['style']
-    );
-  }
-  if (!dynamic && styleResult) {
-    // $flow-disable-line
-    el.staticStyle = styleResult;
-  }
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-  if (styleBinding) {
-    el.styleBinding = styleBinding;
-  } else if (dynamic) {
-    // $flow-disable-line
-    el.styleBinding = styleResult;
-  }
-}
-
-function genData$2 (el) {
-  var data = '';
-  if (el.staticStyle) {
-    data += "staticStyle:" + (el.staticStyle) + ",";
-  }
-  if (el.styleBinding) {
-    data += "style:" + (el.styleBinding) + ",";
-  }
-  return data
-}
-
-function parseStaticStyle (staticStyle, options) {
-  // "width: 200px; height: 200px;" -> {width: 200, height: 200}
-  // "width: 200px; height: {{y}}" -> {width: 200, height: y}
-  var dynamic = false;
-  var styleResult = '';
-  if (typeof staticStyle === 'string') {
-    var styleList = staticStyle.trim().split(';').map(function (style) {
-      var result = style.trim().split(':');
-      if (result.length !== 2) {
-        return
-      }
-      var key = normalize(result[0].trim());
-      var value = result[1].trim();
-      var dynamicValue = parseText(value, options.delimiters);
-      if (dynamicValue) {
-        dynamic = true;
-        return key + ':' + dynamicValue.expression
-      }
-      return key + ':' + JSON.stringify(value)
-    }).filter(function (result) { return result; });
-    if (styleList.length) {
-      styleResult = '{' + styleList.join(',') + '}';
-    }
-  } else if (isPlainObject(staticStyle)) {
-    styleResult = JSON.stringify(staticStyle) || '';
-  }
-  return { dynamic: dynamic, styleResult: styleResult }
-}
-
-var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode$1,
-  genData: genData$2
-};
-
-/*  */
-
-var normalize$1 = cached(camelize);
-
-function normalizeKeyName (str) {
-  if (str.match(/^v\-/)) {
-    return str.replace(/(v-[a-z\-]+\:)([a-z\-]+)$/i, function ($, directive, prop) {
-      return directive + normalize$1(prop)
-    })
-  }
-  return normalize$1(str)
-}
-
-function transformNode$2 (el) {
-  if (Array.isArray(el.attrsList)) {
-    el.attrsList.forEach(function (attr) {
-      if (attr.name && attr.name.match(/\-/)) {
-        var realName = normalizeKeyName(attr.name);
-        if (el.attrsMap) {
-          el.attrsMap[realName] = el.attrsMap[attr.name];
-          delete el.attrsMap[attr.name];
-        }
-        if (el.rawAttrsMap && el.rawAttrsMap[attr.name]) {
-          el.rawAttrsMap[realName] = el.rawAttrsMap[attr.name];
-          // $flow-disable-line
-          delete el.rawAttrsMap[attr.name];
-        }
-        attr.name = realName;
-      }
-    });
-  }
-}
-var props = {
-  transformNode: transformNode$2
-};
-
-/*  */
-
-// The "unitary tag" means that the tag node and its children
-// must be sent to the native together.
-var isUnitaryTag = makeMap('cell,header,cell-slot,recycle-list', true);
-
-function preTransformNode (el) {
-  if (isUnitaryTag(el.tag) && !el.attrsList.some(function (item) { return item.name === 'append'; })) {
-    el.attrsMap.append = 'tree';
-    el.attrsList.push({ name: 'append', value: 'tree' });
-  }
-  if (el.attrsMap.append === 'tree') {
-    el.appendAsTree = true;
-  }
-}
-
-function genData$3 (el) {
-  return el.appendAsTree ? "appendAsTree:true," : ''
-}
-
-var append = {
-  staticKeys: ['appendAsTree'],
-  preTransformNode: preTransformNode,
-  genData: genData$3
-};
-
-/*  */
-
-/**
- * Map the following syntax to corresponding attrs:
- *
- * <recycle-list for="(item, i) in longList" switch="cellType">
- *   <cell-slot case="A"> ... </cell-slot>
- *   <cell-slot case="B"> ... </cell-slot>
- * </recycle-list>
- */
-
-function preTransformRecycleList (
-  el,
-  options
-) {
-  var exp = getAndRemoveAttr(el, 'for');
-  if (!exp) {
-    if (options.warn) {
-      options.warn("Invalid <recycle-list> syntax: missing \"for\" expression.");
-    }
-    return
-  }
-
-  var res = parseFor(exp);
-  if (!res) {
-    if (options.warn) {
-      options.warn(("Invalid <recycle-list> syntax: " + exp + "."));
-    }
-    return
-  }
-
-  addRawAttr(el, ':list-data', res.for);
-  addRawAttr(el, 'binding-expression', res.for);
-  addRawAttr(el, 'alias', res.alias);
-  if (res.iterator2) {
-    // (item, key, index) for object iteration
-    // is this even supported?
-    addRawAttr(el, 'index', res.iterator2);
-  } else if (res.iterator1) {
-    addRawAttr(el, 'index', res.iterator1);
-  }
-
-  var switchKey = getAndRemoveAttr(el, 'switch');
-  if (switchKey) {
-    addRawAttr(el, 'switch', switchKey);
-  }
-}
-
-/*  */
-
-var RECYCLE_LIST_MARKER = '@inRecycleList';
-
-/*  */
-
-// mark components as inside recycle-list so that we know we need to invoke
-// their special @render function instead of render in create-component.js
-function postTransformComponent (
-  el,
-  options
-) {
-  // $flow-disable-line (we know isReservedTag is there)
-  if (!options.isReservedTag(el.tag) && el.tag !== 'cell-slot') {
-    addAttr(el, RECYCLE_LIST_MARKER, 'true');
-  }
-}
-
-/*  */
-
-// mark component root nodes as
-function postTransformComponentRoot (el) {
-  if (!el.parent) {
-    // component root
-    addAttr(el, '@isComponentRoot', 'true');
-    addAttr(el, '@templateId', '_uid');
-    addAttr(el, '@componentProps', '$props || {}');
-  }
-}
-
-/*  */
-
-function genText$1 (node) {
-  var value = node.type === 3
-    ? node.text
-    : node.type === 2
-      ? node.tokens.length === 1
-        ? node.tokens[0]
-        : node.tokens
-      : '';
-  return JSON.stringify(value)
-}
-
-function postTransformText (el) {
-  // weex <text> can only contain text, so the parser
-  // always generates a single child.
-  if (el.children.length) {
-    addAttr(el, 'value', genText$1(el.children[0]));
-    el.children = [];
-  }
-}
-
-/*  */
-
-// import { warn } from 'core/util/index'
-
-// this will be preserved during build
-// $flow-disable-line
-var acorn = require('acorn'); // $flow-disable-line
-var walk = require('acorn/dist/walk'); // $flow-disable-line
-var escodegen = require('escodegen');
-
-function nodeToBinding (node) {
-  switch (node.type) {
-    case 'Literal': return node.value
-    case 'Identifier':
-    case 'UnaryExpression':
-    case 'BinaryExpression':
-    case 'LogicalExpression':
-    case 'ConditionalExpression':
-    case 'MemberExpression': return { '@binding': escodegen.generate(node) }
-    case 'ArrayExpression': return node.elements.map(function (_) { return nodeToBinding(_); })
-    case 'ObjectExpression': {
-      var object = {};
-      node.properties.forEach(function (prop) {
-        if (!prop.key || prop.key.type !== 'Identifier') {
-          return
-        }
-        var key = escodegen.generate(prop.key);
-        var value = nodeToBinding(prop.value);
-        if (key && value) {
-          object[key] = value;
-        }
-      });
-      return object
-    }
-    default: {
-      // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
-      return ''
-    }
-  }
-}
-
-function generateBinding (exp) {
-  if (exp && typeof exp === 'string') {
-    var ast = null;
-    try {
-      ast = acorn.parse(("(" + exp + ")"));
-    } catch (e) {
-      // warn(`Failed to parse the expression: "${exp}"`)
-      return ''
-    }
-
-    var output = '';
-    walk.simple(ast, {
-      Expression: function Expression (node) {
-        output = nodeToBinding(node);
-      }
-    });
-    return output
-  }
-}
-
-/*  */
-
-function parseAttrName (name) {
-  return camelize(name.replace(bindRE, ''))
-}
-
-function preTransformVBind (el) {
-  for (var attr in el.attrsMap) {
-    if (bindRE.test(attr)) {
-      var name = parseAttrName(attr);
-      var value = generateBinding(getAndRemoveAttr(el, attr));
-      delete el.attrsMap[attr];
-      addRawAttr(el, name, value);
-    }
-  }
-}
-
-/*  */
-
-function hasConditionDirective (el) {
-  for (var attr in el.attrsMap) {
-    if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
-      return true
-    }
-  }
-  return false
-}
-
-function getPreviousConditions (el) {
-  var conditions = [];
-  if (el.parent && el.parent.children) {
-    for (var c = 0, n = el.parent.children.length; c < n; ++c) {
-      // $flow-disable-line
-      var ifConditions = el.parent.children[c].ifConditions;
-      if (ifConditions) {
-        for (var i = 0, l = ifConditions.length; i < l; ++i) {
-          var condition = ifConditions[i];
-          if (condition && condition.exp) {
-            conditions.push(condition.exp);
-          }
-        }
-      }
-    }
-  }
-  return conditions
-}
-
-function preTransformVIf (el, options) {
-  if (hasConditionDirective(el)) {
-    var exp;
-    var ifExp = getAndRemoveAttr(el, 'v-if', true /* remove from attrsMap */);
-    var elseifExp = getAndRemoveAttr(el, 'v-else-if', true);
-    // don't need the value, but remove it to avoid being generated as a
-    // custom directive
-    getAndRemoveAttr(el, 'v-else', true);
-    if (ifExp) {
-      exp = ifExp;
-      addIfCondition(el, { exp: ifExp, block: el });
-    } else {
-      elseifExp && addIfCondition(el, { exp: elseifExp, block: el });
-      var prevConditions = getPreviousConditions(el);
-      if (prevConditions.length) {
-        var prevMatch = prevConditions.join(' || ');
-        exp = elseifExp
-          ? ("!(" + prevMatch + ") && (" + elseifExp + ")") // v-else-if
-          : ("!(" + prevMatch + ")"); // v-else
-      } else if (process.env.NODE_ENV !== 'production' && options.warn) {
-        options.warn(
-          "v-" + (elseifExp ? ('else-if="' + elseifExp + '"') : 'else') + " " +
-          "used on element <" + (el.tag) + "> without corresponding v-if."
-        );
-        return
-      }
-    }
-    addRawAttr(el, '[[match]]', exp);
-  }
-}
-
-/*  */
-
-function preTransformVFor (el, options) {
-  var exp = getAndRemoveAttr(el, 'v-for');
-  if (!exp) {
-    return
-  }
-
-  var res = parseFor(exp);
-  if (!res) {
-    if (process.env.NODE_ENV !== 'production' && options.warn) {
-      options.warn(("Invalid v-for expression: " + exp));
-    }
-    return
-  }
-
-  var desc = {
-    '@expression': res.for,
-    '@alias': res.alias
-  };
-  if (res.iterator2) {
-    desc['@key'] = res.iterator1;
-    desc['@index'] = res.iterator2;
-  } else {
-    desc['@index'] = res.iterator1;
-  }
-
-  delete el.attrsMap['v-for'];
-  addRawAttr(el, '[[repeat]]', desc);
-}
-
-/*  */
-
-var inlineStatementRE = /^\s*([A-Za-z_$0-9\['\."\]]+)*\s*\(\s*(([A-Za-z_$0-9\['\."\]]+)?(\s*,\s*([A-Za-z_$0-9\['\."\]]+))*)\s*\)$/;
-
-function parseHandlerParams (handler) {
-  var res = inlineStatementRE.exec(handler.value);
-  if (res && res[2]) {
-    handler.params = res[2].split(/\s*,\s*/);
-  }
-}
-
-function postTransformVOn (el) {
-  var events = el.events;
-  if (!events) {
-    return
-  }
-  for (var name in events) {
-    var handler = events[name];
-    if (Array.isArray(handler)) {
-      handler.map(function (fn) { return parseHandlerParams(fn); });
-    } else {
-      parseHandlerParams(handler);
-    }
-  }
-}
-
-/*  */
-
-function containVOnce (el) {
-  for (var attr in el.attrsMap) {
-    if (/^v\-once$/i.test(attr)) {
-      return true
-    }
-  }
-  return false
-}
-
-function preTransformVOnce (el) {
-  if (containVOnce(el)) {
-    getAndRemoveAttr(el, 'v-once', true);
-    addRawAttr(el, '[[once]]', true);
-  }
-}
-
-/*  */
-
-var currentRecycleList = null;
-
-function shouldCompile (el, options) {
-  return options.recyclable ||
-    (currentRecycleList && el !== currentRecycleList)
-}
-
-function preTransformNode$1 (el, options) {
-  if (el.tag === 'recycle-list') {
-    preTransformRecycleList(el, options);
-    currentRecycleList = el;
-  }
-  if (shouldCompile(el, options)) {
-    preTransformVBind(el);
-    preTransformVIf(el, options); // also v-else-if and v-else
-    preTransformVFor(el, options);
-    preTransformVOnce(el);
-  }
-}
-
-function transformNode$3 (el, options) {
-  if (shouldCompile(el, options)) ;
-}
-
-function postTransformNode (el, options) {
-  if (shouldCompile(el, options)) {
-    // mark child component in parent template
-    postTransformComponent(el, options);
-    // mark root in child component template
-    postTransformComponentRoot(el);
-    // <text>: transform children text into value attr
-    if (el.tag === 'text') {
-      postTransformText(el);
-    }
-    postTransformVOn(el);
-  }
-  if (el === currentRecycleList) {
-    currentRecycleList = null;
-  }
-}
-
-var recycleList = {
-  preTransformNode: preTransformNode$1,
-  transformNode: transformNode$3,
-  postTransformNode: postTransformNode
-};
-
-var modules = [
-  recycleList,
-  klass,
-  style,
-  props,
-  append
-];
-
-/*  */
-
-function model (
-  el,
-  dir
-) {
-  if (el.tag === 'input' || el.tag === 'textarea') {
-    genDefaultModel(el, dir.value, dir.modifiers);
-  } else {
-    genComponentModel(el, dir.value, dir.modifiers);
-  }
-}
-
-function genDefaultModel (
-  el,
-  value,
-  modifiers
-) {
-  var ref = modifiers || {};
-  var lazy = ref.lazy;
-  var trim = ref.trim;
-  var number = ref.number;
-  var event = lazy ? 'change' : 'input';
-
-  var valueExpression = "$event.target.attr.value" + (trim ? '.trim()' : '');
-  if (number) {
-    valueExpression = "_n(" + valueExpression + ")";
-  }
-
-  var code = genAssignmentCode(value, valueExpression);
-  addAttr(el, 'value', ("(" + value + ")"));
-  addHandler(el, event, code, null, true);
-}
-
-var directives = {
-  model: model
-};
-
-/*  */
-
-var isReservedTag = makeMap(
-  'template,script,style,element,content,slot,link,meta,svg,view,' +
-  'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-  'slider,slider-neighbor,indicator,canvas,' +
-  'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-  'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown',
-  true
-);
-
-// Elements that you can, intentionally, leave open (and which close themselves)
-// more flexible than web
-var canBeLeftOpenTag$1 = makeMap(
-  'web,spinner,switch,video,textarea,canvas,' +
-  'indicator,marquee,countdown',
-  true
-);
-
-var isRuntimeComponent = makeMap(
-  'richtext,transition,transition-group',
-  true
-);
-
-var isUnaryTag$1 = makeMap(
-  'embed,img,image,input,link,meta',
-  true
-);
-
-function mustUseProp () {
-  return false
-}
-
-function getTagNamespace () { }
-
-/*  */
-
-var baseOptions = {
-  modules: modules,
-  directives: directives,
-  isUnaryTag: isUnaryTag$1,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag$1,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  preserveWhitespace: false,
-  recyclable: false,
-  staticKeys: genStaticKeys(modules)
-};
-
-var compiler = createCompiler(baseOptions);
-
-function compile (
-  template,
-  options
-) {
-  var generateAltRender = false;
-  if (options && options.recyclable === true) {
-    generateAltRender = true;
-    options.recyclable = false;
-  }
-  var result = compiler.compile(template, options);
-
-  // generate @render function for <recycle-list>
-  if (options && generateAltRender) {
-    options.recyclable = true;
-    // disable static optimizations
-    options.optimize = false;
-    var ref = compiler.compile(template, options);
-    var render = ref.render;
-    result['@render'] = render;
-  }
-  return result
-}
-
-exports.compile = compile;
-exports.generateCodeFrame = generateCodeFrame;
diff --git a/packages/weex-template-compiler/index.js b/packages/weex-template-compiler/index.js
deleted file mode 100644
index f50a0e659e9..00000000000
--- a/packages/weex-template-compiler/index.js
+++ /dev/null
@@ -1,17 +0,0 @@
-try {
-  var vueVersion = require('weex-vue-framework').version
-} catch (e) {}
-
-var packageName = require('./package.json').name
-var packageVersion = require('./package.json').version
-if (vueVersion && vueVersion !== packageVersion) {
-  throw new Error(
-    '\n\nVue packages version mismatch:\n\n' +
-    '- vue@' + vueVersion + '\n' +
-    '- ' + packageName + '@' + packageVersion + '\n\n' +
-    'This may cause things to work incorrectly. Make sure to use the same version for both.\n' +
-    'If you are using weex-vue-loader, re-installing them should bump ' + packageName + ' to the latest.\n'
-  )
-}
-
-module.exports = require('./build')
diff --git a/packages/weex-template-compiler/package.json b/packages/weex-template-compiler/package.json
deleted file mode 100644
index f1155267109..00000000000
--- a/packages/weex-template-compiler/package.json
+++ /dev/null
@@ -1,26 +0,0 @@
-{
-  "name": "weex-template-compiler",
-  "version": "2.4.2-weex.1",
-  "description": "Weex template compiler for Vue 2.0",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vuejs/vue.git"
-  },
-  "keywords": [
-    "vue",
-    "compiler"
-  ],
-  "author": "Evan You",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/vuejs/vue/issues"
-  },
-  "homepage": "https://github.com/vuejs/vue/tree/dev/packages/weex-template-compiler#readme",
-  "dependencies": {
-    "acorn": "^8.1.0",
-    "acorn-walk": "^8.0.2",
-    "escodegen": "^1.8.1",
-    "he": "^1.1.0"
-  }
-}
diff --git a/packages/weex-vue-framework/README.md b/packages/weex-vue-framework/README.md
deleted file mode 100644
index 9f3183185a6..00000000000
--- a/packages/weex-vue-framework/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# weex-vue-framework
-
-> This package is auto-generated. For pull requests please see [src/platforms/weex/entry-framework.js](https://github.com/vuejs/vue/blob/dev/src/platforms/weex/entry-framework.js).
diff --git a/packages/weex-vue-framework/factory.js b/packages/weex-vue-framework/factory.js
deleted file mode 100644
index 38bbf0534d0..00000000000
--- a/packages/weex-vue-framework/factory.js
+++ /dev/null
@@ -1,6858 +0,0 @@
-'use strict';
-
-
-
-module.exports = function weexFactory (exports, document) {
-
-var emptyObject = Object.freeze({});
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-    return v === undefined || v === null;
-}
-function isDef(v) {
-    return v !== undefined && v !== null;
-}
-function isTrue(v) {
-    return v === true;
-}
-function isFalse(v) {
-    return v === false;
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-    return (typeof value === 'string' ||
-        typeof value === 'number' ||
-        // $flow-disable-line
-        typeof value === 'symbol' ||
-        typeof value === 'boolean');
-}
-/**
- * Quick object check - this is primarily used to tell
- * Objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-var _toString = Object.prototype.toString;
-function toRawType(value) {
-    return _toString.call(value).slice(8, -1);
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]';
-}
-function isRegExp(v) {
-    return _toString.call(v) === '[object RegExp]';
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-    var n = parseFloat(String(val));
-    return n >= 0 && Math.floor(n) === n && isFinite(val);
-}
-function isPromise(val) {
-    return (isDef(val) &&
-        typeof val.then === 'function' &&
-        typeof val.catch === 'function');
-}
-/**
- * Convert a value to a string that is actually rendered.
- */
-function toString(val) {
-    return val == null
-        ? ''
-        : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-            ? JSON.stringify(val, null, 2)
-            : String(val);
-}
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-function toNumber(val) {
-    var n = parseFloat(val);
-    return isNaN(n) ? val : n;
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null);
-    var list = str.split(',');
-    for (var i = 0; i < list.length; i++) {
-        map[list[i]] = true;
-    }
-    return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; };
-}
-/**
- * Check if a tag is a built-in tag.
- */
-var isBuiltInTag = makeMap('slot,component', true);
-/**
- * Check if an attribute is a reserved attribute.
- */
-var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');
-/**
- * Remove an item from an array.
- */
-function remove$2(arr, item) {
-    if (arr.length) {
-        var index = arr.indexOf(item);
-        if (index > -1) {
-            return arr.splice(index, 1);
-        }
-    }
-}
-/**
- * Check whether an object has the property.
- */
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key);
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-    var cache = Object.create(null);
-    return function cachedFn(str) {
-        var hit = cache[str];
-        return hit || (cache[str] = fn(str));
-    };
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-var camelizeRE = /-(\w)/g;
-var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); });
-});
-/**
- * Capitalize a string.
- */
-var capitalize = cached(function (str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-});
-/**
- * Hyphenate a camelCase string.
- */
-var hyphenateRE = /\B([A-Z])/g;
-var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase();
-});
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-/* istanbul ignore next */
-function polyfillBind(fn, ctx) {
-    function boundFn(a) {
-        var l = arguments.length;
-        return l
-            ? l > 1
-                ? fn.apply(ctx, arguments)
-                : fn.call(ctx, a)
-            : fn.call(ctx);
-    }
-    boundFn._length = fn.length;
-    return boundFn;
-}
-function nativeBind(fn, ctx) {
-    return fn.bind(ctx);
-}
-// @ts-expect-error bind cannot be `undefined`
-var bind = Function.prototype.bind ? nativeBind : polyfillBind;
-/**
- * Convert an Array-like object to a real Array.
- */
-function toArray(list, start) {
-    start = start || 0;
-    var i = list.length - start;
-    var ret = new Array(i);
-    while (i--) {
-        ret[i] = list[i + start];
-    }
-    return ret;
-}
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-    for (var key in _from) {
-        to[key] = _from[key];
-    }
-    return to;
-}
-/**
- * Merge an Array of Objects into a single Object.
- */
-function toObject$1(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) { }
-/**
- * Always return false.
- */
-var no = function (a, b, c) { return false; };
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-var identity = function (_) { return _; };
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-function looseEqual(a, b) {
-    if (a === b)
-        { return true; }
-    var isObjectA = isObject(a);
-    var isObjectB = isObject(b);
-    if (isObjectA && isObjectB) {
-        try {
-            var isArrayA = Array.isArray(a);
-            var isArrayB = Array.isArray(b);
-            if (isArrayA && isArrayB) {
-                return (a.length === b.length &&
-                    a.every(function (e, i) {
-                        return looseEqual(e, b[i]);
-                    }));
-            }
-            else if (a instanceof Date && b instanceof Date) {
-                return a.getTime() === b.getTime();
-            }
-            else if (!isArrayA && !isArrayB) {
-                var keysA = Object.keys(a);
-                var keysB = Object.keys(b);
-                return (keysA.length === keysB.length &&
-                    keysA.every(function (key) {
-                        return looseEqual(a[key], b[key]);
-                    }));
-            }
-            else {
-                /* istanbul ignore next */
-                return false;
-            }
-        }
-        catch (e) {
-            /* istanbul ignore next */
-            return false;
-        }
-    }
-    else if (!isObjectA && !isObjectB) {
-        return String(a) === String(b);
-    }
-    else {
-        return false;
-    }
-}
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-function looseIndexOf(arr, val) {
-    for (var i = 0; i < arr.length; i++) {
-        if (looseEqual(arr[i], val))
-            { return i; }
-    }
-    return -1;
-}
-/**
- * Ensure a function is called only once.
- */
-function once(fn) {
-    var called = false;
-    return function () {
-        if (!called) {
-            called = true;
-            fn.apply(this, arguments);
-        }
-    };
-}
-
-var SSR_ATTR = 'data-server-rendered';
-var ASSET_TYPES = ['component', 'directive', 'filter'];
-var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch' ];
-
-var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: process.env.NODE_ENV !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS,
-};
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-var unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/;
-/**
- * Check if a string starts with $ or _
- */
-function isReserved(str) {
-    var c = (str + '').charCodeAt(0);
-    return c === 0x24 || c === 0x5f;
-}
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-        value: val,
-        enumerable: !!enumerable,
-        writable: true,
-        configurable: true,
-    });
-}
-/**
- * Parse simple path.
- */
-var bailRE = new RegExp("[^" + unicodeRegExp.source + ".$_\\d]");
-function parsePath(path) {
-    if (bailRE.test(path)) {
-        return;
-    }
-    var segments = path.split('.');
-    return function (obj) {
-        for (var i = 0; i < segments.length; i++) {
-            if (!obj)
-                { return; }
-            obj = obj[segments[i]];
-        }
-        return obj;
-    };
-}
-
-// can we use __proto__?
-var hasProto = '__proto__' in {};
-// Browser environment sniffing
-var inBrowser = typeof window !== 'undefined';
-// @ts-ignore
-var inWeex = 
-// @ts-ignore
-typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;
-// @ts-ignore
-var weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();
-var UA = inBrowser && window.navigator.userAgent.toLowerCase();
-var isIE = UA && /msie|trident/.test(UA);
-UA && UA.indexOf('msie 9.0') > 0;
-var isEdge = UA && UA.indexOf('edge/') > 0;
-(UA && UA.indexOf('android') > 0) || weexPlatform === 'android';
-var isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios';
-UA && /chrome\/\d+/.test(UA) && !isEdge;
-UA && /phantomjs/.test(UA);
-UA && UA.match(/firefox\/(\d+)/);
-// Firefox has a "watch" function on Object.prototype...
-// @ts-ignore
-var nativeWatch = {}.watch;
-var supportsPassive = false;
-if (inBrowser) {
-    try {
-        var opts = {};
-        Object.defineProperty(opts, 'passive', {
-            get: function () {
-                /* istanbul ignore next */
-                supportsPassive = true;
-            },
-        }); // https://github.com/facebook/flow/issues/285
-        // @ts-ignore
-        window.addEventListener('test-passive', null, opts);
-    }
-    catch (e) { }
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-var _isServer;
-var isServerRendering = function () {
-    if (_isServer === undefined) {
-        /* istanbul ignore if */
-        if (!inBrowser && !inWeex && typeof global !== 'undefined') {
-            // detect presence of vue-server-renderer and avoid
-            // Webpack shimming the process
-            _isServer =
-                global['process'] && global['process'].env.VUE_ENV === 'server';
-        }
-        else {
-            _isServer = false;
-        }
-    }
-    return _isServer;
-};
-// detect devtools
-// @ts-ignore TODO decalre this types
-var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
-/* istanbul ignore next */
-function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
-}
-var hasSymbol = typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys);
-var _Set; // $flow-disable-line
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) {
-    // use native Set when available.
-    _Set = Set;
-}
-else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    _Set = /** @class */ (function () {
-        function Set() {
-            this.set = Object.create(null);
-        }
-        Set.prototype.has = function (key) {
-            return this.set[key] === true;
-        };
-        Set.prototype.add = function (key) {
-            this.set[key] = true;
-        };
-        Set.prototype.clear = function () {
-            this.set = Object.create(null);
-        };
-        return Set;
-    }());
-}
-
-var warn = noop;
-var tip = noop;
-var generateComponentTrace; // work around flow check
-var formatComponentName;
-if (process.env.NODE_ENV !== 'production') {
-    var hasConsole_1 = typeof console !== 'undefined';
-    var classifyRE_1 = /(?:^|[-_])(\w)/g;
-    var classify_1 = function (str) {
-        return str.replace(classifyRE_1, function (c) { return c.toUpperCase(); }).replace(/[-_]/g, '');
-    };
-    warn = function (msg, vm) {
-        var trace = vm ? generateComponentTrace(vm) : '';
-        if (config.warnHandler) {
-            config.warnHandler.call(null, msg, vm, trace);
-        }
-        else if (hasConsole_1 && !config.silent) {
-            console.error("[Vue warn]: " + msg + trace);
-        }
-    };
-    tip = function (msg, vm) {
-        if (hasConsole_1 && !config.silent) {
-            console.warn("[Vue tip]: " + msg + (vm ? generateComponentTrace(vm) : ''));
-        }
-    };
-    formatComponentName = function (vm, includeFile) {
-        if (vm.$root === vm) {
-            return '<Root>';
-        }
-        var options = 
-        // @ts-ignore
-        typeof vm === 'function' && vm.cid != null
-            ? // @ts-ignore
-                vm.options
-            : vm._isVue
-                ? // @ts-ignore
-                    vm.$options || vm.constructor.options
-                : vm;
-        var name = options.name || options._componentTag;
-        var file = options.__file;
-        if (!name && file) {
-            var match = file.match(/([^/\\]+)\.vue$/);
-            name = match && match[1];
-        }
-        return ((name ? "<" + classify_1(name) + ">" : "<Anonymous>") +
-            (file && includeFile !== false ? " at " + file : ''));
-    };
-    var repeat_1 = function (str, n) {
-        var res = '';
-        while (n) {
-            if (n % 2 === 1)
-                { res += str; }
-            if (n > 1)
-                { str += str; }
-            n >>= 1;
-        }
-        return res;
-    };
-    generateComponentTrace = function (vm) {
-        // @ts-ignore
-        if (vm._isVue && vm.$parent) {
-            var tree = [];
-            var currentRecursiveSequence = 0;
-            while (vm) {
-                if (tree.length > 0) {
-                    var last = tree[tree.length - 1];
-                    if (last.constructor === vm.constructor) {
-                        currentRecursiveSequence++;
-                        vm = vm.$parent;
-                        continue;
-                    }
-                    else if (currentRecursiveSequence > 0) {
-                        tree[tree.length - 1] = [last, currentRecursiveSequence];
-                        currentRecursiveSequence = 0;
-                    }
-                }
-                tree.push(vm);
-                vm = vm.$parent;
-            }
-            return ('\n\nfound in\n\n' +
-                tree
-                    .map(function (vm, i) {
-                    return "" + (i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2)) + (Array.isArray(vm)
-                        ? formatComponentName(vm[0]) + "... (" + vm[1] + " recursive calls)"
-                        : formatComponentName(vm));
-                })
-                    .join('\n'));
-        }
-        else {
-            return "\n\n(found in " + formatComponentName(vm) + ")";
-        }
-    };
-}
-
-var uid$3 = 0;
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-var Dep = /** @class */ (function () {
-    function Dep() {
-        this.id = uid$3++;
-        this.subs = [];
-    }
-    Dep.prototype.addSub = function (sub) {
-        this.subs.push(sub);
-    };
-    Dep.prototype.removeSub = function (sub) {
-        remove$2(this.subs, sub);
-    };
-    Dep.prototype.depend = function () {
-        if (Dep.target) {
-            Dep.target.addDep(this);
-        }
-    };
-    Dep.prototype.notify = function () {
-        // stabilize the subscriber list first
-        var subs = this.subs.slice();
-        if (process.env.NODE_ENV !== 'production' && !config.async) {
-            // subs aren't sorted in scheduler if not running async
-            // we need to sort them now to make sure they fire in correct
-            // order
-            subs.sort(function (a, b) { return a.id - b.id; });
-        }
-        for (var i = 0, l = subs.length; i < l; i++) {
-            subs[i].update();
-        }
-    };
-    return Dep;
-}());
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null;
-var targetStack = [];
-function pushTarget(target) {
-    targetStack.push(target);
-    Dep.target = target;
-}
-function popTarget() {
-    targetStack.pop();
-    Dep.target = targetStack[targetStack.length - 1];
-}
-
-var VNode = /** @class */ (function () {
-    function VNode(tag, data, children, text, elm, context, componentOptions, asyncFactory) {
-        this.tag = tag;
-        this.data = data;
-        this.children = children;
-        this.text = text;
-        this.elm = elm;
-        this.ns = undefined;
-        this.context = context;
-        this.fnContext = undefined;
-        this.fnOptions = undefined;
-        this.fnScopeId = undefined;
-        this.key = data && data.key;
-        this.componentOptions = componentOptions;
-        this.componentInstance = undefined;
-        this.parent = undefined;
-        this.raw = false;
-        this.isStatic = false;
-        this.isRootInsert = true;
-        this.isComment = false;
-        this.isCloned = false;
-        this.isOnce = false;
-        this.asyncFactory = asyncFactory;
-        this.asyncMeta = undefined;
-        this.isAsyncPlaceholder = false;
-    }
-    Object.defineProperty(VNode.prototype, "child", {
-        // DEPRECATED: alias for componentInstance for backwards compat.
-        /* istanbul ignore next */
-        get: function () {
-            return this.componentInstance;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return VNode;
-}());
-var createEmptyVNode = function (text) {
-    if (text === void 0) { text = ''; }
-    var node = new VNode();
-    node.text = text;
-    node.isComment = true;
-    return node;
-};
-function createTextVNode(val) {
-    return new VNode(undefined, undefined, undefined, String(val));
-}
-// optimized shallow clone
-// used for static nodes and slot nodes because they may be reused across
-// multiple renders, cloning them avoids errors when DOM manipulations rely
-// on their elm reference.
-function cloneVNode(vnode) {
-    var cloned = new VNode(
-    //@ts-expect-error void type not valid here
-    vnode.tag, vnode.data, 
-    // #7975
-    // clone children array to avoid mutating original in case of cloning
-    // a child.
-    vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory);
-    cloned.ns = vnode.ns;
-    cloned.isStatic = vnode.isStatic;
-    cloned.key = vnode.key;
-    cloned.isComment = vnode.isComment;
-    cloned.fnContext = vnode.fnContext;
-    cloned.fnOptions = vnode.fnOptions;
-    cloned.fnScopeId = vnode.fnScopeId;
-    cloned.asyncMeta = vnode.asyncMeta;
-    cloned.isCloned = true;
-    return cloned;
-}
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-var arrayProto = Array.prototype;
-var arrayMethods = Object.create(arrayProto);
-var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse' ];
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method];
-    def(arrayMethods, method, function mutator() {
-        var arguments$1 = arguments;
-
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments$1[_i];
-        }
-        var result = original.apply(this, args);
-        var ob = this.__ob__;
-        var inserted;
-        switch (method) {
-            case 'push':
-            case 'unshift':
-                inserted = args;
-                break;
-            case 'splice':
-                inserted = args.slice(2);
-                break;
-        }
-        if (inserted)
-            { ob.observeArray(inserted); }
-        // notify change
-        ob.dep.notify();
-        return result;
-    });
-});
-
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-/**
- * In some cases we may want to disable observation inside a component's
- * update computation.
- */
-var shouldObserve = true;
-function toggleObserving(value) {
-    shouldObserve = value;
-}
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-var Observer = /** @class */ (function () {
-    function Observer(value) {
-        this.value = value;
-        this.dep = new Dep();
-        this.vmCount = 0;
-        def(value, '__ob__', this);
-        if (Array.isArray(value)) {
-            if (hasProto) {
-                protoAugment(value, arrayMethods);
-            }
-            else {
-                copyAugment(value, arrayMethods, arrayKeys);
-            }
-            this.observeArray(value);
-        }
-        else {
-            this.walk(value);
-        }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-        var keys = Object.keys(obj);
-        for (var i = 0; i < keys.length; i++) {
-            defineReactive(obj, keys[i]);
-        }
-    };
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-        for (var i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
-        }
-    };
-    return Observer;
-}());
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src;
-    /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-        var key = keys[i];
-        def(target, key, src[key]);
-    }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-        return;
-    }
-    var ob;
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-        ob = value.__ob__;
-    }
-    else if (shouldObserve &&
-        !isServerRendering() &&
-        (Array.isArray(value) || isPlainObject(value)) &&
-        Object.isExtensible(value) &&
-        !value._isVue) {
-        ob = new Observer(value);
-    }
-    if (asRootData && ob) {
-        ob.vmCount++;
-    }
-    return ob;
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep();
-    var property = Object.getOwnPropertyDescriptor(obj, key);
-    if (property && property.configurable === false) {
-        return;
-    }
-    // cater for pre-defined getter/setters
-    var getter = property && property.get;
-    var setter = property && property.set;
-    if ((!getter || setter) && arguments.length === 2) {
-        val = obj[key];
-    }
-    var childOb = !shallow && observe(val);
-    Object.defineProperty(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function reactiveGetter() {
-            var value = getter ? getter.call(obj) : val;
-            if (Dep.target) {
-                dep.depend();
-                if (childOb) {
-                    childOb.dep.depend();
-                    if (Array.isArray(value)) {
-                        dependArray(value);
-                    }
-                }
-            }
-            return value;
-        },
-        set: function reactiveSetter(newVal) {
-            var value = getter ? getter.call(obj) : val;
-            /* eslint-disable no-self-compare */
-            if (newVal === value || (newVal !== newVal && value !== value)) {
-                return;
-            }
-            /* eslint-enable no-self-compare */
-            if (process.env.NODE_ENV !== 'production' && customSetter) {
-                customSetter();
-            }
-            // #7981: for accessor properties without setter
-            if (getter && !setter)
-                { return; }
-            if (setter) {
-                setter.call(obj, newVal);
-            }
-            else {
-                val = newVal;
-            }
-            childOb = !shallow && observe(newVal);
-            dep.notify();
-        },
-    });
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.length = Math.max(target.length, key);
-        target.splice(key, 1, val);
-        return val;
-    }
-    if (key in target && !(key in Object.prototype)) {
-        target[key] = val;
-        return val;
-    }
-    var ob = target.__ob__;
-    // @ts-ignore
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
-                'at runtime - declare it upfront in the data option.');
-        return val;
-    }
-    if (!ob) {
-        target[key] = val;
-        return val;
-    }
-    defineReactive(ob.value, key, val);
-    ob.dep.notify();
-    return val;
-}
-/**
- * Delete a property and trigger change if necessary.
- */
-function del(target, key) {
-    if (process.env.NODE_ENV !== 'production' &&
-        (isUndef(target) || isPrimitive(target))) {
-        warn("Cannot delete reactive property on undefined, null, or primitive value: " + target);
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-        target.splice(key, 1);
-        return;
-    }
-    var ob = target.__ob__;
-    //@ts-ignore
-    if (target._isVue || (ob && ob.vmCount)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn('Avoid deleting properties on a Vue instance or its root $data ' +
-                '- just set it to null.');
-        return;
-    }
-    if (!hasOwn(target, key)) {
-        return;
-    }
-    delete target[key];
-    if (!ob) {
-        return;
-    }
-    ob.dep.notify();
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
-        e = value[i];
-        e && e.__ob__ && e.__ob__.dep.depend();
-        if (Array.isArray(e)) {
-            dependArray(e);
-        }
-    }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-var strats = config.optionMergeStrategies;
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-        if (!vm) {
-            warn("option \"" + key + "\" can only be used during instance " +
-                'creation with the `new` keyword.');
-        }
-        return defaultStrat(parent, child);
-    };
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-    if (!from)
-        { return to; }
-    var key, toVal, fromVal;
-    var keys = hasSymbol
-        ? Reflect.ownKeys(from)
-        : Object.keys(from);
-    for (var i = 0; i < keys.length; i++) {
-        key = keys[i];
-        // in case the object is already observed...
-        if (key === '__ob__')
-            { continue; }
-        toVal = to[key];
-        fromVal = from[key];
-        if (!hasOwn(to, key)) {
-            set(to, key, fromVal);
-        }
-        else if (toVal !== fromVal &&
-            isPlainObject(toVal) &&
-            isPlainObject(fromVal)) {
-            mergeData(toVal, fromVal);
-        }
-    }
-    return to;
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-        // in a Vue.extend merge, both should be functions
-        if (!childVal) {
-            return parentVal;
-        }
-        if (!parentVal) {
-            return childVal;
-        }
-        // when parentVal & childVal are both present,
-        // we need to return a function that returns the
-        // merged result of both functions... no need to
-        // check if parentVal is a function here because
-        // it has to be a function to pass previous merges.
-        return function mergedDataFn() {
-            return mergeData(
-            // @ts-ignore
-            typeof childVal === 'function' ? childVal.call(this, this) : childVal, 
-            // @ts-ignore
-            typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal);
-        };
-    }
-    else {
-        return function mergedInstanceDataFn() {
-            // instance merge
-            var instanceData = typeof childVal === 'function' ? childVal.call(vm, vm) : childVal;
-            var defaultData = typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal;
-            if (instanceData) {
-                return mergeData(instanceData, defaultData);
-            }
-            else {
-                return defaultData;
-            }
-        };
-    }
-}
-strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-        if (childVal && typeof childVal !== 'function') {
-            process.env.NODE_ENV !== 'production' &&
-                warn('The "data" option should be a function ' +
-                    'that returns a per-instance value in component ' +
-                    'definitions.', vm);
-            return parentVal;
-        }
-        return mergeDataOrFn(parentVal, childVal);
-    }
-    return mergeDataOrFn(parentVal, childVal, vm);
-};
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook$1(parentVal, childVal) {
-    var res = childVal
-        ? parentVal
-            ? parentVal.concat(childVal)
-            : Array.isArray(childVal)
-                ? childVal
-                : [childVal]
-        : parentVal;
-    return res ? dedupeHooks(res) : res;
-}
-function dedupeHooks(hooks) {
-    var res = [];
-    for (var i = 0; i < hooks.length; i++) {
-        if (res.indexOf(hooks[i]) === -1) {
-            res.push(hooks[i]);
-        }
-    }
-    return res;
-}
-LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook$1;
-});
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null);
-    if (childVal) {
-        process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);
-        return extend(res, childVal);
-    }
-    else {
-        return res;
-    }
-}
-ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets;
-});
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch)
-        { parentVal = undefined; }
-    //@ts-expect-error work around
-    if (childVal === nativeWatch)
-        { childVal = undefined; }
-    /* istanbul ignore if */
-    if (!childVal)
-        { return Object.create(parentVal || null); }
-    if (process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        { return childVal; }
-    var ret = {};
-    extend(ret, parentVal);
-    for (var key_1 in childVal) {
-        var parent_1 = ret[key_1];
-        var child = childVal[key_1];
-        if (parent_1 && !Array.isArray(parent_1)) {
-            parent_1 = [parent_1];
-        }
-        ret[key_1] = parent_1
-            ? parent_1.concat(child)
-            : Array.isArray(child)
-                ? child
-                : [child];
-    }
-    return ret;
-};
-/**
- * Other object hashes.
- */
-strats.props = strats.methods = strats.inject = strats.computed = function (parentVal, childVal, vm, key) {
-    if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm);
-    }
-    if (!parentVal)
-        { return childVal; }
-    var ret = Object.create(null);
-    extend(ret, parentVal);
-    if (childVal)
-        { extend(ret, childVal); }
-    return ret;
-};
-strats.provide = mergeDataOrFn;
-/**
- * Default strategy.
- */
-var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal;
-};
-/**
- * Validate component names
- */
-function checkComponents(options) {
-    for (var key in options.components) {
-        validateComponentName(key);
-    }
-}
-function validateComponentName(name) {
-    if (!new RegExp("^[a-zA-Z][\\-\\.0-9_" + unicodeRegExp.source + "]*$").test(name)) {
-        warn('Invalid component name: "' +
-            name +
-            '". Component names ' +
-            'should conform to valid custom element name in html5 specification.');
-    }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-        warn('Do not use built-in or reserved HTML elements as component ' +
-            'id: ' +
-            name);
-    }
-}
-/**
- * Ensure all props option syntax are normalized into the
- * Object-based format.
- */
-function normalizeProps(options, vm) {
-    var props = options.props;
-    if (!props)
-        { return; }
-    var res = {};
-    var i, val, name;
-    if (Array.isArray(props)) {
-        i = props.length;
-        while (i--) {
-            val = props[i];
-            if (typeof val === 'string') {
-                name = camelize(val);
-                res[name] = { type: null };
-            }
-            else if (process.env.NODE_ENV !== 'production') {
-                warn('props must be strings when using array syntax.');
-            }
-        }
-    }
-    else if (isPlainObject(props)) {
-        for (var key in props) {
-            val = props[key];
-            name = camelize(key);
-            res[name] = isPlainObject(val) ? val : { type: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn("Invalid value for option \"props\": expected an Array or an Object, " +
-            ("but got " + toRawType(props) + "."), vm);
-    }
-    options.props = res;
-}
-/**
- * Normalize all injections into Object-based format
- */
-function normalizeInject(options, vm) {
-    var inject = options.inject;
-    if (!inject)
-        { return; }
-    var normalized = (options.inject = {});
-    if (Array.isArray(inject)) {
-        for (var i = 0; i < inject.length; i++) {
-            normalized[inject[i]] = { from: inject[i] };
-        }
-    }
-    else if (isPlainObject(inject)) {
-        for (var key in inject) {
-            var val = inject[key];
-            normalized[key] = isPlainObject(val)
-                ? extend({ from: key }, val)
-                : { from: val };
-        }
-    }
-    else if (process.env.NODE_ENV !== 'production') {
-        warn("Invalid value for option \"inject\": expected an Array or an Object, " +
-            ("but got " + toRawType(inject) + "."), vm);
-    }
-}
-/**
- * Normalize raw function directives into object format.
- */
-function normalizeDirectives$1(options) {
-    var dirs = options.directives;
-    if (dirs) {
-        for (var key in dirs) {
-            var def = dirs[key];
-            if (typeof def === 'function') {
-                dirs[key] = { bind: def, update: def };
-            }
-        }
-    }
-}
-function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-        warn("Invalid value for option \"" + name + "\": expected an Object, " +
-            ("but got " + toRawType(value) + "."), vm);
-    }
-}
-/**
- * Merge two option objects into a new one.
- * Core utility used in both instantiation and inheritance.
- */
-function mergeOptions(parent, child, vm) {
-    if (process.env.NODE_ENV !== 'production') {
-        checkComponents(child);
-    }
-    if (typeof child === 'function') {
-        // @ts-expect-error
-        child = child.options;
-    }
-    normalizeProps(child, vm);
-    normalizeInject(child, vm);
-    normalizeDirectives$1(child);
-    // Apply extends and mixins on the child options,
-    // but only if it is a raw options object that isn't
-    // the result of another mergeOptions call.
-    // Only merged options has the _base property.
-    if (!child._base) {
-        if (child.extends) {
-            parent = mergeOptions(parent, child.extends, vm);
-        }
-        if (child.mixins) {
-            for (var i = 0, l = child.mixins.length; i < l; i++) {
-                parent = mergeOptions(parent, child.mixins[i], vm);
-            }
-        }
-    }
-    var options = {};
-    var key;
-    for (key in parent) {
-        mergeField(key);
-    }
-    for (key in child) {
-        if (!hasOwn(parent, key)) {
-            mergeField(key);
-        }
-    }
-    function mergeField(key) {
-        var strat = strats[key] || defaultStrat;
-        options[key] = strat(parent[key], child[key], vm, key);
-    }
-    return options;
-}
-/**
- * Resolve an asset.
- * This function is used because child instances need access
- * to assets defined in its ancestor chain.
- */
-function resolveAsset(options, type, id, warnMissing) {
-    /* istanbul ignore if */
-    if (typeof id !== 'string') {
-        return;
-    }
-    var assets = options[type];
-    // check local registration variations first
-    if (hasOwn(assets, id))
-        { return assets[id]; }
-    var camelizedId = camelize(id);
-    if (hasOwn(assets, camelizedId))
-        { return assets[camelizedId]; }
-    var PascalCaseId = capitalize(camelizedId);
-    if (hasOwn(assets, PascalCaseId))
-        { return assets[PascalCaseId]; }
-    // fallback to prototype chain
-    var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
-    if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
-        warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options);
-    }
-    return res;
-}
-
-function validateProp(key, propOptions, propsData, vm) {
-    var prop = propOptions[key];
-    var absent = !hasOwn(propsData, key);
-    var value = propsData[key];
-    // boolean casting
-    var booleanIndex = getTypeIndex(Boolean, prop.type);
-    if (booleanIndex > -1) {
-        if (absent && !hasOwn(prop, 'default')) {
-            value = false;
-        }
-        else if (value === '' || value === hyphenate(key)) {
-            // only cast empty string / same name to boolean if
-            // boolean has higher priority
-            var stringIndex = getTypeIndex(String, prop.type);
-            if (stringIndex < 0 || booleanIndex < stringIndex) {
-                value = true;
-            }
-        }
-    }
-    // check default value
-    if (value === undefined) {
-        value = getPropDefaultValue(vm, prop, key);
-        // since the default value is a fresh copy,
-        // make sure to observe it.
-        var prevShouldObserve = shouldObserve;
-        toggleObserving(true);
-        observe(value);
-        toggleObserving(prevShouldObserve);
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-        // skip validation for weex recycle-list child component props
-        !(isObject(value) && '@binding' in value)) {
-        assertProp(prop, key, value, vm, absent);
-    }
-    return value;
-}
-/**
- * Get the default value of a prop.
- */
-function getPropDefaultValue(vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-        return undefined;
-    }
-    var def = prop.default;
-    // warn against non-factory defaults for Object & Array
-    if (process.env.NODE_ENV !== 'production' && isObject(def)) {
-        warn('Invalid default value for prop "' +
-            key +
-            '": ' +
-            'Props with type Object/Array must use a factory function ' +
-            'to return the default value.', vm);
-    }
-    // the raw prop value was also undefined from previous render,
-    // return previous default value to avoid unnecessary watcher trigger
-    if (vm &&
-        vm.$options.propsData &&
-        vm.$options.propsData[key] === undefined &&
-        vm._props[key] !== undefined) {
-        return vm._props[key];
-    }
-    // call factory function for non-Function types
-    // a value is Function if its prototype is function even across different execution context
-    return typeof def === 'function' && getType(prop.type) !== 'Function'
-        ? def.call(vm)
-        : def;
-}
-/**
- * Assert whether a prop is valid.
- */
-function assertProp(prop, name, value, vm, absent) {
-    if (prop.required && absent) {
-        warn('Missing required prop: "' + name + '"', vm);
-        return;
-    }
-    if (value == null && !prop.required) {
-        return;
-    }
-    var type = prop.type;
-    // @ts-ignore
-    var valid = !type || type === true;
-    var expectedTypes = [];
-    if (type) {
-        if (!Array.isArray(type)) {
-            type = [type];
-        }
-        for (var i = 0; i < type.length && !valid; i++) {
-            var assertedType = assertType(value, type[i], vm);
-            expectedTypes.push(assertedType.expectedType || '');
-            valid = assertedType.valid;
-        }
-    }
-    var haveExpectedTypes = expectedTypes.some(function (t) { return t; });
-    if (!valid && haveExpectedTypes) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes), vm);
-        return;
-    }
-    var validator = prop.validator;
-    if (validator) {
-        if (!validator(value)) {
-            warn('Invalid prop: custom validator check failed for prop "' + name + '".', vm);
-        }
-    }
-}
-var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol|BigInt)$/;
-function assertType(value, type, vm) {
-    var valid;
-    var expectedType = getType(type);
-    if (simpleCheckRE.test(expectedType)) {
-        var t = typeof value;
-        valid = t === expectedType.toLowerCase();
-        // for primitive wrapper objects
-        if (!valid && t === 'object') {
-            valid = value instanceof type;
-        }
-    }
-    else if (expectedType === 'Object') {
-        valid = isPlainObject(value);
-    }
-    else if (expectedType === 'Array') {
-        valid = Array.isArray(value);
-    }
-    else {
-        try {
-            valid = value instanceof type;
-        }
-        catch (e) {
-            warn('Invalid prop type: "' + String(type) + '" is not a constructor', vm);
-            valid = false;
-        }
-    }
-    return {
-        valid: valid,
-        expectedType: expectedType,
-    };
-}
-var functionTypeCheckRE = /^\s*function (\w+)/;
-/**
- * Use function string name to check built-in types,
- * because a simple equality check will fail when running
- * across different vms / iframes.
- */
-function getType(fn) {
-    var match = fn && fn.toString().match(functionTypeCheckRE);
-    return match ? match[1] : '';
-}
-function isSameType(a, b) {
-    return getType(a) === getType(b);
-}
-function getTypeIndex(type, expectedTypes) {
-    if (!Array.isArray(expectedTypes)) {
-        return isSameType(expectedTypes, type) ? 0 : -1;
-    }
-    for (var i = 0, len = expectedTypes.length; i < len; i++) {
-        if (isSameType(expectedTypes[i], type)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function getInvalidTypeMessage(name, value, expectedTypes) {
-    var message = "Invalid prop: type check failed for prop \"" + name + "\"." +
-        (" Expected " + expectedTypes.map(capitalize).join(', '));
-    var expectedType = expectedTypes[0];
-    var receivedType = toRawType(value);
-    // check if we need to specify expected value
-    if (expectedTypes.length === 1 &&
-        isExplicable(expectedType) &&
-        isExplicable(typeof value) &&
-        !isBoolean(expectedType, receivedType)) {
-        message += " with value " + styleValue(value, expectedType);
-    }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-        message += "with value " + styleValue(value, receivedType) + ".";
-    }
-    return message;
-}
-function styleValue(value, type) {
-    if (type === 'String') {
-        return "\"" + value + "\"";
-    }
-    else if (type === 'Number') {
-        return "" + Number(value);
-    }
-    else {
-        return "" + value;
-    }
-}
-var EXPLICABLE_TYPES = ['string', 'number', 'boolean'];
-function isExplicable(value) {
-    return EXPLICABLE_TYPES.some(function (elem) { return value.toLowerCase() === elem; });
-}
-function isBoolean() {
-    var arguments$1 = arguments;
-
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments$1[_i];
-    }
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; });
-}
-
-function handleError(err, vm, info) {
-    // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
-    // See: https://github.com/vuejs/vuex/issues/1505
-    pushTarget();
-    try {
-        if (vm) {
-            var cur = vm;
-            while ((cur = cur.$parent)) {
-                var hooks = cur.$options.errorCaptured;
-                if (hooks) {
-                    for (var i = 0; i < hooks.length; i++) {
-                        try {
-                            var capture = hooks[i].call(cur, err, vm, info) === false;
-                            if (capture)
-                                { return; }
-                        }
-                        catch (e) {
-                            globalHandleError(e, cur, 'errorCaptured hook');
-                        }
-                    }
-                }
-            }
-        }
-        globalHandleError(err, vm, info);
-    }
-    finally {
-        popTarget();
-    }
-}
-function invokeWithErrorHandling(handler, context, args, vm, info) {
-    var res;
-    try {
-        res = args ? handler.apply(context, args) : handler.call(context);
-        if (res && !res._isVue && isPromise(res) && !res._handled) {
-            res.catch(function (e) { return handleError(e, vm, info + " (Promise/async)"); });
-            // issue #9511
-            // avoid catch triggering multiple times when nested calls
-            res._handled = true;
-        }
-    }
-    catch (e) {
-        handleError(e, vm, info);
-    }
-    return res;
-}
-function globalHandleError(err, vm, info) {
-    if (config.errorHandler) {
-        try {
-            return config.errorHandler.call(null, err, vm, info);
-        }
-        catch (e) {
-            // if the user intentionally throws the original error in the handler,
-            // do not log it twice
-            if (e !== err) {
-                logError(e, null, 'config.errorHandler');
-            }
-        }
-    }
-    logError(err, vm, info);
-}
-function logError(err, vm, info) {
-    if (process.env.NODE_ENV !== 'production') {
-        warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
-    }
-    /* istanbul ignore else */
-    if ((inBrowser || inWeex) && typeof console !== 'undefined') {
-        console.error(err);
-    }
-    else {
-        throw err;
-    }
-}
-
-/* globals MutationObserver */
-var callbacks = [];
-var pending = false;
-function flushCallbacks() {
-    pending = false;
-    var copies = callbacks.slice(0);
-    callbacks.length = 0;
-    for (var i = 0; i < copies.length; i++) {
-        copies[i]();
-    }
-}
-// Here we have async deferring wrappers using microtasks.
-// In 2.5 we used (macro) tasks (in combination with microtasks).
-// However, it has subtle problems when state is changed right before repaint
-// (e.g. #6813, out-in transitions).
-// Also, using (macro) tasks in event handler would cause some weird behaviors
-// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).
-// So we now use microtasks everywhere, again.
-// A major drawback of this tradeoff is that there are some scenarios
-// where microtasks have too high a priority and fire in between supposedly
-// sequential events (e.g. #4521, #6690, which have workarounds)
-// or even between bubbling of the same event (#6566).
-var timerFunc;
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    var p_1 = Promise.resolve();
-    timerFunc = function () {
-        p_1.then(flushCallbacks);
-        // In problematic UIWebViews, Promise.then doesn't completely break, but
-        // it can get stuck in a weird state where callbacks are pushed into the
-        // microtask queue but the queue isn't being flushed, until the browser
-        // needs to do some other work, e.g. handle a timer. Therefore we can
-        // "force" the microtask queue to be flushed by adding an empty timer.
-        if (isIOS)
-            { setTimeout(noop); }
-    };
-}
-else if (!isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-        // PhantomJS and iOS 7.x
-        MutationObserver.toString() === '[object MutationObserverConstructor]')) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1;
-    var observer = new MutationObserver(flushCallbacks);
-    var textNode_1 = document.createTextNode(String(counter_1));
-    observer.observe(textNode_1, {
-        characterData: true,
-    });
-    timerFunc = function () {
-        counter_1 = (counter_1 + 1) % 2;
-        textNode_1.data = String(counter_1);
-    };
-}
-else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
-    // Fallback to setImmediate.
-    // Technically it leverages the (macro) task queue,
-    // but it is still a better choice than setTimeout.
-    timerFunc = function () {
-        setImmediate(flushCallbacks);
-    };
-}
-else {
-    // Fallback to setTimeout.
-    timerFunc = function () {
-        setTimeout(flushCallbacks, 0);
-    };
-}
-function nextTick(cb, ctx) {
-    var _resolve;
-    callbacks.push(function () {
-        if (cb) {
-            try {
-                cb.call(ctx);
-            }
-            catch (e) {
-                handleError(e, ctx, 'nextTick');
-            }
-        }
-        else if (_resolve) {
-            _resolve(ctx);
-        }
-    });
-    if (!pending) {
-        pending = true;
-        timerFunc();
-    }
-    // $flow-disable-line
-    if (!cb && typeof Promise !== 'undefined') {
-        return new Promise(function (resolve) {
-            _resolve = resolve;
-        });
-    }
-}
-
-/* not type checking this file because flow doesn't play well with Proxy */
-var initProxy;
-if (process.env.NODE_ENV !== 'production') {
-    var allowedGlobals_1 = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' +
-        'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
-        'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' +
-        'require' // for Webpack/Browserify
-    );
-    var warnNonPresent_1 = function (target, key) {
-        warn("Property or method \"" + key + "\" is not defined on the instance but " +
-            'referenced during render. Make sure that this property is reactive, ' +
-            'either in the data option, or for class-based components, by ' +
-            'initializing the property. ' +
-            'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
-    };
-    var warnReservedPrefix_1 = function (target, key) {
-        warn("Property \"" + key + "\" must be accessed with \"$data." + key + "\" because " +
-            'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
-            'prevent conflicts with Vue internals. ' +
-            'See: https://vuejs.org/v2/api/#data', target);
-    };
-    var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
-    if (hasProxy_1) {
-        var isBuiltInModifier_1 = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');
-        config.keyCodes = new Proxy(config.keyCodes, {
-            set: function (target, key, value) {
-                if (isBuiltInModifier_1(key)) {
-                    warn("Avoid overwriting built-in modifier in config.keyCodes: ." + key);
-                    return false;
-                }
-                else {
-                    target[key] = value;
-                    return true;
-                }
-            },
-        });
-    }
-    var hasHandler_1 = {
-        has: function (target, key) {
-            var has = key in target;
-            var isAllowed = allowedGlobals_1(key) ||
-                (typeof key === 'string' &&
-                    key.charAt(0) === '_' &&
-                    !(key in target.$data));
-            if (!has && !isAllowed) {
-                if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
-                else
-                    { warnNonPresent_1(target, key); }
-            }
-            return has || !isAllowed;
-        },
-    };
-    var getHandler_1 = {
-        get: function (target, key) {
-            if (typeof key === 'string' && !(key in target)) {
-                if (key in target.$data)
-                    { warnReservedPrefix_1(target, key); }
-                else
-                    { warnNonPresent_1(target, key); }
-            }
-            return target[key];
-        },
-    };
-    initProxy = function initProxy(vm) {
-        if (hasProxy_1) {
-            // determine which proxy handler to use
-            var options = vm.$options;
-            var handlers = options.render && options.render._withStripped ? getHandler_1 : hasHandler_1;
-            vm._renderProxy = new Proxy(vm, handlers);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-    };
-}
-
-var seenObjects = new _Set();
-/**
- * Recursively traverse an object to evoke all converted
- * getters, so that every nested property inside the object
- * is collected as a "deep" dependency.
- */
-function traverse(val) {
-    _traverse(val, seenObjects);
-    seenObjects.clear();
-}
-function _traverse(val, seen) {
-    var i, keys;
-    var isA = Array.isArray(val);
-    if ((!isA && !isObject(val)) ||
-        Object.isFrozen(val) ||
-        val instanceof VNode) {
-        return;
-    }
-    if (val.__ob__) {
-        var depId = val.__ob__.dep.id;
-        if (seen.has(depId)) {
-            return;
-        }
-        seen.add(depId);
-    }
-    if (isA) {
-        i = val.length;
-        while (i--)
-            { _traverse(val[i], seen); }
-    }
-    else {
-        keys = Object.keys(val);
-        i = keys.length;
-        while (i--)
-            { _traverse(val[keys[i]], seen); }
-    }
-}
-
-var mark;
-var measure;
-if (process.env.NODE_ENV !== 'production') {
-    var perf_1 = inBrowser && window.performance;
-    /* istanbul ignore if */
-    if (perf_1 &&
-        perf_1.mark &&
-        perf_1.measure &&
-        perf_1.clearMarks &&
-        perf_1.clearMeasures) {
-        mark = function (tag) { return perf_1.mark(tag); };
-        measure = function (name, startTag, endTag) {
-            perf_1.measure(name, startTag, endTag);
-            perf_1.clearMarks(startTag);
-            perf_1.clearMarks(endTag);
-            // perf.clearMeasures(name)
-        };
-    }
-}
-
-var normalizeEvent = cached(function (name) {
-    var passive = name.charAt(0) === '&';
-    name = passive ? name.slice(1) : name;
-    var once = name.charAt(0) === '~'; // Prefixed last, checked first
-    name = once ? name.slice(1) : name;
-    var capture = name.charAt(0) === '!';
-    name = capture ? name.slice(1) : name;
-    return {
-        name: name,
-        once: once,
-        capture: capture,
-        passive: passive,
-    };
-});
-function createFnInvoker(fns, vm) {
-    function invoker() {
-        var arguments$1 = arguments;
-
-        var fns = invoker.fns;
-        if (Array.isArray(fns)) {
-            var cloned = fns.slice();
-            for (var i = 0; i < cloned.length; i++) {
-                invokeWithErrorHandling(cloned[i], null, arguments$1, vm, "v-on handler");
-            }
-        }
-        else {
-            // return handler return value for single handlers
-            return invokeWithErrorHandling(fns, null, arguments, vm, "v-on handler");
-        }
-    }
-    invoker.fns = fns;
-    return invoker;
-}
-function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) {
-    var name, def, cur, old, event;
-    for (name in on) {
-        def = cur = on[name];
-        old = oldOn[name];
-        event = normalizeEvent(name);
-        /* istanbul ignore if */
-        if (isPlainObject(def)) {
-            cur = def.handler;
-            event.params = def.params;
-        }
-        if (isUndef(cur)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn("Invalid handler for event \"" + event.name + "\": got " + String(cur), vm);
-        }
-        else if (isUndef(old)) {
-            if (isUndef(cur.fns)) {
-                cur = on[name] = createFnInvoker(cur, vm);
-            }
-            if (isTrue(event.once)) {
-                cur = on[name] = createOnceHandler(event.name, cur, event.capture);
-            }
-            add(event.name, cur, event.capture, event.passive, event.params);
-        }
-        else if (cur !== old) {
-            old.fns = cur;
-            on[name] = old;
-        }
-    }
-    for (name in oldOn) {
-        if (isUndef(on[name])) {
-            event = normalizeEvent(name);
-            remove(event.name, oldOn[name], event.capture);
-        }
-    }
-}
-
-function mergeVNodeHook(def, hookKey, hook) {
-    if (def instanceof VNode) {
-        def = def.data.hook || (def.data.hook = {});
-    }
-    var invoker;
-    var oldHook = def[hookKey];
-    function wrappedHook() {
-        hook.apply(this, arguments);
-        // important: remove merged hook to ensure it's called only once
-        // and prevent memory leak
-        remove$2(invoker.fns, wrappedHook);
-    }
-    if (isUndef(oldHook)) {
-        // no existing hook
-        invoker = createFnInvoker([wrappedHook]);
-    }
-    else {
-        /* istanbul ignore if */
-        if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
-            // already a merged invoker
-            invoker = oldHook;
-            invoker.fns.push(wrappedHook);
-        }
-        else {
-            // existing plain hook
-            invoker = createFnInvoker([oldHook, wrappedHook]);
-        }
-    }
-    invoker.merged = true;
-    def[hookKey] = invoker;
-}
-
-function extractPropsFromVNodeData(data, Ctor, tag) {
-    // we are only extracting raw values here.
-    // validation and default values are handled in the child
-    // component itself.
-    var propOptions = Ctor.options.props;
-    if (isUndef(propOptions)) {
-        return;
-    }
-    var res = {};
-    var attrs = data.attrs, props = data.props;
-    if (isDef(attrs) || isDef(props)) {
-        for (var key in propOptions) {
-            var altKey = hyphenate(key);
-            if (process.env.NODE_ENV !== 'production') {
-                var keyInLowerCase = key.toLowerCase();
-                if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
-                    tip("Prop \"" + keyInLowerCase + "\" is passed to component " +
-                        (formatComponentName(
-                        // @ts-ignore
-                        tag || Ctor) + ", but the declared prop name is") +
-                        (" \"" + key + "\". ") +
-                        "Note that HTML attributes are case-insensitive and camelCased " +
-                        "props need to use their kebab-case equivalents when using in-DOM " +
-                        ("templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."));
-                }
-            }
-            checkProp(res, props, key, altKey, true) ||
-                checkProp(res, attrs, key, altKey, false);
-        }
-    }
-    return res;
-}
-function checkProp(res, hash, key, altKey, preserve) {
-    if (isDef(hash)) {
-        if (hasOwn(hash, key)) {
-            res[key] = hash[key];
-            if (!preserve) {
-                delete hash[key];
-            }
-            return true;
-        }
-        else if (hasOwn(hash, altKey)) {
-            res[key] = hash[altKey];
-            if (!preserve) {
-                delete hash[altKey];
-            }
-            return true;
-        }
-    }
-    return false;
-}
-
-// The template compiler attempts to minimize the need for normalization by
-// statically analyzing the template at compile time.
-//
-// For plain HTML markup, normalization can be completely skipped because the
-// generated render function is guaranteed to return Array<VNode>. There are
-// two cases where extra normalization is needed:
-// 1. When the children contains components - because a functional component
-// may return an Array instead of a single root. In this case, just a simple
-// normalization is needed - if any child is an Array, we flatten the whole
-// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
-// because functional components already normalize their own children.
-function simpleNormalizeChildren(children) {
-    for (var i = 0; i < children.length; i++) {
-        if (Array.isArray(children[i])) {
-            return Array.prototype.concat.apply([], children);
-        }
-    }
-    return children;
-}
-// 2. When the children contains constructs that always generated nested Arrays,
-// e.g. <template>, <slot>, v-for, or when the children is provided by user
-// with hand-written render functions / JSX. In such cases a full normalization
-// is needed to cater to all possible types of children values.
-function normalizeChildren(children) {
-    return isPrimitive(children)
-        ? [createTextVNode(children)]
-        : Array.isArray(children)
-            ? normalizeArrayChildren(children)
-            : undefined;
-}
-function isTextNode(node) {
-    return isDef(node) && isDef(node.text) && isFalse(node.isComment);
-}
-function normalizeArrayChildren(children, nestedIndex) {
-    var res = [];
-    var i, c, lastIndex, last;
-    for (i = 0; i < children.length; i++) {
-        c = children[i];
-        if (isUndef(c) || typeof c === 'boolean')
-            { continue; }
-        lastIndex = res.length - 1;
-        last = res[lastIndex];
-        //  nested
-        if (Array.isArray(c)) {
-            if (c.length > 0) {
-                c = normalizeArrayChildren(c, (nestedIndex || '') + "_" + i);
-                // merge adjacent text nodes
-                if (isTextNode(c[0]) && isTextNode(last)) {
-                    res[lastIndex] = createTextVNode(last.text + c[0].text);
-                    c.shift();
-                }
-                res.push.apply(res, c);
-            }
-        }
-        else if (isPrimitive(c)) {
-            if (isTextNode(last)) {
-                // merge adjacent text nodes
-                // this is necessary for SSR hydration because text nodes are
-                // essentially merged when rendered to HTML strings
-                res[lastIndex] = createTextVNode(last.text + c);
-            }
-            else if (c !== '') {
-                // convert primitive to vnode
-                res.push(createTextVNode(c));
-            }
-        }
-        else {
-            if (isTextNode(c) && isTextNode(last)) {
-                // merge adjacent text nodes
-                res[lastIndex] = createTextVNode(last.text + c.text);
-            }
-            else {
-                // default key for nested array children (likely generated by v-for)
-                if (isTrue(children._isVList) &&
-                    isDef(c.tag) &&
-                    isUndef(c.key) &&
-                    isDef(nestedIndex)) {
-                    c.key = "__vlist" + nestedIndex + "_" + i + "__";
-                }
-                res.push(c);
-            }
-        }
-    }
-    return res;
-}
-
-function initProvide(vm) {
-    var provide = vm.$options.provide;
-    if (provide) {
-        vm._provided =
-            typeof provide === 'function'
-                ? // @ts-expect-error typing not correct
-                    provide.call(vm)
-                : provide;
-    }
-}
-function initInjections(vm) {
-    var result = resolveInject(vm.$options.inject, vm);
-    if (result) {
-        toggleObserving(false);
-        Object.keys(result).forEach(function (key) {
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production') {
-                defineReactive(vm, key, result[key], function () {
-                    warn("Avoid mutating an injected value directly since the changes will be " +
-                        "overwritten whenever the provided component re-renders. " +
-                        ("injection being mutated: \"" + key + "\""), vm);
-                });
-            }
-            else {
-                defineReactive(vm, key, result[key]);
-            }
-        });
-        toggleObserving(true);
-    }
-}
-function resolveInject(inject, vm) {
-    if (inject) {
-        // inject is :any because flow is not smart enough to figure out cached
-        var result = Object.create(null);
-        var keys = hasSymbol ? Reflect.ownKeys(inject) : Object.keys(inject);
-        for (var i = 0; i < keys.length; i++) {
-            var key = keys[i];
-            // #6574 in case the inject object is observed...
-            if (key === '__ob__')
-                { continue; }
-            var provideKey = inject[key].from;
-            var source = vm;
-            while (source) {
-                if (source._provided && hasOwn(source._provided, provideKey)) {
-                    result[key] = source._provided[provideKey];
-                    break;
-                }
-                // @ts-expect-error
-                source = source.$parent;
-            }
-            if (!source) {
-                if ('default' in inject[key]) {
-                    var provideDefault = inject[key].default;
-                    result[key] =
-                        typeof provideDefault === 'function'
-                            ? provideDefault.call(vm)
-                            : provideDefault;
-                }
-                else if (process.env.NODE_ENV !== 'production') {
-                    // @ts-ignore
-                    warn("Injection \"" + key + "\" not found", vm);
-                }
-            }
-        }
-        return result;
-    }
-}
-
-/**
- * Runtime helper for resolving raw children VNodes into a slot object.
- */
-function resolveSlots(children, context) {
-    if (!children || !children.length) {
-        return {};
-    }
-    var slots = {};
-    for (var i = 0, l = children.length; i < l; i++) {
-        var child = children[i];
-        var data = child.data;
-        // remove slot attribute if the node is resolved as a Vue slot node
-        if (data && data.attrs && data.attrs.slot) {
-            delete data.attrs.slot;
-        }
-        // named slots should only be respected if the vnode was rendered in the
-        // same context.
-        if ((child.context === context || child.fnContext === context) &&
-            data &&
-            data.slot != null) {
-            var name_1 = data.slot;
-            var slot = slots[name_1] || (slots[name_1] = []);
-            if (child.tag === 'template') {
-                slot.push.apply(slot, child.children || []);
-            }
-            else {
-                slot.push(child);
-            }
-        }
-        else {
-            (slots.default || (slots.default = [])).push(child);
-        }
-    }
-    // ignore slots that contains only whitespace
-    for (var name_2 in slots) {
-        if (slots[name_2].every(isWhitespace)) {
-            delete slots[name_2];
-        }
-    }
-    return slots;
-}
-function isWhitespace(node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' ';
-}
-
-function normalizeScopedSlots(slots, normalSlots, prevSlots) {
-    var res;
-    var hasNormalSlots = Object.keys(normalSlots).length > 0;
-    var isStable = slots ? !!slots.$stable : !hasNormalSlots;
-    var key = slots && slots.$key;
-    if (!slots) {
-        res = {};
-    }
-    else if (slots._normalized) {
-        // fast path 1: child component re-render only, parent did not change
-        return slots._normalized;
-    }
-    else if (isStable &&
-        prevSlots &&
-        prevSlots !== emptyObject &&
-        key === prevSlots.$key &&
-        !hasNormalSlots &&
-        !prevSlots.$hasNormal) {
-        // fast path 2: stable scoped slots w/ no normal slots to proxy,
-        // only need to normalize once
-        return prevSlots;
-    }
-    else {
-        res = {};
-        for (var key_1 in slots) {
-            if (slots[key_1] && key_1[0] !== '$') {
-                res[key_1] = normalizeScopedSlot(normalSlots, key_1, slots[key_1]);
-            }
-        }
-    }
-    // expose normal slots on scopedSlots
-    for (var key_2 in normalSlots) {
-        if (!(key_2 in res)) {
-            res[key_2] = proxyNormalSlot(normalSlots, key_2);
-        }
-    }
-    // avoriaz seems to mock a non-extensible $scopedSlots object
-    // and when that is passed down this would cause an error
-    if (slots && Object.isExtensible(slots)) {
-        slots._normalized = res;
-    }
-    def(res, '$stable', isStable);
-    def(res, '$key', key);
-    def(res, '$hasNormal', hasNormalSlots);
-    return res;
-}
-function normalizeScopedSlot(normalSlots, key, fn) {
-    var normalized = function () {
-        var res = arguments.length ? fn.apply(null, arguments) : fn({});
-        res =
-            res && typeof res === 'object' && !Array.isArray(res)
-                ? [res] // single vnode
-                : normalizeChildren(res);
-        return res && (res.length === 0 || (res.length === 1 && res[0].isComment)) // #9658
-            ? undefined
-            : res;
-    };
-    // this is a slot using the new v-slot syntax without scope. although it is
-    // compiled as a scoped slot, render fn users would expect it to be present
-    // on this.$slots because the usage is semantically a normal slot.
-    if (fn.proxy) {
-        Object.defineProperty(normalSlots, key, {
-            get: normalized,
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    return normalized;
-}
-function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; };
-}
-
-/**
- * Runtime helper for rendering v-for lists.
- */
-function renderList(val, render) {
-    var ret = null, i, l, keys, key;
-    if (Array.isArray(val) || typeof val === 'string') {
-        ret = new Array(val.length);
-        for (i = 0, l = val.length; i < l; i++) {
-            ret[i] = render(val[i], i);
-        }
-    }
-    else if (typeof val === 'number') {
-        ret = new Array(val);
-        for (i = 0; i < val; i++) {
-            ret[i] = render(i + 1, i);
-        }
-    }
-    else if (isObject(val)) {
-        if (hasSymbol && val[Symbol.iterator]) {
-            ret = [];
-            var iterator = val[Symbol.iterator]();
-            var result = iterator.next();
-            while (!result.done) {
-                ret.push(render(result.value, ret.length));
-                result = iterator.next();
-            }
-        }
-        else {
-            keys = Object.keys(val);
-            ret = new Array(keys.length);
-            for (i = 0, l = keys.length; i < l; i++) {
-                key = keys[i];
-                ret[i] = render(val[key], key, i);
-            }
-        }
-    }
-    if (!isDef(ret)) {
-        ret = [];
-    }
-    ret._isVList = true;
-    return ret;
-}
-
-/**
- * Runtime helper for rendering <slot>
- */
-function renderSlot(name, fallback, props, bindObject) {
-    var scopedSlotFn = this.$scopedSlots[name];
-    var nodes;
-    if (scopedSlotFn) {
-        // scoped slot
-        props = props || {};
-        if (bindObject) {
-            if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
-                warn('slot v-bind without argument expects an Object', this);
-            }
-            props = extend(extend({}, bindObject), props);
-        }
-        nodes = scopedSlotFn(props) || fallback;
-    }
-    else {
-        nodes = this.$slots[name] || fallback;
-    }
-    var target = props && props.slot;
-    if (target) {
-        return this.$createElement('template', { slot: target }, nodes);
-    }
-    else {
-        return nodes;
-    }
-}
-
-/**
- * Runtime helper for resolving filters
- */
-function resolveFilter(id) {
-    return resolveAsset(this.$options, 'filters', id, true) || identity;
-}
-
-function isKeyNotMatch(expect, actual) {
-    if (Array.isArray(expect)) {
-        return expect.indexOf(actual) === -1;
-    }
-    else {
-        return expect !== actual;
-    }
-}
-/**
- * Runtime helper for checking keyCodes from config.
- * exposed as Vue.prototype._k
- * passing in eventKeyName as last argument separately for backwards compat
- */
-function checkKeyCodes(eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
-    var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;
-    if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {
-        return isKeyNotMatch(builtInKeyName, eventKeyName);
-    }
-    else if (mappedKeyCode) {
-        return isKeyNotMatch(mappedKeyCode, eventKeyCode);
-    }
-    else if (eventKeyName) {
-        return hyphenate(eventKeyName) !== key;
-    }
-}
-
-/**
- * Runtime helper for merging v-bind="object" into a VNode's data.
- */
-function bindObjectProps(data, tag, value, asProp, isSync) {
-    if (value) {
-        if (!isObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('v-bind without argument expects an Object or Array value', this);
-        }
-        else {
-            if (Array.isArray(value)) {
-                value = toObject$1(value);
-            }
-            var hash = void 0;
-            var _loop_1 = function (key) {
-                if (key === 'class' || key === 'style' || isReservedAttribute(key)) {
-                    hash = data;
-                }
-                else {
-                    var type = data.attrs && data.attrs.type;
-                    hash =
-                        asProp || config.mustUseProp(tag, type, key)
-                            ? data.domProps || (data.domProps = {})
-                            : data.attrs || (data.attrs = {});
-                }
-                var camelizedKey = camelize(key);
-                var hyphenatedKey = hyphenate(key);
-                if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {
-                    hash[key] = value[key];
-                    if (isSync) {
-                        var on = data.on || (data.on = {});
-                        on["update:" + key] = function ($event) {
-                            value[key] = $event;
-                        };
-                    }
-                }
-            };
-            for (var key in value) {
-                _loop_1(key);
-            }
-        }
-    }
-    return data;
-}
-
-/**
- * Runtime helper for rendering static trees.
- */
-function renderStatic(index, isInFor) {
-    var cached = this._staticTrees || (this._staticTrees = []);
-    var tree = cached[index];
-    // if has already-rendered static tree and not inside v-for,
-    // we can reuse the same tree.
-    if (tree && !isInFor) {
-        return tree;
-    }
-    // otherwise, render a fresh tree.
-    tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
-    );
-    markStatic(tree, "__static__" + index, false);
-    return tree;
-}
-/**
- * Runtime helper for v-once.
- * Effectively it means marking the node as static with a unique key.
- */
-function markOnce(tree, index, key) {
-    markStatic(tree, "__once__" + index + (key ? "_" + key : ""), true);
-    return tree;
-}
-function markStatic(tree, key, isOnce) {
-    if (Array.isArray(tree)) {
-        for (var i = 0; i < tree.length; i++) {
-            if (tree[i] && typeof tree[i] !== 'string') {
-                markStaticNode(tree[i], key + "_" + i, isOnce);
-            }
-        }
-    }
-    else {
-        markStaticNode(tree, key, isOnce);
-    }
-}
-function markStaticNode(node, key, isOnce) {
-    node.isStatic = true;
-    node.key = key;
-    node.isOnce = isOnce;
-}
-
-function bindObjectListeners(data, value) {
-    if (value) {
-        if (!isPlainObject(value)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn('v-on without argument expects an Object value', this);
-        }
-        else {
-            var on = (data.on = data.on ? extend({}, data.on) : {});
-            for (var key in value) {
-                var existing = on[key];
-                var ours = value[key];
-                on[key] = existing ? [].concat(existing, ours) : ours;
-            }
-        }
-    }
-    return data;
-}
-
-function resolveScopedSlots(fns, res, 
-// the following are added in 2.6
-hasDynamicKeys, contentHashKey) {
-    res = res || { $stable: !hasDynamicKeys };
-    for (var i = 0; i < fns.length; i++) {
-        var slot = fns[i];
-        if (Array.isArray(slot)) {
-            resolveScopedSlots(slot, res, hasDynamicKeys);
-        }
-        else if (slot) {
-            // marker for reverse proxying v-slot without scope on this.$slots
-            // @ts-expect-error
-            if (slot.proxy) {
-                // @ts-expect-error
-                slot.fn.proxy = true;
-            }
-            res[slot.key] = slot.fn;
-        }
-    }
-    if (contentHashKey) {
-        res.$key = contentHashKey;
-    }
-    return res;
-}
-
-// helper to process dynamic keys for dynamic arguments in v-bind and v-on.
-function bindDynamicKeys(baseObj, values) {
-    for (var i = 0; i < values.length; i += 2) {
-        var key = values[i];
-        if (typeof key === 'string' && key) {
-            baseObj[values[i]] = values[i + 1];
-        }
-        else if (process.env.NODE_ENV !== 'production' &&
-            key !== '' &&
-            key !== null) {
-            // null is a special value for explicitly removing a binding
-            warn("Invalid value for dynamic directive argument (expected string or null): " + key, this);
-        }
-    }
-    return baseObj;
-}
-// helper to dynamically append modifier runtime markers to event names.
-// ensure only append when value is already string, otherwise it will be cast
-// to string and cause the type check to miss.
-function prependModifier(value, symbol) {
-    return typeof value === 'string' ? symbol + value : value;
-}
-
-function installRenderHelpers(target) {
-    target._o = markOnce;
-    target._n = toNumber;
-    target._s = toString;
-    target._l = renderList;
-    target._t = renderSlot;
-    target._q = looseEqual;
-    target._i = looseIndexOf;
-    target._m = renderStatic;
-    target._f = resolveFilter;
-    target._k = checkKeyCodes;
-    target._b = bindObjectProps;
-    target._v = createTextVNode;
-    target._e = createEmptyVNode;
-    target._u = resolveScopedSlots;
-    target._g = bindObjectListeners;
-    target._d = bindDynamicKeys;
-    target._p = prependModifier;
-}
-
-function FunctionalRenderContext(data, props, children, parent, Ctor) {
-    var _this = this;
-    var options = Ctor.options;
-    // ensure the createElement function in functional components
-    // gets a unique context - this is necessary for correct named slot check
-    var contextVm;
-    if (hasOwn(parent, '_uid')) {
-        contextVm = Object.create(parent);
-        // $flow-disable-line
-        contextVm._original = parent;
-    }
-    else {
-        // the context vm passed in is a functional context as well.
-        // in this case we want to make sure we are able to get a hold to the
-        // real context instance.
-        contextVm = parent;
-        // $flow-disable-line
-        parent = parent._original;
-    }
-    var isCompiled = isTrue(options._compiled);
-    var needNormalization = !isCompiled;
-    this.data = data;
-    this.props = props;
-    this.children = children;
-    this.parent = parent;
-    this.listeners = data.on || emptyObject;
-    this.injections = resolveInject(options.inject, parent);
-    this.slots = function () {
-        if (!_this.$slots) {
-            normalizeScopedSlots(data.scopedSlots, (_this.$slots = resolveSlots(children, parent)));
-        }
-        return _this.$slots;
-    };
-    Object.defineProperty(this, 'scopedSlots', {
-        enumerable: true,
-        get: function () {
-            return normalizeScopedSlots(data.scopedSlots, this.slots());
-        },
-    });
-    // support for compiled functional template
-    if (isCompiled) {
-        // exposing $options for renderStatic()
-        this.$options = options;
-        // pre-resolve slots for renderSlot()
-        this.$slots = this.slots();
-        this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);
-    }
-    if (options._scopeId) {
-        this._c = function (a, b, c, d) {
-            var vnode = createElement$1(contextVm, a, b, c, d, needNormalization);
-            if (vnode && !Array.isArray(vnode)) {
-                vnode.fnScopeId = options._scopeId;
-                vnode.fnContext = parent;
-            }
-            return vnode;
-        };
-    }
-    else {
-        this._c = function (a, b, c, d) {
-            return createElement$1(contextVm, a, b, c, d, needNormalization);
-        };
-    }
-}
-installRenderHelpers(FunctionalRenderContext.prototype);
-function createFunctionalComponent(Ctor, propsData, data, contextVm, children) {
-    var options = Ctor.options;
-    var props = {};
-    var propOptions = options.props;
-    if (isDef(propOptions)) {
-        for (var key in propOptions) {
-            props[key] = validateProp(key, propOptions, propsData || emptyObject);
-        }
-    }
-    else {
-        if (isDef(data.attrs))
-            { mergeProps(props, data.attrs); }
-        if (isDef(data.props))
-            { mergeProps(props, data.props); }
-    }
-    var renderContext = new FunctionalRenderContext(data, props, children, contextVm, Ctor);
-    var vnode = options.render.call(null, renderContext._c, renderContext);
-    if (vnode instanceof VNode) {
-        return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext);
-    }
-    else if (Array.isArray(vnode)) {
-        var vnodes = normalizeChildren(vnode) || [];
-        var res = new Array(vnodes.length);
-        for (var i = 0; i < vnodes.length; i++) {
-            res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);
-        }
-        return res;
-    }
-}
-function cloneAndMarkFunctionalResult(vnode, data, contextVm, options, renderContext) {
-    // #7817 clone node before setting fnContext, otherwise if the node is reused
-    // (e.g. it was from a cached normal slot) the fnContext causes named slots
-    // that should not be matched to match.
-    var clone = cloneVNode(vnode);
-    clone.fnContext = contextVm;
-    clone.fnOptions = options;
-    if (process.env.NODE_ENV !== 'production') {
-        (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;
-    }
-    if (data.slot) {
-        (clone.data || (clone.data = {})).slot = data.slot;
-    }
-    return clone;
-}
-function mergeProps(to, from) {
-    for (var key in from) {
-        to[camelize(key)] = from[key];
-    }
-}
-
-var RECYCLE_LIST_MARKER = '@inRecycleList';
-// Register the component hook to weex native render engine.
-// The hook will be triggered by native, not javascript.
-function registerComponentHook(componentId, type, // hook type, could be "lifecycle" or "instance"
-hook, // hook name
-fn) {
-    if (!document || !document.taskCenter) {
-        warn("Can't find available \"document\" or \"taskCenter\".");
-        return;
-    }
-    if (typeof document.taskCenter.registerHook === 'function') {
-        return document.taskCenter.registerHook(componentId, type, hook, fn);
-    }
-    warn("Failed to register component hook \"" + type + "@" + hook + "#" + componentId + "\".");
-}
-// Updates the state of the component to weex native render engine.
-function updateComponentData(componentId, newData, callback) {
-    if (!document || !document.taskCenter) {
-        warn("Can't find available \"document\" or \"taskCenter\".");
-        return;
-    }
-    if (typeof document.taskCenter.updateData === 'function') {
-        return document.taskCenter.updateData(componentId, newData, callback);
-    }
-    warn("Failed to update component data (" + componentId + ").");
-}
-
-// https://github.com/Hanks10100/weex-native-directive/tree/master/component
-var uid$2 = 0;
-// override Vue.prototype._init
-function initVirtualComponent(options) {
-    if (options === void 0) { options = {}; }
-    var vm = this;
-    var componentId = options.componentId;
-    // virtual component uid
-    vm._uid = "virtual-component-" + uid$2++;
-    // a flag to avoid this being observed
-    vm._isVue = true;
-    // merge options
-    if (options && options._isComponent) {
-        // optimize internal component instantiation
-        // since dynamic options merging is pretty slow, and none of the
-        // internal component options needs special treatment.
-        //@ts-expect-error
-        initInternalComponent(vm, options);
-    }
-    else {
-        vm.$options = mergeOptions(
-        //@ts-expect-error
-        resolveConstructorOptions(vm.constructor), options || {}, vm);
-    }
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-        initProxy(vm);
-    }
-    else {
-        vm._renderProxy = vm;
-    }
-    vm._self = vm;
-    initLifecycle(vm);
-    initEvents(vm);
-    initRender(vm);
-    callHook$1(vm, 'beforeCreate');
-    initInjections(vm); // resolve injections before data/props
-    initState(vm);
-    initProvide(vm); // resolve provide after data/props
-    callHook$1(vm, 'created');
-    // send initial data to native
-    var data = vm.$options.data;
-    var params = typeof data === 'function' ? getData(data, vm) : data || {};
-    if (isPlainObject(params)) {
-        updateComponentData(componentId, params);
-    }
-    registerComponentHook(componentId, 'lifecycle', 'attach', function () {
-        callHook$1(vm, 'beforeMount');
-        var updateComponent = function () {
-            vm._update(vm._vnode, false);
-        };
-        new Watcher(vm, updateComponent, noop, null, true);
-        vm._isMounted = true;
-        callHook$1(vm, 'mounted');
-    });
-    registerComponentHook(componentId, 'lifecycle', 'detach', function () {
-        vm.$destroy();
-    });
-}
-// override Vue.prototype._update
-function updateVirtualComponent(vnode) {
-    var vm = this;
-    var componentId = vm.$options.componentId;
-    if (vm._isMounted) {
-        callHook$1(vm, 'beforeUpdate');
-    }
-    vm._vnode = vnode;
-    if (vm._isMounted && componentId) {
-        // TODO: data should be filtered and without bindings
-        var data = Object.assign({}, vm._data);
-        updateComponentData(componentId, data, function () {
-            callHook$1(vm, 'updated');
-        });
-    }
-}
-// listening on native callback
-function resolveVirtualComponent(vnode) {
-    var BaseCtor = vnode.componentOptions.Ctor;
-    var VirtualComponent = BaseCtor.extend({});
-    var cid = VirtualComponent.cid;
-    VirtualComponent.prototype._init = initVirtualComponent;
-    VirtualComponent.prototype._update = updateVirtualComponent;
-    vnode.componentOptions.Ctor = BaseCtor.extend({
-        beforeCreate: function () {
-            // const vm: Component = this
-            // TODO: listen on all events and dispatch them to the
-            // corresponding virtual components according to the componentId.
-            // vm._virtualComponents = {}
-            var createVirtualComponent = function (componentId, propsData) {
-                // create virtual component
-                // const subVm =
-                new VirtualComponent({
-                    componentId: componentId,
-                    propsData: propsData,
-                });
-                // if (vm._virtualComponents) {
-                //   vm._virtualComponents[componentId] = subVm
-                // }
-            };
-            registerComponentHook(cid, 'lifecycle', 'create', createVirtualComponent);
-        },
-        beforeDestroy: function () {
-            delete this._virtualComponents;
-        },
-    });
-}
-
-function isRecyclableComponent(vnode) {
-    return vnode.data.attrs ? RECYCLE_LIST_MARKER in vnode.data.attrs : false;
-}
-function renderRecyclableComponentTemplate(vnode) {
-    //@ts-expect-error
-    delete vnode.data.attrs[RECYCLE_LIST_MARKER];
-    resolveVirtualComponent(vnode);
-    var vm = createComponentInstanceForVnode(vnode);
-    var render = vm.$options['@render'];
-    if (render) {
-        try {
-            return render.call(vm);
-        }
-        catch (err) {
-            handleError(err, vm, "@render");
-        }
-    }
-    else {
-        warn("@render function not defined on component used in <recycle-list>. " +
-            "Make sure to declare `recyclable=\"true\"` on the component's template.", vm);
-    }
-}
-
-// inline hooks to be invoked on component VNodes during patch
-var componentVNodeHooks = {
-    init: function (vnode, hydrating) {
-        if (vnode.componentInstance &&
-            !vnode.componentInstance._isDestroyed &&
-            vnode.data.keepAlive) {
-            // kept-alive components, treat as a patch
-            var mountedNode = vnode; // work around flow
-            componentVNodeHooks.prepatch(mountedNode, mountedNode);
-        }
-        else {
-            var child = (vnode.componentInstance = createComponentInstanceForVnode(vnode, activeInstance));
-            child.$mount(hydrating ? vnode.elm : undefined, hydrating);
-        }
-    },
-    prepatch: function (oldVnode, vnode) {
-        var options = vnode.componentOptions;
-        var child = (vnode.componentInstance = oldVnode.componentInstance);
-        updateChildComponent(child, options.propsData, // updated props
-        options.listeners, // updated listeners
-        vnode, // new parent vnode
-        options.children // new children
-        );
-    },
-    insert: function (vnode) {
-        var context = vnode.context, componentInstance = vnode.componentInstance;
-        if (!componentInstance._isMounted) {
-            componentInstance._isMounted = true;
-            callHook$1(componentInstance, 'mounted');
-        }
-        if (vnode.data.keepAlive) {
-            if (context._isMounted) {
-                // vue-router#1212
-                // During updates, a kept-alive component's child components may
-                // change, so directly walking the tree here may call activated hooks
-                // on incorrect children. Instead we push them into a queue which will
-                // be processed after the whole patch process ended.
-                queueActivatedComponent(componentInstance);
-            }
-            else {
-                activateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-    destroy: function (vnode) {
-        var componentInstance = vnode.componentInstance;
-        if (!componentInstance._isDestroyed) {
-            if (!vnode.data.keepAlive) {
-                componentInstance.$destroy();
-            }
-            else {
-                deactivateChildComponent(componentInstance, true /* direct */);
-            }
-        }
-    },
-};
-var hooksToMerge = Object.keys(componentVNodeHooks);
-function createComponent(Ctor, data, context, children, tag) {
-    if (isUndef(Ctor)) {
-        return;
-    }
-    var baseCtor = context.$options._base;
-    // plain options object: turn it into a constructor
-    if (isObject(Ctor)) {
-        Ctor = baseCtor.extend(Ctor);
-    }
-    // if at this stage it's not a constructor or an async component factory,
-    // reject.
-    if (typeof Ctor !== 'function') {
-        if (process.env.NODE_ENV !== 'production') {
-            warn("Invalid Component definition: " + String(Ctor), context);
-        }
-        return;
-    }
-    // async component
-    var asyncFactory;
-    // @ts-expect-error
-    if (isUndef(Ctor.cid)) {
-        asyncFactory = Ctor;
-        Ctor = resolveAsyncComponent(asyncFactory, baseCtor);
-        if (Ctor === undefined) {
-            // return a placeholder node for async component, which is rendered
-            // as a comment node but preserves all the raw information for the node.
-            // the information will be used for async server-rendering and hydration.
-            return createAsyncPlaceholder(asyncFactory, data, context, children, tag);
-        }
-    }
-    data = data || {};
-    // resolve constructor options in case global mixins are applied after
-    // component constructor creation
-    resolveConstructorOptions(Ctor);
-    // transform component v-model data into props & events
-    if (isDef(data.model)) {
-        // @ts-expect-error
-        transformModel(Ctor.options, data);
-    }
-    // extract props
-    // @ts-expect-error
-    var propsData = extractPropsFromVNodeData(data, Ctor, tag);
-    // functional component
-    // @ts-expect-error
-    if (isTrue(Ctor.options.functional)) {
-        return createFunctionalComponent(Ctor, propsData, data, context, children);
-    }
-    // extract listeners, since these needs to be treated as
-    // child component listeners instead of DOM listeners
-    var listeners = data.on;
-    // replace with listeners with .native modifier
-    // so it gets processed during parent component patch.
-    data.on = data.nativeOn;
-    // @ts-expect-error
-    if (isTrue(Ctor.options.abstract)) {
-        // abstract components do not keep anything
-        // other than props & listeners & slot
-        // work around flow
-        var slot = data.slot;
-        data = {};
-        if (slot) {
-            data.slot = slot;
-        }
-    }
-    // install component management hooks onto the placeholder node
-    installComponentHooks(data);
-    // return a placeholder vnode
-    // @ts-expect-error
-    var name = Ctor.options.name || tag;
-    var vnode = new VNode(
-    // @ts-expect-error
-    "vue-component-" + Ctor.cid + (name ? "-" + name : ''), data, undefined, undefined, undefined, context, 
-    // @ts-expect-error
-    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children }, asyncFactory);
-    // Weex specific: invoke recycle-list optimized @render function for
-    // extracting cell-slot template.
-    // https://github.com/Hanks10100/weex-native-directive/tree/master/component
-    /* istanbul ignore if */
-    if (isRecyclableComponent(vnode)) {
-        return renderRecyclableComponentTemplate(vnode);
-    }
-    return vnode;
-}
-function createComponentInstanceForVnode(
-// we know it's MountedComponentVNode but flow doesn't
-vnode, 
-// activeInstance in lifecycle state
-parent) {
-    var options = {
-        _isComponent: true,
-        _parentVnode: vnode,
-        parent: parent,
-    };
-    // check inline-template render functions
-    var inlineTemplate = vnode.data.inlineTemplate;
-    if (isDef(inlineTemplate)) {
-        options.render = inlineTemplate.render;
-        options.staticRenderFns = inlineTemplate.staticRenderFns;
-    }
-    return new vnode.componentOptions.Ctor(options);
-}
-function installComponentHooks(data) {
-    var hooks = data.hook || (data.hook = {});
-    for (var i = 0; i < hooksToMerge.length; i++) {
-        var key = hooksToMerge[i];
-        var existing = hooks[key];
-        var toMerge = componentVNodeHooks[key];
-        // @ts-expect-error
-        if (existing !== toMerge && !(existing && existing._merged)) {
-            hooks[key] = existing ? mergeHook(toMerge, existing) : toMerge;
-        }
-    }
-}
-function mergeHook(f1, f2) {
-    var merged = function (a, b) {
-        // flow complains about extra args which is why we use any
-        f1(a, b);
-        f2(a, b);
-    };
-    merged._merged = true;
-    return merged;
-}
-// transform component v-model info (value and callback) into
-// prop and event handler respectively.
-function transformModel(options, data) {
-    var prop = (options.model && options.model.prop) || 'value';
-    var event = (options.model && options.model.event) || 'input';
-    (data.attrs || (data.attrs = {}))[prop] = data.model.value;
-    var on = data.on || (data.on = {});
-    var existing = on[event];
-    var callback = data.model.callback;
-    if (isDef(existing)) {
-        if (Array.isArray(existing)
-            ? existing.indexOf(callback) === -1
-            : existing !== callback) {
-            on[event] = [callback].concat(existing);
-        }
-    }
-    else {
-        on[event] = callback;
-    }
-}
-
-var SIMPLE_NORMALIZE = 1;
-var ALWAYS_NORMALIZE = 2;
-// wrapper function for providing a more flexible interface
-// without getting yelled at by flow
-function createElement$1(context, tag, data, children, normalizationType, alwaysNormalize) {
-    if (Array.isArray(data) || isPrimitive(data)) {
-        normalizationType = children;
-        children = data;
-        data = undefined;
-    }
-    if (isTrue(alwaysNormalize)) {
-        normalizationType = ALWAYS_NORMALIZE;
-    }
-    return _createElement(context, tag, data, children, normalizationType);
-}
-function _createElement(context, tag, data, children, normalizationType) {
-    if (isDef(data) && isDef(data.__ob__)) {
-        process.env.NODE_ENV !== 'production' &&
-            warn("Avoid using observed data object as vnode data: " + JSON.stringify(data) + "\n" + 'Always create fresh vnode data objects in each render!', context);
-        return createEmptyVNode();
-    }
-    // object syntax in v-bind
-    if (isDef(data) && isDef(data.is)) {
-        tag = data.is;
-    }
-    if (!tag) {
-        // in case of component :is set to falsy value
-        return createEmptyVNode();
-    }
-    // warn against non-primitive key
-    if (process.env.NODE_ENV !== 'production' &&
-        isDef(data) &&
-        isDef(data.key) &&
-        !isPrimitive(data.key)) {
-        // @ts-expect-error
-        if (!('@binding' in data.key)) {
-            warn('Avoid using non-primitive value as key, ' +
-                'use string/number value instead.', context);
-        }
-    }
-    // support single function children as default scoped slot
-    if (Array.isArray(children) && typeof children[0] === 'function') {
-        data = data || {};
-        data.scopedSlots = { default: children[0] };
-        children.length = 0;
-    }
-    if (normalizationType === ALWAYS_NORMALIZE) {
-        children = normalizeChildren(children);
-    }
-    else if (normalizationType === SIMPLE_NORMALIZE) {
-        children = simpleNormalizeChildren(children);
-    }
-    var vnode, ns;
-    if (typeof tag === 'string') {
-        var Ctor = void 0;
-        ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
-        if (config.isReservedTag(tag)) {
-            // platform built-in elements
-            if (process.env.NODE_ENV !== 'production' &&
-                isDef(data) &&
-                isDef(data.nativeOn) &&
-                data.tag !== 'component') {
-                warn("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">.", context);
-            }
-            vnode = new VNode(config.parsePlatformTagName(tag), data, children, undefined, undefined, context);
-        }
-        else if ((!data || !data.pre) &&
-            isDef((Ctor = resolveAsset(context.$options, 'components', tag)))) {
-            // component
-            vnode = createComponent(Ctor, data, context, children, tag);
-        }
-        else {
-            // unknown or unlisted namespaced elements
-            // check at runtime because it may get assigned a namespace when its
-            // parent normalizes children
-            vnode = new VNode(tag, data, children, undefined, undefined, context);
-        }
-    }
-    else {
-        // direct component options / constructor
-        vnode = createComponent(tag, data, context, children);
-    }
-    if (Array.isArray(vnode)) {
-        return vnode;
-    }
-    else if (isDef(vnode)) {
-        if (isDef(ns))
-            { applyNS(vnode, ns); }
-        if (isDef(data))
-            { registerDeepBindings(data); }
-        return vnode;
-    }
-    else {
-        return createEmptyVNode();
-    }
-}
-function applyNS(vnode, ns, force) {
-    vnode.ns = ns;
-    if (vnode.tag === 'foreignObject') {
-        // use default namespace inside foreignObject
-        ns = undefined;
-        force = true;
-    }
-    if (isDef(vnode.children)) {
-        for (var i = 0, l = vnode.children.length; i < l; i++) {
-            var child = vnode.children[i];
-            if (isDef(child.tag) &&
-                (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-                applyNS(child, ns, force);
-            }
-        }
-    }
-}
-// ref #5318
-// necessary to ensure parent re-render when deep bindings like :style and
-// :class are used on slot nodes
-function registerDeepBindings(data) {
-    if (isObject(data.style)) {
-        traverse(data.style);
-    }
-    if (isObject(data.class)) {
-        traverse(data.class);
-    }
-}
-
-function initRender(vm) {
-    vm._vnode = null; // the root of the child tree
-    vm._staticTrees = null; // v-once cached trees
-    var options = vm.$options;
-    var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
-    var renderContext = parentVnode && parentVnode.context;
-    vm.$slots = resolveSlots(options._renderChildren, renderContext);
-    vm.$scopedSlots = emptyObject;
-    // bind the createElement fn to this instance
-    // so that we get proper render context inside it.
-    // args order: tag, data, children, normalizationType, alwaysNormalize
-    // internal version is used by render functions compiled from templates
-    // @ts-expect-error
-    vm._c = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, false); };
-    // normalization is always applied for the public version, used in
-    // user-written render functions.
-    // @ts-expect-error
-    vm.$createElement = function (a, b, c, d) { return createElement$1(vm, a, b, c, d, true); };
-    // $attrs & $listeners are exposed for easier HOC creation.
-    // they need to be reactive so that HOCs using them are always updated
-    var parentData = parentVnode && parentVnode.data;
-    /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
-        }, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, function () {
-            !isUpdatingChildComponent && warn("$listeners is readonly.", vm);
-        }, true);
-    }
-    else {
-        defineReactive(vm, '$attrs', (parentData && parentData.attrs) || emptyObject, null, true);
-        defineReactive(vm, '$listeners', options._parentListeners || emptyObject, null, true);
-    }
-}
-var currentRenderingInstance = null;
-function renderMixin(Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-    Vue.prototype.$nextTick = function (fn) {
-        return nextTick(fn, this);
-    };
-    Vue.prototype._render = function () {
-        var vm = this;
-        var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
-        if (_parentVnode) {
-            vm.$scopedSlots = normalizeScopedSlots(_parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
-        }
-        // set parent vnode. this allows render functions to have access
-        // to the data on the placeholder node.
-        vm.$vnode = _parentVnode;
-        // render self
-        var vnode;
-        try {
-            // There's no need to maintain a stack because all render fns are called
-            // separately from one another. Nested component's render fns are called
-            // when parent component is patched.
-            currentRenderingInstance = vm;
-            vnode = render.call(vm._renderProxy, vm.$createElement);
-        }
-        catch (e) {
-            handleError(e, vm, "render");
-            // return error render result,
-            // or previous vnode to prevent render error causing blank component
-            /* istanbul ignore else */
-            if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
-                try {
-                    vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);
-                }
-                catch (e$1) {
-                    handleError(e$1, vm, "renderError");
-                    vnode = vm._vnode;
-                }
-            }
-            else {
-                vnode = vm._vnode;
-            }
-        }
-        finally {
-            currentRenderingInstance = null;
-        }
-        // if the returned array contains only a single node, allow it
-        if (Array.isArray(vnode) && vnode.length === 1) {
-            vnode = vnode[0];
-        }
-        // return empty vnode in case the render function errored out
-        if (!(vnode instanceof VNode)) {
-            if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
-                warn('Multiple root nodes returned from render function. Render function ' +
-                    'should return a single root node.', vm);
-            }
-            vnode = createEmptyVNode();
-        }
-        // set parent
-        vnode.parent = _parentVnode;
-        return vnode;
-    };
-}
-
-function ensureCtor(comp, base) {
-    if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
-        comp = comp.default;
-    }
-    return isObject(comp) ? base.extend(comp) : comp;
-}
-function createAsyncPlaceholder(factory, data, context, children, tag) {
-    var node = createEmptyVNode();
-    node.asyncFactory = factory;
-    node.asyncMeta = { data: data, context: context, children: children, tag: tag };
-    return node;
-}
-function resolveAsyncComponent(factory, baseCtor) {
-    if (isTrue(factory.error) && isDef(factory.errorComp)) {
-        return factory.errorComp;
-    }
-    if (isDef(factory.resolved)) {
-        return factory.resolved;
-    }
-    var owner = currentRenderingInstance;
-    if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {
-        // already pending
-        factory.owners.push(owner);
-    }
-    if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
-        return factory.loadingComp;
-    }
-    if (owner && !isDef(factory.owners)) {
-        var owners_1 = (factory.owners = [owner]);
-        var sync_1 = true;
-        var timerLoading_1 = null;
-        var timerTimeout_1 = null;
-        owner.$on('hook:destroyed', function () { return remove$2(owners_1, owner); });
-        var forceRender_1 = function (renderCompleted) {
-            for (var i = 0, l = owners_1.length; i < l; i++) {
-                owners_1[i].$forceUpdate();
-            }
-            if (renderCompleted) {
-                owners_1.length = 0;
-                if (timerLoading_1 !== null) {
-                    clearTimeout(timerLoading_1);
-                    timerLoading_1 = null;
-                }
-                if (timerTimeout_1 !== null) {
-                    clearTimeout(timerTimeout_1);
-                    timerTimeout_1 = null;
-                }
-            }
-        };
-        var resolve = once(function (res) {
-            // cache resolved
-            factory.resolved = ensureCtor(res, baseCtor);
-            // invoke callbacks only if this is not a synchronous resolve
-            // (async resolves are shimmed as synchronous during SSR)
-            if (!sync_1) {
-                forceRender_1(true);
-            }
-            else {
-                owners_1.length = 0;
-            }
-        });
-        var reject_1 = once(function (reason) {
-            process.env.NODE_ENV !== 'production' &&
-                warn("Failed to resolve async component: " + String(factory) +
-                    (reason ? "\nReason: " + reason : ''));
-            if (isDef(factory.errorComp)) {
-                factory.error = true;
-                forceRender_1(true);
-            }
-        });
-        var res_1 = factory(resolve, reject_1);
-        if (isObject(res_1)) {
-            if (isPromise(res_1)) {
-                // () => Promise
-                if (isUndef(factory.resolved)) {
-                    res_1.then(resolve, reject_1);
-                }
-            }
-            else if (isPromise(res_1.component)) {
-                res_1.component.then(resolve, reject_1);
-                if (isDef(res_1.error)) {
-                    factory.errorComp = ensureCtor(res_1.error, baseCtor);
-                }
-                if (isDef(res_1.loading)) {
-                    factory.loadingComp = ensureCtor(res_1.loading, baseCtor);
-                    if (res_1.delay === 0) {
-                        factory.loading = true;
-                    }
-                    else {
-                        // @ts-expect-error NodeJS timeout type
-                        timerLoading_1 = setTimeout(function () {
-                            timerLoading_1 = null;
-                            if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                                factory.loading = true;
-                                forceRender_1(false);
-                            }
-                        }, res_1.delay || 200);
-                    }
-                }
-                if (isDef(res_1.timeout)) {
-                    // @ts-expect-error NodeJS timeout type
-                    timerTimeout_1 = setTimeout(function () {
-                        timerTimeout_1 = null;
-                        if (isUndef(factory.resolved)) {
-                            reject_1(process.env.NODE_ENV !== 'production'
-                                ? "timeout (" + res_1.timeout + "ms)"
-                                : null);
-                        }
-                    }, res_1.timeout);
-                }
-            }
-        }
-        sync_1 = false;
-        // return in case resolved synchronously
-        return factory.loading ? factory.loadingComp : factory.resolved;
-    }
-}
-
-function isAsyncPlaceholder(node) {
-    // @ts-expect-error not really boolean type
-    return node.isComment && node.asyncFactory;
-}
-
-function getFirstComponentChild(children) {
-    if (Array.isArray(children)) {
-        for (var i = 0; i < children.length; i++) {
-            var c = children[i];
-            if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
-                return c;
-            }
-        }
-    }
-}
-
-function initEvents(vm) {
-    vm._events = Object.create(null);
-    vm._hasHookEvent = false;
-    // init parent attached events
-    var listeners = vm.$options._parentListeners;
-    if (listeners) {
-        updateComponentListeners(vm, listeners);
-    }
-}
-var target$1;
-function add$1(event, fn) {
-    target$1.$on(event, fn);
-}
-function remove$1(event, fn) {
-    target$1.$off(event, fn);
-}
-function createOnceHandler$1(event, fn) {
-    var _target = target$1;
-    return function onceHandler() {
-        var res = fn.apply(null, arguments);
-        if (res !== null) {
-            _target.$off(event, onceHandler);
-        }
-    };
-}
-function updateComponentListeners(vm, listeners, oldListeners) {
-    target$1 = vm;
-    updateListeners(listeners, oldListeners || {}, add$1, remove$1, createOnceHandler$1, vm);
-    target$1 = undefined;
-}
-function eventsMixin(Vue) {
-    var hookRE = /^hook:/;
-    Vue.prototype.$on = function (event, fn) {
-        var vm = this;
-        if (Array.isArray(event)) {
-            for (var i = 0, l = event.length; i < l; i++) {
-                vm.$on(event[i], fn);
-            }
-        }
-        else {
-            (vm._events[event] || (vm._events[event] = [])).push(fn);
-            // optimize hook:event cost by using a boolean flag marked at registration
-            // instead of a hash lookup
-            if (hookRE.test(event)) {
-                vm._hasHookEvent = true;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$once = function (event, fn) {
-        var vm = this;
-        function on() {
-            vm.$off(event, on);
-            fn.apply(vm, arguments);
-        }
-        on.fn = fn;
-        vm.$on(event, on);
-        return vm;
-    };
-    Vue.prototype.$off = function (event, fn) {
-        var vm = this;
-        // all
-        if (!arguments.length) {
-            vm._events = Object.create(null);
-            return vm;
-        }
-        // array of events
-        if (Array.isArray(event)) {
-            for (var i_1 = 0, l = event.length; i_1 < l; i_1++) {
-                vm.$off(event[i_1], fn);
-            }
-            return vm;
-        }
-        // specific event
-        var cbs = vm._events[event];
-        if (!cbs) {
-            return vm;
-        }
-        if (!fn) {
-            vm._events[event] = null;
-            return vm;
-        }
-        // specific handler
-        var cb;
-        var i = cbs.length;
-        while (i--) {
-            cb = cbs[i];
-            if (cb === fn || cb.fn === fn) {
-                cbs.splice(i, 1);
-                break;
-            }
-        }
-        return vm;
-    };
-    Vue.prototype.$emit = function (event) {
-        var vm = this;
-        if (process.env.NODE_ENV !== 'production') {
-            var lowerCaseEvent = event.toLowerCase();
-            if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
-                tip("Event \"" + lowerCaseEvent + "\" is emitted in component " +
-                    (formatComponentName(vm) + " but the handler is registered for \"" + event + "\". ") +
-                    "Note that HTML attributes are case-insensitive and you cannot use " +
-                    "v-on to listen to camelCase events when using in-DOM templates. " +
-                    ("You should probably use \"" + hyphenate(event) + "\" instead of \"" + event + "\"."));
-            }
-        }
-        var cbs = vm._events[event];
-        if (cbs) {
-            cbs = cbs.length > 1 ? toArray(cbs) : cbs;
-            var args = toArray(arguments, 1);
-            var info = "event handler for \"" + event + "\"";
-            for (var i = 0, l = cbs.length; i < l; i++) {
-                invokeWithErrorHandling(cbs[i], vm, args, vm, info);
-            }
-        }
-        return vm;
-    };
-}
-
-var activeInstance = null;
-var isUpdatingChildComponent = false;
-function setActiveInstance(vm) {
-    var prevActiveInstance = activeInstance;
-    activeInstance = vm;
-    return function () {
-        activeInstance = prevActiveInstance;
-    };
-}
-function initLifecycle(vm) {
-    var options = vm.$options;
-    // locate first non-abstract parent
-    var parent = options.parent;
-    if (parent && !options.abstract) {
-        while (parent.$options.abstract && parent.$parent) {
-            parent = parent.$parent;
-        }
-        parent.$children.push(vm);
-    }
-    vm.$parent = parent;
-    vm.$root = parent ? parent.$root : vm;
-    vm.$children = [];
-    vm.$refs = {};
-    // @ts-ignore
-    vm._watcher = null;
-    vm._inactive = null;
-    vm._directInactive = false;
-    vm._isMounted = false;
-    vm._isDestroyed = false;
-    vm._isBeingDestroyed = false;
-}
-function lifecycleMixin(Vue) {
-    Vue.prototype._update = function (vnode, hydrating) {
-        var vm = this;
-        var prevEl = vm.$el;
-        var prevVnode = vm._vnode;
-        var restoreActiveInstance = setActiveInstance(vm);
-        vm._vnode = vnode;
-        // Vue.prototype.__patch__ is injected in entry points
-        // based on the rendering backend used.
-        if (!prevVnode) {
-            // initial render
-            vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
-        }
-        else {
-            // updates
-            vm.$el = vm.__patch__(prevVnode, vnode);
-        }
-        restoreActiveInstance();
-        // update __vue__ reference
-        if (prevEl) {
-            prevEl.__vue__ = null;
-        }
-        if (vm.$el) {
-            vm.$el.__vue__ = vm;
-        }
-        // if parent is an HOC, update its $el as well
-        if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-            vm.$parent.$el = vm.$el;
-        }
-        // updated hook is called by the scheduler to ensure that children are
-        // updated in a parent's updated hook.
-    };
-    Vue.prototype.$forceUpdate = function () {
-        var vm = this;
-        if (vm._watcher) {
-            vm._watcher.update();
-        }
-    };
-    Vue.prototype.$destroy = function () {
-        var vm = this;
-        if (vm._isBeingDestroyed) {
-            return;
-        }
-        callHook$1(vm, 'beforeDestroy');
-        vm._isBeingDestroyed = true;
-        // remove self from parent
-        var parent = vm.$parent;
-        // @ts-ignore
-        if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-            remove$2(parent.$children, vm);
-        }
-        // teardown watchers
-        if (vm._watcher) {
-            vm._watcher.teardown();
-        }
-        var i = vm._watchers.length;
-        while (i--) {
-            vm._watchers[i].teardown();
-        }
-        // remove reference from data ob
-        // frozen object may not have observer.
-        if (vm._data.__ob__) {
-            vm._data.__ob__.vmCount--;
-        }
-        // call the last hook...
-        vm._isDestroyed = true;
-        // invoke destroy hooks on current rendered tree
-        vm.__patch__(vm._vnode, null);
-        // fire destroyed hook
-        callHook$1(vm, 'destroyed');
-        // turn off all instance listeners.
-        vm.$off();
-        // remove __vue__ reference
-        if (vm.$el) {
-            vm.$el.__vue__ = null;
-        }
-        // release circular reference (#6759)
-        if (vm.$vnode) {
-            // @ts-expect-error null is not undefined
-            vm.$vnode.parent = null;
-        }
-    };
-}
-function mountComponent(vm, el, hydrating) {
-    vm.$el = el;
-    if (!vm.$options.render) {
-        // @ts-expect-error invalid type
-        vm.$options.render = createEmptyVNode;
-        if (process.env.NODE_ENV !== 'production') {
-            /* istanbul ignore if */
-            if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
-                vm.$options.el ||
-                el) {
-                warn('You are using the runtime-only build of Vue where the template ' +
-                    'compiler is not available. Either pre-compile the templates into ' +
-                    'render functions, or use the compiler-included build.', vm);
-            }
-            else {
-                warn('Failed to mount component: template or render function not defined.', vm);
-            }
-        }
-    }
-    callHook$1(vm, 'beforeMount');
-    var updateComponent;
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-        updateComponent = function () {
-            var name = vm._name;
-            var id = vm._uid;
-            var startTag = "vue-perf-start:" + id;
-            var endTag = "vue-perf-end:" + id;
-            mark(startTag);
-            var vnode = vm._render();
-            mark(endTag);
-            measure("vue " + name + " render", startTag, endTag);
-            mark(startTag);
-            vm._update(vnode, hydrating);
-            mark(endTag);
-            measure("vue " + name + " patch", startTag, endTag);
-        };
-    }
-    else {
-        updateComponent = function () {
-            vm._update(vm._render(), hydrating);
-        };
-    }
-    // we set this to vm._watcher inside the watcher's constructor
-    // since the watcher's initial patch may call $forceUpdate (e.g. inside child
-    // component's mounted hook), which relies on vm._watcher being already defined
-    new Watcher(vm, updateComponent, noop, {
-        before: function () {
-            if (vm._isMounted && !vm._isDestroyed) {
-                callHook$1(vm, 'beforeUpdate');
-            }
-        },
-    }, true /* isRenderWatcher */);
-    hydrating = false;
-    // manually mounted instance, call mounted on self
-    // mounted is called for render-created child components in its inserted hook
-    if (vm.$vnode == null) {
-        vm._isMounted = true;
-        callHook$1(vm, 'mounted');
-    }
-    return vm;
-}
-function updateChildComponent(vm, propsData, listeners, parentVnode, renderChildren) {
-    if (process.env.NODE_ENV !== 'production') {
-        isUpdatingChildComponent = true;
-    }
-    // determine whether component has slot children
-    // we need to do this before overwriting $options._renderChildren.
-    // check if there are dynamic scopedSlots (hand-written or compiled but with
-    // dynamic slot names). Static scoped slots compiled from template has the
-    // "$stable" marker.
-    var newScopedSlots = parentVnode.data.scopedSlots;
-    var oldScopedSlots = vm.$scopedSlots;
-    var hasDynamicScopedSlot = !!((newScopedSlots && !newScopedSlots.$stable) ||
-        (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
-        (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key));
-    // Any static slot children from the parent may have changed during parent's
-    // update. Dynamic scoped slots may also have changed. In such cases, a forced
-    // update is necessary to ensure correctness.
-    var needsForceUpdate = !!(renderChildren || // has new static slots
-        vm.$options._renderChildren || // has old static slots
-        hasDynamicScopedSlot);
-    // @ts-ignore
-    vm.$options._parentVnode = parentVnode;
-    // @ts-ignore
-    vm.$vnode = parentVnode; // update vm's placeholder node without re-render
-    if (vm._vnode) {
-        // update child tree's parent
-        // @ts-ignore
-        vm._vnode.parent = parentVnode;
-    }
-    vm.$options._renderChildren = renderChildren;
-    // update $attrs and $listeners hash
-    // these are also reactive so they may trigger child update if the child
-    // used them during render
-    vm.$attrs = parentVnode.data.attrs || emptyObject;
-    // @ts-ignore
-    vm.$listeners = listeners || emptyObject;
-    // update props
-    if (propsData && vm.$options.props) {
-        toggleObserving(false);
-        var props = vm._props;
-        var propKeys = vm.$options._propKeys || [];
-        for (var i = 0; i < propKeys.length; i++) {
-            var key = propKeys[i];
-            var propOptions = vm.$options.props; // wtf flow?
-            props[key] = validateProp(key, propOptions, propsData, vm);
-        }
-        toggleObserving(true);
-        // keep a copy of raw propsData
-        vm.$options.propsData = propsData;
-    }
-    // update listeners
-    listeners = listeners || emptyObject;
-    var oldListeners = vm.$options._parentListeners;
-    vm.$options._parentListeners = listeners;
-    updateComponentListeners(vm, listeners, oldListeners);
-    // resolve slots + force update if has children
-    if (needsForceUpdate) {
-        vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-        vm.$forceUpdate();
-    }
-    if (process.env.NODE_ENV !== 'production') {
-        isUpdatingChildComponent = false;
-    }
-}
-function isInInactiveTree(vm) {
-    while (vm && (vm = vm.$parent)) {
-        if (vm._inactive)
-            { return true; }
-    }
-    return false;
-}
-function activateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = false;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    else if (vm._directInactive) {
-        return;
-    }
-    if (vm._inactive || vm._inactive === null) {
-        vm._inactive = false;
-        for (var i = 0; i < vm.$children.length; i++) {
-            activateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, 'activated');
-    }
-}
-function deactivateChildComponent(vm, direct) {
-    if (direct) {
-        vm._directInactive = true;
-        if (isInInactiveTree(vm)) {
-            return;
-        }
-    }
-    if (!vm._inactive) {
-        vm._inactive = true;
-        for (var i = 0; i < vm.$children.length; i++) {
-            deactivateChildComponent(vm.$children[i]);
-        }
-        callHook$1(vm, 'deactivated');
-    }
-}
-function callHook$1(vm, hook) {
-    // #7573 disable dep collection when invoking lifecycle hooks
-    pushTarget();
-    var handlers = vm.$options[hook];
-    var info = hook + " hook";
-    if (handlers) {
-        for (var i = 0, j = handlers.length; i < j; i++) {
-            invokeWithErrorHandling(handlers[i], vm, null, vm, info);
-        }
-    }
-    if (vm._hasHookEvent) {
-        vm.$emit('hook:' + hook);
-    }
-    popTarget();
-}
-
-var MAX_UPDATE_COUNT = 100;
-var queue = [];
-var activatedChildren = [];
-var has = {};
-var circular = {};
-var waiting = false;
-var flushing = false;
-var index = 0;
-/**
- * Reset the scheduler's state.
- */
-function resetSchedulerState() {
-    index = queue.length = activatedChildren.length = 0;
-    has = {};
-    if (process.env.NODE_ENV !== 'production') {
-        circular = {};
-    }
-    waiting = flushing = false;
-}
-// Async edge case fix requires storing an event listener's attach timestamp.
-var getNow = Date.now;
-// Determine what event timestamp the browser is using. Annoyingly, the
-// timestamp can either be hi-res (relative to page load) or low-res
-// (relative to UNIX epoch), so in order to compare time we have to use the
-// same timestamp type when saving the flush timestamp.
-// All IE versions use low-res event timestamps, and have problematic clock
-// implementations (#9632)
-if (inBrowser && !isIE) {
-    var performance_1 = window.performance;
-    if (performance_1 &&
-        typeof performance_1.now === 'function' &&
-        getNow() > document.createEvent('Event').timeStamp) {
-        // if the event timestamp, although evaluated AFTER the Date.now(), is
-        // smaller than it, it means the event is using a hi-res timestamp,
-        // and we need to use the hi-res version for event listener timestamps as
-        // well.
-        getNow = function () { return performance_1.now(); };
-    }
-}
-/**
- * Flush both queues and run the watchers.
- */
-function flushSchedulerQueue() {
-    getNow();
-    flushing = true;
-    var watcher, id;
-    // Sort queue before flush.
-    // This ensures that:
-    // 1. Components are updated from parent to child. (because parent is always
-    //    created before the child)
-    // 2. A component's user watchers are run before its render watcher (because
-    //    user watchers are created before the render watcher)
-    // 3. If a component is destroyed during a parent component's watcher run,
-    //    its watchers can be skipped.
-    queue.sort(function (a, b) { return a.id - b.id; });
-    // do not cache length because more watchers might be pushed
-    // as we run existing watchers
-    for (index = 0; index < queue.length; index++) {
-        watcher = queue[index];
-        if (watcher.before) {
-            watcher.before();
-        }
-        id = watcher.id;
-        has[id] = null;
-        watcher.run();
-        // in dev build, check and stop circular updates.
-        if (process.env.NODE_ENV !== 'production' && has[id] != null) {
-            circular[id] = (circular[id] || 0) + 1;
-            if (circular[id] > MAX_UPDATE_COUNT) {
-                warn('You may have an infinite update loop ' +
-                    (watcher.user
-                        ? "in watcher with expression \"" + watcher.expression + "\""
-                        : "in a component render function."), watcher.vm);
-                break;
-            }
-        }
-    }
-    // keep copies of post queues before resetting state
-    var activatedQueue = activatedChildren.slice();
-    var updatedQueue = queue.slice();
-    resetSchedulerState();
-    // call component updated and activated hooks
-    callActivatedHooks(activatedQueue);
-    callUpdatedHooks(updatedQueue);
-    // devtool hook
-    /* istanbul ignore if */
-    if (devtools && config.devtools) {
-        devtools.emit('flush');
-    }
-}
-function callUpdatedHooks(queue) {
-    var i = queue.length;
-    while (i--) {
-        var watcher = queue[i];
-        var vm = watcher.vm;
-        if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
-            callHook$1(vm, 'updated');
-        }
-    }
-}
-/**
- * Queue a kept-alive component that was activated during patch.
- * The queue will be processed after the entire tree has been patched.
- */
-function queueActivatedComponent(vm) {
-    // setting _inactive to false here so that a render function can
-    // rely on checking whether it's in an inactive tree (e.g. router-view)
-    vm._inactive = false;
-    activatedChildren.push(vm);
-}
-function callActivatedHooks(queue) {
-    for (var i = 0; i < queue.length; i++) {
-        queue[i]._inactive = true;
-        activateChildComponent(queue[i], true /* true */);
-    }
-}
-/**
- * Push a watcher into the watcher queue.
- * Jobs with duplicate IDs will be skipped unless it's
- * pushed when the queue is being flushed.
- */
-function queueWatcher(watcher) {
-    var id = watcher.id;
-    if (has[id] == null) {
-        has[id] = true;
-        if (!flushing) {
-            queue.push(watcher);
-        }
-        else {
-            // if already flushing, splice the watcher based on its id
-            // if already past its id, it will be run next immediately.
-            var i = queue.length - 1;
-            while (i > index && queue[i].id > watcher.id) {
-                i--;
-            }
-            queue.splice(i + 1, 0, watcher);
-        }
-        // queue the flush
-        if (!waiting) {
-            waiting = true;
-            if (process.env.NODE_ENV !== 'production' && !config.async) {
-                flushSchedulerQueue();
-                return;
-            }
-            nextTick(flushSchedulerQueue);
-        }
-    }
-}
-
-var uid$1 = 0;
-/**
- * A watcher parses an expression, collects dependencies,
- * and fires callback when the expression value changes.
- * This is used for both the $watch() api and directives.
- */
-var Watcher = /** @class */ (function () {
-    function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-        this.vm = vm;
-        if (isRenderWatcher) {
-            vm._watcher = this;
-        }
-        vm._watchers.push(this);
-        // options
-        if (options) {
-            this.deep = !!options.deep;
-            this.user = !!options.user;
-            this.lazy = !!options.lazy;
-            this.sync = !!options.sync;
-            this.before = options.before;
-        }
-        else {
-            this.deep = this.user = this.lazy = this.sync = false;
-        }
-        this.cb = cb;
-        this.id = ++uid$1; // uid for batching
-        this.active = true;
-        this.dirty = this.lazy; // for lazy watchers
-        this.deps = [];
-        this.newDeps = [];
-        this.depIds = new _Set();
-        this.newDepIds = new _Set();
-        this.expression =
-            process.env.NODE_ENV !== 'production' ? expOrFn.toString() : '';
-        // parse expression for getter
-        if (typeof expOrFn === 'function') {
-            this.getter = expOrFn;
-        }
-        else {
-            this.getter = parsePath(expOrFn);
-            if (!this.getter) {
-                this.getter = noop;
-                process.env.NODE_ENV !== 'production' &&
-                    warn("Failed watching path: \"" + expOrFn + "\" " +
-                        'Watcher only accepts simple dot-delimited paths. ' +
-                        'For full control, use a function instead.', vm);
-            }
-        }
-        this.value = this.lazy ? undefined : this.get();
-    }
-    /**
-     * Evaluate the getter, and re-collect dependencies.
-     */
-    Watcher.prototype.get = function () {
-        pushTarget(this);
-        var value;
-        var vm = this.vm;
-        try {
-            value = this.getter.call(vm, vm);
-        }
-        catch (e) {
-            if (this.user) {
-                handleError(e, vm, "getter for watcher \"" + this.expression + "\"");
-            }
-            else {
-                throw e;
-            }
-        }
-        finally {
-            // "touch" every property so they are all tracked as
-            // dependencies for deep watching
-            if (this.deep) {
-                traverse(value);
-            }
-            popTarget();
-            this.cleanupDeps();
-        }
-        return value;
-    };
-    /**
-     * Add a dependency to this directive.
-     */
-    Watcher.prototype.addDep = function (dep) {
-        var id = dep.id;
-        if (!this.newDepIds.has(id)) {
-            this.newDepIds.add(id);
-            this.newDeps.push(dep);
-            if (!this.depIds.has(id)) {
-                dep.addSub(this);
-            }
-        }
-    };
-    /**
-     * Clean up for dependency collection.
-     */
-    Watcher.prototype.cleanupDeps = function () {
-        var i = this.deps.length;
-        while (i--) {
-            var dep = this.deps[i];
-            if (!this.newDepIds.has(dep.id)) {
-                dep.removeSub(this);
-            }
-        }
-        var tmp = this.depIds;
-        this.depIds = this.newDepIds;
-        this.newDepIds = tmp;
-        this.newDepIds.clear();
-        tmp = this.deps;
-        this.deps = this.newDeps;
-        this.newDeps = tmp;
-        this.newDeps.length = 0;
-    };
-    /**
-     * Subscriber interface.
-     * Will be called when a dependency changes.
-     */
-    Watcher.prototype.update = function () {
-        /* istanbul ignore else */
-        if (this.lazy) {
-            this.dirty = true;
-        }
-        else if (this.sync) {
-            this.run();
-        }
-        else {
-            queueWatcher(this);
-        }
-    };
-    /**
-     * Scheduler job interface.
-     * Will be called by the scheduler.
-     */
-    Watcher.prototype.run = function () {
-        if (this.active) {
-            var value = this.get();
-            if (value !== this.value ||
-                // Deep watchers and watchers on Object/Arrays should fire even
-                // when the value is the same, because the value may
-                // have mutated.
-                isObject(value) ||
-                this.deep) {
-                // set new value
-                var oldValue = this.value;
-                this.value = value;
-                if (this.user) {
-                    try {
-                        this.cb.call(this.vm, value, oldValue);
-                    }
-                    catch (e) {
-                        handleError(e, this.vm, "callback for watcher \"" + this.expression + "\"");
-                    }
-                }
-                else {
-                    this.cb.call(this.vm, value, oldValue);
-                }
-            }
-        }
-    };
-    /**
-     * Evaluate the value of the watcher.
-     * This only gets called for lazy watchers.
-     */
-    Watcher.prototype.evaluate = function () {
-        this.value = this.get();
-        this.dirty = false;
-    };
-    /**
-     * Depend on all deps collected by this watcher.
-     */
-    Watcher.prototype.depend = function () {
-        var i = this.deps.length;
-        while (i--) {
-            this.deps[i].depend();
-        }
-    };
-    /**
-     * Remove self from all dependencies' subscriber list.
-     */
-    Watcher.prototype.teardown = function () {
-        if (this.active) {
-            // remove self from vm's watcher list
-            // this is a somewhat expensive operation so we skip it
-            // if the vm is being destroyed.
-            if (!this.vm._isBeingDestroyed) {
-                remove$2(this.vm._watchers, this);
-            }
-            var i = this.deps.length;
-            while (i--) {
-                this.deps[i].removeSub(this);
-            }
-            this.active = false;
-        }
-    };
-    return Watcher;
-}());
-
-var sharedPropertyDefinition = {
-    enumerable: true,
-    configurable: true,
-    get: noop,
-    set: noop,
-};
-function proxy(target, sourceKey, key) {
-    sharedPropertyDefinition.get = function proxyGetter() {
-        return this[sourceKey][key];
-    };
-    sharedPropertyDefinition.set = function proxySetter(val) {
-        this[sourceKey][key] = val;
-    };
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function initState(vm) {
-    vm._watchers = [];
-    var opts = vm.$options;
-    if (opts.props)
-        { initProps$1(vm, opts.props); }
-    if (opts.methods)
-        { initMethods(vm, opts.methods); }
-    if (opts.data) {
-        initData(vm);
-    }
-    else {
-        observe((vm._data = {}), true /* asRootData */);
-    }
-    if (opts.computed)
-        { initComputed$1(vm, opts.computed); }
-    if (opts.watch && opts.watch !== nativeWatch) {
-        initWatch(vm, opts.watch);
-    }
-}
-function initProps$1(vm, propsOptions) {
-    var propsData = vm.$options.propsData || {};
-    var props = (vm._props = {});
-    // cache prop keys so that future props updates can iterate using Array
-    // instead of dynamic object key enumeration.
-    var keys = (vm.$options._propKeys = []);
-    var isRoot = !vm.$parent;
-    // root instance props should be converted
-    if (!isRoot) {
-        toggleObserving(false);
-    }
-    var _loop_1 = function (key) {
-        keys.push(key);
-        var value = validateProp(key, propsOptions, propsData, vm);
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            var hyphenatedKey = hyphenate(key);
-            if (isReservedAttribute(hyphenatedKey) ||
-                config.isReservedAttr(hyphenatedKey)) {
-                warn("\"" + hyphenatedKey + "\" is a reserved attribute and cannot be used as component prop.", vm);
-            }
-            defineReactive(props, key, value, function () {
-                if (!isRoot && !isUpdatingChildComponent) {
-                    warn("Avoid mutating a prop directly since the value will be " +
-                        "overwritten whenever the parent component re-renders. " +
-                        "Instead, use a data or computed property based on the prop's " +
-                        ("value. Prop being mutated: \"" + key + "\""), vm);
-                }
-            });
-        }
-        else {
-            defineReactive(props, key, value);
-        }
-        // static props are already proxied on the component's prototype
-        // during Vue.extend(). We only need to proxy props defined at
-        // instantiation here.
-        if (!(key in vm)) {
-            proxy(vm, "_props", key);
-        }
-    };
-    for (var key in propsOptions) {
-        _loop_1(key);
-    }
-    toggleObserving(true);
-}
-function initData(vm) {
-    var data = vm.$options.data;
-    data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {};
-    if (!isPlainObject(data)) {
-        data = {};
-        process.env.NODE_ENV !== 'production' &&
-            warn('data functions should return an object:\n' +
-                'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
-    }
-    // proxy data on instance
-    var keys = Object.keys(data);
-    var props = vm.$options.props;
-    var methods = vm.$options.methods;
-    var i = keys.length;
-    while (i--) {
-        var key = keys[i];
-        if (process.env.NODE_ENV !== 'production') {
-            if (methods && hasOwn(methods, key)) {
-                warn("Method \"" + key + "\" has already been defined as a data property.", vm);
-            }
-        }
-        if (props && hasOwn(props, key)) {
-            process.env.NODE_ENV !== 'production' &&
-                warn("The data property \"" + key + "\" is already declared as a prop. " +
-                    "Use prop default value instead.", vm);
-        }
-        else if (!isReserved(key)) {
-            proxy(vm, "_data", key);
-        }
-    }
-    // observe data
-    observe(data, true /* asRootData */);
-}
-function getData(data, vm) {
-    // #7573 disable dep collection when invoking data getters
-    pushTarget();
-    try {
-        return data.call(vm, vm);
-    }
-    catch (e) {
-        handleError(e, vm, "data()");
-        return {};
-    }
-    finally {
-        popTarget();
-    }
-}
-var computedWatcherOptions = { lazy: true };
-function initComputed$1(vm, computed) {
-    // $flow-disable-line
-    var watchers = (vm._computedWatchers = Object.create(null));
-    // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
-    for (var key in computed) {
-        var userDef = computed[key];
-        var getter = typeof userDef === 'function' ? userDef : userDef.get;
-        if (process.env.NODE_ENV !== 'production' && getter == null) {
-            warn("Getter is missing for computed property \"" + key + "\".", vm);
-        }
-        if (!isSSR) {
-            // create internal watcher for the computed property.
-            watchers[key] = new Watcher(vm, getter || noop, noop, computedWatcherOptions);
-        }
-        // component-defined computed properties are already defined on the
-        // component prototype. We only need to define computed properties defined
-        // at instantiation here.
-        if (!(key in vm)) {
-            defineComputed(vm, key, userDef);
-        }
-        else if (process.env.NODE_ENV !== 'production') {
-            if (key in vm.$data) {
-                warn("The computed property \"" + key + "\" is already defined in data.", vm);
-            }
-            else if (vm.$options.props && key in vm.$options.props) {
-                warn("The computed property \"" + key + "\" is already defined as a prop.", vm);
-            }
-        }
-    }
-}
-function defineComputed(target, key, userDef) {
-    var shouldCache = !isServerRendering();
-    if (typeof userDef === 'function') {
-        sharedPropertyDefinition.get = shouldCache
-            ? createComputedGetter(key)
-            : createGetterInvoker(userDef);
-        sharedPropertyDefinition.set = noop;
-    }
-    else {
-        sharedPropertyDefinition.get = userDef.get
-            ? shouldCache && userDef.cache !== false
-                ? createComputedGetter(key)
-                : createGetterInvoker(userDef.get)
-            : noop;
-        sharedPropertyDefinition.set = userDef.set || noop;
-    }
-    if (process.env.NODE_ENV !== 'production' &&
-        sharedPropertyDefinition.set === noop) {
-        sharedPropertyDefinition.set = function () {
-            warn("Computed property \"" + key + "\" was assigned to but it has no setter.", this);
-        };
-    }
-    Object.defineProperty(target, key, sharedPropertyDefinition);
-}
-function createComputedGetter(key) {
-    return function computedGetter() {
-        var watcher = this._computedWatchers && this._computedWatchers[key];
-        if (watcher) {
-            if (watcher.dirty) {
-                watcher.evaluate();
-            }
-            if (Dep.target) {
-                watcher.depend();
-            }
-            return watcher.value;
-        }
-    };
-}
-function createGetterInvoker(fn) {
-    return function computedGetter() {
-        return fn.call(this, this);
-    };
-}
-function initMethods(vm, methods) {
-    var props = vm.$options.props;
-    for (var key in methods) {
-        if (process.env.NODE_ENV !== 'production') {
-            if (typeof methods[key] !== 'function') {
-                warn("Method \"" + key + "\" has type \"" + typeof methods[key] + "\" in the component definition. " +
-                    "Did you reference the function correctly?", vm);
-            }
-            if (props && hasOwn(props, key)) {
-                warn("Method \"" + key + "\" has already been defined as a prop.", vm);
-            }
-            if (key in vm && isReserved(key)) {
-                warn("Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-                    "Avoid defining component methods that start with _ or $.");
-            }
-        }
-        vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);
-    }
-}
-function initWatch(vm, watch) {
-    for (var key in watch) {
-        var handler = watch[key];
-        if (Array.isArray(handler)) {
-            for (var i = 0; i < handler.length; i++) {
-                createWatcher(vm, key, handler[i]);
-            }
-        }
-        else {
-            createWatcher(vm, key, handler);
-        }
-    }
-}
-function createWatcher(vm, expOrFn, handler, options) {
-    if (isPlainObject(handler)) {
-        options = handler;
-        handler = handler.handler;
-    }
-    if (typeof handler === 'string') {
-        handler = vm[handler];
-    }
-    return vm.$watch(expOrFn, handler, options);
-}
-function stateMixin(Vue) {
-    // flow somehow has problems with directly declared definition object
-    // when using Object.defineProperty, so we have to procedurally build up
-    // the object here.
-    var dataDef = {};
-    dataDef.get = function () {
-        return this._data;
-    };
-    var propsDef = {};
-    propsDef.get = function () {
-        return this._props;
-    };
-    if (process.env.NODE_ENV !== 'production') {
-        dataDef.set = function () {
-            warn('Avoid replacing instance root $data. ' +
-                'Use nested data properties instead.', this);
-        };
-        propsDef.set = function () {
-            warn("$props is readonly.", this);
-        };
-    }
-    Object.defineProperty(Vue.prototype, '$data', dataDef);
-    Object.defineProperty(Vue.prototype, '$props', propsDef);
-    Vue.prototype.$set = set;
-    Vue.prototype.$delete = del;
-    Vue.prototype.$watch = function (expOrFn, cb, options) {
-        var vm = this;
-        if (isPlainObject(cb)) {
-            return createWatcher(vm, expOrFn, cb, options);
-        }
-        options = options || {};
-        options.user = true;
-        var watcher = new Watcher(vm, expOrFn, cb, options);
-        if (options.immediate) {
-            pushTarget();
-            try {
-                cb.call(vm, watcher.value);
-            }
-            catch (error) {
-                handleError(error, vm, "callback for immediate watcher \"" + watcher.expression + "\"");
-            }
-            popTarget();
-        }
-        return function unwatchFn() {
-            watcher.teardown();
-        };
-    };
-}
-
-var uid = 0;
-function initMixin$1(Vue) {
-    Vue.prototype._init = function (options) {
-        var vm = this;
-        // a uid
-        vm._uid = uid++;
-        var startTag, endTag;
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            startTag = "vue-perf-start:" + vm._uid;
-            endTag = "vue-perf-end:" + vm._uid;
-            mark(startTag);
-        }
-        // a flag to avoid this being observed
-        vm._isVue = true;
-        // merge options
-        if (options && options._isComponent) {
-            // optimize internal component instantiation
-            // since dynamic options merging is pretty slow, and none of the
-            // internal component options needs special treatment.
-            initInternalComponent(vm, options);
-        }
-        else {
-            vm.$options = mergeOptions(resolveConstructorOptions(vm.constructor), options || {}, vm);
-        }
-        /* istanbul ignore else */
-        if (process.env.NODE_ENV !== 'production') {
-            initProxy(vm);
-        }
-        else {
-            vm._renderProxy = vm;
-        }
-        // expose real self
-        vm._self = vm;
-        initLifecycle(vm);
-        initEvents(vm);
-        initRender(vm);
-        callHook$1(vm, 'beforeCreate');
-        initInjections(vm); // resolve injections before data/props
-        initState(vm);
-        initProvide(vm); // resolve provide after data/props
-        callHook$1(vm, 'created');
-        /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
-            vm._name = formatComponentName(vm, false);
-            mark(endTag);
-            measure("vue " + vm._name + " init", startTag, endTag);
-        }
-        if (vm.$options.el) {
-            vm.$mount(vm.$options.el);
-        }
-    };
-}
-function initInternalComponent(vm, options) {
-    // @ts-ignore
-    var opts = (vm.$options = Object.create(vm.constructor.options));
-    // doing this because it's faster than dynamic enumeration.
-    var parentVnode = options._parentVnode;
-    opts.parent = options.parent;
-    opts._parentVnode = parentVnode;
-    var vnodeComponentOptions = parentVnode.componentOptions;
-    opts.propsData = vnodeComponentOptions.propsData;
-    opts._parentListeners = vnodeComponentOptions.listeners;
-    opts._renderChildren = vnodeComponentOptions.children;
-    opts._componentTag = vnodeComponentOptions.tag;
-    if (options.render) {
-        opts.render = options.render;
-        opts.staticRenderFns = options.staticRenderFns;
-    }
-}
-function resolveConstructorOptions(Ctor) {
-    var options = Ctor.options;
-    if (Ctor.super) {
-        var superOptions = resolveConstructorOptions(Ctor.super);
-        var cachedSuperOptions = Ctor.superOptions;
-        if (superOptions !== cachedSuperOptions) {
-            // super option changed,
-            // need to resolve new options.
-            Ctor.superOptions = superOptions;
-            // check if there are any late-modified/attached options (#4976)
-            var modifiedOptions = resolveModifiedOptions(Ctor);
-            // update base extend options
-            if (modifiedOptions) {
-                extend(Ctor.extendOptions, modifiedOptions);
-            }
-            options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-            if (options.name) {
-                options.components[options.name] = Ctor;
-            }
-        }
-    }
-    return options;
-}
-function resolveModifiedOptions(Ctor) {
-    var modified;
-    var latest = Ctor.options;
-    var sealed = Ctor.sealedOptions;
-    for (var key in latest) {
-        if (latest[key] !== sealed[key]) {
-            if (!modified)
-                { modified = {}; }
-            modified[key] = latest[key];
-        }
-    }
-    return modified;
-}
-
-function Vue(options) {
-    if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
-        warn('Vue is a constructor and should be called with the `new` keyword');
-    }
-    this._init(options);
-}
-//@ts-ignore
-initMixin$1(Vue);
-//@ts-ignore
-stateMixin(Vue);
-//@ts-ignore
-eventsMixin(Vue);
-//@ts-ignore
-lifecycleMixin(Vue);
-//@ts-ignore
-renderMixin(Vue);
-
-function initUse(Vue) {
-    Vue.use = function (plugin) {
-        var installedPlugins = this._installedPlugins || (this._installedPlugins = []);
-        if (installedPlugins.indexOf(plugin) > -1) {
-            return this;
-        }
-        // additional parameters
-        var args = toArray(arguments, 1);
-        args.unshift(this);
-        if (typeof plugin.install === 'function') {
-            plugin.install.apply(plugin, args);
-        }
-        else if (typeof plugin === 'function') {
-            plugin.apply(null, args);
-        }
-        installedPlugins.push(plugin);
-        return this;
-    };
-}
-
-function initMixin(Vue) {
-    Vue.mixin = function (mixin) {
-        this.options = mergeOptions(this.options, mixin);
-        return this;
-    };
-}
-
-function initExtend(Vue) {
-    /**
-     * Each instance constructor, including Vue, has a unique
-     * cid. This enables us to create wrapped "child
-     * constructors" for prototypal inheritance and cache them.
-     */
-    Vue.cid = 0;
-    var cid = 1;
-    /**
-     * Class inheritance
-     */
-    Vue.extend = function (extendOptions) {
-        extendOptions = extendOptions || {};
-        var Super = this;
-        var SuperId = Super.cid;
-        var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
-        if (cachedCtors[SuperId]) {
-            return cachedCtors[SuperId];
-        }
-        var name = extendOptions.name || Super.options.name;
-        if (process.env.NODE_ENV !== 'production' && name) {
-            validateComponentName(name);
-        }
-        var Sub = function VueComponent(options) {
-            this._init(options);
-        };
-        Sub.prototype = Object.create(Super.prototype);
-        Sub.prototype.constructor = Sub;
-        Sub.cid = cid++;
-        Sub.options = mergeOptions(Super.options, extendOptions);
-        Sub['super'] = Super;
-        // For props and computed properties, we define the proxy getters on
-        // the Vue instances at extension time, on the extended prototype. This
-        // avoids Object.defineProperty calls for each instance created.
-        if (Sub.options.props) {
-            initProps(Sub);
-        }
-        if (Sub.options.computed) {
-            initComputed(Sub);
-        }
-        // allow further extension/mixin/plugin usage
-        Sub.extend = Super.extend;
-        Sub.mixin = Super.mixin;
-        Sub.use = Super.use;
-        // create asset registers, so extended classes
-        // can have their private assets too.
-        ASSET_TYPES.forEach(function (type) {
-            Sub[type] = Super[type];
-        });
-        // enable recursive self-lookup
-        if (name) {
-            Sub.options.components[name] = Sub;
-        }
-        // keep a reference to the super options at extension time.
-        // later at instantiation we can check if Super's options have
-        // been updated.
-        Sub.superOptions = Super.options;
-        Sub.extendOptions = extendOptions;
-        Sub.sealedOptions = extend({}, Sub.options);
-        // cache constructor
-        cachedCtors[SuperId] = Sub;
-        return Sub;
-    };
-}
-function initProps(Comp) {
-    var props = Comp.options.props;
-    for (var key in props) {
-        proxy(Comp.prototype, "_props", key);
-    }
-}
-function initComputed(Comp) {
-    var computed = Comp.options.computed;
-    for (var key in computed) {
-        defineComputed(Comp.prototype, key, computed[key]);
-    }
-}
-
-function initAssetRegisters(Vue) {
-    /**
-     * Create asset registration methods.
-     */
-    ASSET_TYPES.forEach(function (type) {
-        // @ts-expect-error function is not exact same type
-        Vue[type] = function (id, definition) {
-            if (!definition) {
-                return this.options[type + 's'][id];
-            }
-            else {
-                /* istanbul ignore if */
-                if (process.env.NODE_ENV !== 'production' && type === 'component') {
-                    validateComponentName(id);
-                }
-                if (type === 'component' && isPlainObject(definition)) {
-                    // @ts-expect-error
-                    definition.name = definition.name || id;
-                    definition = this.options._base.extend(definition);
-                }
-                if (type === 'directive' && typeof definition === 'function') {
-                    definition = { bind: definition, update: definition };
-                }
-                this.options[type + 's'][id] = definition;
-                return definition;
-            }
-        };
-    });
-}
-
-function getComponentName(opts) {
-    return opts && (opts.Ctor.options.name || opts.tag);
-}
-function matches(pattern, name) {
-    if (Array.isArray(pattern)) {
-        return pattern.indexOf(name) > -1;
-    }
-    else if (typeof pattern === 'string') {
-        return pattern.split(',').indexOf(name) > -1;
-    }
-    else if (isRegExp(pattern)) {
-        return pattern.test(name);
-    }
-    /* istanbul ignore next */
-    return false;
-}
-function pruneCache(keepAliveInstance, filter) {
-    var cache = keepAliveInstance.cache, keys = keepAliveInstance.keys, _vnode = keepAliveInstance._vnode;
-    for (var key in cache) {
-        var cachedNode = cache[key];
-        if (cachedNode) {
-            var name_1 = getComponentName(cachedNode.componentOptions);
-            if (name_1 && !filter(name_1)) {
-                pruneCacheEntry(cache, key, keys, _vnode);
-            }
-        }
-    }
-}
-function pruneCacheEntry(cache, key, keys, current) {
-    var cached = cache[key];
-    if (cached && (!current || cached.tag !== current.tag)) {
-        //@ts-expect-error has void type
-        cached.componentInstance.$destroy();
-    }
-    cache[key] = null;
-    remove$2(keys, key);
-}
-var patternTypes = [String, RegExp, Array];
-// TODO use defineComponent
-var KeepAlive = {
-    name: 'keep-alive',
-    abstract: true,
-    props: {
-        include: patternTypes,
-        exclude: patternTypes,
-        max: [String, Number],
-    },
-    created: function () {
-        this.cache = Object.create(null);
-        this.keys = [];
-    },
-    destroyed: function () {
-        for (var key in this.cache) {
-            pruneCacheEntry(this.cache, key, this.keys);
-        }
-    },
-    mounted: function () {
-        var _this = this;
-        this.$watch('include', function (val) {
-            pruneCache(_this, function (name) { return matches(val, name); });
-        });
-        this.$watch('exclude', function (val) {
-            pruneCache(_this, function (name) { return !matches(val, name); });
-        });
-    },
-    render: function () {
-        var slot = this.$slots.default;
-        var vnode = getFirstComponentChild(slot);
-        var componentOptions = vnode && vnode.componentOptions;
-        if (componentOptions) {
-            // check pattern
-            var name_2 = getComponentName(componentOptions);
-            var _a = this, include = _a.include, exclude = _a.exclude;
-            if (
-            // not included
-            (include && (!name_2 || !matches(include, name_2))) ||
-                // excluded
-                (exclude && name_2 && matches(exclude, name_2))) {
-                return vnode;
-            }
-            var _b = this, cache = _b.cache, keys = _b.keys;
-            var key = vnode.key == null
-                ? // same constructor may get registered as different local components
-                    // so cid alone is not enough (#3269)
-                    componentOptions.Ctor.cid +
-                        (componentOptions.tag ? "::" + componentOptions.tag : '')
-                : vnode.key;
-            if (cache[key]) {
-                vnode.componentInstance = cache[key].componentInstance;
-                // make current key freshest
-                remove$2(keys, key);
-                keys.push(key);
-            }
-            else {
-                cache[key] = vnode;
-                keys.push(key);
-                // prune oldest entry
-                if (this.max && keys.length > parseInt(this.max)) {
-                    pruneCacheEntry(cache, keys[0], keys, this._vnode);
-                }
-            }
-            vnode.data.keepAlive = true;
-        }
-        return vnode || (slot && slot[0]);
-    },
-};
-
-var builtInComponents = {
-    KeepAlive: KeepAlive,
-};
-
-function initGlobalAPI(Vue) {
-    // config
-    var configDef = {};
-    configDef.get = function () { return config; };
-    if (process.env.NODE_ENV !== 'production') {
-        configDef.set = function () {
-            warn('Do not replace the Vue.config object, set individual fields instead.');
-        };
-    }
-    Object.defineProperty(Vue, 'config', configDef);
-    // exposed util methods.
-    // NOTE: these are not considered part of the public API - avoid relying on
-    // them unless you are aware of the risk.
-    Vue.util = {
-        warn: warn,
-        extend: extend,
-        mergeOptions: mergeOptions,
-        defineReactive: defineReactive,
-    };
-    Vue.set = set;
-    Vue.delete = del;
-    Vue.nextTick = nextTick;
-    // 2.6 explicit observable API
-    Vue.observable = function (obj) {
-        observe(obj);
-        return obj;
-    };
-    Vue.options = Object.create(null);
-    ASSET_TYPES.forEach(function (type) {
-        Vue.options[type + 's'] = Object.create(null);
-    });
-    // this is used to identify the "base" constructor to extend all plain-object
-    // components with in Weex's multi-instance scenarios.
-    Vue.options._base = Vue;
-    extend(Vue.options.components, builtInComponents);
-    initUse(Vue);
-    initMixin(Vue);
-    initExtend(Vue);
-    initAssetRegisters(Vue);
-}
-
-initGlobalAPI(Vue);
-Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering,
-});
-Object.defineProperty(Vue.prototype, '$ssrContext', {
-    get: function () {
-        /* istanbul ignore next */
-        return this.$vnode && this.$vnode.ssrContext;
-    },
-});
-// expose FunctionalRenderContext for ssr runtime helper installation
-Object.defineProperty(Vue, 'FunctionalRenderContext', {
-    value: FunctionalRenderContext,
-});
-Vue.version = '2.6.12';
-
-var latestNodeId = 1;
-function TextNode(text) {
-    this.instanceId = '';
-    this.nodeId = latestNodeId++;
-    this.parentNode = null;
-    this.nodeType = 3;
-    this.text = text;
-}
-
-var namespaceMap = {};
-function createElement(tagName) {
-    return document.createElement(tagName);
-}
-function createElementNS(namespace, tagName) {
-    return document.createElement(namespace + ':' + tagName);
-}
-function createTextNode(text) {
-    return new TextNode(text);
-}
-function createComment(text) {
-    return document.createComment(text);
-}
-function insertBefore(node, target, before) {
-    if (target.nodeType === 3) {
-        if (node.type === 'text') {
-            node.setAttr('value', target.text);
-            target.parentNode = node;
-        }
-        else {
-            var text = createElement('text');
-            text.setAttr('value', target.text);
-            node.insertBefore(text, before);
-        }
-        return;
-    }
-    node.insertBefore(target, before);
-}
-function removeChild(node, child) {
-    if (child.nodeType === 3) {
-        node.setAttr('value', '');
-        return;
-    }
-    node.removeChild(child);
-}
-function appendChild(node, child) {
-    if (child.nodeType === 3) {
-        if (node.type === 'text') {
-            node.setAttr('value', child.text);
-            child.parentNode = node;
-        }
-        else {
-            var text = createElement('text');
-            text.setAttr('value', child.text);
-            node.appendChild(text);
-        }
-        return;
-    }
-    node.appendChild(child);
-}
-function parentNode(node) {
-    return node.parentNode;
-}
-function nextSibling(node) {
-    return node.nextSibling;
-}
-function tagName(node) {
-    return node.type;
-}
-function setTextContent(node, text) {
-    if (node.parentNode) {
-        node.parentNode.setAttr('value', text);
-    }
-}
-function setAttribute(node, key, val) {
-    node.setAttr(key, val);
-}
-function setStyleScope(node, scopeId) {
-    node.setAttr('@styleScope', scopeId);
-}
-
-var nodeOps = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  namespaceMap: namespaceMap,
-  createElement: createElement,
-  createElementNS: createElementNS,
-  createTextNode: createTextNode,
-  createComment: createComment,
-  insertBefore: insertBefore,
-  removeChild: removeChild,
-  appendChild: appendChild,
-  parentNode: parentNode,
-  nextSibling: nextSibling,
-  tagName: tagName,
-  setTextContent: setTextContent,
-  setAttribute: setAttribute,
-  setStyleScope: setStyleScope
-});
-
-var ref = {
-    create: function (_, vnode) {
-        registerRef(vnode);
-    },
-    update: function (oldVnode, vnode) {
-        if (oldVnode.data.ref !== vnode.data.ref) {
-            registerRef(oldVnode, true);
-            registerRef(vnode);
-        }
-    },
-    destroy: function (vnode) {
-        registerRef(vnode, true);
-    },
-};
-function registerRef(vnode, isRemoval) {
-    var key = vnode.data.ref;
-    if (!isDef(key))
-        { return; }
-    var vm = vnode.context;
-    var ref = vnode.componentInstance || vnode.elm;
-    var refs = vm.$refs;
-    if (isRemoval) {
-        if (Array.isArray(refs[key])) {
-            // @ts-expect-error invalid typings
-            remove$2(refs[key], ref);
-        }
-        else if (refs[key] === ref) {
-            refs[key] = undefined;
-        }
-    }
-    else {
-        // @ts-expect-error invalid typings
-        if (vnode.data.refInFor) {
-            if (!Array.isArray(refs[key])) {
-                refs[key] = [ref];
-                // @ts-expect-error invalid typings
-            }
-            else if (refs[key].indexOf(ref) < 0) {
-                // @ts-expect-error invalid typings
-                refs[key].push(ref);
-            }
-        }
-        else {
-            refs[key] = ref;
-        }
-    }
-}
-
-makeMap('html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot');
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-makeMap('svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view', true);
-var isTextInputType = makeMap('text,number,password,search,email,tel,url');
-
-/**
- * Virtual DOM patching algorithm based on Snabbdom by
- * Simon Friis Vindum (@paldepind)
- * Licensed under the MIT License
- * https://github.com/paldepind/snabbdom/blob/master/LICENSE
- *
- * modified by Evan You (@yyx990803)
- *
- * Not type-checking this because this file is perf-critical and the cost
- * of making flow understand it is not worth it.
- */
-var emptyNode = new VNode('', {}, []);
-var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
-function sameVnode(a, b) {
-    return (a.key === b.key &&
-        ((a.tag === b.tag &&
-            a.isComment === b.isComment &&
-            isDef(a.data) === isDef(b.data) &&
-            sameInputType(a, b)) ||
-            (isTrue(a.isAsyncPlaceholder) &&
-                a.asyncFactory === b.asyncFactory &&
-                isUndef(b.asyncFactory.error))));
-}
-function sameInputType(a, b) {
-    if (a.tag !== 'input')
-        { return true; }
-    var i;
-    var typeA = isDef((i = a.data)) && isDef((i = i.attrs)) && i.type;
-    var typeB = isDef((i = b.data)) && isDef((i = i.attrs)) && i.type;
-    return typeA === typeB || (isTextInputType(typeA) && isTextInputType(typeB));
-}
-function createKeyToOldIdx(children, beginIdx, endIdx) {
-    var i, key;
-    var map = {};
-    for (i = beginIdx; i <= endIdx; ++i) {
-        key = children[i].key;
-        if (isDef(key))
-            { map[key] = i; }
-    }
-    return map;
-}
-function createPatchFunction(backend) {
-    var i, j;
-    var cbs = {};
-    var modules = backend.modules, nodeOps = backend.nodeOps;
-    for (i = 0; i < hooks.length; ++i) {
-        cbs[hooks[i]] = [];
-        for (j = 0; j < modules.length; ++j) {
-            if (isDef(modules[j][hooks[i]])) {
-                cbs[hooks[i]].push(modules[j][hooks[i]]);
-            }
-        }
-    }
-    function emptyNodeAt(elm) {
-        return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm);
-    }
-    function createRmCb(childElm, listeners) {
-        function remove() {
-            if (--remove.listeners === 0) {
-                removeNode(childElm);
-            }
-        }
-        remove.listeners = listeners;
-        return remove;
-    }
-    function removeNode(el) {
-        var parent = nodeOps.parentNode(el);
-        // element may have already been removed due to v-html / v-text
-        if (isDef(parent)) {
-            nodeOps.removeChild(parent, el);
-        }
-    }
-    function isUnknownElement(vnode, inVPre) {
-        return (!inVPre &&
-            !vnode.ns &&
-            !(config.ignoredElements.length &&
-                config.ignoredElements.some(function (ignore) {
-                    return isRegExp(ignore)
-                        ? ignore.test(vnode.tag)
-                        : ignore === vnode.tag;
-                })) &&
-            config.isUnknownElement(vnode.tag));
-    }
-    var creatingElmInVPre = 0;
-    function createElm(vnode, insertedVnodeQueue, parentElm, refElm, nested, ownerArray, index) {
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // This vnode was used in a previous render!
-            // now it's used as a new node, overwriting its elm would cause
-            // potential patch errors down the road when it's used as an insertion
-            // reference node. Instead, we clone the node on-demand before creating
-            // associated DOM element for it.
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        vnode.isRootInsert = !nested; // for transition enter check
-        if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
-            return;
-        }
-        var data = vnode.data;
-        var children = vnode.children;
-        var tag = vnode.tag;
-        if (isDef(tag)) {
-            if (process.env.NODE_ENV !== 'production') {
-                if (data && data.pre) {
-                    creatingElmInVPre++;
-                }
-                if (isUnknownElement(vnode, creatingElmInVPre)) {
-                    warn('Unknown custom element: <' +
-                        tag +
-                        '> - did you ' +
-                        'register the component correctly? For recursive components, ' +
-                        'make sure to provide the "name" option.', vnode.context);
-                }
-            }
-            vnode.elm = vnode.ns
-                ? nodeOps.createElementNS(vnode.ns, tag)
-                : nodeOps.createElement(tag, vnode);
-            setScope(vnode);
-            /* istanbul ignore if */
-            {
-                // in Weex, the default insertion order is parent-first.
-                // List items can be optimized to use children-first insertion
-                // with append="tree".
-                var appendAsTree = isDef(data) && isTrue(data.appendAsTree);
-                if (!appendAsTree) {
-                    if (isDef(data)) {
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                    }
-                    insert(parentElm, vnode.elm, refElm);
-                }
-                createChildren(vnode, children, insertedVnodeQueue);
-                if (appendAsTree) {
-                    if (isDef(data)) {
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                    }
-                    insert(parentElm, vnode.elm, refElm);
-                }
-            }
-            if (process.env.NODE_ENV !== 'production' && data && data.pre) {
-                creatingElmInVPre--;
-            }
-        }
-        else if (isTrue(vnode.isComment)) {
-            vnode.elm = nodeOps.createComment(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-        else {
-            vnode.elm = nodeOps.createTextNode(vnode.text);
-            insert(parentElm, vnode.elm, refElm);
-        }
-    }
-    function createComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i = vnode.data;
-        if (isDef(i)) {
-            var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
-            if (isDef((i = i.hook)) && isDef((i = i.init))) {
-                i(vnode, false /* hydrating */);
-            }
-            // after calling the init hook, if the vnode is a child component
-            // it should've created a child instance and mounted it. the child
-            // component also has set the placeholder vnode's elm.
-            // in that case we can just return the element and be done.
-            if (isDef(vnode.componentInstance)) {
-                initComponent(vnode, insertedVnodeQueue);
-                insert(parentElm, vnode.elm, refElm);
-                if (isTrue(isReactivated)) {
-                    reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
-                }
-                return true;
-            }
-        }
-    }
-    function initComponent(vnode, insertedVnodeQueue) {
-        if (isDef(vnode.data.pendingInsert)) {
-            insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-            vnode.data.pendingInsert = null;
-        }
-        vnode.elm = vnode.componentInstance.$el;
-        if (isPatchable(vnode)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue);
-            setScope(vnode);
-        }
-        else {
-            // empty component root.
-            // skip all element-related modules except for ref (#3455)
-            registerRef(vnode);
-            // make sure to invoke the insert hook
-            insertedVnodeQueue.push(vnode);
-        }
-    }
-    function reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm) {
-        var i;
-        // hack for #4339: a reactivated component with inner transition
-        // does not trigger because the inner node's created hooks are not called
-        // again. It's not ideal to involve module-specific logic in here but
-        // there doesn't seem to be a better way to do it.
-        var innerNode = vnode;
-        while (innerNode.componentInstance) {
-            innerNode = innerNode.componentInstance._vnode;
-            if (isDef((i = innerNode.data)) && isDef((i = i.transition))) {
-                for (i = 0; i < cbs.activate.length; ++i) {
-                    cbs.activate[i](emptyNode, innerNode);
-                }
-                insertedVnodeQueue.push(innerNode);
-                break;
-            }
-        }
-        // unlike a newly created component,
-        // a reactivated keep-alive component doesn't insert itself
-        insert(parentElm, vnode.elm, refElm);
-    }
-    function insert(parent, elm, ref) {
-        if (isDef(parent)) {
-            if (isDef(ref)) {
-                if (nodeOps.parentNode(ref) === parent) {
-                    nodeOps.insertBefore(parent, elm, ref);
-                }
-            }
-            else {
-                nodeOps.appendChild(parent, elm);
-            }
-        }
-    }
-    function createChildren(vnode, children, insertedVnodeQueue) {
-        if (Array.isArray(children)) {
-            if (process.env.NODE_ENV !== 'production') {
-                checkDuplicateKeys(children);
-            }
-            for (var i_1 = 0; i_1 < children.length; ++i_1) {
-                createElm(children[i_1], insertedVnodeQueue, vnode.elm, null, true, children, i_1);
-            }
-        }
-        else if (isPrimitive(vnode.text)) {
-            nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
-        }
-    }
-    function isPatchable(vnode) {
-        while (vnode.componentInstance) {
-            vnode = vnode.componentInstance._vnode;
-        }
-        return isDef(vnode.tag);
-    }
-    function invokeCreateHooks(vnode, insertedVnodeQueue) {
-        for (var i_2 = 0; i_2 < cbs.create.length; ++i_2) {
-            cbs.create[i_2](emptyNode, vnode);
-        }
-        i = vnode.data.hook; // Reuse variable
-        if (isDef(i)) {
-            if (isDef(i.create))
-                { i.create(emptyNode, vnode); }
-            if (isDef(i.insert))
-                { insertedVnodeQueue.push(vnode); }
-        }
-    }
-    // set scope id attribute for scoped CSS.
-    // this is implemented as a special case to avoid the overhead
-    // of going through the normal attribute patching process.
-    function setScope(vnode) {
-        var i;
-        if (isDef((i = vnode.fnScopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-        else {
-            var ancestor = vnode;
-            while (ancestor) {
-                if (isDef((i = ancestor.context)) && isDef((i = i.$options._scopeId))) {
-                    nodeOps.setStyleScope(vnode.elm, i);
-                }
-                ancestor = ancestor.parent;
-            }
-        }
-        // for slot content they should also get the scopeId from the host instance.
-        if (isDef((i = activeInstance)) &&
-            i !== vnode.context &&
-            i !== vnode.fnContext &&
-            isDef((i = i.$options._scopeId))) {
-            nodeOps.setStyleScope(vnode.elm, i);
-        }
-    }
-    function addVnodes(parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
-        }
-    }
-    function invokeDestroyHook(vnode) {
-        var i, j;
-        var data = vnode.data;
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.destroy)))
-                { i(vnode); }
-            for (i = 0; i < cbs.destroy.length; ++i)
-                { cbs.destroy[i](vnode); }
-        }
-        if (isDef((i = vnode.children))) {
-            for (j = 0; j < vnode.children.length; ++j) {
-                invokeDestroyHook(vnode.children[j]);
-            }
-        }
-    }
-    function removeVnodes(vnodes, startIdx, endIdx) {
-        for (; startIdx <= endIdx; ++startIdx) {
-            var ch = vnodes[startIdx];
-            if (isDef(ch)) {
-                if (isDef(ch.tag)) {
-                    removeAndInvokeRemoveHook(ch);
-                    invokeDestroyHook(ch);
-                }
-                else {
-                    // Text node
-                    removeNode(ch.elm);
-                }
-            }
-        }
-    }
-    function removeAndInvokeRemoveHook(vnode, rm) {
-        if (isDef(rm) || isDef(vnode.data)) {
-            var i_3;
-            var listeners = cbs.remove.length + 1;
-            if (isDef(rm)) {
-                // we have a recursively passed down rm callback
-                // increase the listeners count
-                rm.listeners += listeners;
-            }
-            else {
-                // directly removing
-                rm = createRmCb(vnode.elm, listeners);
-            }
-            // recursively invoke hooks on child component root node
-            if (isDef((i_3 = vnode.componentInstance)) &&
-                isDef((i_3 = i_3._vnode)) &&
-                isDef(i_3.data)) {
-                removeAndInvokeRemoveHook(i_3, rm);
-            }
-            for (i_3 = 0; i_3 < cbs.remove.length; ++i_3) {
-                cbs.remove[i_3](vnode, rm);
-            }
-            if (isDef((i_3 = vnode.data.hook)) && isDef((i_3 = i_3.remove))) {
-                i_3(vnode, rm);
-            }
-            else {
-                rm();
-            }
-        }
-        else {
-            removeNode(vnode.elm);
-        }
-    }
-    function updateChildren(parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
-        var oldStartIdx = 0;
-        var newStartIdx = 0;
-        var oldEndIdx = oldCh.length - 1;
-        var oldStartVnode = oldCh[0];
-        var oldEndVnode = oldCh[oldEndIdx];
-        var newEndIdx = newCh.length - 1;
-        var newStartVnode = newCh[0];
-        var newEndVnode = newCh[newEndIdx];
-        var oldKeyToIdx, idxInOld, vnodeToMove, refElm;
-        // removeOnly is a special flag used only by <transition-group>
-        // to ensure removed elements stay in correct relative positions
-        // during leaving transitions
-        var canMove = !removeOnly;
-        if (process.env.NODE_ENV !== 'production') {
-            checkDuplicateKeys(newCh);
-        }
-        while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
-            if (isUndef(oldStartVnode)) {
-                oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
-            }
-            else if (isUndef(oldEndVnode)) {
-                oldEndVnode = oldCh[--oldEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newStartVnode)) {
-                patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                oldStartVnode = oldCh[++oldStartIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else if (sameVnode(oldEndVnode, newEndVnode)) {
-                patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldStartVnode, newEndVnode)) {
-                // Vnode moved right
-                patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
-                oldStartVnode = oldCh[++oldStartIdx];
-                newEndVnode = newCh[--newEndIdx];
-            }
-            else if (sameVnode(oldEndVnode, newStartVnode)) {
-                // Vnode moved left
-                patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                canMove &&
-                    nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
-                oldEndVnode = oldCh[--oldEndIdx];
-                newStartVnode = newCh[++newStartIdx];
-            }
-            else {
-                if (isUndef(oldKeyToIdx))
-                    { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
-                idxInOld = isDef(newStartVnode.key)
-                    ? oldKeyToIdx[newStartVnode.key]
-                    : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
-                if (isUndef(idxInOld)) {
-                    // New element
-                    createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                }
-                else {
-                    vnodeToMove = oldCh[idxInOld];
-                    if (sameVnode(vnodeToMove, newStartVnode)) {
-                        patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
-                        oldCh[idxInOld] = undefined;
-                        canMove &&
-                            nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);
-                    }
-                    else {
-                        // same key but different element. treat as new element
-                        createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
-                    }
-                }
-                newStartVnode = newCh[++newStartIdx];
-            }
-        }
-        if (oldStartIdx > oldEndIdx) {
-            refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
-            addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
-        }
-        else if (newStartIdx > newEndIdx) {
-            removeVnodes(oldCh, oldStartIdx, oldEndIdx);
-        }
-    }
-    function checkDuplicateKeys(children) {
-        var seenKeys = {};
-        for (var i_4 = 0; i_4 < children.length; i_4++) {
-            var vnode = children[i_4];
-            var key = vnode.key;
-            if (isDef(key)) {
-                if (seenKeys[key]) {
-                    warn("Duplicate keys detected: '" + key + "'. This may cause an update error.", vnode.context);
-                }
-                else {
-                    seenKeys[key] = true;
-                }
-            }
-        }
-    }
-    function findIdxInOld(node, oldCh, start, end) {
-        for (var i_5 = start; i_5 < end; i_5++) {
-            var c = oldCh[i_5];
-            if (isDef(c) && sameVnode(node, c))
-                { return i_5; }
-        }
-    }
-    function patchVnode(oldVnode, vnode, insertedVnodeQueue, ownerArray, index, removeOnly) {
-        if (oldVnode === vnode) {
-            return;
-        }
-        if (isDef(vnode.elm) && isDef(ownerArray)) {
-            // clone reused vnode
-            vnode = ownerArray[index] = cloneVNode(vnode);
-        }
-        var elm = (vnode.elm = oldVnode.elm);
-        if (isTrue(oldVnode.isAsyncPlaceholder)) {
-            if (isDef(vnode.asyncFactory.resolved)) {
-                hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
-            }
-            else {
-                vnode.isAsyncPlaceholder = true;
-            }
-            return;
-        }
-        // reuse element for static trees.
-        // note we only do this if the vnode is cloned -
-        // if the new node is not cloned it means the render functions have been
-        // reset by the hot-reload-api and we need to do a proper re-render.
-        if (isTrue(vnode.isStatic) &&
-            isTrue(oldVnode.isStatic) &&
-            vnode.key === oldVnode.key &&
-            (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))) {
-            vnode.componentInstance = oldVnode.componentInstance;
-            return;
-        }
-        var i;
-        var data = vnode.data;
-        if (isDef(data) && isDef((i = data.hook)) && isDef((i = i.prepatch))) {
-            i(oldVnode, vnode);
-        }
-        var oldCh = oldVnode.children;
-        var ch = vnode.children;
-        if (isDef(data) && isPatchable(vnode)) {
-            for (i = 0; i < cbs.update.length; ++i)
-                { cbs.update[i](oldVnode, vnode); }
-            if (isDef((i = data.hook)) && isDef((i = i.update)))
-                { i(oldVnode, vnode); }
-        }
-        if (isUndef(vnode.text)) {
-            if (isDef(oldCh) && isDef(ch)) {
-                if (oldCh !== ch)
-                    { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-            }
-            else if (isDef(ch)) {
-                if (process.env.NODE_ENV !== 'production') {
-                    checkDuplicateKeys(ch);
-                }
-                if (isDef(oldVnode.text))
-                    { nodeOps.setTextContent(elm, ''); }
-                addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-            }
-            else if (isDef(oldCh)) {
-                removeVnodes(oldCh, 0, oldCh.length - 1);
-            }
-            else if (isDef(oldVnode.text)) {
-                nodeOps.setTextContent(elm, '');
-            }
-        }
-        else if (oldVnode.text !== vnode.text) {
-            nodeOps.setTextContent(elm, vnode.text);
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.postpatch)))
-                { i(oldVnode, vnode); }
-        }
-    }
-    function invokeInsertHook(vnode, queue, initial) {
-        // delay insert hooks for component root nodes, invoke them after the
-        // element is really inserted
-        if (isTrue(initial) && isDef(vnode.parent)) {
-            vnode.parent.data.pendingInsert = queue;
-        }
-        else {
-            for (var i_6 = 0; i_6 < queue.length; ++i_6) {
-                queue[i_6].data.hook.insert(queue[i_6]);
-            }
-        }
-    }
-    var hydrationBailed = false;
-    // list of modules that can skip create hook during hydration because they
-    // are already rendered on the client or has no need for initialization
-    // Note: style is excluded because it relies on initial clone for future
-    // deep updates (#7063).
-    var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');
-    // Note: this is a browser-only function so we can assume elms are DOM nodes.
-    function hydrate(elm, vnode, insertedVnodeQueue, inVPre) {
-        var i;
-        var tag = vnode.tag, data = vnode.data, children = vnode.children;
-        inVPre = inVPre || (data && data.pre);
-        vnode.elm = elm;
-        if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
-            vnode.isAsyncPlaceholder = true;
-            return true;
-        }
-        // assert node match
-        if (process.env.NODE_ENV !== 'production') {
-            if (!assertNodeMatch(elm, vnode, inVPre)) {
-                return false;
-            }
-        }
-        if (isDef(data)) {
-            if (isDef((i = data.hook)) && isDef((i = i.init)))
-                { i(vnode, true /* hydrating */); }
-            if (isDef((i = vnode.componentInstance))) {
-                // child component. it should have hydrated its own tree.
-                initComponent(vnode, insertedVnodeQueue);
-                return true;
-            }
-        }
-        if (isDef(tag)) {
-            if (isDef(children)) {
-                // empty element, allow client to pick up and populate children
-                if (!elm.hasChildNodes()) {
-                    createChildren(vnode, children, insertedVnodeQueue);
-                }
-                else {
-                    // v-html and domProps: innerHTML
-                    if (isDef((i = data)) &&
-                        isDef((i = i.domProps)) &&
-                        isDef((i = i.innerHTML))) {
-                        if (i !== elm.innerHTML) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('server innerHTML: ', i);
-                                console.warn('client innerHTML: ', elm.innerHTML);
-                            }
-                            return false;
-                        }
-                    }
-                    else {
-                        // iterate and compare children lists
-                        var childrenMatch = true;
-                        var childNode = elm.firstChild;
-                        for (var i_7 = 0; i_7 < children.length; i_7++) {
-                            if (!childNode ||
-                                !hydrate(childNode, children[i_7], insertedVnodeQueue, inVPre)) {
-                                childrenMatch = false;
-                                break;
-                            }
-                            childNode = childNode.nextSibling;
-                        }
-                        // if childNode is not null, it means the actual childNodes list is
-                        // longer than the virtual children list.
-                        if (!childrenMatch || childNode) {
-                            /* istanbul ignore if */
-                            if (process.env.NODE_ENV !== 'production' &&
-                                typeof console !== 'undefined' &&
-                                !hydrationBailed) {
-                                hydrationBailed = true;
-                                console.warn('Parent: ', elm);
-                                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
-                            }
-                            return false;
-                        }
-                    }
-                }
-            }
-            if (isDef(data)) {
-                var fullInvoke = false;
-                for (var key in data) {
-                    if (!isRenderedModule(key)) {
-                        fullInvoke = true;
-                        invokeCreateHooks(vnode, insertedVnodeQueue);
-                        break;
-                    }
-                }
-                if (!fullInvoke && data['class']) {
-                    // ensure collecting deps for deep class bindings for future updates
-                    traverse(data['class']);
-                }
-            }
-        }
-        else if (elm.data !== vnode.text) {
-            elm.data = vnode.text;
-        }
-        return true;
-    }
-    function assertNodeMatch(node, vnode, inVPre) {
-        if (isDef(vnode.tag)) {
-            return (vnode.tag.indexOf('vue-component') === 0 ||
-                (!isUnknownElement(vnode, inVPre) &&
-                    vnode.tag.toLowerCase() ===
-                        (node.tagName && node.tagName.toLowerCase())));
-        }
-        else {
-            return node.nodeType === (vnode.isComment ? 8 : 3);
-        }
-    }
-    return function patch(oldVnode, vnode, hydrating, removeOnly) {
-        if (isUndef(vnode)) {
-            if (isDef(oldVnode))
-                { invokeDestroyHook(oldVnode); }
-            return;
-        }
-        var isInitialPatch = false;
-        var insertedVnodeQueue = [];
-        if (isUndef(oldVnode)) {
-            // empty mount (likely as component), create new root element
-            isInitialPatch = true;
-            createElm(vnode, insertedVnodeQueue);
-        }
-        else {
-            var isRealElement = isDef(oldVnode.nodeType);
-            if (!isRealElement && sameVnode(oldVnode, vnode)) {
-                // patch existing root node
-                patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);
-            }
-            else {
-                if (isRealElement) {
-                    // mounting to a real element
-                    // check if this is server-rendered content and if we can perform
-                    // a successful hydration.
-                    if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
-                        oldVnode.removeAttribute(SSR_ATTR);
-                        hydrating = true;
-                    }
-                    if (isTrue(hydrating)) {
-                        if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
-                            invokeInsertHook(vnode, insertedVnodeQueue, true);
-                            return oldVnode;
-                        }
-                        else if (process.env.NODE_ENV !== 'production') {
-                            warn('The client-side rendered virtual DOM tree is not matching ' +
-                                'server-rendered content. This is likely caused by incorrect ' +
-                                'HTML markup, for example nesting block-level elements inside ' +
-                                '<p>, or missing <tbody>. Bailing hydration and performing ' +
-                                'full client-side render.');
-                        }
-                    }
-                    // either not server-rendered, or hydration failed.
-                    // create an empty node and replace it
-                    oldVnode = emptyNodeAt(oldVnode);
-                }
-                // replacing existing element
-                var oldElm = oldVnode.elm;
-                var parentElm = nodeOps.parentNode(oldElm);
-                // create new node
-                createElm(vnode, insertedVnodeQueue, 
-                // extremely rare edge case: do not insert if old element is in a
-                // leaving transition. Only happens when combining transition +
-                // keep-alive + HOCs. (#4590)
-                oldElm._leaveCb ? null : parentElm, nodeOps.nextSibling(oldElm));
-                // update parent placeholder node element, recursively
-                if (isDef(vnode.parent)) {
-                    var ancestor = vnode.parent;
-                    var patchable = isPatchable(vnode);
-                    while (ancestor) {
-                        for (var i_8 = 0; i_8 < cbs.destroy.length; ++i_8) {
-                            cbs.destroy[i_8](ancestor);
-                        }
-                        ancestor.elm = vnode.elm;
-                        if (patchable) {
-                            for (var i_9 = 0; i_9 < cbs.create.length; ++i_9) {
-                                cbs.create[i_9](emptyNode, ancestor);
-                            }
-                            // #6513
-                            // invoke insert hooks that may have been merged by create hooks.
-                            // e.g. for directives that uses the "inserted" hook.
-                            var insert_1 = ancestor.data.hook.insert;
-                            if (insert_1.merged) {
-                                // start at index 1 to avoid re-invoking component mounted hook
-                                for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                    insert_1.fns[i_10]();
-                                }
-                            }
-                        }
-                        else {
-                            registerRef(ancestor);
-                        }
-                        ancestor = ancestor.parent;
-                    }
-                }
-                // destroy old node
-                if (isDef(parentElm)) {
-                    removeVnodes([oldVnode], 0, 0);
-                }
-                else if (isDef(oldVnode.tag)) {
-                    invokeDestroyHook(oldVnode);
-                }
-            }
-        }
-        invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-        return vnode.elm;
-    };
-}
-
-var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives(vnode) {
-        // @ts-expect-error emptyNode is not VNodeWithData
-        updateDirectives(vnode, emptyNode);
-    },
-};
-function updateDirectives(oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-        _update(oldVnode, vnode);
-    }
-}
-function _update(oldVnode, vnode) {
-    var isCreate = oldVnode === emptyNode;
-    var isDestroy = vnode === emptyNode;
-    var oldDirs = normalizeDirectives(oldVnode.data.directives, oldVnode.context);
-    var newDirs = normalizeDirectives(vnode.data.directives, vnode.context);
-    var dirsWithInsert = [];
-    var dirsWithPostpatch = [];
-    var key, oldDir, dir;
-    for (key in newDirs) {
-        oldDir = oldDirs[key];
-        dir = newDirs[key];
-        if (!oldDir) {
-            // new directive, bind
-            callHook(dir, 'bind', vnode, oldVnode);
-            if (dir.def && dir.def.inserted) {
-                dirsWithInsert.push(dir);
-            }
-        }
-        else {
-            // existing directive, update
-            dir.oldValue = oldDir.value;
-            dir.oldArg = oldDir.arg;
-            callHook(dir, 'update', vnode, oldVnode);
-            if (dir.def && dir.def.componentUpdated) {
-                dirsWithPostpatch.push(dir);
-            }
-        }
-    }
-    if (dirsWithInsert.length) {
-        var callInsert = function () {
-            for (var i = 0; i < dirsWithInsert.length; i++) {
-                callHook(dirsWithInsert[i], 'inserted', vnode, oldVnode);
-            }
-        };
-        if (isCreate) {
-            mergeVNodeHook(vnode, 'insert', callInsert);
-        }
-        else {
-            callInsert();
-        }
-    }
-    if (dirsWithPostpatch.length) {
-        mergeVNodeHook(vnode, 'postpatch', function () {
-            for (var i = 0; i < dirsWithPostpatch.length; i++) {
-                callHook(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
-            }
-        });
-    }
-    if (!isCreate) {
-        for (key in oldDirs) {
-            if (!newDirs[key]) {
-                // no longer present, unbind
-                callHook(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
-            }
-        }
-    }
-}
-var emptyModifiers = Object.create(null);
-function normalizeDirectives(dirs, vm) {
-    var res = Object.create(null);
-    if (!dirs) {
-        // $flow-disable-line
-        return res;
-    }
-    var i, dir;
-    for (i = 0; i < dirs.length; i++) {
-        dir = dirs[i];
-        if (!dir.modifiers) {
-            // $flow-disable-line
-            dir.modifiers = emptyModifiers;
-        }
-        res[getRawDirName(dir)] = dir;
-        dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
-    }
-    // $flow-disable-line
-    return res;
-}
-function getRawDirName(dir) {
-    return (dir.rawName || dir.name + "." + Object.keys(dir.modifiers || {}).join('.'));
-}
-function callHook(dir, hook, vnode, oldVnode, isDestroy) {
-    var fn = dir.def && dir.def[hook];
-    if (fn) {
-        try {
-            fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
-        }
-        catch (e) {
-            handleError(e, vnode.context, "directive " + dir.name + " " + hook + " hook");
-        }
-    }
-}
-
-var baseModules = [ref, directives];
-
-function updateAttrs(oldVnode, vnode) {
-    if (!oldVnode.data.attrs && !vnode.data.attrs) {
-        return;
-    }
-    var key, cur, old;
-    var elm = vnode.elm;
-    var oldAttrs = oldVnode.data.attrs || {};
-    var attrs = vnode.data.attrs || {};
-    // clone observed objects, as the user probably wants to mutate it
-    if (attrs.__ob__) {
-        attrs = vnode.data.attrs = extend({}, attrs);
-    }
-    var supportBatchUpdate = typeof elm.setAttrs === 'function';
-    var batchedAttrs = {};
-    for (key in attrs) {
-        cur = attrs[key];
-        old = oldAttrs[key];
-        if (old !== cur) {
-            supportBatchUpdate ? (batchedAttrs[key] = cur) : elm.setAttr(key, cur);
-        }
-    }
-    for (key in oldAttrs) {
-        if (attrs[key] == null) {
-            supportBatchUpdate ? (batchedAttrs[key] = undefined) : elm.setAttr(key);
-        }
-    }
-    if (supportBatchUpdate) {
-        elm.setAttrs(batchedAttrs);
-    }
-}
-var attrs = {
-    create: updateAttrs,
-    update: updateAttrs,
-};
-
-function updateClass(oldVnode, vnode) {
-    var el = vnode.elm;
-    var ctx = vnode.context;
-    var data = vnode.data;
-    var oldData = oldVnode.data;
-    if (!data.staticClass &&
-        !data.class &&
-        (!oldData || (!oldData.staticClass && !oldData.class))) {
-        return;
-    }
-    var oldClassList = makeClassList(oldData);
-    var classList = makeClassList(data);
-    if (typeof el.setClassList === 'function') {
-        el.setClassList(classList);
-    }
-    else {
-        var style = getStyle(oldClassList, classList, ctx);
-        if (typeof el.setStyles === 'function') {
-            el.setStyles(style);
-        }
-        else {
-            for (var key in style) {
-                el.setStyle(key, style[key]);
-            }
-        }
-    }
-}
-function makeClassList(data) {
-    var classList = [];
-    // unlike web, weex vnode staticClass is an Array
-    var staticClass = data.staticClass;
-    var dataClass = data.class;
-    if (staticClass) {
-        classList.push.apply(classList, staticClass);
-    }
-    if (Array.isArray(dataClass)) {
-        classList.push.apply(classList, dataClass);
-    }
-    else if (isObject(dataClass)) {
-        classList.push.apply(classList, Object.keys(dataClass).filter(function (className) { return dataClass[className]; }));
-    }
-    else if (typeof dataClass === 'string') {
-        classList.push.apply(classList, dataClass.trim().split(/\s+/));
-    }
-    return classList;
-}
-function getStyle(oldClassList, classList, ctx) {
-    // style is a weex-only injected object
-    // compiled from <style> tags in weex files
-    //@ts-expect-error
-    var stylesheet = ctx.$options.style || {};
-    var result = {};
-    classList.forEach(function (name) {
-        var style = stylesheet[name];
-        extend(result, style);
-    });
-    oldClassList.forEach(function (name) {
-        var style = stylesheet[name];
-        for (var key in style) {
-            if (!result.hasOwnProperty(key)) {
-                result[key] = '';
-            }
-        }
-    });
-    return result;
-}
-var klass = {
-    create: updateClass,
-    update: updateClass,
-};
-
-var target;
-function createOnceHandler(event, handler, capture) {
-    var _target = target; // save current target element in closure
-    return function onceHandler() {
-        var res = handler.apply(null, arguments);
-        if (res !== null) {
-            remove(event, onceHandler, capture, _target);
-        }
-    };
-}
-function add(event, handler, capture, passive, params) {
-    if (capture) {
-        console.log('Weex do not support event in bubble phase.');
-        return;
-    }
-    target.addEvent(event, handler, params);
-}
-function remove(event, handler, capture, _target) {
-    (_target || target).removeEvent(event);
-}
-function updateDOMListeners(oldVnode, vnode) {
-    if (!oldVnode.data.on && !vnode.data.on) {
-        return;
-    }
-    var on = vnode.data.on || {};
-    var oldOn = oldVnode.data.on || {};
-    target = vnode.elm;
-    updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context);
-    target = undefined;
-}
-var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners,
-};
-
-var normalize = cached(camelize);
-function createStyle(oldVnode, vnode) {
-    if (!vnode.data.staticStyle) {
-        updateStyle(oldVnode, vnode);
-        return;
-    }
-    var elm = vnode.elm;
-    var staticStyle = vnode.data.staticStyle;
-    var supportBatchUpdate = typeof elm.setStyles === 'function';
-    var batchedStyles = {};
-    for (var name_1 in staticStyle) {
-        if (staticStyle[name_1]) {
-            supportBatchUpdate
-                ? (batchedStyles[normalize(name_1)] = staticStyle[name_1])
-                : elm.setStyle(normalize(name_1), staticStyle[name_1]);
-        }
-    }
-    if (supportBatchUpdate) {
-        elm.setStyles(batchedStyles);
-    }
-    updateStyle(oldVnode, vnode);
-}
-function updateStyle(oldVnode, vnode) {
-    if (!oldVnode.data.style && !vnode.data.style) {
-        return;
-    }
-    var cur, name;
-    var elm = vnode.elm;
-    var oldStyle = oldVnode.data.style || {};
-    var style = vnode.data.style || {};
-    var needClone = style.__ob__;
-    // handle array syntax
-    if (Array.isArray(style)) {
-        style = vnode.data.style = toObject(style);
-    }
-    // clone the style for future updates,
-    // in case the user mutates the style object in-place.
-    if (needClone) {
-        style = vnode.data.style = extend({}, style);
-    }
-    var supportBatchUpdate = typeof elm.setStyles === 'function';
-    var batchedStyles = {};
-    for (name in oldStyle) {
-        if (!style[name]) {
-            supportBatchUpdate
-                ? (batchedStyles[normalize(name)] = '')
-                : elm.setStyle(normalize(name), '');
-        }
-    }
-    for (name in style) {
-        cur = style[name];
-        supportBatchUpdate
-            ? (batchedStyles[normalize(name)] = cur)
-            : elm.setStyle(normalize(name), cur);
-    }
-    if (supportBatchUpdate) {
-        elm.setStyles(batchedStyles);
-    }
-}
-function toObject(arr) {
-    var res = {};
-    for (var i = 0; i < arr.length; i++) {
-        if (arr[i]) {
-            extend(res, arr[i]);
-        }
-    }
-    return res;
-}
-var style = {
-    create: createStyle,
-    update: updateStyle,
-};
-
-function resolveTransition(def) {
-    if (!def) {
-        return;
-    }
-    /* istanbul ignore else */
-    if (typeof def === 'object') {
-        var res = {};
-        if (def.css !== false) {
-            extend(res, autoCssTransition(def.name || 'v'));
-        }
-        extend(res, def);
-        return res;
-    }
-    else if (typeof def === 'string') {
-        return autoCssTransition(def);
-    }
-}
-var autoCssTransition = cached(function (name) {
-    return {
-        enterClass: name + "-enter",
-        enterToClass: name + "-enter-to",
-        enterActiveClass: name + "-enter-active",
-        leaveClass: name + "-leave",
-        leaveToClass: name + "-leave-to",
-        leaveActiveClass: name + "-leave-active",
-    };
-});
-// binding to window is necessary to make hot reload work in IE in strict mode
-inBrowser
-    ? window.requestAnimationFrame
-        ? window.requestAnimationFrame.bind(window)
-        : setTimeout
-    : /* istanbul ignore next */ function (fn) { return fn(); };
-
-var transition = {
-    create: enter,
-    activate: enter,
-    remove: leave,
-};
-function enter(_, vnode) {
-    var el = vnode.elm;
-    // call leave callback now
-    if (el._leaveCb) {
-        el._leaveCb.cancelled = true;
-        el._leaveCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (!data) {
-        return;
-    }
-    /* istanbul ignore if */
-    if (el._enterCb) {
-        return;
-    }
-    var enterClass = data.enterClass, enterToClass = data.enterToClass, enterActiveClass = data.enterActiveClass, appearClass = data.appearClass, appearToClass = data.appearToClass, appearActiveClass = data.appearActiveClass, beforeEnter = data.beforeEnter, enter = data.enter, afterEnter = data.afterEnter, enterCancelled = data.enterCancelled, beforeAppear = data.beforeAppear, appear = data.appear, afterAppear = data.afterAppear, appearCancelled = data.appearCancelled;
-    var context = activeInstance;
-    var transitionNode = activeInstance.$vnode;
-    while (transitionNode && transitionNode.parent) {
-        transitionNode = transitionNode.parent;
-        context = transitionNode.context;
-    }
-    var isAppear = !context._isMounted || !vnode.isRootInsert;
-    if (isAppear && !appear && appear !== '') {
-        return;
-    }
-    var startClass = isAppear ? appearClass : enterClass;
-    var toClass = isAppear ? appearToClass : enterToClass;
-    var activeClass = isAppear ? appearActiveClass : enterActiveClass;
-    var beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter;
-    var enterHook = isAppear
-        ? typeof appear === 'function'
-            ? appear
-            : enter
-        : enter;
-    var afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter;
-    var enterCancelledHook = isAppear
-        ? appearCancelled || enterCancelled
-        : enterCancelled;
-    var userWantsControl = enterHook &&
-        // enterHook may be a bound method which exposes
-        // the length of original fn as _length
-        (enterHook._length || enterHook.length) > 1;
-    var stylesheet = vnode.context.$options.style || {};
-    var startState = stylesheet[startClass];
-    var transitionProperties = (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {};
-    var endState = getEnterTargetState(el, stylesheet, startClass, toClass, activeClass);
-    var needAnimation = Object.keys(endState).length > 0;
-    var cb = (el._enterCb = once(function () {
-        //@ts-expect-error
-        if (cb.cancelled) {
-            enterCancelledHook && enterCancelledHook(el);
-        }
-        else {
-            afterEnterHook && afterEnterHook(el);
-        }
-        el._enterCb = null;
-    }));
-    // We need to wait until the native element has been inserted, but currently
-    // there's no API to do that. So we have to wait "one frame" - not entirely
-    // sure if this is guaranteed to be enough (e.g. on slow devices?)
-    setTimeout(function () {
-        var parent = el.parentNode;
-        var pendingNode = parent && parent._pending && parent._pending[vnode.key];
-        if (pendingNode &&
-            pendingNode.context === vnode.context &&
-            pendingNode.tag === vnode.tag &&
-            pendingNode.elm._leaveCb) {
-            pendingNode.elm._leaveCb();
-        }
-        enterHook && enterHook(el, cb);
-        if (needAnimation) {
-            var animation = vnode.context.$requireWeexModule('animation');
-            animation.transition(el.ref, {
-                styles: endState,
-                duration: transitionProperties.duration || 0,
-                delay: transitionProperties.delay || 0,
-                timingFunction: transitionProperties.timingFunction || 'linear',
-            }, userWantsControl ? noop : cb);
-        }
-        else if (!userWantsControl) {
-            cb();
-        }
-    }, 16);
-    // start enter transition
-    beforeEnterHook && beforeEnterHook(el);
-    if (startState) {
-        if (typeof el.setStyles === 'function') {
-            el.setStyles(startState);
-        }
-        else {
-            for (var key in startState) {
-                el.setStyle(key, startState[key]);
-            }
-        }
-    }
-    if (!needAnimation && !userWantsControl) {
-        cb();
-    }
-}
-function leave(vnode, rm) {
-    var el = vnode.elm;
-    // call enter callback now
-    if (el._enterCb) {
-        el._enterCb.cancelled = true;
-        el._enterCb();
-    }
-    var data = resolveTransition(vnode.data.transition);
-    if (!data) {
-        return rm();
-    }
-    if (el._leaveCb) {
-        return;
-    }
-    var leaveClass = data.leaveClass, leaveToClass = data.leaveToClass, leaveActiveClass = data.leaveActiveClass, beforeLeave = data.beforeLeave, leave = data.leave, afterLeave = data.afterLeave, leaveCancelled = data.leaveCancelled, delayLeave = data.delayLeave;
-    var userWantsControl = leave &&
-        // leave hook may be a bound method which exposes
-        // the length of original fn as _length
-        (leave._length || leave.length) > 1;
-    var stylesheet = vnode.context.$options.style || {};
-    var startState = stylesheet[leaveClass];
-    var endState = stylesheet[leaveToClass] || stylesheet[leaveActiveClass];
-    var transitionProperties = (stylesheet['@TRANSITION'] &&
-        stylesheet['@TRANSITION'][leaveActiveClass]) ||
-        {};
-    var cb = (el._leaveCb = once(function () {
-        if (el.parentNode && el.parentNode._pending) {
-            el.parentNode._pending[vnode.key] = null;
-        }
-        //@ts-expect-error
-        if (cb.cancelled) {
-            leaveCancelled && leaveCancelled(el);
-        }
-        else {
-            rm();
-            afterLeave && afterLeave(el);
-        }
-        el._leaveCb = null;
-    }));
-    if (delayLeave) {
-        delayLeave(performLeave);
-    }
-    else {
-        performLeave();
-    }
-    function performLeave() {
-        var animation = vnode.context.$requireWeexModule('animation');
-        // the delayed leave may have already been cancelled
-        //@ts-expect-error
-        if (cb.cancelled) {
-            return;
-        }
-        // record leaving element
-        if (!vnode.data.show) {
-            (el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key] = vnode;
-        }
-        beforeLeave && beforeLeave(el);
-        if (startState) {
-            animation.transition(el.ref, {
-                styles: startState,
-            }, next);
-        }
-        else {
-            next();
-        }
-        function next() {
-            animation.transition(el.ref, {
-                styles: endState,
-                duration: transitionProperties.duration || 0,
-                delay: transitionProperties.delay || 0,
-                timingFunction: transitionProperties.timingFunction || 'linear',
-            }, userWantsControl ? noop : cb);
-        }
-        leave && leave(el, cb);
-        if (!endState && !userWantsControl) {
-            cb();
-        }
-    }
-}
-// determine the target animation style for an entering transition.
-function getEnterTargetState(el, stylesheet, startClass, endClass, activeClass) {
-    var targetState = {};
-    var startState = stylesheet[startClass];
-    var endState = stylesheet[endClass];
-    var activeState = stylesheet[activeClass];
-    // 1. fallback to element's default styling
-    if (startState) {
-        for (var key in startState) {
-            targetState[key] = el.style[key];
-            if (process.env.NODE_ENV !== 'production' &&
-                targetState[key] == null &&
-                (!activeState || activeState[key] == null) &&
-                (!endState || endState[key] == null)) {
-                warn("transition property \"" + key + "\" is declared in enter starting class (." + startClass + "), " +
-                    ("but not declared anywhere in enter ending class (." + endClass + "), ") +
-                    ("enter active cass (." + activeClass + ") or the element's default styling. ") +
-                    "Note in Weex, CSS properties need explicit values to be transitionable.");
-            }
-        }
-    }
-    // 2. if state is mixed in active state, extract them while excluding
-    //    transition properties
-    if (activeState) {
-        for (var key in activeState) {
-            if (key.indexOf('transition') !== 0) {
-                targetState[key] = activeState[key];
-            }
-        }
-    }
-    // 3. explicit endState has highest priority
-    if (endState) {
-        extend(targetState, endState);
-    }
-    return targetState;
-}
-
-var platformModules = [attrs, klass, events, style, transition];
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-var modules = platformModules.concat(baseModules);
-var patch = createPatchFunction({
-    nodeOps: nodeOps,
-    modules: modules,
-    LONG_LIST_THRESHOLD: 10,
-});
-
-var platformDirectives = {};
-
-function getVNodeType(vnode) {
-    if (!vnode.tag) {
-        return '';
-    }
-    return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '');
-}
-function isSimpleSpan(vnode) {
-    return (vnode.children &&
-        vnode.children.length === 1 &&
-        !vnode.children[0].tag);
-}
-function parseStyle(vnode) {
-    if (!vnode || !vnode.data) {
-        return;
-    }
-    var _a = vnode.data, staticStyle = _a.staticStyle, staticClass = _a.staticClass;
-    if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
-        var styles_1 = Object.assign({}, staticStyle, vnode.data.style);
-        // @ts-expect-error
-        var cssMap_1 = vnode.context.$options.style || {};
-        var classList = [].concat(staticClass, vnode.data.class);
-        classList.forEach(function (name) {
-            if (name && cssMap_1[name]) {
-                Object.assign(styles_1, cssMap_1[name]);
-            }
-        });
-        return styles_1;
-    }
-}
-function convertVNodeChildren(children) {
-    if (!children.length) {
-        return;
-    }
-    return children.map(function (vnode) {
-        var type = getVNodeType(vnode);
-        var props = { type: type };
-        // convert raw text node
-        if (!type) {
-            props.type = 'span';
-            props.attr = {
-                value: (vnode.text || '').trim(),
-            };
-        }
-        else {
-            props.style = parseStyle(vnode);
-            if (vnode.data) {
-                props.attr = vnode.data.attrs;
-                if (vnode.data.on) {
-                    props.events = vnode.data.on;
-                }
-            }
-            if (type === 'span' && isSimpleSpan(vnode)) {
-                props.attr = props.attr || {};
-                //@ts-expect-error
-                props.attr.value = vnode.children[0].text.trim();
-                return props;
-            }
-        }
-        if (vnode.children && vnode.children.length) {
-            props.children = convertVNodeChildren(vnode.children);
-        }
-        return props;
-    });
-}
-var Richtext = {
-    name: 'richtext',
-    render: function (h) {
-        return h('weex:richtext', {
-            on: this._events,
-            attrs: {
-                value: convertVNodeChildren(this.$options._renderChildren || []),
-            },
-        });
-    },
-};
-
-// Provides transition support for a single element/component.
-var transitionProps = {
-    name: String,
-    appear: Boolean,
-    css: Boolean,
-    mode: String,
-    type: String,
-    enterClass: String,
-    leaveClass: String,
-    enterToClass: String,
-    leaveToClass: String,
-    enterActiveClass: String,
-    leaveActiveClass: String,
-    appearClass: String,
-    appearActiveClass: String,
-    appearToClass: String,
-    duration: [Number, String, Object],
-};
-// in case the child is also an abstract component, e.g. <keep-alive>
-// we want to recursively retrieve the real component to be rendered
-function getRealChild(vnode) {
-    var compOptions = vnode && vnode.componentOptions;
-    if (compOptions && compOptions.Ctor.options.abstract) {
-        return getRealChild(getFirstComponentChild(compOptions.children));
-    }
-    else {
-        return vnode;
-    }
-}
-function extractTransitionData(comp) {
-    var data = {};
-    var options = comp.$options;
-    // props
-    for (var key in options.propsData) {
-        data[key] = comp[key];
-    }
-    // events.
-    // extract listeners and pass them directly to the transition methods
-    var listeners = options._parentListeners;
-    for (var key in listeners) {
-        data[camelize(key)] = listeners[key];
-    }
-    return data;
-}
-function placeholder(h, rawChild) {
-    // @ts-expect-error
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-        return h('keep-alive', {
-            props: rawChild.componentOptions.propsData,
-        });
-    }
-}
-function hasParentTransition(vnode) {
-    while ((vnode = vnode.parent)) {
-        if (vnode.data.transition) {
-            return true;
-        }
-    }
-}
-function isSameChild(child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag;
-}
-var isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };
-var isVShowDirective = function (d) { return d.name === 'show'; };
-var Transition = {
-    name: 'transition',
-    props: transitionProps,
-    abstract: true,
-    render: function (h) {
-        var _this = this;
-        var children = this.$slots.default;
-        if (!children) {
-            return;
-        }
-        // filter out text nodes (possible whitespaces)
-        children = children.filter(isNotTextNode);
-        /* istanbul ignore if */
-        if (!children.length) {
-            return;
-        }
-        // warn multiple elements
-        if (process.env.NODE_ENV !== 'production' && children.length > 1) {
-            warn('<transition> can only be used on a single element. Use ' +
-                '<transition-group> for lists.', this.$parent);
-        }
-        var mode = this.mode;
-        // warn invalid mode
-        if (process.env.NODE_ENV !== 'production' &&
-            mode &&
-            mode !== 'in-out' &&
-            mode !== 'out-in') {
-            warn('invalid <transition> mode: ' + mode, this.$parent);
-        }
-        var rawChild = children[0];
-        // if this is a component root node and the component's
-        // parent container node also has transition, skip.
-        if (hasParentTransition(this.$vnode)) {
-            return rawChild;
-        }
-        // apply transition data to child
-        // use getRealChild() to ignore abstract components e.g. keep-alive
-        var child = getRealChild(rawChild);
-        /* istanbul ignore if */
-        if (!child) {
-            return rawChild;
-        }
-        if (this._leaving) {
-            return placeholder(h, rawChild);
-        }
-        // ensure a key that is unique to the vnode type and to this transition
-        // component instance. This key will be used to remove pending leaving nodes
-        // during entering.
-        var id = "__transition-" + this._uid + "-";
-        child.key =
-            child.key == null
-                ? child.isComment
-                    ? id + 'comment'
-                    : id + child.tag
-                : isPrimitive(child.key)
-                    ? String(child.key).indexOf(id) === 0
-                        ? child.key
-                        : id + child.key
-                    : child.key;
-        var data = ((child.data || (child.data = {})).transition = extractTransitionData(this));
-        var oldRawChild = this._vnode;
-        var oldChild = getRealChild(oldRawChild);
-        // mark v-show
-        // so that the transition module can hand over the control to the directive
-        if (child.data.directives && child.data.directives.some(isVShowDirective)) {
-            child.data.show = true;
-        }
-        if (oldChild &&
-            oldChild.data &&
-            !isSameChild(child, oldChild) &&
-            !isAsyncPlaceholder(oldChild) &&
-            // #6687 component root is a comment node
-            !(oldChild.componentInstance &&
-                oldChild.componentInstance._vnode.isComment)) {
-            // replace old child transition data with fresh one
-            // important for dynamic transitions!
-            var oldData = (oldChild.data.transition = extend({}, data));
-            // handle transition mode
-            if (mode === 'out-in') {
-                // return placeholder node and queue update when leave finishes
-                this._leaving = true;
-                mergeVNodeHook(oldData, 'afterLeave', function () {
-                    _this._leaving = false;
-                    _this.$forceUpdate();
-                });
-                return placeholder(h, rawChild);
-            }
-            else if (mode === 'in-out') {
-                if (isAsyncPlaceholder(child)) {
-                    return oldRawChild;
-                }
-                var delayedLeave_1;
-                var performLeave = function () {
-                    delayedLeave_1();
-                };
-                mergeVNodeHook(data, 'afterEnter', performLeave);
-                mergeVNodeHook(data, 'enterCancelled', performLeave);
-                mergeVNodeHook(oldData, 'delayLeave', function (leave) {
-                    delayedLeave_1 = leave;
-                });
-            }
-        }
-        return rawChild;
-    },
-};
-
-var props = extend({
-    tag: String,
-    moveClass: String,
-}, transitionProps);
-delete props.mode;
-var TransitionGroup = {
-    props: props,
-    created: function () {
-        var dom = this.$requireWeexModule('dom');
-        this.getPosition = function (el) {
-            return new Promise(function (resolve, reject) {
-                dom.getComponentRect(el.ref, function (res) {
-                    if (!res.result) {
-                        reject(new Error("failed to get rect for element: " + el.tag));
-                    }
-                    else {
-                        resolve(res.size);
-                    }
-                });
-            });
-        };
-        var animation = this.$requireWeexModule('animation');
-        this.animate = function (el, options) {
-            return new Promise(function (resolve) {
-                animation.transition(el.ref, options, resolve);
-            });
-        };
-    },
-    render: function (h) {
-        var tag = this.tag || this.$vnode.data.tag || 'span';
-        var map = Object.create(null);
-        var prevChildren = (this.prevChildren = this.children);
-        var rawChildren = this.$slots.default || [];
-        var children = (this.children = []);
-        var transitionData = extractTransitionData(this);
-        for (var i = 0; i < rawChildren.length; i++) {
-            var c = rawChildren[i];
-            if (c.tag) {
-                if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-                    children.push(c);
-                    map[c.key] = c;
-                    (c.data || (c.data = {})).transition = transitionData;
-                }
-                else if (process.env.NODE_ENV !== 'production') {
-                    var opts = c.componentOptions;
-                    var name_1 = opts ? opts.Ctor.options.name || opts.tag : c.tag;
-                    warn("<transition-group> children must be keyed: <" + name_1 + ">");
-                }
-            }
-        }
-        if (prevChildren) {
-            var kept_1 = [];
-            var removed_1 = [];
-            prevChildren.forEach(function (c) {
-                c.data.transition = transitionData;
-                // TODO: record before patch positions
-                if (map[c.key]) {
-                    kept_1.push(c);
-                }
-                else {
-                    removed_1.push(c);
-                }
-            });
-            this.kept = h(tag, null, kept_1);
-            this.removed = removed_1;
-        }
-        return h(tag, null, children);
-    },
-    beforeUpdate: function () {
-        // force removing pass
-        this.__patch__(this._vnode, this.kept, false, // hydrating
-        true // removeOnly (!important, avoids unnecessary moves)
-        );
-        this._vnode = this.kept;
-    },
-    updated: function () {
-        var children = this.prevChildren;
-        var moveClass = this.moveClass || (this.name || 'v') + '-move';
-        var moveData = children.length && this.getMoveData(children[0].context, moveClass);
-        if (!moveData) {
-            return;
-        }
-        // TODO: finish implementing move animations once
-        // we have access to sync getComponentRect()
-        // children.forEach(callPendingCbs)
-        // Promise.all(children.map(c => {
-        //   const oldPos = c.data.pos
-        //   const newPos = c.data.newPos
-        //   const dx = oldPos.left - newPos.left
-        //   const dy = oldPos.top - newPos.top
-        //   if (dx || dy) {
-        //     c.data.moved = true
-        //     return this.animate(c.elm, {
-        //       styles: {
-        //         transform: `translate(${dx}px,${dy}px)`
-        //       }
-        //     })
-        //   }
-        // })).then(() => {
-        //   children.forEach(c => {
-        //     if (c.data.moved) {
-        //       this.animate(c.elm, {
-        //         styles: {
-        //           transform: ''
-        //         },
-        //         duration: moveData.duration || 0,
-        //         delay: moveData.delay || 0,
-        //         timingFunction: moveData.timingFunction || 'linear'
-        //       })
-        //     }
-        //   })
-        // })
-    },
-    methods: {
-        getMoveData: function (context, moveClass) {
-            var stylesheet = context.$options.style || {};
-            return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass];
-        },
-    },
-};
-// function callPendingCbs (c) {
-//   /* istanbul ignore if */
-//   if (c.elm._moveCb) {
-//     c.elm._moveCb()
-//   }
-//   /* istanbul ignore if */
-//   if (c.elm._enterCb) {
-//     c.elm._enterCb()
-//   }
-// }
-
-var platformComponents = {
-    Richtext: Richtext,
-    Transition: Transition,
-    TransitionGroup: TransitionGroup,
-};
-
-// These util functions are split into its own file because Rollup cannot drop
-var isReservedTag = makeMap('template,script,style,element,content,slot,link,meta,svg,view,' +
-    'a,div,img,image,text,span,input,switch,textarea,spinner,select,' +
-    'slider,slider-neighbor,indicator,canvas,' +
-    'list,cell,header,loading,loading-indicator,refresh,scrollable,scroller,' +
-    'video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown', true);
-// Elements that you can, intentionally, leave open (and which close themselves)
-// more flexible than web
-makeMap('web,spinner,switch,video,textarea,canvas,' + 'indicator,marquee,countdown', true);
-var isRuntimeComponent = makeMap('richtext,transition,transition-group', true);
-makeMap('embed,img,image,input,link,meta', true);
-function mustUseProp() {
-    return false;
-}
-function isUnknownElement() {
-    return false;
-}
-function query(el, document) {
-    // document is injected by weex factory wrapper
-    var placeholder = document.createComment('root');
-    placeholder.hasAttribute = placeholder.removeAttribute = noop; // hack for patch
-    document.documentElement.appendChild(placeholder);
-    return placeholder;
-}
-
-//@ts-nocheck
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp;
-Vue.config.isReservedTag = isReservedTag;
-Vue.config.isRuntimeComponent = isRuntimeComponent;
-Vue.config.isUnknownElement = isUnknownElement;
-// install platform runtime directives and components
-Vue.options.directives = platformDirectives;
-Vue.options.components = platformComponents;
-// install platform patch function
-Vue.prototype.__patch__ = patch;
-// wrap mount
-Vue.prototype.$mount = function (el, hydrating) {
-    return mountComponent(this, el && query(el, this.$document), hydrating);
-};
-
-// this entry is built and wrapped with a factory function
-exports.Vue = Vue;
-
-
-
-}
diff --git a/packages/weex-vue-framework/index.js b/packages/weex-vue-framework/index.js
deleted file mode 100644
index 8fab9f5373b..00000000000
--- a/packages/weex-vue-framework/index.js
+++ /dev/null
@@ -1,203 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-/*  */
-
-// this will be preserved during build
-// $flow-disable-line
-var VueFactory = require('./factory');
-
-var instanceOptions = {};
-
-/**
- * Create instance context.
- */
-function createInstanceContext (
-  instanceId,
-  runtimeContext,
-  data
-) {
-  if ( data === void 0 ) data = {};
-
-  var weex = runtimeContext.weex;
-  var instance = instanceOptions[instanceId] = {
-    instanceId: instanceId,
-    config: weex.config,
-    document: weex.document,
-    data: data
-  };
-
-  // Each instance has an independent `Vue` module instance
-  var Vue = instance.Vue = createVueModuleInstance(instanceId, weex);
-
-  // DEPRECATED
-  var timerAPIs = getInstanceTimer(instanceId, weex.requireModule);
-
-  var instanceContext = Object.assign({ Vue: Vue }, timerAPIs);
-  Object.freeze(instanceContext);
-  return instanceContext
-}
-
-/**
- * Destroy an instance with id. It will make sure all memory of
- * this instance released and no more leaks.
- */
-function destroyInstance (instanceId) {
-  var instance = instanceOptions[instanceId];
-  if (instance && instance.app instanceof instance.Vue) {
-    try {
-      instance.app.$destroy();
-      instance.document.destroy();
-    } catch (e) {}
-    delete instance.document;
-    delete instance.app;
-  }
-  delete instanceOptions[instanceId];
-}
-
-/**
- * Refresh an instance with id and new top-level component data.
- * It will use `Vue.set` on all keys of the new data. So it's better
- * define all possible meaningful keys when instance created.
- */
-function refreshInstance (
-  instanceId,
-  data
-) {
-  var instance = instanceOptions[instanceId];
-  if (!instance || !(instance.app instanceof instance.Vue)) {
-    return new Error(("refreshInstance: instance " + instanceId + " not found!"))
-  }
-  if (instance.Vue && instance.Vue.set) {
-    for (var key in data) {
-      instance.Vue.set(instance.app, key, data[key]);
-    }
-  }
-  // Finally `refreshFinish` signal needed.
-  instance.document.taskCenter.send('dom', { action: 'refreshFinish' }, []);
-}
-
-/**
- * Create a fresh instance of Vue for each Weex instance.
- */
-function createVueModuleInstance (
-  instanceId,
-  weex
-) {
-  var exports = {};
-  VueFactory(exports, weex.document);
-  var Vue = exports.Vue;
-
-  var instance = instanceOptions[instanceId];
-
-  // patch reserved tag detection to account for dynamically registered
-  // components
-  var weexRegex = /^weex:/i;
-  var isReservedTag = Vue.config.isReservedTag || (function () { return false; });
-  var isRuntimeComponent = Vue.config.isRuntimeComponent || (function () { return false; });
-  Vue.config.isReservedTag = function (name) {
-    return (!isRuntimeComponent(name) && weex.supports(("@component/" + name))) ||
-      isReservedTag(name) ||
-      weexRegex.test(name)
-  };
-  Vue.config.parsePlatformTagName = function (name) { return name.replace(weexRegex, ''); };
-
-  // expose weex-specific info
-  Vue.prototype.$instanceId = instanceId;
-  Vue.prototype.$document = instance.document;
-
-  // expose weex native module getter on subVue prototype so that
-  // vdom runtime modules can access native modules via vnode.context
-  Vue.prototype.$requireWeexModule = weex.requireModule;
-
-  // Hack `Vue` behavior to handle instance information and data
-  // before root component created.
-  Vue.mixin({
-    beforeCreate: function beforeCreate () {
-      var options = this.$options;
-      // root component (vm)
-      if (options.el) {
-        // set external data of instance
-        var dataOption = options.data;
-        var internalData = (typeof dataOption === 'function' ? dataOption() : dataOption) || {};
-        options.data = Object.assign(internalData, instance.data);
-        // record instance by id
-        instance.app = this;
-      }
-    },
-    mounted: function mounted () {
-      var options = this.$options;
-      // root component (vm)
-      if (options.el && weex.document && instance.app === this) {
-        try {
-          // Send "createFinish" signal to native.
-          weex.document.taskCenter.send('dom', { action: 'createFinish' }, []);
-        } catch (e) {}
-      }
-    }
-  });
-
-  /**
-   * @deprecated Just instance variable `weex.config`
-   * Get instance config.
-   * @return {object}
-   */
-  Vue.prototype.$getConfig = function () {
-    if (instance.app instanceof Vue) {
-      return instance.config
-    }
-  };
-
-  return Vue
-}
-
-/**
- * DEPRECATED
- * Generate HTML5 Timer APIs. An important point is that the callback
- * will be converted into callback id when sent to native. So the
- * framework can make sure no side effect of the callback happened after
- * an instance destroyed.
- */
-function getInstanceTimer (
-  instanceId,
-  moduleGetter
-) {
-  var instance = instanceOptions[instanceId];
-  var timer = moduleGetter('timer');
-  var timerAPIs = {
-    setTimeout: function () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var handler = function () {
-        args[0].apply(args, args.slice(2));
-      };
-
-      timer.setTimeout(handler, args[1]);
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    setInterval: function () {
-      var args = [], len = arguments.length;
-      while ( len-- ) args[ len ] = arguments[ len ];
-
-      var handler = function () {
-        args[0].apply(args, args.slice(2));
-      };
-
-      timer.setInterval(handler, args[1]);
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    clearTimeout: function (n) {
-      timer.clearTimeout(n);
-    },
-    clearInterval: function (n) {
-      timer.clearInterval(n);
-    }
-  };
-  return timerAPIs
-}
-
-exports.createInstanceContext = createInstanceContext;
-exports.destroyInstance = destroyInstance;
-exports.refreshInstance = refreshInstance;
diff --git a/packages/weex-vue-framework/package.json b/packages/weex-vue-framework/package.json
deleted file mode 100644
index 71bd1d65c88..00000000000
--- a/packages/weex-vue-framework/package.json
+++ /dev/null
@@ -1,20 +0,0 @@
-{
-  "name": "weex-vue-framework",
-  "version": "2.4.2-weex.1",
-  "description": "Vue 2.0 Framework for Weex",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vuejs/vue.git"
-  },
-  "keywords": [
-    "vue",
-    "compiler"
-  ],
-  "author": "Evan You",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/vuejs/vue/issues"
-  },
-  "homepage": "https://github.com/vuejs/vue/tree/dev/packages/weex-vue-framework#readme"
-}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 386d3aa1a1e..8b7db65e746 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -44,8 +44,6 @@ specifiers:
   typescript: ^4.6.4
   vitest: ^0.12.6
   webpack: ^5.72.1
-  weex-js-runtime: ^0.23.6
-  weex-styler: ^0.3.0
   yorkie: ^2.0.0
 
 devDependencies:
@@ -92,8 +90,6 @@ devDependencies:
   typescript: 4.6.4
   vitest: 0.12.6_jsdom@19.0.0
   webpack: 5.72.1
-  weex-js-runtime: 0.23.7
-  weex-styler: 0.3.1
   yorkie: 2.0.0
 
 packages:
@@ -837,12 +833,6 @@ packages:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
     dev: true
 
-  /atob/2.1.2:
-    resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
-    engines: {node: '>= 4.5.0'}
-    hasBin: true
-    dev: true
-
   /balanced-match/1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
     dev: true
@@ -1315,15 +1305,6 @@ packages:
       which: 2.0.2
     dev: true
 
-  /css/2.2.4:
-    resolution: {integrity: sha512-oUnjmWpy0niI3x/mPL8dVEI1l7MnG3+HHyRPHf+YFSbK+svOhXpmSOcDURUh2aOCgl2grzrOPt1nHLuCVFULLw==}
-    dependencies:
-      inherits: 2.0.4
-      source-map: 0.6.1
-      source-map-resolve: 0.5.3
-      urix: 0.1.0
-    dev: true
-
   /cssom/0.3.8:
     resolution: {integrity: sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==}
     dev: true
@@ -1448,11 +1429,6 @@ packages:
     resolution: {integrity: sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ==}
     dev: true
 
-  /decode-uri-component/0.2.0:
-    resolution: {integrity: sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=}
-    engines: {node: '>=0.10'}
-    dev: true
-
   /dedent/0.7.0:
     resolution: {integrity: sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=}
     dev: true
@@ -3629,11 +3605,6 @@ packages:
     dev: true
     optional: true
 
-  /resolve-url/0.2.1:
-    resolution: {integrity: sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=}
-    deprecated: https://github.com/lydell/resolve-url#deprecated
-    dev: true
-
   /resolve/1.22.0:
     resolution: {integrity: sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==}
     hasBin: true
@@ -3861,17 +3832,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /source-map-resolve/0.5.3:
-    resolution: {integrity: sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==}
-    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
-    dependencies:
-      atob: 2.1.2
-      decode-uri-component: 0.2.0
-      resolve-url: 0.2.1
-      source-map-url: 0.4.1
-      urix: 0.1.0
-    dev: true
-
   /source-map-support/0.5.21:
     resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
     dependencies:
@@ -3879,11 +3839,6 @@ packages:
       source-map: 0.6.1
     dev: true
 
-  /source-map-url/0.4.1:
-    resolution: {integrity: sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==}
-    deprecated: See https://github.com/lydell/source-map-url#deprecated
-    dev: true
-
   /source-map/0.5.6:
     resolution: {integrity: sha1-dc449SvwczxafwwRjYEzSiu19BI=}
     engines: {node: '>=0.10.0'}
@@ -4350,11 +4305,6 @@ packages:
       punycode: 2.1.1
     dev: true
 
-  /urix/0.1.0:
-    resolution: {integrity: sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=}
-    deprecated: Please see https://github.com/lydell/urix#deprecated
-    dev: true
-
   /url-join/4.0.1:
     resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
     dev: true
@@ -4510,17 +4460,6 @@ packages:
       - uglify-js
     dev: true
 
-  /weex-js-runtime/0.23.7:
-    resolution: {integrity: sha512-3BFd5GXTo0X/GWh0KjzXDpIcPJuSwYuc9fE9llgez35IfVHs/nUmfkFBjifzxOJS2YLhtKf0Cy8eTQ00CJDWZA==}
-    engines: {node: '>=4'}
-    dev: true
-
-  /weex-styler/0.3.1:
-    resolution: {integrity: sha512-xkX5/wS/QLiJXKwbdpeytbLN0kHviQwj9CLdvBxqu+RRZABZpTniKZr1oxjh9Q0+n/aRC+smwFpQpUKvXh9V1g==}
-    dependencies:
-      css: 2.2.4
-    dev: true
-
   /whatwg-encoding/2.0.0:
     resolution: {integrity: sha512-p41ogyeMUrw3jWclHWTQg1k05DSVXPLcVxRTYsXUk+ZooOCZLcoYgPZ/HL/D/N+uQPOtcp1me1WhBEaX02mhWg==}
     engines: {node: '>=12'}
diff --git a/scripts/alias.js b/scripts/alias.js
index 03904cca35d..aab3750afa0 100644
--- a/scripts/alias.js
+++ b/scripts/alias.js
@@ -8,7 +8,6 @@ module.exports = {
   core: resolve('src/core'),
   shared: resolve('src/shared'),
   web: resolve('src/platforms/web'),
-  weex: resolve('src/platforms/weex'),
   server: resolve('src/server'),
   sfc: resolve('src/sfc')
 }
diff --git a/scripts/build.js b/scripts/build.js
index 131833b668f..939bb2bffe8 100644
--- a/scripts/build.js
+++ b/scripts/build.js
@@ -16,11 +16,6 @@ if (process.argv[2]) {
   builds = builds.filter(b => {
     return filters.some(f => b.output.file.indexOf(f) > -1 || b._name.indexOf(f) > -1)
   })
-} else {
-  // filter out weex builds by default
-  builds = builds.filter(b => {
-    return b.output.file.indexOf('weex') === -1
-  })
 }
 
 build(builds)
diff --git a/scripts/config.js b/scripts/config.js
index c62f3021220..deaa2bd49cc 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -6,9 +6,6 @@ const node = require('@rollup/plugin-node-resolve').nodeResolve
 const ts = require('rollup-plugin-typescript2')
 
 const version = process.env.VERSION || require('../package.json').version
-const weexVersion =
-  process.env.WEEX_VERSION ||
-  require('../packages/weex-vue-framework/package.json').version
 const featureFlags = require('./feature-flags')
 
 const banner =
@@ -18,15 +15,6 @@ const banner =
   ' * Released under the MIT License.\n' +
   ' */'
 
-const weexFactoryPlugin = {
-  intro() {
-    return 'module.exports = function weexFactory (exports, document) {'
-  },
-  outro() {
-    return '}'
-  }
-}
-
 const aliases = require('./alias')
 const resolve = (p) => {
   const base = p.split('/')[0]
@@ -199,31 +187,6 @@ const builds = {
     external: Object.keys(
       require('../packages/vue-server-renderer/package.json').dependencies
     )
-  },
-  // Weex runtime factory
-  'weex-factory': {
-    weex: true,
-    entry: resolve('weex/entry-runtime-factory.ts'),
-    dest: resolve('packages/weex-vue-framework/factory.js'),
-    format: 'cjs',
-    plugins: [weexFactoryPlugin]
-  },
-  // Weex runtime framework (CommonJS).
-  'weex-framework': {
-    weex: true,
-    entry: resolve('weex/entry-framework.ts'),
-    dest: resolve('packages/weex-vue-framework/index.js'),
-    format: 'cjs'
-  },
-  // Weex compiler (CommonJS). Used by Weex's Webpack loader.
-  'weex-compiler': {
-    weex: true,
-    entry: resolve('weex/entry-compiler.ts'),
-    dest: resolve('packages/weex-template-compiler/build.js'),
-    format: 'cjs',
-    external: Object.keys(
-      require('../packages/weex-template-compiler/package.json').dependencies
-    )
   }
 }
 
@@ -267,8 +230,6 @@ function genConfig(name) {
 
   // built-in vars
   const vars = {
-    __WEEX__: !!opts.weex,
-    __WEEX_VERSION__: weexVersion,
     __VERSION__: version,
     __SSR_TEST__: false
   }
diff --git a/scripts/get-weex-version.js b/scripts/get-weex-version.js
deleted file mode 100644
index f66492b37df..00000000000
--- a/scripts/get-weex-version.js
+++ /dev/null
@@ -1,24 +0,0 @@
-const coreVersion = require('../package.json').version
-const weexVersion = require('../packages/weex-vue-framework/package.json').version
-let weexBaseVersion = weexVersion.match(/^[\d.]+/)[0]
-let weexSubVersion = Number(weexVersion.match(/-weex\.(\d+)$/)[1])
-
-if (weexBaseVersion === coreVersion) {
-  // same core version, increment sub version
-  weexSubVersion++
-} else {
-  // new core version, reset sub version
-  weexBaseVersion = coreVersion
-  weexSubVersion = 1
-}
-
-if (process.argv[2] === '-c') {
-  console.log(weexVersion)
-} else {
-  console.log(weexBaseVersion + '-weex.' + weexSubVersion)
-}
-
-module.exports = {
-  base: weexBaseVersion,
-  sub: weexSubVersion
-}
diff --git a/scripts/release-weex.sh b/scripts/release-weex.sh
deleted file mode 100644
index f731977769f..00000000000
--- a/scripts/release-weex.sh
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash
-set -e
-CUR_VERSION=$(node build/get-weex-version.js -c)
-NEXT_VERSION=$(node build/get-weex-version.js)
-
-echo "Current: $CUR_VERSION"
-read -p "Enter new version ($NEXT_VERSION): " -n 1 -r
-if ! [[ -z $REPLY ]]; then
-  NEXT_VERSION=$REPLY
-fi
-
-read -p "Releasing weex-vue-framework@$NEXT_VERSION - are you sure? (y/n) " -n 1 -r
-echo
-if [[ $REPLY =~ ^[Yy]$ ]]; then
-  echo "Releasing weex-vue-framework@$NEXT_VERSION ..."
-  npm run lint
-  npm run flow
-  npm run test:weex
-
-  # build
-  WEEX_VERSION=$NEXT_VERSION npm run build:weex
-
-  # update package
-  # using subshells to avoid having to cd back
-  ( cd packages/weex-vue-framework
-  npm version "$NEXT_VERSION"
-  npm publish
-  )
-
-  ( cd packages/weex-template-compiler
-  npm version "$NEXT_VERSION"
-  npm publish
-  )
-
-  # commit
-  git add packages/weex*
-  git commit -m "[release] weex-vue-framework@$NEXT_VERSION"
-fi
diff --git a/src/compiler/codegen/events.ts b/src/compiler/codegen/events.ts
index 1fbe914f41e..1c3685bf729 100644
--- a/src/compiler/codegen/events.ts
+++ b/src/compiler/codegen/events.ts
@@ -1,7 +1,7 @@
-
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
 const fnInvokeRE = /\([^)]*?\);*$/
-const simplePathRE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
+const simplePathRE =
+  /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
 
 // KeyboardEvent.keyCode aliases
 const keyCodes: { [key: string]: number | Array<number> } = {
@@ -13,7 +13,7 @@ const keyCodes: { [key: string]: number | Array<number> } = {
   left: 37,
   right: 39,
   down: 40,
-  delete: [8, 46],
+  delete: [8, 46]
 }
 
 // KeyboardEvent.key aliases
@@ -30,7 +30,7 @@ const keyNames: { [key: string]: string | Array<string> } = {
   right: ['Right', 'ArrowRight'],
   down: ['Down', 'ArrowDown'],
   // #9112: IE11 uses `Del` for Delete key name.
-  delete: ['Backspace', 'Delete', 'Del'],
+  delete: ['Backspace', 'Delete', 'Del']
 }
 
 // #4868: modifiers that prevent the execution of the listener
@@ -48,7 +48,7 @@ const modifierCode: { [key: string]: string } = {
   meta: genGuard(`!$event.metaKey`),
   left: genGuard(`'button' in $event && $event.button !== 0`),
   middle: genGuard(`'button' in $event && $event.button !== 1`),
-  right: genGuard(`'button' in $event && $event.button !== 2`),
+  right: genGuard(`'button' in $event && $event.button !== 2`)
 }
 
 export function genHandlers(
@@ -75,28 +75,6 @@ export function genHandlers(
   }
 }
 
-// Generate handler code with binding params on Weex
-/* istanbul ignore next */
-function genWeexHandler(params: Array<any>, handlerCode: string) {
-  let innerHandlerCode = handlerCode
-  const exps = params.filter(
-    (exp) => simplePathRE.test(exp) && exp !== '$event'
-  )
-  const bindings = exps.map((exp) => ({ '@binding': exp }))
-  const args = exps.map((exp, i) => {
-    const key = `$_${i + 1}`
-    innerHandlerCode = innerHandlerCode.replace(exp, key)
-    return key
-  })
-  args.push('$event')
-  return (
-    '{\n' +
-    `handler:function(${args.join(',')}){${innerHandlerCode}},\n` +
-    `params:${JSON.stringify(bindings)}\n` +
-    '}'
-  )
-}
-
 function genHandler(
   handler: ASTElementHandler | Array<ASTElementHandler>
 ): string {
@@ -118,10 +96,6 @@ function genHandler(
     if (isMethodPath || isFunctionExpression) {
       return handler.value
     }
-    /* istanbul ignore if */
-    if (__WEEX__ && handler.params) {
-      return genWeexHandler(handler.params, handler.value)
-    }
     return `function($event){${
       isFunctionInvocation ? `return ${handler.value}` : handler.value
     }}` // inline statement
@@ -162,10 +136,6 @@ function genHandler(
       : isFunctionInvocation
       ? `return ${handler.value}`
       : handler.value
-    /* istanbul ignore if */
-    if (__WEEX__ && handler.params) {
-      return genWeexHandler(handler.params, code + handlerCode)
-    }
     return `function($event){${code}${handlerCode}}`
   }
 }
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index fbb489a8713..0b7de4492f6 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -1,4 +1,3 @@
-
 import { genHandlers } from './events'
 import baseDirectives from '../directives/index'
 import { camelize, no, extend } from 'shared/util'
@@ -58,7 +57,7 @@ export function generate(
     : '_c("div")'
   return {
     render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns,
+    staticRenderFns: state.staticRenderFns
   }
 }
 
@@ -561,14 +560,17 @@ function genSlot(el: ASTElement, state: CodegenState): string {
   const slotName = el.slotName || '"default"'
   const children = genChildren(el, state)
   let res = `_t(${slotName}${children ? `,function(){return ${children}}` : ''}`
-  const attrs = el.attrs || el.dynamicAttrs
-    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
-        // slot props are camelized
-        name: camelize(attr.name),
-        value: attr.value,
-        dynamic: attr.dynamic
-      })))
-    : null
+  const attrs =
+    el.attrs || el.dynamicAttrs
+      ? genProps(
+          (el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
+            // slot props are camelized
+            name: camelize(attr.name),
+            value: attr.value,
+            dynamic: attr.dynamic
+          }))
+        )
+      : null
   const bind = el.attrsMap['v-bind']
   if ((attrs || bind) && !children) {
     res += `,null`
@@ -599,9 +601,7 @@ function genProps(props: Array<ASTAttr>): string {
   let dynamicProps = ``
   for (let i = 0; i < props.length; i++) {
     const prop = props[i]
-    const value = __WEEX__
-      ? generateValue(prop.value)
-      : transformSpecialNewlines(prop.value)
+    const value = transformSpecialNewlines(prop.value)
     if (prop.dynamic) {
       dynamicProps += `${prop.name},${value},`
     } else {
@@ -616,14 +616,6 @@ function genProps(props: Array<ASTAttr>): string {
   }
 }
 
-/* istanbul ignore next */
-function generateValue(value) {
-  if (typeof value === 'string') {
-    return transformSpecialNewlines(value)
-  }
-  return JSON.stringify(value)
-}
-
 // #3895, #4268
 function transformSpecialNewlines(text: string): string {
   return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
diff --git a/src/core/util/env.ts b/src/core/util/env.ts
index 1b914ce853e..cf64f50b7a2 100644
--- a/src/core/util/env.ts
+++ b/src/core/util/env.ts
@@ -1,19 +1,14 @@
-
 // can we use __proto__?
 export const hasProto = '__proto__' in {}
 
 // Browser environment sniffing
 export const inBrowser = typeof window !== 'undefined'
-export const inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform
-export const weexPlatform = inWeex && WXEnvironment.platform.toLowerCase()
 export const UA = inBrowser && window.navigator.userAgent.toLowerCase()
 export const isIE = UA && /msie|trident/.test(UA)
 export const isIE9 = UA && UA.indexOf('msie 9.0') > 0
 export const isEdge = UA && UA.indexOf('edge/') > 0
-export const isAndroid =
-  (UA && UA.indexOf('android') > 0) || weexPlatform === 'android'
-export const isIOS =
-  (UA && /iphone|ipad|ipod|ios/.test(UA)) || weexPlatform === 'ios'
+export const isAndroid = UA && UA.indexOf('android') > 0
+export const isIOS = UA && /iphone|ipad|ipod|ios/.test(UA)
 export const isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge
 export const isPhantomJS = UA && /phantomjs/.test(UA)
 export const isFF = UA && UA.match(/firefox\/(\d+)/)
@@ -30,7 +25,7 @@ if (inBrowser) {
       get() {
         /* istanbul ignore next */
         supportsPassive = true
-      },
+      }
     } as object) // https://github.com/facebook/flow/issues/285
     window.addEventListener('test-passive', null as any, opts)
   } catch (e: any) {}
@@ -42,7 +37,7 @@ let _isServer
 export const isServerRendering = () => {
   if (_isServer === undefined) {
     /* istanbul ignore if */
-    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
+    if (!inBrowser && typeof global !== 'undefined') {
       // detect presence of vue-server-renderer and avoid
       // Webpack shimming the process
       _isServer =
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index f441fb8c599..e25b47720dc 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -1,4 +1,3 @@
-
 import { warn } from './debug'
 import { observe, toggleObserving, shouldObserve } from '../observer/index'
 import {
@@ -7,7 +6,7 @@ import {
   toRawType,
   hyphenate,
   capitalize,
-  isPlainObject,
+  isPlainObject
 } from 'shared/util'
 import type { Component } from 'typescript/component'
 
@@ -51,11 +50,7 @@ export function validateProp(
     observe(value)
     toggleObserving(prevShouldObserve)
   }
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    // skip validation for weex recycle-list child component props
-    !(__WEEX__ && isObject(value) && '@binding' in value)
-  ) {
+  if (process.env.NODE_ENV !== 'production') {
     assertProp(prop, key, value, vm, absent)
   }
   return value
@@ -182,7 +177,7 @@ function assertType(
   }
   return {
     valid,
-    expectedType,
+    expectedType
   }
 }
 
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index cbe4ce9b3a1..3958217cb0d 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -20,10 +20,6 @@ import {
   deactivateChildComponent,
 } from '../instance/lifecycle'
 
-import {
-  isRecyclableComponent,
-  renderRecyclableComponentTemplate,
-} from 'weex/runtime/recycle-list/render-component-template'
 import type {
   MountedComponentVNode,
   VNodeData,
@@ -206,14 +202,6 @@ export function createComponent(
     asyncFactory
   )
 
-  // Weex specific: invoke recycle-list optimized @render function for
-  // extracting cell-slot template.
-  // https://github.com/Hanks10100/weex-native-directive/tree/master/component
-  /* istanbul ignore if */
-  if (__WEEX__ && isRecyclableComponent(vnode)) {
-    return renderRecyclableComponentTemplate(vnode)
-  }
-
   return vnode
 }
 
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index 1da4f29a42d..4dd695a0863 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -1,4 +1,3 @@
-
 import config from '../config'
 import VNode, { createEmptyVNode } from './vnode'
 import { createComponent } from './create-component'
@@ -11,7 +10,7 @@ import {
   isTrue,
   isObject,
   isPrimitive,
-  resolveAsset,
+  resolveAsset
 } from '../util/index'
 
 import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
@@ -74,14 +73,11 @@ export function _createElement(
     isDef(data.key) &&
     !isPrimitive(data.key)
   ) {
-    // @ts-expect-error
-    if (!__WEEX__ || !('@binding' in data.key)) {
-      warn(
-        'Avoid using non-primitive value as key, ' +
-          'use string/number value instead.',
-        context
-      )
-    }
+    warn(
+      'Avoid using non-primitive value as key, ' +
+        'use string/number value instead.',
+      context
+    )
   }
   // support single function children as default scoped slot
   if (Array.isArray(children) && typeof children[0] === 'function') {
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index ce84e18bab3..ff133d88b68 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -1,5 +1,5 @@
 import { warn, invokeWithErrorHandling } from 'core/util/index'
-import { cached, isUndef, isTrue, isPlainObject } from 'shared/util'
+import { cached, isUndef, isTrue } from 'shared/util'
 import type { Component } from 'typescript/component'
 
 const normalizeEvent = cached((name: string): {
@@ -69,11 +69,6 @@ export function updateListeners(
     def = cur = on[name]
     old = oldOn[name]
     event = normalizeEvent(name)
-    /* istanbul ignore if */
-    if (__WEEX__ && isPlainObject(def)) {
-      cur = def.handler
-      event.params = def.params
-    }
     if (isUndef(cur)) {
       process.env.NODE_ENV !== 'production' &&
         warn(
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index 5f925a5ca71..4c5fd4acd42 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -170,32 +170,11 @@ export function createPatchFunction(backend) {
         : nodeOps.createElement(tag, vnode)
       setScope(vnode)
 
-      /* istanbul ignore if */
-      if (__WEEX__) {
-        // in Weex, the default insertion order is parent-first.
-        // List items can be optimized to use children-first insertion
-        // with append="tree".
-        const appendAsTree = isDef(data) && isTrue(data.appendAsTree)
-        if (!appendAsTree) {
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue)
-          }
-          insert(parentElm, vnode.elm, refElm)
-        }
-        createChildren(vnode, children, insertedVnodeQueue)
-        if (appendAsTree) {
-          if (isDef(data)) {
-            invokeCreateHooks(vnode, insertedVnodeQueue)
-          }
-          insert(parentElm, vnode.elm, refElm)
-        }
-      } else {
-        createChildren(vnode, children, insertedVnodeQueue)
-        if (isDef(data)) {
-          invokeCreateHooks(vnode, insertedVnodeQueue)
-        }
-        insert(parentElm, vnode.elm, refElm)
+      createChildren(vnode, children, insertedVnodeQueue)
+      if (isDef(data)) {
+        invokeCreateHooks(vnode, insertedVnodeQueue)
       }
+      insert(parentElm, vnode.elm, refElm)
 
       if (process.env.NODE_ENV !== 'production' && data && data.pre) {
         creatingElmInVPre--
diff --git a/src/global.d.ts b/src/global.d.ts
index cdb70d0f9cb..22eaaeff235 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,32 +1,9 @@
-declare const __WEEX__: boolean;
 declare const __SSR_TEST__: boolean;
-declare type WeexEnvironment = {
-  platform: string; // could be "Web", "iOS", "Android"
-  weexVersion: string; // the version of WeexSDK
-
-  osName: string; // could be "iOS", "Android" or others
-  osVersion: string;
-  appName: string; // mobile app name or browser name
-  appVersion: string;
-
-  // information about current running device
-  deviceModel: string; // phone device model
-  deviceWidth: number;
-  deviceHeight: number;
-  scale: number;
-
-  // only available on the web
-  userAgent?: string;
-  dpr?: number;
-  rem?: number;
-};
-declare let WXEnvironment: WeexEnvironment;
 
 interface Window {
   __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook;
 }
 
-
 // from https://github.com/vuejs/vue-devtools/blob/bc719c95a744614f5c3693460b64dc21dfa339a8/packages/app-backend-api/src/global-hook.ts#L3
 interface DevtoolsHook {
   emit: (event: string, ...payload: any[]) => void
diff --git a/src/platforms/weex/compiler/directives/index.ts b/src/platforms/weex/compiler/directives/index.ts
deleted file mode 100644
index 8242af3a02a..00000000000
--- a/src/platforms/weex/compiler/directives/index.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import model from './model'
-
-export default {
-  model,
-}
diff --git a/src/platforms/weex/compiler/directives/model.ts b/src/platforms/weex/compiler/directives/model.ts
deleted file mode 100644
index e333ddad263..00000000000
--- a/src/platforms/weex/compiler/directives/model.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-
-import { addHandler, addAttr } from 'compiler/helpers'
-import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
-
-export default function model(el: ASTElement, dir: ASTDirective): void {
-  if (el.tag === 'input' || el.tag === 'textarea') {
-    genDefaultModel(el, dir.value, dir.modifiers)
-  } else {
-    genComponentModel(el, dir.value, dir.modifiers)
-  }
-}
-
-function genDefaultModel(
-  el: ASTElement,
-  value: string,
-  modifiers: ASTModifiers | null
-) {
-  const { lazy, trim, number } = modifiers || {}
-  const event = lazy ? 'change' : 'input'
-
-  let valueExpression = `$event.target.attr.value${trim ? '.trim()' : ''}`
-  if (number) {
-    valueExpression = `_n(${valueExpression})`
-  }
-
-  const code = genAssignmentCode(value, valueExpression)
-  addAttr(el, 'value', `(${value})`)
-  addHandler(el, event, code, null, true)
-}
diff --git a/src/platforms/weex/compiler/index.ts b/src/platforms/weex/compiler/index.ts
deleted file mode 100644
index 37782b99f25..00000000000
--- a/src/platforms/weex/compiler/index.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-
-import { genStaticKeys } from 'shared/util'
-import { createCompiler } from 'compiler/index'
-
-import modules from './modules/index'
-import directives from './directives/index'
-
-import {
-  isUnaryTag,
-  mustUseProp,
-  isReservedTag,
-  canBeLeftOpenTag,
-  getTagNamespace,
-} from '../util/element'
-import type { WeexCompiledResult, WeexCompilerOptions } from 'typescript/weex'
-
-export const baseOptions: WeexCompilerOptions = {
-  modules,
-  directives,
-  isUnaryTag,
-  mustUseProp,
-  canBeLeftOpenTag,
-  isReservedTag,
-  getTagNamespace,
-  preserveWhitespace: false,
-  recyclable: false,
-  staticKeys: genStaticKeys(modules),
-}
-
-const compiler = createCompiler(baseOptions)
-
-export function compile(
-  template: string,
-  options?: WeexCompilerOptions
-): WeexCompiledResult {
-  let generateAltRender = false
-  if (options && options.recyclable === true) {
-    generateAltRender = true
-    options.recyclable = false
-  }
-  const result = compiler.compile(template, options)
-
-  // generate @render function for <recycle-list>
-  if (options && generateAltRender) {
-    options.recyclable = true
-    // disable static optimizations
-    options.optimize = false
-    const { render } = compiler.compile(template, options)
-    result['@render'] = render
-  }
-  return result
-}
diff --git a/src/platforms/weex/compiler/modules/append.ts b/src/platforms/weex/compiler/modules/append.ts
deleted file mode 100644
index 90555041332..00000000000
--- a/src/platforms/weex/compiler/modules/append.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-
-import { makeMap } from 'shared/util'
-
-// The "unitary tag" means that the tag node and its children
-// must be sent to the native together.
-const isUnitaryTag = makeMap('cell,header,cell-slot,recycle-list', true)
-
-function preTransformNode(el: ASTElement) {
-  if (
-    isUnitaryTag(el.tag) &&
-    !el.attrsList.some((item) => item.name === 'append')
-  ) {
-    el.attrsMap.append = 'tree'
-    el.attrsList.push({ name: 'append', value: 'tree' })
-  }
-  if (el.attrsMap.append === 'tree') {
-    el.appendAsTree = true
-  }
-}
-
-function genData(el: ASTElement): string {
-  return el.appendAsTree ? `appendAsTree:true,` : ''
-}
-
-export default {
-  staticKeys: ['appendAsTree'],
-  preTransformNode,
-  genData,
-} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/class.ts b/src/platforms/weex/compiler/modules/class.ts
deleted file mode 100644
index 99c6d771cba..00000000000
--- a/src/platforms/weex/compiler/modules/class.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-
-import { parseText } from 'compiler/parser/text-parser'
-import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
-
-type StaticClassResult = {
-  dynamic: boolean
-  classResult: string
-}
-
-function transformNode(el: ASTElement, options: CompilerOptions) {
-  const warn = options.warn || baseWarn
-  const staticClass = getAndRemoveAttr(el, 'class')
-  const { dynamic, classResult } = parseStaticClass(staticClass, options)
-  if (process.env.NODE_ENV !== 'production' && dynamic && staticClass) {
-    warn(
-      `class="${staticClass}": ` +
-        'Interpolation inside attributes has been deprecated. ' +
-        'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['class']
-    )
-  }
-  if (!dynamic && classResult) {
-    el.staticClass = classResult
-  }
-  const classBinding = getBindingAttr(el, 'class', false /* getStatic */)
-  if (classBinding) {
-    el.classBinding = classBinding
-  } else if (dynamic) {
-    el.classBinding = classResult
-  }
-}
-
-function genData(el: ASTElement): string {
-  let data = ''
-  if (el.staticClass) {
-    data += `staticClass:${el.staticClass},`
-  }
-  if (el.classBinding) {
-    data += `class:${el.classBinding},`
-  }
-  return data
-}
-
-function parseStaticClass(
-  staticClass: string | null | undefined,
-  options: CompilerOptions
-): StaticClassResult {
-  // "a b c" -> ["a", "b", "c"] => staticClass: ["a", "b", "c"]
-  // "a {{x}} c" -> ["a", x, "c"] => classBinding: '["a", x, "c"]'
-  let dynamic = false
-  let classResult = ''
-  if (staticClass) {
-    const classList = staticClass
-      .trim()
-      .split(' ')
-      .map((name) => {
-        const result = parseText(name, options.delimiters)
-        if (result) {
-          dynamic = true
-          return result.expression
-        }
-        return JSON.stringify(name)
-      })
-    if (classList.length) {
-      classResult = '[' + classList.join(',') + ']'
-    }
-  }
-  return { dynamic, classResult }
-}
-
-export default {
-  staticKeys: ['staticClass'],
-  transformNode,
-  genData,
-} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/index.ts b/src/platforms/weex/compiler/modules/index.ts
deleted file mode 100644
index 96a379925aa..00000000000
--- a/src/platforms/weex/compiler/modules/index.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import klass from './class'
-import style from './style'
-import props from './props'
-import append from './append'
-import recycleList from './recycle-list/index'
-
-export default [recycleList, klass, style, props, append]
diff --git a/src/platforms/weex/compiler/modules/props.ts b/src/platforms/weex/compiler/modules/props.ts
deleted file mode 100644
index 08b358ed09c..00000000000
--- a/src/platforms/weex/compiler/modules/props.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-
-import { cached, camelize } from 'shared/util'
-
-const normalize = cached(camelize)
-
-function normalizeKeyName(str: string): string {
-  if (str.match(/^v\-/)) {
-    return str.replace(/(v-[a-z\-]+\:)([a-z\-]+)$/i, ($, directive, prop) => {
-      return directive + normalize(prop)
-    })
-  }
-  return normalize(str)
-}
-
-function transformNode(el: ASTElement) {
-  if (Array.isArray(el.attrsList)) {
-    el.attrsList.forEach((attr) => {
-      if (attr.name && attr.name.match(/\-/)) {
-        const realName = normalizeKeyName(attr.name)
-        if (el.attrsMap) {
-          el.attrsMap[realName] = el.attrsMap[attr.name]
-          delete el.attrsMap[attr.name]
-        }
-        if (el.rawAttrsMap && el.rawAttrsMap[attr.name]) {
-          el.rawAttrsMap[realName] = el.rawAttrsMap[attr.name]
-          // $flow-disable-line
-          delete el.rawAttrsMap[attr.name]
-        }
-        attr.name = realName
-      }
-    })
-  }
-}
-export default {
-  transformNode,
-} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component-root.ts b/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
deleted file mode 100644
index f82989cbad1..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/component-root.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-
-import { addAttr } from 'compiler/helpers'
-
-// mark component root nodes as
-export function postTransformComponentRoot(el: ASTElement) {
-  if (!el.parent) {
-    // component root
-    addAttr(el, '@isComponentRoot', 'true')
-    addAttr(el, '@templateId', '_uid')
-    addAttr(el, '@componentProps', '$props || {}')
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/component.ts b/src/platforms/weex/compiler/modules/recycle-list/component.ts
deleted file mode 100644
index 0fa37100901..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/component.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-
-import { addAttr } from 'compiler/helpers'
-import type { WeexCompilerOptions } from 'typescript/weex'
-import { RECYCLE_LIST_MARKER } from 'weex/util/index'
-
-// mark components as inside recycle-list so that we know we need to invoke
-// their special @render function instead of render in create-component.js
-export function postTransformComponent(
-  el: ASTElement,
-  options: WeexCompilerOptions
-) {
-  // $flow-disable-line (we know isReservedTag is there)
-  if (!options.isReservedTag!(el.tag) && el.tag !== 'cell-slot') {
-    addAttr(el, RECYCLE_LIST_MARKER, 'true')
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/index.ts b/src/platforms/weex/compiler/modules/recycle-list/index.ts
deleted file mode 100644
index 89b25e7b306..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/index.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-
-import { preTransformRecycleList } from './recycle-list'
-import { postTransformComponent } from './component'
-import { postTransformComponentRoot } from './component-root'
-import { postTransformText } from './text'
-import { preTransformVBind } from './v-bind'
-import { preTransformVIf } from './v-if'
-import { preTransformVFor } from './v-for'
-import { postTransformVOn } from './v-on'
-import { preTransformVOnce } from './v-once'
-import type { WeexCompilerOptions } from 'typescript/weex'
-
-let currentRecycleList: null | ASTElement = null
-
-function shouldCompile(el: ASTElement, options: WeexCompilerOptions) {
-  return options.recyclable || (currentRecycleList && el !== currentRecycleList)
-}
-
-function preTransformNode(el: ASTElement, options: WeexCompilerOptions) {
-  if (el.tag === 'recycle-list') {
-    preTransformRecycleList(el, options)
-    currentRecycleList = el
-  }
-  if (shouldCompile(el, options)) {
-    preTransformVBind(el)
-    preTransformVIf(el, options) // also v-else-if and v-else
-    preTransformVFor(el, options)
-    preTransformVOnce(el)
-  }
-}
-
-function transformNode(el: ASTElement, options: WeexCompilerOptions) {
-  if (shouldCompile(el, options)) {
-    // do nothing yet
-  }
-}
-
-function postTransformNode(el: ASTElement, options: WeexCompilerOptions) {
-  if (shouldCompile(el, options)) {
-    // mark child component in parent template
-    postTransformComponent(el, options)
-    // mark root in child component template
-    postTransformComponentRoot(el)
-    // <text>: transform children text into value attr
-    if (el.tag === 'text') {
-      postTransformText(el)
-    }
-    postTransformVOn(el)
-  }
-  if (el === currentRecycleList) {
-    currentRecycleList = null
-  }
-}
-
-export default {
-  preTransformNode,
-  transformNode,
-  postTransformNode,
-} as ModuleOptions
diff --git a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts b/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
deleted file mode 100644
index c3f3a58b72d..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/recycle-list.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-
-import { parseFor } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-import type { WeexCompilerOptions } from 'typescript/weex'
-
-/**
- * Map the following syntax to corresponding attrs:
- *
- * <recycle-list for="(item, i) in longList" switch="cellType">
- *   <cell-slot case="A"> ... </cell-slot>
- *   <cell-slot case="B"> ... </cell-slot>
- * </recycle-list>
- */
-
-export function preTransformRecycleList(
-  el: ASTElement,
-  options: WeexCompilerOptions
-) {
-  const exp = getAndRemoveAttr(el, 'for')
-  if (!exp) {
-    if (options.warn) {
-      options.warn(`Invalid <recycle-list> syntax: missing "for" expression.`)
-    }
-    return
-  }
-
-  const res = parseFor(exp)
-  if (!res) {
-    if (options.warn) {
-      options.warn(`Invalid <recycle-list> syntax: ${exp}.`)
-    }
-    return
-  }
-
-  addRawAttr(el, ':list-data', res.for)
-  addRawAttr(el, 'binding-expression', res.for)
-  addRawAttr(el, 'alias', res.alias)
-  if (res.iterator2) {
-    // (item, key, index) for object iteration
-    // is this even supported?
-    addRawAttr(el, 'index', res.iterator2)
-  } else if (res.iterator1) {
-    addRawAttr(el, 'index', res.iterator1)
-  }
-
-  const switchKey = getAndRemoveAttr(el, 'switch')
-  if (switchKey) {
-    addRawAttr(el, 'switch', switchKey)
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/text.ts b/src/platforms/weex/compiler/modules/recycle-list/text.ts
deleted file mode 100644
index be8cddbc85f..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/text.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-
-import { addAttr } from 'compiler/helpers'
-
-function genText(node: ASTNode) {
-  const value =
-    node.type === 3
-      ? node.text
-      : node.type === 2
-      ? node.tokens.length === 1
-        ? node.tokens[0]
-        : node.tokens
-      : ''
-  return JSON.stringify(value)
-}
-
-export function postTransformText(el: ASTElement) {
-  // weex <text> can only contain text, so the parser
-  // always generates a single child.
-  if (el.children.length) {
-    addAttr(el, 'value', genText(el.children[0]))
-    el.children = []
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts b/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
deleted file mode 100644
index 04b42ff0f27..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/v-bind.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-
-import { camelize } from 'shared/util'
-import { generateBinding } from 'weex/util/parser'
-import { bindRE } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-function parseAttrName(name: string): string {
-  return camelize(name.replace(bindRE, ''))
-}
-
-export function preTransformVBind(el: ASTElement) {
-  for (const attr in el.attrsMap) {
-    if (bindRE.test(attr)) {
-      const name: string = parseAttrName(attr)
-      const value = generateBinding(getAndRemoveAttr(el, attr))
-      delete el.attrsMap[attr]
-      addRawAttr(el, name, value)
-    }
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-for.ts b/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
deleted file mode 100644
index c441819c0ba..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/v-for.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-
-import { parseFor } from 'compiler/parser/index'
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-import type { WeexCompilerOptions } from 'typescript/weex'
-
-export function preTransformVFor(el: ASTElement, options: WeexCompilerOptions) {
-  const exp = getAndRemoveAttr(el, 'v-for')
-  if (!exp) {
-    return
-  }
-
-  const res = parseFor(exp)
-  if (!res) {
-    if (process.env.NODE_ENV !== 'production' && options.warn) {
-      options.warn(`Invalid v-for expression: ${exp}`)
-    }
-    return
-  }
-
-  const desc: Object = {
-    '@expression': res.for,
-    '@alias': res.alias,
-  }
-  if (res.iterator2) {
-    desc['@key'] = res.iterator1
-    desc['@index'] = res.iterator2
-  } else {
-    desc['@index'] = res.iterator1
-  }
-
-  delete el.attrsMap['v-for']
-  addRawAttr(el, '[[repeat]]', desc)
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts b/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
deleted file mode 100644
index a8a22347c4d..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/v-if.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { addIfCondition } from "compiler/parser/index";
-import { getAndRemoveAttr, addRawAttr } from "compiler/helpers";
-import type { WeexCompilerOptions } from "typescript/weex";
-
-function hasConditionDirective(el: ASTElement): boolean {
-  for (const attr in el.attrsMap) {
-    if (/^v\-if|v\-else|v\-else\-if$/.test(attr)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function getPreviousConditions(el: ASTElement): Array<string> {
-  const conditions: any[] = [];
-  if (el.parent && el.parent.children) {
-    for (let c = 0, n = el.parent.children.length; c < n; ++c) {
-      const ifConditions = (el.parent.children[c] as ASTElement).ifConditions;
-      if (ifConditions) {
-        for (let i = 0, l = ifConditions.length; i < l; ++i) {
-          const condition = ifConditions[i];
-          if (condition && condition.exp) {
-            conditions.push(condition.exp);
-          }
-        }
-      }
-    }
-  }
-  return conditions;
-}
-
-export function preTransformVIf(el: ASTElement, options: WeexCompilerOptions) {
-  if (hasConditionDirective(el)) {
-    let exp;
-    const ifExp = getAndRemoveAttr(el, "v-if", true /* remove from attrsMap */);
-    const elseifExp = getAndRemoveAttr(el, "v-else-if", true);
-    // don't need the value, but remove it to avoid being generated as a
-    // custom directive
-    getAndRemoveAttr(el, "v-else", true);
-    if (ifExp) {
-      exp = ifExp;
-      addIfCondition(el, { exp: ifExp, block: el });
-    } else {
-      elseifExp && addIfCondition(el, { exp: elseifExp, block: el });
-      const prevConditions = getPreviousConditions(el);
-      if (prevConditions.length) {
-        const prevMatch = prevConditions.join(" || ");
-        exp = elseifExp
-          ? `!(${prevMatch}) && (${elseifExp})` // v-else-if
-          : `!(${prevMatch})`; // v-else
-      } else if (process.env.NODE_ENV !== "production" && options.warn) {
-        options.warn(
-          `v-${elseifExp ? 'else-if="' + elseifExp + '"' : "else"} ` +
-            `used on element <${el.tag}> without corresponding v-if.`
-        );
-        return;
-      }
-    }
-    addRawAttr(el, "[[match]]", exp);
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-on.ts b/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
deleted file mode 100644
index 94051ad3356..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/v-on.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-
-const inlineStatementRE = /^\s*([A-Za-z_$0-9\['\."\]]+)*\s*\(\s*(([A-Za-z_$0-9\['\."\]]+)?(\s*,\s*([A-Za-z_$0-9\['\."\]]+))*)\s*\)$/
-
-function parseHandlerParams(handler: ASTElementHandler) {
-  const res = inlineStatementRE.exec(handler.value)
-  if (res && res[2]) {
-    handler.params = res[2].split(/\s*,\s*/)
-  }
-}
-
-export function postTransformVOn(el: ASTElement) {
-  const events: ASTElementHandlers | void = el.events
-  if (!events) {
-    return
-  }
-  for (const name in events) {
-    const handler: ASTElementHandler | Array<ASTElementHandler> = events[name]
-    if (Array.isArray(handler)) {
-      handler.map((fn) => parseHandlerParams(fn))
-    } else {
-      parseHandlerParams(handler)
-    }
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/recycle-list/v-once.ts b/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
deleted file mode 100644
index a3e4d29bc84..00000000000
--- a/src/platforms/weex/compiler/modules/recycle-list/v-once.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-
-import { getAndRemoveAttr, addRawAttr } from 'compiler/helpers'
-
-function containVOnce(el: ASTElement): boolean {
-  for (const attr in el.attrsMap) {
-    if (/^v\-once$/i.test(attr)) {
-      return true
-    }
-  }
-  return false
-}
-
-export function preTransformVOnce(el: ASTElement) {
-  if (containVOnce(el)) {
-    getAndRemoveAttr(el, 'v-once', true)
-    addRawAttr(el, '[[once]]', true)
-  }
-}
diff --git a/src/platforms/weex/compiler/modules/style.ts b/src/platforms/weex/compiler/modules/style.ts
deleted file mode 100644
index 67ba48e2fe4..00000000000
--- a/src/platforms/weex/compiler/modules/style.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-
-import { cached, camelize, isPlainObject } from 'shared/util'
-import { parseText } from 'compiler/parser/text-parser'
-import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
-
-type StaticStyleResult = {
-  dynamic: boolean
-  styleResult: string 
-}
-
-const normalize = cached(camelize)
-
-function transformNode(el: ASTElement, options: CompilerOptions) {
-  const warn = options.warn || baseWarn
-  const staticStyle = getAndRemoveAttr(el, 'style')
-  const { dynamic, styleResult } = parseStaticStyle(staticStyle!, options)
-  if (process.env.NODE_ENV !== 'production' && dynamic) {
-    warn(
-      `style="${String(staticStyle)}": ` +
-        'Interpolation inside attributes has been deprecated. ' +
-        'Use v-bind or the colon shorthand instead.',
-      el.rawAttrsMap['style']
-    )
-  }
-  if (!dynamic && styleResult) {
-    el.staticStyle = styleResult
-  }
-  const styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
-  if (styleBinding) {
-    el.styleBinding = styleBinding
-  } else if (dynamic) {
-    el.styleBinding = styleResult
-  }
-}
-
-function genData(el: ASTElement): string {
-  let data = ''
-  if (el.staticStyle) {
-    data += `staticStyle:${el.staticStyle},`
-  }
-  if (el.styleBinding) {
-    data += `style:${el.styleBinding},`
-  }
-  return data
-}
-
-function parseStaticStyle(
-  staticStyle: string | null,
-  options: CompilerOptions
-): StaticStyleResult {
-  // "width: 200px; height: 200px;" -> {width: 200, height: 200}
-  // "width: 200px; height: {{y}}" -> {width: 200, height: y}
-  let dynamic = false
-  let styleResult = ''
-  if (typeof staticStyle === 'string') {
-    const styleList = staticStyle
-      .trim()
-      .split(';')
-      .map((style) => {
-        const result = style.trim().split(':')
-        if (result.length !== 2) {
-          return
-        }
-        const key = normalize(result[0].trim())
-        const value = result[1].trim()
-        const dynamicValue = parseText(value, options.delimiters)
-        if (dynamicValue) {
-          dynamic = true
-          return key + ':' + dynamicValue.expression
-        }
-        return key + ':' + JSON.stringify(value)
-      })
-      .filter((result) => result)
-    if (styleList.length) {
-      styleResult = '{' + styleList.join(',') + '}'
-    }
-  } else if (isPlainObject(staticStyle)) {
-    styleResult = JSON.stringify(staticStyle) || ''
-  }
-  return { dynamic, styleResult }
-}
-
-export default {
-  staticKeys: ['staticStyle'],
-  transformNode,
-  genData,
-} as ModuleOptions
diff --git a/src/platforms/weex/entry-compiler.ts b/src/platforms/weex/entry-compiler.ts
deleted file mode 100644
index b8f3f8ffcfb..00000000000
--- a/src/platforms/weex/entry-compiler.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export { compile } from 'weex/compiler/index'
-export { generateCodeFrame } from 'compiler/codeframe'
diff --git a/src/platforms/weex/entry-framework.ts b/src/platforms/weex/entry-framework.ts
deleted file mode 100644
index 90766b2333e..00000000000
--- a/src/platforms/weex/entry-framework.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-
-import type { GlobalAPI } from 'typescript/global-api'
-import type {
-  Weex,
-  WeexInstanceContext,
-  WeexInstanceOption,
-  WeexRuntimeContext,
-} from 'typescript/weex'
-
-// this will be preserved during build
-const VueFactory = require('./factory')
-
-const instanceOptions: { [key: string]: WeexInstanceOption } = {}
-
-/**
- * Create instance context.
- */
-export function createInstanceContext(
-  instanceId: string,
-  runtimeContext: WeexRuntimeContext,
-  data: any = {}
-): WeexInstanceContext {
-  const weex: Weex = runtimeContext.weex
-  const instance: WeexInstanceOption = (instanceOptions[instanceId] = {
-    instanceId,
-    config: weex.config,
-    document: weex.document,
-    data
-  })
-
-  // Each instance has an independent `Vue` module instance
-  const Vue = instance.Vue = createVueModuleInstance(instanceId, weex)
-
-  // DEPRECATED
-  const timerAPIs = getInstanceTimer(instanceId, weex.requireModule)
-
-  const instanceContext = Object.assign({ Vue }, timerAPIs)
-  Object.freeze(instanceContext)
-  return instanceContext
-}
-
-/**
- * Destroy an instance with id. It will make sure all memory of
- * this instance released and no more leaks.
- */
-export function destroyInstance(instanceId: string): void {
-  const instance = instanceOptions[instanceId]
-  //@ts-expect-error
-  if (instance && instance.app instanceof instance.Vue) {
-    try {
-      instance.app!.$destroy()
-      instance.document.destroy()
-    } catch (e: any) {}
-    //@ts-expect-error
-    delete instance.document
-    delete instance.app
-  }
-  delete instanceOptions[instanceId]
-}
-
-/**
- * Refresh an instance with id and new top-level component data.
- * It will use `Vue.set` on all keys of the new data. So it's better
- * define all possible meaningful keys when instance created.
- */
-export function refreshInstance(
-  instanceId: string,
-  data: Object
-): Error | void {
-  const instance = instanceOptions[instanceId]
-  //@ts-expect-error
-  if (!instance || !(instance.app instanceof instance.Vue)) {
-    return new Error(`refreshInstance: instance ${instanceId} not found!`)
-  }
-  if (instance.Vue && instance.Vue.set) {
-    for (const key in data) {
-      instance.Vue.set(instance.app!, key, data[key])
-    }
-  }
-  // Finally `refreshFinish` signal needed.
-  instance.document.taskCenter.send('dom', { action: 'refreshFinish' }, [])
-}
-
-/**
- * Create a fresh instance of Vue for each Weex instance.
- */
-function createVueModuleInstance(instanceId: string, weex: Weex): GlobalAPI {
-  const exports = {}
-  VueFactory(exports, weex.document)
-  //@ts-expect-error
-  const Vue = exports.Vue
-
-  const instance = instanceOptions[instanceId]
-
-  // patch reserved tag detection to account for dynamically registered
-  // components
-  const weexRegex = /^weex:/i
-  const isReservedTag = Vue.config.isReservedTag || (() => false)
-  const isRuntimeComponent = Vue.config.isRuntimeComponent || (() => false)
-  Vue.config.isReservedTag = (name) => {
-    return (
-      (!isRuntimeComponent(name) && weex.supports(`@component/${name}`)) ||
-      isReservedTag(name) ||
-      weexRegex.test(name)
-    )
-  }
-  Vue.config.parsePlatformTagName = (name) => name.replace(weexRegex, '')
-
-  // expose weex-specific info
-  Vue.prototype.$instanceId = instanceId
-  Vue.prototype.$document = instance.document
-
-  // expose weex native module getter on subVue prototype so that
-  // vdom runtime modules can access native modules via vnode.context
-  Vue.prototype.$requireWeexModule = weex.requireModule
-
-  // Hack `Vue` behavior to handle instance information and data
-  // before root component created.
-  Vue.mixin({
-    beforeCreate() {
-      const options = this.$options
-      // root component (vm)
-      if (options.el) {
-        // set external data of instance
-        const dataOption = options.data
-        const internalData =
-          (typeof dataOption === 'function' ? dataOption() : dataOption) || {}
-        options.data = Object.assign(internalData, instance.data)
-        // record instance by id
-        instance.app = this
-      }
-    },
-    mounted() {
-      const options = this.$options
-      // root component (vm)
-      if (options.el && weex.document && instance.app === this) {
-        try {
-          // Send "createFinish" signal to native.
-          weex.document.taskCenter.send('dom', { action: 'createFinish' }, [])
-        } catch (e: any) {}
-      }
-    },
-  })
-
-  /**
-   * @deprecated Just instance variable `weex.config`
-   * Get instance config.
-   * @return {object}
-   */
-  Vue.prototype.$getConfig = function () {
-    if (instance.app instanceof Vue) {
-      return instance.config
-    }
-  }
-
-  return Vue
-}
-
-/**
- * DEPRECATED
- * Generate HTML5 Timer APIs. An important point is that the callback
- * will be converted into callback id when sent to native. So the
- * framework can make sure no side effect of the callback happened after
- * an instance destroyed.
- */
-function getInstanceTimer(instanceId: string, moduleGetter: Function): Object {
-  const instance = instanceOptions[instanceId]
-  const timer = moduleGetter('timer')
-  const timerAPIs = {
-    setTimeout: (...args) => {
-      const handler = function () {
-        args[0](...args.slice(2))
-      }
-
-      timer.setTimeout(handler, args[1])
-      //@ts-expect-error
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    setInterval: (...args) => {
-      const handler = function () {
-        args[0](...args.slice(2))
-      }
-
-      timer.setInterval(handler, args[1])
-      //@ts-expect-error
-      return instance.document.taskCenter.callbackManager.lastCallbackId.toString()
-    },
-    clearTimeout: (n) => {
-      timer.clearTimeout(n)
-    },
-    clearInterval: (n) => {
-      timer.clearInterval(n)
-    },
-  }
-  return timerAPIs
-}
diff --git a/src/platforms/weex/entry-runtime-factory.ts b/src/platforms/weex/entry-runtime-factory.ts
deleted file mode 100644
index 166ddf2dae8..00000000000
--- a/src/platforms/weex/entry-runtime-factory.ts
+++ /dev/null
@@ -1,6 +0,0 @@
-// this entry is built and wrapped with a factory function
-// used to generate a fresh copy of Vue for every Weex instance.
-
-import Vue from './runtime/index'
-
-exports.Vue = Vue
diff --git a/src/platforms/weex/runtime/components/index.ts b/src/platforms/weex/runtime/components/index.ts
deleted file mode 100644
index 541a002566b..00000000000
--- a/src/platforms/weex/runtime/components/index.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import Richtext from './richtext'
-import Transition from './transition'
-import TransitionGroup from './transition-group'
-
-export default {
-  Richtext,
-  Transition,
-  TransitionGroup,
-}
diff --git a/src/platforms/weex/runtime/components/richtext.ts b/src/platforms/weex/runtime/components/richtext.ts
deleted file mode 100644
index 5d3e400a8e3..00000000000
--- a/src/platforms/weex/runtime/components/richtext.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-
-import VNode from 'core/vdom/vnode'
-
-function getVNodeType(vnode: VNode): string {
-  if (!vnode.tag) {
-    return ''
-  }
-  return vnode.tag.replace(/vue\-component\-(\d+\-)?/, '')
-}
-
-function isSimpleSpan(vnode: VNode): boolean {
-  return (vnode.children &&
-    vnode.children.length === 1 &&
-    !vnode.children[0].tag) as any
-}
-
-function parseStyle(vnode: VNode): Object | void {
-  if (!vnode || !vnode.data) {
-    return
-  }
-  const { staticStyle, staticClass } = vnode.data
-  if (vnode.data.style || vnode.data.class || staticStyle || staticClass) {
-    const styles = Object.assign({}, staticStyle, vnode.data.style)
-    // @ts-expect-error
-    const cssMap = vnode.context!.$options.style || {}
-    const classList = ([] as string[]).concat(staticClass!, vnode.data.class)
-    classList.forEach((name) => {
-      if (name && cssMap[name]) {
-        Object.assign(styles, cssMap[name])
-      }
-    })
-    return styles
-  }
-}
-
-function convertVNodeChildren(
-  children: Array<VNode>
-): Array<VNode> | undefined {
-  if (!children.length) {
-    return
-  }
-
-  return children.map(
-    (vnode): VNode => {
-      const type: string = getVNodeType(vnode)
-      const props: any = { type }
-
-      // convert raw text node
-      if (!type) {
-        props.type = 'span'
-        props.attr = {
-          value: (vnode.text || '').trim(),
-        }
-      } else {
-        props.style = parseStyle(vnode)
-        if (vnode.data) {
-          props.attr = vnode.data.attrs
-          if (vnode.data.on) {
-            props.events = vnode.data.on
-          }
-        }
-        if (type === 'span' && isSimpleSpan(vnode)) {
-          props.attr = props.attr || {}
-          //@ts-expect-error
-          props.attr.value = vnode.children[0].text.trim()
-          return props
-        }
-      }
-
-      if (vnode.children && vnode.children.length) {
-        props.children = convertVNodeChildren(vnode.children)
-      }
-
-      return props
-    }
-  )
-}
-
-export default {
-  name: 'richtext',
-  render(h: Function) {
-    return h('weex:richtext', {
-      on: this._events,
-      attrs: {
-        value: convertVNodeChildren(this.$options._renderChildren || []),
-      },
-    })
-  },
-}
diff --git a/src/platforms/weex/runtime/components/transition-group.ts b/src/platforms/weex/runtime/components/transition-group.ts
deleted file mode 100644
index 7333a3fd5a9..00000000000
--- a/src/platforms/weex/runtime/components/transition-group.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-import { warn, extend } from 'core/util/index'
-import { transitionProps, extractTransitionData } from './transition'
-
-const props = extend(
-  {
-    tag: String,
-    moveClass: String,
-  },
-  transitionProps
-)
-
-delete props.mode
-
-export default {
-  props,
-
-  created() {
-    const dom = this.$requireWeexModule('dom')
-    this.getPosition = (el) =>
-      new Promise((resolve, reject) => {
-        dom.getComponentRect(el.ref, (res) => {
-          if (!res.result) {
-            reject(new Error(`failed to get rect for element: ${el.tag}`))
-          } else {
-            resolve(res.size)
-          }
-        })
-      })
-
-    const animation = this.$requireWeexModule('animation')
-    this.animate = (el, options) =>
-      new Promise((resolve) => {
-        animation.transition(el.ref, options, resolve)
-      })
-  },
-
-  render(h) {
-    const tag = this.tag || this.$vnode.data.tag || 'span'
-    const map = Object.create(null)
-    const prevChildren = (this.prevChildren = this.children)
-    const rawChildren = this.$slots.default || []
-    const children: any[] = (this.children = [])
-    const transitionData = extractTransitionData(this)
-
-    for (let i = 0; i < rawChildren.length; i++) {
-      const c = rawChildren[i]
-      if (c.tag) {
-        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
-          children.push(c)
-          map[c.key] = c
-          ;(c.data || (c.data = {})).transition = transitionData
-        } else if (process.env.NODE_ENV !== 'production') {
-          const opts = c.componentOptions
-          const name = opts ? opts.Ctor.options.name || opts.tag : c.tag
-          warn(`<transition-group> children must be keyed: <${name}>`)
-        }
-      }
-    }
-
-    if (prevChildren) {
-      const kept: any[] = []
-      const removed: any[] = []
-      prevChildren.forEach((c) => {
-        c.data.transition = transitionData
-
-        // TODO: record before patch positions
-
-        if (map[c.key]) {
-          kept.push(c)
-        } else {
-          removed.push(c)
-        }
-      })
-      this.kept = h(tag, null, kept)
-      this.removed = removed
-    }
-
-    return h(tag, null, children)
-  },
-
-  beforeUpdate() {
-    // force removing pass
-    this.__patch__(
-      this._vnode,
-      this.kept,
-      false, // hydrating
-      true // removeOnly (!important, avoids unnecessary moves)
-    )
-    this._vnode = this.kept
-  },
-
-  updated() {
-    const children = this.prevChildren
-    const moveClass = this.moveClass || (this.name || 'v') + '-move'
-    const moveData =
-      children.length && this.getMoveData(children[0].context, moveClass)
-    if (!moveData) {
-      return
-    }
-
-    // TODO: finish implementing move animations once
-    // we have access to sync getComponentRect()
-
-    // children.forEach(callPendingCbs)
-
-    // Promise.all(children.map(c => {
-    //   const oldPos = c.data.pos
-    //   const newPos = c.data.newPos
-    //   const dx = oldPos.left - newPos.left
-    //   const dy = oldPos.top - newPos.top
-    //   if (dx || dy) {
-    //     c.data.moved = true
-    //     return this.animate(c.elm, {
-    //       styles: {
-    //         transform: `translate(${dx}px,${dy}px)`
-    //       }
-    //     })
-    //   }
-    // })).then(() => {
-    //   children.forEach(c => {
-    //     if (c.data.moved) {
-    //       this.animate(c.elm, {
-    //         styles: {
-    //           transform: ''
-    //         },
-    //         duration: moveData.duration || 0,
-    //         delay: moveData.delay || 0,
-    //         timingFunction: moveData.timingFunction || 'linear'
-    //       })
-    //     }
-    //   })
-    // })
-  },
-
-  methods: {
-    getMoveData(context, moveClass) {
-      const stylesheet = context.$options.style || {}
-      return stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][moveClass]
-    },
-  },
-}
-
-// function callPendingCbs (c) {
-//   /* istanbul ignore if */
-//   if (c.elm._moveCb) {
-//     c.elm._moveCb()
-//   }
-//   /* istanbul ignore if */
-//   if (c.elm._enterCb) {
-//     c.elm._enterCb()
-//   }
-// }
diff --git a/src/platforms/weex/runtime/components/transition.ts b/src/platforms/weex/runtime/components/transition.ts
deleted file mode 100644
index 21203def087..00000000000
--- a/src/platforms/weex/runtime/components/transition.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-// reuse same transition component logic from web
-export {
-  transitionProps,
-  extractTransitionData,
-} from 'web/runtime/components/transition'
-
-import Transition from 'web/runtime/components/transition'
-
-export default Transition
diff --git a/src/platforms/weex/runtime/directives/index.ts b/src/platforms/weex/runtime/directives/index.ts
deleted file mode 100644
index b1c6ea436a5..00000000000
--- a/src/platforms/weex/runtime/directives/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export default {}
diff --git a/src/platforms/weex/runtime/index.ts b/src/platforms/weex/runtime/index.ts
deleted file mode 100644
index a310677d2bf..00000000000
--- a/src/platforms/weex/runtime/index.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import Vue from 'core/index'
-import { patch } from 'weex/runtime/patch'
-import { mountComponent } from 'core/instance/lifecycle'
-import platformDirectives from 'weex/runtime/directives/index'
-import platformComponents from 'weex/runtime/components/index'
-
-import {
-  query,
-  mustUseProp,
-  isReservedTag,
-  isRuntimeComponent,
-  isUnknownElement,
-} from 'weex/util/element'
-
-import { Component} from 'typescript/component'
-
-// install platform specific utils
-Vue.config.mustUseProp = mustUseProp
-Vue.config.isReservedTag = isReservedTag
-Vue.config.isRuntimeComponent = isRuntimeComponent
-Vue.config.isUnknownElement = isUnknownElement
-
-// install platform runtime directives and components
-Vue.options.directives = platformDirectives
-Vue.options.components = platformComponents
-
-// install platform patch function
-Vue.prototype.__patch__ = patch
-
-// wrap mount
-Vue.prototype.$mount = function (el?: any, hydrating?: boolean): Component {
-  return mountComponent(this, el && query(el, this.$document), hydrating)
-}
-
-export default Vue
diff --git a/src/platforms/weex/runtime/modules/attrs.ts b/src/platforms/weex/runtime/modules/attrs.ts
deleted file mode 100644
index fd17bcfde9c..00000000000
--- a/src/platforms/weex/runtime/modules/attrs.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-
-import { extend } from 'shared/util'
-import type { VNodeWithData } from 'typescript/vnode'
-
-function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.attrs && !vnode.data.attrs) {
-    return
-  }
-  let key, cur, old
-  const elm = vnode.elm
-  const oldAttrs = oldVnode.data.attrs || {}
-  let attrs = vnode.data.attrs || {}
-  // clone observed objects, as the user probably wants to mutate it
-  if (attrs.__ob__) {
-    attrs = vnode.data.attrs = extend({}, attrs)
-  }
-
-  const supportBatchUpdate = typeof elm.setAttrs === 'function'
-  const batchedAttrs = {}
-  for (key in attrs) {
-    cur = attrs[key]
-    old = oldAttrs[key]
-    if (old !== cur) {
-      supportBatchUpdate ? (batchedAttrs[key] = cur) : elm.setAttr(key, cur)
-    }
-  }
-  for (key in oldAttrs) {
-    if (attrs[key] == null) {
-      supportBatchUpdate ? (batchedAttrs[key] = undefined) : elm.setAttr(key)
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setAttrs(batchedAttrs)
-  }
-}
-
-export default {
-  create: updateAttrs,
-  update: updateAttrs,
-}
diff --git a/src/platforms/weex/runtime/modules/class.ts b/src/platforms/weex/runtime/modules/class.ts
deleted file mode 100644
index d6eecdad87d..00000000000
--- a/src/platforms/weex/runtime/modules/class.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-
-import { extend, isObject } from 'shared/util'
-import type { Component } from 'typescript/component'
-import type { VNodeData, VNodeWithData } from 'typescript/vnode'
-
-function updateClass(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  const el = vnode.elm
-  const ctx = vnode.context
-
-  const data: VNodeData = vnode.data
-  const oldData: VNodeData = oldVnode.data
-  if (
-    !data.staticClass &&
-    !data.class &&
-    (!oldData || (!oldData.staticClass && !oldData.class))
-  ) {
-    return
-  }
-
-  const oldClassList = makeClassList(oldData)
-  const classList = makeClassList(data)
-
-  if (typeof el.setClassList === 'function') {
-    el.setClassList(classList)
-  } else {
-    const style = getStyle(oldClassList, classList, ctx)
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(style)
-    } else {
-      for (const key in style) {
-        el.setStyle(key, style[key])
-      }
-    }
-  }
-}
-
-function makeClassList(data: VNodeData): Array<string> {
-  const classList: any[] = []
-  // unlike web, weex vnode staticClass is an Array
-  const staticClass: any = data.staticClass
-  const dataClass = data.class
-  if (staticClass) {
-    classList.push.apply(classList, staticClass)
-  }
-  if (Array.isArray(dataClass)) {
-    classList.push.apply(classList, dataClass)
-  } else if (isObject(dataClass)) {
-    classList.push.apply(
-      classList,
-      Object.keys(dataClass).filter((className) => dataClass[className])
-    )
-  } else if (typeof dataClass === 'string') {
-    classList.push.apply(classList, dataClass.trim().split(/\s+/))
-  }
-  return classList
-}
-
-function getStyle(
-  oldClassList: Array<string>,
-  classList: Array<string>,
-  ctx: Component
-): Object {
-  // style is a weex-only injected object
-  // compiled from <style> tags in weex files
-  //@ts-expect-error
-  const stylesheet: any = ctx.$options.style || {}
-  const result = {}
-  classList.forEach((name) => {
-    const style = stylesheet[name]
-    extend(result, style)
-  })
-  oldClassList.forEach((name) => {
-    const style = stylesheet[name]
-    for (const key in style) {
-      if (!result.hasOwnProperty(key)) {
-        result[key] = ''
-      }
-    }
-  })
-  return result
-}
-
-export default {
-  create: updateClass,
-  update: updateClass,
-}
diff --git a/src/platforms/weex/runtime/modules/events.ts b/src/platforms/weex/runtime/modules/events.ts
deleted file mode 100644
index 6a3a409e9d4..00000000000
--- a/src/platforms/weex/runtime/modules/events.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-
-import { updateListeners } from 'core/vdom/helpers/update-listeners'
-import type { VNodeWithData } from 'typescript/vnode'
-
-let target: any
-
-function createOnceHandler(event, handler, capture) {
-  const _target = target // save current target element in closure
-  return function onceHandler() {
-    const res = handler.apply(null, arguments)
-    if (res !== null) {
-      remove(event, onceHandler, capture, _target)
-    }
-  }
-}
-
-function add(
-  event: string,
-  handler: Function,
-  capture: boolean,
-  passive?: boolean,
-  params?: Array<any>
-) {
-  if (capture) {
-    console.log('Weex do not support event in bubble phase.')
-    return
-  }
-  target.addEvent(event, handler, params)
-}
-
-function remove(event: string, handler: any, capture: any, _target?: any) {
-  (_target || target).removeEvent(event)
-}
-
-function updateDOMListeners(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.on && !vnode.data.on) {
-    return
-  }
-  const on = vnode.data.on || {}
-  const oldOn = oldVnode.data.on || {}
-  target = vnode.elm
-  updateListeners(on, oldOn, add, remove, createOnceHandler, vnode.context)
-  target = undefined
-}
-
-export default {
-  create: updateDOMListeners,
-  update: updateDOMListeners,
-}
diff --git a/src/platforms/weex/runtime/modules/index.ts b/src/platforms/weex/runtime/modules/index.ts
deleted file mode 100644
index bc1923b00f7..00000000000
--- a/src/platforms/weex/runtime/modules/index.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import attrs from './attrs'
-import klass from './class'
-import events from './events'
-import style from './style'
-import transition from './transition'
-
-export default [attrs, klass, events, style, transition]
diff --git a/src/platforms/weex/runtime/modules/style.ts b/src/platforms/weex/runtime/modules/style.ts
deleted file mode 100644
index 81494d54000..00000000000
--- a/src/platforms/weex/runtime/modules/style.ts
+++ /dev/null
@@ -1,84 +0,0 @@
-
-import { extend, cached, camelize } from 'shared/util'
-import type { VNodeWithData } from 'typescript/vnode'
-
-const normalize = cached(camelize)
-
-function createStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!vnode.data.staticStyle) {
-    updateStyle(oldVnode, vnode)
-    return
-  }
-  const elm = vnode.elm
-  const staticStyle = vnode.data.staticStyle
-  const supportBatchUpdate = typeof elm.setStyles === 'function'
-  const batchedStyles = {}
-  for (const name in staticStyle) {
-    if (staticStyle[name]) {
-      supportBatchUpdate
-        ? (batchedStyles[normalize(name)] = staticStyle[name])
-        : elm.setStyle(normalize(name), staticStyle[name])
-    }
-  }
-  if (supportBatchUpdate) {
-    elm.setStyles(batchedStyles)
-  }
-  updateStyle(oldVnode, vnode)
-}
-
-function updateStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
-  if (!oldVnode.data.style && !vnode.data.style) {
-    return
-  }
-  let cur, name
-  const elm = vnode.elm
-  const oldStyle: any = oldVnode.data.style || {}
-  let style: any = vnode.data.style || {}
-
-  const needClone = style.__ob__
-
-  // handle array syntax
-  if (Array.isArray(style)) {
-    style = vnode.data.style = toObject(style)
-  }
-
-  // clone the style for future updates,
-  // in case the user mutates the style object in-place.
-  if (needClone) {
-    style = vnode.data.style = extend({}, style)
-  }
-
-  const supportBatchUpdate = typeof elm.setStyles === 'function'
-  const batchedStyles = {}
-  for (name in oldStyle) {
-    if (!style[name]) {
-      supportBatchUpdate
-        ? (batchedStyles[normalize(name)] = '')
-        : elm.setStyle(normalize(name), '')
-    }
-  }
-  for (name in style) {
-    cur = style[name]
-    supportBatchUpdate
-      ? (batchedStyles[normalize(name)] = cur)
-      : elm.setStyle(normalize(name), cur)
-  }
-  if (supportBatchUpdate) {
-    elm.setStyles(batchedStyles)
-  }
-}
-
-function toObject(arr) {
-  const res = {}
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i])
-    }
-  }
-  return res
-}
-
-export default {
-  create: createStyle,
-  update: updateStyle,
-}
diff --git a/src/platforms/weex/runtime/modules/transition.ts b/src/platforms/weex/runtime/modules/transition.ts
deleted file mode 100644
index e83b73e2bf5..00000000000
--- a/src/platforms/weex/runtime/modules/transition.ts
+++ /dev/null
@@ -1,310 +0,0 @@
-import { warn } from 'core/util/debug'
-import { extend, once, noop } from 'shared/util'
-import { activeInstance } from 'core/instance/lifecycle'
-import { resolveTransition } from 'web/runtime/transition-util'
-
-export default {
-  create: enter,
-  activate: enter,
-  remove: leave,
-}
-
-function enter(_, vnode) {
-  const el = vnode.elm
-
-  // call leave callback now
-  if (el._leaveCb) {
-    el._leaveCb.cancelled = true
-    el._leaveCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (!data) {
-    return
-  }
-
-  /* istanbul ignore if */
-  if (el._enterCb) {
-    return
-  }
-
-  const {
-    enterClass,
-    enterToClass,
-    enterActiveClass,
-    appearClass,
-    appearToClass,
-    appearActiveClass,
-    beforeEnter,
-    enter,
-    afterEnter,
-    enterCancelled,
-    beforeAppear,
-    appear,
-    afterAppear,
-    appearCancelled,
-  } = data
-
-  let context = activeInstance
-  let transitionNode = activeInstance.$vnode
-  while (transitionNode && transitionNode.parent) {
-    transitionNode = transitionNode.parent
-    context = transitionNode.context
-  }
-
-  const isAppear = !context._isMounted || !vnode.isRootInsert
-
-  if (isAppear && !appear && appear !== '') {
-    return
-  }
-
-  const startClass = isAppear ? appearClass : enterClass
-  const toClass = isAppear ? appearToClass : enterToClass
-  const activeClass = isAppear ? appearActiveClass : enterActiveClass
-  const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter
-  const enterHook = isAppear
-    ? typeof appear === 'function'
-      ? appear
-      : enter
-    : enter
-  const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter
-  const enterCancelledHook = isAppear
-    ? appearCancelled || enterCancelled
-    : enterCancelled
-
-  const userWantsControl =
-    enterHook &&
-    // enterHook may be a bound method which exposes
-    // the length of original fn as _length
-    (enterHook._length || enterHook.length) > 1
-
-  const stylesheet = vnode.context.$options.style || {}
-  const startState = stylesheet[startClass]
-  const transitionProperties =
-    (stylesheet['@TRANSITION'] && stylesheet['@TRANSITION'][activeClass]) || {}
-  const endState = getEnterTargetState(
-    el,
-    stylesheet,
-    startClass,
-    toClass,
-    activeClass
-  )
-  const needAnimation = Object.keys(endState).length > 0
-
-  const cb = (el._enterCb = once(() => {
-    //@ts-expect-error
-    if (cb.cancelled) {
-      enterCancelledHook && enterCancelledHook(el)
-    } else {
-      afterEnterHook && afterEnterHook(el)
-    }
-    el._enterCb = null
-  }))
-
-  // We need to wait until the native element has been inserted, but currently
-  // there's no API to do that. So we have to wait "one frame" - not entirely
-  // sure if this is guaranteed to be enough (e.g. on slow devices?)
-  setTimeout(() => {
-    const parent = el.parentNode
-    const pendingNode = parent && parent._pending && parent._pending[vnode.key]
-    if (
-      pendingNode &&
-      pendingNode.context === vnode.context &&
-      pendingNode.tag === vnode.tag &&
-      pendingNode.elm._leaveCb
-    ) {
-      pendingNode.elm._leaveCb()
-    }
-    enterHook && enterHook(el, cb)
-
-    if (needAnimation) {
-      const animation = vnode.context.$requireWeexModule('animation')
-      animation.transition(
-        el.ref,
-        {
-          styles: endState,
-          duration: transitionProperties.duration || 0,
-          delay: transitionProperties.delay || 0,
-          timingFunction: transitionProperties.timingFunction || 'linear',
-        },
-        userWantsControl ? noop : cb
-      )
-    } else if (!userWantsControl) {
-      cb()
-    }
-  }, 16)
-
-  // start enter transition
-  beforeEnterHook && beforeEnterHook(el)
-
-  if (startState) {
-    if (typeof el.setStyles === 'function') {
-      el.setStyles(startState)
-    } else {
-      for (const key in startState) {
-        el.setStyle(key, startState[key])
-      }
-    }
-  }
-
-  if (!needAnimation && !userWantsControl) {
-    cb()
-  }
-}
-
-function leave(vnode, rm) {
-  const el = vnode.elm
-
-  // call enter callback now
-  if (el._enterCb) {
-    el._enterCb.cancelled = true
-    el._enterCb()
-  }
-
-  const data = resolveTransition(vnode.data.transition)
-  if (!data) {
-    return rm()
-  }
-
-  if (el._leaveCb) {
-    return
-  }
-
-  const {
-    leaveClass,
-    leaveToClass,
-    leaveActiveClass,
-    beforeLeave,
-    leave,
-    afterLeave,
-    leaveCancelled,
-    delayLeave,
-  } = data
-
-  const userWantsControl =
-    leave &&
-    // leave hook may be a bound method which exposes
-    // the length of original fn as _length
-    (leave._length || leave.length) > 1
-
-  const stylesheet = vnode.context.$options.style || {}
-  const startState = stylesheet[leaveClass]
-  const endState = stylesheet[leaveToClass] || stylesheet[leaveActiveClass]
-  const transitionProperties =
-    (stylesheet['@TRANSITION'] &&
-      stylesheet['@TRANSITION'][leaveActiveClass]) ||
-    {}
-
-  const cb = (el._leaveCb = once(() => {
-    if (el.parentNode && el.parentNode._pending) {
-      el.parentNode._pending[vnode.key] = null
-    }
-    //@ts-expect-error
-    if (cb.cancelled) {
-      leaveCancelled && leaveCancelled(el)
-    } else {
-      rm()
-      afterLeave && afterLeave(el)
-    }
-    el._leaveCb = null
-  }))
-
-  if (delayLeave) {
-    delayLeave(performLeave)
-  } else {
-    performLeave()
-  }
-
-  function performLeave() {
-    const animation = vnode.context.$requireWeexModule('animation')
-    // the delayed leave may have already been cancelled
-    //@ts-expect-error
-    if (cb.cancelled) {
-      return
-    }
-    // record leaving element
-    if (!vnode.data.show) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[
-        vnode.key
-      ] = vnode
-    }
-    beforeLeave && beforeLeave(el)
-
-    if (startState) {
-      animation.transition(
-        el.ref,
-        {
-          styles: startState,
-        },
-        next
-      )
-    } else {
-      next()
-    }
-
-    function next() {
-      animation.transition(
-        el.ref,
-        {
-          styles: endState,
-          duration: transitionProperties.duration || 0,
-          delay: transitionProperties.delay || 0,
-          timingFunction: transitionProperties.timingFunction || 'linear',
-        },
-        userWantsControl ? noop : cb
-      )
-    }
-
-    leave && leave(el, cb)
-    if (!endState && !userWantsControl) {
-      cb()
-    }
-  }
-}
-
-// determine the target animation style for an entering transition.
-function getEnterTargetState(
-  el,
-  stylesheet,
-  startClass,
-  endClass,
-  activeClass
-) {
-  const targetState = {}
-  const startState = stylesheet[startClass]
-  const endState = stylesheet[endClass]
-  const activeState = stylesheet[activeClass]
-  // 1. fallback to element's default styling
-  if (startState) {
-    for (const key in startState) {
-      targetState[key] = el.style[key]
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        targetState[key] == null &&
-        (!activeState || activeState[key] == null) &&
-        (!endState || endState[key] == null)
-      ) {
-        warn(
-          `transition property "${key}" is declared in enter starting class (.${startClass}), ` +
-            `but not declared anywhere in enter ending class (.${endClass}), ` +
-            `enter active cass (.${activeClass}) or the element's default styling. ` +
-            `Note in Weex, CSS properties need explicit values to be transitionable.`
-        )
-      }
-    }
-  }
-  // 2. if state is mixed in active state, extract them while excluding
-  //    transition properties
-  if (activeState) {
-    for (const key in activeState) {
-      if (key.indexOf('transition') !== 0) {
-        targetState[key] = activeState[key]
-      }
-    }
-  }
-  // 3. explicit endState has highest priority
-  if (endState) {
-    extend(targetState, endState)
-  }
-  return targetState
-}
diff --git a/src/platforms/weex/runtime/node-ops.ts b/src/platforms/weex/runtime/node-ops.ts
deleted file mode 100644
index 32b42032a33..00000000000
--- a/src/platforms/weex/runtime/node-ops.ts
+++ /dev/null
@@ -1,94 +0,0 @@
-declare let document: WeexDocument
-
-import type { WeexDocument, WeexElement } from 'typescript/weex'
-import TextNode from 'weex/runtime/text-node'
-
-export const namespaceMap = {}
-
-export function createElement(tagName: string): WeexElement {
-  return document.createElement(tagName)
-}
-
-export function createElementNS(
-  namespace: string,
-  tagName: string
-): WeexElement {
-  return document.createElement(namespace + ':' + tagName)
-}
-
-export function createTextNode(text: string) {
-  return new TextNode(text)
-}
-
-export function createComment(text: string) {
-  return document.createComment(text)
-}
-
-export function insertBefore(
-  node: WeexElement,
-  target: WeexElement,
-  before: WeexElement
-) {
-  if (target.nodeType === 3) {
-    if (node.type === 'text') {
-      node.setAttr('value', target.text)
-      target.parentNode = node
-    } else {
-      const text = createElement('text')
-      text.setAttr('value', target.text)
-      node.insertBefore(text, before)
-    }
-    return
-  }
-  node.insertBefore(target, before)
-}
-
-export function removeChild(node: WeexElement, child: WeexElement) {
-  if (child.nodeType === 3) {
-    node.setAttr('value', '')
-    return
-  }
-  node.removeChild(child)
-}
-
-export function appendChild(node: WeexElement, child: WeexElement) {
-  if (child.nodeType === 3) {
-    if (node.type === 'text') {
-      node.setAttr('value', child.text)
-      child.parentNode = node
-    } else {
-      const text = createElement('text')
-      text.setAttr('value', child.text)
-      node.appendChild(text)
-    }
-    return
-  }
-
-  node.appendChild(child)
-}
-
-export function parentNode(node: WeexElement): WeexElement | void {
-  return node.parentNode
-}
-
-export function nextSibling(node: WeexElement): WeexElement | void {
-  return node.nextSibling
-}
-
-export function tagName(node: WeexElement): string {
-  return node.type
-}
-
-export function setTextContent(node: WeexElement, text: string) {
-  if (node.parentNode) {
-    node.parentNode.setAttr('value', text)
-  }
-}
-
-export function setAttribute(node: WeexElement, key: string, val: any) {
-  node.setAttr(key, val)
-}
-
-export function setStyleScope(node: WeexElement, scopeId: string) {
-  node.setAttr('@styleScope', scopeId)
-}
diff --git a/src/platforms/weex/runtime/patch.ts b/src/platforms/weex/runtime/patch.ts
deleted file mode 100644
index a590411ec01..00000000000
--- a/src/platforms/weex/runtime/patch.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-
-import * as nodeOps from 'weex/runtime/node-ops'
-import { createPatchFunction } from 'core/vdom/patch'
-import baseModules from 'core/vdom/modules/index'
-import platformModules from 'weex/runtime/modules/index'
-
-// the directive module should be applied last, after all
-// built-in modules have been applied.
-const modules = platformModules.concat(baseModules)
-
-export const patch: Function = createPatchFunction({
-  nodeOps,
-  modules,
-  LONG_LIST_THRESHOLD: 10,
-})
diff --git a/src/platforms/weex/runtime/recycle-list/render-component-template.ts b/src/platforms/weex/runtime/recycle-list/render-component-template.ts
deleted file mode 100644
index e301e844b9e..00000000000
--- a/src/platforms/weex/runtime/recycle-list/render-component-template.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-
-import { warn } from 'core/util/debug'
-import { handleError } from 'core/util/error'
-import { RECYCLE_LIST_MARKER } from 'weex/util/index'
-import { createComponentInstanceForVnode } from 'core/vdom/create-component'
-import { resolveVirtualComponent } from './virtual-component'
-import type { MountedComponentVNode, VNodeWithData } from 'typescript/vnode'
-import VNode from 'core/vdom/vnode'
-
-export function isRecyclableComponent(vnode: VNodeWithData | VNode): boolean {
-  return vnode.data!.attrs ? RECYCLE_LIST_MARKER in vnode.data!.attrs : false
-}
-
-export function renderRecyclableComponentTemplate(
-  vnode: MountedComponentVNode | VNode
-): VNode | undefined {
-  //@ts-expect-error
-  delete vnode.data.attrs[RECYCLE_LIST_MARKER]
-  resolveVirtualComponent(vnode)
-  const vm = createComponentInstanceForVnode(vnode)
-  const render = (vm.$options as any)['@render']
-  if (render) {
-    try {
-      return render.call(vm)
-    } catch (err:any) {
-      handleError(err, vm, `@render`)
-    }
-  } else {
-    warn(
-      `@render function not defined on component used in <recycle-list>. ` +
-        `Make sure to declare \`recyclable="true"\` on the component's template.`,
-      vm
-    )
-  }
-}
diff --git a/src/platforms/weex/runtime/recycle-list/virtual-component.ts b/src/platforms/weex/runtime/recycle-list/virtual-component.ts
deleted file mode 100644
index 7523e1f7d40..00000000000
--- a/src/platforms/weex/runtime/recycle-list/virtual-component.ts
+++ /dev/null
@@ -1,142 +0,0 @@
-
-// https://github.com/Hanks10100/weex-native-directive/tree/master/component
-
-import { mergeOptions, isPlainObject, noop } from 'core/util/index'
-import Watcher from 'core/observer/watcher'
-import { initProxy } from 'core/instance/proxy'
-import { initState, getData } from 'core/instance/state'
-import { initRender } from 'core/instance/render'
-import { initEvents } from 'core/instance/events'
-import { initProvide, initInjections } from 'core/instance/inject'
-import { initLifecycle, callHook } from 'core/instance/lifecycle'
-import {
-  initInternalComponent,
-  resolveConstructorOptions,
-} from 'core/instance/init'
-import { registerComponentHook, updateComponentData } from '../../util/index'
-import type { Component } from 'typescript/component'
-import VNode from 'core/vdom/vnode'
-import type { MountedComponentVNode } from 'typescript/vnode'
-
-let uid = 0
-
-// override Vue.prototype._init
-function initVirtualComponent(options: Record<string, any> = {}) {
-  const vm: Component = this
-  const componentId = options.componentId
-
-  // virtual component uid
-  vm._uid = `virtual-component-${uid++}`
-
-  // a flag to avoid this being observed
-  vm._isVue = true
-  // merge options
-  if (options && options._isComponent) {
-    // optimize internal component instantiation
-    // since dynamic options merging is pretty slow, and none of the
-    // internal component options needs special treatment.
-    //@ts-expect-error
-    initInternalComponent(vm, options)
-  } else {
-    vm.$options = mergeOptions(
-      //@ts-expect-error
-      resolveConstructorOptions(vm.constructor),
-      options || {},
-      vm
-    )
-  }
-
-  /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
-    initProxy(vm)
-  } else {
-    vm._renderProxy = vm
-  }
-
-  vm._self = vm
-  initLifecycle(vm)
-  initEvents(vm)
-  initRender(vm)
-  callHook(vm, 'beforeCreate')
-  initInjections(vm) // resolve injections before data/props
-  initState(vm)
-  initProvide(vm) // resolve provide after data/props
-  callHook(vm, 'created')
-
-  // send initial data to native
-  const data = vm.$options.data
-  const params = typeof data === 'function' ? getData(data, vm) : data || {}
-  if (isPlainObject(params)) {
-    updateComponentData(componentId, params)
-  }
-
-  registerComponentHook(componentId, 'lifecycle', 'attach', () => {
-    callHook(vm, 'beforeMount')
-
-    const updateComponent = () => {
-      vm._update(vm._vnode!, false)
-    }
-    new Watcher(vm, updateComponent, noop, null, true)
-
-    vm._isMounted = true
-    callHook(vm, 'mounted')
-  })
-
-  registerComponentHook(componentId, 'lifecycle', 'detach', () => {
-    vm.$destroy()
-  })
-}
-
-// override Vue.prototype._update
-function updateVirtualComponent(vnode?: VNode) {
-  const vm: Component = this
-  const componentId = vm.$options.componentId
-  if (vm._isMounted) {
-    callHook(vm, 'beforeUpdate')
-  }
-  vm._vnode = vnode
-  if (vm._isMounted && componentId) {
-    // TODO: data should be filtered and without bindings
-    const data = Object.assign({}, vm._data)
-    updateComponentData(componentId, data, () => {
-      callHook(vm, 'updated')
-    })
-  }
-}
-
-// listening on native callback
-export function resolveVirtualComponent(
-  vnode: MountedComponentVNode | VNode
-): void {
-  const BaseCtor = vnode.componentOptions!.Ctor
-  const VirtualComponent = BaseCtor.extend({})
-  const cid = VirtualComponent.cid
-  VirtualComponent.prototype._init = initVirtualComponent
-  VirtualComponent.prototype._update = updateVirtualComponent
-
-  vnode.componentOptions!.Ctor = BaseCtor.extend({
-    beforeCreate() {
-      // const vm: Component = this
-
-      // TODO: listen on all events and dispatch them to the
-      // corresponding virtual components according to the componentId.
-      // vm._virtualComponents = {}
-      const createVirtualComponent = (componentId, propsData) => {
-        // create virtual component
-        // const subVm =
-        new VirtualComponent({
-          componentId,
-          propsData,
-        })
-        // if (vm._virtualComponents) {
-        //   vm._virtualComponents[componentId] = subVm
-        // }
-      }
-
-      registerComponentHook(cid, 'lifecycle', 'create', createVirtualComponent)
-    },
-    beforeDestroy() {
-      delete this._virtualComponents
-    },
-  })
-}
diff --git a/src/platforms/weex/runtime/text-node.ts b/src/platforms/weex/runtime/text-node.ts
deleted file mode 100644
index 18143b3110e..00000000000
--- a/src/platforms/weex/runtime/text-node.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-let latestNodeId = 1
-
-export default function TextNode(text) {
-  this.instanceId = ''
-  this.nodeId = latestNodeId++
-  this.parentNode = null
-  this.nodeType = 3
-  this.text = text
-}
diff --git a/src/platforms/weex/types.d.ts b/src/platforms/weex/types.d.ts
deleted file mode 100644
index 0871a9c18f2..00000000000
--- a/src/platforms/weex/types.d.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-import "core/config";
-
-declare module "core/config" {
-  interface Config {
-    isRuntimeComponent: (key: string) => true | undefined;
-  }
-}
diff --git a/src/platforms/weex/util/element.ts b/src/platforms/weex/util/element.ts
deleted file mode 100644
index 44fdfe4db6e..00000000000
--- a/src/platforms/weex/util/element.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-// These util functions are split into its own file because Rollup cannot drop
-// makeMap() due to potential side effects, so these variables end up
-// bloating the web builds.
-
-import { makeMap, noop } from "shared/util";
-
-export const isReservedTag = makeMap(
-  "template,script,style,element,content,slot,link,meta,svg,view," +
-    "a,div,img,image,text,span,input,switch,textarea,spinner,select," +
-    "slider,slider-neighbor,indicator,canvas," +
-    "list,cell,header,loading,loading-indicator,refresh,scrollable,scroller," +
-    "video,web,embed,tabbar,tabheader,datepicker,timepicker,marquee,countdown",
-  true
-);
-
-// Elements that you can, intentionally, leave open (and which close themselves)
-// more flexible than web
-export const canBeLeftOpenTag = makeMap(
-  "web,spinner,switch,video,textarea,canvas," + "indicator,marquee,countdown",
-  true
-);
-
-export const isRuntimeComponent = makeMap(
-  "richtext,transition,transition-group",
-  true
-);
-
-export const isUnaryTag = makeMap("embed,img,image,input,link,meta", true);
-
-export function mustUseProp(): boolean {
-  return false;
-}
-
-export function getTagNamespace() {
-  return undefined;
-}
-
-export function isUnknownElement(): boolean {
-  return false;
-}
-
-export function query(el: string | Element, document: any) {
-  // document is injected by weex factory wrapper
-  const placeholder = document.createComment("root");
-  placeholder.hasAttribute = placeholder.removeAttribute = noop; // hack for patch
-  document.documentElement.appendChild(placeholder);
-  return placeholder;
-}
diff --git a/src/platforms/weex/util/index.ts b/src/platforms/weex/util/index.ts
deleted file mode 100644
index ddbd695b568..00000000000
--- a/src/platforms/weex/util/index.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-declare let document: WeexDocument
-
-import { warn } from 'core/util/index'
-import type { WeexDocument } from 'typescript/weex'
-
-export const RECYCLE_LIST_MARKER = '@inRecycleList'
-
-// Register the component hook to weex native render engine.
-// The hook will be triggered by native, not javascript.
-export function registerComponentHook(
-  componentId: string,
-  type: string, // hook type, could be "lifecycle" or "instance"
-  hook: string, // hook name
-  fn: Function
-) {
-  if (!document || !document.taskCenter) {
-    warn(`Can't find available "document" or "taskCenter".`)
-    return
-  }
-  if (typeof document.taskCenter.registerHook === 'function') {
-    return document.taskCenter.registerHook(componentId, type, hook, fn)
-  }
-  warn(`Failed to register component hook "${type}@${hook}#${componentId}".`)
-}
-
-// Updates the state of the component to weex native render engine.
-export function updateComponentData(
-  componentId: string,
-  newData: Object | void,
-  callback?: Function
-) {
-  if (!document || !document.taskCenter) {
-    warn(`Can't find available "document" or "taskCenter".`)
-    return
-  }
-  if (typeof document.taskCenter.updateData === 'function') {
-    return document.taskCenter.updateData(componentId, newData, callback)
-  }
-  warn(`Failed to update component data (${componentId}).`)
-}
diff --git a/src/platforms/weex/util/parser.ts b/src/platforms/weex/util/parser.ts
deleted file mode 100644
index 10b25946c78..00000000000
--- a/src/platforms/weex/util/parser.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-// import { warn } from 'core/util/index'
-
-import acorn from 'acorn'
-import walk from "acorn-walk";
-const escodegen = require("escodegen");
-
-
-export function nodeToBinding(node: any): any {
-  switch (node.type) {
-    case "Literal":
-      return node.value;
-    case "Identifier":
-    case "UnaryExpression":
-    case "BinaryExpression":
-    case "LogicalExpression":
-    case "ConditionalExpression":
-    case "MemberExpression":
-      return { "@binding": escodegen.generate(node) };
-    case "ArrayExpression":
-      return node.elements.map((_) => nodeToBinding(_));
-    case "ObjectExpression": {
-      const object = {};
-      node.properties.forEach((prop) => {
-        if (!prop.key || prop.key.type !== "Identifier") {
-          return;
-        }
-        const key = escodegen.generate(prop.key);
-        const value = nodeToBinding(prop.value);
-        if (key && value) {
-          object[key] = value;
-        }
-      });
-      return object;
-    }
-    default: {
-      // warn(`Not support ${node.type}: "${escodegen.generate(node)}"`)
-      return "";
-    }
-  }
-}
-
-export function generateBinding(exp?: string): any {
-  if (exp && typeof exp === "string") {
-    let ast: acorn.Node| null = null;
-    try {
-      ast = acorn.parse(`(${exp})`, {ecmaVersion: 5});
-    } catch (e: any) {
-      // warn(`Failed to parse the expression: "${exp}"`)
-      return "";
-    }
-
-    let output = "";
-    walk.simple(ast, {
-      Expression(node) {
-        output = nodeToBinding(node);
-      },
-    });
-    return output;
-  }
-}
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index 8b097694523..03baf752020 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -1,5 +1,5 @@
-;(global as any).__WEEX__ = false
 ;(global as any).__SSR_TEST__ = false
+
 process.env.NEW_SLOT_SYNTAX = 'true'
 
 import './helpers/shim-done'
diff --git a/test/weex/cases/cases.spec.ts b/test/weex/cases/cases.spec.ts
deleted file mode 100644
index d4838eb3e2b..00000000000
--- a/test/weex/cases/cases.spec.ts
+++ /dev/null
@@ -1,238 +0,0 @@
-import {
-  readFile,
-  readObject,
-  compileVue,
-  compileWithDeps,
-  createInstance,
-  addTaskHook,
-  resetTaskHook,
-  getRoot,
-  getEvents,
-  fireEvent
-} from '../helpers'
-
-// Create one-off render test case
-function createRenderTestCase (name) {
-  const source = readFile(`${name}.vue`)
-  const target = readObject(`${name}.vdom.js`)
-  return done => {
-    compileVue(source).then(code => {
-      const id = String(Date.now() * Math.random())
-      const instance = createInstance(id, code)
-      setTimeout(() => {
-        expect(getRoot(instance)).toEqual(target)
-        instance.$destroy()
-        done()
-      }, 50)
-    }).catch(done.fail)
-  }
-}
-
-// Create event test case, will trigger the first bind event
-function createEventTestCase (name) {
-  const source = readFile(`${name}.vue`)
-  const before = readObject(`${name}.before.vdom.js`)
-  const after = readObject(`${name}.after.vdom.js`)
-  return done => {
-    compileVue(source).then(code => {
-      const id = String(Date.now() * Math.random())
-      const instance = createInstance(id, code)
-      setTimeout(() => {
-        expect(getRoot(instance)).toEqual(before)
-        const event = getEvents(instance)[0]
-        fireEvent(instance, event.ref, event.type, {})
-        setTimeout(() => {
-          expect(getRoot(instance)).toEqual(after)
-          instance.$destroy()
-          done()
-        }, 50)
-      }, 50)
-    }).catch(done.fail)
-  }
-}
-
-describe('Usage', () => {
-  describe('render', () => {
-    it('sample', createRenderTestCase('render/sample'))
-    it('class', createRenderTestCase('render/class'))
-  })
-
-  describe('event', () => {
-    it('click', createEventTestCase('event/click'))
-  })
-
-  describe('recycle-list', () => {
-    it('text node', createRenderTestCase('recycle-list/text-node'))
-    it('attributes', createRenderTestCase('recycle-list/attrs'))
-    // it('class name', createRenderTestCase('recycle-list/classname'))
-    it('inline style', createRenderTestCase('recycle-list/inline-style'))
-    it('v-if', createRenderTestCase('recycle-list/v-if'))
-    it('v-else', createRenderTestCase('recycle-list/v-else'))
-    it('v-else-if', createRenderTestCase('recycle-list/v-else-if'))
-    it('v-for', createRenderTestCase('recycle-list/v-for'))
-    it('v-for-iterator', createRenderTestCase('recycle-list/v-for-iterator'))
-    it('v-on', createRenderTestCase('recycle-list/v-on'))
-    it('v-on-inline', createRenderTestCase('recycle-list/v-on-inline'))
-    it('v-once', createRenderTestCase('recycle-list/v-once'))
-
-    it('stateless component', done => {
-      compileWithDeps('recycle-list/components/stateless.vue', [{
-        name: 'banner',
-        path: 'recycle-list/components/banner.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateless.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    it('stateless component with props', done => {
-      compileWithDeps('recycle-list/components/stateless-with-props.vue', [{
-        name: 'poster',
-        path: 'recycle-list/components/poster.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateless-with-props.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    it('multi stateless components', done => {
-      compileWithDeps('recycle-list/components/stateless-multi-components.vue', [{
-        name: 'banner',
-        path: 'recycle-list/components/banner.vue'
-      }, {
-        name: 'poster',
-        path: 'recycle-list/components/poster.vue'
-      }, {
-        name: 'footer',
-        path: 'recycle-list/components/footer.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateless-multi-components.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    it('stateful component', done => {
-      const tasks: any[] = []
-      addTaskHook((_, task) => tasks.push(task))
-      compileWithDeps('recycle-list/components/stateful.vue', [{
-        name: 'counter',
-        path: 'recycle-list/components/counter.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        // expect(tasks.length).toEqual(3)
-        setTimeout(() => {
-          // check the render results
-          const target = readObject('recycle-list/components/stateful.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          tasks.length = 0
-
-          // // trigger component hooks
-          // instance.$triggerHook(
-          //   2, // cid of the virtual component template
-          //   'create', // lifecycle hook name
-
-          //   // arguments for the callback
-          //   [
-          //     'x-1', // componentId of the virtual component
-          //     { start: 3 } // propsData of the virtual component
-          //   ]
-          // )
-          // instance.$triggerHook(2, 'create', ['x-2', { start: 11 }])
-
-          // // the state (_data) of the virtual component should be sent to native
-          // expect(tasks.length).toEqual(2)
-          // expect(tasks[0].method).toEqual('updateComponentData')
-          // expect(tasks[0].args).toEqual(['x-1', { count: 6 }, ''])
-          // expect(tasks[1].method).toEqual('updateComponentData')
-          // expect(tasks[1].args).toEqual(['x-2', { count: 22 }, ''])
-
-          // instance.$triggerHook('x-1', 'attach')
-          // instance.$triggerHook('x-2', 'attach')
-          // tasks.length = 0
-
-          // // simulate a click event
-          // // the event will be caught by the virtual component template and
-          // // should be dispatched to virtual component according to the componentId
-          // const event = getEvents(instance)[0]
-          // fireEvent(instance, event.ref, 'click', { componentId: 'x-1' })
-          setTimeout(() => {
-            // expect(tasks.length).toEqual(1)
-            // expect(tasks[0].method).toEqual('updateComponentData')
-            // expect(tasks[0].args).toEqual([{ count: 7 }])
-            instance.$destroy()
-            resetTaskHook()
-            done()
-          })
-        }, 50)
-      }).catch(done.fail)
-    })
-
-    // it('component lifecycle', done => {
-    //   global.__lifecycles = []
-    //   compileWithDeps('recycle-list/components/stateful-lifecycle.vue', [{
-    //     name: 'lifecycle',
-    //     path: 'recycle-list/components/lifecycle.vue'
-    //   }]).then(code => {
-    //     const id = String(Date.now() * Math.random())
-    //     const instance = createInstance(id, code)
-    //     setTimeout(() => {
-    //       const target = readObject('recycle-list/components/stateful-lifecycle.vdom.js')
-    //       expect(getRoot(instance)).toEqual(target)
-
-    //       instance.$triggerHook(2, 'create', ['y-1'])
-    //       instance.$triggerHook('y-1', 'attach')
-    //       instance.$triggerHook('y-1', 'detach')
-    //       expect(global.__lifecycles).toEqual([
-    //         'beforeCreate undefined',
-    //         'created 0',
-    //         'beforeMount 1',
-    //         'mounted 1',
-    //         'beforeUpdate 2',
-    //         'updated 2',
-    //         'beforeDestroy 2',
-    //         'destroyed 2'
-    //       ])
-
-    //       delete global.__lifecycles
-    //       instance.$destroy()
-    //       done()
-    //     }, 50)
-    //   }).catch(done.fail)
-    // })
-
-    it('stateful component with v-model', done => {
-      compileWithDeps('recycle-list/components/stateful-v-model.vue', [{
-        name: 'editor',
-        path: 'recycle-list/components/editor.vue'
-      }]).then(code => {
-        const id = String(Date.now() * Math.random())
-        const instance = createInstance(id, code)
-        setTimeout(() => {
-          const target = readObject('recycle-list/components/stateful-v-model.vdom.js')
-          expect(getRoot(instance)).toEqual(target)
-          instance.$destroy()
-          done()
-        }, 50)
-      }).catch(done.fail)
-    })
-  })
-})
diff --git a/test/weex/cases/event/click.after.vdom.ts b/test/weex/cases/event/click.after.vdom.ts
deleted file mode 100644
index eab1a36e7a3..00000000000
--- a/test/weex/cases/event/click.after.vdom.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-({
-  type: 'div',
-  event: ['click'],
-  children: [{
-    type: 'text',
-    attr: {
-      value: '43'
-    }
-  }]
-})
diff --git a/test/weex/cases/event/click.before.vdom.ts b/test/weex/cases/event/click.before.vdom.ts
deleted file mode 100644
index de278b3a100..00000000000
--- a/test/weex/cases/event/click.before.vdom.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-({
-  type: 'div',
-  event: ['click'],
-  children: [{
-    type: 'text',
-    attr: {
-      value: '42'
-    }
-  }]
-})
diff --git a/test/weex/cases/event/click.vue b/test/weex/cases/event/click.vue
deleted file mode 100644
index 508782c59e7..00000000000
--- a/test/weex/cases/event/click.vue
+++ /dev/null
@@ -1,20 +0,0 @@
-<template>
-  <div @click="inc">
-    <text>{{count}}</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        count: 42
-      }
-    },
-    methods: {
-      inc () {
-        this.count++
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/attrs.vdom.ts b/test/weex/cases/recycle-list/attrs.vdom.ts
deleted file mode 100644
index ccce367fc34..00000000000
--- a/test/weex/cases/recycle-list/attrs.vdom.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', count: 1, source: 'http://whatever.com/x.png' },
-      { type: 'A', count: 2, source: 'http://whatever.com/y.png' },
-      { type: 'A', count: 3, source: 'http://whatever.com/z.png' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        resize: 'cover',
-        src: {
-          '@binding': 'item.source'
-        }
-      }
-    }, {
-      type: 'text',
-      attr: {
-        lines: '3',
-        count: {
-          '@binding': 'item.count'
-        }
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/attrs.vue b/test/weex/cases/recycle-list/attrs.vue
deleted file mode 100644
index 1e2d0318af6..00000000000
--- a/test/weex/cases/recycle-list/attrs.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image resize="cover" :src="item.source">
-      <text lines="3" v-bind:count="item.count"></text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', count: 1, source: 'http://whatever.com/x.png' },
-          { type: 'A', count: 2, source: 'http://whatever.com/y.png' },
-          { type: 'A', count: 3, source: 'http://whatever.com/z.png' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/classname.vdom.ts b/test/weex/cases/recycle-list/classname.vdom.ts
deleted file mode 100644
index e9280e0e1bf..00000000000
--- a/test/weex/cases/recycle-list/classname.vdom.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', color: 'red' },
-      { type: 'A', color: 'blue' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    style: {
-      backgroundColor: '#FF6600'
-    },
-    children: [{
-      type: 'text',
-      attr: {
-        // not supported yet
-        // classList: ['text', { '@binding': 'item.color' }],
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/classname.vue b/test/weex/cases/recycle-list/classname.vue
deleted file mode 100644
index beca441fa39..00000000000
--- a/test/weex/cases/recycle-list/classname.vue
+++ /dev/null
@@ -1,37 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A" class="cell">
-      <text :class="['text', item.color]">content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<style scoped>
-  .cell {
-    background-color: #FF6600;
-  }
-  .text {
-    font-size: 100px;
-    text-align: center;
-  }
-  .red {
-    color: #FF0000;
-  }
-  .blue {
-    color: #0000FF;
-  }
-</style>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', color: 'red' },
-          { type: 'A', color: 'blue' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/components/banner.vue b/test/weex/cases/recycle-list/components/banner.vue
deleted file mode 100644
index a6c2f75c818..00000000000
--- a/test/weex/cases/recycle-list/components/banner.vue
+++ /dev/null
@@ -1,19 +0,0 @@
-<template recyclable="true">
-  <div class="banner">
-    <text class="title">BANNER</text>
-  </div>
-</template>
-
-<style scoped>
-  .banner {
-    height: 120px;
-    justify-content: center;
-    align-items: center;
-    background-color: rgb(162, 217, 192);
-  }
-  .title {
-    font-weight: bold;
-    color: #41B883;
-    font-size: 60px;
-  }
-</style>
diff --git a/test/weex/cases/recycle-list/components/counter.vue b/test/weex/cases/recycle-list/components/counter.vue
deleted file mode 100644
index 79b8189b030..00000000000
--- a/test/weex/cases/recycle-list/components/counter.vue
+++ /dev/null
@@ -1,36 +0,0 @@
-<template recyclable="true">
-  <div>
-    <text class="output">{{count}}</text>
-    <text class="button" @click="inc">+</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    props: ['start'],
-    data () {
-      return {
-        count: parseInt(this.start, 10) * 2 || 42
-      }
-    },
-    methods: {
-      inc () {
-        this.count++
-      }
-    }
-  }
-</script>
-
-<style scoped>
-  .output {
-    font-size: 150px;
-    text-align: center;
-  }
-  .button {
-    font-size: 100px;
-    text-align: center;
-    border-width: 2px;
-    border-color: #DDD;
-    background-color: #F5F5F5;
-  }
-</style>
diff --git a/test/weex/cases/recycle-list/components/editor.vue b/test/weex/cases/recycle-list/components/editor.vue
deleted file mode 100644
index 9ab63e7b3c4..00000000000
--- a/test/weex/cases/recycle-list/components/editor.vue
+++ /dev/null
@@ -1,31 +0,0 @@
-<template recyclable="true">
-  <div>
-    <text class="output">{{output}}</text>
-    <input class="input" type="text" v-model="output" />
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    props: ['message'],
-    data () {
-      return {
-        output: this.message || ''
-      }
-    }
-  }
-</script>
-
-<style scoped>
-  .output {
-    height: 80px;
-    font-size: 60px;
-    color: #41B883;
-  }
-  .input {
-    font-size: 50px;
-    color: #666666;
-    border-width: 2px;
-    border-color: #41B883;
-  }
-</style>
diff --git a/test/weex/cases/recycle-list/components/footer.vue b/test/weex/cases/recycle-list/components/footer.vue
deleted file mode 100644
index b3fe0c8b038..00000000000
--- a/test/weex/cases/recycle-list/components/footer.vue
+++ /dev/null
@@ -1,18 +0,0 @@
-<template recyclable="true">
-  <div class="footer">
-    <text class="copyright">All rights reserved.</text>
-  </div>
-</template>
-
-<style scoped>
-  .footer {
-    height: 80px;
-    justify-content: center;
-    background-color: #EEEEEE;
-  }
-  .copyright {
-    color: #AAAAAA;
-    font-size: 32px;
-    text-align: center;
-  }
-</style>
diff --git a/test/weex/cases/recycle-list/components/lifecycle.vue b/test/weex/cases/recycle-list/components/lifecycle.vue
deleted file mode 100644
index 03ee65ada5c..00000000000
--- a/test/weex/cases/recycle-list/components/lifecycle.vue
+++ /dev/null
@@ -1,39 +0,0 @@
-<template recyclable="true">
-  <div>
-    <text>{{number}}</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return { number: 0 }
-    },
-    beforeCreate () {
-      try { __lifecycles.push('beforeCreate ' + this.number) } catch (e) {}
-    },
-    created () {
-      try { __lifecycles.push('created ' + this.number) } catch (e) {}
-      this.number++
-    },
-    beforeMount () {
-      try { __lifecycles.push('beforeMount ' + this.number) } catch (e) {}
-    },
-    mounted () {
-      try { __lifecycles.push('mounted ' + this.number) } catch (e) {}
-      this.number++
-    },
-    beforeUpdate () {
-      try { __lifecycles.push('beforeUpdate ' + this.number) } catch (e) {}
-    },
-    updated () {
-      try { __lifecycles.push('updated ' + this.number) } catch (e) {}
-    },
-    beforeDestroy () {
-      try { __lifecycles.push('beforeDestroy ' + this.number) } catch (e) {}
-    },
-    destroyed () {
-      try { __lifecycles.push('destroyed ' + this.number) } catch (e) {}
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/components/poster.vue b/test/weex/cases/recycle-list/components/poster.vue
deleted file mode 100644
index 61571854ee7..00000000000
--- a/test/weex/cases/recycle-list/components/poster.vue
+++ /dev/null
@@ -1,33 +0,0 @@
-<template recyclable="true">
-  <div>
-    <image class="image" :src="imageUrl"></image>
-    <text class="title">{{title}}</text>
-  </div>
-</template>
-
-<script>
-  module.exports = {
-    props: {
-      imageUrl: {
-        type: String,
-        default: 'https://gw.alicdn.com/tfs/TB1KF_ybRTH8KJjy0FiXXcRsXXa-890-1186.png'
-      },
-      title: {
-        type: String,
-        default: 'I WANT YOU!'
-      }
-    }
-  }
-</script>
-
-<style scoped>
-  .image {
-    width: 750px;
-    height: 1000px;
-  }
-  .title {
-    font-size: 80px;
-    text-align: center;
-    color: #E95659;
-  }
-</style>
diff --git a/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.ts b/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.ts
deleted file mode 100644
index 45268ffefad..00000000000
--- a/test/weex/cases/recycle-list/components/stateful-lifecycle.vdom.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'X' },
-      { type: 'X' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'X' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      children: [{
-        type: 'text',
-        attr: {
-          value: { '@binding': 'number' }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/components/stateful-lifecycle.vue b/test/weex/cases/recycle-list/components/stateful-lifecycle.vue
deleted file mode 100644
index 97673b7bb93..00000000000
--- a/test/weex/cases/recycle-list/components/stateful-lifecycle.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="X">
-      <lifecycle></lifecycle>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./lifecycle.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'X' },
-          { type: 'X' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/components/stateful-v-model.vdom.ts b/test/weex/cases/recycle-list/components/stateful-v-model.vdom.ts
deleted file mode 100644
index f2d0d96cdc4..00000000000
--- a/test/weex/cases/recycle-list/components/stateful-v-model.vdom.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          message: 'No binding'
-        }
-      },
-      children: [{
-        type: 'text',
-        classList: ['output'],
-        attr: {
-          value: { '@binding': 'output' }
-        }
-      }, {
-        type: 'input',
-        event: ['input'],
-        classList: ['input'],
-        attr: {
-          type: 'text',
-          value: 'No binding'
-        }
-      }]
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/components/stateful-v-model.vue b/test/weex/cases/recycle-list/components/stateful-v-model.vue
deleted file mode 100644
index 3b7cc61a1f0..00000000000
--- a/test/weex/cases/recycle-list/components/stateful-v-model.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <editor message="No binding"></editor>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./editor.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/components/stateful.vdom.ts b/test/weex/cases/recycle-list/components/stateful.vdom.ts
deleted file mode 100644
index 6a2bddc795a..00000000000
--- a/test/weex/cases/recycle-list/components/stateful.vdom.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', number: 24 },
-      { type: 'A', number: 42 }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          start: { '@binding': 'item.number' }
-        }
-      },
-      children: [{
-        type: 'text',
-        classList: ['output'],
-        attr: {
-          value: { '@binding': 'count' } // need confirm
-        }
-      }, {
-        type: 'text',
-        event: ['click'],
-        classList: ['button'],
-        attr: { value: '+' }
-      }]
-    }, {
-      type: 'text',
-      attr: { value: 'other' }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/components/stateful.vue b/test/weex/cases/recycle-list/components/stateful.vue
deleted file mode 100644
index 797f3f5681a..00000000000
--- a/test/weex/cases/recycle-list/components/stateful.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <counter :start="item.number"></counter>
-      <text>other</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./counter.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', number: 24 },
-          { type: 'A', number: 42 }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.ts b/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.ts
deleted file mode 100644
index 2e4b4d9487a..00000000000
--- a/test/weex/cases/recycle-list/components/stateless-multi-components.vdom.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'B', poster: 'yy', title: 'y' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['banner'],
-      children: [{
-        type: 'text',
-        classList: ['title'],
-        attr: { value: 'BANNER' }
-      }]
-    }, {
-      type: 'text',
-      attr: { value: '----' }
-    }, {
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['footer'],
-      children: [{
-        type: 'text',
-        classList: ['copyright'],
-        attr: { value: 'All rights reserved.' }
-      }]
-    }]
-  }, {
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'B' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['banner'],
-      children: [{
-        type: 'text',
-        classList: ['title'],
-        attr: { value: 'BANNER' }
-      }]
-    }, {
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          imageUrl: { '@binding': 'item.poster' },
-          title: { '@binding': 'item.title' }
-        }
-      },
-      children: [{
-        type: 'image',
-        classList: ['image'],
-        attr: {
-          src: { '@binding': 'imageUrl' }
-        }
-      }, {
-        type: 'text',
-        classList: ['title'],
-        attr: {
-          value: { '@binding': 'title' }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/components/stateless-multi-components.vue b/test/weex/cases/recycle-list/components/stateless-multi-components.vue
deleted file mode 100644
index 9a6d6bf694e..00000000000
--- a/test/weex/cases/recycle-list/components/stateless-multi-components.vue
+++ /dev/null
@@ -1,30 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <banner></banner>
-      <text>----</text>
-      <footer></footer>
-    </cell-slot>
-    <cell-slot case="B">
-      <banner></banner>
-      <poster :image-url="item.poster" :title="item.title"></poster>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./banner.vue')
-  // require('./footer.vue')
-  // require('./poster.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'B', poster: 'yy', title: 'y' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/components/stateless-with-props.vdom.ts b/test/weex/cases/recycle-list/components/stateless-with-props.vdom.ts
deleted file mode 100644
index 3fc18dc0cf0..00000000000
--- a/test/weex/cases/recycle-list/components/stateless-with-props.vdom.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', poster: 'xx', title: 'x' },
-      { type: 'A', poster: 'yy', title: 'y' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {
-          imageUrl: { '@binding': 'item.poster' },
-          title: { '@binding': 'item.title' }
-        }
-      },
-      children: [{
-        type: 'image',
-        classList: ['image'],
-        attr: {
-          src: { '@binding': 'imageUrl' }
-        }
-      }, {
-        type: 'text',
-        classList: ['title'],
-        attr: {
-          value: { '@binding': 'title' }
-        }
-      }]
-    }, {
-      type: 'text',
-      attr: {
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/components/stateless-with-props.vue b/test/weex/cases/recycle-list/components/stateless-with-props.vue
deleted file mode 100644
index e1d3d8ccb21..00000000000
--- a/test/weex/cases/recycle-list/components/stateless-with-props.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <poster :image-url="item.poster" :title="item.title"></poster>
-      <text>content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./poster.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', poster: 'xx', title: 'x' },
-          { type: 'A', poster: 'yy', title: 'y' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/components/stateless.vdom.ts b/test/weex/cases/recycle-list/components/stateless.vdom.ts
deleted file mode 100644
index 3ae12d03b28..00000000000
--- a/test/weex/cases/recycle-list/components/stateless.vdom.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '@isComponentRoot': true,
-        '@componentProps': {}
-      },
-      classList: ['banner'],
-      children: [{
-        type: 'text',
-        classList: ['title'],
-        attr: {
-          value: 'BANNER'
-        }
-      }]
-    }, {
-      type: 'text',
-      attr: {
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/components/stateless.vue b/test/weex/cases/recycle-list/components/stateless.vue
deleted file mode 100644
index 3ad942de64f..00000000000
--- a/test/weex/cases/recycle-list/components/stateless.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <banner></banner>
-      <text>content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  // require('./banner.vue')
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
diff --git a/test/weex/cases/recycle-list/inline-style.vdom.ts b/test/weex/cases/recycle-list/inline-style.vdom.ts
deleted file mode 100644
index c29bcf977fe..00000000000
--- a/test/weex/cases/recycle-list/inline-style.vdom.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', color: '#606060' },
-      { type: 'A', color: '#E5E5E5' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    style: {
-      backgroundColor: '#FF6600'
-    },
-    children: [{
-      type: 'text',
-      style: {
-        fontSize: '100px',
-        color: { '@binding': 'item.color' }
-      },
-      attr: {
-        value: 'content'
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/inline-style.vue b/test/weex/cases/recycle-list/inline-style.vue
deleted file mode 100644
index af9da5b0832..00000000000
--- a/test/weex/cases/recycle-list/inline-style.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A" style="background-color:#FF6600">
-      <text :style="{ fontSize: '100px', color: item.color }">content</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', color: '#606060' },
-          { type: 'A', color: '#E5E5E5' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/text-node.vdom.ts b/test/weex/cases/recycle-list/text-node.vdom.ts
deleted file mode 100644
index 6ab5d1e6bbc..00000000000
--- a/test/weex/cases/recycle-list/text-node.vdom.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A', dynamic: 'decimal', two: '2', four: '4' },
-      { type: 'A', dynamic: 'binary', two: '10', four: '100' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'text',
-      attr: {
-        value: 'static'
-      }
-    }, {
-      type: 'text',
-      attr: {
-        value: { '@binding': 'item.dynamic' }
-      }
-    }, {
-      type: 'text',
-      attr: {
-        value: [
-          'one ',
-          { '@binding': 'item.two' },
-          ' three ',
-          { '@binding': 'item.four' },
-          ' five'
-        ]
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/text-node.vue b/test/weex/cases/recycle-list/text-node.vue
deleted file mode 100644
index 56b21cad1c6..00000000000
--- a/test/weex/cases/recycle-list/text-node.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <text>static</text>
-      <text>{{item.dynamic}}</text>
-      <text>one {{item.two}} three {{ item.four }} five</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A', dynamic: 'decimal', two: '2', four: '4' },
-          { type: 'A', dynamic: 'binary', two: '10', four: '100' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-else-if.vdom.ts b/test/weex/cases/recycle-list/v-else-if.vdom.ts
deleted file mode 100644
index 1181e267fb8..00000000000
--- a/test/weex/cases/recycle-list/v-else-if.vdom.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        '[[match]]': 'item.sourceA',
-        src: { '@binding': 'item.sourceA' }
-      }
-    }, {
-      type: 'image',
-      attr: {
-        '[[match]]': '!(item.sourceA) && (item.sourceB)',
-        src: { '@binding': 'item.sourceB' }
-      }
-    }, {
-      type: 'image',
-      attr: {
-        '[[match]]': '!(item.sourceA || item.sourceB)',
-        src: { '@binding': 'item.placeholder' }
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-else-if.vue b/test/weex/cases/recycle-list/v-else-if.vue
deleted file mode 100644
index 6078450c334..00000000000
--- a/test/weex/cases/recycle-list/v-else-if.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image v-if="item.sourceA" :src="item.sourceA"></image>
-      <image v-else-if="item.sourceB" :src="item.sourceB"></image>
-      <image v-else :src="item.placeholder"></image>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-else.vdom.ts b/test/weex/cases/recycle-list/v-else.vdom.ts
deleted file mode 100644
index dc37e1d3cd8..00000000000
--- a/test/weex/cases/recycle-list/v-else.vdom.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        '[[match]]': 'item.source',
-        src: { '@binding': 'item.source' }
-      }
-    }, {
-      type: 'image',
-      attr: {
-        '[[match]]': '!(item.source)',
-        src: { '@binding': 'item.placeholder' }
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-else.vue b/test/weex/cases/recycle-list/v-else.vue
deleted file mode 100644
index 48e85fd8889..00000000000
--- a/test/weex/cases/recycle-list/v-else.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image v-if="item.source" :src="item.source"></image>
-      <image v-else v-bind:src="item.placeholder"></image>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-for-iterator.vdom.ts b/test/weex/cases/recycle-list/v-for-iterator.vdom.ts
deleted file mode 100644
index 5507403b8c9..00000000000
--- a/test/weex/cases/recycle-list/v-for-iterator.vdom.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '[[repeat]]': {
-          '@expression': 'item.list',
-          '@index': 'index',
-          '@alias': 'object'
-        }
-      },
-      children: [{
-        type: 'text',
-        attr: {
-          value: {
-            '@binding': 'object.name'
-          }
-        }
-      }, {
-        type: 'text',
-        attr: {
-          '[[repeat]]': {
-            '@expression': 'object',
-            '@alias': 'v',
-            '@key': 'k',
-            '@index': 'i'
-          },
-          value: {
-            '@binding': 'v'
-          }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-for-iterator.vue b/test/weex/cases/recycle-list/v-for-iterator.vue
deleted file mode 100644
index ed424a28069..00000000000
--- a/test/weex/cases/recycle-list/v-for-iterator.vue
+++ /dev/null
@@ -1,24 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <div v-for="(object, index) in item.list" :key="index">
-        <text>{{object.name}}</text>
-        <text v-for="(v, k, i) in object" :key="k">{{v}}</text>
-      </div>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-for.vdom.ts b/test/weex/cases/recycle-list/v-for.vdom.ts
deleted file mode 100644
index bbae2d53184..00000000000
--- a/test/weex/cases/recycle-list/v-for.vdom.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'div',
-      attr: {
-        '[[repeat]]': {
-          '@expression': 'item.list',
-          '@alias': 'panel'
-        }
-      },
-      children: [{
-        type: 'text',
-        attr: {
-          value: {
-            '@binding': 'panel.label'
-          }
-        }
-      }]
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-for.vue b/test/weex/cases/recycle-list/v-for.vue
deleted file mode 100644
index 57a6890d948..00000000000
--- a/test/weex/cases/recycle-list/v-for.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <div v-for="panel in item.list" :key="panel.id">
-        <text>{{panel.label}}</text>
-      </div>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-if.vdom.ts b/test/weex/cases/recycle-list/v-if.vdom.ts
deleted file mode 100644
index fe5339b0e76..00000000000
--- a/test/weex/cases/recycle-list/v-if.vdom.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'image',
-      attr: {
-        '[[match]]': 'item.source',
-        src: { '@binding': 'item.source' }
-      }
-    }, {
-      type: 'text',
-      attr: {
-        '[[match]]': '!item.source',
-        value: 'Title'
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-if.vue b/test/weex/cases/recycle-list/v-if.vue
deleted file mode 100644
index ab2e04706da..00000000000
--- a/test/weex/cases/recycle-list/v-if.vue
+++ /dev/null
@@ -1,22 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <image v-if="item.source" :src="item.source"></image>
-      <text v-if="!item.source">Title</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-on-inline.vdom.ts b/test/weex/cases/recycle-list/v-on-inline.vdom.ts
deleted file mode 100644
index 461fb993d83..00000000000
--- a/test/weex/cases/recycle-list/v-on-inline.vdom.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'text',
-      event: ['click', {
-        type: 'longpress',
-        params: [{ '@binding': 'item.key' }]
-      }]
-    }, {
-      type: 'text',
-      event: [{
-        type: 'appear',
-        params: [
-          { '@binding': 'item.index' },
-          { '@binding': 'item.type' }
-        ]
-      }],
-      attr: { value: 'Button' }
-    }, {
-      type: 'text',
-      event: [{ type: 'disappear' }],
-      attr: { value: 'Tips' }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-on-inline.vue b/test/weex/cases/recycle-list/v-on-inline.vue
deleted file mode 100644
index ae909b281a2..00000000000
--- a/test/weex/cases/recycle-list/v-on-inline.vue
+++ /dev/null
@@ -1,28 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <text v-on:click="toggle()" @longpress="toggle(item.key)"></text>
-      <text @appear="onappear(item.index, 'static', item.type, $event)">Button</text>
-      <text @disappear="onappear(25, 'static')">Tips</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    },
-    methods: {
-      hide () {},
-      toggle () {},
-      onappear () {}
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-on.vdom.ts b/test/weex/cases/recycle-list/v-on.vdom.ts
deleted file mode 100644
index 3da82096382..00000000000
--- a/test/weex/cases/recycle-list/v-on.vdom.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    switch: 'type',
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree', case: 'A' },
-    children: [{
-      type: 'text',
-      event: ['click', 'longpress'],
-      attr: { value: 'A' }
-    }, {
-      type: 'text',
-      event: ['touchend'],
-      attr: { value: 'B' }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-on.vue b/test/weex/cases/recycle-list/v-on.vue
deleted file mode 100644
index fb40f1522a1..00000000000
--- a/test/weex/cases/recycle-list/v-on.vue
+++ /dev/null
@@ -1,26 +0,0 @@
-<template>
-  <recycle-list for="item in longList" switch="type">
-    <cell-slot case="A">
-      <text v-on:click="handler" @longpress="move">A</text>
-      <text @touchend="move">B</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        longList: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    },
-    methods: {
-      handler () {},
-      move () {}
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/recycle-list/v-once.vdom.ts b/test/weex/cases/recycle-list/v-once.vdom.ts
deleted file mode 100644
index 07e641977d0..00000000000
--- a/test/weex/cases/recycle-list/v-once.vdom.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-({
-  type: 'recycle-list',
-  attr: {
-    append: 'tree',
-    listData: [
-      { type: 'A' },
-      { type: 'A' }
-    ],
-    alias: 'item'
-  },
-  children: [{
-    type: 'cell-slot',
-    attr: { append: 'tree' },
-    children: [{
-      type: 'text',
-      attr: {
-        '[[once]]': true,
-        value: { '@binding': 'item.type' }
-      }
-    }]
-  }]
-})
diff --git a/test/weex/cases/recycle-list/v-once.vue b/test/weex/cases/recycle-list/v-once.vue
deleted file mode 100644
index f1e3a367a8f..00000000000
--- a/test/weex/cases/recycle-list/v-once.vue
+++ /dev/null
@@ -1,21 +0,0 @@
-<template>
-  <recycle-list for="item in list">
-    <cell-slot>
-      <text v-once>{{item.type}}</text>
-    </cell-slot>
-  </recycle-list>
-</template>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        list: [
-          { type: 'A' },
-          { type: 'A' }
-        ]
-      }
-    }
-  }
-</script>
-
diff --git a/test/weex/cases/render/class.vdom.ts b/test/weex/cases/render/class.vdom.ts
deleted file mode 100644
index 7dec4ab57a9..00000000000
--- a/test/weex/cases/render/class.vdom.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-({
-  type: 'div',
-  children: [{
-    type: 'div',
-    classList: ['box', 'box1']
-  }, {
-    type: 'div',
-    classList: ['box', 'box2']
-  }, {
-    type: 'div',
-    classList: ['box', 'box3']
-  }, {
-    type: 'div',
-    classList: ['box', 'box4']
-  }, {
-    type: 'div',
-    classList: ['box', 'box5']
-  }]
-})
diff --git a/test/weex/cases/render/class.vue b/test/weex/cases/render/class.vue
deleted file mode 100644
index f4443c50dd2..00000000000
--- a/test/weex/cases/render/class.vue
+++ /dev/null
@@ -1,56 +0,0 @@
-<template>
-  <div>
-    <div :class="class1"></div>
-    <div :class="class2"></div>
-    <div class="box" :class="class3"></div>
-    <div class="box" :class="class4"></div>
-    <div class="box" :class="{ box5: class5 }"></div>
-  </div>
-</template>
-
-<style scoped>
-  .box {
-    width: 100px;
-    height: 100px;
-  }
-
-  .box1 {
-    background-color: #DDD;
-  }
-
-  .box2 {
-    background-color: #CCC;
-  }
-
-  .box3 {
-    background-color: #BBB;
-  }
-
-  .box4 {
-    background-color: #AAA;
-  }
-
-  .box5 {
-    background-color: #999;
-  }
-</style>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        class1: ['box', 'box1'],
-        class2: {
-          'box': true,
-          'box1': false,
-          'box2': true
-        },
-        class3: ['box3'],
-        class4: {
-          'box4': true
-        },
-        class5: true
-      }
-    }
-  }
-</script>
\ No newline at end of file
diff --git a/test/weex/cases/render/sample.vdom.ts b/test/weex/cases/render/sample.vdom.ts
deleted file mode 100644
index 1d9b198a0b2..00000000000
--- a/test/weex/cases/render/sample.vdom.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-({
-  type: 'div',
-  style: {
-    justifyContent: 'center'
-  },
-  children: [{
-    type: 'text',
-    attr: {
-      value: 'Yo'
-    },
-    classList: ['freestyle']
-  }]
-})
diff --git a/test/weex/cases/render/sample.vue b/test/weex/cases/render/sample.vue
deleted file mode 100644
index 0251b3d6fba..00000000000
--- a/test/weex/cases/render/sample.vue
+++ /dev/null
@@ -1,23 +0,0 @@
-<template>
-  <div style="justify-content:center">
-    <text class="freestyle">{{string}}</text>
-  </div>
-</template>
-
-<style scoped>
-  .freestyle {
-    color: #41B883;
-    font-size: 233px;
-    text-align: center;
-  }
-</style>
-
-<script>
-  module.exports = {
-    data () {
-      return {
-        string: 'Yo'
-      }
-    }
-  }
-</script>
diff --git a/test/weex/compiler/append.spec.ts b/test/weex/compiler/append.spec.ts
deleted file mode 100644
index c75267c9078..00000000000
--- a/test/weex/compiler/append.spec.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('append props', () => {
-  it('add append="tree" on <cell>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell></cell></list>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(1)
-    expect(staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"tree"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('override append="node" on <cell>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell append="node"></cell></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"node"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('add append="tree" on <header>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><header></header></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"tree"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('add append="tree" on <recycle-list>', () => {
-    const { render, staticRenderFns, errors } = compile(`<recycle-list for="item in list"><div></div></recycle-list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(render + staticRenderFns).toMatch(strToRegExp(`"append":"tree"`))
-    expect(errors).toEqual([])
-  })
-
-  it('add append="tree" on <cell-slot>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell-slot></cell-slot></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`appendAsTree:true`))
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"tree"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('override append="node" on <cell-slot>', () => {
-    const { render, staticRenderFns, errors } = compile(`<list><cell-slot append="node"></cell-slot></list>`)
-    expect(render + staticRenderFns).toMatch(strToRegExp(`attrs:{"append":"node"}`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/test/weex/compiler/class.spec.ts b/test/weex/compiler/class.spec.ts
deleted file mode 100644
index a7e88ab83a8..00000000000
--- a/test/weex/compiler/class.spec.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile class', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`<div class="a b c"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticClass:["a","b","c"]`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile dynamic class', () => {
-    const { render, staticRenderFns, errors } = compile(`<div class="a {{b}} c"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:["a",_s(b),"c"]`))
-    expect(errors).not.toBeUndefined()
-    expect(errors.length).toEqual(1)
-    expect(errors[0]).toMatch(strToRegExp(`a {{b}} c`))
-    expect(errors[0]).toMatch(strToRegExp(`v-bind`))
-  })
-
-  it('should compile class binding of array', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:class="['a', 'b', c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:['a', 'b', c]`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile class binding of map', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:class="{ a: true, b: x }"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:{ a: true, b: x }`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile class binding of a variable', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:class="x"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:x`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile class binding by shorthand', () => {
-    const { render, staticRenderFns, errors } = compile(`<div :class="['a', 'b', c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`class:['a', 'b', c]`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/test/weex/compiler/compile.spec.ts b/test/weex/compiler/compile.spec.ts
deleted file mode 100644
index 7a717f19146..00000000000
--- a/test/weex/compiler/compile.spec.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile basic', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`<div>{{hi}}</div>`)
-    expect(render).toEqual(`with(this){return _c('div',[_v(_s(hi))])}`)
-    expect(staticRenderFns.length).toBe(0)
-    expect(errors).toEqual([])
-  })
-
-  it('should compile data bindings', () => {
-    const { render, staticRenderFns, errors } = compile(`<div :a="b"></div>`)
-    expect(render).toEqual(`with(this){return _c('div',{attrs:{"a":b}})}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile event bindings', () => {
-    const { render, staticRenderFns, errors } = compile(`<div @click="x"></div>`)
-    expect(render).toEqual(`with(this){return _c('div',{on:{"click":x}})}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile data bindings with children', () => {
-    const { render, staticRenderFns, errors } = compile(`<foo :a="b"><text>Hello</text></foo>`)
-    expect(render).toEqual(`with(this){return _c('foo',{attrs:{"a":b}},[_c('text',[_v("Hello")])])}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile unary tag', () => {
-    const inputCase = compile(`<div><input><text>abc</text></div>`)
-    expect(inputCase.render).toMatch(strToRegExp(`return _m(0)`))
-    expect(inputCase.staticRenderFns).toMatch(strToRegExp(`_c('div',[_c('input'),_c('text',[_v("abc")])])`))
-    expect(inputCase.errors).toEqual([])
-
-    const imageCase = compile(`<div><image src="path"><text>abc</text></div>`)
-    expect(imageCase.render).toMatch(strToRegExp(`return _m(0)`))
-    expect(imageCase.staticRenderFns).toMatch(strToRegExp(`_c('div',[_c('image',{attrs:{"src":"path"}}),_c('text',[_v("abc")])])`))
-    expect(imageCase.errors).toEqual([])
-
-    const complexCase = compile(`
-      <div>
-        <image src="path">
-        <image></image>
-        <div>
-          <embed>
-          <text>start</text>
-          <input type="text">
-          <input type="url" />
-          <text>end</text>
-        </div>
-      </div>
-    `)
-    expect(complexCase.render).toMatch(strToRegExp(`return _m(0)`))
-    expect(complexCase.staticRenderFns).toMatch(strToRegExp(`_c('image',{attrs:{"src":"path"}}),_c('image'),_c('div'`))
-    expect(complexCase.staticRenderFns).toMatch(strToRegExp(`_c('div',[_c('embed'),_c('text',[_v("start")]),_c('input',{attrs:{"type":"text"}}),_c('input',{attrs:{"type":"url"}}),_c('text',[_v("end")])]`))
-    expect(complexCase.errors).toEqual([])
-  })
-
-  it('should compile more complex situation', () => {
-    // from examples of https://github.com/alibaba/weex
-    const { render, staticRenderFns, errors } = compile(`
-      <refresh class="refresh" @refresh="handleRefresh" :display="displayRefresh"
-        style="flex-direction:row;">
-        <loading-indicator></loading-indicator>
-        <text style="margin-left:36px;color:#eee;">Load more...</text>
-      </refresh>
-    `)
-    expect(render).toEqual(`with(this){return _c('refresh',{staticClass:["refresh"],staticStyle:{flexDirection:"row"},attrs:{"display":displayRefresh},on:{"refresh":handleRefresh}},[_c('loading-indicator'),_c('text',{staticStyle:{marginLeft:"36px",color:"#eee"}},[_v("Load more...")])])}`)
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-})
diff --git a/test/weex/compiler/parser.spec.ts b/test/weex/compiler/parser.spec.ts
deleted file mode 100644
index 1d560b5b44c..00000000000
--- a/test/weex/compiler/parser.spec.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { generateBinding } from '../../../src/platforms/weex/util/parser'
-
-describe('expression parser', () => {
-  describe('generateBinding', () => {
-    it('primitive literal', () => {
-      expect(generateBinding('15')).toEqual(15)
-      expect(generateBinding('"xxx"')).toEqual('xxx')
-    })
-
-    it('identifiers', () => {
-      expect(generateBinding('x')).toEqual({ '@binding': 'x' })
-      expect(generateBinding('x.y')).toEqual({ '@binding': 'x.y' })
-      expect(generateBinding(`x.y['z']`)).toEqual({ '@binding': `x.y['z']` })
-    })
-
-    it('object literal', () => {
-      expect(generateBinding('{}')).toEqual({})
-      expect(generateBinding('{ abc: 25 }')).toEqual({ abc: 25 })
-      expect(generateBinding('{ abc: 25, def: "xxx" }')).toEqual({ abc: 25, def: 'xxx' })
-      expect(generateBinding('{ a: 3, b: { bb: "bb", bbb: { bbc: "BBC" } } }'))
-        .toEqual({ a: 3, b: { bb: 'bb', bbb: { bbc: 'BBC' }}})
-    })
-
-    it('array literal', () => {
-      expect(generateBinding('[]')).toEqual([])
-      expect(generateBinding('[{ abc: 25 }]')).toEqual([{ abc: 25 }])
-      expect(generateBinding('[{ abc: 25, def: ["xxx"] }]')).toEqual([{ abc: 25, def: ['xxx'] }])
-      expect(generateBinding('{ a: [3,16], b: [{ bb: ["aa","bb"], bbb: [{bbc:"BBC"}] }] }'))
-        .toEqual({ a: [3, 16], b: [{ bb: ['aa', 'bb'], bbb: [{ bbc: 'BBC' }] }] })
-    })
-
-    it('expressions', () => {
-      expect(generateBinding(`3 + 5`)).toEqual({ '@binding': `3 + 5` })
-      expect(generateBinding(`'x' + 2`)).toEqual({ '@binding': `'x' + 2` })
-      expect(generateBinding(`\`xx\` + 2`)).toEqual({ '@binding': `\`xx\` + 2` })
-      expect(generateBinding(`item.size * 23 + 'px'`)).toEqual({ '@binding': `item.size * 23 + 'px'` })
-    })
-
-    it('object bindings', () => {
-      expect(generateBinding(`{ color: textColor }`)).toEqual({
-        color: { '@binding': 'textColor' }
-      })
-      expect(generateBinding(`{ color: '#FF' + 66 * 100, fontSize: item.size }`)).toEqual({
-        color: { '@binding': `'#FF' + 66 * 100` },
-        fontSize: { '@binding': 'item.size' }
-      })
-      expect(generateBinding(`{
-        x: { xx: obj, xy: -2 + 5 },
-        y: {
-          yy: { yyy: obj.y || yy },
-          yz: typeof object.yz === 'string' ? object.yz : ''
-        }
-      }`)).toEqual({
-        x: { xx: { '@binding': 'obj' }, xy: { '@binding': '-2 + 5' }},
-        y: {
-          yy: { yyy: { '@binding': 'obj.y || yy' }},
-          yz: { '@binding': `typeof object.yz === 'string' ? object.yz : ''` }
-        }
-      })
-    })
-
-    it('array bindings', () => {
-      expect(generateBinding(`[textColor, 3 + 5, 'string']`)).toEqual([
-        { '@binding': 'textColor' },
-        { '@binding': '3 + 5' },
-        'string'
-      ])
-      expect(generateBinding(`[
-        { color: '#FF' + 66 * -100 },
-        item && item.style,
-        { fontSize: item.size | 0 }
-      ]`)).toEqual([
-        { color: { '@binding': `'#FF' + 66 * -100` }},
-        { '@binding': 'item && item.style' },
-        { fontSize: { '@binding': 'item.size | 0' }}
-      ])
-      expect(generateBinding(`[{
-        x: [{ xx: [fn instanceof Function ? 'function' : '' , 25] }],
-        y: {
-          yy: [{ yyy: [obj.yy.y, obj.y.yy] }],
-          yz: [object.yz, void 0]
-        }
-      }]`)).toEqual([{
-        x: [{ xx: [{ '@binding': `fn instanceof Function ? 'function' : ''` }, 25] }],
-        y: {
-          yy: [{ yyy: [{ '@binding': 'obj.yy.y' }, { '@binding': 'obj.y.yy' }] }],
-          yz: [{ '@binding': 'object.yz' }, { '@binding': 'void 0' }]
-        }
-      }])
-    })
-
-    it('unsupported bindings', () => {
-      expect(generateBinding('() => {}')).toEqual('')
-      expect(generateBinding('function(){}')).toEqual('')
-      expect(generateBinding('(function(){})()')).toEqual('')
-      expect(generateBinding('var abc = 35')).toEqual('')
-      expect(generateBinding('abc++')).toEqual('')
-      expect(generateBinding('x.y(0)')).toEqual('')
-      expect(generateBinding('class X {}')).toEqual('')
-      expect(generateBinding('if (typeof x == null) { 35 }')).toEqual('')
-      expect(generateBinding('while (x == null)')).toEqual('')
-      expect(generateBinding('new Function()')).toEqual('')
-    })
-  })
-})
diff --git a/test/weex/compiler/props.spec.ts b/test/weex/compiler/props.spec.ts
deleted file mode 100644
index 85f4e10ab70..00000000000
--- a/test/weex/compiler/props.spec.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile props', () => {
-  it('custom props', () => {
-    const { render, staticRenderFns, errors } = compile(`<div custom="whatever"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`attrs:{"custom":"whatever"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('camelize props', () => {
-    const { render, staticRenderFns, errors } = compile(`<div kebab-case="whatever"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`attrs:{"kebabCase":"whatever"}`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/test/weex/compiler/style.spec.ts b/test/weex/compiler/style.spec.ts
deleted file mode 100644
index efde3c35aad..00000000000
--- a/test/weex/compiler/style.spec.ts
+++ /dev/null
@@ -1,83 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile style', () => {
-  it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="a: x; b: y"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticStyle:{a:"x",b:"y"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile empty style value', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style=""></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(/[(^style|^staticStyle)]/)
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style value with trailing semicolon', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="a: x; b: y;"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticStyle:{a:"x",b:"y"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile hyphenated style name & value', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="-abc-def: x-y; abc-def: x-y"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).not.toBeUndefined()
-    expect(staticRenderFns.length).toEqual(0)
-    expect(render).toMatch(strToRegExp(`staticStyle:{AbcDef:"x-y",abcDef:"x-y"}`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile dynamic style', () => {
-    const { render, staticRenderFns, errors } = compile(`<div style="a: x; b: {{y}}"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:{a:"x",b:_s(y)}`))
-    expect(errors).not.toBeUndefined()
-    expect(errors.length).toEqual(1)
-    expect(errors[0]).toMatch(strToRegExp(`b: {{y}}`))
-    expect(errors[0]).toMatch(strToRegExp(`v-bind`))
-  })
-
-  it('should compile style binding of array', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:style="[a, b, c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:[a, b, c]`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style binding of map', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:style="{ a: x, b: 'y' + z }"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:{ a: x, b: 'y' + z }`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style binding of a variable', () => {
-    const { render, staticRenderFns, errors } = compile(`<div v-bind:style="x"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:x`))
-    expect(errors).toEqual([])
-  })
-
-  it('should compile style binding by shorthand', () => {
-    const { render, staticRenderFns, errors } = compile(`<div :style="[a, b, c]"></div>`)
-    expect(render).not.toBeUndefined()
-    expect(staticRenderFns).toEqual([])
-    expect(render).toMatch(strToRegExp(`style:[a, b, c]`))
-    expect(errors).toEqual([])
-  })
-})
diff --git a/test/weex/compiler/v-model.spec.ts b/test/weex/compiler/v-model.spec.ts
deleted file mode 100644
index c5f0401dc7b..00000000000
--- a/test/weex/compiler/v-model.spec.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { compile } from '../../../packages/weex-template-compiler'
-import { strToRegExp } from '../helpers/index'
-
-describe('compile v-model', () => {
-  it('should compile modelable native component', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><input v-model="x" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(x)}`))
-    expect(render).toMatch(strToRegExp(`on:{"input":function($event){x=$event.target.attr.value}}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile other component with whole $event as the value', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><foo v-model="x" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`model:{value:(x),callback:function ($$v) {x=$$v},expression:"x"}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile with trim modifier for modelable native component', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><input v-model.trim="x" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(x)}`))
-    expect(render).toMatch(strToRegExp(`on:{"input":function($event){x=$event.target.attr.value.trim()}}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-
-  it('should compile with trim & lazy modifier', () => {
-    const { render, staticRenderFns, errors } = compile(`<div><input v-model.trim.lazy="x" /><input v-model.lazy.trim="y" /></div>`)
-    expect(render).not.toBeUndefined()
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(x)}`))
-    expect(render).toMatch(strToRegExp(`attrs:{"value":(y)}`))
-    expect(render).toMatch(strToRegExp(`on:{"change":function($event){x=$event.target.attr.value.trim()}}`))
-    expect(render).toMatch(strToRegExp(`on:{"change":function($event){y=$event.target.attr.value.trim()}}`))
-    expect(staticRenderFns).toEqual([])
-    expect(errors).toEqual([])
-  })
-})
diff --git a/test/weex/helpers/index.ts b/test/weex/helpers/index.ts
deleted file mode 100644
index c75ab07a052..00000000000
--- a/test/weex/helpers/index.ts
+++ /dev/null
@@ -1,233 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import * as Vue from '../../../packages/weex-vue-framework'
-import { compile } from '../../../packages/weex-template-compiler'
-import WeexRuntime from 'weex-js-runtime'
-import styler from 'weex-styler'
-
-const styleRE = /<\s*style\s*\w*>([^(<\/)]*)<\/\s*style\s*>/g
-const scriptRE = /<\s*script.*>([^]*)<\/\s*script\s*>/
-const templateRE = /<\s*template\s*([^>]*)>([^]*)<\/\s*template\s*>/
-
-export function readFile (filename) {
-  return fs.readFileSync(path.resolve(__dirname, '../cases/', filename), 'utf8')
-}
-
-export function readObject (filename) {
-  return (new Function(`return ${readFile(filename)}`))()
-}
-
-console.debug = () => {}
-
-// http://stackoverflow.com/a/35478115
-const matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g
-export function strToRegExp (str) {
-  return new RegExp(str.replace(matchOperatorsRe, '\\$&'))
-}
-
-function parseStatic (fns) {
-  return '[' + fns.map(fn => `function () { ${fn} }`).join(',') + ']'
-}
-
-export function compileAndStringify (template) {
-  const { render, staticRenderFns } = compile(template)
-  return {
-    render: `function () { ${render} }`,
-    staticRenderFns: parseStatic(staticRenderFns)
-  }
-}
-
-/**
- * Compile *.vue file into js code
- * @param {string} source raw text of *.vue file
- * @param {string} componentName whether compile to a component
- */
-export function compileVue (source, componentName) {
-  return new Promise((resolve, reject) => {
-    if (!templateRE.test(source)) {
-      return reject('No Template!')
-    }
-    const scriptMatch = scriptRE.exec(source)
-    const script = scriptMatch ? scriptMatch[1] : ''
-    const templateMatch = templateRE.exec(source)
-    const compileOptions = {}
-    if (/\s*recyclable\=?/i.test(templateMatch[1])) {
-      compileOptions.recyclable = true
-    }
-    const res = compile(templateMatch[2], compileOptions)
-
-    const name = 'test_case_' + (Math.random() * 99999999).toFixed(0)
-    const generateCode = styles => (`
-      try { weex.document.registerStyleSheets("${name}", [${JSON.stringify(styles)}]) } catch(e) {};
-      var ${name} = Object.assign({
-        _scopeId: "${name}",
-        style: ${JSON.stringify(styles)},
-        render: function () { ${res.render} },
-        ${res['@render'] ? ('"@render": function () {' + res['@render'] + '},') : ''}
-        staticRenderFns: ${parseStatic(res.staticRenderFns)},
-      }, (function(){
-        var module = { exports: {} };
-        ${script};
-        return module.exports;
-      })());
-    ` + (componentName
-        ? `Vue.component('${componentName}', ${name});\n`
-        : `${name}.el = 'body';new Vue(${name});`)
-    )
-
-    let cssText = ''
-    let styleMatch = null
-    while ((styleMatch = styleRE.exec(source))) {
-      cssText += `\n${styleMatch[1]}\n`
-    }
-    styler.parse(cssText, (error, result) => {
-      if (error) {
-        return reject(error)
-      }
-      resolve(generateCode(result.jsonStyle))
-    })
-    resolve(generateCode({}))
-  })
-}
-
-export function compileWithDeps (entryPath, deps) {
-  return new Promise((resolve, reject) => {
-    if (Array.isArray(deps)) {
-      Promise.all(deps.map(dep => {
-        return compileVue(readFile(dep.path), dep.name).catch(reject)
-      })).then(depCodes => {
-        compileVue(readFile(entryPath)).then(entryCode => {
-          resolve(depCodes.join('\n') + entryCode)
-        }).catch(reject)
-      }).catch(reject)
-    }
-  })
-}
-
-function isObject (object) {
-  return object !== null && typeof object === 'object'
-}
-
-function isEmptyObject (object) {
-  return isObject(object) && Object.keys(object).length < 1
-}
-
-function omitUseless (object) {
-  if (isObject(object)) {
-    delete object.ref
-    for (const key in object) {
-      omitUseless(object[key])
-      if (key === '@styleScope' ||
-        key === '@templateId' ||
-        key === 'bindingExpression') {
-        delete object[key]
-      }
-      if (key.charAt(0) !== '@' &&
-        (isEmptyObject(object[key]) || object[key] === undefined)) {
-        delete object[key]
-      }
-    }
-  }
-  return object
-}
-
-export function getRoot (instance) {
-  return omitUseless(instance.$getRoot())
-}
-
-// Get all binding events in the instance
-export function getEvents (instance) {
-  const events: any[] = []
-  const recordEvent = node => {
-    if (!node) { return }
-    if (Array.isArray(node.event)) {
-      node.event.forEach(type => {
-        events.push({ ref: node.ref, type })
-      })
-    }
-    if (Array.isArray(node.children)) {
-      node.children.forEach(recordEvent)
-    }
-  }
-  recordEvent(instance.$getRoot())
-  return events
-}
-
-export function fireEvent (instance, ref, type, event = {}) {
-  const el = instance.document.getRef(ref)
-  if (el) {
-    instance.document.fireEvent(el, type, event)
-  }
-}
-
-export function createInstance (id, code, ...args) {
-  WeexRuntime.config.frameworks = { Vue }
-  const context = WeexRuntime.init(WeexRuntime.config)
-  context.registerModules({
-    timer: ['setTimeout', 'setInterval']
-  })
-  const instance = context.createInstance(id, `// { "framework": "Vue" }\n${code}`, ...args) || {}
-  instance.document = context.getDocument(id)
-  instance.$getRoot = () => context.getRoot(id)
-  instance.$refresh = (data) => context.refreshInstance(id, data)
-  instance.$destroy = () => {
-    delete instance.document
-    context.destroyInstance(id)
-  }
-  instance.$triggerHook = (id, hook, args) => {
-    instance.document.taskCenter.triggerHook(id, 'lifecycle', hook, { args })
-  }
-  return instance
-}
-
-export function compileAndExecute (template, additional = '') {
-  return new Promise(resolve => {
-    const id = String(Date.now() * Math.random())
-    const { render, staticRenderFns } = compile(template)
-    const instance = createInstance(id, `
-      new Vue({
-        el: '#whatever',
-        render: function () { ${render} },
-        staticRenderFns: ${parseStatic(staticRenderFns)},
-        ${additional}
-      })
-    `)
-    setTimeout(() => resolve(instance), 10)
-  })
-}
-
-export function syncPromise (arr) {
-  let p = Promise.resolve()
-  arr.forEach(item => {
-    p = p.then(item)
-  })
-  return p
-}
-
-export function checkRefresh (instance, data, checker) {
-  return () => new Promise(res => {
-    instance.$refresh(data)
-    setTimeout(() => {
-      checker(getRoot(instance))
-      res()
-    })
-  })
-}
-
-export function addTaskHook (hook) {
-  global.callNative = function callNative (id, tasks) {
-    if (Array.isArray(tasks) && typeof hook === 'function') {
-      tasks.forEach(task => {
-        hook(id, {
-          module: task.module,
-          method: task.method,
-          args: Array.from(task.args)
-        })
-      })
-    }
-  }
-}
-
-export function resetTaskHook () {
-  delete global.callNative
-}
diff --git a/test/weex/runtime/attrs.spec.ts b/test/weex/runtime/attrs.spec.ts
deleted file mode 100644
index 037067ac1a2..00000000000
--- a/test/weex/runtime/attrs.spec.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-import { getRoot, fireEvent, compileAndExecute } from '../helpers/index'
-
-describe('generate attribute', () => {
-  it('should be generated', (done) => {
-    compileAndExecute(`
-      <div>
-        <text value="Hello World" style="font-size: 100"></text>
-      </div>
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          style: { fontSize: '100' },
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    }).catch(e => done.fail(e))
-  })
-
-  it('should be updated', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :value="x"></text>
-      </div>
-    `, `
-      data: { x: 'Hello World' },
-      methods: {
-        foo: function () {
-          this.x = 'Hello Vue'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: 'Hello World' }}
-        ]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: 'Hello Vue' }}
-        ]
-      })
-      done()
-    }).catch(e => done.fail(e))
-  })
-
-  it('should be cleared', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :value="x"></text>
-      </div>
-    `, `
-      data: { x: 'Hello World' },
-      methods: {
-        foo: function () {
-          this.x = ''
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: 'Hello World' }}
-        ]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [
-          { type: 'text', attr: { value: '' }}
-        ]
-      })
-      done()
-    })
-  })
-})
diff --git a/test/weex/runtime/class.spec.ts b/test/weex/runtime/class.spec.ts
deleted file mode 100644
index ec704f7b3dd..00000000000
--- a/test/weex/runtime/class.spec.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import { getRoot, fireEvent, compileAndExecute } from '../helpers/index'
-
-describe('generate class', () => {
-  it('should be generated', () => {
-    compileAndExecute(`
-      <div>
-        <text class="a b c">Hello World</text>
-      </div>
-    `, `
-      style: {
-        a: { fontSize: '100' },
-        b: { color: '#ff0000' },
-        c: { fontWeight: 'bold' }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          classList: ['a', 'b', 'c'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-    })
-  })
-
-  it('should be updated', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :class="['a', x]">Hello World</text>
-      </div>
-    `, `
-      data: { x: 'b' },
-      style: {
-        a: { fontSize: '100' },
-        b: { color: '#ff0000' },
-        c: { fontWeight: 'bold' },
-        d: {
-          color: '#0000ff',
-          fontWeight: 'bold'
-        }
-      },
-      methods: {
-        foo: function () {
-          this.x = 'd'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'b'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'd'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    })
-  })
-
-  it('should be applied in order', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :class="arr">Hello World</text>
-      </div>
-    `, `
-      data: {
-        arr: ['b', 'a']
-      },
-      style: {
-        a: { color: '#ff0000' },
-        b: { color: '#00ff00' },
-        c: { color: '#0000ff' }
-      },
-      methods: {
-        foo: function () {
-          this.arr.push('c')
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['b', 'a'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['b', 'a', 'c'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    })
-  })
-
-  it('should be cleared', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text :class="['a', x]">Hello World</text>
-      </div>
-    `, `
-      data: { x: 'b' },
-      style: {
-        a: { fontSize: '100' },
-        b: { color: '#ff0000' },
-        c: { fontWeight: 'bold' }
-      },
-      methods: {
-        foo: function () {
-          this.x = 'c'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'b'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          classList: ['a', 'c'],
-          attr: { value: 'Hello World' }
-        }]
-      })
-      done()
-    })
-  })
-})
diff --git a/test/weex/runtime/components/richtext.spec.ts b/test/weex/runtime/components/richtext.spec.ts
deleted file mode 100644
index 7d104988c20..00000000000
--- a/test/weex/runtime/components/richtext.spec.ts
+++ /dev/null
@@ -1,692 +0,0 @@
-import {
-  compileAndStringify,
-  getRoot,
-  fireEvent,
-  createInstance
-} from '../../helpers/index'
-
-function compileSnippet (snippet, additional) {
-  const { render, staticRenderFns } = compileAndStringify(`<div>${snippet}</div>`)
-  const id = String(Date.now() * Math.random())
-  const instance = createInstance(id, `
-    new Vue({
-      el: 'body',
-      render: ${render},
-      staticRenderFns: ${staticRenderFns},
-      ${additional}
-    })
-  `)
-  return getRoot(instance).children[0]
-}
-
-describe('richtext component', () => {
-  it('with no child', () => {
-    expect(compileSnippet(`
-      <richtext></richtext>
-    `)).toEqual({
-      type: 'richtext'
-    })
-  })
-
-  it('with single text node', () => {
-    expect(compileSnippet(`
-      <richtext>single</richtext>
-    `)).toEqual({
-      type: 'richtext',
-      attr: {
-        value: [{
-          type: 'span',
-          attr: {
-            value: 'single'
-          }
-        }]
-      }
-    })
-  })
-
-  describe('span', () => {
-    it('single node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>single</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: {
-              value: 'single'
-            }
-          }]
-        }
-      })
-    })
-
-    it('multiple node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>AAA</span>
-          <span>BBB</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'AAA' }
-          }, {
-            type: 'span',
-            attr: { value: 'BBB' }
-          }]
-        }
-      })
-    })
-
-    it('with raw text', () => {
-      expect(compileSnippet(`
-        <richtext>
-          AAA
-          <span>BBB</span>CCC
-          <span>DDD</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'AAA' }
-          }, {
-            type: 'span',
-            attr: { value: 'BBB' }
-          }, {
-            type: 'span',
-            attr: { value: 'CCC' }
-          }, {
-            type: 'span',
-            attr: { value: 'DDD' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('a', () => {
-    it('single node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <a href="http://whatever.com"></a>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'a',
-            attr: { href: 'http://whatever.com' }
-          }]
-        }
-      })
-    })
-
-    it('multiple node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <a href="http://a.whatever.com"></a>
-          <a href="http://b.whatever.com"></a>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'a',
-            attr: { href: 'http://a.whatever.com' }
-          }, {
-            type: 'a',
-            attr: { href: 'http://b.whatever.com' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('image', () => {
-    it('single node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image src="path/to/profile.png"></image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            attr: { src: 'path/to/profile.png' }
-          }]
-        }
-      })
-    })
-
-    it('multiple node', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image src="path/to/A.png"></image>
-          <image src="path/to/B.png"></image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            attr: { src: 'path/to/A.png' }
-          }, {
-            type: 'image',
-            attr: { src: 'path/to/B.png' }
-          }]
-        }
-      })
-    })
-
-    it('with width and height', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image
-            style="width:150px;height:150px;"
-            src="path/to/profile.png">
-          </image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            style: { width: '150px', height: '150px' },
-            attr: { src: 'path/to/profile.png' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('nested', () => {
-    it('span', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>AAA
-            <span>
-              <span>BBB</span>
-              <span><span>CCC</span>DDD</span>
-            </span>
-          </span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            children: [{
-              type: 'span',
-              attr: { value: 'AAA' }
-            }, {
-              type: 'span',
-              children: [{
-                type: 'span',
-                attr: { value: 'BBB' }
-              }, {
-                type: 'span',
-                children: [{
-                  type: 'span',
-                  attr: { value: 'CCC' }
-                }, {
-                  type: 'span',
-                  attr: { value: 'DDD' }
-                }]
-              }]
-            }]
-          }]
-        }
-      })
-    })
-
-    it('image and a', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>title</span>
-          <a href="http://remote.com/xx.js">
-            <span><span>name</span></span>
-            <image src="path/to/yy.gif"></image>
-          </a>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'title' }
-          }, {
-            type: 'a',
-            attr: { href: 'http://remote.com/xx.js' },
-            children: [{
-              type: 'span',
-              children: [{
-                type: 'span',
-                attr: { value: 'name' }
-              }]
-            }, {
-              type: 'image',
-              attr: { src: 'path/to/yy.gif' }
-            }]
-          }]
-        }
-      })
-    })
-  })
-
-  describe('with styles', () => {
-    it('inline', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span style="font-size:16px;color:#FF6600;">ABCD</span>
-          <image style="width:33.33px;height:66.67px" src="path/to/A.png"></image>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: '16px', color: '#FF6600' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'image',
-            style: { width: '33.33px', height: '66.67px' },
-            attr: { src: 'path/to/A.png' }
-          }]
-        }
-      })
-    })
-
-    it('class list', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image class="icon" src="path/to/A.png"></image>
-          <span class="title large">ABCD</span>
-        </richtext>
-      `, `
-        style: {
-          title: { color: '#FF6600' },
-          large: { fontSize: 24 },
-          icon: { width: 40, height: 60 }
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            style: { width: 40, height: 60 },
-            attr: { src: 'path/to/A.png' }
-          }, {
-            type: 'span',
-            style: { fontSize: 24, color: '#FF6600' },
-            attr: { value: 'ABCD' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('data binding', () => {
-    it('simple', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>{{name}}</span>
-        </richtext>
-      `, `data: { name: 'ABCDEFG' }`)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'ABCDEFG' }
-          }]
-        }
-      })
-    })
-
-    it('nested', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>{{a}}</span>
-          <span>{{b}}<span>{{c.d}}</span></span>
-          <span>{{e}}</span>
-        </richtext>
-      `, `
-        data: { a: 'A', b: 'B', c: { d: 'CD' }, e: 'E' }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'A' }
-          }, {
-            type: 'span',
-            children: [{
-              type: 'span',
-              attr: { value: 'B' }
-            }, {
-              type: 'span',
-              attr: { value: 'CD' }
-            }]
-          }, {
-            type: 'span',
-            attr: { value: 'E' }
-          }]
-        }
-      })
-    })
-
-    it('update', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span>{{name}}</span>
-        </richtext>
-      `, `
-        data: { name: 'default' },
-        created: function () {
-          this.name = 'updated'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'updated' }
-          }]
-        }
-      })
-    })
-
-    it('attribute', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :label="label">{{name}}</span>
-        </richtext>
-      `, `
-        data: {
-          label: 'uid',
-          name: '10100'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: {
-              label: 'uid',
-              value: '10100'
-            }
-          }]
-        }
-      })
-    })
-
-    it('update attribute', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :label="label">{{name}}</span>
-        </richtext>
-      `, `
-        data: {
-          label: 'name',
-          name: 'Hanks'
-        },
-        created: function () {
-          this.label = 'uid';
-          this.name = '10100';
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            attr: {
-              label: 'uid',
-              value: '10100'
-            }
-          }]
-        }
-      })
-    })
-
-    it('inline style', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :style="styleObject">ABCD</span>
-          <span :style="{ textAlign: align, color: 'red' }">EFGH</span>
-        </richtext>
-      `, `
-        data: {
-          styleObject: { fontSize: '32px', color: '#F6F660' },
-          align: 'center'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: '32px', color: '#F6F660' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'span',
-            style: { textAlign: 'center', color: 'red' },
-            attr: { value: 'EFGH' }
-          }]
-        }
-      })
-    })
-
-    it('class list', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <image :class="classList" src="path/to/A.png"></image>
-          <span :class="['title', size]">ABCD</span>
-          <span class="large" style="color:#F6F0F4">EFGH</span>
-        </richtext>
-      `, `
-        style: {
-          title: { color: '#FF6600' },
-          large: { fontSize: 24 },
-          icon: { width: 40, height: 60 }
-        },
-        data: {
-          classList: ['unknown'],
-          size: 'small'
-        },
-        created: function () {
-          this.classList = ['icon'];
-          this.size = 'large';
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'image',
-            style: { width: 40, height: 60 },
-            attr: { src: 'path/to/A.png' }
-          }, {
-            type: 'span',
-            style: { fontSize: 24, color: '#FF6600' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'span',
-            style: { fontSize: 24, color: '#F6F0F4' },
-            attr: { value: 'EFGH' }
-          }]
-        }
-      })
-    })
-
-    it('update inline style', () => {
-      expect(compileSnippet(`
-        <richtext>
-          <span :style="styleObject">ABCD</span>
-          <span :style="{ textAlign: align, color: 'red' }">EFGH</span>
-        </richtext>
-      `, `
-        data: {
-          styleObject: { fontSize: '32px', color: '#F6F660' }
-        },
-        created: function () {
-          this.styleObject = { fontSize: '24px', color: 'blue' }
-          this.styleObject.color = '#ABCDEF'
-          this.align = 'left'
-        }
-      `)).toEqual({
-        type: 'richtext',
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: '24px', color: '#ABCDEF' },
-            attr: { value: 'ABCD' }
-          }, {
-            type: 'span',
-            style: { textAlign: 'left', color: 'red' },
-            attr: { value: 'EFGH' }
-          }]
-        }
-      })
-    })
-  })
-
-  describe('itself', () => {
-    it('inline styles', () => {
-      expect(compileSnippet(`
-        <richtext style="background-color:red">
-          <span>empty</span>
-        </richtext>
-      `)).toEqual({
-        type: 'richtext',
-        style: { backgroundColor: 'red' },
-        attr: {
-          value: [{
-            type: 'span',
-            attr: { value: 'empty' }
-          }]
-        }
-      })
-    })
-
-    it('class list', () => {
-      expect(compileSnippet(`
-        <richtext class="title">
-          <span class="large">ABCD</span>
-        </richtext>
-      `, `
-        style: {
-          title: { backgroundColor: '#FF6600', height: 200 },
-          large: { fontSize: 24 }
-        }
-      `)).toEqual({
-        type: 'richtext',
-        classList: ['title'],
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: 24 },
-            attr: { value: 'ABCD' }
-          }]
-        }
-      })
-    })
-
-    it('update styles', () => {
-      expect(compileSnippet(`
-        <richtext :class="classList" :style="{ backgroundColor: color }">
-          <span class="large">ABCD</span>
-        </richtext>
-      `, `
-        data: { classList: ['unknow'], color: '#FF6600' },
-        style: {
-          title: { height: 200 },
-          large: { fontSize: 24 }
-        },
-        created: function () {
-          this.classList = ['title']
-        }
-      `)).toEqual({
-        type: 'richtext',
-        classList: ['title'],
-        style: { backgroundColor: '#FF6600' },
-        attr: {
-          value: [{
-            type: 'span',
-            style: { fontSize: 24 },
-            attr: { value: 'ABCD' }
-          }]
-        }
-      })
-    })
-
-    it('bind events', (done) => {
-      const { render, staticRenderFns } = compileAndStringify(`
-        <div>
-          <richtext @click="handler">
-            <span>Label: {{label}}</span>
-          </richtext>
-        </div>
-      `)
-      const id = String(Date.now() * Math.random())
-      const instance = createInstance(id, `
-        new Vue({
-          el: 'body',
-          render: ${render},
-          staticRenderFns: ${staticRenderFns},
-          data: { label: 'AAA' },
-          methods: {
-            handler: function () {
-              this.label = 'BBB'
-            }
-          }
-        })
-      `)
-      const richtext = instance.document.body.children[0]
-      fireEvent(instance, richtext.ref, 'click')
-      setTimeout(() => {
-        expect(getRoot(instance).children[0]).toEqual({
-          type: 'richtext',
-          event: ['click'],
-          attr: {
-            value: [{
-              type: 'span',
-              attr: { value: 'Label: BBB' }
-            }]
-          }
-        })
-        done()
-      }, 0)
-    })
-
-    it('v-for', () => {
-      expect(compileSnippet(`
-        <div>
-          <richtext v-for="k in labels">
-            <span>{{k}}</span>
-          </richtext>
-        </div>
-      `, `
-        data: {
-          labels: ['A', 'B', 'C']
-        }
-      `)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'richtext',
-          attr: { value: [{ type: 'span', attr: { value: 'A' }}] }
-        }, {
-          type: 'richtext',
-          attr: { value: [{ type: 'span', attr: { value: 'B' }}] }
-        }, {
-          type: 'richtext',
-          attr: { value: [{ type: 'span', attr: { value: 'C' }}] }
-        }]
-      })
-    })
-  })
-})
diff --git a/test/weex/runtime/events.spec.ts b/test/weex/runtime/events.spec.ts
deleted file mode 100644
index 79ddbdb176e..00000000000
--- a/test/weex/runtime/events.spec.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-import { getRoot, fireEvent, compileAndStringify, compileAndExecute } from '../helpers/index'
-
-describe('generate events', () => {
-  it('should be bound and fired for native component', (done) => {
-    compileAndExecute(`
-      <div @click="foo">
-        <text>Hello {{x}}</text>
-      </div>
-    `, `
-      data: { x: 'World' },
-      methods: {
-        foo: function () {
-          this.x = 'Weex'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello World' }
-        }]
-      })
-      fireEvent(instance, '_root', 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        event: ['click'],
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello Weex' }
-        }]
-      })
-      done()
-    })
-  })
-
-  it('should be bound and fired by custom component', (done) => {
-    const { render, staticRenderFns } = compileAndStringify(`<text>Hello {{x}}</text>`)
-    compileAndExecute(`
-      <div>
-        <text>Hello {{x}}</text>
-        <sub @click="foo" @click.native="bar"></sub>
-      </div>
-    `, `
-      data: { x: 'World' },
-      components: {
-        sub: {
-          data: function () {
-            return { x: 'Sub' }
-          },
-          render: ${render},
-          staticRenderFns: ${staticRenderFns},
-          created: function () {
-            this.$emit('click')
-          }
-        }
-      },
-      methods: {
-        foo: function () {
-          this.x = 'Foo'
-        },
-        bar: function () {
-          this.x = 'Bar'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello Foo' }
-        }, {
-          type: 'text',
-          event: ['click'],
-          attr: { value: 'Hello Sub' }
-        }]
-      })
-      fireEvent(instance, instance.document.body.children[1].ref, 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          attr: { value: 'Hello Bar' }
-        }, {
-          type: 'text',
-          event: ['click'],
-          attr: { value: 'Hello Sub' }
-        }]
-      })
-      done()
-    })
-  })
-})
diff --git a/test/weex/runtime/framework.spec.ts b/test/weex/runtime/framework.spec.ts
deleted file mode 100644
index ac74680c41b..00000000000
--- a/test/weex/runtime/framework.spec.ts
+++ /dev/null
@@ -1,194 +0,0 @@
-import { getRoot, createInstance } from '../helpers/index'
-
-describe('framework APIs', () => {
-  it('createInstance', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-
-  it('createInstance with config', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: JSON.stringify(weex.config) }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `, { bundleType: 'Vue', bundleUrl: 'http://example.com/', a: 1, b: 2 })
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{
-        type: 'text',
-        attr: { value: '{"bundleType":"Vue","bundleUrl":"http://example.com/","a":1,"b":2,"env":{}}' }
-      }]
-    })
-  })
-
-  it('createInstance with external data', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          a: 1,
-          b: 2
-        },
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: this.a + '-' + this.b }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `, undefined, { a: 111 })
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: '111-2' }}]
-    })
-  })
-
-  it('destroyInstance', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          x: 'Hello'
-        },
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: this.x }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-    instance.$destroy()
-    setTimeout(() => {
-      expect(instance.document).toBeUndefined()
-      expect(instance.app).toBeUndefined()
-      done()
-    }, 0)
-  })
-
-  it('refreshInstance', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          x: 'Hello'
-        },
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: this.x }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-    instance.$refresh({ x: 'World' })
-    setTimeout(() => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{ type: 'text', attr: { value: 'World' }}]
-      })
-      instance.$destroy()
-      const result = instance.$refresh({ x: 'World' })
-      expect(result instanceof Error).toBe(true)
-      done()
-    })
-  })
-
-  it('registering global assets', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      Vue.component('test', {
-        render (h) {
-          return h('div', 'Hello')
-        }
-      })
-      new Vue({
-        render (h) {
-          return h('test')
-        },
-        el: 'body'
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-
-  it('adding prototype methods', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      Vue.prototype.$test = () => 'Hello'
-      const Test = {
-        render (h) {
-          return h('div', this.$test())
-        }
-      }
-      new Vue({
-        render (h) {
-          return h(Test)
-        },
-        el: 'body'
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-
-  it('using global mixins', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      Vue.mixin({
-        created () {
-          this.test = true
-        }
-      })
-      const Test = {
-        data: () => ({ test: false }),
-        render (h) {
-          return h('div', this.test ? 'Hello' : 'nope')
-        }
-      }
-      new Vue({
-        data: { test: false },
-        render (h) {
-          return this.test ? h(Test) : h('p')
-        },
-        el: 'body'
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [{ type: 'text', attr: { value: 'Hello' }}]
-    })
-  })
-})
diff --git a/test/weex/runtime/node.spec.ts b/test/weex/runtime/node.spec.ts
deleted file mode 100644
index 06a20c63a85..00000000000
--- a/test/weex/runtime/node.spec.ts
+++ /dev/null
@@ -1,513 +0,0 @@
-import {
-  compileAndStringify,
-  createInstance,
-  getRoot,
-  syncPromise,
-  checkRefresh
-} from '../helpers/index'
-
-describe('node in render function', () => {
-  it('should be generated', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, [])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }}
-      ]
-    })
-  })
-
-  it('should be generated with all types of text', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, []),
-            'World',
-            createElement('text', {}, ['Weex'])
-          ])
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }},
-        { type: 'text', attr: { value: 'World' }},
-        { type: 'text', attr: { value: 'Weex' }}
-      ]
-    })
-  })
-
-  it('should be generated with comments', () => {
-    // todo
-  })
-
-  it('should be generated with module diff', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          counter: 0
-        },
-        methods: {
-          foo: function () {}
-        },
-        render: function (createElement) {
-          switch (this.counter) {
-            case 1:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'World' }}, [])
-            ])
-
-            case 2:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'World' }, style: { fontSize: 100 }}, [])
-            ])
-
-            case 3:
-            return createElement('div', {}, [
-              createElement('text', {
-                attrs: { value: 'World' },
-                style: { fontSize: 100 },
-                on: { click: this.foo }
-              }, [])
-            ])
-
-            case 4:
-            return createElement('div', {}, [
-              createElement('text', {
-                attrs: { value: 'Weex' },
-                style: { color: '#ff0000' }
-              }, [])
-            ])
-
-            default:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, [])
-            ])
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { counter: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'World' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'World' }, style: { fontSize: 100 }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'World' }, style: { fontSize: 100 }, event: ['click'] }
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Weex' }, style: { fontSize: '', color: '#ff0000' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-
-  it('should be generated with sub components', () => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        render: function (createElement) {
-          return createElement('div', {}, [
-            createElement('text', { attrs: { value: 'Hello' }}, []),
-            createElement('foo', { props: { x: 'Weex' }})
-          ])
-        },
-        components: {
-          foo: {
-            props: {
-              x: { default: 'World' }
-            },
-            render: function (createElement) {
-              return createElement('text', { attrs: { value: this.x }}, [])
-            }
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }},
-        { type: 'text', attr: { value: 'Weex' }}
-      ]
-    })
-  })
-
-  it('should be generated with if/for diff', (done) => {
-    const { render, staticRenderFns } = compileAndStringify(`
-      <div>
-        <text v-for="item in list" v-if="item.x">{{item.v}}</text>
-      </div>
-    `)
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          list: [
-            { v: 'Hello', x: true },
-            { v: 'World', x: false },
-            { v: 'Weex', x: true }
-          ]
-        },
-        computed: {
-          x: {
-            get: function () { return 0 },
-            set: function (v) {
-              switch (v) {
-                case 1:
-                this.list[1].x = true
-                break
-                case 2:
-                this.list.push({ v: 'v-if' })
-                break
-                case 3:
-                this.list.push({ v: 'v-for', x: true })
-                break
-                case 4:
-                this.list.splice(1, 2)
-                break
-              }
-            }
-          }
-        },
-        render: ${render},
-        staticRenderFns: ${staticRenderFns},
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }},
-        { type: 'text', attr: { value: 'Weex' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { x: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { x: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { x: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }},
-            { type: 'text', attr: { value: 'v-for' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { x: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'v-for' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-
-  it('should be generated with node structure diff', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          counter: 0
-        },
-        render: function (createElement) {
-          switch (this.counter) {
-            case 1:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'World' }}, [])
-            ])
-
-            case 2:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'World' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 3:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 4:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 5:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            case 6:
-            return createElement('div', {}, [
-              createElement('input', { attrs: { value: 'Hello' }}, []),
-              createElement('text', { attrs: { value: 'Weex' }}, [])
-            ])
-
-            default:
-            return createElement('div', {}, [
-              createElement('text', { attrs: { value: 'Hello' }}, []),
-            ])
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: 'Hello' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { counter: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'World' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 5 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 6 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'input', attr: { value: 'Hello' }},
-            { type: 'text', attr: { value: 'Weex' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-
-  it('should be generated with component diff', (done) => {
-    const id = String(Date.now() * Math.random())
-    const instance = createInstance(id, `
-      new Vue({
-        data: {
-          counter: 0
-        },
-        components: {
-          foo: {
-            props: { a: { default: '1' }, b: { default: '2' }},
-            render: function (createElement) {
-              return createElement('text', { attrs: { value: this.a + '-' + this.b }}, [])
-            }
-          },
-          bar: {
-            render: function (createElement) {
-              return createElement('text', { attrs: { value: 'Bar' }, style: { fontSize: 100 }})
-            }
-          },
-          baz: {
-            render: function (createElement) {
-              return createElement('image', { attrs: { src: 'http://example.com/favicon.ico' }})
-            }
-          }
-        },
-        render: function (createElement) {
-          switch (this.counter) {
-            case 1:
-            return createElement('div', {}, [
-              createElement('foo', { props: { a: '111', b: '222' }}, [])
-            ])
-
-            case 2:
-            return createElement('div', {}, [
-              createElement('foo', {}, [])
-            ])
-
-            case 3:
-            return createElement('div', {}, [
-              createElement('bar', {}, [])
-            ])
-
-            case 4:
-            return createElement('div', {}, [
-              createElement('baz', {}, [])
-            ])
-
-            case 5:
-            return createElement('div', {}, [
-              createElement('foo', {}, []),
-              createElement('bar', {}, []),
-              createElement('baz', {}, [])
-            ])
-
-            default:
-            return createElement('div', {}, [
-              createElement('foo', { props: { a: '111' }}, [])
-            ])
-          }
-        },
-        el: "body"
-      })
-    `)
-    expect(getRoot(instance)).toEqual({
-      type: 'div',
-      children: [
-        { type: 'text', attr: { value: '111-2' }}
-      ]
-    })
-
-    syncPromise([
-      checkRefresh(instance, { counter: 1 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: '111-222' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 2 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: '1-2' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 3 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: 'Bar' }, style: { fontSize: 100 }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 4 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'image', attr: { src: 'http://example.com/favicon.ico' }}
-          ]
-        })
-      }),
-      checkRefresh(instance, { counter: 5 }, result => {
-        expect(result).toEqual({
-          type: 'div',
-          children: [
-            { type: 'text', attr: { value: '1-2' }},
-            { type: 'text', attr: { value: 'Bar' }, style: { fontSize: 100 }},
-            { type: 'image', attr: { src: 'http://example.com/favicon.ico' }}
-          ]
-        })
-        done()
-      })
-    ])
-  })
-})
diff --git a/test/weex/runtime/style.spec.ts b/test/weex/runtime/style.spec.ts
deleted file mode 100644
index 752f57580bd..00000000000
--- a/test/weex/runtime/style.spec.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-import { getRoot, fireEvent, compileAndExecute } from '../helpers/index'
-
-describe('generate style', () => {
-  it('should be generated', () => {
-    compileAndExecute(`
-      <div>
-        <text style="font-size: 100">Hello World</text>
-      </div>
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [{
-          type: 'text',
-          style: { fontSize: '100' },
-          attr: { value: 'Hello World' }
-        }]
-      })
-    })
-  })
-
-  it('should be generated by array binding', (done) => {
-    compileAndExecute(`
-      <div>
-        <text :style="[x, y]" @click="foo">Hello {{z}}</text>
-      </div>
-    `, `
-      data: {
-        x: { fontSize: 100, color: '#00ff00' },
-        y: { color: '#ff0000', fontWeight: 'bold' },
-        z: 'World'
-      },
-      methods: {
-        foo: function () {
-          this.x.fontSize = 200
-          this.x.color = '#0000ff'
-          Vue.delete(this.y, 'fontWeight')
-          this.z = 'Weex'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 100, color: '#ff0000', fontWeight: 'bold' },
-            attr: { value: 'Hello World' }
-          }
-        ]
-      })
-      fireEvent(instance, instance.document.body.children[0].ref, 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 200, color: '#ff0000', fontWeight: '' },
-            attr: { value: 'Hello Weex' }
-          }
-        ]
-      })
-      done()
-    })
-  })
-
-  it('should be generated by map binding', (done) => {
-    compileAndExecute(`
-      <div>
-        <text :style="{ fontSize: x, color: '#00ff00' }" @click="foo">Hello</text>
-        <text :style="y">{{z}}</text>
-      </div>
-    `, `
-      data: {
-        x: 100,
-        y: { color: '#ff0000', fontWeight: 'bold' },
-        z: 'World'
-      },
-      methods: {
-        foo: function () {
-          this.x = 200
-          this.y.color = '#0000ff'
-          Vue.delete(this.y, 'fontWeight')
-          this.z = 'Weex'
-        }
-      }
-    `).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 100, color: '#00ff00' },
-            attr: { value: 'Hello' }
-          },
-          {
-            type: 'text',
-            style: { color: '#ff0000', fontWeight: 'bold' },
-            attr: { value: 'World' }
-          }
-        ]
-      })
-      fireEvent(instance, instance.document.body.children[0].ref, 'click')
-      return instance
-    }).then(instance => {
-      expect(getRoot(instance)).toEqual({
-        type: 'div',
-        children: [
-          {
-            type: 'text',
-            event: ['click'],
-            style: { fontSize: 200, color: '#00ff00' },
-            attr: { value: 'Hello' }
-          },
-          {
-            type: 'text',
-            style: { color: '#0000ff', fontWeight: '' },
-            attr: { value: 'Weex' }
-          }
-        ]
-      })
-      done()
-    })
-  })
-})
diff --git a/tsconfig.json b/tsconfig.json
index 97a1c51f9bb..a762781faf9 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -29,7 +29,6 @@
       "shared/*": ["src/shared/*"],
 
       "web/*": ["src/platforms/web/*"],
-      "weex/*": ["src/platforms/weex/*"],
 
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
diff --git a/typescript/compiler.d.ts b/typescript/compiler.d.ts
index 5d2356dbe39..68d596fae82 100644
--- a/typescript/compiler.d.ts
+++ b/typescript/compiler.d.ts
@@ -175,9 +175,6 @@ declare type ASTElement = {
 
   // 2.4 ssr optimization
   ssrOptimizability?: number;
-
-  // weex specific
-  appendAsTree?: boolean;
 };
 
 declare type ASTExpression = {
diff --git a/typescript/weex.d.ts b/typescript/weex.d.ts
deleted file mode 100644
index 0427fadc589..00000000000
--- a/typescript/weex.d.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import { Component } from "./component";
-import { GlobalAPI } from "./global-api";
-
-// global flag to be compiled away
-declare const __WEEX__: boolean;
-
-// global object in Weex
-declare var WXEnvironment: WeexEnvironment;
-
-declare type Weex = {
-  config: WeexConfigAPI;
-  document: WeexDocument;
-  requireModule: (name: string) => Object | void;
-  supports: (condition: string) => boolean | void;
-  isRegisteredModule: (name: string, method?: string) => boolean;
-  isRegisteredComponent: (name: string) => boolean;
-};
-
-declare type WeexConfigAPI = {
-  bundleUrl: string; // === weex.document.URL
-  bundleType: string;
-  env: WeexEnvironment; // === WXEnvironment
-};
-
-declare type WeexEnvironment = {
-  platform: string; // could be "Web", "iOS", "Android"
-  weexVersion: string; // the version of WeexSDK
-
-  osName: string; // could be "iOS", "Android" or others
-  osVersion: string;
-  appName: string; // mobile app name or browser name
-  appVersion: string;
-
-  // information about current running device
-  deviceModel: string; // phone device model
-  deviceWidth: number;
-  deviceHeight: number;
-  scale: number;
-
-  // only available on the web
-  userAgent?: string;
-  dpr?: number;
-  rem?: number;
-};
-
-declare interface WeexDocument {
-  id: string;
-  URL: string;
-  taskCenter: WeexTaskCenter;
-
-  open: () => void;
-  close: () => void;
-  createElement: (tagName: string, props?: Object) => WeexElement;
-  createComment: (text: string) => Object;
-  fireEvent: (type: string) => void;
-  destroy: () => void;
-}
-
-declare interface WeexTaskCenter {
-  instanceId: string;
-  callbackManager: Object;
-  send: (type: string, params: Object, args: Array<any>, options?: Object) => void;
-  registerHook: (componentId: string, type: string, hook: string, fn: Function) => void;
-  updateData: (componentId: string, data: Object | void, callback?: Function) => void;
-}
-
-declare interface WeexElement {
-  nodeType: number;
-  nodeId: string;
-  type: string;
-  ref: string;
-  text?: string;
-
-  parentNode: WeexElement | void;
-  children: Array<WeexElement>;
-  previousSibling: WeexElement | void;
-  nextSibling: WeexElement | void;
-
-  appendChild: (node: WeexElement) => void;
-  removeChild: (node: WeexElement, preserved?: boolean) => void;
-  insertBefore: (node: WeexElement, before: WeexElement) => void;
-  insertAfter: (node: WeexElement, after: WeexElement) => void;
-  setAttr: (key: string, value: any, silent?: boolean) => void;
-  setAttrs: (attrs: Object, silent?: boolean) => void;
-  setStyle: (key: string, value: any, silent?: boolean) => void;
-  setStyles: (attrs: Object, silent?: boolean) => void;
-  addEvent: (type: string, handler: Function, args?: Array<any>) => void;
-  removeEvent: (type: string) => void;
-  fireEvent: (type: string) => void;
-  destroy: () => void;
-}
-
-declare type WeexInstanceOption = {
-  instanceId: string;
-  config: WeexConfigAPI;
-  document: WeexDocument;
-  Vue?: GlobalAPI;
-  app?: Component;
-  data?: Object;
-};
-
-declare type WeexRuntimeContext = {
-  weex: Weex;
-  service: Object;
-  BroadcastChannel?: Function;
-};
-
-declare type WeexInstanceContext = {
-  Vue: GlobalAPI;
-
-  // DEPRECATED
-  setTimeout?: Function;
-  clearTimeout?: Function;
-  setInterval?: Function;
-  clearInterval?: Function;
-};
-
-declare type WeexCompilerOptions = CompilerOptions & {
-  // whether to compile special template for <recycle-list>
-  recyclable?: boolean;
-};
-
-declare type WeexCompiledResult = CompiledResult & {
-  '@render'?: string;
-};
diff --git a/vitest.config.ts b/vitest.config.ts
index de4938c069e..35f7d2c68f2 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -12,7 +12,6 @@ export default defineConfig({
       sfc: resolve('src/sfc'),
       shared: resolve('src/shared'),
       web: resolve('src/platforms/web'),
-      weex: resolve('src/platforms/weex'),
       vue: resolve('src/platforms/web/entry-runtime-with-compiler')
     }
   },

From 575f07643d769424baf0147ad8e385a3ef3c022d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 14:35:56 +0800
Subject: [PATCH 053/317] build: separate src and test tsconfig

---
 .github/workflows/ci.yml                      | 71 +++++++++++++++++++
 package.json                                  |  7 +-
 .../vue-server-renderer/types/tsconfig.json   |  8 ++-
 src/core/util/error.ts                        |  8 +--
 src/core/vdom/helpers/update-listeners.ts     |  4 +-
 test/e2e/nightwatch.config.ts                 | 58 ---------------
 test/e2e/runner.ts                            | 34 ---------
 test/e2e/specs/todomvc.ts                     |  2 +-
 test/e2e/specs/tree.ts                        | 12 ++--
 test/tsconfig.json                            | 37 ++++++++++
 tsconfig.json                                 |  6 +-
 11 files changed, 131 insertions(+), 116 deletions(-)
 create mode 100644 .github/workflows/ci.yml
 delete mode 100644 test/e2e/nightwatch.config.ts
 delete mode 100644 test/e2e/runner.ts
 create mode 100644 test/tsconfig.json

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 00000000000..e0a152114b9
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,71 @@
+name: 'ci'
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+    branches:
+      - main
+jobs:
+  unit-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+
+      - name: Set node version to 16
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: 'pnpm'
+
+      - run: pnpm install
+
+      - name: Run unit tests
+        run: pnpm run test:unit
+
+  # e2e-test:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v2
+
+  #     - name: Install pnpm
+  #       uses: pnpm/action-setup@v2
+
+  #     - name: Set node version to 16
+  #       uses: actions/setup-node@v2
+  #       with:
+  #         node-version: 16
+  #         cache: 'pnpm'
+
+  #     - run: pnpm install
+
+  #     - name: Run e2e tests
+  #       run: pnpm run test:e2e
+
+  lint-and-test-dts:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+
+      - name: Set node version to 16
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: 'pnpm'
+
+      - run: pnpm install
+
+      - name: Run srouce type check
+        run: pnpm run ts-check
+
+      - name: Run eslint
+        run: pnpm run lint
+
+      - name: Run type declaration tests
+        run: pnpm run test:types
diff --git a/package.json b/package.json
index cbf67b2f71d..d08429f317f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,7 @@
 {
   "name": "vue",
   "version": "2.6.14",
+  "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
   "module": "dist/vue.runtime.esm.js",
@@ -17,17 +18,17 @@
     "dev": "rollup -w -c scripts/config.js --environment TARGET:web-full-dev",
     "dev:cjs": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-cjs-dev",
     "dev:esm": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-esm",
-    "dev:test": "karma start test/unit/karma.dev.config.ts",
     "dev:ssr": "rollup -w -c scripts/config.js --environment TARGET:web-server-renderer",
     "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:web-compiler ",
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
-    "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:cover && npm run test:e2e -- --env phantomjs && npm run test:ssr",
+    "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.ts",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
-    "ts-check": "tsc --noEmit",
+    "ts-check": "tsc -p tsconfig.json --noEmit",
+    "ts-check:test": "tsc -p test/tsconfig.json --noEmit",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
     "release": "bash scripts/release.sh",
     "release:note": "node scripts/gen-release-note.js",
diff --git a/packages/vue-server-renderer/types/tsconfig.json b/packages/vue-server-renderer/types/tsconfig.json
index 084dd317ea1..559228da74d 100644
--- a/packages/vue-server-renderer/types/tsconfig.json
+++ b/packages/vue-server-renderer/types/tsconfig.json
@@ -4,10 +4,14 @@
     "module": "commonjs",
     "moduleResolution": "node",
     "strict": true,
-    "noEmit": true
+    "noEmit": true,
+    "paths": {
+      "vue": ["../../../types/index.d.ts"]
+    }
   },
   "compileOnSave": false,
   "include": [
-    "**/*.ts"
+    "**/*.ts",
+    "../../../types"
   ]
 }
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index 48de9b40142..e336e92aa55 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -1,6 +1,6 @@
 import config from '../config'
 import { warn } from './debug'
-import { inBrowser, inWeex } from './env'
+import { inBrowser } from './env'
 import { isPromise } from 'shared/util'
 import { pushTarget, popTarget } from '../observer/dep'
 
@@ -73,11 +73,7 @@ function logError(err, vm, info) {
     warn(`Error in ${info}: "${err.toString()}"`, vm)
   }
   /* istanbul ignore else */
-  if (
-    (inBrowser || inWeex) &&
-    typeof console !== 'undefined' &&
-    !__SSR_TEST__
-  ) {
+  if (inBrowser && typeof console !== 'undefined' && !__SSR_TEST__) {
     console.error(err)
   } else {
     throw err
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index ff133d88b68..4bc2dbbaf5e 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -64,9 +64,9 @@ export function updateListeners(
   createOnceHandler: Function,
   vm: Component
 ) {
-  let name, def, cur, old, event
+  let name, cur, old, event
   for (name in on) {
-    def = cur = on[name]
+    cur = on[name]
     old = oldOn[name]
     event = normalizeEvent(name)
     if (isUndef(cur)) {
diff --git a/test/e2e/nightwatch.config.ts b/test/e2e/nightwatch.config.ts
deleted file mode 100644
index 8ec592494fe..00000000000
--- a/test/e2e/nightwatch.config.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-// http://nightwatchjs.org/guide#settings-file
-module.exports = {
-  'src_folders': ['test/e2e/specs'],
-  'output_folder': 'test/e2e/reports',
-  'custom_commands_path': ['node_modules/nightwatch-helpers/commands'],
-  'custom_assertions_path': ['node_modules/nightwatch-helpers/assertions'],
-
-  'selenium': {
-    'start_process': true,
-    'server_path': require('selenium-server').path,
-    'host': '127.0.0.1',
-    'port': 4444,
-    'cli_args': {
-      'webdriver.chrome.driver': require('chromedriver').path
-      // , 'webdriver.gecko.driver': require('geckodriver').path
-    }
-  },
-
-  'test_settings': {
-    'default': {
-      'selenium_port': 4444,
-      'selenium_host': 'localhost',
-      'silent': true,
-      'screenshots': {
-        'enabled': true,
-        'on_failure': true,
-        'on_error': false,
-        'path': 'test/e2e/screenshots'
-      }
-    },
-
-    'chrome': {
-      'desiredCapabilities': {
-        'browserName': 'chrome',
-        'javascriptEnabled': true,
-        'acceptSslCerts': true
-      }
-    },
-
-    'firefox': {
-      'desiredCapabilities': {
-        'browserName': 'firefox',
-        'javascriptEnabled': true,
-        'acceptSslCerts': true,
-        'marionette': true
-      }
-    },
-
-    'phantomjs': {
-      'desiredCapabilities': {
-        'browserName': 'phantomjs',
-        'javascriptEnabled': true,
-        'acceptSslCerts': true,
-        'phantomjs.binary.path': require('phantomjs-prebuilt').path
-      }
-    }
-  }
-}
diff --git a/test/e2e/runner.ts b/test/e2e/runner.ts
deleted file mode 100644
index 7baa4507fbb..00000000000
--- a/test/e2e/runner.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-const path = require('path')
-const spawn = require('cross-spawn')
-const httpServer = require('http-server')
-const server = httpServer.createServer({
-  root: path.resolve(__dirname, '../../')
-})
-
-server.listen(8080)
-
-let args = process.argv.slice(2)
-if (args.indexOf('--config') === -1) {
-  args = args.concat(['--config', 'test/e2e/nightwatch.config.ts'])
-}
-if (args.indexOf('--env') === -1) {
-  args = args.concat(['--env', 'chrome,phantomjs'])
-}
-const i = args.indexOf('--test')
-if (i > -1) {
-  args[i + 1] = 'test/e2e/specs/' + args[i + 1] + '.js'
-}
-
-const runner = spawn('./node_modules/.bin/nightwatch', args, {
-  stdio: 'inherit'
-})
-
-runner.on('exit', function (code) {
-  server.close()
-  process.exit(code)
-})
-
-runner.on('error', function (err) {
-  server.close()
-  throw err
-})
diff --git a/test/e2e/specs/todomvc.ts b/test/e2e/specs/todomvc.ts
index 7720b04ddd5..0e459b3253c 100644
--- a/test/e2e/specs/todomvc.ts
+++ b/test/e2e/specs/todomvc.ts
@@ -7,7 +7,7 @@ module.exports = {
       .assert.notVisible('.footer')
       .assert.count('.filters .selected', 1)
       .assert.evaluate(function () {
-        return document.querySelector('.filters .selected').textContent === 'All'
+        return document.querySelector('.filters .selected')!.textContent === 'All'
       })
 
     createNewItem('test')
diff --git a/test/e2e/specs/tree.ts b/test/e2e/specs/tree.ts
index 08df908ad44..3329c7c75d1 100644
--- a/test/e2e/specs/tree.ts
+++ b/test/e2e/specs/tree.ts
@@ -13,7 +13,7 @@ module.exports = {
       .click('.bold')
       .assert.visible('#demo ul')
       .assert.evaluate(function () {
-        return document.querySelector('#demo li ul').children.length === 4
+        return document.querySelector('#demo li ul')!.children.length === 4
       })
       .assert.containsText('#demo li div span', '[-]')
       .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
@@ -24,7 +24,7 @@ module.exports = {
       // add items to root
       .click('#demo > .item > ul > .add')
       .assert.evaluate(function () {
-        return document.querySelector('#demo li ul').children.length === 5
+        return document.querySelector('#demo li ul')!.children.length === 5
       })
       .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
       .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
@@ -35,7 +35,7 @@ module.exports = {
       // add another item
       .click('#demo > .item > ul > .add')
       .assert.evaluate(function () {
-        return document.querySelector('#demo li ul').children.length === 6
+        return document.querySelector('#demo li ul')!.children.length === 6
       })
       .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
       .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
@@ -48,7 +48,7 @@ module.exports = {
       .assert.visible('#demo ul ul')
       .assert.containsText('#demo ul > .item:nth-child(3)', '[-]')
       .assert.evaluate(function () {
-        return document.querySelector('#demo ul ul').children.length === 5
+        return document.querySelector('#demo ul ul')!.children.length === 5
       })
 
       .click('.bold')
@@ -63,8 +63,8 @@ module.exports = {
       .assert.count('.item > ul', 5)
       .assert.containsText('#demo ul > .item:nth-child(1)', '[-]')
       .assert.evaluate(function () {
-        const firstItem = document.querySelector('#demo ul > .item:nth-child(1)')
-        const ul = firstItem.querySelector('ul')
+        const firstItem = document.querySelector('#demo ul > .item:nth-child(1)')!
+        const ul = firstItem.querySelector('ul')!
         return ul.children.length === 2
       })
       .end()
diff --git a/test/tsconfig.json b/test/tsconfig.json
new file mode 100644
index 00000000000..884bf24a271
--- /dev/null
+++ b/test/tsconfig.json
@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "dist",
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+
+    "allowJs": true,
+    "noImplicitAny": false,
+    "noImplicitThis": false,
+
+    "noUnusedLocals": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "removeComments": false,
+    "jsx": "preserve",
+    "lib": ["esnext", "dom"],
+    "types": ["node", "vitest/globals"],
+    "paths": {
+      "compiler/*": ["../src/compiler/*"],
+      "core/*": ["../src/core/*"],
+
+      "server/*": ["../src/server/*"],
+      "sfc/*": ["../src/sfc/*"],
+      "shared/*": ["../src/shared/*"],
+
+      "web/*": ["../src/platforms/web/*"],
+
+      "vue": ["../src/platforms/web/entry-runtime-with-compiler"]
+    }
+  },
+  "include": ["../src", "../typescript", "."]
+}
diff --git a/tsconfig.json b/tsconfig.json
index a762781faf9..1c7470ced45 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -19,7 +19,7 @@
     "removeComments": false,
     "jsx": "preserve",
     "lib": ["esnext", "dom"],
-    "types": ["node", "vitest/globals"],
+    "types": ["node"],
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
@@ -33,7 +33,5 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "test-dts", "typescript", "test"],
-
-  "exclude": ["node_modules", "packages", "types"]
+  "include": ["src", "typescript"],
 }

From 7136e19bc82d385ed0dd817fb284ed5f26c76f30 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 15:08:58 +0800
Subject: [PATCH 054/317] chore: remove stale js file

---
 src/server/webpack-plugin/client.js | 67 -----------------------------
 1 file changed, 67 deletions(-)
 delete mode 100644 src/server/webpack-plugin/client.js

diff --git a/src/server/webpack-plugin/client.js b/src/server/webpack-plugin/client.js
deleted file mode 100644
index ec7b87578b4..00000000000
--- a/src/server/webpack-plugin/client.js
+++ /dev/null
@@ -1,67 +0,0 @@
-const hash = require('hash-sum')
-const uniq = require('lodash.uniq')
-import { isJS, isCSS, getAssetName, onEmit, stripModuleIdHash } from './util'
-
-export default class VueSSRClientPlugin {
-  constructor (options = {}) {
-    this.options = Object.assign({
-      filename: 'vue-ssr-client-manifest.json'
-    }, options)
-  }
-
-  apply (compiler) {
-    const stage = 'PROCESS_ASSETS_STAGE_ADDITIONAL'
-    onEmit(compiler, 'vue-client-plugin', stage, (compilation, cb) => {
-      const stats = compilation.getStats().toJson()
-
-      const allFiles = uniq(stats.assets
-        .map(a => a.name))
-
-      const initialFiles = uniq(Object.keys(stats.entrypoints)
-        .map(name => stats.entrypoints[name].assets)
-        .reduce((assets, all) => all.concat(assets), [])
-        .map(getAssetName)
-        .filter((file) => isJS(file) || isCSS(file)))
-
-      const asyncFiles = allFiles
-        .filter((file) => isJS(file) || isCSS(file))
-        .filter(file => initialFiles.indexOf(file) < 0)
-
-      const manifest = {
-        publicPath: stats.publicPath,
-        all: allFiles,
-        initial: initialFiles,
-        async: asyncFiles,
-        modules: { /* [identifier: string]: Array<index: number> */ }
-      }
-
-      const assetModules = stats.modules.filter(m => m.assets.length)
-      const fileToIndex = asset => manifest.all.indexOf(getAssetName(asset))
-      stats.modules.forEach(m => {
-        // ignore modules duplicated in multiple chunks
-        if (m.chunks.length === 1) {
-          const cid = m.chunks[0]
-          const chunk = stats.chunks.find(c => c.id === cid)
-          if (!chunk || !chunk.files) {
-            return
-          }
-          const id = stripModuleIdHash(m.identifier)
-          const files = manifest.modules[hash(id)] = chunk.files.map(fileToIndex)
-          // find all asset modules associated with the same chunk
-          assetModules.forEach(m => {
-            if (m.chunks.some(id => id === cid)) {
-              files.push.apply(files, m.assets.map(fileToIndex))
-            }
-          })
-        }
-      })
-
-      const json = JSON.stringify(manifest, null, 2)
-      compilation.assets[this.options.filename] = {
-        source: () => json,
-        size: () => json.length
-      }
-      cb()
-    })
-  }
-}

From 5fb1c9d62a08334393321c0b94aaa7cd07c2b40d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 15:16:14 +0800
Subject: [PATCH 055/317] test: fix ssr test imports

---
 test/ssr/ssr-bundle-render.spec.ts | 4 ++--
 test/ssr/ssr-template.spec.ts      | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/ssr/ssr-bundle-render.spec.ts b/test/ssr/ssr-bundle-render.spec.ts
index 28d82d872e5..c4f726cb690 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/test/ssr/ssr-bundle-render.spec.ts
@@ -1,7 +1,7 @@
 import LRU from 'lru-cache'
 import { compileWithWebpack } from './compile-with-webpack'
-import { createBundleRenderer } from '../../packages/vue-server-renderer'
-import VueSSRServerPlugin from '../../packages/vue-server-renderer/server-plugin'
+import { createBundleRenderer } from 'web/entry-server-renderer'
+import VueSSRServerPlugin from 'server/webpack-plugin/server'
 
 ;(global as any).__SSR_TEST__ = true
 
diff --git a/test/ssr/ssr-template.spec.ts b/test/ssr/ssr-template.spec.ts
index dc9267d9b90..6f5d6563bf3 100644
--- a/test/ssr/ssr-template.spec.ts
+++ b/test/ssr/ssr-template.spec.ts
@@ -1,7 +1,7 @@
-import Vue from '../../dist/vue.runtime.common.js'
+import Vue from 'vue'
 import { compileWithWebpack } from './compile-with-webpack'
-import { createRenderer } from '../../packages/vue-server-renderer'
-import VueSSRClientPlugin from '../../packages/vue-server-renderer/client-plugin'
+import { createRenderer } from 'web/entry-server-renderer'
+import VueSSRClientPlugin from 'server/webpack-plugin/client'
 import { createRenderer as createBundleRenderer } from './ssr-bundle-render.spec.js'
 
 ;(global as any).__SSR_TEST__ = true

From c63d43c830795e17e20e5e67fcc52b26252d994f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 15:26:18 +0800
Subject: [PATCH 056/317] build: externalize stream to avoid warning

---
 scripts/config.js | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/scripts/config.js b/scripts/config.js
index deaa2bd49cc..3d5fe7b6968 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -151,18 +151,24 @@ const builds = {
     dest: resolve('packages/vue-server-renderer/build.dev.js'),
     format: 'cjs',
     env: 'development',
-    external: Object.keys(
-      require('../packages/vue-server-renderer/package.json').dependencies
-    )
+    external: [
+      'stream',
+      ...Object.keys(
+        require('../packages/vue-server-renderer/package.json').dependencies
+      )
+    ]
   },
   'web-server-renderer-prod': {
     entry: resolve('web/entry-server-renderer.ts'),
     dest: resolve('packages/vue-server-renderer/build.prod.js'),
     format: 'cjs',
     env: 'production',
-    external: Object.keys(
-      require('../packages/vue-server-renderer/package.json').dependencies
-    )
+    external: [
+      'stream',
+      ...Object.keys(
+        require('../packages/vue-server-renderer/package.json').dependencies
+      )
+    ]
   },
   'web-server-renderer-basic': {
     entry: resolve('web/entry-server-basic-renderer.ts'),

From 3a27b6b3e1307f45ff7ab593f398fad5a41e8780 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 15:29:48 +0800
Subject: [PATCH 057/317] build: restore cjs entry files

---
 dist/vue.common.js         | 5 +++++
 dist/vue.runtime.common.js | 5 +++++
 2 files changed, 10 insertions(+)
 create mode 100644 dist/vue.common.js
 create mode 100644 dist/vue.runtime.common.js

diff --git a/dist/vue.common.js b/dist/vue.common.js
new file mode 100644
index 00000000000..3bbc37c95fc
--- /dev/null
+++ b/dist/vue.common.js
@@ -0,0 +1,5 @@
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./vue.common.prod.js')
+} else {
+  module.exports = require('./vue.common.dev.js')
+}
diff --git a/dist/vue.runtime.common.js b/dist/vue.runtime.common.js
new file mode 100644
index 00000000000..07ddaa2ccba
--- /dev/null
+++ b/dist/vue.runtime.common.js
@@ -0,0 +1,5 @@
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./vue.runtime.common.prod.js')
+} else {
+  module.exports = require('./vue.runtime.common.dev.js')
+}

From 898d1e19fc3c0a8e899767a627c2d0a09615db9d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 16:55:05 +0800
Subject: [PATCH 058/317] test: all ssr tests passing

---
 .github/workflows/ci.yml                      |   19 +
 package.json                                  |    7 +-
 pnpm-lock.yaml                                | 2005 +++++++++++++++--
 scripts/config.js                             |    3 +-
 src/core/util/error.ts                        |    2 +-
 src/global.d.ts                               |    2 -
 .../bundle-renderer/create-bundle-renderer.ts |    9 +-
 src/server/create-renderer.ts                 |   13 +-
 src/server/template-renderer/index.ts         |    7 +-
 test/ssr/compile-with-webpack.ts              |   52 +-
 test/ssr/fixtures/{app.ts => app.js}          |    0
 .../fixtures/{async-bar.ts => async-bar.js}   |    0
 .../fixtures/{async-foo.ts => async-foo.js}   |    0
 .../{cache-opt-out.ts => cache-opt-out.js}    |    0
 test/ssr/fixtures/{cache.ts => cache.js}      |    0
 test/ssr/fixtures/{error.ts => error.js}      |    0
 .../{nested-cache.ts => nested-cache.js}      |    0
 ...mise-rejection.ts => promise-rejection.js} |    0
 test/ssr/fixtures/{split.ts => split.js}      |    0
 test/ssr/ssr-basic-renderer.spec.ts           |    4 +-
 test/ssr/ssr-bundle-render.spec.ts            |  415 ++--
 test/ssr/ssr-stream.spec.ts                   |    4 +-
 test/ssr/ssr-string.spec.ts                   |    4 +-
 test/ssr/ssr-template.spec.ts                 |  619 ++---
 test/vitest.setup.ts                          |    2 -
 25 files changed, 2398 insertions(+), 769 deletions(-)
 rename test/ssr/fixtures/{app.ts => app.js} (100%)
 rename test/ssr/fixtures/{async-bar.ts => async-bar.js} (100%)
 rename test/ssr/fixtures/{async-foo.ts => async-foo.js} (100%)
 rename test/ssr/fixtures/{cache-opt-out.ts => cache-opt-out.js} (100%)
 rename test/ssr/fixtures/{cache.ts => cache.js} (100%)
 rename test/ssr/fixtures/{error.ts => error.js} (100%)
 rename test/ssr/fixtures/{nested-cache.ts => nested-cache.js} (100%)
 rename test/ssr/fixtures/{promise-rejection.ts => promise-rejection.js} (100%)
 rename test/ssr/fixtures/{split.ts => split.js} (100%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e0a152114b9..35c20a19080 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -26,6 +26,25 @@ jobs:
       - name: Run unit tests
         run: pnpm run test:unit
 
+  ssr-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
+
+      - name: Set node version to 16
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: 'pnpm'
+
+      - run: pnpm install
+
+      - name: Run SSR tests
+        run: pnpm run test:ssr
+
   # e2e-test:
   #   runs-on: ubuntu-latest
   #   steps:
diff --git a/package.json b/package.json
index d08429f317f..9082038c2d9 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,8 @@
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
     "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
-    "test:unit": "vitest run",
+    "test:unit": "vitest run test/unit",
+    "test:ssr": "vitest run test/ssr",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.ts",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
@@ -75,7 +76,7 @@
     "de-indent": "^1.0.2",
     "escodegen": "^2.0.0",
     "eslint": "^8.14.0",
-    "file-loader": "^6.2.0",
+    "file-loader": "^3.0.1",
     "fsevents": "2.3.2",
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
@@ -99,7 +100,7 @@
     "tslib": "^2.4.0",
     "typescript": "^4.6.4",
     "vitest": "^0.12.6",
-    "webpack": "^5.72.1",
+    "webpack": "^4.46.0",
     "yorkie": "^2.0.0"
   },
   "config": {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8b7db65e746..6b0ebacb2c9 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -19,7 +19,7 @@ specifiers:
   de-indent: ^1.0.2
   escodegen: ^2.0.0
   eslint: ^8.14.0
-  file-loader: ^6.2.0
+  file-loader: ^3.0.1
   fsevents: 2.3.2
   hash-sum: ^2.0.0
   he: ^1.2.0
@@ -43,7 +43,7 @@ specifiers:
   tslib: ^2.4.0
   typescript: ^4.6.4
   vitest: ^0.12.6
-  webpack: ^5.72.1
+  webpack: ^4.46.0
   yorkie: ^2.0.0
 
 devDependencies:
@@ -65,7 +65,7 @@ devDependencies:
   de-indent: 1.0.2
   escodegen: 2.0.0
   eslint: 8.15.0
-  file-loader: 6.2.0_webpack@5.72.1
+  file-loader: 3.0.1_webpack@4.46.0
   fsevents: 2.3.2
   hash-sum: 2.0.0
   he: 1.2.0
@@ -89,7 +89,7 @@ devDependencies:
   tslib: 2.4.0
   typescript: 4.6.4
   vitest: 0.12.6_jsdom@19.0.0
-  webpack: 5.72.1
+  webpack: 4.46.0
   yorkie: 2.0.0
 
 packages:
@@ -345,20 +345,6 @@ packages:
     resolution: {integrity: sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ==}
     dev: true
 
-  /@types/eslint-scope/3.7.3:
-    resolution: {integrity: sha512-PB3ldyrcnAicT35TWPs5IcwKD8S333HMaa2VVv4+wdvebJkjWuW/xESoB8IwRcog8HYVYamb1g/R31Qv5Bx03g==}
-    dependencies:
-      '@types/eslint': 8.4.2
-      '@types/estree': 0.0.51
-    dev: true
-
-  /@types/eslint/8.4.2:
-    resolution: {integrity: sha512-Z1nseZON+GEnFjJc04sv4NSALGjhFwy6K0HXt7qsn5ArfAKtb63dXNJHf+1YW6IpOIYRBGUbu3GwJdj8DGnCjA==}
-    dependencies:
-      '@types/estree': 0.0.51
-      '@types/json-schema': 7.0.11
-    dev: true
-
   /@types/estree/0.0.39:
     resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==}
     dev: true
@@ -524,109 +510,130 @@ packages:
       eslint-visitor-keys: 3.3.0
     dev: true
 
-  /@webassemblyjs/ast/1.11.1:
-    resolution: {integrity: sha512-ukBh14qFLjxTQNTXocdyksN5QdM28S1CxHt2rdskFyL+xFV7VremuBLVbmCePj+URalXBENx/9Lm7lnhihtCSw==}
+  /@webassemblyjs/ast/1.9.0:
+    resolution: {integrity: sha512-C6wW5L+b7ogSDVqymbkkvuW9kruN//YisMED04xzeBBqjHa2FYnmvOlS6Xj68xWQRgWvI9cIglsjFowH/RJyEA==}
     dependencies:
-      '@webassemblyjs/helper-numbers': 1.11.1
-      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
+      '@webassemblyjs/helper-module-context': 1.9.0
+      '@webassemblyjs/helper-wasm-bytecode': 1.9.0
+      '@webassemblyjs/wast-parser': 1.9.0
     dev: true
 
-  /@webassemblyjs/floating-point-hex-parser/1.11.1:
-    resolution: {integrity: sha512-iGRfyc5Bq+NnNuX8b5hwBrRjzf0ocrJPI6GWFodBFzmFnyvrQ83SHKhmilCU/8Jv67i4GJZBMhEzltxzcNagtQ==}
+  /@webassemblyjs/floating-point-hex-parser/1.9.0:
+    resolution: {integrity: sha512-TG5qcFsS8QB4g4MhrxK5TqfdNe7Ey/7YL/xN+36rRjl/BlGE/NcBvJcqsRgCP6Z92mRE+7N50pRIi8SmKUbcQA==}
     dev: true
 
-  /@webassemblyjs/helper-api-error/1.11.1:
-    resolution: {integrity: sha512-RlhS8CBCXfRUR/cwo2ho9bkheSXG0+NwooXcc3PAILALf2QLdFyj7KGsKRbVc95hZnhnERon4kW/D3SZpp6Tcg==}
+  /@webassemblyjs/helper-api-error/1.9.0:
+    resolution: {integrity: sha512-NcMLjoFMXpsASZFxJ5h2HZRcEhDkvnNFOAKneP5RbKRzaWJN36NC4jqQHKwStIhGXu5mUWlUUk7ygdtrO8lbmw==}
     dev: true
 
-  /@webassemblyjs/helper-buffer/1.11.1:
-    resolution: {integrity: sha512-gwikF65aDNeeXa8JxXa2BAk+REjSyhrNC9ZwdT0f8jc4dQQeDQ7G4m0f2QCLPJiMTTO6wfDmRmj/pW0PsUvIcA==}
+  /@webassemblyjs/helper-buffer/1.9.0:
+    resolution: {integrity: sha512-qZol43oqhq6yBPx7YM3m9Bv7WMV9Eevj6kMi6InKOuZxhw+q9hOkvq5e/PpKSiLfyetpaBnogSbNCfBwyB00CA==}
     dev: true
 
-  /@webassemblyjs/helper-numbers/1.11.1:
-    resolution: {integrity: sha512-vDkbxiB8zfnPdNK9Rajcey5C0w+QJugEglN0of+kmO8l7lDb77AnlKYQF7aarZuCrv+l0UvqL+68gSDr3k9LPQ==}
+  /@webassemblyjs/helper-code-frame/1.9.0:
+    resolution: {integrity: sha512-ERCYdJBkD9Vu4vtjUYe8LZruWuNIToYq/ME22igL+2vj2dQ2OOujIZr3MEFvfEaqKoVqpsFKAGsRdBSBjrIvZA==}
     dependencies:
-      '@webassemblyjs/floating-point-hex-parser': 1.11.1
-      '@webassemblyjs/helper-api-error': 1.11.1
-      '@xtuc/long': 4.2.2
+      '@webassemblyjs/wast-printer': 1.9.0
+    dev: true
+
+  /@webassemblyjs/helper-fsm/1.9.0:
+    resolution: {integrity: sha512-OPRowhGbshCb5PxJ8LocpdX9Kl0uB4XsAjl6jH/dWKlk/mzsANvhwbiULsaiqT5GZGT9qinTICdj6PLuM5gslw==}
     dev: true
 
-  /@webassemblyjs/helper-wasm-bytecode/1.11.1:
-    resolution: {integrity: sha512-PvpoOGiJwXeTrSf/qfudJhwlvDQxFgelbMqtq52WWiXC6Xgg1IREdngmPN3bs4RoO83PnL/nFrxucXj1+BX62Q==}
+  /@webassemblyjs/helper-module-context/1.9.0:
+    resolution: {integrity: sha512-MJCW8iGC08tMk2enck1aPW+BE5Cw8/7ph/VGZxwyvGbJwjktKkDK7vy7gAmMDx88D7mhDTCNKAW5tED+gZ0W8g==}
+    dependencies:
+      '@webassemblyjs/ast': 1.9.0
+    dev: true
+
+  /@webassemblyjs/helper-wasm-bytecode/1.9.0:
+    resolution: {integrity: sha512-R7FStIzyNcd7xKxCZH5lE0Bqy+hGTwS3LJjuv1ZVxd9O7eHCedSdrId/hMOd20I+v8wDXEn+bjfKDLzTepoaUw==}
     dev: true
 
-  /@webassemblyjs/helper-wasm-section/1.11.1:
-    resolution: {integrity: sha512-10P9No29rYX1j7F3EVPX3JvGPQPae+AomuSTPiF9eBQeChHI6iqjMIwR9JmOJXwpnn/oVGDk7I5IlskuMwU/pg==}
+  /@webassemblyjs/helper-wasm-section/1.9.0:
+    resolution: {integrity: sha512-XnMB8l3ek4tvrKUUku+IVaXNHz2YsJyOOmz+MMkZvh8h1uSJpSen6vYnw3IoQ7WwEuAhL8Efjms1ZWjqh2agvw==}
     dependencies:
-      '@webassemblyjs/ast': 1.11.1
-      '@webassemblyjs/helper-buffer': 1.11.1
-      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
-      '@webassemblyjs/wasm-gen': 1.11.1
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/helper-buffer': 1.9.0
+      '@webassemblyjs/helper-wasm-bytecode': 1.9.0
+      '@webassemblyjs/wasm-gen': 1.9.0
     dev: true
 
-  /@webassemblyjs/ieee754/1.11.1:
-    resolution: {integrity: sha512-hJ87QIPtAMKbFq6CGTkZYJivEwZDbQUgYd3qKSadTNOhVY7p+gfP6Sr0lLRVTaG1JjFj+r3YchoqRYxNH3M0GQ==}
+  /@webassemblyjs/ieee754/1.9.0:
+    resolution: {integrity: sha512-dcX8JuYU/gvymzIHc9DgxTzUUTLexWwt8uCTWP3otys596io0L5aW02Gb1RjYpx2+0Jus1h4ZFqjla7umFniTg==}
     dependencies:
       '@xtuc/ieee754': 1.2.0
     dev: true
 
-  /@webassemblyjs/leb128/1.11.1:
-    resolution: {integrity: sha512-BJ2P0hNZ0u+Th1YZXJpzW6miwqQUGcIHT1G/sf72gLVD9DZ5AdYTqPNbHZh6K1M5VmKvFXwGSWZADz+qBWxeRw==}
+  /@webassemblyjs/leb128/1.9.0:
+    resolution: {integrity: sha512-ENVzM5VwV1ojs9jam6vPys97B/S65YQtv/aanqnU7D8aSoHFX8GyhGg0CMfyKNIHBuAVjy3tlzd5QMMINa7wpw==}
     dependencies:
       '@xtuc/long': 4.2.2
     dev: true
 
-  /@webassemblyjs/utf8/1.11.1:
-    resolution: {integrity: sha512-9kqcxAEdMhiwQkHpkNiorZzqpGrodQQ2IGrHHxCy+Ozng0ofyMA0lTqiLkVs1uzTRejX+/O0EOT7KxqVPuXosQ==}
+  /@webassemblyjs/utf8/1.9.0:
+    resolution: {integrity: sha512-GZbQlWtopBTP0u7cHrEx+73yZKrQoBMpwkGEIqlacljhXCkVM1kMQge/Mf+csMJAjEdSwhOyLAS0AoR3AG5P8w==}
+    dev: true
+
+  /@webassemblyjs/wasm-edit/1.9.0:
+    resolution: {integrity: sha512-FgHzBm80uwz5M8WKnMTn6j/sVbqilPdQXTWraSjBwFXSYGirpkSWE2R9Qvz9tNiTKQvoKILpCuTjBKzOIm0nxw==}
+    dependencies:
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/helper-buffer': 1.9.0
+      '@webassemblyjs/helper-wasm-bytecode': 1.9.0
+      '@webassemblyjs/helper-wasm-section': 1.9.0
+      '@webassemblyjs/wasm-gen': 1.9.0
+      '@webassemblyjs/wasm-opt': 1.9.0
+      '@webassemblyjs/wasm-parser': 1.9.0
+      '@webassemblyjs/wast-printer': 1.9.0
     dev: true
 
-  /@webassemblyjs/wasm-edit/1.11.1:
-    resolution: {integrity: sha512-g+RsupUC1aTHfR8CDgnsVRVZFJqdkFHpsHMfJuWQzWU3tvnLC07UqHICfP+4XyL2tnr1amvl1Sdp06TnYCmVkA==}
+  /@webassemblyjs/wasm-gen/1.9.0:
+    resolution: {integrity: sha512-cPE3o44YzOOHvlsb4+E9qSqjc9Qf9Na1OO/BHFy4OI91XDE14MjFN4lTMezzaIWdPqHnsTodGGNP+iRSYfGkjA==}
     dependencies:
-      '@webassemblyjs/ast': 1.11.1
-      '@webassemblyjs/helper-buffer': 1.11.1
-      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
-      '@webassemblyjs/helper-wasm-section': 1.11.1
-      '@webassemblyjs/wasm-gen': 1.11.1
-      '@webassemblyjs/wasm-opt': 1.11.1
-      '@webassemblyjs/wasm-parser': 1.11.1
-      '@webassemblyjs/wast-printer': 1.11.1
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/helper-wasm-bytecode': 1.9.0
+      '@webassemblyjs/ieee754': 1.9.0
+      '@webassemblyjs/leb128': 1.9.0
+      '@webassemblyjs/utf8': 1.9.0
     dev: true
 
-  /@webassemblyjs/wasm-gen/1.11.1:
-    resolution: {integrity: sha512-F7QqKXwwNlMmsulj6+O7r4mmtAlCWfO/0HdgOxSklZfQcDu0TpLiD1mRt/zF25Bk59FIjEuGAIyn5ei4yMfLhA==}
+  /@webassemblyjs/wasm-opt/1.9.0:
+    resolution: {integrity: sha512-Qkjgm6Anhm+OMbIL0iokO7meajkzQD71ioelnfPEj6r4eOFuqm4YC3VBPqXjFyyNwowzbMD+hizmprP/Fwkl2A==}
     dependencies:
-      '@webassemblyjs/ast': 1.11.1
-      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
-      '@webassemblyjs/ieee754': 1.11.1
-      '@webassemblyjs/leb128': 1.11.1
-      '@webassemblyjs/utf8': 1.11.1
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/helper-buffer': 1.9.0
+      '@webassemblyjs/wasm-gen': 1.9.0
+      '@webassemblyjs/wasm-parser': 1.9.0
     dev: true
 
-  /@webassemblyjs/wasm-opt/1.11.1:
-    resolution: {integrity: sha512-VqnkNqnZlU5EB64pp1l7hdm3hmQw7Vgqa0KF/KCNO9sIpI6Fk6brDEiX+iCOYrvMuBWDws0NkTOxYEb85XQHHw==}
+  /@webassemblyjs/wasm-parser/1.9.0:
+    resolution: {integrity: sha512-9+wkMowR2AmdSWQzsPEjFU7njh8HTO5MqO8vjwEHuM+AMHioNqSBONRdr0NQQ3dVQrzp0s8lTcYqzUdb7YgELA==}
     dependencies:
-      '@webassemblyjs/ast': 1.11.1
-      '@webassemblyjs/helper-buffer': 1.11.1
-      '@webassemblyjs/wasm-gen': 1.11.1
-      '@webassemblyjs/wasm-parser': 1.11.1
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/helper-api-error': 1.9.0
+      '@webassemblyjs/helper-wasm-bytecode': 1.9.0
+      '@webassemblyjs/ieee754': 1.9.0
+      '@webassemblyjs/leb128': 1.9.0
+      '@webassemblyjs/utf8': 1.9.0
     dev: true
 
-  /@webassemblyjs/wasm-parser/1.11.1:
-    resolution: {integrity: sha512-rrBujw+dJu32gYB7/Lup6UhdkPx9S9SnobZzRVL7VcBH9Bt9bCBLEuX/YXOOtBsOZ4NQrRykKhffRWHvigQvOA==}
+  /@webassemblyjs/wast-parser/1.9.0:
+    resolution: {integrity: sha512-qsqSAP3QQ3LyZjNC/0jBJ/ToSxfYJ8kYyuiGvtn/8MK89VrNEfwj7BPQzJVHi0jGTRK2dGdJ5PRqhtjzoww+bw==}
     dependencies:
-      '@webassemblyjs/ast': 1.11.1
-      '@webassemblyjs/helper-api-error': 1.11.1
-      '@webassemblyjs/helper-wasm-bytecode': 1.11.1
-      '@webassemblyjs/ieee754': 1.11.1
-      '@webassemblyjs/leb128': 1.11.1
-      '@webassemblyjs/utf8': 1.11.1
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/floating-point-hex-parser': 1.9.0
+      '@webassemblyjs/helper-api-error': 1.9.0
+      '@webassemblyjs/helper-code-frame': 1.9.0
+      '@webassemblyjs/helper-fsm': 1.9.0
+      '@xtuc/long': 4.2.2
     dev: true
 
-  /@webassemblyjs/wast-printer/1.11.1:
-    resolution: {integrity: sha512-IQboUWM4eKzWW+N/jij2sRatKMh99QEelo3Eb2q0qXkvPRISAj8Qxtmw5itwqK+TTkBuUIE45AxYPToqPtL5gg==}
+  /@webassemblyjs/wast-printer/1.9.0:
+    resolution: {integrity: sha512-2J0nE95rHXHyQ24cWjMKJ1tqB/ds8z/cyeOZxJhcb+rW+SQASVjuznUSmdz5GpVJTzU8JkhYut0D3siFDD6wsA==}
     dependencies:
-      '@webassemblyjs/ast': 1.11.1
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/wast-parser': 1.9.0
       '@xtuc/long': 4.2.2
     dev: true
 
@@ -665,14 +672,6 @@ packages:
       acorn-walk: 7.2.0
     dev: true
 
-  /acorn-import-assertions/1.8.0_acorn@8.7.1:
-    resolution: {integrity: sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==}
-    peerDependencies:
-      acorn: ^8
-    dependencies:
-      acorn: 8.7.1
-    dev: true
-
   /acorn-jsx/5.3.2_acorn@8.7.1:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -691,6 +690,12 @@ packages:
     engines: {node: '>=0.4.0'}
     dev: true
 
+  /acorn/6.4.2:
+    resolution: {integrity: sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+    dev: true
+
   /acorn/7.4.1:
     resolution: {integrity: sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==}
     engines: {node: '>=0.4.0'}
@@ -724,6 +729,14 @@ packages:
       indent-string: 4.0.0
     dev: true
 
+  /ajv-errors/1.0.1_ajv@6.12.6:
+    resolution: {integrity: sha512-DCRfO/4nQ+89p/RK43i8Ezd41EqdGIU4ld7nGF8OQ14oc/we5rEntLCUa7+jrn3nn83BosfwZA0wb4pon2o8iQ==}
+    peerDependencies:
+      ajv: '>=5.0.0'
+    dependencies:
+      ajv: 6.12.6
+    dev: true
+
   /ajv-keywords/3.5.2_ajv@6.12.6:
     resolution: {integrity: sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==}
     peerDependencies:
@@ -792,6 +805,29 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
+  /anymatch/2.0.0:
+    resolution: {integrity: sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==}
+    dependencies:
+      micromatch: 3.1.10
+      normalize-path: 2.1.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+    optional: true
+
+  /anymatch/3.1.2:
+    resolution: {integrity: sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==}
+    engines: {node: '>= 8'}
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.1
+    dev: true
+    optional: true
+
+  /aproba/1.2.0:
+    resolution: {integrity: sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==}
+    dev: true
+
   /arg/4.1.3:
     resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
     dev: true
@@ -800,6 +836,21 @@ packages:
     resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
     dev: true
 
+  /arr-diff/4.0.0:
+    resolution: {integrity: sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /arr-flatten/1.1.0:
+    resolution: {integrity: sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /arr-union/3.1.0:
+    resolution: {integrity: sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /array-ify/1.0.0:
     resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}
     dev: true
@@ -809,20 +860,51 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /array-unique/0.3.2:
+    resolution: {integrity: sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /arrify/1.0.1:
     resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==}
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /asn1.js/5.4.1:
+    resolution: {integrity: sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==}
+    dependencies:
+      bn.js: 4.12.0
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+      safer-buffer: 2.1.2
+    dev: true
+
+  /assert/1.5.0:
+    resolution: {integrity: sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==}
+    dependencies:
+      object-assign: 4.1.1
+      util: 0.10.3
+    dev: true
+
   /assertion-error/1.1.0:
     resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==}
     dev: true
 
+  /assign-symbols/1.0.0:
+    resolution: {integrity: sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /astral-regex/2.0.0:
     resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
     engines: {node: '>=8'}
     dev: true
 
+  /async-each/1.0.3:
+    resolution: {integrity: sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==}
+    dev: true
+    optional: true
+
   /async/2.6.4:
     resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==}
     dependencies:
@@ -833,10 +915,33 @@ packages:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
     dev: true
 
+  /atob/2.1.2:
+    resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
+    engines: {node: '>= 4.5.0'}
+    hasBin: true
+    dev: true
+
   /balanced-match/1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
     dev: true
 
+  /base/0.11.2:
+    resolution: {integrity: sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      cache-base: 1.0.1
+      class-utils: 0.3.6
+      component-emitter: 1.3.0
+      define-property: 1.0.0
+      isobject: 3.0.1
+      mixin-deep: 1.3.2
+      pascalcase: 0.1.1
+    dev: true
+
+  /base64-js/1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+    dev: true
+
   /basic-auth/2.0.1:
     resolution: {integrity: sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==}
     engines: {node: '>= 0.8'}
@@ -848,6 +953,37 @@ packages:
     resolution: {integrity: sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==}
     dev: true
 
+  /binary-extensions/1.13.1:
+    resolution: {integrity: sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+    optional: true
+
+  /binary-extensions/2.2.0:
+    resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==}
+    engines: {node: '>=8'}
+    dev: true
+    optional: true
+
+  /bindings/1.5.0:
+    resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
+    dependencies:
+      file-uri-to-path: 1.0.0
+    dev: true
+    optional: true
+
+  /bluebird/3.7.2:
+    resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==}
+    dev: true
+
+  /bn.js/4.12.0:
+    resolution: {integrity: sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==}
+    dev: true
+
+  /bn.js/5.2.0:
+    resolution: {integrity: sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==}
+    dev: true
+
   /brace-expansion/1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
     dependencies:
@@ -855,6 +991,24 @@ packages:
       concat-map: 0.0.1
     dev: true
 
+  /braces/2.3.2:
+    resolution: {integrity: sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      arr-flatten: 1.1.0
+      array-unique: 0.3.2
+      extend-shallow: 2.0.1
+      fill-range: 4.0.0
+      isobject: 3.0.1
+      repeat-element: 1.1.4
+      snapdragon: 0.8.2
+      snapdragon-node: 2.1.1
+      split-string: 3.1.0
+      to-regex: 3.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /braces/3.0.2:
     resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}
     engines: {node: '>=8'}
@@ -862,31 +1016,129 @@ packages:
       fill-range: 7.0.1
     dev: true
 
+  /brorand/1.1.0:
+    resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==}
+    dev: true
+
   /browser-process-hrtime/1.0.0:
     resolution: {integrity: sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==}
     dev: true
 
-  /browserslist/4.20.3:
-    resolution: {integrity: sha512-NBhymBQl1zM0Y5dQT/O+xiLP9/rzOIQdKM/eMJBAq7yBgaB6krIYLGejrwVYnSHZdqjscB1SPuAjHwxjvN6Wdg==}
-    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
-    hasBin: true
+  /browserify-aes/1.2.0:
+    resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==}
     dependencies:
-      caniuse-lite: 1.0.30001341
-      electron-to-chromium: 1.4.137
-      escalade: 3.1.1
-      node-releases: 2.0.4
-      picocolors: 1.0.0
+      buffer-xor: 1.0.3
+      cipher-base: 1.0.4
+      create-hash: 1.2.0
+      evp_bytestokey: 1.0.3
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+    dev: true
+
+  /browserify-cipher/1.0.1:
+    resolution: {integrity: sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==}
+    dependencies:
+      browserify-aes: 1.2.0
+      browserify-des: 1.0.2
+      evp_bytestokey: 1.0.3
+    dev: true
+
+  /browserify-des/1.0.2:
+    resolution: {integrity: sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==}
+    dependencies:
+      cipher-base: 1.0.4
+      des.js: 1.0.1
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+    dev: true
+
+  /browserify-rsa/4.1.0:
+    resolution: {integrity: sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==}
+    dependencies:
+      bn.js: 5.2.0
+      randombytes: 2.1.0
+    dev: true
+
+  /browserify-sign/4.2.1:
+    resolution: {integrity: sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==}
+    dependencies:
+      bn.js: 5.2.0
+      browserify-rsa: 4.1.0
+      create-hash: 1.2.0
+      create-hmac: 1.1.7
+      elliptic: 6.5.4
+      inherits: 2.0.4
+      parse-asn1: 5.1.6
+      readable-stream: 3.6.0
+      safe-buffer: 5.2.1
+    dev: true
+
+  /browserify-zlib/0.2.0:
+    resolution: {integrity: sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==}
+    dependencies:
+      pako: 1.0.11
     dev: true
 
   /buffer-from/1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
     dev: true
 
+  /buffer-xor/1.0.3:
+    resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==}
+    dev: true
+
+  /buffer/4.9.2:
+    resolution: {integrity: sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg==}
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+      isarray: 1.0.0
+    dev: true
+
   /builtin-modules/3.3.0:
     resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==}
     engines: {node: '>=6'}
     dev: true
 
+  /builtin-status-codes/3.0.0:
+    resolution: {integrity: sha512-HpGFw18DgFWlncDfjTa2rcQ4W88O1mC8e8yZ2AvQY5KDaktSTwo+KRf6nHK6FRI5FyRyb/5T6+TSxfP7QyGsmQ==}
+    dev: true
+
+  /cacache/12.0.4:
+    resolution: {integrity: sha512-a0tMB40oefvuInr4Cwb3GerbL9xTj1D5yg0T5xrjGCGyfvbxseIXX7BAO/u/hIXdafzOI5JC3wDwHyf24buOAQ==}
+    dependencies:
+      bluebird: 3.7.2
+      chownr: 1.1.4
+      figgy-pudding: 3.5.2
+      glob: 7.2.3
+      graceful-fs: 4.2.10
+      infer-owner: 1.0.4
+      lru-cache: 5.1.1
+      mississippi: 3.0.0
+      mkdirp: 0.5.6
+      move-concurrently: 1.0.1
+      promise-inflight: 1.0.1_bluebird@3.7.2
+      rimraf: 2.7.1
+      ssri: 6.0.2
+      unique-filename: 1.1.1
+      y18n: 4.0.3
+    dev: true
+
+  /cache-base/1.0.1:
+    resolution: {integrity: sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      collection-visit: 1.0.0
+      component-emitter: 1.3.0
+      get-value: 2.0.6
+      has-value: 1.0.0
+      isobject: 3.0.1
+      set-value: 2.0.1
+      to-object-path: 0.3.0
+      union-value: 1.0.1
+      unset-value: 1.0.0
+    dev: true
+
   /cachedir/2.2.0:
     resolution: {integrity: sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==}
     engines: {node: '>=6'}
@@ -918,10 +1170,6 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /caniuse-lite/1.0.30001341:
-    resolution: {integrity: sha512-2SodVrFFtvGENGCv0ChVJIDQ0KPaS1cg7/qtfMaICgeMolDdo/Z2OD32F0Aq9yl6F4YFwGPBS5AaPqNYiW4PoA==}
-    dev: true
-
   /chai/4.3.6:
     resolution: {integrity: sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q==}
     engines: {node: '>=4'}
@@ -960,6 +1208,49 @@ packages:
     resolution: {integrity: sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==}
     dev: true
 
+  /chokidar/2.1.8:
+    resolution: {integrity: sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==}
+    deprecated: Chokidar 2 does not receive security updates since 2019. Upgrade to chokidar 3 with 15x fewer dependencies
+    dependencies:
+      anymatch: 2.0.0
+      async-each: 1.0.3
+      braces: 2.3.2
+      glob-parent: 3.1.0
+      inherits: 2.0.4
+      is-binary-path: 1.0.1
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      path-is-absolute: 1.0.1
+      readdirp: 2.2.1
+      upath: 1.2.0
+    optionalDependencies:
+      fsevents: 1.2.13
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+    optional: true
+
+  /chokidar/3.5.3:
+    resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==}
+    engines: {node: '>= 8.10.0'}
+    requiresBuild: true
+    dependencies:
+      anymatch: 3.1.2
+      braces: 3.0.2
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.2
+    dev: true
+    optional: true
+
+  /chownr/1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+    dev: true
+
   /chrome-trace-event/1.0.3:
     resolution: {integrity: sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==}
     engines: {node: '>=6.0'}
@@ -969,6 +1260,23 @@ packages:
     resolution: {integrity: sha512-vsGdkwSCDpWmP80ncATX7iea5DWQemg1UgCW5J8tqjU3lYw4FBYuj89J0CTVomA7BEfvSZd84GmHko+MxFQU2A==}
     dev: true
 
+  /cipher-base/1.0.4:
+    resolution: {integrity: sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==}
+    dependencies:
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+    dev: true
+
+  /class-utils/0.3.6:
+    resolution: {integrity: sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      arr-union: 3.1.0
+      define-property: 0.2.5
+      isobject: 3.0.1
+      static-extend: 0.1.2
+    dev: true
+
   /clean-stack/2.2.0:
     resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
     engines: {node: '>=6'}
@@ -1016,6 +1324,14 @@ packages:
       wrap-ansi: 7.0.0
     dev: true
 
+  /collection-visit/1.0.0:
+    resolution: {integrity: sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      map-visit: 1.0.0
+      object-visit: 1.0.1
+    dev: true
+
   /color-convert/1.9.3:
     resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
     dependencies:
@@ -1092,10 +1408,32 @@ packages:
       dot-prop: 5.3.0
     dev: true
 
+  /component-emitter/1.3.0:
+    resolution: {integrity: sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==}
+    dev: true
+
   /concat-map/0.0.1:
     resolution: {integrity: sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=}
     dev: true
 
+  /concat-stream/1.6.2:
+    resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==}
+    engines: {'0': node >= 0.8}
+    dependencies:
+      buffer-from: 1.1.2
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+      typedarray: 0.0.6
+    dev: true
+
+  /console-browserify/1.2.0:
+    resolution: {integrity: sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==}
+    dev: true
+
+  /constants-browserify/1.0.0:
+    resolution: {integrity: sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=}
+    dev: true
+
   /conventional-changelog-angular/5.0.13:
     resolution: {integrity: sha512-i/gipMxs7s8L/QeuavPF2hLnJgH6pEZAttySB6aiQLWcX3puWDL3ACVmvBhJGxnAy52Qc15ua26BufY6KpmrVA==}
     engines: {node: '>=10'}
@@ -1246,6 +1584,22 @@ packages:
       through2: 4.0.2
     dev: true
 
+  /copy-concurrently/1.0.5:
+    resolution: {integrity: sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==}
+    dependencies:
+      aproba: 1.2.0
+      fs-write-stream-atomic: 1.0.10
+      iferr: 0.1.5
+      mkdirp: 0.5.6
+      rimraf: 2.7.1
+      run-queue: 1.0.3
+    dev: true
+
+  /copy-descriptor/0.1.1:
+    resolution: {integrity: sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /core-util-is/1.0.3:
     resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
     dev: true
@@ -1284,6 +1638,34 @@ packages:
     dev: true
     optional: true
 
+  /create-ecdh/4.0.4:
+    resolution: {integrity: sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==}
+    dependencies:
+      bn.js: 4.12.0
+      elliptic: 6.5.4
+    dev: true
+
+  /create-hash/1.2.0:
+    resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==}
+    dependencies:
+      cipher-base: 1.0.4
+      inherits: 2.0.4
+      md5.js: 1.3.5
+      ripemd160: 2.0.2
+      sha.js: 2.4.11
+    dev: true
+
+  /create-hmac/1.1.7:
+    resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==}
+    dependencies:
+      cipher-base: 1.0.4
+      create-hash: 1.2.0
+      inherits: 2.0.4
+      ripemd160: 2.0.2
+      safe-buffer: 5.2.1
+      sha.js: 2.4.11
+    dev: true
+
   /create-require/1.1.1:
     resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
     dev: true
@@ -1305,6 +1687,22 @@ packages:
       which: 2.0.2
     dev: true
 
+  /crypto-browserify/3.12.0:
+    resolution: {integrity: sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==}
+    dependencies:
+      browserify-cipher: 1.0.1
+      browserify-sign: 4.2.1
+      create-ecdh: 4.0.4
+      create-hash: 1.2.0
+      create-hmac: 1.1.7
+      diffie-hellman: 5.0.3
+      inherits: 2.0.4
+      pbkdf2: 3.1.2
+      public-encrypt: 4.0.3
+      randombytes: 2.1.0
+      randomfill: 1.0.4
+    dev: true
+
   /cssom/0.3.8:
     resolution: {integrity: sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==}
     dev: true
@@ -1320,6 +1718,10 @@ packages:
       cssom: 0.3.8
     dev: true
 
+  /cyclist/1.0.1:
+    resolution: {integrity: sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=}
+    dev: true
+
   /cz-conventional-changelog/3.2.0:
     resolution: {integrity: sha512-yAYxeGpVi27hqIilG1nh4A9Bnx4J3Ov+eXy4koL3drrR+IO9GaWPsKjik20ht608Asqi8TQPf0mczhEeyAtMzg==}
     engines: {node: '>= 10'}
@@ -1376,6 +1778,17 @@ packages:
     resolution: {integrity: sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=}
     dev: true
 
+  /debug/2.6.9:
+    resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.0.0
+    dev: true
+
   /debug/3.2.7:
     resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
     peerDependencies:
@@ -1429,6 +1842,11 @@ packages:
     resolution: {integrity: sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ==}
     dev: true
 
+  /decode-uri-component/0.2.0:
+    resolution: {integrity: sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=}
+    engines: {node: '>=0.10'}
+    dev: true
+
   /dedent/0.7.0:
     resolution: {integrity: sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=}
     dev: true
@@ -1449,26 +1867,63 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /delayed-stream/1.0.0:
-    resolution: {integrity: sha1-3zrhmayt+31ECqrgsp4icrJOxhk=}
-    engines: {node: '>=0.4.0'}
+  /define-property/0.2.5:
+    resolution: {integrity: sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-descriptor: 0.1.6
     dev: true
 
-  /detect-file/1.0.0:
-    resolution: {integrity: sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=}
+  /define-property/1.0.0:
+    resolution: {integrity: sha1-dp66rz9KY6rTr56NMEybvnm/sOY=}
     engines: {node: '>=0.10.0'}
+    dependencies:
+      is-descriptor: 1.0.2
     dev: true
 
-  /detect-indent/6.0.0:
-    resolution: {integrity: sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==}
-    engines: {node: '>=8'}
+  /define-property/2.0.2:
+    resolution: {integrity: sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-descriptor: 1.0.2
+      isobject: 3.0.1
     dev: true
 
-  /diff/4.0.2:
-    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
+  /delayed-stream/1.0.0:
+    resolution: {integrity: sha1-3zrhmayt+31ECqrgsp4icrJOxhk=}
+    engines: {node: '>=0.4.0'}
+    dev: true
+
+  /des.js/1.0.1:
+    resolution: {integrity: sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==}
+    dependencies:
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+    dev: true
+
+  /detect-file/1.0.0:
+    resolution: {integrity: sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /detect-indent/6.0.0:
+    resolution: {integrity: sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /diff/4.0.2:
+    resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
     engines: {node: '>=0.3.1'}
     dev: true
 
+  /diffie-hellman/5.0.3:
+    resolution: {integrity: sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==}
+    dependencies:
+      bn.js: 4.12.0
+      miller-rabin: 4.0.1
+      randombytes: 2.1.0
+    dev: true
+
   /dir-glob/3.0.1:
     resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
     engines: {node: '>=8'}
@@ -1483,6 +1938,11 @@ packages:
       esutils: 2.0.3
     dev: true
 
+  /domain-browser/1.2.0:
+    resolution: {integrity: sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==}
+    engines: {node: '>=0.4', npm: '>=1.2'}
+    dev: true
+
   /domexception/4.0.0:
     resolution: {integrity: sha512-A2is4PLG+eeSfoTMA95/s4pvAoSo2mKtiM5jlHkAVewmiO8ISFTFKZjH7UAM1Atli/OT/7JHOrJRJiMKUZKYBw==}
     engines: {node: '>=12'}
@@ -1497,12 +1957,29 @@ packages:
       is-obj: 2.0.0
     dev: true
 
+  /duplexify/3.7.1:
+    resolution: {integrity: sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==}
+    dependencies:
+      end-of-stream: 1.4.4
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+      stream-shift: 1.0.1
+    dev: true
+
   /eastasianwidth/0.2.0:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
     dev: true
 
-  /electron-to-chromium/1.4.137:
-    resolution: {integrity: sha512-0Rcpald12O11BUogJagX3HsCN3FE83DSqWjgXoHo5a72KUKMSfI39XBgJpgNNxS9fuGzytaFjE06kZkiVFy2qA==}
+  /elliptic/6.5.4:
+    resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==}
+    dependencies:
+      bn.js: 4.12.0
+      brorand: 1.1.0
+      hash.js: 1.1.7
+      hmac-drbg: 1.0.1
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+      minimalistic-crypto-utils: 1.0.1
     dev: true
 
   /emoji-regex/8.0.0:
@@ -1518,12 +1995,19 @@ packages:
     engines: {node: '>= 4'}
     dev: true
 
-  /enhanced-resolve/5.9.3:
-    resolution: {integrity: sha512-Bq9VSor+kjvW3f9/MiiR4eE3XYgOl7/rS8lnSxbRbF3kS0B2r+Y9w5krBWxZgDxASVZbdYrn5wT4j/Wb0J9qow==}
-    engines: {node: '>=10.13.0'}
+  /end-of-stream/1.4.4:
+    resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==}
+    dependencies:
+      once: 1.4.0
+    dev: true
+
+  /enhanced-resolve/4.5.0:
+    resolution: {integrity: sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==}
+    engines: {node: '>=6.9.0'}
     dependencies:
       graceful-fs: 4.2.10
-      tapable: 2.2.1
+      memory-fs: 0.5.0
+      tapable: 1.1.3
     dev: true
 
   /errno/0.1.8:
@@ -1539,10 +2023,6 @@ packages:
       is-arrayish: 0.2.1
     dev: true
 
-  /es-module-lexer/0.9.3:
-    resolution: {integrity: sha512-1HQ2M2sPtxwnvOvT1ZClHyQDiggdNjURWpY2we6aMKCQiUVxTmVs2UYPLIrD84sS+kMdUwfBSylbJPwNnBrnHQ==}
-    dev: true
-
   /esbuild-android-64/0.14.39:
     resolution: {integrity: sha512-EJOu04p9WgZk0UoKTqLId9VnIsotmI/Z98EXrKURGb3LPNunkeffqQIkjS2cAvidh+OK5uVrXaIP229zK6GvhQ==}
     engines: {node: '>=12'}
@@ -1779,6 +2259,14 @@ packages:
       source-map: 0.6.1
     dev: true
 
+  /eslint-scope/4.0.3:
+    resolution: {integrity: sha512-p7VutNr1O/QrxysMo3E45FjYDTeXBy0iTltPFNSqKAIfjDSXC+4dj+qfyuD8bfAXrW/y6lW3O76VaYNPKfpKrg==}
+    engines: {node: '>=4.0.0'}
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 4.3.0
+    dev: true
+
   /eslint-scope/5.1.1:
     resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==}
     engines: {node: '>=8.0.0'}
@@ -1920,6 +2408,13 @@ packages:
     engines: {node: '>=0.8.x'}
     dev: true
 
+  /evp_bytestokey/1.0.3:
+    resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==}
+    dependencies:
+      md5.js: 1.3.5
+      safe-buffer: 5.2.1
+    dev: true
+
   /execa/0.8.0:
     resolution: {integrity: sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=}
     engines: {node: '>=4'}
@@ -1948,6 +2443,21 @@ packages:
       strip-final-newline: 2.0.0
     dev: true
 
+  /expand-brackets/2.1.4:
+    resolution: {integrity: sha1-t3c14xXOMPa27/D4OwQVGiJEliI=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      debug: 2.6.9
+      define-property: 0.2.5
+      extend-shallow: 2.0.1
+      posix-character-classes: 0.1.1
+      regex-not: 1.0.2
+      snapdragon: 0.8.2
+      to-regex: 3.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /expand-tilde/2.0.2:
     resolution: {integrity: sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=}
     engines: {node: '>=0.10.0'}
@@ -1955,6 +2465,21 @@ packages:
       homedir-polyfill: 1.0.3
     dev: true
 
+  /extend-shallow/2.0.1:
+    resolution: {integrity: sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-extendable: 0.1.1
+    dev: true
+
+  /extend-shallow/3.0.2:
+    resolution: {integrity: sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      assign-symbols: 1.0.0
+      is-extendable: 1.0.1
+    dev: true
+
   /external-editor/3.1.0:
     resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
     engines: {node: '>=4'}
@@ -1964,6 +2489,22 @@ packages:
       tmp: 0.0.33
     dev: true
 
+  /extglob/2.0.4:
+    resolution: {integrity: sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      array-unique: 0.3.2
+      define-property: 1.0.0
+      expand-brackets: 2.1.4
+      extend-shallow: 2.0.1
+      fragment-cache: 0.2.1
+      regex-not: 1.0.2
+      snapdragon: 0.8.2
+      to-regex: 3.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /fast-deep-equal/3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
     dev: true
@@ -1993,6 +2534,10 @@ packages:
       reusify: 1.0.4
     dev: true
 
+  /figgy-pudding/3.5.2:
+    resolution: {integrity: sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw==}
+    dev: true
+
   /figures/2.0.0:
     resolution: {integrity: sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=}
     engines: {node: '>=4'}
@@ -2007,15 +2552,30 @@ packages:
       flat-cache: 3.0.4
     dev: true
 
-  /file-loader/6.2.0_webpack@5.72.1:
-    resolution: {integrity: sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==}
-    engines: {node: '>= 10.13.0'}
+  /file-loader/3.0.1_webpack@4.46.0:
+    resolution: {integrity: sha512-4sNIOXgtH/9WZq4NvlfU3Opn5ynUsqBwSLyM+I7UOwdGigTBYfVVQEwe/msZNX/j4pCJTIM14Fsw66Svo1oVrw==}
+    engines: {node: '>= 6.9.0'}
     peerDependencies:
-      webpack: ^4.0.0 || ^5.0.0
+      webpack: ^4.0.0
+    dependencies:
+      loader-utils: 1.4.0
+      schema-utils: 1.0.0
+      webpack: 4.46.0
+    dev: true
+
+  /file-uri-to-path/1.0.0:
+    resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
+    dev: true
+    optional: true
+
+  /fill-range/4.0.0:
+    resolution: {integrity: sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=}
+    engines: {node: '>=0.10.0'}
     dependencies:
-      loader-utils: 2.0.2
-      schema-utils: 3.1.1
-      webpack: 5.72.1
+      extend-shallow: 2.0.1
+      is-number: 3.0.0
+      repeat-string: 1.6.1
+      to-regex-range: 2.1.1
     dev: true
 
   /fill-range/7.0.1:
@@ -2025,6 +2585,15 @@ packages:
       to-regex-range: 5.0.1
     dev: true
 
+  /find-cache-dir/2.1.0:
+    resolution: {integrity: sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      commondir: 1.0.1
+      make-dir: 2.1.0
+      pkg-dir: 3.0.0
+    dev: true
+
   /find-cache-dir/3.3.2:
     resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==}
     engines: {node: '>=8'}
@@ -2052,6 +2621,13 @@ packages:
       locate-path: 2.0.0
     dev: true
 
+  /find-up/3.0.0:
+    resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==}
+    engines: {node: '>=6'}
+    dependencies:
+      locate-path: 3.0.0
+    dev: true
+
   /find-up/4.1.0:
     resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
     engines: {node: '>=8'}
@@ -2090,6 +2666,13 @@ packages:
     resolution: {integrity: sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==}
     dev: true
 
+  /flush-write-stream/1.1.1:
+    resolution: {integrity: sha512-3Z4XhFZ3992uIq0XOqb9AreonueSYphE6oYbpt5+3u06JWklbsPkNv3ZKkP9Bz/r+1MWCaMoSQ28P85+1Yc77w==}
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+    dev: true
+
   /follow-redirects/1.15.0:
     resolution: {integrity: sha512-aExlJShTV4qOUOL7yF1U5tvLCB0xQuudbf6toyYA0E/acBNw71mvjFTnLaRp50aQaYocMR0a/RMMBIHeZnGyjQ==}
     engines: {node: '>=4.0'}
@@ -2100,6 +2683,11 @@ packages:
         optional: true
     dev: true
 
+  /for-in/1.0.2:
+    resolution: {integrity: sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /form-data/4.0.0:
     resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==}
     engines: {node: '>= 6'}
@@ -2109,6 +2697,20 @@ packages:
       mime-types: 2.1.35
     dev: true
 
+  /fragment-cache/0.2.1:
+    resolution: {integrity: sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      map-cache: 0.2.2
+    dev: true
+
+  /from2/2.3.0:
+    resolution: {integrity: sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=}
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+    dev: true
+
   /fs-extra/10.1.0:
     resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==}
     engines: {node: '>=12'}
@@ -2127,10 +2729,31 @@ packages:
       universalify: 0.1.2
     dev: true
 
+  /fs-write-stream-atomic/1.0.10:
+    resolution: {integrity: sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=}
+    dependencies:
+      graceful-fs: 4.2.10
+      iferr: 0.1.5
+      imurmurhash: 0.1.4
+      readable-stream: 2.3.7
+    dev: true
+
   /fs.realpath/1.0.0:
     resolution: {integrity: sha1-FQStJSMVjKpA20onh8sBQRmU6k8=}
     dev: true
 
+  /fsevents/1.2.13:
+    resolution: {integrity: sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==}
+    engines: {node: '>= 4.0'}
+    os: [darwin]
+    deprecated: fsevents 1 will break on node v14+ and could be using insecure binaries. Upgrade to fsevents 2.
+    requiresBuild: true
+    dependencies:
+      bindings: 1.5.0
+      nan: 2.15.0
+    dev: true
+    optional: true
+
   /fsevents/2.3.2:
     resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
@@ -2183,6 +2806,11 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
+  /get-value/2.0.6:
+    resolution: {integrity: sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /git-raw-commits/2.0.11:
     resolution: {integrity: sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==}
     engines: {node: '>=10'}
@@ -2218,6 +2846,14 @@ packages:
       ini: 1.3.8
     dev: true
 
+  /glob-parent/3.1.0:
+    resolution: {integrity: sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=}
+    dependencies:
+      is-glob: 3.1.0
+      path-dirname: 1.0.2
+    dev: true
+    optional: true
+
   /glob-parent/5.1.2:
     resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
     engines: {node: '>= 6'}
@@ -2232,10 +2868,6 @@ packages:
       is-glob: 4.0.3
     dev: true
 
-  /glob-to-regexp/0.4.1:
-    resolution: {integrity: sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==}
-    dev: true
-
   /glob/7.1.4:
     resolution: {integrity: sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==}
     dependencies:
@@ -2342,6 +2974,37 @@ packages:
     engines: {node: '>= 0.4'}
     dev: true
 
+  /has-value/0.3.1:
+    resolution: {integrity: sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      get-value: 2.0.6
+      has-values: 0.1.4
+      isobject: 2.1.0
+    dev: true
+
+  /has-value/1.0.0:
+    resolution: {integrity: sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      get-value: 2.0.6
+      has-values: 1.0.0
+      isobject: 3.0.1
+    dev: true
+
+  /has-values/0.1.4:
+    resolution: {integrity: sha1-bWHeldkd/Km5oCCJrThL/49it3E=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /has-values/1.0.0:
+    resolution: {integrity: sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-number: 3.0.0
+      kind-of: 4.0.0
+    dev: true
+
   /has/1.0.3:
     resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==}
     engines: {node: '>= 0.4.0'}
@@ -2349,15 +3012,39 @@ packages:
       function-bind: 1.1.1
     dev: true
 
+  /hash-base/3.1.0:
+    resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==}
+    engines: {node: '>=4'}
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 3.6.0
+      safe-buffer: 5.2.1
+    dev: true
+
   /hash-sum/2.0.0:
     resolution: {integrity: sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==}
     dev: true
 
+  /hash.js/1.1.7:
+    resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==}
+    dependencies:
+      inherits: 2.0.4
+      minimalistic-assert: 1.0.1
+    dev: true
+
   /he/1.2.0:
     resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
     hasBin: true
     dev: true
 
+  /hmac-drbg/1.0.1:
+    resolution: {integrity: sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=}
+    dependencies:
+      hash.js: 1.1.7
+      minimalistic-assert: 1.0.1
+      minimalistic-crypto-utils: 1.0.1
+    dev: true
+
   /homedir-polyfill/1.0.3:
     resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==}
     engines: {node: '>=0.10.0'}
@@ -2428,6 +3115,10 @@ packages:
       - supports-color
     dev: true
 
+  /https-browserify/1.0.0:
+    resolution: {integrity: sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=}
+    dev: true
+
   /https-proxy-agent/5.0.1:
     resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
     engines: {node: '>= 6'}
@@ -2457,6 +3148,14 @@ packages:
       safer-buffer: 2.1.2
     dev: true
 
+  /ieee754/1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+    dev: true
+
+  /iferr/0.1.5:
+    resolution: {integrity: sha1-xg7taebY/bazEEofy8ocGS3FtQE=}
+    dev: true
+
   /ignore/5.2.0:
     resolution: {integrity: sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==}
     engines: {node: '>= 4'}
@@ -2480,6 +3179,10 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /infer-owner/1.0.4:
+    resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==}
+    dev: true
+
   /inflight/1.0.6:
     resolution: {integrity: sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=}
     dependencies:
@@ -2487,6 +3190,14 @@ packages:
       wrappy: 1.0.2
     dev: true
 
+  /inherits/2.0.1:
+    resolution: {integrity: sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=}
+    dev: true
+
+  /inherits/2.0.3:
+    resolution: {integrity: sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=}
+    dev: true
+
   /inherits/2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
     dev: true
@@ -2519,10 +3230,44 @@ packages:
     engines: {node: '>= 0.10'}
     dev: true
 
+  /is-accessor-descriptor/0.1.6:
+    resolution: {integrity: sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 3.2.2
+    dev: true
+
+  /is-accessor-descriptor/1.0.0:
+    resolution: {integrity: sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 6.0.3
+    dev: true
+
   /is-arrayish/0.2.1:
     resolution: {integrity: sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=}
     dev: true
 
+  /is-binary-path/1.0.1:
+    resolution: {integrity: sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      binary-extensions: 1.13.1
+    dev: true
+    optional: true
+
+  /is-binary-path/2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+    dependencies:
+      binary-extensions: 2.2.0
+    dev: true
+    optional: true
+
+  /is-buffer/1.1.6:
+    resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==}
+    dev: true
+
   /is-builtin-module/3.1.0:
     resolution: {integrity: sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==}
     engines: {node: '>=6'}
@@ -2543,6 +3288,50 @@ packages:
       has: 1.0.3
     dev: true
 
+  /is-data-descriptor/0.1.4:
+    resolution: {integrity: sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 3.2.2
+    dev: true
+
+  /is-data-descriptor/1.0.0:
+    resolution: {integrity: sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 6.0.3
+    dev: true
+
+  /is-descriptor/0.1.6:
+    resolution: {integrity: sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-accessor-descriptor: 0.1.6
+      is-data-descriptor: 0.1.4
+      kind-of: 5.1.0
+    dev: true
+
+  /is-descriptor/1.0.2:
+    resolution: {integrity: sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-accessor-descriptor: 1.0.0
+      is-data-descriptor: 1.0.0
+      kind-of: 6.0.3
+    dev: true
+
+  /is-extendable/0.1.1:
+    resolution: {integrity: sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /is-extendable/1.0.1:
+    resolution: {integrity: sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-plain-object: 2.0.4
+    dev: true
+
   /is-extglob/2.1.1:
     resolution: {integrity: sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=}
     engines: {node: '>=0.10.0'}
@@ -2563,6 +3352,14 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
+  /is-glob/3.1.0:
+    resolution: {integrity: sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-extglob: 2.1.1
+    dev: true
+    optional: true
+
   /is-glob/4.0.3:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
@@ -2574,6 +3371,13 @@ packages:
     resolution: {integrity: sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=}
     dev: true
 
+  /is-number/3.0.0:
+    resolution: {integrity: sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 3.2.2
+    dev: true
+
   /is-number/7.0.0:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
@@ -2589,6 +3393,13 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /is-plain-object/2.0.4:
+    resolution: {integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      isobject: 3.0.1
+    dev: true
+
   /is-potential-custom-element-name/1.0.1:
     resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
     dev: true
@@ -2625,6 +3436,11 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /is-wsl/1.1.0:
+    resolution: {integrity: sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0=}
+    engines: {node: '>=4'}
+    dev: true
+
   /isarray/1.0.0:
     resolution: {integrity: sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=}
     dev: true
@@ -2633,13 +3449,16 @@ packages:
     resolution: {integrity: sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=}
     dev: true
 
-  /jest-worker/27.5.1:
-    resolution: {integrity: sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==}
-    engines: {node: '>= 10.13.0'}
+  /isobject/2.1.0:
+    resolution: {integrity: sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=}
+    engines: {node: '>=0.10.0'}
     dependencies:
-      '@types/node': 17.0.34
-      merge-stream: 2.0.0
-      supports-color: 8.1.1
+      isarray: 1.0.0
+    dev: true
+
+  /isobject/3.0.1:
+    resolution: {integrity: sha1-TkMekrEalzFjaqH5yNHMvP2reN8=}
+    engines: {node: '>=0.10.0'}
     dev: true
 
   /js-tokens/4.0.0:
@@ -2715,10 +3534,11 @@ packages:
     resolution: {integrity: sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=}
     dev: true
 
-  /json5/2.2.1:
-    resolution: {integrity: sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA==}
-    engines: {node: '>=6'}
+  /json5/1.0.1:
+    resolution: {integrity: sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==}
     hasBin: true
+    dependencies:
+      minimist: 1.2.6
     dev: true
 
   /jsonfile/4.0.0:
@@ -2740,6 +3560,25 @@ packages:
     engines: {'0': node >= 0.2.0}
     dev: true
 
+  /kind-of/3.2.2:
+    resolution: {integrity: sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-buffer: 1.1.6
+    dev: true
+
+  /kind-of/4.0.0:
+    resolution: {integrity: sha1-IIE989cSkosgc3hpGkUGb65y3Vc=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-buffer: 1.1.6
+    dev: true
+
+  /kind-of/5.1.0:
+    resolution: {integrity: sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /kind-of/6.0.3:
     resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
     engines: {node: '>=0.10.0'}
@@ -2822,18 +3661,18 @@ packages:
       strip-bom: 3.0.0
     dev: true
 
-  /loader-runner/4.3.0:
-    resolution: {integrity: sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==}
-    engines: {node: '>=6.11.5'}
+  /loader-runner/2.4.0:
+    resolution: {integrity: sha512-Jsmr89RcXGIwivFY21FcRrisYZfvLMTWx5kOLc+JTxtpBOG6xML0vzbc6SEQG2FO9/4Fc3wW4LVcB5DmGflaRw==}
+    engines: {node: '>=4.3.0 <5.0.0 || >=5.10'}
     dev: true
 
-  /loader-utils/2.0.2:
-    resolution: {integrity: sha512-TM57VeHptv569d/GKh6TAYdzKblwDNiumOdkFnejjD0XwTH87K90w3O7AiJRqdQoXygvi1VQTJTLGhJl7WqA7A==}
-    engines: {node: '>=8.9.0'}
+  /loader-utils/1.4.0:
+    resolution: {integrity: sha512-qH0WSMBtn/oHuwjy/NucEgbx5dbxxnxup9s4PVXJUDHZBQY+s0NWA9rJf53RBnQZxfch7euUui7hpoAPvALZdA==}
+    engines: {node: '>=4.0.0'}
     dependencies:
       big.js: 5.2.2
       emojis-list: 3.0.0
-      json5: 2.2.1
+      json5: 1.0.1
     dev: true
 
   /local-pkg/0.4.1:
@@ -2849,6 +3688,14 @@ packages:
       path-exists: 3.0.0
     dev: true
 
+  /locate-path/3.0.0:
+    resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==}
+    engines: {node: '>=6'}
+    dependencies:
+      p-locate: 3.0.0
+      path-exists: 3.0.0
+    dev: true
+
   /locate-path/5.0.0:
     resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
     engines: {node: '>=8'}
@@ -2932,6 +3779,12 @@ packages:
       yallist: 2.1.2
     dev: true
 
+  /lru-cache/5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+    dependencies:
+      yallist: 3.1.1
+    dev: true
+
   /lru-cache/6.0.0:
     resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
     engines: {node: '>=10'}
@@ -2950,6 +3803,14 @@ packages:
       sourcemap-codec: 1.4.8
     dev: true
 
+  /make-dir/2.1.0:
+    resolution: {integrity: sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==}
+    engines: {node: '>=6'}
+    dependencies:
+      pify: 4.0.1
+      semver: 5.7.1
+    dev: true
+
   /make-dir/3.1.0:
     resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
     engines: {node: '>=8'}
@@ -2961,6 +3822,11 @@ packages:
     resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==}
     dev: true
 
+  /map-cache/0.2.2:
+    resolution: {integrity: sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /map-obj/1.0.1:
     resolution: {integrity: sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=}
     engines: {node: '>=0.10.0'}
@@ -2971,6 +3837,28 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /map-visit/1.0.0:
+    resolution: {integrity: sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      object-visit: 1.0.1
+    dev: true
+
+  /md5.js/1.3.5:
+    resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==}
+    dependencies:
+      hash-base: 3.1.0
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+    dev: true
+
+  /memory-fs/0.4.1:
+    resolution: {integrity: sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=}
+    dependencies:
+      errno: 0.1.8
+      readable-stream: 2.3.7
+    dev: true
+
   /memory-fs/0.5.0:
     resolution: {integrity: sha512-jA0rdU5KoQMC0e6ppoNRtpp6vjFq6+NY7r8hywnC7V+1Xj/MtHwGIbB1QaK/dunyjWteJzmkpd7ooeWg10T7GA==}
     engines: {node: '>=4.3.0 <5.0.0 || >=5.10'}
@@ -3009,6 +3897,27 @@ packages:
     engines: {node: '>= 8'}
     dev: true
 
+  /micromatch/3.1.10:
+    resolution: {integrity: sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      arr-diff: 4.0.0
+      array-unique: 0.3.2
+      braces: 2.3.2
+      define-property: 2.0.2
+      extend-shallow: 3.0.2
+      extglob: 2.0.4
+      fragment-cache: 0.2.1
+      kind-of: 6.0.3
+      nanomatch: 1.2.13
+      object.pick: 1.3.0
+      regex-not: 1.0.2
+      snapdragon: 0.8.2
+      to-regex: 3.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /micromatch/4.0.5:
     resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==}
     engines: {node: '>=8.6'}
@@ -3017,6 +3926,14 @@ packages:
       picomatch: 2.3.1
     dev: true
 
+  /miller-rabin/4.0.1:
+    resolution: {integrity: sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==}
+    hasBin: true
+    dependencies:
+      bn.js: 4.12.0
+      brorand: 1.1.0
+    dev: true
+
   /mime-db/1.52.0:
     resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==}
     engines: {node: '>= 0.6'}
@@ -3050,6 +3967,14 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
+  /minimalistic-assert/1.0.1:
+    resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==}
+    dev: true
+
+  /minimalistic-crypto-utils/1.0.1:
+    resolution: {integrity: sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=}
+    dev: true
+
   /minimatch/3.1.2:
     resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
     dependencies:
@@ -3073,6 +3998,30 @@ packages:
     resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==}
     dev: true
 
+  /mississippi/3.0.0:
+    resolution: {integrity: sha512-x471SsVjUtBRtcvd4BzKE9kFC+/2TeWgKCgw0bZcw1b9l2X3QX5vCWgF+KaZaYm87Ss//rHnWryupDrgLvmSkA==}
+    engines: {node: '>=4.0.0'}
+    dependencies:
+      concat-stream: 1.6.2
+      duplexify: 3.7.1
+      end-of-stream: 1.4.4
+      flush-write-stream: 1.1.1
+      from2: 2.3.0
+      parallel-transform: 1.2.0
+      pump: 3.0.0
+      pumpify: 1.5.1
+      stream-each: 1.2.3
+      through2: 2.0.5
+    dev: true
+
+  /mixin-deep/1.3.2:
+    resolution: {integrity: sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      for-in: 1.0.2
+      is-extendable: 1.0.1
+    dev: true
+
   /mkdirp/0.5.6:
     resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
     hasBin: true
@@ -3085,6 +4034,21 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /move-concurrently/1.0.1:
+    resolution: {integrity: sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=}
+    dependencies:
+      aproba: 1.2.0
+      copy-concurrently: 1.0.5
+      fs-write-stream-atomic: 1.0.10
+      mkdirp: 0.5.6
+      rimraf: 2.7.1
+      run-queue: 1.0.3
+    dev: true
+
+  /ms/2.0.0:
+    resolution: {integrity: sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=}
+    dev: true
+
   /ms/2.1.2:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
     dev: true
@@ -3097,12 +4061,36 @@ packages:
     resolution: {integrity: sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=}
     dev: true
 
+  /nan/2.15.0:
+    resolution: {integrity: sha512-8ZtvEnA2c5aYCZYd1cvgdnU6cqwixRoYg70xPLWUws5ORTa/lnw+u4amixRS/Ac5U5mQVgp9pnlSUnbNWFaWZQ==}
+    dev: true
+    optional: true
+
   /nanoid/3.3.4:
     resolution: {integrity: sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
     dev: true
 
+  /nanomatch/1.2.13:
+    resolution: {integrity: sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      arr-diff: 4.0.0
+      array-unique: 0.3.2
+      define-property: 2.0.2
+      extend-shallow: 3.0.2
+      fragment-cache: 0.2.1
+      is-windows: 1.0.2
+      kind-of: 6.0.3
+      object.pick: 1.3.0
+      regex-not: 1.0.2
+      snapdragon: 0.8.2
+      to-regex: 3.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /natural-compare/1.4.0:
     resolution: {integrity: sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=}
     dev: true
@@ -3111,8 +4099,32 @@ packages:
     resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
     dev: true
 
-  /node-releases/2.0.4:
-    resolution: {integrity: sha512-gbMzqQtTtDz/00jQzZ21PQzdI9PyLYqUSvD0p3naOhX4odFji0ZxYdnVwPTxmSwkmxhcFImpozceidSG+AgoPQ==}
+  /node-libs-browser/2.2.1:
+    resolution: {integrity: sha512-h/zcD8H9kaDZ9ALUWwlBUDo6TKF8a7qBSCSEGfjTVIYeqsioSKaAX+BN7NgiMGp6iSIXZ3PxgCu8KS3b71YK5Q==}
+    dependencies:
+      assert: 1.5.0
+      browserify-zlib: 0.2.0
+      buffer: 4.9.2
+      console-browserify: 1.2.0
+      constants-browserify: 1.0.0
+      crypto-browserify: 3.12.0
+      domain-browser: 1.2.0
+      events: 3.3.0
+      https-browserify: 1.0.0
+      os-browserify: 0.3.0
+      path-browserify: 0.0.1
+      process: 0.11.10
+      punycode: 1.4.1
+      querystring-es3: 0.2.1
+      readable-stream: 2.3.7
+      stream-browserify: 2.0.2
+      stream-http: 2.8.3
+      string_decoder: 1.3.0
+      timers-browserify: 2.0.12
+      tty-browserify: 0.0.0
+      url: 0.11.0
+      util: 0.11.1
+      vm-browserify: 1.1.2
     dev: true
 
   /normalize-package-data/2.5.0:
@@ -3139,6 +4151,14 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /normalize-path/2.1.1:
+    resolution: {integrity: sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      remove-trailing-separator: 1.1.0
+    dev: true
+    optional: true
+
   /normalize-path/3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
@@ -3162,10 +4182,38 @@ packages:
     resolution: {integrity: sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ==}
     dev: true
 
+  /object-assign/4.1.1:
+    resolution: {integrity: sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /object-copy/0.1.0:
+    resolution: {integrity: sha1-fn2Fi3gb18mRpBupde04EnVOmYw=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      copy-descriptor: 0.1.1
+      define-property: 0.2.5
+      kind-of: 3.2.2
+    dev: true
+
   /object-inspect/1.12.0:
     resolution: {integrity: sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==}
     dev: true
 
+  /object-visit/1.0.1:
+    resolution: {integrity: sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      isobject: 3.0.1
+    dev: true
+
+  /object.pick/1.3.0:
+    resolution: {integrity: sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      isobject: 3.0.1
+    dev: true
+
   /once/1.4.0:
     resolution: {integrity: sha1-WDsap3WWHUsROsF9nFC6753Xa9E=}
     dependencies:
@@ -3215,6 +4263,10 @@ packages:
       word-wrap: 1.2.3
     dev: true
 
+  /os-browserify/0.3.0:
+    resolution: {integrity: sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=}
+    dev: true
+
   /os-tmpdir/1.0.2:
     resolution: {integrity: sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=}
     engines: {node: '>=0.10.0'}
@@ -3253,6 +4305,13 @@ packages:
       p-limit: 1.3.0
     dev: true
 
+  /p-locate/3.0.0:
+    resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      p-limit: 2.3.0
+    dev: true
+
   /p-locate/4.1.0:
     resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
     engines: {node: '>=8'}
@@ -3284,6 +4343,18 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /pako/1.0.11:
+    resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==}
+    dev: true
+
+  /parallel-transform/1.2.0:
+    resolution: {integrity: sha512-P2vSmIu38uIlvdcU7fDkyrxj33gTUy/ABO5ZUbGowxNCopBq/OoD42bP4UmMrJoPyk4Uqf0mu3mtWBhHCZD8yg==}
+    dependencies:
+      cyclist: 1.0.1
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+    dev: true
+
   /parent-module/1.0.1:
     resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
     engines: {node: '>=6'}
@@ -3291,6 +4362,16 @@ packages:
       callsites: 3.1.0
     dev: true
 
+  /parse-asn1/5.1.6:
+    resolution: {integrity: sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==}
+    dependencies:
+      asn1.js: 5.4.1
+      browserify-aes: 1.2.0
+      evp_bytestokey: 1.0.3
+      pbkdf2: 3.1.2
+      safe-buffer: 5.2.1
+    dev: true
+
   /parse-json/4.0.0:
     resolution: {integrity: sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=}
     engines: {node: '>=4'}
@@ -3318,6 +4399,20 @@ packages:
     resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
     dev: true
 
+  /pascalcase/0.1.1:
+    resolution: {integrity: sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /path-browserify/0.0.1:
+    resolution: {integrity: sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==}
+    dev: true
+
+  /path-dirname/1.0.2:
+    resolution: {integrity: sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=}
+    dev: true
+    optional: true
+
   /path-exists/3.0.0:
     resolution: {integrity: sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=}
     engines: {node: '>=4'}
@@ -3375,6 +4470,17 @@ packages:
     resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
     dev: true
 
+  /pbkdf2/3.1.2:
+    resolution: {integrity: sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==}
+    engines: {node: '>=0.12'}
+    dependencies:
+      create-hash: 1.2.0
+      create-hmac: 1.1.7
+      ripemd160: 2.0.2
+      safe-buffer: 5.2.1
+      sha.js: 2.4.11
+    dev: true
+
   /picocolors/1.0.0:
     resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}
     dev: true
@@ -3400,6 +4506,18 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
+  /pify/4.0.1:
+    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /pkg-dir/3.0.0:
+    resolution: {integrity: sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==}
+    engines: {node: '>=6'}
+    dependencies:
+      find-up: 3.0.0
+    dev: true
+
   /pkg-dir/4.2.0:
     resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==}
     engines: {node: '>=8'}
@@ -3425,6 +4543,11 @@ packages:
       - supports-color
     dev: true
 
+  /posix-character-classes/0.1.1:
+    resolution: {integrity: sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /postcss/8.4.14:
     resolution: {integrity: sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==}
     engines: {node: ^10 || ^12 || >=14}
@@ -3439,25 +4562,82 @@ packages:
     engines: {node: '>= 0.8.0'}
     dev: true
 
-  /prelude-ls/1.2.1:
-    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
-    engines: {node: '>= 0.8.0'}
+  /prelude-ls/1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+    dev: true
+
+  /process-nextick-args/2.0.1:
+    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
+    dev: true
+
+  /process/0.11.10:
+    resolution: {integrity: sha1-czIwDoQBYb2j5podHZGn1LwW8YI=}
+    engines: {node: '>= 0.6.0'}
+    dev: true
+
+  /promise-inflight/1.0.1_bluebird@3.7.2:
+    resolution: {integrity: sha1-mEcocL8igTL8vdhoEputEsPAKeM=}
+    peerDependencies:
+      bluebird: '*'
+    peerDependenciesMeta:
+      bluebird:
+        optional: true
+    dependencies:
+      bluebird: 3.7.2
+    dev: true
+
+  /prr/1.0.1:
+    resolution: {integrity: sha1-0/wRS6BplaRexok/SEzrHXj19HY=}
+    dev: true
+
+  /pseudomap/1.0.2:
+    resolution: {integrity: sha1-8FKijacOYYkX7wqKw0wa5aaChrM=}
+    dev: true
+
+  /psl/1.8.0:
+    resolution: {integrity: sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==}
+    dev: true
+
+  /public-encrypt/4.0.3:
+    resolution: {integrity: sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==}
+    dependencies:
+      bn.js: 4.12.0
+      browserify-rsa: 4.1.0
+      create-hash: 1.2.0
+      parse-asn1: 5.1.6
+      randombytes: 2.1.0
+      safe-buffer: 5.2.1
+    dev: true
+
+  /pump/2.0.1:
+    resolution: {integrity: sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==}
+    dependencies:
+      end-of-stream: 1.4.4
+      once: 1.4.0
     dev: true
 
-  /process-nextick-args/2.0.1:
-    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
+  /pump/3.0.0:
+    resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==}
+    dependencies:
+      end-of-stream: 1.4.4
+      once: 1.4.0
     dev: true
 
-  /prr/1.0.1:
-    resolution: {integrity: sha1-0/wRS6BplaRexok/SEzrHXj19HY=}
+  /pumpify/1.5.1:
+    resolution: {integrity: sha512-oClZI37HvuUJJxSKKrC17bZ9Cu0ZYhEAGPsPUy9KlMUmv9dKX2o77RUmq7f3XjIxbwyGwYzbzQ1L2Ks8sIradQ==}
+    dependencies:
+      duplexify: 3.7.1
+      inherits: 2.0.4
+      pump: 2.0.1
     dev: true
 
-  /pseudomap/1.0.2:
-    resolution: {integrity: sha1-8FKijacOYYkX7wqKw0wa5aaChrM=}
+  /punycode/1.3.2:
+    resolution: {integrity: sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=}
     dev: true
 
-  /psl/1.8.0:
-    resolution: {integrity: sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==}
+  /punycode/1.4.1:
+    resolution: {integrity: sha1-wNWmOycYgArY4esPpSachN1BhF4=}
     dev: true
 
   /punycode/2.1.1:
@@ -3477,6 +4657,17 @@ packages:
       side-channel: 1.0.4
     dev: true
 
+  /querystring-es3/0.2.1:
+    resolution: {integrity: sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=}
+    engines: {node: '>=0.4.x'}
+    dev: true
+
+  /querystring/0.2.0:
+    resolution: {integrity: sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=}
+    engines: {node: '>=0.4.x'}
+    deprecated: The querystring API is considered Legacy. new code should use the URLSearchParams API instead.
+    dev: true
+
   /queue-microtask/1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
     dev: true
@@ -3492,6 +4683,13 @@ packages:
       safe-buffer: 5.2.1
     dev: true
 
+  /randomfill/1.0.4:
+    resolution: {integrity: sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==}
+    dependencies:
+      randombytes: 2.1.0
+      safe-buffer: 5.2.1
+    dev: true
+
   /read-pkg-up/3.0.0:
     resolution: {integrity: sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=}
     engines: {node: '>=4'}
@@ -3549,6 +4747,26 @@ packages:
       util-deprecate: 1.0.2
     dev: true
 
+  /readdirp/2.2.1:
+    resolution: {integrity: sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==}
+    engines: {node: '>=0.10'}
+    dependencies:
+      graceful-fs: 4.2.10
+      micromatch: 3.1.10
+      readable-stream: 2.3.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+    optional: true
+
+  /readdirp/3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+    dependencies:
+      picomatch: 2.3.1
+    dev: true
+    optional: true
+
   /rechoir/0.6.2:
     resolution: {integrity: sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=}
     engines: {node: '>= 0.10'}
@@ -3564,11 +4782,34 @@ packages:
       strip-indent: 3.0.0
     dev: true
 
+  /regex-not/1.0.2:
+    resolution: {integrity: sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      extend-shallow: 3.0.2
+      safe-regex: 1.1.0
+    dev: true
+
   /regexpp/3.2.0:
     resolution: {integrity: sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==}
     engines: {node: '>=8'}
     dev: true
 
+  /remove-trailing-separator/1.1.0:
+    resolution: {integrity: sha1-wkvOKig62tW8P1jg1IJJuSN52O8=}
+    dev: true
+    optional: true
+
+  /repeat-element/1.1.4:
+    resolution: {integrity: sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /repeat-string/1.6.1:
+    resolution: {integrity: sha1-jcrkcOHIirwtYA//Sndihtp15jc=}
+    engines: {node: '>=0.10'}
+    dev: true
+
   /require-directory/2.1.1:
     resolution: {integrity: sha1-jGStX9MNqxyXbiNE/+f3kqam30I=}
     engines: {node: '>=0.10.0'}
@@ -3605,6 +4846,11 @@ packages:
     dev: true
     optional: true
 
+  /resolve-url/0.2.1:
+    resolution: {integrity: sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=}
+    deprecated: https://github.com/lydell/resolve-url#deprecated
+    dev: true
+
   /resolve/1.22.0:
     resolution: {integrity: sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==}
     hasBin: true
@@ -3630,6 +4876,11 @@ packages:
       signal-exit: 3.0.7
     dev: true
 
+  /ret/0.1.15:
+    resolution: {integrity: sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==}
+    engines: {node: '>=0.12'}
+    dev: true
+
   /reusify/1.0.4:
     resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
@@ -3639,6 +4890,13 @@ packages:
     resolution: {integrity: sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==}
     dev: true
 
+  /rimraf/2.7.1:
+    resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==}
+    hasBin: true
+    dependencies:
+      glob: 7.2.3
+    dev: true
+
   /rimraf/3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
     hasBin: true
@@ -3646,6 +4904,13 @@ packages:
       glob: 7.2.3
     dev: true
 
+  /ripemd160/2.0.2:
+    resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==}
+    dependencies:
+      hash-base: 3.1.0
+      inherits: 2.0.4
+    dev: true
+
   /rollup-plugin-typescript2/0.31.2_dyu3set7imqii5ytavmnwecwpy:
     resolution: {integrity: sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==}
     peerDependencies:
@@ -3681,6 +4946,12 @@ packages:
       queue-microtask: 1.2.3
     dev: true
 
+  /run-queue/1.0.3:
+    resolution: {integrity: sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=}
+    dependencies:
+      aproba: 1.2.0
+    dev: true
+
   /rxjs/6.6.7:
     resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==}
     engines: {npm: '>=2.0.0'}
@@ -3702,6 +4973,12 @@ packages:
     resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
     dev: true
 
+  /safe-regex/1.1.0:
+    resolution: {integrity: sha1-QKNmnzsHfR6UPURinhV91IAjvy4=}
+    dependencies:
+      ret: 0.1.15
+    dev: true
+
   /safer-buffer/2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
     dev: true
@@ -3713,12 +4990,12 @@ packages:
       xmlchars: 2.2.0
     dev: true
 
-  /schema-utils/3.1.1:
-    resolution: {integrity: sha512-Y5PQxS4ITlC+EahLuXaY86TXfR7Dc5lw294alXOq86JAHCihAIZfqv8nNCWvaEJvaC51uN9hbLGeV0cFBdH+Fw==}
-    engines: {node: '>= 10.13.0'}
+  /schema-utils/1.0.0:
+    resolution: {integrity: sha512-i27Mic4KovM/lnGsy8whRCHhc7VicJajAjTrYg11K9zfZXnYIt4k5F+kZkwjnrhKzLic/HLU4j11mjsz2G/75g==}
+    engines: {node: '>= 4'}
     dependencies:
-      '@types/json-schema': 7.0.11
       ajv: 6.12.6
+      ajv-errors: 1.0.1_ajv@6.12.6
       ajv-keywords: 3.5.2_ajv@6.12.6
     dev: true
 
@@ -3744,12 +5021,40 @@ packages:
       lru-cache: 6.0.0
     dev: true
 
+  /serialize-javascript/4.0.0:
+    resolution: {integrity: sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==}
+    dependencies:
+      randombytes: 2.1.0
+    dev: true
+
   /serialize-javascript/6.0.0:
     resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==}
     dependencies:
       randombytes: 2.1.0
     dev: true
 
+  /set-value/2.0.1:
+    resolution: {integrity: sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      extend-shallow: 2.0.1
+      is-extendable: 0.1.1
+      is-plain-object: 2.0.4
+      split-string: 3.1.0
+    dev: true
+
+  /setimmediate/1.0.5:
+    resolution: {integrity: sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=}
+    dev: true
+
+  /sha.js/2.4.11:
+    resolution: {integrity: sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==}
+    hasBin: true
+    dependencies:
+      inherits: 2.0.4
+      safe-buffer: 5.2.1
+    dev: true
+
   /shebang-command/1.2.0:
     resolution: {integrity: sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=}
     engines: {node: '>=0.10.0'}
@@ -3827,11 +5132,58 @@ packages:
       is-fullwidth-code-point: 4.0.0
     dev: true
 
+  /snapdragon-node/2.1.1:
+    resolution: {integrity: sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      define-property: 1.0.0
+      isobject: 3.0.1
+      snapdragon-util: 3.0.1
+    dev: true
+
+  /snapdragon-util/3.0.1:
+    resolution: {integrity: sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 3.2.2
+    dev: true
+
+  /snapdragon/0.8.2:
+    resolution: {integrity: sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      base: 0.11.2
+      debug: 2.6.9
+      define-property: 0.2.5
+      extend-shallow: 2.0.1
+      map-cache: 0.2.2
+      source-map: 0.5.6
+      source-map-resolve: 0.5.3
+      use: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /source-list-map/2.0.1:
+    resolution: {integrity: sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==}
+    dev: true
+
   /source-map-js/1.0.2:
     resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==}
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /source-map-resolve/0.5.3:
+    resolution: {integrity: sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==}
+    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
+    dependencies:
+      atob: 2.1.2
+      decode-uri-component: 0.2.0
+      resolve-url: 0.2.1
+      source-map-url: 0.4.1
+      urix: 0.1.0
+    dev: true
+
   /source-map-support/0.5.21:
     resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
     dependencies:
@@ -3839,6 +5191,11 @@ packages:
       source-map: 0.6.1
     dev: true
 
+  /source-map-url/0.4.1:
+    resolution: {integrity: sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==}
+    deprecated: See https://github.com/lydell/source-map-url#deprecated
+    dev: true
+
   /source-map/0.5.6:
     resolution: {integrity: sha1-dc449SvwczxafwwRjYEzSiu19BI=}
     engines: {node: '>=0.10.0'}
@@ -3882,6 +5239,13 @@ packages:
     resolution: {integrity: sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==}
     dev: true
 
+  /split-string/3.1.0:
+    resolution: {integrity: sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      extend-shallow: 3.0.2
+    dev: true
+
   /split/1.0.1:
     resolution: {integrity: sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg==}
     dependencies:
@@ -3894,6 +5258,27 @@ packages:
       readable-stream: 3.6.0
     dev: true
 
+  /ssri/6.0.2:
+    resolution: {integrity: sha512-cepbSq/neFK7xB6A50KHN0xHDotYzq58wWCa5LeWqnPrHG8GzfEjO/4O8kpmcGW+oaxkvhEJCWgbgNk4/ZV93Q==}
+    dependencies:
+      figgy-pudding: 3.5.2
+    dev: true
+
+  /static-extend/0.1.2:
+    resolution: {integrity: sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      define-property: 0.2.5
+      object-copy: 0.1.0
+    dev: true
+
+  /stream-browserify/2.0.2:
+    resolution: {integrity: sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==}
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+    dev: true
+
   /stream-browserify/3.0.0:
     resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==}
     dependencies:
@@ -3901,6 +5286,27 @@ packages:
       readable-stream: 3.6.0
     dev: true
 
+  /stream-each/1.2.3:
+    resolution: {integrity: sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==}
+    dependencies:
+      end-of-stream: 1.4.4
+      stream-shift: 1.0.1
+    dev: true
+
+  /stream-http/2.8.3:
+    resolution: {integrity: sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==}
+    dependencies:
+      builtin-status-codes: 3.0.0
+      inherits: 2.0.4
+      readable-stream: 2.3.7
+      to-arraybuffer: 1.0.1
+      xtend: 4.0.2
+    dev: true
+
+  /stream-shift/1.0.1:
+    resolution: {integrity: sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==}
+    dev: true
+
   /string-argv/0.3.1:
     resolution: {integrity: sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==}
     engines: {node: '>=0.6.19'}
@@ -4028,13 +5434,6 @@ packages:
       has-flag: 4.0.0
     dev: true
 
-  /supports-color/8.1.1:
-    resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
-    engines: {node: '>=10'}
-    dependencies:
-      has-flag: 4.0.0
-    dev: true
-
   /supports-color/9.2.2:
     resolution: {integrity: sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==}
     engines: {node: '>=12'}
@@ -4049,33 +5448,38 @@ packages:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
     dev: true
 
-  /tapable/2.2.1:
-    resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==}
+  /tapable/1.1.3:
+    resolution: {integrity: sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==}
     engines: {node: '>=6'}
     dev: true
 
-  /terser-webpack-plugin/5.3.1_webpack@5.72.1:
-    resolution: {integrity: sha512-GvlZdT6wPQKbDNW/GDQzZFg/j4vKU96yl2q6mcUkzKOgW4gwf1Z8cZToUCrz31XHlPWH8MVb1r2tFtdDtTGJ7g==}
-    engines: {node: '>= 10.13.0'}
+  /terser-webpack-plugin/1.4.5_webpack@4.46.0:
+    resolution: {integrity: sha512-04Rfe496lN8EYruwi6oPQkG0vo8C+HT49X687FZnpPF0qMAIHONI6HEXYPKDOE8e5HjXTyKfqRd/agHtH0kOtw==}
+    engines: {node: '>= 6.9.0'}
     peerDependencies:
-      '@swc/core': '*'
-      esbuild: '*'
-      uglify-js: '*'
-      webpack: ^5.1.0
-    peerDependenciesMeta:
-      '@swc/core':
-        optional: true
-      esbuild:
-        optional: true
-      uglify-js:
-        optional: true
+      webpack: ^4.0.0
+    dependencies:
+      cacache: 12.0.4
+      find-cache-dir: 2.1.0
+      is-wsl: 1.1.0
+      schema-utils: 1.0.0
+      serialize-javascript: 4.0.0
+      source-map: 0.6.1
+      terser: 4.8.0
+      webpack: 4.46.0
+      webpack-sources: 1.4.3
+      worker-farm: 1.7.0
+    dev: true
+
+  /terser/4.8.0:
+    resolution: {integrity: sha512-EAPipTNeWsb/3wLPeup1tVPaXfIaU68xMnVdPafIL1TV05OhASArYyIfFvnvJCNrR2NIOvDVNNTFRa+Re2MWyw==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
     dependencies:
-      jest-worker: 27.5.1
-      schema-utils: 3.1.1
-      serialize-javascript: 6.0.0
+      acorn: 8.7.1
+      commander: 2.20.3
       source-map: 0.6.1
-      terser: 5.13.1
-      webpack: 5.72.1
+      source-map-support: 0.5.21
     dev: true
 
   /terser/5.13.1:
@@ -4115,6 +5519,13 @@ packages:
       readable-stream: 3.6.0
     dev: true
 
+  /timers-browserify/2.0.12:
+    resolution: {integrity: sha512-9phl76Cqm6FhSX9Xe1ZUAMLtm1BLkKj2Qd5ApyWkXzsMRaA7dgr81kf4wJmQf/hAvg8EEyJxDo3du/0KlhPiKQ==}
+    engines: {node: '>=0.6.0'}
+    dependencies:
+      setimmediate: 1.0.5
+    dev: true
+
   /tinypool/0.1.3:
     resolution: {integrity: sha512-2IfcQh7CP46XGWGGbdyO4pjcKqsmVqFAPcXfPxcPXmOWt9cYkTP9HcDmGgsfijYoAEc4z9qcpM/BaBz46Y9/CQ==}
     engines: {node: '>=14.0.0'}
@@ -4132,6 +5543,25 @@ packages:
       os-tmpdir: 1.0.2
     dev: true
 
+  /to-arraybuffer/1.0.1:
+    resolution: {integrity: sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=}
+    dev: true
+
+  /to-object-path/0.3.0:
+    resolution: {integrity: sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      kind-of: 3.2.2
+    dev: true
+
+  /to-regex-range/2.1.1:
+    resolution: {integrity: sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-number: 3.0.0
+      repeat-string: 1.6.1
+    dev: true
+
   /to-regex-range/5.0.1:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
@@ -4139,6 +5569,16 @@ packages:
       is-number: 7.0.0
     dev: true
 
+  /to-regex/3.0.2:
+    resolution: {integrity: sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      define-property: 2.0.2
+      extend-shallow: 3.0.2
+      regex-not: 1.0.2
+      safe-regex: 1.1.0
+    dev: true
+
   /tough-cookie/4.0.0:
     resolution: {integrity: sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==}
     engines: {node: '>=6'}
@@ -4215,6 +5655,10 @@ packages:
       typescript: 4.6.4
     dev: true
 
+  /tty-browserify/0.0.0:
+    resolution: {integrity: sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=}
+    dev: true
+
   /type-check/0.3.2:
     resolution: {integrity: sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=}
     engines: {node: '>= 0.8.0'}
@@ -4259,6 +5703,10 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /typedarray/0.0.6:
+    resolution: {integrity: sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=}
+    dev: true
+
   /typescript/4.6.4:
     resolution: {integrity: sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg==}
     engines: {node: '>=4.2.0'}
@@ -4273,6 +5721,16 @@ packages:
     dev: true
     optional: true
 
+  /union-value/1.0.1:
+    resolution: {integrity: sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      arr-union: 3.1.0
+      get-value: 2.0.6
+      is-extendable: 0.1.1
+      set-value: 2.0.1
+    dev: true
+
   /union/0.5.0:
     resolution: {integrity: sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==}
     engines: {node: '>= 0.8.0'}
@@ -4280,6 +5738,18 @@ packages:
       qs: 6.10.3
     dev: true
 
+  /unique-filename/1.1.1:
+    resolution: {integrity: sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==}
+    dependencies:
+      unique-slug: 2.0.2
+    dev: true
+
+  /unique-slug/2.0.2:
+    resolution: {integrity: sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w==}
+    dependencies:
+      imurmurhash: 0.1.4
+    dev: true
+
   /universalify/0.1.2:
     resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
     engines: {node: '>= 4.0.0'}
@@ -4290,6 +5760,20 @@ packages:
     engines: {node: '>= 10.0.0'}
     dev: true
 
+  /unset-value/1.0.0:
+    resolution: {integrity: sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      has-value: 0.3.1
+      isobject: 3.0.1
+    dev: true
+
+  /upath/1.2.0:
+    resolution: {integrity: sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==}
+    engines: {node: '>=4'}
+    dev: true
+    optional: true
+
   /upath2/3.1.13:
     resolution: {integrity: sha512-M88uBoqgzrkXvXrF/+oSIPsTmL21uRwGhPVJKODrl+3lXkQ5NPKrTYuSBZVa+lgPGFoI6qYyHlSKACFHO0AoNw==}
     dependencies:
@@ -4305,14 +5789,43 @@ packages:
       punycode: 2.1.1
     dev: true
 
+  /urix/0.1.0:
+    resolution: {integrity: sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=}
+    deprecated: Please see https://github.com/lydell/urix#deprecated
+    dev: true
+
   /url-join/4.0.1:
     resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
     dev: true
 
+  /url/0.11.0:
+    resolution: {integrity: sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=}
+    dependencies:
+      punycode: 1.3.2
+      querystring: 0.2.0
+    dev: true
+
+  /use/3.1.1:
+    resolution: {integrity: sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /util-deprecate/1.0.2:
     resolution: {integrity: sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=}
     dev: true
 
+  /util/0.10.3:
+    resolution: {integrity: sha1-evsa/lCAUkZInj23/g7TeTNqwPk=}
+    dependencies:
+      inherits: 2.0.1
+    dev: true
+
+  /util/0.11.1:
+    resolution: {integrity: sha512-HShAsny+zS2TZfaXxD9tYj4HQGlBezXZMZuM/S5PKLLoZkShZiGk9o5CzukI1LVHZvjdvZ2Sj1aW/Ndn2NB/HQ==}
+    dependencies:
+      inherits: 2.0.3
+    dev: true
+
   /v8-compile-cache-lib/3.0.1:
     resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
     dev: true
@@ -4385,6 +5898,10 @@ packages:
       - stylus
     dev: true
 
+  /vm-browserify/1.1.2:
+    resolution: {integrity: sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==}
+    dev: true
+
   /w3c-hr-time/1.0.2:
     resolution: {integrity: sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==}
     dependencies:
@@ -4398,12 +5915,26 @@ packages:
       xml-name-validator: 4.0.0
     dev: true
 
-  /watchpack/2.3.1:
-    resolution: {integrity: sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==}
-    engines: {node: '>=10.13.0'}
+  /watchpack-chokidar2/2.0.1:
+    resolution: {integrity: sha512-nCFfBIPKr5Sh61s4LPpy1Wtfi0HE8isJ3d2Yb5/Ppw2P2B/3eVSEBjKfN0fmHJSK14+31KwMKmcrzs2GM4P0Ww==}
+    requiresBuild: true
+    dependencies:
+      chokidar: 2.1.8
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+    optional: true
+
+  /watchpack/1.7.5:
+    resolution: {integrity: sha512-9P3MWk6SrKjHsGkLT2KHXdQ/9SNkyoJbabxnKOoJepsvJjJG8uYTR3yTPxPQvNDI3w4Nz1xnE0TLHK4RIVe/MQ==}
     dependencies:
-      glob-to-regexp: 0.4.1
       graceful-fs: 4.2.10
+      neo-async: 2.6.2
+    optionalDependencies:
+      chokidar: 3.5.3
+      watchpack-chokidar2: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
     dev: true
 
   /webidl-conversions/4.0.2:
@@ -4415,49 +5946,51 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /webpack-sources/3.2.3:
-    resolution: {integrity: sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==}
-    engines: {node: '>=10.13.0'}
+  /webpack-sources/1.4.3:
+    resolution: {integrity: sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ==}
+    dependencies:
+      source-list-map: 2.0.1
+      source-map: 0.6.1
     dev: true
 
-  /webpack/5.72.1:
-    resolution: {integrity: sha512-dXG5zXCLspQR4krZVR6QgajnZOjW2K/djHvdcRaDQvsjV9z9vaW6+ja5dZOYbqBBjF6kGXka/2ZyxNdc+8Jung==}
-    engines: {node: '>=10.13.0'}
+  /webpack/4.46.0:
+    resolution: {integrity: sha512-6jJuJjg8znb/xRItk7bkT0+Q7AHCYjjFnvKIWQPkNIOyRqoCGvkOs0ipeQzrqz4l5FtN5ZI/ukEHroeX/o1/5Q==}
+    engines: {node: '>=6.11.5'}
     hasBin: true
     peerDependencies:
       webpack-cli: '*'
+      webpack-command: '*'
     peerDependenciesMeta:
       webpack-cli:
         optional: true
+      webpack-command:
+        optional: true
     dependencies:
-      '@types/eslint-scope': 3.7.3
-      '@types/estree': 0.0.51
-      '@webassemblyjs/ast': 1.11.1
-      '@webassemblyjs/wasm-edit': 1.11.1
-      '@webassemblyjs/wasm-parser': 1.11.1
-      acorn: 8.7.1
-      acorn-import-assertions: 1.8.0_acorn@8.7.1
-      browserslist: 4.20.3
+      '@webassemblyjs/ast': 1.9.0
+      '@webassemblyjs/helper-module-context': 1.9.0
+      '@webassemblyjs/wasm-edit': 1.9.0
+      '@webassemblyjs/wasm-parser': 1.9.0
+      acorn: 6.4.2
+      ajv: 6.12.6
+      ajv-keywords: 3.5.2_ajv@6.12.6
       chrome-trace-event: 1.0.3
-      enhanced-resolve: 5.9.3
-      es-module-lexer: 0.9.3
-      eslint-scope: 5.1.1
-      events: 3.3.0
-      glob-to-regexp: 0.4.1
-      graceful-fs: 4.2.10
-      json-parse-even-better-errors: 2.3.1
-      loader-runner: 4.3.0
-      mime-types: 2.1.35
+      enhanced-resolve: 4.5.0
+      eslint-scope: 4.0.3
+      json-parse-better-errors: 1.0.2
+      loader-runner: 2.4.0
+      loader-utils: 1.4.0
+      memory-fs: 0.4.1
+      micromatch: 3.1.10
+      mkdirp: 0.5.6
       neo-async: 2.6.2
-      schema-utils: 3.1.1
-      tapable: 2.2.1
-      terser-webpack-plugin: 5.3.1_webpack@5.72.1
-      watchpack: 2.3.1
-      webpack-sources: 3.2.3
+      node-libs-browser: 2.2.1
+      schema-utils: 1.0.0
+      tapable: 1.1.3
+      terser-webpack-plugin: 1.4.5_webpack@4.46.0
+      watchpack: 1.7.5
+      webpack-sources: 1.4.3
     transitivePeerDependencies:
-      - '@swc/core'
-      - esbuild
-      - uglify-js
+      - supports-color
     dev: true
 
   /whatwg-encoding/2.0.0:
@@ -4520,6 +6053,12 @@ packages:
     resolution: {integrity: sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=}
     dev: true
 
+  /worker-farm/1.7.0:
+    resolution: {integrity: sha512-rvw3QTZc8lAxyVrqcSGVm5yP/IJ2UcB3U0graE3LCFoZ0Yn2x4EoVSqJKdB/T5M+FLcRPjz4TDacRf3OCfNUzw==}
+    dependencies:
+      errno: 0.1.8
+    dev: true
+
   /wrap-ansi/6.2.0:
     resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
     engines: {node: '>=8'}
@@ -4569,6 +6108,10 @@ packages:
     engines: {node: '>=0.4'}
     dev: true
 
+  /y18n/4.0.3:
+    resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==}
+    dev: true
+
   /y18n/5.0.8:
     resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
     engines: {node: '>=10'}
@@ -4578,6 +6121,10 @@ packages:
     resolution: {integrity: sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=}
     dev: true
 
+  /yallist/3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+    dev: true
+
   /yallist/4.0.0:
     resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
     dev: true
diff --git a/scripts/config.js b/scripts/config.js
index 3d5fe7b6968..05d5e0e628f 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -236,8 +236,7 @@ function genConfig(name) {
 
   // built-in vars
   const vars = {
-    __VERSION__: version,
-    __SSR_TEST__: false
+    __VERSION__: version
   }
   // feature flags
   Object.keys(featureFlags).forEach((key) => {
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index e336e92aa55..0aa9f6a8172 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -73,7 +73,7 @@ function logError(err, vm, info) {
     warn(`Error in ${info}: "${err.toString()}"`, vm)
   }
   /* istanbul ignore else */
-  if (inBrowser && typeof console !== 'undefined' && !__SSR_TEST__) {
+  if (inBrowser && typeof console !== 'undefined') {
     console.error(err)
   } else {
     throw err
diff --git a/src/global.d.ts b/src/global.d.ts
index 22eaaeff235..1bdbeafea43 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,5 +1,3 @@
-declare const __SSR_TEST__: boolean;
-
 interface Window {
   __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook;
 }
diff --git a/src/server/bundle-renderer/create-bundle-renderer.ts b/src/server/bundle-renderer/create-bundle-renderer.ts
index a0836d689b8..ba3c730390b 100644
--- a/src/server/bundle-renderer/create-bundle-renderer.ts
+++ b/src/server/bundle-renderer/create-bundle-renderer.ts
@@ -1,10 +1,9 @@
-
 import { createPromiseCallback } from '../util'
 import { createBundleRunner } from './create-bundle-runner'
 import type { Renderer, RenderOptions } from '../create-renderer'
 import {
   createSourceMapConsumers,
-  rewriteErrorTrace,
+  rewriteErrorTrace
 } from './source-map-support'
 
 const fs = require('fs')
@@ -89,7 +88,7 @@ export function createBundleRendererCreator(
     )
 
     return {
-      renderToString: (context: Object | undefined, cb: any) => {
+      renderToString: (context?: Object | undefined, cb?: any) => {
         if (typeof context === 'function') {
           cb = context
           context = {}
@@ -97,7 +96,7 @@ export function createBundleRendererCreator(
 
         let promise
         if (!cb) {
-          ({ promise, cb } = createPromiseCallback())
+          ;({ promise, cb } = createPromiseCallback())
         }
 
         run(context)
@@ -154,7 +153,7 @@ export function createBundleRendererCreator(
           })
 
         return res
-      },
+      }
     }
   }
 }
diff --git a/src/server/create-renderer.ts b/src/server/create-renderer.ts
index ea1d6a5d7c1..98155488f1b 100644
--- a/src/server/create-renderer.ts
+++ b/src/server/create-renderer.ts
@@ -1,4 +1,3 @@
-
 import RenderStream from './render-stream'
 import { createWriteFunction } from './write'
 import { createRenderFunction } from './render'
@@ -29,7 +28,9 @@ export type RenderOptions = {
   directives?: Object
   isUnaryTag?: Function
   cache?: RenderCache
-  template?: string | ((content: string, context: any) => string)
+  template?:
+    | string
+    | ((content: string, context: any) => string | Promise<string>)
   inject?: boolean
   basedir?: string
   shouldPreload?: Function
@@ -49,7 +50,7 @@ export function createRenderer({
   shouldPreload,
   shouldPrefetch,
   clientManifest,
-  serializer,
+  serializer
 }: RenderOptions = {}): Renderer {
   const render = createRenderFunction(modules, directives, isUnaryTag, cache)
   const templateRenderer = new TemplateRenderer({
@@ -60,7 +61,7 @@ export function createRenderer({
     // @ts-expect-error
     shouldPrefetch,
     clientManifest,
-    serializer,
+    serializer
   })
 
   return {
@@ -80,7 +81,7 @@ export function createRenderer({
       // no callback, return Promise
       let promise
       if (!cb) {
-        ({ promise, cb } = createPromiseCallback())
+        ;({ promise, cb } = createPromiseCallback())
       }
 
       let result = ''
@@ -158,6 +159,6 @@ export function createRenderer({
         }
         return templateStream
       }
-    },
+    }
   }
 }
diff --git a/src/server/template-renderer/index.ts b/src/server/template-renderer/index.ts
index 7c0ddd91a9f..0048222b768 100644
--- a/src/server/template-renderer/index.ts
+++ b/src/server/template-renderer/index.ts
@@ -1,4 +1,3 @@
-
 const path = require('path')
 const serialize = require('serialize-javascript')
 
@@ -10,7 +9,9 @@ import type { ParsedTemplate } from './parse-template'
 import type { AsyncFileMapper } from './create-async-file-mapper'
 
 type TemplateRendererOptions = {
-  template?: string | ((content: string, context: any) => string)
+  template?:
+    | string
+    | ((content: string, context: any) => string | Promise<string>)
   inject?: boolean
   clientManifest?: ClientManifest
   shouldPreload?: (file: string, type: string) => boolean
@@ -286,7 +287,7 @@ function normalizeFile(file: string): Resource {
     file,
     extension,
     fileWithoutQuery: withoutQuery,
-    asType: getPreloadType(extension),
+    asType: getPreloadType(extension)
   }
 }
 
diff --git a/test/ssr/compile-with-webpack.ts b/test/ssr/compile-with-webpack.ts
index 2b6b0b326d2..334911c76ca 100644
--- a/test/ssr/compile-with-webpack.ts
+++ b/test/ssr/compile-with-webpack.ts
@@ -1,9 +1,15 @@
 import path from 'path'
 import webpack from 'webpack'
 import MemoryFS from 'memory-fs'
+import { RenderOptions } from '../../src/server/create-renderer'
+import { createBundleRenderer } from 'web/entry-server-renderer'
+import VueSSRServerPlugin from 'server/webpack-plugin/server'
 
-export function compileWithWebpack (file, extraConfig, cb) {
-  const config = Object.assign({
+export function compileWithWebpack(
+  file: string,
+  extraConfig?: webpack.Configuration
+) {
+  const config: webpack.Configuration = {
     mode: 'development',
     entry: path.resolve(__dirname, 'fixtures', file),
     module: {
@@ -21,15 +27,47 @@ export function compileWithWebpack (file, extraConfig, cb) {
         }
       ]
     }
-  }, extraConfig)
+  }
+  if (extraConfig) {
+    Object.assign(config, extraConfig)
+  }
 
   const compiler = webpack(config)
   const fs = new MemoryFS()
   compiler.outputFileSystem = fs
 
-  compiler.run((err, stats) => {
-    expect(err).toBeFalsy()
-    expect(stats.errors).toBeFalsy()
-    cb(fs)
+  return new Promise<MemoryFS>((resolve, reject) => {
+    compiler.run((err) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(fs)
+      }
+    })
   })
 }
+
+export async function createWebpackBundleRenderer(
+  file: string,
+  options?: RenderOptions & { asBundle?: boolean }
+) {
+  const asBundle = !!(options && options.asBundle)
+  if (options) delete options.asBundle
+
+  const fs = await compileWithWebpack(file, {
+    target: 'node',
+    devtool: asBundle ? 'source-map' : false,
+    output: {
+      path: '/',
+      filename: 'bundle.js',
+      libraryTarget: 'commonjs2'
+    },
+    externals: [require.resolve('../../dist/vue.runtime.common.js')],
+    plugins: asBundle ? [new VueSSRServerPlugin()] : []
+  })
+
+  const bundle = asBundle
+    ? JSON.parse(fs.readFileSync('/vue-ssr-server-bundle.json', 'utf-8'))
+    : fs.readFileSync('/bundle.js', 'utf-8')
+  return createBundleRenderer(bundle, options)
+}
diff --git a/test/ssr/fixtures/app.ts b/test/ssr/fixtures/app.js
similarity index 100%
rename from test/ssr/fixtures/app.ts
rename to test/ssr/fixtures/app.js
diff --git a/test/ssr/fixtures/async-bar.ts b/test/ssr/fixtures/async-bar.js
similarity index 100%
rename from test/ssr/fixtures/async-bar.ts
rename to test/ssr/fixtures/async-bar.js
diff --git a/test/ssr/fixtures/async-foo.ts b/test/ssr/fixtures/async-foo.js
similarity index 100%
rename from test/ssr/fixtures/async-foo.ts
rename to test/ssr/fixtures/async-foo.js
diff --git a/test/ssr/fixtures/cache-opt-out.ts b/test/ssr/fixtures/cache-opt-out.js
similarity index 100%
rename from test/ssr/fixtures/cache-opt-out.ts
rename to test/ssr/fixtures/cache-opt-out.js
diff --git a/test/ssr/fixtures/cache.ts b/test/ssr/fixtures/cache.js
similarity index 100%
rename from test/ssr/fixtures/cache.ts
rename to test/ssr/fixtures/cache.js
diff --git a/test/ssr/fixtures/error.ts b/test/ssr/fixtures/error.js
similarity index 100%
rename from test/ssr/fixtures/error.ts
rename to test/ssr/fixtures/error.js
diff --git a/test/ssr/fixtures/nested-cache.ts b/test/ssr/fixtures/nested-cache.js
similarity index 100%
rename from test/ssr/fixtures/nested-cache.ts
rename to test/ssr/fixtures/nested-cache.js
diff --git a/test/ssr/fixtures/promise-rejection.ts b/test/ssr/fixtures/promise-rejection.js
similarity index 100%
rename from test/ssr/fixtures/promise-rejection.ts
rename to test/ssr/fixtures/promise-rejection.js
diff --git a/test/ssr/fixtures/split.ts b/test/ssr/fixtures/split.js
similarity index 100%
rename from test/ssr/fixtures/split.ts
rename to test/ssr/fixtures/split.js
diff --git a/test/ssr/ssr-basic-renderer.spec.ts b/test/ssr/ssr-basic-renderer.spec.ts
index 3a91fd40e96..286ec9104aa 100644
--- a/test/ssr/ssr-basic-renderer.spec.ts
+++ b/test/ssr/ssr-basic-renderer.spec.ts
@@ -1,8 +1,8 @@
+// @vitest-environment node
+
 import Vue from 'vue'
 import renderToString from 'web/entry-server-basic-renderer'
 
-;(global as any).__SSR_TEST__ = true
-
 describe('SSR: basicRenderer', () => {
   it('should work', done => {
     renderToString(new Vue({
diff --git a/test/ssr/ssr-bundle-render.spec.ts b/test/ssr/ssr-bundle-render.spec.ts
index c4f726cb690..fc2161276d8 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/test/ssr/ssr-bundle-render.spec.ts
@@ -1,112 +1,95 @@
+// @vitest-environment node
+
 import LRU from 'lru-cache'
-import { compileWithWebpack } from './compile-with-webpack'
-import { createBundleRenderer } from 'web/entry-server-renderer'
-import VueSSRServerPlugin from 'server/webpack-plugin/server'
-
-;(global as any).__SSR_TEST__ = true
-
-export function createRenderer (file, options, cb) {
-  if (typeof options === 'function') {
-    cb = options
-    options = undefined
-  }
-  const asBundle = !!(options && options.asBundle)
-  if (options) delete options.asBundle
-
-  compileWithWebpack(file, {
-    target: 'node',
-    devtool: asBundle ? 'source-map' : false,
-    output: {
-      path: '/',
-      filename: 'bundle.js',
-      libraryTarget: 'commonjs2'
-    },
-    externals: [require.resolve('../../dist/vue.runtime.common.js')],
-    plugins: asBundle
-      ? [new VueSSRServerPlugin()]
-      : []
-  }, fs => {
-    const bundle = asBundle
-      ? JSON.parse(fs.readFileSync('/vue-ssr-server-bundle.json', 'utf-8'))
-      : fs.readFileSync('/bundle.js', 'utf-8')
-    const renderer = createBundleRenderer(bundle, options)
-    cb(renderer)
-  })
-}
+import { createWebpackBundleRenderer } from './compile-with-webpack'
 
-describe.skip('SSR: bundle renderer', () => {
+describe('SSR: bundle renderer', () => {
   createAssertions(true)
   createAssertions(false)
 })
 
-function createAssertions (runInNewContext) {
-  it('renderToString', done => {
-    createRenderer('app.js', { runInNewContext }, renderer => {
-      const context = { url: '/test' }
-      renderer.renderToString(context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe('<div data-server-rendered="true">/test</div>')
-        expect(context.msg).toBe('hello')
-        done()
-      })
+function createAssertions(runInNewContext) {
+  it('renderToString', async () => {
+    const renderer = await createWebpackBundleRenderer('app.js', {
+      runInNewContext
     })
+    const context: any = { url: '/test' }
+    const res = await renderer.renderToString(context)
+    expect(res).toBe('<div data-server-rendered="true">/test</div>')
+    expect(context.msg).toBe('hello')
   })
 
-  it('renderToStream', done => {
-    createRenderer('app.js', { runInNewContext }, renderer => {
-      const context = { url: '/test' }
+  it('renderToStream', async () => {
+    const renderer = await createWebpackBundleRenderer('app.js', {
+      runInNewContext
+    })
+    const context: any = { url: '/test' }
+
+    const res = await new Promise((resolve, reject) => {
       const stream = renderer.renderToStream(context)
       let res = ''
-      stream.on('data', chunk => {
+      stream.on('data', (chunk) => {
         res += chunk.toString()
       })
+      stream.on('error', reject)
       stream.on('end', () => {
-        expect(res).toBe('<div data-server-rendered="true">/test</div>')
-        expect(context.msg).toBe('hello')
-        done()
+        resolve(res)
       })
     })
+
+    expect(res).toBe('<div data-server-rendered="true">/test</div>')
+    expect(context.msg).toBe('hello')
   })
 
-  it('renderToString catch error', done => {
-    createRenderer('error.js', { runInNewContext }, renderer => {
-      renderer.renderToString(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
+  it('renderToString catch error', async () => {
+    const renderer = await createWebpackBundleRenderer('error.js', {
+      runInNewContext
     })
+    try {
+      await renderer.renderToString()
+    } catch (err: any) {
+      expect(err.message).toBe('foo')
+    }
   })
 
-  it('renderToString catch Promise rejection', done => {
-    createRenderer('promise-rejection.js', { runInNewContext }, renderer => {
-      renderer.renderToString(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
+  it('renderToString catch Promise rejection', async () => {
+    const renderer = await createWebpackBundleRenderer('promise-rejection.js', {
+      runInNewContext
     })
+    try {
+      await renderer.renderToString()
+    } catch (err: any) {
+      expect(err.message).toBe('foo')
+    }
   })
 
-  it('renderToStream catch error', done => {
-    createRenderer('error.js', { runInNewContext }, renderer => {
+  it('renderToStream catch error', async () => {
+    const renderer = await createWebpackBundleRenderer('error.js', {
+      runInNewContext
+    })
+
+    const err = await new Promise<Error>((resolve) => {
       const stream = renderer.renderToStream()
-      stream.on('error', err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
+      stream.on('error', resolve)
     })
+
+    expect(err.message).toBe('foo')
   })
 
-  it('renderToStream catch Promise rejection', done => {
-    createRenderer('promise-rejection.js', { runInNewContext }, renderer => {
+  it('renderToStream catch Promise rejection', async () => {
+    const renderer = await createWebpackBundleRenderer('promise-rejection.js', {
+      runInNewContext
+    })
+
+    const err = await new Promise<Error>((resolve) => {
       const stream = renderer.renderToStream()
-      stream.on('error', err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
+      stream.on('error', resolve)
     })
+
+    expect(err.message).toBe('foo')
   })
 
-  it('render with cache (get/set)', done => {
+  it('render with cache (get/set)', async () => {
     const cache = {}
     const get = vi.fn()
     const set = vi.fn()
@@ -126,29 +109,25 @@ function createAssertions (runInNewContext) {
         }
       }
     }
-    createRenderer('cache.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      const key = 'app::1'
-      renderer.renderToString((err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(get).toHaveBeenCalledWith(key)
-        const setArgs = set.mock.calls[0]
-        expect(setArgs[0]).toBe(key)
-        expect(setArgs[1].html).toBe(expected)
-        expect(cache[key].html).toBe(expected)
-        renderer.renderToString((err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(get.mock.calls.length).toBe(2)
-          expect(set.mock.calls.length).toBe(1)
-          done()
-        })
-      })
-    })
+    const renderer = await createWebpackBundleRenderer('cache.js', options)
+    const expected = '<div data-server-rendered="true">/test</div>'
+    const key = 'app::1'
+    const res = await renderer.renderToString()
+
+    expect(res).toBe(expected)
+    expect(get).toHaveBeenCalledWith(key)
+    const setArgs = set.mock.calls[0]
+    expect(setArgs[0]).toBe(key)
+    expect(setArgs[1].html).toBe(expected)
+    expect(cache[key].html).toBe(expected)
+
+    const res2 = await renderer.renderToString()
+    expect(res2).toBe(expected)
+    expect(get.mock.calls.length).toBe(2)
+    expect(set.mock.calls.length).toBe(1)
   })
 
-  it('render with cache (get/set/has)', done => {
+  it('render with cache (get/set/has)', async () => {
     const cache = {}
     const has = vi.fn()
     const get = vi.fn()
@@ -162,7 +141,7 @@ function createAssertions (runInNewContext) {
           cb(!!cache[key])
         },
         // sync
-        get: key => {
+        get: (key) => {
           get(key)
           return cache[key]
         },
@@ -172,68 +151,60 @@ function createAssertions (runInNewContext) {
         }
       }
     }
-    createRenderer('cache.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      const key = 'app::1'
-      renderer.renderToString((err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(has).toHaveBeenCalledWith(key)
-        expect(get).not.toHaveBeenCalled()
-        const setArgs = set.mock.calls[0]
-        expect(setArgs[0]).toBe(key)
-        expect(setArgs[1].html).toBe(expected)
-        expect(cache[key].html).toBe(expected)
-        renderer.renderToString((err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(has.mock.calls.length).toBe(2)
-          expect(get.mock.calls.length).toBe(1)
-          expect(set.mock.calls.length).toBe(1)
-          done()
-        })
-      })
-    })
+    const renderer = await createWebpackBundleRenderer('cache.js', options)
+    const expected = '<div data-server-rendered="true">/test</div>'
+    const key = 'app::1'
+    const res = await renderer.renderToString()
+    expect(res).toBe(expected)
+    expect(has).toHaveBeenCalledWith(key)
+    expect(get).not.toHaveBeenCalled()
+    const setArgs = set.mock.calls[0]
+    expect(setArgs[0]).toBe(key)
+    expect(setArgs[1].html).toBe(expected)
+    expect(cache[key].html).toBe(expected)
+
+    const res2 = await renderer.renderToString()
+    expect(res2).toBe(expected)
+    expect(has.mock.calls.length).toBe(2)
+    expect(get.mock.calls.length).toBe(1)
+    expect(set.mock.calls.length).toBe(1)
   })
 
-  it('render with cache (nested)', done => {
-    const cache = new LRU({ maxAge: Infinity })
-    spyOn(cache, 'get').and.callThrough()
-    spyOn(cache, 'set').and.callThrough()
+  it('render with cache (nested)', async () => {
+    const cache = new LRU({ ttl: 65535 }) as any
+    vi.spyOn(cache, 'get')
+    vi.spyOn(cache, 'set')
     const options = {
       cache,
       runInNewContext
     }
-    createRenderer('nested-cache.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      const key = 'app::1'
-      const context1 = { registered: [] }
-      const context2 = { registered: [] }
-      renderer.renderToString(context1, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(cache.set.mock.calls.length).toBe(3) // 3 nested components cached
-        const cached = cache.get(key)
-        expect(cached.html).toBe(expected)
-        expect(cache.get.mock.calls.length).toBe(1)
-
-        // assert component usage registration for nested children
-        expect(context1.registered).toEqual(['app', 'child', 'grandchild'])
-
-        renderer.renderToString(context2, (err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(cache.set.mock.calls.length).toBe(3) // no new cache sets
-          expect(cache.get.mock.calls.length).toBe(2) // 1 get for root
-
-          expect(context2.registered).toEqual(['app', 'child', 'grandchild'])
-          done()
-        })
-      })
-    })
+    const renderer = await createWebpackBundleRenderer(
+      'nested-cache.js',
+      options
+    )
+    const expected = '<div data-server-rendered="true">/test</div>'
+    const key = 'app::1'
+    const context1 = { registered: [] }
+    const context2 = { registered: [] }
+    const res = await renderer.renderToString(context1)
+    expect(res).toBe(expected)
+    expect(cache.set.mock.calls.length).toBe(3) // 3 nested components cached
+    const cached = cache.get(key)
+    expect(cached.html).toBe(expected)
+    expect(cache.get.mock.calls.length).toBe(1)
+
+    // assert component usage registration for nested children
+    expect(context1.registered).toEqual(['app', 'child', 'grandchild'])
+
+    const res2 = await renderer.renderToString(context2)
+    expect(res2).toBe(expected)
+    expect(cache.set.mock.calls.length).toBe(3) // no new cache sets
+    expect(cache.get.mock.calls.length).toBe(2) // 1 get for root
+
+    expect(context2.registered).toEqual(['app', 'child', 'grandchild'])
   })
 
-  it('render with cache (opt-out)', done => {
+  it('render with cache (opt-out)', async () => {
     const cache = {}
     const get = vi.fn()
     const set = vi.fn()
@@ -253,97 +224,103 @@ function createAssertions (runInNewContext) {
         }
       }
     }
-    createRenderer('cache-opt-out.js', options, renderer => {
-      const expected = '<div data-server-rendered="true">/test</div>'
-      renderer.renderToString((err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe(expected)
-        expect(get).not.toHaveBeenCalled()
-        expect(set).not.toHaveBeenCalled()
-        renderer.renderToString((err, res) => {
-          expect(err).toBeNull()
-          expect(res).toBe(expected)
-          expect(get).not.toHaveBeenCalled()
-          expect(set).not.toHaveBeenCalled()
-          done()
-        })
-      })
-    })
+    const renderer = await createWebpackBundleRenderer(
+      'cache-opt-out.js',
+      options
+    )
+    const expected = '<div data-server-rendered="true">/test</div>'
+    const res = await renderer.renderToString()
+    expect(res).toBe(expected)
+    expect(get).not.toHaveBeenCalled()
+    expect(set).not.toHaveBeenCalled()
+    const res2 = await renderer.renderToString()
+    expect(res2).toBe(expected)
+    expect(get).not.toHaveBeenCalled()
+    expect(set).not.toHaveBeenCalled()
   })
 
-  it('renderToString (bundle format with code split)', done => {
-    createRenderer('split.js', { runInNewContext, asBundle: true }, renderer => {
-      const context = { url: '/test' }
-      renderer.renderToString(context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toBe('<div data-server-rendered="true">/test<div>async test.woff2 test.png</div></div>')
-        done()
-      })
+  it('renderToString (bundle format with code split)', async () => {
+    const renderer = await createWebpackBundleRenderer('split.js', {
+      runInNewContext,
+      asBundle: true
     })
+    const context = { url: '/test' }
+    const res = await renderer.renderToString(context)
+    expect(res).toBe(
+      '<div data-server-rendered="true">/test<div>async test.woff2 test.png</div></div>'
+    )
   })
 
-  it('renderToStream (bundle format with code split)', done => {
-    createRenderer('split.js', { runInNewContext, asBundle: true }, renderer => {
-      const context = { url: '/test' }
+  it('renderToStream (bundle format with code split)', async () => {
+    const renderer = await createWebpackBundleRenderer('split.js', {
+      runInNewContext,
+      asBundle: true
+    })
+    const context = { url: '/test' }
+
+    const res = await new Promise((resolve, reject) => {
       const stream = renderer.renderToStream(context)
       let res = ''
-      stream.on('data', chunk => {
+      stream.on('data', (chunk) => {
         res += chunk.toString()
       })
+      stream.on('error', reject)
       stream.on('end', () => {
-        expect(res).toBe('<div data-server-rendered="true">/test<div>async test.woff2 test.png</div></div>')
-        done()
+        resolve(res)
       })
     })
+
+    expect(res).toBe(
+      '<div data-server-rendered="true">/test<div>async test.woff2 test.png</div></div>'
+    )
   })
 
-  it('renderToString catch error (bundle format with source map)', done => {
-    createRenderer('error.js', { runInNewContext, asBundle: true }, renderer => {
-      renderer.renderToString(err => {
-        expect(err.stack).toContain('test/ssr/fixtures/error.js:1:6')
-        expect(err.message).toBe('foo')
-        done()
-      })
+  it('renderToString catch error (bundle format with source map)', async () => {
+    const renderer = await createWebpackBundleRenderer('error.js', {
+      runInNewContext,
+      asBundle: true
     })
+
+    try {
+      await renderer.renderToString()
+    } catch (err: any) {
+      expect(err.stack).toContain('test/ssr/fixtures/error.js:1:0')
+      expect(err.message).toBe('foo')
+    }
   })
 
-  it('renderToString catch error (bundle format with source map)', done => {
-    createRenderer('error.js', { runInNewContext, asBundle: true }, renderer => {
-      const stream = renderer.renderToStream()
-      stream.on('error', err => {
-        expect(err.stack).toContain('test/ssr/fixtures/error.js:1:6')
-        expect(err.message).toBe('foo')
-        done()
-      })
+  it('renderToStream catch error (bundle format with source map)', async () => {
+    const renderer = await createWebpackBundleRenderer('error.js', {
+      runInNewContext,
+      asBundle: true
     })
-  })
 
-  it('renderToString return Promise', done => {
-    createRenderer('app.js', { runInNewContext }, renderer => {
-      const context = { url: '/test' }
-      renderer.renderToString(context).then(res => {
-        expect(res).toBe('<div data-server-rendered="true">/test</div>')
-        expect(context.msg).toBe('hello')
-        done()
-      })
+    const err = await new Promise<Error>((resolve) => {
+      const stream = renderer.renderToStream()
+      stream.on('error', resolve)
     })
+
+    expect(err.stack).toContain('test/ssr/fixtures/error.js:1:0')
+    expect(err.message).toBe('foo')
   })
 
-  it('renderToString return Promise (error)', done => {
-    createRenderer('error.js', { runInNewContext }, renderer => {
-      renderer.renderToString().catch(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
+  it('renderToString w/ callback', async () => {
+    const renderer = await createWebpackBundleRenderer('app.js', {
+      runInNewContext
     })
+    const context: any = { url: '/test' }
+    const res = await new Promise((r) =>
+      renderer.renderToString(context, (_err, res) => r(res))
+    )
+    expect(res).toBe('<div data-server-rendered="true">/test</div>')
+    expect(context.msg).toBe('hello')
   })
 
-  it('renderToString return Promise (Promise rejection)', done => {
-    createRenderer('promise-rejection.js', { runInNewContext }, renderer => {
-      renderer.renderToString().catch(err => {
-        expect(err.message).toBe('foo')
-        done()
-      })
+  it('renderToString error handling w/ callback', async () => {
+    const renderer = await createWebpackBundleRenderer('error.js', {
+      runInNewContext
     })
+    const err = await new Promise<Error>((r) => renderer.renderToString(r))
+    expect(err.message).toBe('foo')
   })
 }
diff --git a/test/ssr/ssr-stream.spec.ts b/test/ssr/ssr-stream.spec.ts
index 000d201a1a7..e4157f03bd2 100644
--- a/test/ssr/ssr-stream.spec.ts
+++ b/test/ssr/ssr-stream.spec.ts
@@ -1,9 +1,9 @@
+// @vitest-environment node
+
 import Vue from 'vue'
 import { createRenderer } from 'web/entry-server-renderer'
 const { renderToStream } = createRenderer()
 
-;(global as any).__SSR_TEST__ = true
-
 describe('SSR: renderToStream', () => {
   it('should render to a stream', done => {
     const stream = renderToStream(new Vue({
diff --git a/test/ssr/ssr-string.spec.ts b/test/ssr/ssr-string.spec.ts
index ffa4a390195..d3d3dc49ea2 100644
--- a/test/ssr/ssr-string.spec.ts
+++ b/test/ssr/ssr-string.spec.ts
@@ -1,10 +1,10 @@
+// @vitest-environment node
+
 import Vue from 'vue'
 import VM from 'vm'
 import { createRenderer } from 'web/entry-server-renderer'
 const { renderToString } = createRenderer()
 
-;(global as any).__SSR_TEST__ = true
-
 describe('SSR: renderToString', () => {
   it('static attributes', done => {
     renderVmWithOptions({
diff --git a/test/ssr/ssr-template.spec.ts b/test/ssr/ssr-template.spec.ts
index 6f5d6563bf3..8c77c89d4bc 100644
--- a/test/ssr/ssr-template.spec.ts
+++ b/test/ssr/ssr-template.spec.ts
@@ -1,16 +1,19 @@
+// @vitest-environment node
+
 import Vue from 'vue'
-import { compileWithWebpack } from './compile-with-webpack'
+import {
+  compileWithWebpack,
+  createWebpackBundleRenderer
+} from './compile-with-webpack'
 import { createRenderer } from 'web/entry-server-renderer'
 import VueSSRClientPlugin from 'server/webpack-plugin/client'
-import { createRenderer as createBundleRenderer } from './ssr-bundle-render.spec.js'
-
-;(global as any).__SSR_TEST__ = true
+import { RenderOptions } from '../../src/server/create-renderer'
 
 const defaultTemplate = `<html><head></head><body><!--vue-ssr-outlet--></body></html>`
 const interpolateTemplate = `<html><head><title>{{ title }}</title></head><body><!--vue-ssr-outlet-->{{{ snippet }}}</body></html>`
 
-function generateClientManifest (file, cb) {
-  compileWithWebpack(file, {
+async function generateClientManifest(file: string) {
+  const fs = await compileWithWebpack(file, {
     output: {
       path: '/',
       publicPath: '/',
@@ -21,30 +24,31 @@ function generateClientManifest (file, cb) {
         name: 'manifest'
       }
     },
-    plugins: [
-      new VueSSRClientPlugin()
-    ]
-  }, fs => {
-    cb(JSON.parse(fs.readFileSync('/vue-ssr-client-manifest.json', 'utf-8')))
+    plugins: [new VueSSRClientPlugin()]
   })
+  return JSON.parse(fs.readFileSync('/vue-ssr-client-manifest.json', 'utf-8'))
 }
 
-function createRendererWithManifest (file, options, cb) {
-  if (typeof options === 'function') {
-    cb = options
-    options = null
-  }
-  generateClientManifest(file, clientManifest => {
-    createBundleRenderer(file, Object.assign({
-      asBundle: true,
-      template: defaultTemplate,
-      clientManifest
-    }, options), cb)
-  })
+async function createRendererWithManifest(
+  file: string,
+  options?: RenderOptions
+) {
+  const clientManifest = await generateClientManifest(file)
+  return createWebpackBundleRenderer(
+    file,
+    Object.assign(
+      {
+        asBundle: true,
+        template: defaultTemplate,
+        clientManifest
+      },
+      options
+    )
+  )
 }
 
-describe.skip('SSR: template option', () => {
-  it('renderToString', done => {
+describe('SSR: template option', () => {
+  it('renderToString', async () => {
     const renderer = createRenderer({
       template: defaultTemplate
     })
@@ -55,21 +59,22 @@ describe.skip('SSR: template option', () => {
       state: { a: 1 }
     }
 
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(
-        `<html><head>${context.head}${context.styles}</head><body>` +
+    const res = await renderer.renderToString(
+      new Vue({
+        template: '<div>hi</div>'
+      }),
+      context
+    )
+
+    expect(res).toContain(
+      `<html><head>${context.head}${context.styles}</head><body>` +
         `<div data-server-rendered="true">hi</div>` +
         `<script>window.__INITIAL_STATE__={"a":1}</script>` +
         `</body></html>`
-      )
-      done()
-    })
+    )
   })
 
-  it('renderToString with interpolation', done => {
+  it('renderToString with interpolation', async () => {
     const renderer = createRenderer({
       template: interpolateTemplate
     })
@@ -82,12 +87,15 @@ describe.skip('SSR: template option', () => {
       state: { a: 1 }
     }
 
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(
-        `<html><head>` +
+    const res = await renderer.renderToString(
+      new Vue({
+        template: '<div>hi</div>'
+      }),
+      context
+    )
+
+    expect(res).toContain(
+      `<html><head>` +
         // double mustache should be escaped
         `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
         `${context.head}${context.styles}</head><body>` +
@@ -96,12 +104,10 @@ describe.skip('SSR: template option', () => {
         // triple should be raw
         `<div>foo</div>` +
         `</body></html>`
-      )
-      done()
-    })
+    )
   })
 
-  it('renderToString with interpolation and context.rendered', done => {
+  it('renderToString with interpolation and context.rendered', async () => {
     const renderer = createRenderer({
       template: interpolateTemplate
     })
@@ -112,17 +118,19 @@ describe.skip('SSR: template option', () => {
       head: '<meta name="viewport" content="width=device-width">',
       styles: '<style>h1 { color: red }</style>',
       state: { a: 0 },
-      rendered: context => {
+      rendered: (context) => {
         context.state.a = 1
       }
     }
 
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(
-        `<html><head>` +
+    const res = await renderer.renderToString(
+      new Vue({
+        template: '<div>hi</div>'
+      }),
+      context
+    )
+    expect(res).toContain(
+      `<html><head>` +
         // double mustache should be escaped
         `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
         `${context.head}${context.styles}</head><body>` +
@@ -131,74 +139,84 @@ describe.skip('SSR: template option', () => {
         // triple should be raw
         `<div>foo</div>` +
         `</body></html>`
-      )
-      done()
-    })
+    )
   })
 
-  it('renderToString w/ template function', done => {
+  it('renderToString w/ template function', async () => {
     const renderer = createRenderer({
-      template: (content, context) => `<html><head>${context.head}</head>${content}</html>`
+      template: (content, context) =>
+        `<html><head>${context.head}</head>${content}</html>`
     })
 
     const context = {
       head: '<meta name="viewport" content="width=device-width">'
     }
 
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(`<html><head>${context.head}</head><div data-server-rendered="true">hi</div></html>`)
-      done()
-    })
+    const res = await renderer.renderToString(
+      new Vue({
+        template: '<div>hi</div>'
+      }),
+      context
+    )
+
+    expect(res).toContain(
+      `<html><head>${context.head}</head><div data-server-rendered="true">hi</div></html>`
+    )
   })
 
-  it('renderToString w/ template function returning Promise', done => {
+  it('renderToString w/ template function returning Promise', async () => {
     const renderer = createRenderer({
-      template: (content, context) => new Promise((resolve) => {
-        setTimeout(() => {
-          resolve(`<html><head>${context.head}</head>${content}</html>`)
-        }, 0)
-      })
+      template: (content, context) =>
+        new Promise<string>((resolve) => {
+          setTimeout(() => {
+            resolve(`<html><head>${context.head}</head>${content}</html>`)
+          }, 0)
+        })
     })
 
     const context = {
       head: '<meta name="viewport" content="width=device-width">'
     }
 
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain(`<html><head>${context.head}</head><div data-server-rendered="true">hi</div></html>`)
-      done()
-    })
+    const res = await renderer.renderToString(
+      new Vue({
+        template: '<div>hi</div>'
+      }),
+      context
+    )
+
+    expect(res).toContain(
+      `<html><head>${context.head}</head><div data-server-rendered="true">hi</div></html>`
+    )
   })
 
-  it('renderToString w/ template function returning Promise w/ rejection', done => {
+  it('renderToString w/ template function returning Promise w/ rejection', async () => {
     const renderer = createRenderer({
-      template: () => new Promise((resolve, reject) => {
-        setTimeout(() => {
-          reject(new Error(`foo`))
-        }, 0)
-      })
+      template: () =>
+        new Promise((resolve, reject) => {
+          setTimeout(() => {
+            reject(new Error(`foo`))
+          }, 0)
+        })
     })
 
     const context = {
       head: '<meta name="viewport" content="width=device-width">'
     }
 
-    renderer.renderToString(new Vue({
-      template: '<div>hi</div>'
-    }), context, (err, res) => {
+    try {
+      await renderer.renderToString(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
+    } catch (err: any) {
       expect(err.message).toBe(`foo`)
-      expect(res).toBeUndefined()
-      done()
-    })
+    }
   })
 
-  it('renderToStream', done => {
+  it('renderToStream', async () => {
     const renderer = createRenderer({
       template: defaultTemplate
     })
@@ -209,26 +227,33 @@ describe.skip('SSR: template option', () => {
       state: { a: 1 }
     }
 
-    const stream = renderer.renderToStream(new Vue({
-      template: '<div>hi</div>'
-    }), context)
+    const res = await new Promise((resolve, reject) => {
+      const stream = renderer.renderToStream(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
 
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
+      let res = ''
+      stream.on('data', (chunk) => {
+        res += chunk
+      })
+      stream.on('error', reject)
+      stream.on('end', () => {
+        resolve(res)
+      })
     })
-    stream.on('end', () => {
-      expect(res).toContain(
-        `<html><head>${context.head}${context.styles}</head><body>` +
+
+    expect(res).toContain(
+      `<html><head>${context.head}${context.styles}</head><body>` +
         `<div data-server-rendered="true">hi</div>` +
         `<script>window.__INITIAL_STATE__={"a":1}</script>` +
         `</body></html>`
-      )
-      done()
-    })
+    )
   })
 
-  it('renderToStream with interpolation', done => {
+  it('renderToStream with interpolation', async () => {
     const renderer = createRenderer({
       template: interpolateTemplate
     })
@@ -241,17 +266,26 @@ describe.skip('SSR: template option', () => {
       state: { a: 1 }
     }
 
-    const stream = renderer.renderToStream(new Vue({
-      template: '<div>hi</div>'
-    }), context)
+    const res = await new Promise((resolve, reject) => {
+      const stream = renderer.renderToStream(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
 
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
+      let res = ''
+      stream.on('data', (chunk) => {
+        res += chunk
+      })
+      stream.on('error', reject)
+      stream.on('end', () => {
+        resolve(res)
+      })
     })
-    stream.on('end', () => {
-      expect(res).toContain(
-        `<html><head>` +
+
+    expect(res).toContain(
+      `<html><head>` +
         // double mustache should be escaped
         `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
         `${context.head}${context.styles}</head><body>` +
@@ -260,12 +294,10 @@ describe.skip('SSR: template option', () => {
         // triple should be raw
         `<div>foo</div>` +
         `</body></html>`
-      )
-      done()
-    })
+    )
   })
 
-  it('renderToStream with interpolation and context.rendered', done => {
+  it('renderToStream with interpolation and context.rendered', async () => {
     const renderer = createRenderer({
       template: interpolateTemplate
     })
@@ -276,22 +308,31 @@ describe.skip('SSR: template option', () => {
       head: '<meta name="viewport" content="width=device-width">',
       styles: '<style>h1 { color: red }</style>',
       state: { a: 0 },
-      rendered: context => {
+      rendered: (context) => {
         context.state.a = 1
       }
     }
 
-    const stream = renderer.renderToStream(new Vue({
-      template: '<div>hi</div>'
-    }), context)
+    const res = await new Promise((resolve, reject) => {
+      const stream = renderer.renderToStream(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
 
-    let res = ''
-    stream.on('data', chunk => {
-      res += chunk
+      let res = ''
+      stream.on('data', (chunk) => {
+        res += chunk
+      })
+      stream.on('error', reject)
+      stream.on('end', () => {
+        resolve(res)
+      })
     })
-    stream.on('end', () => {
-      expect(res).toContain(
-        `<html><head>` +
+
+    expect(res).toContain(
+      `<html><head>` +
         // double mustache should be escaped
         `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
         `${context.head}${context.styles}</head><body>` +
@@ -300,201 +341,211 @@ describe.skip('SSR: template option', () => {
         // triple should be raw
         `<div>foo</div>` +
         `</body></html>`
-      )
-      done()
-    })
+    )
   })
 
-  it('bundleRenderer + renderToString', done => {
-    createBundleRenderer('app.js', {
+  it('bundleRenderer + renderToString', async () => {
+    const renderer = await createWebpackBundleRenderer('app.js', {
       asBundle: true,
       template: defaultTemplate
-    }, renderer => {
-      const context = {
-        head: '<meta name="viewport" content="width=device-width">',
-        styles: '<style>h1 { color: red }</style>',
-        state: { a: 1 },
-        url: '/test'
-      }
-      renderer.renderToString(context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<html><head>${context.head}${context.styles}</head><body>` +
-          `<div data-server-rendered="true">/test</div>` +
-          `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-          `</body></html>`
-        )
-        expect(context.msg).toBe('hello')
-        done()
-      })
     })
+    const context: any = {
+      head: '<meta name="viewport" content="width=device-width">',
+      styles: '<style>h1 { color: red }</style>',
+      state: { a: 1 },
+      url: '/test'
+    }
+    const res = await renderer.renderToString(context)
+    expect(res).toContain(
+      `<html><head>${context.head}${context.styles}</head><body>` +
+        `<div data-server-rendered="true">/test</div>` +
+        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
+        `</body></html>`
+    )
+    expect(context.msg).toBe('hello')
   })
 
-  it('bundleRenderer + renderToStream', done => {
-    createBundleRenderer('app.js', {
+  it('bundleRenderer + renderToStream', async () => {
+    const renderer = await createWebpackBundleRenderer('app.js', {
       asBundle: true,
       template: defaultTemplate
-    }, renderer => {
-      const context = {
-        head: '<meta name="viewport" content="width=device-width">',
-        styles: '<style>h1 { color: red }</style>',
-        state: { a: 1 },
-        url: '/test'
-      }
+    })
+    const context: any = {
+      head: '<meta name="viewport" content="width=device-width">',
+      styles: '<style>h1 { color: red }</style>',
+      state: { a: 1 },
+      url: '/test'
+    }
+
+    const res = await new Promise((resolve) => {
       const stream = renderer.renderToStream(context)
       let res = ''
-      stream.on('data', chunk => {
+      stream.on('data', (chunk) => {
         res += chunk.toString()
       })
       stream.on('end', () => {
-        expect(res).toContain(
-          `<html><head>${context.head}${context.styles}</head><body>` +
-          `<div data-server-rendered="true">/test</div>` +
-          `<script>window.__INITIAL_STATE__={"a":1}</script>` +
-          `</body></html>`
-        )
-        expect(context.msg).toBe('hello')
-        done()
+        resolve(res)
       })
     })
+
+    expect(res).toContain(
+      `<html><head>${context.head}${context.styles}</head><body>` +
+        `<div data-server-rendered="true">/test</div>` +
+        `<script>window.__INITIAL_STATE__={"a":1}</script>` +
+        `</body></html>`
+    )
+    expect(context.msg).toBe('hello')
   })
 
-  const expectedHTMLWithManifest = (options = {}) =>
+  const expectedHTMLWithManifest = (options: any = {}) =>
     `<html><head>` +
-      // used chunks should have preload
-      `<link rel="preload" href="/manifest.js" as="script">` +
-      `<link rel="preload" href="/main.js" as="script">` +
-      `<link rel="preload" href="/0.js" as="script">` +
-      `<link rel="preload" href="/test.css" as="style">` +
-      // images and fonts are only preloaded when explicitly asked for
-      (options.preloadOtherAssets ? `<link rel="preload" href="/test.png" as="image">` : ``) +
-      (options.preloadOtherAssets ? `<link rel="preload" href="/test.woff2" as="font" type="font/woff2" crossorigin>` : ``) +
-      // unused chunks should have prefetch
-      (options.noPrefetch ? `` : `<link rel="prefetch" href="/1.js">`) +
-      // css assets should be loaded
-      `<link rel="stylesheet" href="/test.css">` +
+    // used chunks should have preload
+    `<link rel="preload" href="/manifest.js" as="script">` +
+    `<link rel="preload" href="/main.js" as="script">` +
+    `<link rel="preload" href="/0.js" as="script">` +
+    `<link rel="preload" href="/test.css" as="style">` +
+    // images and fonts are only preloaded when explicitly asked for
+    (options.preloadOtherAssets
+      ? `<link rel="preload" href="/test.png" as="image">`
+      : ``) +
+    (options.preloadOtherAssets
+      ? `<link rel="preload" href="/test.woff2" as="font" type="font/woff2" crossorigin>`
+      : ``) +
+    // unused chunks should have prefetch
+    (options.noPrefetch ? `` : `<link rel="prefetch" href="/1.js">`) +
+    // css assets should be loaded
+    `<link rel="stylesheet" href="/test.css">` +
     `</head><body>` +
-      `<div data-server-rendered="true"><div>async test.woff2 test.png</div></div>` +
-      // state should be inlined before scripts
-      `<script>window.${options.stateKey || '__INITIAL_STATE__'}={"a":1}</script>` +
-      // manifest chunk should be first
-      `<script src="/manifest.js" defer></script>` +
-      // async chunks should be before main chunk
-      `<script src="/0.js" defer></script>` +
-      `<script src="/main.js" defer></script>` +
+    `<div data-server-rendered="true"><div>async test.woff2 test.png</div></div>` +
+    // state should be inlined before scripts
+    `<script>window.${
+      options.stateKey || '__INITIAL_STATE__'
+    }={"a":1}</script>` +
+    // manifest chunk should be first
+    `<script src="/manifest.js" defer></script>` +
+    // async chunks should be before main chunk
+    `<script src="/0.js" defer></script>` +
+    `<script src="/main.js" defer></script>` +
     `</body></html>`
 
   createClientManifestAssertions(true)
   createClientManifestAssertions(false)
 
-  function createClientManifestAssertions (runInNewContext) {
-    it('bundleRenderer + renderToString + clientManifest ()', done => {
-      createRendererWithManifest('split.js', { runInNewContext }, renderer => {
-        renderer.renderToString({ state: { a: 1 }}, (err, res) => {
-          expect(err).toBeNull()
-          expect(res).toContain(expectedHTMLWithManifest())
-          done()
-        })
+  function createClientManifestAssertions(runInNewContext) {
+    it('bundleRenderer + renderToString + clientManifest ()', async () => {
+      const renderer = await createRendererWithManifest('split.js', {
+        runInNewContext
       })
+      const res = await renderer.renderToString({ state: { a: 1 } })
+      expect(res).toContain(expectedHTMLWithManifest())
     })
 
-    it('bundleRenderer + renderToStream + clientManifest + shouldPreload', done => {
-      createRendererWithManifest('split.js', {
+    it('bundleRenderer + renderToStream + clientManifest + shouldPreload', async () => {
+      const renderer = await createRendererWithManifest('split.js', {
         runInNewContext,
         shouldPreload: (file, type) => {
-          if (type === 'image' || type === 'script' || type === 'font' || type === 'style') {
+          if (
+            type === 'image' ||
+            type === 'script' ||
+            type === 'font' ||
+            type === 'style'
+          ) {
             return true
           }
         }
-      }, renderer => {
-        const stream = renderer.renderToStream({ state: { a: 1 }})
+      })
+      const res = await new Promise((resolve) => {
+        const stream = renderer.renderToStream({ state: { a: 1 } })
         let res = ''
-        stream.on('data', chunk => {
+        stream.on('data', (chunk) => {
           res += chunk.toString()
         })
         stream.on('end', () => {
-          expect(res).toContain(expectedHTMLWithManifest({
-            preloadOtherAssets: true
-          }))
-          done()
+          resolve(res)
         })
       })
+
+      expect(res).toContain(
+        expectedHTMLWithManifest({
+          preloadOtherAssets: true
+        })
+      )
     })
 
-    it('bundleRenderer + renderToStream + clientManifest + shouldPrefetch', done => {
-      createRendererWithManifest('split.js', {
+    it('bundleRenderer + renderToStream + clientManifest + shouldPrefetch', async () => {
+      const renderer = await createRendererWithManifest('split.js', {
         runInNewContext,
         shouldPrefetch: (file, type) => {
           if (type === 'script') {
             return false
           }
         }
-      }, renderer => {
-        const stream = renderer.renderToStream({ state: { a: 1 }})
+      })
+
+      const res = await new Promise((resolve) => {
+        const stream = renderer.renderToStream({ state: { a: 1 } })
         let res = ''
-        stream.on('data', chunk => {
+        stream.on('data', (chunk) => {
           res += chunk.toString()
         })
         stream.on('end', () => {
-          expect(res).toContain(expectedHTMLWithManifest({
-            noPrefetch: true
-          }))
-          done()
+          resolve(res)
         })
       })
+
+      expect(res).toContain(
+        expectedHTMLWithManifest({
+          noPrefetch: true
+        })
+      )
     })
 
-    it('bundleRenderer + renderToString + clientManifest + inject: false', done => {
-      createRendererWithManifest('split.js', {
+    it('bundleRenderer + renderToString + clientManifest + inject: false', async () => {
+      const renderer = await createRendererWithManifest('split.js', {
         runInNewContext,
-        template: `<html>` +
+        template:
+          `<html>` +
           `<head>{{{ renderResourceHints() }}}{{{ renderStyles() }}}</head>` +
           `<body><!--vue-ssr-outlet-->{{{ renderState({ windowKey: '__FOO__', contextKey: 'foo' }) }}}{{{ renderScripts() }}}</body>` +
-        `</html>`,
+          `</html>`,
         inject: false
-      }, renderer => {
-        const context = { foo: { a: 1 }}
-        renderer.renderToString(context, (err, res) => {
-          expect(err).toBeNull()
-          expect(res).toContain(expectedHTMLWithManifest({
-            stateKey: '__FOO__'
-          }))
-          done()
-        })
       })
+      const context = { foo: { a: 1 } }
+      const res = await renderer.renderToString(context)
+      expect(res).toContain(
+        expectedHTMLWithManifest({
+          stateKey: '__FOO__'
+        })
+      )
     })
 
-    it('bundleRenderer + renderToString + clientManifest + no template', done => {
-      createRendererWithManifest('split.js', {
+    it('bundleRenderer + renderToString + clientManifest + no template', async () => {
+      const renderer = await createRendererWithManifest('split.js', {
         runInNewContext,
-        template: null
-      }, renderer => {
-        const context = { foo: { a: 1 }}
-        renderer.renderToString(context, (err, res) => {
-          expect(err).toBeNull()
-
-          const customOutput =
-            `<html><head>${
-              context.renderResourceHints() +
-              context.renderStyles()
-            }</head><body>${
-              res +
-              context.renderState({
-                windowKey: '__FOO__',
-                contextKey: 'foo'
-              }) +
-              context.renderScripts()
-            }</body></html>`
-
-          expect(customOutput).toContain(expectedHTMLWithManifest({
-            stateKey: '__FOO__'
-          }))
-          done()
-        })
+        template: null as any
       })
+      const context: any = { foo: { a: 1 } }
+      const res = await renderer.renderToString(context)
+
+      const customOutput = `<html><head>${
+        context.renderResourceHints() + context.renderStyles()
+      }</head><body>${
+        res +
+        context.renderState({
+          windowKey: '__FOO__',
+          contextKey: 'foo'
+        }) +
+        context.renderScripts()
+      }</body></html>`
+
+      expect(customOutput).toContain(
+        expectedHTMLWithManifest({
+          stateKey: '__FOO__'
+        })
+      )
     })
 
-    it('whitespace insensitive interpolation', done => {
+    it('whitespace insensitive interpolation', async () => {
       const interpolateTemplate = `<html><head><title>{{title}}</title></head><body><!--vue-ssr-outlet-->{{{snippet}}}</body></html>`
       const renderer = createRenderer({
         template: interpolateTemplate
@@ -508,12 +559,14 @@ describe.skip('SSR: template option', () => {
         state: { a: 1 }
       }
 
-      renderer.renderToString(new Vue({
-        template: '<div>hi</div>'
-      }), context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<html><head>` +
+      const res = await renderer.renderToString(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
+      expect(res).toContain(
+        `<html><head>` +
           // double mustache should be escaped
           `<title>&lt;script&gt;hacks&lt;/script&gt;</title>` +
           `${context.head}${context.styles}</head><body>` +
@@ -522,12 +575,10 @@ describe.skip('SSR: template option', () => {
           // triple should be raw
           `<div>foo</div>` +
           `</body></html>`
-        )
-        done()
-      })
+      )
     })
 
-    it('renderToString + nonce', done => {
+    it('renderToString + nonce', async () => {
       const interpolateTemplate = `<html><head><title>hello</title></head><body><!--vue-ssr-outlet--></body></html>`
       const renderer = createRenderer({
         template: interpolateTemplate
@@ -538,23 +589,23 @@ describe.skip('SSR: template option', () => {
         nonce: '4AEemGb0xJptoIGFP3Nd'
       }
 
-      renderer.renderToString(new Vue({
-        template: '<div>hi</div>'
-      }), context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<html><head>` +
+      const res = await renderer.renderToString(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
+      expect(res).toContain(
+        `<html><head>` +
           `<title>hello</title>` +
           `</head><body>` +
           `<div data-server-rendered="true">hi</div>` +
           `<script nonce="4AEemGb0xJptoIGFP3Nd">window.__INITIAL_STATE__={"a":1}</script>` +
           `</body></html>`
-        )
-        done()
-      })
+      )
     })
 
-    it('renderToString + custom serializer', done => {
+    it('renderToString + custom serializer', async () => {
       const expected = `{"foo":123}`
       const renderer = createRenderer({
         template: defaultTemplate,
@@ -565,15 +616,15 @@ describe.skip('SSR: template option', () => {
         state: { a: 1 }
       }
 
-      renderer.renderToString(new Vue({
-        template: '<div>hi</div>'
-      }), context, (err, res) => {
-        expect(err).toBeNull()
-        expect(res).toContain(
-          `<script>window.__INITIAL_STATE__=${expected}</script>`
-        )
-        done()
-      })
+      const res = await renderer.renderToString(
+        new Vue({
+          template: '<div>hi</div>'
+        }),
+        context
+      )
+      expect(res).toContain(
+        `<script>window.__INITIAL_STATE__=${expected}</script>`
+      )
     })
   }
 })
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index 03baf752020..645dd2289b2 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -1,5 +1,3 @@
-;(global as any).__SSR_TEST__ = false
-
 process.env.NEW_SLOT_SYNTAX = 'true'
 
 import './helpers/shim-done'

From d000703c8019278c76d2c1e7ce8d3d81a8b55ba9 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 16:59:55 +0800
Subject: [PATCH 059/317] workflow: build ssr packages before running ssr tests

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9082038c2d9..149a1c36219 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
     "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run test/unit",
-    "test:ssr": "vitest run test/ssr",
+    "test:ssr": "npm run build:ssr && vitest run test/ssr",
     "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.ts",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",

From acb1aeed6d5d76c8385290a3c1c33cef077056fd Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 17:18:39 +0800
Subject: [PATCH 060/317] chore: remove unused deps

---
 package.json   |   3 -
 pnpm-lock.yaml | 171 +------------------------------------------------
 2 files changed, 1 insertion(+), 173 deletions(-)

diff --git a/package.json b/package.json
index 149a1c36219..b24c8326dfa 100644
--- a/package.json
+++ b/package.json
@@ -77,10 +77,8 @@
     "escodegen": "^2.0.0",
     "eslint": "^8.14.0",
     "file-loader": "^3.0.1",
-    "fsevents": "2.3.2",
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
-    "http-server": "^14.1.0",
     "jsdom": "^19.0.0",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
@@ -94,7 +92,6 @@
     "serialize-javascript": "^6.0.0",
     "shelljs": "^0.8.5",
     "source-map": "0.5.6",
-    "stream-browserify": "^3.0.0",
     "terser": "^5.13.1",
     "ts-node": "^10.7.0",
     "tslib": "^2.4.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 6b0ebacb2c9..c757942464f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -20,10 +20,8 @@ specifiers:
   escodegen: ^2.0.0
   eslint: ^8.14.0
   file-loader: ^3.0.1
-  fsevents: 2.3.2
   hash-sum: ^2.0.0
   he: ^1.2.0
-  http-server: ^14.1.0
   jsdom: ^19.0.0
   lint-staged: ^12.4.1
   lodash: ^4.17.21
@@ -37,7 +35,6 @@ specifiers:
   serialize-javascript: ^6.0.0
   shelljs: ^0.8.5
   source-map: 0.5.6
-  stream-browserify: ^3.0.0
   terser: ^5.13.1
   ts-node: ^10.7.0
   tslib: ^2.4.0
@@ -66,10 +63,8 @@ devDependencies:
   escodegen: 2.0.0
   eslint: 8.15.0
   file-loader: 3.0.1_webpack@4.46.0
-  fsevents: 2.3.2
   hash-sum: 2.0.0
   he: 1.2.0
-  http-server: 14.1.0
   jsdom: 19.0.0
   lint-staged: 12.4.1
   lodash: 4.17.21
@@ -83,7 +78,6 @@ devDependencies:
   serialize-javascript: 6.0.0
   shelljs: 0.8.5
   source-map: 0.5.6
-  stream-browserify: 3.0.0
   terser: 5.13.1
   ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
   tslib: 2.4.0
@@ -905,12 +899,6 @@ packages:
     dev: true
     optional: true
 
-  /async/2.6.4:
-    resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==}
-    dependencies:
-      lodash: 4.17.21
-    dev: true
-
   /asynckit/0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
     dev: true
@@ -942,13 +930,6 @@ packages:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
     dev: true
 
-  /basic-auth/2.0.1:
-    resolution: {integrity: sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==}
-    engines: {node: '>= 0.8'}
-    dependencies:
-      safe-buffer: 5.1.2
-    dev: true
-
   /big.js/5.2.2:
     resolution: {integrity: sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==}
     dev: true
@@ -1144,13 +1125,6 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /call-bind/1.0.2:
-    resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
-    dependencies:
-      function-bind: 1.1.1
-      get-intrinsic: 1.1.1
-    dev: true
-
   /callsites/3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
@@ -1604,11 +1578,6 @@ packages:
     resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
     dev: true
 
-  /corser/2.0.1:
-    resolution: {integrity: sha1-jtolLsqrWEDc2XXOuQ2TcMgZ/4c=}
-    engines: {node: '>= 0.4.0'}
-    dev: true
-
   /cosmiconfig-typescript-loader/2.0.0_3smuweqyuzdazdnyhhezld6mfa:
     resolution: {integrity: sha512-2NlGul/E3vTQEANqPziqkA01vfiuUU8vT0jZAuUIjEW8u3eCcnCQWLggapCjhbF76s7KQF0fM0kXSKmzaDaG1g==}
     engines: {node: '>=12', npm: '>=6'}
@@ -1789,17 +1758,6 @@ packages:
       ms: 2.0.0
     dev: true
 
-  /debug/3.2.7:
-    resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
-    peerDependencies:
-      supports-color: '*'
-    peerDependenciesMeta:
-      supports-color:
-        optional: true
-    dependencies:
-      ms: 2.1.3
-    dev: true
-
   /debug/4.3.4:
     resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
     engines: {node: '>=6.0'}
@@ -2399,10 +2357,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /eventemitter3/4.0.7:
-    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
-    dev: true
-
   /events/3.3.0:
     resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
     engines: {node: '>=0.8.x'}
@@ -2673,16 +2627,6 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
-  /follow-redirects/1.15.0:
-    resolution: {integrity: sha512-aExlJShTV4qOUOL7yF1U5tvLCB0xQuudbf6toyYA0E/acBNw71mvjFTnLaRp50aQaYocMR0a/RMMBIHeZnGyjQ==}
-    engines: {node: '>=4.0'}
-    peerDependencies:
-      debug: '*'
-    peerDependenciesMeta:
-      debug:
-        optional: true
-    dev: true
-
   /for-in/1.0.2:
     resolution: {integrity: sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=}
     engines: {node: '>=0.10.0'}
@@ -2759,6 +2703,7 @@ packages:
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
     dev: true
+    optional: true
 
   /function-bind/1.1.1:
     resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==}
@@ -2777,14 +2722,6 @@ packages:
     resolution: {integrity: sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=}
     dev: true
 
-  /get-intrinsic/1.1.1:
-    resolution: {integrity: sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==}
-    dependencies:
-      function-bind: 1.1.1
-      has: 1.0.3
-      has-symbols: 1.0.3
-    dev: true
-
   /get-pkg-repo/4.2.1:
     resolution: {integrity: sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==}
     engines: {node: '>=6.9.0'}
@@ -2969,11 +2906,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /has-symbols/1.0.3:
-    resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
-    engines: {node: '>= 0.4'}
-    dev: true
-
   /has-value/0.3.1:
     resolution: {integrity: sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=}
     engines: {node: '>=0.10.0'}
@@ -3081,40 +3013,6 @@ packages:
       - supports-color
     dev: true
 
-  /http-proxy/1.18.1:
-    resolution: {integrity: sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==}
-    engines: {node: '>=8.0.0'}
-    dependencies:
-      eventemitter3: 4.0.7
-      follow-redirects: 1.15.0
-      requires-port: 1.0.0
-    transitivePeerDependencies:
-      - debug
-    dev: true
-
-  /http-server/14.1.0:
-    resolution: {integrity: sha512-5lYsIcZtf6pdR8tCtzAHTWrAveo4liUlJdWc7YafwK/maPgYHs+VNP6KpCClmUnSorJrARVMXqtT055zBv11Yg==}
-    engines: {node: '>=12'}
-    hasBin: true
-    dependencies:
-      basic-auth: 2.0.1
-      chalk: 4.1.2
-      corser: 2.0.1
-      he: 1.2.0
-      html-encoding-sniffer: 3.0.0
-      http-proxy: 1.18.1
-      mime: 1.6.0
-      minimist: 1.2.6
-      opener: 1.5.2
-      portfinder: 1.0.28
-      secure-compare: 3.0.1
-      union: 0.5.0
-      url-join: 4.0.1
-    transitivePeerDependencies:
-      - debug
-      - supports-color
-    dev: true
-
   /https-browserify/1.0.0:
     resolution: {integrity: sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=}
     dev: true
@@ -3946,12 +3844,6 @@ packages:
       mime-db: 1.52.0
     dev: true
 
-  /mime/1.6.0:
-    resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
-    engines: {node: '>=4'}
-    hasBin: true
-    dev: true
-
   /mimic-fn/1.2.0:
     resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
     engines: {node: '>=4'}
@@ -4053,10 +3945,6 @@ packages:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
     dev: true
 
-  /ms/2.1.3:
-    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
-    dev: true
-
   /mute-stream/0.0.7:
     resolution: {integrity: sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=}
     dev: true
@@ -4234,11 +4122,6 @@ packages:
       mimic-fn: 2.1.0
     dev: true
 
-  /opener/1.5.2:
-    resolution: {integrity: sha512-ur5UIdyw5Y7yEj9wLzhqXiy6GZ3Mwx0yGI+5sMn2r0N0v3cKJvUmFH5yPP+WXh9e0xfyzyJX95D8l088DNFj7A==}
-    hasBin: true
-    dev: true
-
   /optionator/0.8.3:
     resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==}
     engines: {node: '>= 0.8.0'}
@@ -4532,17 +4415,6 @@ packages:
       find-up: 5.0.0
     dev: true
 
-  /portfinder/1.0.28:
-    resolution: {integrity: sha512-Se+2isanIcEqf2XMHjyUKskczxbPH7dQnlMjXX6+dybayyHvAf/TCgyMRlzf/B6QDhAEFOGes0pzRo3by4AbMA==}
-    engines: {node: '>= 0.12.0'}
-    dependencies:
-      async: 2.6.4
-      debug: 3.2.7
-      mkdirp: 0.5.6
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /posix-character-classes/0.1.1:
     resolution: {integrity: sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=}
     engines: {node: '>=0.10.0'}
@@ -4650,13 +4522,6 @@ packages:
     engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
     dev: true
 
-  /qs/6.10.3:
-    resolution: {integrity: sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==}
-    engines: {node: '>=0.6'}
-    dependencies:
-      side-channel: 1.0.4
-    dev: true
-
   /querystring-es3/0.2.1:
     resolution: {integrity: sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=}
     engines: {node: '>=0.4.x'}
@@ -4815,10 +4680,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /requires-port/1.0.0:
-    resolution: {integrity: sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=}
-    dev: true
-
   /resolve-dir/1.0.1:
     resolution: {integrity: sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=}
     engines: {node: '>=0.10.0'}
@@ -4999,10 +4860,6 @@ packages:
       ajv-keywords: 3.5.2_ajv@6.12.6
     dev: true
 
-  /secure-compare/3.0.1:
-    resolution: {integrity: sha1-8aAymzCLIh+uN7mXTz1XjQypmeM=}
-    dev: true
-
   /semver/5.7.1:
     resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==}
     hasBin: true
@@ -5089,14 +4946,6 @@ packages:
       rechoir: 0.6.2
     dev: true
 
-  /side-channel/1.0.4:
-    resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
-    dependencies:
-      call-bind: 1.0.2
-      get-intrinsic: 1.1.1
-      object-inspect: 1.12.0
-    dev: true
-
   /signal-exit/3.0.7:
     resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
     dev: true
@@ -5279,13 +5128,6 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
-  /stream-browserify/3.0.0:
-    resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==}
-    dependencies:
-      inherits: 2.0.4
-      readable-stream: 3.6.0
-    dev: true
-
   /stream-each/1.2.3:
     resolution: {integrity: sha512-vlMC2f8I2u/bZGqkdfLQW/13Zihpej/7PmSiMQsbYddxuTsJp8vRe2x2FvVExZg7FaOds43ROAuFJwPR4MTZLw==}
     dependencies:
@@ -5731,13 +5573,6 @@ packages:
       set-value: 2.0.1
     dev: true
 
-  /union/0.5.0:
-    resolution: {integrity: sha512-N6uOhuW6zO95P3Mel2I2zMsbsanvvtgn6jVqJv4vbVcz/JN0OkL9suomjQGmWtxJQXOCqUJvquc1sMeNz/IwlA==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      qs: 6.10.3
-    dev: true
-
   /unique-filename/1.1.1:
     resolution: {integrity: sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==}
     dependencies:
@@ -5794,10 +5629,6 @@ packages:
     deprecated: Please see https://github.com/lydell/urix#deprecated
     dev: true
 
-  /url-join/4.0.1:
-    resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
-    dev: true
-
   /url/0.11.0:
     resolution: {integrity: sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=}
     dependencies:

From ab110cf8a952a27c8d96de87ed285e8094251b6d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 18:21:53 +0800
Subject: [PATCH 061/317] test: e2e tests

---
 .github/workflows/ci.yml                      |  30 +--
 examples/.eslintrc.json                       |   6 +
 examples/classic/commits/app.js               |  46 +++++
 examples/{ => classic}/commits/index.html     |   3 +-
 .../{ => classic}/elastic-header/index.html   |   2 +-
 .../{ => classic}/elastic-header/style.css    |   0
 examples/{ => classic}/firebase/app.js        |   0
 examples/{ => classic}/firebase/index.html    |   2 +-
 examples/{ => classic}/firebase/style.css     |   0
 examples/{ => classic}/grid/grid.js           |   0
 examples/{ => classic}/grid/index.html        |   2 +-
 examples/{ => classic}/grid/style.css         |   0
 examples/{ => classic}/markdown/index.html    |   6 +-
 examples/{ => classic}/markdown/style.css     |   0
 examples/{ => classic}/modal/index.html       |   2 +-
 examples/{ => classic}/modal/style.css        |   0
 .../{ => classic}/move-animations/index.html  |  29 +--
 examples/{ => classic}/select2/index.html     |   0
 examples/{ => classic}/svg/index.html         |   3 +-
 examples/{ => classic}/svg/style.css          |   0
 examples/{ => classic}/svg/svg.js             |   0
 examples/{ => classic}/todomvc/app.js         |   0
 examples/{ => classic}/todomvc/index.html     |   8 +-
 examples/{ => classic}/todomvc/readme.md      |   0
 examples/{ => classic}/tree/index.html        |   2 +-
 examples/{ => classic}/tree/tree.js           |   0
 examples/commits/app.js                       |  56 ------
 package.json                                  |   5 +-
 pnpm-lock.yaml                                | 188 ++++++++++++++++++
 test/e2e/{specs => }/async-edge-cases.html    |   2 +-
 test/e2e/async-edge-cases.spec.ts             |  44 ++++
 test/e2e/{specs => }/basic-ssr.html           |   4 +-
 test/e2e/basic-ssr.spec.ts                    |  18 ++
 .../mock.js => test/e2e/commits.mock.ts       |   4 +-
 test/e2e/commits.spec.ts                      |  62 ++++++
 test/e2e/e2eUtils.ts                          | 186 +++++++++++++++++
 test/e2e/grid.spec.ts                         | 115 +++++++++++
 test/e2e/markdown.spec.ts                     |  46 +++++
 test/e2e/{specs => }/modal.ts                 |   0
 test/e2e/{specs => }/select2.ts               |   0
 test/e2e/specs/async-edge-cases.ts            |  34 ----
 test/e2e/specs/basic-ssr.ts                   |   8 -
 test/e2e/specs/commits.ts                     |  23 ---
 test/e2e/specs/grid.ts                        | 105 ----------
 test/e2e/specs/markdown.ts                    |  19 --
 test/e2e/specs/svg.ts                         |  50 -----
 test/e2e/specs/todomvc.ts                     | 166 ----------------
 test/e2e/specs/tree.ts                        |  72 -------
 test/e2e/svg.spec.ts                          | 151 ++++++++++++++
 test/e2e/todomvc.spec.ts                      | 182 +++++++++++++++++
 test/e2e/tree.spec.ts                         | 108 ++++++++++
 51 files changed, 1207 insertions(+), 582 deletions(-)
 create mode 100644 examples/.eslintrc.json
 create mode 100644 examples/classic/commits/app.js
 rename examples/{ => classic}/commits/index.html (94%)
 rename examples/{ => classic}/elastic-header/index.html (98%)
 rename examples/{ => classic}/elastic-header/style.css (100%)
 rename examples/{ => classic}/firebase/app.js (100%)
 rename examples/{ => classic}/firebase/index.html (95%)
 rename examples/{ => classic}/firebase/style.css (100%)
 rename examples/{ => classic}/grid/grid.js (100%)
 rename examples/{ => classic}/grid/index.html (96%)
 rename examples/{ => classic}/grid/style.css (100%)
 rename examples/{ => classic}/markdown/index.html (80%)
 rename examples/{ => classic}/markdown/style.css (100%)
 rename examples/{ => classic}/modal/index.html (97%)
 rename examples/{ => classic}/modal/style.css (100%)
 rename examples/{ => classic}/move-animations/index.html (79%)
 rename examples/{ => classic}/select2/index.html (100%)
 rename examples/{ => classic}/svg/index.html (93%)
 rename examples/{ => classic}/svg/style.css (100%)
 rename examples/{ => classic}/svg/svg.js (100%)
 rename examples/{ => classic}/todomvc/app.js (100%)
 rename examples/{ => classic}/todomvc/index.html (89%)
 rename examples/{ => classic}/todomvc/readme.md (100%)
 rename examples/{ => classic}/tree/index.html (96%)
 rename examples/{ => classic}/tree/tree.js (100%)
 delete mode 100644 examples/commits/app.js
 rename test/e2e/{specs => }/async-edge-cases.html (95%)
 create mode 100644 test/e2e/async-edge-cases.spec.ts
 rename test/e2e/{specs => }/basic-ssr.html (77%)
 create mode 100644 test/e2e/basic-ssr.spec.ts
 rename examples/commits/mock.js => test/e2e/commits.mock.ts (99%)
 create mode 100644 test/e2e/commits.spec.ts
 create mode 100644 test/e2e/e2eUtils.ts
 create mode 100644 test/e2e/grid.spec.ts
 create mode 100644 test/e2e/markdown.spec.ts
 rename test/e2e/{specs => }/modal.ts (100%)
 rename test/e2e/{specs => }/select2.ts (100%)
 delete mode 100644 test/e2e/specs/async-edge-cases.ts
 delete mode 100644 test/e2e/specs/basic-ssr.ts
 delete mode 100644 test/e2e/specs/commits.ts
 delete mode 100644 test/e2e/specs/grid.ts
 delete mode 100644 test/e2e/specs/markdown.ts
 delete mode 100644 test/e2e/specs/svg.ts
 delete mode 100644 test/e2e/specs/todomvc.ts
 delete mode 100644 test/e2e/specs/tree.ts
 create mode 100644 test/e2e/svg.spec.ts
 create mode 100644 test/e2e/todomvc.spec.ts
 create mode 100644 test/e2e/tree.spec.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 35c20a19080..bbc876baba4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,7 +2,7 @@ name: 'ci'
 on:
   push:
     branches:
-      - '**'
+      - main
   pull_request:
     branches:
       - main
@@ -45,24 +45,24 @@ jobs:
       - name: Run SSR tests
         run: pnpm run test:ssr
 
-  # e2e-test:
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v2
+  e2e-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
 
-  #     - name: Install pnpm
-  #       uses: pnpm/action-setup@v2
+      - name: Install pnpm
+        uses: pnpm/action-setup@v2
 
-  #     - name: Set node version to 16
-  #       uses: actions/setup-node@v2
-  #       with:
-  #         node-version: 16
-  #         cache: 'pnpm'
+      - name: Set node version to 16
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: 'pnpm'
 
-  #     - run: pnpm install
+      - run: pnpm install
 
-  #     - name: Run e2e tests
-  #       run: pnpm run test:e2e
+      - name: Run e2e tests
+        run: pnpm run test:e2e
 
   lint-and-test-dts:
     runs-on: ubuntu-latest
diff --git a/examples/.eslintrc.json b/examples/.eslintrc.json
new file mode 100644
index 00000000000..f7a85281a36
--- /dev/null
+++ b/examples/.eslintrc.json
@@ -0,0 +1,6 @@
+{
+  "globals": {
+    "Vue": true,
+    "firebase": true
+  }
+}
diff --git a/examples/classic/commits/app.js b/examples/classic/commits/app.js
new file mode 100644
index 00000000000..d15ec443cd9
--- /dev/null
+++ b/examples/classic/commits/app.js
@@ -0,0 +1,46 @@
+var apiURL = 'https://api.github.com/repos/vuejs/vue/commits?per_page=3&sha='
+
+/**
+ * Actual demo
+ */
+
+new Vue({
+  el: '#demo',
+
+  data: {
+    branches: ['main', 'dev'],
+    currentBranch: 'main',
+    commits: null
+  },
+
+  created: function () {
+    this.fetchData()
+  },
+
+  watch: {
+    currentBranch: 'fetchData'
+  },
+
+  filters: {
+    truncate: function (v) {
+      var newline = v.indexOf('\n')
+      return newline > 0 ? v.slice(0, newline) : v
+    },
+    formatDate: function (v) {
+      return v.replace(/T|Z/g, ' ')
+    }
+  },
+
+  methods: {
+    fetchData: function () {
+      var self = this
+      var xhr = new XMLHttpRequest()
+      xhr.open('GET', apiURL + self.currentBranch)
+      xhr.onload = function () {
+        self.commits = JSON.parse(xhr.responseText)
+        console.log(self.commits[0].html_url)
+      }
+      xhr.send()
+    }
+  }
+})
diff --git a/examples/commits/index.html b/examples/classic/commits/index.html
similarity index 94%
rename from examples/commits/index.html
rename to examples/classic/commits/index.html
index c1e2e325db6..10bc8d4d40a 100644
--- a/examples/commits/index.html
+++ b/examples/classic/commits/index.html
@@ -19,7 +19,7 @@
       }
     </style>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
   </head>
   <body>
     <div id="demo">
@@ -42,7 +42,6 @@ <h1>Latest Vue.js Commits</h1>
         </li>
       </ul>
     </div>
-    <script src="mock.js"></script>
     <script src="app.js"></script>
   </body>
 </html>
diff --git a/examples/elastic-header/index.html b/examples/classic/elastic-header/index.html
similarity index 98%
rename from examples/elastic-header/index.html
rename to examples/classic/elastic-header/index.html
index de6d6a2bfd1..3ba66367de6 100644
--- a/examples/elastic-header/index.html
+++ b/examples/classic/elastic-header/index.html
@@ -5,7 +5,7 @@
     <meta name="viewport" content="initial-scale=1, maximum-scale=1, user-scalable=no">
     <title>Vue.js elastic header example</title>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
     <script src="http://dynamicsjs.com/lib/dynamics.js"></script>
     <link rel="stylesheet" href="style.css">
     <!-- template for the component -->
diff --git a/examples/elastic-header/style.css b/examples/classic/elastic-header/style.css
similarity index 100%
rename from examples/elastic-header/style.css
rename to examples/classic/elastic-header/style.css
diff --git a/examples/firebase/app.js b/examples/classic/firebase/app.js
similarity index 100%
rename from examples/firebase/app.js
rename to examples/classic/firebase/app.js
diff --git a/examples/firebase/index.html b/examples/classic/firebase/index.html
similarity index 95%
rename from examples/firebase/index.html
rename to examples/classic/firebase/index.html
index 7bab1a70b55..f2d2f805f07 100644
--- a/examples/firebase/index.html
+++ b/examples/classic/firebase/index.html
@@ -6,7 +6,7 @@
     <link rel="stylesheet" type="text/css" href="style.css">
     <!-- Vue -->
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
     <!-- Firebase -->
     <script src="https://www.gstatic.com/firebasejs/3.4.0/firebase.js"></script>
     <!-- VueFire -->
diff --git a/examples/firebase/style.css b/examples/classic/firebase/style.css
similarity index 100%
rename from examples/firebase/style.css
rename to examples/classic/firebase/style.css
diff --git a/examples/grid/grid.js b/examples/classic/grid/grid.js
similarity index 100%
rename from examples/grid/grid.js
rename to examples/classic/grid/grid.js
diff --git a/examples/grid/index.html b/examples/classic/grid/index.html
similarity index 96%
rename from examples/grid/index.html
rename to examples/classic/grid/index.html
index d668cd76cc5..41b07060afe 100644
--- a/examples/grid/index.html
+++ b/examples/classic/grid/index.html
@@ -5,7 +5,7 @@
     <title>Vue.js grid component example</title>
     <link rel="stylesheet" href="style.css">
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
     </head>
   <body>
 
diff --git a/examples/grid/style.css b/examples/classic/grid/style.css
similarity index 100%
rename from examples/grid/style.css
rename to examples/classic/grid/style.css
diff --git a/examples/markdown/index.html b/examples/classic/markdown/index.html
similarity index 80%
rename from examples/markdown/index.html
rename to examples/classic/markdown/index.html
index 9ca987466ba..25ee2602924 100644
--- a/examples/markdown/index.html
+++ b/examples/classic/markdown/index.html
@@ -4,10 +4,10 @@
     <meta charset="utf-8">
     <title>Vue.js markdown editor example</title>
     <link rel="stylesheet" href="style.css">
-    <script src="https://unpkg.com/marked@0.3.6"></script>
-    <script src="https://unpkg.com/lodash@4.16.0"></script>
+    <script src="../../../node_modules/marked/marked.min.js"></script>
+    <script src="../../../node_modules/lodash/lodash.min.js"></script>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
   </head>
   <body>
 
diff --git a/examples/markdown/style.css b/examples/classic/markdown/style.css
similarity index 100%
rename from examples/markdown/style.css
rename to examples/classic/markdown/style.css
diff --git a/examples/modal/index.html b/examples/classic/modal/index.html
similarity index 97%
rename from examples/modal/index.html
rename to examples/classic/modal/index.html
index 34b4ebb1d2b..9acb7a42f69 100644
--- a/examples/modal/index.html
+++ b/examples/classic/modal/index.html
@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <title>Vue.js modal component example</title>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
     <link rel="stylesheet" href="style.css">
   </head>
   <body>
diff --git a/examples/modal/style.css b/examples/classic/modal/style.css
similarity index 100%
rename from examples/modal/style.css
rename to examples/classic/modal/style.css
diff --git a/examples/move-animations/index.html b/examples/classic/move-animations/index.html
similarity index 79%
rename from examples/move-animations/index.html
rename to examples/classic/move-animations/index.html
index 46819adfd5f..e89d137b2b7 100644
--- a/examples/move-animations/index.html
+++ b/examples/classic/move-animations/index.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
   <head>
-    <meta charset="utf-8">
+    <meta charset="utf-8" />
     <title>Move Animations</title>
     <style>
       .container {
@@ -16,11 +16,14 @@
         box-sizing: border-box;
       }
       /* 1. declare transition */
-      .fade-move, .fade-enter-active, .fade-leave-active {
-        transition: all .5s cubic-bezier(.55,0,.1,1);
+      .fade-move,
+      .fade-enter-active,
+      .fade-leave-active {
+        transition: all 0.5s cubic-bezier(0.55, 0, 0.1, 1);
       }
       /* 2. declare enter from and leave to state */
-      .fade-enter, .fade-leave-to {
+      .fade-enter,
+      .fade-leave-to {
         opacity: 0;
         transform: scaleY(0.01) translate(30px, 0);
       }
@@ -30,9 +33,9 @@
         position: absolute;
       }
     </style>
-    <script src="https://cdn.jsdelivr.net/lodash/4.3.0/lodash.min.js"></script>
+    <script src="../../../node_modules/lodash/lodash.min.js"></script>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
   </head>
   <body>
     <div id="el">
@@ -40,11 +43,13 @@
       <button @click="reset">reset</button>
       <button @click="shuffle">shuffle</button>
       <transition-group tag="ul" name="fade" class="container">
-        <item v-for="item in items"
+        <item
+          v-for="item in items"
           class="item"
           :msg="item"
           :key="item"
-          @rm="remove(item)">
+          @rm="remove(item)"
+        >
         </item>
       </transition-group>
     </div>
@@ -65,17 +70,17 @@
           }
         },
         methods: {
-          insert () {
+          insert() {
             var i = Math.round(Math.random() * this.items.length)
             this.items.splice(i, 0, id++)
           },
-          reset () {
+          reset() {
             this.items = [1, 2, 3, 4, 5]
           },
-          shuffle () {
+          shuffle() {
             this.items = _.shuffle(this.items)
           },
-          remove (item) {
+          remove(item) {
             var i = this.items.indexOf(item)
             if (i > -1) {
               this.items.splice(i, 1)
diff --git a/examples/select2/index.html b/examples/classic/select2/index.html
similarity index 100%
rename from examples/select2/index.html
rename to examples/classic/select2/index.html
diff --git a/examples/svg/index.html b/examples/classic/svg/index.html
similarity index 93%
rename from examples/svg/index.html
rename to examples/classic/svg/index.html
index e50fc80084f..75d229638bb 100644
--- a/examples/svg/index.html
+++ b/examples/classic/svg/index.html
@@ -5,8 +5,7 @@
     <title>Vue.js SVG graph example</title>
     <link rel="stylesheet" href="style.css">
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
-    <script src="https://unpkg.com/marky/dist/marky.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
   </head>
   <body>
 
diff --git a/examples/svg/style.css b/examples/classic/svg/style.css
similarity index 100%
rename from examples/svg/style.css
rename to examples/classic/svg/style.css
diff --git a/examples/svg/svg.js b/examples/classic/svg/svg.js
similarity index 100%
rename from examples/svg/svg.js
rename to examples/classic/svg/svg.js
diff --git a/examples/todomvc/app.js b/examples/classic/todomvc/app.js
similarity index 100%
rename from examples/todomvc/app.js
rename to examples/classic/todomvc/app.js
diff --git a/examples/todomvc/index.html b/examples/classic/todomvc/index.html
similarity index 89%
rename from examples/todomvc/index.html
rename to examples/classic/todomvc/index.html
index edf28d84728..504d93597d7 100644
--- a/examples/todomvc/index.html
+++ b/examples/classic/todomvc/index.html
@@ -3,8 +3,7 @@
   <head>
     <meta charset="utf-8">
     <title>Vue.js • TodoMVC</title>
-    <link rel="stylesheet" href="https://unpkg.com/todomvc-app-css@2.0.4/index.css">
-    <script src="https://unpkg.com/director@1.2.8/build/director.js"></script>
+    <link rel="stylesheet" href="../../../node_modules/todomvc-app-css/index.css">
     <style>[v-cloak] { display: none; }</style>
   </head>
   <body>
@@ -18,7 +17,8 @@ <h1>todos</h1>
           @keyup.enter="addTodo">
       </header>
       <section class="main" v-show="todos.length" v-cloak>
-        <input class="toggle-all" type="checkbox" v-model="allDone">
+        <input id="toggle-all" class="toggle-all" type="checkbox" v-model="allDone">
+        <label for="toggle-all">Mark all as complete</label>
         <ul class="todo-list">
           <li v-for="todo in filteredTodos"
             class="todo"
@@ -63,7 +63,7 @@ <h1>todos</h1>
     if (navigator.userAgent.indexOf('PhantomJS') > -1) localStorage.clear()
     </script>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
     <script src="app.js"></script>
   </body>
 </html>
diff --git a/examples/todomvc/readme.md b/examples/classic/todomvc/readme.md
similarity index 100%
rename from examples/todomvc/readme.md
rename to examples/classic/todomvc/readme.md
diff --git a/examples/tree/index.html b/examples/classic/tree/index.html
similarity index 96%
rename from examples/tree/index.html
rename to examples/classic/tree/index.html
index bfb9db4a95e..a32ff272f75 100644
--- a/examples/tree/index.html
+++ b/examples/classic/tree/index.html
@@ -21,7 +21,7 @@
       }
     </style>
     <!-- Delete ".min" for console warnings in development -->
-    <script src="../../dist/vue.min.js"></script>
+    <script src="../../../dist/vue.min.js"></script>
   </head>
   <body>
 
diff --git a/examples/tree/tree.js b/examples/classic/tree/tree.js
similarity index 100%
rename from examples/tree/tree.js
rename to examples/classic/tree/tree.js
diff --git a/examples/commits/app.js b/examples/commits/app.js
deleted file mode 100644
index fbbd0d53034..00000000000
--- a/examples/commits/app.js
+++ /dev/null
@@ -1,56 +0,0 @@
-/* global Vue */
-
-var apiURL = 'https://api.github.com/repos/vuejs/vue/commits?per_page=3&sha='
-
-/**
- * Actual demo
- */
-
-new Vue({
-
-  el: '#demo',
-
-  data: {
-    branches: ['master', 'dev'],
-    currentBranch: 'master',
-    commits: null
-  },
-
-  created: function () {
-    this.fetchData()
-  },
-
-  watch: {
-    currentBranch: 'fetchData'
-  },
-
-  filters: {
-    truncate: function (v) {
-      var newline = v.indexOf('\n')
-      return newline > 0 ? v.slice(0, newline) : v
-    },
-    formatDate: function (v) {
-      return v.replace(/T|Z/g, ' ')
-    }
-  },
-
-  methods: {
-    fetchData: function () {
-      var self = this
-      if (navigator.userAgent.indexOf('PhantomJS') > -1) {
-        // use mocks in e2e to avoid dependency on network / authentication
-        setTimeout(function () {
-          self.commits = window.MOCKS[self.currentBranch]
-        }, 0)
-      } else {
-        var xhr = new XMLHttpRequest()
-        xhr.open('GET', apiURL + self.currentBranch)
-        xhr.onload = function () {
-          self.commits = JSON.parse(xhr.responseText)
-          console.log(self.commits[0].html_url)
-        }
-        xhr.send()
-      }
-    }
-  }
-})
diff --git a/package.json b/package.json
index b24c8326dfa..62262f39cc1 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,7 @@
     "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run test/unit",
     "test:ssr": "npm run build:ssr && vitest run test/ssr",
-    "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && node test/e2e/runner.ts",
+    "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && vitest run test/e2e",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
     "ts-check": "tsc -p tsconfig.json --noEmit",
@@ -85,7 +85,9 @@
     "lodash.template": "^4.4.0",
     "lodash.uniq": "^4.5.0",
     "lru-cache": "^7.8.1",
+    "marked": "^3.0.8",
     "memory-fs": "^0.5.0",
+    "puppeteer": "^14.1.1",
     "resolve": "^1.22.0",
     "rollup": "^2.70.2",
     "rollup-plugin-typescript2": "^0.31.2",
@@ -93,6 +95,7 @@
     "shelljs": "^0.8.5",
     "source-map": "0.5.6",
     "terser": "^5.13.1",
+    "todomvc-app-css": "^2.4.2",
     "ts-node": "^10.7.0",
     "tslib": "^2.4.0",
     "typescript": "^4.6.4",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c757942464f..77a55742c73 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -28,7 +28,9 @@ specifiers:
   lodash.template: ^4.4.0
   lodash.uniq: ^4.5.0
   lru-cache: ^7.8.1
+  marked: ^3.0.8
   memory-fs: ^0.5.0
+  puppeteer: ^14.1.1
   resolve: ^1.22.0
   rollup: ^2.70.2
   rollup-plugin-typescript2: ^0.31.2
@@ -36,6 +38,7 @@ specifiers:
   shelljs: ^0.8.5
   source-map: 0.5.6
   terser: ^5.13.1
+  todomvc-app-css: ^2.4.2
   ts-node: ^10.7.0
   tslib: ^2.4.0
   typescript: ^4.6.4
@@ -71,7 +74,9 @@ devDependencies:
   lodash.template: 4.5.0
   lodash.uniq: 4.5.0
   lru-cache: 7.10.1
+  marked: 3.0.8
   memory-fs: 0.5.0
+  puppeteer: 14.1.1
   resolve: 1.22.0
   rollup: 2.74.0
   rollup-plugin-typescript2: 0.31.2_dyu3set7imqii5ytavmnwecwpy
@@ -79,6 +84,7 @@ devDependencies:
   shelljs: 0.8.5
   source-map: 0.5.6
   terser: 5.13.1
+  todomvc-app-css: 2.4.2
   ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
   tslib: 2.4.0
   typescript: 4.6.4
@@ -378,6 +384,14 @@ packages:
       '@types/node': 17.0.34
     dev: true
 
+  /@types/yauzl/2.10.0:
+    resolution: {integrity: sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==}
+    requiresBuild: true
+    dependencies:
+      '@types/node': 17.0.34
+    dev: true
+    optional: true
+
   /@typescript-eslint/eslint-plugin/5.25.0_qo2hgs5jt7x2a3p77h2rutcdae:
     resolution: {integrity: sha512-icYrFnUzvm+LhW0QeJNKkezBu6tJs9p/53dpPLFH8zoM9w1tfaKzVurkPotEpAqQ8Vf8uaFyL5jHd0Vs6Z0ZQg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
@@ -953,6 +967,14 @@ packages:
     dev: true
     optional: true
 
+  /bl/4.1.0:
+    resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
+    dependencies:
+      buffer: 5.7.1
+      inherits: 2.0.4
+      readable-stream: 3.6.0
+    dev: true
+
   /bluebird/3.7.2:
     resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==}
     dev: true
@@ -1060,6 +1082,10 @@ packages:
       pako: 1.0.11
     dev: true
 
+  /buffer-crc32/0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+    dev: true
+
   /buffer-from/1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
     dev: true
@@ -1076,6 +1102,13 @@ packages:
       isarray: 1.0.0
     dev: true
 
+  /buffer/5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+    dev: true
+
   /builtin-modules/3.3.0:
     resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==}
     engines: {node: '>=6'}
@@ -1639,6 +1672,14 @@ packages:
     resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
     dev: true
 
+  /cross-fetch/3.1.5:
+    resolution: {integrity: sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw==}
+    dependencies:
+      node-fetch: 2.6.7
+    transitivePeerDependencies:
+      - encoding
+    dev: true
+
   /cross-spawn/5.1.0:
     resolution: {integrity: sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=}
     dependencies:
@@ -1869,6 +1910,10 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /devtools-protocol/0.0.982423:
+    resolution: {integrity: sha512-FnVW2nDbjGNw1uD/JRC+9U5768W7e1TfUwqbDTcSsAu1jXFjITSX8w3rkW5FEpHRMPPGpvNSmO1pOpqByiWscA==}
+    dev: true
+
   /diff/4.0.2:
     resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
     engines: {node: '>=0.3.1'}
@@ -2459,6 +2504,20 @@ packages:
       - supports-color
     dev: true
 
+  /extract-zip/2.0.1:
+    resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
+    engines: {node: '>= 10.17.0'}
+    hasBin: true
+    dependencies:
+      debug: 4.3.4
+      get-stream: 5.2.0
+      yauzl: 2.10.0
+    optionalDependencies:
+      '@types/yauzl': 2.10.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /fast-deep-equal/3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
     dev: true
@@ -2488,6 +2547,12 @@ packages:
       reusify: 1.0.4
     dev: true
 
+  /fd-slicer/1.1.0:
+    resolution: {integrity: sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=}
+    dependencies:
+      pend: 1.2.0
+    dev: true
+
   /figgy-pudding/3.5.2:
     resolution: {integrity: sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw==}
     dev: true
@@ -2655,6 +2720,10 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
+  /fs-constants/1.0.0:
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
+    dev: true
+
   /fs-extra/10.1.0:
     resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==}
     engines: {node: '>=12'}
@@ -2738,6 +2807,13 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
+  /get-stream/5.2.0:
+    resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==}
+    engines: {node: '>=8'}
+    dependencies:
+      pump: 3.0.0
+    dev: true
+
   /get-stream/6.0.1:
     resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
     engines: {node: '>=10'}
@@ -3742,6 +3818,12 @@ packages:
       object-visit: 1.0.1
     dev: true
 
+  /marked/3.0.8:
+    resolution: {integrity: sha512-0gVrAjo5m0VZSJb4rpL59K1unJAMb/hm8HRXqasD8VeC8m91ytDPMritgFSlKonfdt+rRYYpP/JfLxgIX8yoSw==}
+    engines: {node: '>= 12'}
+    hasBin: true
+    dev: true
+
   /md5.js/1.3.5:
     resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==}
     dependencies:
@@ -3914,6 +3996,10 @@ packages:
       is-extendable: 1.0.1
     dev: true
 
+  /mkdirp-classic/0.5.3:
+    resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
+    dev: true
+
   /mkdirp/0.5.6:
     resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
     hasBin: true
@@ -3987,6 +4073,18 @@ packages:
     resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
     dev: true
 
+  /node-fetch/2.6.7:
+    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+    dependencies:
+      whatwg-url: 5.0.0
+    dev: true
+
   /node-libs-browser/2.2.1:
     resolution: {integrity: sha512-h/zcD8H9kaDZ9ALUWwlBUDo6TKF8a7qBSCSEGfjTVIYeqsioSKaAX+BN7NgiMGp6iSIXZ3PxgCu8KS3b71YK5Q==}
     dependencies:
@@ -4364,6 +4462,10 @@ packages:
       sha.js: 2.4.11
     dev: true
 
+  /pend/1.2.0:
+    resolution: {integrity: sha1-elfrVQpng/kRUzH89GY9XI4AelA=}
+    dev: true
+
   /picocolors/1.0.0:
     resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}
     dev: true
@@ -4448,6 +4550,11 @@ packages:
     engines: {node: '>= 0.6.0'}
     dev: true
 
+  /progress/2.0.3:
+    resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
+    engines: {node: '>=0.4.0'}
+    dev: true
+
   /promise-inflight/1.0.1_bluebird@3.7.2:
     resolution: {integrity: sha1-mEcocL8igTL8vdhoEputEsPAKeM=}
     peerDependencies:
@@ -4459,6 +4566,10 @@ packages:
       bluebird: 3.7.2
     dev: true
 
+  /proxy-from-env/1.1.0:
+    resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
+    dev: true
+
   /prr/1.0.1:
     resolution: {integrity: sha1-0/wRS6BplaRexok/SEzrHXj19HY=}
     dev: true
@@ -4517,6 +4628,30 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /puppeteer/14.1.1:
+    resolution: {integrity: sha512-4dC6GYR5YlXTmNO3TbYEHTdVSdml1cVD2Ok/h/f/xSTp4ITVdbRWkMjiOaEKRAhtIl6GqaP7B89zx+hfhcNGMQ==}
+    engines: {node: '>=14.1.0'}
+    requiresBuild: true
+    dependencies:
+      cross-fetch: 3.1.5
+      debug: 4.3.4
+      devtools-protocol: 0.0.982423
+      extract-zip: 2.0.1
+      https-proxy-agent: 5.0.1
+      pkg-dir: 4.2.0
+      progress: 2.0.3
+      proxy-from-env: 1.1.0
+      rimraf: 3.0.2
+      tar-fs: 2.1.1
+      unbzip2-stream: 1.4.3
+      ws: 8.6.0
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - utf-8-validate
+    dev: true
+
   /q/1.5.1:
     resolution: {integrity: sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=}
     engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
@@ -5295,6 +5430,26 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /tar-fs/2.1.1:
+    resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==}
+    dependencies:
+      chownr: 1.1.4
+      mkdirp-classic: 0.5.3
+      pump: 3.0.0
+      tar-stream: 2.2.0
+    dev: true
+
+  /tar-stream/2.2.0:
+    resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      bl: 4.1.0
+      end-of-stream: 1.4.4
+      fs-constants: 1.0.0
+      inherits: 2.0.4
+      readable-stream: 3.6.0
+    dev: true
+
   /terser-webpack-plugin/1.4.5_webpack@4.46.0:
     resolution: {integrity: sha512-04Rfe496lN8EYruwi6oPQkG0vo8C+HT49X687FZnpPF0qMAIHONI6HEXYPKDOE8e5HjXTyKfqRd/agHtH0kOtw==}
     engines: {node: '>= 6.9.0'}
@@ -5421,6 +5576,10 @@ packages:
       safe-regex: 1.1.0
     dev: true
 
+  /todomvc-app-css/2.4.2:
+    resolution: {integrity: sha512-ViAkQ7ed89rmhFIGRsT36njN+97z8+s3XsJnB8E2IKOq+/SLD/6PtSvmTtiwUcVk39qPcjAc/OyeDys4LoJUVg==}
+    dev: true
+
   /tough-cookie/4.0.0:
     resolution: {integrity: sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==}
     engines: {node: '>=6'}
@@ -5430,6 +5589,10 @@ packages:
       universalify: 0.1.2
     dev: true
 
+  /tr46/0.0.3:
+    resolution: {integrity: sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=}
+    dev: true
+
   /tr46/1.0.1:
     resolution: {integrity: sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=}
     dependencies:
@@ -5563,6 +5726,13 @@ packages:
     dev: true
     optional: true
 
+  /unbzip2-stream/1.4.3:
+    resolution: {integrity: sha512-mlExGW4w71ebDJviH16lQLtZS32VKqsSfk80GCfUlwT/4/hNRFsoscrF/c++9xinkMzECL1uL9DDwXqFWkruPg==}
+    dependencies:
+      buffer: 5.7.1
+      through: 2.3.8
+    dev: true
+
   /union-value/1.0.1:
     resolution: {integrity: sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==}
     engines: {node: '>=0.10.0'}
@@ -5768,6 +5938,10 @@ packages:
       - supports-color
     dev: true
 
+  /webidl-conversions/3.0.1:
+    resolution: {integrity: sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=}
+    dev: true
+
   /webidl-conversions/4.0.2:
     resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
     dev: true
@@ -5852,6 +6026,13 @@ packages:
       webidl-conversions: 7.0.0
     dev: true
 
+  /whatwg-url/5.0.0:
+    resolution: {integrity: sha1-lmRU6HZUYuN2RNNib2dCzotwll0=}
+    dependencies:
+      tr46: 0.0.3
+      webidl-conversions: 3.0.1
+    dev: true
+
   /whatwg-url/7.1.0:
     resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==}
     dependencies:
@@ -5983,6 +6164,13 @@ packages:
       yargs-parser: 20.2.9
     dev: true
 
+  /yauzl/2.10.0:
+    resolution: {integrity: sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=}
+    dependencies:
+      buffer-crc32: 0.2.13
+      fd-slicer: 1.1.0
+    dev: true
+
   /yn/3.1.1:
     resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==}
     engines: {node: '>=6'}
diff --git a/test/e2e/specs/async-edge-cases.html b/test/e2e/async-edge-cases.html
similarity index 95%
rename from test/e2e/specs/async-edge-cases.html
rename to test/e2e/async-edge-cases.html
index 7bca8f8cb9c..0fc9848efdb 100644
--- a/test/e2e/specs/async-edge-cases.html
+++ b/test/e2e/async-edge-cases.html
@@ -3,7 +3,7 @@
   <head>
     <meta charset="utf-8">
     <title></title>
-    <script src="../../../dist/vue.min.js"></script>
+    <script src="../../dist/vue.min.js"></script>
   </head>
   <body>
     <!-- #4510 click and change event on checkbox -->
diff --git a/test/e2e/async-edge-cases.spec.ts b/test/e2e/async-edge-cases.spec.ts
new file mode 100644
index 00000000000..08b1a751f35
--- /dev/null
+++ b/test/e2e/async-edge-cases.spec.ts
@@ -0,0 +1,44 @@
+// @vitest-environment node
+import path from 'path'
+import { E2E_TIMEOUT, setupPuppeteer } from './e2eUtils'
+
+describe('basic-ssr', () => {
+  const { page, text, click, isChecked } = setupPuppeteer()
+
+  test(
+    'should work',
+    async () => {
+      await page().goto(
+        `file://${path.resolve(__dirname, `async-edge-cases.html`)}`
+      )
+
+      // #4510
+      expect(await text('#case-1')).toContain('1')
+      expect(await isChecked('#case-1 input')).toBe(false)
+
+      await click('#case-1 input')
+      expect(await text('#case-1')).toContain('2')
+      expect(await isChecked('#case-1 input')).toBe(true)
+
+      await click('#case-1 input')
+      expect(await text('#case-1')).toContain('3')
+      expect(await isChecked('#case-1 input')).toBe(false)
+
+      // #6566
+      expect(await text('#case-2 button')).toContain('Expand is True')
+      expect(await text('.count-a')).toContain('countA: 0')
+      expect(await text('.count-b')).toContain('countB: 0')
+
+      await click('#case-2 button')
+      expect(await text('#case-2 button')).toContain('Expand is False')
+      expect(await text('.count-a')).toContain('countA: 1')
+      expect(await text('.count-b')).toContain('countB: 0')
+
+      await click('#case-2 button')
+      expect(await text('#case-2 button')).toContain('Expand is True')
+      expect(await text('.count-a')).toContain('countA: 1')
+      expect(await text('.count-b')).toContain('countB: 1')
+    },
+    E2E_TIMEOUT
+  )
+})
diff --git a/test/e2e/specs/basic-ssr.html b/test/e2e/basic-ssr.html
similarity index 77%
rename from test/e2e/specs/basic-ssr.html
rename to test/e2e/basic-ssr.html
index 67f0dac6d6a..ff248935941 100644
--- a/test/e2e/specs/basic-ssr.html
+++ b/test/e2e/basic-ssr.html
@@ -5,8 +5,8 @@
     <title></title>
   </head>
   <body>
-    <script src="../../../dist/vue.min.js"></script>
-    <script src="../../../packages/vue-server-renderer/basic.js"></script>
+    <script src="../../dist/vue.min.js"></script>
+    <script src="../../packages/vue-server-renderer/basic.js"></script>
 
     <div id="result">wtf</div>
 
diff --git a/test/e2e/basic-ssr.spec.ts b/test/e2e/basic-ssr.spec.ts
new file mode 100644
index 00000000000..384761644fe
--- /dev/null
+++ b/test/e2e/basic-ssr.spec.ts
@@ -0,0 +1,18 @@
+// @vitest-environment node
+import path from 'path'
+import { E2E_TIMEOUT, setupPuppeteer } from './e2eUtils'
+
+describe('basic-ssr', () => {
+  const { page, text } = setupPuppeteer()
+
+  test(
+    'should work',
+    async () => {
+      await page().goto(`file://${path.resolve(__dirname, `basic-ssr.html`)}`)
+      expect(await text('#result')).toContain(
+        `<div data-server-rendered="true">foo</div>`
+      )
+    },
+    E2E_TIMEOUT
+  )
+})
diff --git a/examples/commits/mock.js b/test/e2e/commits.mock.ts
similarity index 99%
rename from examples/commits/mock.js
rename to test/e2e/commits.mock.ts
index 0e22a088686..9ef89cb3bf9 100644
--- a/examples/commits/mock.js
+++ b/test/e2e/commits.mock.ts
@@ -1,5 +1,5 @@
-window.MOCKS = {
-  master: [
+export default {
+  main: [
     {
       sha: "0948d999f2fddf9f90991956493f976273c5da1f",
       node_id:
diff --git a/test/e2e/commits.spec.ts b/test/e2e/commits.spec.ts
new file mode 100644
index 00000000000..ab299933a07
--- /dev/null
+++ b/test/e2e/commits.spec.ts
@@ -0,0 +1,62 @@
+// @vitest-environment node
+import { setupPuppeteer, getExampleUrl, E2E_TIMEOUT } from './e2eUtils'
+import mocks from './commits.mock'
+
+describe('e2e: commits', () => {
+  const { page, click, count, text, isChecked } = setupPuppeteer()
+
+  async function testCommits(apiType: 'classic' | 'composition') {
+    // intercept and mock the response to avoid hitting the actual API
+    await page().setRequestInterception(true)
+    page().on('request', (req) => {
+      const match = req.url().match(/&sha=(.*)$/)
+      if (!match) {
+        req.continue()
+      } else {
+        const ret = JSON.stringify(mocks[match[1] as 'main' | 'dev'])
+        req.respond({
+          status: 200,
+          contentType: 'application/json',
+          headers: { 'Access-Control-Allow-Origin': '*' },
+          body: ret
+        })
+      }
+    })
+
+    await page().goto(getExampleUrl('commits', apiType))
+    await page().waitForSelector('li')
+
+    expect(await count('input')).toBe(2)
+    expect(await count('label')).toBe(2)
+    expect(await text('label[for="main"]')).toBe('main')
+    expect(await text('label[for="dev"]')).toBe('dev')
+    expect(await isChecked('#main')).toBe(true)
+    expect(await isChecked('#dev')).toBe(false)
+    expect(await text('p')).toBe('vuejs/vue@main')
+    expect(await count('li')).toBe(3)
+    expect(await count('li .commit')).toBe(3)
+    expect(await count('li .message')).toBe(3)
+
+    await click('#dev')
+    expect(await text('p')).toBe('vuejs/vue@dev')
+    expect(await count('li')).toBe(3)
+    expect(await count('li .commit')).toBe(3)
+    expect(await count('li .message')).toBe(3)
+  }
+
+  test(
+    'classic',
+    async () => {
+      await testCommits('classic')
+    },
+    E2E_TIMEOUT
+  )
+
+  // test(
+  //   'composition',
+  //   async () => {
+  //     await testCommits('composition')
+  //   },
+  //   E2E_TIMEOUT
+  // )
+})
diff --git a/test/e2e/e2eUtils.ts b/test/e2e/e2eUtils.ts
new file mode 100644
index 00000000000..58b81a9671e
--- /dev/null
+++ b/test/e2e/e2eUtils.ts
@@ -0,0 +1,186 @@
+import path from 'path'
+import puppeteer from 'puppeteer'
+
+export function getExampleUrl(name: string, apiType: 'classic' | 'composition') {
+  return `file://${path.resolve(
+    __dirname,
+    `../../examples/${apiType}/${name}/index.html`
+  )}`
+}
+
+export const E2E_TIMEOUT = 30 * 1000
+
+const puppeteerOptions = process.env.CI
+  ? { args: ['--no-sandbox', '--disable-setuid-sandbox'] }
+  : { headless: !process.env.DEBUG }
+
+const maxTries = 30
+export const timeout = (n: number) => new Promise((r) => setTimeout(r, n))
+
+export async function expectByPolling(
+  poll: () => Promise<any>,
+  expected: string
+) {
+  for (let tries = 0; tries < maxTries; tries++) {
+    const actual = (await poll()) || ''
+    if (actual.indexOf(expected) > -1 || tries === maxTries - 1) {
+      expect(actual).toMatch(expected)
+      break
+    } else {
+      await timeout(50)
+    }
+  }
+}
+
+export function setupPuppeteer() {
+  let browser: puppeteer.Browser
+  let page: puppeteer.Page
+
+  beforeAll(async () => {
+    browser = await puppeteer.launch(puppeteerOptions)
+  })
+
+  beforeEach(async () => {
+    page = await browser.newPage()
+
+    await page.evaluateOnNewDocument(() => {
+      localStorage.clear()
+    })
+
+    page.on('console', (e) => {
+      if (e.type() === 'error') {
+        const err = e.args()[0]
+        console.error(
+          `Error from Puppeteer-loaded page:\n`,
+          err._remoteObject.description
+        )
+      }
+    })
+  })
+
+  afterEach(async () => {
+    await page.close()
+  })
+
+  afterAll(async () => {
+    await browser.close()
+  })
+
+  async function click(selector: string, options?: puppeteer.ClickOptions) {
+    await page.click(selector, options)
+  }
+
+  async function count(selector: string) {
+    return (await page.$$(selector)).length
+  }
+
+  async function text(selector: string) {
+    return await page.$eval(selector, (node) => node.textContent)
+  }
+
+  async function value(selector: string) {
+    return await page.$eval(
+      selector,
+      (node) => (node as HTMLInputElement).value
+    )
+  }
+
+  async function html(selector: string) {
+    return await page.$eval(selector, (node) => node.innerHTML)
+  }
+
+  async function classList(selector: string) {
+    return await page.$eval(selector, (node: any) => [...node.classList])
+  }
+
+  async function childrenCount(selector: string) {
+    return await page.$eval(selector, (node: any) => node.children.length)
+  }
+
+  async function isVisible(selector: string) {
+    const display = await page.$eval(selector, (node) => {
+      return window.getComputedStyle(node).display
+    })
+    return display !== 'none'
+  }
+
+  async function isChecked(selector: string) {
+    return await page.$eval(
+      selector,
+      (node) => (node as HTMLInputElement).checked
+    )
+  }
+
+  async function isFocused(selector: string) {
+    return await page.$eval(selector, (node) => node === document.activeElement)
+  }
+
+  async function setValue(selector: string, value: string) {
+    await page.$eval(
+      selector,
+      (node, value) => {
+        ;(node as HTMLInputElement).value = value as string
+        node.dispatchEvent(new Event('input'))
+      },
+      value
+    )
+  }
+
+  async function typeValue(selector: string, value: string) {
+    const el = (await page.$(selector))!
+    await el.evaluate((node) => ((node as HTMLInputElement).value = ''))
+    await el.type(value)
+  }
+
+  async function enterValue(selector: string, value: string) {
+    const el = (await page.$(selector))!
+    await el.evaluate((node) => ((node as HTMLInputElement).value = ''))
+    await el.type(value)
+    await el.press('Enter')
+  }
+
+  async function clearValue(selector: string) {
+    return await page.$eval(
+      selector,
+      (node) => ((node as HTMLInputElement).value = '')
+    )
+  }
+
+  function timeout(time: number) {
+    return page.evaluate((time) => {
+      return new Promise((r) => {
+        setTimeout(r, time)
+      })
+    }, time)
+  }
+
+  function nextFrame() {
+    return page.evaluate(() => {
+      return new Promise((resolve) => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(resolve)
+        })
+      })
+    })
+  }
+
+  return {
+    page: () => page,
+    click,
+    count,
+    text,
+    value,
+    html,
+    classList,
+    childrenCount,
+    isVisible,
+    isChecked,
+    isFocused,
+    setValue,
+    typeValue,
+    enterValue,
+    clearValue,
+    timeout,
+    nextFrame
+  }
+}
diff --git a/test/e2e/grid.spec.ts b/test/e2e/grid.spec.ts
new file mode 100644
index 00000000000..9648872dfb5
--- /dev/null
+++ b/test/e2e/grid.spec.ts
@@ -0,0 +1,115 @@
+import { setupPuppeteer, getExampleUrl, E2E_TIMEOUT } from './e2eUtils'
+
+interface TableData {
+  name: string
+  power: number
+}
+
+describe('e2e: grid', () => {
+  const { page, click, text, count, typeValue, clearValue } = setupPuppeteer()
+  const columns = ['name', 'power'] as const
+
+  async function assertTable(data: TableData[]) {
+    expect(await count('td')).toBe(data.length * columns.length)
+    for (let i = 0; i < data.length; i++) {
+      for (let j = 0; j < columns.length; j++) {
+        expect(
+          await text(`tr:nth-child(${i + 1}) td:nth-child(${j + 1})`)
+        ).toContain(`${data[i][columns[j]]}`)
+      }
+    }
+  }
+
+  async function testGrid(apiType: 'classic' | 'composition') {
+    await page().goto(getExampleUrl('grid', apiType))
+    await page().waitForSelector('table')
+    expect(await count('th')).toBe(2)
+    expect(await count('th.active')).toBe(0)
+    expect(await text('th:nth-child(1)')).toContain('Name')
+    expect(await text('th:nth-child(2)')).toContain('Power')
+    await assertTable([
+      { name: 'Chuck Norris', power: Infinity },
+      { name: 'Bruce Lee', power: 9000 },
+      { name: 'Jackie Chan', power: 7000 },
+      { name: 'Jet Li', power: 8000 }
+    ])
+
+    await click('th:nth-child(1)')
+    expect(await count('th.active:nth-child(1)')).toBe(1)
+    expect(await count('th.active:nth-child(2)')).toBe(0)
+    expect(await count('th:nth-child(1) .arrow.dsc')).toBe(1)
+    expect(await count('th:nth-child(2) .arrow.dsc')).toBe(0)
+    await assertTable([
+      { name: 'Jet Li', power: 8000 },
+      { name: 'Jackie Chan', power: 7000 },
+      { name: 'Chuck Norris', power: Infinity },
+      { name: 'Bruce Lee', power: 9000 }
+    ])
+
+    await click('th:nth-child(2)')
+    expect(await count('th.active:nth-child(1)')).toBe(0)
+    expect(await count('th.active:nth-child(2)')).toBe(1)
+    expect(await count('th:nth-child(1) .arrow.dsc')).toBe(1)
+    expect(await count('th:nth-child(2) .arrow.dsc')).toBe(1)
+    await assertTable([
+      { name: 'Chuck Norris', power: Infinity },
+      { name: 'Bruce Lee', power: 9000 },
+      { name: 'Jet Li', power: 8000 },
+      { name: 'Jackie Chan', power: 7000 }
+    ])
+
+    await click('th:nth-child(2)')
+    expect(await count('th.active:nth-child(1)')).toBe(0)
+    expect(await count('th.active:nth-child(2)')).toBe(1)
+    expect(await count('th:nth-child(1) .arrow.dsc')).toBe(1)
+    expect(await count('th:nth-child(2) .arrow.asc')).toBe(1)
+    await assertTable([
+      { name: 'Jackie Chan', power: 7000 },
+      { name: 'Jet Li', power: 8000 },
+      { name: 'Bruce Lee', power: 9000 },
+      { name: 'Chuck Norris', power: Infinity }
+    ])
+
+    await click('th:nth-child(1)')
+    expect(await count('th.active:nth-child(1)')).toBe(1)
+    expect(await count('th.active:nth-child(2)')).toBe(0)
+    expect(await count('th:nth-child(1) .arrow.asc')).toBe(1)
+    expect(await count('th:nth-child(2) .arrow.asc')).toBe(1)
+    await assertTable([
+      { name: 'Bruce Lee', power: 9000 },
+      { name: 'Chuck Norris', power: Infinity },
+      { name: 'Jackie Chan', power: 7000 },
+      { name: 'Jet Li', power: 8000 }
+    ])
+
+    await typeValue('input[name="query"]', 'j')
+    await assertTable([
+      { name: 'Jackie Chan', power: 7000 },
+      { name: 'Jet Li', power: 8000 }
+    ])
+
+    await typeValue('input[name="query"]', 'infinity')
+    await assertTable([{ name: 'Chuck Norris', power: Infinity }])
+
+    await clearValue('input[name="query"]')
+    expect(await count('p')).toBe(0)
+    await typeValue('input[name="query"]', 'stringthatdoesnotexistanywhere')
+    expect(await count('p')).toBe(1)
+  }
+
+  test(
+    'classic',
+    async () => {
+      await testGrid('classic')
+    },
+    E2E_TIMEOUT
+  )
+
+  // test(
+  //   'composition',
+  //   async () => {
+  //     await testGrid('composition')
+  //   },
+  //   E2E_TIMEOUT
+  // )
+})
diff --git a/test/e2e/markdown.spec.ts b/test/e2e/markdown.spec.ts
new file mode 100644
index 00000000000..cd1d64f5dfb
--- /dev/null
+++ b/test/e2e/markdown.spec.ts
@@ -0,0 +1,46 @@
+import {
+  setupPuppeteer,
+  expectByPolling,
+  getExampleUrl,
+  E2E_TIMEOUT
+} from './e2eUtils'
+
+describe('e2e: markdown', () => {
+  const { page, isVisible, value, html } = setupPuppeteer()
+
+  async function testMarkdown(apiType: 'classic' | 'composition') {
+    await page().goto(getExampleUrl('markdown', apiType))
+    expect(await isVisible('#editor')).toBe(true)
+    expect(await value('textarea')).toBe('# hello')
+    expect(await html('#editor div')).toBe('<h1 id="hello">hello</h1>\n')
+
+    await page().type('textarea', '\n## foo\n\n- bar\n- baz')
+
+    // assert the output is not updated yet because of debounce
+    // debounce has become unstable on CI so this assertion is disabled
+    // expect(await html('#editor div')).toBe('<h1 id="hello">hello</h1>\n')
+
+    await expectByPolling(
+      () => html('#editor div'),
+      '<h1 id="hello">hello</h1>\n' +
+        '<h2 id="foo">foo</h2>\n' +
+        '<ul>\n<li>bar</li>\n<li>baz</li>\n</ul>\n'
+    )
+  }
+
+  test(
+    'classic',
+    async () => {
+      await testMarkdown('classic')
+    },
+    E2E_TIMEOUT
+  )
+
+  // test(
+  //   'composition',
+  //   async () => {
+  //     await testMarkdown('composition')
+  //   },
+  //   E2E_TIMEOUT
+  // )
+})
diff --git a/test/e2e/specs/modal.ts b/test/e2e/modal.ts
similarity index 100%
rename from test/e2e/specs/modal.ts
rename to test/e2e/modal.ts
diff --git a/test/e2e/specs/select2.ts b/test/e2e/select2.ts
similarity index 100%
rename from test/e2e/specs/select2.ts
rename to test/e2e/select2.ts
diff --git a/test/e2e/specs/async-edge-cases.ts b/test/e2e/specs/async-edge-cases.ts
deleted file mode 100644
index 27212b76d65..00000000000
--- a/test/e2e/specs/async-edge-cases.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-module.exports = {
-  'async edge cases': function (browser) {
-    browser
-    .url('http://localhost:8080/test/e2e/specs/async-edge-cases.html')
-      // #4510
-      .assert.containsText('#case-1', '1')
-      .assert.checked('#case-1 input', false)
-
-      .click('#case-1 input')
-      .assert.containsText('#case-1', '2')
-      .assert.checked('#case-1 input', true)
-
-      .click('#case-1 input')
-      .assert.containsText('#case-1', '3')
-      .assert.checked('#case-1 input', false)
-
-      // // #6566
-      .assert.containsText('#case-2 button', 'Expand is True')
-      .assert.containsText('.count-a', 'countA: 0')
-      .assert.containsText('.count-b', 'countB: 0')
-
-      .click('#case-2 button')
-      .assert.containsText('#case-2 button', 'Expand is False')
-      .assert.containsText('.count-a', 'countA: 1')
-      .assert.containsText('.count-b', 'countB: 0')
-
-      .click('#case-2 button')
-      .assert.containsText('#case-2 button', 'Expand is True')
-      .assert.containsText('.count-a', 'countA: 1')
-      .assert.containsText('.count-b', 'countB: 1')
-
-      .end()
-  }
-}
diff --git a/test/e2e/specs/basic-ssr.ts b/test/e2e/specs/basic-ssr.ts
deleted file mode 100644
index b1ea2402d2e..00000000000
--- a/test/e2e/specs/basic-ssr.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-module.exports = {
-  'basic SSR': function (browser) {
-    browser
-    .url('http://localhost:8080/test/e2e/specs/basic-ssr.html')
-      .assert.containsText('#result', '<div data-server-rendered="true">foo</div>')
-      .end()
-  }
-}
diff --git a/test/e2e/specs/commits.ts b/test/e2e/specs/commits.ts
deleted file mode 100644
index cf8152724e2..00000000000
--- a/test/e2e/specs/commits.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-module.exports = {
-  'commits': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/commits/')
-      .waitForElementVisible('li', 5000)
-      .assert.count('input', 2)
-      .assert.count('label', 2)
-      .assert.containsText('label[for="master"]', 'master')
-      .assert.containsText('label[for="dev"]', 'dev')
-      .assert.checked('#master')
-      .assert.checked('#dev', false)
-      .assert.containsText('p', 'vuejs/vue@master')
-      .assert.count('li', 3)
-      .assert.count('li .commit', 3)
-      .assert.count('li .message', 3)
-      .click('#dev')
-      .assert.containsText('p', 'vuejs/vue@dev')
-      .assert.count('li', 3)
-      .assert.count('li .commit', 3)
-      .assert.count('li .message', 3)
-      .end()
-  }
-}
diff --git a/test/e2e/specs/grid.ts b/test/e2e/specs/grid.ts
deleted file mode 100644
index ab635b28f86..00000000000
--- a/test/e2e/specs/grid.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-module.exports = {
-  'grid': function (browser) {
-    const columns = ['name', 'power']
-
-    browser
-    .url('http://localhost:8080/examples/grid/')
-      .waitForElementVisible('table', 1000)
-      .assert.count('th', 2)
-      .assert.count('th.active', 0)
-      .assert.containsText('th:nth-child(1)', 'Name')
-      .assert.containsText('th:nth-child(2)', 'Power')
-      assertTable([
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 }
-      ])
-
-    browser
-      .click('th:nth-child(1)')
-      .assert.count('th.active:nth-child(1)', 1)
-      .assert.count('th.active:nth-child(2)', 0)
-      .assert.count('th:nth-child(1) .arrow.dsc', 1)
-      .assert.count('th:nth-child(2) .arrow.dsc', 0)
-      assertTable([
-        { name: 'Jet Li', power: 8000 },
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Bruce Lee', power: 9000 }
-      ])
-
-    browser
-      .click('th:nth-child(2)')
-      .assert.count('th.active:nth-child(1)', 0)
-      .assert.count('th.active:nth-child(2)', 1)
-      .assert.count('th:nth-child(1) .arrow.dsc', 1)
-      .assert.count('th:nth-child(2) .arrow.dsc', 1)
-      assertTable([
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Jet Li', power: 8000 },
-        { name: 'Jackie Chan', power: 7000 }
-      ])
-
-    browser
-      .click('th:nth-child(2)')
-      .assert.count('th.active:nth-child(1)', 0)
-      .assert.count('th.active:nth-child(2)', 1)
-      .assert.count('th:nth-child(1) .arrow.dsc', 1)
-      .assert.count('th:nth-child(2) .arrow.asc', 1)
-      assertTable([
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 },
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Chuck Norris', power: Infinity }
-      ])
-
-    browser
-      .click('th:nth-child(1)')
-      .assert.count('th.active:nth-child(1)', 1)
-      .assert.count('th.active:nth-child(2)', 0)
-      .assert.count('th:nth-child(1) .arrow.asc', 1)
-      .assert.count('th:nth-child(2) .arrow.asc', 1)
-      assertTable([
-        { name: 'Bruce Lee', power: 9000 },
-        { name: 'Chuck Norris', power: Infinity },
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 }
-      ])
-
-    browser
-      .setValue('input[name="query"]', 'j')
-      assertTable([
-        { name: 'Jackie Chan', power: 7000 },
-        { name: 'Jet Li', power: 8000 }
-      ])
-
-    browser
-      .clearValue('input[name="query"]')
-      .setValue('input[name="query"]', 'infinity')
-      assertTable([
-        { name: 'Chuck Norris', power: Infinity }
-      ])
-
-    browser
-      .clearValue('input[name="query"]')
-      .assert.count('p', 0)
-      .setValue('input[name="query"]', 'stringthatdoesnotexistanywhere')
-      .assert.count('p', 1)
-
-    browser.end()
-
-    function assertTable (data) {
-      browser.assert.count('td', data.length * columns.length)
-      for (let i = 0; i < data.length; i++) {
-        for (let j = 0; j < columns.length; j++) {
-          browser.assert.containsText(
-            'tr:nth-child(' + (i + 1) + ') td:nth-child(' + (j + 1) + ')',
-            data[i][columns[j]]
-          )
-        }
-      }
-    }
-  }
-}
diff --git a/test/e2e/specs/markdown.ts b/test/e2e/specs/markdown.ts
deleted file mode 100644
index 84be2b43b70..00000000000
--- a/test/e2e/specs/markdown.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-module.exports = {
-  'markdown': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/markdown/')
-      .waitForElementVisible('#editor', 1000)
-      .assert.value('textarea', '# hello')
-      .assert.hasHTML('#editor div', '<h1 id="hello">hello</h1>')
-      .setValue('textarea', '\n## foo\n\n- bar\n- baz')
-      // assert the output is not updated yet because of debounce
-      .assert.hasHTML('#editor div', '<h1 id="hello">hello</h1>')
-      .waitFor(500)
-      .assert.hasHTML('#editor div',
-        '<h1 id="hello">hello</h1>\n' +
-        '<h2 id="foo">foo</h2>\n' +
-        '<ul>\n<li>bar</li>\n<li>baz</li>\n</ul>'
-      )
-      .end()
-  }
-}
diff --git a/test/e2e/specs/svg.ts b/test/e2e/specs/svg.ts
deleted file mode 100644
index 38f81b6be91..00000000000
--- a/test/e2e/specs/svg.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-declare const stats: any
-declare const valueToPoint: Function
-
-module.exports = {
-  'svg': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/svg/')
-      .waitForElementVisible('svg', 1000)
-      .assert.count('g', 1)
-      .assert.count('polygon', 1)
-      .assert.count('circle', 1)
-      .assert.count('text', 6)
-      .assert.count('label', 6)
-      .assert.count('button', 7)
-      .assert.count('input[type="range"]', 6)
-      .assert.evaluate(function () {
-        const points = stats.map(function (stat, i) {
-        const point = valueToPoint(stat.value, i, 6)
-          return point.x + ',' + point.y
-        }).join(' ')
-        return document.querySelector('polygon')!.attributes[0].value === points
-      })
-      .click('button.remove')
-      .assert.count('text', 5)
-      .assert.count('label', 5)
-      .assert.count('button', 6)
-      .assert.count('input[type="range"]', 5)
-      .assert.evaluate(function () {
-        const points = stats.map(function (stat, i) {
-        const point = valueToPoint(stat.value, i, 5)
-          return point.x + ',' + point.y
-        }).join(' ')
-        return document.querySelector('polygon')!.attributes[0].value === points
-      })
-      .setValue('input[name="newlabel"]', 'foo')
-      .click('#add > button')
-      .assert.count('text', 6)
-      .assert.count('label', 6)
-      .assert.count('button', 7)
-      .assert.count('input[type="range"]', 6)
-      .assert.evaluate(function () {
-        const points = stats.map(function (stat, i) {
-        const point = valueToPoint(stat.value, i, 6)
-          return point.x + ',' + point.y
-        }).join(' ')
-        return document.querySelector('polygon')!.attributes[0].value === points
-      })
-      .end()
-  }
-}
diff --git a/test/e2e/specs/todomvc.ts b/test/e2e/specs/todomvc.ts
deleted file mode 100644
index 0e459b3253c..00000000000
--- a/test/e2e/specs/todomvc.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-module.exports = {
-  'todomvc': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/todomvc/#test')
-      .waitForElementVisible('.todoapp', 1000)
-      .assert.notVisible('.main')
-      .assert.notVisible('.footer')
-      .assert.count('.filters .selected', 1)
-      .assert.evaluate(function () {
-        return document.querySelector('.filters .selected')!.textContent === 'All'
-      })
-
-    createNewItem('test')
-      .assert.count('.todo', 1)
-      .assert.notVisible('.todo .edit')
-      .assert.containsText('.todo label', 'test')
-      .assert.containsText('.todo-count strong', '1')
-      .assert.checked('.todo .toggle', false)
-      .assert.visible('.main')
-      .assert.visible('.footer')
-      .assert.notVisible('.clear-completed')
-      .assert.value('.new-todo', '')
-
-    createNewItem('test2')
-      .assert.count('.todo', 2)
-      .assert.containsText('.todo:nth-child(2) label', 'test2')
-      .assert.containsText('.todo-count strong', '2')
-
-    // toggle
-    browser
-      .click('.todo .toggle')
-      .assert.count('.todo.completed', 1)
-      .assert.cssClassPresent('.todo:nth-child(1)', 'completed')
-      .assert.containsText('.todo-count strong', '1')
-      .assert.visible('.clear-completed')
-
-    createNewItem('test3')
-      .assert.count('.todo', 3)
-      .assert.containsText('.todo:nth-child(3) label', 'test3')
-      .assert.containsText('.todo-count strong', '2')
-
-    createNewItem('test4')
-    createNewItem('test5')
-      .assert.count('.todo', 5)
-      .assert.containsText('.todo-count strong', '4')
-
-    // toggle more
-    browser
-      .click('.todo:nth-child(4) .toggle')
-      .click('.todo:nth-child(5) .toggle')
-      .assert.count('.todo.completed', 3)
-      .assert.containsText('.todo-count strong', '2')
-
-    // remove
-    removeItemAt(1)
-      .assert.count('.todo', 4)
-      .assert.count('.todo.completed', 2)
-      .assert.containsText('.todo-count strong', '2')
-    removeItemAt(2)
-      .assert.count('.todo', 3)
-      .assert.count('.todo.completed', 2)
-      .assert.containsText('.todo-count strong', '1')
-
-    // remove all
-    browser
-      .click('.clear-completed')
-      .assert.count('.todo', 1)
-      .assert.containsText('.todo label', 'test2')
-      .assert.count('.todo.completed', 0)
-      .assert.containsText('.todo-count strong', '1')
-      .assert.notVisible('.clear-completed')
-
-    // prepare to test filters
-    createNewItem('test')
-    createNewItem('test')
-      .click('.todo:nth-child(2) .toggle')
-      .click('.todo:nth-child(3) .toggle')
-
-    // active filter
-    browser
-      .click('.filters li:nth-child(2) a')
-      .assert.count('.todo', 1)
-      .assert.count('.todo.completed', 0)
-      // add item with filter active
-      createNewItem('test')
-      .assert.count('.todo', 2)
-
-    // completed filter
-    browser.click('.filters li:nth-child(3) a')
-      .assert.count('.todo', 2)
-      .assert.count('.todo.completed', 2)
-
-    // filter on page load
-    browser.url('http://localhost:8080/examples/todomvc/#active')
-      .assert.count('.todo', 2)
-      .assert.count('.todo.completed', 0)
-      .assert.containsText('.todo-count strong', '2')
-
-    // completed on page load
-    browser.url('http://localhost:8080/examples/todomvc/#completed')
-      .assert.count('.todo', 2)
-      .assert.count('.todo.completed', 2)
-      .assert.containsText('.todo-count strong', '2')
-
-    // toggling with filter active
-    browser
-      .click('.todo .toggle')
-      .assert.count('.todo', 1)
-      .click('.filters li:nth-child(2) a')
-      .assert.count('.todo', 3)
-      .click('.todo .toggle')
-      .assert.count('.todo', 2)
-
-    // editing triggered by blur
-    browser
-      .click('.filters li:nth-child(1) a')
-      .dblClick('.todo:nth-child(1) label')
-      .assert.count('.todo.editing', 1)
-      .assert.focused('.todo:nth-child(1) .edit')
-      .clearValue('.todo:nth-child(1) .edit')
-      .setValue('.todo:nth-child(1) .edit', 'edited!')
-      .click('.new-todo') // blur
-      .assert.count('.todo.editing', 0)
-      .assert.containsText('.todo:nth-child(1) label', 'edited!')
-
-    // editing triggered by enter
-    browser
-      .dblClick('.todo label')
-      .enterValue('.todo:nth-child(1) .edit', 'edited again!')
-      .assert.count('.todo.editing', 0)
-      .assert.containsText('.todo:nth-child(1) label', 'edited again!')
-
-    // cancel
-    browser
-      .dblClick('.todo label')
-      .clearValue('.todo:nth-child(1) .edit')
-      .setValue('.todo:nth-child(1) .edit', 'edited!')
-      .trigger('.todo:nth-child(1) .edit', 'keyup', 27)
-      .assert.count('.todo.editing', 0)
-      .assert.containsText('.todo:nth-child(1) label', 'edited again!')
-
-    // empty value should remove
-    browser
-      .dblClick('.todo label')
-      .enterValue('.todo:nth-child(1) .edit', ' ')
-      .assert.count('.todo', 3)
-
-    // toggle all
-    browser
-      .click('.toggle-all')
-      .assert.count('.todo.completed', 3)
-      .click('.toggle-all')
-      .assert.count('.todo:not(.completed)', 3)
-      .end()
-
-    function createNewItem (text) {
-      return browser.enterValue('.new-todo', text)
-    }
-
-    function removeItemAt (n) {
-      return browser
-        .moveToElement('.todo:nth-child(' + n + ')', 10, 10)
-        .click('.todo:nth-child(' + n + ') .destroy')
-    }
-  }
-}
diff --git a/test/e2e/specs/tree.ts b/test/e2e/specs/tree.ts
deleted file mode 100644
index 3329c7c75d1..00000000000
--- a/test/e2e/specs/tree.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-module.exports = {
-  'tree': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/tree/')
-      .waitForElementVisible('li', 1000)
-      .assert.count('.item', 12)
-      .assert.count('.add', 4)
-      .assert.count('.item > ul', 4)
-      .assert.notVisible('#demo li ul')
-      .assert.containsText('#demo li div span', '[+]')
-
-      // expand root
-      .click('.bold')
-      .assert.visible('#demo ul')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo li ul')!.children.length === 4
-      })
-      .assert.containsText('#demo li div span', '[-]')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', 'child folder')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', '[+]')
-
-      // add items to root
-      .click('#demo > .item > ul > .add')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo li ul')!.children.length === 5
-      })
-      .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', 'child folder')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', '[+]')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(4)', 'new stuff')
-
-      // add another item
-      .click('#demo > .item > ul > .add')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo li ul')!.children.length === 6
-      })
-      .assert.containsText('#demo > .item > ul > .item:nth-child(1)', 'hello')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(2)', 'wat')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', 'child folder')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(3)', '[+]')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(4)', 'new stuff')
-      .assert.containsText('#demo > .item > ul > .item:nth-child(5)', 'new stuff')
-
-      .click('#demo ul .bold')
-      .assert.visible('#demo ul ul')
-      .assert.containsText('#demo ul > .item:nth-child(3)', '[-]')
-      .assert.evaluate(function () {
-        return document.querySelector('#demo ul ul')!.children.length === 5
-      })
-
-      .click('.bold')
-      .assert.notVisible('#demo ul')
-      .assert.containsText('#demo li div span', '[+]')
-      .click('.bold')
-      .assert.visible('#demo ul')
-      .assert.containsText('#demo li div span', '[-]')
-
-      .dblClick('#demo ul > .item div')
-      .assert.count('.item', 15)
-      .assert.count('.item > ul', 5)
-      .assert.containsText('#demo ul > .item:nth-child(1)', '[-]')
-      .assert.evaluate(function () {
-        const firstItem = document.querySelector('#demo ul > .item:nth-child(1)')!
-        const ul = firstItem.querySelector('ul')!
-        return ul.children.length === 2
-      })
-      .end()
-  }
-}
diff --git a/test/e2e/svg.spec.ts b/test/e2e/svg.spec.ts
new file mode 100644
index 00000000000..f966407c4e5
--- /dev/null
+++ b/test/e2e/svg.spec.ts
@@ -0,0 +1,151 @@
+import { setupPuppeteer, getExampleUrl, E2E_TIMEOUT } from './e2eUtils'
+
+declare const stats: {
+  label: string
+  value: number
+}[]
+
+declare function valueToPoint(
+  value: number,
+  index: number,
+  total: number
+): {
+  x: number
+  y: number
+}
+
+describe('e2e: svg', () => {
+  const { page, click, count, setValue, typeValue } = setupPuppeteer()
+
+  // assert the shape of the polygon is correct
+  async function assertPolygon(total: number) {
+    expect(
+      await page().evaluate(
+        (total) => {
+          const points = stats
+            .map((stat, i) => {
+              const point = valueToPoint(stat.value, i, total)
+              return point.x + ',' + point.y
+            })
+            .join(' ')
+          return (
+            document.querySelector('polygon')!.attributes[0].value === points
+          )
+        },
+        [total]
+      )
+    ).toBe(true)
+  }
+
+  // assert the position of each label is correct
+  async function assertLabels(total: number) {
+    const positions = await page().evaluate(
+      (total) => {
+        return stats.map((stat, i) => {
+          const point = valueToPoint(+stat.value + 10, i, total)
+          return [point.x, point.y]
+        })
+      },
+      [total]
+    )
+    for (let i = 0; i < total; i++) {
+      const textPosition = await page().$eval(
+        `text:nth-child(${i + 3})`,
+        (node) => [+node.attributes[0].value, +node.attributes[1].value]
+      )
+      expect(textPosition).toEqual(positions[i])
+    }
+  }
+
+  // assert each value of stats is correct
+  async function assertStats(expected: number[]) {
+    const statsValue = await page().evaluate(() => {
+      return stats.map((stat) => +stat.value)
+    })
+    expect(statsValue).toEqual(expected)
+  }
+
+  function nthRange(n: number) {
+    return `#demo div:nth-child(${n + 1}) input[type="range"]`
+  }
+
+  async function testSvg(apiType: 'classic' | 'composition') {
+    await page().goto(getExampleUrl('svg', apiType))
+    await page().waitForSelector('svg')
+    expect(await count('g')).toBe(1)
+    expect(await count('polygon')).toBe(1)
+    expect(await count('circle')).toBe(1)
+    expect(await count('text')).toBe(6)
+    expect(await count('label')).toBe(6)
+    expect(await count('button')).toBe(7)
+    expect(await count('input[type="range"]')).toBe(6)
+    await assertPolygon(6)
+    await assertLabels(6)
+    await assertStats([100, 100, 100, 100, 100, 100])
+
+    await setValue(nthRange(1), '10')
+    await assertPolygon(6)
+    await assertLabels(6)
+    await assertStats([10, 100, 100, 100, 100, 100])
+
+    await click('button.remove')
+    expect(await count('text')).toBe(5)
+    expect(await count('label')).toBe(5)
+    expect(await count('button')).toBe(6)
+    expect(await count('input[type="range"]')).toBe(5)
+    await assertPolygon(5)
+    await assertLabels(5)
+    await assertStats([100, 100, 100, 100, 100])
+
+    await typeValue('input[name="newlabel"]', 'foo')
+    await click('#add > button')
+    expect(await count('text')).toBe(6)
+    expect(await count('label')).toBe(6)
+    expect(await count('button')).toBe(7)
+    expect(await count('input[type="range"]')).toBe(6)
+    await assertPolygon(6)
+    await assertLabels(6)
+    await assertStats([100, 100, 100, 100, 100, 100])
+
+    await setValue(nthRange(1), '10')
+    await assertPolygon(6)
+    await assertLabels(6)
+    await assertStats([10, 100, 100, 100, 100, 100])
+
+    await setValue(nthRange(2), '20')
+    await assertPolygon(6)
+    await assertLabels(6)
+    await assertStats([10, 20, 100, 100, 100, 100])
+
+    await setValue(nthRange(6), '60')
+    await assertPolygon(6)
+    await assertLabels(6)
+    await assertStats([10, 20, 100, 100, 100, 60])
+
+    await click('button.remove')
+    await assertPolygon(5)
+    await assertLabels(5)
+    await assertStats([20, 100, 100, 100, 60])
+
+    await setValue(nthRange(1), '10')
+    await assertPolygon(5)
+    await assertLabels(5)
+    await assertStats([10, 100, 100, 100, 60])
+  }
+
+  test(
+    'classic',
+    async () => {
+      await testSvg('classic')
+    },
+    E2E_TIMEOUT
+  )
+
+  // test(
+  //   'composition',
+  //   async () => {
+  //     await testSvg('composition')
+  //   },
+  //   E2E_TIMEOUT
+  // )
+})
diff --git a/test/e2e/todomvc.spec.ts b/test/e2e/todomvc.spec.ts
new file mode 100644
index 00000000000..b73b3e214b1
--- /dev/null
+++ b/test/e2e/todomvc.spec.ts
@@ -0,0 +1,182 @@
+import { setupPuppeteer, getExampleUrl, E2E_TIMEOUT } from './e2eUtils'
+
+describe('e2e: todomvc', () => {
+  const {
+    page,
+    click,
+    isVisible,
+    count,
+    text,
+    value,
+    isChecked,
+    isFocused,
+    classList,
+    enterValue,
+    clearValue
+  } = setupPuppeteer()
+
+  async function removeItemAt(n: number) {
+    const item = (await page().$('.todo:nth-child(' + n + ')'))!
+    const itemBBox = (await item.boundingBox())!
+    await page().mouse.move(itemBBox.x + 10, itemBBox.y + 10)
+    await click('.todo:nth-child(' + n + ') .destroy')
+  }
+
+  async function testTodomvc(apiType: 'classic' | 'composition') {
+    const baseUrl = getExampleUrl('todomvc', apiType)
+    await page().goto(baseUrl)
+    expect(await isVisible('.main')).toBe(false)
+    expect(await isVisible('.footer')).toBe(false)
+    expect(await count('.filters .selected')).toBe(1)
+    expect(await text('.filters .selected')).toBe('All')
+    expect(await count('.todo')).toBe(0)
+
+    await enterValue('.new-todo', 'test')
+    expect(await count('.todo')).toBe(1)
+    expect(await isVisible('.todo .edit')).toBe(false)
+    expect(await text('.todo label')).toBe('test')
+    expect(await text('.todo-count strong')).toBe('1')
+    expect(await isChecked('.todo .toggle')).toBe(false)
+    expect(await isVisible('.main')).toBe(true)
+    expect(await isVisible('.footer')).toBe(true)
+    expect(await isVisible('.clear-completed')).toBe(false)
+    expect(await value('.new-todo')).toBe('')
+
+    await enterValue('.new-todo', 'test2')
+    expect(await count('.todo')).toBe(2)
+    expect(await text('.todo:nth-child(2) label')).toBe('test2')
+    expect(await text('.todo-count strong')).toBe('2')
+
+    // toggle
+    await click('.todo .toggle')
+    expect(await count('.todo.completed')).toBe(1)
+    expect(await classList('.todo:nth-child(1)')).toContain('completed')
+    expect(await text('.todo-count strong')).toBe('1')
+    expect(await isVisible('.clear-completed')).toBe(true)
+
+    await enterValue('.new-todo', 'test3')
+    expect(await count('.todo')).toBe(3)
+    expect(await text('.todo:nth-child(3) label')).toBe('test3')
+    expect(await text('.todo-count strong')).toBe('2')
+
+    await enterValue('.new-todo', 'test4')
+    await enterValue('.new-todo', 'test5')
+    expect(await count('.todo')).toBe(5)
+    expect(await text('.todo-count strong')).toBe('4')
+
+    // toggle more
+    await click('.todo:nth-child(4) .toggle')
+    await click('.todo:nth-child(5) .toggle')
+    expect(await count('.todo.completed')).toBe(3)
+    expect(await text('.todo-count strong')).toBe('2')
+
+    // remove
+    await removeItemAt(1)
+    expect(await count('.todo')).toBe(4)
+    expect(await count('.todo.completed')).toBe(2)
+    expect(await text('.todo-count strong')).toBe('2')
+    await removeItemAt(2)
+    expect(await count('.todo')).toBe(3)
+    expect(await count('.todo.completed')).toBe(2)
+    expect(await text('.todo-count strong')).toBe('1')
+
+    // remove all
+    await click('.clear-completed')
+    expect(await count('.todo')).toBe(1)
+    expect(await text('.todo label')).toBe('test2')
+    expect(await count('.todo.completed')).toBe(0)
+    expect(await text('.todo-count strong')).toBe('1')
+    expect(await isVisible('.clear-completed')).toBe(false)
+
+    // prepare to test filters
+    await enterValue('.new-todo', 'test')
+    await enterValue('.new-todo', 'test')
+    await click('.todo:nth-child(2) .toggle')
+    await click('.todo:nth-child(3) .toggle')
+
+    // active filter
+    await click('.filters li:nth-child(2) a')
+    expect(await count('.todo')).toBe(1)
+    expect(await count('.todo.completed')).toBe(0)
+    // add item with filter active
+    await enterValue('.new-todo', 'test')
+    expect(await count('.todo')).toBe(2)
+
+    // completed filter
+    await click('.filters li:nth-child(3) a')
+    expect(await count('.todo')).toBe(2)
+    expect(await count('.todo.completed')).toBe(2)
+
+    // filter on page load
+    await page().goto(`${baseUrl}#active`)
+    expect(await count('.todo')).toBe(2)
+    expect(await count('.todo.completed')).toBe(0)
+    expect(await text('.todo-count strong')).toBe('2')
+
+    // completed on page load
+    await page().goto(`${baseUrl}#completed`)
+    expect(await count('.todo')).toBe(2)
+    expect(await count('.todo.completed')).toBe(2)
+    expect(await text('.todo-count strong')).toBe('2')
+
+    // toggling with filter active
+    await click('.todo .toggle')
+    expect(await count('.todo')).toBe(1)
+    await click('.filters li:nth-child(2) a')
+    expect(await count('.todo')).toBe(3)
+    await click('.todo .toggle')
+    expect(await count('.todo')).toBe(2)
+
+    // editing triggered by blur
+    await click('.filters li:nth-child(1) a')
+    await click('.todo:nth-child(1) label', { clickCount: 2 })
+    expect(await count('.todo.editing')).toBe(1)
+    expect(await isFocused('.todo:nth-child(1) .edit')).toBe(true)
+    await clearValue('.todo:nth-child(1) .edit')
+    await page().type('.todo:nth-child(1) .edit', 'edited!')
+    await click('.new-todo') // blur
+    expect(await count('.todo.editing')).toBe(0)
+    expect(await text('.todo:nth-child(1) label')).toBe('edited!')
+
+    // editing triggered by enter
+    await click('.todo label', { clickCount: 2 })
+    await enterValue('.todo:nth-child(1) .edit', 'edited again!')
+    expect(await count('.todo.editing')).toBe(0)
+    expect(await text('.todo:nth-child(1) label')).toBe('edited again!')
+
+    // cancel
+    await click('.todo label', { clickCount: 2 })
+    await clearValue('.todo:nth-child(1) .edit')
+    await page().type('.todo:nth-child(1) .edit', 'edited!')
+    await page().keyboard.press('Escape')
+    expect(await count('.todo.editing')).toBe(0)
+    expect(await text('.todo:nth-child(1) label')).toBe('edited again!')
+
+    // empty value should remove
+    await click('.todo label', { clickCount: 2 })
+    await enterValue('.todo:nth-child(1) .edit', ' ')
+    expect(await count('.todo')).toBe(3)
+
+    // toggle all
+    await click('.toggle-all+label')
+    expect(await count('.todo.completed')).toBe(3)
+    await click('.toggle-all+label')
+    expect(await count('.todo:not(.completed)')).toBe(3)
+  }
+
+  test(
+    'classic',
+    async () => {
+      await testTodomvc('classic')
+    },
+    E2E_TIMEOUT
+  )
+
+  // test(
+  //   'composition',
+  //   async () => {
+  //     await testTodomvc('composition')
+  //   },
+  //   E2E_TIMEOUT
+  // )
+})
diff --git a/test/e2e/tree.spec.ts b/test/e2e/tree.spec.ts
new file mode 100644
index 00000000000..360374100b3
--- /dev/null
+++ b/test/e2e/tree.spec.ts
@@ -0,0 +1,108 @@
+import { setupPuppeteer, getExampleUrl, E2E_TIMEOUT } from './e2eUtils'
+
+describe('e2e: tree', () => {
+  const { page, click, count, text, childrenCount, isVisible } =
+    setupPuppeteer()
+
+  async function testTree(apiType: 'classic' | 'composition') {
+    await page().goto(getExampleUrl('tree', apiType))
+    expect(await count('.item')).toBe(12)
+    expect(await count('.add')).toBe(4)
+    expect(await count('.item > ul')).toBe(4)
+    expect(await isVisible('#demo li ul')).toBe(false)
+    expect(await text('#demo li div span')).toBe('[+]')
+
+    // expand root
+    await click('.bold')
+    expect(await isVisible('#demo ul')).toBe(true)
+    expect(await childrenCount('#demo li ul')).toBe(4)
+    expect(await text('#demo li div span')).toContain('[-]')
+    expect(await text('#demo > .item > ul > .item:nth-child(1)')).toContain(
+      'hello'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(2)')).toContain(
+      'wat'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(3)')).toContain(
+      'child folder'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(3)')).toContain(
+      '[+]'
+    )
+
+    // add items to root
+    await click('#demo > .item > ul > .add')
+    expect(await childrenCount('#demo li ul')).toBe(5)
+    expect(await text('#demo > .item > ul > .item:nth-child(1)')).toContain(
+      'hello'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(2)')).toContain(
+      'wat'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(3)')).toContain(
+      'child folder'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(3)')).toContain(
+      '[+]'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(4)')).toContain(
+      'new stuff'
+    )
+
+    // add another item
+    await click('#demo > .item > ul > .add')
+    expect(await childrenCount('#demo li ul')).toBe(6)
+    expect(await text('#demo > .item > ul > .item:nth-child(1)')).toContain(
+      'hello'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(2)')).toContain(
+      'wat'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(3)')).toContain(
+      'child folder'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(3)')).toContain(
+      '[+]'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(4)')).toContain(
+      'new stuff'
+    )
+    expect(await text('#demo > .item > ul > .item:nth-child(5)')).toContain(
+      'new stuff'
+    )
+
+    await click('#demo ul .bold')
+    expect(await isVisible('#demo ul ul')).toBe(true)
+    expect(await text('#demo ul > .item:nth-child(3)')).toContain('[-]')
+    expect(await childrenCount('#demo ul ul')).toBe(5)
+
+    await click('.bold')
+    expect(await isVisible('#demo ul')).toBe(false)
+    expect(await text('#demo li div span')).toContain('[+]')
+    await click('.bold')
+    expect(await isVisible('#demo ul')).toBe(true)
+    expect(await text('#demo li div span')).toContain('[-]')
+
+    await click('#demo ul > .item div', { clickCount: 2 })
+    expect(await count('.item')).toBe(15)
+    expect(await count('.item > ul')).toBe(5)
+    expect(await text('#demo ul > .item:nth-child(1)')).toContain('[-]')
+    expect(await childrenCount('#demo ul > .item:nth-child(1) > ul')).toBe(2)
+  }
+
+  test(
+    'classic',
+    async () => {
+      await testTree('classic')
+    },
+    E2E_TIMEOUT
+  )
+
+  // test(
+  //   'composition',
+  //   async () => {
+  //     await testTree('composition')
+  //   },
+  //   E2E_TIMEOUT
+  // )
+})

From 76188513233b9640188b3af40a395a49c1ac75be Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 18:22:45 +0800
Subject: [PATCH 062/317] chore: remove stale tests [ci skip]

---
 test/e2e/modal.ts   | 27 --------------------------
 test/e2e/select2.ts | 47 ---------------------------------------------
 2 files changed, 74 deletions(-)
 delete mode 100644 test/e2e/modal.ts
 delete mode 100644 test/e2e/select2.ts

diff --git a/test/e2e/modal.ts b/test/e2e/modal.ts
deleted file mode 100644
index 947bab1768f..00000000000
--- a/test/e2e/modal.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-module.exports = {
-  'modal': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/modal/')
-      .waitForElementVisible('#app', 1000)
-      .assert.elementNotPresent('.modal-mask')
-      .click('#show-modal')
-      .assert.elementPresent('.modal-mask')
-      .assert.elementPresent('.modal-wrapper')
-      .assert.elementPresent('.modal-container')
-      .waitFor(50)
-      .assert.cssClassPresent('.modal-mask', 'modal-enter-active')
-      .waitFor(300)
-      .assert.cssClassNotPresent('.modal-mask', 'modal-enter-active')
-      .assert.containsText('.modal-header h3', 'custom header')
-      .assert.containsText('.modal-body', 'default body')
-      .assert.containsText('.modal-footer', 'default footer')
-      .click('.modal-default-button')
-      // should have transition
-      .assert.elementPresent('.modal-mask')
-      .waitFor(50)
-      .assert.cssClassPresent('.modal-mask', 'modal-leave-active')
-      .waitFor(300)
-      .assert.elementNotPresent('.modal-mask')
-      .end()
-  }
-}
diff --git a/test/e2e/select2.ts b/test/e2e/select2.ts
deleted file mode 100644
index 24a2a87b6d3..00000000000
--- a/test/e2e/select2.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-declare const vm: any 
-
-module.exports = {
-  'select2': function (browser) {
-    browser
-    .url('http://localhost:8080/examples/select2/')
-      .waitForElementVisible('.select2', 1000)
-      .assert.elementPresent('select')
-      .assert.containsText('p', 'Selected: 0')
-      .assert.containsText('span.select2', 'Select one')
-
-      .click('.select2-selection__rendered')
-      .assert.count('.select2-results__option', 3)
-      .assert.containsText('.select2-results__option:nth-child(1)', 'Select one')
-      .assert.containsText('.select2-results__option:nth-child(2)', 'Hello')
-      .assert.containsText('.select2-results__option:nth-child(3)', 'World')
-      .assert.attributePresent('.select2-results__option:nth-child(1)', 'aria-disabled')
-
-      .click('.select2-results__option:nth-child(2)')
-      .assert.count('.select2-results__option', 0)
-      .assert.containsText('p', 'Selected: 1')
-      .assert.containsText('span.select2', 'Hello')
-
-      // test dynamic options
-      .execute(function () {
-        vm.options.push({ id: 3, text: 'Vue' })
-      })
-      .click('.select2-selection__rendered')
-      .assert.count('.select2-results__option', 4)
-      .assert.containsText('.select2-results__option:nth-child(1)', 'Select one')
-      .assert.containsText('.select2-results__option:nth-child(2)', 'Hello')
-      .assert.containsText('.select2-results__option:nth-child(3)', 'World')
-      .assert.containsText('.select2-results__option:nth-child(4)', 'Vue')
-
-      .click('.select2-results__option:nth-child(4)')
-      .assert.count('.select2-results__option', 0)
-      .assert.containsText('p', 'Selected: 3')
-      .assert.containsText('span.select2', 'Vue')
-
-      .execute(function () {
-        vm.selected = 2
-      })
-      .assert.containsText('p', 'Selected: 2')
-      .assert.containsText('span.select2', 'World')
-      .end()
-  }
-}

From cca88b9919cb0773895bbcef649c61a206fd0a32 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 20 May 2022 18:24:45 +0800
Subject: [PATCH 063/317] ci: fix e2e build script

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 62262f39cc1..3bdb751a94d 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,7 @@
     "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run test/unit",
     "test:ssr": "npm run build:ssr && vitest run test/ssr",
-    "test:e2e": "npm run build -- web-full-prod,web-server-basic-renderer && vitest run test/e2e",
+    "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
     "ts-check": "tsc -p tsconfig.json --noEmit",

From 04b584ffc17db74b4b6330feef9847e936fbb325 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 23 May 2022 15:15:29 +0800
Subject: [PATCH 064/317] test: transition tests

---
 .github/workflows/ci.yml                      |   1 +
 package.json                                  |   8 +
 pnpm-lock.yaml                                | 532 +++++++++++++++++-
 test/helpers/trigger-event.ts                 |   2 +-
 test/helpers/vdom.ts                          |   2 +-
 test/helpers/wait-for-update.ts               |   4 +-
 test/test-env.d.ts                            |  10 +
 test/transition/helpers.ts                    | 144 +++++
 test/transition/karma.conf.js                 |  27 +
 test/transition/package.json                  |   1 +
 .../transition/transition-group.spec.ts       |  17 +-
 .../transition/transition-mode.spec.ts        |   7 +-
 .../transition-with-keep-alive.spec.ts        |  39 +-
 .../transition/transition.spec.ts             |  47 +-
 .../unit/features/transition/inject-styles.ts |  64 ---
 test/vitest.setup.ts                          |  11 +-
 16 files changed, 784 insertions(+), 132 deletions(-)
 create mode 100644 test/transition/helpers.ts
 create mode 100644 test/transition/karma.conf.js
 create mode 100644 test/transition/package.json
 rename test/{unit/features => }/transition/transition-group.spec.ts (96%)
 rename test/{unit/features => }/transition/transition-mode.spec.ts (99%)
 rename test/{unit/features => }/transition/transition-with-keep-alive.spec.ts (95%)
 rename test/{unit/features => }/transition/transition.spec.ts (98%)
 delete mode 100644 test/unit/features/transition/inject-styles.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bbc876baba4..fb1374ef9d3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -63,6 +63,7 @@ jobs:
 
       - name: Run e2e tests
         run: pnpm run test:e2e
+        run: pnpm run test:transition
 
   lint-and-test-dts:
     runs-on: ubuntu-latest
diff --git a/package.json b/package.json
index 3bdb751a94d..86aa61a70df 100644
--- a/package.json
+++ b/package.json
@@ -26,6 +26,7 @@
     "test:unit": "vitest run test/unit",
     "test:ssr": "npm run build:ssr && vitest run test/ssr",
     "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",
+    "test:transition": "karma start test/transition/karma.conf.js",
     "test:types": "tsc -p ./types/tsconfig.json",
     "lint": "eslint src scripts test",
     "ts-check": "tsc -p tsconfig.json --noEmit",
@@ -74,12 +75,19 @@
     "cross-spawn": "^7.0.3",
     "cz-conventional-changelog": "^3.3.0",
     "de-indent": "^1.0.2",
+    "esbuild": "^0.14.39",
     "escodegen": "^2.0.0",
     "eslint": "^8.14.0",
     "file-loader": "^3.0.1",
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
+    "jasmine-core": "^4.1.1",
     "jsdom": "^19.0.0",
+    "karma": "^6.3.20",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-cli": "^2.0.0",
+    "karma-esbuild": "^2.2.4",
+    "karma-jasmine": "^5.0.1",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
     "lodash.template": "^4.4.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 77a55742c73..19c27af9e0b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -17,12 +17,19 @@ specifiers:
   cross-spawn: ^7.0.3
   cz-conventional-changelog: ^3.3.0
   de-indent: ^1.0.2
+  esbuild: ^0.14.39
   escodegen: ^2.0.0
   eslint: ^8.14.0
   file-loader: ^3.0.1
   hash-sum: ^2.0.0
   he: ^1.2.0
+  jasmine-core: ^4.1.1
   jsdom: ^19.0.0
+  karma: ^6.3.20
+  karma-chrome-launcher: ^3.1.1
+  karma-cli: ^2.0.0
+  karma-esbuild: ^2.2.4
+  karma-jasmine: ^5.0.1
   lint-staged: ^12.4.1
   lodash: ^4.17.21
   lodash.template: ^4.4.0
@@ -63,12 +70,19 @@ devDependencies:
   cross-spawn: 7.0.3
   cz-conventional-changelog: 3.3.0
   de-indent: 1.0.2
+  esbuild: 0.14.39
   escodegen: 2.0.0
   eslint: 8.15.0
   file-loader: 3.0.1_webpack@4.46.0
   hash-sum: 2.0.0
   he: 1.2.0
+  jasmine-core: 4.1.1
   jsdom: 19.0.0
+  karma: 6.3.20
+  karma-chrome-launcher: 3.1.1
+  karma-cli: 2.0.0
+  karma-esbuild: 2.2.4_esbuild@0.14.39
+  karma-jasmine: 5.0.1_karma@6.3.20
   lint-staged: 12.4.1
   lodash: 4.17.21
   lodash.template: 4.5.0
@@ -115,6 +129,11 @@ packages:
       js-tokens: 4.0.0
     dev: true
 
+  /@colors/colors/1.5.0:
+    resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==}
+    engines: {node: '>=0.1.90'}
+    dev: true
+
   /@commitlint/config-validator/17.0.0:
     resolution: {integrity: sha512-78IQjoZWR4kDHp/U5y17euEWzswJpPkA9TDL5F6oZZZaLIEreWzrDZD5PWtM8MsSRl/K2LDU/UrzYju2bKLMpA==}
     engines: {node: '>=v14'}
@@ -345,6 +364,18 @@ packages:
     resolution: {integrity: sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ==}
     dev: true
 
+  /@types/component-emitter/1.2.11:
+    resolution: {integrity: sha512-SRXjM+tfsSlA9VuG8hGO2nft2p8zjXCK1VcC6N4NXbBbYbSia9kzCChYQajIjzIqOOOuh5Ock6MmV2oux4jDZQ==}
+    dev: true
+
+  /@types/cookie/0.4.1:
+    resolution: {integrity: sha512-XW/Aa8APYr6jSVVA1y/DEIZX0/GMKLEVekNG727R8cs56ahETkRAy/3DR7+fJyh7oUgGwNQaRfXCun0+KbWY7Q==}
+    dev: true
+
+  /@types/cors/2.8.12:
+    resolution: {integrity: sha512-vt+kDhq/M2ayberEtJcIN/hxXy1Pk+59g2FV/ZQceeaTyCtCucjL2Q7FXlFjtWn4n15KCr1NE2lNNFhp0lEThw==}
+    dev: true
+
   /@types/estree/0.0.39:
     resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==}
     dev: true
@@ -673,6 +704,14 @@ packages:
     resolution: {integrity: sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA==}
     dev: true
 
+  /accepts/1.3.8:
+    resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      mime-types: 2.1.35
+      negotiator: 0.6.3
+    dev: true
+
   /acorn-globals/6.0.0:
     resolution: {integrity: sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==}
     dependencies:
@@ -830,7 +869,6 @@ packages:
       normalize-path: 3.0.0
       picomatch: 2.3.1
     dev: true
-    optional: true
 
   /aproba/1.2.0:
     resolution: {integrity: sha512-Y9J6ZjXtoYh8RnXVCMOU/ttDmk1aBjunq9vO0ta5x85WDQiQfUF9sIPBITdbiiIVcBo03Hi3jMxigBtsddlXRw==}
@@ -944,6 +982,11 @@ packages:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
     dev: true
 
+  /base64id/2.0.0:
+    resolution: {integrity: sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==}
+    engines: {node: ^4.5.0 || >= 5.9}
+    dev: true
+
   /big.js/5.2.2:
     resolution: {integrity: sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==}
     dev: true
@@ -958,7 +1001,6 @@ packages:
     resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==}
     engines: {node: '>=8'}
     dev: true
-    optional: true
 
   /bindings/1.5.0:
     resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
@@ -987,6 +1029,26 @@ packages:
     resolution: {integrity: sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==}
     dev: true
 
+  /body-parser/1.20.0:
+    resolution: {integrity: sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg==}
+    engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.4
+      debug: 2.6.9
+      depd: 2.0.0
+      destroy: 1.2.0
+      http-errors: 2.0.0
+      iconv-lite: 0.4.24
+      on-finished: 2.4.1
+      qs: 6.10.3
+      raw-body: 2.5.1
+      type-is: 1.6.18
+      unpipe: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /brace-expansion/1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
     dependencies:
@@ -1118,6 +1180,11 @@ packages:
     resolution: {integrity: sha512-HpGFw18DgFWlncDfjTa2rcQ4W88O1mC8e8yZ2AvQY5KDaktSTwo+KRf6nHK6FRI5FyRyb/5T6+TSxfP7QyGsmQ==}
     dev: true
 
+  /bytes/3.1.2:
+    resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /cacache/12.0.4:
     resolution: {integrity: sha512-a0tMB40oefvuInr4Cwb3GerbL9xTj1D5yg0T5xrjGCGyfvbxseIXX7BAO/u/hIXdafzOI5JC3wDwHyf24buOAQ==}
     dependencies:
@@ -1158,6 +1225,13 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /call-bind/1.0.2:
+    resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
+    dependencies:
+      function-bind: 1.1.1
+      get-intrinsic: 1.1.1
+    dev: true
+
   /callsites/3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
@@ -1252,7 +1326,6 @@ packages:
     optionalDependencies:
       fsevents: 2.3.2
     dev: true
-    optional: true
 
   /chownr/1.1.4:
     resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
@@ -1433,6 +1506,18 @@ packages:
       typedarray: 0.0.6
     dev: true
 
+  /connect/3.7.0:
+    resolution: {integrity: sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==}
+    engines: {node: '>= 0.10.0'}
+    dependencies:
+      debug: 2.6.9
+      finalhandler: 1.1.2
+      parseurl: 1.3.3
+      utils-merge: 1.0.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /console-browserify/1.2.0:
     resolution: {integrity: sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==}
     dev: true
@@ -1441,6 +1526,11 @@ packages:
     resolution: {integrity: sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=}
     dev: true
 
+  /content-type/1.0.4:
+    resolution: {integrity: sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==}
+    engines: {node: '>= 0.6'}
+    dev: true
+
   /conventional-changelog-angular/5.0.13:
     resolution: {integrity: sha512-i/gipMxs7s8L/QeuavPF2hLnJgH6pEZAttySB6aiQLWcX3puWDL3ACVmvBhJGxnAy52Qc15ua26BufY6KpmrVA==}
     engines: {node: '>=10'}
@@ -1591,6 +1681,11 @@ packages:
       through2: 4.0.2
     dev: true
 
+  /cookie/0.4.2:
+    resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==}
+    engines: {node: '>= 0.6'}
+    dev: true
+
   /copy-concurrently/1.0.5:
     resolution: {integrity: sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==}
     dependencies:
@@ -1611,6 +1706,14 @@ packages:
     resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
     dev: true
 
+  /cors/2.8.5:
+    resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}
+    engines: {node: '>= 0.10'}
+    dependencies:
+      object-assign: 4.1.1
+      vary: 1.1.2
+    dev: true
+
   /cosmiconfig-typescript-loader/2.0.0_3smuweqyuzdazdnyhhezld6mfa:
     resolution: {integrity: sha512-2NlGul/E3vTQEANqPziqkA01vfiuUU8vT0jZAuUIjEW8u3eCcnCQWLggapCjhbF76s7KQF0fM0kXSKmzaDaG1g==}
     engines: {node: '>=12', npm: '>=6'}
@@ -1728,6 +1831,10 @@ packages:
       cssom: 0.3.8
     dev: true
 
+  /custom-event/1.0.1:
+    resolution: {integrity: sha1-XQKkaFCt8bSjF5RqOSj8y1v9BCU=}
+    dev: true
+
   /cyclist/1.0.1:
     resolution: {integrity: sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=}
     dev: true
@@ -1780,6 +1887,11 @@ packages:
       whatwg-url: 11.0.0
     dev: true
 
+  /date-format/4.0.10:
+    resolution: {integrity: sha512-RuMIHocrVjF84bUSTcd1uokIsLsOsk1Awb7TexNOI3f48ukCu39mjslWquDTA08VaDMF2umr3MB9ow5EyJTWyA==}
+    engines: {node: '>=4.0'}
+    dev: true
+
   /dateformat/3.0.3:
     resolution: {integrity: sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q==}
     dev: true
@@ -1893,6 +2005,11 @@ packages:
     engines: {node: '>=0.4.0'}
     dev: true
 
+  /depd/2.0.0:
+    resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /des.js/1.0.1:
     resolution: {integrity: sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==}
     dependencies:
@@ -1900,6 +2017,11 @@ packages:
       minimalistic-assert: 1.0.1
     dev: true
 
+  /destroy/1.2.0:
+    resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==}
+    engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
+    dev: true
+
   /detect-file/1.0.0:
     resolution: {integrity: sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=}
     engines: {node: '>=0.10.0'}
@@ -1914,6 +2036,10 @@ packages:
     resolution: {integrity: sha512-FnVW2nDbjGNw1uD/JRC+9U5768W7e1TfUwqbDTcSsAu1jXFjITSX8w3rkW5FEpHRMPPGpvNSmO1pOpqByiWscA==}
     dev: true
 
+  /di/0.0.1:
+    resolution: {integrity: sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=}
+    dev: true
+
   /diff/4.0.2:
     resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
     engines: {node: '>=0.3.1'}
@@ -1941,6 +2067,15 @@ packages:
       esutils: 2.0.3
     dev: true
 
+  /dom-serialize/2.2.1:
+    resolution: {integrity: sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=}
+    dependencies:
+      custom-event: 1.0.1
+      ent: 2.2.0
+      extend: 3.0.2
+      void-elements: 2.0.1
+    dev: true
+
   /domain-browser/1.2.0:
     resolution: {integrity: sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==}
     engines: {node: '>=0.4', npm: '>=1.2'}
@@ -1973,6 +2108,10 @@ packages:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
     dev: true
 
+  /ee-first/1.1.1:
+    resolution: {integrity: sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=}
+    dev: true
+
   /elliptic/6.5.4:
     resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==}
     dependencies:
@@ -1998,12 +2137,42 @@ packages:
     engines: {node: '>= 4'}
     dev: true
 
+  /encodeurl/1.0.2:
+    resolution: {integrity: sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /end-of-stream/1.4.4:
     resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==}
     dependencies:
       once: 1.4.0
     dev: true
 
+  /engine.io-parser/5.0.4:
+    resolution: {integrity: sha512-+nVFp+5z1E3HcToEnO7ZIj3g+3k9389DvWtvJZz0T6/eOCPIyyxehFcedoYrZQrp0LgQbD9pPXhpMBKMd5QURg==}
+    engines: {node: '>=10.0.0'}
+    dev: true
+
+  /engine.io/6.2.0:
+    resolution: {integrity: sha512-4KzwW3F3bk+KlzSOY57fj/Jx6LyRQ1nbcyIadehl+AnXjKT7gDO0ORdRi/84ixvMKTym6ZKuxvbzN62HDDU1Lg==}
+    engines: {node: '>=10.0.0'}
+    dependencies:
+      '@types/cookie': 0.4.1
+      '@types/cors': 2.8.12
+      '@types/node': 17.0.34
+      accepts: 1.3.8
+      base64id: 2.0.0
+      cookie: 0.4.2
+      cors: 2.8.5
+      debug: 4.3.4
+      engine.io-parser: 5.0.4
+      ws: 8.2.3
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    dev: true
+
   /enhanced-resolve/4.5.0:
     resolution: {integrity: sha512-Nv9m36S/vxpsI+Hc4/ZGRs0n9mXqSWGGq49zxb/cJfPAQMbUtttJAlNPS4AQzaBdw/pKskw5bMbekT/Y7W/Wlg==}
     engines: {node: '>=6.9.0'}
@@ -2013,6 +2182,10 @@ packages:
       tapable: 1.1.3
     dev: true
 
+  /ent/2.2.0:
+    resolution: {integrity: sha1-6WQhkyWiHQX0RGai9obtbOX13R0=}
+    dev: true
+
   /errno/0.1.8:
     resolution: {integrity: sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A==}
     hasBin: true
@@ -2239,6 +2412,10 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
+  /escape-html/1.0.3:
+    resolution: {integrity: sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=}
+    dev: true
+
   /escape-string-regexp/1.0.5:
     resolution: {integrity: sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=}
     engines: {node: '>=0.8.0'}
@@ -2402,6 +2579,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /eventemitter3/4.0.7:
+    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
+    dev: true
+
   /events/3.3.0:
     resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
     engines: {node: '>=0.8.x'}
@@ -2479,6 +2660,10 @@ packages:
       is-extendable: 1.0.1
     dev: true
 
+  /extend/3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+    dev: true
+
   /external-editor/3.1.0:
     resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
     engines: {node: '>=4'}
@@ -2604,6 +2789,21 @@ packages:
       to-regex-range: 5.0.1
     dev: true
 
+  /finalhandler/1.1.2:
+    resolution: {integrity: sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      debug: 2.6.9
+      encodeurl: 1.0.2
+      escape-html: 1.0.3
+      on-finished: 2.3.0
+      parseurl: 1.3.3
+      statuses: 1.5.0
+      unpipe: 1.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /find-cache-dir/2.1.0:
     resolution: {integrity: sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==}
     engines: {node: '>=6'}
@@ -2692,6 +2892,16 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
+  /follow-redirects/1.15.0:
+    resolution: {integrity: sha512-aExlJShTV4qOUOL7yF1U5tvLCB0xQuudbf6toyYA0E/acBNw71mvjFTnLaRp50aQaYocMR0a/RMMBIHeZnGyjQ==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+    dev: true
+
   /for-in/1.0.2:
     resolution: {integrity: sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=}
     engines: {node: '>=0.10.0'}
@@ -2791,6 +3001,14 @@ packages:
     resolution: {integrity: sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=}
     dev: true
 
+  /get-intrinsic/1.1.1:
+    resolution: {integrity: sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==}
+    dependencies:
+      function-bind: 1.1.1
+      has: 1.0.3
+      has-symbols: 1.0.3
+    dev: true
+
   /get-pkg-repo/4.2.1:
     resolution: {integrity: sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA==}
     engines: {node: '>=6.9.0'}
@@ -2982,6 +3200,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /has-symbols/1.0.3:
+    resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
   /has-value/0.3.1:
     resolution: {integrity: sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=}
     engines: {node: '>=0.10.0'}
@@ -3078,6 +3301,17 @@ packages:
       whatwg-encoding: 2.0.0
     dev: true
 
+  /http-errors/2.0.0:
+    resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.1
+      toidentifier: 1.0.1
+    dev: true
+
   /http-proxy-agent/5.0.0:
     resolution: {integrity: sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==}
     engines: {node: '>= 6'}
@@ -3089,6 +3323,17 @@ packages:
       - supports-color
     dev: true
 
+  /http-proxy/1.18.1:
+    resolution: {integrity: sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==}
+    engines: {node: '>=8.0.0'}
+    dependencies:
+      eventemitter3: 4.0.7
+      follow-redirects: 1.15.0
+      requires-port: 1.0.0
+    transitivePeerDependencies:
+      - debug
+    dev: true
+
   /https-browserify/1.0.0:
     resolution: {integrity: sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=}
     dev: true
@@ -3236,7 +3481,6 @@ packages:
     dependencies:
       binary-extensions: 2.2.0
     dev: true
-    optional: true
 
   /is-buffer/1.1.6:
     resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==}
@@ -3419,6 +3663,11 @@ packages:
     resolution: {integrity: sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=}
     dev: true
 
+  /isbinaryfile/4.0.10:
+    resolution: {integrity: sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==}
+    engines: {node: '>= 8.0.0'}
+    dev: true
+
   /isexe/2.0.0:
     resolution: {integrity: sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=}
     dev: true
@@ -3435,6 +3684,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /jasmine-core/4.1.1:
+    resolution: {integrity: sha512-lmUfT5XcK9KKvt3lLYzn93hc4MGzlUBowExFVgzbSW0ZCrdeyS574dfsyfRhxbg81Wj4gk+RxUiTnj7KBfDA1g==}
+    dev: true
+
   /js-tokens/4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
     dev: true
@@ -3534,6 +3787,76 @@ packages:
     engines: {'0': node >= 0.2.0}
     dev: true
 
+  /karma-chrome-launcher/3.1.1:
+    resolution: {integrity: sha512-hsIglcq1vtboGPAN+DGCISCFOxW+ZVnIqhDQcCMqqCp+4dmJ0Qpq5QAjkbA0X2L9Mi6OBkHi2Srrbmm7pUKkzQ==}
+    dependencies:
+      which: 1.3.1
+    dev: true
+
+  /karma-cli/2.0.0:
+    resolution: {integrity: sha512-1Kb28UILg1ZsfqQmeELbPzuEb5C6GZJfVIk0qOr8LNYQuYWmAaqP16WpbpKEjhejDrDYyYOwwJXSZO6u7q5Pvw==}
+    engines: {node: '>= 6'}
+    hasBin: true
+    dependencies:
+      resolve: 1.22.0
+    dev: true
+
+  /karma-esbuild/2.2.4_esbuild@0.14.39:
+    resolution: {integrity: sha512-nt5+AJ0iFpgJXboBmXvwjM5LYTqTmFA9NuNGj9A442gCMJHwL4Eft4JUBVRc7ORSPoJAQ26Kgf5252Xt6GbkRw==}
+    peerDependencies:
+      esbuild: '>=0.8.45'
+    dependencies:
+      chokidar: 3.5.3
+      esbuild: 0.14.39
+      source-map: 0.6.1
+    dev: true
+
+  /karma-jasmine/5.0.1_karma@6.3.20:
+    resolution: {integrity: sha512-FkL1Kk+JAKmim8VWU8RXKZBpl0lLI7J8LijM0/q7oP7emfB6QMZV1Az+JgqGKSLpF0tYaav+KUVFQroZUxQTHA==}
+    engines: {node: '>=12'}
+    peerDependencies:
+      karma: ^6.0.0
+    dependencies:
+      jasmine-core: 4.1.1
+      karma: 6.3.20
+    dev: true
+
+  /karma/6.3.20:
+    resolution: {integrity: sha512-HRNQhMuKOwKpjYlWiJP0DUrJOh+QjaI/DTaD8b9rEm4Il3tJ8MijutVZH4ts10LuUFst/CedwTS6vieCN8yTSw==}
+    engines: {node: '>= 10'}
+    hasBin: true
+    dependencies:
+      '@colors/colors': 1.5.0
+      body-parser: 1.20.0
+      braces: 3.0.2
+      chokidar: 3.5.3
+      connect: 3.7.0
+      di: 0.0.1
+      dom-serialize: 2.2.1
+      glob: 7.2.3
+      graceful-fs: 4.2.10
+      http-proxy: 1.18.1
+      isbinaryfile: 4.0.10
+      lodash: 4.17.21
+      log4js: 6.5.0
+      mime: 2.6.0
+      minimatch: 3.1.2
+      mkdirp: 0.5.6
+      qjobs: 1.2.0
+      range-parser: 1.2.1
+      rimraf: 3.0.2
+      socket.io: 4.5.1
+      source-map: 0.6.1
+      tmp: 0.2.1
+      ua-parser-js: 0.7.31
+      yargs: 16.2.0
+    transitivePeerDependencies:
+      - bufferutil
+      - debug
+      - supports-color
+      - utf-8-validate
+    dev: true
+
   /kind-of/3.2.2:
     resolution: {integrity: sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=}
     engines: {node: '>=0.10.0'}
@@ -3735,6 +4058,19 @@ packages:
       wrap-ansi: 6.2.0
     dev: true
 
+  /log4js/6.5.0:
+    resolution: {integrity: sha512-VT8b+k4nS7feV3p2nTdI5UqO2+7KRi4sfb6YKlnZlQU0d1DnvA18dvPhxKElgVTRTjS3GtChvvR67yMpp/xAfQ==}
+    engines: {node: '>=8.0'}
+    dependencies:
+      date-format: 4.0.10
+      debug: 4.3.4
+      flatted: 3.2.5
+      rfdc: 1.3.0
+      streamroller: 3.1.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /longest/2.0.1:
     resolution: {integrity: sha1-eB4YMpaqlPbU2RbcM10NF676I/g=}
     engines: {node: '>=0.10.0'}
@@ -3832,6 +4168,11 @@ packages:
       safe-buffer: 5.2.1
     dev: true
 
+  /media-typer/0.3.0:
+    resolution: {integrity: sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=}
+    engines: {node: '>= 0.6'}
+    dev: true
+
   /memory-fs/0.4.1:
     resolution: {integrity: sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=}
     dependencies:
@@ -3926,6 +4267,12 @@ packages:
       mime-db: 1.52.0
     dev: true
 
+  /mime/2.6.0:
+    resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==}
+    engines: {node: '>=4.0.0'}
+    hasBin: true
+    dev: true
+
   /mimic-fn/1.2.0:
     resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
     engines: {node: '>=4'}
@@ -4069,6 +4416,11 @@ packages:
     resolution: {integrity: sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=}
     dev: true
 
+  /negotiator/0.6.3:
+    resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
+    engines: {node: '>= 0.6'}
+    dev: true
+
   /neo-async/2.6.2:
     resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==}
     dev: true
@@ -4200,6 +4552,20 @@ packages:
       isobject: 3.0.1
     dev: true
 
+  /on-finished/2.3.0:
+    resolution: {integrity: sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      ee-first: 1.1.1
+    dev: true
+
+  /on-finished/2.4.1:
+    resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      ee-first: 1.1.1
+    dev: true
+
   /once/1.4.0:
     resolution: {integrity: sha1-WDsap3WWHUsROsF9nFC6753Xa9E=}
     dependencies:
@@ -4380,6 +4746,11 @@ packages:
     resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
     dev: true
 
+  /parseurl/1.3.3:
+    resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /pascalcase/0.1.1:
     resolution: {integrity: sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=}
     engines: {node: '>=0.10.0'}
@@ -4657,6 +5028,18 @@ packages:
     engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
     dev: true
 
+  /qjobs/1.2.0:
+    resolution: {integrity: sha512-8YOJEHtxpySA3fFDyCRxA+UUV+fA+rTWnuWvylOK/NCjhY+b4ocCtmu8TtsWb+mYeU+GCHf/S66KZF/AsteKHg==}
+    engines: {node: '>=0.9'}
+    dev: true
+
+  /qs/6.10.3:
+    resolution: {integrity: sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==}
+    engines: {node: '>=0.6'}
+    dependencies:
+      side-channel: 1.0.4
+    dev: true
+
   /querystring-es3/0.2.1:
     resolution: {integrity: sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=}
     engines: {node: '>=0.4.x'}
@@ -4690,6 +5073,21 @@ packages:
       safe-buffer: 5.2.1
     dev: true
 
+  /range-parser/1.2.1:
+    resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
+    engines: {node: '>= 0.6'}
+    dev: true
+
+  /raw-body/2.5.1:
+    resolution: {integrity: sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.0
+      iconv-lite: 0.4.24
+      unpipe: 1.0.0
+    dev: true
+
   /read-pkg-up/3.0.0:
     resolution: {integrity: sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=}
     engines: {node: '>=4'}
@@ -4765,7 +5163,6 @@ packages:
     dependencies:
       picomatch: 2.3.1
     dev: true
-    optional: true
 
   /rechoir/0.6.2:
     resolution: {integrity: sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=}
@@ -4815,6 +5212,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /requires-port/1.0.0:
+    resolution: {integrity: sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=}
+    dev: true
+
   /resolve-dir/1.0.1:
     resolution: {integrity: sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=}
     engines: {node: '>=0.10.0'}
@@ -5039,6 +5440,10 @@ packages:
     resolution: {integrity: sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=}
     dev: true
 
+  /setprototypeof/1.2.0:
+    resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
+    dev: true
+
   /sha.js/2.4.11:
     resolution: {integrity: sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==}
     hasBin: true
@@ -5081,6 +5486,14 @@ packages:
       rechoir: 0.6.2
     dev: true
 
+  /side-channel/1.0.4:
+    resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
+    dependencies:
+      call-bind: 1.0.2
+      get-intrinsic: 1.1.1
+      object-inspect: 1.12.0
+    dev: true
+
   /signal-exit/3.0.7:
     resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
     dev: true
@@ -5148,6 +5561,37 @@ packages:
       - supports-color
     dev: true
 
+  /socket.io-adapter/2.4.0:
+    resolution: {integrity: sha512-W4N+o69rkMEGVuk2D/cvca3uYsvGlMwsySWV447y99gUPghxq42BxqLNMndb+a1mm/5/7NeXVQS7RLa2XyXvYg==}
+    dev: true
+
+  /socket.io-parser/4.0.4:
+    resolution: {integrity: sha512-t+b0SS+IxG7Rxzda2EVvyBZbvFPBCjJoyHuE0P//7OAsN23GItzDRdWa6ALxZI/8R5ygK7jAR6t028/z+7295g==}
+    engines: {node: '>=10.0.0'}
+    dependencies:
+      '@types/component-emitter': 1.2.11
+      component-emitter: 1.3.0
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /socket.io/4.5.1:
+    resolution: {integrity: sha512-0y9pnIso5a9i+lJmsCdtmTTgJFFSvNQKDnPQRz28mGNnxbmqYg2QPtJTLFxhymFZhAIn50eHAKzJeiNaKr+yUQ==}
+    engines: {node: '>=10.0.0'}
+    dependencies:
+      accepts: 1.3.8
+      base64id: 2.0.0
+      debug: 4.3.4
+      engine.io: 6.2.0
+      socket.io-adapter: 2.4.0
+      socket.io-parser: 4.0.4
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    dev: true
+
   /source-list-map/2.0.1:
     resolution: {integrity: sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==}
     dev: true
@@ -5256,6 +5700,16 @@ packages:
       object-copy: 0.1.0
     dev: true
 
+  /statuses/1.5.0:
+    resolution: {integrity: sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=}
+    engines: {node: '>= 0.6'}
+    dev: true
+
+  /statuses/2.0.1:
+    resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /stream-browserify/2.0.2:
     resolution: {integrity: sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==}
     dependencies:
@@ -5284,6 +5738,17 @@ packages:
     resolution: {integrity: sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==}
     dev: true
 
+  /streamroller/3.1.0:
+    resolution: {integrity: sha512-9+fOFZX3qeo5lEdq9AnPxyRqdrh0MhlX5uqDN6+OLGuGK0PnyyKjMicwcUYIzjYRut5Pfbc0AV6WKdv6di3YGA==}
+    engines: {node: '>=8.0'}
+    dependencies:
+      date-format: 4.0.10
+      debug: 4.3.4
+      fs-extra: 10.1.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /string-argv/0.3.1:
     resolution: {integrity: sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg==}
     engines: {node: '>=0.6.19'}
@@ -5540,6 +6005,13 @@ packages:
       os-tmpdir: 1.0.2
     dev: true
 
+  /tmp/0.2.1:
+    resolution: {integrity: sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==}
+    engines: {node: '>=8.17.0'}
+    dependencies:
+      rimraf: 3.0.2
+    dev: true
+
   /to-arraybuffer/1.0.1:
     resolution: {integrity: sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=}
     dev: true
@@ -5580,6 +6052,11 @@ packages:
     resolution: {integrity: sha512-ViAkQ7ed89rmhFIGRsT36njN+97z8+s3XsJnB8E2IKOq+/SLD/6PtSvmTtiwUcVk39qPcjAc/OyeDys4LoJUVg==}
     dev: true
 
+  /toidentifier/1.0.1:
+    resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
+    engines: {node: '>=0.6'}
+    dev: true
+
   /tough-cookie/4.0.0:
     resolution: {integrity: sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==}
     engines: {node: '>=6'}
@@ -5708,6 +6185,14 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /type-is/1.6.18:
+    resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      media-typer: 0.3.0
+      mime-types: 2.1.35
+    dev: true
+
   /typedarray/0.0.6:
     resolution: {integrity: sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=}
     dev: true
@@ -5718,6 +6203,10 @@ packages:
     hasBin: true
     dev: true
 
+  /ua-parser-js/0.7.31:
+    resolution: {integrity: sha512-qLK/Xe9E2uzmYI3qLeOmI0tEOt+TBBQyUIAh4aAgU05FVYzeZrKUdkAZfBNVGRaHVgV0TDkdEngJSw/SyQchkQ==}
+    dev: true
+
   /uglify-js/3.15.5:
     resolution: {integrity: sha512-hNM5q5GbBRB5xB+PMqVRcgYe4c8jbyZ1pzZhS6jbq54/4F2gFK869ZheiE5A8/t+W5jtTNpWef/5Q9zk639FNQ==}
     engines: {node: '>=0.8.0'}
@@ -5765,6 +6254,11 @@ packages:
     engines: {node: '>= 10.0.0'}
     dev: true
 
+  /unpipe/1.0.0:
+    resolution: {integrity: sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /unset-value/1.0.0:
     resolution: {integrity: sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=}
     engines: {node: '>=0.10.0'}
@@ -5827,6 +6321,11 @@ packages:
       inherits: 2.0.3
     dev: true
 
+  /utils-merge/1.0.1:
+    resolution: {integrity: sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=}
+    engines: {node: '>= 0.4.0'}
+    dev: true
+
   /v8-compile-cache-lib/3.0.1:
     resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
     dev: true
@@ -5842,6 +6341,11 @@ packages:
       spdx-expression-parse: 3.0.1
     dev: true
 
+  /vary/1.1.2:
+    resolution: {integrity: sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=}
+    engines: {node: '>= 0.8'}
+    dev: true
+
   /vite/2.9.9:
     resolution: {integrity: sha512-ffaam+NgHfbEmfw/Vuh6BHKKlI/XIAhxE5QSS7gFLIngxg171mg1P3a4LSRME0z2ZU1ScxoKzphkipcYwSD5Ew==}
     engines: {node: '>=12.2.0'}
@@ -5903,6 +6407,11 @@ packages:
     resolution: {integrity: sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==}
     dev: true
 
+  /void-elements/2.0.1:
+    resolution: {integrity: sha1-wGavtYK7HLQSjWDqkjkulNXp2+w=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /w3c-hr-time/1.0.2:
     resolution: {integrity: sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==}
     dependencies:
@@ -6093,6 +6602,19 @@ packages:
     resolution: {integrity: sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=}
     dev: true
 
+  /ws/8.2.3:
+    resolution: {integrity: sha512-wBuoj1BDpC6ZQ1B7DWQBYVLphPWkm8i9Y0/3YdHjHKHiohOJ1ws+3OccDWtH+PoC9DZD5WOTrJvNbWvjS6JWaA==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+    dev: true
+
   /ws/8.6.0:
     resolution: {integrity: sha512-AzmM3aH3gk0aX7/rZLYvjdvZooofDu3fFOzGqcSnQ1tOcTWwhM/o+q++E8mAyVVIyUdajrkzWUGftaVSDLn1bw==}
     engines: {node: '>=10.0.0'}
diff --git a/test/helpers/trigger-event.ts b/test/helpers/trigger-event.ts
index 8fb5a2274ee..6dedd95cdef 100644
--- a/test/helpers/trigger-event.ts
+++ b/test/helpers/trigger-event.ts
@@ -1,4 +1,4 @@
-global.triggerEvent = function triggerEvent (target, event, process) {
+export function triggerEvent (target, event, process) {
   const e = document.createEvent('HTMLEvents')
   e.initEvent(event, true, true)
   if (event === 'click') {
diff --git a/test/helpers/vdom.ts b/test/helpers/vdom.ts
index ab74df8f621..ab4af6e9883 100644
--- a/test/helpers/vdom.ts
+++ b/test/helpers/vdom.ts
@@ -1,5 +1,5 @@
 import VNode from 'core/vdom/vnode'
 
-global.createTextVNode = function (text) {
+export function createTextVNode(text) {
   return new VNode(undefined, undefined, undefined, text)
 }
diff --git a/test/helpers/wait-for-update.ts b/test/helpers/wait-for-update.ts
index 0d643f8439a..1898466b7b8 100644
--- a/test/helpers/wait-for-update.ts
+++ b/test/helpers/wait-for-update.ts
@@ -18,7 +18,7 @@ interface Job extends Function {
   fail?: (e: any) => void
 }
 
-global.waitForUpdate = (initialCb: Job) => {
+const waitForUpdate = (initialCb: Job) => {
   let end
   const queue: Job[] = initialCb ? [initialCb] : []
 
@@ -77,3 +77,5 @@ global.waitForUpdate = (initialCb: Job) => {
 function timeout(n) {
   return (next) => setTimeout(next, n)
 }
+
+export { waitForUpdate }
diff --git a/test/test-env.d.ts b/test/test-env.d.ts
index 035caba5c36..be1fa6a7d85 100644
--- a/test/test-env.d.ts
+++ b/test/test-env.d.ts
@@ -24,3 +24,13 @@ declare namespace jest {
     toHaveClass(cls: string): R
   }
 }
+
+declare const jasmine: {
+  createSpy: (id?: string) => {
+    (...args: any[]): any
+    calls: {
+      count(): number
+    }
+  }
+  addMatchers(matchers: any): void
+}
diff --git a/test/transition/helpers.ts b/test/transition/helpers.ts
new file mode 100644
index 00000000000..f6a405f0cf7
--- /dev/null
+++ b/test/transition/helpers.ts
@@ -0,0 +1,144 @@
+export { waitForUpdate } from '../helpers/wait-for-update'
+export { nextFrame } from 'web/runtime/transition-util'
+
+// toHaveBeenWarned() matcher
+function noop() {}
+
+if (typeof console === 'undefined') {
+  // @ts-ignore
+  window.console = {
+    warn: noop,
+    error: noop
+  }
+}
+
+// avoid info messages during test
+console.info = noop
+
+let asserted
+
+function createCompareFn(spy) {
+  const hasWarned = (msg) => {
+    let count = spy.calls.count()
+    let args
+    while (count--) {
+      args = spy.calls.argsFor(count)
+      if (args.some(containsMsg)) {
+        return true
+      }
+    }
+
+    function containsMsg(arg) {
+      return arg.toString().indexOf(msg) > -1
+    }
+  }
+
+  return {
+    compare: (msg) => {
+      asserted = asserted.concat(msg)
+      const warned = Array.isArray(msg) ? msg.some(hasWarned) : hasWarned(msg)
+      return {
+        pass: warned,
+        message: warned
+          ? 'Expected message "' + msg + '" not to have been warned'
+          : 'Expected message "' + msg + '" to have been warned'
+      }
+    }
+  }
+}
+
+// define custom matcher for warnings
+beforeEach(() => {
+  asserted = []
+  // @ts-ignore
+  spyOn(console, 'warn')
+  // @ts-ignore
+  spyOn(console, 'error')
+  jasmine.addMatchers({
+    toHaveBeenWarned: () => createCompareFn(console.error),
+    toHaveBeenTipped: () => createCompareFn(console.warn)
+  })
+})
+
+afterEach((done) => {
+  const warned = (msg) =>
+    asserted.some((assertedMsg) => msg.toString().indexOf(assertedMsg) > -1)
+  // @ts-ignore
+  let count = console.error.calls.count()
+  let args
+  while (count--) {
+    // @ts-ignore
+    args = console.error.calls.argsFor(count)
+    if (!warned(args[0])) {
+      // @ts-ignore
+      done.fail(`Unexpected console.error message: ${args[0]}`)
+      return
+    }
+  }
+  done()
+})
+
+// injectStyles helper
+function insertCSS(text) {
+  const cssEl = document.createElement('style')
+  cssEl.textContent = text.trim()
+  document.head.appendChild(cssEl)
+}
+
+const duration = process.env.CI ? 200 : 50
+const buffer = process.env.CI ? 20 : 5
+let injected = false
+
+export function injectStyles() {
+  if (injected) return { duration, buffer }
+  injected = true
+  insertCSS(`
+    .test {
+      -webkit-transition: opacity ${duration}ms ease;
+      transition: opacity ${duration}ms ease;
+    }
+    .group-move {
+      -webkit-transition: -webkit-transform ${duration}ms ease;
+      transition: transform ${duration}ms ease;
+    }
+    .v-appear, .v-enter, .v-leave-active,
+    .test-appear, .test-enter, .test-leave-active,
+    .hello, .bye.active,
+    .changed-enter {
+      opacity: 0;
+    }
+    .test-anim-enter-active {
+      animation: test-enter ${duration}ms;
+      -webkit-animation: test-enter ${duration}ms;
+    }
+    .test-anim-leave-active {
+      animation: test-leave ${duration}ms;
+      -webkit-animation: test-leave ${duration}ms;
+    }
+    .test-anim-long-enter-active {
+      animation: test-enter ${duration * 2}ms;
+      -webkit-animation: test-enter ${duration * 2}ms;
+    }
+    .test-anim-long-leave-active {
+      animation: test-leave ${duration * 2}ms;
+      -webkit-animation: test-leave ${duration * 2}ms;
+    }
+    @keyframes test-enter {
+      from { opacity: 0 }
+      to { opacity: 1 }
+    }
+    @-webkit-keyframes test-enter {
+      from { opacity: 0 }
+      to { opacity: 1 }
+    }
+    @keyframes test-leave {
+      from { opacity: 1 }
+      to { opacity: 0 }
+    }
+    @-webkit-keyframes test-leave {
+      from { opacity: 1 }
+      to { opacity: 0 }
+    }
+  `)
+  return { duration, buffer }
+}
diff --git a/test/transition/karma.conf.js b/test/transition/karma.conf.js
new file mode 100644
index 00000000000..f2e68c509da
--- /dev/null
+++ b/test/transition/karma.conf.js
@@ -0,0 +1,27 @@
+const featureFlags = require('../../scripts/feature-flags')
+process.env.CHROME_BIN = require('puppeteer').executablePath()
+
+const define = {
+  'process.env.CI': !!process.env.CI
+}
+
+for (const key in featureFlags) {
+  define[`process.env.${key}`] = featureFlags[key]
+}
+
+module.exports = function (config) {
+  config.set({
+    basePath: '.',
+    frameworks: ['jasmine'],
+    files: ['*.spec.ts'],
+    preprocessors: {
+      '*.spec.ts': ['esbuild']
+    },
+    esbuild: {
+      define
+    },
+    browsers: ['ChromeHeadless'],
+    plugins: ['karma-jasmine', 'karma-esbuild', 'karma-chrome-launcher'],
+    singleRun: true
+  })
+}
diff --git a/test/transition/package.json b/test/transition/package.json
new file mode 100644
index 00000000000..0967ef424bc
--- /dev/null
+++ b/test/transition/package.json
@@ -0,0 +1 @@
+{}
diff --git a/test/unit/features/transition/transition-group.spec.ts b/test/transition/transition-group.spec.ts
similarity index 96%
rename from test/unit/features/transition/transition-group.spec.ts
rename to test/transition/transition-group.spec.ts
index 7f2499bd93f..a9c1ab62ffe 100644
--- a/test/unit/features/transition/transition-group.spec.ts
+++ b/test/transition/transition-group.spec.ts
@@ -1,8 +1,7 @@
 import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { nextFrame } from 'web/runtime/transition-util'
+import { injectStyles, waitForUpdate, nextFrame } from './helpers'
 
-describe.skip('Transition group', () => {
+describe('Transition group', () => {
   const { duration, buffer } = injectStyles()
 
   let el
@@ -212,9 +211,9 @@ describe.skip('Transition group', () => {
 
   it('events', (done) => {
     let next
-    const beforeEnterSpy = vi.fn()
-    const afterEnterSpy = vi.fn()
-    const afterLeaveSpy = vi.fn()
+    const beforeEnterSpy = jasmine.createSpy()
+    const afterEnterSpy = jasmine.createSpy()
+    const afterLeaveSpy = jasmine.createSpy()
     const vm = new Vue({
       template: `
           <div>
@@ -254,7 +253,7 @@ describe.skip('Transition group', () => {
           `<div class="test v-enter v-enter-active">d</div>` +
           `</span>`
       )
-      expect(beforeEnterSpy.mock.calls.length).toBe(1)
+      expect(beforeEnterSpy.calls.count()).toBe(1)
     })
       .thenWaitFor((_next) => {
         next = _next
@@ -268,7 +267,7 @@ describe.skip('Transition group', () => {
             `<div class="test">d</div>` +
             `</span>`
         )
-        expect(afterEnterSpy.mock.calls.length).toBe(1)
+        expect(afterEnterSpy.calls.count()).toBe(1)
         vm.items.shift()
       })
       .thenWaitFor((_next) => {
@@ -282,7 +281,7 @@ describe.skip('Transition group', () => {
             `<div class="test">d</div>` +
             `</span>`
         )
-        expect(afterLeaveSpy.mock.calls.length).toBe(1)
+        expect(afterLeaveSpy.calls.count()).toBe(1)
       })
       .then(done)
   })
diff --git a/test/unit/features/transition/transition-mode.spec.ts b/test/transition/transition-mode.spec.ts
similarity index 99%
rename from test/unit/features/transition/transition-mode.spec.ts
rename to test/transition/transition-mode.spec.ts
index 1e92911b924..eba58ecbef5 100644
--- a/test/unit/features/transition/transition-mode.spec.ts
+++ b/test/transition/transition-mode.spec.ts
@@ -1,8 +1,7 @@
 import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { nextFrame } from 'web/runtime/transition-util'
+import { injectStyles, waitForUpdate, nextFrame } from './helpers'
 
-describe.skip('Transition mode', () => {
+describe('Transition mode', () => {
   const { duration, buffer } = injectStyles()
   const components = {
     one: { template: '<div>one</div>' },
@@ -667,7 +666,7 @@ describe.skip('Transition mode', () => {
           expect(vm.$el.children[0].className).toMatch('test-anim-leave-active')
           expect(vm.$el.children[1].className).toBe('')
         })
-        .thenWaitFor(duration + buffer)
+        .thenWaitFor(duration + buffer * 2)
         .then(() => {
           expect(vm.$el.children.length).toBe(1)
           expect(vm.$el.textContent).toBe('component B')
diff --git a/test/unit/features/transition/transition-with-keep-alive.spec.ts b/test/transition/transition-with-keep-alive.spec.ts
similarity index 95%
rename from test/unit/features/transition/transition-with-keep-alive.spec.ts
rename to test/transition/transition-with-keep-alive.spec.ts
index 92caaaf122c..09c6613046a 100644
--- a/test/unit/features/transition/transition-with-keep-alive.spec.ts
+++ b/test/transition/transition-with-keep-alive.spec.ts
@@ -1,27 +1,26 @@
 import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { nextFrame } from 'web/runtime/transition-util'
+import { injectStyles, waitForUpdate, nextFrame } from './helpers'
 
-describe.skip('Transition w/ KeepAlive', () => {
+describe('Transition w/ KeepAlive', () => {
   const { duration, buffer } = injectStyles()
 
   let components, one, two, el
   beforeEach(() => {
     one = {
       template: '<div>one</div>',
-      created: vi.fn(),
-      mounted: vi.fn(),
-      activated: vi.fn(),
-      deactivated: vi.fn(),
-      destroyed: vi.fn()
+      created: jasmine.createSpy(),
+      mounted: jasmine.createSpy(),
+      activated: jasmine.createSpy(),
+      deactivated: jasmine.createSpy(),
+      destroyed: jasmine.createSpy()
     }
     two = {
       template: '<div>two</div>',
-      created: vi.fn(),
-      mounted: vi.fn(),
-      activated: vi.fn(),
-      deactivated: vi.fn(),
-      destroyed: vi.fn()
+      created: jasmine.createSpy(),
+      mounted: jasmine.createSpy(),
+      activated: jasmine.createSpy(),
+      deactivated: jasmine.createSpy(),
+      destroyed: jasmine.createSpy()
     }
     components = {
       one,
@@ -33,11 +32,11 @@ describe.skip('Transition w/ KeepAlive', () => {
 
   function assertHookCalls(component, callCounts) {
     expect([
-      component.created.mock.calls.length,
-      component.mounted.mock.calls.length,
-      component.activated.mock.calls.length,
-      component.deactivated.mock.calls.length,
-      component.destroyed.mock.calls.length
+      component.created.calls.count(),
+      component.mounted.calls.count(),
+      component.activated.calls.count(),
+      component.deactivated.calls.count(),
+      component.destroyed.calls.count()
     ]).toEqual(callCounts)
   }
 
@@ -515,7 +514,7 @@ describe.skip('Transition w/ KeepAlive', () => {
   })
 
   it('async components with transition-mode out-in', (done) => {
-    const barResolve = vi.fn()
+    const barResolve = jasmine.createSpy()
     let next
     const foo = (resolve) => {
       setTimeout(() => {
@@ -591,7 +590,7 @@ describe.skip('Transition w/ KeepAlive', () => {
         .then(() => {
           // foo afterLeave get called
           // and bar has already been resolved before afterLeave get called
-          expect(barResolve.mock.calls.length).toBe(1)
+          expect(barResolve.calls.count()).toBe(1)
           expect(vm.$el.innerHTML).toBe('<!---->')
         })
         .thenWaitFor(nextFrame)
diff --git a/test/unit/features/transition/transition.spec.ts b/test/transition/transition.spec.ts
similarity index 98%
rename from test/unit/features/transition/transition.spec.ts
rename to test/transition/transition.spec.ts
index 534e06d1a7e..e84a3cfa563 100644
--- a/test/unit/features/transition/transition.spec.ts
+++ b/test/transition/transition.spec.ts
@@ -1,8 +1,7 @@
 import Vue from 'vue'
-import injectStyles from './inject-styles'
-import { nextFrame } from 'web/runtime/transition-util'
+import { injectStyles, waitForUpdate, nextFrame } from './helpers'
 
-describe.skip('Transition basic', () => {
+describe('Transition basic', () => {
   const { duration, buffer } = injectStyles() as {
     duration: number
     buffer: number
@@ -202,8 +201,8 @@ describe.skip('Transition basic', () => {
   })
 
   it('inline transition object', (done) => {
-    const enter = vi.fn()
-    const leave = vi.fn()
+    const enter = jasmine.createSpy()
+    const leave = jasmine.createSpy()
     const vm = new Vue({
       render(h) {
         return h('div', null, [
@@ -263,12 +262,12 @@ describe.skip('Transition basic', () => {
   })
 
   it('transition events', (done) => {
-    const onLeaveSpy = vi.fn()
-    const onEnterSpy = vi.fn()
-    const beforeLeaveSpy = vi.fn()
-    const beforeEnterSpy = vi.fn()
-    const afterLeaveSpy = vi.fn()
-    const afterEnterSpy = vi.fn()
+    const onLeaveSpy = jasmine.createSpy()
+    const onEnterSpy = jasmine.createSpy()
+    const beforeLeaveSpy = jasmine.createSpy()
+    const beforeEnterSpy = jasmine.createSpy()
+    const afterLeaveSpy = jasmine.createSpy()
+    const afterEnterSpy = jasmine.createSpy()
 
     const vm = new Vue({
       template: `
@@ -356,12 +355,12 @@ describe.skip('Transition basic', () => {
   })
 
   it('transition events (v-show)', (done) => {
-    const onLeaveSpy = vi.fn()
-    const onEnterSpy = vi.fn()
-    const beforeLeaveSpy = vi.fn()
-    const beforeEnterSpy = vi.fn()
-    const afterLeaveSpy = vi.fn()
-    const afterEnterSpy = vi.fn()
+    const onLeaveSpy = jasmine.createSpy()
+    const onEnterSpy = jasmine.createSpy()
+    const beforeLeaveSpy = jasmine.createSpy()
+    const beforeEnterSpy = jasmine.createSpy()
+    const afterLeaveSpy = jasmine.createSpy()
+    const afterEnterSpy = jasmine.createSpy()
 
     const vm = new Vue({
       template: `
@@ -524,8 +523,8 @@ describe.skip('Transition basic', () => {
   })
 
   it('css: false', (done) => {
-    const enterSpy = vi.fn()
-    const leaveSpy = vi.fn()
+    const enterSpy = jasmine.createSpy()
+    const leaveSpy = jasmine.createSpy()
     const vm = new Vue({
       template: `
           <div>
@@ -555,8 +554,8 @@ describe.skip('Transition basic', () => {
   })
 
   it('no transition detected', (done) => {
-    const enterSpy = vi.fn()
-    const leaveSpy = vi.fn()
+    const enterSpy = jasmine.createSpy()
+    const leaveSpy = jasmine.createSpy()
     const vm = new Vue({
       template:
         '<div><transition name="nope" @enter="enter" @leave="leave"><div v-if="ok">foo</div></transition></div>',
@@ -593,7 +592,7 @@ describe.skip('Transition basic', () => {
   })
 
   it('enterCancelled', (done) => {
-    const spy = vi.fn()
+    const spy = jasmine.createSpy()
     const vm = new Vue({
       template: `
           <div>
@@ -645,7 +644,7 @@ describe.skip('Transition basic', () => {
   })
 
   it('should remove stale leaving elements', (done) => {
-    const spy = vi.fn()
+    const spy = jasmine.createSpy()
     const vm = new Vue({
       template: `
           <div>
@@ -798,7 +797,7 @@ describe.skip('Transition basic', () => {
   })
 
   it('leaveCancelled (v-show only)', (done) => {
-    const spy = vi.fn()
+    const spy = jasmine.createSpy()
     const vm = new Vue({
       template: `
           <div>
diff --git a/test/unit/features/transition/inject-styles.ts b/test/unit/features/transition/inject-styles.ts
deleted file mode 100644
index e2f8f87ccf9..00000000000
--- a/test/unit/features/transition/inject-styles.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-function insertCSS (text) {
-  const cssEl = document.createElement('style')
-  cssEl.textContent = text.trim()
-  document.head.appendChild(cssEl)
-}
-
-const duration = parseInt(process.env.TRANSITION_DURATION || '50')
-const buffer = parseInt(process.env.TRANSITION_BUFFER || '10')
-let injected = false
-
-export default function injectStyles () {
-  if (injected) return { duration, buffer }
-  injected = true
-  insertCSS(`
-    .test {
-      -webkit-transition: opacity ${duration}ms ease;
-      transition: opacity ${duration}ms ease;
-    }
-    .group-move {
-      -webkit-transition: -webkit-transform ${duration}ms ease;
-      transition: transform ${duration}ms ease;
-    }
-    .v-appear, .v-enter, .v-leave-active,
-    .test-appear, .test-enter, .test-leave-active,
-    .hello, .bye.active,
-    .changed-enter {
-      opacity: 0;
-    }
-    .test-anim-enter-active {
-      animation: test-enter ${duration}ms;
-      -webkit-animation: test-enter ${duration}ms;
-    }
-    .test-anim-leave-active {
-      animation: test-leave ${duration}ms;
-      -webkit-animation: test-leave ${duration}ms;
-    }
-    .test-anim-long-enter-active {
-      animation: test-enter ${duration * 2}ms;
-      -webkit-animation: test-enter ${duration * 2}ms;
-    }
-    .test-anim-long-leave-active {
-      animation: test-leave ${duration * 2}ms;
-      -webkit-animation: test-leave ${duration * 2}ms;
-    }
-    @keyframes test-enter {
-      from { opacity: 0 }
-      to { opacity: 1 }
-    }
-    @-webkit-keyframes test-enter {
-      from { opacity: 0 }
-      to { opacity: 1 }
-    }
-    @keyframes test-leave {
-      from { opacity: 1 }
-      to { opacity: 0 }
-    }
-    @-webkit-keyframes test-leave {
-      from { opacity: 1 }
-      to { opacity: 0 }
-    }
-  `)
-  return { duration, buffer }
-}
-
diff --git a/test/vitest.setup.ts b/test/vitest.setup.ts
index 645dd2289b2..38397765f06 100644
--- a/test/vitest.setup.ts
+++ b/test/vitest.setup.ts
@@ -2,7 +2,12 @@ process.env.NEW_SLOT_SYNTAX = 'true'
 
 import './helpers/shim-done'
 import './helpers/to-have-warned'
-import './helpers/wait-for-update'
-import './helpers/trigger-event'
-import './helpers/vdom'
 import './helpers/classlist'
+
+import { waitForUpdate } from './helpers/wait-for-update'
+import { triggerEvent } from './helpers/trigger-event'
+import { createTextVNode } from './helpers/vdom'
+
+global.waitForUpdate = waitForUpdate
+global.triggerEvent = triggerEvent
+global.createTextVNode = createTextVNode

From 58608a2f26edb64ec4bc48139b6bea14789721b5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 23 May 2022 15:16:32 +0800
Subject: [PATCH 065/317] chore: fix ci script

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fb1374ef9d3..caa2fdcd672 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -63,6 +63,8 @@ jobs:
 
       - name: Run e2e tests
         run: pnpm run test:e2e
+
+      - name: Run transition tests
         run: pnpm run test:transition
 
   lint-and-test-dts:

From 6f8fb220e20c007a32cde2d0c0f4187517ae3323 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 23 May 2022 17:14:02 +0800
Subject: [PATCH 066/317] build: target es2017 / node 8 for cjs files

---
 scripts/config.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/scripts/config.js b/scripts/config.js
index 05d5e0e628f..5cb0fdcc461 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -212,7 +212,9 @@ function genConfig(name) {
         cacheRoot: path.resolve(__dirname, '../', 'node_modules/.rts2_cache'),
         tsconfigOverride: {
           compilerOptions: {
-            target: opts.transpile === false ? 'esnext' : 'es5'
+            // if targeting browser, target es5
+            // if targeting node, es2017 means Node 8
+            target: opts.transpile === false ? 'es2017' : 'es5'
           },
           exclude: ['test', 'test-dts']
         }

From 72aed6a149b94b5b929fb47370a7a6d4cb7491c5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 23 May 2022 17:21:17 +0800
Subject: [PATCH 067/317] workflow: remove eslint, apply prettier

---
 .babelrc.js                                   |   13 -
 .eslintignore                                 |    3 -
 .eslintrc.js                                  |   39 -
 .prettierrc                                   |    5 +
 examples/.eslintrc.json                       |    6 -
 package.json                                  |   11 +-
 .../vue-server-renderer/client-plugin.d.ts    |    6 +-
 .../vue-server-renderer/server-plugin.d.ts    |    6 +-
 packages/vue-server-renderer/types/index.d.ts |   59 +-
 .../vue-server-renderer/types/plugin.d.ts     |    6 +-
 .../vue-template-compiler/types/index.d.ts    |  266 +-
 packages/vue-template-compiler/types/test.ts  |   42 +-
 pnpm-lock.yaml                                |  501 +---
 src/compiler/codeframe.ts                     |    1 -
 src/compiler/codegen/events.ts                |    8 +-
 src/compiler/codegen/index.ts                 |   14 +-
 src/compiler/create-compiler.ts               |   21 +-
 src/compiler/directives/bind.ts               |    1 -
 src/compiler/directives/index.ts              |    3 +-
 src/compiler/directives/model.ts              |    9 +-
 src/compiler/directives/on.ts                 |    1 -
 src/compiler/error-detector.ts                |    8 +-
 src/compiler/helpers.ts                       |    9 +-
 src/compiler/index.ts                         |    3 +-
 src/compiler/optimizer.ts                     |    1 -
 src/compiler/parser/entity-decoder.ts         |    3 +-
 src/compiler/parser/filter-parser.ts          |    3 +-
 src/compiler/parser/html-parser.ts            |   20 +-
 src/compiler/parser/index.ts                  |   50 +-
 src/compiler/parser/text-parser.ts            |    5 +-
 src/compiler/to-function.ts                   |   13 +-
 src/core/components/index.ts                  |    2 +-
 src/core/components/keep-alive.ts             |  128 +-
 src/core/config.ts                            |    7 +-
 src/core/global-api/assets.ts                 |    3 +-
 src/core/global-api/extend.ts                 |    5 +-
 src/core/global-api/index.ts                  |    7 +-
 src/core/global-api/mixin.ts                  |    1 -
 src/core/global-api/use.ts                    |    1 -
 src/core/index.ts                             |    6 +-
 src/core/instance/events.ts                   |    5 +-
 src/core/instance/index.ts                    |   32 +-
 src/core/instance/init.ts                     |    1 -
 src/core/instance/inject.ts                   |    3 +-
 src/core/instance/lifecycle.ts                |  296 +-
 src/core/instance/proxy.ts                    |    6 +-
 .../render-helpers/bind-dynamic-keys.ts       |    1 -
 .../render-helpers/bind-object-listeners.ts   |    1 -
 .../render-helpers/bind-object-props.ts       |    3 +-
 .../instance/render-helpers/check-keycodes.ts |    1 -
 src/core/instance/render-helpers/index.ts     |    1 -
 .../instance/render-helpers/render-list.ts    |    2 +-
 .../instance/render-helpers/render-slot.ts    |   30 +-
 .../render-helpers/resolve-scoped-slots.ts    |    2 +-
 .../instance/render-helpers/resolve-slots.ts  |    3 +-
 src/core/instance/render.ts                   |    7 +-
 src/core/instance/state.ts                    |  279 +-
 src/core/observer/array.ts                    |    2 +-
 src/core/observer/index.ts                    |   10 +-
 src/core/observer/scheduler.ts                |    1 -
 src/core/observer/traverse.ts                 |    1 -
 src/core/observer/watcher.ts                  |   31 +-
 src/core/util/debug.ts                        |    5 +-
 src/core/util/error.ts                        |    2 +-
 src/core/util/index.ts                        |    1 -
 src/core/util/lang.ts                         |    6 +-
 src/core/util/next-tick.ts                    |    4 +-
 src/core/util/options.ts                      |   39 +-
 src/core/util/perf.ts                         |    2 +-
 src/core/util/props.ts                        |    6 +-
 src/core/vdom/create-component.ts             |   11 +-
 src/core/vdom/create-functional-component.ts  |   10 +-
 src/core/vdom/helpers/extract-props.ts        |    3 +-
 .../vdom/helpers/get-first-component-child.ts |    1 -
 src/core/vdom/helpers/index.ts                |    1 -
 src/core/vdom/helpers/is-async-placeholder.ts |    1 -
 src/core/vdom/helpers/merge-hook.ts           |    1 -
 src/core/vdom/helpers/normalize-children.ts   |    1 -
 .../vdom/helpers/normalize-scoped-slots.ts    |   62 +-
 .../vdom/helpers/resolve-async-component.ts   |    5 +-
 src/core/vdom/helpers/update-listeners.ts     |   44 +-
 src/core/vdom/modules/directives.ts           |    3 +-
 src/core/vdom/modules/ref.ts                  |   38 +-
 src/core/vdom/patch.ts                        |   21 +-
 src/core/vdom/vnode.ts                        |  140 +-
 src/global.d.ts                               |    2 +-
 src/platforms/web/compiler/directives/html.ts |    1 -
 .../web/compiler/directives/index.ts          |    2 +-
 .../web/compiler/directives/model.ts          |    1 -
 src/platforms/web/compiler/directives/text.ts |    1 -
 src/platforms/web/compiler/index.ts           |    1 -
 src/platforms/web/compiler/modules/class.ts   |    3 +-
 src/platforms/web/compiler/modules/model.ts   |   11 +-
 src/platforms/web/compiler/modules/style.ts   |    3 +-
 src/platforms/web/compiler/options.ts         |   16 +-
 src/platforms/web/compiler/util.ts            |    1 -
 src/platforms/web/entry-compiler.ts           |    1 -
 .../web/entry-runtime-with-compiler.ts        |    6 +-
 src/platforms/web/entry-runtime.ts            |    1 -
 .../web/entry-server-basic-renderer.ts        |    3 +-
 src/platforms/web/entry-server-renderer.ts    |    5 +-
 src/platforms/web/runtime/class-util.ts       |    5 +-
 src/platforms/web/runtime/components/index.ts |    2 +-
 .../runtime/components/transition-group.ts    |  172 +-
 .../web/runtime/components/transition.ts      |   18 +-
 src/platforms/web/runtime/directives/index.ts |    2 +-
 src/platforms/web/runtime/directives/model.ts |    6 +-
 src/platforms/web/runtime/directives/show.ts  |    4 +-
 src/platforms/web/runtime/modules/attrs.ts    |    7 +-
 src/platforms/web/runtime/modules/class.ts    |    3 +-
 .../web/runtime/modules/dom-props.ts          |    3 +-
 src/platforms/web/runtime/modules/events.ts   |    7 +-
 src/platforms/web/runtime/modules/style.ts    |    5 +-
 .../web/runtime/modules/transition.ts         |   17 +-
 src/platforms/web/runtime/node-ops.ts         |    1 -
 src/platforms/web/runtime/patch.ts            |    1 -
 src/platforms/web/runtime/transition-util.ts  |   10 +-
 src/platforms/web/server/compiler.ts          |    1 -
 src/platforms/web/server/directives/index.ts  |    2 +-
 src/platforms/web/server/directives/model.ts  |    1 -
 src/platforms/web/server/directives/show.ts   |    1 -
 src/platforms/web/server/modules/attrs.ts     |    3 +-
 src/platforms/web/server/modules/class.ts     |    1 -
 src/platforms/web/server/modules/dom-props.ts |    1 -
 src/platforms/web/server/modules/style.ts     |    1 -
 src/platforms/web/server/util.ts              |    7 +-
 src/platforms/web/util/attrs.ts               |    1 -
 src/platforms/web/util/class.ts               |    3 +-
 src/platforms/web/util/compat.ts              |    1 -
 src/platforms/web/util/element.ts             |    3 +-
 src/platforms/web/util/index.ts               |    1 -
 src/platforms/web/util/style.ts               |    1 -
 .../bundle-renderer/create-bundle-renderer.ts |   10 +-
 .../bundle-renderer/create-bundle-runner.ts   |   12 +-
 .../bundle-renderer/source-map-support.ts     |    7 +-
 src/server/create-basic-renderer.ts           |    5 +-
 src/server/create-renderer.ts                 |    8 +-
 src/server/optimizing-compiler/codegen.ts     |   15 +-
 src/server/optimizing-compiler/index.ts       |    3 +-
 src/server/optimizing-compiler/modules.ts     |   19 +-
 src/server/optimizing-compiler/optimizer.ts   |   11 +-
 .../optimizing-compiler/runtime-helpers.ts    |    5 +-
 src/server/render-context.ts                  |    5 +-
 src/server/render-stream.ts                   |    3 +-
 src/server/render.ts                          |   35 +-
 .../create-async-file-mapper.ts               |    5 +-
 src/server/template-renderer/index.ts         |    8 +-
 .../template-renderer/parse-template.ts       |    8 +-
 .../template-renderer/template-stream.ts      |    1 -
 src/server/util.ts                            |    1 -
 src/server/webpack-plugin/client.ts           |   68 +-
 src/server/webpack-plugin/server.ts           |   14 +-
 src/server/webpack-plugin/util.ts             |   15 +-
 src/server/write.ts                           |    5 +-
 src/sfc/parser.ts                             |    9 +-
 src/shared/constants.ts                       |    2 +-
 src/shared/util.ts                            |    6 +-
 test/e2e/.eslintrc.json                       |    5 -
 test/e2e/commits.mock.ts                      |  636 ++---
 test/e2e/commits.spec.ts                      |    2 +-
 test/e2e/e2eUtils.ts                          |   36 +-
 test/e2e/svg.spec.ts                          |    8 +-
 test/helpers/.eslintrc.json                   |    8 -
 test/helpers/test-object-option.ts            |    2 +-
 test/helpers/to-have-warned.ts                |   18 +-
 test/helpers/trigger-event.ts                 |    4 +-
 test/helpers/wait-for-update.ts               |    8 +-
 test/ssr/compile-with-webpack.ts              |    2 +-
 test/ssr/ssr-basic-renderer.spec.ts           |   92 +-
 test/ssr/ssr-bundle-render.spec.ts            |   16 +-
 test/ssr/ssr-stream.spec.ts                   |   97 +-
 test/ssr/ssr-string.spec.ts                   | 2512 ++++++++++-------
 test/ssr/ssr-template.spec.ts                 |   24 +-
 test/transition/helpers.ts                    |   10 +-
 test/transition/transition-group.spec.ts      |   42 +-
 test/transition/transition-mode.spec.ts       |   46 +-
 .../transition-with-keep-alive.spec.ts        |   38 +-
 test/transition/transition.spec.ts            |   96 +-
 test/unit/.eslintrc.json                      |    7 -
 .../component/component-async.spec.ts         |   46 +-
 .../component/component-keep-alive.spec.ts    |   40 +-
 .../component/component-scoped-slot.spec.ts   |  236 +-
 .../features/component/component-slot.spec.ts |  202 +-
 .../unit/features/component/component.spec.ts |  105 +-
 test/unit/features/debug.spec.ts              |    8 +-
 test/unit/features/directives/bind.spec.ts    |  144 +-
 test/unit/features/directives/class.spec.ts   |  159 +-
 test/unit/features/directives/for.spec.ts     |   42 +-
 test/unit/features/directives/html.spec.ts    |   79 +-
 test/unit/features/directives/if.spec.ts      |  241 +-
 .../directives/model-checkbox.spec.ts         |  229 +-
 .../directives/model-component.spec.ts        |   86 +-
 .../features/directives/model-dynamic.spec.ts |  110 +-
 .../features/directives/model-radio.spec.ts   |  139 +-
 .../features/directives/model-select.spec.ts  |  231 +-
 .../features/directives/model-text.spec.ts    |   84 +-
 test/unit/features/directives/on.spec.ts      |  260 +-
 test/unit/features/directives/once.spec.ts    |  154 +-
 test/unit/features/directives/show.spec.ts    |   69 +-
 .../directives/static-style-parser.spec.ts    |    3 +-
 test/unit/features/directives/style.spec.ts   |   44 +-
 test/unit/features/directives/text.spec.ts    |   79 +-
 test/unit/features/error-handling.spec.ts     |  222 +-
 test/unit/features/filter/filter.spec.ts      |    2 +-
 test/unit/features/global-api/config.spec.ts  |    6 +-
 test/unit/features/global-api/extend.spec.ts  |   20 +-
 test/unit/features/global-api/mixin.spec.ts   |   18 +-
 .../features/global-api/observable.spec.ts    |   16 +-
 .../features/global-api/set-delete.spec.ts    |  135 +-
 test/unit/features/instance/init.spec.ts      |    8 +-
 .../features/instance/methods-data.spec.ts    |   38 +-
 .../instance/methods-lifecycle.spec.ts        |   14 +-
 .../unit/features/instance/properties.spec.ts |   42 +-
 .../features/instance/render-proxy.spec.ts    |   22 +-
 test/unit/features/options/_scopeId.spec.ts   |   12 +-
 test/unit/features/options/comments.spec.ts   |    9 +-
 test/unit/features/options/components.spec.ts |    8 +-
 test/unit/features/options/computed.spec.ts   |   56 +-
 test/unit/features/options/data.spec.ts       |   24 +-
 test/unit/features/options/directives.spec.ts |   69 +-
 test/unit/features/options/el.spec.ts         |   15 +-
 .../features/options/errorCaptured.spec.ts    |  122 +-
 test/unit/features/options/extends.spec.ts    |    8 +-
 test/unit/features/options/functional.spec.ts |   83 +-
 test/unit/features/options/inject.spec.ts     |  114 +-
 test/unit/features/options/lifecycle.spec.ts  |   50 +-
 test/unit/features/options/methods.spec.ts    |   18 +-
 test/unit/features/options/mixins.spec.ts     |   32 +-
 test/unit/features/options/name.spec.ts       |   14 +-
 test/unit/features/options/parent.spec.ts     |    4 +-
 test/unit/features/options/props.spec.ts      |   72 +-
 test/unit/features/options/propsData.spec.ts  |    4 +-
 test/unit/features/options/render.spec.ts     |   13 +-
 .../unit/features/options/renderError.spec.ts |   10 +-
 test/unit/features/options/template.spec.ts   |   11 +-
 test/unit/features/options/watch.spec.ts      |   12 +-
 test/unit/features/ref.spec.ts                |   69 +-
 test/unit/modules/compiler/codeframe.spec.ts  |   24 +-
 test/unit/modules/compiler/codegen.spec.ts    |   30 +-
 .../modules/compiler/compiler-options.spec.ts |  120 +-
 test/unit/modules/compiler/optimizer.spec.ts  |  116 +-
 test/unit/modules/compiler/parser.spec.ts     |  469 ++-
 test/unit/modules/observer/observer.spec.ts   |   85 +-
 test/unit/modules/observer/scheduler.spec.ts  |   28 +-
 test/unit/modules/observer/watcher.spec.ts    |   86 +-
 .../server-compiler/compiler-options.spec.ts  |    7 +-
 test/unit/modules/sfc/sfc-parser.spec.ts      |   69 +-
 test/unit/modules/util/error.spec.ts          |   14 +-
 .../modules/vdom/create-component.spec.ts     |   22 +-
 test/unit/modules/vdom/create-element.spec.ts |   44 +-
 test/unit/modules/vdom/modules/attrs.spec.ts  |   34 +-
 test/unit/modules/vdom/modules/class.spec.ts  |    8 +-
 .../modules/vdom/modules/directive.spec.ts    |   46 +-
 .../modules/vdom/modules/dom-props.spec.ts    |   34 +-
 test/unit/modules/vdom/modules/events.spec.ts |   28 +-
 test/unit/modules/vdom/modules/style.spec.ts  |   16 +-
 test/unit/modules/vdom/patch/children.spec.ts |   76 +-
 .../modules/vdom/patch/edge-cases.spec.ts     |  160 +-
 test/unit/modules/vdom/patch/element.spec.ts  |    4 +-
 test/unit/modules/vdom/patch/hooks.spec.ts    |  132 +-
 .../unit/modules/vdom/patch/hydration.spec.ts |   94 +-
 261 files changed, 6858 insertions(+), 5809 deletions(-)
 delete mode 100644 .babelrc.js
 delete mode 100644 .eslintignore
 delete mode 100644 .eslintrc.js
 create mode 100644 .prettierrc
 delete mode 100644 examples/.eslintrc.json
 delete mode 100644 test/e2e/.eslintrc.json
 delete mode 100644 test/helpers/.eslintrc.json
 delete mode 100644 test/unit/.eslintrc.json

diff --git a/.babelrc.js b/.babelrc.js
deleted file mode 100644
index 4104dde65d5..00000000000
--- a/.babelrc.js
+++ /dev/null
@@ -1,13 +0,0 @@
-
-module.exports = {
-  presets: [
-    "@babel/preset-env",
-    "@babel/preset-typescript"
-  ],
-  plugins: [
-    require("babel-plugin-transform-vue-jsx"),
-    require("@babel/plugin-syntax-dynamic-import")
-  ],
-
-  ignore: ["dist/*.js", "packages/**/*.js"],
-};
diff --git a/.eslintignore b/.eslintignore
deleted file mode 100644
index 7bf90e20366..00000000000
--- a/.eslintignore
+++ /dev/null
@@ -1,3 +0,0 @@
-flow
-dist
-packages
diff --git a/.eslintrc.js b/.eslintrc.js
deleted file mode 100644
index c1e2b4d03e4..00000000000
--- a/.eslintrc.js
+++ /dev/null
@@ -1,39 +0,0 @@
-module.exports = {
-  root: true,
-  parser: "@typescript-eslint/parser",
-
-  parserOptions: {
-    // parser: "@typescript-eslint/parser",
-    // ecmaVersion: 2018,
-    sourceType: "module",
-  },
-  env: {
-    es6: true,
-    node: true,
-    browser: true,
-  },
-  // plugins: ["flowtype"],
-  extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/eslint-recommended",
-  ],
-  globals: {
-    __TEST__: true,
-    WXEnvironment: true,
-  },
-  rules: {
-    'no-unused-vars': [
-      'error',
-      // we are only using this rule to check for unused arguments since TS
-      // catches unused variables but not args.
-      { varsIgnorePattern: '.*', args: 'none' }
-    ],
-    'prefer-spread': 0,
-    'prefer-rest-params': 0,
-    'no-prototype-builtins': 0,
-    "no-console": process.env.NODE_ENV !== "production" ? 0 : 2,
-    "no-useless-escape": 0,
-    "no-empty": 0,
-    "no-extra-semi": 0
-  },
-};
diff --git a/.prettierrc b/.prettierrc
new file mode 100644
index 00000000000..ef93d94821a
--- /dev/null
+++ b/.prettierrc
@@ -0,0 +1,5 @@
+semi: false
+singleQuote: true
+printWidth: 80
+trailingComma: 'none'
+arrowParens: 'avoid'
diff --git a/examples/.eslintrc.json b/examples/.eslintrc.json
deleted file mode 100644
index f7a85281a36..00000000000
--- a/examples/.eslintrc.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "globals": {
-    "Vue": true,
-    "firebase": true
-  }
-}
diff --git a/package.json b/package.json
index 86aa61a70df..c4f37976cc2 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
     "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",
     "test:transition": "karma start test/transition/karma.conf.js",
     "test:types": "tsc -p ./types/tsconfig.json",
-    "lint": "eslint src scripts test",
+    "format": "prettier --write --parser typescript \"(src|test|packages)/**/*.ts\"",
     "ts-check": "tsc -p tsconfig.json --noEmit",
     "ts-check:test": "tsc -p test/tsconfig.json --noEmit",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
@@ -42,7 +42,10 @@
   },
   "lint-staged": {
     "*.js": [
-      "eslint --fix"
+      "prettier --write"
+    ],
+    "*.ts": [
+      "prettier --parser=typescript --write"
     ]
   },
   "repository": {
@@ -65,8 +68,6 @@
     "@rollup/plugin-replace": "^4.0.0",
     "@types/he": "^1.1.2",
     "@types/node": "^17.0.30",
-    "@typescript-eslint/eslint-plugin": "^5.21.0",
-    "@typescript-eslint/parser": "^5.21.0",
     "acorn": "^8.7.1",
     "acorn-walk": "^8.2.0",
     "chalk": "^4.0.0",
@@ -77,7 +78,6 @@
     "de-indent": "^1.0.2",
     "esbuild": "^0.14.39",
     "escodegen": "^2.0.0",
-    "eslint": "^8.14.0",
     "file-loader": "^3.0.1",
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
@@ -95,6 +95,7 @@
     "lru-cache": "^7.8.1",
     "marked": "^3.0.8",
     "memory-fs": "^0.5.0",
+    "prettier": "^2.6.2",
     "puppeteer": "^14.1.1",
     "resolve": "^1.22.0",
     "rollup": "^2.70.2",
diff --git a/packages/vue-server-renderer/client-plugin.d.ts b/packages/vue-server-renderer/client-plugin.d.ts
index 005c0f619e9..d0d639a6463 100644
--- a/packages/vue-server-renderer/client-plugin.d.ts
+++ b/packages/vue-server-renderer/client-plugin.d.ts
@@ -1,3 +1,3 @@
-import { WebpackPlugin } from './types/plugin';
-declare const Plugin: WebpackPlugin;
-export = Plugin;
+import { WebpackPlugin } from './types/plugin'
+declare const Plugin: WebpackPlugin
+export = Plugin
diff --git a/packages/vue-server-renderer/server-plugin.d.ts b/packages/vue-server-renderer/server-plugin.d.ts
index 005c0f619e9..d0d639a6463 100644
--- a/packages/vue-server-renderer/server-plugin.d.ts
+++ b/packages/vue-server-renderer/server-plugin.d.ts
@@ -1,3 +1,3 @@
-import { WebpackPlugin } from './types/plugin';
-declare const Plugin: WebpackPlugin;
-export = Plugin;
+import { WebpackPlugin } from './types/plugin'
+declare const Plugin: WebpackPlugin
+export = Plugin
diff --git a/packages/vue-server-renderer/types/index.d.ts b/packages/vue-server-renderer/types/index.d.ts
index e1ab698940b..6932cd1430f 100644
--- a/packages/vue-server-renderer/types/index.d.ts
+++ b/packages/vue-server-renderer/types/index.d.ts
@@ -1,50 +1,53 @@
-import Vue, { VNode, VNodeDirective } from 'vue';
-import { Readable } from 'stream';
+import Vue, { VNode, VNodeDirective } from 'vue'
+import { Readable } from 'stream'
 
-export declare function createRenderer(options?: RendererOptions): Renderer;
+export declare function createRenderer(options?: RendererOptions): Renderer
 
-export declare function createBundleRenderer(bundle: string | object, options?: BundleRendererOptions): BundleRenderer;
+export declare function createBundleRenderer(
+  bundle: string | object,
+  options?: BundleRendererOptions
+): BundleRenderer
 
-type RenderCallback = (err: Error | null, html: string) => void;
+type RenderCallback = (err: Error | null, html: string) => void
 
 interface Renderer {
-  renderToString(vm: Vue, callback: RenderCallback): void;
-  renderToString(vm: Vue, context: object, callback: RenderCallback): void;
-  renderToString(vm: Vue): Promise<string>;
-  renderToString(vm: Vue, context: object): Promise<string>;
+  renderToString(vm: Vue, callback: RenderCallback): void
+  renderToString(vm: Vue, context: object, callback: RenderCallback): void
+  renderToString(vm: Vue): Promise<string>
+  renderToString(vm: Vue, context: object): Promise<string>
 
-  renderToStream(vm: Vue, context?: object): Readable;
+  renderToStream(vm: Vue, context?: object): Readable
 }
 
 interface BundleRenderer {
-  renderToString(callback: RenderCallback): void;
-  renderToString(context: object, callback: RenderCallback): void;
-  renderToString(): Promise<string>;
-  renderToString(context: object): Promise<string>;
+  renderToString(callback: RenderCallback): void
+  renderToString(context: object, callback: RenderCallback): void
+  renderToString(): Promise<string>
+  renderToString(context: object): Promise<string>
 
-  renderToStream(context?: object): Readable;
+  renderToStream(context?: object): Readable
 }
 
 interface RendererOptions {
-  template?: string;
-  inject?: boolean;
-  shouldPreload?: (file: string, type: string) => boolean;
-  shouldPrefetch?: (file: string, type: string) => boolean;
-  cache?: RenderCache;
+  template?: string
+  inject?: boolean
+  shouldPreload?: (file: string, type: string) => boolean
+  shouldPrefetch?: (file: string, type: string) => boolean
+  cache?: RenderCache
   directives?: {
     [key: string]: (vnode: VNode, dir: VNodeDirective) => void
-  };
+  }
 }
 
 interface BundleRendererOptions extends RendererOptions {
-  clientManifest?: object;
-  serializer?: (state: object) => string;
-  runInNewContext?: boolean | 'once';
-  basedir?: string;
+  clientManifest?: object
+  serializer?: (state: object) => string
+  runInNewContext?: boolean | 'once'
+  basedir?: string
 }
 
 interface RenderCache {
-  get: (key: string, cb?: (res: string) => void) => string | void;
-  set: (key: string, val: string) => void;
-  has?: (key: string, cb?: (hit: boolean) => void) => boolean | void;
+  get: (key: string, cb?: (res: string) => void) => string | void
+  set: (key: string, val: string) => void
+  has?: (key: string, cb?: (hit: boolean) => void) => boolean | void
 }
diff --git a/packages/vue-server-renderer/types/plugin.d.ts b/packages/vue-server-renderer/types/plugin.d.ts
index 89d03c8da7e..423a58b4d81 100644
--- a/packages/vue-server-renderer/types/plugin.d.ts
+++ b/packages/vue-server-renderer/types/plugin.d.ts
@@ -1,11 +1,11 @@
-import { DefinePlugin } from 'webpack';
+import { DefinePlugin } from 'webpack'
 
 interface WebpackPluginOptions {
-  filename?: string;
+  filename?: string
 }
 
 export interface WebpackPlugin {
   // NOTE NOT SURE ABOUT THIS
   // TODO DOUBLE CHECK HERE
-  new (options?: WebpackPluginOptions): DefinePlugin;
+  new (options?: WebpackPluginOptions): DefinePlugin
 }
diff --git a/packages/vue-template-compiler/types/index.d.ts b/packages/vue-template-compiler/types/index.d.ts
index e2b603f025b..92476a49e5a 100644
--- a/packages/vue-template-compiler/types/index.d.ts
+++ b/packages/vue-template-compiler/types/index.d.ts
@@ -1,13 +1,13 @@
-import Vue, { VNode } from "vue"
+import Vue, { VNode } from 'vue'
 
 /*
  * Template compilation options / results
  */
 interface CompilerOptions {
-  modules?: ModuleOptions[];
-  directives?: Record<string, DirectiveFunction>;
-  preserveWhitespace?: boolean;
-  whitespace?: 'preserve' | 'condense';
+  modules?: ModuleOptions[]
+  directives?: Record<string, DirectiveFunction>
+  preserveWhitespace?: boolean
+  whitespace?: 'preserve' | 'condense'
   outputSourceRange?: any
 }
 
@@ -16,34 +16,34 @@ interface CompilerOptionsWithSourceRange extends CompilerOptions {
 }
 
 interface ErrorWithRange {
-  msg: string;
-  start: number;
-  end: number;
+  msg: string
+  start: number
+  end: number
 }
 
 interface CompiledResult<ErrorType> {
-  ast: ASTElement | undefined;
-  render: string;
-  staticRenderFns: string[];
-  errors: ErrorType[];
-  tips: ErrorType[];
+  ast: ASTElement | undefined
+  render: string
+  staticRenderFns: string[]
+  errors: ErrorType[]
+  tips: ErrorType[]
 }
 
 interface CompiledResultFunctions {
-  render: () => VNode;
-  staticRenderFns: (() => VNode)[];
+  render: () => VNode
+  staticRenderFns: (() => VNode)[]
 }
 
 interface ModuleOptions {
-  preTransformNode: (el: ASTElement) => ASTElement | undefined;
-  transformNode: (el: ASTElement) => ASTElement | undefined;
-  postTransformNode: (el: ASTElement) => void;
-  genData: (el: ASTElement) => string;
-  transformCode?: (el: ASTElement, code: string) => string;
-  staticKeys?: string[];
+  preTransformNode: (el: ASTElement) => ASTElement | undefined
+  transformNode: (el: ASTElement) => ASTElement | undefined
+  postTransformNode: (el: ASTElement) => void
+  genData: (el: ASTElement) => string
+  transformCode?: (el: ASTElement, code: string) => string
+  staticKeys?: string[]
 }
 
-type DirectiveFunction = (node: ASTElement, directiveMeta: ASTDirective) => void;
+type DirectiveFunction = (node: ASTElement, directiveMeta: ASTDirective) => void
 
 /*
  * AST Types
@@ -59,153 +59,153 @@ type DirectiveFunction = (node: ASTElement, directiveMeta: ASTDirective) => void
 export type SSROptimizability = 0 | 1 | 2 | 3 | 4
 
 export interface ASTModifiers {
-  [key: string]: boolean;
+  [key: string]: boolean
 }
 
 export interface ASTIfCondition {
-  exp: string | undefined;
-  block: ASTElement;
+  exp: string | undefined
+  block: ASTElement
 }
 
 export interface ASTElementHandler {
-  value: string;
-  params?: any[];
-  modifiers: ASTModifiers | undefined;
+  value: string
+  params?: any[]
+  modifiers: ASTModifiers | undefined
 }
 
 export interface ASTElementHandlers {
-  [key: string]: ASTElementHandler | ASTElementHandler[];
+  [key: string]: ASTElementHandler | ASTElementHandler[]
 }
 
 export interface ASTDirective {
-  name: string;
-  rawName: string;
-  value: string;
-  arg: string | undefined;
-  modifiers: ASTModifiers | undefined;
+  name: string
+  rawName: string
+  value: string
+  arg: string | undefined
+  modifiers: ASTModifiers | undefined
 }
 
-export type ASTNode = ASTElement | ASTText | ASTExpression;
+export type ASTNode = ASTElement | ASTText | ASTExpression
 
 export interface ASTElement {
-  type: 1;
-  tag: string;
-  attrsList: { name: string; value: any }[];
-  attrsMap: Record<string, any>;
-  parent: ASTElement | undefined;
-  children: ASTNode[];
-
-  processed?: true;
-
-  static?: boolean;
-  staticRoot?: boolean;
-  staticInFor?: boolean;
-  staticProcessed?: boolean;
-  hasBindings?: boolean;
-
-  text?: string;
-  attrs?: { name: string; value: any }[];
-  props?: { name: string; value: string }[];
-  plain?: boolean;
-  pre?: true;
-  ns?: string;
-
-  component?: string;
-  inlineTemplate?: true;
-  transitionMode?: string | null;
-  slotName?: string;
-  slotTarget?: string;
-  slotScope?: string;
-  scopedSlots?: Record<string, ASTElement>;
-
-  ref?: string;
-  refInFor?: boolean;
-
-  if?: string;
-  ifProcessed?: boolean;
-  elseif?: string;
-  else?: true;
-  ifConditions?: ASTIfCondition[];
-
-  for?: string;
-  forProcessed?: boolean;
-  key?: string;
-  alias?: string;
-  iterator1?: string;
-  iterator2?: string;
-
-  staticClass?: string;
-  classBinding?: string;
-  staticStyle?: string;
-  styleBinding?: string;
-  events?: ASTElementHandlers;
-  nativeEvents?: ASTElementHandlers;
-
-  transition?: string | true;
-  transitionOnAppear?: boolean;
+  type: 1
+  tag: string
+  attrsList: { name: string; value: any }[]
+  attrsMap: Record<string, any>
+  parent: ASTElement | undefined
+  children: ASTNode[]
+
+  processed?: true
+
+  static?: boolean
+  staticRoot?: boolean
+  staticInFor?: boolean
+  staticProcessed?: boolean
+  hasBindings?: boolean
+
+  text?: string
+  attrs?: { name: string; value: any }[]
+  props?: { name: string; value: string }[]
+  plain?: boolean
+  pre?: true
+  ns?: string
+
+  component?: string
+  inlineTemplate?: true
+  transitionMode?: string | null
+  slotName?: string
+  slotTarget?: string
+  slotScope?: string
+  scopedSlots?: Record<string, ASTElement>
+
+  ref?: string
+  refInFor?: boolean
+
+  if?: string
+  ifProcessed?: boolean
+  elseif?: string
+  else?: true
+  ifConditions?: ASTIfCondition[]
+
+  for?: string
+  forProcessed?: boolean
+  key?: string
+  alias?: string
+  iterator1?: string
+  iterator2?: string
+
+  staticClass?: string
+  classBinding?: string
+  staticStyle?: string
+  styleBinding?: string
+  events?: ASTElementHandlers
+  nativeEvents?: ASTElementHandlers
+
+  transition?: string | true
+  transitionOnAppear?: boolean
 
   model?: {
-    value: string;
-    callback: string;
-    expression: string;
-  };
+    value: string
+    callback: string
+    expression: string
+  }
 
-  directives?: ASTDirective[];
+  directives?: ASTDirective[]
 
-  forbidden?: true;
-  once?: true;
-  onceProcessed?: boolean;
-  wrapData?: (code: string) => string;
-  wrapListeners?: (code: string) => string;
+  forbidden?: true
+  once?: true
+  onceProcessed?: boolean
+  wrapData?: (code: string) => string
+  wrapListeners?: (code: string) => string
 
   // 2.4 ssr optimization
-  ssrOptimizability?: SSROptimizability;
+  ssrOptimizability?: SSROptimizability
 }
 
 export interface ASTExpression {
-  type: 2;
-  expression: string;
-  text: string;
-  tokens: (string | Record<string, any>)[];
-  static?: boolean;
+  type: 2
+  expression: string
+  text: string
+  tokens: (string | Record<string, any>)[]
+  static?: boolean
   // 2.4 ssr optimization
-  ssrOptimizability?: SSROptimizability;
+  ssrOptimizability?: SSROptimizability
 }
 
 export interface ASTText {
-  type: 3;
-  text: string;
-  static?: boolean;
-  isComment?: boolean;
+  type: 3
+  text: string
+  static?: boolean
+  isComment?: boolean
   // 2.4 ssr optimization
-  ssrOptimizability?: SSROptimizability;
+  ssrOptimizability?: SSROptimizability
 }
 
 /*
  * SFC parser related types
  */
 interface SFCParserOptions {
-  pad?: true | 'line' | 'space';
+  pad?: true | 'line' | 'space'
   deindent?: boolean
 }
 
 export interface SFCBlock {
-  type: string;
-  content: string;
-  attrs: Record<string, string>;
-  start?: number;
-  end?: number;
-  lang?: string;
-  src?: string;
-  scoped?: boolean;
-  module?: string | boolean;
+  type: string
+  content: string
+  attrs: Record<string, string>
+  start?: number
+  end?: number
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
 }
 
 export interface SFCDescriptor {
-  template: SFCBlock | undefined;
-  script: SFCBlock | undefined;
-  styles: SFCBlock[];
-  customBlocks: SFCBlock[];
+  template: SFCBlock | undefined
+  script: SFCBlock | undefined
+  styles: SFCBlock[]
+  customBlocks: SFCBlock[]
 }
 
 /*
@@ -219,29 +219,29 @@ export function compile(
 export function compile(
   template: string,
   options?: CompilerOptions
-): CompiledResult<string>;
+): CompiledResult<string>
 
-export function compileToFunctions(template: string): CompiledResultFunctions;
+export function compileToFunctions(template: string): CompiledResultFunctions
 
 export function ssrCompile(
   template: string,
   options: CompilerOptionsWithSourceRange
-): CompiledResult<ErrorWithRange>;
+): CompiledResult<ErrorWithRange>
 
 export function ssrCompile(
   template: string,
   options?: CompilerOptions
-): CompiledResult<string>;
+): CompiledResult<string>
 
-export function ssrCompileToFunctions(template: string): CompiledResultFunctions;
+export function ssrCompileToFunctions(template: string): CompiledResultFunctions
 
 export function parseComponent(
   file: string,
   options?: SFCParserOptions
-): SFCDescriptor;
+): SFCDescriptor
 
 export function generateCodeFrame(
   template: string,
   start: number,
   end: number
-): string;
+): string
diff --git a/packages/vue-template-compiler/types/test.ts b/packages/vue-template-compiler/types/test.ts
index b0e6cb1549f..3b8484481c7 100644
--- a/packages/vue-template-compiler/types/test.ts
+++ b/packages/vue-template-compiler/types/test.ts
@@ -1,4 +1,4 @@
-import Vue, { VNode } from "vue";
+import Vue, { VNode } from 'vue'
 import {
   compile,
   compileToFunctions,
@@ -6,10 +6,10 @@ import {
   ssrCompileToFunctions,
   parseComponent,
   generateCodeFrame
-} from "./";
+} from './'
 
 // check compile options
-const compiled = compile("<div>hi</div>", {
+const compiled = compile('<div>hi</div>', {
   outputSourceRange: true,
   preserveWhitespace: false,
   whitespace: 'condense',
@@ -18,24 +18,24 @@ const compiled = compile("<div>hi</div>", {
       preTransformNode: el => el,
       transformNode: el => el,
       postTransformNode: el => {
-        el.tag = "p";
+        el.tag = 'p'
       },
       genData: el => el.tag,
       transformCode: (el, code) => code,
-      staticKeys: ["test"]
+      staticKeys: ['test']
     }
   ],
   directives: {
     test: (node, directiveMeta) => {
-      node.tag;
-      directiveMeta.value;
+      node.tag
+      directiveMeta.value
     }
   }
-});
+})
 
 // can be passed to function constructor
-new Function(compiled.render);
-compiled.staticRenderFns.map(fn => new Function(fn));
+new Function(compiled.render)
+compiled.staticRenderFns.map(fn => new Function(fn))
 
 // with outputSourceRange: true
 // errors should be objects with range
@@ -61,30 +61,30 @@ errors3.forEach(e => {
   console.log(e.length)
 })
 
-const compiledFns = compileToFunctions("<div>hi</div>");
+const compiledFns = compileToFunctions('<div>hi</div>')
 
 // can be passed to component render / staticRenderFns options
 const vm = new Vue({
   data() {
     return {
-      test: "Test"
-    };
+      test: 'Test'
+    }
   },
   render: compiledFns.render,
   staticRenderFns: compiledFns.staticRenderFns
-});
+})
 
 // can be called with component instance
-const vnode: VNode = compiledFns.render.call(vm);
+const vnode: VNode = compiledFns.render.call(vm)
 
 // check SFC parser
-const desc = parseComponent("<template></template>", {
-  pad: "space",
+const desc = parseComponent('<template></template>', {
+  pad: 'space',
   deindent: false
-});
+})
 
-const templateContent: string = desc.template!.content;
-const scriptContent: string = desc.script!.content;
-const styleContent: string = desc.styles.map(s => s.content).join("\n");
+const templateContent: string = desc.template!.content
+const scriptContent: string = desc.script!.content
+const styleContent: string = desc.styles.map(s => s.content).join('\n')
 
 const codeframe: string = generateCodeFrame(`foobar`, 0, 4)
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 19c27af9e0b..a0f328bffa4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -7,8 +7,6 @@ specifiers:
   '@rollup/plugin-replace': ^4.0.0
   '@types/he': ^1.1.2
   '@types/node': ^17.0.30
-  '@typescript-eslint/eslint-plugin': ^5.21.0
-  '@typescript-eslint/parser': ^5.21.0
   acorn: ^8.7.1
   acorn-walk: ^8.2.0
   chalk: ^4.0.0
@@ -19,7 +17,6 @@ specifiers:
   de-indent: ^1.0.2
   esbuild: ^0.14.39
   escodegen: ^2.0.0
-  eslint: ^8.14.0
   file-loader: ^3.0.1
   hash-sum: ^2.0.0
   he: ^1.2.0
@@ -37,6 +34,7 @@ specifiers:
   lru-cache: ^7.8.1
   marked: ^3.0.8
   memory-fs: ^0.5.0
+  prettier: ^2.6.2
   puppeteer: ^14.1.1
   resolve: ^1.22.0
   rollup: ^2.70.2
@@ -60,8 +58,6 @@ devDependencies:
   '@rollup/plugin-replace': 4.0.0_rollup@2.74.0
   '@types/he': 1.1.2
   '@types/node': 17.0.34
-  '@typescript-eslint/eslint-plugin': 5.25.0_qo2hgs5jt7x2a3p77h2rutcdae
-  '@typescript-eslint/parser': 5.25.0_hcfsmds2fshutdssjqluwm76uu
   acorn: 8.7.1
   acorn-walk: 8.2.0
   chalk: 4.1.2
@@ -72,7 +68,6 @@ devDependencies:
   de-indent: 1.0.2
   esbuild: 0.14.39
   escodegen: 2.0.0
-  eslint: 8.15.0
   file-loader: 3.0.1_webpack@4.46.0
   hash-sum: 2.0.0
   he: 1.2.0
@@ -90,6 +85,7 @@ devDependencies:
   lru-cache: 7.10.1
   marked: 3.0.8
   memory-fs: 0.5.0
+  prettier: 2.6.2
   puppeteer: 14.1.1
   resolve: 1.22.0
   rollup: 2.74.0
@@ -204,64 +200,11 @@ packages:
       '@cspotcode/source-map-consumer': 0.8.0
     dev: true
 
-  /@eslint/eslintrc/1.2.3:
-    resolution: {integrity: sha512-uGo44hIwoLGNyduRpjdEpovcbMdd+Nv7amtmJxnKmI8xj6yd5LncmSwDa5NgX/41lIFJtkjD6YdVfgEzPfJ5UA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      ajv: 6.12.6
-      debug: 4.3.4
-      espree: 9.3.2
-      globals: 13.15.0
-      ignore: 5.2.0
-      import-fresh: 3.3.0
-      js-yaml: 4.1.0
-      minimatch: 3.1.2
-      strip-json-comments: 3.1.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@humanwhocodes/config-array/0.9.5:
-    resolution: {integrity: sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw==}
-    engines: {node: '>=10.10.0'}
-    dependencies:
-      '@humanwhocodes/object-schema': 1.2.1
-      debug: 4.3.4
-      minimatch: 3.1.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@humanwhocodes/object-schema/1.2.1:
-    resolution: {integrity: sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==}
-    dev: true
-
   /@hutson/parse-repository-url/3.0.2:
     resolution: {integrity: sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==}
     engines: {node: '>=6.9.0'}
     dev: true
 
-  /@nodelib/fs.scandir/2.1.5:
-    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
-    engines: {node: '>= 8'}
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      run-parallel: 1.2.0
-    dev: true
-
-  /@nodelib/fs.stat/2.0.5:
-    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
-    engines: {node: '>= 8'}
-    dev: true
-
-  /@nodelib/fs.walk/1.2.8:
-    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
-    engines: {node: '>= 8'}
-    dependencies:
-      '@nodelib/fs.scandir': 2.1.5
-      fastq: 1.13.0
-    dev: true
-
   /@rollup/plugin-alias/3.1.9_rollup@2.74.0:
     resolution: {integrity: sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==}
     engines: {node: '>=8.0.0'}
@@ -388,10 +331,6 @@ packages:
     resolution: {integrity: sha512-kSJPcLO1x+oolc0R89pUl2kozldQ/fVQ1C1p5mp8fPoLdF/ZcBvckaTC2M8xXh3GYendXvCpy5m/a2eSbfgNgw==}
     dev: true
 
-  /@types/json-schema/7.0.11:
-    resolution: {integrity: sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==}
-    dev: true
-
   /@types/minimist/1.2.2:
     resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==}
     dev: true
@@ -423,132 +362,6 @@ packages:
     dev: true
     optional: true
 
-  /@typescript-eslint/eslint-plugin/5.25.0_qo2hgs5jt7x2a3p77h2rutcdae:
-    resolution: {integrity: sha512-icYrFnUzvm+LhW0QeJNKkezBu6tJs9p/53dpPLFH8zoM9w1tfaKzVurkPotEpAqQ8Vf8uaFyL5jHd0Vs6Z0ZQg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      '@typescript-eslint/parser': ^5.0.0
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/parser': 5.25.0_hcfsmds2fshutdssjqluwm76uu
-      '@typescript-eslint/scope-manager': 5.25.0
-      '@typescript-eslint/type-utils': 5.25.0_hcfsmds2fshutdssjqluwm76uu
-      '@typescript-eslint/utils': 5.25.0_hcfsmds2fshutdssjqluwm76uu
-      debug: 4.3.4
-      eslint: 8.15.0
-      functional-red-black-tree: 1.0.1
-      ignore: 5.2.0
-      regexpp: 3.2.0
-      semver: 7.3.7
-      tsutils: 3.21.0_typescript@4.6.4
-      typescript: 4.6.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/parser/5.25.0_hcfsmds2fshutdssjqluwm76uu:
-    resolution: {integrity: sha512-r3hwrOWYbNKP1nTcIw/aZoH+8bBnh/Lh1iDHoFpyG4DnCpvEdctrSl6LOo19fZbzypjQMHdajolxs6VpYoChgA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/scope-manager': 5.25.0
-      '@typescript-eslint/types': 5.25.0
-      '@typescript-eslint/typescript-estree': 5.25.0_typescript@4.6.4
-      debug: 4.3.4
-      eslint: 8.15.0
-      typescript: 4.6.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/scope-manager/5.25.0:
-    resolution: {integrity: sha512-p4SKTFWj+2VpreUZ5xMQsBMDdQ9XdRvODKXN4EksyBjFp2YvQdLkyHqOffakYZPuWJUDNu3jVXtHALDyTv3cww==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.25.0
-      '@typescript-eslint/visitor-keys': 5.25.0
-    dev: true
-
-  /@typescript-eslint/type-utils/5.25.0_hcfsmds2fshutdssjqluwm76uu:
-    resolution: {integrity: sha512-B6nb3GK3Gv1Rsb2pqalebe/RyQoyG/WDy9yhj8EE0Ikds4Xa8RR28nHz+wlt4tMZk5bnAr0f3oC8TuDAd5CPrw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: '*'
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/utils': 5.25.0_hcfsmds2fshutdssjqluwm76uu
-      debug: 4.3.4
-      eslint: 8.15.0
-      tsutils: 3.21.0_typescript@4.6.4
-      typescript: 4.6.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/types/5.25.0:
-    resolution: {integrity: sha512-7fWqfxr0KNHj75PFqlGX24gWjdV/FDBABXL5dyvBOWHpACGyveok8Uj4ipPX/1fGU63fBkzSIycEje4XsOxUFA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dev: true
-
-  /@typescript-eslint/typescript-estree/5.25.0_typescript@4.6.4:
-    resolution: {integrity: sha512-MrPODKDych/oWs/71LCnuO7NyR681HuBly2uLnX3r5i4ME7q/yBqC4hW33kmxtuauLTM0OuBOhhkFaxCCOjEEw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/types': 5.25.0
-      '@typescript-eslint/visitor-keys': 5.25.0
-      debug: 4.3.4
-      globby: 11.1.0
-      is-glob: 4.0.3
-      semver: 7.3.7
-      tsutils: 3.21.0_typescript@4.6.4
-      typescript: 4.6.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/utils/5.25.0_hcfsmds2fshutdssjqluwm76uu:
-    resolution: {integrity: sha512-qNC9bhnz/n9Kba3yI6HQgQdBLuxDoMgdjzdhSInZh6NaDnFpTUlwNGxplUFWfY260Ya0TRPvkg9dd57qxrJI9g==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-    dependencies:
-      '@types/json-schema': 7.0.11
-      '@typescript-eslint/scope-manager': 5.25.0
-      '@typescript-eslint/types': 5.25.0
-      '@typescript-eslint/typescript-estree': 5.25.0_typescript@4.6.4
-      eslint: 8.15.0
-      eslint-scope: 5.1.1
-      eslint-utils: 3.0.0_eslint@8.15.0
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-    dev: true
-
-  /@typescript-eslint/visitor-keys/5.25.0:
-    resolution: {integrity: sha512-yd26vFgMsC4h2dgX4+LR+GeicSKIfUvZREFLf3DDjZPtqgLx5AJZr6TetMNwFP9hcKreTTeztQYBTNbNoOycwA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.25.0
-      eslint-visitor-keys: 3.3.0
-    dev: true
-
   /@webassemblyjs/ast/1.9.0:
     resolution: {integrity: sha512-C6wW5L+b7ogSDVqymbkkvuW9kruN//YisMED04xzeBBqjHa2FYnmvOlS6Xj68xWQRgWvI9cIglsjFowH/RJyEA==}
     dependencies:
@@ -719,14 +532,6 @@ packages:
       acorn-walk: 7.2.0
     dev: true
 
-  /acorn-jsx/5.3.2_acorn@8.7.1:
-    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
-    peerDependencies:
-      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
-    dependencies:
-      acorn: 8.7.1
-    dev: true
-
   /acorn-walk/7.2.0:
     resolution: {integrity: sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==}
     engines: {node: '>=0.4.0'}
@@ -878,10 +683,6 @@ packages:
     resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
     dev: true
 
-  /argparse/2.0.1:
-    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
-    dev: true
-
   /arr-diff/4.0.0:
     resolution: {integrity: sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA==}
     engines: {node: '>=0.10.0'}
@@ -901,11 +702,6 @@ packages:
     resolution: {integrity: sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng==}
     dev: true
 
-  /array-union/2.1.0:
-    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
-    engines: {node: '>=8'}
-    dev: true
-
   /array-unique/0.3.2:
     resolution: {integrity: sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ==}
     engines: {node: '>=0.10.0'}
@@ -1236,6 +1032,7 @@ packages:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
     dev: true
+    optional: true
 
   /camelcase-keys/6.2.2:
     resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==}
@@ -2053,20 +1850,6 @@ packages:
       randombytes: 2.1.0
     dev: true
 
-  /dir-glob/3.0.1:
-    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
-    engines: {node: '>=8'}
-    dependencies:
-      path-type: 4.0.0
-    dev: true
-
-  /doctrine/3.0.0:
-    resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      esutils: 2.0.3
-    dev: true
-
   /dom-serialize/2.2.1:
     resolution: {integrity: sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=}
     dependencies:
@@ -2421,11 +2204,6 @@ packages:
     engines: {node: '>=0.8.0'}
     dev: true
 
-  /escape-string-regexp/4.0.0:
-    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
-    engines: {node: '>=10'}
-    dev: true
-
   /escodegen/2.0.0:
     resolution: {integrity: sha512-mmHKys/C8BFUGI+MAWNcSYoORYLMdPzjrknd2Vc+bUsjN5bXcr8EhrNB+UTqfL1y3I9c4fw2ihgtMPQLBRiQxw==}
     engines: {node: '>=6.0'}
@@ -2447,108 +2225,12 @@ packages:
       estraverse: 4.3.0
     dev: true
 
-  /eslint-scope/5.1.1:
-    resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==}
-    engines: {node: '>=8.0.0'}
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 4.3.0
-    dev: true
-
-  /eslint-scope/7.1.1:
-    resolution: {integrity: sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 5.3.0
-    dev: true
-
-  /eslint-utils/3.0.0_eslint@8.15.0:
-    resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==}
-    engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0}
-    peerDependencies:
-      eslint: '>=5'
-    dependencies:
-      eslint: 8.15.0
-      eslint-visitor-keys: 2.1.0
-    dev: true
-
-  /eslint-visitor-keys/2.1.0:
-    resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /eslint-visitor-keys/3.3.0:
-    resolution: {integrity: sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dev: true
-
-  /eslint/8.15.0:
-    resolution: {integrity: sha512-GG5USZ1jhCu8HJkzGgeK8/+RGnHaNYZGrGDzUtigK3BsGESW/rs2az23XqE0WVwDxy1VRvvjSSGu5nB0Bu+6SA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    hasBin: true
-    dependencies:
-      '@eslint/eslintrc': 1.2.3
-      '@humanwhocodes/config-array': 0.9.5
-      ajv: 6.12.6
-      chalk: 4.1.2
-      cross-spawn: 7.0.3
-      debug: 4.3.4
-      doctrine: 3.0.0
-      escape-string-regexp: 4.0.0
-      eslint-scope: 7.1.1
-      eslint-utils: 3.0.0_eslint@8.15.0
-      eslint-visitor-keys: 3.3.0
-      espree: 9.3.2
-      esquery: 1.4.0
-      esutils: 2.0.3
-      fast-deep-equal: 3.1.3
-      file-entry-cache: 6.0.1
-      functional-red-black-tree: 1.0.1
-      glob-parent: 6.0.2
-      globals: 13.15.0
-      ignore: 5.2.0
-      import-fresh: 3.3.0
-      imurmurhash: 0.1.4
-      is-glob: 4.0.3
-      js-yaml: 4.1.0
-      json-stable-stringify-without-jsonify: 1.0.1
-      levn: 0.4.1
-      lodash.merge: 4.6.2
-      minimatch: 3.1.2
-      natural-compare: 1.4.0
-      optionator: 0.9.1
-      regexpp: 3.2.0
-      strip-ansi: 6.0.1
-      strip-json-comments: 3.1.1
-      text-table: 0.2.0
-      v8-compile-cache: 2.3.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /espree/9.3.2:
-    resolution: {integrity: sha512-D211tC7ZwouTIuY5x9XnS0E9sWNChB7IYKX/Xp5eQj3nFXhqmiUDB9q27y76oFl8jTg3pXcQx/bpxMfs3CIZbA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      acorn: 8.7.1
-      acorn-jsx: 5.3.2_acorn@8.7.1
-      eslint-visitor-keys: 3.3.0
-    dev: true
-
   /esprima/4.0.1:
     resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
     engines: {node: '>=4'}
     hasBin: true
     dev: true
 
-  /esquery/1.4.0:
-    resolution: {integrity: sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w==}
-    engines: {node: '>=0.10'}
-    dependencies:
-      estraverse: 5.3.0
-    dev: true
-
   /esrecurse/4.3.0:
     resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
     engines: {node: '>=4.0'}
@@ -2707,17 +2389,6 @@ packages:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
     dev: true
 
-  /fast-glob/3.2.11:
-    resolution: {integrity: sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew==}
-    engines: {node: '>=8.6.0'}
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      '@nodelib/fs.walk': 1.2.8
-      glob-parent: 5.1.2
-      merge2: 1.4.1
-      micromatch: 4.0.5
-    dev: true
-
   /fast-json-stable-stringify/2.1.0:
     resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
     dev: true
@@ -2726,12 +2397,6 @@ packages:
     resolution: {integrity: sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=}
     dev: true
 
-  /fastq/1.13.0:
-    resolution: {integrity: sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw==}
-    dependencies:
-      reusify: 1.0.4
-    dev: true
-
   /fd-slicer/1.1.0:
     resolution: {integrity: sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=}
     dependencies:
@@ -2749,13 +2414,6 @@ packages:
       escape-string-regexp: 1.0.5
     dev: true
 
-  /file-entry-cache/6.0.1:
-    resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    dependencies:
-      flat-cache: 3.0.4
-    dev: true
-
   /file-loader/3.0.1_webpack@4.46.0:
     resolution: {integrity: sha512-4sNIOXgtH/9WZq4NvlfU3Opn5ynUsqBwSLyM+I7UOwdGigTBYfVVQEwe/msZNX/j4pCJTIM14Fsw66Svo1oVrw==}
     engines: {node: '>= 6.9.0'}
@@ -2873,14 +2531,6 @@ packages:
       resolve-dir: 1.0.1
     dev: true
 
-  /flat-cache/3.0.4:
-    resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    dependencies:
-      flatted: 3.2.5
-      rimraf: 3.0.2
-    dev: true
-
   /flatted/3.2.5:
     resolution: {integrity: sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==}
     dev: true
@@ -2988,10 +2638,6 @@ packages:
     resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==}
     dev: true
 
-  /functional-red-black-tree/1.0.1:
-    resolution: {integrity: sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=}
-    dev: true
-
   /get-caller-file/2.0.5:
     resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
     engines: {node: 6.* || 8.* || >= 10.*}
@@ -3092,13 +2738,6 @@ packages:
       is-glob: 4.0.3
     dev: true
 
-  /glob-parent/6.0.2:
-    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
-    engines: {node: '>=10.13.0'}
-    dependencies:
-      is-glob: 4.0.3
-    dev: true
-
   /glob/7.1.4:
     resolution: {integrity: sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==}
     dependencies:
@@ -3149,25 +2788,6 @@ packages:
       which: 1.3.1
     dev: true
 
-  /globals/13.15.0:
-    resolution: {integrity: sha512-bpzcOlgDhMG070Av0Vy5Owklpv1I6+j96GhUI7Rh7IzDCKLzboflLrrfqMu8NquDbiR4EOQk7XzJwqVJxicxog==}
-    engines: {node: '>=8'}
-    dependencies:
-      type-fest: 0.20.2
-    dev: true
-
-  /globby/11.1.0:
-    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
-    engines: {node: '>=10'}
-    dependencies:
-      array-union: 2.1.0
-      dir-glob: 3.0.1
-      fast-glob: 3.2.11
-      ignore: 5.2.0
-      merge2: 1.4.1
-      slash: 3.0.0
-    dev: true
-
   /graceful-fs/4.2.10:
     resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==}
     dev: true
@@ -3375,11 +2995,6 @@ packages:
     resolution: {integrity: sha1-xg7taebY/bazEEofy8ocGS3FtQE=}
     dev: true
 
-  /ignore/5.2.0:
-    resolution: {integrity: sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ==}
-    engines: {node: '>= 4'}
-    dev: true
-
   /import-fresh/3.3.0:
     resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==}
     engines: {node: '>=6'}
@@ -3387,6 +3002,7 @@ packages:
       parent-module: 1.0.1
       resolve-from: 4.0.0
     dev: true
+    optional: true
 
   /imurmurhash/0.1.4:
     resolution: {integrity: sha1-khi5srkoojixPcT7a21XbyMUU+o=}
@@ -3692,13 +3308,6 @@ packages:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
     dev: true
 
-  /js-yaml/4.1.0:
-    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
-    hasBin: true
-    dependencies:
-      argparse: 2.0.1
-    dev: true
-
   /jsdom/19.0.0:
     resolution: {integrity: sha512-RYAyjCbxy/vri/CfnjUWJQQtZ3LKlLnDqj+9XLNnJPgEGeirZs3hllKR20re8LUZ6o1b1X4Jat+Qd26zmP41+A==}
     engines: {node: '>=12'}
@@ -3753,10 +3362,6 @@ packages:
     resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
     dev: true
 
-  /json-stable-stringify-without-jsonify/1.0.1:
-    resolution: {integrity: sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=}
-    dev: true
-
   /json-stringify-safe/5.0.1:
     resolution: {integrity: sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=}
     dev: true
@@ -3889,14 +3494,6 @@ packages:
       type-check: 0.3.2
     dev: true
 
-  /levn/0.4.1:
-    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
-    dev: true
-
   /lilconfig/2.0.4:
     resolution: {integrity: sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA==}
     engines: {node: '>=10'}
@@ -4019,10 +3616,6 @@ packages:
     resolution: {integrity: sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=}
     dev: true
 
-  /lodash.merge/4.6.2:
-    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
-    dev: true
-
   /lodash.sortby/4.7.0:
     resolution: {integrity: sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=}
     dev: true
@@ -4213,11 +3806,6 @@ packages:
     resolution: {integrity: sha512-jz+Cfrg9GWOZbQAnDQ4hlVnQky+341Yk5ru8bZSe6sIDTCIg8n9i/u7hSQGSVOF3C7lH6mGtqjkiT9G4wFLL0w==}
     dev: true
 
-  /merge2/1.4.1:
-    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
-    engines: {node: '>= 8'}
-    dev: true
-
   /micromatch/3.1.10:
     resolution: {integrity: sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==}
     engines: {node: '>=0.10.0'}
@@ -4412,10 +4000,6 @@ packages:
       - supports-color
     dev: true
 
-  /natural-compare/1.4.0:
-    resolution: {integrity: sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=}
-    dev: true
-
   /negotiator/0.6.3:
     resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
     engines: {node: '>= 0.6'}
@@ -4598,18 +4182,6 @@ packages:
       word-wrap: 1.2.3
     dev: true
 
-  /optionator/0.9.1:
-    resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      deep-is: 0.1.4
-      fast-levenshtein: 2.0.6
-      levn: 0.4.1
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
-      word-wrap: 1.2.3
-    dev: true
-
   /os-browserify/0.3.0:
     resolution: {integrity: sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=}
     dev: true
@@ -4708,6 +4280,7 @@ packages:
     dependencies:
       callsites: 3.1.0
     dev: true
+    optional: true
 
   /parse-asn1/5.1.6:
     resolution: {integrity: sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==}
@@ -4817,6 +4390,7 @@ packages:
     resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
     engines: {node: '>=8'}
     dev: true
+    optional: true
 
   /pathval/1.1.1:
     resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
@@ -4907,9 +4481,10 @@ packages:
     engines: {node: '>= 0.8.0'}
     dev: true
 
-  /prelude-ls/1.2.1:
-    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
-    engines: {node: '>= 0.8.0'}
+  /prettier/2.6.2:
+    resolution: {integrity: sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
     dev: true
 
   /process-nextick-args/2.0.1:
@@ -5051,10 +4626,6 @@ packages:
     deprecated: The querystring API is considered Legacy. new code should use the URLSearchParams API instead.
     dev: true
 
-  /queue-microtask/1.2.3:
-    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
-    dev: true
-
   /quick-lru/4.0.1:
     resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==}
     engines: {node: '>=8'}
@@ -5187,11 +4758,6 @@ packages:
       safe-regex: 1.1.0
     dev: true
 
-  /regexpp/3.2.0:
-    resolution: {integrity: sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==}
-    engines: {node: '>=8'}
-    dev: true
-
   /remove-trailing-separator/1.1.0:
     resolution: {integrity: sha1-wkvOKig62tW8P1jg1IJJuSN52O8=}
     dev: true
@@ -5228,6 +4794,7 @@ packages:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
     dev: true
+    optional: true
 
   /resolve-from/5.0.0:
     resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
@@ -5278,11 +4845,6 @@ packages:
     engines: {node: '>=0.12'}
     dev: true
 
-  /reusify/1.0.4:
-    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
-    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
-    dev: true
-
   /rfdc/1.3.0:
     resolution: {integrity: sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA==}
     dev: true
@@ -5337,12 +4899,6 @@ packages:
     engines: {node: '>=0.12.0'}
     dev: true
 
-  /run-parallel/1.2.0:
-    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
-    dependencies:
-      queue-microtask: 1.2.3
-    dev: true
-
   /run-queue/1.0.3:
     resolution: {integrity: sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=}
     dependencies:
@@ -5857,11 +5413,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /strip-json-comments/3.1.1:
-    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
-    engines: {node: '>=8'}
-    dev: true
-
   /supports-color/5.5.0:
     resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
     engines: {node: '>=4'}
@@ -5960,10 +5511,6 @@ packages:
     engines: {node: '>=0.10'}
     dev: true
 
-  /text-table/0.2.0:
-    resolution: {integrity: sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=}
-    dev: true
-
   /through/2.3.8:
     resolution: {integrity: sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=}
     dev: true
@@ -6127,16 +5674,6 @@ packages:
     resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==}
     dev: true
 
-  /tsutils/3.21.0_typescript@4.6.4:
-    resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
-    engines: {node: '>= 6'}
-    peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
-    dependencies:
-      tslib: 1.14.1
-      typescript: 4.6.4
-    dev: true
-
   /tty-browserify/0.0.0:
     resolution: {integrity: sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=}
     dev: true
@@ -6148,13 +5685,6 @@ packages:
       prelude-ls: 1.1.2
     dev: true
 
-  /type-check/0.4.0:
-    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      prelude-ls: 1.2.1
-    dev: true
-
   /type-detect/4.0.8:
     resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
     engines: {node: '>=4'}
@@ -6165,11 +5695,6 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /type-fest/0.20.2:
-    resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==}
-    engines: {node: '>=10'}
-    dev: true
-
   /type-fest/0.21.3:
     resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
     engines: {node: '>=10'}
@@ -6330,10 +5855,6 @@ packages:
     resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
     dev: true
 
-  /v8-compile-cache/2.3.0:
-    resolution: {integrity: sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA==}
-    dev: true
-
   /validate-npm-package-license/3.0.4:
     resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==}
     dependencies:
diff --git a/src/compiler/codeframe.ts b/src/compiler/codeframe.ts
index a06f387f45a..86b540ffc6f 100644
--- a/src/compiler/codeframe.ts
+++ b/src/compiler/codeframe.ts
@@ -1,4 +1,3 @@
-
 const range = 2
 
 export function generateCodeFrame(
diff --git a/src/compiler/codegen/events.ts b/src/compiler/codegen/events.ts
index 1c3685bf729..34de474e8d3 100644
--- a/src/compiler/codegen/events.ts
+++ b/src/compiler/codegen/events.ts
@@ -36,7 +36,7 @@ const keyNames: { [key: string]: string | Array<string> } = {
 // #4868: modifiers that prevent the execution of the listener
 // need to explicitly return null so that we can determine whether to remove
 // the listener for .once
-const genGuard = (condition) => `if(${condition})return null;`
+const genGuard = condition => `if(${condition})return null;`
 
 const modifierCode: { [key: string]: string } = {
   stop: '$event.stopPropagation();',
@@ -83,7 +83,7 @@ function genHandler(
   }
 
   if (Array.isArray(handler)) {
-    return `[${handler.map((handler) => genHandler(handler)).join(',')}]`
+    return `[${handler.map(handler => genHandler(handler)).join(',')}]`
   }
 
   const isMethodPath = simplePathRE.test(handler.value)
@@ -114,8 +114,8 @@ function genHandler(
         const modifiers = handler.modifiers
         genModifierCode += genGuard(
           ['ctrl', 'shift', 'alt', 'meta']
-            .filter((keyModifier) => !modifiers[keyModifier])
-            .map((keyModifier) => `$event.${keyModifier}Key`)
+            .filter(keyModifier => !modifiers[keyModifier])
+            .map(keyModifier => `$event.${keyModifier}Key`)
             .join('||')
         )
       } else {
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 0b7de4492f6..d87bd5e6f5c 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -359,7 +359,7 @@ function genInlineTemplate(
     return `inlineTemplate:{render:function(){${
       inlineRenderFns.render
     }},staticRenderFns:[${inlineRenderFns.staticRenderFns
-      .map((code) => `function(){${code}}`)
+      .map(code => `function(){${code}}`)
       .join(',')}]}`
   }
 }
@@ -375,7 +375,7 @@ function genScopedSlots(
   // for example if the slot contains dynamic names, has v-if or v-for on them...
   let needsForceUpdate =
     el.for ||
-    Object.keys(slots).some((key) => {
+    Object.keys(slots).some(key => {
       const slot = slots[key]
       return (
         slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
@@ -411,7 +411,7 @@ function genScopedSlots(
   }
 
   const generatedSlots = Object.keys(slots)
-    .map((key) => genScopedSlot(slots[key], state))
+    .map(key => genScopedSlot(slots[key], state))
     .join(',')
 
   return `scopedSlots:_u([${generatedSlots}]${
@@ -492,7 +492,7 @@ export function genChildren(
       ? getNormalizationType(children, state.maybeComponent)
       : 0
     const gen = altGenNode || genNode
-    return `[${children.map((c) => gen(c, state)).join(',')}]${
+    return `[${children.map(c => gen(c, state)).join(',')}]${
       normalizationType ? `,${normalizationType}` : ''
     }`
   }
@@ -515,14 +515,14 @@ function getNormalizationType(
     if (
       needsNormalization(el) ||
       (el.ifConditions &&
-        el.ifConditions.some((c) => needsNormalization(c.block)))
+        el.ifConditions.some(c => needsNormalization(c.block)))
     ) {
       res = 2
       break
     }
     if (
       maybeComponent(el) ||
-      (el.ifConditions && el.ifConditions.some((c) => maybeComponent(c.block)))
+      (el.ifConditions && el.ifConditions.some(c => maybeComponent(c.block)))
     ) {
       res = 1
     }
@@ -563,7 +563,7 @@ function genSlot(el: ASTElement, state: CodegenState): string {
   const attrs =
     el.attrs || el.dynamicAttrs
       ? genProps(
-          (el.attrs || []).concat(el.dynamicAttrs || []).map((attr) => ({
+          (el.attrs || []).concat(el.dynamicAttrs || []).map(attr => ({
             // slot props are camelized
             name: camelize(attr.name),
             value: attr.value,
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index 214c0e48a49..f6aa0ae3b17 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -1,4 +1,3 @@
-
 import { extend } from 'shared/util'
 import { detectErrors } from './error-detector'
 import { createCompileToFunctionFn } from './to-function'
@@ -13,8 +12,12 @@ export function createCompilerCreator(baseCompile: Function): Function {
       const errors: WarningMessage[] = []
       const tips: WarningMessage[] = []
 
-      let warn = (msg: WarningMessage, range: { start: number, end: number }, tip: string) => {
-        (tip ? tips : errors).push(msg)
+      let warn = (
+        msg: WarningMessage,
+        range: { start: number; end: number },
+        tip: string
+      ) => {
+        ;(tip ? tips : errors).push(msg)
       }
 
       if (options) {
@@ -25,8 +28,12 @@ export function createCompilerCreator(baseCompile: Function): Function {
           // $flow-disable-line
           const leadingSpaceLength = template.match(/^\s*/)![0].length
 
-          warn = (msg: WarningMessage | string, range: { start: number, end: number }, tip: string) => {
-            const data: WarningMessage = typeof(msg) === 'string' ? { msg } : msg
+          warn = (
+            msg: WarningMessage | string,
+            range: { start: number; end: number },
+            tip: string
+          ) => {
+            const data: WarningMessage = typeof msg === 'string' ? { msg } : msg
             if (range) {
               if (range.start != null) {
                 data.start = range.start + leadingSpaceLength
@@ -35,7 +42,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
                 data.end = range.end + leadingSpaceLength
               }
             }
-            (tip ? tips : errors).push(data)
+            ;(tip ? tips : errors).push(data)
           }
         }
         // merge custom modules
@@ -72,7 +79,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
 
     return {
       compile,
-      compileToFunctions: createCompileToFunctionFn(compile),
+      compileToFunctions: createCompileToFunctionFn(compile)
     }
   }
 }
diff --git a/src/compiler/directives/bind.ts b/src/compiler/directives/bind.ts
index 409852ba5f1..8e646c3c5bc 100644
--- a/src/compiler/directives/bind.ts
+++ b/src/compiler/directives/bind.ts
@@ -1,4 +1,3 @@
-
 export default function bind(el: ASTElement, dir: ASTDirective) {
   el.wrapData = (code: string) => {
     return `_b(${code},'${el.tag}',${dir.value},${
diff --git a/src/compiler/directives/index.ts b/src/compiler/directives/index.ts
index e04df4f1071..72cfb22ab11 100644
--- a/src/compiler/directives/index.ts
+++ b/src/compiler/directives/index.ts
@@ -1,4 +1,3 @@
-
 import on from './on'
 import bind from './bind'
 import { noop } from 'shared/util'
@@ -6,5 +5,5 @@ import { noop } from 'shared/util'
 export default {
   on,
   bind,
-  cloak: noop,
+  cloak: noop
 }
diff --git a/src/compiler/directives/model.ts b/src/compiler/directives/model.ts
index 39262b53777..c3591027498 100644
--- a/src/compiler/directives/model.ts
+++ b/src/compiler/directives/model.ts
@@ -1,4 +1,3 @@
-
 /**
  * Cross-platform code generation for component v-model
  */
@@ -25,7 +24,7 @@ export function genComponentModel(
   el.model = {
     value: `(${value})`,
     expression: JSON.stringify(value),
-    callback: `function (${baseValueExpression}) {${assignment}}`,
+    callback: `function (${baseValueExpression}) {${assignment}}`
   }
 }
 
@@ -74,12 +73,12 @@ export function parseModel(val: string): ModelParseResult {
     if (index > -1) {
       return {
         exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"',
+        key: '"' + val.slice(index + 1) + '"'
       }
     } else {
       return {
         exp: val,
-        key: null,
+        key: null
       }
     }
   }
@@ -99,7 +98,7 @@ export function parseModel(val: string): ModelParseResult {
 
   return {
     exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos),
+    key: val.slice(expressionPos + 1, expressionEndPos)
   }
 }
 
diff --git a/src/compiler/directives/on.ts b/src/compiler/directives/on.ts
index 2ca2d124a07..da0d66fbd1a 100644
--- a/src/compiler/directives/on.ts
+++ b/src/compiler/directives/on.ts
@@ -1,4 +1,3 @@
-
 import { warn } from 'core/util/index'
 
 export default function on(el: ASTElement, dir: ASTDirective) {
diff --git a/src/compiler/error-detector.ts b/src/compiler/error-detector.ts
index 9271aa5bd92..eb29280be05 100644
--- a/src/compiler/error-detector.ts
+++ b/src/compiler/error-detector.ts
@@ -1,4 +1,3 @@
-
 import { dirRE, onRE } from './parser/index'
 
 type Range = { start?: number; end?: number }
@@ -25,7 +24,8 @@ const unaryOperatorsRE = new RegExp(
 )
 
 // strip strings in expressions
-const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
+const stripStringRE =
+  /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
 
 // detect problematic expressions in a template
 export function detectErrors(ast: ASTNode | undefined, warn: Function) {
@@ -117,7 +117,7 @@ function checkExpression(
 ) {
   try {
     new Function(`return ${exp}`)
-  } catch (e:any) {
+  } catch (e: any) {
     const keywordMatch = exp
       .replace(stripStringRE, '')
       .match(prohibitedKeywordRE)
@@ -146,7 +146,7 @@ function checkFunctionParameterExpression(
 ) {
   try {
     new Function(exp, '')
-  } catch (e:any) {
+  } catch (e: any) {
     warn(
       `invalid function parameter expression: ${e.message} in\n\n` +
         `    ${exp}\n\n` +
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index 93c661f785b..be588bdf40d 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -1,4 +1,3 @@
-
 import { emptyObject } from 'shared/util'
 import { parseFilters } from './parser/filter-parser'
 
@@ -14,7 +13,7 @@ export function pluckModuleFunction<T, K extends keyof T>(
   modules: Array<T> | undefined,
   key: K
 ): Array<T[K]> {
-  return modules ? modules.map((m) => m[key]).filter((_) => _) : []
+  return modules ? modules.map(m => m[key]).filter(_ => _) : []
 }
 
 export function addProp(
@@ -24,7 +23,7 @@ export function addProp(
   range?: Range,
   dynamic?: boolean
 ) {
-  (el.props || (el.props = [])).push(
+  ;(el.props || (el.props = [])).push(
     rangeSetItem({ name, value, dynamic }, range)
   )
   el.plain = false
@@ -65,7 +64,7 @@ export function addDirective(
   modifiers?: ASTModifiers,
   range?: Range
 ) {
-  (el.directives || (el.directives = [])).push(
+  ;(el.directives || (el.directives = [])).push(
     rangeSetItem(
       {
         name,
@@ -73,7 +72,7 @@ export function addDirective(
         value,
         arg,
         isDynamicArg,
-        modifiers,
+        modifiers
       },
       range
     )
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index 997689ccd2b..585b5c63091 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -1,4 +1,3 @@
-
 import { parse } from './parser/index'
 import { optimize } from './optimizer'
 import { generate } from './codegen/index'
@@ -19,6 +18,6 @@ export const createCompiler = createCompilerCreator(function baseCompile(
   return {
     ast,
     render: code.render,
-    staticRenderFns: code.staticRenderFns,
+    staticRenderFns: code.staticRenderFns
   }
 })
diff --git a/src/compiler/optimizer.ts b/src/compiler/optimizer.ts
index 5b4cb718df9..c0b81736535 100644
--- a/src/compiler/optimizer.ts
+++ b/src/compiler/optimizer.ts
@@ -1,4 +1,3 @@
-
 import { makeMap, isBuiltInTag, cached, no } from 'shared/util'
 
 let isStaticKey
diff --git a/src/compiler/parser/entity-decoder.ts b/src/compiler/parser/entity-decoder.ts
index 7e693d8ab0e..031f3291763 100644
--- a/src/compiler/parser/entity-decoder.ts
+++ b/src/compiler/parser/entity-decoder.ts
@@ -1,4 +1,3 @@
-
 let decoder
 
 export default {
@@ -6,5 +5,5 @@ export default {
     decoder = decoder || document.createElement('div')
     decoder.innerHTML = html
     return decoder.textContent
-  },
+  }
 }
diff --git a/src/compiler/parser/filter-parser.ts b/src/compiler/parser/filter-parser.ts
index 0684a3751ec..b5aa5b7f4a6 100644
--- a/src/compiler/parser/filter-parser.ts
+++ b/src/compiler/parser/filter-parser.ts
@@ -1,4 +1,3 @@
-
 const validDivisionCharRE = /[\w).+\-_$\]]/
 
 export function parseFilters(exp: string): string {
@@ -91,7 +90,7 @@ export function parseFilters(exp: string): string {
   }
 
   function pushFilter() {
-    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
+    ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
     lastFilterIndex = i + 1
   }
 
diff --git a/src/compiler/parser/html-parser.ts b/src/compiler/parser/html-parser.ts
index 2913e650240..b1cf9768d24 100644
--- a/src/compiler/parser/html-parser.ts
+++ b/src/compiler/parser/html-parser.ts
@@ -14,8 +14,10 @@ import { isNonPhrasingTag } from 'web/compiler/util'
 import { unicodeRegExp } from 'core/util/lang'
 
 // Regular Expressions for parsing tags and attributes
-const attribute = /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-const dynamicArgAttribute = /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
+const attribute =
+  /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
+const dynamicArgAttribute =
+  /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
 const ncname = `[a-zA-Z_][\\-\\.0-9_a-zA-Z${unicodeRegExp.source}]*`
 const qnameCapture = `((?:${ncname}\\:)?${ncname})`
 const startTagOpen = new RegExp(`^<${qnameCapture}`)
@@ -37,7 +39,7 @@ const decodingMap = {
   '&amp;': '&',
   '&#10;': '\n',
   '&#9;': '\t',
-  '&#39;': "'",
+  '&#39;': "'"
 }
 const encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
 const encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
@@ -49,7 +51,7 @@ const shouldIgnoreFirstNewline = (tag, html) =>
 
 function decodeAttr(value, shouldDecodeNewlines) {
   const re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
-  return value.replace(re, (match) => decodingMap[match])
+  return value.replace(re, match => decodingMap[match])
 }
 
 export function parseHTML(html, options) {
@@ -185,7 +187,7 @@ export function parseHTML(html, options) {
         options.warn
       ) {
         options.warn(`Mal-formatted tag at end of template: "${html}"`, {
-          start: index + html.length,
+          start: index + html.length
         })
       }
       break
@@ -206,7 +208,7 @@ export function parseHTML(html, options) {
       const match: any = {
         tagName: start[1],
         attrs: [],
-        start: index,
+        start: index
       }
       advance(start[0].length)
       let end, attr
@@ -254,7 +256,7 @@ export function parseHTML(html, options) {
           : options.shouldDecodeNewlines
       attrs[i] = {
         name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines),
+        value: decodeAttr(value, shouldDecodeNewlines)
       }
       if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
         attrs[i].start = args.start + args[0].match(/^\s*/).length
@@ -268,7 +270,7 @@ export function parseHTML(html, options) {
         lowerCasedTag: tagName.toLowerCase(),
         attrs: attrs,
         start: match.start,
-        end: match.end,
+        end: match.end
       })
       lastTag = tagName
     }
@@ -306,7 +308,7 @@ export function parseHTML(html, options) {
         ) {
           options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
             start: stack[i].start,
-            end: stack[i].end,
+            end: stack[i].end
           })
         }
         if (options.end) {
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index 5f238a3fdac..d2f2fc21cb7 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -1,4 +1,3 @@
-
 import he from 'he'
 import { parseHTML } from './html-parser'
 import { parseText } from './text-parser'
@@ -17,7 +16,7 @@ import {
   getAndRemoveAttr,
   getRawBindingAttr,
   pluckModuleFunction,
-  getAndRemoveAttrByRegex,
+  getAndRemoveAttrByRegex
 } from '../helpers'
 
 export const onRE = /^@|^v-on:/
@@ -68,7 +67,7 @@ export function createASTElement(
     attrsMap: makeAttrsMap(attrs),
     rawAttrsMap: {},
     parent,
-    children: [],
+    children: []
   }
 }
 
@@ -82,12 +81,13 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
   platformMustUseProp = options.mustUseProp || no
   platformGetTagNamespace = options.getTagNamespace || no
   const isReservedTag = options.isReservedTag || no
-  maybeComponent = (el: ASTElement) => !!(
-    el.component ||
-    el.attrsMap[':is'] ||
-    el.attrsMap['v-bind:is'] ||
-    !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
-  )
+  maybeComponent = (el: ASTElement) =>
+    !!(
+      el.component ||
+      el.attrsMap[':is'] ||
+      el.attrsMap['v-bind:is'] ||
+      !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
+    )
   transforms = pluckModuleFunction(options.modules, 'transformNode')
   preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
   postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
@@ -124,7 +124,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
         }
         addIfCondition(root, {
           exp: element.elseif,
-          block: element,
+          block: element
         })
       } else if (process.env.NODE_ENV !== 'production') {
         warnOnce(
@@ -155,7 +155,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
 
     // final children cleanup
     // filter out scoped slots
-    element.children = element.children.filter((c) => !c.slotScope)
+    element.children = element.children.filter(c => !c.slotScope)
     // remove trailing whitespace node again
     trimEndingWhitespace(element)
 
@@ -238,14 +238,14 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
             return cumulated
           }, {})
         }
-        attrs.forEach((attr) => {
+        attrs.forEach(attr => {
           if (invalidAttributeRE.test(attr.name)) {
             warn(
               `Invalid dynamic argument expression: attribute names cannot contain ` +
                 `spaces, quotes, <, >, / or =.`,
               {
                 start: attr.start + attr.name.indexOf(`[`),
-                end: attr.start + attr.name.length,
+                end: attr.start + attr.name.length
               }
             )
           }
@@ -323,7 +323,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
             )
           } else if ((text = text.trim())) {
             warnOnce(`text "${text}" outside root element will be ignored.`, {
-              start,
+              start
             })
           }
         }
@@ -340,7 +340,9 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
       }
       const children = currentParent.children
       if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text) as string
+        text = isTextTag(currentParent)
+          ? text
+          : (decodeHTMLCached(text) as string)
       } else if (!children.length) {
         // remove the whitespace-only node right after an opening tag
         text = ''
@@ -367,7 +369,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
             type: 2,
             expression: res.expression,
             tokens: res.tokens,
-            text,
+            text
           }
         } else if (
           text !== ' ' ||
@@ -376,7 +378,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
         ) {
           child = {
             type: 3,
-            text,
+            text
           }
         }
         if (child) {
@@ -398,7 +400,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
         const child: ASTText = {
           type: 3,
           text,
-          isComment: true,
+          isComment: true
         }
         if (
           process.env.NODE_ENV !== 'production' &&
@@ -409,7 +411,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
         }
         currentParent.children.push(child)
       }
-    },
+    }
   })
   return root
 }
@@ -428,7 +430,7 @@ function processRawAttrs(el) {
     for (let i = 0; i < len; i++) {
       attrs[i] = {
         name: list[i].name,
-        value: JSON.stringify(list[i].value),
+        value: JSON.stringify(list[i].value)
       }
       if (list[i].start != null) {
         attrs[i].start = list[i].start
@@ -544,7 +546,7 @@ function processIf(el) {
     el.if = exp
     addIfCondition(el, {
       exp: exp,
-      block: el,
+      block: el
     })
   } else {
     if (getAndRemoveAttr(el, 'v-else') != null) {
@@ -562,7 +564,7 @@ function processIfConditions(el, parent) {
   if (prev && prev.if) {
     addIfCondition(prev, {
       exp: el.elseif,
-      block: el,
+      block: el
     })
   } else if (process.env.NODE_ENV !== 'production') {
     warn(
@@ -776,7 +778,7 @@ function processAttrs(el) {
       modifiers = parseModifiers(name.replace(dirRE, ''))
       // support .foo shorthand syntax for the .prop modifier
       if (process.env.VBIND_PROP_SHORTHAND && propBindRE.test(name)) {
-        (modifiers || (modifiers = {})).prop = true
+        ;(modifiers || (modifiers = {})).prop = true
         name = `.` + name.slice(1).replace(modifierRE, '')
       } else if (modifiers) {
         name = name.replace(modifierRE, '')
@@ -930,7 +932,7 @@ function parseModifiers(name: string): Object | void {
   const match = name.match(modifierRE)
   if (match) {
     const ret = {}
-    match.forEach((m) => {
+    match.forEach(m => {
       ret[m.slice(1)] = true
     })
     return ret
diff --git a/src/compiler/parser/text-parser.ts b/src/compiler/parser/text-parser.ts
index a1e569a16df..ea7387ffff8 100644
--- a/src/compiler/parser/text-parser.ts
+++ b/src/compiler/parser/text-parser.ts
@@ -1,11 +1,10 @@
-
 import { cached } from 'shared/util'
 import { parseFilters } from './filter-parser'
 
 const defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
 const regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
 
-const buildRegex = cached((delimiters) => {
+const buildRegex = cached(delimiters => {
   const open = delimiters[0].replace(regexEscapeRE, '\\$&')
   const close = delimiters[1].replace(regexEscapeRE, '\\$&')
   return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
@@ -48,6 +47,6 @@ export function parseText(
   }
   return {
     expression: tokens.join('+'),
-    tokens: rawTokens,
+    tokens: rawTokens
   }
 }
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index 8a384b5d07c..3165d3cc0ed 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -1,4 +1,3 @@
-
 import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
 import { generateCodeFrame } from './codeframe'
@@ -35,7 +34,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
       // detect possible CSP restriction
       try {
         new Function('return 1')
-      } catch (e:any) {
+      } catch (e: any) {
         if (e.toString().match(/unsafe-eval|CSP/)) {
           warn(
             'It seems you are using the standalone build of Vue.js in an ' +
@@ -63,7 +62,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
     if (process.env.NODE_ENV !== 'production') {
       if (compiled.errors && compiled.errors.length) {
         if (options.outputSourceRange) {
-          compiled.errors.forEach((e) => {
+          compiled.errors.forEach(e => {
             warn(
               `Error compiling template:\n\n${e.msg}\n\n` +
                 generateCodeFrame(template, e.start, e.end),
@@ -73,7 +72,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
         } else {
           warn(
             `Error compiling template:\n\n${template}\n\n` +
-              compiled.errors.map((e) => `- ${e}`).join('\n') +
+              compiled.errors.map(e => `- ${e}`).join('\n') +
               '\n',
             vm
           )
@@ -81,9 +80,9 @@ export function createCompileToFunctionFn(compile: Function): Function {
       }
       if (compiled.tips && compiled.tips.length) {
         if (options.outputSourceRange) {
-          compiled.tips.forEach((e) => tip(e.msg, vm))
+          compiled.tips.forEach(e => tip(e.msg, vm))
         } else {
-          compiled.tips.forEach((msg) => tip(msg, vm))
+          compiled.tips.forEach(msg => tip(msg, vm))
         }
       }
     }
@@ -92,7 +91,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
     const res: any = {}
     const fnGenErrors: any[] = []
     res.render = createFunction(compiled.render, fnGenErrors)
-    res.staticRenderFns = compiled.staticRenderFns.map((code) => {
+    res.staticRenderFns = compiled.staticRenderFns.map(code => {
       return createFunction(code, fnGenErrors)
     })
 
diff --git a/src/core/components/index.ts b/src/core/components/index.ts
index 3c681dae261..5461c763841 100644
--- a/src/core/components/index.ts
+++ b/src/core/components/index.ts
@@ -1,5 +1,5 @@
 import KeepAlive from './keep-alive'
 
 export default {
-  KeepAlive,
+  KeepAlive
 }
diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index 6e03c1e990a..605167f1522 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -1,19 +1,19 @@
-import { isRegExp, remove } from "shared/util";
-import { getFirstComponentChild } from "core/vdom/helpers/index";
-import type VNode from "core/vdom/vnode";
-import type { VNodeComponentOptions } from "typescript/vnode";
-import type { Component } from "typescript/component";
+import { isRegExp, remove } from 'shared/util'
+import { getFirstComponentChild } from 'core/vdom/helpers/index'
+import type VNode from 'core/vdom/vnode'
+import type { VNodeComponentOptions } from 'typescript/vnode'
+import type { Component } from 'typescript/component'
 
 type CacheEntry = {
-  name?: string;
-  tag?: string;
-  componentInstance?: Component;
-};
+  name?: string
+  tag?: string
+  componentInstance?: Component
+}
 
-type CacheEntryMap = Record<string, CacheEntry | null>;
+type CacheEntryMap = Record<string, CacheEntry | null>
 
 function getComponentName(opts?: VNodeComponentOptions): string | null {
-  return opts && (opts.Ctor.options.name || opts.tag);
+  return opts && (opts.Ctor.options.name || opts.tag)
 }
 
 function matches(
@@ -21,27 +21,27 @@ function matches(
   name: string
 ): boolean {
   if (Array.isArray(pattern)) {
-    return pattern.indexOf(name) > -1;
-  } else if (typeof pattern === "string") {
-    return pattern.split(",").indexOf(name) > -1;
+    return pattern.indexOf(name) > -1
+  } else if (typeof pattern === 'string') {
+    return pattern.split(',').indexOf(name) > -1
   } else if (isRegExp(pattern)) {
-    return pattern.test(name);
+    return pattern.test(name)
   }
   /* istanbul ignore next */
-  return false;
+  return false
 }
 
 function pruneCache(
   keepAliveInstance: { cache: CacheEntryMap; keys: string[]; _vnode: VNode },
   filter: Function
 ) {
-  const { cache, keys, _vnode } = keepAliveInstance;
+  const { cache, keys, _vnode } = keepAliveInstance
   for (const key in cache) {
-    const entry = cache[key];
+    const entry = cache[key]
     if (entry) {
-      const name = entry.name;
+      const name = entry.name
       if (name && !filter(name)) {
-        pruneCacheEntry(cache, key, keys, _vnode);
+        pruneCacheEntry(cache, key, keys, _vnode)
       }
     }
   }
@@ -53,112 +53,112 @@ function pruneCacheEntry(
   keys: Array<string>,
   current?: VNode
 ) {
-  const entry = cache[key];
+  const entry = cache[key]
   if (entry && (!current || entry.tag !== current.tag)) {
     // @ts-expect-error can be undefined
-    entry.componentInstance.$destroy();
+    entry.componentInstance.$destroy()
   }
-  cache[key] = null;
-  remove(keys, key);
+  cache[key] = null
+  remove(keys, key)
 }
 
-const patternTypes: Array<Function> = [String, RegExp, Array];
+const patternTypes: Array<Function> = [String, RegExp, Array]
 
 // TODO defineComponent
 export default {
-  name: "keep-alive",
+  name: 'keep-alive',
   abstract: true,
 
   props: {
     include: patternTypes,
     exclude: patternTypes,
-    max: [String, Number],
+    max: [String, Number]
   },
 
   methods: {
     cacheVNode() {
-      const { cache, keys, vnodeToCache, keyToCache } = this;
+      const { cache, keys, vnodeToCache, keyToCache } = this
       if (vnodeToCache) {
-        const { tag, componentInstance, componentOptions } = vnodeToCache;
+        const { tag, componentInstance, componentOptions } = vnodeToCache
         cache[keyToCache] = {
           name: getComponentName(componentOptions),
           tag,
-          componentInstance,
-        };
-        keys.push(keyToCache);
+          componentInstance
+        }
+        keys.push(keyToCache)
         // prune oldest entry
         if (this.max && keys.length > parseInt(this.max)) {
-          pruneCacheEntry(cache, keys[0], keys, this._vnode);
+          pruneCacheEntry(cache, keys[0], keys, this._vnode)
         }
-        this.vnodeToCache = null;
+        this.vnodeToCache = null
       }
-    },
+    }
   },
 
   created() {
-    this.cache = Object.create(null);
-    this.keys = [];
+    this.cache = Object.create(null)
+    this.keys = []
   },
 
   destroyed() {
     for (const key in this.cache) {
-      pruneCacheEntry(this.cache, key, this.keys);
+      pruneCacheEntry(this.cache, key, this.keys)
     }
   },
 
   mounted() {
-    this.cacheVNode();
-    this.$watch("include", (val) => {
-      pruneCache(this, (name) => matches(val, name));
-    });
-    this.$watch("exclude", (val) => {
-      pruneCache(this, (name) => !matches(val, name));
-    });
+    this.cacheVNode()
+    this.$watch('include', val => {
+      pruneCache(this, name => matches(val, name))
+    })
+    this.$watch('exclude', val => {
+      pruneCache(this, name => !matches(val, name))
+    })
   },
 
   updated() {
-    this.cacheVNode();
+    this.cacheVNode()
   },
 
   render() {
-    const slot = this.$slots.default;
-    const vnode = getFirstComponentChild(slot);
-    const componentOptions = vnode && vnode.componentOptions;
+    const slot = this.$slots.default
+    const vnode = getFirstComponentChild(slot)
+    const componentOptions = vnode && vnode.componentOptions
     if (componentOptions) {
       // check pattern
-      const name = getComponentName(componentOptions);
-      const { include, exclude } = this;
+      const name = getComponentName(componentOptions)
+      const { include, exclude } = this
       if (
         // not included
         (include && (!name || !matches(include, name))) ||
         // excluded
         (exclude && name && matches(exclude, name))
       ) {
-        return vnode;
+        return vnode
       }
 
-      const { cache, keys } = this;
+      const { cache, keys } = this
       const key =
         vnode.key == null
           ? // same constructor may get registered as different local components
             // so cid alone is not enough (#3269)
             componentOptions.Ctor.cid +
-            (componentOptions.tag ? `::${componentOptions.tag}` : "")
-          : vnode.key;
+            (componentOptions.tag ? `::${componentOptions.tag}` : '')
+          : vnode.key
       if (cache[key]) {
-        vnode.componentInstance = cache[key].componentInstance;
+        vnode.componentInstance = cache[key].componentInstance
         // make current key freshest
-        remove(keys, key);
-        keys.push(key);
+        remove(keys, key)
+        keys.push(key)
       } else {
         // delay setting the cache until update
-        this.vnodeToCache = vnode;
-        this.keyToCache = key;
+        this.vnodeToCache = vnode
+        this.keyToCache = key
       }
 
       // @ts-expect-error can vnode.data can be undefined
-      vnode.data.keepAlive = true;
+      vnode.data.keepAlive = true
     }
-    return vnode || (slot && slot[0]);
-  },
-};
+    return vnode || (slot && slot[0])
+  }
+}
diff --git a/src/core/config.ts b/src/core/config.ts
index 20ef40c234f..f125f9052b0 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -1,4 +1,3 @@
-
 import { no, noop, identity } from 'shared/util'
 
 import { LIFECYCLE_HOOKS } from 'shared/constants'
@@ -31,7 +30,7 @@ export interface Config {
   _lifecycleHooks: Array<string>
 }
 
-export default ({
+export default {
   /**
    * Option merge strategies (used in core/util/options)
    */
@@ -122,5 +121,5 @@ export default ({
   /**
    * Exposed for legacy reasons
    */
-  _lifecycleHooks: LIFECYCLE_HOOKS,
-} as unknown) as Config
+  _lifecycleHooks: LIFECYCLE_HOOKS
+} as unknown as Config
diff --git a/src/core/global-api/assets.ts b/src/core/global-api/assets.ts
index 82f02a30597..6b09170a1f4 100644
--- a/src/core/global-api/assets.ts
+++ b/src/core/global-api/assets.ts
@@ -1,4 +1,3 @@
-
 import { ASSET_TYPES } from 'shared/constants'
 import type { GlobalAPI } from 'typescript/global-api'
 import { isPlainObject, validateComponentName } from '../util/index'
@@ -7,7 +6,7 @@ export function initAssetRegisters(Vue: GlobalAPI) {
   /**
    * Create asset registration methods.
    */
-  ASSET_TYPES.forEach((type) => {
+  ASSET_TYPES.forEach(type => {
     // @ts-expect-error function is not exact same type
     Vue[type] = function (
       id: string,
diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index f1ca45aedd7..afabe769891 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -1,4 +1,3 @@
-
 import { ASSET_TYPES } from 'shared/constants'
 import type { Component } from 'typescript/component'
 import type { GlobalAPI } from 'typescript/global-api'
@@ -31,9 +30,9 @@ export function initExtend(Vue: GlobalAPI) {
       validateComponentName(name)
     }
 
-    const Sub = (function VueComponent(this: any, options: any) {
+    const Sub = function VueComponent(this: any, options: any) {
       this._init(options)
-    } as unknown) as typeof Component
+    } as unknown as typeof Component
     Sub.prototype = Object.create(Super.prototype)
     Sub.prototype.constructor = Sub
     Sub.cid = cid++
diff --git a/src/core/global-api/index.ts b/src/core/global-api/index.ts
index 008dea41077..69bdc6ee3a1 100644
--- a/src/core/global-api/index.ts
+++ b/src/core/global-api/index.ts
@@ -1,4 +1,3 @@
-
 import config from '../config'
 import { initUse } from './use'
 import { initMixin } from './mixin'
@@ -14,7 +13,7 @@ import {
   extend,
   nextTick,
   mergeOptions,
-  defineReactive,
+  defineReactive
 } from '../util/index'
 import type { GlobalAPI } from 'typescript/global-api'
 
@@ -38,7 +37,7 @@ export function initGlobalAPI(Vue: GlobalAPI) {
     warn,
     extend,
     mergeOptions,
-    defineReactive,
+    defineReactive
   }
 
   Vue.set = set
@@ -52,7 +51,7 @@ export function initGlobalAPI(Vue: GlobalAPI) {
   }
 
   Vue.options = Object.create(null)
-  ASSET_TYPES.forEach((type) => {
+  ASSET_TYPES.forEach(type => {
     Vue.options[type + 's'] = Object.create(null)
   })
 
diff --git a/src/core/global-api/mixin.ts b/src/core/global-api/mixin.ts
index 7b53b510f66..6bc7b8f245a 100644
--- a/src/core/global-api/mixin.ts
+++ b/src/core/global-api/mixin.ts
@@ -1,4 +1,3 @@
-
 import type { GlobalAPI } from 'typescript/global-api'
 import { mergeOptions } from '../util/index'
 
diff --git a/src/core/global-api/use.ts b/src/core/global-api/use.ts
index a0f8eace629..d3bad623d1e 100644
--- a/src/core/global-api/use.ts
+++ b/src/core/global-api/use.ts
@@ -1,4 +1,3 @@
-
 import type { GlobalAPI } from 'typescript/global-api'
 import { toArray } from '../util/index'
 
diff --git a/src/core/index.ts b/src/core/index.ts
index b50240e4a81..2ce6c9d604a 100644
--- a/src/core/index.ts
+++ b/src/core/index.ts
@@ -6,19 +6,19 @@ import { FunctionalRenderContext } from 'core/vdom/create-functional-component'
 initGlobalAPI(Vue)
 
 Object.defineProperty(Vue.prototype, '$isServer', {
-  get: isServerRendering,
+  get: isServerRendering
 })
 
 Object.defineProperty(Vue.prototype, '$ssrContext', {
   get() {
     /* istanbul ignore next */
     return this.$vnode && this.$vnode.ssrContext
-  },
+  }
 })
 
 // expose FunctionalRenderContext for ssr runtime helper installation
 Object.defineProperty(Vue, 'FunctionalRenderContext', {
-  value: FunctionalRenderContext,
+  value: FunctionalRenderContext
 })
 
 Vue.version = '__VERSION__'
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index 24fa7aa6c7a..7420d06b8f0 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -1,11 +1,10 @@
-
 import type { Component } from 'typescript/component'
 import {
   tip,
   toArray,
   hyphenate,
   formatComponentName,
-  invokeWithErrorHandling,
+  invokeWithErrorHandling
 } from '../util/index'
 import { updateListeners } from '../vdom/helpers/index'
 
@@ -68,7 +67,7 @@ export function eventsMixin(Vue: Component) {
         vm.$on(event[i], fn)
       }
     } else {
-      (vm._events[event] || (vm._events[event] = [])).push(fn)
+      ;(vm._events[event] || (vm._events[event] = [])).push(fn)
       // optimize hook:event cost by using a boolean flag marked at registration
       // instead of a hash lookup
       if (hookRE.test(event)) {
diff --git a/src/core/instance/index.ts b/src/core/instance/index.ts
index 03151ae5880..afe64c18c7b 100644
--- a/src/core/instance/index.ts
+++ b/src/core/instance/index.ts
@@ -1,27 +1,27 @@
-import { initMixin } from "./init";
-import { stateMixin } from "./state";
-import { renderMixin } from "./render";
-import { eventsMixin } from "./events";
-import { lifecycleMixin } from "./lifecycle";
-import { warn } from "../util/index";
-import type { GlobalAPI } from "typescript/global-api";
+import { initMixin } from './init'
+import { stateMixin } from './state'
+import { renderMixin } from './render'
+import { eventsMixin } from './events'
+import { lifecycleMixin } from './lifecycle'
+import { warn } from '../util/index'
+import type { GlobalAPI } from 'typescript/global-api'
 
 function Vue(options) {
-  if (process.env.NODE_ENV !== "production" && !(this instanceof Vue)) {
-    warn("Vue is a constructor and should be called with the `new` keyword");
+  if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
+    warn('Vue is a constructor and should be called with the `new` keyword')
   }
-  this._init(options);
+  this._init(options)
 }
 
 //@ts-expect-error Vue has function type
-initMixin(Vue);
+initMixin(Vue)
 //@ts-expect-error Vue has function type
-stateMixin(Vue);
+stateMixin(Vue)
 //@ts-expect-error Vue has function type
-eventsMixin(Vue);
+eventsMixin(Vue)
 //@ts-expect-error Vue has function type
-lifecycleMixin(Vue);
+lifecycleMixin(Vue)
 //@ts-expect-error Vue has function type
-renderMixin(Vue);
+renderMixin(Vue)
 
-export default (Vue as unknown) as GlobalAPI;
+export default Vue as unknown as GlobalAPI
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index e1a314cf741..16c72dd7a50 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -1,4 +1,3 @@
-
 import config from '../config'
 import { initProxy } from './proxy'
 import { initState } from './state'
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 8ade3154bd3..58e43ed56ac 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,4 +1,3 @@
-
 import { hasOwn } from 'shared/util'
 import { warn, hasSymbol } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
@@ -19,7 +18,7 @@ export function initInjections(vm: Component) {
   const result = resolveInject(vm.$options.inject, vm)
   if (result) {
     toggleObserving(false)
-    Object.keys(result).forEach((key) => {
+    Object.keys(result).forEach(key => {
       /* istanbul ignore else */
       if (process.env.NODE_ENV !== 'production') {
         defineReactive(vm, key, result[key], () => {
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index b5deefebbb4..f5915fe193c 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -1,13 +1,13 @@
-import config from "../config";
-import Watcher from "../observer/watcher";
-import { mark, measure } from "../util/perf";
-import VNode, { createEmptyVNode } from "../vdom/vnode";
-import { updateComponentListeners } from "./events";
-import { resolveSlots } from "./render-helpers/resolve-slots";
-import { toggleObserving } from "../observer/index";
-import { pushTarget, popTarget } from "../observer/dep";
-import type { Component } from "../../../typescript/component";
-import type { MountedComponentVNode } from "../../../typescript/vnode";
+import config from '../config'
+import Watcher from '../observer/watcher'
+import { mark, measure } from '../util/perf'
+import VNode, { createEmptyVNode } from '../vdom/vnode'
+import { updateComponentListeners } from './events'
+import { resolveSlots } from './render-helpers/resolve-slots'
+import { toggleObserving } from '../observer/index'
+import { pushTarget, popTarget } from '../observer/dep'
+import type { Component } from '../../../typescript/component'
+import type { MountedComponentVNode } from '../../../typescript/vnode'
 
 import {
   warn,
@@ -15,127 +15,127 @@ import {
   remove,
   emptyObject,
   validateProp,
-  invokeWithErrorHandling,
-} from "../util/index";
+  invokeWithErrorHandling
+} from '../util/index'
 
-export let activeInstance: any = null;
-export let isUpdatingChildComponent: boolean = false;
+export let activeInstance: any = null
+export let isUpdatingChildComponent: boolean = false
 
 export function setActiveInstance(vm: Component) {
-  const prevActiveInstance = activeInstance;
-  activeInstance = vm;
+  const prevActiveInstance = activeInstance
+  activeInstance = vm
   return () => {
-    activeInstance = prevActiveInstance;
-  };
+    activeInstance = prevActiveInstance
+  }
 }
 
 export function initLifecycle(vm: Component) {
-  const options = vm.$options;
+  const options = vm.$options
 
   // locate first non-abstract parent
-  let parent = options.parent;
+  let parent = options.parent
   if (parent && !options.abstract) {
     while (parent.$options.abstract && parent.$parent) {
-      parent = parent.$parent;
+      parent = parent.$parent
     }
-    parent.$children.push(vm);
+    parent.$children.push(vm)
   }
 
-  vm.$parent = parent;
-  vm.$root = parent ? parent.$root : vm;
+  vm.$parent = parent
+  vm.$root = parent ? parent.$root : vm
 
-  vm.$children = [];
-  vm.$refs = {};
+  vm.$children = []
+  vm.$refs = {}
 
-  vm._watcher = null;
-  vm._inactive = null;
-  vm._directInactive = false;
-  vm._isMounted = false;
-  vm._isDestroyed = false;
-  vm._isBeingDestroyed = false;
+  vm._watcher = null
+  vm._inactive = null
+  vm._directInactive = false
+  vm._isMounted = false
+  vm._isDestroyed = false
+  vm._isBeingDestroyed = false
 }
 
 export function lifecycleMixin(Vue: Component) {
   Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
-    const vm: Component = this;
-    const prevEl = vm.$el;
-    const prevVnode = vm._vnode;
-    const restoreActiveInstance = setActiveInstance(vm);
-    vm._vnode = vnode;
+    const vm: Component = this
+    const prevEl = vm.$el
+    const prevVnode = vm._vnode
+    const restoreActiveInstance = setActiveInstance(vm)
+    vm._vnode = vnode
     // Vue.prototype.__patch__ is injected in entry points
     // based on the rendering backend used.
     if (!prevVnode) {
       // initial render
-      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
+      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */)
     } else {
       // updates
-      vm.$el = vm.__patch__(prevVnode, vnode);
+      vm.$el = vm.__patch__(prevVnode, vnode)
     }
-    restoreActiveInstance();
+    restoreActiveInstance()
     // update __vue__ reference
     if (prevEl) {
-      prevEl.__vue__ = null;
+      prevEl.__vue__ = null
     }
     if (vm.$el) {
-      vm.$el.__vue__ = vm;
+      vm.$el.__vue__ = vm
     }
     // if parent is an HOC, update its $el as well
     if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el;
+      vm.$parent.$el = vm.$el
     }
     // updated hook is called by the scheduler to ensure that children are
     // updated in a parent's updated hook.
-  };
+  }
 
   Vue.prototype.$forceUpdate = function () {
-    const vm: Component = this;
+    const vm: Component = this
     if (vm._watcher) {
-      vm._watcher.update();
+      vm._watcher.update()
     }
-  };
+  }
 
   Vue.prototype.$destroy = function () {
-    const vm: Component = this;
+    const vm: Component = this
     if (vm._isBeingDestroyed) {
-      return;
+      return
     }
-    callHook(vm, "beforeDestroy");
-    vm._isBeingDestroyed = true;
+    callHook(vm, 'beforeDestroy')
+    vm._isBeingDestroyed = true
     // remove self from parent
-    const parent = vm.$parent;
+    const parent = vm.$parent
     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
-      remove(parent.$children, vm);
+      remove(parent.$children, vm)
     }
     // teardown watchers
     if (vm._watcher) {
-      vm._watcher.teardown();
+      vm._watcher.teardown()
     }
-    let i = vm._watchers.length;
+    let i = vm._watchers.length
     while (i--) {
-      vm._watchers[i].teardown();
+      vm._watchers[i].teardown()
     }
     // remove reference from data ob
     // frozen object may not have observer.
     if (vm._data.__ob__) {
-      vm._data.__ob__.vmCount--;
+      vm._data.__ob__.vmCount--
     }
     // call the last hook...
-    vm._isDestroyed = true;
+    vm._isDestroyed = true
     // invoke destroy hooks on current rendered tree
-    vm.__patch__(vm._vnode, null);
+    vm.__patch__(vm._vnode, null)
     // fire destroyed hook
-    callHook(vm, "destroyed");
+    callHook(vm, 'destroyed')
     // turn off all instance listeners.
-    vm.$off();
+    vm.$off()
     // remove __vue__ reference
     if (vm.$el) {
-      vm.$el.__vue__ = null;
+      vm.$el.__vue__ = null
     }
     // release circular reference (#6759)
     if (vm.$vnode) {
-      vm.$vnode.parent = null;
+      vm.$vnode.parent = null
     }
-  };
+  }
 }
 
 export function mountComponent(
@@ -143,56 +143,56 @@ export function mountComponent(
   el: Element | null | undefined,
   hydrating?: boolean
 ): Component {
-  vm.$el = el;
+  vm.$el = el
   if (!vm.$options.render) {
     // @ts-expect-error invalid type
-    vm.$options.render = createEmptyVNode;
-    if (process.env.NODE_ENV !== "production") {
+    vm.$options.render = createEmptyVNode
+    if (process.env.NODE_ENV !== 'production') {
       /* istanbul ignore if */
       if (
-        (vm.$options.template && vm.$options.template.charAt(0) !== "#") ||
+        (vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
         vm.$options.el ||
         el
       ) {
         warn(
-          "You are using the runtime-only build of Vue where the template " +
-            "compiler is not available. Either pre-compile the templates into " +
-            "render functions, or use the compiler-included build.",
+          'You are using the runtime-only build of Vue where the template ' +
+            'compiler is not available. Either pre-compile the templates into ' +
+            'render functions, or use the compiler-included build.',
           vm
-        );
+        )
       } else {
         warn(
-          "Failed to mount component: template or render function not defined.",
+          'Failed to mount component: template or render function not defined.',
           vm
-        );
+        )
       }
     }
   }
-  callHook(vm, "beforeMount");
+  callHook(vm, 'beforeMount')
 
-  let updateComponent;
+  let updateComponent
   /* istanbul ignore if */
-  if (process.env.NODE_ENV !== "production" && config.performance && mark) {
+  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
     updateComponent = () => {
-      const name = vm._name;
-      const id = vm._uid;
-      const startTag = `vue-perf-start:${id}`;
-      const endTag = `vue-perf-end:${id}`;
-
-      mark(startTag);
-      const vnode = vm._render();
-      mark(endTag);
-      measure(`vue ${name} render`, startTag, endTag);
-
-      mark(startTag);
-      vm._update(vnode, hydrating);
-      mark(endTag);
-      measure(`vue ${name} patch`, startTag, endTag);
-    };
+      const name = vm._name
+      const id = vm._uid
+      const startTag = `vue-perf-start:${id}`
+      const endTag = `vue-perf-end:${id}`
+
+      mark(startTag)
+      const vnode = vm._render()
+      mark(endTag)
+      measure(`vue ${name} render`, startTag, endTag)
+
+      mark(startTag)
+      vm._update(vnode, hydrating)
+      mark(endTag)
+      measure(`vue ${name} patch`, startTag, endTag)
+    }
   } else {
     updateComponent = () => {
-      vm._update(vm._render(), hydrating);
-    };
+      vm._update(vm._render(), hydrating)
+    }
   }
 
   // we set this to vm._watcher inside the watcher's constructor
@@ -205,21 +205,21 @@ export function mountComponent(
     {
       before() {
         if (vm._isMounted && !vm._isDestroyed) {
-          callHook(vm, "beforeUpdate");
+          callHook(vm, 'beforeUpdate')
         }
-      },
+      }
     },
     true /* isRenderWatcher */
-  );
-  hydrating = false;
+  )
+  hydrating = false
 
   // manually mounted instance, call mounted on self
   // mounted is called for render-created child components in its inserted hook
   if (vm.$vnode == null) {
-    vm._isMounted = true;
-    callHook(vm, "mounted");
+    vm._isMounted = true
+    callHook(vm, 'mounted')
   }
-  return vm;
+  return vm
 }
 
 export function updateChildComponent(
@@ -229,8 +229,8 @@ export function updateChildComponent(
   parentVnode: MountedComponentVNode,
   renderChildren?: Array<VNode> | null
 ) {
-  if (process.env.NODE_ENV !== "production") {
-    isUpdatingChildComponent = true;
+  if (process.env.NODE_ENV !== 'production') {
+    isUpdatingChildComponent = true
   }
 
   // determine whether component has slot children
@@ -239,14 +239,14 @@ export function updateChildComponent(
   // check if there are dynamic scopedSlots (hand-written or compiled but with
   // dynamic slot names). Static scoped slots compiled from template has the
   // "$stable" marker.
-  const newScopedSlots = parentVnode.data.scopedSlots;
-  const oldScopedSlots = vm.$scopedSlots;
+  const newScopedSlots = parentVnode.data.scopedSlots
+  const oldScopedSlots = vm.$scopedSlots
   const hasDynamicScopedSlot = !!(
     (newScopedSlots && !newScopedSlots.$stable) ||
     (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||
     (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key) ||
     (!newScopedSlots && vm.$scopedSlots.$key)
-  );
+  )
 
   // Any static slot children from the parent may have changed during parent's
   // update. Dynamic scoped slots may also have changed. In such cases, a forced
@@ -255,108 +255,108 @@ export function updateChildComponent(
     renderChildren || // has new static slots
     vm.$options._renderChildren || // has old static slots
     hasDynamicScopedSlot
-  );
+  )
 
-  vm.$options._parentVnode = parentVnode;
-  vm.$vnode = parentVnode; // update vm's placeholder node without re-render
+  vm.$options._parentVnode = parentVnode
+  vm.$vnode = parentVnode // update vm's placeholder node without re-render
 
   if (vm._vnode) {
     // update child tree's parent
-    vm._vnode.parent = parentVnode;
+    vm._vnode.parent = parentVnode
   }
-  vm.$options._renderChildren = renderChildren;
+  vm.$options._renderChildren = renderChildren
 
   // update $attrs and $listeners hash
   // these are also reactive so they may trigger child update if the child
   // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject;
-  vm.$listeners = listeners || emptyObject;
+  vm.$attrs = parentVnode.data.attrs || emptyObject
+  vm.$listeners = listeners || emptyObject
 
   // update props
   if (propsData && vm.$options.props) {
-    toggleObserving(false);
-    const props = vm._props;
-    const propKeys = vm.$options._propKeys || [];
+    toggleObserving(false)
+    const props = vm._props
+    const propKeys = vm.$options._propKeys || []
     for (let i = 0; i < propKeys.length; i++) {
-      const key = propKeys[i];
-      const propOptions: any = vm.$options.props; // wtf flow?
-      props[key] = validateProp(key, propOptions, propsData, vm);
+      const key = propKeys[i]
+      const propOptions: any = vm.$options.props // wtf flow?
+      props[key] = validateProp(key, propOptions, propsData, vm)
     }
-    toggleObserving(true);
+    toggleObserving(true)
     // keep a copy of raw propsData
-    vm.$options.propsData = propsData;
+    vm.$options.propsData = propsData
   }
 
   // update listeners
-  listeners = listeners || emptyObject;
-  const oldListeners = vm.$options._parentListeners;
-  vm.$options._parentListeners = listeners;
-  updateComponentListeners(vm, listeners, oldListeners);
+  listeners = listeners || emptyObject
+  const oldListeners = vm.$options._parentListeners
+  vm.$options._parentListeners = listeners
+  updateComponentListeners(vm, listeners, oldListeners)
 
   // resolve slots + force update if has children
   if (needsForceUpdate) {
-    vm.$slots = resolveSlots(renderChildren, parentVnode.context);
-    vm.$forceUpdate();
+    vm.$slots = resolveSlots(renderChildren, parentVnode.context)
+    vm.$forceUpdate()
   }
 
-  if (process.env.NODE_ENV !== "production") {
-    isUpdatingChildComponent = false;
+  if (process.env.NODE_ENV !== 'production') {
+    isUpdatingChildComponent = false
   }
 }
 
 function isInInactiveTree(vm) {
   while (vm && (vm = vm.$parent)) {
-    if (vm._inactive) return true;
+    if (vm._inactive) return true
   }
-  return false;
+  return false
 }
 
 export function activateChildComponent(vm: Component, direct?: boolean) {
   if (direct) {
-    vm._directInactive = false;
+    vm._directInactive = false
     if (isInInactiveTree(vm)) {
-      return;
+      return
     }
   } else if (vm._directInactive) {
-    return;
+    return
   }
   if (vm._inactive || vm._inactive === null) {
-    vm._inactive = false;
+    vm._inactive = false
     for (let i = 0; i < vm.$children.length; i++) {
-      activateChildComponent(vm.$children[i]);
+      activateChildComponent(vm.$children[i])
     }
-    callHook(vm, "activated");
+    callHook(vm, 'activated')
   }
 }
 
 export function deactivateChildComponent(vm: Component, direct?: boolean) {
   if (direct) {
-    vm._directInactive = true;
+    vm._directInactive = true
     if (isInInactiveTree(vm)) {
-      return;
+      return
     }
   }
   if (!vm._inactive) {
-    vm._inactive = true;
+    vm._inactive = true
     for (let i = 0; i < vm.$children.length; i++) {
-      deactivateChildComponent(vm.$children[i]);
+      deactivateChildComponent(vm.$children[i])
     }
-    callHook(vm, "deactivated");
+    callHook(vm, 'deactivated')
   }
 }
 
 export function callHook(vm: Component, hook: string) {
   // #7573 disable dep collection when invoking lifecycle hooks
-  pushTarget();
-  const handlers = vm.$options[hook];
-  const info = `${hook} hook`;
+  pushTarget()
+  const handlers = vm.$options[hook]
+  const info = `${hook} hook`
   if (handlers) {
     for (let i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info);
+      invokeWithErrorHandling(handlers[i], vm, null, vm, info)
     }
   }
   if (vm._hasHookEvent) {
-    vm.$emit("hook:" + hook);
+    vm.$emit('hook:' + hook)
   }
-  popTarget();
+  popTarget()
 }
diff --git a/src/core/instance/proxy.ts b/src/core/instance/proxy.ts
index 33bc30a0312..cba02619984 100644
--- a/src/core/instance/proxy.ts
+++ b/src/core/instance/proxy.ts
@@ -51,7 +51,7 @@ if (process.env.NODE_ENV !== 'production') {
           target[key] = value
           return true
         }
-      },
+      }
     })
   }
 
@@ -68,7 +68,7 @@ if (process.env.NODE_ENV !== 'production') {
         else warnNonPresent(target, key)
       }
       return has || !isAllowed
-    },
+    }
   }
 
   const getHandler = {
@@ -78,7 +78,7 @@ if (process.env.NODE_ENV !== 'production') {
         else warnNonPresent(target, key)
       }
       return target[key]
-    },
+    }
   }
 
   initProxy = function initProxy(vm) {
diff --git a/src/core/instance/render-helpers/bind-dynamic-keys.ts b/src/core/instance/render-helpers/bind-dynamic-keys.ts
index 455b9647588..2f1de7e76ed 100644
--- a/src/core/instance/render-helpers/bind-dynamic-keys.ts
+++ b/src/core/instance/render-helpers/bind-dynamic-keys.ts
@@ -1,4 +1,3 @@
-
 // helper to process dynamic keys for dynamic arguments in v-bind and v-on.
 // For example, the following template:
 //
diff --git a/src/core/instance/render-helpers/bind-object-listeners.ts b/src/core/instance/render-helpers/bind-object-listeners.ts
index 648f01b6d76..b4d2417f620 100644
--- a/src/core/instance/render-helpers/bind-object-listeners.ts
+++ b/src/core/instance/render-helpers/bind-object-listeners.ts
@@ -1,4 +1,3 @@
-
 import { warn, extend, isPlainObject } from 'core/util/index'
 import type { VNodeData } from 'typescript/vnode'
 
diff --git a/src/core/instance/render-helpers/bind-object-props.ts b/src/core/instance/render-helpers/bind-object-props.ts
index eaf4219a932..9050cd8c694 100644
--- a/src/core/instance/render-helpers/bind-object-props.ts
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -1,4 +1,3 @@
-
 import config from 'core/config'
 
 import {
@@ -7,7 +6,7 @@ import {
   toObject,
   isReservedAttribute,
   camelize,
-  hyphenate,
+  hyphenate
 } from 'core/util/index'
 import type { VNodeData } from 'typescript/vnode'
 
diff --git a/src/core/instance/render-helpers/check-keycodes.ts b/src/core/instance/render-helpers/check-keycodes.ts
index 92ddec6c832..0f58b54d55b 100644
--- a/src/core/instance/render-helpers/check-keycodes.ts
+++ b/src/core/instance/render-helpers/check-keycodes.ts
@@ -1,4 +1,3 @@
-
 import config from 'core/config'
 import { hyphenate } from 'shared/util'
 
diff --git a/src/core/instance/render-helpers/index.ts b/src/core/instance/render-helpers/index.ts
index 480e8d9a00f..27ea60e9c8e 100644
--- a/src/core/instance/render-helpers/index.ts
+++ b/src/core/instance/render-helpers/index.ts
@@ -1,4 +1,3 @@
-
 import { toNumber, toString, looseEqual, looseIndexOf } from 'shared/util'
 import { createTextVNode, createEmptyVNode } from 'core/vdom/vnode'
 import { renderList } from './render-list'
diff --git a/src/core/instance/render-helpers/render-list.ts b/src/core/instance/render-helpers/render-list.ts
index cc8a800eb3a..8f7f6ed9e28 100644
--- a/src/core/instance/render-helpers/render-list.ts
+++ b/src/core/instance/render-helpers/render-list.ts
@@ -44,6 +44,6 @@ export function renderList(
   if (!isDef(ret)) {
     ret = []
   }
-  (ret as any)._isVList = true
+  ;(ret as any)._isVList = true
   return ret
 }
diff --git a/src/core/instance/render-helpers/render-slot.ts b/src/core/instance/render-helpers/render-slot.ts
index 439ae0aafc7..f2c82a7a744 100644
--- a/src/core/instance/render-helpers/render-slot.ts
+++ b/src/core/instance/render-helpers/render-slot.ts
@@ -1,5 +1,5 @@
-import { extend, warn, isObject } from "core/util/index";
-import VNode from "core/vdom/vnode";
+import { extend, warn, isObject } from 'core/util/index'
+import VNode from 'core/vdom/vnode'
 
 /**
  * Runtime helper for rendering <slot>
@@ -10,34 +10,30 @@ export function renderSlot(
   props: Record<string, any> | null,
   bindObject: object | null
 ): Array<VNode> | null {
-  const scopedSlotFn = this.$scopedSlots[name];
-  let nodes;
+  const scopedSlotFn = this.$scopedSlots[name]
+  let nodes
   if (scopedSlotFn) {
     // scoped slot
-    props = props || {};
+    props = props || {}
     if (bindObject) {
-      if (process.env.NODE_ENV !== "production" && !isObject(bindObject)) {
-        warn("slot v-bind without argument expects an Object", this);
+      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
+        warn('slot v-bind without argument expects an Object', this)
       }
-      props = extend(extend({}, bindObject), props);
+      props = extend(extend({}, bindObject), props)
     }
     nodes =
       scopedSlotFn(props) ||
-      (typeof fallbackRender === "function"
-        ? fallbackRender()
-        : fallbackRender);
+      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender)
   } else {
     nodes =
       this.$slots[name] ||
-      (typeof fallbackRender === "function"
-        ? fallbackRender()
-        : fallbackRender);
+      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender)
   }
 
-  const target = props && props.slot;
+  const target = props && props.slot
   if (target) {
-    return this.$createElement("template", { slot: target }, nodes);
+    return this.$createElement('template', { slot: target }, nodes)
   } else {
-    return nodes;
+    return nodes
   }
 }
diff --git a/src/core/instance/render-helpers/resolve-scoped-slots.ts b/src/core/instance/render-helpers/resolve-scoped-slots.ts
index 0b7869546ae..c5bd2903316 100644
--- a/src/core/instance/render-helpers/resolve-scoped-slots.ts
+++ b/src/core/instance/render-helpers/resolve-scoped-slots.ts
@@ -23,7 +23,7 @@ export function resolveScopedSlots(
     }
   }
   if (contentHashKey) {
-    (res as any).$key = contentHashKey
+    ;(res as any).$key = contentHashKey
   }
   return res as any
 }
diff --git a/src/core/instance/render-helpers/resolve-slots.ts b/src/core/instance/render-helpers/resolve-slots.ts
index 17f79c158c4..e664004f94b 100644
--- a/src/core/instance/render-helpers/resolve-slots.ts
+++ b/src/core/instance/render-helpers/resolve-slots.ts
@@ -1,4 +1,3 @@
-
 import type VNode from 'core/vdom/vnode'
 import type { Component } from 'typescript/component'
 
@@ -35,7 +34,7 @@ export function resolveSlots(
         slot.push(child)
       }
     } else {
-      (slots.default || (slots.default = [])).push(child)
+      ;(slots.default || (slots.default = [])).push(child)
     }
   }
   // ignore slots that contains only whitespace
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 39c3b359206..4696399d57e 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -1,10 +1,9 @@
-
 import {
   warn,
   nextTick,
   emptyObject,
   handleError,
-  defineReactive,
+  defineReactive
 } from '../util/index'
 
 import { createElement } from '../vdom/create-element'
@@ -21,7 +20,7 @@ export function initRender(vm: Component) {
   vm._staticTrees = null // v-once cached trees
   const options = vm.$options
   const parentVnode = (vm.$vnode = options._parentVnode!) // the placeholder node in parent tree
-  const renderContext  = parentVnode && parentVnode.context as Component
+  const renderContext = parentVnode && (parentVnode.context as Component)
   vm.$slots = resolveSlots(options._renderChildren, renderContext)
   vm.$scopedSlots = emptyObject
   // bind the createElement fn to this instance
@@ -127,7 +126,7 @@ export function renderMixin(Vue: Component) {
             vm.$createElement,
             e
           )
-        } catch (e:any) {
+        } catch (e: any) {
           handleError(e, vm, `renderError`)
           vnode = vm._vnode
         }
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 22b8bda1ae6..2f91f1bf2c9 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -1,15 +1,15 @@
-import config from "../config";
-import Watcher from "../observer/watcher";
-import Dep, { pushTarget, popTarget } from "../observer/dep";
-import { isUpdatingChildComponent } from "./lifecycle";
+import config from '../config'
+import Watcher from '../observer/watcher'
+import Dep, { pushTarget, popTarget } from '../observer/dep'
+import { isUpdatingChildComponent } from './lifecycle'
 
 import {
   set,
   del,
   observe,
   defineReactive,
-  toggleObserving,
-} from "../observer/index";
+  toggleObserving
+} from '../observer/index'
 
 import {
   warn,
@@ -24,60 +24,60 @@ import {
   isPlainObject,
   isServerRendering,
   isReservedAttribute,
-  invokeWithErrorHandling,
-} from "../util/index";
-import type { Component } from "../../../typescript/component";
+  invokeWithErrorHandling
+} from '../util/index'
+import type { Component } from '../../../typescript/component'
 
 const sharedPropertyDefinition = {
   enumerable: true,
   configurable: true,
   get: noop,
-  set: noop,
-};
+  set: noop
+}
 
 export function proxy(target: Object, sourceKey: string, key: string) {
   sharedPropertyDefinition.get = function proxyGetter() {
-    return this[sourceKey][key];
-  };
+    return this[sourceKey][key]
+  }
   sharedPropertyDefinition.set = function proxySetter(val) {
-    this[sourceKey][key] = val;
-  };
-  Object.defineProperty(target, key, sharedPropertyDefinition);
+    this[sourceKey][key] = val
+  }
+  Object.defineProperty(target, key, sharedPropertyDefinition)
 }
 
 export function initState(vm: Component) {
-  vm._watchers = [];
-  const opts = vm.$options;
-  if (opts.props) initProps(vm, opts.props);
-  if (opts.methods) initMethods(vm, opts.methods);
+  vm._watchers = []
+  const opts = vm.$options
+  if (opts.props) initProps(vm, opts.props)
+  if (opts.methods) initMethods(vm, opts.methods)
   if (opts.data) {
-    initData(vm);
+    initData(vm)
   } else {
-    observe((vm._data = {}), true /* asRootData */);
+    observe((vm._data = {}), true /* asRootData */)
   }
-  if (opts.computed) initComputed(vm, opts.computed);
+  if (opts.computed) initComputed(vm, opts.computed)
   if (opts.watch && opts.watch !== nativeWatch) {
-    initWatch(vm, opts.watch);
+    initWatch(vm, opts.watch)
   }
 }
 
 function initProps(vm: Component, propsOptions: Object) {
-  const propsData = vm.$options.propsData || {};
-  const props = (vm._props = {});
+  const propsData = vm.$options.propsData || {}
+  const props = (vm._props = {})
   // cache prop keys so that future props updates can iterate using Array
   // instead of dynamic object key enumeration.
-  const keys: string[] = (vm.$options._propKeys = []);
-  const isRoot = !vm.$parent;
+  const keys: string[] = (vm.$options._propKeys = [])
+  const isRoot = !vm.$parent
   // root instance props should be converted
   if (!isRoot) {
-    toggleObserving(false);
+    toggleObserving(false)
   }
   for (const key in propsOptions) {
-    keys.push(key);
-    const value = validateProp(key, propsOptions, propsData, vm);
+    keys.push(key)
+    const value = validateProp(key, propsOptions, propsData, vm)
     /* istanbul ignore else */
-    if (process.env.NODE_ENV !== "production") {
-      const hyphenatedKey = hyphenate(key);
+    if (process.env.NODE_ENV !== 'production') {
+      const hyphenatedKey = hyphenate(key)
       if (
         isReservedAttribute(hyphenatedKey) ||
         config.isReservedAttr(hyphenatedKey)
@@ -85,7 +85,7 @@ function initProps(vm: Component, propsOptions: Object) {
         warn(
           `"${hyphenatedKey}" is a reserved attribute and cannot be used as component prop.`,
           vm
-        );
+        )
       }
       defineReactive(props, key, value, () => {
         if (!isRoot && !isUpdatingChildComponent) {
@@ -95,90 +95,87 @@ function initProps(vm: Component, propsOptions: Object) {
               `Instead, use a data or computed property based on the prop's ` +
               `value. Prop being mutated: "${key}"`,
             vm
-          );
+          )
         }
-      });
+      })
     } else {
-      defineReactive(props, key, value);
+      defineReactive(props, key, value)
     }
     // static props are already proxied on the component's prototype
     // during Vue.extend(). We only need to proxy props defined at
     // instantiation here.
     if (!(key in vm)) {
-      proxy(vm, `_props`, key);
+      proxy(vm, `_props`, key)
     }
   }
-  toggleObserving(true);
+  toggleObserving(true)
 }
 
 function initData(vm: Component) {
-  let data: any = vm.$options.data;
-  data = vm._data = typeof data === "function" ? getData(data, vm) : data || {};
+  let data: any = vm.$options.data
+  data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {}
   if (!isPlainObject(data)) {
-    data = {};
-    process.env.NODE_ENV !== "production" &&
+    data = {}
+    process.env.NODE_ENV !== 'production' &&
       warn(
-        "data functions should return an object:\n" +
-          "https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function",
+        'data functions should return an object:\n' +
+          'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
         vm
-      );
+      )
   }
   // proxy data on instance
-  const keys = Object.keys(data);
-  const props = vm.$options.props;
-  const methods = vm.$options.methods;
-  let i = keys.length;
+  const keys = Object.keys(data)
+  const props = vm.$options.props
+  const methods = vm.$options.methods
+  let i = keys.length
   while (i--) {
-    const key = keys[i];
-    if (process.env.NODE_ENV !== "production") {
+    const key = keys[i]
+    if (process.env.NODE_ENV !== 'production') {
       if (methods && hasOwn(methods, key)) {
-        warn(
-          `Method "${key}" has already been defined as a data property.`,
-          vm
-        );
+        warn(`Method "${key}" has already been defined as a data property.`, vm)
       }
     }
     if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== "production" &&
+      process.env.NODE_ENV !== 'production' &&
         warn(
           `The data property "${key}" is already declared as a prop. ` +
             `Use prop default value instead.`,
           vm
-        );
+        )
     } else if (!isReserved(key)) {
-      proxy(vm, `_data`, key);
+      proxy(vm, `_data`, key)
     }
   }
   // observe data
-  observe(data, true /* asRootData */);
+  observe(data, true /* asRootData */)
 }
 
 export function getData(data: Function, vm: Component): any {
   // #7573 disable dep collection when invoking data getters
-  pushTarget();
+  pushTarget()
   try {
-    return data.call(vm, vm);
+    return data.call(vm, vm)
   } catch (e: any) {
-    handleError(e, vm, `data()`);
-    return {};
+    handleError(e, vm, `data()`)
+    return {}
   } finally {
-    popTarget();
+    popTarget()
   }
 }
 
-const computedWatcherOptions = { lazy: true };
+const computedWatcherOptions = { lazy: true }
 
 function initComputed(vm: Component, computed: Object) {
   // $flow-disable-line
-  const watchers = (vm._computedWatchers = Object.create(null));
+  const watchers = (vm._computedWatchers = Object.create(null))
   // computed properties are just getters during SSR
-  const isSSR = isServerRendering();
+  const isSSR = isServerRendering()
 
   for (const key in computed) {
-    const userDef = computed[key];
-    const getter = typeof userDef === "function" ? userDef : userDef.get;
-    if (process.env.NODE_ENV !== "production" && getter == null) {
-      warn(`Getter is missing for computed property "${key}".`, vm);
+    const userDef = computed[key]
+    const getter = typeof userDef === 'function' ? userDef : userDef.get
+    if (process.env.NODE_ENV !== 'production' && getter == null) {
+      warn(`Getter is missing for computed property "${key}".`, vm)
     }
 
     if (!isSSR) {
@@ -188,27 +185,24 @@ function initComputed(vm: Component, computed: Object) {
         getter || noop,
         noop,
         computedWatcherOptions
-      );
+      )
     }
 
     // component-defined computed properties are already defined on the
     // component prototype. We only need to define computed properties defined
     // at instantiation here.
     if (!(key in vm)) {
-      defineComputed(vm, key, userDef);
-    } else if (process.env.NODE_ENV !== "production") {
+      defineComputed(vm, key, userDef)
+    } else if (process.env.NODE_ENV !== 'production') {
       if (key in vm.$data) {
-        warn(`The computed property "${key}" is already defined in data.`, vm);
+        warn(`The computed property "${key}" is already defined in data.`, vm)
       } else if (vm.$options.props && key in vm.$options.props) {
-        warn(
-          `The computed property "${key}" is already defined as a prop.`,
-          vm
-        );
+        warn(`The computed property "${key}" is already defined as a prop.`, vm)
       } else if (vm.$options.methods && key in vm.$options.methods) {
         warn(
           `The computed property "${key}" is already defined as a method.`,
           vm
-        );
+        )
       }
     }
   }
@@ -219,92 +213,91 @@ export function defineComputed(
   key: string,
   userDef: Record<string, any> | Function
 ) {
-  const shouldCache = !isServerRendering();
-  if (typeof userDef === "function") {
+  const shouldCache = !isServerRendering()
+  if (typeof userDef === 'function') {
     sharedPropertyDefinition.get = shouldCache
       ? createComputedGetter(key)
-      : createGetterInvoker(userDef);
-    sharedPropertyDefinition.set = noop;
+      : createGetterInvoker(userDef)
+    sharedPropertyDefinition.set = noop
   } else {
     sharedPropertyDefinition.get = userDef.get
       ? shouldCache && userDef.cache !== false
         ? createComputedGetter(key)
         : createGetterInvoker(userDef.get)
-      : noop;
-    sharedPropertyDefinition.set = userDef.set || noop;
+      : noop
+    sharedPropertyDefinition.set = userDef.set || noop
   }
   if (
-    process.env.NODE_ENV !== "production" &&
+    process.env.NODE_ENV !== 'production' &&
     sharedPropertyDefinition.set === noop
   ) {
     sharedPropertyDefinition.set = function () {
       warn(
         `Computed property "${key}" was assigned to but it has no setter.`,
         this
-      );
-    };
+      )
+    }
   }
-  Object.defineProperty(target, key, sharedPropertyDefinition);
+  Object.defineProperty(target, key, sharedPropertyDefinition)
 }
 
 function createComputedGetter(key) {
   return function computedGetter() {
-    const watcher = this._computedWatchers && this._computedWatchers[key];
+    const watcher = this._computedWatchers && this._computedWatchers[key]
     if (watcher) {
       if (watcher.dirty) {
-        watcher.evaluate();
+        watcher.evaluate()
       }
       if (Dep.target) {
-        watcher.depend();
+        watcher.depend()
       }
-      return watcher.value;
+      return watcher.value
     }
-  };
+  }
 }
 
 function createGetterInvoker(fn) {
   return function computedGetter() {
-    return fn.call(this, this);
-  };
+    return fn.call(this, this)
+  }
 }
 
 function initMethods(vm: Component, methods: Object) {
-  const props = vm.$options.props;
+  const props = vm.$options.props
   for (const key in methods) {
-    if (process.env.NODE_ENV !== "production") {
-      if (typeof methods[key] !== "function") {
+    if (process.env.NODE_ENV !== 'production') {
+      if (typeof methods[key] !== 'function') {
         warn(
           `Method "${key}" has type "${typeof methods[
             key
           ]}" in the component definition. ` +
             `Did you reference the function correctly?`,
           vm
-        );
+        )
       }
       if (props && hasOwn(props, key)) {
-        warn(`Method "${key}" has already been defined as a prop.`, vm);
+        warn(`Method "${key}" has already been defined as a prop.`, vm)
       }
       if (key in vm && isReserved(key)) {
         warn(
           `Method "${key}" conflicts with an existing Vue instance method. ` +
             `Avoid defining component methods that start with _ or $.`
-        );
+        )
       }
     }
-    vm[key] =
-      typeof methods[key] !== "function" ? noop : bind(methods[key], vm);
+    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm)
   }
 }
 
 function initWatch(vm: Component, watch: Object) {
   for (const key in watch) {
-    const handler = watch[key];
+    const handler = watch[key]
     if (Array.isArray(handler)) {
       for (let i = 0; i < handler.length; i++) {
-        createWatcher(vm, key, handler[i]);
+        createWatcher(vm, key, handler[i])
       }
     } else {
-      createWatcher(vm, key, handler);
+      createWatcher(vm, key, handler)
     }
   }
 }
@@ -316,65 +309,65 @@ function createWatcher(
   options?: Object
 ) {
   if (isPlainObject(handler)) {
-    options = handler;
-    handler = handler.handler;
+    options = handler
+    handler = handler.handler
   }
-  if (typeof handler === "string") {
-    handler = vm[handler];
+  if (typeof handler === 'string') {
+    handler = vm[handler]
   }
-  return vm.$watch(expOrFn, handler, options);
+  return vm.$watch(expOrFn, handler, options)
 }
 
 export function stateMixin(Vue: Component) {
   // flow somehow has problems with directly declared definition object
   // when using Object.defineProperty, so we have to procedurally build up
   // the object here.
-  const dataDef: any = {};
+  const dataDef: any = {}
   dataDef.get = function () {
-    return this._data;
-  };
-  const propsDef: any = {};
+    return this._data
+  }
+  const propsDef: any = {}
   propsDef.get = function () {
-    return this._props;
-  };
-  if (process.env.NODE_ENV !== "production") {
+    return this._props
+  }
+  if (process.env.NODE_ENV !== 'production') {
     dataDef.set = function () {
       warn(
-        "Avoid replacing instance root $data. " +
-          "Use nested data properties instead.",
+        'Avoid replacing instance root $data. ' +
+          'Use nested data properties instead.',
         this
-      );
-    };
+      )
+    }
     propsDef.set = function () {
-      warn(`$props is readonly.`, this);
-    };
+      warn(`$props is readonly.`, this)
+    }
   }
-  Object.defineProperty(Vue.prototype, "$data", dataDef);
-  Object.defineProperty(Vue.prototype, "$props", propsDef);
+  Object.defineProperty(Vue.prototype, '$data', dataDef)
+  Object.defineProperty(Vue.prototype, '$props', propsDef)
 
-  Vue.prototype.$set = set;
-  Vue.prototype.$delete = del;
+  Vue.prototype.$set = set
+  Vue.prototype.$delete = del
 
   Vue.prototype.$watch = function (
     expOrFn: string | Function,
     cb: any,
     options?: Record<string, any>
   ): Function {
-    const vm: Component = this;
+    const vm: Component = this
     if (isPlainObject(cb)) {
-      return createWatcher(vm, expOrFn, cb, options);
+      return createWatcher(vm, expOrFn, cb, options)
     }
-    options = options || {};
-    options.user = true;
-    const watcher = new Watcher(vm, expOrFn, cb, options);
+    options = options || {}
+    options.user = true
+    const watcher = new Watcher(vm, expOrFn, cb, options)
     if (options.immediate) {
-      const info = `callback for immediate watcher "${watcher.expression}"`;
-      pushTarget();
-      invokeWithErrorHandling(cb, vm, [watcher.value], vm, info);
-      popTarget();
+      const info = `callback for immediate watcher "${watcher.expression}"`
+      pushTarget()
+      invokeWithErrorHandling(cb, vm, [watcher.value], vm, info)
+      popTarget()
     }
     return function unwatchFn() {
-      watcher.teardown();
-    };
-  };
+      watcher.teardown()
+    }
+  }
 }
diff --git a/src/core/observer/array.ts b/src/core/observer/array.ts
index 1a59b511e24..c043d9dfe76 100644
--- a/src/core/observer/array.ts
+++ b/src/core/observer/array.ts
@@ -15,7 +15,7 @@ const methodsToPatch = [
   'unshift',
   'splice',
   'sort',
-  'reverse',
+  'reverse'
 ]
 
 /**
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index fca48d1ac74..f8bb1fa62a0 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -11,7 +11,7 @@ import {
   isPrimitive,
   isUndef,
   isValidArrayIndex,
-  isServerRendering,
+  isServerRendering
 } from '../util/index'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
@@ -187,7 +187,7 @@ export function defineReactive(
       }
       childOb = !shallow && observe(newVal)
       dep.notify()
-    },
+    }
   })
 }
 
@@ -196,7 +196,11 @@ export function defineReactive(
  * triggers change notification if the property doesn't
  * already exist.
  */
-export function set(target: Array<any> | Record<string,any>, key: any, val: any): any {
+export function set(
+  target: Array<any> | Record<string, any>,
+  key: any,
+  val: any
+): any {
   if (
     process.env.NODE_ENV !== 'production' &&
     (isUndef(target) || isPrimitive(target))
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index efeaec64c0e..3c2d0b7ea4a 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -1,4 +1,3 @@
-
 import type Watcher from './watcher'
 import config from '../config'
 import { callHook, activateChildComponent } from '../instance/lifecycle'
diff --git a/src/core/observer/traverse.ts b/src/core/observer/traverse.ts
index c52efe0ac89..14eca535bd9 100644
--- a/src/core/observer/traverse.ts
+++ b/src/core/observer/traverse.ts
@@ -1,4 +1,3 @@
-
 import { _Set as Set, isObject } from '../util/index'
 import type { SimpleSet } from '../util/index'
 import VNode from '../vdom/vnode'
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 5543d6d1e71..f5539372bfe 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -1,4 +1,3 @@
-
 import {
   warn,
   remove,
@@ -79,9 +78,8 @@ export default class Watcher {
     this.newDeps = []
     this.depIds = new Set()
     this.newDepIds = new Set()
-    this.expression = process.env.NODE_ENV !== 'production'
-      ? expOrFn.toString()
-      : ''
+    this.expression =
+      process.env.NODE_ENV !== 'production' ? expOrFn.toString() : ''
     // parse expression for getter
     if (typeof expOrFn === 'function') {
       this.getter = expOrFn
@@ -89,17 +87,16 @@ export default class Watcher {
       this.getter = parsePath(expOrFn)
       if (!this.getter) {
         this.getter = noop
-        process.env.NODE_ENV !== 'production' && warn(
-          `Failed watching path: "${expOrFn}" ` +
-          'Watcher only accepts simple dot-delimited paths. ' +
-          'For full control, use a function instead.',
-          vm
-        )
+        process.env.NODE_ENV !== 'production' &&
+          warn(
+            `Failed watching path: "${expOrFn}" ` +
+              'Watcher only accepts simple dot-delimited paths. ' +
+              'For full control, use a function instead.',
+            vm
+          )
       }
     }
-    this.value = this.lazy
-      ? undefined
-      : this.get()
+    this.value = this.lazy ? undefined : this.get()
   }
 
   /**
@@ -199,7 +196,13 @@ export default class Watcher {
         this.value = value
         if (this.user) {
           const info = `callback for watcher "${this.expression}"`
-          invokeWithErrorHandling(this.cb, this.vm, [value, oldValue], this.vm, info)
+          invokeWithErrorHandling(
+            this.cb,
+            this.vm,
+            [value, oldValue],
+            this.vm,
+            info
+          )
         } else {
           this.cb.call(this.vm, value, oldValue)
         }
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index ec42241abd2..f44fe86a277 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -1,4 +1,3 @@
-
 import config from '../config'
 import { noop } from 'shared/util'
 import type { Component } from 'typescript/component'
@@ -11,8 +10,8 @@ export let formatComponentName: (vm: Component, includeFile?: false) => string
 if (process.env.NODE_ENV !== 'production') {
   const hasConsole = typeof console !== 'undefined'
   const classifyRE = /(?:^|[-_])(\w)/g
-  const classify = (str) =>
-    str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, '')
+  const classify = str =>
+    str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '')
 
   warn = (msg, vm) => {
     const trace = vm ? generateComponentTrace(vm) : ''
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index 0aa9f6a8172..093e8731469 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -42,7 +42,7 @@ export function invokeWithErrorHandling(
   try {
     res = args ? handler.apply(context, args) : handler.call(context)
     if (res && !res._isVue && isPromise(res) && !res._handled) {
-      res.catch((e) => handleError(e, vm, info + ` (Promise/async)`))
+      res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
       // issue #9511
       // avoid catch triggering multiple times when nested calls
       res._handled = true
diff --git a/src/core/util/index.ts b/src/core/util/index.ts
index af73de55cb0..c47b8dbe937 100644
--- a/src/core/util/index.ts
+++ b/src/core/util/index.ts
@@ -1,4 +1,3 @@
-
 export * from 'shared/util'
 export * from './lang'
 export * from './env'
diff --git a/src/core/util/lang.ts b/src/core/util/lang.ts
index 2f49594b0b1..1d332f66027 100644
--- a/src/core/util/lang.ts
+++ b/src/core/util/lang.ts
@@ -1,10 +1,10 @@
-
 /**
  * unicode letters used for parsing html tags, component names and property paths.
  * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
  * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
  */
-export const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
+export const unicodeRegExp =
+  /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
 
 /**
  * Check if a string starts with $ or _
@@ -22,7 +22,7 @@ export function def(obj: Object, key: string, val: any, enumerable?: boolean) {
     value: val,
     enumerable: !!enumerable,
     writable: true,
-    configurable: true,
+    configurable: true
   })
 }
 
diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index 0bff7f44ed6..5d4670d2f75 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -64,7 +64,7 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
   const observer = new MutationObserver(flushCallbacks)
   const textNode = document.createTextNode(String(counter))
   observer.observe(textNode, {
-    characterData: true,
+    characterData: true
   })
   timerFunc = () => {
     counter = (counter + 1) % 2
@@ -104,7 +104,7 @@ export function nextTick(cb?: Function, ctx?: Object) {
   }
   // $flow-disable-line
   if (!cb && typeof Promise !== 'undefined') {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       _resolve = resolve
     })
   }
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index aeb2eaf2bbe..2850ad26edc 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -1,4 +1,3 @@
-
 import config from '../config'
 import { warn } from './debug'
 import { set } from '../observer/index'
@@ -14,7 +13,7 @@ import {
   toRawType,
   capitalize,
   isBuiltInTag,
-  isPlainObject,
+  isPlainObject
 } from 'shared/util'
 import type { Component } from 'typescript/component'
 import type { ComponentOptions } from 'typescript/options'
@@ -172,7 +171,7 @@ function dedupeHooks(hooks: any) {
   return res
 }
 
-LIFECYCLE_HOOKS.forEach((hook) => {
+LIFECYCLE_HOOKS.forEach(hook => {
   strats[hook] = mergeHook
 })
 
@@ -245,21 +244,25 @@ strats.watch = function (
 /**
  * Other object hashes.
  */
-strats.props = strats.methods = strats.inject = strats.computed = function (
-  parentVal: Object | null,
-  childVal: Object | null,
-  vm: Component | null,
-  key: string
-): Object | null {
-  if (childVal && process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm)
-  }
-  if (!parentVal) return childVal
-  const ret = Object.create(null)
-  extend(ret, parentVal)
-  if (childVal) extend(ret, childVal)
-  return ret
-}
+strats.props =
+  strats.methods =
+  strats.inject =
+  strats.computed =
+    function (
+      parentVal: Object | null,
+      childVal: Object | null,
+      vm: Component | null,
+      key: string
+    ): Object | null {
+      if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm)
+      }
+      if (!parentVal) return childVal
+      const ret = Object.create(null)
+      extend(ret, parentVal)
+      if (childVal) extend(ret, childVal)
+      return ret
+    }
 strats.provide = mergeDataOrFn
 
 /**
diff --git a/src/core/util/perf.ts b/src/core/util/perf.ts
index f8201ddb6ec..c0c8a277633 100644
--- a/src/core/util/perf.ts
+++ b/src/core/util/perf.ts
@@ -13,7 +13,7 @@ if (process.env.NODE_ENV !== 'production') {
     perf.clearMarks &&
     perf.clearMeasures
   ) {
-    mark = (tag) => perf.mark(tag)
+    mark = tag => perf.mark(tag)
     measure = (name, startTag, endTag) => {
       perf.measure(name, startTag, endTag)
       perf.clearMarks(startTag)
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index e25b47720dc..168d133b76f 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -128,7 +128,7 @@ function assertProp(
     }
   }
 
-  const haveExpectedTypes = expectedTypes.some((t) => t)
+  const haveExpectedTypes = expectedTypes.some(t => t)
   if (!valid && haveExpectedTypes) {
     warn(getInvalidTypeMessage(name, value, expectedTypes), vm)
     return
@@ -244,9 +244,9 @@ function styleValue(value, type) {
 
 const EXPLICABLE_TYPES = ['string', 'number', 'boolean']
 function isExplicable(value) {
-  return EXPLICABLE_TYPES.some((elem) => value.toLowerCase() === elem)
+  return EXPLICABLE_TYPES.some(elem => value.toLowerCase() === elem)
 }
 
 function isBoolean(...args) {
-  return args.some((elem) => elem.toLowerCase() === 'boolean')
+  return args.some(elem => elem.toLowerCase() === 'boolean')
 }
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 3958217cb0d..d35cd266173 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -1,4 +1,3 @@
-
 import VNode from './vnode'
 import { resolveConstructorOptions } from 'core/instance/init'
 import { queueActivatedComponent } from 'core/observer/scheduler'
@@ -9,7 +8,7 @@ import { warn, isDef, isUndef, isTrue, isObject } from '../util/index'
 import {
   resolveAsyncComponent,
   createAsyncPlaceholder,
-  extractPropsFromVNodeData,
+  extractPropsFromVNodeData
 } from './helpers/index'
 
 import {
@@ -17,13 +16,13 @@ import {
   activeInstance,
   updateChildComponent,
   activateChildComponent,
-  deactivateChildComponent,
+  deactivateChildComponent
 } from '../instance/lifecycle'
 
 import type {
   MountedComponentVNode,
   VNodeData,
-  VNodeWithData,
+  VNodeWithData
 } from 'typescript/vnode'
 import type { Component } from 'typescript/component'
 import type { InternalComponentOptions } from 'typescript/options'
@@ -89,7 +88,7 @@ const componentVNodeHooks = {
         deactivateChildComponent(componentInstance, true /* direct */)
       }
     }
-  },
+  }
 }
 
 const hooksToMerge = Object.keys(componentVNodeHooks)
@@ -214,7 +213,7 @@ export function createComponentInstanceForVnode(
   const options: InternalComponentOptions = {
     _isComponent: true,
     _parentVnode: vnode,
-    parent,
+    parent
   }
   // check inline-template render functions
   const inlineTemplate = vnode.data.inlineTemplate
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index 99915b764de..b5700949353 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -1,4 +1,3 @@
-
 import VNode, { cloneVNode } from './vnode'
 import { createElement } from './create-element'
 import { resolveInject } from '../instance/inject'
@@ -13,7 +12,7 @@ import {
   hasOwn,
   camelize,
   emptyObject,
-  validateProp,
+  validateProp
 } from '../util/index'
 import type { Component } from 'typescript/component'
 import type { VNodeData } from 'typescript/vnode'
@@ -64,7 +63,7 @@ export function FunctionalRenderContext(
     enumerable: true,
     get() {
       return normalizeScopedSlots(data.scopedSlots, this.slots())
-    },
+    }
   } as any)
 
   // support for compiled functional template
@@ -160,10 +159,11 @@ function cloneAndMarkFunctionalResult(
   clone.fnContext = contextVm
   clone.fnOptions = options
   if (process.env.NODE_ENV !== 'production') {
-    (clone.devtoolsMeta = clone.devtoolsMeta || {} as any).renderContext = renderContext
+    ;(clone.devtoolsMeta = clone.devtoolsMeta || ({} as any)).renderContext =
+      renderContext
   }
   if (data.slot) {
-    (clone.data || (clone.data = {})).slot = data.slot
+    ;(clone.data || (clone.data = {})).slot = data.slot
   }
   return clone
 }
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index 6a03bc4b73c..b68107df5f0 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -1,11 +1,10 @@
-
 import {
   tip,
   hasOwn,
   isDef,
   isUndef,
   hyphenate,
-  formatComponentName,
+  formatComponentName
 } from 'core/util/index'
 import type { Component } from 'typescript/component'
 import type { VNodeData } from 'typescript/vnode'
diff --git a/src/core/vdom/helpers/get-first-component-child.ts b/src/core/vdom/helpers/get-first-component-child.ts
index 23a8433ed35..ea3c7ec4e37 100644
--- a/src/core/vdom/helpers/get-first-component-child.ts
+++ b/src/core/vdom/helpers/get-first-component-child.ts
@@ -1,4 +1,3 @@
-
 import { isDef } from 'shared/util'
 import VNode from '../vnode'
 import { isAsyncPlaceholder } from './is-async-placeholder'
diff --git a/src/core/vdom/helpers/index.ts b/src/core/vdom/helpers/index.ts
index 50d719e8537..12a72ee848b 100644
--- a/src/core/vdom/helpers/index.ts
+++ b/src/core/vdom/helpers/index.ts
@@ -1,4 +1,3 @@
-
 export * from './merge-hook'
 export * from './extract-props'
 export * from './update-listeners'
diff --git a/src/core/vdom/helpers/is-async-placeholder.ts b/src/core/vdom/helpers/is-async-placeholder.ts
index fe2e12b8a9f..6e0d602758b 100644
--- a/src/core/vdom/helpers/is-async-placeholder.ts
+++ b/src/core/vdom/helpers/is-async-placeholder.ts
@@ -1,4 +1,3 @@
-
 import VNode from '../vnode'
 
 export function isAsyncPlaceholder(node: VNode): boolean {
diff --git a/src/core/vdom/helpers/merge-hook.ts b/src/core/vdom/helpers/merge-hook.ts
index 6c846653126..6881f914170 100644
--- a/src/core/vdom/helpers/merge-hook.ts
+++ b/src/core/vdom/helpers/merge-hook.ts
@@ -1,4 +1,3 @@
-
 import VNode from '../vnode'
 import { createFnInvoker } from './update-listeners'
 import { remove, isDef, isUndef, isTrue } from 'shared/util'
diff --git a/src/core/vdom/helpers/normalize-children.ts b/src/core/vdom/helpers/normalize-children.ts
index b9bb12dd8f5..521bb9cc120 100644
--- a/src/core/vdom/helpers/normalize-children.ts
+++ b/src/core/vdom/helpers/normalize-children.ts
@@ -1,4 +1,3 @@
-
 import VNode, { createTextVNode } from 'core/vdom/vnode'
 import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
 
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index ecba4d691d8..afc5299a342 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -1,23 +1,23 @@
-import { def } from "core/util/lang";
-import { normalizeChildren } from "core/vdom/helpers/normalize-children";
-import { emptyObject } from "shared/util";
-import { isAsyncPlaceholder } from "./is-async-placeholder";
-import type VNode from "../vnode";
+import { def } from 'core/util/lang'
+import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
+import { emptyObject } from 'shared/util'
+import { isAsyncPlaceholder } from './is-async-placeholder'
+import type VNode from '../vnode'
 
 export function normalizeScopedSlots(
   slots: { [key: string]: Function } | void,
   normalSlots: { [key: string]: Array<VNode> },
   prevSlots?: { [key: string]: Function } | void
 ): any {
-  let res;
-  const hasNormalSlots = Object.keys(normalSlots).length > 0;
-  const isStable = slots ? !!slots.$stable : !hasNormalSlots;
-  const key = slots && slots.$key;
+  let res
+  const hasNormalSlots = Object.keys(normalSlots).length > 0
+  const isStable = slots ? !!slots.$stable : !hasNormalSlots
+  const key = slots && slots.$key
   if (!slots) {
-    res = {};
+    res = {}
   } else if (slots._normalized) {
     // fast path 1: child component re-render only, parent did not change
-    return slots._normalized;
+    return slots._normalized
   } else if (
     isStable &&
     prevSlots &&
@@ -28,46 +28,46 @@ export function normalizeScopedSlots(
   ) {
     // fast path 2: stable scoped slots w/ no normal slots to proxy,
     // only need to normalize once
-    return prevSlots;
+    return prevSlots
   } else {
-    res = {};
+    res = {}
     for (const key in slots) {
-      if (slots[key] && key[0] !== "$") {
-        res[key] = normalizeScopedSlot(normalSlots, key, slots[key]);
+      if (slots[key] && key[0] !== '$') {
+        res[key] = normalizeScopedSlot(normalSlots, key, slots[key])
       }
     }
   }
   // expose normal slots on scopedSlots
   for (const key in normalSlots) {
     if (!(key in res)) {
-      res[key] = proxyNormalSlot(normalSlots, key);
+      res[key] = proxyNormalSlot(normalSlots, key)
     }
   }
   // avoriaz seems to mock a non-extensible $scopedSlots object
   // and when that is passed down this would cause an error
   if (slots && Object.isExtensible(slots)) {
-    slots._normalized = res;
+    slots._normalized = res
   }
-  def(res, "$stable", isStable);
-  def(res, "$key", key);
-  def(res, "$hasNormal", hasNormalSlots);
-  return res;
+  def(res, '$stable', isStable)
+  def(res, '$key', key)
+  def(res, '$hasNormal', hasNormalSlots)
+  return res
 }
 
 function normalizeScopedSlot(normalSlots, key, fn) {
   const normalized = function () {
-    let res = arguments.length ? fn.apply(null, arguments) : fn({});
+    let res = arguments.length ? fn.apply(null, arguments) : fn({})
     res =
-      res && typeof res === "object" && !Array.isArray(res)
+      res && typeof res === 'object' && !Array.isArray(res)
         ? [res] // single vnode
-        : normalizeChildren(res);
-    const vnode: VNode | null = res && res[0];
+        : normalizeChildren(res)
+    const vnode: VNode | null = res && res[0]
     return res &&
       (!vnode ||
         (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
       ? undefined
-      : res;
-  };
+      : res
+  }
   // this is a slot using the new v-slot syntax without scope. although it is
   // compiled as a scoped slot, render fn users would expect it to be present
   // on this.$slots because the usage is semantically a normal slot.
@@ -75,12 +75,12 @@ function normalizeScopedSlot(normalSlots, key, fn) {
     Object.defineProperty(normalSlots, key, {
       get: normalized,
       enumerable: true,
-      configurable: true,
-    });
+      configurable: true
+    })
   }
-  return normalized;
+  return normalized
 }
 
 function proxyNormalSlot(slots, key) {
-  return () => slots[key];
+  return () => slots[key]
 }
diff --git a/src/core/vdom/helpers/resolve-async-component.ts b/src/core/vdom/helpers/resolve-async-component.ts
index c3d7c61c34f..4b965b3cfde 100644
--- a/src/core/vdom/helpers/resolve-async-component.ts
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -1,4 +1,3 @@
-
 import {
   warn,
   once,
@@ -8,7 +7,7 @@ import {
   isObject,
   hasSymbol,
   isPromise,
-  remove,
+  remove
 } from 'core/util/index'
 
 import VNode, { createEmptyVNode } from 'core/vdom/vnode'
@@ -96,7 +95,7 @@ export function resolveAsyncComponent(
       }
     })
 
-    const reject = once((reason) => {
+    const reject = once(reason => {
       process.env.NODE_ENV !== 'production' &&
         warn(
           `Failed to resolve async component: ${String(factory)}` +
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index 4bc2dbbaf5e..801cbe9a6ec 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -2,27 +2,31 @@ import { warn, invokeWithErrorHandling } from 'core/util/index'
 import { cached, isUndef, isTrue } from 'shared/util'
 import type { Component } from 'typescript/component'
 
-const normalizeEvent = cached((name: string): {
-  name: string
-  once: boolean
-  capture: boolean
-  passive: boolean
-  handler?: Function
-  params?: Array<any>
-} => {
-  const passive = name.charAt(0) === '&'
-  name = passive ? name.slice(1) : name
-  const once = name.charAt(0) === '~' // Prefixed last, checked first
-  name = once ? name.slice(1) : name
-  const capture = name.charAt(0) === '!'
-  name = capture ? name.slice(1) : name
-  return {
-    name,
-    once,
-    capture,
-    passive,
+const normalizeEvent = cached(
+  (
+    name: string
+  ): {
+    name: string
+    once: boolean
+    capture: boolean
+    passive: boolean
+    handler?: Function
+    params?: Array<any>
+  } => {
+    const passive = name.charAt(0) === '&'
+    name = passive ? name.slice(1) : name
+    const once = name.charAt(0) === '~' // Prefixed last, checked first
+    name = once ? name.slice(1) : name
+    const capture = name.charAt(0) === '!'
+    name = capture ? name.slice(1) : name
+    return {
+      name,
+      once,
+      capture,
+      passive
+    }
   }
-})
+)
 
 export function createFnInvoker(
   fns: Function | Array<Function>,
diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 302f1746d0f..0ba2d9d0e0e 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -1,4 +1,3 @@
-
 import { emptyNode } from 'core/vdom/patch'
 import { resolveAsset, handleError } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
@@ -11,7 +10,7 @@ export default {
   destroy: function unbindDirectives(vnode: VNodeWithData) {
     // @ts-expect-error emptyNode is not VNodeWithData
     updateDirectives(vnode, emptyNode)
-  },
+  }
 }
 
 function updateDirectives(oldVnode: VNodeWithData, vnode: VNodeWithData) {
diff --git a/src/core/vdom/modules/ref.ts b/src/core/vdom/modules/ref.ts
index f6651b905fc..a161b727915 100644
--- a/src/core/vdom/modules/ref.ts
+++ b/src/core/vdom/modules/ref.ts
@@ -1,44 +1,44 @@
-import { remove, isDef } from "shared/util";
-import type { VNodeWithData } from "typescript/vnode";
+import { remove, isDef } from 'shared/util'
+import type { VNodeWithData } from 'typescript/vnode'
 
 export default {
   create(_: any, vnode: VNodeWithData) {
-    registerRef(vnode);
+    registerRef(vnode)
   },
   update(oldVnode: VNodeWithData, vnode: VNodeWithData) {
     if (oldVnode.data.ref !== vnode.data.ref) {
-      registerRef(oldVnode, true);
-      registerRef(vnode);
+      registerRef(oldVnode, true)
+      registerRef(vnode)
     }
   },
   destroy(vnode: VNodeWithData) {
-    registerRef(vnode, true);
-  },
-};
+    registerRef(vnode, true)
+  }
+}
 
 export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
-  const key = vnode.data.ref;
-  if (!isDef(key)) return;
+  const key = vnode.data.ref
+  if (!isDef(key)) return
 
-  const vm = vnode.context;
-  const ref = vnode.componentInstance || vnode.elm;
-  const refs = vm.$refs;
-  const obj = refs[key];
+  const vm = vnode.context
+  const ref = vnode.componentInstance || vnode.elm
+  const refs = vm.$refs
+  const obj = refs[key]
   if (isRemoval) {
     if (Array.isArray(obj)) {
-      remove(obj, ref);
+      remove(obj, ref)
     } else if (obj === ref) {
-      refs[key] = undefined;
+      refs[key] = undefined
     }
   } else {
     if (vnode.data.refInFor) {
       if (!Array.isArray(obj)) {
-        refs[key] = [ref];
+        refs[key] = [ref]
       } else if (obj.indexOf(ref) < 0) {
-        obj.push(ref);
+        obj.push(ref)
       }
     } else {
-      refs[key] = ref;
+      refs[key] = ref
     }
   }
 }
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index 4c5fd4acd42..ec47e2c36a1 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -25,7 +25,7 @@ import {
   isTrue,
   makeMap,
   isRegExp,
-  isPrimitive,
+  isPrimitive
 } from '../util/index'
 
 export const emptyNode = new VNode('', {}, [])
@@ -35,17 +35,12 @@ const hooks = ['create', 'activate', 'update', 'remove', 'destroy']
 function sameVnode(a, b) {
   return (
     a.key === b.key &&
-    a.asyncFactory === b.asyncFactory && (
-      (
-        a.tag === b.tag &&
-        a.isComment === b.isComment &&
-        isDef(a.data) === isDef(b.data) &&
-        sameInputType(a, b)
-      ) || (
-        isTrue(a.isAsyncPlaceholder) &&
-        isUndef(b.asyncFactory.error)
-      )
-    )
+    a.asyncFactory === b.asyncFactory &&
+    ((a.tag === b.tag &&
+      a.isComment === b.isComment &&
+      isDef(a.data) === isDef(b.data) &&
+      sameInputType(a, b)) ||
+      (isTrue(a.isAsyncPlaceholder) && isUndef(b.asyncFactory.error)))
   )
 }
 
@@ -110,7 +105,7 @@ export function createPatchFunction(backend) {
       !vnode.ns &&
       !(
         config.ignoredElements.length &&
-        config.ignoredElements.some((ignore) => {
+        config.ignoredElements.some(ignore => {
           return isRegExp(ignore)
             ? ignore.test(vnode.tag)
             : ignore === vnode.tag
diff --git a/src/core/vdom/vnode.ts b/src/core/vdom/vnode.ts
index 93bab1012fa..39fa2833315 100644
--- a/src/core/vdom/vnode.ts
+++ b/src/core/vdom/vnode.ts
@@ -1,35 +1,35 @@
-import type { Component } from "typescript/component";
-import type { ComponentOptions } from "typescript/options";
-import type { VNodeComponentOptions, VNodeData } from "typescript/vnode";
+import type { Component } from 'typescript/component'
+import type { ComponentOptions } from 'typescript/options'
+import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
 
 export default class VNode {
-  tag?: string;
-  data: VNodeData | undefined;
-  children?: Array<VNode> | null;
-  text?: string;
-  elm: Node | undefined;
-  ns?: string;
-  context?: Component; // rendered in this component's scope
-  key: string | number | undefined;
-  componentOptions?: VNodeComponentOptions;
-  componentInstance?: Component; // component instance
-  parent: VNode | undefined | null; // component placeholder node
+  tag?: string
+  data: VNodeData | undefined
+  children?: Array<VNode> | null
+  text?: string
+  elm: Node | undefined
+  ns?: string
+  context?: Component // rendered in this component's scope
+  key: string | number | undefined
+  componentOptions?: VNodeComponentOptions
+  componentInstance?: Component // component instance
+  parent: VNode | undefined | null // component placeholder node
 
   // strictly internal
-  raw: boolean; // contains raw HTML? (server only)
-  isStatic: boolean; // hoisted static node
-  isRootInsert: boolean; // necessary for enter transition check
-  isComment: boolean; // empty comment placeholder?
-  isCloned: boolean; // is a cloned node?
-  isOnce: boolean; // is a v-once node?
-  asyncFactory?: Function; // async component factory function
-  asyncMeta: Object | void;
-  isAsyncPlaceholder: boolean;
-  ssrContext?: Object | void;
-  fnContext: Component | void; // real context vm for functional nodes
-  fnOptions?: ComponentOptions | null; // for SSR caching
-  devtoolsMeta?: Object | null; // used to store functional render context for devtools
-  fnScopeId?: string | null; // functional scope id support
+  raw: boolean // contains raw HTML? (server only)
+  isStatic: boolean // hoisted static node
+  isRootInsert: boolean // necessary for enter transition check
+  isComment: boolean // empty comment placeholder?
+  isCloned: boolean // is a cloned node?
+  isOnce: boolean // is a v-once node?
+  asyncFactory?: Function // async component factory function
+  asyncMeta: Object | void
+  isAsyncPlaceholder: boolean
+  ssrContext?: Object | void
+  fnContext: Component | void // real context vm for functional nodes
+  fnOptions?: ComponentOptions | null // for SSR caching
+  devtoolsMeta?: Object | null // used to store functional render context for devtools
+  fnScopeId?: string | null // functional scope id support
 
   constructor(
     tag?: string,
@@ -41,47 +41,47 @@ export default class VNode {
     componentOptions?: VNodeComponentOptions,
     asyncFactory?: Function
   ) {
-    this.tag = tag;
-    this.data = data;
-    this.children = children;
-    this.text = text;
-    this.elm = elm;
-    this.ns = undefined;
-    this.context = context;
-    this.fnContext = undefined;
-    this.fnOptions = undefined;
-    this.fnScopeId = undefined;
-    this.key = data && data.key;
-    this.componentOptions = componentOptions;
-    this.componentInstance = undefined;
-    this.parent = undefined;
-    this.raw = false;
-    this.isStatic = false;
-    this.isRootInsert = true;
-    this.isComment = false;
-    this.isCloned = false;
-    this.isOnce = false;
-    this.asyncFactory = asyncFactory;
-    this.asyncMeta = undefined;
-    this.isAsyncPlaceholder = false;
+    this.tag = tag
+    this.data = data
+    this.children = children
+    this.text = text
+    this.elm = elm
+    this.ns = undefined
+    this.context = context
+    this.fnContext = undefined
+    this.fnOptions = undefined
+    this.fnScopeId = undefined
+    this.key = data && data.key
+    this.componentOptions = componentOptions
+    this.componentInstance = undefined
+    this.parent = undefined
+    this.raw = false
+    this.isStatic = false
+    this.isRootInsert = true
+    this.isComment = false
+    this.isCloned = false
+    this.isOnce = false
+    this.asyncFactory = asyncFactory
+    this.asyncMeta = undefined
+    this.isAsyncPlaceholder = false
   }
 
   // DEPRECATED: alias for componentInstance for backwards compat.
   /* istanbul ignore next */
   get child(): Component | void {
-    return this.componentInstance;
+    return this.componentInstance
   }
 }
 
-export const createEmptyVNode = (text: string = "") => {
-  const node = new VNode();
-  node.text = text;
-  node.isComment = true;
-  return node;
-};
+export const createEmptyVNode = (text: string = '') => {
+  const node = new VNode()
+  node.text = text
+  node.isComment = true
+  return node
+}
 
 export function createTextVNode(val: string | number) {
-  return new VNode(undefined, undefined, undefined, String(val));
+  return new VNode(undefined, undefined, undefined, String(val))
 }
 
 // optimized shallow clone
@@ -101,15 +101,15 @@ export function cloneVNode(vnode: VNode): VNode {
     vnode.context,
     vnode.componentOptions,
     vnode.asyncFactory
-  );
-  cloned.ns = vnode.ns;
-  cloned.isStatic = vnode.isStatic;
-  cloned.key = vnode.key;
-  cloned.isComment = vnode.isComment;
-  cloned.fnContext = vnode.fnContext;
-  cloned.fnOptions = vnode.fnOptions;
-  cloned.fnScopeId = vnode.fnScopeId;
-  cloned.asyncMeta = vnode.asyncMeta;
-  cloned.isCloned = true;
-  return cloned;
+  )
+  cloned.ns = vnode.ns
+  cloned.isStatic = vnode.isStatic
+  cloned.key = vnode.key
+  cloned.isComment = vnode.isComment
+  cloned.fnContext = vnode.fnContext
+  cloned.fnOptions = vnode.fnOptions
+  cloned.fnScopeId = vnode.fnScopeId
+  cloned.asyncMeta = vnode.asyncMeta
+  cloned.isCloned = true
+  return cloned
 }
diff --git a/src/global.d.ts b/src/global.d.ts
index 1bdbeafea43..0fabe95c676 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,5 +1,5 @@
 interface Window {
-  __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook;
+  __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook
 }
 
 // from https://github.com/vuejs/vue-devtools/blob/bc719c95a744614f5c3693460b64dc21dfa339a8/packages/app-backend-api/src/global-hook.ts#L3
diff --git a/src/platforms/web/compiler/directives/html.ts b/src/platforms/web/compiler/directives/html.ts
index b12be5e616f..af6dd62dc33 100644
--- a/src/platforms/web/compiler/directives/html.ts
+++ b/src/platforms/web/compiler/directives/html.ts
@@ -1,4 +1,3 @@
-
 import { addProp } from 'compiler/helpers'
 
 export default function html(el: ASTElement, dir: ASTDirective) {
diff --git a/src/platforms/web/compiler/directives/index.ts b/src/platforms/web/compiler/directives/index.ts
index 2473ae1a735..0955b51e7aa 100644
--- a/src/platforms/web/compiler/directives/index.ts
+++ b/src/platforms/web/compiler/directives/index.ts
@@ -5,5 +5,5 @@ import html from './html'
 export default {
   model,
   text,
-  html,
+  html
 }
diff --git a/src/platforms/web/compiler/directives/model.ts b/src/platforms/web/compiler/directives/model.ts
index 82892dc26e2..8dd3ed4a2b9 100644
--- a/src/platforms/web/compiler/directives/model.ts
+++ b/src/platforms/web/compiler/directives/model.ts
@@ -1,4 +1,3 @@
-
 import config from 'core/config'
 import { addHandler, addProp, getBindingAttr } from 'compiler/helpers'
 import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
diff --git a/src/platforms/web/compiler/directives/text.ts b/src/platforms/web/compiler/directives/text.ts
index 1502797c477..9cb39d1180c 100644
--- a/src/platforms/web/compiler/directives/text.ts
+++ b/src/platforms/web/compiler/directives/text.ts
@@ -1,4 +1,3 @@
-
 import { addProp } from 'compiler/helpers'
 
 export default function text(el: ASTElement, dir: ASTDirective) {
diff --git a/src/platforms/web/compiler/index.ts b/src/platforms/web/compiler/index.ts
index 5e50ce90c86..857351f15f5 100644
--- a/src/platforms/web/compiler/index.ts
+++ b/src/platforms/web/compiler/index.ts
@@ -1,4 +1,3 @@
-
 import { baseOptions } from './options'
 import { createCompiler } from 'compiler/index'
 
diff --git a/src/platforms/web/compiler/modules/class.ts b/src/platforms/web/compiler/modules/class.ts
index 347b386ef8e..4789c3d09b5 100644
--- a/src/platforms/web/compiler/modules/class.ts
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -1,4 +1,3 @@
-
 import { parseText } from 'compiler/parser/text-parser'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 
@@ -40,5 +39,5 @@ function genData(el: ASTElement): string {
 export default {
   staticKeys: ['staticClass'],
   transformNode,
-  genData,
+  genData
 } as ModuleOptions
diff --git a/src/platforms/web/compiler/modules/model.ts b/src/platforms/web/compiler/modules/model.ts
index d55d08b5fcc..63c6f83fcfd 100644
--- a/src/platforms/web/compiler/modules/model.ts
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -1,4 +1,3 @@
-
 /**
  * Expand input[v-model] with dynamic type bindings into v-if-else chains
  * Turn this:
@@ -15,7 +14,7 @@ import {
   processFor,
   processElement,
   addIfCondition,
-  createASTElement,
+  createASTElement
 } from 'compiler/parser/index'
 
 function preTransformNode(el: ASTElement, options: CompilerOptions) {
@@ -48,7 +47,7 @@ function preTransformNode(el: ASTElement, options: CompilerOptions) {
       branch0.if = `(${typeBinding})==='checkbox'` + ifConditionExtra
       addIfCondition(branch0, {
         exp: branch0.if,
-        block: branch0,
+        block: branch0
       })
       // 2. add radio else-if condition
       const branch1 = cloneASTElement(el)
@@ -57,7 +56,7 @@ function preTransformNode(el: ASTElement, options: CompilerOptions) {
       processElement(branch1, options)
       addIfCondition(branch0, {
         exp: `(${typeBinding})==='radio'` + ifConditionExtra,
-        block: branch1,
+        block: branch1
       })
       // 3. other
       const branch2 = cloneASTElement(el)
@@ -66,7 +65,7 @@ function preTransformNode(el: ASTElement, options: CompilerOptions) {
       processElement(branch2, options)
       addIfCondition(branch0, {
         exp: ifCondition!,
-        block: branch2,
+        block: branch2
       })
 
       if (hasElse) {
@@ -85,5 +84,5 @@ function cloneASTElement(el) {
 }
 
 export default {
-  preTransformNode,
+  preTransformNode
 } as ModuleOptions
diff --git a/src/platforms/web/compiler/modules/style.ts b/src/platforms/web/compiler/modules/style.ts
index 833a40d3d5c..8daf3b66df9 100644
--- a/src/platforms/web/compiler/modules/style.ts
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -1,4 +1,3 @@
-
 import { parseText } from 'compiler/parser/text-parser'
 import { parseStyleText } from 'web/util/style'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
@@ -43,5 +42,5 @@ function genData(el: ASTElement): string {
 export default {
   staticKeys: ['staticStyle'],
   transformNode,
-  genData,
+  genData
 } as ModuleOptions
diff --git a/src/platforms/web/compiler/options.ts b/src/platforms/web/compiler/options.ts
index edbc1fdac34..86653884800 100644
--- a/src/platforms/web/compiler/options.ts
+++ b/src/platforms/web/compiler/options.ts
@@ -2,13 +2,13 @@ import {
   isPreTag,
   mustUseProp,
   isReservedTag,
-  getTagNamespace,
-} from "../util/index";
+  getTagNamespace
+} from '../util/index'
 
-import modules from "./modules/index";
-import directives from "./directives/index";
-import { genStaticKeys } from "shared/util";
-import { isUnaryTag, canBeLeftOpenTag } from "./util";
+import modules from './modules/index'
+import directives from './directives/index'
+import { genStaticKeys } from 'shared/util'
+import { isUnaryTag, canBeLeftOpenTag } from './util'
 
 export const baseOptions: CompilerOptions = {
   expectHTML: true,
@@ -20,5 +20,5 @@ export const baseOptions: CompilerOptions = {
   canBeLeftOpenTag,
   isReservedTag,
   getTagNamespace,
-  staticKeys: genStaticKeys(modules),
-};
+  staticKeys: genStaticKeys(modules)
+}
diff --git a/src/platforms/web/compiler/util.ts b/src/platforms/web/compiler/util.ts
index b1412c07475..097e0a47c97 100644
--- a/src/platforms/web/compiler/util.ts
+++ b/src/platforms/web/compiler/util.ts
@@ -1,4 +1,3 @@
-
 import { makeMap } from 'shared/util'
 
 export const isUnaryTag = makeMap(
diff --git a/src/platforms/web/entry-compiler.ts b/src/platforms/web/entry-compiler.ts
index b14a1f699fe..f1f6aec4052 100644
--- a/src/platforms/web/entry-compiler.ts
+++ b/src/platforms/web/entry-compiler.ts
@@ -1,4 +1,3 @@
-
 export { parseComponent } from 'sfc/parser'
 export { compile, compileToFunctions } from './compiler/index'
 export { ssrCompile, ssrCompileToFunctions } from './server/compiler'
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index 8ac91a4e1bd..7d11b79fb96 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -7,12 +7,12 @@ import { query } from './util/index'
 import { compileToFunctions } from './compiler/index'
 import {
   shouldDecodeNewlines,
-  shouldDecodeNewlinesForHref,
+  shouldDecodeNewlinesForHref
 } from './util/compat'
 import type { Component } from 'typescript/component'
 import type { GlobalAPI } from 'typescript/global-api'
 
-const idToTemplate = cached((id) => {
+const idToTemplate = cached(id => {
   const el = query(id)
   return el && el.innerHTML
 })
@@ -74,7 +74,7 @@ Vue.prototype.$mount = function (
           shouldDecodeNewlines,
           shouldDecodeNewlinesForHref,
           delimiters: options.delimiters,
-          comments: options.comments,
+          comments: options.comments
         },
         this
       )
diff --git a/src/platforms/web/entry-runtime.ts b/src/platforms/web/entry-runtime.ts
index 0ce6019264f..0251259b0bd 100644
--- a/src/platforms/web/entry-runtime.ts
+++ b/src/platforms/web/entry-runtime.ts
@@ -1,4 +1,3 @@
-
 import Vue from './runtime/index'
 
 export default Vue
diff --git a/src/platforms/web/entry-server-basic-renderer.ts b/src/platforms/web/entry-server-basic-renderer.ts
index 9c6d3175f5d..2f965eb66cc 100644
--- a/src/platforms/web/entry-server-basic-renderer.ts
+++ b/src/platforms/web/entry-server-basic-renderer.ts
@@ -1,4 +1,3 @@
-
 import modules from './server/modules/index'
 import directives from './server/directives/index'
 import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
@@ -9,5 +8,5 @@ export default createBasicRenderer({
   modules,
   directives,
   isUnaryTag,
-  canBeLeftOpenTag,
+  canBeLeftOpenTag
 })
diff --git a/src/platforms/web/entry-server-renderer.ts b/src/platforms/web/entry-server-renderer.ts
index d0e7f8fb00c..10d09d3680b 100644
--- a/src/platforms/web/entry-server-renderer.ts
+++ b/src/platforms/web/entry-server-renderer.ts
@@ -1,4 +1,3 @@
-
 process.env.VUE_ENV = 'server'
 
 import { extend } from 'shared/util'
@@ -9,7 +8,7 @@ import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
 import {
   createRenderer as _createRenderer,
   Renderer,
-  RenderOptions,
+  RenderOptions
 } from 'server/create-renderer'
 import { createBundleRendererCreator } from 'server/bundle-renderer/create-bundle-renderer'
 
@@ -23,7 +22,7 @@ export function createRenderer(
       modules,
       // user can provide server-side implementations for custom directives
       // when creating the renderer.
-      directives: extend(baseDirectives, options.directives),
+      directives: extend(baseDirectives, options.directives)
     })
   )
 }
diff --git a/src/platforms/web/runtime/class-util.ts b/src/platforms/web/runtime/class-util.ts
index b24cce0d9b2..e66ffae5878 100644
--- a/src/platforms/web/runtime/class-util.ts
+++ b/src/platforms/web/runtime/class-util.ts
@@ -1,4 +1,3 @@
-
 const whitespaceRE = /\s+/
 
 /**
@@ -14,7 +13,7 @@ export function addClass(el: HTMLElement, cls?: string) {
   /* istanbul ignore else */
   if (el.classList) {
     if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach((c) => el.classList.add(c))
+      cls.split(whitespaceRE).forEach(c => el.classList.add(c))
     } else {
       el.classList.add(cls)
     }
@@ -39,7 +38,7 @@ export function removeClass(el: HTMLElement, cls?: string) {
   /* istanbul ignore else */
   if (el.classList) {
     if (cls.indexOf(' ') > -1) {
-      cls.split(whitespaceRE).forEach((c) => el.classList.remove(c))
+      cls.split(whitespaceRE).forEach(c => el.classList.remove(c))
     } else {
       el.classList.remove(cls)
     }
diff --git a/src/platforms/web/runtime/components/index.ts b/src/platforms/web/runtime/components/index.ts
index cbbaa132aaa..6bfe5780a5a 100644
--- a/src/platforms/web/runtime/components/index.ts
+++ b/src/platforms/web/runtime/components/index.ts
@@ -3,5 +3,5 @@ import TransitionGroup from './transition-group'
 
 export default {
   Transition,
-  TransitionGroup,
+  TransitionGroup
 }
diff --git a/src/platforms/web/runtime/components/transition-group.ts b/src/platforms/web/runtime/components/transition-group.ts
index d62318ed2fb..664d3c4599d 100644
--- a/src/platforms/web/runtime/components/transition-group.ts
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -9,195 +9,195 @@
 // into the final desired state. This way in the second pass removed
 // nodes will remain where they should be.
 
-import { warn, extend } from "core/util/index";
-import { addClass, removeClass } from "web/runtime/class-util";
-import { transitionProps, extractTransitionData } from "./transition";
-import { setActiveInstance } from "core/instance/lifecycle";
+import { warn, extend } from 'core/util/index'
+import { addClass, removeClass } from 'web/runtime/class-util'
+import { transitionProps, extractTransitionData } from './transition'
+import { setActiveInstance } from 'core/instance/lifecycle'
 
 import {
   hasTransition,
   getTransitionInfo,
   transitionEndEvent,
   addTransitionClass,
-  removeTransitionClass,
-} from "web/runtime/transition-util";
-import VNode from "core/vdom/vnode";
-import { VNodeWithData } from "typescript/vnode";
+  removeTransitionClass
+} from 'web/runtime/transition-util'
+import VNode from 'core/vdom/vnode'
+import { VNodeWithData } from 'typescript/vnode'
 
 const props = extend(
   {
     tag: String,
-    moveClass: String,
+    moveClass: String
   },
   transitionProps
-);
+)
 
-delete props.mode;
+delete props.mode
 
 export default {
   props,
 
   beforeMount() {
-    const update = this._update;
+    const update = this._update
     this._update = (vnode, hydrating) => {
-      const restoreActiveInstance = setActiveInstance(this);
+      const restoreActiveInstance = setActiveInstance(this)
       // force removing pass
       this.__patch__(
         this._vnode,
         this.kept,
         false, // hydrating
         true // removeOnly (!important, avoids unnecessary moves)
-      );
-      this._vnode = this.kept;
-      restoreActiveInstance();
-      update.call(this, vnode, hydrating);
-    };
+      )
+      this._vnode = this.kept
+      restoreActiveInstance()
+      update.call(this, vnode, hydrating)
+    }
   },
 
   render(h: Function) {
-    const tag: string = this.tag || this.$vnode.data.tag || "span";
-    const map: Record<string, any> = Object.create(null);
-    const prevChildren: Array<VNode> = (this.prevChildren = this.children);
-    const rawChildren: Array<VNode> = this.$slots.default || [];
-    const children: Array<VNode> = (this.children = []);
-    const transitionData = extractTransitionData(this);
+    const tag: string = this.tag || this.$vnode.data.tag || 'span'
+    const map: Record<string, any> = Object.create(null)
+    const prevChildren: Array<VNode> = (this.prevChildren = this.children)
+    const rawChildren: Array<VNode> = this.$slots.default || []
+    const children: Array<VNode> = (this.children = [])
+    const transitionData = extractTransitionData(this)
 
     for (let i = 0; i < rawChildren.length; i++) {
-      const c: VNode = rawChildren[i];
+      const c: VNode = rawChildren[i]
       if (c.tag) {
-        if (c.key != null && String(c.key).indexOf("__vlist") !== 0) {
-          children.push(c);
-          map[c.key] = c;
-          (c.data || (c.data = {})).transition = transitionData;
-        } else if (process.env.NODE_ENV !== "production") {
-          const opts = c.componentOptions;
+        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
+          children.push(c)
+          map[c.key] = c
+          ;(c.data || (c.data = {})).transition = transitionData
+        } else if (process.env.NODE_ENV !== 'production') {
+          const opts = c.componentOptions
           const name: string = opts
-            ? opts.Ctor.options.name || opts.tag || ""
-            : c.tag;
-          warn(`<transition-group> children must be keyed: <${name}>`);
+            ? opts.Ctor.options.name || opts.tag || ''
+            : c.tag
+          warn(`<transition-group> children must be keyed: <${name}>`)
         }
       }
     }
 
     if (prevChildren) {
-      const kept: Array<VNode> = [];
-      const removed: Array<VNode> = [];
+      const kept: Array<VNode> = []
+      const removed: Array<VNode> = []
       for (let i = 0; i < prevChildren.length; i++) {
-        const c: VNode = prevChildren[i];
-        c.data!.transition = transitionData;
+        const c: VNode = prevChildren[i]
+        c.data!.transition = transitionData
         // @ts-expect-error .getBoundingClientRect is not typed in Node
-        c.data!.pos = c.elm.getBoundingClientRect();
+        c.data!.pos = c.elm.getBoundingClientRect()
         if (map[c.key!]) {
-          kept.push(c);
+          kept.push(c)
         } else {
-          removed.push(c);
+          removed.push(c)
         }
       }
-      this.kept = h(tag, null, kept);
-      this.removed = removed;
+      this.kept = h(tag, null, kept)
+      this.removed = removed
     }
 
-    return h(tag, null, children);
+    return h(tag, null, children)
   },
 
   updated() {
-    const children: Array<VNodeWithData> = this.prevChildren;
-    const moveClass: string = this.moveClass || (this.name || "v") + "-move";
+    const children: Array<VNodeWithData> = this.prevChildren
+    const moveClass: string = this.moveClass || (this.name || 'v') + '-move'
     if (!children.length || !this.hasMove(children[0].elm, moveClass)) {
-      return;
+      return
     }
 
     // we divide the work into three loops to avoid mixing DOM reads and writes
     // in each iteration - which helps prevent layout thrashing.
-    children.forEach(callPendingCbs);
-    children.forEach(recordPosition);
-    children.forEach(applyTranslation);
+    children.forEach(callPendingCbs)
+    children.forEach(recordPosition)
+    children.forEach(applyTranslation)
 
     // force reflow to put everything in position
     // assign to this to avoid being removed in tree-shaking
     // $flow-disable-line
-    this._reflow = document.body.offsetHeight;
+    this._reflow = document.body.offsetHeight
 
     children.forEach((c: VNode) => {
       if (c.data!.moved) {
-        const el: any = c.elm;
-        const s: any = el.style;
-        addTransitionClass(el, moveClass);
-        s.transform = s.WebkitTransform = s.transitionDuration = "";
+        const el: any = c.elm
+        const s: any = el.style
+        addTransitionClass(el, moveClass)
+        s.transform = s.WebkitTransform = s.transitionDuration = ''
         el.addEventListener(
           transitionEndEvent,
           (el._moveCb = function cb(e) {
             if (e && e.target !== el) {
-              return;
+              return
             }
             if (!e || /transform$/.test(e.propertyName)) {
-              el.removeEventListener(transitionEndEvent, cb);
-              el._moveCb = null;
-              removeTransitionClass(el, moveClass);
+              el.removeEventListener(transitionEndEvent, cb)
+              el._moveCb = null
+              removeTransitionClass(el, moveClass)
             }
           })
-        );
+        )
       }
-    });
+    })
   },
 
   methods: {
     hasMove(el: any, moveClass: string): boolean {
       /* istanbul ignore if */
       if (!hasTransition) {
-        return false;
+        return false
       }
       /* istanbul ignore if */
       if (this._hasMove) {
-        return this._hasMove;
+        return this._hasMove
       }
       // Detect whether an element with the move class applied has
       // CSS transitions. Since the element may be inside an entering
       // transition at this very moment, we make a clone of it and remove
       // all other transition classes applied to ensure only the move class
       // is applied.
-      const clone: HTMLElement = el.cloneNode();
+      const clone: HTMLElement = el.cloneNode()
       if (el._transitionClasses) {
         el._transitionClasses.forEach((cls: string) => {
-          removeClass(clone, cls);
-        });
+          removeClass(clone, cls)
+        })
       }
-      addClass(clone, moveClass);
-      clone.style.display = "none";
-      this.$el.appendChild(clone);
-      const info: any = getTransitionInfo(clone);
-      this.$el.removeChild(clone);
-      return (this._hasMove = info.hasTransform);
-    },
-  },
-};
+      addClass(clone, moveClass)
+      clone.style.display = 'none'
+      this.$el.appendChild(clone)
+      const info: any = getTransitionInfo(clone)
+      this.$el.removeChild(clone)
+      return (this._hasMove = info.hasTransform)
+    }
+  }
+}
 
 function callPendingCbs(
   c: VNodeWithData & { elm?: { _moveCb?: Function; _enterCb?: Function } }
 ) {
   /* istanbul ignore if */
   if (c.elm!._moveCb) {
-    c.elm!._moveCb();
+    c.elm!._moveCb()
   }
   /* istanbul ignore if */
   if (c.elm!._enterCb) {
-    c.elm!._enterCb();
+    c.elm!._enterCb()
   }
 }
 
 function recordPosition(c: VNodeWithData) {
-  c.data!.newPos = c.elm.getBoundingClientRect();
+  c.data!.newPos = c.elm.getBoundingClientRect()
 }
 
 function applyTranslation(c: VNodeWithData) {
-  const oldPos = c.data.pos;
-  const newPos = c.data.newPos;
-  const dx = oldPos.left - newPos.left;
-  const dy = oldPos.top - newPos.top;
+  const oldPos = c.data.pos
+  const newPos = c.data.newPos
+  const dx = oldPos.left - newPos.left
+  const dy = oldPos.top - newPos.top
   if (dx || dy) {
-    c.data.moved = true;
-    const s = c.elm.style;
-    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`;
-    s.transitionDuration = "0s";
+    c.data.moved = true
+    const s = c.elm.style
+    s.transform = s.WebkitTransform = `translate(${dx}px,${dy}px)`
+    s.transitionDuration = '0s'
   }
 }
diff --git a/src/platforms/web/runtime/components/transition.ts b/src/platforms/web/runtime/components/transition.ts
index a1f82e3c1dc..782c0b6d300 100644
--- a/src/platforms/web/runtime/components/transition.ts
+++ b/src/platforms/web/runtime/components/transition.ts
@@ -1,4 +1,3 @@
-
 // Provides transition support for a single element/component.
 // supports transition mode (out-in / in-out)
 
@@ -7,7 +6,7 @@ import { camelize, extend, isPrimitive } from 'shared/util'
 import {
   mergeVNodeHook,
   isAsyncPlaceholder,
-  getFirstComponentChild,
+  getFirstComponentChild
 } from 'core/vdom/helpers/index'
 import VNode from 'core/vdom/vnode'
 import type { Component } from 'typescript/component'
@@ -27,7 +26,7 @@ export const transitionProps = {
   appearClass: String,
   appearActiveClass: String,
   appearToClass: String,
-  duration: [Number, String, Object],
+  duration: [Number, String, Object]
 }
 
 // in case the child is also an abstract component, e.g. <keep-alive>
@@ -61,7 +60,7 @@ function placeholder(h: Function, rawChild: VNode): VNode | undefined {
   // @ts-expect-error
   if (/\d-keep-alive$/.test(rawChild.tag)) {
     return h('keep-alive', {
-      props: rawChild.componentOptions!.propsData,
+      props: rawChild.componentOptions!.propsData
     })
   }
 }
@@ -80,7 +79,7 @@ function isSameChild(child: VNode, oldChild: VNode): boolean {
 
 const isNotTextNode = (c: VNode) => c.tag || isAsyncPlaceholder(c)
 
-const isVShowDirective = (d) => d.name === 'show'
+const isVShowDirective = d => d.name === 'show'
 
 export default {
   name: 'transition',
@@ -156,9 +155,8 @@ export default {
           : id + child.key
         : child.key
 
-    const data: Object = ((
-      child.data || (child.data = {})
-    ).transition = extractTransitionData(this))
+    const data: Object = ((child.data || (child.data = {})).transition =
+      extractTransitionData(this))
     const oldRawChild: VNode = this._vnode
     const oldChild = getRealChild(oldRawChild)
 
@@ -201,12 +199,12 @@ export default {
         }
         mergeVNodeHook(data, 'afterEnter', performLeave)
         mergeVNodeHook(data, 'enterCancelled', performLeave)
-        mergeVNodeHook(oldData, 'delayLeave', (leave) => {
+        mergeVNodeHook(oldData, 'delayLeave', leave => {
           delayedLeave = leave
         })
       }
     }
 
     return rawChild
-  },
+  }
 }
diff --git a/src/platforms/web/runtime/directives/index.ts b/src/platforms/web/runtime/directives/index.ts
index 6409229c35d..b673f11aa61 100644
--- a/src/platforms/web/runtime/directives/index.ts
+++ b/src/platforms/web/runtime/directives/index.ts
@@ -3,5 +3,5 @@ import show from './show'
 
 export default {
   model,
-  show,
+  show
 }
diff --git a/src/platforms/web/runtime/directives/model.ts b/src/platforms/web/runtime/directives/model.ts
index 91f250b0b92..799113ca816 100644
--- a/src/platforms/web/runtime/directives/model.ts
+++ b/src/platforms/web/runtime/directives/model.ts
@@ -63,7 +63,7 @@ const directive = {
         // trigger change event if
         // no matching option found for at least one value
         const needReset = el.multiple
-          ? binding.value.some((v) => hasNoMatchingOption(v, curOptions))
+          ? binding.value.some(v => hasNoMatchingOption(v, curOptions))
           : binding.value !== binding.oldValue &&
             hasNoMatchingOption(binding.value, curOptions)
         if (needReset) {
@@ -71,7 +71,7 @@ const directive = {
         }
       }
     }
-  },
+  }
 }
 
 function setSelected(el, binding, vm) {
@@ -121,7 +121,7 @@ function actuallySetSelected(el, binding, vm) {
 }
 
 function hasNoMatchingOption(value, options) {
-  return options.every((o) => !looseEqual(o, value))
+  return options.every(o => !looseEqual(o, value))
 }
 
 function getValue(option) {
diff --git a/src/platforms/web/runtime/directives/show.ts b/src/platforms/web/runtime/directives/show.ts
index bd59c79ee8c..230725e708d 100644
--- a/src/platforms/web/runtime/directives/show.ts
+++ b/src/platforms/web/runtime/directives/show.ts
@@ -1,9 +1,7 @@
-
 import VNode from 'core/vdom/vnode'
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 import { enter, leave } from 'web/runtime/modules/transition'
 
-
 // recursively search for possible transition defined inside the component root
 function locateNode(vnode: VNode | VNodeWithData): VNodeWithData {
   // @ts-expect-error
@@ -59,5 +57,5 @@ export default {
     if (!isDestroy) {
       el.style.display = el.__vOriginalDisplay
     }
-  },
+  }
 }
diff --git a/src/platforms/web/runtime/modules/attrs.ts b/src/platforms/web/runtime/modules/attrs.ts
index 780e283b6cf..cda1d3e2446 100644
--- a/src/platforms/web/runtime/modules/attrs.ts
+++ b/src/platforms/web/runtime/modules/attrs.ts
@@ -1,4 +1,3 @@
-
 import { isIE, isIE9, isEdge } from 'core/util/env'
 
 import { extend, isDef, isUndef } from 'shared/util'
@@ -11,7 +10,7 @@ import {
   isBooleanAttr,
   isEnumeratedAttr,
   isFalsyAttrValue,
-  convertEnumeratedValue,
+  convertEnumeratedValue
 } from 'web/util/index'
 
 function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
@@ -98,7 +97,7 @@ function baseSetAttr(el, key, value) {
       value !== '' &&
       !el.__ieph
     ) {
-      const blocker = (e) => {
+      const blocker = e => {
         e.stopImmediatePropagation()
         el.removeEventListener('input', blocker)
       }
@@ -112,5 +111,5 @@ function baseSetAttr(el, key, value) {
 
 export default {
   create: updateAttrs,
-  update: updateAttrs,
+  update: updateAttrs
 }
diff --git a/src/platforms/web/runtime/modules/class.ts b/src/platforms/web/runtime/modules/class.ts
index 3f183098360..3be15a1ab4c 100644
--- a/src/platforms/web/runtime/modules/class.ts
+++ b/src/platforms/web/runtime/modules/class.ts
@@ -1,4 +1,3 @@
-
 import { isDef, isUndef } from 'shared/util'
 import type { VNodeData } from 'typescript/vnode'
 
@@ -34,5 +33,5 @@ function updateClass(oldVnode: any, vnode: any) {
 
 export default {
   create: updateClass,
-  update: updateClass,
+  update: updateClass
 }
diff --git a/src/platforms/web/runtime/modules/dom-props.ts b/src/platforms/web/runtime/modules/dom-props.ts
index c666504d5b8..6cf736566b6 100644
--- a/src/platforms/web/runtime/modules/dom-props.ts
+++ b/src/platforms/web/runtime/modules/dom-props.ts
@@ -1,4 +1,3 @@
-
 import { isDef, isUndef, extend, toNumber } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
 import { isSVG } from 'web/util/index'
@@ -120,5 +119,5 @@ function isDirtyWithModifiers(elm: any, newVal: string): boolean {
 
 export default {
   create: updateDOMProps,
-  update: updateDOMProps,
+  update: updateDOMProps
 }
diff --git a/src/platforms/web/runtime/modules/events.ts b/src/platforms/web/runtime/modules/events.ts
index 85cc6efcfbd..31b220ff92f 100644
--- a/src/platforms/web/runtime/modules/events.ts
+++ b/src/platforms/web/runtime/modules/events.ts
@@ -1,10 +1,9 @@
-
 import { isDef, isUndef } from 'shared/util'
 import { updateListeners } from 'core/vdom/helpers/index'
 import { isIE, isFF, supportsPassive, isUsingMicroTask } from 'core/util/index'
 import {
   RANGE_TOKEN,
-  CHECKBOX_RADIO_TOKEN,
+  CHECKBOX_RADIO_TOKEN
 } from 'web/compiler/directives/model'
 import { currentFlushTimestamp } from 'core/observer/scheduler'
 import { emptyNode } from 'core/vdom/patch'
@@ -63,7 +62,7 @@ function add(
   if (useMicrotaskFix) {
     const attachedTimestamp = currentFlushTimestamp
     const original = handler
-    //@ts-expect-error 
+    //@ts-expect-error
     handler = original._wrapper = function (e) {
       if (
         // no bubbling, should always fire.
@@ -98,7 +97,7 @@ function remove(
   capture: boolean,
   _target?: HTMLElement
 ) {
-  (_target || target).removeEventListener(
+  ;(_target || target).removeEventListener(
     name,
     //@ts-expect-error
     handler._wrapper || handler,
diff --git a/src/platforms/web/runtime/modules/style.ts b/src/platforms/web/runtime/modules/style.ts
index c40c9f50fb8..b8412bdae6c 100644
--- a/src/platforms/web/runtime/modules/style.ts
+++ b/src/platforms/web/runtime/modules/style.ts
@@ -1,4 +1,3 @@
-
 import { getStyle, normalizeStyleBinding } from 'web/util/style'
 import {
   cached,
@@ -6,7 +5,7 @@ import {
   extend,
   isDef,
   isUndef,
-  hyphenate,
+  hyphenate
 } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
 
@@ -101,5 +100,5 @@ function updateStyle(oldVnode: VNodeWithData, vnode: VNodeWithData) {
 
 export default {
   create: updateStyle,
-  update: updateStyle,
+  update: updateStyle
 }
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index ebed6480666..69f03fd150b 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -1,16 +1,16 @@
-
 import { inBrowser, isIE9, warn } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
 import { activeInstance } from 'core/instance/lifecycle'
 
 import { once, isDef, isUndef, isObject, toNumber } from 'shared/util'
 
-import { 
+import {
   nextFrame,
   resolveTransition,
   whenTransitionEnds,
   addTransitionClass,
-  removeTransitionClass } from 'web/runtime/transition-util'
+  removeTransitionClass
+} from 'web/runtime/transition-util'
 
 import type { VNodeWithData } from 'typescript/vnode'
 import VNode from 'core/vdom/vnode'
@@ -51,7 +51,7 @@ export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
     appear,
     afterAppear,
     appearCancelled,
-    duration,
+    duration
   } = data
 
   // activeInstance will always be the <transition> component managing this
@@ -193,7 +193,7 @@ export function leave(vnode: VNodeWithData, rm: Function) {
     afterLeave,
     leaveCancelled,
     delayLeave,
-    duration,
+    duration
   } = data
 
   const expectsCSS = css !== false && !isIE9
@@ -242,9 +242,8 @@ export function leave(vnode: VNodeWithData, rm: Function) {
     }
     // record leaving element
     if (!vnode.data.show && el.parentNode) {
-      (el.parentNode._pending || (el.parentNode._pending = {}))[
-        vnode.key!
-      ] = vnode
+      ;(el.parentNode._pending || (el.parentNode._pending = {}))[vnode.key!] =
+        vnode
     }
     beforeLeave && beforeLeave(el)
     if (expectsCSS) {
@@ -334,6 +333,6 @@ export default inBrowser
         } else {
           rm()
         }
-      },
+      }
     }
   : {}
diff --git a/src/platforms/web/runtime/node-ops.ts b/src/platforms/web/runtime/node-ops.ts
index 5eca28e3615..fed3abc8cb2 100644
--- a/src/platforms/web/runtime/node-ops.ts
+++ b/src/platforms/web/runtime/node-ops.ts
@@ -1,4 +1,3 @@
-
 import VNode from 'core/vdom/vnode'
 import { namespaceMap } from 'web/util/index'
 
diff --git a/src/platforms/web/runtime/patch.ts b/src/platforms/web/runtime/patch.ts
index 76cc4c0cc3f..a56e67f0ce0 100644
--- a/src/platforms/web/runtime/patch.ts
+++ b/src/platforms/web/runtime/patch.ts
@@ -1,4 +1,3 @@
-
 import * as nodeOps from 'web/runtime/node-ops'
 import { createPatchFunction } from 'core/vdom/patch'
 import baseModules from 'core/vdom/modules/index'
diff --git a/src/platforms/web/runtime/transition-util.ts b/src/platforms/web/runtime/transition-util.ts
index d327e29b82d..6174c6f37e4 100644
--- a/src/platforms/web/runtime/transition-util.ts
+++ b/src/platforms/web/runtime/transition-util.ts
@@ -21,14 +21,14 @@ export function resolveTransition(
   }
 }
 
-const autoCssTransition: (name: string) => Object = cached((name) => {
+const autoCssTransition: (name: string) => Object = cached(name => {
   return {
     enterClass: `${name}-enter`,
     enterToClass: `${name}-enter-to`,
     enterActiveClass: `${name}-enter-active`,
     leaveClass: `${name}-leave`,
     leaveToClass: `${name}-leave-to`,
-    leaveActiveClass: `${name}-leave-active`,
+    leaveActiveClass: `${name}-leave-active`
   }
 })
 
@@ -64,7 +64,7 @@ const raf = inBrowser
   ? window.requestAnimationFrame
     ? window.requestAnimationFrame.bind(window)
     : setTimeout
-  : /* istanbul ignore next */ (fn) => fn()
+  : /* istanbul ignore next */ fn => fn()
 
 export function nextFrame(fn: Function) {
   raf(() => {
@@ -103,7 +103,7 @@ export function whenTransitionEnds(
     el.removeEventListener(event, onEnd)
     cb()
   }
-  const onEnd = (e) => {
+  const onEnd = e => {
     if (e.target === el) {
       if (++ended >= propCount) {
         end()
@@ -188,7 +188,7 @@ export function getTransitionInfo(
     type,
     timeout,
     propCount,
-    hasTransform,
+    hasTransform
   }
 }
 
diff --git a/src/platforms/web/server/compiler.ts b/src/platforms/web/server/compiler.ts
index 55dc68ec3f9..27831e8e36b 100644
--- a/src/platforms/web/server/compiler.ts
+++ b/src/platforms/web/server/compiler.ts
@@ -1,4 +1,3 @@
-
 import { baseOptions } from '../compiler/options'
 import { createCompiler } from 'server/optimizing-compiler/index'
 
diff --git a/src/platforms/web/server/directives/index.ts b/src/platforms/web/server/directives/index.ts
index 7d999b92556..fd7fce0a34c 100644
--- a/src/platforms/web/server/directives/index.ts
+++ b/src/platforms/web/server/directives/index.ts
@@ -3,5 +3,5 @@ import model from './model'
 
 export default {
   show,
-  model,
+  model
 }
diff --git a/src/platforms/web/server/directives/model.ts b/src/platforms/web/server/directives/model.ts
index cab659512b7..321727eb28d 100644
--- a/src/platforms/web/server/directives/model.ts
+++ b/src/platforms/web/server/directives/model.ts
@@ -1,4 +1,3 @@
-
 import { looseEqual, looseIndexOf } from 'shared/util'
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 
diff --git a/src/platforms/web/server/directives/show.ts b/src/platforms/web/server/directives/show.ts
index 3ab67bf6266..6811d84654a 100644
--- a/src/platforms/web/server/directives/show.ts
+++ b/src/platforms/web/server/directives/show.ts
@@ -1,4 +1,3 @@
-
 import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
 
 export default function show(node: VNodeWithData, dir: VNodeDirective) {
diff --git a/src/platforms/web/server/modules/attrs.ts b/src/platforms/web/server/modules/attrs.ts
index e64f24dc053..5cb7e3b6140 100644
--- a/src/platforms/web/server/modules/attrs.ts
+++ b/src/platforms/web/server/modules/attrs.ts
@@ -1,4 +1,3 @@
-
 import { escape } from '../util'
 
 import { isDef, isUndef, extend } from 'shared/util'
@@ -7,7 +6,7 @@ import {
   isBooleanAttr,
   isEnumeratedAttr,
   isFalsyAttrValue,
-  convertEnumeratedValue,
+  convertEnumeratedValue
 } from 'web/util/attrs'
 
 import { isSSRUnsafeAttr } from 'web/server/util'
diff --git a/src/platforms/web/server/modules/class.ts b/src/platforms/web/server/modules/class.ts
index f087c7f5d86..c0f674e102d 100644
--- a/src/platforms/web/server/modules/class.ts
+++ b/src/platforms/web/server/modules/class.ts
@@ -1,4 +1,3 @@
-
 import { escape } from '../util'
 import { genClassForVnode } from 'web/util/index'
 import type { VNodeWithData } from 'typescript/vnode'
diff --git a/src/platforms/web/server/modules/dom-props.ts b/src/platforms/web/server/modules/dom-props.ts
index e57bf9cab04..1c13030c805 100644
--- a/src/platforms/web/server/modules/dom-props.ts
+++ b/src/platforms/web/server/modules/dom-props.ts
@@ -1,4 +1,3 @@
-
 import VNode from 'core/vdom/vnode'
 import { renderAttr } from './attrs'
 import { isDef, isUndef, extend, toString } from 'shared/util'
diff --git a/src/platforms/web/server/modules/style.ts b/src/platforms/web/server/modules/style.ts
index d9ea3901c40..8e165e28243 100644
--- a/src/platforms/web/server/modules/style.ts
+++ b/src/platforms/web/server/modules/style.ts
@@ -1,4 +1,3 @@
-
 import { escape, noUnitNumericStyleProps } from '../util'
 import { hyphenate } from 'shared/util'
 import { getStyle } from 'web/util/style'
diff --git a/src/platforms/web/server/util.ts b/src/platforms/web/server/util.ts
index 6ad3a1ed5bf..9fa4e7aa7ed 100644
--- a/src/platforms/web/server/util.ts
+++ b/src/platforms/web/server/util.ts
@@ -1,4 +1,3 @@
-
 import { makeMap } from 'shared/util'
 
 const isAttr = makeMap(
@@ -34,14 +33,14 @@ export const propsToAttrMap = {
   acceptCharset: 'accept-charset',
   className: 'class',
   htmlFor: 'for',
-  httpEquiv: 'http-equiv',
+  httpEquiv: 'http-equiv'
 }
 
 const ESC = {
   '<': '&lt;',
   '>': '&gt;',
   '"': '&quot;',
-  '&': '&amp;',
+  '&': '&amp;'
 }
 
 export function escape(s: string) {
@@ -94,5 +93,5 @@ export const noUnitNumericStyleProps = {
   'stroke-dashoffset': true,
   'stroke-miterlimit': true,
   'stroke-opacity': true,
-  'stroke-width': true,
+  'stroke-width': true
 }
diff --git a/src/platforms/web/util/attrs.ts b/src/platforms/web/util/attrs.ts
index aa3db7aae03..e520c33d09b 100644
--- a/src/platforms/web/util/attrs.ts
+++ b/src/platforms/web/util/attrs.ts
@@ -1,4 +1,3 @@
-
 import { makeMap } from 'shared/util'
 
 // these are reserved for web because they are directly compiled away
diff --git a/src/platforms/web/util/class.ts b/src/platforms/web/util/class.ts
index 24255cc7bbf..74323a8770b 100644
--- a/src/platforms/web/util/class.ts
+++ b/src/platforms/web/util/class.ts
@@ -1,4 +1,3 @@
-
 import VNode from 'core/vdom/vnode'
 import { isDef, isObject } from 'shared/util'
 import type { VNodeData, VNodeWithData } from 'typescript/vnode'
@@ -31,7 +30,7 @@ function mergeClassData(
 } {
   return {
     staticClass: concat(child.staticClass, parent.staticClass),
-    class: isDef(child.class) ? [child.class, parent.class] : parent.class,
+    class: isDef(child.class) ? [child.class, parent.class] : parent.class
   }
 }
 
diff --git a/src/platforms/web/util/compat.ts b/src/platforms/web/util/compat.ts
index 08d1d4e0635..eaa0b87aaa9 100644
--- a/src/platforms/web/util/compat.ts
+++ b/src/platforms/web/util/compat.ts
@@ -1,4 +1,3 @@
-
 import { inBrowser } from 'core/util/index'
 
 // check whether current browser encodes a char inside attribute values
diff --git a/src/platforms/web/util/element.ts b/src/platforms/web/util/element.ts
index 14fc8a3bacc..e5788c4a029 100644
--- a/src/platforms/web/util/element.ts
+++ b/src/platforms/web/util/element.ts
@@ -1,10 +1,9 @@
-
 import { inBrowser } from 'core/util/env'
 import { makeMap } from 'shared/util'
 
 export const namespaceMap = {
   svg: 'http://www.w3.org/2000/svg',
-  math: 'http://www.w3.org/1998/Math/MathML',
+  math: 'http://www.w3.org/1998/Math/MathML'
 }
 
 export const isHTMLTag = makeMap(
diff --git a/src/platforms/web/util/index.ts b/src/platforms/web/util/index.ts
index d7a53c6bf4e..8bdce82514a 100644
--- a/src/platforms/web/util/index.ts
+++ b/src/platforms/web/util/index.ts
@@ -1,4 +1,3 @@
-
 import { warn } from 'core/util/index'
 
 export * from './attrs'
diff --git a/src/platforms/web/util/style.ts b/src/platforms/web/util/style.ts
index 20d2d40fec8..81992af1eaf 100644
--- a/src/platforms/web/util/style.ts
+++ b/src/platforms/web/util/style.ts
@@ -1,4 +1,3 @@
-
 import VNode from 'core/vdom/vnode'
 import { cached, extend, toObject } from 'shared/util'
 import type { VNodeData, VNodeWithData } from 'typescript/vnode'
diff --git a/src/server/bundle-renderer/create-bundle-renderer.ts b/src/server/bundle-renderer/create-bundle-renderer.ts
index ba3c730390b..d7587321976 100644
--- a/src/server/bundle-renderer/create-bundle-renderer.ts
+++ b/src/server/bundle-renderer/create-bundle-renderer.ts
@@ -100,11 +100,11 @@ export function createBundleRendererCreator(
         }
 
         run(context)
-          .catch((err) => {
+          .catch(err => {
             rewriteErrorTrace(err, maps)
             cb(err)
           })
-          .then((app) => {
+          .then(app => {
             if (app) {
               //@ts-expect-error
               renderer.renderToString(app, context, (err, res) => {
@@ -120,7 +120,7 @@ export function createBundleRendererCreator(
       renderToStream: (context?: Object) => {
         const res = new PassThrough()
         run(context)
-          .catch((err) => {
+          .catch(err => {
             rewriteErrorTrace(err, maps)
             // avoid emitting synchronously before user can
             // attach error listener
@@ -128,12 +128,12 @@ export function createBundleRendererCreator(
               res.emit('error', err)
             })
           })
-          .then((app) => {
+          .then(app => {
             if (app) {
               //@ts-expect-error
               const renderStream = renderer.renderToStream(app, context)
 
-              renderStream.on('error', (err) => {
+              renderStream.on('error', err => {
                 rewriteErrorTrace(err, maps)
                 res.emit('error', err)
               })
diff --git a/src/server/bundle-renderer/create-bundle-runner.ts b/src/server/bundle-renderer/create-bundle-runner.ts
index e61fa67f22d..6e9d063693b 100644
--- a/src/server/bundle-renderer/create-bundle-runner.ts
+++ b/src/server/bundle-renderer/create-bundle-runner.ts
@@ -16,7 +16,7 @@ function createSandbox(context?: any) {
     clearTimeout,
     clearInterval,
     clearImmediate,
-    __VUE_SSR_CONTEXT__: context,
+    __VUE_SSR_CONTEXT__: context
   }
 
   // @ts-expect-error
@@ -36,7 +36,7 @@ function compileModule(files, basedir, runInNewContext) {
     const wrapper = NativeModule.wrap(code)
     const script = new vm.Script(wrapper, {
       filename,
-      displayErrors: true,
+      displayErrors: true
     })
     compiledScripts[filename] = script
     return script
@@ -53,7 +53,7 @@ function compileModule(files, basedir, runInNewContext) {
         ? script.runInThisContext()
         : script.runInNewContext(sandbox)
     const m = { exports: {} }
-    const r = (file) => {
+    const r = file => {
       file = path.posix.join('.', file)
       if (files[file]) {
         return evaluateModule(file, sandbox, evaluatedFiles)
@@ -97,7 +97,7 @@ export function createBundleRunner(entry, files, basedir, runInNewContext) {
     // on each render. Ensures entire application state is fresh for each
     // render, but incurs extra evaluation cost.
     return (userContext = {}) =>
-      new Promise((resolve) => {
+      new Promise(resolve => {
         // @ts-expect-error
         userContext._registeredComponents = new Set()
         const res = evaluate(entry, createSandbox(userContext))
@@ -111,7 +111,7 @@ export function createBundleRunner(entry, files, basedir, runInNewContext) {
     let runner // lazy creation so that errors can be caught by user
     let initialContext
     return (userContext = {}) =>
-      new Promise((resolve) => {
+      new Promise(resolve => {
         if (!runner) {
           const sandbox = runInNewContext === 'once' ? createSandbox() : global
           // the initial context is only used for collecting possible non-component
@@ -147,7 +147,7 @@ export function createBundleRunner(entry, files, basedir, runInNewContext) {
               get() {
                 // @ts-expect-error
                 return renderStyles(userContext._styles)
-              },
+              }
             })
           }
         }
diff --git a/src/server/bundle-renderer/source-map-support.ts b/src/server/bundle-renderer/source-map-support.ts
index 27f8a46dcce..6f03ebb131a 100644
--- a/src/server/bundle-renderer/source-map-support.ts
+++ b/src/server/bundle-renderer/source-map-support.ts
@@ -1,11 +1,10 @@
-
 const SourceMapConsumer = require('source-map').SourceMapConsumer
 
 const filenameRE = /\(([^)]+\.js):(\d+):(\d+)\)$/
 
 export function createSourceMapConsumers(rawMaps: Object) {
   const maps = {}
-  Object.keys(rawMaps).forEach((file) => {
+  Object.keys(rawMaps).forEach(file => {
     maps[file] = new SourceMapConsumer(rawMaps[file])
   })
   return maps
@@ -20,7 +19,7 @@ export function rewriteErrorTrace(
   if (e && typeof e.stack === 'string') {
     e.stack = e.stack
       .split('\n')
-      .map((line) => {
+      .map(line => {
         return rewriteTraceLine(line, mapConsumers)
       })
       .join('\n')
@@ -38,7 +37,7 @@ function rewriteTraceLine(
   if (m != null && map) {
     const originalPosition = map.originalPositionFor({
       line: Number(m[2]),
-      column: Number(m[3]),
+      column: Number(m[3])
     })
     if (originalPosition.source != null) {
       const { source, line, column } = originalPosition
diff --git a/src/server/create-basic-renderer.ts b/src/server/create-basic-renderer.ts
index 733b3e320f1..fc12ec8a73f 100644
--- a/src/server/create-basic-renderer.ts
+++ b/src/server/create-basic-renderer.ts
@@ -1,4 +1,3 @@
-
 import { createWriteFunction } from './write'
 import { createRenderFunction } from './render'
 import type { RenderOptions } from './create-renderer'
@@ -8,7 +7,7 @@ export function createBasicRenderer({
   modules = [],
   directives = {},
   isUnaryTag = () => false,
-  cache,
+  cache
 }: RenderOptions = {}) {
   const render = createRenderFunction(modules, directives, isUnaryTag, cache)
 
@@ -22,7 +21,7 @@ export function createBasicRenderer({
       context = {}
     }
     let result = ''
-    const write = createWriteFunction((text) => {
+    const write = createWriteFunction(text => {
       result += text
       return false
     }, done)
diff --git a/src/server/create-renderer.ts b/src/server/create-renderer.ts
index 98155488f1b..8005547480a 100644
--- a/src/server/create-renderer.ts
+++ b/src/server/create-renderer.ts
@@ -85,13 +85,13 @@ export function createRenderer({
       }
 
       let result = ''
-      const write = createWriteFunction((text) => {
+      const write = createWriteFunction(text => {
         result += text
         return false
       }, cb)
       try {
         // @ts-expect-error TODO improve
-        render(component, write, context, (err) => {
+        render(component, write, context, err => {
           if (err) {
             return cb(err)
           }
@@ -103,7 +103,7 @@ export function createRenderer({
               const res = templateRenderer.render(result, context)
               if (typeof res !== 'string') {
                 // function template returning promise
-                res.then((html) => cb(null, html)).catch(cb)
+                res.then(html => cb(null, html)).catch(cb)
               } else {
                 cb(null, res)
               }
@@ -145,7 +145,7 @@ export function createRenderer({
         )
       } else {
         const templateStream = templateRenderer.createStream(context)
-        renderStream.on('error', (err) => {
+        renderStream.on('error', err => {
           templateStream.emit('error', err)
         })
         renderStream.pipe(templateStream)
diff --git a/src/server/optimizing-compiler/codegen.ts b/src/server/optimizing-compiler/codegen.ts
index 1c5dc7bfe65..670a5f6d583 100644
--- a/src/server/optimizing-compiler/codegen.ts
+++ b/src/server/optimizing-compiler/codegen.ts
@@ -1,4 +1,3 @@
-
 // The SSR codegen is essentially extending the default codegen to handle
 // SSR-optimizable nodes and turn them into string render fns. In cases where
 // a node is not optimizable it simply falls back to the default codegen.
@@ -10,7 +9,7 @@ import {
   genText,
   genElement,
   genChildren,
-  CodegenState,
+  CodegenState
 } from 'compiler/codegen/index'
 
 import {
@@ -18,7 +17,7 @@ import {
   genDOMPropSegments,
   genClassSegments,
   genStyleSegments,
-  applyModelTransform,
+  applyModelTransform
 } from './modules'
 
 import { escape } from 'web/server/util'
@@ -43,7 +42,7 @@ export function generate(
   const code = ast ? genSSRElement(ast, state) : '_c("div")'
   return {
     render: `with(this){return ${code}}`,
-    staticRenderFns: state.staticRenderFns,
+    staticRenderFns: state.staticRenderFns
   }
 }
 
@@ -123,16 +122,16 @@ function elementToSegments(el, state): Array<StringSegment> {
     return [
       {
         type: EXPRESSION,
-        value: genFor(el, state, elementToString, '_ssrList'),
-      },
+        value: genFor(el, state, elementToString, '_ssrList')
+      }
     ]
   } else if (el.if && !el.ifProcessed) {
     el.ifProcessed = true
     return [
       {
         type: EXPRESSION,
-        value: genIf(el, state, elementToString, '"<!---->"'),
-      },
+        value: genIf(el, state, elementToString, '"<!---->"')
+      }
     ]
   } else if (el.tag === 'template') {
     return childrenToSegments(el, state)
diff --git a/src/server/optimizing-compiler/index.ts b/src/server/optimizing-compiler/index.ts
index a07588d37f3..25b37e419d9 100644
--- a/src/server/optimizing-compiler/index.ts
+++ b/src/server/optimizing-compiler/index.ts
@@ -1,4 +1,3 @@
-
 import { parse } from 'compiler/parser/index'
 import { generate } from './codegen'
 import { optimize } from './optimizer'
@@ -14,6 +13,6 @@ export const createCompiler = createCompilerCreator(function baseCompile(
   return {
     ast,
     render: code.render,
-    staticRenderFns: code.staticRenderFns,
+    staticRenderFns: code.staticRenderFns
   }
 })
diff --git a/src/server/optimizing-compiler/modules.ts b/src/server/optimizing-compiler/modules.ts
index 20c7239718c..9a52768e524 100644
--- a/src/server/optimizing-compiler/modules.ts
+++ b/src/server/optimizing-compiler/modules.ts
@@ -1,8 +1,7 @@
-
 import {
   RAW,
   // INTERPOLATION,
-  EXPRESSION,
+  EXPRESSION
 } from './codegen'
 
 import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
@@ -24,7 +23,7 @@ export function applyModelTransform(el: ASTElement, state: CodegenState) {
         state.directives.model(el, dir, state.warn)
         // remove value for textarea as its converted to text
         if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter((p) => p.name !== 'value')
+          el.props = el.props.filter(p => p.name !== 'value')
         }
         break
       }
@@ -45,7 +44,7 @@ export function genDOMPropSegments(
     name = propsToAttrMap[name] || name.toLowerCase()
     if (
       isRenderableAttr(name) &&
-      !(attrs && attrs.some((a) => a.name === name))
+      !(attrs && attrs.some(a => a.name === name))
     ) {
       segments.push(genAttrSegment(name, value))
     }
@@ -67,12 +66,12 @@ function genAttrSegment(name: string, value: string): StringSegment {
         ? ` ${name}="${name}"`
         : value === '""'
         ? ` ${name}`
-        : ` ${name}="${JSON.parse(value)}"`,
+        : ` ${name}="${JSON.parse(value)}"`
     }
   } else {
     return {
       type: EXPRESSION,
-      value: `_ssrAttr(${JSON.stringify(name)},${value})`,
+      value: `_ssrAttr(${JSON.stringify(name)},${value})`
     }
   }
 }
@@ -87,8 +86,8 @@ export function genClassSegments(
     return [
       {
         type: EXPRESSION,
-        value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`,
-      },
+        value: `_ssrClass(${staticClass || 'null'},${classBinding || 'null'})`
+      }
     ]
   }
 }
@@ -111,8 +110,8 @@ export function genStyleSegments(
           vShowExpression
             ? `{ display: (${vShowExpression}) ? '' : 'none' }`
             : 'null'
-        })`,
-      },
+        })`
+      }
     ]
   }
 }
diff --git a/src/server/optimizing-compiler/optimizer.ts b/src/server/optimizing-compiler/optimizer.ts
index 8e8a70ba176..08afa3d90ab 100644
--- a/src/server/optimizing-compiler/optimizer.ts
+++ b/src/server/optimizing-compiler/optimizer.ts
@@ -1,4 +1,3 @@
-
 /**
  * In SSR, the vdom tree is generated only once and never patched, so
  * we can optimize most element / trees into plain string render functions.
@@ -17,7 +16,7 @@ export const optimizability = {
   FULL: 1, // whole sub tree optimizable
   SELF: 2, // self optimizable but has some un-optimizable children
   CHILDREN: 3, // self un-optimizable but have fully optimizable children
-  PARTIAL: 4, // self un-optimizable with some un-optimizable children
+  PARTIAL: 4 // self un-optimizable with some un-optimizable children
 }
 
 let isPlatformReservedTag
@@ -35,7 +34,7 @@ function walk(node: ASTNode, isRoot?: boolean) {
   }
   // root node or nodes with custom directives should always be a VNode
   const selfUnoptimizable = isRoot || hasCustomDirective(node)
-  const check = (child) => {
+  const check = child => {
     if (child.ssrOptimizability !== optimizability.FULL) {
       node.ssrOptimizability = selfUnoptimizable
         ? optimizability.PARTIAL
@@ -86,7 +85,7 @@ function optimizeSiblings(el) {
         attrsMap: {},
         rawAttrsMap: {},
         children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL,
+        ssrOptimizability: optimizability.FULL
       })
     }
     currentOptimizableGroup = []
@@ -125,7 +124,7 @@ const isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
 function hasCustomDirective(node: ASTNode): boolean {
   return (node.type === 1 &&
     node.directives &&
-    node.directives.some((d) => !isBuiltInDir(d.name))) as any
+    node.directives.some(d => !isBuiltInDir(d.name))) as any
 }
 
 // <select v-model> cannot be optimized because it requires a runtime check
@@ -135,6 +134,6 @@ function isSelectWithModel(node: ASTNode): boolean {
     node.type === 1 &&
     node.tag === 'select' &&
     node.directives != null &&
-    node.directives.some((d) => d.name === 'model')
+    node.directives.some(d => d.name === 'model')
   )
 }
diff --git a/src/server/optimizing-compiler/runtime-helpers.ts b/src/server/optimizing-compiler/runtime-helpers.ts
index e4f1e187a94..5c3e08b1d43 100644
--- a/src/server/optimizing-compiler/runtime-helpers.ts
+++ b/src/server/optimizing-compiler/runtime-helpers.ts
@@ -1,4 +1,3 @@
-
 import { escape, isSSRUnsafeAttr } from 'web/server/util'
 import { isObject, extend } from 'shared/util'
 import { renderAttr } from 'web/server/modules/attrs'
@@ -8,7 +7,7 @@ import { normalizeStyleBinding } from 'web/util/style'
 
 import {
   normalizeChildren,
-  simpleNormalizeChildren,
+  simpleNormalizeChildren
 } from 'core/vdom/helpers/normalize-children'
 
 import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
@@ -22,7 +21,7 @@ const ssrHelpers = {
   _ssrAttrs: renderAttrs,
   _ssrDOMProps: renderDOMProps,
   _ssrClass: renderSSRClass,
-  _ssrStyle: renderSSRStyle,
+  _ssrStyle: renderSSRStyle
 }
 
 export function installSSRHelpers(vm: Component) {
diff --git a/src/server/render-context.ts b/src/server/render-context.ts
index 2e15f9b702b..7fc1e6812b6 100644
--- a/src/server/render-context.ts
+++ b/src/server/render-context.ts
@@ -1,4 +1,3 @@
-
 import VNode from 'core/vdom/vnode'
 import { isUndef } from 'shared/util'
 import { Component } from 'typescript/component'
@@ -104,7 +103,7 @@ export class RenderContext {
           const { buffer, bufferIndex, componentBuffer, key } = lastState
           const result = {
             html: buffer[bufferIndex],
-            components: componentBuffer[bufferIndex],
+            components: componentBuffer[bufferIndex]
           }
           this.cache.set(key, result)
           if (bufferIndex === 0) {
@@ -117,7 +116,7 @@ export class RenderContext {
             // merge self into parent's result
             buffer[bufferIndex - 1] += result.html
             const prev = componentBuffer[bufferIndex - 1]
-            result.components.forEach((c) => prev.add(c))
+            result.components.forEach(c => prev.add(c))
           }
           buffer.length = bufferIndex
           componentBuffer.length = bufferIndex
diff --git a/src/server/render-stream.ts b/src/server/render-stream.ts
index 998ad391232..6cbe6298cca 100644
--- a/src/server/render-stream.ts
+++ b/src/server/render-stream.ts
@@ -1,4 +1,3 @@
-
 /**
  * Original RenderStream implementation by Sasha Aickin (@aickin)
  * Licensed under the Apache License, Version 2.0
@@ -42,7 +41,7 @@ export default class RenderStream extends Readable {
         }
         return false
       },
-      (err) => {
+      err => {
         this.emit('error', err)
       }
     )
diff --git a/src/server/render.ts b/src/server/render.ts
index f2b9e5b7359..272adc4f7c7 100644
--- a/src/server/render.ts
+++ b/src/server/render.ts
@@ -1,4 +1,3 @@
-
 import { escape } from 'web/server/util'
 import { SSR_ATTR } from 'shared/constants'
 import { RenderContext } from './render-context'
@@ -11,14 +10,14 @@ import { isDef, isUndef, isTrue } from 'shared/util'
 
 import {
   createComponent,
-  createComponentInstanceForVnode,
+  createComponentInstanceForVnode
 } from 'core/vdom/create-component'
 import VNode from 'core/vdom/vnode'
 import type { VNodeDirective } from 'typescript/vnode'
 import type { Component } from 'typescript/component'
 
 let warned = Object.create(null)
-const warnOnce = (msg) => {
+const warnOnce = msg => {
   if (!warned[msg]) {
     warned[msg] = true
     // eslint-disable-next-line no-console
@@ -31,7 +30,7 @@ const onCompilationError = (err, vm) => {
   throw new Error(`\n\u001b[31m${err}${trace}\u001b[39m\n`)
 }
 
-const normalizeRender = (vm) => {
+const normalizeRender = vm => {
   const { render, template, _scopeId } = vm.$options
   if (isUndef(render)) {
     if (template) {
@@ -39,7 +38,7 @@ const normalizeRender = (vm) => {
         template,
         {
           scopeId: _scopeId,
-          warn: onCompilationError,
+          warn: onCompilationError
         },
         vm
       )
@@ -128,13 +127,13 @@ function renderComponent(node, isRoot, context) {
     const key = name + '::' + rawKey
     const { has, get } = context
     if (isDef(has)) {
-      has(key, (hit) => {
+      has(key, hit => {
         if (hit === true && isDef(get)) {
-          get(key, (res) => {
+          get(key, res => {
             if (isDef(registerComponent)) {
               registerComponent(userContext)
             }
-            res.components.forEach((register) => register(userContext))
+            res.components.forEach(register => register(userContext))
             write(res.html, next)
           })
         } else {
@@ -142,12 +141,12 @@ function renderComponent(node, isRoot, context) {
         }
       })
     } else if (isDef(get)) {
-      get(key, (res) => {
+      get(key, res => {
         if (isDef(res)) {
           if (isDef(registerComponent)) {
             registerComponent(userContext)
           }
-          res.components.forEach((register) => register(userContext))
+          res.components.forEach(register => register(userContext))
           write(res.html, next)
         } else {
           renderComponentWithCache(node, isRoot, key, context)
@@ -185,7 +184,7 @@ function renderComponentWithCache(node, isRoot, key, context) {
     key,
     buffer,
     bufferIndex,
-    componentBuffer,
+    componentBuffer
   })
   renderComponentInner(node, isRoot, context)
 }
@@ -205,7 +204,7 @@ function renderComponentInner(node, isRoot, context) {
     childNode.parent = node
     context.renderStates.push({
       type: 'Component',
-      prevActive,
+      prevActive
     })
     renderNode(childNode, isRoot, context)
   }
@@ -218,7 +217,7 @@ function renderComponentInner(node, isRoot, context) {
 function renderAsyncComponent(node, isRoot, context) {
   const factory = node.asyncFactory
 
-  const resolve = (comp) => {
+  const resolve = comp => {
     if (comp.__esModule && comp.default) {
       comp = comp.default
     }
@@ -244,7 +243,7 @@ function renderAsyncComponent(node, isRoot, context) {
           type: 'Fragment',
           children: resolvedNode,
           rendered: 0,
-          total: resolvedNode.length,
+          total: resolvedNode.length
         })
         context.next()
       }
@@ -291,7 +290,7 @@ function renderStringNode(el, context) {
       children,
       rendered: 0,
       total: children.length,
-      endTag: el.close,
+      endTag: el.close
     })
     write(el.open, next)
   }
@@ -323,7 +322,7 @@ function renderElement(el, isRoot, context) {
       children,
       rendered: 0,
       total: children.length,
-      endTag,
+      endTag
     })
     write(startTag, next)
   }
@@ -342,7 +341,7 @@ function getVShowDirectiveInfo(node: VNode): VNodeDirective | undefined {
 
   while (isDef(node)) {
     if (node.data && node.data.directives) {
-      tmp = node.data.directives.find((dir) => dir.name === 'show')
+      tmp = node.data.directives.find(dir => dir.name === 'show')
       if (tmp) {
         dir = tmp
       }
@@ -439,7 +438,7 @@ export function createRenderFunction(
       isUnaryTag,
       modules,
       directives,
-      cache,
+      cache
     })
     installSSRHelpers(component)
     normalizeRender(component)
diff --git a/src/server/template-renderer/create-async-file-mapper.ts b/src/server/template-renderer/create-async-file-mapper.ts
index 168b16ace12..e09fc3a47ff 100644
--- a/src/server/template-renderer/create-async-file-mapper.ts
+++ b/src/server/template-renderer/create-async-file-mapper.ts
@@ -1,4 +1,3 @@
-
 /**
  * Creates a mapper that maps components used during a server-side render
  * to async chunk files in the client-side build, so that we can inline them
@@ -28,7 +27,7 @@ export function createMapper(clientManifest: ClientManifest): AsyncFileMapper {
 
 function createMap(clientManifest) {
   const map = new Map()
-  Object.keys(clientManifest.modules).forEach((id) => {
+  Object.keys(clientManifest.modules).forEach(id => {
     map.set(id, mapIdToFile(id, clientManifest))
   })
   return map
@@ -38,7 +37,7 @@ function mapIdToFile(id, clientManifest) {
   const files: string[] = []
   const fileIndices = clientManifest.modules[id]
   if (fileIndices) {
-    fileIndices.forEach((index) => {
+    fileIndices.forEach(index => {
       const file = clientManifest.all[index]
       // only include async files or non-js, non-css assets
       if (
diff --git a/src/server/template-renderer/index.ts b/src/server/template-renderer/index.ts
index 0048222b768..992af98c8e2 100644
--- a/src/server/template-renderer/index.ts
+++ b/src/server/template-renderer/index.ts
@@ -71,7 +71,7 @@ export default class TemplateRenderer {
     // function used to serialize initial state JSON
     this.serialize =
       options.serializer ||
-      ((state) => {
+      (state => {
         return serialize(state, { isJSON: true })
       })
 
@@ -93,7 +93,7 @@ export default class TemplateRenderer {
 
   bindRenderFns(context: Record<string, any>) {
     const renderer: any = this
-    ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach((type) => {
+    ;['ResourceHints', 'State', 'Scripts', 'Styles'].forEach(type => {
       context[`render${type}`] = renderer[`render${type}`].bind(
         renderer,
         context
@@ -205,8 +205,8 @@ export default class TemplateRenderer {
     const shouldPrefetch = this.options.shouldPrefetch
     if (this.prefetchFiles) {
       const usedAsyncFiles = this.getUsedAsyncFiles(context)
-      const alreadyRendered = (file) => {
-        return usedAsyncFiles && usedAsyncFiles.some((f) => f.file === file)
+      const alreadyRendered = file => {
+        return usedAsyncFiles && usedAsyncFiles.some(f => f.file === file)
       }
       return this.prefetchFiles
         .map(({ file, fileWithoutQuery, asType }) => {
diff --git a/src/server/template-renderer/parse-template.ts b/src/server/template-renderer/parse-template.ts
index 7aedead5556..29baf23b546 100644
--- a/src/server/template-renderer/parse-template.ts
+++ b/src/server/template-renderer/parse-template.ts
@@ -1,8 +1,7 @@
-
 const compile = require('lodash.template')
 const compileOptions = {
   escape: /{{([^{][\s\S]+?[^}])}}/g,
-  interpolate: /{{{([\s\S]+?)}}}/g,
+  interpolate: /{{{([\s\S]+?)}}}/g
 }
 
 export type ParsedTemplate = {
@@ -36,9 +35,6 @@ export function parseTemplate(
   return {
     head: compile(template.slice(0, i), compileOptions),
     neck: compile(template.slice(i, j), compileOptions),
-    tail: compile(
-      template.slice(j + contentPlaceholder.length),
-      compileOptions
-    ),
+    tail: compile(template.slice(j + contentPlaceholder.length), compileOptions)
   }
 }
diff --git a/src/server/template-renderer/template-stream.ts b/src/server/template-renderer/template-stream.ts
index 438161f984e..38fe7ba37f4 100644
--- a/src/server/template-renderer/template-stream.ts
+++ b/src/server/template-renderer/template-stream.ts
@@ -1,4 +1,3 @@
-
 // const Transform = require("stream").Transform;
 import type TemplateRenderer from './index'
 import type { ParsedTemplate } from './parse-template'
diff --git a/src/server/util.ts b/src/server/util.ts
index 428f5703be6..5e607b24545 100644
--- a/src/server/util.ts
+++ b/src/server/util.ts
@@ -1,4 +1,3 @@
-
 export const isJS = (file: string): boolean => /\.js(\?[^.]+)?$/.test(file)
 
 export const isCSS = (file: string): boolean => /\.css(\?[^.]+)?$/.test(file)
diff --git a/src/server/webpack-plugin/client.ts b/src/server/webpack-plugin/client.ts
index b8a9a0bf4f5..d95061e0279 100644
--- a/src/server/webpack-plugin/client.ts
+++ b/src/server/webpack-plugin/client.ts
@@ -1,36 +1,36 @@
-const hash = require("hash-sum");
-const uniq = require("lodash.uniq");
-import { isJS, isCSS, getAssetName, onEmit, stripModuleIdHash } from "./util";
+const hash = require('hash-sum')
+const uniq = require('lodash.uniq')
+import { isJS, isCSS, getAssetName, onEmit, stripModuleIdHash } from './util'
 
 export default class VueSSRClientPlugin {
   constructor(options = {}) {
     //@ts-expect-error no type on options
     this.options = Object.assign(
       {
-        filename: "vue-ssr-client-manifest.json",
+        filename: 'vue-ssr-client-manifest.json'
       },
       options
-    );
+    )
   }
 
   apply(compiler) {
-    const stage = "PROCESS_ASSETS_STAGE_ADDITIONAL";
-    onEmit(compiler, "vue-client-plugin", stage, (compilation, cb) => {
-      const stats = compilation.getStats().toJson();
+    const stage = 'PROCESS_ASSETS_STAGE_ADDITIONAL'
+    onEmit(compiler, 'vue-client-plugin', stage, (compilation, cb) => {
+      const stats = compilation.getStats().toJson()
 
-      const allFiles = uniq(stats.assets.map((a) => a.name));
+      const allFiles = uniq(stats.assets.map(a => a.name))
 
       const initialFiles = uniq(
         Object.keys(stats.entrypoints)
-          .map((name) => stats.entrypoints[name].assets)
+          .map(name => stats.entrypoints[name].assets)
           .reduce((assets, all) => all.concat(assets), [])
           .map(getAssetName)
-          .filter((file) => isJS(file) || isCSS(file))
-      );
+          .filter(file => isJS(file) || isCSS(file))
+      )
 
       const asyncFiles = allFiles
-        .filter((file) => isJS(file) || isCSS(file))
-        .filter((file) => initialFiles.indexOf(file) < 0);
+        .filter(file => isJS(file) || isCSS(file))
+        .filter(file => initialFiles.indexOf(file) < 0)
 
       const manifest = {
         publicPath: stats.publicPath,
@@ -39,38 +39,38 @@ export default class VueSSRClientPlugin {
         async: asyncFiles,
         modules: {
           /* [identifier: string]: Array<index: number> */
-        },
-      };
+        }
+      }
 
-      const assetModules = stats.modules.filter((m) => m.assets.length);
-      const fileToIndex = (asset) => manifest.all.indexOf(getAssetName(asset));
-      stats.modules.forEach((m) => {
+      const assetModules = stats.modules.filter(m => m.assets.length)
+      const fileToIndex = asset => manifest.all.indexOf(getAssetName(asset))
+      stats.modules.forEach(m => {
         // ignore modules duplicated in multiple chunks
         if (m.chunks.length === 1) {
-          const cid = m.chunks[0];
-          const chunk = stats.chunks.find((c) => c.id === cid);
+          const cid = m.chunks[0]
+          const chunk = stats.chunks.find(c => c.id === cid)
           if (!chunk || !chunk.files) {
-            return;
+            return
           }
-          const id = stripModuleIdHash(m.identifier);
+          const id = stripModuleIdHash(m.identifier)
           const files = (manifest.modules[hash(id)] =
-            chunk.files.map(fileToIndex));
+            chunk.files.map(fileToIndex))
           // find all asset modules associated with the same chunk
-          assetModules.forEach((m) => {
-            if (m.chunks.some((id) => id === cid)) {
-              files.push.apply(files, m.assets.map(fileToIndex));
+          assetModules.forEach(m => {
+            if (m.chunks.some(id => id === cid)) {
+              files.push.apply(files, m.assets.map(fileToIndex))
             }
-          });
+          })
         }
-      });
+      })
 
-      const json = JSON.stringify(manifest, null, 2);
+      const json = JSON.stringify(manifest, null, 2)
       //@ts-expect-error no type on options
       compilation.assets[this.options.filename] = {
         source: () => json,
-        size: () => json.length,
-      };
-      cb();
-    });
+        size: () => json.length
+      }
+      cb()
+    })
   }
 }
diff --git a/src/server/webpack-plugin/server.ts b/src/server/webpack-plugin/server.ts
index 560598c3db8..439335ef9cd 100644
--- a/src/server/webpack-plugin/server.ts
+++ b/src/server/webpack-plugin/server.ts
@@ -5,7 +5,7 @@ export default class VueSSRServerPlugin {
     //@ts-expect-error
     this.options = Object.assign(
       {
-        filename: 'vue-ssr-server-bundle.json',
+        filename: 'vue-ssr-server-bundle.json'
       },
       options
     )
@@ -25,9 +25,7 @@ export default class VueSSRServerPlugin {
         return cb()
       }
 
-      const entryAssets = entryInfo.assets
-        .map(getAssetName)
-        .filter(isJS)
+      const entryAssets = entryInfo.assets.map(getAssetName).filter(isJS)
 
       if (entryAssets.length > 1) {
         throw new Error(
@@ -46,14 +44,16 @@ export default class VueSSRServerPlugin {
       const bundle = {
         entry,
         files: {},
-        maps: {},
+        maps: {}
       }
 
       Object.keys(compilation.assets).forEach(name => {
         if (isJS(name)) {
           bundle.files[name] = compilation.assets[name].source()
         } else if (name.match(/\.js\.map$/)) {
-          bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(compilation.assets[name].source())
+          bundle.maps[name.replace(/\.map$/, '')] = JSON.parse(
+            compilation.assets[name].source()
+          )
         }
         // do not emit anything else for server
         delete compilation.assets[name]
@@ -65,7 +65,7 @@ export default class VueSSRServerPlugin {
 
       compilation.assets[filename] = {
         source: () => json,
-        size: () => json.length,
+        size: () => json.length
       }
 
       cb()
diff --git a/src/server/webpack-plugin/util.ts b/src/server/webpack-plugin/util.ts
index 844671bbd7a..1af5a7f28e5 100644
--- a/src/server/webpack-plugin/util.ts
+++ b/src/server/webpack-plugin/util.ts
@@ -2,8 +2,8 @@ const { red, yellow } = require('chalk')
 const webpack = require('webpack')
 
 const prefix = `[vue-server-renderer-webpack-plugin]`
-const warn = exports.warn = msg => console.error(red(`${prefix} ${msg}\n`))
-const tip = exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`))
+const warn = (exports.warn = msg => console.error(red(`${prefix} ${msg}\n`)))
+const tip = (exports.tip = msg => console.log(yellow(`${prefix} ${msg}\n`)))
 
 const isWebpack5 = !!(webpack.version && webpack.version[0] > 4)
 
@@ -27,7 +27,7 @@ export const validate = compiler => {
   if (!compiler.options.externals) {
     tip(
       'It is recommended to externalize dependencies in the server build for ' +
-      'better build performance.'
+        'better build performance.'
     )
   }
 }
@@ -41,9 +41,12 @@ export const onEmit = (compiler, name, stageName, hook) => {
         return
       }
       const stage = webpack.Compilation[stageName]
-      compilation.hooks.processAssets.tapAsync({ name, stage }, (assets, cb) => {
-        hook(compilation, cb)
-      })
+      compilation.hooks.processAssets.tapAsync(
+        { name, stage },
+        (assets, cb) => {
+          hook(compilation, cb)
+        }
+      )
     })
   } else if (compiler.hooks) {
     // Webpack >= 4.0.0
diff --git a/src/server/write.ts b/src/server/write.ts
index d48aa672520..925c0f96588 100644
--- a/src/server/write.ts
+++ b/src/server/write.ts
@@ -1,12 +1,11 @@
-
 const MAX_STACK_DEPTH = 800
-const noop = (_) => _
+const noop = _ => _
 
 const defer =
   typeof process !== 'undefined' && process.nextTick
     ? process.nextTick
     : typeof Promise !== 'undefined'
-    ? (fn) => Promise.resolve().then(fn)
+    ? fn => Promise.resolve().then(fn)
     : typeof setTimeout !== 'undefined'
     ? setTimeout
     : noop
diff --git a/src/sfc/parser.ts b/src/sfc/parser.ts
index 385b9138188..cc4c43a5935 100644
--- a/src/sfc/parser.ts
+++ b/src/sfc/parser.ts
@@ -1,4 +1,3 @@
-
 import deindent from 'de-indent'
 import { parseHTML } from 'compiler/parser/html-parser'
 import { makeMap } from 'shared/util'
@@ -19,12 +18,12 @@ export function parseComponent(
     script: null,
     styles: [],
     customBlocks: [],
-    errors: [],
+    errors: []
   }
   let depth = 0
   let currentBlock: SFCBlock | null = null
 
-  let warn: any = (msg) => {
+  let warn: any = msg => {
     sfc.errors.push(msg)
   }
 
@@ -56,7 +55,7 @@ export function parseComponent(
         attrs: attrs.reduce((cumulated, { name, value }) => {
           cumulated[name] = value || true
           return cumulated
-        }, {}),
+        }, {})
       }
       if (isSpecialTag(tag)) {
         checkAttrs(currentBlock, attrs)
@@ -125,7 +124,7 @@ export function parseComponent(
     warn,
     start,
     end,
-    outputSourceRange: options.outputSourceRange,
+    outputSourceRange: options.outputSourceRange
   })
 
   return sfc
diff --git a/src/shared/constants.ts b/src/shared/constants.ts
index e4814c0f773..990bfcb49be 100644
--- a/src/shared/constants.ts
+++ b/src/shared/constants.ts
@@ -14,5 +14,5 @@ export const LIFECYCLE_HOOKS = [
   'activated',
   'deactivated',
   'errorCaptured',
-  'serverPrefetch',
+  'serverPrefetch'
 ] as const
diff --git a/src/shared/util.ts b/src/shared/util.ts
index b63d959a433..468c2af21bf 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -1,4 +1,3 @@
-
 export const emptyObject: Record<string, any> = Object.freeze({})
 
 // These helpers produce better VM code in JS engines due to their
@@ -98,7 +97,6 @@ export function toNumber(val: string): number | string {
   return isNaN(n) ? val : n
 }
 
-
 /**
  * Make a map and return a function for checking if a key
  * is in that map.
@@ -112,7 +110,7 @@ export function makeMap(
   for (let i = 0; i < list.length; i++) {
     map[list[i]] = true
   }
-  return expectsLowerCase ? (val) => map[val.toLowerCase()] : (val) => map[val]
+  return expectsLowerCase ? val => map[val.toLowerCase()] : val => map[val]
 }
 
 /**
@@ -306,7 +304,7 @@ export function looseEqual(a: any, b: any): boolean {
         const keysB = Object.keys(b)
         return (
           keysA.length === keysB.length &&
-          keysA.every((key) => {
+          keysA.every(key => {
             return looseEqual(a[key], b[key])
           })
         )
diff --git a/test/e2e/.eslintrc.json b/test/e2e/.eslintrc.json
deleted file mode 100644
index e866525fec5..00000000000
--- a/test/e2e/.eslintrc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "indent": 0
-  }
-}
diff --git a/test/e2e/commits.mock.ts b/test/e2e/commits.mock.ts
index 9ef89cb3bf9..c13e127d736 100644
--- a/test/e2e/commits.mock.ts
+++ b/test/e2e/commits.mock.ts
@@ -1,575 +1,551 @@
 export default {
   main: [
     {
-      sha: "0948d999f2fddf9f90991956493f976273c5da1f",
+      sha: '0948d999f2fddf9f90991956493f976273c5da1f',
       node_id:
-        "MDY6Q29tbWl0MTE3MzAzNDI6MDk0OGQ5OTlmMmZkZGY5ZjkwOTkxOTU2NDkzZjk3NjI3M2M1ZGExZg==",
+        'MDY6Q29tbWl0MTE3MzAzNDI6MDk0OGQ5OTlmMmZkZGY5ZjkwOTkxOTU2NDkzZjk3NjI3M2M1ZGExZg==',
       commit: {
         author: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2017-10-13T03:07:14Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2017-10-13T03:07:14Z'
         },
         committer: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2017-10-13T03:07:14Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2017-10-13T03:07:14Z'
         },
-        message: "build: release 2.5.0",
+        message: 'build: release 2.5.0',
         tree: {
-          sha: "7846816b875eb664ddf718fad04a720efeac72d0",
-          url:
-            "https://api.github.com/repos/vuejs/vue/git/trees/7846816b875eb664ddf718fad04a720efeac72d0"
+          sha: '7846816b875eb664ddf718fad04a720efeac72d0',
+          url: 'https://api.github.com/repos/vuejs/vue/git/trees/7846816b875eb664ddf718fad04a720efeac72d0'
         },
-        url:
-          "https://api.github.com/repos/vuejs/vue/git/commits/0948d999f2fddf9f90991956493f976273c5da1f",
+        url: 'https://api.github.com/repos/vuejs/vue/git/commits/0948d999f2fddf9f90991956493f976273c5da1f',
         comment_count: 0,
         verification: {
           verified: false,
-          reason: "unsigned",
+          reason: 'unsigned',
           signature: null,
           payload: null
         }
       },
-      url:
-        "https://api.github.com/repos/vuejs/vue/commits/0948d999f2fddf9f90991956493f976273c5da1f",
+      url: 'https://api.github.com/repos/vuejs/vue/commits/0948d999f2fddf9f90991956493f976273c5da1f',
       html_url:
-        "https://github.com/vuejs/vue/commit/0948d999f2fddf9f90991956493f976273c5da1f",
+        'https://github.com/vuejs/vue/commit/0948d999f2fddf9f90991956493f976273c5da1f',
       comments_url:
-        "https://api.github.com/repos/vuejs/vue/commits/0948d999f2fddf9f90991956493f976273c5da1f/comments",
+        'https://api.github.com/repos/vuejs/vue/commits/0948d999f2fddf9f90991956493f976273c5da1f/comments',
       author: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       committer: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       parents: [
         {
-          sha: "bc2918f0e596d0e133a25606cbb66075402ce6c3",
-          url:
-            "https://api.github.com/repos/vuejs/vue/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3",
+          sha: 'bc2918f0e596d0e133a25606cbb66075402ce6c3',
+          url: 'https://api.github.com/repos/vuejs/vue/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3',
           html_url:
-            "https://github.com/vuejs/vue/commit/bc2918f0e596d0e133a25606cbb66075402ce6c3"
+            'https://github.com/vuejs/vue/commit/bc2918f0e596d0e133a25606cbb66075402ce6c3'
         }
       ]
     },
     {
-      sha: "bc2918f0e596d0e133a25606cbb66075402ce6c3",
+      sha: 'bc2918f0e596d0e133a25606cbb66075402ce6c3',
       node_id:
-        "MDY6Q29tbWl0MTE3MzAzNDI6YmMyOTE4ZjBlNTk2ZDBlMTMzYTI1NjA2Y2JiNjYwNzU0MDJjZTZjMw==",
+        'MDY6Q29tbWl0MTE3MzAzNDI6YmMyOTE4ZjBlNTk2ZDBlMTMzYTI1NjA2Y2JiNjYwNzU0MDJjZTZjMw==',
       commit: {
         author: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2017-10-13T03:04:35Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2017-10-13T03:04:35Z'
         },
         committer: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2017-10-13T03:04:35Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2017-10-13T03:04:35Z'
         },
-        message: "build: build 2.5.0",
+        message: 'build: build 2.5.0',
         tree: {
-          sha: "5c57af855d76df68ec0782a2d2f4cd0a54e80125",
-          url:
-            "https://api.github.com/repos/vuejs/vue/git/trees/5c57af855d76df68ec0782a2d2f4cd0a54e80125"
+          sha: '5c57af855d76df68ec0782a2d2f4cd0a54e80125',
+          url: 'https://api.github.com/repos/vuejs/vue/git/trees/5c57af855d76df68ec0782a2d2f4cd0a54e80125'
         },
-        url:
-          "https://api.github.com/repos/vuejs/vue/git/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3",
+        url: 'https://api.github.com/repos/vuejs/vue/git/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3',
         comment_count: 0,
         verification: {
           verified: false,
-          reason: "unsigned",
+          reason: 'unsigned',
           signature: null,
           payload: null
         }
       },
-      url:
-        "https://api.github.com/repos/vuejs/vue/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3",
+      url: 'https://api.github.com/repos/vuejs/vue/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3',
       html_url:
-        "https://github.com/vuejs/vue/commit/bc2918f0e596d0e133a25606cbb66075402ce6c3",
+        'https://github.com/vuejs/vue/commit/bc2918f0e596d0e133a25606cbb66075402ce6c3',
       comments_url:
-        "https://api.github.com/repos/vuejs/vue/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3/comments",
+        'https://api.github.com/repos/vuejs/vue/commits/bc2918f0e596d0e133a25606cbb66075402ce6c3/comments',
       author: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       committer: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       parents: [
         {
-          sha: "df8f179cfc3b98d6e0f48502cc5071b993d9cdb5",
-          url:
-            "https://api.github.com/repos/vuejs/vue/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5",
+          sha: 'df8f179cfc3b98d6e0f48502cc5071b993d9cdb5',
+          url: 'https://api.github.com/repos/vuejs/vue/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5',
           html_url:
-            "https://github.com/vuejs/vue/commit/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5"
+            'https://github.com/vuejs/vue/commit/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5'
         }
       ]
     },
     {
-      sha: "df8f179cfc3b98d6e0f48502cc5071b993d9cdb5",
+      sha: 'df8f179cfc3b98d6e0f48502cc5071b993d9cdb5',
       node_id:
-        "MDY6Q29tbWl0MTE3MzAzNDI6ZGY4ZjE3OWNmYzNiOThkNmUwZjQ4NTAyY2M1MDcxYjk5M2Q5Y2RiNQ==",
+        'MDY6Q29tbWl0MTE3MzAzNDI6ZGY4ZjE3OWNmYzNiOThkNmUwZjQ4NTAyY2M1MDcxYjk5M2Q5Y2RiNQ==',
       commit: {
         author: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2017-10-13T00:41:36Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2017-10-13T00:41:36Z'
         },
         committer: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2017-10-13T00:41:36Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2017-10-13T00:41:36Z'
         },
-        message: "test: make hydration spec more stable for Edge",
+        message: 'test: make hydration spec more stable for Edge',
         tree: {
-          sha: "b399dba6180378d6a04715a5624599b49b3e6454",
-          url:
-            "https://api.github.com/repos/vuejs/vue/git/trees/b399dba6180378d6a04715a5624599b49b3e6454"
+          sha: 'b399dba6180378d6a04715a5624599b49b3e6454',
+          url: 'https://api.github.com/repos/vuejs/vue/git/trees/b399dba6180378d6a04715a5624599b49b3e6454'
         },
-        url:
-          "https://api.github.com/repos/vuejs/vue/git/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5",
+        url: 'https://api.github.com/repos/vuejs/vue/git/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5',
         comment_count: 0,
         verification: {
           verified: false,
-          reason: "unsigned",
+          reason: 'unsigned',
           signature: null,
           payload: null
         }
       },
-      url:
-        "https://api.github.com/repos/vuejs/vue/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5",
+      url: 'https://api.github.com/repos/vuejs/vue/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5',
       html_url:
-        "https://github.com/vuejs/vue/commit/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5",
+        'https://github.com/vuejs/vue/commit/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5',
       comments_url:
-        "https://api.github.com/repos/vuejs/vue/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5/comments",
+        'https://api.github.com/repos/vuejs/vue/commits/df8f179cfc3b98d6e0f48502cc5071b993d9cdb5/comments',
       author: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       committer: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       parents: [
         {
-          sha: "a85f95c422e0bde6ce4068f5e44e761d4e00ca08",
-          url:
-            "https://api.github.com/repos/vuejs/vue/commits/a85f95c422e0bde6ce4068f5e44e761d4e00ca08",
+          sha: 'a85f95c422e0bde6ce4068f5e44e761d4e00ca08',
+          url: 'https://api.github.com/repos/vuejs/vue/commits/a85f95c422e0bde6ce4068f5e44e761d4e00ca08',
           html_url:
-            "https://github.com/vuejs/vue/commit/a85f95c422e0bde6ce4068f5e44e761d4e00ca08"
+            'https://github.com/vuejs/vue/commit/a85f95c422e0bde6ce4068f5e44e761d4e00ca08'
         }
       ]
     }
   ],
   dev: [
     {
-      sha: "4074104fac219e61e542f4da3a4800975a8063f2",
+      sha: '4074104fac219e61e542f4da3a4800975a8063f2',
       node_id:
-        "MDY6Q29tbWl0MTE3MzAzNDI6NDA3NDEwNGZhYzIxOWU2MWU1NDJmNGRhM2E0ODAwOTc1YTgwNjNmMg==",
+        'MDY6Q29tbWl0MTE3MzAzNDI6NDA3NDEwNGZhYzIxOWU2MWU1NDJmNGRhM2E0ODAwOTc1YTgwNjNmMg==',
       commit: {
         author: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2018-12-11T21:51:40Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2018-12-11T21:51:40Z'
         },
         committer: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2018-12-11T21:51:40Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2018-12-11T21:51:40Z'
         },
-        message: "perf: skip normalization on single child element v-for",
+        message: 'perf: skip normalization on single child element v-for',
         tree: {
-          sha: "75b999a0562d64a38eb322973c982edfa8d84fda",
-          url:
-            "https://api.github.com/repos/vuejs/vue/git/trees/75b999a0562d64a38eb322973c982edfa8d84fda"
+          sha: '75b999a0562d64a38eb322973c982edfa8d84fda',
+          url: 'https://api.github.com/repos/vuejs/vue/git/trees/75b999a0562d64a38eb322973c982edfa8d84fda'
         },
-        url:
-          "https://api.github.com/repos/vuejs/vue/git/commits/4074104fac219e61e542f4da3a4800975a8063f2",
+        url: 'https://api.github.com/repos/vuejs/vue/git/commits/4074104fac219e61e542f4da3a4800975a8063f2',
         comment_count: 0,
         verification: {
           verified: false,
-          reason: "unsigned",
+          reason: 'unsigned',
           signature: null,
           payload: null
         }
       },
-      url:
-        "https://api.github.com/repos/vuejs/vue/commits/4074104fac219e61e542f4da3a4800975a8063f2",
+      url: 'https://api.github.com/repos/vuejs/vue/commits/4074104fac219e61e542f4da3a4800975a8063f2',
       html_url:
-        "https://github.com/vuejs/vue/commit/4074104fac219e61e542f4da3a4800975a8063f2",
+        'https://github.com/vuejs/vue/commit/4074104fac219e61e542f4da3a4800975a8063f2',
       comments_url:
-        "https://api.github.com/repos/vuejs/vue/commits/4074104fac219e61e542f4da3a4800975a8063f2/comments",
+        'https://api.github.com/repos/vuejs/vue/commits/4074104fac219e61e542f4da3a4800975a8063f2/comments',
       author: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       committer: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       parents: [
         {
-          sha: "47487607fbb99339038cf84990ba341c25b5e20d",
-          url:
-            "https://api.github.com/repos/vuejs/vue/commits/47487607fbb99339038cf84990ba341c25b5e20d",
+          sha: '47487607fbb99339038cf84990ba341c25b5e20d',
+          url: 'https://api.github.com/repos/vuejs/vue/commits/47487607fbb99339038cf84990ba341c25b5e20d',
           html_url:
-            "https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d"
+            'https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d'
         }
       ]
     },
     {
-      sha: "47487607fbb99339038cf84990ba341c25b5e20d",
+      sha: '47487607fbb99339038cf84990ba341c25b5e20d',
       node_id:
-        "MDY6Q29tbWl0MTE3MzAzNDI6NDc0ODc2MDdmYmI5OTMzOTAzOGNmODQ5OTBiYTM0MWMyNWI1ZTIwZA==",
+        'MDY6Q29tbWl0MTE3MzAzNDI6NDc0ODc2MDdmYmI5OTMzOTAzOGNmODQ5OTBiYTM0MWMyNWI1ZTIwZA==',
       commit: {
         author: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2018-12-11T21:51:03Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2018-12-11T21:51:03Z'
         },
         committer: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2018-12-11T21:51:03Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2018-12-11T21:51:03Z'
         },
-        message: "fix: fix v-for component with undefined value\n\nfix #9181",
+        message: 'fix: fix v-for component with undefined value\n\nfix #9181',
         tree: {
-          sha: "cc30183c2663cd88a35a4a18f758ad0ca872805a",
-          url:
-            "https://api.github.com/repos/vuejs/vue/git/trees/cc30183c2663cd88a35a4a18f758ad0ca872805a"
+          sha: 'cc30183c2663cd88a35a4a18f758ad0ca872805a',
+          url: 'https://api.github.com/repos/vuejs/vue/git/trees/cc30183c2663cd88a35a4a18f758ad0ca872805a'
         },
-        url:
-          "https://api.github.com/repos/vuejs/vue/git/commits/47487607fbb99339038cf84990ba341c25b5e20d",
+        url: 'https://api.github.com/repos/vuejs/vue/git/commits/47487607fbb99339038cf84990ba341c25b5e20d',
         comment_count: 0,
         verification: {
           verified: false,
-          reason: "unsigned",
+          reason: 'unsigned',
           signature: null,
           payload: null
         }
       },
-      url:
-        "https://api.github.com/repos/vuejs/vue/commits/47487607fbb99339038cf84990ba341c25b5e20d",
+      url: 'https://api.github.com/repos/vuejs/vue/commits/47487607fbb99339038cf84990ba341c25b5e20d',
       html_url:
-        "https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d",
+        'https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d',
       comments_url:
-        "https://api.github.com/repos/vuejs/vue/commits/47487607fbb99339038cf84990ba341c25b5e20d/comments",
+        'https://api.github.com/repos/vuejs/vue/commits/47487607fbb99339038cf84990ba341c25b5e20d/comments',
       author: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       committer: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       parents: [
         {
-          sha: "984393fed981c58ad79ed50424f023dcfa6829d0",
-          url:
-            "https://api.github.com/repos/vuejs/vue/commits/984393fed981c58ad79ed50424f023dcfa6829d0",
+          sha: '984393fed981c58ad79ed50424f023dcfa6829d0',
+          url: 'https://api.github.com/repos/vuejs/vue/commits/984393fed981c58ad79ed50424f023dcfa6829d0',
           html_url:
-            "https://github.com/vuejs/vue/commit/984393fed981c58ad79ed50424f023dcfa6829d0"
+            'https://github.com/vuejs/vue/commit/984393fed981c58ad79ed50424f023dcfa6829d0'
         }
       ]
     },
     {
-      sha: "984393fed981c58ad79ed50424f023dcfa6829d0",
+      sha: '984393fed981c58ad79ed50424f023dcfa6829d0',
       node_id:
-        "MDY6Q29tbWl0MTE3MzAzNDI6OTg0MzkzZmVkOTgxYzU4YWQ3OWVkNTA0MjRmMDIzZGNmYTY4MjlkMA==",
+        'MDY6Q29tbWl0MTE3MzAzNDI6OTg0MzkzZmVkOTgxYzU4YWQ3OWVkNTA0MjRmMDIzZGNmYTY4MjlkMA==',
       commit: {
         author: {
-          name: "krystal",
-          email: "krystalnumber@gmail.com",
-          date: "2018-12-11T16:37:39Z"
+          name: 'krystal',
+          email: 'krystalnumber@gmail.com',
+          date: '2018-12-11T16:37:39Z'
         },
         committer: {
-          name: "Evan You",
-          email: "yyx990803@gmail.com",
-          date: "2018-12-11T16:37:39Z"
+          name: 'Evan You',
+          email: 'yyx990803@gmail.com',
+          date: '2018-12-11T16:37:39Z'
         },
         message: "test: change model text's priority case (#9170)",
         tree: {
-          sha: "9af5d03838b964ea98c3173c92c3e6e5263ee9ec",
-          url:
-            "https://api.github.com/repos/vuejs/vue/git/trees/9af5d03838b964ea98c3173c92c3e6e5263ee9ec"
+          sha: '9af5d03838b964ea98c3173c92c3e6e5263ee9ec',
+          url: 'https://api.github.com/repos/vuejs/vue/git/trees/9af5d03838b964ea98c3173c92c3e6e5263ee9ec'
         },
-        url:
-          "https://api.github.com/repos/vuejs/vue/git/commits/984393fed981c58ad79ed50424f023dcfa6829d0",
+        url: 'https://api.github.com/repos/vuejs/vue/git/commits/984393fed981c58ad79ed50424f023dcfa6829d0',
         comment_count: 0,
         verification: {
           verified: false,
-          reason: "unsigned",
+          reason: 'unsigned',
           signature: null,
           payload: null
         }
       },
-      url:
-        "https://api.github.com/repos/vuejs/vue/commits/984393fed981c58ad79ed50424f023dcfa6829d0",
+      url: 'https://api.github.com/repos/vuejs/vue/commits/984393fed981c58ad79ed50424f023dcfa6829d0',
       html_url:
-        "https://github.com/vuejs/vue/commit/984393fed981c58ad79ed50424f023dcfa6829d0",
+        'https://github.com/vuejs/vue/commit/984393fed981c58ad79ed50424f023dcfa6829d0',
       comments_url:
-        "https://api.github.com/repos/vuejs/vue/commits/984393fed981c58ad79ed50424f023dcfa6829d0/comments",
+        'https://api.github.com/repos/vuejs/vue/commits/984393fed981c58ad79ed50424f023dcfa6829d0/comments',
       author: {
-        login: "dejour",
+        login: 'dejour',
         id: 7224044,
-        node_id: "MDQ6VXNlcjcyMjQwNDQ=",
-        avatar_url: "https://avatars3.githubusercontent.com/u/7224044?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/dejour",
-        html_url: "https://github.com/dejour",
-        followers_url: "https://api.github.com/users/dejour/followers",
+        node_id: 'MDQ6VXNlcjcyMjQwNDQ=',
+        avatar_url: 'https://avatars3.githubusercontent.com/u/7224044?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/dejour',
+        html_url: 'https://github.com/dejour',
+        followers_url: 'https://api.github.com/users/dejour/followers',
         following_url:
-          "https://api.github.com/users/dejour/following{/other_user}",
-        gists_url: "https://api.github.com/users/dejour/gists{/gist_id}",
+          'https://api.github.com/users/dejour/following{/other_user}',
+        gists_url: 'https://api.github.com/users/dejour/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/dejour/starred{/owner}{/repo}",
-        subscriptions_url: "https://api.github.com/users/dejour/subscriptions",
-        organizations_url: "https://api.github.com/users/dejour/orgs",
-        repos_url: "https://api.github.com/users/dejour/repos",
-        events_url: "https://api.github.com/users/dejour/events{/privacy}",
+          'https://api.github.com/users/dejour/starred{/owner}{/repo}',
+        subscriptions_url: 'https://api.github.com/users/dejour/subscriptions',
+        organizations_url: 'https://api.github.com/users/dejour/orgs',
+        repos_url: 'https://api.github.com/users/dejour/repos',
+        events_url: 'https://api.github.com/users/dejour/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/dejour/received_events",
-        type: "User",
+          'https://api.github.com/users/dejour/received_events',
+        type: 'User',
         site_admin: false
       },
       committer: {
-        login: "yyx990803",
+        login: 'yyx990803',
         id: 499550,
-        node_id: "MDQ6VXNlcjQ5OTU1MA==",
-        avatar_url: "https://avatars1.githubusercontent.com/u/499550?v=4",
-        gravatar_id: "",
-        url: "https://api.github.com/users/yyx990803",
-        html_url: "https://github.com/yyx990803",
-        followers_url: "https://api.github.com/users/yyx990803/followers",
+        node_id: 'MDQ6VXNlcjQ5OTU1MA==',
+        avatar_url: 'https://avatars1.githubusercontent.com/u/499550?v=4',
+        gravatar_id: '',
+        url: 'https://api.github.com/users/yyx990803',
+        html_url: 'https://github.com/yyx990803',
+        followers_url: 'https://api.github.com/users/yyx990803/followers',
         following_url:
-          "https://api.github.com/users/yyx990803/following{/other_user}",
-        gists_url: "https://api.github.com/users/yyx990803/gists{/gist_id}",
+          'https://api.github.com/users/yyx990803/following{/other_user}',
+        gists_url: 'https://api.github.com/users/yyx990803/gists{/gist_id}',
         starred_url:
-          "https://api.github.com/users/yyx990803/starred{/owner}{/repo}",
+          'https://api.github.com/users/yyx990803/starred{/owner}{/repo}',
         subscriptions_url:
-          "https://api.github.com/users/yyx990803/subscriptions",
-        organizations_url: "https://api.github.com/users/yyx990803/orgs",
-        repos_url: "https://api.github.com/users/yyx990803/repos",
-        events_url: "https://api.github.com/users/yyx990803/events{/privacy}",
+          'https://api.github.com/users/yyx990803/subscriptions',
+        organizations_url: 'https://api.github.com/users/yyx990803/orgs',
+        repos_url: 'https://api.github.com/users/yyx990803/repos',
+        events_url: 'https://api.github.com/users/yyx990803/events{/privacy}',
         received_events_url:
-          "https://api.github.com/users/yyx990803/received_events",
-        type: "User",
+          'https://api.github.com/users/yyx990803/received_events',
+        type: 'User',
         site_admin: false
       },
       parents: [
         {
-          sha: "6980035a86cfb79368af77a5040e468177d6b14a",
-          url:
-            "https://api.github.com/repos/vuejs/vue/commits/6980035a86cfb79368af77a5040e468177d6b14a",
+          sha: '6980035a86cfb79368af77a5040e468177d6b14a',
+          url: 'https://api.github.com/repos/vuejs/vue/commits/6980035a86cfb79368af77a5040e468177d6b14a',
           html_url:
-            "https://github.com/vuejs/vue/commit/6980035a86cfb79368af77a5040e468177d6b14a"
+            'https://github.com/vuejs/vue/commit/6980035a86cfb79368af77a5040e468177d6b14a'
         }
       ]
     }
   ]
-};
+}
diff --git a/test/e2e/commits.spec.ts b/test/e2e/commits.spec.ts
index ab299933a07..73e94667f1e 100644
--- a/test/e2e/commits.spec.ts
+++ b/test/e2e/commits.spec.ts
@@ -8,7 +8,7 @@ describe('e2e: commits', () => {
   async function testCommits(apiType: 'classic' | 'composition') {
     // intercept and mock the response to avoid hitting the actual API
     await page().setRequestInterception(true)
-    page().on('request', (req) => {
+    page().on('request', req => {
       const match = req.url().match(/&sha=(.*)$/)
       if (!match) {
         req.continue()
diff --git a/test/e2e/e2eUtils.ts b/test/e2e/e2eUtils.ts
index 58b81a9671e..d9224e62e1c 100644
--- a/test/e2e/e2eUtils.ts
+++ b/test/e2e/e2eUtils.ts
@@ -1,7 +1,10 @@
 import path from 'path'
 import puppeteer from 'puppeteer'
 
-export function getExampleUrl(name: string, apiType: 'classic' | 'composition') {
+export function getExampleUrl(
+  name: string,
+  apiType: 'classic' | 'composition'
+) {
   return `file://${path.resolve(
     __dirname,
     `../../examples/${apiType}/${name}/index.html`
@@ -15,7 +18,7 @@ const puppeteerOptions = process.env.CI
   : { headless: !process.env.DEBUG }
 
 const maxTries = 30
-export const timeout = (n: number) => new Promise((r) => setTimeout(r, n))
+export const timeout = (n: number) => new Promise(r => setTimeout(r, n))
 
 export async function expectByPolling(
   poll: () => Promise<any>,
@@ -47,7 +50,7 @@ export function setupPuppeteer() {
       localStorage.clear()
     })
 
-    page.on('console', (e) => {
+    page.on('console', e => {
       if (e.type() === 'error') {
         const err = e.args()[0]
         console.error(
@@ -75,18 +78,15 @@ export function setupPuppeteer() {
   }
 
   async function text(selector: string) {
-    return await page.$eval(selector, (node) => node.textContent)
+    return await page.$eval(selector, node => node.textContent)
   }
 
   async function value(selector: string) {
-    return await page.$eval(
-      selector,
-      (node) => (node as HTMLInputElement).value
-    )
+    return await page.$eval(selector, node => (node as HTMLInputElement).value)
   }
 
   async function html(selector: string) {
-    return await page.$eval(selector, (node) => node.innerHTML)
+    return await page.$eval(selector, node => node.innerHTML)
   }
 
   async function classList(selector: string) {
@@ -98,7 +98,7 @@ export function setupPuppeteer() {
   }
 
   async function isVisible(selector: string) {
-    const display = await page.$eval(selector, (node) => {
+    const display = await page.$eval(selector, node => {
       return window.getComputedStyle(node).display
     })
     return display !== 'none'
@@ -107,12 +107,12 @@ export function setupPuppeteer() {
   async function isChecked(selector: string) {
     return await page.$eval(
       selector,
-      (node) => (node as HTMLInputElement).checked
+      node => (node as HTMLInputElement).checked
     )
   }
 
   async function isFocused(selector: string) {
-    return await page.$eval(selector, (node) => node === document.activeElement)
+    return await page.$eval(selector, node => node === document.activeElement)
   }
 
   async function setValue(selector: string, value: string) {
@@ -128,13 +128,13 @@ export function setupPuppeteer() {
 
   async function typeValue(selector: string, value: string) {
     const el = (await page.$(selector))!
-    await el.evaluate((node) => ((node as HTMLInputElement).value = ''))
+    await el.evaluate(node => ((node as HTMLInputElement).value = ''))
     await el.type(value)
   }
 
   async function enterValue(selector: string, value: string) {
     const el = (await page.$(selector))!
-    await el.evaluate((node) => ((node as HTMLInputElement).value = ''))
+    await el.evaluate(node => ((node as HTMLInputElement).value = ''))
     await el.type(value)
     await el.press('Enter')
   }
@@ -142,13 +142,13 @@ export function setupPuppeteer() {
   async function clearValue(selector: string) {
     return await page.$eval(
       selector,
-      (node) => ((node as HTMLInputElement).value = '')
+      node => ((node as HTMLInputElement).value = '')
     )
   }
 
   function timeout(time: number) {
-    return page.evaluate((time) => {
-      return new Promise((r) => {
+    return page.evaluate(time => {
+      return new Promise(r => {
         setTimeout(r, time)
       })
     }, time)
@@ -156,7 +156,7 @@ export function setupPuppeteer() {
 
   function nextFrame() {
     return page.evaluate(() => {
-      return new Promise((resolve) => {
+      return new Promise(resolve => {
         requestAnimationFrame(() => {
           requestAnimationFrame(resolve)
         })
diff --git a/test/e2e/svg.spec.ts b/test/e2e/svg.spec.ts
index f966407c4e5..e8584e87dd3 100644
--- a/test/e2e/svg.spec.ts
+++ b/test/e2e/svg.spec.ts
@@ -21,7 +21,7 @@ describe('e2e: svg', () => {
   async function assertPolygon(total: number) {
     expect(
       await page().evaluate(
-        (total) => {
+        total => {
           const points = stats
             .map((stat, i) => {
               const point = valueToPoint(stat.value, i, total)
@@ -40,7 +40,7 @@ describe('e2e: svg', () => {
   // assert the position of each label is correct
   async function assertLabels(total: number) {
     const positions = await page().evaluate(
-      (total) => {
+      total => {
         return stats.map((stat, i) => {
           const point = valueToPoint(+stat.value + 10, i, total)
           return [point.x, point.y]
@@ -51,7 +51,7 @@ describe('e2e: svg', () => {
     for (let i = 0; i < total; i++) {
       const textPosition = await page().$eval(
         `text:nth-child(${i + 3})`,
-        (node) => [+node.attributes[0].value, +node.attributes[1].value]
+        node => [+node.attributes[0].value, +node.attributes[1].value]
       )
       expect(textPosition).toEqual(positions[i])
     }
@@ -60,7 +60,7 @@ describe('e2e: svg', () => {
   // assert each value of stats is correct
   async function assertStats(expected: number[]) {
     const statsValue = await page().evaluate(() => {
-      return stats.map((stat) => +stat.value)
+      return stats.map(stat => +stat.value)
     })
     expect(statsValue).toEqual(expected)
   }
diff --git a/test/helpers/.eslintrc.json b/test/helpers/.eslintrc.json
deleted file mode 100644
index de3ffc6bd74..00000000000
--- a/test/helpers/.eslintrc.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "env": {
-    "jasmine": true
-  },
-  "globals": {
-    "waitForUpdate": true
-  }
-}
diff --git a/test/helpers/test-object-option.ts b/test/helpers/test-object-option.ts
index 058929291c8..39be7ee8b29 100644
--- a/test/helpers/test-object-option.ts
+++ b/test/helpers/test-object-option.ts
@@ -1,6 +1,6 @@
 import Vue from 'vue'
 
-export default function testObjectOption (name) {
+export default function testObjectOption(name) {
   it(`Options ${name}: should warn non object value`, () => {
     const options = {}
     options[name] = () => {}
diff --git a/test/helpers/to-have-warned.ts b/test/helpers/to-have-warned.ts
index 1a931595eaa..2aca2bdcfd1 100644
--- a/test/helpers/to-have-warned.ts
+++ b/test/helpers/to-have-warned.ts
@@ -3,7 +3,7 @@ import { SpyInstance } from 'vitest'
 expect.extend({
   toHaveBeenWarned(received: string) {
     asserted.add(received)
-    const passed = warn.mock.calls.some((args) =>
+    const passed = warn.mock.calls.some(args =>
       String(args[0]).includes(received)
     )
     if (passed) {
@@ -12,7 +12,7 @@ expect.extend({
         message: () => `expected "${received}" not to have been warned.`
       }
     } else {
-      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      const msgs = warn.mock.calls.map(args => args[0]).join('\n - ')
       return {
         pass: false,
         message: () =>
@@ -34,7 +34,7 @@ expect.extend({
         message: () => `expected "${received}" not to have been warned last.`
       }
     } else {
-      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      const msgs = warn.mock.calls.map(args => args[0]).join('\n - ')
       return {
         pass: false,
         message: () =>
@@ -46,7 +46,7 @@ expect.extend({
   toHaveBeenWarnedTimes(received: string, n: number) {
     asserted.add(received)
     let found = 0
-    warn.mock.calls.forEach((args) => {
+    warn.mock.calls.forEach(args => {
       if (args[0].includes(received)) {
         found++
       }
@@ -67,14 +67,14 @@ expect.extend({
   },
 
   toHaveBeenTipped(received: string) {
-    const passed = tip.mock.calls.some((args) => args[0].includes(received))
+    const passed = tip.mock.calls.some(args => args[0].includes(received))
     if (passed) {
       return {
         pass: true,
         message: () => `expected "${received}" not to have been tipped.`
       }
     } else {
-      const msgs = warn.mock.calls.map((args) => args[0]).join('\n - ')
+      const msgs = warn.mock.calls.map(args => args[0]).join('\n - ')
       return {
         pass: false,
         message: () =>
@@ -101,9 +101,9 @@ beforeEach(() => {
 afterEach(() => {
   const assertedArray = Array.from(asserted)
   const nonAssertedWarnings = warn.mock.calls
-    .map((args) => args[0])
-    .filter((received) => {
-      return !assertedArray.some((assertedMsg) => {
+    .map(args => args[0])
+    .filter(received => {
+      return !assertedArray.some(assertedMsg => {
         return String(received).includes(assertedMsg)
       })
     })
diff --git a/test/helpers/trigger-event.ts b/test/helpers/trigger-event.ts
index 6dedd95cdef..cbe5e76531e 100644
--- a/test/helpers/trigger-event.ts
+++ b/test/helpers/trigger-event.ts
@@ -1,9 +1,9 @@
-export function triggerEvent (target, event, process) {
+export function triggerEvent(target, event, process) {
   const e = document.createEvent('HTMLEvents')
   e.initEvent(event, true, true)
   if (event === 'click') {
     // @ts-expect-error Button is readonly
-    (e as MouseEvent).button = 0
+    ;(e as MouseEvent).button = 0
   }
   if (process) process(e)
   target.dispatchEvent(e)
diff --git a/test/helpers/wait-for-update.ts b/test/helpers/wait-for-update.ts
index 1898466b7b8..9adf35fcd63 100644
--- a/test/helpers/wait-for-update.ts
+++ b/test/helpers/wait-for-update.ts
@@ -53,11 +53,11 @@ const waitForUpdate = (initialCb: Job) => {
   })
 
   const chainer = {
-    then: (nextCb) => {
+    then: nextCb => {
       queue.push(nextCb)
       return chainer
     },
-    thenWaitFor: (wait) => {
+    thenWaitFor: wait => {
       if (typeof wait === 'number') {
         wait = timeout(wait)
       }
@@ -65,7 +65,7 @@ const waitForUpdate = (initialCb: Job) => {
       queue.push(wait)
       return chainer
     },
-    end: (endFn) => {
+    end: endFn => {
       queue.push(endFn)
       end = endFn
     }
@@ -75,7 +75,7 @@ const waitForUpdate = (initialCb: Job) => {
 }
 
 function timeout(n) {
-  return (next) => setTimeout(next, n)
+  return next => setTimeout(next, n)
 }
 
 export { waitForUpdate }
diff --git a/test/ssr/compile-with-webpack.ts b/test/ssr/compile-with-webpack.ts
index 334911c76ca..a76d511eec8 100644
--- a/test/ssr/compile-with-webpack.ts
+++ b/test/ssr/compile-with-webpack.ts
@@ -37,7 +37,7 @@ export function compileWithWebpack(
   compiler.outputFileSystem = fs
 
   return new Promise<MemoryFS>((resolve, reject) => {
-    compiler.run((err) => {
+    compiler.run(err => {
       if (err) {
         reject(err)
       } else {
diff --git a/test/ssr/ssr-basic-renderer.spec.ts b/test/ssr/ssr-basic-renderer.spec.ts
index 286ec9104aa..f47ef73d4cf 100644
--- a/test/ssr/ssr-basic-renderer.spec.ts
+++ b/test/ssr/ssr-basic-renderer.spec.ts
@@ -5,8 +5,9 @@ import renderToString from 'web/entry-server-basic-renderer'
 
 describe('SSR: basicRenderer', () => {
   it('should work', done => {
-    renderToString(new Vue({
-      template: `
+    renderToString(
+      new Vue({
+        template: `
         <div>
           <p class="hi">yoyo</p>
           <div id="ho" :class="{ red: isRed }"></div>
@@ -17,56 +18,65 @@ describe('SSR: basicRenderer', () => {
           <test-async></test-async>
         </div>
       `,
-      data: {
-        test: 'hi',
-        isRed: true,
-        imageUrl: 'https://vuejs.org/images/logo.png'
-      },
-      components: {
-        test: {
-          render () {
-            return this.$createElement('div', { class: ['a'] }, 'test')
-          }
+        data: {
+          test: 'hi',
+          isRed: true,
+          imageUrl: 'https://vuejs.org/images/logo.png'
         },
-        testAsync (resolve) {
-          resolve({
-            render () {
-              return this.$createElement('span', { class: ['b'] }, 'testAsync')
+        components: {
+          test: {
+            render() {
+              return this.$createElement('div', { class: ['a'] }, 'test')
             }
-          })
+          },
+          testAsync(resolve) {
+            resolve({
+              render() {
+                return this.$createElement(
+                  'span',
+                  { class: ['b'] },
+                  'testAsync'
+                )
+              }
+            })
+          }
         }
+      }),
+      (err, result) => {
+        expect(err).toBeNull()
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<p class="hi">yoyo</p> ' +
+            '<div id="ho" class="red"></div> ' +
+            '<span>hi</span> ' +
+            '<input value="hi"> ' +
+            '<img src="https://vuejs.org/images/logo.png"> ' +
+            '<div class="a">test</div> ' +
+            '<span class="b">testAsync</span>' +
+            '</div>'
+        )
+        done()
       }
-    }), (err, result) => {
-      expect(err).toBeNull()
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<p class="hi">yoyo</p> ' +
-          '<div id="ho" class="red"></div> ' +
-          '<span>hi</span> ' +
-          '<input value="hi"> ' +
-          '<img src="https://vuejs.org/images/logo.png"> ' +
-          '<div class="a">test</div> ' +
-          '<span class="b">testAsync</span>' +
-        '</div>'
-      )
-      done()
-    })
+    )
   })
 
   // #5941
   it('should work properly when accessing $ssrContext in root component', done => {
     let ssrContext
-    renderToString(new Vue({
-      template: `
+    renderToString(
+      new Vue({
+        template: `
         <div></div>
       `,
-      created () {
-        ssrContext = this.$ssrContext
+        created() {
+          ssrContext = this.$ssrContext
+        }
+      }),
+      err => {
+        expect(err).toBeNull()
+        expect(ssrContext).toBeUndefined()
+        done()
       }
-    }), (err) => {
-      expect(err).toBeNull()
-      expect(ssrContext).toBeUndefined()
-      done()
-    })
+    )
   })
 })
diff --git a/test/ssr/ssr-bundle-render.spec.ts b/test/ssr/ssr-bundle-render.spec.ts
index fc2161276d8..78ce3301e67 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/test/ssr/ssr-bundle-render.spec.ts
@@ -28,7 +28,7 @@ function createAssertions(runInNewContext) {
     const res = await new Promise((resolve, reject) => {
       const stream = renderer.renderToStream(context)
       let res = ''
-      stream.on('data', (chunk) => {
+      stream.on('data', chunk => {
         res += chunk.toString()
       })
       stream.on('error', reject)
@@ -68,7 +68,7 @@ function createAssertions(runInNewContext) {
       runInNewContext
     })
 
-    const err = await new Promise<Error>((resolve) => {
+    const err = await new Promise<Error>(resolve => {
       const stream = renderer.renderToStream()
       stream.on('error', resolve)
     })
@@ -81,7 +81,7 @@ function createAssertions(runInNewContext) {
       runInNewContext
     })
 
-    const err = await new Promise<Error>((resolve) => {
+    const err = await new Promise<Error>(resolve => {
       const stream = renderer.renderToStream()
       stream.on('error', resolve)
     })
@@ -141,7 +141,7 @@ function createAssertions(runInNewContext) {
           cb(!!cache[key])
         },
         // sync
-        get: (key) => {
+        get: key => {
           get(key)
           return cache[key]
         },
@@ -261,7 +261,7 @@ function createAssertions(runInNewContext) {
     const res = await new Promise((resolve, reject) => {
       const stream = renderer.renderToStream(context)
       let res = ''
-      stream.on('data', (chunk) => {
+      stream.on('data', chunk => {
         res += chunk.toString()
       })
       stream.on('error', reject)
@@ -295,7 +295,7 @@ function createAssertions(runInNewContext) {
       asBundle: true
     })
 
-    const err = await new Promise<Error>((resolve) => {
+    const err = await new Promise<Error>(resolve => {
       const stream = renderer.renderToStream()
       stream.on('error', resolve)
     })
@@ -309,7 +309,7 @@ function createAssertions(runInNewContext) {
       runInNewContext
     })
     const context: any = { url: '/test' }
-    const res = await new Promise((r) =>
+    const res = await new Promise(r =>
       renderer.renderToString(context, (_err, res) => r(res))
     )
     expect(res).toBe('<div data-server-rendered="true">/test</div>')
@@ -320,7 +320,7 @@ function createAssertions(runInNewContext) {
     const renderer = await createWebpackBundleRenderer('error.js', {
       runInNewContext
     })
-    const err = await new Promise<Error>((r) => renderer.renderToString(r))
+    const err = await new Promise<Error>(r => renderer.renderToString(r))
     expect(err.message).toBe('foo')
   })
 }
diff --git a/test/ssr/ssr-stream.spec.ts b/test/ssr/ssr-stream.spec.ts
index e4157f03bd2..6d4ed10c1ee 100644
--- a/test/ssr/ssr-stream.spec.ts
+++ b/test/ssr/ssr-stream.spec.ts
@@ -6,8 +6,9 @@ const { renderToStream } = createRenderer()
 
 describe('SSR: renderToStream', () => {
   it('should render to a stream', done => {
-    const stream = renderToStream(new Vue({
-      template: `
+    const stream = renderToStream(
+      new Vue({
+        template: `
         <div>
           <p class="hi">yoyo</p>
           <div id="ho" :class="[testClass, { red: isRed }]"></div>
@@ -17,36 +18,43 @@ describe('SSR: renderToStream', () => {
           <c-comp></c-comp>
         </div>
       `,
-      data: {
-        test: 'hi',
-        isRed: true,
-        testClass: 'a'
-      },
-      components: {
-        bComp (resolve) {
-          return resolve({
-            render (h) {
-              return h('test-async-2')
-            },
-            components: {
-              testAsync2 (resolve) {
-                return resolve({
-                  created () { this.$parent.$parent.testClass = 'b' },
-                  render (h) {
-                    return h('div', { class: [this.$parent.$parent.testClass] }, 'test')
-                  }
-                })
+        data: {
+          test: 'hi',
+          isRed: true,
+          testClass: 'a'
+        },
+        components: {
+          bComp(resolve) {
+            return resolve({
+              render(h) {
+                return h('test-async-2')
+              },
+              components: {
+                testAsync2(resolve) {
+                  return resolve({
+                    created() {
+                      this.$parent.$parent.testClass = 'b'
+                    },
+                    render(h) {
+                      return h(
+                        'div',
+                        { class: [this.$parent.$parent.testClass] },
+                        'test'
+                      )
+                    }
+                  })
+                }
               }
+            })
+          },
+          cComp: {
+            render(h) {
+              return h('div', { class: [this.$parent.testClass] }, 'test')
             }
-          })
-        },
-        cComp: {
-          render (h) {
-            return h('div', { class: [this.$parent.testClass] }, 'test')
           }
         }
-      }
-    }))
+      })
+    )
     let res = ''
     stream.on('data', chunk => {
       res += chunk
@@ -60,18 +68,20 @@ describe('SSR: renderToStream', () => {
           '<input value="hi"> ' +
           '<div class="b">test</div> ' +
           '<div class="b">test</div>' +
-        '</div>'
+          '</div>'
       )
       done()
     })
   })
 
   it('should catch error', done => {
-    const stream = renderToStream(new Vue({
-      render () {
-        throw new Error('oops')
-      }
-    }))
+    const stream = renderToStream(
+      new Vue({
+        render() {
+          throw new Error('oops')
+        }
+      })
+    )
     stream.on('error', err => {
       expect(err.toString()).toMatch(/oops/)
       expect(`oops`).toHaveBeenWarned()
@@ -81,7 +91,7 @@ describe('SSR: renderToStream', () => {
   })
 
   it('should not mingle two components', done => {
-    const padding = (new Array(20000)).join('x')
+    const padding = new Array(20000).join('x')
     const component1 = new Vue({
       template: `<div>${padding}<div></div></div>`,
       _scopeId: '_component1'
@@ -93,7 +103,7 @@ describe('SSR: renderToStream', () => {
     const stream1 = renderToStream(component1)
     const stream2 = renderToStream(component2)
     let res = ''
-    stream1.on('data', (text) => {
+    stream1.on('data', text => {
       res += text.toString('utf-8').replace(/x/g, '')
     })
     stream1.on('end', () => {
@@ -106,15 +116,18 @@ describe('SSR: renderToStream', () => {
 
   it('should call context.rendered', done => {
     let a = 0
-    const stream = renderToStream(new Vue({
-      template: `
+    const stream = renderToStream(
+      new Vue({
+        template: `
         <div>Hello</div>
       `
-    }), {
-      rendered: () => {
-        a = 42
+      }),
+      {
+        rendered: () => {
+          a = 42
+        }
       }
-    })
+    )
     let res = ''
     stream.on('data', chunk => {
       res += chunk
diff --git a/test/ssr/ssr-string.spec.ts b/test/ssr/ssr-string.spec.ts
index d3d3dc49ea2..9f07a379927 100644
--- a/test/ssr/ssr-string.spec.ts
+++ b/test/ssr/ssr-string.spec.ts
@@ -7,555 +7,713 @@ const { renderToString } = createRenderer()
 
 describe('SSR: renderToString', () => {
   it('static attributes', done => {
-    renderVmWithOptions({
-      template: '<div id="foo" bar="123"></div>'
-    }, result => {
-      expect(result).toContain('<div id="foo" bar="123" data-server-rendered="true"></div>')
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: '<div id="foo" bar="123"></div>'
+      },
+      result => {
+        expect(result).toContain(
+          '<div id="foo" bar="123" data-server-rendered="true"></div>'
+        )
+        done()
+      }
+    )
   })
 
   it('unary tags', done => {
-    renderVmWithOptions({
-      template: '<input value="123">'
-    }, result => {
-      expect(result).toContain('<input value="123" data-server-rendered="true">')
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: '<input value="123">'
+      },
+      result => {
+        expect(result).toContain(
+          '<input value="123" data-server-rendered="true">'
+        )
+        done()
+      }
+    )
   })
 
   it('dynamic attributes', done => {
-    renderVmWithOptions({
-      template: '<div qux="quux" :id="foo" :bar="baz"></div>',
-      data: {
-        foo: 'hi',
-        baz: 123
+    renderVmWithOptions(
+      {
+        template: '<div qux="quux" :id="foo" :bar="baz"></div>',
+        data: {
+          foo: 'hi',
+          baz: 123
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div qux="quux" id="hi" bar="123" data-server-rendered="true"></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div qux="quux" id="hi" bar="123" data-server-rendered="true"></div>')
-      done()
-    })
+    )
   })
 
   it('static class', done => {
-    renderVmWithOptions({
-      template: '<div class="foo bar"></div>'
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="foo bar"></div>')
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: '<div class="foo bar"></div>'
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" class="foo bar"></div>'
+        )
+        done()
+      }
+    )
   })
 
   it('dynamic class', done => {
-    renderVmWithOptions({
-      template: '<div class="foo bar" :class="[a, { qux: hasQux, quux: hasQuux }]"></div>',
-      data: {
-        a: 'baz',
-        hasQux: true,
-        hasQuux: false
+    renderVmWithOptions(
+      {
+        template:
+          '<div class="foo bar" :class="[a, { qux: hasQux, quux: hasQuux }]"></div>',
+        data: {
+          a: 'baz',
+          hasQux: true,
+          hasQuux: false
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" class="foo bar baz qux"></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="foo bar baz qux"></div>')
-      done()
-    })
+    )
   })
 
   it('custom component class', done => {
-    renderVmWithOptions({
-      template: '<div><cmp class="cmp"></cmp></div>',
-      components: {
-        cmp: {
-          render: h => h('div', 'test')
+    renderVmWithOptions(
+      {
+        template: '<div><cmp class="cmp"></cmp></div>',
+        components: {
+          cmp: {
+            render: h => h('div', 'test')
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><div class="cmp">test</div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div class="cmp">test</div></div>')
-      done()
-    })
+    )
   })
 
   it('nested component class', done => {
-    renderVmWithOptions({
-      template: '<cmp class="outer" :class="cls"></cmp>',
-      data: { cls: { 'success': 1 }},
-      components: {
-        cmp: {
-          render: h => h('div', [h('nested', { staticClass: 'nested', 'class': { 'error': 1 }})]),
-          components: {
-            nested: {
-              render: h => h('div', { staticClass: 'inner' }, 'test')
+    renderVmWithOptions(
+      {
+        template: '<cmp class="outer" :class="cls"></cmp>',
+        data: { cls: { success: 1 } },
+        components: {
+          cmp: {
+            render: h =>
+              h('div', [
+                h('nested', { staticClass: 'nested', class: { error: 1 } })
+              ]),
+            components: {
+              nested: {
+                render: h => h('div', { staticClass: 'inner' }, 'test')
+              }
             }
           }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" class="outer success">' +
+            '<div class="inner nested error">test</div>' +
+            '</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="outer success">' +
-          '<div class="inner nested error">test</div>' +
-        '</div>')
-      done()
-    })
+    )
   })
 
   it('dynamic style', done => {
-    renderVmWithOptions({
-      template: '<div style="background-color:black" :style="{ fontSize: fontSize + \'px\', color: color }"></div>',
-      data: {
-        fontSize: 14,
-        color: 'red'
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="background-color:black;font-size:14px;color:red;"></div>'
-      )
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template:
+          '<div style="background-color:black" :style="{ fontSize: fontSize + \'px\', color: color }"></div>',
+        data: {
+          fontSize: 14,
+          color: 'red'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="background-color:black;font-size:14px;color:red;"></div>'
+        )
+        done()
+      }
+    )
   })
 
   it('dynamic string style', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"></div>',
-      data: {
-        style: 'color:red'
+    renderVmWithOptions(
+      {
+        template: '<div :style="style"></div>',
+        data: {
+          style: 'color:red'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="color:red;"></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="color:red;"></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('auto-prefixed style value as array', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"></div>',
-      data: {
-        style: {
-          display: ['-webkit-box', '-ms-flexbox', 'flex']
+    renderVmWithOptions(
+      {
+        template: '<div :style="style"></div>',
+        data: {
+          style: {
+            display: ['-webkit-box', '-ms-flexbox', 'flex']
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="display:-webkit-box;display:-ms-flexbox;display:flex;"></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="display:-webkit-box;display:-ms-flexbox;display:flex;"></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('custom component style', done => {
-    renderVmWithOptions({
-      template: '<section><comp :style="style"></comp></section>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<div></div>'
+    renderVmWithOptions(
+      {
+        template: '<section><comp :style="style"></comp></section>',
+        data: {
+          style: 'color:red'
+        },
+        components: {
+          comp: {
+            template: '<div></div>'
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<section data-server-rendered="true"><div style="color:red;"></div></section>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<section data-server-rendered="true"><div style="color:red;"></div></section>'
-      )
-      done()
-    })
+    )
   })
 
   it('nested custom component style', done => {
-    renderVmWithOptions({
-      template: '<comp style="color: blue" :style="style"></comp>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<nested style="text-align: left;" :style="{fontSize:\'520rem\'}"></nested>',
-          components: {
-            nested: {
-              template: '<div></div>'
+    renderVmWithOptions(
+      {
+        template: '<comp style="color: blue" :style="style"></comp>',
+        data: {
+          style: 'color:red'
+        },
+        components: {
+          comp: {
+            template:
+              '<nested style="text-align: left;" :style="{fontSize:\'520rem\'}"></nested>',
+            components: {
+              nested: {
+                template: '<div></div>'
+              }
             }
           }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="text-align:left;font-size:520rem;color:red;"></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="text-align:left;font-size:520rem;color:red;"></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('component style not passed to child', done => {
-    renderVmWithOptions({
-      template: '<comp :style="style"></comp>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<div><div></div></div>'
+    renderVmWithOptions(
+      {
+        template: '<comp :style="style"></comp>',
+        data: {
+          style: 'color:red'
+        },
+        components: {
+          comp: {
+            template: '<div><div></div></div>'
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="color:red;"><div></div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="color:red;"><div></div></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('component style not passed to slot', done => {
-    renderVmWithOptions({
-      template: '<comp :style="style"><span style="color:black"></span></comp>',
-      data: {
-        style: 'color:red'
-      },
-      components: {
-        comp: {
-          template: '<div><slot></slot></div>'
+    renderVmWithOptions(
+      {
+        template:
+          '<comp :style="style"><span style="color:black"></span></comp>',
+        data: {
+          style: 'color:red'
+        },
+        components: {
+          comp: {
+            template: '<div><slot></slot></div>'
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="color:red;"><span style="color:black;"></span></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="color:red;"><span style="color:black;"></span></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('attrs merging on components', done => {
     const Test = {
-      render: h => h('div', {
-        attrs: { id: 'a' }
-      })
+      render: h =>
+        h('div', {
+          attrs: { id: 'a' }
+        })
     }
-    renderVmWithOptions({
-      render: h => h(Test, {
-        attrs: { id: 'b', name: 'c' }
-      })
-    }, res => {
-      expect(res).toContain(
-        '<div id="b" data-server-rendered="true" name="c"></div>'
-      )
-      done()
-    })
+    renderVmWithOptions(
+      {
+        render: h =>
+          h(Test, {
+            attrs: { id: 'b', name: 'c' }
+          })
+      },
+      res => {
+        expect(res).toContain(
+          '<div id="b" data-server-rendered="true" name="c"></div>'
+        )
+        done()
+      }
+    )
   })
 
   it('domProps merging on components', done => {
     const Test = {
-      render: h => h('div', {
-        domProps: { innerHTML: 'a' }
-      })
+      render: h =>
+        h('div', {
+          domProps: { innerHTML: 'a' }
+        })
     }
-    renderVmWithOptions({
-      render: h => h(Test, {
-        domProps: { innerHTML: 'b', value: 'c' }
-      })
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" value="c">b</div>'
-      )
-      done()
-    })
+    renderVmWithOptions(
+      {
+        render: h =>
+          h(Test, {
+            domProps: { innerHTML: 'b', value: 'c' }
+          })
+      },
+      res => {
+        expect(res).toContain(
+          '<div data-server-rendered="true" value="c">b</div>'
+        )
+        done()
+      }
+    )
   })
 
   it('v-show directive render', done => {
-    renderVmWithOptions({
-      template: '<div v-show="false"><span>inner</span></div>'
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: '<div v-show="false"><span>inner</span></div>'
+      },
+      res => {
+        expect(res).toContain(
+          '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
+        )
+        done()
+      }
+    )
   })
 
   it('v-show directive merge with style', done => {
-    renderVmWithOptions({
-      template: '<div :style="[{lineHeight: 1}]" v-show="false"><span>inner</span></div>'
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="line-height:1;display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template:
+          '<div :style="[{lineHeight: 1}]" v-show="false"><span>inner</span></div>'
+      },
+      res => {
+        expect(res).toContain(
+          '<div data-server-rendered="true" style="line-height:1;display:none;"><span>inner</span></div>'
+        )
+        done()
+      }
+    )
   })
 
   it('v-show directive not passed to child', done => {
-    renderVmWithOptions({
-      template: '<foo v-show="false"></foo>',
-      components: {
-        foo: {
-          template: '<div><span>inner</span></div>'
+    renderVmWithOptions(
+      {
+        template: '<foo v-show="false"></foo>',
+        components: {
+          foo: {
+            template: '<div><span>inner</span></div>'
+          }
         }
+      },
+      res => {
+        expect(res).toContain(
+          '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
+        )
+        done()
       }
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('v-show directive not passed to slot', done => {
-    renderVmWithOptions({
-      template: '<foo v-show="false"><span>inner</span></foo>',
-      components: {
-        foo: {
-          template: '<div><slot></slot></div>'
+    renderVmWithOptions(
+      {
+        template: '<foo v-show="false"><span>inner</span></foo>',
+        components: {
+          foo: {
+            template: '<div><slot></slot></div>'
+          }
         }
+      },
+      res => {
+        expect(res).toContain(
+          '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
+        )
+        done()
       }
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;"><span>inner</span></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('v-show directive merging on components', done => {
-    renderVmWithOptions({
-      template: '<foo v-show="false"></foo>',
-      components: {
-        foo: {
-          render: h => h('bar', {
-            directives: [{
-              name: 'show',
-              value: true
-            }]
-          }),
-          components: {
-            bar: {
-              render: h => h('div', 'inner')
+    renderVmWithOptions(
+      {
+        template: '<foo v-show="false"></foo>',
+        components: {
+          foo: {
+            render: h =>
+              h('bar', {
+                directives: [
+                  {
+                    name: 'show',
+                    value: true
+                  }
+                ]
+              }),
+            components: {
+              bar: {
+                render: h => h('div', 'inner')
+              }
             }
           }
         }
+      },
+      res => {
+        expect(res).toContain(
+          '<div data-server-rendered="true" style="display:none;">inner</div>'
+        )
+        done()
       }
-    }, res => {
-      expect(res).toContain(
-        '<div data-server-rendered="true" style="display:none;">inner</div>'
-      )
-      done()
-    })
+    )
   })
 
   it('text interpolation', done => {
-    renderVmWithOptions({
-      template: '<div>{{ foo }} side {{ bar }}</div>',
-      data: {
-        foo: 'server',
-        bar: '<span>rendering</span>'
+    renderVmWithOptions(
+      {
+        template: '<div>{{ foo }} side {{ bar }}</div>',
+        data: {
+          foo: 'server',
+          bar: '<span>rendering</span>'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">server side &lt;span&gt;rendering&lt;/span&gt;</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">server side &lt;span&gt;rendering&lt;/span&gt;</div>')
-      done()
-    })
+    )
   })
 
   it('v-html on root', done => {
-    renderVmWithOptions({
-      template: '<div v-html="text"></div>',
-      data: {
-        text: '<span>foo</span>'
+    renderVmWithOptions(
+      {
+        template: '<div v-html="text"></div>',
+        data: {
+          text: '<span>foo</span>'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><span>foo</span></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>foo</span></div>')
-      done()
-    })
+    )
   })
 
   it('v-text on root', done => {
-    renderVmWithOptions({
-      template: '<div v-text="text"></div>',
-      data: {
-        text: '<span>foo</span>'
+    renderVmWithOptions(
+      {
+        template: '<div v-text="text"></div>',
+        data: {
+          text: '<span>foo</span>'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">&lt;span&gt;foo&lt;/span&gt;</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">&lt;span&gt;foo&lt;/span&gt;</div>')
-      done()
-    })
+    )
   })
 
   it('v-html', done => {
-    renderVmWithOptions({
-      template: '<div><div v-html="text"></div></div>',
-      data: {
-        text: '<span>foo</span>'
+    renderVmWithOptions(
+      {
+        template: '<div><div v-html="text"></div></div>',
+        data: {
+          text: '<span>foo</span>'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><div><span>foo</span></div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div><span>foo</span></div></div>')
-      done()
-    })
+    )
   })
 
   it('v-html with null value', done => {
-    renderVmWithOptions({
-      template: '<div><div v-html="text"></div></div>',
-      data: {
-        text: null
+    renderVmWithOptions(
+      {
+        template: '<div><div v-html="text"></div></div>',
+        data: {
+          text: null
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><div></div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div></div></div>')
-      done()
-    })
+    )
   })
 
   it('v-text', done => {
-    renderVmWithOptions({
-      template: '<div><div v-text="text"></div></div>',
-      data: {
-        text: '<span>foo</span>'
+    renderVmWithOptions(
+      {
+        template: '<div><div v-text="text"></div></div>',
+        data: {
+          text: '<span>foo</span>'
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><div>&lt;span&gt;foo&lt;/span&gt;</div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div>&lt;span&gt;foo&lt;/span&gt;</div></div>')
-      done()
-    })
+    )
   })
 
   it('v-text with null value', done => {
-    renderVmWithOptions({
-      template: '<div><div v-text="text"></div></div>',
-      data: {
-        text: null
+    renderVmWithOptions(
+      {
+        template: '<div><div v-text="text"></div></div>',
+        data: {
+          text: null
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><div></div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div></div></div>')
-      done()
-    })
+    )
   })
 
   it('child component (hoc)', done => {
-    renderVmWithOptions({
-      template: '<child class="foo" :msg="msg"></child>',
-      data: {
-        msg: 'hello'
-      },
-      components: {
-        child: {
-          props: ['msg'],
-          data () {
-            return { name: 'bar' }
-          },
-          render () {
-            const h = this.$createElement
-            return h('div', { class: ['bar'] }, [`${this.msg} ${this.name}`])
+    renderVmWithOptions(
+      {
+        template: '<child class="foo" :msg="msg"></child>',
+        data: {
+          msg: 'hello'
+        },
+        components: {
+          child: {
+            props: ['msg'],
+            data() {
+              return { name: 'bar' }
+            },
+            render() {
+              const h = this.$createElement
+              return h('div', { class: ['bar'] }, [`${this.msg} ${this.name}`])
+            }
           }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" class="foo bar">hello bar</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true" class="foo bar">hello bar</div>')
-      done()
-    })
+    )
   })
 
   it('has correct lifecycle during render', done => {
     let lifecycleCount = 1
-    renderVmWithOptions({
-      template: '<div><span>{{ val }}</span><test></test></div>',
-      data: {
-        val: 'hi'
-      },
-      beforeCreate () {
-        expect(lifecycleCount++).toBe(1)
-      },
-      created () {
-        this.val = 'hello'
-        expect(this.val).toBe('hello')
-        expect(lifecycleCount++).toBe(2)
-      },
-      components: {
-        test: {
-          beforeCreate () {
-            expect(lifecycleCount++).toBe(3)
-          },
-          created () {
-            expect(lifecycleCount++).toBe(4)
-          },
-          render () {
-            expect(lifecycleCount++).toBeGreaterThan(4)
-            return this.$createElement('span', { class: ['b'] }, 'testAsync')
+    renderVmWithOptions(
+      {
+        template: '<div><span>{{ val }}</span><test></test></div>',
+        data: {
+          val: 'hi'
+        },
+        beforeCreate() {
+          expect(lifecycleCount++).toBe(1)
+        },
+        created() {
+          this.val = 'hello'
+          expect(this.val).toBe('hello')
+          expect(lifecycleCount++).toBe(2)
+        },
+        components: {
+          test: {
+            beforeCreate() {
+              expect(lifecycleCount++).toBe(3)
+            },
+            created() {
+              expect(lifecycleCount++).toBe(4)
+            },
+            render() {
+              expect(lifecycleCount++).toBeGreaterThan(4)
+              return this.$createElement('span', { class: ['b'] }, 'testAsync')
+            }
           }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<span>hello</span>' +
+            '<span class="b">testAsync</span>' +
+            '</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span>hello</span>' +
-          '<span class="b">testAsync</span>' +
-        '</div>'
-      )
-      done()
-    })
+    )
   })
 
   it('computed properties', done => {
-    renderVmWithOptions({
-      template: '<div>{{ b }}</div>',
-      data: {
-        a: {
-          b: 1
-        }
-      },
-      computed: {
-        b () {
-          return this.a.b + 1
+    renderVmWithOptions(
+      {
+        template: '<div>{{ b }}</div>',
+        data: {
+          a: {
+            b: 1
+          }
+        },
+        computed: {
+          b() {
+            return this.a.b + 1
+          }
+        },
+        created() {
+          this.a.b = 2
+          expect(this.b).toBe(3)
         }
       },
-      created () {
-        this.a.b = 2
-        expect(this.b).toBe(3)
+      result => {
+        expect(result).toContain('<div data-server-rendered="true">3</div>')
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">3</div>')
-      done()
-    })
+    )
   })
 
   it('renders async component', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <test-async></test-async>
         </div>
       `,
-      components: {
-        testAsync (resolve) {
-          setTimeout(() => resolve({
-            render () {
-              return this.$createElement('span', { class: ['b'] }, 'testAsync')
-            }
-          }), 1)
+        components: {
+          testAsync(resolve) {
+            setTimeout(
+              () =>
+                resolve({
+                  render() {
+                    return this.$createElement(
+                      'span',
+                      { class: ['b'] },
+                      'testAsync'
+                    )
+                  }
+                }),
+              1
+            )
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><span class="b">testAsync</span></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span class="b">testAsync</span></div>')
-      done()
-    })
+    )
   })
 
   it('renders async component (Promise, nested)', done => {
-    const Foo = () => Promise.resolve({
-      render: h => h('div', [h('span', 'foo'), h(Bar)])
-    })
+    const Foo = () =>
+      Promise.resolve({
+        render: h => h('div', [h('span', 'foo'), h(Bar)])
+      })
     const Bar = () => ({
       component: Promise.resolve({
         render: h => h('span', 'bar')
       })
     })
-    renderVmWithOptions({
-      render: h => h(Foo)
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span><span>bar</span></div>`)
-      done()
-    })
+    renderVmWithOptions(
+      {
+        render: h => h(Foo)
+      },
+      res => {
+        expect(res).toContain(
+          `<div data-server-rendered="true"><span>foo</span><span>bar</span></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('renders async component (ES module)', done => {
-    const Foo = () => Promise.resolve({
-      __esModule: true,
-      default: {
-        render: h => h('div', [h('span', 'foo'), h(Bar)])
-      }
-    })
+    const Foo = () =>
+      Promise.resolve({
+        __esModule: true,
+        default: {
+          render: h => h('div', [h('span', 'foo'), h(Bar)])
+        }
+      })
     const Bar = () => ({
       component: Promise.resolve({
         __esModule: true,
@@ -564,135 +722,181 @@ describe('SSR: renderToString', () => {
         }
       })
     })
-    renderVmWithOptions({
-      render: h => h(Foo)
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span><span>bar</span></div>`)
-      done()
-    })
+    renderVmWithOptions(
+      {
+        render: h => h(Foo)
+      },
+      res => {
+        expect(res).toContain(
+          `<div data-server-rendered="true"><span>foo</span><span>bar</span></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('renders async component (hoc)', done => {
-    renderVmWithOptions({
-      template: '<test-async></test-async>',
-      components: {
-        testAsync: () => Promise.resolve({
-          render () {
-            return this.$createElement('span', { class: ['b'] }, 'testAsync')
-          }
-        })
+    renderVmWithOptions(
+      {
+        template: '<test-async></test-async>',
+        components: {
+          testAsync: () =>
+            Promise.resolve({
+              render() {
+                return this.$createElement(
+                  'span',
+                  { class: ['b'] },
+                  'testAsync'
+                )
+              }
+            })
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<span data-server-rendered="true" class="b">testAsync</span>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<span data-server-rendered="true" class="b">testAsync</span>')
-      done()
-    })
+    )
   })
 
   it('renders async component (functional, single node)', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <test-async></test-async>
         </div>
       `,
-      components: {
-        testAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return h('span', { class: ['b'] }, 'testAsync')
-            }
-          }), 1)
+        components: {
+          testAsync(resolve) {
+            setTimeout(
+              () =>
+                resolve({
+                  functional: true,
+                  render(h) {
+                    return h('span', { class: ['b'] }, 'testAsync')
+                  }
+                }),
+              1
+            )
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><span class="b">testAsync</span></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span class="b">testAsync</span></div>')
-      done()
-    })
+    )
   })
 
   it('renders async component (functional, multiple nodes)', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <test-async></test-async>
         </div>
       `,
-      components: {
-        testAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return [
-                h('span', { class: ['a'] }, 'foo'),
-                h('span', { class: ['b'] }, 'bar')
-              ]
-            }
-          }), 1)
+        components: {
+          testAsync(resolve) {
+            setTimeout(
+              () =>
+                resolve({
+                  functional: true,
+                  render(h) {
+                    return [
+                      h('span', { class: ['a'] }, 'foo'),
+                      h('span', { class: ['b'] }, 'bar')
+                    ]
+                  }
+                }),
+              1
+            )
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<span class="a">foo</span>' +
+            '<span class="b">bar</span>' +
+            '</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span class="a">foo</span>' +
-          '<span class="b">bar</span>' +
-        '</div>'
-      )
-      done()
-    })
+    )
   })
 
   it('renders nested async functional component', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <outer-async></outer-async>
         </div>
       `,
-      components: {
-        outerAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return h('innerAsync')
-            }
-          }), 1)
-        },
-        innerAsync (resolve) {
-          setTimeout(() => resolve({
-            functional: true,
-            render (h) {
-              return h('span', { class: ['a'] }, 'inner')
-            },
-          }), 1)
+        components: {
+          outerAsync(resolve) {
+            setTimeout(
+              () =>
+                resolve({
+                  functional: true,
+                  render(h) {
+                    return h('innerAsync')
+                  }
+                }),
+              1
+            )
+          },
+          innerAsync(resolve) {
+            setTimeout(
+              () =>
+                resolve({
+                  functional: true,
+                  render(h) {
+                    return h('span', { class: ['a'] }, 'inner')
+                  }
+                }),
+              1
+            )
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<span class="a">inner</span>' +
+            '</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span class="a">inner</span>' +
-        '</div>'
-      )
-      done()
-    })
+    )
   })
 
   it('should catch async component error', done => {
-    renderToString(new Vue({
-      template: '<test-async></test-async>',
-      components: {
-        testAsync: () => Promise.resolve({
-          render () {
-            throw new Error('foo')
-          }
-        })
+    renderToString(
+      new Vue({
+        template: '<test-async></test-async>',
+        components: {
+          testAsync: () =>
+            Promise.resolve({
+              render() {
+                throw new Error('foo')
+              }
+            })
+        }
+      }),
+      (err, result) => {
+        expect(err).toBeTruthy()
+        expect(result).toBeUndefined()
+        expect('foo').toHaveBeenWarned()
+        done()
       }
-    }), (err, result) => {
-      expect(err).toBeTruthy()
-      expect(result).toBeUndefined()
-      expect('foo').toHaveBeenWarned()
-      done()
-    })
+    )
   })
 
   // #11963, #10391
@@ -703,29 +907,33 @@ describe('SSR: renderToString', () => {
     const Child = {
       template: `<p>child</p>`
     }
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
       <Parent>
         <template #child>
           <Child/>
         </template>
       </Parent>
       `,
-      components: {
-        Parent,
-        Child: () => Promise.resolve(Child)
-      }
-    }, result => {
-      expect(result).toContain(
-        `<div data-server-rendered="true"><p>child</p></div>`
-      )
-      done()
-    })
+        components: {
+          Parent,
+          Child: () => Promise.resolve(Child)
+        }
+      },
+      result => {
+        expect(result).toContain(
+          `<div data-server-rendered="true"><p>child</p></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('everything together', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <p class="hi">yoyo</p>
           <div id="ho" :class="{ red: isRed }"></div>
@@ -736,44 +944,51 @@ describe('SSR: renderToString', () => {
           <test-async></test-async>
         </div>
       `,
-      data: {
-        test: 'hi',
-        isRed: true,
-        imageUrl: 'https://vuejs.org/images/logo.png'
-      },
-      components: {
-        test: {
-          render () {
-            return this.$createElement('div', { class: ['a'] }, 'test')
-          }
+        data: {
+          test: 'hi',
+          isRed: true,
+          imageUrl: 'https://vuejs.org/images/logo.png'
         },
-        testAsync (resolve) {
-          resolve({
-            render () {
-              return this.$createElement('span', { class: ['b'] }, 'testAsync')
+        components: {
+          test: {
+            render() {
+              return this.$createElement('div', { class: ['a'] }, 'test')
             }
-          })
+          },
+          testAsync(resolve) {
+            resolve({
+              render() {
+                return this.$createElement(
+                  'span',
+                  { class: ['b'] },
+                  'testAsync'
+                )
+              }
+            })
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<p class="hi">yoyo</p> ' +
+            '<div id="ho" class="red"></div> ' +
+            '<span>hi</span> ' +
+            '<input value="hi"> ' +
+            '<img src="https://vuejs.org/images/logo.png"> ' +
+            '<div class="a">test</div> ' +
+            '<span class="b">testAsync</span>' +
+            '</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<p class="hi">yoyo</p> ' +
-          '<div id="ho" class="red"></div> ' +
-          '<span>hi</span> ' +
-          '<input value="hi"> ' +
-          '<img src="https://vuejs.org/images/logo.png"> ' +
-          '<div class="a">test</div> ' +
-          '<span class="b">testAsync</span>' +
-        '</div>'
-      )
-      done()
-    })
+    )
   })
 
   it('normal attr', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span :test="'ok'">hello</span>
           <span :test="null">hello</span>
@@ -782,23 +997,26 @@ describe('SSR: renderToString', () => {
           <span :test="0">hello</span>
         </div>
       `
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span test="ok">hello</span> ' +
-          '<span>hello</span> ' +
-          '<span>hello</span> ' +
-          '<span test="true">hello</span> ' +
-          '<span test="0">hello</span>' +
-        '</div>'
-      )
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<span test="ok">hello</span> ' +
+            '<span>hello</span> ' +
+            '<span>hello</span> ' +
+            '<span test="true">hello</span> ' +
+            '<span test="0">hello</span>' +
+            '</div>'
+        )
+        done()
+      }
+    )
   })
 
   it('enumerated attr', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span :draggable="true">hello</span>
           <span :draggable="'ok'">hello</span>
@@ -808,24 +1026,27 @@ describe('SSR: renderToString', () => {
           <span :draggable="'false'">hello</span>
         </div>
       `
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span draggable="true">hello</span> ' +
-          '<span draggable="true">hello</span> ' +
-          '<span draggable="false">hello</span> ' +
-          '<span draggable="false">hello</span> ' +
-          '<span draggable="true">hello</span> ' +
-          '<span draggable="false">hello</span>' +
-        '</div>'
-      )
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<span draggable="true">hello</span> ' +
+            '<span draggable="true">hello</span> ' +
+            '<span draggable="false">hello</span> ' +
+            '<span draggable="false">hello</span> ' +
+            '<span draggable="true">hello</span> ' +
+            '<span draggable="false">hello</span>' +
+            '</div>'
+        )
+        done()
+      }
+    )
   })
 
   it('boolean attr', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span :disabled="true">hello</span>
           <span :disabled="'ok'">hello</span>
@@ -833,29 +1054,36 @@ describe('SSR: renderToString', () => {
           <span :disabled="''">hello</span>
         </div>
       `
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true">' +
-          '<span disabled="disabled">hello</span> ' +
-          '<span disabled="disabled">hello</span> ' +
-          '<span>hello</span> ' +
-          '<span disabled="disabled">hello</span>' +
-        '</div>'
-      )
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true">' +
+            '<span disabled="disabled">hello</span> ' +
+            '<span disabled="disabled">hello</span> ' +
+            '<span>hello</span> ' +
+            '<span disabled="disabled">hello</span>' +
+            '</div>'
+        )
+        done()
+      }
+    )
   })
 
   it('v-bind object', done => {
-    renderVmWithOptions({
-      data: {
-        test: { id: 'a', class: ['a', 'b'], value: 'c' }
+    renderVmWithOptions(
+      {
+        data: {
+          test: { id: 'a', class: ['a', 'b'], value: 'c' }
+        },
+        template: '<input v-bind="test">'
       },
-      template: '<input v-bind="test">'
-    }, result => {
-      expect(result).toContain('<input id="a" data-server-rendered="true" value="c" class="a b">')
-      done()
-    })
+      result => {
+        expect(result).toContain(
+          '<input id="a" data-server-rendered="true" value="c" class="a b">'
+        )
+        done()
+      }
+    )
   })
 
   it('custom directives', done => {
@@ -871,108 +1099,136 @@ describe('SSR: renderToString', () => {
         }
       }
     })
-    renderer.renderToString(new Vue({
-      render () {
-        const h = this.$createElement
-        return h('p', {
-          class: 'class1',
-          staticClass: 'class2',
-          directives: [{
-            name: 'class-prefixer',
-            value: 'my'
-          }]
-        }, ['hello world'])
-      }
-    }), (err, result) => {
-      expect(err).toBeNull()
-      expect(result).toContain('<p data-server-rendered="true" class="my-class2 my-class1">hello world</p>')
-      done()
-    })
+    renderer.renderToString(
+      new Vue({
+        render() {
+          const h = this.$createElement
+          return h(
+            'p',
+            {
+              class: 'class1',
+              staticClass: 'class2',
+              directives: [
+                {
+                  name: 'class-prefixer',
+                  value: 'my'
+                }
+              ]
+            },
+            ['hello world']
+          )
+        }
+      }),
+      (err, result) => {
+        expect(err).toBeNull()
+        expect(result).toContain(
+          '<p data-server-rendered="true" class="my-class2 my-class1">hello world</p>'
+        )
+        done()
+      }
+    )
   })
 
   it('should not warn for custom directives that do not have server-side implementation', done => {
-    renderToString(new Vue({
-      directives: {
-        test: {
-          bind() {
-            // noop
+    renderToString(
+      new Vue({
+        directives: {
+          test: {
+            bind() {
+              // noop
+            }
           }
-        }
-      },
-      template: '<div v-test></div>',
-    }), () => {
-      expect('Failed to resolve directive: test').not.toHaveBeenWarned()
-      done()
-    })
+        },
+        template: '<div v-test></div>'
+      }),
+      () => {
+        expect('Failed to resolve directive: test').not.toHaveBeenWarned()
+        done()
+      }
+    )
   })
 
   it('_scopeId', done => {
-    renderVmWithOptions({
-      _scopeId: '_v-parent',
-      template: '<div id="foo"><p><child></child></p></div>',
-      components: {
-        child: {
-          _scopeId: '_v-child',
-          render () {
-            const h = this.$createElement
-            return h('div', null, [h('span', null, ['foo'])])
+    renderVmWithOptions(
+      {
+        _scopeId: '_v-parent',
+        template: '<div id="foo"><p><child></child></p></div>',
+        components: {
+          child: {
+            _scopeId: '_v-child',
+            render() {
+              const h = this.$createElement
+              return h('div', null, [h('span', null, ['foo'])])
+            }
           }
         }
-      }
-    }, result => {
-      expect(result).toContain(
-        '<div id="foo" data-server-rendered="true" _v-parent>' +
-          '<p _v-parent>' +
+      },
+      result => {
+        expect(result).toContain(
+          '<div id="foo" data-server-rendered="true" _v-parent>' +
+            '<p _v-parent>' +
             '<div _v-child _v-parent><span _v-child>foo</span></div>' +
-          '</p>' +
-        '</div>'
-      )
-      done()
-    })
+            '</p>' +
+            '</div>'
+        )
+        done()
+      }
+    )
   })
 
   it('_scopeId on slot content', done => {
-    renderVmWithOptions({
-      _scopeId: '_v-parent',
-      template: '<div><child><p>foo</p></child></div>',
-      components: {
-        child: {
-          _scopeId: '_v-child',
-          render () {
-            const h = this.$createElement
-            return h('div', null, this.$slots.default)
+    renderVmWithOptions(
+      {
+        _scopeId: '_v-parent',
+        template: '<div><child><p>foo</p></child></div>',
+        components: {
+          child: {
+            _scopeId: '_v-child',
+            render() {
+              const h = this.$createElement
+              return h('div', null, this.$slots.default)
+            }
           }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" _v-parent>' +
+            '<div _v-child _v-parent><p _v-child _v-parent>foo</p></div>' +
+            '</div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" _v-parent>' +
-          '<div _v-child _v-parent><p _v-child _v-parent>foo</p></div>' +
-        '</div>'
-      )
-      done()
-    })
+    )
   })
 
   it('comment nodes', done => {
-    renderVmWithOptions({
-      template: '<div><transition><div v-if="false"></div></transition></div>'
-    }, result => {
-      expect(result).toContain(`<div data-server-rendered="true"><!----></div>`)
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: '<div><transition><div v-if="false"></div></transition></div>'
+      },
+      result => {
+        expect(result).toContain(
+          `<div data-server-rendered="true"><!----></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('should catch error', done => {
-    renderToString(new Vue({
-      render () {
-        throw new Error('oops')
-      }
-    }), err => {
-      expect(err instanceof Error).toBe(true)
-      expect(`oops`).toHaveBeenWarned()
-      done()
-    })
+    renderToString(
+      new Vue({
+        render() {
+          throw new Error('oops')
+        }
+      }),
+      err => {
+        expect(err instanceof Error).toBe(true)
+        expect(`oops`).toHaveBeenWarned()
+        done()
+      }
+    )
   })
 
   it('default value Foreign Function', () => {
@@ -993,98 +1249,121 @@ describe('SSR: renderToString', () => {
   })
 
   it('should prevent xss in attributes', done => {
-    renderVmWithOptions({
-      data: {
-        xss: '"><script>alert(1)</script>'
-      },
-      template: `
+    renderVmWithOptions(
+      {
+        data: {
+          xss: '"><script>alert(1)</script>'
+        },
+        template: `
         <div>
           <a :title="xss" :style="{ color: xss }" :class="[xss]">foo</a>
         </div>
       `
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).not.toContain(`<script>alert(1)</script>`)
+        done()
+      }
+    )
   })
 
   it('should prevent xss in attribute names', done => {
-    renderVmWithOptions({
-      data: {
-        xss: {
-          'foo="bar"></div><script>alert(1)</script>': ''
-        }
-      },
-      template: `
+    renderVmWithOptions(
+      {
+        data: {
+          xss: {
+            'foo="bar"></div><script>alert(1)</script>': ''
+          }
+        },
+        template: `
         <div v-bind="xss"></div>
       `
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).not.toContain(`<script>alert(1)</script>`)
+        done()
+      }
+    )
   })
 
   it('should prevent xss in attribute names (optimized)', done => {
-    renderVmWithOptions({
-      data: {
-        xss: {
-          'foo="bar"></div><script>alert(1)</script>': ''
-        }
-      },
-      template: `
+    renderVmWithOptions(
+      {
+        data: {
+          xss: {
+            'foo="bar"></div><script>alert(1)</script>': ''
+          }
+        },
+        template: `
         <div>
           <a v-bind="xss">foo</a>
         </div>
       `
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).not.toContain(`<script>alert(1)</script>`)
+        done()
+      }
+    )
   })
 
   it('should prevent script xss with v-bind object syntax + array value', done => {
-    renderVmWithOptions({
-      data: {
-        test: ['"><script>alert(1)</script><!--"']
+    renderVmWithOptions(
+      {
+        data: {
+          test: ['"><script>alert(1)</script><!--"']
+        },
+        template: `<div v-bind="{ test }"></div>`
       },
-      template: `<div v-bind="{ test }"></div>`
-    }, res => {
-      expect(res).not.toContain(`<script>alert(1)</script>`)
-      done()
-    })
+      res => {
+        expect(res).not.toContain(`<script>alert(1)</script>`)
+        done()
+      }
+    )
   })
 
   it('v-if', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span v-if="true">foo</span>
           <span v-if="false">bar</span>
         </div>
       `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <!----></div>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).toContain(
+          `<div data-server-rendered="true"><span>foo</span> <!----></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('v-for', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span>foo</span>
           <span v-for="i in 2">{{ i }}</span>
         </div>
       `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <span>1</span><span>2</span></div>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).toContain(
+          `<div data-server-rendered="true"><span>foo</span> <span>1</span><span>2</span></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('template v-if', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span>foo</span>
           <template v-if="true">
@@ -1092,15 +1371,20 @@ describe('SSR: renderToString', () => {
           </template>
         </div>
       `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <span>foo</span> bar <span>baz</span></div>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).toContain(
+          `<div data-server-rendered="true"><span>foo</span> <span>foo</span> bar <span>baz</span></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('template v-for', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span>foo</span>
           <template v-for="i in 2">
@@ -1108,178 +1392,231 @@ describe('SSR: renderToString', () => {
           </template>
         </div>
       `
-    }, res => {
-      expect(res).toContain(`<div data-server-rendered="true"><span>foo</span> <span>1</span><span>bar</span><span>2</span><span>bar</span></div>`)
-      done()
-    })
+      },
+      res => {
+        expect(res).toContain(
+          `<div data-server-rendered="true"><span>foo</span> <span>1</span><span>bar</span><span>2</span><span>bar</span></div>`
+        )
+        done()
+      }
+    )
   })
 
   it('with inheritAttrs: false + $attrs', done => {
-    renderVmWithOptions({
-      template: `<foo id="a"/>`,
-      components: {
-        foo: {
-          inheritAttrs: false,
-          template: `<div><div v-bind="$attrs"></div></div>`
+    renderVmWithOptions(
+      {
+        template: `<foo id="a"/>`,
+        components: {
+          foo: {
+            inheritAttrs: false,
+            template: `<div><div v-bind="$attrs"></div></div>`
+          }
         }
+      },
+      res => {
+        expect(res).toBe(
+          `<div data-server-rendered="true"><div id="a"></div></div>`
+        )
+        done()
       }
-    }, res => {
-      expect(res).toBe(`<div data-server-rendered="true"><div id="a"></div></div>`)
-      done()
-    })
+    )
   })
 
   it('should escape static strings', done => {
-    renderVmWithOptions({
-      template: `<div>&lt;foo&gt;</div>`
-    }, res => {
-      expect(res).toBe(`<div data-server-rendered="true">&lt;foo&gt;</div>`)
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: `<div>&lt;foo&gt;</div>`
+      },
+      res => {
+        expect(res).toBe(`<div data-server-rendered="true">&lt;foo&gt;</div>`)
+        done()
+      }
+    )
   })
 
   it('should not cache computed properties', done => {
-    renderVmWithOptions({
-      template: `<div>{{ foo }}</div>`,
-      data: () => ({ bar: 1 }),
-      computed: {
-        foo () { return this.bar + 1 }
-      },
-      created () {
-        this.foo // access
-        this.bar++ // trigger change
-      }
-    }, res => {
-      expect(res).toBe(`<div data-server-rendered="true">3</div>`)
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: `<div>{{ foo }}</div>`,
+        data: () => ({ bar: 1 }),
+        computed: {
+          foo() {
+            return this.bar + 1
+          }
+        },
+        created() {
+          this.foo // access
+          this.bar++ // trigger change
+        }
+      },
+      res => {
+        expect(res).toBe(`<div data-server-rendered="true">3</div>`)
+        done()
+      }
+    )
   })
 
   // #8977
   it('should call computed properties with vm as first argument', done => {
-    renderToString(new Vue({
-      data: {
-        firstName: 'Evan',
-        lastName: 'You'
-      },
-      computed: {
-        fullName: ({ firstName, lastName }) => `${firstName} ${lastName}`,
-      },
-      template: '<div>{{ fullName }}</div>',
-    }), (err, result) => {
-      expect(err).toBeNull()
-      expect(result).toContain('<div data-server-rendered="true">Evan You</div>')
-      done()
-    })
+    renderToString(
+      new Vue({
+        data: {
+          firstName: 'Evan',
+          lastName: 'You'
+        },
+        computed: {
+          fullName: ({ firstName, lastName }) => `${firstName} ${lastName}`
+        },
+        template: '<div>{{ fullName }}</div>'
+      }),
+      (err, result) => {
+        expect(err).toBeNull()
+        expect(result).toContain(
+          '<div data-server-rendered="true">Evan You</div>'
+        )
+        done()
+      }
+    )
   })
 
   it('return Promise', async () => {
-    await renderToString(new Vue({
-      template: `<div>{{ foo }}</div>`,
-      data: { foo: 'bar' }
-    }))!.then(res => {
+    await renderToString(
+      new Vue({
+        template: `<div>{{ foo }}</div>`,
+        data: { foo: 'bar' }
+      })
+    )!.then(res => {
       expect(res).toBe(`<div data-server-rendered="true">bar</div>`)
     })
   })
 
   it('return Promise (error)', async () => {
-    await renderToString(new Vue({
-      render () {
-        throw new Error('foobar')
-      }
-    }))!.catch(err => {
+    await renderToString(
+      new Vue({
+        render() {
+          throw new Error('foobar')
+        }
+      })
+    )!.catch(err => {
       expect('foobar').toHaveBeenWarned()
       expect(err.toString()).toContain(`foobar`)
     })
   })
 
   it('should catch template compilation error', done => {
-    renderToString(new Vue({
-      template: `<div></div><div></div>`
-    }), (err) => {
-      expect(err.toString()).toContain('Component template should contain exactly one root element')
-      done()
-    })
+    renderToString(
+      new Vue({
+        template: `<div></div><div></div>`
+      }),
+      err => {
+        expect(err.toString()).toContain(
+          'Component template should contain exactly one root element'
+        )
+        done()
+      }
+    )
   })
 
   // #6907
   it('should not optimize root if conditions', done => {
-    renderVmWithOptions({
-      data: { foo: 123 },
-      template: `<input :type="'text'" v-model="foo">`
-    }, res => {
-      expect(res).toBe(`<input type="text" data-server-rendered="true" value="123">`)
-      done()
-    })
+    renderVmWithOptions(
+      {
+        data: { foo: 123 },
+        template: `<input :type="'text'" v-model="foo">`
+      },
+      res => {
+        expect(res).toBe(
+          `<input type="text" data-server-rendered="true" value="123">`
+        )
+        done()
+      }
+    )
   })
 
   it('render muted properly', done => {
-    renderVmWithOptions({
-      template: '<video muted></video>'
-    }, result => {
-      expect(result).toContain('<video muted="muted" data-server-rendered="true"></video>')
-      done()
-    })
+    renderVmWithOptions(
+      {
+        template: '<video muted></video>'
+      },
+      result => {
+        expect(result).toContain(
+          '<video muted="muted" data-server-rendered="true"></video>'
+        )
+        done()
+      }
+    )
   })
 
   it('render v-model with textarea', done => {
-    renderVmWithOptions({
-      data: { foo: 'bar' },
-      template: '<div><textarea v-model="foo"></textarea></div>'
-    }, result => {
-      expect(result).toContain('<textarea>bar</textarea>')
-      done()
-    })
+    renderVmWithOptions(
+      {
+        data: { foo: 'bar' },
+        template: '<div><textarea v-model="foo"></textarea></div>'
+      },
+      result => {
+        expect(result).toContain('<textarea>bar</textarea>')
+        done()
+      }
+    )
   })
 
   it('render v-model with textarea (non-optimized)', done => {
-    renderVmWithOptions({
-      render (h) {
-        return h('textarea', {
-          domProps: {
-            value: 'foo'
-          }
-        })
+    renderVmWithOptions(
+      {
+        render(h) {
+          return h('textarea', {
+            domProps: {
+              value: 'foo'
+            }
+          })
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<textarea data-server-rendered="true">foo</textarea>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<textarea data-server-rendered="true">foo</textarea>')
-      done()
-    })
+    )
   })
 
   it('render v-model with <select> (value binding)', done => {
-    renderVmWithOptions({
-      data: {
-        selected: 2,
-        options: [
-          { id: 1, label: 'one' },
-          { id: 2, label: 'two' }
-        ]
-      },
-      template: `
+    renderVmWithOptions(
+      {
+        data: {
+          selected: 2,
+          options: [
+            { id: 1, label: 'one' },
+            { id: 2, label: 'two' }
+          ]
+        },
+        template: `
       <div>
         <select v-model="selected">
           <option v-for="o in options" :value="o.id">{{ o.label }}</option>
         </select>
       </div>
       `
-    }, result => {
-      expect(result).toContain(
-        '<select>' +
-          '<option value="1">one</option>' +
-          '<option selected="selected" value="2">two</option>' +
-        '</select>'
-      )
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(
+          '<select>' +
+            '<option value="1">one</option>' +
+            '<option selected="selected" value="2">two</option>' +
+            '</select>'
+        )
+        done()
+      }
+    )
   })
 
   it('render v-model with <select> (static value)', done => {
-    renderVmWithOptions({
-      data: {
-        selected: 2
-      },
-      template: `
+    renderVmWithOptions(
+      {
+        data: {
+          selected: 2
+        },
+        template: `
       <div>
         <select v-model="selected">
           <option value="1">one</option>
@@ -1287,203 +1624,230 @@ describe('SSR: renderToString', () => {
         </select>
       </div>
       `
-    }, result => {
-      expect(result).toContain(
-        '<select>' +
-          '<option value="1">one</option> ' +
-          '<option value="2" selected="selected">two</option>' +
-        '</select>'
-      )
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(
+          '<select>' +
+            '<option value="1">one</option> ' +
+            '<option value="2" selected="selected">two</option>' +
+            '</select>'
+        )
+        done()
+      }
+    )
   })
 
   it('render v-model with <select> (text as value)', done => {
-    renderVmWithOptions({
-      data: {
-        selected: 2,
-        options: [
-          { id: 1, label: 'one' },
-          { id: 2, label: 'two' }
-        ]
-      },
-      template: `
+    renderVmWithOptions(
+      {
+        data: {
+          selected: 2,
+          options: [
+            { id: 1, label: 'one' },
+            { id: 2, label: 'two' }
+          ]
+        },
+        template: `
       <div>
         <select v-model="selected">
           <option v-for="o in options">{{ o.id }}</option>
         </select>
       </div>
       `
-    }, result => {
-      expect(result).toContain(
-        '<select>' +
-          '<option>1</option>' +
-          '<option selected="selected">2</option>' +
-        '</select>'
-      )
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(
+          '<select>' +
+            '<option>1</option>' +
+            '<option selected="selected">2</option>' +
+            '</select>'
+        )
+        done()
+      }
+    )
   })
 
   // #7223
   it('should not double escape attribute values', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
       <div>
         <div id="a\nb"></div>
       </div>
       `
-    }, result => {
-      expect(result).toContain(`<div id="a\nb"></div>`)
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(`<div id="a\nb"></div>`)
+        done()
+      }
+    )
   })
 
   // #7859
   it('should not double escape class values', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
       <div>
         <div class="a\nb"></div>
       </div>
       `
-    }, result => {
-      expect(result).toContain(`<div class="a b"></div>`)
-      done()
-    })
+      },
+      result => {
+        expect(result).toContain(`<div class="a b"></div>`)
+        done()
+      }
+    )
   })
 
   it('should expose ssr helpers on functional context', done => {
     let called = false
-    renderVmWithOptions({
-      template: `<div><foo/></div>`,
-      components: {
-        foo: {
-          functional: true,
-          render (h, ctx) {
-            expect(ctx._ssrNode).toBeTruthy()
-            called = true
+    renderVmWithOptions(
+      {
+        template: `<div><foo/></div>`,
+        components: {
+          foo: {
+            functional: true,
+            render(h, ctx) {
+              expect(ctx._ssrNode).toBeTruthy()
+              called = true
+            }
           }
         }
+      },
+      () => {
+        expect(called).toBe(true)
+        done()
       }
-    }, () => {
-      expect(called).toBe(true)
-      done()
-    })
+    )
   })
 
   it('should support serverPrefetch option', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>{{ count }}</div>
       `,
-      data: {
-        count: 0
+        data: {
+          count: 0
+        },
+        serverPrefetch() {
+          return new Promise<void>(resolve => {
+            setTimeout(() => {
+              this.count = 42
+              resolve()
+            }, 1)
+          })
+        }
       },
-      serverPrefetch () {
-        return new Promise<void>((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
+      result => {
+        expect(result).toContain('<div data-server-rendered="true">42</div>')
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">42</div>')
-      done()
-    })
+    )
   })
 
   it('should support serverPrefetch option (nested)', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span>{{ count }}</span>
           <nested-prefetch></nested-prefetch>
         </div>
       `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        return new Promise<void>((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
-      },
-      components: {
-        nestedPrefetch: {
-          template: `
+        data: {
+          count: 0
+        },
+        serverPrefetch() {
+          return new Promise<void>(resolve => {
+            setTimeout(() => {
+              this.count = 42
+              resolve()
+            }, 1)
+          })
+        },
+        components: {
+          nestedPrefetch: {
+            template: `
             <div>{{ message }}</div>
           `,
-          data () {
-            return {
-              message: ''
+            data() {
+              return {
+                message: ''
+              }
+            },
+            serverPrefetch() {
+              return new Promise<void>(resolve => {
+                setTimeout(() => {
+                  this.message = 'vue.js'
+                  resolve()
+                }, 1)
+              })
             }
-          },
-          serverPrefetch () {
-            return new Promise<void>((resolve) => {
-              setTimeout(() => {
-                this.message = 'vue.js'
-                resolve()
-              }, 1)
-            })
           }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>')
-      done()
-    })
+    )
   })
 
   it('should support serverPrefetch option (nested async)', done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <span>{{ count }}</span>
           <nested-prefetch></nested-prefetch>
         </div>
       `,
-      data: {
-        count: 0
-      },
-      serverPrefetch () {
-        return new Promise<void>((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
-      },
-      components: {
-        nestedPrefetch (resolve) {
-          resolve({
-            template: `
+        data: {
+          count: 0
+        },
+        serverPrefetch() {
+          return new Promise<void>(resolve => {
+            setTimeout(() => {
+              this.count = 42
+              resolve()
+            }, 1)
+          })
+        },
+        components: {
+          nestedPrefetch(resolve) {
+            resolve({
+              template: `
               <div>{{ message }}</div>
             `,
-            data () {
-              return {
-                message: ''
+              data() {
+                return {
+                  message: ''
+                }
+              },
+              serverPrefetch() {
+                return new Promise<void>(resolve => {
+                  setTimeout(() => {
+                    this.message = 'vue.js'
+                    resolve()
+                  }, 1)
+                })
               }
-            },
-            serverPrefetch () {
-              return new Promise<void>((resolve) => {
-                setTimeout(() => {
-                  this.message = 'vue.js'
-                  resolve()
-                }, 1)
-              })
-            }
-          })
+            })
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>')
-      done()
-    })
+    )
   })
 
   it('should merge serverPrefetch option', done => {
@@ -1491,8 +1855,8 @@ describe('SSR: renderToString', () => {
       data: {
         message: ''
       },
-      serverPrefetch () {
-        return new Promise<void>((resolve) => {
+      serverPrefetch() {
+        return new Promise<void>(resolve => {
           setTimeout(() => {
             this.message = 'vue.js'
             resolve()
@@ -1500,106 +1864,124 @@ describe('SSR: renderToString', () => {
         })
       }
     }
-    renderVmWithOptions({
-      mixins: [mixin],
-      template: `
+    renderVmWithOptions(
+      {
+        mixins: [mixin],
+        template: `
         <div>
           <span>{{ count }}</span>
           <div>{{ message }}</div>
         </div>
       `,
-      data: {
-        count: 0
+        data: {
+          count: 0
+        },
+        serverPrefetch() {
+          return new Promise<void>(resolve => {
+            setTimeout(() => {
+              this.count = 42
+              resolve()
+            }, 1)
+          })
+        }
       },
-      serverPrefetch () {
-        return new Promise<void>((resolve) => {
-          setTimeout(() => {
-            this.count = 42
-            resolve()
-          }, 1)
-        })
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><span>42</span> <div>vue.js</div></div>')
-      done()
-    })
+    )
   })
 
   it(`should skip serverPrefetch option that doesn't return a promise`, done => {
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>{{ count }}</div>
       `,
-      data: {
-        count: 0
+        data: {
+          count: 0
+        },
+        serverPrefetch() {
+          setTimeout(() => {
+            this.count = 42
+          }, 1)
+        }
       },
-      serverPrefetch () {
-        setTimeout(() => {
-          this.count = 42
-        }, 1)
+      result => {
+        expect(result).toContain('<div data-server-rendered="true">0</div>')
+        done()
       }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true">0</div>')
-      done()
-    })
+    )
   })
 
   it('should call context.rendered', done => {
     let a = 0
-    renderToString(new Vue({
-      template: '<div>Hello</div>'
-    }), {
-      rendered: () => {
-        a = 42
-      }
-    }, (err, res) => {
-      expect(err).toBeNull()
-      expect(res).toContain('<div data-server-rendered="true">Hello</div>')
-      expect(a).toBe(42)
-      done()
-    })
+    renderToString(
+      new Vue({
+        template: '<div>Hello</div>'
+      }),
+      {
+        rendered: () => {
+          a = 42
+        }
+      },
+      (err, res) => {
+        expect(err).toBeNull()
+        expect(res).toContain('<div data-server-rendered="true">Hello</div>')
+        expect(a).toBe(42)
+        done()
+      }
+    )
   })
 
   it('invalid style value', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"><p :style="style2"/></div>',
-      data: {
-        // all invalid, should not even have "style" attribute
-        style: {
-          opacity: {},
-          color: null
-        },
-        // mix of valid and invalid
-        style2: {
-          opacity: 0,
-          color: null
+    renderVmWithOptions(
+      {
+        template: '<div :style="style"><p :style="style2"/></div>',
+        data: {
+          // all invalid, should not even have "style" attribute
+          style: {
+            opacity: {},
+            color: null
+          },
+          // mix of valid and invalid
+          style2: {
+            opacity: 0,
+            color: null
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><p style="opacity:0;"></p></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true"><p style="opacity:0;"></p></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('numeric style value', done => {
-    renderVmWithOptions({
-      template: '<div :style="style"></div>',
-      data: {
-        style: {
-          opacity: 0, // valid, opacity is unit-less
-          top: 0, // valid, top requires unit but 0 is allowed
-          left: 10, // invalid, left requires a unit
-          marginTop: '10px' // valid
+    renderVmWithOptions(
+      {
+        template: '<div :style="style"></div>',
+        data: {
+          style: {
+            opacity: 0, // valid, opacity is unit-less
+            top: 0, // valid, top requires unit but 0 is allowed
+            left: 10, // invalid, left requires a unit
+            marginTop: '10px' // valid
+          }
         }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true" style="opacity:0;top:0;margin-top:10px;"></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true" style="opacity:0;top:0;margin-top:10px;"></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('handling max stack size limit', done => {
@@ -1621,22 +2003,25 @@ describe('SSR: renderToString', () => {
   })
 
   it('undefined v-model with textarea', done => {
-    renderVmWithOptions({
-      render (h) {
-        return h('div', [
-          h('textarea', {
-            domProps: {
-              value: null
-            }
-          })
-        ])
+    renderVmWithOptions(
+      {
+        render(h) {
+          return h('div', [
+            h('textarea', {
+              domProps: {
+                value: null
+              }
+            })
+          ])
+        }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><textarea></textarea></div>'
+        )
+        done()
       }
-    }, result => {
-      expect(result).toContain(
-        '<div data-server-rendered="true"><textarea></textarea></div>'
-      )
-      done()
-    })
+    )
   })
 
   it('Options inheritAttrs in parent component', done => {
@@ -1644,28 +2029,33 @@ describe('SSR: renderToString', () => {
       template: `<div>{{ someProp }}</div>`,
       props: {
         someProp: {}
-      },
+      }
     }
     const parentComponent = {
       template: `<childComponent v-bind="$attrs" />`,
       components: { childComponent },
       inheritAttrs: false
     }
-    renderVmWithOptions({
-      template: `
+    renderVmWithOptions(
+      {
+        template: `
         <div>
           <parentComponent some-prop="some-val" />
         </div>
         `,
-      components: { parentComponent }
-    }, result => {
-      expect(result).toContain('<div data-server-rendered="true"><div>some-val</div></div>')
-      done()
-    })
+        components: { parentComponent }
+      },
+      result => {
+        expect(result).toContain(
+          '<div data-server-rendered="true"><div>some-val</div></div>'
+        )
+        done()
+      }
+    )
   })
 })
 
-function renderVmWithOptions (options, cb) {
+function renderVmWithOptions(options, cb) {
   renderToString(new Vue(options), (err, res) => {
     expect(err).toBeNull()
     cb(res)
diff --git a/test/ssr/ssr-template.spec.ts b/test/ssr/ssr-template.spec.ts
index 8c77c89d4bc..ba716f4ea7b 100644
--- a/test/ssr/ssr-template.spec.ts
+++ b/test/ssr/ssr-template.spec.ts
@@ -118,7 +118,7 @@ describe('SSR: template option', () => {
       head: '<meta name="viewport" content="width=device-width">',
       styles: '<style>h1 { color: red }</style>',
       state: { a: 0 },
-      rendered: (context) => {
+      rendered: context => {
         context.state.a = 1
       }
     }
@@ -167,7 +167,7 @@ describe('SSR: template option', () => {
   it('renderToString w/ template function returning Promise', async () => {
     const renderer = createRenderer({
       template: (content, context) =>
-        new Promise<string>((resolve) => {
+        new Promise<string>(resolve => {
           setTimeout(() => {
             resolve(`<html><head>${context.head}</head>${content}</html>`)
           }, 0)
@@ -236,7 +236,7 @@ describe('SSR: template option', () => {
       )
 
       let res = ''
-      stream.on('data', (chunk) => {
+      stream.on('data', chunk => {
         res += chunk
       })
       stream.on('error', reject)
@@ -275,7 +275,7 @@ describe('SSR: template option', () => {
       )
 
       let res = ''
-      stream.on('data', (chunk) => {
+      stream.on('data', chunk => {
         res += chunk
       })
       stream.on('error', reject)
@@ -308,7 +308,7 @@ describe('SSR: template option', () => {
       head: '<meta name="viewport" content="width=device-width">',
       styles: '<style>h1 { color: red }</style>',
       state: { a: 0 },
-      rendered: (context) => {
+      rendered: context => {
         context.state.a = 1
       }
     }
@@ -322,7 +322,7 @@ describe('SSR: template option', () => {
       )
 
       let res = ''
-      stream.on('data', (chunk) => {
+      stream.on('data', chunk => {
         res += chunk
       })
       stream.on('error', reject)
@@ -377,10 +377,10 @@ describe('SSR: template option', () => {
       url: '/test'
     }
 
-    const res = await new Promise((resolve) => {
+    const res = await new Promise(resolve => {
       const stream = renderer.renderToStream(context)
       let res = ''
-      stream.on('data', (chunk) => {
+      stream.on('data', chunk => {
         res += chunk.toString()
       })
       stream.on('end', () => {
@@ -454,10 +454,10 @@ describe('SSR: template option', () => {
           }
         }
       })
-      const res = await new Promise((resolve) => {
+      const res = await new Promise(resolve => {
         const stream = renderer.renderToStream({ state: { a: 1 } })
         let res = ''
-        stream.on('data', (chunk) => {
+        stream.on('data', chunk => {
           res += chunk.toString()
         })
         stream.on('end', () => {
@@ -482,10 +482,10 @@ describe('SSR: template option', () => {
         }
       })
 
-      const res = await new Promise((resolve) => {
+      const res = await new Promise(resolve => {
         const stream = renderer.renderToStream({ state: { a: 1 } })
         let res = ''
-        stream.on('data', (chunk) => {
+        stream.on('data', chunk => {
           res += chunk.toString()
         })
         stream.on('end', () => {
diff --git a/test/transition/helpers.ts b/test/transition/helpers.ts
index f6a405f0cf7..a47fd01cb55 100644
--- a/test/transition/helpers.ts
+++ b/test/transition/helpers.ts
@@ -18,7 +18,7 @@ console.info = noop
 let asserted
 
 function createCompareFn(spy) {
-  const hasWarned = (msg) => {
+  const hasWarned = msg => {
     let count = spy.calls.count()
     let args
     while (count--) {
@@ -34,7 +34,7 @@ function createCompareFn(spy) {
   }
 
   return {
-    compare: (msg) => {
+    compare: msg => {
       asserted = asserted.concat(msg)
       const warned = Array.isArray(msg) ? msg.some(hasWarned) : hasWarned(msg)
       return {
@@ -60,9 +60,9 @@ beforeEach(() => {
   })
 })
 
-afterEach((done) => {
-  const warned = (msg) =>
-    asserted.some((assertedMsg) => msg.toString().indexOf(assertedMsg) > -1)
+afterEach(done => {
+  const warned = msg =>
+    asserted.some(assertedMsg => msg.toString().indexOf(assertedMsg) > -1)
   // @ts-ignore
   let count = console.error.calls.count()
   let args
diff --git a/test/transition/transition-group.spec.ts b/test/transition/transition-group.spec.ts
index a9c1ab62ffe..2c1905dbb7e 100644
--- a/test/transition/transition-group.spec.ts
+++ b/test/transition/transition-group.spec.ts
@@ -30,20 +30,20 @@ describe('Transition group', () => {
     if (!appear) {
       expect(vm.$el.innerHTML).toBe(
         `<span>` +
-          vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+          vm.items.map(i => `<div class="test">${i}</div>`).join('') +
           `</span>`
       )
     }
     return vm
   }
 
-  it('enter', (done) => {
+  it('enter', done => {
     const vm = createBasicVM()
     vm.items.push('d', 'e')
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe(
         `<span>` +
-          ['a', 'b', 'c'].map((i) => `<div class="test">${i}</div>`).join('') +
+          ['a', 'b', 'c'].map(i => `<div class="test">${i}</div>`).join('') +
           `<div class="test v-enter v-enter-active">d</div>` +
           `<div class="test v-enter v-enter-active">e</div>` +
           `</span>`
@@ -53,9 +53,7 @@ describe('Transition group', () => {
       .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            ['a', 'b', 'c']
-              .map((i) => `<div class="test">${i}</div>`)
-              .join('') +
+            ['a', 'b', 'c'].map(i => `<div class="test">${i}</div>`).join('') +
             `<div class="test v-enter-active v-enter-to">d</div>` +
             `<div class="test v-enter-active v-enter-to">e</div>` +
             `</span>`
@@ -65,14 +63,14 @@ describe('Transition group', () => {
       .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
             `</span>`
         )
       })
       .then(done)
   })
 
-  it('leave', (done) => {
+  it('leave', done => {
     const vm = createBasicVM()
     vm.items = ['b']
     waitForUpdate(() => {
@@ -98,14 +96,14 @@ describe('Transition group', () => {
       .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
             `</span>`
         )
       })
       .then(done)
   })
 
-  it('enter + leave', (done) => {
+  it('enter + leave', done => {
     const vm = createBasicVM()
     vm.items = ['b', 'c', 'd']
     waitForUpdate(() => {
@@ -133,14 +131,14 @@ describe('Transition group', () => {
       .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
             `</span>`
         )
       })
       .then(done)
   })
 
-  it('use with "is" attribute', (done) => {
+  it('use with "is" attribute', done => {
     const vm = createBasicVM(true)
     vm.items = ['b', 'c', 'd']
     waitForUpdate(() => {
@@ -168,20 +166,20 @@ describe('Transition group', () => {
       .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
             `</span>`
         )
       })
       .then(done)
   })
 
-  it('appear', (done) => {
+  it('appear', done => {
     const vm = createBasicVM(false, true /* appear */)
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe(
         `<span>` +
           vm.items
-            .map((i) => `<div class="test v-enter v-enter-active">${i}</div>`)
+            .map(i => `<div class="test v-enter v-enter-active">${i}</div>`)
             .join('') +
           `</span>`
       )
@@ -192,7 +190,7 @@ describe('Transition group', () => {
           `<span>` +
             vm.items
               .map(
-                (i) => `<div class="test v-enter-active v-enter-to">${i}</div>`
+                i => `<div class="test v-enter-active v-enter-to">${i}</div>`
               )
               .join('') +
             `</span>`
@@ -202,14 +200,14 @@ describe('Transition group', () => {
       .then(() => {
         expect(vm.$el.innerHTML).toBe(
           `<span>` +
-            vm.items.map((i) => `<div class="test">${i}</div>`).join('') +
+            vm.items.map(i => `<div class="test">${i}</div>`).join('') +
             `</span>`
         )
       })
       .then(done)
   })
 
-  it('events', (done) => {
+  it('events', done => {
     let next
     const beforeEnterSpy = jasmine.createSpy()
     const afterEnterSpy = jasmine.createSpy()
@@ -255,7 +253,7 @@ describe('Transition group', () => {
       )
       expect(beforeEnterSpy.calls.count()).toBe(1)
     })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -270,7 +268,7 @@ describe('Transition group', () => {
         expect(afterEnterSpy.calls.count()).toBe(1)
         vm.items.shift()
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -286,7 +284,7 @@ describe('Transition group', () => {
       .then(done)
   })
 
-  it('move', (done) => {
+  it('move', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -345,7 +343,7 @@ describe('Transition group', () => {
   })
 
   // GitHub issue #6006
-  it('should work with dynamic name', (done) => {
+  it('should work with dynamic name', done => {
     const vm = new Vue({
       template: `
           <div>
diff --git a/test/transition/transition-mode.spec.ts b/test/transition/transition-mode.spec.ts
index eba58ecbef5..779dd33f7e2 100644
--- a/test/transition/transition-mode.spec.ts
+++ b/test/transition/transition-mode.spec.ts
@@ -14,7 +14,7 @@ describe('Transition mode', () => {
     document.body.appendChild(el)
   })
 
-  it('dynamic components, simultaneous', (done) => {
+  it('dynamic components, simultaneous', done => {
     const vm = new Vue({
       template: `<div>
           <transition>
@@ -47,7 +47,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('dynamic components, out-in', (done) => {
+  it('dynamic components, out-in', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -77,7 +77,7 @@ describe('Transition mode', () => {
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -103,7 +103,7 @@ describe('Transition mode', () => {
   })
 
   // #3440
-  it('dynamic components, out-in (with extra re-render)', (done) => {
+  it('dynamic components, out-in (with extra re-render)', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -136,7 +136,7 @@ describe('Transition mode', () => {
         // this should not cause the incoming element to enter early
         vm.$forceUpdate()
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -161,7 +161,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('dynamic components, in-out', (done) => {
+  it('dynamic components, in-out', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -193,7 +193,7 @@ describe('Transition mode', () => {
             '<div class="test test-enter-active test-enter-to">two</div>'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -221,7 +221,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('dynamic components, in-out with early cancel', (done) => {
+  it('dynamic components, in-out with early cancel', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -271,7 +271,7 @@ describe('Transition mode', () => {
             '<div class="test test-enter-active test-enter-to">one</div>'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -299,7 +299,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('normal elements with different keys, simultaneous', (done) => {
+  it('normal elements with different keys, simultaneous', done => {
     const vm = new Vue({
       template: `<div>
           <transition>
@@ -331,7 +331,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('normal elements with different keys, out-in', (done) => {
+  it('normal elements with different keys, out-in', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -360,7 +360,7 @@ describe('Transition mode', () => {
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -385,7 +385,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('normal elements with different keys, in-out', (done) => {
+  it('normal elements with different keys, in-out', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -416,7 +416,7 @@ describe('Transition mode', () => {
             '<div class="test test-enter-active test-enter-to">two</div>'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -444,7 +444,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('transition out-in on async component (resolve before leave complete)', (done) => {
+  it('transition out-in on async component (resolve before leave complete)', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -455,13 +455,13 @@ describe('Transition mode', () => {
           </div>
         `,
       components: {
-        componentA: (resolve) => {
+        componentA: resolve => {
           setTimeout(() => {
             resolve({ template: '<div><h1>component A</h1></div>' })
             next1()
           }, duration / 2)
         },
-        componentB: (resolve) => {
+        componentB: resolve => {
           setTimeout(() => {
             resolve({ template: '<div><h1>component B</h1></div>' })
           }, duration / 2)
@@ -522,7 +522,7 @@ describe('Transition mode', () => {
     }
   })
 
-  it('transition out-in on async component (resolve after leave complete)', (done) => {
+  it('transition out-in on async component (resolve after leave complete)', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -534,7 +534,7 @@ describe('Transition mode', () => {
         `,
       components: {
         componentA: { template: '<div><h1>component A</h1></div>' },
-        componentB: (resolve) => {
+        componentB: resolve => {
           setTimeout(() => {
             resolve({ template: '<div><h1>component B</h1></div>' })
             Vue.nextTick(next)
@@ -569,7 +569,7 @@ describe('Transition mode', () => {
         expect(vm.$el.children.length).toBe(0)
         expect(vm.$el.innerHTML).toBe('<!---->')
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -594,7 +594,7 @@ describe('Transition mode', () => {
       .then(done)
   })
 
-  it('transition in-out on async component', (done) => {
+  it('transition in-out on async component', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -605,13 +605,13 @@ describe('Transition mode', () => {
           </div>
         `,
       components: {
-        componentA: (resolve) => {
+        componentA: resolve => {
           setTimeout(() => {
             resolve({ template: '<div><h1>component A</h1></div>' })
             next1()
           }, duration / 2)
         },
-        componentB: (resolve) => {
+        componentB: resolve => {
           setTimeout(() => {
             resolve({ template: '<div><h1>component B</h1></div>' })
             next2()
diff --git a/test/transition/transition-with-keep-alive.spec.ts b/test/transition/transition-with-keep-alive.spec.ts
index 09c6613046a..128255e0981 100644
--- a/test/transition/transition-with-keep-alive.spec.ts
+++ b/test/transition/transition-with-keep-alive.spec.ts
@@ -40,7 +40,7 @@ describe('Transition w/ KeepAlive', () => {
     ]).toEqual(callCounts)
   }
 
-  it('with transition-mode out-in', (done) => {
+  it('with transition-mode out-in', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -77,7 +77,7 @@ describe('Transition w/ KeepAlive', () => {
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -119,7 +119,7 @@ describe('Transition w/ KeepAlive', () => {
           '<div class="test test-leave-active test-leave-to">two</div><!---->'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -148,7 +148,7 @@ describe('Transition w/ KeepAlive', () => {
       .then(done)
   })
 
-  it('with transition-mode out-in + include', (done) => {
+  it('with transition-mode out-in + include', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -185,7 +185,7 @@ describe('Transition w/ KeepAlive', () => {
           '<div class="test test-leave-active test-leave-to">one</div><!---->'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -227,7 +227,7 @@ describe('Transition w/ KeepAlive', () => {
           '<div class="test test-leave-active test-leave-to">two</div><!---->'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -256,7 +256,7 @@ describe('Transition w/ KeepAlive', () => {
       .then(done)
   })
 
-  it('with transition-mode in-out', (done) => {
+  it('with transition-mode in-out', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -295,7 +295,7 @@ describe('Transition w/ KeepAlive', () => {
             '<div class="test test-enter-active test-enter-to">two</div>'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -340,7 +340,7 @@ describe('Transition w/ KeepAlive', () => {
             '<div class="test test-enter-active test-enter-to">one</div>'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -370,7 +370,7 @@ describe('Transition w/ KeepAlive', () => {
       .then(done)
   })
 
-  it('dynamic components, in-out with early cancel', (done) => {
+  it('dynamic components, in-out with early cancel', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -422,7 +422,7 @@ describe('Transition w/ KeepAlive', () => {
             '<div class="test test-enter-active test-enter-to">one</div>'
         )
       })
-      .thenWaitFor((_next) => {
+      .thenWaitFor(_next => {
         next = _next
       })
       .then(() => {
@@ -451,7 +451,7 @@ describe('Transition w/ KeepAlive', () => {
   })
 
   // #4339
-  it('component with inner transition', (done) => {
+  it('component with inner transition', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -513,16 +513,16 @@ describe('Transition w/ KeepAlive', () => {
       .then(done)
   })
 
-  it('async components with transition-mode out-in', (done) => {
+  it('async components with transition-mode out-in', done => {
     const barResolve = jasmine.createSpy()
     let next
-    const foo = (resolve) => {
+    const foo = resolve => {
       setTimeout(() => {
         resolve(one)
         Vue.nextTick(next)
       }, duration / 2)
     }
-    const bar = (resolve) => {
+    const bar = resolve => {
       setTimeout(() => {
         resolve(two)
         barResolve()
@@ -568,7 +568,7 @@ describe('Transition w/ KeepAlive', () => {
             '<div class="test test-enter-active test-enter-to">one</div>'
           )
         })
-        .thenWaitFor((_next) => {
+        .thenWaitFor(_next => {
           next = _next
         })
         .then(() => {
@@ -584,7 +584,7 @@ describe('Transition w/ KeepAlive', () => {
             '<div class="test test-leave-active test-leave-to">one</div><!---->'
           )
         })
-        .thenWaitFor((_next) => {
+        .thenWaitFor(_next => {
           next = _next
         })
         .then(() => {
@@ -607,7 +607,7 @@ describe('Transition w/ KeepAlive', () => {
             '<div class="test test-enter-active test-enter-to">two</div>'
           )
         })
-        .thenWaitFor((_next) => {
+        .thenWaitFor(_next => {
           next = _next
         })
         .then(() => {
@@ -619,7 +619,7 @@ describe('Transition w/ KeepAlive', () => {
   })
 
   // #10083
-  it('should not attach event handler repeatedly', (done) => {
+  it('should not attach event handler repeatedly', done => {
     const vm = new Vue({
       template: `
           <keep-alive>
diff --git a/test/transition/transition.spec.ts b/test/transition/transition.spec.ts
index e84a3cfa563..bff2e0fefd7 100644
--- a/test/transition/transition.spec.ts
+++ b/test/transition/transition.spec.ts
@@ -14,7 +14,7 @@ describe('Transition basic', () => {
     document.body.appendChild(el)
   })
 
-  it('basic transition', (done) => {
+  it('basic transition', done => {
     const vm = new Vue({
       template:
         '<div><transition><div v-if="ok" class="test">foo</div></transition></div>',
@@ -54,7 +54,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('named transition', (done) => {
+  it('named transition', done => {
     const vm = new Vue({
       template:
         '<div><transition name="test"><div v-if="ok" class="test">foo</div></transition></div>',
@@ -98,7 +98,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('custom transition classes', (done) => {
+  it('custom transition classes', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -147,7 +147,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('dynamic transition', (done) => {
+  it('dynamic transition', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -200,7 +200,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('inline transition object', (done) => {
+  it('inline transition object', done => {
     const enter = jasmine.createSpy()
     const leave = jasmine.createSpy()
     const vm = new Vue({
@@ -261,7 +261,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition events', (done) => {
+  it('transition events', done => {
     const onLeaveSpy = jasmine.createSpy()
     const onEnterSpy = jasmine.createSpy()
     const beforeLeaveSpy = jasmine.createSpy()
@@ -286,23 +286,23 @@ describe('Transition basic', () => {
         `,
       data: { ok: true },
       methods: {
-        beforeLeave: (el) => {
+        beforeLeave: el => {
           expect(el).toBe(vm.$el.children[0])
           expect(el.className).toBe('test')
           beforeLeaveSpy(el)
         },
-        leave: (el) => onLeaveSpy(el),
-        afterLeave: (el) => afterLeaveSpy(el),
-        beforeEnter: (el) => {
+        leave: el => onLeaveSpy(el),
+        afterLeave: el => afterLeaveSpy(el),
+        beforeEnter: el => {
           expect(vm.$el.contains(el)).toBe(false)
           expect(el.className).toBe('test')
           beforeEnterSpy(el)
         },
-        enter: (el) => {
+        enter: el => {
           expect(vm.$el.contains(el)).toBe(true)
           onEnterSpy(el)
         },
-        afterEnter: (el) => afterEnterSpy(el)
+        afterEnter: el => afterEnterSpy(el)
       }
     }).$mount(el)
 
@@ -354,7 +354,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition events (v-show)', (done) => {
+  it('transition events (v-show)', done => {
     const onLeaveSpy = jasmine.createSpy()
     const onEnterSpy = jasmine.createSpy()
     const beforeLeaveSpy = jasmine.createSpy()
@@ -379,30 +379,30 @@ describe('Transition basic', () => {
         `,
       data: { ok: true },
       methods: {
-        beforeLeave: (el) => {
+        beforeLeave: el => {
           expect(el.style.display).toBe('')
           expect(el).toBe(vm.$el.children[0])
           expect(el.className).toBe('test')
           beforeLeaveSpy(el)
         },
-        leave: (el) => {
+        leave: el => {
           expect(el.style.display).toBe('')
           onLeaveSpy(el)
         },
-        afterLeave: (el) => {
+        afterLeave: el => {
           expect(el.style.display).toBe('none')
           afterLeaveSpy(el)
         },
-        beforeEnter: (el) => {
+        beforeEnter: el => {
           expect(el.className).toBe('test')
           expect(el.style.display).toBe('none')
           beforeEnterSpy(el)
         },
-        enter: (el) => {
+        enter: el => {
           expect(el.style.display).toBe('')
           onEnterSpy(el)
         },
-        afterEnter: (el) => {
+        afterEnter: el => {
           expect(el.style.display).toBe('')
           afterEnterSpy(el)
         }
@@ -457,7 +457,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('explicit user callback in JavaScript hooks', (done) => {
+  it('explicit user callback in JavaScript hooks', done => {
     let next
     const vm = new Vue({
       template: `<div>
@@ -522,7 +522,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('css: false', (done) => {
+  it('css: false', done => {
     const enterSpy = jasmine.createSpy()
     const leaveSpy = jasmine.createSpy()
     const vm = new Vue({
@@ -553,7 +553,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('no transition detected', (done) => {
+  it('no transition detected', done => {
     const enterSpy = jasmine.createSpy()
     const leaveSpy = jasmine.createSpy()
     const vm = new Vue({
@@ -591,7 +591,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('enterCancelled', (done) => {
+  it('enterCancelled', done => {
     const spy = jasmine.createSpy()
     const vm = new Vue({
       template: `
@@ -643,7 +643,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('should remove stale leaving elements', (done) => {
+  it('should remove stale leaving elements', done => {
     const spy = jasmine.createSpy()
     const vm = new Vue({
       template: `
@@ -690,7 +690,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition with v-show', (done) => {
+  it('transition with v-show', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -742,7 +742,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition with v-show, inside child component', (done) => {
+  it('transition with v-show, inside child component', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -796,7 +796,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('leaveCancelled (v-show only)', (done) => {
+  it('leaveCancelled (v-show only)', done => {
     const spy = jasmine.createSpy()
     const vm = new Vue({
       template: `
@@ -848,7 +848,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('leave transition with v-show: cancelled on next frame', (done) => {
+  it('leave transition with v-show: cancelled on next frame', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -877,7 +877,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('enter transition with v-show: cancelled on next frame', (done) => {
+  it('enter transition with v-show: cancelled on next frame', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -906,7 +906,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('animations', (done) => {
+  it('animations', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -955,7 +955,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('explicit transition type', (done) => {
+  it('explicit transition type', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1017,7 +1017,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition on appear', (done) => {
+  it('transition on appear', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1051,7 +1051,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition on appear with v-show', (done) => {
+  it('transition on appear with v-show', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1081,7 +1081,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition on SVG elements', (done) => {
+  it('transition on SVG elements', done => {
     const vm = new Vue({
       template: `
           <svg>
@@ -1132,7 +1132,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition on child components', (done) => {
+  it('transition on child components', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1186,7 +1186,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition inside child component with v-if', (done) => {
+  it('transition inside child component with v-if', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1228,7 +1228,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition with appear inside child component with v-if', (done) => {
+  it('transition with appear inside child component with v-if', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1282,7 +1282,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition inside nested child component with v-if', (done) => {
+  it('transition inside nested child component with v-if', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1325,7 +1325,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('transition with appear inside nested child component with v-if', (done) => {
+  it('transition with appear inside nested child component with v-if', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1384,7 +1384,7 @@ describe('Transition basic', () => {
       .then(done)
   })
 
-  it('custom transition higher-order component', (done) => {
+  it('custom transition higher-order component', done => {
     const vm = new Vue({
       template:
         '<div><my-transition><div v-if="ok" class="test">foo</div></my-transition></div>',
@@ -1447,7 +1447,7 @@ describe('Transition basic', () => {
   })
 
   describe('explicit durations -', () => {
-    it('single value', (done) => {
+    it('single value', done => {
       const vm = new Vue({
         template: `
             <div>
@@ -1493,7 +1493,7 @@ describe('Transition basic', () => {
         .then(done)
     })
 
-    it('enter and auto leave', (done) => {
+    it('enter and auto leave', done => {
       const vm = new Vue({
         template: `
             <div>
@@ -1539,7 +1539,7 @@ describe('Transition basic', () => {
         .then(done)
     })
 
-    it('leave and auto enter', (done) => {
+    it('leave and auto enter', done => {
       const vm = new Vue({
         template: `
             <div>
@@ -1585,7 +1585,7 @@ describe('Transition basic', () => {
         .then(done)
     })
 
-    it('separate enter and leave', (done) => {
+    it('separate enter and leave', done => {
       const enter = explicitDuration
       const leave = explicitDuration * 2
 
@@ -1634,7 +1634,7 @@ describe('Transition basic', () => {
         .then(done)
     })
 
-    it('enter and leave + duration change', (done) => {
+    it('enter and leave + duration change', done => {
       const enter1 = explicitDuration * 2
       const enter2 = explicitDuration
       const leave1 = explicitDuration * 0.5
@@ -1725,7 +1725,7 @@ describe('Transition basic', () => {
         .then(done)
     }, 10000)
 
-    it('warn invalid durations', (done) => {
+    it('warn invalid durations', done => {
       const vm = new Vue({
         template: `
             <div>
@@ -1759,7 +1759,7 @@ describe('Transition basic', () => {
   })
 
   // #6687
-  it('transition on child components with empty root node', (done) => {
+  it('transition on child components with empty root node', done => {
     const vm = new Vue({
       template: `
           <div>
@@ -1819,7 +1819,7 @@ describe('Transition basic', () => {
   })
 
   // #8199
-  it('should not throw error when replaced by v-html contents', (done) => {
+  it('should not throw error when replaced by v-html contents', done => {
     const vm = new Vue({
       template: `
           <div>
diff --git a/test/unit/.eslintrc.json b/test/unit/.eslintrc.json
deleted file mode 100644
index 5973f4d4b0c..00000000000
--- a/test/unit/.eslintrc.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "globals": {
-    "waitForUpdate": true,
-    "triggerEvent": true,
-    "createTextVNode": true
-  }
-}
diff --git a/test/unit/features/component/component-async.spec.ts b/test/unit/features/component/component-async.spec.ts
index 9e08cfa59db..ec1ec2484fe 100644
--- a/test/unit/features/component/component-async.spec.ts
+++ b/test/unit/features/component/component-async.spec.ts
@@ -46,11 +46,11 @@ describe('Component async', () => {
     expect(JSON.stringify(timeoutsPending)).toEqual(JSON.stringify({}))
   })
 
-  it('normal', (done) => {
+  it('normal', done => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
-        test: (resolve) => {
+        test: resolve => {
           setTimeout(() => {
             resolve({
               template: '<div>hi</div>'
@@ -71,11 +71,11 @@ describe('Component async', () => {
     }
   })
 
-  it('resolve ES module default', (done) => {
+  it('resolve ES module default', done => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
-        test: (resolve) => {
+        test: resolve => {
           setTimeout(() => {
             resolve({
               __esModule: true,
@@ -99,11 +99,11 @@ describe('Component async', () => {
     }
   })
 
-  it('as root', (done) => {
+  it('as root', done => {
     const vm = new Vue({
       template: '<test></test>',
       components: {
-        test: (resolve) => {
+        test: resolve => {
           setTimeout(() => {
             resolve({
               template: '<div>hi</div>'
@@ -125,14 +125,14 @@ describe('Component async', () => {
     }
   })
 
-  it('dynamic', (done) => {
+  it('dynamic', done => {
     const vm = new Vue({
       template: '<component :is="view"></component>',
       data: {
         view: 'view-a'
       },
       components: {
-        'view-a': (resolve) => {
+        'view-a': resolve => {
           setTimeout(() => {
             resolve({
               template: '<div>A</div>'
@@ -140,7 +140,7 @@ describe('Component async', () => {
             Vue.nextTick(step1)
           }, 0)
         },
-        'view-b': (resolve) => {
+        'view-b': resolve => {
           setTimeout(() => {
             resolve({
               template: '<p>B</p>'
@@ -184,14 +184,14 @@ describe('Component async', () => {
     expect('Reason: nooooo').toHaveBeenWarned()
   })
 
-  it('with v-for', (done) => {
+  it('with v-for', done => {
     const vm = new Vue({
       template: '<div><test v-for="n in list" :key="n" :n="n"></test></div>',
       data: {
         list: [1, 2, 3]
       },
       components: {
-        test: (resolve) => {
+        test: resolve => {
           setTimeout(() => {
             resolve({
               props: ['n'],
@@ -209,12 +209,12 @@ describe('Component async', () => {
     }
   })
 
-  it('returning Promise', (done) => {
+  it('returning Promise', done => {
     const vm = new Vue({
       template: '<div><test></test></div>',
       components: {
         test: () => {
-          return new Promise((resolve) => {
+          return new Promise(resolve => {
             setTimeout(() => {
               resolve({
                 template: '<div>hi</div>'
@@ -239,12 +239,12 @@ describe('Component async', () => {
   })
 
   describe('loading/error/timeout', () => {
-    it('with loading component', (done) => {
+    it('with loading component', done => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
           test: () => ({
-            component: new Promise((resolve) => {
+            component: new Promise(resolve => {
               setTimeout(() => {
                 resolve({ template: '<div>hi</div>' })
                 // wait for promise resolve and then parent update
@@ -276,12 +276,12 @@ describe('Component async', () => {
       }
     })
 
-    it('with loading component (0 delay)', (done) => {
+    it('with loading component (0 delay)', done => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
           test: () => ({
-            component: new Promise((resolve) => {
+            component: new Promise(resolve => {
               setTimeout(() => {
                 resolve({ template: '<div>hi</div>' })
                 // wait for promise resolve and then parent update
@@ -304,7 +304,7 @@ describe('Component async', () => {
       }
     })
 
-    it('with error component', (done) => {
+    it('with error component', done => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -334,7 +334,7 @@ describe('Component async', () => {
       }
     })
 
-    it('with error component + timeout', (done) => {
+    it('with error component + timeout', done => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -371,7 +371,7 @@ describe('Component async', () => {
       }
     })
 
-    it('should not trigger timeout if resolved', (done) => {
+    it('should not trigger timeout if resolved', done => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -394,7 +394,7 @@ describe('Component async', () => {
       }, 50)
     })
 
-    it('should not have running timeout/loading if resolved', (done) => {
+    it('should not have running timeout/loading if resolved', done => {
       const vm = new Vue({
         template: `<div><test/></div>`,
         components: {
@@ -423,7 +423,7 @@ describe('Component async', () => {
     })
 
     // #7107
-    it(`should work when resolving sync in sibling component's mounted hook`, (done) => {
+    it(`should work when resolving sync in sibling component's mounted hook`, done => {
       let resolveTwo
 
       const vm = new Vue({
@@ -435,7 +435,7 @@ describe('Component async', () => {
               resolveTwo()
             }
           },
-          two: (resolve) => {
+          two: resolve => {
             resolveTwo = () => {
               resolve({
                 template: `<div>two</div>`
diff --git a/test/unit/features/component/component-keep-alive.spec.ts b/test/unit/features/component/component-keep-alive.spec.ts
index 833a33ea9f1..28722d0c6a6 100644
--- a/test/unit/features/component/component-keep-alive.spec.ts
+++ b/test/unit/features/component/component-keep-alive.spec.ts
@@ -37,7 +37,7 @@ describe('Component keep-alive', () => {
     ]).toEqual(callCounts)
   }
 
-  it('should work', (done) => {
+  it('should work', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -82,7 +82,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('should invoke hooks on the entire sub tree', (done) => {
+  it('should invoke hooks on the entire sub tree', done => {
     one.template = '<two/>'
     one.components = { two }
 
@@ -124,7 +124,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('should handle nested keep-alive hooks properly', (done) => {
+  it('should handle nested keep-alive hooks properly', done => {
     one.template = '<keep-alive><two v-if="ok" /></keep-alive>'
     one.data = () => ({ ok: true })
     one.components = { two }
@@ -262,7 +262,7 @@ describe('Component keep-alive', () => {
       .then(done)
   }
 
-  it('include (string)', (done) => {
+  it('include (string)', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -280,7 +280,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('include (regex)', (done) => {
+  it('include (regex)', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -298,7 +298,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('include (array)', (done) => {
+  it('include (array)', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -316,7 +316,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('exclude (string)', (done) => {
+  it('exclude (string)', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -334,7 +334,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('exclude (regex)', (done) => {
+  it('exclude (regex)', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -352,7 +352,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('exclude (array)', (done) => {
+  it('exclude (array)', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -370,7 +370,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('include + exclude', (done) => {
+  it('include + exclude', done => {
     const vm = new Vue({
       template: `
         <div v-if="ok">
@@ -388,7 +388,7 @@ describe('Component keep-alive', () => {
     sharedAssertions(vm, done)
   })
 
-  it('prune cache on include/exclude change', (done) => {
+  it('prune cache on include/exclude change', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -422,7 +422,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('prune cache on include/exclude change + view switch', (done) => {
+  it('prune cache on include/exclude change + view switch', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -453,7 +453,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('should not prune currently active instance', (done) => {
+  it('should not prune currently active instance', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -483,7 +483,7 @@ describe('Component keep-alive', () => {
   })
 
   // #3882
-  it('deeply nested keep-alive should be destroyed properly', (done) => {
+  it('deeply nested keep-alive should be destroyed properly', done => {
     one.template = `<div><keep-alive><two></two></keep-alive></div>`
     one.components = { two }
     const vm = new Vue({
@@ -508,7 +508,7 @@ describe('Component keep-alive', () => {
   })
 
   // #4237
-  it('should update latest props/listeners for a re-activated component', (done) => {
+  it('should update latest props/listeners for a re-activated component', done => {
     const one = {
       props: ['prop'],
       template: `<div>one {{ prop }}</div>`
@@ -541,7 +541,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('max', (done) => {
+  it('max', done => {
     const spyA = vi.fn()
     const spyB = vi.fn()
     const spyC = vi.fn()
@@ -611,7 +611,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('max=1', (done) => {
+  it('max=1', done => {
     const spyA = vi.fn()
     const spyB = vi.fn()
     const spyC = vi.fn()
@@ -690,7 +690,7 @@ describe('Component keep-alive', () => {
   })
 
   // #6938
-  it('should not cache anonymous component when include is specified', (done) => {
+  it('should not cache anonymous component when include is specified', done => {
     const Foo = {
       name: 'foo',
       template: `<div>foo</div>`,
@@ -746,7 +746,7 @@ describe('Component keep-alive', () => {
       .then(done)
   })
 
-  it('should cache anonymous components if include is not specified', (done) => {
+  it('should cache anonymous components if include is not specified', done => {
     const Foo = {
       template: `<div>foo</div>`,
       created: vi.fn()
@@ -802,7 +802,7 @@ describe('Component keep-alive', () => {
   })
 
   // #7105
-  it('should not destroy active instance when pruning cache', (done) => {
+  it('should not destroy active instance when pruning cache', done => {
     const Foo = {
       template: `<div>foo</div>`,
       destroyed: vi.fn()
diff --git a/test/unit/features/component/component-scoped-slot.spec.ts b/test/unit/features/component/component-scoped-slot.spec.ts
index 21b7d8e0db3..96c23f8c66c 100644
--- a/test/unit/features/component/component-scoped-slot.spec.ts
+++ b/test/unit/features/component/component-scoped-slot.spec.ts
@@ -12,7 +12,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
           template: `
@@ -40,7 +40,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
           template: `
@@ -70,7 +70,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               msg: 'hello',
               obj: { msg2: 'world', msg3: '.' }
@@ -103,7 +103,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               text: 'some text'
             }
@@ -129,7 +129,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               foo: {
                 text: 'some text'
@@ -144,7 +144,9 @@ describe('Component scoped slot', () => {
         }
       }
     }).$mount()
-    expect('slot v-bind without argument expects an Object').not.toHaveBeenWarned()
+    expect(
+      'slot v-bind without argument expects an Object'
+    ).not.toHaveBeenWarned()
   })
 
   it('named scoped slot', done => {
@@ -158,7 +160,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { foo: 'FOO', bar: 'BAR' }
           },
           template: `
@@ -186,7 +188,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { foo: 'FOO', bar: 'BAR' }
           },
           template: `
@@ -210,7 +212,7 @@ describe('Component scoped slot', () => {
       template: `<test></test>`,
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
           template: `
@@ -237,7 +239,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               items: ['foo', 'bar', 'baz']
             }
@@ -251,17 +253,24 @@ describe('Component scoped slot', () => {
       }
     }).$mount()
 
-    function assertOutput () {
-      expect(vm.$el.innerHTML).toBe(vm.$refs.test.items.map(item => {
-        return `<span>${item}</span>`
-      }).join(''))
+    function assertOutput() {
+      expect(vm.$el.innerHTML).toBe(
+        vm.$refs.test.items
+          .map(item => {
+            return `<span>${item}</span>`
+          })
+          .join('')
+      )
     }
 
     assertOutput()
     vm.$refs.test.items.reverse()
-    waitForUpdate(assertOutput).then(() => {
-      vm.$refs.test.items.push('qux')
-    }).then(assertOutput).then(done)
+    waitForUpdate(assertOutput)
+      .then(() => {
+        vm.$refs.test.items.push('qux')
+      })
+      .then(assertOutput)
+      .then(done)
   })
 
   it('slot inside v-for', done => {
@@ -275,7 +284,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               items: ['foo', 'bar', 'baz']
             }
@@ -291,17 +300,24 @@ describe('Component scoped slot', () => {
       }
     }).$mount()
 
-    function assertOutput () {
-      expect(vm.$el.innerHTML).toBe(vm.$refs.test.items.map(item => {
-        return `<li><span>${item}</span></li>`
-      }).join(''))
+    function assertOutput() {
+      expect(vm.$el.innerHTML).toBe(
+        vm.$refs.test.items
+          .map(item => {
+            return `<li><span>${item}</span></li>`
+          })
+          .join('')
+      )
     }
 
     assertOutput()
     vm.$refs.test.items.reverse()
-    waitForUpdate(assertOutput).then(() => {
-      vm.$refs.test.items.push('qux')
-    }).then(assertOutput).then(done)
+    waitForUpdate(assertOutput)
+      .then(() => {
+        vm.$refs.test.items.push('qux')
+      })
+      .then(assertOutput)
+      .then(done)
   })
 
   it('scoped slot without scope alias', () => {
@@ -313,7 +329,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
           template: `
@@ -338,7 +354,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
           template: `
@@ -363,7 +379,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               items: ['foo', 'bar', 'baz']
             }
@@ -381,7 +397,7 @@ describe('Component scoped slot', () => {
 
   it('render function usage (named, via data)', done => {
     const vm = new Vue({
-      render (h) {
+      render(h) {
         return h('test', {
           ref: 'test',
           scopedSlots: {
@@ -391,13 +407,16 @@ describe('Component scoped slot', () => {
       },
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
-          render (h) {
-            return h('div', this.$scopedSlots.item({
-              text: this.msg
-            }))
+          render(h) {
+            return h(
+              'div',
+              this.$scopedSlots.item({
+                text: this.msg
+              })
+            )
           }
         }
       }
@@ -412,17 +431,15 @@ describe('Component scoped slot', () => {
 
   it('render function usage (default, as children)', () => {
     const vm = new Vue({
-      render (h) {
-        return h('test', [
-          props => h('span', [props.msg])
-        ])
+      render(h) {
+        return h('test', [props => h('span', [props.msg])])
       },
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
-          render (h) {
+          render(h) {
             return h('div', this.$scopedSlots.default({ msg: this.msg }))
           }
         }
@@ -433,17 +450,15 @@ describe('Component scoped slot', () => {
 
   it('render function usage (default, as root)', () => {
     const vm = new Vue({
-      render (h) {
-        return h('test', [
-          props => h('span', [props.msg])
-        ])
+      render(h) {
+        return h('test', [props => h('span', [props.msg])])
       },
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
-          render (h) {
+          render(h) {
             const res = this.$scopedSlots.default({ msg: this.msg })
             // all scoped slots should be normalized into arrays
             expect(Array.isArray(res)).toBe(true)
@@ -559,10 +574,14 @@ describe('Component scoped slot', () => {
       }
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe('<span>hello foo</span> <span>hello bar</span> <span>hello abc</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>hello foo</span> <span>hello bar</span> <span>hello abc</span>'
+    )
     vm.$refs.test.msg = 'world'
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world foo</span> <span>world bar</span> <span>world abc</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>world foo</span> <span>world bar</span> <span>world abc</span>'
+      )
     }).then(done)
   })
 
@@ -589,10 +608,14 @@ describe('Component scoped slot', () => {
       }
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe('<span>hello foo</span> <span>hello bar</span> <span>hello abc</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>hello foo</span> <span>hello bar</span> <span>hello abc</span>'
+    )
     vm.$refs.test.msg = 'world'
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>world foo</span> <span>world bar</span> <span>world abc</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>world foo</span> <span>world bar</span> <span>world abc</span>'
+      )
     }).then(done)
   })
 
@@ -611,7 +634,7 @@ describe('Component scoped slot', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { msg: 'hello' }
           },
           template: `
@@ -636,7 +659,7 @@ describe('Component scoped slot', () => {
   // the behavior of the new syntax is slightly different.
   it('scoped slot v-if using slot-scope value', () => {
     const Child = {
-      template: '<div><slot value="foo"/></div>',
+      template: '<div><slot value="foo"/></div>'
     }
     const vm = new Vue({
       components: { Child },
@@ -656,7 +679,8 @@ describe('Component scoped slot', () => {
     const Foo = {
       render(h) {
         return h('div', [
-          this.$scopedSlots.default && this.$scopedSlots.default('from foo default'),
+          this.$scopedSlots.default &&
+            this.$scopedSlots.default('from foo default'),
           this.$scopedSlots.one && this.$scopedSlots.one('from foo one'),
           this.$scopedSlots.two && this.$scopedSlots.two('from foo two')
         ])
@@ -665,19 +689,24 @@ describe('Component scoped slot', () => {
 
     const Bar = {
       render(h) {
-        return this.$scopedSlots.default && this.$scopedSlots.default('from bar')
+        return (
+          this.$scopedSlots.default && this.$scopedSlots.default('from bar')
+        )
       }
     }
 
     const Baz = {
       render(h) {
-        return this.$scopedSlots.default && this.$scopedSlots.default('from baz')
+        return (
+          this.$scopedSlots.default && this.$scopedSlots.default('from baz')
+        )
       }
     }
 
-    const toNamed = (syntax, name) => syntax[0] === '#'
-      ? `#${name}` // shorthand
-      : `${syntax}:${name}` // full syntax
+    const toNamed = (syntax, name) =>
+      syntax[0] === '#'
+        ? `#${name}` // shorthand
+        : `${syntax}:${name}` // full syntax
 
     function runSuite(syntax) {
       it('default slot', () => {
@@ -685,7 +714,9 @@ describe('Component scoped slot', () => {
           template: `<foo ${syntax}="foo">{{ foo }}<div>{{ foo }}</div></foo>`,
           components: { Foo }
         }).$mount()
-        expect(vm.$el.innerHTML).toBe(`from foo default<div>from foo default</div>`)
+        expect(vm.$el.innerHTML).toBe(
+          `from foo default<div>from foo default</div>`
+        )
       })
 
       it('nested default slots', () => {
@@ -701,7 +732,9 @@ describe('Component scoped slot', () => {
           `,
           components: { Foo, Bar, Baz }
         }).$mount()
-        expect(vm.$el.innerHTML.trim()).toBe(`from foo default | from bar | from baz`)
+        expect(vm.$el.innerHTML.trim()).toBe(
+          `from foo default | from bar | from baz`
+        )
       })
 
       it('named slots', () => {
@@ -721,7 +754,9 @@ describe('Component scoped slot', () => {
           `,
           components: { Foo }
         }).$mount()
-        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo default from foo one from foo two`)
+        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(
+          `from foo default from foo one from foo two`
+        )
       })
 
       it('nested + named + default slots', () => {
@@ -742,14 +777,18 @@ describe('Component scoped slot', () => {
           `,
           components: { Foo, Bar, Baz }
         }).$mount()
-        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo one from bar from foo two from baz`)
+        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(
+          `from foo one from bar from foo two from baz`
+        )
       })
 
       it('should warn v-slot usage on non-component elements', () => {
         new Vue({
           template: `<div ${syntax}="foo"/>`
         }).$mount()
-        expect(`v-slot can only be used on components or <template>`).toHaveBeenWarned()
+        expect(
+          `v-slot can only be used on components or <template>`
+        ).toHaveBeenWarned()
       })
 
       it('should warn mixed usage', () => {
@@ -757,14 +796,16 @@ describe('Component scoped slot', () => {
           template: `<foo><bar slot="one" slot-scope="bar" ${syntax}="bar"></bar></foo>`,
           components: { Foo, Bar }
         }).$mount()
-        expect(`Unexpected mixed usage of different slot syntaxes`).toHaveBeenWarned()
+        expect(
+          `Unexpected mixed usage of different slot syntaxes`
+        ).toHaveBeenWarned()
       })
 
       it('should warn invalid parameter expression', () => {
         new Vue({
           template: `<foo ${syntax}="1"></foo>`,
           components: { Foo }
-        }).$mount();
+        }).$mount()
         expect('invalid function parameter expression').toHaveBeenWarned()
       })
 
@@ -772,7 +813,7 @@ describe('Component scoped slot', () => {
         new Vue({
           template: `<foo ${syntax}="{ foo = { bar: '1' } }"></foo>`,
           components: { Foo }
-        }).$mount();
+        }).$mount()
         expect('invalid function parameter expression').not.toHaveBeenWarned()
       })
     }
@@ -798,7 +839,9 @@ describe('Component scoped slot', () => {
         `,
         components: { Foo }
       }).$mount()
-      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`from foo default from foo one from foo two`)
+      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(
+        `from foo default from foo one from foo two`
+      )
     })
 
     it('should warn mixed root-default and named slots', () => {
@@ -855,11 +898,15 @@ describe('Component scoped slot', () => {
         `,
         components: { Foo }
       }).$mount()
-      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`a from foo one b from foo two`)
+      expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(
+        `a from foo one b from foo two`
+      )
       vm.a = 'two'
       vm.b = 'one'
       waitForUpdate(() => {
-        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(`b from foo one a from foo two `)
+        expect(vm.$el.innerHTML.replace(/\s+/g, ' ')).toMatch(
+          `b from foo one a from foo two `
+        )
       }).then(done)
     })
 
@@ -893,7 +940,9 @@ describe('Component scoped slot', () => {
         `,
         components: { Foo }
       }).$mount()
-      expect(`<template v-slot> can only appear at the root level`).toHaveBeenWarned()
+      expect(
+        `<template v-slot> can only appear at the root level`
+      ).toHaveBeenWarned()
     })
   })
 
@@ -927,12 +976,14 @@ describe('Component scoped slot', () => {
       expect(childUpdate.mock.calls.length).toBe(0)
 
       vm.childCount++
-    }).then(() => {
-      expect(vm.$el.innerHTML).toMatch(`1<div>1</div>`)
-      // should only trigger child update
-      expect(parentUpdate.mock.calls.length).toBe(1)
-      expect(childUpdate.mock.calls.length).toBe(1)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toMatch(`1<div>1</div>`)
+        // should only trigger child update
+        expect(parentUpdate.mock.calls.length).toBe(1)
+        expect(childUpdate.mock.calls.length).toBe(1)
+      })
+      .then(done)
   })
 
   // #9432: async components inside a scoped slot should trigger update of the
@@ -961,7 +1012,7 @@ describe('Component scoped slot', () => {
       }
     }).$mount()
 
-    function next () {
+    function next() {
       waitForUpdate(() => {
         expect(vm.$el.textContent).toBe(`foobar`)
       }).then(done)
@@ -1047,7 +1098,9 @@ describe('Component scoped slot', () => {
 
     vm.$refs.foo.key = 'changed'
     waitForUpdate(() => {
-      expect(vm.$el.textContent).toBe(JSON.stringify({ changed: 'hello' }, null, 2))
+      expect(vm.$el.textContent).toBe(
+        JSON.stringify({ changed: 'hello' }, null, 2)
+      )
     }).then(done)
   })
 
@@ -1271,14 +1324,17 @@ describe('Component scoped slot', () => {
       expect(vm.$el.textContent).toMatch(`Default:ok`)
       expect(vm.$el.textContent).toMatch(`Content:ok`)
       vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).not.toMatch(`Default:ok`)
-      expect(vm.$el.textContent).not.toMatch(`Content:ok`)
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toMatch(`Default:ok`)
-      expect(vm.$el.textContent).toMatch(`Content:ok`)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).not.toMatch(`Default:ok`)
+        expect(vm.$el.textContent).not.toMatch(`Content:ok`)
+        vm.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toMatch(`Default:ok`)
+        expect(vm.$el.textContent).toMatch(`Content:ok`)
+      })
+      .then(done)
   })
 
   //#9658
@@ -1313,9 +1369,7 @@ describe('Component scoped slot', () => {
     const vm = new Vue({
       data: { count: 0 },
       render(h) {
-        return h(two, [
-          h('span', { slot: 'footer' }, this.count)
-        ])
+        return h(two, [h('span', { slot: 'footer' }, this.count)])
       }
     }).$mount()
 
@@ -1344,8 +1398,8 @@ describe('Component scoped slot', () => {
     }).$mount()
 
     expect(parent.$el.textContent).toMatch(`foo`)
-    parent.flag=false
-    waitForUpdate(()=>{
+    parent.flag = false
+    waitForUpdate(() => {
       expect(parent.$el.textContent).toMatch(``)
     }).then(done)
   })
diff --git a/test/unit/features/component/component-slot.spec.ts b/test/unit/features/component/component-slot.spec.ts
index e1004ba8dea..a8042bf5700 100644
--- a/test/unit/features/component/component-slot.spec.ts
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -2,7 +2,7 @@ import Vue from 'vue'
 
 describe('Component slot', () => {
   let vm, child
-  function mount (options) {
+  function mount(options) {
     vm = new Vue({
       data: {
         msg: 'parent message'
@@ -11,7 +11,7 @@ describe('Component slot', () => {
       components: {
         test: {
           template: options.childTemplate,
-          data () {
+          data() {
             return {
               msg: 'child message'
             }
@@ -109,13 +109,17 @@ describe('Component slot', () => {
     expect(child.$el.children[1].textContent).toBe('slot b')
   })
 
- it('it should work with previous versions of the templates', () => {
-   const Test = {
+  it('it should work with previous versions of the templates', () => {
+    const Test = {
       render() {
-        const _vm = this;
+        const _vm = this
         // const _h = _vm.$createElement;
-        const _c = _vm._self._c || vm._h;
-        return _c('div', [_vm._t("default", [_c('p', [_vm._v("slot default")])])], 2)
+        const _c = _vm._self._c || vm._h
+        return _c(
+          'div',
+          [_vm._t('default', [_c('p', [_vm._v('slot default')])])],
+          2
+        )
       }
     }
     let vm = new Vue({
@@ -138,7 +142,7 @@ describe('Component slot', () => {
         test: {
           template: '<div><slot>{{test()}}</slot></div>',
           methods: {
-            test () {
+            test() {
               test()
               return 'test'
             }
@@ -221,13 +225,16 @@ describe('Component slot', () => {
     waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('22')
       vm.show = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('')
-      vm.show = true
-      vm.a = 3
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('32')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('')
+        vm.show = true
+        vm.a = 3
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('32')
+      })
+      .then(done)
   })
 
   it('slot inside v-for', () => {
@@ -279,9 +286,11 @@ describe('Component slot', () => {
       expect(vm.$el.innerHTML).toBe('fallback')
       vm.ok = true
       vm.msg = 'bye'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<p>bye</p>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<p>bye</p>')
+      })
+      .then(done)
   })
 
   it('template slot', function () {
@@ -341,7 +350,7 @@ describe('Component slot', () => {
       template: '<test><p slot="a">A</p><div>C</div><p slot="b">B</p></test>',
       components: {
         test: {
-          render () {
+          render() {
             expect(this.$slots.a.length).toBe(1)
             expect(this.$slots.a[0].tag).toBe('p')
             expect(this.$slots.a[0].children.length).toBe(1)
@@ -371,13 +380,15 @@ describe('Component slot', () => {
       template: '<test><div slot="foo"></div><div slot="foo"></div></test>',
       components: {
         test: {
-          render () {
+          render() {
             return this.$slots.foo
           }
         }
       }
     }).$mount()
-    expect('Render function should return a single root node').toHaveBeenWarned()
+    expect(
+      'Render function should return a single root node'
+    ).toHaveBeenWarned()
   })
 
   // #3254
@@ -445,7 +456,7 @@ describe('Component slot', () => {
       components: {
         test: {
           functional: true,
-          render (h, ctx) {
+          render(h, ctx) {
             const slots = ctx.slots()
             return h(child, slots.foo)
           }
@@ -466,7 +477,7 @@ describe('Component slot', () => {
       `,
       components: {
         comp: {
-          data () {
+          data() {
             return { a: 1 }
           },
           template: `<div><slot name="foo"></slot>{{ a }}</div>`
@@ -493,17 +504,17 @@ describe('Component slot', () => {
       `,
       components: {
         comp: {
-          data () {
+          data() {
             return { ok: true }
           },
           template: `<div><slot name="foo" v-if="ok"></slot></div>`
         },
         child: {
           template: '<div>child</div>',
-          created () {
+          created() {
             calls.push(1)
           },
-          destroyed () {
+          destroyed() {
             calls.push(2)
           }
         }
@@ -515,12 +526,15 @@ describe('Component slot', () => {
     waitForUpdate(() => {
       expect(calls).toEqual([1, 2])
       vm.$refs.child.ok = true
-    }).then(() => {
-      expect(calls).toEqual([1, 2, 1])
-      vm.$refs.child.ok = false
-    }).then(() => {
-      expect(calls).toEqual([1, 2, 1, 2])
-    }).then(done)
+    })
+      .then(() => {
+        expect(calls).toEqual([1, 2, 1])
+        vm.$refs.child.ok = false
+      })
+      .then(() => {
+        expect(calls).toEqual([1, 2, 1, 2])
+      })
+      .then(done)
   })
 
   it('should support duplicate slots', done => {
@@ -548,21 +562,35 @@ describe('Component slot', () => {
         }
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe(`<div>1</div> <div>1</div> <pre><div>1</div></pre>`)
+    expect(vm.$el.innerHTML).toBe(
+      `<div>1</div> <div>1</div> <pre><div>1</div></pre>`
+    )
     vm.n++
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>2</div> <div>2</div> <pre><div>2</div></pre>`)
-      vm.n++
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>3</div> <div>3</div> <pre><div>3</div></pre>`)
-      vm.$refs.foo.ok = false
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>3</div> <!----> <pre><div>3</div></pre>`)
+      expect(vm.$el.innerHTML).toBe(
+        `<div>2</div> <div>2</div> <pre><div>2</div></pre>`
+      )
       vm.n++
-      vm.$refs.foo.ok = true
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(`<div>4</div> <div>4</div> <pre><div>4</div></pre>`)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          `<div>3</div> <div>3</div> <pre><div>3</div></pre>`
+        )
+        vm.$refs.foo.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          `<div>3</div> <!----> <pre><div>3</div></pre>`
+        )
+        vm.n++
+        vm.$refs.foo.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          `<div>4</div> <div>4</div> <pre><div>4</div></pre>`
+        )
+      })
+      .then(done)
   })
 
   // #3518
@@ -588,12 +616,15 @@ describe('Component slot', () => {
     vm.$children[0].toggle = false
     waitForUpdate(() => {
       vm.$children[0].toggle = true
-    }).then(() => {
-      global.triggerEvent(vm.$el.querySelector('.click'), 'click')
-      expect(spy).toHaveBeenCalled()
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        global.triggerEvent(vm.$el.querySelector('.click'), 'click')
+        expect(spy).toHaveBeenCalled()
+      })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('renders static tree with text', () => {
@@ -624,7 +655,7 @@ describe('Component slot', () => {
         },
         child: {
           functional: true,
-          render (h, { slots }) {
+          render(h, { slots }) {
             return h('div', slots().default)
           }
         }
@@ -659,21 +690,21 @@ describe('Component slot', () => {
   // #4315
   it('functional component passing slot content to stateful child component', done => {
     const ComponentWithSlots = {
-      render (h) {
+      render(h) {
         return h('div', this.$slots.slot1)
       }
     }
 
     const FunctionalComp = {
       functional: true,
-      render (h) {
+      render(h) {
         return h(ComponentWithSlots, [h('span', { slot: 'slot1' }, 'foo')])
       }
     }
 
     const vm = new Vue({
       data: { n: 1 },
-      render (h) {
+      render(h) {
         return h('div', [this.n, h(FunctionalComp)])
       }
     }).$mount()
@@ -689,7 +720,8 @@ describe('Component slot', () => {
   it('the elements of slot should be updated correctly', done => {
     const vm = new Vue({
       data: { n: 1 },
-      template: '<div><test><span v-for="i in n" :key="i">{{ i }}</span><input value="a"/></test></div>',
+      template:
+        '<div><test><span v-for="i in n" :key="i">{{ i }}</span><input value="a"/></test></div>',
       components: {
         test: {
           template: '<div><slot></slot></div>'
@@ -701,7 +733,9 @@ describe('Component slot', () => {
     input.value = 'b'
     vm.n++
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<div><span>1</span><span>2</span><input value="a"></div>')
+      expect(vm.$el.innerHTML).toBe(
+        '<div><span>1</span><span>2</span><input value="a"></div>'
+      )
       expect(vm.$el.querySelector('input')).toBe(input)
       expect(vm.$el.querySelector('input').value).toBe('b')
     }).then(done)
@@ -740,7 +774,7 @@ describe('Component slot', () => {
           <slot />
         </component>
       `,
-      data () {
+      data() {
         return {
           toggleEl: true
         }
@@ -771,11 +805,15 @@ describe('Component slot', () => {
       }
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe(`<b><div><div>foo</div></div> <div>bar<div>foo</div></div></b>`)
+    expect(vm.$el.innerHTML).toBe(
+      `<b><div><div>foo</div></div> <div>bar<div>foo</div></div></b>`
+    )
 
     vm.$refs.test.toggleEl = false
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe(`<i><div><div>foo</div></div> <div>bar<div>foo</div></div></i>`)
+      expect(vm.$el.innerHTML).toBe(
+        `<i><div><div>foo</div></div> <div>bar<div>foo</div></div></i>`
+      )
     }).then(done)
   })
 
@@ -805,7 +843,9 @@ describe('Component slot', () => {
       template: `<div><foo>hello</foo></div>`
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe('<div class="foo"><div class="bar">hello</div></div>')
+    expect(vm.$el.innerHTML).toBe(
+      '<div class="foo"><div class="bar">hello</div></div>'
+    )
   })
 
   it('fallback content for named template slot', () => {
@@ -823,7 +863,9 @@ describe('Component slot', () => {
       template: `<div><foo></foo></div>`
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe('<div class="foo"><div class="bar">fallback</div></div>')
+    expect(vm.$el.innerHTML).toBe(
+      '<div class="foo"><div class="bar">fallback</div></div>'
+    )
   })
 
   // #7106
@@ -832,14 +874,14 @@ describe('Component slot', () => {
       data: () => ({
         foo: true
       }),
-      render (h) {
+      render(h) {
         this.foo
         return h('div', this.$slots.slot)
       }
     }
 
     const Two = {
-      render (h) {
+      render(h) {
         return h('span', this.$slots.slot)
       }
     }
@@ -874,14 +916,14 @@ describe('Component slot', () => {
   it('should allow passing named slots as raw children down multiple layers of functional component', () => {
     const CompB = {
       functional: true,
-      render (h, { slots }) {
+      render(h, { slots }) {
         return slots().foo
       }
     }
 
     const CompA = {
       functional: true,
-      render (h, { children }) {
+      render(h, { children }) {
         return h(CompB, children)
       }
     }
@@ -910,14 +952,12 @@ describe('Component slot', () => {
     }
 
     const Stateful = {
-      data () {
+      data() {
         return { ok: true }
       },
-      render (h) {
+      render(h) {
         this.ok // register dep
-        return h('div', [
-          h(Functional, this.$slots.named)
-        ])
+        return h('div', [h(Functional, this.$slots.named)])
       }
     }
 
@@ -939,7 +979,7 @@ describe('Component slot', () => {
       template: '<b>{{ message }}</b>',
       props: ['message']
     }
-     let parentVm
+    let parentVm
     const ParentComponent = {
       template: `
         <div>
@@ -951,16 +991,16 @@ describe('Component slot', () => {
           </span>
         </div>
       `,
-      data () {
+      data() {
         return {
           alter: true
         }
       },
-      mounted () {
+      mounted() {
         parentVm = this
       }
     }
-     const vm = new Vue({
+    const vm = new Vue({
       template: `
         <parent-component>
           <span slot="foo">
@@ -972,19 +1012,23 @@ describe('Component slot', () => {
         ChildComponent,
         ParentComponent
       },
-      data () {
+      data() {
         return {
           message: 1
         }
       }
     }).$mount()
-     expect(vm.$el.firstChild.innerHTML).toBe('<span><span><b>1</b></span></span>')
+    expect(vm.$el.firstChild.innerHTML).toBe(
+      '<span><span><b>1</b></span></span>'
+    )
     parentVm.alter = false
     waitForUpdate(() => {
       vm.message = 2
-    }).then(() => {
-      expect(vm.$el.firstChild.innerHTML).toBe('<span><b>2</b></span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.innerHTML).toBe('<span><b>2</b></span>')
+      })
+      .then(done)
   })
 
   // #12102
diff --git a/test/unit/features/component/component.spec.ts b/test/unit/features/component/component.spec.ts
index 587b0eec931..510ad2473ba 100644
--- a/test/unit/features/component/component.spec.ts
+++ b/test/unit/features/component/component.spec.ts
@@ -6,7 +6,7 @@ describe('Component', () => {
       template: '<test></test>',
       components: {
         test: {
-          data () {
+          data() {
             return { a: 123 }
           },
           template: '<span>{{a}}</span>'
@@ -22,14 +22,16 @@ describe('Component', () => {
       template: '<div><table><tbody><test></test></tbody></table></div>',
       components: {
         test: {
-          data () {
+          data() {
             return { a: 123 }
           },
           template: '<tr><td>{{a}}</td></tr>'
         }
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<table><tbody><tr><td>123</td></tr></tbody></table>')
+    expect(vm.$el.innerHTML).toBe(
+      '<table><tbody><tr><td>123</td></tr></tbody></table>'
+    )
   })
 
   it('"is" attribute', () => {
@@ -37,14 +39,16 @@ describe('Component', () => {
       template: '<div><table><tbody><tr is="test"></tr></tbody></table></div>',
       components: {
         test: {
-          data () {
+          data() {
             return { a: 123 }
           },
           template: '<tr><td>{{a}}</td></tr>'
         }
       }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<table><tbody><tr><td>123</td></tr></tbody></table>')
+    expect(vm.$el.innerHTML).toBe(
+      '<table><tbody><tr><td>123</td></tr></tbody></table>'
+    )
   })
 
   it('inline-template', () => {
@@ -55,7 +59,7 @@ describe('Component', () => {
       },
       components: {
         test: {
-          data () {
+          data() {
             return { a: 'child' }
           }
         }
@@ -69,14 +73,16 @@ describe('Component', () => {
       template: '<test></test>',
       components: {
         test: {
-          data () {
+          data() {
             return { a: 123, b: 234 }
           },
           template: '<p>{{a}}</p><p>{{b}}</p>'
         }
       }
     }).$mount()
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
+    expect(
+      'Component template should contain exactly one root element'
+    ).toHaveBeenWarned()
   })
 
   it('dynamic', done => {
@@ -88,13 +94,13 @@ describe('Component', () => {
       components: {
         'view-a': {
           template: '<div>foo {{view}}</div>',
-          data () {
+          data() {
             return { view: 'a' }
           }
         },
         'view-b': {
           template: '<div>bar {{view}}</div>',
-          data () {
+          data() {
             return { view: 'b' }
           }
         }
@@ -109,7 +115,8 @@ describe('Component', () => {
       .then(() => {
         expect(vm.$el.nodeType).toBe(8)
         expect(vm.$el.data).toBe('')
-      }).then(done)
+      })
+      .then(done)
   })
 
   it('dynamic with props', done => {
@@ -134,18 +141,20 @@ describe('Component', () => {
     waitForUpdate(() => {
       expect(vm.$el.outerHTML).toBe('<div>bar view-b</div>')
       vm.view = ''
-    }).then(() => {
-      expect(vm.$el.nodeType).toBe(8)
-      expect(vm.$el.data).toBe('')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.nodeType).toBe(8)
+        expect(vm.$el.data).toBe('')
+      })
+      .then(done)
   })
 
   it(':is using raw component constructor', () => {
     const vm = new Vue({
       template:
         '<div>' +
-          '<component :is="$options.components.test"></component>' +
-          '<component :is="$options.components.async"></component>' +
+        '<component :is="$options.components.test"></component>' +
+        '<component :is="$options.components.async"></component>' +
         '</div>',
       components: {
         test: {
@@ -165,7 +174,7 @@ describe('Component', () => {
     const vm = new Vue({
       template:
         '<div>' +
-          '<component v-for="(c, i) in comps" :key="i" :is="c.type"></component>' +
+        '<component v-for="(c, i) in comps" :key="i" :is="c.type"></component>' +
         '</div>',
       data: {
         comps: [{ type: 'one' }, { type: 'two' }]
@@ -215,7 +224,7 @@ describe('Component', () => {
       components: {
         test: {
           template: '<div><slot></slot> {{message}}</div>',
-          data () {
+          data() {
             return {
               message: 'world'
             }
@@ -243,7 +252,7 @@ describe('Component', () => {
       components: {
         test: {
           template: '<div><slot></slot> {{message}}</div>',
-          data () {
+          data() {
             return {
               message: 'world'
             }
@@ -284,7 +293,8 @@ describe('Component', () => {
       template: '<test :somecollection="list"></test>', // <-- simulate lowercased template
       components: {
         test: {
-          template: '<ul><li v-for="item in someCollection">{{item.a}}</li></ul>',
+          template:
+            '<ul><li v-for="item in someCollection">{{item.a}}</li></ul>',
           props: ['someCollection']
         }
       }
@@ -300,7 +310,7 @@ describe('Component', () => {
       components: {
         test: {
           template: '<div></div>',
-          created () {
+          created() {
             this.$emit('fooBar')
           }
         }
@@ -327,10 +337,10 @@ describe('Component', () => {
       template: '<test id="foo" :class="color"></test>',
       components: {
         test: {
-          data () {
+          data() {
             return { tag: 'div' }
           },
-          render (h) {
+          render(h) {
             return h(this.tag, { class: 'test' }, 'hi')
           }
         }
@@ -347,16 +357,19 @@ describe('Component', () => {
       expect(vm.$el.id).toBe('foo')
       expect(vm.$el.className).toBe('test green')
       vm.$children[0].tag = 'p'
-    }).then(() => {
-      expect(vm.$el.tagName).toBe('P')
-      expect(vm.$el.id).toBe('foo')
-      expect(vm.$el.className).toBe('test green')
-      vm.color = 'red'
-    }).then(() => {
-      expect(vm.$el.tagName).toBe('P')
-      expect(vm.$el.id).toBe('foo')
-      expect(vm.$el.className).toBe('test red')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.tagName).toBe('P')
+        expect(vm.$el.id).toBe('foo')
+        expect(vm.$el.className).toBe('test green')
+        vm.color = 'red'
+      })
+      .then(() => {
+        expect(vm.$el.tagName).toBe('P')
+        expect(vm.$el.id).toBe('foo')
+        expect(vm.$el.className).toBe('test red')
+      })
+      .then(done)
   })
 
   it('catch component render error and preserve previous vnode', done => {
@@ -368,7 +381,7 @@ describe('Component', () => {
           b: 123
         }
       },
-      render (h) {
+      render(h) {
         return h('div', [this.a.b])
       }
     }).$mount()
@@ -379,10 +392,12 @@ describe('Component', () => {
       expect(spy).toHaveBeenCalled()
       expect(vm.$el.textContent).toBe('123') // should preserve rendered DOM
       vm.a = { b: 234 }
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('234') // should be able to recover
-      Vue.config.errorHandler = undefined
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('234') // should be able to recover
+        Vue.config.errorHandler = undefined
+      })
+      .then(done)
   })
 
   it('relocates node without error', done => {
@@ -392,13 +407,13 @@ describe('Component', () => {
     document.body.appendChild(target)
 
     const Test = {
-      render (h) {
+      render(h) {
         return h('div', { class: 'test' }, this.$slots.default)
       },
-      mounted () {
+      mounted() {
         target.appendChild(this.$el)
       },
-      beforeDestroy () {
+      beforeDestroy() {
         const parent = this.$el.parentNode
         if (parent) {
           parent.removeChild(this.$el)
@@ -406,7 +421,7 @@ describe('Component', () => {
       }
     }
     const vm = new Vue({
-      data () {
+      data() {
         return {
           view: true
         }
@@ -437,6 +452,8 @@ describe('Component', () => {
       }
     }).$mount()
     expect(vm.$el.nodeName).toBe('#comment')
-    expect('Templates should only be responsible for mapping the state').toHaveBeenWarned()
+    expect(
+      'Templates should only be responsible for mapping the state'
+    ).toHaveBeenWarned()
   })
 })
diff --git a/test/unit/features/debug.spec.ts b/test/unit/features/debug.spec.ts
index 6e206c0d356..49398b4c1f7 100644
--- a/test/unit/features/debug.spec.ts
+++ b/test/unit/features/debug.spec.ts
@@ -20,7 +20,9 @@ describe('Debug utilities', () => {
     expect(formatComponentName(vm, false)).toBe('<SomeThing>')
 
     vm.$options.__file = 'C:\\foo\\bar\\baz\\windows_file.vue'
-    expect(formatComponentName(vm)).toBe(`<WindowsFile> at ${vm.$options.__file}`)
+    expect(formatComponentName(vm)).toBe(
+      `<WindowsFile> at ${vm.$options.__file}`
+    )
     expect(formatComponentName(vm, false)).toBe('<WindowsFile>')
   })
 
@@ -56,7 +58,7 @@ found in
     let i = 0
     const one = {
       name: 'one',
-      render: h => i++ < 5 ? h(one) : h(two)
+      render: h => (i++ < 5 ? h(one) : h(two))
     }
     const two = {
       name: 'two',
@@ -86,7 +88,7 @@ found in
     const vm = new Vue()
 
     it('calls warnHandler if warnHandler is set', () => {
-      const spy = Vue.config.warnHandler = vi.fn()
+      const spy = (Vue.config.warnHandler = vi.fn())
 
       warn(msg, vm)
 
diff --git a/test/unit/features/directives/bind.spec.ts b/test/unit/features/directives/bind.spec.ts
index 7e4827dc061..9adb72ff22a 100644
--- a/test/unit/features/directives/bind.spec.ts
+++ b/test/unit/features/directives/bind.spec.ts
@@ -11,18 +11,23 @@ describe('Directive v-bind', () => {
     waitForUpdate(() => {
       expect(vm.$el.firstChild.getAttribute('test')).toBe('again')
       vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('test')).toBe(false)
-      vm.foo = false
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('test')).toBe(false)
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('test')).toBe('true')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('test')).toBe('0')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.hasAttribute('test')).toBe(false)
+        vm.foo = false
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.hasAttribute('test')).toBe(false)
+        vm.foo = true
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttribute('test')).toBe('true')
+        vm.foo = 0
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttribute('test')).toBe('0')
+      })
+      .then(done)
   })
 
   it('should set property for input value', done => {
@@ -59,12 +64,17 @@ describe('Directive v-bind', () => {
     waitForUpdate(() => {
       expect(vm.$el.firstChild.getAttributeNS(xlinkNS, 'special')).toBe('again')
       vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttributeNS(xlinkNS, 'special')).toBe(false)
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttributeNS(xlinkNS, 'special')).toBe('true')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.hasAttributeNS(xlinkNS, 'special')).toBe(false)
+        vm.foo = true
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttributeNS(xlinkNS, 'special')).toBe(
+          'true'
+        )
+      })
+      .then(done)
   })
 
   it('enumerated attr', done => {
@@ -75,20 +85,27 @@ describe('Directive v-bind', () => {
     expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('true')
     vm.foo = 'plaintext-only' // allow special values
     waitForUpdate(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('plaintext-only')
+      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe(
+        'plaintext-only'
+      )
       vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
-      vm.foo = ''
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('true')
-      vm.foo = false
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
-      vm.foo = 'false'
-    }).then(() => {
-      expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
+        vm.foo = ''
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('true')
+        vm.foo = false
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
+        vm.foo = 'false'
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.getAttribute('contenteditable')).toBe('false')
+      })
+      .then(done)
   })
 
   it('boolean attr', done => {
@@ -101,17 +118,21 @@ describe('Directive v-bind', () => {
     waitForUpdate(() => {
       expect(vm.$el.firstChild.getAttribute('disabled')).toBe('disabled')
       vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('disabled')).toBe(false)
-      vm.foo = ''
-    }).then(() => {
-      expect(vm.$el.firstChild.hasAttribute('disabled')).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.hasAttribute('disabled')).toBe(false)
+        vm.foo = ''
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.hasAttribute('disabled')).toBe(true)
+      })
+      .then(done)
   })
 
   it('.prop modifier', () => {
     const vm = new Vue({
-      template: '<div><span v-bind:text-content.prop="foo"></span><span :inner-html.prop="bar"></span></div>',
+      template:
+        '<div><span v-bind:text-content.prop="foo"></span><span :inner-html.prop="bar"></span></div>',
       data: {
         foo: 'hello',
         bar: '<span>qux</span>'
@@ -136,7 +157,8 @@ describe('Directive v-bind', () => {
   if (process.env.VBIND_PROP_SHORTHAND) {
     it('.prop modifier shorthand', () => {
       const vm = new Vue({
-        template: '<div><span .text-content="foo"></span><span .inner-html="bar"></span></div>',
+        template:
+          '<div><span .text-content="foo"></span><span .inner-html="bar"></span></div>',
         data: {
           foo: 'hello',
           bar: '<span>qux</span>'
@@ -191,7 +213,7 @@ describe('Directive v-bind', () => {
           props: ['fooBar'],
           template: `<div>{{ fooBar }}</div>`,
           methods: {
-            update () {
+            update() {
               this.$emit('update:foo-bar', 2)
             }
           }
@@ -261,7 +283,7 @@ describe('Directive v-bind', () => {
           props: ['fooBar'],
           template: `<div @click="handleUpdate">{{ fooBar }}</div>`,
           methods: {
-            handleUpdate () {
+            handleUpdate() {
               this.$emit('update:fooBar', 2)
             }
           }
@@ -274,10 +296,12 @@ describe('Directive v-bind', () => {
     waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('2')
       vm.test.fooBar = 3
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('3')
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('3')
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('bind object with overwrite', done => {
@@ -357,10 +381,7 @@ describe('Directive v-bind', () => {
     const vm = new Vue({
       template: '<input v-bind="test">',
       data: {
-        test: [
-          { id: 'test', class: 'ok' },
-          { value: 'hello' }
-        ]
+        test: [{ id: 'test', class: 'ok' }, { value: 'hello' }]
       }
     }).$mount()
     expect(vm.$el.getAttribute('id')).toBe('test')
@@ -382,7 +403,9 @@ describe('Directive v-bind', () => {
         test: 1
       }
     }).$mount()
-    expect('v-bind without argument expects an Object or Array value').toHaveBeenWarned()
+    expect(
+      'v-bind without argument expects an Object or Array value'
+    ).toHaveBeenWarned()
   })
 
   it('set value for option element', () => {
@@ -420,7 +443,7 @@ describe('Directive v-bind', () => {
   })
 
   describe('bind object with special attribute', () => {
-    function makeInstance (options) {
+    function makeInstance(options) {
       return new Vue({
         template: `<div>${options.parentTemp}</div>`,
         data: {
@@ -491,13 +514,18 @@ describe('Directive v-bind', () => {
         expect(vm.$el.className).toBe('hello')
         // explicit null value
         vm.key = null
-      }).then(() => {
-        expect(vm.$el.className).toBe('')
-        expect(vm.$el.id).toBe('')
-        vm.key = undefined
-      }).then(() => {
-        expect(`Invalid value for dynamic directive argument`).toHaveBeenWarned()
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.className).toBe('')
+          expect(vm.$el.id).toBe('')
+          vm.key = undefined
+        })
+        .then(() => {
+          expect(
+            `Invalid value for dynamic directive argument`
+          ).toHaveBeenWarned()
+        })
+        .then(done)
     })
 
     it('shorthand', done => {
diff --git a/test/unit/features/directives/class.spec.ts b/test/unit/features/directives/class.spec.ts
index 1b50301a721..814ee8a2c70 100644
--- a/test/unit/features/directives/class.spec.ts
+++ b/test/unit/features/directives/class.spec.ts
@@ -1,69 +1,83 @@
 import Vue from 'vue'
 
-function assertClass (assertions, done) {
+function assertClass(assertions, done) {
   const vm = new Vue({
     template: '<div class="foo" :class="value"></div>',
     data: { value: '' }
   }).$mount()
   const chain = waitForUpdate()
   assertions.forEach(([value, expected], i) => {
-    chain.then(() => {
-      if (typeof value === 'function') {
-        value(vm.value)
-      } else {
-        vm.value = value
-      }
-    }).then(() => {
-      expect(vm.$el.className).toBe(expected)
-      // NOTE THIS WAS MAKING 
-      // if (i >= assertions.length - 1) {
-      //   done()
-      // }
-    })
+    chain
+      .then(() => {
+        if (typeof value === 'function') {
+          value(vm.value)
+        } else {
+          vm.value = value
+        }
+      })
+      .then(() => {
+        expect(vm.$el.className).toBe(expected)
+        // NOTE THIS WAS MAKING
+        // if (i >= assertions.length - 1) {
+        //   done()
+        // }
+      })
   })
   chain.then(done)
 }
 
 describe('Directive v-bind:class', () => {
   it('plain string', done => {
-    assertClass([
-      ['bar', 'foo bar'],
-      ['baz qux', 'foo baz qux'],
-      ['qux', 'foo qux'],
-      [undefined, 'foo']
-    ], done)
+    assertClass(
+      [
+        ['bar', 'foo bar'],
+        ['baz qux', 'foo baz qux'],
+        ['qux', 'foo qux'],
+        [undefined, 'foo']
+      ],
+      done
+    )
   })
 
   it('object value', done => {
-    assertClass([
-      [{ bar: true, baz: false }, 'foo bar'],
-      [{ baz: true }, 'foo baz'],
-      [null, 'foo'],
-      [{ 'bar baz': true, qux: false }, 'foo bar baz'],
-      [{ qux: true }, 'foo qux']
-    ], done)
+    assertClass(
+      [
+        [{ bar: true, baz: false }, 'foo bar'],
+        [{ baz: true }, 'foo baz'],
+        [null, 'foo'],
+        [{ 'bar baz': true, qux: false }, 'foo bar baz'],
+        [{ qux: true }, 'foo qux']
+      ],
+      done
+    )
   })
 
   it('array value', done => {
-    assertClass([
-      [['bar', 'baz'], 'foo bar baz'],
-      [['qux', 'baz'], 'foo qux baz'],
-      [['w', 'x y z'], 'foo w x y z'],
-      [undefined, 'foo'],
-      [['bar'], 'foo bar'],
-      [val => val.push('baz'), 'foo bar baz']
-    ], done)
+    assertClass(
+      [
+        [['bar', 'baz'], 'foo bar baz'],
+        [['qux', 'baz'], 'foo qux baz'],
+        [['w', 'x y z'], 'foo w x y z'],
+        [undefined, 'foo'],
+        [['bar'], 'foo bar'],
+        [val => val.push('baz'), 'foo bar baz']
+      ],
+      done
+    )
   })
 
   it('array of mixed values', done => {
-    assertClass([
-      [['x', { y: true, z: true }], 'foo x y z'],
-      [['x', { y: true, z: false }], 'foo x y'],
-      [['f', { z: true }], 'foo f z'],
-      [['l', 'f', { n: true, z: true }], 'foo l f n z'],
-      [['x', {}], 'foo x'],
-      [undefined, 'foo']
-    ], done)
+    assertClass(
+      [
+        [['x', { y: true, z: true }], 'foo x y z'],
+        [['x', { y: true, z: false }], 'foo x y'],
+        [['f', { z: true }], 'foo f z'],
+        [['l', 'f', { n: true, z: true }], 'foo l f n z'],
+        [['x', {}], 'foo x'],
+        [undefined, 'foo']
+      ],
+      done
+    )
   })
 
   it('class merge between parent and child', done => {
@@ -82,16 +96,21 @@ describe('Directive v-bind:class', () => {
     vm.value = 'e'
     waitForUpdate(() => {
       expect(vm.$el.className).toBe('c a d e')
-    }).then(() => {
-      child.value = 'f'
-    }).then(() => {
-      expect(vm.$el.className).toBe('c a f e')
-    }).then(() => {
-      vm.value = { foo: true }
-      child.value = ['bar', 'baz']
-    }).then(() => {
-      expect(vm.$el.className).toBe('c a bar baz foo')
-    }).then(done)
+    })
+      .then(() => {
+        child.value = 'f'
+      })
+      .then(() => {
+        expect(vm.$el.className).toBe('c a f e')
+      })
+      .then(() => {
+        vm.value = { foo: true }
+        child.value = ['bar', 'baz']
+      })
+      .then(() => {
+        expect(vm.$el.className).toBe('c a bar baz foo')
+      })
+      .then(done)
   })
 
   it('class merge between multiple nested components sharing same element', done => {
@@ -112,12 +131,12 @@ describe('Directive v-bind:class', () => {
       },
       components: {
         component1: {
-          render () {
+          render() {
             return this.$slots.default[0]
           }
         },
         component2: {
-          render () {
+          render() {
             return this.$slots.default[0]
           }
         },
@@ -126,17 +145,24 @@ describe('Directive v-bind:class', () => {
         }
       }
     }).$mount()
-    expect(vm.$el.className).toBe('staticClass componentClass3 componentClass2 componentClass1')
+    expect(vm.$el.className).toBe(
+      'staticClass componentClass3 componentClass2 componentClass1'
+    )
     vm.componentClass1 = 'c1'
     waitForUpdate(() => {
-      expect(vm.$el.className).toBe('staticClass componentClass3 componentClass2 c1')
+      expect(vm.$el.className).toBe(
+        'staticClass componentClass3 componentClass2 c1'
+      )
       vm.componentClass2 = 'c2'
-    }).then(() => {
-      expect(vm.$el.className).toBe('staticClass componentClass3 c2 c1')
-      vm.componentClass3 = 'c3'
-    }).then(() => {
-      expect(vm.$el.className).toBe('staticClass c3 c2 c1')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.className).toBe('staticClass componentClass3 c2 c1')
+        vm.componentClass3 = 'c3'
+      })
+      .then(() => {
+        expect(vm.$el.className).toBe('staticClass c3 c2 c1')
+      })
+      .then(done)
   })
 
   it('deep update', done => {
@@ -158,7 +184,8 @@ describe('Directive v-bind:class', () => {
   // and this could lead to useless spacing in static classes
   it('condenses whitespace in staticClass', done => {
     const vm = new Vue({
-      template: '<div class=" test1\ntest2\ttest3 test4   test5 \n \n \ntest6\t"></div>',
+      template:
+        '<div class=" test1\ntest2\ttest3 test4   test5 \n \n \ntest6\t"></div>'
     }).$mount()
     expect(vm.$el.className).toBe('test1 test2 test3 test4 test5 test6')
     done()
@@ -171,12 +198,12 @@ describe('Directive v-bind:class', () => {
         </component1>
       `,
       data: {
-        componentClass1: 'componentClass1',
+        componentClass1: 'componentClass1'
       },
       components: {
         component1: {
           template: '<div class="\n\t test \t\n"></div>'
-        },
+        }
       }
     }).$mount()
     expect(vm.$el.className).toBe('test staticClass componentClass1')
diff --git a/test/unit/features/directives/for.spec.ts b/test/unit/features/directives/for.spec.ts
index 9b4ffb22db2..7291bd5d264 100644
--- a/test/unit/features/directives/for.spec.ts
+++ b/test/unit/features/directives/for.spec.ts
@@ -2,7 +2,7 @@ import Vue from 'vue'
 import { hasSymbol } from 'core/util/env'
 
 describe('Directive v-for', () => {
-  it('should render array of primitive values', (done) => {
+  it('should render array of primitive values', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -37,7 +37,7 @@ describe('Directive v-for', () => {
       .then(done)
   })
 
-  it('should render array of primitive values with index', (done) => {
+  it('should render array of primitive values with index', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -74,7 +74,7 @@ describe('Directive v-for', () => {
       .then(done)
   })
 
-  it('should render array of object values', (done) => {
+  it('should render array of object values', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -115,7 +115,7 @@ describe('Directive v-for', () => {
       .then(done)
   })
 
-  it('should render array of object values with index', (done) => {
+  it('should render array of object values with index', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -184,7 +184,7 @@ describe('Directive v-for', () => {
       )
     })
 
-    it('should render iterable of primitive values', (done) => {
+    it('should render iterable of primitive values', done => {
       const iterable = {
         models: ['a', 'b', 'c'],
         index: 0,
@@ -239,7 +239,7 @@ describe('Directive v-for', () => {
         .then(done)
     })
 
-    it('should render iterable of primitive values with index', (done) => {
+    it('should render iterable of primitive values with index', done => {
       const iterable = {
         models: ['a', 'b', 'c'],
         index: 0,
@@ -295,7 +295,7 @@ describe('Directive v-for', () => {
         .then(done)
     })
 
-    it('should render iterable of object values', (done) => {
+    it('should render iterable of object values', done => {
       const iterable = {
         models: [{ value: 'a' }, { value: 'b' }, { value: 'c' }],
         index: 0,
@@ -357,7 +357,7 @@ describe('Directive v-for', () => {
         .then(done)
     })
 
-    it('should render iterable of object values with index', (done) => {
+    it('should render iterable of object values with index', done => {
       const iterable = {
         models: [{ value: 'a' }, { value: 'b' }, { value: 'c' }],
         index: 0,
@@ -420,7 +420,7 @@ describe('Directive v-for', () => {
     })
   }
 
-  it('should render an Object', (done) => {
+  it('should render an Object', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -453,7 +453,7 @@ describe('Directive v-for', () => {
       .then(done)
   })
 
-  it('should render an Object with key', (done) => {
+  it('should render an Object with key', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -488,7 +488,7 @@ describe('Directive v-for', () => {
       .then(done)
   })
 
-  it('should render an Object with key and index', (done) => {
+  it('should render an Object with key and index', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -523,7 +523,7 @@ describe('Directive v-for', () => {
       .then(done)
   })
 
-  it('should render each key of data', (done) => {
+  it('should render each key of data', done => {
     const vm = new Vue({
       template: `
         <div>
@@ -572,7 +572,7 @@ describe('Directive v-for', () => {
     expect(vm.$el.textContent).toBe('123')
   })
 
-  it('without key', (done) => {
+  it('without key', done => {
     const vm = new Vue({
       data: {
         items: [
@@ -593,7 +593,7 @@ describe('Directive v-for', () => {
     }).then(done)
   })
 
-  it('with key', (done) => {
+  it('with key', done => {
     const vm = new Vue({
       data: {
         items: [
@@ -637,7 +637,7 @@ describe('Directive v-for', () => {
     )
   })
 
-  it('template v-for', (done) => {
+  it('template v-for', done => {
     const vm = new Vue({
       data: {
         list: [{ a: 1 }, { a: 2 }, { a: 3 }]
@@ -672,7 +672,7 @@ describe('Directive v-for', () => {
     }
   })
 
-  it('component v-for', (done) => {
+  it('component v-for', done => {
     const vm = new Vue({
       data: {
         list: [{ a: 1 }, { a: 2 }, { a: 3 }]
@@ -712,7 +712,7 @@ describe('Directive v-for', () => {
     }
   })
 
-  it('dynamic component v-for', (done) => {
+  it('dynamic component v-for', done => {
     const vm = new Vue({
       data: {
         list: [{ type: 'one' }, { type: 'two' }]
@@ -751,7 +751,7 @@ describe('Directive v-for', () => {
     ).toHaveBeenTipped()
   })
 
-  it('multi nested array reactivity', (done) => {
+  it('multi nested array reactivity', done => {
     const vm = new Vue({
       data: {
         list: [[['foo']]]
@@ -775,7 +775,7 @@ describe('Directive v-for', () => {
     }).then(done)
   })
 
-  it('should work with strings', (done) => {
+  it('should work with strings', done => {
     const vm = new Vue({
       data: {
         text: 'foo'
@@ -814,7 +814,7 @@ describe('Directive v-for', () => {
   })
 
   // #9181
-  it('components with v-for and empty list', (done) => {
+  it('components with v-for and empty list', done => {
     const vm = new Vue({
       template:
         '<div attr>' +
@@ -836,7 +836,7 @@ describe('Directive v-for', () => {
     }).then(done)
   })
 
-  it('elements with v-for and empty list', (done) => {
+  it('elements with v-for and empty list', done => {
     const vm = new Vue({
       template:
         '<div attr>' + '<div v-for="item in list">{{ item }}</div>' + '</div>',
diff --git a/test/unit/features/directives/html.spec.ts b/test/unit/features/directives/html.spec.ts
index 5e67c815b2e..95b125f1188 100644
--- a/test/unit/features/directives/html.spec.ts
+++ b/test/unit/features/directives/html.spec.ts
@@ -39,35 +39,54 @@ describe('Directive v-html', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('false')
       vm.a = []
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('[]')
-      vm.a = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{}')
-      vm.a = { toString () { return 'foo' } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('foo')
-      vm.a = { toJSON () { return { foo: 'bar' } } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{\n  "foo": "bar"\n}')
-      vm.a = 123
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('123')
-      vm.a = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('0')
-      vm.a = ' '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(' ')
-      vm.a = '    '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('    ')
-      vm.a = null
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-      vm.a = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('[]')
+        vm.a = {}
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('{}')
+        vm.a = {
+          toString() {
+            return 'foo'
+          }
+        }
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('foo')
+        vm.a = {
+          toJSON() {
+            return { foo: 'bar' }
+          }
+        }
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('{\n  "foo": "bar"\n}')
+        vm.a = 123
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('123')
+        vm.a = 0
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('0')
+        vm.a = ' '
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(' ')
+        vm.a = '    '
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('    ')
+        vm.a = null
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('')
+        vm.a = undefined
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('')
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/features/directives/if.spec.ts b/test/unit/features/directives/if.spec.ts
index 17851d2d6b0..caaca63f3af 100644
--- a/test/unit/features/directives/if.spec.ts
+++ b/test/unit/features/directives/if.spec.ts
@@ -27,27 +27,35 @@ describe('Directive v-if', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('<!---->')
       vm.foo = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = []
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = '0'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-      vm.foo = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!---->')
-      vm.foo = 1
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>hello</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>hello</span>')
+        vm.foo = 0
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+        vm.foo = []
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>hello</span>')
+        vm.foo = null
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+        vm.foo = '0'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>hello</span>')
+        vm.foo = undefined
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!---->')
+        vm.foo = 1
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>hello</span>')
+      })
+      .then(done)
   })
 
   it('should work well with v-else', done => {
@@ -65,27 +73,35 @@ describe('Directive v-if', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
       vm.foo = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = []
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = '0'
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = 1
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
+        vm.foo = 0
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.foo = []
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
+        vm.foo = null
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.foo = '0'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
+        vm.foo = undefined
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.foo = 1
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
+      })
+      .then(done)
   })
 
   it('should work well with v-else-if', done => {
@@ -104,37 +120,48 @@ describe('Directive v-if', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
       vm.bar = true
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = false
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.foo = true
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
-      vm.foo = false
-      vm.bar = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = []
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = null
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = '0'
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-      vm.bar = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
-      vm.bar = 1
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
+        vm.bar = false
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.foo = true
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span>')
+        vm.foo = false
+        vm.bar = {}
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
+        vm.bar = 0
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.bar = []
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
+        vm.bar = null
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.bar = '0'
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
+        vm.bar = undefined
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span>')
+        vm.bar = 1
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe('<span>elseif</span>')
+      })
+      .then(done)
   })
 
   it('should work well with v-for', done => {
@@ -145,11 +172,7 @@ describe('Directive v-if', () => {
         </div>
       `,
       data: {
-        list: [
-          { value: true },
-          { value: false },
-          { value: true }
-        ]
+        list: [{ value: true }, { value: false }, { value: true }]
       }
     }).$mount()
     expect(vm.$el.innerHTML).toBe('<span>0</span><!----><span>2</span>')
@@ -157,12 +180,17 @@ describe('Directive v-if', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('<!----><!----><span>2</span>')
       vm.list.push({ value: true })
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!----><!----><span>2</span><span>3</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<!----><span>1</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<!----><!----><span>2</span><span>3</span>'
+        )
+        vm.list.splice(1, 2)
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<!----><span>1</span>')
+      })
+      .then(done)
   })
 
   it('should work well with v-for and v-else', done => {
@@ -174,24 +202,31 @@ describe('Directive v-if', () => {
         </div>
       `,
       data: {
-        list: [
-          { value: true },
-          { value: false },
-          { value: true }
-        ]
+        list: [{ value: true }, { value: false }, { value: true }]
       }
     }).$mount()
-    expect(vm.$el.innerHTML.trim()).toBe('<span>hello</span><span>bye</span><span>hello</span>')
+    expect(vm.$el.innerHTML.trim()).toBe(
+      '<span>hello</span><span>bye</span><span>hello</span>'
+    )
     vm.list[0].value = false
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span><span>bye</span><span>hello</span>')
+      expect(vm.$el.innerHTML.trim()).toBe(
+        '<span>bye</span><span>bye</span><span>hello</span>'
+      )
       vm.list.push({ value: true })
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span><span>bye</span><span>hello</span><span>hello</span>')
-      vm.list.splice(1, 2)
-    }).then(() => {
-      expect(vm.$el.innerHTML.trim()).toBe('<span>bye</span><span>hello</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe(
+          '<span>bye</span><span>bye</span><span>hello</span><span>hello</span>'
+        )
+        vm.list.splice(1, 2)
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML.trim()).toBe(
+          '<span>bye</span><span>hello</span>'
+        )
+      })
+      .then(done)
   })
 
   it('should work with v-for on v-else branch', done => {
@@ -222,7 +257,7 @@ describe('Directive v-if', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return { ok: true }
           },
           template: '<div v-if="ok" id="ok" class="inner">test</div>'
@@ -236,10 +271,12 @@ describe('Directive v-if', () => {
       // attrs / class modules should not attempt to patch the comment node
       expect(vm.$el.innerHTML).toBe('<!---->')
       vm.$children[0].ok = true
-    }).then(() => {
-      expect(vm.$el.children[0].id).toBe('ok')
-      expect(vm.$el.children[0].className).toBe('inner test')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.children[0].id).toBe('ok')
+        expect(vm.$el.children[0].className).toBe('inner test')
+      })
+      .then(done)
   })
 
   it('should maintain stable list to avoid unnecessary patches', done => {
diff --git a/test/unit/features/directives/model-checkbox.spec.ts b/test/unit/features/directives/model-checkbox.spec.ts
index 0d6ba2f7d15..212d03990df 100644
--- a/test/unit/features/directives/model-checkbox.spec.ts
+++ b/test/unit/features/directives/model-checkbox.spec.ts
@@ -17,9 +17,11 @@ describe('Directive v-model checkbox', () => {
       vm.$el.click()
       expect(vm.$el.checked).toBe(true)
       expect(vm.test).toBe(true)
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('should respect value bindings', done => {
@@ -29,7 +31,8 @@ describe('Directive v-model checkbox', () => {
         a: 1,
         b: 2
       },
-      template: '<input type="checkbox" v-model="test" :true-value="a" :false-value="b">'
+      template:
+        '<input type="checkbox" v-model="test" :true-value="a" :false-value="b">'
     }).$mount()
     document.body.appendChild(vm.$el)
     expect(vm.$el.checked).toBe(true)
@@ -43,10 +46,12 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.$el.checked).toBe(false)
       vm.test = 1
-    }).then(() => {
-      expect(vm.$el.checked).toBe(true)
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.checked).toBe(true)
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('bind to Array value', done => {
@@ -69,16 +74,20 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.test.length).toBe(0)
       vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2'])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2', '1'])
-      vm.test = ['1']
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.test).toEqual(['2'])
+        vm.$el.children[0].click()
+      })
+      .then(() => {
+        expect(vm.test).toEqual(['2', '1'])
+        vm.test = ['1']
+      })
+      .then(() => {
+        expect(vm.$el.children[0].checked).toBe(true)
+        expect(vm.$el.children[1].checked).toBe(false)
+      })
+      .then(done)
   })
 
   it('bind to Array value ignores false-value', done => {
@@ -100,16 +109,20 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.test.length).toBe(0)
       vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2'])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual(['2', '1'])
-      vm.test = ['1']
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.test).toEqual(['2'])
+        vm.$el.children[0].click()
+      })
+      .then(() => {
+        expect(vm.test).toEqual(['2', '1'])
+        vm.test = ['1']
+      })
+      .then(() => {
+        expect(vm.$el.children[0].checked).toBe(true)
+        expect(vm.$el.children[1].checked).toBe(false)
+      })
+      .then(done)
   })
 
   it('bind to Array value with value bindings', done => {
@@ -131,16 +144,20 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.test.length).toBe(0)
       vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual([2])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual([2, 1])
-      vm.test = [1]
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.test).toEqual([2])
+        vm.$el.children[0].click()
+      })
+      .then(() => {
+        expect(vm.test).toEqual([2, 1])
+        vm.test = [1]
+      })
+      .then(() => {
+        expect(vm.$el.children[0].checked).toBe(true)
+        expect(vm.$el.children[1].checked).toBe(false)
+      })
+      .then(done)
   })
 
   it('bind to Array value with value bindings (object loose equal)', done => {
@@ -162,16 +179,20 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.test.length).toBe(0)
       vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual([{ a: 2 }])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual([{ a: 2 }, { a: 1 }])
-      vm.test = [{ a: 1 }]
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.test).toEqual([{ a: 2 }])
+        vm.$el.children[0].click()
+      })
+      .then(() => {
+        expect(vm.test).toEqual([{ a: 2 }, { a: 1 }])
+        vm.test = [{ a: 1 }]
+      })
+      .then(() => {
+        expect(vm.$el.children[0].checked).toBe(true)
+        expect(vm.$el.children[1].checked).toBe(false)
+      })
+      .then(done)
   })
 
   it('bind to Array value with array value bindings (object loose equal)', done => {
@@ -193,16 +214,20 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.test.length).toBe(0)
       vm.$el.children[1].click()
-    }).then(() => {
-      expect(vm.test).toEqual([[2]])
-      vm.$el.children[0].click()
-    }).then(() => {
-      expect(vm.test).toEqual([[2], { a: 1 }])
-      vm.test = [{ a: 1 }]
-    }).then(() => {
-      expect(vm.$el.children[0].checked).toBe(true)
-      expect(vm.$el.children[1].checked).toBe(false)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.test).toEqual([[2]])
+        vm.$el.children[0].click()
+      })
+      .then(() => {
+        expect(vm.test).toEqual([[2], { a: 1 }])
+        vm.test = [{ a: 1 }]
+      })
+      .then(() => {
+        expect(vm.$el.children[0].checked).toBe(true)
+        expect(vm.$el.children[1].checked).toBe(false)
+      })
+      .then(done)
   })
 
   it('.number modifier', () => {
@@ -231,18 +256,18 @@ describe('Directive v-model checkbox', () => {
     expect(vm.check).toEqual(false)
   })
 
-  it('should respect different primitive type value', (done) => {
+  it('should respect different primitive type value', done => {
     const vm = new Vue({
       data: {
         test: [0]
       },
       template:
         '<div>' +
-          '<input type="checkbox" value="" v-model="test">' +
-          '<input type="checkbox" value="0" v-model="test">' +
-          '<input type="checkbox" value="1" v-model="test">' +
-          '<input type="checkbox" value="false" v-model="test">' +
-          '<input type="checkbox" value="true" v-model="test">' +
+        '<input type="checkbox" value="" v-model="test">' +
+        '<input type="checkbox" value="0" v-model="test">' +
+        '<input type="checkbox" value="1" v-model="test">' +
+        '<input type="checkbox" value="false" v-model="test">' +
+        '<input type="checkbox" value="true" v-model="test">' +
         '</div>'
     }).$mount()
     const checkboxInput = vm.$el.children
@@ -259,44 +284,50 @@ describe('Directive v-model checkbox', () => {
       expect(checkboxInput[3].checked).toBe(false)
       expect(checkboxInput[4].checked).toBe(false)
       vm.test = ['']
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(true)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(false)
-      expect(checkboxInput[3].checked).toBe(false)
-      expect(checkboxInput[4].checked).toBe(false)
-      vm.test = [false]
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(false)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(false)
-      expect(checkboxInput[3].checked).toBe(true)
-      expect(checkboxInput[4].checked).toBe(false)
-      vm.test = [true]
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(false)
-      expect(checkboxInput[1].checked).toBe(false)
-      expect(checkboxInput[2].checked).toBe(false)
-      expect(checkboxInput[3].checked).toBe(false)
-      expect(checkboxInput[4].checked).toBe(true)
-      vm.test = ['', 0, 1, false, true]
-    }).then(() => {
-      expect(checkboxInput[0].checked).toBe(true)
-      expect(checkboxInput[1].checked).toBe(true)
-      expect(checkboxInput[2].checked).toBe(true)
-      expect(checkboxInput[3].checked).toBe(true)
-      expect(checkboxInput[4].checked).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(checkboxInput[0].checked).toBe(true)
+        expect(checkboxInput[1].checked).toBe(false)
+        expect(checkboxInput[2].checked).toBe(false)
+        expect(checkboxInput[3].checked).toBe(false)
+        expect(checkboxInput[4].checked).toBe(false)
+        vm.test = [false]
+      })
+      .then(() => {
+        expect(checkboxInput[0].checked).toBe(false)
+        expect(checkboxInput[1].checked).toBe(false)
+        expect(checkboxInput[2].checked).toBe(false)
+        expect(checkboxInput[3].checked).toBe(true)
+        expect(checkboxInput[4].checked).toBe(false)
+        vm.test = [true]
+      })
+      .then(() => {
+        expect(checkboxInput[0].checked).toBe(false)
+        expect(checkboxInput[1].checked).toBe(false)
+        expect(checkboxInput[2].checked).toBe(false)
+        expect(checkboxInput[3].checked).toBe(false)
+        expect(checkboxInput[4].checked).toBe(true)
+        vm.test = ['', 0, 1, false, true]
+      })
+      .then(() => {
+        expect(checkboxInput[0].checked).toBe(true)
+        expect(checkboxInput[1].checked).toBe(true)
+        expect(checkboxInput[2].checked).toBe(true)
+        expect(checkboxInput[3].checked).toBe(true)
+        expect(checkboxInput[4].checked).toBe(true)
+      })
+      .then(done)
   })
 
   // #4521
-  it('should work with click event', (done) => {
+  it('should work with click event', done => {
     const vm = new Vue({
       data: {
         num: 1,
         checked: false
       },
-      template: '<div @click="add">click {{ num }}<input ref="checkbox" type="checkbox" v-model="checked"/></div>',
+      template:
+        '<div @click="add">click {{ num }}<input ref="checkbox" type="checkbox" v-model="checked"/></div>',
       methods: {
         add: function () {
           this.num++
@@ -312,7 +343,7 @@ describe('Directive v-model checkbox', () => {
     }).then(done)
   })
 
-  it('should get updated with model when in focus', (done) => {
+  it('should get updated with model when in focus', done => {
     const vm = new Vue({
       data: {
         a: 2
@@ -324,9 +355,11 @@ describe('Directive v-model checkbox', () => {
     waitForUpdate(() => {
       expect(vm.$el.checked).toBe(false)
       vm.a = 2
-    }).then(() => {
-      expect(vm.$el.checked).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.checked).toBe(true)
+      })
+      .then(done)
   })
 
   it('triggers a watcher when binding to an array value in a checkbox', done => {
diff --git a/test/unit/features/directives/model-component.spec.ts b/test/unit/features/directives/model-component.spec.ts
index 52ccc9ad751..412278bc366 100644
--- a/test/unit/features/directives/model-component.spec.ts
+++ b/test/unit/features/directives/model-component.spec.ts
@@ -24,16 +24,20 @@ describe('Directive v-model component', () => {
       const input = vm.$el.querySelector('input')
       input.value = 'world'
       triggerEvent(input, 'input')
-    }).then(() => {
-      expect(vm.msg).toEqual('world')
-      expect(vm.$el.querySelector('p').textContent).toEqual('world')
-      vm.msg = 'changed'
-    }).then(() => {
-      expect(vm.$el.querySelector('p').textContent).toEqual('changed')
-      expect(vm.$el.querySelector('input').value).toEqual('changed')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.msg).toEqual('world')
+        expect(vm.$el.querySelector('p').textContent).toEqual('world')
+        vm.msg = 'changed'
+      })
+      .then(() => {
+        expect(vm.$el.querySelector('p').textContent).toEqual('changed')
+        expect(vm.$el.querySelector('input').value).toEqual('changed')
+      })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('should work with native tags with "is"', done => {
@@ -59,16 +63,20 @@ describe('Directive v-model component', () => {
       const input = vm.$el.querySelector('input')
       input.value = 'world'
       triggerEvent(input, 'input')
-    }).then(() => {
-      expect(vm.msg).toEqual('world')
-      expect(vm.$el.querySelector('p').textContent).toEqual('world')
-      vm.msg = 'changed'
-    }).then(() => {
-      expect(vm.$el.querySelector('p').textContent).toEqual('changed')
-      expect(vm.$el.querySelector('input').value).toEqual('changed')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.msg).toEqual('world')
+        expect(vm.$el.querySelector('p').textContent).toEqual('world')
+        vm.msg = 'changed'
+      })
+      .then(() => {
+        expect(vm.$el.querySelector('p').textContent).toEqual('changed')
+        expect(vm.$el.querySelector('input').value).toEqual('changed')
+      })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('should support customization via model option', done => {
@@ -102,17 +110,21 @@ describe('Directive v-model component', () => {
       const input = vm.$el.querySelector('input')
       input.value = 'world'
       triggerEvent(input, 'input')
-    }).then(() => {
-      expect(vm.msg).toEqual('world')
-      expect(vm.$el.querySelector('p').textContent).toEqual('world')
-      expect(spy).toHaveBeenCalledWith('world')
-      vm.msg = 'changed'
-    }).then(() => {
-      expect(vm.$el.querySelector('p').textContent).toEqual('changed')
-      expect(vm.$el.querySelector('input').value).toEqual('changed')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.msg).toEqual('world')
+        expect(vm.$el.querySelector('p').textContent).toEqual('world')
+        expect(spy).toHaveBeenCalledWith('world')
+        vm.msg = 'changed'
+      })
+      .then(() => {
+        expect(vm.$el.querySelector('p').textContent).toEqual('changed')
+        expect(vm.$el.querySelector('input').value).toEqual('changed')
+      })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('modifier: .number', () => {
@@ -153,7 +165,7 @@ describe('Directive v-model component', () => {
   it('should not double transform mode props', () => {
     const BaseInput = {
       props: ['value'],
-      render (h) {
+      render(h) {
         return h('input', {
           domProps: {
             value: this.value
@@ -167,7 +179,7 @@ describe('Directive v-model component', () => {
 
     const FunctionalWrapper = {
       functional: true,
-      render (h, ctx) {
+      render(h, ctx) {
         return h(BaseInput, ctx.data)
       }
     }
@@ -188,10 +200,10 @@ describe('Directive v-model component', () => {
       },
       computed: {
         val: {
-          get () {
+          get() {
             return this.internalVal
           },
-          set (val) {
+          set(val) {
             triggerCount++
             this.internalVal = val
           }
@@ -209,7 +221,7 @@ describe('Directive v-model component', () => {
   it('should add value to $attrs if not defined in props', () => {
     const TestComponent = {
       inheritAttrs: false,
-      render (h) {
+      render(h) {
         return h('div', this.$attrs.value)
       }
     }
@@ -228,6 +240,6 @@ describe('Directive v-model component', () => {
       }
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe('<div>foo</div>');
+    expect(vm.$el.innerHTML).toBe('<div>foo</div>')
   })
 })
diff --git a/test/unit/features/directives/model-dynamic.spec.ts b/test/unit/features/directives/model-dynamic.spec.ts
index 88a910fedfa..b50a519f905 100644
--- a/test/unit/features/directives/model-dynamic.spec.ts
+++ b/test/unit/features/directives/model-dynamic.spec.ts
@@ -26,16 +26,19 @@ describe('Directive v-model dynamic input type', () => {
     }).$mount()
     document.body.appendChild(vm.$el)
 
-    const chain = assertInputWorks(vm).then(() => {
-      vm.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('haha')
-    }).then(() => {
-      // reset
-      vm.ok = true
-      vm.type = null
-      vm.test = 'b'
-    })
+    const chain = assertInputWorks(vm)
+      .then(() => {
+        vm.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('haha')
+      })
+      .then(() => {
+        // reset
+        vm.ok = true
+        vm.type = null
+        vm.test = 'b'
+      })
 
     assertInputWorks(vm, chain).then(done)
   })
@@ -71,13 +74,16 @@ describe('Directive v-model dynamic input type', () => {
 
     const chain = waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('text')
-    }).then(() => {
-      vm.foo = false
-    }).then(() => {
-      expect(vm._vnode.isComment).toBe(true)
-    }).then(() => {
-      vm.bar = true
     })
+      .then(() => {
+        vm.foo = false
+      })
+      .then(() => {
+        expect(vm._vnode.isComment).toBe(true)
+      })
+      .then(() => {
+        vm.bar = true
+      })
 
     assertInputWorks(vm, chain).then(done)
   })
@@ -135,7 +141,10 @@ describe('Directive v-model dynamic input type', () => {
           text: 'foo',
           checkbox: true
         },
-        inputs: [{ id: 'one', type: 'text' }, { id: 'two', type: 'checkbox' }]
+        inputs: [
+          { id: 'one', type: 'text' },
+          { id: 'two', type: 'checkbox' }
+        ]
       },
       template: `<div>
         <input v-for="i in inputs" v-bind="i" v-model="data[i.type]">
@@ -179,40 +188,47 @@ describe('Directive v-model dynamic input type', () => {
   })
 })
 
-function assertInputWorks (vm, type, chain) {
+function assertInputWorks(vm, type, chain) {
   if (typeof type !== 'string') {
     if (!chain) chain = type
     type = 'type'
   }
   if (!chain) chain = waitForUpdate()
-  chain.then(() => {
-    expect(vm.$el.value).toBe('b')
-    vm.test = 'a'
-  }).then(() => {
-    expect(vm.$el.value).toBe('a')
-    vm.$el.value = 'c'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('c')
-  }).then(() => {
-    // change it to password
-    vm[type] = 'password'
-    vm.test = 'b'
-  }).then(() => {
-    expect(vm.$el.type).toBe('password')
-    expect(vm.$el.value).toBe('b')
-    vm.$el.value = 'c'
-    triggerEvent(vm.$el, 'input')
-    expect(vm.test).toBe('c')
-  }).then(() => {
-    // change it to checkbox...
-    vm[type] = 'checkbox'
-  }).then(() => {
-    expect(vm.$el.type).toBe('checkbox')
-    expect(vm.$el.checked).toBe(true)
-  }).then(() => {
-    vm.$el.click()
-    expect(vm.$el.checked).toBe(false)
-    expect(vm.test).toBe(false)
-  })
+  chain
+    .then(() => {
+      expect(vm.$el.value).toBe('b')
+      vm.test = 'a'
+    })
+    .then(() => {
+      expect(vm.$el.value).toBe('a')
+      vm.$el.value = 'c'
+      triggerEvent(vm.$el, 'input')
+      expect(vm.test).toBe('c')
+    })
+    .then(() => {
+      // change it to password
+      vm[type] = 'password'
+      vm.test = 'b'
+    })
+    .then(() => {
+      expect(vm.$el.type).toBe('password')
+      expect(vm.$el.value).toBe('b')
+      vm.$el.value = 'c'
+      triggerEvent(vm.$el, 'input')
+      expect(vm.test).toBe('c')
+    })
+    .then(() => {
+      // change it to checkbox...
+      vm[type] = 'checkbox'
+    })
+    .then(() => {
+      expect(vm.$el.type).toBe('checkbox')
+      expect(vm.$el.checked).toBe(true)
+    })
+    .then(() => {
+      vm.$el.click()
+      expect(vm.$el.checked).toBe(false)
+      expect(vm.test).toBe(false)
+    })
   return chain
 }
diff --git a/test/unit/features/directives/model-radio.spec.ts b/test/unit/features/directives/model-radio.spec.ts
index 9c5198e5ef4..f36167a7a7f 100644
--- a/test/unit/features/directives/model-radio.spec.ts
+++ b/test/unit/features/directives/model-radio.spec.ts
@@ -24,9 +24,11 @@ describe('Directive v-model radio', () => {
       expect(vm.$el.children[0].checked).toBe(true)
       expect(vm.$el.children[1].checked).toBe(false)
       expect(vm.test).toBe('1')
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('should respect value bindings', done => {
@@ -52,9 +54,11 @@ describe('Directive v-model radio', () => {
       expect(vm.$el.children[0].checked).toBe(true)
       expect(vm.$el.children[1].checked).toBe(false)
       expect(vm.test).toBe(1)
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
   it('should respect value bindings (object loose equal)', done => {
@@ -80,12 +84,14 @@ describe('Directive v-model radio', () => {
       expect(vm.$el.children[0].checked).toBe(true)
       expect(vm.$el.children[1].checked).toBe(false)
       expect(vm.test).toEqual({ a: 1 })
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-    }).then(done)
+    })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+      })
+      .then(done)
   })
 
-  it('multiple radios ', (done) => {
+  it('multiple radios ', done => {
     const spy = vi.fn()
     const vm = new Vue({
       data: {
@@ -106,14 +112,14 @@ describe('Directive v-model radio', () => {
       },
       template:
         '<div>' +
-          '<div v-for="(radioGroup, idx) in radioList">' +
-            '<div>' +
-              '<span v-for="(item, index) in radioGroup.data">' +
-                '<input :name="radioGroup.name" type="radio" :value="item" v-model="selections[idx]" :id="idx"/>' +
-                '<label>{{item}}</label>' +
-              '</span>' +
-            '</div>' +
-          '</div>' +
+        '<div v-for="(radioGroup, idx) in radioList">' +
+        '<div>' +
+        '<span v-for="(item, index) in radioGroup.data">' +
+        '<input :name="radioGroup.name" type="radio" :value="item" v-model="selections[idx]" :id="idx"/>' +
+        '<label>{{item}}</label>' +
+        '</span>' +
+        '</div>' +
+        '</div>' +
         '</div>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -146,18 +152,18 @@ describe('Directive v-model radio', () => {
     expect(vm.test).toBe(2)
   })
 
-  it('should respect different primitive type value', (done) => {
+  it('should respect different primitive type value', done => {
     const vm = new Vue({
       data: {
         test: 1
       },
       template:
         '<div>' +
-          '<input type="radio" value="" v-model="test" name="test">' +
-          '<input type="radio" value="0" v-model="test" name="test">' +
-          '<input type="radio" value="1" v-model="test" name="test">' +
-          '<input type="radio" value="false" v-model="test" name="test">' +
-          '<input type="radio" value="true" v-model="test" name="test">' +
+        '<input type="radio" value="" v-model="test" name="test">' +
+        '<input type="radio" value="0" v-model="test" name="test">' +
+        '<input type="radio" value="1" v-model="test" name="test">' +
+        '<input type="radio" value="false" v-model="test" name="test">' +
+        '<input type="radio" value="true" v-model="test" name="test">' +
         '</div>'
     }).$mount()
     const radioboxInput = vm.$el.children
@@ -174,31 +180,35 @@ describe('Directive v-model radio', () => {
       expect(radioboxInput[3].checked).toBe(false)
       expect(radioboxInput[4].checked).toBe(false)
       vm.test = ''
-    }).then(() => {
-      expect(radioboxInput[0].checked).toBe(true)
-      expect(radioboxInput[1].checked).toBe(false)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(false)
-      expect(radioboxInput[4].checked).toBe(false)
-      vm.test = false
-    }).then(() => {
-      expect(radioboxInput[0].checked).toBe(false)
-      expect(radioboxInput[1].checked).toBe(false)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(true)
-      expect(radioboxInput[4].checked).toBe(false)
-      vm.test = true
-    }).then(() => {
-      expect(radioboxInput[0].checked).toBe(false)
-      expect(radioboxInput[1].checked).toBe(false)
-      expect(radioboxInput[2].checked).toBe(false)
-      expect(radioboxInput[3].checked).toBe(false)
-      expect(radioboxInput[4].checked).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(radioboxInput[0].checked).toBe(true)
+        expect(radioboxInput[1].checked).toBe(false)
+        expect(radioboxInput[2].checked).toBe(false)
+        expect(radioboxInput[3].checked).toBe(false)
+        expect(radioboxInput[4].checked).toBe(false)
+        vm.test = false
+      })
+      .then(() => {
+        expect(radioboxInput[0].checked).toBe(false)
+        expect(radioboxInput[1].checked).toBe(false)
+        expect(radioboxInput[2].checked).toBe(false)
+        expect(radioboxInput[3].checked).toBe(true)
+        expect(radioboxInput[4].checked).toBe(false)
+        vm.test = true
+      })
+      .then(() => {
+        expect(radioboxInput[0].checked).toBe(false)
+        expect(radioboxInput[1].checked).toBe(false)
+        expect(radioboxInput[2].checked).toBe(false)
+        expect(radioboxInput[3].checked).toBe(false)
+        expect(radioboxInput[4].checked).toBe(true)
+      })
+      .then(done)
   })
 
   // #4521
-  it('should work with click event', (done) => {
+  it('should work with click event', done => {
     const vm = new Vue({
       data: {
         num: 1,
@@ -206,8 +216,8 @@ describe('Directive v-model radio', () => {
       },
       template:
         '<div @click="add">' +
-          'click {{ num }}<input name="test" type="radio" value="1" v-model="checked"/>' +
-          '<input name="test" type="radio" value="2" v-model="checked"/>' +
+        'click {{ num }}<input name="test" type="radio" value="1" v-model="checked"/>' +
+        '<input name="test" type="radio" value="2" v-model="checked"/>' +
         '</div>',
       methods: {
         add: function () {
@@ -223,19 +233,22 @@ describe('Directive v-model radio', () => {
       expect(radios[1].checked).toBe(false)
       expect(vm.num).toBe(2)
       radios[0].click()
-    }).then(() => {
-      expect(radios[0].checked).toBe(true)
-      expect(radios[1].checked).toBe(false)
-      expect(vm.num).toBe(3)
-      radios[1].click()
-    }).then(() => {
-      expect(radios[0].checked).toBe(false)
-      expect(radios[1].checked).toBe(true)
-      expect(vm.num).toBe(4)
-    }).then(done)
+    })
+      .then(() => {
+        expect(radios[0].checked).toBe(true)
+        expect(radios[1].checked).toBe(false)
+        expect(vm.num).toBe(3)
+        radios[1].click()
+      })
+      .then(() => {
+        expect(radios[0].checked).toBe(false)
+        expect(radios[1].checked).toBe(true)
+        expect(vm.num).toBe(4)
+      })
+      .then(done)
   })
 
-  it('should get updated with model when in focus', (done) => {
+  it('should get updated with model when in focus', done => {
     const vm = new Vue({
       data: {
         a: '2'
@@ -247,8 +260,10 @@ describe('Directive v-model radio', () => {
     waitForUpdate(() => {
       expect(vm.$el.checked).toBe(true)
       vm.a = 2
-    }).then(() => {
-      expect(vm.$el.checked).toBe(false)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.checked).toBe(false)
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/features/directives/model-select.spec.ts b/test/unit/features/directives/model-select.spec.ts
index ba8439344ec..6b9b682f7c9 100644
--- a/test/unit/features/directives/model-select.spec.ts
+++ b/test/unit/features/directives/model-select.spec.ts
@@ -3,7 +3,7 @@ import { looseEqual } from 'shared/util'
 
 // Android 4.4 Chrome 30 has the bug that a multi-select option cannot be
 // deselected by setting its "selected" prop via JavaScript.
-function hasMultiSelectBug () {
+function hasMultiSelectBug() {
   const s = document.createElement('select')
   s.setAttribute('multiple', '')
   const o = document.createElement('option')
@@ -17,7 +17,7 @@ function hasMultiSelectBug () {
  * setting <select>'s value in IE9 doesn't work
  * we have to manually loop through the options
  */
-function updateSelect (el, value) {
+function updateSelect(el, value) {
   const options = el.options
   let i = options.length
   while (i--) {
@@ -28,10 +28,8 @@ function updateSelect (el, value) {
   }
 }
 
-function getValue (option) {
-  return '_value' in option
-    ? option._value
-    : option.value || option.text
+function getValue(option) {
+  return '_value' in option ? option._value : option.value || option.text
 }
 
 describe('Directive v-model select', () => {
@@ -42,9 +40,9 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option>a</option>' +
-          '<option>b</option>' +
-          '<option>c</option>' +
+        '<option>a</option>' +
+        '<option>b</option>' +
+        '<option>c</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -68,9 +66,9 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="2">b</option>' +
-          '<option :value="3">c</option>' +
+        '<option value="1">a</option>' +
+        '<option :value="2">b</option>' +
+        '<option :value="3">c</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -98,9 +96,9 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="{ a: 2 }">b</option>' +
-          '<option :value="{ a: 3 }">c</option>' +
+        '<option value="1">a</option>' +
+        '<option :value="{ a: 2 }">b</option>' +
+        '<option :value="{ a: 3 }">c</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -126,9 +124,9 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="[{ a: 2 }]">b</option>' +
-          '<option :value="[{ a: 3 }]">c</option>' +
+        '<option value="1">a</option>' +
+        '<option :value="[{ a: 2 }]">b</option>' +
+        '<option :value="[{ a: 3 }]">c</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -155,7 +153,7 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option v-for="o in opts">{{ o }}</option>' +
+        '<option v-for="o in opts">{{ o }}</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -171,10 +169,12 @@ describe('Directive v-model select', () => {
       expect(vm.test).toBe('a')
       // update v-for opts
       vm.opts = ['d', 'a']
-    }).then(() => {
-      expect(vm.$el.childNodes[0].selected).toBe(false)
-      expect(vm.$el.childNodes[1].selected).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.childNodes[0].selected).toBe(false)
+        expect(vm.$el.childNodes[1].selected).toBe(true)
+      })
+      .then(done)
   })
 
   it('should work with v-for & value bindings', done => {
@@ -185,7 +185,7 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option v-for="o in opts" :value="o">option {{ o }}</option>' +
+        '<option v-for="o in opts" :value="o">option {{ o }}</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -200,13 +200,15 @@ describe('Directive v-model select', () => {
       expect(vm.test).toBe(1)
       // update v-for opts
       vm.opts = [0, 1]
-    }).then(() => {
-      expect(vm.$el.childNodes[0].selected).toBe(false)
-      expect(vm.$el.childNodes[1].selected).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.childNodes[0].selected).toBe(false)
+        expect(vm.$el.childNodes[1].selected).toBe(true)
+      })
+      .then(done)
   })
 
-  it('should work with select which has no default selected options', (done) => {
+  it('should work with select which has no default selected options', done => {
     const spy = vi.fn()
     const vm = new Vue({
       data: {
@@ -216,10 +218,10 @@ describe('Directive v-model select', () => {
       },
       template:
         '<div>' +
-          '<select @change="test" v-model="id">' +
-            '<option v-for="item in list" :value="item">{{item}}</option>' +
-          '</select>' +
-          '{{testChange}}' +
+        '<select @change="test" v-model="id">' +
+        '<option v-for="item in list" :value="item">{{item}}</option>' +
+        '</select>' +
+        '{{testChange}}' +
         '</div>',
       methods: {
         test: spy
@@ -240,9 +242,9 @@ describe('Directive v-model select', () => {
         },
         template:
           '<select v-model="test" multiple>' +
-            '<option>a</option>' +
-            '<option>b</option>' +
-            '<option>c</option>' +
+          '<option>a</option>' +
+          '<option>b</option>' +
+          '<option>c</option>' +
           '</select>'
       }).$mount()
       const opts = vm.$el.options
@@ -269,7 +271,7 @@ describe('Directive v-model select', () => {
         },
         template:
           '<select v-model="test" multiple>' +
-            '<option v-for="o in opts">{{ o }}</option>' +
+          '<option v-for="o in opts">{{ o }}</option>' +
           '</select>'
       }).$mount()
       const opts = vm.$el.options
@@ -287,15 +289,17 @@ describe('Directive v-model select', () => {
         expect(vm.test).toEqual(['b', 'c'])
         // update v-for opts
         vm.opts = ['c', 'd']
-      }).then(() => {
-        expect(opts[0].selected).toBe(true)
-        expect(opts[1].selected).toBe(false)
-        expect(vm.test).toEqual(['c']) // should remove 'd' which no longer has a matching option
-      }).then(done)
+      })
+        .then(() => {
+          expect(opts[0].selected).toBe(true)
+          expect(opts[1].selected).toBe(false)
+          expect(vm.test).toEqual(['c']) // should remove 'd' which no longer has a matching option
+        })
+        .then(done)
     })
   }
 
-  it('should work with multiple binding', (done) => {
+  it('should work with multiple binding', done => {
     const spy = vi.fn()
     const vm = new Vue({
       data: {
@@ -304,8 +308,8 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="selections" :multiple="isMultiple">' +
-          '<option value="1">item 1</option>' +
-          '<option value="2">item 2</option>' +
+        '<option value="1">item 1</option>' +
+        '<option value="2">item 2</option>' +
         '</select>',
       watch: {
         selections: spy
@@ -320,14 +324,14 @@ describe('Directive v-model select', () => {
     }).then(done)
   })
 
-  it('should not have multiple attr with falsy values except \'\'', () => {
+  it("should not have multiple attr with falsy values except ''", () => {
     const vm = new Vue({
       template:
         '<div>' +
-          '<select id="undefined" :multiple="undefined"></select>' +
-          '<select id="null" :multiple="null"></select>' +
-          '<select id="false" :multiple="false"></select>' +
-          '<select id="string" :multiple="\'\'"></select>' +
+        '<select id="undefined" :multiple="undefined"></select>' +
+        '<select id="null" :multiple="null"></select>' +
+        '<select id="false" :multiple="false"></select>' +
+        '<select id="string" :multiple="\'\'"></select>' +
         '</div>'
     }).$mount()
     expect(vm.$el.querySelector('#undefined').multiple).toEqual(false)
@@ -339,11 +343,11 @@ describe('Directive v-model select', () => {
   it('multiple with static template', () => {
     const vm = new Vue({
       template:
-      '<select multiple>' +
+        '<select multiple>' +
         '<option selected>a</option>' +
         '<option selected>b</option>' +
         '<option selected>c</option>' +
-      '</select>'
+        '</select>'
     }).$mount()
     const opts = vm.$el.options
     expect(opts[0].selected).toBe(true)
@@ -351,7 +355,7 @@ describe('Directive v-model select', () => {
     expect(opts[2].selected).toBe(true)
   })
 
-  it('multiple selects', (done) => {
+  it('multiple selects', done => {
     const spy = vi.fn()
     const vm = new Vue({
       data: {
@@ -372,10 +376,10 @@ describe('Directive v-model select', () => {
       },
       template:
         '<div>' +
-          '<select v-for="(item, index) in selectBoxes" v-model="selections[index]">' +
-            '<option v-for="element in item" v-bind:value="element.value" v-text="element.text"></option>' +
-          '</select>' +
-          '<span ref="rs">{{selections}}</span>' +
+        '<select v-for="(item, index) in selectBoxes" v-model="selections[index]">' +
+        '<option v-for="element in item" v-bind:value="element.value" v-text="element.text"></option>' +
+        '</select>' +
+        '<span ref="rs">{{selections}}</span>' +
         '</div>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -396,9 +400,9 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model.number="test">' +
-          '<option value="1">a</option>' +
-          '<option :value="2">b</option>' +
-          '<option :value="3">c</option>' +
+        '<option value="1">a</option>' +
+        '<option :value="2">b</option>' +
+        '<option :value="3">c</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -407,18 +411,18 @@ describe('Directive v-model select', () => {
     expect(vm.test).toBe(1)
   })
 
-  it('should respect different primitive type value', (done) => {
+  it('should respect different primitive type value', done => {
     const vm = new Vue({
       data: {
         test: 0
       },
       template:
         '<select v-model.number="test">' +
-          '<option value="">a</option>' +
-          '<option value="0">b</option>' +
-          '<option value="1">c</option>' +
-          '<option value="false">c</option>' +
-          '<option value="true">c</option>' +
+        '<option value="">a</option>' +
+        '<option value="0">b</option>' +
+        '<option value="1">c</option>' +
+        '<option value="false">c</option>' +
+        '<option value="true">c</option>' +
         '</select>'
     }).$mount()
     const opts = vm.$el.options
@@ -435,27 +439,31 @@ describe('Directive v-model select', () => {
       expect(opts[3].selected).toBe(false)
       expect(opts[4].selected).toBe(false)
       vm.test = ''
-    }).then(() => {
-      expect(opts[0].selected).toBe(true)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(false)
-      expect(opts[3].selected).toBe(false)
-      expect(opts[4].selected).toBe(false)
-      vm.test = false
-    }).then(() => {
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(false)
-      expect(opts[3].selected).toBe(true)
-      expect(opts[4].selected).toBe(false)
-      vm.test = true
-    }).then(() => {
-      expect(opts[0].selected).toBe(false)
-      expect(opts[1].selected).toBe(false)
-      expect(opts[2].selected).toBe(false)
-      expect(opts[3].selected).toBe(false)
-      expect(opts[4].selected).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(opts[0].selected).toBe(true)
+        expect(opts[1].selected).toBe(false)
+        expect(opts[2].selected).toBe(false)
+        expect(opts[3].selected).toBe(false)
+        expect(opts[4].selected).toBe(false)
+        vm.test = false
+      })
+      .then(() => {
+        expect(opts[0].selected).toBe(false)
+        expect(opts[1].selected).toBe(false)
+        expect(opts[2].selected).toBe(false)
+        expect(opts[3].selected).toBe(true)
+        expect(opts[4].selected).toBe(false)
+        vm.test = true
+      })
+      .then(() => {
+        expect(opts[0].selected).toBe(false)
+        expect(opts[1].selected).toBe(false)
+        expect(opts[2].selected).toBe(false)
+        expect(opts[3].selected).toBe(false)
+        expect(opts[4].selected).toBe(true)
+      })
+      .then(done)
   })
 
   it('should warn multiple with non-Array value', done => {
@@ -463,13 +471,13 @@ describe('Directive v-model select', () => {
       data: {
         test: 'meh'
       },
-      template:
-        '<select v-model="test" multiple></select>'
+      template: '<select v-model="test" multiple></select>'
     }).$mount()
     // IE warns on a setTimeout as well
     setTimeout(() => {
-      expect('<select multiple v-model="test"> expects an Array value for its binding, but got String')
-        .toHaveBeenWarned()
+      expect(
+        '<select multiple v-model="test"> expects an Array value for its binding, but got String'
+      ).toHaveBeenWarned()
       done()
     }, 0)
   })
@@ -485,9 +493,9 @@ describe('Directive v-model select', () => {
       },
       template:
         '<select v-model="test">' +
-          '<option :value="circular">a</option>' +
-          '<option>b</option>' +
-          '<option>c</option>' +
+        '<option :value="circular">a</option>' +
+        '<option>b</option>' +
+        '<option>c</option>' +
         '</select>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -506,10 +514,7 @@ describe('Directive v-model select', () => {
       data: {
         test: '1'
       },
-      template:
-        '<select v-model="test">' +
-          '<option>a</option>' +
-        '</select>'
+      template: '<select v-model="test">' + '<option>a</option>' + '</select>'
     }).$mount()
 
     vm.test = '2'
@@ -527,17 +532,17 @@ describe('Directive v-model select', () => {
       },
       computed: {
         test: {
-          get () {
+          get() {
             return '1'
           },
-          set () {
+          set() {
             spy()
           }
         }
       },
       template:
         '<select v-model="test">' +
-          '<option :key="opt" v-for="opt in options" :value="opt">{{ opt }}</option>' +
+        '<option :key="opt" v-for="opt in options" :value="opt">{{ opt }}</option>' +
         '</select>'
     }).$mount()
 
@@ -549,7 +554,7 @@ describe('Directive v-model select', () => {
 
   // #6903
   describe('should correctly handle v-model when the vnodes are the same', () => {
-    function makeInstance (foo) {
+    function makeInstance(foo) {
       return new Vue({
         data: {
           foo: foo,
@@ -558,12 +563,12 @@ describe('Directive v-model select', () => {
         },
         template:
           '<div>' +
-            '<select v-if="foo" data-attr>' +
-              '<option selected>a</option>' +
-            '</select>' +
-            '<select v-else v-model="value">' +
-              '<option v-for="option in options" :value="option">{{ option }}</option>' +
-            '</select>' +
+          '<select v-if="foo" data-attr>' +
+          '<option selected>a</option>' +
+          '</select>' +
+          '<select v-else v-model="value">' +
+          '<option v-for="option in options" :value="option">{{ option }}</option>' +
+          '</select>' +
           '</div>'
       }).$mount()
     }
@@ -602,11 +607,11 @@ describe('Directive v-model select', () => {
       },
       template:
         '<div>' +
-          '<select v-model="selectedDate">' +
-            '<option v-for="(date, i) in dates" :key="i" :value="date">' +
-              '{{date}}' +
-            '</option>' +
-          '</select>' +
+        '<select v-model="selectedDate">' +
+        '<option v-for="(date, i) in dates" :key="i" :value="date">' +
+        '{{date}}' +
+        '</option>' +
+        '</select>' +
         '</div>'
     }).$mount()
 
diff --git a/test/unit/features/directives/model-text.spec.ts b/test/unit/features/directives/model-text.spec.ts
index 9b0a7445831..467fd3c585c 100644
--- a/test/unit/features/directives/model-text.spec.ts
+++ b/test/unit/features/directives/model-text.spec.ts
@@ -80,7 +80,7 @@ describe('Directive v-model text', () => {
     expect(vm.test).toBe('what')
   })
 
-  it('.number focus and typing', (done) => {
+  it('.number focus and typing', done => {
     const vm = new Vue({
       data: {
         test: 0,
@@ -88,8 +88,8 @@ describe('Directive v-model text', () => {
       },
       template:
         '<div>' +
-          '<input ref="input" v-model.number="test">{{ update }}' +
-          '<input ref="blur">' +
+        '<input ref="input" v-model.number="test">{{ update }}' +
+        '<input ref="blur">' +
         '</div>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -103,12 +103,14 @@ describe('Directive v-model text', () => {
       expect(vm.$refs.input.value).toBe('1.0')
       vm.$refs.blur.focus()
       vm.update++
-    }).then(() => {
-      expect(vm.$refs.input.value).toBe('1')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$refs.input.value).toBe('1')
+      })
+      .then(done)
   })
 
-  it('.trim focus and typing', (done) => {
+  it('.trim focus and typing', done => {
     const vm = new Vue({
       data: {
         test: 'abc',
@@ -116,8 +118,8 @@ describe('Directive v-model text', () => {
       },
       template:
         '<div>' +
-          '<input ref="input" v-model.trim="test" type="text">{{ update }}' +
-          '<input ref="blur"/>' +
+        '<input ref="input" v-model.trim="test" type="text">{{ update }}' +
+        '<input ref="blur"/>' +
         '</div>'
     }).$mount()
     document.body.appendChild(vm.$el)
@@ -130,16 +132,21 @@ describe('Directive v-model text', () => {
       expect(vm.$refs.input.value).toBe(' abc ')
       vm.$refs.blur.focus()
       vm.update++
-    }).then(() => {
-      expect(vm.$refs.input.value).toBe('abc')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$refs.input.value).toBe('abc')
+      })
+      .then(done)
   })
 
-  it('multiple inputs', (done) => {
+  it('multiple inputs', done => {
     const spy = vi.fn()
     const vm = new Vue({
       data: {
-        selections: [[1, 2, 3], [4, 5]],
+        selections: [
+          [1, 2, 3],
+          [4, 5]
+        ],
         inputList: [
           {
             name: 'questionA',
@@ -156,15 +163,15 @@ describe('Directive v-model text', () => {
       },
       template:
         '<div>' +
-          '<div v-for="(inputGroup, idx) in inputList">' +
-            '<div>' +
-              '<span v-for="(item, index) in inputGroup.data">' +
-                '<input v-bind:name="item" type="text" v-model.number="selections[idx][index]" v-bind:id="idx+\'-\'+index"/>' +
-                '<label>{{item}}</label>' +
-              '</span>' +
-            '</div>' +
-          '</div>' +
-          '<span ref="rs">{{selections}}</span>' +
+        '<div v-for="(inputGroup, idx) in inputList">' +
+        '<div>' +
+        '<span v-for="(item, index) in inputGroup.data">' +
+        '<input v-bind:name="item" type="text" v-model.number="selections[idx][index]" v-bind:id="idx+\'-\'+index"/>' +
+        '<label>{{item}}</label>' +
+        '</span>' +
+        '</div>' +
+        '</div>' +
+        '<span ref="rs">{{selections}}</span>' +
         '</div>'
     }).$mount()
     const inputs = vm.$el.getElementsByTagName('input')
@@ -172,7 +179,10 @@ describe('Directive v-model text', () => {
     triggerEvent(inputs[1], 'input')
     waitForUpdate(() => {
       expect(spy).toHaveBeenCalled()
-      expect(vm.selections).toEqual([[1, 'test', 3], [4, 5]])
+      expect(vm.selections).toEqual([
+        [1, 'test', 3],
+        [4, 5]
+      ])
     }).then(done)
   })
 
@@ -225,7 +235,9 @@ describe('Directive v-model text', () => {
       },
       template: '<div v-model="test"></div>'
     }).$mount()
-    expect('<div v-model="test">: v-model is not supported on this element type').toHaveBeenWarned()
+    expect(
+      '<div v-model="test">: v-model is not supported on this element type'
+    ).toHaveBeenWarned()
   })
 
   // #3468
@@ -237,7 +249,7 @@ describe('Directive v-model text', () => {
       },
       template: '<input v-model="a" @input="onInput">',
       methods: {
-        onInput (e) {
+        onInput(e) {
           spy(this.a)
         }
       }
@@ -260,7 +272,9 @@ describe('Directive v-model text', () => {
         </div>
       `
     }).$mount()
-    expect('You are binding v-model directly to a v-for iteration alias').toHaveBeenWarned()
+    expect(
+      'You are binding v-model directly to a v-for iteration alias'
+    ).toHaveBeenWarned()
   })
 
   it('warn if v-model and v-bind:value conflict', () => {
@@ -324,7 +338,7 @@ describe('Directive v-model text', () => {
         },
         template: '<input v-model="a" @input="onInput">',
         methods: {
-          onInput (e) {
+          onInput(e) {
             spy(e.target.value)
           }
         }
@@ -345,7 +359,7 @@ describe('Directive v-model text', () => {
         },
         template: '<input v-model="a" @input="onInput">',
         methods: {
-          onInput (e) {
+          onInput(e) {
             spy(e.target.value)
           }
         }
@@ -395,7 +409,7 @@ describe('Directive v-model text', () => {
           </div>
         `,
         methods: {
-          onInput (e) {
+          onInput(e) {
             this.foo = true
           }
         }
@@ -431,9 +445,11 @@ describe('Directive v-model text', () => {
       waitForUpdate(() => {
         expect(vm.$el.value).toBe('b')
         vm.foo = {}
-      }).then(() => {
-        expect(vm.$el.value).toBe('')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.value).toBe('')
+        })
+        .then(done)
     })
   }
 
@@ -460,7 +476,7 @@ describe('Directive v-model text', () => {
       const vm = new Vue({
         el,
         data: { evtCount: 0 },
-        template: `<textarea placeholder="" @input="evtCount++"></textarea>`,
+        template: `<textarea placeholder="" @input="evtCount++"></textarea>`
       })
       triggerEvent(vm.$el, 'input')
       setTimeout(() => {
diff --git a/test/unit/features/directives/on.spec.ts b/test/unit/features/directives/on.spec.ts
index 12c6bb5cc63..e103301471e 100644
--- a/test/unit/features/directives/on.spec.ts
+++ b/test/unit/features/directives/on.spec.ts
@@ -28,7 +28,7 @@ describe('Directive v-on', () => {
     expect(spy.mock.calls.length).toBe(1)
 
     const args = spy.mock.calls
-    const event = args[0] && args[0][0] || {}
+    const event = (args[0] && args[0][0]) || {}
     expect(event.type).toBe('click')
   })
 
@@ -93,7 +93,7 @@ describe('Directive v-on', () => {
         <input type="checkbox" ref="input" @click.prevent="foo">
       `,
       methods: {
-        foo ($event) {
+        foo($event) {
           spy($event.defaultPrevented)
         }
       }
@@ -113,8 +113,12 @@ describe('Directive v-on', () => {
         </div>
       `,
       methods: {
-        foo () { callOrder.push(1) },
-        bar () { callOrder.push(2) }
+        foo() {
+          callOrder.push(1)
+        },
+        bar() {
+          callOrder.push(2)
+        }
       }
     })
     triggerEvent(vm.$el.firstChild, 'click')
@@ -169,8 +173,12 @@ describe('Directive v-on', () => {
         </div>
       `,
       methods: {
-        foo () { callOrder.push(1) },
-        bar () { callOrder.push(2) }
+        foo() {
+          callOrder.push(1)
+        },
+        bar() {
+          callOrder.push(2)
+        }
       }
     })
     triggerEvent(vm.$el.firstChild, 'click')
@@ -235,22 +243,30 @@ describe('Directive v-on', () => {
 
     triggerEvent(vm.$refs.ctrl, 'keyup')
     expect(spy.mock.calls.length).toBe(0)
-    triggerEvent(vm.$refs.ctrl, 'keyup', e => { e.ctrlKey = true })
+    triggerEvent(vm.$refs.ctrl, 'keyup', e => {
+      e.ctrlKey = true
+    })
     expect(spy.mock.calls.length).toBe(1)
 
     triggerEvent(vm.$refs.shift, 'keyup')
     expect(spy.mock.calls.length).toBe(1)
-    triggerEvent(vm.$refs.shift, 'keyup', e => { e.shiftKey = true })
+    triggerEvent(vm.$refs.shift, 'keyup', e => {
+      e.shiftKey = true
+    })
     expect(spy.mock.calls.length).toBe(2)
 
     triggerEvent(vm.$refs.alt, 'keyup')
     expect(spy.mock.calls.length).toBe(2)
-    triggerEvent(vm.$refs.alt, 'keyup', e => { e.altKey = true })
+    triggerEvent(vm.$refs.alt, 'keyup', e => {
+      e.altKey = true
+    })
     expect(spy.mock.calls.length).toBe(3)
 
     triggerEvent(vm.$refs.meta, 'keyup')
     expect(spy.mock.calls.length).toBe(3)
-    triggerEvent(vm.$refs.meta, 'keyup', e => { e.metaKey = true })
+    triggerEvent(vm.$refs.meta, 'keyup', e => {
+      e.metaKey = true
+    })
     expect(spy.mock.calls.length).toBe(4)
   })
 
@@ -344,22 +360,40 @@ describe('Directive v-on', () => {
       }
     })
 
-    triggerEvent(vm.$refs.left, 'mousedown', e => { e.button = right })
-    triggerEvent(vm.$refs.left, 'mousedown', e => { e.button = middle })
+    triggerEvent(vm.$refs.left, 'mousedown', e => {
+      e.button = right
+    })
+    triggerEvent(vm.$refs.left, 'mousedown', e => {
+      e.button = middle
+    })
     expect(spyLeft).not.toHaveBeenCalled()
-    triggerEvent(vm.$refs.left, 'mousedown', e => { e.button = left })
+    triggerEvent(vm.$refs.left, 'mousedown', e => {
+      e.button = left
+    })
     expect(spyLeft).toHaveBeenCalled()
 
-    triggerEvent(vm.$refs.right, 'mousedown', e => { e.button = left })
-    triggerEvent(vm.$refs.right, 'mousedown', e => { e.button = middle })
+    triggerEvent(vm.$refs.right, 'mousedown', e => {
+      e.button = left
+    })
+    triggerEvent(vm.$refs.right, 'mousedown', e => {
+      e.button = middle
+    })
     expect(spyRight).not.toHaveBeenCalled()
-    triggerEvent(vm.$refs.right, 'mousedown', e => { e.button = right })
+    triggerEvent(vm.$refs.right, 'mousedown', e => {
+      e.button = right
+    })
     expect(spyRight).toHaveBeenCalled()
 
-    triggerEvent(vm.$refs.middle, 'mousedown', e => { e.button = left })
-    triggerEvent(vm.$refs.middle, 'mousedown', e => { e.button = right })
+    triggerEvent(vm.$refs.middle, 'mousedown', e => {
+      e.button = left
+    })
+    triggerEvent(vm.$refs.middle, 'mousedown', e => {
+      e.button = right
+    })
     expect(spyMiddle).not.toHaveBeenCalled()
-    triggerEvent(vm.$refs.middle, 'mousedown', e => { e.button = middle })
+    triggerEvent(vm.$refs.middle, 'mousedown', e => {
+      e.button = middle
+    })
     expect(spyMiddle).toHaveBeenCalled()
   })
 
@@ -378,17 +412,29 @@ describe('Directive v-on', () => {
       methods: { foo: spy }
     })
 
-    triggerEvent(vm.$refs.enter, 'keyup', e => { e.key = 'Enter' })
+    triggerEvent(vm.$refs.enter, 'keyup', e => {
+      e.key = 'Enter'
+    })
     expect(spy.mock.calls.length).toBe(1)
-    triggerEvent(vm.$refs.space, 'keyup', e => { e.key = ' ' })
+    triggerEvent(vm.$refs.space, 'keyup', e => {
+      e.key = ' '
+    })
     expect(spy.mock.calls.length).toBe(2)
-    triggerEvent(vm.$refs.esc, 'keyup', e => { e.key = 'Escape' })
+    triggerEvent(vm.$refs.esc, 'keyup', e => {
+      e.key = 'Escape'
+    })
     expect(spy.mock.calls.length).toBe(3)
-    triggerEvent(vm.$refs.left, 'keyup', e => { e.key = 'ArrowLeft' })
+    triggerEvent(vm.$refs.left, 'keyup', e => {
+      e.key = 'ArrowLeft'
+    })
     expect(spy.mock.calls.length).toBe(4)
-    triggerEvent(vm.$refs.delete, 'keyup', e => { e.key = 'Backspace' })
+    triggerEvent(vm.$refs.delete, 'keyup', e => {
+      e.key = 'Backspace'
+    })
     expect(spy.mock.calls.length).toBe(5)
-    triggerEvent(vm.$refs.delete, 'keyup', e => { e.key = 'Delete' })
+    triggerEvent(vm.$refs.delete, 'keyup', e => {
+      e.key = 'Delete'
+    })
     expect(spy.mock.calls.length).toBe(6)
   })
 
@@ -467,11 +513,13 @@ describe('Directive v-on', () => {
       template: `
         <button @click.native="foo"></button>
       `,
-      methods: { foo: spy },
+      methods: { foo: spy }
     })
 
     triggerEvent(vm.$el, 'click')
-    expect(`The .native modifier for v-on is only valid on components but it was used on <button>.`).toHaveBeenWarned()
+    expect(
+      `The .native modifier for v-on is only valid on components but it was used on <button>.`
+    ).toHaveBeenWarned()
     expect(spy.mock.calls.length).toBe(0)
   })
 
@@ -481,12 +529,14 @@ describe('Directive v-on', () => {
       template: `
         <component is="div" @click.native="foo('native')" @click="foo('regular')"/>
       `,
-      methods: { foo: spy },
+      methods: { foo: spy }
     })
 
     triggerEvent(vm.$el, 'click')
-    expect(`The .native modifier for v-on is only valid on components but it was used on <div>.`).not.toHaveBeenWarned()
-    expect(spy.mock.calls).toEqual([['regular']]); // Regular @click should work for dynamic components resolved to native HTML elements.
+    expect(
+      `The .native modifier for v-on is only valid on components but it was used on <div>.`
+    ).not.toHaveBeenWarned()
+    expect(spy.mock.calls).toEqual([['regular']]) // Regular @click should work for dynamic components resolved to native HTML elements.
   })
 
   it('.once modifier should work with child components', () => {
@@ -514,10 +564,10 @@ describe('Directive v-on', () => {
       data: {
         ok: true
       },
-      render (h) {
+      render(h) {
         return this.ok
-          ? h('input', { on: { click: this.foo }})
-          : h('input', { on: { input: this.bar }})
+          ? h('input', { on: { click: this.foo } })
+          : h('input', { on: { input: this.bar } })
       }
     })
     triggerEvent(vm.$el, 'click')
@@ -536,14 +586,22 @@ describe('Directive v-on', () => {
     const spy2 = vi.fn()
     vm = new Vue({
       el,
-      methods: { foo: spy, bar: spy2, stopped (ev) { ev.stopPropagation() } },
+      methods: {
+        foo: spy,
+        bar: spy2,
+        stopped(ev) {
+          ev.stopPropagation()
+        }
+      },
       data: {
         ok: true
       },
-      render (h) {
+      render(h) {
         return this.ok
-          ? h('div', { on: { '!click': this.foo }}, [h('div', { on: { click: this.stopped }})])
-          : h('div', { on: { mouseOver: this.bar }}, [h('div')])
+          ? h('div', { on: { '!click': this.foo } }, [
+              h('div', { on: { click: this.stopped } })
+            ])
+          : h('div', { on: { mouseOver: this.bar } }, [h('div')])
       }
     })
     triggerEvent(vm.$el.firstChild, 'click')
@@ -566,10 +624,10 @@ describe('Directive v-on', () => {
       data: {
         ok: true
       },
-      render (h) {
+      render(h) {
         return this.ok
-          ? h('input', { on: { '~click': this.foo }})
-          : h('input', { on: { input: this.bar }})
+          ? h('input', { on: { '~click': this.foo } })
+          : h('input', { on: { input: this.bar } })
       }
     })
     triggerEvent(vm.$el, 'click')
@@ -590,14 +648,22 @@ describe('Directive v-on', () => {
     const spy2 = vi.fn()
     vm = new Vue({
       el,
-      methods: { foo: spy, bar: spy2, stopped (ev) { ev.stopPropagation() } },
+      methods: {
+        foo: spy,
+        bar: spy2,
+        stopped(ev) {
+          ev.stopPropagation()
+        }
+      },
       data: {
         ok: true
       },
-      render (h) {
+      render(h) {
         return this.ok
-          ? h('div', { on: { '~!click': this.foo }}, [h('div', { on: { click: this.stopped }})])
-          : h('div', { on: { mouseOver: this.bar }}, [h('div')])
+          ? h('div', { on: { '~!click': this.foo } }, [
+              h('div', { on: { click: this.stopped } })
+            ])
+          : h('div', { on: { mouseOver: this.bar } }, [h('div')])
       }
     })
     triggerEvent(vm.$el.firstChild, 'click')
@@ -627,10 +693,10 @@ describe('Directive v-on', () => {
           template: '<div></div>'
         }
       },
-      render (h) {
+      render(h) {
         return this.ok
-          ? h('test', { on: { foo: this.foo }})
-          : h('test', { on: { bar: this.bar }})
+          ? h('test', { on: { foo: this.foo } })
+          : h('test', { on: { bar: this.bar } })
       }
     })
     vm.$children[0].$emit('foo')
@@ -680,17 +746,33 @@ describe('Directive v-on', () => {
         foo3: spyDown
       }
     })
-    triggerEvent(vm.$refs.left, 'keydown', e => { e.keyCode = 37 })
-    triggerEvent(vm.$refs.left, 'keydown', e => { e.keyCode = 39 })
+    triggerEvent(vm.$refs.left, 'keydown', e => {
+      e.keyCode = 37
+    })
+    triggerEvent(vm.$refs.left, 'keydown', e => {
+      e.keyCode = 39
+    })
 
-    triggerEvent(vm.$refs.right, 'keydown', e => { e.keyCode = 39 })
-    triggerEvent(vm.$refs.right, 'keydown', e => { e.keyCode = 38 })
+    triggerEvent(vm.$refs.right, 'keydown', e => {
+      e.keyCode = 39
+    })
+    triggerEvent(vm.$refs.right, 'keydown', e => {
+      e.keyCode = 38
+    })
 
-    triggerEvent(vm.$refs.up, 'keydown', e => { e.keyCode = 38 })
-    triggerEvent(vm.$refs.up, 'keydown', e => { e.keyCode = 37 })
+    triggerEvent(vm.$refs.up, 'keydown', e => {
+      e.keyCode = 38
+    })
+    triggerEvent(vm.$refs.up, 'keydown', e => {
+      e.keyCode = 37
+    })
 
-    triggerEvent(vm.$refs.down, 'keydown', e => { e.keyCode = 40 })
-    triggerEvent(vm.$refs.down, 'keydown', e => { e.keyCode = 39 })
+    triggerEvent(vm.$refs.down, 'keydown', e => {
+      e.keyCode = 40
+    })
+    triggerEvent(vm.$refs.down, 'keydown', e => {
+      e.keyCode = 39
+    })
 
     expect(spyLeft.mock.calls.length).toBe(1)
     expect(spyRight.mock.calls.length).toBe(1)
@@ -711,7 +793,7 @@ describe('Directive v-on', () => {
           </div>
         `,
         methods: {
-          foo (e) {
+          foo(e) {
             e.preventDefault()
           }
         }
@@ -726,7 +808,9 @@ describe('Directive v-on', () => {
       expect(vm.$refs.normal.checked).toBe(false)
       expect(vm.$refs.passive.checked).toBe(true)
       expect(vm.$refs.exclusive.checked).toBe(true)
-      expect('passive and prevent can\'t be used together. Passive handler can\'t prevent default event.').toHaveBeenWarned()
+      expect(
+        "passive and prevent can't be used together. Passive handler can't prevent default event."
+      ).toHaveBeenWarned()
     })
   }
 
@@ -739,15 +823,19 @@ describe('Directive v-on', () => {
         <input ref="input" @keydown.enter.prevent="foo">
       `,
       methods: {
-        foo ($event) {
+        foo($event) {
           prevented = $event.defaultPrevented
         }
       }
     })
 
-    triggerEvent(vm.$refs.input, 'keydown', e => { e.keyCode = 32 })
+    triggerEvent(vm.$refs.input, 'keydown', e => {
+      e.keyCode = 32
+    })
     expect(prevented).toBe(false)
-    triggerEvent(vm.$refs.input, 'keydown', e => { e.keyCode = 13 })
+    triggerEvent(vm.$refs.input, 'keydown', e => {
+      e.keyCode = 13
+    })
     expect(prevented).toBe(true)
   })
 
@@ -769,9 +857,13 @@ describe('Directive v-on', () => {
       template: `<div @click.middle="foo"></div>`,
       methods: { foo: spy }
     })
-    triggerEvent(vm.$el, 'mouseup', e => { e.button = 0 })
+    triggerEvent(vm.$el, 'mouseup', e => {
+      e.button = 0
+    })
     expect(spy).not.toHaveBeenCalled()
-    triggerEvent(vm.$el, 'mouseup', e => { e.button = 1 })
+    triggerEvent(vm.$el, 'mouseup', e => {
+      e.button = 1
+    })
     expect(spy).toHaveBeenCalled()
   })
 
@@ -781,7 +873,7 @@ describe('Directive v-on', () => {
     vm = new Vue({
       el,
       template: `<button v-on="listeners">foo</button>`,
-      created () {
+      created() {
         this.listeners = {
           click,
           mouseup
@@ -805,7 +897,7 @@ describe('Directive v-on', () => {
     vm = new Vue({
       el,
       template: `<button v-on="listeners" @click="click2">foo</button>`,
-      created () {
+      created() {
         this.listeners = {
           click: click1,
           mouseup
@@ -880,10 +972,10 @@ describe('Directive v-on', () => {
       },
       computed: {
         model: {
-          get () {
+          get() {
             return this.value
           },
-          set (val) {
+          set(val) {
             this.$emit('input', val)
           }
         }
@@ -902,7 +994,7 @@ describe('Directive v-on', () => {
         check: false
       },
       methods: {
-        change () {
+        change() {
           expect(this.check).toBe(true)
           done()
         }
@@ -916,7 +1008,9 @@ describe('Directive v-on', () => {
     new Vue({
       template: `<button v-on.self="{}"></button>`
     }).$mount()
-    expect(`v-on without argument does not support modifiers`).toHaveBeenWarned()
+    expect(
+      `v-on without argument does not support modifiers`
+    ).toHaveBeenWarned()
   })
 
   it('warn object syntax with non-object value', () => {
@@ -1010,12 +1104,14 @@ describe('Directive v-on', () => {
         expect(spy.mock.calls.length).toBe(2)
         // explicit null value
         vm.key = null
-      }).then(() => {
-        triggerEvent(vm.$el, 'click')
-        expect(spy.mock.calls.length).toBe(2)
-        triggerEvent(vm.$el, 'mouseup')
-        expect(spy.mock.calls.length).toBe(2)
-      }).then(done)
+      })
+        .then(() => {
+          triggerEvent(vm.$el, 'click')
+          expect(spy.mock.calls.length).toBe(2)
+          triggerEvent(vm.$el, 'mouseup')
+          expect(spy.mock.calls.length).toBe(2)
+        })
+        .then(done)
     })
 
     it('shorthand', done => {
@@ -1051,9 +1147,13 @@ describe('Directive v-on', () => {
           spy
         }
       }).$mount()
-      triggerEvent(vm.$el, 'mouseup', e => { e.button = 0 })
+      triggerEvent(vm.$el, 'mouseup', e => {
+        e.button = 0
+      })
       expect(spy).not.toHaveBeenCalled()
-      triggerEvent(vm.$el, 'mouseup', e => { e.button = 1 })
+      triggerEvent(vm.$el, 'mouseup', e => {
+        e.button = 1
+      })
       expect(spy).toHaveBeenCalled()
     })
 
@@ -1084,8 +1184,12 @@ describe('Directive v-on', () => {
           key: 'click'
         },
         methods: {
-          foo () { callOrder.push(1) },
-          bar () { callOrder.push(2) }
+          foo() {
+            callOrder.push(1)
+          },
+          bar() {
+            callOrder.push(2)
+          }
         }
       }).$mount()
       triggerEvent(vm.$el.firstChild, 'click')
diff --git a/test/unit/features/directives/once.spec.ts b/test/unit/features/directives/once.spec.ts
index eca8be0a3ef..732a440bf6e 100644
--- a/test/unit/features/directives/once.spec.ts
+++ b/test/unit/features/directives/once.spec.ts
@@ -29,12 +29,10 @@ describe('Directive v-once', () => {
       }
     }).$mount()
     expect(vm.$children.length).toBe(1)
-    expect(vm.$el.innerHTML)
-      .toBe('<span>hello</span> <div>hello</div>')
+    expect(vm.$el.innerHTML).toBe('<span>hello</span> <div>hello</div>')
     vm.a = 'world'
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>hello</span> <div>hello</div>')
+      expect(vm.$el.innerHTML).toBe('<span>hello</span> <div>hello</div>')
     }).then(done)
   })
 
@@ -54,12 +52,10 @@ describe('Directive v-once', () => {
       }
     }).$mount()
     expect(vm.$children.length).toBe(1)
-    expect(vm.$el.innerHTML)
-      .toBe('<span>hello</span> <div>hello</div>')
+    expect(vm.$el.innerHTML).toBe('<span>hello</span> <div>hello</div>')
     vm.a = 'world'
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>world</span> <div>hello</div>')
+      expect(vm.$el.innerHTML).toBe('<span>world</span> <div>hello</div>')
     }).then(done)
   })
 
@@ -82,17 +78,22 @@ describe('Directive v-once', () => {
         }
       }
     }).$mount()
-    expect(vm.$el.innerHTML)
-      .toBe('<span>hello</span> <div>hello</div> <span>?</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>hello</span> <div>hello</div> <span>?</span>'
+    )
     vm.a = 'world'
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>hello</span> <div>world</div> <span>?</span>')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>hello</span> <div>world</div> <span>?</span>'
+      )
       vm.suffix = '!'
-    }).then(() => {
-      expect(vm.$el.innerHTML)
-        .toBe('<span>hello</span> <div>world</div> <span>!</span>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>hello</span> <div>world</div> <span>!</span>'
+        )
+      })
+      .then(done)
   })
 
   it('should work with v-if', done => {
@@ -120,12 +121,15 @@ describe('Directive v-once', () => {
     waitForUpdate(() => {
       expectTextContent(vm, 'yesyyesy')
       vm.tester = false
-    }).then(() => {
-      expectTextContent(vm, 'nnnn')
-      vm.no = 'no'
-    }).then(() => {
-      expectTextContent(vm, 'nononn')
-    }).then(done)
+    })
+      .then(() => {
+        expectTextContent(vm, 'nnnn')
+        vm.no = 'no'
+      })
+      .then(() => {
+        expectTextContent(vm, 'nononn')
+      })
+      .then(done)
   })
 
   it('should work with v-for', done => {
@@ -168,20 +172,21 @@ describe('Directive v-once', () => {
     waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('adbbcc')
       vm.list[1].text = 'e'
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('adbecc')
-      vm.list.reverse()
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('ccbead')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('adbecc')
+        vm.list.reverse()
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('ccbead')
+      })
+      .then(done)
   })
 
   it('should work inside v-for with v-if', done => {
     const vm = new Vue({
       data: {
-        list: [
-          { id: 0, text: 'a', tester: true, truthy: 'y' }
-        ]
+        list: [{ id: 0, text: 'a', tester: true, truthy: 'y' }]
       },
       template: `
         <div>
@@ -205,12 +210,15 @@ describe('Directive v-once', () => {
     waitForUpdate(() => {
       expectTextContent(vm, 'yyyyyy')
       vm.list[0].tester = false
-    }).then(() => {
-      expectTextContent(vm, 'aaaa')
-      vm.list[0].text = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'annann')
-    }).then(done)
+    })
+      .then(() => {
+        expectTextContent(vm, 'aaaa')
+        vm.list[0].text = 'nn'
+      })
+      .then(() => {
+        expectTextContent(vm, 'annann')
+      })
+      .then(done)
   })
 
   it('should work inside v-for with nested v-else', done => {
@@ -234,12 +242,15 @@ describe('Directive v-once', () => {
     waitForUpdate(() => {
       expectTextContent(vm, 'y')
       vm.list[0].tester = false
-    }).then(() => {
-      expectTextContent(vm, 'a')
-      vm.list[0].text = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'a')
-    }).then(done)
+    })
+      .then(() => {
+        expectTextContent(vm, 'a')
+        vm.list[0].text = 'nn'
+      })
+      .then(() => {
+        expectTextContent(vm, 'a')
+      })
+      .then(done)
   })
 
   it('should work inside v-for with nested v-else-if and v-else', done => {
@@ -272,24 +283,31 @@ describe('Directive v-once', () => {
     waitForUpdate(() => {
       expectTextContent(vm, 'y')
       vm.list[0].tester = false
-    }).then(() => {
-      expectTextContent(vm, 'a')
-      vm.list[0].text = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'a')
-      vm.tester = true
-    }).then(() => {
-      expectTextContent(vm, 'nnelseif')
-      vm.list[0].text = 'xx'
-    }).then(() => {
-      expectTextContent(vm, 'nnelseif')
-      vm.list[0].tester = true
-    }).then(() => {
-      expectTextContent(vm, 'yy')
-      vm.list[0].truthy = 'nn'
-    }).then(() => {
-      expectTextContent(vm, 'yy')
-    }).then(done)
+    })
+      .then(() => {
+        expectTextContent(vm, 'a')
+        vm.list[0].text = 'nn'
+      })
+      .then(() => {
+        expectTextContent(vm, 'a')
+        vm.tester = true
+      })
+      .then(() => {
+        expectTextContent(vm, 'nnelseif')
+        vm.list[0].text = 'xx'
+      })
+      .then(() => {
+        expectTextContent(vm, 'nnelseif')
+        vm.list[0].tester = true
+      })
+      .then(() => {
+        expectTextContent(vm, 'yy')
+        vm.list[0].truthy = 'nn'
+      })
+      .then(() => {
+        expectTextContent(vm, 'yy')
+      })
+      .then(done)
   })
 
   it('should warn inside non-keyed v-for', () => {
@@ -311,7 +329,9 @@ describe('Directive v-once', () => {
     }).$mount()
 
     expect(vm.$el.textContent).toBe('aabbcc')
-    expect(`v-once can only be used inside v-for that is keyed.`).toHaveBeenWarned()
+    expect(
+      `v-once can only be used inside v-for that is keyed.`
+    ).toHaveBeenWarned()
   })
 
   // #4288
@@ -331,9 +351,11 @@ describe('Directive v-once', () => {
     vm.a++ // first update to force a patch
     waitForUpdate(() => {
       expect(vm.$el.textContent).toBe('1foo')
-    }).then(() => {
-      vm.ok = false // teardown component with v-once
-    }).then(done) // should not throw
+    })
+      .then(() => {
+        vm.ok = false // teardown component with v-once
+      })
+      .then(done) // should not throw
   })
 
   // #6826
@@ -359,6 +381,6 @@ describe('Directive v-once', () => {
   })
 })
 
-function expectTextContent (vm, text) {
+function expectTextContent(vm, text) {
   expect(vm.$el.textContent.replace(/\s+/g, '')).toBe(text)
 }
diff --git a/test/unit/features/directives/show.spec.ts b/test/unit/features/directives/show.spec.ts
index dd509577c27..86641b4af4f 100644
--- a/test/unit/features/directives/show.spec.ts
+++ b/test/unit/features/directives/show.spec.ts
@@ -27,32 +27,41 @@ describe('Directive v-show', () => {
     waitForUpdate(() => {
       expect(vm.$el.firstChild.style.display).toBe('none')
       vm.foo = {}
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.foo = 0
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = []
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.foo = null
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = '0'
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-      vm.foo = undefined
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-      vm.foo = 1
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('')
+        vm.foo = 0
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('none')
+        vm.foo = []
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('')
+        vm.foo = null
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('none')
+        vm.foo = '0'
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('')
+        vm.foo = undefined
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('none')
+        vm.foo = 1
+      })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('')
+      })
+      .then(done)
   })
 
   it('should respect display value in style attribute', done => {
     const vm = new Vue({
-      template: '<div><span v-show="foo" style="display:block">hello</span></div>',
+      template:
+        '<div><span v-show="foo" style="display:block">hello</span></div>',
       data: { foo: true }
     }).$mount()
     expect(vm.$el.firstChild.style.display).toBe('block')
@@ -60,9 +69,11 @@ describe('Directive v-show', () => {
     waitForUpdate(() => {
       expect(vm.$el.firstChild.style.display).toBe('none')
       vm.foo = true
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('block')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('block')
+      })
+      .then(done)
   })
 
   it('should support unbind when reused', done => {
@@ -77,8 +88,10 @@ describe('Directive v-show', () => {
     waitForUpdate(() => {
       expect(vm.$el.firstChild.style.display).toBe('')
       vm.tester = true
-    }).then(() => {
-      expect(vm.$el.firstChild.style.display).toBe('none')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.firstChild.style.display).toBe('none')
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/features/directives/static-style-parser.spec.ts b/test/unit/features/directives/static-style-parser.spec.ts
index 13dd675bda1..ccf9e4fe9c1 100644
--- a/test/unit/features/directives/static-style-parser.spec.ts
+++ b/test/unit/features/directives/static-style-parser.spec.ts
@@ -1,5 +1,6 @@
 import { parseStyleText } from 'web/util/style'
-const base64ImgUrl = 'url("data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAARBxAR/Q9ERP8DAABWUDggGAAAABQBAJ0BKgEAAQAAAP4AAA3AAP7mtQAAAA==")'
+const base64ImgUrl =
+  'url("data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAARBxAR/Q9ERP8DAABWUDggGAAAABQBAJ0BKgEAAQAAAP4AAA3AAP7mtQAAAA==")'
 const logoUrl = 'url(https://vuejs.org/images/logo.png)'
 
 it('should parse normal static style', () => {
diff --git a/test/unit/features/directives/style.spec.ts b/test/unit/features/directives/style.spec.ts
index 5e6f435b295..f1cfb871db7 100644
--- a/test/unit/features/directives/style.spec.ts
+++ b/test/unit/features/directives/style.spec.ts
@@ -30,35 +30,35 @@ describe('Directive v-bind:style', () => {
     }).$mount()
   })
 
-  it('string', (done) => {
+  it('string', done => {
     vm.styles = 'color:red;'
     waitForUpdate(() => {
       expect(vm.$el.style.cssText.replace(/\s/g, '')).toBe('color:red;')
     }).then(done)
   })
 
-  it('falsy number', (done) => {
+  it('falsy number', done => {
     vm.styles = { opacity: 0 }
     waitForUpdate(() => {
       expect(vm.$el.style.opacity).toBe('0')
     }).then(done)
   })
 
-  it('plain object', (done) => {
+  it('plain object', done => {
     vm.styles = { color: 'red' }
     waitForUpdate(() => {
       expect(vm.$el.style.cssText.replace(/\s/g, '')).toBe('color:red;')
     }).then(done)
   })
 
-  it('camelCase', (done) => {
+  it('camelCase', done => {
     vm.styles = { marginRight: '10px' }
     waitForUpdate(() => {
       expect(vm.$el.style.marginRight).toBe('10px')
     }).then(done)
   })
 
-  it('remove if falsy value', (done) => {
+  it('remove if falsy value', done => {
     vm.$el.style.color = 'red'
     waitForUpdate(() => {
       vm.styles = { color: null }
@@ -69,14 +69,14 @@ describe('Directive v-bind:style', () => {
       .then(done)
   })
 
-  it('ignore unsupported property', (done) => {
+  it('ignore unsupported property', done => {
     vm.styles = { foo: 'bar' }
     waitForUpdate(() => {
       expect(vm.$el.style.foo).not.toBe('bar')
     }).then(done)
   })
 
-  it('auto prefix', (done) => {
+  it('auto prefix', done => {
     const prop = checkPrefixedProp('transform')
     const val = 'scale(0.5)'
     vm.styles = { transform: val }
@@ -85,10 +85,10 @@ describe('Directive v-bind:style', () => {
     }).then(done)
   })
 
-  it('auto-prefixed style value as array', (done) => {
+  it('auto-prefixed style value as array', done => {
     vm.styles = { display: ['-webkit-box', '-ms-flexbox', 'flex'] }
     const testEl = document.createElement('div')
-    vm.styles.display.forEach((value) => {
+    vm.styles.display.forEach(value => {
       testEl.style.display = value
     })
     waitForUpdate(() => {
@@ -96,21 +96,21 @@ describe('Directive v-bind:style', () => {
     }).then(done)
   })
 
-  it('!important', (done) => {
+  it('!important', done => {
     vm.styles = { display: 'block !important' }
     waitForUpdate(() => {
       expect(vm.$el.style.getPropertyPriority('display')).toBe('important')
     }).then(done)
   })
 
-  it('camelCase with !important', (done) => {
+  it('camelCase with !important', done => {
     vm.styles = { zIndex: '100 !important' }
     waitForUpdate(() => {
       expect(vm.$el.style.getPropertyPriority('z-index')).toBe('important')
     }).then(done)
   })
 
-  it('object with multiple entries', (done) => {
+  it('object with multiple entries', done => {
     vm.$el.style.color = 'red'
     vm.styles = {
       fontSize: '10px'
@@ -141,7 +141,7 @@ describe('Directive v-bind:style', () => {
       .then(done)
   })
 
-  it('array of objects', (done) => {
+  it('array of objects', done => {
     vm.$el.style.padding = '10px'
     vm.styles = [{ color: 'red' }, { fontSize: '20px' }]
 
@@ -159,7 +159,7 @@ describe('Directive v-bind:style', () => {
       .then(done)
   })
 
-  it('updates objects deeply', (done) => {
+  it('updates objects deeply', done => {
     vm.styles = { display: 'none' }
     waitForUpdate(() => {
       expect(vm.$el.style.display).toBe('none')
@@ -171,7 +171,7 @@ describe('Directive v-bind:style', () => {
       .then(done)
   })
 
-  it('background size with only one value', (done) => {
+  it('background size with only one value', done => {
     vm.styles = { backgroundSize: '100%' }
     waitForUpdate(() => {
       expect(vm.$el.style.cssText.replace(/\s/g, '')).toMatch(
@@ -180,7 +180,7 @@ describe('Directive v-bind:style', () => {
     }).then(done)
   })
 
-  it('should work with interpolation', (done) => {
+  it('should work with interpolation', done => {
     vm.styles = { fontSize: `${vm.fontSize}px` }
     waitForUpdate(() => {
       expect(vm.$el.style.fontSize).toBe('16px')
@@ -194,7 +194,7 @@ describe('Directive v-bind:style', () => {
   }
 
   if (supportCssVariable()) {
-    it('CSS variables', (done) => {
+    it('CSS variables', done => {
       vm.styles = { '--color': 'red' }
       waitForUpdate(() => {
         expect(vm.$el.style.getPropertyValue('--color')).toBe('red')
@@ -216,7 +216,7 @@ describe('Directive v-bind:style', () => {
     expect(style.fontSize).toBe('12px')
   })
 
-  it('should merge between parent and child', (done) => {
+  it('should merge between parent and child', done => {
     const vm = new Vue({
       template:
         '<child style="text-align: left;margin-right:20px" :style="test"></child>',
@@ -281,7 +281,7 @@ describe('Directive v-bind:style', () => {
     expect(vm.$children[0].$refs.nested.$el.style.color).toBe('blue')
   })
 
-  it('should merge between nested components', (done) => {
+  it('should merge between nested components', done => {
     const vm = new Vue({
       template: '<child :style="test"></child>',
       data: {
@@ -324,7 +324,7 @@ describe('Directive v-bind:style', () => {
       .then(done)
   })
 
-  it('should not merge for different adjacent elements', (done) => {
+  it('should not merge for different adjacent elements', done => {
     const vm = new Vue({
       template:
         '<div>' +
@@ -353,7 +353,7 @@ describe('Directive v-bind:style', () => {
       .then(done)
   })
 
-  it('should not merge for v-if, v-else-if and v-else elements', (done) => {
+  it('should not merge for v-if, v-else-if and v-else elements', done => {
     const vm = new Vue({
       template:
         '<div>' +
@@ -392,7 +392,7 @@ describe('Directive v-bind:style', () => {
   })
 
   // #5318
-  it('should work for elements passed down as a slot', (done) => {
+  it('should work for elements passed down as a slot', done => {
     const vm = new Vue({
       template: `<test><div :style="style"/></test>`,
       data: {
diff --git a/test/unit/features/directives/text.spec.ts b/test/unit/features/directives/text.spec.ts
index 84f9bbe5db7..5affa3c7f43 100644
--- a/test/unit/features/directives/text.spec.ts
+++ b/test/unit/features/directives/text.spec.ts
@@ -25,35 +25,54 @@ describe('Directive v-text', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('false')
       vm.a = []
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('[]')
-      vm.a = {}
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{}')
-      vm.a = { toString () { return 'foo' } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('foo')
-      vm.a = { toJSON () { return { foo: 'bar' } } }
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('{\n  "foo": "bar"\n}')
-      vm.a = 123
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('123')
-      vm.a = 0
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('0')
-      vm.a = ' '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe(' ')
-      vm.a = '    '
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('    ')
-      vm.a = null
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-      vm.a = undefined
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('[]')
+        vm.a = {}
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('{}')
+        vm.a = {
+          toString() {
+            return 'foo'
+          }
+        }
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('foo')
+        vm.a = {
+          toJSON() {
+            return { foo: 'bar' }
+          }
+        }
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('{\n  "foo": "bar"\n}')
+        vm.a = 123
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('123')
+        vm.a = 0
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('0')
+        vm.a = ' '
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(' ')
+        vm.a = '    '
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('    ')
+        vm.a = null
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('')
+        vm.a = undefined
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('')
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/features/error-handling.spec.ts b/test/unit/features/error-handling.spec.ts
index ba737e616ec..b90bb947a96 100644
--- a/test/unit/features/error-handling.spec.ts
+++ b/test/unit/features/error-handling.spec.ts
@@ -5,7 +5,7 @@ const components = createErrorTestComponents()
 describe('Error handling', () => {
   // hooks that prevents the component from rendering, but should not
   // break parent component
-  [
+  ;[
     ['data', 'data()'],
     ['render', 'render'],
     ['beforeCreate', 'beforeCreate hook'],
@@ -55,10 +55,12 @@ describe('Error handling', () => {
   ].forEach(([type, description]) => {
     it(`should recover from errors in ${type} hook`, done => {
       const vm = createTestInstance(components[type])
-      assertBothInstancesActive(vm).then(() => {
-        expect(`Error in ${description}`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-      }).then(done)
+      assertBothInstancesActive(vm)
+        .then(() => {
+          expect(`Error in ${description}`).toHaveBeenWarned()
+          expect(`Error: ${type}`).toHaveBeenWarned()
+        })
+        .then(done)
     })
   })
 
@@ -69,13 +71,14 @@ describe('Error handling', () => {
   ].forEach(([type, description]) => {
     it(`should recover from promise errors in ${type} hook`, done => {
       const vm = createTestInstance(components[`${type}Async`])
-      assertBothInstancesActive(vm).then(() => {
-        expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
-        expect(`Error: ${type}`).toHaveBeenWarned()
-      }).then(done)
+      assertBothInstancesActive(vm)
+        .then(() => {
+          expect(`Error in ${description} (Promise/async)`).toHaveBeenWarned()
+          expect(`Error: ${type}`).toHaveBeenWarned()
+        })
+        .then(done)
     })
   })
-
   ;[
     ['beforeDestroy', 'beforeDestroy hook'],
     ['destroyed', 'destroyed hook'],
@@ -87,12 +90,13 @@ describe('Error handling', () => {
       waitForUpdate(() => {
         expect(`Error in ${description}`).toHaveBeenWarned()
         expect(`Error: ${type}`).toHaveBeenWarned()
-      }).thenWaitFor(next => {
-        assertRootInstanceActive(vm).end(next)
-      }).then(done)
+      })
+        .thenWaitFor(next => {
+          assertRootInstanceActive(vm).end(next)
+        })
+        .then(done)
     })
   })
-
   ;[
     ['beforeDestroy', 'beforeDestroy hook'],
     ['destroyed', 'destroyed hook']
@@ -113,7 +117,7 @@ describe('Error handling', () => {
     vm.n++
     waitForUpdate(() => {
       expect(`Error in getter for watcher`).toHaveBeenWarned()
-      function getErrorMsg () {
+      function getErrorMsg() {
         try {
           this.a.b.c
         } catch (e: any) {
@@ -122,34 +126,41 @@ describe('Error handling', () => {
       }
       const msg = getErrorMsg.call(vm)
       expect(msg).toHaveBeenWarned()
-    }).thenWaitFor(next => {
-      assertBothInstancesActive(vm).end(next)
-    }).then(done)
+    })
+      .thenWaitFor(next => {
+        assertBothInstancesActive(vm).end(next)
+      })
+      .then(done)
   })
-
   ;[
     ['userWatcherCallback', 'watcher'],
     ['userImmediateWatcherCallback', 'immediate watcher']
   ].forEach(([type, description]) => {
     it(`should recover from errors in user ${description} callback`, done => {
       const vm = createTestInstance(components[type])
-      assertBothInstancesActive(vm).then(() => {
-        expect(`Error in callback for ${description} "n"`).toHaveBeenWarned()
-        expect(`Error: ${type} error`).toHaveBeenWarned()
-      }).then(done)
+      assertBothInstancesActive(vm)
+        .then(() => {
+          expect(`Error in callback for ${description} "n"`).toHaveBeenWarned()
+          expect(`Error: ${type} error`).toHaveBeenWarned()
+        })
+        .then(done)
     })
 
     it(`should recover from promise errors in user ${description} callback`, done => {
       const vm = createTestInstance(components[`${type}Async`])
-      assertBothInstancesActive(vm).then(() => {
-        expect(`Error in callback for ${description} "n" (Promise/async)`).toHaveBeenWarned()
-        expect(`Error: ${type} error`).toHaveBeenWarned()
-      }).then(done)
+      assertBothInstancesActive(vm)
+        .then(() => {
+          expect(
+            `Error in callback for ${description} "n" (Promise/async)`
+          ).toHaveBeenWarned()
+          expect(`Error: ${type} error`).toHaveBeenWarned()
+        })
+        .then(done)
     })
   })
 
   it('config.errorHandler should capture render errors', done => {
-    const spy = Vue.config.errorHandler = vi.fn()
+    const spy = (Vue.config.errorHandler = vi.fn())
     const vm = createTestInstance(components.render)
 
     const args = spy.mock.calls[0]
@@ -157,21 +168,27 @@ describe('Error handling', () => {
     expect(args[1]).toBe(vm.$refs.child) // vm
     expect(args[2]).toContain('render') // description
 
-    assertRootInstanceActive(vm).then(() => {
-      Vue.config.errorHandler = undefined
-    }).then(done)
+    assertRootInstanceActive(vm)
+      .then(() => {
+        Vue.config.errorHandler = undefined
+      })
+      .then(done)
   })
 
   it('should capture and recover from nextTick errors', done => {
     const err1 = new Error('nextTick')
     const err2 = new Error('nextTick2')
-    const spy = Vue.config.errorHandler = vi.fn()
-    Vue.nextTick(() => { throw err1 })
+    const spy = (Vue.config.errorHandler = vi.fn())
+    Vue.nextTick(() => {
+      throw err1
+    })
     Vue.nextTick(() => {
       expect(spy).toHaveBeenCalledWith(err1, undefined, 'nextTick')
 
       const vm = new Vue()
-      vm.$nextTick(() => { throw err2 })
+      vm.$nextTick(() => {
+        throw err2
+      })
       Vue.nextTick(() => {
         // should be called with correct instance info
         expect(spy).toHaveBeenCalledWith(err2, vm, 'nextTick')
@@ -186,10 +203,10 @@ describe('Error handling', () => {
       throw new Error('error in errorHandler ¯\\_(ツ)_/¯')
     }
     const vm = new Vue({
-      render (h) {
+      render(h) {
         throw new Error('error in render')
       },
-      renderError (h, err) {
+      renderError(h, err) {
         return h('div', err.toString())
       }
     }).$mount()
@@ -202,12 +219,19 @@ describe('Error handling', () => {
   // event handlers that can throw errors or return rejected promise
   ;[
     ['single handler', '<div v-on:click="bork"></div>'],
-    ['multiple handlers', '<div v-on="{ click: [bork, function test() {}] }"></div>']
+    [
+      'multiple handlers',
+      '<div v-on="{ click: [bork, function test() {}] }"></div>'
+    ]
   ].forEach(([type, template]) => {
     it(`should recover from v-on errors for ${type} registered`, () => {
       const vm = new Vue({
         template,
-        methods: { bork () { throw new Error('v-on') } }
+        methods: {
+          bork() {
+            throw new Error('v-on')
+          }
+        }
       }).$mount()
       document.body.appendChild(vm.$el)
       global.triggerEvent(vm.$el, 'click')
@@ -216,12 +240,16 @@ describe('Error handling', () => {
       document.body.removeChild(vm.$el)
     })
 
-    it(`should recover from v-on async errors for ${type} registered`, (done) => {
+    it(`should recover from v-on async errors for ${type} registered`, done => {
       const vm = new Vue({
         template,
-        methods: { bork () {
-          return new Promise((resolve, reject) => reject(new Error('v-on async')))
-        } }
+        methods: {
+          bork() {
+            return new Promise((resolve, reject) =>
+              reject(new Error('v-on async'))
+            )
+          }
+        }
       }).$mount()
       document.body.appendChild(vm.$el)
       global.triggerEvent(vm.$el, 'click')
@@ -234,22 +262,22 @@ describe('Error handling', () => {
   })
 })
 
-function createErrorTestComponents () {
+function createErrorTestComponents() {
   const components: any = {}
 
   // data
   components.data = {
-    data () {
+    data() {
       throw new Error('data')
     },
-    render (h) {
+    render(h) {
       return h('div')
     }
   }
 
   // render error
   components.render = {
-    render (h) {
+    render(h) {
       throw new Error('render')
     }
   }
@@ -258,44 +286,44 @@ function createErrorTestComponents () {
   ;['create', 'mount', 'update', 'destroy'].forEach(hook => {
     // before
     const before = 'before' + hook.charAt(0).toUpperCase() + hook.slice(1)
-    const beforeComp = components[before] = {
+    const beforeComp = (components[before] = {
       props: ['n'],
-      render (h) {
+      render(h) {
         return h('div', this.n)
       }
-    }
+    })
     beforeComp[before] = function () {
       throw new Error(before)
     }
 
-    const beforeCompAsync = components[`${before}Async`] = {
+    const beforeCompAsync = (components[`${before}Async`] = {
       props: ['n'],
-      render (h) {
+      render(h) {
         return h('div', this.n)
       }
-    }
+    })
     beforeCompAsync[before] = function () {
       return new Promise((resolve, reject) => reject(new Error(before)))
     }
 
     // after
     const after = hook.replace(/e?$/, 'ed')
-    const afterComp = components[after] = {
+    const afterComp = (components[after] = {
       props: ['n'],
-      render (h) {
+      render(h) {
         return h('div', this.n)
       }
-    }
+    })
     afterComp[after] = function () {
       throw new Error(after)
     }
 
-    const afterCompAsync = components[`${after}Async`] = {
+    const afterCompAsync = (components[`${after}Async`] = {
       props: ['n'],
-      render (h) {
+      render(h) {
         return h('div', this.n)
       }
-    }
+    })
     afterCompAsync[after] = function () {
       return new Promise((resolve, reject) => reject(new Error(after)))
     }
@@ -304,10 +332,10 @@ function createErrorTestComponents () {
   // directive hooks errors
   ;['bind', 'update', 'unbind'].forEach(hook => {
     const key = 'directive ' + hook
-    const dirComp: any = components[key] = {
+    const dirComp: any = (components[key] = {
       props: ['n'],
       template: `<div v-foo="n">{{ n }}</div>`
-    }
+    })
     const dirFoo = {}
     dirFoo[hook] = function () {
       throw new Error(key)
@@ -320,14 +348,17 @@ function createErrorTestComponents () {
   // user watcher
   components.userWatcherGetter = {
     props: ['n'],
-    created () {
-      this.$watch(function () {
-        return this.n + this.a.b.c
-      }, val => {
-        console.log('user watcher fired: ' + val)
-      })
+    created() {
+      this.$watch(
+        function () {
+          return this.n + this.a.b.c
+        },
+        val => {
+          console.log('user watcher fired: ' + val)
+        }
+      )
     },
-    render (h) {
+    render(h) {
       return h('div', this.n)
     }
   }
@@ -335,11 +366,11 @@ function createErrorTestComponents () {
   components.userWatcherCallback = {
     props: ['n'],
     watch: {
-      n () {
+      n() {
         throw new Error('userWatcherCallback error')
       }
     },
-    render (h) {
+    render(h) {
       return h('div', this.n)
     }
   }
@@ -349,12 +380,12 @@ function createErrorTestComponents () {
     watch: {
       n: {
         immediate: true,
-        handler () {
+        handler() {
           throw new Error('userImmediateWatcherCallback error')
         }
       }
     },
-    render (h) {
+    render(h) {
       return h('div', this.n)
     }
   }
@@ -362,11 +393,11 @@ function createErrorTestComponents () {
   components.userWatcherCallbackAsync = {
     props: ['n'],
     watch: {
-      n () {
+      n() {
         return Promise.reject(new Error('userWatcherCallback error'))
       }
     },
-    render (h) {
+    render(h) {
       return h('div', this.n)
     }
   }
@@ -376,37 +407,42 @@ function createErrorTestComponents () {
     watch: {
       n: {
         immediate: true,
-        handler () {
+        handler() {
           return Promise.reject(new Error('userImmediateWatcherCallback error'))
         }
       }
     },
-    render (h) {
+    render(h) {
       return h('div', this.n)
     }
   }
 
   // event errors
   components.event = {
-    beforeCreate () {
-      this.$on('e', () => { throw new Error('event') })
+    beforeCreate() {
+      this.$on('e', () => {
+        throw new Error('event')
+      })
     },
-    mounted () {
+    mounted() {
       this.$emit('e')
     },
-    render (h) {
+    render(h) {
       return h('div')
     }
   }
 
   components.eventAsync = {
-    beforeCreate () {
-      this.$on('e', () => new Promise((resolve, reject) => reject(new Error('event'))))
+    beforeCreate() {
+      this.$on(
+        'e',
+        () => new Promise((resolve, reject) => reject(new Error('event')))
+      )
     },
-    mounted () {
+    mounted() {
       this.$emit('e')
     },
-    render (h) {
+    render(h) {
       return h('div')
     }
   }
@@ -414,24 +450,22 @@ function createErrorTestComponents () {
   return components
 }
 
-function createTestInstance (Comp) {
+function createTestInstance(Comp) {
   return new Vue({
     data: {
       n: 0,
       ok: true
     },
-    render (h) {
+    render(h) {
       return h('div', [
         'n:' + this.n + '\n',
-        this.ok
-          ? h(Comp, { ref: 'child', props: { n: this.n }})
-          : null
+        this.ok ? h(Comp, { ref: 'child', props: { n: this.n } }) : null
       ])
     }
   }).$mount()
 }
 
-function assertRootInstanceActive (vm) {
+function assertRootInstanceActive(vm) {
   expect(vm.$el.innerHTML).toContain('n:0\n')
   vm.n++
   return waitForUpdate(() => {
@@ -439,13 +473,15 @@ function assertRootInstanceActive (vm) {
   })
 }
 
-function assertBothInstancesActive (vm) {
+function assertBothInstancesActive(vm) {
   vm.n = 0
   return waitForUpdate(() => {
     expect(vm.$refs.child.$el.innerHTML).toContain('0')
   }).thenWaitFor(next => {
-    assertRootInstanceActive(vm).then(() => {
-      expect(vm.$refs.child.$el.innerHTML).toContain('1')
-    }).end(next)
+    assertRootInstanceActive(vm)
+      .then(() => {
+        expect(vm.$refs.child.$el.innerHTML).toContain('1')
+      })
+      .end(next)
   })
 }
diff --git a/test/unit/features/filter/filter.spec.ts b/test/unit/features/filter/filter.spec.ts
index 854ea575064..b7d72c93f00 100644
--- a/test/unit/features/filter/filter.spec.ts
+++ b/test/unit/features/filter/filter.spec.ts
@@ -106,7 +106,7 @@ describe('Filters', () => {
 
   it('handle division with hash values', () => {
     const vm = new Vue({
-      data: { a: { n: 20 }},
+      data: { a: { n: 20 } },
       template: `<div>{{ a['n'] / 5 | double }}</div>`,
       filters: { double: v => v * 2 }
     }).$mount()
diff --git a/test/unit/features/global-api/config.spec.ts b/test/unit/features/global-api/config.spec.ts
index fb8f45d2152..20080c987fb 100644
--- a/test/unit/features/global-api/config.spec.ts
+++ b/test/unit/features/global-api/config.spec.ts
@@ -90,13 +90,13 @@ describe('Global config', () => {
           </div>`,
         props: ['prop'],
         propsData: {
-          'prop': []
+          prop: []
         },
         data: () => ({
           data: ''
         }),
         computed: {
-          computed () {
+          computed() {
             return this.prop.join(',')
           }
         },
@@ -104,7 +104,7 @@ describe('Global config', () => {
           prop: 'execute'
         },
         methods: {
-          execute () {
+          execute() {
             this.data = this.computed
           }
         }
diff --git a/test/unit/features/global-api/extend.spec.ts b/test/unit/features/global-api/extend.spec.ts
index f8ab40c6f6a..b2aca199de4 100644
--- a/test/unit/features/global-api/extend.spec.ts
+++ b/test/unit/features/global-api/extend.spec.ts
@@ -54,17 +54,17 @@ describe('Global API: extend', () => {
   it('should merge lifecycle hooks', () => {
     const calls: any[] = []
     const A = Vue.extend({
-      created () {
+      created() {
         calls.push(1)
       }
     })
     const B = A.extend({
-      created () {
+      created() {
         calls.push(2)
       }
     })
     new B({
-      created () {
+      created() {
         calls.push(3)
       }
     })
@@ -93,18 +93,24 @@ describe('Global API: extend', () => {
   it('should merge methods', () => {
     const A = Vue.extend({
       methods: {
-        a () { return this.n }
+        a() {
+          return this.n
+        }
       }
     })
     const B = A.extend({
       methods: {
-        b () { return this.n + 1 }
+        b() {
+          return this.n + 1
+        }
       }
     })
     const b = new B({
       data: { n: 0 },
       methods: {
-        c () { return this.n + 2 }
+        c() {
+          return this.n + 2
+        }
       }
     })
     expect(b.a()).toBe(0)
@@ -144,7 +150,7 @@ describe('Global API: extend', () => {
 
   // #4767
   it('extended options should use different identify from parent', () => {
-    const A = Vue.extend({ computed: {}})
+    const A = Vue.extend({ computed: {} })
     const B = A.extend()
     B.options.computed.b = () => 'foo'
     expect(B.options.computed).not.toBe(A.options.computed)
diff --git a/test/unit/features/global-api/mixin.spec.ts b/test/unit/features/global-api/mixin.spec.ts
index 23edf82b49b..622f8bd806a 100644
--- a/test/unit/features/global-api/mixin.spec.ts
+++ b/test/unit/features/global-api/mixin.spec.ts
@@ -2,13 +2,17 @@ import Vue from 'vue'
 
 describe('Global API: mixin', () => {
   let options
-  beforeEach(() => { options = Vue.options })
-  afterEach(() => { Vue.options = options })
+  beforeEach(() => {
+    options = Vue.options
+  })
+  afterEach(() => {
+    Vue.options = options
+  })
 
   it('should work', () => {
     const spy = vi.fn()
     Vue.mixin({
-      created () {
+      created() {
         spy(this.$options.myOption)
       }
     })
@@ -22,12 +26,12 @@ describe('Global API: mixin', () => {
     const calls: any[] = []
     const Test: Vue = Vue.extend({
       name: 'test',
-      beforeCreate () {
+      beforeCreate() {
         calls.push(this.$options.myOption + ' local')
       }
     })
     Vue.mixin({
-      beforeCreate () {
+      beforeCreate() {
         calls.push(this.$options.myOption + ' global')
       }
     })
@@ -129,7 +133,7 @@ describe('Global API: mixin', () => {
   it('should work for a constructor mixin', () => {
     const spy = vi.fn()
     const Mixin = Vue.extend({
-      created () {
+      created() {
         spy(this.$options.myOption)
       }
     })
@@ -186,7 +190,7 @@ describe('Global API: mixin', () => {
     })
 
     const Child = Vue.extend({
-      mixins: [mixin2],
+      mixins: [mixin2]
     })
 
     const vm = new Child()
diff --git a/test/unit/features/global-api/observable.spec.ts b/test/unit/features/global-api/observable.spec.ts
index ecf2897d0a7..1c0388b889a 100644
--- a/test/unit/features/global-api/observable.spec.ts
+++ b/test/unit/features/global-api/observable.spec.ts
@@ -10,13 +10,17 @@ describe('Global API: observable', () => {
       render(h) {
         return h('div', [
           h('span', state.count),
-          h('button', {
-            on: {
-              click: () => {
-                state.count++
+          h(
+            'button',
+            {
+              on: {
+                click: () => {
+                  state.count++
+                }
               }
-            }
-          }, '+')
+            },
+            '+'
+          )
         ])
       }
     }).$mount()
diff --git a/test/unit/features/global-api/set-delete.spec.ts b/test/unit/features/global-api/set-delete.spec.ts
index cfc4cf3744d..1303119498e 100644
--- a/test/unit/features/global-api/set-delete.spec.ts
+++ b/test/unit/features/global-api/set-delete.spec.ts
@@ -17,7 +17,7 @@ describe('Global API: set/delete', () => {
     it('should update an observing object', done => {
       const vm = new Vue({
         template: '<div>{{foo.x}}</div>',
-        data: { foo: { x: 1 }}
+        data: { foo: { x: 1 } }
       }).$mount()
       expect(vm.$el.innerHTML).toBe('1')
       Vue.set(vm.foo, 'x', 2)
@@ -31,21 +31,35 @@ describe('Global API: set/delete', () => {
         template: '<div><div v-for="v,k in list">{{k}}-{{v}}</div></div>',
         data: { list: ['a', 'b', 'c'] }
       }).$mount()
-      expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-b</div><div>2-c</div>')
+      expect(vm.$el.innerHTML).toBe(
+        '<div>0-a</div><div>1-b</div><div>2-c</div>'
+      )
       Vue.set(vm.list, 1, 'd')
       waitForUpdate(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-d</div><div>2-c</div>')
+        expect(vm.$el.innerHTML).toBe(
+          '<div>0-a</div><div>1-d</div><div>2-c</div>'
+        )
         Vue.set(vm.list, '2', 'e')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-d</div><div>2-e</div>')
-        /* eslint-disable no-new-wrappers */
-        Vue.set(vm.list, new Number(1), 'f')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-f</div><div>2-e</div>')
-        Vue.set(vm.list, '3g', 'g')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<div>0-a</div><div>1-f</div><div>2-e</div>')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div>0-a</div><div>1-d</div><div>2-e</div>'
+          )
+          /* eslint-disable no-new-wrappers */
+          Vue.set(vm.list, new Number(1), 'f')
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div>0-a</div><div>1-f</div><div>2-e</div>'
+          )
+          Vue.set(vm.list, '3g', 'g')
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe(
+            '<div>0-a</div><div>1-f</div><div>2-e</div>'
+          )
+        })
+        .then(done)
     })
 
     it('should update a vue object with nothing', done => {
@@ -58,20 +72,18 @@ describe('Global API: set/delete', () => {
       waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe('')
         Vue.set(vm, 'x')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('')
+        })
+        .then(done)
     })
 
     it('be able to use string type index in array', done => {
       const vm = new Vue({
         template: '<div><p v-for="obj in lists">{{obj.name}}</p></div>',
         data: {
-          lists: [
-            { name: 'A' },
-            { name: 'B' },
-            { name: 'C' }
-          ]
+          lists: [{ name: 'A' }, { name: 'B' }, { name: 'C' }]
         }
       }).$mount()
       expect(vm.$el.innerHTML).toBe('<p>A</p><p>B</p><p>C</p>')
@@ -85,13 +97,13 @@ describe('Global API: set/delete', () => {
     it('should not overwrite properties on prototype chain', () => {
       class Model {
         _bar?: string
-        constructor () {
+        constructor() {
           this._bar = null
         }
-        get bar () {
+        get bar() {
           return this._bar
         }
-        set bar (newvalue) {
+        set bar(newvalue) {
           this._bar = newvalue
         }
       }
@@ -113,30 +125,29 @@ describe('Global API: set/delete', () => {
     it('should delete a key', done => {
       const vm = new Vue({
         template: '<div>{{obj.x}}</div>',
-        data: { obj: { x: 1 }}
+        data: { obj: { x: 1 } }
       }).$mount()
       expect(vm.$el.innerHTML).toBe('1')
       vm.obj.x = 2
       waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe('2')
         Vue.delete(vm.obj, 'x')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-        vm.obj.x = 3
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('')
+          vm.obj.x = 3
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('')
+        })
+        .then(done)
     })
 
     it('be able to delete an item in array', done => {
       const vm = new Vue({
         template: '<div><p v-for="obj in lists">{{obj.name}}</p></div>',
         data: {
-          lists: [
-            { name: 'A' },
-            { name: 'B' },
-            { name: 'C' }
-          ]
+          lists: [{ name: 'A' }, { name: 'B' }, { name: 'C' }]
         }
       }).$mount()
       expect(vm.$el.innerHTML).toBe('<p>A</p><p>B</p><p>C</p>')
@@ -144,28 +155,36 @@ describe('Global API: set/delete', () => {
       waitForUpdate(() => {
         expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
         Vue.delete(vm.lists, NaN)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, -1)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, '1.3')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, true)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, {})
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
-        Vue.delete(vm.lists, '1')
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('<p>A</p>')
-        /* eslint-disable no-new-wrappers */
-        Vue.delete(vm.lists, new Number(0) as number)
-      }).then(() => {
-        expect(vm.$el.innerHTML).toBe('')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
+          Vue.delete(vm.lists, -1)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
+          Vue.delete(vm.lists, '1.3')
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
+          Vue.delete(vm.lists, true)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
+          Vue.delete(vm.lists, {})
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<p>A</p><p>C</p>')
+          Vue.delete(vm.lists, '1')
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('<p>A</p>')
+          /* eslint-disable no-new-wrappers */
+          Vue.delete(vm.lists, new Number(0) as number)
+        })
+        .then(() => {
+          expect(vm.$el.innerHTML).toBe('')
+        })
+        .then(done)
     })
   })
 })
diff --git a/test/unit/features/instance/init.spec.ts b/test/unit/features/instance/init.spec.ts
index 62cc06dc22d..2619a785a6d 100644
--- a/test/unit/features/instance/init.spec.ts
+++ b/test/unit/features/instance/init.spec.ts
@@ -2,8 +2,12 @@ import Vue from 'vue'
 
 describe('Initialization', () => {
   it('without new', () => {
-    try { Vue() } catch (e) {}
-    expect('Vue is a constructor and should be called with the `new` keyword').toHaveBeenWarned()
+    try {
+      Vue()
+    } catch (e) {}
+    expect(
+      'Vue is a constructor and should be called with the `new` keyword'
+    ).toHaveBeenWarned()
   })
 
   it('with new', () => {
diff --git a/test/unit/features/instance/methods-data.spec.ts b/test/unit/features/instance/methods-data.spec.ts
index 616d5295aa9..0cdc4789222 100644
--- a/test/unit/features/instance/methods-data.spec.ts
+++ b/test/unit/features/instance/methods-data.spec.ts
@@ -13,9 +13,11 @@ describe('Instance methods data', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('hello')
       vm.$delete(vm.a, 'msg')
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('')
+      })
+      .then(done)
   })
 
   describe('$watch', () => {
@@ -44,10 +46,12 @@ describe('Instance methods data', () => {
         expect(spy.mock.calls.length).toBe(1)
         expect(spy).toHaveBeenCalledWith(2, 1)
         vm.a = { b: 3 }
-      }).then(() => {
-        expect(spy.mock.calls.length).toBe(2)
-        expect(spy).toHaveBeenCalledWith(3, 2)
-      }).then(done)
+      })
+        .then(() => {
+          expect(spy.mock.calls.length).toBe(2)
+          expect(spy).toHaveBeenCalledWith(3, 2)
+        })
+        .then(done)
     })
 
     it('immediate', () => {
@@ -82,9 +86,11 @@ describe('Instance methods data', () => {
       waitForUpdate(() => {
         expect(spy).toHaveBeenCalledWith(oldA, oldA)
         vm.a = { b: 3 }
-      }).then(() => {
-        expect(spy).toHaveBeenCalledWith(vm.a, oldA)
-      }).then(done)
+      })
+        .then(() => {
+          expect(spy).toHaveBeenCalledWith(vm.a, oldA)
+        })
+        .then(done)
     })
 
     it('handler option', done => {
@@ -97,9 +103,11 @@ describe('Instance methods data', () => {
       waitForUpdate(() => {
         expect(spy).toHaveBeenCalledWith(oldA, oldA)
         vm.a = { b: 3 }
-      }).then(() => {
-        expect(spy).toHaveBeenCalledWith(vm.a, oldA)
-      }).then(done)
+      })
+        .then(() => {
+          expect(spy).toHaveBeenCalledWith(vm.a, oldA)
+        })
+        .then(done)
     })
 
     it('handler option in string', () => {
@@ -122,7 +130,9 @@ describe('Instance methods data', () => {
 
     it('warn expression', () => {
       vm.$watch('a + b', spy)
-      expect('Watcher only accepts simple dot-delimited paths').toHaveBeenWarned()
+      expect(
+        'Watcher only accepts simple dot-delimited paths'
+      ).toHaveBeenWarned()
     })
   })
 })
diff --git a/test/unit/features/instance/methods-lifecycle.spec.ts b/test/unit/features/instance/methods-lifecycle.spec.ts
index 19b4727a358..e89b86ea9db 100644
--- a/test/unit/features/instance/methods-lifecycle.spec.ts
+++ b/test/unit/features/instance/methods-lifecycle.spec.ts
@@ -40,12 +40,12 @@ describe('Instance methods lifecycle', () => {
         components: {
           myComponent: {
             template: '<div>hi</div>',
-            mounted () {
+            mounted() {
               this.msg
               expect(Dep.target).toBe(undefined)
             },
             computed: {
-              msg () {
+              msg() {
                 return 1
               }
             }
@@ -111,7 +111,7 @@ describe('Instance methods lifecycle', () => {
     })
 
     it('remove self from data observer', () => {
-      const vm = new Vue({ data: { a: 1 }})
+      const vm = new Vue({ data: { a: 1 } })
       vm.$destroy()
       expect(vm.$data.__ob__.vmCount).toBe(0)
     })
@@ -141,9 +141,11 @@ describe('Instance methods lifecycle', () => {
         // should not work because adding new property
         expect(vm.$el.textContent).toBe('')
         vm.$forceUpdate()
-      }).then(() => {
-        expect(vm.$el.textContent).toBe('foo')
-      }).then(done)
+      })
+        .then(() => {
+          expect(vm.$el.textContent).toBe('foo')
+        })
+        .then(done)
     })
   })
 
diff --git a/test/unit/features/instance/properties.spec.ts b/test/unit/features/instance/properties.spec.ts
index fc426ba4ed0..366997ee22b 100644
--- a/test/unit/features/instance/properties.spec.ts
+++ b/test/unit/features/instance/properties.spec.ts
@@ -19,12 +19,12 @@ describe('Instance properties', () => {
   it('$options', () => {
     const A = Vue.extend({
       methods: {
-        a () {}
+        a() {}
       }
     })
     const vm = new A({
       methods: {
-        b () {}
+        b() {}
       }
     })
     expect(typeof vm.$options.methods?.a).toBe('function')
@@ -48,10 +48,12 @@ describe('Instance properties', () => {
     waitForUpdate(() => {
       expect(vm.$children.length).toBe(0)
       vm.ok = true
-    }).then(() => {
-      expect(vm.$children.length).toBe(1)
-      expect(vm.$children[0].$root).toBe(vm)
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$children.length).toBe(1)
+        expect(vm.$children[0].$root).toBe(vm)
+      })
+      .then(done)
   })
 
   it('$parent', () => {
@@ -59,7 +61,7 @@ describe('Instance properties', () => {
     const makeOption = name => ({
       name,
       template: `<div><slot></slot></div>`,
-      created () {
+      created() {
         calls.push(`${name}:${this.$parent.$options.name}`)
       }
     })
@@ -77,7 +79,12 @@ describe('Instance properties', () => {
         next: makeOption('next')
       }
     }).$mount()
-    expect(calls).toEqual(['outer:undefined', 'middle:outer', 'inner:middle', 'next:undefined'])
+    expect(calls).toEqual([
+      'outer:undefined',
+      'middle:outer',
+      'inner:middle',
+      'next:undefined'
+    ])
   })
 
   it('$props', done => {
@@ -102,19 +109,22 @@ describe('Instance properties', () => {
     expect(vm.$props.msg).toBe('bar')
     waitForUpdate(() => {
       expect(vm.$el.textContent).toContain('bar bar')
-    }).then(() => {
-      vm.$props.msg = 'baz'
-      expect(vm.msg).toBe('baz')
-    }).then(() => {
-      expect(vm.$el.textContent).toContain('baz baz')
-    }).then(done)
+    })
+      .then(() => {
+        vm.$props.msg = 'baz'
+        expect(vm.msg).toBe('baz')
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toContain('baz baz')
+      })
+      .then(done)
   })
 
   it('warn mutating $props', () => {
     const Comp = {
       props: ['msg'],
-      render () {},
-      mounted () {
+      render() {},
+      mounted() {
         expect(this.$props.msg).toBe('foo')
         this.$props.msg = 'bar'
       }
diff --git a/test/unit/features/instance/render-proxy.spec.ts b/test/unit/features/instance/render-proxy.spec.ts
index 8da17172608..62b347a1292 100644
--- a/test/unit/features/instance/render-proxy.spec.ts
+++ b/test/unit/features/instance/render-proxy.spec.ts
@@ -22,7 +22,7 @@ if (typeof Proxy !== 'undefined') {
 
     it('should not warn for hand-written render functions', () => {
       new Vue({
-        render (h) {
+        render(h) {
           return h('div', [this.a])
         }
       }).$mount()
@@ -33,10 +33,10 @@ if (typeof Proxy !== 'undefined') {
       const sym = Symbol()
 
       const vm = new Vue({
-        created () {
+        created() {
           this[sym] = 'foo'
         },
-        render (h) {
+        render(h) {
           if (sym in this) {
             return h('div', [this[sym]])
           }
@@ -51,7 +51,9 @@ if (typeof Proxy !== 'undefined') {
         data: { $a: 'foo' },
         template: `<div>{{ $a }}</div>`
       }).$mount()
-      expect(`Property "$a" must be accessed with "$data.$a"`).toHaveBeenWarned()
+      expect(
+        `Property "$a" must be accessed with "$data.$a"`
+      ).toHaveBeenWarned()
     })
 
     it('should warn properties starting with _ when found', () => {
@@ -59,7 +61,9 @@ if (typeof Proxy !== 'undefined') {
         data: { _foo: 'foo' },
         template: `<div>{{ _foo }}</div>`
       }).$mount()
-      expect(`Property "_foo" must be accessed with "$data._foo"`).toHaveBeenWarned()
+      expect(
+        `Property "_foo" must be accessed with "$data._foo"`
+      ).toHaveBeenWarned()
     })
 
     it('should warn properties starting with $ when not found', () => {
@@ -67,7 +71,9 @@ if (typeof Proxy !== 'undefined') {
         template: `<div>{{ $a }}</div>`
       }).$mount()
       expect(`Property or method "$a" is not defined`).toHaveBeenWarned()
-      expect(`Property "$a" must be accessed with "$data.$a"`).not.toHaveBeenWarned()
+      expect(
+        `Property "$a" must be accessed with "$data.$a"`
+      ).not.toHaveBeenWarned()
     })
 
     it('should warn properties starting with $ when not found (with stripped)', () => {
@@ -79,7 +85,9 @@ if (typeof Proxy !== 'undefined') {
         data: { $a: 'foo' },
         render
       }).$mount()
-      expect(`Property "$a" must be accessed with "$data.$a"`).toHaveBeenWarned()
+      expect(
+        `Property "$a" must be accessed with "$data.$a"`
+      ).toHaveBeenWarned()
     })
 
     it('should not warn properties starting with $ when using $data to access', () => {
diff --git a/test/unit/features/options/_scopeId.spec.ts b/test/unit/features/options/_scopeId.spec.ts
index ec45f902c32..a800f80f806 100644
--- a/test/unit/features/options/_scopeId.spec.ts
+++ b/test/unit/features/options/_scopeId.spec.ts
@@ -63,17 +63,19 @@ describe('Options _scopeId', () => {
     child.show = false
     waitForUpdate(() => {
       child.show = true
-    }).then(() => {
-      expect(child.$el.hasAttribute('data-1')).toBe(true)
-      expect(child.$el.hasAttribute('data-2')).toBe(true)
-    }).then(done)
+    })
+      .then(() => {
+        expect(child.$el.hasAttribute('data-1')).toBe(true)
+        expect(child.$el.hasAttribute('data-2')).toBe(true)
+      })
+      .then(done)
   })
 
   it('should work on functional components', () => {
     const child = {
       functional: true,
       _scopeId: 'child',
-      render (h) {
+      render(h) {
         return h('div', { class: 'child' }, [
           h('span', { class: 'child' }, 'child')
         ])
diff --git a/test/unit/features/options/comments.spec.ts b/test/unit/features/options/comments.spec.ts
index b13b63aaabc..d1c5fb3de5a 100644
--- a/test/unit/features/options/comments.spec.ts
+++ b/test/unit/features/options/comments.spec.ts
@@ -4,13 +4,16 @@ describe('Comments', () => {
   it('comments should be kept', () => {
     const vm = new Vue({
       comments: true,
-      data () {
+      data() {
         return {
           foo: 1
         }
       },
-      template: '<div><span>node1</span><!--comment1-->{{foo}}<!--comment2--></div>'
+      template:
+        '<div><span>node1</span><!--comment1-->{{foo}}<!--comment2--></div>'
     }).$mount()
-    expect(vm.$el.innerHTML).toEqual('<span>node1</span><!--comment1-->1<!--comment2-->')
+    expect(vm.$el.innerHTML).toEqual(
+      '<span>node1</span><!--comment1-->1<!--comment2-->'
+    )
   })
 })
diff --git a/test/unit/features/options/components.spec.ts b/test/unit/features/options/components.spec.ts
index 1a94380c322..bff289536a5 100644
--- a/test/unit/features/options/components.spec.ts
+++ b/test/unit/features/options/components.spec.ts
@@ -66,7 +66,9 @@ describe('Options components', () => {
         div: { template: '<div></div>' }
       }
     })
-    expect('Do not use built-in or reserved HTML elements as component').toHaveBeenWarned()
+    expect(
+      'Do not use built-in or reserved HTML elements as component'
+    ).toHaveBeenWarned()
   })
 
   it('should warn built-in elements', () => {
@@ -75,7 +77,9 @@ describe('Options components', () => {
         component: { template: '<div></div>' }
       }
     })
-    expect('Do not use built-in or reserved HTML elements as component').toHaveBeenWarned()
+    expect(
+      'Do not use built-in or reserved HTML elements as component'
+    ).toHaveBeenWarned()
   })
 
   // the HTMLUnknownElement check doesn't work in Android 4.2
diff --git a/test/unit/features/options/computed.spec.ts b/test/unit/features/options/computed.spec.ts
index b2616b1382c..bcebaea4adf 100644
--- a/test/unit/features/options/computed.spec.ts
+++ b/test/unit/features/options/computed.spec.ts
@@ -11,7 +11,7 @@ describe('Options computed', () => {
         a: 1
       },
       computed: {
-        b () {
+        b() {
           return this.a + 1
         }
       }
@@ -33,8 +33,12 @@ describe('Options computed', () => {
       },
       computed: {
         b: {
-          get () { return this.a + 1 },
-          set (v) { this.a = v - 1 }
+          get() {
+            return this.a + 1
+          },
+          set(v) {
+            this.a = v - 1
+          }
         }
       }
     }).$mount()
@@ -46,9 +50,11 @@ describe('Options computed', () => {
       expect(vm.$el.textContent).toBe('3')
       vm.b = 1
       expect(vm.a).toBe(0)
-    }).then(() => {
-      expect(vm.$el.textContent).toBe('1')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toBe('1')
+      })
+      .then(done)
   })
 
   it('warn with setter and no getter', () => {
@@ -60,14 +66,16 @@ describe('Options computed', () => {
       `,
       components: {
         test: {
-          data () {
+          data() {
             return {
               a: 1
             }
           },
           computed: {
             b: {
-              set (v) { this.a = v }
+              set(v) {
+                this.a = v
+              }
             }
           },
           template: `<div>{{a}}</div>`
@@ -81,13 +89,15 @@ describe('Options computed', () => {
   it('warn assigning to computed with no setter', () => {
     const vm = new Vue({
       computed: {
-        b () {
+        b() {
           return 1
         }
       }
     })
     vm.b = 2
-    expect(`Computed property "b" was assigned to but it has no setter.`).toHaveBeenWarned()
+    expect(
+      `Computed property "b" was assigned to but it has no setter.`
+    ).toHaveBeenWarned()
   })
 
   it('watching computed', done => {
@@ -97,7 +107,9 @@ describe('Options computed', () => {
         a: 1
       },
       computed: {
-        b () { return this.a + 1 }
+        b() {
+          return this.a + 1
+        }
       }
     })
     vm.$watch('b', spy)
@@ -114,7 +126,7 @@ describe('Options computed', () => {
         a: 1
       },
       computed: {
-        b () {
+        b() {
           spy()
           return this.a + 1
         }
@@ -136,7 +148,7 @@ describe('Options computed', () => {
       computed: {
         b: {
           cache: false,
-          get () {
+          get() {
             spy()
             return this.a + 1
           }
@@ -153,12 +165,12 @@ describe('Options computed', () => {
   it('as component', done => {
     const Comp = Vue.extend({
       template: `<div>{{ b }} {{ c }}</div>`,
-      data () {
+      data() {
         return { a: 1 }
       },
       computed: {
         // defined on prototype
-        b () {
+        b() {
           return this.a + 1
         }
       }
@@ -167,7 +179,7 @@ describe('Options computed', () => {
     const vm = new Comp({
       computed: {
         // defined at instantiation
-        c () {
+        c() {
           return this.b + 1
         }
       }
@@ -192,7 +204,9 @@ describe('Options computed', () => {
         a: () => 2
       }
     })
-    expect(`computed property "a" is already defined in data`).toHaveBeenWarned()
+    expect(
+      `computed property "a" is already defined in data`
+    ).toHaveBeenWarned()
   })
 
   it('warn conflict with props', () => {
@@ -203,7 +217,9 @@ describe('Options computed', () => {
         a: () => 2
       }
     })
-    expect(`computed property "a" is already defined as a prop`).toHaveBeenWarned()
+    expect(
+      `computed property "a" is already defined as a prop`
+    ).toHaveBeenWarned()
   })
 
   it('warn conflict with methods', () => {
@@ -215,7 +231,9 @@ describe('Options computed', () => {
         a: () => {}
       }
     })
-    expect(`computed property "a" is already defined as a method`).toHaveBeenWarned()
+    expect(
+      `computed property "a" is already defined as a method`
+    ).toHaveBeenWarned()
   })
 
   it('rethrow computed error', () => {
diff --git a/test/unit/features/options/data.spec.ts b/test/unit/features/options/data.spec.ts
index ac431bbd939..398ea70fd23 100644
--- a/test/unit/features/options/data.spec.ts
+++ b/test/unit/features/options/data.spec.ts
@@ -17,7 +17,7 @@ describe('Options data', () => {
 
   it('should merge data properly', () => {
     const Test = Vue.extend({
-      data () {
+      data() {
         return { a: 1 }
       }
     })
@@ -35,7 +35,7 @@ describe('Options data', () => {
     expect(vm.a).toBe(1)
     // recursively merge objects
     const WithObject = Vue.extend({
-      data () {
+      data() {
         return {
           obj: {
             a: 1
@@ -63,7 +63,7 @@ describe('Options data', () => {
 
   it('should warn non object return', () => {
     new Vue({
-      data () {}
+      data() {}
     })
     expect('data functions should return an object').toHaveBeenWarned()
   })
@@ -79,8 +79,8 @@ describe('Options data', () => {
   it('should have access to props', () => {
     const Test = {
       props: ['a'],
-      render () {},
-      data () {
+      render() {},
+      data() {
         return {
           b: this.a
         }
@@ -100,16 +100,18 @@ describe('Options data', () => {
       data: {
         msg: 'hello'
       },
-      beforeUpdate () { calls++ },
+      beforeUpdate() {
+        calls++
+      },
       components: {
         child: {
           template: `<span>{{ localMsg }}</span>`,
           props: ['msg'],
-          data () {
+          data() {
             return { localMsg: this.msg }
           },
           computed: {
-            computedMsg () {
+            computedMsg() {
               return this.msg + ' world'
             }
           }
@@ -128,11 +130,11 @@ describe('Options data', () => {
   it('should have access to methods', () => {
     const vm = new Vue({
       methods: {
-        get () {
+        get() {
           return { a: 1 }
         }
       },
-      data () {
+      data() {
         return this.get()
       }
     })
@@ -147,7 +149,7 @@ describe('Options data', () => {
         child: {
           template: '<span>{{bar}}</span>',
           inject: ['foo'],
-          data ({ foo }) {
+          data({ foo }) {
             return { bar: 'foo:' + foo }
           }
         }
diff --git a/test/unit/features/options/directives.spec.ts b/test/unit/features/options/directives.spec.ts
index 824377b3bb9..2d999c8b3ae 100644
--- a/test/unit/features/options/directives.spec.ts
+++ b/test/unit/features/options/directives.spec.ts
@@ -16,7 +16,8 @@ describe('Options directives', () => {
     }
 
     const vm = new Vue({
-      template: '<div class="hi"><div v-if="ok" v-test:arg.hello="a">{{ msg }}</div></div>',
+      template:
+        '<div class="hi"><div v-if="ok" v-test:arg.hello="a">{{ msg }}</div></div>',
       data: {
         msg: 'hi',
         a: 'foo',
@@ -24,7 +25,7 @@ describe('Options directives', () => {
       },
       directives: {
         test: {
-          bind (el, binding, vnode) {
+          bind(el, binding, vnode) {
             bindSpy()
             assertContext(el, binding, vnode)
             expect(binding.value).toBe('foo')
@@ -32,7 +33,7 @@ describe('Options directives', () => {
             expect(binding.oldValue).toBeUndefined()
             expect(el.parentNode).toBeNull()
           },
-          inserted (el, binding, vnode) {
+          inserted(el, binding, vnode) {
             insertedSpy()
             assertContext(el, binding, vnode)
             expect(binding.value).toBe('foo')
@@ -40,7 +41,7 @@ describe('Options directives', () => {
             expect(binding.oldValue).toBeUndefined()
             expect(el.parentNode.className).toBe('hi')
           },
-          update (el, binding, vnode, oldVnode) {
+          update(el, binding, vnode, oldVnode) {
             updateSpy()
             assertContext(el, binding, vnode)
             expect(el).toBe(vm.$el.children[0])
@@ -51,11 +52,11 @@ describe('Options directives', () => {
               expect(binding.oldValue).toBe('foo')
             }
           },
-          componentUpdated (el, binding, vnode) {
+          componentUpdated(el, binding, vnode) {
             componentUpdatedSpy()
             assertContext(el, binding, vnode)
           },
-          unbind (el, binding, vnode) {
+          unbind(el, binding, vnode) {
             unbindSpy()
             assertContext(el, binding, vnode)
           }
@@ -75,12 +76,15 @@ describe('Options directives', () => {
       expect(componentUpdatedSpy).toHaveBeenCalled()
       expect(unbindSpy).not.toHaveBeenCalled()
       vm.msg = 'bye'
-    }).then(() => {
-      expect(componentUpdatedSpy.mock.calls.length).toBe(2)
-      vm.ok = false
-    }).then(() => {
-      expect(unbindSpy).toHaveBeenCalled()
-    }).then(done)
+    })
+      .then(() => {
+        expect(componentUpdatedSpy.mock.calls.length).toBe(2)
+        vm.ok = false
+      })
+      .then(() => {
+        expect(unbindSpy).toHaveBeenCalled()
+      })
+      .then(done)
   })
 
   it('function shorthand', done => {
@@ -89,7 +93,7 @@ describe('Options directives', () => {
       template: '<div v-test:arg.hello="a"></div>',
       data: { a: 'foo' },
       directives: {
-        test (el, binding, vnode) {
+        test(el, binding, vnode) {
           expect(vnode.context).toBe(vm)
           expect(binding.arg).toBe('arg')
           expect(binding.modifiers).toEqual({ hello: true })
@@ -139,8 +143,12 @@ describe('Options directives', () => {
       `,
       directives: {
         test: {
-          bind: el => { el.id = 'a' },
-          unbind: el => { el.id = '' }
+          bind: el => {
+            el.id = 'a'
+          },
+          unbind: el => {
+            el.id = ''
+          }
         }
       }
     }).$mount()
@@ -203,23 +211,26 @@ describe('Options directives', () => {
       expect(spies.inserted2.mock.calls.length).toBe(1)
 
       vm.ok = true
-    }).then(() => {
-      // v-test without modifier should be bound again
-      expect(spies.bind1.mock.calls.length).toBe(3)
-      expect(spies.inserted1.mock.calls.length).toBe(3)
+    })
+      .then(() => {
+        // v-test without modifier should be bound again
+        expect(spies.bind1.mock.calls.length).toBe(3)
+        expect(spies.inserted1.mock.calls.length).toBe(3)
 
-      // v-test2 should be unbound
-      expect(spies.unbind2.mock.calls.length).toBe(1)
+        // v-test2 should be unbound
+        expect(spies.unbind2.mock.calls.length).toBe(1)
 
-      // v-test with modifier should be updated again
-      expect(spies.update1.mock.calls.length).toBe(2)
-      expect(spies.componentUpdated1.mock.calls.length).toBe(2)
+        // v-test with modifier should be updated again
+        expect(spies.update1.mock.calls.length).toBe(2)
+        expect(spies.componentUpdated1.mock.calls.length).toBe(2)
 
-      vm.val = 234
-    }).then(() => {
-      expect(spies.update1.mock.calls.length).toBe(4)
-      expect(spies.componentUpdated1.mock.calls.length).toBe(4)
-    }).then(done)
+        vm.val = 234
+      })
+      .then(() => {
+        expect(spies.update1.mock.calls.length).toBe(4)
+        expect(spies.componentUpdated1.mock.calls.length).toBe(4)
+      })
+      .then(done)
   })
 
   it('warn non-existent', () => {
diff --git a/test/unit/features/options/el.spec.ts b/test/unit/features/options/el.spec.ts
index 75beda1c2a1..e30382ff02c 100644
--- a/test/unit/features/options/el.spec.ts
+++ b/test/unit/features/options/el.spec.ts
@@ -29,8 +29,8 @@ describe('Options el', () => {
     el.innerHTML = '<span>{{message}}</span>'
     const vm = new Vue({
       el,
-      render (h) {
-        return h('p', { staticAttrs: { id: 'app' }}, [
+      render(h) {
+        return h('p', { staticAttrs: { id: 'app' } }, [
           h('span', {}, [this.message])
         ])
       },
@@ -44,8 +44,8 @@ describe('Options el', () => {
     const parent = document.createElement('div')
     parent.innerHTML =
       '<svg>' +
-        '<text :x="x" :y="y" :fill="color">{{ text }}</text>' +
-        '<g><clipPath><foo></foo></clipPath></g>' +
+      '<text :x="x" :y="y" :fill="color">{{ text }}</text>' +
+      '<g><clipPath><foo></foo></clipPath></g>' +
       '</svg>'
     const vm = new Vue({
       el: parent.childNodes[0],
@@ -63,13 +63,16 @@ describe('Options el', () => {
     expect(vm.$el.childNodes[0].textContent).toBe(vm.text)
     // nested, non-explicitly listed SVG elements
     expect(vm.$el.childNodes[1].childNodes[0].namespaceURI).toContain('svg')
-    expect(vm.$el.childNodes[1].childNodes[0].childNodes[0].namespaceURI).toContain('svg')
+    expect(
+      vm.$el.childNodes[1].childNodes[0].childNodes[0].namespaceURI
+    ).toContain('svg')
   })
 
   // https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
   it('properly decode attribute values when parsing templates from DOM', () => {
     const el = document.createElement('div')
-    el.innerHTML = '<a href="/a?foo=bar&baz=qux" name="<abc>" single=\'"hi"\'></a>'
+    el.innerHTML =
+      '<a href="/a?foo=bar&baz=qux" name="<abc>" single=\'"hi"\'></a>'
     const vm = new Vue({ el })
     expect(vm.$el.children[0].getAttribute('href')).toBe('/a?foo=bar&baz=qux')
     expect(vm.$el.children[0].getAttribute('name')).toBe('<abc>')
diff --git a/test/unit/features/options/errorCaptured.spec.ts b/test/unit/features/options/errorCaptured.spec.ts
index bcda50b6e21..65991544e66 100644
--- a/test/unit/features/options/errorCaptured.spec.ts
+++ b/test/unit/features/options/errorCaptured.spec.ts
@@ -17,12 +17,12 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      created () {
+      created() {
         child = this
         err = new Error('child')
         throw err
       },
-      render () {}
+      render() {}
     }
 
     new Vue({
@@ -38,22 +38,22 @@ describe('Options errorCaptured', () => {
   it('should be able to render the error in itself', done => {
     let child
     const Child = {
-      created () {
+      created() {
         child = this
         throw new Error('error from child')
       },
-      render () {}
+      render() {}
     }
 
     const vm = new Vue({
       data: {
         error: null
       },
-      errorCaptured (e, vm, info) {
+      errorCaptured(e, vm, info) {
         expect(vm).toBe(child)
         this.error = e.toString() + ' in ' + info
       },
-      render (h) {
+      render(h) {
         if (this.error) {
           return h('pre', this.error)
         }
@@ -73,16 +73,16 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      created () {
+      created() {
         child = this
         err = new Error('child')
         throw err
       },
-      render () {}
+      render() {}
     }
 
     new Vue({
-      errorCaptured (err, vm, info) {
+      errorCaptured(err, vm, info) {
         spy(err, vm, info)
         return false
       },
@@ -98,17 +98,17 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      created () {
+      created() {
         child = this
         err = new Error('child')
         throw err
       },
-      render () {}
+      render() {}
     }
 
     let err2
     const vm = new Vue({
-      errorCaptured () {
+      errorCaptured() {
         err2 = new Error('foo')
         throw err2
       },
@@ -123,20 +123,20 @@ describe('Options errorCaptured', () => {
     const calls: any[] = []
 
     const Child = {
-      created () {
+      created() {
         throw new Error('child')
       },
-      render () {}
+      render() {}
     }
 
     const ErrorBoundaryBase = {
-      errorCaptured () {
+      errorCaptured() {
         calls.push(1)
       }
     }
 
     const mixin = {
-      errorCaptured () {
+      errorCaptured() {
         calls.push(2)
       }
     }
@@ -144,7 +144,7 @@ describe('Options errorCaptured', () => {
     const ErrorBoundaryExtended = {
       extends: ErrorBoundaryBase,
       mixins: [mixin],
-      errorCaptured () {
+      errorCaptured() {
         calls.push(3)
       },
       render: h => h(Child)
@@ -155,7 +155,7 @@ describe('Options errorCaptured', () => {
     }
 
     new Vue({
-      errorCaptured () {
+      errorCaptured() {
         calls.push(4)
       },
       render: h => h(ErrorBoundaryExtended)
@@ -168,20 +168,20 @@ describe('Options errorCaptured', () => {
     const calls: any[] = []
 
     const Child = {
-      created () {
+      created() {
         throw new Error('child')
       },
-      render () {}
+      render() {}
     }
 
     const ErrorBoundaryBase = {
-      errorCaptured () {
+      errorCaptured() {
         calls.push(1)
       }
     }
 
     const mixin = {
-      errorCaptured () {
+      errorCaptured() {
         calls.push(2)
       }
     }
@@ -189,7 +189,7 @@ describe('Options errorCaptured', () => {
     const ErrorBoundaryExtended = {
       extends: ErrorBoundaryBase,
       mixins: [mixin],
-      errorCaptured () {
+      errorCaptured() {
         calls.push(3)
         return false
       },
@@ -201,7 +201,7 @@ describe('Options errorCaptured', () => {
     }
 
     new Vue({
-      errorCaptured () {
+      errorCaptured() {
         calls.push(4)
       },
       render: h => h(ErrorBoundaryExtended)
@@ -254,21 +254,21 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      data () {
+      data() {
         return {
           foo: null
         }
       },
       watch: {
-        foo () {
+        foo() {
           err = new Error('userWatcherCallback error')
           throw err
         }
       },
-      created () {
+      created() {
         child = this
       },
-      render () {}
+      render() {}
     }
 
     new Vue({
@@ -280,7 +280,11 @@ describe('Options errorCaptured', () => {
 
     waitForUpdate(() => {
       expect(spy).toHaveBeenCalledWith(err, child, 'callback for watcher "foo"')
-      expect(globalSpy).toHaveBeenCalledWith(err, child, 'callback for watcher "foo"')
+      expect(globalSpy).toHaveBeenCalledWith(
+        err,
+        child,
+        'callback for watcher "foo"'
+      )
     }).then(done)
   })
 
@@ -290,21 +294,21 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      data () {
+      data() {
         return {
           foo: null
         }
       },
       watch: {
-        foo () {
+        foo() {
           err = new Error('userWatcherCallback error')
           return Promise.reject(err)
         }
       },
-      created () {
+      created() {
         child = this
       },
-      render () {}
+      render() {}
     }
 
     new Vue({
@@ -316,8 +320,16 @@ describe('Options errorCaptured', () => {
 
     child.$nextTick(() => {
       waitForUpdate(() => {
-        expect(spy).toHaveBeenCalledWith(err, child, 'callback for watcher "foo" (Promise/async)')
-        expect(globalSpy).toHaveBeenCalledWith(err, child, 'callback for watcher "foo" (Promise/async)')
+        expect(spy).toHaveBeenCalledWith(
+          err,
+          child,
+          'callback for watcher "foo" (Promise/async)'
+        )
+        expect(globalSpy).toHaveBeenCalledWith(
+          err,
+          child,
+          'callback for watcher "foo" (Promise/async)'
+        )
       }).then(done)
     })
   })
@@ -328,7 +340,7 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      data () {
+      data() {
         return {
           foo: 'foo'
         }
@@ -336,16 +348,16 @@ describe('Options errorCaptured', () => {
       watch: {
         foo: {
           immediate: true,
-          handler () {
+          handler() {
             err = new Error('userImmediateWatcherCallback error')
             throw err
           }
         }
       },
-      created () {
+      created() {
         child = this
       },
-      render () {}
+      render() {}
     }
 
     new Vue({
@@ -354,8 +366,16 @@ describe('Options errorCaptured', () => {
     }).$mount()
 
     waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(err, child, 'callback for immediate watcher "foo"')
-      expect(globalSpy).toHaveBeenCalledWith(err, child, 'callback for immediate watcher "foo"')
+      expect(spy).toHaveBeenCalledWith(
+        err,
+        child,
+        'callback for immediate watcher "foo"'
+      )
+      expect(globalSpy).toHaveBeenCalledWith(
+        err,
+        child,
+        'callback for immediate watcher "foo"'
+      )
     }).then(done)
   })
 
@@ -365,7 +385,7 @@ describe('Options errorCaptured', () => {
     let child
     let err
     const Child = {
-      data () {
+      data() {
         return {
           foo: 'foo'
         }
@@ -373,16 +393,16 @@ describe('Options errorCaptured', () => {
       watch: {
         foo: {
           immediate: true,
-          handler () {
+          handler() {
             err = new Error('userImmediateWatcherCallback error')
             return Promise.reject(err)
           }
         }
       },
-      created () {
+      created() {
         child = this
       },
-      render () {}
+      render() {}
     }
 
     new Vue({
@@ -391,8 +411,16 @@ describe('Options errorCaptured', () => {
     }).$mount()
 
     waitForUpdate(() => {
-      expect(spy).toHaveBeenCalledWith(err, child, 'callback for immediate watcher "foo" (Promise/async)')
-      expect(globalSpy).toHaveBeenCalledWith(err, child, 'callback for immediate watcher "foo" (Promise/async)')
+      expect(spy).toHaveBeenCalledWith(
+        err,
+        child,
+        'callback for immediate watcher "foo" (Promise/async)'
+      )
+      expect(globalSpy).toHaveBeenCalledWith(
+        err,
+        child,
+        'callback for immediate watcher "foo" (Promise/async)'
+      )
     }).then(done)
   })
 })
diff --git a/test/unit/features/options/extends.spec.ts b/test/unit/features/options/extends.spec.ts
index 3ea9c4624af..d94247dd540 100644
--- a/test/unit/features/options/extends.spec.ts
+++ b/test/unit/features/options/extends.spec.ts
@@ -4,13 +4,13 @@ import { nativeWatch } from 'core/util/env'
 describe('Options extends', () => {
   it('should work on objects', () => {
     const A = {
-      data () {
+      data() {
         return { a: 1 }
       }
     }
     const B = {
       extends: A,
-      data () {
+      data() {
         return { b: 2 }
       }
     }
@@ -27,13 +27,13 @@ describe('Options extends', () => {
 
   it('should work on extended constructors', () => {
     const A = Vue.extend({
-      data () {
+      data() {
         return { a: 1 }
       }
     })
     const B = Vue.extend({
       extends: A,
-      data () {
+      data() {
         return { b: 2 }
       }
     })
diff --git a/test/unit/features/options/functional.spec.ts b/test/unit/features/options/functional.spec.ts
index 723ba1b6a4c..bd1d300561e 100644
--- a/test/unit/features/options/functional.spec.ts
+++ b/test/unit/features/options/functional.spec.ts
@@ -10,7 +10,7 @@ describe('Options functional', () => {
         wrap: {
           functional: true,
           props: ['msg'],
-          render (h, { props, children }) {
+          render(h, { props, children }) {
             return h('div', null, [props.msg, ' '].concat(children))
           }
         }
@@ -26,14 +26,14 @@ describe('Options functional', () => {
   it('should expose all props when not declared', done => {
     const fn = {
       functional: true,
-      render (h, { props }) {
+      render(h, { props }) {
         return h('div', `${props.msg} ${props.kebabMsg}`)
       }
     }
 
     const vm = new Vue({
       data: { test: 'foo' },
-      render (h) {
+      render(h) {
         return h('div', [
           h(fn, {
             props: { msg: this.test },
@@ -59,7 +59,7 @@ describe('Options functional', () => {
       components: {
         wrap: {
           functional: true,
-          render (h, { listeners }) {
+          render(h, { listeners }) {
             return h('div', {
               on: {
                 click: [listeners.click, () => listeners.test('bar')]
@@ -81,11 +81,12 @@ describe('Options functional', () => {
 
   it('should expose scopedSlots on render context', () => {
     const vm = new Vue({
-      template: '<div><wrap>foo<p slot="p" slot-scope="a">{{ a }}</p></wrap></div>',
+      template:
+        '<div><wrap>foo<p slot="p" slot-scope="a">{{ a }}</p></wrap></div>',
       components: {
         wrap: {
           functional: true,
-          render (h, { scopedSlots }) {
+          render(h, { scopedSlots }) {
             return [
               // scoped
               scopedSlots.p('a'),
@@ -106,7 +107,7 @@ describe('Options functional', () => {
       components: {
         test: {
           functional: true,
-          render (h) {
+          render(h) {
             return [h('span', 'foo'), h('span', 'bar')]
           }
         }
@@ -118,12 +119,13 @@ describe('Options functional', () => {
   it('should support slots', () => {
     const vm = new Vue({
       data: { test: 'foo' },
-      template: '<div><wrap><div slot="a">foo</div><div slot="b">bar</div></wrap></div>',
+      template:
+        '<div><wrap><div slot="a">foo</div><div slot="b">bar</div></wrap></div>',
       components: {
         wrap: {
           functional: true,
           props: ['msg'],
-          render (h, { slots }) {
+          render(h, { slots }) {
             slots = slots()
             return h('div', null, [slots.b, slots.a])
           }
@@ -146,31 +148,31 @@ describe('Options functional', () => {
         validate: {
           functional: true,
           props: ['field'],
-          render (h, { props, children, data: { on }}) {
+          render(h, { props, children, data: { on } }) {
             props.child = children[0]
             return h('validate-control', { props, on })
           }
         },
         'validate-control': {
           props: ['field', 'child'],
-          render () {
+          render() {
             return this.child
           },
-          mounted () {
+          mounted() {
             this.$el.addEventListener('input', this.onInput)
           },
-          destroyed () {
+          destroyed() {
             this.$el.removeEventListener('input', this.onInput)
           },
           methods: {
-            onInput (e) {
+            onInput(e) {
               const value = e.target.value
               if (this.validate(value)) {
                 this.$emit('valid', this)
               }
             },
             // something validation logic here
-            validate (val) {
+            validate(val) {
               return val.length > 0
             }
           }
@@ -184,18 +186,21 @@ describe('Options functional', () => {
     waitForUpdate(() => {
       input.value = 'foo'
       triggerEvent(input, 'input')
-    }).then(() => {
-      expect(onValid).toHaveBeenCalled()
-    }).then(() => {
-      document.body.removeChild(vm.$el)
-      vm.$destroy()
-    }).then(done)
+    })
+      .then(() => {
+        expect(onValid).toHaveBeenCalled()
+      })
+      .then(() => {
+        document.body.removeChild(vm.$el)
+        vm.$destroy()
+      })
+      .then(done)
   })
 
   it('create empty vnode when render return null', () => {
     const child = {
       functional: true,
-      render () {
+      render() {
         return null
       }
     }
@@ -213,7 +218,7 @@ describe('Options functional', () => {
   it('should normalize top-level arrays', () => {
     const Foo = {
       functional: true,
-      render (h) {
+      render(h) {
         return [h('span', 'hi'), null]
       }
     }
@@ -231,11 +236,7 @@ describe('Options functional', () => {
 
     const Bar = {
       functional: true,
-      render: h => ([
-        h('div', 'one'),
-        h('div', 'two'),
-        h(Baz)
-      ])
+      render: h => [h('div', 'one'), h('div', 'two'), h(Baz)]
     }
 
     const Baz = {
@@ -248,13 +249,15 @@ describe('Options functional', () => {
       components: { Foo, Bar }
     }).$mount()
 
-    expect(vm.$el.innerHTML).toBe('<div>one</div><div>two</div><div>three</div>')
+    expect(vm.$el.innerHTML).toBe(
+      '<div>one</div><div>two</div><div>three</div>'
+    )
   })
 
   it('should apply namespace when returning arrays', () => {
     const Child = {
       functional: true,
-      render: h => ([h('foo'), h('bar')])
+      render: h => [h('foo'), h('bar')]
     }
     const vm = new Vue({
       template: `<svg><child/></svg>`,
@@ -277,9 +280,11 @@ describe('Options functional', () => {
           _vm._t('slot2'),
           _vm._t('scoped', null, { msg: _vm.props.msg }),
           _vm._m(0),
-          _c('div', { staticClass: 'clickable', on: { click: _vm.parent.fn }}, [
-            _vm._v('click me')
-          ])
+          _c(
+            'div',
+            { staticClass: 'clickable', on: { click: _vm.parent.fn } },
+            [_vm._v('click me')]
+          )
         ],
         2
       )
@@ -315,13 +320,13 @@ describe('Options functional', () => {
       </div>
       `,
       methods: {
-        fn () {
+        fn() {
           this.msg = 'bye'
         }
       }
     }).$mount()
 
-    function assertMarkup () {
+    function assertMarkup() {
       expect(parent.$el.innerHTML).toBe(
         `<div>` +
           `<h2 class="red">${parent.msg}</h2>` +
@@ -331,7 +336,7 @@ describe('Options functional', () => {
           // static
           `<div>Some <span>text</span></div>` +
           `<div class="clickable">click me</div>` +
-        `</div>`
+          `</div>`
       )
     }
 
@@ -347,7 +352,7 @@ describe('Options functional', () => {
       props: {
         name: {}
       },
-      render (h, context) {
+      render(h, context) {
         return [h('span', 'hi'), h('span', context.props.name)]
       }
     }
@@ -358,6 +363,8 @@ describe('Options functional', () => {
       },
       components: { Foo }
     }).$mount()
-    expect(vm.$el.innerHTML).toBe('<span>hi</span><span>foo</span><span>hi</span><span>bar</span>')
+    expect(vm.$el.innerHTML).toBe(
+      '<span>hi</span><span>foo</span><span>hi</span><span>bar</span>'
+    )
   })
 })
diff --git a/test/unit/features/options/inject.spec.ts b/test/unit/features/options/inject.spec.ts
index 3b47ef566f0..399061f9768 100644
--- a/test/unit/features/options/inject.spec.ts
+++ b/test/unit/features/options/inject.spec.ts
@@ -9,8 +9,8 @@ describe('Options provide/inject', () => {
   let injected
   const injectedComp = {
     inject: ['foo', 'bar'],
-    render () {},
-    created () {
+    render() {},
+    created() {
       injected = [this.foo, this.bar]
     }
   }
@@ -69,7 +69,7 @@ describe('Options provide/inject', () => {
         a: 1,
         b: false
       },
-      provide () {
+      provide() {
         return {
           foo: this.a,
           bar: this.b
@@ -94,8 +94,8 @@ describe('Options provide/inject', () => {
         baz: 'foo',
         qux: 'bar'
       },
-      render () {},
-      created () {
+      render() {},
+      created() {
         injected = [this.baz, this.qux]
       }
     }
@@ -129,14 +129,14 @@ describe('Options provide/inject', () => {
     const child = new Vue({
       parent: vm,
       inject: ['foo'],
-      data () {
+      data() {
         return {
           bar: this.foo + 1
         }
       },
       props: {
         baz: {
-          default () {
+          default() {
             return this.foo + 2
           }
         }
@@ -160,7 +160,7 @@ describe('Options provide/inject', () => {
         child: {
           functional: true,
           inject: ['foo', 'bar'],
-          render (h, context) {
+          render(h, context) {
             const { injections } = context
             injected = [injections.foo, injections.bar]
           }
@@ -201,13 +201,13 @@ describe('Options provide/inject', () => {
           bar: keyB
         },
         template: `<span/>`,
-        created () {
+        created() {
           injected = [this.foo, this.bar]
         }
       }
       new Vue({
         mixins: [mixinA, mixinB],
-        render (h) {
+        render(h) {
           return h(child)
         }
       }).$mount()
@@ -220,12 +220,12 @@ describe('Options provide/inject', () => {
   it('should work with reactive array', done => {
     const vm = new Vue({
       template: `<div><child></child></div>`,
-      data () {
+      data() {
         return {
           foo: []
         }
       },
-      provide () {
+      provide() {
         return {
           foo: this.foo
         }
@@ -259,7 +259,7 @@ describe('Options provide/inject', () => {
     const child = parent.extend({
       template: `<span/>`,
       inject: ['bar'],
-      created () {
+      created() {
         injected = [this.foo, this.bar]
       }
     })
@@ -280,18 +280,18 @@ describe('Options provide/inject', () => {
   })
 
   it('should merge from mixins properly (objects)', () => {
-    const mixinA = { inject: { foo: 'foo' }}
-    const mixinB = { inject: { bar: 'bar' }}
+    const mixinA = { inject: { foo: 'foo' } }
+    const mixinB = { inject: { bar: 'bar' } }
     const child = {
       mixins: [mixinA, mixinB],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar]
       }
     }
     new Vue({
       provide: { foo: 'foo', bar: 'bar', baz: 'baz' },
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -306,13 +306,13 @@ describe('Options provide/inject', () => {
       mixins: [mixinA, mixinB],
       inject: ['baz'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar, this.baz]
       }
     }
     new Vue({
       provide: { foo: 'foo', bar: 'bar', baz: 'baz' },
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -321,19 +321,19 @@ describe('Options provide/inject', () => {
   })
 
   it('should merge from mixins properly (mix of objects and arrays)', () => {
-    const mixinA = { inject: { foo: 'foo' }}
+    const mixinA = { inject: { foo: 'foo' } }
     const mixinB = { inject: ['bar'] }
     const child = {
       mixins: [mixinA, mixinB],
       inject: { qux: 'baz' },
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar, this.qux]
       }
     }
     new Vue({
       provide: { foo: 'foo', bar: 'bar', baz: 'baz' },
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -358,8 +358,9 @@ describe('Options provide/inject', () => {
     child.foo = 2
     expect(
       `Avoid mutating an injected value directly since the changes will be ` +
-      `overwritten whenever the provided component re-renders. ` +
-      `injection being mutated: "${key}"`).toHaveBeenWarned()
+        `overwritten whenever the provided component re-renders. ` +
+        `injection being mutated: "${key}"`
+    ).toHaveBeenWarned()
   })
 
   it('should warn when injections cannot be found', () => {
@@ -367,7 +368,7 @@ describe('Options provide/inject', () => {
     new Vue({
       parent: vm,
       inject: ['foo', 'bar'],
-      created () {}
+      created() {}
     })
     expect(`Injection "foo" not found`).toHaveBeenWarned()
     expect(`Injection "bar" not found`).toHaveBeenWarned()
@@ -384,7 +385,7 @@ describe('Options provide/inject', () => {
     new Vue({
       parent: vm,
       inject: ['foo', 'bar', 'baz'],
-      created () {}
+      created() {}
     })
     expect(`Injection "foo" not found`).not.toHaveBeenWarned()
     expect(`Injection "bar" not found`).not.toHaveBeenWarned()
@@ -392,9 +393,12 @@ describe('Options provide/inject', () => {
   })
 
   it('should not warn when injection key which is not provided is not enumerable', () => {
-    const parent = new Vue({ provide: { foo: 1 }})
+    const parent = new Vue({ provide: { foo: 1 } })
     const inject = { foo: 'foo' }
-    Object.defineProperty(inject, '__ob__', { enumerable: false, value: '__ob__' })
+    Object.defineProperty(inject, '__ob__', {
+      enumerable: false,
+      value: '__ob__'
+    })
     new Vue({ parent, inject })
     expect(`Injection "__ob__" not found`).not.toHaveBeenWarned()
   })
@@ -409,7 +413,7 @@ describe('Options provide/inject', () => {
         bar: { default: false },
         baz: { default: undefined }
       },
-      created () {
+      created() {
         injected = [this.foo, this.bar, this.baz]
       }
     })
@@ -429,7 +433,7 @@ describe('Options provide/inject', () => {
         bar: { default: false },
         baz: { default: undefined }
       },
-      created () {
+      created() {
         injected = [this.foo, this.bar, this.baz]
       }
     })
@@ -451,7 +455,7 @@ describe('Options provide/inject', () => {
         bar: { default: 2 },
         baz: { default: 2 }
       },
-      created () {
+      created() {
         injected = [this.foo, this.bar, this.baz]
       }
     })
@@ -460,18 +464,18 @@ describe('Options provide/inject', () => {
 
   // Github issue #6008
   it('should merge provide from mixins (objects)', () => {
-    const mixinA = { provide: { foo: 'foo' }}
-    const mixinB = { provide: { bar: 'bar' }}
+    const mixinA = { provide: { foo: 'foo' } }
+    const mixinB = { provide: { bar: 'bar' } }
     const child = {
       inject: ['foo', 'bar'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar]
       }
     }
     new Vue({
       mixins: [mixinA, mixinB],
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -485,13 +489,13 @@ describe('Options provide/inject', () => {
     const child = {
       inject: ['foo', 'bar'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar]
       }
     }
     new Vue({
       mixins: [mixinA, mixinB],
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -500,20 +504,20 @@ describe('Options provide/inject', () => {
   })
 
   it('should merge provide from mixins (mix of objects and functions)', () => {
-    const mixinA = { provide: { foo: 'foo' }}
+    const mixinA = { provide: { foo: 'foo' } }
     const mixinB = { provide: () => ({ bar: 'bar' }) }
-    const mixinC = { provide: { baz: 'baz' }}
+    const mixinC = { provide: { baz: 'baz' } }
     const mixinD = { provide: () => ({ bam: 'bam' }) }
     const child = {
       inject: ['foo', 'bar', 'baz', 'bam'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar, this.baz, this.bam]
       }
     }
     new Vue({
       mixins: [mixinA, mixinB, mixinC, mixinD],
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -522,18 +526,18 @@ describe('Options provide/inject', () => {
   })
 
   it('should merge provide from mixins and override existing keys', () => {
-    const mixinA = { provide: { foo: 'foo' }}
-    const mixinB = { provide: { foo: 'bar' }}
+    const mixinA = { provide: { foo: 'foo' } }
+    const mixinB = { provide: { foo: 'bar' } }
     const child = {
       inject: ['foo'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo]
       }
     }
     new Vue({
       mixins: [mixinA, mixinB],
-      render (h) {
+      render(h) {
         return h(child)
       }
     }).$mount()
@@ -546,14 +550,14 @@ describe('Options provide/inject', () => {
     const child = {
       inject: ['foo', 'bar'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = [this.foo, this.bar]
       }
     }
     const Ctor = Vue.extend({
       mixins: [mixinA],
       provide: { bar: 'bar' },
-      render (h) {
+      render(h) {
         return h(child)
       }
     })
@@ -565,7 +569,7 @@ describe('Options provide/inject', () => {
 
   // #5913
   it('should keep the reactive with provide', () => {
-    function isObserver (obj) {
+    function isObserver(obj) {
       if (isObject(obj)) {
         return hasOwn(obj, '__ob__') && obj.__ob__ instanceof Observer
       }
@@ -574,14 +578,14 @@ describe('Options provide/inject', () => {
 
     const vm = new Vue({
       template: `<div><child ref='child'></child></div>`,
-      data () {
+      data() {
         return {
           foo: {},
           $foo: {},
           foo1: []
         }
       },
-      provide () {
+      provide() {
         return {
           foo: this.foo,
           $foo: this.$foo,
@@ -621,20 +625,20 @@ describe('Options provide/inject', () => {
 
     const Child = {
       inject: ['foo', 'bar'],
-      render (h) {
+      render(h) {
         return h('div', [`foo: ${this.foo}, `, `bar: ${this.bar}`])
       }
     }
 
     const Parent = {
       mixins: [ProvideFooMixin, ProvideBarMixin],
-      render (h) {
+      render(h) {
         return h(Child)
       }
     }
 
     const vm = new Vue({
-      render (h) {
+      render(h) {
         return h(Parent)
       }
     }).$mount()
@@ -646,13 +650,13 @@ describe('Options provide/inject', () => {
     const child = {
       inject: ['foo'],
       template: `<span/>`,
-      created () {
+      created() {
         injected = this.foo
       }
     }
     const Ctor = Vue.extend({
       provide: { foo: 'foo' },
-      render (h) {
+      render(h) {
         return h(child)
       }
     })
diff --git a/test/unit/features/options/lifecycle.spec.ts b/test/unit/features/options/lifecycle.spec.ts
index dd4b3e87ad2..39e43881250 100644
--- a/test/unit/features/options/lifecycle.spec.ts
+++ b/test/unit/features/options/lifecycle.spec.ts
@@ -12,11 +12,11 @@ describe('Options lifecycle hooks', () => {
         data: {
           a: 1
         },
-        beforeCreate () {
+        beforeCreate() {
           spy()
           expect(this.a).toBeUndefined()
           this.$options.computed = {
-            b () {
+            b() {
               return this.a + 1
             }
           }
@@ -33,7 +33,7 @@ describe('Options lifecycle hooks', () => {
         data: {
           a: 1
         },
-        created () {
+        created() {
           expect(this.a).toBe(1)
           spy()
         }
@@ -45,8 +45,8 @@ describe('Options lifecycle hooks', () => {
   describe('beforeMount', () => {
     it('should not have mounted', () => {
       const vm = new Vue({
-        render () {},
-        beforeMount () {
+        render() {},
+        beforeMount() {
           spy()
           expect(this._isMounted).toBe(false)
           expect(this.$el).toBeUndefined() // due to empty mount
@@ -64,7 +64,7 @@ describe('Options lifecycle hooks', () => {
     it('should have mounted', () => {
       const vm = new Vue({
         template: '<div></div>',
-        mounted () {
+        mounted() {
           spy()
           expect(this._isMounted).toBe(true)
           expect(this.$el.tagName).toBe('DIV')
@@ -83,7 +83,7 @@ describe('Options lifecycle hooks', () => {
       new Vue({
         parent,
         template: '<div></div>',
-        mounted () {
+        mounted() {
           spy()
         }
       }).$mount()
@@ -94,20 +94,20 @@ describe('Options lifecycle hooks', () => {
       const calls: any[] = []
       new Vue({
         template: '<div><test></test></div>',
-        mounted () {
+        mounted() {
           calls.push('parent')
         },
         components: {
           test: {
             template: '<nested></nested>',
-            mounted () {
+            mounted() {
               expect(this.$el.parentNode).toBeTruthy()
               calls.push('child')
             },
             components: {
               nested: {
                 template: '<div></div>',
-                mounted () {
+                mounted() {
                   expect(this.$el.parentNode).toBeTruthy()
                   calls.push('nested')
                 }
@@ -125,7 +125,7 @@ describe('Options lifecycle hooks', () => {
       const vm = new Vue({
         template: '<div>{{ msg }}</div>',
         data: { msg: 'foo' },
-        beforeUpdate () {
+        beforeUpdate() {
           spy()
           expect(this.$el.textContent).toBe('foo')
         }
@@ -142,7 +142,7 @@ describe('Options lifecycle hooks', () => {
       const vm = new Vue({
         template: '<div>{{ msg }}</div>',
         data: { msg: 'foo' },
-        beforeUpdate () {
+        beforeUpdate() {
           this.msg += '!'
         }
       }).$mount()
@@ -171,13 +171,13 @@ describe('Options lifecycle hooks', () => {
             <todo v-for="t in pendingTodos" :todo="t" :key="t.id"></todo>
           </div>
         `,
-        data () {
+        data() {
           return {
             todos: [{ id: 1, done: false }]
           }
         },
         computed: {
-          pendingTodos () {
+          pendingTodos() {
             return this.todos.filter(t => !t.done)
           }
         }
@@ -196,7 +196,7 @@ describe('Options lifecycle hooks', () => {
       const vm = new Vue({
         template: '<div>{{ msg }}</div>',
         data: { msg: 'foo' },
-        updated () {
+        updated() {
           spy()
           expect(this.$el.textContent).toBe('bar')
         }
@@ -217,13 +217,13 @@ describe('Options lifecycle hooks', () => {
         components: {
           test: {
             template: `<div><slot></slot></div>`,
-            updated () {
+            updated() {
               expect(this.$el.textContent).toBe('bar')
               calls.push('child')
             }
           }
         },
-        updated () {
+        updated() {
           expect(this.$el.textContent).toBe('bar')
           calls.push('parent')
         }
@@ -255,13 +255,13 @@ describe('Options lifecycle hooks', () => {
             <todo v-for="t in pendingTodos" :todo="t" :key="t.id"></todo>
           </div>
         `,
-        data () {
+        data() {
           return {
             todos: [{ id: 1, done: false }]
           }
         },
         computed: {
-          pendingTodos () {
+          pendingTodos() {
             return this.todos.filter(t => !t.done)
           }
         }
@@ -278,8 +278,8 @@ describe('Options lifecycle hooks', () => {
   describe('beforeDestroy', () => {
     it('should be called before destroy', () => {
       const vm = new Vue({
-        render () {},
-        beforeDestroy () {
+        render() {},
+        beforeDestroy() {
           spy()
           expect(this._isBeingDestroyed).toBe(false)
           expect(this._isDestroyed).toBe(false)
@@ -296,8 +296,8 @@ describe('Options lifecycle hooks', () => {
   describe('destroyed', () => {
     it('should be called after destroy', () => {
       const vm = new Vue({
-        render () {},
-        destroyed () {
+        render() {},
+        destroyed() {
           spy()
           expect(this._isBeingDestroyed).toBe(true)
           expect(this._isDestroyed).toBe(true)
@@ -316,8 +316,8 @@ describe('Options lifecycle hooks', () => {
     const mounted = vi.fn()
     const destroyed = vi.fn()
     const vm = new Vue({
-      render () {},
-      beforeCreate () {
+      render() {},
+      beforeCreate() {
         this.$on('hook:created', created)
         this.$on('hook:mounted', mounted)
         this.$on('hook:destroyed', destroyed)
diff --git a/test/unit/features/options/methods.spec.ts b/test/unit/features/options/methods.spec.ts
index f1e5fc68b27..93f31f8ef4e 100644
--- a/test/unit/features/options/methods.spec.ts
+++ b/test/unit/features/options/methods.spec.ts
@@ -10,7 +10,7 @@ describe('Options methods', () => {
         a: 1
       },
       methods: {
-        plus () {
+        plus() {
           this.a++
         }
       }
@@ -25,7 +25,9 @@ describe('Options methods', () => {
         hello: {}
       }
     })
-    expect('Method "hello" has type "object" in the component definition').toHaveBeenWarned()
+    expect(
+      'Method "hello" has type "object" in the component definition'
+    ).toHaveBeenWarned()
   })
 
   it('should warn methods conflicting with data', () => {
@@ -34,18 +36,22 @@ describe('Options methods', () => {
         foo: 1
       },
       methods: {
-        foo () {}
+        foo() {}
       }
     })
-    expect(`Method "foo" has already been defined as a data property`).toHaveBeenWarned()
+    expect(
+      `Method "foo" has already been defined as a data property`
+    ).toHaveBeenWarned()
   })
 
   it('should warn methods conflicting with internal methods', () => {
     new Vue({
       methods: {
-        _update () {}
+        _update() {}
       }
     })
-    expect(`Method "_update" conflicts with an existing Vue instance method`).toHaveBeenWarned()
+    expect(
+      `Method "_update" conflicts with an existing Vue instance method`
+    ).toHaveBeenWarned()
   })
 })
diff --git a/test/unit/features/options/mixins.spec.ts b/test/unit/features/options/mixins.spec.ts
index 8b71b0f355e..760e07429b2 100644
--- a/test/unit/features/options/mixins.spec.ts
+++ b/test/unit/features/options/mixins.spec.ts
@@ -46,14 +46,17 @@ describe('Options mixins', () => {
       },
       created: f2
     }
-    const result = mergeOptions({}, {
-      directives: {
-        c: c
-      },
-      template: 'bar',
-      mixins: [mixinA, mixinB],
-      created: f3
-    })
+    const result = mergeOptions(
+      {},
+      {
+        directives: {
+          c: c
+        },
+        template: 'bar',
+        mixins: [mixinA, mixinB],
+        created: f3
+      }
+    )
     expect(result.a).toBe(1)
     expect(result.b).toBe(1)
     expect(result.directives?.a).toBe(a)
@@ -79,12 +82,15 @@ describe('Options mixins', () => {
         xyz: f2
       }
     }
-    const result = mergeOptions({}, {
-      mixins: [mixinA, mixinB],
-      methods: {
-        xyz: f3
+    const result = mergeOptions(
+      {},
+      {
+        mixins: [mixinA, mixinB],
+        methods: {
+          xyz: f3
+        }
       }
-    })
+    )
     expect(result.methods?.xyz).toBe(f3)
   })
 
diff --git a/test/unit/features/options/name.spec.ts b/test/unit/features/options/name.spec.ts
index b982c9fba0e..753acf26a47 100644
--- a/test/unit/features/options/name.spec.ts
+++ b/test/unit/features/options/name.spec.ts
@@ -15,8 +15,7 @@ describe('Options name', () => {
     })
 
     /* eslint-disable */
-    expect(`Invalid component name: "Hyper*Vue".`)
-      .toHaveBeenWarned()
+    expect(`Invalid component name: "Hyper*Vue".`).toHaveBeenWarned()
     /* eslint-enable */
 
     Vue.extend({
@@ -24,8 +23,7 @@ describe('Options name', () => {
     })
 
     /* eslint-disable */
-    expect(`Invalid component name: "2Cool2BValid".`)
-      .toHaveBeenWarned()
+    expect(`Invalid component name: "2Cool2BValid".`).toHaveBeenWarned()
     /* eslint-enable */
   })
 
@@ -34,8 +32,12 @@ describe('Options name', () => {
       name: 'SuperVue'
     })!
 
-    expect(SuperComponent.options.components['SuperVue']).toEqual(SuperComponent)
-    expect(SuperComponent.options.components['super-component']).toEqual(SuperComponent)
+    expect(SuperComponent.options.components['SuperVue']).toEqual(
+      SuperComponent
+    )
+    expect(SuperComponent.options.components['super-component']).toEqual(
+      SuperComponent
+    )
   })
 
   it('should allow all potential custom element name for component name including non-alphanumeric characters', () => {
diff --git a/test/unit/features/options/parent.spec.ts b/test/unit/features/options/parent.spec.ts
index ac844713c2f..6defc783eac 100644
--- a/test/unit/features/options/parent.spec.ts
+++ b/test/unit/features/options/parent.spec.ts
@@ -3,12 +3,12 @@ import Vue from 'vue'
 describe('Options parent', () => {
   it('should work', () => {
     const parent = new Vue({
-      render () {}
+      render() {}
     }).$mount()
 
     const child = new Vue({
       parent: parent,
-      render () {}
+      render() {}
     }).$mount()
 
     // this option is straight-forward
diff --git a/test/unit/features/options/props.spec.ts b/test/unit/features/options/props.spec.ts
index 6d1978f112c..d1d2a6b00f5 100644
--- a/test/unit/features/options/props.spec.ts
+++ b/test/unit/features/options/props.spec.ts
@@ -23,10 +23,12 @@ describe('Options props', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('baz')
       vm.$refs.child.b = 'qux'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('qux')
-      expect('Avoid mutating a prop directly').toHaveBeenWarned()
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('qux')
+        expect('Avoid mutating a prop directly').toHaveBeenWarned()
+      })
+      .then(done)
   })
 
   it('object syntax', done => {
@@ -47,10 +49,12 @@ describe('Options props', () => {
     waitForUpdate(() => {
       expect(vm.$el.innerHTML).toBe('baz')
       vm.$refs.child.b = 'qux'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('qux')
-      expect('Avoid mutating a prop directly').toHaveBeenWarned()
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('qux')
+        expect('Avoid mutating a prop directly').toHaveBeenWarned()
+      })
+      .then(done)
   })
 
   it('warn mixed syntax', () => {
@@ -129,7 +133,9 @@ describe('Options props', () => {
         a: undefined
       }
     })
-    expect('Props with type Object/Array must use a factory function').toHaveBeenWarned()
+    expect(
+      'Props with type Object/Array must use a factory function'
+    ).toHaveBeenWarned()
   })
 
   it('warn missing required', () => {
@@ -137,7 +143,7 @@ describe('Options props', () => {
       template: '<test></test>',
       components: {
         test: {
-          props: { a: { required: true }},
+          props: { a: { required: true } },
           template: '<div>{{a}}</div>'
         }
       }
@@ -146,7 +152,7 @@ describe('Options props', () => {
   })
 
   describe('assertions', () => {
-    function makeInstance (value, type, validator?, required?) {
+    function makeInstance(value, type, validator?, required?) {
       return new Vue({
         template: '<test :test="val"></test>',
         data: {
@@ -171,14 +177,18 @@ describe('Options props', () => {
       makeInstance('hello', String)
       expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance(123, String)
-      expect('Expected String with value "123", got Number with value 123').toHaveBeenWarned()
+      expect(
+        'Expected String with value "123", got Number with value 123'
+      ).toHaveBeenWarned()
     })
 
     it('number', () => {
       makeInstance(123, Number)
       expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance('123', Number)
-      expect('Expected Number with value 123, got String with value "123"').toHaveBeenWarned()
+      expect(
+        'Expected Number with value 123, got String with value "123"'
+      ).toHaveBeenWarned()
     })
 
     it('number & boolean', () => {
@@ -264,7 +274,7 @@ describe('Options props', () => {
     }
 
     it('custom constructor', () => {
-      function Class () {}
+      function Class() {}
       makeInstance(new Class(), Class)
       expect((console.error as any).mock.calls.length).toBe(0)
       makeInstance({}, Class)
@@ -291,7 +301,9 @@ describe('Options props', () => {
       makeInstance(123, Number, v => v === 234)
       expect('custom validator check failed').toHaveBeenWarned()
       makeInstance(123, String, v => v === 123)
-      expect('Expected String with value "123", got Number with value 123').toHaveBeenWarned()
+      expect(
+        'Expected String with value "123", got Number with value 123'
+      ).toHaveBeenWarned()
     })
 
     it('multiple types + custom validator', () => {
@@ -374,9 +386,7 @@ describe('Options props', () => {
             a: null
           },
           methods: {
-            a () {
-
-            }
+            a() {}
           }
         }
       }
@@ -525,16 +535,21 @@ describe('Options props', () => {
     waitForUpdate(() => {
       expect(spy).not.toHaveBeenCalled()
       vm.b = {}
-    }).then(() => {
-      expect(spy.mock.calls.length).toBe(1)
-    }).then(() => {
-      vm.b = undefined
-    }).then(() => {
-      expect(spy.mock.calls.length).toBe(2)
-      vm.a++
-    }).then(() => {
-      expect(spy.mock.calls.length).toBe(2)
-    }).then(done)
+    })
+      .then(() => {
+        expect(spy.mock.calls.length).toBe(1)
+      })
+      .then(() => {
+        vm.b = undefined
+      })
+      .then(() => {
+        expect(spy.mock.calls.length).toBe(2)
+        vm.a++
+      })
+      .then(() => {
+        expect(spy.mock.calls.length).toBe(2)
+      })
+      .then(done)
   })
 
   it('warn reserved props', () => {
@@ -578,5 +593,4 @@ describe('Options props', () => {
       'Invalid prop type: "String" is not a constructor'
     ).toHaveBeenWarned()
   })
-
 })
diff --git a/test/unit/features/options/propsData.spec.ts b/test/unit/features/options/propsData.spec.ts
index 9fa5557ef07..bc364581a28 100644
--- a/test/unit/features/options/propsData.spec.ts
+++ b/test/unit/features/options/propsData.spec.ts
@@ -25,6 +25,8 @@ describe('Options propsData', () => {
         a: 123
       }
     })
-    expect('option "propsData" can only be used during instance creation').toHaveBeenWarned()
+    expect(
+      'option "propsData" can only be used during instance creation'
+    ).toHaveBeenWarned()
   })
 })
diff --git a/test/unit/features/options/render.spec.ts b/test/unit/features/options/render.spec.ts
index 736afa2ca4d..7bccefdc1f1 100644
--- a/test/unit/features/options/render.spec.ts
+++ b/test/unit/features/options/render.spec.ts
@@ -3,7 +3,7 @@ import Vue from 'vue'
 describe('Options render', () => {
   it('basic usage', () => {
     const vm = new Vue({
-      render (h) {
+      render(h) {
         const children: any[] = []
         for (let i = 0; i < this.items.length; i++) {
           children.push(h('li', { staticClass: 'task' }, [this.items[i].name]))
@@ -11,7 +11,10 @@ describe('Options render', () => {
         return h('ul', { staticClass: 'tasks' }, children)
       },
       data: {
-        items: [{ id: 1, name: 'task1' }, { id: 2, name: 'task2' }]
+        items: [
+          { id: 1, name: 'task1' },
+          { id: 2, name: 'task2' }
+        ]
       }
     }).$mount()
     expect(vm.$el.tagName).toBe('UL')
@@ -24,7 +27,7 @@ describe('Options render', () => {
 
   it('allow null data', () => {
     const vm = new Vue({
-      render (h) {
+      render(h) {
         return h('div', null, 'hello' /* string as children*/)
       }
     }).$mount()
@@ -34,6 +37,8 @@ describe('Options render', () => {
 
   it('should warn non `render` option and non `template` option', () => {
     new Vue().$mount()
-    expect('Failed to mount component: template or render function not defined.').toHaveBeenWarned()
+    expect(
+      'Failed to mount component: template or render function not defined.'
+    ).toHaveBeenWarned()
   })
 })
diff --git a/test/unit/features/options/renderError.spec.ts b/test/unit/features/options/renderError.spec.ts
index d25c4f48a5c..6ca0a590f58 100644
--- a/test/unit/features/options/renderError.spec.ts
+++ b/test/unit/features/options/renderError.spec.ts
@@ -7,14 +7,14 @@ describe('Options renderError', () => {
       data: {
         ok: true
       },
-      render (h) {
+      render(h) {
         if (this.ok) {
           return h('div', 'ok')
         } else {
           throw new Error('no')
         }
       },
-      renderError (h, err) {
+      renderError(h, err) {
         return h('div', err.toString())
       }
     }).$mount()
@@ -27,13 +27,13 @@ describe('Options renderError', () => {
   })
 
   it('should pass on errors in renderError to global handler', () => {
-    const spy = Vue.config.errorHandler = vi.fn()
+    const spy = (Vue.config.errorHandler = vi.fn())
     const err = new Error('renderError')
     const vm = new Vue({
-      render () {
+      render() {
         throw new Error('render')
       },
-      renderError () {
+      renderError() {
         throw err
       }
     }).$mount()
diff --git a/test/unit/features/options/template.spec.ts b/test/unit/features/options/template.spec.ts
index 09aafd3efaa..e4ed15a38c1 100644
--- a/test/unit/features/options/template.spec.ts
+++ b/test/unit/features/options/template.spec.ts
@@ -53,19 +53,24 @@ describe('Options template', () => {
 
   it('warn error in generated function', () => {
     new Vue({
-      template: '<div v-if="!@"><span>{{ a"" }}</span><span>{{ do + 1 }}</span></div>'
+      template:
+        '<div v-if="!@"><span>{{ a"" }}</span><span>{{ do + 1 }}</span></div>'
     }).$mount()
     expect('Error compiling template').toHaveBeenWarned()
     expect('Raw expression: v-if="!@"').toHaveBeenWarned()
     expect('Raw expression: {{ a"" }}').toHaveBeenWarned()
-    expect('avoid using JavaScript keyword as property name: "do"').toHaveBeenWarned()
+    expect(
+      'avoid using JavaScript keyword as property name: "do"'
+    ).toHaveBeenWarned()
   })
 
   it('should not warn $ prefixed keywords', () => {
     new Vue({
       template: `<div @click="$delete(foo, 'bar')"></div>`
     }).$mount()
-    expect('avoid using JavaScript keyword as property name').not.toHaveBeenWarned()
+    expect(
+      'avoid using JavaScript keyword as property name'
+    ).not.toHaveBeenWarned()
   })
 
   it('warn error in generated function (v-for)', () => {
diff --git a/test/unit/features/options/watch.spec.ts b/test/unit/features/options/watch.spec.ts
index edd298066b9..d092e21224b 100644
--- a/test/unit/features/options/watch.spec.ts
+++ b/test/unit/features/options/watch.spec.ts
@@ -85,7 +85,7 @@ describe('Options watch', () => {
 
   it('with option: deep', done => {
     const vm = new Vue({
-      data: { a: { b: 1 }},
+      data: { a: { b: 1 } },
       watch: {
         a: {
           handler: spy,
@@ -100,9 +100,11 @@ describe('Options watch', () => {
     waitForUpdate(() => {
       expect(spy).toHaveBeenCalledWith(vm.a, vm.a)
       vm.a = { b: 3 }
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.a, oldA)
-    }).then(done)
+    })
+      .then(() => {
+        expect(spy).toHaveBeenCalledWith(vm.a, oldA)
+      })
+      .then(done)
   })
 
   it('correctly merges multiple extends', done => {
@@ -169,7 +171,7 @@ describe('Options watch', () => {
       },
       watch: {
         'foo._bar': () => {},
-        prop1 () {}
+        prop1() {}
       }
     })
     expect(`Failed watching path`).not.toHaveBeenWarned()
diff --git a/test/unit/features/ref.spec.ts b/test/unit/features/ref.spec.ts
index 880a6ca67c9..0629e14abb0 100644
--- a/test/unit/features/ref.spec.ts
+++ b/test/unit/features/ref.spec.ts
@@ -1,17 +1,16 @@
 import Vue from 'vue'
 
 describe('ref', () => {
-  
-  type TestShape = { 
-    id: string,
-    template: string,
+  type TestShape = {
+    id: string
+    template: string
     data?: any
     components?: any
   }
   type ComponentShape = {
-    test: TestShape,
-    test2: TestShape,
-    test3: TestShape,
+    test: TestShape
+    test2: TestShape
+    test3: TestShape
   }
   const components: ComponentShape = {
     test: {
@@ -67,10 +66,8 @@ describe('ref', () => {
   it('should work as a hyperscript prop', () => {
     const vm = new Vue({
       components,
-      render (h) {
-        return h('div', null, [
-          h('test', { ref: 'test' })
-        ])
+      render(h) {
+        return h('div', null, [h('test', { ref: 'test' })])
       }
     })
     vm.$mount()
@@ -102,9 +99,11 @@ describe('ref', () => {
     waitForUpdate(() => {
       expect(vm.$refs.test.$options.id).toBe('test2')
       vm.test = ''
-    }).then(() => {
-      expect(vm.$refs.test).toBeUndefined()
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$refs.test).toBeUndefined()
+      })
+      .then(done)
   })
 
   it('should register as Array when used with v-for', done => {
@@ -122,14 +121,18 @@ describe('ref', () => {
     // updating
     vm.items.push(4)
     waitForUpdate(assertRefs)
-      .then(() => { vm.items = [] })
+      .then(() => {
+        vm.items = []
+      })
       .then(assertRefs)
       .then(done)
 
-    function assertRefs () {
+    function assertRefs() {
       expect(Array.isArray(vm.$refs.list)).toBe(true)
       expect(vm.$refs.list.length).toBe(vm.items.length)
-      expect(vm.$refs.list.every((item, i) => item.textContent === String(i + 1))).toBe(true)
+      expect(
+        vm.$refs.list.every((item, i) => item.textContent === String(i + 1))
+      ).toBe(true)
     }
   })
 
@@ -154,14 +157,18 @@ describe('ref', () => {
     // updating
     vm.items.push(4)
     waitForUpdate(assertRefs)
-      .then(() => { vm.items = [] })
+      .then(() => {
+        vm.items = []
+      })
       .then(assertRefs)
       .then(done)
 
-    function assertRefs () {
+    function assertRefs() {
       expect(Array.isArray(vm.$refs.list)).toBe(true)
       expect(vm.$refs.list.length).toBe(vm.items.length)
-      expect(vm.$refs.list.every((comp, i) => comp.$el.textContent === String(i + 1))).toBe(true)
+      expect(
+        vm.$refs.list.every((comp, i) => comp.$el.textContent === String(i + 1))
+      ).toBe(true)
     }
   })
 
@@ -169,7 +176,7 @@ describe('ref', () => {
     components.test3 = {
       id: 'test3',
       template: `<test1 v-if="!normal"></test1><div v-else>test3</div>`,
-      data () {
+      data() {
         return { normal: false }
       },
       components: { test1: components.test }
@@ -200,16 +207,20 @@ describe('ref', () => {
     vm.$refs.children[1].normal = true
     testContent = true
     waitForUpdate(assertRefs)
-      .then(() => { vm.items.push('test') })
+      .then(() => {
+        vm.items.push('test')
+      })
       .then(assertRefs)
       .then(done)
 
-    function assertRefs () {
+    function assertRefs() {
       expect(Array.isArray(vm.$refs.children)).toBe(true)
       expect(vm.$refs.children.length).toBe(vm.items.length)
       if (testContent) {
         expect(
-          vm.$refs.children.every((comp, i) => comp.$el.textContent === vm.items[i])
+          vm.$refs.children.every(
+            (comp, i) => comp.$el.textContent === vm.items[i]
+          )
         ).toBe(true)
       }
     }
@@ -221,7 +232,7 @@ describe('ref', () => {
       components: {
         child: {
           template: '<div v-if="show"></div>',
-          data () {
+          data() {
             return { show: false }
           }
         }
@@ -232,8 +243,10 @@ describe('ref', () => {
     waitForUpdate(() => {
       expect(vm.$refs.test).toBe(vm.$children[0])
       vm.$refs.test.show = false
-    }).then(() => {
-      expect(vm.$refs.test).toBe(vm.$children[0])
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$refs.test).toBe(vm.$children[0])
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/modules/compiler/codeframe.spec.ts b/test/unit/modules/compiler/codeframe.spec.ts
index 318bcdc84df..4ed904d78bf 100644
--- a/test/unit/modules/compiler/codeframe.spec.ts
+++ b/test/unit/modules/compiler/codeframe.spec.ts
@@ -14,39 +14,45 @@ describe('codeframe', () => {
   it('line near top', () => {
     const keyStart = source.indexOf(`key="one"`)
     const keyEnd = keyStart + `key="one"`.length
-    expect(generateCodeFrame(source, keyStart, keyEnd)).toBe(`
+    expect(generateCodeFrame(source, keyStart, keyEnd)).toBe(
+      `
 1  |  <div>
 2  |    <template key="one"></template>
    |              ^^^^^^^^^
 3  |    <ul>
 4  |      <li v-for="foobar">hi</li>
-    `.trim())
+    `.trim()
+    )
   })
 
   it('line in middle', () => {
     // should cover 5 lines
     const forStart = source.indexOf(`v-for=`)
     const forEnd = forStart + `v-for="foobar"`.length
-    expect(generateCodeFrame(source, forStart, forEnd)).toBe(`
+    expect(generateCodeFrame(source, forStart, forEnd)).toBe(
+      `
 2  |    <template key="one"></template>
 3  |    <ul>
 4  |      <li v-for="foobar">hi</li>
    |          ^^^^^^^^^^^^^^
 5  |    </ul>
 6  |    <template key="two"></template>
-    `.trim())
+    `.trim()
+    )
   })
 
   it('line near bottom', () => {
     const keyStart = source.indexOf(`key="two"`)
     const keyEnd = keyStart + `key="two"`.length
-    expect(generateCodeFrame(source, keyStart, keyEnd)).toBe(`
+    expect(generateCodeFrame(source, keyStart, keyEnd)).toBe(
+      `
 4  |      <li v-for="foobar">hi</li>
 5  |    </ul>
 6  |    <template key="two"></template>
    |              ^^^^^^^^^
 7  |  </div>
-    `.trim())
+    `.trim()
+    )
   })
 
   it('multi-line highlights', () => {
@@ -60,7 +66,8 @@ attr
 
     const attrStart = source.indexOf(`attr=`)
     const attrEnd = source.indexOf(`">`) + 1
-    expect(generateCodeFrame(source, attrStart, attrEnd)).toBe(`
+    expect(generateCodeFrame(source, attrStart, attrEnd)).toBe(
+      `
 1  |  <div attr="some
    |       ^^^^^^^^^^
 2  |    multiline
@@ -69,6 +76,7 @@ attr
    |  ^^^^
 4  |  ">
    |  ^
-    `.trim())
+    `.trim()
+    )
   })
 })
diff --git a/test/unit/modules/compiler/codegen.spec.ts b/test/unit/modules/compiler/codegen.spec.ts
index 5c18388d6e0..fe1ea829c60 100644
--- a/test/unit/modules/compiler/codegen.spec.ts
+++ b/test/unit/modules/compiler/codegen.spec.ts
@@ -5,7 +5,7 @@ import { isObject, extend } from 'shared/util'
 import { isReservedTag } from 'web/util/index'
 import { baseOptions } from 'web/compiler/options'
 
-function assertCodegen (template, generatedCode, ...args) {
+function assertCodegen(template, generatedCode, ...args) {
   let staticRenderFnCodes = []
   let generateOptions = baseOptions
   let proc = null
@@ -258,7 +258,7 @@ describe('codegen', () => {
     // static
     assertCodegen(
       '<p class="class1">hello world</p>',
-      `with(this){return _c('p',{staticClass:"class1"},[_v("hello world")])}`,
+      `with(this){return _c('p',{staticClass:"class1"},[_v("hello world")])}`
     )
     // dynamic
     assertCodegen(
@@ -360,7 +360,7 @@ describe('codegen', () => {
     )
     // function with multiple args
     assertCodegen(
-      '<input @input="onInput1($event, \'text\');onInput2(\'text2\', $event)">',
+      "<input @input=\"onInput1($event, 'text');onInput2('text2', $event)\">",
       `with(this){return _c('input',{on:{"input":function($event){onInput1($event, 'text');onInput2('text2', $event)}}})}`
     )
   })
@@ -621,7 +621,9 @@ describe('codegen', () => {
       '<div is="myComponent" inline-template></div>',
       `with(this){return _c("myComponent",{tag:"div"})}`
     )
-    expect('Inline-template components must have exactly one child element.').toHaveBeenWarned()
+    expect(
+      'Inline-template components must have exactly one child element.'
+    ).toHaveBeenWarned()
     expect(console.error.mock.calls.length).toBe(3)
   })
 
@@ -642,9 +644,12 @@ describe('codegen', () => {
   })
 
   it('generate component with comment', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
+    const options = extend(
+      {
+        comments: true
+      },
+      baseOptions
+    )
     const template = '<div><!--comment--></div>'
     const generatedCode = `with(this){return _c('div',[_e("comment")])}`
 
@@ -656,10 +661,13 @@ describe('codegen', () => {
 
   // #6150
   it('generate comments with special characters', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const template = '<div><!--\n\'comment\'\n--></div>'
+    const options = extend(
+      {
+        comments: true
+      },
+      baseOptions
+    )
+    const template = "<div><!--\n'comment'\n--></div>"
     const generatedCode = `with(this){return _c('div',[_e("\\n'comment'\\n")])}`
 
     const ast = parse(template, options)
diff --git a/test/unit/modules/compiler/compiler-options.spec.ts b/test/unit/modules/compiler/compiler-options.spec.ts
index a0cfcdde5ca..865ad0b30c9 100644
--- a/test/unit/modules/compiler/compiler-options.spec.ts
+++ b/test/unit/modules/compiler/compiler-options.spec.ts
@@ -4,65 +4,75 @@ import { getAndRemoveAttr } from 'compiler/helpers'
 
 describe('compile options', () => {
   it('should be compiled', () => {
-    const { render, staticRenderFns, errors } = compile(`
+    const { render, staticRenderFns, errors } = compile(
+      `
       <div>
         <input type="text" v-model="msg" required max="8" v-validate:field1.group1.group2>
       </div>
-    `, {
-      directives: {
-        validate (el, dir) {
-          if (dir.name === 'validate' && dir.arg) {
-            el.validate = {
-              field: dir.arg,
-              groups: dir.modifiers ? Object.keys(dir.modifiers) : []
+    `,
+      {
+        directives: {
+          validate(el, dir) {
+            if (dir.name === 'validate' && dir.arg) {
+              el.validate = {
+                field: dir.arg,
+                groups: dir.modifiers ? Object.keys(dir.modifiers) : []
+              }
             }
           }
-        }
-      },
-      modules: [
-        {
-          transformNode (el) {
-            el.validators = el.validators || []
-            const validators = ['required', 'min', 'max', 'pattern', 'maxlength', 'minlength']
-            validators.forEach(name => {
-              const rule = getAndRemoveAttr(el, name)
-              if (rule !== undefined) {
-                el.validators.push({ name, rule })
+        },
+        modules: [
+          {
+            transformNode(el) {
+              el.validators = el.validators || []
+              const validators = [
+                'required',
+                'min',
+                'max',
+                'pattern',
+                'maxlength',
+                'minlength'
+              ]
+              validators.forEach(name => {
+                const rule = getAndRemoveAttr(el, name)
+                if (rule !== undefined) {
+                  el.validators.push({ name, rule })
+                }
+              })
+            },
+            genData(el) {
+              let data = ''
+              if (el.validate) {
+                data += `validate:${JSON.stringify(el.validate)},`
               }
-            })
-          },
-          genData (el) {
-            let data = ''
-            if (el.validate) {
-              data += `validate:${JSON.stringify(el.validate)},`
-            }
-            if (el.validators) {
-              data += `validators:${JSON.stringify(el.validators)},`
-            }
-            return data
-          },
-          transformCode (el, code) {
-            // check
-            if (!el.validate || !el.validators) {
-              return code
-            }
-            // setup validation result props
-            const result = { dirty: false } // define something other prop
-            el.validators.forEach(validator => {
-              result[validator.name] = null
-            })
-            // generate code
-            return `_c('validate',{props:{
+              if (el.validators) {
+                data += `validators:${JSON.stringify(el.validators)},`
+              }
+              return data
+            },
+            transformCode(el, code) {
+              // check
+              if (!el.validate || !el.validators) {
+                return code
+              }
+              // setup validation result props
+              const result = { dirty: false } // define something other prop
+              el.validators.forEach(validator => {
+                result[validator.name] = null
+              })
+              // generate code
+              return `_c('validate',{props:{
               field:${JSON.stringify(el.validate.field)},
               groups:${JSON.stringify(el.validate.groups)},
               validators:${JSON.stringify(el.validators)},
               result:${JSON.stringify(result)},
               child:${code}}
             })`
+            }
           }
-        }
-      ]
-    })
+        ]
+      }
+    )
     expect(render).not.toBeUndefined()
     expect(staticRenderFns).toEqual([])
     expect(errors).toEqual([])
@@ -75,11 +85,11 @@ describe('compile options', () => {
       components: {
         validate: {
           props: ['field', 'groups', 'validators', 'result', 'child'],
-          render (h) {
+          render(h) {
             return this.child
           },
           computed: {
-            valid () {
+            valid() {
               let ret = true
               for (let i = 0; i < this.validators.length; i++) {
                 const { name } = this.validators[i]
@@ -91,7 +101,7 @@ describe('compile options', () => {
               return ret
             }
           },
-          mounted () {
+          mounted() {
             // initialize validation
             const value = this.$el.value
             this.validators.forEach(validator => {
@@ -101,10 +111,10 @@ describe('compile options', () => {
           },
           methods: {
             // something validators logic
-            required (val) {
+            required(val) {
               return val.length > 0
             },
-            max (val, rule) {
+            max(val, rule) {
               return !(parseInt(val, 10) > parseInt(rule, 10))
             }
           }
@@ -134,7 +144,9 @@ describe('compile options', () => {
     expect(compiled.errors[0].start).toBe(0)
     expect(compiled.errors[0].end).toBeUndefined()
 
-    compiled = compile('<div v-if="a----">{{ b++++ }}</div>', { outputSourceRange: true })
+    compiled = compile('<div v-if="a----">{{ b++++ }}</div>', {
+      outputSourceRange: true
+    })
     expect(compiled.errors.length).toBe(2)
     expect(compiled.errors[0].start).toBe(5)
     expect(compiled.errors[0].end).toBe(17)
@@ -148,7 +160,9 @@ describe('compile options', () => {
   })
 
   it('should collect source range for binding keys', () => {
-    const compiled = compile('<div><slot v-bind:key="key" /></div>', { outputSourceRange: true })
+    const compiled = compile('<div><slot v-bind:key="key" /></div>', {
+      outputSourceRange: true
+    })
     expect(compiled.errors.length).toBe(1)
     expect(compiled.errors[0].start).toBe(11)
     expect(compiled.errors[0].end).toBe(27)
diff --git a/test/unit/modules/compiler/optimizer.spec.ts b/test/unit/modules/compiler/optimizer.spec.ts
index c807908044b..a2b9e351ae3 100644
--- a/test/unit/modules/compiler/optimizer.spec.ts
+++ b/test/unit/modules/compiler/optimizer.spec.ts
@@ -5,7 +5,10 @@ import { baseOptions } from 'web/compiler/options'
 
 describe('optimizer', () => {
   it('simple', () => {
-    const ast = parse('<h1 id="section1"><span>hello world</span></h1>', baseOptions)
+    const ast = parse(
+      '<h1 id="section1"><span>hello world</span></h1>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(true) // h1
     expect(ast.staticRoot).toBe(true)
@@ -13,10 +16,16 @@ describe('optimizer', () => {
   })
 
   it('simple with comment', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
-    const ast = parse('<h1 id="section1"><span>hello world</span><!--comment--></h1>', options)
+    const options = extend(
+      {
+        comments: true
+      },
+      baseOptions
+    )
+    const ast = parse(
+      '<h1 id="section1"><span>hello world</span><!--comment--></h1>',
+      options
+    )
     optimize(ast, options)
     expect(ast.static).toBe(true) // h1
     expect(ast.staticRoot).toBe(true)
@@ -54,7 +63,10 @@ describe('optimizer', () => {
   })
 
   it('nested complex elements', () => {
-    const ast = parse('<ul><li>{{msg1}}</li><li>---</li><li>{{msg2}}</li></ul>', baseOptions)
+    const ast = parse(
+      '<ul><li>{{msg1}}</li><li>---</li><li>{{msg2}}</li></ul>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     // ul
     expect(ast.static).toBe(false) // ul
@@ -69,14 +81,20 @@ describe('optimizer', () => {
   })
 
   it('v-if directive', () => {
-    const ast = parse('<div id="section1" v-if="show"><p><span>hello world</span></p></div>', baseOptions)
+    const ast = parse(
+      '<div id="section1" v-if="show"><p><span>hello world</span></p></div>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(false)
     expect(ast.children[0].static).toBe(true)
   })
 
   it('v-else directive', () => {
-    const ast = parse('<div><p v-if="show">hello world</p><div v-else><p><span>foo bar</span></p></div></div>', baseOptions)
+    const ast = parse(
+      '<div><p v-if="show">hello world</p><div v-else><p><span>foo bar</span></p></div></div>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(false)
     expect(ast.children[0].static).toBe(false)
@@ -87,7 +105,10 @@ describe('optimizer', () => {
   })
 
   it('v-pre directive', () => {
-    const ast = parse('<ul v-pre><li>{{msg}}</li><li>world</li></ul>', baseOptions)
+    const ast = parse(
+      '<ul v-pre><li>{{msg}}</li><li>world</li></ul>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(true)
     expect(ast.staticRoot).toBe(true)
@@ -98,7 +119,10 @@ describe('optimizer', () => {
   })
 
   it('v-for directive', () => {
-    const ast = parse('<ul><li v-for="item in items">hello world {{$index}}</li></ul>', baseOptions)
+    const ast = parse(
+      '<ul><li v-for="item in items">hello world {{$index}}</li></ul>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     // ul
     expect(ast.static).toBe(false)
@@ -122,7 +146,10 @@ describe('optimizer', () => {
   })
 
   it('named slot', () => {
-    const ast = parse('<div><slot name="one">hello world</slot></div>', baseOptions)
+    const ast = parse(
+      '<div><slot name="one">hello world</slot></div>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.children[0].static).toBe(false) // slot
     expect(ast.children[0].children[0].static).toBe(true) // text node
@@ -142,7 +169,10 @@ describe('optimizer', () => {
   })
 
   it('component for inline-template', () => {
-    const ast = parse('<my-component inline-template><p>hello world</p><p>{{msg}}</p></my-component>', baseOptions)
+    const ast = parse(
+      '<my-component inline-template><p>hello world</p><p>{{msg}}</p></my-component>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     // component
     expect(ast.static).toBe(false) // component
@@ -183,26 +213,38 @@ describe('optimizer', () => {
   })
 
   it('transition', () => {
-    const ast = parse('<p v-if="show" transition="expand">hello world</p>', baseOptions)
+    const ast = parse(
+      '<p v-if="show" transition="expand">hello world</p>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(false)
     expect(ast.children[0].static).toBe(true)
   })
 
   it('v-bind directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg">', baseOptions)
+    const ast = parse(
+      '<input type="text" name="field1" :value="msg">',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(false)
   })
 
   it('v-on directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" @input="onInput">', baseOptions)
+    const ast = parse(
+      '<input type="text" name="field1" :value="msg" @input="onInput">',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(false)
   })
 
   it('custom directive', () => {
-    const ast = parse('<form><input type="text" name="field1" :value="msg" v-validate:field1="required"></form>', baseOptions)
+    const ast = parse(
+      '<form><input type="text" name="field1" :value="msg" v-validate:field1="required"></form>',
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.static).toBe(false)
     expect(ast.children[0].static).toBe(false)
@@ -221,14 +263,18 @@ describe('optimizer', () => {
   })
 
   it('mark static trees inside v-for', () => {
-    const ast = parse(`<div><div v-for="i in 10"><p><span>hi</span></p></div></div>`, baseOptions)
+    const ast = parse(
+      `<div><div v-for="i in 10"><p><span>hi</span></p></div></div>`,
+      baseOptions
+    )
     optimize(ast, baseOptions)
     expect(ast.children[0].children[0].staticRoot).toBe(true)
     expect(ast.children[0].children[0].staticInFor).toBe(true)
   })
 
   it('mark static trees inside v-for with nested v-else and v-once', () => {
-    const ast = parse(`
+    const ast = parse(
+      `
       <div v-if="1"></div>
       <div v-else-if="2">
         <div v-for="i in 10" :key="i">
@@ -243,15 +289,35 @@ describe('optimizer', () => {
           <div v-else v-once>{{ i }}</div>
         </div>
       </div>
-      `, baseOptions)
+      `,
+      baseOptions
+    )
     optimize(ast, baseOptions)
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[1].block.staticRoot).toBe(false)
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[1].block.staticInFor).toBe(true)
+    expect(
+      ast.ifConditions[1].block.children[0].children[0].ifConditions[1].block
+        .staticRoot
+    ).toBe(false)
+    expect(
+      ast.ifConditions[1].block.children[0].children[0].ifConditions[1].block
+        .staticInFor
+    ).toBe(true)
 
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[2].block.staticRoot).toBe(false)
-    expect(ast.ifConditions[1].block.children[0].children[0].ifConditions[2].block.staticInFor).toBe(true)
+    expect(
+      ast.ifConditions[1].block.children[0].children[0].ifConditions[2].block
+        .staticRoot
+    ).toBe(false)
+    expect(
+      ast.ifConditions[1].block.children[0].children[0].ifConditions[2].block
+        .staticInFor
+    ).toBe(true)
 
-    expect(ast.ifConditions[2].block.children[0].children[0].ifConditions[1].block.staticRoot).toBe(false)
-    expect(ast.ifConditions[2].block.children[0].children[0].ifConditions[1].block.staticInFor).toBe(true)
+    expect(
+      ast.ifConditions[2].block.children[0].children[0].ifConditions[1].block
+        .staticRoot
+    ).toBe(false)
+    expect(
+      ast.ifConditions[2].block.children[0].children[0].ifConditions[1].block
+        .staticInFor
+    ).toBe(true)
   })
 })
diff --git a/test/unit/modules/compiler/parser.spec.ts b/test/unit/modules/compiler/parser.spec.ts
index 1e6f1567335..4fb272f3b0e 100644
--- a/test/unit/modules/compiler/parser.spec.ts
+++ b/test/unit/modules/compiler/parser.spec.ts
@@ -46,7 +46,10 @@ describe('parser', () => {
   })
 
   it('camelCase element', () => {
-    const ast = parse('<MyComponent><p>hello world</p></MyComponent>', baseOptions)
+    const ast = parse(
+      '<MyComponent><p>hello world</p></MyComponent>',
+      baseOptions
+    )
     expect(ast.tag).toBe('MyComponent')
     expect(ast.plain).toBe(true)
     expect(ast.children[0].tag).toBe('p')
@@ -62,34 +65,49 @@ describe('parser', () => {
     expect(styleAst.plain).toBe(true)
     expect(styleAst.forbidden).toBe(true)
     expect(styleAst.children[0].text).toBe('error { color: red; }')
-    expect('Templates should only be responsible for mapping the state').toHaveBeenWarned()
+    expect(
+      'Templates should only be responsible for mapping the state'
+    ).toHaveBeenWarned()
     // script
-    const scriptAst = parse('<script type="text/javascript">alert("hello world!")</script>', baseOptions)
+    const scriptAst = parse(
+      '<script type="text/javascript">alert("hello world!")</script>',
+      baseOptions
+    )
     expect(scriptAst.tag).toBe('script')
     expect(scriptAst.plain).toBe(false)
     expect(scriptAst.forbidden).toBe(true)
     expect(scriptAst.children[0].text).toBe('alert("hello world!")')
-    expect('Templates should only be responsible for mapping the state').toHaveBeenWarned()
+    expect(
+      'Templates should only be responsible for mapping the state'
+    ).toHaveBeenWarned()
   })
 
   it('not contain root element', () => {
     parse('hello world', baseOptions)
-    expect('Component template requires a root element, rather than just text').toHaveBeenWarned()
+    expect(
+      'Component template requires a root element, rather than just text'
+    ).toHaveBeenWarned()
   })
 
   it('warn text before root element', () => {
     parse('before root {{ interpolation }}<div></div>', baseOptions)
-    expect('text "before root {{ interpolation }}" outside root element will be ignored.').toHaveBeenWarned()
+    expect(
+      'text "before root {{ interpolation }}" outside root element will be ignored.'
+    ).toHaveBeenWarned()
   })
 
   it('warn text after root element', () => {
     parse('<div></div>after root {{ interpolation }}', baseOptions)
-    expect('text "after root {{ interpolation }}" outside root element will be ignored.').toHaveBeenWarned()
+    expect(
+      'text "after root {{ interpolation }}" outside root element will be ignored.'
+    ).toHaveBeenWarned()
   })
 
   it('warn multiple root elements', () => {
     parse('<div></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
+    expect(
+      'Component template should contain exactly one root element'
+    ).toHaveBeenWarned()
   })
 
   it('remove duplicate whitespace text nodes caused by comments', () => {
@@ -101,7 +119,10 @@ describe('parser', () => {
   })
 
   it('remove text nodes between v-if conditions', () => {
-    const ast = parse(`<div><div v-if="1"></div> <div v-else-if="2"></div> <div v-else></div> <span></span></div>`, baseOptions)
+    const ast = parse(
+      `<div><div v-if="1"></div> <div v-else-if="2"></div> <div v-else></div> <span></span></div>`,
+      baseOptions
+    )
     expect(ast.children.length).toBe(3)
     expect(ast.children[0].tag).toBe('div')
     expect(ast.children[0].ifConditions.length).toBe(3)
@@ -111,77 +132,105 @@ describe('parser', () => {
 
   it('warn non whitespace text between v-if conditions', () => {
     parse(`<div><div v-if="1"></div> foo <div v-else></div></div>`, baseOptions)
-    expect(`text "foo" between v-if and v-else(-if) will be ignored`).toHaveBeenWarned()
+    expect(
+      `text "foo" between v-if and v-else(-if) will be ignored`
+    ).toHaveBeenWarned()
   })
 
   it('not warn 2 root elements with v-if and v-else', () => {
     parse('<div v-if="1"></div><div v-else></div>', baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
+    expect(
+      'Component template should contain exactly one root element'
+    ).not.toHaveBeenWarned()
   })
 
   it('not warn 3 root elements with v-if, v-else-if and v-else', () => {
-    parse('<div v-if="1"></div><div v-else-if="2"></div><div v-else></div>', baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
+    parse(
+      '<div v-if="1"></div><div v-else-if="2"></div><div v-else></div>',
+      baseOptions
+    )
+    expect(
+      'Component template should contain exactly one root element'
+    ).not.toHaveBeenWarned()
   })
 
   it('not warn 2 root elements with v-if and v-else on separate lines', () => {
-    parse(`
+    parse(
+      `
       <div v-if="1"></div>
       <div v-else></div>
-    `, baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
+    `,
+      baseOptions
+    )
+    expect(
+      'Component template should contain exactly one root element'
+    ).not.toHaveBeenWarned()
   })
 
   it('not warn 3 or more root elements with v-if, v-else-if and v-else on separate lines', () => {
-    parse(`
+    parse(
+      `
       <div v-if="1"></div>
       <div v-else-if="2"></div>
       <div v-else></div>
-    `, baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
-
-    parse(`
+    `,
+      baseOptions
+    )
+    expect(
+      'Component template should contain exactly one root element'
+    ).not.toHaveBeenWarned()
+
+    parse(
+      `
       <div v-if="1"></div>
       <div v-else-if="2"></div>
       <div v-else-if="3"></div>
       <div v-else-if="4"></div>
       <div v-else></div>
-    `, baseOptions)
-    expect('Component template should contain exactly one root element')
-      .not.toHaveBeenWarned()
+    `,
+      baseOptions
+    )
+    expect(
+      'Component template should contain exactly one root element'
+    ).not.toHaveBeenWarned()
   })
 
   it('generate correct ast for 2 root elements with v-if and v-else on separate lines', () => {
-    const ast = parse(`
+    const ast = parse(
+      `
       <div v-if="1"></div>
       <p v-else></p>
-    `, baseOptions)
+    `,
+      baseOptions
+    )
     expect(ast.tag).toBe('div')
     expect(ast.ifConditions[1].block.tag).toBe('p')
   })
 
   it('generate correct ast for 3 or more root elements with v-if and v-else on separate lines', () => {
-    const ast = parse(`
+    const ast = parse(
+      `
       <div v-if="1"></div>
       <span v-else-if="2"></span>
       <p v-else></p>
-    `, baseOptions)
+    `,
+      baseOptions
+    )
     expect(ast.tag).toBe('div')
     expect(ast.ifConditions[0].block.tag).toBe('div')
     expect(ast.ifConditions[1].block.tag).toBe('span')
     expect(ast.ifConditions[2].block.tag).toBe('p')
 
-    const astMore = parse(`
+    const astMore = parse(
+      `
       <div v-if="1"></div>
       <span v-else-if="2"></span>
       <div v-else-if="3"></div>
       <span v-else-if="4"></span>
       <p v-else></p>
-    `, baseOptions)
+    `,
+      baseOptions
+    )
     expect(astMore.tag).toBe('div')
     expect(astMore.ifConditions[0].block.tag).toBe('div')
     expect(astMore.ifConditions[1].block.tag).toBe('span')
@@ -192,34 +241,53 @@ describe('parser', () => {
 
   it('warn 2 root elements with v-if', () => {
     parse('<div v-if="1"></div><div v-if="2"></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
+    expect(
+      'Component template should contain exactly one root element'
+    ).toHaveBeenWarned()
   })
 
   it('warn 3 root elements with v-if and v-else on first 2', () => {
     parse('<div v-if="1"></div><div v-else></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
+    expect(
+      'Component template should contain exactly one root element'
+    ).toHaveBeenWarned()
   })
 
   it('warn 3 root elements with v-if and v-else-if on first 2', () => {
     parse('<div v-if="1"></div><div v-else-if></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
+    expect(
+      'Component template should contain exactly one root element'
+    ).toHaveBeenWarned()
   })
 
   it('warn 4 root elements with v-if, v-else-if and v-else on first 2', () => {
-    parse('<div v-if="1"></div><div v-else-if></div><div v-else></div><div></div>', baseOptions)
-    expect('Component template should contain exactly one root element').toHaveBeenWarned()
+    parse(
+      '<div v-if="1"></div><div v-else-if></div><div v-else></div><div></div>',
+      baseOptions
+    )
+    expect(
+      'Component template should contain exactly one root element'
+    ).toHaveBeenWarned()
   })
 
   it('warn 2 root elements with v-if and v-else with v-for on 2nd', () => {
-    parse('<div v-if="1"></div><div v-else v-for="i in [1]"></div>', baseOptions)
-    expect('Cannot use v-for on stateful component root element because it renders multiple elements')
-      .toHaveBeenWarned()
+    parse(
+      '<div v-if="1"></div><div v-else v-for="i in [1]"></div>',
+      baseOptions
+    )
+    expect(
+      'Cannot use v-for on stateful component root element because it renders multiple elements'
+    ).toHaveBeenWarned()
   })
 
   it('warn 2 root elements with v-if and v-else-if with v-for on 2nd', () => {
-    parse('<div v-if="1"></div><div v-else-if="2" v-for="i in [1]"></div>', baseOptions)
-    expect('Cannot use v-for on stateful component root element because it renders multiple elements')
-      .toHaveBeenWarned()
+    parse(
+      '<div v-if="1"></div><div v-else-if="2" v-for="i in [1]"></div>',
+      baseOptions
+    )
+    expect(
+      'Cannot use v-for on stateful component root element because it renders multiple elements'
+    ).toHaveBeenWarned()
   })
 
   it('warn <template> as root element', () => {
@@ -234,27 +302,40 @@ describe('parser', () => {
 
   it('warn v-for on root element', () => {
     parse('<div v-for="item in items"></div>', baseOptions)
-    expect('Cannot use v-for on stateful component root element').toHaveBeenWarned()
+    expect(
+      'Cannot use v-for on stateful component root element'
+    ).toHaveBeenWarned()
   })
 
   it('warn <template> key', () => {
-    parse('<div><template v-for="i in 10" :key="i"></template></div>', baseOptions)
+    parse(
+      '<div><template v-for="i in 10" :key="i"></template></div>',
+      baseOptions
+    )
     expect('<template> cannot be keyed').toHaveBeenWarned()
   })
 
   it('warn the child of the <transition-group> component has sequential index', () => {
-    parse(`
+    parse(
+      `
       <div>
         <transition-group>
           <i v-for="(o, i) of arr" :key="i"></i>
         </transition-group>
       </div>
-    `, baseOptions)
-    expect('Do not use v-for index as key on <transition-group> children').toHaveBeenWarned()
+    `,
+      baseOptions
+    )
+    expect(
+      'Do not use v-for index as key on <transition-group> children'
+    ).toHaveBeenWarned()
   })
 
   it('v-pre directive', () => {
-    const ast = parse('<div v-pre id="message1"><p>{{msg}}</p></div>', baseOptions)
+    const ast = parse(
+      '<div v-pre id="message1"><p>{{msg}}</p></div>',
+      baseOptions
+    )
     expect(ast.pre).toBe(true)
     expect(ast.attrs[0].name).toBe('id')
     expect(ast.attrs[0].value).toBe('"message1"')
@@ -262,7 +343,10 @@ describe('parser', () => {
   })
 
   it('v-pre directive should leave template in DOM', () => {
-    const ast = parse('<div v-pre id="message1"><template id="template1"><p>{{msg}}</p></template></div>', baseOptions)
+    const ast = parse(
+      '<div v-pre id="message1"><template id="template1"><p>{{msg}}</p></template></div>',
+      baseOptions
+    )
     expect(ast.pre).toBe(true)
     expect(ast.attrs[0].name).toBe('id')
     expect(ast.attrs[0].value).toBe('"message1"')
@@ -278,7 +362,10 @@ describe('parser', () => {
   })
 
   it('v-for directive iteration syntax', () => {
-    const ast = parse('<ul><li v-for="(item, index) in items"></li></ul>', baseOptions)
+    const ast = parse(
+      '<ul><li v-for="(item, index) in items"></li></ul>',
+      baseOptions
+    )
     const liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('item')
@@ -287,7 +374,10 @@ describe('parser', () => {
   })
 
   it('v-for directive iteration syntax (multiple)', () => {
-    const ast = parse('<ul><li v-for="(item, key, index) in items"></li></ul>', baseOptions)
+    const ast = parse(
+      '<ul><li v-for="(item, key, index) in items"></li></ul>',
+      baseOptions
+    )
     const liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('item')
@@ -296,7 +386,10 @@ describe('parser', () => {
   })
 
   it('v-for directive key', () => {
-    const ast = parse('<ul><li v-for="item in items" :key="item.uid"></li></ul>', baseOptions)
+    const ast = parse(
+      '<ul><li v-for="item in items" :key="item.uid"></li></ul>',
+      baseOptions
+    )
     const liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('item')
@@ -316,13 +409,19 @@ describe('parser', () => {
     expect(liAst.alias).toBe('{ foo }')
 
     // multi-var destructuring
-    ast = parse('<ul><li v-for="{ foo, bar, baz } in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="{ foo, bar, baz } in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('{ foo, bar, baz }')
 
     // multi-var destructuring with paren
-    ast = parse('<ul><li v-for="({ foo, bar, baz }) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="({ foo, bar, baz }) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('{ foo, bar, baz }')
@@ -335,7 +434,10 @@ describe('parser', () => {
     expect(liAst.iterator1).toBe('i')
 
     // with key + index
-    ast = parse('<ul><li v-for="({ foo }, i, j) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="({ foo }, i, j) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('{ foo }')
@@ -343,7 +445,10 @@ describe('parser', () => {
     expect(liAst.iterator2).toBe('j')
 
     // multi-var destructuring with index
-    ast = parse('<ul><li v-for="({ foo, bar, baz }, i) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="({ foo, bar, baz }, i) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('{ foo, bar, baz }')
@@ -356,7 +461,10 @@ describe('parser', () => {
     expect(liAst.alias).toBe('[ foo ]')
 
     // multi-array
-    ast = parse('<ul><li v-for="[ foo, bar, baz ] in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="[ foo, bar, baz ] in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('[ foo, bar, baz ]')
@@ -368,7 +476,10 @@ describe('parser', () => {
     expect(liAst.alias).toBe('[ foo ]')
 
     // multi-array with paren
-    ast = parse('<ul><li v-for="([ foo, bar, baz ]) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="([ foo, bar, baz ]) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('[ foo, bar, baz ]')
@@ -381,7 +492,10 @@ describe('parser', () => {
     expect(liAst.iterator1).toBe('i')
 
     // array with key + index
-    ast = parse('<ul><li v-for="([ foo ], i, j) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="([ foo ], i, j) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('[ foo ]')
@@ -389,20 +503,29 @@ describe('parser', () => {
     expect(liAst.iterator2).toBe('j')
 
     // multi-array with paren
-    ast = parse('<ul><li v-for="([ foo, bar, baz ]) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="([ foo, bar, baz ]) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('[ foo, bar, baz ]')
 
     // multi-array with index
-    ast = parse('<ul><li v-for="([ foo, bar, baz ], i) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="([ foo, bar, baz ], i) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('[ foo, bar, baz ]')
     expect(liAst.iterator1).toBe('i')
 
     // nested
-    ast = parse('<ul><li v-for="({ foo, bar: { baz }, qux: [ n ] }, i, j) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="({ foo, bar: { baz }, qux: [ n ] }, i, j) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('{ foo, bar: { baz }, qux: [ n ] }')
@@ -410,7 +533,10 @@ describe('parser', () => {
     expect(liAst.iterator2).toBe('j')
 
     // array nested
-    ast = parse('<ul><li v-for="([ foo, { bar }, baz ], i, j) in items"></li></ul>', baseOptions)
+    ast = parse(
+      '<ul><li v-for="([ foo, { bar }, baz ], i, j) in items"></li></ul>',
+      baseOptions
+    )
     liAst = ast.children[0]
     expect(liAst.for).toBe('items')
     expect(liAst.alias).toBe('[ foo, { bar }, baz ]')
@@ -430,7 +556,10 @@ describe('parser', () => {
   })
 
   it('v-else-if directive syntax', () => {
-    const ast = parse('<div><p v-if="show">hello</p><span v-else-if="2">elseif</span><p v-else>world</p></div>', baseOptions)
+    const ast = parse(
+      '<div><p v-if="show">hello</p><span v-else-if="2">elseif</span><p v-else>world</p></div>',
+      baseOptions
+    )
     const ifAst = ast.children[0]
     const conditionsAst = ifAst.ifConditions
     expect(conditionsAst.length).toBe(3)
@@ -441,7 +570,10 @@ describe('parser', () => {
   })
 
   it('v-else directive syntax', () => {
-    const ast = parse('<div><p v-if="show">hello</p><p v-else>world</p></div>', baseOptions)
+    const ast = parse(
+      '<div><p v-if="show">hello</p><p v-else>world</p></div>',
+      baseOptions
+    )
     const ifAst = ast.children[0]
     const conditionsAst = ifAst.ifConditions
     expect(conditionsAst.length).toBe(2)
@@ -471,7 +603,10 @@ describe('parser', () => {
   })
 
   it('slot tag named syntax', () => {
-    const ast = parse('<div><slot name="one">hello world</slot></div>', baseOptions)
+    const ast = parse(
+      '<div><slot name="one">hello world</slot></div>',
+      baseOptions
+    )
     expect(ast.children[0].tag).toBe('slot')
     expect(ast.children[0].slotName).toBe('"one"')
   })
@@ -488,12 +623,18 @@ describe('parser', () => {
   })
 
   it('component "is" attribute', () => {
-    const ast = parse('<my-component is="component1"></my-component>', baseOptions)
+    const ast = parse(
+      '<my-component is="component1"></my-component>',
+      baseOptions
+    )
     expect(ast.component).toBe('"component1"')
   })
 
   it('component "inline-template" attribute', () => {
-    const ast = parse('<my-component inline-template>hello world</my-component>', baseOptions)
+    const ast = parse(
+      '<my-component inline-template>hello world</my-component>',
+      baseOptions
+    )
     expect(ast.inlineTemplate).toBe(true)
   })
 
@@ -506,7 +647,9 @@ describe('parser', () => {
     expect(ast2.classBinding).toBe('class1')
     // interpolation warning
     parse('<p class="{{error}}">hello world</p>', baseOptions)
-    expect('Interpolation inside attributes has been removed').toHaveBeenWarned()
+    expect(
+      'Interpolation inside attributes has been removed'
+    ).toHaveBeenWarned()
   })
 
   it('style binding', () => {
@@ -515,7 +658,10 @@ describe('parser', () => {
   })
 
   it('attribute with v-bind', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg">', baseOptions)
+    const ast = parse(
+      '<input type="text" name="field1" :value="msg">',
+      baseOptions
+    )
     expect(ast.attrsList[0].name).toBe('type')
     expect(ast.attrsList[0].value).toBe('text')
     expect(ast.attrsList[1].name).toBe('name')
@@ -532,7 +678,9 @@ describe('parser', () => {
 
   it('empty v-bind expression', () => {
     parse('<div :empty-msg=""></div>', baseOptions)
-    expect('The value for a v-bind expression cannot be empty. Found in "v-bind:empty-msg"').toHaveBeenWarned()
+    expect(
+      'The value for a v-bind expression cannot be empty. Found in "v-bind:empty-msg"'
+    ).toHaveBeenWarned()
   })
 
   if (process.env.VBIND_PROP_SHORTHAND) {
@@ -555,7 +703,7 @@ describe('parser', () => {
   // This only works for string templates.
   // In-DOM templates will be malformed before Vue can parse it.
   describe('parse and warn invalid dynamic arguments', () => {
-    [
+    ;[
       `<div v-bind:['foo' + bar]="baz"/>`,
       `<div :['foo' + bar]="baz"/>`,
       `<div @['foo' + bar]="baz"/>`,
@@ -571,11 +719,14 @@ describe('parser', () => {
 
   // #9781
   it('multiple dynamic slot names without warning', () => {
-    const ast = parse(`<my-component>
+    const ast = parse(
+      `<my-component>
       <template #[foo]>foo</template>
       <template #[data]="scope">scope</template>
       <template #[bar]>bar</template>
-    </my-component>`, baseOptions)
+    </my-component>`,
+      baseOptions
+    )
 
     expect(`Invalid dynamic argument expression`).not.toHaveBeenWarned()
     expect(ast.scopedSlots.foo).not.toBeUndefined()
@@ -599,26 +750,38 @@ describe('parser', () => {
   })
 
   it('attribute with v-on', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" @input="onInput">', baseOptions)
+    const ast = parse(
+      '<input type="text" name="field1" :value="msg" @input="onInput">',
+      baseOptions
+    )
     expect(ast.events.input.value).toBe('onInput')
   })
 
   it('attribute with directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" v-validate:field1="required">', baseOptions)
+    const ast = parse(
+      '<input type="text" name="field1" :value="msg" v-validate:field1="required">',
+      baseOptions
+    )
     expect(ast.directives[0].name).toBe('validate')
     expect(ast.directives[0].value).toBe('required')
     expect(ast.directives[0].arg).toBe('field1')
   })
 
   it('attribute with modifiered directive', () => {
-    const ast = parse('<input type="text" name="field1" :value="msg" v-validate.on.off>', baseOptions)
+    const ast = parse(
+      '<input type="text" name="field1" :value="msg" v-validate.on.off>',
+      baseOptions
+    )
     expect(ast.directives[0].modifiers.on).toBe(true)
     expect(ast.directives[0].modifiers.off).toBe(true)
   })
 
   it('literal attribute', () => {
     // basic
-    const ast1 = parse('<input type="text" name="field1" value="hello world">', baseOptions)
+    const ast1 = parse(
+      '<input type="text" name="field1" value="hello world">',
+      baseOptions
+    )
     expect(ast1.attrsList[0].name).toBe('type')
     expect(ast1.attrsList[0].value).toBe('text')
     expect(ast1.attrsList[1].name).toBe('name')
@@ -636,7 +799,9 @@ describe('parser', () => {
     expect(ast1.attrs[2].value).toBe('"hello world"')
     // interpolation warning
     parse('<input type="text" name="field1" value="{{msg}}">', baseOptions)
-    expect('Interpolation inside attributes has been removed').toHaveBeenWarned()
+    expect(
+      'Interpolation inside attributes has been removed'
+    ).toHaveBeenWarned()
   })
 
   if (!isIE && !isEdge) {
@@ -647,7 +812,10 @@ describe('parser', () => {
   }
 
   it('custom delimiter', () => {
-    const ast = parse('<p>{msg}</p>', extend({ delimiters: ['{', '}'] }, baseOptions))
+    const ast = parse(
+      '<p>{msg}</p>',
+      extend({ delimiters: ['{', '}'] }, baseOptions)
+    )
     expect(ast.children[0].expression).toBe('_s(msg)')
   })
 
@@ -667,7 +835,10 @@ describe('parser', () => {
   })
 
   it('use prop when prop modifier was explicitly declared', () => {
-    const ast = parse('<component is="textarea" :value.prop="val" />', baseOptions)
+    const ast = parse(
+      '<component is="textarea" :value.prop="val" />',
+      baseOptions
+    )
     expect(ast.attrs).toBeUndefined()
     expect(ast.props.length).toBe(1)
     expect(ast.props[0].name).toBe('value')
@@ -678,15 +849,17 @@ describe('parser', () => {
     const options = extend({}, baseOptions)
     const spy1 = vi.fn()
     const spy2 = vi.fn()
-    options.modules = options.modules.concat([{
-      preTransformNode (el) {
-        spy1(el.tag)
-      },
-      postTransformNode (el) {
-        expect(el.attrs.length).toBe(1)
-        spy2(el.tag)
+    options.modules = options.modules.concat([
+      {
+        preTransformNode(el) {
+          spy1(el.tag)
+        },
+        postTransformNode(el) {
+          expect(el.attrs.length).toBe(1)
+          spy2(el.tag)
+        }
       }
-    }])
+    ])
     parse('<img v-pre src="hi">', options)
     expect(spy1).toHaveBeenCalledWith('img')
     expect(spy2).toHaveBeenCalledWith('img')
@@ -694,7 +867,10 @@ describe('parser', () => {
 
   it('preserve whitespace in <pre> tag', function () {
     const options = extend({}, baseOptions)
-    const ast = parse('<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>', options)
+    const ast = parse(
+      '<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>',
+      options
+    )
     const code = ast.children[0]
     expect(code.children[0].type).toBe(3)
     expect(code.children[0].text).toBe('  \n')
@@ -709,7 +885,10 @@ describe('parser', () => {
   // #5992
   it('ignore the first newline in <pre> tag', function () {
     const options = extend({}, baseOptions)
-    const ast = parse('<div><pre>\nabc</pre>\ndef<pre>\n\nabc</pre></div>', options)
+    const ast = parse(
+      '<div><pre>\nabc</pre>\ndef<pre>\n\nabc</pre></div>',
+      options
+    )
     const pre = ast.children[0]
     expect(pre.children[0].type).toBe(3)
     expect(pre.children[0].text).toBe('abc')
@@ -741,13 +920,16 @@ describe('parser', () => {
 
   it('IE conditional comments', () => {
     const options = extend({}, baseOptions)
-    const ast = parse(`
+    const ast = parse(
+      `
       <div>
         <!--[if lte IE 8]>
           <p>Test 1</p>
         <![endif]-->
       </div>
-    `, options)
+    `,
+      options
+    )
     expect(ast.tag).toBe('div')
     expect(ast.children.length).toBe(0)
   })
@@ -755,12 +937,15 @@ describe('parser', () => {
   it('parse content in textarea as text', () => {
     const options = extend({}, baseOptions)
 
-    const whitespace = parse(`
+    const whitespace = parse(
+      `
       <textarea>
         <p>Test 1</p>
         test2
       </textarea>
-    `, options)
+    `,
+      options
+    )
     expect(whitespace.tag).toBe('textarea')
     expect(whitespace.children.length).toBe(1)
     expect(whitespace.children[0].type).toBe(3)
@@ -779,7 +964,10 @@ describe('parser', () => {
   // #5526
   it('should not decode text in script tags', () => {
     const options = extend({}, baseOptions)
-    const ast = parse(`<script type="x/template">&gt;<foo>&lt;</script>`, options)
+    const ast = parse(
+      `<script type="x/template">&gt;<foo>&lt;</script>`,
+      options
+    )
     expect(ast.children[0].text).toBe(`&gt;<foo>&lt;`)
   })
 
@@ -793,9 +981,12 @@ describe('parser', () => {
   })
 
   it('should kept comments', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
+    const options = extend(
+      {
+        comments: true
+      },
+      baseOptions
+    )
     const ast = parse(`<div>123<!--comment here--></div>`, options)
     expect(ast.tag).toBe('div')
     expect(ast.children.length).toBe(2)
@@ -808,9 +999,12 @@ describe('parser', () => {
 
   // #9407
   it('should parse templates with comments anywhere', () => {
-    const options = extend({
-      comments: true
-    }, baseOptions)
+    const options = extend(
+      {
+        comments: true
+      },
+      baseOptions
+    )
     const ast = parse(`<!--comment here--><div>123</div>`, options)
     expect(ast.tag).toBe('div')
     expect(ast.children.length).toBe(1)
@@ -823,11 +1017,17 @@ describe('parser', () => {
   })
 
   it('preserveWhitespace: false', () => {
-    const options = extend({
-      preserveWhitespace: false
-    }, baseOptions)
+    const options = extend(
+      {
+        preserveWhitespace: false
+      },
+      baseOptions
+    )
 
-    const ast = parse('<p>\n  Welcome to <b>Vue.js</b>    <i>world</i>  \n  <span>.\n  Have fun!\n</span></p>', options)
+    const ast = parse(
+      '<p>\n  Welcome to <b>Vue.js</b>    <i>world</i>  \n  <span>.\n  Have fun!\n</span></p>',
+      options
+    )
     expect(ast.tag).toBe('p')
     expect(ast.children.length).toBe(4)
     expect(ast.children[0].type).toBe(3)
@@ -840,15 +1040,21 @@ describe('parser', () => {
     expect(ast.children[3].children[0].text).toBe('.\n  Have fun!\n')
   })
 
-  const condenseOptions = extend({
-    whitespace: 'condense',
-    // should be ignored when whitespace is specified
-    preserveWhitespace: false
-  }, baseOptions)
+  const condenseOptions = extend(
+    {
+      whitespace: 'condense',
+      // should be ignored when whitespace is specified
+      preserveWhitespace: false
+    },
+    baseOptions
+  )
 
   it(`whitespace: 'condense'`, () => {
     const options = extend({}, condenseOptions)
-    const ast = parse('<p>\n  Welcome to <b>Vue.js</b>    <i>world</i>  \n  <span>.\n  Have fun!\n</span></p>', options)
+    const ast = parse(
+      '<p>\n  Welcome to <b>Vue.js</b>    <i>world</i>  \n  <span>.\n  Have fun!\n</span></p>',
+      options
+    )
     expect(ast.tag).toBe('p')
     expect(ast.children.length).toBe(5)
     expect(ast.children[0].type).toBe(3)
@@ -875,7 +1081,10 @@ describe('parser', () => {
 
   it(`preserve whitespace in <pre> tag with whitespace: 'condense'`, function () {
     const options = extend({}, condenseOptions)
-    const ast = parse('<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>', options)
+    const ast = parse(
+      '<pre><code>  \n<span>hi</span>\n  </code><span> </span></pre>',
+      options
+    )
     const code = ast.children[0]
     expect(code.children[0].type).toBe(3)
     expect(code.children[0].text).toBe('  \n')
@@ -889,7 +1098,10 @@ describe('parser', () => {
 
   it(`ignore the first newline in <pre> tag with whitespace: 'condense'`, function () {
     const options = extend({}, condenseOptions)
-    const ast = parse('<div><pre>\nabc</pre>\ndef<pre>\n\nabc</pre></div>', options)
+    const ast = parse(
+      '<div><pre>\nabc</pre>\ndef<pre>\n\nabc</pre></div>',
+      options
+    )
     const pre = ast.children[0]
     expect(pre.children[0].type).toBe(3)
     expect(pre.children[0].text).toBe('abc')
@@ -912,17 +1124,26 @@ describe('parser', () => {
 
   // #10152
   it('not warn when scoped slot used inside of dynamic component on regular element', () => {
-    parse(`
+    parse(
+      `
       <div>
         <div is="customComp" v-slot="slotProps"></div>
         <div :is="'customComp'" v-slot="slotProps"></div>
         <div v-bind:is="'customComp'" v-slot="slotProps"></div>
       </div>
-    `, baseOptions)
-    expect('v-slot can only be used on components or <template>').not.toHaveBeenWarned()
-
-    parse(`<div is="customComp"><template v-slot="slotProps"></template></div>`, baseOptions)
-    expect(`<template v-slot> can only appear at the root level inside the receiving the component`)
-      .not.toHaveBeenWarned()
+    `,
+      baseOptions
+    )
+    expect(
+      'v-slot can only be used on components or <template>'
+    ).not.toHaveBeenWarned()
+
+    parse(
+      `<div is="customComp"><template v-slot="slotProps"></template></div>`,
+      baseOptions
+    )
+    expect(
+      `<template v-slot> can only appear at the root level inside the receiving the component`
+    ).not.toHaveBeenWarned()
   })
 })
diff --git a/test/unit/modules/observer/observer.spec.ts b/test/unit/modules/observer/observer.spec.ts
index 18d71780ef2..72fc03e2e7e 100644
--- a/test/unit/modules/observer/observer.spec.ts
+++ b/test/unit/modules/observer/observer.spec.ts
@@ -41,7 +41,7 @@ describe('Observer', () => {
 
   it('create on null', () => {
     // on null
-    const obj: any =Object.create(null)
+    const obj: any = Object.create(null)
     obj.a = {}
     obj.b = {}
     const ob1 = observe(obj)!
@@ -64,11 +64,13 @@ describe('Observer', () => {
     Object.defineProperty(obj, 'a', {
       configurable: true,
       enumerable: true,
-      get () {
+      get() {
         getCount++
         return val
       },
-      set (v) { val = v }
+      set(v) {
+        val = v
+      }
     })
 
     const ob1 = observe(obj)!
@@ -98,7 +100,9 @@ describe('Observer', () => {
     Object.defineProperty(obj, 'a', {
       configurable: true,
       enumerable: true,
-      get () { return 123 }
+      get() {
+        return 123
+      }
     })
 
     const ob1 = observe(obj)!
@@ -124,12 +128,15 @@ describe('Observer', () => {
 
   it('create on property with only setter', () => {
     // on object
-    const obj: any ={}
+    const obj: any = {}
     let val = 10
-    Object.defineProperty(obj, 'a', { // eslint-disable-line accessor-pairs
+    Object.defineProperty(obj, 'a', {
+      // eslint-disable-line accessor-pairs
       configurable: true,
       enumerable: true,
-      set (v) { val = v }
+      set(v) {
+        val = v
+      }
     })
 
     const ob1 = observe(obj)!
@@ -151,7 +158,7 @@ describe('Observer', () => {
 
   it('create on property which is marked not configurable', () => {
     // on object
-    const obj: any ={}
+    const obj: any = {}
     Object.defineProperty(obj, 'a', {
       configurable: false,
       enumerable: true,
@@ -177,12 +184,12 @@ describe('Observer', () => {
   })
 
   it('observing object prop change', () => {
-    const obj: any ={ a: { b: 2 }, c: NaN }
+    const obj: any = { a: { b: 2 }, c: NaN }
     observe(obj)!
     // mock a watcher!
     const watcher: any = {
       deps: [],
-      addDep (dep) {
+      addDep(dep) {
         this.deps.push(dep)
         dep.addSub(this)
       },
@@ -214,12 +221,14 @@ describe('Observer', () => {
   })
 
   it('observing object prop change on defined property', () => {
-    const obj: any ={ val: 2 }
+    const obj: any = { val: 2 }
     Object.defineProperty(obj, 'a', {
       configurable: true,
       enumerable: true,
-      get () { return this.val },
-      set (v) {
+      get() {
+        return this.val
+      },
+      set(v) {
         this.val = v
         // eslint-disable-next-line no-setter-return
         return this.val
@@ -295,14 +304,20 @@ describe('Observer', () => {
     Vue.set(vm, 'a', 2)
     waitForUpdate(() => {
       expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      expect('Avoid adding reactive properties to a Vue instance').not.toHaveBeenWarned()
+      expect(
+        'Avoid adding reactive properties to a Vue instance'
+      ).not.toHaveBeenWarned()
       Vue.delete(vm, 'a')
-    }).then(() => {
-      expect('Avoid deleting properties on a Vue instance').toHaveBeenWarned()
-      expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      Vue.set(vm, 'b', 123)
-      expect('Avoid adding reactive properties to a Vue instance').toHaveBeenWarned()
-    }).then(done)
+    })
+      .then(() => {
+        expect('Avoid deleting properties on a Vue instance').toHaveBeenWarned()
+        expect(vm.$el.outerHTML).toBe('<div>2</div>')
+        Vue.set(vm, 'b', 123)
+        expect(
+          'Avoid adding reactive properties to a Vue instance'
+        ).toHaveBeenWarned()
+      })
+      .then(done)
   })
 
   it('warning set/delete on Vue instance root $data', done => {
@@ -315,14 +330,20 @@ describe('Observer', () => {
     expect(Vue.set(data, 'a', 2)).toBe(2)
     waitForUpdate(() => {
       expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      expect('Avoid adding reactive properties to a Vue instance').not.toHaveBeenWarned()
+      expect(
+        'Avoid adding reactive properties to a Vue instance'
+      ).not.toHaveBeenWarned()
       Vue.delete(data, 'a')
-    }).then(() => {
-      expect('Avoid deleting properties on a Vue instance').toHaveBeenWarned()
-      expect(vm.$el.outerHTML).toBe('<div>2</div>')
-      expect(Vue.set(data, 'b', 123)).toBe(123)
-      expect('Avoid adding reactive properties to a Vue instance').toHaveBeenWarned()
-    }).then(done)
+    })
+      .then(() => {
+        expect('Avoid deleting properties on a Vue instance').toHaveBeenWarned()
+        expect(vm.$el.outerHTML).toBe('<div>2</div>')
+        expect(Vue.set(data, 'b', 123)).toBe(123)
+        expect(
+          'Avoid adding reactive properties to a Vue instance'
+        ).toHaveBeenWarned()
+      })
+      .then(done)
   })
 
   it('observing array mutation', () => {
@@ -350,17 +371,21 @@ describe('Observer', () => {
       // @ts-expect-error
       setProp(null, 'foo', 1)
     } catch (e) {}
-    expect(`Cannot set reactive property on undefined, null, or primitive value`).toHaveBeenWarned()
+    expect(
+      `Cannot set reactive property on undefined, null, or primitive value`
+    ).toHaveBeenWarned()
 
     try {
       // @ts-expect-error
       delProp(null, 'foo')
     } catch (e) {}
-    expect(`Cannot delete reactive property on undefined, null, or primitive value`).toHaveBeenWarned()
+    expect(
+      `Cannot delete reactive property on undefined, null, or primitive value`
+    ).toHaveBeenWarned()
   })
 
   it('should lazy invoke existing getters', () => {
-    const obj: any ={}
+    const obj: any = {}
     let called = false
     Object.defineProperty(obj, 'getterProp', {
       enumerable: true,
diff --git a/test/unit/modules/observer/scheduler.spec.ts b/test/unit/modules/observer/scheduler.spec.ts
index f17f75f94ec..001ee5a429a 100644
--- a/test/unit/modules/observer/scheduler.spec.ts
+++ b/test/unit/modules/observer/scheduler.spec.ts
@@ -4,7 +4,7 @@ import {
   queueWatcher as _queueWatcher
 } from 'core/observer/scheduler'
 
-function queueWatcher (watcher) {
+function queueWatcher(watcher) {
   watcher.vm = {} // mock vm
   _queueWatcher(watcher)
 }
@@ -46,7 +46,9 @@ describe('Scheduler', () => {
     queueWatcher(job)
     queueWatcher({
       id: 2,
-      run () { queueWatcher(job) }
+      run() {
+        queueWatcher(job)
+      }
     })
     waitForUpdate(() => {
       expect(spy.mock.calls.length).toBe(2)
@@ -61,9 +63,11 @@ describe('Scheduler', () => {
       },
       template: '<div>{{ a }}</div>',
       watch: {
-        a () { calls.push(1) }
+        a() {
+          calls.push(1)
+        }
       },
-      beforeUpdate () {
+      beforeUpdate() {
         calls.push(2)
       }
     }).$mount()
@@ -81,11 +85,11 @@ describe('Scheduler', () => {
         a: 1
       },
       watch: {
-        a () {
+        a() {
           calls.push(1)
         }
       },
-      beforeUpdate () {
+      beforeUpdate() {
         calls.push(2)
       },
       template: '<div><test :a="a"></test></div>',
@@ -94,11 +98,11 @@ describe('Scheduler', () => {
           props: ['a'],
           template: '<div>{{ a }}</div>',
           watch: {
-            a () {
+            a() {
               calls.push(3)
             }
           },
-          beforeUpdate () {
+          beforeUpdate() {
             calls.push(4)
           }
         }
@@ -114,7 +118,7 @@ describe('Scheduler', () => {
     let count = 0
     const job = {
       id: 1,
-      run () {
+      run() {
         count++
         queueWatcher(job)
       }
@@ -131,11 +135,11 @@ describe('Scheduler', () => {
     queueWatcher({
       id: 1,
       user: true,
-      run () {
+      run() {
         callOrder.push(1)
         queueWatcher({
           id: 2,
-          run () {
+          run() {
             callOrder.push(3)
           }
         })
@@ -162,7 +166,7 @@ describe('Scheduler', () => {
         child: {
           template: `<div>{{foo}}</div>`,
           props: ['foo'],
-          updated () {
+          updated() {
             this.$emit('change')
           }
         }
diff --git a/test/unit/modules/observer/watcher.spec.ts b/test/unit/modules/observer/watcher.spec.ts
index 810a72b6dc7..1525d30b397 100644
--- a/test/unit/modules/observer/watcher.spec.ts
+++ b/test/unit/modules/observer/watcher.spec.ts
@@ -27,10 +27,12 @@ describe('Watcher', () => {
       expect(watcher.value).toBe(3)
       expect(spy).toHaveBeenCalledWith(3, 2)
       vm.b = { c: 4 } // swapping the object
-    }).then(() => {
-      expect(watcher.value).toBe(4)
-      expect(spy).toHaveBeenCalledWith(4, 3)
-    }).then(done)
+    })
+      .then(() => {
+        expect(watcher.value).toBe(4)
+        expect(spy).toHaveBeenCalledWith(4, 3)
+      })
+      .then(done)
   })
 
   it('non-existent path, set later', done => {
@@ -67,10 +69,12 @@ describe('Watcher', () => {
       expect(watcher.value).toBe(3)
       expect(spy).toHaveBeenCalledWith(3, 2)
       vm.$data.b.c = 4
-    }).then(() => {
-      expect(watcher.value).toBe(4)
-      expect(spy).toHaveBeenCalledWith(4, 3)
-    }).then(done)
+    })
+      .then(() => {
+        expect(watcher.value).toBe(4)
+        expect(spy).toHaveBeenCalledWith(4, 3)
+      })
+      .then(done)
   })
 
   it('deep watch', done => {
@@ -83,14 +87,17 @@ describe('Watcher', () => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
       oldB = vm.b
       vm.b = { c: [{ a: 1 }] }
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, oldB)
-      expect(spy.mock.calls.length).toBe(2)
-      vm.b.c[0].a = 2
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.mock.calls.length).toBe(3)
-    }).then(done)
+    })
+      .then(() => {
+        expect(spy).toHaveBeenCalledWith(vm.b, oldB)
+        expect(spy.mock.calls.length).toBe(2)
+        vm.b.c[0].a = 2
+      })
+      .then(() => {
+        expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
+        expect(spy.mock.calls.length).toBe(3)
+      })
+      .then(done)
   })
 
   it('deep watch $data', done => {
@@ -112,10 +119,12 @@ describe('Watcher', () => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
       expect(spy.mock.calls.length).toBe(1)
       vm.b._.c = 1
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
-      expect(spy.mock.calls.length).toBe(2)
-    }).then(done)
+    })
+      .then(() => {
+        expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
+        expect(spy.mock.calls.length).toBe(2)
+      })
+      .then(done)
   })
 
   it('fire change for prop addition/deletion in non-deep mode', done => {
@@ -125,29 +134,42 @@ describe('Watcher', () => {
       expect(spy).toHaveBeenCalledWith(vm.b, vm.b)
       expect(spy.mock.calls.length).toBe(1)
       Vue.delete(vm.b, 'e')
-    }).then(() => {
-      expect(spy.mock.calls.length).toBe(2)
-    }).then(done)
+    })
+      .then(() => {
+        expect(spy.mock.calls.length).toBe(2)
+      })
+      .then(done)
   })
 
   it('watch function', done => {
-    const watcher = new Watcher(vm, function () {
-      return this.a + this.b.d
-    }, spy)
+    const watcher = new Watcher(
+      vm,
+      function () {
+        return this.a + this.b.d
+      },
+      spy
+    )
     expect(watcher.value).toBe(5)
     vm.a = 2
     waitForUpdate(() => {
       expect(spy).toHaveBeenCalledWith(6, 5)
       vm.b = { d: 2 }
-    }).then(() => {
-      expect(spy).toHaveBeenCalledWith(4, 6)
-    }).then(done)
+    })
+      .then(() => {
+        expect(spy).toHaveBeenCalledWith(4, 6)
+      })
+      .then(done)
   })
 
   it('lazy mode', done => {
-    const watcher = new Watcher(vm, function () {
-      return this.a + this.b.d
-    }, null, { lazy: true })
+    const watcher = new Watcher(
+      vm,
+      function () {
+        return this.a + this.b.d
+      },
+      null,
+      { lazy: true }
+    )
     expect(watcher.lazy).toBe(true)
     expect(watcher.value).toBeUndefined()
     expect(watcher.dirty).toBe(true)
diff --git a/test/unit/modules/server-compiler/compiler-options.spec.ts b/test/unit/modules/server-compiler/compiler-options.spec.ts
index aa151a89f59..e8a5fc2e822 100644
--- a/test/unit/modules/server-compiler/compiler-options.spec.ts
+++ b/test/unit/modules/server-compiler/compiler-options.spec.ts
@@ -2,11 +2,14 @@ import { ssrCompile } from 'web/server/compiler'
 
 describe('ssrCompile options', () => {
   it('comments', () => {
-    const compiled = ssrCompile(`
+    const compiled = ssrCompile(
+      `
       <div>
         <!-- test comments -->
       </div>
-    `, { comments: true })
+    `,
+      { comments: true }
+    )
 
     expect(compiled.render).toContain('<!-- test comments -->')
   })
diff --git a/test/unit/modules/sfc/sfc-parser.spec.ts b/test/unit/modules/sfc/sfc-parser.spec.ts
index ff4c9b1b4f2..93db49c611b 100644
--- a/test/unit/modules/sfc/sfc-parser.spec.ts
+++ b/test/unit/modules/sfc/sfc-parser.spec.ts
@@ -29,7 +29,9 @@ describe('Single File Component parser', () => {
     expect(res.styles[0].src).toBe('./test.css')
     expect(res.styles[1].lang).toBe('stylus')
     expect(res.styles[1].scoped).toBe(true)
-    expect(res.styles[1].content.trim()).toBe('h1\n  color red\nh2\n  color green')
+    expect(res.styles[1].content.trim()).toBe(
+      'h1\n  color red\nh2\n  color green'
+    )
     expect(res.styles[2].module).toBe(true)
     expect(res.styles[3].attrs['bool-attr']).toBe(true)
     expect(res.styles[3].attrs['val-attr']).toBe('test')
@@ -52,7 +54,9 @@ describe('Single File Component parser', () => {
         <div><template v-if="ok">hi</template></div>
       </template>
     `)
-    expect(res.template!.content.trim()).toBe('<div><template v-if="ok">hi</template></div>')
+    expect(res.template!.content.trim()).toBe(
+      '<div><template v-if="ok">hi</template></div>'
+    )
   })
 
   it('deindent content', () => {
@@ -68,8 +72,14 @@ describe('Single File Component parser', () => {
       </style>
     `
     const deindentDefault = parseComponent(content.trim(), { pad: false })
-    const deindentEnabled = parseComponent(content.trim(), { pad: false, deindent: true })
-    const deindentDisabled = parseComponent(content.trim(), { pad: false, deindent: false })
+    const deindentEnabled = parseComponent(content.trim(), {
+      pad: false,
+      deindent: true
+    })
+    const deindentDisabled = parseComponent(content.trim(), {
+      pad: false,
+      deindent: false
+    })
 
     expect(deindentDefault.template!.content).toBe('\n<div></div>\n')
     expect(deindentDefault.script!.content).toBe('\nexport default {}\n')
@@ -77,9 +87,15 @@ describe('Single File Component parser', () => {
     expect(deindentEnabled.template!.content).toBe('\n<div></div>\n')
     expect(deindentEnabled.script!.content).toBe('\nexport default {}\n')
     expect(deindentEnabled.styles[0].content).toBe('\nh1 { color: red }\n')
-    expect(deindentDisabled.template!.content).toBe('\n        <div></div>\n      ')
-    expect(deindentDisabled.script!.content).toBe('\n        export default {}\n      ')
-    expect(deindentDisabled.styles[0].content).toBe('\n        h1 { color: red }\n      ')
+    expect(deindentDisabled.template!.content).toBe(
+      '\n        <div></div>\n      '
+    )
+    expect(deindentDisabled.script!.content).toBe(
+      '\n        export default {}\n      '
+    )
+    expect(deindentDisabled.styles[0].content).toBe(
+      '\n        h1 { color: red }\n      '
+    )
   })
 
   it('pad content', () => {
@@ -98,21 +114,33 @@ describe('Single File Component parser', () => {
     const padLine = parseComponent(content.trim(), { pad: 'line' })
     const padSpace = parseComponent(content.trim(), { pad: 'space' })
 
-    expect(padDefault.script!.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
-    expect(padDefault.styles[0].content).toBe(Array(6 + 1).join('\n') + '\nh1 { color: red }\n')
-    expect(padLine.script!.content).toBe(Array(3 + 1).join('//\n') + '\nexport default {}\n')
-    expect(padLine.styles[0].content).toBe(Array(6 + 1).join('\n') + '\nh1 { color: red }\n')
-    expect(padSpace.script!.content).toBe(`<template>
+    expect(padDefault.script!.content).toBe(
+      Array(3 + 1).join('//\n') + '\nexport default {}\n'
+    )
+    expect(padDefault.styles[0].content).toBe(
+      Array(6 + 1).join('\n') + '\nh1 { color: red }\n'
+    )
+    expect(padLine.script!.content).toBe(
+      Array(3 + 1).join('//\n') + '\nexport default {}\n'
+    )
+    expect(padLine.styles[0].content).toBe(
+      Array(6 + 1).join('\n') + '\nh1 { color: red }\n'
+    )
+    expect(padSpace.script!.content).toBe(
+      `<template>
         <div></div>
       </template>
-      <script>`.replace(/./g, ' ') + '\nexport default {}\n')
-    expect(padSpace.styles[0].content).toBe(`<template>
+      <script>`.replace(/./g, ' ') + '\nexport default {}\n'
+    )
+    expect(padSpace.styles[0].content).toBe(
+      `<template>
         <div></div>
       </template>
       <script>
         export default {}
       </script>
-      <style>`.replace(/./g, ' ') + '\nh1 { color: red }\n')
+      <style>`.replace(/./g, ' ') + '\nh1 { color: red }\n'
+    )
   })
 
   it('should handle template blocks with lang as special text', () => {
@@ -159,17 +187,22 @@ describe('Single File Component parser', () => {
 
     const simpleExample = res.customBlocks[0]
     expect(simpleExample.type).toBe('example')
-    expect(simpleExample.content.trim()).toBe('<my-button ref="button">Hello</my-button>')
+    expect(simpleExample.content.trim()).toBe(
+      '<my-button ref="button">Hello</my-button>'
+    )
     expect(simpleExample.attrs.name).toBe('simple')
 
     const withProps = res.customBlocks[1]
     expect(withProps.type).toBe('example')
-    expect(withProps.content.trim()).toBe('<my-button color="red">Hello</my-button>')
+    expect(withProps.content.trim()).toBe(
+      '<my-button color="red">Hello</my-button>'
+    )
     expect(withProps.attrs.name).toBe('with props')
 
     const simpleTest = res.customBlocks[2]
     expect(simpleTest.type).toBe('test')
-    expect(simpleTest.content.trim()).toBe(`export default function simple (vm) {
+    expect(simpleTest.content.trim())
+      .toBe(`export default function simple (vm) {
   describe('Hello', () => {
     it('should display Hello', () => {
       this.vm.$refs.button.$el.innerText.should.equal('Hello')
diff --git a/test/unit/modules/util/error.spec.ts b/test/unit/modules/util/error.spec.ts
index 2db5e7531ab..1ed8b72107c 100644
--- a/test/unit/modules/util/error.spec.ts
+++ b/test/unit/modules/util/error.spec.ts
@@ -5,7 +5,7 @@ describe('invokeWithErrorHandling', () => {
   if (typeof Promise !== 'undefined') {
     it('should errorHandler call once when nested calls return rejected promise', done => {
       const originalHandler = Vue.config.errorHandler
-      const handler = Vue.config.errorHandler = vi.fn()
+      const handler = (Vue.config.errorHandler = vi.fn())
       const userCatch = vi.fn()
       const err = new Error('fake error')
 
@@ -13,12 +13,14 @@ describe('invokeWithErrorHandling', () => {
         return invokeWithErrorHandling(() => {
           return Promise.reject(err)
         })
-      }).catch(userCatch).then(() => {
-        Vue.config.errorHandler = originalHandler
-        expect(handler.mock.calls.length).toBe(1)
-        expect(userCatch).toHaveBeenCalledWith(err)
-        done()
       })
+        .catch(userCatch)
+        .then(() => {
+          Vue.config.errorHandler = originalHandler
+          expect(handler.mock.calls.length).toBe(1)
+          expect(userCatch).toHaveBeenCalledWith(err)
+          done()
+        })
     })
   }
 })
diff --git a/test/unit/modules/vdom/create-component.spec.ts b/test/unit/modules/vdom/create-component.spec.ts
index bb082caf008..55a9e085a46 100644
--- a/test/unit/modules/vdom/create-component.spec.ts
+++ b/test/unit/modules/vdom/create-component.spec.ts
@@ -7,7 +7,7 @@ describe('create-component', () => {
   beforeEach(() => {
     vm = new Vue({
       template: '<p>{{msg}}</p>',
-      data () {
+      data() {
         return { msg: 'hello, my children' }
       }
     }).$mount()
@@ -18,7 +18,7 @@ describe('create-component', () => {
     const child = {
       name: 'child',
       props: ['msg'],
-      render () {}
+      render() {}
     }
     const data = {
       props: { msg: 'hello world' },
@@ -46,7 +46,7 @@ describe('create-component', () => {
       staticAttrs: { class: 'foo' }
     }
     vi.spyOn(vm, '$forceUpdate')
-    function async (resolve, reject) {
+    function async(resolve, reject) {
       setTimeout(() => {
         resolve({
           name: 'child',
@@ -55,7 +55,7 @@ describe('create-component', () => {
         Vue.nextTick(loaded)
       }, 0)
     }
-    function go () {
+    function go() {
       setCurrentRenderingInstance(vm)
       vnode = createComponent(async, data, vm, vm)
       setCurrentRenderingInstance(null)
@@ -63,7 +63,7 @@ describe('create-component', () => {
       expect(vnode.asyncFactory).toBe(async)
       expect(vnode.asyncFactory.owners.length).toEqual(1)
     }
-    function loaded () {
+    function loaded() {
       setCurrentRenderingInstance(vm)
       vnode = createComponent(async, data, vm, vm)
       setCurrentRenderingInstance(null)
@@ -87,7 +87,7 @@ describe('create-component', () => {
       staticAttrs: { class: 'bar' }
     }
     vi.spyOn(vm, '$forceUpdate')
-    function async (resolve, reject) {
+    function async(resolve, reject) {
       resolve({
         name: 'child',
         props: ['msg']
@@ -116,24 +116,26 @@ describe('create-component', () => {
       attrs: { id: 1 }
     }
     const reason = 'failed!!'
-    function async (resolve, reject) {
+    function async(resolve, reject) {
       setTimeout(() => {
         reject(reason)
         Vue.nextTick(failed)
       }, 0)
     }
-    function go () {
+    function go() {
       setCurrentRenderingInstance(vm)
       vnode = createComponent(async, data, vm, vm)
       setCurrentRenderingInstance(null)
       expect(vnode.isComment).toBe(true) // not to be loaded yet.
     }
-    function failed () {
+    function failed() {
       setCurrentRenderingInstance(vm)
       vnode = createComponent(async, data, vm, vm)
       setCurrentRenderingInstance(null)
       expect(vnode.isComment).toBe(true) // failed, still a comment node
-      expect(`Failed to resolve async component: ${async}\nReason: ${reason}`).toHaveBeenWarned()
+      expect(
+        `Failed to resolve async component: ${async}\nReason: ${reason}`
+      ).toHaveBeenWarned()
       done()
     }
     go()
diff --git a/test/unit/modules/vdom/create-element.spec.ts b/test/unit/modules/vdom/create-element.spec.ts
index 405ad4143ad..f97b4bc07cf 100644
--- a/test/unit/modules/vdom/create-element.spec.ts
+++ b/test/unit/modules/vdom/create-element.spec.ts
@@ -27,7 +27,7 @@ describe('create-element', () => {
       }
     })
     const h = vm.$createElement
-    const vnode = h('my-component', { props: { msg: vm.message }})
+    const vnode = h('my-component', { props: { msg: vm.message } })
     expect(vnode.tag).toMatch(/vue-component-[0-9]+/)
     expect(vnode.componentOptions.propsData).toEqual({ msg: vm.message })
     expect(vnode.children).toBeUndefined()
@@ -68,9 +68,13 @@ describe('create-element', () => {
       data: { msg: 'hello world' }
     })
     const h = vm.$createElement
-    const vnode = h(Vue.extend({ // Component class
-      props: ['msg']
-    }), { props: { msg: vm.message }})
+    const vnode = h(
+      Vue.extend({
+        // Component class
+        props: ['msg']
+      }),
+      { props: { msg: vm.message } }
+    )
     expect(vnode.tag).toMatch(/vue-component-[0-9]+/)
     expect(vnode.componentOptions.propsData).toEqual({ msg: vm.message })
     expect(vnode.children).toBeUndefined()
@@ -192,7 +196,7 @@ describe('create-element', () => {
       data: {
         data: {}
       },
-      render (h) {
+      render(h) {
         return h('div', this.data)
       }
     }).$mount()
@@ -201,25 +205,25 @@ describe('create-element', () => {
 
   it('warn non-primitive key', () => {
     new Vue({
-      render (h) {
-        return h('div', { key: {}})
+      render(h) {
+        return h('div', { key: {} })
       }
     }).$mount()
     expect('Avoid using non-primitive value as key').toHaveBeenWarned()
   })
 
-  it('doesn\'t warn boolean key', () => {
+  it("doesn't warn boolean key", () => {
     new Vue({
-      render (h) {
+      render(h) {
         return h('div', { key: true })
       }
     }).$mount()
     expect('Avoid using non-primitive value as key').not.toHaveBeenWarned()
   })
 
-  it('doesn\'t warn symbol key', () => {
+  it("doesn't warn symbol key", () => {
     new Vue({
-      render (h) {
+      render(h) {
         return h('div', { key: Symbol('symbol') })
       }
     }).$mount()
@@ -229,7 +233,7 @@ describe('create-element', () => {
   it('nested child elements should be updated correctly', done => {
     const vm = new Vue({
       data: { n: 1 },
-      render (h) {
+      render(h) {
         const list: any[] = []
         for (let i = 0; i < this.n; i++) {
           list.push(h('span', i))
@@ -259,12 +263,16 @@ describe('create-element', () => {
     const vm = new Vue({
       components: {
         foo: {
-          render (h) {
-            return h('div', {
-              class: {
-                'has-vnode': this.$vnode
-              }
-            }, 'foo')
+          render(h) {
+            return h(
+              'div',
+              {
+                class: {
+                  'has-vnode': this.$vnode
+                }
+              },
+              'foo'
+            )
           }
         }
       },
diff --git a/test/unit/modules/vdom/modules/attrs.spec.ts b/test/unit/modules/vdom/modules/attrs.spec.ts
index 0ec1cc43694..fa654a65292 100644
--- a/test/unit/modules/vdom/modules/attrs.spec.ts
+++ b/test/unit/modules/vdom/modules/attrs.spec.ts
@@ -5,15 +5,15 @@ import { xlinkNS } from 'web/util/index'
 
 describe('vdom attrs module', () => {
   it('should create an element with attrs', () => {
-    const vnode = new VNode('p', { attrs: { id: 1, class: 'class1' }})
+    const vnode = new VNode('p', { attrs: { id: 1, class: 'class1' } })
     const elm = patch(null, vnode)
     expect(elm.id).toBe('1')
     expect(elm).toHaveClass('class1')
   })
 
   it('should change the elements attrs', () => {
-    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' }})
-    const vnode2 = new VNode('i', { attrs: { id: '2', class: 'i am' }})
+    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' } })
+    const vnode2 = new VNode('i', { attrs: { id: '2', class: 'i am' } })
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
     expect(elm.id).toBe('2')
@@ -23,8 +23,8 @@ describe('vdom attrs module', () => {
   })
 
   it('should remove the elements attrs', () => {
-    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' }})
-    const vnode2 = new VNode('i', { attrs: { id: '1' }})
+    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' } })
+    const vnode2 = new VNode('i', { attrs: { id: '1' } })
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
     expect(elm.id).toBe('1')
@@ -32,7 +32,7 @@ describe('vdom attrs module', () => {
   })
 
   it('should remove the elements attrs for new nodes without attrs data', () => {
-    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' }})
+    const vnode1 = new VNode('i', { attrs: { id: '1', class: 'i am vdom' } })
     const vnode2 = new VNode('i', {})
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
@@ -41,37 +41,37 @@ describe('vdom attrs module', () => {
   })
 
   it('should remove the falsy value from boolean attr', () => {
-    const vnode = new VNode('option', { attrs: { disabled: null }})
+    const vnode = new VNode('option', { attrs: { disabled: null } })
     const elm = patch(null, vnode)
     expect(elm.getAttribute('disabled')).toBe(null)
   })
 
   it('should set the attr name to boolean attr', () => {
-    const vnode = new VNode('option', { attrs: { disabled: true }})
+    const vnode = new VNode('option', { attrs: { disabled: true } })
     const elm = patch(null, vnode)
     expect(elm.getAttribute('disabled')).toBe('disabled')
   })
 
   it('should set the falsy value to enumerated attr', () => {
-    const vnode = new VNode('div', { attrs: { contenteditable: null }})
+    const vnode = new VNode('div', { attrs: { contenteditable: null } })
     const elm = patch(null, vnode)
     expect(elm.getAttribute('contenteditable')).toBe('false')
   })
 
   it('should set the boolean string value to enumerated attr', () => {
-    const vnode = new VNode('div', { attrs: { contenteditable: 'true' }})
+    const vnode = new VNode('div', { attrs: { contenteditable: 'true' } })
     const elm = patch(null, vnode)
     expect(elm.getAttribute('contenteditable')).toBe('true')
   })
 
   it('should set the xlink value to attr', () => {
-    const vnode = new VNode('a', { attrs: { 'xlink:href': '#id1' }})
+    const vnode = new VNode('a', { attrs: { 'xlink:href': '#id1' } })
     const elm = patch(null, vnode)
     expect(elm.getAttributeNS(xlinkNS, 'href')).toBe('#id1')
   })
 
   it('should set the xlink boolean string value to attr', () => {
-    const vnode = new VNode('option', { attrs: { 'xlink:disabled': true }})
+    const vnode = new VNode('option', { attrs: { 'xlink:disabled': true } })
     const elm = patch(null, vnode)
     expect(elm.getAttributeNS(xlinkNS, 'disabled')).toBe('true')
   })
@@ -83,7 +83,7 @@ describe('vdom attrs module', () => {
           id: 'foo'
         }
       },
-      render (h) {
+      render(h) {
         return h('div', {
           attrs: this.attrs
         })
@@ -95,8 +95,10 @@ describe('vdom attrs module', () => {
     waitForUpdate(() => {
       expect(vm.$el.id).toBe('bar')
       vm.attrs = { id: 'baz' }
-    }).then(() => {
-      expect(vm.$el.id).toBe('baz')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.id).toBe('baz')
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/modules/vdom/modules/class.spec.ts b/test/unit/modules/vdom/modules/class.spec.ts
index 174e934d4ac..1d0dee4d232 100644
--- a/test/unit/modules/vdom/modules/class.spec.ts
+++ b/test/unit/modules/vdom/modules/class.spec.ts
@@ -33,7 +33,11 @@ describe('vdom class module', () => {
 
   it('should create an element with mixed class', () => {
     const vnode = new VNode('p', {
-      class: [{ class1: false, class2: true, class3: false }, 'class4', ['class5', 'class6']]
+      class: [
+        { class1: false, class2: true, class3: false },
+        'class4',
+        ['class5', 'class6']
+      ]
     })
     const elm = patch(null, vnode)
     expect(elm).not.toHaveClass('class1')
@@ -85,7 +89,7 @@ describe('vdom class module', () => {
     const vnode1 = new VNode('p', {
       class: { class1: true, class2: false, class3: true }
     })
-    const vnode2 = new VNode('p', { class: {}})
+    const vnode2 = new VNode('p', { class: {} })
     let elm = patch(null, vnode1)
     elm = patch(vnode1, vnode2)
     expect(elm).not.toHaveClass('class1')
diff --git a/test/unit/modules/vdom/modules/directive.spec.ts b/test/unit/modules/vdom/modules/directive.spec.ts
index c19b316f0eb..d17d66ba6db 100644
--- a/test/unit/modules/vdom/modules/directive.spec.ts
+++ b/test/unit/modules/vdom/modules/directive.spec.ts
@@ -9,24 +9,48 @@ describe('vdom directive module', () => {
       update: vi.fn(),
       unbind: vi.fn()
     }
-    const vm = new Vue({ directives: { directive1 }})
+    const vm = new Vue({ directives: { directive1 } })
     // create
     const vnode1 = new VNode('div', {}, [
-      new VNode('p', {
-        directives: [{
-          name: 'directive1', value: 'hello', arg: 'arg1', modifiers: { modifier1: true }
-        }]
-      }, undefined, 'hello world', undefined, vm)
+      new VNode(
+        'p',
+        {
+          directives: [
+            {
+              name: 'directive1',
+              value: 'hello',
+              arg: 'arg1',
+              modifiers: { modifier1: true }
+            }
+          ]
+        },
+        undefined,
+        'hello world',
+        undefined,
+        vm
+      )
     ])
     patch(null, vnode1)
     expect(directive1.bind).toHaveBeenCalled()
     // update
     const vnode2 = new VNode('div', {}, [
-      new VNode('p', {
-        directives: [{
-          name: 'directive1', value: 'world', arg: 'arg1', modifiers: { modifier1: true }
-        }]
-      }, undefined, 'hello world', undefined, vm)
+      new VNode(
+        'p',
+        {
+          directives: [
+            {
+              name: 'directive1',
+              value: 'world',
+              arg: 'arg1',
+              modifiers: { modifier1: true }
+            }
+          ]
+        },
+        undefined,
+        'hello world',
+        undefined,
+        vm
+      )
     ])
     patch(vnode1, vnode2)
     expect(directive1.update).toHaveBeenCalled()
diff --git a/test/unit/modules/vdom/modules/dom-props.spec.ts b/test/unit/modules/vdom/modules/dom-props.spec.ts
index 90176759ab3..0f5d3aa0313 100644
--- a/test/unit/modules/vdom/modules/dom-props.spec.ts
+++ b/test/unit/modules/vdom/modules/dom-props.spec.ts
@@ -4,50 +4,52 @@ import VNode from 'core/vdom/vnode'
 
 describe('vdom domProps module', () => {
   it('should create an element with domProps', () => {
-    const vnode = new VNode('a', { domProps: { src: 'http://localhost/' }})
+    const vnode = new VNode('a', { domProps: { src: 'http://localhost/' } })
     const elm = patch(null, vnode)
     expect(elm.src).toBe('http://localhost/')
   })
 
   it('should change the elements domProps', () => {
-    const vnode1 = new VNode('a', { domProps: { src: 'http://localhost/' }})
-    const vnode2 = new VNode('a', { domProps: { src: 'https://vuejs.org/' }})
+    const vnode1 = new VNode('a', { domProps: { src: 'http://localhost/' } })
+    const vnode2 = new VNode('a', { domProps: { src: 'https://vuejs.org/' } })
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
     expect(elm.src).toBe('https://vuejs.org/')
   })
 
   it('should remove the elements domProps', () => {
-    const vnode1 = new VNode('a', { domProps: { src: 'http://localhost/' }})
-    const vnode2 = new VNode('a', { domProps: {}})
+    const vnode1 = new VNode('a', { domProps: { src: 'http://localhost/' } })
+    const vnode2 = new VNode('a', { domProps: {} })
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
     expect(elm.src).toBe('')
   })
 
   it('should initialize the elements value to zero', () => {
-    const vnode = new VNode('input', { domProps: { value: 0 }})
+    const vnode = new VNode('input', { domProps: { value: 0 } })
     const elm = patch(null, vnode)
     expect(elm.value).toBe('0')
   })
 
   it('should save raw value on element', () => {
     const value = {}
-    const vnode = new VNode('input', { domProps: { value }})
+    const vnode = new VNode('input', { domProps: { value } })
     const elm = patch(null, vnode)
     expect(elm._value).toBe(value)
   })
 
   it('should discard vnode children if the node has innerHTML or textContent as a prop', () => {
-    const vnode = new VNode('div', { domProps: { innerHTML: 'hi' }}, [
-      new VNode('span'), new VNode('span')
+    const vnode = new VNode('div', { domProps: { innerHTML: 'hi' } }, [
+      new VNode('span'),
+      new VNode('span')
     ])
     const elm = patch(null, vnode)
     expect(elm.innerHTML).toBe('hi')
     expect(vnode.children.length).toBe(0)
 
-    const vnode2 = new VNode('div', { domProps: { textContent: 'hi' }}, [
-      new VNode('span'), new VNode('span')
+    const vnode2 = new VNode('div', { domProps: { textContent: 'hi' } }, [
+      new VNode('span'),
+      new VNode('span')
     ])
     const elm2 = patch(null, vnode2)
     expect(elm2.textContent).toBe('hi')
@@ -71,7 +73,7 @@ describe('vdom domProps module', () => {
           id: 'foo'
         }
       },
-      render (h) {
+      render(h) {
         return h('div', {
           domProps: this.props
         })
@@ -83,8 +85,10 @@ describe('vdom domProps module', () => {
     waitForUpdate(() => {
       expect(vm.$el.id).toBe('bar')
       vm.props = { id: 'baz' }
-    }).then(() => {
-      expect(vm.$el.id).toBe('baz')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.id).toBe('baz')
+      })
+      .then(done)
   })
 })
diff --git a/test/unit/modules/vdom/modules/events.spec.ts b/test/unit/modules/vdom/modules/events.spec.ts
index 7ee6169f10c..514054783aa 100644
--- a/test/unit/modules/vdom/modules/events.spec.ts
+++ b/test/unit/modules/vdom/modules/events.spec.ts
@@ -4,7 +4,7 @@ import VNode from 'core/vdom/vnode'
 describe('vdom events module', () => {
   it('should attach event handler to element', () => {
     const click = vi.fn()
-    const vnode = new VNode('a', { on: { click }})
+    const vnode = new VNode('a', { on: { click } })
 
     const elm = patch(null, vnode)
     document.body.appendChild(elm)
@@ -14,8 +14,8 @@ describe('vdom events module', () => {
 
   it('should not duplicate the same listener', () => {
     const click = vi.fn()
-    const vnode1 = new VNode('a', { on: { click }})
-    const vnode2 = new VNode('a', { on: { click }})
+    const vnode1 = new VNode('a', { on: { click } })
+    const vnode2 = new VNode('a', { on: { click } })
 
     const elm = patch(null, vnode1)
     patch(vnode1, vnode2)
@@ -27,8 +27,8 @@ describe('vdom events module', () => {
   it('should update different listener', () => {
     const click = vi.fn()
     const click2 = vi.fn()
-    const vnode1 = new VNode('a', { on: { click }})
-    const vnode2 = new VNode('a', { on: { click: click2 }})
+    const vnode1 = new VNode('a', { on: { click } })
+    const vnode2 = new VNode('a', { on: { click: click2 } })
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
@@ -44,7 +44,7 @@ describe('vdom events module', () => {
 
   it('should attach Array of multiple handlers', () => {
     const click = vi.fn()
-    const vnode = new VNode('a', { on: { click: [click, click] }})
+    const vnode = new VNode('a', { on: { click: [click, click] } })
 
     const elm = patch(null, vnode)
     document.body.appendChild(elm)
@@ -55,8 +55,8 @@ describe('vdom events module', () => {
   it('should update Array of multiple handlers', () => {
     const click = vi.fn()
     const click2 = vi.fn()
-    const vnode1 = new VNode('a', { on: { click: [click, click2] }})
-    const vnode2 = new VNode('a', { on: { click: [click] }})
+    const vnode1 = new VNode('a', { on: { click: [click, click2] } })
+    const vnode2 = new VNode('a', { on: { click: [click] } })
 
     const elm = patch(null, vnode1)
     document.body.appendChild(elm)
@@ -72,7 +72,7 @@ describe('vdom events module', () => {
 
   it('should remove handlers that are no longer present', () => {
     const click = vi.fn()
-    const vnode1 = new VNode('a', { on: { click }})
+    const vnode1 = new VNode('a', { on: { click } })
     const vnode2 = new VNode('a', {})
 
     const elm = patch(null, vnode1)
@@ -87,7 +87,7 @@ describe('vdom events module', () => {
 
   it('should remove Array handlers that are no longer present', () => {
     const click = vi.fn()
-    const vnode1 = new VNode('a', { on: { click: [click, click] }})
+    const vnode1 = new VNode('a', { on: { click: [click, click] } })
     const vnode2 = new VNode('a', {})
 
     const elm = patch(null, vnode1)
@@ -105,10 +105,10 @@ describe('vdom events module', () => {
     const click = vi.fn()
     const click2 = vi.fn()
     const click3 = vi.fn()
-    const vnode0 = new VNode('a', { on: { click: click }})
-    const vnode1 = new VNode('a', { on: { click: [click, click2] }})
-    const vnode2 = new VNode('a', { on: { click: click }})
-    const vnode3 = new VNode('a', { on: { click: [click2, click3] }})
+    const vnode0 = new VNode('a', { on: { click: click } })
+    const vnode1 = new VNode('a', { on: { click: [click, click2] } })
+    const vnode2 = new VNode('a', { on: { click: click } })
+    const vnode3 = new VNode('a', { on: { click: [click2, click3] } })
 
     const elm = patch(null, vnode0)
     document.body.appendChild(elm)
diff --git a/test/unit/modules/vdom/modules/style.spec.ts b/test/unit/modules/vdom/modules/style.spec.ts
index 13ee5fce5c6..ec57ae88d6e 100644
--- a/test/unit/modules/vdom/modules/style.spec.ts
+++ b/test/unit/modules/vdom/modules/style.spec.ts
@@ -3,21 +3,25 @@ import VNode from 'core/vdom/vnode'
 
 describe('vdom style module', () => {
   it('should create an element with style', () => {
-    const vnode = new VNode('p', { style: { fontSize: '12px' }})
+    const vnode = new VNode('p', { style: { fontSize: '12px' } })
     const elm = patch(null, vnode)
     expect(elm.style.fontSize).toBe('12px')
   })
 
   it('should create an element with array style', () => {
-    const vnode = new VNode('p', { style: [{ fontSize: '12px' }, { color: 'red' }] })
+    const vnode = new VNode('p', {
+      style: [{ fontSize: '12px' }, { color: 'red' }]
+    })
     const elm = patch(null, vnode)
     expect(elm.style.fontSize).toBe('12px')
     expect(elm.style.color).toBe('red')
   })
 
   it('should change elements style', () => {
-    const vnode1 = new VNode('p', { style: { fontSize: '12px' }})
-    const vnode2 = new VNode('p', { style: { fontSize: '10px', display: 'block' }})
+    const vnode1 = new VNode('p', { style: { fontSize: '12px' } })
+    const vnode2 = new VNode('p', {
+      style: { fontSize: '10px', display: 'block' }
+    })
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
     expect(elm.style.fontSize).toBe('10px')
@@ -25,8 +29,8 @@ describe('vdom style module', () => {
   })
 
   it('should remove elements attrs', () => {
-    const vnode1 = new VNode('p', { style: { fontSize: '12px' }})
-    const vnode2 = new VNode('p', { style: { display: 'block' }})
+    const vnode1 = new VNode('p', { style: { fontSize: '12px' } })
+    const vnode2 = new VNode('p', { style: { display: 'block' } })
     patch(null, vnode1)
     const elm = patch(vnode1, vnode2)
     expect(elm.style.fontSize).toBe('')
diff --git a/test/unit/modules/vdom/patch/children.spec.ts b/test/unit/modules/vdom/patch/children.spec.ts
index 202a4314d06..2cdc142218e 100644
--- a/test/unit/modules/vdom/patch/children.spec.ts
+++ b/test/unit/modules/vdom/patch/children.spec.ts
@@ -1,11 +1,13 @@
 import { patch } from 'web/runtime/patch'
 import VNode, { createEmptyVNode } from 'core/vdom/vnode'
 
-function prop (name) {
-  return obj => { return obj[name] }
+function prop(name) {
+  return obj => {
+    return obj[name]
+  }
 }
 
-function map (fn, list) {
+function map(fn, list) {
   const ret: any[] = []
   for (let i = 0; i < list.length; i++) {
     ret[i] = fn(list[i])
@@ -13,7 +15,7 @@ function map (fn, list) {
   return ret
 }
 
-function spanNum (n) {
+function spanNum(n) {
   if (typeof n === 'string') {
     return new VNode('span', {}, undefined, n)
   } else {
@@ -21,7 +23,7 @@ function spanNum (n) {
   }
 }
 
-function shuffle (array) {
+function shuffle(array) {
   let currentIndex = array.length
   let temporaryValue
   let randomIndex
@@ -45,7 +47,9 @@ const tag = prop('tagName')
 describe('vdom patch: children', () => {
   let vnode0
   beforeEach(() => {
-    vnode0 = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
+    vnode0 = new VNode('p', { attrs: { id: '1' } }, [
+      createTextVNode('hello world')
+    ])
     patch(null, vnode0)
   })
 
@@ -220,7 +224,16 @@ describe('vdom patch: children', () => {
     let elm = patch(vnode0, vnode1)
     expect(elm.children.length).toBe(8)
     elm = patch(vnode1, vnode2)
-    expect(map(inner, elm.children)).toEqual(['8', '7', '6', '5', '4', '3', '2', '1'])
+    expect(map(inner, elm.children)).toEqual([
+      '8',
+      '7',
+      '6',
+      '5',
+      '4',
+      '3',
+      '2',
+      '1'
+    ])
   })
 
   it('something', () => {
@@ -239,24 +252,39 @@ describe('vdom patch: children', () => {
     const opacities: any[] = []
     const elms = 14
     const samples = 5
-    function spanNumWithOpacity (n, o) {
-      return new VNode('span', { key: n, style: { opacity: o }}, undefined, n.toString())
+    function spanNumWithOpacity(n, o) {
+      return new VNode(
+        'span',
+        { key: n, style: { opacity: o } },
+        undefined,
+        n.toString()
+      )
     }
 
-    for (n = 0; n < elms; ++n) { arr[n] = n }
+    for (n = 0; n < elms; ++n) {
+      arr[n] = n
+    }
     for (n = 0; n < samples; ++n) {
-      const vnode1 = new VNode('span', {}, arr.map(n => {
-        return spanNumWithOpacity(n, '1')
-      }))
+      const vnode1 = new VNode(
+        'span',
+        {},
+        arr.map(n => {
+          return spanNumWithOpacity(n, '1')
+        })
+      )
       const shufArr = shuffle(arr.slice(0))
       let elm = patch(vnode0, vnode1)
       for (i = 0; i < elms; ++i) {
         expect(elm.children[i].innerHTML).toBe(i.toString())
         opacities[i] = Math.random().toFixed(5).toString()
       }
-      const vnode2 = new VNode('span', {}, arr.map(n => {
-        return spanNumWithOpacity(shufArr[n], opacities[n])
-      }))
+      const vnode2 = new VNode(
+        'span',
+        {},
+        arr.map(n => {
+          return spanNumWithOpacity(shufArr[n], opacities[n])
+        })
+      )
       elm = patch(vnode1, vnode2)
       for (i = 0; i < elms; ++i) {
         expect(elm.children[i].innerHTML).toBe(shufArr[i].toString())
@@ -446,7 +474,7 @@ describe('vdom patch: children', () => {
   })
 
   it('should handle static vnodes properly', () => {
-    function makeNode (text) {
+    function makeNode(text) {
       return new VNode('div', undefined, [
         new VNode(undefined, undefined, undefined, text)
       ])
@@ -467,7 +495,7 @@ describe('vdom patch: children', () => {
   })
 
   it('should handle static vnodes inside ', () => {
-    function makeNode (text) {
+    function makeNode(text) {
       return new VNode('div', undefined, [
         new VNode(undefined, undefined, undefined, text)
       ])
@@ -509,7 +537,7 @@ describe('vdom patch: children', () => {
   })
 
   it('should warn with duplicate keys: createChildren', () => {
-    function makeNode (key) {
+    function makeNode(key) {
       return new VNode('div', { key: key })
     }
 
@@ -519,7 +547,7 @@ describe('vdom patch: children', () => {
   })
 
   it('should warn with duplicate keys: updateChildren', () => {
-    function makeNode (key) {
+    function makeNode(key) {
       return new VNode('div', { key: key })
     }
 
@@ -532,12 +560,16 @@ describe('vdom patch: children', () => {
   })
 
   it('should warn with duplicate keys: patchVnode with empty oldVnode', () => {
-    function makeNode (key) {
+    function makeNode(key) {
       return new VNode('li', { key: key })
     }
 
     const vnode1 = new VNode('div')
-    const vnode2 = new VNode('div', undefined, ['1', '2', '3', '4', '4'].map(makeNode))
+    const vnode2 = new VNode(
+      'div',
+      undefined,
+      ['1', '2', '3', '4', '4'].map(makeNode)
+    )
 
     patch(vnode1, vnode2)
     expect(`Duplicate keys detected: '4'`).toHaveBeenWarned()
diff --git a/test/unit/modules/vdom/patch/edge-cases.spec.ts b/test/unit/modules/vdom/patch/edge-cases.spec.ts
index 60ebca54b4e..10b8ad8179d 100644
--- a/test/unit/modules/vdom/patch/edge-cases.spec.ts
+++ b/test/unit/modules/vdom/patch/edge-cases.spec.ts
@@ -29,7 +29,7 @@ describe('vdom patch: edge cases', () => {
   // exposed by #7705
   // methods and function expressions with modifiers should return result instead of undefined
   // skipped odd children[1,3, ...] because they are rendered as text nodes with undefined value
-  it('should return listener\'s result for method name and function expression with and w/o modifiers', done => {
+  it("should return listener's result for method name and function expression with and w/o modifiers", done => {
     const dummyEvt = { preventDefault: () => {} }
     new Vue({
       template: `
@@ -41,13 +41,13 @@ describe('vdom patch: edge cases', () => {
         </div>
       `,
       methods: {
-        addFive ($event, toAdd = 0) {
+        addFive($event, toAdd = 0) {
           return toAdd + 5
         }
       },
       directives: {
         test: {
-          bind (el, binding, vnode) {
+          bind(el, binding, vnode) {
             waitForUpdate(() => {
               expect(vnode.children[0].data.on.click()).toBe(5)
               expect(vnode.children[2].data.on.click(dummyEvt)).toBe(5)
@@ -65,7 +65,7 @@ describe('vdom patch: edge cases', () => {
   // and is inserted into a different parent.
   // later when patching the next element a DOM insertion uses it as the
   // reference node, causing a parent mismatch.
-  it('should handle static node edge case when it\'s reused AND used as a reference node for insertion', done => {
+  it("should handle static node edge case when it's reused AND used as a reference node for insertion", done => {
     const vm = new Vue({
       data: {
         ok: true
@@ -103,10 +103,10 @@ describe('vdom patch: edge cases', () => {
       `,
       components: {
         foo: {
-          data () {
+          data() {
             return { ok: true }
           },
-          render (h) {
+          render(h) {
             const children = [
               this.ok ? h('div', 'toggler ') : null,
               h('div', [this.$slots.default, h('span', ' 1')]),
@@ -122,22 +122,23 @@ describe('vdom patch: edge cases', () => {
     waitForUpdate(() => {
       expect(vm.$el.textContent).toContain('slot 1 2')
       vm.$refs.foo.ok = true
-    }).then(() => {
-      expect(vm.$el.textContent).toContain('toggler slot 1 2')
-      vm.$refs.foo.ok = false
-    }).then(() => {
-      expect(vm.$el.textContent).toContain('slot 1 2')
-      vm.$refs.foo.ok = true
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.textContent).toContain('toggler slot 1 2')
+        vm.$refs.foo.ok = false
+      })
+      .then(() => {
+        expect(vm.$el.textContent).toContain('slot 1 2')
+        vm.$refs.foo.ok = true
+      })
+      .then(done)
   })
 
-  it('should synchronize vm\' vnode', done => {
+  it("should synchronize vm' vnode", done => {
     const comp = {
       data: () => ({ swap: true }),
-      render (h) {
-        return this.swap
-          ? h('a', 'atag')
-          : h('span', 'span')
+      render(h) {
+        return this.swap ? h('a', 'atag') : h('span', 'span')
       }
     }
 
@@ -147,11 +148,8 @@ describe('vdom patch: edge cases', () => {
     }
 
     const vm = new Vue({
-      render (h) {
-        const children = [
-          h('wrapper'),
-          h('div', 'row')
-        ]
+      render(h) {
+        const children = [h('wrapper'), h('div', 'row')]
         if (this.swap) {
           children.reverse()
         }
@@ -169,19 +167,23 @@ describe('vdom patch: edge cases', () => {
       expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
       expect(vm.$el.innerHTML).toBe('<div>row</div><a>atag</a>')
       vm.swap = false
-    }).then(() => {
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      expect(vm.$el.innerHTML).toBe('<a>atag</a><div>row</div>')
-      compVm.swap = false
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>span</span><div>row</div>')
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      vm.swap = true
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<div>row</div><span>span</span>')
-      expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
-      vm.swap = true
-    }).then(done)
+    })
+      .then(() => {
+        expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
+        expect(vm.$el.innerHTML).toBe('<a>atag</a><div>row</div>')
+        compVm.swap = false
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<span>span</span><div>row</div>')
+        expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
+        vm.swap = true
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe('<div>row</div><span>span</span>')
+        expect(compVm.$vnode.parent).toBe(wrapperVm.$vnode)
+        vm.swap = true
+      })
+      .then(done)
   })
 
   // #4530
@@ -200,9 +202,11 @@ describe('vdom patch: edge cases', () => {
     waitForUpdate(() => {
       expect(vm.$el.children[0].value).toBe('b')
       vm.ok = true
-    }).then(() => {
-      expect(vm.$el.children[0].value).toBe('a')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.children[0].value).toBe('a')
+      })
+      .then(done)
   })
 
   // #6313
@@ -224,11 +228,13 @@ describe('vdom patch: edge cases', () => {
       expect(vm.$el.children[0].value).toBe('test')
       expect(vm.$el.children[0].type).toBe('text')
       vm.show = false
-    }).then(() => {
-      expect(vm.$el.children[0]).toBe(node)
-      expect(vm.$el.children[0].value).toBe('test')
-      expect(vm.$el.children[0].type).toBe('password')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.children[0]).toBe(node)
+        expect(vm.$el.children[0].value).toBe('test')
+        expect(vm.$el.children[0].type).toBe('password')
+      })
+      .then(done)
   })
 
   it('should properly patch nested HOC when root element is replaced', done => {
@@ -240,7 +246,7 @@ describe('vdom patch: edge cases', () => {
           components: {
             bar: {
               template: `<div v-if="ok"></div><span v-else></span>`,
-              data () {
+              data() {
                 return { ok: true }
               }
             }
@@ -278,36 +284,39 @@ describe('vdom patch: edge cases', () => {
       },
       computed: {
         value: {
-          get () {
+          get() {
             return 1
           },
           set: spy
         }
       },
-      render (h) {
+      render(h) {
         const _vm = this
-        return h('div', {},
-          [h('input', {
-            directives: [{
-              name: 'model',
-              rawName: 'v-model',
-              value: (_vm.value),
-              expression: 'value'
-            }],
+        return h('div', {}, [
+          h('input', {
+            directives: [
+              {
+                name: 'model',
+                rawName: 'v-model',
+                value: _vm.value,
+                expression: 'value'
+              }
+            ],
             attrs: {
-              'type': 'radio',
-              'name': _vm.name
+              type: 'radio',
+              name: _vm.name
             },
             domProps: {
-              'value': _vm.label,
-              'checked': _vm._q(_vm.value, _vm.label)
+              value: _vm.label,
+              checked: _vm._q(_vm.value, _vm.label)
             },
             on: {
-              '__c': function ($event) {
+              __c: function ($event) {
                 _vm.value = _vm.label
               }
             }
-          })])
+          })
+        ])
       }
     }).$mount()
 
@@ -350,7 +359,7 @@ describe('vdom patch: edge cases', () => {
       `,
       components: {
         foo: {
-          render () {}
+          render() {}
         }
       },
       methods: { log }
@@ -369,14 +378,16 @@ describe('vdom patch: edge cases', () => {
     const vm = new Vue({
       template: `<div><custom-foo selected="1"/></div>`
     }).$mount()
-    expect(vm.$el.querySelector('custom-foo').getAttribute('selected')).toBe('1')
+    expect(vm.$el.querySelector('custom-foo').getAttribute('selected')).toBe(
+      '1'
+    )
     Vue.config.ignoredElements = []
   })
 
   // #7805
   it('should not cause duplicate init when components share data object', () => {
     const Base = {
-      render (h) {
+      render(h) {
         return h('div', this.$options.name)
       }
     }
@@ -396,15 +407,15 @@ describe('vdom patch: edge cases', () => {
     const inlineHookSpy = vi.fn()
 
     const vm = new Vue({
-      render (h) {
-        const data = { staticClass: 'text-red', hook: {
-          init: inlineHookSpy
-        }}
-
-        return h('div', [
-          h(Foo, data),
-          h(Bar, data)
-        ])
+      render(h) {
+        const data = {
+          staticClass: 'text-red',
+          hook: {
+            init: inlineHookSpy
+          }
+        }
+
+        return h('div', [h(Foo, data), h(Bar, data)])
       }
     }).$mount()
 
@@ -445,7 +456,8 @@ describe('vdom patch: edge cases', () => {
       components: {
         PendingAsyncComponent
       },
-      template: '<pending-async-component v-if="visible"></pending-async-component>'
+      template:
+        '<pending-async-component v-if="visible"></pending-async-component>'
     }).$mount(ssrAsyncComponent)
 
     vm.visible = false
diff --git a/test/unit/modules/vdom/patch/element.spec.ts b/test/unit/modules/vdom/patch/element.spec.ts
index be74b86e72b..2838b87da94 100644
--- a/test/unit/modules/vdom/patch/element.spec.ts
+++ b/test/unit/modules/vdom/patch/element.spec.ts
@@ -4,7 +4,9 @@ import VNode from 'core/vdom/vnode'
 
 describe('vdom patch: element', () => {
   it('should create an element', () => {
-    const vnode = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
+    const vnode = new VNode('p', { attrs: { id: '1' } }, [
+      createTextVNode('hello world')
+    ])
     const elm = patch(null, vnode)
     expect(elm.tagName).toBe('P')
     expect(elm.outerHTML).toBe('<p id="1">hello world</p>')
diff --git a/test/unit/modules/vdom/patch/hooks.spec.ts b/test/unit/modules/vdom/patch/hooks.spec.ts
index 4105349b143..ba80c700739 100644
--- a/test/unit/modules/vdom/patch/hooks.spec.ts
+++ b/test/unit/modules/vdom/patch/hooks.spec.ts
@@ -10,20 +10,22 @@ const modules = baseModules.concat(platformModules) as any[]
 describe('vdom patch: hooks', () => {
   let vnode0
   beforeEach(() => {
-    vnode0 = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
+    vnode0 = new VNode('p', { attrs: { id: '1' } }, [
+      createTextVNode('hello world')
+    ])
     patch(null, vnode0)
   })
 
   it('should call `insert` listener after both parents, siblings and children have been inserted', () => {
     const result: any[] = []
-    function insert (vnode) {
+    function insert(vnode) {
       expect(vnode.elm.children.length).toBe(2)
       expect(vnode.elm.parentNode.children.length).toBe(3)
       result.push(vnode)
     }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { insert }}, [
+      new VNode('div', { hook: { insert } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ]),
@@ -35,21 +37,21 @@ describe('vdom patch: hooks', () => {
 
   it('should call `prepatch` listener', () => {
     const result: any[] = []
-    function prepatch (oldVnode, newVnode) {
+    function prepatch(oldVnode, newVnode) {
       expect(oldVnode).toEqual(vnode1.children[1])
       expect(newVnode).toEqual(vnode2.children[1])
       result.push(newVnode)
     }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch }}, [
+      new VNode('div', { hook: { prepatch } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ])
     ])
     const vnode2 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch }}, [
+      new VNode('div', { hook: { prepatch } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ])
@@ -62,23 +64,23 @@ describe('vdom patch: hooks', () => {
   it('should call `postpatch` after `prepatch` listener', () => {
     const pre: any[] = []
     const post: any[] = []
-    function prepatch (oldVnode, newVnode) {
+    function prepatch(oldVnode, newVnode) {
       pre.push(pre)
     }
-    function postpatch (oldVnode, newVnode) {
+    function postpatch(oldVnode, newVnode) {
       expect(pre.length).toBe(post.length + 1)
       post.push(post)
     }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch, postpatch }}, [
+      new VNode('div', { hook: { prepatch, postpatch } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ])
     ])
     const vnode2 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { prepatch, postpatch }}, [
+      new VNode('div', { hook: { prepatch, postpatch } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ])
@@ -92,7 +94,7 @@ describe('vdom patch: hooks', () => {
   it('should call `update` listener', () => {
     const result1: any[] = []
     const result2: any[] = []
-    function cb (result, oldVnode, newVnode) {
+    function cb(result, oldVnode, newVnode) {
       if (result.length > 1) {
         expect(result[result.length - 1]).toEqual(oldVnode)
       }
@@ -100,16 +102,26 @@ describe('vdom patch: hooks', () => {
     }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { update: cb.bind(null, result1) }}, [
+      new VNode('div', { hook: { update: cb.bind(null, result1) } }, [
         new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', { hook: { update: cb.bind(null, result2) }}, undefined, 'child 2')
+        new VNode(
+          'span',
+          { hook: { update: cb.bind(null, result2) } },
+          undefined,
+          'child 2'
+        )
       ])
     ])
     const vnode2 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { update: cb.bind(null, result1) }}, [
+      new VNode('div', { hook: { update: cb.bind(null, result1) } }, [
         new VNode('span', {}, undefined, 'child 1'),
-        new VNode('span', { hook: { update: cb.bind(null, result2) }}, undefined, 'child 2')
+        new VNode(
+          'span',
+          { hook: { update: cb.bind(null, result2) } },
+          undefined,
+          'child 2'
+        )
       ])
     ])
     patch(vnode0, vnode1)
@@ -120,7 +132,7 @@ describe('vdom patch: hooks', () => {
 
   it('should call `remove` listener', () => {
     const result: any[] = []
-    function remove (vnode, rm) {
+    function remove(vnode, rm) {
       const parent = vnode.elm.parentNode
       expect(vnode.elm.children.length).toBe(2)
       expect(vnode.elm.children.length).toBe(2)
@@ -130,7 +142,7 @@ describe('vdom patch: hooks', () => {
     }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { remove }}, [
+      new VNode('div', { hook: { remove } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ])
@@ -145,12 +157,16 @@ describe('vdom patch: hooks', () => {
 
   it('should call `init` and `prepatch` listeners on root', () => {
     let count = 0
-    function init (vnode) { count++ }
-    function prepatch (oldVnode, newVnode) { count++ }
-    const vnode1 = new VNode('div', { hook: { init, prepatch }})
+    function init(vnode) {
+      count++
+    }
+    function prepatch(oldVnode, newVnode) {
+      count++
+    }
+    const vnode1 = new VNode('div', { hook: { init, prepatch } })
     patch(vnode0, vnode1)
     expect(count).toBe(1)
-    const vnode2 = new VNode('span', { hook: { init, prepatch }})
+    const vnode2 = new VNode('span', { hook: { init, prepatch } })
     patch(vnode1, vnode2)
     expect(count).toBe(2)
   })
@@ -161,12 +177,26 @@ describe('vdom patch: hooks', () => {
       nodeOps,
       // @ts-ignore - TODO dtw
       modules: modules.concat([
-        { remove (_, rm) { rm1 = rm } },
-        { remove (_, rm) { rm2 = rm } }
+        {
+          remove(_, rm) {
+            rm1 = rm
+          }
+        },
+        {
+          remove(_, rm) {
+            rm2 = rm
+          }
+        }
       ])
     })
     const vnode1 = new VNode('div', {}, [
-      new VNode('a', { hook: { remove (_, rm) { rm3 = rm } }})
+      new VNode('a', {
+        hook: {
+          remove(_, rm) {
+            rm3 = rm
+          }
+        }
+      })
     ])
     const vnode2 = new VNode('div', {}, [])
     let elm = patch1(vnode0, vnode1)
@@ -186,11 +216,11 @@ describe('vdom patch: hooks', () => {
     const parent = nodeOps.createElement('div')
     vnode0 = nodeOps.createElement('div')
     parent.appendChild(vnode0)
-    function remove (vnode, rm) {
+    function remove(vnode, rm) {
       result.push(vnode)
       rm()
     }
-    const vnode1 = new VNode('div', { hook: { remove }}, [
+    const vnode1 = new VNode('div', { hook: { remove } }, [
       new VNode('b', {}, undefined, 'child 1'),
       new VNode('i', {}, undefined, 'child 2')
     ])
@@ -205,11 +235,13 @@ describe('vdom patch: hooks', () => {
 
   it('should invoke global `destroy` hook for all removed children', () => {
     const result: any[] = []
-    function destroy (vnode) { result.push(vnode) }
+    function destroy(vnode) {
+      result.push(vnode)
+    }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
       new VNode('div', {}, [
-        new VNode('span', { hook: { destroy }}, undefined, 'child 1'),
+        new VNode('span', { hook: { destroy } }, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ])
     ])
@@ -232,8 +264,16 @@ describe('vdom patch: hooks', () => {
     const patch1 = createPatchFunction({
       nodeOps,
       modules: modules.concat([
-        { create () { created++ } },
-        { destroy () { destroyed++ } }
+        {
+          create() {
+            created++
+          }
+        },
+        {
+          destroy() {
+            destroyed++
+          }
+        }
       ])
     })
     const vnode1 = new VNode('div', {}, [
@@ -257,8 +297,16 @@ describe('vdom patch: hooks', () => {
     const patch1 = createPatchFunction({
       nodeOps,
       modules: modules.concat([
-        { create () { created++ } },
-        { remove () { removed++ } }
+        {
+          create() {
+            created++
+          }
+        },
+        {
+          remove() {
+            removed++
+          }
+        }
       ])
     })
     const vnode1 = new VNode('div', {}, [
@@ -279,8 +327,16 @@ describe('vdom patch: hooks', () => {
     const patch1 = createPatchFunction({
       nodeOps,
       modules: modules.concat([
-        { create () { created++ } },
-        { destroy () { destroyed++ } }
+        {
+          create() {
+            created++
+          }
+        },
+        {
+          destroy() {
+            destroyed++
+          }
+        }
       ])
     })
     const vnode1 = new VNode('div', {}, [
@@ -303,20 +359,20 @@ describe('vdom patch: hooks', () => {
 
   it('should call `create` listener before inserted into parent but after children', () => {
     const result: any[] = []
-    function create (empty, vnode) {
+    function create(empty, vnode) {
       expect(vnode.elm.children.length).toBe(2)
       expect(vnode.elm.parentNode).toBe(null)
       result.push(vnode)
     }
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}, undefined, 'first sibling'),
-      new VNode('div', { hook: { create }}, [
+      new VNode('div', { hook: { create } }, [
         new VNode('span', {}, undefined, 'child 1'),
         new VNode('span', {}, undefined, 'child 2')
       ]),
-      new VNode('span', {}, undefined, 'can\'t touch me')
+      new VNode('span', {}, undefined, "can't touch me")
     ])
     patch(vnode0, vnode1)
     expect(result.length).toBe(1)
   })
-})
\ No newline at end of file
+})
diff --git a/test/unit/modules/vdom/patch/hydration.spec.ts b/test/unit/modules/vdom/patch/hydration.spec.ts
index 48ddb64d9ae..a757226f83d 100644
--- a/test/unit/modules/vdom/patch/hydration.spec.ts
+++ b/test/unit/modules/vdom/patch/hydration.spec.ts
@@ -3,7 +3,7 @@ import VNode from 'core/vdom/vnode'
 import { patch } from 'web/runtime/patch'
 import { SSR_ATTR } from 'shared/constants'
 
-function createMockSSRDOM (innerHTML) {
+function createMockSSRDOM(innerHTML) {
   const dom = document.createElement('div')
   dom.setAttribute(SSR_ATTR, 'true')
   dom.innerHTML = innerHTML
@@ -13,14 +13,18 @@ function createMockSSRDOM (innerHTML) {
 describe('vdom patch: hydration', () => {
   let vnode0
   beforeEach(() => {
-    vnode0 = new VNode('p', { attrs: { id: '1' }}, [createTextVNode('hello world')])
+    vnode0 = new VNode('p', { attrs: { id: '1' } }, [
+      createTextVNode('hello world')
+    ])
     patch(null, vnode0)
   })
 
   it('should hydrate elements when server-rendered DOM tree is same as virtual DOM tree', () => {
     const result: any[] = []
-    function init (vnode) { result.push(vnode) }
-    function createServerRenderedDOM () {
+    function init(vnode) {
+      result.push(vnode)
+    }
+    function createServerRenderedDOM() {
       const root = document.createElement('div')
       root.setAttribute(SSR_ATTR, 'true')
       const span = document.createElement('span')
@@ -38,15 +42,19 @@ describe('vdom patch: hydration', () => {
     const node0 = createServerRenderedDOM()
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}),
-      new VNode('div', { hook: { init }}, [
-        new VNode('span', {}, [new VNode(undefined, undefined, undefined, 'hi')]),
-        new VNode('span', {}, [new VNode(undefined, undefined, undefined, 'ho')])
+      new VNode('div', { hook: { init } }, [
+        new VNode('span', {}, [
+          new VNode(undefined, undefined, undefined, 'hi')
+        ]),
+        new VNode('span', {}, [
+          new VNode(undefined, undefined, undefined, 'ho')
+        ])
       ])
     ])
     patch(node0, vnode1)
     expect(result.length).toBe(1)
 
-    function traverseAndAssert (vnode, element) {
+    function traverseAndAssert(vnode, element) {
       expect(vnode.elm).toBe(element)
       if (vnode.children) {
         vnode.children.forEach((node, i) => {
@@ -58,9 +66,9 @@ describe('vdom patch: hydration', () => {
     traverseAndAssert(vnode1, node0)
 
     // check update
-    const vnode2 = new VNode('div', { attrs: { id: 'foo' }}, [
-      new VNode('span', { attrs: { id: 'bar' }}),
-      new VNode('div', { hook: { init }}, [
+    const vnode2 = new VNode('div', { attrs: { id: 'foo' } }, [
+      new VNode('span', { attrs: { id: 'bar' } }),
+      new VNode('div', { hook: { init } }, [
         new VNode('span', {}),
         new VNode('span', {})
       ])
@@ -71,7 +79,7 @@ describe('vdom patch: hydration', () => {
   })
 
   it('should warn message that virtual DOM tree is not matching when hydrate element', () => {
-    function createServerRenderedDOM () {
+    function createServerRenderedDOM() {
       const root = document.createElement('div')
       root.setAttribute(SSR_ATTR, 'true')
       const span = document.createElement('span')
@@ -85,23 +93,25 @@ describe('vdom patch: hydration', () => {
     const node0 = createServerRenderedDOM()
     const vnode1 = new VNode('div', {}, [
       new VNode('span', {}),
-      new VNode('div', {}, [
-        new VNode('span', {}),
-        new VNode('span', {})
-      ])
+      new VNode('div', {}, [new VNode('span', {}), new VNode('span', {})])
     ])
     patch(node0, vnode1)
-    expect('The client-side rendered virtual DOM tree is not matching').toHaveBeenWarned()
+    expect(
+      'The client-side rendered virtual DOM tree is not matching'
+    ).toHaveBeenWarned()
   })
 
   // component hydration is better off with a more e2e approach
   it('should hydrate components when server-rendered DOM tree is same as virtual DOM tree', done => {
-    const dom = createMockSSRDOM('<span>foo</span><div class="b a"><span>foo qux</span></div><!---->')
+    const dom = createMockSSRDOM(
+      '<span>foo</span><div class="b a"><span>foo qux</span></div><!---->'
+    )
     const originalNode1 = dom.children[0]
     const originalNode2 = dom.children[1]
 
     const vm = new Vue({
-      template: '<div><span>{{msg}}</span><test class="a" :msg="msg"></test><p v-if="ok"></p></div>',
+      template:
+        '<div><span>{{msg}}</span><test class="a" :msg="msg"></test><p v-if="ok"></p></div>',
       data: {
         msg: 'foo',
         ok: false
@@ -109,7 +119,7 @@ describe('vdom patch: hydration', () => {
       components: {
         test: {
           props: ['msg'],
-          data () {
+          data() {
             return { a: 'qux' }
           },
           template: '<div class="b"><span>{{msg}} {{a}}</span></div>'
@@ -117,7 +127,9 @@ describe('vdom patch: hydration', () => {
       }
     })
 
-    expect(() => { vm.$mount(dom) }).not.toThrow()
+    expect(() => {
+      vm.$mount(dom)
+    }).not.toThrow()
     expect('not matching server-rendered content').not.toHaveBeenWarned()
     expect(vm.$el).toBe(dom)
     expect(vm.$children[0].$el).toBe(originalNode2)
@@ -125,14 +137,23 @@ describe('vdom patch: hydration', () => {
     expect(vm.$el.children[1]).toBe(originalNode2)
     vm.msg = 'bar'
     waitForUpdate(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bar</span><div class="b a"><span>bar qux</span></div><!---->')
+      expect(vm.$el.innerHTML).toBe(
+        '<span>bar</span><div class="b a"><span>bar qux</span></div><!---->'
+      )
       vm.$children[0].a = 'ququx'
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bar</span><div class="b a"><span>bar ququx</span></div><!---->')
-      vm.ok = true
-    }).then(() => {
-      expect(vm.$el.innerHTML).toBe('<span>bar</span><div class="b a"><span>bar ququx</span></div><p></p>')
-    }).then(done)
+    })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>bar</span><div class="b a"><span>bar ququx</span></div><!---->'
+        )
+        vm.ok = true
+      })
+      .then(() => {
+        expect(vm.$el.innerHTML).toBe(
+          '<span>bar</span><div class="b a"><span>bar ququx</span></div><p></p>'
+        )
+      })
+      .then(done)
   })
 
   it('should warn failed hydration for non-matching DOM in child component', () => {
@@ -168,7 +189,7 @@ describe('vdom patch: hydration', () => {
       template: '<div><test></test></div>',
       components: {
         test: {
-          data () {
+          data() {
             return { a: 'qux' }
           },
           template: '<div><span>{{a}}</span></div>'
@@ -188,7 +209,7 @@ describe('vdom patch: hydration', () => {
       template: '<div><test></test></div>',
       components: {
         test: {
-          data () {
+          data() {
             return { a: 'qux' }
           },
           template: '<div><span>{{a}}</span></div>'
@@ -210,12 +231,13 @@ describe('vdom patch: hydration', () => {
     const dom = createMockSSRDOM('<span>foo</span>')
     const span = dom.querySelector('span')
 
-    const Foo = resolve => setTimeout(() => {
-      resolve({
-        data: () => ({ msg: 'foo' }),
-        template: `<span>{{ msg }}</span>`
-      })
-    }, 0)
+    const Foo = resolve =>
+      setTimeout(() => {
+        resolve({
+          data: () => ({ msg: 'foo' }),
+          template: `<span>{{ msg }}</span>`
+        })
+      }, 0)
 
     const vm = new Vue({
       template: '<div><foo ref="foo" /></div>',

From 797e72e6fd6b67cb021942330ac1cd7c502913fc Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 24 May 2022 08:55:11 +0800
Subject: [PATCH 068/317] build: use __DEV__ flag

---
 scripts/config.js                             |  5 +-
 src/compiler/codegen/index.ts                 |  9 +--
 src/compiler/create-compiler.ts               |  7 +--
 src/compiler/directives/on.ts                 |  2 +-
 src/compiler/helpers.ts                       |  7 +--
 src/compiler/parser/html-parser.ts            | 14 +----
 src/compiler/parser/index.ts                  | 60 +++++++------------
 src/compiler/to-function.ts                   |  6 +-
 src/core/config.ts                            |  4 +-
 src/core/global-api/assets.ts                 |  2 +-
 src/core/global-api/extend.ts                 |  2 +-
 src/core/global-api/index.ts                  |  2 +-
 src/core/instance/events.ts                   |  2 +-
 src/core/instance/index.ts                    |  2 +-
 src/core/instance/init.ts                     |  6 +-
 src/core/instance/inject.ts                   |  4 +-
 src/core/instance/lifecycle.ts                |  8 +--
 src/core/instance/proxy.ts                    |  2 +-
 .../render-helpers/bind-dynamic-keys.ts       |  6 +-
 .../render-helpers/bind-object-listeners.ts   |  3 +-
 .../render-helpers/bind-object-props.ts       |  2 +-
 .../instance/render-helpers/render-slot.ts    |  2 +-
 src/core/instance/render.ts                   |  6 +-
 src/core/instance/state.ts                    | 21 +++----
 src/core/observer/dep.ts                      |  2 +-
 src/core/observer/index.ts                    | 16 ++---
 src/core/observer/scheduler.ts                |  6 +-
 src/core/observer/watcher.ts                  |  5 +-
 src/core/util/debug.ts                        |  2 +-
 src/core/util/error.ts                        |  2 +-
 src/core/util/options.ts                      | 20 +++----
 src/core/util/perf.ts                         |  2 +-
 src/core/util/props.ts                        |  4 +-
 src/core/vdom/create-component.ts             |  2 +-
 src/core/vdom/create-element.ts               | 11 +---
 src/core/vdom/create-functional-component.ts  |  2 +-
 src/core/vdom/helpers/extract-props.ts        |  2 +-
 .../vdom/helpers/resolve-async-component.ts   |  8 +--
 src/core/vdom/helpers/update-listeners.ts     |  2 +-
 src/core/vdom/patch.ts                        | 18 +++---
 src/global.d.ts                               |  2 +
 .../web/compiler/directives/model.ts          |  6 +-
 src/platforms/web/compiler/modules/class.ts   |  2 +-
 src/platforms/web/compiler/modules/style.ts   |  2 +-
 .../web/entry-runtime-with-compiler.ts        | 12 ++--
 .../runtime/components/transition-group.ts    |  2 +-
 .../web/runtime/components/transition.ts      |  9 +--
 src/platforms/web/runtime/directives/model.ts |  2 +-
 src/platforms/web/runtime/index.ts            |  7 +--
 .../web/runtime/modules/transition.ts         |  4 +-
 src/platforms/web/util/index.ts               |  3 +-
 src/server/template-renderer/index.ts         |  7 +--
 src/sfc/parser.ts                             |  2 +-
 vitest.config.ts                              |  3 +
 54 files changed, 145 insertions(+), 206 deletions(-)

diff --git a/scripts/config.js b/scripts/config.js
index 5cb0fdcc461..905fb8b9974 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -16,7 +16,7 @@ const banner =
   ' */'
 
 const aliases = require('./alias')
-const resolve = (p) => {
+const resolve = p => {
   const base = p.split('/')[0]
   if (aliases[base]) {
     return path.resolve(aliases[base], p.slice(base.length + 1))
@@ -241,12 +241,13 @@ function genConfig(name) {
     __VERSION__: version
   }
   // feature flags
-  Object.keys(featureFlags).forEach((key) => {
+  Object.keys(featureFlags).forEach(key => {
     vars[`process.env.${key}`] = featureFlags[key]
   })
   // build-specific env
   if (opts.env) {
     vars['process.env.NODE_ENV'] = JSON.stringify(opts.env)
+    vars.__DEV__ = opts.env !== 'production'
   }
 
   vars.preventAssignment = true
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index d87bd5e6f5c..0831d621179 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -137,7 +137,7 @@ function genOnce(el: ASTElement, state: CodegenState): string {
       parent = parent.parent
     }
     if (!key) {
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
         state.warn(
           `v-once can only be used inside v-for that is keyed. `,
           el.rawAttrsMap['v-once']
@@ -201,7 +201,7 @@ export function genFor(
   const iterator2 = el.iterator2 ? `,${el.iterator2}` : ''
 
   if (
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
     state.maybeComponent(el) &&
     el.tag !== 'slot' &&
     el.tag !== 'template' &&
@@ -345,10 +345,7 @@ function genInlineTemplate(
   state: CodegenState
 ): string | undefined {
   const ast = el.children[0]
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    (el.children.length !== 1 || ast.type !== 1)
-  ) {
+  if (__DEV__ && (el.children.length !== 1 || ast.type !== 1)) {
     state.warn(
       'Inline-template components must have exactly one child element.',
       { start: el.start }
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index f6aa0ae3b17..fe55c6fa281 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -21,10 +21,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
       }
 
       if (options) {
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          options.outputSourceRange
-        ) {
+        if (__DEV__ && options.outputSourceRange) {
           // $flow-disable-line
           const leadingSpaceLength = template.match(/^\s*/)![0].length
 
@@ -69,7 +66,7 @@ export function createCompilerCreator(baseCompile: Function): Function {
       finalOptions.warn = warn
 
       const compiled = baseCompile(template.trim(), finalOptions)
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         detectErrors(compiled.ast, warn)
       }
       compiled.errors = errors
diff --git a/src/compiler/directives/on.ts b/src/compiler/directives/on.ts
index da0d66fbd1a..e2ddf2c1ca4 100644
--- a/src/compiler/directives/on.ts
+++ b/src/compiler/directives/on.ts
@@ -1,7 +1,7 @@
 import { warn } from 'core/util/index'
 
 export default function on(el: ASTElement, dir: ASTDirective) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+  if (__DEV__ && dir.modifiers) {
     warn(`v-on without argument does not support modifiers.`)
   }
   el.wrapListeners = (code: string) => `_g(${code},${dir.value})`
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index be588bdf40d..a5b66b34259 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -101,12 +101,7 @@ export function addHandler(
   modifiers = modifiers || emptyObject
   // warn prevent and passive modifier
   /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    warn &&
-    modifiers.prevent &&
-    modifiers.passive
-  ) {
+  if (__DEV__ && warn && modifiers.prevent && modifiers.passive) {
     warn(
       "passive and prevent can't be used together. " +
         "Passive handler can't prevent default event.",
diff --git a/src/compiler/parser/html-parser.ts b/src/compiler/parser/html-parser.ts
index b1cf9768d24..15c3d81ff62 100644
--- a/src/compiler/parser/html-parser.ts
+++ b/src/compiler/parser/html-parser.ts
@@ -181,11 +181,7 @@ export function parseHTML(html, options) {
 
     if (html === last) {
       options.chars && options.chars(html)
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        !stack.length &&
-        options.warn
-      ) {
+      if (__DEV__ && !stack.length && options.warn) {
         options.warn(`Mal-formatted tag at end of template: "${html}"`, {
           start: index + html.length
         })
@@ -258,7 +254,7 @@ export function parseHTML(html, options) {
         name: args[1],
         value: decodeAttr(value, shouldDecodeNewlines)
       }
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+      if (__DEV__ && options.outputSourceRange) {
         attrs[i].start = args.start + args[0].match(/^\s*/).length
         attrs[i].end = args.end
       }
@@ -301,11 +297,7 @@ export function parseHTML(html, options) {
     if (pos >= 0) {
       // Close all the open elements, up the stack
       for (let i = stack.length - 1; i >= pos; i--) {
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
+        if (__DEV__ && (i > pos || !tagName) && options.warn) {
           options.warn(`tag <${stack[i].tag}> has no matching end tag.`, {
             start: stack[i].start,
             end: stack[i].end
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index d2f2fc21cb7..26d72d4e873 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -119,14 +119,14 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
     if (!stack.length && element !== root) {
       // allow root elements with v-if, v-else-if and v-else
       if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           checkRootConstraints(element)
         }
         addIfCondition(root, {
           exp: element.elseif,
           block: element
         })
-      } else if (process.env.NODE_ENV !== 'production') {
+      } else if (__DEV__) {
         warnOnce(
           `Component template should contain exactly one root element. ` +
             `If you are using v-if on multiple elements, ` +
@@ -229,7 +229,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
         element.ns = ns
       }
 
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         if (options.outputSourceRange) {
           element.start = start
           element.end = end
@@ -254,7 +254,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
 
       if (isForbiddenTag(element) && !isServerRendering()) {
         element.forbidden = true
-        process.env.NODE_ENV !== 'production' &&
+        __DEV__ &&
           warn(
             'Templates should only be responsible for mapping the state to the ' +
               'UI. Avoid placing tags with side-effects in your templates, such as ' +
@@ -289,7 +289,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
 
       if (!root) {
         root = element
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           checkRootConstraints(root)
         }
       }
@@ -307,7 +307,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
       // pop stack
       stack.length -= 1
       currentParent = stack[stack.length - 1]
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+      if (__DEV__ && options.outputSourceRange) {
         element.end = end
       }
       closeElement(element)
@@ -315,7 +315,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
 
     chars(text: string, start: number, end: number) {
       if (!currentParent) {
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           if (text === template) {
             warnOnce(
               'Component template requires a root element, rather than just text.',
@@ -382,10 +382,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
           }
         }
         if (child) {
-          if (
-            process.env.NODE_ENV !== 'production' &&
-            options.outputSourceRange
-          ) {
+          if (__DEV__ && options.outputSourceRange) {
             child.start = start
             child.end = end
           }
@@ -402,10 +399,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
           text,
           isComment: true
         }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          options.outputSourceRange
-        ) {
+        if (__DEV__ && options.outputSourceRange) {
           child.start = start
           child.end = end
         }
@@ -465,7 +459,7 @@ export function processElement(element: ASTElement, options: CompilerOptions) {
 function processKey(el) {
   const exp = getBindingAttr(el, 'key')
   if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if (el.tag === 'template') {
         warn(
           `<template> cannot be keyed. Place the key on real elements instead.`,
@@ -508,7 +502,7 @@ export function processFor(el: ASTElement) {
     const res = parseFor(exp)
     if (res) {
       extend(el, res)
-    } else if (process.env.NODE_ENV !== 'production') {
+    } else if (__DEV__) {
       warn(`Invalid v-for expression: ${exp}`, el.rawAttrsMap['v-for'])
     }
   }
@@ -566,7 +560,7 @@ function processIfConditions(el, parent) {
       exp: el.elseif,
       block: el
     })
-  } else if (process.env.NODE_ENV !== 'production') {
+  } else if (__DEV__) {
     warn(
       `v-${el.elseif ? 'else-if="' + el.elseif + '"' : 'else'} ` +
         `used on element <${el.tag}> without corresponding v-if.`,
@@ -581,7 +575,7 @@ function findPrevElement(children: Array<any>): ASTElement | void {
     if (children[i].type === 1) {
       return children[i]
     } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+      if (__DEV__ && children[i].text !== ' ') {
         warn(
           `text "${children[i].text.trim()}" between v-if and v-else(-if) ` +
             `will be ignored.`,
@@ -614,7 +608,7 @@ function processSlotContent(el) {
   if (el.tag === 'template') {
     slotScope = getAndRemoveAttr(el, 'scope')
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
+    if (__DEV__ && slotScope) {
       warn(
         `the "scope" attribute for scoped slots have been deprecated and ` +
           `replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ` +
@@ -627,7 +621,7 @@ function processSlotContent(el) {
     el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
   } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+    if (__DEV__ && el.attrsMap['v-for']) {
       warn(
         `Ambiguous combined usage of slot-scope and v-for on <${el.tag}> ` +
           `(v-for takes higher priority). Use a wrapper <template> for the ` +
@@ -659,7 +653,7 @@ function processSlotContent(el) {
       // v-slot on <template>
       const slotBinding = getAndRemoveAttrByRegex(el, slotRE)
       if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           if (el.slotTarget || el.slotScope) {
             warn(`Unexpected mixed usage of different slot syntaxes.`, el)
           }
@@ -680,7 +674,7 @@ function processSlotContent(el) {
       // v-slot on component, denotes default slot
       const slotBinding = getAndRemoveAttrByRegex(el, slotRE)
       if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           if (!maybeComponent(el)) {
             warn(
               `v-slot can only be used on components or <template>.`,
@@ -729,7 +723,7 @@ function getSlotName(binding) {
   if (!name) {
     if (binding.name[0] !== '#') {
       name = 'default'
-    } else if (process.env.NODE_ENV !== 'production') {
+    } else if (__DEV__) {
       warn(`v-slot shorthand syntax requires a slot name.`, binding)
     }
   }
@@ -744,7 +738,7 @@ function getSlotName(binding) {
 function processSlotOutlet(el) {
   if (el.tag === 'slot') {
     el.slotName = getBindingAttr(el, 'name')
-    if (process.env.NODE_ENV !== 'production' && el.key) {
+    if (__DEV__ && el.key) {
       warn(
         `\`key\` does not work on <slot> because slots are abstract outlets ` +
           `and can possibly expand into multiple elements. ` +
@@ -791,10 +785,7 @@ function processAttrs(el) {
         if (isDynamic) {
           name = name.slice(1, -1)
         }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
+        if (__DEV__ && value.trim().length === 0) {
           warn(
             `The value for a v-bind expression cannot be empty. Found in "v-bind:${name}"`
           )
@@ -885,13 +876,13 @@ function processAttrs(el) {
           modifiers,
           list[i]
         )
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
+        if (__DEV__ && name === 'model') {
           checkForAliasModel(el, value)
         }
       }
     } else {
       // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         const res = parseText(value, delimiters)
         if (res) {
           warn(
@@ -942,12 +933,7 @@ function parseModifiers(name: string): Object | void {
 function makeAttrsMap(attrs: Array<Record<string, any>>): Record<string, any> {
   const map = {}
   for (let i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] &&
-      !isIE &&
-      !isEdge
-    ) {
+    if (__DEV__ && map[attrs[i].name] && !isIE && !isEdge) {
       warn('duplicate attribute: ' + attrs[i].name, attrs[i])
     }
     map[attrs[i].name] = attrs[i].value
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index 3165d3cc0ed..a928d6c8d3f 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -30,7 +30,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
     delete options.warn
 
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       // detect possible CSP restriction
       try {
         new Function('return 1')
@@ -59,7 +59,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
     const compiled = compile(template, options)
 
     // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if (compiled.errors && compiled.errors.length) {
         if (options.outputSourceRange) {
           compiled.errors.forEach(e => {
@@ -99,7 +99,7 @@ export function createCompileToFunctionFn(compile: Function): Function {
     // this should only happen if there is a bug in the compiler itself.
     // mostly for codegen development use
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
         warn(
           `Failed to generate render function:\n\n` +
diff --git a/src/core/config.ts b/src/core/config.ts
index f125f9052b0..1819422a7aa 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -45,12 +45,12 @@ export default {
   /**
    * Show production mode tip message on boot?
    */
-  productionTip: process.env.NODE_ENV !== 'production',
+  productionTip: __DEV__,
 
   /**
    * Whether to enable devtools
    */
-  devtools: process.env.NODE_ENV !== 'production',
+  devtools: __DEV__,
 
   /**
    * Whether to record perf
diff --git a/src/core/global-api/assets.ts b/src/core/global-api/assets.ts
index 6b09170a1f4..711f7e8785f 100644
--- a/src/core/global-api/assets.ts
+++ b/src/core/global-api/assets.ts
@@ -16,7 +16,7 @@ export function initAssetRegisters(Vue: GlobalAPI) {
         return this.options[type + 's'][id]
       } else {
         /* istanbul ignore if */
-        if (process.env.NODE_ENV !== 'production' && type === 'component') {
+        if (__DEV__ && type === 'component') {
           validateComponentName(id)
         }
         if (type === 'component' && isPlainObject(definition)) {
diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index afabe769891..703cb4b7d12 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -26,7 +26,7 @@ export function initExtend(Vue: GlobalAPI) {
     }
 
     const name = extendOptions.name || Super.options.name
-    if (process.env.NODE_ENV !== 'production' && name) {
+    if (__DEV__ && name) {
       validateComponentName(name)
     }
 
diff --git a/src/core/global-api/index.ts b/src/core/global-api/index.ts
index 69bdc6ee3a1..82c70eaed8b 100644
--- a/src/core/global-api/index.ts
+++ b/src/core/global-api/index.ts
@@ -21,7 +21,7 @@ export function initGlobalAPI(Vue: GlobalAPI) {
   // config
   const configDef: Record<string, any> = {}
   configDef.get = () => config
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     configDef.set = () => {
       warn(
         'Do not replace the Vue.config object, set individual fields instead.'
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index 7420d06b8f0..36dff2e643e 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -129,7 +129,7 @@ export function eventsMixin(Vue: Component) {
 
   Vue.prototype.$emit = function (event: string): Component {
     const vm: Component = this
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       const lowerCaseEvent = event.toLowerCase()
       if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
         tip(
diff --git a/src/core/instance/index.ts b/src/core/instance/index.ts
index afe64c18c7b..95a3af38ece 100644
--- a/src/core/instance/index.ts
+++ b/src/core/instance/index.ts
@@ -7,7 +7,7 @@ import { warn } from '../util/index'
 import type { GlobalAPI } from 'typescript/global-api'
 
 function Vue(options) {
-  if (process.env.NODE_ENV !== 'production' && !(this instanceof Vue)) {
+  if (__DEV__ && !(this instanceof Vue)) {
     warn('Vue is a constructor and should be called with the `new` keyword')
   }
   this._init(options)
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 16c72dd7a50..6a58c432dff 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -20,7 +20,7 @@ export function initMixin(Vue: Component) {
 
     let startTag, endTag
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+    if (__DEV__ && config.performance && mark) {
       startTag = `vue-perf-start:${vm._uid}`
       endTag = `vue-perf-end:${vm._uid}`
       mark(startTag)
@@ -42,7 +42,7 @@ export function initMixin(Vue: Component) {
       )
     }
     /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       initProxy(vm)
     } else {
       vm._renderProxy = vm
@@ -59,7 +59,7 @@ export function initMixin(Vue: Component) {
     callHook(vm, 'created')
 
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+    if (__DEV__ && config.performance && mark) {
       vm._name = formatComponentName(vm, false)
       mark(endTag)
       measure(`vue ${vm._name} init`, startTag, endTag)
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 58e43ed56ac..1ea4c3b8f76 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -20,7 +20,7 @@ export function initInjections(vm: Component) {
     toggleObserving(false)
     Object.keys(result).forEach(key => {
       /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         defineReactive(vm, key, result[key], () => {
           warn(
             `Avoid mutating an injected value directly since the changes will be ` +
@@ -67,7 +67,7 @@ export function resolveInject(
             typeof provideDefault === 'function'
               ? provideDefault.call(vm)
               : provideDefault
-        } else if (process.env.NODE_ENV !== 'production') {
+        } else if (__DEV__) {
           warn(`Injection "${key as string}" not found`, vm)
         }
       }
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index f5915fe193c..7329560929b 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -147,7 +147,7 @@ export function mountComponent(
   if (!vm.$options.render) {
     // @ts-expect-error invalid type
     vm.$options.render = createEmptyVNode
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       /* istanbul ignore if */
       if (
         (vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
@@ -172,7 +172,7 @@ export function mountComponent(
 
   let updateComponent
   /* istanbul ignore if */
-  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+  if (__DEV__ && config.performance && mark) {
     updateComponent = () => {
       const name = vm._name
       const id = vm._uid
@@ -229,7 +229,7 @@ export function updateChildComponent(
   parentVnode: MountedComponentVNode,
   renderChildren?: Array<VNode> | null
 ) {
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     isUpdatingChildComponent = true
   }
 
@@ -299,7 +299,7 @@ export function updateChildComponent(
     vm.$forceUpdate()
   }
 
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     isUpdatingChildComponent = false
   }
 }
diff --git a/src/core/instance/proxy.ts b/src/core/instance/proxy.ts
index cba02619984..3543d74954a 100644
--- a/src/core/instance/proxy.ts
+++ b/src/core/instance/proxy.ts
@@ -5,7 +5,7 @@ import { warn, makeMap, isNative } from '../util/index'
 
 let initProxy
 
-if (process.env.NODE_ENV !== 'production') {
+if (__DEV__) {
   const allowedGlobals = makeMap(
     'Infinity,undefined,NaN,isFinite,isNaN,' +
       'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
diff --git a/src/core/instance/render-helpers/bind-dynamic-keys.ts b/src/core/instance/render-helpers/bind-dynamic-keys.ts
index 2f1de7e76ed..a1fefa65816 100644
--- a/src/core/instance/render-helpers/bind-dynamic-keys.ts
+++ b/src/core/instance/render-helpers/bind-dynamic-keys.ts
@@ -17,11 +17,7 @@ export function bindDynamicKeys(
     const key = values[i]
     if (typeof key === 'string' && key) {
       baseObj[values[i]] = values[i + 1]
-    } else if (
-      process.env.NODE_ENV !== 'production' &&
-      key !== '' &&
-      key !== null
-    ) {
+    } else if (__DEV__ && key !== '' && key !== null) {
       // null is a special value for explicitly removing a binding
       warn(
         `Invalid value for dynamic directive argument (expected string or null): ${key}`,
diff --git a/src/core/instance/render-helpers/bind-object-listeners.ts b/src/core/instance/render-helpers/bind-object-listeners.ts
index b4d2417f620..753f78207e5 100644
--- a/src/core/instance/render-helpers/bind-object-listeners.ts
+++ b/src/core/instance/render-helpers/bind-object-listeners.ts
@@ -4,8 +4,7 @@ import type { VNodeData } from 'typescript/vnode'
 export function bindObjectListeners(data: any, value: any): VNodeData {
   if (value) {
     if (!isPlainObject(value)) {
-      process.env.NODE_ENV !== 'production' &&
-        warn('v-on without argument expects an Object value', this)
+      __DEV__ && warn('v-on without argument expects an Object value', this)
     } else {
       const on = (data.on = data.on ? extend({}, data.on) : {})
       for (const key in value) {
diff --git a/src/core/instance/render-helpers/bind-object-props.ts b/src/core/instance/render-helpers/bind-object-props.ts
index 9050cd8c694..56b597eb869 100644
--- a/src/core/instance/render-helpers/bind-object-props.ts
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -22,7 +22,7 @@ export function bindObjectProps(
 ): VNodeData {
   if (value) {
     if (!isObject(value)) {
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
         warn('v-bind without argument expects an Object or Array value', this)
     } else {
       if (Array.isArray(value)) {
diff --git a/src/core/instance/render-helpers/render-slot.ts b/src/core/instance/render-helpers/render-slot.ts
index f2c82a7a744..7843108c31b 100644
--- a/src/core/instance/render-helpers/render-slot.ts
+++ b/src/core/instance/render-helpers/render-slot.ts
@@ -16,7 +16,7 @@ export function renderSlot(
     // scoped slot
     props = props || {}
     if (bindObject) {
-      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
+      if (__DEV__ && !isObject(bindObject)) {
         warn('slot v-bind without argument expects an Object', this)
       }
       props = extend(extend({}, bindObject), props)
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 4696399d57e..941803f78aa 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -39,7 +39,7 @@ export function initRender(vm: Component) {
   const parentData = parentVnode && parentVnode.data
 
   /* istanbul ignore else */
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     defineReactive(
       vm,
       '$attrs',
@@ -119,7 +119,7 @@ export function renderMixin(Vue: Component) {
       // return error render result,
       // or previous vnode to prevent render error causing blank component
       /* istanbul ignore else */
-      if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {
+      if (__DEV__ && vm.$options.renderError) {
         try {
           vnode = vm.$options.renderError.call(
             vm._renderProxy,
@@ -142,7 +142,7 @@ export function renderMixin(Vue: Component) {
     }
     // return empty vnode in case the render function errored out
     if (!(vnode instanceof VNode)) {
-      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
+      if (__DEV__ && Array.isArray(vnode)) {
         warn(
           'Multiple root nodes returned from render function. Render function ' +
             'should return a single root node.',
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 2f91f1bf2c9..e337e92ba7d 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -76,7 +76,7 @@ function initProps(vm: Component, propsOptions: Object) {
     keys.push(key)
     const value = validateProp(key, propsOptions, propsData, vm)
     /* istanbul ignore else */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       const hyphenatedKey = hyphenate(key)
       if (
         isReservedAttribute(hyphenatedKey) ||
@@ -116,7 +116,7 @@ function initData(vm: Component) {
   data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {}
   if (!isPlainObject(data)) {
     data = {}
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
       warn(
         'data functions should return an object:\n' +
           'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
@@ -130,13 +130,13 @@ function initData(vm: Component) {
   let i = keys.length
   while (i--) {
     const key = keys[i]
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if (methods && hasOwn(methods, key)) {
         warn(`Method "${key}" has already been defined as a data property.`, vm)
       }
     }
     if (props && hasOwn(props, key)) {
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
         warn(
           `The data property "${key}" is already declared as a prop. ` +
             `Use prop default value instead.`,
@@ -174,7 +174,7 @@ function initComputed(vm: Component, computed: Object) {
   for (const key in computed) {
     const userDef = computed[key]
     const getter = typeof userDef === 'function' ? userDef : userDef.get
-    if (process.env.NODE_ENV !== 'production' && getter == null) {
+    if (__DEV__ && getter == null) {
       warn(`Getter is missing for computed property "${key}".`, vm)
     }
 
@@ -193,7 +193,7 @@ function initComputed(vm: Component, computed: Object) {
     // at instantiation here.
     if (!(key in vm)) {
       defineComputed(vm, key, userDef)
-    } else if (process.env.NODE_ENV !== 'production') {
+    } else if (__DEV__) {
       if (key in vm.$data) {
         warn(`The computed property "${key}" is already defined in data.`, vm)
       } else if (vm.$options.props && key in vm.$options.props) {
@@ -227,10 +227,7 @@ export function defineComputed(
       : noop
     sharedPropertyDefinition.set = userDef.set || noop
   }
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    sharedPropertyDefinition.set === noop
-  ) {
+  if (__DEV__ && sharedPropertyDefinition.set === noop) {
     sharedPropertyDefinition.set = function () {
       warn(
         `Computed property "${key}" was assigned to but it has no setter.`,
@@ -265,7 +262,7 @@ function createGetterInvoker(fn) {
 function initMethods(vm: Component, methods: Object) {
   const props = vm.$options.props
   for (const key in methods) {
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if (typeof methods[key] !== 'function') {
         warn(
           `Method "${key}" has type "${typeof methods[
@@ -330,7 +327,7 @@ export function stateMixin(Vue: Component) {
   propsDef.get = function () {
     return this._props
   }
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     dataDef.set = function () {
       warn(
         'Avoid replacing instance root $data. ' +
diff --git a/src/core/observer/dep.ts b/src/core/observer/dep.ts
index b03c053a254..3bf256ba034 100644
--- a/src/core/observer/dep.ts
+++ b/src/core/observer/dep.ts
@@ -35,7 +35,7 @@ export default class Dep {
   notify() {
     // stabilize the subscriber list first
     const subs = this.subs.slice()
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
+    if (__DEV__ && !config.async) {
       // subs aren't sorted in scheduler if not running async
       // we need to sort them now to make sure they fire in correct
       // order
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index f8bb1fa62a0..605f987c45d 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -175,7 +175,7 @@ export function defineReactive(
         return
       }
       /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
+      if (__DEV__ && customSetter) {
         customSetter()
       }
       // #7981: for accessor properties without setter
@@ -201,10 +201,7 @@ export function set(
   key: any,
   val: any
 ): any {
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
+  if (__DEV__ && (isUndef(target) || isPrimitive(target))) {
     warn(
       `Cannot set reactive property on undefined, null, or primitive value: ${target}`
     )
@@ -220,7 +217,7 @@ export function set(
   }
   const ob = (target as any).__ob__
   if ((target as any)._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
       warn(
         'Avoid adding reactive properties to a Vue instance or its root $data ' +
           'at runtime - declare it upfront in the data option.'
@@ -240,10 +237,7 @@ export function set(
  * Delete a property and trigger change if necessary.
  */
 export function del(target: Array<any> | Object, key: any) {
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
+  if (__DEV__ && (isUndef(target) || isPrimitive(target))) {
     warn(
       `Cannot delete reactive property on undefined, null, or primitive value: ${target}`
     )
@@ -254,7 +248,7 @@ export function del(target: Array<any> | Object, key: any) {
   }
   const ob = (target as any).__ob__
   if ((target as any)._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
       warn(
         'Avoid deleting properties on a Vue instance or its root $data ' +
           '- just set it to null.'
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index 3c2d0b7ea4a..6d327797548 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -21,7 +21,7 @@ let index = 0
 function resetSchedulerState() {
   index = queue.length = activatedChildren.length = 0
   has = {}
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     circular = {}
   }
   waiting = flushing = false
@@ -87,7 +87,7 @@ function flushSchedulerQueue() {
     has[id] = null
     watcher.run()
     // in dev build, check and stop circular updates.
-    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+    if (__DEV__ && has[id] != null) {
       circular[id] = (circular[id] || 0) + 1
       if (circular[id] > MAX_UPDATE_COUNT) {
         warn(
@@ -172,7 +172,7 @@ export function queueWatcher(watcher: Watcher) {
     if (!waiting) {
       waiting = true
 
-      if (process.env.NODE_ENV !== 'production' && !config.async) {
+      if (__DEV__ && !config.async) {
         flushSchedulerQueue()
         return
       }
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index f5539372bfe..d8a811d5265 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -78,8 +78,7 @@ export default class Watcher {
     this.newDeps = []
     this.depIds = new Set()
     this.newDepIds = new Set()
-    this.expression =
-      process.env.NODE_ENV !== 'production' ? expOrFn.toString() : ''
+    this.expression = __DEV__ ? expOrFn.toString() : ''
     // parse expression for getter
     if (typeof expOrFn === 'function') {
       this.getter = expOrFn
@@ -87,7 +86,7 @@ export default class Watcher {
       this.getter = parsePath(expOrFn)
       if (!this.getter) {
         this.getter = noop
-        process.env.NODE_ENV !== 'production' &&
+        __DEV__ &&
           warn(
             `Failed watching path: "${expOrFn}" ` +
               'Watcher only accepts simple dot-delimited paths. ' +
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index f44fe86a277..18f13ce0b69 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -7,7 +7,7 @@ export let tip = noop
 export let generateComponentTrace: (vm: Component) => string // work around flow check
 export let formatComponentName: (vm: Component, includeFile?: false) => string
 
-if (process.env.NODE_ENV !== 'production') {
+if (__DEV__) {
   const hasConsole = typeof console !== 'undefined'
   const classifyRE = /(?:^|[-_])(\w)/g
   const classify = str =>
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index 093e8731469..693fadb5701 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -69,7 +69,7 @@ function globalHandleError(err, vm, info) {
 }
 
 function logError(err, vm, info) {
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     warn(`Error in ${info}: "${err.toString()}"`, vm)
   }
   /* istanbul ignore else */
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index 2850ad26edc..8f32a26e1e0 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -28,7 +28,7 @@ const strats = config.optionMergeStrategies
 /**
  * Options with restrictions
  */
-if (process.env.NODE_ENV !== 'production') {
+if (__DEV__) {
   strats.el = strats.propsData = function (
     parent: any,
     child: any,
@@ -128,7 +128,7 @@ strats.data = function (
 ): Function | null {
   if (!vm) {
     if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
         warn(
           'The "data" option should be a function ' +
             'that returns a per-instance value in component ' +
@@ -190,7 +190,7 @@ function mergeAssets(
 ): Object {
   const res = Object.create(parentVal || null)
   if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm)
+    __DEV__ && assertObjectType(key, childVal, vm)
     return extend(res, childVal)
   } else {
     return res
@@ -220,7 +220,7 @@ strats.watch = function (
   if (childVal === nativeWatch) childVal = undefined
   /* istanbul ignore if */
   if (!childVal) return Object.create(parentVal || null)
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     assertObjectType(key, childVal, vm)
   }
   if (!parentVal) return childVal
@@ -254,7 +254,7 @@ strats.props =
       vm: Component | null,
       key: string
     ): Object | null {
-      if (childVal && process.env.NODE_ENV !== 'production') {
+      if (childVal && __DEV__) {
         assertObjectType(key, childVal, vm)
       }
       if (!parentVal) return childVal
@@ -317,7 +317,7 @@ function normalizeProps(options: Record<string, any>, vm?: Component | null) {
       if (typeof val === 'string') {
         name = camelize(val)
         res[name] = { type: null }
-      } else if (process.env.NODE_ENV !== 'production') {
+      } else if (__DEV__) {
         warn('props must be strings when using array syntax.')
       }
     }
@@ -327,7 +327,7 @@ function normalizeProps(options: Record<string, any>, vm?: Component | null) {
       name = camelize(key)
       res[name] = isPlainObject(val) ? val : { type: val }
     }
-  } else if (process.env.NODE_ENV !== 'production') {
+  } else if (__DEV__) {
     warn(
       `Invalid value for option "props": expected an Array or an Object, ` +
         `but got ${toRawType(props)}.`,
@@ -355,7 +355,7 @@ function normalizeInject(options: Record<string, any>, vm?: Component | null) {
         ? extend({ from: key }, val)
         : { from: val }
     }
-  } else if (process.env.NODE_ENV !== 'production') {
+  } else if (__DEV__) {
     warn(
       `Invalid value for option "inject": expected an Array or an Object, ` +
         `but got ${toRawType(inject)}.`,
@@ -398,7 +398,7 @@ export function mergeOptions(
   child: Record<string, any>,
   vm?: Component | null
 ): ComponentOptions {
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     checkComponents(child)
   }
 
@@ -467,7 +467,7 @@ export function resolveAsset(
   if (hasOwn(assets, PascalCaseId)) return assets[PascalCaseId]
   // fallback to prototype chain
   const res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
-  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
+  if (__DEV__ && warnMissing && !res) {
     warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options)
   }
   return res
diff --git a/src/core/util/perf.ts b/src/core/util/perf.ts
index c0c8a277633..eb42cdbe57f 100644
--- a/src/core/util/perf.ts
+++ b/src/core/util/perf.ts
@@ -3,7 +3,7 @@ import { inBrowser } from './env'
 export let mark
 export let measure
 
-if (process.env.NODE_ENV !== 'production') {
+if (__DEV__) {
   const perf = inBrowser && window.performance
   /* istanbul ignore if */
   if (
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index 168d133b76f..d3a528e12bf 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -50,7 +50,7 @@ export function validateProp(
     observe(value)
     toggleObserving(prevShouldObserve)
   }
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     assertProp(prop, key, value, vm, absent)
   }
   return value
@@ -70,7 +70,7 @@ function getPropDefaultValue(
   }
   const def = prop.default
   // warn against non-factory defaults for Object & Array
-  if (process.env.NODE_ENV !== 'production' && isObject(def)) {
+  if (__DEV__ && isObject(def)) {
     warn(
       'Invalid default value for prop "' +
         key +
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index d35cd266173..9813620484f 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -114,7 +114,7 @@ export function createComponent(
   // if at this stage it's not a constructor or an async component factory,
   // reject.
   if (typeof Ctor !== 'function') {
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       warn(`Invalid Component definition: ${String(Ctor)}`, context)
     }
     return
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index 4dd695a0863..f81aec564c6 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -49,7 +49,7 @@ export function _createElement(
   normalizationType?: number
 ): VNode | Array<VNode> {
   if (isDef(data) && isDef((data as any).__ob__)) {
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
       warn(
         `Avoid using observed data object as vnode data: ${JSON.stringify(
           data
@@ -67,12 +67,7 @@ export function _createElement(
     return createEmptyVNode()
   }
   // warn against non-primitive key
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    isDef(data) &&
-    isDef(data.key) &&
-    !isPrimitive(data.key)
-  ) {
+  if (__DEV__ && isDef(data) && isDef(data.key) && !isPrimitive(data.key)) {
     warn(
       'Avoid using non-primitive value as key, ' +
         'use string/number value instead.',
@@ -97,7 +92,7 @@ export function _createElement(
     if (config.isReservedTag(tag)) {
       // platform built-in elements
       if (
-        process.env.NODE_ENV !== 'production' &&
+        __DEV__ &&
         isDef(data) &&
         isDef(data.nativeOn) &&
         data.tag !== 'component'
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index b5700949353..34dddd15fec 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -158,7 +158,7 @@ function cloneAndMarkFunctionalResult(
   const clone = cloneVNode(vnode)
   clone.fnContext = contextVm
   clone.fnOptions = options
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     ;(clone.devtoolsMeta = clone.devtoolsMeta || ({} as any)).renderContext =
       renderContext
   }
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index b68107df5f0..b97637ad4a0 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -26,7 +26,7 @@ export function extractPropsFromVNodeData(
   if (isDef(attrs) || isDef(props)) {
     for (const key in propOptions) {
       const altKey = hyphenate(key)
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         const keyInLowerCase = key.toLowerCase()
         if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) {
           tip(
diff --git a/src/core/vdom/helpers/resolve-async-component.ts b/src/core/vdom/helpers/resolve-async-component.ts
index 4b965b3cfde..ea89092e9b3 100644
--- a/src/core/vdom/helpers/resolve-async-component.ts
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -96,7 +96,7 @@ export function resolveAsyncComponent(
     })
 
     const reject = once(reason => {
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
         warn(
           `Failed to resolve async component: ${String(factory)}` +
             (reason ? `\nReason: ${reason}` : '')
@@ -143,11 +143,7 @@ export function resolveAsyncComponent(
           timerTimeout = setTimeout(() => {
             timerTimeout = null
             if (isUndef(factory.resolved)) {
-              reject(
-                process.env.NODE_ENV !== 'production'
-                  ? `timeout (${res.timeout}ms)`
-                  : null
-              )
+              reject(__DEV__ ? `timeout (${res.timeout}ms)` : null)
             }
           }, res.timeout)
         }
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index 801cbe9a6ec..0443bd02e4d 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -74,7 +74,7 @@ export function updateListeners(
     old = oldOn[name]
     event = normalizeEvent(name)
     if (isUndef(cur)) {
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
         warn(
           `Invalid handler for event "${event.name}": got ` + String(cur),
           vm
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index ec47e2c36a1..ba6a1b9369d 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -144,7 +144,7 @@ export function createPatchFunction(backend) {
     const children = vnode.children
     const tag = vnode.tag
     if (isDef(tag)) {
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         if (data && data.pre) {
           creatingElmInVPre++
         }
@@ -171,7 +171,7 @@ export function createPatchFunction(backend) {
       }
       insert(parentElm, vnode.elm, refElm)
 
-      if (process.env.NODE_ENV !== 'production' && data && data.pre) {
+      if (__DEV__ && data && data.pre) {
         creatingElmInVPre--
       }
     } else if (isTrue(vnode.isComment)) {
@@ -262,7 +262,7 @@ export function createPatchFunction(backend) {
 
   function createChildren(vnode, children, insertedVnodeQueue) {
     if (Array.isArray(children)) {
-      if (process.env.NODE_ENV !== 'production') {
+      if (__DEV__) {
         checkDuplicateKeys(children)
       }
       for (let i = 0; i < children.length; ++i) {
@@ -431,7 +431,7 @@ export function createPatchFunction(backend) {
     // during leaving transitions
     const canMove = !removeOnly
 
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       checkDuplicateKeys(newCh)
     }
 
@@ -639,7 +639,7 @@ export function createPatchFunction(backend) {
         if (oldCh !== ch)
           updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)
       } else if (isDef(ch)) {
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           checkDuplicateKeys(ch)
         }
         if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
@@ -688,7 +688,7 @@ export function createPatchFunction(backend) {
       return true
     }
     // assert node match
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       if (!assertNodeMatch(elm, vnode, inVPre)) {
         return false
       }
@@ -717,7 +717,7 @@ export function createPatchFunction(backend) {
             if (i !== elm.innerHTML) {
               /* istanbul ignore if */
               if (
-                process.env.NODE_ENV !== 'production' &&
+                __DEV__ &&
                 typeof console !== 'undefined' &&
                 !hydrationBailed
               ) {
@@ -747,7 +747,7 @@ export function createPatchFunction(backend) {
             if (!childrenMatch || childNode) {
               /* istanbul ignore if */
               if (
-                process.env.NODE_ENV !== 'production' &&
+                __DEV__ &&
                 typeof console !== 'undefined' &&
                 !hydrationBailed
               ) {
@@ -828,7 +828,7 @@ export function createPatchFunction(backend) {
             if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
               invokeInsertHook(vnode, insertedVnodeQueue, true)
               return oldVnode
-            } else if (process.env.NODE_ENV !== 'production') {
+            } else if (__DEV__) {
               warn(
                 'The client-side rendered virtual DOM tree is not matching ' +
                   'server-rendered content. This is likely caused by incorrect ' +
diff --git a/src/global.d.ts b/src/global.d.ts
index 0fabe95c676..5a28776b988 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,3 +1,5 @@
+declare const __DEV__: boolean
+
 interface Window {
   __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook
 }
diff --git a/src/platforms/web/compiler/directives/model.ts b/src/platforms/web/compiler/directives/model.ts
index 8dd3ed4a2b9..2db1b483a78 100644
--- a/src/platforms/web/compiler/directives/model.ts
+++ b/src/platforms/web/compiler/directives/model.ts
@@ -20,7 +20,7 @@ export default function model(
   const tag = el.tag
   const type = el.attrsMap.type
 
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     // inputs with type="file" are read only and setting the input's
     // value will throw an error.
     if (tag === 'input' && type === 'file') {
@@ -48,7 +48,7 @@ export default function model(
     genComponentModel(el, value, modifiers)
     // component v-model doesn't need extra runtime
     return false
-  } else if (process.env.NODE_ENV !== 'production') {
+  } else if (__DEV__) {
     warn(
       `<${el.tag} v-model="${value}">: ` +
         `v-model is not supported on this element type. ` +
@@ -142,7 +142,7 @@ function genDefaultModel(
 
   // warn if v-bind:value conflicts with v-model
   // except for inputs with v-bind:type
-  if (process.env.NODE_ENV !== 'production') {
+  if (__DEV__) {
     const value = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
     const typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
     if (value && !typeBinding) {
diff --git a/src/platforms/web/compiler/modules/class.ts b/src/platforms/web/compiler/modules/class.ts
index 4789c3d09b5..f4c5b7bd27d 100644
--- a/src/platforms/web/compiler/modules/class.ts
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -4,7 +4,7 @@ import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
 function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
   const staticClass = getAndRemoveAttr(el, 'class')
-  if (process.env.NODE_ENV !== 'production' && staticClass) {
+  if (__DEV__ && staticClass) {
     const res = parseText(staticClass, options.delimiters)
     if (res) {
       warn(
diff --git a/src/platforms/web/compiler/modules/style.ts b/src/platforms/web/compiler/modules/style.ts
index 8daf3b66df9..d7eeeb0f4d6 100644
--- a/src/platforms/web/compiler/modules/style.ts
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -7,7 +7,7 @@ function transformNode(el: ASTElement, options: CompilerOptions) {
   const staticStyle = getAndRemoveAttr(el, 'style')
   if (staticStyle) {
     /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       const res = parseText(staticStyle, options.delimiters)
       if (res) {
         warn(
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index 7d11b79fb96..8bb02675f43 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -26,7 +26,7 @@ Vue.prototype.$mount = function (
 
   /* istanbul ignore if */
   if (el === document.body || el === document.documentElement) {
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
       warn(
         `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
       )
@@ -42,7 +42,7 @@ Vue.prototype.$mount = function (
         if (template.charAt(0) === '#') {
           template = idToTemplate(template)
           /* istanbul ignore if */
-          if (process.env.NODE_ENV !== 'production' && !template) {
+          if (__DEV__ && !template) {
             warn(
               `Template element not found or is empty: ${options.template}`,
               this
@@ -52,7 +52,7 @@ Vue.prototype.$mount = function (
       } else if (template.nodeType) {
         template = template.innerHTML
       } else {
-        if (process.env.NODE_ENV !== 'production') {
+        if (__DEV__) {
           warn('invalid template option:' + template, this)
         }
         return this
@@ -63,14 +63,14 @@ Vue.prototype.$mount = function (
     }
     if (template) {
       /* istanbul ignore if */
-      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+      if (__DEV__ && config.performance && mark) {
         mark('compile')
       }
 
       const { render, staticRenderFns } = compileToFunctions(
         template,
         {
-          outputSourceRange: process.env.NODE_ENV !== 'production',
+          outputSourceRange: __DEV__,
           shouldDecodeNewlines,
           shouldDecodeNewlinesForHref,
           delimiters: options.delimiters,
@@ -82,7 +82,7 @@ Vue.prototype.$mount = function (
       options.staticRenderFns = staticRenderFns
 
       /* istanbul ignore if */
-      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {
+      if (__DEV__ && config.performance && mark) {
         mark('compile end')
         measure(`vue ${this._name} compile`, 'compile', 'compile end')
       }
diff --git a/src/platforms/web/runtime/components/transition-group.ts b/src/platforms/web/runtime/components/transition-group.ts
index 664d3c4599d..ee72009f547 100644
--- a/src/platforms/web/runtime/components/transition-group.ts
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -69,7 +69,7 @@ export default {
           children.push(c)
           map[c.key] = c
           ;(c.data || (c.data = {})).transition = transitionData
-        } else if (process.env.NODE_ENV !== 'production') {
+        } else if (__DEV__) {
           const opts = c.componentOptions
           const name: string = opts
             ? opts.Ctor.options.name || opts.tag || ''
diff --git a/src/platforms/web/runtime/components/transition.ts b/src/platforms/web/runtime/components/transition.ts
index 782c0b6d300..2dc6b847eed 100644
--- a/src/platforms/web/runtime/components/transition.ts
+++ b/src/platforms/web/runtime/components/transition.ts
@@ -100,7 +100,7 @@ export default {
     }
 
     // warn multiple elements
-    if (process.env.NODE_ENV !== 'production' && children.length > 1) {
+    if (__DEV__ && children.length > 1) {
       warn(
         '<transition> can only be used on a single element. Use ' +
           '<transition-group> for lists.',
@@ -111,12 +111,7 @@ export default {
     const mode: string = this.mode
 
     // warn invalid mode
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      mode &&
-      mode !== 'in-out' &&
-      mode !== 'out-in'
-    ) {
+    if (__DEV__ && mode && mode !== 'in-out' && mode !== 'out-in') {
       warn('invalid <transition> mode: ' + mode, this.$parent)
     }
 
diff --git a/src/platforms/web/runtime/directives/model.ts b/src/platforms/web/runtime/directives/model.ts
index 799113ca816..b5430894f6e 100644
--- a/src/platforms/web/runtime/directives/model.ts
+++ b/src/platforms/web/runtime/directives/model.ts
@@ -88,7 +88,7 @@ function actuallySetSelected(el, binding, vm) {
   const value = binding.value
   const isMultiple = el.multiple
   if (isMultiple && !Array.isArray(value)) {
-    process.env.NODE_ENV !== 'production' &&
+    __DEV__ &&
       warn(
         `<select multiple v-model="${binding.expression}"> ` +
           `expects an Array value for its binding, but got ${Object.prototype.toString
diff --git a/src/platforms/web/runtime/index.ts b/src/platforms/web/runtime/index.ts
index 28a55ce9053..1d8541931a1 100644
--- a/src/platforms/web/runtime/index.ts
+++ b/src/platforms/web/runtime/index.ts
@@ -48,10 +48,7 @@ if (inBrowser) {
     if (config.devtools) {
       if (devtools) {
         devtools.emit('init', Vue)
-      } else if (
-        process.env.NODE_ENV !== 'production' &&
-        process.env.NODE_ENV !== 'test'
-      ) {
+      } else if (__DEV__ && process.env.NODE_ENV !== 'test') {
         // @ts-expect-error
         console[console.info ? 'info' : 'log'](
           'Download the Vue Devtools extension for a better development experience:\n' +
@@ -60,7 +57,7 @@ if (inBrowser) {
       }
     }
     if (
-      process.env.NODE_ENV !== 'production' &&
+      __DEV__ &&
       process.env.NODE_ENV !== 'test' &&
       config.productionTip !== false &&
       typeof console !== 'undefined'
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index 69f03fd150b..4f8b31a1e3f 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -91,7 +91,7 @@ export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
     isObject(duration) ? duration.enter : duration
   )
 
-  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {
+  if (__DEV__ && explicitEnterDuration != null) {
     checkDuration(explicitEnterDuration, 'enter', vnode)
   }
 
@@ -203,7 +203,7 @@ export function leave(vnode: VNodeWithData, rm: Function) {
     isObject(duration) ? duration.leave : duration
   )
 
-  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {
+  if (__DEV__ && isDef(explicitLeaveDuration)) {
     checkDuration(explicitLeaveDuration, 'leave', vnode)
   }
 
diff --git a/src/platforms/web/util/index.ts b/src/platforms/web/util/index.ts
index 8bdce82514a..e02a0dc955e 100644
--- a/src/platforms/web/util/index.ts
+++ b/src/platforms/web/util/index.ts
@@ -11,8 +11,7 @@ export function query(el: string | Element): Element {
   if (typeof el === 'string') {
     const selected = document.querySelector(el)
     if (!selected) {
-      process.env.NODE_ENV !== 'production' &&
-        warn('Cannot find element: ' + el)
+      __DEV__ && warn('Cannot find element: ' + el)
       return document.createElement('div')
     }
     return selected
diff --git a/src/server/template-renderer/index.ts b/src/server/template-renderer/index.ts
index 992af98c8e2..124ece4cf51 100644
--- a/src/server/template-renderer/index.ts
+++ b/src/server/template-renderer/index.ts
@@ -231,10 +231,9 @@ export default class TemplateRenderer {
     const { contextKey = 'state', windowKey = '__INITIAL_STATE__' } =
       options || {}
     const state = this.serialize(context[contextKey])
-    const autoRemove =
-      process.env.NODE_ENV === 'production'
-        ? ';(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());'
-        : ''
+    const autoRemove = __DEV__
+      ? ''
+      : ';(function(){var s;(s=document.currentScript||document.scripts[document.scripts.length-1]).parentNode.removeChild(s);}());'
     const nonceAttr = context.nonce ? ` nonce="${context.nonce}"` : ''
     return context[contextKey]
       ? `<script${nonceAttr}>window.${windowKey}=${state}${autoRemove}</script>`
diff --git a/src/sfc/parser.ts b/src/sfc/parser.ts
index cc4c43a5935..9de84e21056 100644
--- a/src/sfc/parser.ts
+++ b/src/sfc/parser.ts
@@ -27,7 +27,7 @@ export function parseComponent(
     sfc.errors.push(msg)
   }
 
-  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+  if (__DEV__ && options.outputSourceRange) {
     warn = (msg, range) => {
       const data: WarningMessage = { msg }
       if (range.start != null) {
diff --git a/vitest.config.ts b/vitest.config.ts
index 35f7d2c68f2..ec26dec727b 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -15,6 +15,9 @@ export default defineConfig({
       vue: resolve('src/platforms/web/entry-runtime-with-compiler')
     }
   },
+  define: {
+    __DEV__: true
+  },
   test: {
     globals: true,
     environment: 'jsdom',

From 450767f3bbad98cce99a206484b26afa0c328805 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 24 May 2022 21:48:01 +0800
Subject: [PATCH 069/317] refactor: isArray

---
 src/core/components/keep-alive.ts             |  4 ++--
 src/core/instance/events.ts                   |  5 ++--
 .../render-helpers/bind-object-props.ts       |  5 ++--
 .../instance/render-helpers/check-keycodes.ts |  4 ++--
 .../instance/render-helpers/render-list.ts    |  4 ++--
 .../instance/render-helpers/render-static.ts  |  3 ++-
 .../render-helpers/resolve-scoped-slots.ts    |  3 ++-
 src/core/instance/render.ts                   |  7 +++---
 src/core/instance/state.ts                    |  3 ++-
 src/core/observer/dep.ts                      | 19 +++++++++------
 src/core/observer/index.ts                    | 13 +++++-----
 src/core/observer/traverse.ts                 |  4 ++--
 src/core/observer/watcher.ts                  | 24 ++++++++++++-------
 src/core/util/debug.ts                        |  5 ++--
 src/core/util/options.ts                      | 15 +++++-------
 src/core/util/props.ts                        |  7 +++---
 src/core/vdom/create-component.ts             |  3 ++-
 src/core/vdom/create-element.ts               |  7 +++---
 src/core/vdom/create-functional-component.ts  |  5 ++--
 .../vdom/helpers/get-first-component-child.ts |  4 ++--
 src/core/vdom/helpers/normalize-children.ts   | 15 ++++++++----
 .../vdom/helpers/normalize-scoped-slots.ts    |  4 ++--
 src/core/vdom/helpers/update-listeners.ts     |  4 ++--
 src/core/vdom/modules/ref.ts                  |  6 ++---
 src/core/vdom/patch.ts                        |  3 ++-
 src/shared/util.ts                            |  2 ++
 26 files changed, 104 insertions(+), 74 deletions(-)

diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index 605167f1522..15bea54da9c 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -1,4 +1,4 @@
-import { isRegExp, remove } from 'shared/util'
+import { isRegExp, isArray, remove } from 'shared/util'
 import { getFirstComponentChild } from 'core/vdom/helpers/index'
 import type VNode from 'core/vdom/vnode'
 import type { VNodeComponentOptions } from 'typescript/vnode'
@@ -20,7 +20,7 @@ function matches(
   pattern: string | RegExp | Array<string>,
   name: string
 ): boolean {
-  if (Array.isArray(pattern)) {
+  if (isArray(pattern)) {
     return pattern.indexOf(name) > -1
   } else if (typeof pattern === 'string') {
     return pattern.split(',').indexOf(name) > -1
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index 36dff2e643e..9affa565a23 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -2,6 +2,7 @@ import type { Component } from 'typescript/component'
 import {
   tip,
   toArray,
+  isArray,
   hyphenate,
   formatComponentName,
   invokeWithErrorHandling
@@ -62,7 +63,7 @@ export function eventsMixin(Vue: Component) {
     fn: Function
   ): Component {
     const vm: Component = this
-    if (Array.isArray(event)) {
+    if (isArray(event)) {
       for (let i = 0, l = event.length; i < l; i++) {
         vm.$on(event[i], fn)
       }
@@ -99,7 +100,7 @@ export function eventsMixin(Vue: Component) {
       return vm
     }
     // array of events
-    if (Array.isArray(event)) {
+    if (isArray(event)) {
       for (let i = 0, l = event.length; i < l; i++) {
         vm.$off(event[i], fn)
       }
diff --git a/src/core/instance/render-helpers/bind-object-props.ts b/src/core/instance/render-helpers/bind-object-props.ts
index 56b597eb869..d37fc69eb9b 100644
--- a/src/core/instance/render-helpers/bind-object-props.ts
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -6,7 +6,8 @@ import {
   toObject,
   isReservedAttribute,
   camelize,
-  hyphenate
+  hyphenate,
+  isArray
 } from 'core/util/index'
 import type { VNodeData } from 'typescript/vnode'
 
@@ -25,7 +26,7 @@ export function bindObjectProps(
       __DEV__ &&
         warn('v-bind without argument expects an Object or Array value', this)
     } else {
-      if (Array.isArray(value)) {
+      if (isArray(value)) {
         value = toObject(value)
       }
       let hash
diff --git a/src/core/instance/render-helpers/check-keycodes.ts b/src/core/instance/render-helpers/check-keycodes.ts
index 0f58b54d55b..482051ffd19 100644
--- a/src/core/instance/render-helpers/check-keycodes.ts
+++ b/src/core/instance/render-helpers/check-keycodes.ts
@@ -1,8 +1,8 @@
 import config from 'core/config'
-import { hyphenate } from 'shared/util'
+import { hyphenate, isArray } from 'shared/util'
 
 function isKeyNotMatch<T>(expect: T | Array<T>, actual: T): boolean {
-  if (Array.isArray(expect)) {
+  if (isArray(expect)) {
     return expect.indexOf(actual) === -1
   } else {
     return expect !== actual
diff --git a/src/core/instance/render-helpers/render-list.ts b/src/core/instance/render-helpers/render-list.ts
index 8f7f6ed9e28..ba9318d3ded 100644
--- a/src/core/instance/render-helpers/render-list.ts
+++ b/src/core/instance/render-helpers/render-list.ts
@@ -1,4 +1,4 @@
-import { isObject, isDef, hasSymbol } from 'core/util/index'
+import { isObject, isDef, hasSymbol, isArray } from 'core/util/index'
 import VNode from 'core/vdom/vnode'
 
 /**
@@ -13,7 +13,7 @@ export function renderList(
     l,
     keys,
     key
-  if (Array.isArray(val) || typeof val === 'string') {
+  if (isArray(val) || typeof val === 'string') {
     ret = new Array(val.length)
     for (i = 0, l = val.length; i < l; i++) {
       ret[i] = render(val[i], i)
diff --git a/src/core/instance/render-helpers/render-static.ts b/src/core/instance/render-helpers/render-static.ts
index c6aa669dd59..4c7fb0b7777 100644
--- a/src/core/instance/render-helpers/render-static.ts
+++ b/src/core/instance/render-helpers/render-static.ts
@@ -1,4 +1,5 @@
 import VNode from 'core/vdom/vnode'
+import { isArray } from 'core/util'
 
 /**
  * Runtime helper for rendering static trees.
@@ -38,7 +39,7 @@ export function markOnce(
 }
 
 function markStatic(tree: VNode | Array<VNode>, key: string, isOnce: boolean) {
-  if (Array.isArray(tree)) {
+  if (isArray(tree)) {
     for (let i = 0; i < tree.length; i++) {
       if (tree[i] && typeof tree[i] !== 'string') {
         markStaticNode(tree[i], `${key}_${i}`, isOnce)
diff --git a/src/core/instance/render-helpers/resolve-scoped-slots.ts b/src/core/instance/render-helpers/resolve-scoped-slots.ts
index c5bd2903316..1ba8951c199 100644
--- a/src/core/instance/render-helpers/resolve-scoped-slots.ts
+++ b/src/core/instance/render-helpers/resolve-scoped-slots.ts
@@ -1,4 +1,5 @@
 import type { ScopedSlotsData } from 'typescript/vnode'
+import { isArray } from 'core/util'
 
 export function resolveScopedSlots(
   fns: ScopedSlotsData,
@@ -10,7 +11,7 @@ export function resolveScopedSlots(
   res = res || { $stable: !hasDynamicKeys }
   for (let i = 0; i < fns.length; i++) {
     const slot = fns[i]
-    if (Array.isArray(slot)) {
+    if (isArray(slot)) {
       resolveScopedSlots(slot, res, hasDynamicKeys)
     } else if (slot) {
       // marker for reverse proxying v-slot without scope on this.$slots
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 941803f78aa..4da1b2f3b50 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -3,7 +3,8 @@ import {
   nextTick,
   emptyObject,
   handleError,
-  defineReactive
+  defineReactive,
+  isArray
 } from '../util/index'
 
 import { createElement } from '../vdom/create-element'
@@ -137,12 +138,12 @@ export function renderMixin(Vue: Component) {
       currentRenderingInstance = null
     }
     // if the returned array contains only a single node, allow it
-    if (Array.isArray(vnode) && vnode.length === 1) {
+    if (isArray(vnode) && vnode.length === 1) {
       vnode = vnode[0]
     }
     // return empty vnode in case the render function errored out
     if (!(vnode instanceof VNode)) {
-      if (__DEV__ && Array.isArray(vnode)) {
+      if (__DEV__ && isArray(vnode)) {
         warn(
           'Multiple root nodes returned from render function. Render function ' +
             'should return a single root node.',
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index e337e92ba7d..6abfef2516e 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -16,6 +16,7 @@ import {
   bind,
   noop,
   hasOwn,
+  isArray,
   hyphenate,
   isReserved,
   handleError,
@@ -289,7 +290,7 @@ function initMethods(vm: Component, methods: Object) {
 function initWatch(vm: Component, watch: Object) {
   for (const key in watch) {
     const handler = watch[key]
-    if (Array.isArray(handler)) {
+    if (isArray(handler)) {
       for (let i = 0; i < handler.length; i++) {
         createWatcher(vm, key, handler[i])
       }
diff --git a/src/core/observer/dep.ts b/src/core/observer/dep.ts
index 3bf256ba034..df14f2f2f4c 100644
--- a/src/core/observer/dep.ts
+++ b/src/core/observer/dep.ts
@@ -1,28 +1,33 @@
-import type Watcher from './watcher'
 import { remove } from '../util/index'
 import config from '../config'
 
 let uid = 0
 
+export interface DepTarget {
+  id: number
+  addDep(dep: Dep): void
+  update(): void
+}
+
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
  */
 export default class Dep {
-  static target?: Watcher | null
+  static target?: DepTarget | null
   id: number
-  subs: Array<Watcher>
+  subs: Array<DepTarget>
 
   constructor() {
     this.id = uid++
     this.subs = []
   }
 
-  addSub(sub: Watcher) {
+  addSub(sub: DepTarget) {
     this.subs.push(sub)
   }
 
-  removeSub(sub: Watcher) {
+  removeSub(sub: DepTarget) {
     remove(this.subs, sub)
   }
 
@@ -51,9 +56,9 @@ export default class Dep {
 // This is globally unique because only one watcher
 // can be evaluated at a time.
 Dep.target = null
-const targetStack: Array<Watcher | null | undefined> = []
+const targetStack: Array<DepTarget | null | undefined> = []
 
-export function pushTarget(target?: Watcher | null) {
+export function pushTarget(target?: DepTarget | null) {
   targetStack.push(target)
   Dep.target = target
 }
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 605f987c45d..1a534c06182 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -5,6 +5,7 @@ import {
   def,
   warn,
   hasOwn,
+  isArray,
   hasProto,
   isObject,
   isPlainObject,
@@ -42,7 +43,7 @@ export class Observer {
     this.dep = new Dep()
     this.vmCount = 0
     def(value, '__ob__', this)
-    if (Array.isArray(value)) {
+    if (isArray(value)) {
       if (hasProto) {
         protoAugment(value, arrayMethods)
       } else {
@@ -115,7 +116,7 @@ export function observe(value: any, asRootData?: boolean): Observer | void {
   } else if (
     shouldObserve &&
     !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
+    (isArray(value) || isPlainObject(value)) &&
     Object.isExtensible(value) &&
     !value._isVue
   ) {
@@ -161,7 +162,7 @@ export function defineReactive(
         dep.depend()
         if (childOb) {
           childOb.dep.depend()
-          if (Array.isArray(value)) {
+          if (isArray(value)) {
             dependArray(value)
           }
         }
@@ -206,7 +207,7 @@ export function set(
       `Cannot set reactive property on undefined, null, or primitive value: ${target}`
     )
   }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
+  if (isArray(target) && isValidArrayIndex(key)) {
     target.length = Math.max(target.length, key)
     target.splice(key, 1, val)
     return val
@@ -242,7 +243,7 @@ export function del(target: Array<any> | Object, key: any) {
       `Cannot delete reactive property on undefined, null, or primitive value: ${target}`
     )
   }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
+  if (isArray(target) && isValidArrayIndex(key)) {
     target.splice(key, 1)
     return
   }
@@ -273,7 +274,7 @@ function dependArray(value: Array<any>) {
   for (let e, i = 0, l = value.length; i < l; i++) {
     e = value[i]
     e && e.__ob__ && e.__ob__.dep.depend()
-    if (Array.isArray(e)) {
+    if (isArray(e)) {
       dependArray(e)
     }
   }
diff --git a/src/core/observer/traverse.ts b/src/core/observer/traverse.ts
index 14eca535bd9..da1c6a7e987 100644
--- a/src/core/observer/traverse.ts
+++ b/src/core/observer/traverse.ts
@@ -1,4 +1,4 @@
-import { _Set as Set, isObject } from '../util/index'
+import { _Set as Set, isObject, isArray } from '../util/index'
 import type { SimpleSet } from '../util/index'
 import VNode from '../vdom/vnode'
 
@@ -16,7 +16,7 @@ export function traverse(val: any) {
 
 function _traverse(val: any, seen: SimpleSet) {
   let i, keys
-  const isA = Array.isArray(val)
+  const isA = isArray(val)
   if (
     (!isA && !isObject(val)) ||
     Object.isFrozen(val) ||
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index d8a811d5265..eb998fe63d6 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -11,7 +11,7 @@ import {
 
 import { traverse } from './traverse'
 import { queueWatcher } from './scheduler'
-import Dep, { pushTarget, popTarget } from './dep'
+import Dep, { pushTarget, popTarget, DepTarget } from './dep'
 
 import type { SimpleSet } from '../util/index'
 import type { Component } from 'typescript/component'
@@ -23,8 +23,8 @@ let uid = 0
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
  */
-export default class Watcher {
-  vm: Component
+export default class Watcher implements DepTarget {
+  vm: Component | null
   expression: string
   cb: Function
   id: number
@@ -39,11 +39,12 @@ export default class Watcher {
   depIds: SimpleSet
   newDepIds: SimpleSet
   before?: Function
+  scheduler?: Function
   getter: Function
   value: any
 
   constructor(
-    vm: Component,
+    vm: Component | null,
     expOrFn: string | Function,
     cb: Function,
     options?: {
@@ -52,14 +53,16 @@ export default class Watcher {
       lazy?: boolean
       sync?: boolean
       before?: Function
+      scheduler?: Function
     } | null,
     isRenderWatcher?: boolean
   ) {
-    this.vm = vm
-    if (isRenderWatcher) {
-      vm._watcher = this
+    if ((this.vm = vm)) {
+      if (isRenderWatcher) {
+        vm._watcher = this
+      }
+      vm._watchers.push(this)
     }
-    vm._watchers.push(this)
     // options
     if (options) {
       this.deep = !!options.deep
@@ -67,6 +70,7 @@ export default class Watcher {
       this.lazy = !!options.lazy
       this.sync = !!options.sync
       this.before = options.before
+      this.scheduler = options.scheduler
     } else {
       this.deep = this.user = this.lazy = this.sync = false
     }
@@ -170,6 +174,8 @@ export default class Watcher {
       this.dirty = true
     } else if (this.sync) {
       this.run()
+    } else if (this.scheduler) {
+      this.scheduler()
     } else {
       queueWatcher(this)
     }
@@ -236,7 +242,7 @@ export default class Watcher {
       // remove self from vm's watcher list
       // this is a somewhat expensive operation so we skip it
       // if the vm is being destroyed.
-      if (!this.vm._isBeingDestroyed) {
+      if (this.vm && !this.vm._isBeingDestroyed) {
         remove(this.vm._watchers, this)
       }
       let i = this.deps.length
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index 18f13ce0b69..0f1c1241bba 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -1,5 +1,5 @@
 import config from '../config'
-import { noop } from 'shared/util'
+import { noop, isArray } from 'shared/util'
 import type { Component } from 'typescript/component'
 
 export let warn = noop
@@ -14,6 +14,7 @@ if (__DEV__) {
     str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '')
 
   warn = (msg, vm) => {
+    // TODO get current instance
     const trace = vm ? generateComponentTrace(vm) : ''
 
     if (config.warnHandler) {
@@ -87,7 +88,7 @@ if (__DEV__) {
           .map(
             (vm, i) =>
               `${i === 0 ? '---> ' : repeat(' ', 5 + i * 2)}${
-                Array.isArray(vm)
+                isArray(vm)
                   ? `${formatComponentName(vm[0])}... (${
                       vm[1]
                     } recursive calls)`
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index 8f32a26e1e0..605681addb3 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -3,6 +3,7 @@ import { warn } from './debug'
 import { set } from '../observer/index'
 import { unicodeRegExp } from './lang'
 import { nativeWatch, hasSymbol } from './env'
+import { isArray } from 'shared/util'
 
 import { ASSET_TYPES, LIFECYCLE_HOOKS } from 'shared/constants'
 
@@ -154,7 +155,7 @@ function mergeHook(
   const res = childVal
     ? parentVal
       ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
+      : isArray(childVal)
       ? childVal
       : [childVal]
     : parentVal
@@ -229,14 +230,10 @@ strats.watch = function (
   for (const key in childVal) {
     let parent = ret[key]
     const child = childVal[key]
-    if (parent && !Array.isArray(parent)) {
+    if (parent && !isArray(parent)) {
       parent = [parent]
     }
-    ret[key] = parent
-      ? parent.concat(child)
-      : Array.isArray(child)
-      ? child
-      : [child]
+    ret[key] = parent ? parent.concat(child) : isArray(child) ? child : [child]
   }
   return ret
 }
@@ -310,7 +307,7 @@ function normalizeProps(options: Record<string, any>, vm?: Component | null) {
   if (!props) return
   const res: Record<string, any> = {}
   let i, val, name
-  if (Array.isArray(props)) {
+  if (isArray(props)) {
     i = props.length
     while (i--) {
       val = props[i]
@@ -344,7 +341,7 @@ function normalizeInject(options: Record<string, any>, vm?: Component | null) {
   const inject = options.inject
   if (!inject) return
   const normalized: Record<string, any> = (options.inject = {})
-  if (Array.isArray(inject)) {
+  if (isArray(inject)) {
     for (let i = 0; i < inject.length; i++) {
       normalized[inject[i]] = { from: inject[i] }
     }
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index d3a528e12bf..a464060529d 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -2,6 +2,7 @@ import { warn } from './debug'
 import { observe, toggleObserving, shouldObserve } from '../observer/index'
 import {
   hasOwn,
+  isArray,
   isObject,
   toRawType,
   hyphenate,
@@ -118,7 +119,7 @@ function assertProp(
   let valid = !type || (type as any) === true
   const expectedTypes: string[] = []
   if (type) {
-    if (!Array.isArray(type)) {
+    if (!isArray(type)) {
       type = [type]
     }
     for (let i = 0; i < type.length && !valid; i++) {
@@ -166,7 +167,7 @@ function assertType(
   } else if (expectedType === 'Object') {
     valid = isPlainObject(value)
   } else if (expectedType === 'Array') {
-    valid = Array.isArray(value)
+    valid = isArray(value)
   } else {
     try {
       valid = value instanceof type
@@ -198,7 +199,7 @@ function isSameType(a, b) {
 }
 
 function getTypeIndex(type, expectedTypes): number {
-  if (!Array.isArray(expectedTypes)) {
+  if (!isArray(expectedTypes)) {
     return isSameType(expectedTypes, type) ? 0 : -1
   }
   for (let i = 0, len = expectedTypes.length; i < len; i++) {
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 9813620484f..1f738b7cd17 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -1,4 +1,5 @@
 import VNode from './vnode'
+import { isArray } from 'core/util'
 import { resolveConstructorOptions } from 'core/instance/init'
 import { queueActivatedComponent } from 'core/observer/scheduler'
 import { createFunctionalComponent } from './create-functional-component'
@@ -258,7 +259,7 @@ function transformModel(options, data: any) {
   const callback = data.model.callback
   if (isDef(existing)) {
     if (
-      Array.isArray(existing)
+      isArray(existing)
         ? existing.indexOf(callback) === -1
         : existing !== callback
     ) {
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index f81aec564c6..415fb1b20af 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -7,6 +7,7 @@ import {
   warn,
   isDef,
   isUndef,
+  isArray,
   isTrue,
   isObject,
   isPrimitive,
@@ -30,7 +31,7 @@ export function createElement(
   normalizationType: any,
   alwaysNormalize: boolean
 ): VNode | Array<VNode> {
-  if (Array.isArray(data) || isPrimitive(data)) {
+  if (isArray(data) || isPrimitive(data)) {
     normalizationType = children
     children = data
     data = undefined
@@ -75,7 +76,7 @@ export function _createElement(
     )
   }
   // support single function children as default scoped slot
-  if (Array.isArray(children) && typeof children[0] === 'function') {
+  if (isArray(children) && typeof children[0] === 'function') {
     data = data || {}
     data.scopedSlots = { default: children[0] }
     children.length = 0
@@ -126,7 +127,7 @@ export function _createElement(
     // direct component options / constructor
     vnode = createComponent(tag, data, context, children)
   }
-  if (Array.isArray(vnode)) {
+  if (isArray(vnode)) {
     return vnode
   } else if (isDef(vnode)) {
     if (isDef(ns)) applyNS(vnode, ns)
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index 34dddd15fec..de576e97688 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -10,6 +10,7 @@ import {
   isDef,
   isTrue,
   hasOwn,
+  isArray,
   camelize,
   emptyObject,
   validateProp
@@ -78,7 +79,7 @@ export function FunctionalRenderContext(
   if (options._scopeId) {
     this._c = (a, b, c, d) => {
       const vnode = createElement(contextVm, a, b, c, d, needNormalization)
-      if (vnode && !Array.isArray(vnode)) {
+      if (vnode && !isArray(vnode)) {
         vnode.fnScopeId = options._scopeId
         vnode.fnContext = parent
       }
@@ -129,7 +130,7 @@ export function createFunctionalComponent(
       options,
       renderContext
     )
-  } else if (Array.isArray(vnode)) {
+  } else if (isArray(vnode)) {
     const vnodes = normalizeChildren(vnode) || []
     const res = new Array(vnodes.length)
     for (let i = 0; i < vnodes.length; i++) {
diff --git a/src/core/vdom/helpers/get-first-component-child.ts b/src/core/vdom/helpers/get-first-component-child.ts
index ea3c7ec4e37..ab4543af3eb 100644
--- a/src/core/vdom/helpers/get-first-component-child.ts
+++ b/src/core/vdom/helpers/get-first-component-child.ts
@@ -1,11 +1,11 @@
-import { isDef } from 'shared/util'
+import { isDef, isArray } from 'shared/util'
 import VNode from '../vnode'
 import { isAsyncPlaceholder } from './is-async-placeholder'
 
 export function getFirstComponentChild(
   children?: Array<VNode>
 ): VNode | undefined {
-  if (Array.isArray(children)) {
+  if (isArray(children)) {
     for (let i = 0; i < children.length; i++) {
       const c = children[i]
       if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
diff --git a/src/core/vdom/helpers/normalize-children.ts b/src/core/vdom/helpers/normalize-children.ts
index 521bb9cc120..6908ab1d15d 100644
--- a/src/core/vdom/helpers/normalize-children.ts
+++ b/src/core/vdom/helpers/normalize-children.ts
@@ -1,5 +1,12 @@
 import VNode, { createTextVNode } from 'core/vdom/vnode'
-import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
+import {
+  isFalse,
+  isTrue,
+  isArray,
+  isDef,
+  isUndef,
+  isPrimitive
+} from 'shared/util'
 
 // The template compiler attempts to minimize the need for normalization by
 // statically analyzing the template at compile time.
@@ -15,7 +22,7 @@ import { isFalse, isTrue, isDef, isUndef, isPrimitive } from 'shared/util'
 // because functional components already normalize their own children.
 export function simpleNormalizeChildren(children: any) {
   for (let i = 0; i < children.length; i++) {
-    if (Array.isArray(children[i])) {
+    if (isArray(children[i])) {
       return Array.prototype.concat.apply([], children)
     }
   }
@@ -29,7 +36,7 @@ export function simpleNormalizeChildren(children: any) {
 export function normalizeChildren(children: any): Array<VNode> | undefined {
   return isPrimitive(children)
     ? [createTextVNode(children)]
-    : Array.isArray(children)
+    : isArray(children)
     ? normalizeArrayChildren(children)
     : undefined
 }
@@ -50,7 +57,7 @@ function normalizeArrayChildren(
     lastIndex = res.length - 1
     last = res[lastIndex]
     //  nested
-    if (Array.isArray(c)) {
+    if (isArray(c)) {
       if (c.length > 0) {
         c = normalizeArrayChildren(c, `${nestedIndex || ''}_${i}`)
         // merge adjacent text nodes
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index afc5299a342..f65a3ae817e 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -1,6 +1,6 @@
 import { def } from 'core/util/lang'
 import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
-import { emptyObject } from 'shared/util'
+import { emptyObject, isArray } from 'shared/util'
 import { isAsyncPlaceholder } from './is-async-placeholder'
 import type VNode from '../vnode'
 
@@ -58,7 +58,7 @@ function normalizeScopedSlot(normalSlots, key, fn) {
   const normalized = function () {
     let res = arguments.length ? fn.apply(null, arguments) : fn({})
     res =
-      res && typeof res === 'object' && !Array.isArray(res)
+      res && typeof res === 'object' && !isArray(res)
         ? [res] // single vnode
         : normalizeChildren(res)
     const vnode: VNode | null = res && res[0]
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index 0443bd02e4d..054bae2ab1d 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -1,5 +1,5 @@
 import { warn, invokeWithErrorHandling } from 'core/util/index'
-import { cached, isUndef, isTrue } from 'shared/util'
+import { cached, isUndef, isTrue, isArray } from 'shared/util'
 import type { Component } from 'typescript/component'
 
 const normalizeEvent = cached(
@@ -34,7 +34,7 @@ export function createFnInvoker(
 ): Function {
   function invoker() {
     const fns = invoker.fns
-    if (Array.isArray(fns)) {
+    if (isArray(fns)) {
       const cloned = fns.slice()
       for (let i = 0; i < cloned.length; i++) {
         invokeWithErrorHandling(
diff --git a/src/core/vdom/modules/ref.ts b/src/core/vdom/modules/ref.ts
index a161b727915..ed7e4426c30 100644
--- a/src/core/vdom/modules/ref.ts
+++ b/src/core/vdom/modules/ref.ts
@@ -1,4 +1,4 @@
-import { remove, isDef } from 'shared/util'
+import { remove, isDef, isArray } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
 
 export default {
@@ -25,14 +25,14 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
   const refs = vm.$refs
   const obj = refs[key]
   if (isRemoval) {
-    if (Array.isArray(obj)) {
+    if (isArray(obj)) {
       remove(obj, ref)
     } else if (obj === ref) {
       refs[key] = undefined
     }
   } else {
     if (vnode.data.refInFor) {
-      if (!Array.isArray(obj)) {
+      if (!isArray(obj)) {
         refs[key] = [ref]
       } else if (obj.indexOf(ref) < 0) {
         obj.push(ref)
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index ba6a1b9369d..78204c55b54 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -23,6 +23,7 @@ import {
   isDef,
   isUndef,
   isTrue,
+  isArray,
   makeMap,
   isRegExp,
   isPrimitive
@@ -261,7 +262,7 @@ export function createPatchFunction(backend) {
   }
 
   function createChildren(vnode, children, insertedVnodeQueue) {
-    if (Array.isArray(children)) {
+    if (isArray(children)) {
       if (__DEV__) {
         checkDuplicateKeys(children)
       }
diff --git a/src/shared/util.ts b/src/shared/util.ts
index 468c2af21bf..f4497057aaf 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -1,5 +1,7 @@
 export const emptyObject: Record<string, any> = Object.freeze({})
 
+export const isArray = Array.isArray
+
 // These helpers produce better VM code in JS engines due to their
 // explicitness and function inlining.
 export function isUndef(v: any): v is undefined | null {

From d7d3dbbcc87b35411880f69ca895ae31811d403f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 24 May 2022 21:49:09 +0800
Subject: [PATCH 070/317] workflow: allow wip commits

---
 scripts/config.js            |  8 ++++----
 scripts/verify-commit-msg.js | 25 ++++++++++++++++++-------
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/scripts/config.js b/scripts/config.js
index 905fb8b9974..c2bc0d7bfa7 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -60,14 +60,14 @@ const builds = {
   },
   // Runtime only ES modules build (for bundlers)
   'web-runtime-esm': {
-    entry: resolve('web/entry-runtime.ts'),
+    entry: resolve('web/entry-runtime-esm.ts'),
     dest: resolve('dist/vue.runtime.esm.js'),
     format: 'es',
     banner
   },
   // Runtime+compiler ES modules build (for bundlers)
   'web-full-esm': {
-    entry: resolve('web/entry-runtime-with-compiler.ts'),
+    entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
     dest: resolve('dist/vue.esm.js'),
     format: 'es',
     alias: { he: './entity-decoder' },
@@ -75,7 +75,7 @@ const builds = {
   },
   // Runtime+compiler ES modules build (for direct import in browser)
   'web-full-esm-browser-dev': {
-    entry: resolve('web/entry-runtime-with-compiler.ts'),
+    entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
     dest: resolve('dist/vue.esm.browser.js'),
     format: 'es',
     transpile: false,
@@ -85,7 +85,7 @@ const builds = {
   },
   // Runtime+compiler ES modules build (for direct import in browser)
   'web-full-esm-browser-prod': {
-    entry: resolve('web/entry-runtime-with-compiler.ts'),
+    entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
     dest: resolve('dist/vue.esm.browser.min.js'),
     format: 'es',
     transpile: false,
diff --git a/scripts/verify-commit-msg.js b/scripts/verify-commit-msg.js
index 2a72e49c4bd..6fdc5e32ef3 100644
--- a/scripts/verify-commit-msg.js
+++ b/scripts/verify-commit-msg.js
@@ -2,17 +2,28 @@ const chalk = require('chalk')
 const msgPath = process.env.GIT_PARAMS
 const msg = require('fs').readFileSync(msgPath, 'utf-8').trim()
 
-const commitRE = /^(revert: )?(feat|fix|polish|docs|style|refactor|perf|test|workflow|ci|chore|types|build)(\(.+\))?: .{1,50}/
+const commitRE =
+  /^(revert: )?(wip|feat|fix|polish|docs|style|refactor|perf|test|workflow|ci|chore|types|build)(\(.+\))?: .{1,50}/
 
 if (!commitRE.test(msg)) {
   console.log()
   console.error(
-    `  ${chalk.bgRed.white(' ERROR ')} ${chalk.red(`invalid commit message format.`)}\n\n` +
-    chalk.red(`  Proper commit message format is required for automated changelog generation. Examples:\n\n`) +
-    `    ${chalk.green(`feat(compiler): add 'comments' option`)}\n` +
-    `    ${chalk.green(`fix(v-model): handle events on blur (close #28)`)}\n\n` +
-    chalk.red(`  See .github/COMMIT_CONVENTION.md for more details.\n`) +
-    chalk.red(`  You can also use ${chalk.cyan(`npm run commit`)} to interactively generate a commit message.\n`)
+    `  ${chalk.bgRed.white(' ERROR ')} ${chalk.red(
+      `invalid commit message format.`
+    )}\n\n` +
+      chalk.red(
+        `  Proper commit message format is required for automated changelog generation. Examples:\n\n`
+      ) +
+      `    ${chalk.green(`feat(compiler): add 'comments' option`)}\n` +
+      `    ${chalk.green(
+        `fix(v-model): handle events on blur (close #28)`
+      )}\n\n` +
+      chalk.red(`  See .github/COMMIT_CONVENTION.md for more details.\n`) +
+      chalk.red(
+        `  You can also use ${chalk.cyan(
+          `npm run commit`
+        )} to interactively generate a commit message.\n`
+      )
   )
   process.exit(1)
 }

From f50a1b84d9a0bd6be199847122f8af7cc177dee1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 24 May 2022 21:49:16 +0800
Subject: [PATCH 071/317] wip(vca): partial ref and watch implementation

---
 src/composition-api/apiInject.ts              |   3 +
 src/composition-api/apiLifecycle.ts           |   1 +
 src/composition-api/apiWatch.ts               | 366 ++++++++++++++++
 src/composition-api/currentInstance.ts        |  12 +
 src/composition-api/index.ts                  |  25 ++
 src/composition-api/reactivity/computed.ts    |  20 +
 src/composition-api/reactivity/effect.ts      |  54 +++
 src/composition-api/reactivity/operations.ts  |  15 +
 src/composition-api/reactivity/reactive.ts    |  12 +
 src/composition-api/reactivity/ref.ts         | 143 +++++++
 src/platforms/web/entry-runtime-esm.ts        |   5 +
 .../web/entry-runtime-with-compiler-esm.ts    |   5 +
 src/platforms/web/entry-runtime.ts            |   4 +
 test/tsconfig.json                            |   1 +
 .../composition-api/reactivity/ref.spec.ts    | 395 ++++++++++++++++++
 tsconfig.json                                 |   1 +
 typescript/utils.ts                           |   3 +
 vitest.config.ts                              |   1 +
 18 files changed, 1066 insertions(+)
 create mode 100644 src/composition-api/apiInject.ts
 create mode 100644 src/composition-api/apiLifecycle.ts
 create mode 100644 src/composition-api/apiWatch.ts
 create mode 100644 src/composition-api/currentInstance.ts
 create mode 100644 src/composition-api/index.ts
 create mode 100644 src/composition-api/reactivity/computed.ts
 create mode 100644 src/composition-api/reactivity/effect.ts
 create mode 100644 src/composition-api/reactivity/operations.ts
 create mode 100644 src/composition-api/reactivity/reactive.ts
 create mode 100644 src/composition-api/reactivity/ref.ts
 create mode 100644 src/platforms/web/entry-runtime-esm.ts
 create mode 100644 src/platforms/web/entry-runtime-with-compiler-esm.ts
 create mode 100644 test/unit/features/composition-api/reactivity/ref.spec.ts
 create mode 100644 typescript/utils.ts

diff --git a/src/composition-api/apiInject.ts b/src/composition-api/apiInject.ts
new file mode 100644
index 00000000000..815fec6c353
--- /dev/null
+++ b/src/composition-api/apiInject.ts
@@ -0,0 +1,3 @@
+export function provide() {}
+
+export function inject() {}
diff --git a/src/composition-api/apiLifecycle.ts b/src/composition-api/apiLifecycle.ts
new file mode 100644
index 00000000000..1396db60e56
--- /dev/null
+++ b/src/composition-api/apiLifecycle.ts
@@ -0,0 +1 @@
+export function onMounted() {}
diff --git a/src/composition-api/apiWatch.ts b/src/composition-api/apiWatch.ts
new file mode 100644
index 00000000000..faa524406f4
--- /dev/null
+++ b/src/composition-api/apiWatch.ts
@@ -0,0 +1,366 @@
+import { isRef, Ref } from './reactivity/ref'
+import { ComputedRef } from './reactivity/computed'
+import { isReactive, isShallow } from './reactivity/reactive'
+import { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
+import {
+  warn,
+  noop,
+  isArray,
+  emptyObject,
+  remove,
+  isServerRendering,
+  invokeWithErrorHandling
+} from 'core/util'
+import { currentInstance } from './currentInstance'
+import { traverse } from 'core/observer/traverse'
+import { EffectScheduler, ReactiveEffect } from './reactivity/effect'
+
+const WATCHER = `watcher`
+const WATCHER_CB = `${WATCHER} callback`
+const WATCHER_GETTER = `${WATCHER} getter`
+const WATCHER_CLEANUP = `${WATCHER} cleanup`
+
+export type WatchEffect = (onCleanup: OnCleanup) => void
+
+export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
+
+export type WatchCallback<V = any, OV = any> = (
+  value: V,
+  oldValue: OV,
+  onCleanup: OnCleanup
+) => any
+
+type MapSources<T, Immediate> = {
+  [K in keyof T]: T[K] extends WatchSource<infer V>
+    ? Immediate extends true
+      ? V | undefined
+      : V
+    : T[K] extends object
+    ? Immediate extends true
+      ? T[K] | undefined
+      : T[K]
+    : never
+}
+
+type OnCleanup = (cleanupFn: () => void) => void
+
+export interface WatchOptionsBase extends DebuggerOptions {
+  flush?: 'pre' | 'post' | 'sync'
+}
+
+interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void
+  onTrigger?: (event: DebuggerEvent) => void
+}
+
+export type DebuggerEvent = {
+  // TODO effect: ReactiveEffect
+} & DebuggerEventExtraInfo
+
+export type DebuggerEventExtraInfo = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key: any
+  newValue?: any
+  oldValue?: any
+  oldTarget?: Map<any, any> | Set<any>
+}
+
+export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
+  immediate?: Immediate
+  deep?: boolean
+}
+
+export type WatchStopHandle = () => void
+
+// Simple effect.
+export function watchEffect(
+  effect: WatchEffect,
+  options?: WatchOptionsBase
+): WatchStopHandle {
+  return doWatch(effect, null, options)
+}
+
+export function watchPostEffect(
+  effect: WatchEffect,
+  options?: DebuggerOptions
+) {
+  return doWatch(
+    effect,
+    null,
+    (__DEV__
+      ? { ...options, flush: 'post' }
+      : { flush: 'post' }) as WatchOptionsBase
+  )
+}
+
+export function watchSyncEffect(
+  effect: WatchEffect,
+  options?: DebuggerOptions
+) {
+  return doWatch(
+    effect,
+    null,
+    (__DEV__
+      ? { ...options, flush: 'sync' }
+      : { flush: 'sync' }) as WatchOptionsBase
+  )
+}
+
+// initial value for watchers to trigger on undefined initial values
+const INITIAL_WATCHER_VALUE = {}
+
+type MultiWatchSources = (WatchSource<unknown> | object)[]
+
+// overload: array of multiple sources + cb
+export function watch<
+  T extends MultiWatchSources,
+  Immediate extends Readonly<boolean> = false
+>(
+  sources: [...T],
+  cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,
+  options?: WatchOptions<Immediate>
+): WatchStopHandle
+
+// overload: multiple sources w/ `as const`
+// watch([foo, bar] as const, () => {})
+// somehow [...T] breaks when the type is readonly
+export function watch<
+  T extends Readonly<MultiWatchSources>,
+  Immediate extends Readonly<boolean> = false
+>(
+  source: T,
+  cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,
+  options?: WatchOptions<Immediate>
+): WatchStopHandle
+
+// overload: single source + cb
+export function watch<T, Immediate extends Readonly<boolean> = false>(
+  source: WatchSource<T>,
+  cb: WatchCallback<T, Immediate extends true ? T | undefined : T>,
+  options?: WatchOptions<Immediate>
+): WatchStopHandle
+
+// overload: watching reactive object w/ cb
+export function watch<
+  T extends object,
+  Immediate extends Readonly<boolean> = false
+>(
+  source: T,
+  cb: WatchCallback<T, Immediate extends true ? T | undefined : T>,
+  options?: WatchOptions<Immediate>
+): WatchStopHandle
+
+// implementation
+export function watch<T = any, Immediate extends Readonly<boolean> = false>(
+  source: T | WatchSource<T>,
+  cb: any,
+  options?: WatchOptions<Immediate>
+): WatchStopHandle {
+  if (__DEV__ && typeof cb !== 'function') {
+    warn(
+      `\`watch(fn, options?)\` signature has been moved to a separate API. ` +
+        `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` +
+        `supports \`watch(source, cb, options?) signature.`
+    )
+  }
+  return doWatch(source as any, cb, options)
+}
+
+function doWatch(
+  source: WatchSource | WatchSource[] | WatchEffect | object,
+  cb: WatchCallback | null,
+  { immediate, deep, flush, onTrack, onTrigger }: WatchOptions = emptyObject
+): WatchStopHandle {
+  if (__DEV__ && !cb) {
+    if (immediate !== undefined) {
+      warn(
+        `watch() "immediate" option is only respected when using the ` +
+          `watch(source, callback, options?) signature.`
+      )
+    }
+    if (deep !== undefined) {
+      warn(
+        `watch() "deep" option is only respected when using the ` +
+          `watch(source, callback, options?) signature.`
+      )
+    }
+  }
+
+  const warnInvalidSource = (s: unknown) => {
+    warn(
+      `Invalid watch source: `,
+      s,
+      `A watch source can only be a getter/effect function, a ref, ` +
+        `a reactive object, or an array of these types.`
+    )
+  }
+
+  const instance = currentInstance
+  const call = (fn: Function, type: string, args: any[] | null = null) =>
+    invokeWithErrorHandling(fn, null, args, instance, type)
+
+  let getter: () => any
+  let forceTrigger = false
+  let isMultiSource = false
+
+  if (isRef(source)) {
+    getter = () => source.value
+    forceTrigger = isShallow(source)
+  } else if (isReactive(source)) {
+    getter = () => source
+    deep = true
+  } else if (isArray(source)) {
+    isMultiSource = true
+    forceTrigger = source.some(s => isReactive(s) || isShallow(s))
+    getter = () =>
+      source.map(s => {
+        if (isRef(s)) {
+          return s.value
+        } else if (isReactive(s)) {
+          return traverse(s)
+        } else if (typeof s === 'function') {
+          return call(s, WATCHER_GETTER)
+        } else {
+          __DEV__ && warnInvalidSource(s)
+        }
+      })
+  } else if (typeof source === 'function') {
+    if (cb) {
+      // getter with cb
+      getter = () => call(source as Function, WATCHER_GETTER)
+    } else {
+      // no cb -> simple effect
+      getter = () => {
+        if (instance && instance.isUnmounted) {
+          return
+        }
+        if (cleanup) {
+          cleanup()
+        }
+        return call(source as Function, WATCHER, [onCleanup])
+      }
+    }
+  } else {
+    getter = noop
+    __DEV__ && warnInvalidSource(source)
+  }
+
+  if (cb && deep) {
+    const baseGetter = getter
+    getter = () => traverse(baseGetter())
+  }
+
+  let cleanup: () => void
+  let onCleanup: OnCleanup = (fn: () => void) => {
+    cleanup = effect.onStop = () => {
+      call(fn, WATCHER_CLEANUP)
+    }
+  }
+
+  // in SSR there is no need to setup an actual effect, and it should be noop
+  // unless it's eager
+  if (isServerRendering()) {
+    // we will also not call the invalidate callback (+ runner is not set up)
+    onCleanup = noop
+    if (!cb) {
+      getter()
+    } else if (immediate) {
+      call(cb, WATCHER_CB, [
+        getter(),
+        isMultiSource ? [] : undefined,
+        onCleanup
+      ])
+    }
+    return noop
+  }
+
+  let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE
+  const job = () => {
+    if (!effect.active) {
+      return
+    }
+    if (cb) {
+      // watch(source, cb)
+      const newValue = effect.run()
+      if (
+        deep ||
+        forceTrigger ||
+        (isMultiSource
+          ? (newValue as any[]).some((v, i) =>
+              hasChanged(v, (oldValue as any[])[i])
+            )
+          : hasChanged(newValue, oldValue))
+      ) {
+        // cleanup before running cb again
+        if (cleanup) {
+          cleanup()
+        }
+        call(cb, WATCHER_CB, [
+          newValue,
+          // pass undefined as the old value when it's changed for the first time
+          oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,
+          onCleanup
+        ])
+        oldValue = newValue
+      }
+    } else {
+      // watchEffect
+      effect.run()
+    }
+  }
+
+  let scheduler: EffectScheduler
+  if (flush === 'sync') {
+    scheduler = job as any // the scheduler function gets called directly
+  } else if (flush === 'post') {
+    scheduler = () => queuePostRenderEffect(job)
+  } else {
+    // default: 'pre'
+    scheduler = () => queuePreFlushCb(job)
+  }
+
+  const effect = new ReactiveEffect(getter, scheduler)
+
+  if (__DEV__) {
+    effect.onTrack = onTrack
+    effect.onTrigger = onTrigger
+  }
+
+  // initial run
+  if (cb) {
+    if (immediate) {
+      job()
+    } else {
+      oldValue = effect.run()
+    }
+  } else if (flush === 'post') {
+    queuePostRenderEffect(effect.run.bind(effect))
+  } else {
+    effect.run()
+  }
+
+  return () => {
+    effect.stop()
+    if (instance && instance.scope) {
+      remove(instance.scope.effects!, effect)
+    }
+  }
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill
+function hasChanged(x: unknown, y: unknown): boolean {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / (y as number)
+  } else {
+    return x !== x && y !== y
+  }
+}
+
+function queuePostRenderEffect(fn: Function) {
+  // TODO
+}
+
+function queuePreFlushCb(fn: Function) {
+  // TODO
+}
diff --git a/src/composition-api/currentInstance.ts b/src/composition-api/currentInstance.ts
new file mode 100644
index 00000000000..27611959ec1
--- /dev/null
+++ b/src/composition-api/currentInstance.ts
@@ -0,0 +1,12 @@
+import { Component } from 'typescript/component'
+
+// TODO set this
+export let currentInstance: Component | null = null
+
+export function getCurrentInstance(): Component | null {
+  return currentInstance
+}
+
+export function setCurrentInstance(vm: Component | null) {
+  currentInstance = vm
+}
diff --git a/src/composition-api/index.ts b/src/composition-api/index.ts
new file mode 100644
index 00000000000..428e6cf6a6e
--- /dev/null
+++ b/src/composition-api/index.ts
@@ -0,0 +1,25 @@
+export {
+  ref,
+  shallowRef,
+  isRef,
+  toRef,
+  toRefs,
+  unref,
+  customRef,
+  triggerRef,
+  Ref,
+  ToRef,
+  ToRefs,
+  UnwrapRef,
+  ShallowRef,
+  ShallowUnwrapRef,
+  RefUnwrapBailTypes,
+  CustomRefFactory
+} from './reactivity/ref'
+
+export {
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect
+} from './apiWatch'
diff --git a/src/composition-api/reactivity/computed.ts b/src/composition-api/reactivity/computed.ts
new file mode 100644
index 00000000000..91924b24d0c
--- /dev/null
+++ b/src/composition-api/reactivity/computed.ts
@@ -0,0 +1,20 @@
+import { Ref } from './ref'
+
+declare const ComputedRefSymbol: unique symbol
+
+export interface ComputedRef<T = any> extends WritableComputedRef<T> {
+  readonly value: T
+  [ComputedRefSymbol]: true
+}
+
+export interface WritableComputedRef<T> extends Ref<T> {
+  // TODO readonly effect: ReactiveEffect<T>
+}
+
+export type ComputedGetter<T> = (...args: any[]) => T
+export type ComputedSetter<T> = (v: T) => void
+
+export interface WritableComputedOptions<T> {
+  get: ComputedGetter<T>
+  set: ComputedSetter<T>
+}
diff --git a/src/composition-api/reactivity/effect.ts b/src/composition-api/reactivity/effect.ts
new file mode 100644
index 00000000000..895e2030182
--- /dev/null
+++ b/src/composition-api/reactivity/effect.ts
@@ -0,0 +1,54 @@
+import Watcher from 'core/observer/watcher'
+import { noop } from 'shared/util'
+import { currentInstance } from '../currentInstance'
+import { TrackOpTypes, TriggerOpTypes } from './operations'
+
+export type EffectScheduler = (...args: any[]) => any
+
+export type DebuggerEvent = {
+  effect: ReactiveEffect
+} & DebuggerEventExtraInfo
+
+export type DebuggerEventExtraInfo = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key: any
+  newValue?: any
+  oldValue?: any
+  oldTarget?: Map<any, any> | Set<any>
+}
+
+export class ReactiveEffect<T = any> {
+  onStop?: () => void
+  // dev only
+  onTrack?: (event: DebuggerEvent) => void
+  // dev only
+  onTrigger?: (event: DebuggerEvent) => void
+
+  public active = true
+  private _watcher: Watcher
+
+  constructor(
+    public fn: () => T,
+    public scheduler?: EffectScheduler // TODO scope?: EffectScope
+  ) {
+    // TODO recordEffectScope(this, scope)
+    // TODO debug options
+    this._watcher = new Watcher(currentInstance, fn, noop, {
+      // force cb trigger
+      deep: true,
+      sync: !scheduler,
+      scheduler
+    })
+  }
+
+  run() {
+    this._watcher.run()
+    return this._watcher.value
+  }
+
+  stop() {
+    this._watcher.teardown()
+    this.active = false
+  }
+}
diff --git a/src/composition-api/reactivity/operations.ts b/src/composition-api/reactivity/operations.ts
new file mode 100644
index 00000000000..1b96e982571
--- /dev/null
+++ b/src/composition-api/reactivity/operations.ts
@@ -0,0 +1,15 @@
+// using literal strings instead of numbers so that it's easier to inspect
+// debugger events
+
+export const enum TrackOpTypes {
+  GET = 'get',
+  HAS = 'has',
+  ITERATE = 'iterate'
+}
+
+export const enum TriggerOpTypes {
+  SET = 'set',
+  ADD = 'add',
+  DELETE = 'delete',
+  CLEAR = 'clear'
+}
diff --git a/src/composition-api/reactivity/reactive.ts b/src/composition-api/reactivity/reactive.ts
new file mode 100644
index 00000000000..60fc9886a29
--- /dev/null
+++ b/src/composition-api/reactivity/reactive.ts
@@ -0,0 +1,12 @@
+export declare const ShallowReactiveMarker: unique symbol
+
+export function reactive() {}
+
+export function isReactive(value: unknown): boolean {
+  return !!(value && (value as any).__ob__)
+}
+
+export function isShallow(value: unknown): boolean {
+  // TODO
+  return !!(value && (value as any).__ob__)
+}
diff --git a/src/composition-api/reactivity/ref.ts b/src/composition-api/reactivity/ref.ts
new file mode 100644
index 00000000000..c4a5f28f42c
--- /dev/null
+++ b/src/composition-api/reactivity/ref.ts
@@ -0,0 +1,143 @@
+import { defineReactive } from 'core/observer/index'
+import type { ShallowReactiveMarker } from './reactive'
+import type { IfAny } from 'typescript/utils'
+
+declare const RefSymbol: unique symbol
+export declare const RawSymbol: unique symbol
+
+export interface Ref<T = any> {
+  value: T
+  /**
+   * Type differentiator only.
+   * We need this to be in public d.ts but don't want it to show up in IDE
+   * autocomplete, so we use a private Symbol instead.
+   */
+  [RefSymbol]: true
+}
+
+export function isRef<T>(r: Ref<T> | unknown): r is Ref<T>
+export function isRef(r: any): r is Ref {
+  return !!(r && r.__v_isRef === true)
+}
+
+export function ref<T extends object>(
+  value: T
+): [T] extends [Ref] ? T : Ref<UnwrapRef<T>>
+export function ref<T>(value: T): Ref<UnwrapRef<T>>
+export function ref<T = any>(): Ref<T | undefined>
+export function ref(value?: unknown) {
+  return createRef(value, false)
+}
+
+declare const ShallowRefMarker: unique symbol
+
+export type ShallowRef<T = any> = Ref<T> & { [ShallowRefMarker]?: true }
+
+export function shallowRef<T extends object>(
+  value: T
+): T extends Ref ? T : ShallowRef<T>
+export function shallowRef<T>(value: T): ShallowRef<T>
+export function shallowRef<T = any>(): ShallowRef<T | undefined>
+export function shallowRef(value?: unknown) {
+  return createRef(value, true)
+}
+
+function createRef(rawValue: unknown, shallow: boolean) {
+  if (isRef(rawValue)) {
+    return rawValue
+  }
+  const ref = { __v_isRef: true }
+  defineReactive(ref, 'value', rawValue, null, shallow)
+  return ref
+}
+
+export function triggerRef(ref: Ref) {
+  // TODO triggerRefValue(ref, __DEV__ ? ref.value : void 0)
+}
+
+export function unref<T>(ref: T | Ref<T>): T {
+  return isRef(ref) ? (ref.value as any) : ref
+}
+
+export type CustomRefFactory<T> = (
+  track: () => void,
+  trigger: () => void
+) => {
+  get: () => T
+  set: (value: T) => void
+}
+
+export function customRef() {
+  // TODO
+}
+
+export type ToRefs<T = any> = {
+  [K in keyof T]: ToRef<T[K]>
+}
+
+export function toRefs() {
+  // TODO
+}
+
+export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>
+
+export function toRef() {
+  // TODO
+}
+
+/**
+ * This is a special exported interface for other packages to declare
+ * additional types that should bail out for ref unwrapping. For example
+ * \@vue/runtime-dom can declare it like so in its d.ts:
+ *
+ * ``` ts
+ * declare module 'vue' {
+ *   export interface RefUnwrapBailTypes {
+ *     runtimeDOMBailTypes: Node | Window
+ *   }
+ * }
+ * ```
+ *
+ * Note that api-extractor somehow refuses to include `declare module`
+ * augmentations in its generated d.ts, so we have to manually append them
+ * to the final generated d.ts in our build process.
+ */
+export interface RefUnwrapBailTypes {}
+
+export type ShallowUnwrapRef<T> = {
+  [K in keyof T]: T[K] extends Ref<infer V>
+    ? V
+    : // if `V` is `unknown` that means it does not extend `Ref` and is undefined
+    T[K] extends Ref<infer V> | undefined
+    ? unknown extends V
+      ? undefined
+      : V | undefined
+    : T[K]
+}
+
+export type UnwrapRef<T> = T extends ShallowRef<infer V>
+  ? V
+  : T extends Ref<infer V>
+  ? UnwrapRefSimple<V>
+  : UnwrapRefSimple<T>
+
+type BaseTypes = string | number | boolean
+type CollectionTypes = IterableCollections | WeakCollections
+type IterableCollections = Map<any, any> | Set<any>
+type WeakCollections = WeakMap<any, any> | WeakSet<any>
+
+export type UnwrapRefSimple<T> = T extends
+  | Function
+  | CollectionTypes
+  | BaseTypes
+  | Ref
+  | RefUnwrapBailTypes[keyof RefUnwrapBailTypes]
+  | { [RawSymbol]?: true }
+  ? T
+  : T extends Array<any>
+  ? { [K in keyof T]: UnwrapRefSimple<T[K]> }
+  : T extends object & { [ShallowReactiveMarker]?: never }
+  ? {
+      [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>
+    }
+  : T
diff --git a/src/platforms/web/entry-runtime-esm.ts b/src/platforms/web/entry-runtime-esm.ts
new file mode 100644
index 00000000000..790cef573bb
--- /dev/null
+++ b/src/platforms/web/entry-runtime-esm.ts
@@ -0,0 +1,5 @@
+import Vue from './runtime/index'
+
+export default Vue
+
+export * from 'vca/index'
diff --git a/src/platforms/web/entry-runtime-with-compiler-esm.ts b/src/platforms/web/entry-runtime-with-compiler-esm.ts
new file mode 100644
index 00000000000..d49c131bc59
--- /dev/null
+++ b/src/platforms/web/entry-runtime-with-compiler-esm.ts
@@ -0,0 +1,5 @@
+import Vue from './entry-runtime-with-compiler'
+
+export default Vue
+
+export * from 'vca/index'
diff --git a/src/platforms/web/entry-runtime.ts b/src/platforms/web/entry-runtime.ts
index 0251259b0bd..d2973d65931 100644
--- a/src/platforms/web/entry-runtime.ts
+++ b/src/platforms/web/entry-runtime.ts
@@ -1,3 +1,7 @@
 import Vue from './runtime/index'
+import * as vca from 'vca/index'
+import { extend } from 'shared/util'
+
+extend(Vue, vca)
 
 export default Vue
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 884bf24a271..5c10275e644 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -29,6 +29,7 @@
       "shared/*": ["../src/shared/*"],
 
       "web/*": ["../src/platforms/web/*"],
+      "vca/*": ["../src/composition-api/*"],
 
       "vue": ["../src/platforms/web/entry-runtime-with-compiler"]
     }
diff --git a/test/unit/features/composition-api/reactivity/ref.spec.ts b/test/unit/features/composition-api/reactivity/ref.spec.ts
new file mode 100644
index 00000000000..984547bbaf7
--- /dev/null
+++ b/test/unit/features/composition-api/reactivity/ref.spec.ts
@@ -0,0 +1,395 @@
+import { ref, shallowRef, unref } from 'vca/reactivity/ref'
+import { ReactiveEffect } from 'vca/reactivity/effect'
+import { isReactive } from 'vca/reactivity/reactive'
+
+const effect = (fn: () => any) => new ReactiveEffect(fn)
+
+describe('reactivity/ref', () => {
+  it('should hold a value', () => {
+    const a = ref(1)
+    expect(a.value).toBe(1)
+    a.value = 2
+    expect(a.value).toBe(2)
+  })
+
+  it('should be reactive', () => {
+    const a = ref(1)
+    let dummy
+    let calls = 0
+    effect(() => {
+      calls++
+      dummy = a.value
+    })
+    expect(calls).toBe(1)
+    expect(dummy).toBe(1)
+    a.value = 2
+    expect(calls).toBe(2)
+    expect(dummy).toBe(2)
+    // same value should not trigger
+    a.value = 2
+    expect(calls).toBe(2)
+  })
+
+  it('should make nested properties reactive', () => {
+    const a = ref({
+      count: 1
+    })
+    let dummy
+    effect(() => {
+      dummy = a.value.count
+    })
+    expect(dummy).toBe(1)
+    a.value.count = 2
+    expect(dummy).toBe(2)
+  })
+
+  it('should work without initial value', () => {
+    const a = ref()
+    let dummy
+    effect(() => {
+      dummy = a.value
+    })
+    expect(dummy).toBe(undefined)
+    a.value = 2
+    expect(dummy).toBe(2)
+  })
+
+  // it('should work like a normal property when nested in a reactive object', () => {
+  //   const a = ref(1)
+  //   const obj = reactive({
+  //     a,
+  //     b: {
+  //       c: a
+  //     }
+  //   })
+
+  //   let dummy1: number
+  //   let dummy2: number
+
+  //   effect(() => {
+  //     dummy1 = obj.a
+  //     dummy2 = obj.b.c
+  //   })
+
+  //   const assertDummiesEqualTo = (val: number) =>
+  //     [dummy1, dummy2].forEach(dummy => expect(dummy).toBe(val))
+
+  //   assertDummiesEqualTo(1)
+  //   a.value++
+  //   assertDummiesEqualTo(2)
+  //   obj.a++
+  //   assertDummiesEqualTo(3)
+  //   obj.b.c++
+  //   assertDummiesEqualTo(4)
+  // })
+
+  // it('should unwrap nested ref in types', () => {
+  //   const a = ref(0)
+  //   const b = ref(a)
+
+  //   expect(typeof (b.value + 1)).toBe('number')
+  // })
+
+  // it('should unwrap nested values in types', () => {
+  //   const a = {
+  //     b: ref(0)
+  //   }
+
+  //   const c = ref(a)
+
+  //   expect(typeof (c.value.b + 1)).toBe('number')
+  // })
+
+  // it('should NOT unwrap ref types nested inside arrays', () => {
+  //   const arr = ref([1, ref(3)]).value
+  //   expect(isRef(arr[0])).toBe(false)
+  //   expect(isRef(arr[1])).toBe(true)
+  //   expect((arr[1] as Ref).value).toBe(3)
+  // })
+
+  // it('should unwrap ref types as props of arrays', () => {
+  //   const arr = [ref(0)]
+  //   const symbolKey = Symbol('')
+  //   arr['' as any] = ref(1)
+  //   arr[symbolKey as any] = ref(2)
+  //   const arrRef = ref(arr).value
+  //   expect(isRef(arrRef[0])).toBe(true)
+  //   expect(isRef(arrRef['' as any])).toBe(false)
+  //   expect(isRef(arrRef[symbolKey as any])).toBe(false)
+  //   expect(arrRef['' as any]).toBe(1)
+  //   expect(arrRef[symbolKey as any]).toBe(2)
+  // })
+
+  // it('should keep tuple types', () => {
+  //   const tuple: [number, string, { a: number }, () => number, Ref<number>] = [
+  //     0,
+  //     '1',
+  //     { a: 1 },
+  //     () => 0,
+  //     ref(0)
+  //   ]
+  //   const tupleRef = ref(tuple)
+
+  //   tupleRef.value[0]++
+  //   expect(tupleRef.value[0]).toBe(1)
+  //   tupleRef.value[1] += '1'
+  //   expect(tupleRef.value[1]).toBe('11')
+  //   tupleRef.value[2].a++
+  //   expect(tupleRef.value[2].a).toBe(2)
+  //   expect(tupleRef.value[3]()).toBe(0)
+  //   tupleRef.value[4].value++
+  //   expect(tupleRef.value[4].value).toBe(1)
+  // })
+
+  // it('should keep symbols', () => {
+  //   const customSymbol = Symbol()
+  //   const obj = {
+  //     [Symbol.asyncIterator]: ref(1),
+  //     [Symbol.hasInstance]: { a: ref('a') },
+  //     [Symbol.isConcatSpreadable]: { b: ref(true) },
+  //     [Symbol.iterator]: [ref(1)],
+  //     [Symbol.match]: new Set<Ref<number>>(),
+  //     [Symbol.matchAll]: new Map<number, Ref<string>>(),
+  //     [Symbol.replace]: { arr: [ref('a')] },
+  //     [Symbol.search]: { set: new Set<Ref<number>>() },
+  //     [Symbol.species]: { map: new Map<number, Ref<string>>() },
+  //     [Symbol.split]: new WeakSet<Ref<boolean>>(),
+  //     [Symbol.toPrimitive]: new WeakMap<Ref<boolean>, string>(),
+  //     [Symbol.toStringTag]: { weakSet: new WeakSet<Ref<boolean>>() },
+  //     [Symbol.unscopables]: { weakMap: new WeakMap<Ref<boolean>, string>() },
+  //     [customSymbol]: { arr: [ref(1)] }
+  //   }
+
+  //   const objRef = ref(obj)
+
+  //   const keys: (keyof typeof obj)[] = [
+  //     Symbol.asyncIterator,
+  //     Symbol.hasInstance,
+  //     Symbol.isConcatSpreadable,
+  //     Symbol.iterator,
+  //     Symbol.match,
+  //     Symbol.matchAll,
+  //     Symbol.replace,
+  //     Symbol.search,
+  //     Symbol.species,
+  //     Symbol.split,
+  //     Symbol.toPrimitive,
+  //     Symbol.toStringTag,
+  //     Symbol.unscopables,
+  //     customSymbol
+  //   ]
+
+  //   keys.forEach(key => {
+  //     expect(objRef.value[key]).toStrictEqual(obj[key])
+  //   })
+  // })
+
+  test('unref', () => {
+    expect(unref(1)).toBe(1)
+    expect(unref(ref(1))).toBe(1)
+  })
+
+  test('shallowRef', () => {
+    const sref = shallowRef({ a: 1 })
+    expect(isReactive(sref.value)).toBe(false)
+
+    let dummy
+    effect(() => {
+      dummy = sref.value.a
+    })
+    expect(dummy).toBe(1)
+
+    sref.value = { a: 2 }
+    expect(isReactive(sref.value)).toBe(false)
+    expect(dummy).toBe(2)
+  })
+
+  // test('shallowRef force trigger', () => {
+  //   const sref = shallowRef({ a: 1 })
+  //   let dummy
+  //   effect(() => {
+  //     dummy = sref.value.a
+  //   })
+  //   expect(dummy).toBe(1)
+
+  //   sref.value.a = 2
+  //   expect(dummy).toBe(1) // should not trigger yet
+
+  //   // force trigger
+  //   triggerRef(sref)
+  //   expect(dummy).toBe(2)
+  // })
+
+  // test('shallowRef isShallow', () => {
+  //   expect(isShallow(shallowRef({ a: 1 }))).toBe(true)
+  // })
+
+  // test('isRef', () => {
+  //   expect(isRef(ref(1))).toBe(true)
+  //   expect(isRef(computed(() => 1))).toBe(true)
+
+  //   expect(isRef(0)).toBe(false)
+  //   expect(isRef(1)).toBe(false)
+  //   // an object that looks like a ref isn't necessarily a ref
+  //   expect(isRef({ value: 0 })).toBe(false)
+  // })
+
+  // test('toRef', () => {
+  //   const a = reactive({
+  //     x: 1
+  //   })
+  //   const x = toRef(a, 'x')
+  //   expect(isRef(x)).toBe(true)
+  //   expect(x.value).toBe(1)
+
+  //   // source -> proxy
+  //   a.x = 2
+  //   expect(x.value).toBe(2)
+
+  //   // proxy -> source
+  //   x.value = 3
+  //   expect(a.x).toBe(3)
+
+  //   // reactivity
+  //   let dummyX
+  //   effect(() => {
+  //     dummyX = x.value
+  //   })
+  //   expect(dummyX).toBe(x.value)
+
+  //   // mutating source should trigger effect using the proxy refs
+  //   a.x = 4
+  //   expect(dummyX).toBe(4)
+
+  //   // should keep ref
+  //   const r = { x: ref(1) }
+  //   expect(toRef(r, 'x')).toBe(r.x)
+  // })
+
+  // test('toRef default value', () => {
+  //   const a: { x: number | undefined } = { x: undefined }
+  //   const x = toRef(a, 'x', 1)
+  //   expect(x.value).toBe(1)
+
+  //   a.x = 2
+  //   expect(x.value).toBe(2)
+
+  //   a.x = undefined
+  //   expect(x.value).toBe(1)
+  // })
+
+  // test('toRefs', () => {
+  //   const a = reactive({
+  //     x: 1,
+  //     y: 2
+  //   })
+
+  //   const { x, y } = toRefs(a)
+
+  //   expect(isRef(x)).toBe(true)
+  //   expect(isRef(y)).toBe(true)
+  //   expect(x.value).toBe(1)
+  //   expect(y.value).toBe(2)
+
+  //   // source -> proxy
+  //   a.x = 2
+  //   a.y = 3
+  //   expect(x.value).toBe(2)
+  //   expect(y.value).toBe(3)
+
+  //   // proxy -> source
+  //   x.value = 3
+  //   y.value = 4
+  //   expect(a.x).toBe(3)
+  //   expect(a.y).toBe(4)
+
+  //   // reactivity
+  //   let dummyX, dummyY
+  //   effect(() => {
+  //     dummyX = x.value
+  //     dummyY = y.value
+  //   })
+  //   expect(dummyX).toBe(x.value)
+  //   expect(dummyY).toBe(y.value)
+
+  //   // mutating source should trigger effect using the proxy refs
+  //   a.x = 4
+  //   a.y = 5
+  //   expect(dummyX).toBe(4)
+  //   expect(dummyY).toBe(5)
+  // })
+
+  // test('toRefs should warn on plain object', () => {
+  //   toRefs({})
+  //   expect(`toRefs() expects a reactive object`).toHaveBeenWarned()
+  // })
+
+  // test('toRefs should warn on plain array', () => {
+  //   toRefs([])
+  //   expect(`toRefs() expects a reactive object`).toHaveBeenWarned()
+  // })
+
+  // test('toRefs reactive array', () => {
+  //   const arr = reactive(['a', 'b', 'c'])
+  //   const refs = toRefs(arr)
+
+  //   expect(Array.isArray(refs)).toBe(true)
+
+  //   refs[0].value = '1'
+  //   expect(arr[0]).toBe('1')
+
+  //   arr[1] = '2'
+  //   expect(refs[1].value).toBe('2')
+  // })
+
+  // test('customRef', () => {
+  //   let value = 1
+  //   let _trigger: () => void
+
+  //   const custom = customRef((track, trigger) => ({
+  //     get() {
+  //       track()
+  //       return value
+  //     },
+  //     set(newValue: number) {
+  //       value = newValue
+  //       _trigger = trigger
+  //     }
+  //   }))
+
+  //   expect(isRef(custom)).toBe(true)
+
+  //   let dummy
+  //   effect(() => {
+  //     dummy = custom.value
+  //   })
+  //   expect(dummy).toBe(1)
+
+  //   custom.value = 2
+  //   // should not trigger yet
+  //   expect(dummy).toBe(1)
+
+  //   _trigger!()
+  //   expect(dummy).toBe(2)
+  // })
+
+  // test('should not trigger when setting value to same proxy', () => {
+  //   const obj = reactive({ count: 0 })
+
+  //   const a = ref(obj)
+  //   const spy1 = jest.fn(() => a.value)
+
+  //   effect(spy1)
+
+  //   a.value = obj
+  //   expect(spy1).toBeCalledTimes(1)
+
+  //   const b = shallowRef(obj)
+  //   const spy2 = jest.fn(() => b.value)
+
+  //   effect(spy2)
+
+  //   b.value = obj
+  //   expect(spy2).toBeCalledTimes(1)
+  // })
+})
diff --git a/tsconfig.json b/tsconfig.json
index 1c7470ced45..3d6f0b6926e 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -29,6 +29,7 @@
       "shared/*": ["src/shared/*"],
 
       "web/*": ["src/platforms/web/*"],
+      "vca/*": ["src/composition-api/*"],
 
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
diff --git a/typescript/utils.ts b/typescript/utils.ts
new file mode 100644
index 00000000000..8c77093f5ee
--- /dev/null
+++ b/typescript/utils.ts
@@ -0,0 +1,3 @@
+// If the the type T accepts type "any", output type Y, otherwise output type N.
+// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
+export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N
diff --git a/vitest.config.ts b/vitest.config.ts
index ec26dec727b..09f725ddf70 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -12,6 +12,7 @@ export default defineConfig({
       sfc: resolve('src/sfc'),
       shared: resolve('src/shared'),
       web: resolve('src/platforms/web'),
+      vca: resolve('src/composition-api'),
       vue: resolve('src/platforms/web/entry-runtime-with-compiler')
     }
   },

From e1e5a75540c31d847000c08f81a4a662eca1ebb5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 25 May 2022 15:07:46 +0800
Subject: [PATCH 072/317] wip: fix entry with compiler

---
 .../web/entry-runtime-with-compiler-esm.ts    |   2 +-
 .../web/entry-runtime-with-compiler.ts        | 113 +-----------------
 src/platforms/web/runtime-with-compiler.ts    | 110 +++++++++++++++++
 3 files changed, 116 insertions(+), 109 deletions(-)
 create mode 100644 src/platforms/web/runtime-with-compiler.ts

diff --git a/src/platforms/web/entry-runtime-with-compiler-esm.ts b/src/platforms/web/entry-runtime-with-compiler-esm.ts
index d49c131bc59..f54d6f66b8f 100644
--- a/src/platforms/web/entry-runtime-with-compiler-esm.ts
+++ b/src/platforms/web/entry-runtime-with-compiler-esm.ts
@@ -1,4 +1,4 @@
-import Vue from './entry-runtime-with-compiler'
+import Vue from './runtime-with-compiler'
 
 export default Vue
 
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index 8bb02675f43..a7437b2e8d1 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -1,110 +1,7 @@
-import config from 'core/config'
-import { warn, cached } from 'core/util/index'
-import { mark, measure } from 'core/util/perf'
+import Vue from './runtime-with-compiler'
+import * as vca from 'vca/index'
+import { extend } from 'shared/util'
 
-import Vue from './runtime/index'
-import { query } from './util/index'
-import { compileToFunctions } from './compiler/index'
-import {
-  shouldDecodeNewlines,
-  shouldDecodeNewlinesForHref
-} from './util/compat'
-import type { Component } from 'typescript/component'
-import type { GlobalAPI } from 'typescript/global-api'
+extend(Vue, vca)
 
-const idToTemplate = cached(id => {
-  const el = query(id)
-  return el && el.innerHTML
-})
-
-const mount = Vue.prototype.$mount
-Vue.prototype.$mount = function (
-  el?: string | Element,
-  hydrating?: boolean
-): Component {
-  el = el && query(el)
-
-  /* istanbul ignore if */
-  if (el === document.body || el === document.documentElement) {
-    __DEV__ &&
-      warn(
-        `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
-      )
-    return this
-  }
-
-  const options = this.$options
-  // resolve template/el and convert to render function
-  if (!options.render) {
-    let template = options.template
-    if (template) {
-      if (typeof template === 'string') {
-        if (template.charAt(0) === '#') {
-          template = idToTemplate(template)
-          /* istanbul ignore if */
-          if (__DEV__ && !template) {
-            warn(
-              `Template element not found or is empty: ${options.template}`,
-              this
-            )
-          }
-        }
-      } else if (template.nodeType) {
-        template = template.innerHTML
-      } else {
-        if (__DEV__) {
-          warn('invalid template option:' + template, this)
-        }
-        return this
-      }
-    } else if (el) {
-      // @ts-expect-error
-      template = getOuterHTML(el)
-    }
-    if (template) {
-      /* istanbul ignore if */
-      if (__DEV__ && config.performance && mark) {
-        mark('compile')
-      }
-
-      const { render, staticRenderFns } = compileToFunctions(
-        template,
-        {
-          outputSourceRange: __DEV__,
-          shouldDecodeNewlines,
-          shouldDecodeNewlinesForHref,
-          delimiters: options.delimiters,
-          comments: options.comments
-        },
-        this
-      )
-      options.render = render
-      options.staticRenderFns = staticRenderFns
-
-      /* istanbul ignore if */
-      if (__DEV__ && config.performance && mark) {
-        mark('compile end')
-        measure(`vue ${this._name} compile`, 'compile', 'compile end')
-      }
-    }
-  }
-  return mount.call(this, el, hydrating)
-}
-
-/**
- * Get outerHTML of elements, taking care
- * of SVG elements in IE as well.
- */
-function getOuterHTML(el: Element): string {
-  if (el.outerHTML) {
-    return el.outerHTML
-  } else {
-    const container = document.createElement('div')
-    container.appendChild(el.cloneNode(true))
-    return container.innerHTML
-  }
-}
-
-Vue.compile = compileToFunctions
-
-export default Vue as GlobalAPI
+export default Vue
diff --git a/src/platforms/web/runtime-with-compiler.ts b/src/platforms/web/runtime-with-compiler.ts
new file mode 100644
index 00000000000..8bb02675f43
--- /dev/null
+++ b/src/platforms/web/runtime-with-compiler.ts
@@ -0,0 +1,110 @@
+import config from 'core/config'
+import { warn, cached } from 'core/util/index'
+import { mark, measure } from 'core/util/perf'
+
+import Vue from './runtime/index'
+import { query } from './util/index'
+import { compileToFunctions } from './compiler/index'
+import {
+  shouldDecodeNewlines,
+  shouldDecodeNewlinesForHref
+} from './util/compat'
+import type { Component } from 'typescript/component'
+import type { GlobalAPI } from 'typescript/global-api'
+
+const idToTemplate = cached(id => {
+  const el = query(id)
+  return el && el.innerHTML
+})
+
+const mount = Vue.prototype.$mount
+Vue.prototype.$mount = function (
+  el?: string | Element,
+  hydrating?: boolean
+): Component {
+  el = el && query(el)
+
+  /* istanbul ignore if */
+  if (el === document.body || el === document.documentElement) {
+    __DEV__ &&
+      warn(
+        `Do not mount Vue to <html> or <body> - mount to normal elements instead.`
+      )
+    return this
+  }
+
+  const options = this.$options
+  // resolve template/el and convert to render function
+  if (!options.render) {
+    let template = options.template
+    if (template) {
+      if (typeof template === 'string') {
+        if (template.charAt(0) === '#') {
+          template = idToTemplate(template)
+          /* istanbul ignore if */
+          if (__DEV__ && !template) {
+            warn(
+              `Template element not found or is empty: ${options.template}`,
+              this
+            )
+          }
+        }
+      } else if (template.nodeType) {
+        template = template.innerHTML
+      } else {
+        if (__DEV__) {
+          warn('invalid template option:' + template, this)
+        }
+        return this
+      }
+    } else if (el) {
+      // @ts-expect-error
+      template = getOuterHTML(el)
+    }
+    if (template) {
+      /* istanbul ignore if */
+      if (__DEV__ && config.performance && mark) {
+        mark('compile')
+      }
+
+      const { render, staticRenderFns } = compileToFunctions(
+        template,
+        {
+          outputSourceRange: __DEV__,
+          shouldDecodeNewlines,
+          shouldDecodeNewlinesForHref,
+          delimiters: options.delimiters,
+          comments: options.comments
+        },
+        this
+      )
+      options.render = render
+      options.staticRenderFns = staticRenderFns
+
+      /* istanbul ignore if */
+      if (__DEV__ && config.performance && mark) {
+        mark('compile end')
+        measure(`vue ${this._name} compile`, 'compile', 'compile end')
+      }
+    }
+  }
+  return mount.call(this, el, hydrating)
+}
+
+/**
+ * Get outerHTML of elements, taking care
+ * of SVG elements in IE as well.
+ */
+function getOuterHTML(el: Element): string {
+  if (el.outerHTML) {
+    return el.outerHTML
+  } else {
+    const container = document.createElement('div')
+    container.appendChild(el.cloneNode(true))
+    return container.innerHTML
+  }
+}
+
+Vue.compile = compileToFunctions
+
+export default Vue as GlobalAPI

From ac85a4217e2ee1595ce15202358f6f34d137c1a1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 25 May 2022 15:36:10 +0800
Subject: [PATCH 073/317] wip: ref tests passing

---
 src/composition-api/apiWatch.ts               |  10 +-
 src/composition-api/index.ts                  |  17 +
 src/composition-api/reactivity/reactive.ts    |  38 +-
 src/composition-api/reactivity/ref.ts         |  97 ++-
 src/core/observer/index.ts                    |  21 +-
 src/shared/util.ts                            |   9 +
 .../composition-api/reactivity/ref.spec.ts    | 559 +++++++++---------
 7 files changed, 447 insertions(+), 304 deletions(-)

diff --git a/src/composition-api/apiWatch.ts b/src/composition-api/apiWatch.ts
index faa524406f4..59862b1ddc4 100644
--- a/src/composition-api/apiWatch.ts
+++ b/src/composition-api/apiWatch.ts
@@ -8,6 +8,7 @@ import {
   isArray,
   emptyObject,
   remove,
+  hasChanged,
   isServerRendering,
   invokeWithErrorHandling
 } from 'core/util'
@@ -348,15 +349,6 @@ function doWatch(
   }
 }
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill
-function hasChanged(x: unknown, y: unknown): boolean {
-  if (x === y) {
-    return x !== 0 || 1 / x === 1 / (y as number)
-  } else {
-    return x !== x && y !== y
-  }
-}
-
 function queuePostRenderEffect(fn: Function) {
   // TODO
 }
diff --git a/src/composition-api/index.ts b/src/composition-api/index.ts
index 428e6cf6a6e..2163d905cb8 100644
--- a/src/composition-api/index.ts
+++ b/src/composition-api/index.ts
@@ -17,6 +17,23 @@ export {
   CustomRefFactory
 } from './reactivity/ref'
 
+export {
+  reactive,
+  // readonly,
+  isReactive,
+  isReadonly,
+  isShallow,
+  // isProxy,
+  // shallowReactive,
+  // shallowReadonly,
+  // markRaw,
+  // toRaw,
+  ReactiveFlags,
+  // DeepReadonly,
+  // ShallowReactive,
+  UnwrapNestedRefs
+} from './reactivity/reactive'
+
 export {
   watch,
   watchEffect,
diff --git a/src/composition-api/reactivity/reactive.ts b/src/composition-api/reactivity/reactive.ts
index 60fc9886a29..1cd310a854d 100644
--- a/src/composition-api/reactivity/reactive.ts
+++ b/src/composition-api/reactivity/reactive.ts
@@ -1,12 +1,44 @@
+import { observe, Observer } from 'core/observer'
+import { Ref, UnwrapRefSimple } from './ref'
+
+export const enum ReactiveFlags {
+  SKIP = '__v_skip',
+  IS_READONLY = '__v_isReadonly',
+  IS_SHALLOW = '__v_isShallow',
+  RAW = '__v_raw'
+}
+
+export interface Target {
+  __ob__?: Observer
+  [ReactiveFlags.SKIP]?: boolean
+  [ReactiveFlags.IS_READONLY]?: boolean
+  [ReactiveFlags.IS_SHALLOW]?: boolean
+  [ReactiveFlags.RAW]?: any
+}
+
 export declare const ShallowReactiveMarker: unique symbol
 
-export function reactive() {}
+// only unwrap nested ref
+export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>
+
+export function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
+export function reactive(target: object) {
+  // if trying to observe a readonly proxy, return the readonly version.
+  if (!isReadonly(target)) {
+    observe(target)
+  }
+  return target
+}
 
 export function isReactive(value: unknown): boolean {
-  return !!(value && (value as any).__ob__)
+  return !!(value && (value as Target).__ob__)
 }
 
 export function isShallow(value: unknown): boolean {
+  return !!(value && (value as Target).__v_isShallow)
+}
+
+export function isReadonly(value: unknown): boolean {
   // TODO
-  return !!(value && (value as any).__ob__)
+  return !!(value && (value as Target).__v_isReadonly)
 }
diff --git a/src/composition-api/reactivity/ref.ts b/src/composition-api/reactivity/ref.ts
index c4a5f28f42c..960b198ba7d 100644
--- a/src/composition-api/reactivity/ref.ts
+++ b/src/composition-api/reactivity/ref.ts
@@ -1,6 +1,8 @@
 import { defineReactive } from 'core/observer/index'
-import type { ShallowReactiveMarker } from './reactive'
+import { isReactive, ShallowReactiveMarker } from './reactive'
 import type { IfAny } from 'typescript/utils'
+import Dep from 'core/observer/dep'
+import { warn, isArray } from 'core/util'
 
 declare const RefSymbol: unique symbol
 export declare const RawSymbol: unique symbol
@@ -13,6 +15,10 @@ export interface Ref<T = any> {
    * autocomplete, so we use a private Symbol instead.
    */
   [RefSymbol]: true
+  /**
+   * @private
+   */
+  dep: Dep
 }
 
 export function isRef<T>(r: Ref<T> | unknown): r is Ref<T>
@@ -46,13 +52,13 @@ function createRef(rawValue: unknown, shallow: boolean) {
   if (isRef(rawValue)) {
     return rawValue
   }
-  const ref = { __v_isRef: true }
-  defineReactive(ref, 'value', rawValue, null, shallow)
+  const ref: any = { __v_isRef: true, __v_isShallow: shallow }
+  ref.dep = defineReactive(ref, 'value', rawValue, null, shallow)
   return ref
 }
 
 export function triggerRef(ref: Ref) {
-  // TODO triggerRefValue(ref, __DEV__ ? ref.value : void 0)
+  ref.dep.notify()
 }
 
 export function unref<T>(ref: T | Ref<T>): T {
@@ -67,22 +73,93 @@ export type CustomRefFactory<T> = (
   set: (value: T) => void
 }
 
-export function customRef() {
-  // TODO
+class CustomRefImpl<T> {
+  public dep?: Dep = undefined
+
+  private readonly _get: ReturnType<CustomRefFactory<T>>['get']
+  private readonly _set: ReturnType<CustomRefFactory<T>>['set']
+
+  public readonly __v_isRef = true
+
+  constructor(factory: CustomRefFactory<T>) {
+    const dep = new Dep()
+    const { get, set } = factory(
+      () => dep.depend(),
+      () => dep.notify()
+    )
+    this._get = get
+    this._set = set
+  }
+
+  get value() {
+    return this._get()
+  }
+
+  set value(newVal) {
+    this._set(newVal)
+  }
+}
+
+export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
+  return new CustomRefImpl(factory) as any
 }
 
 export type ToRefs<T = any> = {
   [K in keyof T]: ToRef<T[K]>
 }
 
-export function toRefs() {
-  // TODO
+export function toRefs<T extends object>(object: T): ToRefs<T> {
+  if (__DEV__ && !isReactive(object)) {
+    warn(`toRefs() expects a reactive object but received a plain one.`)
+  }
+  const ret: any = isArray(object) ? new Array(object.length) : {}
+  for (const key in object) {
+    ret[key] = toRef(object, key)
+  }
+  return ret
+}
+
+class ObjectRefImpl<T extends object, K extends keyof T> {
+  public readonly __v_isRef = true
+
+  constructor(
+    private readonly _object: T,
+    private readonly _key: K,
+    private readonly _defaultValue?: T[K]
+  ) {}
+
+  get value() {
+    const val = this._object[this._key]
+    return val === undefined ? (this._defaultValue as T[K]) : val
+  }
+
+  set value(newVal) {
+    this._object[this._key] = newVal
+  }
 }
 
 export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>
 
-export function toRef() {
-  // TODO
+export function toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K
+): ToRef<T[K]>
+
+export function toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K,
+  defaultValue: T[K]
+): ToRef<Exclude<T[K], undefined>>
+
+export function toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K,
+  defaultValue?: T[K]
+): ToRef<T[K]> {
+  const val = object[key]
+  return isRef(val)
+    ? val
+    : (new ObjectRefImpl(object, key, defaultValue) as any)
 }
 
 /**
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 1a534c06182..8a2da69e108 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -12,8 +12,10 @@ import {
   isPrimitive,
   isUndef,
   isValidArrayIndex,
-  isServerRendering
+  isServerRendering,
+  hasChanged
 } from '../util/index'
+import { isRef } from '../../composition-api'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
@@ -107,7 +109,7 @@ function copyAugment(target: Object, src: Object, keys: Array<string>) {
  * or the existing observer if the value already has one.
  */
 export function observe(value: any, asRootData?: boolean): Observer | void {
-  if (!isObject(value) || value instanceof VNode) {
+  if (!isObject(value) || isRef(value) || value instanceof VNode) {
     return
   }
   let ob: Observer | void
@@ -167,22 +169,23 @@ export function defineReactive(
           }
         }
       }
-      return value
+      return isRef(value) ? value.value : value
     },
     set: function reactiveSetter(newVal) {
       const value = getter ? getter.call(obj) : val
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
+      if (!hasChanged(value, newVal)) {
         return
       }
-      /* eslint-enable no-self-compare */
       if (__DEV__ && customSetter) {
         customSetter()
       }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) return
       if (setter) {
         setter.call(obj, newVal)
+      } else if (getter) {
+        // #7981: for accessor properties without setter
+        return
+      } else if (isRef(value) && !isRef(newVal)) {
+        value.value = newVal
       } else {
         val = newVal
       }
@@ -190,6 +193,8 @@ export function defineReactive(
       dep.notify()
     }
   })
+
+  return dep
 }
 
 /**
diff --git a/src/shared/util.ts b/src/shared/util.ts
index f4497057aaf..fa276117117 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -349,3 +349,12 @@ export function once(fn: Function): Function {
     }
   }
 }
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill
+export function hasChanged(x: unknown, y: unknown): boolean {
+  if (x === y) {
+    return x === 0 && 1 / x !== 1 / (y as number)
+  } else {
+    return x === x && y === y
+  }
+}
diff --git a/test/unit/features/composition-api/reactivity/ref.spec.ts b/test/unit/features/composition-api/reactivity/ref.spec.ts
index 984547bbaf7..d696348e2be 100644
--- a/test/unit/features/composition-api/reactivity/ref.spec.ts
+++ b/test/unit/features/composition-api/reactivity/ref.spec.ts
@@ -1,6 +1,16 @@
-import { ref, shallowRef, unref } from 'vca/reactivity/ref'
+import {
+  ref,
+  isRef,
+  shallowRef,
+  unref,
+  triggerRef,
+  toRef,
+  toRefs,
+  customRef,
+  Ref
+} from 'vca/reactivity/ref'
 import { ReactiveEffect } from 'vca/reactivity/effect'
-import { isReactive } from 'vca/reactivity/reactive'
+import { isReactive, isShallow, reactive } from 'vca/reactivity/reactive'
 
 const effect = (fn: () => any) => new ReactiveEffect(fn)
 
@@ -54,59 +64,60 @@ describe('reactivity/ref', () => {
     expect(dummy).toBe(2)
   })
 
-  // it('should work like a normal property when nested in a reactive object', () => {
-  //   const a = ref(1)
-  //   const obj = reactive({
-  //     a,
-  //     b: {
-  //       c: a
-  //     }
-  //   })
-
-  //   let dummy1: number
-  //   let dummy2: number
-
-  //   effect(() => {
-  //     dummy1 = obj.a
-  //     dummy2 = obj.b.c
-  //   })
-
-  //   const assertDummiesEqualTo = (val: number) =>
-  //     [dummy1, dummy2].forEach(dummy => expect(dummy).toBe(val))
-
-  //   assertDummiesEqualTo(1)
-  //   a.value++
-  //   assertDummiesEqualTo(2)
-  //   obj.a++
-  //   assertDummiesEqualTo(3)
-  //   obj.b.c++
-  //   assertDummiesEqualTo(4)
-  // })
+  it('should work like a normal property when nested in a reactive object', () => {
+    const a = ref(1)
+    const obj = reactive({
+      a,
+      b: {
+        c: a
+      }
+    })
 
-  // it('should unwrap nested ref in types', () => {
-  //   const a = ref(0)
-  //   const b = ref(a)
+    let dummy1: number
+    let dummy2: number
 
-  //   expect(typeof (b.value + 1)).toBe('number')
-  // })
+    effect(() => {
+      dummy1 = obj.a
+      dummy2 = obj.b.c
+    })
 
-  // it('should unwrap nested values in types', () => {
-  //   const a = {
-  //     b: ref(0)
-  //   }
+    const assertDummiesEqualTo = (val: number) =>
+      [dummy1, dummy2].forEach(dummy => expect(dummy).toBe(val))
 
-  //   const c = ref(a)
+    assertDummiesEqualTo(1)
+    a.value++
+    assertDummiesEqualTo(2)
+    obj.a++
+    assertDummiesEqualTo(3)
+    obj.b.c++
+    assertDummiesEqualTo(4)
+  })
 
-  //   expect(typeof (c.value.b + 1)).toBe('number')
-  // })
+  it('should unwrap nested ref in types', () => {
+    const a = ref(0)
+    const b = ref(a)
 
-  // it('should NOT unwrap ref types nested inside arrays', () => {
-  //   const arr = ref([1, ref(3)]).value
-  //   expect(isRef(arr[0])).toBe(false)
-  //   expect(isRef(arr[1])).toBe(true)
-  //   expect((arr[1] as Ref).value).toBe(3)
-  // })
+    expect(typeof (b.value + 1)).toBe('number')
+  })
 
+  it('should unwrap nested values in types', () => {
+    const a = {
+      b: ref(0)
+    }
+
+    const c = ref(a)
+
+    expect(typeof (c.value.b + 1)).toBe('number')
+  })
+
+  it('should NOT unwrap ref types nested inside arrays', () => {
+    const arr = ref([1, ref(3)]).value
+    expect(isRef(arr[0])).toBe(false)
+    expect(isRef(arr[1])).toBe(true)
+    expect((arr[1] as Ref).value).toBe(3)
+  })
+
+  // Vue 2 does not observe array properties
   // it('should unwrap ref types as props of arrays', () => {
   //   const arr = [ref(0)]
   //   const symbolKey = Symbol('')
@@ -120,69 +131,69 @@ describe('reactivity/ref', () => {
   //   expect(arrRef[symbolKey as any]).toBe(2)
   // })
 
-  // it('should keep tuple types', () => {
-  //   const tuple: [number, string, { a: number }, () => number, Ref<number>] = [
-  //     0,
-  //     '1',
-  //     { a: 1 },
-  //     () => 0,
-  //     ref(0)
-  //   ]
-  //   const tupleRef = ref(tuple)
-
-  //   tupleRef.value[0]++
-  //   expect(tupleRef.value[0]).toBe(1)
-  //   tupleRef.value[1] += '1'
-  //   expect(tupleRef.value[1]).toBe('11')
-  //   tupleRef.value[2].a++
-  //   expect(tupleRef.value[2].a).toBe(2)
-  //   expect(tupleRef.value[3]()).toBe(0)
-  //   tupleRef.value[4].value++
-  //   expect(tupleRef.value[4].value).toBe(1)
-  // })
+  it('should keep tuple types', () => {
+    const tuple: [number, string, { a: number }, () => number, Ref<number>] = [
+      0,
+      '1',
+      { a: 1 },
+      () => 0,
+      ref(0)
+    ]
+    const tupleRef = ref(tuple)
+
+    tupleRef.value[0]++
+    expect(tupleRef.value[0]).toBe(1)
+    tupleRef.value[1] += '1'
+    expect(tupleRef.value[1]).toBe('11')
+    tupleRef.value[2].a++
+    expect(tupleRef.value[2].a).toBe(2)
+    expect(tupleRef.value[3]()).toBe(0)
+    tupleRef.value[4].value++
+    expect(tupleRef.value[4].value).toBe(1)
+  })
 
-  // it('should keep symbols', () => {
-  //   const customSymbol = Symbol()
-  //   const obj = {
-  //     [Symbol.asyncIterator]: ref(1),
-  //     [Symbol.hasInstance]: { a: ref('a') },
-  //     [Symbol.isConcatSpreadable]: { b: ref(true) },
-  //     [Symbol.iterator]: [ref(1)],
-  //     [Symbol.match]: new Set<Ref<number>>(),
-  //     [Symbol.matchAll]: new Map<number, Ref<string>>(),
-  //     [Symbol.replace]: { arr: [ref('a')] },
-  //     [Symbol.search]: { set: new Set<Ref<number>>() },
-  //     [Symbol.species]: { map: new Map<number, Ref<string>>() },
-  //     [Symbol.split]: new WeakSet<Ref<boolean>>(),
-  //     [Symbol.toPrimitive]: new WeakMap<Ref<boolean>, string>(),
-  //     [Symbol.toStringTag]: { weakSet: new WeakSet<Ref<boolean>>() },
-  //     [Symbol.unscopables]: { weakMap: new WeakMap<Ref<boolean>, string>() },
-  //     [customSymbol]: { arr: [ref(1)] }
-  //   }
-
-  //   const objRef = ref(obj)
-
-  //   const keys: (keyof typeof obj)[] = [
-  //     Symbol.asyncIterator,
-  //     Symbol.hasInstance,
-  //     Symbol.isConcatSpreadable,
-  //     Symbol.iterator,
-  //     Symbol.match,
-  //     Symbol.matchAll,
-  //     Symbol.replace,
-  //     Symbol.search,
-  //     Symbol.species,
-  //     Symbol.split,
-  //     Symbol.toPrimitive,
-  //     Symbol.toStringTag,
-  //     Symbol.unscopables,
-  //     customSymbol
-  //   ]
-
-  //   keys.forEach(key => {
-  //     expect(objRef.value[key]).toStrictEqual(obj[key])
-  //   })
-  // })
+  it('should keep symbols', () => {
+    const customSymbol = Symbol()
+    const obj = {
+      [Symbol.asyncIterator]: ref(1),
+      [Symbol.hasInstance]: { a: ref('a') },
+      [Symbol.isConcatSpreadable]: { b: ref(true) },
+      [Symbol.iterator]: [ref(1)],
+      [Symbol.match]: new Set<Ref<number>>(),
+      [Symbol.matchAll]: new Map<number, Ref<string>>(),
+      [Symbol.replace]: { arr: [ref('a')] },
+      [Symbol.search]: { set: new Set<Ref<number>>() },
+      [Symbol.species]: { map: new Map<number, Ref<string>>() },
+      [Symbol.split]: new WeakSet<Ref<boolean>>(),
+      [Symbol.toPrimitive]: new WeakMap<Ref<boolean>, string>(),
+      [Symbol.toStringTag]: { weakSet: new WeakSet<Ref<boolean>>() },
+      [Symbol.unscopables]: { weakMap: new WeakMap<Ref<boolean>, string>() },
+      [customSymbol]: { arr: [ref(1)] }
+    }
+
+    const objRef = ref(obj)
+
+    const keys: (keyof typeof obj)[] = [
+      Symbol.asyncIterator,
+      Symbol.hasInstance,
+      Symbol.isConcatSpreadable,
+      Symbol.iterator,
+      Symbol.match,
+      Symbol.matchAll,
+      Symbol.replace,
+      Symbol.search,
+      Symbol.species,
+      Symbol.split,
+      Symbol.toPrimitive,
+      Symbol.toStringTag,
+      Symbol.unscopables,
+      customSymbol
+    ]
+
+    keys.forEach(key => {
+      expect(objRef.value[key]).toStrictEqual(obj[key])
+    })
+  })
 
   test('unref', () => {
     expect(unref(1)).toBe(1)
@@ -204,192 +215,192 @@ describe('reactivity/ref', () => {
     expect(dummy).toBe(2)
   })
 
-  // test('shallowRef force trigger', () => {
-  //   const sref = shallowRef({ a: 1 })
-  //   let dummy
-  //   effect(() => {
-  //     dummy = sref.value.a
-  //   })
-  //   expect(dummy).toBe(1)
+  test('shallowRef force trigger', () => {
+    const sref = shallowRef({ a: 1 })
+    let dummy
+    effect(() => {
+      dummy = sref.value.a
+    })
+    expect(dummy).toBe(1)
 
-  //   sref.value.a = 2
-  //   expect(dummy).toBe(1) // should not trigger yet
+    sref.value.a = 2
+    expect(dummy).toBe(1) // should not trigger yet
 
-  //   // force trigger
-  //   triggerRef(sref)
-  //   expect(dummy).toBe(2)
-  // })
+    // force trigger
+    triggerRef(sref)
+    expect(dummy).toBe(2)
+  })
 
-  // test('shallowRef isShallow', () => {
-  //   expect(isShallow(shallowRef({ a: 1 }))).toBe(true)
-  // })
+  test('shallowRef isShallow', () => {
+    expect(isShallow(shallowRef({ a: 1 }))).toBe(true)
+  })
 
-  // test('isRef', () => {
-  //   expect(isRef(ref(1))).toBe(true)
-  //   expect(isRef(computed(() => 1))).toBe(true)
+  test('isRef', () => {
+    expect(isRef(ref(1))).toBe(true)
+    // TODO expect(isRef(computed(() => 1))).toBe(true)
 
-  //   expect(isRef(0)).toBe(false)
-  //   expect(isRef(1)).toBe(false)
-  //   // an object that looks like a ref isn't necessarily a ref
-  //   expect(isRef({ value: 0 })).toBe(false)
-  // })
+    expect(isRef(0)).toBe(false)
+    expect(isRef(1)).toBe(false)
+    // an object that looks like a ref isn't necessarily a ref
+    expect(isRef({ value: 0 })).toBe(false)
+  })
 
-  // test('toRef', () => {
-  //   const a = reactive({
-  //     x: 1
-  //   })
-  //   const x = toRef(a, 'x')
-  //   expect(isRef(x)).toBe(true)
-  //   expect(x.value).toBe(1)
-
-  //   // source -> proxy
-  //   a.x = 2
-  //   expect(x.value).toBe(2)
-
-  //   // proxy -> source
-  //   x.value = 3
-  //   expect(a.x).toBe(3)
-
-  //   // reactivity
-  //   let dummyX
-  //   effect(() => {
-  //     dummyX = x.value
-  //   })
-  //   expect(dummyX).toBe(x.value)
-
-  //   // mutating source should trigger effect using the proxy refs
-  //   a.x = 4
-  //   expect(dummyX).toBe(4)
-
-  //   // should keep ref
-  //   const r = { x: ref(1) }
-  //   expect(toRef(r, 'x')).toBe(r.x)
-  // })
+  test('toRef', () => {
+    const a = reactive({
+      x: 1
+    })
+    const x = toRef(a, 'x')
+    expect(isRef(x)).toBe(true)
+    expect(x.value).toBe(1)
 
-  // test('toRef default value', () => {
-  //   const a: { x: number | undefined } = { x: undefined }
-  //   const x = toRef(a, 'x', 1)
-  //   expect(x.value).toBe(1)
+    // source -> proxy
+    a.x = 2
+    expect(x.value).toBe(2)
 
-  //   a.x = 2
-  //   expect(x.value).toBe(2)
+    // proxy -> source
+    x.value = 3
+    expect(a.x).toBe(3)
 
-  //   a.x = undefined
-  //   expect(x.value).toBe(1)
-  // })
+    // reactivity
+    let dummyX
+    effect(() => {
+      dummyX = x.value
+    })
+    expect(dummyX).toBe(x.value)
 
-  // test('toRefs', () => {
-  //   const a = reactive({
-  //     x: 1,
-  //     y: 2
-  //   })
-
-  //   const { x, y } = toRefs(a)
-
-  //   expect(isRef(x)).toBe(true)
-  //   expect(isRef(y)).toBe(true)
-  //   expect(x.value).toBe(1)
-  //   expect(y.value).toBe(2)
-
-  //   // source -> proxy
-  //   a.x = 2
-  //   a.y = 3
-  //   expect(x.value).toBe(2)
-  //   expect(y.value).toBe(3)
-
-  //   // proxy -> source
-  //   x.value = 3
-  //   y.value = 4
-  //   expect(a.x).toBe(3)
-  //   expect(a.y).toBe(4)
-
-  //   // reactivity
-  //   let dummyX, dummyY
-  //   effect(() => {
-  //     dummyX = x.value
-  //     dummyY = y.value
-  //   })
-  //   expect(dummyX).toBe(x.value)
-  //   expect(dummyY).toBe(y.value)
-
-  //   // mutating source should trigger effect using the proxy refs
-  //   a.x = 4
-  //   a.y = 5
-  //   expect(dummyX).toBe(4)
-  //   expect(dummyY).toBe(5)
-  // })
+    // mutating source should trigger effect using the proxy refs
+    a.x = 4
+    expect(dummyX).toBe(4)
 
-  // test('toRefs should warn on plain object', () => {
-  //   toRefs({})
-  //   expect(`toRefs() expects a reactive object`).toHaveBeenWarned()
-  // })
+    // should keep ref
+    const r = { x: ref(1) }
+    expect(toRef(r, 'x')).toBe(r.x)
+  })
 
-  // test('toRefs should warn on plain array', () => {
-  //   toRefs([])
-  //   expect(`toRefs() expects a reactive object`).toHaveBeenWarned()
-  // })
+  test('toRef default value', () => {
+    const a: { x: number | undefined } = { x: undefined }
+    const x = toRef(a, 'x', 1)
+    expect(x.value).toBe(1)
 
-  // test('toRefs reactive array', () => {
-  //   const arr = reactive(['a', 'b', 'c'])
-  //   const refs = toRefs(arr)
+    a.x = 2
+    expect(x.value).toBe(2)
 
-  //   expect(Array.isArray(refs)).toBe(true)
+    a.x = undefined
+    expect(x.value).toBe(1)
+  })
 
-  //   refs[0].value = '1'
-  //   expect(arr[0]).toBe('1')
+  test('toRefs', () => {
+    const a = reactive({
+      x: 1,
+      y: 2
+    })
 
-  //   arr[1] = '2'
-  //   expect(refs[1].value).toBe('2')
-  // })
+    const { x, y } = toRefs(a)
 
-  // test('customRef', () => {
-  //   let value = 1
-  //   let _trigger: () => void
-
-  //   const custom = customRef((track, trigger) => ({
-  //     get() {
-  //       track()
-  //       return value
-  //     },
-  //     set(newValue: number) {
-  //       value = newValue
-  //       _trigger = trigger
-  //     }
-  //   }))
-
-  //   expect(isRef(custom)).toBe(true)
-
-  //   let dummy
-  //   effect(() => {
-  //     dummy = custom.value
-  //   })
-  //   expect(dummy).toBe(1)
-
-  //   custom.value = 2
-  //   // should not trigger yet
-  //   expect(dummy).toBe(1)
-
-  //   _trigger!()
-  //   expect(dummy).toBe(2)
-  // })
+    expect(isRef(x)).toBe(true)
+    expect(isRef(y)).toBe(true)
+    expect(x.value).toBe(1)
+    expect(y.value).toBe(2)
 
-  // test('should not trigger when setting value to same proxy', () => {
-  //   const obj = reactive({ count: 0 })
+    // source -> proxy
+    a.x = 2
+    a.y = 3
+    expect(x.value).toBe(2)
+    expect(y.value).toBe(3)
 
-  //   const a = ref(obj)
-  //   const spy1 = jest.fn(() => a.value)
+    // proxy -> source
+    x.value = 3
+    y.value = 4
+    expect(a.x).toBe(3)
+    expect(a.y).toBe(4)
 
-  //   effect(spy1)
+    // reactivity
+    let dummyX, dummyY
+    effect(() => {
+      dummyX = x.value
+      dummyY = y.value
+    })
+    expect(dummyX).toBe(x.value)
+    expect(dummyY).toBe(y.value)
+
+    // mutating source should trigger effect using the proxy refs
+    a.x = 4
+    a.y = 5
+    expect(dummyX).toBe(4)
+    expect(dummyY).toBe(5)
+  })
 
-  //   a.value = obj
-  //   expect(spy1).toBeCalledTimes(1)
+  test('toRefs should warn on plain object', () => {
+    toRefs({})
+    expect(`toRefs() expects a reactive object`).toHaveBeenWarned()
+  })
 
-  //   const b = shallowRef(obj)
-  //   const spy2 = jest.fn(() => b.value)
+  test('toRefs should warn on plain array', () => {
+    toRefs([])
+    expect(`toRefs() expects a reactive object`).toHaveBeenWarned()
+  })
 
-  //   effect(spy2)
+  test('toRefs reactive array', () => {
+    const arr = reactive(['a', 'b', 'c'])
+    const refs = toRefs(arr)
 
-  //   b.value = obj
-  //   expect(spy2).toBeCalledTimes(1)
-  // })
+    expect(Array.isArray(refs)).toBe(true)
+
+    refs[0].value = '1'
+    expect(arr[0]).toBe('1')
+
+    arr[1] = '2'
+    expect(refs[1].value).toBe('2')
+  })
+
+  test('customRef', () => {
+    let value = 1
+    let _trigger: () => void
+
+    const custom = customRef((track, trigger) => ({
+      get() {
+        track()
+        return value
+      },
+      set(newValue: number) {
+        value = newValue
+        _trigger = trigger
+      }
+    }))
+
+    expect(isRef(custom)).toBe(true)
+
+    let dummy
+    effect(() => {
+      dummy = custom.value
+    })
+    expect(dummy).toBe(1)
+
+    custom.value = 2
+    // should not trigger yet
+    expect(dummy).toBe(1)
+
+    _trigger!()
+    expect(dummy).toBe(2)
+  })
+
+  test('should not trigger when setting value to same proxy', () => {
+    const obj = reactive({ count: 0 })
+
+    const a = ref(obj)
+    const spy1 = vi.fn(() => a.value)
+
+    effect(spy1)
+
+    a.value = obj
+    expect(spy1).toBeCalledTimes(1)
+
+    const b = shallowRef(obj)
+    const spy2 = vi.fn(() => b.value)
+
+    effect(spy2)
+
+    b.value = obj
+    expect(spy2).toBeCalledTimes(1)
+  })
 })

From c4aa8ea66d2ef218d2b792f3fcdeba21d402e7b3 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 26 May 2022 00:30:31 +0800
Subject: [PATCH 074/317] wip: reactive tests passing

---
 src/composition-api/reactivity/computed.ts    |   4 +
 src/composition-api/reactivity/effect.ts      |   3 +
 src/composition-api/reactivity/reactive.ts    |  20 +-
 src/composition-api/reactivity/ref.ts         |   2 +-
 src/core/instance/init.ts                     |   5 +-
 src/core/observer/index.ts                    |   2 +-
 test/helpers/to-have-warned.ts                |   2 +-
 .../reactivity/reactive.spec.ts               | 284 ++++++++++++++++++
 .../composition-api/reactivity/ref.spec.ts    |   6 +-
 9 files changed, 318 insertions(+), 10 deletions(-)
 create mode 100644 test/unit/features/composition-api/reactivity/reactive.spec.ts

diff --git a/src/composition-api/reactivity/computed.ts b/src/composition-api/reactivity/computed.ts
index 91924b24d0c..b9daf8abf5a 100644
--- a/src/composition-api/reactivity/computed.ts
+++ b/src/composition-api/reactivity/computed.ts
@@ -18,3 +18,7 @@ export interface WritableComputedOptions<T> {
   get: ComputedGetter<T>
   set: ComputedSetter<T>
 }
+
+export function computed() {
+  // TODO
+}
diff --git a/src/composition-api/reactivity/effect.ts b/src/composition-api/reactivity/effect.ts
index 895e2030182..e6bcaaeb1cc 100644
--- a/src/composition-api/reactivity/effect.ts
+++ b/src/composition-api/reactivity/effect.ts
@@ -52,3 +52,6 @@ export class ReactiveEffect<T = any> {
     this.active = false
   }
 }
+
+// since we are not exposing this in Vue 2, it's used only for internal testing.
+export const effect = (fn: () => any) => new ReactiveEffect(fn)
diff --git a/src/composition-api/reactivity/reactive.ts b/src/composition-api/reactivity/reactive.ts
index 1cd310a854d..db0ce06af2b 100644
--- a/src/composition-api/reactivity/reactive.ts
+++ b/src/composition-api/reactivity/reactive.ts
@@ -1,5 +1,6 @@
 import { observe, Observer } from 'core/observer'
-import { Ref, UnwrapRefSimple } from './ref'
+import { def, isPrimitive, warn } from 'core/util'
+import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
 
 export const enum ReactiveFlags {
   SKIP = '__v_skip',
@@ -25,7 +26,10 @@ export function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
 export function reactive(target: object) {
   // if trying to observe a readonly proxy, return the readonly version.
   if (!isReadonly(target)) {
-    observe(target)
+    const ob = observe(target)
+    if (__DEV__ && !ob && (target == null || isPrimitive(target))) {
+      warn(`value cannot be made reactive: ${String(target)}`)
+    }
   }
   return target
 }
@@ -42,3 +46,15 @@ export function isReadonly(value: unknown): boolean {
   // TODO
   return !!(value && (value as Target).__v_isReadonly)
 }
+
+export function toRaw<T>(observed: T): T {
+  // TODO for readonly
+  return observed
+}
+
+export function markRaw<T extends object>(
+  value: T
+): T & { [RawSymbol]?: true } {
+  def(value, ReactiveFlags.SKIP, true)
+  return value
+}
diff --git a/src/composition-api/reactivity/ref.ts b/src/composition-api/reactivity/ref.ts
index 960b198ba7d..b0c9c4a0ea5 100644
--- a/src/composition-api/reactivity/ref.ts
+++ b/src/composition-api/reactivity/ref.ts
@@ -1,5 +1,5 @@
 import { defineReactive } from 'core/observer/index'
-import { isReactive, ShallowReactiveMarker } from './reactive'
+import { isReactive, type ShallowReactiveMarker } from './reactive'
 import type { IfAny } from 'typescript/utils'
 import Dep from 'core/observer/dep'
 import { warn, isArray } from 'core/util'
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 6a58c432dff..aaf55a35d29 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -26,8 +26,11 @@ export function initMixin(Vue: Component) {
       mark(startTag)
     }
 
-    // a flag to avoid this being observed
+    // a flag to mark this as a Vue instance without having to do instanceof
+    // check
     vm._isVue = true
+    // avoid instances from being observed
+    vm.__v_skip = true
     // merge options
     if (options && options._isComponent) {
       // optimize internal component instantiation
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 8a2da69e108..7f688d42391 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -120,7 +120,7 @@ export function observe(value: any, asRootData?: boolean): Observer | void {
     !isServerRendering() &&
     (isArray(value) || isPlainObject(value)) &&
     Object.isExtensible(value) &&
-    !value._isVue
+    !value.__v_skip
   ) {
     ob = new Observer(value)
   }
diff --git a/test/helpers/to-have-warned.ts b/test/helpers/to-have-warned.ts
index 2aca2bdcfd1..cba4bc0cafc 100644
--- a/test/helpers/to-have-warned.ts
+++ b/test/helpers/to-have-warned.ts
@@ -27,7 +27,7 @@ expect.extend({
   toHaveBeenWarnedLast(received: string) {
     asserted.add(received)
     const passed =
-      warn.mock.calls[warn.mock.calls.length - 1][0].includes(received)
+      warn.mock.calls[warn.mock.calls.length - 1]?.[0].includes(received)
     if (passed) {
       return {
         pass: true,
diff --git a/test/unit/features/composition-api/reactivity/reactive.spec.ts b/test/unit/features/composition-api/reactivity/reactive.spec.ts
new file mode 100644
index 00000000000..5d03554ef3b
--- /dev/null
+++ b/test/unit/features/composition-api/reactivity/reactive.spec.ts
@@ -0,0 +1,284 @@
+import { ref, isRef } from 'vca/reactivity/ref'
+import { reactive, isReactive, toRaw, markRaw } from 'vca/reactivity/reactive'
+import { effect } from 'vca/reactivity/effect'
+import { set } from 'core/observer'
+// TODO import { computed } from 'vca/reactivity/computed'
+
+describe('reactivity/reactive', () => {
+  test('Object', () => {
+    const original = { foo: 1 }
+    const observed = reactive(original)
+    // @discrepancy Vue 2 does not create proxy objects
+    // expect(observed).not.toBe(original)
+    expect(isReactive(observed)).toBe(true)
+    // @discrepancy Vue 2 does not create proxy objects
+    // expect(isReactive(original)).toBe(false)
+    // get
+    expect(observed.foo).toBe(1)
+    // has
+    expect('foo' in observed).toBe(true)
+    // ownKeys
+    expect(Object.keys(observed)).toEqual(['foo'])
+  })
+
+  test('proto', () => {
+    const obj = {}
+    const reactiveObj = reactive(obj)
+    expect(isReactive(reactiveObj)).toBe(true)
+    // read prop of reactiveObject will cause reactiveObj[prop] to be reactive
+    // @ts-ignore
+    const prototype = reactiveObj['__proto__']
+    const otherObj = { data: ['a'] }
+    expect(isReactive(otherObj)).toBe(false)
+    const reactiveOther = reactive(otherObj)
+    expect(isReactive(reactiveOther)).toBe(true)
+    expect(reactiveOther.data[0]).toBe('a')
+  })
+
+  test('nested reactives', () => {
+    const original = {
+      nested: {
+        foo: 1
+      },
+      array: [{ bar: 2 }]
+    }
+    const observed = reactive(original)
+    expect(isReactive(observed.nested)).toBe(true)
+    expect(isReactive(observed.array)).toBe(true)
+    expect(isReactive(observed.array[0])).toBe(true)
+  })
+
+  // @discrepancy Vue 2 does not support collections
+  // test('observing subtypes of IterableCollections(Map, Set)', () => {
+  //   // subtypes of Map
+  //   class CustomMap extends Map {}
+  //   const cmap = reactive(new CustomMap())
+
+  //   expect(cmap instanceof Map).toBe(true)
+  //   expect(isReactive(cmap)).toBe(true)
+
+  //   cmap.set('key', {})
+  //   expect(isReactive(cmap.get('key'))).toBe(true)
+
+  //   // subtypes of Set
+  //   class CustomSet extends Set {}
+  //   const cset = reactive(new CustomSet())
+
+  //   expect(cset instanceof Set).toBe(true)
+  //   expect(isReactive(cset)).toBe(true)
+
+  //   let dummy
+  //   effect(() => (dummy = cset.has('value')))
+  //   expect(dummy).toBe(false)
+  //   cset.add('value')
+  //   expect(dummy).toBe(true)
+  //   cset.delete('value')
+  //   expect(dummy).toBe(false)
+  // })
+
+  // test('observing subtypes of WeakCollections(WeakMap, WeakSet)', () => {
+  //   // subtypes of WeakMap
+  //   class CustomMap extends WeakMap {}
+  //   const cmap = reactive(new CustomMap())
+
+  //   expect(cmap instanceof WeakMap).toBe(true)
+  //   expect(isReactive(cmap)).toBe(true)
+
+  //   const key = {}
+  //   cmap.set(key, {})
+  //   expect(isReactive(cmap.get(key))).toBe(true)
+
+  //   // subtypes of WeakSet
+  //   class CustomSet extends WeakSet {}
+  //   const cset = reactive(new CustomSet())
+
+  //   expect(cset instanceof WeakSet).toBe(true)
+  //   expect(isReactive(cset)).toBe(true)
+
+  //   let dummy
+  //   effect(() => (dummy = cset.has(key)))
+  //   expect(dummy).toBe(false)
+  //   cset.add(key)
+  //   expect(dummy).toBe(true)
+  //   cset.delete(key)
+  //   expect(dummy).toBe(false)
+  // })
+
+  test('observed value should proxy mutations to original (Object)', () => {
+    const original: any = { foo: 1 }
+    const observed = reactive(original)
+    // set
+    observed.bar = 1
+    expect(observed.bar).toBe(1)
+    expect(original.bar).toBe(1)
+    // delete
+    delete observed.foo
+    expect('foo' in observed).toBe(false)
+    expect('foo' in original).toBe(false)
+  })
+
+  test('original value change should reflect in observed value (Object)', () => {
+    const original: any = { foo: 1 }
+    const observed = reactive(original)
+    // set
+    original.bar = 1
+    expect(original.bar).toBe(1)
+    expect(observed.bar).toBe(1)
+    // delete
+    delete original.foo
+    expect('foo' in original).toBe(false)
+    expect('foo' in observed).toBe(false)
+  })
+
+  test('setting a property with an unobserved value should wrap with reactive', () => {
+    const observed = reactive<{ foo?: object }>({})
+    const raw = {}
+    set(observed, 'foo', raw)
+    // @discrepancy not a proxy
+    // expect(observed.foo).not.toBe(raw)
+    expect(isReactive(observed.foo)).toBe(true)
+  })
+
+  test('observing already observed value should return same Proxy', () => {
+    const original = { foo: 1 }
+    const observed = reactive(original)
+    const observed2 = reactive(observed)
+    expect(observed2).toBe(observed)
+  })
+
+  test('observing the same value multiple times should return same Proxy', () => {
+    const original = { foo: 1 }
+    const observed = reactive(original)
+    const observed2 = reactive(original)
+    expect(observed2).toBe(observed)
+  })
+
+  test('should not pollute original object with Proxies', () => {
+    const original: any = { foo: 1 }
+    const original2 = { bar: 2 }
+    const observed = reactive(original)
+    const observed2 = reactive(original2)
+    observed.bar = observed2
+    expect(observed.bar).toBe(observed2)
+    expect(original.bar).toBe(original2)
+  })
+
+  test('toRaw', () => {
+    const original = { foo: 1 }
+    const observed = reactive(original)
+    expect(toRaw(observed)).toBe(original)
+    expect(toRaw(original)).toBe(original)
+  })
+
+  test('toRaw on object using reactive as prototype', () => {
+    const original = reactive({})
+    const obj = Object.create(original)
+    const raw = toRaw(obj)
+    expect(raw).toBe(obj)
+    expect(raw).not.toBe(toRaw(original))
+  })
+
+  test('should not unwrap Ref<T>', () => {
+    const observedNumberRef = reactive(ref(1))
+    const observedObjectRef = reactive(ref({ foo: 1 }))
+
+    expect(isRef(observedNumberRef)).toBe(true)
+    expect(isRef(observedObjectRef)).toBe(true)
+  })
+
+  // TODO
+  // test('should unwrap computed refs', () => {
+  //   // readonly
+  //   const a = computed(() => 1)
+  //   // writable
+  //   const b = computed({
+  //     get: () => 1,
+  //     set: () => {}
+  //   })
+  //   const obj = reactive({ a, b })
+  //   // check type
+  //   obj.a + 1
+  //   obj.b + 1
+  //   expect(typeof obj.a).toBe(`number`)
+  //   expect(typeof obj.b).toBe(`number`)
+  // })
+
+  test('should allow setting property from a ref to another ref', () => {
+    const foo = ref(0)
+    const bar = ref(1)
+    const observed = reactive({ a: foo })
+    let dummy
+    effect(() => {
+      dummy = observed.a
+    })
+    expect(dummy).toBe(0)
+
+    // @ts-ignore
+    observed.a = bar
+    expect(dummy).toBe(1)
+
+    bar.value++
+    expect(dummy).toBe(2)
+  })
+
+  test('non-observable values', () => {
+    const assertValue = (value: any) => {
+      reactive(value)
+      expect(
+        `value cannot be made reactive: ${String(value)}`
+      ).toHaveBeenWarnedLast()
+    }
+
+    // number
+    assertValue(1)
+    // string
+    assertValue('foo')
+    // boolean
+    assertValue(false)
+    // null
+    assertValue(null)
+    // undefined
+    assertValue(undefined)
+    // symbol
+    const s = Symbol()
+    assertValue(s)
+
+    // built-ins should work and return same value
+    const p = Promise.resolve()
+    expect(reactive(p)).toBe(p)
+    const r = new RegExp('')
+    expect(reactive(r)).toBe(r)
+    const d = new Date()
+    expect(reactive(d)).toBe(d)
+  })
+
+  test('markRaw', () => {
+    const obj = reactive({
+      foo: { a: 1 },
+      bar: markRaw({ b: 2 })
+    })
+    expect(isReactive(obj.foo)).toBe(true)
+    expect(isReactive(obj.bar)).toBe(false)
+  })
+
+  test('should not observe non-extensible objects', () => {
+    const obj = reactive({
+      foo: Object.preventExtensions({ a: 1 }),
+      // sealed or frozen objects are considered non-extensible as well
+      bar: Object.freeze({ a: 1 }),
+      baz: Object.seal({ a: 1 })
+    })
+    expect(isReactive(obj.foo)).toBe(false)
+    expect(isReactive(obj.bar)).toBe(false)
+    expect(isReactive(obj.baz)).toBe(false)
+  })
+
+  test('should not observe objects with __v_skip', () => {
+    const original = {
+      foo: 1,
+      __v_skip: true
+    }
+    const observed = reactive(original)
+    expect(isReactive(observed)).toBe(false)
+  })
+})
diff --git a/test/unit/features/composition-api/reactivity/ref.spec.ts b/test/unit/features/composition-api/reactivity/ref.spec.ts
index d696348e2be..fd20dae850e 100644
--- a/test/unit/features/composition-api/reactivity/ref.spec.ts
+++ b/test/unit/features/composition-api/reactivity/ref.spec.ts
@@ -9,11 +9,9 @@ import {
   customRef,
   Ref
 } from 'vca/reactivity/ref'
-import { ReactiveEffect } from 'vca/reactivity/effect'
+import { effect } from 'vca/reactivity/effect'
 import { isReactive, isShallow, reactive } from 'vca/reactivity/reactive'
 
-const effect = (fn: () => any) => new ReactiveEffect(fn)
-
 describe('reactivity/ref', () => {
   it('should hold a value', () => {
     const a = ref(1)
@@ -117,7 +115,7 @@ describe('reactivity/ref', () => {
     expect((arr[1] as Ref).value).toBe(3)
   })
 
-  // Vue 2 does not observe array properties
+  // @discrepancy Vue 2 does not observe array properties
   // it('should unwrap ref types as props of arrays', () => {
   //   const arr = [ref(0)]
   //   const symbolKey = Symbol('')

From 05aaa33a45f2893952e6e838e23ac5ed6cc90aaa Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 26 May 2022 02:14:14 +0800
Subject: [PATCH 075/317] wip: computed tests passing

---
 src/composition-api/apiWatch.ts               |   2 +-
 src/composition-api/index.ts                  |  16 +-
 src/composition-api/reactivity/computed.ts    |  88 +++++-
 src/composition-api/reactivity/effect.ts      |   7 +-
 src/composition-api/reactivity/ref.ts         |  15 +-
 src/core/observer/watcher.ts                  |  10 +-
 .../web/entry-runtime-with-compiler.ts        |   3 +
 .../reactivity/computed.spec.ts               | 298 ++++++++++++++++++
 .../reactivity/reactive.spec.ts               |  45 +--
 .../composition-api/reactivity/ref.spec.ts    |   8 +-
 10 files changed, 449 insertions(+), 43 deletions(-)
 create mode 100644 test/unit/features/composition-api/reactivity/computed.spec.ts

diff --git a/src/composition-api/apiWatch.ts b/src/composition-api/apiWatch.ts
index 59862b1ddc4..3418a788381 100644
--- a/src/composition-api/apiWatch.ts
+++ b/src/composition-api/apiWatch.ts
@@ -49,7 +49,7 @@ export interface WatchOptionsBase extends DebuggerOptions {
   flush?: 'pre' | 'post' | 'sync'
 }
 
-interface DebuggerOptions {
+export interface DebuggerOptions {
   onTrack?: (event: DebuggerEvent) => void
   onTrigger?: (event: DebuggerEvent) => void
 }
diff --git a/src/composition-api/index.ts b/src/composition-api/index.ts
index 2163d905cb8..e755d224ff1 100644
--- a/src/composition-api/index.ts
+++ b/src/composition-api/index.ts
@@ -26,17 +26,27 @@ export {
   // isProxy,
   // shallowReactive,
   // shallowReadonly,
-  // markRaw,
-  // toRaw,
+  markRaw,
+  toRaw,
   ReactiveFlags,
   // DeepReadonly,
   // ShallowReactive,
   UnwrapNestedRefs
 } from './reactivity/reactive'
 
+export {
+  computed,
+  ComputedRef,
+  WritableComputedRef,
+  WritableComputedOptions,
+  ComputedGetter,
+  ComputedSetter
+} from './reactivity/computed'
+
 export {
   watch,
   watchEffect,
   watchPostEffect,
-  watchSyncEffect
+  watchSyncEffect,
+  DebuggerEvent
 } from './apiWatch'
diff --git a/src/composition-api/reactivity/computed.ts b/src/composition-api/reactivity/computed.ts
index b9daf8abf5a..d064dad0c31 100644
--- a/src/composition-api/reactivity/computed.ts
+++ b/src/composition-api/reactivity/computed.ts
@@ -1,4 +1,9 @@
+import { isServerRendering, noop, warn } from 'core/util'
 import { Ref } from './ref'
+import Watcher from 'core/observer/watcher'
+import Dep from 'core/observer/dep'
+import { currentInstance } from '../currentInstance'
+import { DebuggerOptions } from '../apiWatch'
 
 declare const ComputedRefSymbol: unique symbol
 
@@ -8,7 +13,7 @@ export interface ComputedRef<T = any> extends WritableComputedRef<T> {
 }
 
 export interface WritableComputedRef<T> extends Ref<T> {
-  // TODO readonly effect: ReactiveEffect<T>
+  readonly effect: { stop(): void }
 }
 
 export type ComputedGetter<T> = (...args: any[]) => T
@@ -19,6 +24,83 @@ export interface WritableComputedOptions<T> {
   set: ComputedSetter<T>
 }
 
-export function computed() {
-  // TODO
+export function computed<T>(
+  getter: ComputedGetter<T>,
+  debugOptions?: DebuggerOptions
+): ComputedRef<T>
+export function computed<T>(
+  options: WritableComputedOptions<T>,
+  debugOptions?: DebuggerOptions
+): WritableComputedRef<T>
+export function computed<T>(
+  getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>,
+  // TODO debug options
+  debugOptions?: DebuggerOptions
+) {
+  let getter: ComputedGetter<T>
+  let setter: ComputedSetter<T>
+
+  const onlyGetter = typeof getterOrOptions === 'function'
+  if (onlyGetter) {
+    getter = getterOrOptions
+    setter = __DEV__
+      ? () => {
+          warn('Write operation failed: computed value is readonly')
+        }
+      : noop
+  } else {
+    getter = getterOrOptions.get
+    setter = getterOrOptions.set
+  }
+
+  return new ComputedRefImpl(
+    getter,
+    setter,
+    onlyGetter,
+    isServerRendering()
+  ) as any
+}
+
+class ComputedRefImpl<T> {
+  public dep?: Dep = undefined
+
+  public readonly __v_isRef = true
+  public readonly effect
+
+  private _watcher: Watcher | null
+
+  constructor(
+    private _getter: ComputedGetter<T>,
+    private readonly _setter: ComputedSetter<T>,
+    public readonly __v_isReadonly: boolean,
+    isSSR: boolean
+  ) {
+    const watcher = (this._watcher = isSSR
+      ? null
+      : new Watcher(currentInstance, _getter, noop, { lazy: true }))
+    this.effect = {
+      stop() {
+        watcher && watcher.teardown()
+      }
+    }
+  }
+
+  get value() {
+    const watcher = this._watcher
+    if (watcher) {
+      if (watcher.dirty) {
+        watcher.evaluate()
+      }
+      if (Dep.target) {
+        watcher.depend()
+      }
+      return watcher.value
+    } else {
+      return this._getter()
+    }
+  }
+
+  set value(newValue: T) {
+    this._setter(newValue)
+  }
 }
diff --git a/src/composition-api/reactivity/effect.ts b/src/composition-api/reactivity/effect.ts
index e6bcaaeb1cc..677d7b9da34 100644
--- a/src/composition-api/reactivity/effect.ts
+++ b/src/composition-api/reactivity/effect.ts
@@ -30,12 +30,12 @@ export class ReactiveEffect<T = any> {
 
   constructor(
     public fn: () => T,
-    public scheduler?: EffectScheduler // TODO scope?: EffectScope
+    scheduler?: EffectScheduler // TODO scope?: EffectScope
   ) {
     // TODO recordEffectScope(this, scope)
     // TODO debug options
     this._watcher = new Watcher(currentInstance, fn, noop, {
-      // force cb trigger
+      // always force trigger update if has scheduler
       deep: true,
       sync: !scheduler,
       scheduler
@@ -54,4 +54,5 @@ export class ReactiveEffect<T = any> {
 }
 
 // since we are not exposing this in Vue 2, it's used only for internal testing.
-export const effect = (fn: () => any) => new ReactiveEffect(fn)
+export const effect = (fn: () => any, scheduler?: any) =>
+  new ReactiveEffect(fn, scheduler)
diff --git a/src/composition-api/reactivity/ref.ts b/src/composition-api/reactivity/ref.ts
index b0c9c4a0ea5..e6edcf663fe 100644
--- a/src/composition-api/reactivity/ref.ts
+++ b/src/composition-api/reactivity/ref.ts
@@ -18,7 +18,7 @@ export interface Ref<T = any> {
   /**
    * @private
    */
-  dep: Dep
+  dep?: Dep
 }
 
 export function isRef<T>(r: Ref<T> | unknown): r is Ref<T>
@@ -58,7 +58,10 @@ function createRef(rawValue: unknown, shallow: boolean) {
 }
 
 export function triggerRef(ref: Ref) {
-  ref.dep.notify()
+  if (__DEV__ && !ref.dep) {
+    warn(`received object is not a triggerable ref.`)
+  }
+  ref.dep && ref.dep.notify()
 }
 
 export function unref<T>(ref: T | Ref<T>): T {
@@ -74,18 +77,16 @@ export type CustomRefFactory<T> = (
 }
 
 class CustomRefImpl<T> {
-  public dep?: Dep = undefined
-
+  public dep = new Dep()
   private readonly _get: ReturnType<CustomRefFactory<T>>['get']
   private readonly _set: ReturnType<CustomRefFactory<T>>['set']
 
   public readonly __v_isRef = true
 
   constructor(factory: CustomRefFactory<T>) {
-    const dep = new Dep()
     const { get, set } = factory(
-      () => dep.depend(),
-      () => dep.notify()
+      () => this.dep.depend(),
+      () => this.dep.notify()
     )
     this._get = get
     this._set = set
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index eb998fe63d6..438577052f1 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -6,7 +6,8 @@ import {
   _Set as Set,
   handleError,
   invokeWithErrorHandling,
-  noop
+  noop,
+  bind
 } from '../util/index'
 
 import { traverse } from './traverse'
@@ -70,7 +71,10 @@ export default class Watcher implements DepTarget {
       this.lazy = !!options.lazy
       this.sync = !!options.sync
       this.before = options.before
-      this.scheduler = options.scheduler
+      if ((this.scheduler = options.scheduler)) {
+        // @ts-ignore
+        this.run = bind(this.run, this)
+      }
     } else {
       this.deep = this.user = this.lazy = this.sync = false
     }
@@ -175,7 +179,7 @@ export default class Watcher implements DepTarget {
     } else if (this.sync) {
       this.run()
     } else if (this.scheduler) {
-      this.scheduler()
+      this.scheduler(this.run)
     } else {
       queueWatcher(this)
     }
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index a7437b2e8d1..5b393292e71 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -4,4 +4,7 @@ import { extend } from 'shared/util'
 
 extend(Vue, vca)
 
+import { effect } from 'vca/reactivity/effect'
+Vue.effect = effect
+
 export default Vue
diff --git a/test/unit/features/composition-api/reactivity/computed.spec.ts b/test/unit/features/composition-api/reactivity/computed.spec.ts
new file mode 100644
index 00000000000..afbbf8b2371
--- /dev/null
+++ b/test/unit/features/composition-api/reactivity/computed.spec.ts
@@ -0,0 +1,298 @@
+import {
+  computed,
+  reactive,
+  ref,
+  isReadonly,
+  // toRaw,
+  WritableComputedRef
+  // DebuggerEvent
+} from 'vca/index'
+import { effect } from 'vca/reactivity/effect'
+import { nextTick } from 'core/util'
+// import { TrackOpTypes, TriggerOpTypes } from 'vca/reactivity/operations'
+
+describe('reactivity/computed', () => {
+  it('should return updated value', () => {
+    const value = reactive({ foo: 1 })
+    const cValue = computed(() => value.foo)
+    expect(cValue.value).toBe(1)
+    value.foo = 2
+    expect(cValue.value).toBe(2)
+  })
+
+  it('should compute lazily', () => {
+    const value = reactive<{ foo?: number }>({ foo: undefined })
+    const getter = vi.fn(() => value.foo)
+    const cValue = computed(getter)
+
+    // lazy
+    expect(getter).not.toHaveBeenCalled()
+
+    expect(cValue.value).toBe(undefined)
+    expect(getter).toHaveBeenCalledTimes(1)
+
+    // should not compute again
+    cValue.value
+    expect(getter).toHaveBeenCalledTimes(1)
+
+    // should not compute until needed
+    value.foo = 1
+    expect(getter).toHaveBeenCalledTimes(1)
+
+    // now it should compute
+    expect(cValue.value).toBe(1)
+    expect(getter).toHaveBeenCalledTimes(2)
+
+    // should not compute again
+    cValue.value
+    expect(getter).toHaveBeenCalledTimes(2)
+  })
+
+  it('should trigger effect', () => {
+    const value = reactive<{ foo?: number }>({ foo: undefined })
+    const cValue = computed(() => value.foo)
+    let dummy
+    effect(() => {
+      dummy = cValue.value
+    })
+    expect(dummy).toBe(undefined)
+    value.foo = 1
+    expect(dummy).toBe(1)
+  })
+
+  it('should work when chained', () => {
+    const value = reactive({ foo: 0 })
+    const c1 = computed(() => value.foo)
+    const c2 = computed(() => c1.value + 1)
+    expect(c2.value).toBe(1)
+    expect(c1.value).toBe(0)
+    value.foo++
+    expect(c2.value).toBe(2)
+    expect(c1.value).toBe(1)
+  })
+
+  it('should trigger effect when chained', () => {
+    const value = reactive({ foo: 0 })
+    const getter1 = vi.fn(() => value.foo)
+    const getter2 = vi.fn(() => {
+      return c1.value + 1
+    })
+    const c1 = computed(getter1)
+    const c2 = computed(getter2)
+
+    let dummy
+    effect(() => {
+      dummy = c2.value
+    })
+    expect(dummy).toBe(1)
+    expect(getter1).toHaveBeenCalledTimes(1)
+    expect(getter2).toHaveBeenCalledTimes(1)
+    value.foo++
+    expect(dummy).toBe(2)
+    // should not result in duplicate calls
+    expect(getter1).toHaveBeenCalledTimes(2)
+    expect(getter2).toHaveBeenCalledTimes(2)
+  })
+
+  it('should trigger effect when chained (mixed invocations)', async () => {
+    const value = reactive({ foo: 0 })
+    const getter1 = vi.fn(() => value.foo)
+    const getter2 = vi.fn(() => {
+      return c1.value + 1
+    })
+    const c1 = computed(getter1)
+    const c2 = computed(getter2)
+
+    let dummy
+    // @discrepancy Vue 2 chained computed doesn't work with sync watchers
+    effect(() => {
+      dummy = c1.value + c2.value
+    }, nextTick)
+    expect(dummy).toBe(1)
+
+    expect(getter1).toHaveBeenCalledTimes(1)
+    expect(getter2).toHaveBeenCalledTimes(1)
+    value.foo++
+
+    await nextTick()
+    expect(dummy).toBe(3)
+    // should not result in duplicate calls
+    expect(getter1).toHaveBeenCalledTimes(2)
+    expect(getter2).toHaveBeenCalledTimes(2)
+  })
+
+  it('should no longer update when stopped', () => {
+    const value = reactive<{ foo?: number }>({ foo: undefined })
+    const cValue = computed(() => value.foo)
+    let dummy
+    effect(() => {
+      dummy = cValue.value
+    })
+    expect(dummy).toBe(undefined)
+    value.foo = 1
+    expect(dummy).toBe(1)
+    cValue.effect.stop()
+    value.foo = 2
+    expect(dummy).toBe(1)
+  })
+
+  it('should support setter', () => {
+    const n = ref(1)
+    const plusOne = computed({
+      get: () => n.value + 1,
+      set: val => {
+        n.value = val - 1
+      }
+    })
+
+    expect(plusOne.value).toBe(2)
+    n.value++
+    expect(plusOne.value).toBe(3)
+
+    plusOne.value = 0
+    expect(n.value).toBe(-1)
+  })
+
+  it('should trigger effect w/ setter', () => {
+    const n = ref(1)
+    const plusOne = computed({
+      get: () => n.value + 1,
+      set: val => {
+        n.value = val - 1
+      }
+    })
+
+    let dummy
+    effect(() => {
+      dummy = n.value
+    })
+    expect(dummy).toBe(1)
+
+    plusOne.value = 0
+    expect(dummy).toBe(-1)
+  })
+
+  // #5720
+  it('should invalidate before non-computed effects', async () => {
+    let plusOneValues: number[] = []
+    const n = ref(0)
+    const plusOne = computed(() => n.value + 1)
+    effect(() => {
+      n.value
+      plusOneValues.push(plusOne.value)
+    }, nextTick)
+    expect(plusOneValues).toMatchObject([1])
+    // access plusOne, causing it to be non-dirty
+    plusOne.value
+    // mutate n
+    n.value++
+    await nextTick()
+    // on the 2nd run, plusOne.value should have already updated.
+    expect(plusOneValues).toMatchObject([1, 2])
+  })
+
+  it('should warn if trying to set a readonly computed', () => {
+    const n = ref(1)
+    const plusOne = computed(() => n.value + 1)
+    ;(plusOne as WritableComputedRef<number>).value++ // Type cast to prevent TS from preventing the error
+
+    expect(
+      'Write operation failed: computed value is readonly'
+    ).toHaveBeenWarnedLast()
+  })
+
+  it('should be readonly', () => {
+    let a = { a: 1 }
+    const x = computed(() => a)
+    expect(isReadonly(x)).toBe(true)
+    expect(isReadonly(x.value)).toBe(false)
+    expect(isReadonly(x.value.a)).toBe(false)
+    const z = computed<typeof a>({
+      get() {
+        return a
+      },
+      set(v) {
+        a = v
+      }
+    })
+    expect(isReadonly(z)).toBe(false)
+    expect(isReadonly(z.value.a)).toBe(false)
+  })
+
+  it('should expose value when stopped', () => {
+    const x = computed(() => 1)
+    x.effect.stop()
+    expect(x.value).toBe(1)
+  })
+
+  // TODO
+  // it('debug: onTrack', () => {
+  //   let events: DebuggerEvent[] = []
+  //   const onTrack = vi.fn((e: DebuggerEvent) => {
+  //     events.push(e)
+  //   })
+  //   const obj = reactive({ foo: 1, bar: 2 })
+  //   const c = computed(() => (obj.foo, 'bar' in obj, Object.keys(obj)), {
+  //     onTrack
+  //   })
+  //   expect(c.value).toEqual(['foo', 'bar'])
+  //   expect(onTrack).toHaveBeenCalledTimes(3)
+  //   expect(events).toEqual([
+  //     {
+  //       effect: c.effect,
+  //       target: toRaw(obj),
+  //       type: TrackOpTypes.GET,
+  //       key: 'foo'
+  //     },
+  //     {
+  //       effect: c.effect,
+  //       target: toRaw(obj),
+  //       type: TrackOpTypes.HAS,
+  //       key: 'bar'
+  //     },
+  //     {
+  //       effect: c.effect,
+  //       target: toRaw(obj),
+  //       type: TrackOpTypes.ITERATE,
+  //       key: ITERATE_KEY
+  //     }
+  //   ])
+  // })
+
+  // TODO
+  // it('debug: onTrigger', () => {
+  //   let events: DebuggerEvent[] = []
+  //   const onTrigger = vi.fn((e: DebuggerEvent) => {
+  //     events.push(e)
+  //   })
+  //   const obj = reactive({ foo: 1 })
+  //   const c = computed(() => obj.foo, { onTrigger })
+
+  //   // computed won't trigger compute until accessed
+  //   c.value
+
+  //   obj.foo++
+  //   expect(c.value).toBe(2)
+  //   expect(onTrigger).toHaveBeenCalledTimes(1)
+  //   expect(events[0]).toEqual({
+  //     effect: c.effect,
+  //     target: toRaw(obj),
+  //     type: TriggerOpTypes.SET,
+  //     key: 'foo',
+  //     oldValue: 1,
+  //     newValue: 2
+  //   })
+
+  //   // @ts-ignore
+  //   delete obj.foo
+  //   expect(c.value).toBeUndefined()
+  //   expect(onTrigger).toHaveBeenCalledTimes(2)
+  //   expect(events[1]).toEqual({
+  //     effect: c.effect,
+  //     target: toRaw(obj),
+  //     type: TriggerOpTypes.DELETE,
+  //     key: 'foo',
+  //     oldValue: 2
+  //   })
+  // })
+})
diff --git a/test/unit/features/composition-api/reactivity/reactive.spec.ts b/test/unit/features/composition-api/reactivity/reactive.spec.ts
index 5d03554ef3b..28fcedf78f2 100644
--- a/test/unit/features/composition-api/reactivity/reactive.spec.ts
+++ b/test/unit/features/composition-api/reactivity/reactive.spec.ts
@@ -1,8 +1,14 @@
-import { ref, isRef } from 'vca/reactivity/ref'
-import { reactive, isReactive, toRaw, markRaw } from 'vca/reactivity/reactive'
-import { effect } from 'vca/reactivity/effect'
+import {
+  ref,
+  isRef,
+  reactive,
+  isReactive,
+  toRaw,
+  markRaw,
+  computed
+} from 'vca/index'
 import { set } from 'core/observer'
-// TODO import { computed } from 'vca/reactivity/computed'
+import { effect } from 'vca/reactivity/effect'
 
 describe('reactivity/reactive', () => {
   test('Object', () => {
@@ -186,22 +192,21 @@ describe('reactivity/reactive', () => {
     expect(isRef(observedObjectRef)).toBe(true)
   })
 
-  // TODO
-  // test('should unwrap computed refs', () => {
-  //   // readonly
-  //   const a = computed(() => 1)
-  //   // writable
-  //   const b = computed({
-  //     get: () => 1,
-  //     set: () => {}
-  //   })
-  //   const obj = reactive({ a, b })
-  //   // check type
-  //   obj.a + 1
-  //   obj.b + 1
-  //   expect(typeof obj.a).toBe(`number`)
-  //   expect(typeof obj.b).toBe(`number`)
-  // })
+  test('should unwrap computed refs', () => {
+    // readonly
+    const a = computed(() => 1)
+    // writable
+    const b = computed({
+      get: () => 1,
+      set: () => {}
+    })
+    const obj = reactive({ a, b })
+    // check type
+    obj.a + 1
+    obj.b + 1
+    expect(typeof obj.a).toBe(`number`)
+    expect(typeof obj.b).toBe(`number`)
+  })
 
   test('should allow setting property from a ref to another ref', () => {
     const foo = ref(0)
diff --git a/test/unit/features/composition-api/reactivity/ref.spec.ts b/test/unit/features/composition-api/reactivity/ref.spec.ts
index fd20dae850e..376e8cffc74 100644
--- a/test/unit/features/composition-api/reactivity/ref.spec.ts
+++ b/test/unit/features/composition-api/reactivity/ref.spec.ts
@@ -7,10 +7,12 @@ import {
   toRef,
   toRefs,
   customRef,
-  Ref
-} from 'vca/reactivity/ref'
+  Ref,
+  isReactive,
+  isShallow,
+  reactive
+} from 'vca/index'
 import { effect } from 'vca/reactivity/effect'
-import { isReactive, isShallow, reactive } from 'vca/reactivity/reactive'
 
 describe('reactivity/ref', () => {
   it('should hold a value', () => {

From 282ebb08937b41cd19ca43ed20fb1c9fdd8ea86d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 26 May 2022 02:18:33 +0800
Subject: [PATCH 076/317] chore: remove duplicated types

---
 src/composition-api/apiWatch.ts | 20 +++++---------------
 src/composition-api/index.ts    |  3 +--
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/src/composition-api/apiWatch.ts b/src/composition-api/apiWatch.ts
index 3418a788381..112fbd26ea4 100644
--- a/src/composition-api/apiWatch.ts
+++ b/src/composition-api/apiWatch.ts
@@ -1,7 +1,6 @@
 import { isRef, Ref } from './reactivity/ref'
 import { ComputedRef } from './reactivity/computed'
 import { isReactive, isShallow } from './reactivity/reactive'
-import { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 import {
   warn,
   noop,
@@ -14,7 +13,11 @@ import {
 } from 'core/util'
 import { currentInstance } from './currentInstance'
 import { traverse } from 'core/observer/traverse'
-import { EffectScheduler, ReactiveEffect } from './reactivity/effect'
+import {
+  EffectScheduler,
+  ReactiveEffect,
+  DebuggerEvent
+} from './reactivity/effect'
 
 const WATCHER = `watcher`
 const WATCHER_CB = `${WATCHER} callback`
@@ -54,19 +57,6 @@ export interface DebuggerOptions {
   onTrigger?: (event: DebuggerEvent) => void
 }
 
-export type DebuggerEvent = {
-  // TODO effect: ReactiveEffect
-} & DebuggerEventExtraInfo
-
-export type DebuggerEventExtraInfo = {
-  target: object
-  type: TrackOpTypes | TriggerOpTypes
-  key: any
-  newValue?: any
-  oldValue?: any
-  oldTarget?: Map<any, any> | Set<any>
-}
-
 export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
   immediate?: Immediate
   deep?: boolean
diff --git a/src/composition-api/index.ts b/src/composition-api/index.ts
index e755d224ff1..ad35f223066 100644
--- a/src/composition-api/index.ts
+++ b/src/composition-api/index.ts
@@ -47,6 +47,5 @@ export {
   watch,
   watchEffect,
   watchPostEffect,
-  watchSyncEffect,
-  DebuggerEvent
+  watchSyncEffect
 } from './apiWatch'

From a16271280a164d4e9ef4af9bb7bd5e58e5cff2dc Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 26 May 2022 02:34:15 +0800
Subject: [PATCH 077/317] refactor: simplify implementations

since we output es5, classes are more verbose then necessary
---
 src/composition-api/reactivity/computed.ts    | 73 +++++++-----------
 src/composition-api/reactivity/ref.ts         | 75 +++++++------------
 .../reactivity/computed.spec.ts               |  4 +-
 3 files changed, 54 insertions(+), 98 deletions(-)

diff --git a/src/composition-api/reactivity/computed.ts b/src/composition-api/reactivity/computed.ts
index d064dad0c31..3d03fcea9d1 100644
--- a/src/composition-api/reactivity/computed.ts
+++ b/src/composition-api/reactivity/computed.ts
@@ -13,7 +13,7 @@ export interface ComputedRef<T = any> extends WritableComputedRef<T> {
 }
 
 export interface WritableComputedRef<T> extends Ref<T> {
-  readonly effect: { stop(): void }
+  readonly effect: Watcher
 }
 
 export type ComputedGetter<T> = (...args: any[]) => T
@@ -53,54 +53,31 @@ export function computed<T>(
     setter = getterOrOptions.set
   }
 
-  return new ComputedRefImpl(
-    getter,
-    setter,
-    onlyGetter,
-    isServerRendering()
-  ) as any
-}
-
-class ComputedRefImpl<T> {
-  public dep?: Dep = undefined
-
-  public readonly __v_isRef = true
-  public readonly effect
-
-  private _watcher: Watcher | null
-
-  constructor(
-    private _getter: ComputedGetter<T>,
-    private readonly _setter: ComputedSetter<T>,
-    public readonly __v_isReadonly: boolean,
-    isSSR: boolean
-  ) {
-    const watcher = (this._watcher = isSSR
-      ? null
-      : new Watcher(currentInstance, _getter, noop, { lazy: true }))
-    this.effect = {
-      stop() {
-        watcher && watcher.teardown()
-      }
-    }
-  }
+  const watcher = isServerRendering()
+    ? null
+    : new Watcher(currentInstance, getter, noop, { lazy: true })
 
-  get value() {
-    const watcher = this._watcher
-    if (watcher) {
-      if (watcher.dirty) {
-        watcher.evaluate()
-      }
-      if (Dep.target) {
-        watcher.depend()
+  return {
+    __v_isRef: true,
+    __v_isReadonly: onlyGetter,
+    // some libs rely on the presence effect for checking computed refs
+    // from normal refs, but the implementation doesn't matter
+    effect: watcher,
+    get value() {
+      if (watcher) {
+        if (watcher.dirty) {
+          watcher.evaluate()
+        }
+        if (Dep.target) {
+          watcher.depend()
+        }
+        return watcher.value
+      } else {
+        return getter()
       }
-      return watcher.value
-    } else {
-      return this._getter()
+    },
+    set value(newVal) {
+      setter(newVal)
     }
-  }
-
-  set value(newValue: T) {
-    this._setter(newValue)
-  }
+  } as any
 }
diff --git a/src/composition-api/reactivity/ref.ts b/src/composition-api/reactivity/ref.ts
index e6edcf663fe..bf097ec2e91 100644
--- a/src/composition-api/reactivity/ref.ts
+++ b/src/composition-api/reactivity/ref.ts
@@ -76,33 +76,21 @@ export type CustomRefFactory<T> = (
   set: (value: T) => void
 }
 
-class CustomRefImpl<T> {
-  public dep = new Dep()
-  private readonly _get: ReturnType<CustomRefFactory<T>>['get']
-  private readonly _set: ReturnType<CustomRefFactory<T>>['set']
-
-  public readonly __v_isRef = true
-
-  constructor(factory: CustomRefFactory<T>) {
-    const { get, set } = factory(
-      () => this.dep.depend(),
-      () => this.dep.notify()
-    )
-    this._get = get
-    this._set = set
-  }
-
-  get value() {
-    return this._get()
-  }
-
-  set value(newVal) {
-    this._set(newVal)
-  }
-}
-
 export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
-  return new CustomRefImpl(factory) as any
+  const dep = new Dep()
+  const { get, set } = factory(
+    () => dep.depend(),
+    () => dep.notify()
+  )
+  return {
+    __v_isRef: true,
+    get value() {
+      return get()
+    },
+    set value(newVal) {
+      set(newVal)
+    }
+  } as any
 }
 
 export type ToRefs<T = any> = {
@@ -120,25 +108,6 @@ export function toRefs<T extends object>(object: T): ToRefs<T> {
   return ret
 }
 
-class ObjectRefImpl<T extends object, K extends keyof T> {
-  public readonly __v_isRef = true
-
-  constructor(
-    private readonly _object: T,
-    private readonly _key: K,
-    private readonly _defaultValue?: T[K]
-  ) {}
-
-  get value() {
-    const val = this._object[this._key]
-    return val === undefined ? (this._defaultValue as T[K]) : val
-  }
-
-  set value(newVal) {
-    this._object[this._key] = newVal
-  }
-}
-
 export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>
 
 export function toRef<T extends object, K extends keyof T>(
@@ -158,9 +127,19 @@ export function toRef<T extends object, K extends keyof T>(
   defaultValue?: T[K]
 ): ToRef<T[K]> {
   const val = object[key]
-  return isRef(val)
-    ? val
-    : (new ObjectRefImpl(object, key, defaultValue) as any)
+  if (isRef(val)) {
+    return val as any
+  }
+  return {
+    __v_isRef: true,
+    get value() {
+      const val = object[key]
+      return val === undefined ? (defaultValue as T[K]) : val
+    },
+    set value(newVal) {
+      object[key] = newVal
+    }
+  } as any
 }
 
 /**
diff --git a/test/unit/features/composition-api/reactivity/computed.spec.ts b/test/unit/features/composition-api/reactivity/computed.spec.ts
index afbbf8b2371..d4ca08939cc 100644
--- a/test/unit/features/composition-api/reactivity/computed.spec.ts
+++ b/test/unit/features/composition-api/reactivity/computed.spec.ts
@@ -131,7 +131,7 @@ describe('reactivity/computed', () => {
     expect(dummy).toBe(undefined)
     value.foo = 1
     expect(dummy).toBe(1)
-    cValue.effect.stop()
+    cValue.effect.teardown()
     value.foo = 2
     expect(dummy).toBe(1)
   })
@@ -221,7 +221,7 @@ describe('reactivity/computed', () => {
 
   it('should expose value when stopped', () => {
     const x = computed(() => 1)
-    x.effect.stop()
+    x.effect.teardown()
     expect(x.value).toBe(1)
   })
 

From eb20b8228f1a9010f0cf3ebfbe227a4eeb984223 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 26 May 2022 02:36:51 +0800
Subject: [PATCH 078/317] ci: fix ci

---
 .github/workflows/ci.yml | 5 +----
 scripts/config.js        | 3 ++-
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index caa2fdcd672..6d46c236f61 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -67,7 +67,7 @@ jobs:
       - name: Run transition tests
         run: pnpm run test:transition
 
-  lint-and-test-dts:
+  type-test:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -86,8 +86,5 @@ jobs:
       - name: Run srouce type check
         run: pnpm run ts-check
 
-      - name: Run eslint
-        run: pnpm run lint
-
       - name: Run type declaration tests
         run: pnpm run test:types
diff --git a/scripts/config.js b/scripts/config.js
index c2bc0d7bfa7..8cef33b66a4 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -238,7 +238,8 @@ function genConfig(name) {
 
   // built-in vars
   const vars = {
-    __VERSION__: version
+    __VERSION__: version,
+    __DEV__: `process.env.NODE_ENV !== 'production'`
   }
   // feature flags
   Object.keys(featureFlags).forEach(key => {

From b0140bfdabf3955a5b105f778253c5d8d87cc540 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 26 May 2022 02:39:58 +0800
Subject: [PATCH 079/317] ci: __DEV__ flag for e2e tests

---
 test/transition/karma.conf.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/transition/karma.conf.js b/test/transition/karma.conf.js
index f2e68c509da..e6f29d6113c 100644
--- a/test/transition/karma.conf.js
+++ b/test/transition/karma.conf.js
@@ -2,6 +2,7 @@ const featureFlags = require('../../scripts/feature-flags')
 process.env.CHROME_BIN = require('puppeteer').executablePath()
 
 const define = {
+  __DEV__: true,
   'process.env.CI': !!process.env.CI
 }
 

From a5ad708ccf43ae43e1feb44569928a92ec27a5f1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 10:45:28 +0800
Subject: [PATCH 080/317] wip: readonly

---
 src/composition-api/index.ts                  |  11 +-
 src/composition-api/reactivity/computed.ts    |  14 +-
 src/composition-api/reactivity/effect.ts      |   8 +-
 src/composition-api/reactivity/reactive.ts    |  52 +-
 src/composition-api/reactivity/readonly.ts    | 110 ++++
 src/composition-api/reactivity/ref.ts         |  30 +-
 src/core/observer/index.ts                    |  11 +-
 .../reactivity/readonly.spec.ts               | 502 ++++++++++++++++++
 .../reactivity/shallowReactive.spec.ts        |   0
 .../reactivity/shallowReadonly.spec.ts        |   0
 10 files changed, 709 insertions(+), 29 deletions(-)
 create mode 100644 src/composition-api/reactivity/readonly.ts
 create mode 100644 test/unit/features/composition-api/reactivity/readonly.spec.ts
 create mode 100644 test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
 create mode 100644 test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts

diff --git a/src/composition-api/index.ts b/src/composition-api/index.ts
index ad35f223066..0093e13b8ed 100644
--- a/src/composition-api/index.ts
+++ b/src/composition-api/index.ts
@@ -19,21 +19,20 @@ export {
 
 export {
   reactive,
-  // readonly,
   isReactive,
   isReadonly,
   isShallow,
-  // isProxy,
-  // shallowReactive,
-  // shallowReadonly,
+  isProxy,
+  shallowReactive,
   markRaw,
   toRaw,
   ReactiveFlags,
-  // DeepReadonly,
-  // ShallowReactive,
+  ShallowReactive,
   UnwrapNestedRefs
 } from './reactivity/reactive'
 
+export { readonly, shallowReadonly, DeepReadonly } from './reactivity/readonly'
+
 export {
   computed,
   ComputedRef,
diff --git a/src/composition-api/reactivity/computed.ts b/src/composition-api/reactivity/computed.ts
index 3d03fcea9d1..13d08e758cd 100644
--- a/src/composition-api/reactivity/computed.ts
+++ b/src/composition-api/reactivity/computed.ts
@@ -1,9 +1,10 @@
-import { isServerRendering, noop, warn } from 'core/util'
-import { Ref } from './ref'
+import { isServerRendering, noop, warn, def } from 'core/util'
+import { Ref, RefFlag } from './ref'
 import Watcher from 'core/observer/watcher'
 import Dep from 'core/observer/dep'
 import { currentInstance } from '../currentInstance'
 import { DebuggerOptions } from '../apiWatch'
+import { ReactiveFlags } from './reactive'
 
 declare const ComputedRefSymbol: unique symbol
 
@@ -57,9 +58,7 @@ export function computed<T>(
     ? null
     : new Watcher(currentInstance, getter, noop, { lazy: true })
 
-  return {
-    __v_isRef: true,
-    __v_isReadonly: onlyGetter,
+  const ref = {
     // some libs rely on the presence effect for checking computed refs
     // from normal refs, but the implementation doesn't matter
     effect: watcher,
@@ -80,4 +79,9 @@ export function computed<T>(
       setter(newVal)
     }
   } as any
+
+  def(ref, RefFlag, true)
+  def(ref, ReactiveFlags.IS_READONLY, true)
+
+  return ref
 }
diff --git a/src/composition-api/reactivity/effect.ts b/src/composition-api/reactivity/effect.ts
index 677d7b9da34..7bd8d7198ce 100644
--- a/src/composition-api/reactivity/effect.ts
+++ b/src/composition-api/reactivity/effect.ts
@@ -19,14 +19,18 @@ export type DebuggerEventExtraInfo = {
 }
 
 export class ReactiveEffect<T = any> {
+  // TODO
   onStop?: () => void
   // dev only
   onTrack?: (event: DebuggerEvent) => void
   // dev only
   onTrigger?: (event: DebuggerEvent) => void
 
-  public active = true
-  private _watcher: Watcher
+  active = true
+  /**
+   * @private
+   */
+  _watcher: Watcher
 
   constructor(
     public fn: () => T,
diff --git a/src/composition-api/reactivity/reactive.ts b/src/composition-api/reactivity/reactive.ts
index db0ce06af2b..b05156f93e1 100644
--- a/src/composition-api/reactivity/reactive.ts
+++ b/src/composition-api/reactivity/reactive.ts
@@ -1,5 +1,5 @@
 import { observe, Observer } from 'core/observer'
-import { def, isPrimitive, warn } from 'core/util'
+import { def, isPrimitive, warn, toRawType } from 'core/util'
 import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
 
 export const enum ReactiveFlags {
@@ -17,8 +17,6 @@ export interface Target {
   [ReactiveFlags.RAW]?: any
 }
 
-export declare const ShallowReactiveMarker: unique symbol
-
 // only unwrap nested ref
 export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>
 
@@ -27,14 +25,40 @@ export function reactive(target: object) {
   // if trying to observe a readonly proxy, return the readonly version.
   if (!isReadonly(target)) {
     const ob = observe(target)
-    if (__DEV__ && !ob && (target == null || isPrimitive(target))) {
-      warn(`value cannot be made reactive: ${String(target)}`)
+    if (__DEV__ && !ob) {
+      if (target == null || isPrimitive(target)) {
+        warn(`value cannot be made reactive: ${String(target)}`)
+      }
+      if (isCollectionType(target)) {
+        warn(
+          `Vue 2 does not support reactive collection types such as Map or Set.`
+        )
+      }
     }
   }
   return target
 }
 
+export declare const ShallowReactiveMarker: unique symbol
+
+export type ShallowReactive<T> = T & { [ShallowReactiveMarker]?: true }
+
+/**
+ * Return a shallowly-reactive copy of the original object, where only the root
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
+ * root level).
+ */
+export function shallowReactive<T extends object>(
+  target: T
+): ShallowReactive<T> {
+  // TODO
+  return target
+}
+
 export function isReactive(value: unknown): boolean {
+  if (isReadonly(value)) {
+    return isReactive((value as Target)[ReactiveFlags.RAW])
+  }
   return !!(value && (value as Target).__ob__)
 }
 
@@ -47,9 +71,13 @@ export function isReadonly(value: unknown): boolean {
   return !!(value && (value as Target).__v_isReadonly)
 }
 
+export function isProxy(value: unknown): boolean {
+  return isReactive(value) || isReadonly(value)
+}
+
 export function toRaw<T>(observed: T): T {
-  // TODO for readonly
-  return observed
+  const raw = observed && (observed as Target)[ReactiveFlags.RAW]
+  return raw ? toRaw(raw) : observed
 }
 
 export function markRaw<T extends object>(
@@ -58,3 +86,13 @@ export function markRaw<T extends object>(
   def(value, ReactiveFlags.SKIP, true)
   return value
 }
+
+/**
+ * @private
+ */
+export function isCollectionType(value: unknown): boolean {
+  const type = toRawType(value)
+  return (
+    type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet'
+  )
+}
diff --git a/src/composition-api/reactivity/readonly.ts b/src/composition-api/reactivity/readonly.ts
new file mode 100644
index 00000000000..7c176e63bc8
--- /dev/null
+++ b/src/composition-api/reactivity/readonly.ts
@@ -0,0 +1,110 @@
+import { def, warn, isPlainObject, isArray } from 'core/util'
+import {
+  isCollectionType,
+  isReadonly,
+  isShallow,
+  ReactiveFlags,
+  UnwrapNestedRefs
+} from './reactive'
+import { isRef, Ref, RefFlag } from './ref'
+
+type Primitive = string | number | boolean | bigint | symbol | undefined | null
+type Builtin = Primitive | Function | Date | Error | RegExp
+export type DeepReadonly<T> = T extends Builtin
+  ? T
+  : T extends Map<infer K, infer V>
+  ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
+  : T extends ReadonlyMap<infer K, infer V>
+  ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
+  : T extends WeakMap<infer K, infer V>
+  ? WeakMap<DeepReadonly<K>, DeepReadonly<V>>
+  : T extends Set<infer U>
+  ? ReadonlySet<DeepReadonly<U>>
+  : T extends ReadonlySet<infer U>
+  ? ReadonlySet<DeepReadonly<U>>
+  : T extends WeakSet<infer U>
+  ? WeakSet<DeepReadonly<U>>
+  : T extends Promise<infer U>
+  ? Promise<DeepReadonly<U>>
+  : T extends Ref<infer U>
+  ? Readonly<Ref<DeepReadonly<U>>>
+  : T extends {}
+  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+  : Readonly<T>
+
+const rawToReadonlyFlag = `__v_rawToReadonly`
+
+export function readonly<T extends object>(
+  target: T
+): DeepReadonly<UnwrapNestedRefs<T>> {
+  if (!isPlainObject(target)) {
+    if (__DEV__) {
+      if (isArray(target)) {
+        warn(`Vue 2 does not support readonly arrays.`)
+      } else if (isCollectionType(target)) {
+        warn(
+          `Vue 2 does not support readonly collection types such as Map or Set.`
+        )
+      } else {
+        warn(`value cannot be made readonly: ${typeof target}`)
+      }
+    }
+    return target as any
+  }
+
+  // already a readonly object
+  if (isReadonly(target)) {
+    return target as any
+  }
+
+  // already has a readonly proxy
+  const existingProxy = target[rawToReadonlyFlag]
+  if (existingProxy) {
+    return existingProxy
+  }
+
+  const proxy = {}
+  def(target, rawToReadonlyFlag, proxy)
+
+  def(proxy, ReactiveFlags.IS_READONLY, true)
+  def(proxy, ReactiveFlags.RAW, target)
+
+  if (isRef(target)) {
+    def(proxy, RefFlag, true)
+  }
+  if (isShallow(target)) {
+    def(proxy, ReactiveFlags.IS_SHALLOW, true)
+  }
+
+  const keys = Object.keys(target)
+  for (let i = 0; i < keys.length; i++) {
+    defineReadonlyProperty(proxy, target, keys[i])
+  }
+
+  return proxy as any
+}
+
+function defineReadonlyProperty(proxy: any, target: any, key: string) {
+  Object.defineProperty(proxy, key, {
+    enumerable: true,
+    configurable: true,
+    get() {
+      const val = target[key]
+      return isPlainObject(val) ? readonly(val) : val
+    },
+    set() {
+      __DEV__ &&
+        warn(`Set operation on key "${key}" failed: target is readonly.`)
+    }
+  })
+}
+
+/**
+ * Returns a reactive-copy of the original object, where only the root level
+ * properties are readonly, and does NOT unwrap refs nor recursively convert
+ * returned properties.
+ * This is used for creating the props proxy object for stateful components.
+ */
+export function shallowReadonly<T extends object>(target: T): Readonly<T> {
+  return target as any
+}
diff --git a/src/composition-api/reactivity/ref.ts b/src/composition-api/reactivity/ref.ts
index bf097ec2e91..71cabb3d066 100644
--- a/src/composition-api/reactivity/ref.ts
+++ b/src/composition-api/reactivity/ref.ts
@@ -1,12 +1,18 @@
 import { defineReactive } from 'core/observer/index'
-import { isReactive, type ShallowReactiveMarker } from './reactive'
+import {
+  isReactive,
+  ReactiveFlags,
+  type ShallowReactiveMarker
+} from './reactive'
 import type { IfAny } from 'typescript/utils'
 import Dep from 'core/observer/dep'
-import { warn, isArray } from 'core/util'
+import { warn, isArray, def } from 'core/util'
 
 declare const RefSymbol: unique symbol
 export declare const RawSymbol: unique symbol
 
+export const RefFlag = `__v_isRef`
+
 export interface Ref<T = any> {
   value: T
   /**
@@ -19,11 +25,15 @@ export interface Ref<T = any> {
    * @private
    */
   dep?: Dep
+  /**
+   * @private
+   */
+  [RefFlag]: true
 }
 
 export function isRef<T>(r: Ref<T> | unknown): r is Ref<T>
 export function isRef(r: any): r is Ref {
-  return !!(r && r.__v_isRef === true)
+  return !!(r && (r as Ref).__v_isRef === true)
 }
 
 export function ref<T extends object>(
@@ -52,7 +62,9 @@ function createRef(rawValue: unknown, shallow: boolean) {
   if (isRef(rawValue)) {
     return rawValue
   }
-  const ref: any = { __v_isRef: true, __v_isShallow: shallow }
+  const ref: any = {}
+  def(ref, RefFlag, true)
+  def(ref, ReactiveFlags.IS_SHALLOW, true)
   ref.dep = defineReactive(ref, 'value', rawValue, null, shallow)
   return ref
 }
@@ -82,8 +94,7 @@ export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
     () => dep.depend(),
     () => dep.notify()
   )
-  return {
-    __v_isRef: true,
+  const ref = {
     get value() {
       return get()
     },
@@ -91,6 +102,8 @@ export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
       set(newVal)
     }
   } as any
+  def(ref, RefFlag, true)
+  return ref
 }
 
 export type ToRefs<T = any> = {
@@ -130,8 +143,7 @@ export function toRef<T extends object, K extends keyof T>(
   if (isRef(val)) {
     return val as any
   }
-  return {
-    __v_isRef: true,
+  const ref = {
     get value() {
       const val = object[key]
       return val === undefined ? (defaultValue as T[K]) : val
@@ -140,6 +152,8 @@ export function toRef<T extends object, K extends keyof T>(
       object[key] = newVal
     }
   } as any
+  def(ref, RefFlag, true)
+  return ref
 }
 
 /**
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 7f688d42391..9e23ecaee58 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -15,7 +15,7 @@ import {
   isServerRendering,
   hasChanged
 } from '../util/index'
-import { isRef } from '../../composition-api'
+import { isReadonly, isRef } from '../../composition-api'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
@@ -212,6 +212,10 @@ export function set(
       `Cannot set reactive property on undefined, null, or primitive value: ${target}`
     )
   }
+  if (isReadonly(target)) {
+    __DEV__ && warn(`Set operation on key "${key}" failed: target is readonly.`)
+    return
+  }
   if (isArray(target) && isValidArrayIndex(key)) {
     target.length = Math.max(target.length, key)
     target.splice(key, 1, val)
@@ -261,6 +265,11 @@ export function del(target: Array<any> | Object, key: any) {
       )
     return
   }
+  if (isReadonly(target)) {
+    __DEV__ &&
+      warn(`Delete operation on key "${key}" failed: target is readonly.`)
+    return
+  }
   if (!hasOwn(target, key)) {
     return
   }
diff --git a/test/unit/features/composition-api/reactivity/readonly.spec.ts b/test/unit/features/composition-api/reactivity/readonly.spec.ts
new file mode 100644
index 00000000000..d413dc043af
--- /dev/null
+++ b/test/unit/features/composition-api/reactivity/readonly.spec.ts
@@ -0,0 +1,502 @@
+import {
+  reactive,
+  readonly,
+  toRaw,
+  isReactive,
+  isReadonly,
+  markRaw,
+  ref,
+  isProxy
+} from 'vca/index'
+import { effect } from 'vca/reactivity/effect'
+import { set, del } from 'core/observer'
+
+/**
+ * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html
+ */
+type Writable<T> = { -readonly [P in keyof T]: T[P] }
+
+describe('reactivity/readonly', () => {
+  describe('Object', () => {
+    it('should make nested values readonly', () => {
+      const original = { foo: 1, bar: { baz: 2 } }
+      const wrapped = readonly(original)
+      expect(wrapped).not.toBe(original)
+      expect(isProxy(wrapped)).toBe(true)
+      expect(isReactive(wrapped)).toBe(false)
+      expect(isReadonly(wrapped)).toBe(true)
+      expect(isReactive(original)).toBe(false)
+      expect(isReadonly(original)).toBe(false)
+      expect(isReactive(wrapped.bar)).toBe(false)
+      expect(isReadonly(wrapped.bar)).toBe(true)
+      expect(isReactive(original.bar)).toBe(false)
+      expect(isReadonly(original.bar)).toBe(false)
+      // get
+      expect(wrapped.foo).toBe(1)
+      // has
+      expect('foo' in wrapped).toBe(true)
+      // ownKeys
+      expect(Object.keys(wrapped)).toEqual(['foo', 'bar'])
+    })
+
+    it('should not allow mutation', () => {
+      const qux = Symbol('qux')
+      const original = {
+        foo: 1,
+        bar: {
+          baz: 2
+        },
+        [qux]: 3
+      }
+      const wrapped: Writable<typeof original> = readonly(original)
+
+      wrapped.foo = 2
+      expect(wrapped.foo).toBe(1)
+      expect(
+        `Set operation on key "foo" failed: target is readonly.`
+      ).toHaveBeenWarnedLast()
+
+      set(wrapped.bar, `baz`, 3)
+      expect(wrapped.bar.baz).toBe(2)
+      expect(
+        `Set operation on key "baz" failed: target is readonly.`
+      ).toHaveBeenWarnedLast()
+
+      // @discrepancy: Vue 2 reactive system does not handle symbol keys.
+      // wrapped[qux] = 4
+      // expect(wrapped[qux]).toBe(3)
+      // expect(
+      //   `Set operation on key "Symbol(qux)" failed: target is readonly.`
+      // ).toHaveBeenWarnedLast()
+
+      del(wrapped, `foo`)
+      expect(wrapped.foo).toBe(1)
+      expect(
+        `Delete operation on key "foo" failed: target is readonly.`
+      ).toHaveBeenWarnedLast()
+
+      del(wrapped.bar, `baz`)
+      expect(wrapped.bar.baz).toBe(2)
+      expect(
+        `Delete operation on key "baz" failed: target is readonly.`
+      ).toHaveBeenWarnedLast()
+
+      // // @ts-expect-error
+      // delete wrapped[qux]
+      // expect(wrapped[qux]).toBe(3)
+      // expect(
+      //   `Delete operation on key "Symbol(qux)" failed: target is readonly.`
+      // ).toHaveBeenWarnedLast()
+    })
+
+    it('should not trigger effects', () => {
+      const wrapped: any = readonly({ a: 1 })
+      let dummy
+      effect(() => {
+        dummy = wrapped.a
+      })
+      expect(dummy).toBe(1)
+      wrapped.a = 2
+      expect(wrapped.a).toBe(1)
+      expect(dummy).toBe(1)
+      expect(`target is readonly`).toHaveBeenWarned()
+    })
+  })
+
+  // @discrepancy Vue 2 cannot support readonly array
+  // describe('Array', () => {
+  //   it('should make nested values readonly', () => {
+  //     const original = [{ foo: 1 }]
+  //     const wrapped = readonly(original)
+  //     expect(wrapped).not.toBe(original)
+  //     expect(isProxy(wrapped)).toBe(true)
+  //     expect(isReactive(wrapped)).toBe(false)
+  //     expect(isReadonly(wrapped)).toBe(true)
+  //     expect(isReactive(original)).toBe(false)
+  //     expect(isReadonly(original)).toBe(false)
+  //     expect(isReactive(wrapped[0])).toBe(false)
+  //     expect(isReadonly(wrapped[0])).toBe(true)
+  //     expect(isReactive(original[0])).toBe(false)
+  //     expect(isReadonly(original[0])).toBe(false)
+  //     // get
+  //     expect(wrapped[0].foo).toBe(1)
+  //     // has
+  //     expect(0 in wrapped).toBe(true)
+  //     // ownKeys
+  //     expect(Object.keys(wrapped)).toEqual(['0'])
+  //   })
+
+  //   it('should not allow mutation', () => {
+  //     const wrapped: any = readonly([{ foo: 1 }])
+  //     wrapped[0] = 1
+  //     expect(wrapped[0]).not.toBe(1)
+  //     expect(
+  //       `Set operation on key "0" failed: target is readonly.`
+  //     ).toHaveBeenWarned()
+  //     wrapped[0].foo = 2
+  //     expect(wrapped[0].foo).toBe(1)
+  //     expect(
+  //       `Set operation on key "foo" failed: target is readonly.`
+  //     ).toHaveBeenWarned()
+
+  //     // should block length mutation
+  //     wrapped.length = 0
+  //     expect(wrapped.length).toBe(1)
+  //     expect(wrapped[0].foo).toBe(1)
+  //     expect(
+  //       `Set operation on key "length" failed: target is readonly.`
+  //     ).toHaveBeenWarned()
+
+  //     // mutation methods invoke set/length internally and thus are blocked as well
+  //     wrapped.push(2)
+  //     expect(wrapped.length).toBe(1)
+  //     // push triggers two warnings on [1] and .length
+  //     expect(`target is readonly.`).toHaveBeenWarnedTimes(5)
+  //   })
+
+  //   it('should not trigger effects', () => {
+  //     const wrapped: any = readonly([{ a: 1 }])
+  //     let dummy
+  //     effect(() => {
+  //       dummy = wrapped[0].a
+  //     })
+  //     expect(dummy).toBe(1)
+  //     wrapped[0].a = 2
+  //     expect(wrapped[0].a).toBe(1)
+  //     expect(dummy).toBe(1)
+  //     expect(`target is readonly`).toHaveBeenWarnedTimes(1)
+  //     wrapped[0] = { a: 2 }
+  //     expect(wrapped[0].a).toBe(1)
+  //     expect(dummy).toBe(1)
+  //     expect(`target is readonly`).toHaveBeenWarnedTimes(2)
+  //   })
+  // })
+
+  // @discrepancy: Vue 2 doesn't support readonly on collection types
+  // const maps = [Map, WeakMap]
+  // maps.forEach((Collection: any) => {
+  //   describe(Collection.name, () => {
+  //     test('should make nested values readonly', () => {
+  //       const key1 = {}
+  //       const key2 = {}
+  //       const original = new Collection([
+  //         [key1, {}],
+  //         [key2, {}]
+  //       ])
+  //       const wrapped = readonly(original)
+  //       expect(wrapped).not.toBe(original)
+  //       expect(isProxy(wrapped)).toBe(true)
+  //       expect(isReactive(wrapped)).toBe(false)
+  //       expect(isReadonly(wrapped)).toBe(true)
+  //       expect(isReactive(original)).toBe(false)
+  //       expect(isReadonly(original)).toBe(false)
+  //       expect(isReactive(wrapped.get(key1))).toBe(false)
+  //       expect(isReadonly(wrapped.get(key1))).toBe(true)
+  //       expect(isReactive(original.get(key1))).toBe(false)
+  //       expect(isReadonly(original.get(key1))).toBe(false)
+  //     })
+
+  //     test('should not allow mutation & not trigger effect', () => {
+  //       const map = readonly(new Collection())
+  //       const key = {}
+  //       let dummy
+  //       effect(() => {
+  //         dummy = map.get(key)
+  //       })
+  //       expect(dummy).toBeUndefined()
+  //       map.set(key, 1)
+  //       expect(dummy).toBeUndefined()
+  //       expect(map.has(key)).toBe(false)
+  //       expect(
+  //         `Set operation on key "${key}" failed: target is readonly.`
+  //       ).toHaveBeenWarned()
+  //     })
+
+  //     // #1772
+  //     test('readonly + reactive should make get() value also readonly + reactive', () => {
+  //       const map = reactive(new Collection())
+  //       const roMap = readonly(map)
+  //       const key = {}
+  //       map.set(key, {})
+
+  //       const item = map.get(key)
+  //       expect(isReactive(item)).toBe(true)
+  //       expect(isReadonly(item)).toBe(false)
+
+  //       const roItem = roMap.get(key)
+  //       expect(isReactive(roItem)).toBe(true)
+  //       expect(isReadonly(roItem)).toBe(true)
+  //     })
+
+  //     if (Collection === Map) {
+  //       test('should retrieve readonly values on iteration', () => {
+  //         const key1 = {}
+  //         const key2 = {}
+  //         const original = new Map([
+  //           [key1, {}],
+  //           [key2, {}]
+  //         ])
+  //         const wrapped: any = readonly(original)
+  //         expect(wrapped.size).toBe(2)
+  //         for (const [key, value] of wrapped) {
+  //           expect(isReadonly(key)).toBe(true)
+  //           expect(isReadonly(value)).toBe(true)
+  //         }
+  //         wrapped.forEach((value: any) => {
+  //           expect(isReadonly(value)).toBe(true)
+  //         })
+  //         for (const value of wrapped.values()) {
+  //           expect(isReadonly(value)).toBe(true)
+  //         }
+  //       })
+
+  //       test('should retrieve reactive + readonly values on iteration', () => {
+  //         const key1 = {}
+  //         const key2 = {}
+  //         const original = reactive(
+  //           new Map([
+  //             [key1, {}],
+  //             [key2, {}]
+  //           ])
+  //         )
+  //         const wrapped: any = readonly(original)
+  //         expect(wrapped.size).toBe(2)
+  //         for (const [key, value] of wrapped) {
+  //           expect(isReadonly(key)).toBe(true)
+  //           expect(isReadonly(value)).toBe(true)
+  //           expect(isReactive(key)).toBe(true)
+  //           expect(isReactive(value)).toBe(true)
+  //         }
+  //         wrapped.forEach((value: any) => {
+  //           expect(isReadonly(value)).toBe(true)
+  //           expect(isReactive(value)).toBe(true)
+  //         })
+  //         for (const value of wrapped.values()) {
+  //           expect(isReadonly(value)).toBe(true)
+  //           expect(isReactive(value)).toBe(true)
+  //         }
+  //       })
+  //     }
+  //   })
+  // })
+
+  // const sets = [Set, WeakSet]
+  // sets.forEach((Collection: any) => {
+  //   describe(Collection.name, () => {
+  //     test('should make nested values readonly', () => {
+  //       const key1 = {}
+  //       const key2 = {}
+  //       const original = new Collection([key1, key2])
+  //       const wrapped = readonly(original)
+  //       expect(wrapped).not.toBe(original)
+  //       expect(isProxy(wrapped)).toBe(true)
+  //       expect(isReactive(wrapped)).toBe(false)
+  //       expect(isReadonly(wrapped)).toBe(true)
+  //       expect(isReactive(original)).toBe(false)
+  //       expect(isReadonly(original)).toBe(false)
+  //       expect(wrapped.has(reactive(key1))).toBe(true)
+  //       expect(original.has(reactive(key1))).toBe(false)
+  //     })
+
+  //     test('should not allow mutation & not trigger effect', () => {
+  //       const set = readonly(new Collection())
+  //       const key = {}
+  //       let dummy
+  //       effect(() => {
+  //         dummy = set.has(key)
+  //       })
+  //       expect(dummy).toBe(false)
+  //       set.add(key)
+  //       expect(dummy).toBe(false)
+  //       expect(set.has(key)).toBe(false)
+  //       expect(
+  //         `Add operation on key "${key}" failed: target is readonly.`
+  //       ).toHaveBeenWarned()
+  //     })
+
+  //     if (Collection === Set) {
+  //       test('should retrieve readonly values on iteration', () => {
+  //         const original = new Collection([{}, {}])
+  //         const wrapped: any = readonly(original)
+  //         expect(wrapped.size).toBe(2)
+  //         for (const value of wrapped) {
+  //           expect(isReadonly(value)).toBe(true)
+  //         }
+  //         wrapped.forEach((value: any) => {
+  //           expect(isReadonly(value)).toBe(true)
+  //         })
+  //         for (const value of wrapped.values()) {
+  //           expect(isReadonly(value)).toBe(true)
+  //         }
+  //         for (const [v1, v2] of wrapped.entries()) {
+  //           expect(isReadonly(v1)).toBe(true)
+  //           expect(isReadonly(v2)).toBe(true)
+  //         }
+  //       })
+  //     }
+  //   })
+  // })
+
+  test('calling reactive on an readonly should return readonly', () => {
+    const a = readonly({})
+    const b = reactive(a)
+    expect(isReadonly(b)).toBe(true)
+    // should point to same original
+    expect(toRaw(a)).toBe(toRaw(b))
+  })
+
+  test('calling readonly on a reactive object should return readonly', () => {
+    const a = reactive({})
+    const b = readonly(a)
+    expect(isReadonly(b)).toBe(true)
+    // should point to same original
+    expect(toRaw(a)).toBe(toRaw(b))
+  })
+
+  test('readonly should track and trigger if wrapping reactive original', () => {
+    const a = reactive({ n: 1 })
+    const b = readonly(a)
+    // should return true since it's wrapping a reactive source
+    expect(isReactive(b)).toBe(true)
+
+    let dummy
+    effect(() => {
+      dummy = b.n
+    })
+    expect(dummy).toBe(1)
+    a.n++
+    expect(b.n).toBe(2)
+    expect(dummy).toBe(2)
+  })
+
+  // test('readonly collection should not track', () => {
+  //   const map = new Map()
+  //   map.set('foo', 1)
+
+  //   const reMap = reactive(map)
+  //   const roMap = readonly(map)
+
+  //   let dummy
+  //   effect(() => {
+  //     dummy = roMap.get('foo')
+  //   })
+  //   expect(dummy).toBe(1)
+  //   reMap.set('foo', 2)
+  //   expect(roMap.get('foo')).toBe(2)
+  //   // should not trigger
+  //   expect(dummy).toBe(1)
+  // })
+
+  // test('readonly array should not track', () => {
+  //   const arr = [1]
+  //   const roArr = readonly(arr)
+
+  //   const eff = effect(() => {
+  //     roArr.includes(2)
+  //   })
+  //   expect(eff._watcher.deps.length).toBe(0)
+  // })
+
+  // test('readonly should track and trigger if wrapping reactive original (collection)', () => {
+  //   const a = reactive(new Map())
+  //   const b = readonly(a)
+  //   // should return true since it's wrapping a reactive source
+  //   expect(isReactive(b)).toBe(true)
+
+  //   a.set('foo', 1)
+
+  //   let dummy
+  //   effect(() => {
+  //     dummy = b.get('foo')
+  //   })
+  //   expect(dummy).toBe(1)
+  //   a.set('foo', 2)
+  //   expect(b.get('foo')).toBe(2)
+  //   expect(dummy).toBe(2)
+  // })
+
+  test('wrapping already wrapped value should return same Proxy', () => {
+    const original = { foo: 1 }
+    const wrapped = readonly(original)
+    const wrapped2 = readonly(wrapped)
+    expect(wrapped2).toBe(wrapped)
+  })
+
+  test('wrapping the same value multiple times should return same Proxy', () => {
+    const original = { foo: 1 }
+    const wrapped = readonly(original)
+    const wrapped2 = readonly(original)
+    expect(wrapped2).toBe(wrapped)
+  })
+
+  test('markRaw', () => {
+    const obj = readonly({
+      foo: { a: 1 },
+      bar: markRaw({ b: 2 })
+    })
+    expect(isReadonly(obj.foo)).toBe(true)
+    expect(isReactive(obj.bar)).toBe(false)
+  })
+
+  test('should make ref readonly', () => {
+    const n = readonly(ref(1))
+    // @ts-expect-error
+    n.value = 2
+    expect(n.value).toBe(1)
+    expect(
+      `Set operation on key "value" failed: target is readonly.`
+    ).toHaveBeenWarned()
+  })
+
+  // Test case not applicable to Vue 2
+  // https://github.com/vuejs/core/issues/3376
+  // test('calling readonly on computed should allow computed to set its private properties', () => {
+  //   const r = ref<boolean>(false)
+  //   const c = computed(() => r.value)
+  //   const rC = readonly(c)
+
+  //   r.value = true
+
+  //   expect(rC.value).toBe(true)
+  //   expect(
+  //     'Set operation on key "_dirty" failed: target is readonly.'
+  //   ).not.toHaveBeenWarned()
+  //   // @ts-expect-error - non-existent property
+  //   rC.randomProperty = true
+
+  //   expect(
+  //     'Set operation on key "randomProperty" failed: target is readonly.'
+  //   ).toHaveBeenWarned()
+  // })
+
+  // #4986
+  test('setting a readonly object as a property of a reactive object should retain readonly proxy', () => {
+    const r = readonly({})
+    const rr = reactive({}) as any
+    rr.foo = r
+    expect(rr.foo).toBe(r)
+    expect(isReadonly(rr.foo)).toBe(true)
+  })
+
+  test('attempting to write plain value to a readonly ref nested in a reactive object should fail', () => {
+    const r = ref(false)
+    const ror = readonly(r)
+    const obj = reactive({ ror })
+    obj.ror = true
+
+    expect(obj.ror).toBe(false)
+    expect(`Set operation on key "value" failed`).toHaveBeenWarned()
+  })
+
+  test('replacing a readonly ref nested in a reactive object with a new ref', () => {
+    const r = ref(false)
+    const ror = readonly(r)
+    const obj = reactive({ ror })
+    try {
+      obj.ror = ref(true) as unknown as boolean
+    } catch (e) {}
+
+    expect(obj.ror).toBe(true)
+    expect(toRaw(obj).ror).not.toBe(ror) // ref successfully replaced
+  })
+})
diff --git a/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts b/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts b/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts
new file mode 100644
index 00000000000..e69de29bb2d

From f29ad1def5f923836254e7ff4e29fe83db83055f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 12:07:19 +0800
Subject: [PATCH 081/317] wip: shallowReactive/shallowReadonly

---
 src/composition-api/reactivity/computed.ts    |   2 +-
 src/composition-api/reactivity/reactive.ts    |  58 +++--
 src/composition-api/reactivity/readonly.ts    |  25 ++-
 src/core/instance/state.ts                    |   4 +-
 src/core/observer/index.ts                    |  23 +-
 .../composition-api/reactivity/ref.spec.ts    |   2 +-
 .../reactivity/shallowReactive.spec.ts        | 169 ++++++++++++++
 .../reactivity/shallowReadonly.spec.ts        | 206 ++++++++++++++++++
 8 files changed, 450 insertions(+), 39 deletions(-)

diff --git a/src/composition-api/reactivity/computed.ts b/src/composition-api/reactivity/computed.ts
index 13d08e758cd..a74655c63a6 100644
--- a/src/composition-api/reactivity/computed.ts
+++ b/src/composition-api/reactivity/computed.ts
@@ -81,7 +81,7 @@ export function computed<T>(
   } as any
 
   def(ref, RefFlag, true)
-  def(ref, ReactiveFlags.IS_READONLY, true)
+  def(ref, ReactiveFlags.IS_READONLY, onlyGetter)
 
   return ref
 }
diff --git a/src/composition-api/reactivity/reactive.ts b/src/composition-api/reactivity/reactive.ts
index b05156f93e1..ed79cfda032 100644
--- a/src/composition-api/reactivity/reactive.ts
+++ b/src/composition-api/reactivity/reactive.ts
@@ -1,5 +1,5 @@
 import { observe, Observer } from 'core/observer'
-import { def, isPrimitive, warn, toRawType } from 'core/util'
+import { def, isArray, isPrimitive, warn, toRawType } from 'core/util'
 import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
 
 export const enum ReactiveFlags {
@@ -22,20 +22,7 @@ export type UnwrapNestedRefs<T> = T extends Ref ? T : UnwrapRefSimple<T>
 
 export function reactive<T extends object>(target: T): UnwrapNestedRefs<T>
 export function reactive(target: object) {
-  // if trying to observe a readonly proxy, return the readonly version.
-  if (!isReadonly(target)) {
-    const ob = observe(target)
-    if (__DEV__ && !ob) {
-      if (target == null || isPrimitive(target)) {
-        warn(`value cannot be made reactive: ${String(target)}`)
-      }
-      if (isCollectionType(target)) {
-        warn(
-          `Vue 2 does not support reactive collection types such as Map or Set.`
-        )
-      }
-    }
-  }
+  makeReactive(target, false)
   return target
 }
 
@@ -51,10 +38,49 @@ export type ShallowReactive<T> = T & { [ShallowReactiveMarker]?: true }
 export function shallowReactive<T extends object>(
   target: T
 ): ShallowReactive<T> {
-  // TODO
+  makeReactive(target, true)
+  def(target, ReactiveFlags.IS_SHALLOW, true)
   return target
 }
 
+function makeReactive(target: any, shallow: boolean) {
+  // if trying to observe a readonly proxy, return the readonly version.
+  if (!isReadonly(target)) {
+    if (__DEV__) {
+      if (isArray(target)) {
+        warn(
+          `Avoid using Array as root value for ${
+            shallow ? `shallowReactive()` : `reactive()`
+          } as it cannot be tracked in watch() or watchEffect(). Use ${
+            shallow ? `shallowRef()` : `ref()`
+          } instead. This is a Vue-2-only limitation.`
+        )
+      }
+      const existingOb = target && target.__ob__
+      if (existingOb && existingOb.shallow !== shallow) {
+        warn(
+          `Target is already a ${
+            existingOb.shallow ? `` : `non-`
+          }shallow reactive object, and cannot be converted to ${
+            shallow ? `` : `non-`
+          }shallow.`
+        )
+      }
+    }
+    const ob = observe(target, shallow)
+    if (__DEV__ && !ob) {
+      if (target == null || isPrimitive(target)) {
+        warn(`value cannot be made reactive: ${String(target)}`)
+      }
+      if (isCollectionType(target)) {
+        warn(
+          `Vue 2 does not support reactive collection types such as Map or Set.`
+        )
+      }
+    }
+  }
+}
+
 export function isReactive(value: unknown): boolean {
   if (isReadonly(value)) {
     return isReactive((value as Target)[ReactiveFlags.RAW])
diff --git a/src/composition-api/reactivity/readonly.ts b/src/composition-api/reactivity/readonly.ts
index 7c176e63bc8..19179e02bba 100644
--- a/src/composition-api/reactivity/readonly.ts
+++ b/src/composition-api/reactivity/readonly.ts
@@ -33,10 +33,15 @@ export type DeepReadonly<T> = T extends Builtin
   : Readonly<T>
 
 const rawToReadonlyFlag = `__v_rawToReadonly`
+const rawToShallowReadonlyFlag = `__v_rawToShallowReadonly`
 
 export function readonly<T extends object>(
   target: T
 ): DeepReadonly<UnwrapNestedRefs<T>> {
+  return createReadonly(target, false)
+}
+
+function createReadonly(target: any, shallow: boolean) {
   if (!isPlainObject(target)) {
     if (__DEV__) {
       if (isArray(target)) {
@@ -58,13 +63,14 @@ export function readonly<T extends object>(
   }
 
   // already has a readonly proxy
-  const existingProxy = target[rawToReadonlyFlag]
+  const existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag
+  const existingProxy = target[existingFlag]
   if (existingProxy) {
     return existingProxy
   }
 
   const proxy = {}
-  def(target, rawToReadonlyFlag, proxy)
+  def(target, existingFlag, proxy)
 
   def(proxy, ReactiveFlags.IS_READONLY, true)
   def(proxy, ReactiveFlags.RAW, target)
@@ -72,25 +78,30 @@ export function readonly<T extends object>(
   if (isRef(target)) {
     def(proxy, RefFlag, true)
   }
-  if (isShallow(target)) {
+  if (shallow || isShallow(target)) {
     def(proxy, ReactiveFlags.IS_SHALLOW, true)
   }
 
   const keys = Object.keys(target)
   for (let i = 0; i < keys.length; i++) {
-    defineReadonlyProperty(proxy, target, keys[i])
+    defineReadonlyProperty(proxy, target, keys[i], shallow)
   }
 
   return proxy as any
 }
 
-function defineReadonlyProperty(proxy: any, target: any, key: string) {
+function defineReadonlyProperty(
+  proxy: any,
+  target: any,
+  key: string,
+  shallow: boolean
+) {
   Object.defineProperty(proxy, key, {
     enumerable: true,
     configurable: true,
     get() {
       const val = target[key]
-      return isPlainObject(val) ? readonly(val) : val
+      return shallow || !isPlainObject(val) ? val : readonly(val)
     },
     set() {
       __DEV__ &&
@@ -106,5 +117,5 @@ function defineReadonlyProperty(proxy: any, target: any, key: string) {
  * This is used for creating the props proxy object for stateful components.
  */
 export function shallowReadonly<T extends object>(target: T): Readonly<T> {
-  return target as any
+  return createReadonly(target, true)
 }
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 6abfef2516e..40fc32663b4 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -54,7 +54,7 @@ export function initState(vm: Component) {
   if (opts.data) {
     initData(vm)
   } else {
-    observe((vm._data = {}), true /* asRootData */)
+    observe((vm._data = {}))!.vmCount++
   }
   if (opts.computed) initComputed(vm, opts.computed)
   if (opts.watch && opts.watch !== nativeWatch) {
@@ -148,7 +148,7 @@ function initData(vm: Component) {
     }
   }
   // observe data
-  observe(data, true /* asRootData */)
+  observe(data)!.vmCount++
 }
 
 export function getData(data: Function, vm: Component): any {
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 9e23ecaee58..7ba9e0877dd 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -36,12 +36,11 @@ export function toggleObserving(value: boolean) {
  * collect dependencies and dispatch updates.
  */
 export class Observer {
-  value: any
   dep: Dep
   vmCount: number // number of vms that have this object as root $data
 
-  constructor(value: any) {
-    this.value = value
+  constructor(public value: any, public shallow = false) {
+    // this.value = value
     this.dep = new Dep()
     this.vmCount = 0
     def(value, '__ob__', this)
@@ -51,9 +50,11 @@ export class Observer {
       } else {
         copyAugment(value, arrayMethods, arrayKeys)
       }
-      this.observeArray(value)
+      if (!shallow) {
+        this.observeArray(value)
+      }
     } else {
-      this.walk(value)
+      this.walk(value, shallow)
     }
   }
 
@@ -62,10 +63,11 @@ export class Observer {
    * getter/setters. This method should only be called when
    * value type is Object.
    */
-  walk(obj: object) {
+  walk(obj: object, shallow: boolean) {
     const keys = Object.keys(obj)
     for (let i = 0; i < keys.length; i++) {
-      defineReactive(obj, keys[i])
+      const key = keys[i]
+      defineReactive(obj, key, obj[key], undefined, shallow)
     }
   }
 
@@ -108,7 +110,7 @@ function copyAugment(target: Object, src: Object, keys: Array<string>) {
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-export function observe(value: any, asRootData?: boolean): Observer | void {
+export function observe(value: any, shallow?: boolean): Observer | void {
   if (!isObject(value) || isRef(value) || value instanceof VNode) {
     return
   }
@@ -122,10 +124,7 @@ export function observe(value: any, asRootData?: boolean): Observer | void {
     Object.isExtensible(value) &&
     !value.__v_skip
   ) {
-    ob = new Observer(value)
-  }
-  if (asRootData && ob) {
-    ob.vmCount++
+    ob = new Observer(value, shallow)
   }
   return ob
 }
diff --git a/test/unit/features/composition-api/reactivity/ref.spec.ts b/test/unit/features/composition-api/reactivity/ref.spec.ts
index 376e8cffc74..720e6e812b6 100644
--- a/test/unit/features/composition-api/reactivity/ref.spec.ts
+++ b/test/unit/features/composition-api/reactivity/ref.spec.ts
@@ -341,7 +341,7 @@ describe('reactivity/ref', () => {
   })
 
   test('toRefs reactive array', () => {
-    const arr = reactive(['a', 'b', 'c'])
+    const { arr } = reactive({ arr: ['a', 'b', 'c'] })
     const refs = toRefs(arr)
 
     expect(Array.isArray(refs)).toBe(true)
diff --git a/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts b/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
index e69de29bb2d..d4c4619878e 100644
--- a/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
+++ b/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
@@ -0,0 +1,169 @@
+import {
+  isReactive,
+  isShallow,
+  reactive,
+  shallowReactive,
+  shallowReadonly
+} from 'vca/index'
+
+describe('shallowReactive', () => {
+  test('should not make non-reactive properties reactive', () => {
+    const props = shallowReactive({ n: { foo: 1 } })
+    expect(isReactive(props.n)).toBe(false)
+  })
+
+  test('should keep reactive properties reactive', () => {
+    const props: any = shallowReactive({ n: reactive({ foo: 1 }) })
+    props.n = reactive({ foo: 2 })
+    expect(isReactive(props.n)).toBe(true)
+  })
+
+  test('isShallow', () => {
+    expect(isShallow(shallowReactive({}))).toBe(true)
+    expect(isShallow(shallowReadonly({}))).toBe(true)
+  })
+
+  // #5271
+  test('should respect shallow reactive nested inside reactive on reset', () => {
+    const r = reactive({ foo: shallowReactive({ bar: {} }) })
+    expect(isShallow(r.foo)).toBe(true)
+    expect(isReactive(r.foo.bar)).toBe(false)
+
+    r.foo = shallowReactive({ bar: {} })
+    expect(isShallow(r.foo)).toBe(true)
+    expect(isReactive(r.foo.bar)).toBe(false)
+  })
+
+  // @discrepancy no shallow/non-shallow versions from the same source -
+  // cannot support this without real proxies
+  // #2843
+  // test('should allow shallow and normal reactive for same target', () => {
+  //   const original = { foo: {} }
+  //   const shallowProxy = shallowReactive(original)
+  //   const reactiveProxy = reactive(original)
+  //   expect(shallowProxy).not.toBe(reactiveProxy)
+  //   expect(isReactive(shallowProxy.foo)).toBe(false)
+  //   expect(isReactive(reactiveProxy.foo)).toBe(true)
+  // })
+
+  // test('should respect shallow/deep versions of same target on access', () => {
+  //   const original = {}
+  //   const shallow = shallowReactive(original)
+  //   const deep = reactive(original)
+  //   const r = reactive({ shallow, deep })
+  //   expect(r.shallow).toBe(shallow)
+  //   expect(r.deep).toBe(deep)
+  // })
+
+  // @discrepancy Vue 2 does not support collections
+  // describe('collections', () => {
+  //   test('should be reactive', () => {
+  //     const shallowSet = shallowReactive(new Set())
+  //     const a = {}
+  //     let size
+
+  //     effect(() => {
+  //       size = shallowSet.size
+  //     })
+
+  //     expect(size).toBe(0)
+
+  //     shallowSet.add(a)
+  //     expect(size).toBe(1)
+
+  //     shallowSet.delete(a)
+  //     expect(size).toBe(0)
+  //   })
+
+  //   test('should not observe when iterating', () => {
+  //     const shallowSet = shallowReactive(new Set())
+  //     const a = {}
+  //     shallowSet.add(a)
+
+  //     const spreadA = [...shallowSet][0]
+  //     expect(isReactive(spreadA)).toBe(false)
+  //   })
+
+  //   test('should not get reactive entry', () => {
+  //     const shallowMap = shallowReactive(new Map())
+  //     const a = {}
+  //     const key = 'a'
+
+  //     shallowMap.set(key, a)
+
+  //     expect(isReactive(shallowMap.get(key))).toBe(false)
+  //   })
+
+  //   test('should not get reactive on foreach', () => {
+  //     const shallowSet = shallowReactive(new Set())
+  //     const a = {}
+  //     shallowSet.add(a)
+
+  //     shallowSet.forEach(x => expect(isReactive(x)).toBe(false))
+  //   })
+
+  //   // #1210
+  //   test('onTrack on called on objectSpread', () => {
+  //     const onTrackFn = vi.fn()
+  //     const shallowSet = shallowReactive(new Set())
+  //     let a
+  //     effect(
+  //       () => {
+  //         a = Array.from(shallowSet)
+  //       },
+  //       {
+  //         onTrack: onTrackFn
+  //       }
+  //     )
+
+  //     expect(a).toMatchObject([])
+  //     expect(onTrackFn).toHaveBeenCalled()
+  //   })
+  // })
+
+  // @discrepancy Vue 2 does not track array without access
+  // describe('array', () => {
+  //   test('should be reactive', () => {
+  //     const shallowArray = shallowReactive<unknown[]>([])
+  //     const a = {}
+  //     let size
+
+  //     effect(() => {
+  //       size = shallowArray.length
+  //     })
+
+  //     expect(size).toBe(0)
+
+  //     shallowArray.push(a)
+  //     expect(size).toBe(1)
+
+  //     shallowArray.pop()
+  //     expect(size).toBe(0)
+  //   })
+  //   test('should not observe when iterating', () => {
+  //     const shallowArray = shallowReactive<object[]>([])
+  //     const a = {}
+  //     shallowArray.push(a)
+
+  //     const spreadA = [...shallowArray][0]
+  //     expect(isReactive(spreadA)).toBe(false)
+  //   })
+
+  //   test('onTrack on called on objectSpread', () => {
+  //     const onTrackFn = vi.fn()
+  //     const shallowArray = shallowReactive([])
+  //     let a
+  //     effect(
+  //       () => {
+  //         a = Array.from(shallowArray)
+  //       },
+  //       {
+  //         onTrack: onTrackFn
+  //       }
+  //     )
+
+  //     expect(a).toMatchObject([])
+  //     expect(onTrackFn).toHaveBeenCalled()
+  //   })
+  // })
+})
diff --git a/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts b/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts
index e69de29bb2d..82432d32423 100644
--- a/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts
+++ b/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts
@@ -0,0 +1,206 @@
+import { isReactive, shallowReadonly, readonly, isReadonly } from 'vca/index'
+
+describe('reactivity/shallowReadonly', () => {
+  test('should be readonly', () => {
+    expect(isReadonly(shallowReadonly({}))).toBe(true)
+  })
+
+  test('should not make non-reactive properties reactive', () => {
+    const props = shallowReadonly({ n: { foo: 1 } })
+    expect(isReactive(props.n)).toBe(false)
+  })
+
+  test('should make root level properties readonly', () => {
+    const props = shallowReadonly({ n: 1 })
+    // @ts-expect-error
+    props.n = 2
+    expect(props.n).toBe(1)
+    expect(
+      `Set operation on key "n" failed: target is readonly.`
+    ).toHaveBeenWarned()
+  })
+
+  // to retain 2.x behavior.
+  test('should NOT make nested properties readonly', () => {
+    const props = shallowReadonly({ n: { foo: 1 } })
+
+    props.n.foo = 2
+    expect(props.n.foo).toBe(2)
+    expect(
+      `Set operation on key "foo" failed: target is readonly.`
+    ).not.toHaveBeenWarned()
+  })
+
+  // #2843
+  test('should differentiate from normal readonly calls', () => {
+    const original = { foo: {} }
+    const shallowProxy = shallowReadonly(original)
+    const reactiveProxy = readonly(original)
+    expect(shallowProxy).not.toBe(reactiveProxy)
+    expect(isReadonly(shallowProxy.foo)).toBe(false)
+    expect(isReadonly(reactiveProxy.foo)).toBe(true)
+  })
+
+  // @discrepancy does not support collections
+  // describe('collection/Map', () => {
+  //   ;[Map, WeakMap].forEach(Collection => {
+  //     test('should make the map/weak-map readonly', () => {
+  //       const key = {}
+  //       const val = { foo: 1 }
+  //       const original = new Collection([[key, val]])
+  //       const sroMap = shallowReadonly(original)
+  //       expect(isReadonly(sroMap)).toBe(true)
+  //       expect(isReactive(sroMap)).toBe(false)
+  //       expect(sroMap.get(key)).toBe(val)
+
+  //       sroMap.set(key, {} as any)
+  //       expect(
+  //         `Set operation on key "[object Object]" failed: target is readonly.`
+  //       ).toHaveBeenWarned()
+  //     })
+
+  //     test('should not make nested values readonly', () => {
+  //       const key = {}
+  //       const val = { foo: 1 }
+  //       const original = new Collection([[key, val]])
+  //       const sroMap = shallowReadonly(original)
+  //       expect(isReadonly(sroMap.get(key))).toBe(false)
+  //       expect(isReactive(sroMap.get(key))).toBe(false)
+
+  //       sroMap.get(key)!.foo = 2
+  //       expect(
+  //         `Set operation on key "foo" failed: target is readonly.`
+  //       ).not.toHaveBeenWarned()
+  //     })
+  //   })
+
+  //   test('should not make the value generated by the iterable method readonly', () => {
+  //     const key = {}
+  //     const val = { foo: 1 }
+  //     const original = new Map([[key, val]])
+  //     const sroMap = shallowReadonly(original)
+
+  //     const values1 = [...sroMap.values()]
+  //     const values2 = [...sroMap.entries()]
+
+  //     expect(isReadonly(values1[0])).toBe(false)
+  //     expect(isReactive(values1[0])).toBe(false)
+  //     expect(values1[0]).toBe(val)
+
+  //     values1[0].foo = 2
+  //     expect(
+  //       `Set operation on key "foo" failed: target is readonly.`
+  //     ).not.toHaveBeenWarned()
+
+  //     expect(isReadonly(values2[0][1])).toBe(false)
+  //     expect(isReactive(values2[0][1])).toBe(false)
+  //     expect(values2[0][1]).toBe(val)
+
+  //     values2[0][1].foo = 2
+  //     expect(
+  //       `Set operation on key "foo" failed: target is readonly.`
+  //     ).not.toHaveBeenWarned()
+  //   })
+
+  //   test('should not make the value generated by the forEach method readonly', () => {
+  //     const val = { foo: 1 }
+  //     const original = new Map([['key', val]])
+  //     const sroMap = shallowReadonly(original)
+
+  //     sroMap.forEach(val => {
+  //       expect(isReadonly(val)).toBe(false)
+  //       expect(isReactive(val)).toBe(false)
+  //       expect(val).toBe(val)
+
+  //       val.foo = 2
+  //       expect(
+  //         `Set operation on key "foo" failed: target is readonly.`
+  //       ).not.toHaveBeenWarned()
+  //     })
+  //   })
+  // })
+
+  // describe('collection/Set', () => {
+  //   test('should make the set/weak-set readonly', () => {
+  //     ;[Set, WeakSet].forEach(Collection => {
+  //       const obj = { foo: 1 }
+  //       const original = new Collection([obj])
+  //       const sroSet = shallowReadonly(original)
+  //       expect(isReadonly(sroSet)).toBe(true)
+  //       expect(isReactive(sroSet)).toBe(false)
+  //       expect(sroSet.has(obj)).toBe(true)
+
+  //       sroSet.add({} as any)
+  //       expect(
+  //         `Add operation on key "[object Object]" failed: target is readonly.`
+  //       ).toHaveBeenWarned()
+  //     })
+  //   })
+
+  //   test('should not make nested values readonly', () => {
+  //     const obj = { foo: 1 }
+  //     const original = new Set([obj])
+  //     const sroSet = shallowReadonly(original)
+
+  //     const values = [...sroSet.values()]
+
+  //     expect(values[0]).toBe(obj)
+  //     expect(isReadonly(values[0])).toBe(false)
+  //     expect(isReactive(values[0])).toBe(false)
+
+  //     sroSet.add({} as any)
+  //     expect(
+  //       `Add operation on key "[object Object]" failed: target is readonly.`
+  //     ).toHaveBeenWarned()
+
+  //     values[0].foo = 2
+  //     expect(
+  //       `Set operation on key "foo" failed: target is readonly.`
+  //     ).not.toHaveBeenWarned()
+  //   })
+
+  //   test('should not make the value generated by the iterable method readonly', () => {
+  //     const val = { foo: 1 }
+  //     const original = new Set([val])
+  //     const sroSet = shallowReadonly(original)
+
+  //     const values1 = [...sroSet.values()]
+  //     const values2 = [...sroSet.entries()]
+
+  //     expect(isReadonly(values1[0])).toBe(false)
+  //     expect(isReactive(values1[0])).toBe(false)
+  //     expect(values1[0]).toBe(val)
+
+  //     values1[0].foo = 2
+  //     expect(
+  //       `Set operation on key "foo" failed: target is readonly.`
+  //     ).not.toHaveBeenWarned()
+
+  //     expect(isReadonly(values2[0][1])).toBe(false)
+  //     expect(isReactive(values2[0][1])).toBe(false)
+  //     expect(values2[0][1]).toBe(val)
+
+  //     values2[0][1].foo = 2
+  //     expect(
+  //       `Set operation on key "foo" failed: target is readonly.`
+  //     ).not.toHaveBeenWarned()
+  //   })
+
+  //   test('should not make the value generated by the forEach method readonly', () => {
+  //     const val = { foo: 1 }
+  //     const original = new Set([val])
+  //     const sroSet = shallowReadonly(original)
+
+  //     sroSet.forEach(val => {
+  //       expect(isReadonly(val)).toBe(false)
+  //       expect(isReactive(val)).toBe(false)
+  //       expect(val).toBe(val)
+
+  //       val.foo = 2
+  //       expect(
+  //         `Set operation on key "foo" failed: target is readonly.`
+  //       ).not.toHaveBeenWarned()
+  //     })
+  //   })
+  // })
+})

From 93214586aafa6fbfff7eaf2643d18894ee3db119 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 17:26:55 +0800
Subject: [PATCH 082/317] types: types for setup() + format types

---
 types/index.d.ts                   |  22 +-
 types/options.d.ts                 | 365 +++++++++++++++++----------
 types/plugin.d.ts                  |   8 +-
 types/test/async-component-test.ts |  14 +-
 types/test/augmentation-test.ts    |  34 +--
 types/test/options-test.ts         | 316 ++++++++++++------------
 types/test/plugin-test.ts          |  20 +-
 types/test/setup-test.ts           |  35 +++
 types/test/ssr-test.ts             | 150 ++++++------
 types/test/umd-test.ts             |   8 +-
 types/test/vue-test.ts             | 237 +++++++++---------
 types/umd.d.ts                     |  74 ++++--
 types/v3.d.ts                      |  13 +
 types/vnode.d.ts                   | 127 +++++-----
 types/vue.d.ts                     | 380 ++++++++++++++++++++++-------
 15 files changed, 1108 insertions(+), 695 deletions(-)
 create mode 100644 types/test/setup-test.ts
 create mode 100644 types/v3.d.ts

diff --git a/types/index.d.ts b/types/index.d.ts
index 58ceb209e5d..a792a1b031b 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -1,12 +1,9 @@
-import { Vue } from "./vue";
-import "./umd";
+import { Vue } from './vue'
+import './umd'
 
-export default Vue;
+export default Vue
 
-export {
-  CreateElement,
-  VueConstructor
-} from "./vue";
+export { CreateElement, VueConstructor } from './vue'
 
 export {
   Component,
@@ -22,12 +19,9 @@ export {
   WatchOptionsWithHandler,
   DirectiveFunction,
   DirectiveOptions
-} from "./options";
+} from './options'
 
-export {
-  PluginFunction,
-  PluginObject
-} from "./plugin";
+export { PluginFunction, PluginObject } from './plugin'
 
 export {
   VNodeChildren,
@@ -36,4 +30,6 @@ export {
   VNodeComponentOptions,
   VNodeData,
   VNodeDirective
-} from "./vnode";
+} from './vnode'
+
+export { h, getCurrentInstance } from './v3'
diff --git a/types/options.d.ts b/types/options.d.ts
index ff266052feb..3701acb333b 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -1,37 +1,73 @@
-import { Vue, CreateElement, CombinedVueInstance } from "./vue";
-import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from "./vnode";
+import { Vue, CreateElement, CombinedVueInstance } from './vue'
+import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from './vnode'
+import { SetupContext } from './v3'
 
 type Constructor = {
-  new (...args: any[]): any;
+  new (...args: any[]): any
 }
 
 // we don't support infer props in async component
 // N.B. ComponentOptions<V> is contravariant, the default generic should be bottom type
-export type Component<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> =
+export type Component<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> =
   | typeof Vue
   | FunctionalComponentOptions<Props>
-  | ComponentOptions<never, Data, Methods, Computed, Props>
+  | ComponentOptions<never, Data, Methods, Computed, Props, SetupBindings>
 
 type EsModule<T> = T | { default: T }
 
-type ImportedComponent<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps>
-  = EsModule<Component<Data, Methods, Computed, Props>>
-
-export type AsyncComponent<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps>
-  = AsyncComponentPromise<Data, Methods, Computed, Props>
-  | AsyncComponentFactory<Data, Methods, Computed, Props>
-
-export type AsyncComponentPromise<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = (
-  resolve: (component: Component<Data, Methods, Computed, Props>) => void,
+type ImportedComponent<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> = EsModule<Component<Data, Methods, Computed, Props, SetupBindings>>
+
+export type AsyncComponent<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> =
+  | AsyncComponentPromise<Data, Methods, Computed, Props, SetupBindings>
+  | AsyncComponentFactory<Data, Methods, Computed, Props, SetupBindings>
+
+export type AsyncComponentPromise<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> = (
+  resolve: (
+    component: Component<Data, Methods, Computed, Props, SetupBindings>
+  ) => void,
   reject: (reason?: any) => void
-) => Promise<ImportedComponent<Data, Methods, Computed, Props>> | void;
-
-export type AsyncComponentFactory<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = () => {
-  component: Promise<ImportedComponent<Data, Methods, Computed, Props>>;
-  loading?: ImportedComponent;
-  error?: ImportedComponent;
-  delay?: number;
-  timeout?: number;
+) => Promise<
+  ImportedComponent<Data, Methods, Computed, Props, SetupBindings>
+> | void
+
+export type AsyncComponentFactory<
+  Data = DefaultData<never>,
+  Methods = DefaultMethods<never>,
+  Computed = DefaultComputed,
+  Props = DefaultProps,
+  SetupBindings = {}
+> = () => {
+  component: Promise<
+    ImportedComponent<Data, Methods, Computed, Props, SetupBindings>
+  >
+  loading?: ImportedComponent
+  error?: ImportedComponent
+  delay?: number
+  timeout?: number
 }
 
 /**
@@ -48,141 +84,212 @@ type DataDef<Data, Props, V> = Data | ((this: Readonly<Props> & V) => Data)
 /**
  * This type should be used when an array of strings is used for a component's `props` value.
  */
-export type ThisTypedComponentOptionsWithArrayProps<V extends Vue, Data, Methods, Computed, PropNames extends string> =
-  object &
-  ComponentOptions<V, DataDef<Data, Record<PropNames, any>, V>, Methods, Computed, PropNames[], Record<PropNames, any>> &
-  ThisType<CombinedVueInstance<V, Data, Methods, Computed, Readonly<Record<PropNames, any>>>>;
+export type ThisTypedComponentOptionsWithArrayProps<
+  V extends Vue,
+  Data,
+  Methods,
+  Computed,
+  PropNames extends string,
+  SetupBindings
+> = object &
+  ComponentOptions<
+    V,
+    DataDef<Data, Record<PropNames, any>, V>,
+    Methods,
+    Computed,
+    PropNames[],
+    Record<PropNames, any>,
+    SetupBindings
+  > &
+  ThisType<
+    CombinedVueInstance<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Readonly<Record<PropNames, any>>,
+      SetupBindings
+    >
+  >
 
 /**
  * This type should be used when an object mapped to `PropOptions` is used for a component's `props` value.
  */
-export type ThisTypedComponentOptionsWithRecordProps<V extends Vue, Data, Methods, Computed, Props> =
-  object &
-  ComponentOptions<V, DataDef<Data, Props, V>, Methods, Computed, RecordPropsDefinition<Props>, Props> &
-  ThisType<CombinedVueInstance<V, Data, Methods, Computed, Readonly<Props>>>;
-
-type DefaultData<V> =  object | ((this: V) => object);
-type DefaultProps = Record<string, any>;
-type DefaultMethods<V> =  { [key: string]: (this: V, ...args: any[]) => any };
-type DefaultComputed = { [key: string]: any };
+export type ThisTypedComponentOptionsWithRecordProps<
+  V extends Vue,
+  Data,
+  Methods,
+  Computed,
+  Props,
+  SetupBindings
+> = object &
+  ComponentOptions<
+    V,
+    DataDef<Data, Props, V>,
+    Methods,
+    Computed,
+    RecordPropsDefinition<Props>,
+    Props,
+    SetupBindings
+  > &
+  ThisType<
+    CombinedVueInstance<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Readonly<Props>,
+      SetupBindings
+    >
+  >
+
+type DefaultData<V> = object | ((this: V) => object)
+type DefaultProps = Record<string, any>
+type DefaultMethods<V> = { [key: string]: (this: V, ...args: any[]) => any }
+type DefaultComputed = { [key: string]: any }
+
 export interface ComponentOptions<
   V extends Vue,
-  Data=DefaultData<V>,
-  Methods=DefaultMethods<V>,
-  Computed=DefaultComputed,
-  PropsDef=PropsDefinition<DefaultProps>,
-  Props=DefaultProps> {
-  data?: Data;
-  props?: PropsDef;
-  propsData?: object;
-  computed?: Accessors<Computed>;
-  methods?: Methods;
-  watch?: Record<string, WatchOptionsWithHandler<any> | WatchHandler<any>>;
-
-  el?: Element | string;
-  template?: string;
+  Data = DefaultData<V>,
+  Methods = DefaultMethods<V>,
+  Computed = DefaultComputed,
+  PropsDef = PropsDefinition<DefaultProps>,
+  Props = DefaultProps,
+  RawBindings = {}
+> {
+  data?: Data
+  props?: PropsDef
+  propsData?: object
+  computed?: Accessors<Computed>
+  methods?: Methods
+  watch?: Record<string, WatchOptionsWithHandler<any> | WatchHandler<any>>
+
+  setup?: (
+    this: void,
+    props: Props,
+    ctx: SetupContext
+  ) => Promise<RawBindings> | RawBindings | ((h: CreateElement) => VNode) | void
+
+  el?: Element | string
+  template?: string
   // hack is for functional component type inference, should not be used in user code
-  render?(createElement: CreateElement, hack: RenderContext<Props>): VNode;
-  renderError?(createElement: CreateElement, err: Error): VNode;
-  staticRenderFns?: ((createElement: CreateElement) => VNode)[];
-
-  beforeCreate?(this: V): void;
-  created?(): void;
-  beforeDestroy?(): void;
-  destroyed?(): void;
-  beforeMount?(): void;
-  mounted?(): void;
-  beforeUpdate?(): void;
-  updated?(): void;
-  activated?(): void;
-  deactivated?(): void;
-  errorCaptured?(err: Error, vm: Vue, info: string): boolean | void;
-  serverPrefetch?(this: V): Promise<void>;
-
-  directives?: { [key: string]: DirectiveFunction | DirectiveOptions };
-  components?: { [key: string]: Component<any, any, any, any> | AsyncComponent<any, any, any, any> };
-  transitions?: { [key: string]: object };
-  filters?: { [key: string]: Function };
-
-  provide?: object | (() => object);
-  inject?: InjectOptions;
+  render?(createElement: CreateElement, hack: RenderContext<Props>): VNode
+  renderError?(createElement: CreateElement, err: Error): VNode
+  staticRenderFns?: ((createElement: CreateElement) => VNode)[]
+
+  beforeCreate?(this: V): void
+  created?(): void
+  beforeDestroy?(): void
+  destroyed?(): void
+  beforeMount?(): void
+  mounted?(): void
+  beforeUpdate?(): void
+  updated?(): void
+  activated?(): void
+  deactivated?(): void
+  errorCaptured?(err: Error, vm: Vue, info: string): boolean | void
+  serverPrefetch?(this: V): Promise<void>
+
+  directives?: { [key: string]: DirectiveFunction | DirectiveOptions }
+  components?: {
+    [key: string]:
+      | Component<any, any, any, any>
+      | AsyncComponent<any, any, any, any>
+  }
+  transitions?: { [key: string]: object }
+  filters?: { [key: string]: Function }
+
+  provide?: object | (() => object)
+  inject?: InjectOptions
 
   model?: {
-    prop?: string;
-    event?: string;
-  };
+    prop?: string
+    event?: string
+  }
 
-  parent?: Vue;
-  mixins?: (ComponentOptions<Vue> | typeof Vue)[];
-  name?: string;
+  parent?: Vue
+  mixins?: (ComponentOptions<Vue> | typeof Vue)[]
+  name?: string
   // TODO: support properly inferred 'extends'
-  extends?: ComponentOptions<Vue> | typeof Vue;
-  delimiters?: [string, string];
-  comments?: boolean;
-  inheritAttrs?: boolean;
+  extends?: ComponentOptions<Vue> | typeof Vue
+  delimiters?: [string, string]
+  comments?: boolean
+  inheritAttrs?: boolean
 }
 
-export interface FunctionalComponentOptions<Props = DefaultProps, PropDefs = PropsDefinition<Props>> {
-  name?: string;
-  props?: PropDefs;
+export interface FunctionalComponentOptions<
+  Props = DefaultProps,
+  PropDefs = PropsDefinition<Props>
+> {
+  name?: string
+  props?: PropDefs
   model?: {
-    prop?: string;
-    event?: string;
-  };
-  inject?: InjectOptions;
-  functional: boolean;
-  render?(this: undefined, createElement: CreateElement, context: RenderContext<Props>): VNode | VNode[];
+    prop?: string
+    event?: string
+  }
+  inject?: InjectOptions
+  functional: boolean
+  render?(
+    this: undefined,
+    createElement: CreateElement,
+    context: RenderContext<Props>
+  ): VNode | VNode[]
 }
 
-export interface RenderContext<Props=DefaultProps> {
-  props: Props;
-  children: VNode[];
-  slots(): any;
-  data: VNodeData;
-  parent: Vue;
-  listeners: { [key: string]: Function | Function[] };
-  scopedSlots: { [key: string]: NormalizedScopedSlot };
+export interface RenderContext<Props = DefaultProps> {
+  props: Props
+  children: VNode[]
+  slots(): any
+  data: VNodeData
+  parent: Vue
+  listeners: { [key: string]: Function | Function[] }
+  scopedSlots: { [key: string]: NormalizedScopedSlot }
   injections: any
 }
 
-export type Prop<T> = { (): T } | { new(...args: never[]): T & object } | { new(...args: string[]): Function }
+export type Prop<T> =
+  | { (): T }
+  | { new (...args: never[]): T & object }
+  | { new (...args: string[]): Function }
 
-export type PropType<T> = Prop<T> | Prop<T>[];
+export type PropType<T> = Prop<T> | Prop<T>[]
 
-export type PropValidator<T> = PropOptions<T> | PropType<T>;
+export type PropValidator<T> = PropOptions<T> | PropType<T>
 
-export interface PropOptions<T=any> {
-  type?: PropType<T>;
-  required?: boolean;
-  default?: T | null | undefined | (() => T | null | undefined);
-  validator?(value: T): boolean;
+export interface PropOptions<T = any> {
+  type?: PropType<T>
+  required?: boolean
+  default?: T | null | undefined | (() => T | null | undefined)
+  validator?(value: T): boolean
 }
 
 export type RecordPropsDefinition<T> = {
   [K in keyof T]: PropValidator<T[K]>
 }
-export type ArrayPropsDefinition<T> = (keyof T)[];
-export type PropsDefinition<T> = ArrayPropsDefinition<T> | RecordPropsDefinition<T>;
+export type ArrayPropsDefinition<T> = (keyof T)[]
+export type PropsDefinition<T> =
+  | ArrayPropsDefinition<T>
+  | RecordPropsDefinition<T>
 
 export interface ComputedOptions<T> {
-  get?(): T;
-  set?(value: T): void;
-  cache?: boolean;
+  get?(): T
+  set?(value: T): void
+  cache?: boolean
 }
 
-export type WatchHandler<T> = string | ((val: T, oldVal: T) => void);
+export type WatchHandler<T> = string | ((val: T, oldVal: T) => void)
 
 export interface WatchOptions {
-  deep?: boolean;
-  immediate?: boolean;
+  deep?: boolean
+  immediate?: boolean
 }
 
 export interface WatchOptionsWithHandler<T> extends WatchOptions {
-  handler: WatchHandler<T>;
+  handler: WatchHandler<T>
 }
 
 export interface DirectiveBinding extends Readonly<VNodeDirective> {
-  readonly modifiers: { [key: string]: boolean };
+  readonly modifiers: { [key: string]: boolean }
 }
 
 export type DirectiveFunction = (
@@ -190,18 +297,20 @@ export type DirectiveFunction = (
   binding: DirectiveBinding,
   vnode: VNode,
   oldVnode: VNode
-) => void;
+) => void
 
 export interface DirectiveOptions {
-  bind?: DirectiveFunction;
-  inserted?: DirectiveFunction;
-  update?: DirectiveFunction;
-  componentUpdated?: DirectiveFunction;
-  unbind?: DirectiveFunction;
+  bind?: DirectiveFunction
+  inserted?: DirectiveFunction
+  update?: DirectiveFunction
+  componentUpdated?: DirectiveFunction
+  unbind?: DirectiveFunction
 }
 
-export type InjectKey = string | symbol;
+export type InjectKey = string | symbol
 
-export type InjectOptions = {
-  [key: string]: InjectKey | { from?: InjectKey, default?: any }
-} | string[];
+export type InjectOptions =
+  | {
+      [key: string]: InjectKey | { from?: InjectKey; default?: any }
+    }
+  | string[]
diff --git a/types/plugin.d.ts b/types/plugin.d.ts
index 5741f862c55..8ebdfae9057 100644
--- a/types/plugin.d.ts
+++ b/types/plugin.d.ts
@@ -1,8 +1,8 @@
-import { Vue as _Vue } from "./vue";
+import { Vue as _Vue } from './vue'
 
-export type PluginFunction<T> = (Vue: typeof _Vue, options?: T) => void;
+export type PluginFunction<T> = (Vue: typeof _Vue, options?: T) => void
 
 export interface PluginObject<T> {
-  install: PluginFunction<T>;
-  [key: string]: any;
+  install: PluginFunction<T>
+  [key: string]: any
 }
diff --git a/types/test/async-component-test.ts b/types/test/async-component-test.ts
index baa50c4b915..d139157b5c5 100644
--- a/types/test/async-component-test.ts
+++ b/types/test/async-component-test.ts
@@ -1,8 +1,8 @@
-import Vue, { AsyncComponent, Component } from "../index";
+import Vue, { AsyncComponent, Component } from '../index'
 
 const a: AsyncComponent = () => ({
   component: new Promise<Component>((res, rej) => {
-    res({ template: "" })
+    res({ template: '' })
   })
 })
 
@@ -10,14 +10,14 @@ const b: AsyncComponent = () => ({
   // @ts-expect-error component has to be a Promise that resolves to a component
   component: () =>
     new Promise<Component>((res, rej) => {
-      res({ template: "" })
+      res({ template: '' })
     })
 })
 
 const c: AsyncComponent = () =>
   new Promise<Component>((res, rej) => {
     res({
-      template: ""
+      template: ''
     })
   })
 
@@ -25,7 +25,7 @@ const d: AsyncComponent = () =>
   new Promise<{ default: Component }>((res, rej) => {
     res({
       default: {
-        template: ""
+        template: ''
       }
     })
   })
@@ -34,11 +34,11 @@ const e: AsyncComponent = () => ({
   component: new Promise<{ default: Component }>((res, rej) => {
     res({
       default: {
-        template: ""
+        template: ''
       }
     })
   })
 })
 
 // Test that Vue.component accepts any AsyncComponent
-Vue.component("async-compponent1", a)
+Vue.component('async-compponent1', a)
diff --git a/types/test/augmentation-test.ts b/types/test/augmentation-test.ts
index bb77672103e..77c616f18d7 100644
--- a/types/test/augmentation-test.ts
+++ b/types/test/augmentation-test.ts
@@ -1,46 +1,46 @@
-import Vue from "../index";
+import Vue from '../index'
 
-declare module "../vue" {
+declare module '../vue' {
   // add instance property and method
   interface Vue {
-    $instanceProperty: string;
-    $instanceMethod(): void;
+    $instanceProperty: string
+    $instanceMethod(): void
   }
 
   // add static property and method
   interface VueConstructor {
-    staticProperty: string;
-    staticMethod(): void;
+    staticProperty: string
+    staticMethod(): void
   }
 }
 
 // augment ComponentOptions
-declare module "../options" {
+declare module '../options' {
   interface ComponentOptions<V extends Vue> {
-    foo?: string;
+    foo?: string
   }
 }
 
 const vm = new Vue({
-  props: ["bar"],
+  props: ['bar'],
   data: {
     a: true
   },
-  foo: "foo",
+  foo: 'foo',
   methods: {
     foo() {
-      this.a = false;
+      this.a = false
     }
   },
   computed: {
     BAR(): string {
-      return this.bar.toUpperCase();
+      return this.bar.toUpperCase()
     }
   }
-});
+})
 
-vm.$instanceProperty;
-vm.$instanceMethod();
+vm.$instanceProperty
+vm.$instanceMethod()
 
-Vue.staticProperty;
-Vue.staticMethod();
+Vue.staticProperty
+Vue.staticMethod()
diff --git a/types/test/options-test.ts b/types/test/options-test.ts
index cb8fa2e3f1b..49deeb9ef44 100644
--- a/types/test/options-test.ts
+++ b/types/test/options-test.ts
@@ -1,9 +1,9 @@
-import Vue, { PropType, VNode } from "../index";
-import { ComponentOptions, Component } from "../index";
-import { CreateElement } from "../vue";
+import Vue, { PropType, VNode } from '../index'
+import { ComponentOptions, Component } from '../index'
+import { CreateElement } from '../vue'
 
 interface MyComponent extends Vue {
-  a: number;
+  a: number
 }
 
 const option: ComponentOptions<MyComponent> = {
@@ -20,10 +20,10 @@ const componentType: Component = option
 
 Vue.component('sub-component', {
   components: {
-    a: Vue.component(""),
+    a: Vue.component(''),
     b: {}
   }
-});
+})
 
 Vue.component('prop-component', {
   props: {
@@ -31,7 +31,7 @@ Vue.component('prop-component', {
     name: {
       type: String,
       default: '0',
-      required: true,
+      required: true
     }
   },
   data() {
@@ -40,7 +40,7 @@ Vue.component('prop-component', {
       capName: this.name.toUpperCase()
     }
   }
-});
+})
 
 Vue.component('string-prop', {
   props: ['size', 'name'],
@@ -50,7 +50,7 @@ Vue.component('string-prop', {
       capName: this.name.isany
     }
   }
-});
+})
 
 class User {
   private u = 1
@@ -60,15 +60,15 @@ class Cat {
 }
 
 interface IUser {
-  foo: string,
+  foo: string
   bar: number
 }
 
 interface ICat {
-  foo: any,
+  foo: any
   bar: object
 }
-type ConfirmCallback = (confirm: boolean) => void;
+type ConfirmCallback = (confirm: boolean) => void
 
 Vue.component('union-prop', {
   props: {
@@ -79,16 +79,16 @@ Vue.component('union-prop', {
     union: [User, Number] as PropType<User | number>
   },
   data() {
-    this.cat;
-    this.complexUnion;
-    this.kittyUser;
-    this.callback(true);
-    this.union;
+    this.cat
+    this.complexUnion
+    this.kittyUser
+    this.callback(true)
+    this.union
     return {
-      fixedSize: this.union,
+      fixedSize: this.union
     }
   }
-});
+})
 
 Vue.component('union-prop-with-no-casting', {
   props: {
@@ -98,10 +98,10 @@ Vue.component('union-prop-with-no-casting', {
     regex: RegExp
   },
   data() {
-    this.mixed;
-    this.object;
-    this.primitive;
-    this.regex.compile;
+    this.mixed
+    this.object
+    this.primitive
+    this.regex.compile
   }
 })
 
@@ -113,9 +113,9 @@ Vue.component('prop-with-primitive-default', {
     }
   },
   created(): void {
-    this.id;
+    this.id
   }
-});
+})
 
 Vue.component('component', {
   data() {
@@ -130,40 +130,40 @@ Vue.component('component', {
     name: {
       type: String,
       default: '0',
-      required: true,
+      required: true
     }
   },
   propsData: {
-    msg: "Hello"
+    msg: 'Hello'
   },
   computed: {
     aDouble(): number {
-      return this.a * 2;
+      return this.a * 2
     },
     aPlus: {
       get(): number {
-        return this.a + 1;
+        return this.a + 1
       },
       set(v: number) {
-        this.a = v - 1;
+        this.a = v - 1
       },
       cache: false
     }
   },
   methods: {
     plus(): void {
-      this.a++;
-      this.aDouble.toFixed();
-      this.aPlus = 1;
-      this.size.toFixed();
+      this.a++
+      this.aDouble.toFixed()
+      this.aPlus = 1
+      this.size.toFixed()
     }
   },
   watch: {
-    'a': function(val: number, oldVal: number) {
-      console.log(`new: ${val}, old: ${oldVal}`);
+    a: function (val: number, oldVal: number) {
+      console.log(`new: ${val}, old: ${oldVal}`)
     },
-    'b': 'someMethod',
-    'c': {
+    b: 'someMethod',
+    c: {
       handler(val, oldVal) {
         this.a = val
       },
@@ -174,71 +174,77 @@ Vue.component('component', {
       immediate: true
     }
   },
-  el: "#app",
-  template: "<div>{{ message }}</div>",
+  el: '#app',
+  template: '<div>{{ message }}</div>',
   render(createElement) {
-    return createElement("div", {
-      attrs: {
-        id: "foo"
-      },
-      props: {
-        myProp: "bar"
-      },
-      directives: [{
-        name: 'a',
-        value: 'foo'
-      }],
-      domProps: {
-        innerHTML: "baz"
-      },
-      on: {
-        click: new Function
-      },
-      nativeOn: {
-        click: new Function
-      },
-      class: {
-        foo: true,
-        bar: false
-      },
-      style: {
-        color: 'red',
-        fontSize: '14px'
+    return createElement(
+      'div',
+      {
+        attrs: {
+          id: 'foo'
+        },
+        props: {
+          myProp: 'bar'
+        },
+        directives: [
+          {
+            name: 'a',
+            value: 'foo'
+          }
+        ],
+        domProps: {
+          innerHTML: 'baz'
+        },
+        on: {
+          click: new Function()
+        },
+        nativeOn: {
+          click: new Function()
+        },
+        class: {
+          foo: true,
+          bar: false
+        },
+        style: {
+          color: 'red',
+          fontSize: '14px'
+        },
+        key: 'myKey',
+        ref: 'myRef',
+        refInFor: true
       },
-      key: 'myKey',
-      ref: 'myRef',
-      refInFor: true
-    }, [
-      createElement(),
-      createElement("div", "message"),
-      createElement(Vue.component("component")),
-      createElement({} as ComponentOptions<Vue>),
-      createElement({
-        functional: true,
-        render(c: CreateElement) {
-          return createElement()
-        }
-      }),
-
-      createElement(() => Vue.component("component")),
-      createElement(() => ( {} as ComponentOptions<Vue> )),
-      createElement((resolve, reject) => {
-        resolve({} as ComponentOptions<Vue>);
-        reject();
-      }),
-
-      "message",
-
-      [createElement("div", "message")]
-    ]);
+      [
+        createElement(),
+        createElement('div', 'message'),
+        createElement(Vue.component('component')),
+        createElement({} as ComponentOptions<Vue>),
+        createElement({
+          functional: true,
+          render(c: CreateElement) {
+            return createElement()
+          }
+        }),
+
+        createElement(() => Vue.component('component')),
+        createElement(() => ({} as ComponentOptions<Vue>)),
+        createElement((resolve, reject) => {
+          resolve({} as ComponentOptions<Vue>)
+          reject()
+        }),
+
+        'message',
+
+        [createElement('div', 'message')]
+      ]
+    )
   },
   renderError(createElement, err) {
-    return createElement('pre', { style: { color: 'red' }}, err.stack)
+    return createElement('pre', { style: { color: 'red' } }, err.stack)
   },
   staticRenderFns: [],
 
   beforeCreate() {
-    (this as any).a = 1;
+    ;(this as any).a = 1
   },
   created() {},
   beforeDestroy() {},
@@ -255,7 +261,7 @@ Vue.component('component', {
     info.toUpperCase()
     return true
   },
-  serverPrefetch () {
+  serverPrefetch() {
     return Promise.resolve()
   },
 
@@ -268,44 +274,43 @@ Vue.component('component', {
       unbind() {}
     },
     b(el, binding, vnode, oldVnode) {
-      el.textContent;
-
-      binding.name;
-      binding.value;
-      binding.oldValue;
-      binding.expression;
-      binding.arg;
-      binding.modifiers["modifier"];
+      el.textContent
+
+      binding.name
+      binding.value
+      binding.oldValue
+      binding.expression
+      binding.arg
+      binding.modifiers['modifier']
     }
   },
   components: {
-    a: Vue.component(""),
+    a: Vue.component(''),
     b: {} as ComponentOptions<Vue>
   },
   transitions: {},
   filters: {
     double(value: number) {
-      return value * 2;
+      return value * 2
     }
   },
-  parent: new Vue,
-  mixins: [Vue.component(""), ({} as ComponentOptions<Vue>)],
-  name: "Component",
+  parent: new Vue(),
+  mixins: [Vue.component(''), {} as ComponentOptions<Vue>],
+  name: 'Component',
   extends: {} as ComponentOptions<Vue>,
-  delimiters: ["${", "}"]
-});
-
+  delimiters: ['${', '}']
+})
 
 Vue.component('custom-prop-type-function', {
   props: {
-    callback: Function as PropType<(confirm: boolean) => void>,
+    callback: Function as PropType<(confirm: boolean) => void>
   },
   methods: {
-    confirm(){
-      this.callback(true);
+    confirm() {
+      this.callback(true)
     }
   }
-});
+})
 
 Vue.component('provide-inject', {
   provide: {
@@ -316,7 +321,7 @@ Vue.component('provide-inject', {
     injectBar: Symbol(),
     injectBaz: { from: 'baz' },
     injectQux: { default: 1 },
-    injectQuux: { from: 'quuz', default: () => ({ value: 1 })}
+    injectQuux: { from: 'quuz', default: () => ({ value: 1 }) }
   }
 })
 
@@ -327,13 +332,13 @@ Vue.component('provide-function', {
 })
 
 Vue.component('component-with-slot', {
-  render (h): VNode {
+  render(h): VNode {
     return h('div', this.$slots.default)
   }
 })
 
 Vue.component('component-with-scoped-slot', {
-  render (h) {
+  render(h) {
     interface ScopedSlotProps {
       msg: string
     }
@@ -367,11 +372,12 @@ Vue.component('component-with-scoped-slot', {
   },
   components: {
     child: {
-      render (this: Vue, h: CreateElement) {
+      render(this: Vue, h: CreateElement) {
         const defaultSlot = this.$scopedSlots['default']!({ msg: 'hi' })
-        defaultSlot && defaultSlot.forEach(vnode => {
-          vnode.tag
-        })
+        defaultSlot &&
+          defaultSlot.forEach(vnode => {
+            vnode.tag
+          })
         return h('div', [
           defaultSlot,
           this.$scopedSlots['item']!({ msg: 'hello' })
@@ -382,7 +388,7 @@ Vue.component('component-with-scoped-slot', {
 })
 
 Vue.component('narrow-array-of-vnode-type', {
-  render (h): VNode {
+  render(h): VNode {
     const slot = this.$scopedSlots.default!({})
     if (typeof slot === 'string') {
       // <template slot-scope="data">bare string</template>
@@ -410,16 +416,16 @@ Vue.component('functional-component', {
   functional: true,
   inject: ['foo'],
   render(createElement, context) {
-    context.props;
-    context.children;
-    context.slots();
-    context.data;
-    context.parent;
-    context.scopedSlots;
-    context.listeners.click;
-    return createElement("div", {}, context.children);
+    context.props
+    context.children
+    context.slots()
+    context.data
+    context.parent
+    context.scopedSlots
+    context.listeners.click
+    return createElement('div', {}, context.children)
   }
-});
+})
 
 Vue.component('functional-component-object-inject', {
   functional: true,
@@ -428,7 +434,7 @@ Vue.component('functional-component-object-inject', {
     bar: Symbol(),
     baz: { from: 'baz' },
     qux: { default: 1 },
-    quux: { from: 'quuz', default: () => ({ value: 1 })}
+    quux: { from: 'quuz', default: () => ({ value: 1 }) }
   },
   render(h) {
     return h('div')
@@ -443,23 +449,25 @@ Vue.component('functional-component-multi-root', {
   functional: true,
   render(h) {
     return [
-      h("tr", [h("td", "foo"), h("td", "bar")]),
-      h("tr", [h("td", "lorem"), h("td", "ipsum")])
+      h('tr', [h('td', 'foo'), h('td', 'bar')]),
+      h('tr', [h('td', 'lorem'), h('td', 'ipsum')])
     ]
   }
 })
 
-Vue.component("async-component", ((resolve, reject) => {
+Vue.component('async-component', (resolve, reject) => {
   setTimeout(() => {
-    resolve(Vue.component("component"));
-  }, 0);
-  return new Promise((resolve) => {
+    resolve(Vue.component('component'))
+  }, 0)
+  return new Promise(resolve => {
     resolve({
       functional: true,
-      render(h: CreateElement) { return h('div') }
-    });
+      render(h: CreateElement) {
+        return h('div')
+      }
+    })
   })
-}));
+})
 
 Vue.component('functional-component-v-model', {
   props: ['foo'],
@@ -469,33 +477,33 @@ Vue.component('functional-component-v-model', {
     event: 'change'
   },
   render(createElement, context) {
-    return createElement("input", {
+    return createElement('input', {
       on: {
         input: new Function()
       },
       domProps: {
         value: context.props.foo
       }
-    });
+    })
   }
-});
-
+})
 
 Vue.component('async-es-module-component', () => import('./es-module'))
 
 Vue.component('directive-expression-optional-string', {
   render(createElement) {
-    return createElement("div", {
+    return createElement('div', {
       directives: [
         {
           name: 'has-expression',
           value: 2,
-          expression: '1 + 1',
-        }, {
-          name: 'no-expression',
-          value: 'foo',
+          expression: '1 + 1'
         },
-      ],
+        {
+          name: 'no-expression',
+          value: 'foo'
+        }
+      ]
     })
   }
-});
+})
diff --git a/types/test/plugin-test.ts b/types/test/plugin-test.ts
index ebb352e8239..c6c480343f3 100644
--- a/types/test/plugin-test.ts
+++ b/types/test/plugin-test.ts
@@ -1,20 +1,20 @@
-import Vue from "../index";
-import { PluginFunction, PluginObject } from "../index";
+import Vue from '../index'
+import { PluginFunction, PluginObject } from '../index'
 
 class Option {
-  prefix: string = "";
-  suffix: string = "";
+  prefix: string = ''
+  suffix: string = ''
 }
 
 const plugin: PluginObject<Option> = {
   install(Vue, option) {
-    if (typeof option !== "undefined") {
-      const {prefix, suffix} = option;
+    if (typeof option !== 'undefined') {
+      const { prefix, suffix } = option
     }
   }
 }
-const installer: PluginFunction<Option> = function(Vue, option) { }
+const installer: PluginFunction<Option> = function (Vue, option) {}
 
-Vue.use(plugin, new Option);
-Vue.use(installer, new Option);
-Vue.use(installer, new Option, new Option, new Option);
+Vue.use(plugin, new Option())
+Vue.use(installer, new Option())
+Vue.use(installer, new Option(), new Option(), new Option())
diff --git a/types/test/setup-test.ts b/types/test/setup-test.ts
new file mode 100644
index 00000000000..bc63a927c62
--- /dev/null
+++ b/types/test/setup-test.ts
@@ -0,0 +1,35 @@
+import Vue from '../index'
+
+// object props
+Vue.extend({
+  props: {
+    foo: String,
+    bar: Number
+  },
+  setup(props) {
+    props.foo + 'foo'
+    props.bar + 123
+  }
+})
+
+// array props
+Vue.extend({
+  props: ['foo', 'bar'],
+  setup(props) {
+    props.foo
+    props.bar
+  }
+})
+
+// context
+Vue.extend({
+  setup(_props, ctx) {
+    if (ctx.attrs.id) {
+    }
+    ctx.emit('foo')
+    ctx.slots.default && ctx.slots.default()
+    ctx.expose({
+      foo: 123
+    })
+  }
+})
diff --git a/types/test/ssr-test.ts b/types/test/ssr-test.ts
index ed6409a316d..37652b3324f 100644
--- a/types/test/ssr-test.ts
+++ b/types/test/ssr-test.ts
@@ -1,119 +1,127 @@
-import Vue, { VNode, VNodeDirective } from '../index';
-import VueSSRClientPlugin = require('../../packages/vue-server-renderer/client-plugin');
-import VueSSRServerPlugin = require('../../packages/vue-server-renderer/server-plugin');
-import webpack = require('webpack');
-import { readFileSync } from 'fs';
-import { createRenderer, createBundleRenderer } from '../../packages/vue-server-renderer';
-
-function createApp (context: any) {
+import Vue, { VNode, VNodeDirective } from '../index'
+import VueSSRClientPlugin = require('../../packages/vue-server-renderer/client-plugin')
+import VueSSRServerPlugin = require('../../packages/vue-server-renderer/server-plugin')
+import webpack = require('webpack')
+import { readFileSync } from 'fs'
+import {
+  createRenderer,
+  createBundleRenderer
+} from '../../packages/vue-server-renderer'
+
+function createApp(context: any) {
   return new Vue({
     data: {
       url: context.url
     },
     template: `<div>The visited URL is: {{ url }}</div>`
-  });
+  })
 }
 
 // Renderer test
-const app = createApp({ url: 'http://localhost:8000/' });
+const app = createApp({ url: 'http://localhost:8000/' })
 
 const renderer = createRenderer({
   template: readFileSync('./index.template.html', 'utf-8')
-});
+})
 
 const context = {
   title: 'Hello',
   meta: `
     <meta name="description" content="Vue.js SSR Example">
   `
-};
+}
 
 renderer.renderToString(app, (err, html) => {
-  if (err) throw err;
-  const res: string = html;
-});
+  if (err) throw err
+  const res: string = html
+})
 
 renderer.renderToString(app, context, (err, html) => {
-  if (err) throw err;
-  const res: string = html;
-});
+  if (err) throw err
+  const res: string = html
+})
 
-renderer.renderToString(app)
+renderer
+  .renderToString(app)
   .then(html => {
-    const res: string = html;
+    const res: string = html
   })
   .catch(err => {
-    throw err;
-  });
+    throw err
+  })
 
-renderer.renderToString(app, context)
+renderer
+  .renderToString(app, context)
   .then(html => {
-    const res: string = html;
+    const res: string = html
   })
   .catch(err => {
-    throw err;
-  });
+    throw err
+  })
 
 renderer.renderToStream(app, context).on('data', chunk => {
-  const html = chunk.toString();
-});
+  const html = chunk.toString()
+})
 
 // Bundle renderer test
-declare const cacheClient: { [key: string]: string };
-
-const bundleRenderer = createBundleRenderer('/path/to/vue-ssr-server-bundle.json', {
-  inject: false,
-  runInNewContext: 'once',
-  basedir: '/path/to/base',
-
-  shouldPreload: (file, type) => {
-    if (type === 'script' || type === 'style') {
-      return true;
-    }
-    if (type === 'font') {
-      return /\.woff2$/.test(file);
-    }
-    if (type === 'image') {
-      return file === 'hero.jpg';
-    }
-    return false;
-  },
-
-  cache: {
-    get: key => {
-      return cacheClient[key];
+declare const cacheClient: { [key: string]: string }
+
+const bundleRenderer = createBundleRenderer(
+  '/path/to/vue-ssr-server-bundle.json',
+  {
+    inject: false,
+    runInNewContext: 'once',
+    basedir: '/path/to/base',
+
+    shouldPreload: (file, type) => {
+      if (type === 'script' || type === 'style') {
+        return true
+      }
+      if (type === 'font') {
+        return /\.woff2$/.test(file)
+      }
+      if (type === 'image') {
+        return file === 'hero.jpg'
+      }
+      return false
     },
-    set: (key, val) => {
-      cacheClient[key] = val;
+
+    cache: {
+      get: key => {
+        return cacheClient[key]
+      },
+      set: (key, val) => {
+        cacheClient[key] = val
+      },
+      has: key => {
+        return !!cacheClient[key]
+      }
     },
-    has: key => {
-      return !!cacheClient[key];
-    }
-  },
 
-  directives: {
-    example (vnode: VNode, directiveMeta: VNodeDirective) {
-      // transform vnode based on directive binding metadata
+    directives: {
+      example(vnode: VNode, directiveMeta: VNodeDirective) {
+        // transform vnode based on directive binding metadata
+      }
     }
   }
-});
+)
 
 bundleRenderer.renderToString(context, (err, html) => {
-  if (err) throw err;
-  const res: string = html;
-});
+  if (err) throw err
+  const res: string = html
+})
 
 bundleRenderer.renderToString().then(html => {
-  const res: string = html;
-});
+  const res: string = html
+})
 
 bundleRenderer.renderToString(context).then(html => {
-  const res: string = html;
-});
+  const res: string = html
+})
 
 bundleRenderer.renderToStream(context).on('data', chunk => {
-  const html = chunk.toString();
-});
+  const html = chunk.toString()
+})
 
 // webpack plugins
 webpack({
@@ -125,4 +133,4 @@ webpack({
       filename: 'server-bundle.json'
     })
   ]
-});
+})
diff --git a/types/test/umd-test.ts b/types/test/umd-test.ts
index ffdc7046f92..d8e05b88fbf 100644
--- a/types/test/umd-test.ts
+++ b/types/test/umd-test.ts
@@ -1,7 +1,7 @@
 const vm = new Vue({
-  template: "<div>hi</div>"
-});
+  template: '<div>hi</div>'
+})
 
 const options: Vue.ComponentOptions<Vue> = {
-  template: "<div>test</div>"
-};
+  template: '<div>test</div>'
+}
diff --git a/types/test/vue-test.ts b/types/test/vue-test.ts
index 626220d0aac..45e7bc7a719 100644
--- a/types/test/vue-test.ts
+++ b/types/test/vue-test.ts
@@ -1,79 +1,82 @@
-import Vue, { VNode } from "../index";
-import { ComponentOptions } from "../options";
+import Vue, { VNode } from '../index'
+import { ComponentOptions } from '../options'
 
 class Test extends Vue {
-  a: number = 0;
+  a: number = 0
 
   testProperties() {
-    this.$data;
-    this.$el;
-    this.$options;
-    this.$parent;
-    this.$root;
-    this.$children;
-    this.$refs;
-    this.$slots;
-    this.$isServer;
-    this.$ssrContext;
-    this.$vnode;
+    this.$data
+    this.$el
+    this.$options
+    this.$parent
+    this.$root
+    this.$children
+    this.$refs
+    this.$slots
+    this.$isServer
+    this.$ssrContext
+    this.$vnode
   }
 
   // test property reification
-  $el!: HTMLElement | SVGElement;
+  $el!: HTMLElement | SVGElement
   $refs!: {
-    vue: Vue,
-    element: HTMLInputElement,
-    vues: Vue[],
+    vue: Vue
+    element: HTMLInputElement
+    vues: Vue[]
     elements: HTMLInputElement[]
   }
   testReification() {
-    this.$refs.vue.$data;
-    this.$refs.element.value;
-    this.$refs.vues[0].$data;
-    this.$refs.elements[0].value;
+    this.$refs.vue.$data
+    this.$refs.element.value
+    this.$refs.vues[0].$data
+    this.$refs.elements[0].value
   }
 
   testMethods() {
-    this.$mount("#app", false);
-    this.$forceUpdate();
-    this.$destroy();
-    this.$set({}, "key", "value");
-    this.$delete({}, "key");
-    this.$watch("a", (val: number, oldVal: number) => {}, {
+    this.$mount('#app', false)
+    this.$forceUpdate()
+    this.$destroy()
+    this.$set({}, 'key', 'value')
+    this.$delete({}, 'key')
+    this.$watch('a', (val: number, oldVal: number) => {}, {
       immediate: true,
       deep: false
-    })();
-    this.$watch(() => this.a, (val: number) => {});
-    this.$on("", () => {});
-    this.$once("", () => {});
-    this.$off("", () => {});
-    this.$emit("", 1, 2, 3);
-    this.$nextTick(function() {
-      this.$nextTick;
-    });
-    this.$nextTick().then(() => {});
-    this.$createElement("div", {}, "message");
+    })()
+    this.$watch(
+      () => this.a,
+      (val: number) => {}
+    )
+    this.$on('', () => {})
+    this.$once('', () => {})
+    this.$off('', () => {})
+    this.$emit('', 1, 2, 3)
+    this.$nextTick(function () {
+      this.$nextTick
+    })
+    this.$nextTick().then(() => {})
+    this.$createElement('div', {}, 'message')
   }
 
   static testConfig() {
-    const { config } = this;
-    config.silent;
-    config.optionMergeStrategies;
-    config.devtools;
+    const { config } = this
+    config.silent
+    config.optionMergeStrategies
+    config.devtools
     config.errorHandler = (err, vm) => {
       if (vm instanceof Test) {
-        vm.testProperties();
-        vm.testMethods();
+        vm.testProperties()
+        vm.testMethods()
       }
-    };
+    }
     config.warnHandler = (msg, vm) => {
       if (vm instanceof Test) {
-        vm.testProperties();
-        vm.testMethods();
+        vm.testProperties()
+        vm.testMethods()
       }
-    };
-    config.keyCodes = { esc: 27 };
-    config.ignoredElements = ['foo', /^ion-/];
+    }
+    config.keyCodes = { esc: 27 }
+    config.ignoredElements = ['foo', /^ion-/]
     config.async = false
   }
 
@@ -81,108 +84,114 @@ class Test extends Vue {
     this.extend({
       data() {
         return {
-          msg: ""
-        };
+          msg: ''
+        }
+      }
+    })
+    this.nextTick(() => {})
+    this.nextTick(
+      function () {
+        console.log(this.text === 'test')
+      },
+      { text: 'test' }
+    )
+    this.nextTick().then(() => {})
+    this.set({}, '', '')
+    this.set({}, 1, '')
+    this.set([true, false, true], 1, true)
+    this.delete({}, '')
+    this.delete({}, 1)
+    this.delete([true, false], 0)
+    this.directive('', { bind() {} })
+    this.filter('', (value: number) => value)
+    this.component('', { data: () => ({}) })
+    this.component('', {
+      functional: true,
+      render(h) {
+        return h('div', 'hello!')
       }
-    });
-    this.nextTick(() => {});
-    this.nextTick(function () {
-      console.log(this.text === 'test');
-    }, { text: 'test'});
-    this.nextTick().then(() => {});
-    this.set({}, "", "");
-    this.set({}, 1, "");
-    this.set([true, false, true], 1, true);
-    this.delete({}, "");
-    this.delete({}, 1);
-    this.delete([true, false], 0);
-    this.directive("", {bind() {}});
-    this.filter("", (value: number) => value);
-    this.component("", { data: () => ({}) });
-    this.component("", { functional: true, render(h) { return h("div", "hello!") } });
-    this.use;
-    this.mixin(Test);
-    this.compile("<div>{{ message }}</div>");
-    this
-      .use(() => {
-
-      })
-      .use(() => {
-
-      })
+    })
+    this.use
+    this.mixin(Test)
+    this.compile('<div>{{ message }}</div>')
+    this.use(() => {})
+      .use(() => {})
+      .mixin({})
       .mixin({})
-      .mixin({});
   }
 }
 
 const HelloWorldComponent = Vue.extend({
-  props: ["name"],
+  props: ['name'],
   data() {
     return {
-      message: "Hello " + this.name,
+      message: 'Hello ' + this.name
     }
   },
   computed: {
     shouted(): string {
-      return this.message.toUpperCase();
+      return this.message.toUpperCase()
     }
   },
   methods: {
     getMoreExcited() {
-      this.message += "!";
+      this.message += '!'
     }
   },
   watch: {
     message(a: string) {
-      console.log(`Message ${this.message} was changed!`);
+      console.log(`Message ${this.message} was changed!`)
     }
   }
-});
+})
 
 const FunctionalHelloWorldComponent = Vue.extend({
   functional: true,
-  props: ["name"],
+  props: ['name'],
   render(createElement, ctxt) {
-    return createElement("div", "Hello " + ctxt.props.name)
+    return createElement('div', 'Hello ' + ctxt.props.name)
   }
-});
+})
 
 const FunctionalScopedSlotsComponent = Vue.extend({
   functional: true,
   render(h, ctx) {
-    return ctx.scopedSlots.default && ctx.scopedSlots.default({}) || h('div', 'functional scoped slots');
+    return (
+      (ctx.scopedSlots.default && ctx.scopedSlots.default({})) ||
+      h('div', 'functional scoped slots')
+    )
   }
-});
+})
 
 const Parent = Vue.extend({
   data() {
     return { greeting: 'Hello' }
   }
-});
+})
 
 const Child = Parent.extend({
   methods: {
     foo() {
-      console.log(this.greeting.toLowerCase());
+      console.log(this.greeting.toLowerCase())
     }
   }
-});
+})
 
 const GrandChild = Child.extend({
   computed: {
     lower(): string {
-      return this.greeting.toLowerCase();
+      return this.greeting.toLowerCase()
     }
   }
-});
+})
 
-new GrandChild().lower.toUpperCase();
-for (let _ in (new Test()).$options) {
+new GrandChild().lower.toUpperCase()
+for (let _ in new Test().$options) {
 }
-declare const options: ComponentOptions<Vue>;
-Vue.extend(options);
-Vue.component('test-comp', options);
-new Vue(options);
+declare const options: ComponentOptions<Vue>
+Vue.extend(options)
+Vue.component('test-comp', options)
+new Vue(options)
 
 // cyclic example
 Vue.extend({
@@ -194,21 +203,21 @@ Vue.extend({
   methods: {
     foo() {}
   },
-  mounted () {
+  mounted() {
     this.foo()
   },
   // manual annotation
-  render (h): VNode {
+  render(h): VNode {
     const a = this.bar
     return h('canvas', {}, [a])
   }
 })
 
-declare function decorate<VC extends typeof Vue>(v: VC): VC;
+declare function decorate<VC extends typeof Vue>(v: VC): VC
 
 @decorate
 class Decorated extends Vue {
-  a = 123;
+  a = 123
 }
 
 const obj = Vue.observable({ a: 1 })
@@ -216,25 +225,23 @@ obj.a++
 
 // VNodeData style tests.
 const ComponentWithStyleInVNodeData = Vue.extend({
-  render (h) {
+  render(h) {
     const elementWithStyleAsString = h('div', {
       style: 'background-color: red;'
-    });
+    })
 
     const elementWithStyleAsObject = h('div', {
       style: { backgroundColor: 'green' }
-    });
+    })
 
     const elementWithStyleAsArrayOfObjects = h('div', {
-      style: [
-        { backgroundColor: 'blue' }
-      ]
-    });
+      style: [{ backgroundColor: 'blue' }]
+    })
 
     return h('div', undefined, [
       elementWithStyleAsString,
       elementWithStyleAsObject,
       elementWithStyleAsArrayOfObjects
-    ]);
+    ])
   }
-});
+})
diff --git a/types/umd.d.ts b/types/umd.d.ts
index d1dc8d15d66..3df7afef21c 100644
--- a/types/umd.d.ts
+++ b/types/umd.d.ts
@@ -1,48 +1,68 @@
-import * as V from "./index";
+import * as V from './index'
 import {
   DefaultData,
   DefaultProps,
   DefaultMethods,
   DefaultComputed,
   PropsDefinition
-} from "./options";
+} from './options'
 
 // Expose some types for backward compatibility...
 declare namespace Vue {
   // vue.d.ts
-  export type CreateElement = V.CreateElement;
-  export type VueConstructor<V extends Vue = Vue> = V.VueConstructor<V>;
+  export type CreateElement = V.CreateElement
+  export type VueConstructor<V extends Vue = Vue> = V.VueConstructor<V>
 
   // options.d.ts
-  export type Component<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = V.Component<Data, Methods, Computed, Props>;
-  export type AsyncComponent<Data=DefaultData<never>, Methods=DefaultMethods<never>, Computed=DefaultComputed, Props=DefaultProps> = V.AsyncComponent<Data, Methods, Computed, Props>;
-  export type ComponentOptions<V extends Vue, Data=DefaultData<V>, Methods=DefaultMethods<V>, Computed=DefaultComputed, PropsDef=PropsDefinition<DefaultProps>, Props=DefaultProps> = V.ComponentOptions<V, Data, Methods, Computed, PropsDef, Props>;
-  export type FunctionalComponentOptions<Props = DefaultProps, PropDefs = PropsDefinition<Props>> = V.FunctionalComponentOptions<Props, PropDefs>;
-  export type RenderContext<Props=DefaultProps> = V.RenderContext<Props>;
-  export type PropType<T> = V.PropType<T>;
-  export type PropOptions<T=any> = V.PropOptions<T>;
-  export type ComputedOptions<T> = V.ComputedOptions<T>;
-  export type WatchHandler<T> = V.WatchHandler<T>;
-  export type WatchOptions = V.WatchOptions;
-  export type WatchOptionsWithHandler<T> = V.WatchOptionsWithHandler<T>;
-  export type DirectiveFunction = V.DirectiveFunction;
-  export type DirectiveOptions = V.DirectiveOptions;
+  export type Component<
+    Data = DefaultData<never>,
+    Methods = DefaultMethods<never>,
+    Computed = DefaultComputed,
+    Props = DefaultProps
+  > = V.Component<Data, Methods, Computed, Props>
+  export type AsyncComponent<
+    Data = DefaultData<never>,
+    Methods = DefaultMethods<never>,
+    Computed = DefaultComputed,
+    Props = DefaultProps
+  > = V.AsyncComponent<Data, Methods, Computed, Props>
+  export type ComponentOptions<
+    V extends Vue,
+    Data = DefaultData<V>,
+    Methods = DefaultMethods<V>,
+    Computed = DefaultComputed,
+    PropsDef = PropsDefinition<DefaultProps>,
+    Props = DefaultProps
+  > = V.ComponentOptions<V, Data, Methods, Computed, PropsDef, Props>
+  export type FunctionalComponentOptions<
+    Props = DefaultProps,
+    PropDefs = PropsDefinition<Props>
+  > = V.FunctionalComponentOptions<Props, PropDefs>
+  export type RenderContext<Props = DefaultProps> = V.RenderContext<Props>
+  export type PropType<T> = V.PropType<T>
+  export type PropOptions<T = any> = V.PropOptions<T>
+  export type ComputedOptions<T> = V.ComputedOptions<T>
+  export type WatchHandler<T> = V.WatchHandler<T>
+  export type WatchOptions = V.WatchOptions
+  export type WatchOptionsWithHandler<T> = V.WatchOptionsWithHandler<T>
+  export type DirectiveFunction = V.DirectiveFunction
+  export type DirectiveOptions = V.DirectiveOptions
 
   // plugin.d.ts
-  export type PluginFunction<T> = V.PluginFunction<T>;
-  export type PluginObject<T> = V.PluginObject<T>;
+  export type PluginFunction<T> = V.PluginFunction<T>
+  export type PluginObject<T> = V.PluginObject<T>
 
   // vnode.d.ts
-  export type VNodeChildren = V.VNodeChildren;
-  export type VNodeChildrenArrayContents = V.VNodeChildrenArrayContents;
-  export type VNode = V.VNode;
-  export type VNodeComponentOptions = V.VNodeComponentOptions;
-  export type VNodeData = V.VNodeData;
-  export type VNodeDirective = V.VNodeDirective;
+  export type VNodeChildren = V.VNodeChildren
+  export type VNodeChildrenArrayContents = V.VNodeChildrenArrayContents
+  export type VNode = V.VNode
+  export type VNodeComponentOptions = V.VNodeComponentOptions
+  export type VNodeData = V.VNodeData
+  export type VNodeDirective = V.VNodeDirective
 }
 
 declare class Vue extends V.default {}
 
-export = Vue;
+export = Vue
 
-export as namespace Vue;
+export as namespace Vue
diff --git a/types/v3.d.ts b/types/v3.d.ts
new file mode 100644
index 00000000000..ae250120bee
--- /dev/null
+++ b/types/v3.d.ts
@@ -0,0 +1,13 @@
+import { VNode } from './vnode'
+import { CreateElement, Vue } from './vue'
+
+export interface SetupContext {
+  attrs: Record<string, any>
+  slots: Record<string, (() => VNode[]) | undefined>
+  emit: (event: string, ...args: any[]) => any
+  expose: (exposed?: Record<string, any>) => void
+}
+
+export function getCurrentInstance(): { proxy: Vue } | null
+
+export const h: CreateElement
diff --git a/types/vnode.d.ts b/types/vnode.d.ts
index 997980ce0b8..59eeb032b77 100644
--- a/types/vnode.d.ts
+++ b/types/vnode.d.ts
@@ -1,76 +1,89 @@
-import { Vue } from "./vue";
+import { Vue } from './vue'
 
-export type ScopedSlot = (props: any) => ScopedSlotReturnValue;
-type ScopedSlotReturnValue = VNode | string | boolean | null | undefined | ScopedSlotReturnArray;
+export type ScopedSlot = (props: any) => ScopedSlotReturnValue
+type ScopedSlotReturnValue =
+  | VNode
+  | string
+  | boolean
+  | null
+  | undefined
+  | ScopedSlotReturnArray
 interface ScopedSlotReturnArray extends Array<ScopedSlotReturnValue> {}
 
 // Scoped slots are guaranteed to return Array of VNodes starting in 2.6
-export type NormalizedScopedSlot = (props: any) => ScopedSlotChildren;
-export type ScopedSlotChildren = VNode[] | undefined;
+export type NormalizedScopedSlot = (props: any) => ScopedSlotChildren
+export type ScopedSlotChildren = VNode[] | undefined
 
 // Relaxed type compatible with $createElement
-export type VNodeChildren = VNodeChildrenArrayContents | [ScopedSlot] | string | boolean | null | undefined;
-export interface VNodeChildrenArrayContents extends Array<VNodeChildren | VNode> {}
+export type VNodeChildren =
+  | VNodeChildrenArrayContents
+  | [ScopedSlot]
+  | string
+  | boolean
+  | null
+  | undefined
+export interface VNodeChildrenArrayContents
+  extends Array<VNodeChildren | VNode> {}
 
 export interface VNode {
-  tag?: string;
-  data?: VNodeData;
-  children?: VNode[];
-  text?: string;
-  elm?: Node;
-  ns?: string;
-  context?: Vue;
-  key?: string | number | symbol | boolean;
-  componentOptions?: VNodeComponentOptions;
-  componentInstance?: Vue;
-  parent?: VNode;
-  raw?: boolean;
-  isStatic?: boolean;
-  isRootInsert: boolean;
-  isComment: boolean;
+  tag?: string
+  data?: VNodeData
+  children?: VNode[]
+  text?: string
+  elm?: Node
+  ns?: string
+  context?: Vue
+  key?: string | number | symbol | boolean
+  componentOptions?: VNodeComponentOptions
+  componentInstance?: Vue
+  parent?: VNode
+  raw?: boolean
+  isStatic?: boolean
+  isRootInsert: boolean
+  isComment: boolean
 }
 
 export interface VNodeComponentOptions {
-  Ctor: typeof Vue;
-  propsData?: object;
-  listeners?: object;
-  children?: VNode[];
-  tag?: string;
+  Ctor: typeof Vue
+  propsData?: object
+  listeners?: object
+  children?: VNode[]
+  tag?: string
 }
 
 export interface VNodeData {
-  key?: string | number;
-  slot?: string;
-  scopedSlots?: { [key: string]: ScopedSlot | undefined };
-  ref?: string;
-  refInFor?: boolean;
-  tag?: string;
-  staticClass?: string;
-  class?: any;
-  staticStyle?: { [key: string]: any };
-  style?: string | object[] | object;
-  props?: { [key: string]: any };
-  attrs?: { [key: string]: any };
-  domProps?: { [key: string]: any };
-  hook?: { [key: string]: Function };
-  on?: { [key: string]: Function | Function[] };
-  nativeOn?: { [key: string]: Function | Function[] };
-  transition?: object;
-  show?: boolean;
+  key?: string | number
+  slot?: string
+  scopedSlots?: { [key: string]: ScopedSlot | undefined }
+  ref?: string
+  refInFor?: boolean
+  tag?: string
+  staticClass?: string
+  class?: any
+  staticStyle?: { [key: string]: any }
+  style?: string | object[] | object
+  props?: { [key: string]: any }
+  attrs?: { [key: string]: any }
+  domProps?: { [key: string]: any }
+  hook?: { [key: string]: Function }
+  on?: { [key: string]: Function | Function[] }
+  nativeOn?: { [key: string]: Function | Function[] }
+  transition?: object
+  show?: boolean
   inlineTemplate?: {
-    render: Function;
-    staticRenderFns: Function[];
-  };
-  directives?: VNodeDirective[];
-  keepAlive?: boolean;
+    render: Function
+    staticRenderFns: Function[]
+  }
+  directives?: VNodeDirective[]
+  keepAlive?: boolean
 }
 
 export interface VNodeDirective {
-  name: string;
-  value?: any;
-  oldValue?: any;
-  expression?: string;
-  arg?: string;
-  oldArg?: string;
-  modifiers?: { [key: string]: boolean };
+  name: string
+  value?: any
+  oldValue?: any
+  expression?: string
+  arg?: string
+  oldArg?: string
+  modifiers?: { [key: string]: boolean }
 }
diff --git a/types/vue.d.ts b/types/vue.d.ts
index 7adb5a53aec..696a2f75b46 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -10,123 +10,327 @@ import {
   RecordPropsDefinition,
   ThisTypedComponentOptionsWithArrayProps,
   ThisTypedComponentOptionsWithRecordProps,
-  WatchOptions,
-} from "./options";
-import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from "./vnode";
-import { PluginFunction, PluginObject } from "./plugin";
+  WatchOptions
+} from './options'
+import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
+import { PluginFunction, PluginObject } from './plugin'
 
 export interface CreateElement {
-  (tag?: string | Component<any, any, any, any> | AsyncComponent<any, any, any, any> | (() => Component), children?: VNodeChildren): VNode;
-  (tag?: string | Component<any, any, any, any> | AsyncComponent<any, any, any, any> | (() => Component), data?: VNodeData, children?: VNodeChildren): VNode;
+  (
+    tag?:
+      | string
+      | Component<any, any, any, any>
+      | AsyncComponent<any, any, any, any>
+      | (() => Component),
+    children?: VNodeChildren
+  ): VNode
+  (
+    tag?:
+      | string
+      | Component<any, any, any, any>
+      | AsyncComponent<any, any, any, any>
+      | (() => Component),
+    data?: VNodeData,
+    children?: VNodeChildren
+  ): VNode
 }
 
 export interface Vue {
-  readonly $el: Element;
-  readonly $options: ComponentOptions<Vue>;
-  readonly $parent: Vue;
-  readonly $root: Vue;
-  readonly $children: Vue[];
-  readonly $refs: { [key: string]: Vue | Element | (Vue | Element)[] | undefined };
-  readonly $slots: { [key: string]: VNode[] | undefined };
-  readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined };
-  readonly $isServer: boolean;
-  readonly $data: Record<string, any>;
-  readonly $props: Record<string, any>;
-  readonly $ssrContext: any;
-  readonly $vnode: VNode;
-  readonly $attrs: Record<string, string>;
-  readonly $listeners: Record<string, Function | Function[]>;
-
-  $mount(elementOrSelector?: Element | string, hydrating?: boolean): this;
-  $forceUpdate(): void;
-  $destroy(): void;
-  $set: typeof Vue.set;
-  $delete: typeof Vue.delete;
+  readonly $el: Element
+  readonly $options: ComponentOptions<Vue>
+  readonly $parent: Vue
+  readonly $root: Vue
+  readonly $children: Vue[]
+  readonly $refs: {
+    [key: string]: Vue | Element | (Vue | Element)[] | undefined
+  }
+  readonly $slots: { [key: string]: VNode[] | undefined }
+  readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined }
+  readonly $isServer: boolean
+  readonly $data: Record<string, any>
+  readonly $props: Record<string, any>
+  readonly $ssrContext: any
+  readonly $vnode: VNode
+  readonly $attrs: Record<string, string>
+  readonly $listeners: Record<string, Function | Function[]>
+
+  $mount(elementOrSelector?: Element | string, hydrating?: boolean): this
+  $forceUpdate(): void
+  $destroy(): void
+  $set: typeof Vue.set
+  $delete: typeof Vue.delete
   $watch(
     expOrFn: string,
     callback: (this: this, n: any, o: any) => void,
     options?: WatchOptions
-  ): (() => void);
+  ): () => void
   $watch<T>(
     expOrFn: (this: this) => T,
     callback: (this: this, n: T, o: T) => void,
     options?: WatchOptions
-  ): (() => void);
-  $on(event: string | string[], callback: Function): this;
-  $once(event: string | string[], callback: Function): this;
-  $off(event?: string | string[], callback?: Function): this;
-  $emit(event: string, ...args: any[]): this;
-  $nextTick(callback: (this: this) => void): void;
-  $nextTick(): Promise<void>;
-  $createElement: CreateElement;
+  ): () => void
+  $on(event: string | string[], callback: Function): this
+  $once(event: string | string[], callback: Function): this
+  $off(event?: string | string[], callback?: Function): this
+  $emit(event: string, ...args: any[]): this
+  $nextTick(callback: (this: this) => void): void
+  $nextTick(): Promise<void>
+  $createElement: CreateElement
 }
 
-export type CombinedVueInstance<Instance extends Vue, Data, Methods, Computed, Props> =  Data & Methods & Computed & Props & Instance;
-export type ExtendedVue<Instance extends Vue, Data, Methods, Computed, Props> = VueConstructor<CombinedVueInstance<Instance, Data, Methods, Computed, Props> & Vue>;
+export type CombinedVueInstance<
+  Instance extends Vue,
+  Data,
+  Methods,
+  Computed,
+  Props,
+  SetupBindings
+> = Data & Methods & Computed & Props & Instance & SetupBindings
+
+export type ExtendedVue<
+  Instance extends Vue,
+  Data,
+  Methods,
+  Computed,
+  Props,
+  SetupBindings
+> = VueConstructor<
+  CombinedVueInstance<Instance, Data, Methods, Computed, Props, SetupBindings> &
+    Vue
+>
 
 export interface VueConfiguration {
-  silent: boolean;
-  optionMergeStrategies: any;
-  devtools: boolean;
-  productionTip: boolean;
-  performance: boolean;
-  errorHandler(err: Error, vm: Vue, info: string): void;
-  warnHandler(msg: string, vm: Vue, trace: string): void;
-  ignoredElements: (string | RegExp)[];
-  keyCodes: { [key: string]: number | number[] };
-  async: boolean;
+  silent: boolean
+  optionMergeStrategies: any
+  devtools: boolean
+  productionTip: boolean
+  performance: boolean
+  errorHandler(err: Error, vm: Vue, info: string): void
+  warnHandler(msg: string, vm: Vue, trace: string): void
+  ignoredElements: (string | RegExp)[]
+  keyCodes: { [key: string]: number | number[] }
+  async: boolean
 }
 
 export interface VueConstructor<V extends Vue = Vue> {
-  new <Data = object, Methods = object, Computed = object, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): CombinedVueInstance<V, Data, Methods, Computed, Record<PropNames, any>>;
-  // ideally, the return type should just contain Props, not Record<keyof Props, any>. But TS requires to have Base constructors with the same return type.
-  new <Data = object, Methods = object, Computed = object, Props = object>(options?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): CombinedVueInstance<V, Data, Methods, Computed, Record<keyof Props, any>>;
-  new (options?: ComponentOptions<V>): CombinedVueInstance<V, object, object, object, Record<keyof object, any>>;
-
-  extend<Data, Methods, Computed, PropNames extends string = never>(options?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): ExtendedVue<V, Data, Methods, Computed, Record<PropNames, any>>;
-  extend<Data, Methods, Computed, Props>(options?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
-  extend<PropNames extends string = never>(definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>>;
-  extend<Props>(definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
-  extend(options?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
-
-  nextTick<T>(callback: (this: T) => void, context?: T): void;
+  /**
+   * new with array props
+   */
+  new <
+    Data = object,
+    Methods = object,
+    Computed = object,
+    PropNames extends string = never,
+    SetupBindings = {}
+  >(
+    options?: ThisTypedComponentOptionsWithArrayProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      PropNames,
+      SetupBindings
+    >
+  ): CombinedVueInstance<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<PropNames, any>,
+    SetupBindings
+  >
+
+  /**
+   * new with object props
+   * ideally, the return type should just contain Props,
+   * not Record<keyof Props, any>. But TS requires to have Base constructors
+   * with the same return type.
+   */
+  new <
+    Data = object,
+    Methods = object,
+    Computed = object,
+    Props = object,
+    SetupBindings = {}
+  >(
+    options?: ThisTypedComponentOptionsWithRecordProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Props,
+      SetupBindings
+    >
+  ): CombinedVueInstance<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<keyof Props, any>,
+    SetupBindings
+  >
+
+  /**
+   * new with no props
+   */
+  new (options?: ComponentOptions<V>): CombinedVueInstance<
+    V,
+    object,
+    object,
+    object,
+    Record<keyof object, any>,
+    {}
+  >
+
+  /**
+   * extend with array props
+   */
+  extend<
+    Data,
+    Methods,
+    Computed,
+    PropNames extends string = never,
+    SetupBindings = {}
+  >(
+    options?: ThisTypedComponentOptionsWithArrayProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      PropNames,
+      SetupBindings
+    >
+  ): ExtendedVue<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<PropNames, any>,
+    SetupBindings
+  >
+
+  /**
+   * extend with object props
+   */
+  extend<Data, Methods, Computed, Props, SetupBindings = {}>(
+    options?: ThisTypedComponentOptionsWithRecordProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Props,
+      SetupBindings
+    >
+  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+
+  /**
+   * extend with functional + array props
+   */
+  extend<PropNames extends string = never>(
+    definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>
+  ): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>, {}>
+
+  /**
+   * extend with functional + object props
+   */
+  extend<Props>(
+    definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>
+  ): ExtendedVue<V, {}, {}, {}, Props, {}>
+
+  /**
+   * extend with no props
+   */
+  extend(options?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}, {}>
+
+  nextTick<T>(callback: (this: T) => void, context?: T): void
   nextTick(): Promise<void>
-  set<T>(object: object, key: string | number, value: T): T;
-  set<T>(array: T[], key: number, value: T): T;
-  delete(object: object, key: string | number): void;
-  delete<T>(array: T[], key: number): void;
+  set<T>(object: object, key: string | number, value: T): T
+  set<T>(array: T[], key: number, value: T): T
+  delete(object: object, key: string | number): void
+  delete<T>(array: T[], key: number): void
 
   directive(
     id: string,
     definition?: DirectiveOptions | DirectiveFunction
-  ): DirectiveOptions;
-  filter(id: string, definition?: Function): Function;
-
-  component(id: string): VueConstructor;
-  component<VC extends VueConstructor>(id: string, constructor: VC): VC;
-  component<Data, Methods, Computed, Props>(id: string, definition: AsyncComponent<Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
-  component<Data, Methods, Computed, PropNames extends string = never>(id: string, definition?: ThisTypedComponentOptionsWithArrayProps<V, Data, Methods, Computed, PropNames>): ExtendedVue<V, Data, Methods, Computed, Record<PropNames, any>>;
-  component<Data, Methods, Computed, Props>(id: string, definition?: ThisTypedComponentOptionsWithRecordProps<V, Data, Methods, Computed, Props>): ExtendedVue<V, Data, Methods, Computed, Props>;
-  component<PropNames extends string>(id: string, definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>>;
-  component<Props>(id: string, definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>): ExtendedVue<V, {}, {}, {}, Props>;
-  component(id: string, definition?: ComponentOptions<V>): ExtendedVue<V, {}, {}, {}, {}>;
-
-  use<T>(plugin: PluginObject<T> | PluginFunction<T>, options?: T): VueConstructor<V>;
-  use(plugin: PluginObject<any> | PluginFunction<any>, ...options: any[]): VueConstructor<V>;
-  mixin(mixin: VueConstructor | ComponentOptions<Vue>): VueConstructor<V>;
+  ): DirectiveOptions
+  filter(id: string, definition?: Function): Function
+
+  component(id: string): VueConstructor
+  component<VC extends VueConstructor>(id: string, constructor: VC): VC
+  component<Data, Methods, Computed, Props, SetupBindings>(
+    id: string,
+    definition: AsyncComponent<Data, Methods, Computed, Props>
+  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+  component<
+    Data,
+    Methods,
+    Computed,
+    PropNames extends string = never,
+    SetupBindings = {}
+  >(
+    id: string,
+    definition?: ThisTypedComponentOptionsWithArrayProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      PropNames,
+      SetupBindings
+    >
+  ): ExtendedVue<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Record<PropNames, any>,
+    SetupBindings
+  >
+  component<Data, Methods, Computed, Props, SetupBindings>(
+    id: string,
+    definition?: ThisTypedComponentOptionsWithRecordProps<
+      V,
+      Data,
+      Methods,
+      Computed,
+      Props,
+      SetupBindings
+    >
+  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+  component<PropNames extends string>(
+    id: string,
+    definition: FunctionalComponentOptions<Record<PropNames, any>, PropNames[]>
+  ): ExtendedVue<V, {}, {}, {}, Record<PropNames, any>, {}>
+  component<Props>(
+    id: string,
+    definition: FunctionalComponentOptions<Props, RecordPropsDefinition<Props>>
+  ): ExtendedVue<V, {}, {}, {}, Props, {}>
+  component(
+    id: string,
+    definition?: ComponentOptions<V>
+  ): ExtendedVue<V, {}, {}, {}, {}, {}>
+
+  use<T>(
+    plugin: PluginObject<T> | PluginFunction<T>,
+    options?: T
+  ): VueConstructor<V>
+  use(
+    plugin: PluginObject<any> | PluginFunction<any>,
+    ...options: any[]
+  ): VueConstructor<V>
+  mixin(mixin: VueConstructor | ComponentOptions<Vue>): VueConstructor<V>
   compile(template: string): {
-    render(createElement: typeof Vue.prototype.$createElement): VNode;
-    staticRenderFns: (() => VNode)[];
-  };
+    render(createElement: typeof Vue.prototype.$createElement): VNode
+    staticRenderFns: (() => VNode)[]
+  }
 
-  observable<T>(obj: T): T;
+  observable<T>(obj: T): T
 
   util: {
-    warn(msg: string, vm?: InstanceType<VueConstructor>): void;
-  };
+    warn(msg: string, vm?: InstanceType<VueConstructor>): void
+  }
 
-  config: VueConfiguration;
-  version: string;
+  config: VueConfiguration
+  version: string
 }
 
-export const Vue: VueConstructor;
+export const Vue: VueConstructor

From 1f1046b7e5e6f9165fae92c5208cfa1bae191c11 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 17:27:17 +0800
Subject: [PATCH 083/317] wip: rename dir to v3

---
 package.json                                  |    2 +-
 src/composition-api/currentInstance.ts        |   12 -
 src/core/observer/index.ts                    |    2 +-
 src/core/util/debug.ts                        |    3 +-
 src/platforms/web/entry-runtime-esm.ts        |    2 +-
 .../web/entry-runtime-with-compiler-esm.ts    |    2 +-
 .../web/entry-runtime-with-compiler.ts        |    4 +-
 src/platforms/web/entry-runtime.ts            |    2 +-
 src/{composition-api => v3}/apiInject.ts      |    0
 src/{composition-api => v3}/apiLifecycle.ts   |    0
 src/{composition-api => v3}/apiWatch.ts       |    0
 src/v3/currentInstance.ts                     |   21 +
 src/v3/h.ts                                   |   27 +
 src/{composition-api => v3}/index.ts          |   15 +-
 .../reactivity/computed.ts                    |    0
 .../reactivity/effect.ts                      |    0
 .../reactivity/operations.ts                  |    0
 .../reactivity/reactive.ts                    |    0
 .../reactivity/readonly.ts                    |    0
 src/{composition-api => v3}/reactivity/ref.ts |    0
 test/tsconfig.json                            |    7 +-
 test/unit/features/v3/apiWatch.spec.ts        | 1126 +++++++++++++++++
 .../reactivity/computed.spec.ts               |    6 +-
 .../reactivity/reactive.spec.ts               |   12 +-
 .../reactivity/readonly.spec.ts               |    4 +-
 .../reactivity/ref.spec.ts                    |    4 +-
 .../reactivity/shallowReactive.spec.ts        |    2 +-
 .../reactivity/shallowReadonly.spec.ts        |    2 +-
 tsconfig.json                                 |    6 +-
 vitest.config.ts                              |    2 +-
 30 files changed, 1214 insertions(+), 49 deletions(-)
 delete mode 100644 src/composition-api/currentInstance.ts
 rename src/{composition-api => v3}/apiInject.ts (100%)
 rename src/{composition-api => v3}/apiLifecycle.ts (100%)
 rename src/{composition-api => v3}/apiWatch.ts (100%)
 create mode 100644 src/v3/currentInstance.ts
 create mode 100644 src/v3/h.ts
 rename src/{composition-api => v3}/index.ts (68%)
 rename src/{composition-api => v3}/reactivity/computed.ts (100%)
 rename src/{composition-api => v3}/reactivity/effect.ts (100%)
 rename src/{composition-api => v3}/reactivity/operations.ts (100%)
 rename src/{composition-api => v3}/reactivity/reactive.ts (100%)
 rename src/{composition-api => v3}/reactivity/readonly.ts (100%)
 rename src/{composition-api => v3}/reactivity/ref.ts (100%)
 create mode 100644 test/unit/features/v3/apiWatch.spec.ts
 rename test/unit/features/{composition-api => v3}/reactivity/computed.spec.ts (98%)
 rename test/unit/features/{composition-api => v3}/reactivity/reactive.spec.ts (98%)
 rename test/unit/features/{composition-api => v3}/reactivity/readonly.spec.ts (99%)
 rename test/unit/features/{composition-api => v3}/reactivity/ref.spec.ts (99%)
 rename test/unit/features/{composition-api => v3}/reactivity/shallowReactive.spec.ts (99%)
 rename test/unit/features/{composition-api => v3}/reactivity/shallowReadonly.spec.ts (99%)

diff --git a/package.json b/package.json
index c4f37976cc2..a631ac6d49b 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
     "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",
     "test:transition": "karma start test/transition/karma.conf.js",
     "test:types": "tsc -p ./types/tsconfig.json",
-    "format": "prettier --write --parser typescript \"(src|test|packages)/**/*.ts\"",
+    "format": "prettier --write --parser typescript \"(src|test|packages|types)/**/*.ts\"",
     "ts-check": "tsc -p tsconfig.json --noEmit",
     "ts-check:test": "tsc -p test/tsconfig.json --noEmit",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
diff --git a/src/composition-api/currentInstance.ts b/src/composition-api/currentInstance.ts
deleted file mode 100644
index 27611959ec1..00000000000
--- a/src/composition-api/currentInstance.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { Component } from 'typescript/component'
-
-// TODO set this
-export let currentInstance: Component | null = null
-
-export function getCurrentInstance(): Component | null {
-  return currentInstance
-}
-
-export function setCurrentInstance(vm: Component | null) {
-  currentInstance = vm
-}
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 7ba9e0877dd..3ad49493892 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -15,7 +15,7 @@ import {
   isServerRendering,
   hasChanged
 } from '../util/index'
-import { isReadonly, isRef } from '../../composition-api'
+import { isReadonly, isRef } from '../../v3'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index 0f1c1241bba..f8fd902f298 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -1,6 +1,7 @@
 import config from '../config'
 import { noop, isArray } from 'shared/util'
 import type { Component } from 'typescript/component'
+import { currentInstance } from 'v3/currentInstance'
 
 export let warn = noop
 export let tip = noop
@@ -13,7 +14,7 @@ if (__DEV__) {
   const classify = str =>
     str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '')
 
-  warn = (msg, vm) => {
+  warn = (msg, vm = currentInstance) => {
     // TODO get current instance
     const trace = vm ? generateComponentTrace(vm) : ''
 
diff --git a/src/platforms/web/entry-runtime-esm.ts b/src/platforms/web/entry-runtime-esm.ts
index 790cef573bb..f858d03d0df 100644
--- a/src/platforms/web/entry-runtime-esm.ts
+++ b/src/platforms/web/entry-runtime-esm.ts
@@ -2,4 +2,4 @@ import Vue from './runtime/index'
 
 export default Vue
 
-export * from 'vca/index'
+export * from 'v3'
diff --git a/src/platforms/web/entry-runtime-with-compiler-esm.ts b/src/platforms/web/entry-runtime-with-compiler-esm.ts
index f54d6f66b8f..ff2ac5c928e 100644
--- a/src/platforms/web/entry-runtime-with-compiler-esm.ts
+++ b/src/platforms/web/entry-runtime-with-compiler-esm.ts
@@ -2,4 +2,4 @@ import Vue from './runtime-with-compiler'
 
 export default Vue
 
-export * from 'vca/index'
+export * from 'v3'
diff --git a/src/platforms/web/entry-runtime-with-compiler.ts b/src/platforms/web/entry-runtime-with-compiler.ts
index 5b393292e71..a28aea80dc4 100644
--- a/src/platforms/web/entry-runtime-with-compiler.ts
+++ b/src/platforms/web/entry-runtime-with-compiler.ts
@@ -1,10 +1,10 @@
 import Vue from './runtime-with-compiler'
-import * as vca from 'vca/index'
+import * as vca from 'v3'
 import { extend } from 'shared/util'
 
 extend(Vue, vca)
 
-import { effect } from 'vca/reactivity/effect'
+import { effect } from 'v3/reactivity/effect'
 Vue.effect = effect
 
 export default Vue
diff --git a/src/platforms/web/entry-runtime.ts b/src/platforms/web/entry-runtime.ts
index d2973d65931..86cea399ec5 100644
--- a/src/platforms/web/entry-runtime.ts
+++ b/src/platforms/web/entry-runtime.ts
@@ -1,5 +1,5 @@
 import Vue from './runtime/index'
-import * as vca from 'vca/index'
+import * as vca from 'v3'
 import { extend } from 'shared/util'
 
 extend(Vue, vca)
diff --git a/src/composition-api/apiInject.ts b/src/v3/apiInject.ts
similarity index 100%
rename from src/composition-api/apiInject.ts
rename to src/v3/apiInject.ts
diff --git a/src/composition-api/apiLifecycle.ts b/src/v3/apiLifecycle.ts
similarity index 100%
rename from src/composition-api/apiLifecycle.ts
rename to src/v3/apiLifecycle.ts
diff --git a/src/composition-api/apiWatch.ts b/src/v3/apiWatch.ts
similarity index 100%
rename from src/composition-api/apiWatch.ts
rename to src/v3/apiWatch.ts
diff --git a/src/v3/currentInstance.ts b/src/v3/currentInstance.ts
new file mode 100644
index 00000000000..59da6f312a4
--- /dev/null
+++ b/src/v3/currentInstance.ts
@@ -0,0 +1,21 @@
+import { Component } from 'typescript/component'
+
+export let currentInstance: Component | null = null
+
+/**
+ * This is exposed for compatibility with v3 (e.g. some functions in VueUse
+ * relies on it). Do not use this internally, just use `currentInstance`.
+ *
+ * @private this function needs manual type declaration because it relies
+ * on previously manually authored types from Vue 2
+ */
+export function getCurrentInstance(): { proxy: Component } | null {
+  return currentInstance && { proxy: currentInstance }
+}
+
+/**
+ * @private
+ */
+export function setCurrentInstance(vm: Component | null) {
+  currentInstance = vm
+}
diff --git a/src/v3/h.ts b/src/v3/h.ts
new file mode 100644
index 00000000000..f2124ebfa3a
--- /dev/null
+++ b/src/v3/h.ts
@@ -0,0 +1,27 @@
+import { createElement } from '../core/vdom/create-element'
+import VNode from 'core/vdom/vnode'
+import { VNodeData, VNodeChildren } from 'typescript/vnode'
+import { currentInstance } from './currentInstance'
+import { warn } from 'core/util'
+
+/**
+ * @private this function needs manual type declaration because it relies
+ * on previously manually authored types from Vue 2
+ */
+export function h(type: any, children?: VNodeChildren): VNode
+export function h(
+  type: any,
+  props?: VNodeData | null,
+  children?: VNodeChildren
+): VNode
+
+export function h(type: any, props?: any, children?: any) {
+  if (!currentInstance) {
+    __DEV__ &&
+      warn(
+        `globally imported h() can only be invoked when there is an active ` +
+          `component instance, e.g. synchronously in a component's render or setup function.`
+      )
+  }
+  return createElement(currentInstance!, type, props, children, 2, true)
+}
diff --git a/src/composition-api/index.ts b/src/v3/index.ts
similarity index 68%
rename from src/composition-api/index.ts
rename to src/v3/index.ts
index 0093e13b8ed..a54ba23dd10 100644
--- a/src/composition-api/index.ts
+++ b/src/v3/index.ts
@@ -46,5 +46,18 @@ export {
   watch,
   watchEffect,
   watchPostEffect,
-  watchSyncEffect
+  watchSyncEffect,
+  WatchEffect,
+  WatchOptions,
+  WatchOptionsBase,
+  WatchCallback,
+  WatchSource,
+  WatchStopHandle,
+  DebuggerOptions
 } from './apiWatch'
+
+export { DebuggerEvent } from './reactivity/effect'
+export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
+
+export { h } from './h'
+export { getCurrentInstance } from './currentInstance'
diff --git a/src/composition-api/reactivity/computed.ts b/src/v3/reactivity/computed.ts
similarity index 100%
rename from src/composition-api/reactivity/computed.ts
rename to src/v3/reactivity/computed.ts
diff --git a/src/composition-api/reactivity/effect.ts b/src/v3/reactivity/effect.ts
similarity index 100%
rename from src/composition-api/reactivity/effect.ts
rename to src/v3/reactivity/effect.ts
diff --git a/src/composition-api/reactivity/operations.ts b/src/v3/reactivity/operations.ts
similarity index 100%
rename from src/composition-api/reactivity/operations.ts
rename to src/v3/reactivity/operations.ts
diff --git a/src/composition-api/reactivity/reactive.ts b/src/v3/reactivity/reactive.ts
similarity index 100%
rename from src/composition-api/reactivity/reactive.ts
rename to src/v3/reactivity/reactive.ts
diff --git a/src/composition-api/reactivity/readonly.ts b/src/v3/reactivity/readonly.ts
similarity index 100%
rename from src/composition-api/reactivity/readonly.ts
rename to src/v3/reactivity/readonly.ts
diff --git a/src/composition-api/reactivity/ref.ts b/src/v3/reactivity/ref.ts
similarity index 100%
rename from src/composition-api/reactivity/ref.ts
rename to src/v3/reactivity/ref.ts
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 5c10275e644..1ad444952f7 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -23,14 +23,13 @@
     "paths": {
       "compiler/*": ["../src/compiler/*"],
       "core/*": ["../src/core/*"],
-
       "server/*": ["../src/server/*"],
       "sfc/*": ["../src/sfc/*"],
       "shared/*": ["../src/shared/*"],
-
       "web/*": ["../src/platforms/web/*"],
-      "vca/*": ["../src/composition-api/*"],
-
+      "v3": ["../src/v3/index"],
+      "v3/*": ["../src/v3/*"],
+      "typescript/*": ["../typescript/*"],
       "vue": ["../src/platforms/web/entry-runtime-with-compiler"]
     }
   },
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
new file mode 100644
index 00000000000..a68ed397713
--- /dev/null
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -0,0 +1,1126 @@
+import Vue from 'vue'
+import {
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+  reactive,
+  computed,
+  ref,
+  DebuggerEvent,
+  TrackOpTypes,
+  TriggerOpTypes,
+  triggerRef,
+  shallowRef,
+  Ref,
+  h,
+  getCurrentInstance
+  // effectScope
+} from 'v3'
+import { nextTick } from 'core/util'
+import { Component } from 'typescript/component'
+
+// reference: https://vue-composition-api-rfc.netlify.com/api.html#watch
+
+describe('api: watch', () => {
+  it('effect', async () => {
+    const state = reactive({ count: 0 })
+    let dummy
+    watchEffect(() => {
+      dummy = state.count
+    })
+    expect(dummy).toBe(0)
+
+    state.count++
+    await nextTick()
+    expect(dummy).toBe(1)
+  })
+
+  it('watching single source: getter', async () => {
+    const state = reactive({ count: 0 })
+    let dummy
+    watch(
+      () => state.count,
+      (count, prevCount) => {
+        dummy = [count, prevCount]
+        // assert types
+        count + 1
+        if (prevCount) {
+          prevCount + 1
+        }
+      }
+    )
+    state.count++
+    await nextTick()
+    expect(dummy).toMatchObject([1, 0])
+  })
+
+  it('watching single source: ref', async () => {
+    const count = ref(0)
+    let dummy
+    watch(count, (count, prevCount) => {
+      dummy = [count, prevCount]
+      // assert types
+      count + 1
+      if (prevCount) {
+        prevCount + 1
+      }
+    })
+    count.value++
+    await nextTick()
+    expect(dummy).toMatchObject([1, 0])
+  })
+
+  it('watching single source: array', async () => {
+    const array = reactive([] as number[])
+    const spy = vi.fn()
+    watch(array, spy)
+    array.push(1)
+    await nextTick()
+    expect(spy).toBeCalledTimes(1)
+    expect(spy).toBeCalledWith([1], expect.anything(), expect.anything())
+  })
+
+  it('should not fire if watched getter result did not change', async () => {
+    const spy = vi.fn()
+    const n = ref(0)
+    watch(() => n.value % 2, spy)
+
+    n.value++
+    await nextTick()
+    expect(spy).toBeCalledTimes(1)
+
+    n.value += 2
+    await nextTick()
+    // should not be called again because getter result did not change
+    expect(spy).toBeCalledTimes(1)
+  })
+
+  it('watching single source: computed ref', async () => {
+    const count = ref(0)
+    const plus = computed(() => count.value + 1)
+    let dummy
+    watch(plus, (count, prevCount) => {
+      dummy = [count, prevCount]
+      // assert types
+      count + 1
+      if (prevCount) {
+        prevCount + 1
+      }
+    })
+    count.value++
+    await nextTick()
+    expect(dummy).toMatchObject([2, 1])
+  })
+
+  it('watching primitive with deep: true', async () => {
+    const count = ref(0)
+    let dummy
+    watch(
+      count,
+      (c, prevCount) => {
+        dummy = [c, prevCount]
+      },
+      {
+        deep: true
+      }
+    )
+    count.value++
+    await nextTick()
+    expect(dummy).toMatchObject([1, 0])
+  })
+
+  it('directly watching reactive object (with automatic deep: true)', async () => {
+    const src = reactive({
+      count: 0
+    })
+    let dummy
+    watch(src, ({ count }) => {
+      dummy = count
+    })
+    src.count++
+    await nextTick()
+    expect(dummy).toBe(1)
+  })
+
+  it('watching multiple sources', async () => {
+    const state = reactive({ count: 1 })
+    const count = ref(1)
+    const plus = computed(() => count.value + 1)
+
+    let dummy
+    watch([() => state.count, count, plus], (vals, oldVals) => {
+      dummy = [vals, oldVals]
+      // assert types
+      vals.concat(1)
+      oldVals.concat(1)
+    })
+
+    state.count++
+    count.value++
+    await nextTick()
+    expect(dummy).toMatchObject([
+      [2, 2, 3],
+      [1, 1, 2]
+    ])
+  })
+
+  it('watching multiple sources: readonly array', async () => {
+    const state = reactive({ count: 1 })
+    const status = ref(false)
+
+    let dummy
+    watch([() => state.count, status] as const, (vals, oldVals) => {
+      dummy = [vals, oldVals]
+      const [count] = vals
+      const [, oldStatus] = oldVals
+      // assert types
+      count + 1
+      oldStatus === true
+    })
+
+    state.count++
+    status.value = true
+    await nextTick()
+    expect(dummy).toMatchObject([
+      [2, true],
+      [1, false]
+    ])
+  })
+
+  it('watching multiple sources: reactive object (with automatic deep: true)', async () => {
+    const src = reactive({ count: 0 })
+    let dummy
+    watch([src], ([state]) => {
+      dummy = state
+      // assert types
+      state.count === 1
+    })
+    src.count++
+    await nextTick()
+    expect(dummy).toMatchObject({ count: 1 })
+  })
+
+  it('warn invalid watch source', () => {
+    // @ts-expect-error
+    watch(1, () => {})
+    expect(`Invalid watch source`).toHaveBeenWarned()
+  })
+
+  it('warn invalid watch source: multiple sources', () => {
+    watch([1], () => {})
+    expect(`Invalid watch source`).toHaveBeenWarned()
+  })
+
+  it('stopping the watcher (effect)', async () => {
+    const state = reactive({ count: 0 })
+    let dummy
+    const stop = watchEffect(() => {
+      dummy = state.count
+    })
+    expect(dummy).toBe(0)
+
+    stop()
+    state.count++
+    await nextTick()
+    // should not update
+    expect(dummy).toBe(0)
+  })
+
+  it('stopping the watcher (with source)', async () => {
+    const state = reactive({ count: 0 })
+    let dummy
+    const stop = watch(
+      () => state.count,
+      count => {
+        dummy = count
+      }
+    )
+
+    state.count++
+    await nextTick()
+    expect(dummy).toBe(1)
+
+    stop()
+    state.count++
+    await nextTick()
+    // should not update
+    expect(dummy).toBe(1)
+  })
+
+  it('cleanup registration (effect)', async () => {
+    const state = reactive({ count: 0 })
+    const cleanup = vi.fn()
+    let dummy
+    const stop = watchEffect(onCleanup => {
+      onCleanup(cleanup)
+      dummy = state.count
+    })
+    expect(dummy).toBe(0)
+
+    state.count++
+    await nextTick()
+    expect(cleanup).toHaveBeenCalledTimes(1)
+    expect(dummy).toBe(1)
+
+    stop()
+    expect(cleanup).toHaveBeenCalledTimes(2)
+  })
+
+  it('cleanup registration (with source)', async () => {
+    const count = ref(0)
+    const cleanup = vi.fn()
+    let dummy
+    const stop = watch(count, (count, prevCount, onCleanup) => {
+      onCleanup(cleanup)
+      dummy = count
+    })
+
+    count.value++
+    await nextTick()
+    expect(cleanup).toHaveBeenCalledTimes(0)
+    expect(dummy).toBe(1)
+
+    count.value++
+    await nextTick()
+    expect(cleanup).toHaveBeenCalledTimes(1)
+    expect(dummy).toBe(2)
+
+    stop()
+    expect(cleanup).toHaveBeenCalledTimes(2)
+  })
+
+  it('flush timing: pre (default)', async () => {
+    const count = ref(0)
+    const count2 = ref(0)
+
+    let callCount = 0
+    let result1
+    let result2
+    const assertion = vi.fn((count, count2Value) => {
+      callCount++
+      // on mount, the watcher callback should be called before DOM render
+      // on update, should be called before the count is updated
+      const expectedDOM = callCount === 1 ? `` : `${count - 1}`
+      result1 = root.innerHTML === expectedDOM
+
+      // in a pre-flush callback, all state should have been updated
+      const expectedState = callCount - 1
+      result2 = count === expectedState && count2Value === expectedState
+    })
+
+    const Comp = {
+      setup() {
+        watchEffect(() => {
+          assertion(count.value, count2.value)
+        })
+        return () => count.value
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    expect(assertion).toHaveBeenCalledTimes(1)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+
+    count.value++
+    count2.value++
+    await nextTick()
+    // two mutations should result in 1 callback execution
+    expect(assertion).toHaveBeenCalledTimes(2)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+  })
+
+  it('flush timing: post', async () => {
+    const count = ref(0)
+    let result
+    const assertion = vi.fn(count => {
+      result = root.innerHTML === `${count}`
+    })
+
+    const Comp = {
+      setup() {
+        watchEffect(
+          () => {
+            assertion(count.value)
+          },
+          { flush: 'post' }
+        )
+        return () => count.value
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    expect(assertion).toHaveBeenCalledTimes(1)
+    expect(result).toBe(true)
+
+    count.value++
+    await nextTick()
+    expect(assertion).toHaveBeenCalledTimes(2)
+    expect(result).toBe(true)
+  })
+
+  it('watchPostEffect', async () => {
+    const count = ref(0)
+    let result
+    const assertion = vi.fn(count => {
+      result = root.innerHTML === `${count}`
+    })
+
+    const Comp = {
+      setup() {
+        watchPostEffect(() => {
+          assertion(count.value)
+        })
+        return () => count.value
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    expect(assertion).toHaveBeenCalledTimes(1)
+    expect(result).toBe(true)
+
+    count.value++
+    await nextTick()
+    expect(assertion).toHaveBeenCalledTimes(2)
+    expect(result).toBe(true)
+  })
+
+  it('flush timing: sync', async () => {
+    const count = ref(0)
+    const count2 = ref(0)
+
+    let callCount = 0
+    let result1
+    let result2
+    const assertion = vi.fn(count => {
+      callCount++
+      // on mount, the watcher callback should be called before DOM render
+      // on update, should be called before the count is updated
+      const expectedDOM = callCount === 1 ? `` : `${count - 1}`
+      result1 = root.innerHTML === expectedDOM
+
+      // in a sync callback, state mutation on the next line should not have
+      // executed yet on the 2nd call, but will be on the 3rd call.
+      const expectedState = callCount < 3 ? 0 : 1
+      result2 = count2.value === expectedState
+    })
+
+    const Comp = {
+      setup() {
+        watchEffect(
+          () => {
+            assertion(count.value)
+          },
+          {
+            flush: 'sync'
+          }
+        )
+        return () => count.value
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    expect(assertion).toHaveBeenCalledTimes(1)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+
+    count.value++
+    count2.value++
+    await nextTick()
+    expect(assertion).toHaveBeenCalledTimes(3)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+  })
+
+  it('watchSyncEffect', async () => {
+    const count = ref(0)
+    const count2 = ref(0)
+
+    let callCount = 0
+    let result1
+    let result2
+    const assertion = vi.fn(count => {
+      callCount++
+      // on mount, the watcher callback should be called before DOM render
+      // on update, should be called before the count is updated
+      const expectedDOM = callCount === 1 ? `` : `${count - 1}`
+      result1 = root.innerHTML === expectedDOM
+
+      // in a sync callback, state mutation on the next line should not have
+      // executed yet on the 2nd call, but will be on the 3rd call.
+      const expectedState = callCount < 3 ? 0 : 1
+      result2 = count2.value === expectedState
+    })
+
+    const Comp = {
+      setup() {
+        watchSyncEffect(() => {
+          assertion(count.value)
+        })
+        return () => count.value
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    expect(assertion).toHaveBeenCalledTimes(1)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+
+    count.value++
+    count2.value++
+    await nextTick()
+    expect(assertion).toHaveBeenCalledTimes(3)
+    expect(result1).toBe(true)
+    expect(result2).toBe(true)
+  })
+
+  it('should not fire on component unmount w/ flush: post', async () => {
+    const toggle = ref(true)
+    const cb = vi.fn()
+    const Comp = {
+      setup() {
+        watch(toggle, cb, { flush: 'post' })
+      },
+      render() {}
+    }
+    const App = {
+      render() {
+        return toggle.value ? h(Comp) : null
+      }
+    }
+    new Vue(App).$mount(document.createElement('div'))
+    expect(cb).not.toHaveBeenCalled()
+    toggle.value = false
+    await nextTick()
+    expect(cb).not.toHaveBeenCalled()
+  })
+
+  it('should fire on component unmount w/ flush: pre', async () => {
+    const toggle = ref(true)
+    const cb = vi.fn()
+    const Comp = {
+      setup() {
+        watch(toggle, cb, { flush: 'pre' })
+      },
+      render() {}
+    }
+    const App = {
+      render() {
+        return toggle.value ? h(Comp) : null
+      }
+    }
+    new Vue(App).$mount(document.createElement('div'))
+    expect(cb).not.toHaveBeenCalled()
+    toggle.value = false
+    await nextTick()
+    expect(cb).toHaveBeenCalledTimes(1)
+  })
+
+  // #1763
+  it('flush: pre watcher watching props should fire before child update', async () => {
+    const a = ref(0)
+    const b = ref(0)
+    const c = ref(0)
+    const calls: string[] = []
+
+    const Comp = {
+      props: ['a', 'b'],
+      setup(props: any) {
+        watch(
+          () => props.a + props.b,
+          () => {
+            calls.push('watcher 1')
+            c.value++
+          },
+          { flush: 'pre' }
+        )
+
+        // #1777 chained pre-watcher
+        watch(
+          c,
+          () => {
+            calls.push('watcher 2')
+          },
+          { flush: 'pre' }
+        )
+        return () => {
+          c.value
+          calls.push('render')
+        }
+      }
+    }
+
+    const App = {
+      render() {
+        return h(Comp, { props: { a: a.value, b: b.value } })
+      }
+    }
+
+    new Vue(App).$mount(document.createElement('div'))
+    expect(calls).toEqual(['render'])
+
+    // both props are updated
+    // should trigger pre-flush watcher first and only once
+    // then trigger child render
+    a.value++
+    b.value++
+    await nextTick()
+    expect(calls).toEqual(['render', 'watcher 1', 'watcher 2', 'render'])
+  })
+
+  // #5721
+  it('flush: pre triggered in component setup should be buffered and called before mounted', () => {
+    const count = ref(0)
+    const calls: string[] = []
+    const App = {
+      render() {},
+      setup() {
+        watch(
+          count,
+          () => {
+            calls.push('watch ' + count.value)
+          },
+          { flush: 'pre' }
+        )
+        onMounted(() => {
+          calls.push('mounted')
+        })
+        // mutate multiple times
+        count.value++
+        count.value++
+        count.value++
+      }
+    }
+    new Vue(App).$mount(document.createElement('div'))
+    expect(calls).toMatchObject(['watch 3', 'mounted'])
+  })
+
+  // #1852
+  it('flush: post watcher should fire after template refs updated', async () => {
+    const toggle = ref(false)
+    let dom: TestElement | null = null
+
+    const App = {
+      setup() {
+        const domRef = ref<TestElement | null>(null)
+
+        watch(
+          toggle,
+          () => {
+            dom = domRef.value
+          },
+          { flush: 'post' }
+        )
+
+        return () => {
+          return toggle.value ? h('p', { ref: domRef }) : null
+        }
+      }
+    }
+
+    new Vue(App).$mount(document.createElement('div'))
+    expect(dom).toBe(null)
+
+    toggle.value = true
+    await nextTick()
+    expect(dom!.tag).toBe('p')
+  })
+
+  it('deep', async () => {
+    const state = reactive({
+      nested: {
+        count: ref(0)
+      },
+      array: [1, 2, 3],
+      map: new Map([
+        ['a', 1],
+        ['b', 2]
+      ]),
+      set: new Set([1, 2, 3])
+    })
+
+    let dummy
+    watch(
+      () => state,
+      state => {
+        dummy = [
+          state.nested.count,
+          state.array[0],
+          state.map.get('a'),
+          state.set.has(1)
+        ]
+      },
+      { deep: true }
+    )
+
+    state.nested.count++
+    await nextTick()
+    expect(dummy).toEqual([1, 1, 1, true])
+
+    // nested array mutation
+    state.array[0] = 2
+    await nextTick()
+    expect(dummy).toEqual([1, 2, 1, true])
+
+    // nested map mutation
+    state.map.set('a', 2)
+    await nextTick()
+    expect(dummy).toEqual([1, 2, 2, true])
+
+    // nested set mutation
+    state.set.delete(1)
+    await nextTick()
+    expect(dummy).toEqual([1, 2, 2, false])
+  })
+
+  it('watching deep ref', async () => {
+    const count = ref(0)
+    const double = computed(() => count.value * 2)
+    const state = reactive([count, double])
+
+    let dummy
+    watch(
+      () => state,
+      state => {
+        dummy = [state[0].value, state[1].value]
+      },
+      { deep: true }
+    )
+
+    count.value++
+    await nextTick()
+    expect(dummy).toEqual([1, 2])
+  })
+
+  it('immediate', async () => {
+    const count = ref(0)
+    const cb = vi.fn()
+    watch(count, cb, { immediate: true })
+    expect(cb).toHaveBeenCalledTimes(1)
+    count.value++
+    await nextTick()
+    expect(cb).toHaveBeenCalledTimes(2)
+  })
+
+  it('immediate: triggers when initial value is null', async () => {
+    const state = ref(null)
+    const spy = vi.fn()
+    watch(() => state.value, spy, { immediate: true })
+    expect(spy).toHaveBeenCalled()
+  })
+
+  it('immediate: triggers when initial value is undefined', async () => {
+    const state = ref()
+    const spy = vi.fn()
+    watch(() => state.value, spy, { immediate: true })
+    expect(spy).toHaveBeenCalled()
+    state.value = 3
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(2)
+    // testing if undefined can trigger the watcher
+    state.value = undefined
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(3)
+    // it shouldn't trigger if the same value is set
+    state.value = undefined
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(3)
+  })
+
+  it('warn immediate option when using effect', async () => {
+    const count = ref(0)
+    let dummy
+    watchEffect(
+      () => {
+        dummy = count.value
+      },
+      // @ts-expect-error
+      { immediate: false }
+    )
+    expect(dummy).toBe(0)
+    expect(`"immediate" option is only respected`).toHaveBeenWarned()
+
+    count.value++
+    await nextTick()
+    expect(dummy).toBe(1)
+  })
+
+  it('warn and not respect deep option when using effect', async () => {
+    const arr = ref([1, [2]])
+    const spy = vi.fn()
+    watchEffect(
+      () => {
+        spy()
+        return arr
+      },
+      // @ts-expect-error
+      { deep: true }
+    )
+    expect(spy).toHaveBeenCalledTimes(1)
+    ;(arr.value[1] as Array<number>)[0] = 3
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(1)
+    expect(`"deep" option is only respected`).toHaveBeenWarned()
+  })
+
+  // TODO
+  // it('onTrack', async () => {
+  //   const events: DebuggerEvent[] = []
+  //   let dummy
+  //   const onTrack = vi.fn((e: DebuggerEvent) => {
+  //     events.push(e)
+  //   })
+  //   const obj = reactive({ foo: 1, bar: 2 })
+  //   watchEffect(
+  //     () => {
+  //       dummy = [obj.foo, 'bar' in obj, Object.keys(obj)]
+  //     },
+  //     { onTrack }
+  //   )
+  //   await nextTick()
+  //   expect(dummy).toEqual([1, true, ['foo', 'bar']])
+  //   expect(onTrack).toHaveBeenCalledTimes(3)
+  //   expect(events).toMatchObject([
+  //     {
+  //       target: obj,
+  //       type: TrackOpTypes.GET,
+  //       key: 'foo'
+  //     },
+  //     {
+  //       target: obj,
+  //       type: TrackOpTypes.HAS,
+  //       key: 'bar'
+  //     },
+  //     {
+  //       target: obj,
+  //       type: TrackOpTypes.ITERATE,
+  //       key: ITERATE_KEY
+  //     }
+  //   ])
+  // })
+
+  // it('onTrigger', async () => {
+  //   const events: DebuggerEvent[] = []
+  //   let dummy
+  //   const onTrigger = vi.fn((e: DebuggerEvent) => {
+  //     events.push(e)
+  //   })
+  //   const obj = reactive<{ foo?: number }>({ foo: 1 })
+  //   watchEffect(
+  //     () => {
+  //       dummy = obj.foo
+  //     },
+  //     { onTrigger }
+  //   )
+  //   await nextTick()
+  //   expect(dummy).toBe(1)
+
+  //   obj.foo!++
+  //   await nextTick()
+  //   expect(dummy).toBe(2)
+  //   expect(onTrigger).toHaveBeenCalledTimes(1)
+  //   expect(events[0]).toMatchObject({
+  //     type: TriggerOpTypes.SET,
+  //     key: 'foo',
+  //     oldValue: 1,
+  //     newValue: 2
+  //   })
+
+  //   delete obj.foo
+  //   await nextTick()
+  //   expect(dummy).toBeUndefined()
+  //   expect(onTrigger).toHaveBeenCalledTimes(2)
+  //   expect(events[1]).toMatchObject({
+  //     type: TriggerOpTypes.DELETE,
+  //     key: 'foo',
+  //     oldValue: 2
+  //   })
+  // })
+
+  it('should work sync', () => {
+    const v = ref(1)
+    let calls = 0
+
+    watch(
+      v,
+      () => {
+        ++calls
+      },
+      {
+        flush: 'sync'
+      }
+    )
+
+    expect(calls).toBe(0)
+    v.value++
+    expect(calls).toBe(1)
+  })
+
+  test('should force trigger on triggerRef when watching a shallow ref', async () => {
+    const v = shallowRef({ a: 1 })
+    let sideEffect = 0
+    watch(v, obj => {
+      sideEffect = obj.a
+    })
+
+    v.value = v.value
+    await nextTick()
+    // should not trigger
+    expect(sideEffect).toBe(0)
+
+    v.value.a++
+    await nextTick()
+    // should not trigger
+    expect(sideEffect).toBe(0)
+
+    triggerRef(v)
+    await nextTick()
+    // should trigger now
+    expect(sideEffect).toBe(2)
+  })
+
+  test('should force trigger on triggerRef when watching multiple sources: shallow ref array', async () => {
+    const v = shallowRef([] as any)
+    const spy = vi.fn()
+    watch([v], () => {
+      spy()
+    })
+
+    v.value.push(1)
+    triggerRef(v)
+
+    await nextTick()
+    // should trigger now
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  // #2125
+  test('watchEffect should not recursively trigger itself', async () => {
+    const spy = vi.fn()
+    const price = ref(10)
+    const history = ref<number[]>([])
+    watchEffect(() => {
+      history.value.push(price.value)
+      spy()
+    })
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  // #2231
+  test('computed refs should not trigger watch if value has no change', async () => {
+    const spy = vi.fn()
+    const source = ref(0)
+    const price = computed(() => source.value === 0)
+    watch(price, spy)
+    source.value++
+    await nextTick()
+    source.value++
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  // TODO
+  // https://github.com/vuejs/core/issues/2381
+  test.skip('$watch should always register its effects with its own instance', async () => {
+    let instance: Component | null
+    let _show: Ref<boolean>
+
+    const Child = {
+      render: () => h('div'),
+      mounted() {
+        instance = getCurrentInstance()!.proxy
+      },
+      unmounted() {}
+    }
+
+    const Comp = {
+      setup() {
+        const comp = ref<Component | undefined>()
+        const show = ref(true)
+        _show = show
+        return { comp, show }
+      },
+      render() {
+        return this.show
+          ? h(Child, {
+              ref: vm => void (this.comp = vm as Component)
+            })
+          : null
+      },
+      mounted() {
+        // this call runs while Comp is currentInstance, but
+        // the effect for this `$watch` should nontheless be registered with Child
+        this.comp!.$watch(
+          () => this.show,
+          () => void 0
+        )
+      }
+    }
+
+    new Vue(Comp).$mount(document.createElement('div'))
+
+    expect(instance!).toBeDefined()
+    expect(instance!.scope.effects).toBeInstanceOf(Array)
+    // includes the component's own render effect AND the watcher effect
+    expect(instance!.scope.effects.length).toBe(2)
+
+    _show!.value = false
+
+    await nextTick()
+    await nextTick()
+
+    expect(instance!.scope.effects[0].active).toBe(false)
+  })
+
+  test('this.$watch should pass `this.proxy` to watch source as the first argument ', () => {
+    let instance: any
+    const source = vi.fn()
+
+    const Comp = {
+      render() {},
+      created(this: any) {
+        instance = this
+        this.$watch(source, function () {})
+      }
+    }
+
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+
+    expect(instance).toBeDefined()
+    expect(source).toHaveBeenCalledWith(instance)
+  })
+
+  test('should not leak `this.proxy` to setup()', () => {
+    const source = vi.fn()
+
+    const Comp = {
+      render() {},
+      setup() {
+        watch(source, () => {})
+      }
+    }
+
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    // should not have any arguments
+    expect(source.mock.calls[0]).toMatchObject([])
+  })
+
+  // #2728
+  test('pre watcher callbacks should not track dependencies', async () => {
+    const a = ref(0)
+    const b = ref(0)
+    const updated = vi.fn()
+
+    const Child = {
+      props: ['a'],
+      updated,
+      watch: {
+        a() {
+          b.value
+        }
+      },
+      render() {
+        return h('div', this.a)
+      }
+    }
+
+    const Parent = {
+      render() {
+        return h(Child, { a: a.value })
+      }
+    }
+
+    const root = document.createElement('div')
+    new Vue(Parent).$mount(root)
+
+    a.value++
+    await nextTick()
+    expect(updated).toHaveBeenCalledTimes(1)
+
+    b.value++
+    await nextTick()
+    // should not track b as dependency of Child
+    expect(updated).toHaveBeenCalledTimes(1)
+  })
+
+  test('watching keypath', async () => {
+    const spy = vi.fn()
+    const Comp = {
+      render() {},
+      data() {
+        return {
+          a: {
+            b: 1
+          }
+        }
+      },
+      watch: {
+        'a.b': spy
+      },
+      created(this: any) {
+        this.$watch('a.b', spy)
+      },
+      mounted(this: any) {
+        this.a.b++
+      }
+    }
+
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(2)
+  })
+
+  it('watching sources: ref<any[]>', async () => {
+    const foo = ref([1])
+    const spy = vi.fn()
+    watch(foo, () => {
+      spy()
+    })
+    foo.value = foo.value.slice()
+    await nextTick()
+    expect(spy).toBeCalledTimes(1)
+  })
+
+  it('watching multiple sources: computed', async () => {
+    let count = 0
+    const value = ref('1')
+    const plus = computed(() => !!value.value)
+    watch([plus], () => {
+      count++
+    })
+    value.value = '2'
+    await nextTick()
+    expect(plus.value).toBe(true)
+    expect(count).toBe(0)
+  })
+
+  // #4158
+  // TODO
+  test.skip('watch should not register in owner component if created inside detached scope', () => {
+    let instance: Component
+    const Comp = {
+      setup() {
+        instance = getCurrentInstance()!.proxy
+        effectScope(true).run(() => {
+          watch(
+            () => 1,
+            () => {}
+          )
+        })
+        return () => ''
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    // should not record watcher in detached scope and only the instance's
+    // own update effect
+    expect(instance!.scope.effects.length).toBe(1)
+  })
+})
diff --git a/test/unit/features/composition-api/reactivity/computed.spec.ts b/test/unit/features/v3/reactivity/computed.spec.ts
similarity index 98%
rename from test/unit/features/composition-api/reactivity/computed.spec.ts
rename to test/unit/features/v3/reactivity/computed.spec.ts
index d4ca08939cc..5ca4ab4da6b 100644
--- a/test/unit/features/composition-api/reactivity/computed.spec.ts
+++ b/test/unit/features/v3/reactivity/computed.spec.ts
@@ -6,10 +6,10 @@ import {
   // toRaw,
   WritableComputedRef
   // DebuggerEvent
-} from 'vca/index'
-import { effect } from 'vca/reactivity/effect'
+} from 'v3'
+import { effect } from 'v3/reactivity/effect'
 import { nextTick } from 'core/util'
-// import { TrackOpTypes, TriggerOpTypes } from 'vca/reactivity/operations'
+// import { TrackOpTypes, TriggerOpTypes } from 'v3/reactivity/operations'
 
 describe('reactivity/computed', () => {
   it('should return updated value', () => {
diff --git a/test/unit/features/composition-api/reactivity/reactive.spec.ts b/test/unit/features/v3/reactivity/reactive.spec.ts
similarity index 98%
rename from test/unit/features/composition-api/reactivity/reactive.spec.ts
rename to test/unit/features/v3/reactivity/reactive.spec.ts
index 28fcedf78f2..e5e381d71df 100644
--- a/test/unit/features/composition-api/reactivity/reactive.spec.ts
+++ b/test/unit/features/v3/reactivity/reactive.spec.ts
@@ -1,14 +1,6 @@
-import {
-  ref,
-  isRef,
-  reactive,
-  isReactive,
-  toRaw,
-  markRaw,
-  computed
-} from 'vca/index'
+import { ref, isRef, reactive, isReactive, toRaw, markRaw, computed } from 'v3'
 import { set } from 'core/observer'
-import { effect } from 'vca/reactivity/effect'
+import { effect } from 'v3/reactivity/effect'
 
 describe('reactivity/reactive', () => {
   test('Object', () => {
diff --git a/test/unit/features/composition-api/reactivity/readonly.spec.ts b/test/unit/features/v3/reactivity/readonly.spec.ts
similarity index 99%
rename from test/unit/features/composition-api/reactivity/readonly.spec.ts
rename to test/unit/features/v3/reactivity/readonly.spec.ts
index d413dc043af..ab4c52f7ce7 100644
--- a/test/unit/features/composition-api/reactivity/readonly.spec.ts
+++ b/test/unit/features/v3/reactivity/readonly.spec.ts
@@ -7,8 +7,8 @@ import {
   markRaw,
   ref,
   isProxy
-} from 'vca/index'
-import { effect } from 'vca/reactivity/effect'
+} from 'v3'
+import { effect } from 'v3/reactivity/effect'
 import { set, del } from 'core/observer'
 
 /**
diff --git a/test/unit/features/composition-api/reactivity/ref.spec.ts b/test/unit/features/v3/reactivity/ref.spec.ts
similarity index 99%
rename from test/unit/features/composition-api/reactivity/ref.spec.ts
rename to test/unit/features/v3/reactivity/ref.spec.ts
index 720e6e812b6..78498a29d25 100644
--- a/test/unit/features/composition-api/reactivity/ref.spec.ts
+++ b/test/unit/features/v3/reactivity/ref.spec.ts
@@ -11,8 +11,8 @@ import {
   isReactive,
   isShallow,
   reactive
-} from 'vca/index'
-import { effect } from 'vca/reactivity/effect'
+} from 'v3'
+import { effect } from 'v3/reactivity/effect'
 
 describe('reactivity/ref', () => {
   it('should hold a value', () => {
diff --git a/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts b/test/unit/features/v3/reactivity/shallowReactive.spec.ts
similarity index 99%
rename from test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
rename to test/unit/features/v3/reactivity/shallowReactive.spec.ts
index d4c4619878e..5d86bb85d82 100644
--- a/test/unit/features/composition-api/reactivity/shallowReactive.spec.ts
+++ b/test/unit/features/v3/reactivity/shallowReactive.spec.ts
@@ -4,7 +4,7 @@ import {
   reactive,
   shallowReactive,
   shallowReadonly
-} from 'vca/index'
+} from 'v3'
 
 describe('shallowReactive', () => {
   test('should not make non-reactive properties reactive', () => {
diff --git a/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts b/test/unit/features/v3/reactivity/shallowReadonly.spec.ts
similarity index 99%
rename from test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts
rename to test/unit/features/v3/reactivity/shallowReadonly.spec.ts
index 82432d32423..6ac3578c675 100644
--- a/test/unit/features/composition-api/reactivity/shallowReadonly.spec.ts
+++ b/test/unit/features/v3/reactivity/shallowReadonly.spec.ts
@@ -1,4 +1,4 @@
-import { isReactive, shallowReadonly, readonly, isReadonly } from 'vca/index'
+import { isReactive, shallowReadonly, readonly, isReadonly } from 'v3'
 
 describe('reactivity/shallowReadonly', () => {
   test('should be readonly', () => {
diff --git a/tsconfig.json b/tsconfig.json
index 3d6f0b6926e..9db0172bd6d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -23,14 +23,12 @@
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
-
       "server/*": ["src/server/*"],
       "sfc/*": ["src/sfc/*"],
       "shared/*": ["src/shared/*"],
-
       "web/*": ["src/platforms/web/*"],
-      "vca/*": ["src/composition-api/*"],
-
+      "v3": ["src/v3/index"],
+      "v3/*": ["src/v3/*"],
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
diff --git a/vitest.config.ts b/vitest.config.ts
index 09f725ddf70..9db404dcae8 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -12,7 +12,7 @@ export default defineConfig({
       sfc: resolve('src/sfc'),
       shared: resolve('src/shared'),
       web: resolve('src/platforms/web'),
-      vca: resolve('src/composition-api'),
+      v3: resolve('src/v3'),
       vue: resolve('src/platforms/web/entry-runtime-with-compiler')
     }
   },

From 12150f622b3b469904240390eaf4ccdd49eedbbb Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 17:30:12 +0800
Subject: [PATCH 084/317] chore: format typescript dir

---
 typescript/compiler.d.ts | 352 +++++++++++++++++++--------------------
 typescript/modules.d.ts  |  12 +-
 typescript/options.d.ts  | 144 ++++++++--------
 typescript/ssr.d.ts      |  34 ++--
 typescript/vnode.d.ts    | 134 +++++++--------
 5 files changed, 343 insertions(+), 333 deletions(-)

diff --git a/typescript/compiler.d.ts b/typescript/compiler.d.ts
index 68d596fae82..5dec6bc3506 100644
--- a/typescript/compiler.d.ts
+++ b/typescript/compiler.d.ts
@@ -1,224 +1,224 @@
 declare type CompilerOptions = {
-  warn?: Function; // allow customizing warning in different environments; e.g. node
-  modules?: Array<ModuleOptions>; // platform specific modules; e.g. style; class
-  directives?: { [key: string]: Function }; // platform specific directives
-  staticKeys?: string; // a list of AST properties to be considered static; for optimization
-  isUnaryTag?: (tag: string) => boolean | undefined; // check if a tag is unary for the platform
-  canBeLeftOpenTag?: (tag: string) => boolean | undefined; // check if a tag can be left opened
-  isReservedTag?: (tag: string) => boolean | undefined; // check if a tag is a native for the platform
-  preserveWhitespace?: boolean; // preserve whitespace between elements? (Deprecated)
-  whitespace?: "preserve" | "condense"; // whitespace handling strategy
-  optimize?: boolean; // optimize static content?
+  warn?: Function // allow customizing warning in different environments; e.g. node
+  modules?: Array<ModuleOptions> // platform specific modules; e.g. style; class
+  directives?: { [key: string]: Function } // platform specific directives
+  staticKeys?: string // a list of AST properties to be considered static; for optimization
+  isUnaryTag?: (tag: string) => boolean | undefined // check if a tag is unary for the platform
+  canBeLeftOpenTag?: (tag: string) => boolean | undefined // check if a tag can be left opened
+  isReservedTag?: (tag: string) => boolean | undefined // check if a tag is a native for the platform
+  preserveWhitespace?: boolean // preserve whitespace between elements? (Deprecated)
+  whitespace?: 'preserve' | 'condense' // whitespace handling strategy
+  optimize?: boolean // optimize static content?
 
   // web specific
-  mustUseProp?: (tag: string, type: string | null, name: string) => boolean; // check if an attribute should be bound as a property
-  isPreTag?: (attr: string) => boolean | null; // check if a tag needs to preserve whitespace
-  getTagNamespace?: (tag: string) => string | undefined; // check the namespace for a tag
-  expectHTML?: boolean; // only false for non-web builds
-  isFromDOM?: boolean;
-  shouldDecodeTags?: boolean;
-  shouldDecodeNewlines?: boolean;
-  shouldDecodeNewlinesForHref?: boolean;
-  outputSourceRange?: boolean;
+  mustUseProp?: (tag: string, type: string | null, name: string) => boolean // check if an attribute should be bound as a property
+  isPreTag?: (attr: string) => boolean | null // check if a tag needs to preserve whitespace
+  getTagNamespace?: (tag: string) => string | undefined // check the namespace for a tag
+  expectHTML?: boolean // only false for non-web builds
+  isFromDOM?: boolean
+  shouldDecodeTags?: boolean
+  shouldDecodeNewlines?: boolean
+  shouldDecodeNewlinesForHref?: boolean
+  outputSourceRange?: boolean
 
   // runtime user-configurable
-  delimiters?: [string, string]; // template delimiters
-  comments?: boolean; // preserve comments in template
+  delimiters?: [string, string] // template delimiters
+  comments?: boolean // preserve comments in template
 
   // for ssr optimization compiler
-  scopeId?: string;
-};
+  scopeId?: string
+}
 
 declare type WarningMessage = {
-  msg: string;
-  start?: number;
-  end?: number;
-};
+  msg: string
+  start?: number
+  end?: number
+}
 
 declare type CompiledResult = {
-  ast: ASTElement | null;
-  render: string;
-  staticRenderFns: Array<string>;
-  stringRenderFns?: Array<string>;
-  errors?: Array<string | WarningMessage>;
-  tips?: Array<string | WarningMessage>;
-};
+  ast: ASTElement | null
+  render: string
+  staticRenderFns: Array<string>
+  stringRenderFns?: Array<string>
+  errors?: Array<string | WarningMessage>
+  tips?: Array<string | WarningMessage>
+}
 
 declare type ModuleOptions = {
   // transform an AST node before any attributes are processed
   // returning an ASTElement from pre/transforms replaces the element
-  preTransformNode: (el: ASTElement) => ASTElement | null;
+  preTransformNode: (el: ASTElement) => ASTElement | null
   // transform an AST node after built-ins like v-if, v-for are processed
-  transformNode: (el: ASTElement) => ASTElement | null;
+  transformNode: (el: ASTElement) => ASTElement | null
   // transform an AST node after its children have been processed
   // cannot return replacement in postTransform because tree is already finalized
-  postTransformNode: (el: ASTElement) => void;
-  genData: (el: ASTElement) => string; // generate extra data string for an element
-  transformCode?: (el: ASTElement, code: string) => string; // further transform generated code for an element
-  staticKeys?: Array<string>; // AST properties to be considered static
-};
+  postTransformNode: (el: ASTElement) => void
+  genData: (el: ASTElement) => string // generate extra data string for an element
+  transformCode?: (el: ASTElement, code: string) => string // further transform generated code for an element
+  staticKeys?: Array<string> // AST properties to be considered static
+}
 
-declare type ASTModifiers = { [key: string]: boolean };
-declare type ASTIfCondition = { exp: string | null; block: ASTElement };
-declare type ASTIfConditions = Array<ASTIfCondition>;
+declare type ASTModifiers = { [key: string]: boolean }
+declare type ASTIfCondition = { exp: string | null; block: ASTElement }
+declare type ASTIfConditions = Array<ASTIfCondition>
 
 declare type ASTAttr = {
-  name: string;
-  value: any;
-  dynamic?: boolean;
-  start?: number;
-  end?: number;
-};
+  name: string
+  value: any
+  dynamic?: boolean
+  start?: number
+  end?: number
+}
 
 declare type ASTElementHandler = {
-  value: string;
-  params?: Array<any>;
-  modifiers: ASTModifiers | null;
-  dynamic?: boolean;
-  start?: number;
-  end?: number;
-};
+  value: string
+  params?: Array<any>
+  modifiers: ASTModifiers | null
+  dynamic?: boolean
+  start?: number
+  end?: number
+}
 
 declare type ASTElementHandlers = {
-  [key: string]: ASTElementHandler | Array<ASTElementHandler>;
-};
+  [key: string]: ASTElementHandler | Array<ASTElementHandler>
+}
 
 declare type ASTDirective = {
-  name: string;
-  rawName: string;
-  value: string;
-  arg: string | null;
-  isDynamicArg: boolean;
-  modifiers: ASTModifiers | null;
-  start?: number;
-  end?: number;
-};
-
-declare type ASTNode = ASTElement | ASTText | ASTExpression;
+  name: string
+  rawName: string
+  value: string
+  arg: string | null
+  isDynamicArg: boolean
+  modifiers: ASTModifiers | null
+  start?: number
+  end?: number
+}
+
+declare type ASTNode = ASTElement | ASTText | ASTExpression
 
 declare type ASTElement = {
-  type: 1;
-  tag: string;
-  attrsList: Array<ASTAttr>;
-  attrsMap: { [key: string]: any };
-  rawAttrsMap: { [key: string]: ASTAttr };
-  parent: ASTElement | void;
-  children: Array<ASTNode>;
-
-  start?: number;
-  end?: number;
-
-  processed?: true;
-
-  static?: boolean;
-  staticRoot?: boolean;
-  staticInFor?: boolean;
-  staticProcessed?: boolean;
-  hasBindings?: boolean;
-
-  text?: string;
-  attrs?: Array<ASTAttr>;
-  dynamicAttrs?: Array<ASTAttr>;
-  props?: Array<ASTAttr>;
-  plain?: boolean;
-  pre?: true;
-  ns?: string;
-
-  component?: string;
-  inlineTemplate?: true;
-  transitionMode?: string | null;
-  slotName?: string | null;
-  slotTarget?: string | null;
-  slotTargetDynamic?: boolean;
-  slotScope?: string | null;
-  scopedSlots?: { [name: string]: ASTElement };
-
-  ref?: string;
-  refInFor?: boolean;
-
-  if?: string;
-  ifProcessed?: boolean;
-  elseif?: string;
-  else?: true;
-  ifConditions?: ASTIfConditions;
-
-  for?: string;
-  forProcessed?: boolean;
-  key?: string;
-  alias?: string;
-  iterator1?: string;
-  iterator2?: string;
-
-  staticClass?: string;
-  classBinding?: string;
-  staticStyle?: string;
-  styleBinding?: string;
-  events?: ASTElementHandlers;
-  nativeEvents?: ASTElementHandlers;
-
-  transition?: string | true;
-  transitionOnAppear?: boolean;
+  type: 1
+  tag: string
+  attrsList: Array<ASTAttr>
+  attrsMap: { [key: string]: any }
+  rawAttrsMap: { [key: string]: ASTAttr }
+  parent: ASTElement | void
+  children: Array<ASTNode>
+
+  start?: number
+  end?: number
+
+  processed?: true
+
+  static?: boolean
+  staticRoot?: boolean
+  staticInFor?: boolean
+  staticProcessed?: boolean
+  hasBindings?: boolean
+
+  text?: string
+  attrs?: Array<ASTAttr>
+  dynamicAttrs?: Array<ASTAttr>
+  props?: Array<ASTAttr>
+  plain?: boolean
+  pre?: true
+  ns?: string
+
+  component?: string
+  inlineTemplate?: true
+  transitionMode?: string | null
+  slotName?: string | null
+  slotTarget?: string | null
+  slotTargetDynamic?: boolean
+  slotScope?: string | null
+  scopedSlots?: { [name: string]: ASTElement }
+
+  ref?: string
+  refInFor?: boolean
+
+  if?: string
+  ifProcessed?: boolean
+  elseif?: string
+  else?: true
+  ifConditions?: ASTIfConditions
+
+  for?: string
+  forProcessed?: boolean
+  key?: string
+  alias?: string
+  iterator1?: string
+  iterator2?: string
+
+  staticClass?: string
+  classBinding?: string
+  staticStyle?: string
+  styleBinding?: string
+  events?: ASTElementHandlers
+  nativeEvents?: ASTElementHandlers
+
+  transition?: string | true
+  transitionOnAppear?: boolean
 
   model?: {
-    value: string;
-    callback: string;
-    expression: string;
-  };
+    value: string
+    callback: string
+    expression: string
+  }
 
-  directives?: Array<ASTDirective>;
+  directives?: Array<ASTDirective>
 
-  forbidden?: true;
-  once?: true;
-  onceProcessed?: boolean;
-  wrapData?: (code: string) => string;
-  wrapListeners?: (code: string) => string;
+  forbidden?: true
+  once?: true
+  onceProcessed?: boolean
+  wrapData?: (code: string) => string
+  wrapListeners?: (code: string) => string
 
   // 2.4 ssr optimization
-  ssrOptimizability?: number;
-};
+  ssrOptimizability?: number
+}
 
 declare type ASTExpression = {
-  type: 2;
-  expression: string;
-  text: string;
-  tokens: Array<string | Object>;
-  static?: boolean;
+  type: 2
+  expression: string
+  text: string
+  tokens: Array<string | Object>
+  static?: boolean
   // 2.4 ssr optimization
-  ssrOptimizability?: number;
-  start?: number;
-  end?: number;
-};
+  ssrOptimizability?: number
+  start?: number
+  end?: number
+}
 
 declare type ASTText = {
-  type: 3;
-  text: string;
-  static?: boolean;
-  isComment?: boolean;
+  type: 3
+  text: string
+  static?: boolean
+  isComment?: boolean
   // 2.4 ssr optimization
-  ssrOptimizability?: number;
-  start?: number;
-  end?: number;
-};
+  ssrOptimizability?: number
+  start?: number
+  end?: number
+}
 
 // SFC-parser related declarations
 
 // an object format describing a single-file component
 declare type SFCDescriptor = {
-  template: SFCBlock | null;
-  script: SFCBlock | null;
-  styles: Array<SFCBlock>;
-  customBlocks: Array<SFCBlock>;
-  errors: Array<string | WarningMessage>;
-};
+  template: SFCBlock | null
+  script: SFCBlock | null
+  styles: Array<SFCBlock>
+  customBlocks: Array<SFCBlock>
+  errors: Array<string | WarningMessage>
+}
 
 declare type SFCBlock = {
-  type: string;
-  content: string;
-  attrs: { [attribute: string]: string };
-  start?: number;
-  end?: number;
-  lang?: string;
-  src?: string;
-  scoped?: boolean;
-  module?: string | boolean;
-};
+  type: string
+  content: string
+  attrs: { [attribute: string]: string }
+  start?: number
+  end?: number
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
+}
diff --git a/typescript/modules.d.ts b/typescript/modules.d.ts
index 0f97add3161..814033a1945 100644
--- a/typescript/modules.d.ts
+++ b/typescript/modules.d.ts
@@ -1,15 +1,15 @@
 declare module 'de-indent' {
-  export default function deindent (input: string): string
+  export default function deindent(input: string): string
 }
 
 declare namespace jasmine {
   interface Matchers<T> {
-    toHaveBeenWarned(): void;
-    toHaveBeenTipped(): void;
+    toHaveBeenWarned(): void
+    toHaveBeenTipped(): void
   }
 
   interface ArrayLikeMatchers<T> {
-    toHaveBeenWarned(): void;
-    toHaveBeenTipped(): void;
+    toHaveBeenWarned(): void
+    toHaveBeenTipped(): void
   }
-}
\ No newline at end of file
+}
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
index b562a913235..e53a909edeb 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.d.ts
@@ -1,102 +1,112 @@
-import VNode from "../src/core/vdom/vnode";
-import { Component } from "./component";
+import VNode from '../src/core/vdom/vnode'
+import { Component } from './component'
 
 declare type InternalComponentOptions = {
-  _isComponent: true;
-  parent: Component;
-  _parentVnode: VNode;
-  render?: Function;
-  staticRenderFns?: Array<Function>;
-};
+  _isComponent: true
+  parent: Component
+  _parentVnode: VNode
+  render?: Function
+  staticRenderFns?: Array<Function>
+}
 
-type InjectKey = string | Symbol;
+type InjectKey = string | Symbol
+
+declare interface SetupContext {
+  attrs: Record<string, any>
+  slots: Record<string, (() => VNode[]) | undefined>
+  emit: (event: string, ...args: any[]) => any
+  expose: (exposed?: Record<string, any>) => void
+}
 
 declare type ComponentOptions = {
+  // v3
+  setup(props: Record<string, any>, ctx: SetupContext): any
+
   [key: string]: any
 
-  componentId?: string;
+  componentId?: string
 
   // data
-  data: object | Function | void;
-  props?: { [key: string]: PropOptions };
-  propsData?: object;
+  data: object | Function | void
+  props?: { [key: string]: PropOptions }
+  propsData?: object
   computed?: {
     [key: string]:
       | Function
       | {
-          get?: Function;
-          set?: Function;
-          cache?: boolean;
-        };
-  };
-  methods?: { [key: string]: Function };
-  watch?: { [key: string]: Function | string };
+          get?: Function
+          set?: Function
+          cache?: boolean
+        }
+  }
+  methods?: { [key: string]: Function }
+  watch?: { [key: string]: Function | string }
 
   // DOM
-  el?: string | Element;
-  template?: string;
-  render: (h: () => VNode) => VNode;
-  renderError?: (h: () => VNode, err: Error) => VNode;
-  staticRenderFns?: Array<() => VNode>;
+  el?: string | Element
+  template?: string
+  render: (h: () => VNode) => VNode
+  renderError?: (h: () => VNode, err: Error) => VNode
+  staticRenderFns?: Array<() => VNode>
 
   // lifecycle
-  beforeCreate?: Function;
-  created?: Function;
-  beforeMount?: Function;
-  mounted?: Function;
-  beforeUpdate?: Function;
-  updated?: Function;
-  activated?: Function;
-  deactivated?: Function;
-  beforeDestroy?: Function;
-  destroyed?: Function;
-  errorCaptured?: () => boolean | void;
-  serverPrefetch?: Function;
+  beforeCreate?: Function
+  created?: Function
+  beforeMount?: Function
+  mounted?: Function
+  beforeUpdate?: Function
+  updated?: Function
+  activated?: Function
+  deactivated?: Function
+  beforeDestroy?: Function
+  destroyed?: Function
+  errorCaptured?: () => boolean | void
+  serverPrefetch?: Function
 
   // assets
-  directives?: { [key: string]: object };
-  components?: { [key: string]: Component };
-  transitions?: { [key: string]: object };
-  filters?: { [key: string]: Function };
+  directives?: { [key: string]: object }
+  components?: { [key: string]: Component }
+  transitions?: { [key: string]: object }
+  filters?: { [key: string]: Function }
 
   // context
-  provide?: Record<string | symbol, any> | (() => Record<string | symbol, any>);
+  provide?: Record<string | symbol, any> | (() => Record<string | symbol, any>)
   inject?:
     | { [key: string]: InjectKey | { from?: InjectKey; default?: any } }
-    | Array<string>;
+    | Array<string>
 
   // component v-model customization
   model?: {
-    prop?: string;
-    event?: string;
-  };
+    prop?: string
+    event?: string
+  }
 
   // misc
-  parent?: Component;
-  mixins?: Array<object>;
-  name?: string;
-  extends?: Component | object;
-  delimiters?: [string, string];
-  comments?: boolean;
-  inheritAttrs?: boolean;
+  parent?: Component
+  mixins?: Array<object>
+  name?: string
+  extends?: Component | object
+  delimiters?: [string, string]
+  comments?: boolean
+  inheritAttrs?: boolean
 
   // Class API
   abstract?: any
 
   // private
-  _isComponent?: true;
-  _propKeys?: Array<string>;
-  _parentVnode?: VNode;
-  _parentListeners?: object | null;
-  _renderChildren?: Array<VNode> | null;
-  _componentTag: string | null;
-  _scopeId: string | null;
-  _base: Component;
-};
+  _isComponent?: true
+  _propKeys?: Array<string>
+  _parentVnode?: VNode
+  _parentListeners?: object | null
+  _renderChildren?: Array<VNode> | null
+  _componentTag: string | null
+  _scopeId: string | null
+  _base: Component
+}
 
 declare type PropOptions = {
-  type: Function | Array<Function> | null;
-  default: any;
-  required: boolean | null;
-  validator: Function | null;
-};
+  type: Function | Array<Function> | null
+  default: any
+  required: boolean | null
+  validator: Function | null
+}
diff --git a/typescript/ssr.d.ts b/typescript/ssr.d.ts
index 2f351f2164c..3a2be3c5f77 100644
--- a/typescript/ssr.d.ts
+++ b/typescript/ssr.d.ts
@@ -1,27 +1,27 @@
-import VNode from "../src/core/vdom/vnode";
-import { Component } from "./component";
+import VNode from '../src/core/vdom/vnode'
+import { Component } from './component'
 
 declare type ComponentWithCacheContext = {
-  type: "ComponentWithCache";
-  bufferIndex: number;
-  buffer: Array<string>;
-  key: string;
-};
+  type: 'ComponentWithCache'
+  bufferIndex: number
+  buffer: Array<string>
+  key: string
+}
 
 declare type ElementContext = {
-  type: "Element";
-  children: Array<VNode>;
-  rendered: number;
-  endTag: string;
-  total: number;
-};
+  type: 'Element'
+  children: Array<VNode>
+  rendered: number
+  endTag: string
+  total: number
+}
 
 declare type ComponentContext = {
-  type: "Component";
-  prevActive: Component;
-};
+  type: 'Component'
+  prevActive: Component
+}
 
 declare type RenderState =
   | ComponentContext
   | ComponentWithCacheContext
-  | ElementContext;
+  | ElementContext
diff --git a/typescript/vnode.d.ts b/typescript/vnode.d.ts
index 1dd467cc22c..8cef05cd42a 100644
--- a/typescript/vnode.d.ts
+++ b/typescript/vnode.d.ts
@@ -1,41 +1,41 @@
-import VNode from "../src/core/vdom/vnode";
-import { Component } from "./component";
+import VNode from '../src/core/vdom/vnode'
+import { Component } from './component'
 
 declare type VNodeChildren =
   | Array<null | VNode | string | VNodeChildren>
-  | string;
+  | string
 
 declare type VNodeComponentOptions = {
-  Ctor: Component;
-  propsData?: Object;
-  listeners?: Record<string, Function | Function[]>;
-  children?: Array<VNode>;
-  tag?: string;
-};
+  Ctor: Component
+  propsData?: Object
+  listeners?: Record<string, Function | Function[]>
+  children?: Array<VNode>
+  tag?: string
+}
 
 declare type MountedComponentVNode = VNode & {
-  context: Component;
-  componentOptions: VNodeComponentOptions;
-  componentInstance: Component;
-  parent: VNode;
-  data: VNodeData;
-};
+  context: Component
+  componentOptions: VNodeComponentOptions
+  componentInstance: Component
+  parent: VNode
+  data: VNodeData
+}
 
 // interface for vnodes in update modules
 declare type VNodeWithData = VNode & {
-  tag: string;
-  data: VNodeData;
-  children: Array<VNode>;
-  text: void;
-  elm: any;
-  ns: string | void;
-  context: Component;
-  key: string | number | undefined;
-  parent?: VNodeWithData;
-  componentOptions?: VNodeComponentOptions;
-  componentInstance?: Component;
-  isRootInsert: boolean;
-};
+  tag: string
+  data: VNodeData
+  children: Array<VNode>
+  text: void
+  elm: any
+  ns: string | void
+  context: Component
+  key: string | number | undefined
+  parent?: VNodeWithData
+  componentOptions?: VNodeComponentOptions
+  componentInstance?: Component
+  isRootInsert: boolean
+}
 
 // // interface for vnodes in update modules
 // declare type VNodeWithData = {
@@ -54,51 +54,51 @@ declare type VNodeWithData = VNode & {
 // };
 
 declare interface VNodeData {
-  key?: string | number;
-  slot?: string;
-  ref?: string;
-  is?: string;
-  pre?: boolean;
-  tag?: string;
-  staticClass?: string;
-  class?: any;
-  staticStyle?: { [key: string]: any };
-  style?: string | Array<Object> | Object;
-  normalizedStyle?: Object;
-  props?: { [key: string]: any };
-  attrs?: { [key: string]: string };
-  domProps?: { [key: string]: any };
-  hook?: { [key: string]: Function };
-  on?: { [key: string]: Function | Array<Function> };
-  nativeOn?: { [key: string]: Function | Array<Function> };
-  transition?: Object;
-  show?: boolean; // marker for v-show
+  key?: string | number
+  slot?: string
+  ref?: string
+  is?: string
+  pre?: boolean
+  tag?: string
+  staticClass?: string
+  class?: any
+  staticStyle?: { [key: string]: any }
+  style?: string | Array<Object> | Object
+  normalizedStyle?: Object
+  props?: { [key: string]: any }
+  attrs?: { [key: string]: string }
+  domProps?: { [key: string]: any }
+  hook?: { [key: string]: Function }
+  on?: { [key: string]: Function | Array<Function> }
+  nativeOn?: { [key: string]: Function | Array<Function> }
+  transition?: Object
+  show?: boolean // marker for v-show
   inlineTemplate?: {
-    render: Function;
-    staticRenderFns: Array<Function>;
-  };
-  directives?: Array<VNodeDirective>;
-  keepAlive?: boolean;
-  scopedSlots?: { [key: string]: Function };
+    render: Function
+    staticRenderFns: Array<Function>
+  }
+  directives?: Array<VNodeDirective>
+  keepAlive?: boolean
+  scopedSlots?: { [key: string]: Function }
   model?: {
-    value: any;
-    callback: Function;
-  };
+    value: any
+    callback: Function
+  }
 
-  [key: string]: any;
+  [key: string]: any
 }
 
 declare type VNodeDirective = {
-  name: string;
-  rawName: string;
-  value?: any;
-  oldValue?: any;
-  arg?: string;
-  oldArg?: string;
-  modifiers?: ASTModifiers;
-  def?: Object;
-};
+  name: string
+  rawName: string
+  value?: any
+  oldValue?: any
+  arg?: string
+  oldArg?: string
+  modifiers?: ASTModifiers
+  def?: Object
+}
 
 declare type ScopedSlotsData = Array<
   { key: string; fn: Function } | ScopedSlotsData
->;
+>

From 1e4ac46fe5b99a9d7b0a87506466e34d1ffa90eb Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 23:40:03 +0800
Subject: [PATCH 085/317] wip: lifecycle api

---
 src/core/instance/lifecycle.ts             |   9 +
 src/core/instance/render.ts                | 116 +++++----
 src/core/instance/state.ts                 |   5 +
 src/core/util/error.ts                     |   4 +-
 src/core/util/options.ts                   |   4 +-
 src/shared/util.ts                         |   8 +-
 src/v3/apiLifecycle.ts                     |  46 +++-
 src/v3/apiSetup.ts                         | 114 +++++++++
 src/v3/currentInstance.ts                  |   2 +-
 src/v3/h.ts                                |  11 +-
 src/v3/index.ts                            |   3 +
 test/unit/features/v3/apiLifecycle.spec.ts | 284 +++++++++++++++++++++
 test/unit/features/v3/apiSetup.spec.ts     |   0
 test/unit/features/v3/apiWatch.spec.ts     |  17 +-
 types/v3.d.ts                              |   1 -
 typescript/component.d.ts                  |   7 +-
 typescript/options.d.ts                    |   5 +-
 typescript/vnode.d.ts                      |   2 +-
 18 files changed, 551 insertions(+), 87 deletions(-)
 create mode 100644 src/v3/apiSetup.ts
 create mode 100644 test/unit/features/v3/apiLifecycle.spec.ts
 create mode 100644 test/unit/features/v3/apiSetup.spec.ts

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 7329560929b..86300cfbbd8 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -17,6 +17,8 @@ import {
   validateProp,
   invokeWithErrorHandling
 } from '../util/index'
+import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
+import { syncObject } from 'v3/apiSetup'
 
 export let activeInstance: any = null
 export let isUpdatingChildComponent: boolean = false
@@ -270,6 +272,10 @@ export function updateChildComponent(
   // these are also reactive so they may trigger child update if the child
   // used them during render
   vm.$attrs = parentVnode.data.attrs || emptyObject
+  if (vm._attrsProxy) {
+    syncObject(vm._attrsProxy, vm.$attrs)
+  }
+
   vm.$listeners = listeners || emptyObject
 
   // update props
@@ -348,6 +354,8 @@ export function deactivateChildComponent(vm: Component, direct?: boolean) {
 export function callHook(vm: Component, hook: string) {
   // #7573 disable dep collection when invoking lifecycle hooks
   pushTarget()
+  const prev = currentInstance
+  setCurrentInstance(vm)
   const handlers = vm.$options[hook]
   const info = `${hook} hook`
   if (handlers) {
@@ -358,5 +366,6 @@ export function callHook(vm: Component, hook: string) {
   if (vm._hasHookEvent) {
     vm.$emit('hook:' + hook)
   }
+  setCurrentInstance(prev)
   popTarget()
 }
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 4da1b2f3b50..78c06e6eff9 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -15,6 +15,8 @@ import VNode, { createEmptyVNode } from '../vdom/vnode'
 
 import { isUpdatingChildComponent } from './lifecycle'
 import type { Component } from 'typescript/component'
+import { setCurrentInstance } from 'v3/currentInstance'
+import { syncObject } from 'v3/apiSetup'
 
 export function initRender(vm: Component) {
   vm._vnode = null // the root of the child tree
@@ -95,65 +97,73 @@ export function renderMixin(Vue: Component) {
   Vue.prototype._render = function (): VNode {
     const vm: Component = this
     const { render, _parentVnode } = vm.$options
+    setCurrentInstance(vm)
 
-    if (_parentVnode) {
-      vm.$scopedSlots = normalizeScopedSlots(
-        _parentVnode.data!.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
-      )
-    }
-
-    // set parent vnode. this allows render functions to have access
-    // to the data on the placeholder node.
-    vm.$vnode = _parentVnode!
-    // render self
-    let vnode
     try {
-      // There's no need to maintain a stack because all render fns are called
-      // separately from one another. Nested component's render fns are called
-      // when parent component is patched.
-      currentRenderingInstance = vm
-      vnode = render.call(vm._renderProxy, vm.$createElement)
-    } catch (e: any) {
-      handleError(e, vm, `render`)
-      // return error render result,
-      // or previous vnode to prevent render error causing blank component
-      /* istanbul ignore else */
-      if (__DEV__ && vm.$options.renderError) {
-        try {
-          vnode = vm.$options.renderError.call(
-            vm._renderProxy,
-            vm.$createElement,
-            e
-          )
-        } catch (e: any) {
-          handleError(e, vm, `renderError`)
+      if (_parentVnode) {
+        vm.$scopedSlots = normalizeScopedSlots(
+          _parentVnode.data!.scopedSlots,
+          vm.$slots,
+          vm.$scopedSlots
+        )
+        if (vm._slotsProxy) {
+          syncObject(vm._slotsProxy, vm.$scopedSlots)
+        }
+      }
+
+      // set parent vnode. this allows render functions to have access
+      // to the data on the placeholder node.
+      vm.$vnode = _parentVnode!
+      // render self
+      let vnode
+      try {
+        // There's no need to maintain a stack because all render fns are called
+        // separately from one another. Nested component's render fns are called
+        // when parent component is patched.
+        currentRenderingInstance = vm
+        vnode = render.call(vm._renderProxy, vm.$createElement)
+      } catch (e: any) {
+        handleError(e, vm, `render`)
+        // return error render result,
+        // or previous vnode to prevent render error causing blank component
+        /* istanbul ignore else */
+        if (__DEV__ && vm.$options.renderError) {
+          try {
+            vnode = vm.$options.renderError.call(
+              vm._renderProxy,
+              vm.$createElement,
+              e
+            )
+          } catch (e: any) {
+            handleError(e, vm, `renderError`)
+            vnode = vm._vnode
+          }
+        } else {
           vnode = vm._vnode
         }
-      } else {
-        vnode = vm._vnode
+      } finally {
+        currentRenderingInstance = null
       }
-    } finally {
-      currentRenderingInstance = null
-    }
-    // if the returned array contains only a single node, allow it
-    if (isArray(vnode) && vnode.length === 1) {
-      vnode = vnode[0]
-    }
-    // return empty vnode in case the render function errored out
-    if (!(vnode instanceof VNode)) {
-      if (__DEV__ && isArray(vnode)) {
-        warn(
-          'Multiple root nodes returned from render function. Render function ' +
-            'should return a single root node.',
-          vm
-        )
+      // if the returned array contains only a single node, allow it
+      if (isArray(vnode) && vnode.length === 1) {
+        vnode = vnode[0]
       }
-      vnode = createEmptyVNode()
+      // return empty vnode in case the render function errored out
+      if (!(vnode instanceof VNode)) {
+        if (__DEV__ && isArray(vnode)) {
+          warn(
+            'Multiple root nodes returned from render function. Render function ' +
+              'should return a single root node.',
+            vm
+          )
+        }
+        vnode = createEmptyVNode()
+      }
+      // set parent
+      vnode.parent = _parentVnode
+      return vnode
+    } finally {
+      setCurrentInstance()
     }
-    // set parent
-    vnode.parent = _parentVnode
-    return vnode
   }
 }
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 40fc32663b4..d324de9778b 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -2,6 +2,7 @@ import config from '../config'
 import Watcher from '../observer/watcher'
 import Dep, { pushTarget, popTarget } from '../observer/dep'
 import { isUpdatingChildComponent } from './lifecycle'
+import { initSetup } from 'v3/apiSetup'
 
 import {
   set,
@@ -50,6 +51,10 @@ export function initState(vm: Component) {
   vm._watchers = []
   const opts = vm.$options
   if (opts.props) initProps(vm, opts.props)
+
+  // Composition API
+  initSetup(vm)
+
   if (opts.methods) initMethods(vm, opts.methods)
   if (opts.data) {
     initData(vm)
diff --git a/src/core/util/error.ts b/src/core/util/error.ts
index 693fadb5701..d97f847fd21 100644
--- a/src/core/util/error.ts
+++ b/src/core/util/error.ts
@@ -41,11 +41,11 @@ export function invokeWithErrorHandling(
   let res
   try {
     res = args ? handler.apply(context, args) : handler.call(context)
-    if (res && !res._isVue && isPromise(res) && !res._handled) {
+    if (res && !res._isVue && isPromise(res) && !(res as any)._handled) {
       res.catch(e => handleError(e, vm, info + ` (Promise/async)`))
       // issue #9511
       // avoid catch triggering multiple times when nested calls
-      res._handled = true
+      ;(res as any)._handled = true
     }
   } catch (e: any) {
     handleError(e, vm, info)
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index 605681addb3..8d43afa5038 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -148,7 +148,7 @@ strats.data = function (
 /**
  * Hooks and props are merged as arrays.
  */
-function mergeHook(
+export function mergeLifecycleHook(
   parentVal: Array<Function> | null,
   childVal: Function | Array<Function> | null
 ): Array<Function> | null {
@@ -173,7 +173,7 @@ function dedupeHooks(hooks: any) {
 }
 
 LIFECYCLE_HOOKS.forEach(hook => {
-  strats[hook] = mergeHook
+  strats[hook] = mergeLifecycleHook
 })
 
 /**
diff --git a/src/shared/util.ts b/src/shared/util.ts
index fa276117117..ed15bc0d3dd 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -71,7 +71,7 @@ export function isValidArrayIndex(val: any): boolean {
   return n >= 0 && Math.floor(n) === n && isFinite(val)
 }
 
-export function isPromise(val: any): boolean {
+export function isPromise(val: any): val is Promise<any> {
   return (
     isDef(val) &&
     typeof val.then === 'function' &&
@@ -340,14 +340,14 @@ export function looseIndexOf(arr: Array<unknown>, val: unknown): number {
 /**
  * Ensure a function is called only once.
  */
-export function once(fn: Function): Function {
+export function once<T extends (...args: any[]) => any>(fn: T): T {
   let called = false
   return function () {
     if (!called) {
       called = true
-      fn.apply(this, arguments)
+      fn.apply(this, arguments as any)
     }
-  }
+  } as any
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill
diff --git a/src/v3/apiLifecycle.ts b/src/v3/apiLifecycle.ts
index 1396db60e56..615e297f4e5 100644
--- a/src/v3/apiLifecycle.ts
+++ b/src/v3/apiLifecycle.ts
@@ -1 +1,45 @@
-export function onMounted() {}
+import { Component } from '../../typescript/component'
+import { mergeLifecycleHook, warn } from '../core/util'
+import { currentInstance } from './currentInstance'
+
+function createLifeCycle(hookName: string) {
+  return (fn: () => void, target: Component | null = currentInstance) => {
+    if (!target) {
+      __DEV__ &&
+        warn(
+          `${formatName(
+            hookName
+          )} is called when there is no active component instance to be ` +
+            `associated with. ` +
+            `Lifecycle injection APIs can only be used during execution of setup().`
+        )
+      return
+    }
+    return injectHook(target, hookName, fn)
+  }
+}
+
+function formatName(name: string) {
+  if (name === 'beforeDestroy') {
+    name = 'beforeUnmount'
+  } else if (name === 'destroyed') {
+    name = 'unmounted'
+  }
+  return `on${name[0].toUpperCase() + name.slice(1)}`
+}
+
+function injectHook(instance: Component, hookName: string, fn: () => void) {
+  const options = instance.$options
+  options[hookName] = mergeLifecycleHook(options[hookName], fn)
+}
+
+export const onBeforeMount = createLifeCycle('beforeMount')
+export const onMounted = createLifeCycle('mounted')
+export const onBeforeUpdate = createLifeCycle('beforeUpdate')
+export const onUpdated = createLifeCycle('updated')
+export const onBeforeUnmount = createLifeCycle('beforeDestroy')
+export const onUnmounted = createLifeCycle('destroyed')
+export const onErrorCaptured = createLifeCycle('errorCaptured')
+export const onActivated = createLifeCycle('activated')
+export const onDeactivated = createLifeCycle('deactivated')
+export const onServerPrefetch = createLifeCycle('serverPrefetch')
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
new file mode 100644
index 00000000000..bf7d25a07ea
--- /dev/null
+++ b/src/v3/apiSetup.ts
@@ -0,0 +1,114 @@
+import { Component } from 'typescript/component'
+import type { SetupContext } from 'typescript/options'
+import { invokeWithErrorHandling, isReserved, warn } from '../core/util'
+import VNode from '../core/vdom/vnode'
+import { bind, isObject } from '../shared/util'
+import { currentInstance, setCurrentInstance } from './currentInstance'
+import { isRef } from './reactivity/ref'
+
+export function initSetup(vm: Component) {
+  const options = vm.$options
+  const setup = options.setup
+  if (setup) {
+    const ctx = {
+      get attrs() {
+        return initAttrsProxy(vm)
+      },
+      get slots() {
+        return initSlotsProxy(vm)
+      },
+      emit: bind(vm.$emit, vm) as any
+    }
+
+    setCurrentInstance(vm)
+    const setupResult = invokeWithErrorHandling(
+      setup,
+      null,
+      [vm._props, ctx],
+      vm,
+      `setup`
+    )
+    setCurrentInstance()
+
+    if (typeof setupResult === 'function') {
+      // render function
+      // @ts-ignore
+      options.render = setupResult
+    } else if (isObject(setupResult)) {
+      // bindings
+      if (__DEV__ && setupResult instanceof VNode) {
+        warn(
+          `setup() should not return VNodes directly - ` +
+            `return a render function instead.`
+        )
+      }
+      vm._setupState = setupResult
+      for (const key in setupResult) {
+        if (!isReserved(key)) {
+          proxySetupProperty(vm, setupResult, key)
+        }
+      }
+    } else if (__DEV__ && setupResult !== undefined) {
+      warn(
+        `setup() should return an object. Received: ${
+          setupResult === null ? 'null' : typeof setupResult
+        }`
+      )
+    }
+  }
+}
+
+function proxySetupProperty(
+  vm: Component,
+  setupResult: Record<string, any>,
+  key: string
+) {
+  const raw = setupResult[key]
+  const unwrap = isRef(raw)
+  Object.defineProperty(vm, key, {
+    enumerable: true,
+    configurable: true,
+    get: unwrap ? () => raw.value : () => setupResult[key],
+    set: unwrap ? v => (raw.value = v) : v => (setupResult[key] = v)
+  })
+}
+
+function initAttrsProxy(vm: Component) {
+  if (!vm._attrsProxy) {
+    syncObject((vm._attrsProxy = {}), vm.$attrs)
+  }
+  return vm._attrsProxy
+}
+
+function initSlotsProxy(vm: Component) {
+  if (!vm._slotsProxy) {
+    syncObject((vm._slotsProxy = {}), vm.$scopedSlots)
+  }
+  return vm._slotsProxy
+}
+
+export function syncObject(to: any, from: any) {
+  for (const key in from) {
+    to[key] = from[key]
+  }
+  for (const key in to) {
+    if (!(key in from)) {
+      delete to[key]
+    }
+  }
+}
+
+export function useSlots(): SetupContext['slots'] {
+  return getContext().slots
+}
+
+export function useAttrs(): SetupContext['attrs'] {
+  return getContext().attrs
+}
+
+function getContext(): SetupContext {
+  if (__DEV__ && !currentInstance) {
+    warn(`useContext() called without active instance.`)
+  }
+  return currentInstance!.setupContext
+}
diff --git a/src/v3/currentInstance.ts b/src/v3/currentInstance.ts
index 59da6f312a4..9beb8b6897e 100644
--- a/src/v3/currentInstance.ts
+++ b/src/v3/currentInstance.ts
@@ -16,6 +16,6 @@ export function getCurrentInstance(): { proxy: Component } | null {
 /**
  * @private
  */
-export function setCurrentInstance(vm: Component | null) {
+export function setCurrentInstance(vm: Component | null = null) {
   currentInstance = vm
 }
diff --git a/src/v3/h.ts b/src/v3/h.ts
index f2124ebfa3a..3febeb789dc 100644
--- a/src/v3/h.ts
+++ b/src/v3/h.ts
@@ -1,20 +1,11 @@
 import { createElement } from '../core/vdom/create-element'
-import VNode from 'core/vdom/vnode'
-import { VNodeData, VNodeChildren } from 'typescript/vnode'
 import { currentInstance } from './currentInstance'
 import { warn } from 'core/util'
 
 /**
- * @private this function needs manual type declaration because it relies
+ * @private this function needs manual public type declaration because it relies
  * on previously manually authored types from Vue 2
  */
-export function h(type: any, children?: VNodeChildren): VNode
-export function h(
-  type: any,
-  props?: VNodeData | null,
-  children?: VNodeChildren
-): VNode
-
 export function h(type: any, props?: any, children?: any) {
   if (!currentInstance) {
     __DEV__ &&
diff --git a/src/v3/index.ts b/src/v3/index.ts
index a54ba23dd10..cc8411646f5 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -61,3 +61,6 @@ export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
+export { useSlots, useAttrs } from './apiSetup'
+
+export * from './apiLifecycle'
diff --git a/test/unit/features/v3/apiLifecycle.spec.ts b/test/unit/features/v3/apiLifecycle.spec.ts
new file mode 100644
index 00000000000..22ba34bd4f4
--- /dev/null
+++ b/test/unit/features/v3/apiLifecycle.spec.ts
@@ -0,0 +1,284 @@
+import Vue from 'vue'
+import {
+  h,
+  onBeforeMount,
+  onMounted,
+  ref,
+  onBeforeUpdate,
+  onUpdated,
+  onBeforeUnmount,
+  onUnmounted
+} from 'v3'
+import { nextTick } from 'core/util'
+
+describe('api: lifecycle hooks', () => {
+  it('onBeforeMount', () => {
+    const fn = vi.fn(() => {
+      // should be called before root is replaced
+      expect(vm.$el).toBeUndefined()
+    })
+
+    const Comp = {
+      setup() {
+        onBeforeMount(fn)
+        return () => h('div', 'hello')
+      }
+    }
+    const vm = new Vue(Comp)
+    vm.$mount()
+    expect(fn).toHaveBeenCalledTimes(1)
+    expect(vm.$el.innerHTML).toBe(`hello`)
+  })
+
+  it('onMounted', () => {
+    const fn = vi.fn(() => {
+      // should be called after inner div is rendered
+      expect(vm.$el.outerHTML).toBe(`<div></div>`)
+    })
+
+    const Comp = {
+      setup() {
+        onMounted(fn)
+        return () => h('div')
+      }
+    }
+    const vm = new Vue(Comp)
+    vm.$mount()
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('onBeforeUpdate', async () => {
+    const count = ref(0)
+    const fn = vi.fn(() => {
+      // should be called before inner div is updated
+      expect(vm.$el.outerHTML).toBe(`<div>0</div>`)
+    })
+
+    const Comp = {
+      setup() {
+        onBeforeUpdate(fn)
+        return () => h('div', count.value)
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+
+    count.value++
+    await nextTick()
+    expect(fn).toHaveBeenCalledTimes(1)
+    expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+  })
+
+  it('state mutation in onBeforeUpdate', async () => {
+    const count = ref(0)
+    const fn = vi.fn(() => {
+      // should be called before inner div is updated
+      expect(vm.$el.outerHTML).toBe(`<div>0</div>`)
+      count.value++
+    })
+    const renderSpy = vi.fn()
+
+    const Comp = {
+      setup() {
+        onBeforeUpdate(fn)
+        return () => {
+          renderSpy()
+          return h('div', count.value)
+        }
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(renderSpy).toHaveBeenCalledTimes(1)
+
+    count.value++
+    await nextTick()
+    expect(fn).toHaveBeenCalledTimes(1)
+    expect(renderSpy).toHaveBeenCalledTimes(2)
+    expect(vm.$el.outerHTML).toBe(`<div>2</div>`)
+  })
+
+  it('onUpdated', async () => {
+    const count = ref(0)
+    const fn = vi.fn(() => {
+      // should be called after inner div is updated
+      expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+    })
+
+    const Comp = {
+      setup() {
+        onUpdated(fn)
+        return () => h('div', count.value)
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+
+    count.value++
+    await nextTick()
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('onBeforeUnmount', async () => {
+    const toggle = ref(true)
+    const root = document.createElement('div')
+    const fn = vi.fn(() => {
+      // should be called before inner div is removed
+      expect(root.outerHTML).toBe(`<div></div>`)
+    })
+
+    const Comp = {
+      setup() {
+        return () => (toggle.value ? h(Child) : null)
+      }
+    }
+
+    const Child = {
+      setup() {
+        onBeforeUnmount(fn)
+        return () => h('div')
+      }
+    }
+
+    new Vue(Comp).$mount(root)
+
+    toggle.value = false
+    await nextTick()
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('onUnmounted', async () => {
+    const toggle = ref(true)
+    const fn = vi.fn(() => {
+      // @discrepancy should be called after inner div is removed
+      // expect(vm.$el.outerHTML).toBe(`<span></span>`)
+    })
+
+    const Comp = {
+      setup() {
+        return () => (toggle.value ? h(Child) : h('span'))
+      }
+    }
+
+    const Child = {
+      setup() {
+        onUnmounted(fn)
+        return () => h('div')
+      }
+    }
+
+    new Vue(Comp).$mount()
+
+    toggle.value = false
+    await nextTick()
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('onBeforeUnmount in onMounted', async () => {
+    const toggle = ref(true)
+    const fn = vi.fn(() => {
+      // should be called before inner div is removed
+      expect(vm.$el.outerHTML).toBe(`<div></div>`)
+    })
+
+    const Comp = {
+      setup() {
+        return () => (toggle.value ? h(Child) : null)
+      }
+    }
+
+    const Child = {
+      setup() {
+        onMounted(() => {
+          onBeforeUnmount(fn)
+        })
+        return () => h('div')
+      }
+    }
+
+    const vm = new Vue(Comp).$mount()
+
+    toggle.value = false
+    await nextTick()
+    expect(fn).toHaveBeenCalledTimes(1)
+  })
+
+  it('lifecycle call order', async () => {
+    const count = ref(0)
+    const calls: string[] = []
+
+    const Root = {
+      setup() {
+        onBeforeMount(() => calls.push('root onBeforeMount'))
+        onMounted(() => calls.push('root onMounted'))
+        onBeforeUpdate(() => calls.push('root onBeforeUpdate'))
+        onUpdated(() => calls.push('root onUpdated'))
+        onBeforeUnmount(() => calls.push('root onBeforeUnmount'))
+        onUnmounted(() => calls.push('root onUnmounted'))
+        return () => h(Mid, { props: { count: count.value } })
+      }
+    }
+
+    const Mid = {
+      props: ['count'],
+      setup(props: any) {
+        onBeforeMount(() => calls.push('mid onBeforeMount'))
+        onMounted(() => calls.push('mid onMounted'))
+        onBeforeUpdate(() => calls.push('mid onBeforeUpdate'))
+        onUpdated(() => calls.push('mid onUpdated'))
+        onBeforeUnmount(() => calls.push('mid onBeforeUnmount'))
+        onUnmounted(() => calls.push('mid onUnmounted'))
+        return () => h(Child, { props: { count: props.count } })
+      }
+    }
+
+    const Child = {
+      props: ['count'],
+      setup(props: any) {
+        onBeforeMount(() => calls.push('child onBeforeMount'))
+        onMounted(() => calls.push('child onMounted'))
+        onBeforeUpdate(() => calls.push('child onBeforeUpdate'))
+        onUpdated(() => calls.push('child onUpdated'))
+        onBeforeUnmount(() => calls.push('child onBeforeUnmount'))
+        onUnmounted(() => calls.push('child onUnmounted'))
+        return () => h('div', props.count)
+      }
+    }
+
+    // mount
+    const vm = new Vue(Root)
+    vm.$mount()
+    expect(calls).toEqual([
+      'root onBeforeMount',
+      'mid onBeforeMount',
+      'child onBeforeMount',
+      'child onMounted',
+      'mid onMounted',
+      'root onMounted'
+    ])
+
+    calls.length = 0
+
+    // update
+    count.value++
+    await nextTick()
+    expect(calls).toEqual([
+      'root onBeforeUpdate',
+      'mid onBeforeUpdate',
+      'child onBeforeUpdate',
+      'child onUpdated',
+      'mid onUpdated',
+      'root onUpdated'
+    ])
+
+    calls.length = 0
+
+    // unmount
+    vm.$destroy()
+    expect(calls).toEqual([
+      'root onBeforeUnmount',
+      'mid onBeforeUnmount',
+      'child onBeforeUnmount',
+      'child onUnmounted',
+      'mid onUnmounted',
+      'root onUnmounted'
+    ])
+  })
+})
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index a68ed397713..8c509598f64 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -7,14 +7,15 @@ import {
   reactive,
   computed,
   ref,
-  DebuggerEvent,
-  TrackOpTypes,
-  TriggerOpTypes,
+  // DebuggerEvent,
+  // TrackOpTypes,
+  // TriggerOpTypes,
   triggerRef,
   shallowRef,
   Ref,
   h,
-  getCurrentInstance
+  getCurrentInstance,
+  onMounted
   // effectScope
 } from 'v3'
 import { nextTick } from 'core/util'
@@ -600,11 +601,11 @@ describe('api: watch', () => {
   // #1852
   it('flush: post watcher should fire after template refs updated', async () => {
     const toggle = ref(false)
-    let dom: TestElement | null = null
+    let dom: HTMLElement | null = null
 
     const App = {
       setup() {
-        const domRef = ref<TestElement | null>(null)
+        const domRef = ref<any>(null)
 
         watch(
           toggle,
@@ -625,7 +626,7 @@ describe('api: watch', () => {
 
     toggle.value = true
     await nextTick()
-    expect(dom!.tag).toBe('p')
+    expect(dom!.tagName).toBe('P')
   })
 
   it('deep', async () => {
@@ -924,7 +925,7 @@ describe('api: watch', () => {
 
   // TODO
   // https://github.com/vuejs/core/issues/2381
-  test.skip('$watch should always register its effects with its own instance', async () => {
+  test('$watch should always register its effects with its own instance', async () => {
     let instance: Component | null
     let _show: Ref<boolean>
 
diff --git a/types/v3.d.ts b/types/v3.d.ts
index ae250120bee..53367f8d56f 100644
--- a/types/v3.d.ts
+++ b/types/v3.d.ts
@@ -5,7 +5,6 @@ export interface SetupContext {
   attrs: Record<string, any>
   slots: Record<string, (() => VNode[]) | undefined>
   emit: (event: string, ...args: any[]) => any
-  expose: (exposed?: Record<string, any>) => void
 }
 
 export function getCurrentInstance(): { proxy: Vue } | null
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index 89366cc4b3a..b5888279f41 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -38,7 +38,7 @@ export declare class Component {
     [key: string]: Component | Element | Array<Component | Element> | undefined
   }
   $slots: { [key: string]: Array<VNode> }
-  $scopedSlots: { [key: string]: () => VNodeChildren }
+  $scopedSlots: { [key: string]: () => VNode[] | undefined }
   $vnode: VNode // the placeholder node for the component in parent's render tree
   $attrs: { [key: string]: string }
   $listeners: Record<string, Function | Array<Function>>
@@ -97,6 +97,11 @@ export declare class Component {
   _provided?: Record<string, any>
   // _virtualComponents?: { [key: string]: Component };
 
+  // @v3
+  _setupState?: Record<string, any>
+  _attrsProxy?: Record<string, any>
+  _slotsProxy?: Record<string, () => VNode[]>
+
   // private methods
 
   // lifecycle
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
index e53a909edeb..bd59f80889d 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.d.ts
@@ -13,14 +13,13 @@ type InjectKey = string | Symbol
 
 declare interface SetupContext {
   attrs: Record<string, any>
-  slots: Record<string, (() => VNode[]) | undefined>
+  slots: Record<string, () => VNode[]>
   emit: (event: string, ...args: any[]) => any
-  expose: (exposed?: Record<string, any>) => void
 }
 
 declare type ComponentOptions = {
   // v3
-  setup(props: Record<string, any>, ctx: SetupContext): any
+  setup?: (props: Record<string, any>, ctx: SetupContext) => unknown
 
   [key: string]: any
 
diff --git a/typescript/vnode.d.ts b/typescript/vnode.d.ts
index 8cef05cd42a..36dc1c4ff95 100644
--- a/typescript/vnode.d.ts
+++ b/typescript/vnode.d.ts
@@ -2,7 +2,7 @@ import VNode from '../src/core/vdom/vnode'
 import { Component } from './component'
 
 declare type VNodeChildren =
-  | Array<null | VNode | string | VNodeChildren>
+  | Array<null | VNode | string | number | VNodeChildren>
   | string
 
 declare type VNodeComponentOptions = {

From cfc2c591327849233500b746b63a35c82e5ef868 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 27 May 2022 23:51:46 +0800
Subject: [PATCH 086/317] chore: use isFunction

---
 src/core/global-api/assets.ts                 |  4 ++--
 src/core/global-api/use.ts                    |  6 +++---
 src/core/instance/inject.ts                   | 15 +++++---------
 .../instance/render-helpers/render-slot.ts    |  6 +++---
 src/core/instance/state.ts                    | 13 ++++++------
 src/core/observer/watcher.ts                  |  7 ++++---
 src/core/util/debug.ts                        |  4 ++--
 src/core/util/options.ts                      | 20 ++++++++++---------
 src/core/util/props.ts                        |  3 ++-
 .../web/runtime/modules/transition.ts         | 15 ++++++++------
 src/shared/util.ts                            |  4 ++++
 src/v3/apiSetup.ts                            |  4 ++--
 src/v3/apiWatch.ts                            |  5 +++--
 src/v3/reactivity/computed.ts                 |  4 ++--
 test/unit/features/directives/class.spec.ts   |  2 +-
 test/unit/modules/compiler/codegen.spec.ts    |  2 +-
 16 files changed, 61 insertions(+), 53 deletions(-)

diff --git a/src/core/global-api/assets.ts b/src/core/global-api/assets.ts
index 711f7e8785f..38954dbf481 100644
--- a/src/core/global-api/assets.ts
+++ b/src/core/global-api/assets.ts
@@ -1,6 +1,6 @@
 import { ASSET_TYPES } from 'shared/constants'
 import type { GlobalAPI } from 'typescript/global-api'
-import { isPlainObject, validateComponentName } from '../util/index'
+import { isFunction, isPlainObject, validateComponentName } from '../util/index'
 
 export function initAssetRegisters(Vue: GlobalAPI) {
   /**
@@ -24,7 +24,7 @@ export function initAssetRegisters(Vue: GlobalAPI) {
           definition.name = definition.name || id
           definition = this.options._base.extend(definition)
         }
-        if (type === 'directive' && typeof definition === 'function') {
+        if (type === 'directive' && isFunction(definition)) {
           definition = { bind: definition, update: definition }
         }
         this.options[type + 's'][id] = definition
diff --git a/src/core/global-api/use.ts b/src/core/global-api/use.ts
index d3bad623d1e..799defb635f 100644
--- a/src/core/global-api/use.ts
+++ b/src/core/global-api/use.ts
@@ -1,5 +1,5 @@
 import type { GlobalAPI } from 'typescript/global-api'
-import { toArray } from '../util/index'
+import { toArray, isFunction } from '../util/index'
 
 export function initUse(Vue: GlobalAPI) {
   Vue.use = function (plugin: Function | any) {
@@ -12,9 +12,9 @@ export function initUse(Vue: GlobalAPI) {
     // additional parameters
     const args = toArray(arguments, 1)
     args.unshift(this)
-    if (typeof plugin.install === 'function') {
+    if (isFunction(plugin.install)) {
       plugin.install.apply(plugin, args)
-    } else if (typeof plugin === 'function') {
+    } else if (isFunction(plugin)) {
       plugin.apply(null, args)
     }
     installedPlugins.push(plugin)
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 1ea4c3b8f76..8449d410d66 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,16 +1,12 @@
 import { hasOwn } from 'shared/util'
-import { warn, hasSymbol } from '../util/index'
+import { warn, hasSymbol, isFunction } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
 import type { Component } from 'typescript/component'
 
 export function initProvide(vm: Component) {
   const provide = vm.$options.provide
   if (provide) {
-    vm._provided =
-      typeof provide === 'function'
-        ? // @ts-expect-error typing not correct
-          provide.call(vm)
-        : provide
+    vm._provided = isFunction(provide) ? provide.call(vm) : provide
   }
 }
 
@@ -63,10 +59,9 @@ export function resolveInject(
       if (!source) {
         if ('default' in inject[key]) {
           const provideDefault = inject[key].default
-          result[key] =
-            typeof provideDefault === 'function'
-              ? provideDefault.call(vm)
-              : provideDefault
+          result[key] = isFunction(provideDefault)
+            ? provideDefault.call(vm)
+            : provideDefault
         } else if (__DEV__) {
           warn(`Injection "${key as string}" not found`, vm)
         }
diff --git a/src/core/instance/render-helpers/render-slot.ts b/src/core/instance/render-helpers/render-slot.ts
index 7843108c31b..501143ee3f5 100644
--- a/src/core/instance/render-helpers/render-slot.ts
+++ b/src/core/instance/render-helpers/render-slot.ts
@@ -1,4 +1,4 @@
-import { extend, warn, isObject } from 'core/util/index'
+import { extend, warn, isObject, isFunction } from 'core/util/index'
 import VNode from 'core/vdom/vnode'
 
 /**
@@ -23,11 +23,11 @@ export function renderSlot(
     }
     nodes =
       scopedSlotFn(props) ||
-      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender)
+      (isFunction(fallbackRender) ? fallbackRender() : fallbackRender)
   } else {
     nodes =
       this.$slots[name] ||
-      (typeof fallbackRender === 'function' ? fallbackRender() : fallbackRender)
+      (isFunction(fallbackRender) ? fallbackRender() : fallbackRender)
   }
 
   const target = props && props.slot
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index d324de9778b..c53da4de83e 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -26,7 +26,8 @@ import {
   isPlainObject,
   isServerRendering,
   isReservedAttribute,
-  invokeWithErrorHandling
+  invokeWithErrorHandling,
+  isFunction
 } from '../util/index'
 import type { Component } from '../../../typescript/component'
 
@@ -119,7 +120,7 @@ function initProps(vm: Component, propsOptions: Object) {
 
 function initData(vm: Component) {
   let data: any = vm.$options.data
-  data = vm._data = typeof data === 'function' ? getData(data, vm) : data || {}
+  data = vm._data = isFunction(data) ? getData(data, vm) : data || {}
   if (!isPlainObject(data)) {
     data = {}
     __DEV__ &&
@@ -179,7 +180,7 @@ function initComputed(vm: Component, computed: Object) {
 
   for (const key in computed) {
     const userDef = computed[key]
-    const getter = typeof userDef === 'function' ? userDef : userDef.get
+    const getter = isFunction(userDef) ? userDef : userDef.get
     if (__DEV__ && getter == null) {
       warn(`Getter is missing for computed property "${key}".`, vm)
     }
@@ -217,10 +218,10 @@ function initComputed(vm: Component, computed: Object) {
 export function defineComputed(
   target: any,
   key: string,
-  userDef: Record<string, any> | Function
+  userDef: Record<string, any> | (() => any)
 ) {
   const shouldCache = !isServerRendering()
-  if (typeof userDef === 'function') {
+  if (isFunction(userDef)) {
     sharedPropertyDefinition.get = shouldCache
       ? createComputedGetter(key)
       : createGetterInvoker(userDef)
@@ -352,7 +353,7 @@ export function stateMixin(Vue: Component) {
   Vue.prototype.$delete = del
 
   Vue.prototype.$watch = function (
-    expOrFn: string | Function,
+    expOrFn: string | (() => any),
     cb: any,
     options?: Record<string, any>
   ): Function {
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 438577052f1..e697b5e19c2 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -7,7 +7,8 @@ import {
   handleError,
   invokeWithErrorHandling,
   noop,
-  bind
+  bind,
+  isFunction
 } from '../util/index'
 
 import { traverse } from './traverse'
@@ -46,7 +47,7 @@ export default class Watcher implements DepTarget {
 
   constructor(
     vm: Component | null,
-    expOrFn: string | Function,
+    expOrFn: string | (() => any),
     cb: Function,
     options?: {
       deep?: boolean
@@ -88,7 +89,7 @@ export default class Watcher implements DepTarget {
     this.newDepIds = new Set()
     this.expression = __DEV__ ? expOrFn.toString() : ''
     // parse expression for getter
-    if (typeof expOrFn === 'function') {
+    if (isFunction(expOrFn)) {
       this.getter = expOrFn
     } else {
       this.getter = parsePath(expOrFn)
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index f8fd902f298..99d6b8eb437 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -1,5 +1,5 @@
 import config from '../config'
-import { noop, isArray } from 'shared/util'
+import { noop, isArray, isFunction } from 'shared/util'
 import type { Component } from 'typescript/component'
 import { currentInstance } from 'v3/currentInstance'
 
@@ -36,7 +36,7 @@ if (__DEV__) {
       return '<Root>'
     }
     const options =
-      typeof vm === 'function' && (vm as any).cid != null
+      isFunction(vm) && (vm as any).cid != null
         ? (vm as any).options
         : vm._isVue
         ? vm.$options || (vm.constructor as any).options
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index 8d43afa5038..8873d96b7d9 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -3,7 +3,7 @@ import { warn } from './debug'
 import { set } from '../observer/index'
 import { unicodeRegExp } from './lang'
 import { nativeWatch, hasSymbol } from './env'
-import { isArray } from 'shared/util'
+import { isArray, isFunction } from 'shared/util'
 
 import { ASSET_TYPES, LIFECYCLE_HOOKS } from 'shared/constants'
 
@@ -102,17 +102,19 @@ export function mergeDataOrFn(
     // it has to be a function to pass previous merges.
     return function mergedDataFn() {
       return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
+        isFunction(childVal) ? childVal.call(this, this) : childVal,
+        isFunction(parentVal) ? parentVal.call(this, this) : parentVal
       )
     }
   } else {
     return function mergedInstanceDataFn() {
       // instance merge
-      const instanceData =
-        typeof childVal === 'function' ? childVal.call(vm, vm) : childVal
-      const defaultData =
-        typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal
+      const instanceData = isFunction(childVal)
+        ? childVal.call(vm, vm)
+        : childVal
+      const defaultData = isFunction(parentVal)
+        ? parentVal.call(vm, vm)
+        : parentVal
       if (instanceData) {
         return mergeData(instanceData, defaultData)
       } else {
@@ -369,7 +371,7 @@ function normalizeDirectives(options: Record<string, any>) {
   if (dirs) {
     for (const key in dirs) {
       const def = dirs[key]
-      if (typeof def === 'function') {
+      if (isFunction(def)) {
         dirs[key] = { bind: def, update: def }
       }
     }
@@ -399,7 +401,7 @@ export function mergeOptions(
     checkComponents(child)
   }
 
-  if (typeof child === 'function') {
+  if (isFunction(child)) {
     // @ts-expect-error
     child = child.options
   }
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index a464060529d..2f8cb857963 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -4,6 +4,7 @@ import {
   hasOwn,
   isArray,
   isObject,
+  isFunction,
   toRawType,
   hyphenate,
   capitalize,
@@ -93,7 +94,7 @@ function getPropDefaultValue(
   }
   // call factory function for non-Function types
   // a value is Function if its prototype is function even across different execution context
-  return typeof def === 'function' && getType(prop.type) !== 'Function'
+  return isFunction(def) && getType(prop.type) !== 'Function'
     ? def.call(vm)
     : def
 }
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index 4f8b31a1e3f..a889989f1a8 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -2,7 +2,14 @@ import { inBrowser, isIE9, warn } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
 import { activeInstance } from 'core/instance/lifecycle'
 
-import { once, isDef, isUndef, isObject, toNumber } from 'shared/util'
+import {
+  once,
+  isDef,
+  isUndef,
+  isObject,
+  toNumber,
+  isFunction
+} from 'shared/util'
 
 import {
   nextFrame,
@@ -77,11 +84,7 @@ export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
   const toClass = isAppear && appearToClass ? appearToClass : enterToClass
 
   const beforeEnterHook = isAppear ? beforeAppear || beforeEnter : beforeEnter
-  const enterHook = isAppear
-    ? typeof appear === 'function'
-      ? appear
-      : enter
-    : enter
+  const enterHook = isAppear ? (isFunction(appear) ? appear : enter) : enter
   const afterEnterHook = isAppear ? afterAppear || afterEnter : afterEnter
   const enterCancelledHook = isAppear
     ? appearCancelled || enterCancelled
diff --git a/src/shared/util.ts b/src/shared/util.ts
index ed15bc0d3dd..4923995423c 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -33,6 +33,10 @@ export function isPrimitive(value: any): boolean {
   )
 }
 
+export function isFunction(value: any): value is (...args: any[]) => any {
+  return typeof value === 'function'
+}
+
 /**
  * Quick object check - this is primarily used to tell
  * objects from primitive values when we know the value
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index bf7d25a07ea..a2711b54408 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -2,7 +2,7 @@ import { Component } from 'typescript/component'
 import type { SetupContext } from 'typescript/options'
 import { invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
-import { bind, isObject } from '../shared/util'
+import { bind, isFunction, isObject } from '../shared/util'
 import { currentInstance, setCurrentInstance } from './currentInstance'
 import { isRef } from './reactivity/ref'
 
@@ -30,7 +30,7 @@ export function initSetup(vm: Component) {
     )
     setCurrentInstance()
 
-    if (typeof setupResult === 'function') {
+    if (isFunction(setupResult)) {
       // render function
       // @ts-ignore
       options.render = setupResult
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 112fbd26ea4..9fb0beb6e57 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -5,6 +5,7 @@ import {
   warn,
   noop,
   isArray,
+  isFunction,
   emptyObject,
   remove,
   hasChanged,
@@ -210,13 +211,13 @@ function doWatch(
           return s.value
         } else if (isReactive(s)) {
           return traverse(s)
-        } else if (typeof s === 'function') {
+        } else if (isFunction(s)) {
           return call(s, WATCHER_GETTER)
         } else {
           __DEV__ && warnInvalidSource(s)
         }
       })
-  } else if (typeof source === 'function') {
+  } else if (isFunction(source)) {
     if (cb) {
       // getter with cb
       getter = () => call(source as Function, WATCHER_GETTER)
diff --git a/src/v3/reactivity/computed.ts b/src/v3/reactivity/computed.ts
index a74655c63a6..01ee2f34e93 100644
--- a/src/v3/reactivity/computed.ts
+++ b/src/v3/reactivity/computed.ts
@@ -1,4 +1,4 @@
-import { isServerRendering, noop, warn, def } from 'core/util'
+import { isServerRendering, noop, warn, def, isFunction } from 'core/util'
 import { Ref, RefFlag } from './ref'
 import Watcher from 'core/observer/watcher'
 import Dep from 'core/observer/dep'
@@ -41,7 +41,7 @@ export function computed<T>(
   let getter: ComputedGetter<T>
   let setter: ComputedSetter<T>
 
-  const onlyGetter = typeof getterOrOptions === 'function'
+  const onlyGetter = isFunction(getterOrOptions)
   if (onlyGetter) {
     getter = getterOrOptions
     setter = __DEV__
diff --git a/test/unit/features/directives/class.spec.ts b/test/unit/features/directives/class.spec.ts
index 814ee8a2c70..153294ba3f4 100644
--- a/test/unit/features/directives/class.spec.ts
+++ b/test/unit/features/directives/class.spec.ts
@@ -9,7 +9,7 @@ function assertClass(assertions, done) {
   assertions.forEach(([value, expected], i) => {
     chain
       .then(() => {
-        if (typeof value === 'function') {
+        if (isFunction(value)) {
           value(vm.value)
         } else {
           vm.value = value
diff --git a/test/unit/modules/compiler/codegen.spec.ts b/test/unit/modules/compiler/codegen.spec.ts
index fe1ea829c60..ad7da7e592b 100644
--- a/test/unit/modules/compiler/codegen.spec.ts
+++ b/test/unit/modules/compiler/codegen.spec.ts
@@ -16,7 +16,7 @@ function assertCodegen(template, generatedCode, ...args) {
       staticRenderFnCodes = arg
     } else if (isObject(arg)) {
       generateOptions = arg
-    } else if (typeof arg === 'function') {
+    } else if (isFunction(arg)) {
       proc = arg
     }
   }

From 6c1d2efd04c9225ce7b76295be30ab954f8038c5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 28 May 2022 20:33:12 +0800
Subject: [PATCH 087/317] wip: setup() tests

---
 src/core/instance/lifecycle.ts                |  21 +-
 src/core/instance/render.ts                   | 117 +++++----
 src/core/vdom/create-element.ts               |   5 +-
 src/platforms/web/runtime/modules/attrs.ts    |   4 +-
 .../web/runtime/modules/dom-props.ts          |   4 +-
 src/v3/apiSetup.ts                            |  46 +++-
 test/unit/features/v3/apiSetup.spec.ts        | 236 ++++++++++++++++++
 7 files changed, 358 insertions(+), 75 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 86300cfbbd8..e37078c0b27 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -18,7 +18,7 @@ import {
   invokeWithErrorHandling
 } from '../util/index'
 import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
-import { syncObject } from 'v3/apiSetup'
+import { syncSetupAttrs } from 'v3/apiSetup'
 
 export let activeInstance: any = null
 export let isUpdatingChildComponent: boolean = false
@@ -253,12 +253,13 @@ export function updateChildComponent(
   // Any static slot children from the parent may have changed during parent's
   // update. Dynamic scoped slots may also have changed. In such cases, a forced
   // update is necessary to ensure correctness.
-  const needsForceUpdate = !!(
+  let needsForceUpdate = !!(
     renderChildren || // has new static slots
     vm.$options._renderChildren || // has old static slots
     hasDynamicScopedSlot
   )
 
+  const prevVNode = vm.$vnode
   vm.$options._parentVnode = parentVnode
   vm.$vnode = parentVnode // update vm's placeholder node without re-render
 
@@ -271,10 +272,22 @@ export function updateChildComponent(
   // update $attrs and $listeners hash
   // these are also reactive so they may trigger child update if the child
   // used them during render
-  vm.$attrs = parentVnode.data.attrs || emptyObject
+  const attrs = parentVnode.data.attrs || emptyObject
   if (vm._attrsProxy) {
-    syncObject(vm._attrsProxy, vm.$attrs)
+    // force update if attrs are accessed and has changed since it may be
+    // passed to a child component.
+    if (
+      syncSetupAttrs(
+        vm._attrsProxy,
+        attrs,
+        (prevVNode.data && prevVNode.data.attrs) || emptyObject,
+        vm
+      )
+    ) {
+      needsForceUpdate = true
+    }
   }
+  vm.$attrs = attrs
 
   vm.$listeners = listeners || emptyObject
 
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 78c06e6eff9..1f4208b678e 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -16,7 +16,7 @@ import VNode, { createEmptyVNode } from '../vdom/vnode'
 import { isUpdatingChildComponent } from './lifecycle'
 import type { Component } from 'typescript/component'
 import { setCurrentInstance } from 'v3/currentInstance'
-import { syncObject } from 'v3/apiSetup'
+import { syncSetupSlots } from 'v3/apiSetup'
 
 export function initRender(vm: Component) {
   vm._vnode = null // the root of the child tree
@@ -97,73 +97,70 @@ export function renderMixin(Vue: Component) {
   Vue.prototype._render = function (): VNode {
     const vm: Component = this
     const { render, _parentVnode } = vm.$options
-    setCurrentInstance(vm)
 
-    try {
-      if (_parentVnode) {
-        vm.$scopedSlots = normalizeScopedSlots(
-          _parentVnode.data!.scopedSlots,
-          vm.$slots,
-          vm.$scopedSlots
-        )
-        if (vm._slotsProxy) {
-          syncObject(vm._slotsProxy, vm.$scopedSlots)
-        }
+    if (_parentVnode) {
+      vm.$scopedSlots = normalizeScopedSlots(
+        _parentVnode.data!.scopedSlots,
+        vm.$slots,
+        vm.$scopedSlots
+      )
+      if (vm._slotsProxy) {
+        syncSetupSlots(vm._slotsProxy, vm.$scopedSlots)
       }
+    }
 
-      // set parent vnode. this allows render functions to have access
-      // to the data on the placeholder node.
-      vm.$vnode = _parentVnode!
-      // render self
-      let vnode
-      try {
-        // There's no need to maintain a stack because all render fns are called
-        // separately from one another. Nested component's render fns are called
-        // when parent component is patched.
-        currentRenderingInstance = vm
-        vnode = render.call(vm._renderProxy, vm.$createElement)
-      } catch (e: any) {
-        handleError(e, vm, `render`)
-        // return error render result,
-        // or previous vnode to prevent render error causing blank component
-        /* istanbul ignore else */
-        if (__DEV__ && vm.$options.renderError) {
-          try {
-            vnode = vm.$options.renderError.call(
-              vm._renderProxy,
-              vm.$createElement,
-              e
-            )
-          } catch (e: any) {
-            handleError(e, vm, `renderError`)
-            vnode = vm._vnode
-          }
-        } else {
-          vnode = vm._vnode
-        }
-      } finally {
-        currentRenderingInstance = null
-      }
-      // if the returned array contains only a single node, allow it
-      if (isArray(vnode) && vnode.length === 1) {
-        vnode = vnode[0]
-      }
-      // return empty vnode in case the render function errored out
-      if (!(vnode instanceof VNode)) {
-        if (__DEV__ && isArray(vnode)) {
-          warn(
-            'Multiple root nodes returned from render function. Render function ' +
-              'should return a single root node.',
-            vm
+    // set parent vnode. this allows render functions to have access
+    // to the data on the placeholder node.
+    vm.$vnode = _parentVnode!
+    // render self
+    let vnode
+    try {
+      // There's no need to maintain a stack because all render fns are called
+      // separately from one another. Nested component's render fns are called
+      // when parent component is patched.
+      setCurrentInstance(vm)
+      currentRenderingInstance = vm
+      vnode = render.call(vm._renderProxy, vm.$createElement)
+    } catch (e: any) {
+      handleError(e, vm, `render`)
+      // return error render result,
+      // or previous vnode to prevent render error causing blank component
+      /* istanbul ignore else */
+      if (__DEV__ && vm.$options.renderError) {
+        try {
+          vnode = vm.$options.renderError.call(
+            vm._renderProxy,
+            vm.$createElement,
+            e
           )
+        } catch (e: any) {
+          handleError(e, vm, `renderError`)
+          vnode = vm._vnode
         }
-        vnode = createEmptyVNode()
+      } else {
+        vnode = vm._vnode
       }
-      // set parent
-      vnode.parent = _parentVnode
-      return vnode
     } finally {
+      currentRenderingInstance = null
       setCurrentInstance()
     }
+    // if the returned array contains only a single node, allow it
+    if (isArray(vnode) && vnode.length === 1) {
+      vnode = vnode[0]
+    }
+    // return empty vnode in case the render function errored out
+    if (!(vnode instanceof VNode)) {
+      if (__DEV__ && isArray(vnode)) {
+        warn(
+          'Multiple root nodes returned from render function. Render function ' +
+            'should return a single root node.',
+          vm
+        )
+      }
+      vnode = createEmptyVNode()
+    }
+    // set parent
+    vnode.parent = _parentVnode
+    return vnode
   }
 }
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index 415fb1b20af..e41b81a92e7 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -11,7 +11,8 @@ import {
   isTrue,
   isObject,
   isPrimitive,
-  resolveAsset
+  resolveAsset,
+  isFunction
 } from '../util/index'
 
 import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
@@ -76,7 +77,7 @@ export function _createElement(
     )
   }
   // support single function children as default scoped slot
-  if (isArray(children) && typeof children[0] === 'function') {
+  if (isArray(children) && isFunction(children[0])) {
     data = data || {}
     data.scopedSlots = { default: children[0] }
     children.length = 0
diff --git a/src/platforms/web/runtime/modules/attrs.ts b/src/platforms/web/runtime/modules/attrs.ts
index cda1d3e2446..520c00c91f2 100644
--- a/src/platforms/web/runtime/modules/attrs.ts
+++ b/src/platforms/web/runtime/modules/attrs.ts
@@ -1,6 +1,6 @@
 import { isIE, isIE9, isEdge } from 'core/util/env'
 
-import { extend, isDef, isUndef } from 'shared/util'
+import { extend, isDef, isUndef, isTrue } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
 
 import {
@@ -26,7 +26,7 @@ function updateAttrs(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   const oldAttrs = oldVnode.data.attrs || {}
   let attrs: any = vnode.data.attrs || {}
   // clone observed objects, as the user probably wants to mutate it
-  if (isDef(attrs.__ob__)) {
+  if (isDef(attrs.__ob__) || isTrue(attrs._v_attr_proxy)) {
     attrs = vnode.data.attrs = extend({}, attrs)
   }
 
diff --git a/src/platforms/web/runtime/modules/dom-props.ts b/src/platforms/web/runtime/modules/dom-props.ts
index 6cf736566b6..38c143b90b3 100644
--- a/src/platforms/web/runtime/modules/dom-props.ts
+++ b/src/platforms/web/runtime/modules/dom-props.ts
@@ -1,4 +1,4 @@
-import { isDef, isUndef, extend, toNumber } from 'shared/util'
+import { isDef, isUndef, extend, toNumber, isTrue } from 'shared/util'
 import type { VNodeWithData } from 'typescript/vnode'
 import { isSVG } from 'web/util/index'
 
@@ -13,7 +13,7 @@ function updateDOMProps(oldVnode: VNodeWithData, vnode: VNodeWithData) {
   const oldProps = oldVnode.data.domProps || {}
   let props = vnode.data.domProps || {}
   // clone observed objects, as the user probably wants to mutate it
-  if (isDef(props.__ob__)) {
+  if (isDef(props.__ob__) || isTrue(props._v_attr_proxy)) {
     props = vnode.data.domProps = extend({}, props)
   }
 
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index a2711b54408..fee173c1c7a 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -1,8 +1,8 @@
 import { Component } from 'typescript/component'
 import type { SetupContext } from 'typescript/options'
-import { invokeWithErrorHandling, isReserved, warn } from '../core/util'
+import { def, invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
-import { bind, isFunction, isObject } from '../shared/util'
+import { bind, emptyObject, isFunction, isObject } from '../shared/util'
 import { currentInstance, setCurrentInstance } from './currentInstance'
 import { isRef } from './reactivity/ref'
 
@@ -75,19 +75,55 @@ function proxySetupProperty(
 
 function initAttrsProxy(vm: Component) {
   if (!vm._attrsProxy) {
-    syncObject((vm._attrsProxy = {}), vm.$attrs)
+    const proxy = (vm._attrsProxy = {})
+    def(proxy, '_v_attr_proxy', true)
+    syncSetupAttrs(proxy, vm.$attrs, emptyObject, vm)
   }
   return vm._attrsProxy
 }
 
+export function syncSetupAttrs(
+  to: any,
+  from: any,
+  prev: any,
+  instance: Component
+) {
+  let changed = false
+  for (const key in from) {
+    if (!(key in to)) {
+      changed = true
+      defineProxyAttr(to, key, instance)
+    } else if (from[key] !== prev[key]) {
+      changed = true
+    }
+  }
+  for (const key in to) {
+    if (!(key in from)) {
+      changed = true
+      delete to[key]
+    }
+  }
+  return changed
+}
+
+function defineProxyAttr(proxy: any, key: string, instance: Component) {
+  Object.defineProperty(proxy, key, {
+    enumerable: true,
+    configurable: true,
+    get() {
+      return instance.$attrs[key]
+    }
+  })
+}
+
 function initSlotsProxy(vm: Component) {
   if (!vm._slotsProxy) {
-    syncObject((vm._slotsProxy = {}), vm.$scopedSlots)
+    syncSetupSlots((vm._slotsProxy = {}), vm.$scopedSlots)
   }
   return vm._slotsProxy
 }
 
-export function syncObject(to: any, from: any) {
+export function syncSetupSlots(to: any, from: any) {
   for (const key in from) {
     to[key] = from[key]
   }
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index e69de29bb2d..806ab55ffcb 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -0,0 +1,236 @@
+import { h, ref, reactive } from 'v3'
+import { nextTick } from 'core/util'
+import { effect } from 'v3/reactivity/effect'
+import Vue from 'vue'
+
+function renderToString(comp: any) {
+  const vm = new Vue(comp).$mount()
+  return vm.$el.outerHTML
+}
+
+describe('api: setup context', () => {
+  it('should expose return values to template render context', () => {
+    const Comp = {
+      setup() {
+        return {
+          // ref should auto-unwrap
+          ref: ref('foo'),
+          // object exposed as-is
+          object: reactive({ msg: 'bar' }),
+          // primitive value exposed as-is
+          value: 'baz'
+        }
+      },
+      render() {
+        return h('div', `${this.ref} ${this.object.msg} ${this.value}`)
+      }
+    }
+    expect(renderToString(Comp)).toMatch(`<div>foo bar baz</div>`)
+  })
+
+  it('should support returning render function', () => {
+    const Comp = {
+      setup() {
+        return () => {
+          return h('div', 'hello')
+        }
+      }
+    }
+    expect(renderToString(Comp)).toMatch(`<div>hello</div>`)
+  })
+
+  it('props', async () => {
+    const count = ref(0)
+    let dummy
+
+    const Parent = {
+      render: () => h(Child, { props: { count: count.value } })
+    }
+
+    const Child = {
+      props: { count: Number },
+      setup(props) {
+        effect(() => {
+          dummy = props.count
+        })
+        return () => h('div', props.count)
+      }
+    }
+
+    const vm = new Vue(Parent).$mount()
+    expect(vm.$el.outerHTML).toMatch(`<div>0</div>`)
+    expect(dummy).toBe(0)
+
+    // props should be reactive
+    count.value++
+    await nextTick()
+    expect(vm.$el.outerHTML).toMatch(`<div>1</div>`)
+    expect(dummy).toBe(1)
+  })
+
+  it('context.attrs', async () => {
+    const toggle = ref(true)
+
+    const Parent = {
+      render: () =>
+        h(Child, { attrs: toggle.value ? { id: 'foo' } : { class: 'baz' } })
+    }
+
+    const Child = {
+      // explicit empty props declaration
+      // puts everything received in attrs
+      // disable implicit fallthrough
+      inheritAttrs: false,
+      setup(_props: any, { attrs }: any) {
+        return () => h('div', { attrs })
+      }
+    }
+
+    const vm = new Vue(Parent).$mount()
+    expect(vm.$el.outerHTML).toMatch(`<div id="foo"></div>`)
+
+    // should update even though it's not reactive
+    toggle.value = false
+    await nextTick()
+    expect(vm.$el.outerHTML).toMatch(`<div class="baz"></div>`)
+  })
+
+  // vuejs/core #4161
+  it('context.attrs in child component slots', async () => {
+    const toggle = ref(true)
+
+    const Wrapper = {
+      template: `<div><slot/></div>`
+    }
+
+    const Child = {
+      inheritAttrs: false,
+      setup(_: any, { attrs }: any) {
+        return () => {
+          return h(Wrapper, [h('div', { attrs })])
+        }
+      }
+    }
+
+    const Parent = {
+      render: () =>
+        h(Child, { attrs: toggle.value ? { id: 'foo' } : { class: 'baz' } })
+    }
+
+    const vm = new Vue(Parent).$mount()
+    expect(vm.$el.outerHTML).toMatch(`<div id="foo"></div>`)
+
+    // should update even though it's not reactive
+    toggle.value = false
+    await nextTick()
+    expect(vm.$el.outerHTML).toMatch(`<div class="baz"></div>`)
+  })
+
+  it('context.attrs in child component scoped slots', async () => {
+    const toggle = ref(true)
+
+    const Wrapper = {
+      template: `<div><slot/></div>`
+    }
+
+    const Child = {
+      inheritAttrs: false,
+      setup(_: any, { attrs }: any) {
+        return () => {
+          return h(Wrapper, {
+            scopedSlots: {
+              default: () => h('div', { attrs })
+            }
+          })
+        }
+      }
+    }
+
+    const Parent = {
+      render: () =>
+        h(Child, { attrs: toggle.value ? { id: 'foo' } : { class: 'baz' } })
+    }
+
+    const vm = new Vue(Parent).$mount()
+    expect(vm.$el.outerHTML).toMatch(`<div id="foo"></div>`)
+
+    // should update even though it's not reactive
+    toggle.value = false
+    await nextTick()
+    expect(vm.$el.outerHTML).toMatch(`<div class="baz"></div>`)
+  })
+
+  it('context.slots', async () => {
+    const id = ref('foo')
+
+    const Child = {
+      setup(props: any, { slots }: any) {
+        return () => h('div', [...slots.foo(), ...slots.bar()])
+      }
+    }
+
+    const Parent = {
+      components: { Child },
+      setup() {
+        return { id }
+      },
+      template: `<Child>
+        <template #foo>{{ id }}</template>
+        <template #bar>bar</template>
+      </Child>`
+    }
+
+    const vm = new Vue(Parent).$mount()
+    expect(vm.$el.outerHTML).toMatch(`<div>foobar</div>`)
+
+    // should update even though it's not reactive
+    id.value = 'baz'
+    await nextTick()
+    expect(vm.$el.outerHTML).toMatch(`<div>bazbar</div>`)
+  })
+
+  it('context.emit', async () => {
+    const count = ref(0)
+    const spy = vi.fn()
+
+    const Child = {
+      props: {
+        count: {
+          type: Number,
+          default: 1
+        }
+      },
+      setup(props, { emit }) {
+        return () =>
+          h(
+            'div',
+            {
+              on: { click: () => emit('inc', props.count + 1) }
+            },
+            props.count
+          )
+      }
+    }
+
+    const Parent = {
+      components: { Child },
+      setup: () => ({
+        count,
+        onInc(newVal: number) {
+          spy()
+          count.value = newVal
+        }
+      }),
+      template: `<Child :count="count" @inc="onInc" />`
+    }
+
+    const vm = new Vue(Parent).$mount()
+    expect(vm.$el.outerHTML).toMatch(`<div>0</div>`)
+
+    // emit should trigger parent handler
+    triggerEvent(vm.$el as HTMLElement, 'click')
+    expect(spy).toHaveBeenCalled()
+    await nextTick()
+    expect(vm.$el.outerHTML).toMatch(`<div>1</div>`)
+  })
+})

From c9136b12759cfa873d82130f5c07056c018807b2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 02:21:44 +0800
Subject: [PATCH 088/317] wip: apiWatch tests

---
 src/core/instance/lifecycle.ts         |   6 +
 src/core/observer/scheduler.ts         |  51 +++---
 src/core/observer/traverse.ts          |   1 +
 src/core/observer/watcher.ts           |  15 +-
 src/v3/apiWatch.ts                     | 111 ++++++++-----
 src/v3/index.ts                        |   4 +-
 src/v3/reactivity/effect.ts            |  70 ++------
 test/unit/features/v3/apiWatch.spec.ts | 217 ++++++++++---------------
 typescript/component.d.ts              |   1 +
 9 files changed, 217 insertions(+), 259 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index e37078c0b27..19dab25256a 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -218,6 +218,12 @@ export function mountComponent(
   // manually mounted instance, call mounted on self
   // mounted is called for render-created child components in its inserted hook
   if (vm.$vnode == null) {
+    const preWatchers = vm._preWatchers
+    if (preWatchers) {
+      for (let i = 0; i < preWatchers.length; i++) {
+        preWatchers[i].run()
+      }
+    }
     vm._isMounted = true
     callHook(vm, 'mounted')
   }
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index 6d327797548..22dc6904f5b 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -1,5 +1,6 @@
 import type Watcher from './watcher'
 import config from '../config'
+import Dep from './dep'
 import { callHook, activateChildComponent } from '../instance/lifecycle'
 
 import { warn, nextTick, devtools, inBrowser, isIE } from '../util/index'
@@ -119,12 +120,12 @@ function flushSchedulerQueue() {
   }
 }
 
-function callUpdatedHooks(queue) {
+function callUpdatedHooks(queue: Watcher[]) {
   let i = queue.length
   while (i--) {
     const watcher = queue[i]
     const vm = watcher.vm
-    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
+    if (vm && vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {
       callHook(vm, 'updated')
     }
   }
@@ -155,28 +156,34 @@ function callActivatedHooks(queue) {
  */
 export function queueWatcher(watcher: Watcher) {
   const id = watcher.id
-  if (has[id] == null) {
-    has[id] = true
-    if (!flushing) {
-      queue.push(watcher)
-    } else {
-      // if already flushing, splice the watcher based on its id
-      // if already past its id, it will be run next immediately.
-      let i = queue.length - 1
-      while (i > index && queue[i].id > watcher.id) {
-        i--
-      }
-      queue.splice(i + 1, 0, watcher)
+  if (has[id] != null) {
+    return
+  }
+
+  if (watcher === Dep.target && watcher.noRecurse) {
+    return
+  }
+
+  has[id] = true
+  if (!flushing) {
+    queue.push(watcher)
+  } else {
+    // if already flushing, splice the watcher based on its id
+    // if already past its id, it will be run next immediately.
+    let i = queue.length - 1
+    while (i > index && queue[i].id > watcher.id) {
+      i--
     }
-    // queue the flush
-    if (!waiting) {
-      waiting = true
+    queue.splice(i + 1, 0, watcher)
+  }
+  // queue the flush
+  if (!waiting) {
+    waiting = true
 
-      if (__DEV__ && !config.async) {
-        flushSchedulerQueue()
-        return
-      }
-      nextTick(flushSchedulerQueue)
+    if (__DEV__ && !config.async) {
+      flushSchedulerQueue()
+      return
     }
+    nextTick(flushSchedulerQueue)
   }
 }
diff --git a/src/core/observer/traverse.ts b/src/core/observer/traverse.ts
index da1c6a7e987..0fe671c06cf 100644
--- a/src/core/observer/traverse.ts
+++ b/src/core/observer/traverse.ts
@@ -12,6 +12,7 @@ const seenObjects = new Set()
 export function traverse(val: any) {
   _traverse(val, seenObjects)
   seenObjects.clear()
+  return val
 }
 
 function _traverse(val: any, seen: SimpleSet) {
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index e697b5e19c2..1704d921d7c 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -7,7 +7,6 @@ import {
   handleError,
   invokeWithErrorHandling,
   noop,
-  bind,
   isFunction
 } from '../util/index'
 
@@ -26,7 +25,7 @@ let uid = 0
  * This is used for both the $watch() api and directives.
  */
 export default class Watcher implements DepTarget {
-  vm: Component | null
+  vm?: Component | null
   expression: string
   cb: Function
   id: number
@@ -41,7 +40,8 @@ export default class Watcher implements DepTarget {
   depIds: SimpleSet
   newDepIds: SimpleSet
   before?: Function
-  scheduler?: Function
+  onStop?: Function
+  noRecurse?: boolean
   getter: Function
   value: any
 
@@ -72,10 +72,6 @@ export default class Watcher implements DepTarget {
       this.lazy = !!options.lazy
       this.sync = !!options.sync
       this.before = options.before
-      if ((this.scheduler = options.scheduler)) {
-        // @ts-ignore
-        this.run = bind(this.run, this)
-      }
     } else {
       this.deep = this.user = this.lazy = this.sync = false
     }
@@ -179,8 +175,6 @@ export default class Watcher implements DepTarget {
       this.dirty = true
     } else if (this.sync) {
       this.run()
-    } else if (this.scheduler) {
-      this.scheduler(this.run)
     } else {
       queueWatcher(this)
     }
@@ -255,6 +249,9 @@ export default class Watcher implements DepTarget {
         this.deps[i].removeSub(this)
       }
       this.active = false
+      if (this.onStop) {
+        this.onStop()
+      }
     }
   }
 }
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 9fb0beb6e57..17d62eeba2d 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -7,18 +7,15 @@ import {
   isArray,
   isFunction,
   emptyObject,
-  remove,
   hasChanged,
   isServerRendering,
   invokeWithErrorHandling
 } from 'core/util'
 import { currentInstance } from './currentInstance'
 import { traverse } from 'core/observer/traverse'
-import {
-  EffectScheduler,
-  ReactiveEffect,
-  DebuggerEvent
-} from './reactivity/effect'
+import Watcher from '../core/observer/watcher'
+import { queueWatcher } from '../core/observer/scheduler'
+import { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
 const WATCHER = `watcher`
 const WATCHER_CB = `${WATCHER} callback`
@@ -58,6 +55,19 @@ export interface DebuggerOptions {
   onTrigger?: (event: DebuggerEvent) => void
 }
 
+export type DebuggerEvent = {
+  watcher: Watcher
+} & DebuggerEventExtraInfo
+
+export type DebuggerEventExtraInfo = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key: any
+  newValue?: any
+  oldValue?: any
+  oldTarget?: Map<any, any> | Set<any>
+}
+
 export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
   immediate?: Immediate
   deep?: boolean
@@ -162,7 +172,13 @@ export function watch<T = any, Immediate extends Readonly<boolean> = false>(
 function doWatch(
   source: WatchSource | WatchSource[] | WatchEffect | object,
   cb: WatchCallback | null,
-  { immediate, deep, flush, onTrack, onTrigger }: WatchOptions = emptyObject
+  {
+    immediate,
+    deep,
+    flush = 'pre',
+    onTrack,
+    onTrigger
+  }: WatchOptions = emptyObject
 ): WatchStopHandle {
   if (__DEV__ && !cb) {
     if (immediate !== undefined) {
@@ -200,7 +216,12 @@ function doWatch(
     getter = () => source.value
     forceTrigger = isShallow(source)
   } else if (isReactive(source)) {
-    getter = () => source
+    getter = isArray(source)
+      ? () => {
+          ;(source as any).__ob__.dep.depend()
+          return source
+        }
+      : () => source
     deep = true
   } else if (isArray(source)) {
     isMultiSource = true
@@ -245,7 +266,7 @@ function doWatch(
 
   let cleanup: () => void
   let onCleanup: OnCleanup = (fn: () => void) => {
-    cleanup = effect.onStop = () => {
+    cleanup = watcher.onStop = () => {
       call(fn, WATCHER_CLEANUP)
     }
   }
@@ -267,14 +288,23 @@ function doWatch(
     return noop
   }
 
+  const watcher = new Watcher(currentInstance, getter, noop, {
+    lazy: true
+  })
+  watcher.noRecurse = !cb
+
   let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE
-  const job = () => {
-    if (!effect.active) {
+  // overwrite default run
+  watcher.run = () => {
+    if (
+      !watcher.active &&
+      !(flush === 'pre' && instance && instance._isBeingDestroyed)
+    ) {
       return
     }
     if (cb) {
       // watch(source, cb)
-      const newValue = effect.run()
+      const newValue = watcher.get()
       if (
         deep ||
         forceTrigger ||
@@ -298,52 +328,51 @@ function doWatch(
       }
     } else {
       // watchEffect
-      effect.run()
+      watcher.get()
     }
   }
 
-  let scheduler: EffectScheduler
   if (flush === 'sync') {
-    scheduler = job as any // the scheduler function gets called directly
+    watcher.update = watcher.run
   } else if (flush === 'post') {
-    scheduler = () => queuePostRenderEffect(job)
+    watcher.id = Infinity
+    watcher.update = () => queueWatcher(watcher)
   } else {
-    // default: 'pre'
-    scheduler = () => queuePreFlushCb(job)
+    // pre
+    watcher.update = () => {
+      if (!instance || instance._isMounted) {
+        queueWatcher(watcher)
+      } else {
+        const buffer = instance._preWatchers || (instance._preWatchers = [])
+        if (buffer.indexOf(watcher) < 0) buffer.push(watcher)
+      }
+    }
   }
 
-  const effect = new ReactiveEffect(getter, scheduler)
-
-  if (__DEV__) {
-    effect.onTrack = onTrack
-    effect.onTrigger = onTrigger
-  }
+  // TODO
+  // if (__DEV__) {
+  //   effect.onTrack = onTrack
+  //   effect.onTrigger = onTrigger
+  // }
 
   // initial run
   if (cb) {
     if (immediate) {
-      job()
+      watcher.run()
     } else {
-      oldValue = effect.run()
+      oldValue = watcher.get()
     }
-  } else if (flush === 'post') {
-    queuePostRenderEffect(effect.run.bind(effect))
+  } else if (flush === 'post' && instance) {
+    instance.$once('hook:mounted', () => watcher.get())
   } else {
-    effect.run()
+    watcher.get()
   }
 
   return () => {
-    effect.stop()
-    if (instance && instance.scope) {
-      remove(instance.scope.effects!, effect)
-    }
+    watcher.teardown()
+    // TODO
+    // if (instance && instance.scope) {
+    //   remove(instance.scope.effects!, effect)
+    // }
   }
 }
-
-function queuePostRenderEffect(fn: Function) {
-  // TODO
-}
-
-function queuePreFlushCb(fn: Function) {
-  // TODO
-}
diff --git a/src/v3/index.ts b/src/v3/index.ts
index cc8411646f5..610527a5c04 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -53,10 +53,10 @@ export {
   WatchCallback,
   WatchSource,
   WatchStopHandle,
-  DebuggerOptions
+  DebuggerOptions,
+  DebuggerEvent
 } from './apiWatch'
 
-export { DebuggerEvent } from './reactivity/effect'
 export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
 export { h } from './h'
diff --git a/src/v3/reactivity/effect.ts b/src/v3/reactivity/effect.ts
index 7bd8d7198ce..607af2c0f97 100644
--- a/src/v3/reactivity/effect.ts
+++ b/src/v3/reactivity/effect.ts
@@ -1,62 +1,20 @@
 import Watcher from 'core/observer/watcher'
 import { noop } from 'shared/util'
 import { currentInstance } from '../currentInstance'
-import { TrackOpTypes, TriggerOpTypes } from './operations'
 
-export type EffectScheduler = (...args: any[]) => any
-
-export type DebuggerEvent = {
-  effect: ReactiveEffect
-} & DebuggerEventExtraInfo
-
-export type DebuggerEventExtraInfo = {
-  target: object
-  type: TrackOpTypes | TriggerOpTypes
-  key: any
-  newValue?: any
-  oldValue?: any
-  oldTarget?: Map<any, any> | Set<any>
-}
-
-export class ReactiveEffect<T = any> {
-  // TODO
-  onStop?: () => void
-  // dev only
-  onTrack?: (event: DebuggerEvent) => void
-  // dev only
-  onTrigger?: (event: DebuggerEvent) => void
-
-  active = true
-  /**
-   * @private
-   */
-  _watcher: Watcher
-
-  constructor(
-    public fn: () => T,
-    scheduler?: EffectScheduler // TODO scope?: EffectScope
-  ) {
-    // TODO recordEffectScope(this, scope)
-    // TODO debug options
-    this._watcher = new Watcher(currentInstance, fn, noop, {
-      // always force trigger update if has scheduler
-      deep: true,
-      sync: !scheduler,
-      scheduler
-    })
-  }
-
-  run() {
-    this._watcher.run()
-    return this._watcher.value
-  }
-
-  stop() {
-    this._watcher.teardown()
-    this.active = false
+// export type EffectScheduler = (...args: any[]) => any
+
+/**
+ * @private since we are not exposing this in Vue 2, it's used only for
+ * internal testing.
+ */
+export function effect(fn: () => any, scheduler?: (cb: any) => void) {
+  const watcher = new Watcher(currentInstance, fn, noop, {
+    sync: true
+  })
+  if (scheduler) {
+    watcher.update = () => {
+      scheduler(() => watcher.run())
+    }
   }
 }
-
-// since we are not exposing this in Vue 2, it's used only for internal testing.
-export const effect = (fn: () => any, scheduler?: any) =>
-  new ReactiveEffect(fn, scheduler)
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 8c509598f64..84740cb80e6 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -7,19 +7,13 @@ import {
   reactive,
   computed,
   ref,
-  // DebuggerEvent,
-  // TrackOpTypes,
-  // TriggerOpTypes,
   triggerRef,
   shallowRef,
-  Ref,
   h,
-  getCurrentInstance,
   onMounted
-  // effectScope
 } from 'v3'
 import { nextTick } from 'core/util'
-import { Component } from 'typescript/component'
+import { set } from 'core/observer'
 
 // reference: https://vue-composition-api-rfc.netlify.com/api.html#watch
 
@@ -73,7 +67,7 @@ describe('api: watch', () => {
   })
 
   it('watching single source: array', async () => {
-    const array = reactive([] as number[])
+    const array = reactive({ a: [] as number[] }).a
     const spy = vi.fn()
     watch(array, spy)
     array.push(1)
@@ -302,8 +296,9 @@ describe('api: watch', () => {
       callCount++
       // on mount, the watcher callback should be called before DOM render
       // on update, should be called before the count is updated
-      const expectedDOM = callCount === 1 ? `` : `${count - 1}`
-      result1 = root.innerHTML === expectedDOM
+      const expectedDOM =
+        callCount === 1 ? `<div></div>` : `<div>${count - 1}</div>`
+      result1 = container.innerHTML === expectedDOM
 
       // in a pre-flush callback, all state should have been updated
       const expectedState = callCount - 1
@@ -315,10 +310,12 @@ describe('api: watch', () => {
         watchEffect(() => {
           assertion(count.value, count2.value)
         })
-        return () => count.value
+        return () => h('div', count.value)
       }
     }
+    const container = document.createElement('div')
     const root = document.createElement('div')
+    container.appendChild(root)
     new Vue(Comp).$mount(root)
     expect(assertion).toHaveBeenCalledTimes(1)
     expect(result1).toBe(true)
@@ -337,7 +334,7 @@ describe('api: watch', () => {
     const count = ref(0)
     let result
     const assertion = vi.fn(count => {
-      result = root.innerHTML === `${count}`
+      result = container.innerHTML === `<div>${count}</div>`
     })
 
     const Comp = {
@@ -348,10 +345,12 @@ describe('api: watch', () => {
           },
           { flush: 'post' }
         )
-        return () => count.value
+        return () => h('div', count.value)
       }
     }
+    const container = document.createElement('div')
     const root = document.createElement('div')
+    container.appendChild(root)
     new Vue(Comp).$mount(root)
     expect(assertion).toHaveBeenCalledTimes(1)
     expect(result).toBe(true)
@@ -366,7 +365,7 @@ describe('api: watch', () => {
     const count = ref(0)
     let result
     const assertion = vi.fn(count => {
-      result = root.innerHTML === `${count}`
+      result = container.innerHTML === `<div>${count}</div>`
     })
 
     const Comp = {
@@ -374,10 +373,12 @@ describe('api: watch', () => {
         watchPostEffect(() => {
           assertion(count.value)
         })
-        return () => count.value
+        return () => h('div', count.value)
       }
     }
+    const container = document.createElement('div')
     const root = document.createElement('div')
+    container.appendChild(root)
     new Vue(Comp).$mount(root)
     expect(assertion).toHaveBeenCalledTimes(1)
     expect(result).toBe(true)
@@ -399,8 +400,9 @@ describe('api: watch', () => {
       callCount++
       // on mount, the watcher callback should be called before DOM render
       // on update, should be called before the count is updated
-      const expectedDOM = callCount === 1 ? `` : `${count - 1}`
-      result1 = root.innerHTML === expectedDOM
+      const expectedDOM =
+        callCount === 1 ? `<div></div>` : `<div>${count - 1}</div>`
+      result1 = container.innerHTML === expectedDOM
 
       // in a sync callback, state mutation on the next line should not have
       // executed yet on the 2nd call, but will be on the 3rd call.
@@ -418,10 +420,12 @@ describe('api: watch', () => {
             flush: 'sync'
           }
         )
-        return () => count.value
+        return () => h('div', count.value)
       }
     }
+    const container = document.createElement('div')
     const root = document.createElement('div')
+    container.appendChild(root)
     new Vue(Comp).$mount(root)
     expect(assertion).toHaveBeenCalledTimes(1)
     expect(result1).toBe(true)
@@ -446,8 +450,9 @@ describe('api: watch', () => {
       callCount++
       // on mount, the watcher callback should be called before DOM render
       // on update, should be called before the count is updated
-      const expectedDOM = callCount === 1 ? `` : `${count - 1}`
-      result1 = root.innerHTML === expectedDOM
+      const expectedDOM =
+        callCount === 1 ? `<div></div>` : `<div>${count - 1}</div>`
+      result1 = container.innerHTML === expectedDOM
 
       // in a sync callback, state mutation on the next line should not have
       // executed yet on the 2nd call, but will be on the 3rd call.
@@ -460,10 +465,12 @@ describe('api: watch', () => {
         watchSyncEffect(() => {
           assertion(count.value)
         })
-        return () => count.value
+        return () => h('div', count.value)
       }
     }
+    const container = document.createElement('div')
     const root = document.createElement('div')
+    container.appendChild(root)
     new Vue(Comp).$mount(root)
     expect(assertion).toHaveBeenCalledTimes(1)
     expect(result1).toBe(true)
@@ -491,7 +498,7 @@ describe('api: watch', () => {
         return toggle.value ? h(Comp) : null
       }
     }
-    new Vue(App).$mount(document.createElement('div'))
+    new Vue(App).$mount()
     expect(cb).not.toHaveBeenCalled()
     toggle.value = false
     await nextTick()
@@ -512,14 +519,14 @@ describe('api: watch', () => {
         return toggle.value ? h(Comp) : null
       }
     }
-    new Vue(App).$mount(document.createElement('div'))
+    new Vue(App).$mount()
     expect(cb).not.toHaveBeenCalled()
     toggle.value = false
     await nextTick()
     expect(cb).toHaveBeenCalledTimes(1)
   })
 
-  // #1763
+  // vuejs/core#1763
   it('flush: pre watcher watching props should fire before child update', async () => {
     const a = ref(0)
     const b = ref(0)
@@ -538,7 +545,7 @@ describe('api: watch', () => {
           { flush: 'pre' }
         )
 
-        // #1777 chained pre-watcher
+        // vuejs/core#1777 chained pre-watcher
         watch(
           c,
           () => {
@@ -559,7 +566,7 @@ describe('api: watch', () => {
       }
     }
 
-    new Vue(App).$mount(document.createElement('div'))
+    new Vue(App).$mount()
     expect(calls).toEqual(['render'])
 
     // both props are updated
@@ -571,7 +578,7 @@ describe('api: watch', () => {
     expect(calls).toEqual(['render', 'watcher 1', 'watcher 2', 'render'])
   })
 
-  // #5721
+  // vuejs/core#5721
   it('flush: pre triggered in component setup should be buffered and called before mounted', () => {
     const count = ref(0)
     const calls: string[] = []
@@ -594,12 +601,13 @@ describe('api: watch', () => {
         count.value++
       }
     }
-    new Vue(App).$mount(document.createElement('div'))
+    new Vue(App).$mount()
     expect(calls).toMatchObject(['watch 3', 'mounted'])
   })
 
-  // #1852
-  it('flush: post watcher should fire after template refs updated', async () => {
+  // TODO
+  // vuejs/core#1852
+  it.skip('flush: post watcher should fire after template refs updated', async () => {
     const toggle = ref(false)
     let dom: HTMLElement | null = null
 
@@ -621,7 +629,7 @@ describe('api: watch', () => {
       }
     }
 
-    new Vue(App).$mount(document.createElement('div'))
+    new Vue(App).$mount()
     expect(dom).toBe(null)
 
     toggle.value = true
@@ -634,12 +642,12 @@ describe('api: watch', () => {
       nested: {
         count: ref(0)
       },
-      array: [1, 2, 3],
-      map: new Map([
-        ['a', 1],
-        ['b', 2]
-      ]),
-      set: new Set([1, 2, 3])
+      array: [1, 2, 3]
+      // map: new Map([
+      //   ['a', 1],
+      //   ['b', 2]
+      // ]),
+      // set: new Set([1, 2, 3])
     })
 
     let dummy
@@ -648,9 +656,9 @@ describe('api: watch', () => {
       state => {
         dummy = [
           state.nested.count,
-          state.array[0],
-          state.map.get('a'),
-          state.set.has(1)
+          state.array[0]
+          // state.map.get('a'),
+          // state.set.has(1)
         ]
       },
       { deep: true }
@@ -658,34 +666,34 @@ describe('api: watch', () => {
 
     state.nested.count++
     await nextTick()
-    expect(dummy).toEqual([1, 1, 1, true])
+    expect(dummy).toEqual([1, 1])
 
     // nested array mutation
-    state.array[0] = 2
+    set(state.array, 0, 2)
     await nextTick()
-    expect(dummy).toEqual([1, 2, 1, true])
+    expect(dummy).toEqual([1, 2])
 
     // nested map mutation
-    state.map.set('a', 2)
-    await nextTick()
-    expect(dummy).toEqual([1, 2, 2, true])
+    // state.map.set('a', 2)
+    // await nextTick()
+    // expect(dummy).toEqual([1, 2, 2, true])
 
     // nested set mutation
-    state.set.delete(1)
-    await nextTick()
-    expect(dummy).toEqual([1, 2, 2, false])
+    // state.set.delete(1)
+    // await nextTick()
+    // expect(dummy).toEqual([1, 2, 2, false])
   })
 
   it('watching deep ref', async () => {
     const count = ref(0)
     const double = computed(() => count.value * 2)
-    const state = reactive([count, double])
+    const state = reactive({ count, double })
 
     let dummy
     watch(
       () => state,
       state => {
-        dummy = [state[0].value, state[1].value]
+        dummy = [state.count, state.double]
       },
       { deep: true }
     )
@@ -897,7 +905,7 @@ describe('api: watch', () => {
     expect(spy).toHaveBeenCalledTimes(1)
   })
 
-  // #2125
+  // vuejs/core#2125
   test('watchEffect should not recursively trigger itself', async () => {
     const spy = vi.fn()
     const price = ref(10)
@@ -910,7 +918,7 @@ describe('api: watch', () => {
     expect(spy).toHaveBeenCalledTimes(1)
   })
 
-  // #2231
+  // vuejs/core#2231
   test('computed refs should not trigger watch if value has no change', async () => {
     const spy = vi.fn()
     const source = ref(0)
@@ -923,59 +931,6 @@ describe('api: watch', () => {
     expect(spy).toHaveBeenCalledTimes(1)
   })
 
-  // TODO
-  // https://github.com/vuejs/core/issues/2381
-  test('$watch should always register its effects with its own instance', async () => {
-    let instance: Component | null
-    let _show: Ref<boolean>
-
-    const Child = {
-      render: () => h('div'),
-      mounted() {
-        instance = getCurrentInstance()!.proxy
-      },
-      unmounted() {}
-    }
-
-    const Comp = {
-      setup() {
-        const comp = ref<Component | undefined>()
-        const show = ref(true)
-        _show = show
-        return { comp, show }
-      },
-      render() {
-        return this.show
-          ? h(Child, {
-              ref: vm => void (this.comp = vm as Component)
-            })
-          : null
-      },
-      mounted() {
-        // this call runs while Comp is currentInstance, but
-        // the effect for this `$watch` should nontheless be registered with Child
-        this.comp!.$watch(
-          () => this.show,
-          () => void 0
-        )
-      }
-    }
-
-    new Vue(Comp).$mount(document.createElement('div'))
-
-    expect(instance!).toBeDefined()
-    expect(instance!.scope.effects).toBeInstanceOf(Array)
-    // includes the component's own render effect AND the watcher effect
-    expect(instance!.scope.effects.length).toBe(2)
-
-    _show!.value = false
-
-    await nextTick()
-    await nextTick()
-
-    expect(instance!.scope.effects[0].active).toBe(false)
-  })
-
   test('this.$watch should pass `this.proxy` to watch source as the first argument ', () => {
     let instance: any
     const source = vi.fn()
@@ -1011,17 +966,19 @@ describe('api: watch', () => {
     expect(source.mock.calls[0]).toMatchObject([])
   })
 
-  // #2728
+  // vuejs/core#2728
   test('pre watcher callbacks should not track dependencies', async () => {
     const a = ref(0)
     const b = ref(0)
     const updated = vi.fn()
+    const cb = vi.fn()
 
     const Child = {
       props: ['a'],
       updated,
       watch: {
         a() {
+          cb()
           b.value
         }
       },
@@ -1032,7 +989,7 @@ describe('api: watch', () => {
 
     const Parent = {
       render() {
-        return h(Child, { a: a.value })
+        return h(Child, { props: { a: a.value } })
       }
     }
 
@@ -1042,11 +999,13 @@ describe('api: watch', () => {
     a.value++
     await nextTick()
     expect(updated).toHaveBeenCalledTimes(1)
+    expect(cb).toHaveBeenCalledTimes(1)
 
     b.value++
     await nextTick()
     // should not track b as dependency of Child
     expect(updated).toHaveBeenCalledTimes(1)
+    expect(cb).toHaveBeenCalledTimes(1)
   })
 
   test('watching keypath', async () => {
@@ -1102,26 +1061,26 @@ describe('api: watch', () => {
     expect(count).toBe(0)
   })
 
-  // #4158
+  // vuejs/core#4158
   // TODO
-  test.skip('watch should not register in owner component if created inside detached scope', () => {
-    let instance: Component
-    const Comp = {
-      setup() {
-        instance = getCurrentInstance()!.proxy
-        effectScope(true).run(() => {
-          watch(
-            () => 1,
-            () => {}
-          )
-        })
-        return () => ''
-      }
-    }
-    const root = document.createElement('div')
-    new Vue(Comp).$mount(root)
-    // should not record watcher in detached scope and only the instance's
-    // own update effect
-    expect(instance!.scope.effects.length).toBe(1)
-  })
+  // test.skip('watch should not register in owner component if created inside detached scope', () => {
+  //   let instance: Component
+  //   const Comp = {
+  //     setup() {
+  //       instance = getCurrentInstance()!.proxy
+  //       effectScope(true).run(() => {
+  //         watch(
+  //           () => 1,
+  //           () => {}
+  //         )
+  //       })
+  //       return () => ''
+  //     }
+  //   }
+  //   const root = document.createElement('div')
+  //   new Vue(Comp).$mount(root)
+  //   // should not record watcher in detached scope and only the instance's
+  //   // own update effect
+  //   expect(instance!.scope.effects.length).toBe(1)
+  // })
 })
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index b5888279f41..a95719dc543 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -101,6 +101,7 @@ export declare class Component {
   _setupState?: Record<string, any>
   _attrsProxy?: Record<string, any>
   _slotsProxy?: Record<string, () => VNode[]>
+  _preWatchers?: Watcher[]
 
   // private methods
 

From 54f5f9bad6350993b176dedd60ce118a47887c56 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 02:26:36 +0800
Subject: [PATCH 089/317] chore: fix ssr tests

---
 src/core/instance/state.ts | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index c53da4de83e..9af2a5c472a 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -60,7 +60,8 @@ export function initState(vm: Component) {
   if (opts.data) {
     initData(vm)
   } else {
-    observe((vm._data = {}))!.vmCount++
+    const ob = observe((vm._data = {}))
+    ob && ob.vmCount++
   }
   if (opts.computed) initComputed(vm, opts.computed)
   if (opts.watch && opts.watch !== nativeWatch) {
@@ -154,7 +155,8 @@ function initData(vm: Component) {
     }
   }
   // observe data
-  observe(data)!.vmCount++
+  const ob = observe(data)
+  ob && ob.vmCount++
 }
 
 export function getData(data: Function, vm: Component): any {

From b4c511da8f82d4bf130284a5242ea745cf8c7ae1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 02:33:46 +0800
Subject: [PATCH 090/317] chore: fix unit tests

---
 src/core/observer/index.ts                  | 9 +++++++--
 test/unit/features/directives/class.spec.ts | 1 +
 test/unit/modules/compiler/codegen.spec.ts  | 2 +-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 3ad49493892..c043f3923de 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -19,6 +19,8 @@ import { isReadonly, isRef } from '../../v3'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
+const NO_INIITIAL_VALUE = {}
+
 /**
  * In some cases we may want to disable observation inside a component's
  * update computation.
@@ -67,7 +69,7 @@ export class Observer {
     const keys = Object.keys(obj)
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i]
-      defineReactive(obj, key, obj[key], undefined, shallow)
+      defineReactive(obj, key, NO_INIITIAL_VALUE, undefined, shallow)
     }
   }
 
@@ -149,7 +151,10 @@ export function defineReactive(
   // cater for pre-defined getter/setters
   const getter = property && property.get
   const setter = property && property.set
-  if ((!getter || setter) && arguments.length === 2) {
+  if (
+    (!getter || setter) &&
+    (val === NO_INIITIAL_VALUE || arguments.length === 2)
+  ) {
     val = obj[key]
   }
 
diff --git a/test/unit/features/directives/class.spec.ts b/test/unit/features/directives/class.spec.ts
index 153294ba3f4..f2c00110b6a 100644
--- a/test/unit/features/directives/class.spec.ts
+++ b/test/unit/features/directives/class.spec.ts
@@ -1,4 +1,5 @@
 import Vue from 'vue'
+import { isFunction } from 'core/util'
 
 function assertClass(assertions, done) {
   const vm = new Vue({
diff --git a/test/unit/modules/compiler/codegen.spec.ts b/test/unit/modules/compiler/codegen.spec.ts
index ad7da7e592b..e893a81920e 100644
--- a/test/unit/modules/compiler/codegen.spec.ts
+++ b/test/unit/modules/compiler/codegen.spec.ts
@@ -1,7 +1,7 @@
 import { parse } from 'compiler/parser/index'
 import { optimize } from 'compiler/optimizer'
 import { generate } from 'compiler/codegen'
-import { isObject, extend } from 'shared/util'
+import { isObject, isFunction, extend } from 'shared/util'
 import { isReservedTag } from 'web/util/index'
 import { baseOptions } from 'web/compiler/options'
 

From 9fb4f7d0702d34ccfabe59fa4f9713ee9755ab58 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 14:17:08 +0800
Subject: [PATCH 091/317] wip: effectScope

---
 src/core/instance/events.ts                   |   2 +-
 src/core/instance/init.ts                     |  11 +-
 src/core/instance/lifecycle.ts                |  13 +-
 src/core/instance/render.ts                   |   4 +-
 src/core/instance/state.ts                    |   7 +-
 src/core/observer/watcher.ts                  |  15 +-
 src/core/util/next-tick.ts                    |   4 +-
 src/core/vdom/create-component.ts             |  13 +-
 src/core/vdom/create-element.ts               |   2 +-
 src/core/vdom/create-functional-component.ts  |   7 +-
 src/core/vdom/helpers/extract-props.ts        |   2 +-
 .../vdom/helpers/resolve-async-component.ts   |   4 +-
 src/v3/apiSetup.ts                            |  25 +-
 src/v3/apiWatch.ts                            |   2 +-
 src/v3/currentInstance.ts                     |   2 +
 src/v3/index.ts                               |   8 +
 src/v3/reactivity/effectScope.ts              | 131 ++++++++
 .../instance/methods-lifecycle.spec.ts        |   2 +-
 test/unit/features/v3/apiWatch.spec.ts        |  75 ++---
 .../v3/reactivity/effectScope.spec.ts         | 282 ++++++++++++++++++
 typescript/component.d.ts                     |  17 +-
 typescript/global-api.d.ts                    |   3 +-
 typescript/options.d.ts                       |   2 +-
 typescript/vnode.d.ts                         |   2 +-
 24 files changed, 522 insertions(+), 113 deletions(-)
 create mode 100644 src/v3/reactivity/effectScope.ts
 create mode 100644 test/unit/features/v3/reactivity/effectScope.spec.ts

diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index 9affa565a23..d62d565678a 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -56,7 +56,7 @@ export function updateComponentListeners(
   target = undefined
 }
 
-export function eventsMixin(Vue: Component) {
+export function eventsMixin(Vue: typeof Component) {
   const hookRE = /^hook:/
   Vue.prototype.$on = function (
     event: string | Array<string>,
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index aaf55a35d29..99241f8fc83 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -9,10 +9,11 @@ import { initProvide, initInjections } from './inject'
 import { extend, mergeOptions, formatComponentName } from '../util/index'
 import type { Component } from 'typescript/component'
 import type { InternalComponentOptions } from 'typescript/options'
+import { EffectScope } from 'v3'
 
 let uid = 0
 
-export function initMixin(Vue: Component) {
+export function initMixin(Vue: typeof Component) {
   Vue.prototype._init = function (options?: Record<string, any>) {
     const vm: Component = this
     // a uid
@@ -31,6 +32,8 @@ export function initMixin(Vue: Component) {
     vm._isVue = true
     // avoid instances from being observed
     vm.__v_skip = true
+    // effect scope
+    vm._scope = new EffectScope(true /* detached */)
     // merge options
     if (options && options._isComponent) {
       // optimize internal component instantiation
@@ -96,7 +99,7 @@ export function initInternalComponent(
   }
 }
 
-export function resolveConstructorOptions(Ctor: Component) {
+export function resolveConstructorOptions(Ctor: typeof Component) {
   let options = Ctor.options
   if (Ctor.super) {
     const superOptions = resolveConstructorOptions(Ctor.super)
@@ -120,7 +123,9 @@ export function resolveConstructorOptions(Ctor: Component) {
   return options
 }
 
-function resolveModifiedOptions(Ctor: Component): Record<string, any> | null {
+function resolveModifiedOptions(
+  Ctor: typeof Component
+): Record<string, any> | null {
   let modified
   const latest = Ctor.options
   const sealed = Ctor.sealedOptions
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 19dab25256a..0b9b445bb8a 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -57,7 +57,7 @@ export function initLifecycle(vm: Component) {
   vm._isBeingDestroyed = false
 }
 
-export function lifecycleMixin(Vue: Component) {
+export function lifecycleMixin(Vue: typeof Component) {
   Vue.prototype._update = function (vnode: VNode, hydrating?: boolean) {
     const vm: Component = this
     const prevEl = vm.$el
@@ -108,14 +108,9 @@ export function lifecycleMixin(Vue: Component) {
     if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
       remove(parent.$children, vm)
     }
-    // teardown watchers
-    if (vm._watcher) {
-      vm._watcher.teardown()
-    }
-    let i = vm._watchers.length
-    while (i--) {
-      vm._watchers[i].teardown()
-    }
+    // teardown scope. this includes both the render watcher and other
+    // watchers created
+    vm._scope.stop()
     // remove reference from data ob
     // frozen object may not have observer.
     if (vm._data.__ob__) {
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 1f4208b678e..fc0407b87d5 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -86,11 +86,11 @@ export function setCurrentRenderingInstance(vm: Component) {
   currentRenderingInstance = vm
 }
 
-export function renderMixin(Vue: Component) {
+export function renderMixin(Vue: typeof Component) {
   // install runtime convenience helpers
   installRenderHelpers(Vue.prototype)
 
-  Vue.prototype.$nextTick = function (fn: Function) {
+  Vue.prototype.$nextTick = function (fn: (...args: any[]) => any) {
     return nextTick(fn, this)
   }
 
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 9af2a5c472a..f9da112d214 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -29,7 +29,7 @@ import {
   invokeWithErrorHandling,
   isFunction
 } from '../util/index'
-import type { Component } from '../../../typescript/component'
+import type { Component } from 'typescript/component'
 
 const sharedPropertyDefinition = {
   enumerable: true,
@@ -49,7 +49,6 @@ export function proxy(target: Object, sourceKey: string, key: string) {
 }
 
 export function initState(vm: Component) {
-  vm._watchers = []
   const opts = vm.$options
   if (opts.props) initProps(vm, opts.props)
 
@@ -310,7 +309,7 @@ function initWatch(vm: Component, watch: Object) {
 
 function createWatcher(
   vm: Component,
-  expOrFn: string | Function,
+  expOrFn: string | (() => any),
   handler: any,
   options?: Object
 ) {
@@ -324,7 +323,7 @@ function createWatcher(
   return vm.$watch(expOrFn, handler, options)
 }
 
-export function stateMixin(Vue: Component) {
+export function stateMixin(Vue: typeof Component) {
   // flow somehow has problems with directly declared definition object
   // when using Object.defineProperty, so we have to procedurally build up
   // the object here.
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 1704d921d7c..2225249570e 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -16,6 +16,10 @@ import Dep, { pushTarget, popTarget, DepTarget } from './dep'
 
 import type { SimpleSet } from '../util/index'
 import type { Component } from 'typescript/component'
+import {
+  activeEffectScope,
+  recordEffectScope
+} from '../../v3/reactivity/effectScope'
 
 let uid = 0
 
@@ -59,11 +63,11 @@ export default class Watcher implements DepTarget {
     } | null,
     isRenderWatcher?: boolean
   ) {
+    recordEffectScope(this, activeEffectScope || (vm ? vm._scope : undefined))
     if ((this.vm = vm)) {
       if (isRenderWatcher) {
         vm._watcher = this
       }
-      vm._watchers.push(this)
     }
     // options
     if (options) {
@@ -237,13 +241,10 @@ export default class Watcher implements DepTarget {
    * Remove self from all dependencies' subscriber list.
    */
   teardown() {
+    if (this.vm && !this.vm._isBeingDestroyed) {
+      remove(this.vm._scope.effects, this)
+    }
     if (this.active) {
-      // remove self from vm's watcher list
-      // this is a somewhat expensive operation so we skip it
-      // if the vm is being destroyed.
-      if (this.vm && !this.vm._isBeingDestroyed) {
-        remove(this.vm._watchers, this)
-      }
       let i = this.deps.length
       while (i--) {
         this.deps[i].removeSub(this)
diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index 5d4670d2f75..ac3eceaf5f9 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -85,7 +85,9 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
   }
 }
 
-export function nextTick(cb?: Function, ctx?: Object) {
+export function nextTick(): Promise<void>
+export function nextTick(cb: (...args: any[]) => any, ctx?: object): void
+export function nextTick(cb?: (...args: any[]) => any, ctx?: object) {
   let _resolve
   callbacks.push(() => {
     if (cb) {
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 1f738b7cd17..6cca96552f2 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -26,7 +26,10 @@ import type {
   VNodeWithData
 } from 'typescript/vnode'
 import type { Component } from 'typescript/component'
-import type { InternalComponentOptions } from 'typescript/options'
+import type {
+  ComponentOptions,
+  InternalComponentOptions
+} from 'typescript/options'
 
 // inline hooks to be invoked on component VNodes during patch
 const componentVNodeHooks = {
@@ -95,7 +98,7 @@ const componentVNodeHooks = {
 const hooksToMerge = Object.keys(componentVNodeHooks)
 
 export function createComponent(
-  Ctor: Component | Function | Object | void,
+  Ctor: typeof Component | Function | ComponentOptions | void,
   data: VNodeData | undefined,
   context: Component,
   children?: Array<VNode>,
@@ -109,7 +112,7 @@ export function createComponent(
 
   // plain options object: turn it into a constructor
   if (isObject(Ctor)) {
-    Ctor = baseCtor.extend(Ctor)
+    Ctor = baseCtor.extend(Ctor as typeof Component)
   }
 
   // if at this stage it's not a constructor or an async component factory,
@@ -139,7 +142,7 @@ export function createComponent(
 
   // resolve constructor options in case global mixins are applied after
   // component constructor creation
-  resolveConstructorOptions(Ctor as Component)
+  resolveConstructorOptions(Ctor as typeof Component)
 
   // transform component v-model data into props & events
   if (isDef(data.model)) {
@@ -155,7 +158,7 @@ export function createComponent(
   // @ts-expect-error
   if (isTrue(Ctor.options.functional)) {
     return createFunctionalComponent(
-      Ctor as Component,
+      Ctor as typeof Component,
       propsData,
       data,
       context,
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index e41b81a92e7..9207b8fa8c4 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -126,7 +126,7 @@ export function _createElement(
     }
   } else {
     // direct component options / constructor
-    vnode = createComponent(tag, data, context, children)
+    vnode = createComponent(tag as any, data, context, children)
   }
   if (isArray(vnode)) {
     return vnode
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index de576e97688..eee5811ffd3 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -23,7 +23,7 @@ export function FunctionalRenderContext(
   props: Object,
   children: Array<VNode> | undefined,
   parent: Component,
-  Ctor: Component
+  Ctor: typeof Component
 ) {
   const options = Ctor.options
   // ensure the createElement function in functional components
@@ -31,14 +31,13 @@ export function FunctionalRenderContext(
   let contextVm
   if (hasOwn(parent, '_uid')) {
     contextVm = Object.create(parent)
-    // $flow-disable-line
     contextVm._original = parent
   } else {
     // the context vm passed in is a functional context as well.
     // in this case we want to make sure we are able to get a hold to the
     // real context instance.
     contextVm = parent
-    // $flow-disable-line
+    // @ts-ignore
     parent = parent._original
   }
   const isCompiled = isTrue(options._compiled)
@@ -94,7 +93,7 @@ export function FunctionalRenderContext(
 installRenderHelpers(FunctionalRenderContext.prototype)
 
 export function createFunctionalComponent(
-  Ctor: Component,
+  Ctor: typeof Component,
   propsData: Object | undefined,
   data: VNodeData,
   contextVm: Component,
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index b97637ad4a0..87abc595197 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -11,7 +11,7 @@ import type { VNodeData } from 'typescript/vnode'
 
 export function extractPropsFromVNodeData(
   data: VNodeData,
-  Ctor: Component,
+  Ctor: typeof Component,
   tag?: string
 ): object | undefined {
   // we are only extracting raw values here.
diff --git a/src/core/vdom/helpers/resolve-async-component.ts b/src/core/vdom/helpers/resolve-async-component.ts
index ea89092e9b3..69794170af8 100644
--- a/src/core/vdom/helpers/resolve-async-component.ts
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -37,8 +37,8 @@ export function createAsyncPlaceholder(
 
 export function resolveAsyncComponent(
   factory: { (...args: any[]): any; [keye: string]: any },
-  baseCtor: Component
-): Component | void {
+  baseCtor: typeof Component
+): typeof Component | void {
   if (isTrue(factory.error) && isDef(factory.errorComp)) {
     return factory.errorComp
   }
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index fee173c1c7a..c25203112f3 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -10,15 +10,7 @@ export function initSetup(vm: Component) {
   const options = vm.$options
   const setup = options.setup
   if (setup) {
-    const ctx = {
-      get attrs() {
-        return initAttrsProxy(vm)
-      },
-      get slots() {
-        return initSlotsProxy(vm)
-      },
-      emit: bind(vm.$emit, vm) as any
-    }
+    const ctx = (vm._setupContext = createSetupContext(vm))
 
     setCurrentInstance(vm)
     const setupResult = invokeWithErrorHandling(
@@ -73,6 +65,18 @@ function proxySetupProperty(
   })
 }
 
+function createSetupContext(vm: Component) {
+  return {
+    get attrs() {
+      return initAttrsProxy(vm)
+    },
+    get slots() {
+      return initSlotsProxy(vm)
+    },
+    emit: bind(vm.$emit, vm) as any
+  }
+}
+
 function initAttrsProxy(vm: Component) {
   if (!vm._attrsProxy) {
     const proxy = (vm._attrsProxy = {})
@@ -146,5 +150,6 @@ function getContext(): SetupContext {
   if (__DEV__ && !currentInstance) {
     warn(`useContext() called without active instance.`)
   }
-  return currentInstance!.setupContext
+  const vm = currentInstance!
+  return vm._setupContext || (vm._setupContext = createSetupContext(vm))
 }
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 17d62eeba2d..0e83cf3f09e 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -245,7 +245,7 @@ function doWatch(
     } else {
       // no cb -> simple effect
       getter = () => {
-        if (instance && instance.isUnmounted) {
+        if (instance && instance._isDestroyed) {
           return
         }
         if (cleanup) {
diff --git a/src/v3/currentInstance.ts b/src/v3/currentInstance.ts
index 9beb8b6897e..43a89d85704 100644
--- a/src/v3/currentInstance.ts
+++ b/src/v3/currentInstance.ts
@@ -17,5 +17,7 @@ export function getCurrentInstance(): { proxy: Component } | null {
  * @private
  */
 export function setCurrentInstance(vm: Component | null = null) {
+  if (!vm) currentInstance && currentInstance._scope.off()
   currentInstance = vm
+  vm && vm._scope.on()
 }
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 610527a5c04..40097d3569b 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -57,10 +57,18 @@ export {
   DebuggerEvent
 } from './apiWatch'
 
+export {
+  EffectScope,
+  effectScope,
+  onScopeDispose,
+  getCurrentScope
+} from './reactivity/effectScope'
+
 export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
 export { useSlots, useAttrs } from './apiSetup'
+export { nextTick } from 'core/util'
 
 export * from './apiLifecycle'
diff --git a/src/v3/reactivity/effectScope.ts b/src/v3/reactivity/effectScope.ts
new file mode 100644
index 00000000000..7324d757b99
--- /dev/null
+++ b/src/v3/reactivity/effectScope.ts
@@ -0,0 +1,131 @@
+import Watcher from 'core/observer/watcher'
+import { warn } from 'core/util'
+
+export let activeEffectScope: EffectScope | undefined
+
+export class EffectScope {
+  /**
+   * @internal
+   */
+  active = true
+  /**
+   * @internal
+   */
+  effects: Watcher[] = []
+  /**
+   * @internal
+   */
+  cleanups: (() => void)[] = []
+
+  /**
+   * only assigned by undetached scope
+   * @internal
+   */
+  parent: EffectScope | undefined
+  /**
+   * record undetached scopes
+   * @internal
+   */
+  scopes: EffectScope[] | undefined
+  /**
+   * track a child scope's index in its parent's scopes array for optimized
+   * removal
+   * @internal
+   */
+  private index: number | undefined
+
+  constructor(detached = false) {
+    if (!detached && activeEffectScope) {
+      this.parent = activeEffectScope
+      this.index =
+        (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+          this
+        ) - 1
+    }
+  }
+
+  run<T>(fn: () => T): T | undefined {
+    if (this.active) {
+      const currentEffectScope = activeEffectScope
+      try {
+        activeEffectScope = this
+        return fn()
+      } finally {
+        activeEffectScope = currentEffectScope
+      }
+    } else if (__DEV__) {
+      warn(`cannot run an inactive effect scope.`)
+    }
+  }
+
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  on() {
+    activeEffectScope = this
+  }
+
+  /**
+   * This should only be called on non-detached scopes
+   * @internal
+   */
+  off() {
+    activeEffectScope = this.parent
+  }
+
+  stop(fromParent?: boolean) {
+    if (this.active) {
+      let i, l
+      for (i = 0, l = this.effects.length; i < l; i++) {
+        this.effects[i].teardown()
+      }
+      for (i = 0, l = this.cleanups.length; i < l; i++) {
+        this.cleanups[i]()
+      }
+      if (this.scopes) {
+        for (i = 0, l = this.scopes.length; i < l; i++) {
+          this.scopes[i].stop(true)
+        }
+      }
+      // nested scope, dereference from parent to avoid memory leaks
+      if (this.parent && !fromParent) {
+        // optimized O(1) removal
+        const last = this.parent.scopes!.pop()
+        if (last && last !== this) {
+          this.parent.scopes![this.index!] = last
+          last.index = this.index!
+        }
+      }
+      this.active = false
+    }
+  }
+}
+
+export function effectScope(detached?: boolean) {
+  return new EffectScope(detached)
+}
+
+export function recordEffectScope(
+  effect: Watcher,
+  scope: EffectScope | undefined = activeEffectScope
+) {
+  if (scope && scope.active) {
+    scope.effects.push(effect)
+  }
+}
+
+export function getCurrentScope() {
+  return activeEffectScope
+}
+
+export function onScopeDispose(fn: () => void) {
+  if (activeEffectScope) {
+    activeEffectScope.cleanups.push(fn)
+  } else if (__DEV__) {
+    warn(
+      `onScopeDispose() is called when there is no active effect scope` +
+        ` to be associated with.`
+    )
+  }
+}
diff --git a/test/unit/features/instance/methods-lifecycle.spec.ts b/test/unit/features/instance/methods-lifecycle.spec.ts
index e89b86ea9db..826f1b7a368 100644
--- a/test/unit/features/instance/methods-lifecycle.spec.ts
+++ b/test/unit/features/instance/methods-lifecycle.spec.ts
@@ -107,7 +107,7 @@ describe('Instance methods lifecycle', () => {
       vm.$watch('a', () => {})
       vm.$destroy()
       expect(vm._watcher.active).toBe(false)
-      expect(vm._watchers.every(w => !w.active)).toBe(true)
+      expect(vm._scope.effects.every(w => !w.active)).toBe(true)
     })
 
     it('remove self from data observer', () => {
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 84740cb80e6..9018a88d9de 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -10,10 +10,13 @@ import {
   triggerRef,
   shallowRef,
   h,
-  onMounted
+  onMounted,
+  getCurrentInstance,
+  effectScope
 } from 'v3'
 import { nextTick } from 'core/util'
 import { set } from 'core/observer'
+import { Component } from 'typescript/component'
 
 // reference: https://vue-composition-api-rfc.netlify.com/api.html#watch
 
@@ -1008,35 +1011,6 @@ describe('api: watch', () => {
     expect(cb).toHaveBeenCalledTimes(1)
   })
 
-  test('watching keypath', async () => {
-    const spy = vi.fn()
-    const Comp = {
-      render() {},
-      data() {
-        return {
-          a: {
-            b: 1
-          }
-        }
-      },
-      watch: {
-        'a.b': spy
-      },
-      created(this: any) {
-        this.$watch('a.b', spy)
-      },
-      mounted(this: any) {
-        this.a.b++
-      }
-    }
-
-    const root = document.createElement('div')
-    new Vue(Comp).$mount(root)
-
-    await nextTick()
-    expect(spy).toHaveBeenCalledTimes(2)
-  })
-
   it('watching sources: ref<any[]>', async () => {
     const foo = ref([1])
     const spy = vi.fn()
@@ -1062,25 +1036,24 @@ describe('api: watch', () => {
   })
 
   // vuejs/core#4158
-  // TODO
-  // test.skip('watch should not register in owner component if created inside detached scope', () => {
-  //   let instance: Component
-  //   const Comp = {
-  //     setup() {
-  //       instance = getCurrentInstance()!.proxy
-  //       effectScope(true).run(() => {
-  //         watch(
-  //           () => 1,
-  //           () => {}
-  //         )
-  //       })
-  //       return () => ''
-  //     }
-  //   }
-  //   const root = document.createElement('div')
-  //   new Vue(Comp).$mount(root)
-  //   // should not record watcher in detached scope and only the instance's
-  //   // own update effect
-  //   expect(instance!.scope.effects.length).toBe(1)
-  // })
+  test('watch should not register in owner component if created inside detached scope', () => {
+    let instance: Component
+    const Comp = {
+      setup() {
+        instance = getCurrentInstance()!.proxy
+        effectScope(true).run(() => {
+          watch(
+            () => 1,
+            () => {}
+          )
+        })
+        return () => ''
+      }
+    }
+    const root = document.createElement('div')
+    new Vue(Comp).$mount(root)
+    // should not record watcher in detached scope and only the instance's
+    // own update effect
+    expect(instance!._scope.effects.length).toBe(1)
+  })
 })
diff --git a/test/unit/features/v3/reactivity/effectScope.spec.ts b/test/unit/features/v3/reactivity/effectScope.spec.ts
new file mode 100644
index 00000000000..b82127cdc76
--- /dev/null
+++ b/test/unit/features/v3/reactivity/effectScope.spec.ts
@@ -0,0 +1,282 @@
+import { nextTick } from 'core/util'
+import {
+  watch,
+  watchEffect,
+  reactive,
+  computed,
+  ref,
+  ComputedRef,
+  EffectScope,
+  onScopeDispose,
+  getCurrentScope
+} from 'v3/index'
+import { effect } from 'v3/reactivity/effect'
+
+describe('reactivity/effectScope', () => {
+  it('should run', () => {
+    const fnSpy = vi.fn(() => {})
+    new EffectScope().run(fnSpy)
+    expect(fnSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should accept zero argument', () => {
+    const scope = new EffectScope()
+    expect(scope.effects.length).toBe(0)
+  })
+
+  it('should return run value', () => {
+    expect(new EffectScope().run(() => 1)).toBe(1)
+  })
+
+  it('should collect the effects', () => {
+    const scope = new EffectScope()
+    scope.run(() => {
+      let dummy
+      const counter = reactive({ num: 0 })
+      effect(() => (dummy = counter.num))
+
+      expect(dummy).toBe(0)
+      counter.num = 7
+      expect(dummy).toBe(7)
+    })
+
+    expect(scope.effects.length).toBe(1)
+  })
+
+  it('stop', () => {
+    let dummy, doubled
+    const counter = reactive({ num: 0 })
+
+    const scope = new EffectScope()
+    scope.run(() => {
+      effect(() => (dummy = counter.num))
+      effect(() => (doubled = counter.num * 2))
+    })
+
+    expect(scope.effects.length).toBe(2)
+
+    expect(dummy).toBe(0)
+    counter.num = 7
+    expect(dummy).toBe(7)
+    expect(doubled).toBe(14)
+
+    scope.stop()
+
+    counter.num = 6
+    expect(dummy).toBe(7)
+    expect(doubled).toBe(14)
+  })
+
+  it('should collect nested scope', () => {
+    let dummy, doubled
+    const counter = reactive({ num: 0 })
+
+    const scope = new EffectScope()
+    scope.run(() => {
+      effect(() => (dummy = counter.num))
+      // nested scope
+      new EffectScope().run(() => {
+        effect(() => (doubled = counter.num * 2))
+      })
+    })
+
+    expect(scope.effects.length).toBe(1)
+    expect(scope.scopes!.length).toBe(1)
+    expect(scope.scopes![0]).toBeInstanceOf(EffectScope)
+
+    expect(dummy).toBe(0)
+    counter.num = 7
+    expect(dummy).toBe(7)
+    expect(doubled).toBe(14)
+
+    // stop the nested scope as well
+    scope.stop()
+
+    counter.num = 6
+    expect(dummy).toBe(7)
+    expect(doubled).toBe(14)
+  })
+
+  it('nested scope can be escaped', () => {
+    let dummy, doubled
+    const counter = reactive({ num: 0 })
+
+    const scope = new EffectScope()
+    scope.run(() => {
+      effect(() => (dummy = counter.num))
+      // nested scope
+      new EffectScope(true).run(() => {
+        effect(() => (doubled = counter.num * 2))
+      })
+    })
+
+    expect(scope.effects.length).toBe(1)
+
+    expect(dummy).toBe(0)
+    counter.num = 7
+    expect(dummy).toBe(7)
+    expect(doubled).toBe(14)
+
+    scope.stop()
+
+    counter.num = 6
+    expect(dummy).toBe(7)
+
+    // nested scope should not be stopped
+    expect(doubled).toBe(12)
+  })
+
+  it('able to run the scope', () => {
+    let dummy, doubled
+    const counter = reactive({ num: 0 })
+
+    const scope = new EffectScope()
+    scope.run(() => {
+      effect(() => (dummy = counter.num))
+    })
+
+    expect(scope.effects.length).toBe(1)
+
+    scope.run(() => {
+      effect(() => (doubled = counter.num * 2))
+    })
+
+    expect(scope.effects.length).toBe(2)
+
+    counter.num = 7
+    expect(dummy).toBe(7)
+    expect(doubled).toBe(14)
+
+    scope.stop()
+  })
+
+  it('can not run an inactive scope', () => {
+    let dummy, doubled
+    const counter = reactive({ num: 0 })
+
+    const scope = new EffectScope()
+    scope.run(() => {
+      effect(() => (dummy = counter.num))
+    })
+
+    expect(scope.effects.length).toBe(1)
+
+    scope.stop()
+
+    scope.run(() => {
+      effect(() => (doubled = counter.num * 2))
+    })
+
+    expect('cannot run an inactive effect scope.').toHaveBeenWarned()
+
+    expect(scope.effects.length).toBe(1)
+
+    counter.num = 7
+    expect(dummy).toBe(0)
+    expect(doubled).toBe(undefined)
+  })
+
+  it('should fire onScopeDispose hook', () => {
+    let dummy = 0
+
+    const scope = new EffectScope()
+    scope.run(() => {
+      onScopeDispose(() => (dummy += 1))
+      onScopeDispose(() => (dummy += 2))
+    })
+
+    scope.run(() => {
+      onScopeDispose(() => (dummy += 4))
+    })
+
+    expect(dummy).toBe(0)
+
+    scope.stop()
+    expect(dummy).toBe(7)
+  })
+
+  it('should warn onScopeDispose() is called when there is no active effect scope', () => {
+    const spy = vi.fn()
+    const scope = new EffectScope()
+    scope.run(() => {
+      onScopeDispose(spy)
+    })
+
+    expect(spy).toHaveBeenCalledTimes(0)
+
+    onScopeDispose(spy)
+
+    expect(
+      'onScopeDispose() is called when there is no active effect scope to be associated with.'
+    ).toHaveBeenWarned()
+
+    scope.stop()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should dereference child scope from parent scope after stopping child scope (no memleaks)', () => {
+    const parent = new EffectScope()
+    const child = parent.run(() => new EffectScope())!
+    expect(parent.scopes!.includes(child)).toBe(true)
+    child.stop()
+    expect(parent.scopes!.includes(child)).toBe(false)
+  })
+
+  it('test with higher level APIs', async () => {
+    const r = ref(1)
+
+    const computedSpy = vi.fn()
+    const watchSpy = vi.fn()
+    const watchEffectSpy = vi.fn()
+
+    let c: ComputedRef
+    const scope = new EffectScope()
+    scope.run(() => {
+      c = computed(() => {
+        computedSpy()
+        return r.value + 1
+      })
+
+      watch(r, watchSpy)
+      watchEffect(() => {
+        watchEffectSpy()
+        r.value
+      })
+    })
+
+    c!.value // computed is lazy so trigger collection
+    expect(computedSpy).toHaveBeenCalledTimes(1)
+    expect(watchSpy).toHaveBeenCalledTimes(0)
+    expect(watchEffectSpy).toHaveBeenCalledTimes(1)
+
+    r.value++
+    c!.value
+    await nextTick()
+    expect(computedSpy).toHaveBeenCalledTimes(2)
+    expect(watchSpy).toHaveBeenCalledTimes(1)
+    expect(watchEffectSpy).toHaveBeenCalledTimes(2)
+
+    scope.stop()
+
+    r.value++
+    c!.value
+    await nextTick()
+    // should not trigger anymore
+    expect(computedSpy).toHaveBeenCalledTimes(2)
+    expect(watchSpy).toHaveBeenCalledTimes(1)
+    expect(watchEffectSpy).toHaveBeenCalledTimes(2)
+  })
+
+  it('getCurrentScope() stays valid when running a detached nested EffectScope', () => {
+    const parentScope = new EffectScope()
+
+    parentScope.run(() => {
+      const currentScope = getCurrentScope()
+      expect(currentScope).toBeDefined()
+      const detachedScope = new EffectScope(true)
+      detachedScope.run(() => {})
+
+      expect(getCurrentScope()).toBe(currentScope)
+    })
+  })
+})
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index a95719dc543..c1e2d3b1516 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -1,8 +1,9 @@
 import type VNode from '../src/core/vdom/vnode'
 import type Watcher from '../src/core/observer/watcher'
-import { ComponentOptions } from './options'
+import { ComponentOptions, SetupContext } from './options'
 import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
 import { GlobalAPI } from './global-api'
+import { EffectScope } from 'v3'
 
 // TODO this should be using the same as /component/
 
@@ -16,7 +17,7 @@ export declare class Component {
   static superOptions: Record<string, any>
   static extendOptions: Record<string, any>
   static sealedOptions: Record<string, any>
-  static super: Component
+  static super: typeof Component
   // assets
   static directive: GlobalAPI['directive']
   static component: GlobalAPI['component']
@@ -58,7 +59,7 @@ export declare class Component {
     key: string | number
   ) => void
   $watch: (
-    expOrFn: string | Function,
+    expOrFn: string | (() => any),
     cb: Function,
     options?: Record<string, any>
   ) => Function
@@ -66,7 +67,7 @@ export declare class Component {
   $once: (event: string, fn: Function) => Component
   $off: (event?: string | Array<string>, fn?: Function) => Component
   $emit: (event: string, ...args: Array<any>) => Component
-  $nextTick: (fn: Function) => void | Promise<any>
+  $nextTick: (fn: (...args: any[]) => any) => void | Promise<any>
   $createElement: (
     tag?: string | Component,
     data?: Record<string, any>,
@@ -77,11 +78,12 @@ export declare class Component {
   _uid: number | string
   _name: string // this only exists in dev mode
   _isVue: true
+  __v_skip: true
   _self: Component
   _renderProxy: Component
   _renderContext?: Component
   _watcher: Watcher | null
-  _watchers: Array<Watcher>
+  _scope: EffectScope
   _computedWatchers: { [key: string]: Watcher }
   _data: Record<string, any>
   _props: Record<string, any>
@@ -99,6 +101,7 @@ export declare class Component {
 
   // @v3
   _setupState?: Record<string, any>
+  _setupContext?: SetupContext
   _attrsProxy?: Record<string, any>
   _slotsProxy?: Record<string, () => VNode[]>
   _preWatchers?: Watcher[]
@@ -193,8 +196,8 @@ export declare class Component {
   _ssrAttrs: Function
   _ssrDOMProps: Function
   _ssrClass: Function
-  _ssrStyle: Function;
+  _ssrStyle: Function
 
   // allow dynamic method registration
-  [key: string]: any
+  // [key: string]: any
 }
diff --git a/typescript/global-api.d.ts b/typescript/global-api.d.ts
index eab61b82b2a..8afef2ae8da 100644
--- a/typescript/global-api.d.ts
+++ b/typescript/global-api.d.ts
@@ -1,5 +1,6 @@
 import { Config } from '../src/core/config'
 import { Component } from './component'
+import { ComponentOptions } from './options'
 
 declare interface GlobalAPI {
   // new(options?: any): Component
@@ -9,7 +10,7 @@ declare interface GlobalAPI {
   config: Config
   util: Object
 
-  extend: (options: Object) => typeof Component
+  extend: (options: typeof Component | ComponentOptions) => typeof Component
   set: <T>(target: Object | Array<T>, key: string | number, value: T) => T
   delete: <T>(target: Object | Array<T>, key: string | number) => void
   nextTick: (fn: Function, context?: Object) => void | Promise<any>
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
index bd59f80889d..bd2af3a3b18 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.d.ts
@@ -100,7 +100,7 @@ declare type ComponentOptions = {
   _renderChildren?: Array<VNode> | null
   _componentTag: string | null
   _scopeId: string | null
-  _base: Component
+  _base: typeof Component
 }
 
 declare type PropOptions = {
diff --git a/typescript/vnode.d.ts b/typescript/vnode.d.ts
index 36dc1c4ff95..5fd49babff0 100644
--- a/typescript/vnode.d.ts
+++ b/typescript/vnode.d.ts
@@ -6,7 +6,7 @@ declare type VNodeChildren =
   | string
 
 declare type VNodeComponentOptions = {
-  Ctor: Component
+  Ctor: typeof Component
   propsData?: Object
   listeners?: Record<string, Function | Function[]>
   children?: Array<VNode>

From 15c5c43ca65443a463013010f9d55ce54b0f4e59 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 15:05:35 +0800
Subject: [PATCH 092/317] wip: onTrack debugger option

---
 src/core/instance/state.ts                    |  9 +++
 src/core/observer/dep.ts                      | 39 +++++++++-
 src/core/observer/index.ts                    | 16 +++-
 src/core/observer/watcher.ts                  |  6 +-
 src/core/util/debug.ts                        |  1 -
 src/v3/apiWatch.ts                            | 33 ++------
 src/v3/index.ts                               |  9 ++-
 src/v3/reactivity/computed.ts                 | 18 ++++-
 src/v3/reactivity/operations.ts               |  6 +-
 src/v3/reactivity/reactive.ts                 |  1 -
 src/v3/reactivity/ref.ts                      | 17 +++-
 test/unit/features/v3/apiWatch.spec.ts        | 77 ++++++++++---------
 .../features/v3/reactivity/computed.spec.ts   | 65 +++++++---------
 13 files changed, 176 insertions(+), 121 deletions(-)

diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index f9da112d214..d56761f9023 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -30,6 +30,7 @@ import {
   isFunction
 } from '../util/index'
 import type { Component } from 'typescript/component'
+import { TrackOpTypes } from '../../v3'
 
 const sharedPropertyDefinition = {
   enumerable: true,
@@ -254,6 +255,14 @@ function createComputedGetter(key) {
         watcher.evaluate()
       }
       if (Dep.target) {
+        if (__DEV__ && Dep.target.onTrack) {
+          Dep.target.onTrack({
+            effect: Dep.target,
+            target: this,
+            type: TrackOpTypes.GET,
+            key
+          })
+        }
         watcher.depend()
       }
       return watcher.value
diff --git a/src/core/observer/dep.ts b/src/core/observer/dep.ts
index df14f2f2f4c..fd5c6a2c1cf 100644
--- a/src/core/observer/dep.ts
+++ b/src/core/observer/dep.ts
@@ -1,14 +1,33 @@
 import { remove } from '../util/index'
 import config from '../config'
+import { TrackOpTypes, TriggerOpTypes } from 'v3'
 
 let uid = 0
 
-export interface DepTarget {
+export interface DepTarget extends DebuggerOptions {
   id: number
   addDep(dep: Dep): void
   update(): void
 }
 
+export interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void
+  onTrigger?: (event: DebuggerEvent) => void
+}
+
+export type DebuggerEvent = {
+  effect: DepTarget
+} & DebuggerEventExtraInfo
+
+export type DebuggerEventExtraInfo = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key?: any
+  newValue?: any
+  oldValue?: any
+  oldTarget?: Map<any, any> | Set<any>
+}
+
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
@@ -31,13 +50,19 @@ export default class Dep {
     remove(this.subs, sub)
   }
 
-  depend() {
+  depend(info?: DebuggerEventExtraInfo) {
     if (Dep.target) {
       Dep.target.addDep(this)
+      if (__DEV__ && info && Dep.target.onTrack) {
+        Dep.target.onTrack({
+          effect: Dep.target,
+          ...info
+        })
+      }
     }
   }
 
-  notify() {
+  notify(info?: DebuggerEventExtraInfo) {
     // stabilize the subscriber list first
     const subs = this.subs.slice()
     if (__DEV__ && !config.async) {
@@ -47,6 +72,14 @@ export default class Dep {
       subs.sort((a, b) => a.id - b.id)
     }
     for (let i = 0, l = subs.length; i < l; i++) {
+      if (__DEV__ && info) {
+        const sub = subs[i]
+        sub.onTrigger &&
+          sub.onTrigger({
+            effect: subs[i],
+            ...info
+          })
+      }
       subs[i].update()
     }
   }
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index c043f3923de..77c200f60af 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -15,7 +15,7 @@ import {
   isServerRendering,
   hasChanged
 } from '../util/index'
-import { isReadonly, isRef } from '../../v3'
+import { isReadonly, isRef, TrackOpTypes } from '../../v3'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
@@ -165,7 +165,15 @@ export function defineReactive(
     get: function reactiveGetter() {
       const value = getter ? getter.call(obj) : val
       if (Dep.target) {
-        dep.depend()
+        if (__DEV__) {
+          dep.depend({
+            target: obj,
+            type: TrackOpTypes.GET,
+            key
+          })
+        } else {
+          dep.depend()
+        }
         if (childOb) {
           childOb.dep.depend()
           if (isArray(value)) {
@@ -291,7 +299,9 @@ export function del(target: Array<any> | Object, key: any) {
 function dependArray(value: Array<any>) {
   for (let e, i = 0, l = value.length; i < l; i++) {
     e = value[i]
-    e && e.__ob__ && e.__ob__.dep.depend()
+    if (e && e.__ob__) {
+      e.__ob__.dep.depend()
+    }
     if (isArray(e)) {
       dependArray(e)
     }
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 2225249570e..118c9fea5c7 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -12,7 +12,7 @@ import {
 
 import { traverse } from './traverse'
 import { queueWatcher } from './scheduler'
-import Dep, { pushTarget, popTarget, DepTarget } from './dep'
+import Dep, { pushTarget, popTarget, DepTarget, DebuggerEvent } from './dep'
 
 import type { SimpleSet } from '../util/index'
 import type { Component } from 'typescript/component'
@@ -49,6 +49,10 @@ export default class Watcher implements DepTarget {
   getter: Function
   value: any
 
+  // dev only
+  onTrack?: ((event: DebuggerEvent) => void) | undefined
+  onTrigger?: ((event: DebuggerEvent) => void) | undefined
+
   constructor(
     vm: Component | null,
     expOrFn: string | (() => any),
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index 99d6b8eb437..e8aa02b87cc 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -15,7 +15,6 @@ if (__DEV__) {
     str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '')
 
   warn = (msg, vm = currentInstance) => {
-    // TODO get current instance
     const trace = vm ? generateComponentTrace(vm) : ''
 
     if (config.warnHandler) {
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 0e83cf3f09e..c5487976b60 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -15,7 +15,7 @@ import { currentInstance } from './currentInstance'
 import { traverse } from 'core/observer/traverse'
 import Watcher from '../core/observer/watcher'
 import { queueWatcher } from '../core/observer/scheduler'
-import { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
+import { DebuggerOptions } from '../core/observer/dep'
 
 const WATCHER = `watcher`
 const WATCHER_CB = `${WATCHER} callback`
@@ -50,24 +50,6 @@ export interface WatchOptionsBase extends DebuggerOptions {
   flush?: 'pre' | 'post' | 'sync'
 }
 
-export interface DebuggerOptions {
-  onTrack?: (event: DebuggerEvent) => void
-  onTrigger?: (event: DebuggerEvent) => void
-}
-
-export type DebuggerEvent = {
-  watcher: Watcher
-} & DebuggerEventExtraInfo
-
-export type DebuggerEventExtraInfo = {
-  target: object
-  type: TrackOpTypes | TriggerOpTypes
-  key: any
-  newValue?: any
-  oldValue?: any
-  oldTarget?: Map<any, any> | Set<any>
-}
-
 export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
   immediate?: Immediate
   deep?: boolean
@@ -349,11 +331,10 @@ function doWatch(
     }
   }
 
-  // TODO
-  // if (__DEV__) {
-  //   effect.onTrack = onTrack
-  //   effect.onTrigger = onTrigger
-  // }
+  if (__DEV__) {
+    watcher.onTrack = onTrack
+    watcher.onTrigger = onTrigger
+  }
 
   // initial run
   if (cb) {
@@ -370,9 +351,5 @@ function doWatch(
 
   return () => {
     watcher.teardown()
-    // TODO
-    // if (instance && instance.scope) {
-    //   remove(instance.scope.effects!, effect)
-    // }
   }
 }
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 40097d3569b..4cd90665190 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -52,9 +52,7 @@ export {
   WatchOptionsBase,
   WatchCallback,
   WatchSource,
-  WatchStopHandle,
-  DebuggerOptions,
-  DebuggerEvent
+  WatchStopHandle
 } from './apiWatch'
 
 export {
@@ -64,6 +62,11 @@ export {
   getCurrentScope
 } from './reactivity/effectScope'
 
+export {
+  DebuggerOptions,
+  DebuggerEvent,
+  DebuggerEventExtraInfo
+} from 'core/observer/dep'
 export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
 export { h } from './h'
diff --git a/src/v3/reactivity/computed.ts b/src/v3/reactivity/computed.ts
index 01ee2f34e93..9e9368b858d 100644
--- a/src/v3/reactivity/computed.ts
+++ b/src/v3/reactivity/computed.ts
@@ -1,10 +1,10 @@
 import { isServerRendering, noop, warn, def, isFunction } from 'core/util'
 import { Ref, RefFlag } from './ref'
 import Watcher from 'core/observer/watcher'
-import Dep from 'core/observer/dep'
+import Dep, { DebuggerOptions } from 'core/observer/dep'
 import { currentInstance } from '../currentInstance'
-import { DebuggerOptions } from '../apiWatch'
 import { ReactiveFlags } from './reactive'
+import { TrackOpTypes } from './operations'
 
 declare const ComputedRefSymbol: unique symbol
 
@@ -35,7 +35,6 @@ export function computed<T>(
 ): WritableComputedRef<T>
 export function computed<T>(
   getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>,
-  // TODO debug options
   debugOptions?: DebuggerOptions
 ) {
   let getter: ComputedGetter<T>
@@ -58,6 +57,11 @@ export function computed<T>(
     ? null
     : new Watcher(currentInstance, getter, noop, { lazy: true })
 
+  if (__DEV__ && watcher && debugOptions) {
+    watcher.onTrack = debugOptions.onTrack
+    watcher.onTrigger = debugOptions.onTrigger
+  }
+
   const ref = {
     // some libs rely on the presence effect for checking computed refs
     // from normal refs, but the implementation doesn't matter
@@ -68,6 +72,14 @@ export function computed<T>(
           watcher.evaluate()
         }
         if (Dep.target) {
+          if (__DEV__ && Dep.target.onTrack) {
+            Dep.target.onTrack({
+              effect: Dep.target,
+              target: ref,
+              type: TrackOpTypes.GET,
+              key: 'value'
+            })
+          }
           watcher.depend()
         }
         return watcher.value
diff --git a/src/v3/reactivity/operations.ts b/src/v3/reactivity/operations.ts
index 1b96e982571..0ffb422b5e8 100644
--- a/src/v3/reactivity/operations.ts
+++ b/src/v3/reactivity/operations.ts
@@ -3,13 +3,11 @@
 
 export const enum TrackOpTypes {
   GET = 'get',
-  HAS = 'has',
-  ITERATE = 'iterate'
+  TOUCH = 'touch'
 }
 
 export const enum TriggerOpTypes {
   SET = 'set',
   ADD = 'add',
-  DELETE = 'delete',
-  CLEAR = 'clear'
+  DELETE = 'delete'
 }
diff --git a/src/v3/reactivity/reactive.ts b/src/v3/reactivity/reactive.ts
index ed79cfda032..b1bf54c69c2 100644
--- a/src/v3/reactivity/reactive.ts
+++ b/src/v3/reactivity/reactive.ts
@@ -93,7 +93,6 @@ export function isShallow(value: unknown): boolean {
 }
 
 export function isReadonly(value: unknown): boolean {
-  // TODO
   return !!(value && (value as Target).__v_isReadonly)
 }
 
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index 71cabb3d066..7f82108f821 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -7,6 +7,7 @@ import {
 import type { IfAny } from 'typescript/utils'
 import Dep from 'core/observer/dep'
 import { warn, isArray, def } from 'core/util'
+import { TrackOpTypes } from './operations'
 
 declare const RefSymbol: unique symbol
 export declare const RawSymbol: unique symbol
@@ -91,8 +92,20 @@ export type CustomRefFactory<T> = (
 export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
   const dep = new Dep()
   const { get, set } = factory(
-    () => dep.depend(),
-    () => dep.notify()
+    () => {
+      if (__DEV__) {
+        dep.depend({
+          target: ref,
+          type: TrackOpTypes.GET,
+          key: 'value'
+        })
+      } else {
+        dep.depend()
+      }
+    },
+    () => {
+      dep.notify()
+    }
   )
   const ref = {
     get value() {
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 9018a88d9de..1158a260777 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -12,7 +12,10 @@ import {
   h,
   onMounted,
   getCurrentInstance,
-  effectScope
+  effectScope,
+  TrackOpTypes,
+  TriggerOpTypes,
+  DebuggerEvent
 } from 'v3'
 import { nextTick } from 'core/util'
 import { set } from 'core/observer'
@@ -777,41 +780,43 @@ describe('api: watch', () => {
     expect(`"deep" option is only respected`).toHaveBeenWarned()
   })
 
-  // TODO
-  // it('onTrack', async () => {
-  //   const events: DebuggerEvent[] = []
-  //   let dummy
-  //   const onTrack = vi.fn((e: DebuggerEvent) => {
-  //     events.push(e)
-  //   })
-  //   const obj = reactive({ foo: 1, bar: 2 })
-  //   watchEffect(
-  //     () => {
-  //       dummy = [obj.foo, 'bar' in obj, Object.keys(obj)]
-  //     },
-  //     { onTrack }
-  //   )
-  //   await nextTick()
-  //   expect(dummy).toEqual([1, true, ['foo', 'bar']])
-  //   expect(onTrack).toHaveBeenCalledTimes(3)
-  //   expect(events).toMatchObject([
-  //     {
-  //       target: obj,
-  //       type: TrackOpTypes.GET,
-  //       key: 'foo'
-  //     },
-  //     {
-  //       target: obj,
-  //       type: TrackOpTypes.HAS,
-  //       key: 'bar'
-  //     },
-  //     {
-  //       target: obj,
-  //       type: TrackOpTypes.ITERATE,
-  //       key: ITERATE_KEY
-  //     }
-  //   ])
-  // })
+  it('onTrack', async () => {
+    const events: DebuggerEvent[] = []
+    let dummy
+    const onTrack = vi.fn((e: DebuggerEvent) => {
+      events.push(e)
+    })
+    const obj = reactive({ foo: 1 })
+    const r = ref(2)
+    const c = computed(() => r.value + 1)
+    // TODO computed & ref
+    watchEffect(
+      () => {
+        dummy = obj.foo + r.value + c.value
+      },
+      { onTrack }
+    )
+    await nextTick()
+    expect(dummy).toEqual(6)
+    expect(onTrack).toHaveBeenCalledTimes(3)
+    expect(events).toMatchObject([
+      {
+        target: obj,
+        type: TrackOpTypes.GET,
+        key: 'foo'
+      },
+      {
+        target: r,
+        type: TrackOpTypes.GET,
+        key: 'value'
+      },
+      {
+        target: c,
+        type: TrackOpTypes.GET,
+        key: 'value'
+      }
+    ])
+  })
 
   // it('onTrigger', async () => {
   //   const events: DebuggerEvent[] = []
diff --git a/test/unit/features/v3/reactivity/computed.spec.ts b/test/unit/features/v3/reactivity/computed.spec.ts
index 5ca4ab4da6b..3d7cf260a12 100644
--- a/test/unit/features/v3/reactivity/computed.spec.ts
+++ b/test/unit/features/v3/reactivity/computed.spec.ts
@@ -3,9 +3,9 @@ import {
   reactive,
   ref,
   isReadonly,
-  // toRaw,
-  WritableComputedRef
-  // DebuggerEvent
+  WritableComputedRef,
+  DebuggerEvent,
+  TrackOpTypes
 } from 'v3'
 import { effect } from 'v3/reactivity/effect'
 import { nextTick } from 'core/util'
@@ -225,39 +225,32 @@ describe('reactivity/computed', () => {
     expect(x.value).toBe(1)
   })
 
-  // TODO
-  // it('debug: onTrack', () => {
-  //   let events: DebuggerEvent[] = []
-  //   const onTrack = vi.fn((e: DebuggerEvent) => {
-  //     events.push(e)
-  //   })
-  //   const obj = reactive({ foo: 1, bar: 2 })
-  //   const c = computed(() => (obj.foo, 'bar' in obj, Object.keys(obj)), {
-  //     onTrack
-  //   })
-  //   expect(c.value).toEqual(['foo', 'bar'])
-  //   expect(onTrack).toHaveBeenCalledTimes(3)
-  //   expect(events).toEqual([
-  //     {
-  //       effect: c.effect,
-  //       target: toRaw(obj),
-  //       type: TrackOpTypes.GET,
-  //       key: 'foo'
-  //     },
-  //     {
-  //       effect: c.effect,
-  //       target: toRaw(obj),
-  //       type: TrackOpTypes.HAS,
-  //       key: 'bar'
-  //     },
-  //     {
-  //       effect: c.effect,
-  //       target: toRaw(obj),
-  //       type: TrackOpTypes.ITERATE,
-  //       key: ITERATE_KEY
-  //     }
-  //   ])
-  // })
+  it('debug: onTrack', () => {
+    let events: DebuggerEvent[] = []
+    const onTrack = vi.fn((e: DebuggerEvent) => {
+      events.push(e)
+    })
+    const obj = reactive({ foo: 1, bar: 2 })
+    const c = computed(() => obj.foo + obj.bar, {
+      onTrack
+    })
+    expect(c.value).toEqual(3)
+    expect(onTrack).toHaveBeenCalledTimes(2)
+    expect(events).toEqual([
+      {
+        effect: c.effect,
+        target: obj,
+        type: TrackOpTypes.GET,
+        key: 'foo'
+      },
+      {
+        effect: c.effect,
+        target: obj,
+        type: TrackOpTypes.GET,
+        key: 'bar'
+      }
+    ])
+  })
 
   // TODO
   // it('debug: onTrigger', () => {

From 075f215edfff12b50b80d9e5cd230548bb98538a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 15:39:49 +0800
Subject: [PATCH 093/317] wip: onTrack/onTrigger debugger options

---
 src/core/observer/array.ts                    | 11 ++-
 src/core/observer/index.ts                    | 37 +++++++-
 src/v3/reactivity/operations.ts               |  3 +-
 src/v3/reactivity/ref.ts                      | 23 ++++-
 test/unit/features/v3/apiWatch.spec.ts        | 91 +++++++++++--------
 .../features/v3/reactivity/computed.spec.ts   | 86 ++++++++++--------
 test/unit/features/v3/reactivity/ref.spec.ts  |  5 +-
 typescript/component.d.ts                     |  5 +-
 typescript/global-api.d.ts                    |  3 +-
 9 files changed, 174 insertions(+), 90 deletions(-)

diff --git a/src/core/observer/array.ts b/src/core/observer/array.ts
index c043d9dfe76..b2ff2385555 100644
--- a/src/core/observer/array.ts
+++ b/src/core/observer/array.ts
@@ -3,6 +3,7 @@
  * dynamically accessing methods on Array prototype
  */
 
+import { TriggerOpTypes } from '../../v3'
 import { def } from '../util/index'
 
 const arrayProto = Array.prototype
@@ -39,7 +40,15 @@ methodsToPatch.forEach(function (method) {
     }
     if (inserted) ob.observeArray(inserted)
     // notify change
-    ob.dep.notify()
+    if (__DEV__) {
+      ob.dep.notify({
+        type: TriggerOpTypes.ARRAY_MUTATION,
+        target: this,
+        key: method
+      })
+    } else {
+      ob.dep.notify()
+    }
     return result
   })
 })
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 77c200f60af..a32ed049ec3 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -15,7 +15,7 @@ import {
   isServerRendering,
   hasChanged
 } from '../util/index'
-import { isReadonly, isRef, TrackOpTypes } from '../../v3'
+import { isReadonly, isRef, TrackOpTypes, TriggerOpTypes } from '../../v3'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
@@ -198,11 +198,22 @@ export function defineReactive(
         return
       } else if (isRef(value) && !isRef(newVal)) {
         value.value = newVal
+        return
       } else {
         val = newVal
       }
       childOb = !shallow && observe(newVal)
-      dep.notify()
+      if (__DEV__) {
+        dep.notify({
+          type: TriggerOpTypes.SET,
+          target: obj,
+          key,
+          newValue: newVal,
+          oldValue: value
+        })
+      } else {
+        dep.notify()
+      }
     }
   })
 
@@ -251,7 +262,17 @@ export function set(
     return val
   }
   defineReactive(ob.value, key, val)
-  ob.dep.notify()
+  if (__DEV__) {
+    ob.dep.notify({
+      type: TriggerOpTypes.ADD,
+      target: target,
+      key,
+      newValue: val,
+      oldValue: undefined
+    })
+  } else {
+    ob.dep.notify()
+  }
   return val
 }
 
@@ -289,7 +310,15 @@ export function del(target: Array<any> | Object, key: any) {
   if (!ob) {
     return
   }
-  ob.dep.notify()
+  if (__DEV__) {
+    ob.dep.notify({
+      type: TriggerOpTypes.DELETE,
+      target: target,
+      key
+    })
+  } else {
+    ob.dep.notify()
+  }
 }
 
 /**
diff --git a/src/v3/reactivity/operations.ts b/src/v3/reactivity/operations.ts
index 0ffb422b5e8..9e6bec51878 100644
--- a/src/v3/reactivity/operations.ts
+++ b/src/v3/reactivity/operations.ts
@@ -9,5 +9,6 @@ export const enum TrackOpTypes {
 export const enum TriggerOpTypes {
   SET = 'set',
   ADD = 'add',
-  DELETE = 'delete'
+  DELETE = 'delete',
+  ARRAY_MUTATION = 'array mutation'
 }
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index 7f82108f821..21453c40f2d 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -7,7 +7,7 @@ import {
 import type { IfAny } from 'typescript/utils'
 import Dep from 'core/observer/dep'
 import { warn, isArray, def } from 'core/util'
-import { TrackOpTypes } from './operations'
+import { TrackOpTypes, TriggerOpTypes } from './operations'
 
 declare const RefSymbol: unique symbol
 export declare const RawSymbol: unique symbol
@@ -74,7 +74,16 @@ export function triggerRef(ref: Ref) {
   if (__DEV__ && !ref.dep) {
     warn(`received object is not a triggerable ref.`)
   }
-  ref.dep && ref.dep.notify()
+  if (__DEV__) {
+    ref.dep &&
+      ref.dep.notify({
+        type: TriggerOpTypes.SET,
+        target: ref,
+        key: 'value'
+      })
+  } else {
+    ref.dep && ref.dep.notify()
+  }
 }
 
 export function unref<T>(ref: T | Ref<T>): T {
@@ -104,7 +113,15 @@ export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
       }
     },
     () => {
-      dep.notify()
+      if (__DEV__) {
+        dep.notify({
+          target: ref,
+          type: TriggerOpTypes.SET,
+          key: 'value'
+        })
+      } else {
+        dep.notify()
+      }
     }
   )
   const ref = {
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 1158a260777..beff133f98f 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -789,7 +789,6 @@ describe('api: watch', () => {
     const obj = reactive({ foo: 1 })
     const r = ref(2)
     const c = computed(() => r.value + 1)
-    // TODO computed & ref
     watchEffect(
       () => {
         dummy = obj.foo + r.value + c.value
@@ -818,43 +817,59 @@ describe('api: watch', () => {
     ])
   })
 
-  // it('onTrigger', async () => {
-  //   const events: DebuggerEvent[] = []
-  //   let dummy
-  //   const onTrigger = vi.fn((e: DebuggerEvent) => {
-  //     events.push(e)
-  //   })
-  //   const obj = reactive<{ foo?: number }>({ foo: 1 })
-  //   watchEffect(
-  //     () => {
-  //       dummy = obj.foo
-  //     },
-  //     { onTrigger }
-  //   )
-  //   await nextTick()
-  //   expect(dummy).toBe(1)
-
-  //   obj.foo!++
-  //   await nextTick()
-  //   expect(dummy).toBe(2)
-  //   expect(onTrigger).toHaveBeenCalledTimes(1)
-  //   expect(events[0]).toMatchObject({
-  //     type: TriggerOpTypes.SET,
-  //     key: 'foo',
-  //     oldValue: 1,
-  //     newValue: 2
-  //   })
-
-  //   delete obj.foo
-  //   await nextTick()
-  //   expect(dummy).toBeUndefined()
-  //   expect(onTrigger).toHaveBeenCalledTimes(2)
-  //   expect(events[1]).toMatchObject({
-  //     type: TriggerOpTypes.DELETE,
-  //     key: 'foo',
-  //     oldValue: 2
-  //   })
-  // })
+  it('onTrigger', async () => {
+    const events: DebuggerEvent[] = []
+    let dummy
+    const onTrigger = vi.fn((e: DebuggerEvent) => {
+      events.push(e)
+    })
+    const obj = reactive<{
+      foo: number
+      bar: any[]
+      baz: { qux?: number }
+    }>({ foo: 1, bar: [], baz: {} })
+
+    watchEffect(
+      () => {
+        dummy = obj.foo + (obj.bar[0] || 0) + (obj.baz.qux || 0)
+      },
+      { onTrigger }
+    )
+    await nextTick()
+    expect(dummy).toBe(1)
+
+    obj.foo++
+    await nextTick()
+    expect(dummy).toBe(2)
+    expect(onTrigger).toHaveBeenCalledTimes(1)
+    expect(events[0]).toMatchObject({
+      type: TriggerOpTypes.SET,
+      key: 'foo',
+      target: obj,
+      oldValue: 1,
+      newValue: 2
+    })
+
+    obj.bar.push(1)
+    await nextTick()
+    expect(dummy).toBe(3)
+    expect(onTrigger).toHaveBeenCalledTimes(2)
+    expect(events[1]).toMatchObject({
+      type: TriggerOpTypes.ARRAY_MUTATION,
+      target: obj.bar,
+      key: 'push'
+    })
+
+    set(obj.baz, 'qux', 1)
+    await nextTick()
+    expect(dummy).toBe(4)
+    expect(onTrigger).toHaveBeenCalledTimes(3)
+    expect(events[2]).toMatchObject({
+      type: TriggerOpTypes.ADD,
+      target: obj.baz,
+      key: 'qux'
+    })
+  })
 
   it('should work sync', () => {
     const v = ref(1)
diff --git a/test/unit/features/v3/reactivity/computed.spec.ts b/test/unit/features/v3/reactivity/computed.spec.ts
index 3d7cf260a12..b03278877cf 100644
--- a/test/unit/features/v3/reactivity/computed.spec.ts
+++ b/test/unit/features/v3/reactivity/computed.spec.ts
@@ -5,11 +5,12 @@ import {
   isReadonly,
   WritableComputedRef,
   DebuggerEvent,
-  TrackOpTypes
+  TrackOpTypes,
+  TriggerOpTypes
 } from 'v3'
 import { effect } from 'v3/reactivity/effect'
 import { nextTick } from 'core/util'
-// import { TrackOpTypes, TriggerOpTypes } from 'v3/reactivity/operations'
+import { set, del } from 'core/observer/index'
 
 describe('reactivity/computed', () => {
   it('should return updated value', () => {
@@ -252,40 +253,49 @@ describe('reactivity/computed', () => {
     ])
   })
 
-  // TODO
-  // it('debug: onTrigger', () => {
-  //   let events: DebuggerEvent[] = []
-  //   const onTrigger = vi.fn((e: DebuggerEvent) => {
-  //     events.push(e)
-  //   })
-  //   const obj = reactive({ foo: 1 })
-  //   const c = computed(() => obj.foo, { onTrigger })
-
-  //   // computed won't trigger compute until accessed
-  //   c.value
-
-  //   obj.foo++
-  //   expect(c.value).toBe(2)
-  //   expect(onTrigger).toHaveBeenCalledTimes(1)
-  //   expect(events[0]).toEqual({
-  //     effect: c.effect,
-  //     target: toRaw(obj),
-  //     type: TriggerOpTypes.SET,
-  //     key: 'foo',
-  //     oldValue: 1,
-  //     newValue: 2
-  //   })
-
-  //   // @ts-ignore
-  //   delete obj.foo
-  //   expect(c.value).toBeUndefined()
-  //   expect(onTrigger).toHaveBeenCalledTimes(2)
-  //   expect(events[1]).toEqual({
-  //     effect: c.effect,
-  //     target: toRaw(obj),
-  //     type: TriggerOpTypes.DELETE,
-  //     key: 'foo',
-  //     oldValue: 2
-  //   })
-  // })
+  it('debug: onTrigger', () => {
+    let events: DebuggerEvent[] = []
+    const onTrigger = vi.fn((e: DebuggerEvent) => {
+      events.push(e)
+    })
+    const obj = reactive({ foo: 1, bar: { baz: 2 } })
+    const c = computed(() => obj.foo + (obj.bar.baz || 0), { onTrigger })
+
+    // computed won't trigger compute until accessed
+    c.value
+
+    obj.foo++
+    expect(c.value).toBe(4)
+    expect(onTrigger).toHaveBeenCalledTimes(1)
+    expect(events[0]).toEqual({
+      effect: c.effect,
+      target: obj,
+      type: TriggerOpTypes.SET,
+      key: 'foo',
+      oldValue: 1,
+      newValue: 2
+    })
+
+    del(obj.bar, 'baz')
+    expect(c.value).toBe(2)
+    expect(onTrigger).toHaveBeenCalledTimes(2)
+    expect(events[1]).toEqual({
+      effect: c.effect,
+      target: obj.bar,
+      type: TriggerOpTypes.DELETE,
+      key: 'baz'
+    })
+
+    set(obj.bar, 'baz', 1)
+    expect(c.value).toBe(3)
+    expect(onTrigger).toHaveBeenCalledTimes(3)
+    expect(events[2]).toEqual({
+      effect: c.effect,
+      target: obj.bar,
+      type: TriggerOpTypes.ADD,
+      key: 'baz',
+      oldValue: undefined,
+      newValue: 1
+    })
+  })
 })
diff --git a/test/unit/features/v3/reactivity/ref.spec.ts b/test/unit/features/v3/reactivity/ref.spec.ts
index 78498a29d25..c61aaa71027 100644
--- a/test/unit/features/v3/reactivity/ref.spec.ts
+++ b/test/unit/features/v3/reactivity/ref.spec.ts
@@ -10,7 +10,8 @@ import {
   Ref,
   isReactive,
   isShallow,
-  reactive
+  reactive,
+  computed
 } from 'v3'
 import { effect } from 'v3/reactivity/effect'
 
@@ -237,7 +238,7 @@ describe('reactivity/ref', () => {
 
   test('isRef', () => {
     expect(isRef(ref(1))).toBe(true)
-    // TODO expect(isRef(computed(() => 1))).toBe(true)
+    expect(isRef(computed(() => 1))).toBe(true)
 
     expect(isRef(0)).toBe(false)
     expect(isRef(1)).toBe(false)
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index c1e2d3b1516..79aebbf8d7c 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -46,7 +46,10 @@ export declare class Component {
   $isServer: boolean
 
   // public methods
-  $mount: (el?: Element | string, hydrating?: boolean) => Component
+  $mount: (
+    el?: Element | string,
+    hydrating?: boolean
+  ) => Component & { [key: string]: any }
   $forceUpdate: () => void
   $destroy: () => void
   $set: <T>(
diff --git a/typescript/global-api.d.ts b/typescript/global-api.d.ts
index 8afef2ae8da..14b82c4bb9d 100644
--- a/typescript/global-api.d.ts
+++ b/typescript/global-api.d.ts
@@ -1,6 +1,5 @@
 import { Config } from '../src/core/config'
 import { Component } from './component'
-import { ComponentOptions } from './options'
 
 declare interface GlobalAPI {
   // new(options?: any): Component
@@ -10,7 +9,7 @@ declare interface GlobalAPI {
   config: Config
   util: Object
 
-  extend: (options: typeof Component | ComponentOptions) => typeof Component
+  extend: (options: typeof Component | object) => typeof Component
   set: <T>(target: Object | Array<T>, key: string | number, value: T) => T
   delete: <T>(target: Object | Array<T>, key: string | number) => void
   nextTick: (fn: Function, context?: Object) => void | Promise<any>

From dae380dc24a166942f8f9e99a009d55a035b1ecc Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 16:01:38 +0800
Subject: [PATCH 094/317] wip: renderTriggered/renderTracked

---
 src/core/instance/lifecycle.ts             | 27 +++++---
 src/core/observer/watcher.ts               | 29 +++++---
 src/v3/apiLifecycle.ts                     | 12 +++-
 test/unit/features/v3/apiLifecycle.spec.ts | 78 +++++++++++++++++++++-
 types/options.d.ts                         | 23 +++++++
 typescript/options.d.ts                    |  3 +
 6 files changed, 150 insertions(+), 22 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 0b9b445bb8a..fbb7cb5d9ed 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -1,5 +1,5 @@
 import config from '../config'
-import Watcher from '../observer/watcher'
+import Watcher, { WatcherOptions } from '../observer/watcher'
 import { mark, measure } from '../util/perf'
 import VNode, { createEmptyVNode } from '../vdom/vnode'
 import { updateComponentListeners } from './events'
@@ -192,6 +192,19 @@ export function mountComponent(
     }
   }
 
+  const watcherOptions: WatcherOptions = {
+    before() {
+      if (vm._isMounted && !vm._isDestroyed) {
+        callHook(vm, 'beforeUpdate')
+      }
+    }
+  }
+
+  if (__DEV__) {
+    watcherOptions.onTrack = e => callHook(vm, 'renderTracked', [e])
+    watcherOptions.onTrigger = e => callHook(vm, 'renderTriggered', [e])
+  }
+
   // we set this to vm._watcher inside the watcher's constructor
   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
   // component's mounted hook), which relies on vm._watcher being already defined
@@ -199,13 +212,7 @@ export function mountComponent(
     vm,
     updateComponent,
     noop,
-    {
-      before() {
-        if (vm._isMounted && !vm._isDestroyed) {
-          callHook(vm, 'beforeUpdate')
-        }
-      }
-    },
+    watcherOptions,
     true /* isRenderWatcher */
   )
   hydrating = false
@@ -365,7 +372,7 @@ export function deactivateChildComponent(vm: Component, direct?: boolean) {
   }
 }
 
-export function callHook(vm: Component, hook: string) {
+export function callHook(vm: Component, hook: string, args?: any[]) {
   // #7573 disable dep collection when invoking lifecycle hooks
   pushTarget()
   const prev = currentInstance
@@ -374,7 +381,7 @@ export function callHook(vm: Component, hook: string) {
   const info = `${hook} hook`
   if (handlers) {
     for (let i = 0, j = handlers.length; i < j; i++) {
-      invokeWithErrorHandling(handlers[i], vm, null, vm, info)
+      invokeWithErrorHandling(handlers[i], vm, args || null, vm, info)
     }
   }
   if (vm._hasHookEvent) {
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 118c9fea5c7..2a6f22ff1c3 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -12,7 +12,13 @@ import {
 
 import { traverse } from './traverse'
 import { queueWatcher } from './scheduler'
-import Dep, { pushTarget, popTarget, DepTarget, DebuggerEvent } from './dep'
+import Dep, {
+  pushTarget,
+  popTarget,
+  DepTarget,
+  DebuggerEvent,
+  DebuggerOptions
+} from './dep'
 
 import type { SimpleSet } from '../util/index'
 import type { Component } from 'typescript/component'
@@ -23,6 +29,14 @@ import {
 
 let uid = 0
 
+export interface WatcherOptions extends DebuggerOptions {
+  deep?: boolean
+  user?: boolean
+  lazy?: boolean
+  sync?: boolean
+  before?: Function
+}
+
 /**
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
@@ -57,14 +71,7 @@ export default class Watcher implements DepTarget {
     vm: Component | null,
     expOrFn: string | (() => any),
     cb: Function,
-    options?: {
-      deep?: boolean
-      user?: boolean
-      lazy?: boolean
-      sync?: boolean
-      before?: Function
-      scheduler?: Function
-    } | null,
+    options?: WatcherOptions | null,
     isRenderWatcher?: boolean
   ) {
     recordEffectScope(this, activeEffectScope || (vm ? vm._scope : undefined))
@@ -80,6 +87,10 @@ export default class Watcher implements DepTarget {
       this.lazy = !!options.lazy
       this.sync = !!options.sync
       this.before = options.before
+      if (__DEV__) {
+        this.onTrack = options.onTrack
+        this.onTrigger = options.onTrigger
+      }
     } else {
       this.deep = this.user = this.lazy = this.sync = false
     }
diff --git a/src/v3/apiLifecycle.ts b/src/v3/apiLifecycle.ts
index 615e297f4e5..cd72fb8fabc 100644
--- a/src/v3/apiLifecycle.ts
+++ b/src/v3/apiLifecycle.ts
@@ -1,9 +1,12 @@
+import { DebuggerEvent } from '.'
 import { Component } from '../../typescript/component'
 import { mergeLifecycleHook, warn } from '../core/util'
 import { currentInstance } from './currentInstance'
 
-function createLifeCycle(hookName: string) {
-  return (fn: () => void, target: Component | null = currentInstance) => {
+function createLifeCycle<T extends (...args: any[]) => any = () => void>(
+  hookName: string
+) {
+  return (fn: T, target: Component | null = currentInstance) => {
     if (!target) {
       __DEV__ &&
         warn(
@@ -43,3 +46,8 @@ export const onErrorCaptured = createLifeCycle('errorCaptured')
 export const onActivated = createLifeCycle('activated')
 export const onDeactivated = createLifeCycle('deactivated')
 export const onServerPrefetch = createLifeCycle('serverPrefetch')
+
+export const onRenderTracked =
+  createLifeCycle<(e: DebuggerEvent) => any>('renderTracked')
+export const onRenderTriggered =
+  createLifeCycle<(e: DebuggerEvent) => any>('renderTriggered')
diff --git a/test/unit/features/v3/apiLifecycle.spec.ts b/test/unit/features/v3/apiLifecycle.spec.ts
index 22ba34bd4f4..21eb33272e3 100644
--- a/test/unit/features/v3/apiLifecycle.spec.ts
+++ b/test/unit/features/v3/apiLifecycle.spec.ts
@@ -4,10 +4,16 @@ import {
   onBeforeMount,
   onMounted,
   ref,
+  reactive,
   onBeforeUpdate,
   onUpdated,
   onBeforeUnmount,
-  onUnmounted
+  onUnmounted,
+  onRenderTracked,
+  onRenderTriggered,
+  DebuggerEvent,
+  TrackOpTypes,
+  TriggerOpTypes
 } from 'v3'
 import { nextTick } from 'core/util'
 
@@ -281,4 +287,74 @@ describe('api: lifecycle hooks', () => {
       'root onUnmounted'
     ])
   })
+
+  it('onRenderTracked', () => {
+    const events: DebuggerEvent[] = []
+    const onTrack = vi.fn((e: DebuggerEvent) => {
+      events.push(e)
+    })
+    const obj = reactive({ foo: 1, bar: 2 })
+
+    const Comp = {
+      setup() {
+        onRenderTracked(onTrack)
+        return () => h('div', [obj.foo + obj.bar])
+      }
+    }
+
+    new Vue(Comp).$mount()
+    expect(onTrack).toHaveBeenCalledTimes(2)
+    expect(events).toMatchObject([
+      {
+        target: obj,
+        type: TrackOpTypes.GET,
+        key: 'foo'
+      },
+      {
+        target: obj,
+        type: TrackOpTypes.GET,
+        key: 'bar'
+      }
+    ])
+  })
+
+  it('onRenderTriggered', async () => {
+    const events: DebuggerEvent[] = []
+    const onTrigger = vi.fn((e: DebuggerEvent) => {
+      events.push(e)
+    })
+    const obj = reactive<{
+      foo: number
+      bar: number
+    }>({ foo: 1, bar: 2 })
+
+    const Comp = {
+      setup() {
+        onRenderTriggered(onTrigger)
+        return () => h('div', [obj.foo + obj.bar])
+      }
+    }
+
+    new Vue(Comp).$mount()
+
+    obj.foo++
+    await nextTick()
+    expect(onTrigger).toHaveBeenCalledTimes(1)
+    expect(events[0]).toMatchObject({
+      type: TriggerOpTypes.SET,
+      key: 'foo',
+      oldValue: 1,
+      newValue: 2
+    })
+
+    obj.bar++
+    await nextTick()
+    expect(onTrigger).toHaveBeenCalledTimes(2)
+    expect(events[1]).toMatchObject({
+      type: TriggerOpTypes.SET,
+      key: 'bar',
+      oldValue: 2,
+      newValue: 3
+    })
+  })
 })
diff --git a/types/options.d.ts b/types/options.d.ts
index 3701acb333b..e01c1ba6d3a 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -189,6 +189,8 @@ export interface ComponentOptions<
   deactivated?(): void
   errorCaptured?(err: Error, vm: Vue, info: string): boolean | void
   serverPrefetch?(this: V): Promise<void>
+  renderTracked?(e: DebuggerEvent): void
+  renderTriggerd?(e: DebuggerEvent): void
 
   directives?: { [key: string]: DirectiveFunction | DirectiveOptions }
   components?: {
@@ -314,3 +316,24 @@ export type InjectOptions =
       [key: string]: InjectKey | { from?: InjectKey; default?: any }
     }
   | string[]
+
+export type DebuggerEvent = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key?: any
+  newValue?: any
+  oldValue?: any
+  oldTarget?: Map<any, any> | Set<any>
+}
+
+export const enum TrackOpTypes {
+  GET = 'get',
+  TOUCH = 'touch'
+}
+
+export const enum TriggerOpTypes {
+  SET = 'set',
+  ADD = 'add',
+  DELETE = 'delete',
+  ARRAY_MUTATION = 'array mutation'
+}
diff --git a/typescript/options.d.ts b/typescript/options.d.ts
index bd2af3a3b18..919602c0970 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.d.ts
@@ -1,4 +1,5 @@
 import VNode from '../src/core/vdom/vnode'
+import { DebuggerEvent } from '../src/v3'
 import { Component } from './component'
 
 declare type InternalComponentOptions = {
@@ -61,6 +62,8 @@ declare type ComponentOptions = {
   destroyed?: Function
   errorCaptured?: () => boolean | void
   serverPrefetch?: Function
+  renderTracked?(e: DebuggerEvent): void
+  renderTriggerd?(e: DebuggerEvent): void
 
   // assets
   directives?: { [key: string]: object }

From 1a13c63ff5b22780318ee25b921af4faafe0fa2c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 18:43:36 +0800
Subject: [PATCH 095/317] wip: provide/inject

---
 src/core/instance/inject.ts             |  44 ++--
 src/core/instance/lifecycle.ts          |   1 +
 src/v3/apiInject.ts                     |  67 ++++-
 src/v3/index.ts                         |   2 +
 test/unit/features/v3/apiInject.spec.ts | 336 ++++++++++++++++++++++++
 typescript/component.d.ts               |   2 +-
 6 files changed, 427 insertions(+), 25 deletions(-)
 create mode 100644 test/unit/features/v3/apiInject.spec.ts

diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 8449d410d66..750b24d4053 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,12 +1,21 @@
-import { hasOwn } from 'shared/util'
 import { warn, hasSymbol, isFunction } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
 import type { Component } from 'typescript/component'
+import { provide } from 'v3/apiInject'
+import { setCurrentInstance } from '../../v3/currentInstance'
 
 export function initProvide(vm: Component) {
-  const provide = vm.$options.provide
-  if (provide) {
-    vm._provided = isFunction(provide) ? provide.call(vm) : provide
+  const provideOption = vm.$options.provide
+  if (provideOption) {
+    const provided = isFunction(provideOption)
+      ? provideOption.call(vm)
+      : provideOption
+    const keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided)
+    setCurrentInstance(vm)
+    for (let i = 0; i < keys.length; i++) {
+      provide(keys[i], provided[keys[i]])
+    }
+    setCurrentInstance()
   }
 }
 
@@ -47,24 +56,15 @@ export function resolveInject(
       // #6574 in case the inject object is observed...
       if (key === '__ob__') continue
       const provideKey = inject[key].from
-      let source = vm
-      while (source) {
-        if (source._provided && hasOwn(source._provided, provideKey)) {
-          result[key] = source._provided[provideKey]
-          break
-        }
-        // @ts-expect-error
-        source = source.$parent
-      }
-      if (!source) {
-        if ('default' in inject[key]) {
-          const provideDefault = inject[key].default
-          result[key] = isFunction(provideDefault)
-            ? provideDefault.call(vm)
-            : provideDefault
-        } else if (__DEV__) {
-          warn(`Injection "${key as string}" not found`, vm)
-        }
+      if (provideKey in vm._provided) {
+        result[key] = vm._provided[provideKey]
+      } else if ('default' in inject[key]) {
+        const provideDefault = inject[key].default
+        result[key] = isFunction(provideDefault)
+          ? provideDefault.call(vm)
+          : provideDefault
+      } else if (__DEV__) {
+        warn(`Injection "${key as string}" not found`, vm)
       }
     }
     return result
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index fbb7cb5d9ed..ec73b4f689e 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -49,6 +49,7 @@ export function initLifecycle(vm: Component) {
   vm.$children = []
   vm.$refs = {}
 
+  vm._provided = parent ? parent._provided : Object.create(null)
   vm._watcher = null
   vm._inactive = null
   vm._directInactive = false
diff --git a/src/v3/apiInject.ts b/src/v3/apiInject.ts
index 815fec6c353..3644c56ab46 100644
--- a/src/v3/apiInject.ts
+++ b/src/v3/apiInject.ts
@@ -1,3 +1,66 @@
-export function provide() {}
+import { isFunction, warn } from 'core/util'
+import { currentInstance } from './currentInstance'
 
-export function inject() {}
+export interface InjectionKey<T> extends Symbol {}
+
+export function provide<T>(key: InjectionKey<T> | string | number, value: T) {
+  if (!currentInstance) {
+    if (__DEV__) {
+      warn(`provide() can only be used inside setup().`)
+    }
+  } else {
+    let provides = currentInstance._provided
+    // by default an instance inherits its parent's provides object
+    // but when it needs to provide values of its own, it creates its
+    // own provides object using parent provides object as prototype.
+    // this way in `inject` we can simply look up injections from direct
+    // parent and let the prototype chain do the work.
+    const parentProvides =
+      currentInstance.$parent && currentInstance.$parent._provided
+    if (parentProvides === provides) {
+      provides = currentInstance._provided = Object.create(parentProvides)
+    }
+    // TS doesn't allow symbol as index type
+    provides[key as string] = value
+  }
+}
+
+export function inject<T>(key: InjectionKey<T> | string): T | undefined
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue: T,
+  treatDefaultAsFactory?: false
+): T
+export function inject<T>(
+  key: InjectionKey<T> | string,
+  defaultValue: T | (() => T),
+  treatDefaultAsFactory: true
+): T
+export function inject(
+  key: InjectionKey<any> | string,
+  defaultValue?: unknown,
+  treatDefaultAsFactory = false
+) {
+  // fallback to `currentRenderingInstance` so that this can be called in
+  // a functional component
+  const instance = currentInstance
+  if (instance) {
+    // #2400
+    // to support `app.use` plugins,
+    // fallback to appContext's `provides` if the instance is at root
+    const provides = instance.$parent && instance.$parent._provided
+
+    if (provides && (key as string | symbol) in provides) {
+      // TS doesn't allow symbol as index type
+      return provides[key as string]
+    } else if (arguments.length > 1) {
+      return treatDefaultAsFactory && isFunction(defaultValue)
+        ? defaultValue.call(instance)
+        : defaultValue
+    } else if (__DEV__) {
+      warn(`injection "${String(key)}" not found.`)
+    }
+  } else if (__DEV__) {
+    warn(`inject() can only be used inside setup() or functional components.`)
+  }
+}
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 4cd90665190..ad0f991e949 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -69,6 +69,8 @@ export {
 } from 'core/observer/dep'
 export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
+export { provide, inject, InjectionKey } from './apiInject'
+
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
 export { useSlots, useAttrs } from './apiSetup'
diff --git a/test/unit/features/v3/apiInject.spec.ts b/test/unit/features/v3/apiInject.spec.ts
new file mode 100644
index 00000000000..c467d085a55
--- /dev/null
+++ b/test/unit/features/v3/apiInject.spec.ts
@@ -0,0 +1,336 @@
+import Vue from 'vue'
+import {
+  h,
+  provide,
+  inject,
+  InjectionKey,
+  ref,
+  nextTick,
+  Ref,
+  readonly,
+  reactive
+} from 'v3/index'
+
+// reference: https://vue-composition-api-rfc.netlify.com/api.html#provide-inject
+describe('api: provide/inject', () => {
+  it('string keys', () => {
+    const Provider = {
+      setup() {
+        provide('foo', 1)
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const foo = inject('foo')
+        return () => h('div', foo)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+  })
+
+  it('symbol keys', () => {
+    // also verifies InjectionKey type sync
+    const key: InjectionKey<number> = Symbol()
+
+    const Provider = {
+      setup() {
+        provide(key, 1)
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const foo = inject(key) || 1
+        return () => h('div', foo + 1)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>2</div>`)
+  })
+
+  it('default values', () => {
+    const Provider = {
+      setup() {
+        provide('foo', 'foo')
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        // default value should be ignored if value is provided
+        const foo = inject('foo', 'fooDefault')
+        // default value should be used if value is not provided
+        const bar = inject('bar', 'bar')
+        return () => h('div', foo + bar)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>foobar</div>`)
+  })
+
+  it('bound to instance', () => {
+    const Provider = {
+      setup() {
+        return () => h(Consumer)
+      }
+    }
+
+    const Consumer = {
+      name: 'Consumer',
+      inject: {
+        foo: {
+          from: 'foo',
+          default() {
+            return this!.$options.name
+          }
+        }
+      },
+      render() {
+        // @ts-ignore
+        return h('div', this.foo)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>Consumer</div>`)
+  })
+
+  it('nested providers', () => {
+    const ProviderOne = {
+      setup() {
+        provide('foo', 'foo')
+        provide('bar', 'bar')
+        return () => h(ProviderTwo)
+      }
+    }
+
+    const ProviderTwo = {
+      setup() {
+        // override parent value
+        provide('foo', 'fooOverride')
+        provide('baz', 'baz')
+        return () => h(Consumer)
+      }
+    }
+
+    const Consumer = {
+      setup() {
+        const foo = inject('foo')
+        const bar = inject('bar')
+        const baz = inject('baz')
+        return () => h('div', [foo, bar, baz].join(','))
+      }
+    }
+
+    const vm = new Vue(ProviderOne).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>fooOverride,bar,baz</div>`)
+  })
+
+  it('reactivity with refs', async () => {
+    const count = ref(1)
+
+    const Provider = {
+      setup() {
+        provide('count', count)
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const count = inject<Ref<number>>('count')!
+        return () => h('div', count.value)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+
+    count.value++
+    await nextTick()
+    expect(vm.$el.outerHTML).toBe(`<div>2</div>`)
+  })
+
+  it('reactivity with readonly refs', async () => {
+    const count = ref(1)
+
+    const Provider = {
+      setup() {
+        provide('count', readonly(count))
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const count = inject<Ref<number>>('count')!
+        // should not work
+        count.value++
+        return () => h('div', count.value)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+
+    expect(
+      `Set operation on key "value" failed: target is readonly`
+    ).toHaveBeenWarned()
+
+    // source mutation should still work
+    count.value++
+    await nextTick()
+    expect(vm.$el.outerHTML).toBe(`<div>2</div>`)
+  })
+
+  it('reactivity with objects', async () => {
+    const rootState = reactive({ count: 1 })
+
+    const Provider = {
+      setup() {
+        provide('state', rootState)
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const state = inject<typeof rootState>('state')!
+        return () => h('div', state.count)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+
+    rootState.count++
+    await nextTick()
+    expect(vm.$el.outerHTML).toBe(`<div>2</div>`)
+  })
+
+  it('reactivity with readonly objects', async () => {
+    const rootState = reactive({ count: 1 })
+
+    const Provider = {
+      setup() {
+        provide('state', readonly(rootState))
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const state = inject<typeof rootState>('state')!
+        // should not work
+        state.count++
+        return () => h('div', state.count)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div>1</div>`)
+
+    expect(
+      `Set operation on key "count" failed: target is readonly`
+    ).toHaveBeenWarned()
+
+    rootState.count++
+    await nextTick()
+    expect(vm.$el.outerHTML).toBe(`<div>2</div>`)
+  })
+
+  it('should warn unfound', () => {
+    const Provider = {
+      setup() {
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const foo = inject('foo')
+        expect(foo).toBeUndefined()
+        return () => h('div', foo)
+      }
+    }
+
+    const vm = new Vue(Provider).$mount()
+    expect(vm.$el.outerHTML).toBe(`<div></div>`)
+    expect(`injection "foo" not found.`).toHaveBeenWarned()
+  })
+
+  it('should not warn when default value is undefined', () => {
+    const Provider = {
+      setup() {
+        return () => h(Middle)
+      }
+    }
+
+    const Middle = {
+      render: () => h(Consumer)
+    }
+
+    const Consumer = {
+      setup() {
+        const foo = inject('foo', undefined)
+        return () => h('div', foo)
+      }
+    }
+
+    new Vue(Provider).$mount()
+    expect(`injection "foo" not found.`).not.toHaveBeenWarned()
+  })
+
+  // #2400
+  it('should not self-inject', () => {
+    const Comp = {
+      setup() {
+        provide('foo', 'foo')
+        const injection = inject('foo', null)
+        return () => h('div', injection)
+      }
+    }
+
+    expect(new Vue(Comp).$mount().$el.outerHTML).toBe(`<div></div>`)
+  })
+})
diff --git a/typescript/component.d.ts b/typescript/component.d.ts
index 79aebbf8d7c..91847ff84ee 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.d.ts
@@ -99,7 +99,7 @@ export declare class Component {
   _vnode?: VNode | null // self root node
   _staticTrees?: Array<VNode> | null // v-once cached trees
   _hasHookEvent: boolean
-  _provided?: Record<string, any>
+  _provided: Record<string, any>
   // _virtualComponents?: { [key: string]: Component };
 
   // @v3

From cae88defa2b35cc6f77468c7c853b31032128a54 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 29 May 2022 19:29:17 +0800
Subject: [PATCH 096/317] chore: rename template ref module

---
 src/core/vdom/modules/index.ts                    | 2 +-
 src/core/vdom/modules/{ref.ts => template-ref.ts} | 0
 src/core/vdom/patch.ts                            | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename src/core/vdom/modules/{ref.ts => template-ref.ts} (100%)

diff --git a/src/core/vdom/modules/index.ts b/src/core/vdom/modules/index.ts
index e870f33b1b8..327693d098c 100644
--- a/src/core/vdom/modules/index.ts
+++ b/src/core/vdom/modules/index.ts
@@ -1,4 +1,4 @@
 import directives from './directives'
-import ref from './ref'
+import ref from './template-ref'
 
 export default [ref, directives]
diff --git a/src/core/vdom/modules/ref.ts b/src/core/vdom/modules/template-ref.ts
similarity index 100%
rename from src/core/vdom/modules/ref.ts
rename to src/core/vdom/modules/template-ref.ts
diff --git a/src/core/vdom/patch.ts b/src/core/vdom/patch.ts
index 78204c55b54..d0594863e3b 100644
--- a/src/core/vdom/patch.ts
+++ b/src/core/vdom/patch.ts
@@ -13,7 +13,7 @@
 import VNode, { cloneVNode } from './vnode'
 import config from '../config'
 import { SSR_ATTR } from 'shared/constants'
-import { registerRef } from './modules/ref'
+import { registerRef } from './modules/template-ref'
 import { traverse } from '../observer/traverse'
 import { activeInstance } from '../instance/lifecycle'
 import { isTextInputType } from 'web/util/element'

From 460856510d1a6356194e10f887df9b057297c07e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 30 May 2022 16:37:53 +0800
Subject: [PATCH 097/317] wip: setup() template refs support

---
 src/core/instance/render.ts                   |   4 +-
 src/core/vdom/create-functional-component.ts  |   9 +-
 .../vdom/helpers/normalize-scoped-slots.ts    |  14 +-
 src/core/vdom/modules/template-ref.ts         |  84 ++-
 .../{ref.spec.ts => template-ref.spec.ts}     |   4 +-
 test/unit/features/v3/apiSetup.spec.ts        |   2 +-
 .../unit/features/v3/setupTemplateRef.spec.ts | 501 ++++++++++++++++++
 typescript/vnode.d.ts                         |   3 +-
 8 files changed, 591 insertions(+), 30 deletions(-)
 rename test/unit/features/{ref.spec.ts => template-ref.spec.ts} (98%)
 create mode 100644 test/unit/features/v3/setupTemplateRef.spec.ts

diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index fc0407b87d5..900cc130488 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -100,9 +100,9 @@ export function renderMixin(Vue: typeof Component) {
 
     if (_parentVnode) {
       vm.$scopedSlots = normalizeScopedSlots(
+        vm.$parent!,
         _parentVnode.data!.scopedSlots,
-        vm.$slots,
-        vm.$scopedSlots
+        vm.$slots
       )
       if (vm._slotsProxy) {
         syncSetupSlots(vm._slotsProxy, vm.$scopedSlots)
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index eee5811ffd3..019453f5ccf 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -52,6 +52,7 @@ export function FunctionalRenderContext(
   this.slots = () => {
     if (!this.$slots) {
       normalizeScopedSlots(
+        parent,
         data.scopedSlots,
         (this.$slots = resolveSlots(children, parent))
       )
@@ -62,7 +63,7 @@ export function FunctionalRenderContext(
   Object.defineProperty(this, 'scopedSlots', {
     enumerable: true,
     get() {
-      return normalizeScopedSlots(data.scopedSlots, this.slots())
+      return normalizeScopedSlots(parent, data.scopedSlots, this.slots())
     }
   } as any)
 
@@ -72,7 +73,11 @@ export function FunctionalRenderContext(
     this.$options = options
     // pre-resolve slots for renderSlot()
     this.$slots = this.slots()
-    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots)
+    this.$scopedSlots = normalizeScopedSlots(
+      parent,
+      data.scopedSlots,
+      this.$slots
+    )
   }
 
   if (options._scopeId) {
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index f65a3ae817e..ab22597acb7 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -3,13 +3,16 @@ import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
 import { emptyObject, isArray } from 'shared/util'
 import { isAsyncPlaceholder } from './is-async-placeholder'
 import type VNode from '../vnode'
+import { Component } from 'typescript/component'
+import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
 
 export function normalizeScopedSlots(
+  ownerVm: Component,
   slots: { [key: string]: Function } | void,
-  normalSlots: { [key: string]: Array<VNode> },
-  prevSlots?: { [key: string]: Function } | void
+  normalSlots: { [key: string]: VNode[] }
 ): any {
   let res
+  const prevSlots = ownerVm.$scopedSlots
   const hasNormalSlots = Object.keys(normalSlots).length > 0
   const isStable = slots ? !!slots.$stable : !hasNormalSlots
   const key = slots && slots.$key
@@ -33,7 +36,7 @@ export function normalizeScopedSlots(
     res = {}
     for (const key in slots) {
       if (slots[key] && key[0] !== '$') {
-        res[key] = normalizeScopedSlot(normalSlots, key, slots[key])
+        res[key] = normalizeScopedSlot(ownerVm, normalSlots, key, slots[key])
       }
     }
   }
@@ -54,14 +57,17 @@ export function normalizeScopedSlots(
   return res
 }
 
-function normalizeScopedSlot(normalSlots, key, fn) {
+function normalizeScopedSlot(vm, normalSlots, key, fn) {
   const normalized = function () {
+    const cur = currentInstance
+    setCurrentInstance(vm)
     let res = arguments.length ? fn.apply(null, arguments) : fn({})
     res =
       res && typeof res === 'object' && !isArray(res)
         ? [res] // single vnode
         : normalizeChildren(res)
     const vnode: VNode | null = res && res[0]
+    setCurrentInstance(cur)
     return res &&
       (!vnode ||
         (res.length === 1 && vnode.isComment && !isAsyncPlaceholder(vnode))) // #9658, #10391
diff --git a/src/core/vdom/modules/template-ref.ts b/src/core/vdom/modules/template-ref.ts
index ed7e4426c30..8688697e9b7 100644
--- a/src/core/vdom/modules/template-ref.ts
+++ b/src/core/vdom/modules/template-ref.ts
@@ -1,5 +1,15 @@
-import { remove, isDef, isArray } from 'shared/util'
+import {
+  remove,
+  isDef,
+  hasOwn,
+  isArray,
+  isFunction,
+  invokeWithErrorHandling,
+  warn
+} from 'core/util'
 import type { VNodeWithData } from 'typescript/vnode'
+import { Component } from 'typescript/component'
+import { isRef } from 'v3'
 
 export default {
   create(_: any, vnode: VNodeWithData) {
@@ -17,28 +27,66 @@ export default {
 }
 
 export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
-  const key = vnode.data.ref
-  if (!isDef(key)) return
+  const ref = vnode.data.ref
+  if (!isDef(ref)) return
 
   const vm = vnode.context
-  const ref = vnode.componentInstance || vnode.elm
+  const refValue = vnode.componentInstance || vnode.elm
+  const value = isRemoval ? null : refValue
+
+  if (isFunction(ref)) {
+    invokeWithErrorHandling(ref, vm, [value], vm, `template ref function`)
+    return
+  }
+
+  const setupRefKey = vnode.data.ref_key
+  const isFor = vnode.data.refInFor
+  const _isString = typeof ref === 'string' || typeof ref === 'number'
+  const _isRef = isRef(ref)
   const refs = vm.$refs
-  const obj = refs[key]
-  if (isRemoval) {
-    if (isArray(obj)) {
-      remove(obj, ref)
-    } else if (obj === ref) {
-      refs[key] = undefined
-    }
-  } else {
-    if (vnode.data.refInFor) {
-      if (!isArray(obj)) {
-        refs[key] = [ref]
-      } else if (obj.indexOf(ref) < 0) {
-        obj.push(ref)
+
+  if (_isString || _isRef) {
+    if (isFor) {
+      const existing = _isString ? refs[ref] : ref.value
+      if (isRemoval) {
+        isArray(existing) && remove(existing, refValue)
+      } else {
+        if (!isArray(existing)) {
+          if (_isString) {
+            refs[ref] = [refValue]
+            setSetupRef(vm, ref, refs[ref])
+          } else {
+            ref.value = [refValue]
+            if (setupRefKey) refs[setupRefKey] = ref.value as any
+          }
+        } else if (!existing.includes(refValue)) {
+          existing.push(refValue)
+        }
+      }
+    } else if (_isString) {
+      if (isRemoval && refs[ref] !== refValue) {
+        return
       }
+      refs[ref] = value
+      setSetupRef(vm, ref, value)
+    } else if (_isRef) {
+      if (isRemoval && ref.value !== refValue) {
+        return
+      }
+      ref.value = value
+      if (setupRefKey) refs[setupRefKey] = value
+    } else if (__DEV__) {
+      warn(`Invalid template ref type: ${typeof ref}`)
+    }
+  }
+}
+
+function setSetupRef({ _setupState }: Component, key: string, val: any) {
+  if (_setupState && hasOwn(_setupState, key)) {
+    if (isRef(_setupState[key])) {
+      _setupState[key].value = val
     } else {
-      refs[key] = ref
+      _setupState[key] = val
     }
   }
 }
diff --git a/test/unit/features/ref.spec.ts b/test/unit/features/template-ref.spec.ts
similarity index 98%
rename from test/unit/features/ref.spec.ts
rename to test/unit/features/template-ref.spec.ts
index 0629e14abb0..00aeeb2f99f 100644
--- a/test/unit/features/ref.spec.ts
+++ b/test/unit/features/template-ref.spec.ts
@@ -58,7 +58,7 @@ describe('ref', () => {
     expect(vm.$refs.foo).toBe(vm.$el)
     vm.value = 'bar'
     waitForUpdate(() => {
-      expect(vm.$refs.foo).toBeUndefined()
+      expect(vm.$refs.foo).toBe(null)
       expect(vm.$refs.bar).toBe(vm.$el)
     }).then(done)
   })
@@ -101,7 +101,7 @@ describe('ref', () => {
       vm.test = ''
     })
       .then(() => {
-        expect(vm.$refs.test).toBeUndefined()
+        expect(vm.$refs.test).toBe(null)
       })
       .then(done)
   })
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 806ab55ffcb..f3c152b48cf 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -164,7 +164,7 @@ describe('api: setup context', () => {
     const id = ref('foo')
 
     const Child = {
-      setup(props: any, { slots }: any) {
+      setup(_props: any, { slots }: any) {
         return () => h('div', [...slots.foo(), ...slots.bar()])
       }
     }
diff --git a/test/unit/features/v3/setupTemplateRef.spec.ts b/test/unit/features/v3/setupTemplateRef.spec.ts
new file mode 100644
index 00000000000..189b3a1ed28
--- /dev/null
+++ b/test/unit/features/v3/setupTemplateRef.spec.ts
@@ -0,0 +1,501 @@
+import Vue from 'vue'
+import { ref, h, nextTick, reactive } from 'v3/index'
+
+// reference: https://vue-composition-api-rfc.netlify.com/api.html#template-refs
+
+describe('api: setup() template refs', () => {
+  it('string ref mount', () => {
+    const el = ref(null)
+
+    const Comp = {
+      setup() {
+        return {
+          refKey: el
+        }
+      },
+      render() {
+        return h('div', { ref: 'refKey' })
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(el.value).toBe(vm.$el)
+  })
+
+  it('string ref update', async () => {
+    const fooEl = ref(null)
+    const barEl = ref(null)
+    const refKey = ref('foo')
+
+    const Comp = {
+      setup() {
+        return {
+          foo: fooEl,
+          bar: barEl
+        }
+      },
+      render() {
+        return h('div', { ref: refKey.value })
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(barEl.value).toBe(null)
+
+    refKey.value = 'bar'
+    await nextTick()
+    expect(fooEl.value).toBe(null)
+    expect(barEl.value).toBe(vm.$el)
+  })
+
+  it('string ref unmount', async () => {
+    const el = ref(null)
+    const toggle = ref(true)
+
+    const Comp = {
+      setup() {
+        return {
+          refKey: el
+        }
+      },
+      render() {
+        return toggle.value ? h('div', { ref: 'refKey' }) : null
+      }
+    }
+
+    const vm = new Vue(Comp).$mount()
+    expect(el.value).toBe(vm.$el)
+
+    toggle.value = false
+    await nextTick()
+    expect(el.value).toBe(null)
+  })
+
+  it('function ref mount', () => {
+    const fn = vi.fn()
+
+    const Comp = {
+      render: () => h('div', { ref: fn })
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(fn.mock.calls[0][0]).toBe(vm.$el)
+  })
+
+  it('function ref update', async () => {
+    const fn1 = vi.fn()
+    const fn2 = vi.fn()
+    const fn = ref(fn1)
+
+    const Comp = { render: () => h('div', { ref: fn.value }) }
+
+    const vm = new Vue(Comp).$mount()
+    expect(fn1.mock.calls).toHaveLength(1)
+    expect(fn1.mock.calls[0][0]).toBe(vm.$el)
+    expect(fn2.mock.calls).toHaveLength(0)
+
+    fn.value = fn2
+    await nextTick()
+    expect(fn1.mock.calls).toHaveLength(2)
+    expect(fn1.mock.calls[1][0]).toBe(null)
+    expect(fn2.mock.calls).toHaveLength(1)
+    expect(fn2.mock.calls[0][0]).toBe(vm.$el)
+  })
+
+  it('function ref unmount', async () => {
+    const fn = vi.fn()
+    const toggle = ref(true)
+
+    const Comp = {
+      render: () => (toggle.value ? h('div', { ref: fn }) : null)
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(fn.mock.calls[0][0]).toBe(vm.$el)
+    toggle.value = false
+    await nextTick()
+    expect(fn.mock.calls[1][0]).toBe(null)
+  })
+
+  it('render function ref mount', () => {
+    const el = ref(null)
+
+    const Comp = {
+      setup() {
+        return () => h('div', { ref: el })
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(el.value).toBe(vm.$el)
+  })
+
+  it('render function ref update', async () => {
+    const refs = {
+      foo: ref(null),
+      bar: ref(null)
+    }
+    const refKey = ref<keyof typeof refs>('foo')
+
+    const Comp = {
+      setup() {
+        return () => h('div', { ref: refs[refKey.value] })
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(refs.foo.value).toBe(vm.$el)
+    expect(refs.bar.value).toBe(null)
+
+    refKey.value = 'bar'
+    await nextTick()
+    expect(refs.foo.value).toBe(null)
+    expect(refs.bar.value).toBe(vm.$el)
+  })
+
+  it('render function ref unmount', async () => {
+    const el = ref(null)
+    const toggle = ref(true)
+
+    const Comp = {
+      setup() {
+        return () => (toggle.value ? h('div', { ref: el }) : null)
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(el.value).toBe(vm.$el)
+
+    toggle.value = false
+    await nextTick()
+    expect(el.value).toBe(null)
+  })
+
+  it('string ref inside slots', async () => {
+    const spy = vi.fn()
+    const Child = {
+      render(this: any) {
+        return this.$slots.default
+      }
+    }
+
+    const Comp = {
+      render() {
+        return h(Child, [h('div', { ref: 'foo' })])
+      },
+      mounted(this: any) {
+        spy(this.$refs.foo.tagName)
+      }
+    }
+    new Vue(Comp).$mount()
+    expect(spy).toHaveBeenCalledWith('DIV')
+  })
+
+  it('string ref inside scoped slots', async () => {
+    const spy = vi.fn()
+    const Child = {
+      render(this: any) {
+        return this.$scopedSlots.default()
+      }
+    }
+
+    const Comp = {
+      render() {
+        return h(Child, {
+          scopedSlots: {
+            default: () => [h('div', { ref: 'foo' })]
+          }
+        })
+      },
+      mounted(this: any) {
+        spy(this.$refs.foo.tagName)
+      }
+    }
+    new Vue(Comp).$mount()
+    expect(spy).toHaveBeenCalledWith('DIV')
+  })
+
+  it('should work with direct reactive property', () => {
+    const state = reactive({
+      refKey: null
+    })
+
+    const Comp = {
+      setup() {
+        return state
+      },
+      render() {
+        return h('div', { ref: 'refKey' })
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(state.refKey).toBe(vm.$el)
+  })
+
+  test('multiple refs', () => {
+    const refKey1 = ref(null)
+    const refKey2 = ref(null)
+    const refKey3 = ref(null)
+
+    const Comp = {
+      setup() {
+        return {
+          refKey1,
+          refKey2,
+          refKey3
+        }
+      },
+      render() {
+        return h('div', [
+          h('div', { ref: 'refKey1' }),
+          h('div', { ref: 'refKey2' }),
+          h('div', { ref: 'refKey3' })
+        ])
+      }
+    }
+    const vm = new Vue(Comp).$mount()
+    expect(refKey1.value).toBe(vm.$el.children[0])
+    expect(refKey2.value).toBe(vm.$el.children[1])
+    expect(refKey3.value).toBe(vm.$el.children[2])
+  })
+
+  // vuejs/core#1505
+  test('reactive template ref in the same template', async () => {
+    const Comp = {
+      setup() {
+        const el = ref()
+        return { el }
+      },
+      render(this: any) {
+        return h(
+          'div',
+          { attrs: { id: 'foo' }, ref: 'el' },
+          this.el && this.el.id
+        )
+      }
+    }
+
+    const vm = new Vue(Comp).$mount()
+    // ref not ready on first render, but should queue an update immediately
+    expect(vm.$el.outerHTML).toBe(`<div id="foo"></div>`)
+    await nextTick()
+    // ref should be updated
+    expect(vm.$el.outerHTML).toBe(`<div id="foo">foo</div>`)
+  })
+
+  // vuejs/core#1834
+  test('exchange refs', async () => {
+    const refToggle = ref(false)
+    const spy = vi.fn()
+
+    const Comp = {
+      render(this: any) {
+        return h('div', [
+          h('p', { ref: refToggle.value ? 'foo' : 'bar' }),
+          h('i', { ref: refToggle.value ? 'bar' : 'foo' })
+        ])
+      },
+      mounted(this: any) {
+        spy(this.$refs.foo.tagName, this.$refs.bar.tagName)
+      },
+      updated(this: any) {
+        spy(this.$refs.foo.tagName, this.$refs.bar.tagName)
+      }
+    }
+
+    new Vue(Comp).$mount()
+
+    expect(spy.mock.calls[0][0]).toBe('I')
+    expect(spy.mock.calls[0][1]).toBe('P')
+    refToggle.value = true
+    await nextTick()
+    expect(spy.mock.calls[1][0]).toBe('P')
+    expect(spy.mock.calls[1][1]).toBe('I')
+  })
+
+  // vuejs/core#1789
+  test('toggle the same ref to different elements', async () => {
+    const refToggle = ref(false)
+    const spy = vi.fn()
+
+    const Comp = {
+      render(this: any) {
+        return refToggle.value ? h('p', { ref: 'foo' }) : h('i', { ref: 'foo' })
+      },
+      mounted(this: any) {
+        spy(this.$refs.foo.tagName)
+      },
+      updated(this: any) {
+        spy(this.$refs.foo.tagName)
+      }
+    }
+
+    new Vue(Comp).$mount()
+
+    expect(spy.mock.calls[0][0]).toBe('I')
+    refToggle.value = true
+    await nextTick()
+    expect(spy.mock.calls[1][0]).toBe('P')
+  })
+
+  // vuejs/core#2078
+  // @discrepancy Vue 2 doesn't handle merge refs
+  // test('handling multiple merged refs', async () => {
+  //   const Foo = {
+  //     render: () => h('div', 'foo')
+  //   }
+  //   const Bar = {
+  //     render: () => h('div', 'bar')
+  //   }
+
+  //   const viewRef = shallowRef<any>(Foo)
+  //   const elRef1 = ref()
+  //   const elRef2 = ref()
+
+  //   const App = {
+  //     render() {
+  //       if (!viewRef.value) {
+  //         return null
+  //       }
+  //       const view = h(viewRef.value, { ref: elRef1 })
+  //       return h(view, { ref: elRef2 })
+  //     }
+  //   }
+
+  //   new Vue(App).$mount()
+
+  //   expect(elRef1.value.$el.innerHTML).toBe('foo')
+  //   expect(elRef1.value).toBe(elRef2.value)
+
+  //   viewRef.value = Bar
+  //   await nextTick()
+  //   expect(elRef1.value.$el.innerHTML).toBe('bar')
+  //   expect(elRef1.value).toBe(elRef2.value)
+
+  //   viewRef.value = null
+  //   await nextTick()
+  //   expect(elRef1.value).toBeNull()
+  //   expect(elRef1.value).toBe(elRef2.value)
+  // })
+
+  // compiled output of <script setup> inline mode
+  test('raw ref with ref_key', () => {
+    let refs: any
+
+    const el = ref()
+
+    const App = {
+      mounted() {
+        refs = (this as any).$refs
+      },
+      render() {
+        return h(
+          'div',
+          {
+            ref: el,
+            ref_key: 'el'
+          },
+          'hello'
+        )
+      }
+    }
+
+    new Vue(App).$mount()
+
+    expect(el.value.innerHTML).toBe('hello')
+    expect(refs.el.innerHTML).toBe('hello')
+  })
+
+  // compiled output of v-for + template ref
+  test('ref in v-for', async () => {
+    const show = ref(true)
+    const state = reactive({ list: [1, 2, 3] })
+    const listRefs = ref<any[]>([])
+    const mapRefs = () => listRefs.value.map(n => n.innerHTML)
+
+    const App = {
+      render() {
+        return show.value
+          ? h(
+              'ul',
+              state.list.map(i =>
+                h(
+                  'li',
+                  {
+                    ref: listRefs,
+                    refInFor: true
+                  },
+                  i
+                )
+              )
+            )
+          : null
+      }
+    }
+
+    new Vue(App).$mount()
+
+    expect(mapRefs()).toMatchObject(['1', '2', '3'])
+
+    state.list.push(4)
+    await nextTick()
+    expect(mapRefs()).toMatchObject(['1', '2', '3', '4'])
+
+    state.list.shift()
+    await nextTick()
+    expect(mapRefs()).toMatchObject(['2', '3', '4'])
+
+    show.value = !show.value
+    await nextTick()
+
+    expect(mapRefs()).toMatchObject([])
+
+    show.value = !show.value
+    await nextTick()
+    expect(mapRefs()).toMatchObject(['2', '3', '4'])
+  })
+
+  test('named ref in v-for', async () => {
+    const show = ref(true)
+    const state = reactive({ list: [1, 2, 3] })
+    const listRefs = ref([])
+    const mapRefs = () => listRefs.value.map((n: HTMLElement) => n.innerHTML)
+
+    const App = {
+      setup() {
+        return { listRefs }
+      },
+      render() {
+        return show.value
+          ? h(
+              'ul',
+              state.list.map(i =>
+                h(
+                  'li',
+                  {
+                    ref: 'listRefs',
+                    refInFor: true
+                  },
+                  i
+                )
+              )
+            )
+          : null
+      }
+    }
+
+    new Vue(App).$mount()
+
+    expect(mapRefs()).toMatchObject(['1', '2', '3'])
+
+    state.list.push(4)
+    await nextTick()
+    expect(mapRefs()).toMatchObject(['1', '2', '3', '4'])
+
+    state.list.shift()
+    await nextTick()
+    expect(mapRefs()).toMatchObject(['2', '3', '4'])
+
+    show.value = !show.value
+    await nextTick()
+
+    expect(mapRefs()).toMatchObject([])
+
+    show.value = !show.value
+    await nextTick()
+    expect(mapRefs()).toMatchObject(['2', '3', '4'])
+  })
+})
diff --git a/typescript/vnode.d.ts b/typescript/vnode.d.ts
index 5fd49babff0..456afdad42e 100644
--- a/typescript/vnode.d.ts
+++ b/typescript/vnode.d.ts
@@ -1,4 +1,5 @@
 import VNode from '../src/core/vdom/vnode'
+import { Ref } from '../src/v3'
 import { Component } from './component'
 
 declare type VNodeChildren =
@@ -56,7 +57,7 @@ declare type VNodeWithData = VNode & {
 declare interface VNodeData {
   key?: string | number
   slot?: string
-  ref?: string
+  ref?: string | Ref | ((el: any) => void)
   is?: string
   pre?: boolean
   tag?: string

From e5a6fe5da7a68e00e0143c6f4414f7e615a684ca Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 30 May 2022 17:20:43 +0800
Subject: [PATCH 098/317] test: e2e test for composition API examples

---
 examples/classic/markdown/index.html |   2 +-
 examples/classic/svg/svg.js          |  38 ++---
 examples/composition/commits.html    |  75 +++++++++
 examples/composition/grid.html       | 173 +++++++++++++++++++
 examples/composition/markdown.html   |  66 ++++++++
 examples/composition/svg.html        | 172 +++++++++++++++++++
 examples/composition/todomvc.html    | 241 +++++++++++++++++++++++++++
 examples/composition/tree.html       | 124 ++++++++++++++
 package.json                         |   2 +-
 pnpm-lock.yaml                       |   8 +-
 test/e2e/commits.spec.ts             |  14 +-
 test/e2e/e2eUtils.ts                 |   3 +-
 test/e2e/grid.spec.ts                |  14 +-
 test/e2e/markdown.spec.ts            |  14 +-
 test/e2e/svg.spec.ts                 |  22 +--
 test/e2e/todomvc.spec.ts             |  14 +-
 test/e2e/tree.spec.ts                |  14 +-
 17 files changed, 923 insertions(+), 73 deletions(-)
 create mode 100644 examples/composition/commits.html
 create mode 100644 examples/composition/grid.html
 create mode 100644 examples/composition/markdown.html
 create mode 100644 examples/composition/svg.html
 create mode 100644 examples/composition/todomvc.html
 create mode 100644 examples/composition/tree.html

diff --git a/examples/classic/markdown/index.html b/examples/classic/markdown/index.html
index 25ee2602924..bc77e29c07c 100644
--- a/examples/classic/markdown/index.html
+++ b/examples/classic/markdown/index.html
@@ -24,7 +24,7 @@
         },
         computed: {
           compiledMarkdown: function () {
-            return marked(this.input, { sanitize: true })
+            return marked.marked(this.input)
           }
         },
         methods: {
diff --git a/examples/classic/svg/svg.js b/examples/classic/svg/svg.js
index f4491ce3088..c6df94582ef 100644
--- a/examples/classic/svg/svg.js
+++ b/examples/classic/svg/svg.js
@@ -1,5 +1,5 @@
 // The raw data to observe
-var stats = [
+var globalStats = [
   { label: 'A', value: 100 },
   { label: 'B', value: 100 },
   { label: 'C', value: 100 },
@@ -16,10 +16,12 @@ Vue.component('polygraph', {
     // a computed property for the polygon's points
     points: function () {
       var total = this.stats.length
-      return this.stats.map(function (stat, i) {
-        var point = valueToPoint(stat.value, i, total)
-        return point.x + ',' + point.y
-      }).join(' ')
+      return this.stats
+        .map(function (stat, i) {
+          var point = valueToPoint(stat.value, i, total)
+          return point.x + ',' + point.y
+        })
+        .join(' ')
     }
   },
   components: {
@@ -33,11 +35,7 @@ Vue.component('polygraph', {
       template: '#axis-label-template',
       computed: {
         point: function () {
-          return valueToPoint(
-            +this.stat.value + 10,
-            this.index,
-            this.total
-          )
+          return valueToPoint(+this.stat.value + 10, this.index, this.total)
         }
       }
     }
@@ -45,14 +43,14 @@ Vue.component('polygraph', {
 })
 
 // math helper...
-function valueToPoint (value, index, total) {
-  var x     = 0
-  var y     = -value * 0.8
-  var angle = Math.PI * 2 / total * index
-  var cos   = Math.cos(angle)
-  var sin   = Math.sin(angle)
-  var tx    = x * cos - y * sin + 100
-  var ty    = x * sin + y * cos + 100
+function valueToPoint(value, index, total) {
+  var x = 0
+  var y = -value * 0.8
+  var angle = ((Math.PI * 2) / total) * index
+  var cos = Math.cos(angle)
+  var sin = Math.sin(angle)
+  var tx = x * cos - y * sin + 100
+  var ty = x * sin + y * cos + 100
   return {
     x: tx,
     y: ty
@@ -64,7 +62,7 @@ new Vue({
   el: '#demo',
   data: {
     newLabel: '',
-    stats: stats
+    stats: globalStats
   },
   methods: {
     add: function (e) {
@@ -80,7 +78,7 @@ new Vue({
       if (this.stats.length > 3) {
         this.stats.splice(this.stats.indexOf(stat), 1)
       } else {
-        alert('Can\'t delete more!')
+        alert("Can't delete more!")
       }
     }
   }
diff --git a/examples/composition/commits.html b/examples/composition/commits.html
new file mode 100644
index 00000000000..3c16a3f7bb8
--- /dev/null
+++ b/examples/composition/commits.html
@@ -0,0 +1,75 @@
+<script src="../../dist/vue.min.js"></script>
+
+<div id="demo">
+  <h1>Latest Vue.js Commits</h1>
+  <template v-for="branch in branches">
+    <input type="radio"
+      :id="branch"
+      :value="branch"
+      name="branch"
+      v-model="currentBranch">
+    <label :for="branch">{{ branch }}</label>
+  </template>
+  <p>vuejs/vue@{{ currentBranch }}</p>
+  <ul>
+    <li v-for="{ html_url, sha, author, commit } in commits">
+      <a :href="html_url" target="_blank" class="commit">{{ sha.slice(0, 7) }}</a>
+      - <span class="message">{{ truncate(commit.message) }}</span><br>
+      by <span class="author"><a :href="author.html_url" target="_blank">{{ commit.author.name }}</a></span>
+      at <span class="date">{{ formatDate(commit.author.date) }}</span>
+    </li>
+  </ul>
+</div>
+
+<script>
+const { ref, watchEffect } = Vue
+const API_URL = `https://api.github.com/repos/vuejs/vue/commits?per_page=3&sha=`
+
+const truncate = v => {
+  const newline = v.indexOf('\n')
+  return newline > 0 ? v.slice(0, newline) : v
+}
+
+const formatDate = v => v.replace(/T|Z/g, ' ')
+
+new Vue({
+  setup() {
+    const currentBranch = ref('main')
+    const commits = ref(null)
+
+    watchEffect(() => {
+      fetch(`${API_URL}${currentBranch.value}`)
+        .then(res => res.json())
+        .then(data => {
+          console.log(data)
+          commits.value = data
+        })
+    })
+
+    return {
+      branches: ['main', 'dev'],
+      currentBranch,
+      commits,
+      truncate,
+      formatDate
+    }
+  }
+}).$mount('#demo')
+</script>
+
+<style>
+  #demo {
+    font-family: 'Helvetica', Arial, sans-serif;
+  }
+  a {
+    text-decoration: none;
+    color: #f66;
+  }
+  li {
+    line-height: 1.5em;
+    margin-bottom: 20px;
+  }
+  .author, .date {
+    font-weight: bold;
+  }
+</style>
diff --git a/examples/composition/grid.html b/examples/composition/grid.html
new file mode 100644
index 00000000000..090d3d7dbad
--- /dev/null
+++ b/examples/composition/grid.html
@@ -0,0 +1,173 @@
+<script src="../../dist/vue.min.js"></script>
+
+<!-- DemoGrid component template -->
+<script type="text/x-template" id="grid-template">
+  <table v-if="filteredData.length">
+    <thead>
+      <tr>
+        <th v-for="key in columns"
+          @click="sortBy(key)"
+          :class="{ active: state.sortKey == key }">
+          {{ capitalize(key) }}
+          <span class="arrow" :class="state.sortOrders[key] > 0 ? 'asc' : 'dsc'">
+          </span>
+        </th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr v-for="entry in filteredData">
+        <td v-for="key in columns">
+          {{entry[key]}}
+        </td>
+      </tr>
+    </tbody>
+  </table>
+  <p v-else>No matches found.</p>
+</script>
+<!-- DemoGrid component script -->
+<script>
+const { reactive, computed } = Vue
+
+const capitalize = str => str.charAt(0).toUpperCase() + str.slice(1)
+
+const DemoGrid = {
+  template: '#grid-template',
+  props: {
+    data: Array,
+    columns: Array,
+    filterKey: String
+  },
+  setup(props) {
+    const state = reactive({
+      sortKey: '',
+      sortOrders: props.columns.reduce((o, key) => (o[key] = 1, o), {})
+    })
+
+    const filteredData = computed(() => {
+      let { data, filterKey } = props
+      if (filterKey) {
+        filterKey = filterKey.toLowerCase()
+        data = data.filter(row => {
+          return Object.keys(row).some(key => {
+            return String(row[key]).toLowerCase().indexOf(filterKey) > -1
+          })
+        })
+      }
+      const { sortKey } = state
+      if (sortKey) {
+        const order = state.sortOrders[sortKey]
+        data = data.slice().sort((a, b) => {
+          a = a[sortKey]
+          b = b[sortKey]
+          return (a === b ? 0 : a > b ? 1 : -1) * order
+        })
+      }
+      return data
+    })
+
+    function sortBy(key) {
+      state.sortKey = key
+      state.sortOrders[key] *= -1
+    }
+
+    return {
+      state,
+      filteredData,
+      sortBy,
+      capitalize
+    }
+  }
+}
+</script>
+
+<!-- App template (in DOM) -->
+<div id="demo">
+  <form id="search">
+    Search <input name="query" v-model="searchQuery">
+  </form>
+  <demo-grid
+    :data="gridData"
+    :columns="gridColumns"
+    :filter-key="searchQuery">
+  </demo-grid>
+</div>
+<!-- App script -->
+<script>
+new Vue({
+  components: {
+    DemoGrid
+  },
+  data: () => ({
+    searchQuery: '',
+    gridColumns: ['name', 'power'],
+    gridData: [
+      { name: 'Chuck Norris', power: Infinity },
+      { name: 'Bruce Lee', power: 9000 },
+      { name: 'Jackie Chan', power: 7000 },
+      { name: 'Jet Li', power: 8000 }
+    ]
+  })
+}).$mount('#demo')
+</script>
+
+<style>
+body {
+  font-family: Helvetica Neue, Arial, sans-serif;
+  font-size: 14px;
+  color: #444;
+}
+
+table {
+  border: 2px solid #42b983;
+  border-radius: 3px;
+  background-color: #fff;
+}
+
+th {
+  background-color: #42b983;
+  color: rgba(255,255,255,0.66);
+  cursor: pointer;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+
+td {
+  background-color: #f9f9f9;
+}
+
+th, td {
+  min-width: 120px;
+  padding: 10px 20px;
+}
+
+th.active {
+  color: #fff;
+}
+
+th.active .arrow {
+  opacity: 1;
+}
+
+.arrow {
+  display: inline-block;
+  vertical-align: middle;
+  width: 0;
+  height: 0;
+  margin-left: 5px;
+  opacity: 0.66;
+}
+
+.arrow.asc {
+  border-left: 4px solid transparent;
+  border-right: 4px solid transparent;
+  border-bottom: 4px solid #fff;
+}
+
+.arrow.dsc {
+  border-left: 4px solid transparent;
+  border-right: 4px solid transparent;
+  border-top: 4px solid #fff;
+}
+</style>
diff --git a/examples/composition/markdown.html b/examples/composition/markdown.html
new file mode 100644
index 00000000000..d3387de4a43
--- /dev/null
+++ b/examples/composition/markdown.html
@@ -0,0 +1,66 @@
+<script src="../../node_modules/marked/marked.min.js"></script>
+<script src="../../node_modules/lodash/lodash.min.js"></script>
+<script src="../../dist/vue.min.js"></script>
+
+<div id="editor">
+  <textarea :value="input" @input="update"></textarea>
+  <div v-html="output"></div>
+</div>
+
+<script>
+  const { ref, computed } = Vue
+
+  new Vue({
+    setup() {
+      const input = ref('# hello')
+      const output = computed(() => marked.marked(input.value))
+      const update = _.debounce(e => {
+        input.value = e.target.value
+      }, 300)
+
+      return {
+        input,
+        output,
+        update
+      }
+    }
+  }).$mount('#editor')
+</script>
+
+<style>
+  html,
+  body,
+  #editor {
+    margin: 0;
+    height: 100%;
+    font-family: 'Helvetica Neue', Arial, sans-serif;
+    color: #333;
+  }
+
+  textarea,
+  #editor div {
+    display: inline-block;
+    width: 49%;
+    height: 100%;
+    vertical-align: top;
+    -webkit-box-sizing: border-box;
+    -moz-box-sizing: border-box;
+    box-sizing: border-box;
+    padding: 0 20px;
+  }
+
+  textarea {
+    border: none;
+    border-right: 1px solid #ccc;
+    resize: none;
+    outline: none;
+    background-color: #f6f6f6;
+    font-size: 14px;
+    font-family: 'Monaco', courier, monospace;
+    padding: 20px;
+  }
+
+  code {
+    color: #f66;
+  }
+</style>
diff --git a/examples/composition/svg.html b/examples/composition/svg.html
new file mode 100644
index 00000000000..2b4d5e0c316
--- /dev/null
+++ b/examples/composition/svg.html
@@ -0,0 +1,172 @@
+<script src="../../dist/vue.min.js"></script>
+<script>
+  const { ref, computed, createApp } = Vue
+
+  // math helper...
+  function valueToPoint(value, index, total) {
+    var x = 0
+    var y = -value * 0.8
+    var angle = ((Math.PI * 2) / total) * index
+    var cos = Math.cos(angle)
+    var sin = Math.sin(angle)
+    var tx = x * cos - y * sin + 100
+    var ty = x * sin + y * cos + 100
+    return {
+      x: tx,
+      y: ty
+    }
+  }
+
+  const AxisLabel = {
+    template: '<text :x="point.x" :y="point.y">{{stat.label}}</text>',
+    props: {
+      stat: Object,
+      index: Number,
+      total: Number
+    },
+    setup(props) {
+      return {
+        point: computed(() =>
+          valueToPoint(+props.stat.value + 10, props.index, props.total)
+        )
+      }
+    }
+  }
+</script>
+
+<!-- template for the polygraph component. -->
+<script type="text/x-template" id="polygraph-template">
+  <g>
+    <polygon :points="points"></polygon>
+    <circle cx="100" cy="100" r="80"></circle>
+    <axis-label
+      v-for="(stat, index) in stats"
+      :stat="stat"
+      :index="index"
+      :total="stats.length">
+    </axis-label>
+  </g>
+</script>
+
+<script>
+  const Polygraph = {
+    props: ['stats'],
+    template: '#polygraph-template',
+    setup(props) {
+      return {
+        points: computed(() => {
+          const total = props.stats.length
+          return props.stats
+            .map((stat, i) => {
+              const point = valueToPoint(stat.value, i, total)
+              return point.x + ',' + point.y
+            })
+            .join(' ')
+        })
+      }
+    },
+    components: {
+      AxisLabel
+    }
+  }
+</script>
+
+<!-- demo root element -->
+<div id="demo">
+  <!-- Use the polygraph component -->
+  <svg width="200" height="200">
+    <polygraph :stats="stats"></polygraph>
+  </svg>
+  <!-- controls -->
+  <div v-for="stat in stats">
+    <label>{{stat.label}}</label>
+    <input type="range" v-model="stat.value" min="0" max="100" />
+    <span>{{stat.value}}</span>
+    <button @click="remove(stat)" class="remove">X</button>
+  </div>
+  <form id="add">
+    <input name="newlabel" v-model="newLabel" />
+    <button @click="add">Add a Stat</button>
+  </form>
+  <pre id="raw">{{ stats }}</pre>
+</div>
+
+<script>
+  const globalStats = [
+    { label: 'A', value: 100 },
+    { label: 'B', value: 100 },
+    { label: 'C', value: 100 },
+    { label: 'D', value: 100 },
+    { label: 'E', value: 100 },
+    { label: 'F', value: 100 }
+  ]
+
+  new Vue({
+    components: {
+      Polygraph
+    },
+    setup() {
+      const newLabel = ref('')
+      const stats = ref(globalStats)
+
+      function add(e) {
+        e.preventDefault()
+        if (!newLabel.value) return
+        stats.value.push({
+          label: newLabel.value,
+          value: 100
+        })
+        newLabel.value = ''
+      }
+
+      function remove(stat) {
+        if (stats.value.length > 3) {
+          stats.value.splice(stats.value.indexOf(stat), 1)
+        } else {
+          alert("Can't delete more!")
+        }
+      }
+
+      return {
+        newLabel,
+        stats,
+        add,
+        remove
+      }
+    }
+  }).$mount('#demo')
+</script>
+
+<style>
+  body {
+    font-family: Helvetica Neue, Arial, sans-serif;
+  }
+
+  polygon {
+    fill: #42b983;
+    opacity: 0.75;
+  }
+
+  circle {
+    fill: transparent;
+    stroke: #999;
+  }
+
+  text {
+    font-family: Helvetica Neue, Arial, sans-serif;
+    font-size: 10px;
+    fill: #666;
+  }
+
+  label {
+    display: inline-block;
+    margin-left: 10px;
+    width: 20px;
+  }
+
+  #raw {
+    position: absolute;
+    top: 0;
+    left: 300px;
+  }
+</style>
diff --git a/examples/composition/todomvc.html b/examples/composition/todomvc.html
new file mode 100644
index 00000000000..ac806bc8369
--- /dev/null
+++ b/examples/composition/todomvc.html
@@ -0,0 +1,241 @@
+<script src="../../dist/vue.min.js"></script>
+<link
+  rel="stylesheet"
+  href="../../node_modules/todomvc-app-css/index.css"
+/>
+
+<div id="app">
+  <section class="todoapp">
+    <header class="header">
+      <h1>todos</h1>
+      <input
+        class="new-todo"
+        autofocus
+        autocomplete="off"
+        placeholder="What needs to be done?"
+        v-model="state.newTodo"
+        @keyup.enter="addTodo"
+      />
+    </header>
+    <section class="main" v-show="state.todos.length">
+      <input
+        id="toggle-all"
+        class="toggle-all"
+        type="checkbox"
+        v-model="state.allDone"
+      />
+      <label for="toggle-all">Mark all as complete</label>
+      <ul class="todo-list">
+        <li
+          v-for="todo in state.filteredTodos"
+          class="todo"
+          :key="todo.id"
+          :class="{ completed: todo.completed, editing: todo === state.editedTodo }"
+        >
+          <div class="view">
+            <input class="toggle" type="checkbox" v-model="todo.completed" />
+            <label @dblclick="editTodo(todo)">{{ todo.title }}</label>
+            <button class="destroy" @click="removeTodo(todo)"></button>
+          </div>
+          <input
+            class="edit"
+            type="text"
+            v-model="todo.title"
+            v-todo-focus="todo === state.editedTodo"
+            @blur="doneEdit(todo)"
+            @keyup.enter="doneEdit(todo)"
+            @keyup.escape="cancelEdit(todo)"
+          />
+        </li>
+      </ul>
+    </section>
+    <footer class="footer" v-show="state.todos.length">
+      <span class="todo-count">
+        <strong>{{ state.remaining }}</strong>
+        <span>{{ state.remainingText }}</span>
+      </span>
+      <ul class="filters">
+        <li>
+          <a href="#/all" :class="{ selected: state.visibility === 'all' }"
+            >All</a
+          >
+        </li>
+        <li>
+          <a
+            href="#/active"
+            :class="{ selected: state.visibility === 'active' }"
+            >Active</a
+          >
+        </li>
+        <li>
+          <a
+            href="#/completed"
+            :class="{ selected: state.visibility === 'completed' }"
+            >Completed</a
+          >
+        </li>
+      </ul>
+
+      <button
+        class="clear-completed"
+        @click="removeCompleted"
+        v-show="state.todos.length > state.remaining"
+      >
+        Clear completed
+      </button>
+    </footer>
+  </section>
+</div>
+
+<script>
+  const { reactive, computed, watchEffect, onMounted, onUnmounted } = Vue
+
+  const STORAGE_KEY = 'todos-vuejs-3.x'
+  const todoStorage = {
+    fetch() {
+      const todos = JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]')
+      todos.forEach((todo, index) => {
+        todo.id = index
+      })
+      todoStorage.uid = todos.length
+      return todos
+    },
+    save(todos) {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(todos))
+    }
+  }
+
+  const filters = {
+    all(todos) {
+      return todos
+    },
+    active(todos) {
+      return todos.filter(todo => {
+        return !todo.completed
+      })
+    },
+    completed(todos) {
+      return todos.filter(function (todo) {
+        return todo.completed
+      })
+    }
+  }
+
+  function pluralize(n) {
+    return n === 1 ? 'item' : 'items'
+  }
+
+  new Vue({
+    setup() {
+      const state = reactive({
+        todos: todoStorage.fetch(),
+        editedTodo: null,
+        newTodo: '',
+        beforeEditCache: '',
+        visibility: 'all',
+        remaining: computed(() => {
+          return filters.active(state.todos).length
+        }),
+        remainingText: computed(() => {
+          return ` ${pluralize(state.remaining)} left`
+        }),
+        filteredTodos: computed(() => {
+          return filters[state.visibility](state.todos)
+        }),
+        allDone: computed({
+          get: function () {
+            return state.remaining === 0
+          },
+          set: function (value) {
+            state.todos.forEach(todo => {
+              todo.completed = value
+            })
+          }
+        })
+      })
+
+      watchEffect(() => {
+        todoStorage.save(state.todos)
+      })
+
+      onMounted(() => {
+        window.addEventListener('hashchange', onHashChange)
+        onHashChange()
+      })
+
+      onUnmounted(() => {
+        window.removeEventListener('hashchange', onHashChange)
+      })
+
+      function onHashChange() {
+        const visibility = window.location.hash.replace(/#\/?/, '')
+        if (filters[visibility]) {
+          state.visibility = visibility
+        } else {
+          window.location.hash = ''
+          state.visibility = 'all'
+        }
+      }
+
+      function addTodo() {
+        const value = state.newTodo && state.newTodo.trim()
+        if (!value) {
+          return
+        }
+        state.todos.push({
+          id: todoStorage.uid++,
+          title: value,
+          completed: false
+        })
+        state.newTodo = ''
+      }
+
+      function removeTodo(todo) {
+        state.todos.splice(state.todos.indexOf(todo), 1)
+      }
+
+      function editTodo(todo) {
+        state.beforeEditCache = todo.title
+        state.editedTodo = todo
+      }
+
+      function doneEdit(todo) {
+        if (!state.editedTodo) {
+          return
+        }
+        state.editedTodo = null
+        todo.title = todo.title.trim()
+        if (!todo.title) {
+          removeTodo(todo)
+        }
+      }
+
+      function cancelEdit(todo) {
+        state.editedTodo = null
+        todo.title = state.beforeEditCache
+      }
+
+      function removeCompleted() {
+        state.todos = filters.active(state.todos)
+      }
+
+      return {
+        state,
+        addTodo,
+        removeTodo,
+        editTodo,
+        doneEdit,
+        cancelEdit,
+        removeCompleted
+      }
+    },
+
+    directives: {
+      'todo-focus': (el, { value }) => {
+        if (value) {
+          el.focus()
+        }
+      }
+    }
+  }).$mount('#app')
+</script>
diff --git a/examples/composition/tree.html b/examples/composition/tree.html
new file mode 100644
index 00000000000..c39fe3987b7
--- /dev/null
+++ b/examples/composition/tree.html
@@ -0,0 +1,124 @@
+<script src="../../dist/vue.min.js"></script>
+
+<!-- item template -->
+<script type="text/x-template" id="item-template">
+  <li>
+    <div
+      :class="{bold: isFolder}"
+      @click="toggle"
+      @dblclick="changeType">
+      {{model.name}}
+      <span v-if="isFolder">[{{open ? '-' : '+'}}]</span>
+    </div>
+    <ul v-if="isFolder" v-show="open">
+      <tree-item
+        class="item"
+        v-for="model in model.children"
+        :model="model">
+      </tree-item>
+      <li class="add" @click="addChild">+</li>
+    </ul>
+  </li>
+</script>
+<!-- item script -->
+<script>
+  const { reactive, computed, toRefs } = Vue
+
+  const TreeItem = {
+    name: 'TreeItem', // necessary for self-reference
+    template: '#item-template',
+    props: {
+      model: Object
+    },
+    setup(props) {
+      const state = reactive({
+        open: false,
+        isFolder: computed(() => {
+          return props.model.children && props.model.children.length
+        })
+      })
+
+      function toggle() {
+        state.open = !state.open
+      }
+
+      function changeType() {
+        if (!state.isFolder) {
+          Vue.set(props.model, 'children', [])
+          addChild()
+          state.open = true
+        }
+      }
+
+      function addChild() {
+        props.model.children.push({ name: 'new stuff' })
+      }
+
+      return {
+        ...toRefs(state),
+        toggle,
+        changeType,
+        addChild
+      }
+    }
+  }
+</script>
+
+<p>(You can double click on an item to turn it into a folder.)</p>
+
+<!-- the app root element -->
+<ul id="demo">
+  <tree-item class="item" :model="treeData"></tree-item>
+</ul>
+
+<script>
+  const treeData = {
+    name: 'My Tree',
+    children: [
+      { name: 'hello' },
+      { name: 'wat' },
+      {
+        name: 'child folder',
+        children: [
+          {
+            name: 'child folder',
+            children: [{ name: 'hello' }, { name: 'wat' }]
+          },
+          { name: 'hello' },
+          { name: 'wat' },
+          {
+            name: 'child folder',
+            children: [{ name: 'hello' }, { name: 'wat' }]
+          }
+        ]
+      }
+    ]
+  }
+
+  new Vue({
+    components: {
+      TreeItem
+    },
+    data: () => ({
+      treeData
+    })
+  }).$mount('#demo')
+</script>
+
+<style>
+  body {
+    font-family: Menlo, Consolas, monospace;
+    color: #444;
+  }
+  .item {
+    cursor: pointer;
+  }
+  .bold {
+    font-weight: bold;
+  }
+  ul {
+    padding-left: 1em;
+    line-height: 1.5em;
+    list-style-type: dot;
+  }
+</style>
diff --git a/package.json b/package.json
index a631ac6d49b..e1ab5d5dad4 100644
--- a/package.json
+++ b/package.json
@@ -93,7 +93,7 @@
     "lodash.template": "^4.4.0",
     "lodash.uniq": "^4.5.0",
     "lru-cache": "^7.8.1",
-    "marked": "^3.0.8",
+    "marked": "^4.0.6",
     "memory-fs": "^0.5.0",
     "prettier": "^2.6.2",
     "puppeteer": "^14.1.1",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a0f328bffa4..a03e974e3c7 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -32,7 +32,7 @@ specifiers:
   lodash.template: ^4.4.0
   lodash.uniq: ^4.5.0
   lru-cache: ^7.8.1
-  marked: ^3.0.8
+  marked: ^4.0.6
   memory-fs: ^0.5.0
   prettier: ^2.6.2
   puppeteer: ^14.1.1
@@ -83,7 +83,7 @@ devDependencies:
   lodash.template: 4.5.0
   lodash.uniq: 4.5.0
   lru-cache: 7.10.1
-  marked: 3.0.8
+  marked: 4.0.16
   memory-fs: 0.5.0
   prettier: 2.6.2
   puppeteer: 14.1.1
@@ -3747,8 +3747,8 @@ packages:
       object-visit: 1.0.1
     dev: true
 
-  /marked/3.0.8:
-    resolution: {integrity: sha512-0gVrAjo5m0VZSJb4rpL59K1unJAMb/hm8HRXqasD8VeC8m91ytDPMritgFSlKonfdt+rRYYpP/JfLxgIX8yoSw==}
+  /marked/4.0.16:
+    resolution: {integrity: sha512-wahonIQ5Jnyatt2fn8KqF/nIqZM8mh3oRu2+l5EANGMhu6RFjiSG52QNE2eWzFMI94HqYSgN184NurgNG6CztA==}
     engines: {node: '>= 12'}
     hasBin: true
     dev: true
diff --git a/test/e2e/commits.spec.ts b/test/e2e/commits.spec.ts
index 73e94667f1e..28796fe7c71 100644
--- a/test/e2e/commits.spec.ts
+++ b/test/e2e/commits.spec.ts
@@ -52,11 +52,11 @@ describe('e2e: commits', () => {
     E2E_TIMEOUT
   )
 
-  // test(
-  //   'composition',
-  //   async () => {
-  //     await testCommits('composition')
-  //   },
-  //   E2E_TIMEOUT
-  // )
+  test(
+    'composition',
+    async () => {
+      await testCommits('composition')
+    },
+    E2E_TIMEOUT
+  )
 })
diff --git a/test/e2e/e2eUtils.ts b/test/e2e/e2eUtils.ts
index d9224e62e1c..b991cbd299a 100644
--- a/test/e2e/e2eUtils.ts
+++ b/test/e2e/e2eUtils.ts
@@ -5,9 +5,10 @@ export function getExampleUrl(
   name: string,
   apiType: 'classic' | 'composition'
 ) {
+  const file = apiType === 'composition' ? `${name}.html` : `${name}/index.html`
   return `file://${path.resolve(
     __dirname,
-    `../../examples/${apiType}/${name}/index.html`
+    `../../examples/${apiType}/${file}`
   )}`
 }
 
diff --git a/test/e2e/grid.spec.ts b/test/e2e/grid.spec.ts
index 9648872dfb5..937a5bbb2dd 100644
--- a/test/e2e/grid.spec.ts
+++ b/test/e2e/grid.spec.ts
@@ -105,11 +105,11 @@ describe('e2e: grid', () => {
     E2E_TIMEOUT
   )
 
-  // test(
-  //   'composition',
-  //   async () => {
-  //     await testGrid('composition')
-  //   },
-  //   E2E_TIMEOUT
-  // )
+  test(
+    'composition',
+    async () => {
+      await testGrid('composition')
+    },
+    E2E_TIMEOUT
+  )
 })
diff --git a/test/e2e/markdown.spec.ts b/test/e2e/markdown.spec.ts
index cd1d64f5dfb..67b7244afae 100644
--- a/test/e2e/markdown.spec.ts
+++ b/test/e2e/markdown.spec.ts
@@ -36,11 +36,11 @@ describe('e2e: markdown', () => {
     E2E_TIMEOUT
   )
 
-  // test(
-  //   'composition',
-  //   async () => {
-  //     await testMarkdown('composition')
-  //   },
-  //   E2E_TIMEOUT
-  // )
+  test(
+    'composition',
+    async () => {
+      await testMarkdown('composition')
+    },
+    E2E_TIMEOUT
+  )
 })
diff --git a/test/e2e/svg.spec.ts b/test/e2e/svg.spec.ts
index e8584e87dd3..5032ca4c664 100644
--- a/test/e2e/svg.spec.ts
+++ b/test/e2e/svg.spec.ts
@@ -1,6 +1,6 @@
 import { setupPuppeteer, getExampleUrl, E2E_TIMEOUT } from './e2eUtils'
 
-declare const stats: {
+declare const globalStats: {
   label: string
   value: number
 }[]
@@ -22,7 +22,7 @@ describe('e2e: svg', () => {
     expect(
       await page().evaluate(
         total => {
-          const points = stats
+          const points = globalStats
             .map((stat, i) => {
               const point = valueToPoint(stat.value, i, total)
               return point.x + ',' + point.y
@@ -41,7 +41,7 @@ describe('e2e: svg', () => {
   async function assertLabels(total: number) {
     const positions = await page().evaluate(
       total => {
-        return stats.map((stat, i) => {
+        return globalStats.map((stat, i) => {
           const point = valueToPoint(+stat.value + 10, i, total)
           return [point.x, point.y]
         })
@@ -60,7 +60,7 @@ describe('e2e: svg', () => {
   // assert each value of stats is correct
   async function assertStats(expected: number[]) {
     const statsValue = await page().evaluate(() => {
-      return stats.map(stat => +stat.value)
+      return globalStats.map(stat => +stat.value)
     })
     expect(statsValue).toEqual(expected)
   }
@@ -141,11 +141,11 @@ describe('e2e: svg', () => {
     E2E_TIMEOUT
   )
 
-  // test(
-  //   'composition',
-  //   async () => {
-  //     await testSvg('composition')
-  //   },
-  //   E2E_TIMEOUT
-  // )
+  test(
+    'composition',
+    async () => {
+      await testSvg('composition')
+    },
+    E2E_TIMEOUT
+  )
 })
diff --git a/test/e2e/todomvc.spec.ts b/test/e2e/todomvc.spec.ts
index b73b3e214b1..f1de97e6354 100644
--- a/test/e2e/todomvc.spec.ts
+++ b/test/e2e/todomvc.spec.ts
@@ -172,11 +172,11 @@ describe('e2e: todomvc', () => {
     E2E_TIMEOUT
   )
 
-  // test(
-  //   'composition',
-  //   async () => {
-  //     await testTodomvc('composition')
-  //   },
-  //   E2E_TIMEOUT
-  // )
+  test(
+    'composition',
+    async () => {
+      await testTodomvc('composition')
+    },
+    E2E_TIMEOUT
+  )
 })
diff --git a/test/e2e/tree.spec.ts b/test/e2e/tree.spec.ts
index 360374100b3..970aaa5eaf2 100644
--- a/test/e2e/tree.spec.ts
+++ b/test/e2e/tree.spec.ts
@@ -98,11 +98,11 @@ describe('e2e: tree', () => {
     E2E_TIMEOUT
   )
 
-  // test(
-  //   'composition',
-  //   async () => {
-  //     await testTree('composition')
-  //   },
-  //   E2E_TIMEOUT
-  // )
+  test(
+    'composition',
+    async () => {
+      await testTree('composition')
+    },
+    E2E_TIMEOUT
+  )
 })

From 2acb5474bceb533aadc547921c22fa5cd471a3e1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 30 May 2022 21:36:07 +0800
Subject: [PATCH 099/317] types: generate types for v3 apis

---
 .gitignore                                    |   9 +-
 api-extractor.json                            |  63 +++
 api-extractor.tsconfig.json                   |  35 ++
 package.json                                  |   5 +-
 pnpm-lock.yaml                                | 163 +++++++-
 src/compiler/codegen/events.ts                |   2 +
 src/compiler/codegen/index.ts                 |  10 +
 src/compiler/create-compiler.ts               |   5 +
 src/compiler/directives/bind.ts               |   2 +
 src/compiler/directives/model.ts              |   2 +
 src/compiler/directives/on.ts                 |   1 +
 src/compiler/error-detector.ts                |   1 +
 src/compiler/helpers.ts                       |   1 +
 src/compiler/index.ts                         |   1 +
 src/compiler/optimizer.ts                     |   1 +
 src/compiler/parser/index.ts                  |   9 +
 src/compiler/to-function.ts                   |   1 +
 src/core/config.ts                            |   3 +
 src/core/instance/init.ts                     |   2 +-
 src/core/observer/dep.ts                      |  24 +-
 src/core/observer/watcher.ts                  |  18 +-
 src/core/util/next-tick.ts                    |   3 +
 src/core/vdom/vnode.ts                        |   3 +
 src/platforms/web/compiler/directives/html.ts |   1 +
 .../web/compiler/directives/model.ts          |   1 +
 src/platforms/web/compiler/directives/text.ts |   1 +
 src/platforms/web/compiler/modules/class.ts   |   1 +
 src/platforms/web/compiler/modules/model.ts   |   1 +
 src/platforms/web/compiler/modules/style.ts   |   1 +
 src/platforms/web/compiler/options.ts         |   1 +
 src/server/optimizing-compiler/codegen.ts     |   1 +
 src/server/optimizing-compiler/index.ts       |   1 +
 src/server/optimizing-compiler/modules.ts     |   1 +
 src/server/optimizing-compiler/optimizer.ts   |   1 +
 src/sfc/parser.ts                             |   6 +
 src/shared/util.ts                            |   4 +-
 src/v3/apiLifecycle.ts                        |   6 +-
 src/v3/apiSetup.ts                            |   6 +
 src/v3/apiWatch.ts                            |   2 +-
 src/v3/currentInstance.ts                     |   4 +-
 src/v3/debug.ts                               |  21 +
 src/v3/h.ts                                   |   2 +-
 src/v3/index.ts                               |   9 +-
 src/v3/reactivity/computed.ts                 |   5 +-
 src/v3/reactivity/effect.ts                   |   2 +-
 src/v3/reactivity/effectScope.ts              |   3 +
 src/v3/reactivity/reactive.ts                 |   2 +-
 src/v3/reactivity/ref.ts                      |  11 +-
 types/index.d.ts                              |   3 +-
 types/test/utils.ts                           |  14 +
 types/test/v3/inject-test.ts                  |  16 +
 types/test/v3/reactivity-test.ts              | 373 ++++++++++++++++++
 types/test/{ => v3}/setup-test.ts             |   5 +-
 types/test/v3/watch-test.ts                   |  78 ++++
 types/tsconfig.json                           |   6 +-
 types/v3.d.ts                                 |   4 +
 typescript/{compiler.d.ts => compiler.ts}     |  34 +-
 typescript/{component.d.ts => component.ts}   |   5 +-
 typescript/{global-api.d.ts => global-api.ts} |   5 +-
 typescript/{options.d.ts => options.ts}       |  14 +-
 typescript/{ssr.d.ts => ssr.ts}               |   8 +-
 typescript/{vnode.d.ts => vnode.ts}           |  38 +-
 62 files changed, 957 insertions(+), 104 deletions(-)
 create mode 100644 api-extractor.json
 create mode 100644 api-extractor.tsconfig.json
 create mode 100644 src/v3/debug.ts
 create mode 100644 types/test/utils.ts
 create mode 100644 types/test/v3/inject-test.ts
 create mode 100644 types/test/v3/reactivity-test.ts
 rename types/test/{ => v3}/setup-test.ts (85%)
 create mode 100644 types/test/v3/watch-test.ts
 rename typescript/{compiler.d.ts => compiler.ts} (89%)
 rename typescript/{component.d.ts => component.ts} (98%)
 rename typescript/{global-api.d.ts => global-api.ts} (95%)
 rename typescript/{options.d.ts => options.ts} (93%)
 rename typescript/{ssr.d.ts => ssr.ts} (74%)
 rename typescript/{vnode.d.ts => vnode.ts} (82%)

diff --git a/.gitignore b/.gitignore
index 1dd81e3fe8b..0062d8c630d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,14 +3,7 @@ node_modules
 *.log
 explorations
 TODOs.md
-dist/*.gz
-dist/*.map
-dist/vue.common.min.js
-test/e2e/reports
-test/e2e/screenshots
-coverage
 RELEASE_NOTE*.md
-dist/*.js
 packages/vue-server-renderer/basic.js
 packages/vue-server-renderer/build.dev.js
 packages/vue-server-renderer/build.prod.js
@@ -20,3 +13,5 @@ packages/vue-template-compiler/build.js
 packages/vue-template-compiler/browser.js
 .vscode
 dist
+temp
+types/v3-generated.d.ts
diff --git a/api-extractor.json b/api-extractor.json
new file mode 100644
index 00000000000..19fcd417f2b
--- /dev/null
+++ b/api-extractor.json
@@ -0,0 +1,63 @@
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+
+  "projectFolder": ".",
+
+  "compiler": {
+    "tsconfigFilePath": "api-extractor.tsconfig.json"
+  },
+
+  "mainEntryPointFilePath": "./temp/src/v3/index.d.ts",
+
+  "dtsRollup": {
+    "enabled": true,
+    "publicTrimmedFilePath": "./types/v3-generated.d.ts"
+  },
+
+  "apiReport": {
+    "enabled": false
+  },
+
+  "docModel": {
+    "enabled": false
+  },
+
+  "tsdocMetadata": {
+    "enabled": false
+  },
+
+  "messages": {
+    "compilerMessageReporting": {
+      "default": {
+        "logLevel": "warning"
+      }
+    },
+
+    "extractorMessageReporting": {
+      "default": {
+        "logLevel": "warning",
+        "addToApiReportFile": true
+      },
+
+      "ae-missing-release-tag": {
+        "logLevel": "none"
+      },
+      "ae-internal-missing-underscore": {
+        "logLevel": "none"
+      },
+      "ae-forgotten-export": {
+        "logLevel": "none"
+      }
+    },
+
+    "tsdocMessageReporting": {
+      "default": {
+        "logLevel": "warning"
+      },
+
+      "tsdoc-undefined-tag": {
+        "logLevel": "none"
+      }
+    }
+  }
+}
diff --git a/api-extractor.tsconfig.json b/api-extractor.tsconfig.json
new file mode 100644
index 00000000000..905ab9246f8
--- /dev/null
+++ b/api-extractor.tsconfig.json
@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "baseUrl": "./temp",
+    "outDir": "dist",
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+
+    "allowJs": true,
+    "noImplicitAny": false,
+    "noImplicitThis": false,
+
+    "noUnusedLocals": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "removeComments": false,
+    "jsx": "preserve",
+    "lib": ["esnext", "dom"],
+    "paths": {
+      "compiler/*": ["src/compiler/*"],
+      "core/*": ["src/core/*"],
+      "server/*": ["src/server/*"],
+      "sfc/*": ["src/sfc/*"],
+      "shared/*": ["src/shared/*"],
+      "web/*": ["src/platforms/web/*"],
+      "v3": ["src/v3/index"],
+      "v3/*": ["src/v3/*"],
+      "vue": ["src/platforms/web/entry-runtime-with-compiler"]
+    }
+  },
+  "include": ["src", "typescript"]
+}
diff --git a/package.json b/package.json
index e1ab5d5dad4..a9066eb3bed 100644
--- a/package.json
+++ b/package.json
@@ -22,12 +22,13 @@
     "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:web-compiler ",
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
+    "build:types": "rimraf temp && tsc --declaration --emitDeclarationOnly --outDir temp && api-extractor run",
     "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run test/unit",
     "test:ssr": "npm run build:ssr && vitest run test/ssr",
     "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",
     "test:transition": "karma start test/transition/karma.conf.js",
-    "test:types": "tsc -p ./types/tsconfig.json",
+    "test:types": "npm run build:types && tsc -p ./types/tsconfig.json",
     "format": "prettier --write --parser typescript \"(src|test|packages|types)/**/*.ts\"",
     "ts-check": "tsc -p tsconfig.json --noEmit",
     "ts-check:test": "tsc -p test/tsconfig.json --noEmit",
@@ -62,6 +63,7 @@
   },
   "homepage": "https://github.com/vuejs/vue#readme",
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.24.2",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-commonjs": "^22.0.0",
     "@rollup/plugin-node-resolve": "^13.2.1",
@@ -98,6 +100,7 @@
     "prettier": "^2.6.2",
     "puppeteer": "^14.1.1",
     "resolve": "^1.22.0",
+    "rimraf": "^3.0.2",
     "rollup": "^2.70.2",
     "rollup-plugin-typescript2": "^0.31.2",
     "serialize-javascript": "^6.0.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a03e974e3c7..0ba5befa701 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,6 +1,7 @@
 lockfileVersion: 5.4
 
 specifiers:
+  '@microsoft/api-extractor': ^7.24.2
   '@rollup/plugin-alias': ^3.1.9
   '@rollup/plugin-commonjs': ^22.0.0
   '@rollup/plugin-node-resolve': ^13.2.1
@@ -37,6 +38,7 @@ specifiers:
   prettier: ^2.6.2
   puppeteer: ^14.1.1
   resolve: ^1.22.0
+  rimraf: ^3.0.2
   rollup: ^2.70.2
   rollup-plugin-typescript2: ^0.31.2
   serialize-javascript: ^6.0.0
@@ -52,6 +54,7 @@ specifiers:
   yorkie: ^2.0.0
 
 devDependencies:
+  '@microsoft/api-extractor': 7.24.2
   '@rollup/plugin-alias': 3.1.9_rollup@2.74.0
   '@rollup/plugin-commonjs': 22.0.0_rollup@2.74.0
   '@rollup/plugin-node-resolve': 13.3.0_rollup@2.74.0
@@ -88,6 +91,7 @@ devDependencies:
   prettier: 2.6.2
   puppeteer: 14.1.1
   resolve: 1.22.0
+  rimraf: 3.0.2
   rollup: 2.74.0
   rollup-plugin-typescript2: 0.31.2_dyu3set7imqii5ytavmnwecwpy
   serialize-javascript: 6.0.0
@@ -205,6 +209,45 @@ packages:
     engines: {node: '>=6.9.0'}
     dev: true
 
+  /@microsoft/api-extractor-model/7.17.3:
+    resolution: {integrity: sha512-ETslFxVEZTEK6mrOARxM34Ll2W/5H2aTk9Pe9dxsMCnthE8O/CaStV4WZAGsvvZKyjelSWgPVYGowxGVnwOMlQ==}
+    dependencies:
+      '@microsoft/tsdoc': 0.14.1
+      '@microsoft/tsdoc-config': 0.16.1
+      '@rushstack/node-core-library': 3.45.5
+    dev: true
+
+  /@microsoft/api-extractor/7.24.2:
+    resolution: {integrity: sha512-QWZh9aQZvBAdRVK+Go8NiW8YNMN//OGiNqgA3iZ2sEy8imUqkRBCybXgmw2HkEYyPnn55CFoMKvnAHvV9+4B/A==}
+    hasBin: true
+    dependencies:
+      '@microsoft/api-extractor-model': 7.17.3
+      '@microsoft/tsdoc': 0.14.1
+      '@microsoft/tsdoc-config': 0.16.1
+      '@rushstack/node-core-library': 3.45.5
+      '@rushstack/rig-package': 0.3.11
+      '@rushstack/ts-command-line': 4.11.0
+      colors: 1.2.5
+      lodash: 4.17.21
+      resolve: 1.17.0
+      semver: 7.3.7
+      source-map: 0.6.1
+      typescript: 4.6.4
+    dev: true
+
+  /@microsoft/tsdoc-config/0.16.1:
+    resolution: {integrity: sha512-2RqkwiD4uN6MLnHFljqBlZIXlt/SaUT6cuogU1w2ARw4nKuuppSmR0+s+NC+7kXBQykd9zzu0P4HtBpZT5zBpQ==}
+    dependencies:
+      '@microsoft/tsdoc': 0.14.1
+      ajv: 6.12.6
+      jju: 1.4.0
+      resolve: 1.19.0
+    dev: true
+
+  /@microsoft/tsdoc/0.14.1:
+    resolution: {integrity: sha512-6Wci+Tp3CgPt/B9B0a3J4s3yMgLNSku6w5TV6mN+61C71UqsRBv2FUibBf3tPGlNxebgPHMEUzKpb1ggE8KCKw==}
+    dev: true
+
   /@rollup/plugin-alias/3.1.9_rollup@2.74.0:
     resolution: {integrity: sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==}
     engines: {node: '>=8.0.0'}
@@ -276,6 +319,36 @@ packages:
       picomatch: 2.3.1
     dev: true
 
+  /@rushstack/node-core-library/3.45.5:
+    resolution: {integrity: sha512-KbN7Hp9vH3bD3YJfv6RnVtzzTAwGYIBl7y2HQLY4WEQqRbvE3LgI78W9l9X+cTAXCX//p0EeoiUYNTFdqJrMZg==}
+    dependencies:
+      '@types/node': 12.20.24
+      colors: 1.2.5
+      fs-extra: 7.0.1
+      import-lazy: 4.0.0
+      jju: 1.4.0
+      resolve: 1.17.0
+      semver: 7.3.7
+      timsort: 0.3.0
+      z-schema: 5.0.3
+    dev: true
+
+  /@rushstack/rig-package/0.3.11:
+    resolution: {integrity: sha512-uI1/g5oQPtyrT9nStoyX/xgZSLa2b+srRFaDk3r1eqC7zA5th4/bvTGl2QfV3C9NcP+coSqmk5mFJkUfH6i3Lw==}
+    dependencies:
+      resolve: 1.17.0
+      strip-json-comments: 3.1.1
+    dev: true
+
+  /@rushstack/ts-command-line/4.11.0:
+    resolution: {integrity: sha512-ptG9L0mjvJ5QtK11GsAFY+jGfsnqHDS6CY6Yw1xT7a9bhjfNYnf6UPwjV+pF6UgiucfNcMDNW9lkDLxvZKKxMg==}
+    dependencies:
+      '@types/argparse': 1.0.38
+      argparse: 1.0.10
+      colors: 1.2.5
+      string-argv: 0.3.1
+    dev: true
+
   /@tootallnate/once/2.0.0:
     resolution: {integrity: sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==}
     engines: {node: '>= 10'}
@@ -297,6 +370,10 @@ packages:
     resolution: {integrity: sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==}
     dev: true
 
+  /@types/argparse/1.0.38:
+    resolution: {integrity: sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA==}
+    dev: true
+
   /@types/chai-subset/1.3.3:
     resolution: {integrity: sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==}
     dependencies:
@@ -335,6 +412,10 @@ packages:
     resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==}
     dev: true
 
+  /@types/node/12.20.24:
+    resolution: {integrity: sha512-yxDeaQIAJlMav7fH5AQqPH1u8YIuhYJXYBzxaQ4PifsU0GDO38MSdmEDeRlIxrKbC6NbEaaEHDanWb+y30U8SQ==}
+    dev: true
+
   /@types/node/17.0.34:
     resolution: {integrity: sha512-XImEz7XwTvDBtzlTnm8YvMqGW/ErMWBsKZ+hMTvnDIjGCKxwK5Xpc+c/oQjOauwq8M4OS11hEkpjX8rrI/eEgA==}
     dev: true
@@ -683,6 +764,12 @@ packages:
     resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==}
     dev: true
 
+  /argparse/1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+    dependencies:
+      sprintf-js: 1.0.3
+    dev: true
+
   /arr-diff/4.0.0:
     resolution: {integrity: sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA==}
     engines: {node: '>=0.10.0'}
@@ -1234,6 +1321,11 @@ packages:
     resolution: {integrity: sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==}
     dev: true
 
+  /colors/1.2.5:
+    resolution: {integrity: sha512-erNRLao/Y3Fv54qUa0LBB+//Uf3YwMUmdJinN20yMXm9zdKKqH9wt7R9IIVZ+K7ShzfpLV/Zg8+VyrBJYB4lpg==}
+    engines: {node: '>=0.1.90'}
+    dev: true
+
   /combined-stream/1.0.8:
     resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==}
     engines: {node: '>= 0.8'}
@@ -2593,6 +2685,15 @@ packages:
       universalify: 2.0.0
     dev: true
 
+  /fs-extra/7.0.1:
+    resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==}
+    engines: {node: '>=6 <7 || >=8'}
+    dependencies:
+      graceful-fs: 4.2.10
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+    dev: true
+
   /fs-extra/8.1.0:
     resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
     engines: {node: '>=6 <7 || >=8'}
@@ -3004,6 +3105,11 @@ packages:
     dev: true
     optional: true
 
+  /import-lazy/4.0.0:
+    resolution: {integrity: sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==}
+    engines: {node: '>=8'}
+    dev: true
+
   /imurmurhash/0.1.4:
     resolution: {integrity: sha1-khi5srkoojixPcT7a21XbyMUU+o=}
     engines: {node: '>=0.8.19'}
@@ -3019,7 +3125,7 @@ packages:
     dev: true
 
   /inflight/1.0.6:
-    resolution: {integrity: sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=}
+    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
     dependencies:
       once: 1.4.0
       wrappy: 1.0.2
@@ -3304,6 +3410,10 @@ packages:
     resolution: {integrity: sha512-lmUfT5XcK9KKvt3lLYzn93hc4MGzlUBowExFVgzbSW0ZCrdeyS574dfsyfRhxbg81Wj4gk+RxUiTnj7KBfDA1g==}
     dev: true
 
+  /jju/1.4.0:
+    resolution: {integrity: sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==}
+    dev: true
+
   /js-tokens/4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
     dev: true
@@ -3608,6 +3718,14 @@ packages:
     resolution: {integrity: sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=}
     dev: true
 
+  /lodash.get/4.4.2:
+    resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==}
+    dev: true
+
+  /lodash.isequal/4.5.0:
+    resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==}
+    dev: true
+
   /lodash.ismatch/4.4.0:
     resolution: {integrity: sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc=}
     dev: true
@@ -4815,6 +4933,19 @@ packages:
     deprecated: https://github.com/lydell/resolve-url#deprecated
     dev: true
 
+  /resolve/1.17.0:
+    resolution: {integrity: sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==}
+    dependencies:
+      path-parse: 1.0.7
+    dev: true
+
+  /resolve/1.19.0:
+    resolution: {integrity: sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==}
+    dependencies:
+      is-core-module: 2.9.0
+      path-parse: 1.0.7
+    dev: true
+
   /resolve/1.22.0:
     resolution: {integrity: sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==}
     hasBin: true
@@ -5242,6 +5373,10 @@ packages:
       readable-stream: 3.6.0
     dev: true
 
+  /sprintf-js/1.0.3:
+    resolution: {integrity: sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=}
+    dev: true
+
   /ssri/6.0.2:
     resolution: {integrity: sha512-cepbSq/neFK7xB6A50KHN0xHDotYzq58wWCa5LeWqnPrHG8GzfEjO/4O8kpmcGW+oaxkvhEJCWgbgNk4/ZV93Q==}
     dependencies:
@@ -5413,6 +5548,11 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /strip-json-comments/3.1.1:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+    dev: true
+
   /supports-color/5.5.0:
     resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
     engines: {node: '>=4'}
@@ -5535,6 +5675,10 @@ packages:
       setimmediate: 1.0.5
     dev: true
 
+  /timsort/0.3.0:
+    resolution: {integrity: sha1-QFQRqOfmM5/mTbmiNN4R3DHgK9Q=}
+    dev: true
+
   /tinypool/0.1.3:
     resolution: {integrity: sha512-2IfcQh7CP46XGWGGbdyO4pjcKqsmVqFAPcXfPxcPXmOWt9cYkTP9HcDmGgsfijYoAEc4z9qcpM/BaBz46Y9/CQ==}
     engines: {node: '>=14.0.0'}
@@ -5862,6 +6006,11 @@ packages:
       spdx-expression-parse: 3.0.1
     dev: true
 
+  /validator/13.7.0:
+    resolution: {integrity: sha512-nYXQLCBkpJ8X6ltALua9dRrZDHVYxjJ1wgskNt1lH9fzGjs3tgojGSCBjmEPwkWS1y29+DrizMTW19Pr9uB2nw==}
+    engines: {node: '>= 0.10'}
+    dev: true
+
   /vary/1.1.2:
     resolution: {integrity: sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=}
     engines: {node: '>= 0.8'}
@@ -6234,3 +6383,15 @@ packages:
       normalize-path: 1.0.0
       strip-indent: 2.0.0
     dev: true
+
+  /z-schema/5.0.3:
+    resolution: {integrity: sha512-sGvEcBOTNum68x9jCpCVGPFJ6mWnkD0YxOcddDlJHRx3tKdB2q8pCHExMVZo/AV/6geuVJXG7hljDaWG8+5GDw==}
+    engines: {node: '>=8.0.0'}
+    hasBin: true
+    dependencies:
+      lodash.get: 4.4.2
+      lodash.isequal: 4.5.0
+      validator: 13.7.0
+    optionalDependencies:
+      commander: 2.20.3
+    dev: true
diff --git a/src/compiler/codegen/events.ts b/src/compiler/codegen/events.ts
index 34de474e8d3..ecf24383c70 100644
--- a/src/compiler/codegen/events.ts
+++ b/src/compiler/codegen/events.ts
@@ -1,3 +1,5 @@
+import { ASTElementHandler, ASTElementHandlers } from 'typescript/compiler'
+
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
 const fnInvokeRE = /\([^)]*?\);*$/
 const simplePathRE =
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 0831d621179..9ab39f15e32 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -3,6 +3,16 @@ import baseDirectives from '../directives/index'
 import { camelize, no, extend } from 'shared/util'
 import { baseWarn, pluckModuleFunction } from '../helpers'
 import { emptySlotScopeToken } from '../parser/index'
+import {
+  ASTAttr,
+  ASTDirective,
+  ASTElement,
+  ASTExpression,
+  ASTIfConditions,
+  ASTNode,
+  ASTText,
+  CompilerOptions
+} from 'typescript/compiler'
 
 type TransformFunction = (el: ASTElement, code: string) => string
 type DataGenFunction = (el: ASTElement) => string
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index fe55c6fa281..71031987f7b 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -1,4 +1,9 @@
 import { extend } from 'shared/util'
+import {
+  CompilerOptions,
+  CompiledResult,
+  WarningMessage
+} from 'typescript/compiler'
 import { detectErrors } from './error-detector'
 import { createCompileToFunctionFn } from './to-function'
 
diff --git a/src/compiler/directives/bind.ts b/src/compiler/directives/bind.ts
index 8e646c3c5bc..0f84528d868 100644
--- a/src/compiler/directives/bind.ts
+++ b/src/compiler/directives/bind.ts
@@ -1,3 +1,5 @@
+import { ASTDirective, ASTElement } from 'typescript/compiler'
+
 export default function bind(el: ASTElement, dir: ASTDirective) {
   el.wrapData = (code: string) => {
     return `_b(${code},'${el.tag}',${dir.value},${
diff --git a/src/compiler/directives/model.ts b/src/compiler/directives/model.ts
index c3591027498..cd4afa93d85 100644
--- a/src/compiler/directives/model.ts
+++ b/src/compiler/directives/model.ts
@@ -1,3 +1,5 @@
+import { ASTElement, ASTModifiers } from 'typescript/compiler'
+
 /**
  * Cross-platform code generation for component v-model
  */
diff --git a/src/compiler/directives/on.ts b/src/compiler/directives/on.ts
index e2ddf2c1ca4..6d39ee4caf4 100644
--- a/src/compiler/directives/on.ts
+++ b/src/compiler/directives/on.ts
@@ -1,4 +1,5 @@
 import { warn } from 'core/util/index'
+import { ASTDirective, ASTElement } from 'typescript/compiler'
 
 export default function on(el: ASTElement, dir: ASTDirective) {
   if (__DEV__ && dir.modifiers) {
diff --git a/src/compiler/error-detector.ts b/src/compiler/error-detector.ts
index eb29280be05..d4a087575af 100644
--- a/src/compiler/error-detector.ts
+++ b/src/compiler/error-detector.ts
@@ -1,3 +1,4 @@
+import { ASTElement, ASTNode } from 'typescript/compiler'
 import { dirRE, onRE } from './parser/index'
 
 type Range = { start?: number; end?: number }
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index a5b66b34259..800034ef2de 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -1,4 +1,5 @@
 import { emptyObject } from 'shared/util'
+import { ASTElement, ASTModifiers } from 'typescript/compiler'
 import { parseFilters } from './parser/filter-parser'
 
 type Range = { start?: number; end?: number }
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index 585b5c63091..f9f8432c5a9 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -2,6 +2,7 @@ import { parse } from './parser/index'
 import { optimize } from './optimizer'
 import { generate } from './codegen/index'
 import { createCompilerCreator } from './create-compiler'
+import { CompilerOptions, CompiledResult } from 'typescript/compiler'
 
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
diff --git a/src/compiler/optimizer.ts b/src/compiler/optimizer.ts
index c0b81736535..6c2ccb715c8 100644
--- a/src/compiler/optimizer.ts
+++ b/src/compiler/optimizer.ts
@@ -1,4 +1,5 @@
 import { makeMap, isBuiltInTag, cached, no } from 'shared/util'
+import { ASTElement, CompilerOptions, ASTNode } from 'typescript/compiler'
 
 let isStaticKey
 let isPlatformReservedTag
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index 26d72d4e873..5c785917630 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -19,6 +19,15 @@ import {
   getAndRemoveAttrByRegex
 } from '../helpers'
 
+import {
+  ASTAttr,
+  ASTElement,
+  ASTIfCondition,
+  ASTNode,
+  ASTText,
+  CompilerOptions
+} from 'typescript/compiler'
+
 export const onRE = /^@|^v-on:/
 export const dirRE = process.env.VBIND_PROP_SHORTHAND
   ? /^v-|^@|^:|^\.|^#/
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index a928d6c8d3f..b9ee3103bca 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -2,6 +2,7 @@ import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
 import { generateCodeFrame } from './codeframe'
 import type { Component } from 'typescript/component'
+import { CompilerOptions } from 'typescript/compiler'
 
 type CompiledFunctionResult = {
   render: Function
diff --git a/src/core/config.ts b/src/core/config.ts
index 1819422a7aa..a6ca506af51 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -3,6 +3,9 @@ import { no, noop, identity } from 'shared/util'
 import { LIFECYCLE_HOOKS } from 'shared/constants'
 import type { Component } from 'typescript/component'
 
+/**
+ * @internal
+ */
 export interface Config {
   // user
   optionMergeStrategies: { [key: string]: Function }
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 99241f8fc83..3620a596447 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -9,7 +9,7 @@ import { initProvide, initInjections } from './inject'
 import { extend, mergeOptions, formatComponentName } from '../util/index'
 import type { Component } from 'typescript/component'
 import type { InternalComponentOptions } from 'typescript/options'
-import { EffectScope } from 'v3'
+import { EffectScope } from 'v3/reactivity/effectScope'
 
 let uid = 0
 
diff --git a/src/core/observer/dep.ts b/src/core/observer/dep.ts
index fd5c6a2c1cf..e18729cfde9 100644
--- a/src/core/observer/dep.ts
+++ b/src/core/observer/dep.ts
@@ -1,36 +1,22 @@
 import { remove } from '../util/index'
 import config from '../config'
-import { TrackOpTypes, TriggerOpTypes } from 'v3'
+import { DebuggerOptions, DebuggerEventExtraInfo } from 'v3'
 
 let uid = 0
 
+/**
+ * @internal
+ */
 export interface DepTarget extends DebuggerOptions {
   id: number
   addDep(dep: Dep): void
   update(): void
 }
 
-export interface DebuggerOptions {
-  onTrack?: (event: DebuggerEvent) => void
-  onTrigger?: (event: DebuggerEvent) => void
-}
-
-export type DebuggerEvent = {
-  effect: DepTarget
-} & DebuggerEventExtraInfo
-
-export type DebuggerEventExtraInfo = {
-  target: object
-  type: TrackOpTypes | TriggerOpTypes
-  key?: any
-  newValue?: any
-  oldValue?: any
-  oldTarget?: Map<any, any> | Set<any>
-}
-
 /**
  * A dep is an observable that can have multiple
  * directives subscribing to it.
+ * @internal
  */
 export default class Dep {
   static target?: DepTarget | null
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 2a6f22ff1c3..4936fe17a04 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -12,23 +12,18 @@ import {
 
 import { traverse } from './traverse'
 import { queueWatcher } from './scheduler'
-import Dep, {
-  pushTarget,
-  popTarget,
-  DepTarget,
-  DebuggerEvent,
-  DebuggerOptions
-} from './dep'
+import Dep, { pushTarget, popTarget, DepTarget } from './dep'
+import { DebuggerEvent, DebuggerOptions } from 'v3/debug'
 
 import type { SimpleSet } from '../util/index'
 import type { Component } from 'typescript/component'
-import {
-  activeEffectScope,
-  recordEffectScope
-} from '../../v3/reactivity/effectScope'
+import { activeEffectScope, recordEffectScope } from 'v3/reactivity/effectScope'
 
 let uid = 0
 
+/**
+ * @internal
+ */
 export interface WatcherOptions extends DebuggerOptions {
   deep?: boolean
   user?: boolean
@@ -41,6 +36,7 @@ export interface WatcherOptions extends DebuggerOptions {
  * A watcher parses an expression, collects dependencies,
  * and fires callback when the expression value changes.
  * This is used for both the $watch() api and directives.
+ * @internal
  */
 export default class Watcher implements DepTarget {
   vm?: Component | null
diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index ac3eceaf5f9..e7a5b006408 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -87,6 +87,9 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
 
 export function nextTick(): Promise<void>
 export function nextTick(cb: (...args: any[]) => any, ctx?: object): void
+/**
+ * @internal
+ */
 export function nextTick(cb?: (...args: any[]) => any, ctx?: object) {
   let _resolve
   callbacks.push(() => {
diff --git a/src/core/vdom/vnode.ts b/src/core/vdom/vnode.ts
index 39fa2833315..0c59effab09 100644
--- a/src/core/vdom/vnode.ts
+++ b/src/core/vdom/vnode.ts
@@ -2,6 +2,9 @@ import type { Component } from 'typescript/component'
 import type { ComponentOptions } from 'typescript/options'
 import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
 
+/**
+ * @internal
+ */
 export default class VNode {
   tag?: string
   data: VNodeData | undefined
diff --git a/src/platforms/web/compiler/directives/html.ts b/src/platforms/web/compiler/directives/html.ts
index af6dd62dc33..54cb6216c8d 100644
--- a/src/platforms/web/compiler/directives/html.ts
+++ b/src/platforms/web/compiler/directives/html.ts
@@ -1,4 +1,5 @@
 import { addProp } from 'compiler/helpers'
+import { ASTDirective, ASTElement } from 'typescript/compiler'
 
 export default function html(el: ASTElement, dir: ASTDirective) {
   if (dir.value) {
diff --git a/src/platforms/web/compiler/directives/model.ts b/src/platforms/web/compiler/directives/model.ts
index 2db1b483a78..65cc030c388 100644
--- a/src/platforms/web/compiler/directives/model.ts
+++ b/src/platforms/web/compiler/directives/model.ts
@@ -1,6 +1,7 @@
 import config from 'core/config'
 import { addHandler, addProp, getBindingAttr } from 'compiler/helpers'
 import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
+import { ASTDirective, ASTElement, ASTModifiers } from 'typescript/compiler'
 
 let warn
 
diff --git a/src/platforms/web/compiler/directives/text.ts b/src/platforms/web/compiler/directives/text.ts
index 9cb39d1180c..2c80adbf7b7 100644
--- a/src/platforms/web/compiler/directives/text.ts
+++ b/src/platforms/web/compiler/directives/text.ts
@@ -1,4 +1,5 @@
 import { addProp } from 'compiler/helpers'
+import { ASTDirective, ASTElement } from 'typescript/compiler'
 
 export default function text(el: ASTElement, dir: ASTDirective) {
   if (dir.value) {
diff --git a/src/platforms/web/compiler/modules/class.ts b/src/platforms/web/compiler/modules/class.ts
index f4c5b7bd27d..e564fe06ed6 100644
--- a/src/platforms/web/compiler/modules/class.ts
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -1,5 +1,6 @@
 import { parseText } from 'compiler/parser/text-parser'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'typescript/compiler'
 
 function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
diff --git a/src/platforms/web/compiler/modules/model.ts b/src/platforms/web/compiler/modules/model.ts
index 63c6f83fcfd..5e93cf1af29 100644
--- a/src/platforms/web/compiler/modules/model.ts
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -16,6 +16,7 @@ import {
   addIfCondition,
   createASTElement
 } from 'compiler/parser/index'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'typescript/compiler'
 
 function preTransformNode(el: ASTElement, options: CompilerOptions) {
   if (el.tag === 'input') {
diff --git a/src/platforms/web/compiler/modules/style.ts b/src/platforms/web/compiler/modules/style.ts
index d7eeeb0f4d6..aed51db670a 100644
--- a/src/platforms/web/compiler/modules/style.ts
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -1,6 +1,7 @@
 import { parseText } from 'compiler/parser/text-parser'
 import { parseStyleText } from 'web/util/style'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'typescript/compiler'
 
 function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
diff --git a/src/platforms/web/compiler/options.ts b/src/platforms/web/compiler/options.ts
index 86653884800..12a96bb4453 100644
--- a/src/platforms/web/compiler/options.ts
+++ b/src/platforms/web/compiler/options.ts
@@ -9,6 +9,7 @@ import modules from './modules/index'
 import directives from './directives/index'
 import { genStaticKeys } from 'shared/util'
 import { isUnaryTag, canBeLeftOpenTag } from './util'
+import { CompilerOptions } from 'typescript/compiler'
 
 export const baseOptions: CompilerOptions = {
   expectHTML: true,
diff --git a/src/server/optimizing-compiler/codegen.ts b/src/server/optimizing-compiler/codegen.ts
index 670a5f6d583..2ae89b0e9da 100644
--- a/src/server/optimizing-compiler/codegen.ts
+++ b/src/server/optimizing-compiler/codegen.ts
@@ -23,6 +23,7 @@ import {
 import { escape } from 'web/server/util'
 import { optimizability } from './optimizer'
 import type { CodegenResult } from 'compiler/codegen/index'
+import { ASTElement, ASTNode, CompilerOptions } from 'typescript/compiler'
 
 export type StringSegment = {
   type: number
diff --git a/src/server/optimizing-compiler/index.ts b/src/server/optimizing-compiler/index.ts
index 25b37e419d9..758652145c3 100644
--- a/src/server/optimizing-compiler/index.ts
+++ b/src/server/optimizing-compiler/index.ts
@@ -2,6 +2,7 @@ import { parse } from 'compiler/parser/index'
 import { generate } from './codegen'
 import { optimize } from './optimizer'
 import { createCompilerCreator } from 'compiler/create-compiler'
+import { CompiledResult, CompilerOptions } from 'typescript/compiler'
 
 export const createCompiler = createCompilerCreator(function baseCompile(
   template: string,
diff --git a/src/server/optimizing-compiler/modules.ts b/src/server/optimizing-compiler/modules.ts
index 9a52768e524..630e8300b76 100644
--- a/src/server/optimizing-compiler/modules.ts
+++ b/src/server/optimizing-compiler/modules.ts
@@ -10,6 +10,7 @@ import { isBooleanAttr, isEnumeratedAttr } from 'web/util/attrs'
 
 import type { StringSegment } from './codegen'
 import type { CodegenState } from 'compiler/codegen/index'
+import { ASTAttr, ASTElement } from 'typescript/compiler'
 
 const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
 
diff --git a/src/server/optimizing-compiler/optimizer.ts b/src/server/optimizing-compiler/optimizer.ts
index 08afa3d90ab..d9d935ef04c 100644
--- a/src/server/optimizing-compiler/optimizer.ts
+++ b/src/server/optimizing-compiler/optimizer.ts
@@ -9,6 +9,7 @@
  */
 
 import { no, makeMap, isBuiltInTag } from 'shared/util'
+import { ASTElement, ASTNode, CompilerOptions } from 'typescript/compiler'
 
 // optimizability constants
 export const optimizability = {
diff --git a/src/sfc/parser.ts b/src/sfc/parser.ts
index 9de84e21056..3202c55da31 100644
--- a/src/sfc/parser.ts
+++ b/src/sfc/parser.ts
@@ -1,6 +1,12 @@
 import deindent from 'de-indent'
 import { parseHTML } from 'compiler/parser/html-parser'
 import { makeMap } from 'shared/util'
+import {
+  ASTAttr,
+  SFCBlock,
+  SFCDescriptor,
+  WarningMessage
+} from 'typescript/compiler'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
diff --git a/src/shared/util.ts b/src/shared/util.ts
index 4923995423c..a171a743c14 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -276,7 +276,9 @@ export const identity = (_: any) => _
 /**
  * Generate a string containing static keys from compiler modules.
  */
-export function genStaticKeys(modules: Array<ModuleOptions>): string {
+export function genStaticKeys(
+  modules: Array<{ staticKeys?: string[] } /* ModuleOptions */>
+): string {
   return modules
     .reduce((keys, m) => {
       return keys.concat(m.staticKeys || [])
diff --git a/src/v3/apiLifecycle.ts b/src/v3/apiLifecycle.ts
index cd72fb8fabc..0bf31e3bd73 100644
--- a/src/v3/apiLifecycle.ts
+++ b/src/v3/apiLifecycle.ts
@@ -1,12 +1,12 @@
-import { DebuggerEvent } from '.'
-import { Component } from '../../typescript/component'
+import { DebuggerEvent } from './debug'
+import { Component } from 'typescript/component'
 import { mergeLifecycleHook, warn } from '../core/util'
 import { currentInstance } from './currentInstance'
 
 function createLifeCycle<T extends (...args: any[]) => any = () => void>(
   hookName: string
 ) {
-  return (fn: T, target: Component | null = currentInstance) => {
+  return (fn: T, target: any = currentInstance) => {
     if (!target) {
       __DEV__ &&
         warn(
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index c25203112f3..49b71f60a71 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -138,10 +138,16 @@ export function syncSetupSlots(to: any, from: any) {
   }
 }
 
+/**
+ * @internal use manual type def
+ */
 export function useSlots(): SetupContext['slots'] {
   return getContext().slots
 }
 
+/**
+ * @internal use manual type def
+ */
 export function useAttrs(): SetupContext['attrs'] {
   return getContext().attrs
 }
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index c5487976b60..67aafc5fd12 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -15,7 +15,7 @@ import { currentInstance } from './currentInstance'
 import { traverse } from 'core/observer/traverse'
 import Watcher from '../core/observer/watcher'
 import { queueWatcher } from '../core/observer/scheduler'
-import { DebuggerOptions } from '../core/observer/dep'
+import { DebuggerOptions } from './debug'
 
 const WATCHER = `watcher`
 const WATCHER_CB = `${WATCHER} callback`
diff --git a/src/v3/currentInstance.ts b/src/v3/currentInstance.ts
index 43a89d85704..0951c0c4362 100644
--- a/src/v3/currentInstance.ts
+++ b/src/v3/currentInstance.ts
@@ -6,7 +6,7 @@ export let currentInstance: Component | null = null
  * This is exposed for compatibility with v3 (e.g. some functions in VueUse
  * relies on it). Do not use this internally, just use `currentInstance`.
  *
- * @private this function needs manual type declaration because it relies
+ * @internal this function needs manual type declaration because it relies
  * on previously manually authored types from Vue 2
  */
 export function getCurrentInstance(): { proxy: Component } | null {
@@ -14,7 +14,7 @@ export function getCurrentInstance(): { proxy: Component } | null {
 }
 
 /**
- * @private
+ * @internal
  */
 export function setCurrentInstance(vm: Component | null = null) {
   if (!vm) currentInstance && currentInstance._scope.off()
diff --git a/src/v3/debug.ts b/src/v3/debug.ts
new file mode 100644
index 00000000000..ff6890b9c0c
--- /dev/null
+++ b/src/v3/debug.ts
@@ -0,0 +1,21 @@
+import { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
+
+export interface DebuggerOptions {
+  onTrack?: (event: DebuggerEvent) => void
+  onTrigger?: (event: DebuggerEvent) => void
+}
+
+export type DebuggerEvent = {
+  /**
+   * @internal
+   */
+  effect: any
+} & DebuggerEventExtraInfo
+
+export type DebuggerEventExtraInfo = {
+  target: object
+  type: TrackOpTypes | TriggerOpTypes
+  key?: any
+  newValue?: any
+  oldValue?: any
+}
diff --git a/src/v3/h.ts b/src/v3/h.ts
index 3febeb789dc..292446cad3d 100644
--- a/src/v3/h.ts
+++ b/src/v3/h.ts
@@ -3,7 +3,7 @@ import { currentInstance } from './currentInstance'
 import { warn } from 'core/util'
 
 /**
- * @private this function needs manual public type declaration because it relies
+ * @internal this function needs manual public type declaration because it relies
  * on previously manually authored types from Vue 2
  */
 export function h(type: any, props?: any, children?: any) {
diff --git a/src/v3/index.ts b/src/v3/index.ts
index ad0f991e949..4f3ce51dfa7 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -62,11 +62,8 @@ export {
   getCurrentScope
 } from './reactivity/effectScope'
 
-export {
-  DebuggerOptions,
-  DebuggerEvent,
-  DebuggerEventExtraInfo
-} from 'core/observer/dep'
+export { DebuggerOptions, DebuggerEvent, DebuggerEventExtraInfo } from './debug'
+
 export { TrackOpTypes, TriggerOpTypes } from './reactivity/operations'
 
 export { provide, inject, InjectionKey } from './apiInject'
@@ -74,6 +71,6 @@ export { provide, inject, InjectionKey } from './apiInject'
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
 export { useSlots, useAttrs } from './apiSetup'
-export { nextTick } from 'core/util'
+export { nextTick } from 'core/util/next-tick'
 
 export * from './apiLifecycle'
diff --git a/src/v3/reactivity/computed.ts b/src/v3/reactivity/computed.ts
index 9e9368b858d..7a38c3cfc0a 100644
--- a/src/v3/reactivity/computed.ts
+++ b/src/v3/reactivity/computed.ts
@@ -1,10 +1,11 @@
 import { isServerRendering, noop, warn, def, isFunction } from 'core/util'
 import { Ref, RefFlag } from './ref'
 import Watcher from 'core/observer/watcher'
-import Dep, { DebuggerOptions } from 'core/observer/dep'
+import Dep from 'core/observer/dep'
 import { currentInstance } from '../currentInstance'
 import { ReactiveFlags } from './reactive'
 import { TrackOpTypes } from './operations'
+import { DebuggerOptions } from '../debug'
 
 declare const ComputedRefSymbol: unique symbol
 
@@ -14,7 +15,7 @@ export interface ComputedRef<T = any> extends WritableComputedRef<T> {
 }
 
 export interface WritableComputedRef<T> extends Ref<T> {
-  readonly effect: Watcher
+  readonly effect: any /* Watcher */
 }
 
 export type ComputedGetter<T> = (...args: any[]) => T
diff --git a/src/v3/reactivity/effect.ts b/src/v3/reactivity/effect.ts
index 607af2c0f97..11f9534a31b 100644
--- a/src/v3/reactivity/effect.ts
+++ b/src/v3/reactivity/effect.ts
@@ -5,7 +5,7 @@ import { currentInstance } from '../currentInstance'
 // export type EffectScheduler = (...args: any[]) => any
 
 /**
- * @private since we are not exposing this in Vue 2, it's used only for
+ * @internal since we are not exposing this in Vue 2, it's used only for
  * internal testing.
  */
 export function effect(fn: () => any, scheduler?: (cb: any) => void) {
diff --git a/src/v3/reactivity/effectScope.ts b/src/v3/reactivity/effectScope.ts
index 7324d757b99..bc15380eb4a 100644
--- a/src/v3/reactivity/effectScope.ts
+++ b/src/v3/reactivity/effectScope.ts
@@ -106,6 +106,9 @@ export function effectScope(detached?: boolean) {
   return new EffectScope(detached)
 }
 
+/**
+ * @internal
+ */
 export function recordEffectScope(
   effect: Watcher,
   scope: EffectScope | undefined = activeEffectScope
diff --git a/src/v3/reactivity/reactive.ts b/src/v3/reactivity/reactive.ts
index b1bf54c69c2..d750dd2c713 100644
--- a/src/v3/reactivity/reactive.ts
+++ b/src/v3/reactivity/reactive.ts
@@ -113,7 +113,7 @@ export function markRaw<T extends object>(
 }
 
 /**
- * @private
+ * @internal
  */
 export function isCollectionType(value: unknown): boolean {
   const type = toRawType(value)
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index 21453c40f2d..04a4d8a1ea7 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -12,6 +12,9 @@ import { TrackOpTypes, TriggerOpTypes } from './operations'
 declare const RefSymbol: unique symbol
 export declare const RawSymbol: unique symbol
 
+/**
+ * @internal
+ */
 export const RefFlag = `__v_isRef`
 
 export interface Ref<T = any> {
@@ -23,11 +26,11 @@ export interface Ref<T = any> {
    */
   [RefSymbol]: true
   /**
-   * @private
+   * @internal
    */
   dep?: Dep
   /**
-   * @private
+   * @internal
    */
   [RefFlag]: true
 }
@@ -203,7 +206,9 @@ export function toRef<T extends object, K extends keyof T>(
  * augmentations in its generated d.ts, so we have to manually append them
  * to the final generated d.ts in our build process.
  */
-export interface RefUnwrapBailTypes {}
+export interface RefUnwrapBailTypes {
+  runtimeDOMBailTypes: Node | Window
+}
 
 export type ShallowUnwrapRef<T> = {
   [K in keyof T]: T[K] extends Ref<infer V>
diff --git a/types/index.d.ts b/types/index.d.ts
index a792a1b031b..eea3c51c572 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -32,4 +32,5 @@ export {
   VNodeDirective
 } from './vnode'
 
-export { h, getCurrentInstance } from './v3'
+export * from './v3'
+export * from './v3-generated'
diff --git a/types/test/utils.ts b/types/test/utils.ts
new file mode 100644
index 00000000000..48c4fa882df
--- /dev/null
+++ b/types/test/utils.ts
@@ -0,0 +1,14 @@
+export declare function describe(_name: string, _fn: () => void): void
+export declare function test(_name: string, _fn: () => any): void
+
+export declare function expectType<T>(value: T): void
+export declare function expectError<T>(value: T): void
+export declare function expectAssignable<T, T2 extends T = T>(value: T2): void
+
+export type IsUnion<T, U extends T = T> = (
+  T extends any ? (U extends T ? false : true) : never
+) extends false
+  ? false
+  : true
+
+export type IsAny<T> = 0 extends 1 & T ? true : false
diff --git a/types/test/v3/inject-test.ts b/types/test/v3/inject-test.ts
new file mode 100644
index 00000000000..dd294be724d
--- /dev/null
+++ b/types/test/v3/inject-test.ts
@@ -0,0 +1,16 @@
+import { InjectionKey, provide, inject } from '../../index'
+import { expectType } from '../utils'
+
+const key: InjectionKey<number> = Symbol()
+
+provide(key, 1)
+// @ts-expect-error
+provide(key, 'foo')
+
+expectType<number | undefined>(inject(key))
+expectType<number>(inject(key, 1))
+expectType<number>(inject(key, () => 1, true /* treatDefaultAsFactory */))
+
+expectType<() => number>(inject('foo', () => 1))
+expectType<() => number>(inject('foo', () => 1, false))
+expectType<number>(inject('foo', () => 1, true))
diff --git a/types/test/v3/reactivity-test.ts b/types/test/v3/reactivity-test.ts
new file mode 100644
index 00000000000..c316a779641
--- /dev/null
+++ b/types/test/v3/reactivity-test.ts
@@ -0,0 +1,373 @@
+import {
+  Ref,
+  ref,
+  shallowRef,
+  isRef,
+  unref,
+  reactive,
+  toRef,
+  toRefs,
+  ToRefs,
+  shallowReactive,
+  readonly,
+  markRaw,
+  shallowReadonly
+} from '../../index'
+import { describe, expectType } from '../utils'
+
+function plainType(arg: number | Ref<number>) {
+  // ref coercing
+  const coerced = ref(arg)
+  expectType<Ref<number>>(coerced)
+
+  // isRef as type guard
+  if (isRef(arg)) {
+    expectType<Ref<number>>(arg)
+  }
+
+  // ref unwrapping
+  expectType<number>(unref(arg))
+
+  // ref inner type should be unwrapped
+  const nestedRef = ref({
+    foo: ref(1)
+  })
+  expectType<{ foo: number }>(nestedRef.value)
+
+  // ref boolean
+  const falseRef = ref(false)
+  expectType<Ref<boolean>>(falseRef)
+  expectType<boolean>(falseRef.value)
+
+  // ref true
+  const trueRef = ref<true>(true)
+  expectType<Ref<true>>(trueRef)
+  expectType<true>(trueRef.value)
+
+  // tuple
+  expectType<[number, string]>(unref(ref([1, '1'])))
+
+  interface IteratorFoo {
+    [Symbol.iterator]: any
+  }
+
+  // with symbol
+  expectType<Ref<IteratorFoo | null | undefined>>(
+    ref<IteratorFoo | null | undefined>()
+  )
+
+  // should not unwrap ref inside arrays
+  const arr = ref([1, new Map<string, any>(), ref('1')]).value
+  const value = arr[0]
+  if (isRef(value)) {
+    expectType<Ref>(value)
+  } else if (typeof value === 'number') {
+    expectType<number>(value)
+  } else {
+    // should narrow down to Map type
+    // and not contain any Ref type
+    expectType<Map<string, any>>(value)
+  }
+
+  // should still unwrap in objects nested in arrays
+  const arr2 = ref([{ a: ref(1) }]).value
+  expectType<number>(arr2[0].a)
+}
+
+plainType(1)
+
+function bailType(arg: HTMLElement | Ref<HTMLElement>) {
+  // ref coercing
+  const coerced = ref(arg)
+  expectType<Ref<HTMLElement>>(coerced)
+
+  // isRef as type guard
+  if (isRef(arg)) {
+    expectType<Ref<HTMLElement>>(arg)
+  }
+
+  // ref unwrapping
+  expectType<HTMLElement>(unref(arg))
+
+  // ref inner type should be unwrapped
+  // eslint-disable-next-line no-restricted-globals
+  const nestedRef = ref({ foo: ref(document.createElement('DIV')) })
+
+  expectType<Ref<{ foo: HTMLElement }>>(nestedRef)
+  expectType<{ foo: HTMLElement }>(nestedRef.value)
+}
+// eslint-disable-next-line no-restricted-globals
+const el = document.createElement('DIV')
+bailType(el)
+
+function withSymbol() {
+  const customSymbol = Symbol()
+  const obj = {
+    [Symbol.asyncIterator]: ref(1),
+    [Symbol.hasInstance]: { a: ref('a') },
+    [Symbol.isConcatSpreadable]: { b: ref(true) },
+    [Symbol.iterator]: [ref(1)],
+    [Symbol.match]: new Set<Ref<number>>(),
+    [Symbol.matchAll]: new Map<number, Ref<string>>(),
+    [Symbol.replace]: { arr: [ref('a')] },
+    [Symbol.search]: { set: new Set<Ref<number>>() },
+    [Symbol.species]: { map: new Map<number, Ref<string>>() },
+    [Symbol.split]: new WeakSet<Ref<boolean>>(),
+    [Symbol.toPrimitive]: new WeakMap<Ref<boolean>, string>(),
+    [Symbol.toStringTag]: { weakSet: new WeakSet<Ref<boolean>>() },
+    [Symbol.unscopables]: { weakMap: new WeakMap<Ref<boolean>, string>() },
+    [customSymbol]: { arr: [ref(1)] }
+  }
+
+  const objRef = ref(obj)
+
+  expectType<Ref<number>>(objRef.value[Symbol.asyncIterator])
+  expectType<{ a: Ref<string> }>(objRef.value[Symbol.hasInstance])
+  expectType<{ b: Ref<boolean> }>(objRef.value[Symbol.isConcatSpreadable])
+  expectType<Ref<number>[]>(objRef.value[Symbol.iterator])
+  expectType<Set<Ref<number>>>(objRef.value[Symbol.match])
+  expectType<Map<number, Ref<string>>>(objRef.value[Symbol.matchAll])
+  expectType<{ arr: Ref<string>[] }>(objRef.value[Symbol.replace])
+  expectType<{ set: Set<Ref<number>> }>(objRef.value[Symbol.search])
+  expectType<{ map: Map<number, Ref<string>> }>(objRef.value[Symbol.species])
+  expectType<WeakSet<Ref<boolean>>>(objRef.value[Symbol.split])
+  expectType<WeakMap<Ref<boolean>, string>>(objRef.value[Symbol.toPrimitive])
+  expectType<{ weakSet: WeakSet<Ref<boolean>> }>(
+    objRef.value[Symbol.toStringTag]
+  )
+  expectType<{ weakMap: WeakMap<Ref<boolean>, string> }>(
+    objRef.value[Symbol.unscopables]
+  )
+  expectType<{ arr: Ref<number>[] }>(objRef.value[customSymbol])
+}
+
+withSymbol()
+
+const state = reactive({
+  foo: {
+    value: 1,
+    label: 'bar'
+  }
+})
+
+expectType<string>(state.foo.label)
+
+// shallowRef
+type Status = 'initial' | 'ready' | 'invalidating'
+const shallowStatus = shallowRef<Status>('initial')
+if (shallowStatus.value === 'initial') {
+  expectType<Ref<Status>>(shallowStatus)
+  expectType<Status>(shallowStatus.value)
+  shallowStatus.value = 'invalidating'
+}
+
+const refStatus = ref<Status>('initial')
+if (refStatus.value === 'initial') {
+  expectType<Ref<Status>>(shallowStatus)
+  expectType<Status>(shallowStatus.value)
+  refStatus.value = 'invalidating'
+}
+
+// proxyRefs: should return `reactive` directly
+// const r1 = reactive({
+//   k: 'v'
+// })
+// const p1 = proxyRefs(r1)
+// expectType<typeof r1>(p1)
+
+// // proxyRefs: `ShallowUnwrapRef`
+// const r2 = {
+//   a: ref(1),
+//   obj: {
+//     k: ref('foo')
+//   }
+// }
+// const p2 = proxyRefs(r2)
+// expectType<number>(p2.a)
+// expectType<Ref<string>>(p2.obj.k)
+
+// toRef and toRefs
+{
+  const obj: {
+    a: number
+    b: Ref<number>
+    c: number | string
+  } = {
+    a: 1,
+    b: ref(1),
+    c: 1
+  }
+
+  // toRef
+  expectType<Ref<number>>(toRef(obj, 'a'))
+  expectType<Ref<number>>(toRef(obj, 'b'))
+  // Should not distribute Refs over union
+  expectType<Ref<number | string>>(toRef(obj, 'c'))
+
+  // toRefs
+  expectType<{
+    a: Ref<number>
+    b: Ref<number>
+    // Should not distribute Refs over union
+    c: Ref<number | string>
+  }>(toRefs(obj))
+
+  // Both should not do any unwrapping
+  const someReactive = shallowReactive({
+    a: {
+      b: ref(42)
+    }
+  })
+
+  const toRefResult = toRef(someReactive, 'a')
+  const toRefsResult = toRefs(someReactive)
+
+  expectType<Ref<number>>(toRefResult.value.b)
+  expectType<Ref<number>>(toRefsResult.a.value.b)
+
+  // #5188
+  const props = { foo: 1 } as { foo: any }
+  const { foo } = toRefs(props)
+  expectType<Ref<any>>(foo)
+}
+
+// toRef default value
+{
+  const obj: { x?: number } = {}
+  const x = toRef(obj, 'x', 1)
+  expectType<Ref<number>>(x)
+}
+
+// readonly() + ref()
+expectType<Readonly<Ref<number>>>(readonly(ref(1)))
+
+// #2687
+interface AppData {
+  state: 'state1' | 'state2' | 'state3'
+}
+
+const data: ToRefs<AppData> = toRefs(
+  reactive({
+    state: 'state1'
+  })
+)
+
+switch (data.state.value) {
+  case 'state1':
+    data.state.value = 'state2'
+    break
+  case 'state2':
+    data.state.value = 'state3'
+    break
+  case 'state3':
+    data.state.value = 'state1'
+    break
+}
+
+// #3954
+function testUnrefGenerics<T>(p: T | Ref<T>) {
+  expectType<T>(unref(p))
+}
+
+testUnrefGenerics(1)
+
+// #4771
+describe('shallow reactive in reactive', () => {
+  const baz = reactive({
+    foo: shallowReactive({
+      a: {
+        b: ref(42)
+      }
+    })
+  })
+
+  const foo = toRef(baz, 'foo')
+
+  expectType<Ref<number>>(foo.value.a.b)
+  expectType<number>(foo.value.a.b.value)
+})
+
+describe('shallow ref in reactive', () => {
+  const x = reactive({
+    foo: shallowRef({
+      bar: {
+        baz: ref(123),
+        qux: reactive({
+          z: ref(123)
+        })
+      }
+    })
+  })
+
+  expectType<Ref<number>>(x.foo.bar.baz)
+  expectType<number>(x.foo.bar.qux.z)
+})
+
+describe('ref in shallow ref', () => {
+  const x = shallowRef({
+    a: ref(123)
+  })
+
+  expectType<Ref<number>>(x.value.a)
+})
+
+describe('reactive in shallow ref', () => {
+  const x = shallowRef({
+    a: reactive({
+      b: ref(0)
+    })
+  })
+
+  expectType<number>(x.value.a.b)
+})
+
+describe('should support DeepReadonly', () => {
+  const r = readonly({ obj: { k: 'v' } })
+  // @ts-expect-error
+  expectError((r.obj = {}))
+  // @ts-expect-error
+  expectError((r.obj.k = 'x'))
+})
+
+// #4180
+describe('readonly ref', () => {
+  const r = readonly(ref({ count: 1 }))
+  expectType<Ref>(r)
+})
+
+describe('should support markRaw', () => {
+  class Test<T> {
+    item = {} as Ref<T>
+  }
+  const test = new Test<number>()
+  const plain = {
+    ref: ref(1)
+  }
+
+  const r = reactive({
+    class: {
+      raw: markRaw(test),
+      reactive: test
+    },
+    plain: {
+      raw: markRaw(plain),
+      reactive: plain
+    }
+  })
+
+  expectType<Test<number>>(r.class.raw)
+  // @ts-expect-error it should unwrap
+  expectType<Test<number>>(r.class.reactive)
+
+  expectType<Ref<number>>(r.plain.raw.ref)
+  // @ts-expect-error it should unwrap
+  expectType<Ref<number>>(r.plain.reactive.ref)
+})
+
+describe('shallowReadonly ref unwrap', () => {
+  const r = shallowReadonly({ count: { n: ref(1) } })
+  // @ts-expect-error
+  r.count = 2
+  expectType<Ref>(r.count.n)
+  r.count.n.value = 123
+})
diff --git a/types/test/setup-test.ts b/types/test/v3/setup-test.ts
similarity index 85%
rename from types/test/setup-test.ts
rename to types/test/v3/setup-test.ts
index bc63a927c62..d09fdf278c2 100644
--- a/types/test/setup-test.ts
+++ b/types/test/v3/setup-test.ts
@@ -1,4 +1,4 @@
-import Vue from '../index'
+import Vue from '../../index'
 
 // object props
 Vue.extend({
@@ -28,8 +28,5 @@ Vue.extend({
     }
     ctx.emit('foo')
     ctx.slots.default && ctx.slots.default()
-    ctx.expose({
-      foo: 123
-    })
   }
 })
diff --git a/types/test/v3/watch-test.ts b/types/test/v3/watch-test.ts
new file mode 100644
index 00000000000..388fdc2ad9e
--- /dev/null
+++ b/types/test/v3/watch-test.ts
@@ -0,0 +1,78 @@
+import { ref, computed, watch } from '../../index'
+import { expectType } from '../utils'
+
+const source = ref('foo')
+const source2 = computed(() => source.value)
+const source3 = () => 1
+
+// lazy watcher will have consistent types for oldValue.
+watch(source, (value, oldValue) => {
+  expectType<string>(value)
+  expectType<string>(oldValue)
+})
+
+watch([source, source2, source3], (values, oldValues) => {
+  expectType<[string, string, number]>(values)
+  expectType<[string, string, number]>(oldValues)
+})
+
+// const array
+watch([source, source2, source3] as const, (values, oldValues) => {
+  expectType<Readonly<[string, string, number]>>(values)
+  expectType<Readonly<[string, string, number]>>(oldValues)
+})
+
+// immediate watcher's oldValue will be undefined on first run.
+watch(
+  source,
+  (value, oldValue) => {
+    expectType<string>(value)
+    expectType<string | undefined>(oldValue)
+  },
+  { immediate: true }
+)
+
+watch(
+  [source, source2, source3],
+  (values, oldValues) => {
+    expectType<[string, string, number]>(values)
+    expectType<[string | undefined, string | undefined, number | undefined]>(
+      oldValues
+    )
+  },
+  { immediate: true }
+)
+
+// const array
+watch(
+  [source, source2, source3] as const,
+  (values, oldValues) => {
+    expectType<Readonly<[string, string, number]>>(values)
+    expectType<
+      Readonly<[string | undefined, string | undefined, number | undefined]>
+    >(oldValues)
+  },
+  { immediate: true }
+)
+
+// should provide correct ref.value inner type to callbacks
+const nestedRefSource = ref({
+  foo: ref(1)
+})
+
+watch(nestedRefSource, (v, ov) => {
+  expectType<{ foo: number }>(v)
+  expectType<{ foo: number }>(ov)
+})
+
+const someRef = ref({ test: 'test' })
+const otherRef = ref({ a: 'b' })
+watch([someRef, otherRef], values => {
+  const value1 = values[0]
+  // no type error
+  console.log(value1.test)
+
+  const value2 = values[1]
+  // no type error
+  console.log(value2.a)
+})
diff --git a/types/tsconfig.json b/types/tsconfig.json
index ffccdfc70d3..55df2897175 100644
--- a/types/tsconfig.json
+++ b/types/tsconfig.json
@@ -1,10 +1,10 @@
 {
   "compilerOptions": {
-    "target": "es5",
+    "target": "esnext",
     "experimentalDecorators": true,
-    "lib": ["dom", "es2015"],
+    "lib": ["dom", "esnext"],
     "types": ["node"],
-    "module": "commonjs",
+    "module": "esnext",
     "strict": true,
     "noEmit": true,
     "baseUrl": ".",
diff --git a/types/v3.d.ts b/types/v3.d.ts
index 53367f8d56f..464edd7f45a 100644
--- a/types/v3.d.ts
+++ b/types/v3.d.ts
@@ -10,3 +10,7 @@ export interface SetupContext {
 export function getCurrentInstance(): { proxy: Vue } | null
 
 export const h: CreateElement
+
+export function useAttrs(): SetupContext['attrs']
+
+export function useSlots(): SetupContext['slots']
diff --git a/typescript/compiler.d.ts b/typescript/compiler.ts
similarity index 89%
rename from typescript/compiler.d.ts
rename to typescript/compiler.ts
index 5dec6bc3506..fdb0aced8f3 100644
--- a/typescript/compiler.d.ts
+++ b/typescript/compiler.ts
@@ -1,4 +1,4 @@
-declare type CompilerOptions = {
+export type CompilerOptions = {
   warn?: Function // allow customizing warning in different environments; e.g. node
   modules?: Array<ModuleOptions> // platform specific modules; e.g. style; class
   directives?: { [key: string]: Function } // platform specific directives
@@ -29,13 +29,13 @@ declare type CompilerOptions = {
   scopeId?: string
 }
 
-declare type WarningMessage = {
+export type WarningMessage = {
   msg: string
   start?: number
   end?: number
 }
 
-declare type CompiledResult = {
+export type CompiledResult = {
   ast: ASTElement | null
   render: string
   staticRenderFns: Array<string>
@@ -44,7 +44,7 @@ declare type CompiledResult = {
   tips?: Array<string | WarningMessage>
 }
 
-declare type ModuleOptions = {
+export type ModuleOptions = {
   // transform an AST node before any attributes are processed
   // returning an ASTElement from pre/transforms replaces the element
   preTransformNode: (el: ASTElement) => ASTElement | null
@@ -58,11 +58,11 @@ declare type ModuleOptions = {
   staticKeys?: Array<string> // AST properties to be considered static
 }
 
-declare type ASTModifiers = { [key: string]: boolean }
-declare type ASTIfCondition = { exp: string | null; block: ASTElement }
-declare type ASTIfConditions = Array<ASTIfCondition>
+export type ASTModifiers = { [key: string]: boolean }
+export type ASTIfCondition = { exp: string | null; block: ASTElement }
+export type ASTIfConditions = Array<ASTIfCondition>
 
-declare type ASTAttr = {
+export type ASTAttr = {
   name: string
   value: any
   dynamic?: boolean
@@ -70,7 +70,7 @@ declare type ASTAttr = {
   end?: number
 }
 
-declare type ASTElementHandler = {
+export type ASTElementHandler = {
   value: string
   params?: Array<any>
   modifiers: ASTModifiers | null
@@ -79,11 +79,11 @@ declare type ASTElementHandler = {
   end?: number
 }
 
-declare type ASTElementHandlers = {
+export type ASTElementHandlers = {
   [key: string]: ASTElementHandler | Array<ASTElementHandler>
 }
 
-declare type ASTDirective = {
+export type ASTDirective = {
   name: string
   rawName: string
   value: string
@@ -94,9 +94,9 @@ declare type ASTDirective = {
   end?: number
 }
 
-declare type ASTNode = ASTElement | ASTText | ASTExpression
+export type ASTNode = ASTElement | ASTText | ASTExpression
 
-declare type ASTElement = {
+export type ASTElement = {
   type: 1
   tag: string
   attrsList: Array<ASTAttr>
@@ -177,7 +177,7 @@ declare type ASTElement = {
   ssrOptimizability?: number
 }
 
-declare type ASTExpression = {
+export type ASTExpression = {
   type: 2
   expression: string
   text: string
@@ -189,7 +189,7 @@ declare type ASTExpression = {
   end?: number
 }
 
-declare type ASTText = {
+export type ASTText = {
   type: 3
   text: string
   static?: boolean
@@ -203,7 +203,7 @@ declare type ASTText = {
 // SFC-parser related declarations
 
 // an object format describing a single-file component
-declare type SFCDescriptor = {
+export type SFCDescriptor = {
   template: SFCBlock | null
   script: SFCBlock | null
   styles: Array<SFCBlock>
@@ -211,7 +211,7 @@ declare type SFCDescriptor = {
   errors: Array<string | WarningMessage>
 }
 
-declare type SFCBlock = {
+export type SFCBlock = {
   type: string
   content: string
   attrs: { [attribute: string]: string }
diff --git a/typescript/component.d.ts b/typescript/component.ts
similarity index 98%
rename from typescript/component.d.ts
rename to typescript/component.ts
index 91847ff84ee..9de07878110 100644
--- a/typescript/component.d.ts
+++ b/typescript/component.ts
@@ -3,10 +3,13 @@ import type Watcher from '../src/core/observer/watcher'
 import { ComponentOptions, SetupContext } from './options'
 import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
 import { GlobalAPI } from './global-api'
-import { EffectScope } from 'v3'
+import { EffectScope } from 'v3/reactivity/effectScope'
 
 // TODO this should be using the same as /component/
 
+/**
+ * @internal
+ */
 export declare class Component {
   constructor(options?: any)
   // constructor information
diff --git a/typescript/global-api.d.ts b/typescript/global-api.ts
similarity index 95%
rename from typescript/global-api.d.ts
rename to typescript/global-api.ts
index 14b82c4bb9d..7245fe1b215 100644
--- a/typescript/global-api.d.ts
+++ b/typescript/global-api.ts
@@ -1,7 +1,10 @@
 import { Config } from '../src/core/config'
 import { Component } from './component'
 
-declare interface GlobalAPI {
+/**
+ * @internal
+ */
+export interface GlobalAPI {
   // new(options?: any): Component
   (options?: any): void
   cid: number
diff --git a/typescript/options.d.ts b/typescript/options.ts
similarity index 93%
rename from typescript/options.d.ts
rename to typescript/options.ts
index 919602c0970..11214da6d09 100644
--- a/typescript/options.d.ts
+++ b/typescript/options.ts
@@ -2,7 +2,7 @@ import VNode from '../src/core/vdom/vnode'
 import { DebuggerEvent } from '../src/v3'
 import { Component } from './component'
 
-declare type InternalComponentOptions = {
+export type InternalComponentOptions = {
   _isComponent: true
   parent: Component
   _parentVnode: VNode
@@ -12,13 +12,19 @@ declare type InternalComponentOptions = {
 
 type InjectKey = string | Symbol
 
-declare interface SetupContext {
+/**
+ * @internal
+ */
+export interface SetupContext {
   attrs: Record<string, any>
   slots: Record<string, () => VNode[]>
   emit: (event: string, ...args: any[]) => any
 }
 
-declare type ComponentOptions = {
+/**
+ * @internal
+ */
+export type ComponentOptions = {
   // v3
   setup?: (props: Record<string, any>, ctx: SetupContext) => unknown
 
@@ -106,7 +112,7 @@ declare type ComponentOptions = {
   _base: typeof Component
 }
 
-declare type PropOptions = {
+export type PropOptions = {
   type: Function | Array<Function> | null
   default: any
   required: boolean | null
diff --git a/typescript/ssr.d.ts b/typescript/ssr.ts
similarity index 74%
rename from typescript/ssr.d.ts
rename to typescript/ssr.ts
index 3a2be3c5f77..b80ba562297 100644
--- a/typescript/ssr.d.ts
+++ b/typescript/ssr.ts
@@ -1,14 +1,14 @@
 import VNode from '../src/core/vdom/vnode'
 import { Component } from './component'
 
-declare type ComponentWithCacheContext = {
+export type ComponentWithCacheContext = {
   type: 'ComponentWithCache'
   bufferIndex: number
   buffer: Array<string>
   key: string
 }
 
-declare type ElementContext = {
+export type ElementContext = {
   type: 'Element'
   children: Array<VNode>
   rendered: number
@@ -16,12 +16,12 @@ declare type ElementContext = {
   total: number
 }
 
-declare type ComponentContext = {
+export type ComponentContext = {
   type: 'Component'
   prevActive: Component
 }
 
-declare type RenderState =
+export type RenderState =
   | ComponentContext
   | ComponentWithCacheContext
   | ElementContext
diff --git a/typescript/vnode.d.ts b/typescript/vnode.ts
similarity index 82%
rename from typescript/vnode.d.ts
rename to typescript/vnode.ts
index 456afdad42e..cdaa65f0479 100644
--- a/typescript/vnode.d.ts
+++ b/typescript/vnode.ts
@@ -1,12 +1,19 @@
 import VNode from '../src/core/vdom/vnode'
 import { Ref } from '../src/v3'
 import { Component } from './component'
+import { ASTModifiers } from './compiler'
 
-declare type VNodeChildren =
+/**
+ * @internal
+ */
+export type VNodeChildren =
   | Array<null | VNode | string | number | VNodeChildren>
   | string
 
-declare type VNodeComponentOptions = {
+/**
+ * @internal
+ */
+export type VNodeComponentOptions = {
   Ctor: typeof Component
   propsData?: Object
   listeners?: Record<string, Function | Function[]>
@@ -14,7 +21,10 @@ declare type VNodeComponentOptions = {
   tag?: string
 }
 
-declare type MountedComponentVNode = VNode & {
+/**
+ * @internal
+ */
+export type MountedComponentVNode = VNode & {
   context: Component
   componentOptions: VNodeComponentOptions
   componentInstance: Component
@@ -22,8 +32,11 @@ declare type MountedComponentVNode = VNode & {
   data: VNodeData
 }
 
+/**
+ * @internal
+ */
 // interface for vnodes in update modules
-declare type VNodeWithData = VNode & {
+export type VNodeWithData = VNode & {
   tag: string
   data: VNodeData
   children: Array<VNode>
@@ -39,7 +52,7 @@ declare type VNodeWithData = VNode & {
 }
 
 // // interface for vnodes in update modules
-// declare type VNodeWithData = {
+// export type VNodeWithData = {
 //   tag: string;
 //   data: VNodeData;
 //   children: Array<VNode>;
@@ -54,7 +67,10 @@ declare type VNodeWithData = VNode & {
 //   isRootInsert: boolean;
 // };
 
-declare interface VNodeData {
+/**
+ * @internal
+ */
+export interface VNodeData {
   key?: string | number
   slot?: string
   ref?: string | Ref | ((el: any) => void)
@@ -89,7 +105,10 @@ declare interface VNodeData {
   [key: string]: any
 }
 
-declare type VNodeDirective = {
+/**
+ * @internal
+ */
+export type VNodeDirective = {
   name: string
   rawName: string
   value?: any
@@ -100,6 +119,9 @@ declare type VNodeDirective = {
   def?: Object
 }
 
-declare type ScopedSlotsData = Array<
+/**
+ * @internal
+ */
+export type ScopedSlotsData = Array<
   { key: string; fn: Function } | ScopedSlotsData
 >

From b3a8ccf3d29631b9d5a76ba63908b3d1a1dec18b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 30 May 2022 21:41:00 +0800
Subject: [PATCH 100/317] chore: fix test script [ci skip]

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index a9066eb3bed..818062dfefa 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
     "build:types": "rimraf temp && tsc --declaration --emitDeclarationOnly --outDir temp && api-extractor run",
-    "test": "npm run lint && npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e",
+    "test": "npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e && npm run test:ssr",
     "test:unit": "vitest run test/unit",
     "test:ssr": "npm run build:ssr && vitest run test/ssr",
     "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",

From 9f74f2048d0d6e67fd112f0f28c0dbad43e15217 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 15:32:44 +0800
Subject: [PATCH 101/317] refactor: move to monorepo

---
 .github/CONTRIBUTING.md                       |   37 +-
 .gitignore                                    |   14 +-
 compiler-sfc/index.d.ts                       |    1 +
 compiler-sfc/index.js                         |    1 +
 compiler-sfc/package.json                     |    4 +
 package.json                                  |   38 +-
 packages/compiler-sfc/package.json            |   28 +
 .../README.md                                 |    0
 .../client-plugin.d.ts                        |    0
 .../index.js                                  |   12 +-
 .../package.json                              |   10 +-
 .../server-plugin.d.ts                        |    0
 .../bundle-renderer/create-bundle-renderer.ts |    0
 .../bundle-renderer/create-bundle-runner.ts   |    0
 .../bundle-renderer/source-map-support.ts     |    0
 .../src}/create-basic-renderer.ts             |    0
 .../server-renderer/src}/create-renderer.ts   |    0
 .../src}/optimizing-compiler/codegen.ts       |    0
 .../src}/optimizing-compiler/index.ts         |    0
 .../src}/optimizing-compiler/modules.ts       |    0
 .../src}/optimizing-compiler/optimizer.ts     |    0
 .../optimizing-compiler/runtime-helpers.ts    |    0
 .../server-renderer/src}/render-context.ts    |    0
 .../server-renderer/src}/render-stream.ts     |    0
 .../server-renderer/src}/render.ts            |    0
 .../create-async-file-mapper.ts               |    0
 .../src}/template-renderer/index.ts           |    0
 .../src}/template-renderer/parse-template.ts  |    0
 .../src}/template-renderer/template-stream.ts |    0
 .../server-renderer/src}/util.ts              |    0
 .../src}/webpack-plugin/client.ts             |    0
 .../src}/webpack-plugin/server.ts             |    0
 .../src}/webpack-plugin/util.ts               |    0
 .../server-renderer/src}/write.ts             |    0
 .../server-renderer/test}/async-loader.js     |    0
 .../test}/compile-with-webpack.ts             |    6 +-
 packages/server-renderer/test/fixtures/app.js |   14 +
 .../test}/fixtures/async-bar.js               |    4 +-
 .../test}/fixtures/async-foo.js               |    4 +-
 .../test/fixtures/cache-opt-out.js            |   18 +
 .../server-renderer/test/fixtures/cache.js    |   18 +
 .../server-renderer/test}/fixtures/error.js   |    0
 .../test}/fixtures/nested-cache.js            |   24 +-
 .../test}/fixtures/promise-rejection.js       |    0
 .../server-renderer/test}/fixtures/split.js   |    9 +-
 .../server-renderer/test}/fixtures/test.css   |    0
 .../server-renderer/test}/fixtures/test.png   |    0
 .../server-renderer/test}/fixtures/test.woff2 |    0
 .../test}/ssr-basic-renderer.spec.ts          |    0
 .../test}/ssr-bundle-render.spec.ts           |    7 +-
 .../server-renderer/test}/ssr-stream.spec.ts  |    0
 .../server-renderer/test}/ssr-string.spec.ts  |    0
 .../test}/ssr-template.spec.ts                |    2 +-
 packages/server-renderer/tsconfig.json        |   37 +
 .../types/index.d.ts                          |    0
 .../types/plugin.d.ts                         |    0
 .../types/tsconfig.json                       |   10 +-
 .../README.md                                 |    0
 packages/template-compiler/browser.js         | 9337 +++++++++++++++++
 packages/template-compiler/build.js           | 5148 +++++++++
 packages/template-compiler/index.js           |   32 +
 .../package.json                              |    0
 .../types/index.d.ts                          |    2 +-
 .../types/test.ts                             |    2 +-
 .../template-compiler/types/tsconfig.json     |   13 +
 packages/vue-template-compiler/index.js       |   20 -
 .../vue-template-compiler/types/tsconfig.json |   13 -
 pnpm-lock.yaml                                | 1220 ++-
 pnpm-workspace.yaml                           |    2 +
 scripts/alias.js                              |    2 +-
 scripts/config.js                             |   70 +-
 src/platforms/web/entry-compiler-sfc.ts       |    1 +
 test/e2e/basic-ssr.html                       |    2 +-
 test/ssr/fixtures/app.js                      |   12 -
 test/ssr/fixtures/cache-opt-out.js            |   16 -
 test/ssr/fixtures/cache.js                    |   16 -
 test/tsconfig.json                            |    2 +-
 tsconfig.json                                 |    4 +-
 vitest.config.ts                              |    2 +-
 79 files changed, 15605 insertions(+), 609 deletions(-)
 create mode 100644 compiler-sfc/index.d.ts
 create mode 100644 compiler-sfc/index.js
 create mode 100644 compiler-sfc/package.json
 create mode 100644 packages/compiler-sfc/package.json
 rename packages/{vue-server-renderer => server-renderer}/README.md (100%)
 rename packages/{vue-server-renderer => server-renderer}/client-plugin.d.ts (100%)
 rename packages/{vue-server-renderer => server-renderer}/index.js (65%)
 rename packages/{vue-server-renderer => server-renderer}/package.json (82%)
 rename packages/{vue-server-renderer => server-renderer}/server-plugin.d.ts (100%)
 rename {src/server => packages/server-renderer/src}/bundle-renderer/create-bundle-renderer.ts (100%)
 rename {src/server => packages/server-renderer/src}/bundle-renderer/create-bundle-runner.ts (100%)
 rename {src/server => packages/server-renderer/src}/bundle-renderer/source-map-support.ts (100%)
 rename {src/server => packages/server-renderer/src}/create-basic-renderer.ts (100%)
 rename {src/server => packages/server-renderer/src}/create-renderer.ts (100%)
 rename {src/server => packages/server-renderer/src}/optimizing-compiler/codegen.ts (100%)
 rename {src/server => packages/server-renderer/src}/optimizing-compiler/index.ts (100%)
 rename {src/server => packages/server-renderer/src}/optimizing-compiler/modules.ts (100%)
 rename {src/server => packages/server-renderer/src}/optimizing-compiler/optimizer.ts (100%)
 rename {src/server => packages/server-renderer/src}/optimizing-compiler/runtime-helpers.ts (100%)
 rename {src/server => packages/server-renderer/src}/render-context.ts (100%)
 rename {src/server => packages/server-renderer/src}/render-stream.ts (100%)
 rename {src/server => packages/server-renderer/src}/render.ts (100%)
 rename {src/server => packages/server-renderer/src}/template-renderer/create-async-file-mapper.ts (100%)
 rename {src/server => packages/server-renderer/src}/template-renderer/index.ts (100%)
 rename {src/server => packages/server-renderer/src}/template-renderer/parse-template.ts (100%)
 rename {src/server => packages/server-renderer/src}/template-renderer/template-stream.ts (100%)
 rename {src/server => packages/server-renderer/src}/util.ts (100%)
 rename {src/server => packages/server-renderer/src}/webpack-plugin/client.ts (100%)
 rename {src/server => packages/server-renderer/src}/webpack-plugin/server.ts (100%)
 rename {src/server => packages/server-renderer/src}/webpack-plugin/util.ts (100%)
 rename {src/server => packages/server-renderer/src}/write.ts (100%)
 rename {test/ssr => packages/server-renderer/test}/async-loader.js (100%)
 rename {test/ssr => packages/server-renderer/test}/compile-with-webpack.ts (90%)
 create mode 100644 packages/server-renderer/test/fixtures/app.js
 rename {test/ssr => packages/server-renderer/test}/fixtures/async-bar.js (79%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/async-foo.js (87%)
 create mode 100644 packages/server-renderer/test/fixtures/cache-opt-out.js
 create mode 100644 packages/server-renderer/test/fixtures/cache.js
 rename {test/ssr => packages/server-renderer/test}/fixtures/error.js (100%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/nested-cache.js (63%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/promise-rejection.js (100%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/split.js (74%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/test.css (100%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/test.png (100%)
 rename {test/ssr => packages/server-renderer/test}/fixtures/test.woff2 (100%)
 rename {test/ssr => packages/server-renderer/test}/ssr-basic-renderer.spec.ts (100%)
 rename {test/ssr => packages/server-renderer/test}/ssr-bundle-render.spec.ts (97%)
 rename {test/ssr => packages/server-renderer/test}/ssr-stream.spec.ts (100%)
 rename {test/ssr => packages/server-renderer/test}/ssr-string.spec.ts (100%)
 rename {test/ssr => packages/server-renderer/test}/ssr-template.spec.ts (99%)
 create mode 100644 packages/server-renderer/tsconfig.json
 rename packages/{vue-server-renderer => server-renderer}/types/index.d.ts (100%)
 rename packages/{vue-server-renderer => server-renderer}/types/plugin.d.ts (100%)
 rename packages/{vue-server-renderer => server-renderer}/types/tsconfig.json (56%)
 rename packages/{vue-template-compiler => template-compiler}/README.md (100%)
 create mode 100644 packages/template-compiler/browser.js
 create mode 100644 packages/template-compiler/build.js
 create mode 100644 packages/template-compiler/index.js
 rename packages/{vue-template-compiler => template-compiler}/package.json (100%)
 rename packages/{vue-template-compiler => template-compiler}/types/index.d.ts (99%)
 rename packages/{vue-template-compiler => template-compiler}/types/test.ts (99%)
 create mode 100644 packages/template-compiler/types/tsconfig.json
 delete mode 100644 packages/vue-template-compiler/index.js
 delete mode 100644 packages/vue-template-compiler/types/tsconfig.json
 create mode 100644 pnpm-workspace.yaml
 create mode 100644 src/platforms/web/entry-compiler-sfc.ts
 delete mode 100644 test/ssr/fixtures/app.js
 delete mode 100644 test/ssr/fixtures/cache-opt-out.js
 delete mode 100644 test/ssr/fixtures/cache.js

diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 5368b5481bc..825a8470b00 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -25,6 +25,7 @@ Hi! I'm really excited that you are interested in contributing to Vue.js. Before
 - Make sure `npm test` passes. (see [development setup](#development-setup))
 
 - If adding a new feature:
+
   - Add accompanying test case.
   - Provide a convincing reason to add this feature. Ideally, you should open a suggestion issue first and have it approved before working on it.
 
@@ -35,12 +36,12 @@ Hi! I'm really excited that you are interested in contributing to Vue.js. Before
 
 ## Development Setup
 
-You will need [Node.js](http://nodejs.org) **version 8+**, [Java Runtime Environment](http://www.oracle.com/technetwork/java/javase/downloads/index.html) (for running Selenium server during e2e tests) and [yarn](https://yarnpkg.com/en/docs/install).
+You will need [Node.js](http://nodejs.org) **version 12+** and [pnpm](https://pnpm.io/).
 
 After cloning the repo, run:
 
-``` bash
-$ yarn # install the dependencies of the project
+```bash
+$ pnpm i # install the dependencies of the project
 ```
 
 ### Committing Changes
@@ -49,17 +50,20 @@ Commit messages should follow the [commit message convention](./COMMIT_CONVENTIO
 
 ### Commonly used NPM scripts
 
-``` bash
+```bash
 # watch and auto re-build dist/vue.js
 $ npm run dev
 
-# watch and auto re-run unit tests in Chrome
-$ npm run dev:test
+# run unit tests
+$ npm run test:unit
+
+# run specific tests in watch mode
+$ npx vitest {test_file_name_pattern_to_match}
 
 # build all dist files, including npm packages
 $ npm run build
 
-# run the full test suite, including linting/type checking
+# run the full test suite, including unit/e2e/type checking
 $ npm test
 ```
 
@@ -79,9 +83,17 @@ The default test script will do the following: lint with ESLint -> type check wi
 
   See [dist/README.md](https://github.com/vuejs/vue/blob/dev/dist/README.md) for more details on dist files.
 
-- **`flow`**: contains type declarations for [Flow](https://flowtype.org/). These declarations are loaded **globally** and you will see them used in type annotations in normal source code.
+- **`types`**: contains public types published to npm. These were hand-authored before we moved the codebase from Flow to TypeScript. To ensure backwards compatibility, we keep using these manually authored types.
+
+  Types for new features added in 2.7 (Composition API) are auto-generated from source code as `types/v3-generated.d.ts` and re-exported from `types/index.d.ts`.
+
+- **`typescript`**: contains type declarations added when we ported the codebase from Flow to TypeScript. These types should be considered internal - they care less about type inference for end-user scenarios and prioritize working with internal source code.
+
+- **`packages`**:
 
-- **`packages`**: contains `vue-server-renderer` and `vue-template-compiler`, which are distributed as separate NPM packages. They are automatically generated from the source code and always have the same version with the main `vue` package.
+  - `vue-server-renderer` and `vue-template-compiler` are distributed as separate NPM packages. They are automatically generated from the source code and always have the same version with the main `vue` package.
+
+  - `compiler-sfc` is an internal package that is distributed as part of the main `vue` package. It's aliased and can be imported as `vue/compiler-sfc` similar to Vue 3.
 
 - **`test`**: contains all tests. The unit tests are written with [Jasmine](http://jasmine.github.io/2.3/introduction.html) and run with [Karma](http://karma-runner.github.io/0.13/index.html). The e2e tests are written for and run with [Nightwatch.js](http://nightwatchjs.org/).
 
@@ -111,17 +123,12 @@ The default test script will do the following: lint with ESLint -> type check wi
 
     Entry files for dist builds are located in their respective platform directory.
 
-    Each platform module contains three parts: `compiler`, `runtime` and `server`, corresponding to the three directories above. Each part contains platform-specific modules/utilities which are imported and injected to the core counterparts in platform-specific entry files. For example, the code implementing the logic behind `v-bind:class` is in `platforms/web/runtime/modules/class.js` - which is imported in `entries/web-runtime.js` and used to create the browser-specific vdom patching function.
+    Each platform module contains three parts: `compiler`, `runtime` and `server`, corresponding to the three directories above. Each part contains platform-specific modules/utilities which are imported and injected to the core counterparts in platform-specific entry files. For example, the code implementing the logic behind `v-bind:class` is in `platforms/web/runtime/modules/class.js` - which is imported in `platforms/web/entry-runtime.ts` and used to create the browser-specific vdom patching function.
 
   - **`sfc`**: contains single-file component (`*.vue` files) parsing logic. This is used in the `vue-template-compiler` package.
 
   - **`shared`**: contains utilities shared across the entire codebase.
 
-  - **`types`**: contains TypeScript type definitions
-
-    - **`test`**: contains type definitions tests
-
-
 ## Financial Contribution
 
 As a pure community-driven project without major corporate backing, we also welcome financial contributions via GitHub Sponsors and OpenCollective. Please consult the [Sponsor Page](https://vuejs.org/sponsor/) for more details.
diff --git a/.gitignore b/.gitignore
index 0062d8c630d..d86932f233a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,13 +4,13 @@ node_modules
 explorations
 TODOs.md
 RELEASE_NOTE*.md
-packages/vue-server-renderer/basic.js
-packages/vue-server-renderer/build.dev.js
-packages/vue-server-renderer/build.prod.js
-packages/vue-server-renderer/server-plugin.js
-packages/vue-server-renderer/client-plugin.js
-packages/vue-template-compiler/build.js
-packages/vue-template-compiler/browser.js
+packages/server-renderer/basic.js
+packages/server-renderer/build.dev.js
+packages/server-renderer/build.prod.js
+packages/server-renderer/server-plugin.js
+packages/server-renderer/client-plugin.js
+packages/compiler-sfc/build.js
+packages/compiler-sfc/browser.js
 .vscode
 dist
 temp
diff --git a/compiler-sfc/index.d.ts b/compiler-sfc/index.d.ts
new file mode 100644
index 00000000000..3c30abc8ccf
--- /dev/null
+++ b/compiler-sfc/index.d.ts
@@ -0,0 +1 @@
+export * from '@vue/compiler-sfc'
diff --git a/compiler-sfc/index.js b/compiler-sfc/index.js
new file mode 100644
index 00000000000..774f9da2742
--- /dev/null
+++ b/compiler-sfc/index.js
@@ -0,0 +1 @@
+module.exports = require('@vue/compiler-sfc')
diff --git a/compiler-sfc/package.json b/compiler-sfc/package.json
new file mode 100644
index 00000000000..d7ccd0a7b03
--- /dev/null
+++ b/compiler-sfc/package.json
@@ -0,0 +1,4 @@
+{
+  "main": "index.js",
+  "types": "index.d.ts"
+}
diff --git a/package.json b/package.json
index 818062dfefa..319197fad2e 100644
--- a/package.json
+++ b/package.json
@@ -11,22 +11,24 @@
   "files": [
     "src",
     "dist/*.js",
-    "types/*.d.ts"
+    "types/*.d.ts",
+    "compiler-sfc",
+    "packages/compiler-sfc"
   ],
   "sideEffects": false,
   "scripts": {
-    "dev": "rollup -w -c scripts/config.js --environment TARGET:web-full-dev",
-    "dev:cjs": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-cjs-dev",
-    "dev:esm": "rollup -w -c scripts/config.js --environment TARGET:web-runtime-esm",
-    "dev:ssr": "rollup -w -c scripts/config.js --environment TARGET:web-server-renderer",
-    "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:web-compiler ",
+    "dev": "rollup -w -c scripts/config.js --environment TARGET:full-dev",
+    "dev:cjs": "rollup -w -c scripts/config.js --environment TARGET:runtime-cjs-dev",
+    "dev:esm": "rollup -w -c scripts/config.js --environment TARGET:runtime-esm",
+    "dev:ssr": "rollup -w -c scripts/config.js --environment TARGET:server-renderer",
+    "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:compiler ",
     "build": "node scripts/build.js",
-    "build:ssr": "npm run build -- web-runtime-cjs,web-server-renderer",
+    "build:ssr": "npm run build -- runtime-cjs,server-renderer",
     "build:types": "rimraf temp && tsc --declaration --emitDeclarationOnly --outDir temp && api-extractor run",
     "test": "npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e && npm run test:ssr",
     "test:unit": "vitest run test/unit",
-    "test:ssr": "npm run build:ssr && vitest run test/ssr",
-    "test:e2e": "npm run build -- web-full-prod,web-server-renderer-basic && vitest run test/e2e",
+    "test:ssr": "npm run build:ssr && vitest run server-renderer",
+    "test:e2e": "npm run build -- full-prod,server-renderer-basic && vitest run test/e2e",
     "test:transition": "karma start test/transition/karma.conf.js",
     "test:types": "npm run build:types && tsc -p ./types/tsconfig.json",
     "format": "prettier --write --parser typescript \"(src|test|packages|types)/**/*.ts\"",
@@ -62,6 +64,9 @@
     "url": "https://github.com/vuejs/vue/issues"
   },
   "homepage": "https://github.com/vuejs/vue#readme",
+  "dependencies": {
+    "@vue/compiler-sfc": "2.6.14"
+  },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.24.2",
     "@rollup/plugin-alias": "^3.1.9",
@@ -70,19 +75,14 @@
     "@rollup/plugin-replace": "^4.0.0",
     "@types/he": "^1.1.2",
     "@types/node": "^17.0.30",
-    "acorn": "^8.7.1",
-    "acorn-walk": "^8.2.0",
     "chalk": "^4.0.0",
     "commitizen": "^4.2.4",
     "conventional-changelog": "^3.1.25",
     "cross-spawn": "^7.0.3",
     "cz-conventional-changelog": "^3.3.0",
-    "de-indent": "^1.0.2",
     "esbuild": "^0.14.39",
-    "escodegen": "^2.0.0",
-    "file-loader": "^3.0.1",
-    "hash-sum": "^2.0.0",
     "he": "^1.2.0",
+    "de-indent": "^1.0.2",
     "jasmine-core": "^4.1.1",
     "jsdom": "^19.0.0",
     "karma": "^6.3.20",
@@ -92,27 +92,19 @@
     "karma-jasmine": "^5.0.1",
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
-    "lodash.template": "^4.4.0",
-    "lodash.uniq": "^4.5.0",
-    "lru-cache": "^7.8.1",
     "marked": "^4.0.6",
-    "memory-fs": "^0.5.0",
     "prettier": "^2.6.2",
     "puppeteer": "^14.1.1",
-    "resolve": "^1.22.0",
     "rimraf": "^3.0.2",
     "rollup": "^2.70.2",
     "rollup-plugin-typescript2": "^0.31.2",
-    "serialize-javascript": "^6.0.0",
     "shelljs": "^0.8.5",
-    "source-map": "0.5.6",
     "terser": "^5.13.1",
     "todomvc-app-css": "^2.4.2",
     "ts-node": "^10.7.0",
     "tslib": "^2.4.0",
     "typescript": "^4.6.4",
     "vitest": "^0.12.6",
-    "webpack": "^4.46.0",
     "yorkie": "^2.0.0"
   },
   "config": {
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
new file mode 100644
index 00000000000..59ce74c91f5
--- /dev/null
+++ b/packages/compiler-sfc/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@vue/compiler-sfc",
+  "version": "2.6.14",
+  "description": "compiler-sfc for Vue 2",
+  "main": "dist/compiler-sfc.js",
+  "types": "dist/compiler-sfc.d.ts",
+  "files": ["dist"],
+  "dependencies": {
+    "@babel/parser": "^7.16.4",
+    "source-map": "^0.6.1",
+    "postcss": "^8.1.10"
+  },
+  "devDependencies": {
+    "@types/estree": "^0.0.48",
+    "@babel/types": "^7.16.0",
+    "@types/lru-cache": "^5.1.0",
+    "estree-walker": "^2.0.2",
+    "magic-string": "^0.25.7",
+    "pug": "^3.0.1",
+    "sass": "^1.26.9",
+    "@vue/consolidate": "^0.17.3",
+    "hash-sum": "^2.0.0",
+    "lru-cache": "^5.1.1",
+    "merge-source-map": "^1.1.0",
+    "postcss-modules": "^4.0.0",
+    "postcss-selector-parser": "^6.0.4"
+  }
+}
diff --git a/packages/vue-server-renderer/README.md b/packages/server-renderer/README.md
similarity index 100%
rename from packages/vue-server-renderer/README.md
rename to packages/server-renderer/README.md
diff --git a/packages/vue-server-renderer/client-plugin.d.ts b/packages/server-renderer/client-plugin.d.ts
similarity index 100%
rename from packages/vue-server-renderer/client-plugin.d.ts
rename to packages/server-renderer/client-plugin.d.ts
diff --git a/packages/vue-server-renderer/index.js b/packages/server-renderer/index.js
similarity index 65%
rename from packages/vue-server-renderer/index.js
rename to packages/server-renderer/index.js
index b42ea8fa1f6..f3a053cf6b1 100644
--- a/packages/vue-server-renderer/index.js
+++ b/packages/server-renderer/index.js
@@ -7,9 +7,15 @@ var packageVersion = require('./package.json').version
 if (vueVersion && vueVersion !== packageVersion) {
   throw new Error(
     '\n\nVue packages version mismatch:\n\n' +
-    '- vue@' + vueVersion + '\n' +
-    '- ' + packageName + '@' + packageVersion + '\n\n' +
-    'This may cause things to work incorrectly. Make sure to use the same version for both.\n'
+      '- vue@' +
+      vueVersion +
+      '\n' +
+      '- ' +
+      packageName +
+      '@' +
+      packageVersion +
+      '\n\n' +
+      'This may cause things to work incorrectly. Make sure to use the same version for both.\n'
   )
 }
 
diff --git a/packages/vue-server-renderer/package.json b/packages/server-renderer/package.json
similarity index 82%
rename from packages/vue-server-renderer/package.json
rename to packages/server-renderer/package.json
index cfe59dd3156..6a5897cd204 100644
--- a/packages/vue-server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -13,6 +13,11 @@
     "server",
     "ssr"
   ],
+  "files": [
+    "types",
+    "*.js",
+    "*.d.ts"
+  ],
   "author": "Evan You",
   "license": "MIT",
   "bugs": {
@@ -29,7 +34,10 @@
     "source-map": "0.5.6"
   },
   "devDependencies": {
-    "vue": "file:../.."
+    "memory-fs": "^0.5.0",
+    "vue": "file:../..",
+    "webpack": "^4.46.0",
+    "file-loader": "^3.0.1"
   },
   "homepage": "https://github.com/vuejs/vue/tree/dev/packages/vue-server-renderer#readme"
 }
diff --git a/packages/vue-server-renderer/server-plugin.d.ts b/packages/server-renderer/server-plugin.d.ts
similarity index 100%
rename from packages/vue-server-renderer/server-plugin.d.ts
rename to packages/server-renderer/server-plugin.d.ts
diff --git a/src/server/bundle-renderer/create-bundle-renderer.ts b/packages/server-renderer/src/bundle-renderer/create-bundle-renderer.ts
similarity index 100%
rename from src/server/bundle-renderer/create-bundle-renderer.ts
rename to packages/server-renderer/src/bundle-renderer/create-bundle-renderer.ts
diff --git a/src/server/bundle-renderer/create-bundle-runner.ts b/packages/server-renderer/src/bundle-renderer/create-bundle-runner.ts
similarity index 100%
rename from src/server/bundle-renderer/create-bundle-runner.ts
rename to packages/server-renderer/src/bundle-renderer/create-bundle-runner.ts
diff --git a/src/server/bundle-renderer/source-map-support.ts b/packages/server-renderer/src/bundle-renderer/source-map-support.ts
similarity index 100%
rename from src/server/bundle-renderer/source-map-support.ts
rename to packages/server-renderer/src/bundle-renderer/source-map-support.ts
diff --git a/src/server/create-basic-renderer.ts b/packages/server-renderer/src/create-basic-renderer.ts
similarity index 100%
rename from src/server/create-basic-renderer.ts
rename to packages/server-renderer/src/create-basic-renderer.ts
diff --git a/src/server/create-renderer.ts b/packages/server-renderer/src/create-renderer.ts
similarity index 100%
rename from src/server/create-renderer.ts
rename to packages/server-renderer/src/create-renderer.ts
diff --git a/src/server/optimizing-compiler/codegen.ts b/packages/server-renderer/src/optimizing-compiler/codegen.ts
similarity index 100%
rename from src/server/optimizing-compiler/codegen.ts
rename to packages/server-renderer/src/optimizing-compiler/codegen.ts
diff --git a/src/server/optimizing-compiler/index.ts b/packages/server-renderer/src/optimizing-compiler/index.ts
similarity index 100%
rename from src/server/optimizing-compiler/index.ts
rename to packages/server-renderer/src/optimizing-compiler/index.ts
diff --git a/src/server/optimizing-compiler/modules.ts b/packages/server-renderer/src/optimizing-compiler/modules.ts
similarity index 100%
rename from src/server/optimizing-compiler/modules.ts
rename to packages/server-renderer/src/optimizing-compiler/modules.ts
diff --git a/src/server/optimizing-compiler/optimizer.ts b/packages/server-renderer/src/optimizing-compiler/optimizer.ts
similarity index 100%
rename from src/server/optimizing-compiler/optimizer.ts
rename to packages/server-renderer/src/optimizing-compiler/optimizer.ts
diff --git a/src/server/optimizing-compiler/runtime-helpers.ts b/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
similarity index 100%
rename from src/server/optimizing-compiler/runtime-helpers.ts
rename to packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
diff --git a/src/server/render-context.ts b/packages/server-renderer/src/render-context.ts
similarity index 100%
rename from src/server/render-context.ts
rename to packages/server-renderer/src/render-context.ts
diff --git a/src/server/render-stream.ts b/packages/server-renderer/src/render-stream.ts
similarity index 100%
rename from src/server/render-stream.ts
rename to packages/server-renderer/src/render-stream.ts
diff --git a/src/server/render.ts b/packages/server-renderer/src/render.ts
similarity index 100%
rename from src/server/render.ts
rename to packages/server-renderer/src/render.ts
diff --git a/src/server/template-renderer/create-async-file-mapper.ts b/packages/server-renderer/src/template-renderer/create-async-file-mapper.ts
similarity index 100%
rename from src/server/template-renderer/create-async-file-mapper.ts
rename to packages/server-renderer/src/template-renderer/create-async-file-mapper.ts
diff --git a/src/server/template-renderer/index.ts b/packages/server-renderer/src/template-renderer/index.ts
similarity index 100%
rename from src/server/template-renderer/index.ts
rename to packages/server-renderer/src/template-renderer/index.ts
diff --git a/src/server/template-renderer/parse-template.ts b/packages/server-renderer/src/template-renderer/parse-template.ts
similarity index 100%
rename from src/server/template-renderer/parse-template.ts
rename to packages/server-renderer/src/template-renderer/parse-template.ts
diff --git a/src/server/template-renderer/template-stream.ts b/packages/server-renderer/src/template-renderer/template-stream.ts
similarity index 100%
rename from src/server/template-renderer/template-stream.ts
rename to packages/server-renderer/src/template-renderer/template-stream.ts
diff --git a/src/server/util.ts b/packages/server-renderer/src/util.ts
similarity index 100%
rename from src/server/util.ts
rename to packages/server-renderer/src/util.ts
diff --git a/src/server/webpack-plugin/client.ts b/packages/server-renderer/src/webpack-plugin/client.ts
similarity index 100%
rename from src/server/webpack-plugin/client.ts
rename to packages/server-renderer/src/webpack-plugin/client.ts
diff --git a/src/server/webpack-plugin/server.ts b/packages/server-renderer/src/webpack-plugin/server.ts
similarity index 100%
rename from src/server/webpack-plugin/server.ts
rename to packages/server-renderer/src/webpack-plugin/server.ts
diff --git a/src/server/webpack-plugin/util.ts b/packages/server-renderer/src/webpack-plugin/util.ts
similarity index 100%
rename from src/server/webpack-plugin/util.ts
rename to packages/server-renderer/src/webpack-plugin/util.ts
diff --git a/src/server/write.ts b/packages/server-renderer/src/write.ts
similarity index 100%
rename from src/server/write.ts
rename to packages/server-renderer/src/write.ts
diff --git a/test/ssr/async-loader.js b/packages/server-renderer/test/async-loader.js
similarity index 100%
rename from test/ssr/async-loader.js
rename to packages/server-renderer/test/async-loader.js
diff --git a/test/ssr/compile-with-webpack.ts b/packages/server-renderer/test/compile-with-webpack.ts
similarity index 90%
rename from test/ssr/compile-with-webpack.ts
rename to packages/server-renderer/test/compile-with-webpack.ts
index a76d511eec8..d4b57ef0e28 100644
--- a/test/ssr/compile-with-webpack.ts
+++ b/packages/server-renderer/test/compile-with-webpack.ts
@@ -1,7 +1,7 @@
 import path from 'path'
 import webpack from 'webpack'
 import MemoryFS from 'memory-fs'
-import { RenderOptions } from '../../src/server/create-renderer'
+import { RenderOptions } from 'server/create-renderer'
 import { createBundleRenderer } from 'web/entry-server-renderer'
 import VueSSRServerPlugin from 'server/webpack-plugin/server'
 
@@ -20,7 +20,7 @@ export function compileWithWebpack(
         },
         {
           test: /\.(png|woff2|css)$/,
-          loader: 'file-loader',
+          loader: require.resolve('file-loader'),
           options: {
             name: '[name].[ext]'
           }
@@ -62,7 +62,7 @@ export async function createWebpackBundleRenderer(
       filename: 'bundle.js',
       libraryTarget: 'commonjs2'
     },
-    externals: [require.resolve('../../dist/vue.runtime.common.js')],
+    externals: [require.resolve('../../../dist/vue.runtime.common.js')],
     plugins: asBundle ? [new VueSSRServerPlugin()] : []
   })
 
diff --git a/packages/server-renderer/test/fixtures/app.js b/packages/server-renderer/test/fixtures/app.js
new file mode 100644
index 00000000000..08c758522ef
--- /dev/null
+++ b/packages/server-renderer/test/fixtures/app.js
@@ -0,0 +1,14 @@
+import Vue from '../../../../dist/vue.runtime.common.js'
+
+export default context => {
+  return new Promise(resolve => {
+    context.msg = 'hello'
+    resolve(
+      new Vue({
+        render(h) {
+          return h('div', context.url)
+        }
+      })
+    )
+  })
+}
diff --git a/test/ssr/fixtures/async-bar.js b/packages/server-renderer/test/fixtures/async-bar.js
similarity index 79%
rename from test/ssr/fixtures/async-bar.js
rename to packages/server-renderer/test/fixtures/async-bar.js
index 5eb93c12eda..23349f8a9ee 100644
--- a/test/ssr/fixtures/async-bar.js
+++ b/packages/server-renderer/test/fixtures/async-bar.js
@@ -1,8 +1,8 @@
 module.exports = {
-  beforeCreate () {
+  beforeCreate() {
     this.$vnode.ssrContext._registeredComponents.add('__MODULE_ID__')
   },
-  render (h) {
+  render(h) {
     return h('div', 'async bar')
   }
 }
diff --git a/test/ssr/fixtures/async-foo.js b/packages/server-renderer/test/fixtures/async-foo.js
similarity index 87%
rename from test/ssr/fixtures/async-foo.js
rename to packages/server-renderer/test/fixtures/async-foo.js
index 59e0b9abce3..18e5b235e41 100644
--- a/test/ssr/fixtures/async-foo.js
+++ b/packages/server-renderer/test/fixtures/async-foo.js
@@ -4,10 +4,10 @@ import font from './test.woff2'
 import image from './test.png'
 
 export default {
-  beforeCreate () {
+  beforeCreate() {
     this.$vnode.ssrContext._registeredComponents.add('__MODULE_ID__')
   },
-  render (h) {
+  render(h) {
     return h('div', `async ${font} ${image}`)
   }
 }
diff --git a/packages/server-renderer/test/fixtures/cache-opt-out.js b/packages/server-renderer/test/fixtures/cache-opt-out.js
new file mode 100644
index 00000000000..7c0d1247280
--- /dev/null
+++ b/packages/server-renderer/test/fixtures/cache-opt-out.js
@@ -0,0 +1,18 @@
+import Vue from '../../../../dist/vue.runtime.common.js'
+
+const app = {
+  name: 'app',
+  props: ['id'],
+  serverCacheKey: props => (props.id === 1 ? false : props.id),
+  render(h) {
+    return h('div', '/test')
+  }
+}
+
+export default () => {
+  return Promise.resolve(
+    new Vue({
+      render: h => h(app, { props: { id: 1 } })
+    })
+  )
+}
diff --git a/packages/server-renderer/test/fixtures/cache.js b/packages/server-renderer/test/fixtures/cache.js
new file mode 100644
index 00000000000..48d1410b2b3
--- /dev/null
+++ b/packages/server-renderer/test/fixtures/cache.js
@@ -0,0 +1,18 @@
+import Vue from '../../../../dist/vue.runtime.common.js'
+
+const app = {
+  name: 'app',
+  props: ['id'],
+  serverCacheKey: props => props.id,
+  render(h) {
+    return h('div', '/test')
+  }
+}
+
+export default () => {
+  return Promise.resolve(
+    new Vue({
+      render: h => h(app, { props: { id: 1 } })
+    })
+  )
+}
diff --git a/test/ssr/fixtures/error.js b/packages/server-renderer/test/fixtures/error.js
similarity index 100%
rename from test/ssr/fixtures/error.js
rename to packages/server-renderer/test/fixtures/error.js
diff --git a/test/ssr/fixtures/nested-cache.js b/packages/server-renderer/test/fixtures/nested-cache.js
similarity index 63%
rename from test/ssr/fixtures/nested-cache.js
rename to packages/server-renderer/test/fixtures/nested-cache.js
index 9f2656858f3..be72490d666 100644
--- a/test/ssr/fixtures/nested-cache.js
+++ b/packages/server-renderer/test/fixtures/nested-cache.js
@@ -1,13 +1,13 @@
-import Vue from '../../../dist/vue.runtime.common.js'
+import Vue from '../../../../dist/vue.runtime.common.js'
 
-function createRegisterFn (id) {
+function createRegisterFn(id) {
   return function (context) {
     context = context || this.$vnode.ssrContext
     context.registered.push(id)
   }
 }
 
-function addHooks (comp) {
+function addHooks(comp) {
   const hook = createRegisterFn(comp.name)
   return Object.assign(comp, {
     _ssrRegister: hook,
@@ -19,7 +19,7 @@ const grandchild = addHooks({
   name: 'grandchild',
   props: ['id'],
   serverCacheKey: props => props.id,
-  render (h) {
+  render(h) {
     return h('div', '/test')
   }
 })
@@ -28,8 +28,8 @@ const child = addHooks({
   name: 'child',
   props: ['id'],
   serverCacheKey: props => props.id,
-  render (h) {
-    return h(grandchild, { props: { id: this.id }})
+  render(h) {
+    return h(grandchild, { props: { id: this.id } })
   }
 })
 
@@ -37,13 +37,15 @@ const app = addHooks({
   name: 'app',
   props: ['id'],
   serverCacheKey: props => props.id,
-  render (h) {
-    return h(child, { props: { id: this.id }})
+  render(h) {
+    return h(child, { props: { id: this.id } })
   }
 })
 
 export default () => {
-  return Promise.resolve(new Vue({
-    render: h => h(app, { props: { id: 1 }})
-  }))
+  return Promise.resolve(
+    new Vue({
+      render: h => h(app, { props: { id: 1 } })
+    })
+  )
 }
diff --git a/test/ssr/fixtures/promise-rejection.js b/packages/server-renderer/test/fixtures/promise-rejection.js
similarity index 100%
rename from test/ssr/fixtures/promise-rejection.js
rename to packages/server-renderer/test/fixtures/promise-rejection.js
diff --git a/test/ssr/fixtures/split.js b/packages/server-renderer/test/fixtures/split.js
similarity index 74%
rename from test/ssr/fixtures/split.js
rename to packages/server-renderer/test/fixtures/split.js
index 0282f1035ad..1d33acc4abe 100644
--- a/test/ssr/fixtures/split.js
+++ b/packages/server-renderer/test/fixtures/split.js
@@ -1,4 +1,4 @@
-import Vue from '../../../dist/vue.runtime.common.js'
+import Vue from '../../../../dist/vue.runtime.common.js'
 
 // async component!
 const Foo = () => import('./async-foo')
@@ -8,11 +8,8 @@ export default context => {
   return new Promise(resolve => {
     context.msg = 'hello'
     const vm = new Vue({
-      render (h) {
-        return h('div', [
-          context.url,
-          h(Foo)
-        ])
+      render(h) {
+        return h('div', [context.url, h(Foo)])
       }
     })
 
diff --git a/test/ssr/fixtures/test.css b/packages/server-renderer/test/fixtures/test.css
similarity index 100%
rename from test/ssr/fixtures/test.css
rename to packages/server-renderer/test/fixtures/test.css
diff --git a/test/ssr/fixtures/test.png b/packages/server-renderer/test/fixtures/test.png
similarity index 100%
rename from test/ssr/fixtures/test.png
rename to packages/server-renderer/test/fixtures/test.png
diff --git a/test/ssr/fixtures/test.woff2 b/packages/server-renderer/test/fixtures/test.woff2
similarity index 100%
rename from test/ssr/fixtures/test.woff2
rename to packages/server-renderer/test/fixtures/test.woff2
diff --git a/test/ssr/ssr-basic-renderer.spec.ts b/packages/server-renderer/test/ssr-basic-renderer.spec.ts
similarity index 100%
rename from test/ssr/ssr-basic-renderer.spec.ts
rename to packages/server-renderer/test/ssr-basic-renderer.spec.ts
diff --git a/test/ssr/ssr-bundle-render.spec.ts b/packages/server-renderer/test/ssr-bundle-render.spec.ts
similarity index 97%
rename from test/ssr/ssr-bundle-render.spec.ts
rename to packages/server-renderer/test/ssr-bundle-render.spec.ts
index 78ce3301e67..4693b4b1df8 100644
--- a/test/ssr/ssr-bundle-render.spec.ts
+++ b/packages/server-renderer/test/ssr-bundle-render.spec.ts
@@ -1,6 +1,5 @@
 // @vitest-environment node
 
-import LRU from 'lru-cache'
 import { createWebpackBundleRenderer } from './compile-with-webpack'
 
 describe('SSR: bundle renderer', () => {
@@ -171,7 +170,7 @@ function createAssertions(runInNewContext) {
   })
 
   it('render with cache (nested)', async () => {
-    const cache = new LRU({ ttl: 65535 }) as any
+    const cache = new Map() as any
     vi.spyOn(cache, 'get')
     vi.spyOn(cache, 'set')
     const options = {
@@ -284,7 +283,7 @@ function createAssertions(runInNewContext) {
     try {
       await renderer.renderToString()
     } catch (err: any) {
-      expect(err.stack).toContain('test/ssr/fixtures/error.js:1:0')
+      expect(err.stack).toContain('server-renderer/test/fixtures/error.js:1:0')
       expect(err.message).toBe('foo')
     }
   })
@@ -300,7 +299,7 @@ function createAssertions(runInNewContext) {
       stream.on('error', resolve)
     })
 
-    expect(err.stack).toContain('test/ssr/fixtures/error.js:1:0')
+    expect(err.stack).toContain('server-renderer/test/fixtures/error.js:1:0')
     expect(err.message).toBe('foo')
   })
 
diff --git a/test/ssr/ssr-stream.spec.ts b/packages/server-renderer/test/ssr-stream.spec.ts
similarity index 100%
rename from test/ssr/ssr-stream.spec.ts
rename to packages/server-renderer/test/ssr-stream.spec.ts
diff --git a/test/ssr/ssr-string.spec.ts b/packages/server-renderer/test/ssr-string.spec.ts
similarity index 100%
rename from test/ssr/ssr-string.spec.ts
rename to packages/server-renderer/test/ssr-string.spec.ts
diff --git a/test/ssr/ssr-template.spec.ts b/packages/server-renderer/test/ssr-template.spec.ts
similarity index 99%
rename from test/ssr/ssr-template.spec.ts
rename to packages/server-renderer/test/ssr-template.spec.ts
index ba716f4ea7b..943112b4f17 100644
--- a/test/ssr/ssr-template.spec.ts
+++ b/packages/server-renderer/test/ssr-template.spec.ts
@@ -7,7 +7,7 @@ import {
 } from './compile-with-webpack'
 import { createRenderer } from 'web/entry-server-renderer'
 import VueSSRClientPlugin from 'server/webpack-plugin/client'
-import { RenderOptions } from '../../src/server/create-renderer'
+import { RenderOptions } from 'server/create-renderer'
 
 const defaultTemplate = `<html><head></head><body><!--vue-ssr-outlet--></body></html>`
 const interpolateTemplate = `<html><head><title>{{ title }}</title></head><body><!--vue-ssr-outlet-->{{{ snippet }}}</body></html>`
diff --git a/packages/server-renderer/tsconfig.json b/packages/server-renderer/tsconfig.json
new file mode 100644
index 00000000000..dec1b949939
--- /dev/null
+++ b/packages/server-renderer/tsconfig.json
@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "dist",
+    "sourceMap": true,
+    "target": "esnext",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+
+    "allowJs": true,
+    "noImplicitAny": false,
+    "noImplicitThis": false,
+
+    "noUnusedLocals": true,
+    "experimentalDecorators": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "removeComments": false,
+    "jsx": "preserve",
+    "lib": ["esnext", "dom"],
+    "types": ["node", "vitest/globals"],
+    "paths": {
+      "compiler/*": ["../../src/compiler/*"],
+      "core/*": ["../../src/core/*"],
+      "server/*": ["./src/*"],
+      "sfc/*": ["../../src/sfc/*"],
+      "shared/*": ["../../src/shared/*"],
+      "web/*": ["../../src/platforms/web/*"],
+      "v3": ["../../src/v3/index"],
+      "v3/*": ["../../src/v3/*"],
+      "typescript/*": ["../../typescript/*"],
+      "vue": ["../../src/platforms/web/entry-runtime-with-compiler"]
+    }
+  },
+  "include": ["../../src", "../../typescript", "../../test/test-env.d.ts", "."]
+}
diff --git a/packages/vue-server-renderer/types/index.d.ts b/packages/server-renderer/types/index.d.ts
similarity index 100%
rename from packages/vue-server-renderer/types/index.d.ts
rename to packages/server-renderer/types/index.d.ts
diff --git a/packages/vue-server-renderer/types/plugin.d.ts b/packages/server-renderer/types/plugin.d.ts
similarity index 100%
rename from packages/vue-server-renderer/types/plugin.d.ts
rename to packages/server-renderer/types/plugin.d.ts
diff --git a/packages/vue-server-renderer/types/tsconfig.json b/packages/server-renderer/types/tsconfig.json
similarity index 56%
rename from packages/vue-server-renderer/types/tsconfig.json
rename to packages/server-renderer/types/tsconfig.json
index 559228da74d..5e89be1ef9d 100644
--- a/packages/vue-server-renderer/types/tsconfig.json
+++ b/packages/server-renderer/types/tsconfig.json
@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
-    "target": "es5",
-    "module": "commonjs",
+    "target": "esnext",
+    "module": "esnext",
     "moduleResolution": "node",
     "strict": true,
     "noEmit": true,
@@ -9,9 +9,5 @@
       "vue": ["../../../types/index.d.ts"]
     }
   },
-  "compileOnSave": false,
-  "include": [
-    "**/*.ts",
-    "../../../types"
-  ]
+  "include": ["**/*.ts", "../../../types"]
 }
diff --git a/packages/vue-template-compiler/README.md b/packages/template-compiler/README.md
similarity index 100%
rename from packages/vue-template-compiler/README.md
rename to packages/template-compiler/README.md
diff --git a/packages/template-compiler/browser.js b/packages/template-compiler/browser.js
new file mode 100644
index 00000000000..c80108f22d8
--- /dev/null
+++ b/packages/template-compiler/browser.js
@@ -0,0 +1,9337 @@
+;(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined'
+    ? factory(exports)
+    : typeof define === 'function' && define.amd
+    ? define(['exports'], factory)
+    : ((global =
+        typeof globalThis !== 'undefined' ? globalThis : global || self),
+      factory((global.VueTemplateCompiler = {})))
+})(this, function (exports) {
+  'use strict'
+
+  var commonjsGlobal =
+    typeof globalThis !== 'undefined'
+      ? globalThis
+      : typeof window !== 'undefined'
+      ? window
+      : typeof global !== 'undefined'
+      ? global
+      : typeof self !== 'undefined'
+      ? self
+      : {}
+
+  var splitRE$1 = /\r?\n/g
+  var emptyRE = /^\s*$/
+  var needFixRE = /^(\r?\n)*[\t\s]/
+
+  var deIndent = function deindent(str) {
+    if (!needFixRE.test(str)) {
+      return str
+    }
+    var lines = str.split(splitRE$1)
+    var min = Infinity
+    var type, cur, c
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i]
+      if (!emptyRE.test(line)) {
+        if (!type) {
+          c = line.charAt(0)
+          if (c === ' ' || c === '\t') {
+            type = c
+            cur = count(line, type)
+            if (cur < min) {
+              min = cur
+            }
+          } else {
+            return str
+          }
+        } else {
+          cur = count(line, type)
+          if (cur < min) {
+            min = cur
+          }
+        }
+      }
+    }
+    return lines
+      .map(function (line) {
+        return line.slice(min)
+      })
+      .join('\n')
+  }
+
+  function count(line, type) {
+    var i = 0
+    while (line.charAt(i) === type) {
+      i++
+    }
+    return i
+  }
+
+  var emptyObject = Object.freeze({})
+  // These helpers produce better VM code in JS engines due to their
+  // explicitness and function inlining.
+  function isUndef(v) {
+    return v === undefined || v === null
+  }
+  /**
+   * Check if value is primitive.
+   */
+  function isPrimitive(value) {
+    return (
+      typeof value === 'string' ||
+      typeof value === 'number' ||
+      // $flow-disable-line
+      typeof value === 'symbol' ||
+      typeof value === 'boolean'
+    )
+  }
+  /**
+   * Quick object check - this is primarily used to tell
+   * objects from primitive values when we know the value
+   * is a JSON-compliant type.
+   */
+  function isObject(obj) {
+    return obj !== null && typeof obj === 'object'
+  }
+  /**
+   * Get the raw type string of a value, e.g., [object Object].
+   */
+  var _toString = Object.prototype.toString
+  function toRawType(value) {
+    return _toString.call(value).slice(8, -1)
+  }
+  /**
+   * Strict object type check. Only returns true
+   * for plain JavaScript objects.
+   */
+  function isPlainObject(obj) {
+    return _toString.call(obj) === '[object Object]'
+  }
+  /**
+   * Check if val is a valid array index.
+   */
+  function isValidArrayIndex(val) {
+    var n = parseFloat(String(val))
+    return n >= 0 && Math.floor(n) === n && isFinite(val)
+  }
+  /**
+   * Make a map and return a function for checking if a key
+   * is in that map.
+   */
+  function makeMap(str, expectsLowerCase) {
+    var map = Object.create(null)
+    var list = str.split(',')
+    for (var i = 0; i < list.length; i++) {
+      map[list[i]] = true
+    }
+    return expectsLowerCase
+      ? function (val) {
+          return map[val.toLowerCase()]
+        }
+      : function (val) {
+          return map[val]
+        }
+  }
+  /**
+   * Check if a tag is a built-in tag.
+   */
+  var isBuiltInTag = makeMap('slot,component', true)
+  /**
+   * Check if an attribute is a reserved attribute.
+   */
+  makeMap('key,ref,slot,slot-scope,is')
+  /**
+   * Remove an item from an array.
+   */
+  function remove(arr, item) {
+    if (arr.length) {
+      var index = arr.indexOf(item)
+      if (index > -1) {
+        return arr.splice(index, 1)
+      }
+    }
+  }
+  /**
+   * Check whether an object has the property.
+   */
+  var hasOwnProperty = Object.prototype.hasOwnProperty
+  function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key)
+  }
+  /**
+   * Create a cached version of a pure function.
+   */
+  function cached(fn) {
+    var cache = Object.create(null)
+    return function cachedFn(str) {
+      var hit = cache[str]
+      return hit || (cache[str] = fn(str))
+    }
+  }
+  /**
+   * Camelize a hyphen-delimited string.
+   */
+  var camelizeRE = /-(\w)/g
+  var camelize = cached(function (str) {
+    return str.replace(camelizeRE, function (_, c) {
+      return c ? c.toUpperCase() : ''
+    })
+  })
+  /**
+   * Hyphenate a camelCase string.
+   */
+  var hyphenateRE = /\B([A-Z])/g
+  var hyphenate = cached(function (str) {
+    return str.replace(hyphenateRE, '-$1').toLowerCase()
+  })
+  /**
+   * Mix properties into target object.
+   */
+  function extend(to, _from) {
+    for (var key in _from) {
+      to[key] = _from[key]
+    }
+    return to
+  }
+  /* eslint-disable no-unused-vars */
+  /**
+   * Perform no operation.
+   * Stubbing args to make Flow happy without leaving useless transpiled code
+   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+   */
+  function noop(a, b, c) {}
+  /**
+   * Always return false.
+   */
+  var no = function (a, b, c) {
+    return false
+  }
+  /* eslint-enable no-unused-vars */
+  /**
+   * Return the same value.
+   */
+  var identity = function (_) {
+    return _
+  }
+  /**
+   * Generate a string containing static keys from compiler modules.
+   */
+  function genStaticKeys$1(modules) {
+    return modules
+      .reduce(function (keys, m) {
+        return keys.concat(m.staticKeys || [])
+      }, [])
+      .join(',')
+  }
+
+  var isUnaryTag = makeMap(
+    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+      'link,meta,param,source,track,wbr'
+  )
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  var canBeLeftOpenTag = makeMap(
+    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
+  )
+  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+  var isNonPhrasingTag = makeMap(
+    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+      'title,tr,track'
+  )
+
+  /**
+   * unicode letters used for parsing html tags, component names and property paths.
+   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+   */
+  var unicodeRegExp =
+    /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
+  /**
+   * Define a property.
+   */
+  function def(obj, key, val, enumerable) {
+    Object.defineProperty(obj, key, {
+      value: val,
+      enumerable: !!enumerable,
+      writable: true,
+      configurable: true
+    })
+  }
+
+  /**
+   * Not type-checking this file because it's mostly vendor code.
+   */
+  // Regular Expressions for parsing tags and attributes
+  var attribute =
+    /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
+  var dynamicArgAttribute =
+    /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
+  var ncname = '[a-zA-Z_][\\-\\.0-9_a-zA-Z'.concat(unicodeRegExp.source, ']*')
+  var qnameCapture = '((?:'.concat(ncname, '\\:)?').concat(ncname, ')')
+  var startTagOpen = new RegExp('^<'.concat(qnameCapture))
+  var startTagClose = /^\s*(\/?)>/
+  var endTag = new RegExp('^<\\/'.concat(qnameCapture, '[^>]*>'))
+  var doctype = /^<!DOCTYPE [^>]+>/i
+  // #7298: escape - to avoid being passed as HTML comment when inlined in page
+  var comment = /^<!\--/
+  var conditionalComment = /^<!\[/
+  // Special Elements (can contain anything)
+  var isPlainTextElement = makeMap('script,style,textarea', true)
+  var reCache = {}
+  var decodingMap = {
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&amp;': '&',
+    '&#10;': '\n',
+    '&#9;': '\t',
+    '&#39;': "'"
+  }
+  var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
+  var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
+  // #5992
+  var isIgnoreNewlineTag = makeMap('pre,textarea', true)
+  var shouldIgnoreFirstNewline = function (tag, html) {
+    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
+  }
+  function decodeAttr(value, shouldDecodeNewlines) {
+    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
+    return value.replace(re, function (match) {
+      return decodingMap[match]
+    })
+  }
+  function parseHTML(html, options) {
+    var stack = []
+    var expectHTML = options.expectHTML
+    var isUnaryTag = options.isUnaryTag || no
+    var canBeLeftOpenTag = options.canBeLeftOpenTag || no
+    var index = 0
+    var last, lastTag
+    var _loop_1 = function () {
+      last = html
+      // Make sure we're not in a plaintext content element like script/style
+      if (!lastTag || !isPlainTextElement(lastTag)) {
+        var textEnd = html.indexOf('<')
+        if (textEnd === 0) {
+          // Comment:
+          if (comment.test(html)) {
+            var commentEnd = html.indexOf('-->')
+            if (commentEnd >= 0) {
+              if (options.shouldKeepComment) {
+                options.comment(
+                  html.substring(4, commentEnd),
+                  index,
+                  index + commentEnd + 3
+                )
+              }
+              advance(commentEnd + 3)
+              return 'continue'
+            }
+          }
+          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+          if (conditionalComment.test(html)) {
+            var conditionalEnd = html.indexOf(']>')
+            if (conditionalEnd >= 0) {
+              advance(conditionalEnd + 2)
+              return 'continue'
+            }
+          }
+          // Doctype:
+          var doctypeMatch = html.match(doctype)
+          if (doctypeMatch) {
+            advance(doctypeMatch[0].length)
+            return 'continue'
+          }
+          // End tag:
+          var endTagMatch = html.match(endTag)
+          if (endTagMatch) {
+            var curIndex = index
+            advance(endTagMatch[0].length)
+            parseEndTag(endTagMatch[1], curIndex, index)
+            return 'continue'
+          }
+          // Start tag:
+          var startTagMatch = parseStartTag()
+          if (startTagMatch) {
+            handleStartTag(startTagMatch)
+            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+              advance(1)
+            }
+            return 'continue'
+          }
+        }
+        var text = void 0,
+          rest = void 0,
+          next = void 0
+        if (textEnd >= 0) {
+          rest = html.slice(textEnd)
+          while (
+            !endTag.test(rest) &&
+            !startTagOpen.test(rest) &&
+            !comment.test(rest) &&
+            !conditionalComment.test(rest)
+          ) {
+            // < in plain text, be forgiving and treat it as text
+            next = rest.indexOf('<', 1)
+            if (next < 0) break
+            textEnd += next
+            rest = html.slice(textEnd)
+          }
+          text = html.substring(0, textEnd)
+        }
+        if (textEnd < 0) {
+          text = html
+        }
+        if (text) {
+          advance(text.length)
+        }
+        if (options.chars && text) {
+          options.chars(text, index - text.length, index)
+        }
+      } else {
+        var endTagLength_1 = 0
+        var stackedTag_1 = lastTag.toLowerCase()
+        var reStackedTag =
+          reCache[stackedTag_1] ||
+          (reCache[stackedTag_1] = new RegExp(
+            '([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)',
+            'i'
+          ))
+        var rest = html.replace(reStackedTag, function (all, text, endTag) {
+          endTagLength_1 = endTag.length
+          if (
+            !isPlainTextElement(stackedTag_1) &&
+            stackedTag_1 !== 'noscript'
+          ) {
+            text = text
+              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')
+          }
+          if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+            text = text.slice(1)
+          }
+          if (options.chars) {
+            options.chars(text)
+          }
+          return ''
+        })
+        index += html.length - rest.length
+        html = rest
+        parseEndTag(stackedTag_1, index - endTagLength_1, index)
+      }
+      if (html === last) {
+        options.chars && options.chars(html)
+        if (!stack.length && options.warn) {
+          options.warn(
+            'Mal-formatted tag at end of template: "'.concat(html, '"'),
+            {
+              start: index + html.length
+            }
+          )
+        }
+        return 'break'
+      }
+    }
+    while (html) {
+      var state_1 = _loop_1()
+      if (state_1 === 'break') break
+    }
+    // Clean up any remaining tags
+    parseEndTag()
+    function advance(n) {
+      index += n
+      html = html.substring(n)
+    }
+    function parseStartTag() {
+      var start = html.match(startTagOpen)
+      if (start) {
+        var match = {
+          tagName: start[1],
+          attrs: [],
+          start: index
+        }
+        advance(start[0].length)
+        var end = void 0,
+          attr = void 0
+        while (
+          !(end = html.match(startTagClose)) &&
+          (attr = html.match(dynamicArgAttribute) || html.match(attribute))
+        ) {
+          attr.start = index
+          advance(attr[0].length)
+          attr.end = index
+          match.attrs.push(attr)
+        }
+        if (end) {
+          match.unarySlash = end[1]
+          advance(end[0].length)
+          match.end = index
+          return match
+        }
+      }
+    }
+    function handleStartTag(match) {
+      var tagName = match.tagName
+      var unarySlash = match.unarySlash
+      if (expectHTML) {
+        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+          parseEndTag(lastTag)
+        }
+        if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+          parseEndTag(tagName)
+        }
+      }
+      var unary = isUnaryTag(tagName) || !!unarySlash
+      var l = match.attrs.length
+      var attrs = new Array(l)
+      for (var i = 0; i < l; i++) {
+        var args = match.attrs[i]
+        var value = args[3] || args[4] || args[5] || ''
+        var shouldDecodeNewlines =
+          tagName === 'a' && args[1] === 'href'
+            ? options.shouldDecodeNewlinesForHref
+            : options.shouldDecodeNewlines
+        attrs[i] = {
+          name: args[1],
+          value: decodeAttr(value, shouldDecodeNewlines)
+        }
+        if (options.outputSourceRange) {
+          attrs[i].start = args.start + args[0].match(/^\s*/).length
+          attrs[i].end = args.end
+        }
+      }
+      if (!unary) {
+        stack.push({
+          tag: tagName,
+          lowerCasedTag: tagName.toLowerCase(),
+          attrs: attrs,
+          start: match.start,
+          end: match.end
+        })
+        lastTag = tagName
+      }
+      if (options.start) {
+        options.start(tagName, attrs, unary, match.start, match.end)
+      }
+    }
+    function parseEndTag(tagName, start, end) {
+      var pos, lowerCasedTagName
+      if (start == null) start = index
+      if (end == null) end = index
+      // Find the closest opened tag of the same type
+      if (tagName) {
+        lowerCasedTagName = tagName.toLowerCase()
+        for (pos = stack.length - 1; pos >= 0; pos--) {
+          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+            break
+          }
+        }
+      } else {
+        // If no tag name is provided, clean shop
+        pos = 0
+      }
+      if (pos >= 0) {
+        // Close all the open elements, up the stack
+        for (var i = stack.length - 1; i >= pos; i--) {
+          if ((i > pos || !tagName) && options.warn) {
+            options.warn(
+              'tag <'.concat(stack[i].tag, '> has no matching end tag.'),
+              {
+                start: stack[i].start,
+                end: stack[i].end
+              }
+            )
+          }
+          if (options.end) {
+            options.end(stack[i].tag, start, end)
+          }
+        }
+        // Remove the open elements from the stack
+        stack.length = pos
+        lastTag = pos && stack[pos - 1].tag
+      } else if (lowerCasedTagName === 'br') {
+        if (options.start) {
+          options.start(tagName, [], true, start, end)
+        }
+      } else if (lowerCasedTagName === 'p') {
+        if (options.start) {
+          options.start(tagName, [], false, start, end)
+        }
+        if (options.end) {
+          options.end(tagName, start, end)
+        }
+      }
+    }
+  }
+
+  var splitRE = /\r?\n/g
+  var replaceRE = /./g
+  var isSpecialTag = makeMap('script,style,template', true)
+  /**
+   * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+   */
+  function parseComponent(content, options) {
+    if (options === void 0) {
+      options = {}
+    }
+    var sfc = {
+      template: null,
+      script: null,
+      styles: [],
+      customBlocks: [],
+      errors: []
+    }
+    var depth = 0
+    var currentBlock = null
+    var warn = function (msg) {
+      sfc.errors.push(msg)
+    }
+    if (options.outputSourceRange) {
+      warn = function (msg, range) {
+        var data = { msg: msg }
+        if (range.start != null) {
+          data.start = range.start
+        }
+        if (range.end != null) {
+          data.end = range.end
+        }
+        sfc.errors.push(data)
+      }
+    }
+    function start(tag, attrs, unary, start, end) {
+      if (depth === 0) {
+        currentBlock = {
+          type: tag,
+          content: '',
+          start: end,
+          attrs: attrs.reduce(function (cumulated, _a) {
+            var name = _a.name,
+              value = _a.value
+            cumulated[name] = value || true
+            return cumulated
+          }, {})
+        }
+        if (isSpecialTag(tag)) {
+          checkAttrs(currentBlock, attrs)
+          if (tag === 'style') {
+            sfc.styles.push(currentBlock)
+          } else {
+            sfc[tag] = currentBlock
+          }
+        } else {
+          // custom blocks
+          sfc.customBlocks.push(currentBlock)
+        }
+      }
+      if (!unary) {
+        depth++
+      }
+    }
+    function checkAttrs(block, attrs) {
+      for (var i = 0; i < attrs.length; i++) {
+        var attr = attrs[i]
+        if (attr.name === 'lang') {
+          block.lang = attr.value
+        }
+        if (attr.name === 'scoped') {
+          block.scoped = true
+        }
+        if (attr.name === 'module') {
+          block.module = attr.value || true
+        }
+        if (attr.name === 'src') {
+          block.src = attr.value
+        }
+      }
+    }
+    function end(tag, start) {
+      if (depth === 1 && currentBlock) {
+        currentBlock.end = start
+        var text = content.slice(currentBlock.start, currentBlock.end)
+        if (options.deindent !== false) {
+          text = deIndent(text)
+        }
+        // pad content so that linters and pre-processors can output correct
+        // line numbers in errors and warnings
+        if (currentBlock.type !== 'template' && options.pad) {
+          text = padContent(currentBlock, options.pad) + text
+        }
+        currentBlock.content = text
+        currentBlock = null
+      }
+      depth--
+    }
+    function padContent(block, pad) {
+      if (pad === 'space') {
+        return content.slice(0, block.start).replace(replaceRE, ' ')
+      } else {
+        var offset = content.slice(0, block.start).split(splitRE).length
+        var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
+        return Array(offset).join(padChar)
+      }
+    }
+    parseHTML(content, {
+      warn: warn,
+      start: start,
+      end: end,
+      outputSourceRange: options.outputSourceRange
+    })
+    return sfc
+  }
+
+  // can we use __proto__?
+  var hasProto = '__proto__' in {}
+  // Browser environment sniffing
+  var inBrowser = typeof window !== 'undefined'
+  var UA = inBrowser && window.navigator.userAgent.toLowerCase()
+  var isIE = UA && /msie|trident/.test(UA)
+  UA && UA.indexOf('msie 9.0') > 0
+  var isEdge = UA && UA.indexOf('edge/') > 0
+  UA && UA.indexOf('android') > 0
+  UA && /iphone|ipad|ipod|ios/.test(UA)
+  UA && /chrome\/\d+/.test(UA) && !isEdge
+  UA && /phantomjs/.test(UA)
+  UA && UA.match(/firefox\/(\d+)/)
+  // Firefox has a "watch" function on Object.prototype...
+  // @ts-expect-error firebox support
+  var nativeWatch = {}.watch
+  var supportsPassive = false
+  if (inBrowser) {
+    try {
+      var opts = {}
+      Object.defineProperty(opts, 'passive', {
+        get: function () {
+          /* istanbul ignore next */
+          supportsPassive = true
+        }
+      }) // https://github.com/facebook/flow/issues/285
+      window.addEventListener('test-passive', null, opts)
+    } catch (e) {}
+  }
+  // this needs to be lazy-evaled because vue may be required before
+  // vue-server-renderer can set VUE_ENV
+  var _isServer
+  var isServerRendering = function () {
+    if (_isServer === undefined) {
+      /* istanbul ignore if */
+      if (!inBrowser && typeof global !== 'undefined') {
+        // detect presence of vue-server-renderer and avoid
+        // Webpack shimming the process
+        _isServer =
+          global['process'] && global['process'].env.VUE_ENV === 'server'
+      } else {
+        _isServer = false
+      }
+    }
+    return _isServer
+  }
+  /* istanbul ignore next */
+  function isNative(Ctor) {
+    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
+  }
+  var hasSymbol =
+    typeof Symbol !== 'undefined' &&
+    isNative(Symbol) &&
+    typeof Reflect !== 'undefined' &&
+    isNative(Reflect.ownKeys)
+  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set));
+  else {
+    // a non-standard Set polyfill that only works with primitive keys.
+    /** @class */ ;(function () {
+      function Set() {
+        this.set = Object.create(null)
+      }
+      Set.prototype.has = function (key) {
+        return this.set[key] === true
+      }
+      Set.prototype.add = function (key) {
+        this.set[key] = true
+      }
+      Set.prototype.clear = function () {
+        this.set = Object.create(null)
+      }
+      return Set
+    })()
+  }
+
+  var ASSET_TYPES = ['component', 'directive', 'filter']
+  var LIFECYCLE_HOOKS = [
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeUpdate',
+    'updated',
+    'beforeDestroy',
+    'destroyed',
+    'activated',
+    'deactivated',
+    'errorCaptured',
+    'serverPrefetch'
+  ]
+
+  var config = {
+    /**
+     * Option merge strategies (used in core/util/options)
+     */
+    // $flow-disable-line
+    optionMergeStrategies: Object.create(null),
+    /**
+     * Whether to suppress warnings.
+     */
+    silent: false,
+    /**
+     * Show production mode tip message on boot?
+     */
+    productionTip: 'development' !== 'production',
+    /**
+     * Whether to enable devtools
+     */
+    devtools: 'development' !== 'production',
+    /**
+     * Whether to record perf
+     */
+    performance: false,
+    /**
+     * Error handler for watcher errors
+     */
+    errorHandler: null,
+    /**
+     * Warn handler for watcher warns
+     */
+    warnHandler: null,
+    /**
+     * Ignore certain custom elements
+     */
+    ignoredElements: [],
+    /**
+     * Custom user key aliases for v-on
+     */
+    // $flow-disable-line
+    keyCodes: Object.create(null),
+    /**
+     * Check if a tag is reserved so that it cannot be registered as a
+     * component. This is platform-dependent and may be overwritten.
+     */
+    isReservedTag: no,
+    /**
+     * Check if an attribute is reserved so that it cannot be used as a component
+     * prop. This is platform-dependent and may be overwritten.
+     */
+    isReservedAttr: no,
+    /**
+     * Check if a tag is an unknown element.
+     * Platform-dependent.
+     */
+    isUnknownElement: no,
+    /**
+     * Get the namespace of an element
+     */
+    getTagNamespace: noop,
+    /**
+     * Parse the real tag name for the specific platform.
+     */
+    parsePlatformTagName: identity,
+    /**
+     * Check if an attribute must be bound using property, e.g. value
+     * Platform-dependent.
+     */
+    mustUseProp: no,
+    /**
+     * Perform updates asynchronously. Intended to be used by Vue Test Utils
+     * This will significantly reduce performance if set to false.
+     */
+    async: true,
+    /**
+     * Exposed for legacy reasons
+     */
+    _lifecycleHooks: LIFECYCLE_HOOKS
+  }
+
+  var warn$2 = noop
+  var tip = noop
+  var generateComponentTrace // work around flow check
+  var formatComponentName
+  {
+    var hasConsole_1 = typeof console !== 'undefined'
+    var classifyRE_1 = /(?:^|[-_])(\w)/g
+    var classify_1 = function (str) {
+      return str
+        .replace(classifyRE_1, function (c) {
+          return c.toUpperCase()
+        })
+        .replace(/[-_]/g, '')
+    }
+    warn$2 = function (msg, vm) {
+      var trace = vm ? generateComponentTrace(vm) : ''
+      if (hasConsole_1 && !config.silent) {
+        console.error('[Vue warn]: '.concat(msg).concat(trace))
+      }
+    }
+    tip = function (msg, vm) {
+      if (hasConsole_1 && !config.silent) {
+        console.warn(
+          '[Vue tip]: '.concat(msg) + (vm ? generateComponentTrace(vm) : '')
+        )
+      }
+    }
+    formatComponentName = function (vm, includeFile) {
+      if (vm.$root === vm) {
+        return '<Root>'
+      }
+      var options =
+        typeof vm === 'function' && vm.cid != null
+          ? vm.options
+          : vm._isVue
+          ? vm.$options || vm.constructor.options
+          : vm
+      var name = options.name || options._componentTag
+      var file = options.__file
+      if (!name && file) {
+        var match = file.match(/([^/\\]+)\.vue$/)
+        name = match && match[1]
+      }
+      return (
+        (name ? '<'.concat(classify_1(name), '>') : '<Anonymous>') +
+        (file && includeFile !== false ? ' at '.concat(file) : '')
+      )
+    }
+    var repeat_1 = function (str, n) {
+      var res = ''
+      while (n) {
+        if (n % 2 === 1) res += str
+        if (n > 1) str += str
+        n >>= 1
+      }
+      return res
+    }
+    generateComponentTrace = function (vm) {
+      if (vm._isVue && vm.$parent) {
+        var tree = []
+        var currentRecursiveSequence = 0
+        while (vm) {
+          if (tree.length > 0) {
+            var last = tree[tree.length - 1]
+            if (last.constructor === vm.constructor) {
+              currentRecursiveSequence++
+              vm = vm.$parent
+              continue
+            } else if (currentRecursiveSequence > 0) {
+              tree[tree.length - 1] = [last, currentRecursiveSequence]
+              currentRecursiveSequence = 0
+            }
+          }
+          tree.push(vm)
+          vm = vm.$parent
+        }
+        return (
+          '\n\nfound in\n\n' +
+          tree
+            .map(function (vm, i) {
+              return ''
+                .concat(i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2))
+                .concat(
+                  Array.isArray(vm)
+                    ? ''
+                        .concat(formatComponentName(vm[0]), '... (')
+                        .concat(vm[1], ' recursive calls)')
+                    : formatComponentName(vm)
+                )
+            })
+            .join('\n')
+        )
+      } else {
+        return '\n\n(found in '.concat(formatComponentName(vm), ')')
+      }
+    }
+  }
+
+  var uid = 0
+  /**
+   * A dep is an observable that can have multiple
+   * directives subscribing to it.
+   */
+  var Dep = /** @class */ (function () {
+    function Dep() {
+      this.id = uid++
+      this.subs = []
+    }
+    Dep.prototype.addSub = function (sub) {
+      this.subs.push(sub)
+    }
+    Dep.prototype.removeSub = function (sub) {
+      remove(this.subs, sub)
+    }
+    Dep.prototype.depend = function () {
+      if (Dep.target) {
+        Dep.target.addDep(this)
+      }
+    }
+    Dep.prototype.notify = function () {
+      // stabilize the subscriber list first
+      var subs = this.subs.slice()
+      for (var i = 0, l = subs.length; i < l; i++) {
+        subs[i].update()
+      }
+    }
+    return Dep
+  })()
+  // The current target watcher being evaluated.
+  // This is globally unique because only one watcher
+  // can be evaluated at a time.
+  Dep.target = null
+
+  var VNode = /** @class */ (function () {
+    function VNode(
+      tag,
+      data,
+      children,
+      text,
+      elm,
+      context,
+      componentOptions,
+      asyncFactory
+    ) {
+      this.tag = tag
+      this.data = data
+      this.children = children
+      this.text = text
+      this.elm = elm
+      this.ns = undefined
+      this.context = context
+      this.fnContext = undefined
+      this.fnOptions = undefined
+      this.fnScopeId = undefined
+      this.key = data && data.key
+      this.componentOptions = componentOptions
+      this.componentInstance = undefined
+      this.parent = undefined
+      this.raw = false
+      this.isStatic = false
+      this.isRootInsert = true
+      this.isComment = false
+      this.isCloned = false
+      this.isOnce = false
+      this.asyncFactory = asyncFactory
+      this.asyncMeta = undefined
+      this.isAsyncPlaceholder = false
+    }
+    Object.defineProperty(VNode.prototype, 'child', {
+      // DEPRECATED: alias for componentInstance for backwards compat.
+      /* istanbul ignore next */
+      get: function () {
+        return this.componentInstance
+      },
+      enumerable: false,
+      configurable: true
+    })
+    return VNode
+  })()
+
+  /*
+   * not type checking this file because flow doesn't play well with
+   * dynamically accessing methods on Array prototype
+   */
+  var arrayProto = Array.prototype
+  var arrayMethods = Object.create(arrayProto)
+  var methodsToPatch = [
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse'
+  ]
+  /**
+   * Intercept mutating methods and emit events
+   */
+  methodsToPatch.forEach(function (method) {
+    // cache original method
+    var original = arrayProto[method]
+    def(arrayMethods, method, function mutator() {
+      var args = []
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i]
+      }
+      var result = original.apply(this, args)
+      var ob = this.__ob__
+      var inserted
+      switch (method) {
+        case 'push':
+        case 'unshift':
+          inserted = args
+          break
+        case 'splice':
+          inserted = args.slice(2)
+          break
+      }
+      if (inserted) ob.observeArray(inserted)
+      // notify change
+      ob.dep.notify()
+      return result
+    })
+  })
+
+  var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+  /**
+   * Observer class that is attached to each observed
+   * object. Once attached, the observer converts the target
+   * object's property keys into getter/setters that
+   * collect dependencies and dispatch updates.
+   */
+  var Observer = /** @class */ (function () {
+    function Observer(value) {
+      this.value = value
+      this.dep = new Dep()
+      this.vmCount = 0
+      def(value, '__ob__', this)
+      if (Array.isArray(value)) {
+        if (hasProto) {
+          protoAugment(value, arrayMethods)
+        } else {
+          copyAugment(value, arrayMethods, arrayKeys)
+        }
+        this.observeArray(value)
+      } else {
+        this.walk(value)
+      }
+    }
+    /**
+     * Walk through all properties and convert them into
+     * getter/setters. This method should only be called when
+     * value type is Object.
+     */
+    Observer.prototype.walk = function (obj) {
+      var keys = Object.keys(obj)
+      for (var i = 0; i < keys.length; i++) {
+        defineReactive(obj, keys[i])
+      }
+    }
+    /**
+     * Observe a list of Array items.
+     */
+    Observer.prototype.observeArray = function (items) {
+      for (var i = 0, l = items.length; i < l; i++) {
+        observe(items[i])
+      }
+    }
+    return Observer
+  })()
+  // helpers
+  /**
+   * Augment a target Object or Array by intercepting
+   * the prototype chain using __proto__
+   */
+  function protoAugment(target, src) {
+    /* eslint-disable no-proto */
+    target.__proto__ = src
+    /* eslint-enable no-proto */
+  }
+  /**
+   * Augment a target Object or Array by defining
+   * hidden properties.
+   */
+  /* istanbul ignore next */
+  function copyAugment(target, src, keys) {
+    for (var i = 0, l = keys.length; i < l; i++) {
+      var key = keys[i]
+      def(target, key, src[key])
+    }
+  }
+  /**
+   * Attempt to create an observer instance for a value,
+   * returns the new observer if successfully observed,
+   * or the existing observer if the value already has one.
+   */
+  function observe(value, asRootData) {
+    if (!isObject(value) || value instanceof VNode) {
+      return
+    }
+    var ob
+    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+      ob = value.__ob__
+    } else if (
+      !isServerRendering() &&
+      (Array.isArray(value) || isPlainObject(value)) &&
+      Object.isExtensible(value) &&
+      !value._isVue
+    ) {
+      ob = new Observer(value)
+    }
+    if (asRootData && ob) {
+      ob.vmCount++
+    }
+    return ob
+  }
+  /**
+   * Define a reactive property on an Object.
+   */
+  function defineReactive(obj, key, val, customSetter, shallow) {
+    var dep = new Dep()
+    var property = Object.getOwnPropertyDescriptor(obj, key)
+    if (property && property.configurable === false) {
+      return
+    }
+    // cater for pre-defined getter/setters
+    var getter = property && property.get
+    var setter = property && property.set
+    if ((!getter || setter) && arguments.length === 2) {
+      val = obj[key]
+    }
+    var childOb = !shallow && observe(val)
+    Object.defineProperty(obj, key, {
+      enumerable: true,
+      configurable: true,
+      get: function reactiveGetter() {
+        var value = getter ? getter.call(obj) : val
+        if (Dep.target) {
+          dep.depend()
+          if (childOb) {
+            childOb.dep.depend()
+            if (Array.isArray(value)) {
+              dependArray(value)
+            }
+          }
+        }
+        return value
+      },
+      set: function reactiveSetter(newVal) {
+        var value = getter ? getter.call(obj) : val
+        /* eslint-disable no-self-compare */
+        if (newVal === value || (newVal !== newVal && value !== value)) {
+          return
+        }
+        /* eslint-enable no-self-compare */
+        if (customSetter) {
+          customSetter()
+        }
+        // #7981: for accessor properties without setter
+        if (getter && !setter) return
+        if (setter) {
+          setter.call(obj, newVal)
+        } else {
+          val = newVal
+        }
+        childOb = !shallow && observe(newVal)
+        dep.notify()
+      }
+    })
+  }
+  /**
+   * Set a property on an object. Adds the new property and
+   * triggers change notification if the property doesn't
+   * already exist.
+   */
+  function set(target, key, val) {
+    if (isUndef(target) || isPrimitive(target)) {
+      warn$2(
+        'Cannot set reactive property on undefined, null, or primitive value: '.concat(
+          target
+        )
+      )
+    }
+    if (Array.isArray(target) && isValidArrayIndex(key)) {
+      target.length = Math.max(target.length, key)
+      target.splice(key, 1, val)
+      return val
+    }
+    if (key in target && !(key in Object.prototype)) {
+      target[key] = val
+      return val
+    }
+    var ob = target.__ob__
+    if (target._isVue || (ob && ob.vmCount)) {
+      warn$2(
+        'Avoid adding reactive properties to a Vue instance or its root $data ' +
+          'at runtime - declare it upfront in the data option.'
+      )
+      return val
+    }
+    if (!ob) {
+      target[key] = val
+      return val
+    }
+    defineReactive(ob.value, key, val)
+    ob.dep.notify()
+    return val
+  }
+  /**
+   * Collect dependencies on array elements when the array is touched, since
+   * we cannot intercept array element access like property getters.
+   */
+  function dependArray(value) {
+    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+      e = value[i]
+      e && e.__ob__ && e.__ob__.dep.depend()
+      if (Array.isArray(e)) {
+        dependArray(e)
+      }
+    }
+  }
+
+  /**
+   * Option overwriting strategies are functions that handle
+   * how to merge a parent option value and a child option
+   * value into the final value.
+   */
+  var strats = config.optionMergeStrategies
+  /**
+   * Options with restrictions
+   */
+  {
+    strats.el = strats.propsData = function (parent, child, vm, key) {
+      if (!vm) {
+        warn$2(
+          'option "'.concat(key, '" can only be used during instance ') +
+            'creation with the `new` keyword.'
+        )
+      }
+      return defaultStrat(parent, child)
+    }
+  }
+  /**
+   * Helper that recursively merges two data objects together.
+   */
+  function mergeData(to, from) {
+    if (!from) return to
+    var key, toVal, fromVal
+    var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from)
+    for (var i = 0; i < keys.length; i++) {
+      key = keys[i]
+      // in case the object is already observed...
+      if (key === '__ob__') continue
+      toVal = to[key]
+      fromVal = from[key]
+      if (!hasOwn(to, key)) {
+        set(to, key, fromVal)
+      } else if (
+        toVal !== fromVal &&
+        isPlainObject(toVal) &&
+        isPlainObject(fromVal)
+      ) {
+        mergeData(toVal, fromVal)
+      }
+    }
+    return to
+  }
+  /**
+   * Data
+   */
+  function mergeDataOrFn(parentVal, childVal, vm) {
+    if (!vm) {
+      // in a Vue.extend merge, both should be functions
+      if (!childVal) {
+        return parentVal
+      }
+      if (!parentVal) {
+        return childVal
+      }
+      // when parentVal & childVal are both present,
+      // we need to return a function that returns the
+      // merged result of both functions... no need to
+      // check if parentVal is a function here because
+      // it has to be a function to pass previous merges.
+      return function mergedDataFn() {
+        return mergeData(
+          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
+          typeof parentVal === 'function'
+            ? parentVal.call(this, this)
+            : parentVal
+        )
+      }
+    } else {
+      return function mergedInstanceDataFn() {
+        // instance merge
+        var instanceData =
+          typeof childVal === 'function' ? childVal.call(vm, vm) : childVal
+        var defaultData =
+          typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal
+        if (instanceData) {
+          return mergeData(instanceData, defaultData)
+        } else {
+          return defaultData
+        }
+      }
+    }
+  }
+  strats.data = function (parentVal, childVal, vm) {
+    if (!vm) {
+      if (childVal && typeof childVal !== 'function') {
+        warn$2(
+          'The "data" option should be a function ' +
+            'that returns a per-instance value in component ' +
+            'definitions.',
+          vm
+        )
+        return parentVal
+      }
+      return mergeDataOrFn(parentVal, childVal)
+    }
+    return mergeDataOrFn(parentVal, childVal, vm)
+  }
+  /**
+   * Hooks and props are merged as arrays.
+   */
+  function mergeHook(parentVal, childVal) {
+    var res = childVal
+      ? parentVal
+        ? parentVal.concat(childVal)
+        : Array.isArray(childVal)
+        ? childVal
+        : [childVal]
+      : parentVal
+    return res ? dedupeHooks(res) : res
+  }
+  function dedupeHooks(hooks) {
+    var res = []
+    for (var i = 0; i < hooks.length; i++) {
+      if (res.indexOf(hooks[i]) === -1) {
+        res.push(hooks[i])
+      }
+    }
+    return res
+  }
+  LIFECYCLE_HOOKS.forEach(function (hook) {
+    strats[hook] = mergeHook
+  })
+  /**
+   * Assets
+   *
+   * When a vm is present (instance creation), we need to do
+   * a three-way merge between constructor options, instance
+   * options and parent options.
+   */
+  function mergeAssets(parentVal, childVal, vm, key) {
+    var res = Object.create(parentVal || null)
+    if (childVal) {
+      assertObjectType(key, childVal, vm)
+      return extend(res, childVal)
+    } else {
+      return res
+    }
+  }
+  ASSET_TYPES.forEach(function (type) {
+    strats[type + 's'] = mergeAssets
+  })
+  /**
+   * Watchers.
+   *
+   * Watchers hashes should not overwrite one
+   * another, so we merge them as arrays.
+   */
+  strats.watch = function (parentVal, childVal, vm, key) {
+    // work around Firefox's Object.prototype.watch...
+    //@ts-expect-error work around
+    if (parentVal === nativeWatch) parentVal = undefined
+    //@ts-expect-error work around
+    if (childVal === nativeWatch) childVal = undefined
+    /* istanbul ignore if */
+    if (!childVal) return Object.create(parentVal || null)
+    {
+      assertObjectType(key, childVal, vm)
+    }
+    if (!parentVal) return childVal
+    var ret = {}
+    extend(ret, parentVal)
+    for (var key_1 in childVal) {
+      var parent_1 = ret[key_1]
+      var child = childVal[key_1]
+      if (parent_1 && !Array.isArray(parent_1)) {
+        parent_1 = [parent_1]
+      }
+      ret[key_1] = parent_1
+        ? parent_1.concat(child)
+        : Array.isArray(child)
+        ? child
+        : [child]
+    }
+    return ret
+  }
+  /**
+   * Other object hashes.
+   */
+  strats.props =
+    strats.methods =
+    strats.inject =
+    strats.computed =
+      function (parentVal, childVal, vm, key) {
+        if (childVal && 'development' !== 'production') {
+          assertObjectType(key, childVal, vm)
+        }
+        if (!parentVal) return childVal
+        var ret = Object.create(null)
+        extend(ret, parentVal)
+        if (childVal) extend(ret, childVal)
+        return ret
+      }
+  strats.provide = mergeDataOrFn
+  /**
+   * Default strategy.
+   */
+  var defaultStrat = function (parentVal, childVal) {
+    return childVal === undefined ? parentVal : childVal
+  }
+  function assertObjectType(name, value, vm) {
+    if (!isPlainObject(value)) {
+      warn$2(
+        'Invalid value for option "'.concat(name, '": expected an Object, ') +
+          'but got '.concat(toRawType(value), '.'),
+        vm
+      )
+    }
+  }
+
+  /* globals MutationObserver */
+  var callbacks = []
+  function flushCallbacks() {
+    var copies = callbacks.slice(0)
+    callbacks.length = 0
+    for (var i = 0; i < copies.length; i++) {
+      copies[i]()
+    }
+  }
+  // The nextTick behavior leverages the microtask queue, which can be accessed
+  // via either native Promise.then or MutationObserver.
+  // MutationObserver has wider support, however it is seriously bugged in
+  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+  // completely stops working after triggering a few times... so, if native
+  // Promise is available, we will use it:
+  /* istanbul ignore next, $flow-disable-line */
+  if (typeof Promise !== 'undefined' && isNative(Promise)) {
+    Promise.resolve()
+  } else if (
+    !isIE &&
+    typeof MutationObserver !== 'undefined' &&
+    (isNative(MutationObserver) ||
+      // PhantomJS and iOS 7.x
+      MutationObserver.toString() === '[object MutationObserverConstructor]')
+  ) {
+    // Use MutationObserver where native Promise is not available,
+    // e.g. PhantomJS, iOS7, Android 4.4
+    // (#6466 MutationObserver is unreliable in IE11)
+    var counter_1 = 1
+    var observer = new MutationObserver(flushCallbacks)
+    var textNode_1 = document.createTextNode(String(counter_1))
+    observer.observe(textNode_1, {
+      characterData: true
+    })
+  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate));
+  else;
+
+  // these are reserved for web because they are directly compiled away
+  // during template compilation
+  makeMap('style,class')
+  // attributes that should be using props for binding
+  var acceptValue = makeMap('input,textarea,option,select,progress')
+  var mustUseProp = function (tag, type, attr) {
+    return (
+      (attr === 'value' && acceptValue(tag) && type !== 'button') ||
+      (attr === 'selected' && tag === 'option') ||
+      (attr === 'checked' && tag === 'input') ||
+      (attr === 'muted' && tag === 'video')
+    )
+  }
+  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
+  makeMap('events,caret,typing,plaintext-only')
+  var isBooleanAttr = makeMap(
+    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+      'required,reversed,scoped,seamless,selected,sortable,' +
+      'truespeed,typemustmatch,visible'
+  )
+
+  var isHTMLTag = makeMap(
+    'html,body,base,head,link,meta,style,title,' +
+      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+      'embed,object,param,source,canvas,script,noscript,del,ins,' +
+      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+      'output,progress,select,textarea,' +
+      'details,dialog,menu,menuitem,summary,' +
+      'content,element,shadow,template,blockquote,iframe,tfoot'
+  )
+  // this map is intentionally selective, only covering SVG elements that may
+  // contain child elements.
+  var isSVG = makeMap(
+    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
+    true
+  )
+  var isPreTag = function (tag) {
+    return tag === 'pre'
+  }
+  var isReservedTag = function (tag) {
+    return isHTMLTag(tag) || isSVG(tag)
+  }
+  function getTagNamespace(tag) {
+    if (isSVG(tag)) {
+      return 'svg'
+    }
+    // basic support for MathML
+    // note it doesn't support other MathML elements being component roots
+    if (tag === 'math') {
+      return 'math'
+    }
+  }
+  makeMap('text,number,password,search,email,tel,url')
+
+  var validDivisionCharRE = /[\w).+\-_$\]]/
+  function parseFilters(exp) {
+    var inSingle = false
+    var inDouble = false
+    var inTemplateString = false
+    var inRegex = false
+    var curly = 0
+    var square = 0
+    var paren = 0
+    var lastFilterIndex = 0
+    var c, prev, i, expression, filters
+    for (i = 0; i < exp.length; i++) {
+      prev = c
+      c = exp.charCodeAt(i)
+      if (inSingle) {
+        if (c === 0x27 && prev !== 0x5c) inSingle = false
+      } else if (inDouble) {
+        if (c === 0x22 && prev !== 0x5c) inDouble = false
+      } else if (inTemplateString) {
+        if (c === 0x60 && prev !== 0x5c) inTemplateString = false
+      } else if (inRegex) {
+        if (c === 0x2f && prev !== 0x5c) inRegex = false
+      } else if (
+        c === 0x7c && // pipe
+        exp.charCodeAt(i + 1) !== 0x7c &&
+        exp.charCodeAt(i - 1) !== 0x7c &&
+        !curly &&
+        !square &&
+        !paren
+      ) {
+        if (expression === undefined) {
+          // first filter, end of expression
+          lastFilterIndex = i + 1
+          expression = exp.slice(0, i).trim()
+        } else {
+          pushFilter()
+        }
+      } else {
+        switch (c) {
+          case 0x22:
+            inDouble = true
+            break // "
+          case 0x27:
+            inSingle = true
+            break // '
+          case 0x60:
+            inTemplateString = true
+            break // `
+          case 0x28:
+            paren++
+            break // (
+          case 0x29:
+            paren--
+            break // )
+          case 0x5b:
+            square++
+            break // [
+          case 0x5d:
+            square--
+            break // ]
+          case 0x7b:
+            curly++
+            break // {
+          case 0x7d:
+            curly--
+            break // }
+        }
+        if (c === 0x2f) {
+          // /
+          var j = i - 1
+          var p =
+            // find first non-whitespace prev char
+            void 0
+          // find first non-whitespace prev char
+          for (; j >= 0; j--) {
+            p = exp.charAt(j)
+            if (p !== ' ') break
+          }
+          if (!p || !validDivisionCharRE.test(p)) {
+            inRegex = true
+          }
+        }
+      }
+    }
+    if (expression === undefined) {
+      expression = exp.slice(0, i).trim()
+    } else if (lastFilterIndex !== 0) {
+      pushFilter()
+    }
+    function pushFilter() {
+      ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
+      lastFilterIndex = i + 1
+    }
+    if (filters) {
+      for (i = 0; i < filters.length; i++) {
+        expression = wrapFilter(expression, filters[i])
+      }
+    }
+    return expression
+  }
+  function wrapFilter(exp, filter) {
+    var i = filter.indexOf('(')
+    if (i < 0) {
+      // _f: resolveFilter
+      return '_f("'.concat(filter, '")(').concat(exp, ')')
+    } else {
+      var name_1 = filter.slice(0, i)
+      var args = filter.slice(i + 1)
+      return '_f("'
+        .concat(name_1, '")(')
+        .concat(exp)
+        .concat(args !== ')' ? ',' + args : args)
+    }
+  }
+
+  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
+  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
+  var buildRegex = cached(function (delimiters) {
+    var open = delimiters[0].replace(regexEscapeRE, '\\$&')
+    var close = delimiters[1].replace(regexEscapeRE, '\\$&')
+    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+  })
+  function parseText(text, delimiters) {
+    //@ts-expect-error
+    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
+    if (!tagRE.test(text)) {
+      return
+    }
+    var tokens = []
+    var rawTokens = []
+    var lastIndex = (tagRE.lastIndex = 0)
+    var match, index, tokenValue
+    while ((match = tagRE.exec(text))) {
+      index = match.index
+      // push text token
+      if (index > lastIndex) {
+        rawTokens.push((tokenValue = text.slice(lastIndex, index)))
+        tokens.push(JSON.stringify(tokenValue))
+      }
+      // tag token
+      var exp = parseFilters(match[1].trim())
+      tokens.push('_s('.concat(exp, ')'))
+      rawTokens.push({ '@binding': exp })
+      lastIndex = index + match[0].length
+    }
+    if (lastIndex < text.length) {
+      rawTokens.push((tokenValue = text.slice(lastIndex)))
+      tokens.push(JSON.stringify(tokenValue))
+    }
+    return {
+      expression: tokens.join('+'),
+      tokens: rawTokens
+    }
+  }
+
+  /* eslint-disable no-unused-vars */
+  function baseWarn(msg, range) {
+    console.error('[Vue compiler]: '.concat(msg))
+  }
+  /* eslint-enable no-unused-vars */
+  function pluckModuleFunction(modules, key) {
+    return modules
+      ? modules
+          .map(function (m) {
+            return m[key]
+          })
+          .filter(function (_) {
+            return _
+          })
+      : []
+  }
+  function addProp(el, name, value, range, dynamic) {
+    ;(el.props || (el.props = [])).push(
+      rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
+    )
+    el.plain = false
+  }
+  function addAttr(el, name, value, range, dynamic) {
+    var attrs = dynamic
+      ? el.dynamicAttrs || (el.dynamicAttrs = [])
+      : el.attrs || (el.attrs = [])
+    attrs.push(
+      rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
+    )
+    el.plain = false
+  }
+  // add a raw attr (use this in preTransforms)
+  function addRawAttr(el, name, value, range) {
+    el.attrsMap[name] = value
+    el.attrsList.push(rangeSetItem({ name: name, value: value }, range))
+  }
+  function addDirective(
+    el,
+    name,
+    rawName,
+    value,
+    arg,
+    isDynamicArg,
+    modifiers,
+    range
+  ) {
+    ;(el.directives || (el.directives = [])).push(
+      rangeSetItem(
+        {
+          name: name,
+          rawName: rawName,
+          value: value,
+          arg: arg,
+          isDynamicArg: isDynamicArg,
+          modifiers: modifiers
+        },
+        range
+      )
+    )
+    el.plain = false
+  }
+  function prependModifierMarker(symbol, name, dynamic) {
+    return dynamic
+      ? '_p('.concat(name, ',"').concat(symbol, '")')
+      : symbol + name // mark the event as captured
+  }
+  function addHandler(
+    el,
+    name,
+    value,
+    modifiers,
+    important,
+    warn,
+    range,
+    dynamic
+  ) {
+    modifiers = modifiers || emptyObject
+    // warn prevent and passive modifier
+    /* istanbul ignore if */
+    if (warn && modifiers.prevent && modifiers.passive) {
+      warn(
+        "passive and prevent can't be used together. " +
+          "Passive handler can't prevent default event.",
+        range
+      )
+    }
+    // normalize click.right and click.middle since they don't actually fire
+    // this is technically browser-specific, but at least for now browsers are
+    // the only target envs that have right/middle clicks.
+    if (modifiers.right) {
+      if (dynamic) {
+        name = '('.concat(name, ")==='click'?'contextmenu':(").concat(name, ')')
+      } else if (name === 'click') {
+        name = 'contextmenu'
+        delete modifiers.right
+      }
+    } else if (modifiers.middle) {
+      if (dynamic) {
+        name = '('.concat(name, ")==='click'?'mouseup':(").concat(name, ')')
+      } else if (name === 'click') {
+        name = 'mouseup'
+      }
+    }
+    // check capture modifier
+    if (modifiers.capture) {
+      delete modifiers.capture
+      name = prependModifierMarker('!', name, dynamic)
+    }
+    if (modifiers.once) {
+      delete modifiers.once
+      name = prependModifierMarker('~', name, dynamic)
+    }
+    /* istanbul ignore if */
+    if (modifiers.passive) {
+      delete modifiers.passive
+      name = prependModifierMarker('&', name, dynamic)
+    }
+    var events
+    if (modifiers.native) {
+      delete modifiers.native
+      events = el.nativeEvents || (el.nativeEvents = {})
+    } else {
+      events = el.events || (el.events = {})
+    }
+    var newHandler = rangeSetItem(
+      { value: value.trim(), dynamic: dynamic },
+      range
+    )
+    if (modifiers !== emptyObject) {
+      newHandler.modifiers = modifiers
+    }
+    var handlers = events[name]
+    /* istanbul ignore if */
+    if (Array.isArray(handlers)) {
+      important ? handlers.unshift(newHandler) : handlers.push(newHandler)
+    } else if (handlers) {
+      events[name] = important ? [newHandler, handlers] : [handlers, newHandler]
+    } else {
+      events[name] = newHandler
+    }
+    el.plain = false
+  }
+  function getRawBindingAttr(el, name) {
+    return (
+      el.rawAttrsMap[':' + name] ||
+      el.rawAttrsMap['v-bind:' + name] ||
+      el.rawAttrsMap[name]
+    )
+  }
+  function getBindingAttr(el, name, getStatic) {
+    var dynamicValue =
+      getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
+    if (dynamicValue != null) {
+      return parseFilters(dynamicValue)
+    } else if (getStatic !== false) {
+      var staticValue = getAndRemoveAttr(el, name)
+      if (staticValue != null) {
+        return JSON.stringify(staticValue)
+      }
+    }
+  }
+  // note: this only removes the attr from the Array (attrsList) so that it
+  // doesn't get processed by processAttrs.
+  // By default it does NOT remove it from the map (attrsMap) because the map is
+  // needed during codegen.
+  function getAndRemoveAttr(el, name, removeFromMap) {
+    var val
+    if ((val = el.attrsMap[name]) != null) {
+      var list = el.attrsList
+      for (var i = 0, l = list.length; i < l; i++) {
+        if (list[i].name === name) {
+          list.splice(i, 1)
+          break
+        }
+      }
+    }
+    if (removeFromMap) {
+      delete el.attrsMap[name]
+    }
+    return val
+  }
+  function getAndRemoveAttrByRegex(el, name) {
+    var list = el.attrsList
+    for (var i = 0, l = list.length; i < l; i++) {
+      var attr = list[i]
+      if (name.test(attr.name)) {
+        list.splice(i, 1)
+        return attr
+      }
+    }
+  }
+  function rangeSetItem(item, range) {
+    if (range) {
+      if (range.start != null) {
+        item.start = range.start
+      }
+      if (range.end != null) {
+        item.end = range.end
+      }
+    }
+    return item
+  }
+
+  function transformNode$1(el, options) {
+    var warn = options.warn || baseWarn
+    var staticClass = getAndRemoveAttr(el, 'class')
+    if (staticClass) {
+      var res = parseText(staticClass, options.delimiters)
+      if (res) {
+        warn(
+          'class="'.concat(staticClass, '": ') +
+            'Interpolation inside attributes has been removed. ' +
+            'Use v-bind or the colon shorthand instead. For example, ' +
+            'instead of <div class="{{ val }}">, use <div :class="val">.',
+          el.rawAttrsMap['class']
+        )
+      }
+    }
+    if (staticClass) {
+      el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim())
+    }
+    var classBinding = getBindingAttr(el, 'class', false /* getStatic */)
+    if (classBinding) {
+      el.classBinding = classBinding
+    }
+  }
+  function genData$2(el) {
+    var data = ''
+    if (el.staticClass) {
+      data += 'staticClass:'.concat(el.staticClass, ',')
+    }
+    if (el.classBinding) {
+      data += 'class:'.concat(el.classBinding, ',')
+    }
+    return data
+  }
+  var klass = {
+    staticKeys: ['staticClass'],
+    transformNode: transformNode$1,
+    genData: genData$2
+  }
+
+  var parseStyleText = cached(function (cssText) {
+    var res = {}
+    var listDelimiter = /;(?![^(]*\))/g
+    var propertyDelimiter = /:(.+)/
+    cssText.split(listDelimiter).forEach(function (item) {
+      if (item) {
+        var tmp = item.split(propertyDelimiter)
+        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim())
+      }
+    })
+    return res
+  })
+
+  function transformNode(el, options) {
+    var warn = options.warn || baseWarn
+    var staticStyle = getAndRemoveAttr(el, 'style')
+    if (staticStyle) {
+      /* istanbul ignore if */
+      {
+        var res = parseText(staticStyle, options.delimiters)
+        if (res) {
+          warn(
+            'style="'.concat(staticStyle, '": ') +
+              'Interpolation inside attributes has been removed. ' +
+              'Use v-bind or the colon shorthand instead. For example, ' +
+              'instead of <div style="{{ val }}">, use <div :style="val">.',
+            el.rawAttrsMap['style']
+          )
+        }
+      }
+      el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
+    }
+    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
+    if (styleBinding) {
+      el.styleBinding = styleBinding
+    }
+  }
+  function genData$1(el) {
+    var data = ''
+    if (el.staticStyle) {
+      data += 'staticStyle:'.concat(el.staticStyle, ',')
+    }
+    if (el.styleBinding) {
+      data += 'style:('.concat(el.styleBinding, '),')
+    }
+    return data
+  }
+  var style = {
+    staticKeys: ['staticStyle'],
+    transformNode: transformNode,
+    genData: genData$1
+  }
+
+  var he$1 = { exports: {} }
+
+  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
+
+  ;(function (module, exports) {
+    ;(function (root) {
+      // Detect free variables `exports`.
+      var freeExports = exports
+
+      // Detect free variable `module`.
+      var freeModule = module && module.exports == freeExports && module
+
+      // Detect free variable `global`, from Node.js or Browserified code,
+      // and use it as `root`.
+      var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal
+      if (
+        freeGlobal.global === freeGlobal ||
+        freeGlobal.window === freeGlobal
+      ) {
+        root = freeGlobal
+      }
+
+      /*--------------------------------------------------------------------------*/
+
+      // All astral symbols.
+      var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g
+      // All ASCII symbols (not just printable ASCII) except those listed in the
+      // first column of the overrides table.
+      // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
+      var regexAsciiWhitelist = /[\x01-\x7F]/g
+      // All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
+      // code points listed in the first column of the overrides table on
+      // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
+      var regexBmpWhitelist =
+        /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
+
+      var regexEncodeNonAscii =
+        /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g
+      var encodeMap = {
+        '\xAD': 'shy',
+        '\u200C': 'zwnj',
+        '\u200D': 'zwj',
+        '\u200E': 'lrm',
+        '\u2063': 'ic',
+        '\u2062': 'it',
+        '\u2061': 'af',
+        '\u200F': 'rlm',
+        '\u200B': 'ZeroWidthSpace',
+        '\u2060': 'NoBreak',
+        '\u0311': 'DownBreve',
+        '\u20DB': 'tdot',
+        '\u20DC': 'DotDot',
+        '\t': 'Tab',
+        '\n': 'NewLine',
+        '\u2008': 'puncsp',
+        '\u205F': 'MediumSpace',
+        '\u2009': 'thinsp',
+        '\u200A': 'hairsp',
+        '\u2004': 'emsp13',
+        '\u2002': 'ensp',
+        '\u2005': 'emsp14',
+        '\u2003': 'emsp',
+        '\u2007': 'numsp',
+        '\xA0': 'nbsp',
+        '\u205F\u200A': 'ThickSpace',
+        '\u203E': 'oline',
+        _: 'lowbar',
+        '\u2010': 'dash',
+        '\u2013': 'ndash',
+        '\u2014': 'mdash',
+        '\u2015': 'horbar',
+        ',': 'comma',
+        ';': 'semi',
+        '\u204F': 'bsemi',
+        ':': 'colon',
+        '\u2A74': 'Colone',
+        '!': 'excl',
+        '\xA1': 'iexcl',
+        '?': 'quest',
+        '\xBF': 'iquest',
+        '.': 'period',
+        '\u2025': 'nldr',
+        '\u2026': 'mldr',
+        '\xB7': 'middot',
+        "'": 'apos',
+        '\u2018': 'lsquo',
+        '\u2019': 'rsquo',
+        '\u201A': 'sbquo',
+        '\u2039': 'lsaquo',
+        '\u203A': 'rsaquo',
+        '"': 'quot',
+        '\u201C': 'ldquo',
+        '\u201D': 'rdquo',
+        '\u201E': 'bdquo',
+        '\xAB': 'laquo',
+        '\xBB': 'raquo',
+        '(': 'lpar',
+        ')': 'rpar',
+        '[': 'lsqb',
+        ']': 'rsqb',
+        '{': 'lcub',
+        '}': 'rcub',
+        '\u2308': 'lceil',
+        '\u2309': 'rceil',
+        '\u230A': 'lfloor',
+        '\u230B': 'rfloor',
+        '\u2985': 'lopar',
+        '\u2986': 'ropar',
+        '\u298B': 'lbrke',
+        '\u298C': 'rbrke',
+        '\u298D': 'lbrkslu',
+        '\u298E': 'rbrksld',
+        '\u298F': 'lbrksld',
+        '\u2990': 'rbrkslu',
+        '\u2991': 'langd',
+        '\u2992': 'rangd',
+        '\u2993': 'lparlt',
+        '\u2994': 'rpargt',
+        '\u2995': 'gtlPar',
+        '\u2996': 'ltrPar',
+        '\u27E6': 'lobrk',
+        '\u27E7': 'robrk',
+        '\u27E8': 'lang',
+        '\u27E9': 'rang',
+        '\u27EA': 'Lang',
+        '\u27EB': 'Rang',
+        '\u27EC': 'loang',
+        '\u27ED': 'roang',
+        '\u2772': 'lbbrk',
+        '\u2773': 'rbbrk',
+        '\u2016': 'Vert',
+        '\xA7': 'sect',
+        '\xB6': 'para',
+        '@': 'commat',
+        '*': 'ast',
+        '/': 'sol',
+        undefined: null,
+        '&': 'amp',
+        '#': 'num',
+        '%': 'percnt',
+        '\u2030': 'permil',
+        '\u2031': 'pertenk',
+        '\u2020': 'dagger',
+        '\u2021': 'Dagger',
+        '\u2022': 'bull',
+        '\u2043': 'hybull',
+        '\u2032': 'prime',
+        '\u2033': 'Prime',
+        '\u2034': 'tprime',
+        '\u2057': 'qprime',
+        '\u2035': 'bprime',
+        '\u2041': 'caret',
+        '`': 'grave',
+        '\xB4': 'acute',
+        '\u02DC': 'tilde',
+        '^': 'Hat',
+        '\xAF': 'macr',
+        '\u02D8': 'breve',
+        '\u02D9': 'dot',
+        '\xA8': 'die',
+        '\u02DA': 'ring',
+        '\u02DD': 'dblac',
+        '\xB8': 'cedil',
+        '\u02DB': 'ogon',
+        '\u02C6': 'circ',
+        '\u02C7': 'caron',
+        '\xB0': 'deg',
+        '\xA9': 'copy',
+        '\xAE': 'reg',
+        '\u2117': 'copysr',
+        '\u2118': 'wp',
+        '\u211E': 'rx',
+        '\u2127': 'mho',
+        '\u2129': 'iiota',
+        '\u2190': 'larr',
+        '\u219A': 'nlarr',
+        '\u2192': 'rarr',
+        '\u219B': 'nrarr',
+        '\u2191': 'uarr',
+        '\u2193': 'darr',
+        '\u2194': 'harr',
+        '\u21AE': 'nharr',
+        '\u2195': 'varr',
+        '\u2196': 'nwarr',
+        '\u2197': 'nearr',
+        '\u2198': 'searr',
+        '\u2199': 'swarr',
+        '\u219D': 'rarrw',
+        '\u219D\u0338': 'nrarrw',
+        '\u219E': 'Larr',
+        '\u219F': 'Uarr',
+        '\u21A0': 'Rarr',
+        '\u21A1': 'Darr',
+        '\u21A2': 'larrtl',
+        '\u21A3': 'rarrtl',
+        '\u21A4': 'mapstoleft',
+        '\u21A5': 'mapstoup',
+        '\u21A6': 'map',
+        '\u21A7': 'mapstodown',
+        '\u21A9': 'larrhk',
+        '\u21AA': 'rarrhk',
+        '\u21AB': 'larrlp',
+        '\u21AC': 'rarrlp',
+        '\u21AD': 'harrw',
+        '\u21B0': 'lsh',
+        '\u21B1': 'rsh',
+        '\u21B2': 'ldsh',
+        '\u21B3': 'rdsh',
+        '\u21B5': 'crarr',
+        '\u21B6': 'cularr',
+        '\u21B7': 'curarr',
+        '\u21BA': 'olarr',
+        '\u21BB': 'orarr',
+        '\u21BC': 'lharu',
+        '\u21BD': 'lhard',
+        '\u21BE': 'uharr',
+        '\u21BF': 'uharl',
+        '\u21C0': 'rharu',
+        '\u21C1': 'rhard',
+        '\u21C2': 'dharr',
+        '\u21C3': 'dharl',
+        '\u21C4': 'rlarr',
+        '\u21C5': 'udarr',
+        '\u21C6': 'lrarr',
+        '\u21C7': 'llarr',
+        '\u21C8': 'uuarr',
+        '\u21C9': 'rrarr',
+        '\u21CA': 'ddarr',
+        '\u21CB': 'lrhar',
+        '\u21CC': 'rlhar',
+        '\u21D0': 'lArr',
+        '\u21CD': 'nlArr',
+        '\u21D1': 'uArr',
+        '\u21D2': 'rArr',
+        '\u21CF': 'nrArr',
+        '\u21D3': 'dArr',
+        '\u21D4': 'iff',
+        '\u21CE': 'nhArr',
+        '\u21D5': 'vArr',
+        '\u21D6': 'nwArr',
+        '\u21D7': 'neArr',
+        '\u21D8': 'seArr',
+        '\u21D9': 'swArr',
+        '\u21DA': 'lAarr',
+        '\u21DB': 'rAarr',
+        '\u21DD': 'zigrarr',
+        '\u21E4': 'larrb',
+        '\u21E5': 'rarrb',
+        '\u21F5': 'duarr',
+        '\u21FD': 'loarr',
+        '\u21FE': 'roarr',
+        '\u21FF': 'hoarr',
+        '\u2200': 'forall',
+        '\u2201': 'comp',
+        '\u2202': 'part',
+        '\u2202\u0338': 'npart',
+        '\u2203': 'exist',
+        '\u2204': 'nexist',
+        '\u2205': 'empty',
+        '\u2207': 'Del',
+        '\u2208': 'in',
+        '\u2209': 'notin',
+        '\u220B': 'ni',
+        '\u220C': 'notni',
+        '\u03F6': 'bepsi',
+        '\u220F': 'prod',
+        '\u2210': 'coprod',
+        '\u2211': 'sum',
+        '+': 'plus',
+        '\xB1': 'pm',
+        '\xF7': 'div',
+        '\xD7': 'times',
+        '<': 'lt',
+        '\u226E': 'nlt',
+        '<\u20D2': 'nvlt',
+        '=': 'equals',
+        '\u2260': 'ne',
+        '=\u20E5': 'bne',
+        '\u2A75': 'Equal',
+        '>': 'gt',
+        '\u226F': 'ngt',
+        '>\u20D2': 'nvgt',
+        '\xAC': 'not',
+        '|': 'vert',
+        '\xA6': 'brvbar',
+        '\u2212': 'minus',
+        '\u2213': 'mp',
+        '\u2214': 'plusdo',
+        '\u2044': 'frasl',
+        '\u2216': 'setmn',
+        '\u2217': 'lowast',
+        '\u2218': 'compfn',
+        '\u221A': 'Sqrt',
+        '\u221D': 'prop',
+        '\u221E': 'infin',
+        '\u221F': 'angrt',
+        '\u2220': 'ang',
+        '\u2220\u20D2': 'nang',
+        '\u2221': 'angmsd',
+        '\u2222': 'angsph',
+        '\u2223': 'mid',
+        '\u2224': 'nmid',
+        '\u2225': 'par',
+        '\u2226': 'npar',
+        '\u2227': 'and',
+        '\u2228': 'or',
+        '\u2229': 'cap',
+        '\u2229\uFE00': 'caps',
+        '\u222A': 'cup',
+        '\u222A\uFE00': 'cups',
+        '\u222B': 'int',
+        '\u222C': 'Int',
+        '\u222D': 'tint',
+        '\u2A0C': 'qint',
+        '\u222E': 'oint',
+        '\u222F': 'Conint',
+        '\u2230': 'Cconint',
+        '\u2231': 'cwint',
+        '\u2232': 'cwconint',
+        '\u2233': 'awconint',
+        '\u2234': 'there4',
+        '\u2235': 'becaus',
+        '\u2236': 'ratio',
+        '\u2237': 'Colon',
+        '\u2238': 'minusd',
+        '\u223A': 'mDDot',
+        '\u223B': 'homtht',
+        '\u223C': 'sim',
+        '\u2241': 'nsim',
+        '\u223C\u20D2': 'nvsim',
+        '\u223D': 'bsim',
+        '\u223D\u0331': 'race',
+        '\u223E': 'ac',
+        '\u223E\u0333': 'acE',
+        '\u223F': 'acd',
+        '\u2240': 'wr',
+        '\u2242': 'esim',
+        '\u2242\u0338': 'nesim',
+        '\u2243': 'sime',
+        '\u2244': 'nsime',
+        '\u2245': 'cong',
+        '\u2247': 'ncong',
+        '\u2246': 'simne',
+        '\u2248': 'ap',
+        '\u2249': 'nap',
+        '\u224A': 'ape',
+        '\u224B': 'apid',
+        '\u224B\u0338': 'napid',
+        '\u224C': 'bcong',
+        '\u224D': 'CupCap',
+        '\u226D': 'NotCupCap',
+        '\u224D\u20D2': 'nvap',
+        '\u224E': 'bump',
+        '\u224E\u0338': 'nbump',
+        '\u224F': 'bumpe',
+        '\u224F\u0338': 'nbumpe',
+        '\u2250': 'doteq',
+        '\u2250\u0338': 'nedot',
+        '\u2251': 'eDot',
+        '\u2252': 'efDot',
+        '\u2253': 'erDot',
+        '\u2254': 'colone',
+        '\u2255': 'ecolon',
+        '\u2256': 'ecir',
+        '\u2257': 'cire',
+        '\u2259': 'wedgeq',
+        '\u225A': 'veeeq',
+        '\u225C': 'trie',
+        '\u225F': 'equest',
+        '\u2261': 'equiv',
+        '\u2262': 'nequiv',
+        '\u2261\u20E5': 'bnequiv',
+        '\u2264': 'le',
+        '\u2270': 'nle',
+        '\u2264\u20D2': 'nvle',
+        '\u2265': 'ge',
+        '\u2271': 'nge',
+        '\u2265\u20D2': 'nvge',
+        '\u2266': 'lE',
+        '\u2266\u0338': 'nlE',
+        '\u2267': 'gE',
+        '\u2267\u0338': 'ngE',
+        '\u2268\uFE00': 'lvnE',
+        '\u2268': 'lnE',
+        '\u2269': 'gnE',
+        '\u2269\uFE00': 'gvnE',
+        '\u226A': 'll',
+        '\u226A\u0338': 'nLtv',
+        '\u226A\u20D2': 'nLt',
+        '\u226B': 'gg',
+        '\u226B\u0338': 'nGtv',
+        '\u226B\u20D2': 'nGt',
+        '\u226C': 'twixt',
+        '\u2272': 'lsim',
+        '\u2274': 'nlsim',
+        '\u2273': 'gsim',
+        '\u2275': 'ngsim',
+        '\u2276': 'lg',
+        '\u2278': 'ntlg',
+        '\u2277': 'gl',
+        '\u2279': 'ntgl',
+        '\u227A': 'pr',
+        '\u2280': 'npr',
+        '\u227B': 'sc',
+        '\u2281': 'nsc',
+        '\u227C': 'prcue',
+        '\u22E0': 'nprcue',
+        '\u227D': 'sccue',
+        '\u22E1': 'nsccue',
+        '\u227E': 'prsim',
+        '\u227F': 'scsim',
+        '\u227F\u0338': 'NotSucceedsTilde',
+        '\u2282': 'sub',
+        '\u2284': 'nsub',
+        '\u2282\u20D2': 'vnsub',
+        '\u2283': 'sup',
+        '\u2285': 'nsup',
+        '\u2283\u20D2': 'vnsup',
+        '\u2286': 'sube',
+        '\u2288': 'nsube',
+        '\u2287': 'supe',
+        '\u2289': 'nsupe',
+        '\u228A\uFE00': 'vsubne',
+        '\u228A': 'subne',
+        '\u228B\uFE00': 'vsupne',
+        '\u228B': 'supne',
+        '\u228D': 'cupdot',
+        '\u228E': 'uplus',
+        '\u228F': 'sqsub',
+        '\u228F\u0338': 'NotSquareSubset',
+        '\u2290': 'sqsup',
+        '\u2290\u0338': 'NotSquareSuperset',
+        '\u2291': 'sqsube',
+        '\u22E2': 'nsqsube',
+        '\u2292': 'sqsupe',
+        '\u22E3': 'nsqsupe',
+        '\u2293': 'sqcap',
+        '\u2293\uFE00': 'sqcaps',
+        '\u2294': 'sqcup',
+        '\u2294\uFE00': 'sqcups',
+        '\u2295': 'oplus',
+        '\u2296': 'ominus',
+        '\u2297': 'otimes',
+        '\u2298': 'osol',
+        '\u2299': 'odot',
+        '\u229A': 'ocir',
+        '\u229B': 'oast',
+        '\u229D': 'odash',
+        '\u229E': 'plusb',
+        '\u229F': 'minusb',
+        '\u22A0': 'timesb',
+        '\u22A1': 'sdotb',
+        '\u22A2': 'vdash',
+        '\u22AC': 'nvdash',
+        '\u22A3': 'dashv',
+        '\u22A4': 'top',
+        '\u22A5': 'bot',
+        '\u22A7': 'models',
+        '\u22A8': 'vDash',
+        '\u22AD': 'nvDash',
+        '\u22A9': 'Vdash',
+        '\u22AE': 'nVdash',
+        '\u22AA': 'Vvdash',
+        '\u22AB': 'VDash',
+        '\u22AF': 'nVDash',
+        '\u22B0': 'prurel',
+        '\u22B2': 'vltri',
+        '\u22EA': 'nltri',
+        '\u22B3': 'vrtri',
+        '\u22EB': 'nrtri',
+        '\u22B4': 'ltrie',
+        '\u22EC': 'nltrie',
+        '\u22B4\u20D2': 'nvltrie',
+        '\u22B5': 'rtrie',
+        '\u22ED': 'nrtrie',
+        '\u22B5\u20D2': 'nvrtrie',
+        '\u22B6': 'origof',
+        '\u22B7': 'imof',
+        '\u22B8': 'mumap',
+        '\u22B9': 'hercon',
+        '\u22BA': 'intcal',
+        '\u22BB': 'veebar',
+        '\u22BD': 'barvee',
+        '\u22BE': 'angrtvb',
+        '\u22BF': 'lrtri',
+        '\u22C0': 'Wedge',
+        '\u22C1': 'Vee',
+        '\u22C2': 'xcap',
+        '\u22C3': 'xcup',
+        '\u22C4': 'diam',
+        '\u22C5': 'sdot',
+        '\u22C6': 'Star',
+        '\u22C7': 'divonx',
+        '\u22C8': 'bowtie',
+        '\u22C9': 'ltimes',
+        '\u22CA': 'rtimes',
+        '\u22CB': 'lthree',
+        '\u22CC': 'rthree',
+        '\u22CD': 'bsime',
+        '\u22CE': 'cuvee',
+        '\u22CF': 'cuwed',
+        '\u22D0': 'Sub',
+        '\u22D1': 'Sup',
+        '\u22D2': 'Cap',
+        '\u22D3': 'Cup',
+        '\u22D4': 'fork',
+        '\u22D5': 'epar',
+        '\u22D6': 'ltdot',
+        '\u22D7': 'gtdot',
+        '\u22D8': 'Ll',
+        '\u22D8\u0338': 'nLl',
+        '\u22D9': 'Gg',
+        '\u22D9\u0338': 'nGg',
+        '\u22DA\uFE00': 'lesg',
+        '\u22DA': 'leg',
+        '\u22DB': 'gel',
+        '\u22DB\uFE00': 'gesl',
+        '\u22DE': 'cuepr',
+        '\u22DF': 'cuesc',
+        '\u22E6': 'lnsim',
+        '\u22E7': 'gnsim',
+        '\u22E8': 'prnsim',
+        '\u22E9': 'scnsim',
+        '\u22EE': 'vellip',
+        '\u22EF': 'ctdot',
+        '\u22F0': 'utdot',
+        '\u22F1': 'dtdot',
+        '\u22F2': 'disin',
+        '\u22F3': 'isinsv',
+        '\u22F4': 'isins',
+        '\u22F5': 'isindot',
+        '\u22F5\u0338': 'notindot',
+        '\u22F6': 'notinvc',
+        '\u22F7': 'notinvb',
+        '\u22F9': 'isinE',
+        '\u22F9\u0338': 'notinE',
+        '\u22FA': 'nisd',
+        '\u22FB': 'xnis',
+        '\u22FC': 'nis',
+        '\u22FD': 'notnivc',
+        '\u22FE': 'notnivb',
+        '\u2305': 'barwed',
+        '\u2306': 'Barwed',
+        '\u230C': 'drcrop',
+        '\u230D': 'dlcrop',
+        '\u230E': 'urcrop',
+        '\u230F': 'ulcrop',
+        '\u2310': 'bnot',
+        '\u2312': 'profline',
+        '\u2313': 'profsurf',
+        '\u2315': 'telrec',
+        '\u2316': 'target',
+        '\u231C': 'ulcorn',
+        '\u231D': 'urcorn',
+        '\u231E': 'dlcorn',
+        '\u231F': 'drcorn',
+        '\u2322': 'frown',
+        '\u2323': 'smile',
+        '\u232D': 'cylcty',
+        '\u232E': 'profalar',
+        '\u2336': 'topbot',
+        '\u233D': 'ovbar',
+        '\u233F': 'solbar',
+        '\u237C': 'angzarr',
+        '\u23B0': 'lmoust',
+        '\u23B1': 'rmoust',
+        '\u23B4': 'tbrk',
+        '\u23B5': 'bbrk',
+        '\u23B6': 'bbrktbrk',
+        '\u23DC': 'OverParenthesis',
+        '\u23DD': 'UnderParenthesis',
+        '\u23DE': 'OverBrace',
+        '\u23DF': 'UnderBrace',
+        '\u23E2': 'trpezium',
+        '\u23E7': 'elinters',
+        '\u2423': 'blank',
+        '\u2500': 'boxh',
+        '\u2502': 'boxv',
+        '\u250C': 'boxdr',
+        '\u2510': 'boxdl',
+        '\u2514': 'boxur',
+        '\u2518': 'boxul',
+        '\u251C': 'boxvr',
+        '\u2524': 'boxvl',
+        '\u252C': 'boxhd',
+        '\u2534': 'boxhu',
+        '\u253C': 'boxvh',
+        '\u2550': 'boxH',
+        '\u2551': 'boxV',
+        '\u2552': 'boxdR',
+        '\u2553': 'boxDr',
+        '\u2554': 'boxDR',
+        '\u2555': 'boxdL',
+        '\u2556': 'boxDl',
+        '\u2557': 'boxDL',
+        '\u2558': 'boxuR',
+        '\u2559': 'boxUr',
+        '\u255A': 'boxUR',
+        '\u255B': 'boxuL',
+        '\u255C': 'boxUl',
+        '\u255D': 'boxUL',
+        '\u255E': 'boxvR',
+        '\u255F': 'boxVr',
+        '\u2560': 'boxVR',
+        '\u2561': 'boxvL',
+        '\u2562': 'boxVl',
+        '\u2563': 'boxVL',
+        '\u2564': 'boxHd',
+        '\u2565': 'boxhD',
+        '\u2566': 'boxHD',
+        '\u2567': 'boxHu',
+        '\u2568': 'boxhU',
+        '\u2569': 'boxHU',
+        '\u256A': 'boxvH',
+        '\u256B': 'boxVh',
+        '\u256C': 'boxVH',
+        '\u2580': 'uhblk',
+        '\u2584': 'lhblk',
+        '\u2588': 'block',
+        '\u2591': 'blk14',
+        '\u2592': 'blk12',
+        '\u2593': 'blk34',
+        '\u25A1': 'squ',
+        '\u25AA': 'squf',
+        '\u25AB': 'EmptyVerySmallSquare',
+        '\u25AD': 'rect',
+        '\u25AE': 'marker',
+        '\u25B1': 'fltns',
+        '\u25B3': 'xutri',
+        '\u25B4': 'utrif',
+        '\u25B5': 'utri',
+        '\u25B8': 'rtrif',
+        '\u25B9': 'rtri',
+        '\u25BD': 'xdtri',
+        '\u25BE': 'dtrif',
+        '\u25BF': 'dtri',
+        '\u25C2': 'ltrif',
+        '\u25C3': 'ltri',
+        '\u25CA': 'loz',
+        '\u25CB': 'cir',
+        '\u25EC': 'tridot',
+        '\u25EF': 'xcirc',
+        '\u25F8': 'ultri',
+        '\u25F9': 'urtri',
+        '\u25FA': 'lltri',
+        '\u25FB': 'EmptySmallSquare',
+        '\u25FC': 'FilledSmallSquare',
+        '\u2605': 'starf',
+        '\u2606': 'star',
+        '\u260E': 'phone',
+        '\u2640': 'female',
+        '\u2642': 'male',
+        '\u2660': 'spades',
+        '\u2663': 'clubs',
+        '\u2665': 'hearts',
+        '\u2666': 'diams',
+        '\u266A': 'sung',
+        '\u2713': 'check',
+        '\u2717': 'cross',
+        '\u2720': 'malt',
+        '\u2736': 'sext',
+        '\u2758': 'VerticalSeparator',
+        '\u27C8': 'bsolhsub',
+        '\u27C9': 'suphsol',
+        '\u27F5': 'xlarr',
+        '\u27F6': 'xrarr',
+        '\u27F7': 'xharr',
+        '\u27F8': 'xlArr',
+        '\u27F9': 'xrArr',
+        '\u27FA': 'xhArr',
+        '\u27FC': 'xmap',
+        '\u27FF': 'dzigrarr',
+        '\u2902': 'nvlArr',
+        '\u2903': 'nvrArr',
+        '\u2904': 'nvHarr',
+        '\u2905': 'Map',
+        '\u290C': 'lbarr',
+        '\u290D': 'rbarr',
+        '\u290E': 'lBarr',
+        '\u290F': 'rBarr',
+        '\u2910': 'RBarr',
+        '\u2911': 'DDotrahd',
+        '\u2912': 'UpArrowBar',
+        '\u2913': 'DownArrowBar',
+        '\u2916': 'Rarrtl',
+        '\u2919': 'latail',
+        '\u291A': 'ratail',
+        '\u291B': 'lAtail',
+        '\u291C': 'rAtail',
+        '\u291D': 'larrfs',
+        '\u291E': 'rarrfs',
+        '\u291F': 'larrbfs',
+        '\u2920': 'rarrbfs',
+        '\u2923': 'nwarhk',
+        '\u2924': 'nearhk',
+        '\u2925': 'searhk',
+        '\u2926': 'swarhk',
+        '\u2927': 'nwnear',
+        '\u2928': 'toea',
+        '\u2929': 'tosa',
+        '\u292A': 'swnwar',
+        '\u2933': 'rarrc',
+        '\u2933\u0338': 'nrarrc',
+        '\u2935': 'cudarrr',
+        '\u2936': 'ldca',
+        '\u2937': 'rdca',
+        '\u2938': 'cudarrl',
+        '\u2939': 'larrpl',
+        '\u293C': 'curarrm',
+        '\u293D': 'cularrp',
+        '\u2945': 'rarrpl',
+        '\u2948': 'harrcir',
+        '\u2949': 'Uarrocir',
+        '\u294A': 'lurdshar',
+        '\u294B': 'ldrushar',
+        '\u294E': 'LeftRightVector',
+        '\u294F': 'RightUpDownVector',
+        '\u2950': 'DownLeftRightVector',
+        '\u2951': 'LeftUpDownVector',
+        '\u2952': 'LeftVectorBar',
+        '\u2953': 'RightVectorBar',
+        '\u2954': 'RightUpVectorBar',
+        '\u2955': 'RightDownVectorBar',
+        '\u2956': 'DownLeftVectorBar',
+        '\u2957': 'DownRightVectorBar',
+        '\u2958': 'LeftUpVectorBar',
+        '\u2959': 'LeftDownVectorBar',
+        '\u295A': 'LeftTeeVector',
+        '\u295B': 'RightTeeVector',
+        '\u295C': 'RightUpTeeVector',
+        '\u295D': 'RightDownTeeVector',
+        '\u295E': 'DownLeftTeeVector',
+        '\u295F': 'DownRightTeeVector',
+        '\u2960': 'LeftUpTeeVector',
+        '\u2961': 'LeftDownTeeVector',
+        '\u2962': 'lHar',
+        '\u2963': 'uHar',
+        '\u2964': 'rHar',
+        '\u2965': 'dHar',
+        '\u2966': 'luruhar',
+        '\u2967': 'ldrdhar',
+        '\u2968': 'ruluhar',
+        '\u2969': 'rdldhar',
+        '\u296A': 'lharul',
+        '\u296B': 'llhard',
+        '\u296C': 'rharul',
+        '\u296D': 'lrhard',
+        '\u296E': 'udhar',
+        '\u296F': 'duhar',
+        '\u2970': 'RoundImplies',
+        '\u2971': 'erarr',
+        '\u2972': 'simrarr',
+        '\u2973': 'larrsim',
+        '\u2974': 'rarrsim',
+        '\u2975': 'rarrap',
+        '\u2976': 'ltlarr',
+        '\u2978': 'gtrarr',
+        '\u2979': 'subrarr',
+        '\u297B': 'suplarr',
+        '\u297C': 'lfisht',
+        '\u297D': 'rfisht',
+        '\u297E': 'ufisht',
+        '\u297F': 'dfisht',
+        '\u299A': 'vzigzag',
+        '\u299C': 'vangrt',
+        '\u299D': 'angrtvbd',
+        '\u29A4': 'ange',
+        '\u29A5': 'range',
+        '\u29A6': 'dwangle',
+        '\u29A7': 'uwangle',
+        '\u29A8': 'angmsdaa',
+        '\u29A9': 'angmsdab',
+        '\u29AA': 'angmsdac',
+        '\u29AB': 'angmsdad',
+        '\u29AC': 'angmsdae',
+        '\u29AD': 'angmsdaf',
+        '\u29AE': 'angmsdag',
+        '\u29AF': 'angmsdah',
+        '\u29B0': 'bemptyv',
+        '\u29B1': 'demptyv',
+        '\u29B2': 'cemptyv',
+        '\u29B3': 'raemptyv',
+        '\u29B4': 'laemptyv',
+        '\u29B5': 'ohbar',
+        '\u29B6': 'omid',
+        '\u29B7': 'opar',
+        '\u29B9': 'operp',
+        '\u29BB': 'olcross',
+        '\u29BC': 'odsold',
+        '\u29BE': 'olcir',
+        '\u29BF': 'ofcir',
+        '\u29C0': 'olt',
+        '\u29C1': 'ogt',
+        '\u29C2': 'cirscir',
+        '\u29C3': 'cirE',
+        '\u29C4': 'solb',
+        '\u29C5': 'bsolb',
+        '\u29C9': 'boxbox',
+        '\u29CD': 'trisb',
+        '\u29CE': 'rtriltri',
+        '\u29CF': 'LeftTriangleBar',
+        '\u29CF\u0338': 'NotLeftTriangleBar',
+        '\u29D0': 'RightTriangleBar',
+        '\u29D0\u0338': 'NotRightTriangleBar',
+        '\u29DC': 'iinfin',
+        '\u29DD': 'infintie',
+        '\u29DE': 'nvinfin',
+        '\u29E3': 'eparsl',
+        '\u29E4': 'smeparsl',
+        '\u29E5': 'eqvparsl',
+        '\u29EB': 'lozf',
+        '\u29F4': 'RuleDelayed',
+        '\u29F6': 'dsol',
+        '\u2A00': 'xodot',
+        '\u2A01': 'xoplus',
+        '\u2A02': 'xotime',
+        '\u2A04': 'xuplus',
+        '\u2A06': 'xsqcup',
+        '\u2A0D': 'fpartint',
+        '\u2A10': 'cirfnint',
+        '\u2A11': 'awint',
+        '\u2A12': 'rppolint',
+        '\u2A13': 'scpolint',
+        '\u2A14': 'npolint',
+        '\u2A15': 'pointint',
+        '\u2A16': 'quatint',
+        '\u2A17': 'intlarhk',
+        '\u2A22': 'pluscir',
+        '\u2A23': 'plusacir',
+        '\u2A24': 'simplus',
+        '\u2A25': 'plusdu',
+        '\u2A26': 'plussim',
+        '\u2A27': 'plustwo',
+        '\u2A29': 'mcomma',
+        '\u2A2A': 'minusdu',
+        '\u2A2D': 'loplus',
+        '\u2A2E': 'roplus',
+        '\u2A2F': 'Cross',
+        '\u2A30': 'timesd',
+        '\u2A31': 'timesbar',
+        '\u2A33': 'smashp',
+        '\u2A34': 'lotimes',
+        '\u2A35': 'rotimes',
+        '\u2A36': 'otimesas',
+        '\u2A37': 'Otimes',
+        '\u2A38': 'odiv',
+        '\u2A39': 'triplus',
+        '\u2A3A': 'triminus',
+        '\u2A3B': 'tritime',
+        '\u2A3C': 'iprod',
+        '\u2A3F': 'amalg',
+        '\u2A40': 'capdot',
+        '\u2A42': 'ncup',
+        '\u2A43': 'ncap',
+        '\u2A44': 'capand',
+        '\u2A45': 'cupor',
+        '\u2A46': 'cupcap',
+        '\u2A47': 'capcup',
+        '\u2A48': 'cupbrcap',
+        '\u2A49': 'capbrcup',
+        '\u2A4A': 'cupcup',
+        '\u2A4B': 'capcap',
+        '\u2A4C': 'ccups',
+        '\u2A4D': 'ccaps',
+        '\u2A50': 'ccupssm',
+        '\u2A53': 'And',
+        '\u2A54': 'Or',
+        '\u2A55': 'andand',
+        '\u2A56': 'oror',
+        '\u2A57': 'orslope',
+        '\u2A58': 'andslope',
+        '\u2A5A': 'andv',
+        '\u2A5B': 'orv',
+        '\u2A5C': 'andd',
+        '\u2A5D': 'ord',
+        '\u2A5F': 'wedbar',
+        '\u2A66': 'sdote',
+        '\u2A6A': 'simdot',
+        '\u2A6D': 'congdot',
+        '\u2A6D\u0338': 'ncongdot',
+        '\u2A6E': 'easter',
+        '\u2A6F': 'apacir',
+        '\u2A70': 'apE',
+        '\u2A70\u0338': 'napE',
+        '\u2A71': 'eplus',
+        '\u2A72': 'pluse',
+        '\u2A73': 'Esim',
+        '\u2A77': 'eDDot',
+        '\u2A78': 'equivDD',
+        '\u2A79': 'ltcir',
+        '\u2A7A': 'gtcir',
+        '\u2A7B': 'ltquest',
+        '\u2A7C': 'gtquest',
+        '\u2A7D': 'les',
+        '\u2A7D\u0338': 'nles',
+        '\u2A7E': 'ges',
+        '\u2A7E\u0338': 'nges',
+        '\u2A7F': 'lesdot',
+        '\u2A80': 'gesdot',
+        '\u2A81': 'lesdoto',
+        '\u2A82': 'gesdoto',
+        '\u2A83': 'lesdotor',
+        '\u2A84': 'gesdotol',
+        '\u2A85': 'lap',
+        '\u2A86': 'gap',
+        '\u2A87': 'lne',
+        '\u2A88': 'gne',
+        '\u2A89': 'lnap',
+        '\u2A8A': 'gnap',
+        '\u2A8B': 'lEg',
+        '\u2A8C': 'gEl',
+        '\u2A8D': 'lsime',
+        '\u2A8E': 'gsime',
+        '\u2A8F': 'lsimg',
+        '\u2A90': 'gsiml',
+        '\u2A91': 'lgE',
+        '\u2A92': 'glE',
+        '\u2A93': 'lesges',
+        '\u2A94': 'gesles',
+        '\u2A95': 'els',
+        '\u2A96': 'egs',
+        '\u2A97': 'elsdot',
+        '\u2A98': 'egsdot',
+        '\u2A99': 'el',
+        '\u2A9A': 'eg',
+        '\u2A9D': 'siml',
+        '\u2A9E': 'simg',
+        '\u2A9F': 'simlE',
+        '\u2AA0': 'simgE',
+        '\u2AA1': 'LessLess',
+        '\u2AA1\u0338': 'NotNestedLessLess',
+        '\u2AA2': 'GreaterGreater',
+        '\u2AA2\u0338': 'NotNestedGreaterGreater',
+        '\u2AA4': 'glj',
+        '\u2AA5': 'gla',
+        '\u2AA6': 'ltcc',
+        '\u2AA7': 'gtcc',
+        '\u2AA8': 'lescc',
+        '\u2AA9': 'gescc',
+        '\u2AAA': 'smt',
+        '\u2AAB': 'lat',
+        '\u2AAC': 'smte',
+        '\u2AAC\uFE00': 'smtes',
+        '\u2AAD': 'late',
+        '\u2AAD\uFE00': 'lates',
+        '\u2AAE': 'bumpE',
+        '\u2AAF': 'pre',
+        '\u2AAF\u0338': 'npre',
+        '\u2AB0': 'sce',
+        '\u2AB0\u0338': 'nsce',
+        '\u2AB3': 'prE',
+        '\u2AB4': 'scE',
+        '\u2AB5': 'prnE',
+        '\u2AB6': 'scnE',
+        '\u2AB7': 'prap',
+        '\u2AB8': 'scap',
+        '\u2AB9': 'prnap',
+        '\u2ABA': 'scnap',
+        '\u2ABB': 'Pr',
+        '\u2ABC': 'Sc',
+        '\u2ABD': 'subdot',
+        '\u2ABE': 'supdot',
+        '\u2ABF': 'subplus',
+        '\u2AC0': 'supplus',
+        '\u2AC1': 'submult',
+        '\u2AC2': 'supmult',
+        '\u2AC3': 'subedot',
+        '\u2AC4': 'supedot',
+        '\u2AC5': 'subE',
+        '\u2AC5\u0338': 'nsubE',
+        '\u2AC6': 'supE',
+        '\u2AC6\u0338': 'nsupE',
+        '\u2AC7': 'subsim',
+        '\u2AC8': 'supsim',
+        '\u2ACB\uFE00': 'vsubnE',
+        '\u2ACB': 'subnE',
+        '\u2ACC\uFE00': 'vsupnE',
+        '\u2ACC': 'supnE',
+        '\u2ACF': 'csub',
+        '\u2AD0': 'csup',
+        '\u2AD1': 'csube',
+        '\u2AD2': 'csupe',
+        '\u2AD3': 'subsup',
+        '\u2AD4': 'supsub',
+        '\u2AD5': 'subsub',
+        '\u2AD6': 'supsup',
+        '\u2AD7': 'suphsub',
+        '\u2AD8': 'supdsub',
+        '\u2AD9': 'forkv',
+        '\u2ADA': 'topfork',
+        '\u2ADB': 'mlcp',
+        '\u2AE4': 'Dashv',
+        '\u2AE6': 'Vdashl',
+        '\u2AE7': 'Barv',
+        '\u2AE8': 'vBar',
+        '\u2AE9': 'vBarv',
+        '\u2AEB': 'Vbar',
+        '\u2AEC': 'Not',
+        '\u2AED': 'bNot',
+        '\u2AEE': 'rnmid',
+        '\u2AEF': 'cirmid',
+        '\u2AF0': 'midcir',
+        '\u2AF1': 'topcir',
+        '\u2AF2': 'nhpar',
+        '\u2AF3': 'parsim',
+        '\u2AFD': 'parsl',
+        '\u2AFD\u20E5': 'nparsl',
+        '\u266D': 'flat',
+        '\u266E': 'natur',
+        '\u266F': 'sharp',
+        '\xA4': 'curren',
+        '\xA2': 'cent',
+        $: 'dollar',
+        '\xA3': 'pound',
+        '\xA5': 'yen',
+        '\u20AC': 'euro',
+        '\xB9': 'sup1',
+        '\xBD': 'half',
+        '\u2153': 'frac13',
+        '\xBC': 'frac14',
+        '\u2155': 'frac15',
+        '\u2159': 'frac16',
+        '\u215B': 'frac18',
+        '\xB2': 'sup2',
+        '\u2154': 'frac23',
+        '\u2156': 'frac25',
+        '\xB3': 'sup3',
+        '\xBE': 'frac34',
+        '\u2157': 'frac35',
+        '\u215C': 'frac38',
+        '\u2158': 'frac45',
+        '\u215A': 'frac56',
+        '\u215D': 'frac58',
+        '\u215E': 'frac78',
+        '\uD835\uDCB6': 'ascr',
+        '\uD835\uDD52': 'aopf',
+        '\uD835\uDD1E': 'afr',
+        '\uD835\uDD38': 'Aopf',
+        '\uD835\uDD04': 'Afr',
+        '\uD835\uDC9C': 'Ascr',
+        '\xAA': 'ordf',
+        '\xE1': 'aacute',
+        '\xC1': 'Aacute',
+        '\xE0': 'agrave',
+        '\xC0': 'Agrave',
+        '\u0103': 'abreve',
+        '\u0102': 'Abreve',
+        '\xE2': 'acirc',
+        '\xC2': 'Acirc',
+        '\xE5': 'aring',
+        '\xC5': 'angst',
+        '\xE4': 'auml',
+        '\xC4': 'Auml',
+        '\xE3': 'atilde',
+        '\xC3': 'Atilde',
+        '\u0105': 'aogon',
+        '\u0104': 'Aogon',
+        '\u0101': 'amacr',
+        '\u0100': 'Amacr',
+        '\xE6': 'aelig',
+        '\xC6': 'AElig',
+        '\uD835\uDCB7': 'bscr',
+        '\uD835\uDD53': 'bopf',
+        '\uD835\uDD1F': 'bfr',
+        '\uD835\uDD39': 'Bopf',
+        '\u212C': 'Bscr',
+        '\uD835\uDD05': 'Bfr',
+        '\uD835\uDD20': 'cfr',
+        '\uD835\uDCB8': 'cscr',
+        '\uD835\uDD54': 'copf',
+        '\u212D': 'Cfr',
+        '\uD835\uDC9E': 'Cscr',
+        '\u2102': 'Copf',
+        '\u0107': 'cacute',
+        '\u0106': 'Cacute',
+        '\u0109': 'ccirc',
+        '\u0108': 'Ccirc',
+        '\u010D': 'ccaron',
+        '\u010C': 'Ccaron',
+        '\u010B': 'cdot',
+        '\u010A': 'Cdot',
+        '\xE7': 'ccedil',
+        '\xC7': 'Ccedil',
+        '\u2105': 'incare',
+        '\uD835\uDD21': 'dfr',
+        '\u2146': 'dd',
+        '\uD835\uDD55': 'dopf',
+        '\uD835\uDCB9': 'dscr',
+        '\uD835\uDC9F': 'Dscr',
+        '\uD835\uDD07': 'Dfr',
+        '\u2145': 'DD',
+        '\uD835\uDD3B': 'Dopf',
+        '\u010F': 'dcaron',
+        '\u010E': 'Dcaron',
+        '\u0111': 'dstrok',
+        '\u0110': 'Dstrok',
+        '\xF0': 'eth',
+        '\xD0': 'ETH',
+        '\u2147': 'ee',
+        '\u212F': 'escr',
+        '\uD835\uDD22': 'efr',
+        '\uD835\uDD56': 'eopf',
+        '\u2130': 'Escr',
+        '\uD835\uDD08': 'Efr',
+        '\uD835\uDD3C': 'Eopf',
+        '\xE9': 'eacute',
+        '\xC9': 'Eacute',
+        '\xE8': 'egrave',
+        '\xC8': 'Egrave',
+        '\xEA': 'ecirc',
+        '\xCA': 'Ecirc',
+        '\u011B': 'ecaron',
+        '\u011A': 'Ecaron',
+        '\xEB': 'euml',
+        '\xCB': 'Euml',
+        '\u0117': 'edot',
+        '\u0116': 'Edot',
+        '\u0119': 'eogon',
+        '\u0118': 'Eogon',
+        '\u0113': 'emacr',
+        '\u0112': 'Emacr',
+        '\uD835\uDD23': 'ffr',
+        '\uD835\uDD57': 'fopf',
+        '\uD835\uDCBB': 'fscr',
+        '\uD835\uDD09': 'Ffr',
+        '\uD835\uDD3D': 'Fopf',
+        '\u2131': 'Fscr',
+        '\uFB00': 'fflig',
+        '\uFB03': 'ffilig',
+        '\uFB04': 'ffllig',
+        '\uFB01': 'filig',
+        fj: 'fjlig',
+        '\uFB02': 'fllig',
+        '\u0192': 'fnof',
+        '\u210A': 'gscr',
+        '\uD835\uDD58': 'gopf',
+        '\uD835\uDD24': 'gfr',
+        '\uD835\uDCA2': 'Gscr',
+        '\uD835\uDD3E': 'Gopf',
+        '\uD835\uDD0A': 'Gfr',
+        '\u01F5': 'gacute',
+        '\u011F': 'gbreve',
+        '\u011E': 'Gbreve',
+        '\u011D': 'gcirc',
+        '\u011C': 'Gcirc',
+        '\u0121': 'gdot',
+        '\u0120': 'Gdot',
+        '\u0122': 'Gcedil',
+        '\uD835\uDD25': 'hfr',
+        '\u210E': 'planckh',
+        '\uD835\uDCBD': 'hscr',
+        '\uD835\uDD59': 'hopf',
+        '\u210B': 'Hscr',
+        '\u210C': 'Hfr',
+        '\u210D': 'Hopf',
+        '\u0125': 'hcirc',
+        '\u0124': 'Hcirc',
+        '\u210F': 'hbar',
+        '\u0127': 'hstrok',
+        '\u0126': 'Hstrok',
+        '\uD835\uDD5A': 'iopf',
+        '\uD835\uDD26': 'ifr',
+        '\uD835\uDCBE': 'iscr',
+        '\u2148': 'ii',
+        '\uD835\uDD40': 'Iopf',
+        '\u2110': 'Iscr',
+        '\u2111': 'Im',
+        '\xED': 'iacute',
+        '\xCD': 'Iacute',
+        '\xEC': 'igrave',
+        '\xCC': 'Igrave',
+        '\xEE': 'icirc',
+        '\xCE': 'Icirc',
+        '\xEF': 'iuml',
+        '\xCF': 'Iuml',
+        '\u0129': 'itilde',
+        '\u0128': 'Itilde',
+        '\u0130': 'Idot',
+        '\u012F': 'iogon',
+        '\u012E': 'Iogon',
+        '\u012B': 'imacr',
+        '\u012A': 'Imacr',
+        '\u0133': 'ijlig',
+        '\u0132': 'IJlig',
+        '\u0131': 'imath',
+        '\uD835\uDCBF': 'jscr',
+        '\uD835\uDD5B': 'jopf',
+        '\uD835\uDD27': 'jfr',
+        '\uD835\uDCA5': 'Jscr',
+        '\uD835\uDD0D': 'Jfr',
+        '\uD835\uDD41': 'Jopf',
+        '\u0135': 'jcirc',
+        '\u0134': 'Jcirc',
+        '\u0237': 'jmath',
+        '\uD835\uDD5C': 'kopf',
+        '\uD835\uDCC0': 'kscr',
+        '\uD835\uDD28': 'kfr',
+        '\uD835\uDCA6': 'Kscr',
+        '\uD835\uDD42': 'Kopf',
+        '\uD835\uDD0E': 'Kfr',
+        '\u0137': 'kcedil',
+        '\u0136': 'Kcedil',
+        '\uD835\uDD29': 'lfr',
+        '\uD835\uDCC1': 'lscr',
+        '\u2113': 'ell',
+        '\uD835\uDD5D': 'lopf',
+        '\u2112': 'Lscr',
+        '\uD835\uDD0F': 'Lfr',
+        '\uD835\uDD43': 'Lopf',
+        '\u013A': 'lacute',
+        '\u0139': 'Lacute',
+        '\u013E': 'lcaron',
+        '\u013D': 'Lcaron',
+        '\u013C': 'lcedil',
+        '\u013B': 'Lcedil',
+        '\u0142': 'lstrok',
+        '\u0141': 'Lstrok',
+        '\u0140': 'lmidot',
+        '\u013F': 'Lmidot',
+        '\uD835\uDD2A': 'mfr',
+        '\uD835\uDD5E': 'mopf',
+        '\uD835\uDCC2': 'mscr',
+        '\uD835\uDD10': 'Mfr',
+        '\uD835\uDD44': 'Mopf',
+        '\u2133': 'Mscr',
+        '\uD835\uDD2B': 'nfr',
+        '\uD835\uDD5F': 'nopf',
+        '\uD835\uDCC3': 'nscr',
+        '\u2115': 'Nopf',
+        '\uD835\uDCA9': 'Nscr',
+        '\uD835\uDD11': 'Nfr',
+        '\u0144': 'nacute',
+        '\u0143': 'Nacute',
+        '\u0148': 'ncaron',
+        '\u0147': 'Ncaron',
+        '\xF1': 'ntilde',
+        '\xD1': 'Ntilde',
+        '\u0146': 'ncedil',
+        '\u0145': 'Ncedil',
+        '\u2116': 'numero',
+        '\u014B': 'eng',
+        '\u014A': 'ENG',
+        '\uD835\uDD60': 'oopf',
+        '\uD835\uDD2C': 'ofr',
+        '\u2134': 'oscr',
+        '\uD835\uDCAA': 'Oscr',
+        '\uD835\uDD12': 'Ofr',
+        '\uD835\uDD46': 'Oopf',
+        '\xBA': 'ordm',
+        '\xF3': 'oacute',
+        '\xD3': 'Oacute',
+        '\xF2': 'ograve',
+        '\xD2': 'Ograve',
+        '\xF4': 'ocirc',
+        '\xD4': 'Ocirc',
+        '\xF6': 'ouml',
+        '\xD6': 'Ouml',
+        '\u0151': 'odblac',
+        '\u0150': 'Odblac',
+        '\xF5': 'otilde',
+        '\xD5': 'Otilde',
+        '\xF8': 'oslash',
+        '\xD8': 'Oslash',
+        '\u014D': 'omacr',
+        '\u014C': 'Omacr',
+        '\u0153': 'oelig',
+        '\u0152': 'OElig',
+        '\uD835\uDD2D': 'pfr',
+        '\uD835\uDCC5': 'pscr',
+        '\uD835\uDD61': 'popf',
+        '\u2119': 'Popf',
+        '\uD835\uDD13': 'Pfr',
+        '\uD835\uDCAB': 'Pscr',
+        '\uD835\uDD62': 'qopf',
+        '\uD835\uDD2E': 'qfr',
+        '\uD835\uDCC6': 'qscr',
+        '\uD835\uDCAC': 'Qscr',
+        '\uD835\uDD14': 'Qfr',
+        '\u211A': 'Qopf',
+        '\u0138': 'kgreen',
+        '\uD835\uDD2F': 'rfr',
+        '\uD835\uDD63': 'ropf',
+        '\uD835\uDCC7': 'rscr',
+        '\u211B': 'Rscr',
+        '\u211C': 'Re',
+        '\u211D': 'Ropf',
+        '\u0155': 'racute',
+        '\u0154': 'Racute',
+        '\u0159': 'rcaron',
+        '\u0158': 'Rcaron',
+        '\u0157': 'rcedil',
+        '\u0156': 'Rcedil',
+        '\uD835\uDD64': 'sopf',
+        '\uD835\uDCC8': 'sscr',
+        '\uD835\uDD30': 'sfr',
+        '\uD835\uDD4A': 'Sopf',
+        '\uD835\uDD16': 'Sfr',
+        '\uD835\uDCAE': 'Sscr',
+        '\u24C8': 'oS',
+        '\u015B': 'sacute',
+        '\u015A': 'Sacute',
+        '\u015D': 'scirc',
+        '\u015C': 'Scirc',
+        '\u0161': 'scaron',
+        '\u0160': 'Scaron',
+        '\u015F': 'scedil',
+        '\u015E': 'Scedil',
+        '\xDF': 'szlig',
+        '\uD835\uDD31': 'tfr',
+        '\uD835\uDCC9': 'tscr',
+        '\uD835\uDD65': 'topf',
+        '\uD835\uDCAF': 'Tscr',
+        '\uD835\uDD17': 'Tfr',
+        '\uD835\uDD4B': 'Topf',
+        '\u0165': 'tcaron',
+        '\u0164': 'Tcaron',
+        '\u0163': 'tcedil',
+        '\u0162': 'Tcedil',
+        '\u2122': 'trade',
+        '\u0167': 'tstrok',
+        '\u0166': 'Tstrok',
+        '\uD835\uDCCA': 'uscr',
+        '\uD835\uDD66': 'uopf',
+        '\uD835\uDD32': 'ufr',
+        '\uD835\uDD4C': 'Uopf',
+        '\uD835\uDD18': 'Ufr',
+        '\uD835\uDCB0': 'Uscr',
+        '\xFA': 'uacute',
+        '\xDA': 'Uacute',
+        '\xF9': 'ugrave',
+        '\xD9': 'Ugrave',
+        '\u016D': 'ubreve',
+        '\u016C': 'Ubreve',
+        '\xFB': 'ucirc',
+        '\xDB': 'Ucirc',
+        '\u016F': 'uring',
+        '\u016E': 'Uring',
+        '\xFC': 'uuml',
+        '\xDC': 'Uuml',
+        '\u0171': 'udblac',
+        '\u0170': 'Udblac',
+        '\u0169': 'utilde',
+        '\u0168': 'Utilde',
+        '\u0173': 'uogon',
+        '\u0172': 'Uogon',
+        '\u016B': 'umacr',
+        '\u016A': 'Umacr',
+        '\uD835\uDD33': 'vfr',
+        '\uD835\uDD67': 'vopf',
+        '\uD835\uDCCB': 'vscr',
+        '\uD835\uDD19': 'Vfr',
+        '\uD835\uDD4D': 'Vopf',
+        '\uD835\uDCB1': 'Vscr',
+        '\uD835\uDD68': 'wopf',
+        '\uD835\uDCCC': 'wscr',
+        '\uD835\uDD34': 'wfr',
+        '\uD835\uDCB2': 'Wscr',
+        '\uD835\uDD4E': 'Wopf',
+        '\uD835\uDD1A': 'Wfr',
+        '\u0175': 'wcirc',
+        '\u0174': 'Wcirc',
+        '\uD835\uDD35': 'xfr',
+        '\uD835\uDCCD': 'xscr',
+        '\uD835\uDD69': 'xopf',
+        '\uD835\uDD4F': 'Xopf',
+        '\uD835\uDD1B': 'Xfr',
+        '\uD835\uDCB3': 'Xscr',
+        '\uD835\uDD36': 'yfr',
+        '\uD835\uDCCE': 'yscr',
+        '\uD835\uDD6A': 'yopf',
+        '\uD835\uDCB4': 'Yscr',
+        '\uD835\uDD1C': 'Yfr',
+        '\uD835\uDD50': 'Yopf',
+        '\xFD': 'yacute',
+        '\xDD': 'Yacute',
+        '\u0177': 'ycirc',
+        '\u0176': 'Ycirc',
+        '\xFF': 'yuml',
+        '\u0178': 'Yuml',
+        '\uD835\uDCCF': 'zscr',
+        '\uD835\uDD37': 'zfr',
+        '\uD835\uDD6B': 'zopf',
+        '\u2128': 'Zfr',
+        '\u2124': 'Zopf',
+        '\uD835\uDCB5': 'Zscr',
+        '\u017A': 'zacute',
+        '\u0179': 'Zacute',
+        '\u017E': 'zcaron',
+        '\u017D': 'Zcaron',
+        '\u017C': 'zdot',
+        '\u017B': 'Zdot',
+        '\u01B5': 'imped',
+        '\xFE': 'thorn',
+        '\xDE': 'THORN',
+        '\u0149': 'napos',
+        '\u03B1': 'alpha',
+        '\u0391': 'Alpha',
+        '\u03B2': 'beta',
+        '\u0392': 'Beta',
+        '\u03B3': 'gamma',
+        '\u0393': 'Gamma',
+        '\u03B4': 'delta',
+        '\u0394': 'Delta',
+        '\u03B5': 'epsi',
+        '\u03F5': 'epsiv',
+        '\u0395': 'Epsilon',
+        '\u03DD': 'gammad',
+        '\u03DC': 'Gammad',
+        '\u03B6': 'zeta',
+        '\u0396': 'Zeta',
+        '\u03B7': 'eta',
+        '\u0397': 'Eta',
+        '\u03B8': 'theta',
+        '\u03D1': 'thetav',
+        '\u0398': 'Theta',
+        '\u03B9': 'iota',
+        '\u0399': 'Iota',
+        '\u03BA': 'kappa',
+        '\u03F0': 'kappav',
+        '\u039A': 'Kappa',
+        '\u03BB': 'lambda',
+        '\u039B': 'Lambda',
+        '\u03BC': 'mu',
+        '\xB5': 'micro',
+        '\u039C': 'Mu',
+        '\u03BD': 'nu',
+        '\u039D': 'Nu',
+        '\u03BE': 'xi',
+        '\u039E': 'Xi',
+        '\u03BF': 'omicron',
+        '\u039F': 'Omicron',
+        '\u03C0': 'pi',
+        '\u03D6': 'piv',
+        '\u03A0': 'Pi',
+        '\u03C1': 'rho',
+        '\u03F1': 'rhov',
+        '\u03A1': 'Rho',
+        '\u03C3': 'sigma',
+        '\u03A3': 'Sigma',
+        '\u03C2': 'sigmaf',
+        '\u03C4': 'tau',
+        '\u03A4': 'Tau',
+        '\u03C5': 'upsi',
+        '\u03A5': 'Upsilon',
+        '\u03D2': 'Upsi',
+        '\u03C6': 'phi',
+        '\u03D5': 'phiv',
+        '\u03A6': 'Phi',
+        '\u03C7': 'chi',
+        '\u03A7': 'Chi',
+        '\u03C8': 'psi',
+        '\u03A8': 'Psi',
+        '\u03C9': 'omega',
+        '\u03A9': 'ohm',
+        '\u0430': 'acy',
+        '\u0410': 'Acy',
+        '\u0431': 'bcy',
+        '\u0411': 'Bcy',
+        '\u0432': 'vcy',
+        '\u0412': 'Vcy',
+        '\u0433': 'gcy',
+        '\u0413': 'Gcy',
+        '\u0453': 'gjcy',
+        '\u0403': 'GJcy',
+        '\u0434': 'dcy',
+        '\u0414': 'Dcy',
+        '\u0452': 'djcy',
+        '\u0402': 'DJcy',
+        '\u0435': 'iecy',
+        '\u0415': 'IEcy',
+        '\u0451': 'iocy',
+        '\u0401': 'IOcy',
+        '\u0454': 'jukcy',
+        '\u0404': 'Jukcy',
+        '\u0436': 'zhcy',
+        '\u0416': 'ZHcy',
+        '\u0437': 'zcy',
+        '\u0417': 'Zcy',
+        '\u0455': 'dscy',
+        '\u0405': 'DScy',
+        '\u0438': 'icy',
+        '\u0418': 'Icy',
+        '\u0456': 'iukcy',
+        '\u0406': 'Iukcy',
+        '\u0457': 'yicy',
+        '\u0407': 'YIcy',
+        '\u0439': 'jcy',
+        '\u0419': 'Jcy',
+        '\u0458': 'jsercy',
+        '\u0408': 'Jsercy',
+        '\u043A': 'kcy',
+        '\u041A': 'Kcy',
+        '\u045C': 'kjcy',
+        '\u040C': 'KJcy',
+        '\u043B': 'lcy',
+        '\u041B': 'Lcy',
+        '\u0459': 'ljcy',
+        '\u0409': 'LJcy',
+        '\u043C': 'mcy',
+        '\u041C': 'Mcy',
+        '\u043D': 'ncy',
+        '\u041D': 'Ncy',
+        '\u045A': 'njcy',
+        '\u040A': 'NJcy',
+        '\u043E': 'ocy',
+        '\u041E': 'Ocy',
+        '\u043F': 'pcy',
+        '\u041F': 'Pcy',
+        '\u0440': 'rcy',
+        '\u0420': 'Rcy',
+        '\u0441': 'scy',
+        '\u0421': 'Scy',
+        '\u0442': 'tcy',
+        '\u0422': 'Tcy',
+        '\u045B': 'tshcy',
+        '\u040B': 'TSHcy',
+        '\u0443': 'ucy',
+        '\u0423': 'Ucy',
+        '\u045E': 'ubrcy',
+        '\u040E': 'Ubrcy',
+        '\u0444': 'fcy',
+        '\u0424': 'Fcy',
+        '\u0445': 'khcy',
+        '\u0425': 'KHcy',
+        '\u0446': 'tscy',
+        '\u0426': 'TScy',
+        '\u0447': 'chcy',
+        '\u0427': 'CHcy',
+        '\u045F': 'dzcy',
+        '\u040F': 'DZcy',
+        '\u0448': 'shcy',
+        '\u0428': 'SHcy',
+        '\u0449': 'shchcy',
+        '\u0429': 'SHCHcy',
+        '\u044A': 'hardcy',
+        '\u042A': 'HARDcy',
+        '\u044B': 'ycy',
+        '\u042B': 'Ycy',
+        '\u044C': 'softcy',
+        '\u042C': 'SOFTcy',
+        '\u044D': 'ecy',
+        '\u042D': 'Ecy',
+        '\u044E': 'yucy',
+        '\u042E': 'YUcy',
+        '\u044F': 'yacy',
+        '\u042F': 'YAcy',
+        '\u2135': 'aleph',
+        '\u2136': 'beth',
+        '\u2137': 'gimel',
+        '\u2138': 'daleth'
+      }
+
+      var regexEscape = /["&'<>`]/g
+      var escapeMap = {
+        '"': '&quot;',
+        '&': '&amp;',
+        "'": '&#x27;',
+        '<': '&lt;',
+        // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
+        // following is not strictly necessary unless it’s part of a tag or an
+        // unquoted attribute value. We’re only escaping it to support those
+        // situations, and for XML support.
+        '>': '&gt;',
+        // In Internet Explorer ≤ 8, the backtick character can be used
+        // to break out of (un)quoted attribute values or HTML comments.
+        // See http://html5sec.org/#102, http://html5sec.org/#108, and
+        // http://html5sec.org/#133.
+        '`': '&#x60;'
+      }
+
+      var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/
+      var regexInvalidRawCodePoint =
+        /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
+      var regexDecode =
+        /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g
+      var decodeMap = {
+        aacute: '\xE1',
+        Aacute: '\xC1',
+        abreve: '\u0103',
+        Abreve: '\u0102',
+        ac: '\u223E',
+        acd: '\u223F',
+        acE: '\u223E\u0333',
+        acirc: '\xE2',
+        Acirc: '\xC2',
+        acute: '\xB4',
+        acy: '\u0430',
+        Acy: '\u0410',
+        aelig: '\xE6',
+        AElig: '\xC6',
+        af: '\u2061',
+        afr: '\uD835\uDD1E',
+        Afr: '\uD835\uDD04',
+        agrave: '\xE0',
+        Agrave: '\xC0',
+        alefsym: '\u2135',
+        aleph: '\u2135',
+        alpha: '\u03B1',
+        Alpha: '\u0391',
+        amacr: '\u0101',
+        Amacr: '\u0100',
+        amalg: '\u2A3F',
+        amp: '&',
+        AMP: '&',
+        and: '\u2227',
+        And: '\u2A53',
+        andand: '\u2A55',
+        andd: '\u2A5C',
+        andslope: '\u2A58',
+        andv: '\u2A5A',
+        ang: '\u2220',
+        ange: '\u29A4',
+        angle: '\u2220',
+        angmsd: '\u2221',
+        angmsdaa: '\u29A8',
+        angmsdab: '\u29A9',
+        angmsdac: '\u29AA',
+        angmsdad: '\u29AB',
+        angmsdae: '\u29AC',
+        angmsdaf: '\u29AD',
+        angmsdag: '\u29AE',
+        angmsdah: '\u29AF',
+        angrt: '\u221F',
+        angrtvb: '\u22BE',
+        angrtvbd: '\u299D',
+        angsph: '\u2222',
+        angst: '\xC5',
+        angzarr: '\u237C',
+        aogon: '\u0105',
+        Aogon: '\u0104',
+        aopf: '\uD835\uDD52',
+        Aopf: '\uD835\uDD38',
+        ap: '\u2248',
+        apacir: '\u2A6F',
+        ape: '\u224A',
+        apE: '\u2A70',
+        apid: '\u224B',
+        apos: "'",
+        ApplyFunction: '\u2061',
+        approx: '\u2248',
+        approxeq: '\u224A',
+        aring: '\xE5',
+        Aring: '\xC5',
+        ascr: '\uD835\uDCB6',
+        Ascr: '\uD835\uDC9C',
+        Assign: '\u2254',
+        ast: '*',
+        asymp: '\u2248',
+        asympeq: '\u224D',
+        atilde: '\xE3',
+        Atilde: '\xC3',
+        auml: '\xE4',
+        Auml: '\xC4',
+        awconint: '\u2233',
+        awint: '\u2A11',
+        backcong: '\u224C',
+        backepsilon: '\u03F6',
+        backprime: '\u2035',
+        backsim: '\u223D',
+        backsimeq: '\u22CD',
+        Backslash: '\u2216',
+        Barv: '\u2AE7',
+        barvee: '\u22BD',
+        barwed: '\u2305',
+        Barwed: '\u2306',
+        barwedge: '\u2305',
+        bbrk: '\u23B5',
+        bbrktbrk: '\u23B6',
+        bcong: '\u224C',
+        bcy: '\u0431',
+        Bcy: '\u0411',
+        bdquo: '\u201E',
+        becaus: '\u2235',
+        because: '\u2235',
+        Because: '\u2235',
+        bemptyv: '\u29B0',
+        bepsi: '\u03F6',
+        bernou: '\u212C',
+        Bernoullis: '\u212C',
+        beta: '\u03B2',
+        Beta: '\u0392',
+        beth: '\u2136',
+        between: '\u226C',
+        bfr: '\uD835\uDD1F',
+        Bfr: '\uD835\uDD05',
+        bigcap: '\u22C2',
+        bigcirc: '\u25EF',
+        bigcup: '\u22C3',
+        bigodot: '\u2A00',
+        bigoplus: '\u2A01',
+        bigotimes: '\u2A02',
+        bigsqcup: '\u2A06',
+        bigstar: '\u2605',
+        bigtriangledown: '\u25BD',
+        bigtriangleup: '\u25B3',
+        biguplus: '\u2A04',
+        bigvee: '\u22C1',
+        bigwedge: '\u22C0',
+        bkarow: '\u290D',
+        blacklozenge: '\u29EB',
+        blacksquare: '\u25AA',
+        blacktriangle: '\u25B4',
+        blacktriangledown: '\u25BE',
+        blacktriangleleft: '\u25C2',
+        blacktriangleright: '\u25B8',
+        blank: '\u2423',
+        blk12: '\u2592',
+        blk14: '\u2591',
+        blk34: '\u2593',
+        block: '\u2588',
+        bne: '=\u20E5',
+        bnequiv: '\u2261\u20E5',
+        bnot: '\u2310',
+        bNot: '\u2AED',
+        bopf: '\uD835\uDD53',
+        Bopf: '\uD835\uDD39',
+        bot: '\u22A5',
+        bottom: '\u22A5',
+        bowtie: '\u22C8',
+        boxbox: '\u29C9',
+        boxdl: '\u2510',
+        boxdL: '\u2555',
+        boxDl: '\u2556',
+        boxDL: '\u2557',
+        boxdr: '\u250C',
+        boxdR: '\u2552',
+        boxDr: '\u2553',
+        boxDR: '\u2554',
+        boxh: '\u2500',
+        boxH: '\u2550',
+        boxhd: '\u252C',
+        boxhD: '\u2565',
+        boxHd: '\u2564',
+        boxHD: '\u2566',
+        boxhu: '\u2534',
+        boxhU: '\u2568',
+        boxHu: '\u2567',
+        boxHU: '\u2569',
+        boxminus: '\u229F',
+        boxplus: '\u229E',
+        boxtimes: '\u22A0',
+        boxul: '\u2518',
+        boxuL: '\u255B',
+        boxUl: '\u255C',
+        boxUL: '\u255D',
+        boxur: '\u2514',
+        boxuR: '\u2558',
+        boxUr: '\u2559',
+        boxUR: '\u255A',
+        boxv: '\u2502',
+        boxV: '\u2551',
+        boxvh: '\u253C',
+        boxvH: '\u256A',
+        boxVh: '\u256B',
+        boxVH: '\u256C',
+        boxvl: '\u2524',
+        boxvL: '\u2561',
+        boxVl: '\u2562',
+        boxVL: '\u2563',
+        boxvr: '\u251C',
+        boxvR: '\u255E',
+        boxVr: '\u255F',
+        boxVR: '\u2560',
+        bprime: '\u2035',
+        breve: '\u02D8',
+        Breve: '\u02D8',
+        brvbar: '\xA6',
+        bscr: '\uD835\uDCB7',
+        Bscr: '\u212C',
+        bsemi: '\u204F',
+        bsim: '\u223D',
+        bsime: '\u22CD',
+        bsol: '\\',
+        bsolb: '\u29C5',
+        bsolhsub: '\u27C8',
+        bull: '\u2022',
+        bullet: '\u2022',
+        bump: '\u224E',
+        bumpe: '\u224F',
+        bumpE: '\u2AAE',
+        bumpeq: '\u224F',
+        Bumpeq: '\u224E',
+        cacute: '\u0107',
+        Cacute: '\u0106',
+        cap: '\u2229',
+        Cap: '\u22D2',
+        capand: '\u2A44',
+        capbrcup: '\u2A49',
+        capcap: '\u2A4B',
+        capcup: '\u2A47',
+        capdot: '\u2A40',
+        CapitalDifferentialD: '\u2145',
+        caps: '\u2229\uFE00',
+        caret: '\u2041',
+        caron: '\u02C7',
+        Cayleys: '\u212D',
+        ccaps: '\u2A4D',
+        ccaron: '\u010D',
+        Ccaron: '\u010C',
+        ccedil: '\xE7',
+        Ccedil: '\xC7',
+        ccirc: '\u0109',
+        Ccirc: '\u0108',
+        Cconint: '\u2230',
+        ccups: '\u2A4C',
+        ccupssm: '\u2A50',
+        cdot: '\u010B',
+        Cdot: '\u010A',
+        cedil: '\xB8',
+        Cedilla: '\xB8',
+        cemptyv: '\u29B2',
+        cent: '\xA2',
+        centerdot: '\xB7',
+        CenterDot: '\xB7',
+        cfr: '\uD835\uDD20',
+        Cfr: '\u212D',
+        chcy: '\u0447',
+        CHcy: '\u0427',
+        check: '\u2713',
+        checkmark: '\u2713',
+        chi: '\u03C7',
+        Chi: '\u03A7',
+        cir: '\u25CB',
+        circ: '\u02C6',
+        circeq: '\u2257',
+        circlearrowleft: '\u21BA',
+        circlearrowright: '\u21BB',
+        circledast: '\u229B',
+        circledcirc: '\u229A',
+        circleddash: '\u229D',
+        CircleDot: '\u2299',
+        circledR: '\xAE',
+        circledS: '\u24C8',
+        CircleMinus: '\u2296',
+        CirclePlus: '\u2295',
+        CircleTimes: '\u2297',
+        cire: '\u2257',
+        cirE: '\u29C3',
+        cirfnint: '\u2A10',
+        cirmid: '\u2AEF',
+        cirscir: '\u29C2',
+        ClockwiseContourIntegral: '\u2232',
+        CloseCurlyDoubleQuote: '\u201D',
+        CloseCurlyQuote: '\u2019',
+        clubs: '\u2663',
+        clubsuit: '\u2663',
+        colon: ':',
+        Colon: '\u2237',
+        colone: '\u2254',
+        Colone: '\u2A74',
+        coloneq: '\u2254',
+        comma: ',',
+        commat: '@',
+        comp: '\u2201',
+        compfn: '\u2218',
+        complement: '\u2201',
+        complexes: '\u2102',
+        cong: '\u2245',
+        congdot: '\u2A6D',
+        Congruent: '\u2261',
+        conint: '\u222E',
+        Conint: '\u222F',
+        ContourIntegral: '\u222E',
+        copf: '\uD835\uDD54',
+        Copf: '\u2102',
+        coprod: '\u2210',
+        Coproduct: '\u2210',
+        copy: '\xA9',
+        COPY: '\xA9',
+        copysr: '\u2117',
+        CounterClockwiseContourIntegral: '\u2233',
+        crarr: '\u21B5',
+        cross: '\u2717',
+        Cross: '\u2A2F',
+        cscr: '\uD835\uDCB8',
+        Cscr: '\uD835\uDC9E',
+        csub: '\u2ACF',
+        csube: '\u2AD1',
+        csup: '\u2AD0',
+        csupe: '\u2AD2',
+        ctdot: '\u22EF',
+        cudarrl: '\u2938',
+        cudarrr: '\u2935',
+        cuepr: '\u22DE',
+        cuesc: '\u22DF',
+        cularr: '\u21B6',
+        cularrp: '\u293D',
+        cup: '\u222A',
+        Cup: '\u22D3',
+        cupbrcap: '\u2A48',
+        cupcap: '\u2A46',
+        CupCap: '\u224D',
+        cupcup: '\u2A4A',
+        cupdot: '\u228D',
+        cupor: '\u2A45',
+        cups: '\u222A\uFE00',
+        curarr: '\u21B7',
+        curarrm: '\u293C',
+        curlyeqprec: '\u22DE',
+        curlyeqsucc: '\u22DF',
+        curlyvee: '\u22CE',
+        curlywedge: '\u22CF',
+        curren: '\xA4',
+        curvearrowleft: '\u21B6',
+        curvearrowright: '\u21B7',
+        cuvee: '\u22CE',
+        cuwed: '\u22CF',
+        cwconint: '\u2232',
+        cwint: '\u2231',
+        cylcty: '\u232D',
+        dagger: '\u2020',
+        Dagger: '\u2021',
+        daleth: '\u2138',
+        darr: '\u2193',
+        dArr: '\u21D3',
+        Darr: '\u21A1',
+        dash: '\u2010',
+        dashv: '\u22A3',
+        Dashv: '\u2AE4',
+        dbkarow: '\u290F',
+        dblac: '\u02DD',
+        dcaron: '\u010F',
+        Dcaron: '\u010E',
+        dcy: '\u0434',
+        Dcy: '\u0414',
+        dd: '\u2146',
+        DD: '\u2145',
+        ddagger: '\u2021',
+        ddarr: '\u21CA',
+        DDotrahd: '\u2911',
+        ddotseq: '\u2A77',
+        deg: '\xB0',
+        Del: '\u2207',
+        delta: '\u03B4',
+        Delta: '\u0394',
+        demptyv: '\u29B1',
+        dfisht: '\u297F',
+        dfr: '\uD835\uDD21',
+        Dfr: '\uD835\uDD07',
+        dHar: '\u2965',
+        dharl: '\u21C3',
+        dharr: '\u21C2',
+        DiacriticalAcute: '\xB4',
+        DiacriticalDot: '\u02D9',
+        DiacriticalDoubleAcute: '\u02DD',
+        DiacriticalGrave: '`',
+        DiacriticalTilde: '\u02DC',
+        diam: '\u22C4',
+        diamond: '\u22C4',
+        Diamond: '\u22C4',
+        diamondsuit: '\u2666',
+        diams: '\u2666',
+        die: '\xA8',
+        DifferentialD: '\u2146',
+        digamma: '\u03DD',
+        disin: '\u22F2',
+        div: '\xF7',
+        divide: '\xF7',
+        divideontimes: '\u22C7',
+        divonx: '\u22C7',
+        djcy: '\u0452',
+        DJcy: '\u0402',
+        dlcorn: '\u231E',
+        dlcrop: '\u230D',
+        dollar: '$',
+        dopf: '\uD835\uDD55',
+        Dopf: '\uD835\uDD3B',
+        dot: '\u02D9',
+        Dot: '\xA8',
+        DotDot: '\u20DC',
+        doteq: '\u2250',
+        doteqdot: '\u2251',
+        DotEqual: '\u2250',
+        dotminus: '\u2238',
+        dotplus: '\u2214',
+        dotsquare: '\u22A1',
+        doublebarwedge: '\u2306',
+        DoubleContourIntegral: '\u222F',
+        DoubleDot: '\xA8',
+        DoubleDownArrow: '\u21D3',
+        DoubleLeftArrow: '\u21D0',
+        DoubleLeftRightArrow: '\u21D4',
+        DoubleLeftTee: '\u2AE4',
+        DoubleLongLeftArrow: '\u27F8',
+        DoubleLongLeftRightArrow: '\u27FA',
+        DoubleLongRightArrow: '\u27F9',
+        DoubleRightArrow: '\u21D2',
+        DoubleRightTee: '\u22A8',
+        DoubleUpArrow: '\u21D1',
+        DoubleUpDownArrow: '\u21D5',
+        DoubleVerticalBar: '\u2225',
+        downarrow: '\u2193',
+        Downarrow: '\u21D3',
+        DownArrow: '\u2193',
+        DownArrowBar: '\u2913',
+        DownArrowUpArrow: '\u21F5',
+        DownBreve: '\u0311',
+        downdownarrows: '\u21CA',
+        downharpoonleft: '\u21C3',
+        downharpoonright: '\u21C2',
+        DownLeftRightVector: '\u2950',
+        DownLeftTeeVector: '\u295E',
+        DownLeftVector: '\u21BD',
+        DownLeftVectorBar: '\u2956',
+        DownRightTeeVector: '\u295F',
+        DownRightVector: '\u21C1',
+        DownRightVectorBar: '\u2957',
+        DownTee: '\u22A4',
+        DownTeeArrow: '\u21A7',
+        drbkarow: '\u2910',
+        drcorn: '\u231F',
+        drcrop: '\u230C',
+        dscr: '\uD835\uDCB9',
+        Dscr: '\uD835\uDC9F',
+        dscy: '\u0455',
+        DScy: '\u0405',
+        dsol: '\u29F6',
+        dstrok: '\u0111',
+        Dstrok: '\u0110',
+        dtdot: '\u22F1',
+        dtri: '\u25BF',
+        dtrif: '\u25BE',
+        duarr: '\u21F5',
+        duhar: '\u296F',
+        dwangle: '\u29A6',
+        dzcy: '\u045F',
+        DZcy: '\u040F',
+        dzigrarr: '\u27FF',
+        eacute: '\xE9',
+        Eacute: '\xC9',
+        easter: '\u2A6E',
+        ecaron: '\u011B',
+        Ecaron: '\u011A',
+        ecir: '\u2256',
+        ecirc: '\xEA',
+        Ecirc: '\xCA',
+        ecolon: '\u2255',
+        ecy: '\u044D',
+        Ecy: '\u042D',
+        eDDot: '\u2A77',
+        edot: '\u0117',
+        eDot: '\u2251',
+        Edot: '\u0116',
+        ee: '\u2147',
+        efDot: '\u2252',
+        efr: '\uD835\uDD22',
+        Efr: '\uD835\uDD08',
+        eg: '\u2A9A',
+        egrave: '\xE8',
+        Egrave: '\xC8',
+        egs: '\u2A96',
+        egsdot: '\u2A98',
+        el: '\u2A99',
+        Element: '\u2208',
+        elinters: '\u23E7',
+        ell: '\u2113',
+        els: '\u2A95',
+        elsdot: '\u2A97',
+        emacr: '\u0113',
+        Emacr: '\u0112',
+        empty: '\u2205',
+        emptyset: '\u2205',
+        EmptySmallSquare: '\u25FB',
+        emptyv: '\u2205',
+        EmptyVerySmallSquare: '\u25AB',
+        emsp: '\u2003',
+        emsp13: '\u2004',
+        emsp14: '\u2005',
+        eng: '\u014B',
+        ENG: '\u014A',
+        ensp: '\u2002',
+        eogon: '\u0119',
+        Eogon: '\u0118',
+        eopf: '\uD835\uDD56',
+        Eopf: '\uD835\uDD3C',
+        epar: '\u22D5',
+        eparsl: '\u29E3',
+        eplus: '\u2A71',
+        epsi: '\u03B5',
+        epsilon: '\u03B5',
+        Epsilon: '\u0395',
+        epsiv: '\u03F5',
+        eqcirc: '\u2256',
+        eqcolon: '\u2255',
+        eqsim: '\u2242',
+        eqslantgtr: '\u2A96',
+        eqslantless: '\u2A95',
+        Equal: '\u2A75',
+        equals: '=',
+        EqualTilde: '\u2242',
+        equest: '\u225F',
+        Equilibrium: '\u21CC',
+        equiv: '\u2261',
+        equivDD: '\u2A78',
+        eqvparsl: '\u29E5',
+        erarr: '\u2971',
+        erDot: '\u2253',
+        escr: '\u212F',
+        Escr: '\u2130',
+        esdot: '\u2250',
+        esim: '\u2242',
+        Esim: '\u2A73',
+        eta: '\u03B7',
+        Eta: '\u0397',
+        eth: '\xF0',
+        ETH: '\xD0',
+        euml: '\xEB',
+        Euml: '\xCB',
+        euro: '\u20AC',
+        excl: '!',
+        exist: '\u2203',
+        Exists: '\u2203',
+        expectation: '\u2130',
+        exponentiale: '\u2147',
+        ExponentialE: '\u2147',
+        fallingdotseq: '\u2252',
+        fcy: '\u0444',
+        Fcy: '\u0424',
+        female: '\u2640',
+        ffilig: '\uFB03',
+        fflig: '\uFB00',
+        ffllig: '\uFB04',
+        ffr: '\uD835\uDD23',
+        Ffr: '\uD835\uDD09',
+        filig: '\uFB01',
+        FilledSmallSquare: '\u25FC',
+        FilledVerySmallSquare: '\u25AA',
+        fjlig: 'fj',
+        flat: '\u266D',
+        fllig: '\uFB02',
+        fltns: '\u25B1',
+        fnof: '\u0192',
+        fopf: '\uD835\uDD57',
+        Fopf: '\uD835\uDD3D',
+        forall: '\u2200',
+        ForAll: '\u2200',
+        fork: '\u22D4',
+        forkv: '\u2AD9',
+        Fouriertrf: '\u2131',
+        fpartint: '\u2A0D',
+        frac12: '\xBD',
+        frac13: '\u2153',
+        frac14: '\xBC',
+        frac15: '\u2155',
+        frac16: '\u2159',
+        frac18: '\u215B',
+        frac23: '\u2154',
+        frac25: '\u2156',
+        frac34: '\xBE',
+        frac35: '\u2157',
+        frac38: '\u215C',
+        frac45: '\u2158',
+        frac56: '\u215A',
+        frac58: '\u215D',
+        frac78: '\u215E',
+        frasl: '\u2044',
+        frown: '\u2322',
+        fscr: '\uD835\uDCBB',
+        Fscr: '\u2131',
+        gacute: '\u01F5',
+        gamma: '\u03B3',
+        Gamma: '\u0393',
+        gammad: '\u03DD',
+        Gammad: '\u03DC',
+        gap: '\u2A86',
+        gbreve: '\u011F',
+        Gbreve: '\u011E',
+        Gcedil: '\u0122',
+        gcirc: '\u011D',
+        Gcirc: '\u011C',
+        gcy: '\u0433',
+        Gcy: '\u0413',
+        gdot: '\u0121',
+        Gdot: '\u0120',
+        ge: '\u2265',
+        gE: '\u2267',
+        gel: '\u22DB',
+        gEl: '\u2A8C',
+        geq: '\u2265',
+        geqq: '\u2267',
+        geqslant: '\u2A7E',
+        ges: '\u2A7E',
+        gescc: '\u2AA9',
+        gesdot: '\u2A80',
+        gesdoto: '\u2A82',
+        gesdotol: '\u2A84',
+        gesl: '\u22DB\uFE00',
+        gesles: '\u2A94',
+        gfr: '\uD835\uDD24',
+        Gfr: '\uD835\uDD0A',
+        gg: '\u226B',
+        Gg: '\u22D9',
+        ggg: '\u22D9',
+        gimel: '\u2137',
+        gjcy: '\u0453',
+        GJcy: '\u0403',
+        gl: '\u2277',
+        gla: '\u2AA5',
+        glE: '\u2A92',
+        glj: '\u2AA4',
+        gnap: '\u2A8A',
+        gnapprox: '\u2A8A',
+        gne: '\u2A88',
+        gnE: '\u2269',
+        gneq: '\u2A88',
+        gneqq: '\u2269',
+        gnsim: '\u22E7',
+        gopf: '\uD835\uDD58',
+        Gopf: '\uD835\uDD3E',
+        grave: '`',
+        GreaterEqual: '\u2265',
+        GreaterEqualLess: '\u22DB',
+        GreaterFullEqual: '\u2267',
+        GreaterGreater: '\u2AA2',
+        GreaterLess: '\u2277',
+        GreaterSlantEqual: '\u2A7E',
+        GreaterTilde: '\u2273',
+        gscr: '\u210A',
+        Gscr: '\uD835\uDCA2',
+        gsim: '\u2273',
+        gsime: '\u2A8E',
+        gsiml: '\u2A90',
+        gt: '>',
+        Gt: '\u226B',
+        GT: '>',
+        gtcc: '\u2AA7',
+        gtcir: '\u2A7A',
+        gtdot: '\u22D7',
+        gtlPar: '\u2995',
+        gtquest: '\u2A7C',
+        gtrapprox: '\u2A86',
+        gtrarr: '\u2978',
+        gtrdot: '\u22D7',
+        gtreqless: '\u22DB',
+        gtreqqless: '\u2A8C',
+        gtrless: '\u2277',
+        gtrsim: '\u2273',
+        gvertneqq: '\u2269\uFE00',
+        gvnE: '\u2269\uFE00',
+        Hacek: '\u02C7',
+        hairsp: '\u200A',
+        half: '\xBD',
+        hamilt: '\u210B',
+        hardcy: '\u044A',
+        HARDcy: '\u042A',
+        harr: '\u2194',
+        hArr: '\u21D4',
+        harrcir: '\u2948',
+        harrw: '\u21AD',
+        Hat: '^',
+        hbar: '\u210F',
+        hcirc: '\u0125',
+        Hcirc: '\u0124',
+        hearts: '\u2665',
+        heartsuit: '\u2665',
+        hellip: '\u2026',
+        hercon: '\u22B9',
+        hfr: '\uD835\uDD25',
+        Hfr: '\u210C',
+        HilbertSpace: '\u210B',
+        hksearow: '\u2925',
+        hkswarow: '\u2926',
+        hoarr: '\u21FF',
+        homtht: '\u223B',
+        hookleftarrow: '\u21A9',
+        hookrightarrow: '\u21AA',
+        hopf: '\uD835\uDD59',
+        Hopf: '\u210D',
+        horbar: '\u2015',
+        HorizontalLine: '\u2500',
+        hscr: '\uD835\uDCBD',
+        Hscr: '\u210B',
+        hslash: '\u210F',
+        hstrok: '\u0127',
+        Hstrok: '\u0126',
+        HumpDownHump: '\u224E',
+        HumpEqual: '\u224F',
+        hybull: '\u2043',
+        hyphen: '\u2010',
+        iacute: '\xED',
+        Iacute: '\xCD',
+        ic: '\u2063',
+        icirc: '\xEE',
+        Icirc: '\xCE',
+        icy: '\u0438',
+        Icy: '\u0418',
+        Idot: '\u0130',
+        iecy: '\u0435',
+        IEcy: '\u0415',
+        iexcl: '\xA1',
+        iff: '\u21D4',
+        ifr: '\uD835\uDD26',
+        Ifr: '\u2111',
+        igrave: '\xEC',
+        Igrave: '\xCC',
+        ii: '\u2148',
+        iiiint: '\u2A0C',
+        iiint: '\u222D',
+        iinfin: '\u29DC',
+        iiota: '\u2129',
+        ijlig: '\u0133',
+        IJlig: '\u0132',
+        Im: '\u2111',
+        imacr: '\u012B',
+        Imacr: '\u012A',
+        image: '\u2111',
+        ImaginaryI: '\u2148',
+        imagline: '\u2110',
+        imagpart: '\u2111',
+        imath: '\u0131',
+        imof: '\u22B7',
+        imped: '\u01B5',
+        Implies: '\u21D2',
+        in: '\u2208',
+        incare: '\u2105',
+        infin: '\u221E',
+        infintie: '\u29DD',
+        inodot: '\u0131',
+        int: '\u222B',
+        Int: '\u222C',
+        intcal: '\u22BA',
+        integers: '\u2124',
+        Integral: '\u222B',
+        intercal: '\u22BA',
+        Intersection: '\u22C2',
+        intlarhk: '\u2A17',
+        intprod: '\u2A3C',
+        InvisibleComma: '\u2063',
+        InvisibleTimes: '\u2062',
+        iocy: '\u0451',
+        IOcy: '\u0401',
+        iogon: '\u012F',
+        Iogon: '\u012E',
+        iopf: '\uD835\uDD5A',
+        Iopf: '\uD835\uDD40',
+        iota: '\u03B9',
+        Iota: '\u0399',
+        iprod: '\u2A3C',
+        iquest: '\xBF',
+        iscr: '\uD835\uDCBE',
+        Iscr: '\u2110',
+        isin: '\u2208',
+        isindot: '\u22F5',
+        isinE: '\u22F9',
+        isins: '\u22F4',
+        isinsv: '\u22F3',
+        isinv: '\u2208',
+        it: '\u2062',
+        itilde: '\u0129',
+        Itilde: '\u0128',
+        iukcy: '\u0456',
+        Iukcy: '\u0406',
+        iuml: '\xEF',
+        Iuml: '\xCF',
+        jcirc: '\u0135',
+        Jcirc: '\u0134',
+        jcy: '\u0439',
+        Jcy: '\u0419',
+        jfr: '\uD835\uDD27',
+        Jfr: '\uD835\uDD0D',
+        jmath: '\u0237',
+        jopf: '\uD835\uDD5B',
+        Jopf: '\uD835\uDD41',
+        jscr: '\uD835\uDCBF',
+        Jscr: '\uD835\uDCA5',
+        jsercy: '\u0458',
+        Jsercy: '\u0408',
+        jukcy: '\u0454',
+        Jukcy: '\u0404',
+        kappa: '\u03BA',
+        Kappa: '\u039A',
+        kappav: '\u03F0',
+        kcedil: '\u0137',
+        Kcedil: '\u0136',
+        kcy: '\u043A',
+        Kcy: '\u041A',
+        kfr: '\uD835\uDD28',
+        Kfr: '\uD835\uDD0E',
+        kgreen: '\u0138',
+        khcy: '\u0445',
+        KHcy: '\u0425',
+        kjcy: '\u045C',
+        KJcy: '\u040C',
+        kopf: '\uD835\uDD5C',
+        Kopf: '\uD835\uDD42',
+        kscr: '\uD835\uDCC0',
+        Kscr: '\uD835\uDCA6',
+        lAarr: '\u21DA',
+        lacute: '\u013A',
+        Lacute: '\u0139',
+        laemptyv: '\u29B4',
+        lagran: '\u2112',
+        lambda: '\u03BB',
+        Lambda: '\u039B',
+        lang: '\u27E8',
+        Lang: '\u27EA',
+        langd: '\u2991',
+        langle: '\u27E8',
+        lap: '\u2A85',
+        Laplacetrf: '\u2112',
+        laquo: '\xAB',
+        larr: '\u2190',
+        lArr: '\u21D0',
+        Larr: '\u219E',
+        larrb: '\u21E4',
+        larrbfs: '\u291F',
+        larrfs: '\u291D',
+        larrhk: '\u21A9',
+        larrlp: '\u21AB',
+        larrpl: '\u2939',
+        larrsim: '\u2973',
+        larrtl: '\u21A2',
+        lat: '\u2AAB',
+        latail: '\u2919',
+        lAtail: '\u291B',
+        late: '\u2AAD',
+        lates: '\u2AAD\uFE00',
+        lbarr: '\u290C',
+        lBarr: '\u290E',
+        lbbrk: '\u2772',
+        lbrace: '{',
+        lbrack: '[',
+        lbrke: '\u298B',
+        lbrksld: '\u298F',
+        lbrkslu: '\u298D',
+        lcaron: '\u013E',
+        Lcaron: '\u013D',
+        lcedil: '\u013C',
+        Lcedil: '\u013B',
+        lceil: '\u2308',
+        lcub: '{',
+        lcy: '\u043B',
+        Lcy: '\u041B',
+        ldca: '\u2936',
+        ldquo: '\u201C',
+        ldquor: '\u201E',
+        ldrdhar: '\u2967',
+        ldrushar: '\u294B',
+        ldsh: '\u21B2',
+        le: '\u2264',
+        lE: '\u2266',
+        LeftAngleBracket: '\u27E8',
+        leftarrow: '\u2190',
+        Leftarrow: '\u21D0',
+        LeftArrow: '\u2190',
+        LeftArrowBar: '\u21E4',
+        LeftArrowRightArrow: '\u21C6',
+        leftarrowtail: '\u21A2',
+        LeftCeiling: '\u2308',
+        LeftDoubleBracket: '\u27E6',
+        LeftDownTeeVector: '\u2961',
+        LeftDownVector: '\u21C3',
+        LeftDownVectorBar: '\u2959',
+        LeftFloor: '\u230A',
+        leftharpoondown: '\u21BD',
+        leftharpoonup: '\u21BC',
+        leftleftarrows: '\u21C7',
+        leftrightarrow: '\u2194',
+        Leftrightarrow: '\u21D4',
+        LeftRightArrow: '\u2194',
+        leftrightarrows: '\u21C6',
+        leftrightharpoons: '\u21CB',
+        leftrightsquigarrow: '\u21AD',
+        LeftRightVector: '\u294E',
+        LeftTee: '\u22A3',
+        LeftTeeArrow: '\u21A4',
+        LeftTeeVector: '\u295A',
+        leftthreetimes: '\u22CB',
+        LeftTriangle: '\u22B2',
+        LeftTriangleBar: '\u29CF',
+        LeftTriangleEqual: '\u22B4',
+        LeftUpDownVector: '\u2951',
+        LeftUpTeeVector: '\u2960',
+        LeftUpVector: '\u21BF',
+        LeftUpVectorBar: '\u2958',
+        LeftVector: '\u21BC',
+        LeftVectorBar: '\u2952',
+        leg: '\u22DA',
+        lEg: '\u2A8B',
+        leq: '\u2264',
+        leqq: '\u2266',
+        leqslant: '\u2A7D',
+        les: '\u2A7D',
+        lescc: '\u2AA8',
+        lesdot: '\u2A7F',
+        lesdoto: '\u2A81',
+        lesdotor: '\u2A83',
+        lesg: '\u22DA\uFE00',
+        lesges: '\u2A93',
+        lessapprox: '\u2A85',
+        lessdot: '\u22D6',
+        lesseqgtr: '\u22DA',
+        lesseqqgtr: '\u2A8B',
+        LessEqualGreater: '\u22DA',
+        LessFullEqual: '\u2266',
+        LessGreater: '\u2276',
+        lessgtr: '\u2276',
+        LessLess: '\u2AA1',
+        lesssim: '\u2272',
+        LessSlantEqual: '\u2A7D',
+        LessTilde: '\u2272',
+        lfisht: '\u297C',
+        lfloor: '\u230A',
+        lfr: '\uD835\uDD29',
+        Lfr: '\uD835\uDD0F',
+        lg: '\u2276',
+        lgE: '\u2A91',
+        lHar: '\u2962',
+        lhard: '\u21BD',
+        lharu: '\u21BC',
+        lharul: '\u296A',
+        lhblk: '\u2584',
+        ljcy: '\u0459',
+        LJcy: '\u0409',
+        ll: '\u226A',
+        Ll: '\u22D8',
+        llarr: '\u21C7',
+        llcorner: '\u231E',
+        Lleftarrow: '\u21DA',
+        llhard: '\u296B',
+        lltri: '\u25FA',
+        lmidot: '\u0140',
+        Lmidot: '\u013F',
+        lmoust: '\u23B0',
+        lmoustache: '\u23B0',
+        lnap: '\u2A89',
+        lnapprox: '\u2A89',
+        lne: '\u2A87',
+        lnE: '\u2268',
+        lneq: '\u2A87',
+        lneqq: '\u2268',
+        lnsim: '\u22E6',
+        loang: '\u27EC',
+        loarr: '\u21FD',
+        lobrk: '\u27E6',
+        longleftarrow: '\u27F5',
+        Longleftarrow: '\u27F8',
+        LongLeftArrow: '\u27F5',
+        longleftrightarrow: '\u27F7',
+        Longleftrightarrow: '\u27FA',
+        LongLeftRightArrow: '\u27F7',
+        longmapsto: '\u27FC',
+        longrightarrow: '\u27F6',
+        Longrightarrow: '\u27F9',
+        LongRightArrow: '\u27F6',
+        looparrowleft: '\u21AB',
+        looparrowright: '\u21AC',
+        lopar: '\u2985',
+        lopf: '\uD835\uDD5D',
+        Lopf: '\uD835\uDD43',
+        loplus: '\u2A2D',
+        lotimes: '\u2A34',
+        lowast: '\u2217',
+        lowbar: '_',
+        LowerLeftArrow: '\u2199',
+        LowerRightArrow: '\u2198',
+        loz: '\u25CA',
+        lozenge: '\u25CA',
+        lozf: '\u29EB',
+        lpar: '(',
+        lparlt: '\u2993',
+        lrarr: '\u21C6',
+        lrcorner: '\u231F',
+        lrhar: '\u21CB',
+        lrhard: '\u296D',
+        lrm: '\u200E',
+        lrtri: '\u22BF',
+        lsaquo: '\u2039',
+        lscr: '\uD835\uDCC1',
+        Lscr: '\u2112',
+        lsh: '\u21B0',
+        Lsh: '\u21B0',
+        lsim: '\u2272',
+        lsime: '\u2A8D',
+        lsimg: '\u2A8F',
+        lsqb: '[',
+        lsquo: '\u2018',
+        lsquor: '\u201A',
+        lstrok: '\u0142',
+        Lstrok: '\u0141',
+        lt: '<',
+        Lt: '\u226A',
+        LT: '<',
+        ltcc: '\u2AA6',
+        ltcir: '\u2A79',
+        ltdot: '\u22D6',
+        lthree: '\u22CB',
+        ltimes: '\u22C9',
+        ltlarr: '\u2976',
+        ltquest: '\u2A7B',
+        ltri: '\u25C3',
+        ltrie: '\u22B4',
+        ltrif: '\u25C2',
+        ltrPar: '\u2996',
+        lurdshar: '\u294A',
+        luruhar: '\u2966',
+        lvertneqq: '\u2268\uFE00',
+        lvnE: '\u2268\uFE00',
+        macr: '\xAF',
+        male: '\u2642',
+        malt: '\u2720',
+        maltese: '\u2720',
+        map: '\u21A6',
+        Map: '\u2905',
+        mapsto: '\u21A6',
+        mapstodown: '\u21A7',
+        mapstoleft: '\u21A4',
+        mapstoup: '\u21A5',
+        marker: '\u25AE',
+        mcomma: '\u2A29',
+        mcy: '\u043C',
+        Mcy: '\u041C',
+        mdash: '\u2014',
+        mDDot: '\u223A',
+        measuredangle: '\u2221',
+        MediumSpace: '\u205F',
+        Mellintrf: '\u2133',
+        mfr: '\uD835\uDD2A',
+        Mfr: '\uD835\uDD10',
+        mho: '\u2127',
+        micro: '\xB5',
+        mid: '\u2223',
+        midast: '*',
+        midcir: '\u2AF0',
+        middot: '\xB7',
+        minus: '\u2212',
+        minusb: '\u229F',
+        minusd: '\u2238',
+        minusdu: '\u2A2A',
+        MinusPlus: '\u2213',
+        mlcp: '\u2ADB',
+        mldr: '\u2026',
+        mnplus: '\u2213',
+        models: '\u22A7',
+        mopf: '\uD835\uDD5E',
+        Mopf: '\uD835\uDD44',
+        mp: '\u2213',
+        mscr: '\uD835\uDCC2',
+        Mscr: '\u2133',
+        mstpos: '\u223E',
+        mu: '\u03BC',
+        Mu: '\u039C',
+        multimap: '\u22B8',
+        mumap: '\u22B8',
+        nabla: '\u2207',
+        nacute: '\u0144',
+        Nacute: '\u0143',
+        nang: '\u2220\u20D2',
+        nap: '\u2249',
+        napE: '\u2A70\u0338',
+        napid: '\u224B\u0338',
+        napos: '\u0149',
+        napprox: '\u2249',
+        natur: '\u266E',
+        natural: '\u266E',
+        naturals: '\u2115',
+        nbsp: '\xA0',
+        nbump: '\u224E\u0338',
+        nbumpe: '\u224F\u0338',
+        ncap: '\u2A43',
+        ncaron: '\u0148',
+        Ncaron: '\u0147',
+        ncedil: '\u0146',
+        Ncedil: '\u0145',
+        ncong: '\u2247',
+        ncongdot: '\u2A6D\u0338',
+        ncup: '\u2A42',
+        ncy: '\u043D',
+        Ncy: '\u041D',
+        ndash: '\u2013',
+        ne: '\u2260',
+        nearhk: '\u2924',
+        nearr: '\u2197',
+        neArr: '\u21D7',
+        nearrow: '\u2197',
+        nedot: '\u2250\u0338',
+        NegativeMediumSpace: '\u200B',
+        NegativeThickSpace: '\u200B',
+        NegativeThinSpace: '\u200B',
+        NegativeVeryThinSpace: '\u200B',
+        nequiv: '\u2262',
+        nesear: '\u2928',
+        nesim: '\u2242\u0338',
+        NestedGreaterGreater: '\u226B',
+        NestedLessLess: '\u226A',
+        NewLine: '\n',
+        nexist: '\u2204',
+        nexists: '\u2204',
+        nfr: '\uD835\uDD2B',
+        Nfr: '\uD835\uDD11',
+        nge: '\u2271',
+        ngE: '\u2267\u0338',
+        ngeq: '\u2271',
+        ngeqq: '\u2267\u0338',
+        ngeqslant: '\u2A7E\u0338',
+        nges: '\u2A7E\u0338',
+        nGg: '\u22D9\u0338',
+        ngsim: '\u2275',
+        ngt: '\u226F',
+        nGt: '\u226B\u20D2',
+        ngtr: '\u226F',
+        nGtv: '\u226B\u0338',
+        nharr: '\u21AE',
+        nhArr: '\u21CE',
+        nhpar: '\u2AF2',
+        ni: '\u220B',
+        nis: '\u22FC',
+        nisd: '\u22FA',
+        niv: '\u220B',
+        njcy: '\u045A',
+        NJcy: '\u040A',
+        nlarr: '\u219A',
+        nlArr: '\u21CD',
+        nldr: '\u2025',
+        nle: '\u2270',
+        nlE: '\u2266\u0338',
+        nleftarrow: '\u219A',
+        nLeftarrow: '\u21CD',
+        nleftrightarrow: '\u21AE',
+        nLeftrightarrow: '\u21CE',
+        nleq: '\u2270',
+        nleqq: '\u2266\u0338',
+        nleqslant: '\u2A7D\u0338',
+        nles: '\u2A7D\u0338',
+        nless: '\u226E',
+        nLl: '\u22D8\u0338',
+        nlsim: '\u2274',
+        nlt: '\u226E',
+        nLt: '\u226A\u20D2',
+        nltri: '\u22EA',
+        nltrie: '\u22EC',
+        nLtv: '\u226A\u0338',
+        nmid: '\u2224',
+        NoBreak: '\u2060',
+        NonBreakingSpace: '\xA0',
+        nopf: '\uD835\uDD5F',
+        Nopf: '\u2115',
+        not: '\xAC',
+        Not: '\u2AEC',
+        NotCongruent: '\u2262',
+        NotCupCap: '\u226D',
+        NotDoubleVerticalBar: '\u2226',
+        NotElement: '\u2209',
+        NotEqual: '\u2260',
+        NotEqualTilde: '\u2242\u0338',
+        NotExists: '\u2204',
+        NotGreater: '\u226F',
+        NotGreaterEqual: '\u2271',
+        NotGreaterFullEqual: '\u2267\u0338',
+        NotGreaterGreater: '\u226B\u0338',
+        NotGreaterLess: '\u2279',
+        NotGreaterSlantEqual: '\u2A7E\u0338',
+        NotGreaterTilde: '\u2275',
+        NotHumpDownHump: '\u224E\u0338',
+        NotHumpEqual: '\u224F\u0338',
+        notin: '\u2209',
+        notindot: '\u22F5\u0338',
+        notinE: '\u22F9\u0338',
+        notinva: '\u2209',
+        notinvb: '\u22F7',
+        notinvc: '\u22F6',
+        NotLeftTriangle: '\u22EA',
+        NotLeftTriangleBar: '\u29CF\u0338',
+        NotLeftTriangleEqual: '\u22EC',
+        NotLess: '\u226E',
+        NotLessEqual: '\u2270',
+        NotLessGreater: '\u2278',
+        NotLessLess: '\u226A\u0338',
+        NotLessSlantEqual: '\u2A7D\u0338',
+        NotLessTilde: '\u2274',
+        NotNestedGreaterGreater: '\u2AA2\u0338',
+        NotNestedLessLess: '\u2AA1\u0338',
+        notni: '\u220C',
+        notniva: '\u220C',
+        notnivb: '\u22FE',
+        notnivc: '\u22FD',
+        NotPrecedes: '\u2280',
+        NotPrecedesEqual: '\u2AAF\u0338',
+        NotPrecedesSlantEqual: '\u22E0',
+        NotReverseElement: '\u220C',
+        NotRightTriangle: '\u22EB',
+        NotRightTriangleBar: '\u29D0\u0338',
+        NotRightTriangleEqual: '\u22ED',
+        NotSquareSubset: '\u228F\u0338',
+        NotSquareSubsetEqual: '\u22E2',
+        NotSquareSuperset: '\u2290\u0338',
+        NotSquareSupersetEqual: '\u22E3',
+        NotSubset: '\u2282\u20D2',
+        NotSubsetEqual: '\u2288',
+        NotSucceeds: '\u2281',
+        NotSucceedsEqual: '\u2AB0\u0338',
+        NotSucceedsSlantEqual: '\u22E1',
+        NotSucceedsTilde: '\u227F\u0338',
+        NotSuperset: '\u2283\u20D2',
+        NotSupersetEqual: '\u2289',
+        NotTilde: '\u2241',
+        NotTildeEqual: '\u2244',
+        NotTildeFullEqual: '\u2247',
+        NotTildeTilde: '\u2249',
+        NotVerticalBar: '\u2224',
+        npar: '\u2226',
+        nparallel: '\u2226',
+        nparsl: '\u2AFD\u20E5',
+        npart: '\u2202\u0338',
+        npolint: '\u2A14',
+        npr: '\u2280',
+        nprcue: '\u22E0',
+        npre: '\u2AAF\u0338',
+        nprec: '\u2280',
+        npreceq: '\u2AAF\u0338',
+        nrarr: '\u219B',
+        nrArr: '\u21CF',
+        nrarrc: '\u2933\u0338',
+        nrarrw: '\u219D\u0338',
+        nrightarrow: '\u219B',
+        nRightarrow: '\u21CF',
+        nrtri: '\u22EB',
+        nrtrie: '\u22ED',
+        nsc: '\u2281',
+        nsccue: '\u22E1',
+        nsce: '\u2AB0\u0338',
+        nscr: '\uD835\uDCC3',
+        Nscr: '\uD835\uDCA9',
+        nshortmid: '\u2224',
+        nshortparallel: '\u2226',
+        nsim: '\u2241',
+        nsime: '\u2244',
+        nsimeq: '\u2244',
+        nsmid: '\u2224',
+        nspar: '\u2226',
+        nsqsube: '\u22E2',
+        nsqsupe: '\u22E3',
+        nsub: '\u2284',
+        nsube: '\u2288',
+        nsubE: '\u2AC5\u0338',
+        nsubset: '\u2282\u20D2',
+        nsubseteq: '\u2288',
+        nsubseteqq: '\u2AC5\u0338',
+        nsucc: '\u2281',
+        nsucceq: '\u2AB0\u0338',
+        nsup: '\u2285',
+        nsupe: '\u2289',
+        nsupE: '\u2AC6\u0338',
+        nsupset: '\u2283\u20D2',
+        nsupseteq: '\u2289',
+        nsupseteqq: '\u2AC6\u0338',
+        ntgl: '\u2279',
+        ntilde: '\xF1',
+        Ntilde: '\xD1',
+        ntlg: '\u2278',
+        ntriangleleft: '\u22EA',
+        ntrianglelefteq: '\u22EC',
+        ntriangleright: '\u22EB',
+        ntrianglerighteq: '\u22ED',
+        nu: '\u03BD',
+        Nu: '\u039D',
+        num: '#',
+        numero: '\u2116',
+        numsp: '\u2007',
+        nvap: '\u224D\u20D2',
+        nvdash: '\u22AC',
+        nvDash: '\u22AD',
+        nVdash: '\u22AE',
+        nVDash: '\u22AF',
+        nvge: '\u2265\u20D2',
+        nvgt: '>\u20D2',
+        nvHarr: '\u2904',
+        nvinfin: '\u29DE',
+        nvlArr: '\u2902',
+        nvle: '\u2264\u20D2',
+        nvlt: '<\u20D2',
+        nvltrie: '\u22B4\u20D2',
+        nvrArr: '\u2903',
+        nvrtrie: '\u22B5\u20D2',
+        nvsim: '\u223C\u20D2',
+        nwarhk: '\u2923',
+        nwarr: '\u2196',
+        nwArr: '\u21D6',
+        nwarrow: '\u2196',
+        nwnear: '\u2927',
+        oacute: '\xF3',
+        Oacute: '\xD3',
+        oast: '\u229B',
+        ocir: '\u229A',
+        ocirc: '\xF4',
+        Ocirc: '\xD4',
+        ocy: '\u043E',
+        Ocy: '\u041E',
+        odash: '\u229D',
+        odblac: '\u0151',
+        Odblac: '\u0150',
+        odiv: '\u2A38',
+        odot: '\u2299',
+        odsold: '\u29BC',
+        oelig: '\u0153',
+        OElig: '\u0152',
+        ofcir: '\u29BF',
+        ofr: '\uD835\uDD2C',
+        Ofr: '\uD835\uDD12',
+        ogon: '\u02DB',
+        ograve: '\xF2',
+        Ograve: '\xD2',
+        ogt: '\u29C1',
+        ohbar: '\u29B5',
+        ohm: '\u03A9',
+        oint: '\u222E',
+        olarr: '\u21BA',
+        olcir: '\u29BE',
+        olcross: '\u29BB',
+        oline: '\u203E',
+        olt: '\u29C0',
+        omacr: '\u014D',
+        Omacr: '\u014C',
+        omega: '\u03C9',
+        Omega: '\u03A9',
+        omicron: '\u03BF',
+        Omicron: '\u039F',
+        omid: '\u29B6',
+        ominus: '\u2296',
+        oopf: '\uD835\uDD60',
+        Oopf: '\uD835\uDD46',
+        opar: '\u29B7',
+        OpenCurlyDoubleQuote: '\u201C',
+        OpenCurlyQuote: '\u2018',
+        operp: '\u29B9',
+        oplus: '\u2295',
+        or: '\u2228',
+        Or: '\u2A54',
+        orarr: '\u21BB',
+        ord: '\u2A5D',
+        order: '\u2134',
+        orderof: '\u2134',
+        ordf: '\xAA',
+        ordm: '\xBA',
+        origof: '\u22B6',
+        oror: '\u2A56',
+        orslope: '\u2A57',
+        orv: '\u2A5B',
+        oS: '\u24C8',
+        oscr: '\u2134',
+        Oscr: '\uD835\uDCAA',
+        oslash: '\xF8',
+        Oslash: '\xD8',
+        osol: '\u2298',
+        otilde: '\xF5',
+        Otilde: '\xD5',
+        otimes: '\u2297',
+        Otimes: '\u2A37',
+        otimesas: '\u2A36',
+        ouml: '\xF6',
+        Ouml: '\xD6',
+        ovbar: '\u233D',
+        OverBar: '\u203E',
+        OverBrace: '\u23DE',
+        OverBracket: '\u23B4',
+        OverParenthesis: '\u23DC',
+        par: '\u2225',
+        para: '\xB6',
+        parallel: '\u2225',
+        parsim: '\u2AF3',
+        parsl: '\u2AFD',
+        part: '\u2202',
+        PartialD: '\u2202',
+        pcy: '\u043F',
+        Pcy: '\u041F',
+        percnt: '%',
+        period: '.',
+        permil: '\u2030',
+        perp: '\u22A5',
+        pertenk: '\u2031',
+        pfr: '\uD835\uDD2D',
+        Pfr: '\uD835\uDD13',
+        phi: '\u03C6',
+        Phi: '\u03A6',
+        phiv: '\u03D5',
+        phmmat: '\u2133',
+        phone: '\u260E',
+        pi: '\u03C0',
+        Pi: '\u03A0',
+        pitchfork: '\u22D4',
+        piv: '\u03D6',
+        planck: '\u210F',
+        planckh: '\u210E',
+        plankv: '\u210F',
+        plus: '+',
+        plusacir: '\u2A23',
+        plusb: '\u229E',
+        pluscir: '\u2A22',
+        plusdo: '\u2214',
+        plusdu: '\u2A25',
+        pluse: '\u2A72',
+        PlusMinus: '\xB1',
+        plusmn: '\xB1',
+        plussim: '\u2A26',
+        plustwo: '\u2A27',
+        pm: '\xB1',
+        Poincareplane: '\u210C',
+        pointint: '\u2A15',
+        popf: '\uD835\uDD61',
+        Popf: '\u2119',
+        pound: '\xA3',
+        pr: '\u227A',
+        Pr: '\u2ABB',
+        prap: '\u2AB7',
+        prcue: '\u227C',
+        pre: '\u2AAF',
+        prE: '\u2AB3',
+        prec: '\u227A',
+        precapprox: '\u2AB7',
+        preccurlyeq: '\u227C',
+        Precedes: '\u227A',
+        PrecedesEqual: '\u2AAF',
+        PrecedesSlantEqual: '\u227C',
+        PrecedesTilde: '\u227E',
+        preceq: '\u2AAF',
+        precnapprox: '\u2AB9',
+        precneqq: '\u2AB5',
+        precnsim: '\u22E8',
+        precsim: '\u227E',
+        prime: '\u2032',
+        Prime: '\u2033',
+        primes: '\u2119',
+        prnap: '\u2AB9',
+        prnE: '\u2AB5',
+        prnsim: '\u22E8',
+        prod: '\u220F',
+        Product: '\u220F',
+        profalar: '\u232E',
+        profline: '\u2312',
+        profsurf: '\u2313',
+        prop: '\u221D',
+        Proportion: '\u2237',
+        Proportional: '\u221D',
+        propto: '\u221D',
+        prsim: '\u227E',
+        prurel: '\u22B0',
+        pscr: '\uD835\uDCC5',
+        Pscr: '\uD835\uDCAB',
+        psi: '\u03C8',
+        Psi: '\u03A8',
+        puncsp: '\u2008',
+        qfr: '\uD835\uDD2E',
+        Qfr: '\uD835\uDD14',
+        qint: '\u2A0C',
+        qopf: '\uD835\uDD62',
+        Qopf: '\u211A',
+        qprime: '\u2057',
+        qscr: '\uD835\uDCC6',
+        Qscr: '\uD835\uDCAC',
+        quaternions: '\u210D',
+        quatint: '\u2A16',
+        quest: '?',
+        questeq: '\u225F',
+        quot: '"',
+        QUOT: '"',
+        rAarr: '\u21DB',
+        race: '\u223D\u0331',
+        racute: '\u0155',
+        Racute: '\u0154',
+        radic: '\u221A',
+        raemptyv: '\u29B3',
+        rang: '\u27E9',
+        Rang: '\u27EB',
+        rangd: '\u2992',
+        range: '\u29A5',
+        rangle: '\u27E9',
+        raquo: '\xBB',
+        rarr: '\u2192',
+        rArr: '\u21D2',
+        Rarr: '\u21A0',
+        rarrap: '\u2975',
+        rarrb: '\u21E5',
+        rarrbfs: '\u2920',
+        rarrc: '\u2933',
+        rarrfs: '\u291E',
+        rarrhk: '\u21AA',
+        rarrlp: '\u21AC',
+        rarrpl: '\u2945',
+        rarrsim: '\u2974',
+        rarrtl: '\u21A3',
+        Rarrtl: '\u2916',
+        rarrw: '\u219D',
+        ratail: '\u291A',
+        rAtail: '\u291C',
+        ratio: '\u2236',
+        rationals: '\u211A',
+        rbarr: '\u290D',
+        rBarr: '\u290F',
+        RBarr: '\u2910',
+        rbbrk: '\u2773',
+        rbrace: '}',
+        rbrack: ']',
+        rbrke: '\u298C',
+        rbrksld: '\u298E',
+        rbrkslu: '\u2990',
+        rcaron: '\u0159',
+        Rcaron: '\u0158',
+        rcedil: '\u0157',
+        Rcedil: '\u0156',
+        rceil: '\u2309',
+        rcub: '}',
+        rcy: '\u0440',
+        Rcy: '\u0420',
+        rdca: '\u2937',
+        rdldhar: '\u2969',
+        rdquo: '\u201D',
+        rdquor: '\u201D',
+        rdsh: '\u21B3',
+        Re: '\u211C',
+        real: '\u211C',
+        realine: '\u211B',
+        realpart: '\u211C',
+        reals: '\u211D',
+        rect: '\u25AD',
+        reg: '\xAE',
+        REG: '\xAE',
+        ReverseElement: '\u220B',
+        ReverseEquilibrium: '\u21CB',
+        ReverseUpEquilibrium: '\u296F',
+        rfisht: '\u297D',
+        rfloor: '\u230B',
+        rfr: '\uD835\uDD2F',
+        Rfr: '\u211C',
+        rHar: '\u2964',
+        rhard: '\u21C1',
+        rharu: '\u21C0',
+        rharul: '\u296C',
+        rho: '\u03C1',
+        Rho: '\u03A1',
+        rhov: '\u03F1',
+        RightAngleBracket: '\u27E9',
+        rightarrow: '\u2192',
+        Rightarrow: '\u21D2',
+        RightArrow: '\u2192',
+        RightArrowBar: '\u21E5',
+        RightArrowLeftArrow: '\u21C4',
+        rightarrowtail: '\u21A3',
+        RightCeiling: '\u2309',
+        RightDoubleBracket: '\u27E7',
+        RightDownTeeVector: '\u295D',
+        RightDownVector: '\u21C2',
+        RightDownVectorBar: '\u2955',
+        RightFloor: '\u230B',
+        rightharpoondown: '\u21C1',
+        rightharpoonup: '\u21C0',
+        rightleftarrows: '\u21C4',
+        rightleftharpoons: '\u21CC',
+        rightrightarrows: '\u21C9',
+        rightsquigarrow: '\u219D',
+        RightTee: '\u22A2',
+        RightTeeArrow: '\u21A6',
+        RightTeeVector: '\u295B',
+        rightthreetimes: '\u22CC',
+        RightTriangle: '\u22B3',
+        RightTriangleBar: '\u29D0',
+        RightTriangleEqual: '\u22B5',
+        RightUpDownVector: '\u294F',
+        RightUpTeeVector: '\u295C',
+        RightUpVector: '\u21BE',
+        RightUpVectorBar: '\u2954',
+        RightVector: '\u21C0',
+        RightVectorBar: '\u2953',
+        ring: '\u02DA',
+        risingdotseq: '\u2253',
+        rlarr: '\u21C4',
+        rlhar: '\u21CC',
+        rlm: '\u200F',
+        rmoust: '\u23B1',
+        rmoustache: '\u23B1',
+        rnmid: '\u2AEE',
+        roang: '\u27ED',
+        roarr: '\u21FE',
+        robrk: '\u27E7',
+        ropar: '\u2986',
+        ropf: '\uD835\uDD63',
+        Ropf: '\u211D',
+        roplus: '\u2A2E',
+        rotimes: '\u2A35',
+        RoundImplies: '\u2970',
+        rpar: ')',
+        rpargt: '\u2994',
+        rppolint: '\u2A12',
+        rrarr: '\u21C9',
+        Rrightarrow: '\u21DB',
+        rsaquo: '\u203A',
+        rscr: '\uD835\uDCC7',
+        Rscr: '\u211B',
+        rsh: '\u21B1',
+        Rsh: '\u21B1',
+        rsqb: ']',
+        rsquo: '\u2019',
+        rsquor: '\u2019',
+        rthree: '\u22CC',
+        rtimes: '\u22CA',
+        rtri: '\u25B9',
+        rtrie: '\u22B5',
+        rtrif: '\u25B8',
+        rtriltri: '\u29CE',
+        RuleDelayed: '\u29F4',
+        ruluhar: '\u2968',
+        rx: '\u211E',
+        sacute: '\u015B',
+        Sacute: '\u015A',
+        sbquo: '\u201A',
+        sc: '\u227B',
+        Sc: '\u2ABC',
+        scap: '\u2AB8',
+        scaron: '\u0161',
+        Scaron: '\u0160',
+        sccue: '\u227D',
+        sce: '\u2AB0',
+        scE: '\u2AB4',
+        scedil: '\u015F',
+        Scedil: '\u015E',
+        scirc: '\u015D',
+        Scirc: '\u015C',
+        scnap: '\u2ABA',
+        scnE: '\u2AB6',
+        scnsim: '\u22E9',
+        scpolint: '\u2A13',
+        scsim: '\u227F',
+        scy: '\u0441',
+        Scy: '\u0421',
+        sdot: '\u22C5',
+        sdotb: '\u22A1',
+        sdote: '\u2A66',
+        searhk: '\u2925',
+        searr: '\u2198',
+        seArr: '\u21D8',
+        searrow: '\u2198',
+        sect: '\xA7',
+        semi: ';',
+        seswar: '\u2929',
+        setminus: '\u2216',
+        setmn: '\u2216',
+        sext: '\u2736',
+        sfr: '\uD835\uDD30',
+        Sfr: '\uD835\uDD16',
+        sfrown: '\u2322',
+        sharp: '\u266F',
+        shchcy: '\u0449',
+        SHCHcy: '\u0429',
+        shcy: '\u0448',
+        SHcy: '\u0428',
+        ShortDownArrow: '\u2193',
+        ShortLeftArrow: '\u2190',
+        shortmid: '\u2223',
+        shortparallel: '\u2225',
+        ShortRightArrow: '\u2192',
+        ShortUpArrow: '\u2191',
+        shy: '\xAD',
+        sigma: '\u03C3',
+        Sigma: '\u03A3',
+        sigmaf: '\u03C2',
+        sigmav: '\u03C2',
+        sim: '\u223C',
+        simdot: '\u2A6A',
+        sime: '\u2243',
+        simeq: '\u2243',
+        simg: '\u2A9E',
+        simgE: '\u2AA0',
+        siml: '\u2A9D',
+        simlE: '\u2A9F',
+        simne: '\u2246',
+        simplus: '\u2A24',
+        simrarr: '\u2972',
+        slarr: '\u2190',
+        SmallCircle: '\u2218',
+        smallsetminus: '\u2216',
+        smashp: '\u2A33',
+        smeparsl: '\u29E4',
+        smid: '\u2223',
+        smile: '\u2323',
+        smt: '\u2AAA',
+        smte: '\u2AAC',
+        smtes: '\u2AAC\uFE00',
+        softcy: '\u044C',
+        SOFTcy: '\u042C',
+        sol: '/',
+        solb: '\u29C4',
+        solbar: '\u233F',
+        sopf: '\uD835\uDD64',
+        Sopf: '\uD835\uDD4A',
+        spades: '\u2660',
+        spadesuit: '\u2660',
+        spar: '\u2225',
+        sqcap: '\u2293',
+        sqcaps: '\u2293\uFE00',
+        sqcup: '\u2294',
+        sqcups: '\u2294\uFE00',
+        Sqrt: '\u221A',
+        sqsub: '\u228F',
+        sqsube: '\u2291',
+        sqsubset: '\u228F',
+        sqsubseteq: '\u2291',
+        sqsup: '\u2290',
+        sqsupe: '\u2292',
+        sqsupset: '\u2290',
+        sqsupseteq: '\u2292',
+        squ: '\u25A1',
+        square: '\u25A1',
+        Square: '\u25A1',
+        SquareIntersection: '\u2293',
+        SquareSubset: '\u228F',
+        SquareSubsetEqual: '\u2291',
+        SquareSuperset: '\u2290',
+        SquareSupersetEqual: '\u2292',
+        SquareUnion: '\u2294',
+        squarf: '\u25AA',
+        squf: '\u25AA',
+        srarr: '\u2192',
+        sscr: '\uD835\uDCC8',
+        Sscr: '\uD835\uDCAE',
+        ssetmn: '\u2216',
+        ssmile: '\u2323',
+        sstarf: '\u22C6',
+        star: '\u2606',
+        Star: '\u22C6',
+        starf: '\u2605',
+        straightepsilon: '\u03F5',
+        straightphi: '\u03D5',
+        strns: '\xAF',
+        sub: '\u2282',
+        Sub: '\u22D0',
+        subdot: '\u2ABD',
+        sube: '\u2286',
+        subE: '\u2AC5',
+        subedot: '\u2AC3',
+        submult: '\u2AC1',
+        subne: '\u228A',
+        subnE: '\u2ACB',
+        subplus: '\u2ABF',
+        subrarr: '\u2979',
+        subset: '\u2282',
+        Subset: '\u22D0',
+        subseteq: '\u2286',
+        subseteqq: '\u2AC5',
+        SubsetEqual: '\u2286',
+        subsetneq: '\u228A',
+        subsetneqq: '\u2ACB',
+        subsim: '\u2AC7',
+        subsub: '\u2AD5',
+        subsup: '\u2AD3',
+        succ: '\u227B',
+        succapprox: '\u2AB8',
+        succcurlyeq: '\u227D',
+        Succeeds: '\u227B',
+        SucceedsEqual: '\u2AB0',
+        SucceedsSlantEqual: '\u227D',
+        SucceedsTilde: '\u227F',
+        succeq: '\u2AB0',
+        succnapprox: '\u2ABA',
+        succneqq: '\u2AB6',
+        succnsim: '\u22E9',
+        succsim: '\u227F',
+        SuchThat: '\u220B',
+        sum: '\u2211',
+        Sum: '\u2211',
+        sung: '\u266A',
+        sup: '\u2283',
+        Sup: '\u22D1',
+        sup1: '\xB9',
+        sup2: '\xB2',
+        sup3: '\xB3',
+        supdot: '\u2ABE',
+        supdsub: '\u2AD8',
+        supe: '\u2287',
+        supE: '\u2AC6',
+        supedot: '\u2AC4',
+        Superset: '\u2283',
+        SupersetEqual: '\u2287',
+        suphsol: '\u27C9',
+        suphsub: '\u2AD7',
+        suplarr: '\u297B',
+        supmult: '\u2AC2',
+        supne: '\u228B',
+        supnE: '\u2ACC',
+        supplus: '\u2AC0',
+        supset: '\u2283',
+        Supset: '\u22D1',
+        supseteq: '\u2287',
+        supseteqq: '\u2AC6',
+        supsetneq: '\u228B',
+        supsetneqq: '\u2ACC',
+        supsim: '\u2AC8',
+        supsub: '\u2AD4',
+        supsup: '\u2AD6',
+        swarhk: '\u2926',
+        swarr: '\u2199',
+        swArr: '\u21D9',
+        swarrow: '\u2199',
+        swnwar: '\u292A',
+        szlig: '\xDF',
+        Tab: '\t',
+        target: '\u2316',
+        tau: '\u03C4',
+        Tau: '\u03A4',
+        tbrk: '\u23B4',
+        tcaron: '\u0165',
+        Tcaron: '\u0164',
+        tcedil: '\u0163',
+        Tcedil: '\u0162',
+        tcy: '\u0442',
+        Tcy: '\u0422',
+        tdot: '\u20DB',
+        telrec: '\u2315',
+        tfr: '\uD835\uDD31',
+        Tfr: '\uD835\uDD17',
+        there4: '\u2234',
+        therefore: '\u2234',
+        Therefore: '\u2234',
+        theta: '\u03B8',
+        Theta: '\u0398',
+        thetasym: '\u03D1',
+        thetav: '\u03D1',
+        thickapprox: '\u2248',
+        thicksim: '\u223C',
+        ThickSpace: '\u205F\u200A',
+        thinsp: '\u2009',
+        ThinSpace: '\u2009',
+        thkap: '\u2248',
+        thksim: '\u223C',
+        thorn: '\xFE',
+        THORN: '\xDE',
+        tilde: '\u02DC',
+        Tilde: '\u223C',
+        TildeEqual: '\u2243',
+        TildeFullEqual: '\u2245',
+        TildeTilde: '\u2248',
+        times: '\xD7',
+        timesb: '\u22A0',
+        timesbar: '\u2A31',
+        timesd: '\u2A30',
+        tint: '\u222D',
+        toea: '\u2928',
+        top: '\u22A4',
+        topbot: '\u2336',
+        topcir: '\u2AF1',
+        topf: '\uD835\uDD65',
+        Topf: '\uD835\uDD4B',
+        topfork: '\u2ADA',
+        tosa: '\u2929',
+        tprime: '\u2034',
+        trade: '\u2122',
+        TRADE: '\u2122',
+        triangle: '\u25B5',
+        triangledown: '\u25BF',
+        triangleleft: '\u25C3',
+        trianglelefteq: '\u22B4',
+        triangleq: '\u225C',
+        triangleright: '\u25B9',
+        trianglerighteq: '\u22B5',
+        tridot: '\u25EC',
+        trie: '\u225C',
+        triminus: '\u2A3A',
+        TripleDot: '\u20DB',
+        triplus: '\u2A39',
+        trisb: '\u29CD',
+        tritime: '\u2A3B',
+        trpezium: '\u23E2',
+        tscr: '\uD835\uDCC9',
+        Tscr: '\uD835\uDCAF',
+        tscy: '\u0446',
+        TScy: '\u0426',
+        tshcy: '\u045B',
+        TSHcy: '\u040B',
+        tstrok: '\u0167',
+        Tstrok: '\u0166',
+        twixt: '\u226C',
+        twoheadleftarrow: '\u219E',
+        twoheadrightarrow: '\u21A0',
+        uacute: '\xFA',
+        Uacute: '\xDA',
+        uarr: '\u2191',
+        uArr: '\u21D1',
+        Uarr: '\u219F',
+        Uarrocir: '\u2949',
+        ubrcy: '\u045E',
+        Ubrcy: '\u040E',
+        ubreve: '\u016D',
+        Ubreve: '\u016C',
+        ucirc: '\xFB',
+        Ucirc: '\xDB',
+        ucy: '\u0443',
+        Ucy: '\u0423',
+        udarr: '\u21C5',
+        udblac: '\u0171',
+        Udblac: '\u0170',
+        udhar: '\u296E',
+        ufisht: '\u297E',
+        ufr: '\uD835\uDD32',
+        Ufr: '\uD835\uDD18',
+        ugrave: '\xF9',
+        Ugrave: '\xD9',
+        uHar: '\u2963',
+        uharl: '\u21BF',
+        uharr: '\u21BE',
+        uhblk: '\u2580',
+        ulcorn: '\u231C',
+        ulcorner: '\u231C',
+        ulcrop: '\u230F',
+        ultri: '\u25F8',
+        umacr: '\u016B',
+        Umacr: '\u016A',
+        uml: '\xA8',
+        UnderBar: '_',
+        UnderBrace: '\u23DF',
+        UnderBracket: '\u23B5',
+        UnderParenthesis: '\u23DD',
+        Union: '\u22C3',
+        UnionPlus: '\u228E',
+        uogon: '\u0173',
+        Uogon: '\u0172',
+        uopf: '\uD835\uDD66',
+        Uopf: '\uD835\uDD4C',
+        uparrow: '\u2191',
+        Uparrow: '\u21D1',
+        UpArrow: '\u2191',
+        UpArrowBar: '\u2912',
+        UpArrowDownArrow: '\u21C5',
+        updownarrow: '\u2195',
+        Updownarrow: '\u21D5',
+        UpDownArrow: '\u2195',
+        UpEquilibrium: '\u296E',
+        upharpoonleft: '\u21BF',
+        upharpoonright: '\u21BE',
+        uplus: '\u228E',
+        UpperLeftArrow: '\u2196',
+        UpperRightArrow: '\u2197',
+        upsi: '\u03C5',
+        Upsi: '\u03D2',
+        upsih: '\u03D2',
+        upsilon: '\u03C5',
+        Upsilon: '\u03A5',
+        UpTee: '\u22A5',
+        UpTeeArrow: '\u21A5',
+        upuparrows: '\u21C8',
+        urcorn: '\u231D',
+        urcorner: '\u231D',
+        urcrop: '\u230E',
+        uring: '\u016F',
+        Uring: '\u016E',
+        urtri: '\u25F9',
+        uscr: '\uD835\uDCCA',
+        Uscr: '\uD835\uDCB0',
+        utdot: '\u22F0',
+        utilde: '\u0169',
+        Utilde: '\u0168',
+        utri: '\u25B5',
+        utrif: '\u25B4',
+        uuarr: '\u21C8',
+        uuml: '\xFC',
+        Uuml: '\xDC',
+        uwangle: '\u29A7',
+        vangrt: '\u299C',
+        varepsilon: '\u03F5',
+        varkappa: '\u03F0',
+        varnothing: '\u2205',
+        varphi: '\u03D5',
+        varpi: '\u03D6',
+        varpropto: '\u221D',
+        varr: '\u2195',
+        vArr: '\u21D5',
+        varrho: '\u03F1',
+        varsigma: '\u03C2',
+        varsubsetneq: '\u228A\uFE00',
+        varsubsetneqq: '\u2ACB\uFE00',
+        varsupsetneq: '\u228B\uFE00',
+        varsupsetneqq: '\u2ACC\uFE00',
+        vartheta: '\u03D1',
+        vartriangleleft: '\u22B2',
+        vartriangleright: '\u22B3',
+        vBar: '\u2AE8',
+        Vbar: '\u2AEB',
+        vBarv: '\u2AE9',
+        vcy: '\u0432',
+        Vcy: '\u0412',
+        vdash: '\u22A2',
+        vDash: '\u22A8',
+        Vdash: '\u22A9',
+        VDash: '\u22AB',
+        Vdashl: '\u2AE6',
+        vee: '\u2228',
+        Vee: '\u22C1',
+        veebar: '\u22BB',
+        veeeq: '\u225A',
+        vellip: '\u22EE',
+        verbar: '|',
+        Verbar: '\u2016',
+        vert: '|',
+        Vert: '\u2016',
+        VerticalBar: '\u2223',
+        VerticalLine: '|',
+        VerticalSeparator: '\u2758',
+        VerticalTilde: '\u2240',
+        VeryThinSpace: '\u200A',
+        vfr: '\uD835\uDD33',
+        Vfr: '\uD835\uDD19',
+        vltri: '\u22B2',
+        vnsub: '\u2282\u20D2',
+        vnsup: '\u2283\u20D2',
+        vopf: '\uD835\uDD67',
+        Vopf: '\uD835\uDD4D',
+        vprop: '\u221D',
+        vrtri: '\u22B3',
+        vscr: '\uD835\uDCCB',
+        Vscr: '\uD835\uDCB1',
+        vsubne: '\u228A\uFE00',
+        vsubnE: '\u2ACB\uFE00',
+        vsupne: '\u228B\uFE00',
+        vsupnE: '\u2ACC\uFE00',
+        Vvdash: '\u22AA',
+        vzigzag: '\u299A',
+        wcirc: '\u0175',
+        Wcirc: '\u0174',
+        wedbar: '\u2A5F',
+        wedge: '\u2227',
+        Wedge: '\u22C0',
+        wedgeq: '\u2259',
+        weierp: '\u2118',
+        wfr: '\uD835\uDD34',
+        Wfr: '\uD835\uDD1A',
+        wopf: '\uD835\uDD68',
+        Wopf: '\uD835\uDD4E',
+        wp: '\u2118',
+        wr: '\u2240',
+        wreath: '\u2240',
+        wscr: '\uD835\uDCCC',
+        Wscr: '\uD835\uDCB2',
+        xcap: '\u22C2',
+        xcirc: '\u25EF',
+        xcup: '\u22C3',
+        xdtri: '\u25BD',
+        xfr: '\uD835\uDD35',
+        Xfr: '\uD835\uDD1B',
+        xharr: '\u27F7',
+        xhArr: '\u27FA',
+        xi: '\u03BE',
+        Xi: '\u039E',
+        xlarr: '\u27F5',
+        xlArr: '\u27F8',
+        xmap: '\u27FC',
+        xnis: '\u22FB',
+        xodot: '\u2A00',
+        xopf: '\uD835\uDD69',
+        Xopf: '\uD835\uDD4F',
+        xoplus: '\u2A01',
+        xotime: '\u2A02',
+        xrarr: '\u27F6',
+        xrArr: '\u27F9',
+        xscr: '\uD835\uDCCD',
+        Xscr: '\uD835\uDCB3',
+        xsqcup: '\u2A06',
+        xuplus: '\u2A04',
+        xutri: '\u25B3',
+        xvee: '\u22C1',
+        xwedge: '\u22C0',
+        yacute: '\xFD',
+        Yacute: '\xDD',
+        yacy: '\u044F',
+        YAcy: '\u042F',
+        ycirc: '\u0177',
+        Ycirc: '\u0176',
+        ycy: '\u044B',
+        Ycy: '\u042B',
+        yen: '\xA5',
+        yfr: '\uD835\uDD36',
+        Yfr: '\uD835\uDD1C',
+        yicy: '\u0457',
+        YIcy: '\u0407',
+        yopf: '\uD835\uDD6A',
+        Yopf: '\uD835\uDD50',
+        yscr: '\uD835\uDCCE',
+        Yscr: '\uD835\uDCB4',
+        yucy: '\u044E',
+        YUcy: '\u042E',
+        yuml: '\xFF',
+        Yuml: '\u0178',
+        zacute: '\u017A',
+        Zacute: '\u0179',
+        zcaron: '\u017E',
+        Zcaron: '\u017D',
+        zcy: '\u0437',
+        Zcy: '\u0417',
+        zdot: '\u017C',
+        Zdot: '\u017B',
+        zeetrf: '\u2128',
+        ZeroWidthSpace: '\u200B',
+        zeta: '\u03B6',
+        Zeta: '\u0396',
+        zfr: '\uD835\uDD37',
+        Zfr: '\u2128',
+        zhcy: '\u0436',
+        ZHcy: '\u0416',
+        zigrarr: '\u21DD',
+        zopf: '\uD835\uDD6B',
+        Zopf: '\u2124',
+        zscr: '\uD835\uDCCF',
+        Zscr: '\uD835\uDCB5',
+        zwj: '\u200D',
+        zwnj: '\u200C'
+      }
+      var decodeMapLegacy = {
+        aacute: '\xE1',
+        Aacute: '\xC1',
+        acirc: '\xE2',
+        Acirc: '\xC2',
+        acute: '\xB4',
+        aelig: '\xE6',
+        AElig: '\xC6',
+        agrave: '\xE0',
+        Agrave: '\xC0',
+        amp: '&',
+        AMP: '&',
+        aring: '\xE5',
+        Aring: '\xC5',
+        atilde: '\xE3',
+        Atilde: '\xC3',
+        auml: '\xE4',
+        Auml: '\xC4',
+        brvbar: '\xA6',
+        ccedil: '\xE7',
+        Ccedil: '\xC7',
+        cedil: '\xB8',
+        cent: '\xA2',
+        copy: '\xA9',
+        COPY: '\xA9',
+        curren: '\xA4',
+        deg: '\xB0',
+        divide: '\xF7',
+        eacute: '\xE9',
+        Eacute: '\xC9',
+        ecirc: '\xEA',
+        Ecirc: '\xCA',
+        egrave: '\xE8',
+        Egrave: '\xC8',
+        eth: '\xF0',
+        ETH: '\xD0',
+        euml: '\xEB',
+        Euml: '\xCB',
+        frac12: '\xBD',
+        frac14: '\xBC',
+        frac34: '\xBE',
+        gt: '>',
+        GT: '>',
+        iacute: '\xED',
+        Iacute: '\xCD',
+        icirc: '\xEE',
+        Icirc: '\xCE',
+        iexcl: '\xA1',
+        igrave: '\xEC',
+        Igrave: '\xCC',
+        iquest: '\xBF',
+        iuml: '\xEF',
+        Iuml: '\xCF',
+        laquo: '\xAB',
+        lt: '<',
+        LT: '<',
+        macr: '\xAF',
+        micro: '\xB5',
+        middot: '\xB7',
+        nbsp: '\xA0',
+        not: '\xAC',
+        ntilde: '\xF1',
+        Ntilde: '\xD1',
+        oacute: '\xF3',
+        Oacute: '\xD3',
+        ocirc: '\xF4',
+        Ocirc: '\xD4',
+        ograve: '\xF2',
+        Ograve: '\xD2',
+        ordf: '\xAA',
+        ordm: '\xBA',
+        oslash: '\xF8',
+        Oslash: '\xD8',
+        otilde: '\xF5',
+        Otilde: '\xD5',
+        ouml: '\xF6',
+        Ouml: '\xD6',
+        para: '\xB6',
+        plusmn: '\xB1',
+        pound: '\xA3',
+        quot: '"',
+        QUOT: '"',
+        raquo: '\xBB',
+        reg: '\xAE',
+        REG: '\xAE',
+        sect: '\xA7',
+        shy: '\xAD',
+        sup1: '\xB9',
+        sup2: '\xB2',
+        sup3: '\xB3',
+        szlig: '\xDF',
+        thorn: '\xFE',
+        THORN: '\xDE',
+        times: '\xD7',
+        uacute: '\xFA',
+        Uacute: '\xDA',
+        ucirc: '\xFB',
+        Ucirc: '\xDB',
+        ugrave: '\xF9',
+        Ugrave: '\xD9',
+        uml: '\xA8',
+        uuml: '\xFC',
+        Uuml: '\xDC',
+        yacute: '\xFD',
+        Yacute: '\xDD',
+        yen: '\xA5',
+        yuml: '\xFF'
+      }
+      var decodeMapNumeric = {
+        0: '\uFFFD',
+        128: '\u20AC',
+        130: '\u201A',
+        131: '\u0192',
+        132: '\u201E',
+        133: '\u2026',
+        134: '\u2020',
+        135: '\u2021',
+        136: '\u02C6',
+        137: '\u2030',
+        138: '\u0160',
+        139: '\u2039',
+        140: '\u0152',
+        142: '\u017D',
+        145: '\u2018',
+        146: '\u2019',
+        147: '\u201C',
+        148: '\u201D',
+        149: '\u2022',
+        150: '\u2013',
+        151: '\u2014',
+        152: '\u02DC',
+        153: '\u2122',
+        154: '\u0161',
+        155: '\u203A',
+        156: '\u0153',
+        158: '\u017E',
+        159: '\u0178'
+      }
+      var invalidReferenceCodePoints = [
+        1, 2, 3, 4, 5, 6, 7, 8, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+        24, 25, 26, 27, 28, 29, 30, 31, 127, 128, 129, 130, 131, 132, 133, 134,
+        135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
+        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 64976, 64977,
+        64978, 64979, 64980, 64981, 64982, 64983, 64984, 64985, 64986, 64987,
+        64988, 64989, 64990, 64991, 64992, 64993, 64994, 64995, 64996, 64997,
+        64998, 64999, 65000, 65001, 65002, 65003, 65004, 65005, 65006, 65007,
+        65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678,
+        327679, 393214, 393215, 458750, 458751, 524286, 524287, 589822, 589823,
+        655358, 655359, 720894, 720895, 786430, 786431, 851966, 851967, 917502,
+        917503, 983038, 983039, 1048574, 1048575, 1114110, 1114111
+      ]
+
+      /*--------------------------------------------------------------------------*/
+
+      var stringFromCharCode = String.fromCharCode
+
+      var object = {}
+      var hasOwnProperty = object.hasOwnProperty
+      var has = function (object, propertyName) {
+        return hasOwnProperty.call(object, propertyName)
+      }
+
+      var contains = function (array, value) {
+        var index = -1
+        var length = array.length
+        while (++index < length) {
+          if (array[index] == value) {
+            return true
+          }
+        }
+        return false
+      }
+
+      var merge = function (options, defaults) {
+        if (!options) {
+          return defaults
+        }
+        var result = {}
+        var key
+        for (key in defaults) {
+          // A `hasOwnProperty` check is not needed here, since only recognized
+          // option names are used anyway. Any others are ignored.
+          result[key] = has(options, key) ? options[key] : defaults[key]
+        }
+        return result
+      }
+
+      // Modified version of `ucs2encode`; see https://mths.be/punycode.
+      var codePointToSymbol = function (codePoint, strict) {
+        var output = ''
+        if (
+          (codePoint >= 0xd800 && codePoint <= 0xdfff) ||
+          codePoint > 0x10ffff
+        ) {
+          // See issue #4:
+          // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
+          // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
+          // REPLACEMENT CHARACTER.”
+          if (strict) {
+            parseError(
+              'character reference outside the permissible Unicode range'
+            )
+          }
+          return '\uFFFD'
+        }
+        if (has(decodeMapNumeric, codePoint)) {
+          if (strict) {
+            parseError('disallowed character reference')
+          }
+          return decodeMapNumeric[codePoint]
+        }
+        if (strict && contains(invalidReferenceCodePoints, codePoint)) {
+          parseError('disallowed character reference')
+        }
+        if (codePoint > 0xffff) {
+          codePoint -= 0x10000
+          output += stringFromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800)
+          codePoint = 0xdc00 | (codePoint & 0x3ff)
+        }
+        output += stringFromCharCode(codePoint)
+        return output
+      }
+
+      var hexEscape = function (codePoint) {
+        return '&#x' + codePoint.toString(16).toUpperCase() + ';'
+      }
+
+      var decEscape = function (codePoint) {
+        return '&#' + codePoint + ';'
+      }
+
+      var parseError = function (message) {
+        throw Error('Parse error: ' + message)
+      }
+
+      /*--------------------------------------------------------------------------*/
+
+      var encode = function (string, options) {
+        options = merge(options, encode.options)
+        var strict = options.strict
+        if (strict && regexInvalidRawCodePoint.test(string)) {
+          parseError('forbidden code point')
+        }
+        var encodeEverything = options.encodeEverything
+        var useNamedReferences = options.useNamedReferences
+        var allowUnsafeSymbols = options.allowUnsafeSymbols
+        var escapeCodePoint = options.decimal ? decEscape : hexEscape
+
+        var escapeBmpSymbol = function (symbol) {
+          return escapeCodePoint(symbol.charCodeAt(0))
+        }
+
+        if (encodeEverything) {
+          // Encode ASCII symbols.
+          string = string.replace(regexAsciiWhitelist, function (symbol) {
+            // Use named references if requested & possible.
+            if (useNamedReferences && has(encodeMap, symbol)) {
+              return '&' + encodeMap[symbol] + ';'
+            }
+            return escapeBmpSymbol(symbol)
+          })
+          // Shorten a few escapes that represent two symbols, of which at least one
+          // is within the ASCII range.
+          if (useNamedReferences) {
+            string = string
+              .replace(/&gt;\u20D2/g, '&nvgt;')
+              .replace(/&lt;\u20D2/g, '&nvlt;')
+              .replace(/&#x66;&#x6A;/g, '&fjlig;')
+          }
+          // Encode non-ASCII symbols.
+          if (useNamedReferences) {
+            // Encode non-ASCII symbols that can be replaced with a named reference.
+            string = string.replace(regexEncodeNonAscii, function (string) {
+              // Note: there is no need to check `has(encodeMap, string)` here.
+              return '&' + encodeMap[string] + ';'
+            })
+          }
+          // Note: any remaining non-ASCII symbols are handled outside of the `if`.
+        } else if (useNamedReferences) {
+          // Apply named character references.
+          // Encode `<>"'&` using named character references.
+          if (!allowUnsafeSymbols) {
+            string = string.replace(regexEscape, function (string) {
+              return '&' + encodeMap[string] + ';' // no need to check `has()` here
+            })
+          }
+          // Shorten escapes that represent two symbols, of which at least one is
+          // `<>"'&`.
+          string = string
+            .replace(/&gt;\u20D2/g, '&nvgt;')
+            .replace(/&lt;\u20D2/g, '&nvlt;')
+          // Encode non-ASCII symbols that can be replaced with a named reference.
+          string = string.replace(regexEncodeNonAscii, function (string) {
+            // Note: there is no need to check `has(encodeMap, string)` here.
+            return '&' + encodeMap[string] + ';'
+          })
+        } else if (!allowUnsafeSymbols) {
+          // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
+          // using named character references.
+          string = string.replace(regexEscape, escapeBmpSymbol)
+        }
+        return (
+          string
+            // Encode astral symbols.
+            .replace(regexAstralSymbols, function ($0) {
+              // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+              var high = $0.charCodeAt(0)
+              var low = $0.charCodeAt(1)
+              var codePoint = (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000
+              return escapeCodePoint(codePoint)
+            })
+            // Encode any remaining BMP symbols that are not printable ASCII symbols
+            // using a hexadecimal escape.
+            .replace(regexBmpWhitelist, escapeBmpSymbol)
+        )
+      }
+      // Expose default options (so they can be overridden globally).
+      encode.options = {
+        allowUnsafeSymbols: false,
+        encodeEverything: false,
+        strict: false,
+        useNamedReferences: false,
+        decimal: false
+      }
+
+      var decode = function (html, options) {
+        options = merge(options, decode.options)
+        var strict = options.strict
+        if (strict && regexInvalidEntity.test(html)) {
+          parseError('malformed character reference')
+        }
+        return html.replace(
+          regexDecode,
+          function ($0, $1, $2, $3, $4, $5, $6, $7, $8) {
+            var codePoint
+            var semicolon
+            var decDigits
+            var hexDigits
+            var reference
+            var next
+
+            if ($1) {
+              reference = $1
+              // Note: there is no need to check `has(decodeMap, reference)`.
+              return decodeMap[reference]
+            }
+
+            if ($2) {
+              // Decode named character references without trailing `;`, e.g. `&amp`.
+              // This is only a parse error if it gets converted to `&`, or if it is
+              // followed by `=` in an attribute context.
+              reference = $2
+              next = $3
+              if (next && options.isAttributeValue) {
+                if (strict && next == '=') {
+                  parseError('`&` did not start a character reference')
+                }
+                return $0
+              } else {
+                if (strict) {
+                  parseError(
+                    'named character reference was not terminated by a semicolon'
+                  )
+                }
+                // Note: there is no need to check `has(decodeMapLegacy, reference)`.
+                return decodeMapLegacy[reference] + (next || '')
+              }
+            }
+
+            if ($4) {
+              // Decode decimal escapes, e.g. `&#119558;`.
+              decDigits = $4
+              semicolon = $5
+              if (strict && !semicolon) {
+                parseError(
+                  'character reference was not terminated by a semicolon'
+                )
+              }
+              codePoint = parseInt(decDigits, 10)
+              return codePointToSymbol(codePoint, strict)
+            }
+
+            if ($6) {
+              // Decode hexadecimal escapes, e.g. `&#x1D306;`.
+              hexDigits = $6
+              semicolon = $7
+              if (strict && !semicolon) {
+                parseError(
+                  'character reference was not terminated by a semicolon'
+                )
+              }
+              codePoint = parseInt(hexDigits, 16)
+              return codePointToSymbol(codePoint, strict)
+            }
+
+            // If we’re still here, `if ($7)` is implied; it’s an ambiguous
+            // ampersand for sure. https://mths.be/notes/ambiguous-ampersands
+            if (strict) {
+              parseError(
+                'named character reference was not terminated by a semicolon'
+              )
+            }
+            return $0
+          }
+        )
+      }
+      // Expose default options (so they can be overridden globally).
+      decode.options = {
+        isAttributeValue: false,
+        strict: false
+      }
+
+      var escape = function (string) {
+        return string.replace(regexEscape, function ($0) {
+          // Note: there is no need to check `has(escapeMap, $0)` here.
+          return escapeMap[$0]
+        })
+      }
+
+      /*--------------------------------------------------------------------------*/
+
+      var he = {
+        version: '1.2.0',
+        encode: encode,
+        decode: decode,
+        escape: escape,
+        unescape: decode
+      }
+
+      // Some AMD build optimizers, like r.js, check for specific condition patterns
+      // like the following:
+      if (freeExports && !freeExports.nodeType) {
+        if (freeModule) {
+          // in Node.js, io.js, or RingoJS v0.8.0+
+          freeModule.exports = he
+        } else {
+          // in Narwhal or RingoJS v0.7.0-
+          for (var key in he) {
+            has(he, key) && (freeExports[key] = he[key])
+          }
+        }
+      } else {
+        // in Rhino or a web browser
+        root.he = he
+      }
+    })(commonjsGlobal)
+  })(he$1, he$1.exports)
+
+  var he = he$1.exports
+
+  /**
+   * Cross-platform code generation for component v-model
+   */
+  function genComponentModel(el, value, modifiers) {
+    var _a = modifiers || {},
+      number = _a.number,
+      trim = _a.trim
+    var baseValueExpression = '$$v'
+    var valueExpression = baseValueExpression
+    if (trim) {
+      valueExpression =
+        '(typeof '.concat(baseValueExpression, " === 'string'") +
+        '? '.concat(baseValueExpression, '.trim()') +
+        ': '.concat(baseValueExpression, ')')
+    }
+    if (number) {
+      valueExpression = '_n('.concat(valueExpression, ')')
+    }
+    var assignment = genAssignmentCode(value, valueExpression)
+    el.model = {
+      value: '('.concat(value, ')'),
+      expression: JSON.stringify(value),
+      callback: 'function ('
+        .concat(baseValueExpression, ') {')
+        .concat(assignment, '}')
+    }
+  }
+  /**
+   * Cross-platform codegen helper for generating v-model value assignment code.
+   */
+  function genAssignmentCode(value, assignment) {
+    var res = parseModel(value)
+    if (res.key === null) {
+      return ''.concat(value, '=').concat(assignment)
+    } else {
+      return '$set('
+        .concat(res.exp, ', ')
+        .concat(res.key, ', ')
+        .concat(assignment, ')')
+    }
+  }
+  /**
+   * Parse a v-model expression into a base path and a final key segment.
+   * Handles both dot-path and possible square brackets.
+   *
+   * Possible cases:
+   *
+   * - test
+   * - test[key]
+   * - test[test1[key]]
+   * - test["a"][key]
+   * - xxx.test[a[a].test1[key]]
+   * - test.xxx.a["asa"][test1[key]]
+   *
+   */
+  var len, str, chr, index, expressionPos, expressionEndPos
+  function parseModel(val) {
+    // Fix https://github.com/vuejs/vue/pull/7730
+    // allow v-model="obj.val " (trailing whitespace)
+    val = val.trim()
+    len = val.length
+    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+      index = val.lastIndexOf('.')
+      if (index > -1) {
+        return {
+          exp: val.slice(0, index),
+          key: '"' + val.slice(index + 1) + '"'
+        }
+      } else {
+        return {
+          exp: val,
+          key: null
+        }
+      }
+    }
+    str = val
+    index = expressionPos = expressionEndPos = 0
+    while (!eof()) {
+      chr = next()
+      /* istanbul ignore if */
+      if (isStringStart(chr)) {
+        parseString(chr)
+      } else if (chr === 0x5b) {
+        parseBracket(chr)
+      }
+    }
+    return {
+      exp: val.slice(0, expressionPos),
+      key: val.slice(expressionPos + 1, expressionEndPos)
+    }
+  }
+  function next() {
+    return str.charCodeAt(++index)
+  }
+  function eof() {
+    return index >= len
+  }
+  function isStringStart(chr) {
+    return chr === 0x22 || chr === 0x27
+  }
+  function parseBracket(chr) {
+    var inBracket = 1
+    expressionPos = index
+    while (!eof()) {
+      chr = next()
+      if (isStringStart(chr)) {
+        parseString(chr)
+        continue
+      }
+      if (chr === 0x5b) inBracket++
+      if (chr === 0x5d) inBracket--
+      if (inBracket === 0) {
+        expressionEndPos = index
+        break
+      }
+    }
+  }
+  function parseString(chr) {
+    var stringQuote = chr
+    while (!eof()) {
+      chr = next()
+      if (chr === stringQuote) {
+        break
+      }
+    }
+  }
+
+  var onRE = /^@|^v-on:/
+  var dirRE = /^v-|^@|^:|^#/
+  var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
+  var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/
+  var stripParensRE = /^\(|\)$/g
+  var dynamicArgRE = /^\[.*\]$/
+  var argRE = /:(.*)$/
+  var bindRE = /^:|^\.|^v-bind:/
+  var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
+  var slotRE = /^v-slot(:|$)|^#/
+  var lineBreakRE = /[\r\n]/
+  var whitespaceRE = /[ \f\t\r\n]+/g
+  var invalidAttributeRE = /[\s"'<>\/=]/
+  var decodeHTMLCached = cached(he.decode)
+  var emptySlotScopeToken = '_empty_'
+  // configurable state
+  var warn$1
+  var delimiters
+  var transforms
+  var preTransforms
+  var postTransforms
+  var platformIsPreTag
+  var platformMustUseProp
+  var platformGetTagNamespace
+  var maybeComponent
+  function createASTElement(tag, attrs, parent) {
+    return {
+      type: 1,
+      tag: tag,
+      attrsList: attrs,
+      attrsMap: makeAttrsMap(attrs),
+      rawAttrsMap: {},
+      parent: parent,
+      children: []
+    }
+  }
+  /**
+   * Convert HTML string to AST.
+   */
+  function parse(template, options) {
+    warn$1 = options.warn || baseWarn
+    platformIsPreTag = options.isPreTag || no
+    platformMustUseProp = options.mustUseProp || no
+    platformGetTagNamespace = options.getTagNamespace || no
+    var isReservedTag = options.isReservedTag || no
+    maybeComponent = function (el) {
+      return !!(
+        el.component ||
+        el.attrsMap[':is'] ||
+        el.attrsMap['v-bind:is'] ||
+        !(el.attrsMap.is
+          ? isReservedTag(el.attrsMap.is)
+          : isReservedTag(el.tag))
+      )
+    }
+    transforms = pluckModuleFunction(options.modules, 'transformNode')
+    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
+    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
+    delimiters = options.delimiters
+    var stack = []
+    var preserveWhitespace = options.preserveWhitespace !== false
+    var whitespaceOption = options.whitespace
+    var root
+    var currentParent
+    var inVPre = false
+    var inPre = false
+    var warned = false
+    function warnOnce(msg, range) {
+      if (!warned) {
+        warned = true
+        warn$1(msg, range)
+      }
+    }
+    function closeElement(element) {
+      trimEndingWhitespace(element)
+      if (!inVPre && !element.processed) {
+        element = processElement(element, options)
+      }
+      // tree management
+      if (!stack.length && element !== root) {
+        // allow root elements with v-if, v-else-if and v-else
+        if (root.if && (element.elseif || element.else)) {
+          {
+            checkRootConstraints(element)
+          }
+          addIfCondition(root, {
+            exp: element.elseif,
+            block: element
+          })
+        } else {
+          warnOnce(
+            'Component template should contain exactly one root element. ' +
+              'If you are using v-if on multiple elements, ' +
+              'use v-else-if to chain them instead.',
+            { start: element.start }
+          )
+        }
+      }
+      if (currentParent && !element.forbidden) {
+        if (element.elseif || element.else) {
+          processIfConditions(element, currentParent)
+        } else {
+          if (element.slotScope) {
+            // scoped slot
+            // keep it in the children list so that v-else(-if) conditions can
+            // find it as the prev node.
+            var name_1 = element.slotTarget || '"default"'
+            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[
+              name_1
+            ] = element
+          }
+          currentParent.children.push(element)
+          element.parent = currentParent
+        }
+      }
+      // final children cleanup
+      // filter out scoped slots
+      element.children = element.children.filter(function (c) {
+        return !c.slotScope
+      })
+      // remove trailing whitespace node again
+      trimEndingWhitespace(element)
+      // check pre state
+      if (element.pre) {
+        inVPre = false
+      }
+      if (platformIsPreTag(element.tag)) {
+        inPre = false
+      }
+      // apply post-transforms
+      for (var i = 0; i < postTransforms.length; i++) {
+        postTransforms[i](element, options)
+      }
+    }
+    function trimEndingWhitespace(el) {
+      // remove trailing whitespace node
+      if (!inPre) {
+        var lastNode = void 0
+        while (
+          (lastNode = el.children[el.children.length - 1]) &&
+          lastNode.type === 3 &&
+          lastNode.text === ' '
+        ) {
+          el.children.pop()
+        }
+      }
+    }
+    function checkRootConstraints(el) {
+      if (el.tag === 'slot' || el.tag === 'template') {
+        warnOnce(
+          'Cannot use <'.concat(
+            el.tag,
+            '> as component root element because it may '
+          ) + 'contain multiple nodes.',
+          { start: el.start }
+        )
+      }
+      if (el.attrsMap.hasOwnProperty('v-for')) {
+        warnOnce(
+          'Cannot use v-for on stateful component root element because ' +
+            'it renders multiple elements.',
+          el.rawAttrsMap['v-for']
+        )
+      }
+    }
+    parseHTML(template, {
+      warn: warn$1,
+      expectHTML: options.expectHTML,
+      isUnaryTag: options.isUnaryTag,
+      canBeLeftOpenTag: options.canBeLeftOpenTag,
+      shouldDecodeNewlines: options.shouldDecodeNewlines,
+      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+      shouldKeepComment: options.comments,
+      outputSourceRange: options.outputSourceRange,
+      start: function (tag, attrs, unary, start, end) {
+        // check namespace.
+        // inherit parent ns if there is one
+        var ns =
+          (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
+        // handle IE svg bug
+        /* istanbul ignore if */
+        if (isIE && ns === 'svg') {
+          attrs = guardIESVGBug(attrs)
+        }
+        var element = createASTElement(tag, attrs, currentParent)
+        if (ns) {
+          element.ns = ns
+        }
+        {
+          if (options.outputSourceRange) {
+            element.start = start
+            element.end = end
+            element.rawAttrsMap = element.attrsList.reduce(function (
+              cumulated,
+              attr
+            ) {
+              cumulated[attr.name] = attr
+              return cumulated
+            },
+            {})
+          }
+          attrs.forEach(function (attr) {
+            if (invalidAttributeRE.test(attr.name)) {
+              warn$1(
+                'Invalid dynamic argument expression: attribute names cannot contain ' +
+                  'spaces, quotes, <, >, / or =.',
+                {
+                  start: attr.start + attr.name.indexOf('['),
+                  end: attr.start + attr.name.length
+                }
+              )
+            }
+          })
+        }
+        if (isForbiddenTag(element) && !isServerRendering()) {
+          element.forbidden = true
+          warn$1(
+            'Templates should only be responsible for mapping the state to the ' +
+              'UI. Avoid placing tags with side-effects in your templates, such as ' +
+              '<'.concat(tag, '>') +
+              ', as they will not be parsed.',
+            { start: element.start }
+          )
+        }
+        // apply pre-transforms
+        for (var i = 0; i < preTransforms.length; i++) {
+          element = preTransforms[i](element, options) || element
+        }
+        if (!inVPre) {
+          processPre(element)
+          if (element.pre) {
+            inVPre = true
+          }
+        }
+        if (platformIsPreTag(element.tag)) {
+          inPre = true
+        }
+        if (inVPre) {
+          processRawAttrs(element)
+        } else if (!element.processed) {
+          // structural directives
+          processFor(element)
+          processIf(element)
+          processOnce(element)
+        }
+        if (!root) {
+          root = element
+          {
+            checkRootConstraints(root)
+          }
+        }
+        if (!unary) {
+          currentParent = element
+          stack.push(element)
+        } else {
+          closeElement(element)
+        }
+      },
+      end: function (tag, start, end) {
+        var element = stack[stack.length - 1]
+        // pop stack
+        stack.length -= 1
+        currentParent = stack[stack.length - 1]
+        if (options.outputSourceRange) {
+          element.end = end
+        }
+        closeElement(element)
+      },
+      chars: function (text, start, end) {
+        if (!currentParent) {
+          {
+            if (text === template) {
+              warnOnce(
+                'Component template requires a root element, rather than just text.',
+                { start: start }
+              )
+            } else if ((text = text.trim())) {
+              warnOnce(
+                'text "'.concat(
+                  text,
+                  '" outside root element will be ignored.'
+                ),
+                {
+                  start: start
+                }
+              )
+            }
+          }
+          return
+        }
+        // IE textarea placeholder bug
+        /* istanbul ignore if */
+        if (
+          isIE &&
+          currentParent.tag === 'textarea' &&
+          currentParent.attrsMap.placeholder === text
+        ) {
+          return
+        }
+        var children = currentParent.children
+        if (inPre || text.trim()) {
+          text = isTextTag(currentParent) ? text : decodeHTMLCached(text)
+        } else if (!children.length) {
+          // remove the whitespace-only node right after an opening tag
+          text = ''
+        } else if (whitespaceOption) {
+          if (whitespaceOption === 'condense') {
+            // in condense mode, remove the whitespace node if it contains
+            // line break, otherwise condense to a single space
+            text = lineBreakRE.test(text) ? '' : ' '
+          } else {
+            text = ' '
+          }
+        } else {
+          text = preserveWhitespace ? ' ' : ''
+        }
+        if (text) {
+          if (!inPre && whitespaceOption === 'condense') {
+            // condense consecutive whitespaces into single space
+            text = text.replace(whitespaceRE, ' ')
+          }
+          var res = void 0
+          var child = void 0
+          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+            child = {
+              type: 2,
+              expression: res.expression,
+              tokens: res.tokens,
+              text: text
+            }
+          } else if (
+            text !== ' ' ||
+            !children.length ||
+            children[children.length - 1].text !== ' '
+          ) {
+            child = {
+              type: 3,
+              text: text
+            }
+          }
+          if (child) {
+            if (options.outputSourceRange) {
+              child.start = start
+              child.end = end
+            }
+            children.push(child)
+          }
+        }
+      },
+      comment: function (text, start, end) {
+        // adding anything as a sibling to the root node is forbidden
+        // comments should still be allowed, but ignored
+        if (currentParent) {
+          var child = {
+            type: 3,
+            text: text,
+            isComment: true
+          }
+          if (options.outputSourceRange) {
+            child.start = start
+            child.end = end
+          }
+          currentParent.children.push(child)
+        }
+      }
+    })
+    return root
+  }
+  function processPre(el) {
+    if (getAndRemoveAttr(el, 'v-pre') != null) {
+      el.pre = true
+    }
+  }
+  function processRawAttrs(el) {
+    var list = el.attrsList
+    var len = list.length
+    if (len) {
+      var attrs = (el.attrs = new Array(len))
+      for (var i = 0; i < len; i++) {
+        attrs[i] = {
+          name: list[i].name,
+          value: JSON.stringify(list[i].value)
+        }
+        if (list[i].start != null) {
+          attrs[i].start = list[i].start
+          attrs[i].end = list[i].end
+        }
+      }
+    } else if (!el.pre) {
+      // non root node in pre blocks with no attributes
+      el.plain = true
+    }
+  }
+  function processElement(element, options) {
+    processKey(element)
+    // determine whether this is a plain element after
+    // removing structural attributes
+    element.plain =
+      !element.key && !element.scopedSlots && !element.attrsList.length
+    processRef(element)
+    processSlotContent(element)
+    processSlotOutlet(element)
+    processComponent(element)
+    for (var i = 0; i < transforms.length; i++) {
+      element = transforms[i](element, options) || element
+    }
+    processAttrs(element)
+    return element
+  }
+  function processKey(el) {
+    var exp = getBindingAttr(el, 'key')
+    if (exp) {
+      {
+        if (el.tag === 'template') {
+          warn$1(
+            '<template> cannot be keyed. Place the key on real elements instead.',
+            getRawBindingAttr(el, 'key')
+          )
+        }
+        if (el.for) {
+          var iterator = el.iterator2 || el.iterator1
+          var parent_1 = el.parent
+          if (
+            iterator &&
+            iterator === exp &&
+            parent_1 &&
+            parent_1.tag === 'transition-group'
+          ) {
+            warn$1(
+              'Do not use v-for index as key on <transition-group> children, ' +
+                'this is the same as not using keys.',
+              getRawBindingAttr(el, 'key'),
+              true /* tip */
+            )
+          }
+        }
+      }
+      el.key = exp
+    }
+  }
+  function processRef(el) {
+    var ref = getBindingAttr(el, 'ref')
+    if (ref) {
+      el.ref = ref
+      el.refInFor = checkInFor(el)
+    }
+  }
+  function processFor(el) {
+    var exp
+    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+      var res = parseFor(exp)
+      if (res) {
+        extend(el, res)
+      } else {
+        warn$1(
+          'Invalid v-for expression: '.concat(exp),
+          el.rawAttrsMap['v-for']
+        )
+      }
+    }
+  }
+  function parseFor(exp) {
+    var inMatch = exp.match(forAliasRE)
+    if (!inMatch) return
+    var res = {}
+    res.for = inMatch[2].trim()
+    var alias = inMatch[1].trim().replace(stripParensRE, '')
+    var iteratorMatch = alias.match(forIteratorRE)
+    if (iteratorMatch) {
+      res.alias = alias.replace(forIteratorRE, '').trim()
+      res.iterator1 = iteratorMatch[1].trim()
+      if (iteratorMatch[2]) {
+        res.iterator2 = iteratorMatch[2].trim()
+      }
+    } else {
+      res.alias = alias
+    }
+    return res
+  }
+  function processIf(el) {
+    var exp = getAndRemoveAttr(el, 'v-if')
+    if (exp) {
+      el.if = exp
+      addIfCondition(el, {
+        exp: exp,
+        block: el
+      })
+    } else {
+      if (getAndRemoveAttr(el, 'v-else') != null) {
+        el.else = true
+      }
+      var elseif = getAndRemoveAttr(el, 'v-else-if')
+      if (elseif) {
+        el.elseif = elseif
+      }
+    }
+  }
+  function processIfConditions(el, parent) {
+    var prev = findPrevElement(parent.children)
+    if (prev && prev.if) {
+      addIfCondition(prev, {
+        exp: el.elseif,
+        block: el
+      })
+    } else {
+      warn$1(
+        'v-'.concat(el.elseif ? 'else-if="' + el.elseif + '"' : 'else', ' ') +
+          'used on element <'.concat(el.tag, '> without corresponding v-if.'),
+        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
+      )
+    }
+  }
+  function findPrevElement(children) {
+    var i = children.length
+    while (i--) {
+      if (children[i].type === 1) {
+        return children[i]
+      } else {
+        if (children[i].text !== ' ') {
+          warn$1(
+            'text "'.concat(
+              children[i].text.trim(),
+              '" between v-if and v-else(-if) '
+            ) + 'will be ignored.',
+            children[i]
+          )
+        }
+        children.pop()
+      }
+    }
+  }
+  function addIfCondition(el, condition) {
+    if (!el.ifConditions) {
+      el.ifConditions = []
+    }
+    el.ifConditions.push(condition)
+  }
+  function processOnce(el) {
+    var once = getAndRemoveAttr(el, 'v-once')
+    if (once != null) {
+      el.once = true
+    }
+  }
+  // handle content being passed to a component as slot,
+  // e.g. <template slot="xxx">, <div slot-scope="xxx">
+  function processSlotContent(el) {
+    var slotScope
+    if (el.tag === 'template') {
+      slotScope = getAndRemoveAttr(el, 'scope')
+      /* istanbul ignore if */
+      if (slotScope) {
+        warn$1(
+          'the "scope" attribute for scoped slots have been deprecated and ' +
+            'replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ' +
+            'can also be used on plain elements in addition to <template> to ' +
+            'denote scoped slots.',
+          el.rawAttrsMap['scope'],
+          true
+        )
+      }
+      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
+    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+      /* istanbul ignore if */
+      if (el.attrsMap['v-for']) {
+        warn$1(
+          'Ambiguous combined usage of slot-scope and v-for on <'.concat(
+            el.tag,
+            '> '
+          ) +
+            '(v-for takes higher priority). Use a wrapper <template> for the ' +
+            'scoped slot to make it clearer.',
+          el.rawAttrsMap['slot-scope'],
+          true
+        )
+      }
+      el.slotScope = slotScope
+    }
+    // slot="xxx"
+    var slotTarget = getBindingAttr(el, 'slot')
+    if (slotTarget) {
+      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
+      el.slotTargetDynamic = !!(
+        el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']
+      )
+      // preserve slot as an attribute for native shadow DOM compat
+      // only for non-scoped slots.
+      if (el.tag !== 'template' && !el.slotScope) {
+        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'))
+      }
+    }
+    // 2.6 v-slot syntax
+    {
+      if (el.tag === 'template') {
+        // v-slot on <template>
+        var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
+        if (slotBinding) {
+          {
+            if (el.slotTarget || el.slotScope) {
+              warn$1('Unexpected mixed usage of different slot syntaxes.', el)
+            }
+            if (el.parent && !maybeComponent(el.parent)) {
+              warn$1(
+                '<template v-slot> can only appear at the root level inside ' +
+                  'the receiving component',
+                el
+              )
+            }
+          }
+          var _a = getSlotName(slotBinding),
+            name_2 = _a.name,
+            dynamic = _a.dynamic
+          el.slotTarget = name_2
+          el.slotTargetDynamic = dynamic
+          el.slotScope = slotBinding.value || emptySlotScopeToken // force it into a scoped slot for perf
+        }
+      } else {
+        // v-slot on component, denotes default slot
+        var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
+        if (slotBinding) {
+          {
+            if (!maybeComponent(el)) {
+              warn$1(
+                'v-slot can only be used on components or <template>.',
+                slotBinding
+              )
+            }
+            if (el.slotScope || el.slotTarget) {
+              warn$1('Unexpected mixed usage of different slot syntaxes.', el)
+            }
+            if (el.scopedSlots) {
+              warn$1(
+                'To avoid scope ambiguity, the default slot should also use ' +
+                  '<template> syntax when there are other named slots.',
+                slotBinding
+              )
+            }
+          }
+          // add the component's children to its default slot
+          var slots = el.scopedSlots || (el.scopedSlots = {})
+          var _b = getSlotName(slotBinding),
+            name_3 = _b.name,
+            dynamic = _b.dynamic
+          var slotContainer_1 = (slots[name_3] = createASTElement(
+            'template',
+            [],
+            el
+          ))
+          slotContainer_1.slotTarget = name_3
+          slotContainer_1.slotTargetDynamic = dynamic
+          slotContainer_1.children = el.children.filter(function (c) {
+            if (!c.slotScope) {
+              c.parent = slotContainer_1
+              return true
+            }
+          })
+          slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken
+          // remove children as they are returned from scopedSlots now
+          el.children = []
+          // mark el non-plain so data gets generated
+          el.plain = false
+        }
+      }
+    }
+  }
+  function getSlotName(binding) {
+    var name = binding.name.replace(slotRE, '')
+    if (!name) {
+      if (binding.name[0] !== '#') {
+        name = 'default'
+      } else {
+        warn$1('v-slot shorthand syntax requires a slot name.', binding)
+      }
+    }
+    return dynamicArgRE.test(name)
+      ? // dynamic [name]
+        { name: name.slice(1, -1), dynamic: true }
+      : // static name
+        { name: '"'.concat(name, '"'), dynamic: false }
+  }
+  // handle <slot/> outlets
+  function processSlotOutlet(el) {
+    if (el.tag === 'slot') {
+      el.slotName = getBindingAttr(el, 'name')
+      if (el.key) {
+        warn$1(
+          '`key` does not work on <slot> because slots are abstract outlets ' +
+            'and can possibly expand into multiple elements. ' +
+            'Use the key on a wrapping element instead.',
+          getRawBindingAttr(el, 'key')
+        )
+      }
+    }
+  }
+  function processComponent(el) {
+    var binding
+    if ((binding = getBindingAttr(el, 'is'))) {
+      el.component = binding
+    }
+    if (getAndRemoveAttr(el, 'inline-template') != null) {
+      el.inlineTemplate = true
+    }
+  }
+  function processAttrs(el) {
+    var list = el.attrsList
+    var i, l, name, rawName, value, modifiers, syncGen, isDynamic
+    for (i = 0, l = list.length; i < l; i++) {
+      name = rawName = list[i].name
+      value = list[i].value
+      if (dirRE.test(name)) {
+        // mark element as dynamic
+        el.hasBindings = true
+        // modifiers
+        modifiers = parseModifiers(name.replace(dirRE, ''))
+        // support .foo shorthand syntax for the .prop modifier
+        if (modifiers) {
+          name = name.replace(modifierRE, '')
+        }
+        if (bindRE.test(name)) {
+          // v-bind
+          name = name.replace(bindRE, '')
+          value = parseFilters(value)
+          isDynamic = dynamicArgRE.test(name)
+          if (isDynamic) {
+            name = name.slice(1, -1)
+          }
+          if (value.trim().length === 0) {
+            warn$1(
+              'The value for a v-bind expression cannot be empty. Found in "v-bind:'.concat(
+                name,
+                '"'
+              )
+            )
+          }
+          if (modifiers) {
+            if (modifiers.prop && !isDynamic) {
+              name = camelize(name)
+              if (name === 'innerHtml') name = 'innerHTML'
+            }
+            if (modifiers.camel && !isDynamic) {
+              name = camelize(name)
+            }
+            if (modifiers.sync) {
+              syncGen = genAssignmentCode(value, '$event')
+              if (!isDynamic) {
+                addHandler(
+                  el,
+                  'update:'.concat(camelize(name)),
+                  syncGen,
+                  null,
+                  false,
+                  warn$1,
+                  list[i]
+                )
+                if (hyphenate(name) !== camelize(name)) {
+                  addHandler(
+                    el,
+                    'update:'.concat(hyphenate(name)),
+                    syncGen,
+                    null,
+                    false,
+                    warn$1,
+                    list[i]
+                  )
+                }
+              } else {
+                // handler w/ dynamic event name
+                addHandler(
+                  el,
+                  '"update:"+('.concat(name, ')'),
+                  syncGen,
+                  null,
+                  false,
+                  warn$1,
+                  list[i],
+                  true // dynamic
+                )
+              }
+            }
+          }
+          if (
+            (modifiers && modifiers.prop) ||
+            (!el.component &&
+              platformMustUseProp(el.tag, el.attrsMap.type, name))
+          ) {
+            addProp(el, name, value, list[i], isDynamic)
+          } else {
+            addAttr(el, name, value, list[i], isDynamic)
+          }
+        } else if (onRE.test(name)) {
+          // v-on
+          name = name.replace(onRE, '')
+          isDynamic = dynamicArgRE.test(name)
+          if (isDynamic) {
+            name = name.slice(1, -1)
+          }
+          addHandler(
+            el,
+            name,
+            value,
+            modifiers,
+            false,
+            warn$1,
+            list[i],
+            isDynamic
+          )
+        } else {
+          // normal directives
+          name = name.replace(dirRE, '')
+          // parse arg
+          var argMatch = name.match(argRE)
+          var arg = argMatch && argMatch[1]
+          isDynamic = false
+          if (arg) {
+            name = name.slice(0, -(arg.length + 1))
+            if (dynamicArgRE.test(arg)) {
+              arg = arg.slice(1, -1)
+              isDynamic = true
+            }
+          }
+          addDirective(
+            el,
+            name,
+            rawName,
+            value,
+            arg,
+            isDynamic,
+            modifiers,
+            list[i]
+          )
+          if (name === 'model') {
+            checkForAliasModel(el, value)
+          }
+        }
+      } else {
+        // literal attribute
+        {
+          var res = parseText(value, delimiters)
+          if (res) {
+            warn$1(
+              ''.concat(name, '="').concat(value, '": ') +
+                'Interpolation inside attributes has been removed. ' +
+                'Use v-bind or the colon shorthand instead. For example, ' +
+                'instead of <div id="{{ val }}">, use <div :id="val">.',
+              list[i]
+            )
+          }
+        }
+        addAttr(el, name, JSON.stringify(value), list[i])
+        // #6887 firefox doesn't update muted state if set via attribute
+        // even immediately after element creation
+        if (
+          !el.component &&
+          name === 'muted' &&
+          platformMustUseProp(el.tag, el.attrsMap.type, name)
+        ) {
+          addProp(el, name, 'true', list[i])
+        }
+      }
+    }
+  }
+  function checkInFor(el) {
+    var parent = el
+    while (parent) {
+      if (parent.for !== undefined) {
+        return true
+      }
+      parent = parent.parent
+    }
+    return false
+  }
+  function parseModifiers(name) {
+    var match = name.match(modifierRE)
+    if (match) {
+      var ret_1 = {}
+      match.forEach(function (m) {
+        ret_1[m.slice(1)] = true
+      })
+      return ret_1
+    }
+  }
+  function makeAttrsMap(attrs) {
+    var map = {}
+    for (var i = 0, l = attrs.length; i < l; i++) {
+      if (map[attrs[i].name] && !isIE && !isEdge) {
+        warn$1('duplicate attribute: ' + attrs[i].name, attrs[i])
+      }
+      map[attrs[i].name] = attrs[i].value
+    }
+    return map
+  }
+  // for script (e.g. type="x/template") or style, do not decode content
+  function isTextTag(el) {
+    return el.tag === 'script' || el.tag === 'style'
+  }
+  function isForbiddenTag(el) {
+    return (
+      el.tag === 'style' ||
+      (el.tag === 'script' &&
+        (!el.attrsMap.type || el.attrsMap.type === 'text/javascript'))
+    )
+  }
+  var ieNSBug = /^xmlns:NS\d+/
+  var ieNSPrefix = /^NS\d+:/
+  /* istanbul ignore next */
+  function guardIESVGBug(attrs) {
+    var res = []
+    for (var i = 0; i < attrs.length; i++) {
+      var attr = attrs[i]
+      if (!ieNSBug.test(attr.name)) {
+        attr.name = attr.name.replace(ieNSPrefix, '')
+        res.push(attr)
+      }
+    }
+    return res
+  }
+  function checkForAliasModel(el, value) {
+    var _el = el
+    while (_el) {
+      if (_el.for && _el.alias === value) {
+        warn$1(
+          '<'.concat(el.tag, ' v-model="').concat(value, '">: ') +
+            'You are binding v-model directly to a v-for iteration alias. ' +
+            'This will not be able to modify the v-for source array because ' +
+            'writing to the alias is like modifying a function local variable. ' +
+            'Consider using an array of objects and use v-model on an object property instead.',
+          el.rawAttrsMap['v-model']
+        )
+      }
+      _el = _el.parent
+    }
+  }
+
+  /**
+   * Expand input[v-model] with dynamic type bindings into v-if-else chains
+   * Turn this:
+   *   <input v-model="data[type]" :type="type">
+   * into this:
+   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+   *   <input v-else :type="type" v-model="data[type]">
+   */
+  function preTransformNode(el, options) {
+    if (el.tag === 'input') {
+      var map = el.attrsMap
+      if (!map['v-model']) {
+        return
+      }
+      var typeBinding = void 0
+      if (map[':type'] || map['v-bind:type']) {
+        typeBinding = getBindingAttr(el, 'type')
+      }
+      if (!map.type && !typeBinding && map['v-bind']) {
+        typeBinding = '('.concat(map['v-bind'], ').type')
+      }
+      if (typeBinding) {
+        var ifCondition = getAndRemoveAttr(el, 'v-if', true)
+        var ifConditionExtra = ifCondition ? '&&('.concat(ifCondition, ')') : ''
+        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null
+        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
+        // 1. checkbox
+        var branch0 = cloneASTElement(el)
+        // process for on the main node
+        processFor(branch0)
+        addRawAttr(branch0, 'type', 'checkbox')
+        processElement(branch0, options)
+        branch0.processed = true // prevent it from double-processed
+        branch0.if =
+          '('.concat(typeBinding, ")==='checkbox'") + ifConditionExtra
+        addIfCondition(branch0, {
+          exp: branch0.if,
+          block: branch0
+        })
+        // 2. add radio else-if condition
+        var branch1 = cloneASTElement(el)
+        getAndRemoveAttr(branch1, 'v-for', true)
+        addRawAttr(branch1, 'type', 'radio')
+        processElement(branch1, options)
+        addIfCondition(branch0, {
+          exp: '('.concat(typeBinding, ")==='radio'") + ifConditionExtra,
+          block: branch1
+        })
+        // 3. other
+        var branch2 = cloneASTElement(el)
+        getAndRemoveAttr(branch2, 'v-for', true)
+        addRawAttr(branch2, ':type', typeBinding)
+        processElement(branch2, options)
+        addIfCondition(branch0, {
+          exp: ifCondition,
+          block: branch2
+        })
+        if (hasElse) {
+          branch0.else = true
+        } else if (elseIfCondition) {
+          branch0.elseif = elseIfCondition
+        }
+        return branch0
+      }
+    }
+  }
+  function cloneASTElement(el) {
+    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+  }
+  var model$1 = {
+    preTransformNode: preTransformNode
+  }
+
+  var modules = [klass, style, model$1]
+
+  var warn
+  // in some cases, the event used has to be determined at runtime
+  // so we used some reserved tokens during compile.
+  var RANGE_TOKEN = '__r'
+  function model(el, dir, _warn) {
+    warn = _warn
+    var value = dir.value
+    var modifiers = dir.modifiers
+    var tag = el.tag
+    var type = el.attrsMap.type
+    {
+      // inputs with type="file" are read only and setting the input's
+      // value will throw an error.
+      if (tag === 'input' && type === 'file') {
+        warn(
+          '<'.concat(el.tag, ' v-model="').concat(value, '" type="file">:\n') +
+            'File inputs are read only. Use a v-on:change listener instead.',
+          el.rawAttrsMap['v-model']
+        )
+      }
+    }
+    if (el.component) {
+      genComponentModel(el, value, modifiers)
+      // component v-model doesn't need extra runtime
+      return false
+    } else if (tag === 'select') {
+      genSelect(el, value, modifiers)
+    } else if (tag === 'input' && type === 'checkbox') {
+      genCheckboxModel(el, value, modifiers)
+    } else if (tag === 'input' && type === 'radio') {
+      genRadioModel(el, value, modifiers)
+    } else if (tag === 'input' || tag === 'textarea') {
+      genDefaultModel(el, value, modifiers)
+    } else {
+      genComponentModel(el, value, modifiers)
+      // component v-model doesn't need extra runtime
+      return false
+    }
+    // ensure runtime directive metadata
+    return true
+  }
+  function genCheckboxModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number
+    var valueBinding = getBindingAttr(el, 'value') || 'null'
+    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
+    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
+    addProp(
+      el,
+      'checked',
+      'Array.isArray('.concat(value, ')') +
+        '?_i('.concat(value, ',').concat(valueBinding, ')>-1') +
+        (trueValueBinding === 'true'
+          ? ':('.concat(value, ')')
+          : ':_q('.concat(value, ',').concat(trueValueBinding, ')'))
+    )
+    addHandler(
+      el,
+      'change',
+      'var $$a='.concat(value, ',') +
+        '$$el=$event.target,' +
+        '$$c=$$el.checked?('
+          .concat(trueValueBinding, '):(')
+          .concat(falseValueBinding, ');') +
+        'if(Array.isArray($$a)){' +
+        'var $$v='.concat(
+          number ? '_n(' + valueBinding + ')' : valueBinding,
+          ','
+        ) +
+        '$$i=_i($$a,$$v);' +
+        'if($$el.checked){$$i<0&&('.concat(
+          genAssignmentCode(value, '$$a.concat([$$v])'),
+          ')}'
+        ) +
+        'else{$$i>-1&&('.concat(
+          genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))'),
+          ')}'
+        ) +
+        '}else{'.concat(genAssignmentCode(value, '$$c'), '}'),
+      null,
+      true
+    )
+  }
+  function genRadioModel(el, value, modifiers) {
+    var number = modifiers && modifiers.number
+    var valueBinding = getBindingAttr(el, 'value') || 'null'
+    valueBinding = number ? '_n('.concat(valueBinding, ')') : valueBinding
+    addProp(el, 'checked', '_q('.concat(value, ',').concat(valueBinding, ')'))
+    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
+  }
+  function genSelect(el, value, modifiers) {
+    var number = modifiers && modifiers.number
+    var selectedVal =
+      'Array.prototype.filter' +
+      '.call($event.target.options,function(o){return o.selected})' +
+      '.map(function(o){var val = "_value" in o ? o._value : o.value;' +
+      'return '.concat(number ? '_n(val)' : 'val', '})')
+    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
+    var code = 'var $$selectedVal = '.concat(selectedVal, ';')
+    code = ''.concat(code, ' ').concat(genAssignmentCode(value, assignment))
+    addHandler(el, 'change', code, null, true)
+  }
+  function genDefaultModel(el, value, modifiers) {
+    var type = el.attrsMap.type
+    // warn if v-bind:value conflicts with v-model
+    // except for inputs with v-bind:type
+    {
+      var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
+      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
+      if (value_1 && !typeBinding) {
+        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
+        warn(
+          ''
+            .concat(binding, '="')
+            .concat(value_1, '" conflicts with v-model on the same element ') +
+            'because the latter already expands to a value binding internally',
+          el.rawAttrsMap[binding]
+        )
+      }
+    }
+    var _a = modifiers || {},
+      lazy = _a.lazy,
+      number = _a.number,
+      trim = _a.trim
+    var needCompositionGuard = !lazy && type !== 'range'
+    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'
+    var valueExpression = '$event.target.value'
+    if (trim) {
+      valueExpression = '$event.target.value.trim()'
+    }
+    if (number) {
+      valueExpression = '_n('.concat(valueExpression, ')')
+    }
+    var code = genAssignmentCode(value, valueExpression)
+    if (needCompositionGuard) {
+      code = 'if($event.target.composing)return;'.concat(code)
+    }
+    addProp(el, 'value', '('.concat(value, ')'))
+    addHandler(el, event, code, null, true)
+    if (trim || number) {
+      addHandler(el, 'blur', '$forceUpdate()')
+    }
+  }
+
+  function text(el, dir) {
+    if (dir.value) {
+      addProp(el, 'textContent', '_s('.concat(dir.value, ')'), dir)
+    }
+  }
+
+  function html(el, dir) {
+    if (dir.value) {
+      addProp(el, 'innerHTML', '_s('.concat(dir.value, ')'), dir)
+    }
+  }
+
+  var directives = {
+    model: model,
+    text: text,
+    html: html
+  }
+
+  var baseOptions = {
+    expectHTML: true,
+    modules: modules,
+    directives: directives,
+    isPreTag: isPreTag,
+    isUnaryTag: isUnaryTag,
+    mustUseProp: mustUseProp,
+    canBeLeftOpenTag: canBeLeftOpenTag,
+    isReservedTag: isReservedTag,
+    getTagNamespace: getTagNamespace,
+    staticKeys: genStaticKeys$1(modules)
+  }
+
+  var isStaticKey
+  var isPlatformReservedTag$1
+  var genStaticKeysCached = cached(genStaticKeys)
+  /**
+   * Goal of the optimizer: walk the generated template AST tree
+   * and detect sub-trees that are purely static, i.e. parts of
+   * the DOM that never needs to change.
+   *
+   * Once we detect these sub-trees, we can:
+   *
+   * 1. Hoist them into constants, so that we no longer need to
+   *    create fresh nodes for them on each re-render;
+   * 2. Completely skip them in the patching process.
+   */
+  function optimize$1(root, options) {
+    if (!root) return
+    isStaticKey = genStaticKeysCached(options.staticKeys || '')
+    isPlatformReservedTag$1 = options.isReservedTag || no
+    // first pass: mark all non-static nodes.
+    markStatic(root)
+    // second pass: mark static roots.
+    markStaticRoots(root, false)
+  }
+  function genStaticKeys(keys) {
+    return makeMap(
+      'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+        (keys ? ',' + keys : '')
+    )
+  }
+  function markStatic(node) {
+    node.static = isStatic(node)
+    if (node.type === 1) {
+      // do not make component slot content static. this avoids
+      // 1. components not able to mutate slot nodes
+      // 2. static slot content fails for hot-reloading
+      if (
+        !isPlatformReservedTag$1(node.tag) &&
+        node.tag !== 'slot' &&
+        node.attrsMap['inline-template'] == null
+      ) {
+        return
+      }
+      for (var i = 0, l = node.children.length; i < l; i++) {
+        var child = node.children[i]
+        markStatic(child)
+        if (!child.static) {
+          node.static = false
+        }
+      }
+      if (node.ifConditions) {
+        for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+          var block = node.ifConditions[i].block
+          markStatic(block)
+          if (!block.static) {
+            node.static = false
+          }
+        }
+      }
+    }
+  }
+  function markStaticRoots(node, isInFor) {
+    if (node.type === 1) {
+      if (node.static || node.once) {
+        node.staticInFor = isInFor
+      }
+      // For a node to qualify as a static root, it should have children that
+      // are not just static text. Otherwise the cost of hoisting out will
+      // outweigh the benefits and it's better off to just always render it fresh.
+      if (
+        node.static &&
+        node.children.length &&
+        !(node.children.length === 1 && node.children[0].type === 3)
+      ) {
+        node.staticRoot = true
+        return
+      } else {
+        node.staticRoot = false
+      }
+      if (node.children) {
+        for (var i = 0, l = node.children.length; i < l; i++) {
+          markStaticRoots(node.children[i], isInFor || !!node.for)
+        }
+      }
+      if (node.ifConditions) {
+        for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+          markStaticRoots(node.ifConditions[i].block, isInFor)
+        }
+      }
+    }
+  }
+  function isStatic(node) {
+    if (node.type === 2) {
+      // expression
+      return false
+    }
+    if (node.type === 3) {
+      // text
+      return true
+    }
+    return !!(
+      node.pre ||
+      (!node.hasBindings && // no dynamic bindings
+        !node.if &&
+        !node.for && // not v-if or v-for or v-else
+        !isBuiltInTag(node.tag) && // not a built-in
+        isPlatformReservedTag$1(node.tag) && // not a component
+        !isDirectChildOfTemplateFor(node) &&
+        Object.keys(node).every(isStaticKey))
+    )
+  }
+  function isDirectChildOfTemplateFor(node) {
+    while (node.parent) {
+      node = node.parent
+      if (node.tag !== 'template') {
+        return false
+      }
+      if (node.for) {
+        return true
+      }
+    }
+    return false
+  }
+
+  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
+  var fnInvokeRE = /\([^)]*?\);*$/
+  var simplePathRE =
+    /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
+  // KeyboardEvent.keyCode aliases
+  var keyCodes = {
+    esc: 27,
+    tab: 9,
+    enter: 13,
+    space: 32,
+    up: 38,
+    left: 37,
+    right: 39,
+    down: 40,
+    delete: [8, 46]
+  }
+  // KeyboardEvent.key aliases
+  var keyNames = {
+    // #7880: IE11 and Edge use `Esc` for Escape key name.
+    esc: ['Esc', 'Escape'],
+    tab: 'Tab',
+    enter: 'Enter',
+    // #9112: IE11 uses `Spacebar` for Space key name.
+    space: [' ', 'Spacebar'],
+    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+    up: ['Up', 'ArrowUp'],
+    left: ['Left', 'ArrowLeft'],
+    right: ['Right', 'ArrowRight'],
+    down: ['Down', 'ArrowDown'],
+    // #9112: IE11 uses `Del` for Delete key name.
+    delete: ['Backspace', 'Delete', 'Del']
+  }
+  // #4868: modifiers that prevent the execution of the listener
+  // need to explicitly return null so that we can determine whether to remove
+  // the listener for .once
+  var genGuard = function (condition) {
+    return 'if('.concat(condition, ')return null;')
+  }
+  var modifierCode = {
+    stop: '$event.stopPropagation();',
+    prevent: '$event.preventDefault();',
+    self: genGuard('$event.target !== $event.currentTarget'),
+    ctrl: genGuard('!$event.ctrlKey'),
+    shift: genGuard('!$event.shiftKey'),
+    alt: genGuard('!$event.altKey'),
+    meta: genGuard('!$event.metaKey'),
+    left: genGuard("'button' in $event && $event.button !== 0"),
+    middle: genGuard("'button' in $event && $event.button !== 1"),
+    right: genGuard("'button' in $event && $event.button !== 2")
+  }
+  function genHandlers(events, isNative) {
+    var prefix = isNative ? 'nativeOn:' : 'on:'
+    var staticHandlers = ''
+    var dynamicHandlers = ''
+    for (var name_1 in events) {
+      var handlerCode = genHandler(events[name_1])
+      //@ts-expect-error
+      if (events[name_1] && events[name_1].dynamic) {
+        dynamicHandlers += ''.concat(name_1, ',').concat(handlerCode, ',')
+      } else {
+        staticHandlers += '"'.concat(name_1, '":').concat(handlerCode, ',')
+      }
+    }
+    staticHandlers = '{'.concat(staticHandlers.slice(0, -1), '}')
+    if (dynamicHandlers) {
+      return (
+        prefix +
+        '_d('
+          .concat(staticHandlers, ',[')
+          .concat(dynamicHandlers.slice(0, -1), '])')
+      )
+    } else {
+      return prefix + staticHandlers
+    }
+  }
+  function genHandler(handler) {
+    if (!handler) {
+      return 'function(){}'
+    }
+    if (Array.isArray(handler)) {
+      return '['.concat(
+        handler
+          .map(function (handler) {
+            return genHandler(handler)
+          })
+          .join(','),
+        ']'
+      )
+    }
+    var isMethodPath = simplePathRE.test(handler.value)
+    var isFunctionExpression = fnExpRE.test(handler.value)
+    var isFunctionInvocation = simplePathRE.test(
+      handler.value.replace(fnInvokeRE, '')
+    )
+    if (!handler.modifiers) {
+      if (isMethodPath || isFunctionExpression) {
+        return handler.value
+      }
+      return 'function($event){'.concat(
+        isFunctionInvocation ? 'return '.concat(handler.value) : handler.value,
+        '}'
+      ) // inline statement
+    } else {
+      var code = ''
+      var genModifierCode = ''
+      var keys = []
+      var _loop_1 = function (key) {
+        if (modifierCode[key]) {
+          genModifierCode += modifierCode[key]
+          // left/right
+          if (keyCodes[key]) {
+            keys.push(key)
+          }
+        } else if (key === 'exact') {
+          var modifiers_1 = handler.modifiers
+          genModifierCode += genGuard(
+            ['ctrl', 'shift', 'alt', 'meta']
+              .filter(function (keyModifier) {
+                return !modifiers_1[keyModifier]
+              })
+              .map(function (keyModifier) {
+                return '$event.'.concat(keyModifier, 'Key')
+              })
+              .join('||')
+          )
+        } else {
+          keys.push(key)
+        }
+      }
+      for (var key in handler.modifiers) {
+        _loop_1(key)
+      }
+      if (keys.length) {
+        code += genKeyFilter(keys)
+      }
+      // Make sure modifiers like prevent and stop get executed after key filtering
+      if (genModifierCode) {
+        code += genModifierCode
+      }
+      var handlerCode = isMethodPath
+        ? 'return '.concat(handler.value, '.apply(null, arguments)')
+        : isFunctionExpression
+        ? 'return ('.concat(handler.value, ').apply(null, arguments)')
+        : isFunctionInvocation
+        ? 'return '.concat(handler.value)
+        : handler.value
+      return 'function($event){'.concat(code).concat(handlerCode, '}')
+    }
+  }
+  function genKeyFilter(keys) {
+    return (
+      // make sure the key filters only apply to KeyboardEvents
+      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+      // key events that do not have keyCode property...
+      "if(!$event.type.indexOf('key')&&" +
+      ''.concat(keys.map(genFilterCode).join('&&'), ')return null;')
+    )
+  }
+  function genFilterCode(key) {
+    var keyVal = parseInt(key, 10)
+    if (keyVal) {
+      return '$event.keyCode!=='.concat(keyVal)
+    }
+    var keyCode = keyCodes[key]
+    var keyName = keyNames[key]
+    return (
+      '_k($event.keyCode,' +
+      ''.concat(JSON.stringify(key), ',') +
+      ''.concat(JSON.stringify(keyCode), ',') +
+      '$event.key,' +
+      ''.concat(JSON.stringify(keyName)) +
+      ')'
+    )
+  }
+
+  function on(el, dir) {
+    if (dir.modifiers) {
+      warn$2('v-on without argument does not support modifiers.')
+    }
+    el.wrapListeners = function (code) {
+      return '_g('.concat(code, ',').concat(dir.value, ')')
+    }
+  }
+
+  function bind(el, dir) {
+    el.wrapData = function (code) {
+      return '_b('
+        .concat(code, ",'")
+        .concat(el.tag, "',")
+        .concat(dir.value, ',')
+        .concat(dir.modifiers && dir.modifiers.prop ? 'true' : 'false')
+        .concat(dir.modifiers && dir.modifiers.sync ? ',true' : '', ')')
+    }
+  }
+
+  var baseDirectives = {
+    on: on,
+    bind: bind,
+    cloak: noop
+  }
+
+  var CodegenState = /** @class */ (function () {
+    function CodegenState(options) {
+      this.options = options
+      this.warn = options.warn || baseWarn
+      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+      this.transforms = pluckModuleFunction(options.modules, 'transformCode')
+      this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
+      this.directives = extend(extend({}, baseDirectives), options.directives)
+      var isReservedTag = options.isReservedTag || no
+      this.maybeComponent = function (el) {
+        return !!el.component || !isReservedTag(el.tag)
+      }
+      this.onceId = 0
+      this.staticRenderFns = []
+      this.pre = false
+    }
+    return CodegenState
+  })()
+  function generate$1(ast, options) {
+    var state = new CodegenState(options)
+    // fix #11483, Root level <script> tags should not be rendered.
+    var code = ast
+      ? ast.tag === 'script'
+        ? 'null'
+        : genElement(ast, state)
+      : '_c("div")'
+    return {
+      render: 'with(this){return '.concat(code, '}'),
+      staticRenderFns: state.staticRenderFns
+    }
+  }
+  function genElement(el, state) {
+    if (el.parent) {
+      el.pre = el.pre || el.parent.pre
+    }
+    if (el.staticRoot && !el.staticProcessed) {
+      return genStatic(el, state)
+    } else if (el.once && !el.onceProcessed) {
+      return genOnce(el, state)
+    } else if (el.for && !el.forProcessed) {
+      return genFor(el, state)
+    } else if (el.if && !el.ifProcessed) {
+      return genIf(el, state)
+    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+      return genChildren(el, state) || 'void 0'
+    } else if (el.tag === 'slot') {
+      return genSlot(el, state)
+    } else {
+      // component or element
+      var code = void 0
+      if (el.component) {
+        code = genComponent(el.component, el, state)
+      } else {
+        var data = void 0
+        if (!el.plain || (el.pre && state.maybeComponent(el))) {
+          data = genData(el, state)
+        }
+        var children = el.inlineTemplate ? null : genChildren(el, state, true)
+        code = "_c('"
+          .concat(el.tag, "'")
+          .concat(
+            data ? ','.concat(data) : '' // data
+          )
+          .concat(
+            children ? ','.concat(children) : '', // children
+            ')'
+          )
+      }
+      // module transforms
+      for (var i = 0; i < state.transforms.length; i++) {
+        code = state.transforms[i](el, code)
+      }
+      return code
+    }
+  }
+  // hoist static sub-trees out
+  function genStatic(el, state) {
+    el.staticProcessed = true
+    // Some elements (templates) need to behave differently inside of a v-pre
+    // node.  All pre nodes are static roots, so we can use this as a location to
+    // wrap a state change and reset it upon exiting the pre node.
+    var originalPreState = state.pre
+    if (el.pre) {
+      state.pre = el.pre
+    }
+    state.staticRenderFns.push(
+      'with(this){return '.concat(genElement(el, state), '}')
+    )
+    state.pre = originalPreState
+    return '_m('
+      .concat(state.staticRenderFns.length - 1)
+      .concat(el.staticInFor ? ',true' : '', ')')
+  }
+  // v-once
+  function genOnce(el, state) {
+    el.onceProcessed = true
+    if (el.if && !el.ifProcessed) {
+      return genIf(el, state)
+    } else if (el.staticInFor) {
+      var key = ''
+      var parent_1 = el.parent
+      while (parent_1) {
+        if (parent_1.for) {
+          key = parent_1.key
+          break
+        }
+        parent_1 = parent_1.parent
+      }
+      if (!key) {
+        state.warn(
+          'v-once can only be used inside v-for that is keyed. ',
+          el.rawAttrsMap['v-once']
+        )
+        return genElement(el, state)
+      }
+      return '_o('
+        .concat(genElement(el, state), ',')
+        .concat(state.onceId++, ',')
+        .concat(key, ')')
+    } else {
+      return genStatic(el, state)
+    }
+  }
+  function genIf(el, state, altGen, altEmpty) {
+    el.ifProcessed = true // avoid recursion
+    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
+  }
+  function genIfConditions(conditions, state, altGen, altEmpty) {
+    if (!conditions.length) {
+      return altEmpty || '_e()'
+    }
+    var condition = conditions.shift()
+    if (condition.exp) {
+      return '('
+        .concat(condition.exp, ')?')
+        .concat(genTernaryExp(condition.block), ':')
+        .concat(genIfConditions(conditions, state, altGen, altEmpty))
+    } else {
+      return ''.concat(genTernaryExp(condition.block))
+    }
+    // v-if with v-once should generate code like (a)?_m(0):_m(1)
+    function genTernaryExp(el) {
+      return altGen
+        ? altGen(el, state)
+        : el.once
+        ? genOnce(el, state)
+        : genElement(el, state)
+    }
+  }
+  function genFor(el, state, altGen, altHelper) {
+    var exp = el.for
+    var alias = el.alias
+    var iterator1 = el.iterator1 ? ','.concat(el.iterator1) : ''
+    var iterator2 = el.iterator2 ? ','.concat(el.iterator2) : ''
+    if (
+      state.maybeComponent(el) &&
+      el.tag !== 'slot' &&
+      el.tag !== 'template' &&
+      !el.key
+    ) {
+      state.warn(
+        '<'
+          .concat(el.tag, ' v-for="')
+          .concat(alias, ' in ')
+          .concat(exp, '">: component lists rendered with ') +
+          'v-for should have explicit keys. ' +
+          'See https://vuejs.org/guide/list.html#key for more info.',
+        el.rawAttrsMap['v-for'],
+        true /* tip */
+      )
+    }
+    el.forProcessed = true // avoid recursion
+    return (
+      ''.concat(altHelper || '_l', '((').concat(exp, '),') +
+      'function('.concat(alias).concat(iterator1).concat(iterator2, '){') +
+      'return '.concat((altGen || genElement)(el, state)) +
+      '})'
+    )
+  }
+  function genData(el, state) {
+    var data = '{'
+    // directives first.
+    // directives may mutate the el's other properties before they are generated.
+    var dirs = genDirectives(el, state)
+    if (dirs) data += dirs + ','
+    // key
+    if (el.key) {
+      data += 'key:'.concat(el.key, ',')
+    }
+    // ref
+    if (el.ref) {
+      data += 'ref:'.concat(el.ref, ',')
+    }
+    if (el.refInFor) {
+      data += 'refInFor:true,'
+    }
+    // pre
+    if (el.pre) {
+      data += 'pre:true,'
+    }
+    // record original tag name for components using "is" attribute
+    if (el.component) {
+      data += 'tag:"'.concat(el.tag, '",')
+    }
+    // module data generation functions
+    for (var i = 0; i < state.dataGenFns.length; i++) {
+      data += state.dataGenFns[i](el)
+    }
+    // attributes
+    if (el.attrs) {
+      data += 'attrs:'.concat(genProps(el.attrs), ',')
+    }
+    // DOM props
+    if (el.props) {
+      data += 'domProps:'.concat(genProps(el.props), ',')
+    }
+    // event handlers
+    if (el.events) {
+      data += ''.concat(genHandlers(el.events, false), ',')
+    }
+    if (el.nativeEvents) {
+      data += ''.concat(genHandlers(el.nativeEvents, true), ',')
+    }
+    // slot target
+    // only for non-scoped slots
+    if (el.slotTarget && !el.slotScope) {
+      data += 'slot:'.concat(el.slotTarget, ',')
+    }
+    // scoped slots
+    if (el.scopedSlots) {
+      data += ''.concat(genScopedSlots(el, el.scopedSlots, state), ',')
+    }
+    // component v-model
+    if (el.model) {
+      data += 'model:{value:'
+        .concat(el.model.value, ',callback:')
+        .concat(el.model.callback, ',expression:')
+        .concat(el.model.expression, '},')
+    }
+    // inline-template
+    if (el.inlineTemplate) {
+      var inlineTemplate = genInlineTemplate(el, state)
+      if (inlineTemplate) {
+        data += ''.concat(inlineTemplate, ',')
+      }
+    }
+    data = data.replace(/,$/, '') + '}'
+    // v-bind dynamic argument wrap
+    // v-bind with dynamic arguments must be applied using the same v-bind object
+    // merge helper so that class/style/mustUseProp attrs are handled correctly.
+    if (el.dynamicAttrs) {
+      data = '_b('
+        .concat(data, ',"')
+        .concat(el.tag, '",')
+        .concat(genProps(el.dynamicAttrs), ')')
+    }
+    // v-bind data wrap
+    if (el.wrapData) {
+      data = el.wrapData(data)
+    }
+    // v-on data wrap
+    if (el.wrapListeners) {
+      data = el.wrapListeners(data)
+    }
+    return data
+  }
+  function genDirectives(el, state) {
+    var dirs = el.directives
+    if (!dirs) return
+    var res = 'directives:['
+    var hasRuntime = false
+    var i, l, dir, needRuntime
+    for (i = 0, l = dirs.length; i < l; i++) {
+      dir = dirs[i]
+      needRuntime = true
+      var gen = state.directives[dir.name]
+      if (gen) {
+        // compile-time directive that manipulates AST.
+        // returns true if it also needs a runtime counterpart.
+        needRuntime = !!gen(el, dir, state.warn)
+      }
+      if (needRuntime) {
+        hasRuntime = true
+        res += '{name:"'
+          .concat(dir.name, '",rawName:"')
+          .concat(dir.rawName, '"')
+          .concat(
+            dir.value
+              ? ',value:('
+                  .concat(dir.value, '),expression:')
+                  .concat(JSON.stringify(dir.value))
+              : ''
+          )
+          .concat(
+            dir.arg
+              ? ',arg:'.concat(
+                  dir.isDynamicArg ? dir.arg : '"'.concat(dir.arg, '"')
+                )
+              : ''
+          )
+          .concat(
+            dir.modifiers
+              ? ',modifiers:'.concat(JSON.stringify(dir.modifiers))
+              : '',
+            '},'
+          )
+      }
+    }
+    if (hasRuntime) {
+      return res.slice(0, -1) + ']'
+    }
+  }
+  function genInlineTemplate(el, state) {
+    var ast = el.children[0]
+    if (el.children.length !== 1 || ast.type !== 1) {
+      state.warn(
+        'Inline-template components must have exactly one child element.',
+        { start: el.start }
+      )
+    }
+    if (ast && ast.type === 1) {
+      var inlineRenderFns = generate$1(ast, state.options)
+      return 'inlineTemplate:{render:function(){'
+        .concat(inlineRenderFns.render, '},staticRenderFns:[')
+        .concat(
+          inlineRenderFns.staticRenderFns
+            .map(function (code) {
+              return 'function(){'.concat(code, '}')
+            })
+            .join(','),
+          ']}'
+        )
+    }
+  }
+  function genScopedSlots(el, slots, state) {
+    // by default scoped slots are considered "stable", this allows child
+    // components with only scoped slots to skip forced updates from parent.
+    // but in some cases we have to bail-out of this optimization
+    // for example if the slot contains dynamic names, has v-if or v-for on them...
+    var needsForceUpdate =
+      el.for ||
+      Object.keys(slots).some(function (key) {
+        var slot = slots[key]
+        return (
+          slot.slotTargetDynamic ||
+          slot.if ||
+          slot.for ||
+          containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+        )
+      })
+    // #9534: if a component with scoped slots is inside a conditional branch,
+    // it's possible for the same component to be reused but with different
+    // compiled slot content. To avoid that, we generate a unique key based on
+    // the generated code of all the slot contents.
+    var needsKey = !!el.if
+    // OR when it is inside another scoped slot or v-for (the reactivity may be
+    // disconnected due to the intermediate scope variable)
+    // #9438, #9506
+    // TODO: this can be further optimized by properly analyzing in-scope bindings
+    // and skip force updating ones that do not actually use scope variables.
+    if (!needsForceUpdate) {
+      var parent_2 = el.parent
+      while (parent_2) {
+        if (
+          (parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+          parent_2.for
+        ) {
+          needsForceUpdate = true
+          break
+        }
+        if (parent_2.if) {
+          needsKey = true
+        }
+        parent_2 = parent_2.parent
+      }
+    }
+    var generatedSlots = Object.keys(slots)
+      .map(function (key) {
+        return genScopedSlot(slots[key], state)
+      })
+      .join(',')
+    return 'scopedSlots:_u(['
+      .concat(generatedSlots, ']')
+      .concat(needsForceUpdate ? ',null,true' : '')
+      .concat(
+        !needsForceUpdate && needsKey
+          ? ',null,false,'.concat(hash(generatedSlots))
+          : '',
+        ')'
+      )
+  }
+  function hash(str) {
+    var hash = 5381
+    var i = str.length
+    while (i) {
+      hash = (hash * 33) ^ str.charCodeAt(--i)
+    }
+    return hash >>> 0
+  }
+  function containsSlotChild(el) {
+    if (el.type === 1) {
+      if (el.tag === 'slot') {
+        return true
+      }
+      return el.children.some(containsSlotChild)
+    }
+    return false
+  }
+  function genScopedSlot(el, state) {
+    var isLegacySyntax = el.attrsMap['slot-scope']
+    if (el.if && !el.ifProcessed && !isLegacySyntax) {
+      return genIf(el, state, genScopedSlot, 'null')
+    }
+    if (el.for && !el.forProcessed) {
+      return genFor(el, state, genScopedSlot)
+    }
+    var slotScope =
+      el.slotScope === emptySlotScopeToken ? '' : String(el.slotScope)
+    var fn =
+      'function('.concat(slotScope, '){') +
+      'return '.concat(
+        el.tag === 'template'
+          ? el.if && isLegacySyntax
+            ? '('
+                .concat(el.if, ')?')
+                .concat(genChildren(el, state) || 'undefined', ':undefined')
+            : genChildren(el, state) || 'undefined'
+          : genElement(el, state),
+        '}'
+      )
+    // reverse proxy v-slot without scope on this.$slots
+    var reverseProxy = slotScope ? '' : ',proxy:true'
+    return '{key:'
+      .concat(el.slotTarget || '"default"', ',fn:')
+      .concat(fn)
+      .concat(reverseProxy, '}')
+  }
+  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+    var children = el.children
+    if (children.length) {
+      var el_1 = children[0]
+      // optimize single v-for
+      if (
+        children.length === 1 &&
+        el_1.for &&
+        el_1.tag !== 'template' &&
+        el_1.tag !== 'slot'
+      ) {
+        var normalizationType_1 = checkSkip
+          ? state.maybeComponent(el_1)
+            ? ',1'
+            : ',0'
+          : ''
+        return ''
+          .concat((altGenElement || genElement)(el_1, state))
+          .concat(normalizationType_1)
+      }
+      var normalizationType = checkSkip
+        ? getNormalizationType(children, state.maybeComponent)
+        : 0
+      var gen_1 = altGenNode || genNode
+      return '['
+        .concat(
+          children
+            .map(function (c) {
+              return gen_1(c, state)
+            })
+            .join(','),
+          ']'
+        )
+        .concat(normalizationType ? ','.concat(normalizationType) : '')
+    }
+  }
+  // determine the normalization needed for the children array.
+  // 0: no normalization needed
+  // 1: simple normalization needed (possible 1-level deep nested array)
+  // 2: full normalization needed
+  function getNormalizationType(children, maybeComponent) {
+    var res = 0
+    for (var i = 0; i < children.length; i++) {
+      var el = children[i]
+      if (el.type !== 1) {
+        continue
+      }
+      if (
+        needsNormalization(el) ||
+        (el.ifConditions &&
+          el.ifConditions.some(function (c) {
+            return needsNormalization(c.block)
+          }))
+      ) {
+        res = 2
+        break
+      }
+      if (
+        maybeComponent(el) ||
+        (el.ifConditions &&
+          el.ifConditions.some(function (c) {
+            return maybeComponent(c.block)
+          }))
+      ) {
+        res = 1
+      }
+    }
+    return res
+  }
+  function needsNormalization(el) {
+    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+  }
+  function genNode(node, state) {
+    if (node.type === 1) {
+      return genElement(node, state)
+    } else if (node.type === 3 && node.isComment) {
+      return genComment(node)
+    } else {
+      return genText(node)
+    }
+  }
+  function genText(text) {
+    return '_v('.concat(
+      text.type === 2
+        ? text.expression // no need for () because already wrapped in _s()
+        : transformSpecialNewlines(JSON.stringify(text.text)),
+      ')'
+    )
+  }
+  function genComment(comment) {
+    return '_e('.concat(JSON.stringify(comment.text), ')')
+  }
+  function genSlot(el, state) {
+    var slotName = el.slotName || '"default"'
+    var children = genChildren(el, state)
+    var res = '_t('
+      .concat(slotName)
+      .concat(children ? ',function(){return '.concat(children, '}') : '')
+    var attrs =
+      el.attrs || el.dynamicAttrs
+        ? genProps(
+            (el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) {
+              return {
+                // slot props are camelized
+                name: camelize(attr.name),
+                value: attr.value,
+                dynamic: attr.dynamic
+              }
+            })
+          )
+        : null
+    var bind = el.attrsMap['v-bind']
+    if ((attrs || bind) && !children) {
+      res += ',null'
+    }
+    if (attrs) {
+      res += ','.concat(attrs)
+    }
+    if (bind) {
+      res += ''.concat(attrs ? '' : ',null', ',').concat(bind)
+    }
+    return res + ')'
+  }
+  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
+  function genComponent(componentName, el, state) {
+    var children = el.inlineTemplate ? null : genChildren(el, state, true)
+    return '_c('
+      .concat(componentName, ',')
+      .concat(genData(el, state))
+      .concat(children ? ','.concat(children) : '', ')')
+  }
+  function genProps(props) {
+    var staticProps = ''
+    var dynamicProps = ''
+    for (var i = 0; i < props.length; i++) {
+      var prop = props[i]
+      var value = transformSpecialNewlines(prop.value)
+      if (prop.dynamic) {
+        dynamicProps += ''.concat(prop.name, ',').concat(value, ',')
+      } else {
+        staticProps += '"'.concat(prop.name, '":').concat(value, ',')
+      }
+    }
+    staticProps = '{'.concat(staticProps.slice(0, -1), '}')
+    if (dynamicProps) {
+      return '_d('
+        .concat(staticProps, ',[')
+        .concat(dynamicProps.slice(0, -1), '])')
+    } else {
+      return staticProps
+    }
+  }
+  // #3895, #4268
+  function transformSpecialNewlines(text) {
+    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
+  }
+
+  // these keywords should not appear inside expressions, but operators like
+  // typeof, instanceof and in are allowed
+  var prohibitedKeywordRE = new RegExp(
+    '\\b' +
+      (
+        'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+        'super,throw,while,yield,delete,export,import,return,switch,default,' +
+        'extends,finally,continue,debugger,function,arguments'
+      )
+        .split(',')
+        .join('\\b|\\b') +
+      '\\b'
+  )
+  // these unary operators should not be used as property/method names
+  var unaryOperatorsRE = new RegExp(
+    '\\b' +
+      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+      '\\s*\\([^\\)]*\\)'
+  )
+  // strip strings in expressions
+  var stripStringRE =
+    /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
+  // detect problematic expressions in a template
+  function detectErrors(ast, warn) {
+    if (ast) {
+      checkNode(ast, warn)
+    }
+  }
+  function checkNode(node, warn) {
+    if (node.type === 1) {
+      for (var name_1 in node.attrsMap) {
+        if (dirRE.test(name_1)) {
+          var value = node.attrsMap[name_1]
+          if (value) {
+            var range = node.rawAttrsMap[name_1]
+            if (name_1 === 'v-for') {
+              checkFor(node, 'v-for="'.concat(value, '"'), warn, range)
+            } else if (name_1 === 'v-slot' || name_1[0] === '#') {
+              checkFunctionParameterExpression(
+                value,
+                ''.concat(name_1, '="').concat(value, '"'),
+                warn,
+                range
+              )
+            } else if (onRE.test(name_1)) {
+              checkEvent(
+                value,
+                ''.concat(name_1, '="').concat(value, '"'),
+                warn,
+                range
+              )
+            } else {
+              checkExpression(
+                value,
+                ''.concat(name_1, '="').concat(value, '"'),
+                warn,
+                range
+              )
+            }
+          }
+        }
+      }
+      if (node.children) {
+        for (var i = 0; i < node.children.length; i++) {
+          checkNode(node.children[i], warn)
+        }
+      }
+    } else if (node.type === 2) {
+      checkExpression(node.expression, node.text, warn, node)
+    }
+  }
+  function checkEvent(exp, text, warn, range) {
+    var stripped = exp.replace(stripStringRE, '')
+    var keywordMatch = stripped.match(unaryOperatorsRE)
+    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+      warn(
+        'avoid using JavaScript unary operator as property name: ' +
+          '"'.concat(keywordMatch[0], '" in expression ').concat(text.trim()),
+        range
+      )
+    }
+    checkExpression(exp, text, warn, range)
+  }
+  function checkFor(node, text, warn, range) {
+    checkExpression(node.for || '', text, warn, range)
+    checkIdentifier(node.alias, 'v-for alias', text, warn, range)
+    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
+    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
+  }
+  function checkIdentifier(ident, type, text, warn, range) {
+    if (typeof ident === 'string') {
+      try {
+        new Function('var '.concat(ident, '=_'))
+      } catch (e) {
+        warn(
+          'invalid '
+            .concat(type, ' "')
+            .concat(ident, '" in expression: ')
+            .concat(text.trim()),
+          range
+        )
+      }
+    }
+  }
+  function checkExpression(exp, text, warn, range) {
+    try {
+      new Function('return '.concat(exp))
+    } catch (e) {
+      var keywordMatch = exp
+        .replace(stripStringRE, '')
+        .match(prohibitedKeywordRE)
+      if (keywordMatch) {
+        warn(
+          'avoid using JavaScript keyword as property name: ' +
+            '"'
+              .concat(keywordMatch[0], '"\n  Raw expression: ')
+              .concat(text.trim()),
+          range
+        )
+      } else {
+        warn(
+          'invalid expression: '.concat(e.message, ' in\n\n') +
+            '    '.concat(exp, '\n\n') +
+            '  Raw expression: '.concat(text.trim(), '\n'),
+          range
+        )
+      }
+    }
+  }
+  function checkFunctionParameterExpression(exp, text, warn, range) {
+    try {
+      new Function(exp, '')
+    } catch (e) {
+      warn(
+        'invalid function parameter expression: '.concat(e.message, ' in\n\n') +
+          '    '.concat(exp, '\n\n') +
+          '  Raw expression: '.concat(text.trim(), '\n'),
+        range
+      )
+    }
+  }
+
+  var range = 2
+  function generateCodeFrame(source, start, end) {
+    if (start === void 0) {
+      start = 0
+    }
+    if (end === void 0) {
+      end = source.length
+    }
+    var lines = source.split(/\r?\n/)
+    var count = 0
+    var res = []
+    for (var i = 0; i < lines.length; i++) {
+      count += lines[i].length + 1
+      if (count >= start) {
+        for (var j = i - range; j <= i + range || end > count; j++) {
+          if (j < 0 || j >= lines.length) continue
+          res.push(
+            ''
+              .concat(j + 1)
+              .concat(repeat(' ', 3 - String(j + 1).length), '|  ')
+              .concat(lines[j])
+          )
+          var lineLength = lines[j].length
+          if (j === i) {
+            // push underline
+            var pad = start - (count - lineLength) + 1
+            var length_1 = end > count ? lineLength - pad : end - start
+            res.push('   |  ' + repeat(' ', pad) + repeat('^', length_1))
+          } else if (j > i) {
+            if (end > count) {
+              var length_2 = Math.min(end - count, lineLength)
+              res.push('   |  ' + repeat('^', length_2))
+            }
+            count += lineLength + 1
+          }
+        }
+        break
+      }
+    }
+    return res.join('\n')
+  }
+  function repeat(str, n) {
+    var result = ''
+    if (n > 0) {
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        // eslint-disable-line
+        if (n & 1) result += str
+        n >>>= 1
+        if (n <= 0) break
+        str += str
+      }
+    }
+    return result
+  }
+
+  function createFunction(code, errors) {
+    try {
+      return new Function(code)
+    } catch (err) {
+      errors.push({ err: err, code: code })
+      return noop
+    }
+  }
+  function createCompileToFunctionFn(compile) {
+    var cache = Object.create(null)
+    return function compileToFunctions(template, options, vm) {
+      options = extend({}, options)
+      var warn = options.warn || warn$2
+      delete options.warn
+      /* istanbul ignore if */
+      {
+        // detect possible CSP restriction
+        try {
+          new Function('return 1')
+        } catch (e) {
+          if (e.toString().match(/unsafe-eval|CSP/)) {
+            warn(
+              'It seems you are using the standalone build of Vue.js in an ' +
+                'environment with Content Security Policy that prohibits unsafe-eval. ' +
+                'The template compiler cannot work in this environment. Consider ' +
+                'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+                'templates into render functions.'
+            )
+          }
+        }
+      }
+      // check cache
+      var key = options.delimiters
+        ? String(options.delimiters) + template
+        : template
+      if (cache[key]) {
+        return cache[key]
+      }
+      // compile
+      var compiled = compile(template, options)
+      // check compilation errors/tips
+      {
+        if (compiled.errors && compiled.errors.length) {
+          if (options.outputSourceRange) {
+            compiled.errors.forEach(function (e) {
+              warn(
+                'Error compiling template:\n\n'.concat(e.msg, '\n\n') +
+                  generateCodeFrame(template, e.start, e.end),
+                vm
+              )
+            })
+          } else {
+            warn(
+              'Error compiling template:\n\n'.concat(template, '\n\n') +
+                compiled.errors
+                  .map(function (e) {
+                    return '- '.concat(e)
+                  })
+                  .join('\n') +
+                '\n',
+              vm
+            )
+          }
+        }
+        if (compiled.tips && compiled.tips.length) {
+          if (options.outputSourceRange) {
+            compiled.tips.forEach(function (e) {
+              return tip(e.msg, vm)
+            })
+          } else {
+            compiled.tips.forEach(function (msg) {
+              return tip(msg, vm)
+            })
+          }
+        }
+      }
+      // turn code into functions
+      var res = {}
+      var fnGenErrors = []
+      res.render = createFunction(compiled.render, fnGenErrors)
+      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+        return createFunction(code, fnGenErrors)
+      })
+      // check function generation errors.
+      // this should only happen if there is a bug in the compiler itself.
+      // mostly for codegen development use
+      /* istanbul ignore if */
+      {
+        if (
+          (!compiled.errors || !compiled.errors.length) &&
+          fnGenErrors.length
+        ) {
+          warn(
+            'Failed to generate render function:\n\n' +
+              fnGenErrors
+                .map(function (_a) {
+                  var err = _a.err,
+                    code = _a.code
+                  return ''.concat(err.toString(), ' in\n\n').concat(code, '\n')
+                })
+                .join('\n'),
+            vm
+          )
+        }
+      }
+      return (cache[key] = res)
+    }
+  }
+
+  function createCompilerCreator(baseCompile) {
+    return function createCompiler(baseOptions) {
+      function compile(template, options) {
+        var finalOptions = Object.create(baseOptions)
+        var errors = []
+        var tips = []
+        var warn = function (msg, range, tip) {
+          ;(tip ? tips : errors).push(msg)
+        }
+        if (options) {
+          if (options.outputSourceRange) {
+            // $flow-disable-line
+            var leadingSpaceLength_1 = template.match(/^\s*/)[0].length
+            warn = function (msg, range, tip) {
+              var data = typeof msg === 'string' ? { msg: msg } : msg
+              if (range) {
+                if (range.start != null) {
+                  data.start = range.start + leadingSpaceLength_1
+                }
+                if (range.end != null) {
+                  data.end = range.end + leadingSpaceLength_1
+                }
+              }
+              ;(tip ? tips : errors).push(data)
+            }
+          }
+          // merge custom modules
+          if (options.modules) {
+            finalOptions.modules = (baseOptions.modules || []).concat(
+              options.modules
+            )
+          }
+          // merge custom directives
+          if (options.directives) {
+            finalOptions.directives = extend(
+              Object.create(baseOptions.directives || null),
+              options.directives
+            )
+          }
+          // copy other options
+          for (var key in options) {
+            if (key !== 'modules' && key !== 'directives') {
+              finalOptions[key] = options[key]
+            }
+          }
+        }
+        finalOptions.warn = warn
+        var compiled = baseCompile(template.trim(), finalOptions)
+        {
+          detectErrors(compiled.ast, warn)
+        }
+        compiled.errors = errors
+        compiled.tips = tips
+        return compiled
+      }
+      return {
+        compile: compile,
+        compileToFunctions: createCompileToFunctionFn(compile)
+      }
+    }
+  }
+
+  // `createCompilerCreator` allows creating compilers that use alternative
+  // parser/optimizer/codegen, e.g the SSR optimizing compiler.
+  // Here we just export a default compiler using the default parts.
+  var createCompiler$1 = createCompilerCreator(function baseCompile(
+    template,
+    options
+  ) {
+    var ast = parse(template.trim(), options)
+    if (options.optimize !== false) {
+      optimize$1(ast, options)
+    }
+    var code = generate$1(ast, options)
+    return {
+      ast: ast,
+      render: code.render,
+      staticRenderFns: code.staticRenderFns
+    }
+  })
+
+  var _a$1 = createCompiler$1(baseOptions),
+    compile$1 = _a$1.compile,
+    compileToFunctions$1 = _a$1.compileToFunctions
+
+  var isAttr = makeMap(
+    'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+      'target,title,usemap,value,width,wrap'
+  )
+  /* istanbul ignore next */
+  var isRenderableAttr = function (name) {
+    return (
+      isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
+    )
+  }
+  var propsToAttrMap = {
+    acceptCharset: 'accept-charset',
+    className: 'class',
+    htmlFor: 'for',
+    httpEquiv: 'http-equiv'
+  }
+  var ESC = {
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    '&': '&amp;'
+  }
+  function escape(s) {
+    return s.replace(/[<>"&]/g, escapeChar)
+  }
+  function escapeChar(a) {
+    return ESC[a] || a
+  }
+
+  var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
+  // let the model AST transform translate v-model into appropriate
+  // props bindings
+  function applyModelTransform(el, state) {
+    if (el.directives) {
+      for (var i = 0; i < el.directives.length; i++) {
+        var dir = el.directives[i]
+        if (dir.name === 'model') {
+          state.directives.model(el, dir, state.warn)
+          // remove value for textarea as its converted to text
+          if (el.tag === 'textarea' && el.props) {
+            el.props = el.props.filter(function (p) {
+              return p.name !== 'value'
+            })
+          }
+          break
+        }
+      }
+    }
+  }
+  function genAttrSegments(attrs) {
+    return attrs.map(function (_a) {
+      var name = _a.name,
+        value = _a.value
+      return genAttrSegment(name, value)
+    })
+  }
+  function genDOMPropSegments(props, attrs) {
+    var segments = []
+    props.forEach(function (_a) {
+      var name = _a.name,
+        value = _a.value
+      name = propsToAttrMap[name] || name.toLowerCase()
+      if (
+        isRenderableAttr(name) &&
+        !(
+          attrs &&
+          attrs.some(function (a) {
+            return a.name === name
+          })
+        )
+      ) {
+        segments.push(genAttrSegment(name, value))
+      }
+    })
+    return segments
+  }
+  function genAttrSegment(name, value) {
+    if (plainStringRE.test(value)) {
+      // force double quote
+      value = value.replace(/^'|'$/g, '"')
+      // force enumerated attr to "true"
+      if (isEnumeratedAttr(name) && value !== '"false"') {
+        value = '"true"'
+      }
+      return {
+        type: RAW,
+        value: isBooleanAttr(name)
+          ? ' '.concat(name, '="').concat(name, '"')
+          : value === '""'
+          ? ' '.concat(name)
+          : ' '.concat(name, '="').concat(JSON.parse(value), '"')
+      }
+    } else {
+      return {
+        type: EXPRESSION,
+        value: '_ssrAttr('.concat(JSON.stringify(name), ',').concat(value, ')')
+      }
+    }
+  }
+  function genClassSegments(staticClass, classBinding) {
+    if (staticClass && !classBinding) {
+      return [
+        { type: RAW, value: ' class="'.concat(JSON.parse(staticClass), '"') }
+      ]
+    } else {
+      return [
+        {
+          type: EXPRESSION,
+          value: '_ssrClass('
+            .concat(staticClass || 'null', ',')
+            .concat(classBinding || 'null', ')')
+        }
+      ]
+    }
+  }
+  function genStyleSegments(
+    staticStyle,
+    parsedStaticStyle,
+    styleBinding,
+    vShowExpression
+  ) {
+    if (staticStyle && !styleBinding && !vShowExpression) {
+      return [
+        { type: RAW, value: ' style='.concat(JSON.stringify(staticStyle)) }
+      ]
+    } else {
+      return [
+        {
+          type: EXPRESSION,
+          value: '_ssrStyle('
+            .concat(parsedStaticStyle || 'null', ',')
+            .concat(styleBinding || 'null', ', ')
+            .concat(
+              vShowExpression
+                ? '{ display: ('.concat(vShowExpression, ") ? '' : 'none' }")
+                : 'null',
+              ')'
+            )
+        }
+      ]
+    }
+  }
+
+  /**
+   * In SSR, the vdom tree is generated only once and never patched, so
+   * we can optimize most element / trees into plain string render functions.
+   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+   *
+   * The criteria for SSR optimizability is quite a bit looser than static tree
+   * detection (which is designed for client re-render). In SSR we bail only for
+   * components/slots/custom directives.
+   */
+  // optimizability constants
+  var optimizability = {
+    FALSE: 0,
+    FULL: 1,
+    SELF: 2,
+    CHILDREN: 3,
+    PARTIAL: 4 // self un-optimizable with some un-optimizable children
+  }
+  var isPlatformReservedTag
+  function optimize(root, options) {
+    if (!root) return
+    isPlatformReservedTag = options.isReservedTag || no
+    walk(root, true)
+  }
+  function walk(node, isRoot) {
+    if (isUnOptimizableTree(node)) {
+      node.ssrOptimizability = optimizability.FALSE
+      return
+    }
+    // root node or nodes with custom directives should always be a VNode
+    var selfUnoptimizable = isRoot || hasCustomDirective(node)
+    var check = function (child) {
+      if (child.ssrOptimizability !== optimizability.FULL) {
+        node.ssrOptimizability = selfUnoptimizable
+          ? optimizability.PARTIAL
+          : optimizability.SELF
+      }
+    }
+    if (selfUnoptimizable) {
+      node.ssrOptimizability = optimizability.CHILDREN
+    }
+    if (node.type === 1) {
+      for (var i = 0, l = node.children.length; i < l; i++) {
+        var child = node.children[i]
+        walk(child)
+        check(child)
+      }
+      if (node.ifConditions) {
+        for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+          var block = node.ifConditions[i].block
+          walk(block, isRoot)
+          check(block)
+        }
+      }
+      if (
+        node.ssrOptimizability == null ||
+        (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
+      ) {
+        node.ssrOptimizability = optimizability.FULL
+      } else {
+        node.children = optimizeSiblings(node)
+      }
+    } else {
+      node.ssrOptimizability = optimizability.FULL
+    }
+  }
+  function optimizeSiblings(el) {
+    var children = el.children
+    var optimizedChildren = []
+    var currentOptimizableGroup = []
+    var pushGroup = function () {
+      if (currentOptimizableGroup.length) {
+        optimizedChildren.push({
+          type: 1,
+          parent: el,
+          tag: 'template',
+          attrsList: [],
+          attrsMap: {},
+          rawAttrsMap: {},
+          children: currentOptimizableGroup,
+          ssrOptimizability: optimizability.FULL
+        })
+      }
+      currentOptimizableGroup = []
+    }
+    for (var i = 0; i < children.length; i++) {
+      var c = children[i]
+      if (c.ssrOptimizability === optimizability.FULL) {
+        currentOptimizableGroup.push(c)
+      } else {
+        // wrap fully-optimizable adjacent siblings inside a template tag
+        // so that they can be optimized into a single ssrNode by codegen
+        pushGroup()
+        optimizedChildren.push(c)
+      }
+    }
+    pushGroup()
+    return optimizedChildren
+  }
+  function isUnOptimizableTree(node) {
+    if (node.type === 2 || node.type === 3) {
+      // text or expression
+      return false
+    }
+    return (
+      isBuiltInTag(node.tag) || // built-in (slot, component)
+      !isPlatformReservedTag(node.tag) || // custom component
+      !!node.component || // "is" component
+      isSelectWithModel(node) // <select v-model> requires runtime inspection
+    )
+  }
+  var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
+  function hasCustomDirective(node) {
+    return (
+      node.type === 1 &&
+      node.directives &&
+      node.directives.some(function (d) {
+        return !isBuiltInDir(d.name)
+      })
+    )
+  }
+  // <select v-model> cannot be optimized because it requires a runtime check
+  // to determine proper selected option
+  function isSelectWithModel(node) {
+    return (
+      node.type === 1 &&
+      node.tag === 'select' &&
+      node.directives != null &&
+      node.directives.some(function (d) {
+        return d.name === 'model'
+      })
+    )
+  }
+
+  // The SSR codegen is essentially extending the default codegen to handle
+  // segment types
+  var RAW = 0
+  var INTERPOLATION = 1
+  var EXPRESSION = 2
+  function generate(ast, options) {
+    var state = new CodegenState(options)
+    var code = ast ? genSSRElement(ast, state) : '_c("div")'
+    return {
+      render: 'with(this){return '.concat(code, '}'),
+      staticRenderFns: state.staticRenderFns
+    }
+  }
+  function genSSRElement(el, state) {
+    if (el.for && !el.forProcessed) {
+      return genFor(el, state, genSSRElement)
+    } else if (el.if && !el.ifProcessed) {
+      return genIf(el, state, genSSRElement)
+    } else if (el.tag === 'template' && !el.slotTarget) {
+      return el.ssrOptimizability === optimizability.FULL
+        ? genChildrenAsStringNode(el, state)
+        : genSSRChildren(el, state) || 'void 0'
+    }
+    switch (el.ssrOptimizability) {
+      case optimizability.FULL:
+        // stringify whole tree
+        return genStringElement(el, state)
+      case optimizability.SELF:
+        // stringify self and check children
+        return genStringElementWithChildren(el, state)
+      case optimizability.CHILDREN:
+        // generate self as VNode and stringify children
+        return genNormalElement(el, state, true)
+      case optimizability.PARTIAL:
+        // generate self as VNode and check children
+        return genNormalElement(el, state, false)
+      default:
+        // bail whole tree
+        return genElement(el, state)
+    }
+  }
+  function genNormalElement(el, state, stringifyChildren) {
+    var data = el.plain ? undefined : genData(el, state)
+    var children = stringifyChildren
+      ? '['.concat(genChildrenAsStringNode(el, state), ']')
+      : genSSRChildren(el, state, true)
+    return "_c('"
+      .concat(el.tag, "'")
+      .concat(data ? ','.concat(data) : '')
+      .concat(children ? ','.concat(children) : '', ')')
+  }
+  function genSSRChildren(el, state, checkSkip) {
+    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
+  }
+  function genSSRNode(el, state) {
+    return el.type === 1 ? genSSRElement(el, state) : genText(el)
+  }
+  function genChildrenAsStringNode(el, state) {
+    return el.children.length
+      ? '_ssrNode('.concat(flattenSegments(childrenToSegments(el, state)), ')')
+      : ''
+  }
+  function genStringElement(el, state) {
+    return '_ssrNode('.concat(elementToString(el, state), ')')
+  }
+  function genStringElementWithChildren(el, state) {
+    var children = genSSRChildren(el, state, true)
+    return '_ssrNode('
+      .concat(flattenSegments(elementToOpenTagSegments(el, state)), ',"</')
+      .concat(el.tag, '>"')
+      .concat(children ? ','.concat(children) : '', ')')
+  }
+  function elementToString(el, state) {
+    return '('.concat(flattenSegments(elementToSegments(el, state)), ')')
+  }
+  function elementToSegments(el, state) {
+    // v-for / v-if
+    if (el.for && !el.forProcessed) {
+      el.forProcessed = true
+      return [
+        {
+          type: EXPRESSION,
+          value: genFor(el, state, elementToString, '_ssrList')
+        }
+      ]
+    } else if (el.if && !el.ifProcessed) {
+      el.ifProcessed = true
+      return [
+        {
+          type: EXPRESSION,
+          value: genIf(el, state, elementToString, '"<!---->"')
+        }
+      ]
+    } else if (el.tag === 'template') {
+      return childrenToSegments(el, state)
+    }
+    var openSegments = elementToOpenTagSegments(el, state)
+    var childrenSegments = childrenToSegments(el, state)
+    var isUnaryTag = state.options.isUnaryTag
+    var close =
+      isUnaryTag && isUnaryTag(el.tag)
+        ? []
+        : [{ type: RAW, value: '</'.concat(el.tag, '>') }]
+    return openSegments.concat(childrenSegments, close)
+  }
+  function elementToOpenTagSegments(el, state) {
+    applyModelTransform(el, state)
+    var binding
+    var segments = [{ type: RAW, value: '<'.concat(el.tag) }]
+    // attrs
+    if (el.attrs) {
+      segments.push.apply(segments, genAttrSegments(el.attrs))
+    }
+    // domProps
+    if (el.props) {
+      segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs))
+    }
+    // v-bind="object"
+    if ((binding = el.attrsMap['v-bind'])) {
+      segments.push({
+        type: EXPRESSION,
+        value: '_ssrAttrs('.concat(binding, ')')
+      })
+    }
+    // v-bind.prop="object"
+    if ((binding = el.attrsMap['v-bind.prop'])) {
+      segments.push({
+        type: EXPRESSION,
+        value: '_ssrDOMProps('.concat(binding, ')')
+      })
+    }
+    // class
+    if (el.staticClass || el.classBinding) {
+      segments.push.apply(
+        segments,
+        genClassSegments(el.staticClass, el.classBinding)
+      )
+    }
+    // style & v-show
+    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+      segments.push.apply(
+        segments,
+        genStyleSegments(
+          el.attrsMap.style,
+          el.staticStyle,
+          el.styleBinding,
+          el.attrsMap['v-show']
+        )
+      )
+    }
+    // _scopedId
+    if (state.options.scopeId) {
+      segments.push({ type: RAW, value: ' '.concat(state.options.scopeId) })
+    }
+    segments.push({ type: RAW, value: '>' })
+    return segments
+  }
+  function childrenToSegments(el, state) {
+    var binding
+    if ((binding = el.attrsMap['v-html'])) {
+      return [{ type: EXPRESSION, value: '_s('.concat(binding, ')') }]
+    }
+    if ((binding = el.attrsMap['v-text'])) {
+      return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
+    }
+    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+      return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
+    }
+    return el.children ? nodesToSegments(el.children, state) : []
+  }
+  function nodesToSegments(children, state) {
+    var segments = []
+    for (var i = 0; i < children.length; i++) {
+      var c = children[i]
+      if (c.type === 1) {
+        segments.push.apply(segments, elementToSegments(c, state))
+      } else if (c.type === 2) {
+        segments.push({ type: INTERPOLATION, value: c.expression })
+      } else if (c.type === 3) {
+        var text = escape(c.text)
+        if (c.isComment) {
+          text = '<!--' + text + '-->'
+        }
+        segments.push({ type: RAW, value: text })
+      }
+    }
+    return segments
+  }
+  function flattenSegments(segments) {
+    var mergedSegments = []
+    var textBuffer = ''
+    var pushBuffer = function () {
+      if (textBuffer) {
+        mergedSegments.push(JSON.stringify(textBuffer))
+        textBuffer = ''
+      }
+    }
+    for (var i = 0; i < segments.length; i++) {
+      var s = segments[i]
+      if (s.type === RAW) {
+        textBuffer += s.value
+      } else if (s.type === INTERPOLATION) {
+        pushBuffer()
+        mergedSegments.push('_ssrEscape('.concat(s.value, ')'))
+      } else if (s.type === EXPRESSION) {
+        pushBuffer()
+        mergedSegments.push('('.concat(s.value, ')'))
+      }
+    }
+    pushBuffer()
+    return mergedSegments.join('+')
+  }
+
+  var createCompiler = createCompilerCreator(function baseCompile(
+    template,
+    options
+  ) {
+    var ast = parse(template.trim(), options)
+    optimize(ast, options)
+    var code = generate(ast, options)
+    return {
+      ast: ast,
+      render: code.render,
+      staticRenderFns: code.staticRenderFns
+    }
+  })
+
+  var _a = createCompiler(baseOptions),
+    compile = _a.compile,
+    compileToFunctions = _a.compileToFunctions
+
+  exports.compile = compile$1
+  exports.compileToFunctions = compileToFunctions$1
+  exports.generateCodeFrame = generateCodeFrame
+  exports.parseComponent = parseComponent
+  exports.ssrCompile = compile
+  exports.ssrCompileToFunctions = compileToFunctions
+
+  Object.defineProperty(exports, '__esModule', { value: true })
+})
diff --git a/packages/template-compiler/build.js b/packages/template-compiler/build.js
new file mode 100644
index 00000000000..4178b15ca71
--- /dev/null
+++ b/packages/template-compiler/build.js
@@ -0,0 +1,5148 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+
+var deindent = require('de-indent')
+var he = require('he')
+
+function _interopDefaultLegacy(e) {
+  return e && typeof e === 'object' && 'default' in e ? e : { default: e }
+}
+
+var deindent__default = /*#__PURE__*/ _interopDefaultLegacy(deindent)
+var he__default = /*#__PURE__*/ _interopDefaultLegacy(he)
+
+var emptyObject = Object.freeze({})
+// These helpers produce better VM code in JS engines due to their
+// explicitness and function inlining.
+function isUndef(v) {
+  return v === undefined || v === null
+}
+/**
+ * Check if value is primitive.
+ */
+function isPrimitive(value) {
+  return (
+    typeof value === 'string' ||
+    typeof value === 'number' ||
+    // $flow-disable-line
+    typeof value === 'symbol' ||
+    typeof value === 'boolean'
+  )
+}
+/**
+ * Quick object check - this is primarily used to tell
+ * objects from primitive values when we know the value
+ * is a JSON-compliant type.
+ */
+function isObject(obj) {
+  return obj !== null && typeof obj === 'object'
+}
+/**
+ * Get the raw type string of a value, e.g., [object Object].
+ */
+var _toString = Object.prototype.toString
+function toRawType(value) {
+  return _toString.call(value).slice(8, -1)
+}
+/**
+ * Strict object type check. Only returns true
+ * for plain JavaScript objects.
+ */
+function isPlainObject(obj) {
+  return _toString.call(obj) === '[object Object]'
+}
+/**
+ * Check if val is a valid array index.
+ */
+function isValidArrayIndex(val) {
+  var n = parseFloat(String(val))
+  return n >= 0 && Math.floor(n) === n && isFinite(val)
+}
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ */
+function makeMap(str, expectsLowerCase) {
+  var map = Object.create(null)
+  var list = str.split(',')
+  for (var i = 0; i < list.length; i++) {
+    map[list[i]] = true
+  }
+  return expectsLowerCase
+    ? function (val) {
+        return map[val.toLowerCase()]
+      }
+    : function (val) {
+        return map[val]
+      }
+}
+/**
+ * Check if a tag is a built-in tag.
+ */
+var isBuiltInTag = makeMap('slot,component', true)
+/**
+ * Check if an attribute is a reserved attribute.
+ */
+makeMap('key,ref,slot,slot-scope,is')
+/**
+ * Remove an item from an array.
+ */
+function remove(arr, item) {
+  if (arr.length) {
+    var index = arr.indexOf(item)
+    if (index > -1) {
+      return arr.splice(index, 1)
+    }
+  }
+}
+/**
+ * Check whether an object has the property.
+ */
+var hasOwnProperty = Object.prototype.hasOwnProperty
+function hasOwn(obj, key) {
+  return hasOwnProperty.call(obj, key)
+}
+/**
+ * Create a cached version of a pure function.
+ */
+function cached(fn) {
+  var cache = Object.create(null)
+  return function cachedFn(str) {
+    var hit = cache[str]
+    return hit || (cache[str] = fn(str))
+  }
+}
+/**
+ * Camelize a hyphen-delimited string.
+ */
+var camelizeRE = /-(\w)/g
+var camelize = cached(function (str) {
+  return str.replace(camelizeRE, function (_, c) {
+    return c ? c.toUpperCase() : ''
+  })
+})
+/**
+ * Hyphenate a camelCase string.
+ */
+var hyphenateRE = /\B([A-Z])/g
+var hyphenate = cached(function (str) {
+  return str.replace(hyphenateRE, '-$1').toLowerCase()
+})
+/**
+ * Mix properties into target object.
+ */
+function extend(to, _from) {
+  for (var key in _from) {
+    to[key] = _from[key]
+  }
+  return to
+}
+/* eslint-disable no-unused-vars */
+/**
+ * Perform no operation.
+ * Stubbing args to make Flow happy without leaving useless transpiled code
+ * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
+ */
+function noop(a, b, c) {}
+/**
+ * Always return false.
+ */
+var no = function (a, b, c) {
+  return false
+}
+/* eslint-enable no-unused-vars */
+/**
+ * Return the same value.
+ */
+var identity = function (_) {
+  return _
+}
+/**
+ * Generate a string containing static keys from compiler modules.
+ */
+function genStaticKeys$1(modules) {
+  return modules
+    .reduce(function (keys, m) {
+      return keys.concat(m.staticKeys || [])
+    }, [])
+    .join(',')
+}
+
+var isUnaryTag = makeMap(
+  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
+    'link,meta,param,source,track,wbr'
+)
+// Elements that you can, intentionally, leave open
+// (and which close themselves)
+var canBeLeftOpenTag = makeMap(
+  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
+)
+// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+var isNonPhrasingTag = makeMap(
+  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
+    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
+    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
+    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
+    'title,tr,track'
+)
+
+/**
+ * unicode letters used for parsing html tags, component names and property paths.
+ * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
+ * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
+ */
+var unicodeRegExp =
+  /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
+/**
+ * Define a property.
+ */
+function def(obj, key, val, enumerable) {
+  Object.defineProperty(obj, key, {
+    value: val,
+    enumerable: !!enumerable,
+    writable: true,
+    configurable: true
+  })
+}
+
+/**
+ * Not type-checking this file because it's mostly vendor code.
+ */
+// Regular Expressions for parsing tags and attributes
+var attribute =
+  /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
+var dynamicArgAttribute =
+  /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
+var ncname = '[a-zA-Z_][\\-\\.0-9_a-zA-Z'.concat(unicodeRegExp.source, ']*')
+var qnameCapture = '((?:'.concat(ncname, '\\:)?').concat(ncname, ')')
+var startTagOpen = new RegExp('^<'.concat(qnameCapture))
+var startTagClose = /^\s*(\/?)>/
+var endTag = new RegExp('^<\\/'.concat(qnameCapture, '[^>]*>'))
+var doctype = /^<!DOCTYPE [^>]+>/i
+// #7298: escape - to avoid being passed as HTML comment when inlined in page
+var comment = /^<!\--/
+var conditionalComment = /^<!\[/
+// Special Elements (can contain anything)
+var isPlainTextElement = makeMap('script,style,textarea', true)
+var reCache = {}
+var decodingMap = {
+  '&lt;': '<',
+  '&gt;': '>',
+  '&quot;': '"',
+  '&amp;': '&',
+  '&#10;': '\n',
+  '&#9;': '\t',
+  '&#39;': "'"
+}
+var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
+var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
+// #5992
+var isIgnoreNewlineTag = makeMap('pre,textarea', true)
+var shouldIgnoreFirstNewline = function (tag, html) {
+  return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
+}
+function decodeAttr(value, shouldDecodeNewlines) {
+  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
+  return value.replace(re, function (match) {
+    return decodingMap[match]
+  })
+}
+function parseHTML(html, options) {
+  var stack = []
+  var expectHTML = options.expectHTML
+  var isUnaryTag = options.isUnaryTag || no
+  var canBeLeftOpenTag = options.canBeLeftOpenTag || no
+  var index = 0
+  var last, lastTag
+  var _loop_1 = function () {
+    last = html
+    // Make sure we're not in a plaintext content element like script/style
+    if (!lastTag || !isPlainTextElement(lastTag)) {
+      var textEnd = html.indexOf('<')
+      if (textEnd === 0) {
+        // Comment:
+        if (comment.test(html)) {
+          var commentEnd = html.indexOf('-->')
+          if (commentEnd >= 0) {
+            if (options.shouldKeepComment) {
+              options.comment(
+                html.substring(4, commentEnd),
+                index,
+                index + commentEnd + 3
+              )
+            }
+            advance(commentEnd + 3)
+            return 'continue'
+          }
+        }
+        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+        if (conditionalComment.test(html)) {
+          var conditionalEnd = html.indexOf(']>')
+          if (conditionalEnd >= 0) {
+            advance(conditionalEnd + 2)
+            return 'continue'
+          }
+        }
+        // Doctype:
+        var doctypeMatch = html.match(doctype)
+        if (doctypeMatch) {
+          advance(doctypeMatch[0].length)
+          return 'continue'
+        }
+        // End tag:
+        var endTagMatch = html.match(endTag)
+        if (endTagMatch) {
+          var curIndex = index
+          advance(endTagMatch[0].length)
+          parseEndTag(endTagMatch[1], curIndex, index)
+          return 'continue'
+        }
+        // Start tag:
+        var startTagMatch = parseStartTag()
+        if (startTagMatch) {
+          handleStartTag(startTagMatch)
+          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
+            advance(1)
+          }
+          return 'continue'
+        }
+      }
+      var text = void 0,
+        rest = void 0,
+        next = void 0
+      if (textEnd >= 0) {
+        rest = html.slice(textEnd)
+        while (
+          !endTag.test(rest) &&
+          !startTagOpen.test(rest) &&
+          !comment.test(rest) &&
+          !conditionalComment.test(rest)
+        ) {
+          // < in plain text, be forgiving and treat it as text
+          next = rest.indexOf('<', 1)
+          if (next < 0) break
+          textEnd += next
+          rest = html.slice(textEnd)
+        }
+        text = html.substring(0, textEnd)
+      }
+      if (textEnd < 0) {
+        text = html
+      }
+      if (text) {
+        advance(text.length)
+      }
+      if (options.chars && text) {
+        options.chars(text, index - text.length, index)
+      }
+    } else {
+      var endTagLength_1 = 0
+      var stackedTag_1 = lastTag.toLowerCase()
+      var reStackedTag =
+        reCache[stackedTag_1] ||
+        (reCache[stackedTag_1] = new RegExp(
+          '([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)',
+          'i'
+        ))
+      var rest = html.replace(reStackedTag, function (all, text, endTag) {
+        endTagLength_1 = endTag.length
+        if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
+          text = text
+            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
+            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')
+        }
+        if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
+          text = text.slice(1)
+        }
+        if (options.chars) {
+          options.chars(text)
+        }
+        return ''
+      })
+      index += html.length - rest.length
+      html = rest
+      parseEndTag(stackedTag_1, index - endTagLength_1, index)
+    }
+    if (html === last) {
+      options.chars && options.chars(html)
+      if (
+        process.env.NODE_ENV !== 'production' &&
+        !stack.length &&
+        options.warn
+      ) {
+        options.warn(
+          'Mal-formatted tag at end of template: "'.concat(html, '"'),
+          {
+            start: index + html.length
+          }
+        )
+      }
+      return 'break'
+    }
+  }
+  while (html) {
+    var state_1 = _loop_1()
+    if (state_1 === 'break') break
+  }
+  // Clean up any remaining tags
+  parseEndTag()
+  function advance(n) {
+    index += n
+    html = html.substring(n)
+  }
+  function parseStartTag() {
+    var start = html.match(startTagOpen)
+    if (start) {
+      var match = {
+        tagName: start[1],
+        attrs: [],
+        start: index
+      }
+      advance(start[0].length)
+      var end = void 0,
+        attr = void 0
+      while (
+        !(end = html.match(startTagClose)) &&
+        (attr = html.match(dynamicArgAttribute) || html.match(attribute))
+      ) {
+        attr.start = index
+        advance(attr[0].length)
+        attr.end = index
+        match.attrs.push(attr)
+      }
+      if (end) {
+        match.unarySlash = end[1]
+        advance(end[0].length)
+        match.end = index
+        return match
+      }
+    }
+  }
+  function handleStartTag(match) {
+    var tagName = match.tagName
+    var unarySlash = match.unarySlash
+    if (expectHTML) {
+      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
+        parseEndTag(lastTag)
+      }
+      if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
+        parseEndTag(tagName)
+      }
+    }
+    var unary = isUnaryTag(tagName) || !!unarySlash
+    var l = match.attrs.length
+    var attrs = new Array(l)
+    for (var i = 0; i < l; i++) {
+      var args = match.attrs[i]
+      var value = args[3] || args[4] || args[5] || ''
+      var shouldDecodeNewlines =
+        tagName === 'a' && args[1] === 'href'
+          ? options.shouldDecodeNewlinesForHref
+          : options.shouldDecodeNewlines
+      attrs[i] = {
+        name: args[1],
+        value: decodeAttr(value, shouldDecodeNewlines)
+      }
+      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        attrs[i].start = args.start + args[0].match(/^\s*/).length
+        attrs[i].end = args.end
+      }
+    }
+    if (!unary) {
+      stack.push({
+        tag: tagName,
+        lowerCasedTag: tagName.toLowerCase(),
+        attrs: attrs,
+        start: match.start,
+        end: match.end
+      })
+      lastTag = tagName
+    }
+    if (options.start) {
+      options.start(tagName, attrs, unary, match.start, match.end)
+    }
+  }
+  function parseEndTag(tagName, start, end) {
+    var pos, lowerCasedTagName
+    if (start == null) start = index
+    if (end == null) end = index
+    // Find the closest opened tag of the same type
+    if (tagName) {
+      lowerCasedTagName = tagName.toLowerCase()
+      for (pos = stack.length - 1; pos >= 0; pos--) {
+        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
+          break
+        }
+      }
+    } else {
+      // If no tag name is provided, clean shop
+      pos = 0
+    }
+    if (pos >= 0) {
+      // Close all the open elements, up the stack
+      for (var i = stack.length - 1; i >= pos; i--) {
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          (i > pos || !tagName) &&
+          options.warn
+        ) {
+          options.warn(
+            'tag <'.concat(stack[i].tag, '> has no matching end tag.'),
+            {
+              start: stack[i].start,
+              end: stack[i].end
+            }
+          )
+        }
+        if (options.end) {
+          options.end(stack[i].tag, start, end)
+        }
+      }
+      // Remove the open elements from the stack
+      stack.length = pos
+      lastTag = pos && stack[pos - 1].tag
+    } else if (lowerCasedTagName === 'br') {
+      if (options.start) {
+        options.start(tagName, [], true, start, end)
+      }
+    } else if (lowerCasedTagName === 'p') {
+      if (options.start) {
+        options.start(tagName, [], false, start, end)
+      }
+      if (options.end) {
+        options.end(tagName, start, end)
+      }
+    }
+  }
+}
+
+var splitRE = /\r?\n/g
+var replaceRE = /./g
+var isSpecialTag = makeMap('script,style,template', true)
+/**
+ * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
+ */
+function parseComponent(content, options) {
+  if (options === void 0) {
+    options = {}
+  }
+  var sfc = {
+    template: null,
+    script: null,
+    styles: [],
+    customBlocks: [],
+    errors: []
+  }
+  var depth = 0
+  var currentBlock = null
+  var warn = function (msg) {
+    sfc.errors.push(msg)
+  }
+  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+    warn = function (msg, range) {
+      var data = { msg: msg }
+      if (range.start != null) {
+        data.start = range.start
+      }
+      if (range.end != null) {
+        data.end = range.end
+      }
+      sfc.errors.push(data)
+    }
+  }
+  function start(tag, attrs, unary, start, end) {
+    if (depth === 0) {
+      currentBlock = {
+        type: tag,
+        content: '',
+        start: end,
+        attrs: attrs.reduce(function (cumulated, _a) {
+          var name = _a.name,
+            value = _a.value
+          cumulated[name] = value || true
+          return cumulated
+        }, {})
+      }
+      if (isSpecialTag(tag)) {
+        checkAttrs(currentBlock, attrs)
+        if (tag === 'style') {
+          sfc.styles.push(currentBlock)
+        } else {
+          sfc[tag] = currentBlock
+        }
+      } else {
+        // custom blocks
+        sfc.customBlocks.push(currentBlock)
+      }
+    }
+    if (!unary) {
+      depth++
+    }
+  }
+  function checkAttrs(block, attrs) {
+    for (var i = 0; i < attrs.length; i++) {
+      var attr = attrs[i]
+      if (attr.name === 'lang') {
+        block.lang = attr.value
+      }
+      if (attr.name === 'scoped') {
+        block.scoped = true
+      }
+      if (attr.name === 'module') {
+        block.module = attr.value || true
+      }
+      if (attr.name === 'src') {
+        block.src = attr.value
+      }
+    }
+  }
+  function end(tag, start) {
+    if (depth === 1 && currentBlock) {
+      currentBlock.end = start
+      var text = content.slice(currentBlock.start, currentBlock.end)
+      if (options.deindent !== false) {
+        text = deindent__default['default'](text)
+      }
+      // pad content so that linters and pre-processors can output correct
+      // line numbers in errors and warnings
+      if (currentBlock.type !== 'template' && options.pad) {
+        text = padContent(currentBlock, options.pad) + text
+      }
+      currentBlock.content = text
+      currentBlock = null
+    }
+    depth--
+  }
+  function padContent(block, pad) {
+    if (pad === 'space') {
+      return content.slice(0, block.start).replace(replaceRE, ' ')
+    } else {
+      var offset = content.slice(0, block.start).split(splitRE).length
+      var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
+      return Array(offset).join(padChar)
+    }
+  }
+  parseHTML(content, {
+    warn: warn,
+    start: start,
+    end: end,
+    outputSourceRange: options.outputSourceRange
+  })
+  return sfc
+}
+
+// can we use __proto__?
+var hasProto = '__proto__' in {}
+// Browser environment sniffing
+var inBrowser = typeof window !== 'undefined'
+var UA = inBrowser && window.navigator.userAgent.toLowerCase()
+var isIE = UA && /msie|trident/.test(UA)
+UA && UA.indexOf('msie 9.0') > 0
+var isEdge = UA && UA.indexOf('edge/') > 0
+UA && UA.indexOf('android') > 0
+UA && /iphone|ipad|ipod|ios/.test(UA)
+UA && /chrome\/\d+/.test(UA) && !isEdge
+UA && /phantomjs/.test(UA)
+UA && UA.match(/firefox\/(\d+)/)
+// Firefox has a "watch" function on Object.prototype...
+// @ts-expect-error firebox support
+var nativeWatch = {}.watch
+var supportsPassive = false
+if (inBrowser) {
+  try {
+    var opts = {}
+    Object.defineProperty(opts, 'passive', {
+      get: function () {
+        /* istanbul ignore next */
+        supportsPassive = true
+      }
+    }) // https://github.com/facebook/flow/issues/285
+    window.addEventListener('test-passive', null, opts)
+  } catch (e) {}
+}
+// this needs to be lazy-evaled because vue may be required before
+// vue-server-renderer can set VUE_ENV
+var _isServer
+var isServerRendering = function () {
+  if (_isServer === undefined) {
+    /* istanbul ignore if */
+    if (!inBrowser && typeof global !== 'undefined') {
+      // detect presence of vue-server-renderer and avoid
+      // Webpack shimming the process
+      _isServer =
+        global['process'] && global['process'].env.VUE_ENV === 'server'
+    } else {
+      _isServer = false
+    }
+  }
+  return _isServer
+}
+/* istanbul ignore next */
+function isNative(Ctor) {
+  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
+}
+var hasSymbol =
+  typeof Symbol !== 'undefined' &&
+  isNative(Symbol) &&
+  typeof Reflect !== 'undefined' &&
+  isNative(Reflect.ownKeys)
+/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set));
+else {
+  // a non-standard Set polyfill that only works with primitive keys.
+  /** @class */ ;(function () {
+    function Set() {
+      this.set = Object.create(null)
+    }
+    Set.prototype.has = function (key) {
+      return this.set[key] === true
+    }
+    Set.prototype.add = function (key) {
+      this.set[key] = true
+    }
+    Set.prototype.clear = function () {
+      this.set = Object.create(null)
+    }
+    return Set
+  })()
+}
+
+var ASSET_TYPES = ['component', 'directive', 'filter']
+var LIFECYCLE_HOOKS = [
+  'beforeCreate',
+  'created',
+  'beforeMount',
+  'mounted',
+  'beforeUpdate',
+  'updated',
+  'beforeDestroy',
+  'destroyed',
+  'activated',
+  'deactivated',
+  'errorCaptured',
+  'serverPrefetch'
+]
+
+var config = {
+  /**
+   * Option merge strategies (used in core/util/options)
+   */
+  // $flow-disable-line
+  optionMergeStrategies: Object.create(null),
+  /**
+   * Whether to suppress warnings.
+   */
+  silent: false,
+  /**
+   * Show production mode tip message on boot?
+   */
+  productionTip: process.env.NODE_ENV !== 'production',
+  /**
+   * Whether to enable devtools
+   */
+  devtools: process.env.NODE_ENV !== 'production',
+  /**
+   * Whether to record perf
+   */
+  performance: false,
+  /**
+   * Error handler for watcher errors
+   */
+  errorHandler: null,
+  /**
+   * Warn handler for watcher warns
+   */
+  warnHandler: null,
+  /**
+   * Ignore certain custom elements
+   */
+  ignoredElements: [],
+  /**
+   * Custom user key aliases for v-on
+   */
+  // $flow-disable-line
+  keyCodes: Object.create(null),
+  /**
+   * Check if a tag is reserved so that it cannot be registered as a
+   * component. This is platform-dependent and may be overwritten.
+   */
+  isReservedTag: no,
+  /**
+   * Check if an attribute is reserved so that it cannot be used as a component
+   * prop. This is platform-dependent and may be overwritten.
+   */
+  isReservedAttr: no,
+  /**
+   * Check if a tag is an unknown element.
+   * Platform-dependent.
+   */
+  isUnknownElement: no,
+  /**
+   * Get the namespace of an element
+   */
+  getTagNamespace: noop,
+  /**
+   * Parse the real tag name for the specific platform.
+   */
+  parsePlatformTagName: identity,
+  /**
+   * Check if an attribute must be bound using property, e.g. value
+   * Platform-dependent.
+   */
+  mustUseProp: no,
+  /**
+   * Perform updates asynchronously. Intended to be used by Vue Test Utils
+   * This will significantly reduce performance if set to false.
+   */
+  async: true,
+  /**
+   * Exposed for legacy reasons
+   */
+  _lifecycleHooks: LIFECYCLE_HOOKS
+}
+
+var warn$2 = noop
+var tip = noop
+var generateComponentTrace // work around flow check
+var formatComponentName
+if (process.env.NODE_ENV !== 'production') {
+  var hasConsole_1 = typeof console !== 'undefined'
+  var classifyRE_1 = /(?:^|[-_])(\w)/g
+  var classify_1 = function (str) {
+    return str
+      .replace(classifyRE_1, function (c) {
+        return c.toUpperCase()
+      })
+      .replace(/[-_]/g, '')
+  }
+  warn$2 = function (msg, vm) {
+    var trace = vm ? generateComponentTrace(vm) : ''
+    if (hasConsole_1 && !config.silent) {
+      console.error('[Vue warn]: '.concat(msg).concat(trace))
+    }
+  }
+  tip = function (msg, vm) {
+    if (hasConsole_1 && !config.silent) {
+      console.warn(
+        '[Vue tip]: '.concat(msg) + (vm ? generateComponentTrace(vm) : '')
+      )
+    }
+  }
+  formatComponentName = function (vm, includeFile) {
+    if (vm.$root === vm) {
+      return '<Root>'
+    }
+    var options =
+      typeof vm === 'function' && vm.cid != null
+        ? vm.options
+        : vm._isVue
+        ? vm.$options || vm.constructor.options
+        : vm
+    var name = options.name || options._componentTag
+    var file = options.__file
+    if (!name && file) {
+      var match = file.match(/([^/\\]+)\.vue$/)
+      name = match && match[1]
+    }
+    return (
+      (name ? '<'.concat(classify_1(name), '>') : '<Anonymous>') +
+      (file && includeFile !== false ? ' at '.concat(file) : '')
+    )
+  }
+  var repeat_1 = function (str, n) {
+    var res = ''
+    while (n) {
+      if (n % 2 === 1) res += str
+      if (n > 1) str += str
+      n >>= 1
+    }
+    return res
+  }
+  generateComponentTrace = function (vm) {
+    if (vm._isVue && vm.$parent) {
+      var tree = []
+      var currentRecursiveSequence = 0
+      while (vm) {
+        if (tree.length > 0) {
+          var last = tree[tree.length - 1]
+          if (last.constructor === vm.constructor) {
+            currentRecursiveSequence++
+            vm = vm.$parent
+            continue
+          } else if (currentRecursiveSequence > 0) {
+            tree[tree.length - 1] = [last, currentRecursiveSequence]
+            currentRecursiveSequence = 0
+          }
+        }
+        tree.push(vm)
+        vm = vm.$parent
+      }
+      return (
+        '\n\nfound in\n\n' +
+        tree
+          .map(function (vm, i) {
+            return ''
+              .concat(i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2))
+              .concat(
+                Array.isArray(vm)
+                  ? ''
+                      .concat(formatComponentName(vm[0]), '... (')
+                      .concat(vm[1], ' recursive calls)')
+                  : formatComponentName(vm)
+              )
+          })
+          .join('\n')
+      )
+    } else {
+      return '\n\n(found in '.concat(formatComponentName(vm), ')')
+    }
+  }
+}
+
+var uid = 0
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ */
+var Dep = /** @class */ (function () {
+  function Dep() {
+    this.id = uid++
+    this.subs = []
+  }
+  Dep.prototype.addSub = function (sub) {
+    this.subs.push(sub)
+  }
+  Dep.prototype.removeSub = function (sub) {
+    remove(this.subs, sub)
+  }
+  Dep.prototype.depend = function () {
+    if (Dep.target) {
+      Dep.target.addDep(this)
+    }
+  }
+  Dep.prototype.notify = function () {
+    // stabilize the subscriber list first
+    var subs = this.subs.slice()
+    if (process.env.NODE_ENV !== 'production' && !config.async) {
+      // subs aren't sorted in scheduler if not running async
+      // we need to sort them now to make sure they fire in correct
+      // order
+      subs.sort(function (a, b) {
+        return a.id - b.id
+      })
+    }
+    for (var i = 0, l = subs.length; i < l; i++) {
+      subs[i].update()
+    }
+  }
+  return Dep
+})()
+// The current target watcher being evaluated.
+// This is globally unique because only one watcher
+// can be evaluated at a time.
+Dep.target = null
+
+var VNode = /** @class */ (function () {
+  function VNode(
+    tag,
+    data,
+    children,
+    text,
+    elm,
+    context,
+    componentOptions,
+    asyncFactory
+  ) {
+    this.tag = tag
+    this.data = data
+    this.children = children
+    this.text = text
+    this.elm = elm
+    this.ns = undefined
+    this.context = context
+    this.fnContext = undefined
+    this.fnOptions = undefined
+    this.fnScopeId = undefined
+    this.key = data && data.key
+    this.componentOptions = componentOptions
+    this.componentInstance = undefined
+    this.parent = undefined
+    this.raw = false
+    this.isStatic = false
+    this.isRootInsert = true
+    this.isComment = false
+    this.isCloned = false
+    this.isOnce = false
+    this.asyncFactory = asyncFactory
+    this.asyncMeta = undefined
+    this.isAsyncPlaceholder = false
+  }
+  Object.defineProperty(VNode.prototype, 'child', {
+    // DEPRECATED: alias for componentInstance for backwards compat.
+    /* istanbul ignore next */
+    get: function () {
+      return this.componentInstance
+    },
+    enumerable: false,
+    configurable: true
+  })
+  return VNode
+})()
+
+/*
+ * not type checking this file because flow doesn't play well with
+ * dynamically accessing methods on Array prototype
+ */
+var arrayProto = Array.prototype
+var arrayMethods = Object.create(arrayProto)
+var methodsToPatch = [
+  'push',
+  'pop',
+  'shift',
+  'unshift',
+  'splice',
+  'sort',
+  'reverse'
+]
+/**
+ * Intercept mutating methods and emit events
+ */
+methodsToPatch.forEach(function (method) {
+  // cache original method
+  var original = arrayProto[method]
+  def(arrayMethods, method, function mutator() {
+    var args = []
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i]
+    }
+    var result = original.apply(this, args)
+    var ob = this.__ob__
+    var inserted
+    switch (method) {
+      case 'push':
+      case 'unshift':
+        inserted = args
+        break
+      case 'splice':
+        inserted = args.slice(2)
+        break
+    }
+    if (inserted) ob.observeArray(inserted)
+    // notify change
+    ob.dep.notify()
+    return result
+  })
+})
+
+var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+/**
+ * Observer class that is attached to each observed
+ * object. Once attached, the observer converts the target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatch updates.
+ */
+var Observer = /** @class */ (function () {
+  function Observer(value) {
+    this.value = value
+    this.dep = new Dep()
+    this.vmCount = 0
+    def(value, '__ob__', this)
+    if (Array.isArray(value)) {
+      if (hasProto) {
+        protoAugment(value, arrayMethods)
+      } else {
+        copyAugment(value, arrayMethods, arrayKeys)
+      }
+      this.observeArray(value)
+    } else {
+      this.walk(value)
+    }
+  }
+  /**
+   * Walk through all properties and convert them into
+   * getter/setters. This method should only be called when
+   * value type is Object.
+   */
+  Observer.prototype.walk = function (obj) {
+    var keys = Object.keys(obj)
+    for (var i = 0; i < keys.length; i++) {
+      defineReactive(obj, keys[i])
+    }
+  }
+  /**
+   * Observe a list of Array items.
+   */
+  Observer.prototype.observeArray = function (items) {
+    for (var i = 0, l = items.length; i < l; i++) {
+      observe(items[i])
+    }
+  }
+  return Observer
+})()
+// helpers
+/**
+ * Augment a target Object or Array by intercepting
+ * the prototype chain using __proto__
+ */
+function protoAugment(target, src) {
+  /* eslint-disable no-proto */
+  target.__proto__ = src
+  /* eslint-enable no-proto */
+}
+/**
+ * Augment a target Object or Array by defining
+ * hidden properties.
+ */
+/* istanbul ignore next */
+function copyAugment(target, src, keys) {
+  for (var i = 0, l = keys.length; i < l; i++) {
+    var key = keys[i]
+    def(target, key, src[key])
+  }
+}
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ */
+function observe(value, asRootData) {
+  if (!isObject(value) || value instanceof VNode) {
+    return
+  }
+  var ob
+  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+    ob = value.__ob__
+  } else if (
+    !isServerRendering() &&
+    (Array.isArray(value) || isPlainObject(value)) &&
+    Object.isExtensible(value) &&
+    !value._isVue
+  ) {
+    ob = new Observer(value)
+  }
+  if (asRootData && ob) {
+    ob.vmCount++
+  }
+  return ob
+}
+/**
+ * Define a reactive property on an Object.
+ */
+function defineReactive(obj, key, val, customSetter, shallow) {
+  var dep = new Dep()
+  var property = Object.getOwnPropertyDescriptor(obj, key)
+  if (property && property.configurable === false) {
+    return
+  }
+  // cater for pre-defined getter/setters
+  var getter = property && property.get
+  var setter = property && property.set
+  if ((!getter || setter) && arguments.length === 2) {
+    val = obj[key]
+  }
+  var childOb = !shallow && observe(val)
+  Object.defineProperty(obj, key, {
+    enumerable: true,
+    configurable: true,
+    get: function reactiveGetter() {
+      var value = getter ? getter.call(obj) : val
+      if (Dep.target) {
+        dep.depend()
+        if (childOb) {
+          childOb.dep.depend()
+          if (Array.isArray(value)) {
+            dependArray(value)
+          }
+        }
+      }
+      return value
+    },
+    set: function reactiveSetter(newVal) {
+      var value = getter ? getter.call(obj) : val
+      /* eslint-disable no-self-compare */
+      if (newVal === value || (newVal !== newVal && value !== value)) {
+        return
+      }
+      /* eslint-enable no-self-compare */
+      if (process.env.NODE_ENV !== 'production' && customSetter) {
+        customSetter()
+      }
+      // #7981: for accessor properties without setter
+      if (getter && !setter) return
+      if (setter) {
+        setter.call(obj, newVal)
+      } else {
+        val = newVal
+      }
+      childOb = !shallow && observe(newVal)
+      dep.notify()
+    }
+  })
+}
+/**
+ * Set a property on an object. Adds the new property and
+ * triggers change notification if the property doesn't
+ * already exist.
+ */
+function set(target, key, val) {
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    (isUndef(target) || isPrimitive(target))
+  ) {
+    warn$2(
+      'Cannot set reactive property on undefined, null, or primitive value: '.concat(
+        target
+      )
+    )
+  }
+  if (Array.isArray(target) && isValidArrayIndex(key)) {
+    target.length = Math.max(target.length, key)
+    target.splice(key, 1, val)
+    return val
+  }
+  if (key in target && !(key in Object.prototype)) {
+    target[key] = val
+    return val
+  }
+  var ob = target.__ob__
+  if (target._isVue || (ob && ob.vmCount)) {
+    process.env.NODE_ENV !== 'production' &&
+      warn$2(
+        'Avoid adding reactive properties to a Vue instance or its root $data ' +
+          'at runtime - declare it upfront in the data option.'
+      )
+    return val
+  }
+  if (!ob) {
+    target[key] = val
+    return val
+  }
+  defineReactive(ob.value, key, val)
+  ob.dep.notify()
+  return val
+}
+/**
+ * Collect dependencies on array elements when the array is touched, since
+ * we cannot intercept array element access like property getters.
+ */
+function dependArray(value) {
+  for (var e = void 0, i = 0, l = value.length; i < l; i++) {
+    e = value[i]
+    e && e.__ob__ && e.__ob__.dep.depend()
+    if (Array.isArray(e)) {
+      dependArray(e)
+    }
+  }
+}
+
+/**
+ * Option overwriting strategies are functions that handle
+ * how to merge a parent option value and a child option
+ * value into the final value.
+ */
+var strats = config.optionMergeStrategies
+/**
+ * Options with restrictions
+ */
+if (process.env.NODE_ENV !== 'production') {
+  strats.el = strats.propsData = function (parent, child, vm, key) {
+    if (!vm) {
+      warn$2(
+        'option "'.concat(key, '" can only be used during instance ') +
+          'creation with the `new` keyword.'
+      )
+    }
+    return defaultStrat(parent, child)
+  }
+}
+/**
+ * Helper that recursively merges two data objects together.
+ */
+function mergeData(to, from) {
+  if (!from) return to
+  var key, toVal, fromVal
+  var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from)
+  for (var i = 0; i < keys.length; i++) {
+    key = keys[i]
+    // in case the object is already observed...
+    if (key === '__ob__') continue
+    toVal = to[key]
+    fromVal = from[key]
+    if (!hasOwn(to, key)) {
+      set(to, key, fromVal)
+    } else if (
+      toVal !== fromVal &&
+      isPlainObject(toVal) &&
+      isPlainObject(fromVal)
+    ) {
+      mergeData(toVal, fromVal)
+    }
+  }
+  return to
+}
+/**
+ * Data
+ */
+function mergeDataOrFn(parentVal, childVal, vm) {
+  if (!vm) {
+    // in a Vue.extend merge, both should be functions
+    if (!childVal) {
+      return parentVal
+    }
+    if (!parentVal) {
+      return childVal
+    }
+    // when parentVal & childVal are both present,
+    // we need to return a function that returns the
+    // merged result of both functions... no need to
+    // check if parentVal is a function here because
+    // it has to be a function to pass previous merges.
+    return function mergedDataFn() {
+      return mergeData(
+        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
+        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
+      )
+    }
+  } else {
+    return function mergedInstanceDataFn() {
+      // instance merge
+      var instanceData =
+        typeof childVal === 'function' ? childVal.call(vm, vm) : childVal
+      var defaultData =
+        typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal
+      if (instanceData) {
+        return mergeData(instanceData, defaultData)
+      } else {
+        return defaultData
+      }
+    }
+  }
+}
+strats.data = function (parentVal, childVal, vm) {
+  if (!vm) {
+    if (childVal && typeof childVal !== 'function') {
+      process.env.NODE_ENV !== 'production' &&
+        warn$2(
+          'The "data" option should be a function ' +
+            'that returns a per-instance value in component ' +
+            'definitions.',
+          vm
+        )
+      return parentVal
+    }
+    return mergeDataOrFn(parentVal, childVal)
+  }
+  return mergeDataOrFn(parentVal, childVal, vm)
+}
+/**
+ * Hooks and props are merged as arrays.
+ */
+function mergeHook(parentVal, childVal) {
+  var res = childVal
+    ? parentVal
+      ? parentVal.concat(childVal)
+      : Array.isArray(childVal)
+      ? childVal
+      : [childVal]
+    : parentVal
+  return res ? dedupeHooks(res) : res
+}
+function dedupeHooks(hooks) {
+  var res = []
+  for (var i = 0; i < hooks.length; i++) {
+    if (res.indexOf(hooks[i]) === -1) {
+      res.push(hooks[i])
+    }
+  }
+  return res
+}
+LIFECYCLE_HOOKS.forEach(function (hook) {
+  strats[hook] = mergeHook
+})
+/**
+ * Assets
+ *
+ * When a vm is present (instance creation), we need to do
+ * a three-way merge between constructor options, instance
+ * options and parent options.
+ */
+function mergeAssets(parentVal, childVal, vm, key) {
+  var res = Object.create(parentVal || null)
+  if (childVal) {
+    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm)
+    return extend(res, childVal)
+  } else {
+    return res
+  }
+}
+ASSET_TYPES.forEach(function (type) {
+  strats[type + 's'] = mergeAssets
+})
+/**
+ * Watchers.
+ *
+ * Watchers hashes should not overwrite one
+ * another, so we merge them as arrays.
+ */
+strats.watch = function (parentVal, childVal, vm, key) {
+  // work around Firefox's Object.prototype.watch...
+  //@ts-expect-error work around
+  if (parentVal === nativeWatch) parentVal = undefined
+  //@ts-expect-error work around
+  if (childVal === nativeWatch) childVal = undefined
+  /* istanbul ignore if */
+  if (!childVal) return Object.create(parentVal || null)
+  if (process.env.NODE_ENV !== 'production') {
+    assertObjectType(key, childVal, vm)
+  }
+  if (!parentVal) return childVal
+  var ret = {}
+  extend(ret, parentVal)
+  for (var key_1 in childVal) {
+    var parent_1 = ret[key_1]
+    var child = childVal[key_1]
+    if (parent_1 && !Array.isArray(parent_1)) {
+      parent_1 = [parent_1]
+    }
+    ret[key_1] = parent_1
+      ? parent_1.concat(child)
+      : Array.isArray(child)
+      ? child
+      : [child]
+  }
+  return ret
+}
+/**
+ * Other object hashes.
+ */
+strats.props =
+  strats.methods =
+  strats.inject =
+  strats.computed =
+    function (parentVal, childVal, vm, key) {
+      if (childVal && process.env.NODE_ENV !== 'production') {
+        assertObjectType(key, childVal, vm)
+      }
+      if (!parentVal) return childVal
+      var ret = Object.create(null)
+      extend(ret, parentVal)
+      if (childVal) extend(ret, childVal)
+      return ret
+    }
+strats.provide = mergeDataOrFn
+/**
+ * Default strategy.
+ */
+var defaultStrat = function (parentVal, childVal) {
+  return childVal === undefined ? parentVal : childVal
+}
+function assertObjectType(name, value, vm) {
+  if (!isPlainObject(value)) {
+    warn$2(
+      'Invalid value for option "'.concat(name, '": expected an Object, ') +
+        'but got '.concat(toRawType(value), '.'),
+      vm
+    )
+  }
+}
+
+/* globals MutationObserver */
+var callbacks = []
+function flushCallbacks() {
+  var copies = callbacks.slice(0)
+  callbacks.length = 0
+  for (var i = 0; i < copies.length; i++) {
+    copies[i]()
+  }
+}
+// The nextTick behavior leverages the microtask queue, which can be accessed
+// via either native Promise.then or MutationObserver.
+// MutationObserver has wider support, however it is seriously bugged in
+// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
+// completely stops working after triggering a few times... so, if native
+// Promise is available, we will use it:
+/* istanbul ignore next, $flow-disable-line */
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+  Promise.resolve()
+} else if (
+  !isIE &&
+  typeof MutationObserver !== 'undefined' &&
+  (isNative(MutationObserver) ||
+    // PhantomJS and iOS 7.x
+    MutationObserver.toString() === '[object MutationObserverConstructor]')
+) {
+  // Use MutationObserver where native Promise is not available,
+  // e.g. PhantomJS, iOS7, Android 4.4
+  // (#6466 MutationObserver is unreliable in IE11)
+  var counter_1 = 1
+  var observer = new MutationObserver(flushCallbacks)
+  var textNode_1 = document.createTextNode(String(counter_1))
+  observer.observe(textNode_1, {
+    characterData: true
+  })
+} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate));
+else;
+
+// these are reserved for web because they are directly compiled away
+// during template compilation
+makeMap('style,class')
+// attributes that should be using props for binding
+var acceptValue = makeMap('input,textarea,option,select,progress')
+var mustUseProp = function (tag, type, attr) {
+  return (
+    (attr === 'value' && acceptValue(tag) && type !== 'button') ||
+    (attr === 'selected' && tag === 'option') ||
+    (attr === 'checked' && tag === 'input') ||
+    (attr === 'muted' && tag === 'video')
+  )
+}
+var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
+makeMap('events,caret,typing,plaintext-only')
+var isBooleanAttr = makeMap(
+  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
+    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
+    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
+    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
+    'required,reversed,scoped,seamless,selected,sortable,' +
+    'truespeed,typemustmatch,visible'
+)
+
+var isHTMLTag = makeMap(
+  'html,body,base,head,link,meta,style,title,' +
+    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
+    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
+    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
+    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
+    'embed,object,param,source,canvas,script,noscript,del,ins,' +
+    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
+    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
+    'output,progress,select,textarea,' +
+    'details,dialog,menu,menuitem,summary,' +
+    'content,element,shadow,template,blockquote,iframe,tfoot'
+)
+// this map is intentionally selective, only covering SVG elements that may
+// contain child elements.
+var isSVG = makeMap(
+  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
+    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
+    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
+  true
+)
+var isPreTag = function (tag) {
+  return tag === 'pre'
+}
+var isReservedTag = function (tag) {
+  return isHTMLTag(tag) || isSVG(tag)
+}
+function getTagNamespace(tag) {
+  if (isSVG(tag)) {
+    return 'svg'
+  }
+  // basic support for MathML
+  // note it doesn't support other MathML elements being component roots
+  if (tag === 'math') {
+    return 'math'
+  }
+}
+makeMap('text,number,password,search,email,tel,url')
+
+var validDivisionCharRE = /[\w).+\-_$\]]/
+function parseFilters(exp) {
+  var inSingle = false
+  var inDouble = false
+  var inTemplateString = false
+  var inRegex = false
+  var curly = 0
+  var square = 0
+  var paren = 0
+  var lastFilterIndex = 0
+  var c, prev, i, expression, filters
+  for (i = 0; i < exp.length; i++) {
+    prev = c
+    c = exp.charCodeAt(i)
+    if (inSingle) {
+      if (c === 0x27 && prev !== 0x5c) inSingle = false
+    } else if (inDouble) {
+      if (c === 0x22 && prev !== 0x5c) inDouble = false
+    } else if (inTemplateString) {
+      if (c === 0x60 && prev !== 0x5c) inTemplateString = false
+    } else if (inRegex) {
+      if (c === 0x2f && prev !== 0x5c) inRegex = false
+    } else if (
+      c === 0x7c && // pipe
+      exp.charCodeAt(i + 1) !== 0x7c &&
+      exp.charCodeAt(i - 1) !== 0x7c &&
+      !curly &&
+      !square &&
+      !paren
+    ) {
+      if (expression === undefined) {
+        // first filter, end of expression
+        lastFilterIndex = i + 1
+        expression = exp.slice(0, i).trim()
+      } else {
+        pushFilter()
+      }
+    } else {
+      switch (c) {
+        case 0x22:
+          inDouble = true
+          break // "
+        case 0x27:
+          inSingle = true
+          break // '
+        case 0x60:
+          inTemplateString = true
+          break // `
+        case 0x28:
+          paren++
+          break // (
+        case 0x29:
+          paren--
+          break // )
+        case 0x5b:
+          square++
+          break // [
+        case 0x5d:
+          square--
+          break // ]
+        case 0x7b:
+          curly++
+          break // {
+        case 0x7d:
+          curly--
+          break // }
+      }
+      if (c === 0x2f) {
+        // /
+        var j = i - 1
+        var p =
+          // find first non-whitespace prev char
+          void 0
+        // find first non-whitespace prev char
+        for (; j >= 0; j--) {
+          p = exp.charAt(j)
+          if (p !== ' ') break
+        }
+        if (!p || !validDivisionCharRE.test(p)) {
+          inRegex = true
+        }
+      }
+    }
+  }
+  if (expression === undefined) {
+    expression = exp.slice(0, i).trim()
+  } else if (lastFilterIndex !== 0) {
+    pushFilter()
+  }
+  function pushFilter() {
+    ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
+    lastFilterIndex = i + 1
+  }
+  if (filters) {
+    for (i = 0; i < filters.length; i++) {
+      expression = wrapFilter(expression, filters[i])
+    }
+  }
+  return expression
+}
+function wrapFilter(exp, filter) {
+  var i = filter.indexOf('(')
+  if (i < 0) {
+    // _f: resolveFilter
+    return '_f("'.concat(filter, '")(').concat(exp, ')')
+  } else {
+    var name_1 = filter.slice(0, i)
+    var args = filter.slice(i + 1)
+    return '_f("'
+      .concat(name_1, '")(')
+      .concat(exp)
+      .concat(args !== ')' ? ',' + args : args)
+  }
+}
+
+var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
+var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
+var buildRegex = cached(function (delimiters) {
+  var open = delimiters[0].replace(regexEscapeRE, '\\$&')
+  var close = delimiters[1].replace(regexEscapeRE, '\\$&')
+  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
+})
+function parseText(text, delimiters) {
+  //@ts-expect-error
+  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
+  if (!tagRE.test(text)) {
+    return
+  }
+  var tokens = []
+  var rawTokens = []
+  var lastIndex = (tagRE.lastIndex = 0)
+  var match, index, tokenValue
+  while ((match = tagRE.exec(text))) {
+    index = match.index
+    // push text token
+    if (index > lastIndex) {
+      rawTokens.push((tokenValue = text.slice(lastIndex, index)))
+      tokens.push(JSON.stringify(tokenValue))
+    }
+    // tag token
+    var exp = parseFilters(match[1].trim())
+    tokens.push('_s('.concat(exp, ')'))
+    rawTokens.push({ '@binding': exp })
+    lastIndex = index + match[0].length
+  }
+  if (lastIndex < text.length) {
+    rawTokens.push((tokenValue = text.slice(lastIndex)))
+    tokens.push(JSON.stringify(tokenValue))
+  }
+  return {
+    expression: tokens.join('+'),
+    tokens: rawTokens
+  }
+}
+
+/* eslint-disable no-unused-vars */
+function baseWarn(msg, range) {
+  console.error('[Vue compiler]: '.concat(msg))
+}
+/* eslint-enable no-unused-vars */
+function pluckModuleFunction(modules, key) {
+  return modules
+    ? modules
+        .map(function (m) {
+          return m[key]
+        })
+        .filter(function (_) {
+          return _
+        })
+    : []
+}
+function addProp(el, name, value, range, dynamic) {
+  ;(el.props || (el.props = [])).push(
+    rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
+  )
+  el.plain = false
+}
+function addAttr(el, name, value, range, dynamic) {
+  var attrs = dynamic
+    ? el.dynamicAttrs || (el.dynamicAttrs = [])
+    : el.attrs || (el.attrs = [])
+  attrs.push(
+    rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
+  )
+  el.plain = false
+}
+// add a raw attr (use this in preTransforms)
+function addRawAttr(el, name, value, range) {
+  el.attrsMap[name] = value
+  el.attrsList.push(rangeSetItem({ name: name, value: value }, range))
+}
+function addDirective(
+  el,
+  name,
+  rawName,
+  value,
+  arg,
+  isDynamicArg,
+  modifiers,
+  range
+) {
+  ;(el.directives || (el.directives = [])).push(
+    rangeSetItem(
+      {
+        name: name,
+        rawName: rawName,
+        value: value,
+        arg: arg,
+        isDynamicArg: isDynamicArg,
+        modifiers: modifiers
+      },
+      range
+    )
+  )
+  el.plain = false
+}
+function prependModifierMarker(symbol, name, dynamic) {
+  return dynamic ? '_p('.concat(name, ',"').concat(symbol, '")') : symbol + name // mark the event as captured
+}
+function addHandler(
+  el,
+  name,
+  value,
+  modifiers,
+  important,
+  warn,
+  range,
+  dynamic
+) {
+  modifiers = modifiers || emptyObject
+  // warn prevent and passive modifier
+  /* istanbul ignore if */
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    warn &&
+    modifiers.prevent &&
+    modifiers.passive
+  ) {
+    warn(
+      "passive and prevent can't be used together. " +
+        "Passive handler can't prevent default event.",
+      range
+    )
+  }
+  // normalize click.right and click.middle since they don't actually fire
+  // this is technically browser-specific, but at least for now browsers are
+  // the only target envs that have right/middle clicks.
+  if (modifiers.right) {
+    if (dynamic) {
+      name = '('.concat(name, ")==='click'?'contextmenu':(").concat(name, ')')
+    } else if (name === 'click') {
+      name = 'contextmenu'
+      delete modifiers.right
+    }
+  } else if (modifiers.middle) {
+    if (dynamic) {
+      name = '('.concat(name, ")==='click'?'mouseup':(").concat(name, ')')
+    } else if (name === 'click') {
+      name = 'mouseup'
+    }
+  }
+  // check capture modifier
+  if (modifiers.capture) {
+    delete modifiers.capture
+    name = prependModifierMarker('!', name, dynamic)
+  }
+  if (modifiers.once) {
+    delete modifiers.once
+    name = prependModifierMarker('~', name, dynamic)
+  }
+  /* istanbul ignore if */
+  if (modifiers.passive) {
+    delete modifiers.passive
+    name = prependModifierMarker('&', name, dynamic)
+  }
+  var events
+  if (modifiers.native) {
+    delete modifiers.native
+    events = el.nativeEvents || (el.nativeEvents = {})
+  } else {
+    events = el.events || (el.events = {})
+  }
+  var newHandler = rangeSetItem(
+    { value: value.trim(), dynamic: dynamic },
+    range
+  )
+  if (modifiers !== emptyObject) {
+    newHandler.modifiers = modifiers
+  }
+  var handlers = events[name]
+  /* istanbul ignore if */
+  if (Array.isArray(handlers)) {
+    important ? handlers.unshift(newHandler) : handlers.push(newHandler)
+  } else if (handlers) {
+    events[name] = important ? [newHandler, handlers] : [handlers, newHandler]
+  } else {
+    events[name] = newHandler
+  }
+  el.plain = false
+}
+function getRawBindingAttr(el, name) {
+  return (
+    el.rawAttrsMap[':' + name] ||
+    el.rawAttrsMap['v-bind:' + name] ||
+    el.rawAttrsMap[name]
+  )
+}
+function getBindingAttr(el, name, getStatic) {
+  var dynamicValue =
+    getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
+  if (dynamicValue != null) {
+    return parseFilters(dynamicValue)
+  } else if (getStatic !== false) {
+    var staticValue = getAndRemoveAttr(el, name)
+    if (staticValue != null) {
+      return JSON.stringify(staticValue)
+    }
+  }
+}
+// note: this only removes the attr from the Array (attrsList) so that it
+// doesn't get processed by processAttrs.
+// By default it does NOT remove it from the map (attrsMap) because the map is
+// needed during codegen.
+function getAndRemoveAttr(el, name, removeFromMap) {
+  var val
+  if ((val = el.attrsMap[name]) != null) {
+    var list = el.attrsList
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (list[i].name === name) {
+        list.splice(i, 1)
+        break
+      }
+    }
+  }
+  if (removeFromMap) {
+    delete el.attrsMap[name]
+  }
+  return val
+}
+function getAndRemoveAttrByRegex(el, name) {
+  var list = el.attrsList
+  for (var i = 0, l = list.length; i < l; i++) {
+    var attr = list[i]
+    if (name.test(attr.name)) {
+      list.splice(i, 1)
+      return attr
+    }
+  }
+}
+function rangeSetItem(item, range) {
+  if (range) {
+    if (range.start != null) {
+      item.start = range.start
+    }
+    if (range.end != null) {
+      item.end = range.end
+    }
+  }
+  return item
+}
+
+function transformNode$1(el, options) {
+  var warn = options.warn || baseWarn
+  var staticClass = getAndRemoveAttr(el, 'class')
+  if (process.env.NODE_ENV !== 'production' && staticClass) {
+    var res = parseText(staticClass, options.delimiters)
+    if (res) {
+      warn(
+        'class="'.concat(staticClass, '": ') +
+          'Interpolation inside attributes has been removed. ' +
+          'Use v-bind or the colon shorthand instead. For example, ' +
+          'instead of <div class="{{ val }}">, use <div :class="val">.',
+        el.rawAttrsMap['class']
+      )
+    }
+  }
+  if (staticClass) {
+    el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim())
+  }
+  var classBinding = getBindingAttr(el, 'class', false /* getStatic */)
+  if (classBinding) {
+    el.classBinding = classBinding
+  }
+}
+function genData$2(el) {
+  var data = ''
+  if (el.staticClass) {
+    data += 'staticClass:'.concat(el.staticClass, ',')
+  }
+  if (el.classBinding) {
+    data += 'class:'.concat(el.classBinding, ',')
+  }
+  return data
+}
+var klass = {
+  staticKeys: ['staticClass'],
+  transformNode: transformNode$1,
+  genData: genData$2
+}
+
+var parseStyleText = cached(function (cssText) {
+  var res = {}
+  var listDelimiter = /;(?![^(]*\))/g
+  var propertyDelimiter = /:(.+)/
+  cssText.split(listDelimiter).forEach(function (item) {
+    if (item) {
+      var tmp = item.split(propertyDelimiter)
+      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim())
+    }
+  })
+  return res
+})
+
+function transformNode(el, options) {
+  var warn = options.warn || baseWarn
+  var staticStyle = getAndRemoveAttr(el, 'style')
+  if (staticStyle) {
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production') {
+      var res = parseText(staticStyle, options.delimiters)
+      if (res) {
+        warn(
+          'style="'.concat(staticStyle, '": ') +
+            'Interpolation inside attributes has been removed. ' +
+            'Use v-bind or the colon shorthand instead. For example, ' +
+            'instead of <div style="{{ val }}">, use <div :style="val">.',
+          el.rawAttrsMap['style']
+        )
+      }
+    }
+    el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
+  }
+  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
+  if (styleBinding) {
+    el.styleBinding = styleBinding
+  }
+}
+function genData$1(el) {
+  var data = ''
+  if (el.staticStyle) {
+    data += 'staticStyle:'.concat(el.staticStyle, ',')
+  }
+  if (el.styleBinding) {
+    data += 'style:('.concat(el.styleBinding, '),')
+  }
+  return data
+}
+var style = {
+  staticKeys: ['staticStyle'],
+  transformNode: transformNode,
+  genData: genData$1
+}
+
+/**
+ * Cross-platform code generation for component v-model
+ */
+function genComponentModel(el, value, modifiers) {
+  var _a = modifiers || {},
+    number = _a.number,
+    trim = _a.trim
+  var baseValueExpression = '$$v'
+  var valueExpression = baseValueExpression
+  if (trim) {
+    valueExpression =
+      '(typeof '.concat(baseValueExpression, " === 'string'") +
+      '? '.concat(baseValueExpression, '.trim()') +
+      ': '.concat(baseValueExpression, ')')
+  }
+  if (number) {
+    valueExpression = '_n('.concat(valueExpression, ')')
+  }
+  var assignment = genAssignmentCode(value, valueExpression)
+  el.model = {
+    value: '('.concat(value, ')'),
+    expression: JSON.stringify(value),
+    callback: 'function ('
+      .concat(baseValueExpression, ') {')
+      .concat(assignment, '}')
+  }
+}
+/**
+ * Cross-platform codegen helper for generating v-model value assignment code.
+ */
+function genAssignmentCode(value, assignment) {
+  var res = parseModel(value)
+  if (res.key === null) {
+    return ''.concat(value, '=').concat(assignment)
+  } else {
+    return '$set('
+      .concat(res.exp, ', ')
+      .concat(res.key, ', ')
+      .concat(assignment, ')')
+  }
+}
+/**
+ * Parse a v-model expression into a base path and a final key segment.
+ * Handles both dot-path and possible square brackets.
+ *
+ * Possible cases:
+ *
+ * - test
+ * - test[key]
+ * - test[test1[key]]
+ * - test["a"][key]
+ * - xxx.test[a[a].test1[key]]
+ * - test.xxx.a["asa"][test1[key]]
+ *
+ */
+var len, str, chr, index, expressionPos, expressionEndPos
+function parseModel(val) {
+  // Fix https://github.com/vuejs/vue/pull/7730
+  // allow v-model="obj.val " (trailing whitespace)
+  val = val.trim()
+  len = val.length
+  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
+    index = val.lastIndexOf('.')
+    if (index > -1) {
+      return {
+        exp: val.slice(0, index),
+        key: '"' + val.slice(index + 1) + '"'
+      }
+    } else {
+      return {
+        exp: val,
+        key: null
+      }
+    }
+  }
+  str = val
+  index = expressionPos = expressionEndPos = 0
+  while (!eof()) {
+    chr = next()
+    /* istanbul ignore if */
+    if (isStringStart(chr)) {
+      parseString(chr)
+    } else if (chr === 0x5b) {
+      parseBracket(chr)
+    }
+  }
+  return {
+    exp: val.slice(0, expressionPos),
+    key: val.slice(expressionPos + 1, expressionEndPos)
+  }
+}
+function next() {
+  return str.charCodeAt(++index)
+}
+function eof() {
+  return index >= len
+}
+function isStringStart(chr) {
+  return chr === 0x22 || chr === 0x27
+}
+function parseBracket(chr) {
+  var inBracket = 1
+  expressionPos = index
+  while (!eof()) {
+    chr = next()
+    if (isStringStart(chr)) {
+      parseString(chr)
+      continue
+    }
+    if (chr === 0x5b) inBracket++
+    if (chr === 0x5d) inBracket--
+    if (inBracket === 0) {
+      expressionEndPos = index
+      break
+    }
+  }
+}
+function parseString(chr) {
+  var stringQuote = chr
+  while (!eof()) {
+    chr = next()
+    if (chr === stringQuote) {
+      break
+    }
+  }
+}
+
+var onRE = /^@|^v-on:/
+var dirRE = /^v-|^@|^:|^#/
+var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
+var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/
+var stripParensRE = /^\(|\)$/g
+var dynamicArgRE = /^\[.*\]$/
+var argRE = /:(.*)$/
+var bindRE = /^:|^\.|^v-bind:/
+var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
+var slotRE = /^v-slot(:|$)|^#/
+var lineBreakRE = /[\r\n]/
+var whitespaceRE = /[ \f\t\r\n]+/g
+var invalidAttributeRE = /[\s"'<>\/=]/
+var decodeHTMLCached = cached(he__default['default'].decode)
+var emptySlotScopeToken = '_empty_'
+// configurable state
+var warn$1
+var delimiters
+var transforms
+var preTransforms
+var postTransforms
+var platformIsPreTag
+var platformMustUseProp
+var platformGetTagNamespace
+var maybeComponent
+function createASTElement(tag, attrs, parent) {
+  return {
+    type: 1,
+    tag: tag,
+    attrsList: attrs,
+    attrsMap: makeAttrsMap(attrs),
+    rawAttrsMap: {},
+    parent: parent,
+    children: []
+  }
+}
+/**
+ * Convert HTML string to AST.
+ */
+function parse(template, options) {
+  warn$1 = options.warn || baseWarn
+  platformIsPreTag = options.isPreTag || no
+  platformMustUseProp = options.mustUseProp || no
+  platformGetTagNamespace = options.getTagNamespace || no
+  var isReservedTag = options.isReservedTag || no
+  maybeComponent = function (el) {
+    return !!(
+      el.component ||
+      el.attrsMap[':is'] ||
+      el.attrsMap['v-bind:is'] ||
+      !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
+    )
+  }
+  transforms = pluckModuleFunction(options.modules, 'transformNode')
+  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
+  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
+  delimiters = options.delimiters
+  var stack = []
+  var preserveWhitespace = options.preserveWhitespace !== false
+  var whitespaceOption = options.whitespace
+  var root
+  var currentParent
+  var inVPre = false
+  var inPre = false
+  var warned = false
+  function warnOnce(msg, range) {
+    if (!warned) {
+      warned = true
+      warn$1(msg, range)
+    }
+  }
+  function closeElement(element) {
+    trimEndingWhitespace(element)
+    if (!inVPre && !element.processed) {
+      element = processElement(element, options)
+    }
+    // tree management
+    if (!stack.length && element !== root) {
+      // allow root elements with v-if, v-else-if and v-else
+      if (root.if && (element.elseif || element.else)) {
+        if (process.env.NODE_ENV !== 'production') {
+          checkRootConstraints(element)
+        }
+        addIfCondition(root, {
+          exp: element.elseif,
+          block: element
+        })
+      } else if (process.env.NODE_ENV !== 'production') {
+        warnOnce(
+          'Component template should contain exactly one root element. ' +
+            'If you are using v-if on multiple elements, ' +
+            'use v-else-if to chain them instead.',
+          { start: element.start }
+        )
+      }
+    }
+    if (currentParent && !element.forbidden) {
+      if (element.elseif || element.else) {
+        processIfConditions(element, currentParent)
+      } else {
+        if (element.slotScope) {
+          // scoped slot
+          // keep it in the children list so that v-else(-if) conditions can
+          // find it as the prev node.
+          var name_1 = element.slotTarget || '"default"'
+          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[
+            name_1
+          ] = element
+        }
+        currentParent.children.push(element)
+        element.parent = currentParent
+      }
+    }
+    // final children cleanup
+    // filter out scoped slots
+    element.children = element.children.filter(function (c) {
+      return !c.slotScope
+    })
+    // remove trailing whitespace node again
+    trimEndingWhitespace(element)
+    // check pre state
+    if (element.pre) {
+      inVPre = false
+    }
+    if (platformIsPreTag(element.tag)) {
+      inPre = false
+    }
+    // apply post-transforms
+    for (var i = 0; i < postTransforms.length; i++) {
+      postTransforms[i](element, options)
+    }
+  }
+  function trimEndingWhitespace(el) {
+    // remove trailing whitespace node
+    if (!inPre) {
+      var lastNode = void 0
+      while (
+        (lastNode = el.children[el.children.length - 1]) &&
+        lastNode.type === 3 &&
+        lastNode.text === ' '
+      ) {
+        el.children.pop()
+      }
+    }
+  }
+  function checkRootConstraints(el) {
+    if (el.tag === 'slot' || el.tag === 'template') {
+      warnOnce(
+        'Cannot use <'.concat(
+          el.tag,
+          '> as component root element because it may '
+        ) + 'contain multiple nodes.',
+        { start: el.start }
+      )
+    }
+    if (el.attrsMap.hasOwnProperty('v-for')) {
+      warnOnce(
+        'Cannot use v-for on stateful component root element because ' +
+          'it renders multiple elements.',
+        el.rawAttrsMap['v-for']
+      )
+    }
+  }
+  parseHTML(template, {
+    warn: warn$1,
+    expectHTML: options.expectHTML,
+    isUnaryTag: options.isUnaryTag,
+    canBeLeftOpenTag: options.canBeLeftOpenTag,
+    shouldDecodeNewlines: options.shouldDecodeNewlines,
+    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
+    shouldKeepComment: options.comments,
+    outputSourceRange: options.outputSourceRange,
+    start: function (tag, attrs, unary, start, end) {
+      // check namespace.
+      // inherit parent ns if there is one
+      var ns =
+        (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
+      // handle IE svg bug
+      /* istanbul ignore if */
+      if (isIE && ns === 'svg') {
+        attrs = guardIESVGBug(attrs)
+      }
+      var element = createASTElement(tag, attrs, currentParent)
+      if (ns) {
+        element.ns = ns
+      }
+      if (process.env.NODE_ENV !== 'production') {
+        if (options.outputSourceRange) {
+          element.start = start
+          element.end = end
+          element.rawAttrsMap = element.attrsList.reduce(function (
+            cumulated,
+            attr
+          ) {
+            cumulated[attr.name] = attr
+            return cumulated
+          },
+          {})
+        }
+        attrs.forEach(function (attr) {
+          if (invalidAttributeRE.test(attr.name)) {
+            warn$1(
+              'Invalid dynamic argument expression: attribute names cannot contain ' +
+                'spaces, quotes, <, >, / or =.',
+              {
+                start: attr.start + attr.name.indexOf('['),
+                end: attr.start + attr.name.length
+              }
+            )
+          }
+        })
+      }
+      if (isForbiddenTag(element) && !isServerRendering()) {
+        element.forbidden = true
+        process.env.NODE_ENV !== 'production' &&
+          warn$1(
+            'Templates should only be responsible for mapping the state to the ' +
+              'UI. Avoid placing tags with side-effects in your templates, such as ' +
+              '<'.concat(tag, '>') +
+              ', as they will not be parsed.',
+            { start: element.start }
+          )
+      }
+      // apply pre-transforms
+      for (var i = 0; i < preTransforms.length; i++) {
+        element = preTransforms[i](element, options) || element
+      }
+      if (!inVPre) {
+        processPre(element)
+        if (element.pre) {
+          inVPre = true
+        }
+      }
+      if (platformIsPreTag(element.tag)) {
+        inPre = true
+      }
+      if (inVPre) {
+        processRawAttrs(element)
+      } else if (!element.processed) {
+        // structural directives
+        processFor(element)
+        processIf(element)
+        processOnce(element)
+      }
+      if (!root) {
+        root = element
+        if (process.env.NODE_ENV !== 'production') {
+          checkRootConstraints(root)
+        }
+      }
+      if (!unary) {
+        currentParent = element
+        stack.push(element)
+      } else {
+        closeElement(element)
+      }
+    },
+    end: function (tag, start, end) {
+      var element = stack[stack.length - 1]
+      // pop stack
+      stack.length -= 1
+      currentParent = stack[stack.length - 1]
+      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
+        element.end = end
+      }
+      closeElement(element)
+    },
+    chars: function (text, start, end) {
+      if (!currentParent) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (text === template) {
+            warnOnce(
+              'Component template requires a root element, rather than just text.',
+              { start: start }
+            )
+          } else if ((text = text.trim())) {
+            warnOnce(
+              'text "'.concat(text, '" outside root element will be ignored.'),
+              {
+                start: start
+              }
+            )
+          }
+        }
+        return
+      }
+      // IE textarea placeholder bug
+      /* istanbul ignore if */
+      if (
+        isIE &&
+        currentParent.tag === 'textarea' &&
+        currentParent.attrsMap.placeholder === text
+      ) {
+        return
+      }
+      var children = currentParent.children
+      if (inPre || text.trim()) {
+        text = isTextTag(currentParent) ? text : decodeHTMLCached(text)
+      } else if (!children.length) {
+        // remove the whitespace-only node right after an opening tag
+        text = ''
+      } else if (whitespaceOption) {
+        if (whitespaceOption === 'condense') {
+          // in condense mode, remove the whitespace node if it contains
+          // line break, otherwise condense to a single space
+          text = lineBreakRE.test(text) ? '' : ' '
+        } else {
+          text = ' '
+        }
+      } else {
+        text = preserveWhitespace ? ' ' : ''
+      }
+      if (text) {
+        if (!inPre && whitespaceOption === 'condense') {
+          // condense consecutive whitespaces into single space
+          text = text.replace(whitespaceRE, ' ')
+        }
+        var res = void 0
+        var child = void 0
+        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
+          child = {
+            type: 2,
+            expression: res.expression,
+            tokens: res.tokens,
+            text: text
+          }
+        } else if (
+          text !== ' ' ||
+          !children.length ||
+          children[children.length - 1].text !== ' '
+        ) {
+          child = {
+            type: 3,
+            text: text
+          }
+        }
+        if (child) {
+          if (
+            process.env.NODE_ENV !== 'production' &&
+            options.outputSourceRange
+          ) {
+            child.start = start
+            child.end = end
+          }
+          children.push(child)
+        }
+      }
+    },
+    comment: function (text, start, end) {
+      // adding anything as a sibling to the root node is forbidden
+      // comments should still be allowed, but ignored
+      if (currentParent) {
+        var child = {
+          type: 3,
+          text: text,
+          isComment: true
+        }
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          options.outputSourceRange
+        ) {
+          child.start = start
+          child.end = end
+        }
+        currentParent.children.push(child)
+      }
+    }
+  })
+  return root
+}
+function processPre(el) {
+  if (getAndRemoveAttr(el, 'v-pre') != null) {
+    el.pre = true
+  }
+}
+function processRawAttrs(el) {
+  var list = el.attrsList
+  var len = list.length
+  if (len) {
+    var attrs = (el.attrs = new Array(len))
+    for (var i = 0; i < len; i++) {
+      attrs[i] = {
+        name: list[i].name,
+        value: JSON.stringify(list[i].value)
+      }
+      if (list[i].start != null) {
+        attrs[i].start = list[i].start
+        attrs[i].end = list[i].end
+      }
+    }
+  } else if (!el.pre) {
+    // non root node in pre blocks with no attributes
+    el.plain = true
+  }
+}
+function processElement(element, options) {
+  processKey(element)
+  // determine whether this is a plain element after
+  // removing structural attributes
+  element.plain =
+    !element.key && !element.scopedSlots && !element.attrsList.length
+  processRef(element)
+  processSlotContent(element)
+  processSlotOutlet(element)
+  processComponent(element)
+  for (var i = 0; i < transforms.length; i++) {
+    element = transforms[i](element, options) || element
+  }
+  processAttrs(element)
+  return element
+}
+function processKey(el) {
+  var exp = getBindingAttr(el, 'key')
+  if (exp) {
+    if (process.env.NODE_ENV !== 'production') {
+      if (el.tag === 'template') {
+        warn$1(
+          '<template> cannot be keyed. Place the key on real elements instead.',
+          getRawBindingAttr(el, 'key')
+        )
+      }
+      if (el.for) {
+        var iterator = el.iterator2 || el.iterator1
+        var parent_1 = el.parent
+        if (
+          iterator &&
+          iterator === exp &&
+          parent_1 &&
+          parent_1.tag === 'transition-group'
+        ) {
+          warn$1(
+            'Do not use v-for index as key on <transition-group> children, ' +
+              'this is the same as not using keys.',
+            getRawBindingAttr(el, 'key'),
+            true /* tip */
+          )
+        }
+      }
+    }
+    el.key = exp
+  }
+}
+function processRef(el) {
+  var ref = getBindingAttr(el, 'ref')
+  if (ref) {
+    el.ref = ref
+    el.refInFor = checkInFor(el)
+  }
+}
+function processFor(el) {
+  var exp
+  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
+    var res = parseFor(exp)
+    if (res) {
+      extend(el, res)
+    } else if (process.env.NODE_ENV !== 'production') {
+      warn$1('Invalid v-for expression: '.concat(exp), el.rawAttrsMap['v-for'])
+    }
+  }
+}
+function parseFor(exp) {
+  var inMatch = exp.match(forAliasRE)
+  if (!inMatch) return
+  var res = {}
+  res.for = inMatch[2].trim()
+  var alias = inMatch[1].trim().replace(stripParensRE, '')
+  var iteratorMatch = alias.match(forIteratorRE)
+  if (iteratorMatch) {
+    res.alias = alias.replace(forIteratorRE, '').trim()
+    res.iterator1 = iteratorMatch[1].trim()
+    if (iteratorMatch[2]) {
+      res.iterator2 = iteratorMatch[2].trim()
+    }
+  } else {
+    res.alias = alias
+  }
+  return res
+}
+function processIf(el) {
+  var exp = getAndRemoveAttr(el, 'v-if')
+  if (exp) {
+    el.if = exp
+    addIfCondition(el, {
+      exp: exp,
+      block: el
+    })
+  } else {
+    if (getAndRemoveAttr(el, 'v-else') != null) {
+      el.else = true
+    }
+    var elseif = getAndRemoveAttr(el, 'v-else-if')
+    if (elseif) {
+      el.elseif = elseif
+    }
+  }
+}
+function processIfConditions(el, parent) {
+  var prev = findPrevElement(parent.children)
+  if (prev && prev.if) {
+    addIfCondition(prev, {
+      exp: el.elseif,
+      block: el
+    })
+  } else if (process.env.NODE_ENV !== 'production') {
+    warn$1(
+      'v-'.concat(el.elseif ? 'else-if="' + el.elseif + '"' : 'else', ' ') +
+        'used on element <'.concat(el.tag, '> without corresponding v-if.'),
+      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
+    )
+  }
+}
+function findPrevElement(children) {
+  var i = children.length
+  while (i--) {
+    if (children[i].type === 1) {
+      return children[i]
+    } else {
+      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
+        warn$1(
+          'text "'.concat(
+            children[i].text.trim(),
+            '" between v-if and v-else(-if) '
+          ) + 'will be ignored.',
+          children[i]
+        )
+      }
+      children.pop()
+    }
+  }
+}
+function addIfCondition(el, condition) {
+  if (!el.ifConditions) {
+    el.ifConditions = []
+  }
+  el.ifConditions.push(condition)
+}
+function processOnce(el) {
+  var once = getAndRemoveAttr(el, 'v-once')
+  if (once != null) {
+    el.once = true
+  }
+}
+// handle content being passed to a component as slot,
+// e.g. <template slot="xxx">, <div slot-scope="xxx">
+function processSlotContent(el) {
+  var slotScope
+  if (el.tag === 'template') {
+    slotScope = getAndRemoveAttr(el, 'scope')
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' && slotScope) {
+      warn$1(
+        'the "scope" attribute for scoped slots have been deprecated and ' +
+          'replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ' +
+          'can also be used on plain elements in addition to <template> to ' +
+          'denote scoped slots.',
+        el.rawAttrsMap['scope'],
+        true
+      )
+    }
+    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
+  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
+      warn$1(
+        'Ambiguous combined usage of slot-scope and v-for on <'.concat(
+          el.tag,
+          '> '
+        ) +
+          '(v-for takes higher priority). Use a wrapper <template> for the ' +
+          'scoped slot to make it clearer.',
+        el.rawAttrsMap['slot-scope'],
+        true
+      )
+    }
+    el.slotScope = slotScope
+  }
+  // slot="xxx"
+  var slotTarget = getBindingAttr(el, 'slot')
+  if (slotTarget) {
+    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
+    el.slotTargetDynamic = !!(
+      el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']
+    )
+    // preserve slot as an attribute for native shadow DOM compat
+    // only for non-scoped slots.
+    if (el.tag !== 'template' && !el.slotScope) {
+      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'))
+    }
+  }
+  // 2.6 v-slot syntax
+  {
+    if (el.tag === 'template') {
+      // v-slot on <template>
+      var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
+      if (slotBinding) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (el.slotTarget || el.slotScope) {
+            warn$1('Unexpected mixed usage of different slot syntaxes.', el)
+          }
+          if (el.parent && !maybeComponent(el.parent)) {
+            warn$1(
+              '<template v-slot> can only appear at the root level inside ' +
+                'the receiving component',
+              el
+            )
+          }
+        }
+        var _a = getSlotName(slotBinding),
+          name_2 = _a.name,
+          dynamic = _a.dynamic
+        el.slotTarget = name_2
+        el.slotTargetDynamic = dynamic
+        el.slotScope = slotBinding.value || emptySlotScopeToken // force it into a scoped slot for perf
+      }
+    } else {
+      // v-slot on component, denotes default slot
+      var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
+      if (slotBinding) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (!maybeComponent(el)) {
+            warn$1(
+              'v-slot can only be used on components or <template>.',
+              slotBinding
+            )
+          }
+          if (el.slotScope || el.slotTarget) {
+            warn$1('Unexpected mixed usage of different slot syntaxes.', el)
+          }
+          if (el.scopedSlots) {
+            warn$1(
+              'To avoid scope ambiguity, the default slot should also use ' +
+                '<template> syntax when there are other named slots.',
+              slotBinding
+            )
+          }
+        }
+        // add the component's children to its default slot
+        var slots = el.scopedSlots || (el.scopedSlots = {})
+        var _b = getSlotName(slotBinding),
+          name_3 = _b.name,
+          dynamic = _b.dynamic
+        var slotContainer_1 = (slots[name_3] = createASTElement(
+          'template',
+          [],
+          el
+        ))
+        slotContainer_1.slotTarget = name_3
+        slotContainer_1.slotTargetDynamic = dynamic
+        slotContainer_1.children = el.children.filter(function (c) {
+          if (!c.slotScope) {
+            c.parent = slotContainer_1
+            return true
+          }
+        })
+        slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken
+        // remove children as they are returned from scopedSlots now
+        el.children = []
+        // mark el non-plain so data gets generated
+        el.plain = false
+      }
+    }
+  }
+}
+function getSlotName(binding) {
+  var name = binding.name.replace(slotRE, '')
+  if (!name) {
+    if (binding.name[0] !== '#') {
+      name = 'default'
+    } else if (process.env.NODE_ENV !== 'production') {
+      warn$1('v-slot shorthand syntax requires a slot name.', binding)
+    }
+  }
+  return dynamicArgRE.test(name)
+    ? // dynamic [name]
+      { name: name.slice(1, -1), dynamic: true }
+    : // static name
+      { name: '"'.concat(name, '"'), dynamic: false }
+}
+// handle <slot/> outlets
+function processSlotOutlet(el) {
+  if (el.tag === 'slot') {
+    el.slotName = getBindingAttr(el, 'name')
+    if (process.env.NODE_ENV !== 'production' && el.key) {
+      warn$1(
+        '`key` does not work on <slot> because slots are abstract outlets ' +
+          'and can possibly expand into multiple elements. ' +
+          'Use the key on a wrapping element instead.',
+        getRawBindingAttr(el, 'key')
+      )
+    }
+  }
+}
+function processComponent(el) {
+  var binding
+  if ((binding = getBindingAttr(el, 'is'))) {
+    el.component = binding
+  }
+  if (getAndRemoveAttr(el, 'inline-template') != null) {
+    el.inlineTemplate = true
+  }
+}
+function processAttrs(el) {
+  var list = el.attrsList
+  var i, l, name, rawName, value, modifiers, syncGen, isDynamic
+  for (i = 0, l = list.length; i < l; i++) {
+    name = rawName = list[i].name
+    value = list[i].value
+    if (dirRE.test(name)) {
+      // mark element as dynamic
+      el.hasBindings = true
+      // modifiers
+      modifiers = parseModifiers(name.replace(dirRE, ''))
+      // support .foo shorthand syntax for the .prop modifier
+      if (modifiers) {
+        name = name.replace(modifierRE, '')
+      }
+      if (bindRE.test(name)) {
+        // v-bind
+        name = name.replace(bindRE, '')
+        value = parseFilters(value)
+        isDynamic = dynamicArgRE.test(name)
+        if (isDynamic) {
+          name = name.slice(1, -1)
+        }
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          value.trim().length === 0
+        ) {
+          warn$1(
+            'The value for a v-bind expression cannot be empty. Found in "v-bind:'.concat(
+              name,
+              '"'
+            )
+          )
+        }
+        if (modifiers) {
+          if (modifiers.prop && !isDynamic) {
+            name = camelize(name)
+            if (name === 'innerHtml') name = 'innerHTML'
+          }
+          if (modifiers.camel && !isDynamic) {
+            name = camelize(name)
+          }
+          if (modifiers.sync) {
+            syncGen = genAssignmentCode(value, '$event')
+            if (!isDynamic) {
+              addHandler(
+                el,
+                'update:'.concat(camelize(name)),
+                syncGen,
+                null,
+                false,
+                warn$1,
+                list[i]
+              )
+              if (hyphenate(name) !== camelize(name)) {
+                addHandler(
+                  el,
+                  'update:'.concat(hyphenate(name)),
+                  syncGen,
+                  null,
+                  false,
+                  warn$1,
+                  list[i]
+                )
+              }
+            } else {
+              // handler w/ dynamic event name
+              addHandler(
+                el,
+                '"update:"+('.concat(name, ')'),
+                syncGen,
+                null,
+                false,
+                warn$1,
+                list[i],
+                true // dynamic
+              )
+            }
+          }
+        }
+        if (
+          (modifiers && modifiers.prop) ||
+          (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))
+        ) {
+          addProp(el, name, value, list[i], isDynamic)
+        } else {
+          addAttr(el, name, value, list[i], isDynamic)
+        }
+      } else if (onRE.test(name)) {
+        // v-on
+        name = name.replace(onRE, '')
+        isDynamic = dynamicArgRE.test(name)
+        if (isDynamic) {
+          name = name.slice(1, -1)
+        }
+        addHandler(
+          el,
+          name,
+          value,
+          modifiers,
+          false,
+          warn$1,
+          list[i],
+          isDynamic
+        )
+      } else {
+        // normal directives
+        name = name.replace(dirRE, '')
+        // parse arg
+        var argMatch = name.match(argRE)
+        var arg = argMatch && argMatch[1]
+        isDynamic = false
+        if (arg) {
+          name = name.slice(0, -(arg.length + 1))
+          if (dynamicArgRE.test(arg)) {
+            arg = arg.slice(1, -1)
+            isDynamic = true
+          }
+        }
+        addDirective(
+          el,
+          name,
+          rawName,
+          value,
+          arg,
+          isDynamic,
+          modifiers,
+          list[i]
+        )
+        if (process.env.NODE_ENV !== 'production' && name === 'model') {
+          checkForAliasModel(el, value)
+        }
+      }
+    } else {
+      // literal attribute
+      if (process.env.NODE_ENV !== 'production') {
+        var res = parseText(value, delimiters)
+        if (res) {
+          warn$1(
+            ''.concat(name, '="').concat(value, '": ') +
+              'Interpolation inside attributes has been removed. ' +
+              'Use v-bind or the colon shorthand instead. For example, ' +
+              'instead of <div id="{{ val }}">, use <div :id="val">.',
+            list[i]
+          )
+        }
+      }
+      addAttr(el, name, JSON.stringify(value), list[i])
+      // #6887 firefox doesn't update muted state if set via attribute
+      // even immediately after element creation
+      if (
+        !el.component &&
+        name === 'muted' &&
+        platformMustUseProp(el.tag, el.attrsMap.type, name)
+      ) {
+        addProp(el, name, 'true', list[i])
+      }
+    }
+  }
+}
+function checkInFor(el) {
+  var parent = el
+  while (parent) {
+    if (parent.for !== undefined) {
+      return true
+    }
+    parent = parent.parent
+  }
+  return false
+}
+function parseModifiers(name) {
+  var match = name.match(modifierRE)
+  if (match) {
+    var ret_1 = {}
+    match.forEach(function (m) {
+      ret_1[m.slice(1)] = true
+    })
+    return ret_1
+  }
+}
+function makeAttrsMap(attrs) {
+  var map = {}
+  for (var i = 0, l = attrs.length; i < l; i++) {
+    if (
+      process.env.NODE_ENV !== 'production' &&
+      map[attrs[i].name] &&
+      !isIE &&
+      !isEdge
+    ) {
+      warn$1('duplicate attribute: ' + attrs[i].name, attrs[i])
+    }
+    map[attrs[i].name] = attrs[i].value
+  }
+  return map
+}
+// for script (e.g. type="x/template") or style, do not decode content
+function isTextTag(el) {
+  return el.tag === 'script' || el.tag === 'style'
+}
+function isForbiddenTag(el) {
+  return (
+    el.tag === 'style' ||
+    (el.tag === 'script' &&
+      (!el.attrsMap.type || el.attrsMap.type === 'text/javascript'))
+  )
+}
+var ieNSBug = /^xmlns:NS\d+/
+var ieNSPrefix = /^NS\d+:/
+/* istanbul ignore next */
+function guardIESVGBug(attrs) {
+  var res = []
+  for (var i = 0; i < attrs.length; i++) {
+    var attr = attrs[i]
+    if (!ieNSBug.test(attr.name)) {
+      attr.name = attr.name.replace(ieNSPrefix, '')
+      res.push(attr)
+    }
+  }
+  return res
+}
+function checkForAliasModel(el, value) {
+  var _el = el
+  while (_el) {
+    if (_el.for && _el.alias === value) {
+      warn$1(
+        '<'.concat(el.tag, ' v-model="').concat(value, '">: ') +
+          'You are binding v-model directly to a v-for iteration alias. ' +
+          'This will not be able to modify the v-for source array because ' +
+          'writing to the alias is like modifying a function local variable. ' +
+          'Consider using an array of objects and use v-model on an object property instead.',
+        el.rawAttrsMap['v-model']
+      )
+    }
+    _el = _el.parent
+  }
+}
+
+/**
+ * Expand input[v-model] with dynamic type bindings into v-if-else chains
+ * Turn this:
+ *   <input v-model="data[type]" :type="type">
+ * into this:
+ *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
+ *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
+ *   <input v-else :type="type" v-model="data[type]">
+ */
+function preTransformNode(el, options) {
+  if (el.tag === 'input') {
+    var map = el.attrsMap
+    if (!map['v-model']) {
+      return
+    }
+    var typeBinding = void 0
+    if (map[':type'] || map['v-bind:type']) {
+      typeBinding = getBindingAttr(el, 'type')
+    }
+    if (!map.type && !typeBinding && map['v-bind']) {
+      typeBinding = '('.concat(map['v-bind'], ').type')
+    }
+    if (typeBinding) {
+      var ifCondition = getAndRemoveAttr(el, 'v-if', true)
+      var ifConditionExtra = ifCondition ? '&&('.concat(ifCondition, ')') : ''
+      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null
+      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
+      // 1. checkbox
+      var branch0 = cloneASTElement(el)
+      // process for on the main node
+      processFor(branch0)
+      addRawAttr(branch0, 'type', 'checkbox')
+      processElement(branch0, options)
+      branch0.processed = true // prevent it from double-processed
+      branch0.if = '('.concat(typeBinding, ")==='checkbox'") + ifConditionExtra
+      addIfCondition(branch0, {
+        exp: branch0.if,
+        block: branch0
+      })
+      // 2. add radio else-if condition
+      var branch1 = cloneASTElement(el)
+      getAndRemoveAttr(branch1, 'v-for', true)
+      addRawAttr(branch1, 'type', 'radio')
+      processElement(branch1, options)
+      addIfCondition(branch0, {
+        exp: '('.concat(typeBinding, ")==='radio'") + ifConditionExtra,
+        block: branch1
+      })
+      // 3. other
+      var branch2 = cloneASTElement(el)
+      getAndRemoveAttr(branch2, 'v-for', true)
+      addRawAttr(branch2, ':type', typeBinding)
+      processElement(branch2, options)
+      addIfCondition(branch0, {
+        exp: ifCondition,
+        block: branch2
+      })
+      if (hasElse) {
+        branch0.else = true
+      } else if (elseIfCondition) {
+        branch0.elseif = elseIfCondition
+      }
+      return branch0
+    }
+  }
+}
+function cloneASTElement(el) {
+  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+}
+var model$1 = {
+  preTransformNode: preTransformNode
+}
+
+var modules = [klass, style, model$1]
+
+var warn
+// in some cases, the event used has to be determined at runtime
+// so we used some reserved tokens during compile.
+var RANGE_TOKEN = '__r'
+function model(el, dir, _warn) {
+  warn = _warn
+  var value = dir.value
+  var modifiers = dir.modifiers
+  var tag = el.tag
+  var type = el.attrsMap.type
+  if (process.env.NODE_ENV !== 'production') {
+    // inputs with type="file" are read only and setting the input's
+    // value will throw an error.
+    if (tag === 'input' && type === 'file') {
+      warn(
+        '<'.concat(el.tag, ' v-model="').concat(value, '" type="file">:\n') +
+          'File inputs are read only. Use a v-on:change listener instead.',
+        el.rawAttrsMap['v-model']
+      )
+    }
+  }
+  if (el.component) {
+    genComponentModel(el, value, modifiers)
+    // component v-model doesn't need extra runtime
+    return false
+  } else if (tag === 'select') {
+    genSelect(el, value, modifiers)
+  } else if (tag === 'input' && type === 'checkbox') {
+    genCheckboxModel(el, value, modifiers)
+  } else if (tag === 'input' && type === 'radio') {
+    genRadioModel(el, value, modifiers)
+  } else if (tag === 'input' || tag === 'textarea') {
+    genDefaultModel(el, value, modifiers)
+  } else {
+    genComponentModel(el, value, modifiers)
+    // component v-model doesn't need extra runtime
+    return false
+  }
+  // ensure runtime directive metadata
+  return true
+}
+function genCheckboxModel(el, value, modifiers) {
+  var number = modifiers && modifiers.number
+  var valueBinding = getBindingAttr(el, 'value') || 'null'
+  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
+  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
+  addProp(
+    el,
+    'checked',
+    'Array.isArray('.concat(value, ')') +
+      '?_i('.concat(value, ',').concat(valueBinding, ')>-1') +
+      (trueValueBinding === 'true'
+        ? ':('.concat(value, ')')
+        : ':_q('.concat(value, ',').concat(trueValueBinding, ')'))
+  )
+  addHandler(
+    el,
+    'change',
+    'var $$a='.concat(value, ',') +
+      '$$el=$event.target,' +
+      '$$c=$$el.checked?('
+        .concat(trueValueBinding, '):(')
+        .concat(falseValueBinding, ');') +
+      'if(Array.isArray($$a)){' +
+      'var $$v='.concat(
+        number ? '_n(' + valueBinding + ')' : valueBinding,
+        ','
+      ) +
+      '$$i=_i($$a,$$v);' +
+      'if($$el.checked){$$i<0&&('.concat(
+        genAssignmentCode(value, '$$a.concat([$$v])'),
+        ')}'
+      ) +
+      'else{$$i>-1&&('.concat(
+        genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))'),
+        ')}'
+      ) +
+      '}else{'.concat(genAssignmentCode(value, '$$c'), '}'),
+    null,
+    true
+  )
+}
+function genRadioModel(el, value, modifiers) {
+  var number = modifiers && modifiers.number
+  var valueBinding = getBindingAttr(el, 'value') || 'null'
+  valueBinding = number ? '_n('.concat(valueBinding, ')') : valueBinding
+  addProp(el, 'checked', '_q('.concat(value, ',').concat(valueBinding, ')'))
+  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
+}
+function genSelect(el, value, modifiers) {
+  var number = modifiers && modifiers.number
+  var selectedVal =
+    'Array.prototype.filter' +
+    '.call($event.target.options,function(o){return o.selected})' +
+    '.map(function(o){var val = "_value" in o ? o._value : o.value;' +
+    'return '.concat(number ? '_n(val)' : 'val', '})')
+  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
+  var code = 'var $$selectedVal = '.concat(selectedVal, ';')
+  code = ''.concat(code, ' ').concat(genAssignmentCode(value, assignment))
+  addHandler(el, 'change', code, null, true)
+}
+function genDefaultModel(el, value, modifiers) {
+  var type = el.attrsMap.type
+  // warn if v-bind:value conflicts with v-model
+  // except for inputs with v-bind:type
+  if (process.env.NODE_ENV !== 'production') {
+    var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
+    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
+    if (value_1 && !typeBinding) {
+      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
+      warn(
+        ''
+          .concat(binding, '="')
+          .concat(value_1, '" conflicts with v-model on the same element ') +
+          'because the latter already expands to a value binding internally',
+        el.rawAttrsMap[binding]
+      )
+    }
+  }
+  var _a = modifiers || {},
+    lazy = _a.lazy,
+    number = _a.number,
+    trim = _a.trim
+  var needCompositionGuard = !lazy && type !== 'range'
+  var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'
+  var valueExpression = '$event.target.value'
+  if (trim) {
+    valueExpression = '$event.target.value.trim()'
+  }
+  if (number) {
+    valueExpression = '_n('.concat(valueExpression, ')')
+  }
+  var code = genAssignmentCode(value, valueExpression)
+  if (needCompositionGuard) {
+    code = 'if($event.target.composing)return;'.concat(code)
+  }
+  addProp(el, 'value', '('.concat(value, ')'))
+  addHandler(el, event, code, null, true)
+  if (trim || number) {
+    addHandler(el, 'blur', '$forceUpdate()')
+  }
+}
+
+function text(el, dir) {
+  if (dir.value) {
+    addProp(el, 'textContent', '_s('.concat(dir.value, ')'), dir)
+  }
+}
+
+function html(el, dir) {
+  if (dir.value) {
+    addProp(el, 'innerHTML', '_s('.concat(dir.value, ')'), dir)
+  }
+}
+
+var directives = {
+  model: model,
+  text: text,
+  html: html
+}
+
+var baseOptions = {
+  expectHTML: true,
+  modules: modules,
+  directives: directives,
+  isPreTag: isPreTag,
+  isUnaryTag: isUnaryTag,
+  mustUseProp: mustUseProp,
+  canBeLeftOpenTag: canBeLeftOpenTag,
+  isReservedTag: isReservedTag,
+  getTagNamespace: getTagNamespace,
+  staticKeys: genStaticKeys$1(modules)
+}
+
+var isStaticKey
+var isPlatformReservedTag$1
+var genStaticKeysCached = cached(genStaticKeys)
+/**
+ * Goal of the optimizer: walk the generated template AST tree
+ * and detect sub-trees that are purely static, i.e. parts of
+ * the DOM that never needs to change.
+ *
+ * Once we detect these sub-trees, we can:
+ *
+ * 1. Hoist them into constants, so that we no longer need to
+ *    create fresh nodes for them on each re-render;
+ * 2. Completely skip them in the patching process.
+ */
+function optimize$1(root, options) {
+  if (!root) return
+  isStaticKey = genStaticKeysCached(options.staticKeys || '')
+  isPlatformReservedTag$1 = options.isReservedTag || no
+  // first pass: mark all non-static nodes.
+  markStatic(root)
+  // second pass: mark static roots.
+  markStaticRoots(root, false)
+}
+function genStaticKeys(keys) {
+  return makeMap(
+    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
+      (keys ? ',' + keys : '')
+  )
+}
+function markStatic(node) {
+  node.static = isStatic(node)
+  if (node.type === 1) {
+    // do not make component slot content static. this avoids
+    // 1. components not able to mutate slot nodes
+    // 2. static slot content fails for hot-reloading
+    if (
+      !isPlatformReservedTag$1(node.tag) &&
+      node.tag !== 'slot' &&
+      node.attrsMap['inline-template'] == null
+    ) {
+      return
+    }
+    for (var i = 0, l = node.children.length; i < l; i++) {
+      var child = node.children[i]
+      markStatic(child)
+      if (!child.static) {
+        node.static = false
+      }
+    }
+    if (node.ifConditions) {
+      for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+        var block = node.ifConditions[i].block
+        markStatic(block)
+        if (!block.static) {
+          node.static = false
+        }
+      }
+    }
+  }
+}
+function markStaticRoots(node, isInFor) {
+  if (node.type === 1) {
+    if (node.static || node.once) {
+      node.staticInFor = isInFor
+    }
+    // For a node to qualify as a static root, it should have children that
+    // are not just static text. Otherwise the cost of hoisting out will
+    // outweigh the benefits and it's better off to just always render it fresh.
+    if (
+      node.static &&
+      node.children.length &&
+      !(node.children.length === 1 && node.children[0].type === 3)
+    ) {
+      node.staticRoot = true
+      return
+    } else {
+      node.staticRoot = false
+    }
+    if (node.children) {
+      for (var i = 0, l = node.children.length; i < l; i++) {
+        markStaticRoots(node.children[i], isInFor || !!node.for)
+      }
+    }
+    if (node.ifConditions) {
+      for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+        markStaticRoots(node.ifConditions[i].block, isInFor)
+      }
+    }
+  }
+}
+function isStatic(node) {
+  if (node.type === 2) {
+    // expression
+    return false
+  }
+  if (node.type === 3) {
+    // text
+    return true
+  }
+  return !!(
+    node.pre ||
+    (!node.hasBindings && // no dynamic bindings
+      !node.if &&
+      !node.for && // not v-if or v-for or v-else
+      !isBuiltInTag(node.tag) && // not a built-in
+      isPlatformReservedTag$1(node.tag) && // not a component
+      !isDirectChildOfTemplateFor(node) &&
+      Object.keys(node).every(isStaticKey))
+  )
+}
+function isDirectChildOfTemplateFor(node) {
+  while (node.parent) {
+    node = node.parent
+    if (node.tag !== 'template') {
+      return false
+    }
+    if (node.for) {
+      return true
+    }
+  }
+  return false
+}
+
+var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
+var fnInvokeRE = /\([^)]*?\);*$/
+var simplePathRE =
+  /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
+// KeyboardEvent.keyCode aliases
+var keyCodes = {
+  esc: 27,
+  tab: 9,
+  enter: 13,
+  space: 32,
+  up: 38,
+  left: 37,
+  right: 39,
+  down: 40,
+  delete: [8, 46]
+}
+// KeyboardEvent.key aliases
+var keyNames = {
+  // #7880: IE11 and Edge use `Esc` for Escape key name.
+  esc: ['Esc', 'Escape'],
+  tab: 'Tab',
+  enter: 'Enter',
+  // #9112: IE11 uses `Spacebar` for Space key name.
+  space: [' ', 'Spacebar'],
+  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
+  up: ['Up', 'ArrowUp'],
+  left: ['Left', 'ArrowLeft'],
+  right: ['Right', 'ArrowRight'],
+  down: ['Down', 'ArrowDown'],
+  // #9112: IE11 uses `Del` for Delete key name.
+  delete: ['Backspace', 'Delete', 'Del']
+}
+// #4868: modifiers that prevent the execution of the listener
+// need to explicitly return null so that we can determine whether to remove
+// the listener for .once
+var genGuard = function (condition) {
+  return 'if('.concat(condition, ')return null;')
+}
+var modifierCode = {
+  stop: '$event.stopPropagation();',
+  prevent: '$event.preventDefault();',
+  self: genGuard('$event.target !== $event.currentTarget'),
+  ctrl: genGuard('!$event.ctrlKey'),
+  shift: genGuard('!$event.shiftKey'),
+  alt: genGuard('!$event.altKey'),
+  meta: genGuard('!$event.metaKey'),
+  left: genGuard("'button' in $event && $event.button !== 0"),
+  middle: genGuard("'button' in $event && $event.button !== 1"),
+  right: genGuard("'button' in $event && $event.button !== 2")
+}
+function genHandlers(events, isNative) {
+  var prefix = isNative ? 'nativeOn:' : 'on:'
+  var staticHandlers = ''
+  var dynamicHandlers = ''
+  for (var name_1 in events) {
+    var handlerCode = genHandler(events[name_1])
+    //@ts-expect-error
+    if (events[name_1] && events[name_1].dynamic) {
+      dynamicHandlers += ''.concat(name_1, ',').concat(handlerCode, ',')
+    } else {
+      staticHandlers += '"'.concat(name_1, '":').concat(handlerCode, ',')
+    }
+  }
+  staticHandlers = '{'.concat(staticHandlers.slice(0, -1), '}')
+  if (dynamicHandlers) {
+    return (
+      prefix +
+      '_d('
+        .concat(staticHandlers, ',[')
+        .concat(dynamicHandlers.slice(0, -1), '])')
+    )
+  } else {
+    return prefix + staticHandlers
+  }
+}
+function genHandler(handler) {
+  if (!handler) {
+    return 'function(){}'
+  }
+  if (Array.isArray(handler)) {
+    return '['.concat(
+      handler
+        .map(function (handler) {
+          return genHandler(handler)
+        })
+        .join(','),
+      ']'
+    )
+  }
+  var isMethodPath = simplePathRE.test(handler.value)
+  var isFunctionExpression = fnExpRE.test(handler.value)
+  var isFunctionInvocation = simplePathRE.test(
+    handler.value.replace(fnInvokeRE, '')
+  )
+  if (!handler.modifiers) {
+    if (isMethodPath || isFunctionExpression) {
+      return handler.value
+    }
+    return 'function($event){'.concat(
+      isFunctionInvocation ? 'return '.concat(handler.value) : handler.value,
+      '}'
+    ) // inline statement
+  } else {
+    var code = ''
+    var genModifierCode = ''
+    var keys = []
+    var _loop_1 = function (key) {
+      if (modifierCode[key]) {
+        genModifierCode += modifierCode[key]
+        // left/right
+        if (keyCodes[key]) {
+          keys.push(key)
+        }
+      } else if (key === 'exact') {
+        var modifiers_1 = handler.modifiers
+        genModifierCode += genGuard(
+          ['ctrl', 'shift', 'alt', 'meta']
+            .filter(function (keyModifier) {
+              return !modifiers_1[keyModifier]
+            })
+            .map(function (keyModifier) {
+              return '$event.'.concat(keyModifier, 'Key')
+            })
+            .join('||')
+        )
+      } else {
+        keys.push(key)
+      }
+    }
+    for (var key in handler.modifiers) {
+      _loop_1(key)
+    }
+    if (keys.length) {
+      code += genKeyFilter(keys)
+    }
+    // Make sure modifiers like prevent and stop get executed after key filtering
+    if (genModifierCode) {
+      code += genModifierCode
+    }
+    var handlerCode = isMethodPath
+      ? 'return '.concat(handler.value, '.apply(null, arguments)')
+      : isFunctionExpression
+      ? 'return ('.concat(handler.value, ').apply(null, arguments)')
+      : isFunctionInvocation
+      ? 'return '.concat(handler.value)
+      : handler.value
+    return 'function($event){'.concat(code).concat(handlerCode, '}')
+  }
+}
+function genKeyFilter(keys) {
+  return (
+    // make sure the key filters only apply to KeyboardEvents
+    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
+    // key events that do not have keyCode property...
+    "if(!$event.type.indexOf('key')&&" +
+    ''.concat(keys.map(genFilterCode).join('&&'), ')return null;')
+  )
+}
+function genFilterCode(key) {
+  var keyVal = parseInt(key, 10)
+  if (keyVal) {
+    return '$event.keyCode!=='.concat(keyVal)
+  }
+  var keyCode = keyCodes[key]
+  var keyName = keyNames[key]
+  return (
+    '_k($event.keyCode,' +
+    ''.concat(JSON.stringify(key), ',') +
+    ''.concat(JSON.stringify(keyCode), ',') +
+    '$event.key,' +
+    ''.concat(JSON.stringify(keyName)) +
+    ')'
+  )
+}
+
+function on(el, dir) {
+  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
+    warn$2('v-on without argument does not support modifiers.')
+  }
+  el.wrapListeners = function (code) {
+    return '_g('.concat(code, ',').concat(dir.value, ')')
+  }
+}
+
+function bind(el, dir) {
+  el.wrapData = function (code) {
+    return '_b('
+      .concat(code, ",'")
+      .concat(el.tag, "',")
+      .concat(dir.value, ',')
+      .concat(dir.modifiers && dir.modifiers.prop ? 'true' : 'false')
+      .concat(dir.modifiers && dir.modifiers.sync ? ',true' : '', ')')
+  }
+}
+
+var baseDirectives = {
+  on: on,
+  bind: bind,
+  cloak: noop
+}
+
+var CodegenState = /** @class */ (function () {
+  function CodegenState(options) {
+    this.options = options
+    this.warn = options.warn || baseWarn
+    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
+    this.transforms = pluckModuleFunction(options.modules, 'transformCode')
+    this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
+    this.directives = extend(extend({}, baseDirectives), options.directives)
+    var isReservedTag = options.isReservedTag || no
+    this.maybeComponent = function (el) {
+      return !!el.component || !isReservedTag(el.tag)
+    }
+    this.onceId = 0
+    this.staticRenderFns = []
+    this.pre = false
+  }
+  return CodegenState
+})()
+function generate$1(ast, options) {
+  var state = new CodegenState(options)
+  // fix #11483, Root level <script> tags should not be rendered.
+  var code = ast
+    ? ast.tag === 'script'
+      ? 'null'
+      : genElement(ast, state)
+    : '_c("div")'
+  return {
+    render: 'with(this){return '.concat(code, '}'),
+    staticRenderFns: state.staticRenderFns
+  }
+}
+function genElement(el, state) {
+  if (el.parent) {
+    el.pre = el.pre || el.parent.pre
+  }
+  if (el.staticRoot && !el.staticProcessed) {
+    return genStatic(el, state)
+  } else if (el.once && !el.onceProcessed) {
+    return genOnce(el, state)
+  } else if (el.for && !el.forProcessed) {
+    return genFor(el, state)
+  } else if (el.if && !el.ifProcessed) {
+    return genIf(el, state)
+  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
+    return genChildren(el, state) || 'void 0'
+  } else if (el.tag === 'slot') {
+    return genSlot(el, state)
+  } else {
+    // component or element
+    var code = void 0
+    if (el.component) {
+      code = genComponent(el.component, el, state)
+    } else {
+      var data = void 0
+      if (!el.plain || (el.pre && state.maybeComponent(el))) {
+        data = genData(el, state)
+      }
+      var children = el.inlineTemplate ? null : genChildren(el, state, true)
+      code = "_c('"
+        .concat(el.tag, "'")
+        .concat(
+          data ? ','.concat(data) : '' // data
+        )
+        .concat(
+          children ? ','.concat(children) : '', // children
+          ')'
+        )
+    }
+    // module transforms
+    for (var i = 0; i < state.transforms.length; i++) {
+      code = state.transforms[i](el, code)
+    }
+    return code
+  }
+}
+// hoist static sub-trees out
+function genStatic(el, state) {
+  el.staticProcessed = true
+  // Some elements (templates) need to behave differently inside of a v-pre
+  // node.  All pre nodes are static roots, so we can use this as a location to
+  // wrap a state change and reset it upon exiting the pre node.
+  var originalPreState = state.pre
+  if (el.pre) {
+    state.pre = el.pre
+  }
+  state.staticRenderFns.push(
+    'with(this){return '.concat(genElement(el, state), '}')
+  )
+  state.pre = originalPreState
+  return '_m('
+    .concat(state.staticRenderFns.length - 1)
+    .concat(el.staticInFor ? ',true' : '', ')')
+}
+// v-once
+function genOnce(el, state) {
+  el.onceProcessed = true
+  if (el.if && !el.ifProcessed) {
+    return genIf(el, state)
+  } else if (el.staticInFor) {
+    var key = ''
+    var parent_1 = el.parent
+    while (parent_1) {
+      if (parent_1.for) {
+        key = parent_1.key
+        break
+      }
+      parent_1 = parent_1.parent
+    }
+    if (!key) {
+      process.env.NODE_ENV !== 'production' &&
+        state.warn(
+          'v-once can only be used inside v-for that is keyed. ',
+          el.rawAttrsMap['v-once']
+        )
+      return genElement(el, state)
+    }
+    return '_o('
+      .concat(genElement(el, state), ',')
+      .concat(state.onceId++, ',')
+      .concat(key, ')')
+  } else {
+    return genStatic(el, state)
+  }
+}
+function genIf(el, state, altGen, altEmpty) {
+  el.ifProcessed = true // avoid recursion
+  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
+}
+function genIfConditions(conditions, state, altGen, altEmpty) {
+  if (!conditions.length) {
+    return altEmpty || '_e()'
+  }
+  var condition = conditions.shift()
+  if (condition.exp) {
+    return '('
+      .concat(condition.exp, ')?')
+      .concat(genTernaryExp(condition.block), ':')
+      .concat(genIfConditions(conditions, state, altGen, altEmpty))
+  } else {
+    return ''.concat(genTernaryExp(condition.block))
+  }
+  // v-if with v-once should generate code like (a)?_m(0):_m(1)
+  function genTernaryExp(el) {
+    return altGen
+      ? altGen(el, state)
+      : el.once
+      ? genOnce(el, state)
+      : genElement(el, state)
+  }
+}
+function genFor(el, state, altGen, altHelper) {
+  var exp = el.for
+  var alias = el.alias
+  var iterator1 = el.iterator1 ? ','.concat(el.iterator1) : ''
+  var iterator2 = el.iterator2 ? ','.concat(el.iterator2) : ''
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    state.maybeComponent(el) &&
+    el.tag !== 'slot' &&
+    el.tag !== 'template' &&
+    !el.key
+  ) {
+    state.warn(
+      '<'
+        .concat(el.tag, ' v-for="')
+        .concat(alias, ' in ')
+        .concat(exp, '">: component lists rendered with ') +
+        'v-for should have explicit keys. ' +
+        'See https://vuejs.org/guide/list.html#key for more info.',
+      el.rawAttrsMap['v-for'],
+      true /* tip */
+    )
+  }
+  el.forProcessed = true // avoid recursion
+  return (
+    ''.concat(altHelper || '_l', '((').concat(exp, '),') +
+    'function('.concat(alias).concat(iterator1).concat(iterator2, '){') +
+    'return '.concat((altGen || genElement)(el, state)) +
+    '})'
+  )
+}
+function genData(el, state) {
+  var data = '{'
+  // directives first.
+  // directives may mutate the el's other properties before they are generated.
+  var dirs = genDirectives(el, state)
+  if (dirs) data += dirs + ','
+  // key
+  if (el.key) {
+    data += 'key:'.concat(el.key, ',')
+  }
+  // ref
+  if (el.ref) {
+    data += 'ref:'.concat(el.ref, ',')
+  }
+  if (el.refInFor) {
+    data += 'refInFor:true,'
+  }
+  // pre
+  if (el.pre) {
+    data += 'pre:true,'
+  }
+  // record original tag name for components using "is" attribute
+  if (el.component) {
+    data += 'tag:"'.concat(el.tag, '",')
+  }
+  // module data generation functions
+  for (var i = 0; i < state.dataGenFns.length; i++) {
+    data += state.dataGenFns[i](el)
+  }
+  // attributes
+  if (el.attrs) {
+    data += 'attrs:'.concat(genProps(el.attrs), ',')
+  }
+  // DOM props
+  if (el.props) {
+    data += 'domProps:'.concat(genProps(el.props), ',')
+  }
+  // event handlers
+  if (el.events) {
+    data += ''.concat(genHandlers(el.events, false), ',')
+  }
+  if (el.nativeEvents) {
+    data += ''.concat(genHandlers(el.nativeEvents, true), ',')
+  }
+  // slot target
+  // only for non-scoped slots
+  if (el.slotTarget && !el.slotScope) {
+    data += 'slot:'.concat(el.slotTarget, ',')
+  }
+  // scoped slots
+  if (el.scopedSlots) {
+    data += ''.concat(genScopedSlots(el, el.scopedSlots, state), ',')
+  }
+  // component v-model
+  if (el.model) {
+    data += 'model:{value:'
+      .concat(el.model.value, ',callback:')
+      .concat(el.model.callback, ',expression:')
+      .concat(el.model.expression, '},')
+  }
+  // inline-template
+  if (el.inlineTemplate) {
+    var inlineTemplate = genInlineTemplate(el, state)
+    if (inlineTemplate) {
+      data += ''.concat(inlineTemplate, ',')
+    }
+  }
+  data = data.replace(/,$/, '') + '}'
+  // v-bind dynamic argument wrap
+  // v-bind with dynamic arguments must be applied using the same v-bind object
+  // merge helper so that class/style/mustUseProp attrs are handled correctly.
+  if (el.dynamicAttrs) {
+    data = '_b('
+      .concat(data, ',"')
+      .concat(el.tag, '",')
+      .concat(genProps(el.dynamicAttrs), ')')
+  }
+  // v-bind data wrap
+  if (el.wrapData) {
+    data = el.wrapData(data)
+  }
+  // v-on data wrap
+  if (el.wrapListeners) {
+    data = el.wrapListeners(data)
+  }
+  return data
+}
+function genDirectives(el, state) {
+  var dirs = el.directives
+  if (!dirs) return
+  var res = 'directives:['
+  var hasRuntime = false
+  var i, l, dir, needRuntime
+  for (i = 0, l = dirs.length; i < l; i++) {
+    dir = dirs[i]
+    needRuntime = true
+    var gen = state.directives[dir.name]
+    if (gen) {
+      // compile-time directive that manipulates AST.
+      // returns true if it also needs a runtime counterpart.
+      needRuntime = !!gen(el, dir, state.warn)
+    }
+    if (needRuntime) {
+      hasRuntime = true
+      res += '{name:"'
+        .concat(dir.name, '",rawName:"')
+        .concat(dir.rawName, '"')
+        .concat(
+          dir.value
+            ? ',value:('
+                .concat(dir.value, '),expression:')
+                .concat(JSON.stringify(dir.value))
+            : ''
+        )
+        .concat(
+          dir.arg
+            ? ',arg:'.concat(
+                dir.isDynamicArg ? dir.arg : '"'.concat(dir.arg, '"')
+              )
+            : ''
+        )
+        .concat(
+          dir.modifiers
+            ? ',modifiers:'.concat(JSON.stringify(dir.modifiers))
+            : '',
+          '},'
+        )
+    }
+  }
+  if (hasRuntime) {
+    return res.slice(0, -1) + ']'
+  }
+}
+function genInlineTemplate(el, state) {
+  var ast = el.children[0]
+  if (
+    process.env.NODE_ENV !== 'production' &&
+    (el.children.length !== 1 || ast.type !== 1)
+  ) {
+    state.warn(
+      'Inline-template components must have exactly one child element.',
+      { start: el.start }
+    )
+  }
+  if (ast && ast.type === 1) {
+    var inlineRenderFns = generate$1(ast, state.options)
+    return 'inlineTemplate:{render:function(){'
+      .concat(inlineRenderFns.render, '},staticRenderFns:[')
+      .concat(
+        inlineRenderFns.staticRenderFns
+          .map(function (code) {
+            return 'function(){'.concat(code, '}')
+          })
+          .join(','),
+        ']}'
+      )
+  }
+}
+function genScopedSlots(el, slots, state) {
+  // by default scoped slots are considered "stable", this allows child
+  // components with only scoped slots to skip forced updates from parent.
+  // but in some cases we have to bail-out of this optimization
+  // for example if the slot contains dynamic names, has v-if or v-for on them...
+  var needsForceUpdate =
+    el.for ||
+    Object.keys(slots).some(function (key) {
+      var slot = slots[key]
+      return (
+        slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
+      )
+    })
+  // #9534: if a component with scoped slots is inside a conditional branch,
+  // it's possible for the same component to be reused but with different
+  // compiled slot content. To avoid that, we generate a unique key based on
+  // the generated code of all the slot contents.
+  var needsKey = !!el.if
+  // OR when it is inside another scoped slot or v-for (the reactivity may be
+  // disconnected due to the intermediate scope variable)
+  // #9438, #9506
+  // TODO: this can be further optimized by properly analyzing in-scope bindings
+  // and skip force updating ones that do not actually use scope variables.
+  if (!needsForceUpdate) {
+    var parent_2 = el.parent
+    while (parent_2) {
+      if (
+        (parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
+        parent_2.for
+      ) {
+        needsForceUpdate = true
+        break
+      }
+      if (parent_2.if) {
+        needsKey = true
+      }
+      parent_2 = parent_2.parent
+    }
+  }
+  var generatedSlots = Object.keys(slots)
+    .map(function (key) {
+      return genScopedSlot(slots[key], state)
+    })
+    .join(',')
+  return 'scopedSlots:_u(['
+    .concat(generatedSlots, ']')
+    .concat(needsForceUpdate ? ',null,true' : '')
+    .concat(
+      !needsForceUpdate && needsKey
+        ? ',null,false,'.concat(hash(generatedSlots))
+        : '',
+      ')'
+    )
+}
+function hash(str) {
+  var hash = 5381
+  var i = str.length
+  while (i) {
+    hash = (hash * 33) ^ str.charCodeAt(--i)
+  }
+  return hash >>> 0
+}
+function containsSlotChild(el) {
+  if (el.type === 1) {
+    if (el.tag === 'slot') {
+      return true
+    }
+    return el.children.some(containsSlotChild)
+  }
+  return false
+}
+function genScopedSlot(el, state) {
+  var isLegacySyntax = el.attrsMap['slot-scope']
+  if (el.if && !el.ifProcessed && !isLegacySyntax) {
+    return genIf(el, state, genScopedSlot, 'null')
+  }
+  if (el.for && !el.forProcessed) {
+    return genFor(el, state, genScopedSlot)
+  }
+  var slotScope =
+    el.slotScope === emptySlotScopeToken ? '' : String(el.slotScope)
+  var fn =
+    'function('.concat(slotScope, '){') +
+    'return '.concat(
+      el.tag === 'template'
+        ? el.if && isLegacySyntax
+          ? '('
+              .concat(el.if, ')?')
+              .concat(genChildren(el, state) || 'undefined', ':undefined')
+          : genChildren(el, state) || 'undefined'
+        : genElement(el, state),
+      '}'
+    )
+  // reverse proxy v-slot without scope on this.$slots
+  var reverseProxy = slotScope ? '' : ',proxy:true'
+  return '{key:'
+    .concat(el.slotTarget || '"default"', ',fn:')
+    .concat(fn)
+    .concat(reverseProxy, '}')
+}
+function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
+  var children = el.children
+  if (children.length) {
+    var el_1 = children[0]
+    // optimize single v-for
+    if (
+      children.length === 1 &&
+      el_1.for &&
+      el_1.tag !== 'template' &&
+      el_1.tag !== 'slot'
+    ) {
+      var normalizationType_1 = checkSkip
+        ? state.maybeComponent(el_1)
+          ? ',1'
+          : ',0'
+        : ''
+      return ''
+        .concat((altGenElement || genElement)(el_1, state))
+        .concat(normalizationType_1)
+    }
+    var normalizationType = checkSkip
+      ? getNormalizationType(children, state.maybeComponent)
+      : 0
+    var gen_1 = altGenNode || genNode
+    return '['
+      .concat(
+        children
+          .map(function (c) {
+            return gen_1(c, state)
+          })
+          .join(','),
+        ']'
+      )
+      .concat(normalizationType ? ','.concat(normalizationType) : '')
+  }
+}
+// determine the normalization needed for the children array.
+// 0: no normalization needed
+// 1: simple normalization needed (possible 1-level deep nested array)
+// 2: full normalization needed
+function getNormalizationType(children, maybeComponent) {
+  var res = 0
+  for (var i = 0; i < children.length; i++) {
+    var el = children[i]
+    if (el.type !== 1) {
+      continue
+    }
+    if (
+      needsNormalization(el) ||
+      (el.ifConditions &&
+        el.ifConditions.some(function (c) {
+          return needsNormalization(c.block)
+        }))
+    ) {
+      res = 2
+      break
+    }
+    if (
+      maybeComponent(el) ||
+      (el.ifConditions &&
+        el.ifConditions.some(function (c) {
+          return maybeComponent(c.block)
+        }))
+    ) {
+      res = 1
+    }
+  }
+  return res
+}
+function needsNormalization(el) {
+  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+}
+function genNode(node, state) {
+  if (node.type === 1) {
+    return genElement(node, state)
+  } else if (node.type === 3 && node.isComment) {
+    return genComment(node)
+  } else {
+    return genText(node)
+  }
+}
+function genText(text) {
+  return '_v('.concat(
+    text.type === 2
+      ? text.expression // no need for () because already wrapped in _s()
+      : transformSpecialNewlines(JSON.stringify(text.text)),
+    ')'
+  )
+}
+function genComment(comment) {
+  return '_e('.concat(JSON.stringify(comment.text), ')')
+}
+function genSlot(el, state) {
+  var slotName = el.slotName || '"default"'
+  var children = genChildren(el, state)
+  var res = '_t('
+    .concat(slotName)
+    .concat(children ? ',function(){return '.concat(children, '}') : '')
+  var attrs =
+    el.attrs || el.dynamicAttrs
+      ? genProps(
+          (el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) {
+            return {
+              // slot props are camelized
+              name: camelize(attr.name),
+              value: attr.value,
+              dynamic: attr.dynamic
+            }
+          })
+        )
+      : null
+  var bind = el.attrsMap['v-bind']
+  if ((attrs || bind) && !children) {
+    res += ',null'
+  }
+  if (attrs) {
+    res += ','.concat(attrs)
+  }
+  if (bind) {
+    res += ''.concat(attrs ? '' : ',null', ',').concat(bind)
+  }
+  return res + ')'
+}
+// componentName is el.component, take it as argument to shun flow's pessimistic refinement
+function genComponent(componentName, el, state) {
+  var children = el.inlineTemplate ? null : genChildren(el, state, true)
+  return '_c('
+    .concat(componentName, ',')
+    .concat(genData(el, state))
+    .concat(children ? ','.concat(children) : '', ')')
+}
+function genProps(props) {
+  var staticProps = ''
+  var dynamicProps = ''
+  for (var i = 0; i < props.length; i++) {
+    var prop = props[i]
+    var value = transformSpecialNewlines(prop.value)
+    if (prop.dynamic) {
+      dynamicProps += ''.concat(prop.name, ',').concat(value, ',')
+    } else {
+      staticProps += '"'.concat(prop.name, '":').concat(value, ',')
+    }
+  }
+  staticProps = '{'.concat(staticProps.slice(0, -1), '}')
+  if (dynamicProps) {
+    return '_d('
+      .concat(staticProps, ',[')
+      .concat(dynamicProps.slice(0, -1), '])')
+  } else {
+    return staticProps
+  }
+}
+// #3895, #4268
+function transformSpecialNewlines(text) {
+  return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
+}
+
+// these keywords should not appear inside expressions, but operators like
+// typeof, instanceof and in are allowed
+var prohibitedKeywordRE = new RegExp(
+  '\\b' +
+    (
+      'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
+      'super,throw,while,yield,delete,export,import,return,switch,default,' +
+      'extends,finally,continue,debugger,function,arguments'
+    )
+      .split(',')
+      .join('\\b|\\b') +
+    '\\b'
+)
+// these unary operators should not be used as property/method names
+var unaryOperatorsRE = new RegExp(
+  '\\b' +
+    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
+    '\\s*\\([^\\)]*\\)'
+)
+// strip strings in expressions
+var stripStringRE =
+  /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
+// detect problematic expressions in a template
+function detectErrors(ast, warn) {
+  if (ast) {
+    checkNode(ast, warn)
+  }
+}
+function checkNode(node, warn) {
+  if (node.type === 1) {
+    for (var name_1 in node.attrsMap) {
+      if (dirRE.test(name_1)) {
+        var value = node.attrsMap[name_1]
+        if (value) {
+          var range = node.rawAttrsMap[name_1]
+          if (name_1 === 'v-for') {
+            checkFor(node, 'v-for="'.concat(value, '"'), warn, range)
+          } else if (name_1 === 'v-slot' || name_1[0] === '#') {
+            checkFunctionParameterExpression(
+              value,
+              ''.concat(name_1, '="').concat(value, '"'),
+              warn,
+              range
+            )
+          } else if (onRE.test(name_1)) {
+            checkEvent(
+              value,
+              ''.concat(name_1, '="').concat(value, '"'),
+              warn,
+              range
+            )
+          } else {
+            checkExpression(
+              value,
+              ''.concat(name_1, '="').concat(value, '"'),
+              warn,
+              range
+            )
+          }
+        }
+      }
+    }
+    if (node.children) {
+      for (var i = 0; i < node.children.length; i++) {
+        checkNode(node.children[i], warn)
+      }
+    }
+  } else if (node.type === 2) {
+    checkExpression(node.expression, node.text, warn, node)
+  }
+}
+function checkEvent(exp, text, warn, range) {
+  var stripped = exp.replace(stripStringRE, '')
+  var keywordMatch = stripped.match(unaryOperatorsRE)
+  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
+    warn(
+      'avoid using JavaScript unary operator as property name: ' +
+        '"'.concat(keywordMatch[0], '" in expression ').concat(text.trim()),
+      range
+    )
+  }
+  checkExpression(exp, text, warn, range)
+}
+function checkFor(node, text, warn, range) {
+  checkExpression(node.for || '', text, warn, range)
+  checkIdentifier(node.alias, 'v-for alias', text, warn, range)
+  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
+  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
+}
+function checkIdentifier(ident, type, text, warn, range) {
+  if (typeof ident === 'string') {
+    try {
+      new Function('var '.concat(ident, '=_'))
+    } catch (e) {
+      warn(
+        'invalid '
+          .concat(type, ' "')
+          .concat(ident, '" in expression: ')
+          .concat(text.trim()),
+        range
+      )
+    }
+  }
+}
+function checkExpression(exp, text, warn, range) {
+  try {
+    new Function('return '.concat(exp))
+  } catch (e) {
+    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE)
+    if (keywordMatch) {
+      warn(
+        'avoid using JavaScript keyword as property name: ' +
+          '"'
+            .concat(keywordMatch[0], '"\n  Raw expression: ')
+            .concat(text.trim()),
+        range
+      )
+    } else {
+      warn(
+        'invalid expression: '.concat(e.message, ' in\n\n') +
+          '    '.concat(exp, '\n\n') +
+          '  Raw expression: '.concat(text.trim(), '\n'),
+        range
+      )
+    }
+  }
+}
+function checkFunctionParameterExpression(exp, text, warn, range) {
+  try {
+    new Function(exp, '')
+  } catch (e) {
+    warn(
+      'invalid function parameter expression: '.concat(e.message, ' in\n\n') +
+        '    '.concat(exp, '\n\n') +
+        '  Raw expression: '.concat(text.trim(), '\n'),
+      range
+    )
+  }
+}
+
+var range = 2
+function generateCodeFrame(source, start, end) {
+  if (start === void 0) {
+    start = 0
+  }
+  if (end === void 0) {
+    end = source.length
+  }
+  var lines = source.split(/\r?\n/)
+  var count = 0
+  var res = []
+  for (var i = 0; i < lines.length; i++) {
+    count += lines[i].length + 1
+    if (count >= start) {
+      for (var j = i - range; j <= i + range || end > count; j++) {
+        if (j < 0 || j >= lines.length) continue
+        res.push(
+          ''
+            .concat(j + 1)
+            .concat(repeat(' ', 3 - String(j + 1).length), '|  ')
+            .concat(lines[j])
+        )
+        var lineLength = lines[j].length
+        if (j === i) {
+          // push underline
+          var pad = start - (count - lineLength) + 1
+          var length_1 = end > count ? lineLength - pad : end - start
+          res.push('   |  ' + repeat(' ', pad) + repeat('^', length_1))
+        } else if (j > i) {
+          if (end > count) {
+            var length_2 = Math.min(end - count, lineLength)
+            res.push('   |  ' + repeat('^', length_2))
+          }
+          count += lineLength + 1
+        }
+      }
+      break
+    }
+  }
+  return res.join('\n')
+}
+function repeat(str, n) {
+  var result = ''
+  if (n > 0) {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      // eslint-disable-line
+      if (n & 1) result += str
+      n >>>= 1
+      if (n <= 0) break
+      str += str
+    }
+  }
+  return result
+}
+
+function createFunction(code, errors) {
+  try {
+    return new Function(code)
+  } catch (err) {
+    errors.push({ err: err, code: code })
+    return noop
+  }
+}
+function createCompileToFunctionFn(compile) {
+  var cache = Object.create(null)
+  return function compileToFunctions(template, options, vm) {
+    options = extend({}, options)
+    var warn = options.warn || warn$2
+    delete options.warn
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production') {
+      // detect possible CSP restriction
+      try {
+        new Function('return 1')
+      } catch (e) {
+        if (e.toString().match(/unsafe-eval|CSP/)) {
+          warn(
+            'It seems you are using the standalone build of Vue.js in an ' +
+              'environment with Content Security Policy that prohibits unsafe-eval. ' +
+              'The template compiler cannot work in this environment. Consider ' +
+              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
+              'templates into render functions.'
+          )
+        }
+      }
+    }
+    // check cache
+    var key = options.delimiters
+      ? String(options.delimiters) + template
+      : template
+    if (cache[key]) {
+      return cache[key]
+    }
+    // compile
+    var compiled = compile(template, options)
+    // check compilation errors/tips
+    if (process.env.NODE_ENV !== 'production') {
+      if (compiled.errors && compiled.errors.length) {
+        if (options.outputSourceRange) {
+          compiled.errors.forEach(function (e) {
+            warn(
+              'Error compiling template:\n\n'.concat(e.msg, '\n\n') +
+                generateCodeFrame(template, e.start, e.end),
+              vm
+            )
+          })
+        } else {
+          warn(
+            'Error compiling template:\n\n'.concat(template, '\n\n') +
+              compiled.errors
+                .map(function (e) {
+                  return '- '.concat(e)
+                })
+                .join('\n') +
+              '\n',
+            vm
+          )
+        }
+      }
+      if (compiled.tips && compiled.tips.length) {
+        if (options.outputSourceRange) {
+          compiled.tips.forEach(function (e) {
+            return tip(e.msg, vm)
+          })
+        } else {
+          compiled.tips.forEach(function (msg) {
+            return tip(msg, vm)
+          })
+        }
+      }
+    }
+    // turn code into functions
+    var res = {}
+    var fnGenErrors = []
+    res.render = createFunction(compiled.render, fnGenErrors)
+    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
+      return createFunction(code, fnGenErrors)
+    })
+    // check function generation errors.
+    // this should only happen if there is a bug in the compiler itself.
+    // mostly for codegen development use
+    /* istanbul ignore if */
+    if (process.env.NODE_ENV !== 'production') {
+      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
+        warn(
+          'Failed to generate render function:\n\n' +
+            fnGenErrors
+              .map(function (_a) {
+                var err = _a.err,
+                  code = _a.code
+                return ''.concat(err.toString(), ' in\n\n').concat(code, '\n')
+              })
+              .join('\n'),
+          vm
+        )
+      }
+    }
+    return (cache[key] = res)
+  }
+}
+
+function createCompilerCreator(baseCompile) {
+  return function createCompiler(baseOptions) {
+    function compile(template, options) {
+      var finalOptions = Object.create(baseOptions)
+      var errors = []
+      var tips = []
+      var warn = function (msg, range, tip) {
+        ;(tip ? tips : errors).push(msg)
+      }
+      if (options) {
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          options.outputSourceRange
+        ) {
+          // $flow-disable-line
+          var leadingSpaceLength_1 = template.match(/^\s*/)[0].length
+          warn = function (msg, range, tip) {
+            var data = typeof msg === 'string' ? { msg: msg } : msg
+            if (range) {
+              if (range.start != null) {
+                data.start = range.start + leadingSpaceLength_1
+              }
+              if (range.end != null) {
+                data.end = range.end + leadingSpaceLength_1
+              }
+            }
+            ;(tip ? tips : errors).push(data)
+          }
+        }
+        // merge custom modules
+        if (options.modules) {
+          finalOptions.modules = (baseOptions.modules || []).concat(
+            options.modules
+          )
+        }
+        // merge custom directives
+        if (options.directives) {
+          finalOptions.directives = extend(
+            Object.create(baseOptions.directives || null),
+            options.directives
+          )
+        }
+        // copy other options
+        for (var key in options) {
+          if (key !== 'modules' && key !== 'directives') {
+            finalOptions[key] = options[key]
+          }
+        }
+      }
+      finalOptions.warn = warn
+      var compiled = baseCompile(template.trim(), finalOptions)
+      if (process.env.NODE_ENV !== 'production') {
+        detectErrors(compiled.ast, warn)
+      }
+      compiled.errors = errors
+      compiled.tips = tips
+      return compiled
+    }
+    return {
+      compile: compile,
+      compileToFunctions: createCompileToFunctionFn(compile)
+    }
+  }
+}
+
+// `createCompilerCreator` allows creating compilers that use alternative
+// parser/optimizer/codegen, e.g the SSR optimizing compiler.
+// Here we just export a default compiler using the default parts.
+var createCompiler$1 = createCompilerCreator(function baseCompile(
+  template,
+  options
+) {
+  var ast = parse(template.trim(), options)
+  if (options.optimize !== false) {
+    optimize$1(ast, options)
+  }
+  var code = generate$1(ast, options)
+  return {
+    ast: ast,
+    render: code.render,
+    staticRenderFns: code.staticRenderFns
+  }
+})
+
+var _a$1 = createCompiler$1(baseOptions),
+  compile$1 = _a$1.compile,
+  compileToFunctions$1 = _a$1.compileToFunctions
+
+var isAttr = makeMap(
+  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap'
+)
+/* istanbul ignore next */
+var isRenderableAttr = function (name) {
+  return (
+    isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
+  )
+}
+var propsToAttrMap = {
+  acceptCharset: 'accept-charset',
+  className: 'class',
+  htmlFor: 'for',
+  httpEquiv: 'http-equiv'
+}
+var ESC = {
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  '&': '&amp;'
+}
+function escape(s) {
+  return s.replace(/[<>"&]/g, escapeChar)
+}
+function escapeChar(a) {
+  return ESC[a] || a
+}
+
+var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
+// let the model AST transform translate v-model into appropriate
+// props bindings
+function applyModelTransform(el, state) {
+  if (el.directives) {
+    for (var i = 0; i < el.directives.length; i++) {
+      var dir = el.directives[i]
+      if (dir.name === 'model') {
+        state.directives.model(el, dir, state.warn)
+        // remove value for textarea as its converted to text
+        if (el.tag === 'textarea' && el.props) {
+          el.props = el.props.filter(function (p) {
+            return p.name !== 'value'
+          })
+        }
+        break
+      }
+    }
+  }
+}
+function genAttrSegments(attrs) {
+  return attrs.map(function (_a) {
+    var name = _a.name,
+      value = _a.value
+    return genAttrSegment(name, value)
+  })
+}
+function genDOMPropSegments(props, attrs) {
+  var segments = []
+  props.forEach(function (_a) {
+    var name = _a.name,
+      value = _a.value
+    name = propsToAttrMap[name] || name.toLowerCase()
+    if (
+      isRenderableAttr(name) &&
+      !(
+        attrs &&
+        attrs.some(function (a) {
+          return a.name === name
+        })
+      )
+    ) {
+      segments.push(genAttrSegment(name, value))
+    }
+  })
+  return segments
+}
+function genAttrSegment(name, value) {
+  if (plainStringRE.test(value)) {
+    // force double quote
+    value = value.replace(/^'|'$/g, '"')
+    // force enumerated attr to "true"
+    if (isEnumeratedAttr(name) && value !== '"false"') {
+      value = '"true"'
+    }
+    return {
+      type: RAW,
+      value: isBooleanAttr(name)
+        ? ' '.concat(name, '="').concat(name, '"')
+        : value === '""'
+        ? ' '.concat(name)
+        : ' '.concat(name, '="').concat(JSON.parse(value), '"')
+    }
+  } else {
+    return {
+      type: EXPRESSION,
+      value: '_ssrAttr('.concat(JSON.stringify(name), ',').concat(value, ')')
+    }
+  }
+}
+function genClassSegments(staticClass, classBinding) {
+  if (staticClass && !classBinding) {
+    return [
+      { type: RAW, value: ' class="'.concat(JSON.parse(staticClass), '"') }
+    ]
+  } else {
+    return [
+      {
+        type: EXPRESSION,
+        value: '_ssrClass('
+          .concat(staticClass || 'null', ',')
+          .concat(classBinding || 'null', ')')
+      }
+    ]
+  }
+}
+function genStyleSegments(
+  staticStyle,
+  parsedStaticStyle,
+  styleBinding,
+  vShowExpression
+) {
+  if (staticStyle && !styleBinding && !vShowExpression) {
+    return [{ type: RAW, value: ' style='.concat(JSON.stringify(staticStyle)) }]
+  } else {
+    return [
+      {
+        type: EXPRESSION,
+        value: '_ssrStyle('
+          .concat(parsedStaticStyle || 'null', ',')
+          .concat(styleBinding || 'null', ', ')
+          .concat(
+            vShowExpression
+              ? '{ display: ('.concat(vShowExpression, ") ? '' : 'none' }")
+              : 'null',
+            ')'
+          )
+      }
+    ]
+  }
+}
+
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
+// optimizability constants
+var optimizability = {
+  FALSE: 0,
+  FULL: 1,
+  SELF: 2,
+  CHILDREN: 3,
+  PARTIAL: 4 // self un-optimizable with some un-optimizable children
+}
+var isPlatformReservedTag
+function optimize(root, options) {
+  if (!root) return
+  isPlatformReservedTag = options.isReservedTag || no
+  walk(root, true)
+}
+function walk(node, isRoot) {
+  if (isUnOptimizableTree(node)) {
+    node.ssrOptimizability = optimizability.FALSE
+    return
+  }
+  // root node or nodes with custom directives should always be a VNode
+  var selfUnoptimizable = isRoot || hasCustomDirective(node)
+  var check = function (child) {
+    if (child.ssrOptimizability !== optimizability.FULL) {
+      node.ssrOptimizability = selfUnoptimizable
+        ? optimizability.PARTIAL
+        : optimizability.SELF
+    }
+  }
+  if (selfUnoptimizable) {
+    node.ssrOptimizability = optimizability.CHILDREN
+  }
+  if (node.type === 1) {
+    for (var i = 0, l = node.children.length; i < l; i++) {
+      var child = node.children[i]
+      walk(child)
+      check(child)
+    }
+    if (node.ifConditions) {
+      for (var i = 1, l = node.ifConditions.length; i < l; i++) {
+        var block = node.ifConditions[i].block
+        walk(block, isRoot)
+        check(block)
+      }
+    }
+    if (
+      node.ssrOptimizability == null ||
+      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
+    ) {
+      node.ssrOptimizability = optimizability.FULL
+    } else {
+      node.children = optimizeSiblings(node)
+    }
+  } else {
+    node.ssrOptimizability = optimizability.FULL
+  }
+}
+function optimizeSiblings(el) {
+  var children = el.children
+  var optimizedChildren = []
+  var currentOptimizableGroup = []
+  var pushGroup = function () {
+    if (currentOptimizableGroup.length) {
+      optimizedChildren.push({
+        type: 1,
+        parent: el,
+        tag: 'template',
+        attrsList: [],
+        attrsMap: {},
+        rawAttrsMap: {},
+        children: currentOptimizableGroup,
+        ssrOptimizability: optimizability.FULL
+      })
+    }
+    currentOptimizableGroup = []
+  }
+  for (var i = 0; i < children.length; i++) {
+    var c = children[i]
+    if (c.ssrOptimizability === optimizability.FULL) {
+      currentOptimizableGroup.push(c)
+    } else {
+      // wrap fully-optimizable adjacent siblings inside a template tag
+      // so that they can be optimized into a single ssrNode by codegen
+      pushGroup()
+      optimizedChildren.push(c)
+    }
+  }
+  pushGroup()
+  return optimizedChildren
+}
+function isUnOptimizableTree(node) {
+  if (node.type === 2 || node.type === 3) {
+    // text or expression
+    return false
+  }
+  return (
+    isBuiltInTag(node.tag) || // built-in (slot, component)
+    !isPlatformReservedTag(node.tag) || // custom component
+    !!node.component || // "is" component
+    isSelectWithModel(node) // <select v-model> requires runtime inspection
+  )
+}
+var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
+function hasCustomDirective(node) {
+  return (
+    node.type === 1 &&
+    node.directives &&
+    node.directives.some(function (d) {
+      return !isBuiltInDir(d.name)
+    })
+  )
+}
+// <select v-model> cannot be optimized because it requires a runtime check
+// to determine proper selected option
+function isSelectWithModel(node) {
+  return (
+    node.type === 1 &&
+    node.tag === 'select' &&
+    node.directives != null &&
+    node.directives.some(function (d) {
+      return d.name === 'model'
+    })
+  )
+}
+
+// The SSR codegen is essentially extending the default codegen to handle
+// segment types
+var RAW = 0
+var INTERPOLATION = 1
+var EXPRESSION = 2
+function generate(ast, options) {
+  var state = new CodegenState(options)
+  var code = ast ? genSSRElement(ast, state) : '_c("div")'
+  return {
+    render: 'with(this){return '.concat(code, '}'),
+    staticRenderFns: state.staticRenderFns
+  }
+}
+function genSSRElement(el, state) {
+  if (el.for && !el.forProcessed) {
+    return genFor(el, state, genSSRElement)
+  } else if (el.if && !el.ifProcessed) {
+    return genIf(el, state, genSSRElement)
+  } else if (el.tag === 'template' && !el.slotTarget) {
+    return el.ssrOptimizability === optimizability.FULL
+      ? genChildrenAsStringNode(el, state)
+      : genSSRChildren(el, state) || 'void 0'
+  }
+  switch (el.ssrOptimizability) {
+    case optimizability.FULL:
+      // stringify whole tree
+      return genStringElement(el, state)
+    case optimizability.SELF:
+      // stringify self and check children
+      return genStringElementWithChildren(el, state)
+    case optimizability.CHILDREN:
+      // generate self as VNode and stringify children
+      return genNormalElement(el, state, true)
+    case optimizability.PARTIAL:
+      // generate self as VNode and check children
+      return genNormalElement(el, state, false)
+    default:
+      // bail whole tree
+      return genElement(el, state)
+  }
+}
+function genNormalElement(el, state, stringifyChildren) {
+  var data = el.plain ? undefined : genData(el, state)
+  var children = stringifyChildren
+    ? '['.concat(genChildrenAsStringNode(el, state), ']')
+    : genSSRChildren(el, state, true)
+  return "_c('"
+    .concat(el.tag, "'")
+    .concat(data ? ','.concat(data) : '')
+    .concat(children ? ','.concat(children) : '', ')')
+}
+function genSSRChildren(el, state, checkSkip) {
+  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
+}
+function genSSRNode(el, state) {
+  return el.type === 1 ? genSSRElement(el, state) : genText(el)
+}
+function genChildrenAsStringNode(el, state) {
+  return el.children.length
+    ? '_ssrNode('.concat(flattenSegments(childrenToSegments(el, state)), ')')
+    : ''
+}
+function genStringElement(el, state) {
+  return '_ssrNode('.concat(elementToString(el, state), ')')
+}
+function genStringElementWithChildren(el, state) {
+  var children = genSSRChildren(el, state, true)
+  return '_ssrNode('
+    .concat(flattenSegments(elementToOpenTagSegments(el, state)), ',"</')
+    .concat(el.tag, '>"')
+    .concat(children ? ','.concat(children) : '', ')')
+}
+function elementToString(el, state) {
+  return '('.concat(flattenSegments(elementToSegments(el, state)), ')')
+}
+function elementToSegments(el, state) {
+  // v-for / v-if
+  if (el.for && !el.forProcessed) {
+    el.forProcessed = true
+    return [
+      {
+        type: EXPRESSION,
+        value: genFor(el, state, elementToString, '_ssrList')
+      }
+    ]
+  } else if (el.if && !el.ifProcessed) {
+    el.ifProcessed = true
+    return [
+      {
+        type: EXPRESSION,
+        value: genIf(el, state, elementToString, '"<!---->"')
+      }
+    ]
+  } else if (el.tag === 'template') {
+    return childrenToSegments(el, state)
+  }
+  var openSegments = elementToOpenTagSegments(el, state)
+  var childrenSegments = childrenToSegments(el, state)
+  var isUnaryTag = state.options.isUnaryTag
+  var close =
+    isUnaryTag && isUnaryTag(el.tag)
+      ? []
+      : [{ type: RAW, value: '</'.concat(el.tag, '>') }]
+  return openSegments.concat(childrenSegments, close)
+}
+function elementToOpenTagSegments(el, state) {
+  applyModelTransform(el, state)
+  var binding
+  var segments = [{ type: RAW, value: '<'.concat(el.tag) }]
+  // attrs
+  if (el.attrs) {
+    segments.push.apply(segments, genAttrSegments(el.attrs))
+  }
+  // domProps
+  if (el.props) {
+    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs))
+  }
+  // v-bind="object"
+  if ((binding = el.attrsMap['v-bind'])) {
+    segments.push({
+      type: EXPRESSION,
+      value: '_ssrAttrs('.concat(binding, ')')
+    })
+  }
+  // v-bind.prop="object"
+  if ((binding = el.attrsMap['v-bind.prop'])) {
+    segments.push({
+      type: EXPRESSION,
+      value: '_ssrDOMProps('.concat(binding, ')')
+    })
+  }
+  // class
+  if (el.staticClass || el.classBinding) {
+    segments.push.apply(
+      segments,
+      genClassSegments(el.staticClass, el.classBinding)
+    )
+  }
+  // style & v-show
+  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
+    segments.push.apply(
+      segments,
+      genStyleSegments(
+        el.attrsMap.style,
+        el.staticStyle,
+        el.styleBinding,
+        el.attrsMap['v-show']
+      )
+    )
+  }
+  // _scopedId
+  if (state.options.scopeId) {
+    segments.push({ type: RAW, value: ' '.concat(state.options.scopeId) })
+  }
+  segments.push({ type: RAW, value: '>' })
+  return segments
+}
+function childrenToSegments(el, state) {
+  var binding
+  if ((binding = el.attrsMap['v-html'])) {
+    return [{ type: EXPRESSION, value: '_s('.concat(binding, ')') }]
+  }
+  if ((binding = el.attrsMap['v-text'])) {
+    return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
+  }
+  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
+    return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
+  }
+  return el.children ? nodesToSegments(el.children, state) : []
+}
+function nodesToSegments(children, state) {
+  var segments = []
+  for (var i = 0; i < children.length; i++) {
+    var c = children[i]
+    if (c.type === 1) {
+      segments.push.apply(segments, elementToSegments(c, state))
+    } else if (c.type === 2) {
+      segments.push({ type: INTERPOLATION, value: c.expression })
+    } else if (c.type === 3) {
+      var text = escape(c.text)
+      if (c.isComment) {
+        text = '<!--' + text + '-->'
+      }
+      segments.push({ type: RAW, value: text })
+    }
+  }
+  return segments
+}
+function flattenSegments(segments) {
+  var mergedSegments = []
+  var textBuffer = ''
+  var pushBuffer = function () {
+    if (textBuffer) {
+      mergedSegments.push(JSON.stringify(textBuffer))
+      textBuffer = ''
+    }
+  }
+  for (var i = 0; i < segments.length; i++) {
+    var s = segments[i]
+    if (s.type === RAW) {
+      textBuffer += s.value
+    } else if (s.type === INTERPOLATION) {
+      pushBuffer()
+      mergedSegments.push('_ssrEscape('.concat(s.value, ')'))
+    } else if (s.type === EXPRESSION) {
+      pushBuffer()
+      mergedSegments.push('('.concat(s.value, ')'))
+    }
+  }
+  pushBuffer()
+  return mergedSegments.join('+')
+}
+
+var createCompiler = createCompilerCreator(function baseCompile(
+  template,
+  options
+) {
+  var ast = parse(template.trim(), options)
+  optimize(ast, options)
+  var code = generate(ast, options)
+  return {
+    ast: ast,
+    render: code.render,
+    staticRenderFns: code.staticRenderFns
+  }
+})
+
+var _a = createCompiler(baseOptions),
+  compile = _a.compile,
+  compileToFunctions = _a.compileToFunctions
+
+exports.compile = compile$1
+exports.compileToFunctions = compileToFunctions$1
+exports.generateCodeFrame = generateCodeFrame
+exports.parseComponent = parseComponent
+exports.ssrCompile = compile
+exports.ssrCompileToFunctions = compileToFunctions
diff --git a/packages/template-compiler/index.js b/packages/template-compiler/index.js
new file mode 100644
index 00000000000..378a17dfa24
--- /dev/null
+++ b/packages/template-compiler/index.js
@@ -0,0 +1,32 @@
+try {
+  var vueVersion = require('vue').version
+} catch (e) {}
+
+var packageName = require('./package.json').name
+var packageVersion = require('./package.json').version
+if (vueVersion && vueVersion !== packageVersion) {
+  var vuePath = require.resolve('vue')
+  var packagePath = require.resolve('./package.json')
+  throw new Error(
+    '\n\nVue packages version mismatch:\n\n' +
+      '- vue@' +
+      vueVersion +
+      ' (' +
+      vuePath +
+      ')\n' +
+      '- ' +
+      packageName +
+      '@' +
+      packageVersion +
+      ' (' +
+      packagePath +
+      ')\n\n' +
+      'This may cause things to work incorrectly. Make sure to use the same version for both.\n' +
+      'If you are using vue-loader@>=10.0, simply update vue-template-compiler.\n' +
+      'If you are using vue-loader@<10.0 or vueify, re-installing vue-loader/vueify should bump ' +
+      packageName +
+      ' to the latest.\n'
+  )
+}
+
+module.exports = require('./build')
diff --git a/packages/vue-template-compiler/package.json b/packages/template-compiler/package.json
similarity index 100%
rename from packages/vue-template-compiler/package.json
rename to packages/template-compiler/package.json
diff --git a/packages/vue-template-compiler/types/index.d.ts b/packages/template-compiler/types/index.d.ts
similarity index 99%
rename from packages/vue-template-compiler/types/index.d.ts
rename to packages/template-compiler/types/index.d.ts
index 92476a49e5a..105a52c9e94 100644
--- a/packages/vue-template-compiler/types/index.d.ts
+++ b/packages/template-compiler/types/index.d.ts
@@ -1,4 +1,4 @@
-import Vue, { VNode } from 'vue'
+import { VNode } from 'vue'
 
 /*
  * Template compilation options / results
diff --git a/packages/vue-template-compiler/types/test.ts b/packages/template-compiler/types/test.ts
similarity index 99%
rename from packages/vue-template-compiler/types/test.ts
rename to packages/template-compiler/types/test.ts
index 3b8484481c7..09202c90c5e 100644
--- a/packages/vue-template-compiler/types/test.ts
+++ b/packages/template-compiler/types/test.ts
@@ -6,7 +6,7 @@ import {
   ssrCompileToFunctions,
   parseComponent,
   generateCodeFrame
-} from './'
+} from '.'
 
 // check compile options
 const compiled = compile('<div>hi</div>', {
diff --git a/packages/template-compiler/types/tsconfig.json b/packages/template-compiler/types/tsconfig.json
new file mode 100644
index 00000000000..5e89be1ef9d
--- /dev/null
+++ b/packages/template-compiler/types/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "strict": true,
+    "noEmit": true,
+    "paths": {
+      "vue": ["../../../types/index.d.ts"]
+    }
+  },
+  "include": ["**/*.ts", "../../../types"]
+}
diff --git a/packages/vue-template-compiler/index.js b/packages/vue-template-compiler/index.js
deleted file mode 100644
index dcc7e6cbe9c..00000000000
--- a/packages/vue-template-compiler/index.js
+++ /dev/null
@@ -1,20 +0,0 @@
-try {
-  var vueVersion = require('vue').version
-} catch (e) {}
-
-var packageName = require('./package.json').name
-var packageVersion = require('./package.json').version
-if (vueVersion && vueVersion !== packageVersion) {
-  var vuePath = require.resolve('vue')
-  var packagePath = require.resolve('./package.json')
-  throw new Error(
-    '\n\nVue packages version mismatch:\n\n' +
-    '- vue@' + vueVersion + ' (' + vuePath + ')\n' +
-    '- ' + packageName + '@' + packageVersion + ' (' + packagePath + ')\n\n' +
-    'This may cause things to work incorrectly. Make sure to use the same version for both.\n' +
-    'If you are using vue-loader@>=10.0, simply update vue-template-compiler.\n' +
-    'If you are using vue-loader@<10.0 or vueify, re-installing vue-loader/vueify should bump ' + packageName + ' to the latest.\n'
-  )
-}
-
-module.exports = require('./build')
diff --git a/packages/vue-template-compiler/types/tsconfig.json b/packages/vue-template-compiler/types/tsconfig.json
deleted file mode 100644
index 084dd317ea1..00000000000
--- a/packages/vue-template-compiler/types/tsconfig.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es5",
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "strict": true,
-    "noEmit": true
-  },
-  "compileOnSave": false,
-  "include": [
-    "**/*.ts"
-  ]
-}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 0ba5befa701..9e65214c678 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,110 +1,163 @@
 lockfileVersion: 5.4
 
-specifiers:
-  '@microsoft/api-extractor': ^7.24.2
-  '@rollup/plugin-alias': ^3.1.9
-  '@rollup/plugin-commonjs': ^22.0.0
-  '@rollup/plugin-node-resolve': ^13.2.1
-  '@rollup/plugin-replace': ^4.0.0
-  '@types/he': ^1.1.2
-  '@types/node': ^17.0.30
-  acorn: ^8.7.1
-  acorn-walk: ^8.2.0
-  chalk: ^4.0.0
-  commitizen: ^4.2.4
-  conventional-changelog: ^3.1.25
-  cross-spawn: ^7.0.3
-  cz-conventional-changelog: ^3.3.0
-  de-indent: ^1.0.2
-  esbuild: ^0.14.39
-  escodegen: ^2.0.0
-  file-loader: ^3.0.1
-  hash-sum: ^2.0.0
-  he: ^1.2.0
-  jasmine-core: ^4.1.1
-  jsdom: ^19.0.0
-  karma: ^6.3.20
-  karma-chrome-launcher: ^3.1.1
-  karma-cli: ^2.0.0
-  karma-esbuild: ^2.2.4
-  karma-jasmine: ^5.0.1
-  lint-staged: ^12.4.1
-  lodash: ^4.17.21
-  lodash.template: ^4.4.0
-  lodash.uniq: ^4.5.0
-  lru-cache: ^7.8.1
-  marked: ^4.0.6
-  memory-fs: ^0.5.0
-  prettier: ^2.6.2
-  puppeteer: ^14.1.1
-  resolve: ^1.22.0
-  rimraf: ^3.0.2
-  rollup: ^2.70.2
-  rollup-plugin-typescript2: ^0.31.2
-  serialize-javascript: ^6.0.0
-  shelljs: ^0.8.5
-  source-map: 0.5.6
-  terser: ^5.13.1
-  todomvc-app-css: ^2.4.2
-  ts-node: ^10.7.0
-  tslib: ^2.4.0
-  typescript: ^4.6.4
-  vitest: ^0.12.6
-  webpack: ^4.46.0
-  yorkie: ^2.0.0
-
-devDependencies:
-  '@microsoft/api-extractor': 7.24.2
-  '@rollup/plugin-alias': 3.1.9_rollup@2.74.0
-  '@rollup/plugin-commonjs': 22.0.0_rollup@2.74.0
-  '@rollup/plugin-node-resolve': 13.3.0_rollup@2.74.0
-  '@rollup/plugin-replace': 4.0.0_rollup@2.74.0
-  '@types/he': 1.1.2
-  '@types/node': 17.0.34
-  acorn: 8.7.1
-  acorn-walk: 8.2.0
-  chalk: 4.1.2
-  commitizen: 4.2.4
-  conventional-changelog: 3.1.25
-  cross-spawn: 7.0.3
-  cz-conventional-changelog: 3.3.0
-  de-indent: 1.0.2
-  esbuild: 0.14.39
-  escodegen: 2.0.0
-  file-loader: 3.0.1_webpack@4.46.0
-  hash-sum: 2.0.0
-  he: 1.2.0
-  jasmine-core: 4.1.1
-  jsdom: 19.0.0
-  karma: 6.3.20
-  karma-chrome-launcher: 3.1.1
-  karma-cli: 2.0.0
-  karma-esbuild: 2.2.4_esbuild@0.14.39
-  karma-jasmine: 5.0.1_karma@6.3.20
-  lint-staged: 12.4.1
-  lodash: 4.17.21
-  lodash.template: 4.5.0
-  lodash.uniq: 4.5.0
-  lru-cache: 7.10.1
-  marked: 4.0.16
-  memory-fs: 0.5.0
-  prettier: 2.6.2
-  puppeteer: 14.1.1
-  resolve: 1.22.0
-  rimraf: 3.0.2
-  rollup: 2.74.0
-  rollup-plugin-typescript2: 0.31.2_dyu3set7imqii5ytavmnwecwpy
-  serialize-javascript: 6.0.0
-  shelljs: 0.8.5
-  source-map: 0.5.6
-  terser: 5.13.1
-  todomvc-app-css: 2.4.2
-  ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
-  tslib: 2.4.0
-  typescript: 4.6.4
-  vitest: 0.12.6_jsdom@19.0.0
-  webpack: 4.46.0
-  yorkie: 2.0.0
+importers:
+
+  .:
+    specifiers:
+      '@microsoft/api-extractor': ^7.24.2
+      '@rollup/plugin-alias': ^3.1.9
+      '@rollup/plugin-commonjs': ^22.0.0
+      '@rollup/plugin-node-resolve': ^13.2.1
+      '@rollup/plugin-replace': ^4.0.0
+      '@types/he': ^1.1.2
+      '@types/node': ^17.0.30
+      chalk: ^4.0.0
+      commitizen: ^4.2.4
+      conventional-changelog: ^3.1.25
+      cross-spawn: ^7.0.3
+      cz-conventional-changelog: ^3.3.0
+      de-indent: ^1.0.2
+      esbuild: ^0.14.39
+      he: ^1.2.0
+      jasmine-core: ^4.1.1
+      jsdom: ^19.0.0
+      karma: ^6.3.20
+      karma-chrome-launcher: ^3.1.1
+      karma-cli: ^2.0.0
+      karma-esbuild: ^2.2.4
+      karma-jasmine: ^5.0.1
+      lint-staged: ^12.4.1
+      lodash: ^4.17.21
+      marked: ^4.0.6
+      prettier: ^2.6.2
+      puppeteer: ^14.1.1
+      rimraf: ^3.0.2
+      rollup: ^2.70.2
+      rollup-plugin-typescript2: ^0.31.2
+      shelljs: ^0.8.5
+      terser: ^5.13.1
+      todomvc-app-css: ^2.4.2
+      ts-node: ^10.7.0
+      tslib: ^2.4.0
+      typescript: ^4.6.4
+      vitest: ^0.12.6
+      yorkie: ^2.0.0
+    devDependencies:
+      '@microsoft/api-extractor': 7.24.2
+      '@rollup/plugin-alias': 3.1.9_rollup@2.75.3
+      '@rollup/plugin-commonjs': 22.0.0_rollup@2.75.3
+      '@rollup/plugin-node-resolve': 13.3.0_rollup@2.75.3
+      '@rollup/plugin-replace': 4.0.0_rollup@2.75.3
+      '@types/he': 1.1.2
+      '@types/node': 17.0.36
+      chalk: 4.1.2
+      commitizen: 4.2.4
+      conventional-changelog: 3.1.25
+      cross-spawn: 7.0.3
+      cz-conventional-changelog: 3.3.0
+      de-indent: 1.0.2
+      esbuild: 0.14.42
+      he: 1.2.0
+      jasmine-core: 4.1.1
+      jsdom: 19.0.0
+      karma: 6.3.20
+      karma-chrome-launcher: 3.1.1
+      karma-cli: 2.0.0
+      karma-esbuild: 2.2.4_esbuild@0.14.42
+      karma-jasmine: 5.0.1_karma@6.3.20
+      lint-staged: 12.4.3
+      lodash: 4.17.21
+      marked: 4.0.16
+      prettier: 2.6.2
+      puppeteer: 14.1.2
+      rimraf: 3.0.2
+      rollup: 2.75.3
+      rollup-plugin-typescript2: 0.31.2_nl2qxg2fxlgm6l264qcwjguuca
+      shelljs: 0.8.5
+      terser: 5.14.0
+      todomvc-app-css: 2.4.2
+      ts-node: 10.8.0_w6gfxie3xfwntbz3mwbbvycbdq
+      tslib: 2.4.0
+      typescript: 4.7.2
+      vitest: 0.12.10_jsdom@19.0.0
+      yorkie: 2.0.0
+
+  packages/compiler-sfc:
+    specifiers:
+      '@babel/parser': ^7.16.4
+      '@babel/types': ^7.16.0
+      '@types/estree': ^0.0.48
+      '@types/lru-cache': ^5.1.0
+      '@vue/consolidate': ^0.17.3
+      estree-walker: ^2.0.2
+      hash-sum: ^2.0.0
+      lru-cache: ^5.1.1
+      magic-string: ^0.25.7
+      merge-source-map: ^1.1.0
+      postcss: ^8.1.10
+      postcss-modules: ^4.0.0
+      postcss-selector-parser: ^6.0.4
+      pug: ^3.0.1
+      sass: ^1.26.9
+      source-map: ^0.6.1
+    dependencies:
+      '@babel/parser': 7.18.4
+      postcss: 8.4.14
+      source-map: 0.6.1
+    devDependencies:
+      '@babel/types': 7.18.4
+      '@types/estree': 0.0.48
+      '@types/lru-cache': 5.1.1
+      '@vue/consolidate': 0.17.3
+      estree-walker: 2.0.2
+      hash-sum: 2.0.0
+      lru-cache: 5.1.1
+      magic-string: 0.25.9
+      merge-source-map: 1.1.0
+      postcss-modules: 4.3.1_postcss@8.4.14
+      postcss-selector-parser: 6.0.10
+      pug: 3.0.2
+      sass: 1.52.1
+
+  packages/server-renderer:
+    specifiers:
+      chalk: ^4.0.0
+      file-loader: ^3.0.1
+      hash-sum: ^2.0.0
+      he: ^1.2.0
+      lodash.template: ^4.5.0
+      lodash.uniq: ^4.5.0
+      memory-fs: ^0.5.0
+      resolve: ^1.22.0
+      serialize-javascript: ^6.0.0
+      source-map: 0.5.6
+      vue: file:../..
+      webpack: ^4.46.0
+    dependencies:
+      chalk: 4.1.2
+      hash-sum: 2.0.0
+      he: 1.2.0
+      lodash.template: 4.5.0
+      lodash.uniq: 4.5.0
+      resolve: 1.22.0
+      serialize-javascript: 6.0.0
+      source-map: 0.5.6
+    devDependencies:
+      file-loader: 3.0.1_webpack@4.46.0
+      memory-fs: 0.5.0
+      vue: 'file:'
+      webpack: 4.46.0
+
+  packages/template-compiler:
+    specifiers:
+      de-indent: ^1.0.2
+      he: ^1.2.0
+      vue: file:../..
+    dependencies:
+      de-indent: 1.0.2
+      he: 1.2.0
+    devDependencies:
+      vue: 'file:'
 
 packages:
 
@@ -118,7 +171,6 @@ packages:
   /@babel/helper-validator-identifier/7.16.7:
     resolution: {integrity: sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw==}
     engines: {node: '>=6.9.0'}
-    dev: true
 
   /@babel/highlight/7.17.12:
     resolution: {integrity: sha512-7yykMVF3hfZY2jsHZEEgLc+3x4o1O+fYyULu11GynEUQNwB6lua+IIQn1FiJxNucd5UlyJryrwsOh8PL9Sn8Qg==}
@@ -129,6 +181,20 @@ packages:
       js-tokens: 4.0.0
     dev: true
 
+  /@babel/parser/7.18.4:
+    resolution: {integrity: sha512-FDge0dFazETFcxGw/EXzOkN8uJp0PC7Qbm+Pe9T+av2zlBpOgunFHkQPPn+eRuClU73JF+98D531UgayY89tow==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+    dependencies:
+      '@babel/types': 7.18.4
+
+  /@babel/types/7.18.4:
+    resolution: {integrity: sha512-ThN1mBcMq5pG/Vm2IcBmPPfyPXbd8S02rS+OBIDENdufvqC7Z/jHPCv9IcP01277aKtDI8g/2XysBN4hA8niiw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.16.7
+      to-fast-properties: 2.0.0
+
   /@colors/colors/1.5.0:
     resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==}
     engines: {node: '>=0.1.90'}
@@ -158,13 +224,13 @@ packages:
       '@commitlint/execute-rule': 17.0.0
       '@commitlint/resolve-extends': 17.0.0
       '@commitlint/types': 17.0.0
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
       chalk: 4.1.2
       cosmiconfig: 7.0.1
-      cosmiconfig-typescript-loader: 2.0.0_3smuweqyuzdazdnyhhezld6mfa
+      cosmiconfig-typescript-loader: 2.0.1_w6gfxie3xfwntbz3mwbbvycbdq
       lodash: 4.17.21
       resolve-from: 5.0.0
-      typescript: 4.6.4
+      typescript: 4.7.2
     transitivePeerDependencies:
       - '@swc/core'
       - '@swc/wasm'
@@ -192,16 +258,11 @@ packages:
     dev: true
     optional: true
 
-  /@cspotcode/source-map-consumer/0.8.0:
-    resolution: {integrity: sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg==}
-    engines: {node: '>= 12'}
-    dev: true
-
-  /@cspotcode/source-map-support/0.7.0:
-    resolution: {integrity: sha512-X4xqRHqN8ACt2aHVe51OxeA2HjbcL4MqFqXkrmQszJ1NOUuUu5u6Vqx/0lZSVNku7velL5FC/s5uEAj1lsBMhA==}
+  /@cspotcode/source-map-support/0.8.1:
+    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
     dependencies:
-      '@cspotcode/source-map-consumer': 0.8.0
+      '@jridgewell/trace-mapping': 0.3.9
     dev: true
 
   /@hutson/parse-repository-url/3.0.2:
@@ -209,6 +270,50 @@ packages:
     engines: {node: '>=6.9.0'}
     dev: true
 
+  /@jridgewell/gen-mapping/0.3.1:
+    resolution: {integrity: sha512-GcHwniMlA2z+WFPWuY8lp3fsza0I8xPFMWL5+n8LYyP6PSvPrXf4+n8stDHZY2DM0zy9sVkRDy1jDI4XGzYVqg==}
+    engines: {node: '>=6.0.0'}
+    dependencies:
+      '@jridgewell/set-array': 1.1.1
+      '@jridgewell/sourcemap-codec': 1.4.13
+      '@jridgewell/trace-mapping': 0.3.13
+    dev: true
+
+  /@jridgewell/resolve-uri/3.0.7:
+    resolution: {integrity: sha512-8cXDaBBHOr2pQ7j77Y6Vp5VDT2sIqWyWQ56TjEq4ih/a4iST3dItRe8Q9fp0rrIl9DoKhWQtUQz/YpOxLkXbNA==}
+    engines: {node: '>=6.0.0'}
+    dev: true
+
+  /@jridgewell/set-array/1.1.1:
+    resolution: {integrity: sha512-Ct5MqZkLGEXTVmQYbGtx9SVqD2fqwvdubdps5D3djjAkgkKwT918VNOz65pEHFaYTeWcukmJmH5SwsA9Tn2ObQ==}
+    engines: {node: '>=6.0.0'}
+    dev: true
+
+  /@jridgewell/source-map/0.3.2:
+    resolution: {integrity: sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==}
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.1
+      '@jridgewell/trace-mapping': 0.3.13
+    dev: true
+
+  /@jridgewell/sourcemap-codec/1.4.13:
+    resolution: {integrity: sha512-GryiOJmNcWbovBxTfZSF71V/mXbgcV3MewDe3kIMCLyIh5e7SKAeUZs+rMnJ8jkMolZ/4/VsdBmMrw3l+VdZ3w==}
+    dev: true
+
+  /@jridgewell/trace-mapping/0.3.13:
+    resolution: {integrity: sha512-o1xbKhp9qnIAoHJSWd6KlCZfqslL4valSF81H8ImioOAxluWYWOpWkpyktY2vnt4tbrX9XYaxovq6cgowaJp2w==}
+    dependencies:
+      '@jridgewell/resolve-uri': 3.0.7
+      '@jridgewell/sourcemap-codec': 1.4.13
+    dev: true
+
+  /@jridgewell/trace-mapping/0.3.9:
+    resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
+    dependencies:
+      '@jridgewell/resolve-uri': 3.0.7
+      '@jridgewell/sourcemap-codec': 1.4.13
+    dev: true
+
   /@microsoft/api-extractor-model/7.17.3:
     resolution: {integrity: sha512-ETslFxVEZTEK6mrOARxM34Ll2W/5H2aTk9Pe9dxsMCnthE8O/CaStV4WZAGsvvZKyjelSWgPVYGowxGVnwOMlQ==}
     dependencies:
@@ -248,58 +353,58 @@ packages:
     resolution: {integrity: sha512-6Wci+Tp3CgPt/B9B0a3J4s3yMgLNSku6w5TV6mN+61C71UqsRBv2FUibBf3tPGlNxebgPHMEUzKpb1ggE8KCKw==}
     dev: true
 
-  /@rollup/plugin-alias/3.1.9_rollup@2.74.0:
+  /@rollup/plugin-alias/3.1.9_rollup@2.75.3:
     resolution: {integrity: sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==}
     engines: {node: '>=8.0.0'}
     peerDependencies:
       rollup: ^1.20.0||^2.0.0
     dependencies:
-      rollup: 2.74.0
+      rollup: 2.75.3
       slash: 3.0.0
     dev: true
 
-  /@rollup/plugin-commonjs/22.0.0_rollup@2.74.0:
+  /@rollup/plugin-commonjs/22.0.0_rollup@2.75.3:
     resolution: {integrity: sha512-Ktvf2j+bAO+30awhbYoCaXpBcyPmJbaEUYClQns/+6SNCYFURbvBiNbWgHITEsIgDDWCDUclWRKEuf8cwZCFoQ==}
     engines: {node: '>= 12.0.0'}
     peerDependencies:
       rollup: ^2.68.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.74.0
+      '@rollup/pluginutils': 3.1.0_rollup@2.75.3
       commondir: 1.0.1
       estree-walker: 2.0.2
       glob: 7.2.3
       is-reference: 1.2.1
       magic-string: 0.25.9
       resolve: 1.22.0
-      rollup: 2.74.0
+      rollup: 2.75.3
     dev: true
 
-  /@rollup/plugin-node-resolve/13.3.0_rollup@2.74.0:
+  /@rollup/plugin-node-resolve/13.3.0_rollup@2.75.3:
     resolution: {integrity: sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==}
     engines: {node: '>= 10.0.0'}
     peerDependencies:
       rollup: ^2.42.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.74.0
+      '@rollup/pluginutils': 3.1.0_rollup@2.75.3
       '@types/resolve': 1.17.1
       deepmerge: 4.2.2
       is-builtin-module: 3.1.0
       is-module: 1.0.0
       resolve: 1.22.0
-      rollup: 2.74.0
+      rollup: 2.75.3
     dev: true
 
-  /@rollup/plugin-replace/4.0.0_rollup@2.74.0:
+  /@rollup/plugin-replace/4.0.0_rollup@2.75.3:
     resolution: {integrity: sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==}
     peerDependencies:
       rollup: ^1.20.0 || ^2.0.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.74.0
+      '@rollup/pluginutils': 3.1.0_rollup@2.75.3
       magic-string: 0.25.9
-      rollup: 2.74.0
+      rollup: 2.75.3
     dev: true
 
-  /@rollup/pluginutils/3.1.0_rollup@2.74.0:
+  /@rollup/pluginutils/3.1.0_rollup@2.75.3:
     resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==}
     engines: {node: '>= 8.0.0'}
     peerDependencies:
@@ -308,7 +413,7 @@ packages:
       '@types/estree': 0.0.39
       estree-walker: 1.0.1
       picomatch: 2.3.1
-      rollup: 2.74.0
+      rollup: 2.75.3
     dev: true
 
   /@rollup/pluginutils/4.2.1:
@@ -400,6 +505,10 @@ packages:
     resolution: {integrity: sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==}
     dev: true
 
+  /@types/estree/0.0.48:
+    resolution: {integrity: sha512-LfZwXoGUDo0C3me81HXgkBg5CTQYb6xzEl+fNmbO4JdRiSKQ8A0GD1OBBvKAIsbCUgoyAty7m99GqqMQe784ew==}
+    dev: true
+
   /@types/estree/0.0.51:
     resolution: {integrity: sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==}
     dev: true
@@ -408,6 +517,10 @@ packages:
     resolution: {integrity: sha512-kSJPcLO1x+oolc0R89pUl2kozldQ/fVQ1C1p5mp8fPoLdF/ZcBvckaTC2M8xXh3GYendXvCpy5m/a2eSbfgNgw==}
     dev: true
 
+  /@types/lru-cache/5.1.1:
+    resolution: {integrity: sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==}
+    dev: true
+
   /@types/minimist/1.2.2:
     resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==}
     dev: true
@@ -416,8 +529,8 @@ packages:
     resolution: {integrity: sha512-yxDeaQIAJlMav7fH5AQqPH1u8YIuhYJXYBzxaQ4PifsU0GDO38MSdmEDeRlIxrKbC6NbEaaEHDanWb+y30U8SQ==}
     dev: true
 
-  /@types/node/17.0.34:
-    resolution: {integrity: sha512-XImEz7XwTvDBtzlTnm8YvMqGW/ErMWBsKZ+hMTvnDIjGCKxwK5Xpc+c/oQjOauwq8M4OS11hEkpjX8rrI/eEgA==}
+  /@types/node/17.0.36:
+    resolution: {integrity: sha512-V3orv+ggDsWVHP99K3JlwtH20R7J4IhI1Kksgc+64q5VxgfRkQG8Ws3MFm/FZOKDYGy9feGFlZ70/HpCNe9QaA==}
     dev: true
 
   /@types/normalize-package-data/2.4.1:
@@ -432,17 +545,22 @@ packages:
   /@types/resolve/1.17.1:
     resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==}
     dependencies:
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
     dev: true
 
   /@types/yauzl/2.10.0:
     resolution: {integrity: sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==}
     requiresBuild: true
     dependencies:
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
     dev: true
     optional: true
 
+  /@vue/consolidate/0.17.3:
+    resolution: {integrity: sha512-nl0SWcTMzaaTnJ5G6V8VlMDA1CVVrNnaQKF1aBZU3kXtjgU9jtHMsEAsgjoRUx+T0EVJk9TgbmxGhK3pOk22zw==}
+    engines: {node: '>= 0.12.0'}
+    dev: true
+
   /@webassemblyjs/ast/1.9.0:
     resolution: {integrity: sha512-C6wW5L+b7ogSDVqymbkkvuW9kruN//YisMED04xzeBBqjHa2FYnmvOlS6Xj68xWQRgWvI9cIglsjFowH/RJyEA==}
     dependencies:
@@ -731,7 +849,6 @@ packages:
     engines: {node: '>=8'}
     dependencies:
       color-convert: 2.0.1
-    dev: true
 
   /ansi-styles/6.1.0:
     resolution: {integrity: sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ==}
@@ -799,6 +916,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /asap/2.0.6:
+    resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==}
+    dev: true
+
   /asn1.js/5.4.1:
     resolution: {integrity: sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==}
     dependencies:
@@ -808,6 +929,10 @@ packages:
       safer-buffer: 2.1.2
     dev: true
 
+  /assert-never/1.2.1:
+    resolution: {integrity: sha512-TaTivMB6pYI1kXwrFlEhLeGfOqoDNdTxjCdwRfFFkEA30Eu+k48W34nlok2EYWJfFFzqaEmichdNM7th6M5HNw==}
+    dev: true
+
   /assert/1.5.0:
     resolution: {integrity: sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==}
     dependencies:
@@ -844,6 +969,13 @@ packages:
     hasBin: true
     dev: true
 
+  /babel-walk/3.0.0-canary-5:
+    resolution: {integrity: sha512-GAwkz0AihzY5bkwIY5QDR+LvsRQgB/B+1foMPvi0FZPMl5fjD7ICiznUiBdLYMH1QYe6vqu4gWYytZOccLouFw==}
+    engines: {node: '>= 10.0.0'}
+    dependencies:
+      '@babel/types': 7.18.4
+    dev: true
+
   /balanced-match/1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
     dev: true
@@ -908,8 +1040,8 @@ packages:
     resolution: {integrity: sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==}
     dev: true
 
-  /bn.js/5.2.0:
-    resolution: {integrity: sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==}
+  /bn.js/5.2.1:
+    resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==}
     dev: true
 
   /body-parser/1.20.0:
@@ -1003,14 +1135,14 @@ packages:
   /browserify-rsa/4.1.0:
     resolution: {integrity: sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==}
     dependencies:
-      bn.js: 5.2.0
+      bn.js: 5.2.1
       randombytes: 2.1.0
     dev: true
 
   /browserify-sign/4.2.1:
     resolution: {integrity: sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==}
     dependencies:
-      bn.js: 5.2.0
+      bn.js: 5.2.1
       browserify-rsa: 4.1.0
       create-hash: 1.2.0
       create-hmac: 1.1.7
@@ -1163,6 +1295,11 @@ packages:
     dependencies:
       ansi-styles: 4.3.0
       supports-color: 7.2.0
+
+  /character-parser/2.2.0:
+    resolution: {integrity: sha512-+UqJQjFEFaTAs3bNsF2j2kEN1baG/zghZbdqoYEDxGZtJo9LBzl1A+m0D4n3qKx8N2FNv8/Xp6yV9mQmBuptaw==}
+    dependencies:
+      is-regex: 1.1.4
     dev: true
 
   /chardet/0.7.0:
@@ -1198,7 +1335,6 @@ packages:
   /chokidar/3.5.3:
     resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==}
     engines: {node: '>= 8.10.0'}
-    requiresBuild: true
     dependencies:
       anymatch: 3.1.2
       braces: 3.0.2
@@ -1289,7 +1425,7 @@ packages:
     dev: true
 
   /collection-visit/1.0.0:
-    resolution: {integrity: sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA=}
+    resolution: {integrity: sha512-lNkKvzEeMBBjUGHZ+q6z9pSJla0KWAQPvtzhEV9+iGyQYG+pBpl7xKDhxoNSOZH2hhv0v5k0y2yAM4o4SjoSkw==}
     engines: {node: '>=0.10.0'}
     dependencies:
       map-visit: 1.0.0
@@ -1307,15 +1443,13 @@ packages:
     engines: {node: '>=7.0.0'}
     dependencies:
       color-name: 1.1.4
-    dev: true
 
   /color-name/1.1.3:
-    resolution: {integrity: sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=}
+    resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
     dev: true
 
   /color-name/1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
-    dev: true
 
   /colorette/2.0.16:
     resolution: {integrity: sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==}
@@ -1337,9 +1471,9 @@ packages:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
     dev: true
 
-  /commander/8.3.0:
-    resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==}
-    engines: {node: '>= 12'}
+  /commander/9.3.0:
+    resolution: {integrity: sha512-hv95iU5uXPbK83mjrJKuZyFM/LBAoCV/XhVGkS5Je6tl7sxr6A0ITMw5WoRV46/UaJ46Nllm3Xt7IaJhXTIkzw==}
+    engines: {node: ^12.20.0 || >=14}
     dev: true
 
   /commitizen/4.2.4:
@@ -1367,7 +1501,7 @@ packages:
     dev: true
 
   /commondir/1.0.1:
-    resolution: {integrity: sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=}
+    resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
     dev: true
 
   /compare-func/2.0.0:
@@ -1411,8 +1545,15 @@ packages:
     resolution: {integrity: sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==}
     dev: true
 
+  /constantinople/4.0.1:
+    resolution: {integrity: sha512-vCrqcSIq4//Gx74TXXCGnHpulY1dskqLTFGDmhrGxzeXL8lF8kvXv6mpNWlJj1uD4DW23D4ljAqbY4RRaaUZIw==}
+    dependencies:
+      '@babel/parser': 7.18.4
+      '@babel/types': 7.18.4
+    dev: true
+
   /constants-browserify/1.0.0:
-    resolution: {integrity: sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=}
+    resolution: {integrity: sha512-xFxOwqIzR/e1k1gLiWEophSCMqXcwVHIH7akf7b/vxcUeGunlj3hvZaaqxwHsTgn+IndtkQJgSztIDWeumWJDQ==}
     dev: true
 
   /content-type/1.0.4:
@@ -1587,7 +1728,7 @@ packages:
     dev: true
 
   /copy-descriptor/0.1.1:
-    resolution: {integrity: sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=}
+    resolution: {integrity: sha512-XgZ0pFcakEUlbwQEVNg3+QAis1FyTL3Qel9FYy8pSkQqoG3PNoT0bOCQtOXcOkur21r2Eq2kI+IE+gsmAEVlYw==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -1603,17 +1744,17 @@ packages:
       vary: 1.1.2
     dev: true
 
-  /cosmiconfig-typescript-loader/2.0.0_3smuweqyuzdazdnyhhezld6mfa:
-    resolution: {integrity: sha512-2NlGul/E3vTQEANqPziqkA01vfiuUU8vT0jZAuUIjEW8u3eCcnCQWLggapCjhbF76s7KQF0fM0kXSKmzaDaG1g==}
+  /cosmiconfig-typescript-loader/2.0.1_w6gfxie3xfwntbz3mwbbvycbdq:
+    resolution: {integrity: sha512-B9s6sX/omXq7I6gC6+YgLmrBFMJhPWew7ty/X5Tuwtd2zOSgWaUdXjkuVwbe3qqcdETo60+1nSVMekq//LIXVA==}
     engines: {node: '>=12', npm: '>=6'}
     peerDependencies:
       '@types/node': '*'
       typescript: '>=3'
     dependencies:
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
       cosmiconfig: 7.0.1
-      ts-node: 10.7.0_3smuweqyuzdazdnyhhezld6mfa
-      typescript: 4.6.4
+      ts-node: 10.8.0_w6gfxie3xfwntbz3mwbbvycbdq
+      typescript: 4.7.2
     transitivePeerDependencies:
       - '@swc/core'
       - '@swc/wasm'
@@ -1673,7 +1814,7 @@ packages:
     dev: true
 
   /cross-spawn/5.1.0:
-    resolution: {integrity: sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=}
+    resolution: {integrity: sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==}
     dependencies:
       lru-cache: 4.1.5
       shebang-command: 1.2.0
@@ -1705,6 +1846,12 @@ packages:
       randomfill: 1.0.4
     dev: true
 
+  /cssesc/3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+    dev: true
+
   /cssom/0.3.8:
     resolution: {integrity: sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==}
     dev: true
@@ -1721,11 +1868,11 @@ packages:
     dev: true
 
   /custom-event/1.0.1:
-    resolution: {integrity: sha1-XQKkaFCt8bSjF5RqOSj8y1v9BCU=}
+    resolution: {integrity: sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==}
     dev: true
 
   /cyclist/1.0.1:
-    resolution: {integrity: sha1-WW6WmP0MgOEgOMK4LW6xs1tiJNk=}
+    resolution: {integrity: sha512-NJGVKPS81XejHcLhaLJS7plab0fK3slPh11mESeeDq2W4ZI5kUKK/LRRdVDvjJseojbPB7ZwjnyOybg3Igea/A==}
     dev: true
 
   /cz-conventional-changelog/3.2.0:
@@ -1786,8 +1933,7 @@ packages:
     dev: true
 
   /de-indent/1.0.2:
-    resolution: {integrity: sha1-sgOOhG3DO6pXlhKNCAS0VbjB4h0=}
-    dev: true
+    resolution: {integrity: sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==}
 
   /debug/2.6.9:
     resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}
@@ -1826,7 +1972,7 @@ packages:
     dev: true
 
   /decamelize-keys/1.1.0:
-    resolution: {integrity: sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk=}
+    resolution: {integrity: sha512-ocLWuYzRPoS9bfiSdDd3cxvrzovVMZnRDVEzAs+hWIVXGDbHxWMECij2OBuyB/An0FFW/nLuq6Kv1i/YC5Qfzg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       decamelize: 1.2.0
@@ -1834,7 +1980,7 @@ packages:
     dev: true
 
   /decamelize/1.2.0:
-    resolution: {integrity: sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=}
+    resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -1843,7 +1989,7 @@ packages:
     dev: true
 
   /decode-uri-component/0.2.0:
-    resolution: {integrity: sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=}
+    resolution: {integrity: sha512-hjf+xovcEn31w/EUYdTXQh/8smFL/dzYjohQGEIgjyNavaJfBY2p5F527Bo1VPATxv0VYTUC2bOcXvqFwk78Og==}
     engines: {node: '>=0.10'}
     dev: true
 
@@ -1868,14 +2014,14 @@ packages:
     dev: true
 
   /define-property/0.2.5:
-    resolution: {integrity: sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=}
+    resolution: {integrity: sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-descriptor: 0.1.6
     dev: true
 
   /define-property/1.0.0:
-    resolution: {integrity: sha1-dp66rz9KY6rTr56NMEybvnm/sOY=}
+    resolution: {integrity: sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-descriptor: 1.0.2
@@ -1890,7 +2036,7 @@ packages:
     dev: true
 
   /delayed-stream/1.0.0:
-    resolution: {integrity: sha1-3zrhmayt+31ECqrgsp4icrJOxhk=}
+    resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
     engines: {node: '>=0.4.0'}
     dev: true
 
@@ -1912,7 +2058,7 @@ packages:
     dev: true
 
   /detect-file/1.0.0:
-    resolution: {integrity: sha1-8NZtA2cqglyxtzvbP+YjEMjlUrc=}
+    resolution: {integrity: sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -1926,7 +2072,7 @@ packages:
     dev: true
 
   /di/0.0.1:
-    resolution: {integrity: sha1-gGZJMmzqp8qjMG112YXqJ0i6kTw=}
+    resolution: {integrity: sha512-uJaamHkagcZtHPqCIHZxnFrXlunQXgBOsZSUOWwFw31QJCAbyTBoHMW75YOTur5ZNx8pIeAKgf6GWIgaqqiLhA==}
     dev: true
 
   /diff/4.0.2:
@@ -1942,8 +2088,12 @@ packages:
       randombytes: 2.1.0
     dev: true
 
+  /doctypes/1.1.0:
+    resolution: {integrity: sha512-LLBi6pEqS6Do3EKQ3J0NqHWV5hhb78Pi8vvESYwyOy2c31ZEZVdtitdzsQsKb7878PEERhzUk0ftqGhG6Mz+pQ==}
+    dev: true
+
   /dom-serialize/2.2.1:
-    resolution: {integrity: sha1-ViromZ9Evl6jB29UGdzVnrQ6yVs=}
+    resolution: {integrity: sha512-Yra4DbvoW7/Z6LBN560ZwXMjoNOSAN2wRsKFGc4iBeso+mpIA6qj1vfdf9HpMaKAqG6wXTy+1SYEzmNpKXOSsQ==}
     dependencies:
       custom-event: 1.0.1
       ent: 2.2.0
@@ -2013,7 +2163,7 @@ packages:
     dev: true
 
   /encodeurl/1.0.2:
-    resolution: {integrity: sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=}
+    resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==}
     engines: {node: '>= 0.8'}
     dev: true
 
@@ -2034,7 +2184,7 @@ packages:
     dependencies:
       '@types/cookie': 0.4.1
       '@types/cors': 2.8.12
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
       accepts: 1.3.8
       base64id: 2.0.0
       cookie: 0.4.2
@@ -2058,7 +2208,7 @@ packages:
     dev: true
 
   /ent/2.2.0:
-    resolution: {integrity: sha1-6WQhkyWiHQX0RGai9obtbOX13R0=}
+    resolution: {integrity: sha512-GHrMyVZQWvTIdDtpiEXdHZnFQKzeO09apj8Cbl4pKWy4i0Oprcq17usfDt5aO63swf0JOeMWjWQE/LzgSRuWpA==}
     dev: true
 
   /errno/0.1.8:
@@ -2074,8 +2224,8 @@ packages:
       is-arrayish: 0.2.1
     dev: true
 
-  /esbuild-android-64/0.14.39:
-    resolution: {integrity: sha512-EJOu04p9WgZk0UoKTqLId9VnIsotmI/Z98EXrKURGb3LPNunkeffqQIkjS2cAvidh+OK5uVrXaIP229zK6GvhQ==}
+  /esbuild-android-64/0.14.42:
+    resolution: {integrity: sha512-P4Y36VUtRhK/zivqGVMqhptSrFILAGlYp0Z8r9UQqHJ3iWztRCNWnlBzD9HRx0DbueXikzOiwyOri+ojAFfW6A==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [android]
@@ -2083,8 +2233,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-android-arm64/0.14.39:
-    resolution: {integrity: sha512-+twajJqO7n3MrCz9e+2lVOnFplRsaGRwsq1KL/uOy7xK7QdRSprRQcObGDeDZUZsacD5gUkk6OiHiYp6RzU3CA==}
+  /esbuild-android-arm64/0.14.42:
+    resolution: {integrity: sha512-0cOqCubq+RWScPqvtQdjXG3Czb3AWI2CaKw3HeXry2eoA2rrPr85HF7IpdU26UWdBXgPYtlTN1LUiuXbboROhg==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [android]
@@ -2092,8 +2242,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-darwin-64/0.14.39:
-    resolution: {integrity: sha512-ImT6eUw3kcGcHoUxEcdBpi6LfTRWaV6+qf32iYYAfwOeV+XaQ/Xp5XQIBiijLeo+LpGci9M0FVec09nUw41a5g==}
+  /esbuild-darwin-64/0.14.42:
+    resolution: {integrity: sha512-ipiBdCA3ZjYgRfRLdQwP82rTiv/YVMtW36hTvAN5ZKAIfxBOyPXY7Cejp3bMXWgzKD8B6O+zoMzh01GZsCuEIA==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [darwin]
@@ -2101,8 +2251,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-darwin-arm64/0.14.39:
-    resolution: {integrity: sha512-/fcQ5UhE05OiT+bW5v7/up1bDsnvaRZPJxXwzXsMRrr7rZqPa85vayrD723oWMT64dhrgWeA3FIneF8yER0XTw==}
+  /esbuild-darwin-arm64/0.14.42:
+    resolution: {integrity: sha512-bU2tHRqTPOaoH/4m0zYHbFWpiYDmaA0gt90/3BMEFaM0PqVK/a6MA2V/ypV5PO0v8QxN6gH5hBPY4YJ2lopXgA==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [darwin]
@@ -2110,8 +2260,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-freebsd-64/0.14.39:
-    resolution: {integrity: sha512-oMNH8lJI4wtgN5oxuFP7BQ22vgB/e3Tl5Woehcd6i2r6F3TszpCnNl8wo2d/KvyQ4zvLvCWAlRciumhQg88+kQ==}
+  /esbuild-freebsd-64/0.14.42:
+    resolution: {integrity: sha512-75h1+22Ivy07+QvxHyhVqOdekupiTZVLN1PMwCDonAqyXd8TVNJfIRFrdL8QmSJrOJJ5h8H1I9ETyl2L8LQDaw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [freebsd]
@@ -2119,8 +2269,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-freebsd-arm64/0.14.39:
-    resolution: {integrity: sha512-1GHK7kwk57ukY2yI4ILWKJXaxfr+8HcM/r/JKCGCPziIVlL+Wi7RbJ2OzMcTKZ1HpvEqCTBT/J6cO4ZEwW4Ypg==}
+  /esbuild-freebsd-arm64/0.14.42:
+    resolution: {integrity: sha512-W6Jebeu5TTDQMJUJVarEzRU9LlKpNkPBbjqSu+GUPTHDCly5zZEQq9uHkmHHl7OKm+mQ2zFySN83nmfCeZCyNA==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [freebsd]
@@ -2128,8 +2278,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-32/0.14.39:
-    resolution: {integrity: sha512-g97Sbb6g4zfRLIxHgW2pc393DjnkTRMeq3N1rmjDUABxpx8SjocK4jLen+/mq55G46eE2TA0MkJ4R3SpKMu7dg==}
+  /esbuild-linux-32/0.14.42:
+    resolution: {integrity: sha512-Ooy/Bj+mJ1z4jlWcK5Dl6SlPlCgQB9zg1UrTCeY8XagvuWZ4qGPyYEWGkT94HUsRi2hKsXvcs6ThTOjBaJSMfg==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [linux]
@@ -2137,8 +2287,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-64/0.14.39:
-    resolution: {integrity: sha512-4tcgFDYWdI+UbNMGlua9u1Zhu0N5R6u9tl5WOM8aVnNX143JZoBZLpCuUr5lCKhnD0SCO+5gUyMfupGrHtfggQ==}
+  /esbuild-linux-64/0.14.42:
+    resolution: {integrity: sha512-2L0HbzQfbTuemUWfVqNIjOfaTRt9zsvjnme6lnr7/MO9toz/MJ5tZhjqrG6uDWDxhsaHI2/nsDgrv8uEEN2eoA==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [linux]
@@ -2146,8 +2296,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-arm/0.14.39:
-    resolution: {integrity: sha512-t0Hn1kWVx5UpCzAJkKRfHeYOLyFnXwYynIkK54/h3tbMweGI7dj400D1k0Vvtj2u1P+JTRT9tx3AjtLEMmfVBQ==}
+  /esbuild-linux-arm/0.14.42:
+    resolution: {integrity: sha512-STq69yzCMhdRaWnh29UYrLSr/qaWMm/KqwaRF1pMEK7kDiagaXhSL1zQGXbYv94GuGY/zAwzK98+6idCMUOOCg==}
     engines: {node: '>=12'}
     cpu: [arm]
     os: [linux]
@@ -2155,8 +2305,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-arm64/0.14.39:
-    resolution: {integrity: sha512-23pc8MlD2D6Px1mV8GMglZlKgwgNKAO8gsgsLLcXWSs9lQsCYkIlMo/2Ycfo5JrDIbLdwgP8D2vpfH2KcBqrDQ==}
+  /esbuild-linux-arm64/0.14.42:
+    resolution: {integrity: sha512-c3Ug3e9JpVr8jAcfbhirtpBauLxzYPpycjWulD71CF6ZSY26tvzmXMJYooQ2YKqDY4e/fPu5K8bm7MiXMnyxuA==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [linux]
@@ -2164,8 +2314,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-mips64le/0.14.39:
-    resolution: {integrity: sha512-epwlYgVdbmkuRr5n4es3B+yDI0I2e/nxhKejT9H0OLxFAlMkeQZxSpxATpDc9m8NqRci6Kwyb/SfmD1koG2Zuw==}
+  /esbuild-linux-mips64le/0.14.42:
+    resolution: {integrity: sha512-QuvpHGbYlkyXWf2cGm51LBCHx6eUakjaSrRpUqhPwjh/uvNUYvLmz2LgPTTPwCqaKt0iwL+OGVL0tXA5aDbAbg==}
     engines: {node: '>=12'}
     cpu: [mips64el]
     os: [linux]
@@ -2173,8 +2323,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-ppc64le/0.14.39:
-    resolution: {integrity: sha512-W/5ezaq+rQiQBThIjLMNjsuhPHg+ApVAdTz2LvcuesZFMsJoQAW2hutoyg47XxpWi7aEjJGrkS26qCJKhRn3QQ==}
+  /esbuild-linux-ppc64le/0.14.42:
+    resolution: {integrity: sha512-8ohIVIWDbDT+i7lCx44YCyIRrOW1MYlks9fxTo0ME2LS/fxxdoJBwHWzaDYhjvf8kNpA+MInZvyOEAGoVDrMHg==}
     engines: {node: '>=12'}
     cpu: [ppc64]
     os: [linux]
@@ -2182,8 +2332,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-riscv64/0.14.39:
-    resolution: {integrity: sha512-IS48xeokcCTKeQIOke2O0t9t14HPvwnZcy+5baG13Z1wxs9ZrC5ig5ypEQQh4QMKxURD5TpCLHw2W42CLuVZaA==}
+  /esbuild-linux-riscv64/0.14.42:
+    resolution: {integrity: sha512-DzDqK3TuoXktPyG1Lwx7vhaF49Onv3eR61KwQyxYo4y5UKTpL3NmuarHSIaSVlTFDDpcIajCDwz5/uwKLLgKiQ==}
     engines: {node: '>=12'}
     cpu: [riscv64]
     os: [linux]
@@ -2191,8 +2341,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-s390x/0.14.39:
-    resolution: {integrity: sha512-zEfunpqR8sMomqXhNTFEKDs+ik7HC01m3M60MsEjZOqaywHu5e5682fMsqOlZbesEAAaO9aAtRBsU7CHnSZWyA==}
+  /esbuild-linux-s390x/0.14.42:
+    resolution: {integrity: sha512-YFRhPCxl8nb//Wn6SiS5pmtplBi4z9yC2gLrYoYI/tvwuB1jldir9r7JwAGy1Ck4D7sE7wBN9GFtUUX/DLdcEQ==}
     engines: {node: '>=12'}
     cpu: [s390x]
     os: [linux]
@@ -2200,8 +2350,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-netbsd-64/0.14.39:
-    resolution: {integrity: sha512-Uo2suJBSIlrZCe4E0k75VDIFJWfZy+bOV6ih3T4MVMRJh1lHJ2UyGoaX4bOxomYN3t+IakHPyEoln1+qJ1qYaA==}
+  /esbuild-netbsd-64/0.14.42:
+    resolution: {integrity: sha512-QYSD2k+oT9dqB/4eEM9c+7KyNYsIPgzYOSrmfNGDIyJrbT1d+CFVKvnKahDKNJLfOYj8N4MgyFaU9/Ytc6w5Vw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [netbsd]
@@ -2209,8 +2359,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-openbsd-64/0.14.39:
-    resolution: {integrity: sha512-secQU+EpgUPpYjJe3OecoeGKVvRMLeKUxSMGHnK+aK5uQM3n1FPXNJzyz1LHFOo0WOyw+uoCxBYdM4O10oaCAA==}
+  /esbuild-openbsd-64/0.14.42:
+    resolution: {integrity: sha512-M2meNVIKWsm2HMY7+TU9AxM7ZVwI9havdsw6m/6EzdXysyCFFSoaTQ/Jg03izjCsK17FsVRHqRe26Llj6x0MNA==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [openbsd]
@@ -2218,8 +2368,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-sunos-64/0.14.39:
-    resolution: {integrity: sha512-qHq0t5gePEDm2nqZLb+35p/qkaXVS7oIe32R0ECh2HOdiXXkj/1uQI9IRogGqKkK+QjDG+DhwiUw7QoHur/Rwg==}
+  /esbuild-sunos-64/0.14.42:
+    resolution: {integrity: sha512-uXV8TAZEw36DkgW8Ak3MpSJs1ofBb3Smkc/6pZ29sCAN1KzCAQzsje4sUwugf+FVicrHvlamCOlFZIXgct+iqQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [sunos]
@@ -2227,8 +2377,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-32/0.14.39:
-    resolution: {integrity: sha512-XPjwp2OgtEX0JnOlTgT6E5txbRp6Uw54Isorm3CwOtloJazeIWXuiwK0ONJBVb/CGbiCpS7iP2UahGgd2p1x+Q==}
+  /esbuild-windows-32/0.14.42:
+    resolution: {integrity: sha512-4iw/8qWmRICWi9ZOnJJf9sYt6wmtp3hsN4TdI5NqgjfOkBVMxNdM9Vt3626G1Rda9ya2Q0hjQRD9W1o+m6Lz6g==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [win32]
@@ -2236,8 +2386,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-64/0.14.39:
-    resolution: {integrity: sha512-E2wm+5FwCcLpKsBHRw28bSYQw0Ikxb7zIMxw3OPAkiaQhLVr3dnVO8DofmbWhhf6b97bWzg37iSZ45ZDpLw7Ow==}
+  /esbuild-windows-64/0.14.42:
+    resolution: {integrity: sha512-j3cdK+Y3+a5H0wHKmLGTJcq0+/2mMBHPWkItR3vytp/aUGD/ua/t2BLdfBIzbNN9nLCRL9sywCRpOpFMx3CxzA==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [win32]
@@ -2245,8 +2395,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-arm64/0.14.39:
-    resolution: {integrity: sha512-sBZQz5D+Gd0EQ09tZRnz/PpVdLwvp/ufMtJ1iDFYddDaPpZXKqPyaxfYBLs3ueiaksQ26GGa7sci0OqFzNs7KA==}
+  /esbuild-windows-arm64/0.14.42:
+    resolution: {integrity: sha512-+lRAARnF+hf8J0mN27ujO+VbhPbDqJ8rCcJKye4y7YZLV6C4n3pTRThAb388k/zqF5uM0lS5O201u0OqoWSicw==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [win32]
@@ -2254,32 +2404,32 @@ packages:
     dev: true
     optional: true
 
-  /esbuild/0.14.39:
-    resolution: {integrity: sha512-2kKujuzvRWYtwvNjYDY444LQIA3TyJhJIX3Yo4+qkFlDDtGlSicWgeHVJqMUP/2sSfH10PGwfsj+O2ro1m10xQ==}
+  /esbuild/0.14.42:
+    resolution: {integrity: sha512-V0uPZotCEHokJdNqyozH6qsaQXqmZEOiZWrXnds/zaH/0SyrIayRXWRB98CENO73MIZ9T3HBIOsmds5twWtmgw==}
     engines: {node: '>=12'}
     hasBin: true
     requiresBuild: true
     optionalDependencies:
-      esbuild-android-64: 0.14.39
-      esbuild-android-arm64: 0.14.39
-      esbuild-darwin-64: 0.14.39
-      esbuild-darwin-arm64: 0.14.39
-      esbuild-freebsd-64: 0.14.39
-      esbuild-freebsd-arm64: 0.14.39
-      esbuild-linux-32: 0.14.39
-      esbuild-linux-64: 0.14.39
-      esbuild-linux-arm: 0.14.39
-      esbuild-linux-arm64: 0.14.39
-      esbuild-linux-mips64le: 0.14.39
-      esbuild-linux-ppc64le: 0.14.39
-      esbuild-linux-riscv64: 0.14.39
-      esbuild-linux-s390x: 0.14.39
-      esbuild-netbsd-64: 0.14.39
-      esbuild-openbsd-64: 0.14.39
-      esbuild-sunos-64: 0.14.39
-      esbuild-windows-32: 0.14.39
-      esbuild-windows-64: 0.14.39
-      esbuild-windows-arm64: 0.14.39
+      esbuild-android-64: 0.14.42
+      esbuild-android-arm64: 0.14.42
+      esbuild-darwin-64: 0.14.42
+      esbuild-darwin-arm64: 0.14.42
+      esbuild-freebsd-64: 0.14.42
+      esbuild-freebsd-arm64: 0.14.42
+      esbuild-linux-32: 0.14.42
+      esbuild-linux-64: 0.14.42
+      esbuild-linux-arm: 0.14.42
+      esbuild-linux-arm64: 0.14.42
+      esbuild-linux-mips64le: 0.14.42
+      esbuild-linux-ppc64le: 0.14.42
+      esbuild-linux-riscv64: 0.14.42
+      esbuild-linux-s390x: 0.14.42
+      esbuild-netbsd-64: 0.14.42
+      esbuild-openbsd-64: 0.14.42
+      esbuild-sunos-64: 0.14.42
+      esbuild-windows-32: 0.14.42
+      esbuild-windows-64: 0.14.42
+      esbuild-windows-arm64: 0.14.42
     dev: true
 
   /escalade/3.1.1:
@@ -2288,11 +2438,11 @@ packages:
     dev: true
 
   /escape-html/1.0.3:
-    resolution: {integrity: sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=}
+    resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
     dev: true
 
   /escape-string-regexp/1.0.5:
-    resolution: {integrity: sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=}
+    resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
     engines: {node: '>=0.8.0'}
     dev: true
 
@@ -2370,7 +2520,7 @@ packages:
     dev: true
 
   /execa/0.8.0:
-    resolution: {integrity: sha1-2NdrvBtVIX7RkP1t1J08d07PyNo=}
+    resolution: {integrity: sha512-zDWS+Rb1E8BlqqhALSt9kUhss8Qq4nN3iof3gsOdyINksElaPyNBtKUMTR62qhvgVWR0CqCX7sdnKe4MnUbFEA==}
     engines: {node: '>=4'}
     dependencies:
       cross-spawn: 5.1.0
@@ -2398,7 +2548,7 @@ packages:
     dev: true
 
   /expand-brackets/2.1.4:
-    resolution: {integrity: sha1-t3c14xXOMPa27/D4OwQVGiJEliI=}
+    resolution: {integrity: sha512-w/ozOKR9Obk3qoWeY/WDi6MFta9AoMR+zud60mdnbniMcBxRuFJyDt2LdX/14A1UABeqk+Uk+LDfUpvoGKppZA==}
     engines: {node: '>=0.10.0'}
     dependencies:
       debug: 2.6.9
@@ -2413,21 +2563,21 @@ packages:
     dev: true
 
   /expand-tilde/2.0.2:
-    resolution: {integrity: sha1-l+gBqgUt8CRU3kawK/YhZCzchQI=}
+    resolution: {integrity: sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==}
     engines: {node: '>=0.10.0'}
     dependencies:
       homedir-polyfill: 1.0.3
     dev: true
 
   /extend-shallow/2.0.1:
-    resolution: {integrity: sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=}
+    resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-extendable: 0.1.1
     dev: true
 
   /extend-shallow/3.0.2:
-    resolution: {integrity: sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=}
+    resolution: {integrity: sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==}
     engines: {node: '>=0.10.0'}
     dependencies:
       assign-symbols: 1.0.0
@@ -2486,11 +2636,11 @@ packages:
     dev: true
 
   /fast-levenshtein/2.0.6:
-    resolution: {integrity: sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=}
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
     dev: true
 
   /fd-slicer/1.1.0:
-    resolution: {integrity: sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=}
+    resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
     dependencies:
       pend: 1.2.0
     dev: true
@@ -2500,7 +2650,7 @@ packages:
     dev: true
 
   /figures/2.0.0:
-    resolution: {integrity: sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=}
+    resolution: {integrity: sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==}
     engines: {node: '>=4'}
     dependencies:
       escape-string-regexp: 1.0.5
@@ -2523,7 +2673,7 @@ packages:
     optional: true
 
   /fill-range/4.0.0:
-    resolution: {integrity: sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=}
+    resolution: {integrity: sha512-VcpLTWqWDiTerugjj8e3+esbg+skS3M9e54UuR3iCeIDMXCLTsAH8hTSzDQU/X6/6t3eYkOKoZSef2PlU6U1XQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       extend-shallow: 2.0.1
@@ -2584,7 +2734,7 @@ packages:
     dev: true
 
   /find-up/2.1.0:
-    resolution: {integrity: sha1-RdG35QbHF93UgndaK3eSCjwMV6c=}
+    resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==}
     engines: {node: '>=4'}
     dependencies:
       locate-path: 2.0.0
@@ -2634,8 +2784,8 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
-  /follow-redirects/1.15.0:
-    resolution: {integrity: sha512-aExlJShTV4qOUOL7yF1U5tvLCB0xQuudbf6toyYA0E/acBNw71mvjFTnLaRp50aQaYocMR0a/RMMBIHeZnGyjQ==}
+  /follow-redirects/1.15.1:
+    resolution: {integrity: sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA==}
     engines: {node: '>=4.0'}
     peerDependencies:
       debug: '*'
@@ -2645,7 +2795,7 @@ packages:
     dev: true
 
   /for-in/1.0.2:
-    resolution: {integrity: sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=}
+    resolution: {integrity: sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -2659,14 +2809,14 @@ packages:
     dev: true
 
   /fragment-cache/0.2.1:
-    resolution: {integrity: sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=}
+    resolution: {integrity: sha512-GMBAbW9antB8iZRHLoGw0b3HANt57diZYFO/HL1JGIC1MjKrdmhxvrJbupnVvpys0zsz7yBApXdQyfepKly2kA==}
     engines: {node: '>=0.10.0'}
     dependencies:
       map-cache: 0.2.2
     dev: true
 
   /from2/2.3.0:
-    resolution: {integrity: sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=}
+    resolution: {integrity: sha512-OMcX/4IC/uqEPVgGeyfN22LJk6AZrMkRZHxcHBMBvHScDGgwTm2GT2Wkgtocyd3JfZffjj2kYUDXXII0Fk9W0g==}
     dependencies:
       inherits: 2.0.4
       readable-stream: 2.3.7
@@ -2704,7 +2854,7 @@ packages:
     dev: true
 
   /fs-write-stream-atomic/1.0.10:
-    resolution: {integrity: sha1-tH31NJPvkR33VzHnCp3tAYnbQMk=}
+    resolution: {integrity: sha512-gehEzmPn2nAwr39eay+x3X34Ra+M2QlVUTLhkXPjWdeO8RF9kszk116avgBJM3ZyNHgHXBNx+VmPaFC36k0PzA==}
     dependencies:
       graceful-fs: 4.2.10
       iferr: 0.1.5
@@ -2713,7 +2863,7 @@ packages:
     dev: true
 
   /fs.realpath/1.0.0:
-    resolution: {integrity: sha1-FQStJSMVjKpA20onh8sBQRmU6k8=}
+    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
     dev: true
 
   /fsevents/1.2.13:
@@ -2724,7 +2874,7 @@ packages:
     requiresBuild: true
     dependencies:
       bindings: 1.5.0
-      nan: 2.15.0
+      nan: 2.16.0
     dev: true
     optional: true
 
@@ -2732,11 +2882,17 @@ packages:
     resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
     os: [darwin]
+    requiresBuild: true
     dev: true
     optional: true
 
   /function-bind/1.1.1:
     resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==}
+
+  /generic-names/4.0.0:
+    resolution: {integrity: sha512-ySFolZQfw9FoDb3ed9d80Cm9f0+r7qj+HJkWjeD9RBfpxEVTlVhol+gvaQB/78WbwYfbnNh8nWHHBSlg072y6A==}
+    dependencies:
+      loader-utils: 3.2.0
     dev: true
 
   /get-caller-file/2.0.5:
@@ -2745,7 +2901,7 @@ packages:
     dev: true
 
   /get-func-name/2.0.0:
-    resolution: {integrity: sha1-6td0q+5y4gQJQzoGY2YCPdaIekE=}
+    resolution: {integrity: sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==}
     dev: true
 
   /get-intrinsic/1.1.1:
@@ -2768,7 +2924,7 @@ packages:
     dev: true
 
   /get-stream/3.0.0:
-    resolution: {integrity: sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=}
+    resolution: {integrity: sha512-GlhdIUuVakc8SJ6kK0zAFbiGzRFzNnY4jUuEbV9UROo4Y+0Ny4fjvcZFVTeDA4odpFyOQzaw6hXukJSq/f28sQ==}
     engines: {node: '>=4'}
     dev: true
 
@@ -2785,7 +2941,7 @@ packages:
     dev: true
 
   /get-value/2.0.6:
-    resolution: {integrity: sha1-3BXKHGcjh8p2vTesCjlbogQqLCg=}
+    resolution: {integrity: sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -2802,7 +2958,7 @@ packages:
     dev: true
 
   /git-remote-origin-url/2.0.0:
-    resolution: {integrity: sha1-UoJlna4hBxRaERJhEq0yFuxfpl8=}
+    resolution: {integrity: sha512-eU+GGrZgccNJcsDH5LkXR3PB9M958hxc7sbA8DFJjrv9j4L2P/eZfKhM+QD6wyzpiv+b1BpK0XrYCxkovtjSLw==}
     engines: {node: '>=4'}
     dependencies:
       gitconfiglocal: 1.0.0
@@ -2819,13 +2975,13 @@ packages:
     dev: true
 
   /gitconfiglocal/1.0.0:
-    resolution: {integrity: sha1-QdBF84UaXqiPA/JMocYXgRRGS5s=}
+    resolution: {integrity: sha512-spLUXeTAVHxDtKsJc8FkFVgFtMdEN9qPGpL23VfSHx4fP4+Ds097IXLvymbnDH8FnmxX5Nr9bPw3A+AQ6mWEaQ==}
     dependencies:
       ini: 1.3.8
     dev: true
 
   /glob-parent/3.1.0:
-    resolution: {integrity: sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=}
+    resolution: {integrity: sha512-E8Ak/2+dZY6fnzlR7+ueWvhsH1SjHr4jjss4YS/h4py44jY9MhK/VFdaZJAWDz6BbL21KeteKxFSFpq8OS5gVA==}
     dependencies:
       is-glob: 3.1.0
       path-dirname: 1.0.2
@@ -2862,7 +3018,7 @@ packages:
     dev: true
 
   /global-dirs/0.1.1:
-    resolution: {integrity: sha1-sxnA3UYH81PzvpzKTHL8FIxJ9EU=}
+    resolution: {integrity: sha512-NknMLn7F2J7aflwFOlGdNIuCDpN3VGoSoB+aap3KABFWbHVn1TCgFC+np23J8W2BiZbjfEw3BFBycSMv1AFblg==}
     engines: {node: '>=4'}
     dependencies:
       ini: 1.3.8
@@ -2879,7 +3035,7 @@ packages:
     dev: true
 
   /global-prefix/1.0.2:
-    resolution: {integrity: sha1-2/dDxsFJklk8ZVVoy2btMsASLr4=}
+    resolution: {integrity: sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       expand-tilde: 2.0.2
@@ -2912,22 +3068,28 @@ packages:
     dev: true
 
   /has-flag/3.0.0:
-    resolution: {integrity: sha1-tdRU3CGZriJWmfNGfloH87lVuv0=}
+    resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
     engines: {node: '>=4'}
     dev: true
 
   /has-flag/4.0.0:
     resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
     engines: {node: '>=8'}
-    dev: true
 
   /has-symbols/1.0.3:
     resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==}
     engines: {node: '>= 0.4'}
     dev: true
 
+  /has-tostringtag/1.0.0:
+    resolution: {integrity: sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      has-symbols: 1.0.3
+    dev: true
+
   /has-value/0.3.1:
-    resolution: {integrity: sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8=}
+    resolution: {integrity: sha512-gpG936j8/MzaeID5Yif+577c17TxaDmhuyVgSwtnL/q8UUTySg8Mecb+8Cf1otgLoD7DDH75axp86ER7LFsf3Q==}
     engines: {node: '>=0.10.0'}
     dependencies:
       get-value: 2.0.6
@@ -2936,7 +3098,7 @@ packages:
     dev: true
 
   /has-value/1.0.0:
-    resolution: {integrity: sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc=}
+    resolution: {integrity: sha512-IBXk4GTsLYdQ7Rvt+GRBrFSVEkmuOUy4re0Xjd9kJSUQpnTrWR4/y9RpfexN9vkAPMFuQoeWKwqzPozRTlasGw==}
     engines: {node: '>=0.10.0'}
     dependencies:
       get-value: 2.0.6
@@ -2945,12 +3107,12 @@ packages:
     dev: true
 
   /has-values/0.1.4:
-    resolution: {integrity: sha1-bWHeldkd/Km5oCCJrThL/49it3E=}
+    resolution: {integrity: sha512-J8S0cEdWuQbqD9//tlZxiMuMNmxB8PlEwvYwuxsTmR1G5RXUePEX/SJn7aD0GMLieuZYSwNH0cQuJGwnYunXRQ==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /has-values/1.0.0:
-    resolution: {integrity: sha1-lbC2P+whRmGab+V/51Yo1aOe/k8=}
+    resolution: {integrity: sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-number: 3.0.0
@@ -2962,7 +3124,6 @@ packages:
     engines: {node: '>= 0.4.0'}
     dependencies:
       function-bind: 1.1.1
-    dev: true
 
   /hash-base/3.1.0:
     resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==}
@@ -2975,7 +3136,6 @@ packages:
 
   /hash-sum/2.0.0:
     resolution: {integrity: sha512-WdZTbAByD+pHfl/g9QSsBIIwy8IT+EsPiKDs0KNX+zSHhdDLFKdZu0BQHljvO+0QI/BasbMSUa8wYNCZTvhslg==}
-    dev: true
 
   /hash.js/1.1.7:
     resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==}
@@ -2987,10 +3147,9 @@ packages:
   /he/1.2.0:
     resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
     hasBin: true
-    dev: true
 
   /hmac-drbg/1.0.1:
-    resolution: {integrity: sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=}
+    resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==}
     dependencies:
       hash.js: 1.1.7
       minimalistic-assert: 1.0.1
@@ -3049,14 +3208,14 @@ packages:
     engines: {node: '>=8.0.0'}
     dependencies:
       eventemitter3: 4.0.7
-      follow-redirects: 1.15.0
+      follow-redirects: 1.15.1
       requires-port: 1.0.0
     transitivePeerDependencies:
       - debug
     dev: true
 
   /https-browserify/1.0.0:
-    resolution: {integrity: sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=}
+    resolution: {integrity: sha512-J+FkSdyD+0mA0N+81tMotaRMfSL9SGi+xpD3T6YApKsc3bGSXJlfXri3VyFOeYkfLRQisDk1W+jIFFKBeUBbBg==}
     dev: true
 
   /https-proxy-agent/5.0.1:
@@ -3088,12 +3247,29 @@ packages:
       safer-buffer: 2.1.2
     dev: true
 
+  /icss-replace-symbols/1.1.0:
+    resolution: {integrity: sha512-chIaY3Vh2mh2Q3RGXttaDIzeiPvaVXJ+C4DAh/w3c37SKZ/U6PGMmuicR2EQQp9bKG8zLMCl7I+PtIoOOPp8Gg==}
+    dev: true
+
+  /icss-utils/5.1.0_postcss@8.4.14:
+    resolution: {integrity: sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+    dependencies:
+      postcss: 8.4.14
+    dev: true
+
   /ieee754/1.2.1:
     resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
     dev: true
 
   /iferr/0.1.5:
-    resolution: {integrity: sha1-xg7taebY/bazEEofy8ocGS3FtQE=}
+    resolution: {integrity: sha512-DUNFN5j7Tln0D+TxzloUjKB+CtVu6myn0JEFak6dG18mNt9YkQ6lzGCdafwofISZ1lLF3xRHJ98VKy9ynkcFaA==}
+    dev: true
+
+  /immutable/4.1.0:
+    resolution: {integrity: sha512-oNkuqVTA8jqG1Q6c+UglTOD1xhC1BtjKI7XkCXRkZHrN5m18/XsnUp8Q89GkQO/z+0WjonSvl0FLhDYftp46nQ==}
     dev: true
 
   /import-fresh/3.3.0:
@@ -3111,7 +3287,7 @@ packages:
     dev: true
 
   /imurmurhash/0.1.4:
-    resolution: {integrity: sha1-khi5srkoojixPcT7a21XbyMUU+o=}
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
     engines: {node: '>=0.8.19'}
     dev: true
 
@@ -3132,11 +3308,11 @@ packages:
     dev: true
 
   /inherits/2.0.1:
-    resolution: {integrity: sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=}
+    resolution: {integrity: sha512-8nWq2nLTAwd02jTqJExUYFSD/fKq6VH9Y/oG2accc/kdI0V98Bag8d5a4gi3XHz73rDWa2PvTtvcWYquKqSENA==}
     dev: true
 
   /inherits/2.0.3:
-    resolution: {integrity: sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=}
+    resolution: {integrity: sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==}
     dev: true
 
   /inherits/2.0.4:
@@ -3172,7 +3348,7 @@ packages:
     dev: true
 
   /is-accessor-descriptor/0.1.6:
-    resolution: {integrity: sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=}
+    resolution: {integrity: sha512-e1BM1qnDbMRG3ll2U9dSK0UMHuWOs3pY3AtcFsmvwPtKL3MML/Q86i+GilLfvqEs4GW+ExB91tQ3Ig9noDIZ+A==}
     engines: {node: '>=0.10.0'}
     dependencies:
       kind-of: 3.2.2
@@ -3186,11 +3362,11 @@ packages:
     dev: true
 
   /is-arrayish/0.2.1:
-    resolution: {integrity: sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=}
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
     dev: true
 
   /is-binary-path/1.0.1:
-    resolution: {integrity: sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=}
+    resolution: {integrity: sha512-9fRVlXc0uCxEDj1nQzaWONSpbTfx0FmJfzHF7pwlI8DkWGoHBBea4Pg5Ky0ojwwxQmnSifgbKkI06Qv0Ljgj+Q==}
     engines: {node: '>=0.10.0'}
     dependencies:
       binary-extensions: 1.13.1
@@ -3226,10 +3402,9 @@ packages:
     resolution: {integrity: sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==}
     dependencies:
       has: 1.0.3
-    dev: true
 
   /is-data-descriptor/0.1.4:
-    resolution: {integrity: sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=}
+    resolution: {integrity: sha512-+w9D5ulSoBNlmw9OHn3U2v51SyoCd0he+bB3xMl62oijhrspxowjU+AIcDY0N3iEJbUEkB15IlMASQsxYigvXg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       kind-of: 3.2.2
@@ -3260,8 +3435,15 @@ packages:
       kind-of: 6.0.3
     dev: true
 
+  /is-expression/4.0.0:
+    resolution: {integrity: sha512-zMIXX63sxzG3XrkHkrAPvm/OVZVSCPNkwMHU8oTX7/U3AL78I0QXCEICXUM13BIa8TYGZ68PiTKfQz3yaTNr4A==}
+    dependencies:
+      acorn: 7.4.1
+      object-assign: 4.1.1
+    dev: true
+
   /is-extendable/0.1.1:
-    resolution: {integrity: sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=}
+    resolution: {integrity: sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -3273,12 +3455,12 @@ packages:
     dev: true
 
   /is-extglob/2.1.1:
-    resolution: {integrity: sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=}
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /is-fullwidth-code-point/2.0.0:
-    resolution: {integrity: sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=}
+    resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==}
     engines: {node: '>=4'}
     dev: true
 
@@ -3293,7 +3475,7 @@ packages:
     dev: true
 
   /is-glob/3.1.0:
-    resolution: {integrity: sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=}
+    resolution: {integrity: sha512-UFpDDrPgM6qpnFNI+rh/p3bUaq9hKLZN8bMUWzxmcnZVS3omf4IPK+BrewlnWjO1WmUsMYuSjKh4UJuV4+Lqmw==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-extglob: 2.1.1
@@ -3308,11 +3490,11 @@ packages:
     dev: true
 
   /is-module/1.0.0:
-    resolution: {integrity: sha1-Mlj7afeMFNW4FdZkM2tM/7ZEFZE=}
+    resolution: {integrity: sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==}
     dev: true
 
   /is-number/3.0.0:
-    resolution: {integrity: sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=}
+    resolution: {integrity: sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       kind-of: 3.2.2
@@ -3329,7 +3511,7 @@ packages:
     dev: true
 
   /is-plain-obj/1.1.0:
-    resolution: {integrity: sha1-caUMhCnfync8kqOQpKA7OfzVHT4=}
+    resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -3344,14 +3526,26 @@ packages:
     resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
     dev: true
 
+  /is-promise/2.2.2:
+    resolution: {integrity: sha512-+lP4/6lKUBfQjZ2pdxThZvLUAafmZb8OAxFb8XXtiQmS35INgr85hdOGoEs124ez1FCnZJt6jau/T+alh58QFQ==}
+    dev: true
+
   /is-reference/1.2.1:
     resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
     dependencies:
       '@types/estree': 0.0.51
     dev: true
 
+  /is-regex/1.1.4:
+    resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.2
+      has-tostringtag: 1.0.0
+    dev: true
+
   /is-stream/1.1.0:
-    resolution: {integrity: sha1-EtSj3U5o4Lec6428hBc66A2RykQ=}
+    resolution: {integrity: sha512-uQPm8kcs47jx38atAcWTVxyltQYoPT68y9aWYdV6yWXSyW8mzSat0TL6CiWdZeCdF3KrAvpVtnHbTv4RN+rqdQ==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -3361,14 +3555,14 @@ packages:
     dev: true
 
   /is-text-path/1.0.1:
-    resolution: {integrity: sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4=}
+    resolution: {integrity: sha512-xFuJpne9oFz5qDaodwmmG08e3CawH/2ZV8Qqza1Ko7Sk8POWbkRdwIoAWVhqvq0XeUzANEhKo2n0IXUGBm7A/w==}
     engines: {node: '>=0.10.0'}
     dependencies:
       text-extensions: 1.9.0
     dev: true
 
   /is-utf8/0.2.1:
-    resolution: {integrity: sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=}
+    resolution: {integrity: sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==}
     dev: true
 
   /is-windows/1.0.2:
@@ -3377,12 +3571,12 @@ packages:
     dev: true
 
   /is-wsl/1.1.0:
-    resolution: {integrity: sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0=}
+    resolution: {integrity: sha512-gfygJYZ2gLTDlmbWMI0CE2MwnFzSN/2SZfkMlItC4K/JBlsWVDB0bO6XhqcY13YXE7iMcAJnzTCJjPiTeJJ0Mw==}
     engines: {node: '>=4'}
     dev: true
 
   /isarray/1.0.0:
-    resolution: {integrity: sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=}
+    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
     dev: true
 
   /isbinaryfile/4.0.10:
@@ -3391,18 +3585,18 @@ packages:
     dev: true
 
   /isexe/2.0.0:
-    resolution: {integrity: sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=}
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
     dev: true
 
   /isobject/2.1.0:
-    resolution: {integrity: sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=}
+    resolution: {integrity: sha512-+OUdGJlgjOBZDfxnDjYYG6zp487z0JGNQq3cYQYg5f5hKR+syHMsaztzGeml/4kGG55CSpKSpWTY+jYGgsHLgA==}
     engines: {node: '>=0.10.0'}
     dependencies:
       isarray: 1.0.0
     dev: true
 
   /isobject/3.0.1:
-    resolution: {integrity: sha1-TkMekrEalzFjaqH5yNHMvP2reN8=}
+    resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -3414,6 +3608,10 @@ packages:
     resolution: {integrity: sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==}
     dev: true
 
+  /js-stringify/1.0.2:
+    resolution: {integrity: sha512-rtS5ATOo2Q5k1G+DADISilDA6lv79zIiwFd6CcjuIxGKLFm5C+RLImRscVap9k55i+MOZwgliw+NejvkLuGD5g==}
+    dev: true
+
   /js-tokens/4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
     dev: true
@@ -3452,7 +3650,7 @@ packages:
       whatwg-encoding: 2.0.0
       whatwg-mimetype: 3.0.0
       whatwg-url: 10.0.0
-      ws: 8.6.0
+      ws: 8.7.0
       xml-name-validator: 4.0.0
     transitivePeerDependencies:
       - bufferutil
@@ -3473,7 +3671,7 @@ packages:
     dev: true
 
   /json-stringify-safe/5.0.1:
-    resolution: {integrity: sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=}
+    resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==}
     dev: true
 
   /json5/1.0.1:
@@ -3484,7 +3682,7 @@ packages:
     dev: true
 
   /jsonfile/4.0.0:
-    resolution: {integrity: sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=}
+    resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
     optionalDependencies:
       graceful-fs: 4.2.10
     dev: true
@@ -3498,10 +3696,17 @@ packages:
     dev: true
 
   /jsonparse/1.3.1:
-    resolution: {integrity: sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=}
+    resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==}
     engines: {'0': node >= 0.2.0}
     dev: true
 
+  /jstransformer/1.0.0:
+    resolution: {integrity: sha1-7Yvwkh4vPx7U1cGkT2hwntJHIsM=}
+    dependencies:
+      is-promise: 2.2.2
+      promise: 7.3.1
+    dev: true
+
   /karma-chrome-launcher/3.1.1:
     resolution: {integrity: sha512-hsIglcq1vtboGPAN+DGCISCFOxW+ZVnIqhDQcCMqqCp+4dmJ0Qpq5QAjkbA0X2L9Mi6OBkHi2Srrbmm7pUKkzQ==}
     dependencies:
@@ -3516,13 +3721,13 @@ packages:
       resolve: 1.22.0
     dev: true
 
-  /karma-esbuild/2.2.4_esbuild@0.14.39:
+  /karma-esbuild/2.2.4_esbuild@0.14.42:
     resolution: {integrity: sha512-nt5+AJ0iFpgJXboBmXvwjM5LYTqTmFA9NuNGj9A442gCMJHwL4Eft4JUBVRc7ORSPoJAQ26Kgf5252Xt6GbkRw==}
     peerDependencies:
       esbuild: '>=0.8.45'
     dependencies:
       chokidar: 3.5.3
-      esbuild: 0.14.39
+      esbuild: 0.14.42
       source-map: 0.6.1
     dev: true
 
@@ -3553,7 +3758,7 @@ packages:
       http-proxy: 1.18.1
       isbinaryfile: 4.0.10
       lodash: 4.17.21
-      log4js: 6.5.0
+      log4js: 6.5.2
       mime: 2.6.0
       minimatch: 3.1.2
       mkdirp: 0.5.6
@@ -3573,14 +3778,14 @@ packages:
     dev: true
 
   /kind-of/3.2.2:
-    resolution: {integrity: sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=}
+    resolution: {integrity: sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-buffer: 1.1.6
     dev: true
 
   /kind-of/4.0.0:
-    resolution: {integrity: sha1-IIE989cSkosgc3hpGkUGb65y3Vc=}
+    resolution: {integrity: sha512-24XsCxmEbRwEDbz/qz3stgin8TTzZ1ESR56OMCN0ujYg+vRutNSiOj9bHH9u85DKgXguraugV5sFuvbD4FW/hw==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-buffer: 1.1.6
@@ -3597,15 +3802,15 @@ packages:
     dev: true
 
   /levn/0.3.0:
-    resolution: {integrity: sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=}
+    resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==}
     engines: {node: '>= 0.8.0'}
     dependencies:
       prelude-ls: 1.1.2
       type-check: 0.3.2
     dev: true
 
-  /lilconfig/2.0.4:
-    resolution: {integrity: sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA==}
+  /lilconfig/2.0.5:
+    resolution: {integrity: sha512-xaYmXZtTHPAw5m+xLN8ab9C+3a8YmV3asNSPOATITbtwrfbwaLJj8h66H1WMIpALCkqsIzK3h7oQ+PdX+LQ9Eg==}
     engines: {node: '>=10'}
     dev: true
 
@@ -3613,21 +3818,21 @@ packages:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
     dev: true
 
-  /lint-staged/12.4.1:
-    resolution: {integrity: sha512-PTXgzpflrQ+pODQTG116QNB+Q6uUTDg5B5HqGvNhoQSGt8Qy+MA/6zSnR8n38+sxP5TapzeQGTvoKni0KRS8Vg==}
+  /lint-staged/12.4.3:
+    resolution: {integrity: sha512-eH6SKOmdm/ZwCRMTZAmM3q3dPkpq6vco/BfrOw8iGun4Xs/thYegPD/MLIwKO+iPkzibkLJuQcRhRLXKvaKreg==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     hasBin: true
     dependencies:
       cli-truncate: 3.1.0
       colorette: 2.0.16
-      commander: 8.3.0
+      commander: 9.3.0
       debug: 4.3.4_supports-color@9.2.2
       execa: 5.1.1
-      lilconfig: 2.0.4
+      lilconfig: 2.0.5
       listr2: 4.0.5
       micromatch: 4.0.5
       normalize-path: 3.0.0
-      object-inspect: 1.12.0
+      object-inspect: 1.12.2
       pidtree: 0.5.0
       string-argv: 0.3.1
       supports-color: 9.2.2
@@ -3656,7 +3861,7 @@ packages:
     dev: true
 
   /load-json-file/4.0.0:
-    resolution: {integrity: sha1-L19Fq5HjMhYjT9U62rZo607AmTs=}
+    resolution: {integrity: sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==}
     engines: {node: '>=4'}
     dependencies:
       graceful-fs: 4.2.10
@@ -3679,13 +3884,18 @@ packages:
       json5: 1.0.1
     dev: true
 
+  /loader-utils/3.2.0:
+    resolution: {integrity: sha512-HVl9ZqccQihZ7JM85dco1MvO9G+ONvxoGa9rkhzFsneGLKSUg1gJf9bWzhRhcvm2qChhWpebQhP44qxjKIUCaQ==}
+    engines: {node: '>= 12.13.0'}
+    dev: true
+
   /local-pkg/0.4.1:
     resolution: {integrity: sha512-lL87ytIGP2FU5PWwNDo0w3WhIo2gopIAxPg9RxDYF7m4rr5ahuZxP22xnJHIvaLTe4Z9P6uKKY2UHiwyB4pcrw==}
     engines: {node: '>=14'}
     dev: true
 
   /locate-path/2.0.0:
-    resolution: {integrity: sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=}
+    resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==}
     engines: {node: '>=4'}
     dependencies:
       p-locate: 2.0.0
@@ -3715,7 +3925,11 @@ packages:
     dev: true
 
   /lodash._reinterpolate/3.0.0:
-    resolution: {integrity: sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0=}
+    resolution: {integrity: sha512-xYHt68QRoYGjeeM/XOE1uJtvXQAgvszfBhjV4yvsQH0u2i9I6cI6c6/eG4Hh3UAOVn0y/xAXwmTzEay49Q//HA==}
+    dev: false
+
+  /lodash.camelcase/4.3.0:
+    resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==}
     dev: true
 
   /lodash.get/4.4.2:
@@ -3727,15 +3941,11 @@ packages:
     dev: true
 
   /lodash.ismatch/4.4.0:
-    resolution: {integrity: sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc=}
+    resolution: {integrity: sha512-fPMfXjGQEV9Xsq/8MTSgUf255gawYRbjwMyDbcvDhXgV7enSZA0hynz6vMPnpAb5iONEzBHBPsT+0zes5Z301g==}
     dev: true
 
   /lodash.map/4.6.0:
-    resolution: {integrity: sha1-dx7Hg540c9nEzeKLGTlMNWL09tM=}
-    dev: true
-
-  /lodash.sortby/4.7.0:
-    resolution: {integrity: sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=}
+    resolution: {integrity: sha512-worNHGKLDetmcEYDvh2stPCrrQRkP20E4l0iIS7F8EvzMqBBi7ltvFN5m1HvTf1P7Jk1txKhvFcmYsCr8O2F1Q==}
     dev: true
 
   /lodash.template/4.5.0:
@@ -3743,17 +3953,17 @@ packages:
     dependencies:
       lodash._reinterpolate: 3.0.0
       lodash.templatesettings: 4.2.0
-    dev: true
+    dev: false
 
   /lodash.templatesettings/4.2.0:
     resolution: {integrity: sha512-stgLz+i3Aa9mZgnjr/O+v9ruKZsPsndy7qPZOchbqk2cnTU1ZaldKK+v7m54WoKIyxiuMZTKT2H81F8BeAc3ZQ==}
     dependencies:
       lodash._reinterpolate: 3.0.0
-    dev: true
+    dev: false
 
   /lodash.uniq/4.5.0:
-    resolution: {integrity: sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=}
-    dev: true
+    resolution: {integrity: sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==}
+    dev: false
 
   /lodash/4.17.21:
     resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
@@ -3769,21 +3979,21 @@ packages:
       wrap-ansi: 6.2.0
     dev: true
 
-  /log4js/6.5.0:
-    resolution: {integrity: sha512-VT8b+k4nS7feV3p2nTdI5UqO2+7KRi4sfb6YKlnZlQU0d1DnvA18dvPhxKElgVTRTjS3GtChvvR67yMpp/xAfQ==}
+  /log4js/6.5.2:
+    resolution: {integrity: sha512-DXtpNtt+KDOMT7RHUDIur/WsSA3rntlUh9Zg4XCdV42wUuMmbFkl38+LZ92Z5QvQA7mD5kAVkLiBSEH/tvUB8A==}
     engines: {node: '>=8.0'}
     dependencies:
       date-format: 4.0.10
       debug: 4.3.4
       flatted: 3.2.5
       rfdc: 1.3.0
-      streamroller: 3.1.0
+      streamroller: 3.1.1
     transitivePeerDependencies:
       - supports-color
     dev: true
 
   /longest/2.0.1:
-    resolution: {integrity: sha1-eB4YMpaqlPbU2RbcM10NF676I/g=}
+    resolution: {integrity: sha512-Ajzxb8CM6WAnFjgiloPsI3bF+WCxcvhdIG3KNA2KN962+tdBsHcuQ4k4qX/EcS/2CRkcc0iAkR956Nib6aXU/Q==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -3813,11 +4023,6 @@ packages:
       yallist: 4.0.0
     dev: true
 
-  /lru-cache/7.10.1:
-    resolution: {integrity: sha512-BQuhQxPuRl79J5zSXRP+uNzPOyZw2oFI9JLRQ80XswSvg21KMKNtQza9eF42rfI/3Z40RvzBdXgziEkudzjo8A==}
-    engines: {node: '>=12'}
-    dev: true
-
   /magic-string/0.25.9:
     resolution: {integrity: sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==}
     dependencies:
@@ -3844,12 +4049,12 @@ packages:
     dev: true
 
   /map-cache/0.2.2:
-    resolution: {integrity: sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8=}
+    resolution: {integrity: sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /map-obj/1.0.1:
-    resolution: {integrity: sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0=}
+    resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -3859,7 +4064,7 @@ packages:
     dev: true
 
   /map-visit/1.0.0:
-    resolution: {integrity: sha1-7Nyo8TFE5mDxtb1B8S80edmN+48=}
+    resolution: {integrity: sha512-4y7uGv8bd2WdM9vpQsiQNo41Ln1NvhvDRuVt0k2JZQ+ezN2uaQes7lZeZ+QQUHOLQAtDaBJ+7wCbi+ab/KFs+w==}
     engines: {node: '>=0.10.0'}
     dependencies:
       object-visit: 1.0.1
@@ -3885,7 +4090,7 @@ packages:
     dev: true
 
   /memory-fs/0.4.1:
-    resolution: {integrity: sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=}
+    resolution: {integrity: sha512-cda4JKCxReDXFXRqOHPQscuIYg1PvxbE2S2GP45rnwfEK+vZaXC8C1OFvdHIbgw0DLzowXGVoxLaAmlgRy14GQ==}
     dependencies:
       errno: 0.1.8
       readable-stream: 2.3.7
@@ -3916,6 +4121,12 @@ packages:
       yargs-parser: 20.2.9
     dev: true
 
+  /merge-source-map/1.1.0:
+    resolution: {integrity: sha512-Qkcp7P2ygktpMPh2mCQZaf3jhN6D3Z/qVZHSdWvQ+2Ef5HgRAPBO57A77+ENm0CPx2+1Ce/MYKi3ymqdfuqibw==}
+    dependencies:
+      source-map: 0.6.1
+    dev: true
+
   /merge-stream/2.0.0:
     resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
     dev: true
@@ -3999,7 +4210,7 @@ packages:
     dev: true
 
   /minimalistic-crypto-utils/1.0.1:
-    resolution: {integrity: sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=}
+    resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==}
     dev: true
 
   /minimatch/3.1.2:
@@ -4066,7 +4277,7 @@ packages:
     dev: true
 
   /move-concurrently/1.0.1:
-    resolution: {integrity: sha1-viwAX9oy4LKa8fBdfEszIUxwH5I=}
+    resolution: {integrity: sha512-hdrFxZOycD/g6A6SoI2bB5NA/5NEqD0569+S47WZhPvm46sD50ZHdYaFmnua5lndde9rCHGjmfK7Z8BuCt/PcQ==}
     dependencies:
       aproba: 1.2.0
       copy-concurrently: 1.0.5
@@ -4088,8 +4299,8 @@ packages:
     resolution: {integrity: sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=}
     dev: true
 
-  /nan/2.15.0:
-    resolution: {integrity: sha512-8ZtvEnA2c5aYCZYd1cvgdnU6cqwixRoYg70xPLWUws5ORTa/lnw+u4amixRS/Ac5U5mQVgp9pnlSUnbNWFaWZQ==}
+  /nan/2.16.0:
+    resolution: {integrity: sha512-UdAqHyFngu7TfQKsCBgAA6pWDkT8MAO7d0jyOecVhN5354xbLqdn8mV9Tat9gepAupm0bt2DbeaSC8vS52MuFA==}
     dev: true
     optional: true
 
@@ -4097,7 +4308,6 @@ packages:
     resolution: {integrity: sha512-MqBkQh/OHTS2egovRtLk45wEyNXwF+cokD+1YPf9u5VfJiRdAiRwB2froX5Co9Rh20xs4siNPm8naNotSD6RBw==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
-    dev: true
 
   /nanomatch/1.2.13:
     resolution: {integrity: sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==}
@@ -4236,8 +4446,8 @@ packages:
       kind-of: 3.2.2
     dev: true
 
-  /object-inspect/1.12.0:
-    resolution: {integrity: sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g==}
+  /object-inspect/1.12.2:
+    resolution: {integrity: sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ==}
     dev: true
 
   /object-visit/1.0.1:
@@ -4489,7 +4699,6 @@ packages:
 
   /path-parse/1.0.7:
     resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
-    dev: true
 
   /path-strip-sep/1.0.12:
     resolution: {integrity: sha512-EJZSC5WBjVlA9XHLCiluiyisYg6yzeMJ4nY3BQVCuedyEHA/I2crcHWdwuQ74h3V599U9nEbEZUTvvSxOK3vbQ==}
@@ -4531,7 +4740,6 @@ packages:
 
   /picocolors/1.0.0:
     resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==}
-    dev: true
 
   /picomatch/2.3.1:
     resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
@@ -4585,6 +4793,75 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /postcss-modules-extract-imports/3.0.0_postcss@8.4.14:
+    resolution: {integrity: sha512-bdHleFnP3kZ4NYDhuGlVK+CMrQ/pqUm8bx/oGL93K6gVwiclvX5x0n76fYMKuIGKzlABOy13zsvqjb0f92TEXw==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+    dependencies:
+      postcss: 8.4.14
+    dev: true
+
+  /postcss-modules-local-by-default/4.0.0_postcss@8.4.14:
+    resolution: {integrity: sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+    dependencies:
+      icss-utils: 5.1.0_postcss@8.4.14
+      postcss: 8.4.14
+      postcss-selector-parser: 6.0.10
+      postcss-value-parser: 4.2.0
+    dev: true
+
+  /postcss-modules-scope/3.0.0_postcss@8.4.14:
+    resolution: {integrity: sha512-hncihwFA2yPath8oZ15PZqvWGkWf+XUfQgUGamS4LqoP1anQLOsOJw0vr7J7IwLpoY9fatA2qiGUGmuZL0Iqlg==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+    dependencies:
+      postcss: 8.4.14
+      postcss-selector-parser: 6.0.10
+    dev: true
+
+  /postcss-modules-values/4.0.0_postcss@8.4.14:
+    resolution: {integrity: sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==}
+    engines: {node: ^10 || ^12 || >= 14}
+    peerDependencies:
+      postcss: ^8.1.0
+    dependencies:
+      icss-utils: 5.1.0_postcss@8.4.14
+      postcss: 8.4.14
+    dev: true
+
+  /postcss-modules/4.3.1_postcss@8.4.14:
+    resolution: {integrity: sha512-ItUhSUxBBdNamkT3KzIZwYNNRFKmkJrofvC2nWab3CPKhYBQ1f27XXh1PAPE27Psx58jeelPsxWB/+og+KEH0Q==}
+    peerDependencies:
+      postcss: ^8.0.0
+    dependencies:
+      generic-names: 4.0.0
+      icss-replace-symbols: 1.1.0
+      lodash.camelcase: 4.3.0
+      postcss: 8.4.14
+      postcss-modules-extract-imports: 3.0.0_postcss@8.4.14
+      postcss-modules-local-by-default: 4.0.0_postcss@8.4.14
+      postcss-modules-scope: 3.0.0_postcss@8.4.14
+      postcss-modules-values: 4.0.0_postcss@8.4.14
+      string-hash: 1.1.3
+    dev: true
+
+  /postcss-selector-parser/6.0.10:
+    resolution: {integrity: sha512-IQ7TZdoaqbT+LCpShg46jnZVlhWD2w6iQYAcYXfHARZ7X1t/UGhhceQDs5X0cGqKvYlHNOuv7Oa1xmb0oQuA3w==}
+    engines: {node: '>=4'}
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+    dev: true
+
+  /postcss-value-parser/4.2.0:
+    resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
+    dev: true
+
   /postcss/8.4.14:
     resolution: {integrity: sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==}
     engines: {node: ^10 || ^12 || >=14}
@@ -4592,7 +4869,6 @@ packages:
       nanoid: 3.3.4
       picocolors: 1.0.0
       source-map-js: 1.0.2
-    dev: true
 
   /prelude-ls/1.1.2:
     resolution: {integrity: sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=}
@@ -4630,6 +4906,12 @@ packages:
       bluebird: 3.7.2
     dev: true
 
+  /promise/7.3.1:
+    resolution: {integrity: sha512-nolQXZ/4L+bP/UGlkfaIujX9BKxGwmQ9OT4mOt5yvy8iK1h3wqTEJCijzGANTCCl9nWjY41juyAn2K3Q1hLLTg==}
+    dependencies:
+      asap: 2.0.6
+    dev: true
+
   /proxy-from-env/1.1.0:
     resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==}
     dev: true
@@ -4657,6 +4939,97 @@ packages:
       safe-buffer: 5.2.1
     dev: true
 
+  /pug-attrs/3.0.0:
+    resolution: {integrity: sha512-azINV9dUtzPMFQktvTXciNAfAuVh/L/JCl0vtPCwvOA21uZrC08K/UnmrL+SXGEVc1FwzjW62+xw5S/uaLj6cA==}
+    dependencies:
+      constantinople: 4.0.1
+      js-stringify: 1.0.2
+      pug-runtime: 3.0.1
+    dev: true
+
+  /pug-code-gen/3.0.2:
+    resolution: {integrity: sha512-nJMhW16MbiGRiyR4miDTQMRWDgKplnHyeLvioEJYbk1RsPI3FuA3saEP8uwnTb2nTJEKBU90NFVWJBk4OU5qyg==}
+    dependencies:
+      constantinople: 4.0.1
+      doctypes: 1.1.0
+      js-stringify: 1.0.2
+      pug-attrs: 3.0.0
+      pug-error: 2.0.0
+      pug-runtime: 3.0.1
+      void-elements: 3.1.0
+      with: 7.0.2
+    dev: true
+
+  /pug-error/2.0.0:
+    resolution: {integrity: sha512-sjiUsi9M4RAGHktC1drQfCr5C5eriu24Lfbt4s+7SykztEOwVZtbFk1RRq0tzLxcMxMYTBR+zMQaG07J/btayQ==}
+    dev: true
+
+  /pug-filters/4.0.0:
+    resolution: {integrity: sha512-yeNFtq5Yxmfz0f9z2rMXGw/8/4i1cCFecw/Q7+D0V2DdtII5UvqE12VaZ2AY7ri6o5RNXiweGH79OCq+2RQU4A==}
+    dependencies:
+      constantinople: 4.0.1
+      jstransformer: 1.0.0
+      pug-error: 2.0.0
+      pug-walk: 2.0.0
+      resolve: 1.22.0
+    dev: true
+
+  /pug-lexer/5.0.1:
+    resolution: {integrity: sha512-0I6C62+keXlZPZkOJeVam9aBLVP2EnbeDw3An+k0/QlqdwH6rv8284nko14Na7c0TtqtogfWXcRoFE4O4Ff20w==}
+    dependencies:
+      character-parser: 2.2.0
+      is-expression: 4.0.0
+      pug-error: 2.0.0
+    dev: true
+
+  /pug-linker/4.0.0:
+    resolution: {integrity: sha512-gjD1yzp0yxbQqnzBAdlhbgoJL5qIFJw78juN1NpTLt/mfPJ5VgC4BvkoD3G23qKzJtIIXBbcCt6FioLSFLOHdw==}
+    dependencies:
+      pug-error: 2.0.0
+      pug-walk: 2.0.0
+    dev: true
+
+  /pug-load/3.0.0:
+    resolution: {integrity: sha512-OCjTEnhLWZBvS4zni/WUMjH2YSUosnsmjGBB1An7CsKQarYSWQ0GCVyd4eQPMFJqZ8w9xgs01QdiZXKVjk92EQ==}
+    dependencies:
+      object-assign: 4.1.1
+      pug-walk: 2.0.0
+    dev: true
+
+  /pug-parser/6.0.0:
+    resolution: {integrity: sha512-ukiYM/9cH6Cml+AOl5kETtM9NR3WulyVP2y4HOU45DyMim1IeP/OOiyEWRr6qk5I5klpsBnbuHpwKmTx6WURnw==}
+    dependencies:
+      pug-error: 2.0.0
+      token-stream: 1.0.0
+    dev: true
+
+  /pug-runtime/3.0.1:
+    resolution: {integrity: sha512-L50zbvrQ35TkpHwv0G6aLSuueDRwc/97XdY8kL3tOT0FmhgG7UypU3VztfV/LATAvmUfYi4wNxSajhSAeNN+Kg==}
+    dev: true
+
+  /pug-strip-comments/2.0.0:
+    resolution: {integrity: sha512-zo8DsDpH7eTkPHCXFeAk1xZXJbyoTfdPlNR0bK7rpOMuhBYb0f5qUVCO1xlsitYd3w5FQTK7zpNVKb3rZoUrrQ==}
+    dependencies:
+      pug-error: 2.0.0
+    dev: true
+
+  /pug-walk/2.0.0:
+    resolution: {integrity: sha512-yYELe9Q5q9IQhuvqsZNwA5hfPkMJ8u92bQLIMcsMxf/VADjNtEYptU+inlufAFYcWdHlwNfZOEnOOQrZrcyJCQ==}
+    dev: true
+
+  /pug/3.0.2:
+    resolution: {integrity: sha512-bp0I/hiK1D1vChHh6EfDxtndHji55XP/ZJKwsRqrz6lRia6ZC2OZbdAymlxdVFwd1L70ebrVJw4/eZ79skrIaw==}
+    dependencies:
+      pug-code-gen: 3.0.2
+      pug-filters: 4.0.0
+      pug-lexer: 5.0.1
+      pug-linker: 4.0.0
+      pug-load: 3.0.0
+      pug-parser: 6.0.0
+      pug-runtime: 3.0.1
+      pug-strip-comments: 2.0.0
+    dev: true
+
   /pump/2.0.1:
     resolution: {integrity: sha512-ruPMNRkN3MHP1cWJc9OWr+T/xDP0jhXYCLfJcBuX54hhfIBnaQmAUMfDcG4DM5UMWByBbJY69QSphm3jtDKIkA==}
     dependencies:
@@ -4692,8 +5065,8 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /puppeteer/14.1.1:
-    resolution: {integrity: sha512-4dC6GYR5YlXTmNO3TbYEHTdVSdml1cVD2Ok/h/f/xSTp4ITVdbRWkMjiOaEKRAhtIl6GqaP7B89zx+hfhcNGMQ==}
+  /puppeteer/14.1.2:
+    resolution: {integrity: sha512-Nsyy1f7pT2KyBb15u8DHi4q3FfrIqOptAV0r4Bd1lAp2pHz8T0o4DO+On1yWZ7jFbcx1w3AqZ/e7nKqnc3Vwyg==}
     engines: {node: '>=14.1.0'}
     requiresBuild: true
     dependencies:
@@ -4753,7 +5126,6 @@ packages:
     resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
     dependencies:
       safe-buffer: 5.2.1
-    dev: true
 
   /randomfill/1.0.4:
     resolution: {integrity: sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==}
@@ -4953,7 +5325,6 @@ packages:
       is-core-module: 2.9.0
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
-    dev: true
 
   /restore-cursor/2.0.0:
     resolution: {integrity: sha1-n37ih/gv0ybU/RYpI9YhKe7g368=}
@@ -5001,7 +5372,7 @@ packages:
       inherits: 2.0.4
     dev: true
 
-  /rollup-plugin-typescript2/0.31.2_dyu3set7imqii5ytavmnwecwpy:
+  /rollup-plugin-typescript2/0.31.2_nl2qxg2fxlgm6l264qcwjguuca:
     resolution: {integrity: sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==}
     peerDependencies:
       rollup: '>=1.26.3'
@@ -5012,13 +5383,13 @@ packages:
       find-cache-dir: 3.3.2
       fs-extra: 10.1.0
       resolve: 1.22.0
-      rollup: 2.74.0
+      rollup: 2.75.3
       tslib: 2.4.0
-      typescript: 4.6.4
+      typescript: 4.7.2
     dev: true
 
-  /rollup/2.74.0:
-    resolution: {integrity: sha512-RRwXTX5+ObPJhcMV6zP3RdHvy90/lBOUfbzL7IKkFjMJGAqeBGZiv9nZWm/DoTESaTE3GBkkzbU9QVN2AuCkjw==}
+  /rollup/2.75.3:
+    resolution: {integrity: sha512-YA29fLU6MAYSaDxIQYrGGOcbXlDmG96h0krGGYObroezcQ0KgEPM3+7MtKD/qeuUbFuAJXvKZee5dA1dpwq1PQ==}
     engines: {node: '>=10.0.0'}
     hasBin: true
     optionalDependencies:
@@ -5055,7 +5426,6 @@ packages:
 
   /safe-buffer/5.2.1:
     resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
-    dev: true
 
   /safe-regex/1.1.0:
     resolution: {integrity: sha1-QKNmnzsHfR6UPURinhV91IAjvy4=}
@@ -5067,6 +5437,16 @@ packages:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
     dev: true
 
+  /sass/1.52.1:
+    resolution: {integrity: sha512-fSzYTbr7z8oQnVJ3Acp9hV80dM1fkMN7mSD/25mpcct9F7FPBMOI8krEYALgU1aZoqGhQNhTPsuSmxjnIvAm4Q==}
+    engines: {node: '>=12.0.0'}
+    hasBin: true
+    dependencies:
+      chokidar: 3.5.3
+      immutable: 4.1.0
+      source-map-js: 1.0.2
+    dev: true
+
   /saxes/5.0.1:
     resolution: {integrity: sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==}
     engines: {node: '>=10'}
@@ -5111,7 +5491,7 @@ packages:
     resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==}
     dependencies:
       randombytes: 2.1.0
-    dev: true
+    dev: false
 
   /set-value/2.0.1:
     resolution: {integrity: sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==}
@@ -5178,7 +5558,7 @@ packages:
     dependencies:
       call-bind: 1.0.2
       get-intrinsic: 1.1.1
-      object-inspect: 1.12.0
+      object-inspect: 1.12.2
     dev: true
 
   /signal-exit/3.0.7:
@@ -5286,7 +5666,6 @@ packages:
   /source-map-js/1.0.2:
     resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==}
     engines: {node: '>=0.10.0'}
-    dev: true
 
   /source-map-resolve/0.5.3:
     resolution: {integrity: sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==}
@@ -5314,19 +5693,10 @@ packages:
   /source-map/0.5.6:
     resolution: {integrity: sha1-dc449SvwczxafwwRjYEzSiu19BI=}
     engines: {node: '>=0.10.0'}
-    dev: true
 
   /source-map/0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
-    dev: true
-
-  /source-map/0.8.0-beta.0:
-    resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==}
-    engines: {node: '>= 8'}
-    dependencies:
-      whatwg-url: 7.1.0
-    dev: true
 
   /sourcemap-codec/1.4.8:
     resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==}
@@ -5429,8 +5799,8 @@ packages:
     resolution: {integrity: sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==}
     dev: true
 
-  /streamroller/3.1.0:
-    resolution: {integrity: sha512-9+fOFZX3qeo5lEdq9AnPxyRqdrh0MhlX5uqDN6+OLGuGK0PnyyKjMicwcUYIzjYRut5Pfbc0AV6WKdv6di3YGA==}
+  /streamroller/3.1.1:
+    resolution: {integrity: sha512-iPhtd9unZ6zKdWgMeYGfSBuqCngyJy1B/GPi/lTpwGpa3bajuX30GjUVd0/Tn/Xhg0mr4DOSENozz9Y06qyonQ==}
     engines: {node: '>=8.0'}
     dependencies:
       date-format: 4.0.10
@@ -5445,6 +5815,10 @@ packages:
     engines: {node: '>=0.6.19'}
     dev: true
 
+  /string-hash/1.1.3:
+    resolution: {integrity: sha1-6Kr8CsGFW0Zmkp7X3RJ1311sgRs=}
+    dev: true
+
   /string-width/2.1.1:
     resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==}
     engines: {node: '>=4'}
@@ -5565,7 +5939,6 @@ packages:
     engines: {node: '>=8'}
     dependencies:
       has-flag: 4.0.0
-    dev: true
 
   /supports-color/9.2.2:
     resolution: {integrity: sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==}
@@ -5575,7 +5948,6 @@ packages:
   /supports-preserve-symlinks-flag/1.0.0:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
-    dev: true
 
   /symbol-tree/3.2.4:
     resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
@@ -5635,14 +6007,14 @@ packages:
       source-map-support: 0.5.21
     dev: true
 
-  /terser/5.13.1:
-    resolution: {integrity: sha512-hn4WKOfwnwbYfe48NgrQjqNOH9jzLqRcIfbYytOXCOv46LBfWr9bDS17MQqOi+BWGD0sJK3Sj5NC/gJjiojaoA==}
+  /terser/5.14.0:
+    resolution: {integrity: sha512-JC6qfIEkPBd9j1SMO3Pfn+A6w2kQV54tv+ABQLgZr7dA3k/DL/OBoYSWxzVpZev3J+bUHXfr55L8Mox7AaNo6g==}
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
+      '@jridgewell/source-map': 0.3.2
       acorn: 8.7.1
       commander: 2.20.3
-      source-map: 0.8.0-beta.0
       source-map-support: 0.5.21
     dev: true
 
@@ -5707,6 +6079,10 @@ packages:
     resolution: {integrity: sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=}
     dev: true
 
+  /to-fast-properties/2.0.0:
+    resolution: {integrity: sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=}
+    engines: {node: '>=4'}
+
   /to-object-path/0.3.0:
     resolution: {integrity: sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=}
     engines: {node: '>=0.10.0'}
@@ -5748,6 +6124,10 @@ packages:
     engines: {node: '>=0.6'}
     dev: true
 
+  /token-stream/1.0.0:
+    resolution: {integrity: sha1-zCAOqyYT9BZtJ/+a/HylbUnfbrQ=}
+    dev: true
+
   /tough-cookie/4.0.0:
     resolution: {integrity: sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==}
     engines: {node: '>=6'}
@@ -5761,12 +6141,6 @@ packages:
     resolution: {integrity: sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=}
     dev: true
 
-  /tr46/1.0.1:
-    resolution: {integrity: sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk=}
-    dependencies:
-      punycode: 2.1.1
-    dev: true
-
   /tr46/3.0.0:
     resolution: {integrity: sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==}
     engines: {node: '>=12'}
@@ -5779,8 +6153,8 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /ts-node/10.7.0_3smuweqyuzdazdnyhhezld6mfa:
-    resolution: {integrity: sha512-TbIGS4xgJoX2i3do417KSaep1uRAW/Lu+WAL2doDHC0D6ummjirVOXU5/7aiZotbQ5p1Zp9tP7U6cYhA0O7M8A==}
+  /ts-node/10.8.0_w6gfxie3xfwntbz3mwbbvycbdq:
+    resolution: {integrity: sha512-/fNd5Qh+zTt8Vt1KbYZjRHCE9sI5i7nqfD/dzBBRDeVXZXS6kToW6R7tTU6Nd4XavFs0mAVCg29Q//ML7WsZYA==}
     hasBin: true
     peerDependencies:
       '@swc/core': '>=1.2.50'
@@ -5793,19 +6167,19 @@ packages:
       '@swc/wasm':
         optional: true
     dependencies:
-      '@cspotcode/source-map-support': 0.7.0
+      '@cspotcode/source-map-support': 0.8.1
       '@tsconfig/node10': 1.0.8
       '@tsconfig/node12': 1.0.9
       '@tsconfig/node14': 1.0.1
       '@tsconfig/node16': 1.0.2
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
       acorn: 8.7.1
       acorn-walk: 8.2.0
       arg: 4.1.3
       create-require: 1.1.1
       diff: 4.0.2
       make-error: 1.3.6
-      typescript: 4.6.4
+      typescript: 4.7.2
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
     dev: true
@@ -5872,6 +6246,12 @@ packages:
     hasBin: true
     dev: true
 
+  /typescript/4.7.2:
+    resolution: {integrity: sha512-Mamb1iX2FDUpcTRzltPxgWMKy3fhg0TN378ylbktPGPK/99KbDtMQ4W1hwgsbPAsG3a0xKa1vmw4VKZQbkvz5A==}
+    engines: {node: '>=4.2.0'}
+    hasBin: true
+    dev: true
+
   /ua-parser-js/0.7.31:
     resolution: {integrity: sha512-qLK/Xe9E2uzmYI3qLeOmI0tEOt+TBBQyUIAh4aAgU05FVYzeZrKUdkAZfBNVGRaHVgV0TDkdEngJSw/SyQchkQ==}
     dev: true
@@ -5945,7 +6325,7 @@ packages:
   /upath2/3.1.13:
     resolution: {integrity: sha512-M88uBoqgzrkXvXrF/+oSIPsTmL21uRwGhPVJKODrl+3lXkQ5NPKrTYuSBZVa+lgPGFoI6qYyHlSKACFHO0AoNw==}
     dependencies:
-      '@types/node': 17.0.34
+      '@types/node': 17.0.36
       path-is-network-drive: 1.0.15
       path-strip-sep: 1.0.12
       tslib: 2.4.0
@@ -6032,16 +6412,16 @@ packages:
       stylus:
         optional: true
     dependencies:
-      esbuild: 0.14.39
+      esbuild: 0.14.42
       postcss: 8.4.14
       resolve: 1.22.0
-      rollup: 2.74.0
+      rollup: 2.75.3
     optionalDependencies:
       fsevents: 2.3.2
     dev: true
 
-  /vitest/0.12.6_jsdom@19.0.0:
-    resolution: {integrity: sha512-YWbCTv0XKBuBw5YtuW/iufuguoi8QhGpYyi2g57Oo7akpscMkkWTAaZGgY0ux1oJJtO/pc/8GFt0EF32WFBUUQ==}
+  /vitest/0.12.10_jsdom@19.0.0:
+    resolution: {integrity: sha512-TVoI6fM7rZ1zIMDjcviY8Dg5XIaPqBwDweaI3oUwvWqUz68cbM49CIHNMkF+UVoSjl94wXiBRdNhsT4ekgWuGA==}
     engines: {node: '>=v14.16.0'}
     hasBin: true
     peerDependencies:
@@ -6062,6 +6442,7 @@ packages:
       '@types/chai': 4.3.1
       '@types/chai-subset': 1.3.3
       chai: 4.3.6
+      debug: 4.3.4
       jsdom: 19.0.0
       local-pkg: 0.4.1
       tinypool: 0.1.3
@@ -6071,6 +6452,7 @@ packages:
       - less
       - sass
       - stylus
+      - supports-color
     dev: true
 
   /vm-browserify/1.1.2:
@@ -6082,6 +6464,11 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /void-elements/3.1.0:
+    resolution: {integrity: sha1-YU9/v42AHwu18GYfWy9XhXUOTwk=}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /w3c-hr-time/1.0.2:
     resolution: {integrity: sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==}
     dependencies:
@@ -6121,10 +6508,6 @@ packages:
     resolution: {integrity: sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=}
     dev: true
 
-  /webidl-conversions/4.0.2:
-    resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==}
-    dev: true
-
   /webidl-conversions/7.0.0:
     resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
     engines: {node: '>=12'}
@@ -6212,14 +6595,6 @@ packages:
       webidl-conversions: 3.0.1
     dev: true
 
-  /whatwg-url/7.1.0:
-    resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==}
-    dependencies:
-      lodash.sortby: 4.7.0
-      tr46: 1.0.1
-      webidl-conversions: 4.0.2
-    dev: true
-
   /which/1.3.1:
     resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==}
     hasBin: true
@@ -6235,6 +6610,16 @@ packages:
       isexe: 2.0.0
     dev: true
 
+  /with/7.0.2:
+    resolution: {integrity: sha512-RNGKj82nUPg3g5ygxkQl0R937xLyho1J24ItRCBTr/m1YnZkzJy1hUiHUJrc/VlsDQzsCnInEGSg3bci0Lmd4w==}
+    engines: {node: '>= 10.0.0'}
+    dependencies:
+      '@babel/parser': 7.18.4
+      '@babel/types': 7.18.4
+      assert-never: 1.2.1
+      babel-walk: 3.0.0-canary-5
+    dev: true
+
   /word-wrap/1.2.3:
     resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==}
     engines: {node: '>=0.10.0'}
@@ -6298,6 +6683,19 @@ packages:
         optional: true
     dev: true
 
+  /ws/8.7.0:
+    resolution: {integrity: sha512-c2gsP0PRwcLFzUiA8Mkr37/MI7ilIlHQxaEAtd0uNMbVMoy8puJyafRlm0bV9MbGSabUPeLrRRaqIBcFcA2Pqg==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+    dev: true
+
   /xml-name-validator/4.0.0:
     resolution: {integrity: sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==}
     engines: {node: '>=12'}
@@ -6395,3 +6793,9 @@ packages:
     optionalDependencies:
       commander: 2.20.3
     dev: true
+
+  'file:':
+    resolution: {directory: '', type: directory}
+    name: vue
+    version: 2.6.14
+    dev: true
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
new file mode 100644
index 00000000000..18ec407efca
--- /dev/null
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,2 @@
+packages:
+  - 'packages/*'
diff --git a/scripts/alias.js b/scripts/alias.js
index aab3750afa0..08f0eb6e1c3 100644
--- a/scripts/alias.js
+++ b/scripts/alias.js
@@ -8,6 +8,6 @@ module.exports = {
   core: resolve('src/core'),
   shared: resolve('src/shared'),
   web: resolve('src/platforms/web'),
-  server: resolve('src/server'),
+  server: resolve('packages/server-renderer/src'),
   sfc: resolve('src/sfc')
 }
diff --git a/scripts/config.js b/scripts/config.js
index 8cef33b66a4..56fdcd83520 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -27,14 +27,14 @@ const resolve = p => {
 
 const builds = {
   // Runtime only (CommonJS). Used by bundlers e.g. Webpack & Browserify
-  'web-runtime-cjs-dev': {
+  'runtime-cjs-dev': {
     entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.common.dev.js'),
     format: 'cjs',
     env: 'development',
     banner
   },
-  'web-runtime-cjs-prod': {
+  'runtime-cjs-prod': {
     entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.common.prod.js'),
     format: 'cjs',
@@ -42,7 +42,7 @@ const builds = {
     banner
   },
   // Runtime+compiler CommonJS build (CommonJS)
-  'web-full-cjs-dev': {
+  'full-cjs-dev': {
     entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.common.dev.js'),
     format: 'cjs',
@@ -50,7 +50,7 @@ const builds = {
     alias: { he: './entity-decoder' },
     banner
   },
-  'web-full-cjs-prod': {
+  'full-cjs-prod': {
     entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.common.prod.js'),
     format: 'cjs',
@@ -59,14 +59,14 @@ const builds = {
     banner
   },
   // Runtime only ES modules build (for bundlers)
-  'web-runtime-esm': {
+  'runtime-esm': {
     entry: resolve('web/entry-runtime-esm.ts'),
     dest: resolve('dist/vue.runtime.esm.js'),
     format: 'es',
     banner
   },
   // Runtime+compiler ES modules build (for bundlers)
-  'web-full-esm': {
+  'full-esm': {
     entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
     dest: resolve('dist/vue.esm.js'),
     format: 'es',
@@ -74,7 +74,7 @@ const builds = {
     banner
   },
   // Runtime+compiler ES modules build (for direct import in browser)
-  'web-full-esm-browser-dev': {
+  'full-esm-browser-dev': {
     entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
     dest: resolve('dist/vue.esm.browser.js'),
     format: 'es',
@@ -84,7 +84,7 @@ const builds = {
     banner
   },
   // Runtime+compiler ES modules build (for direct import in browser)
-  'web-full-esm-browser-prod': {
+  'full-esm-browser-prod': {
     entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
     dest: resolve('dist/vue.esm.browser.min.js'),
     format: 'es',
@@ -94,7 +94,7 @@ const builds = {
     banner
   },
   // runtime-only build (Browser)
-  'web-runtime-dev': {
+  'runtime-dev': {
     entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.js'),
     format: 'umd',
@@ -102,7 +102,7 @@ const builds = {
     banner
   },
   // runtime-only production build (Browser)
-  'web-runtime-prod': {
+  'runtime-prod': {
     entry: resolve('web/entry-runtime.ts'),
     dest: resolve('dist/vue.runtime.min.js'),
     format: 'umd',
@@ -110,7 +110,7 @@ const builds = {
     banner
   },
   // Runtime+compiler development build (Browser)
-  'web-full-dev': {
+  'full-dev': {
     entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.js'),
     format: 'umd',
@@ -119,7 +119,7 @@ const builds = {
     banner
   },
   // Runtime+compiler production build  (Browser)
-  'web-full-prod': {
+  'full-prod': {
     entry: resolve('web/entry-runtime-with-compiler.ts'),
     dest: resolve('dist/vue.min.js'),
     format: 'umd',
@@ -128,70 +128,78 @@ const builds = {
     banner
   },
   // Web compiler (CommonJS).
-  'web-compiler': {
+  compiler: {
     entry: resolve('web/entry-compiler.ts'),
-    dest: resolve('packages/vue-template-compiler/build.js'),
+    dest: resolve('packages/template-compiler/build.js'),
     format: 'cjs',
     external: Object.keys(
-      require('../packages/vue-template-compiler/package.json').dependencies
+      require('../packages/template-compiler/package.json').dependencies
     )
   },
   // Web compiler (UMD for in-browser use).
-  'web-compiler-browser': {
+  'compiler-browser': {
     entry: resolve('web/entry-compiler.ts'),
-    dest: resolve('packages/vue-template-compiler/browser.js'),
+    dest: resolve('packages/template-compiler/browser.js'),
     format: 'umd',
     env: 'development',
     moduleName: 'VueTemplateCompiler',
     plugins: [node(), cjs()]
   },
   // Web server renderer (CommonJS).
-  'web-server-renderer-dev': {
+  'server-renderer-dev': {
     entry: resolve('web/entry-server-renderer.ts'),
-    dest: resolve('packages/vue-server-renderer/build.dev.js'),
+    dest: resolve('packages/server-renderer/build.dev.js'),
     format: 'cjs',
     env: 'development',
     external: [
       'stream',
       ...Object.keys(
-        require('../packages/vue-server-renderer/package.json').dependencies
+        require('../packages/server-renderer/package.json').dependencies
       )
     ]
   },
-  'web-server-renderer-prod': {
+  'server-renderer-prod': {
     entry: resolve('web/entry-server-renderer.ts'),
-    dest: resolve('packages/vue-server-renderer/build.prod.js'),
+    dest: resolve('packages/server-renderer/build.prod.js'),
     format: 'cjs',
     env: 'production',
     external: [
       'stream',
       ...Object.keys(
-        require('../packages/vue-server-renderer/package.json').dependencies
+        require('../packages/server-renderer/package.json').dependencies
       )
     ]
   },
-  'web-server-renderer-basic': {
+  'server-renderer-basic': {
     entry: resolve('web/entry-server-basic-renderer.ts'),
-    dest: resolve('packages/vue-server-renderer/basic.js'),
+    dest: resolve('packages/server-renderer/basic.js'),
     format: 'umd',
     env: 'development',
     moduleName: 'renderVueComponentToString',
     plugins: [node(), cjs()]
   },
-  'web-server-renderer-webpack-server-plugin': {
+  'server-renderer-webpack-server-plugin': {
     entry: resolve('server/webpack-plugin/server.ts'),
-    dest: resolve('packages/vue-server-renderer/server-plugin.js'),
+    dest: resolve('packages/server-renderer/server-plugin.js'),
     format: 'cjs',
     external: Object.keys(
-      require('../packages/vue-server-renderer/package.json').dependencies
+      require('../packages/server-renderer/package.json').dependencies
     )
   },
-  'web-server-renderer-webpack-client-plugin': {
+  'server-renderer-webpack-client-plugin': {
     entry: resolve('server/webpack-plugin/client.ts'),
-    dest: resolve('packages/vue-server-renderer/client-plugin.js'),
+    dest: resolve('packages/server-renderer/client-plugin.js'),
     format: 'cjs',
     external: Object.keys(
-      require('../packages/vue-server-renderer/package.json').dependencies
+      require('../packages/server-renderer/package.json').dependencies
+    )
+  },
+  'compiler-sfc': {
+    entry: resolve('web/entry-compiler-sfc.ts'),
+    dest: resolve('packages/compiler-sfc/dist/compiler-sfc.js'),
+    format: 'cjs',
+    external: Object.keys(
+      require('../packages/compiler-sfc/package.json').dependencies
     )
   }
 }
diff --git a/src/platforms/web/entry-compiler-sfc.ts b/src/platforms/web/entry-compiler-sfc.ts
new file mode 100644
index 00000000000..eb846577ac0
--- /dev/null
+++ b/src/platforms/web/entry-compiler-sfc.ts
@@ -0,0 +1 @@
+export function compile() {}
diff --git a/test/e2e/basic-ssr.html b/test/e2e/basic-ssr.html
index ff248935941..df6f57deaad 100644
--- a/test/e2e/basic-ssr.html
+++ b/test/e2e/basic-ssr.html
@@ -6,7 +6,7 @@
   </head>
   <body>
     <script src="../../dist/vue.min.js"></script>
-    <script src="../../packages/vue-server-renderer/basic.js"></script>
+    <script src="../../packages/server-renderer/basic.js"></script>
 
     <div id="result">wtf</div>
 
diff --git a/test/ssr/fixtures/app.js b/test/ssr/fixtures/app.js
deleted file mode 100644
index 85bb2888fb6..00000000000
--- a/test/ssr/fixtures/app.js
+++ /dev/null
@@ -1,12 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-export default context => {
-  return new Promise(resolve => {
-    context.msg = 'hello'
-    resolve(new Vue({
-      render (h) {
-        return h('div', context.url)
-      }
-    }))
-  })
-}
diff --git a/test/ssr/fixtures/cache-opt-out.js b/test/ssr/fixtures/cache-opt-out.js
deleted file mode 100644
index 772d403c04d..00000000000
--- a/test/ssr/fixtures/cache-opt-out.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-const app = {
-  name: 'app',
-  props: ['id'],
-  serverCacheKey: props => props.id === 1 ? false : props.id,
-  render (h) {
-    return h('div', '/test')
-  }
-}
-
-export default () => {
-  return Promise.resolve(new Vue({
-    render: h => h(app, { props: { id: 1 }})
-  }))
-}
diff --git a/test/ssr/fixtures/cache.js b/test/ssr/fixtures/cache.js
deleted file mode 100644
index 29016771d7c..00000000000
--- a/test/ssr/fixtures/cache.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import Vue from '../../../dist/vue.runtime.common.js'
-
-const app = {
-  name: 'app',
-  props: ['id'],
-  serverCacheKey: props => props.id,
-  render (h) {
-    return h('div', '/test')
-  }
-}
-
-export default () => {
-  return Promise.resolve(new Vue({
-    render: h => h(app, { props: { id: 1 }})
-  }))
-}
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 1ad444952f7..87c161a9a49 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -23,7 +23,7 @@
     "paths": {
       "compiler/*": ["../src/compiler/*"],
       "core/*": ["../src/core/*"],
-      "server/*": ["../src/server/*"],
+      "server/*": ["../packages/server-renderer/src/*"],
       "sfc/*": ["../src/sfc/*"],
       "shared/*": ["../src/shared/*"],
       "web/*": ["../src/platforms/web/*"],
diff --git a/tsconfig.json b/tsconfig.json
index 9db0172bd6d..364042afda9 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -23,7 +23,7 @@
     "paths": {
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
-      "server/*": ["src/server/*"],
+      "server/*": ["packages/server-renderer/src/*"],
       "sfc/*": ["src/sfc/*"],
       "shared/*": ["src/shared/*"],
       "web/*": ["src/platforms/web/*"],
@@ -32,5 +32,5 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "typescript"],
+  "include": ["src", "typescript", "packages/server-renderer/server"],
 }
diff --git a/vitest.config.ts b/vitest.config.ts
index 9db404dcae8..e021d886f01 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -8,7 +8,7 @@ export default defineConfig({
     alias: {
       compiler: resolve('src/compiler'),
       core: resolve('src/core'),
-      server: resolve('src/server'),
+      server: resolve('packages/server-renderer/src'),
       sfc: resolve('src/sfc'),
       shared: resolve('src/shared'),
       web: resolve('src/platforms/web'),

From ef297d94f9c8611db730efc592471b8a150b386b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 16:02:41 +0800
Subject: [PATCH 102/317] chore: fix dep

---
 package.json   | 2 +-
 pnpm-lock.yaml | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 319197fad2e..84adccaeafc 100644
--- a/package.json
+++ b/package.json
@@ -65,7 +65,7 @@
   },
   "homepage": "https://github.com/vuejs/vue#readme",
   "dependencies": {
-    "@vue/compiler-sfc": "2.6.14"
+    "@vue/compiler-sfc": "workspace:*"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.24.2",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 9e65214c678..3dbe7ee4c55 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -11,6 +11,7 @@ importers:
       '@rollup/plugin-replace': ^4.0.0
       '@types/he': ^1.1.2
       '@types/node': ^17.0.30
+      '@vue/compiler-sfc': workspace:*
       chalk: ^4.0.0
       commitizen: ^4.2.4
       conventional-changelog: ^3.1.25
@@ -42,6 +43,8 @@ importers:
       typescript: ^4.6.4
       vitest: ^0.12.6
       yorkie: ^2.0.0
+    dependencies:
+      '@vue/compiler-sfc': link:packages/compiler-sfc
     devDependencies:
       '@microsoft/api-extractor': 7.24.2
       '@rollup/plugin-alias': 3.1.9_rollup@2.75.3
@@ -6798,4 +6801,6 @@ packages:
     resolution: {directory: '', type: directory}
     name: vue
     version: 2.6.14
+    dependencies:
+      '@vue/compiler-sfc': link:packages/compiler-sfc
     dev: true

From dd39e7ef4cbda470f347aa249b3be058b4fc8f16 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 16:11:55 +0800
Subject: [PATCH 103/317] chore: fix TS 4.7 error

---
 src/core/util/perf.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/core/util/perf.ts b/src/core/util/perf.ts
index eb42cdbe57f..6b6f0a00a3d 100644
--- a/src/core/util/perf.ts
+++ b/src/core/util/perf.ts
@@ -8,9 +8,13 @@ if (__DEV__) {
   /* istanbul ignore if */
   if (
     perf &&
+    // @ts-ignore
     perf.mark &&
+    // @ts-ignore
     perf.measure &&
+    // @ts-ignore
     perf.clearMarks &&
+    // @ts-ignore
     perf.clearMeasures
   ) {
     mark = tag => perf.mark(tag)

From d6bdff890322bc87792094a1690bcd16373cf82d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 16:33:48 +0800
Subject: [PATCH 104/317] refactor: move src types folder

---
 .github/CONTRIBUTING.md                              |  6 +++---
 api-extractor.tsconfig.json                          |  3 ++-
 .../server-renderer/src/create-basic-renderer.ts     |  2 +-
 packages/server-renderer/src/create-renderer.ts      |  2 +-
 .../src/optimizing-compiler/codegen.ts               |  2 +-
 .../server-renderer/src/optimizing-compiler/index.ts |  2 +-
 .../src/optimizing-compiler/modules.ts               |  2 +-
 .../src/optimizing-compiler/optimizer.ts             |  2 +-
 .../src/optimizing-compiler/runtime-helpers.ts       |  2 +-
 packages/server-renderer/src/render-context.ts       |  2 +-
 packages/server-renderer/src/render.ts               |  4 ++--
 packages/server-renderer/tsconfig.json               |  4 ++--
 src/compiler/codegen/events.ts                       |  2 +-
 src/compiler/codegen/index.ts                        |  2 +-
 src/compiler/create-compiler.ts                      |  6 +-----
 src/compiler/directives/bind.ts                      |  2 +-
 src/compiler/directives/model.ts                     |  2 +-
 src/compiler/directives/on.ts                        |  2 +-
 src/compiler/error-detector.ts                       |  2 +-
 src/compiler/helpers.ts                              |  2 +-
 src/compiler/index.ts                                |  2 +-
 src/compiler/optimizer.ts                            |  2 +-
 src/compiler/parser/index.ts                         |  2 +-
 src/compiler/to-function.ts                          |  4 ++--
 src/core/components/keep-alive.ts                    |  4 ++--
 src/core/config.ts                                   |  2 +-
 src/core/global-api/assets.ts                        |  2 +-
 src/core/global-api/extend.ts                        |  4 ++--
 src/core/global-api/index.ts                         |  2 +-
 src/core/global-api/mixin.ts                         |  2 +-
 src/core/global-api/use.ts                           |  2 +-
 src/core/instance/events.ts                          |  2 +-
 src/core/instance/index.ts                           |  2 +-
 src/core/instance/init.ts                            |  4 ++--
 src/core/instance/inject.ts                          |  2 +-
 src/core/instance/lifecycle.ts                       |  4 ++--
 .../instance/render-helpers/bind-object-listeners.ts |  2 +-
 .../instance/render-helpers/bind-object-props.ts     |  2 +-
 .../instance/render-helpers/resolve-scoped-slots.ts  |  2 +-
 src/core/instance/render-helpers/resolve-slots.ts    |  2 +-
 src/core/instance/render.ts                          |  2 +-
 src/core/instance/state.ts                           |  2 +-
 src/core/observer/scheduler.ts                       |  2 +-
 src/core/observer/watcher.ts                         |  2 +-
 src/core/util/debug.ts                               |  2 +-
 src/core/util/options.ts                             |  4 ++--
 src/core/util/props.ts                               |  2 +-
 src/core/vdom/create-component.ts                    |  9 +++------
 src/core/vdom/create-element.ts                      |  4 ++--
 src/core/vdom/create-functional-component.ts         |  4 ++--
 src/core/vdom/helpers/extract-props.ts               |  4 ++--
 src/core/vdom/helpers/normalize-scoped-slots.ts      |  2 +-
 src/core/vdom/helpers/resolve-async-component.ts     |  4 ++--
 src/core/vdom/helpers/update-listeners.ts            |  2 +-
 src/core/vdom/modules/directives.ts                  |  4 ++--
 src/core/vdom/modules/template-ref.ts                | 12 ++++++++----
 src/core/vdom/vnode.ts                               |  6 +++---
 src/platforms/web/compiler/directives/html.ts        |  2 +-
 src/platforms/web/compiler/directives/model.ts       |  2 +-
 src/platforms/web/compiler/directives/text.ts        |  2 +-
 src/platforms/web/compiler/modules/class.ts          |  2 +-
 src/platforms/web/compiler/modules/model.ts          |  2 +-
 src/platforms/web/compiler/modules/style.ts          |  2 +-
 src/platforms/web/compiler/options.ts                |  2 +-
 src/platforms/web/runtime-with-compiler.ts           |  4 ++--
 .../web/runtime/components/transition-group.ts       |  2 +-
 src/platforms/web/runtime/components/transition.ts   |  2 +-
 src/platforms/web/runtime/directives/show.ts         |  2 +-
 src/platforms/web/runtime/index.ts                   |  2 +-
 src/platforms/web/runtime/modules/attrs.ts           |  2 +-
 src/platforms/web/runtime/modules/class.ts           |  2 +-
 src/platforms/web/runtime/modules/dom-props.ts       |  2 +-
 src/platforms/web/runtime/modules/events.ts          |  2 +-
 src/platforms/web/runtime/modules/style.ts           |  2 +-
 src/platforms/web/runtime/modules/transition.ts      |  2 +-
 src/platforms/web/server/directives/model.ts         |  2 +-
 src/platforms/web/server/directives/show.ts          |  2 +-
 src/platforms/web/server/modules/attrs.ts            |  2 +-
 src/platforms/web/server/modules/class.ts            |  2 +-
 src/platforms/web/server/modules/dom-props.ts        |  2 +-
 src/platforms/web/server/modules/style.ts            |  2 +-
 src/platforms/web/util/class.ts                      |  2 +-
 src/platforms/web/util/style.ts                      |  2 +-
 src/sfc/parser.ts                                    |  2 +-
 {typescript => src/types}/compiler.ts                |  0
 {typescript => src/types}/component.ts               |  4 ++--
 {typescript => src/types}/global-api.ts              |  2 +-
 {typescript => src/types}/modules.d.ts               |  0
 {typescript => src/types}/options.ts                 |  4 ++--
 {typescript => src/types}/ssr.ts                     |  2 +-
 {typescript => src/types}/utils.ts                   |  0
 {typescript => src/types}/vnode.ts                   |  4 ++--
 src/v3/apiLifecycle.ts                               |  2 +-
 src/v3/apiSetup.ts                                   |  4 ++--
 src/v3/currentInstance.ts                            |  2 +-
 src/v3/reactivity/ref.ts                             |  2 +-
 test/tsconfig.json                                   |  4 ++--
 test/unit/features/v3/apiWatch.spec.ts               |  2 +-
 tsconfig.json                                        |  3 ++-
 99 files changed, 130 insertions(+), 131 deletions(-)
 rename {typescript => src/types}/compiler.ts (100%)
 rename {typescript => src/types}/component.ts (98%)
 rename {typescript => src/types}/global-api.ts (95%)
 rename {typescript => src/types}/modules.d.ts (100%)
 rename {typescript => src/types}/options.ts (96%)
 rename {typescript => src/types}/ssr.ts (91%)
 rename {typescript => src/types}/utils.ts (100%)
 rename {typescript => src/types}/vnode.ts (97%)

diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 825a8470b00..3f3302a572e 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -83,12 +83,10 @@ The default test script will do the following: lint with ESLint -> type check wi
 
   See [dist/README.md](https://github.com/vuejs/vue/blob/dev/dist/README.md) for more details on dist files.
 
-- **`types`**: contains public types published to npm. These were hand-authored before we moved the codebase from Flow to TypeScript. To ensure backwards compatibility, we keep using these manually authored types.
+- **`types`**: contains public types published to npm (note the types shipped here could be different from `src/types`). These were hand-authored before we moved the codebase from Flow to TypeScript. To ensure backwards compatibility, we keep using these manually authored types.
 
   Types for new features added in 2.7 (Composition API) are auto-generated from source code as `types/v3-generated.d.ts` and re-exported from `types/index.d.ts`.
 
-- **`typescript`**: contains type declarations added when we ported the codebase from Flow to TypeScript. These types should be considered internal - they care less about type inference for end-user scenarios and prioritize working with internal source code.
-
 - **`packages`**:
 
   - `vue-server-renderer` and `vue-template-compiler` are distributed as separate NPM packages. They are automatically generated from the source code and always have the same version with the main `vue` package.
@@ -129,6 +127,8 @@ The default test script will do the following: lint with ESLint -> type check wi
 
   - **`shared`**: contains utilities shared across the entire codebase.
 
+  - **`types`**: contains type declarations added when we ported the codebase from Flow to TypeScript. These types should be considered internal - they care less about type inference for end-user scenarios and prioritize working with internal source code.
+
 ## Financial Contribution
 
 As a pure community-driven project without major corporate backing, we also welcome financial contributions via GitHub Sponsors and OpenCollective. Please consult the [Sponsor Page](https://vuejs.org/sponsor/) for more details.
diff --git a/api-extractor.tsconfig.json b/api-extractor.tsconfig.json
index 905ab9246f8..0f6dfeaace5 100644
--- a/api-extractor.tsconfig.json
+++ b/api-extractor.tsconfig.json
@@ -28,8 +28,9 @@
       "web/*": ["src/platforms/web/*"],
       "v3": ["src/v3/index"],
       "v3/*": ["src/v3/*"],
+      "types/*": ["src/types/*"],
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "typescript"]
+  "include": ["src"]
 }
diff --git a/packages/server-renderer/src/create-basic-renderer.ts b/packages/server-renderer/src/create-basic-renderer.ts
index fc12ec8a73f..05f5509b4cf 100644
--- a/packages/server-renderer/src/create-basic-renderer.ts
+++ b/packages/server-renderer/src/create-basic-renderer.ts
@@ -1,7 +1,7 @@
 import { createWriteFunction } from './write'
 import { createRenderFunction } from './render'
 import type { RenderOptions } from './create-renderer'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 export function createBasicRenderer({
   modules = [],
diff --git a/packages/server-renderer/src/create-renderer.ts b/packages/server-renderer/src/create-renderer.ts
index 8005547480a..a4b992eb8c6 100644
--- a/packages/server-renderer/src/create-renderer.ts
+++ b/packages/server-renderer/src/create-renderer.ts
@@ -4,7 +4,7 @@ import { createRenderFunction } from './render'
 import { createPromiseCallback } from './util'
 import TemplateRenderer from './template-renderer/index'
 import type { ClientManifest } from './template-renderer/index'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import VNode from 'core/vdom/vnode'
 import { Readable } from 'stream'
 
diff --git a/packages/server-renderer/src/optimizing-compiler/codegen.ts b/packages/server-renderer/src/optimizing-compiler/codegen.ts
index 2ae89b0e9da..6f245473e20 100644
--- a/packages/server-renderer/src/optimizing-compiler/codegen.ts
+++ b/packages/server-renderer/src/optimizing-compiler/codegen.ts
@@ -23,7 +23,7 @@ import {
 import { escape } from 'web/server/util'
 import { optimizability } from './optimizer'
 import type { CodegenResult } from 'compiler/codegen/index'
-import { ASTElement, ASTNode, CompilerOptions } from 'typescript/compiler'
+import { ASTElement, ASTNode, CompilerOptions } from 'types/compiler'
 
 export type StringSegment = {
   type: number
diff --git a/packages/server-renderer/src/optimizing-compiler/index.ts b/packages/server-renderer/src/optimizing-compiler/index.ts
index 758652145c3..780d8277806 100644
--- a/packages/server-renderer/src/optimizing-compiler/index.ts
+++ b/packages/server-renderer/src/optimizing-compiler/index.ts
@@ -2,7 +2,7 @@ import { parse } from 'compiler/parser/index'
 import { generate } from './codegen'
 import { optimize } from './optimizer'
 import { createCompilerCreator } from 'compiler/create-compiler'
-import { CompiledResult, CompilerOptions } from 'typescript/compiler'
+import { CompiledResult, CompilerOptions } from 'types/compiler'
 
 export const createCompiler = createCompilerCreator(function baseCompile(
   template: string,
diff --git a/packages/server-renderer/src/optimizing-compiler/modules.ts b/packages/server-renderer/src/optimizing-compiler/modules.ts
index 630e8300b76..98bc0092f21 100644
--- a/packages/server-renderer/src/optimizing-compiler/modules.ts
+++ b/packages/server-renderer/src/optimizing-compiler/modules.ts
@@ -10,7 +10,7 @@ import { isBooleanAttr, isEnumeratedAttr } from 'web/util/attrs'
 
 import type { StringSegment } from './codegen'
 import type { CodegenState } from 'compiler/codegen/index'
-import { ASTAttr, ASTElement } from 'typescript/compiler'
+import { ASTAttr, ASTElement } from 'types/compiler'
 
 const plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
 
diff --git a/packages/server-renderer/src/optimizing-compiler/optimizer.ts b/packages/server-renderer/src/optimizing-compiler/optimizer.ts
index d9d935ef04c..dfb9fb52388 100644
--- a/packages/server-renderer/src/optimizing-compiler/optimizer.ts
+++ b/packages/server-renderer/src/optimizing-compiler/optimizer.ts
@@ -9,7 +9,7 @@
  */
 
 import { no, makeMap, isBuiltInTag } from 'shared/util'
-import { ASTElement, ASTNode, CompilerOptions } from 'typescript/compiler'
+import { ASTElement, ASTNode, CompilerOptions } from 'types/compiler'
 
 // optimizability constants
 export const optimizability = {
diff --git a/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts b/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
index 5c3e08b1d43..0cf57265a86 100644
--- a/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
+++ b/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
@@ -11,7 +11,7 @@ import {
 } from 'core/vdom/helpers/normalize-children'
 
 import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 const ssrHelpers = {
   _ssrEscape: escape,
diff --git a/packages/server-renderer/src/render-context.ts b/packages/server-renderer/src/render-context.ts
index 7fc1e6812b6..bcc359930b6 100644
--- a/packages/server-renderer/src/render-context.ts
+++ b/packages/server-renderer/src/render-context.ts
@@ -1,6 +1,6 @@
 import VNode from 'core/vdom/vnode'
 import { isUndef } from 'shared/util'
-import { Component } from 'typescript/component'
+import { Component } from 'types/component'
 
 type RenderState =
   | {
diff --git a/packages/server-renderer/src/render.ts b/packages/server-renderer/src/render.ts
index 272adc4f7c7..6e29437f412 100644
--- a/packages/server-renderer/src/render.ts
+++ b/packages/server-renderer/src/render.ts
@@ -13,8 +13,8 @@ import {
   createComponentInstanceForVnode
 } from 'core/vdom/create-component'
 import VNode from 'core/vdom/vnode'
-import type { VNodeDirective } from 'typescript/vnode'
-import type { Component } from 'typescript/component'
+import type { VNodeDirective } from 'types/vnode'
+import type { Component } from 'types/component'
 
 let warned = Object.create(null)
 const warnOnce = msg => {
diff --git a/packages/server-renderer/tsconfig.json b/packages/server-renderer/tsconfig.json
index dec1b949939..a490aeb83cf 100644
--- a/packages/server-renderer/tsconfig.json
+++ b/packages/server-renderer/tsconfig.json
@@ -29,9 +29,9 @@
       "web/*": ["../../src/platforms/web/*"],
       "v3": ["../../src/v3/index"],
       "v3/*": ["../../src/v3/*"],
-      "typescript/*": ["../../typescript/*"],
+      "types/*": ["../../src/types/*"],
       "vue": ["../../src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["../../src", "../../typescript", "../../test/test-env.d.ts", "."]
+  "include": ["../../src", "../../test/test-env.d.ts", "."]
 }
diff --git a/src/compiler/codegen/events.ts b/src/compiler/codegen/events.ts
index ecf24383c70..5ee53e54b17 100644
--- a/src/compiler/codegen/events.ts
+++ b/src/compiler/codegen/events.ts
@@ -1,4 +1,4 @@
-import { ASTElementHandler, ASTElementHandlers } from 'typescript/compiler'
+import { ASTElementHandler, ASTElementHandlers } from 'types/compiler'
 
 const fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
 const fnInvokeRE = /\([^)]*?\);*$/
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 9ab39f15e32..565a47fed6c 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -12,7 +12,7 @@ import {
   ASTNode,
   ASTText,
   CompilerOptions
-} from 'typescript/compiler'
+} from 'types/compiler'
 
 type TransformFunction = (el: ASTElement, code: string) => string
 type DataGenFunction = (el: ASTElement) => string
diff --git a/src/compiler/create-compiler.ts b/src/compiler/create-compiler.ts
index 71031987f7b..79a1a112e9c 100644
--- a/src/compiler/create-compiler.ts
+++ b/src/compiler/create-compiler.ts
@@ -1,9 +1,5 @@
 import { extend } from 'shared/util'
-import {
-  CompilerOptions,
-  CompiledResult,
-  WarningMessage
-} from 'typescript/compiler'
+import { CompilerOptions, CompiledResult, WarningMessage } from 'types/compiler'
 import { detectErrors } from './error-detector'
 import { createCompileToFunctionFn } from './to-function'
 
diff --git a/src/compiler/directives/bind.ts b/src/compiler/directives/bind.ts
index 0f84528d868..173871a4949 100644
--- a/src/compiler/directives/bind.ts
+++ b/src/compiler/directives/bind.ts
@@ -1,4 +1,4 @@
-import { ASTDirective, ASTElement } from 'typescript/compiler'
+import { ASTDirective, ASTElement } from 'types/compiler'
 
 export default function bind(el: ASTElement, dir: ASTDirective) {
   el.wrapData = (code: string) => {
diff --git a/src/compiler/directives/model.ts b/src/compiler/directives/model.ts
index cd4afa93d85..4538ccda91f 100644
--- a/src/compiler/directives/model.ts
+++ b/src/compiler/directives/model.ts
@@ -1,4 +1,4 @@
-import { ASTElement, ASTModifiers } from 'typescript/compiler'
+import { ASTElement, ASTModifiers } from 'types/compiler'
 
 /**
  * Cross-platform code generation for component v-model
diff --git a/src/compiler/directives/on.ts b/src/compiler/directives/on.ts
index 6d39ee4caf4..291d4da3a3f 100644
--- a/src/compiler/directives/on.ts
+++ b/src/compiler/directives/on.ts
@@ -1,5 +1,5 @@
 import { warn } from 'core/util/index'
-import { ASTDirective, ASTElement } from 'typescript/compiler'
+import { ASTDirective, ASTElement } from 'types/compiler'
 
 export default function on(el: ASTElement, dir: ASTDirective) {
   if (__DEV__ && dir.modifiers) {
diff --git a/src/compiler/error-detector.ts b/src/compiler/error-detector.ts
index d4a087575af..d60452f7d99 100644
--- a/src/compiler/error-detector.ts
+++ b/src/compiler/error-detector.ts
@@ -1,4 +1,4 @@
-import { ASTElement, ASTNode } from 'typescript/compiler'
+import { ASTElement, ASTNode } from 'types/compiler'
 import { dirRE, onRE } from './parser/index'
 
 type Range = { start?: number; end?: number }
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index 800034ef2de..7702de4173d 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -1,5 +1,5 @@
 import { emptyObject } from 'shared/util'
-import { ASTElement, ASTModifiers } from 'typescript/compiler'
+import { ASTElement, ASTModifiers } from 'types/compiler'
 import { parseFilters } from './parser/filter-parser'
 
 type Range = { start?: number; end?: number }
diff --git a/src/compiler/index.ts b/src/compiler/index.ts
index f9f8432c5a9..e8a17e11dc4 100644
--- a/src/compiler/index.ts
+++ b/src/compiler/index.ts
@@ -2,7 +2,7 @@ import { parse } from './parser/index'
 import { optimize } from './optimizer'
 import { generate } from './codegen/index'
 import { createCompilerCreator } from './create-compiler'
-import { CompilerOptions, CompiledResult } from 'typescript/compiler'
+import { CompilerOptions, CompiledResult } from 'types/compiler'
 
 // `createCompilerCreator` allows creating compilers that use alternative
 // parser/optimizer/codegen, e.g the SSR optimizing compiler.
diff --git a/src/compiler/optimizer.ts b/src/compiler/optimizer.ts
index 6c2ccb715c8..49ef6aee2f1 100644
--- a/src/compiler/optimizer.ts
+++ b/src/compiler/optimizer.ts
@@ -1,5 +1,5 @@
 import { makeMap, isBuiltInTag, cached, no } from 'shared/util'
-import { ASTElement, CompilerOptions, ASTNode } from 'typescript/compiler'
+import { ASTElement, CompilerOptions, ASTNode } from 'types/compiler'
 
 let isStaticKey
 let isPlatformReservedTag
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index 5c785917630..fed000892aa 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -26,7 +26,7 @@ import {
   ASTNode,
   ASTText,
   CompilerOptions
-} from 'typescript/compiler'
+} from 'types/compiler'
 
 export const onRE = /^@|^v-on:/
 export const dirRE = process.env.VBIND_PROP_SHORTHAND
diff --git a/src/compiler/to-function.ts b/src/compiler/to-function.ts
index b9ee3103bca..de0b95c1d35 100644
--- a/src/compiler/to-function.ts
+++ b/src/compiler/to-function.ts
@@ -1,8 +1,8 @@
 import { noop, extend } from 'shared/util'
 import { warn as baseWarn, tip } from 'core/util/debug'
 import { generateCodeFrame } from './codeframe'
-import type { Component } from 'typescript/component'
-import { CompilerOptions } from 'typescript/compiler'
+import type { Component } from 'types/component'
+import { CompilerOptions } from 'types/compiler'
 
 type CompiledFunctionResult = {
   render: Function
diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index 15bea54da9c..c2676a35574 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -1,8 +1,8 @@
 import { isRegExp, isArray, remove } from 'shared/util'
 import { getFirstComponentChild } from 'core/vdom/helpers/index'
 import type VNode from 'core/vdom/vnode'
-import type { VNodeComponentOptions } from 'typescript/vnode'
-import type { Component } from 'typescript/component'
+import type { VNodeComponentOptions } from 'types/vnode'
+import type { Component } from 'types/component'
 
 type CacheEntry = {
   name?: string
diff --git a/src/core/config.ts b/src/core/config.ts
index a6ca506af51..1a0b8265d33 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -1,7 +1,7 @@
 import { no, noop, identity } from 'shared/util'
 
 import { LIFECYCLE_HOOKS } from 'shared/constants'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 /**
  * @internal
diff --git a/src/core/global-api/assets.ts b/src/core/global-api/assets.ts
index 38954dbf481..c26f284d4a8 100644
--- a/src/core/global-api/assets.ts
+++ b/src/core/global-api/assets.ts
@@ -1,5 +1,5 @@
 import { ASSET_TYPES } from 'shared/constants'
-import type { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'types/global-api'
 import { isFunction, isPlainObject, validateComponentName } from '../util/index'
 
 export function initAssetRegisters(Vue: GlobalAPI) {
diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index 703cb4b7d12..5fed6fe90a9 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -1,6 +1,6 @@
 import { ASSET_TYPES } from 'shared/constants'
-import type { Component } from 'typescript/component'
-import type { GlobalAPI } from 'typescript/global-api'
+import type { Component } from 'types/component'
+import type { GlobalAPI } from 'types/global-api'
 import { defineComputed, proxy } from '../instance/state'
 import { extend, mergeOptions, validateComponentName } from '../util/index'
 
diff --git a/src/core/global-api/index.ts b/src/core/global-api/index.ts
index 82c70eaed8b..ca95ccf95c7 100644
--- a/src/core/global-api/index.ts
+++ b/src/core/global-api/index.ts
@@ -15,7 +15,7 @@ import {
   mergeOptions,
   defineReactive
 } from '../util/index'
-import type { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'types/global-api'
 
 export function initGlobalAPI(Vue: GlobalAPI) {
   // config
diff --git a/src/core/global-api/mixin.ts b/src/core/global-api/mixin.ts
index 6bc7b8f245a..7a4b00d97e9 100644
--- a/src/core/global-api/mixin.ts
+++ b/src/core/global-api/mixin.ts
@@ -1,4 +1,4 @@
-import type { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'types/global-api'
 import { mergeOptions } from '../util/index'
 
 export function initMixin(Vue: GlobalAPI) {
diff --git a/src/core/global-api/use.ts b/src/core/global-api/use.ts
index 799defb635f..6ee4d518af4 100644
--- a/src/core/global-api/use.ts
+++ b/src/core/global-api/use.ts
@@ -1,4 +1,4 @@
-import type { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'types/global-api'
 import { toArray, isFunction } from '../util/index'
 
 export function initUse(Vue: GlobalAPI) {
diff --git a/src/core/instance/events.ts b/src/core/instance/events.ts
index d62d565678a..3e6d6ab1df8 100644
--- a/src/core/instance/events.ts
+++ b/src/core/instance/events.ts
@@ -1,4 +1,4 @@
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import {
   tip,
   toArray,
diff --git a/src/core/instance/index.ts b/src/core/instance/index.ts
index 95a3af38ece..4e7aab2d571 100644
--- a/src/core/instance/index.ts
+++ b/src/core/instance/index.ts
@@ -4,7 +4,7 @@ import { renderMixin } from './render'
 import { eventsMixin } from './events'
 import { lifecycleMixin } from './lifecycle'
 import { warn } from '../util/index'
-import type { GlobalAPI } from 'typescript/global-api'
+import type { GlobalAPI } from 'types/global-api'
 
 function Vue(options) {
   if (__DEV__ && !(this instanceof Vue)) {
diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 3620a596447..564dbf9fbbb 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -7,8 +7,8 @@ import { mark, measure } from '../util/perf'
 import { initLifecycle, callHook } from './lifecycle'
 import { initProvide, initInjections } from './inject'
 import { extend, mergeOptions, formatComponentName } from '../util/index'
-import type { Component } from 'typescript/component'
-import type { InternalComponentOptions } from 'typescript/options'
+import type { Component } from 'types/component'
+import type { InternalComponentOptions } from 'types/options'
 import { EffectScope } from 'v3/reactivity/effectScope'
 
 let uid = 0
diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 750b24d4053..ea354ca9401 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,6 +1,6 @@
 import { warn, hasSymbol, isFunction } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import { provide } from 'v3/apiInject'
 import { setCurrentInstance } from '../../v3/currentInstance'
 
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index ec73b4f689e..5c559daaa23 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -6,8 +6,8 @@ import { updateComponentListeners } from './events'
 import { resolveSlots } from './render-helpers/resolve-slots'
 import { toggleObserving } from '../observer/index'
 import { pushTarget, popTarget } from '../observer/dep'
-import type { Component } from '../../../typescript/component'
-import type { MountedComponentVNode } from '../../../typescript/vnode'
+import type { Component } from 'types/component'
+import type { MountedComponentVNode } from 'types/vnode'
 
 import {
   warn,
diff --git a/src/core/instance/render-helpers/bind-object-listeners.ts b/src/core/instance/render-helpers/bind-object-listeners.ts
index 753f78207e5..0cdd8cafcf9 100644
--- a/src/core/instance/render-helpers/bind-object-listeners.ts
+++ b/src/core/instance/render-helpers/bind-object-listeners.ts
@@ -1,5 +1,5 @@
 import { warn, extend, isPlainObject } from 'core/util/index'
-import type { VNodeData } from 'typescript/vnode'
+import type { VNodeData } from 'types/vnode'
 
 export function bindObjectListeners(data: any, value: any): VNodeData {
   if (value) {
diff --git a/src/core/instance/render-helpers/bind-object-props.ts b/src/core/instance/render-helpers/bind-object-props.ts
index d37fc69eb9b..d9009a45dce 100644
--- a/src/core/instance/render-helpers/bind-object-props.ts
+++ b/src/core/instance/render-helpers/bind-object-props.ts
@@ -9,7 +9,7 @@ import {
   hyphenate,
   isArray
 } from 'core/util/index'
-import type { VNodeData } from 'typescript/vnode'
+import type { VNodeData } from 'types/vnode'
 
 /**
  * Runtime helper for merging v-bind="object" into a VNode's data.
diff --git a/src/core/instance/render-helpers/resolve-scoped-slots.ts b/src/core/instance/render-helpers/resolve-scoped-slots.ts
index 1ba8951c199..6a25d084a36 100644
--- a/src/core/instance/render-helpers/resolve-scoped-slots.ts
+++ b/src/core/instance/render-helpers/resolve-scoped-slots.ts
@@ -1,4 +1,4 @@
-import type { ScopedSlotsData } from 'typescript/vnode'
+import type { ScopedSlotsData } from 'types/vnode'
 import { isArray } from 'core/util'
 
 export function resolveScopedSlots(
diff --git a/src/core/instance/render-helpers/resolve-slots.ts b/src/core/instance/render-helpers/resolve-slots.ts
index e664004f94b..5536f919145 100644
--- a/src/core/instance/render-helpers/resolve-slots.ts
+++ b/src/core/instance/render-helpers/resolve-slots.ts
@@ -1,5 +1,5 @@
 import type VNode from 'core/vdom/vnode'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 /**
  * Runtime helper for resolving raw children VNodes into a slot object.
diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 900cc130488..54bc07d9cea 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -14,7 +14,7 @@ import { normalizeScopedSlots } from '../vdom/helpers/normalize-scoped-slots'
 import VNode, { createEmptyVNode } from '../vdom/vnode'
 
 import { isUpdatingChildComponent } from './lifecycle'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import { setCurrentInstance } from 'v3/currentInstance'
 import { syncSetupSlots } from 'v3/apiSetup'
 
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index d56761f9023..4262e06475e 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -29,7 +29,7 @@ import {
   invokeWithErrorHandling,
   isFunction
 } from '../util/index'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import { TrackOpTypes } from '../../v3'
 
 const sharedPropertyDefinition = {
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index 22dc6904f5b..24e711c36fd 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -4,7 +4,7 @@ import Dep from './dep'
 import { callHook, activateChildComponent } from '../instance/lifecycle'
 
 import { warn, nextTick, devtools, inBrowser, isIE } from '../util/index'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 export const MAX_UPDATE_COUNT = 100
 
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 4936fe17a04..f07b0fd379c 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -16,7 +16,7 @@ import Dep, { pushTarget, popTarget, DepTarget } from './dep'
 import { DebuggerEvent, DebuggerOptions } from 'v3/debug'
 
 import type { SimpleSet } from '../util/index'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import { activeEffectScope, recordEffectScope } from 'v3/reactivity/effectScope'
 
 let uid = 0
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index e8aa02b87cc..401a47bba4d 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -1,6 +1,6 @@
 import config from '../config'
 import { noop, isArray, isFunction } from 'shared/util'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 import { currentInstance } from 'v3/currentInstance'
 
 export let warn = noop
diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index 8873d96b7d9..e9b7c489e16 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -16,8 +16,8 @@ import {
   isBuiltInTag,
   isPlainObject
 } from 'shared/util'
-import type { Component } from 'typescript/component'
-import type { ComponentOptions } from 'typescript/options'
+import type { Component } from 'types/component'
+import type { ComponentOptions } from 'types/options'
 
 /**
  * Option overwriting strategies are functions that handle
diff --git a/src/core/util/props.ts b/src/core/util/props.ts
index 2f8cb857963..795f5ac37a6 100644
--- a/src/core/util/props.ts
+++ b/src/core/util/props.ts
@@ -10,7 +10,7 @@ import {
   capitalize,
   isPlainObject
 } from 'shared/util'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 type PropOptions = {
   type: Function | Array<Function> | null
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 6cca96552f2..7ec6d82038b 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -24,12 +24,9 @@ import type {
   MountedComponentVNode,
   VNodeData,
   VNodeWithData
-} from 'typescript/vnode'
-import type { Component } from 'typescript/component'
-import type {
-  ComponentOptions,
-  InternalComponentOptions
-} from 'typescript/options'
+} from 'types/vnode'
+import type { Component } from 'types/component'
+import type { ComponentOptions, InternalComponentOptions } from 'types/options'
 
 // inline hooks to be invoked on component VNodes during patch
 const componentVNodeHooks = {
diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index 9207b8fa8c4..62dd004c34a 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -16,8 +16,8 @@ import {
 } from '../util/index'
 
 import { normalizeChildren, simpleNormalizeChildren } from './helpers/index'
-import type { Component } from 'typescript/component'
-import type { VNodeData } from 'typescript/vnode'
+import type { Component } from 'types/component'
+import type { VNodeData } from 'types/vnode'
 
 const SIMPLE_NORMALIZE = 1
 const ALWAYS_NORMALIZE = 2
diff --git a/src/core/vdom/create-functional-component.ts b/src/core/vdom/create-functional-component.ts
index 019453f5ccf..55bc5bd1ba3 100644
--- a/src/core/vdom/create-functional-component.ts
+++ b/src/core/vdom/create-functional-component.ts
@@ -15,8 +15,8 @@ import {
   emptyObject,
   validateProp
 } from '../util/index'
-import type { Component } from 'typescript/component'
-import type { VNodeData } from 'typescript/vnode'
+import type { Component } from 'types/component'
+import type { VNodeData } from 'types/vnode'
 
 export function FunctionalRenderContext(
   data: VNodeData,
diff --git a/src/core/vdom/helpers/extract-props.ts b/src/core/vdom/helpers/extract-props.ts
index 87abc595197..a8015aa6e75 100644
--- a/src/core/vdom/helpers/extract-props.ts
+++ b/src/core/vdom/helpers/extract-props.ts
@@ -6,8 +6,8 @@ import {
   hyphenate,
   formatComponentName
 } from 'core/util/index'
-import type { Component } from 'typescript/component'
-import type { VNodeData } from 'typescript/vnode'
+import type { Component } from 'types/component'
+import type { VNodeData } from 'types/vnode'
 
 export function extractPropsFromVNodeData(
   data: VNodeData,
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index ab22597acb7..388b5d5024a 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -3,7 +3,7 @@ import { normalizeChildren } from 'core/vdom/helpers/normalize-children'
 import { emptyObject, isArray } from 'shared/util'
 import { isAsyncPlaceholder } from './is-async-placeholder'
 import type VNode from '../vnode'
-import { Component } from 'typescript/component'
+import { Component } from 'types/component'
 import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
 
 export function normalizeScopedSlots(
diff --git a/src/core/vdom/helpers/resolve-async-component.ts b/src/core/vdom/helpers/resolve-async-component.ts
index 69794170af8..b7c66ae6459 100644
--- a/src/core/vdom/helpers/resolve-async-component.ts
+++ b/src/core/vdom/helpers/resolve-async-component.ts
@@ -12,8 +12,8 @@ import {
 
 import VNode, { createEmptyVNode } from 'core/vdom/vnode'
 import { currentRenderingInstance } from 'core/instance/render'
-import type { VNodeData } from 'typescript/vnode'
-import type { Component } from 'typescript/component'
+import type { VNodeData } from 'types/vnode'
+import type { Component } from 'types/component'
 
 function ensureCtor(comp: any, base) {
   if (comp.__esModule || (hasSymbol && comp[Symbol.toStringTag] === 'Module')) {
diff --git a/src/core/vdom/helpers/update-listeners.ts b/src/core/vdom/helpers/update-listeners.ts
index 054bae2ab1d..f7c3c03efb4 100644
--- a/src/core/vdom/helpers/update-listeners.ts
+++ b/src/core/vdom/helpers/update-listeners.ts
@@ -1,6 +1,6 @@
 import { warn, invokeWithErrorHandling } from 'core/util/index'
 import { cached, isUndef, isTrue, isArray } from 'shared/util'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 const normalizeEvent = cached(
   (
diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 0ba2d9d0e0e..0dc61e92799 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -1,8 +1,8 @@
 import { emptyNode } from 'core/vdom/patch'
 import { resolveAsset, handleError } from 'core/util/index'
 import { mergeVNodeHook } from 'core/vdom/helpers/index'
-import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
-import type { Component } from 'typescript/component'
+import type { VNodeDirective, VNodeWithData } from 'types/vnode'
+import type { Component } from 'types/component'
 
 export default {
   create: updateDirectives,
diff --git a/src/core/vdom/modules/template-ref.ts b/src/core/vdom/modules/template-ref.ts
index 8688697e9b7..f613435f2d2 100644
--- a/src/core/vdom/modules/template-ref.ts
+++ b/src/core/vdom/modules/template-ref.ts
@@ -7,8 +7,8 @@ import {
   invokeWithErrorHandling,
   warn
 } from 'core/util'
-import type { VNodeWithData } from 'typescript/vnode'
-import { Component } from 'typescript/component'
+import type { VNodeWithData } from 'types/vnode'
+import { Component } from 'types/component'
 import { isRef } from 'v3'
 
 export default {
@@ -81,8 +81,12 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
   }
 }
 
-function setSetupRef({ _setupState }: Component, key: string, val: any) {
-  if (_setupState && hasOwn(_setupState, key)) {
+function setSetupRef(
+  { _setupState }: Component,
+  key: string | number,
+  val: any
+) {
+  if (_setupState && hasOwn(_setupState, key as string)) {
     if (isRef(_setupState[key])) {
       _setupState[key].value = val
     } else {
diff --git a/src/core/vdom/vnode.ts b/src/core/vdom/vnode.ts
index 0c59effab09..80f784167ba 100644
--- a/src/core/vdom/vnode.ts
+++ b/src/core/vdom/vnode.ts
@@ -1,6 +1,6 @@
-import type { Component } from 'typescript/component'
-import type { ComponentOptions } from 'typescript/options'
-import type { VNodeComponentOptions, VNodeData } from 'typescript/vnode'
+import type { Component } from 'types/component'
+import type { ComponentOptions } from 'types/options'
+import type { VNodeComponentOptions, VNodeData } from 'types/vnode'
 
 /**
  * @internal
diff --git a/src/platforms/web/compiler/directives/html.ts b/src/platforms/web/compiler/directives/html.ts
index 54cb6216c8d..4aeac3fc4a1 100644
--- a/src/platforms/web/compiler/directives/html.ts
+++ b/src/platforms/web/compiler/directives/html.ts
@@ -1,5 +1,5 @@
 import { addProp } from 'compiler/helpers'
-import { ASTDirective, ASTElement } from 'typescript/compiler'
+import { ASTDirective, ASTElement } from 'types/compiler'
 
 export default function html(el: ASTElement, dir: ASTDirective) {
   if (dir.value) {
diff --git a/src/platforms/web/compiler/directives/model.ts b/src/platforms/web/compiler/directives/model.ts
index 65cc030c388..ba6bb28ca2d 100644
--- a/src/platforms/web/compiler/directives/model.ts
+++ b/src/platforms/web/compiler/directives/model.ts
@@ -1,7 +1,7 @@
 import config from 'core/config'
 import { addHandler, addProp, getBindingAttr } from 'compiler/helpers'
 import { genComponentModel, genAssignmentCode } from 'compiler/directives/model'
-import { ASTDirective, ASTElement, ASTModifiers } from 'typescript/compiler'
+import { ASTDirective, ASTElement, ASTModifiers } from 'types/compiler'
 
 let warn
 
diff --git a/src/platforms/web/compiler/directives/text.ts b/src/platforms/web/compiler/directives/text.ts
index 2c80adbf7b7..cabfd583124 100644
--- a/src/platforms/web/compiler/directives/text.ts
+++ b/src/platforms/web/compiler/directives/text.ts
@@ -1,5 +1,5 @@
 import { addProp } from 'compiler/helpers'
-import { ASTDirective, ASTElement } from 'typescript/compiler'
+import { ASTDirective, ASTElement } from 'types/compiler'
 
 export default function text(el: ASTElement, dir: ASTDirective) {
   if (dir.value) {
diff --git a/src/platforms/web/compiler/modules/class.ts b/src/platforms/web/compiler/modules/class.ts
index e564fe06ed6..b7837871459 100644
--- a/src/platforms/web/compiler/modules/class.ts
+++ b/src/platforms/web/compiler/modules/class.ts
@@ -1,6 +1,6 @@
 import { parseText } from 'compiler/parser/text-parser'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
-import { ASTElement, CompilerOptions, ModuleOptions } from 'typescript/compiler'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
 
 function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
diff --git a/src/platforms/web/compiler/modules/model.ts b/src/platforms/web/compiler/modules/model.ts
index 5e93cf1af29..131483a83a1 100644
--- a/src/platforms/web/compiler/modules/model.ts
+++ b/src/platforms/web/compiler/modules/model.ts
@@ -16,7 +16,7 @@ import {
   addIfCondition,
   createASTElement
 } from 'compiler/parser/index'
-import { ASTElement, CompilerOptions, ModuleOptions } from 'typescript/compiler'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
 
 function preTransformNode(el: ASTElement, options: CompilerOptions) {
   if (el.tag === 'input') {
diff --git a/src/platforms/web/compiler/modules/style.ts b/src/platforms/web/compiler/modules/style.ts
index aed51db670a..67e8524a4bb 100644
--- a/src/platforms/web/compiler/modules/style.ts
+++ b/src/platforms/web/compiler/modules/style.ts
@@ -1,7 +1,7 @@
 import { parseText } from 'compiler/parser/text-parser'
 import { parseStyleText } from 'web/util/style'
 import { getAndRemoveAttr, getBindingAttr, baseWarn } from 'compiler/helpers'
-import { ASTElement, CompilerOptions, ModuleOptions } from 'typescript/compiler'
+import { ASTElement, CompilerOptions, ModuleOptions } from 'types/compiler'
 
 function transformNode(el: ASTElement, options: CompilerOptions) {
   const warn = options.warn || baseWarn
diff --git a/src/platforms/web/compiler/options.ts b/src/platforms/web/compiler/options.ts
index 12a96bb4453..29e570ce3b8 100644
--- a/src/platforms/web/compiler/options.ts
+++ b/src/platforms/web/compiler/options.ts
@@ -9,7 +9,7 @@ import modules from './modules/index'
 import directives from './directives/index'
 import { genStaticKeys } from 'shared/util'
 import { isUnaryTag, canBeLeftOpenTag } from './util'
-import { CompilerOptions } from 'typescript/compiler'
+import { CompilerOptions } from 'types/compiler'
 
 export const baseOptions: CompilerOptions = {
   expectHTML: true,
diff --git a/src/platforms/web/runtime-with-compiler.ts b/src/platforms/web/runtime-with-compiler.ts
index 8bb02675f43..0dc1d132d38 100644
--- a/src/platforms/web/runtime-with-compiler.ts
+++ b/src/platforms/web/runtime-with-compiler.ts
@@ -9,8 +9,8 @@ import {
   shouldDecodeNewlines,
   shouldDecodeNewlinesForHref
 } from './util/compat'
-import type { Component } from 'typescript/component'
-import type { GlobalAPI } from 'typescript/global-api'
+import type { Component } from 'types/component'
+import type { GlobalAPI } from 'types/global-api'
 
 const idToTemplate = cached(id => {
   const el = query(id)
diff --git a/src/platforms/web/runtime/components/transition-group.ts b/src/platforms/web/runtime/components/transition-group.ts
index ee72009f547..d7a454d3e19 100644
--- a/src/platforms/web/runtime/components/transition-group.ts
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -22,7 +22,7 @@ import {
   removeTransitionClass
 } from 'web/runtime/transition-util'
 import VNode from 'core/vdom/vnode'
-import { VNodeWithData } from 'typescript/vnode'
+import { VNodeWithData } from 'types/vnode'
 
 const props = extend(
   {
diff --git a/src/platforms/web/runtime/components/transition.ts b/src/platforms/web/runtime/components/transition.ts
index 2dc6b847eed..8f5c05679ef 100644
--- a/src/platforms/web/runtime/components/transition.ts
+++ b/src/platforms/web/runtime/components/transition.ts
@@ -9,7 +9,7 @@ import {
   getFirstComponentChild
 } from 'core/vdom/helpers/index'
 import VNode from 'core/vdom/vnode'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 export const transitionProps = {
   name: String,
diff --git a/src/platforms/web/runtime/directives/show.ts b/src/platforms/web/runtime/directives/show.ts
index 230725e708d..e36178a0cd8 100644
--- a/src/platforms/web/runtime/directives/show.ts
+++ b/src/platforms/web/runtime/directives/show.ts
@@ -1,5 +1,5 @@
 import VNode from 'core/vdom/vnode'
-import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { VNodeDirective, VNodeWithData } from 'types/vnode'
 import { enter, leave } from 'web/runtime/modules/transition'
 
 // recursively search for possible transition defined inside the component root
diff --git a/src/platforms/web/runtime/index.ts b/src/platforms/web/runtime/index.ts
index 1d8541931a1..d8cef39291b 100644
--- a/src/platforms/web/runtime/index.ts
+++ b/src/platforms/web/runtime/index.ts
@@ -16,7 +16,7 @@ import {
 import { patch } from './patch'
 import platformDirectives from './directives/index'
 import platformComponents from './components/index'
-import type { Component } from 'typescript/component'
+import type { Component } from 'types/component'
 
 // install platform specific utils
 Vue.config.mustUseProp = mustUseProp
diff --git a/src/platforms/web/runtime/modules/attrs.ts b/src/platforms/web/runtime/modules/attrs.ts
index 520c00c91f2..431dc51ef63 100644
--- a/src/platforms/web/runtime/modules/attrs.ts
+++ b/src/platforms/web/runtime/modules/attrs.ts
@@ -1,7 +1,7 @@
 import { isIE, isIE9, isEdge } from 'core/util/env'
 
 import { extend, isDef, isUndef, isTrue } from 'shared/util'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 import {
   isXlink,
diff --git a/src/platforms/web/runtime/modules/class.ts b/src/platforms/web/runtime/modules/class.ts
index 3be15a1ab4c..d1720c33d5f 100644
--- a/src/platforms/web/runtime/modules/class.ts
+++ b/src/platforms/web/runtime/modules/class.ts
@@ -1,5 +1,5 @@
 import { isDef, isUndef } from 'shared/util'
-import type { VNodeData } from 'typescript/vnode'
+import type { VNodeData } from 'types/vnode'
 
 import { concat, stringifyClass, genClassForVnode } from 'web/util/index'
 
diff --git a/src/platforms/web/runtime/modules/dom-props.ts b/src/platforms/web/runtime/modules/dom-props.ts
index 38c143b90b3..b182211b9af 100644
--- a/src/platforms/web/runtime/modules/dom-props.ts
+++ b/src/platforms/web/runtime/modules/dom-props.ts
@@ -1,5 +1,5 @@
 import { isDef, isUndef, extend, toNumber, isTrue } from 'shared/util'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 import { isSVG } from 'web/util/index'
 
 let svgContainer
diff --git a/src/platforms/web/runtime/modules/events.ts b/src/platforms/web/runtime/modules/events.ts
index 31b220ff92f..ee71333ec03 100644
--- a/src/platforms/web/runtime/modules/events.ts
+++ b/src/platforms/web/runtime/modules/events.ts
@@ -7,7 +7,7 @@ import {
 } from 'web/compiler/directives/model'
 import { currentFlushTimestamp } from 'core/observer/scheduler'
 import { emptyNode } from 'core/vdom/patch'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 // normalize v-model event tokens that can only be determined at runtime.
 // it's important to place the event as the first in the array because
diff --git a/src/platforms/web/runtime/modules/style.ts b/src/platforms/web/runtime/modules/style.ts
index b8412bdae6c..ff6e14da495 100644
--- a/src/platforms/web/runtime/modules/style.ts
+++ b/src/platforms/web/runtime/modules/style.ts
@@ -7,7 +7,7 @@ import {
   isUndef,
   hyphenate
 } from 'shared/util'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 const cssVarRE = /^--/
 const importantRE = /\s*!important$/
diff --git a/src/platforms/web/runtime/modules/transition.ts b/src/platforms/web/runtime/modules/transition.ts
index a889989f1a8..ba38cf1a316 100644
--- a/src/platforms/web/runtime/modules/transition.ts
+++ b/src/platforms/web/runtime/modules/transition.ts
@@ -19,7 +19,7 @@ import {
   removeTransitionClass
 } from 'web/runtime/transition-util'
 
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 import VNode from 'core/vdom/vnode'
 
 export function enter(vnode: VNodeWithData, toggleDisplay?: () => void) {
diff --git a/src/platforms/web/server/directives/model.ts b/src/platforms/web/server/directives/model.ts
index 321727eb28d..fa54933e0af 100644
--- a/src/platforms/web/server/directives/model.ts
+++ b/src/platforms/web/server/directives/model.ts
@@ -1,5 +1,5 @@
 import { looseEqual, looseIndexOf } from 'shared/util'
-import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { VNodeDirective, VNodeWithData } from 'types/vnode'
 
 // this is only applied for <select v-model> because it is the only edge case
 // that must be done at runtime instead of compile time.
diff --git a/src/platforms/web/server/directives/show.ts b/src/platforms/web/server/directives/show.ts
index 6811d84654a..4a84fc6168c 100644
--- a/src/platforms/web/server/directives/show.ts
+++ b/src/platforms/web/server/directives/show.ts
@@ -1,4 +1,4 @@
-import type { VNodeDirective, VNodeWithData } from 'typescript/vnode'
+import type { VNodeDirective, VNodeWithData } from 'types/vnode'
 
 export default function show(node: VNodeWithData, dir: VNodeDirective) {
   if (!dir.value) {
diff --git a/src/platforms/web/server/modules/attrs.ts b/src/platforms/web/server/modules/attrs.ts
index 5cb7e3b6140..c37b81f5f12 100644
--- a/src/platforms/web/server/modules/attrs.ts
+++ b/src/platforms/web/server/modules/attrs.ts
@@ -10,7 +10,7 @@ import {
 } from 'web/util/attrs'
 
 import { isSSRUnsafeAttr } from 'web/server/util'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 export default function renderAttrs(node: VNodeWithData): string {
   let attrs = node.data.attrs
diff --git a/src/platforms/web/server/modules/class.ts b/src/platforms/web/server/modules/class.ts
index c0f674e102d..5fe93fb304a 100644
--- a/src/platforms/web/server/modules/class.ts
+++ b/src/platforms/web/server/modules/class.ts
@@ -1,6 +1,6 @@
 import { escape } from '../util'
 import { genClassForVnode } from 'web/util/index'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 export default function renderClass(node: VNodeWithData): string | undefined {
   const classList = genClassForVnode(node)
diff --git a/src/platforms/web/server/modules/dom-props.ts b/src/platforms/web/server/modules/dom-props.ts
index 1c13030c805..3c4d12625f3 100644
--- a/src/platforms/web/server/modules/dom-props.ts
+++ b/src/platforms/web/server/modules/dom-props.ts
@@ -2,7 +2,7 @@ import VNode from 'core/vdom/vnode'
 import { renderAttr } from './attrs'
 import { isDef, isUndef, extend, toString } from 'shared/util'
 import { propsToAttrMap, isRenderableAttr } from '../util'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 export default function renderDOMProps(node: VNodeWithData): string {
   let props = node.data.domProps
diff --git a/src/platforms/web/server/modules/style.ts b/src/platforms/web/server/modules/style.ts
index 8e165e28243..23c8e0d4237 100644
--- a/src/platforms/web/server/modules/style.ts
+++ b/src/platforms/web/server/modules/style.ts
@@ -1,7 +1,7 @@
 import { escape, noUnitNumericStyleProps } from '../util'
 import { hyphenate } from 'shared/util'
 import { getStyle } from 'web/util/style'
-import type { VNodeWithData } from 'typescript/vnode'
+import type { VNodeWithData } from 'types/vnode'
 
 export function genStyle(style: Object): string {
   let styleText = ''
diff --git a/src/platforms/web/util/class.ts b/src/platforms/web/util/class.ts
index 74323a8770b..e2afdd71689 100644
--- a/src/platforms/web/util/class.ts
+++ b/src/platforms/web/util/class.ts
@@ -1,6 +1,6 @@
 import VNode from 'core/vdom/vnode'
 import { isDef, isObject } from 'shared/util'
-import type { VNodeData, VNodeWithData } from 'typescript/vnode'
+import type { VNodeData, VNodeWithData } from 'types/vnode'
 
 export function genClassForVnode(vnode: VNodeWithData): string {
   let data = vnode.data
diff --git a/src/platforms/web/util/style.ts b/src/platforms/web/util/style.ts
index 81992af1eaf..25971ce3f10 100644
--- a/src/platforms/web/util/style.ts
+++ b/src/platforms/web/util/style.ts
@@ -1,6 +1,6 @@
 import VNode from 'core/vdom/vnode'
 import { cached, extend, toObject } from 'shared/util'
-import type { VNodeData, VNodeWithData } from 'typescript/vnode'
+import type { VNodeData, VNodeWithData } from 'types/vnode'
 
 export const parseStyleText = cached(function (cssText) {
   const res = {}
diff --git a/src/sfc/parser.ts b/src/sfc/parser.ts
index 3202c55da31..b39d943245c 100644
--- a/src/sfc/parser.ts
+++ b/src/sfc/parser.ts
@@ -6,7 +6,7 @@ import {
   SFCBlock,
   SFCDescriptor,
   WarningMessage
-} from 'typescript/compiler'
+} from 'types/compiler'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
diff --git a/typescript/compiler.ts b/src/types/compiler.ts
similarity index 100%
rename from typescript/compiler.ts
rename to src/types/compiler.ts
diff --git a/typescript/component.ts b/src/types/component.ts
similarity index 98%
rename from typescript/component.ts
rename to src/types/component.ts
index 9de07878110..538f7c3a1c7 100644
--- a/typescript/component.ts
+++ b/src/types/component.ts
@@ -1,5 +1,5 @@
-import type VNode from '../src/core/vdom/vnode'
-import type Watcher from '../src/core/observer/watcher'
+import type VNode from 'core/vdom/vnode'
+import type Watcher from 'core/observer/watcher'
 import { ComponentOptions, SetupContext } from './options'
 import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
 import { GlobalAPI } from './global-api'
diff --git a/typescript/global-api.ts b/src/types/global-api.ts
similarity index 95%
rename from typescript/global-api.ts
rename to src/types/global-api.ts
index 7245fe1b215..c2ecfed5a6b 100644
--- a/typescript/global-api.ts
+++ b/src/types/global-api.ts
@@ -1,4 +1,4 @@
-import { Config } from '../src/core/config'
+import { Config } from 'core/config'
 import { Component } from './component'
 
 /**
diff --git a/typescript/modules.d.ts b/src/types/modules.d.ts
similarity index 100%
rename from typescript/modules.d.ts
rename to src/types/modules.d.ts
diff --git a/typescript/options.ts b/src/types/options.ts
similarity index 96%
rename from typescript/options.ts
rename to src/types/options.ts
index 11214da6d09..76bebd1a7fe 100644
--- a/typescript/options.ts
+++ b/src/types/options.ts
@@ -1,5 +1,5 @@
-import VNode from '../src/core/vdom/vnode'
-import { DebuggerEvent } from '../src/v3'
+import VNode from 'core/vdom/vnode'
+import { DebuggerEvent } from 'v3'
 import { Component } from './component'
 
 export type InternalComponentOptions = {
diff --git a/typescript/ssr.ts b/src/types/ssr.ts
similarity index 91%
rename from typescript/ssr.ts
rename to src/types/ssr.ts
index b80ba562297..d667f283245 100644
--- a/typescript/ssr.ts
+++ b/src/types/ssr.ts
@@ -1,4 +1,4 @@
-import VNode from '../src/core/vdom/vnode'
+import VNode from 'core/vdom/vnode'
 import { Component } from './component'
 
 export type ComponentWithCacheContext = {
diff --git a/typescript/utils.ts b/src/types/utils.ts
similarity index 100%
rename from typescript/utils.ts
rename to src/types/utils.ts
diff --git a/typescript/vnode.ts b/src/types/vnode.ts
similarity index 97%
rename from typescript/vnode.ts
rename to src/types/vnode.ts
index cdaa65f0479..cbe8f0aa98f 100644
--- a/typescript/vnode.ts
+++ b/src/types/vnode.ts
@@ -1,5 +1,5 @@
-import VNode from '../src/core/vdom/vnode'
-import { Ref } from '../src/v3'
+import VNode from 'core/vdom/vnode'
+import { Ref } from 'v3'
 import { Component } from './component'
 import { ASTModifiers } from './compiler'
 
diff --git a/src/v3/apiLifecycle.ts b/src/v3/apiLifecycle.ts
index 0bf31e3bd73..dc47bc4652b 100644
--- a/src/v3/apiLifecycle.ts
+++ b/src/v3/apiLifecycle.ts
@@ -1,5 +1,5 @@
 import { DebuggerEvent } from './debug'
-import { Component } from 'typescript/component'
+import { Component } from 'types/component'
 import { mergeLifecycleHook, warn } from '../core/util'
 import { currentInstance } from './currentInstance'
 
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index 49b71f60a71..c1abe64f4ca 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -1,5 +1,5 @@
-import { Component } from 'typescript/component'
-import type { SetupContext } from 'typescript/options'
+import { Component } from 'types/component'
+import type { SetupContext } from 'types/options'
 import { def, invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
 import { bind, emptyObject, isFunction, isObject } from '../shared/util'
diff --git a/src/v3/currentInstance.ts b/src/v3/currentInstance.ts
index 0951c0c4362..197f9392945 100644
--- a/src/v3/currentInstance.ts
+++ b/src/v3/currentInstance.ts
@@ -1,4 +1,4 @@
-import { Component } from 'typescript/component'
+import { Component } from 'types/component'
 
 export let currentInstance: Component | null = null
 
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index 04a4d8a1ea7..c61e29b1c9b 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -4,7 +4,7 @@ import {
   ReactiveFlags,
   type ShallowReactiveMarker
 } from './reactive'
-import type { IfAny } from 'typescript/utils'
+import type { IfAny } from 'types/utils'
 import Dep from 'core/observer/dep'
 import { warn, isArray, def } from 'core/util'
 import { TrackOpTypes, TriggerOpTypes } from './operations'
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 87c161a9a49..8324fccbebe 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -29,9 +29,9 @@
       "web/*": ["../src/platforms/web/*"],
       "v3": ["../src/v3/index"],
       "v3/*": ["../src/v3/*"],
-      "typescript/*": ["../typescript/*"],
+      "types/*": ["../src/types/*"],
       "vue": ["../src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["../src", "../typescript", "."]
+  "include": ["../src", "."]
 }
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index beff133f98f..9a7bcd9410f 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -19,7 +19,7 @@ import {
 } from 'v3'
 import { nextTick } from 'core/util'
 import { set } from 'core/observer'
-import { Component } from 'typescript/component'
+import { Component } from 'types/component'
 
 // reference: https://vue-composition-api-rfc.netlify.com/api.html#watch
 
diff --git a/tsconfig.json b/tsconfig.json
index 364042afda9..26361cfe407 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -29,8 +29,9 @@
       "web/*": ["src/platforms/web/*"],
       "v3": ["src/v3/index"],
       "v3/*": ["src/v3/*"],
+      "types/*": ["src/types/*"],
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "typescript", "packages/server-renderer/server"],
+  "include": ["src", "packages/server-renderer/src"],
 }

From 8d7793ff107753935681fa7bac564fa3fc3c2465 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 17:17:14 +0800
Subject: [PATCH 105/317] workflow: update release script

---
 CHANGELOG.md       | 1303 ++++++++++++++++++++++++++++++++++++++++++++
 package.json       |   20 +-
 pnpm-lock.yaml     |  577 +++-----------------
 scripts/release.js |  202 +++++++
 scripts/release.sh |   80 ---
 5 files changed, 1589 insertions(+), 593 deletions(-)
 create mode 100644 CHANGELOG.md
 create mode 100644 scripts/release.js
 delete mode 100644 scripts/release.sh

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000000..7ba1cf54d6c
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,1303 @@
+## [2.6.14](https://github.com/vuejs/vue/compare/v2.6.13...v2.6.14) (2021-06-07)
+
+
+### Bug Fixes
+
+* **types:** async Component types ([#11906](https://github.com/vuejs/vue/issues/11906)) ([c52427b](https://github.com/vuejs/vue/commit/c52427b0d2c1d203deea6eb69f2b4b181d56022c))
+* **v-slot:** fix scoped slot normalization combined with v-if ([#12104](https://github.com/vuejs/vue/issues/12104)) ([38f71de](https://github.com/vuejs/vue/commit/38f71de380d566e4eef60968a8eca6bd6f482dd5))
+
+
+### Features
+
+* **ssr:** vue-ssr-webpack-plugin compatible with webpack 5 ([#12002](https://github.com/vuejs/vue/issues/12002)) ([80e7730](https://github.com/vuejs/vue/commit/80e7730946538e0371e213100a0fe81299c2f4b2))
+
+
+
+## [2.6.13](https://github.com/vuejs/vue/compare/v2.6.12...v2.6.13) (2021-06-01)
+
+
+### Bug Fixes
+
+* **attrs:** do not consider translate attribute as boolean ([#11392](https://github.com/vuejs/vue/issues/11392)) ([cd57393](https://github.com/vuejs/vue/commit/cd57393fd3e2c169d450607bc4f03652d106bcc2)), closes [#11391](https://github.com/vuejs/vue/issues/11391)
+* **compiler:** Allow BigInt usage in templates ([#11152](https://github.com/vuejs/vue/issues/11152)) ([c42b706](https://github.com/vuejs/vue/commit/c42b7066cae7947e9fd877e495aeb38623c2354d))
+* **compiler:** avoid converting &nbps; to spaces ([#11065](https://github.com/vuejs/vue/issues/11065)) ([55a30cf](https://github.com/vuejs/vue/commit/55a30cf9db247eba2aca817439fdb3cd15e9184f))
+* **compiler:** event handlers with modifiers swallowing arguments (fix [#10867](https://github.com/vuejs/vue/issues/10867)) ([#10958](https://github.com/vuejs/vue/issues/10958)) ([8620706](https://github.com/vuejs/vue/commit/862070662dd4871cb834664435ec836df57c7d57))
+* **core:** fix sameVnode for async component ([#11107](https://github.com/vuejs/vue/issues/11107)) ([5260830](https://github.com/vuejs/vue/commit/52608302e9bca84fb9e9f0499e89acade78d3d07))
+* **core:** remove trailing comma in function signature ([#10845](https://github.com/vuejs/vue/issues/10845)) ([579e1ff](https://github.com/vuejs/vue/commit/579e1ff9df1d454f85fac386d098b7bf1a42c4f2)), closes [#10843](https://github.com/vuejs/vue/issues/10843)
+* **errorHandler:** async error handling for watchers ([#9484](https://github.com/vuejs/vue/issues/9484)) ([e4dea59](https://github.com/vuejs/vue/commit/e4dea59f84dfbf32cda1cdd832380dd90b1a6fd1))
+* force update between two components with and without slot ([#11795](https://github.com/vuejs/vue/issues/11795)) ([77b5330](https://github.com/vuejs/vue/commit/77b5330c5498a6b14a83197371e9a2dbf9939a9c))
+* give correct namespace in foreignObject ([#11576](https://github.com/vuejs/vue/issues/11576)) ([af5e05d](https://github.com/vuejs/vue/commit/af5e05d87ecd218f73302a1b08dcaedd2b46814a)), closes [#11575](https://github.com/vuejs/vue/issues/11575)
+* handle async placeholders in normalizeScopedSlot ([#11963](https://github.com/vuejs/vue/issues/11963)) ([af54514](https://github.com/vuejs/vue/commit/af54514cf97e724d224408c1ecc6c81ddccd4b75))
+* **keep-alive:** cache what is really needed not the whole VNode data ([#12015](https://github.com/vuejs/vue/issues/12015)) ([e7baaa1](https://github.com/vuejs/vue/commit/e7baaa12055231c9367fa1c7bf917e534bd8a739))
+* **parser:** allow multiple slots with new syntax ([#9785](https://github.com/vuejs/vue/issues/9785)) ([67825c2](https://github.com/vuejs/vue/commit/67825c24bcb0a9f64055bda1b1e4af66aad3c529)), closes [#9781](https://github.com/vuejs/vue/issues/9781)
+* pause dep collection during immediate watcher invocation ([#11943](https://github.com/vuejs/vue/issues/11943)) ([987f322](https://github.com/vuejs/vue/commit/987f322b8f419cc307f4294173f8792a706ed73f))
+* **props:** correctly warn when a provided prop is Symbol ([#10529](https://github.com/vuejs/vue/issues/10529)) ([abb5ef3](https://github.com/vuejs/vue/commit/abb5ef35dd02919dce19c895ad12113071712df0)), closes [#10519](https://github.com/vuejs/vue/issues/10519)
+* **props:** support BigInt in props type validation ([#11191](https://github.com/vuejs/vue/issues/11191)) ([fa1f81e](https://github.com/vuejs/vue/commit/fa1f81e91062e9de6161708209cd7354733aa354))
+* **slot:** add a function to return the slot fallback content ([#12014](https://github.com/vuejs/vue/issues/12014)) ([ce457f9](https://github.com/vuejs/vue/commit/ce457f9f4d48548d5e8763c47d013e23c2b65c12))
+* **ssr:** avoid missing files in manifest ([#11609](https://github.com/vuejs/vue/issues/11609)) ([b97606c](https://github.com/vuejs/vue/commit/b97606cdc658448b56518ac27af98fc82999d05f))
+* **ssr:** inheritAttrs false adds attributes to html ([#11706](https://github.com/vuejs/vue/issues/11706)) ([7e5dc6b](https://github.com/vuejs/vue/commit/7e5dc6bd9ebc1620624191804d2ace43cae557a8))
+* **ssr:** textarea keeps undefined/null values ([#11121](https://github.com/vuejs/vue/issues/11121)) ([b8bd149](https://github.com/vuejs/vue/commit/b8bd149d8aa3f175a1a656d62f7b6ec60c31a364))
+* **types:** add types for Vue.util.warn function ([#11964](https://github.com/vuejs/vue/issues/11964)) ([e0274e4](https://github.com/vuejs/vue/commit/e0274e4320f68bb93bd7f90bb1ef701ccf9b6f2a)), closes [/github.com/vuejs/vue/blob/v2.6.12/src/core/util/debug.js#L18-L26](https://github.com//github.com/vuejs/vue/blob/v2.6.12/src/core/util/debug.js/issues/L18-L26)
+* **types:** allow string for watch handlers in options ([#10396](https://github.com/vuejs/vue/issues/10396)) ([668e1e6](https://github.com/vuejs/vue/commit/668e1e637461ff630803e85bf99158415d276d4c))
+* **types:** allow symbol &  boolean for vnode key ([#11914](https://github.com/vuejs/vue/issues/11914)) ([5c459f0](https://github.com/vuejs/vue/commit/5c459f0fd6911daca09ad205aecf5423a9d05698))
+* **types:** changed expression type to optional string ([#11189](https://github.com/vuejs/vue/issues/11189)) ([7c75462](https://github.com/vuejs/vue/commit/7c754623541c492161f7976203f0b1697a9a0113)), closes [#10871](https://github.com/vuejs/vue/issues/10871)
+* **types:** make $refs undefined possible ([#11112](https://github.com/vuejs/vue/issues/11112)) ([2b93e86](https://github.com/vuejs/vue/commit/2b93e86aa1437168476cbb5100cfb3bbbac55efa))
+* **v-on:** avoid events with empty keyCode (autocomplete) ([#11326](https://github.com/vuejs/vue/issues/11326)) ([c6d7a6f](https://github.com/vuejs/vue/commit/c6d7a6fce795ffbd6b8a599787eca986bb260a25))
+* **v-pre:** do not alter attributes ([#10088](https://github.com/vuejs/vue/issues/10088)) ([0664cb0](https://github.com/vuejs/vue/commit/0664cb01434f3d52efd076b6aafe54066a2a762a)), closes [#10087](https://github.com/vuejs/vue/issues/10087)
+* **vdom:** avoid executing root level script tags ([#11487](https://github.com/vuejs/vue/issues/11487)) ([fb16d7b](https://github.com/vuejs/vue/commit/fb16d7bfa1e32c21a2f4b627fb8864d3c5c6b655)), closes [#11483](https://github.com/vuejs/vue/issues/11483)
+* **warn:** better message with no constructors props ([#9241](https://github.com/vuejs/vue/issues/9241)) ([6940131](https://github.com/vuejs/vue/commit/69401311f4bf55e58550a2134c33ceb8ae1f180e))
+* **warns:** modify `maybeComponent` function in parser ([#10167](https://github.com/vuejs/vue/issues/10167)) ([0603ff6](https://github.com/vuejs/vue/commit/0603ff695d2f41286239298210113cbe2b209e28)), closes [#10152](https://github.com/vuejs/vue/issues/10152)
+
+
+### Features
+
+* **warns:** avoid warning native modifiers on dynamic components ([#11052](https://github.com/vuejs/vue/issues/11052)) ([3d46692](https://github.com/vuejs/vue/commit/3d46692ee4e8ec67b5bc0f66cdabf4667fa4de88))
+* **warn:** warn computed conflict with methods ([#10119](https://github.com/vuejs/vue/issues/10119)) ([3ad60fe](https://github.com/vuejs/vue/commit/3ad60fea73d042fc9a127d19de8329948d3f2ef0))
+
+
+### Performance Improvements
+
+* preinitialize typeCheck RegExp ([#10990](https://github.com/vuejs/vue/issues/10990)) ([2488a6a](https://github.com/vuejs/vue/commit/2488a6a1e9779f0cca4a64163ef44ac30530a450))
+
+
+
+## [2.6.12](https://github.com/vuejs/vue/compare/v2.6.11...v2.6.12) (2020-08-20)
+
+
+### Bug Fixes
+
+* **security:** upgrade serialize-javascript ([#11434](https://github.com/vuejs/vue/issues/11434)) ([5b39961](https://github.com/vuejs/vue/commit/5b399612d8323ad0bb8b3f6fa8b2982ab73c0e6e))
+
+
+
+## [2.6.11](https://github.com/vuejs/vue/compare/v2.6.10...v2.6.11) (2019-12-13)
+
+
+### Bug Fixes
+
+* **compiler:** Remove the warning for valid v-slot value ([#9917](https://github.com/vuejs/vue/issues/9917)) ([085d188](https://github.com/vuejs/vue/commit/085d188379af98e9f482d7e2009ebfd771bd7ca5))
+* fix function expression regex ([#9922](https://github.com/vuejs/vue/issues/9922)) ([569b728](https://github.com/vuejs/vue/commit/569b728ab19d1956bf935a98c9c65a03d92ac85f)), closes [#9920](https://github.com/vuejs/vue/issues/9920)
+* **types:** fix global namespace declaration for UMD bundle ([#9912](https://github.com/vuejs/vue/issues/9912)) ([ab50e8e](https://github.com/vuejs/vue/commit/ab50e8e1da2f4f944af683252481728485fedf16))
+* **types:** fix prop constructor type inference ([#10779](https://github.com/vuejs/vue/issues/10779)) ([4821149](https://github.com/vuejs/vue/commit/4821149b8bbd4650b1d9c9c3cfbb539ac1e24589))
+
+
+
+## [2.6.10](https://github.com/vuejs/vue/compare/v2.6.9...v2.6.10) (2019-03-20)
+
+
+### Bug Fixes
+
+* **codegen:** support named function expression in v-on ([#9709](https://github.com/vuejs/vue/issues/9709)) ([3433ba5](https://github.com/vuejs/vue/commit/3433ba5beef9a6dd97705943c3441ebbee222afd)), closes [#9707](https://github.com/vuejs/vue/issues/9707)
+* **core:** cleanup timeouts for async components ([#9649](https://github.com/vuejs/vue/issues/9649)) ([02d21c2](https://github.com/vuejs/vue/commit/02d21c265c239682e73b2b3f98028f2da5e7205d)), closes [#9648](https://github.com/vuejs/vue/issues/9648)
+* **core:** only unset dom prop when not present ([f11449d](https://github.com/vuejs/vue/commit/f11449d916a468651d4fd5024c37e3eebbc9941f)), closes [#9650](https://github.com/vuejs/vue/issues/9650)
+* **core:** use window.performance for compatibility in JSDOM ([#9700](https://github.com/vuejs/vue/issues/9700)) ([653c74e](https://github.com/vuejs/vue/commit/653c74e64e5ccd66cda94c77577984f8afa8386d)), closes [#9698](https://github.com/vuejs/vue/issues/9698)
+* **scheduler:** revert timeStamp check ([22790b2](https://github.com/vuejs/vue/commit/22790b250cd5239a8379b4ec8cc3a9b570dac4bc)), closes [#9729](https://github.com/vuejs/vue/issues/9729) [#9632](https://github.com/vuejs/vue/issues/9632)
+* **slots:** fix slots not updating when passing down normal slots as $scopedSlots ([ebc1893](https://github.com/vuejs/vue/commit/ebc1893faccd1a9d953a8e8feddcb49cf1b9004d)), closes [#9699](https://github.com/vuejs/vue/issues/9699)
+* **types:** allow using functions on the PropTypes ([#9733](https://github.com/vuejs/vue/issues/9733)) ([df4af4b](https://github.com/vuejs/vue/commit/df4af4bd1906b9f23b62816142fdfbd6336d3d2f)), closes [#9692](https://github.com/vuejs/vue/issues/9692)
+* **types:** support string type for style in VNode data ([#9728](https://github.com/vuejs/vue/issues/9728)) ([982d5a4](https://github.com/vuejs/vue/commit/982d5a492fb95577217e2dacaa044eabe78a8601)), closes [#9727](https://github.com/vuejs/vue/issues/9727)
+
+
+
+## [2.6.9](https://github.com/vuejs/vue/compare/v2.6.8...v2.6.9) (2019-03-14)
+
+
+### Bug Fixes
+
+* **compiler:** whitespace: 'condense' should honor pre tag as well ([#9660](https://github.com/vuejs/vue/issues/9660)) ([f1bdd7f](https://github.com/vuejs/vue/commit/f1bdd7ff9d1fc86f7a8ad8d5cb6d9abc7b2e47f3))
+* event timeStamp check for Qt ([7591b9d](https://github.com/vuejs/vue/commit/7591b9dc6dde314f2d32dcd7a8355f696a330979)), closes [#9681](https://github.com/vuejs/vue/issues/9681)
+* **scheduler:** fix getNow check in IE9 ([#9647](https://github.com/vuejs/vue/issues/9647)) ([da77d6a](https://github.com/vuejs/vue/commit/da77d6a98bdccd8a2c8bfdfe6b9cb46efcb1193c)), closes [#9632](https://github.com/vuejs/vue/issues/9632)
+* **scheduler:** getNow detection can randomly fail ([#9667](https://github.com/vuejs/vue/issues/9667)) ([ef2a380](https://github.com/vuejs/vue/commit/ef2a380c6eb6bd1a7ff516c357dafa717e75a745))
+* should consider presence of normal slots when caching normalized scoped slots ([9313cf9](https://github.com/vuejs/vue/commit/9313cf91740e1d43c43cf9e73d905dbab913beb5)), closes [#9644](https://github.com/vuejs/vue/issues/9644)
+* should not swallow user catch on rejected promise in methods ([7186940](https://github.com/vuejs/vue/commit/7186940143704acc4ec046132f6a56e9c983e510)), closes [#9694](https://github.com/vuejs/vue/issues/9694)
+* should use fallback for scoped slots with single falsy v-if ([781c705](https://github.com/vuejs/vue/commit/781c70514e01bc402828946805bfad7437c7175e)), closes [#9658](https://github.com/vuejs/vue/issues/9658)
+* **ssr:** fix nested async functional componet rendering ([#9673](https://github.com/vuejs/vue/issues/9673)) ([8082d2f](https://github.com/vuejs/vue/commit/8082d2f910d963f14c151fb445e0fcc5c975cca9)), closes [#9643](https://github.com/vuejs/vue/issues/9643)
+* **ssr:** not push non-async css files into map ([#9677](https://github.com/vuejs/vue/issues/9677)) ([d282400](https://github.com/vuejs/vue/commit/d28240009c4c49fb2ef42a79206f0d9ad03f736c))
+* **transition:** fix appear check for transition wrapper components ([#9668](https://github.com/vuejs/vue/issues/9668)) ([4de4649](https://github.com/vuejs/vue/commit/4de4649d9637262a9b007720b59f80ac72a5620c))
+* v-bind object should be overridable by single bindings ([#9653](https://github.com/vuejs/vue/issues/9653)) ([0b57380](https://github.com/vuejs/vue/commit/0b57380f10986c6b07e3c240acc06bfd2eddfd1b)), closes [#9641](https://github.com/vuejs/vue/issues/9641)
+
+
+
+## [2.6.8](https://github.com/vuejs/vue/compare/v2.6.7...v2.6.8) (2019-03-01)
+
+
+### Bug Fixes
+
+* avoid compression of unicode sequences by using regexps ([#9595](https://github.com/vuejs/vue/issues/9595)) ([7912f75](https://github.com/vuejs/vue/commit/7912f75c5eb09e0aef3e4bfd8a3bb78cad7540d7)), closes [#9456](https://github.com/vuejs/vue/issues/9456)
+* **compiler:** set end location for incomplete elements ([#9598](https://github.com/vuejs/vue/issues/9598)) ([cbad54a](https://github.com/vuejs/vue/commit/cbad54aa52847cfc934bb925d53c53ee57fc153d))
+* fix modifier parsing for dynamic argument with deep path ([#9585](https://github.com/vuejs/vue/issues/9585)) ([060c3b9](https://github.com/vuejs/vue/commit/060c3b98efa44a9f21bcc038a2593b1cc3c782e9)), closes [#9577](https://github.com/vuejs/vue/issues/9577)
+* further adjust max stack size ([571a488](https://github.com/vuejs/vue/commit/571a4880fc06b491a280325b79fd4cbb59ceb47e)), closes [#9562](https://github.com/vuejs/vue/issues/9562)
+* handle async component when parent is toggled before resolve ([#9572](https://github.com/vuejs/vue/issues/9572)) ([ed34113](https://github.com/vuejs/vue/commit/ed341137b23315b76ba391db1b0e537950c091e1)), closes [#9571](https://github.com/vuejs/vue/issues/9571)
+* scoped slots dynamic check should include v-for on element itself ([2277b23](https://github.com/vuejs/vue/commit/2277b2322cf81b5830a5b85f6600e1896edc7aa9)), closes [#9596](https://github.com/vuejs/vue/issues/9596)
+* **types:** allow scoped slots to return a single VNode ([#9563](https://github.com/vuejs/vue/issues/9563)) ([241eea1](https://github.com/vuejs/vue/commit/241eea19a64550bfdb3f9d7e4197127997572842))
+* **types:** update this for nextTick api ([#9541](https://github.com/vuejs/vue/issues/9541)) ([f333016](https://github.com/vuejs/vue/commit/f33301619d18b9392597c5230af17921c0b42466))
+
+
+
+## [2.6.7](https://github.com/vuejs/vue/compare/v2.6.6...v2.6.7) (2019-02-21)
+
+
+### Bug Fixes
+
+* **#9511:** avoid promise catch multiple times ([#9526](https://github.com/vuejs/vue/issues/9526)) ([2f3020e](https://github.com/vuejs/vue/commit/2f3020e9cc1ad5c878606b56bb73a30b1d9bb7d9)), closes [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511)
+* avoid errors thrown during dom props update ([8a80a23](https://github.com/vuejs/vue/commit/8a80a23ecba23f92f278d664388050ffcd121385)), closes [#9459](https://github.com/vuejs/vue/issues/9459)
+* avoid possible infinite loop by accessing observables in error handler ([#9489](https://github.com/vuejs/vue/issues/9489)) ([ee29e41](https://github.com/vuejs/vue/commit/ee29e41ef469b3ca3c793f04289075e3b128447f))
+* **compiler:** handle negative length in codeframe repeat ([7a8de91](https://github.com/vuejs/vue/commit/7a8de91cd78f523fabe8452652513250871a01c6))
+* ensure generated scoped slot code is compatible with 2.5 ([7ec4627](https://github.com/vuejs/vue/commit/7ec4627902020cccd7b3f4fbc63e1b0d6b9798cd)), closes [#9545](https://github.com/vuejs/vue/issues/9545)
+* ensure scoped slots update in conditional branches ([d9b27a9](https://github.com/vuejs/vue/commit/d9b27a92bd5277ee23a4e68a8bd31ecc72f4c99b)), closes [#9534](https://github.com/vuejs/vue/issues/9534)
+* scoped slots should update when inside v-for ([8f004ea](https://github.com/vuejs/vue/commit/8f004ea44e06d7764fa884212fa95c2033515928)), closes [#9506](https://github.com/vuejs/vue/issues/9506)
+
+
+
+## [2.6.6](https://github.com/vuejs/vue/compare/v2.6.5...v2.6.6) (2019-02-12)
+
+
+### Bug Fixes
+
+* ensure scoped slot containing passed down slot content updates properly ([21fca2f](https://github.com/vuejs/vue/commit/21fca2fffc3a75235a6656eb85ae40835e04bf69))
+* fix keyCode check for Chrome autofill fake key events ([29c348f](https://github.com/vuejs/vue/commit/29c348f3cf60c50a52cc98123f8c54fa8f5672fc)), closes [#9441](https://github.com/vuejs/vue/issues/9441)
+
+
+
+## [2.6.5](https://github.com/vuejs/vue/compare/v2.6.4...v2.6.5) (2019-02-11)
+
+
+### Bug Fixes
+
+* allow passing multiple arguments to scoped slot ([e7d49cd](https://github.com/vuejs/vue/commit/e7d49cdcf2fd9a612e0dac7a7bea318824210881)), closes [#9468](https://github.com/vuejs/vue/issues/9468)
+* bail out of event blocking for iOS bug ([0bad7e2](https://github.com/vuejs/vue/commit/0bad7e2a3508b55abaa8aec2a1bd9c1127305cb4)), closes [#9462](https://github.com/vuejs/vue/issues/9462)
+* do not cache scoped slots when mixed with normal slots ([060686d](https://github.com/vuejs/vue/commit/060686d6ea4d013129b4d2e93d7d2e5c93e09686))
+
+
+
+## [2.6.4](https://github.com/vuejs/vue/compare/v2.6.3...v2.6.4) (2019-02-08)
+
+
+### Bug Fixes
+
+* avoid breaking avoriaz edge case ([9011b83](https://github.com/vuejs/vue/commit/9011b83db79cf2f3563f8fccb2e41b5b863c3ee9))
+* avoid logging same error twice when thrown by user in global handler ([ca57920](https://github.com/vuejs/vue/commit/ca57920edb56000bfc87bb64f4e5e3450c03e13a)), closes [#9445](https://github.com/vuejs/vue/issues/9445)
+* empty scoped slot should return undefined ([57bc80a](https://github.com/vuejs/vue/commit/57bc80a546acb2bd092edd393228324b453ae4e2)), closes [#9452](https://github.com/vuejs/vue/issues/9452)
+* expose v-slot slots without scope on this.$slots ([0e8560d](https://github.com/vuejs/vue/commit/0e8560d0fc1c0fbf3a52464939701e0e44543b00)), closes [#9421](https://github.com/vuejs/vue/issues/9421) [#9458](https://github.com/vuejs/vue/issues/9458)
+* new syntax slots without scope should also be exposed on functional slots() ([8a80086](https://github.com/vuejs/vue/commit/8a800867fe61e5aa642e1e3da91bb890d07312f7))
+
+
+### Performance Improvements
+
+* cache result from functional ctx.slots() calls ([7a0dfd0](https://github.com/vuejs/vue/commit/7a0dfd0badf3054c95ac1ec66cc6e213f1592c95))
+* skip scoped slots normalization when possible ([099f3ba](https://github.com/vuejs/vue/commit/099f3ba60085a089ff369442bdb835f3868e47c0))
+
+
+
+## [2.6.3](https://github.com/vuejs/vue/compare/v2.6.2...v2.6.3) (2019-02-06)
+
+
+### Bug Fixes
+
+* async component should use render owner as force update context ([b9de23b](https://github.com/vuejs/vue/commit/b9de23b1008b52deca7e7df40843e318a42f3f53)), closes [#9432](https://github.com/vuejs/vue/issues/9432)
+* avoid exposing internal flags on $scopedSlots ([24b4640](https://github.com/vuejs/vue/commit/24b4640c1f268722f5ab8f03e68e2df897cfbdf6)), closes [#9443](https://github.com/vuejs/vue/issues/9443)
+* bail out scoped slot optimization when there are nested scopes ([4d4d22a](https://github.com/vuejs/vue/commit/4d4d22a3f6017c46d08b67afe46af43027b06629)), closes [#9438](https://github.com/vuejs/vue/issues/9438)
+* **compiler:** fix v-bind dynamic arguments on slot outlets ([96a09aa](https://github.com/vuejs/vue/commit/96a09aad99bdecbcc0e5c420077bf41893d4a745)), closes [#9444](https://github.com/vuejs/vue/issues/9444)
+* skip microtask fix if event is fired from different document ([dae7e41](https://github.com/vuejs/vue/commit/dae7e4182fbbb41e599953cc22e5d54dbb164070)), closes [#9448](https://github.com/vuejs/vue/issues/9448)
+* skip microtask fix in Firefix <= 53 ([7bc88f3](https://github.com/vuejs/vue/commit/7bc88f30c3eadded07dd5b460d1e7cb9342d017c)), closes [#9446](https://github.com/vuejs/vue/issues/9446)
+* **types:** add Vue.version to types ([#9431](https://github.com/vuejs/vue/issues/9431)) ([54e6a12](https://github.com/vuejs/vue/commit/54e6a121e992f20c03f104533caa4c59e59b1ee7))
+
+
+### Reverts
+
+* feat: expose all scoped slots on this.$slots ([d5ade28](https://github.com/vuejs/vue/commit/d5ade28652b07303ac6b713813792752ae5e4e04))
+
+
+
+## [2.6.2](https://github.com/vuejs/vue/compare/v2.6.1...v2.6.2) (2019-02-05)
+
+
+### Bug Fixes
+
+* always set transformed model value on attrs ([b034abf](https://github.com/vuejs/vue/commit/b034abf48e793189ce8796c259eed2fbfb79bcd0))
+* restore slot-scope + v-if behavior ([44a4ca3](https://github.com/vuejs/vue/commit/44a4ca33b95070e9aa53c6924479519d86dd9b36)), closes [#9422](https://github.com/vuejs/vue/issues/9422)
+
+
+### Features
+
+* expose all scoped slots on this.$slots ([0129b0e](https://github.com/vuejs/vue/commit/0129b0eb12a1f98a722f100892bfc5e60b0f51ce)), closes [#9421](https://github.com/vuejs/vue/issues/9421)
+
+
+
+## [2.6.1](https://github.com/vuejs/vue/compare/v2.6.0...v2.6.1) (2019-02-04)
+
+
+### Bug Fixes
+
+* avoid blocking first input event in IE when it shouldn't ([#9297](https://github.com/vuejs/vue/issues/9297)) ([0fb03b7](https://github.com/vuejs/vue/commit/0fb03b7831693b4abc90dd0bfe971c36c02d82a6)), closes [#7138](https://github.com/vuejs/vue/issues/7138) [#9042](https://github.com/vuejs/vue/issues/9042) [#9383](https://github.com/vuejs/vue/issues/9383)
+* avoid isPromise check when handler return value is Vue instance ([b6b42ca](https://github.com/vuejs/vue/commit/b6b42ca8c41963be292caa266ce4330603f4c4eb)), closes [#9418](https://github.com/vuejs/vue/issues/9418)
+* **compiler:** fix inline-template crashing ([#9365](https://github.com/vuejs/vue/issues/9365)) ([55bfb94](https://github.com/vuejs/vue/commit/55bfb94a33ecc9b33131ec0fb78bba2946e8fc75)), closes [#9361](https://github.com/vuejs/vue/issues/9361)
+* decode single quotes in html attributes ([#9341](https://github.com/vuejs/vue/issues/9341)) ([c27fe24](https://github.com/vuejs/vue/commit/c27fe24dc6088b517ab17c799a1852f97c22c076))
+* **template-compiler:** allow comments on the root node in templates ([#9408](https://github.com/vuejs/vue/issues/9408)) ([1922e7d](https://github.com/vuejs/vue/commit/1922e7d4d99d0397223b3919a1643aacb7afbbab)), closes [#9407](https://github.com/vuejs/vue/issues/9407)
+* **v-model:** add value to $attrs if not defined in props ([#9331](https://github.com/vuejs/vue/issues/9331)) ([66fd3c8](https://github.com/vuejs/vue/commit/66fd3c8dd1577d4b634731adf4be4d3db5bf1df6)), closes [#9330](https://github.com/vuejs/vue/issues/9330)
+
+
+
+# [2.6.0](https://github.com/vuejs/vue/compare/v2.6.0-beta.3...v2.6.0) (2019-02-04)
+
+
+### Bug Fixes
+
+* allow more enumerated values for contenteditable ([e632e9a](https://github.com/vuejs/vue/commit/e632e9a0759532e1d902871ca07b02c9ac267e7c)), closes [#9397](https://github.com/vuejs/vue/issues/9397)
+* fix child forceUpdate regression ([44a17ba](https://github.com/vuejs/vue/commit/44a17ba2cde7fb9a673486d44de7f29feb5c1882)), closes [#9396](https://github.com/vuejs/vue/issues/9396)
+* fix v-bind:style for camelCase properties with !important  ([#9386](https://github.com/vuejs/vue/issues/9386)) ([539e481](https://github.com/vuejs/vue/commit/539e481f38706a6202f0eacf54c579362fbd5bb4))
+* template v-slot should work with v-else conditions ([2807fd2](https://github.com/vuejs/vue/commit/2807fd24b0c17179336f84d1725b69cd3c7a0aca))
+
+
+### Features
+
+* move v-bind.prop shorthand behind flag ([64f863b](https://github.com/vuejs/vue/commit/64f863bbb9c8147819ef4547dfdadba0239c6d59))
+
+
+
+# [2.6.0-beta.3](https://github.com/vuejs/vue/compare/v2.6.0-beta.2...v2.6.0-beta.3) (2019-01-30)
+
+
+### Features
+
+* detect and warn invalid dynamic argument expressions ([c9e3a5d](https://github.com/vuejs/vue/commit/c9e3a5d1d92500ac1e1d1eb6f3866a9df5eecf53))
+
+
+
+# [2.6.0-beta.2](https://github.com/vuejs/vue/compare/v2.6.0-beta.1...v2.6.0-beta.2) (2019-01-26)
+
+
+### Bug Fixes
+
+* async edge case fix should apply to more browsers ([ba0ebd4](https://github.com/vuejs/vue/commit/ba0ebd4771ddb5c56c1261f82c842b57ca7163a6))
+* fix checkbox event edge case in Firefox ([1868561](https://github.com/vuejs/vue/commit/1868561442507690f07579c258f4db19a650fb9a))
+
+
+### Features
+
+* adjust v-slot per RFC + enable flag ([67e85de](https://github.com/vuejs/vue/commit/67e85deae2b9720624ed7b20223b905a882942a0))
+* dynamic directive arguments for v-on, v-bind and custom directives ([#9373](https://github.com/vuejs/vue/issues/9373)) ([dbc0582](https://github.com/vuejs/vue/commit/dbc0582587f90e78867809bb6ae683301cd0626b))
+* **ssr:** allow template option to be function in renderToString ([#9324](https://github.com/vuejs/vue/issues/9324)) ([b65f6d7](https://github.com/vuejs/vue/commit/b65f6d78e0e480601b0042b1b5e8259343b629fb))
+* update new slot syntax per RFC revision ([4fca045](https://github.com/vuejs/vue/commit/4fca0454bd716a5d3ba32057ff2ed510af933c8d))
+* warning for ambiguous v-slot usage ([8d84572](https://github.com/vuejs/vue/commit/8d8457246daac543c5935aa3cbf62d362431da43))
+
+
+### Performance Improvements
+
+* improve scoped slots change detection accuracy ([#9371](https://github.com/vuejs/vue/issues/9371)) ([f219bed](https://github.com/vuejs/vue/commit/f219bedae8f9cab131eb5529769bcfdc91ce2912))
+
+
+
+# [2.6.0-beta.1](https://github.com/vuejs/vue/compare/v2.5.22...v2.6.0-beta.1) (2019-01-16)
+
+
+### Bug Fixes
+
+* allow _ in watch paths (element compat) ([8b382b3](https://github.com/vuejs/vue/commit/8b382b3efb14986e9ea5213d0b57c244b70ae0e7))
+* always use microtasks for nextTick ([#8450](https://github.com/vuejs/vue/issues/8450)) ([850555d](https://github.com/vuejs/vue/commit/850555d1faa9be7d8306adffd95c7dee5e58717f)), closes [#7109](https://github.com/vuejs/vue/issues/7109) [#7546](https://github.com/vuejs/vue/issues/7546) [#7707](https://github.com/vuejs/vue/issues/7707) [#7834](https://github.com/vuejs/vue/issues/7834) [#8109](https://github.com/vuejs/vue/issues/8109) [#6566](https://github.com/vuejs/vue/issues/6566)
+* **core:** dedupe lifecycle hooks during options merge ([edf7df0](https://github.com/vuejs/vue/commit/edf7df0c837557dd3ea8d7b42ad8d4b21858ade0)), closes [#9199](https://github.com/vuejs/vue/issues/9199)
+* **core:** fix merged twice bug when passing extended constructor to mixins ([#9199](https://github.com/vuejs/vue/issues/9199)) ([5371617](https://github.com/vuejs/vue/commit/537161779ea329c1d0a993997555f1c692b8cac1)), closes [#9198](https://github.com/vuejs/vue/issues/9198)
+* cover more cases in v-on inline return value ([9432737](https://github.com/vuejs/vue/commit/9432737cf871335c42ce0dc0a0baa21a4d8c3832))
+* ensure only nromalize a scoped slot when it is present ([5fb23d4](https://github.com/vuejs/vue/commit/5fb23d4e2971480d14fbee0146e3416a07bc0b9f))
+* ensure proxied normal slot uses correct key ([b32c4b6](https://github.com/vuejs/vue/commit/b32c4b693535c35ae10742eb3351cbc123b15941))
+* make transition-group key warning a tip to avoid breaking compilation ([d08b49f](https://github.com/vuejs/vue/commit/d08b49f520e0704f9d4e61be4f751e3b2cdac6a8))
+* **next-tick:** revert 60da366 ([080dd97](https://github.com/vuejs/vue/commit/080dd971f77f7c631650c4e3027d1802f4e804d8)), closes [#8436](https://github.com/vuejs/vue/issues/8436)
+* **provide/inject:** Merges symbol provides ([#7926](https://github.com/vuejs/vue/issues/7926)) ([1933ee8](https://github.com/vuejs/vue/commit/1933ee80ff808b81a691fa6a135c1588d218bc0a))
+* return inline invocation return value in v-on handlers ([0ebb0f3](https://github.com/vuejs/vue/commit/0ebb0f39dfee0a5c03adb2f312f617cca37b44d6)), closes [#7628](https://github.com/vuejs/vue/issues/7628)
+* **runtime:** DevTools recommendation shows for all browsers ([#8638](https://github.com/vuejs/vue/issues/8638)) ([22ad266](https://github.com/vuejs/vue/commit/22ad26615104c15fd09bc69692e3042bb1bb58e9)), closes [#8634](https://github.com/vuejs/vue/issues/8634)
+* **scoped-slots:** ensure $scopedSlots calls always return Arrays ([c7c13c2](https://github.com/vuejs/vue/commit/c7c13c2a156269d29fd9c9f8f6a3e53a2f2cac3d)), closes [#8056](https://github.com/vuejs/vue/issues/8056)
+* **ssr:** properly handle invalid and numeric style properties ([7d9cfeb](https://github.com/vuejs/vue/commit/7d9cfebe39ffd531e0948668e688474b276cdec1)), closes [#9231](https://github.com/vuejs/vue/issues/9231)
+* **ssr:** should not render invalid numeric style values ([17d8bcb](https://github.com/vuejs/vue/commit/17d8bcb60edc14b2c23f5e6cc92f030897092e21))
+* **ssr:** should render 0 as valid value for style property with unit ([aef5b4e](https://github.com/vuejs/vue/commit/aef5b4e47811cb842315bd27d6919650da45279b))
+
+
+### Features
+
+* add browser ESM build ([861abf4](https://github.com/vuejs/vue/commit/861abf4bb940e89a6ae3c5c3e2dad4ed0bd53b3e))
+* add Vue.observable() for explicitly creating observable objects ([c50bbde](https://github.com/vuejs/vue/commit/c50bbde41c4a1868a8a0b33df3238346840bd37c))
+* **compiler/watch:** allow unicode characters in component names and watch paths ([#8666](https://github.com/vuejs/vue/issues/8666)) ([9c71852](https://github.com/vuejs/vue/commit/9c718522bac60d13d3b48d6b6512fccfd5cf8858)), closes [#8564](https://github.com/vuejs/vue/issues/8564)
+* **compiler:** add whitespace option, deprecate preserveWhitespace option ([e1abedb](https://github.com/vuejs/vue/commit/e1abedb9e66b21da8a7e93e175b9dabe334dfebd)), closes [#9208](https://github.com/vuejs/vue/issues/9208)
+* **compiler:** expose generateCodeFrame method ([a4ed58c](https://github.com/vuejs/vue/commit/a4ed58c076649a4536b40a9c98c974c77602c76b))
+* **compiler:** output codeframe in browser compiler ([325fc76](https://github.com/vuejs/vue/commit/325fc7693c1574e69fe542f1dbc334030a4b1ec3))
+* **compiler:** output source range for compiler errors ([#7127](https://github.com/vuejs/vue/issues/7127)) ([b31a1aa](https://github.com/vuejs/vue/commit/b31a1aa8870474b2ca782c45d55edac2932d4cc2)), closes [#6338](https://github.com/vuejs/vue/issues/6338)
+* **compiler:** support deindent: false in vue-template-compiler ([#7215](https://github.com/vuejs/vue/issues/7215)) ([bf0efb0](https://github.com/vuejs/vue/commit/bf0efb02b1f52cceb0bad8588cf6c90e22349049)), closes [#7054](https://github.com/vuejs/vue/issues/7054)
+* **config:** expose config.useEventDelegation and default to false ([3be1c5d](https://github.com/vuejs/vue/commit/3be1c5d67e8bdfc9387122317bf3779261010d45))
+* **core:** expose all slots on $scopedSlots as functions ([5d52262](https://github.com/vuejs/vue/commit/5d52262f1ce56d080c3438c4773a81dc5c8397aa))
+* **errors:** sync/async error handling for lifecycle hooks and v-on handlers ([#8395](https://github.com/vuejs/vue/issues/8395)) ([6e9fcfc](https://github.com/vuejs/vue/commit/6e9fcfc81d922a1b188268bf50d7e67c07d6d662)), closes [#6953](https://github.com/vuejs/vue/issues/6953) [#7653](https://github.com/vuejs/vue/issues/7653)
+* expose performance measures ([9ae80ac](https://github.com/vuejs/vue/commit/9ae80acde59d9d149ee5e4e2097f209eac6f834f)), closes [#7570](https://github.com/vuejs/vue/issues/7570)
+* **functional:** add scopedSlots to context in functional components ([#7941](https://github.com/vuejs/vue/issues/7941)) ([fb6aa06](https://github.com/vuejs/vue/commit/fb6aa0609045e69a0b6050bc7b6466b63be8d69d))
+* new scoped slot syntax implementation update per rfc ([c5c354d](https://github.com/vuejs/vue/commit/c5c354d593d6f6344e78ca098f1ae1fa3e83d6ed))
+* **ssr:** Add 'nonce' option to context for ssr outlet script ([#8047](https://github.com/vuejs/vue/issues/8047)) ([f036cce](https://github.com/vuejs/vue/commit/f036cce16377cec328bee03a3a4069275b320312)), closes [#7479](https://github.com/vuejs/vue/issues/7479)
+* **ssr:** add custom state serializer option ([4494012](https://github.com/vuejs/vue/commit/44940121eef4e2df5f3cb3c21f3f468af8b336bc)), closes [#6614](https://github.com/vuejs/vue/issues/6614)
+* **ssr:** allow opting-out of caching by returning false in serverCacheKey ([ab24285](https://github.com/vuejs/vue/commit/ab24285458c98e25d5749beb4edebef73672de4b)), closes [#8790](https://github.com/vuejs/vue/issues/8790)
+* **ssr:** ssrPrefetch option + context.rendered hook ([#9017](https://github.com/vuejs/vue/issues/9017)) ([d7a533d](https://github.com/vuejs/vue/commit/d7a533d6f85aae52aed03202fa5ccb774f0cb2ec))
+* support .property shorthand syntax for v-bind.prop modifier ([d2902ca](https://github.com/vuejs/vue/commit/d2902ca8ec5fd184fe81479fea1318553fdb8323)), closes [#7582](https://github.com/vuejs/vue/issues/7582)
+* support custom toString() in text interpolation and v-html ([#8217](https://github.com/vuejs/vue/issues/8217)) ([0e4e45e](https://github.com/vuejs/vue/commit/0e4e45ec741416e0042c29a53bbc0e58c8663f6e)), closes [#8093](https://github.com/vuejs/vue/issues/8093)
+* support slot-props and its shorthand ([584e89d](https://github.com/vuejs/vue/commit/584e89da4ab17e1ebdae0ae10be77ef9d230c7a0))
+* support v-html for SVG elements ([#8652](https://github.com/vuejs/vue/issues/8652)) ([a981c80](https://github.com/vuejs/vue/commit/a981c80d2aedb0d56f98865e39c981819fbf65d0))
+* **types:** add Prop to main type declaration file ([#6856](https://github.com/vuejs/vue/issues/6856)) ([5791072](https://github.com/vuejs/vue/commit/57910723c6ba68386c15e095e42c1ed9603c7bcf)), closes [#6850](https://github.com/vuejs/vue/issues/6850)
+* **types:** add types for vue-template-compiler ([#7918](https://github.com/vuejs/vue/issues/7918)) ([ced774b](https://github.com/vuejs/vue/commit/ced774be6ddbc53884d7a5d395514a9f62e32336))
+* use event delegation when possible ([b7f7f27](https://github.com/vuejs/vue/commit/b7f7f2756928f409950186c5d641034f362b392a)), closes [#6566](https://github.com/vuejs/vue/issues/6566)
+* v-bind.sync also listens for kebab-case update event ([#8297](https://github.com/vuejs/vue/issues/8297)) ([3fca527](https://github.com/vuejs/vue/commit/3fca52792ef83fa58a5c28882706d9e8a039790d)), closes [#6428](https://github.com/vuejs/vue/issues/6428)
+* **v-for:** support iterables in v-for ([#8179](https://github.com/vuejs/vue/issues/8179)) ([d40eb9c](https://github.com/vuejs/vue/commit/d40eb9c2880c8dd27fedb9fbc508823a15742274))
+
+
+
+## [2.5.22](https://github.com/vuejs/vue/compare/v2.5.21...v2.5.22) (2019-01-11)
+
+
+### Bug Fixes
+
+* **async component:** memory leak after synchronous async loading ([#9275](https://github.com/vuejs/vue/issues/9275)) ([d21e931](https://github.com/vuejs/vue/commit/d21e93139697be2c0a6fdc4ee74d30d2834a729f)), closes [#9229](https://github.com/vuejs/vue/issues/9229)
+* **core:** dedupe lifecycle hooks during options merge ([0d2e9c4](https://github.com/vuejs/vue/commit/0d2e9c46f16e9ec5bd0f3eebd2aa31c7f7493856)), closes [#9199](https://github.com/vuejs/vue/issues/9199)
+* **core:** fix merged twice bug when passing extended constructor to mixins ([#9199](https://github.com/vuejs/vue/issues/9199)) ([743edac](https://github.com/vuejs/vue/commit/743edacdb6fa0bb711e860b68373274f50c8baa5)), closes [#9198](https://github.com/vuejs/vue/issues/9198)
+* **ssr:** support rendering comment ([#9128](https://github.com/vuejs/vue/issues/9128)) ([b06c784](https://github.com/vuejs/vue/commit/b06c784b81a244e1bc2d028216fcd2ab873730b9))
+
+
+
+## [2.5.21](https://github.com/vuejs/vue/compare/v2.5.20...v2.5.21) (2018-12-11)
+
+
+### Bug Fixes
+
+* fix single v-for child optimization ([847e493](https://github.com/vuejs/vue/commit/847e493768371cec4718969e02bdb7f8463f4e03))
+* fix v-for component with undefined value ([4748760](https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d)), closes [#9181](https://github.com/vuejs/vue/issues/9181)
+* **lifecycle:** beforeUpdated should not be called if component is destroyed ([#9171](https://github.com/vuejs/vue/issues/9171)) ([87bad80](https://github.com/vuejs/vue/commit/87bad80f0cb9a30b95d9410120ff6e3e2022a723)), closes [#8076](https://github.com/vuejs/vue/issues/8076)
+* **types:** accept primatives and falsy values in createElement children ([#9154](https://github.com/vuejs/vue/issues/9154)) ([d780dd2](https://github.com/vuejs/vue/commit/d780dd2e2adcf71f40c086055a659a9a2b4a8282)), closes [#8498](https://github.com/vuejs/vue/issues/8498)
+* **v-model:** properly handle multiline v-model expressions ([#9184](https://github.com/vuejs/vue/issues/9184)) ([3d44937](https://github.com/vuejs/vue/commit/3d449376d557c4533a9664f95df3a168ecee9bfa)), closes [#9183](https://github.com/vuejs/vue/issues/9183)
+* **weex:** support data class type that is string ([#9139](https://github.com/vuejs/vue/issues/9139)) ([d8285c5](https://github.com/vuejs/vue/commit/d8285c57a613c42eddf2d4f2b75c1cea6aa4703a)), closes [#9124](https://github.com/vuejs/vue/issues/9124)
+
+
+### Performance Improvements
+
+* skip normalization on single child element v-for ([4074104](https://github.com/vuejs/vue/commit/4074104fac219e61e542f4da3a4800975a8063f2))
+
+
+### Reverts
+
+* "chore: use keypress in TodoMVC example for IME input methods ([#9172](https://github.com/vuejs/vue/issues/9172))" ([80fb6b8](https://github.com/vuejs/vue/commit/80fb6b8da144bd9c2313702e23a35d72fa620135))
+
+
+
+## [2.5.20](https://github.com/vuejs/vue/compare/v2.5.19...v2.5.20) (2018-12-10)
+
+
+### Bug Fixes
+
+* **types:** avoid `this` in VueConstructor signature ([#9173](https://github.com/vuejs/vue/issues/9173)) ([e06d2af](https://github.com/vuejs/vue/commit/e06d2af276fc8d626a3b048f4d138a243aa690a4)), closes [/github.com/vuejs/vue-class-component/issues/294#issuecomment-445526936](https://github.com//github.com/vuejs/vue-class-component/issues/294/issues/issuecomment-445526936)
+
+
+
+## [2.5.19](https://github.com/vuejs/vue/compare/v2.5.18...v2.5.19) (2018-12-09)
+
+
+### Bug Fixes
+
+* **ssr:** should not warn for custom directives that do not have ssr implementation ([780dac5](https://github.com/vuejs/vue/commit/780dac561b9cd6c3cec28f154f76e7d28352ebf3)), closes [#9167](https://github.com/vuejs/vue/issues/9167)
+* **vdom:** remove unnecessary sameVnode condition ([0d4b35f](https://github.com/vuejs/vue/commit/0d4b35f55975946cb0eb4f7f5f35efe3d078473e)), closes [#9168](https://github.com/vuejs/vue/issues/9168)
+
+
+### Reverts
+
+* fix(sfc): avoid deindent when pad option is specified ([#7647](https://github.com/vuejs/vue/issues/7647)) ([5d721a4](https://github.com/vuejs/vue/commit/5d721a42b140865e50a78445fe21c5f270bde703))
+
+
+
+## [2.5.18](https://github.com/vuejs/vue/compare/v2.5.18-beta.0...v2.5.18) (2018-12-07)
+
+
+### Bug Fixes
+
+* **compiler:** fix codegen for v-for component inside template ([1b4a8a0](https://github.com/vuejs/vue/commit/1b4a8a0c1edaf9c7eb129ba61bca94ba607bbf56)), closes [#9142](https://github.com/vuejs/vue/issues/9142)
+* fix keyName checking for space and delete in IE11 ([#9150](https://github.com/vuejs/vue/issues/9150)) ([0ed0aad](https://github.com/vuejs/vue/commit/0ed0aad77228b95e9a61a87386736938837527f8)), closes [#9112](https://github.com/vuejs/vue/issues/9112)
+* **ssr:** fix ssr template publicPath generation ([f077ed1](https://github.com/vuejs/vue/commit/f077ed17af14bb2675db64b2aa2d023769219624)), closes [#9145](https://github.com/vuejs/vue/issues/9145)
+* **transition-group:** fix activeInstance regression ([8a2dbf5](https://github.com/vuejs/vue/commit/8a2dbf50105ea729125a42fecfe2c2f0371d7836)), closes [#9151](https://github.com/vuejs/vue/issues/9151)
+* **types:** correct scopedSlot types ([#9131](https://github.com/vuejs/vue/issues/9131)) ([448ba65](https://github.com/vuejs/vue/commit/448ba65d2b139b29f1e6891add9925ac22ffe10b)), closes [#8946](https://github.com/vuejs/vue/issues/8946)
+* **types:** type support for advanced async components ([#8438](https://github.com/vuejs/vue/issues/8438)) ([dfaf9e2](https://github.com/vuejs/vue/commit/dfaf9e24361e10ae68ce3951eaf48262cf90f0ec))
+
+
+
+## [2.5.18-beta.0](https://github.com/vuejs/vue/compare/v2.5.17-beta.0...v2.5.18-beta.0) (2018-12-02)
+
+
+### Bug Fixes
+
+* actually disable dep collection when invoking lifecycle hooks ([#9095](https://github.com/vuejs/vue/issues/9095)) ([0d62bb8](https://github.com/vuejs/vue/commit/0d62bb84ffa1af7a4826aecc11c429c7a020645c)), closes [#9046](https://github.com/vuejs/vue/issues/9046)
+* **compiler:**  wrap scoped slots v-if conditions in parens ([#9119](https://github.com/vuejs/vue/issues/9119)) ([ef8524a](https://github.com/vuejs/vue/commit/ef8524ab7db8d64ac449ce74f5858aa9d91357ad)), closes [#9114](https://github.com/vuejs/vue/issues/9114)
+* **compiler:** maybeComponent should return true when "is" attribute exists ([#8114](https://github.com/vuejs/vue/issues/8114)) ([aef2a5f](https://github.com/vuejs/vue/commit/aef2a5f3dbd5e52ec9d5ce026d7b858539057186)), closes [#8101](https://github.com/vuejs/vue/issues/8101)
+* **compiler:** normalize potential functional component children in v-for ([#8558](https://github.com/vuejs/vue/issues/8558)) ([d483a49](https://github.com/vuejs/vue/commit/d483a49c86874b2e75863b661f81feecd46ae721)), closes [#8468](https://github.com/vuejs/vue/issues/8468)
+* **compiler:** should keep newline after unary tags in <pre> ([#8965](https://github.com/vuejs/vue/issues/8965)) ([05001e6](https://github.com/vuejs/vue/commit/05001e695ebd0b0504d664197a4771463a0f5328)), closes [#8950](https://github.com/vuejs/vue/issues/8950)
+* **compiler:** templates inside v-pre should be rendered to HTML ([#8146](https://github.com/vuejs/vue/issues/8146)) ([ecac831](https://github.com/vuejs/vue/commit/ecac831691d27cf7a10ec73a004d3fbad7623d1a)), closes [#8041](https://github.com/vuejs/vue/issues/8041)
+* **component:** clean up memory leak after loading async component completes (fix [#8740](https://github.com/vuejs/vue/issues/8740)) ([#8755](https://github.com/vuejs/vue/issues/8755)) ([2e472c5](https://github.com/vuejs/vue/commit/2e472c5e5e559a7a4083b4164ffe0c3911ce0651))
+* **core:** avoid mutating original children when cloning vnode ([097f622](https://github.com/vuejs/vue/commit/097f6229dffc34af452b106ad2a3b58845588807)), closes [#7975](https://github.com/vuejs/vue/issues/7975)
+* **core:** properly handle reused vnodes ([530ca1b](https://github.com/vuejs/vue/commit/530ca1b2db315fbd0e360807b2031d26665c5d3d)), closes [#7913](https://github.com/vuejs/vue/issues/7913)
+* **core:** skip mixins and extends if child is already merged ([#8870](https://github.com/vuejs/vue/issues/8870)) ([80f17fa](https://github.com/vuejs/vue/commit/80f17fa498f5df0388412877799dbd7573c44b2d)), closes [#8865](https://github.com/vuejs/vue/issues/8865)
+* **data:** skip recursive call if values are identical ([#8967](https://github.com/vuejs/vue/issues/8967)) ([a7658e0](https://github.com/vuejs/vue/commit/a7658e03a16dc507f0abeba41aee705f773727d0))
+* **error handling:** handle errors on immediate watcher execution ([#8581](https://github.com/vuejs/vue/issues/8581)) ([2686818](https://github.com/vuejs/vue/commit/2686818beb5728e3b7aa22f47a3b3f0d39d90c8e)), closes [#8567](https://github.com/vuejs/vue/issues/8567)
+* fix potential xss vulnerability in ssr when using v-bind ([3d36a44](https://github.com/vuejs/vue/commit/3d36a443c755bf16f2656a8595dda9076f021a4a))
+* fix server env detection in wechat mini program ([#9075](https://github.com/vuejs/vue/issues/9075)) ([05e8bcf](https://github.com/vuejs/vue/commit/05e8bcfe5d308f280f3640df96bd170fbcf1a9b5))
+* **for:** use IE compatible regex in v-for regex ([#8048](https://github.com/vuejs/vue/issues/8048)) ([ecc239e](https://github.com/vuejs/vue/commit/ecc239e47516d7f9a93b2cd49da4a2000960b8f7)), closes [#7946](https://github.com/vuejs/vue/issues/7946)
+* handle undefined style properties in jsdom (fix [#7444](https://github.com/vuejs/vue/issues/7444)) ([#8281](https://github.com/vuejs/vue/issues/8281)) ([5cfdf1a](https://github.com/vuejs/vue/commit/5cfdf1a2484fa73b572eae4afd196dcf9e1912ba))
+* **lifecycle:** updated should not be called after component being destroyed ([#8381](https://github.com/vuejs/vue/issues/8381)) ([a64ff19](https://github.com/vuejs/vue/commit/a64ff1957c35270b818aa9cfdfb2acb6e42ce2a9)), closes [#8076](https://github.com/vuejs/vue/issues/8076)
+* make sure global state is restored in the case of an exception in macrotask callback ([#9093](https://github.com/vuejs/vue/issues/9093)) ([b111de4](https://github.com/vuejs/vue/commit/b111de486b1bdc747fe0f5795fe22697d151bb8c))
+* **parser:** allow CRLFs in string interpolations ([#8408](https://github.com/vuejs/vue/issues/8408)) ([8f04135](https://github.com/vuejs/vue/commit/8f04135dbaa5f5f0500d42c0968beba8043f5363)), closes [#8103](https://github.com/vuejs/vue/issues/8103)
+* replace hardcoded .parentNode with abstract ops, fix [#8713](https://github.com/vuejs/vue/issues/8713) ([#8714](https://github.com/vuejs/vue/issues/8714)) ([1e1ce0c](https://github.com/vuejs/vue/commit/1e1ce0cac7d6c22c980021cbd3cb207a47e85dfb))
+* **server:** use path.posix.join to generate public path ([#8177](https://github.com/vuejs/vue/issues/8177)) ([46b8d2c](https://github.com/vuejs/vue/commit/46b8d2c59dc259995a71662229ed52b8b8beeb38)), closes [#8167](https://github.com/vuejs/vue/issues/8167)
+* **sfc:** avoid deindent when pad option is specified ([#7647](https://github.com/vuejs/vue/issues/7647)) ([9d2f9a0](https://github.com/vuejs/vue/commit/9d2f9a034f9c40d5ba6d8b1e131b1bfb675dc1cf))
+* **shared:** check dates in looseEqual ([#7940](https://github.com/vuejs/vue/issues/7940)) ([db7287c](https://github.com/vuejs/vue/commit/db7287c23b11bdc032fb0786e6617f3c6c40c835)), closes [#7928](https://github.com/vuejs/vue/issues/7928)
+* **ssr:** adjust call stack size defer threshold ([e4b1b57](https://github.com/vuejs/vue/commit/e4b1b57fd7117a19cdb376dcb156606e0cc32a94)), closes [#8545](https://github.com/vuejs/vue/issues/8545)
+* **ssr:** check js assets more accurate in ssr webpack plugin ([#8639](https://github.com/vuejs/vue/issues/8639)) ([5624278](https://github.com/vuejs/vue/commit/5624278fbe5d85cfe578d749da12b1e73c3e61a9))
+* **ssr:** computed properties should pass vm as first argument in ssr ([#9090](https://github.com/vuejs/vue/issues/9090)) ([33e669b](https://github.com/vuejs/vue/commit/33e669b22f69a1f9c9147528360fe0bba85534f0)), closes [#8977](https://github.com/vuejs/vue/issues/8977)
+* **ssr:** fix double escaping of staticClass values ([#7859](https://github.com/vuejs/vue/issues/7859)) ([#8037](https://github.com/vuejs/vue/issues/8037)) ([c21b89e](https://github.com/vuejs/vue/commit/c21b89ebeda4c45024c2a71bc7a292d47ebc7ee1))
+* **ssr:** remove trailing hash in webpack module identifier when ([ae6dcd6](https://github.com/vuejs/vue/commit/ae6dcd63a017059644502f8741d8a514f3e9cf84))
+* **ssr:** render initial and used async css chunks ([#7902](https://github.com/vuejs/vue/issues/7902)) ([575b6e7](https://github.com/vuejs/vue/commit/575b6e77ab82b0bbc581aec3ea9b07135d2d1fcd)), closes [#7897](https://github.com/vuejs/vue/issues/7897)
+* **ssr:** resolve server directives the same as on client ([#9129](https://github.com/vuejs/vue/issues/9129)) ([3078352](https://github.com/vuejs/vue/commit/307835284a326569ea12c4a22c7dcb8f36d2d8ca)), closes [#8961](https://github.com/vuejs/vue/issues/8961)
+* support modifier combination of click.right + .once ([#8492](https://github.com/vuejs/vue/issues/8492)) ([eb60452](https://github.com/vuejs/vue/commit/eb604529c62e9954305889122f34499ad75b3b45))
+* **transition:** check existence of `el.parentNode` ([#8422](https://github.com/vuejs/vue/issues/8422)) ([0b16927](https://github.com/vuejs/vue/commit/0b16927c9d382b9cf134b131b898350340c2ee41)), closes [#8199](https://github.com/vuejs/vue/issues/8199)
+* **transition:** handle local-formatted floats in toMs function.  ([#8495](https://github.com/vuejs/vue/issues/8495)) ([59d4351](https://github.com/vuejs/vue/commit/59d4351ad8fc042bc263a16ed45a56e9ff5b013e)), closes [#4894](https://github.com/vuejs/vue/issues/4894)
+* **transition:** transition-group should only listen for first-level children's end events ([#8374](https://github.com/vuejs/vue/issues/8374)) ([504d5da](https://github.com/vuejs/vue/commit/504d5da7eff1c77117c2f57b0c4238e56de80fc5))
+* **types:** accept `number` type as key on Vue.set/delete ([#8707](https://github.com/vuejs/vue/issues/8707)) ([#8709](https://github.com/vuejs/vue/issues/8709)) ([0ba79e2](https://github.com/vuejs/vue/commit/0ba79e2588309ba386f570ed84d372611c4dd165))
+* **types:** fix `renderError`arguments type ([#8636](https://github.com/vuejs/vue/issues/8636)) ([ac217d2](https://github.com/vuejs/vue/commit/ac217d2472bb92ce901ef1f46595b44a1b5d1a18)), closes [#8635](https://github.com/vuejs/vue/issues/8635)
+* **types:** fix vm.$once argument type ([#8995](https://github.com/vuejs/vue/issues/8995)) ([97086f3](https://github.com/vuejs/vue/commit/97086f365808a040f6cf1ddb12e2b3f63d7769bf)), closes [#8983](https://github.com/vuejs/vue/issues/8983)
+* **types:** make VNodeDirective properties optional, fix [#8013](https://github.com/vuejs/vue/issues/8013) ([#8003](https://github.com/vuejs/vue/issues/8003)) ([99a51b4](https://github.com/vuejs/vue/commit/99a51b452fa13fc4392e87215a8c3024adf5f710))
+* **types:** relax the return type of props default option ([#8537](https://github.com/vuejs/vue/issues/8537)) ([a9eb198](https://github.com/vuejs/vue/commit/a9eb198413e7b1baaf364e93ec3c093734529fe8))
+* **types:** support chain call for Vue.use and Vue.mixin ([#8595](https://github.com/vuejs/vue/issues/8595)) ([c711ec1](https://github.com/vuejs/vue/commit/c711ec189aaf46399756e34d933ba5e0b6576c36))
+* **types:** support typing $el as SVGElement ([#8809](https://github.com/vuejs/vue/issues/8809)) ([3cd4af4](https://github.com/vuejs/vue/commit/3cd4af4af0a8a67f5887d5fc967147d433c8612c))
+* v-bind object should be overridable with kebab-cased props ([#8845](https://github.com/vuejs/vue/issues/8845)) ([7585241](https://github.com/vuejs/vue/commit/758524134e71ae025238e16a4c1f2b30a1310fe8))
+* **v-model:** avoid duplicate model transforms ([7b7164c](https://github.com/vuejs/vue/commit/7b7164c11cbb74ed44ee086f0a82acfcc1ff47a2)), closes [#8436](https://github.com/vuejs/vue/issues/8436)
+* **v-on:** correctly remove once listener ([#8036](https://github.com/vuejs/vue/issues/8036)) ([19c33a7](https://github.com/vuejs/vue/commit/19c33a7e4072b03069f803263ed0c49feb5f73a9)), closes [#8032](https://github.com/vuejs/vue/issues/8032)
+* **v-pre:** skip compiling custom component tags in v-pre blocks (fix [#8286](https://github.com/vuejs/vue/issues/8286)) ([#8376](https://github.com/vuejs/vue/issues/8376)) ([a71853b](https://github.com/vuejs/vue/commit/a71853bfc5b6ee117af05408f4d75c80893d44e2))
+
+
+### Features
+
+* add async option ([#8240](https://github.com/vuejs/vue/issues/8240)) ([c944827](https://github.com/vuejs/vue/commit/c94482743c41e9bfc745aa06d63f7f83bdd56991))
+* **devtools:** store functional render context on vnode in development ([#8586](https://github.com/vuejs/vue/issues/8586)) ([4ecc21c](https://github.com/vuejs/vue/commit/4ecc21c29ec12bb33d3b426cb4d42c579e9b0f2d))
+* **server, webpack-plugin:** webpack 4 support ([#7839](https://github.com/vuejs/vue/issues/7839)) ([ef0b250](https://github.com/vuejs/vue/commit/ef0b25097957ae9ef9970be732d6e65cc78902e9))
+* **weex:** support object syntax of class ([#7930](https://github.com/vuejs/vue/issues/7930)) ([6226503](https://github.com/vuejs/vue/commit/62265035c0c400ad6ec213541dd7cca58dd71f6e))
+
+
+### Reverts
+
+* Revert "perf: avoid unnecessary re-renders when computed property value did not change (#7824)" ([6b1d431](https://github.com/vuejs/vue/commit/6b1d431a89f3f7438d01d8cc98546397f0983287)), closes [#7824](https://github.com/vuejs/vue/issues/7824)
+
+
+
+## [2.5.17-beta.0](https://github.com/vuejs/vue/compare/v2.5.16...v2.5.17-beta.0) (2018-03-23)
+
+
+### Bug Fixes
+
+* add missing `asyncMeta` during VNode cloning ([#7861](https://github.com/vuejs/vue/issues/7861)) ([8227fb3](https://github.com/vuejs/vue/commit/8227fb35240ab1f301c30a6ad5d4d25071fa7996))
+* beforeUpdate should be called before render and allow state mutation ([#7822](https://github.com/vuejs/vue/issues/7822)) ([b7445a2](https://github.com/vuejs/vue/commit/b7445a2b945dcded287601ace8e711ab5cf35ab5)), closes [#7481](https://github.com/vuejs/vue/issues/7481)
+* **codegen:** support IE11 and Edge use of "Esc" key ([#7887](https://github.com/vuejs/vue/issues/7887)) ([1bd6196](https://github.com/vuejs/vue/commit/1bd6196fb234c28754d9a27095afe0b5b84990ad)), closes [#7880](https://github.com/vuejs/vue/issues/7880)
+* correct the `has` implementation in the `_renderProxy` ([#7878](https://github.com/vuejs/vue/issues/7878)) ([7b38739](https://github.com/vuejs/vue/commit/7b387390aa917edffc0eabce0b4186ea1ef40e2c))
+* ensure init/prepatch hooks are still repsected ([de42278](https://github.com/vuejs/vue/commit/de42278d34f6a800cec5c7eb781c1b8b83a829dd)), closes [vue-router#1338](https://github.com/vue-router/issues/1338)
+* invoke component node create hooks before insertion ([#7823](https://github.com/vuejs/vue/issues/7823)) ([f43ce3a](https://github.com/vuejs/vue/commit/f43ce3a5d8f73e273f2d03c9d86ea5662cda481a)), closes [#7531](https://github.com/vuejs/vue/issues/7531)
+* **observer:** invoke getters on initial observation if setter defined ([#7828](https://github.com/vuejs/vue/issues/7828)) ([7a145d8](https://github.com/vuejs/vue/commit/7a145d86430bad65271f4d6ab1344b215fefe52a))
+
+
+### Performance Improvements
+
+* avoid unnecessary re-renders when computed property value did not change ([#7824](https://github.com/vuejs/vue/issues/7824)) ([653aac2](https://github.com/vuejs/vue/commit/653aac2c57d15f0e93a2c1cc7e6fad156658df19)), closes [#7767](https://github.com/vuejs/vue/issues/7767)
+
+
+### Reverts
+
+* Revert "refactor: remove unnecessary checks (#7875)" ([903be9b](https://github.com/vuejs/vue/commit/903be9b91f7c41d40e228676df9d66d2c064fe23)), closes [#7875](https://github.com/vuejs/vue/issues/7875)
+
+
+
+## [2.5.16](https://github.com/vuejs/vue/compare/v2.5.15...v2.5.16) (2018-03-13)
+
+
+### Bug Fixes
+
+* allow multiline expression in v-for ([71b4b25](https://github.com/vuejs/vue/commit/71b4b25375fa4bcd929e1161c35cab133e4a7c23)), closes [#7792](https://github.com/vuejs/vue/issues/7792)
+* **core:** Make set/delete warning condition for undefined, null and ([#7818](https://github.com/vuejs/vue/issues/7818)) ([9084747](https://github.com/vuejs/vue/commit/9084747e307dc9b415ff8e2a788c6a585a2a8f6c)), closes [#7452](https://github.com/vuejs/vue/issues/7452)
+* fix keyName checking for arrow keys in IE11 ([4378fc5](https://github.com/vuejs/vue/commit/4378fc5124067c2b3a3517dd7f527edd9be2ad37)), closes [#7806](https://github.com/vuejs/vue/issues/7806)
+* fix regression on duplicate component init when using shared data objects ([984927a](https://github.com/vuejs/vue/commit/984927a1a98d10ad8af44f2accfb08d34d517610)), closes [#7805](https://github.com/vuejs/vue/issues/7805)
+* fix wrongly matched named slots in functional components ([62a922e](https://github.com/vuejs/vue/commit/62a922e865f5e578f67b386cb614abfc173d7851)), closes [#7817](https://github.com/vuejs/vue/issues/7817)
+* **keep-alive:** run prune after render for correct active component check ([215f877](https://github.com/vuejs/vue/commit/215f877d1b7eb6583f7adf15676ead8611f07379)), closes [#7566](https://github.com/vuejs/vue/issues/7566)
+* **model:** fix static input type being overwritten by v-bind object ([#7819](https://github.com/vuejs/vue/issues/7819)) ([a6169d1](https://github.com/vuejs/vue/commit/a6169d1eb71d64eacddf1738e72d21725e2bff00)), closes [#7811](https://github.com/vuejs/vue/issues/7811)
+* named slots for nested functional components ([6dd73e9](https://github.com/vuejs/vue/commit/6dd73e9ee44c09f04d3f616fcce18750a55e2e4f)), closes [#7710](https://github.com/vuejs/vue/issues/7710)
+* **ssr:** fix SSR for async functional components ([882e719](https://github.com/vuejs/vue/commit/882e7199fd8eee039291c4b9f7f324dcf46f32fd)), closes [#7784](https://github.com/vuejs/vue/issues/7784)
+* **ssr:** fix v-show inline style rendering when style binding is array ([#7814](https://github.com/vuejs/vue/issues/7814)) ([1a979c4](https://github.com/vuejs/vue/commit/1a979c44d6543d89f8a7e26ad7f995b1bf2aee3c)), closes [#7813](https://github.com/vuejs/vue/issues/7813)
+
+
+
+## [2.5.15](https://github.com/vuejs/vue/compare/v2.5.14...v2.5.15) (2018-03-10)
+
+
+### Bug Fixes
+
+* do not traverse VNodes when regsitering dependencies ([84a9a9d](https://github.com/vuejs/vue/commit/84a9a9d61057f6f40a9ad2bee456b39ef0a8f001)), closes [#7786](https://github.com/vuejs/vue/issues/7786)
+
+
+
+## [2.5.14](https://github.com/vuejs/vue/compare/v2.5.13...v2.5.14) (2018-03-09)
+
+
+### Bug Fixes
+
+* address potential regex backtrack ([cd33407](https://github.com/vuejs/vue/commit/cd334070f3b82d3f5892c4999cc290ccd4f56fd8))
+* allow codebase to be inlined directly in HTML ([#7314](https://github.com/vuejs/vue/issues/7314)) ([dccd182](https://github.com/vuejs/vue/commit/dccd182b6763d8ef1871949029c85495ca958246)), closes [#7298](https://github.com/vuejs/vue/issues/7298)
+* always install composition event listeners ([f7ca21e](https://github.com/vuejs/vue/commit/f7ca21eab1e0d661945aa6070fc988028c90966f)), closes [#7367](https://github.com/vuejs/vue/issues/7367)
+* clean up custom events when patched component no longer have events ([d8b0838](https://github.com/vuejs/vue/commit/d8b08387a293c99b95c1efcf2517447335a618db)), closes [#7294](https://github.com/vuejs/vue/issues/7294)
+* **codegen:** support filters with () in older browsers ([#7545](https://github.com/vuejs/vue/issues/7545)) ([dc97a39](https://github.com/vuejs/vue/commit/dc97a39c2f41ce57431d42d8b41811866f8e105c)), closes [#7544](https://github.com/vuejs/vue/issues/7544)
+* **core:** disable dependency collection in lifecycle hooks and data getter ([#7596](https://github.com/vuejs/vue/issues/7596)) ([318f29f](https://github.com/vuejs/vue/commit/318f29fcdf3372ff57a09be6d1dc595d14c92e70)), closes [#7573](https://github.com/vuejs/vue/issues/7573)
+* **core:** handle edge cases for functional component returning arrays ([8335217](https://github.com/vuejs/vue/commit/8335217cb4bd13fb07e08a76c07df0fceed6c197)), closes [#7282](https://github.com/vuejs/vue/issues/7282)
+* do not special case attributes for custom elements ([50b711a](https://github.com/vuejs/vue/commit/50b711af43708426e63b4ea529436b49fafc3f2e)), closes [#6864](https://github.com/vuejs/vue/issues/6864) [#6885](https://github.com/vuejs/vue/issues/6885)
+* fix config.productionTip ([ced00b1](https://github.com/vuejs/vue/commit/ced00b1dec8326a653cce225133927fe5b4a3109)), closes [#7565](https://github.com/vuejs/vue/issues/7565)
+* fix ssr env detection in weex ([#7375](https://github.com/vuejs/vue/issues/7375)) ([3eb37ac](https://github.com/vuejs/vue/commit/3eb37acf98e2d9737de897ebe7bdb7e9576bcc21))
+* **inject:** use hasOwn instead of 'in' for provideKey check ([#7460](https://github.com/vuejs/vue/issues/7460)) ([733c1be](https://github.com/vuejs/vue/commit/733c1be7f5983cdd9e8089a8088b235ba21a4dee)), closes [#7284](https://github.com/vuejs/vue/issues/7284)
+* install ssr helpers for functional context during SSR ([9b22d86](https://github.com/vuejs/vue/commit/9b22d86ab315a3c6061a6a4776eab1964304f92e)), closes [#7443](https://github.com/vuejs/vue/issues/7443) [nuxt/nuxt.js#2565](https://github.com/nuxt/nuxt.js/issues/2565)
+* **model:** fix array index binding for v-model checkbox ([#7671](https://github.com/vuejs/vue/issues/7671)) ([550c3c0](https://github.com/vuejs/vue/commit/550c3c0d14af5485bb7e507c504664a7136e9bf9)), closes [#7670](https://github.com/vuejs/vue/issues/7670)
+* **observer:** do not invoke getters on initial observation  ([#7302](https://github.com/vuejs/vue/issues/7302)) ([7392dfc](https://github.com/vuejs/vue/commit/7392dfcc1d5fd7b257df5ae134f9eb2f0cc0a51e)), closes [#7280](https://github.com/vuejs/vue/issues/7280)
+* **ref:** allow ref key to be zero ([#7676](https://github.com/vuejs/vue/issues/7676)) ([e396eb3](https://github.com/vuejs/vue/commit/e396eb3445904f11232f2355f03e8356173d0e31)), closes [#7669](https://github.com/vuejs/vue/issues/7669)
+* respect type order when boolean casting multi-typed props ([81e1e47](https://github.com/vuejs/vue/commit/81e1e47cabbd479e2a285f03120944f1efffe749)), closes [#7485](https://github.com/vuejs/vue/issues/7485)
+* **show:** prevent transitions from starting on change truthy values ([#7524](https://github.com/vuejs/vue/issues/7524)) ([013d980](https://github.com/vuejs/vue/commit/013d98092868a0c6721831e91616c64f99119b74)), closes [#7523](https://github.com/vuejs/vue/issues/7523)
+* skip v-model & value binding collision check with dynamic type binding ([#7406](https://github.com/vuejs/vue/issues/7406)) ([1c0b4af](https://github.com/vuejs/vue/commit/1c0b4af5fd2f9e8173b8f4718018ee80a6313872)), closes [#7404](https://github.com/vuejs/vue/issues/7404)
+* support KeyboardEvent.key in built-in keyboard event modifiers ([#7121](https://github.com/vuejs/vue/issues/7121)) ([1c8e2e8](https://github.com/vuejs/vue/commit/1c8e2e88ed2d74a02178217b318564b73a096c18)), closes [#6900](https://github.com/vuejs/vue/issues/6900)
+* **transition:** should not add transition class when cancelled ([#7391](https://github.com/vuejs/vue/issues/7391)) ([5191f13](https://github.com/vuejs/vue/commit/5191f13472d1fc37bdd601079970201fde6bf13e)), closes [#7390](https://github.com/vuejs/vue/issues/7390)
+* **types:** add missing `listeners` type on RenderContext ([#7584](https://github.com/vuejs/vue/issues/7584)) ([db1b18c](https://github.com/vuejs/vue/commit/db1b18ceec51761f1bcd6160c51e02b36b86a9c2))
+* **types:** contravariant generic default in ComponentOption ([#7369](https://github.com/vuejs/vue/issues/7369)) ([6ee6849](https://github.com/vuejs/vue/commit/6ee684983b1f3384a4050d7c47cee7c6a325db8b))
+* **types:** fix wrong errorCaptured type ([#7712](https://github.com/vuejs/vue/issues/7712)) ([6b8516b](https://github.com/vuejs/vue/commit/6b8516b2dde52be643ee6855b45b253a17ed0461))
+* **types:** make render option in functional components to optional ([#7663](https://github.com/vuejs/vue/issues/7663)) ([b2092db](https://github.com/vuejs/vue/commit/b2092dbff9ab0ccfa8e59ed3ca540cca0715c683))
+* **types:** make VNodeChildrenArrayContents type more accurate ([#7287](https://github.com/vuejs/vue/issues/7287)) ([49aae6b](https://github.com/vuejs/vue/commit/49aae6bb157e0650507974b7a9a1b0f2215e400b))
+* **types:** prefer normal component over functional one ([#7687](https://github.com/vuejs/vue/issues/7687)) ([144bf5a](https://github.com/vuejs/vue/commit/144bf5a99e2ebd644f80bc8ab61cd1bf0366961a))
+* **v-model:** handle trailing whitespaces in expression ([#7737](https://github.com/vuejs/vue/issues/7737)) ([db58493](https://github.com/vuejs/vue/commit/db584931e20f9ad4b423cfc14d587f9d0240a565))
+* **v-on:** return handler value when using modifiers ([#7704](https://github.com/vuejs/vue/issues/7704)) ([6bc75ca](https://github.com/vuejs/vue/commit/6bc75cacb72c0cc7f3d1041b5d9ff447ac2f5f69))
+* **vdom:** svg inside foreignObject should be rendered with correct namespace (fix [#7330](https://github.com/vuejs/vue/issues/7330)) ([#7350](https://github.com/vuejs/vue/issues/7350)) ([0529961](https://github.com/vuejs/vue/commit/05299610ea3e89ddbcfe4d8ede0c298223766423))
+* **weex:** default value for editor, fix [#7165](https://github.com/vuejs/vue/issues/7165) ([#7286](https://github.com/vuejs/vue/issues/7286)) ([e055df8](https://github.com/vuejs/vue/commit/e055df82fec0e76e4bc65e5a265b42e208595430))
+
+
+### Features
+
+* support v-model dynamic type binding for v-bind="object" ([41838c8](https://github.com/vuejs/vue/commit/41838c8e8632ba78791996fbc697080b2764bb6a)), closes [#7296](https://github.com/vuejs/vue/issues/7296)
+* **weex:** adjust framework entry APIs and add flow annotations ([#7272](https://github.com/vuejs/vue/issues/7272)) ([472a289](https://github.com/vuejs/vue/commit/472a2896bd4f156be168edfecb6ac432b853beb4))
+* **weex:** support parse object literal in binding attrs and styles ([#7291](https://github.com/vuejs/vue/issues/7291)) ([ff8fcd2](https://github.com/vuejs/vue/commit/ff8fcd2e2b95694527018f7836bab781f8600d25))
+* **weex:** update new syntax for <recycle-list> ([7cc0b55](https://github.com/vuejs/vue/commit/7cc0b559e9e57fcb3baeae5d8d4c8964aa335b5e))
+* **weex:** update weex recycle-list compiler ([#7610](https://github.com/vuejs/vue/issues/7610)) ([d6200d7](https://github.com/vuejs/vue/commit/d6200d70261c4a8943190900e0721ede1c4a4f2b))
+
+
+
+## [2.5.13](https://github.com/vuejs/vue/compare/v2.5.12...v2.5.13) (2017-12-19)
+
+
+### Reverts
+
+* Revert "feat: auto cache inline prop literals to avoid child re-render" ([aac7634](https://github.com/vuejs/vue/commit/aac76349e70fe0971ee24a7a1f3dada0e3459fb8))
+
+
+
+## [2.5.12](https://github.com/vuejs/vue/compare/v2.5.11...v2.5.12) (2017-12-19)
+
+
+### Bug Fixes
+
+* **warning:** allow symbol as vdom key ([#7271](https://github.com/vuejs/vue/issues/7271)) ([bacb911](https://github.com/vuejs/vue/commit/bacb911f7df09ff4868b4c848a6d7778872dff5c))
+* **weex:** append as tree by default for recycle-list and cell-slot ([#7216](https://github.com/vuejs/vue/issues/7216)) ([d544d05](https://github.com/vuejs/vue/commit/d544d052a9c5ec113c253895211296120d58b6ab))
+* **weex:** update recycle-list v-for transform ([0ee81b2](https://github.com/vuejs/vue/commit/0ee81b24b5146bca315503e2f5aa3b01832735f1))
+
+
+### Features
+
+* **$compiler:** compile weex native directives in preTransformNode ([2d09ee3](https://github.com/vuejs/vue/commit/2d09ee3b8ce37e201d3973587d1cb442d5e08f31))
+* **$compiler:** supports compiling v-bind to the weex native directive in recycle-list ([8b893c1](https://github.com/vuejs/vue/commit/8b893c13d6ffa79f294fec76a228509ec48e4706))
+* **$compiler:** supports compiling v-else-if and v-else to the weex native directive ([2a1ce0d](https://github.com/vuejs/vue/commit/2a1ce0d92cb12c18f945f69ee5cb6914b389e35e))
+* **$compiler:** supports compiling v-for to the weex native directive ([9bd1483](https://github.com/vuejs/vue/commit/9bd1483803d046877bef4f7adf1d3a942085ea1b))
+* **$event:** support binding parameters on event handler within weex recycle-list ([acdc3c4](https://github.com/vuejs/vue/commit/acdc3c46e98919faa50b3e4cc308ab73b1a60bfe))
+* auto cache inline prop literals to avoid child re-render ([996eb00](https://github.com/vuejs/vue/commit/996eb00a0a0933376c9364c2d187e2bf0512ff0d))
+* **compile:** supports compiling v-if to the weex native directive ([7ad368e](https://github.com/vuejs/vue/commit/7ad368ebb6987bd4044f9df184d73ce14ca680f2))
+* **types:** extract VueConfiguration type for easy expansion ([#7273](https://github.com/vuejs/vue/issues/7273)) ([#7274](https://github.com/vuejs/vue/issues/7274)) ([c0d516c](https://github.com/vuejs/vue/commit/c0d516c283aa1a1c238b6eb8b8e55f64770d27e8))
+* **weex:** generate "[@render](https://github.com/render)" function for weex recycle-list ([#6987](https://github.com/vuejs/vue/issues/6987)) ([0c11aa8](https://github.com/vuejs/vue/commit/0c11aa8addf5ad852e37da358ce2887af72e4193))
+* **weex:** partially support lifecycles of virtual component ([#7242](https://github.com/vuejs/vue/issues/7242)) ([661bfe5](https://github.com/vuejs/vue/commit/661bfe552e16d3a7036012021ae3746cfc02710e))
+* **weex:** pass stateless component test case ([452a65c](https://github.com/vuejs/vue/commit/452a65c98a9354bb529185638475b72d8ca19543))
+* **weex:** recycle-list support stateful child component ([70b97ac](https://github.com/vuejs/vue/commit/70b97ac2f43099a57ce2fb0a23dea0553ba95189))
+* **weex:** recycle-list support WIP ([5254ee3](https://github.com/vuejs/vue/commit/5254ee31c481ac16cf8f822b0b4df0f7815ffff3))
+* **weex:** split text into separate module ([c104cc5](https://github.com/vuejs/vue/commit/c104cc582d647f5e10b90563cb80907b9e30ec12))
+* **weex:** support compiling `v-on` in the weex native directive ([#6892](https://github.com/vuejs/vue/issues/6892)) ([2cb8ea3](https://github.com/vuejs/vue/commit/2cb8ea3fee741807a15bf8f3049ab062a7d9508c))
+* **weex:** update weex utils ([#7115](https://github.com/vuejs/vue/issues/7115)) ([3b32652](https://github.com/vuejs/vue/commit/3b32652aa68a06d881e3149bb21ac8711887e7f6))
+* **weex:** WIP adjust component transform stage ([62e47c9](https://github.com/vuejs/vue/commit/62e47c9eb4446da79d66ad2385c199f31b4348d8))
+* **weex:** WIP fix flow + handle errors in recycle-list template render ([5c2ce00](https://github.com/vuejs/vue/commit/5c2ce0017ff8929e70ce9f701b91d950fb351adb))
+* **weex:** WIP implement virtual component ([#7165](https://github.com/vuejs/vue/issues/7165)) ([b8d33ec](https://github.com/vuejs/vue/commit/b8d33ecd9ab8b7a46d8558b4e2caf506235cd165))
+* **weex:** WIP invoke recycle-list child component with backing instance ([801f793](https://github.com/vuejs/vue/commit/801f793625273b39fd3f25abbaa04508d6651563))
+* **weex:** WIP mark recycle list child component root ([88f3889](https://github.com/vuejs/vue/commit/88f3889f19678981944339be8d22c3ebcd11f822))
+* **wip:** recycle list template inline expand ([ac99957](https://github.com/vuejs/vue/commit/ac999573ea6e4be3a421cdff79d66a5274ec58eb))
+
+
+### Reverts
+
+* revert prop object validation ([01c0750](https://github.com/vuejs/vue/commit/01c07503bf6af902dde06fafa8a0008ee3e303aa)), closes [#7279](https://github.com/vuejs/vue/issues/7279)
+* **weex:** remove the "receiveTasks" api and support component hook ([#7053](https://github.com/vuejs/vue/issues/7053)) ([0bf0cbe](https://github.com/vuejs/vue/commit/0bf0cbef76a9d107ea0d4fbd8f54f640a2c5b221))
+
+
+
+## [2.5.11](https://github.com/vuejs/vue/compare/v2.5.10...v2.5.11) (2017-12-14)
+
+
+### Bug Fixes
+
+* avoid unnecessary lowercase coersion in component name validation ([3f0c628](https://github.com/vuejs/vue/commit/3f0c628e2c0fe6bfaecc521c96c6cc12ff24c7c4)), closes [#7237](https://github.com/vuejs/vue/issues/7237)
+
+
+### Features
+
+* warn misspelled keys on prop validation object ([#7198](https://github.com/vuejs/vue/issues/7198)) ([d02bb37](https://github.com/vuejs/vue/commit/d02bb37efb3c4ee14b8cf9db22d1ab3340ba2c0f))
+
+
+
+## [2.5.10](https://github.com/vuejs/vue/compare/v2.5.9...v2.5.10) (2017-12-12)
+
+
+### Bug Fixes
+
+* **core:** warn duplicate keys in all cases ([#7200](https://github.com/vuejs/vue/issues/7200)) ([023f171](https://github.com/vuejs/vue/commit/023f171f58f7f1b36f0b3e69fc6d330366bfdf43)), closes [#7199](https://github.com/vuejs/vue/issues/7199)
+* data() should be called with vm as first argument in mixins ([bd4819e](https://github.com/vuejs/vue/commit/bd4819e6cf1c8d70d25aba2636e01f40faf59443)), closes [#7191](https://github.com/vuejs/vue/issues/7191)
+* more consistent component naming warnings across the API ([644274c](https://github.com/vuejs/vue/commit/644274cbd34e14e74e8931fa979b22dc2db04895)), closes [#7212](https://github.com/vuejs/vue/issues/7212)
+* revert shared static tree cache to avoid memory leak ([5875c7c](https://github.com/vuejs/vue/commit/5875c7c4906873c31b2feb66bb3ab6a19af6f5d7)), closes [#7184](https://github.com/vuejs/vue/issues/7184)
+* should not update in-focus input value with lazy modifier ([60da366](https://github.com/vuejs/vue/commit/60da366a2653a3984d79331d02ebb2ecf7e73a9a)), closes [#7153](https://github.com/vuejs/vue/issues/7153)
+* **ssr:** fix double escaping of ssrNode attribute values ([#7224](https://github.com/vuejs/vue/issues/7224)) ([73a89bf](https://github.com/vuejs/vue/commit/73a89bf9e53c0f7f00f193e1b1bb195a71ab761f)), closes [#7223](https://github.com/vuejs/vue/issues/7223)
+* **ssr:** properly handle errors in async component ([8936b8d](https://github.com/vuejs/vue/commit/8936b8d9c147441555fcfd4ac748d817ba5ff60e)), closes [#6778](https://github.com/vuejs/vue/issues/6778)
+* **v-for:** support array and nested destructuring in v-for ([f5ce6b5](https://github.com/vuejs/vue/commit/f5ce6b50cffef2e0eb8895c462b2433d8f8a701f))
+* **weex:** send createFinish signal after root component mounted ([#7154](https://github.com/vuejs/vue/issues/7154)) ([0da8bce](https://github.com/vuejs/vue/commit/0da8bced77654beb14c39ff3b4543b2ef37d1aff))
+
+
+
+## [2.5.9](https://github.com/vuejs/vue/compare/v2.5.8...v2.5.9) (2017-11-27)
+
+
+### Bug Fixes
+
+* block unnecessary input event on textarea placeholder in IE ([0f7c443](https://github.com/vuejs/vue/commit/0f7c443dca800204bc2e00876365869ee79e2d7b)), closes [#7138](https://github.com/vuejs/vue/issues/7138)
+* ensure functionalContext is cloned during slot clones ([604e081](https://github.com/vuejs/vue/commit/604e081d0456ed136b24b5f759c608d153dfae93)), closes [#7106](https://github.com/vuejs/vue/issues/7106)
+* fix async component resolving in sibling mounted hook ([dd21eac](https://github.com/vuejs/vue/commit/dd21eacc33fee8f8e6151fe1dcb419644f8f98c2)), closes [#7107](https://github.com/vuejs/vue/issues/7107)
+* fix v-for iterator parsing destructuring + parens without index ([aa82625](https://github.com/vuejs/vue/commit/aa8262540ac0115d56b53863302b9f8e69f8a03d))
+* **keep-alive:** should not destroy active instance when pruning cache ([3932a45](https://github.com/vuejs/vue/commit/3932a451a1419a97ea0200c5cb8096afe9a3e7e7)), closes [#7105](https://github.com/vuejs/vue/issues/7105)
+* **types:** add missing ssr renderToString signature ([14e9908](https://github.com/vuejs/vue/commit/14e99086c02f4bcda55e639fb0baf2c664591448))
+* **types:** add Promise signature for bundleRenderer.renderToString ([#7098](https://github.com/vuejs/vue/issues/7098)) ([3554eb2](https://github.com/vuejs/vue/commit/3554eb27269e151a0ef3d8c4ad9b29ec6664c471))
+* **types:** bump ts version and fix typing bugs ([#7135](https://github.com/vuejs/vue/issues/7135)) ([a71e653](https://github.com/vuejs/vue/commit/a71e653108e4ba56a70107662f3ee30cead59c18))
+* **types:** improve and test bundleRenderer.renderToString Promise types ([fcc1229](https://github.com/vuejs/vue/commit/fcc122931b504655c8255645d57612bc74c0f594))
+* **types:** use object and string instead of Object and String ([#7126](https://github.com/vuejs/vue/issues/7126)) ([d2e1d49](https://github.com/vuejs/vue/commit/d2e1d49c41ac633ea9410e1062b8e3e01f9d6b6d))
+
+
+
+## [2.5.8](https://github.com/vuejs/vue/compare/v2.5.7...v2.5.8) (2017-11-21)
+
+
+### Bug Fixes
+
+* fix v-for alias deconstruct regression ([ebcef58](https://github.com/vuejs/vue/commit/ebcef58645af1582ca3c8a19ec26967946970301)), closes [#7096](https://github.com/vuejs/vue/issues/7096)
+
+
+
+## [2.5.7](https://github.com/vuejs/vue/compare/v2.5.6...v2.5.7) (2017-11-20)
+
+
+### Bug Fixes
+
+* allow traversing reactive objects which are sealed ([#7080](https://github.com/vuejs/vue/issues/7080)) ([4c22d1d](https://github.com/vuejs/vue/commit/4c22d1d17ffd3a9340c3b17443c7989d04ab14c5))
+* fix <keep-alive> include/exclude logic for anonymous components ([a23b913](https://github.com/vuejs/vue/commit/a23b913796a7d18e76185607f250655e18a390c8))
+* improve error detector v-for identifier check ([d891cd1](https://github.com/vuejs/vue/commit/d891cd1761df22e1e0b1953c6ed7947fdb79d915)), closes [#6971](https://github.com/vuejs/vue/issues/6971)
+* **ssr:** fix bundle renderer require path on windows ([#7085](https://github.com/vuejs/vue/issues/7085)) ([063acb7](https://github.com/vuejs/vue/commit/063acb79ebc02344ab277196d4aea0577b113926))
+
+
+### Features
+
+* feat: add warning for ambiguous combined usage of slot-scope and v-for ([c264335](https://github.com/vuejs/vue/commit/c264335fbd1b1d838e3c1085b7d6dcd1c752aa43)), closes [#6817](https://github.com/vuejs/vue/issues/6817)
+
+
+
+## [2.5.6](https://github.com/vuejs/vue/compare/v2.5.5...v2.5.6) (2017-11-18)
+
+
+### Bug Fixes
+
+* fix v-model :value warning on custom component ([59dea37](https://github.com/vuejs/vue/commit/59dea374037ec2e6b1f5570a30774f2de0a44adc)), closes [#7084](https://github.com/vuejs/vue/issues/7084)
+
+
+
+## [2.5.5](https://github.com/vuejs/vue/compare/v2.5.4...v2.5.5) (2017-11-17)
+
+
+### Bug Fixes
+
+* init _staticTrees to avoid runtime reference warning ([f5cd29e](https://github.com/vuejs/vue/commit/f5cd29e1d8197613c4dfb4013b240784c3b64e43)), closes [#7075](https://github.com/vuejs/vue/issues/7075)
+* keep-alive should not cache anonymous components ([4d8226f](https://github.com/vuejs/vue/commit/4d8226fb2c84fa2e13a2d8a86dea8a9a5c6ea95f)), closes [#6938](https://github.com/vuejs/vue/issues/6938)
+* should warn unknown components inside <keep-alive> ([6d6b373](https://github.com/vuejs/vue/commit/6d6b3739e132723915bc2209663db1b825307865))
+
+
+### Features
+
+* warn if both v-model and v-bind:value used on same element ([#7056](https://github.com/vuejs/vue/issues/7056)) ([1e14603](https://github.com/vuejs/vue/commit/1e146037fa4280b502d0edf95936bc67e87fd339)), closes [#7048](https://github.com/vuejs/vue/issues/7048) [#7048](https://github.com/vuejs/vue/issues/7048) [#7048](https://github.com/vuejs/vue/issues/7048)
+
+
+
+## [2.5.4](https://github.com/vuejs/vue/compare/v2.5.3...v2.5.4) (2017-11-16)
+
+
+### Bug Fixes
+
+* clone slot nodes for render fn usage as well ([13196b2](https://github.com/vuejs/vue/commit/13196b25b8a0a84b3936982177195d2e04f13f79)), closes [#7041](https://github.com/vuejs/vue/issues/7041)
+* normlaize [@click](https://github.com/click).right and [@click](https://github.com/click).middle ([daed1e7](https://github.com/vuejs/vue/commit/daed1e73557d57df244ad8d46c9afff7208c9a2d)), closes [#7020](https://github.com/vuejs/vue/issues/7020)
+* should warn unknown components during hydration ([df82aeb](https://github.com/vuejs/vue/commit/df82aeb0bf7454ac99d403000a1ac993e8d8d4de)), closes [#6998](https://github.com/vuejs/vue/issues/6998)
+* **ssr:** ensure hydrated class & style bindings are reactive ([5db86b4](https://github.com/vuejs/vue/commit/5db86b4e94857fdde3ae6b71e24da637bc116baa)), closes [#7063](https://github.com/vuejs/vue/issues/7063)
+* **transition:** fix out-in transition getting stuck with v-if ([#7023](https://github.com/vuejs/vue/issues/7023)) ([45d7ba8](https://github.com/vuejs/vue/commit/45d7ba842917a075d6cb2563c78210e3b9210a58)), closes [#6687](https://github.com/vuejs/vue/issues/6687)
+* **types:** expose VueConstructor ([#7002](https://github.com/vuejs/vue/issues/7002)) ([267ada0](https://github.com/vuejs/vue/commit/267ada04e8dd66f5c159dd6ba1b9f88fbbe78676))
+* **weex:** donot rethrow the captured error on weex platform ([#7024](https://github.com/vuejs/vue/issues/7024)) ([c2b1cfe](https://github.com/vuejs/vue/commit/c2b1cfe9ccd08835f2d99f6ce60f67b4de55187f))
+
+
+### Features
+
+* **weex:** support batch update styles and attributes ([#7046](https://github.com/vuejs/vue/issues/7046)) ([7cf188e](https://github.com/vuejs/vue/commit/7cf188e134fe7bfc9e8a16b763fb85b18eff1eac))
+
+
+
+## [2.5.3](https://github.com/vuejs/vue/compare/v2.5.2...v2.5.3) (2017-11-03)
+
+
+### Bug Fixes
+
+* $set should respect properties on prototype chain ([83ed926](https://github.com/vuejs/vue/commit/83ed92608d81349e1cac2e481ed079e51a490b2b)), closes [#6845](https://github.com/vuejs/vue/issues/6845)
+* also clone component slot children during deepClone ([1cf02ef](https://github.com/vuejs/vue/commit/1cf02efda206185cb72bbaafb00037fa6269e3f3)), closes [#6891](https://github.com/vuejs/vue/issues/6891) [#6915](https://github.com/vuejs/vue/issues/6915)
+* clean up target variables to avoid memory leaks ([#6932](https://github.com/vuejs/vue/issues/6932)) ([c355319](https://github.com/vuejs/vue/commit/c3553196b8b15a71f982bd5e04c61be52e87c828)), closes [#6931](https://github.com/vuejs/vue/issues/6931)
+* **core:** static trees should be cached on options ([#6826](https://github.com/vuejs/vue/issues/6826)) ([#6837](https://github.com/vuejs/vue/issues/6837)) ([b6c384d](https://github.com/vuejs/vue/commit/b6c384dd78b56bd247e6a34d5aea0d3903f5b7fd))
+* **events:** properly $off array of events ([#6949](https://github.com/vuejs/vue/issues/6949)) ([c24f3e4](https://github.com/vuejs/vue/commit/c24f3e4208cd045832002ee9916559f6fe0dc2b5))
+* handle encoded tabs and newlines in attributes for Chrome a[href] and IE/Edge ([cfd73c2](https://github.com/vuejs/vue/commit/cfd73c2386623341fdbb3ac636c4baf84ea89c2c)), closes [#6828](https://github.com/vuejs/vue/issues/6828) [#6916](https://github.com/vuejs/vue/issues/6916)
+* **keep-alive:** higher priority for exclude than include ([#6905](https://github.com/vuejs/vue/issues/6905)) ([604230f](https://github.com/vuejs/vue/commit/604230fe953f864be5dc70bd7d34f64ae43e4f7e))
+* **model:** correctly set select v-model initial value on patch ([#6910](https://github.com/vuejs/vue/issues/6910)) ([58a39df](https://github.com/vuejs/vue/commit/58a39dfa0e8c4a51959e9a84369dad8fbca0e6ac))
+* properly mark slot rendered flag in production mode ([4fe1a95](https://github.com/vuejs/vue/commit/4fe1a95d2953ecf765e27677fa70ebadb176d4c3)), closes [#6997](https://github.com/vuejs/vue/issues/6997)
+* **slots:** properly handle nested named slot passing ([5a9da95](https://github.com/vuejs/vue/commit/5a9da95b8a865416f082952a48416ffc091e4078)), closes [#6996](https://github.com/vuejs/vue/issues/6996)
+* special case for static muted attribute in firefox ([f2e00f7](https://github.com/vuejs/vue/commit/f2e00f756fb540fb09ce3414289c652ce172d85c)), closes [#6887](https://github.com/vuejs/vue/issues/6887)
+* **ssr:** properly render <select v-model> initial state ([e1657fd](https://github.com/vuejs/vue/commit/e1657fd7ce49bff3c3ecad3c56ae527347505c34)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
+* **ssr:** properly render textarea value ([79c0d7b](https://github.com/vuejs/vue/commit/79c0d7bcfbcd1ac492e7ceb77f5024d09efdc6b3)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
+* **ssr:** should not optimize root if conditions ([4ad9a56](https://github.com/vuejs/vue/commit/4ad9a56b229b156e633f3d575cd0e99ba5e474d9)), closes [#6907](https://github.com/vuejs/vue/issues/6907)
+* **types:** improve typing for better completion ([#6886](https://github.com/vuejs/vue/issues/6886)) ([98ea0a3](https://github.com/vuejs/vue/commit/98ea0a3b48e37719f278c10a8ee5fb94d7d5db4e))
+* **typing:** relax $options type for TS2.6+ ([#6819](https://github.com/vuejs/vue/issues/6819)) ([9caed00](https://github.com/vuejs/vue/commit/9caed00d20f37c750e39db4ec86d278b453f0e5d))
+* **v-model:** v-if / v-else not working with :type + v-model ([#6955](https://github.com/vuejs/vue/issues/6955)) ([0c703e3](https://github.com/vuejs/vue/commit/0c703e34d1a2083d9f162fcf0885deefb803182e)), closes [#6918](https://github.com/vuejs/vue/issues/6918)
+* **weex:** stop trim css units in richtext component ([#6927](https://github.com/vuejs/vue/issues/6927)) ([8a784d8](https://github.com/vuejs/vue/commit/8a784d8d2333f0a05569f6c11c5a0fb0ab3a164e))
+
+
+
+## [2.5.2](https://github.com/vuejs/vue/compare/v2.5.1...v2.5.2) (2017-10-13)
+
+
+### Bug Fixes
+
+* further adjust nextTick strategy ([4e0c485](https://github.com/vuejs/vue/commit/4e0c48511d49f331fde31fc87b6ca428330f32d1)), closes [#6813](https://github.com/vuejs/vue/issues/6813)
+
+
+
+## [2.5.1](https://github.com/vuejs/vue/compare/v2.5.0...v2.5.1) (2017-10-13)
+
+
+### Bug Fixes
+
+* backwards compat with checkbox code generated in < 2.5 ([5665eaf](https://github.com/vuejs/vue/commit/5665eaf985a56cfd183ce8ce93c4d813edbd2cf8)), closes [#6803](https://github.com/vuejs/vue/issues/6803)
+* fix empty array edge case in normalizeChildren ([1f84dd1](https://github.com/vuejs/vue/commit/1f84dd1c2488d12ef144d4b548b0e80647f9403c)), closes [#6790](https://github.com/vuejs/vue/issues/6790)
+* **ssr:** add semicolon before self-removal script ([#6794](https://github.com/vuejs/vue/issues/6794)) ([5a15a8d](https://github.com/vuejs/vue/commit/5a15a8d2089bb833b892123c31a2ca04a511c4c8))
+* **transition-group:** work around rollup tree shaking ([#6796](https://github.com/vuejs/vue/issues/6796)) ([60b1af9](https://github.com/vuejs/vue/commit/60b1af9e02b93d9223d2ed1f23e0a618537a4c96)), closes [#6792](https://github.com/vuejs/vue/issues/6792)
+* **v-model:** allow arbitrary naems for type binding ([#6802](https://github.com/vuejs/vue/issues/6802)) ([15031b8](https://github.com/vuejs/vue/commit/15031b85427df5409f0bc4c10589cc6259f8a5b2)), closes [#6800](https://github.com/vuejs/vue/issues/6800)
+* v-on="object" listeners should fire after high-priority ones ([08a7fb5](https://github.com/vuejs/vue/commit/08a7fb539f9d3ab5b08a3c6cec9a6628929be3be)), closes [#6805](https://github.com/vuejs/vue/issues/6805)
+
+
+
+# [2.5.0](https://github.com/vuejs/vue/compare/v2.4.4...v2.5.0) (2017-10-13)
+
+
+### Bug Fixes
+
+* add slot v-bind warning ([#6736](https://github.com/vuejs/vue/issues/6736)) ([514b90b](https://github.com/vuejs/vue/commit/514b90b64770cba9f905d2dff59dfa0e064e580c)), closes [#6677](https://github.com/vuejs/vue/issues/6677)
+* allow an object's Symbols to be observed ([#6704](https://github.com/vuejs/vue/issues/6704)) ([4fd2ce8](https://github.com/vuejs/vue/commit/4fd2ce813cd0a59bd544defe07f44a5731e45f84))
+* **compiler:** warn when inline-template component has no children (fix [#6703](https://github.com/vuejs/vue/issues/6703)) ([#6715](https://github.com/vuejs/vue/issues/6715)) ([baabd6d](https://github.com/vuejs/vue/commit/baabd6d14016c730fe40a4202ae9b8f75e80041c))
+* **core:** avoid observing VNodes ([4459b87](https://github.com/vuejs/vue/commit/4459b87de902cf3ba496a104304ca80d1c9824c1)), closes [#6610](https://github.com/vuejs/vue/issues/6610)
+* ensure nextTick are passed to errorHandler ([#6730](https://github.com/vuejs/vue/issues/6730)) ([ae347a5](https://github.com/vuejs/vue/commit/ae347a52259b24507a9c747c80d78a6beaa36de0))
+* fallback to Promise in non-DOM environments ([6d1f4cb](https://github.com/vuejs/vue/commit/6d1f4cb89a156bf5f84942b1031354aa93916cb7))
+* fix scoped CSS for nested nodes in functional components ([4216588](https://github.com/vuejs/vue/commit/421658884f7ca786747abf9b89e00925fdfdfba8))
+* handle errors in errorHandler ([2b5c83a](https://github.com/vuejs/vue/commit/2b5c83af6d8b15510424af4877d58c261ea02e16)), closes [#6714](https://github.com/vuejs/vue/issues/6714)
+* perperly handle v-if on <template> scoped slot ([68bdbf5](https://github.com/vuejs/vue/commit/68bdbf508b915872627676d6bf987bdac9e5fe97)), closes [#6725](https://github.com/vuejs/vue/issues/6725)
+* prevent memory leak due to circular reference in vnodes ([405d8e9](https://github.com/vuejs/vue/commit/405d8e9f4c3201db2ae0e397d9191d9b94edc219)), closes [#6759](https://github.com/vuejs/vue/issues/6759)
+* properly render value on <progress> in IE/Edge ([c64f9ae](https://github.com/vuejs/vue/commit/c64f9ae1649175ee8cac1c7ecf3283897c948202)), closes [#6666](https://github.com/vuejs/vue/issues/6666)
+* **ref:** preserve ref on components after removing root element ([#6718](https://github.com/vuejs/vue/issues/6718)) ([6ad44e1](https://github.com/vuejs/vue/commit/6ad44e13e990951ff152a0fd7042613c5a87f1c0)), closes [#6632](https://github.com/vuejs/vue/issues/6632) [#6641](https://github.com/vuejs/vue/issues/6641)
+* resolve async component default for native dynamic import ([2876ed8](https://github.com/vuejs/vue/commit/2876ed870c5368a1767fbeddf06e94b55ebd6234)), closes [#6751](https://github.com/vuejs/vue/issues/6751)
+* **ssr:** fix hydration mismatch with adjacent text node from slots ([b080a14](https://github.com/vuejs/vue/commit/b080a14138262f0f274d0888555a11bd7387d576)), closes [vuejs/vue-loader#974](https://github.com/vuejs/vue-loader/issues/974)
+* **ssr:** handle inline template compilation error ([dff85b2](https://github.com/vuejs/vue/commit/dff85b230abda63839ed6b80d56ccfc6068b9ae0)), closes [#6766](https://github.com/vuejs/vue/issues/6766)
+* use correct ns inside <foreignObject> as root node ([cf1ff5b](https://github.com/vuejs/vue/commit/cf1ff5b0dc3d15c1e16821cb5e4fc984c74f07c1)), closes [#6642](https://github.com/vuejs/vue/issues/6642)
+* use MessageChannel for nextTick ([6e41679](https://github.com/vuejs/vue/commit/6e41679a96582da3e0a60bdbf123c33ba0e86b31)), closes [#6566](https://github.com/vuejs/vue/issues/6566) [#6690](https://github.com/vuejs/vue/issues/6690)
+* warn slot-scope when used as a prop ([8295f71](https://github.com/vuejs/vue/commit/8295f716657ffe516f30e84f29ca94f4a0aefabf))
+* work around old Chrome bug ([0f2cb09](https://github.com/vuejs/vue/commit/0f2cb09444e8b2a5fa41aaf8c94e6f2f43e00c2f)), closes [#6601](https://github.com/vuejs/vue/issues/6601)
+
+
+### Features
+
+* add .exact event modifier ([#5977](https://github.com/vuejs/vue/issues/5977)) ([9734e87](https://github.com/vuejs/vue/commit/9734e878ec4efe59f40fc97d9ef86273ad58a430)), closes [#5976](https://github.com/vuejs/vue/issues/5976)
+* add catchError option ([b3cd9bc](https://github.com/vuejs/vue/commit/b3cd9bc3940eb1e01da7081450929557d9c1651e))
+* add in-browser build for vue-template-compiler ([a5e5b31](https://github.com/vuejs/vue/commit/a5e5b31455e0d64f834dd691b7488e0e105d32c3))
+* add max prop for <keep-alive> ([2cba6d4](https://github.com/vuejs/vue/commit/2cba6d4cb1db8273ee45cccb8e50ebd87191244e))
+* **core:** call data method with this value ([#6760](https://github.com/vuejs/vue/issues/6760)) ([3a5432a](https://github.com/vuejs/vue/commit/3a5432a9e3f470ebafcef905281b830537897037)), closes [#6739](https://github.com/vuejs/vue/issues/6739)
+* functional component support for compiled templates ([ea0d227](https://github.com/vuejs/vue/commit/ea0d227d2ddfa5fc5e1112acf9cd485b4eae62cb))
+* improve template expression error message ([e38d006](https://github.com/vuejs/vue/commit/e38d0067521eee85febedc5f3ed3c24b5454c3a9)), closes [#6771](https://github.com/vuejs/vue/issues/6771)
+* **inject:** support providing default values for injections ([#6322](https://github.com/vuejs/vue/issues/6322)) ([88423fc](https://github.com/vuejs/vue/commit/88423fc66a2a4917dcdb7631a4594f05446283b1))
+* make vue and basic server renderer compatible in pure js runtimes ([c5d0fa0](https://github.com/vuejs/vue/commit/c5d0fa0503631b53338e5255bc8640da4b2fd4cb))
+* rename catchError -> errorCaptured ([6dac3db](https://github.com/vuejs/vue/commit/6dac3dbe441302cebb945b675f78f8e7247e2a97))
+* rename inject alias from "name" to "from" ([6893499](https://github.com/vuejs/vue/commit/68934997444c0047c49e419761dfad7fbc043a5d))
+* scoped CSS support for functional components ([050bb33](https://github.com/vuejs/vue/commit/050bb33f9b02589357c037623ea8cbf8ff13555b))
+* **ssr:** add shouldPrefetch option ([7bc899c](https://github.com/vuejs/vue/commit/7bc899ce0ec10be3fbd4bd7e78b66dd357249c81)), closes [#5964](https://github.com/vuejs/vue/issues/5964)
+* **ssr:** auto-remove initial state script if prod ([#6763](https://github.com/vuejs/vue/issues/6763)) ([2d32b5d](https://github.com/vuejs/vue/commit/2d32b5d1b663fa331ec256b73e937af15eb6e3d5)), closes [#6761](https://github.com/vuejs/vue/issues/6761)
+* **ssr:** renderToString return Promise ([f881dd1](https://github.com/vuejs/vue/commit/f881dd175a6764f6f80077df20f950dba63ca447)), closes [#6160](https://github.com/vuejs/vue/issues/6160)
+* support denoting normal elements as scoped slot ([dae173d](https://github.com/vuejs/vue/commit/dae173d96d15f47de6ce6961354d5c05e4273005))
+* support RegExp in ignoredElements ([#6769](https://github.com/vuejs/vue/issues/6769)) ([795b908](https://github.com/vuejs/vue/commit/795b908095b29e76435479879c1ade7ef759ce7b))
+* **types:** further improve Vue type declarations for canonical usage ([#6391](https://github.com/vuejs/vue/issues/6391)) ([db138e2](https://github.com/vuejs/vue/commit/db138e2254d71f6b96e033acf66ba43ad269841a))
+* **v-model:** craete non-existent properties as reactive ([e1da0d5](https://github.com/vuejs/vue/commit/e1da0d585c797860533d6cb10ea3d09c7fb711fc)), closes [#5932](https://github.com/vuejs/vue/issues/5932)
+* **v-model:** support dynamic input type binding ([f3fe012](https://github.com/vuejs/vue/commit/f3fe012d5499f607656b152ce5fcb506c641f9f4))
+* v-on automatic key inference ([4987eeb](https://github.com/vuejs/vue/commit/4987eeb3a734a16a4978d1061f73039002d351e6))
+
+
+### Reverts
+
+* fix(v-model): fix input listener with modifier blocking v-model update ([62405aa](https://github.com/vuejs/vue/commit/62405aa9035d5f547c0440263f16f21c1325f100))
+
+
+
+## [2.4.4](https://github.com/vuejs/vue/compare/v2.4.3...v2.4.4) (2017-09-14)
+
+
+### Bug Fixes
+
+* **ssr:** fix bundleRenderer Promise rejection regression ([0c9534f](https://github.com/vuejs/vue/commit/0c9534ff0069b5289ea9598bcb4f5e5ac346c979))
+* **ssr:** fix style injection regression ([a2f73f2](https://github.com/vuejs/vue/commit/a2f73f2c2e28771e6597334bd86f82851ce0955e)), closes [#6603](https://github.com/vuejs/vue/issues/6603) [#6353](https://github.com/vuejs/vue/issues/6353)
+
+
+
+## [2.4.3](https://github.com/vuejs/vue/compare/v2.4.2...v2.4.3) (2017-09-13)
+
+
+### Bug Fixes
+
+* $off should ignore undefined handler argument ([fa6a729](https://github.com/vuejs/vue/commit/fa6a7290e3b8cb62fb7f999389f476617b56503e)), closes [#6591](https://github.com/vuejs/vue/issues/6591)
+* computed properties should not be cached during SSR ([06741f3](https://github.com/vuejs/vue/commit/06741f326625e2db78d092e586923b97ba006906)), closes [vuejs/vuex#877](https://github.com/vuejs/vuex/issues/877)
+* deep clone slot vnodes on re-render ([0529040](https://github.com/vuejs/vue/commit/0529040c17b8632032a43d142aac88386f6b4a1f)), closes [#6372](https://github.com/vuejs/vue/issues/6372)
+* **directive:** should invoke unbind & inserted on inner component root element change ([538ad20](https://github.com/vuejs/vue/commit/538ad20d8a37fe7ee2463ff20ac9557af70e0d33)), closes [#6513](https://github.com/vuejs/vue/issues/6513)
+* do not use MutationObserver in IE11 ([844a540](https://github.com/vuejs/vue/commit/844a540c647dfa93dc714540953524830dd3475a)), closes [#6466](https://github.com/vuejs/vue/issues/6466)
+* ensure $attrs and $listeners are always objects ([#6441](https://github.com/vuejs/vue/issues/6441)) ([59dbd4a](https://github.com/vuejs/vue/commit/59dbd4a414394a3ce581f9fbd9554da9af9e4b1d)), closes [#6263](https://github.com/vuejs/vue/issues/6263)
+* ensure outer bindings on nested HOC are properly re-applied on inner root element change ([a744497](https://github.com/vuejs/vue/commit/a7444975343f7828004d90bfb0deeb98db0f46e7))
+* handle special case for allowfullscreen on <embed> ([d77b953](https://github.com/vuejs/vue/commit/d77b95317cedae299605fb692e2c7c67796b17cb)), closes [#6202](https://github.com/vuejs/vue/issues/6202)
+* inherit SVG ns on component root node ([#6511](https://github.com/vuejs/vue/issues/6511)) ([89f0d29](https://github.com/vuejs/vue/commit/89f0d29f2d541aa5a1ac9690258cd7c7ee576ef6)), closes [#6506](https://github.com/vuejs/vue/issues/6506)
+* **inject:** exclude not enumerable keys of inject object ([#6346](https://github.com/vuejs/vue/issues/6346)) ([3ee62fd](https://github.com/vuejs/vue/commit/3ee62fd59e20030dd63c08c2390e803d034928fe)), closes [#6574](https://github.com/vuejs/vue/issues/6574)
+* preserve slot attribute if not resolved by Vue ([684cd7d](https://github.com/vuejs/vue/commit/684cd7d21aa7cb9a40fb4a8542c4e08fb3801a86)), closes [#6553](https://github.com/vuejs/vue/issues/6553)
+* **provide:** provide should default to parentVal during merging ([#6473](https://github.com/vuejs/vue/issues/6473)) ([3c21675](https://github.com/vuejs/vue/commit/3c216755f6eb656c6d864265a8dc7b51b3ae971b)), closes [#6436](https://github.com/vuejs/vue/issues/6436)
+* set value as domProp for <progress> ([7116af4](https://github.com/vuejs/vue/commit/7116af4e07520040ed7328c39d0a456808bfe1e1)), closes [#6561](https://github.com/vuejs/vue/issues/6561)
+* **ssr:** address possible xss vector ([5091e2c](https://github.com/vuejs/vue/commit/5091e2c9847601e329ac36d17eae90bb5cb77a91))
+* **ssr:** better handle v-html hydration ([0f00f8f](https://github.com/vuejs/vue/commit/0f00f8fc2b83b964bb929b729a7c9e3675b52106)), closes [#6519](https://github.com/vuejs/vue/issues/6519)
+* **ssr:** expose context.styles when no lifecycle styles are injected ([1f52a2a](https://github.com/vuejs/vue/commit/1f52a2a9f433452c15715131ed74433a43d5cfb7)), closes [#6353](https://github.com/vuejs/vue/issues/6353)
+* **ssr:** fix cachedEscape memory issue ([02f8b80](https://github.com/vuejs/vue/commit/02f8b806768d70c589e646c384e592e93387b994)), closes [#6332](https://github.com/vuejs/vue/issues/6332)
+* **ssr:** handle v-text/v-html with non-string value ([09106f0](https://github.com/vuejs/vue/commit/09106f066a1ba71431e4f9f26246aaf619153e2e)), closes [#6572](https://github.com/vuejs/vue/issues/6572)
+* **ssr:** should also escape static text content ([172dbf9](https://github.com/vuejs/vue/commit/172dbf9faf4cb71dff72c77fdfe80fa1932d1ba3)), closes [#6345](https://github.com/vuejs/vue/issues/6345)
+* support prop type checking for primitive wrapper objects ([#6450](https://github.com/vuejs/vue/issues/6450)) ([679cd1f](https://github.com/vuejs/vue/commit/679cd1fef448989bf645313c391e4134ecd9f593)), closes [#6447](https://github.com/vuejs/vue/issues/6447)
+* **transition:** consider async placeholder as valid child to return ([#6369](https://github.com/vuejs/vue/issues/6369)) ([a43d667](https://github.com/vuejs/vue/commit/a43d66743be2bd62b2398090663e41eeaf0dc75f)), closes [#6256](https://github.com/vuejs/vue/issues/6256)
+* **types:** add `inject` option in functional component options type ([#6530](https://github.com/vuejs/vue/issues/6530)) ([1baa0a7](https://github.com/vuejs/vue/commit/1baa0a7884cfa147df7623a34ee277f7d39c7a21))
+* **types:** allow variadic plugin use ([#6363](https://github.com/vuejs/vue/issues/6363)) ([38d5218](https://github.com/vuejs/vue/commit/38d52182bf8915628314e2aea7d2cc41ec39a0d6)), closes [#6357](https://github.com/vuejs/vue/issues/6357)
+* **v-model:** Allow using array value with array v-model in checkboxes ([#6220](https://github.com/vuejs/vue/issues/6220)) ([d6e6f1d](https://github.com/vuejs/vue/commit/d6e6f1deb180a4f47e94496724623b9e6d8e08b3)), closes [#6219](https://github.com/vuejs/vue/issues/6219)
+* **v-model:** avoid unnecessary change event on select options change ([d4d553c](https://github.com/vuejs/vue/commit/d4d553ced75d8c73e75b85cec398be4b09f6f669)), closes [#6193](https://github.com/vuejs/vue/issues/6193) [#6194](https://github.com/vuejs/vue/issues/6194)
+* **v-model:** fix input listener with modifier blocking v-model update ([6f312d6](https://github.com/vuejs/vue/commit/6f312d636c3d6049dc9e60007f88ea871b8e8173)), closes [#6552](https://github.com/vuejs/vue/issues/6552)
+* **vdom:** avoid diff de-opt when both head/tail are different ([230c6ae](https://github.com/vuejs/vue/commit/230c6ae7822347b9b2a659503291e45fcc58fe41)), closes [#6502](https://github.com/vuejs/vue/issues/6502)
+* **vdom:** Don't replace input for text-like type change ([#6344](https://github.com/vuejs/vue/issues/6344)) ([f76d16e](https://github.com/vuejs/vue/commit/f76d16ed9507d4c2a90243ea3d77ccf00df29346)), closes [#6313](https://github.com/vuejs/vue/issues/6313)
+
+
+### Features
+
+* **weex richtext:** support events and add more test cases ([d627161](https://github.com/vuejs/vue/commit/d627161a91b77ca15e0e30c0313abb33d6c17cbc))
+* **weex richtext:** support to parse styles and classList ([b609642](https://github.com/vuejs/vue/commit/b60964256c876de2516977c776201ef56ab13fb7))
+* **weex richtext:** treat richtext as runtime components ([3e4d926](https://github.com/vuejs/vue/commit/3e4d926336dfdbb5cc4f9d0daed44eb84b53b0de))
+* **weex:** add basic support of richtext ([f1c96e7](https://github.com/vuejs/vue/commit/f1c96e72b2369f3f8cc0078adb732a25cc7bfbfe))
+* **weex:** remove __weex_require_module__ api ([a8146c0](https://github.com/vuejs/vue/commit/a8146c0c1074cfd8214a62309c372b25035fd838))
+* **weex:** return instance in createInstance ([0dc27dc](https://github.com/vuejs/vue/commit/0dc27dcdec72c1c2e12fb49fb95dceca45e84115))
+* **weex:** support nested components in richtext ([0ea2bb4](https://github.com/vuejs/vue/commit/0ea2bb4fb4d9c4d846ae5852c871c472c17f4e34))
+* **weex:** wrap IFFE for appCode ([f975fac](https://github.com/vuejs/vue/commit/f975fac2a8657590dcc23ea8ccae791d125bc935))
+
+
+### Performance Improvements
+
+* **core:** prevent iteration of arrays that should not be observable ([#6467](https://github.com/vuejs/vue/issues/6467)) ([aa820cb](https://github.com/vuejs/vue/commit/aa820cba37b69772868c9cdb69235c424e23f529)), closes [#6284](https://github.com/vuejs/vue/issues/6284)
+* deep clone slot vnodes on re-render ([#6478](https://github.com/vuejs/vue/issues/6478)) ([5346361](https://github.com/vuejs/vue/commit/53463619e5d19d35dfad1a4245a8dc583681feb3))
+* optimize the performance of hyphenate method. ([#6274](https://github.com/vuejs/vue/issues/6274)) ([14ee9e7](https://github.com/vuejs/vue/commit/14ee9e74bf68024fcb53c305b1f15c6aab6e89d3))
+* **v-model:** tweak setSelected ([41d774d](https://github.com/vuejs/vue/commit/41d774d112946f986bf0b0e3f30fd962c01ceba2))
+
+
+
+## [2.4.2](https://github.com/vuejs/vue/compare/v2.4.1...v2.4.2) (2017-07-21)
+
+
+### Bug Fixes
+
+* checkbox v-model="array" ignore false-value ([#6180](https://github.com/vuejs/vue/issues/6180)) ([3d14e85](https://github.com/vuejs/vue/commit/3d14e855e422b656859d1b419af43b94320fcfce)), closes [#6178](https://github.com/vuejs/vue/issues/6178)
+* **compile:** properly generate comments with special character ([#6156](https://github.com/vuejs/vue/issues/6156)) ([d03fa26](https://github.com/vuejs/vue/commit/d03fa26687605a43d9a0c3f395d1d32375f7eaee)), closes [#6150](https://github.com/vuejs/vue/issues/6150)
+* ensure looseEqual is not dependant on key enumeration order ([a8ac129](https://github.com/vuejs/vue/commit/a8ac129a5876a7eeae0137bf2f1b0968d4d6ffad)), closes [#5908](https://github.com/vuejs/vue/issues/5908)
+* include boolean in isPrimitive check ([#6127](https://github.com/vuejs/vue/issues/6127)) ([be3dc9c](https://github.com/vuejs/vue/commit/be3dc9c6e923248bcf81eb8240dd4f3c168fac59)), closes [#6126](https://github.com/vuejs/vue/issues/6126)
+* **parser:** only ignore the first newline in <pre> ([082fc39](https://github.com/vuejs/vue/commit/082fc3967db4d3290e901a38504dcd9bb698e561)), closes [#6146](https://github.com/vuejs/vue/issues/6146)
+* **provide/inject:** merge provide properly from mixins ([3036551](https://github.com/vuejs/vue/commit/303655116f8ec78f3b0ac99569637ad868dfe246)), closes [#6175](https://github.com/vuejs/vue/issues/6175)
+* **provide/inject:** resolve inject properly from mixins ([#6107](https://github.com/vuejs/vue/issues/6107)) ([b0f00e3](https://github.com/vuejs/vue/commit/b0f00e31e7d06edfdc733e2e7f24d5ca448759f9)), closes [#6093](https://github.com/vuejs/vue/issues/6093)
+* **transition:** should trigger transition hooks for v-show in ie9 ([9b4dbba](https://github.com/vuejs/vue/commit/9b4dbba384bc81a99abe429476729f80cb06d19a)), closes [#5525](https://github.com/vuejs/vue/issues/5525)
+* **v-bind:** respect .prop modifier on components ([#6159](https://github.com/vuejs/vue/issues/6159)) ([06b9b0b](https://github.com/vuejs/vue/commit/06b9b0bbadcc6c5afd300ed7748294e62ba00803))
+* **v-model:** use stricter check for <select> option update ([c70addf](https://github.com/vuejs/vue/commit/c70addf7d1a8e820ed80b6ab14aace5aa7b604c5)), closes [#6112](https://github.com/vuejs/vue/issues/6112)
+* **v-on:** revert component root data.on/data.nativeOn behavior for ([1713061](https://github.com/vuejs/vue/commit/17130611261fdbab70d0e5ab45036e4b612b17fe)), closes [#6109](https://github.com/vuejs/vue/issues/6109)
+* work around IE/Edge bug when accessing document.activeElement from iframe ([fc3d7cd](https://github.com/vuejs/vue/commit/fc3d7cd7a93534d76840418467f303d4b301fbcd)), closes [#6157](https://github.com/vuejs/vue/issues/6157)
+
+
+### Features
+
+* warn when assigning to computed property with no setter ([eb9168c](https://github.com/vuejs/vue/commit/eb9168cfc1816b53ddb1eccd6310173a37803897)), closes [#6078](https://github.com/vuejs/vue/issues/6078)
+
+
+### Reverts
+
+* perf: remove src directory from npm module ([#6072](https://github.com/vuejs/vue/issues/6072)) ([ec4b1be](https://github.com/vuejs/vue/commit/ec4b1be42a30a452cca53bbdfdc8404c7a53e890))
+
+
+
+## [2.4.1](https://github.com/vuejs/vue/compare/v2.4.0...v2.4.1) (2017-07-13)
+
+
+
+# [2.4.0](https://github.com/vuejs/vue/compare/v2.3.3...v2.4.0) (2017-07-13)
+
+
+### Bug Fixes
+
+* check enterToClass/leaveToClass existence before adding it ([#5912](https://github.com/vuejs/vue/issues/5912)) ([34d8c79](https://github.com/vuejs/vue/commit/34d8c796ac6a8e47bf23155bad71d07fafd1aa51)), closes [#5800](https://github.com/vuejs/vue/issues/5800)
+* **core:** add merge strategy for provide option ([#6025](https://github.com/vuejs/vue/issues/6025)) ([306997e](https://github.com/vuejs/vue/commit/306997eaf4ff36f4757c753c8a00ce3851e29cca)), closes [#6008](https://github.com/vuejs/vue/issues/6008)
+* **core:** should preserve reactivity-ness of injected objects ([8d66691](https://github.com/vuejs/vue/commit/8d66691ee264969447390822971b8caa029cac3e)), closes [#5913](https://github.com/vuejs/vue/issues/5913)
+* ensure cleanup in watcher.get ([#5988](https://github.com/vuejs/vue/issues/5988)) ([f6cd44c](https://github.com/vuejs/vue/commit/f6cd44c48b83640e5d3fbbea46d7b1b9cb439543)), closes [#5975](https://github.com/vuejs/vue/issues/5975)
+* handle arrays in v-on object syntax ([086e6d9](https://github.com/vuejs/vue/commit/086e6d98f4217542afcc2794717119c62dde89b8))
+* improve Vue.set/Vue.delete API to support multi type of array index ([#5973](https://github.com/vuejs/vue/issues/5973)) ([eea0920](https://github.com/vuejs/vue/commit/eea0920f14d0ea63d1b94c648eeb36ac7dfb4b05)), closes [#5884](https://github.com/vuejs/vue/issues/5884)
+* multiple merged vnode hooks not invoked properly ([91deb4f](https://github.com/vuejs/vue/commit/91deb4fd910afd51137820f120d4c26d0a99e629)), closes [#6076](https://github.com/vuejs/vue/issues/6076)
+* **parser:** the first newline following pre and textarea tag should be ignored ([#6022](https://github.com/vuejs/vue/issues/6022)) ([4d68079](https://github.com/vuejs/vue/commit/4d680794a5a345078827a3fee3db8658bd35ec3a))
+* prefetch should not have `as` attribute ([#5683](https://github.com/vuejs/vue/issues/5683)) ([ebca266](https://github.com/vuejs/vue/commit/ebca266d10febb5ab5ca0cfbcd0dfbff2f2c2170))
+* **ref:** refactor function registerRef ([#6039](https://github.com/vuejs/vue/issues/6039)) ([254d85c](https://github.com/vuejs/vue/commit/254d85cfc42d58bf9e3d0626ba959379bdc32d6f)), closes [#5997](https://github.com/vuejs/vue/issues/5997)
+* **ssr:** fix bundleRenderer mapped async chunks caching check ([#5963](https://github.com/vuejs/vue/issues/5963)) ([de42186](https://github.com/vuejs/vue/commit/de42186d52562a0ce506580484ff64fe86b765bd))
+* **ssr:** reference error when create $ssrContext for root component ([#5981](https://github.com/vuejs/vue/issues/5981)) ([5581654](https://github.com/vuejs/vue/commit/55816543c46e75aa53481ac95a89ff6f87a2d704)), closes [#5941](https://github.com/vuejs/vue/issues/5941)
+* support plugin with multi version vue ([#5985](https://github.com/vuejs/vue/issues/5985)) ([049f317](https://github.com/vuejs/vue/commit/049f3171a9d2e97f62c209a4b78a71ec9dae810f)), closes [#5970](https://github.com/vuejs/vue/issues/5970)
+* transition group should work with dynamic name ([#6006](https://github.com/vuejs/vue/issues/6006)) ([#6019](https://github.com/vuejs/vue/issues/6019)) ([d8d4ca6](https://github.com/vuejs/vue/commit/d8d4ca6763af55e1715bbc1e0fadd10e5be41db3))
+* v-bind object should not override props on scopedSlots ([#5995](https://github.com/vuejs/vue/issues/5995)) ([458030a](https://github.com/vuejs/vue/commit/458030ae19a51982d028dcacfc77ab2cfac8ac26))
+* **v-model:** fix input change check for type="number" ([0a9aab5](https://github.com/vuejs/vue/commit/0a9aab510bcca85c78ef06487b5dcf25d76d780d)), closes [#6069](https://github.com/vuejs/vue/issues/6069)
+* **v-model:** should generate component-specific code for tags with "is" attribute ([a1d1145](https://github.com/vuejs/vue/commit/a1d1145c9123f7175f3ac20b503cfa507ad455f4)), closes [#6066](https://github.com/vuejs/vue/issues/6066)
+* **v-model:** use consistent behavior during IME composition for other text-like input types (fix [#5902](https://github.com/vuejs/vue/issues/5902)) ([4acc8c8](https://github.com/vuejs/vue/commit/4acc8c8be1971112be45e0feb7fb7eddbfc9d247))
+
+
+### Features
+
+* add .editorconfig ([#5691](https://github.com/vuejs/vue/issues/5691)) ([0cc0b07](https://github.com/vuejs/vue/commit/0cc0b0726d389fca535b35e4593a5ecca3dde6c9))
+* add `comments` option to allow preserving comments in template  ([#5951](https://github.com/vuejs/vue/issues/5951)) ([e4da249](https://github.com/vuejs/vue/commit/e4da249ab8ef32a0b8156c840c9d2b9773090f8a)), closes [#5392](https://github.com/vuejs/vue/issues/5392)
+* Add `defer` to body scripts ([#5704](https://github.com/vuejs/vue/issues/5704)) ([f3757eb](https://github.com/vuejs/vue/commit/f3757eb37bfe38cb2e8d87983a1f83d31ea9d30a))
+* **core:** $attrs, $listeners & inheritAttrs option ([6118759](https://github.com/vuejs/vue/commit/61187596b9af48f1cb7b1848ad3eccc02ac2509d)), closes [#5983](https://github.com/vuejs/vue/issues/5983)
+* **keep-alive:** support Array for include and exclude ([#5956](https://github.com/vuejs/vue/issues/5956)) ([51c595a](https://github.com/vuejs/vue/commit/51c595a7cef24e12094f66e0f8934fa41edde07d))
+* resolve ES module default when resolving async components ([0cd6ef3](https://github.com/vuejs/vue/commit/0cd6ef321b3168d6c46c7a870c3d2a53fd9d4bde))
+* **ssr:** inheritAttrs support in SSR ([6bf9772](https://github.com/vuejs/vue/commit/6bf97721f1e38713353d5ac9906c88dca2cdad9b))
+* support sync modifier for v-bind="object" ([#5943](https://github.com/vuejs/vue/issues/5943)) ([3965e50](https://github.com/vuejs/vue/commit/3965e5053a7d2f22e90f81d4a153d65c1c670897)), closes [#5937](https://github.com/vuejs/vue/issues/5937)
+* **types:** add declaration for inheritAttrs ([1f9e924](https://github.com/vuejs/vue/commit/1f9e924971d7894517075f7f0efeeb85994a7ba0))
+* **types:** expose $vnode ([1b7ddd7](https://github.com/vuejs/vue/commit/1b7ddd7a35fab8773508ed47f56d0716081cfa1a))
+* **v-on:** support v-on object syntax with no arguments ([11614d6](https://github.com/vuejs/vue/commit/11614d63b7862b68b11cc45c0891437c62a832d7))
+* **weex:** implement "weex.supports" api to support feature detection ([#6053](https://github.com/vuejs/vue/issues/6053)) ([b1512d8](https://github.com/vuejs/vue/commit/b1512d8b136e0a12aca8dde9e72bf5200d3afe09))
+
+
+### Performance Improvements
+
+* remove src directory from npm module ([#6072](https://github.com/vuejs/vue/issues/6072)) ([e761573](https://github.com/vuejs/vue/commit/e7615737f142e3350b53d09d3a46d7ec143d1ef4))
+
+
+
+## [2.3.3](https://github.com/vuejs/vue/compare/v2.3.2...v2.3.3) (2017-05-09)
+
+
+
+## [2.3.2](https://github.com/vuejs/vue/compare/v2.3.1...v2.3.2) (2017-05-02)
+
+
+
+## [2.3.1](https://github.com/vuejs/vue/compare/v2.3.0...v2.3.1) (2017-05-02)
+
+
+
+# [2.3.0](https://github.com/vuejs/vue/compare/v2.3.0-beta.1...v2.3.0) (2017-04-27)
+
+
+
+# [2.3.0-beta.1](https://github.com/vuejs/vue/compare/v2.2.6...v2.3.0-beta.1) (2017-04-26)
+
+
+
+## [2.2.6](https://github.com/vuejs/vue/compare/v2.2.5...v2.2.6) (2017-03-27)
+
+
+
+## [2.2.5](https://github.com/vuejs/vue/compare/v2.2.4...v2.2.5) (2017-03-24)
+
+
+### Bug Fixes
+
+* **inject:** change warn message when trying to mutate an injected value ([#5243](https://github.com/vuejs/vue/issues/5243)) ([23a058e](https://github.com/vuejs/vue/commit/23a058ed13e7faa667ada2b96e242eb7488b601c))
+
+
+
+## [2.2.4](https://github.com/vuejs/vue/compare/v2.2.3...v2.2.4) (2017-03-13)
+
+
+
+## [2.2.3](https://github.com/vuejs/vue/compare/v2.2.2...v2.2.3) (2017-03-13)
+
+
+
+## [2.2.2](https://github.com/vuejs/vue/compare/v2.2.1...v2.2.2) (2017-03-09)
+
+
+
+## [2.2.1](https://github.com/vuejs/vue/compare/v2.2.0...v2.2.1) (2017-02-26)
+
+
+
+# [2.2.0](https://github.com/vuejs/vue/compare/v2.2.0-beta.2...v2.2.0) (2017-02-26)
+
+
+
+# [2.2.0-beta.2](https://github.com/vuejs/vue/compare/v2.2.0-beta.1...v2.2.0-beta.2) (2017-02-25)
+
+
+### Reverts
+
+* Revert "[WIP] Support for ref callback (#4807)" ([e7a2510](https://github.com/vuejs/vue/commit/e7a2510e631bd25f46b4e1125b83a9236a50ff1d)), closes [#4807](https://github.com/vuejs/vue/issues/4807)
+
+
+
+# [2.2.0-beta.1](https://github.com/vuejs/vue/compare/v2.1.10...v2.2.0-beta.1) (2017-02-24)
+
+
+### Bug Fixes
+
+* **sfc:** component contains '<' only ([#4753](https://github.com/vuejs/vue/issues/4753)) ([938fa4e](https://github.com/vuejs/vue/commit/938fa4efcc9bf6232bf5ace5920398dc2e128ac9))
+
+
+### Features
+
+* allow customization of component v-model prop/event via model option (close [#4515](https://github.com/vuejs/vue/issues/4515)) ([9d6c8ec](https://github.com/vuejs/vue/commit/9d6c8ec268f659a715e3b38c97a1e03964961703))
+* config.performance ([689c107](https://github.com/vuejs/vue/commit/689c107de4624879a5b6282ce43eed5ea3907b38))
+* implement template option for vue-server-renderer ([1c79592](https://github.com/vuejs/vue/commit/1c79592524339773d6397b264b2b489606cd55cb))
+* provide/inject (close [#4029](https://github.com/vuejs/vue/issues/4029)) ([f916bcf](https://github.com/vuejs/vue/commit/f916bcf37105903290ad2353db9a9436536d6859))
+* renderError ([1861ee9](https://github.com/vuejs/vue/commit/1861ee9570730149e01f225323c3a52392e5900f))
+* support multi-chunk bundles in ssr bundle renderer ([561447d](https://github.com/vuejs/vue/commit/561447d278da26e95c488ea75856823557b66c5e))
+
+
+
+## [2.1.10](https://github.com/vuejs/vue/compare/v2.1.9...v2.1.10) (2017-01-17)
+
+
+
+## [2.1.9](https://github.com/vuejs/vue/compare/v2.1.8...v2.1.9) (2017-01-16)
+
+
+### Reverts
+
+* Revert "also bind static special attrs as props (fix #4530)" ([ab0a225](https://github.com/vuejs/vue/commit/ab0a2259e0ef3f4ebdc8d0d4b929fae3e3f579d8)), closes [#4530](https://github.com/vuejs/vue/issues/4530)
+* Revert "Mark node with static props as static (#4662)" ([4e830ba](https://github.com/vuejs/vue/commit/4e830ba3c3c92e78bf3ffbea82a583865deaa52a)), closes [#4662](https://github.com/vuejs/vue/issues/4662)
+
+
+
+## [2.1.8](https://github.com/vuejs/vue/compare/v2.1.7...v2.1.8) (2016-12-28)
+
+
+### Reverts
+
+* Revert "remove no longer necessary code" ([fcc98d5](https://github.com/vuejs/vue/commit/fcc98d52e21bb634c3f0c50eeb4ee87494a7196f))
+* Revert "ensure leave transitions and enter transitions are triggered in the same frame (fix #4510)" ([02e2d99](https://github.com/vuejs/vue/commit/02e2d99e277a1ba1bd42e1b81b2273903fdb7fbc)), closes [#4510](https://github.com/vuejs/vue/issues/4510)
+* Revert "fix enter transition flicker regression (fix #4576)" ([0bb2d4e](https://github.com/vuejs/vue/commit/0bb2d4e2b621950f5d44ed83b7e9ce15e282db68)), closes [#4576](https://github.com/vuejs/vue/issues/4576)
+
+
+
+## [2.1.7](https://github.com/vuejs/vue/compare/v2.1.6...v2.1.7) (2016-12-24)
+
+
+
+## [2.1.6](https://github.com/vuejs/vue/compare/v2.1.5...v2.1.6) (2016-12-13)
+
+
+
+## [2.1.5](https://github.com/vuejs/vue/compare/v2.1.4...v2.1.5) (2016-12-13)
+
+
+
+## [2.1.4](https://github.com/vuejs/vue/compare/v2.1.3...v2.1.4) (2016-12-02)
+
+
+
+## [2.1.3](https://github.com/vuejs/vue/compare/v2.1.2...v2.1.3) (2016-11-24)
+
+
+
+## [2.1.2](https://github.com/vuejs/vue/compare/v2.1.1...v2.1.2) (2016-11-23)
+
+
+
+## [2.1.1](https://github.com/vuejs/vue/compare/v2.1.0...v2.1.1) (2016-11-23)
+
+
+
+# [2.1.0](https://github.com/vuejs/vue/compare/v2.0.8...v2.1.0) (2016-11-22)
+
+
+
+## [2.0.8](https://github.com/vuejs/vue/compare/v2.0.7...v2.0.8) (2016-11-20)
+
+
+
+## [2.0.7](https://github.com/vuejs/vue/compare/v2.0.6...v2.0.7) (2016-11-16)
+
+
+
+## [2.0.6](https://github.com/vuejs/vue/compare/v2.0.5...v2.0.6) (2016-11-15)
+
+
+### Reverts
+
+* Revert "fix #4041, warn overriding Vue's internal methods (#4111)" ([1bcc571](https://github.com/vuejs/vue/commit/1bcc571739d7228db0bc947ee67c20dde5aeb7e0)), closes [#4041](https://github.com/vuejs/vue/issues/4041) [#4111](https://github.com/vuejs/vue/issues/4111)
+
+
+
+## [2.0.5](https://github.com/vuejs/vue/compare/v2.0.4...v2.0.5) (2016-11-05)
+
+
+
+## [2.0.4](https://github.com/vuejs/vue/compare/v2.0.3...v2.0.4) (2016-11-04)
+
+
+
+## [2.0.3](https://github.com/vuejs/vue/compare/v2.0.2...v2.0.3) (2016-10-13)
+
+
+
+## [2.0.2](https://github.com/vuejs/vue/compare/v2.0.1...v2.0.2) (2016-10-12)
+
+
+### Reverts
+
+* Revert "fix select multiple first option auto-selected in Chrome/FF (fix #3852)" ([d0cfd54](https://github.com/vuejs/vue/commit/d0cfd549ba24edc7dced17ef7b8f410c4ea197f0)), closes [#3852](https://github.com/vuejs/vue/issues/3852)
+
+
+
+## [2.0.1](https://github.com/vuejs/vue/compare/v2.0.0...v2.0.1) (2016-09-30)
+
+
+
+# [2.0.0](https://github.com/vuejs/vue/compare/v2.0.0-rc.8...v2.0.0) (2016-09-30)
+
+
+
+# [2.0.0-rc.8](https://github.com/vuejs/vue/compare/v2.0.0-rc.7...v2.0.0-rc.8) (2016-09-27)
+
+
+
+# [2.0.0-rc.7](https://github.com/vuejs/vue/compare/v2.0.0-rc.6...v2.0.0-rc.7) (2016-09-23)
+
+
+
+# [2.0.0-rc.6](https://github.com/vuejs/vue/compare/v2.0.0-rc.5...v2.0.0-rc.6) (2016-09-13)
+
+
+
+# [2.0.0-rc.5](https://github.com/vuejs/vue/compare/v2.0.0-rc.4...v2.0.0-rc.5) (2016-09-08)
+
+
+
+# [2.0.0-rc.4](https://github.com/vuejs/vue/compare/v2.0.0-rc.3...v2.0.0-rc.4) (2016-08-29)
+
+
+
+# [2.0.0-rc.3](https://github.com/vuejs/vue/compare/v2.0.0-rc.2...v2.0.0-rc.3) (2016-08-20)
+
+
+
+# [2.0.0-rc.2](https://github.com/vuejs/vue/compare/v2.0.0-rc.1...v2.0.0-rc.2) (2016-08-16)
+
+
+### Reverts
+
+* Revert "support transition on component with v-show in root node (fix #3431)" ([68be112](https://github.com/vuejs/vue/commit/68be112652060f9a7123b594a3b18ca5fc31b033)), closes [#3431](https://github.com/vuejs/vue/issues/3431)
+
+
+
+# [2.0.0-rc.1](https://github.com/vuejs/vue/compare/v2.0.0-beta.8...v2.0.0-rc.1) (2016-08-11)
+
+
+
+# [2.0.0-beta.8](https://github.com/vuejs/vue/compare/v2.0.0-beta.7...v2.0.0-beta.8) (2016-08-10)
+
+
+
+# [2.0.0-beta.7](https://github.com/vuejs/vue/compare/v2.0.0-beta.6...v2.0.0-beta.7) (2016-08-05)
+
+
+
+# [2.0.0-beta.6](https://github.com/vuejs/vue/compare/v2.0.0-beta.5...v2.0.0-beta.6) (2016-08-01)
+
+
+
+# [2.0.0-beta.5](https://github.com/vuejs/vue/compare/v2.0.0-beta.4...v2.0.0-beta.5) (2016-07-27)
+
+
+### Reverts
+
+* Revert "remove parser pre/post transforms (not used)" ([bee95f8](https://github.com/vuejs/vue/commit/bee95f8c08af2dd5af653847ec569bd801112c90))
+
+
+
+# [2.0.0-beta.4](https://github.com/vuejs/vue/compare/v2.0.0-beta.3...v2.0.0-beta.4) (2016-07-26)
+
+
+
+# [2.0.0-beta.3](https://github.com/vuejs/vue/compare/v2.0.0-beta.2...v2.0.0-beta.3) (2016-07-24)
+
+
+
+# [2.0.0-beta.2](https://github.com/vuejs/vue/compare/v2.0.0-beta.1...v2.0.0-beta.2) (2016-07-17)
+
+
+
+# [2.0.0-beta.1](https://github.com/vuejs/vue/compare/v2.0.0-alpha.8...v2.0.0-beta.1) (2016-07-07)
+
+
+
+# [2.0.0-alpha.8](https://github.com/vuejs/vue/compare/v2.0.0-alpha.7...v2.0.0-alpha.8) (2016-06-28)
+
+
+
+# [2.0.0-alpha.7](https://github.com/vuejs/vue/compare/v2.0.0-alpha.6...v2.0.0-alpha.7) (2016-06-28)
+
+
+
+# [2.0.0-alpha.6](https://github.com/vuejs/vue/compare/v2.0.0-alpha.5...v2.0.0-alpha.6) (2016-06-22)
+
+
+
+# [2.0.0-alpha.5](https://github.com/vuejs/vue/compare/v2.0.0-alpha.4...v2.0.0-alpha.5) (2016-06-17)
+
+
+
+# [2.0.0-alpha.4](https://github.com/vuejs/vue/compare/v2.0.0-alpha.3...v2.0.0-alpha.4) (2016-06-16)
+
+
+
+# [2.0.0-alpha.3](https://github.com/vuejs/vue/compare/v2.0.0-alpha.2...v2.0.0-alpha.3) (2016-06-15)
+
+
+
+# [2.0.0-alpha.2](https://github.com/vuejs/vue/compare/v2.0.0-alpha.1...v2.0.0-alpha.2) (2016-06-13)
+
+
+
+# [2.0.0-alpha.1](https://github.com/vuejs/vue/compare/5b30f3eab89db88cb61894de617bdce53e82393e...v2.0.0-alpha.1) (2016-06-10)
+
+
+### Reverts
+
+* Revert "simplify array change detection" ([5b30f3e](https://github.com/vuejs/vue/commit/5b30f3eab89db88cb61894de617bdce53e82393e))
+
+
+
diff --git a/package.json b/package.json
index 84adccaeafc..59c73d786cf 100644
--- a/package.json
+++ b/package.json
@@ -35,9 +35,8 @@
     "ts-check": "tsc -p tsconfig.json --noEmit",
     "ts-check:test": "tsc -p test/tsconfig.json --noEmit",
     "bench:ssr": "npm run build:ssr && node benchmarks/ssr/renderToString.js && node benchmarks/ssr/renderToStream.js",
-    "release": "bash scripts/release.sh",
-    "release:note": "node scripts/gen-release-note.js",
-    "commit": "git-cz"
+    "release": "node scripts/release.js",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s"
   },
   "gitHooks": {
     "pre-commit": "lint-staged",
@@ -76,13 +75,13 @@
     "@types/he": "^1.1.2",
     "@types/node": "^17.0.30",
     "chalk": "^4.0.0",
-    "commitizen": "^4.2.4",
-    "conventional-changelog": "^3.1.25",
+    "conventional-changelog-cli": "^2.2.2",
     "cross-spawn": "^7.0.3",
-    "cz-conventional-changelog": "^3.3.0",
+    "de-indent": "^1.0.2",
+    "enquirer": "^2.3.6",
     "esbuild": "^0.14.39",
+    "execa": "^4.0.0",
     "he": "^1.2.0",
-    "de-indent": "^1.0.2",
     "jasmine-core": "^4.1.1",
     "jsdom": "^19.0.0",
     "karma": "^6.3.20",
@@ -93,11 +92,13 @@
     "lint-staged": "^12.4.1",
     "lodash": "^4.17.21",
     "marked": "^4.0.6",
+    "minimist": "^1.2.6",
     "prettier": "^2.6.2",
     "puppeteer": "^14.1.1",
     "rimraf": "^3.0.2",
     "rollup": "^2.70.2",
     "rollup-plugin-typescript2": "^0.31.2",
+    "semver": "^7.3.7",
     "shelljs": "^0.8.5",
     "terser": "^5.13.1",
     "todomvc-app-css": "^2.4.2",
@@ -106,10 +107,5 @@
     "typescript": "^4.6.4",
     "vitest": "^0.12.6",
     "yorkie": "^2.0.0"
-  },
-  "config": {
-    "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
-    }
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3dbe7ee4c55..fe5925c21e5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -13,12 +13,12 @@ importers:
       '@types/node': ^17.0.30
       '@vue/compiler-sfc': workspace:*
       chalk: ^4.0.0
-      commitizen: ^4.2.4
-      conventional-changelog: ^3.1.25
+      conventional-changelog-cli: ^2.2.2
       cross-spawn: ^7.0.3
-      cz-conventional-changelog: ^3.3.0
       de-indent: ^1.0.2
+      enquirer: ^2.3.6
       esbuild: ^0.14.39
+      execa: ^4.0.0
       he: ^1.2.0
       jasmine-core: ^4.1.1
       jsdom: ^19.0.0
@@ -30,11 +30,13 @@ importers:
       lint-staged: ^12.4.1
       lodash: ^4.17.21
       marked: ^4.0.6
+      minimist: ^1.2.6
       prettier: ^2.6.2
       puppeteer: ^14.1.1
       rimraf: ^3.0.2
       rollup: ^2.70.2
       rollup-plugin-typescript2: ^0.31.2
+      semver: ^7.3.7
       shelljs: ^0.8.5
       terser: ^5.13.1
       todomvc-app-css: ^2.4.2
@@ -54,12 +56,12 @@ importers:
       '@types/he': 1.1.2
       '@types/node': 17.0.36
       chalk: 4.1.2
-      commitizen: 4.2.4
-      conventional-changelog: 3.1.25
+      conventional-changelog-cli: 2.2.2
       cross-spawn: 7.0.3
-      cz-conventional-changelog: 3.3.0
       de-indent: 1.0.2
+      enquirer: 2.3.6
       esbuild: 0.14.42
+      execa: 4.1.0
       he: 1.2.0
       jasmine-core: 4.1.1
       jsdom: 19.0.0
@@ -68,14 +70,16 @@ importers:
       karma-cli: 2.0.0
       karma-esbuild: 2.2.4_esbuild@0.14.42
       karma-jasmine: 5.0.1_karma@6.3.20
-      lint-staged: 12.4.3
+      lint-staged: 12.4.3_enquirer@2.3.6
       lodash: 4.17.21
       marked: 4.0.16
+      minimist: 1.2.6
       prettier: 2.6.2
       puppeteer: 14.1.2
       rimraf: 3.0.2
       rollup: 2.75.3
       rollup-plugin-typescript2: 0.31.2_nl2qxg2fxlgm6l264qcwjguuca
+      semver: 7.3.7
       shelljs: 0.8.5
       terser: 5.14.0
       todomvc-app-css: 2.4.2
@@ -203,64 +207,6 @@ packages:
     engines: {node: '>=0.1.90'}
     dev: true
 
-  /@commitlint/config-validator/17.0.0:
-    resolution: {integrity: sha512-78IQjoZWR4kDHp/U5y17euEWzswJpPkA9TDL5F6oZZZaLIEreWzrDZD5PWtM8MsSRl/K2LDU/UrzYju2bKLMpA==}
-    engines: {node: '>=v14'}
-    dependencies:
-      '@commitlint/types': 17.0.0
-      ajv: 6.12.6
-    dev: true
-    optional: true
-
-  /@commitlint/execute-rule/17.0.0:
-    resolution: {integrity: sha512-nVjL/w/zuqjCqSJm8UfpNaw66V9WzuJtQvEnCrK4jDw6qKTmZB+1JQ8m6BQVZbNBcwfYdDNKnhIhqI0Rk7lgpQ==}
-    engines: {node: '>=v14'}
-    dev: true
-    optional: true
-
-  /@commitlint/load/17.0.0:
-    resolution: {integrity: sha512-XaiHF4yWQOPAI0O6wXvk+NYLtJn/Xb7jgZEeKd4C1ZWd7vR7u8z5h0PkWxSr0uLZGQsElGxv3fiZ32C5+q6M8w==}
-    engines: {node: '>=v14'}
-    requiresBuild: true
-    dependencies:
-      '@commitlint/config-validator': 17.0.0
-      '@commitlint/execute-rule': 17.0.0
-      '@commitlint/resolve-extends': 17.0.0
-      '@commitlint/types': 17.0.0
-      '@types/node': 17.0.36
-      chalk: 4.1.2
-      cosmiconfig: 7.0.1
-      cosmiconfig-typescript-loader: 2.0.1_w6gfxie3xfwntbz3mwbbvycbdq
-      lodash: 4.17.21
-      resolve-from: 5.0.0
-      typescript: 4.7.2
-    transitivePeerDependencies:
-      - '@swc/core'
-      - '@swc/wasm'
-    dev: true
-    optional: true
-
-  /@commitlint/resolve-extends/17.0.0:
-    resolution: {integrity: sha512-wi60WiJmwaQ7lzMXK8Vbc18Hq9tE2j/6iv2AFfPUGV7fvfY6Sf1iNKuUHirSqR0fquUyufIXe4y/K9A6LVIIvw==}
-    engines: {node: '>=v14'}
-    dependencies:
-      '@commitlint/config-validator': 17.0.0
-      '@commitlint/types': 17.0.0
-      import-fresh: 3.3.0
-      lodash: 4.17.21
-      resolve-from: 5.0.0
-      resolve-global: 1.0.0
-    dev: true
-    optional: true
-
-  /@commitlint/types/17.0.0:
-    resolution: {integrity: sha512-hBAw6U+SkAT5h47zDMeOu3HSiD0SODw4Aq7rRNh1ceUmL7GyLKYhPbUvlRWqZ65XjBLPHZhFyQlRaPNz8qvUyQ==}
-    engines: {node: '>=v14'}
-    dependencies:
-      chalk: 4.1.2
-    dev: true
-    optional: true
-
   /@cspotcode/source-map-support/0.8.1:
     resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
@@ -540,11 +486,6 @@ packages:
     resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
     dev: true
 
-  /@types/parse-json/4.0.0:
-    resolution: {integrity: sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==}
-    dev: true
-    optional: true
-
   /@types/resolve/1.17.1:
     resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==}
     dependencies:
@@ -808,9 +749,9 @@ packages:
       uri-js: 4.4.1
     dev: true
 
-  /ansi-escapes/3.2.0:
-    resolution: {integrity: sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==}
-    engines: {node: '>=4'}
+  /ansi-colors/4.1.3:
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}
     dev: true
 
   /ansi-escapes/4.3.2:
@@ -820,16 +761,6 @@ packages:
       type-fest: 0.21.3
     dev: true
 
-  /ansi-regex/3.0.1:
-    resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==}
-    engines: {node: '>=4'}
-    dev: true
-
-  /ansi-regex/4.1.1:
-    resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==}
-    engines: {node: '>=6'}
-    dev: true
-
   /ansi-regex/5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
     engines: {node: '>=8'}
@@ -1238,11 +1169,6 @@ packages:
       unset-value: 1.0.0
     dev: true
 
-  /cachedir/2.2.0:
-    resolution: {integrity: sha512-VvxA0xhNqIIfg0V9AmJkDg91DaJwryutH5rVEZAhcNi4iJFj9f+QxmAjgK1LT9I8OgToX27fypX6/MeCXVbBjQ==}
-    engines: {node: '>=6'}
-    dev: true
-
   /call-bind/1.0.2:
     resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
     dependencies:
@@ -1250,12 +1176,6 @@ packages:
       get-intrinsic: 1.1.1
     dev: true
 
-  /callsites/3.1.0:
-    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
-    engines: {node: '>=6'}
-    dev: true
-    optional: true
-
   /camelcase-keys/6.2.2:
     resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==}
     engines: {node: '>=8'}
@@ -1305,10 +1225,6 @@ packages:
       is-regex: 1.1.4
     dev: true
 
-  /chardet/0.7.0:
-    resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==}
-    dev: true
-
   /check-error/1.0.2:
     resolution: {integrity: sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==}
     dev: true
@@ -1385,13 +1301,6 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /cli-cursor/2.1.0:
-    resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==}
-    engines: {node: '>=4'}
-    dependencies:
-      restore-cursor: 2.0.0
-    dev: true
-
   /cli-cursor/3.1.0:
     resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==}
     engines: {node: '>=8'}
@@ -1415,10 +1324,6 @@ packages:
       string-width: 5.1.2
     dev: true
 
-  /cli-width/2.2.1:
-    resolution: {integrity: sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==}
-    dev: true
-
   /cliui/7.0.4:
     resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
     dependencies:
@@ -1479,30 +1384,6 @@ packages:
     engines: {node: ^12.20.0 || >=14}
     dev: true
 
-  /commitizen/4.2.4:
-    resolution: {integrity: sha512-LlZChbDzg3Ir3O2S7jSo/cgWp5/QwylQVr59K4xayVq8S4/RdKzSyJkghAiZZHfhh5t4pxunUoyeg0ml1q/7aw==}
-    engines: {node: '>= 10'}
-    hasBin: true
-    dependencies:
-      cachedir: 2.2.0
-      cz-conventional-changelog: 3.2.0
-      dedent: 0.7.0
-      detect-indent: 6.0.0
-      find-node-modules: 2.1.3
-      find-root: 1.1.0
-      fs-extra: 8.1.0
-      glob: 7.1.4
-      inquirer: 6.5.2
-      is-utf8: 0.2.1
-      lodash: 4.17.21
-      minimist: 1.2.5
-      strip-bom: 4.0.0
-      strip-json-comments: 3.0.1
-    transitivePeerDependencies:
-      - '@swc/core'
-      - '@swc/wasm'
-    dev: true
-
   /commondir/1.0.1:
     resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
     dev: true
@@ -1579,6 +1460,18 @@ packages:
       q: 1.5.1
     dev: true
 
+  /conventional-changelog-cli/2.2.2:
+    resolution: {integrity: sha512-8grMV5Jo8S0kP3yoMeJxV2P5R6VJOqK72IiSV9t/4H5r/HiRqEBQ83bYGuz4Yzfdj4bjaAEhZN/FFbsFXr5bOA==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      add-stream: 1.0.0
+      conventional-changelog: 3.1.25
+      lodash: 4.17.21
+      meow: 8.1.2
+      tempfile: 3.0.0
+    dev: true
+
   /conventional-changelog-codemirror/2.0.8:
     resolution: {integrity: sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw==}
     engines: {node: '>=10'}
@@ -1689,10 +1582,6 @@ packages:
       conventional-changelog-preset-loader: 2.3.4
     dev: true
 
-  /conventional-commit-types/3.0.0:
-    resolution: {integrity: sha512-SmmCYnOniSsAa9GqWOeLqc179lfr5TRu5b4QFDkbsrJ5TZjPJx85wtOr3zn+1dbeNiXDKGPbZ72IKbPhLXh/Lg==}
-    dev: true
-
   /conventional-commits-filter/2.0.7:
     resolution: {integrity: sha512-ASS9SamOP4TbCClsRHxIHXRfcGCnIoQqkvAzCSbZzTFLfcTqJVugB0agRgsEELsqaeWgsXv513eS116wnlSSPA==}
     engines: {node: '>=10'}
@@ -1747,35 +1636,6 @@ packages:
       vary: 1.1.2
     dev: true
 
-  /cosmiconfig-typescript-loader/2.0.1_w6gfxie3xfwntbz3mwbbvycbdq:
-    resolution: {integrity: sha512-B9s6sX/omXq7I6gC6+YgLmrBFMJhPWew7ty/X5Tuwtd2zOSgWaUdXjkuVwbe3qqcdETo60+1nSVMekq//LIXVA==}
-    engines: {node: '>=12', npm: '>=6'}
-    peerDependencies:
-      '@types/node': '*'
-      typescript: '>=3'
-    dependencies:
-      '@types/node': 17.0.36
-      cosmiconfig: 7.0.1
-      ts-node: 10.8.0_w6gfxie3xfwntbz3mwbbvycbdq
-      typescript: 4.7.2
-    transitivePeerDependencies:
-      - '@swc/core'
-      - '@swc/wasm'
-    dev: true
-    optional: true
-
-  /cosmiconfig/7.0.1:
-    resolution: {integrity: sha512-a1YWNUV2HwGimB7dU2s1wUMurNKjpx60HxBB6xUM8Re+2s1g1IIfJvFR0/iCF+XHdE0GMTKTuLR32UQff4TEyQ==}
-    engines: {node: '>=10'}
-    dependencies:
-      '@types/parse-json': 4.0.0
-      import-fresh: 3.3.0
-      parse-json: 5.2.0
-      path-type: 4.0.0
-      yaml: 1.10.2
-    dev: true
-    optional: true
-
   /create-ecdh/4.0.4:
     resolution: {integrity: sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==}
     dependencies:
@@ -1878,40 +1738,6 @@ packages:
     resolution: {integrity: sha512-NJGVKPS81XejHcLhaLJS7plab0fK3slPh11mESeeDq2W4ZI5kUKK/LRRdVDvjJseojbPB7ZwjnyOybg3Igea/A==}
     dev: true
 
-  /cz-conventional-changelog/3.2.0:
-    resolution: {integrity: sha512-yAYxeGpVi27hqIilG1nh4A9Bnx4J3Ov+eXy4koL3drrR+IO9GaWPsKjik20ht608Asqi8TQPf0mczhEeyAtMzg==}
-    engines: {node: '>= 10'}
-    dependencies:
-      chalk: 2.4.2
-      commitizen: 4.2.4
-      conventional-commit-types: 3.0.0
-      lodash.map: 4.6.0
-      longest: 2.0.1
-      word-wrap: 1.2.3
-    optionalDependencies:
-      '@commitlint/load': 17.0.0
-    transitivePeerDependencies:
-      - '@swc/core'
-      - '@swc/wasm'
-    dev: true
-
-  /cz-conventional-changelog/3.3.0:
-    resolution: {integrity: sha512-U466fIzU5U22eES5lTNiNbZ+d8dfcHcssH4o7QsdWaCcRs/feIPCxKYSWkYBNs5mny7MvEfwpTLWjvbm94hecw==}
-    engines: {node: '>= 10'}
-    dependencies:
-      chalk: 2.4.2
-      commitizen: 4.2.4
-      conventional-commit-types: 3.0.0
-      lodash.map: 4.6.0
-      longest: 2.0.1
-      word-wrap: 1.2.3
-    optionalDependencies:
-      '@commitlint/load': 17.0.0
-    transitivePeerDependencies:
-      - '@swc/core'
-      - '@swc/wasm'
-    dev: true
-
   /dargs/7.0.0:
     resolution: {integrity: sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg==}
     engines: {node: '>=8'}
@@ -1996,10 +1822,6 @@ packages:
     engines: {node: '>=0.10'}
     dev: true
 
-  /dedent/0.7.0:
-    resolution: {integrity: sha1-JJXduvbrh0q7Dhvp3yLS5aVEMmw=}
-    dev: true
-
   /deep-eql/3.0.1:
     resolution: {integrity: sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw==}
     engines: {node: '>=0.12'}
@@ -2060,16 +1882,6 @@ packages:
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
     dev: true
 
-  /detect-file/1.0.0:
-    resolution: {integrity: sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /detect-indent/6.0.0:
-    resolution: {integrity: sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA==}
-    engines: {node: '>=8'}
-    dev: true
-
   /devtools-protocol/0.0.982423:
     resolution: {integrity: sha512-FnVW2nDbjGNw1uD/JRC+9U5768W7e1TfUwqbDTcSsAu1jXFjITSX8w3rkW5FEpHRMPPGpvNSmO1pOpqByiWscA==}
     dev: true
@@ -2210,6 +2022,13 @@ packages:
       tapable: 1.1.3
     dev: true
 
+  /enquirer/2.3.6:
+    resolution: {integrity: sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==}
+    engines: {node: '>=8.6'}
+    dependencies:
+      ansi-colors: 4.1.3
+    dev: true
+
   /ent/2.2.0:
     resolution: {integrity: sha512-GHrMyVZQWvTIdDtpiEXdHZnFQKzeO09apj8Cbl4pKWy4i0Oprcq17usfDt5aO63swf0JOeMWjWQE/LzgSRuWpA==}
     dev: true
@@ -2535,6 +2354,21 @@ packages:
       strip-eof: 1.0.0
     dev: true
 
+  /execa/4.1.0:
+    resolution: {integrity: sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==}
+    engines: {node: '>=10'}
+    dependencies:
+      cross-spawn: 7.0.3
+      get-stream: 5.2.0
+      human-signals: 1.1.1
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+    dev: true
+
   /execa/5.1.1:
     resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
     engines: {node: '>=10'}
@@ -2565,13 +2399,6 @@ packages:
       - supports-color
     dev: true
 
-  /expand-tilde/2.0.2:
-    resolution: {integrity: sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      homedir-polyfill: 1.0.3
-    dev: true
-
   /extend-shallow/2.0.1:
     resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==}
     engines: {node: '>=0.10.0'}
@@ -2591,15 +2418,6 @@ packages:
     resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
     dev: true
 
-  /external-editor/3.1.0:
-    resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
-    engines: {node: '>=4'}
-    dependencies:
-      chardet: 0.7.0
-      iconv-lite: 0.4.24
-      tmp: 0.0.33
-    dev: true
-
   /extglob/2.0.4:
     resolution: {integrity: sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==}
     engines: {node: '>=0.10.0'}
@@ -2652,13 +2470,6 @@ packages:
     resolution: {integrity: sha512-0btnI/H8f2pavGMN8w40mlSKOfTK2SVJmBfBeVIj3kNw0swwgzyRq0d5TJVOwodFmtvpPeWPN/MCcfuWF0Ezbw==}
     dev: true
 
-  /figures/2.0.0:
-    resolution: {integrity: sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==}
-    engines: {node: '>=4'}
-    dependencies:
-      escape-string-regexp: 1.0.5
-    dev: true
-
   /file-loader/3.0.1_webpack@4.46.0:
     resolution: {integrity: sha512-4sNIOXgtH/9WZq4NvlfU3Opn5ynUsqBwSLyM+I7UOwdGigTBYfVVQEwe/msZNX/j4pCJTIM14Fsw66Svo1oVrw==}
     engines: {node: '>= 6.9.0'}
@@ -2725,17 +2536,6 @@ packages:
       pkg-dir: 4.2.0
     dev: true
 
-  /find-node-modules/2.1.3:
-    resolution: {integrity: sha512-UC2I2+nx1ZuOBclWVNdcnbDR5dlrOdVb7xNjmT/lHE+LsgztWks3dG7boJ37yTS/venXw84B/mAW9uHVoC5QRg==}
-    dependencies:
-      findup-sync: 4.0.0
-      merge: 2.1.1
-    dev: true
-
-  /find-root/1.1.0:
-    resolution: {integrity: sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==}
-    dev: true
-
   /find-up/2.1.0:
     resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==}
     engines: {node: '>=4'}
@@ -2766,16 +2566,6 @@ packages:
       path-exists: 4.0.0
     dev: true
 
-  /findup-sync/4.0.0:
-    resolution: {integrity: sha512-6jvvn/12IC4quLBL1KNokxC7wWTvYncaVUYSoxWw7YykPLuRrnv4qdHcSOywOI5RpkOVGeQRtWM8/q+G6W6qfQ==}
-    engines: {node: '>= 8'}
-    dependencies:
-      detect-file: 1.0.0
-      is-glob: 4.0.3
-      micromatch: 4.0.5
-      resolve-dir: 1.0.1
-    dev: true
-
   /flatted/3.2.5:
     resolution: {integrity: sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==}
     dev: true
@@ -2847,15 +2637,6 @@ packages:
       universalify: 0.1.2
     dev: true
 
-  /fs-extra/8.1.0:
-    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
-    engines: {node: '>=6 <7 || >=8'}
-    dependencies:
-      graceful-fs: 4.2.10
-      jsonfile: 4.0.0
-      universalify: 0.1.2
-    dev: true
-
   /fs-write-stream-atomic/1.0.10:
     resolution: {integrity: sha512-gehEzmPn2nAwr39eay+x3X34Ra+M2QlVUTLhkXPjWdeO8RF9kszk116avgBJM3ZyNHgHXBNx+VmPaFC36k0PzA==}
     dependencies:
@@ -2998,17 +2779,6 @@ packages:
       is-glob: 4.0.3
     dev: true
 
-  /glob/7.1.4:
-    resolution: {integrity: sha512-hkLPepehmnKk41pUGm3sYxoFs/umurYfYJCerbXEyFIWcAzvpipAgVkBqqT9RBKMGjnq6kMuyYwha6csxbiM1A==}
-    dependencies:
-      fs.realpath: 1.0.0
-      inflight: 1.0.6
-      inherits: 2.0.4
-      minimatch: 3.1.2
-      once: 1.4.0
-      path-is-absolute: 1.0.1
-    dev: true
-
   /glob/7.2.3:
     resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
     dependencies:
@@ -3020,34 +2790,6 @@ packages:
       path-is-absolute: 1.0.1
     dev: true
 
-  /global-dirs/0.1.1:
-    resolution: {integrity: sha512-NknMLn7F2J7aflwFOlGdNIuCDpN3VGoSoB+aap3KABFWbHVn1TCgFC+np23J8W2BiZbjfEw3BFBycSMv1AFblg==}
-    engines: {node: '>=4'}
-    dependencies:
-      ini: 1.3.8
-    dev: true
-    optional: true
-
-  /global-modules/1.0.0:
-    resolution: {integrity: sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      global-prefix: 1.0.2
-      is-windows: 1.0.2
-      resolve-dir: 1.0.1
-    dev: true
-
-  /global-prefix/1.0.2:
-    resolution: {integrity: sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      expand-tilde: 2.0.2
-      homedir-polyfill: 1.0.3
-      ini: 1.3.8
-      is-windows: 1.0.2
-      which: 1.3.1
-    dev: true
-
   /graceful-fs/4.2.10:
     resolution: {integrity: sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA==}
     dev: true
@@ -3159,13 +2901,6 @@ packages:
       minimalistic-crypto-utils: 1.0.1
     dev: true
 
-  /homedir-polyfill/1.0.3:
-    resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      parse-passwd: 1.0.0
-    dev: true
-
   /hosted-git-info/2.8.9:
     resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
     dev: true
@@ -3231,6 +2966,11 @@ packages:
       - supports-color
     dev: true
 
+  /human-signals/1.1.1:
+    resolution: {integrity: sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==}
+    engines: {node: '>=8.12.0'}
+    dev: true
+
   /human-signals/2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
@@ -3275,15 +3015,6 @@ packages:
     resolution: {integrity: sha512-oNkuqVTA8jqG1Q6c+UglTOD1xhC1BtjKI7XkCXRkZHrN5m18/XsnUp8Q89GkQO/z+0WjonSvl0FLhDYftp46nQ==}
     dev: true
 
-  /import-fresh/3.3.0:
-    resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==}
-    engines: {node: '>=6'}
-    dependencies:
-      parent-module: 1.0.1
-      resolve-from: 4.0.0
-    dev: true
-    optional: true
-
   /import-lazy/4.0.0:
     resolution: {integrity: sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==}
     engines: {node: '>=8'}
@@ -3326,25 +3057,6 @@ packages:
     resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
     dev: true
 
-  /inquirer/6.5.2:
-    resolution: {integrity: sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      ansi-escapes: 3.2.0
-      chalk: 2.4.2
-      cli-cursor: 2.1.0
-      cli-width: 2.2.1
-      external-editor: 3.1.0
-      figures: 2.0.0
-      lodash: 4.17.21
-      mute-stream: 0.0.7
-      run-async: 2.4.1
-      rxjs: 6.6.7
-      string-width: 2.1.1
-      strip-ansi: 5.2.0
-      through: 2.3.8
-    dev: true
-
   /interpret/1.4.0:
     resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==}
     engines: {node: '>= 0.10'}
@@ -3462,11 +3174,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /is-fullwidth-code-point/2.0.0:
-    resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==}
-    engines: {node: '>=4'}
-    dev: true
-
   /is-fullwidth-code-point/3.0.0:
     resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
     engines: {node: '>=8'}
@@ -3564,10 +3271,6 @@ packages:
       text-extensions: 1.9.0
     dev: true
 
-  /is-utf8/0.2.1:
-    resolution: {integrity: sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==}
-    dev: true
-
   /is-windows/1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
     engines: {node: '>=0.10.0'}
@@ -3821,7 +3524,7 @@ packages:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
     dev: true
 
-  /lint-staged/12.4.3:
+  /lint-staged/12.4.3_enquirer@2.3.6:
     resolution: {integrity: sha512-eH6SKOmdm/ZwCRMTZAmM3q3dPkpq6vco/BfrOw8iGun4Xs/thYegPD/MLIwKO+iPkzibkLJuQcRhRLXKvaKreg==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     hasBin: true
@@ -3832,7 +3535,7 @@ packages:
       debug: 4.3.4_supports-color@9.2.2
       execa: 5.1.1
       lilconfig: 2.0.5
-      listr2: 4.0.5
+      listr2: 4.0.5_enquirer@2.3.6
       micromatch: 4.0.5
       normalize-path: 3.0.0
       object-inspect: 1.12.2
@@ -3844,7 +3547,7 @@ packages:
       - enquirer
     dev: true
 
-  /listr2/4.0.5:
+  /listr2/4.0.5_enquirer@2.3.6:
     resolution: {integrity: sha512-juGHV1doQdpNT3GSTs9IUN43QJb7KHdF9uqg7Vufs/tG9VTzpFphqF4pm/ICdAABGQxsyNn9CiYA3StkI6jpwA==}
     engines: {node: '>=12'}
     peerDependencies:
@@ -3855,6 +3558,7 @@ packages:
     dependencies:
       cli-truncate: 2.1.0
       colorette: 2.0.16
+      enquirer: 2.3.6
       log-update: 4.0.0
       p-map: 4.0.0
       rfdc: 1.3.0
@@ -3947,10 +3651,6 @@ packages:
     resolution: {integrity: sha512-fPMfXjGQEV9Xsq/8MTSgUf255gawYRbjwMyDbcvDhXgV7enSZA0hynz6vMPnpAb5iONEzBHBPsT+0zes5Z301g==}
     dev: true
 
-  /lodash.map/4.6.0:
-    resolution: {integrity: sha512-worNHGKLDetmcEYDvh2stPCrrQRkP20E4l0iIS7F8EvzMqBBi7ltvFN5m1HvTf1P7Jk1txKhvFcmYsCr8O2F1Q==}
-    dev: true
-
   /lodash.template/4.5.0:
     resolution: {integrity: sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==}
     dependencies:
@@ -3995,11 +3695,6 @@ packages:
       - supports-color
     dev: true
 
-  /longest/2.0.1:
-    resolution: {integrity: sha512-Ajzxb8CM6WAnFjgiloPsI3bF+WCxcvhdIG3KNA2KN962+tdBsHcuQ4k4qX/EcS/2CRkcc0iAkR956Nib6aXU/Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /loupe/2.3.4:
     resolution: {integrity: sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ==}
     dependencies:
@@ -4134,10 +3829,6 @@ packages:
     resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
     dev: true
 
-  /merge/2.1.1:
-    resolution: {integrity: sha512-jz+Cfrg9GWOZbQAnDQ4hlVnQky+341Yk5ru8bZSe6sIDTCIg8n9i/u7hSQGSVOF3C7lH6mGtqjkiT9G4wFLL0w==}
-    dev: true
-
   /micromatch/3.1.10:
     resolution: {integrity: sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==}
     engines: {node: '>=0.10.0'}
@@ -4193,11 +3884,6 @@ packages:
     hasBin: true
     dev: true
 
-  /mimic-fn/1.2.0:
-    resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
-    engines: {node: '>=4'}
-    dev: true
-
   /mimic-fn/2.1.0:
     resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
     engines: {node: '>=6'}
@@ -4231,10 +3917,6 @@ packages:
       kind-of: 6.0.3
     dev: true
 
-  /minimist/1.2.5:
-    resolution: {integrity: sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==}
-    dev: true
-
   /minimist/1.2.6:
     resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==}
     dev: true
@@ -4298,10 +3980,6 @@ packages:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
     dev: true
 
-  /mute-stream/0.0.7:
-    resolution: {integrity: sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=}
-    dev: true
-
   /nan/2.16.0:
     resolution: {integrity: sha512-UdAqHyFngu7TfQKsCBgAA6pWDkT8MAO7d0jyOecVhN5354xbLqdn8mV9Tat9gepAupm0bt2DbeaSC8vS52MuFA==}
     dev: true
@@ -4487,13 +4165,6 @@ packages:
       wrappy: 1.0.2
     dev: true
 
-  /onetime/2.0.1:
-    resolution: {integrity: sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=}
-    engines: {node: '>=4'}
-    dependencies:
-      mimic-fn: 1.2.0
-    dev: true
-
   /onetime/5.1.2:
     resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
     engines: {node: '>=6'}
@@ -4517,11 +4188,6 @@ packages:
     resolution: {integrity: sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=}
     dev: true
 
-  /os-tmpdir/1.0.2:
-    resolution: {integrity: sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /p-finally/1.0.0:
     resolution: {integrity: sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=}
     engines: {node: '>=4'}
@@ -4605,14 +4271,6 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
-  /parent-module/1.0.1:
-    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
-    engines: {node: '>=6'}
-    dependencies:
-      callsites: 3.1.0
-    dev: true
-    optional: true
-
   /parse-asn1/5.1.6:
     resolution: {integrity: sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==}
     dependencies:
@@ -4641,11 +4299,6 @@ packages:
       lines-and-columns: 1.2.4
     dev: true
 
-  /parse-passwd/1.0.0:
-    resolution: {integrity: sha1-bVuTSkVpk7I9N/QKOC1vFmao5cY=}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /parse5/6.0.1:
     resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
     dev: true
@@ -4716,12 +4369,6 @@ packages:
       pify: 3.0.0
     dev: true
 
-  /path-type/4.0.0:
-    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
-    engines: {node: '>=8'}
-    dev: true
-    optional: true
-
   /pathval/1.1.1:
     resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==}
     dev: true
@@ -5275,34 +4922,6 @@ packages:
     resolution: {integrity: sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=}
     dev: true
 
-  /resolve-dir/1.0.1:
-    resolution: {integrity: sha1-eaQGRMNivoLybv/nOcm7U4IEb0M=}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      expand-tilde: 2.0.2
-      global-modules: 1.0.0
-    dev: true
-
-  /resolve-from/4.0.0:
-    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
-    engines: {node: '>=4'}
-    dev: true
-    optional: true
-
-  /resolve-from/5.0.0:
-    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
-    engines: {node: '>=8'}
-    dev: true
-    optional: true
-
-  /resolve-global/1.0.0:
-    resolution: {integrity: sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==}
-    engines: {node: '>=8'}
-    dependencies:
-      global-dirs: 0.1.1
-    dev: true
-    optional: true
-
   /resolve-url/0.2.1:
     resolution: {integrity: sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=}
     deprecated: https://github.com/lydell/resolve-url#deprecated
@@ -5329,14 +4948,6 @@ packages:
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
-  /restore-cursor/2.0.0:
-    resolution: {integrity: sha1-n37ih/gv0ybU/RYpI9YhKe7g368=}
-    engines: {node: '>=4'}
-    dependencies:
-      onetime: 2.0.1
-      signal-exit: 3.0.7
-    dev: true
-
   /restore-cursor/3.1.0:
     resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==}
     engines: {node: '>=8'}
@@ -5399,24 +5010,12 @@ packages:
       fsevents: 2.3.2
     dev: true
 
-  /run-async/2.4.1:
-    resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==}
-    engines: {node: '>=0.12.0'}
-    dev: true
-
   /run-queue/1.0.3:
     resolution: {integrity: sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=}
     dependencies:
       aproba: 1.2.0
     dev: true
 
-  /rxjs/6.6.7:
-    resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==}
-    engines: {npm: '>=2.0.0'}
-    dependencies:
-      tslib: 1.14.1
-    dev: true
-
   /rxjs/7.5.5:
     resolution: {integrity: sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==}
     dependencies:
@@ -5822,14 +5421,6 @@ packages:
     resolution: {integrity: sha1-6Kr8CsGFW0Zmkp7X3RJ1311sgRs=}
     dev: true
 
-  /string-width/2.1.1:
-    resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==}
-    engines: {node: '>=4'}
-    dependencies:
-      is-fullwidth-code-point: 2.0.0
-      strip-ansi: 4.0.0
-    dev: true
-
   /string-width/4.2.3:
     resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
     engines: {node: '>=8'}
@@ -5860,20 +5451,6 @@ packages:
       safe-buffer: 5.2.1
     dev: true
 
-  /strip-ansi/4.0.0:
-    resolution: {integrity: sha1-qEeQIusaw2iocTibY1JixQXuNo8=}
-    engines: {node: '>=4'}
-    dependencies:
-      ansi-regex: 3.0.1
-    dev: true
-
-  /strip-ansi/5.2.0:
-    resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==}
-    engines: {node: '>=6'}
-    dependencies:
-      ansi-regex: 4.1.1
-    dev: true
-
   /strip-ansi/6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
@@ -5893,11 +5470,6 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
-  /strip-bom/4.0.0:
-    resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==}
-    engines: {node: '>=8'}
-    dev: true
-
   /strip-eof/1.0.0:
     resolution: {integrity: sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=}
     engines: {node: '>=0.10.0'}
@@ -5920,11 +5492,6 @@ packages:
       min-indent: 1.0.1
     dev: true
 
-  /strip-json-comments/3.0.1:
-    resolution: {integrity: sha512-VTyMAUfdm047mwKl+u79WIdrZxtFtn+nBxHeb844XBQ9uMNTuTHdx2hc5RiAJYqwTj3wc/xe5HLSdJSkJ+WfZw==}
-    engines: {node: '>=8'}
-    dev: true
-
   /strip-json-comments/3.1.1:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
@@ -5981,6 +5548,19 @@ packages:
       readable-stream: 3.6.0
     dev: true
 
+  /temp-dir/2.0.0:
+    resolution: {integrity: sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /tempfile/3.0.0:
+    resolution: {integrity: sha512-uNFCg478XovRi85iD42egu+eSFUmmka750Jy7L5tfHI5hQKKtbPnxaSaXAbBqCDYrw3wx4tXjKwci4/QmsZJxw==}
+    engines: {node: '>=8'}
+    dependencies:
+      temp-dir: 2.0.0
+      uuid: 3.4.0
+    dev: true
+
   /terser-webpack-plugin/1.4.5_webpack@4.46.0:
     resolution: {integrity: sha512-04Rfe496lN8EYruwi6oPQkG0vo8C+HT49X687FZnpPF0qMAIHONI6HEXYPKDOE8e5HjXTyKfqRd/agHtH0kOtw==}
     engines: {node: '>= 6.9.0'}
@@ -6064,13 +5644,6 @@ packages:
     engines: {node: '>=14.0.0'}
     dev: true
 
-  /tmp/0.0.33:
-    resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
-    engines: {node: '>=0.6.0'}
-    dependencies:
-      os-tmpdir: 1.0.2
-    dev: true
-
   /tmp/0.2.1:
     resolution: {integrity: sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==}
     engines: {node: '>=8.17.0'}
@@ -6187,10 +5760,6 @@ packages:
       yn: 3.1.1
     dev: true
 
-  /tslib/1.14.1:
-    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
-    dev: true
-
   /tslib/2.4.0:
     resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==}
     dev: true
@@ -6378,6 +5947,12 @@ packages:
     engines: {node: '>= 0.4.0'}
     dev: true
 
+  /uuid/3.4.0:
+    resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==}
+    deprecated: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
+    hasBin: true
+    dev: true
+
   /v8-compile-cache-lib/3.0.1:
     resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
     dev: true
diff --git a/scripts/release.js b/scripts/release.js
new file mode 100644
index 00000000000..685b80bb4e5
--- /dev/null
+++ b/scripts/release.js
@@ -0,0 +1,202 @@
+const args = require('minimist')(process.argv.slice(2))
+const fs = require('fs')
+const path = require('path')
+const chalk = require('chalk')
+const semver = require('semver')
+const currentVersion = require('../package.json').version
+const { prompt } = require('enquirer')
+const execa = require('execa')
+
+const preId =
+  args.preid ||
+  (semver.prerelease(currentVersion) && semver.prerelease(currentVersion)[0])
+const isDryRun = args.dry
+const skipTests = args.skipTests
+const skipBuild = args.skipBuild
+const packages = fs
+  .readdirSync(path.resolve(__dirname, '../packages'))
+  .filter(p => !p.endsWith('.ts') && !p.startsWith('.'))
+  .concat('vue')
+
+const versionIncrements = [
+  'patch',
+  'minor',
+  'major',
+  ...(preId ? ['prepatch', 'preminor', 'premajor', 'prerelease'] : [])
+]
+
+const inc = i => semver.inc(currentVersion, i, preId)
+const run = (bin, args, opts = {}) =>
+  execa(bin, args, { stdio: 'inherit', ...opts })
+const dryRun = (bin, args, opts = {}) =>
+  console.log(chalk.blue(`[dryrun] ${bin} ${args.join(' ')}`), opts)
+const runIfNotDry = isDryRun ? dryRun : run
+const step = msg => console.log(chalk.cyan(msg))
+
+async function main() {
+  let targetVersion = args._[0]
+
+  if (!targetVersion) {
+    // no explicit version, offer suggestions
+    const { release } = await prompt({
+      type: 'select',
+      name: 'release',
+      message: 'Select release type',
+      choices: versionIncrements.map(i => `${i} (${inc(i)})`).concat(['custom'])
+    })
+
+    if (release === 'custom') {
+      targetVersion = (
+        await prompt({
+          type: 'input',
+          name: 'version',
+          message: 'Input custom version',
+          initial: currentVersion
+        })
+      ).version
+    } else {
+      targetVersion = release.match(/\((.*)\)/)[1]
+    }
+  }
+
+  if (!semver.valid(targetVersion)) {
+    throw new Error(`invalid target version: ${targetVersion}`)
+  }
+
+  const { yes } = await prompt({
+    type: 'confirm',
+    name: 'yes',
+    message: `Releasing v${targetVersion}. Confirm?`
+  })
+
+  if (!yes) {
+    return
+  }
+
+  // run tests before release
+  step('\nRunning tests...')
+  if (!skipTests && !isDryRun) {
+    await run('pnpm', ['test'])
+  } else {
+    console.log(`(skipped)`)
+  }
+
+  // update all package versions and inter-dependencies
+  step('\nUpdating package versions...')
+  packages.forEach(p => updatePackage(getPkgRoot(p), targetVersion))
+
+  // build all packages with types
+  step('\nBuilding all packages...')
+  if (!skipBuild && !isDryRun) {
+    await run('pnpm', ['run', 'build'])
+    if (skipTests) {
+      await run('pnpm', ['run', 'build:types'])
+    }
+  } else {
+    console.log(`(skipped)`)
+  }
+
+  // generate changelog
+  step('\nGenerating changelog...')
+  await run(`pnpm`, ['run', 'changelog'])
+
+  // update pnpm-lock.yaml
+  step('\nUpdating lockfile...')
+  await run(`pnpm`, ['install', '--prefer-offline'])
+
+  const { stdout } = await run('git', ['diff'], { stdio: 'pipe' })
+  if (stdout) {
+    step('\nCommitting changes...')
+    await runIfNotDry('git', ['add', '-A'])
+    await runIfNotDry('git', ['commit', '-m', `release: v${targetVersion}`])
+  } else {
+    console.log('No changes to commit.')
+  }
+
+  // publish packages
+  step('\nPublishing packages...')
+  for (const pkg of packages) {
+    await publishPackage(pkg, targetVersion, runIfNotDry)
+  }
+
+  // push to GitHub
+  step('\nPushing to GitHub...')
+  await runIfNotDry('git', ['tag', `v${targetVersion}`])
+  await runIfNotDry('git', ['push', 'origin', `refs/tags/v${targetVersion}`])
+  await runIfNotDry('git', ['push'])
+
+  if (isDryRun) {
+    console.log(`\nDry run finished - run git diff to see package changes.`)
+  }
+  console.log()
+}
+
+function updatePackage(pkgRoot, version) {
+  const pkgPath = path.resolve(pkgRoot, 'package.json')
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+  pkg.version = version
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+}
+
+const getPkgRoot = pkg =>
+  pkg === 'vue'
+    ? path.resolve(__dirname, '../')
+    : path.resolve(__dirname, '../packages/' + pkg)
+
+async function publishPackage(pkgName, version, runIfNotDry) {
+  const pkgRoot = getPkgRoot(pkgName)
+  const pkgPath = path.resolve(pkgRoot, 'package.json')
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+  const publishedName = pkg.name
+  if (pkg.private) {
+    return
+  }
+
+  let releaseTag = null
+  if (args.tag) {
+    releaseTag = args.tag
+  } else if (version.includes('alpha')) {
+    releaseTag = 'alpha'
+  } else if (version.includes('beta')) {
+    releaseTag = 'beta'
+  } else if (version.includes('rc')) {
+    releaseTag = 'rc'
+  }
+
+  // avoid overwriting tags for v3
+  if (pkgName === 'vue' || pkgName === 'compiler-sfc') {
+    if (releaseTag) {
+      releaseTag = `v2-${releaseTag}`
+    } else {
+      releaseTag = 'v2'
+    }
+  }
+
+  step(`Publishing ${publishedName}...`)
+  try {
+    await runIfNotDry(
+      'pnpm',
+      [
+        'publish',
+        ...(releaseTag ? ['--tag', releaseTag] : []),
+        '--access',
+        'public'
+      ],
+      {
+        cwd: pkgRoot,
+        stdio: 'pipe'
+      }
+    )
+    console.log(
+      chalk.green(`Successfully published ${publishedName}@${version}`)
+    )
+  } catch (e) {
+    if (e.stderr.match(/previously published/)) {
+      console.log(chalk.red(`Skipping already published: ${publishedName}`))
+    } else {
+      throw e
+    }
+  }
+}
+
+main()
diff --git a/scripts/release.sh b/scripts/release.sh
deleted file mode 100644
index ad829313bb8..00000000000
--- a/scripts/release.sh
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/bin/bash
-set -e
-
-if [[ -z $1 ]]; then
-  echo "Enter new version: "
-  read -r VERSION
-else
-  VERSION=$1
-fi
-
-read -p "Releasing $VERSION - are you sure? (y/n) " -n 1 -r
-echo
-if [[ $REPLY =~ ^[Yy]$ ]]; then
-  echo "Releasing $VERSION ..."
-
-  if [[ -z $SKIP_TESTS ]]; then
-    npm run lint
-    npm run flow
-    npm run test:cover
-    npm run test:e2e -- --env phantomjs
-    npm run test:ssr
-  fi
-
-  # Sauce Labs tests has a decent chance of failing
-  # so we usually manually run them before running the release script.
-
-  # if [[ -z $SKIP_SAUCE ]]; then
-  #   export SAUCE_BUILD_ID=$VERSION:`date +"%s"`
-  #   npm run test:sauce
-  # fi
-
-  # build
-  VERSION=$VERSION npm run build
-
-  # update packages
-  # using subshells to avoid having to cd back
-  ( ( cd packages/vue-template-compiler
-  npm version "$VERSION"
-  if [[ -z $RELEASE_TAG ]]; then
-    npm publish
-  else
-    npm publish --tag "$RELEASE_TAG"
-  fi
-  )
-
-  cd packages/vue-server-renderer
-  npm version "$VERSION"
-  if [[ -z $RELEASE_TAG ]]; then
-    npm publish
-  else
-    npm publish --tag "$RELEASE_TAG"
-  fi
-  )
-
-  # commit
-  git add -A
-  git add -f \
-    dist/*.js \
-    packages/vue-server-renderer/basic.js \
-    packages/vue-server-renderer/build.dev.js \
-    packages/vue-server-renderer/build.prod.js \
-    packages/vue-server-renderer/server-plugin.js \
-    packages/vue-server-renderer/client-plugin.js \
-    packages/vue-template-compiler/build.js \
-    packages/vue-template-compiler/browser.js
-  git commit -m "build: build $VERSION"
-  # generate release note
-  npm run release:note
-  # tag version
-  npm version "$VERSION" --message "build: release $VERSION"
-
-  # publish
-  git push origin refs/tags/v"$VERSION"
-  git push
-  if [[ -z $RELEASE_TAG ]]; then
-    npm publish
-  else
-    npm publish --tag "$RELEASE_TAG"
-  fi
-fi

From ff4f1fdf37fd255ef441b6b615f4e90cba4d1c4b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 17:38:27 +0800
Subject: [PATCH 106/317] refactor: move more ssr logic into server-renderer
 package

---
 packages/server-renderer/package.json         |  2 +-
 .../server-renderer/src}/compiler.ts          |  2 +-
 .../server-renderer/src}/directives/index.ts  |  0
 .../server-renderer/src}/directives/model.ts  |  0
 .../server-renderer/src}/directives/show.ts   |  0
 .../server-renderer/src/index-basic.ts        |  6 +-
 .../server-renderer/src/index.ts              |  6 +-
 .../server-renderer/src}/modules/attrs.ts     |  2 +-
 .../server-renderer/src}/modules/class.ts     |  0
 .../server-renderer/src}/modules/dom-props.ts |  0
 .../server-renderer/src}/modules/index.ts     |  0
 .../server-renderer/src}/modules/style.ts     |  0
 .../src/optimizing-compiler/codegen.ts        |  2 +-
 .../src/optimizing-compiler/modules.ts        |  2 +-
 .../optimizing-compiler/runtime-helpers.ts    | 12 ++-
 packages/server-renderer/src/render.ts        |  4 +-
 packages/server-renderer/src/util.ts          | 98 +++++++++++++++++++
 .../test/compile-with-webpack.ts              |  2 +-
 .../test/ssr-basic-renderer.spec.ts           |  2 +-
 .../server-renderer/test/ssr-stream.spec.ts   |  2 +-
 .../server-renderer/test/ssr-string.spec.ts   |  2 +-
 .../server-renderer/test/ssr-template.spec.ts |  2 +-
 packages/template-compiler/package.json       |  4 +
 scripts/config.js                             |  6 +-
 src/platforms/web/entry-compiler.ts           |  2 +-
 src/platforms/web/server/util.ts              | 97 ------------------
 26 files changed, 132 insertions(+), 123 deletions(-)
 rename {src/platforms/web/server => packages/server-renderer/src}/compiler.ts (80%)
 rename {src/platforms/web/server => packages/server-renderer/src}/directives/index.ts (100%)
 rename {src/platforms/web/server => packages/server-renderer/src}/directives/model.ts (100%)
 rename {src/platforms/web/server => packages/server-renderer/src}/directives/show.ts (100%)
 rename src/platforms/web/entry-server-basic-renderer.ts => packages/server-renderer/src/index-basic.ts (54%)
 rename src/platforms/web/entry-server-renderer.ts => packages/server-renderer/src/index.ts (81%)
 rename {src/platforms/web/server => packages/server-renderer/src}/modules/attrs.ts (96%)
 rename {src/platforms/web/server => packages/server-renderer/src}/modules/class.ts (100%)
 rename {src/platforms/web/server => packages/server-renderer/src}/modules/dom-props.ts (100%)
 rename {src/platforms/web/server => packages/server-renderer/src}/modules/index.ts (100%)
 rename {src/platforms/web/server => packages/server-renderer/src}/modules/style.ts (100%)
 delete mode 100644 src/platforms/web/server/util.ts

diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 6a5897cd204..65886f2f824 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -14,7 +14,7 @@
     "ssr"
   ],
   "files": [
-    "types",
+    "types/*.d.ts",
     "*.js",
     "*.d.ts"
   ],
diff --git a/src/platforms/web/server/compiler.ts b/packages/server-renderer/src/compiler.ts
similarity index 80%
rename from src/platforms/web/server/compiler.ts
rename to packages/server-renderer/src/compiler.ts
index 27831e8e36b..094ac929e90 100644
--- a/src/platforms/web/server/compiler.ts
+++ b/packages/server-renderer/src/compiler.ts
@@ -1,4 +1,4 @@
-import { baseOptions } from '../compiler/options'
+import { baseOptions } from 'web/compiler/options'
 import { createCompiler } from 'server/optimizing-compiler/index'
 
 const { compile, compileToFunctions } = createCompiler(baseOptions)
diff --git a/src/platforms/web/server/directives/index.ts b/packages/server-renderer/src/directives/index.ts
similarity index 100%
rename from src/platforms/web/server/directives/index.ts
rename to packages/server-renderer/src/directives/index.ts
diff --git a/src/platforms/web/server/directives/model.ts b/packages/server-renderer/src/directives/model.ts
similarity index 100%
rename from src/platforms/web/server/directives/model.ts
rename to packages/server-renderer/src/directives/model.ts
diff --git a/src/platforms/web/server/directives/show.ts b/packages/server-renderer/src/directives/show.ts
similarity index 100%
rename from src/platforms/web/server/directives/show.ts
rename to packages/server-renderer/src/directives/show.ts
diff --git a/src/platforms/web/entry-server-basic-renderer.ts b/packages/server-renderer/src/index-basic.ts
similarity index 54%
rename from src/platforms/web/entry-server-basic-renderer.ts
rename to packages/server-renderer/src/index-basic.ts
index 2f965eb66cc..ea8babbe0b9 100644
--- a/src/platforms/web/entry-server-basic-renderer.ts
+++ b/packages/server-renderer/src/index-basic.ts
@@ -1,6 +1,6 @@
-import modules from './server/modules/index'
-import directives from './server/directives/index'
-import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
+import modules from './modules/index'
+import directives from './directives/index'
+import { isUnaryTag, canBeLeftOpenTag } from 'web/compiler/util'
 import { createBasicRenderer } from 'server/create-basic-renderer'
 
 export default createBasicRenderer({
diff --git a/src/platforms/web/entry-server-renderer.ts b/packages/server-renderer/src/index.ts
similarity index 81%
rename from src/platforms/web/entry-server-renderer.ts
rename to packages/server-renderer/src/index.ts
index 10d09d3680b..604c69938d0 100644
--- a/src/platforms/web/entry-server-renderer.ts
+++ b/packages/server-renderer/src/index.ts
@@ -1,9 +1,9 @@
 process.env.VUE_ENV = 'server'
 
 import { extend } from 'shared/util'
-import modules from './server/modules/index'
-import baseDirectives from './server/directives/index'
-import { isUnaryTag, canBeLeftOpenTag } from './compiler/util'
+import modules from './modules/index'
+import baseDirectives from './directives/index'
+import { isUnaryTag, canBeLeftOpenTag } from 'web/compiler/util'
 
 import {
   createRenderer as _createRenderer,
diff --git a/src/platforms/web/server/modules/attrs.ts b/packages/server-renderer/src/modules/attrs.ts
similarity index 96%
rename from src/platforms/web/server/modules/attrs.ts
rename to packages/server-renderer/src/modules/attrs.ts
index c37b81f5f12..943e48526f7 100644
--- a/src/platforms/web/server/modules/attrs.ts
+++ b/packages/server-renderer/src/modules/attrs.ts
@@ -9,7 +9,7 @@ import {
   convertEnumeratedValue
 } from 'web/util/attrs'
 
-import { isSSRUnsafeAttr } from 'web/server/util'
+import { isSSRUnsafeAttr } from '../util'
 import type { VNodeWithData } from 'types/vnode'
 
 export default function renderAttrs(node: VNodeWithData): string {
diff --git a/src/platforms/web/server/modules/class.ts b/packages/server-renderer/src/modules/class.ts
similarity index 100%
rename from src/platforms/web/server/modules/class.ts
rename to packages/server-renderer/src/modules/class.ts
diff --git a/src/platforms/web/server/modules/dom-props.ts b/packages/server-renderer/src/modules/dom-props.ts
similarity index 100%
rename from src/platforms/web/server/modules/dom-props.ts
rename to packages/server-renderer/src/modules/dom-props.ts
diff --git a/src/platforms/web/server/modules/index.ts b/packages/server-renderer/src/modules/index.ts
similarity index 100%
rename from src/platforms/web/server/modules/index.ts
rename to packages/server-renderer/src/modules/index.ts
diff --git a/src/platforms/web/server/modules/style.ts b/packages/server-renderer/src/modules/style.ts
similarity index 100%
rename from src/platforms/web/server/modules/style.ts
rename to packages/server-renderer/src/modules/style.ts
diff --git a/packages/server-renderer/src/optimizing-compiler/codegen.ts b/packages/server-renderer/src/optimizing-compiler/codegen.ts
index 6f245473e20..36669e191d2 100644
--- a/packages/server-renderer/src/optimizing-compiler/codegen.ts
+++ b/packages/server-renderer/src/optimizing-compiler/codegen.ts
@@ -20,7 +20,7 @@ import {
   applyModelTransform
 } from './modules'
 
-import { escape } from 'web/server/util'
+import { escape } from '../util'
 import { optimizability } from './optimizer'
 import type { CodegenResult } from 'compiler/codegen/index'
 import { ASTElement, ASTNode, CompilerOptions } from 'types/compiler'
diff --git a/packages/server-renderer/src/optimizing-compiler/modules.ts b/packages/server-renderer/src/optimizing-compiler/modules.ts
index 98bc0092f21..3ece915ead4 100644
--- a/packages/server-renderer/src/optimizing-compiler/modules.ts
+++ b/packages/server-renderer/src/optimizing-compiler/modules.ts
@@ -4,7 +4,7 @@ import {
   EXPRESSION
 } from './codegen'
 
-import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
+import { propsToAttrMap, isRenderableAttr } from '../util'
 
 import { isBooleanAttr, isEnumeratedAttr } from 'web/util/attrs'
 
diff --git a/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts b/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
index 0cf57265a86..7809d4e0a31 100644
--- a/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
+++ b/packages/server-renderer/src/optimizing-compiler/runtime-helpers.ts
@@ -1,8 +1,13 @@
-import { escape, isSSRUnsafeAttr } from 'web/server/util'
+import {
+  escape,
+  isSSRUnsafeAttr,
+  propsToAttrMap,
+  isRenderableAttr
+} from '../util'
 import { isObject, extend } from 'shared/util'
-import { renderAttr } from 'web/server/modules/attrs'
+import { renderAttr } from '../modules/attrs'
 import { renderClass } from 'web/util/class'
-import { genStyle } from 'web/server/modules/style'
+import { genStyle } from '../modules/style'
 import { normalizeStyleBinding } from 'web/util/style'
 
 import {
@@ -10,7 +15,6 @@ import {
   simpleNormalizeChildren
 } from 'core/vdom/helpers/normalize-children'
 
-import { propsToAttrMap, isRenderableAttr } from 'web/server/util'
 import type { Component } from 'types/component'
 
 const ssrHelpers = {
diff --git a/packages/server-renderer/src/render.ts b/packages/server-renderer/src/render.ts
index 6e29437f412..907b795d797 100644
--- a/packages/server-renderer/src/render.ts
+++ b/packages/server-renderer/src/render.ts
@@ -1,9 +1,9 @@
-import { escape } from 'web/server/util'
+import { escape } from './util'
 import { SSR_ATTR } from 'shared/constants'
 import { RenderContext } from './render-context'
 import { resolveAsset } from 'core/util/options'
 import { generateComponentTrace } from 'core/util/debug'
-import { ssrCompileToFunctions } from 'web/server/compiler'
+import { ssrCompileToFunctions } from './compiler'
 import { installSSRHelpers } from './optimizing-compiler/runtime-helpers'
 
 import { isDef, isUndef, isTrue } from 'shared/util'
diff --git a/packages/server-renderer/src/util.ts b/packages/server-renderer/src/util.ts
index 5e607b24545..777abb659f6 100644
--- a/packages/server-renderer/src/util.ts
+++ b/packages/server-renderer/src/util.ts
@@ -1,3 +1,101 @@
+import { makeMap } from 'shared/util'
+
+const isAttr = makeMap(
+  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
+    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
+    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
+    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
+    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
+    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
+    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
+    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
+    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
+    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
+    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
+    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
+    'target,title,usemap,value,width,wrap'
+)
+
+const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/ // eslint-disable-line no-control-regex
+export const isSSRUnsafeAttr = (name: string): boolean => {
+  return unsafeAttrCharRE.test(name)
+}
+
+/* istanbul ignore next */
+const isRenderableAttr = (name: string): boolean => {
+  return (
+    isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
+  )
+}
+export { isRenderableAttr }
+
+export const propsToAttrMap = {
+  acceptCharset: 'accept-charset',
+  className: 'class',
+  htmlFor: 'for',
+  httpEquiv: 'http-equiv'
+}
+
+const ESC = {
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  '&': '&amp;'
+}
+
+export function escape(s: string) {
+  return s.replace(/[<>"&]/g, escapeChar)
+}
+
+function escapeChar(a) {
+  return ESC[a] || a
+}
+
+export const noUnitNumericStyleProps = {
+  'animation-iteration-count': true,
+  'border-image-outset': true,
+  'border-image-slice': true,
+  'border-image-width': true,
+  'box-flex': true,
+  'box-flex-group': true,
+  'box-ordinal-group': true,
+  'column-count': true,
+  columns: true,
+  flex: true,
+  'flex-grow': true,
+  'flex-positive': true,
+  'flex-shrink': true,
+  'flex-negative': true,
+  'flex-order': true,
+  'grid-row': true,
+  'grid-row-end': true,
+  'grid-row-span': true,
+  'grid-row-start': true,
+  'grid-column': true,
+  'grid-column-end': true,
+  'grid-column-span': true,
+  'grid-column-start': true,
+  'font-weight': true,
+  'line-clamp': true,
+  'line-height': true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  'tab-size': true,
+  widows: true,
+  'z-index': true,
+  zoom: true,
+  // SVG
+  'fill-opacity': true,
+  'flood-opacity': true,
+  'stop-opacity': true,
+  'stroke-dasharray': true,
+  'stroke-dashoffset': true,
+  'stroke-miterlimit': true,
+  'stroke-opacity': true,
+  'stroke-width': true
+}
+
 export const isJS = (file: string): boolean => /\.js(\?[^.]+)?$/.test(file)
 
 export const isCSS = (file: string): boolean => /\.css(\?[^.]+)?$/.test(file)
diff --git a/packages/server-renderer/test/compile-with-webpack.ts b/packages/server-renderer/test/compile-with-webpack.ts
index d4b57ef0e28..37467595619 100644
--- a/packages/server-renderer/test/compile-with-webpack.ts
+++ b/packages/server-renderer/test/compile-with-webpack.ts
@@ -2,7 +2,7 @@ import path from 'path'
 import webpack from 'webpack'
 import MemoryFS from 'memory-fs'
 import { RenderOptions } from 'server/create-renderer'
-import { createBundleRenderer } from 'web/entry-server-renderer'
+import { createBundleRenderer } from 'server/index'
 import VueSSRServerPlugin from 'server/webpack-plugin/server'
 
 export function compileWithWebpack(
diff --git a/packages/server-renderer/test/ssr-basic-renderer.spec.ts b/packages/server-renderer/test/ssr-basic-renderer.spec.ts
index f47ef73d4cf..0e144df175f 100644
--- a/packages/server-renderer/test/ssr-basic-renderer.spec.ts
+++ b/packages/server-renderer/test/ssr-basic-renderer.spec.ts
@@ -1,7 +1,7 @@
 // @vitest-environment node
 
 import Vue from 'vue'
-import renderToString from 'web/entry-server-basic-renderer'
+import renderToString from 'server/index-basic'
 
 describe('SSR: basicRenderer', () => {
   it('should work', done => {
diff --git a/packages/server-renderer/test/ssr-stream.spec.ts b/packages/server-renderer/test/ssr-stream.spec.ts
index 6d4ed10c1ee..8636463f65c 100644
--- a/packages/server-renderer/test/ssr-stream.spec.ts
+++ b/packages/server-renderer/test/ssr-stream.spec.ts
@@ -1,7 +1,7 @@
 // @vitest-environment node
 
 import Vue from 'vue'
-import { createRenderer } from 'web/entry-server-renderer'
+import { createRenderer } from 'server/index'
 const { renderToStream } = createRenderer()
 
 describe('SSR: renderToStream', () => {
diff --git a/packages/server-renderer/test/ssr-string.spec.ts b/packages/server-renderer/test/ssr-string.spec.ts
index 9f07a379927..35810c8ed58 100644
--- a/packages/server-renderer/test/ssr-string.spec.ts
+++ b/packages/server-renderer/test/ssr-string.spec.ts
@@ -2,7 +2,7 @@
 
 import Vue from 'vue'
 import VM from 'vm'
-import { createRenderer } from 'web/entry-server-renderer'
+import { createRenderer } from 'server/index'
 const { renderToString } = createRenderer()
 
 describe('SSR: renderToString', () => {
diff --git a/packages/server-renderer/test/ssr-template.spec.ts b/packages/server-renderer/test/ssr-template.spec.ts
index 943112b4f17..b173c439e99 100644
--- a/packages/server-renderer/test/ssr-template.spec.ts
+++ b/packages/server-renderer/test/ssr-template.spec.ts
@@ -5,7 +5,7 @@ import {
   compileWithWebpack,
   createWebpackBundleRenderer
 } from './compile-with-webpack'
-import { createRenderer } from 'web/entry-server-renderer'
+import { createRenderer } from 'server/index'
 import VueSSRClientPlugin from 'server/webpack-plugin/client'
 import { RenderOptions } from 'server/create-renderer'
 
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 4c5068bbab9..a23cd6f158e 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -7,6 +7,10 @@
   "jsdelivr": "browser.js",
   "browser": "browser.js",
   "types": "types/index.d.ts",
+  "files": [
+    "types/*.d.ts",
+    "*.js"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vuejs/vue.git"
diff --git a/scripts/config.js b/scripts/config.js
index 56fdcd83520..2360c8026cf 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -147,7 +147,7 @@ const builds = {
   },
   // Web server renderer (CommonJS).
   'server-renderer-dev': {
-    entry: resolve('web/entry-server-renderer.ts'),
+    entry: resolve('packages/server-renderer/src/index.ts'),
     dest: resolve('packages/server-renderer/build.dev.js'),
     format: 'cjs',
     env: 'development',
@@ -159,7 +159,7 @@ const builds = {
     ]
   },
   'server-renderer-prod': {
-    entry: resolve('web/entry-server-renderer.ts'),
+    entry: resolve('server/index.ts'),
     dest: resolve('packages/server-renderer/build.prod.js'),
     format: 'cjs',
     env: 'production',
@@ -171,7 +171,7 @@ const builds = {
     ]
   },
   'server-renderer-basic': {
-    entry: resolve('web/entry-server-basic-renderer.ts'),
+    entry: resolve('server/index-basic.ts'),
     dest: resolve('packages/server-renderer/basic.js'),
     format: 'umd',
     env: 'development',
diff --git a/src/platforms/web/entry-compiler.ts b/src/platforms/web/entry-compiler.ts
index f1f6aec4052..679ccfaeb39 100644
--- a/src/platforms/web/entry-compiler.ts
+++ b/src/platforms/web/entry-compiler.ts
@@ -1,4 +1,4 @@
 export { parseComponent } from 'sfc/parser'
 export { compile, compileToFunctions } from './compiler/index'
-export { ssrCompile, ssrCompileToFunctions } from './server/compiler'
+export { ssrCompile, ssrCompileToFunctions } from 'server/compiler'
 export { generateCodeFrame } from 'compiler/codeframe'
diff --git a/src/platforms/web/server/util.ts b/src/platforms/web/server/util.ts
deleted file mode 100644
index 9fa4e7aa7ed..00000000000
--- a/src/platforms/web/server/util.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-import { makeMap } from 'shared/util'
-
-const isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap'
-)
-
-const unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/ // eslint-disable-line no-control-regex
-export const isSSRUnsafeAttr = (name: string): boolean => {
-  return unsafeAttrCharRE.test(name)
-}
-
-/* istanbul ignore next */
-const isRenderableAttr = (name: string): boolean => {
-  return (
-    isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
-  )
-}
-export { isRenderableAttr }
-
-export const propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
-}
-
-const ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
-}
-
-export function escape(s: string) {
-  return s.replace(/[<>"&]/g, escapeChar)
-}
-
-function escapeChar(a) {
-  return ESC[a] || a
-}
-
-export const noUnitNumericStyleProps = {
-  'animation-iteration-count': true,
-  'border-image-outset': true,
-  'border-image-slice': true,
-  'border-image-width': true,
-  'box-flex': true,
-  'box-flex-group': true,
-  'box-ordinal-group': true,
-  'column-count': true,
-  columns: true,
-  flex: true,
-  'flex-grow': true,
-  'flex-positive': true,
-  'flex-shrink': true,
-  'flex-negative': true,
-  'flex-order': true,
-  'grid-row': true,
-  'grid-row-end': true,
-  'grid-row-span': true,
-  'grid-row-start': true,
-  'grid-column': true,
-  'grid-column-end': true,
-  'grid-column-span': true,
-  'grid-column-start': true,
-  'font-weight': true,
-  'line-clamp': true,
-  'line-height': true,
-  opacity: true,
-  order: true,
-  orphans: true,
-  'tab-size': true,
-  widows: true,
-  'z-index': true,
-  zoom: true,
-  // SVG
-  'fill-opacity': true,
-  'flood-opacity': true,
-  'stop-opacity': true,
-  'stroke-dasharray': true,
-  'stroke-dashoffset': true,
-  'stroke-miterlimit': true,
-  'stroke-opacity': true,
-  'stroke-width': true
-}

From 1b49c75e2aa909b8f1dabd1c52cd84f532268ee5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 17:45:10 +0800
Subject: [PATCH 107/317] chore: fix unit test

---
 test/unit/modules/server-compiler/compiler-options.spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/modules/server-compiler/compiler-options.spec.ts b/test/unit/modules/server-compiler/compiler-options.spec.ts
index e8a5fc2e822..d6bc36393ff 100644
--- a/test/unit/modules/server-compiler/compiler-options.spec.ts
+++ b/test/unit/modules/server-compiler/compiler-options.spec.ts
@@ -1,4 +1,4 @@
-import { ssrCompile } from 'web/server/compiler'
+import { ssrCompile } from 'server/compiler'
 
 describe('ssrCompile options', () => {
   it('comments', () => {

From 1b7584664da1e1e504ca30fd2630bb8f8ab2347a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 17:56:20 +0800
Subject: [PATCH 108/317] workflow: fix release check + remove dist file from
 git index

---
 .github/workflows/release-tag.yml     |   23 +
 .gitignore                            |    4 +-
 packages/template-compiler/browser.js | 9337 -------------------------
 packages/template-compiler/build.js   | 5148 --------------
 scripts/verify-commit-msg.js          |    9 +-
 5 files changed, 27 insertions(+), 14494 deletions(-)
 create mode 100644 .github/workflows/release-tag.yml
 delete mode 100644 packages/template-compiler/browser.js
 delete mode 100644 packages/template-compiler/build.js

diff --git a/.github/workflows/release-tag.yml b/.github/workflows/release-tag.yml
new file mode 100644
index 00000000000..b698513080d
--- /dev/null
+++ b/.github/workflows/release-tag.yml
@@ -0,0 +1,23 @@
+on:
+  push:
+    tags:
+      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+name: Create Release
+
+jobs:
+  build:
+    name: Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@master
+      - name: Create Release for Tag
+        id: release_tag
+        uses: yyx990803/release-tag@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          body: |
+            Please refer to [CHANGELOG.md](https://github.com/vuejs/vue/blob/main/CHANGELOG.md) for details.
diff --git a/.gitignore b/.gitignore
index d86932f233a..18c343efc53 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,8 +9,8 @@ packages/server-renderer/build.dev.js
 packages/server-renderer/build.prod.js
 packages/server-renderer/server-plugin.js
 packages/server-renderer/client-plugin.js
-packages/compiler-sfc/build.js
-packages/compiler-sfc/browser.js
+packages/template-compiler/build.js
+packages/template-compiler/browser.js
 .vscode
 dist
 temp
diff --git a/packages/template-compiler/browser.js b/packages/template-compiler/browser.js
deleted file mode 100644
index c80108f22d8..00000000000
--- a/packages/template-compiler/browser.js
+++ /dev/null
@@ -1,9337 +0,0 @@
-;(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined'
-    ? factory(exports)
-    : typeof define === 'function' && define.amd
-    ? define(['exports'], factory)
-    : ((global =
-        typeof globalThis !== 'undefined' ? globalThis : global || self),
-      factory((global.VueTemplateCompiler = {})))
-})(this, function (exports) {
-  'use strict'
-
-  var commonjsGlobal =
-    typeof globalThis !== 'undefined'
-      ? globalThis
-      : typeof window !== 'undefined'
-      ? window
-      : typeof global !== 'undefined'
-      ? global
-      : typeof self !== 'undefined'
-      ? self
-      : {}
-
-  var splitRE$1 = /\r?\n/g
-  var emptyRE = /^\s*$/
-  var needFixRE = /^(\r?\n)*[\t\s]/
-
-  var deIndent = function deindent(str) {
-    if (!needFixRE.test(str)) {
-      return str
-    }
-    var lines = str.split(splitRE$1)
-    var min = Infinity
-    var type, cur, c
-    for (var i = 0; i < lines.length; i++) {
-      var line = lines[i]
-      if (!emptyRE.test(line)) {
-        if (!type) {
-          c = line.charAt(0)
-          if (c === ' ' || c === '\t') {
-            type = c
-            cur = count(line, type)
-            if (cur < min) {
-              min = cur
-            }
-          } else {
-            return str
-          }
-        } else {
-          cur = count(line, type)
-          if (cur < min) {
-            min = cur
-          }
-        }
-      }
-    }
-    return lines
-      .map(function (line) {
-        return line.slice(min)
-      })
-      .join('\n')
-  }
-
-  function count(line, type) {
-    var i = 0
-    while (line.charAt(i) === type) {
-      i++
-    }
-    return i
-  }
-
-  var emptyObject = Object.freeze({})
-  // These helpers produce better VM code in JS engines due to their
-  // explicitness and function inlining.
-  function isUndef(v) {
-    return v === undefined || v === null
-  }
-  /**
-   * Check if value is primitive.
-   */
-  function isPrimitive(value) {
-    return (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      // $flow-disable-line
-      typeof value === 'symbol' ||
-      typeof value === 'boolean'
-    )
-  }
-  /**
-   * Quick object check - this is primarily used to tell
-   * objects from primitive values when we know the value
-   * is a JSON-compliant type.
-   */
-  function isObject(obj) {
-    return obj !== null && typeof obj === 'object'
-  }
-  /**
-   * Get the raw type string of a value, e.g., [object Object].
-   */
-  var _toString = Object.prototype.toString
-  function toRawType(value) {
-    return _toString.call(value).slice(8, -1)
-  }
-  /**
-   * Strict object type check. Only returns true
-   * for plain JavaScript objects.
-   */
-  function isPlainObject(obj) {
-    return _toString.call(obj) === '[object Object]'
-  }
-  /**
-   * Check if val is a valid array index.
-   */
-  function isValidArrayIndex(val) {
-    var n = parseFloat(String(val))
-    return n >= 0 && Math.floor(n) === n && isFinite(val)
-  }
-  /**
-   * Make a map and return a function for checking if a key
-   * is in that map.
-   */
-  function makeMap(str, expectsLowerCase) {
-    var map = Object.create(null)
-    var list = str.split(',')
-    for (var i = 0; i < list.length; i++) {
-      map[list[i]] = true
-    }
-    return expectsLowerCase
-      ? function (val) {
-          return map[val.toLowerCase()]
-        }
-      : function (val) {
-          return map[val]
-        }
-  }
-  /**
-   * Check if a tag is a built-in tag.
-   */
-  var isBuiltInTag = makeMap('slot,component', true)
-  /**
-   * Check if an attribute is a reserved attribute.
-   */
-  makeMap('key,ref,slot,slot-scope,is')
-  /**
-   * Remove an item from an array.
-   */
-  function remove(arr, item) {
-    if (arr.length) {
-      var index = arr.indexOf(item)
-      if (index > -1) {
-        return arr.splice(index, 1)
-      }
-    }
-  }
-  /**
-   * Check whether an object has the property.
-   */
-  var hasOwnProperty = Object.prototype.hasOwnProperty
-  function hasOwn(obj, key) {
-    return hasOwnProperty.call(obj, key)
-  }
-  /**
-   * Create a cached version of a pure function.
-   */
-  function cached(fn) {
-    var cache = Object.create(null)
-    return function cachedFn(str) {
-      var hit = cache[str]
-      return hit || (cache[str] = fn(str))
-    }
-  }
-  /**
-   * Camelize a hyphen-delimited string.
-   */
-  var camelizeRE = /-(\w)/g
-  var camelize = cached(function (str) {
-    return str.replace(camelizeRE, function (_, c) {
-      return c ? c.toUpperCase() : ''
-    })
-  })
-  /**
-   * Hyphenate a camelCase string.
-   */
-  var hyphenateRE = /\B([A-Z])/g
-  var hyphenate = cached(function (str) {
-    return str.replace(hyphenateRE, '-$1').toLowerCase()
-  })
-  /**
-   * Mix properties into target object.
-   */
-  function extend(to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key]
-    }
-    return to
-  }
-  /* eslint-disable no-unused-vars */
-  /**
-   * Perform no operation.
-   * Stubbing args to make Flow happy without leaving useless transpiled code
-   * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
-   */
-  function noop(a, b, c) {}
-  /**
-   * Always return false.
-   */
-  var no = function (a, b, c) {
-    return false
-  }
-  /* eslint-enable no-unused-vars */
-  /**
-   * Return the same value.
-   */
-  var identity = function (_) {
-    return _
-  }
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys$1(modules) {
-    return modules
-      .reduce(function (keys, m) {
-        return keys.concat(m.staticKeys || [])
-      }, [])
-      .join(',')
-  }
-
-  var isUnaryTag = makeMap(
-    'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-      'link,meta,param,source,track,wbr'
-  )
-  // Elements that you can, intentionally, leave open
-  // (and which close themselves)
-  var canBeLeftOpenTag = makeMap(
-    'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-  )
-  // HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-  // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-  var isNonPhrasingTag = makeMap(
-    'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-      'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-      'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-      'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-      'title,tr,track'
-  )
-
-  /**
-   * unicode letters used for parsing html tags, component names and property paths.
-   * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
-   * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
-   */
-  var unicodeRegExp =
-    /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
-  /**
-   * Define a property.
-   */
-  function def(obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    })
-  }
-
-  /**
-   * Not type-checking this file because it's mostly vendor code.
-   */
-  // Regular Expressions for parsing tags and attributes
-  var attribute =
-    /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-  var dynamicArgAttribute =
-    /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-  var ncname = '[a-zA-Z_][\\-\\.0-9_a-zA-Z'.concat(unicodeRegExp.source, ']*')
-  var qnameCapture = '((?:'.concat(ncname, '\\:)?').concat(ncname, ')')
-  var startTagOpen = new RegExp('^<'.concat(qnameCapture))
-  var startTagClose = /^\s*(\/?)>/
-  var endTag = new RegExp('^<\\/'.concat(qnameCapture, '[^>]*>'))
-  var doctype = /^<!DOCTYPE [^>]+>/i
-  // #7298: escape - to avoid being passed as HTML comment when inlined in page
-  var comment = /^<!\--/
-  var conditionalComment = /^<!\[/
-  // Special Elements (can contain anything)
-  var isPlainTextElement = makeMap('script,style,textarea', true)
-  var reCache = {}
-  var decodingMap = {
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&amp;': '&',
-    '&#10;': '\n',
-    '&#9;': '\t',
-    '&#39;': "'"
-  }
-  var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
-  var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
-  // #5992
-  var isIgnoreNewlineTag = makeMap('pre,textarea', true)
-  var shouldIgnoreFirstNewline = function (tag, html) {
-    return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
-  }
-  function decodeAttr(value, shouldDecodeNewlines) {
-    var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
-    return value.replace(re, function (match) {
-      return decodingMap[match]
-    })
-  }
-  function parseHTML(html, options) {
-    var stack = []
-    var expectHTML = options.expectHTML
-    var isUnaryTag = options.isUnaryTag || no
-    var canBeLeftOpenTag = options.canBeLeftOpenTag || no
-    var index = 0
-    var last, lastTag
-    var _loop_1 = function () {
-      last = html
-      // Make sure we're not in a plaintext content element like script/style
-      if (!lastTag || !isPlainTextElement(lastTag)) {
-        var textEnd = html.indexOf('<')
-        if (textEnd === 0) {
-          // Comment:
-          if (comment.test(html)) {
-            var commentEnd = html.indexOf('-->')
-            if (commentEnd >= 0) {
-              if (options.shouldKeepComment) {
-                options.comment(
-                  html.substring(4, commentEnd),
-                  index,
-                  index + commentEnd + 3
-                )
-              }
-              advance(commentEnd + 3)
-              return 'continue'
-            }
-          }
-          // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (conditionalComment.test(html)) {
-            var conditionalEnd = html.indexOf(']>')
-            if (conditionalEnd >= 0) {
-              advance(conditionalEnd + 2)
-              return 'continue'
-            }
-          }
-          // Doctype:
-          var doctypeMatch = html.match(doctype)
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length)
-            return 'continue'
-          }
-          // End tag:
-          var endTagMatch = html.match(endTag)
-          if (endTagMatch) {
-            var curIndex = index
-            advance(endTagMatch[0].length)
-            parseEndTag(endTagMatch[1], curIndex, index)
-            return 'continue'
-          }
-          // Start tag:
-          var startTagMatch = parseStartTag()
-          if (startTagMatch) {
-            handleStartTag(startTagMatch)
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1)
-            }
-            return 'continue'
-          }
-        }
-        var text = void 0,
-          rest = void 0,
-          next = void 0
-        if (textEnd >= 0) {
-          rest = html.slice(textEnd)
-          while (
-            !endTag.test(rest) &&
-            !startTagOpen.test(rest) &&
-            !comment.test(rest) &&
-            !conditionalComment.test(rest)
-          ) {
-            // < in plain text, be forgiving and treat it as text
-            next = rest.indexOf('<', 1)
-            if (next < 0) break
-            textEnd += next
-            rest = html.slice(textEnd)
-          }
-          text = html.substring(0, textEnd)
-        }
-        if (textEnd < 0) {
-          text = html
-        }
-        if (text) {
-          advance(text.length)
-        }
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index)
-        }
-      } else {
-        var endTagLength_1 = 0
-        var stackedTag_1 = lastTag.toLowerCase()
-        var reStackedTag =
-          reCache[stackedTag_1] ||
-          (reCache[stackedTag_1] = new RegExp(
-            '([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)',
-            'i'
-          ))
-        var rest = html.replace(reStackedTag, function (all, text, endTag) {
-          endTagLength_1 = endTag.length
-          if (
-            !isPlainTextElement(stackedTag_1) &&
-            stackedTag_1 !== 'noscript'
-          ) {
-            text = text
-              .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')
-          }
-          if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
-            text = text.slice(1)
-          }
-          if (options.chars) {
-            options.chars(text)
-          }
-          return ''
-        })
-        index += html.length - rest.length
-        html = rest
-        parseEndTag(stackedTag_1, index - endTagLength_1, index)
-      }
-      if (html === last) {
-        options.chars && options.chars(html)
-        if (!stack.length && options.warn) {
-          options.warn(
-            'Mal-formatted tag at end of template: "'.concat(html, '"'),
-            {
-              start: index + html.length
-            }
-          )
-        }
-        return 'break'
-      }
-    }
-    while (html) {
-      var state_1 = _loop_1()
-      if (state_1 === 'break') break
-    }
-    // Clean up any remaining tags
-    parseEndTag()
-    function advance(n) {
-      index += n
-      html = html.substring(n)
-    }
-    function parseStartTag() {
-      var start = html.match(startTagOpen)
-      if (start) {
-        var match = {
-          tagName: start[1],
-          attrs: [],
-          start: index
-        }
-        advance(start[0].length)
-        var end = void 0,
-          attr = void 0
-        while (
-          !(end = html.match(startTagClose)) &&
-          (attr = html.match(dynamicArgAttribute) || html.match(attribute))
-        ) {
-          attr.start = index
-          advance(attr[0].length)
-          attr.end = index
-          match.attrs.push(attr)
-        }
-        if (end) {
-          match.unarySlash = end[1]
-          advance(end[0].length)
-          match.end = index
-          return match
-        }
-      }
-    }
-    function handleStartTag(match) {
-      var tagName = match.tagName
-      var unarySlash = match.unarySlash
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag)
-        }
-        if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-          parseEndTag(tagName)
-        }
-      }
-      var unary = isUnaryTag(tagName) || !!unarySlash
-      var l = match.attrs.length
-      var attrs = new Array(l)
-      for (var i = 0; i < l; i++) {
-        var args = match.attrs[i]
-        var value = args[3] || args[4] || args[5] || ''
-        var shouldDecodeNewlines =
-          tagName === 'a' && args[1] === 'href'
-            ? options.shouldDecodeNewlinesForHref
-            : options.shouldDecodeNewlines
-        attrs[i] = {
-          name: args[1],
-          value: decodeAttr(value, shouldDecodeNewlines)
-        }
-        if (options.outputSourceRange) {
-          attrs[i].start = args.start + args[0].match(/^\s*/).length
-          attrs[i].end = args.end
-        }
-      }
-      if (!unary) {
-        stack.push({
-          tag: tagName,
-          lowerCasedTag: tagName.toLowerCase(),
-          attrs: attrs,
-          start: match.start,
-          end: match.end
-        })
-        lastTag = tagName
-      }
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end)
-      }
-    }
-    function parseEndTag(tagName, start, end) {
-      var pos, lowerCasedTagName
-      if (start == null) start = index
-      if (end == null) end = index
-      // Find the closest opened tag of the same type
-      if (tagName) {
-        lowerCasedTagName = tagName.toLowerCase()
-        for (pos = stack.length - 1; pos >= 0; pos--) {
-          if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-            break
-          }
-        }
-      } else {
-        // If no tag name is provided, clean shop
-        pos = 0
-      }
-      if (pos >= 0) {
-        // Close all the open elements, up the stack
-        for (var i = stack.length - 1; i >= pos; i--) {
-          if ((i > pos || !tagName) && options.warn) {
-            options.warn(
-              'tag <'.concat(stack[i].tag, '> has no matching end tag.'),
-              {
-                start: stack[i].start,
-                end: stack[i].end
-              }
-            )
-          }
-          if (options.end) {
-            options.end(stack[i].tag, start, end)
-          }
-        }
-        // Remove the open elements from the stack
-        stack.length = pos
-        lastTag = pos && stack[pos - 1].tag
-      } else if (lowerCasedTagName === 'br') {
-        if (options.start) {
-          options.start(tagName, [], true, start, end)
-        }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end)
-        }
-        if (options.end) {
-          options.end(tagName, start, end)
-        }
-      }
-    }
-  }
-
-  var splitRE = /\r?\n/g
-  var replaceRE = /./g
-  var isSpecialTag = makeMap('script,style,template', true)
-  /**
-   * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
-   */
-  function parseComponent(content, options) {
-    if (options === void 0) {
-      options = {}
-    }
-    var sfc = {
-      template: null,
-      script: null,
-      styles: [],
-      customBlocks: [],
-      errors: []
-    }
-    var depth = 0
-    var currentBlock = null
-    var warn = function (msg) {
-      sfc.errors.push(msg)
-    }
-    if (options.outputSourceRange) {
-      warn = function (msg, range) {
-        var data = { msg: msg }
-        if (range.start != null) {
-          data.start = range.start
-        }
-        if (range.end != null) {
-          data.end = range.end
-        }
-        sfc.errors.push(data)
-      }
-    }
-    function start(tag, attrs, unary, start, end) {
-      if (depth === 0) {
-        currentBlock = {
-          type: tag,
-          content: '',
-          start: end,
-          attrs: attrs.reduce(function (cumulated, _a) {
-            var name = _a.name,
-              value = _a.value
-            cumulated[name] = value || true
-            return cumulated
-          }, {})
-        }
-        if (isSpecialTag(tag)) {
-          checkAttrs(currentBlock, attrs)
-          if (tag === 'style') {
-            sfc.styles.push(currentBlock)
-          } else {
-            sfc[tag] = currentBlock
-          }
-        } else {
-          // custom blocks
-          sfc.customBlocks.push(currentBlock)
-        }
-      }
-      if (!unary) {
-        depth++
-      }
-    }
-    function checkAttrs(block, attrs) {
-      for (var i = 0; i < attrs.length; i++) {
-        var attr = attrs[i]
-        if (attr.name === 'lang') {
-          block.lang = attr.value
-        }
-        if (attr.name === 'scoped') {
-          block.scoped = true
-        }
-        if (attr.name === 'module') {
-          block.module = attr.value || true
-        }
-        if (attr.name === 'src') {
-          block.src = attr.value
-        }
-      }
-    }
-    function end(tag, start) {
-      if (depth === 1 && currentBlock) {
-        currentBlock.end = start
-        var text = content.slice(currentBlock.start, currentBlock.end)
-        if (options.deindent !== false) {
-          text = deIndent(text)
-        }
-        // pad content so that linters and pre-processors can output correct
-        // line numbers in errors and warnings
-        if (currentBlock.type !== 'template' && options.pad) {
-          text = padContent(currentBlock, options.pad) + text
-        }
-        currentBlock.content = text
-        currentBlock = null
-      }
-      depth--
-    }
-    function padContent(block, pad) {
-      if (pad === 'space') {
-        return content.slice(0, block.start).replace(replaceRE, ' ')
-      } else {
-        var offset = content.slice(0, block.start).split(splitRE).length
-        var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
-        return Array(offset).join(padChar)
-      }
-    }
-    parseHTML(content, {
-      warn: warn,
-      start: start,
-      end: end,
-      outputSourceRange: options.outputSourceRange
-    })
-    return sfc
-  }
-
-  // can we use __proto__?
-  var hasProto = '__proto__' in {}
-  // Browser environment sniffing
-  var inBrowser = typeof window !== 'undefined'
-  var UA = inBrowser && window.navigator.userAgent.toLowerCase()
-  var isIE = UA && /msie|trident/.test(UA)
-  UA && UA.indexOf('msie 9.0') > 0
-  var isEdge = UA && UA.indexOf('edge/') > 0
-  UA && UA.indexOf('android') > 0
-  UA && /iphone|ipad|ipod|ios/.test(UA)
-  UA && /chrome\/\d+/.test(UA) && !isEdge
-  UA && /phantomjs/.test(UA)
-  UA && UA.match(/firefox\/(\d+)/)
-  // Firefox has a "watch" function on Object.prototype...
-  // @ts-expect-error firebox support
-  var nativeWatch = {}.watch
-  var supportsPassive = false
-  if (inBrowser) {
-    try {
-      var opts = {}
-      Object.defineProperty(opts, 'passive', {
-        get: function () {
-          /* istanbul ignore next */
-          supportsPassive = true
-        }
-      }) // https://github.com/facebook/flow/issues/285
-      window.addEventListener('test-passive', null, opts)
-    } catch (e) {}
-  }
-  // this needs to be lazy-evaled because vue may be required before
-  // vue-server-renderer can set VUE_ENV
-  var _isServer
-  var isServerRendering = function () {
-    if (_isServer === undefined) {
-      /* istanbul ignore if */
-      if (!inBrowser && typeof global !== 'undefined') {
-        // detect presence of vue-server-renderer and avoid
-        // Webpack shimming the process
-        _isServer =
-          global['process'] && global['process'].env.VUE_ENV === 'server'
-      } else {
-        _isServer = false
-      }
-    }
-    return _isServer
-  }
-  /* istanbul ignore next */
-  function isNative(Ctor) {
-    return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-  }
-  var hasSymbol =
-    typeof Symbol !== 'undefined' &&
-    isNative(Symbol) &&
-    typeof Reflect !== 'undefined' &&
-    isNative(Reflect.ownKeys)
-  /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set));
-  else {
-    // a non-standard Set polyfill that only works with primitive keys.
-    /** @class */ ;(function () {
-      function Set() {
-        this.set = Object.create(null)
-      }
-      Set.prototype.has = function (key) {
-        return this.set[key] === true
-      }
-      Set.prototype.add = function (key) {
-        this.set[key] = true
-      }
-      Set.prototype.clear = function () {
-        this.set = Object.create(null)
-      }
-      return Set
-    })()
-  }
-
-  var ASSET_TYPES = ['component', 'directive', 'filter']
-  var LIFECYCLE_HOOKS = [
-    'beforeCreate',
-    'created',
-    'beforeMount',
-    'mounted',
-    'beforeUpdate',
-    'updated',
-    'beforeDestroy',
-    'destroyed',
-    'activated',
-    'deactivated',
-    'errorCaptured',
-    'serverPrefetch'
-  ]
-
-  var config = {
-    /**
-     * Option merge strategies (used in core/util/options)
-     */
-    // $flow-disable-line
-    optionMergeStrategies: Object.create(null),
-    /**
-     * Whether to suppress warnings.
-     */
-    silent: false,
-    /**
-     * Show production mode tip message on boot?
-     */
-    productionTip: 'development' !== 'production',
-    /**
-     * Whether to enable devtools
-     */
-    devtools: 'development' !== 'production',
-    /**
-     * Whether to record perf
-     */
-    performance: false,
-    /**
-     * Error handler for watcher errors
-     */
-    errorHandler: null,
-    /**
-     * Warn handler for watcher warns
-     */
-    warnHandler: null,
-    /**
-     * Ignore certain custom elements
-     */
-    ignoredElements: [],
-    /**
-     * Custom user key aliases for v-on
-     */
-    // $flow-disable-line
-    keyCodes: Object.create(null),
-    /**
-     * Check if a tag is reserved so that it cannot be registered as a
-     * component. This is platform-dependent and may be overwritten.
-     */
-    isReservedTag: no,
-    /**
-     * Check if an attribute is reserved so that it cannot be used as a component
-     * prop. This is platform-dependent and may be overwritten.
-     */
-    isReservedAttr: no,
-    /**
-     * Check if a tag is an unknown element.
-     * Platform-dependent.
-     */
-    isUnknownElement: no,
-    /**
-     * Get the namespace of an element
-     */
-    getTagNamespace: noop,
-    /**
-     * Parse the real tag name for the specific platform.
-     */
-    parsePlatformTagName: identity,
-    /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
-     */
-    mustUseProp: no,
-    /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
-     */
-    async: true,
-    /**
-     * Exposed for legacy reasons
-     */
-    _lifecycleHooks: LIFECYCLE_HOOKS
-  }
-
-  var warn$2 = noop
-  var tip = noop
-  var generateComponentTrace // work around flow check
-  var formatComponentName
-  {
-    var hasConsole_1 = typeof console !== 'undefined'
-    var classifyRE_1 = /(?:^|[-_])(\w)/g
-    var classify_1 = function (str) {
-      return str
-        .replace(classifyRE_1, function (c) {
-          return c.toUpperCase()
-        })
-        .replace(/[-_]/g, '')
-    }
-    warn$2 = function (msg, vm) {
-      var trace = vm ? generateComponentTrace(vm) : ''
-      if (hasConsole_1 && !config.silent) {
-        console.error('[Vue warn]: '.concat(msg).concat(trace))
-      }
-    }
-    tip = function (msg, vm) {
-      if (hasConsole_1 && !config.silent) {
-        console.warn(
-          '[Vue tip]: '.concat(msg) + (vm ? generateComponentTrace(vm) : '')
-        )
-      }
-    }
-    formatComponentName = function (vm, includeFile) {
-      if (vm.$root === vm) {
-        return '<Root>'
-      }
-      var options =
-        typeof vm === 'function' && vm.cid != null
-          ? vm.options
-          : vm._isVue
-          ? vm.$options || vm.constructor.options
-          : vm
-      var name = options.name || options._componentTag
-      var file = options.__file
-      if (!name && file) {
-        var match = file.match(/([^/\\]+)\.vue$/)
-        name = match && match[1]
-      }
-      return (
-        (name ? '<'.concat(classify_1(name), '>') : '<Anonymous>') +
-        (file && includeFile !== false ? ' at '.concat(file) : '')
-      )
-    }
-    var repeat_1 = function (str, n) {
-      var res = ''
-      while (n) {
-        if (n % 2 === 1) res += str
-        if (n > 1) str += str
-        n >>= 1
-      }
-      return res
-    }
-    generateComponentTrace = function (vm) {
-      if (vm._isVue && vm.$parent) {
-        var tree = []
-        var currentRecursiveSequence = 0
-        while (vm) {
-          if (tree.length > 0) {
-            var last = tree[tree.length - 1]
-            if (last.constructor === vm.constructor) {
-              currentRecursiveSequence++
-              vm = vm.$parent
-              continue
-            } else if (currentRecursiveSequence > 0) {
-              tree[tree.length - 1] = [last, currentRecursiveSequence]
-              currentRecursiveSequence = 0
-            }
-          }
-          tree.push(vm)
-          vm = vm.$parent
-        }
-        return (
-          '\n\nfound in\n\n' +
-          tree
-            .map(function (vm, i) {
-              return ''
-                .concat(i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2))
-                .concat(
-                  Array.isArray(vm)
-                    ? ''
-                        .concat(formatComponentName(vm[0]), '... (')
-                        .concat(vm[1], ' recursive calls)')
-                    : formatComponentName(vm)
-                )
-            })
-            .join('\n')
-        )
-      } else {
-        return '\n\n(found in '.concat(formatComponentName(vm), ')')
-      }
-    }
-  }
-
-  var uid = 0
-  /**
-   * A dep is an observable that can have multiple
-   * directives subscribing to it.
-   */
-  var Dep = /** @class */ (function () {
-    function Dep() {
-      this.id = uid++
-      this.subs = []
-    }
-    Dep.prototype.addSub = function (sub) {
-      this.subs.push(sub)
-    }
-    Dep.prototype.removeSub = function (sub) {
-      remove(this.subs, sub)
-    }
-    Dep.prototype.depend = function () {
-      if (Dep.target) {
-        Dep.target.addDep(this)
-      }
-    }
-    Dep.prototype.notify = function () {
-      // stabilize the subscriber list first
-      var subs = this.subs.slice()
-      for (var i = 0, l = subs.length; i < l; i++) {
-        subs[i].update()
-      }
-    }
-    return Dep
-  })()
-  // The current target watcher being evaluated.
-  // This is globally unique because only one watcher
-  // can be evaluated at a time.
-  Dep.target = null
-
-  var VNode = /** @class */ (function () {
-    function VNode(
-      tag,
-      data,
-      children,
-      text,
-      elm,
-      context,
-      componentOptions,
-      asyncFactory
-    ) {
-      this.tag = tag
-      this.data = data
-      this.children = children
-      this.text = text
-      this.elm = elm
-      this.ns = undefined
-      this.context = context
-      this.fnContext = undefined
-      this.fnOptions = undefined
-      this.fnScopeId = undefined
-      this.key = data && data.key
-      this.componentOptions = componentOptions
-      this.componentInstance = undefined
-      this.parent = undefined
-      this.raw = false
-      this.isStatic = false
-      this.isRootInsert = true
-      this.isComment = false
-      this.isCloned = false
-      this.isOnce = false
-      this.asyncFactory = asyncFactory
-      this.asyncMeta = undefined
-      this.isAsyncPlaceholder = false
-    }
-    Object.defineProperty(VNode.prototype, 'child', {
-      // DEPRECATED: alias for componentInstance for backwards compat.
-      /* istanbul ignore next */
-      get: function () {
-        return this.componentInstance
-      },
-      enumerable: false,
-      configurable: true
-    })
-    return VNode
-  })()
-
-  /*
-   * not type checking this file because flow doesn't play well with
-   * dynamically accessing methods on Array prototype
-   */
-  var arrayProto = Array.prototype
-  var arrayMethods = Object.create(arrayProto)
-  var methodsToPatch = [
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-  ]
-  /**
-   * Intercept mutating methods and emit events
-   */
-  methodsToPatch.forEach(function (method) {
-    // cache original method
-    var original = arrayProto[method]
-    def(arrayMethods, method, function mutator() {
-      var args = []
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i]
-      }
-      var result = original.apply(this, args)
-      var ob = this.__ob__
-      var inserted
-      switch (method) {
-        case 'push':
-        case 'unshift':
-          inserted = args
-          break
-        case 'splice':
-          inserted = args.slice(2)
-          break
-      }
-      if (inserted) ob.observeArray(inserted)
-      // notify change
-      ob.dep.notify()
-      return result
-    })
-  })
-
-  var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
-  /**
-   * Observer class that is attached to each observed
-   * object. Once attached, the observer converts the target
-   * object's property keys into getter/setters that
-   * collect dependencies and dispatch updates.
-   */
-  var Observer = /** @class */ (function () {
-    function Observer(value) {
-      this.value = value
-      this.dep = new Dep()
-      this.vmCount = 0
-      def(value, '__ob__', this)
-      if (Array.isArray(value)) {
-        if (hasProto) {
-          protoAugment(value, arrayMethods)
-        } else {
-          copyAugment(value, arrayMethods, arrayKeys)
-        }
-        this.observeArray(value)
-      } else {
-        this.walk(value)
-      }
-    }
-    /**
-     * Walk through all properties and convert them into
-     * getter/setters. This method should only be called when
-     * value type is Object.
-     */
-    Observer.prototype.walk = function (obj) {
-      var keys = Object.keys(obj)
-      for (var i = 0; i < keys.length; i++) {
-        defineReactive(obj, keys[i])
-      }
-    }
-    /**
-     * Observe a list of Array items.
-     */
-    Observer.prototype.observeArray = function (items) {
-      for (var i = 0, l = items.length; i < l; i++) {
-        observe(items[i])
-      }
-    }
-    return Observer
-  })()
-  // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-    /* eslint-disable no-proto */
-    target.__proto__ = src
-    /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-    for (var i = 0, l = keys.length; i < l; i++) {
-      var key = keys[i]
-      def(target, key, src[key])
-    }
-  }
-  /**
-   * Attempt to create an observer instance for a value,
-   * returns the new observer if successfully observed,
-   * or the existing observer if the value already has one.
-   */
-  function observe(value, asRootData) {
-    if (!isObject(value) || value instanceof VNode) {
-      return
-    }
-    var ob
-    if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-      ob = value.__ob__
-    } else if (
-      !isServerRendering() &&
-      (Array.isArray(value) || isPlainObject(value)) &&
-      Object.isExtensible(value) &&
-      !value._isVue
-    ) {
-      ob = new Observer(value)
-    }
-    if (asRootData && ob) {
-      ob.vmCount++
-    }
-    return ob
-  }
-  /**
-   * Define a reactive property on an Object.
-   */
-  function defineReactive(obj, key, val, customSetter, shallow) {
-    var dep = new Dep()
-    var property = Object.getOwnPropertyDescriptor(obj, key)
-    if (property && property.configurable === false) {
-      return
-    }
-    // cater for pre-defined getter/setters
-    var getter = property && property.get
-    var setter = property && property.set
-    if ((!getter || setter) && arguments.length === 2) {
-      val = obj[key]
-    }
-    var childOb = !shallow && observe(val)
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get: function reactiveGetter() {
-        var value = getter ? getter.call(obj) : val
-        if (Dep.target) {
-          dep.depend()
-          if (childOb) {
-            childOb.dep.depend()
-            if (Array.isArray(value)) {
-              dependArray(value)
-            }
-          }
-        }
-        return value
-      },
-      set: function reactiveSetter(newVal) {
-        var value = getter ? getter.call(obj) : val
-        /* eslint-disable no-self-compare */
-        if (newVal === value || (newVal !== newVal && value !== value)) {
-          return
-        }
-        /* eslint-enable no-self-compare */
-        if (customSetter) {
-          customSetter()
-        }
-        // #7981: for accessor properties without setter
-        if (getter && !setter) return
-        if (setter) {
-          setter.call(obj, newVal)
-        } else {
-          val = newVal
-        }
-        childOb = !shallow && observe(newVal)
-        dep.notify()
-      }
-    })
-  }
-  /**
-   * Set a property on an object. Adds the new property and
-   * triggers change notification if the property doesn't
-   * already exist.
-   */
-  function set(target, key, val) {
-    if (isUndef(target) || isPrimitive(target)) {
-      warn$2(
-        'Cannot set reactive property on undefined, null, or primitive value: '.concat(
-          target
-        )
-      )
-    }
-    if (Array.isArray(target) && isValidArrayIndex(key)) {
-      target.length = Math.max(target.length, key)
-      target.splice(key, 1, val)
-      return val
-    }
-    if (key in target && !(key in Object.prototype)) {
-      target[key] = val
-      return val
-    }
-    var ob = target.__ob__
-    if (target._isVue || (ob && ob.vmCount)) {
-      warn$2(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-          'at runtime - declare it upfront in the data option.'
-      )
-      return val
-    }
-    if (!ob) {
-      target[key] = val
-      return val
-    }
-    defineReactive(ob.value, key, val)
-    ob.dep.notify()
-    return val
-  }
-  /**
-   * Collect dependencies on array elements when the array is touched, since
-   * we cannot intercept array element access like property getters.
-   */
-  function dependArray(value) {
-    for (var e = void 0, i = 0, l = value.length; i < l; i++) {
-      e = value[i]
-      e && e.__ob__ && e.__ob__.dep.depend()
-      if (Array.isArray(e)) {
-        dependArray(e)
-      }
-    }
-  }
-
-  /**
-   * Option overwriting strategies are functions that handle
-   * how to merge a parent option value and a child option
-   * value into the final value.
-   */
-  var strats = config.optionMergeStrategies
-  /**
-   * Options with restrictions
-   */
-  {
-    strats.el = strats.propsData = function (parent, child, vm, key) {
-      if (!vm) {
-        warn$2(
-          'option "'.concat(key, '" can only be used during instance ') +
-            'creation with the `new` keyword.'
-        )
-      }
-      return defaultStrat(parent, child)
-    }
-  }
-  /**
-   * Helper that recursively merges two data objects together.
-   */
-  function mergeData(to, from) {
-    if (!from) return to
-    var key, toVal, fromVal
-    var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from)
-    for (var i = 0; i < keys.length; i++) {
-      key = keys[i]
-      // in case the object is already observed...
-      if (key === '__ob__') continue
-      toVal = to[key]
-      fromVal = from[key]
-      if (!hasOwn(to, key)) {
-        set(to, key, fromVal)
-      } else if (
-        toVal !== fromVal &&
-        isPlainObject(toVal) &&
-        isPlainObject(fromVal)
-      ) {
-        mergeData(toVal, fromVal)
-      }
-    }
-    return to
-  }
-  /**
-   * Data
-   */
-  function mergeDataOrFn(parentVal, childVal, vm) {
-    if (!vm) {
-      // in a Vue.extend merge, both should be functions
-      if (!childVal) {
-        return parentVal
-      }
-      if (!parentVal) {
-        return childVal
-      }
-      // when parentVal & childVal are both present,
-      // we need to return a function that returns the
-      // merged result of both functions... no need to
-      // check if parentVal is a function here because
-      // it has to be a function to pass previous merges.
-      return function mergedDataFn() {
-        return mergeData(
-          typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-          typeof parentVal === 'function'
-            ? parentVal.call(this, this)
-            : parentVal
-        )
-      }
-    } else {
-      return function mergedInstanceDataFn() {
-        // instance merge
-        var instanceData =
-          typeof childVal === 'function' ? childVal.call(vm, vm) : childVal
-        var defaultData =
-          typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal
-        if (instanceData) {
-          return mergeData(instanceData, defaultData)
-        } else {
-          return defaultData
-        }
-      }
-    }
-  }
-  strats.data = function (parentVal, childVal, vm) {
-    if (!vm) {
-      if (childVal && typeof childVal !== 'function') {
-        warn$2(
-          'The "data" option should be a function ' +
-            'that returns a per-instance value in component ' +
-            'definitions.',
-          vm
-        )
-        return parentVal
-      }
-      return mergeDataOrFn(parentVal, childVal)
-    }
-    return mergeDataOrFn(parentVal, childVal, vm)
-  }
-  /**
-   * Hooks and props are merged as arrays.
-   */
-  function mergeHook(parentVal, childVal) {
-    var res = childVal
-      ? parentVal
-        ? parentVal.concat(childVal)
-        : Array.isArray(childVal)
-        ? childVal
-        : [childVal]
-      : parentVal
-    return res ? dedupeHooks(res) : res
-  }
-  function dedupeHooks(hooks) {
-    var res = []
-    for (var i = 0; i < hooks.length; i++) {
-      if (res.indexOf(hooks[i]) === -1) {
-        res.push(hooks[i])
-      }
-    }
-    return res
-  }
-  LIFECYCLE_HOOKS.forEach(function (hook) {
-    strats[hook] = mergeHook
-  })
-  /**
-   * Assets
-   *
-   * When a vm is present (instance creation), we need to do
-   * a three-way merge between constructor options, instance
-   * options and parent options.
-   */
-  function mergeAssets(parentVal, childVal, vm, key) {
-    var res = Object.create(parentVal || null)
-    if (childVal) {
-      assertObjectType(key, childVal, vm)
-      return extend(res, childVal)
-    } else {
-      return res
-    }
-  }
-  ASSET_TYPES.forEach(function (type) {
-    strats[type + 's'] = mergeAssets
-  })
-  /**
-   * Watchers.
-   *
-   * Watchers hashes should not overwrite one
-   * another, so we merge them as arrays.
-   */
-  strats.watch = function (parentVal, childVal, vm, key) {
-    // work around Firefox's Object.prototype.watch...
-    //@ts-expect-error work around
-    if (parentVal === nativeWatch) parentVal = undefined
-    //@ts-expect-error work around
-    if (childVal === nativeWatch) childVal = undefined
-    /* istanbul ignore if */
-    if (!childVal) return Object.create(parentVal || null)
-    {
-      assertObjectType(key, childVal, vm)
-    }
-    if (!parentVal) return childVal
-    var ret = {}
-    extend(ret, parentVal)
-    for (var key_1 in childVal) {
-      var parent_1 = ret[key_1]
-      var child = childVal[key_1]
-      if (parent_1 && !Array.isArray(parent_1)) {
-        parent_1 = [parent_1]
-      }
-      ret[key_1] = parent_1
-        ? parent_1.concat(child)
-        : Array.isArray(child)
-        ? child
-        : [child]
-    }
-    return ret
-  }
-  /**
-   * Other object hashes.
-   */
-  strats.props =
-    strats.methods =
-    strats.inject =
-    strats.computed =
-      function (parentVal, childVal, vm, key) {
-        if (childVal && 'development' !== 'production') {
-          assertObjectType(key, childVal, vm)
-        }
-        if (!parentVal) return childVal
-        var ret = Object.create(null)
-        extend(ret, parentVal)
-        if (childVal) extend(ret, childVal)
-        return ret
-      }
-  strats.provide = mergeDataOrFn
-  /**
-   * Default strategy.
-   */
-  var defaultStrat = function (parentVal, childVal) {
-    return childVal === undefined ? parentVal : childVal
-  }
-  function assertObjectType(name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn$2(
-        'Invalid value for option "'.concat(name, '": expected an Object, ') +
-          'but got '.concat(toRawType(value), '.'),
-        vm
-      )
-    }
-  }
-
-  /* globals MutationObserver */
-  var callbacks = []
-  function flushCallbacks() {
-    var copies = callbacks.slice(0)
-    callbacks.length = 0
-    for (var i = 0; i < copies.length; i++) {
-      copies[i]()
-    }
-  }
-  // The nextTick behavior leverages the microtask queue, which can be accessed
-  // via either native Promise.then or MutationObserver.
-  // MutationObserver has wider support, however it is seriously bugged in
-  // UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-  // completely stops working after triggering a few times... so, if native
-  // Promise is available, we will use it:
-  /* istanbul ignore next, $flow-disable-line */
-  if (typeof Promise !== 'undefined' && isNative(Promise)) {
-    Promise.resolve()
-  } else if (
-    !isIE &&
-    typeof MutationObserver !== 'undefined' &&
-    (isNative(MutationObserver) ||
-      // PhantomJS and iOS 7.x
-      MutationObserver.toString() === '[object MutationObserverConstructor]')
-  ) {
-    // Use MutationObserver where native Promise is not available,
-    // e.g. PhantomJS, iOS7, Android 4.4
-    // (#6466 MutationObserver is unreliable in IE11)
-    var counter_1 = 1
-    var observer = new MutationObserver(flushCallbacks)
-    var textNode_1 = document.createTextNode(String(counter_1))
-    observer.observe(textNode_1, {
-      characterData: true
-    })
-  } else if (typeof setImmediate !== 'undefined' && isNative(setImmediate));
-  else;
-
-  // these are reserved for web because they are directly compiled away
-  // during template compilation
-  makeMap('style,class')
-  // attributes that should be using props for binding
-  var acceptValue = makeMap('input,textarea,option,select,progress')
-  var mustUseProp = function (tag, type, attr) {
-    return (
-      (attr === 'value' && acceptValue(tag) && type !== 'button') ||
-      (attr === 'selected' && tag === 'option') ||
-      (attr === 'checked' && tag === 'input') ||
-      (attr === 'muted' && tag === 'video')
-    )
-  }
-  var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
-  makeMap('events,caret,typing,plaintext-only')
-  var isBooleanAttr = makeMap(
-    'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-      'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-      'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-      'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-      'required,reversed,scoped,seamless,selected,sortable,' +
-      'truespeed,typemustmatch,visible'
-  )
-
-  var isHTMLTag = makeMap(
-    'html,body,base,head,link,meta,style,title,' +
-      'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-      'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-      'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-      's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-      'embed,object,param,source,canvas,script,noscript,del,ins,' +
-      'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-      'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-      'output,progress,select,textarea,' +
-      'details,dialog,menu,menuitem,summary,' +
-      'content,element,shadow,template,blockquote,iframe,tfoot'
-  )
-  // this map is intentionally selective, only covering SVG elements that may
-  // contain child elements.
-  var isSVG = makeMap(
-    'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-      'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-      'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-    true
-  )
-  var isPreTag = function (tag) {
-    return tag === 'pre'
-  }
-  var isReservedTag = function (tag) {
-    return isHTMLTag(tag) || isSVG(tag)
-  }
-  function getTagNamespace(tag) {
-    if (isSVG(tag)) {
-      return 'svg'
-    }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
-    }
-  }
-  makeMap('text,number,password,search,email,tel,url')
-
-  var validDivisionCharRE = /[\w).+\-_$\]]/
-  function parseFilters(exp) {
-    var inSingle = false
-    var inDouble = false
-    var inTemplateString = false
-    var inRegex = false
-    var curly = 0
-    var square = 0
-    var paren = 0
-    var lastFilterIndex = 0
-    var c, prev, i, expression, filters
-    for (i = 0; i < exp.length; i++) {
-      prev = c
-      c = exp.charCodeAt(i)
-      if (inSingle) {
-        if (c === 0x27 && prev !== 0x5c) inSingle = false
-      } else if (inDouble) {
-        if (c === 0x22 && prev !== 0x5c) inDouble = false
-      } else if (inTemplateString) {
-        if (c === 0x60 && prev !== 0x5c) inTemplateString = false
-      } else if (inRegex) {
-        if (c === 0x2f && prev !== 0x5c) inRegex = false
-      } else if (
-        c === 0x7c && // pipe
-        exp.charCodeAt(i + 1) !== 0x7c &&
-        exp.charCodeAt(i - 1) !== 0x7c &&
-        !curly &&
-        !square &&
-        !paren
-      ) {
-        if (expression === undefined) {
-          // first filter, end of expression
-          lastFilterIndex = i + 1
-          expression = exp.slice(0, i).trim()
-        } else {
-          pushFilter()
-        }
-      } else {
-        switch (c) {
-          case 0x22:
-            inDouble = true
-            break // "
-          case 0x27:
-            inSingle = true
-            break // '
-          case 0x60:
-            inTemplateString = true
-            break // `
-          case 0x28:
-            paren++
-            break // (
-          case 0x29:
-            paren--
-            break // )
-          case 0x5b:
-            square++
-            break // [
-          case 0x5d:
-            square--
-            break // ]
-          case 0x7b:
-            curly++
-            break // {
-          case 0x7d:
-            curly--
-            break // }
-        }
-        if (c === 0x2f) {
-          // /
-          var j = i - 1
-          var p =
-            // find first non-whitespace prev char
-            void 0
-          // find first non-whitespace prev char
-          for (; j >= 0; j--) {
-            p = exp.charAt(j)
-            if (p !== ' ') break
-          }
-          if (!p || !validDivisionCharRE.test(p)) {
-            inRegex = true
-          }
-        }
-      }
-    }
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim()
-    } else if (lastFilterIndex !== 0) {
-      pushFilter()
-    }
-    function pushFilter() {
-      ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
-      lastFilterIndex = i + 1
-    }
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i])
-      }
-    }
-    return expression
-  }
-  function wrapFilter(exp, filter) {
-    var i = filter.indexOf('(')
-    if (i < 0) {
-      // _f: resolveFilter
-      return '_f("'.concat(filter, '")(').concat(exp, ')')
-    } else {
-      var name_1 = filter.slice(0, i)
-      var args = filter.slice(i + 1)
-      return '_f("'
-        .concat(name_1, '")(')
-        .concat(exp)
-        .concat(args !== ')' ? ',' + args : args)
-    }
-  }
-
-  var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
-  var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
-  var buildRegex = cached(function (delimiters) {
-    var open = delimiters[0].replace(regexEscapeRE, '\\$&')
-    var close = delimiters[1].replace(regexEscapeRE, '\\$&')
-    return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-  })
-  function parseText(text, delimiters) {
-    //@ts-expect-error
-    var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
-    if (!tagRE.test(text)) {
-      return
-    }
-    var tokens = []
-    var rawTokens = []
-    var lastIndex = (tagRE.lastIndex = 0)
-    var match, index, tokenValue
-    while ((match = tagRE.exec(text))) {
-      index = match.index
-      // push text token
-      if (index > lastIndex) {
-        rawTokens.push((tokenValue = text.slice(lastIndex, index)))
-        tokens.push(JSON.stringify(tokenValue))
-      }
-      // tag token
-      var exp = parseFilters(match[1].trim())
-      tokens.push('_s('.concat(exp, ')'))
-      rawTokens.push({ '@binding': exp })
-      lastIndex = index + match[0].length
-    }
-    if (lastIndex < text.length) {
-      rawTokens.push((tokenValue = text.slice(lastIndex)))
-      tokens.push(JSON.stringify(tokenValue))
-    }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
-    }
-  }
-
-  /* eslint-disable no-unused-vars */
-  function baseWarn(msg, range) {
-    console.error('[Vue compiler]: '.concat(msg))
-  }
-  /* eslint-enable no-unused-vars */
-  function pluckModuleFunction(modules, key) {
-    return modules
-      ? modules
-          .map(function (m) {
-            return m[key]
-          })
-          .filter(function (_) {
-            return _
-          })
-      : []
-  }
-  function addProp(el, name, value, range, dynamic) {
-    ;(el.props || (el.props = [])).push(
-      rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
-    )
-    el.plain = false
-  }
-  function addAttr(el, name, value, range, dynamic) {
-    var attrs = dynamic
-      ? el.dynamicAttrs || (el.dynamicAttrs = [])
-      : el.attrs || (el.attrs = [])
-    attrs.push(
-      rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
-    )
-    el.plain = false
-  }
-  // add a raw attr (use this in preTransforms)
-  function addRawAttr(el, name, value, range) {
-    el.attrsMap[name] = value
-    el.attrsList.push(rangeSetItem({ name: name, value: value }, range))
-  }
-  function addDirective(
-    el,
-    name,
-    rawName,
-    value,
-    arg,
-    isDynamicArg,
-    modifiers,
-    range
-  ) {
-    ;(el.directives || (el.directives = [])).push(
-      rangeSetItem(
-        {
-          name: name,
-          rawName: rawName,
-          value: value,
-          arg: arg,
-          isDynamicArg: isDynamicArg,
-          modifiers: modifiers
-        },
-        range
-      )
-    )
-    el.plain = false
-  }
-  function prependModifierMarker(symbol, name, dynamic) {
-    return dynamic
-      ? '_p('.concat(name, ',"').concat(symbol, '")')
-      : symbol + name // mark the event as captured
-  }
-  function addHandler(
-    el,
-    name,
-    value,
-    modifiers,
-    important,
-    warn,
-    range,
-    dynamic
-  ) {
-    modifiers = modifiers || emptyObject
-    // warn prevent and passive modifier
-    /* istanbul ignore if */
-    if (warn && modifiers.prevent && modifiers.passive) {
-      warn(
-        "passive and prevent can't be used together. " +
-          "Passive handler can't prevent default event.",
-        range
-      )
-    }
-    // normalize click.right and click.middle since they don't actually fire
-    // this is technically browser-specific, but at least for now browsers are
-    // the only target envs that have right/middle clicks.
-    if (modifiers.right) {
-      if (dynamic) {
-        name = '('.concat(name, ")==='click'?'contextmenu':(").concat(name, ')')
-      } else if (name === 'click') {
-        name = 'contextmenu'
-        delete modifiers.right
-      }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = '('.concat(name, ")==='click'?'mouseup':(").concat(name, ')')
-      } else if (name === 'click') {
-        name = 'mouseup'
-      }
-    }
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture
-      name = prependModifierMarker('!', name, dynamic)
-    }
-    if (modifiers.once) {
-      delete modifiers.once
-      name = prependModifierMarker('~', name, dynamic)
-    }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive
-      name = prependModifierMarker('&', name, dynamic)
-    }
-    var events
-    if (modifiers.native) {
-      delete modifiers.native
-      events = el.nativeEvents || (el.nativeEvents = {})
-    } else {
-      events = el.events || (el.events = {})
-    }
-    var newHandler = rangeSetItem(
-      { value: value.trim(), dynamic: dynamic },
-      range
-    )
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers
-    }
-    var handlers = events[name]
-    /* istanbul ignore if */
-    if (Array.isArray(handlers)) {
-      important ? handlers.unshift(newHandler) : handlers.push(newHandler)
-    } else if (handlers) {
-      events[name] = important ? [newHandler, handlers] : [handlers, newHandler]
-    } else {
-      events[name] = newHandler
-    }
-    el.plain = false
-  }
-  function getRawBindingAttr(el, name) {
-    return (
-      el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
-    )
-  }
-  function getBindingAttr(el, name, getStatic) {
-    var dynamicValue =
-      getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
-    if (dynamicValue != null) {
-      return parseFilters(dynamicValue)
-    } else if (getStatic !== false) {
-      var staticValue = getAndRemoveAttr(el, name)
-      if (staticValue != null) {
-        return JSON.stringify(staticValue)
-      }
-    }
-  }
-  // note: this only removes the attr from the Array (attrsList) so that it
-  // doesn't get processed by processAttrs.
-  // By default it does NOT remove it from the map (attrsMap) because the map is
-  // needed during codegen.
-  function getAndRemoveAttr(el, name, removeFromMap) {
-    var val
-    if ((val = el.attrsMap[name]) != null) {
-      var list = el.attrsList
-      for (var i = 0, l = list.length; i < l; i++) {
-        if (list[i].name === name) {
-          list.splice(i, 1)
-          break
-        }
-      }
-    }
-    if (removeFromMap) {
-      delete el.attrsMap[name]
-    }
-    return val
-  }
-  function getAndRemoveAttrByRegex(el, name) {
-    var list = el.attrsList
-    for (var i = 0, l = list.length; i < l; i++) {
-      var attr = list[i]
-      if (name.test(attr.name)) {
-        list.splice(i, 1)
-        return attr
-      }
-    }
-  }
-  function rangeSetItem(item, range) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start
-      }
-      if (range.end != null) {
-        item.end = range.end
-      }
-    }
-    return item
-  }
-
-  function transformNode$1(el, options) {
-    var warn = options.warn || baseWarn
-    var staticClass = getAndRemoveAttr(el, 'class')
-    if (staticClass) {
-      var res = parseText(staticClass, options.delimiters)
-      if (res) {
-        warn(
-          'class="'.concat(staticClass, '": ') +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div class="{{ val }}">, use <div :class="val">.',
-          el.rawAttrsMap['class']
-        )
-      }
-    }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim())
-    }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */)
-    if (classBinding) {
-      el.classBinding = classBinding
-    }
-  }
-  function genData$2(el) {
-    var data = ''
-    if (el.staticClass) {
-      data += 'staticClass:'.concat(el.staticClass, ',')
-    }
-    if (el.classBinding) {
-      data += 'class:'.concat(el.classBinding, ',')
-    }
-    return data
-  }
-  var klass = {
-    staticKeys: ['staticClass'],
-    transformNode: transformNode$1,
-    genData: genData$2
-  }
-
-  var parseStyleText = cached(function (cssText) {
-    var res = {}
-    var listDelimiter = /;(?![^(]*\))/g
-    var propertyDelimiter = /:(.+)/
-    cssText.split(listDelimiter).forEach(function (item) {
-      if (item) {
-        var tmp = item.split(propertyDelimiter)
-        tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim())
-      }
-    })
-    return res
-  })
-
-  function transformNode(el, options) {
-    var warn = options.warn || baseWarn
-    var staticStyle = getAndRemoveAttr(el, 'style')
-    if (staticStyle) {
-      /* istanbul ignore if */
-      {
-        var res = parseText(staticStyle, options.delimiters)
-        if (res) {
-          warn(
-            'style="'.concat(staticStyle, '": ') +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div style="{{ val }}">, use <div :style="val">.',
-            el.rawAttrsMap['style']
-          )
-        }
-      }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
-    }
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
-    if (styleBinding) {
-      el.styleBinding = styleBinding
-    }
-  }
-  function genData$1(el) {
-    var data = ''
-    if (el.staticStyle) {
-      data += 'staticStyle:'.concat(el.staticStyle, ',')
-    }
-    if (el.styleBinding) {
-      data += 'style:('.concat(el.styleBinding, '),')
-    }
-    return data
-  }
-  var style = {
-    staticKeys: ['staticStyle'],
-    transformNode: transformNode,
-    genData: genData$1
-  }
-
-  var he$1 = { exports: {} }
-
-  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
-
-  ;(function (module, exports) {
-    ;(function (root) {
-      // Detect free variables `exports`.
-      var freeExports = exports
-
-      // Detect free variable `module`.
-      var freeModule = module && module.exports == freeExports && module
-
-      // Detect free variable `global`, from Node.js or Browserified code,
-      // and use it as `root`.
-      var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal
-      if (
-        freeGlobal.global === freeGlobal ||
-        freeGlobal.window === freeGlobal
-      ) {
-        root = freeGlobal
-      }
-
-      /*--------------------------------------------------------------------------*/
-
-      // All astral symbols.
-      var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g
-      // All ASCII symbols (not just printable ASCII) except those listed in the
-      // first column of the overrides table.
-      // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
-      var regexAsciiWhitelist = /[\x01-\x7F]/g
-      // All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
-      // code points listed in the first column of the overrides table on
-      // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
-      var regexBmpWhitelist =
-        /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g
-
-      var regexEncodeNonAscii =
-        /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g
-      var encodeMap = {
-        '\xAD': 'shy',
-        '\u200C': 'zwnj',
-        '\u200D': 'zwj',
-        '\u200E': 'lrm',
-        '\u2063': 'ic',
-        '\u2062': 'it',
-        '\u2061': 'af',
-        '\u200F': 'rlm',
-        '\u200B': 'ZeroWidthSpace',
-        '\u2060': 'NoBreak',
-        '\u0311': 'DownBreve',
-        '\u20DB': 'tdot',
-        '\u20DC': 'DotDot',
-        '\t': 'Tab',
-        '\n': 'NewLine',
-        '\u2008': 'puncsp',
-        '\u205F': 'MediumSpace',
-        '\u2009': 'thinsp',
-        '\u200A': 'hairsp',
-        '\u2004': 'emsp13',
-        '\u2002': 'ensp',
-        '\u2005': 'emsp14',
-        '\u2003': 'emsp',
-        '\u2007': 'numsp',
-        '\xA0': 'nbsp',
-        '\u205F\u200A': 'ThickSpace',
-        '\u203E': 'oline',
-        _: 'lowbar',
-        '\u2010': 'dash',
-        '\u2013': 'ndash',
-        '\u2014': 'mdash',
-        '\u2015': 'horbar',
-        ',': 'comma',
-        ';': 'semi',
-        '\u204F': 'bsemi',
-        ':': 'colon',
-        '\u2A74': 'Colone',
-        '!': 'excl',
-        '\xA1': 'iexcl',
-        '?': 'quest',
-        '\xBF': 'iquest',
-        '.': 'period',
-        '\u2025': 'nldr',
-        '\u2026': 'mldr',
-        '\xB7': 'middot',
-        "'": 'apos',
-        '\u2018': 'lsquo',
-        '\u2019': 'rsquo',
-        '\u201A': 'sbquo',
-        '\u2039': 'lsaquo',
-        '\u203A': 'rsaquo',
-        '"': 'quot',
-        '\u201C': 'ldquo',
-        '\u201D': 'rdquo',
-        '\u201E': 'bdquo',
-        '\xAB': 'laquo',
-        '\xBB': 'raquo',
-        '(': 'lpar',
-        ')': 'rpar',
-        '[': 'lsqb',
-        ']': 'rsqb',
-        '{': 'lcub',
-        '}': 'rcub',
-        '\u2308': 'lceil',
-        '\u2309': 'rceil',
-        '\u230A': 'lfloor',
-        '\u230B': 'rfloor',
-        '\u2985': 'lopar',
-        '\u2986': 'ropar',
-        '\u298B': 'lbrke',
-        '\u298C': 'rbrke',
-        '\u298D': 'lbrkslu',
-        '\u298E': 'rbrksld',
-        '\u298F': 'lbrksld',
-        '\u2990': 'rbrkslu',
-        '\u2991': 'langd',
-        '\u2992': 'rangd',
-        '\u2993': 'lparlt',
-        '\u2994': 'rpargt',
-        '\u2995': 'gtlPar',
-        '\u2996': 'ltrPar',
-        '\u27E6': 'lobrk',
-        '\u27E7': 'robrk',
-        '\u27E8': 'lang',
-        '\u27E9': 'rang',
-        '\u27EA': 'Lang',
-        '\u27EB': 'Rang',
-        '\u27EC': 'loang',
-        '\u27ED': 'roang',
-        '\u2772': 'lbbrk',
-        '\u2773': 'rbbrk',
-        '\u2016': 'Vert',
-        '\xA7': 'sect',
-        '\xB6': 'para',
-        '@': 'commat',
-        '*': 'ast',
-        '/': 'sol',
-        undefined: null,
-        '&': 'amp',
-        '#': 'num',
-        '%': 'percnt',
-        '\u2030': 'permil',
-        '\u2031': 'pertenk',
-        '\u2020': 'dagger',
-        '\u2021': 'Dagger',
-        '\u2022': 'bull',
-        '\u2043': 'hybull',
-        '\u2032': 'prime',
-        '\u2033': 'Prime',
-        '\u2034': 'tprime',
-        '\u2057': 'qprime',
-        '\u2035': 'bprime',
-        '\u2041': 'caret',
-        '`': 'grave',
-        '\xB4': 'acute',
-        '\u02DC': 'tilde',
-        '^': 'Hat',
-        '\xAF': 'macr',
-        '\u02D8': 'breve',
-        '\u02D9': 'dot',
-        '\xA8': 'die',
-        '\u02DA': 'ring',
-        '\u02DD': 'dblac',
-        '\xB8': 'cedil',
-        '\u02DB': 'ogon',
-        '\u02C6': 'circ',
-        '\u02C7': 'caron',
-        '\xB0': 'deg',
-        '\xA9': 'copy',
-        '\xAE': 'reg',
-        '\u2117': 'copysr',
-        '\u2118': 'wp',
-        '\u211E': 'rx',
-        '\u2127': 'mho',
-        '\u2129': 'iiota',
-        '\u2190': 'larr',
-        '\u219A': 'nlarr',
-        '\u2192': 'rarr',
-        '\u219B': 'nrarr',
-        '\u2191': 'uarr',
-        '\u2193': 'darr',
-        '\u2194': 'harr',
-        '\u21AE': 'nharr',
-        '\u2195': 'varr',
-        '\u2196': 'nwarr',
-        '\u2197': 'nearr',
-        '\u2198': 'searr',
-        '\u2199': 'swarr',
-        '\u219D': 'rarrw',
-        '\u219D\u0338': 'nrarrw',
-        '\u219E': 'Larr',
-        '\u219F': 'Uarr',
-        '\u21A0': 'Rarr',
-        '\u21A1': 'Darr',
-        '\u21A2': 'larrtl',
-        '\u21A3': 'rarrtl',
-        '\u21A4': 'mapstoleft',
-        '\u21A5': 'mapstoup',
-        '\u21A6': 'map',
-        '\u21A7': 'mapstodown',
-        '\u21A9': 'larrhk',
-        '\u21AA': 'rarrhk',
-        '\u21AB': 'larrlp',
-        '\u21AC': 'rarrlp',
-        '\u21AD': 'harrw',
-        '\u21B0': 'lsh',
-        '\u21B1': 'rsh',
-        '\u21B2': 'ldsh',
-        '\u21B3': 'rdsh',
-        '\u21B5': 'crarr',
-        '\u21B6': 'cularr',
-        '\u21B7': 'curarr',
-        '\u21BA': 'olarr',
-        '\u21BB': 'orarr',
-        '\u21BC': 'lharu',
-        '\u21BD': 'lhard',
-        '\u21BE': 'uharr',
-        '\u21BF': 'uharl',
-        '\u21C0': 'rharu',
-        '\u21C1': 'rhard',
-        '\u21C2': 'dharr',
-        '\u21C3': 'dharl',
-        '\u21C4': 'rlarr',
-        '\u21C5': 'udarr',
-        '\u21C6': 'lrarr',
-        '\u21C7': 'llarr',
-        '\u21C8': 'uuarr',
-        '\u21C9': 'rrarr',
-        '\u21CA': 'ddarr',
-        '\u21CB': 'lrhar',
-        '\u21CC': 'rlhar',
-        '\u21D0': 'lArr',
-        '\u21CD': 'nlArr',
-        '\u21D1': 'uArr',
-        '\u21D2': 'rArr',
-        '\u21CF': 'nrArr',
-        '\u21D3': 'dArr',
-        '\u21D4': 'iff',
-        '\u21CE': 'nhArr',
-        '\u21D5': 'vArr',
-        '\u21D6': 'nwArr',
-        '\u21D7': 'neArr',
-        '\u21D8': 'seArr',
-        '\u21D9': 'swArr',
-        '\u21DA': 'lAarr',
-        '\u21DB': 'rAarr',
-        '\u21DD': 'zigrarr',
-        '\u21E4': 'larrb',
-        '\u21E5': 'rarrb',
-        '\u21F5': 'duarr',
-        '\u21FD': 'loarr',
-        '\u21FE': 'roarr',
-        '\u21FF': 'hoarr',
-        '\u2200': 'forall',
-        '\u2201': 'comp',
-        '\u2202': 'part',
-        '\u2202\u0338': 'npart',
-        '\u2203': 'exist',
-        '\u2204': 'nexist',
-        '\u2205': 'empty',
-        '\u2207': 'Del',
-        '\u2208': 'in',
-        '\u2209': 'notin',
-        '\u220B': 'ni',
-        '\u220C': 'notni',
-        '\u03F6': 'bepsi',
-        '\u220F': 'prod',
-        '\u2210': 'coprod',
-        '\u2211': 'sum',
-        '+': 'plus',
-        '\xB1': 'pm',
-        '\xF7': 'div',
-        '\xD7': 'times',
-        '<': 'lt',
-        '\u226E': 'nlt',
-        '<\u20D2': 'nvlt',
-        '=': 'equals',
-        '\u2260': 'ne',
-        '=\u20E5': 'bne',
-        '\u2A75': 'Equal',
-        '>': 'gt',
-        '\u226F': 'ngt',
-        '>\u20D2': 'nvgt',
-        '\xAC': 'not',
-        '|': 'vert',
-        '\xA6': 'brvbar',
-        '\u2212': 'minus',
-        '\u2213': 'mp',
-        '\u2214': 'plusdo',
-        '\u2044': 'frasl',
-        '\u2216': 'setmn',
-        '\u2217': 'lowast',
-        '\u2218': 'compfn',
-        '\u221A': 'Sqrt',
-        '\u221D': 'prop',
-        '\u221E': 'infin',
-        '\u221F': 'angrt',
-        '\u2220': 'ang',
-        '\u2220\u20D2': 'nang',
-        '\u2221': 'angmsd',
-        '\u2222': 'angsph',
-        '\u2223': 'mid',
-        '\u2224': 'nmid',
-        '\u2225': 'par',
-        '\u2226': 'npar',
-        '\u2227': 'and',
-        '\u2228': 'or',
-        '\u2229': 'cap',
-        '\u2229\uFE00': 'caps',
-        '\u222A': 'cup',
-        '\u222A\uFE00': 'cups',
-        '\u222B': 'int',
-        '\u222C': 'Int',
-        '\u222D': 'tint',
-        '\u2A0C': 'qint',
-        '\u222E': 'oint',
-        '\u222F': 'Conint',
-        '\u2230': 'Cconint',
-        '\u2231': 'cwint',
-        '\u2232': 'cwconint',
-        '\u2233': 'awconint',
-        '\u2234': 'there4',
-        '\u2235': 'becaus',
-        '\u2236': 'ratio',
-        '\u2237': 'Colon',
-        '\u2238': 'minusd',
-        '\u223A': 'mDDot',
-        '\u223B': 'homtht',
-        '\u223C': 'sim',
-        '\u2241': 'nsim',
-        '\u223C\u20D2': 'nvsim',
-        '\u223D': 'bsim',
-        '\u223D\u0331': 'race',
-        '\u223E': 'ac',
-        '\u223E\u0333': 'acE',
-        '\u223F': 'acd',
-        '\u2240': 'wr',
-        '\u2242': 'esim',
-        '\u2242\u0338': 'nesim',
-        '\u2243': 'sime',
-        '\u2244': 'nsime',
-        '\u2245': 'cong',
-        '\u2247': 'ncong',
-        '\u2246': 'simne',
-        '\u2248': 'ap',
-        '\u2249': 'nap',
-        '\u224A': 'ape',
-        '\u224B': 'apid',
-        '\u224B\u0338': 'napid',
-        '\u224C': 'bcong',
-        '\u224D': 'CupCap',
-        '\u226D': 'NotCupCap',
-        '\u224D\u20D2': 'nvap',
-        '\u224E': 'bump',
-        '\u224E\u0338': 'nbump',
-        '\u224F': 'bumpe',
-        '\u224F\u0338': 'nbumpe',
-        '\u2250': 'doteq',
-        '\u2250\u0338': 'nedot',
-        '\u2251': 'eDot',
-        '\u2252': 'efDot',
-        '\u2253': 'erDot',
-        '\u2254': 'colone',
-        '\u2255': 'ecolon',
-        '\u2256': 'ecir',
-        '\u2257': 'cire',
-        '\u2259': 'wedgeq',
-        '\u225A': 'veeeq',
-        '\u225C': 'trie',
-        '\u225F': 'equest',
-        '\u2261': 'equiv',
-        '\u2262': 'nequiv',
-        '\u2261\u20E5': 'bnequiv',
-        '\u2264': 'le',
-        '\u2270': 'nle',
-        '\u2264\u20D2': 'nvle',
-        '\u2265': 'ge',
-        '\u2271': 'nge',
-        '\u2265\u20D2': 'nvge',
-        '\u2266': 'lE',
-        '\u2266\u0338': 'nlE',
-        '\u2267': 'gE',
-        '\u2267\u0338': 'ngE',
-        '\u2268\uFE00': 'lvnE',
-        '\u2268': 'lnE',
-        '\u2269': 'gnE',
-        '\u2269\uFE00': 'gvnE',
-        '\u226A': 'll',
-        '\u226A\u0338': 'nLtv',
-        '\u226A\u20D2': 'nLt',
-        '\u226B': 'gg',
-        '\u226B\u0338': 'nGtv',
-        '\u226B\u20D2': 'nGt',
-        '\u226C': 'twixt',
-        '\u2272': 'lsim',
-        '\u2274': 'nlsim',
-        '\u2273': 'gsim',
-        '\u2275': 'ngsim',
-        '\u2276': 'lg',
-        '\u2278': 'ntlg',
-        '\u2277': 'gl',
-        '\u2279': 'ntgl',
-        '\u227A': 'pr',
-        '\u2280': 'npr',
-        '\u227B': 'sc',
-        '\u2281': 'nsc',
-        '\u227C': 'prcue',
-        '\u22E0': 'nprcue',
-        '\u227D': 'sccue',
-        '\u22E1': 'nsccue',
-        '\u227E': 'prsim',
-        '\u227F': 'scsim',
-        '\u227F\u0338': 'NotSucceedsTilde',
-        '\u2282': 'sub',
-        '\u2284': 'nsub',
-        '\u2282\u20D2': 'vnsub',
-        '\u2283': 'sup',
-        '\u2285': 'nsup',
-        '\u2283\u20D2': 'vnsup',
-        '\u2286': 'sube',
-        '\u2288': 'nsube',
-        '\u2287': 'supe',
-        '\u2289': 'nsupe',
-        '\u228A\uFE00': 'vsubne',
-        '\u228A': 'subne',
-        '\u228B\uFE00': 'vsupne',
-        '\u228B': 'supne',
-        '\u228D': 'cupdot',
-        '\u228E': 'uplus',
-        '\u228F': 'sqsub',
-        '\u228F\u0338': 'NotSquareSubset',
-        '\u2290': 'sqsup',
-        '\u2290\u0338': 'NotSquareSuperset',
-        '\u2291': 'sqsube',
-        '\u22E2': 'nsqsube',
-        '\u2292': 'sqsupe',
-        '\u22E3': 'nsqsupe',
-        '\u2293': 'sqcap',
-        '\u2293\uFE00': 'sqcaps',
-        '\u2294': 'sqcup',
-        '\u2294\uFE00': 'sqcups',
-        '\u2295': 'oplus',
-        '\u2296': 'ominus',
-        '\u2297': 'otimes',
-        '\u2298': 'osol',
-        '\u2299': 'odot',
-        '\u229A': 'ocir',
-        '\u229B': 'oast',
-        '\u229D': 'odash',
-        '\u229E': 'plusb',
-        '\u229F': 'minusb',
-        '\u22A0': 'timesb',
-        '\u22A1': 'sdotb',
-        '\u22A2': 'vdash',
-        '\u22AC': 'nvdash',
-        '\u22A3': 'dashv',
-        '\u22A4': 'top',
-        '\u22A5': 'bot',
-        '\u22A7': 'models',
-        '\u22A8': 'vDash',
-        '\u22AD': 'nvDash',
-        '\u22A9': 'Vdash',
-        '\u22AE': 'nVdash',
-        '\u22AA': 'Vvdash',
-        '\u22AB': 'VDash',
-        '\u22AF': 'nVDash',
-        '\u22B0': 'prurel',
-        '\u22B2': 'vltri',
-        '\u22EA': 'nltri',
-        '\u22B3': 'vrtri',
-        '\u22EB': 'nrtri',
-        '\u22B4': 'ltrie',
-        '\u22EC': 'nltrie',
-        '\u22B4\u20D2': 'nvltrie',
-        '\u22B5': 'rtrie',
-        '\u22ED': 'nrtrie',
-        '\u22B5\u20D2': 'nvrtrie',
-        '\u22B6': 'origof',
-        '\u22B7': 'imof',
-        '\u22B8': 'mumap',
-        '\u22B9': 'hercon',
-        '\u22BA': 'intcal',
-        '\u22BB': 'veebar',
-        '\u22BD': 'barvee',
-        '\u22BE': 'angrtvb',
-        '\u22BF': 'lrtri',
-        '\u22C0': 'Wedge',
-        '\u22C1': 'Vee',
-        '\u22C2': 'xcap',
-        '\u22C3': 'xcup',
-        '\u22C4': 'diam',
-        '\u22C5': 'sdot',
-        '\u22C6': 'Star',
-        '\u22C7': 'divonx',
-        '\u22C8': 'bowtie',
-        '\u22C9': 'ltimes',
-        '\u22CA': 'rtimes',
-        '\u22CB': 'lthree',
-        '\u22CC': 'rthree',
-        '\u22CD': 'bsime',
-        '\u22CE': 'cuvee',
-        '\u22CF': 'cuwed',
-        '\u22D0': 'Sub',
-        '\u22D1': 'Sup',
-        '\u22D2': 'Cap',
-        '\u22D3': 'Cup',
-        '\u22D4': 'fork',
-        '\u22D5': 'epar',
-        '\u22D6': 'ltdot',
-        '\u22D7': 'gtdot',
-        '\u22D8': 'Ll',
-        '\u22D8\u0338': 'nLl',
-        '\u22D9': 'Gg',
-        '\u22D9\u0338': 'nGg',
-        '\u22DA\uFE00': 'lesg',
-        '\u22DA': 'leg',
-        '\u22DB': 'gel',
-        '\u22DB\uFE00': 'gesl',
-        '\u22DE': 'cuepr',
-        '\u22DF': 'cuesc',
-        '\u22E6': 'lnsim',
-        '\u22E7': 'gnsim',
-        '\u22E8': 'prnsim',
-        '\u22E9': 'scnsim',
-        '\u22EE': 'vellip',
-        '\u22EF': 'ctdot',
-        '\u22F0': 'utdot',
-        '\u22F1': 'dtdot',
-        '\u22F2': 'disin',
-        '\u22F3': 'isinsv',
-        '\u22F4': 'isins',
-        '\u22F5': 'isindot',
-        '\u22F5\u0338': 'notindot',
-        '\u22F6': 'notinvc',
-        '\u22F7': 'notinvb',
-        '\u22F9': 'isinE',
-        '\u22F9\u0338': 'notinE',
-        '\u22FA': 'nisd',
-        '\u22FB': 'xnis',
-        '\u22FC': 'nis',
-        '\u22FD': 'notnivc',
-        '\u22FE': 'notnivb',
-        '\u2305': 'barwed',
-        '\u2306': 'Barwed',
-        '\u230C': 'drcrop',
-        '\u230D': 'dlcrop',
-        '\u230E': 'urcrop',
-        '\u230F': 'ulcrop',
-        '\u2310': 'bnot',
-        '\u2312': 'profline',
-        '\u2313': 'profsurf',
-        '\u2315': 'telrec',
-        '\u2316': 'target',
-        '\u231C': 'ulcorn',
-        '\u231D': 'urcorn',
-        '\u231E': 'dlcorn',
-        '\u231F': 'drcorn',
-        '\u2322': 'frown',
-        '\u2323': 'smile',
-        '\u232D': 'cylcty',
-        '\u232E': 'profalar',
-        '\u2336': 'topbot',
-        '\u233D': 'ovbar',
-        '\u233F': 'solbar',
-        '\u237C': 'angzarr',
-        '\u23B0': 'lmoust',
-        '\u23B1': 'rmoust',
-        '\u23B4': 'tbrk',
-        '\u23B5': 'bbrk',
-        '\u23B6': 'bbrktbrk',
-        '\u23DC': 'OverParenthesis',
-        '\u23DD': 'UnderParenthesis',
-        '\u23DE': 'OverBrace',
-        '\u23DF': 'UnderBrace',
-        '\u23E2': 'trpezium',
-        '\u23E7': 'elinters',
-        '\u2423': 'blank',
-        '\u2500': 'boxh',
-        '\u2502': 'boxv',
-        '\u250C': 'boxdr',
-        '\u2510': 'boxdl',
-        '\u2514': 'boxur',
-        '\u2518': 'boxul',
-        '\u251C': 'boxvr',
-        '\u2524': 'boxvl',
-        '\u252C': 'boxhd',
-        '\u2534': 'boxhu',
-        '\u253C': 'boxvh',
-        '\u2550': 'boxH',
-        '\u2551': 'boxV',
-        '\u2552': 'boxdR',
-        '\u2553': 'boxDr',
-        '\u2554': 'boxDR',
-        '\u2555': 'boxdL',
-        '\u2556': 'boxDl',
-        '\u2557': 'boxDL',
-        '\u2558': 'boxuR',
-        '\u2559': 'boxUr',
-        '\u255A': 'boxUR',
-        '\u255B': 'boxuL',
-        '\u255C': 'boxUl',
-        '\u255D': 'boxUL',
-        '\u255E': 'boxvR',
-        '\u255F': 'boxVr',
-        '\u2560': 'boxVR',
-        '\u2561': 'boxvL',
-        '\u2562': 'boxVl',
-        '\u2563': 'boxVL',
-        '\u2564': 'boxHd',
-        '\u2565': 'boxhD',
-        '\u2566': 'boxHD',
-        '\u2567': 'boxHu',
-        '\u2568': 'boxhU',
-        '\u2569': 'boxHU',
-        '\u256A': 'boxvH',
-        '\u256B': 'boxVh',
-        '\u256C': 'boxVH',
-        '\u2580': 'uhblk',
-        '\u2584': 'lhblk',
-        '\u2588': 'block',
-        '\u2591': 'blk14',
-        '\u2592': 'blk12',
-        '\u2593': 'blk34',
-        '\u25A1': 'squ',
-        '\u25AA': 'squf',
-        '\u25AB': 'EmptyVerySmallSquare',
-        '\u25AD': 'rect',
-        '\u25AE': 'marker',
-        '\u25B1': 'fltns',
-        '\u25B3': 'xutri',
-        '\u25B4': 'utrif',
-        '\u25B5': 'utri',
-        '\u25B8': 'rtrif',
-        '\u25B9': 'rtri',
-        '\u25BD': 'xdtri',
-        '\u25BE': 'dtrif',
-        '\u25BF': 'dtri',
-        '\u25C2': 'ltrif',
-        '\u25C3': 'ltri',
-        '\u25CA': 'loz',
-        '\u25CB': 'cir',
-        '\u25EC': 'tridot',
-        '\u25EF': 'xcirc',
-        '\u25F8': 'ultri',
-        '\u25F9': 'urtri',
-        '\u25FA': 'lltri',
-        '\u25FB': 'EmptySmallSquare',
-        '\u25FC': 'FilledSmallSquare',
-        '\u2605': 'starf',
-        '\u2606': 'star',
-        '\u260E': 'phone',
-        '\u2640': 'female',
-        '\u2642': 'male',
-        '\u2660': 'spades',
-        '\u2663': 'clubs',
-        '\u2665': 'hearts',
-        '\u2666': 'diams',
-        '\u266A': 'sung',
-        '\u2713': 'check',
-        '\u2717': 'cross',
-        '\u2720': 'malt',
-        '\u2736': 'sext',
-        '\u2758': 'VerticalSeparator',
-        '\u27C8': 'bsolhsub',
-        '\u27C9': 'suphsol',
-        '\u27F5': 'xlarr',
-        '\u27F6': 'xrarr',
-        '\u27F7': 'xharr',
-        '\u27F8': 'xlArr',
-        '\u27F9': 'xrArr',
-        '\u27FA': 'xhArr',
-        '\u27FC': 'xmap',
-        '\u27FF': 'dzigrarr',
-        '\u2902': 'nvlArr',
-        '\u2903': 'nvrArr',
-        '\u2904': 'nvHarr',
-        '\u2905': 'Map',
-        '\u290C': 'lbarr',
-        '\u290D': 'rbarr',
-        '\u290E': 'lBarr',
-        '\u290F': 'rBarr',
-        '\u2910': 'RBarr',
-        '\u2911': 'DDotrahd',
-        '\u2912': 'UpArrowBar',
-        '\u2913': 'DownArrowBar',
-        '\u2916': 'Rarrtl',
-        '\u2919': 'latail',
-        '\u291A': 'ratail',
-        '\u291B': 'lAtail',
-        '\u291C': 'rAtail',
-        '\u291D': 'larrfs',
-        '\u291E': 'rarrfs',
-        '\u291F': 'larrbfs',
-        '\u2920': 'rarrbfs',
-        '\u2923': 'nwarhk',
-        '\u2924': 'nearhk',
-        '\u2925': 'searhk',
-        '\u2926': 'swarhk',
-        '\u2927': 'nwnear',
-        '\u2928': 'toea',
-        '\u2929': 'tosa',
-        '\u292A': 'swnwar',
-        '\u2933': 'rarrc',
-        '\u2933\u0338': 'nrarrc',
-        '\u2935': 'cudarrr',
-        '\u2936': 'ldca',
-        '\u2937': 'rdca',
-        '\u2938': 'cudarrl',
-        '\u2939': 'larrpl',
-        '\u293C': 'curarrm',
-        '\u293D': 'cularrp',
-        '\u2945': 'rarrpl',
-        '\u2948': 'harrcir',
-        '\u2949': 'Uarrocir',
-        '\u294A': 'lurdshar',
-        '\u294B': 'ldrushar',
-        '\u294E': 'LeftRightVector',
-        '\u294F': 'RightUpDownVector',
-        '\u2950': 'DownLeftRightVector',
-        '\u2951': 'LeftUpDownVector',
-        '\u2952': 'LeftVectorBar',
-        '\u2953': 'RightVectorBar',
-        '\u2954': 'RightUpVectorBar',
-        '\u2955': 'RightDownVectorBar',
-        '\u2956': 'DownLeftVectorBar',
-        '\u2957': 'DownRightVectorBar',
-        '\u2958': 'LeftUpVectorBar',
-        '\u2959': 'LeftDownVectorBar',
-        '\u295A': 'LeftTeeVector',
-        '\u295B': 'RightTeeVector',
-        '\u295C': 'RightUpTeeVector',
-        '\u295D': 'RightDownTeeVector',
-        '\u295E': 'DownLeftTeeVector',
-        '\u295F': 'DownRightTeeVector',
-        '\u2960': 'LeftUpTeeVector',
-        '\u2961': 'LeftDownTeeVector',
-        '\u2962': 'lHar',
-        '\u2963': 'uHar',
-        '\u2964': 'rHar',
-        '\u2965': 'dHar',
-        '\u2966': 'luruhar',
-        '\u2967': 'ldrdhar',
-        '\u2968': 'ruluhar',
-        '\u2969': 'rdldhar',
-        '\u296A': 'lharul',
-        '\u296B': 'llhard',
-        '\u296C': 'rharul',
-        '\u296D': 'lrhard',
-        '\u296E': 'udhar',
-        '\u296F': 'duhar',
-        '\u2970': 'RoundImplies',
-        '\u2971': 'erarr',
-        '\u2972': 'simrarr',
-        '\u2973': 'larrsim',
-        '\u2974': 'rarrsim',
-        '\u2975': 'rarrap',
-        '\u2976': 'ltlarr',
-        '\u2978': 'gtrarr',
-        '\u2979': 'subrarr',
-        '\u297B': 'suplarr',
-        '\u297C': 'lfisht',
-        '\u297D': 'rfisht',
-        '\u297E': 'ufisht',
-        '\u297F': 'dfisht',
-        '\u299A': 'vzigzag',
-        '\u299C': 'vangrt',
-        '\u299D': 'angrtvbd',
-        '\u29A4': 'ange',
-        '\u29A5': 'range',
-        '\u29A6': 'dwangle',
-        '\u29A7': 'uwangle',
-        '\u29A8': 'angmsdaa',
-        '\u29A9': 'angmsdab',
-        '\u29AA': 'angmsdac',
-        '\u29AB': 'angmsdad',
-        '\u29AC': 'angmsdae',
-        '\u29AD': 'angmsdaf',
-        '\u29AE': 'angmsdag',
-        '\u29AF': 'angmsdah',
-        '\u29B0': 'bemptyv',
-        '\u29B1': 'demptyv',
-        '\u29B2': 'cemptyv',
-        '\u29B3': 'raemptyv',
-        '\u29B4': 'laemptyv',
-        '\u29B5': 'ohbar',
-        '\u29B6': 'omid',
-        '\u29B7': 'opar',
-        '\u29B9': 'operp',
-        '\u29BB': 'olcross',
-        '\u29BC': 'odsold',
-        '\u29BE': 'olcir',
-        '\u29BF': 'ofcir',
-        '\u29C0': 'olt',
-        '\u29C1': 'ogt',
-        '\u29C2': 'cirscir',
-        '\u29C3': 'cirE',
-        '\u29C4': 'solb',
-        '\u29C5': 'bsolb',
-        '\u29C9': 'boxbox',
-        '\u29CD': 'trisb',
-        '\u29CE': 'rtriltri',
-        '\u29CF': 'LeftTriangleBar',
-        '\u29CF\u0338': 'NotLeftTriangleBar',
-        '\u29D0': 'RightTriangleBar',
-        '\u29D0\u0338': 'NotRightTriangleBar',
-        '\u29DC': 'iinfin',
-        '\u29DD': 'infintie',
-        '\u29DE': 'nvinfin',
-        '\u29E3': 'eparsl',
-        '\u29E4': 'smeparsl',
-        '\u29E5': 'eqvparsl',
-        '\u29EB': 'lozf',
-        '\u29F4': 'RuleDelayed',
-        '\u29F6': 'dsol',
-        '\u2A00': 'xodot',
-        '\u2A01': 'xoplus',
-        '\u2A02': 'xotime',
-        '\u2A04': 'xuplus',
-        '\u2A06': 'xsqcup',
-        '\u2A0D': 'fpartint',
-        '\u2A10': 'cirfnint',
-        '\u2A11': 'awint',
-        '\u2A12': 'rppolint',
-        '\u2A13': 'scpolint',
-        '\u2A14': 'npolint',
-        '\u2A15': 'pointint',
-        '\u2A16': 'quatint',
-        '\u2A17': 'intlarhk',
-        '\u2A22': 'pluscir',
-        '\u2A23': 'plusacir',
-        '\u2A24': 'simplus',
-        '\u2A25': 'plusdu',
-        '\u2A26': 'plussim',
-        '\u2A27': 'plustwo',
-        '\u2A29': 'mcomma',
-        '\u2A2A': 'minusdu',
-        '\u2A2D': 'loplus',
-        '\u2A2E': 'roplus',
-        '\u2A2F': 'Cross',
-        '\u2A30': 'timesd',
-        '\u2A31': 'timesbar',
-        '\u2A33': 'smashp',
-        '\u2A34': 'lotimes',
-        '\u2A35': 'rotimes',
-        '\u2A36': 'otimesas',
-        '\u2A37': 'Otimes',
-        '\u2A38': 'odiv',
-        '\u2A39': 'triplus',
-        '\u2A3A': 'triminus',
-        '\u2A3B': 'tritime',
-        '\u2A3C': 'iprod',
-        '\u2A3F': 'amalg',
-        '\u2A40': 'capdot',
-        '\u2A42': 'ncup',
-        '\u2A43': 'ncap',
-        '\u2A44': 'capand',
-        '\u2A45': 'cupor',
-        '\u2A46': 'cupcap',
-        '\u2A47': 'capcup',
-        '\u2A48': 'cupbrcap',
-        '\u2A49': 'capbrcup',
-        '\u2A4A': 'cupcup',
-        '\u2A4B': 'capcap',
-        '\u2A4C': 'ccups',
-        '\u2A4D': 'ccaps',
-        '\u2A50': 'ccupssm',
-        '\u2A53': 'And',
-        '\u2A54': 'Or',
-        '\u2A55': 'andand',
-        '\u2A56': 'oror',
-        '\u2A57': 'orslope',
-        '\u2A58': 'andslope',
-        '\u2A5A': 'andv',
-        '\u2A5B': 'orv',
-        '\u2A5C': 'andd',
-        '\u2A5D': 'ord',
-        '\u2A5F': 'wedbar',
-        '\u2A66': 'sdote',
-        '\u2A6A': 'simdot',
-        '\u2A6D': 'congdot',
-        '\u2A6D\u0338': 'ncongdot',
-        '\u2A6E': 'easter',
-        '\u2A6F': 'apacir',
-        '\u2A70': 'apE',
-        '\u2A70\u0338': 'napE',
-        '\u2A71': 'eplus',
-        '\u2A72': 'pluse',
-        '\u2A73': 'Esim',
-        '\u2A77': 'eDDot',
-        '\u2A78': 'equivDD',
-        '\u2A79': 'ltcir',
-        '\u2A7A': 'gtcir',
-        '\u2A7B': 'ltquest',
-        '\u2A7C': 'gtquest',
-        '\u2A7D': 'les',
-        '\u2A7D\u0338': 'nles',
-        '\u2A7E': 'ges',
-        '\u2A7E\u0338': 'nges',
-        '\u2A7F': 'lesdot',
-        '\u2A80': 'gesdot',
-        '\u2A81': 'lesdoto',
-        '\u2A82': 'gesdoto',
-        '\u2A83': 'lesdotor',
-        '\u2A84': 'gesdotol',
-        '\u2A85': 'lap',
-        '\u2A86': 'gap',
-        '\u2A87': 'lne',
-        '\u2A88': 'gne',
-        '\u2A89': 'lnap',
-        '\u2A8A': 'gnap',
-        '\u2A8B': 'lEg',
-        '\u2A8C': 'gEl',
-        '\u2A8D': 'lsime',
-        '\u2A8E': 'gsime',
-        '\u2A8F': 'lsimg',
-        '\u2A90': 'gsiml',
-        '\u2A91': 'lgE',
-        '\u2A92': 'glE',
-        '\u2A93': 'lesges',
-        '\u2A94': 'gesles',
-        '\u2A95': 'els',
-        '\u2A96': 'egs',
-        '\u2A97': 'elsdot',
-        '\u2A98': 'egsdot',
-        '\u2A99': 'el',
-        '\u2A9A': 'eg',
-        '\u2A9D': 'siml',
-        '\u2A9E': 'simg',
-        '\u2A9F': 'simlE',
-        '\u2AA0': 'simgE',
-        '\u2AA1': 'LessLess',
-        '\u2AA1\u0338': 'NotNestedLessLess',
-        '\u2AA2': 'GreaterGreater',
-        '\u2AA2\u0338': 'NotNestedGreaterGreater',
-        '\u2AA4': 'glj',
-        '\u2AA5': 'gla',
-        '\u2AA6': 'ltcc',
-        '\u2AA7': 'gtcc',
-        '\u2AA8': 'lescc',
-        '\u2AA9': 'gescc',
-        '\u2AAA': 'smt',
-        '\u2AAB': 'lat',
-        '\u2AAC': 'smte',
-        '\u2AAC\uFE00': 'smtes',
-        '\u2AAD': 'late',
-        '\u2AAD\uFE00': 'lates',
-        '\u2AAE': 'bumpE',
-        '\u2AAF': 'pre',
-        '\u2AAF\u0338': 'npre',
-        '\u2AB0': 'sce',
-        '\u2AB0\u0338': 'nsce',
-        '\u2AB3': 'prE',
-        '\u2AB4': 'scE',
-        '\u2AB5': 'prnE',
-        '\u2AB6': 'scnE',
-        '\u2AB7': 'prap',
-        '\u2AB8': 'scap',
-        '\u2AB9': 'prnap',
-        '\u2ABA': 'scnap',
-        '\u2ABB': 'Pr',
-        '\u2ABC': 'Sc',
-        '\u2ABD': 'subdot',
-        '\u2ABE': 'supdot',
-        '\u2ABF': 'subplus',
-        '\u2AC0': 'supplus',
-        '\u2AC1': 'submult',
-        '\u2AC2': 'supmult',
-        '\u2AC3': 'subedot',
-        '\u2AC4': 'supedot',
-        '\u2AC5': 'subE',
-        '\u2AC5\u0338': 'nsubE',
-        '\u2AC6': 'supE',
-        '\u2AC6\u0338': 'nsupE',
-        '\u2AC7': 'subsim',
-        '\u2AC8': 'supsim',
-        '\u2ACB\uFE00': 'vsubnE',
-        '\u2ACB': 'subnE',
-        '\u2ACC\uFE00': 'vsupnE',
-        '\u2ACC': 'supnE',
-        '\u2ACF': 'csub',
-        '\u2AD0': 'csup',
-        '\u2AD1': 'csube',
-        '\u2AD2': 'csupe',
-        '\u2AD3': 'subsup',
-        '\u2AD4': 'supsub',
-        '\u2AD5': 'subsub',
-        '\u2AD6': 'supsup',
-        '\u2AD7': 'suphsub',
-        '\u2AD8': 'supdsub',
-        '\u2AD9': 'forkv',
-        '\u2ADA': 'topfork',
-        '\u2ADB': 'mlcp',
-        '\u2AE4': 'Dashv',
-        '\u2AE6': 'Vdashl',
-        '\u2AE7': 'Barv',
-        '\u2AE8': 'vBar',
-        '\u2AE9': 'vBarv',
-        '\u2AEB': 'Vbar',
-        '\u2AEC': 'Not',
-        '\u2AED': 'bNot',
-        '\u2AEE': 'rnmid',
-        '\u2AEF': 'cirmid',
-        '\u2AF0': 'midcir',
-        '\u2AF1': 'topcir',
-        '\u2AF2': 'nhpar',
-        '\u2AF3': 'parsim',
-        '\u2AFD': 'parsl',
-        '\u2AFD\u20E5': 'nparsl',
-        '\u266D': 'flat',
-        '\u266E': 'natur',
-        '\u266F': 'sharp',
-        '\xA4': 'curren',
-        '\xA2': 'cent',
-        $: 'dollar',
-        '\xA3': 'pound',
-        '\xA5': 'yen',
-        '\u20AC': 'euro',
-        '\xB9': 'sup1',
-        '\xBD': 'half',
-        '\u2153': 'frac13',
-        '\xBC': 'frac14',
-        '\u2155': 'frac15',
-        '\u2159': 'frac16',
-        '\u215B': 'frac18',
-        '\xB2': 'sup2',
-        '\u2154': 'frac23',
-        '\u2156': 'frac25',
-        '\xB3': 'sup3',
-        '\xBE': 'frac34',
-        '\u2157': 'frac35',
-        '\u215C': 'frac38',
-        '\u2158': 'frac45',
-        '\u215A': 'frac56',
-        '\u215D': 'frac58',
-        '\u215E': 'frac78',
-        '\uD835\uDCB6': 'ascr',
-        '\uD835\uDD52': 'aopf',
-        '\uD835\uDD1E': 'afr',
-        '\uD835\uDD38': 'Aopf',
-        '\uD835\uDD04': 'Afr',
-        '\uD835\uDC9C': 'Ascr',
-        '\xAA': 'ordf',
-        '\xE1': 'aacute',
-        '\xC1': 'Aacute',
-        '\xE0': 'agrave',
-        '\xC0': 'Agrave',
-        '\u0103': 'abreve',
-        '\u0102': 'Abreve',
-        '\xE2': 'acirc',
-        '\xC2': 'Acirc',
-        '\xE5': 'aring',
-        '\xC5': 'angst',
-        '\xE4': 'auml',
-        '\xC4': 'Auml',
-        '\xE3': 'atilde',
-        '\xC3': 'Atilde',
-        '\u0105': 'aogon',
-        '\u0104': 'Aogon',
-        '\u0101': 'amacr',
-        '\u0100': 'Amacr',
-        '\xE6': 'aelig',
-        '\xC6': 'AElig',
-        '\uD835\uDCB7': 'bscr',
-        '\uD835\uDD53': 'bopf',
-        '\uD835\uDD1F': 'bfr',
-        '\uD835\uDD39': 'Bopf',
-        '\u212C': 'Bscr',
-        '\uD835\uDD05': 'Bfr',
-        '\uD835\uDD20': 'cfr',
-        '\uD835\uDCB8': 'cscr',
-        '\uD835\uDD54': 'copf',
-        '\u212D': 'Cfr',
-        '\uD835\uDC9E': 'Cscr',
-        '\u2102': 'Copf',
-        '\u0107': 'cacute',
-        '\u0106': 'Cacute',
-        '\u0109': 'ccirc',
-        '\u0108': 'Ccirc',
-        '\u010D': 'ccaron',
-        '\u010C': 'Ccaron',
-        '\u010B': 'cdot',
-        '\u010A': 'Cdot',
-        '\xE7': 'ccedil',
-        '\xC7': 'Ccedil',
-        '\u2105': 'incare',
-        '\uD835\uDD21': 'dfr',
-        '\u2146': 'dd',
-        '\uD835\uDD55': 'dopf',
-        '\uD835\uDCB9': 'dscr',
-        '\uD835\uDC9F': 'Dscr',
-        '\uD835\uDD07': 'Dfr',
-        '\u2145': 'DD',
-        '\uD835\uDD3B': 'Dopf',
-        '\u010F': 'dcaron',
-        '\u010E': 'Dcaron',
-        '\u0111': 'dstrok',
-        '\u0110': 'Dstrok',
-        '\xF0': 'eth',
-        '\xD0': 'ETH',
-        '\u2147': 'ee',
-        '\u212F': 'escr',
-        '\uD835\uDD22': 'efr',
-        '\uD835\uDD56': 'eopf',
-        '\u2130': 'Escr',
-        '\uD835\uDD08': 'Efr',
-        '\uD835\uDD3C': 'Eopf',
-        '\xE9': 'eacute',
-        '\xC9': 'Eacute',
-        '\xE8': 'egrave',
-        '\xC8': 'Egrave',
-        '\xEA': 'ecirc',
-        '\xCA': 'Ecirc',
-        '\u011B': 'ecaron',
-        '\u011A': 'Ecaron',
-        '\xEB': 'euml',
-        '\xCB': 'Euml',
-        '\u0117': 'edot',
-        '\u0116': 'Edot',
-        '\u0119': 'eogon',
-        '\u0118': 'Eogon',
-        '\u0113': 'emacr',
-        '\u0112': 'Emacr',
-        '\uD835\uDD23': 'ffr',
-        '\uD835\uDD57': 'fopf',
-        '\uD835\uDCBB': 'fscr',
-        '\uD835\uDD09': 'Ffr',
-        '\uD835\uDD3D': 'Fopf',
-        '\u2131': 'Fscr',
-        '\uFB00': 'fflig',
-        '\uFB03': 'ffilig',
-        '\uFB04': 'ffllig',
-        '\uFB01': 'filig',
-        fj: 'fjlig',
-        '\uFB02': 'fllig',
-        '\u0192': 'fnof',
-        '\u210A': 'gscr',
-        '\uD835\uDD58': 'gopf',
-        '\uD835\uDD24': 'gfr',
-        '\uD835\uDCA2': 'Gscr',
-        '\uD835\uDD3E': 'Gopf',
-        '\uD835\uDD0A': 'Gfr',
-        '\u01F5': 'gacute',
-        '\u011F': 'gbreve',
-        '\u011E': 'Gbreve',
-        '\u011D': 'gcirc',
-        '\u011C': 'Gcirc',
-        '\u0121': 'gdot',
-        '\u0120': 'Gdot',
-        '\u0122': 'Gcedil',
-        '\uD835\uDD25': 'hfr',
-        '\u210E': 'planckh',
-        '\uD835\uDCBD': 'hscr',
-        '\uD835\uDD59': 'hopf',
-        '\u210B': 'Hscr',
-        '\u210C': 'Hfr',
-        '\u210D': 'Hopf',
-        '\u0125': 'hcirc',
-        '\u0124': 'Hcirc',
-        '\u210F': 'hbar',
-        '\u0127': 'hstrok',
-        '\u0126': 'Hstrok',
-        '\uD835\uDD5A': 'iopf',
-        '\uD835\uDD26': 'ifr',
-        '\uD835\uDCBE': 'iscr',
-        '\u2148': 'ii',
-        '\uD835\uDD40': 'Iopf',
-        '\u2110': 'Iscr',
-        '\u2111': 'Im',
-        '\xED': 'iacute',
-        '\xCD': 'Iacute',
-        '\xEC': 'igrave',
-        '\xCC': 'Igrave',
-        '\xEE': 'icirc',
-        '\xCE': 'Icirc',
-        '\xEF': 'iuml',
-        '\xCF': 'Iuml',
-        '\u0129': 'itilde',
-        '\u0128': 'Itilde',
-        '\u0130': 'Idot',
-        '\u012F': 'iogon',
-        '\u012E': 'Iogon',
-        '\u012B': 'imacr',
-        '\u012A': 'Imacr',
-        '\u0133': 'ijlig',
-        '\u0132': 'IJlig',
-        '\u0131': 'imath',
-        '\uD835\uDCBF': 'jscr',
-        '\uD835\uDD5B': 'jopf',
-        '\uD835\uDD27': 'jfr',
-        '\uD835\uDCA5': 'Jscr',
-        '\uD835\uDD0D': 'Jfr',
-        '\uD835\uDD41': 'Jopf',
-        '\u0135': 'jcirc',
-        '\u0134': 'Jcirc',
-        '\u0237': 'jmath',
-        '\uD835\uDD5C': 'kopf',
-        '\uD835\uDCC0': 'kscr',
-        '\uD835\uDD28': 'kfr',
-        '\uD835\uDCA6': 'Kscr',
-        '\uD835\uDD42': 'Kopf',
-        '\uD835\uDD0E': 'Kfr',
-        '\u0137': 'kcedil',
-        '\u0136': 'Kcedil',
-        '\uD835\uDD29': 'lfr',
-        '\uD835\uDCC1': 'lscr',
-        '\u2113': 'ell',
-        '\uD835\uDD5D': 'lopf',
-        '\u2112': 'Lscr',
-        '\uD835\uDD0F': 'Lfr',
-        '\uD835\uDD43': 'Lopf',
-        '\u013A': 'lacute',
-        '\u0139': 'Lacute',
-        '\u013E': 'lcaron',
-        '\u013D': 'Lcaron',
-        '\u013C': 'lcedil',
-        '\u013B': 'Lcedil',
-        '\u0142': 'lstrok',
-        '\u0141': 'Lstrok',
-        '\u0140': 'lmidot',
-        '\u013F': 'Lmidot',
-        '\uD835\uDD2A': 'mfr',
-        '\uD835\uDD5E': 'mopf',
-        '\uD835\uDCC2': 'mscr',
-        '\uD835\uDD10': 'Mfr',
-        '\uD835\uDD44': 'Mopf',
-        '\u2133': 'Mscr',
-        '\uD835\uDD2B': 'nfr',
-        '\uD835\uDD5F': 'nopf',
-        '\uD835\uDCC3': 'nscr',
-        '\u2115': 'Nopf',
-        '\uD835\uDCA9': 'Nscr',
-        '\uD835\uDD11': 'Nfr',
-        '\u0144': 'nacute',
-        '\u0143': 'Nacute',
-        '\u0148': 'ncaron',
-        '\u0147': 'Ncaron',
-        '\xF1': 'ntilde',
-        '\xD1': 'Ntilde',
-        '\u0146': 'ncedil',
-        '\u0145': 'Ncedil',
-        '\u2116': 'numero',
-        '\u014B': 'eng',
-        '\u014A': 'ENG',
-        '\uD835\uDD60': 'oopf',
-        '\uD835\uDD2C': 'ofr',
-        '\u2134': 'oscr',
-        '\uD835\uDCAA': 'Oscr',
-        '\uD835\uDD12': 'Ofr',
-        '\uD835\uDD46': 'Oopf',
-        '\xBA': 'ordm',
-        '\xF3': 'oacute',
-        '\xD3': 'Oacute',
-        '\xF2': 'ograve',
-        '\xD2': 'Ograve',
-        '\xF4': 'ocirc',
-        '\xD4': 'Ocirc',
-        '\xF6': 'ouml',
-        '\xD6': 'Ouml',
-        '\u0151': 'odblac',
-        '\u0150': 'Odblac',
-        '\xF5': 'otilde',
-        '\xD5': 'Otilde',
-        '\xF8': 'oslash',
-        '\xD8': 'Oslash',
-        '\u014D': 'omacr',
-        '\u014C': 'Omacr',
-        '\u0153': 'oelig',
-        '\u0152': 'OElig',
-        '\uD835\uDD2D': 'pfr',
-        '\uD835\uDCC5': 'pscr',
-        '\uD835\uDD61': 'popf',
-        '\u2119': 'Popf',
-        '\uD835\uDD13': 'Pfr',
-        '\uD835\uDCAB': 'Pscr',
-        '\uD835\uDD62': 'qopf',
-        '\uD835\uDD2E': 'qfr',
-        '\uD835\uDCC6': 'qscr',
-        '\uD835\uDCAC': 'Qscr',
-        '\uD835\uDD14': 'Qfr',
-        '\u211A': 'Qopf',
-        '\u0138': 'kgreen',
-        '\uD835\uDD2F': 'rfr',
-        '\uD835\uDD63': 'ropf',
-        '\uD835\uDCC7': 'rscr',
-        '\u211B': 'Rscr',
-        '\u211C': 'Re',
-        '\u211D': 'Ropf',
-        '\u0155': 'racute',
-        '\u0154': 'Racute',
-        '\u0159': 'rcaron',
-        '\u0158': 'Rcaron',
-        '\u0157': 'rcedil',
-        '\u0156': 'Rcedil',
-        '\uD835\uDD64': 'sopf',
-        '\uD835\uDCC8': 'sscr',
-        '\uD835\uDD30': 'sfr',
-        '\uD835\uDD4A': 'Sopf',
-        '\uD835\uDD16': 'Sfr',
-        '\uD835\uDCAE': 'Sscr',
-        '\u24C8': 'oS',
-        '\u015B': 'sacute',
-        '\u015A': 'Sacute',
-        '\u015D': 'scirc',
-        '\u015C': 'Scirc',
-        '\u0161': 'scaron',
-        '\u0160': 'Scaron',
-        '\u015F': 'scedil',
-        '\u015E': 'Scedil',
-        '\xDF': 'szlig',
-        '\uD835\uDD31': 'tfr',
-        '\uD835\uDCC9': 'tscr',
-        '\uD835\uDD65': 'topf',
-        '\uD835\uDCAF': 'Tscr',
-        '\uD835\uDD17': 'Tfr',
-        '\uD835\uDD4B': 'Topf',
-        '\u0165': 'tcaron',
-        '\u0164': 'Tcaron',
-        '\u0163': 'tcedil',
-        '\u0162': 'Tcedil',
-        '\u2122': 'trade',
-        '\u0167': 'tstrok',
-        '\u0166': 'Tstrok',
-        '\uD835\uDCCA': 'uscr',
-        '\uD835\uDD66': 'uopf',
-        '\uD835\uDD32': 'ufr',
-        '\uD835\uDD4C': 'Uopf',
-        '\uD835\uDD18': 'Ufr',
-        '\uD835\uDCB0': 'Uscr',
-        '\xFA': 'uacute',
-        '\xDA': 'Uacute',
-        '\xF9': 'ugrave',
-        '\xD9': 'Ugrave',
-        '\u016D': 'ubreve',
-        '\u016C': 'Ubreve',
-        '\xFB': 'ucirc',
-        '\xDB': 'Ucirc',
-        '\u016F': 'uring',
-        '\u016E': 'Uring',
-        '\xFC': 'uuml',
-        '\xDC': 'Uuml',
-        '\u0171': 'udblac',
-        '\u0170': 'Udblac',
-        '\u0169': 'utilde',
-        '\u0168': 'Utilde',
-        '\u0173': 'uogon',
-        '\u0172': 'Uogon',
-        '\u016B': 'umacr',
-        '\u016A': 'Umacr',
-        '\uD835\uDD33': 'vfr',
-        '\uD835\uDD67': 'vopf',
-        '\uD835\uDCCB': 'vscr',
-        '\uD835\uDD19': 'Vfr',
-        '\uD835\uDD4D': 'Vopf',
-        '\uD835\uDCB1': 'Vscr',
-        '\uD835\uDD68': 'wopf',
-        '\uD835\uDCCC': 'wscr',
-        '\uD835\uDD34': 'wfr',
-        '\uD835\uDCB2': 'Wscr',
-        '\uD835\uDD4E': 'Wopf',
-        '\uD835\uDD1A': 'Wfr',
-        '\u0175': 'wcirc',
-        '\u0174': 'Wcirc',
-        '\uD835\uDD35': 'xfr',
-        '\uD835\uDCCD': 'xscr',
-        '\uD835\uDD69': 'xopf',
-        '\uD835\uDD4F': 'Xopf',
-        '\uD835\uDD1B': 'Xfr',
-        '\uD835\uDCB3': 'Xscr',
-        '\uD835\uDD36': 'yfr',
-        '\uD835\uDCCE': 'yscr',
-        '\uD835\uDD6A': 'yopf',
-        '\uD835\uDCB4': 'Yscr',
-        '\uD835\uDD1C': 'Yfr',
-        '\uD835\uDD50': 'Yopf',
-        '\xFD': 'yacute',
-        '\xDD': 'Yacute',
-        '\u0177': 'ycirc',
-        '\u0176': 'Ycirc',
-        '\xFF': 'yuml',
-        '\u0178': 'Yuml',
-        '\uD835\uDCCF': 'zscr',
-        '\uD835\uDD37': 'zfr',
-        '\uD835\uDD6B': 'zopf',
-        '\u2128': 'Zfr',
-        '\u2124': 'Zopf',
-        '\uD835\uDCB5': 'Zscr',
-        '\u017A': 'zacute',
-        '\u0179': 'Zacute',
-        '\u017E': 'zcaron',
-        '\u017D': 'Zcaron',
-        '\u017C': 'zdot',
-        '\u017B': 'Zdot',
-        '\u01B5': 'imped',
-        '\xFE': 'thorn',
-        '\xDE': 'THORN',
-        '\u0149': 'napos',
-        '\u03B1': 'alpha',
-        '\u0391': 'Alpha',
-        '\u03B2': 'beta',
-        '\u0392': 'Beta',
-        '\u03B3': 'gamma',
-        '\u0393': 'Gamma',
-        '\u03B4': 'delta',
-        '\u0394': 'Delta',
-        '\u03B5': 'epsi',
-        '\u03F5': 'epsiv',
-        '\u0395': 'Epsilon',
-        '\u03DD': 'gammad',
-        '\u03DC': 'Gammad',
-        '\u03B6': 'zeta',
-        '\u0396': 'Zeta',
-        '\u03B7': 'eta',
-        '\u0397': 'Eta',
-        '\u03B8': 'theta',
-        '\u03D1': 'thetav',
-        '\u0398': 'Theta',
-        '\u03B9': 'iota',
-        '\u0399': 'Iota',
-        '\u03BA': 'kappa',
-        '\u03F0': 'kappav',
-        '\u039A': 'Kappa',
-        '\u03BB': 'lambda',
-        '\u039B': 'Lambda',
-        '\u03BC': 'mu',
-        '\xB5': 'micro',
-        '\u039C': 'Mu',
-        '\u03BD': 'nu',
-        '\u039D': 'Nu',
-        '\u03BE': 'xi',
-        '\u039E': 'Xi',
-        '\u03BF': 'omicron',
-        '\u039F': 'Omicron',
-        '\u03C0': 'pi',
-        '\u03D6': 'piv',
-        '\u03A0': 'Pi',
-        '\u03C1': 'rho',
-        '\u03F1': 'rhov',
-        '\u03A1': 'Rho',
-        '\u03C3': 'sigma',
-        '\u03A3': 'Sigma',
-        '\u03C2': 'sigmaf',
-        '\u03C4': 'tau',
-        '\u03A4': 'Tau',
-        '\u03C5': 'upsi',
-        '\u03A5': 'Upsilon',
-        '\u03D2': 'Upsi',
-        '\u03C6': 'phi',
-        '\u03D5': 'phiv',
-        '\u03A6': 'Phi',
-        '\u03C7': 'chi',
-        '\u03A7': 'Chi',
-        '\u03C8': 'psi',
-        '\u03A8': 'Psi',
-        '\u03C9': 'omega',
-        '\u03A9': 'ohm',
-        '\u0430': 'acy',
-        '\u0410': 'Acy',
-        '\u0431': 'bcy',
-        '\u0411': 'Bcy',
-        '\u0432': 'vcy',
-        '\u0412': 'Vcy',
-        '\u0433': 'gcy',
-        '\u0413': 'Gcy',
-        '\u0453': 'gjcy',
-        '\u0403': 'GJcy',
-        '\u0434': 'dcy',
-        '\u0414': 'Dcy',
-        '\u0452': 'djcy',
-        '\u0402': 'DJcy',
-        '\u0435': 'iecy',
-        '\u0415': 'IEcy',
-        '\u0451': 'iocy',
-        '\u0401': 'IOcy',
-        '\u0454': 'jukcy',
-        '\u0404': 'Jukcy',
-        '\u0436': 'zhcy',
-        '\u0416': 'ZHcy',
-        '\u0437': 'zcy',
-        '\u0417': 'Zcy',
-        '\u0455': 'dscy',
-        '\u0405': 'DScy',
-        '\u0438': 'icy',
-        '\u0418': 'Icy',
-        '\u0456': 'iukcy',
-        '\u0406': 'Iukcy',
-        '\u0457': 'yicy',
-        '\u0407': 'YIcy',
-        '\u0439': 'jcy',
-        '\u0419': 'Jcy',
-        '\u0458': 'jsercy',
-        '\u0408': 'Jsercy',
-        '\u043A': 'kcy',
-        '\u041A': 'Kcy',
-        '\u045C': 'kjcy',
-        '\u040C': 'KJcy',
-        '\u043B': 'lcy',
-        '\u041B': 'Lcy',
-        '\u0459': 'ljcy',
-        '\u0409': 'LJcy',
-        '\u043C': 'mcy',
-        '\u041C': 'Mcy',
-        '\u043D': 'ncy',
-        '\u041D': 'Ncy',
-        '\u045A': 'njcy',
-        '\u040A': 'NJcy',
-        '\u043E': 'ocy',
-        '\u041E': 'Ocy',
-        '\u043F': 'pcy',
-        '\u041F': 'Pcy',
-        '\u0440': 'rcy',
-        '\u0420': 'Rcy',
-        '\u0441': 'scy',
-        '\u0421': 'Scy',
-        '\u0442': 'tcy',
-        '\u0422': 'Tcy',
-        '\u045B': 'tshcy',
-        '\u040B': 'TSHcy',
-        '\u0443': 'ucy',
-        '\u0423': 'Ucy',
-        '\u045E': 'ubrcy',
-        '\u040E': 'Ubrcy',
-        '\u0444': 'fcy',
-        '\u0424': 'Fcy',
-        '\u0445': 'khcy',
-        '\u0425': 'KHcy',
-        '\u0446': 'tscy',
-        '\u0426': 'TScy',
-        '\u0447': 'chcy',
-        '\u0427': 'CHcy',
-        '\u045F': 'dzcy',
-        '\u040F': 'DZcy',
-        '\u0448': 'shcy',
-        '\u0428': 'SHcy',
-        '\u0449': 'shchcy',
-        '\u0429': 'SHCHcy',
-        '\u044A': 'hardcy',
-        '\u042A': 'HARDcy',
-        '\u044B': 'ycy',
-        '\u042B': 'Ycy',
-        '\u044C': 'softcy',
-        '\u042C': 'SOFTcy',
-        '\u044D': 'ecy',
-        '\u042D': 'Ecy',
-        '\u044E': 'yucy',
-        '\u042E': 'YUcy',
-        '\u044F': 'yacy',
-        '\u042F': 'YAcy',
-        '\u2135': 'aleph',
-        '\u2136': 'beth',
-        '\u2137': 'gimel',
-        '\u2138': 'daleth'
-      }
-
-      var regexEscape = /["&'<>`]/g
-      var escapeMap = {
-        '"': '&quot;',
-        '&': '&amp;',
-        "'": '&#x27;',
-        '<': '&lt;',
-        // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
-        // following is not strictly necessary unless it’s part of a tag or an
-        // unquoted attribute value. We’re only escaping it to support those
-        // situations, and for XML support.
-        '>': '&gt;',
-        // In Internet Explorer ≤ 8, the backtick character can be used
-        // to break out of (un)quoted attribute values or HTML comments.
-        // See http://html5sec.org/#102, http://html5sec.org/#108, and
-        // http://html5sec.org/#133.
-        '`': '&#x60;'
-      }
-
-      var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/
-      var regexInvalidRawCodePoint =
-        /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/
-      var regexDecode =
-        /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g
-      var decodeMap = {
-        aacute: '\xE1',
-        Aacute: '\xC1',
-        abreve: '\u0103',
-        Abreve: '\u0102',
-        ac: '\u223E',
-        acd: '\u223F',
-        acE: '\u223E\u0333',
-        acirc: '\xE2',
-        Acirc: '\xC2',
-        acute: '\xB4',
-        acy: '\u0430',
-        Acy: '\u0410',
-        aelig: '\xE6',
-        AElig: '\xC6',
-        af: '\u2061',
-        afr: '\uD835\uDD1E',
-        Afr: '\uD835\uDD04',
-        agrave: '\xE0',
-        Agrave: '\xC0',
-        alefsym: '\u2135',
-        aleph: '\u2135',
-        alpha: '\u03B1',
-        Alpha: '\u0391',
-        amacr: '\u0101',
-        Amacr: '\u0100',
-        amalg: '\u2A3F',
-        amp: '&',
-        AMP: '&',
-        and: '\u2227',
-        And: '\u2A53',
-        andand: '\u2A55',
-        andd: '\u2A5C',
-        andslope: '\u2A58',
-        andv: '\u2A5A',
-        ang: '\u2220',
-        ange: '\u29A4',
-        angle: '\u2220',
-        angmsd: '\u2221',
-        angmsdaa: '\u29A8',
-        angmsdab: '\u29A9',
-        angmsdac: '\u29AA',
-        angmsdad: '\u29AB',
-        angmsdae: '\u29AC',
-        angmsdaf: '\u29AD',
-        angmsdag: '\u29AE',
-        angmsdah: '\u29AF',
-        angrt: '\u221F',
-        angrtvb: '\u22BE',
-        angrtvbd: '\u299D',
-        angsph: '\u2222',
-        angst: '\xC5',
-        angzarr: '\u237C',
-        aogon: '\u0105',
-        Aogon: '\u0104',
-        aopf: '\uD835\uDD52',
-        Aopf: '\uD835\uDD38',
-        ap: '\u2248',
-        apacir: '\u2A6F',
-        ape: '\u224A',
-        apE: '\u2A70',
-        apid: '\u224B',
-        apos: "'",
-        ApplyFunction: '\u2061',
-        approx: '\u2248',
-        approxeq: '\u224A',
-        aring: '\xE5',
-        Aring: '\xC5',
-        ascr: '\uD835\uDCB6',
-        Ascr: '\uD835\uDC9C',
-        Assign: '\u2254',
-        ast: '*',
-        asymp: '\u2248',
-        asympeq: '\u224D',
-        atilde: '\xE3',
-        Atilde: '\xC3',
-        auml: '\xE4',
-        Auml: '\xC4',
-        awconint: '\u2233',
-        awint: '\u2A11',
-        backcong: '\u224C',
-        backepsilon: '\u03F6',
-        backprime: '\u2035',
-        backsim: '\u223D',
-        backsimeq: '\u22CD',
-        Backslash: '\u2216',
-        Barv: '\u2AE7',
-        barvee: '\u22BD',
-        barwed: '\u2305',
-        Barwed: '\u2306',
-        barwedge: '\u2305',
-        bbrk: '\u23B5',
-        bbrktbrk: '\u23B6',
-        bcong: '\u224C',
-        bcy: '\u0431',
-        Bcy: '\u0411',
-        bdquo: '\u201E',
-        becaus: '\u2235',
-        because: '\u2235',
-        Because: '\u2235',
-        bemptyv: '\u29B0',
-        bepsi: '\u03F6',
-        bernou: '\u212C',
-        Bernoullis: '\u212C',
-        beta: '\u03B2',
-        Beta: '\u0392',
-        beth: '\u2136',
-        between: '\u226C',
-        bfr: '\uD835\uDD1F',
-        Bfr: '\uD835\uDD05',
-        bigcap: '\u22C2',
-        bigcirc: '\u25EF',
-        bigcup: '\u22C3',
-        bigodot: '\u2A00',
-        bigoplus: '\u2A01',
-        bigotimes: '\u2A02',
-        bigsqcup: '\u2A06',
-        bigstar: '\u2605',
-        bigtriangledown: '\u25BD',
-        bigtriangleup: '\u25B3',
-        biguplus: '\u2A04',
-        bigvee: '\u22C1',
-        bigwedge: '\u22C0',
-        bkarow: '\u290D',
-        blacklozenge: '\u29EB',
-        blacksquare: '\u25AA',
-        blacktriangle: '\u25B4',
-        blacktriangledown: '\u25BE',
-        blacktriangleleft: '\u25C2',
-        blacktriangleright: '\u25B8',
-        blank: '\u2423',
-        blk12: '\u2592',
-        blk14: '\u2591',
-        blk34: '\u2593',
-        block: '\u2588',
-        bne: '=\u20E5',
-        bnequiv: '\u2261\u20E5',
-        bnot: '\u2310',
-        bNot: '\u2AED',
-        bopf: '\uD835\uDD53',
-        Bopf: '\uD835\uDD39',
-        bot: '\u22A5',
-        bottom: '\u22A5',
-        bowtie: '\u22C8',
-        boxbox: '\u29C9',
-        boxdl: '\u2510',
-        boxdL: '\u2555',
-        boxDl: '\u2556',
-        boxDL: '\u2557',
-        boxdr: '\u250C',
-        boxdR: '\u2552',
-        boxDr: '\u2553',
-        boxDR: '\u2554',
-        boxh: '\u2500',
-        boxH: '\u2550',
-        boxhd: '\u252C',
-        boxhD: '\u2565',
-        boxHd: '\u2564',
-        boxHD: '\u2566',
-        boxhu: '\u2534',
-        boxhU: '\u2568',
-        boxHu: '\u2567',
-        boxHU: '\u2569',
-        boxminus: '\u229F',
-        boxplus: '\u229E',
-        boxtimes: '\u22A0',
-        boxul: '\u2518',
-        boxuL: '\u255B',
-        boxUl: '\u255C',
-        boxUL: '\u255D',
-        boxur: '\u2514',
-        boxuR: '\u2558',
-        boxUr: '\u2559',
-        boxUR: '\u255A',
-        boxv: '\u2502',
-        boxV: '\u2551',
-        boxvh: '\u253C',
-        boxvH: '\u256A',
-        boxVh: '\u256B',
-        boxVH: '\u256C',
-        boxvl: '\u2524',
-        boxvL: '\u2561',
-        boxVl: '\u2562',
-        boxVL: '\u2563',
-        boxvr: '\u251C',
-        boxvR: '\u255E',
-        boxVr: '\u255F',
-        boxVR: '\u2560',
-        bprime: '\u2035',
-        breve: '\u02D8',
-        Breve: '\u02D8',
-        brvbar: '\xA6',
-        bscr: '\uD835\uDCB7',
-        Bscr: '\u212C',
-        bsemi: '\u204F',
-        bsim: '\u223D',
-        bsime: '\u22CD',
-        bsol: '\\',
-        bsolb: '\u29C5',
-        bsolhsub: '\u27C8',
-        bull: '\u2022',
-        bullet: '\u2022',
-        bump: '\u224E',
-        bumpe: '\u224F',
-        bumpE: '\u2AAE',
-        bumpeq: '\u224F',
-        Bumpeq: '\u224E',
-        cacute: '\u0107',
-        Cacute: '\u0106',
-        cap: '\u2229',
-        Cap: '\u22D2',
-        capand: '\u2A44',
-        capbrcup: '\u2A49',
-        capcap: '\u2A4B',
-        capcup: '\u2A47',
-        capdot: '\u2A40',
-        CapitalDifferentialD: '\u2145',
-        caps: '\u2229\uFE00',
-        caret: '\u2041',
-        caron: '\u02C7',
-        Cayleys: '\u212D',
-        ccaps: '\u2A4D',
-        ccaron: '\u010D',
-        Ccaron: '\u010C',
-        ccedil: '\xE7',
-        Ccedil: '\xC7',
-        ccirc: '\u0109',
-        Ccirc: '\u0108',
-        Cconint: '\u2230',
-        ccups: '\u2A4C',
-        ccupssm: '\u2A50',
-        cdot: '\u010B',
-        Cdot: '\u010A',
-        cedil: '\xB8',
-        Cedilla: '\xB8',
-        cemptyv: '\u29B2',
-        cent: '\xA2',
-        centerdot: '\xB7',
-        CenterDot: '\xB7',
-        cfr: '\uD835\uDD20',
-        Cfr: '\u212D',
-        chcy: '\u0447',
-        CHcy: '\u0427',
-        check: '\u2713',
-        checkmark: '\u2713',
-        chi: '\u03C7',
-        Chi: '\u03A7',
-        cir: '\u25CB',
-        circ: '\u02C6',
-        circeq: '\u2257',
-        circlearrowleft: '\u21BA',
-        circlearrowright: '\u21BB',
-        circledast: '\u229B',
-        circledcirc: '\u229A',
-        circleddash: '\u229D',
-        CircleDot: '\u2299',
-        circledR: '\xAE',
-        circledS: '\u24C8',
-        CircleMinus: '\u2296',
-        CirclePlus: '\u2295',
-        CircleTimes: '\u2297',
-        cire: '\u2257',
-        cirE: '\u29C3',
-        cirfnint: '\u2A10',
-        cirmid: '\u2AEF',
-        cirscir: '\u29C2',
-        ClockwiseContourIntegral: '\u2232',
-        CloseCurlyDoubleQuote: '\u201D',
-        CloseCurlyQuote: '\u2019',
-        clubs: '\u2663',
-        clubsuit: '\u2663',
-        colon: ':',
-        Colon: '\u2237',
-        colone: '\u2254',
-        Colone: '\u2A74',
-        coloneq: '\u2254',
-        comma: ',',
-        commat: '@',
-        comp: '\u2201',
-        compfn: '\u2218',
-        complement: '\u2201',
-        complexes: '\u2102',
-        cong: '\u2245',
-        congdot: '\u2A6D',
-        Congruent: '\u2261',
-        conint: '\u222E',
-        Conint: '\u222F',
-        ContourIntegral: '\u222E',
-        copf: '\uD835\uDD54',
-        Copf: '\u2102',
-        coprod: '\u2210',
-        Coproduct: '\u2210',
-        copy: '\xA9',
-        COPY: '\xA9',
-        copysr: '\u2117',
-        CounterClockwiseContourIntegral: '\u2233',
-        crarr: '\u21B5',
-        cross: '\u2717',
-        Cross: '\u2A2F',
-        cscr: '\uD835\uDCB8',
-        Cscr: '\uD835\uDC9E',
-        csub: '\u2ACF',
-        csube: '\u2AD1',
-        csup: '\u2AD0',
-        csupe: '\u2AD2',
-        ctdot: '\u22EF',
-        cudarrl: '\u2938',
-        cudarrr: '\u2935',
-        cuepr: '\u22DE',
-        cuesc: '\u22DF',
-        cularr: '\u21B6',
-        cularrp: '\u293D',
-        cup: '\u222A',
-        Cup: '\u22D3',
-        cupbrcap: '\u2A48',
-        cupcap: '\u2A46',
-        CupCap: '\u224D',
-        cupcup: '\u2A4A',
-        cupdot: '\u228D',
-        cupor: '\u2A45',
-        cups: '\u222A\uFE00',
-        curarr: '\u21B7',
-        curarrm: '\u293C',
-        curlyeqprec: '\u22DE',
-        curlyeqsucc: '\u22DF',
-        curlyvee: '\u22CE',
-        curlywedge: '\u22CF',
-        curren: '\xA4',
-        curvearrowleft: '\u21B6',
-        curvearrowright: '\u21B7',
-        cuvee: '\u22CE',
-        cuwed: '\u22CF',
-        cwconint: '\u2232',
-        cwint: '\u2231',
-        cylcty: '\u232D',
-        dagger: '\u2020',
-        Dagger: '\u2021',
-        daleth: '\u2138',
-        darr: '\u2193',
-        dArr: '\u21D3',
-        Darr: '\u21A1',
-        dash: '\u2010',
-        dashv: '\u22A3',
-        Dashv: '\u2AE4',
-        dbkarow: '\u290F',
-        dblac: '\u02DD',
-        dcaron: '\u010F',
-        Dcaron: '\u010E',
-        dcy: '\u0434',
-        Dcy: '\u0414',
-        dd: '\u2146',
-        DD: '\u2145',
-        ddagger: '\u2021',
-        ddarr: '\u21CA',
-        DDotrahd: '\u2911',
-        ddotseq: '\u2A77',
-        deg: '\xB0',
-        Del: '\u2207',
-        delta: '\u03B4',
-        Delta: '\u0394',
-        demptyv: '\u29B1',
-        dfisht: '\u297F',
-        dfr: '\uD835\uDD21',
-        Dfr: '\uD835\uDD07',
-        dHar: '\u2965',
-        dharl: '\u21C3',
-        dharr: '\u21C2',
-        DiacriticalAcute: '\xB4',
-        DiacriticalDot: '\u02D9',
-        DiacriticalDoubleAcute: '\u02DD',
-        DiacriticalGrave: '`',
-        DiacriticalTilde: '\u02DC',
-        diam: '\u22C4',
-        diamond: '\u22C4',
-        Diamond: '\u22C4',
-        diamondsuit: '\u2666',
-        diams: '\u2666',
-        die: '\xA8',
-        DifferentialD: '\u2146',
-        digamma: '\u03DD',
-        disin: '\u22F2',
-        div: '\xF7',
-        divide: '\xF7',
-        divideontimes: '\u22C7',
-        divonx: '\u22C7',
-        djcy: '\u0452',
-        DJcy: '\u0402',
-        dlcorn: '\u231E',
-        dlcrop: '\u230D',
-        dollar: '$',
-        dopf: '\uD835\uDD55',
-        Dopf: '\uD835\uDD3B',
-        dot: '\u02D9',
-        Dot: '\xA8',
-        DotDot: '\u20DC',
-        doteq: '\u2250',
-        doteqdot: '\u2251',
-        DotEqual: '\u2250',
-        dotminus: '\u2238',
-        dotplus: '\u2214',
-        dotsquare: '\u22A1',
-        doublebarwedge: '\u2306',
-        DoubleContourIntegral: '\u222F',
-        DoubleDot: '\xA8',
-        DoubleDownArrow: '\u21D3',
-        DoubleLeftArrow: '\u21D0',
-        DoubleLeftRightArrow: '\u21D4',
-        DoubleLeftTee: '\u2AE4',
-        DoubleLongLeftArrow: '\u27F8',
-        DoubleLongLeftRightArrow: '\u27FA',
-        DoubleLongRightArrow: '\u27F9',
-        DoubleRightArrow: '\u21D2',
-        DoubleRightTee: '\u22A8',
-        DoubleUpArrow: '\u21D1',
-        DoubleUpDownArrow: '\u21D5',
-        DoubleVerticalBar: '\u2225',
-        downarrow: '\u2193',
-        Downarrow: '\u21D3',
-        DownArrow: '\u2193',
-        DownArrowBar: '\u2913',
-        DownArrowUpArrow: '\u21F5',
-        DownBreve: '\u0311',
-        downdownarrows: '\u21CA',
-        downharpoonleft: '\u21C3',
-        downharpoonright: '\u21C2',
-        DownLeftRightVector: '\u2950',
-        DownLeftTeeVector: '\u295E',
-        DownLeftVector: '\u21BD',
-        DownLeftVectorBar: '\u2956',
-        DownRightTeeVector: '\u295F',
-        DownRightVector: '\u21C1',
-        DownRightVectorBar: '\u2957',
-        DownTee: '\u22A4',
-        DownTeeArrow: '\u21A7',
-        drbkarow: '\u2910',
-        drcorn: '\u231F',
-        drcrop: '\u230C',
-        dscr: '\uD835\uDCB9',
-        Dscr: '\uD835\uDC9F',
-        dscy: '\u0455',
-        DScy: '\u0405',
-        dsol: '\u29F6',
-        dstrok: '\u0111',
-        Dstrok: '\u0110',
-        dtdot: '\u22F1',
-        dtri: '\u25BF',
-        dtrif: '\u25BE',
-        duarr: '\u21F5',
-        duhar: '\u296F',
-        dwangle: '\u29A6',
-        dzcy: '\u045F',
-        DZcy: '\u040F',
-        dzigrarr: '\u27FF',
-        eacute: '\xE9',
-        Eacute: '\xC9',
-        easter: '\u2A6E',
-        ecaron: '\u011B',
-        Ecaron: '\u011A',
-        ecir: '\u2256',
-        ecirc: '\xEA',
-        Ecirc: '\xCA',
-        ecolon: '\u2255',
-        ecy: '\u044D',
-        Ecy: '\u042D',
-        eDDot: '\u2A77',
-        edot: '\u0117',
-        eDot: '\u2251',
-        Edot: '\u0116',
-        ee: '\u2147',
-        efDot: '\u2252',
-        efr: '\uD835\uDD22',
-        Efr: '\uD835\uDD08',
-        eg: '\u2A9A',
-        egrave: '\xE8',
-        Egrave: '\xC8',
-        egs: '\u2A96',
-        egsdot: '\u2A98',
-        el: '\u2A99',
-        Element: '\u2208',
-        elinters: '\u23E7',
-        ell: '\u2113',
-        els: '\u2A95',
-        elsdot: '\u2A97',
-        emacr: '\u0113',
-        Emacr: '\u0112',
-        empty: '\u2205',
-        emptyset: '\u2205',
-        EmptySmallSquare: '\u25FB',
-        emptyv: '\u2205',
-        EmptyVerySmallSquare: '\u25AB',
-        emsp: '\u2003',
-        emsp13: '\u2004',
-        emsp14: '\u2005',
-        eng: '\u014B',
-        ENG: '\u014A',
-        ensp: '\u2002',
-        eogon: '\u0119',
-        Eogon: '\u0118',
-        eopf: '\uD835\uDD56',
-        Eopf: '\uD835\uDD3C',
-        epar: '\u22D5',
-        eparsl: '\u29E3',
-        eplus: '\u2A71',
-        epsi: '\u03B5',
-        epsilon: '\u03B5',
-        Epsilon: '\u0395',
-        epsiv: '\u03F5',
-        eqcirc: '\u2256',
-        eqcolon: '\u2255',
-        eqsim: '\u2242',
-        eqslantgtr: '\u2A96',
-        eqslantless: '\u2A95',
-        Equal: '\u2A75',
-        equals: '=',
-        EqualTilde: '\u2242',
-        equest: '\u225F',
-        Equilibrium: '\u21CC',
-        equiv: '\u2261',
-        equivDD: '\u2A78',
-        eqvparsl: '\u29E5',
-        erarr: '\u2971',
-        erDot: '\u2253',
-        escr: '\u212F',
-        Escr: '\u2130',
-        esdot: '\u2250',
-        esim: '\u2242',
-        Esim: '\u2A73',
-        eta: '\u03B7',
-        Eta: '\u0397',
-        eth: '\xF0',
-        ETH: '\xD0',
-        euml: '\xEB',
-        Euml: '\xCB',
-        euro: '\u20AC',
-        excl: '!',
-        exist: '\u2203',
-        Exists: '\u2203',
-        expectation: '\u2130',
-        exponentiale: '\u2147',
-        ExponentialE: '\u2147',
-        fallingdotseq: '\u2252',
-        fcy: '\u0444',
-        Fcy: '\u0424',
-        female: '\u2640',
-        ffilig: '\uFB03',
-        fflig: '\uFB00',
-        ffllig: '\uFB04',
-        ffr: '\uD835\uDD23',
-        Ffr: '\uD835\uDD09',
-        filig: '\uFB01',
-        FilledSmallSquare: '\u25FC',
-        FilledVerySmallSquare: '\u25AA',
-        fjlig: 'fj',
-        flat: '\u266D',
-        fllig: '\uFB02',
-        fltns: '\u25B1',
-        fnof: '\u0192',
-        fopf: '\uD835\uDD57',
-        Fopf: '\uD835\uDD3D',
-        forall: '\u2200',
-        ForAll: '\u2200',
-        fork: '\u22D4',
-        forkv: '\u2AD9',
-        Fouriertrf: '\u2131',
-        fpartint: '\u2A0D',
-        frac12: '\xBD',
-        frac13: '\u2153',
-        frac14: '\xBC',
-        frac15: '\u2155',
-        frac16: '\u2159',
-        frac18: '\u215B',
-        frac23: '\u2154',
-        frac25: '\u2156',
-        frac34: '\xBE',
-        frac35: '\u2157',
-        frac38: '\u215C',
-        frac45: '\u2158',
-        frac56: '\u215A',
-        frac58: '\u215D',
-        frac78: '\u215E',
-        frasl: '\u2044',
-        frown: '\u2322',
-        fscr: '\uD835\uDCBB',
-        Fscr: '\u2131',
-        gacute: '\u01F5',
-        gamma: '\u03B3',
-        Gamma: '\u0393',
-        gammad: '\u03DD',
-        Gammad: '\u03DC',
-        gap: '\u2A86',
-        gbreve: '\u011F',
-        Gbreve: '\u011E',
-        Gcedil: '\u0122',
-        gcirc: '\u011D',
-        Gcirc: '\u011C',
-        gcy: '\u0433',
-        Gcy: '\u0413',
-        gdot: '\u0121',
-        Gdot: '\u0120',
-        ge: '\u2265',
-        gE: '\u2267',
-        gel: '\u22DB',
-        gEl: '\u2A8C',
-        geq: '\u2265',
-        geqq: '\u2267',
-        geqslant: '\u2A7E',
-        ges: '\u2A7E',
-        gescc: '\u2AA9',
-        gesdot: '\u2A80',
-        gesdoto: '\u2A82',
-        gesdotol: '\u2A84',
-        gesl: '\u22DB\uFE00',
-        gesles: '\u2A94',
-        gfr: '\uD835\uDD24',
-        Gfr: '\uD835\uDD0A',
-        gg: '\u226B',
-        Gg: '\u22D9',
-        ggg: '\u22D9',
-        gimel: '\u2137',
-        gjcy: '\u0453',
-        GJcy: '\u0403',
-        gl: '\u2277',
-        gla: '\u2AA5',
-        glE: '\u2A92',
-        glj: '\u2AA4',
-        gnap: '\u2A8A',
-        gnapprox: '\u2A8A',
-        gne: '\u2A88',
-        gnE: '\u2269',
-        gneq: '\u2A88',
-        gneqq: '\u2269',
-        gnsim: '\u22E7',
-        gopf: '\uD835\uDD58',
-        Gopf: '\uD835\uDD3E',
-        grave: '`',
-        GreaterEqual: '\u2265',
-        GreaterEqualLess: '\u22DB',
-        GreaterFullEqual: '\u2267',
-        GreaterGreater: '\u2AA2',
-        GreaterLess: '\u2277',
-        GreaterSlantEqual: '\u2A7E',
-        GreaterTilde: '\u2273',
-        gscr: '\u210A',
-        Gscr: '\uD835\uDCA2',
-        gsim: '\u2273',
-        gsime: '\u2A8E',
-        gsiml: '\u2A90',
-        gt: '>',
-        Gt: '\u226B',
-        GT: '>',
-        gtcc: '\u2AA7',
-        gtcir: '\u2A7A',
-        gtdot: '\u22D7',
-        gtlPar: '\u2995',
-        gtquest: '\u2A7C',
-        gtrapprox: '\u2A86',
-        gtrarr: '\u2978',
-        gtrdot: '\u22D7',
-        gtreqless: '\u22DB',
-        gtreqqless: '\u2A8C',
-        gtrless: '\u2277',
-        gtrsim: '\u2273',
-        gvertneqq: '\u2269\uFE00',
-        gvnE: '\u2269\uFE00',
-        Hacek: '\u02C7',
-        hairsp: '\u200A',
-        half: '\xBD',
-        hamilt: '\u210B',
-        hardcy: '\u044A',
-        HARDcy: '\u042A',
-        harr: '\u2194',
-        hArr: '\u21D4',
-        harrcir: '\u2948',
-        harrw: '\u21AD',
-        Hat: '^',
-        hbar: '\u210F',
-        hcirc: '\u0125',
-        Hcirc: '\u0124',
-        hearts: '\u2665',
-        heartsuit: '\u2665',
-        hellip: '\u2026',
-        hercon: '\u22B9',
-        hfr: '\uD835\uDD25',
-        Hfr: '\u210C',
-        HilbertSpace: '\u210B',
-        hksearow: '\u2925',
-        hkswarow: '\u2926',
-        hoarr: '\u21FF',
-        homtht: '\u223B',
-        hookleftarrow: '\u21A9',
-        hookrightarrow: '\u21AA',
-        hopf: '\uD835\uDD59',
-        Hopf: '\u210D',
-        horbar: '\u2015',
-        HorizontalLine: '\u2500',
-        hscr: '\uD835\uDCBD',
-        Hscr: '\u210B',
-        hslash: '\u210F',
-        hstrok: '\u0127',
-        Hstrok: '\u0126',
-        HumpDownHump: '\u224E',
-        HumpEqual: '\u224F',
-        hybull: '\u2043',
-        hyphen: '\u2010',
-        iacute: '\xED',
-        Iacute: '\xCD',
-        ic: '\u2063',
-        icirc: '\xEE',
-        Icirc: '\xCE',
-        icy: '\u0438',
-        Icy: '\u0418',
-        Idot: '\u0130',
-        iecy: '\u0435',
-        IEcy: '\u0415',
-        iexcl: '\xA1',
-        iff: '\u21D4',
-        ifr: '\uD835\uDD26',
-        Ifr: '\u2111',
-        igrave: '\xEC',
-        Igrave: '\xCC',
-        ii: '\u2148',
-        iiiint: '\u2A0C',
-        iiint: '\u222D',
-        iinfin: '\u29DC',
-        iiota: '\u2129',
-        ijlig: '\u0133',
-        IJlig: '\u0132',
-        Im: '\u2111',
-        imacr: '\u012B',
-        Imacr: '\u012A',
-        image: '\u2111',
-        ImaginaryI: '\u2148',
-        imagline: '\u2110',
-        imagpart: '\u2111',
-        imath: '\u0131',
-        imof: '\u22B7',
-        imped: '\u01B5',
-        Implies: '\u21D2',
-        in: '\u2208',
-        incare: '\u2105',
-        infin: '\u221E',
-        infintie: '\u29DD',
-        inodot: '\u0131',
-        int: '\u222B',
-        Int: '\u222C',
-        intcal: '\u22BA',
-        integers: '\u2124',
-        Integral: '\u222B',
-        intercal: '\u22BA',
-        Intersection: '\u22C2',
-        intlarhk: '\u2A17',
-        intprod: '\u2A3C',
-        InvisibleComma: '\u2063',
-        InvisibleTimes: '\u2062',
-        iocy: '\u0451',
-        IOcy: '\u0401',
-        iogon: '\u012F',
-        Iogon: '\u012E',
-        iopf: '\uD835\uDD5A',
-        Iopf: '\uD835\uDD40',
-        iota: '\u03B9',
-        Iota: '\u0399',
-        iprod: '\u2A3C',
-        iquest: '\xBF',
-        iscr: '\uD835\uDCBE',
-        Iscr: '\u2110',
-        isin: '\u2208',
-        isindot: '\u22F5',
-        isinE: '\u22F9',
-        isins: '\u22F4',
-        isinsv: '\u22F3',
-        isinv: '\u2208',
-        it: '\u2062',
-        itilde: '\u0129',
-        Itilde: '\u0128',
-        iukcy: '\u0456',
-        Iukcy: '\u0406',
-        iuml: '\xEF',
-        Iuml: '\xCF',
-        jcirc: '\u0135',
-        Jcirc: '\u0134',
-        jcy: '\u0439',
-        Jcy: '\u0419',
-        jfr: '\uD835\uDD27',
-        Jfr: '\uD835\uDD0D',
-        jmath: '\u0237',
-        jopf: '\uD835\uDD5B',
-        Jopf: '\uD835\uDD41',
-        jscr: '\uD835\uDCBF',
-        Jscr: '\uD835\uDCA5',
-        jsercy: '\u0458',
-        Jsercy: '\u0408',
-        jukcy: '\u0454',
-        Jukcy: '\u0404',
-        kappa: '\u03BA',
-        Kappa: '\u039A',
-        kappav: '\u03F0',
-        kcedil: '\u0137',
-        Kcedil: '\u0136',
-        kcy: '\u043A',
-        Kcy: '\u041A',
-        kfr: '\uD835\uDD28',
-        Kfr: '\uD835\uDD0E',
-        kgreen: '\u0138',
-        khcy: '\u0445',
-        KHcy: '\u0425',
-        kjcy: '\u045C',
-        KJcy: '\u040C',
-        kopf: '\uD835\uDD5C',
-        Kopf: '\uD835\uDD42',
-        kscr: '\uD835\uDCC0',
-        Kscr: '\uD835\uDCA6',
-        lAarr: '\u21DA',
-        lacute: '\u013A',
-        Lacute: '\u0139',
-        laemptyv: '\u29B4',
-        lagran: '\u2112',
-        lambda: '\u03BB',
-        Lambda: '\u039B',
-        lang: '\u27E8',
-        Lang: '\u27EA',
-        langd: '\u2991',
-        langle: '\u27E8',
-        lap: '\u2A85',
-        Laplacetrf: '\u2112',
-        laquo: '\xAB',
-        larr: '\u2190',
-        lArr: '\u21D0',
-        Larr: '\u219E',
-        larrb: '\u21E4',
-        larrbfs: '\u291F',
-        larrfs: '\u291D',
-        larrhk: '\u21A9',
-        larrlp: '\u21AB',
-        larrpl: '\u2939',
-        larrsim: '\u2973',
-        larrtl: '\u21A2',
-        lat: '\u2AAB',
-        latail: '\u2919',
-        lAtail: '\u291B',
-        late: '\u2AAD',
-        lates: '\u2AAD\uFE00',
-        lbarr: '\u290C',
-        lBarr: '\u290E',
-        lbbrk: '\u2772',
-        lbrace: '{',
-        lbrack: '[',
-        lbrke: '\u298B',
-        lbrksld: '\u298F',
-        lbrkslu: '\u298D',
-        lcaron: '\u013E',
-        Lcaron: '\u013D',
-        lcedil: '\u013C',
-        Lcedil: '\u013B',
-        lceil: '\u2308',
-        lcub: '{',
-        lcy: '\u043B',
-        Lcy: '\u041B',
-        ldca: '\u2936',
-        ldquo: '\u201C',
-        ldquor: '\u201E',
-        ldrdhar: '\u2967',
-        ldrushar: '\u294B',
-        ldsh: '\u21B2',
-        le: '\u2264',
-        lE: '\u2266',
-        LeftAngleBracket: '\u27E8',
-        leftarrow: '\u2190',
-        Leftarrow: '\u21D0',
-        LeftArrow: '\u2190',
-        LeftArrowBar: '\u21E4',
-        LeftArrowRightArrow: '\u21C6',
-        leftarrowtail: '\u21A2',
-        LeftCeiling: '\u2308',
-        LeftDoubleBracket: '\u27E6',
-        LeftDownTeeVector: '\u2961',
-        LeftDownVector: '\u21C3',
-        LeftDownVectorBar: '\u2959',
-        LeftFloor: '\u230A',
-        leftharpoondown: '\u21BD',
-        leftharpoonup: '\u21BC',
-        leftleftarrows: '\u21C7',
-        leftrightarrow: '\u2194',
-        Leftrightarrow: '\u21D4',
-        LeftRightArrow: '\u2194',
-        leftrightarrows: '\u21C6',
-        leftrightharpoons: '\u21CB',
-        leftrightsquigarrow: '\u21AD',
-        LeftRightVector: '\u294E',
-        LeftTee: '\u22A3',
-        LeftTeeArrow: '\u21A4',
-        LeftTeeVector: '\u295A',
-        leftthreetimes: '\u22CB',
-        LeftTriangle: '\u22B2',
-        LeftTriangleBar: '\u29CF',
-        LeftTriangleEqual: '\u22B4',
-        LeftUpDownVector: '\u2951',
-        LeftUpTeeVector: '\u2960',
-        LeftUpVector: '\u21BF',
-        LeftUpVectorBar: '\u2958',
-        LeftVector: '\u21BC',
-        LeftVectorBar: '\u2952',
-        leg: '\u22DA',
-        lEg: '\u2A8B',
-        leq: '\u2264',
-        leqq: '\u2266',
-        leqslant: '\u2A7D',
-        les: '\u2A7D',
-        lescc: '\u2AA8',
-        lesdot: '\u2A7F',
-        lesdoto: '\u2A81',
-        lesdotor: '\u2A83',
-        lesg: '\u22DA\uFE00',
-        lesges: '\u2A93',
-        lessapprox: '\u2A85',
-        lessdot: '\u22D6',
-        lesseqgtr: '\u22DA',
-        lesseqqgtr: '\u2A8B',
-        LessEqualGreater: '\u22DA',
-        LessFullEqual: '\u2266',
-        LessGreater: '\u2276',
-        lessgtr: '\u2276',
-        LessLess: '\u2AA1',
-        lesssim: '\u2272',
-        LessSlantEqual: '\u2A7D',
-        LessTilde: '\u2272',
-        lfisht: '\u297C',
-        lfloor: '\u230A',
-        lfr: '\uD835\uDD29',
-        Lfr: '\uD835\uDD0F',
-        lg: '\u2276',
-        lgE: '\u2A91',
-        lHar: '\u2962',
-        lhard: '\u21BD',
-        lharu: '\u21BC',
-        lharul: '\u296A',
-        lhblk: '\u2584',
-        ljcy: '\u0459',
-        LJcy: '\u0409',
-        ll: '\u226A',
-        Ll: '\u22D8',
-        llarr: '\u21C7',
-        llcorner: '\u231E',
-        Lleftarrow: '\u21DA',
-        llhard: '\u296B',
-        lltri: '\u25FA',
-        lmidot: '\u0140',
-        Lmidot: '\u013F',
-        lmoust: '\u23B0',
-        lmoustache: '\u23B0',
-        lnap: '\u2A89',
-        lnapprox: '\u2A89',
-        lne: '\u2A87',
-        lnE: '\u2268',
-        lneq: '\u2A87',
-        lneqq: '\u2268',
-        lnsim: '\u22E6',
-        loang: '\u27EC',
-        loarr: '\u21FD',
-        lobrk: '\u27E6',
-        longleftarrow: '\u27F5',
-        Longleftarrow: '\u27F8',
-        LongLeftArrow: '\u27F5',
-        longleftrightarrow: '\u27F7',
-        Longleftrightarrow: '\u27FA',
-        LongLeftRightArrow: '\u27F7',
-        longmapsto: '\u27FC',
-        longrightarrow: '\u27F6',
-        Longrightarrow: '\u27F9',
-        LongRightArrow: '\u27F6',
-        looparrowleft: '\u21AB',
-        looparrowright: '\u21AC',
-        lopar: '\u2985',
-        lopf: '\uD835\uDD5D',
-        Lopf: '\uD835\uDD43',
-        loplus: '\u2A2D',
-        lotimes: '\u2A34',
-        lowast: '\u2217',
-        lowbar: '_',
-        LowerLeftArrow: '\u2199',
-        LowerRightArrow: '\u2198',
-        loz: '\u25CA',
-        lozenge: '\u25CA',
-        lozf: '\u29EB',
-        lpar: '(',
-        lparlt: '\u2993',
-        lrarr: '\u21C6',
-        lrcorner: '\u231F',
-        lrhar: '\u21CB',
-        lrhard: '\u296D',
-        lrm: '\u200E',
-        lrtri: '\u22BF',
-        lsaquo: '\u2039',
-        lscr: '\uD835\uDCC1',
-        Lscr: '\u2112',
-        lsh: '\u21B0',
-        Lsh: '\u21B0',
-        lsim: '\u2272',
-        lsime: '\u2A8D',
-        lsimg: '\u2A8F',
-        lsqb: '[',
-        lsquo: '\u2018',
-        lsquor: '\u201A',
-        lstrok: '\u0142',
-        Lstrok: '\u0141',
-        lt: '<',
-        Lt: '\u226A',
-        LT: '<',
-        ltcc: '\u2AA6',
-        ltcir: '\u2A79',
-        ltdot: '\u22D6',
-        lthree: '\u22CB',
-        ltimes: '\u22C9',
-        ltlarr: '\u2976',
-        ltquest: '\u2A7B',
-        ltri: '\u25C3',
-        ltrie: '\u22B4',
-        ltrif: '\u25C2',
-        ltrPar: '\u2996',
-        lurdshar: '\u294A',
-        luruhar: '\u2966',
-        lvertneqq: '\u2268\uFE00',
-        lvnE: '\u2268\uFE00',
-        macr: '\xAF',
-        male: '\u2642',
-        malt: '\u2720',
-        maltese: '\u2720',
-        map: '\u21A6',
-        Map: '\u2905',
-        mapsto: '\u21A6',
-        mapstodown: '\u21A7',
-        mapstoleft: '\u21A4',
-        mapstoup: '\u21A5',
-        marker: '\u25AE',
-        mcomma: '\u2A29',
-        mcy: '\u043C',
-        Mcy: '\u041C',
-        mdash: '\u2014',
-        mDDot: '\u223A',
-        measuredangle: '\u2221',
-        MediumSpace: '\u205F',
-        Mellintrf: '\u2133',
-        mfr: '\uD835\uDD2A',
-        Mfr: '\uD835\uDD10',
-        mho: '\u2127',
-        micro: '\xB5',
-        mid: '\u2223',
-        midast: '*',
-        midcir: '\u2AF0',
-        middot: '\xB7',
-        minus: '\u2212',
-        minusb: '\u229F',
-        minusd: '\u2238',
-        minusdu: '\u2A2A',
-        MinusPlus: '\u2213',
-        mlcp: '\u2ADB',
-        mldr: '\u2026',
-        mnplus: '\u2213',
-        models: '\u22A7',
-        mopf: '\uD835\uDD5E',
-        Mopf: '\uD835\uDD44',
-        mp: '\u2213',
-        mscr: '\uD835\uDCC2',
-        Mscr: '\u2133',
-        mstpos: '\u223E',
-        mu: '\u03BC',
-        Mu: '\u039C',
-        multimap: '\u22B8',
-        mumap: '\u22B8',
-        nabla: '\u2207',
-        nacute: '\u0144',
-        Nacute: '\u0143',
-        nang: '\u2220\u20D2',
-        nap: '\u2249',
-        napE: '\u2A70\u0338',
-        napid: '\u224B\u0338',
-        napos: '\u0149',
-        napprox: '\u2249',
-        natur: '\u266E',
-        natural: '\u266E',
-        naturals: '\u2115',
-        nbsp: '\xA0',
-        nbump: '\u224E\u0338',
-        nbumpe: '\u224F\u0338',
-        ncap: '\u2A43',
-        ncaron: '\u0148',
-        Ncaron: '\u0147',
-        ncedil: '\u0146',
-        Ncedil: '\u0145',
-        ncong: '\u2247',
-        ncongdot: '\u2A6D\u0338',
-        ncup: '\u2A42',
-        ncy: '\u043D',
-        Ncy: '\u041D',
-        ndash: '\u2013',
-        ne: '\u2260',
-        nearhk: '\u2924',
-        nearr: '\u2197',
-        neArr: '\u21D7',
-        nearrow: '\u2197',
-        nedot: '\u2250\u0338',
-        NegativeMediumSpace: '\u200B',
-        NegativeThickSpace: '\u200B',
-        NegativeThinSpace: '\u200B',
-        NegativeVeryThinSpace: '\u200B',
-        nequiv: '\u2262',
-        nesear: '\u2928',
-        nesim: '\u2242\u0338',
-        NestedGreaterGreater: '\u226B',
-        NestedLessLess: '\u226A',
-        NewLine: '\n',
-        nexist: '\u2204',
-        nexists: '\u2204',
-        nfr: '\uD835\uDD2B',
-        Nfr: '\uD835\uDD11',
-        nge: '\u2271',
-        ngE: '\u2267\u0338',
-        ngeq: '\u2271',
-        ngeqq: '\u2267\u0338',
-        ngeqslant: '\u2A7E\u0338',
-        nges: '\u2A7E\u0338',
-        nGg: '\u22D9\u0338',
-        ngsim: '\u2275',
-        ngt: '\u226F',
-        nGt: '\u226B\u20D2',
-        ngtr: '\u226F',
-        nGtv: '\u226B\u0338',
-        nharr: '\u21AE',
-        nhArr: '\u21CE',
-        nhpar: '\u2AF2',
-        ni: '\u220B',
-        nis: '\u22FC',
-        nisd: '\u22FA',
-        niv: '\u220B',
-        njcy: '\u045A',
-        NJcy: '\u040A',
-        nlarr: '\u219A',
-        nlArr: '\u21CD',
-        nldr: '\u2025',
-        nle: '\u2270',
-        nlE: '\u2266\u0338',
-        nleftarrow: '\u219A',
-        nLeftarrow: '\u21CD',
-        nleftrightarrow: '\u21AE',
-        nLeftrightarrow: '\u21CE',
-        nleq: '\u2270',
-        nleqq: '\u2266\u0338',
-        nleqslant: '\u2A7D\u0338',
-        nles: '\u2A7D\u0338',
-        nless: '\u226E',
-        nLl: '\u22D8\u0338',
-        nlsim: '\u2274',
-        nlt: '\u226E',
-        nLt: '\u226A\u20D2',
-        nltri: '\u22EA',
-        nltrie: '\u22EC',
-        nLtv: '\u226A\u0338',
-        nmid: '\u2224',
-        NoBreak: '\u2060',
-        NonBreakingSpace: '\xA0',
-        nopf: '\uD835\uDD5F',
-        Nopf: '\u2115',
-        not: '\xAC',
-        Not: '\u2AEC',
-        NotCongruent: '\u2262',
-        NotCupCap: '\u226D',
-        NotDoubleVerticalBar: '\u2226',
-        NotElement: '\u2209',
-        NotEqual: '\u2260',
-        NotEqualTilde: '\u2242\u0338',
-        NotExists: '\u2204',
-        NotGreater: '\u226F',
-        NotGreaterEqual: '\u2271',
-        NotGreaterFullEqual: '\u2267\u0338',
-        NotGreaterGreater: '\u226B\u0338',
-        NotGreaterLess: '\u2279',
-        NotGreaterSlantEqual: '\u2A7E\u0338',
-        NotGreaterTilde: '\u2275',
-        NotHumpDownHump: '\u224E\u0338',
-        NotHumpEqual: '\u224F\u0338',
-        notin: '\u2209',
-        notindot: '\u22F5\u0338',
-        notinE: '\u22F9\u0338',
-        notinva: '\u2209',
-        notinvb: '\u22F7',
-        notinvc: '\u22F6',
-        NotLeftTriangle: '\u22EA',
-        NotLeftTriangleBar: '\u29CF\u0338',
-        NotLeftTriangleEqual: '\u22EC',
-        NotLess: '\u226E',
-        NotLessEqual: '\u2270',
-        NotLessGreater: '\u2278',
-        NotLessLess: '\u226A\u0338',
-        NotLessSlantEqual: '\u2A7D\u0338',
-        NotLessTilde: '\u2274',
-        NotNestedGreaterGreater: '\u2AA2\u0338',
-        NotNestedLessLess: '\u2AA1\u0338',
-        notni: '\u220C',
-        notniva: '\u220C',
-        notnivb: '\u22FE',
-        notnivc: '\u22FD',
-        NotPrecedes: '\u2280',
-        NotPrecedesEqual: '\u2AAF\u0338',
-        NotPrecedesSlantEqual: '\u22E0',
-        NotReverseElement: '\u220C',
-        NotRightTriangle: '\u22EB',
-        NotRightTriangleBar: '\u29D0\u0338',
-        NotRightTriangleEqual: '\u22ED',
-        NotSquareSubset: '\u228F\u0338',
-        NotSquareSubsetEqual: '\u22E2',
-        NotSquareSuperset: '\u2290\u0338',
-        NotSquareSupersetEqual: '\u22E3',
-        NotSubset: '\u2282\u20D2',
-        NotSubsetEqual: '\u2288',
-        NotSucceeds: '\u2281',
-        NotSucceedsEqual: '\u2AB0\u0338',
-        NotSucceedsSlantEqual: '\u22E1',
-        NotSucceedsTilde: '\u227F\u0338',
-        NotSuperset: '\u2283\u20D2',
-        NotSupersetEqual: '\u2289',
-        NotTilde: '\u2241',
-        NotTildeEqual: '\u2244',
-        NotTildeFullEqual: '\u2247',
-        NotTildeTilde: '\u2249',
-        NotVerticalBar: '\u2224',
-        npar: '\u2226',
-        nparallel: '\u2226',
-        nparsl: '\u2AFD\u20E5',
-        npart: '\u2202\u0338',
-        npolint: '\u2A14',
-        npr: '\u2280',
-        nprcue: '\u22E0',
-        npre: '\u2AAF\u0338',
-        nprec: '\u2280',
-        npreceq: '\u2AAF\u0338',
-        nrarr: '\u219B',
-        nrArr: '\u21CF',
-        nrarrc: '\u2933\u0338',
-        nrarrw: '\u219D\u0338',
-        nrightarrow: '\u219B',
-        nRightarrow: '\u21CF',
-        nrtri: '\u22EB',
-        nrtrie: '\u22ED',
-        nsc: '\u2281',
-        nsccue: '\u22E1',
-        nsce: '\u2AB0\u0338',
-        nscr: '\uD835\uDCC3',
-        Nscr: '\uD835\uDCA9',
-        nshortmid: '\u2224',
-        nshortparallel: '\u2226',
-        nsim: '\u2241',
-        nsime: '\u2244',
-        nsimeq: '\u2244',
-        nsmid: '\u2224',
-        nspar: '\u2226',
-        nsqsube: '\u22E2',
-        nsqsupe: '\u22E3',
-        nsub: '\u2284',
-        nsube: '\u2288',
-        nsubE: '\u2AC5\u0338',
-        nsubset: '\u2282\u20D2',
-        nsubseteq: '\u2288',
-        nsubseteqq: '\u2AC5\u0338',
-        nsucc: '\u2281',
-        nsucceq: '\u2AB0\u0338',
-        nsup: '\u2285',
-        nsupe: '\u2289',
-        nsupE: '\u2AC6\u0338',
-        nsupset: '\u2283\u20D2',
-        nsupseteq: '\u2289',
-        nsupseteqq: '\u2AC6\u0338',
-        ntgl: '\u2279',
-        ntilde: '\xF1',
-        Ntilde: '\xD1',
-        ntlg: '\u2278',
-        ntriangleleft: '\u22EA',
-        ntrianglelefteq: '\u22EC',
-        ntriangleright: '\u22EB',
-        ntrianglerighteq: '\u22ED',
-        nu: '\u03BD',
-        Nu: '\u039D',
-        num: '#',
-        numero: '\u2116',
-        numsp: '\u2007',
-        nvap: '\u224D\u20D2',
-        nvdash: '\u22AC',
-        nvDash: '\u22AD',
-        nVdash: '\u22AE',
-        nVDash: '\u22AF',
-        nvge: '\u2265\u20D2',
-        nvgt: '>\u20D2',
-        nvHarr: '\u2904',
-        nvinfin: '\u29DE',
-        nvlArr: '\u2902',
-        nvle: '\u2264\u20D2',
-        nvlt: '<\u20D2',
-        nvltrie: '\u22B4\u20D2',
-        nvrArr: '\u2903',
-        nvrtrie: '\u22B5\u20D2',
-        nvsim: '\u223C\u20D2',
-        nwarhk: '\u2923',
-        nwarr: '\u2196',
-        nwArr: '\u21D6',
-        nwarrow: '\u2196',
-        nwnear: '\u2927',
-        oacute: '\xF3',
-        Oacute: '\xD3',
-        oast: '\u229B',
-        ocir: '\u229A',
-        ocirc: '\xF4',
-        Ocirc: '\xD4',
-        ocy: '\u043E',
-        Ocy: '\u041E',
-        odash: '\u229D',
-        odblac: '\u0151',
-        Odblac: '\u0150',
-        odiv: '\u2A38',
-        odot: '\u2299',
-        odsold: '\u29BC',
-        oelig: '\u0153',
-        OElig: '\u0152',
-        ofcir: '\u29BF',
-        ofr: '\uD835\uDD2C',
-        Ofr: '\uD835\uDD12',
-        ogon: '\u02DB',
-        ograve: '\xF2',
-        Ograve: '\xD2',
-        ogt: '\u29C1',
-        ohbar: '\u29B5',
-        ohm: '\u03A9',
-        oint: '\u222E',
-        olarr: '\u21BA',
-        olcir: '\u29BE',
-        olcross: '\u29BB',
-        oline: '\u203E',
-        olt: '\u29C0',
-        omacr: '\u014D',
-        Omacr: '\u014C',
-        omega: '\u03C9',
-        Omega: '\u03A9',
-        omicron: '\u03BF',
-        Omicron: '\u039F',
-        omid: '\u29B6',
-        ominus: '\u2296',
-        oopf: '\uD835\uDD60',
-        Oopf: '\uD835\uDD46',
-        opar: '\u29B7',
-        OpenCurlyDoubleQuote: '\u201C',
-        OpenCurlyQuote: '\u2018',
-        operp: '\u29B9',
-        oplus: '\u2295',
-        or: '\u2228',
-        Or: '\u2A54',
-        orarr: '\u21BB',
-        ord: '\u2A5D',
-        order: '\u2134',
-        orderof: '\u2134',
-        ordf: '\xAA',
-        ordm: '\xBA',
-        origof: '\u22B6',
-        oror: '\u2A56',
-        orslope: '\u2A57',
-        orv: '\u2A5B',
-        oS: '\u24C8',
-        oscr: '\u2134',
-        Oscr: '\uD835\uDCAA',
-        oslash: '\xF8',
-        Oslash: '\xD8',
-        osol: '\u2298',
-        otilde: '\xF5',
-        Otilde: '\xD5',
-        otimes: '\u2297',
-        Otimes: '\u2A37',
-        otimesas: '\u2A36',
-        ouml: '\xF6',
-        Ouml: '\xD6',
-        ovbar: '\u233D',
-        OverBar: '\u203E',
-        OverBrace: '\u23DE',
-        OverBracket: '\u23B4',
-        OverParenthesis: '\u23DC',
-        par: '\u2225',
-        para: '\xB6',
-        parallel: '\u2225',
-        parsim: '\u2AF3',
-        parsl: '\u2AFD',
-        part: '\u2202',
-        PartialD: '\u2202',
-        pcy: '\u043F',
-        Pcy: '\u041F',
-        percnt: '%',
-        period: '.',
-        permil: '\u2030',
-        perp: '\u22A5',
-        pertenk: '\u2031',
-        pfr: '\uD835\uDD2D',
-        Pfr: '\uD835\uDD13',
-        phi: '\u03C6',
-        Phi: '\u03A6',
-        phiv: '\u03D5',
-        phmmat: '\u2133',
-        phone: '\u260E',
-        pi: '\u03C0',
-        Pi: '\u03A0',
-        pitchfork: '\u22D4',
-        piv: '\u03D6',
-        planck: '\u210F',
-        planckh: '\u210E',
-        plankv: '\u210F',
-        plus: '+',
-        plusacir: '\u2A23',
-        plusb: '\u229E',
-        pluscir: '\u2A22',
-        plusdo: '\u2214',
-        plusdu: '\u2A25',
-        pluse: '\u2A72',
-        PlusMinus: '\xB1',
-        plusmn: '\xB1',
-        plussim: '\u2A26',
-        plustwo: '\u2A27',
-        pm: '\xB1',
-        Poincareplane: '\u210C',
-        pointint: '\u2A15',
-        popf: '\uD835\uDD61',
-        Popf: '\u2119',
-        pound: '\xA3',
-        pr: '\u227A',
-        Pr: '\u2ABB',
-        prap: '\u2AB7',
-        prcue: '\u227C',
-        pre: '\u2AAF',
-        prE: '\u2AB3',
-        prec: '\u227A',
-        precapprox: '\u2AB7',
-        preccurlyeq: '\u227C',
-        Precedes: '\u227A',
-        PrecedesEqual: '\u2AAF',
-        PrecedesSlantEqual: '\u227C',
-        PrecedesTilde: '\u227E',
-        preceq: '\u2AAF',
-        precnapprox: '\u2AB9',
-        precneqq: '\u2AB5',
-        precnsim: '\u22E8',
-        precsim: '\u227E',
-        prime: '\u2032',
-        Prime: '\u2033',
-        primes: '\u2119',
-        prnap: '\u2AB9',
-        prnE: '\u2AB5',
-        prnsim: '\u22E8',
-        prod: '\u220F',
-        Product: '\u220F',
-        profalar: '\u232E',
-        profline: '\u2312',
-        profsurf: '\u2313',
-        prop: '\u221D',
-        Proportion: '\u2237',
-        Proportional: '\u221D',
-        propto: '\u221D',
-        prsim: '\u227E',
-        prurel: '\u22B0',
-        pscr: '\uD835\uDCC5',
-        Pscr: '\uD835\uDCAB',
-        psi: '\u03C8',
-        Psi: '\u03A8',
-        puncsp: '\u2008',
-        qfr: '\uD835\uDD2E',
-        Qfr: '\uD835\uDD14',
-        qint: '\u2A0C',
-        qopf: '\uD835\uDD62',
-        Qopf: '\u211A',
-        qprime: '\u2057',
-        qscr: '\uD835\uDCC6',
-        Qscr: '\uD835\uDCAC',
-        quaternions: '\u210D',
-        quatint: '\u2A16',
-        quest: '?',
-        questeq: '\u225F',
-        quot: '"',
-        QUOT: '"',
-        rAarr: '\u21DB',
-        race: '\u223D\u0331',
-        racute: '\u0155',
-        Racute: '\u0154',
-        radic: '\u221A',
-        raemptyv: '\u29B3',
-        rang: '\u27E9',
-        Rang: '\u27EB',
-        rangd: '\u2992',
-        range: '\u29A5',
-        rangle: '\u27E9',
-        raquo: '\xBB',
-        rarr: '\u2192',
-        rArr: '\u21D2',
-        Rarr: '\u21A0',
-        rarrap: '\u2975',
-        rarrb: '\u21E5',
-        rarrbfs: '\u2920',
-        rarrc: '\u2933',
-        rarrfs: '\u291E',
-        rarrhk: '\u21AA',
-        rarrlp: '\u21AC',
-        rarrpl: '\u2945',
-        rarrsim: '\u2974',
-        rarrtl: '\u21A3',
-        Rarrtl: '\u2916',
-        rarrw: '\u219D',
-        ratail: '\u291A',
-        rAtail: '\u291C',
-        ratio: '\u2236',
-        rationals: '\u211A',
-        rbarr: '\u290D',
-        rBarr: '\u290F',
-        RBarr: '\u2910',
-        rbbrk: '\u2773',
-        rbrace: '}',
-        rbrack: ']',
-        rbrke: '\u298C',
-        rbrksld: '\u298E',
-        rbrkslu: '\u2990',
-        rcaron: '\u0159',
-        Rcaron: '\u0158',
-        rcedil: '\u0157',
-        Rcedil: '\u0156',
-        rceil: '\u2309',
-        rcub: '}',
-        rcy: '\u0440',
-        Rcy: '\u0420',
-        rdca: '\u2937',
-        rdldhar: '\u2969',
-        rdquo: '\u201D',
-        rdquor: '\u201D',
-        rdsh: '\u21B3',
-        Re: '\u211C',
-        real: '\u211C',
-        realine: '\u211B',
-        realpart: '\u211C',
-        reals: '\u211D',
-        rect: '\u25AD',
-        reg: '\xAE',
-        REG: '\xAE',
-        ReverseElement: '\u220B',
-        ReverseEquilibrium: '\u21CB',
-        ReverseUpEquilibrium: '\u296F',
-        rfisht: '\u297D',
-        rfloor: '\u230B',
-        rfr: '\uD835\uDD2F',
-        Rfr: '\u211C',
-        rHar: '\u2964',
-        rhard: '\u21C1',
-        rharu: '\u21C0',
-        rharul: '\u296C',
-        rho: '\u03C1',
-        Rho: '\u03A1',
-        rhov: '\u03F1',
-        RightAngleBracket: '\u27E9',
-        rightarrow: '\u2192',
-        Rightarrow: '\u21D2',
-        RightArrow: '\u2192',
-        RightArrowBar: '\u21E5',
-        RightArrowLeftArrow: '\u21C4',
-        rightarrowtail: '\u21A3',
-        RightCeiling: '\u2309',
-        RightDoubleBracket: '\u27E7',
-        RightDownTeeVector: '\u295D',
-        RightDownVector: '\u21C2',
-        RightDownVectorBar: '\u2955',
-        RightFloor: '\u230B',
-        rightharpoondown: '\u21C1',
-        rightharpoonup: '\u21C0',
-        rightleftarrows: '\u21C4',
-        rightleftharpoons: '\u21CC',
-        rightrightarrows: '\u21C9',
-        rightsquigarrow: '\u219D',
-        RightTee: '\u22A2',
-        RightTeeArrow: '\u21A6',
-        RightTeeVector: '\u295B',
-        rightthreetimes: '\u22CC',
-        RightTriangle: '\u22B3',
-        RightTriangleBar: '\u29D0',
-        RightTriangleEqual: '\u22B5',
-        RightUpDownVector: '\u294F',
-        RightUpTeeVector: '\u295C',
-        RightUpVector: '\u21BE',
-        RightUpVectorBar: '\u2954',
-        RightVector: '\u21C0',
-        RightVectorBar: '\u2953',
-        ring: '\u02DA',
-        risingdotseq: '\u2253',
-        rlarr: '\u21C4',
-        rlhar: '\u21CC',
-        rlm: '\u200F',
-        rmoust: '\u23B1',
-        rmoustache: '\u23B1',
-        rnmid: '\u2AEE',
-        roang: '\u27ED',
-        roarr: '\u21FE',
-        robrk: '\u27E7',
-        ropar: '\u2986',
-        ropf: '\uD835\uDD63',
-        Ropf: '\u211D',
-        roplus: '\u2A2E',
-        rotimes: '\u2A35',
-        RoundImplies: '\u2970',
-        rpar: ')',
-        rpargt: '\u2994',
-        rppolint: '\u2A12',
-        rrarr: '\u21C9',
-        Rrightarrow: '\u21DB',
-        rsaquo: '\u203A',
-        rscr: '\uD835\uDCC7',
-        Rscr: '\u211B',
-        rsh: '\u21B1',
-        Rsh: '\u21B1',
-        rsqb: ']',
-        rsquo: '\u2019',
-        rsquor: '\u2019',
-        rthree: '\u22CC',
-        rtimes: '\u22CA',
-        rtri: '\u25B9',
-        rtrie: '\u22B5',
-        rtrif: '\u25B8',
-        rtriltri: '\u29CE',
-        RuleDelayed: '\u29F4',
-        ruluhar: '\u2968',
-        rx: '\u211E',
-        sacute: '\u015B',
-        Sacute: '\u015A',
-        sbquo: '\u201A',
-        sc: '\u227B',
-        Sc: '\u2ABC',
-        scap: '\u2AB8',
-        scaron: '\u0161',
-        Scaron: '\u0160',
-        sccue: '\u227D',
-        sce: '\u2AB0',
-        scE: '\u2AB4',
-        scedil: '\u015F',
-        Scedil: '\u015E',
-        scirc: '\u015D',
-        Scirc: '\u015C',
-        scnap: '\u2ABA',
-        scnE: '\u2AB6',
-        scnsim: '\u22E9',
-        scpolint: '\u2A13',
-        scsim: '\u227F',
-        scy: '\u0441',
-        Scy: '\u0421',
-        sdot: '\u22C5',
-        sdotb: '\u22A1',
-        sdote: '\u2A66',
-        searhk: '\u2925',
-        searr: '\u2198',
-        seArr: '\u21D8',
-        searrow: '\u2198',
-        sect: '\xA7',
-        semi: ';',
-        seswar: '\u2929',
-        setminus: '\u2216',
-        setmn: '\u2216',
-        sext: '\u2736',
-        sfr: '\uD835\uDD30',
-        Sfr: '\uD835\uDD16',
-        sfrown: '\u2322',
-        sharp: '\u266F',
-        shchcy: '\u0449',
-        SHCHcy: '\u0429',
-        shcy: '\u0448',
-        SHcy: '\u0428',
-        ShortDownArrow: '\u2193',
-        ShortLeftArrow: '\u2190',
-        shortmid: '\u2223',
-        shortparallel: '\u2225',
-        ShortRightArrow: '\u2192',
-        ShortUpArrow: '\u2191',
-        shy: '\xAD',
-        sigma: '\u03C3',
-        Sigma: '\u03A3',
-        sigmaf: '\u03C2',
-        sigmav: '\u03C2',
-        sim: '\u223C',
-        simdot: '\u2A6A',
-        sime: '\u2243',
-        simeq: '\u2243',
-        simg: '\u2A9E',
-        simgE: '\u2AA0',
-        siml: '\u2A9D',
-        simlE: '\u2A9F',
-        simne: '\u2246',
-        simplus: '\u2A24',
-        simrarr: '\u2972',
-        slarr: '\u2190',
-        SmallCircle: '\u2218',
-        smallsetminus: '\u2216',
-        smashp: '\u2A33',
-        smeparsl: '\u29E4',
-        smid: '\u2223',
-        smile: '\u2323',
-        smt: '\u2AAA',
-        smte: '\u2AAC',
-        smtes: '\u2AAC\uFE00',
-        softcy: '\u044C',
-        SOFTcy: '\u042C',
-        sol: '/',
-        solb: '\u29C4',
-        solbar: '\u233F',
-        sopf: '\uD835\uDD64',
-        Sopf: '\uD835\uDD4A',
-        spades: '\u2660',
-        spadesuit: '\u2660',
-        spar: '\u2225',
-        sqcap: '\u2293',
-        sqcaps: '\u2293\uFE00',
-        sqcup: '\u2294',
-        sqcups: '\u2294\uFE00',
-        Sqrt: '\u221A',
-        sqsub: '\u228F',
-        sqsube: '\u2291',
-        sqsubset: '\u228F',
-        sqsubseteq: '\u2291',
-        sqsup: '\u2290',
-        sqsupe: '\u2292',
-        sqsupset: '\u2290',
-        sqsupseteq: '\u2292',
-        squ: '\u25A1',
-        square: '\u25A1',
-        Square: '\u25A1',
-        SquareIntersection: '\u2293',
-        SquareSubset: '\u228F',
-        SquareSubsetEqual: '\u2291',
-        SquareSuperset: '\u2290',
-        SquareSupersetEqual: '\u2292',
-        SquareUnion: '\u2294',
-        squarf: '\u25AA',
-        squf: '\u25AA',
-        srarr: '\u2192',
-        sscr: '\uD835\uDCC8',
-        Sscr: '\uD835\uDCAE',
-        ssetmn: '\u2216',
-        ssmile: '\u2323',
-        sstarf: '\u22C6',
-        star: '\u2606',
-        Star: '\u22C6',
-        starf: '\u2605',
-        straightepsilon: '\u03F5',
-        straightphi: '\u03D5',
-        strns: '\xAF',
-        sub: '\u2282',
-        Sub: '\u22D0',
-        subdot: '\u2ABD',
-        sube: '\u2286',
-        subE: '\u2AC5',
-        subedot: '\u2AC3',
-        submult: '\u2AC1',
-        subne: '\u228A',
-        subnE: '\u2ACB',
-        subplus: '\u2ABF',
-        subrarr: '\u2979',
-        subset: '\u2282',
-        Subset: '\u22D0',
-        subseteq: '\u2286',
-        subseteqq: '\u2AC5',
-        SubsetEqual: '\u2286',
-        subsetneq: '\u228A',
-        subsetneqq: '\u2ACB',
-        subsim: '\u2AC7',
-        subsub: '\u2AD5',
-        subsup: '\u2AD3',
-        succ: '\u227B',
-        succapprox: '\u2AB8',
-        succcurlyeq: '\u227D',
-        Succeeds: '\u227B',
-        SucceedsEqual: '\u2AB0',
-        SucceedsSlantEqual: '\u227D',
-        SucceedsTilde: '\u227F',
-        succeq: '\u2AB0',
-        succnapprox: '\u2ABA',
-        succneqq: '\u2AB6',
-        succnsim: '\u22E9',
-        succsim: '\u227F',
-        SuchThat: '\u220B',
-        sum: '\u2211',
-        Sum: '\u2211',
-        sung: '\u266A',
-        sup: '\u2283',
-        Sup: '\u22D1',
-        sup1: '\xB9',
-        sup2: '\xB2',
-        sup3: '\xB3',
-        supdot: '\u2ABE',
-        supdsub: '\u2AD8',
-        supe: '\u2287',
-        supE: '\u2AC6',
-        supedot: '\u2AC4',
-        Superset: '\u2283',
-        SupersetEqual: '\u2287',
-        suphsol: '\u27C9',
-        suphsub: '\u2AD7',
-        suplarr: '\u297B',
-        supmult: '\u2AC2',
-        supne: '\u228B',
-        supnE: '\u2ACC',
-        supplus: '\u2AC0',
-        supset: '\u2283',
-        Supset: '\u22D1',
-        supseteq: '\u2287',
-        supseteqq: '\u2AC6',
-        supsetneq: '\u228B',
-        supsetneqq: '\u2ACC',
-        supsim: '\u2AC8',
-        supsub: '\u2AD4',
-        supsup: '\u2AD6',
-        swarhk: '\u2926',
-        swarr: '\u2199',
-        swArr: '\u21D9',
-        swarrow: '\u2199',
-        swnwar: '\u292A',
-        szlig: '\xDF',
-        Tab: '\t',
-        target: '\u2316',
-        tau: '\u03C4',
-        Tau: '\u03A4',
-        tbrk: '\u23B4',
-        tcaron: '\u0165',
-        Tcaron: '\u0164',
-        tcedil: '\u0163',
-        Tcedil: '\u0162',
-        tcy: '\u0442',
-        Tcy: '\u0422',
-        tdot: '\u20DB',
-        telrec: '\u2315',
-        tfr: '\uD835\uDD31',
-        Tfr: '\uD835\uDD17',
-        there4: '\u2234',
-        therefore: '\u2234',
-        Therefore: '\u2234',
-        theta: '\u03B8',
-        Theta: '\u0398',
-        thetasym: '\u03D1',
-        thetav: '\u03D1',
-        thickapprox: '\u2248',
-        thicksim: '\u223C',
-        ThickSpace: '\u205F\u200A',
-        thinsp: '\u2009',
-        ThinSpace: '\u2009',
-        thkap: '\u2248',
-        thksim: '\u223C',
-        thorn: '\xFE',
-        THORN: '\xDE',
-        tilde: '\u02DC',
-        Tilde: '\u223C',
-        TildeEqual: '\u2243',
-        TildeFullEqual: '\u2245',
-        TildeTilde: '\u2248',
-        times: '\xD7',
-        timesb: '\u22A0',
-        timesbar: '\u2A31',
-        timesd: '\u2A30',
-        tint: '\u222D',
-        toea: '\u2928',
-        top: '\u22A4',
-        topbot: '\u2336',
-        topcir: '\u2AF1',
-        topf: '\uD835\uDD65',
-        Topf: '\uD835\uDD4B',
-        topfork: '\u2ADA',
-        tosa: '\u2929',
-        tprime: '\u2034',
-        trade: '\u2122',
-        TRADE: '\u2122',
-        triangle: '\u25B5',
-        triangledown: '\u25BF',
-        triangleleft: '\u25C3',
-        trianglelefteq: '\u22B4',
-        triangleq: '\u225C',
-        triangleright: '\u25B9',
-        trianglerighteq: '\u22B5',
-        tridot: '\u25EC',
-        trie: '\u225C',
-        triminus: '\u2A3A',
-        TripleDot: '\u20DB',
-        triplus: '\u2A39',
-        trisb: '\u29CD',
-        tritime: '\u2A3B',
-        trpezium: '\u23E2',
-        tscr: '\uD835\uDCC9',
-        Tscr: '\uD835\uDCAF',
-        tscy: '\u0446',
-        TScy: '\u0426',
-        tshcy: '\u045B',
-        TSHcy: '\u040B',
-        tstrok: '\u0167',
-        Tstrok: '\u0166',
-        twixt: '\u226C',
-        twoheadleftarrow: '\u219E',
-        twoheadrightarrow: '\u21A0',
-        uacute: '\xFA',
-        Uacute: '\xDA',
-        uarr: '\u2191',
-        uArr: '\u21D1',
-        Uarr: '\u219F',
-        Uarrocir: '\u2949',
-        ubrcy: '\u045E',
-        Ubrcy: '\u040E',
-        ubreve: '\u016D',
-        Ubreve: '\u016C',
-        ucirc: '\xFB',
-        Ucirc: '\xDB',
-        ucy: '\u0443',
-        Ucy: '\u0423',
-        udarr: '\u21C5',
-        udblac: '\u0171',
-        Udblac: '\u0170',
-        udhar: '\u296E',
-        ufisht: '\u297E',
-        ufr: '\uD835\uDD32',
-        Ufr: '\uD835\uDD18',
-        ugrave: '\xF9',
-        Ugrave: '\xD9',
-        uHar: '\u2963',
-        uharl: '\u21BF',
-        uharr: '\u21BE',
-        uhblk: '\u2580',
-        ulcorn: '\u231C',
-        ulcorner: '\u231C',
-        ulcrop: '\u230F',
-        ultri: '\u25F8',
-        umacr: '\u016B',
-        Umacr: '\u016A',
-        uml: '\xA8',
-        UnderBar: '_',
-        UnderBrace: '\u23DF',
-        UnderBracket: '\u23B5',
-        UnderParenthesis: '\u23DD',
-        Union: '\u22C3',
-        UnionPlus: '\u228E',
-        uogon: '\u0173',
-        Uogon: '\u0172',
-        uopf: '\uD835\uDD66',
-        Uopf: '\uD835\uDD4C',
-        uparrow: '\u2191',
-        Uparrow: '\u21D1',
-        UpArrow: '\u2191',
-        UpArrowBar: '\u2912',
-        UpArrowDownArrow: '\u21C5',
-        updownarrow: '\u2195',
-        Updownarrow: '\u21D5',
-        UpDownArrow: '\u2195',
-        UpEquilibrium: '\u296E',
-        upharpoonleft: '\u21BF',
-        upharpoonright: '\u21BE',
-        uplus: '\u228E',
-        UpperLeftArrow: '\u2196',
-        UpperRightArrow: '\u2197',
-        upsi: '\u03C5',
-        Upsi: '\u03D2',
-        upsih: '\u03D2',
-        upsilon: '\u03C5',
-        Upsilon: '\u03A5',
-        UpTee: '\u22A5',
-        UpTeeArrow: '\u21A5',
-        upuparrows: '\u21C8',
-        urcorn: '\u231D',
-        urcorner: '\u231D',
-        urcrop: '\u230E',
-        uring: '\u016F',
-        Uring: '\u016E',
-        urtri: '\u25F9',
-        uscr: '\uD835\uDCCA',
-        Uscr: '\uD835\uDCB0',
-        utdot: '\u22F0',
-        utilde: '\u0169',
-        Utilde: '\u0168',
-        utri: '\u25B5',
-        utrif: '\u25B4',
-        uuarr: '\u21C8',
-        uuml: '\xFC',
-        Uuml: '\xDC',
-        uwangle: '\u29A7',
-        vangrt: '\u299C',
-        varepsilon: '\u03F5',
-        varkappa: '\u03F0',
-        varnothing: '\u2205',
-        varphi: '\u03D5',
-        varpi: '\u03D6',
-        varpropto: '\u221D',
-        varr: '\u2195',
-        vArr: '\u21D5',
-        varrho: '\u03F1',
-        varsigma: '\u03C2',
-        varsubsetneq: '\u228A\uFE00',
-        varsubsetneqq: '\u2ACB\uFE00',
-        varsupsetneq: '\u228B\uFE00',
-        varsupsetneqq: '\u2ACC\uFE00',
-        vartheta: '\u03D1',
-        vartriangleleft: '\u22B2',
-        vartriangleright: '\u22B3',
-        vBar: '\u2AE8',
-        Vbar: '\u2AEB',
-        vBarv: '\u2AE9',
-        vcy: '\u0432',
-        Vcy: '\u0412',
-        vdash: '\u22A2',
-        vDash: '\u22A8',
-        Vdash: '\u22A9',
-        VDash: '\u22AB',
-        Vdashl: '\u2AE6',
-        vee: '\u2228',
-        Vee: '\u22C1',
-        veebar: '\u22BB',
-        veeeq: '\u225A',
-        vellip: '\u22EE',
-        verbar: '|',
-        Verbar: '\u2016',
-        vert: '|',
-        Vert: '\u2016',
-        VerticalBar: '\u2223',
-        VerticalLine: '|',
-        VerticalSeparator: '\u2758',
-        VerticalTilde: '\u2240',
-        VeryThinSpace: '\u200A',
-        vfr: '\uD835\uDD33',
-        Vfr: '\uD835\uDD19',
-        vltri: '\u22B2',
-        vnsub: '\u2282\u20D2',
-        vnsup: '\u2283\u20D2',
-        vopf: '\uD835\uDD67',
-        Vopf: '\uD835\uDD4D',
-        vprop: '\u221D',
-        vrtri: '\u22B3',
-        vscr: '\uD835\uDCCB',
-        Vscr: '\uD835\uDCB1',
-        vsubne: '\u228A\uFE00',
-        vsubnE: '\u2ACB\uFE00',
-        vsupne: '\u228B\uFE00',
-        vsupnE: '\u2ACC\uFE00',
-        Vvdash: '\u22AA',
-        vzigzag: '\u299A',
-        wcirc: '\u0175',
-        Wcirc: '\u0174',
-        wedbar: '\u2A5F',
-        wedge: '\u2227',
-        Wedge: '\u22C0',
-        wedgeq: '\u2259',
-        weierp: '\u2118',
-        wfr: '\uD835\uDD34',
-        Wfr: '\uD835\uDD1A',
-        wopf: '\uD835\uDD68',
-        Wopf: '\uD835\uDD4E',
-        wp: '\u2118',
-        wr: '\u2240',
-        wreath: '\u2240',
-        wscr: '\uD835\uDCCC',
-        Wscr: '\uD835\uDCB2',
-        xcap: '\u22C2',
-        xcirc: '\u25EF',
-        xcup: '\u22C3',
-        xdtri: '\u25BD',
-        xfr: '\uD835\uDD35',
-        Xfr: '\uD835\uDD1B',
-        xharr: '\u27F7',
-        xhArr: '\u27FA',
-        xi: '\u03BE',
-        Xi: '\u039E',
-        xlarr: '\u27F5',
-        xlArr: '\u27F8',
-        xmap: '\u27FC',
-        xnis: '\u22FB',
-        xodot: '\u2A00',
-        xopf: '\uD835\uDD69',
-        Xopf: '\uD835\uDD4F',
-        xoplus: '\u2A01',
-        xotime: '\u2A02',
-        xrarr: '\u27F6',
-        xrArr: '\u27F9',
-        xscr: '\uD835\uDCCD',
-        Xscr: '\uD835\uDCB3',
-        xsqcup: '\u2A06',
-        xuplus: '\u2A04',
-        xutri: '\u25B3',
-        xvee: '\u22C1',
-        xwedge: '\u22C0',
-        yacute: '\xFD',
-        Yacute: '\xDD',
-        yacy: '\u044F',
-        YAcy: '\u042F',
-        ycirc: '\u0177',
-        Ycirc: '\u0176',
-        ycy: '\u044B',
-        Ycy: '\u042B',
-        yen: '\xA5',
-        yfr: '\uD835\uDD36',
-        Yfr: '\uD835\uDD1C',
-        yicy: '\u0457',
-        YIcy: '\u0407',
-        yopf: '\uD835\uDD6A',
-        Yopf: '\uD835\uDD50',
-        yscr: '\uD835\uDCCE',
-        Yscr: '\uD835\uDCB4',
-        yucy: '\u044E',
-        YUcy: '\u042E',
-        yuml: '\xFF',
-        Yuml: '\u0178',
-        zacute: '\u017A',
-        Zacute: '\u0179',
-        zcaron: '\u017E',
-        Zcaron: '\u017D',
-        zcy: '\u0437',
-        Zcy: '\u0417',
-        zdot: '\u017C',
-        Zdot: '\u017B',
-        zeetrf: '\u2128',
-        ZeroWidthSpace: '\u200B',
-        zeta: '\u03B6',
-        Zeta: '\u0396',
-        zfr: '\uD835\uDD37',
-        Zfr: '\u2128',
-        zhcy: '\u0436',
-        ZHcy: '\u0416',
-        zigrarr: '\u21DD',
-        zopf: '\uD835\uDD6B',
-        Zopf: '\u2124',
-        zscr: '\uD835\uDCCF',
-        Zscr: '\uD835\uDCB5',
-        zwj: '\u200D',
-        zwnj: '\u200C'
-      }
-      var decodeMapLegacy = {
-        aacute: '\xE1',
-        Aacute: '\xC1',
-        acirc: '\xE2',
-        Acirc: '\xC2',
-        acute: '\xB4',
-        aelig: '\xE6',
-        AElig: '\xC6',
-        agrave: '\xE0',
-        Agrave: '\xC0',
-        amp: '&',
-        AMP: '&',
-        aring: '\xE5',
-        Aring: '\xC5',
-        atilde: '\xE3',
-        Atilde: '\xC3',
-        auml: '\xE4',
-        Auml: '\xC4',
-        brvbar: '\xA6',
-        ccedil: '\xE7',
-        Ccedil: '\xC7',
-        cedil: '\xB8',
-        cent: '\xA2',
-        copy: '\xA9',
-        COPY: '\xA9',
-        curren: '\xA4',
-        deg: '\xB0',
-        divide: '\xF7',
-        eacute: '\xE9',
-        Eacute: '\xC9',
-        ecirc: '\xEA',
-        Ecirc: '\xCA',
-        egrave: '\xE8',
-        Egrave: '\xC8',
-        eth: '\xF0',
-        ETH: '\xD0',
-        euml: '\xEB',
-        Euml: '\xCB',
-        frac12: '\xBD',
-        frac14: '\xBC',
-        frac34: '\xBE',
-        gt: '>',
-        GT: '>',
-        iacute: '\xED',
-        Iacute: '\xCD',
-        icirc: '\xEE',
-        Icirc: '\xCE',
-        iexcl: '\xA1',
-        igrave: '\xEC',
-        Igrave: '\xCC',
-        iquest: '\xBF',
-        iuml: '\xEF',
-        Iuml: '\xCF',
-        laquo: '\xAB',
-        lt: '<',
-        LT: '<',
-        macr: '\xAF',
-        micro: '\xB5',
-        middot: '\xB7',
-        nbsp: '\xA0',
-        not: '\xAC',
-        ntilde: '\xF1',
-        Ntilde: '\xD1',
-        oacute: '\xF3',
-        Oacute: '\xD3',
-        ocirc: '\xF4',
-        Ocirc: '\xD4',
-        ograve: '\xF2',
-        Ograve: '\xD2',
-        ordf: '\xAA',
-        ordm: '\xBA',
-        oslash: '\xF8',
-        Oslash: '\xD8',
-        otilde: '\xF5',
-        Otilde: '\xD5',
-        ouml: '\xF6',
-        Ouml: '\xD6',
-        para: '\xB6',
-        plusmn: '\xB1',
-        pound: '\xA3',
-        quot: '"',
-        QUOT: '"',
-        raquo: '\xBB',
-        reg: '\xAE',
-        REG: '\xAE',
-        sect: '\xA7',
-        shy: '\xAD',
-        sup1: '\xB9',
-        sup2: '\xB2',
-        sup3: '\xB3',
-        szlig: '\xDF',
-        thorn: '\xFE',
-        THORN: '\xDE',
-        times: '\xD7',
-        uacute: '\xFA',
-        Uacute: '\xDA',
-        ucirc: '\xFB',
-        Ucirc: '\xDB',
-        ugrave: '\xF9',
-        Ugrave: '\xD9',
-        uml: '\xA8',
-        uuml: '\xFC',
-        Uuml: '\xDC',
-        yacute: '\xFD',
-        Yacute: '\xDD',
-        yen: '\xA5',
-        yuml: '\xFF'
-      }
-      var decodeMapNumeric = {
-        0: '\uFFFD',
-        128: '\u20AC',
-        130: '\u201A',
-        131: '\u0192',
-        132: '\u201E',
-        133: '\u2026',
-        134: '\u2020',
-        135: '\u2021',
-        136: '\u02C6',
-        137: '\u2030',
-        138: '\u0160',
-        139: '\u2039',
-        140: '\u0152',
-        142: '\u017D',
-        145: '\u2018',
-        146: '\u2019',
-        147: '\u201C',
-        148: '\u201D',
-        149: '\u2022',
-        150: '\u2013',
-        151: '\u2014',
-        152: '\u02DC',
-        153: '\u2122',
-        154: '\u0161',
-        155: '\u203A',
-        156: '\u0153',
-        158: '\u017E',
-        159: '\u0178'
-      }
-      var invalidReferenceCodePoints = [
-        1, 2, 3, 4, 5, 6, 7, 8, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-        24, 25, 26, 27, 28, 29, 30, 31, 127, 128, 129, 130, 131, 132, 133, 134,
-        135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,
-        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 64976, 64977,
-        64978, 64979, 64980, 64981, 64982, 64983, 64984, 64985, 64986, 64987,
-        64988, 64989, 64990, 64991, 64992, 64993, 64994, 64995, 64996, 64997,
-        64998, 64999, 65000, 65001, 65002, 65003, 65004, 65005, 65006, 65007,
-        65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678,
-        327679, 393214, 393215, 458750, 458751, 524286, 524287, 589822, 589823,
-        655358, 655359, 720894, 720895, 786430, 786431, 851966, 851967, 917502,
-        917503, 983038, 983039, 1048574, 1048575, 1114110, 1114111
-      ]
-
-      /*--------------------------------------------------------------------------*/
-
-      var stringFromCharCode = String.fromCharCode
-
-      var object = {}
-      var hasOwnProperty = object.hasOwnProperty
-      var has = function (object, propertyName) {
-        return hasOwnProperty.call(object, propertyName)
-      }
-
-      var contains = function (array, value) {
-        var index = -1
-        var length = array.length
-        while (++index < length) {
-          if (array[index] == value) {
-            return true
-          }
-        }
-        return false
-      }
-
-      var merge = function (options, defaults) {
-        if (!options) {
-          return defaults
-        }
-        var result = {}
-        var key
-        for (key in defaults) {
-          // A `hasOwnProperty` check is not needed here, since only recognized
-          // option names are used anyway. Any others are ignored.
-          result[key] = has(options, key) ? options[key] : defaults[key]
-        }
-        return result
-      }
-
-      // Modified version of `ucs2encode`; see https://mths.be/punycode.
-      var codePointToSymbol = function (codePoint, strict) {
-        var output = ''
-        if (
-          (codePoint >= 0xd800 && codePoint <= 0xdfff) ||
-          codePoint > 0x10ffff
-        ) {
-          // See issue #4:
-          // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
-          // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
-          // REPLACEMENT CHARACTER.”
-          if (strict) {
-            parseError(
-              'character reference outside the permissible Unicode range'
-            )
-          }
-          return '\uFFFD'
-        }
-        if (has(decodeMapNumeric, codePoint)) {
-          if (strict) {
-            parseError('disallowed character reference')
-          }
-          return decodeMapNumeric[codePoint]
-        }
-        if (strict && contains(invalidReferenceCodePoints, codePoint)) {
-          parseError('disallowed character reference')
-        }
-        if (codePoint > 0xffff) {
-          codePoint -= 0x10000
-          output += stringFromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800)
-          codePoint = 0xdc00 | (codePoint & 0x3ff)
-        }
-        output += stringFromCharCode(codePoint)
-        return output
-      }
-
-      var hexEscape = function (codePoint) {
-        return '&#x' + codePoint.toString(16).toUpperCase() + ';'
-      }
-
-      var decEscape = function (codePoint) {
-        return '&#' + codePoint + ';'
-      }
-
-      var parseError = function (message) {
-        throw Error('Parse error: ' + message)
-      }
-
-      /*--------------------------------------------------------------------------*/
-
-      var encode = function (string, options) {
-        options = merge(options, encode.options)
-        var strict = options.strict
-        if (strict && regexInvalidRawCodePoint.test(string)) {
-          parseError('forbidden code point')
-        }
-        var encodeEverything = options.encodeEverything
-        var useNamedReferences = options.useNamedReferences
-        var allowUnsafeSymbols = options.allowUnsafeSymbols
-        var escapeCodePoint = options.decimal ? decEscape : hexEscape
-
-        var escapeBmpSymbol = function (symbol) {
-          return escapeCodePoint(symbol.charCodeAt(0))
-        }
-
-        if (encodeEverything) {
-          // Encode ASCII symbols.
-          string = string.replace(regexAsciiWhitelist, function (symbol) {
-            // Use named references if requested & possible.
-            if (useNamedReferences && has(encodeMap, symbol)) {
-              return '&' + encodeMap[symbol] + ';'
-            }
-            return escapeBmpSymbol(symbol)
-          })
-          // Shorten a few escapes that represent two symbols, of which at least one
-          // is within the ASCII range.
-          if (useNamedReferences) {
-            string = string
-              .replace(/&gt;\u20D2/g, '&nvgt;')
-              .replace(/&lt;\u20D2/g, '&nvlt;')
-              .replace(/&#x66;&#x6A;/g, '&fjlig;')
-          }
-          // Encode non-ASCII symbols.
-          if (useNamedReferences) {
-            // Encode non-ASCII symbols that can be replaced with a named reference.
-            string = string.replace(regexEncodeNonAscii, function (string) {
-              // Note: there is no need to check `has(encodeMap, string)` here.
-              return '&' + encodeMap[string] + ';'
-            })
-          }
-          // Note: any remaining non-ASCII symbols are handled outside of the `if`.
-        } else if (useNamedReferences) {
-          // Apply named character references.
-          // Encode `<>"'&` using named character references.
-          if (!allowUnsafeSymbols) {
-            string = string.replace(regexEscape, function (string) {
-              return '&' + encodeMap[string] + ';' // no need to check `has()` here
-            })
-          }
-          // Shorten escapes that represent two symbols, of which at least one is
-          // `<>"'&`.
-          string = string
-            .replace(/&gt;\u20D2/g, '&nvgt;')
-            .replace(/&lt;\u20D2/g, '&nvlt;')
-          // Encode non-ASCII symbols that can be replaced with a named reference.
-          string = string.replace(regexEncodeNonAscii, function (string) {
-            // Note: there is no need to check `has(encodeMap, string)` here.
-            return '&' + encodeMap[string] + ';'
-          })
-        } else if (!allowUnsafeSymbols) {
-          // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
-          // using named character references.
-          string = string.replace(regexEscape, escapeBmpSymbol)
-        }
-        return (
-          string
-            // Encode astral symbols.
-            .replace(regexAstralSymbols, function ($0) {
-              // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-              var high = $0.charCodeAt(0)
-              var low = $0.charCodeAt(1)
-              var codePoint = (high - 0xd800) * 0x400 + low - 0xdc00 + 0x10000
-              return escapeCodePoint(codePoint)
-            })
-            // Encode any remaining BMP symbols that are not printable ASCII symbols
-            // using a hexadecimal escape.
-            .replace(regexBmpWhitelist, escapeBmpSymbol)
-        )
-      }
-      // Expose default options (so they can be overridden globally).
-      encode.options = {
-        allowUnsafeSymbols: false,
-        encodeEverything: false,
-        strict: false,
-        useNamedReferences: false,
-        decimal: false
-      }
-
-      var decode = function (html, options) {
-        options = merge(options, decode.options)
-        var strict = options.strict
-        if (strict && regexInvalidEntity.test(html)) {
-          parseError('malformed character reference')
-        }
-        return html.replace(
-          regexDecode,
-          function ($0, $1, $2, $3, $4, $5, $6, $7, $8) {
-            var codePoint
-            var semicolon
-            var decDigits
-            var hexDigits
-            var reference
-            var next
-
-            if ($1) {
-              reference = $1
-              // Note: there is no need to check `has(decodeMap, reference)`.
-              return decodeMap[reference]
-            }
-
-            if ($2) {
-              // Decode named character references without trailing `;`, e.g. `&amp`.
-              // This is only a parse error if it gets converted to `&`, or if it is
-              // followed by `=` in an attribute context.
-              reference = $2
-              next = $3
-              if (next && options.isAttributeValue) {
-                if (strict && next == '=') {
-                  parseError('`&` did not start a character reference')
-                }
-                return $0
-              } else {
-                if (strict) {
-                  parseError(
-                    'named character reference was not terminated by a semicolon'
-                  )
-                }
-                // Note: there is no need to check `has(decodeMapLegacy, reference)`.
-                return decodeMapLegacy[reference] + (next || '')
-              }
-            }
-
-            if ($4) {
-              // Decode decimal escapes, e.g. `&#119558;`.
-              decDigits = $4
-              semicolon = $5
-              if (strict && !semicolon) {
-                parseError(
-                  'character reference was not terminated by a semicolon'
-                )
-              }
-              codePoint = parseInt(decDigits, 10)
-              return codePointToSymbol(codePoint, strict)
-            }
-
-            if ($6) {
-              // Decode hexadecimal escapes, e.g. `&#x1D306;`.
-              hexDigits = $6
-              semicolon = $7
-              if (strict && !semicolon) {
-                parseError(
-                  'character reference was not terminated by a semicolon'
-                )
-              }
-              codePoint = parseInt(hexDigits, 16)
-              return codePointToSymbol(codePoint, strict)
-            }
-
-            // If we’re still here, `if ($7)` is implied; it’s an ambiguous
-            // ampersand for sure. https://mths.be/notes/ambiguous-ampersands
-            if (strict) {
-              parseError(
-                'named character reference was not terminated by a semicolon'
-              )
-            }
-            return $0
-          }
-        )
-      }
-      // Expose default options (so they can be overridden globally).
-      decode.options = {
-        isAttributeValue: false,
-        strict: false
-      }
-
-      var escape = function (string) {
-        return string.replace(regexEscape, function ($0) {
-          // Note: there is no need to check `has(escapeMap, $0)` here.
-          return escapeMap[$0]
-        })
-      }
-
-      /*--------------------------------------------------------------------------*/
-
-      var he = {
-        version: '1.2.0',
-        encode: encode,
-        decode: decode,
-        escape: escape,
-        unescape: decode
-      }
-
-      // Some AMD build optimizers, like r.js, check for specific condition patterns
-      // like the following:
-      if (freeExports && !freeExports.nodeType) {
-        if (freeModule) {
-          // in Node.js, io.js, or RingoJS v0.8.0+
-          freeModule.exports = he
-        } else {
-          // in Narwhal or RingoJS v0.7.0-
-          for (var key in he) {
-            has(he, key) && (freeExports[key] = he[key])
-          }
-        }
-      } else {
-        // in Rhino or a web browser
-        root.he = he
-      }
-    })(commonjsGlobal)
-  })(he$1, he$1.exports)
-
-  var he = he$1.exports
-
-  /**
-   * Cross-platform code generation for component v-model
-   */
-  function genComponentModel(el, value, modifiers) {
-    var _a = modifiers || {},
-      number = _a.number,
-      trim = _a.trim
-    var baseValueExpression = '$$v'
-    var valueExpression = baseValueExpression
-    if (trim) {
-      valueExpression =
-        '(typeof '.concat(baseValueExpression, " === 'string'") +
-        '? '.concat(baseValueExpression, '.trim()') +
-        ': '.concat(baseValueExpression, ')')
-    }
-    if (number) {
-      valueExpression = '_n('.concat(valueExpression, ')')
-    }
-    var assignment = genAssignmentCode(value, valueExpression)
-    el.model = {
-      value: '('.concat(value, ')'),
-      expression: JSON.stringify(value),
-      callback: 'function ('
-        .concat(baseValueExpression, ') {')
-        .concat(assignment, '}')
-    }
-  }
-  /**
-   * Cross-platform codegen helper for generating v-model value assignment code.
-   */
-  function genAssignmentCode(value, assignment) {
-    var res = parseModel(value)
-    if (res.key === null) {
-      return ''.concat(value, '=').concat(assignment)
-    } else {
-      return '$set('
-        .concat(res.exp, ', ')
-        .concat(res.key, ', ')
-        .concat(assignment, ')')
-    }
-  }
-  /**
-   * Parse a v-model expression into a base path and a final key segment.
-   * Handles both dot-path and possible square brackets.
-   *
-   * Possible cases:
-   *
-   * - test
-   * - test[key]
-   * - test[test1[key]]
-   * - test["a"][key]
-   * - xxx.test[a[a].test1[key]]
-   * - test.xxx.a["asa"][test1[key]]
-   *
-   */
-  var len, str, chr, index, expressionPos, expressionEndPos
-  function parseModel(val) {
-    // Fix https://github.com/vuejs/vue/pull/7730
-    // allow v-model="obj.val " (trailing whitespace)
-    val = val.trim()
-    len = val.length
-    if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-      index = val.lastIndexOf('.')
-      if (index > -1) {
-        return {
-          exp: val.slice(0, index),
-          key: '"' + val.slice(index + 1) + '"'
-        }
-      } else {
-        return {
-          exp: val,
-          key: null
-        }
-      }
-    }
-    str = val
-    index = expressionPos = expressionEndPos = 0
-    while (!eof()) {
-      chr = next()
-      /* istanbul ignore if */
-      if (isStringStart(chr)) {
-        parseString(chr)
-      } else if (chr === 0x5b) {
-        parseBracket(chr)
-      }
-    }
-    return {
-      exp: val.slice(0, expressionPos),
-      key: val.slice(expressionPos + 1, expressionEndPos)
-    }
-  }
-  function next() {
-    return str.charCodeAt(++index)
-  }
-  function eof() {
-    return index >= len
-  }
-  function isStringStart(chr) {
-    return chr === 0x22 || chr === 0x27
-  }
-  function parseBracket(chr) {
-    var inBracket = 1
-    expressionPos = index
-    while (!eof()) {
-      chr = next()
-      if (isStringStart(chr)) {
-        parseString(chr)
-        continue
-      }
-      if (chr === 0x5b) inBracket++
-      if (chr === 0x5d) inBracket--
-      if (inBracket === 0) {
-        expressionEndPos = index
-        break
-      }
-    }
-  }
-  function parseString(chr) {
-    var stringQuote = chr
-    while (!eof()) {
-      chr = next()
-      if (chr === stringQuote) {
-        break
-      }
-    }
-  }
-
-  var onRE = /^@|^v-on:/
-  var dirRE = /^v-|^@|^:|^#/
-  var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
-  var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/
-  var stripParensRE = /^\(|\)$/g
-  var dynamicArgRE = /^\[.*\]$/
-  var argRE = /:(.*)$/
-  var bindRE = /^:|^\.|^v-bind:/
-  var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
-  var slotRE = /^v-slot(:|$)|^#/
-  var lineBreakRE = /[\r\n]/
-  var whitespaceRE = /[ \f\t\r\n]+/g
-  var invalidAttributeRE = /[\s"'<>\/=]/
-  var decodeHTMLCached = cached(he.decode)
-  var emptySlotScopeToken = '_empty_'
-  // configurable state
-  var warn$1
-  var delimiters
-  var transforms
-  var preTransforms
-  var postTransforms
-  var platformIsPreTag
-  var platformMustUseProp
-  var platformGetTagNamespace
-  var maybeComponent
-  function createASTElement(tag, attrs, parent) {
-    return {
-      type: 1,
-      tag: tag,
-      attrsList: attrs,
-      attrsMap: makeAttrsMap(attrs),
-      rawAttrsMap: {},
-      parent: parent,
-      children: []
-    }
-  }
-  /**
-   * Convert HTML string to AST.
-   */
-  function parse(template, options) {
-    warn$1 = options.warn || baseWarn
-    platformIsPreTag = options.isPreTag || no
-    platformMustUseProp = options.mustUseProp || no
-    platformGetTagNamespace = options.getTagNamespace || no
-    var isReservedTag = options.isReservedTag || no
-    maybeComponent = function (el) {
-      return !!(
-        el.component ||
-        el.attrsMap[':is'] ||
-        el.attrsMap['v-bind:is'] ||
-        !(el.attrsMap.is
-          ? isReservedTag(el.attrsMap.is)
-          : isReservedTag(el.tag))
-      )
-    }
-    transforms = pluckModuleFunction(options.modules, 'transformNode')
-    preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
-    postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
-    delimiters = options.delimiters
-    var stack = []
-    var preserveWhitespace = options.preserveWhitespace !== false
-    var whitespaceOption = options.whitespace
-    var root
-    var currentParent
-    var inVPre = false
-    var inPre = false
-    var warned = false
-    function warnOnce(msg, range) {
-      if (!warned) {
-        warned = true
-        warn$1(msg, range)
-      }
-    }
-    function closeElement(element) {
-      trimEndingWhitespace(element)
-      if (!inVPre && !element.processed) {
-        element = processElement(element, options)
-      }
-      // tree management
-      if (!stack.length && element !== root) {
-        // allow root elements with v-if, v-else-if and v-else
-        if (root.if && (element.elseif || element.else)) {
-          {
-            checkRootConstraints(element)
-          }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          })
-        } else {
-          warnOnce(
-            'Component template should contain exactly one root element. ' +
-              'If you are using v-if on multiple elements, ' +
-              'use v-else-if to chain them instead.',
-            { start: element.start }
-          )
-        }
-      }
-      if (currentParent && !element.forbidden) {
-        if (element.elseif || element.else) {
-          processIfConditions(element, currentParent)
-        } else {
-          if (element.slotScope) {
-            // scoped slot
-            // keep it in the children list so that v-else(-if) conditions can
-            // find it as the prev node.
-            var name_1 = element.slotTarget || '"default"'
-            ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[
-              name_1
-            ] = element
-          }
-          currentParent.children.push(element)
-          element.parent = currentParent
-        }
-      }
-      // final children cleanup
-      // filter out scoped slots
-      element.children = element.children.filter(function (c) {
-        return !c.slotScope
-      })
-      // remove trailing whitespace node again
-      trimEndingWhitespace(element)
-      // check pre state
-      if (element.pre) {
-        inVPre = false
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false
-      }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options)
-      }
-    }
-    function trimEndingWhitespace(el) {
-      // remove trailing whitespace node
-      if (!inPre) {
-        var lastNode = void 0
-        while (
-          (lastNode = el.children[el.children.length - 1]) &&
-          lastNode.type === 3 &&
-          lastNode.text === ' '
-        ) {
-          el.children.pop()
-        }
-      }
-    }
-    function checkRootConstraints(el) {
-      if (el.tag === 'slot' || el.tag === 'template') {
-        warnOnce(
-          'Cannot use <'.concat(
-            el.tag,
-            '> as component root element because it may '
-          ) + 'contain multiple nodes.',
-          { start: el.start }
-        )
-      }
-      if (el.attrsMap.hasOwnProperty('v-for')) {
-        warnOnce(
-          'Cannot use v-for on stateful component root element because ' +
-            'it renders multiple elements.',
-          el.rawAttrsMap['v-for']
-        )
-      }
-    }
-    parseHTML(template, {
-      warn: warn$1,
-      expectHTML: options.expectHTML,
-      isUnaryTag: options.isUnaryTag,
-      canBeLeftOpenTag: options.canBeLeftOpenTag,
-      shouldDecodeNewlines: options.shouldDecodeNewlines,
-      shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-      shouldKeepComment: options.comments,
-      outputSourceRange: options.outputSourceRange,
-      start: function (tag, attrs, unary, start, end) {
-        // check namespace.
-        // inherit parent ns if there is one
-        var ns =
-          (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
-        // handle IE svg bug
-        /* istanbul ignore if */
-        if (isIE && ns === 'svg') {
-          attrs = guardIESVGBug(attrs)
-        }
-        var element = createASTElement(tag, attrs, currentParent)
-        if (ns) {
-          element.ns = ns
-        }
-        {
-          if (options.outputSourceRange) {
-            element.start = start
-            element.end = end
-            element.rawAttrsMap = element.attrsList.reduce(function (
-              cumulated,
-              attr
-            ) {
-              cumulated[attr.name] = attr
-              return cumulated
-            },
-            {})
-          }
-          attrs.forEach(function (attr) {
-            if (invalidAttributeRE.test(attr.name)) {
-              warn$1(
-                'Invalid dynamic argument expression: attribute names cannot contain ' +
-                  'spaces, quotes, <, >, / or =.',
-                {
-                  start: attr.start + attr.name.indexOf('['),
-                  end: attr.start + attr.name.length
-                }
-              )
-            }
-          })
-        }
-        if (isForbiddenTag(element) && !isServerRendering()) {
-          element.forbidden = true
-          warn$1(
-            'Templates should only be responsible for mapping the state to the ' +
-              'UI. Avoid placing tags with side-effects in your templates, such as ' +
-              '<'.concat(tag, '>') +
-              ', as they will not be parsed.',
-            { start: element.start }
-          )
-        }
-        // apply pre-transforms
-        for (var i = 0; i < preTransforms.length; i++) {
-          element = preTransforms[i](element, options) || element
-        }
-        if (!inVPre) {
-          processPre(element)
-          if (element.pre) {
-            inVPre = true
-          }
-        }
-        if (platformIsPreTag(element.tag)) {
-          inPre = true
-        }
-        if (inVPre) {
-          processRawAttrs(element)
-        } else if (!element.processed) {
-          // structural directives
-          processFor(element)
-          processIf(element)
-          processOnce(element)
-        }
-        if (!root) {
-          root = element
-          {
-            checkRootConstraints(root)
-          }
-        }
-        if (!unary) {
-          currentParent = element
-          stack.push(element)
-        } else {
-          closeElement(element)
-        }
-      },
-      end: function (tag, start, end) {
-        var element = stack[stack.length - 1]
-        // pop stack
-        stack.length -= 1
-        currentParent = stack[stack.length - 1]
-        if (options.outputSourceRange) {
-          element.end = end
-        }
-        closeElement(element)
-      },
-      chars: function (text, start, end) {
-        if (!currentParent) {
-          {
-            if (text === template) {
-              warnOnce(
-                'Component template requires a root element, rather than just text.',
-                { start: start }
-              )
-            } else if ((text = text.trim())) {
-              warnOnce(
-                'text "'.concat(
-                  text,
-                  '" outside root element will be ignored.'
-                ),
-                {
-                  start: start
-                }
-              )
-            }
-          }
-          return
-        }
-        // IE textarea placeholder bug
-        /* istanbul ignore if */
-        if (
-          isIE &&
-          currentParent.tag === 'textarea' &&
-          currentParent.attrsMap.placeholder === text
-        ) {
-          return
-        }
-        var children = currentParent.children
-        if (inPre || text.trim()) {
-          text = isTextTag(currentParent) ? text : decodeHTMLCached(text)
-        } else if (!children.length) {
-          // remove the whitespace-only node right after an opening tag
-          text = ''
-        } else if (whitespaceOption) {
-          if (whitespaceOption === 'condense') {
-            // in condense mode, remove the whitespace node if it contains
-            // line break, otherwise condense to a single space
-            text = lineBreakRE.test(text) ? '' : ' '
-          } else {
-            text = ' '
-          }
-        } else {
-          text = preserveWhitespace ? ' ' : ''
-        }
-        if (text) {
-          if (!inPre && whitespaceOption === 'condense') {
-            // condense consecutive whitespaces into single space
-            text = text.replace(whitespaceRE, ' ')
-          }
-          var res = void 0
-          var child = void 0
-          if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-            child = {
-              type: 2,
-              expression: res.expression,
-              tokens: res.tokens,
-              text: text
-            }
-          } else if (
-            text !== ' ' ||
-            !children.length ||
-            children[children.length - 1].text !== ' '
-          ) {
-            child = {
-              type: 3,
-              text: text
-            }
-          }
-          if (child) {
-            if (options.outputSourceRange) {
-              child.start = start
-              child.end = end
-            }
-            children.push(child)
-          }
-        }
-      },
-      comment: function (text, start, end) {
-        // adding anything as a sibling to the root node is forbidden
-        // comments should still be allowed, but ignored
-        if (currentParent) {
-          var child = {
-            type: 3,
-            text: text,
-            isComment: true
-          }
-          if (options.outputSourceRange) {
-            child.start = start
-            child.end = end
-          }
-          currentParent.children.push(child)
-        }
-      }
-    })
-    return root
-  }
-  function processPre(el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true
-    }
-  }
-  function processRawAttrs(el) {
-    var list = el.attrsList
-    var len = list.length
-    if (len) {
-      var attrs = (el.attrs = new Array(len))
-      for (var i = 0; i < len; i++) {
-        attrs[i] = {
-          name: list[i].name,
-          value: JSON.stringify(list[i].value)
-        }
-        if (list[i].start != null) {
-          attrs[i].start = list[i].start
-          attrs[i].end = list[i].end
-        }
-      }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true
-    }
-  }
-  function processElement(element, options) {
-    processKey(element)
-    // determine whether this is a plain element after
-    // removing structural attributes
-    element.plain =
-      !element.key && !element.scopedSlots && !element.attrsList.length
-    processRef(element)
-    processSlotContent(element)
-    processSlotOutlet(element)
-    processComponent(element)
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element
-    }
-    processAttrs(element)
-    return element
-  }
-  function processKey(el) {
-    var exp = getBindingAttr(el, 'key')
-    if (exp) {
-      {
-        if (el.tag === 'template') {
-          warn$1(
-            '<template> cannot be keyed. Place the key on real elements instead.',
-            getRawBindingAttr(el, 'key')
-          )
-        }
-        if (el.for) {
-          var iterator = el.iterator2 || el.iterator1
-          var parent_1 = el.parent
-          if (
-            iterator &&
-            iterator === exp &&
-            parent_1 &&
-            parent_1.tag === 'transition-group'
-          ) {
-            warn$1(
-              'Do not use v-for index as key on <transition-group> children, ' +
-                'this is the same as not using keys.',
-              getRawBindingAttr(el, 'key'),
-              true /* tip */
-            )
-          }
-        }
-      }
-      el.key = exp
-    }
-  }
-  function processRef(el) {
-    var ref = getBindingAttr(el, 'ref')
-    if (ref) {
-      el.ref = ref
-      el.refInFor = checkInFor(el)
-    }
-  }
-  function processFor(el) {
-    var exp
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp)
-      if (res) {
-        extend(el, res)
-      } else {
-        warn$1(
-          'Invalid v-for expression: '.concat(exp),
-          el.rawAttrsMap['v-for']
-        )
-      }
-    }
-  }
-  function parseFor(exp) {
-    var inMatch = exp.match(forAliasRE)
-    if (!inMatch) return
-    var res = {}
-    res.for = inMatch[2].trim()
-    var alias = inMatch[1].trim().replace(stripParensRE, '')
-    var iteratorMatch = alias.match(forIteratorRE)
-    if (iteratorMatch) {
-      res.alias = alias.replace(forIteratorRE, '').trim()
-      res.iterator1 = iteratorMatch[1].trim()
-      if (iteratorMatch[2]) {
-        res.iterator2 = iteratorMatch[2].trim()
-      }
-    } else {
-      res.alias = alias
-    }
-    return res
-  }
-  function processIf(el) {
-    var exp = getAndRemoveAttr(el, 'v-if')
-    if (exp) {
-      el.if = exp
-      addIfCondition(el, {
-        exp: exp,
-        block: el
-      })
-    } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true
-      }
-      var elseif = getAndRemoveAttr(el, 'v-else-if')
-      if (elseif) {
-        el.elseif = elseif
-      }
-    }
-  }
-  function processIfConditions(el, parent) {
-    var prev = findPrevElement(parent.children)
-    if (prev && prev.if) {
-      addIfCondition(prev, {
-        exp: el.elseif,
-        block: el
-      })
-    } else {
-      warn$1(
-        'v-'.concat(el.elseif ? 'else-if="' + el.elseif + '"' : 'else', ' ') +
-          'used on element <'.concat(el.tag, '> without corresponding v-if.'),
-        el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-      )
-    }
-  }
-  function findPrevElement(children) {
-    var i = children.length
-    while (i--) {
-      if (children[i].type === 1) {
-        return children[i]
-      } else {
-        if (children[i].text !== ' ') {
-          warn$1(
-            'text "'.concat(
-              children[i].text.trim(),
-              '" between v-if and v-else(-if) '
-            ) + 'will be ignored.',
-            children[i]
-          )
-        }
-        children.pop()
-      }
-    }
-  }
-  function addIfCondition(el, condition) {
-    if (!el.ifConditions) {
-      el.ifConditions = []
-    }
-    el.ifConditions.push(condition)
-  }
-  function processOnce(el) {
-    var once = getAndRemoveAttr(el, 'v-once')
-    if (once != null) {
-      el.once = true
-    }
-  }
-  // handle content being passed to a component as slot,
-  // e.g. <template slot="xxx">, <div slot-scope="xxx">
-  function processSlotContent(el) {
-    var slotScope
-    if (el.tag === 'template') {
-      slotScope = getAndRemoveAttr(el, 'scope')
-      /* istanbul ignore if */
-      if (slotScope) {
-        warn$1(
-          'the "scope" attribute for scoped slots have been deprecated and ' +
-            'replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ' +
-            'can also be used on plain elements in addition to <template> to ' +
-            'denote scoped slots.',
-          el.rawAttrsMap['scope'],
-          true
-        )
-      }
-      el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
-    } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-      /* istanbul ignore if */
-      if (el.attrsMap['v-for']) {
-        warn$1(
-          'Ambiguous combined usage of slot-scope and v-for on <'.concat(
-            el.tag,
-            '> '
-          ) +
-            '(v-for takes higher priority). Use a wrapper <template> for the ' +
-            'scoped slot to make it clearer.',
-          el.rawAttrsMap['slot-scope'],
-          true
-        )
-      }
-      el.slotScope = slotScope
-    }
-    // slot="xxx"
-    var slotTarget = getBindingAttr(el, 'slot')
-    if (slotTarget) {
-      el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
-      el.slotTargetDynamic = !!(
-        el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']
-      )
-      // preserve slot as an attribute for native shadow DOM compat
-      // only for non-scoped slots.
-      if (el.tag !== 'template' && !el.slotScope) {
-        addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'))
-      }
-    }
-    // 2.6 v-slot syntax
-    {
-      if (el.tag === 'template') {
-        // v-slot on <template>
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
-        if (slotBinding) {
-          {
-            if (el.slotTarget || el.slotScope) {
-              warn$1('Unexpected mixed usage of different slot syntaxes.', el)
-            }
-            if (el.parent && !maybeComponent(el.parent)) {
-              warn$1(
-                '<template v-slot> can only appear at the root level inside ' +
-                  'the receiving component',
-                el
-              )
-            }
-          }
-          var _a = getSlotName(slotBinding),
-            name_2 = _a.name,
-            dynamic = _a.dynamic
-          el.slotTarget = name_2
-          el.slotTargetDynamic = dynamic
-          el.slotScope = slotBinding.value || emptySlotScopeToken // force it into a scoped slot for perf
-        }
-      } else {
-        // v-slot on component, denotes default slot
-        var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
-        if (slotBinding) {
-          {
-            if (!maybeComponent(el)) {
-              warn$1(
-                'v-slot can only be used on components or <template>.',
-                slotBinding
-              )
-            }
-            if (el.slotScope || el.slotTarget) {
-              warn$1('Unexpected mixed usage of different slot syntaxes.', el)
-            }
-            if (el.scopedSlots) {
-              warn$1(
-                'To avoid scope ambiguity, the default slot should also use ' +
-                  '<template> syntax when there are other named slots.',
-                slotBinding
-              )
-            }
-          }
-          // add the component's children to its default slot
-          var slots = el.scopedSlots || (el.scopedSlots = {})
-          var _b = getSlotName(slotBinding),
-            name_3 = _b.name,
-            dynamic = _b.dynamic
-          var slotContainer_1 = (slots[name_3] = createASTElement(
-            'template',
-            [],
-            el
-          ))
-          slotContainer_1.slotTarget = name_3
-          slotContainer_1.slotTargetDynamic = dynamic
-          slotContainer_1.children = el.children.filter(function (c) {
-            if (!c.slotScope) {
-              c.parent = slotContainer_1
-              return true
-            }
-          })
-          slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken
-          // remove children as they are returned from scopedSlots now
-          el.children = []
-          // mark el non-plain so data gets generated
-          el.plain = false
-        }
-      }
-    }
-  }
-  function getSlotName(binding) {
-    var name = binding.name.replace(slotRE, '')
-    if (!name) {
-      if (binding.name[0] !== '#') {
-        name = 'default'
-      } else {
-        warn$1('v-slot shorthand syntax requires a slot name.', binding)
-      }
-    }
-    return dynamicArgRE.test(name)
-      ? // dynamic [name]
-        { name: name.slice(1, -1), dynamic: true }
-      : // static name
-        { name: '"'.concat(name, '"'), dynamic: false }
-  }
-  // handle <slot/> outlets
-  function processSlotOutlet(el) {
-    if (el.tag === 'slot') {
-      el.slotName = getBindingAttr(el, 'name')
-      if (el.key) {
-        warn$1(
-          '`key` does not work on <slot> because slots are abstract outlets ' +
-            'and can possibly expand into multiple elements. ' +
-            'Use the key on a wrapping element instead.',
-          getRawBindingAttr(el, 'key')
-        )
-      }
-    }
-  }
-  function processComponent(el) {
-    var binding
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true
-    }
-  }
-  function processAttrs(el) {
-    var list = el.attrsList
-    var i, l, name, rawName, value, modifiers, syncGen, isDynamic
-    for (i = 0, l = list.length; i < l; i++) {
-      name = rawName = list[i].name
-      value = list[i].value
-      if (dirRE.test(name)) {
-        // mark element as dynamic
-        el.hasBindings = true
-        // modifiers
-        modifiers = parseModifiers(name.replace(dirRE, ''))
-        // support .foo shorthand syntax for the .prop modifier
-        if (modifiers) {
-          name = name.replace(modifierRE, '')
-        }
-        if (bindRE.test(name)) {
-          // v-bind
-          name = name.replace(bindRE, '')
-          value = parseFilters(value)
-          isDynamic = dynamicArgRE.test(name)
-          if (isDynamic) {
-            name = name.slice(1, -1)
-          }
-          if (value.trim().length === 0) {
-            warn$1(
-              'The value for a v-bind expression cannot be empty. Found in "v-bind:'.concat(
-                name,
-                '"'
-              )
-            )
-          }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name)
-              if (name === 'innerHtml') name = 'innerHTML'
-            }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name)
-            }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, '$event')
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  'update:'.concat(camelize(name)),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                )
-                if (hyphenate(name) !== camelize(name)) {
-                  addHandler(
-                    el,
-                    'update:'.concat(hyphenate(name)),
-                    syncGen,
-                    null,
-                    false,
-                    warn$1,
-                    list[i]
-                  )
-                }
-              } else {
-                // handler w/ dynamic event name
-                addHandler(
-                  el,
-                  '"update:"+('.concat(name, ')'),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i],
-                  true // dynamic
-                )
-              }
-            }
-          }
-          if (
-            (modifiers && modifiers.prop) ||
-            (!el.component &&
-              platformMustUseProp(el.tag, el.attrsMap.type, name))
-          ) {
-            addProp(el, name, value, list[i], isDynamic)
-          } else {
-            addAttr(el, name, value, list[i], isDynamic)
-          }
-        } else if (onRE.test(name)) {
-          // v-on
-          name = name.replace(onRE, '')
-          isDynamic = dynamicArgRE.test(name)
-          if (isDynamic) {
-            name = name.slice(1, -1)
-          }
-          addHandler(
-            el,
-            name,
-            value,
-            modifiers,
-            false,
-            warn$1,
-            list[i],
-            isDynamic
-          )
-        } else {
-          // normal directives
-          name = name.replace(dirRE, '')
-          // parse arg
-          var argMatch = name.match(argRE)
-          var arg = argMatch && argMatch[1]
-          isDynamic = false
-          if (arg) {
-            name = name.slice(0, -(arg.length + 1))
-            if (dynamicArgRE.test(arg)) {
-              arg = arg.slice(1, -1)
-              isDynamic = true
-            }
-          }
-          addDirective(
-            el,
-            name,
-            rawName,
-            value,
-            arg,
-            isDynamic,
-            modifiers,
-            list[i]
-          )
-          if (name === 'model') {
-            checkForAliasModel(el, value)
-          }
-        }
-      } else {
-        // literal attribute
-        {
-          var res = parseText(value, delimiters)
-          if (res) {
-            warn$1(
-              ''.concat(name, '="').concat(value, '": ') +
-                'Interpolation inside attributes has been removed. ' +
-                'Use v-bind or the colon shorthand instead. For example, ' +
-                'instead of <div id="{{ val }}">, use <div :id="val">.',
-              list[i]
-            )
-          }
-        }
-        addAttr(el, name, JSON.stringify(value), list[i])
-        // #6887 firefox doesn't update muted state if set via attribute
-        // even immediately after element creation
-        if (
-          !el.component &&
-          name === 'muted' &&
-          platformMustUseProp(el.tag, el.attrsMap.type, name)
-        ) {
-          addProp(el, name, 'true', list[i])
-        }
-      }
-    }
-  }
-  function checkInFor(el) {
-    var parent = el
-    while (parent) {
-      if (parent.for !== undefined) {
-        return true
-      }
-      parent = parent.parent
-    }
-    return false
-  }
-  function parseModifiers(name) {
-    var match = name.match(modifierRE)
-    if (match) {
-      var ret_1 = {}
-      match.forEach(function (m) {
-        ret_1[m.slice(1)] = true
-      })
-      return ret_1
-    }
-  }
-  function makeAttrsMap(attrs) {
-    var map = {}
-    for (var i = 0, l = attrs.length; i < l; i++) {
-      if (map[attrs[i].name] && !isIE && !isEdge) {
-        warn$1('duplicate attribute: ' + attrs[i].name, attrs[i])
-      }
-      map[attrs[i].name] = attrs[i].value
-    }
-    return map
-  }
-  // for script (e.g. type="x/template") or style, do not decode content
-  function isTextTag(el) {
-    return el.tag === 'script' || el.tag === 'style'
-  }
-  function isForbiddenTag(el) {
-    return (
-      el.tag === 'style' ||
-      (el.tag === 'script' &&
-        (!el.attrsMap.type || el.attrsMap.type === 'text/javascript'))
-    )
-  }
-  var ieNSBug = /^xmlns:NS\d+/
-  var ieNSPrefix = /^NS\d+:/
-  /* istanbul ignore next */
-  function guardIESVGBug(attrs) {
-    var res = []
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i]
-      if (!ieNSBug.test(attr.name)) {
-        attr.name = attr.name.replace(ieNSPrefix, '')
-        res.push(attr)
-      }
-    }
-    return res
-  }
-  function checkForAliasModel(el, value) {
-    var _el = el
-    while (_el) {
-      if (_el.for && _el.alias === value) {
-        warn$1(
-          '<'.concat(el.tag, ' v-model="').concat(value, '">: ') +
-            'You are binding v-model directly to a v-for iteration alias. ' +
-            'This will not be able to modify the v-for source array because ' +
-            'writing to the alias is like modifying a function local variable. ' +
-            'Consider using an array of objects and use v-model on an object property instead.',
-          el.rawAttrsMap['v-model']
-        )
-      }
-      _el = _el.parent
-    }
-  }
-
-  /**
-   * Expand input[v-model] with dynamic type bindings into v-if-else chains
-   * Turn this:
-   *   <input v-model="data[type]" :type="type">
-   * into this:
-   *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
-   *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
-   *   <input v-else :type="type" v-model="data[type]">
-   */
-  function preTransformNode(el, options) {
-    if (el.tag === 'input') {
-      var map = el.attrsMap
-      if (!map['v-model']) {
-        return
-      }
-      var typeBinding = void 0
-      if (map[':type'] || map['v-bind:type']) {
-        typeBinding = getBindingAttr(el, 'type')
-      }
-      if (!map.type && !typeBinding && map['v-bind']) {
-        typeBinding = '('.concat(map['v-bind'], ').type')
-      }
-      if (typeBinding) {
-        var ifCondition = getAndRemoveAttr(el, 'v-if', true)
-        var ifConditionExtra = ifCondition ? '&&('.concat(ifCondition, ')') : ''
-        var hasElse = getAndRemoveAttr(el, 'v-else', true) != null
-        var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
-        // 1. checkbox
-        var branch0 = cloneASTElement(el)
-        // process for on the main node
-        processFor(branch0)
-        addRawAttr(branch0, 'type', 'checkbox')
-        processElement(branch0, options)
-        branch0.processed = true // prevent it from double-processed
-        branch0.if =
-          '('.concat(typeBinding, ")==='checkbox'") + ifConditionExtra
-        addIfCondition(branch0, {
-          exp: branch0.if,
-          block: branch0
-        })
-        // 2. add radio else-if condition
-        var branch1 = cloneASTElement(el)
-        getAndRemoveAttr(branch1, 'v-for', true)
-        addRawAttr(branch1, 'type', 'radio')
-        processElement(branch1, options)
-        addIfCondition(branch0, {
-          exp: '('.concat(typeBinding, ")==='radio'") + ifConditionExtra,
-          block: branch1
-        })
-        // 3. other
-        var branch2 = cloneASTElement(el)
-        getAndRemoveAttr(branch2, 'v-for', true)
-        addRawAttr(branch2, ':type', typeBinding)
-        processElement(branch2, options)
-        addIfCondition(branch0, {
-          exp: ifCondition,
-          block: branch2
-        })
-        if (hasElse) {
-          branch0.else = true
-        } else if (elseIfCondition) {
-          branch0.elseif = elseIfCondition
-        }
-        return branch0
-      }
-    }
-  }
-  function cloneASTElement(el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
-  }
-  var model$1 = {
-    preTransformNode: preTransformNode
-  }
-
-  var modules = [klass, style, model$1]
-
-  var warn
-  // in some cases, the event used has to be determined at runtime
-  // so we used some reserved tokens during compile.
-  var RANGE_TOKEN = '__r'
-  function model(el, dir, _warn) {
-    warn = _warn
-    var value = dir.value
-    var modifiers = dir.modifiers
-    var tag = el.tag
-    var type = el.attrsMap.type
-    {
-      // inputs with type="file" are read only and setting the input's
-      // value will throw an error.
-      if (tag === 'input' && type === 'file') {
-        warn(
-          '<'.concat(el.tag, ' v-model="').concat(value, '" type="file">:\n') +
-            'File inputs are read only. Use a v-on:change listener instead.',
-          el.rawAttrsMap['v-model']
-        )
-      }
-    }
-    if (el.component) {
-      genComponentModel(el, value, modifiers)
-      // component v-model doesn't need extra runtime
-      return false
-    } else if (tag === 'select') {
-      genSelect(el, value, modifiers)
-    } else if (tag === 'input' && type === 'checkbox') {
-      genCheckboxModel(el, value, modifiers)
-    } else if (tag === 'input' && type === 'radio') {
-      genRadioModel(el, value, modifiers)
-    } else if (tag === 'input' || tag === 'textarea') {
-      genDefaultModel(el, value, modifiers)
-    } else {
-      genComponentModel(el, value, modifiers)
-      // component v-model doesn't need extra runtime
-      return false
-    }
-    // ensure runtime directive metadata
-    return true
-  }
-  function genCheckboxModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number
-    var valueBinding = getBindingAttr(el, 'value') || 'null'
-    var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
-    var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
-    addProp(
-      el,
-      'checked',
-      'Array.isArray('.concat(value, ')') +
-        '?_i('.concat(value, ',').concat(valueBinding, ')>-1') +
-        (trueValueBinding === 'true'
-          ? ':('.concat(value, ')')
-          : ':_q('.concat(value, ',').concat(trueValueBinding, ')'))
-    )
-    addHandler(
-      el,
-      'change',
-      'var $$a='.concat(value, ',') +
-        '$$el=$event.target,' +
-        '$$c=$$el.checked?('
-          .concat(trueValueBinding, '):(')
-          .concat(falseValueBinding, ');') +
-        'if(Array.isArray($$a)){' +
-        'var $$v='.concat(
-          number ? '_n(' + valueBinding + ')' : valueBinding,
-          ','
-        ) +
-        '$$i=_i($$a,$$v);' +
-        'if($$el.checked){$$i<0&&('.concat(
-          genAssignmentCode(value, '$$a.concat([$$v])'),
-          ')}'
-        ) +
-        'else{$$i>-1&&('.concat(
-          genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))'),
-          ')}'
-        ) +
-        '}else{'.concat(genAssignmentCode(value, '$$c'), '}'),
-      null,
-      true
-    )
-  }
-  function genRadioModel(el, value, modifiers) {
-    var number = modifiers && modifiers.number
-    var valueBinding = getBindingAttr(el, 'value') || 'null'
-    valueBinding = number ? '_n('.concat(valueBinding, ')') : valueBinding
-    addProp(el, 'checked', '_q('.concat(value, ',').concat(valueBinding, ')'))
-    addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
-  }
-  function genSelect(el, value, modifiers) {
-    var number = modifiers && modifiers.number
-    var selectedVal =
-      'Array.prototype.filter' +
-      '.call($event.target.options,function(o){return o.selected})' +
-      '.map(function(o){var val = "_value" in o ? o._value : o.value;' +
-      'return '.concat(number ? '_n(val)' : 'val', '})')
-    var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
-    var code = 'var $$selectedVal = '.concat(selectedVal, ';')
-    code = ''.concat(code, ' ').concat(genAssignmentCode(value, assignment))
-    addHandler(el, 'change', code, null, true)
-  }
-  function genDefaultModel(el, value, modifiers) {
-    var type = el.attrsMap.type
-    // warn if v-bind:value conflicts with v-model
-    // except for inputs with v-bind:type
-    {
-      var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
-      var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
-      if (value_1 && !typeBinding) {
-        var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
-        warn(
-          ''
-            .concat(binding, '="')
-            .concat(value_1, '" conflicts with v-model on the same element ') +
-            'because the latter already expands to a value binding internally',
-          el.rawAttrsMap[binding]
-        )
-      }
-    }
-    var _a = modifiers || {},
-      lazy = _a.lazy,
-      number = _a.number,
-      trim = _a.trim
-    var needCompositionGuard = !lazy && type !== 'range'
-    var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'
-    var valueExpression = '$event.target.value'
-    if (trim) {
-      valueExpression = '$event.target.value.trim()'
-    }
-    if (number) {
-      valueExpression = '_n('.concat(valueExpression, ')')
-    }
-    var code = genAssignmentCode(value, valueExpression)
-    if (needCompositionGuard) {
-      code = 'if($event.target.composing)return;'.concat(code)
-    }
-    addProp(el, 'value', '('.concat(value, ')'))
-    addHandler(el, event, code, null, true)
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()')
-    }
-  }
-
-  function text(el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', '_s('.concat(dir.value, ')'), dir)
-    }
-  }
-
-  function html(el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', '_s('.concat(dir.value, ')'), dir)
-    }
-  }
-
-  var directives = {
-    model: model,
-    text: text,
-    html: html
-  }
-
-  var baseOptions = {
-    expectHTML: true,
-    modules: modules,
-    directives: directives,
-    isPreTag: isPreTag,
-    isUnaryTag: isUnaryTag,
-    mustUseProp: mustUseProp,
-    canBeLeftOpenTag: canBeLeftOpenTag,
-    isReservedTag: isReservedTag,
-    getTagNamespace: getTagNamespace,
-    staticKeys: genStaticKeys$1(modules)
-  }
-
-  var isStaticKey
-  var isPlatformReservedTag$1
-  var genStaticKeysCached = cached(genStaticKeys)
-  /**
-   * Goal of the optimizer: walk the generated template AST tree
-   * and detect sub-trees that are purely static, i.e. parts of
-   * the DOM that never needs to change.
-   *
-   * Once we detect these sub-trees, we can:
-   *
-   * 1. Hoist them into constants, so that we no longer need to
-   *    create fresh nodes for them on each re-render;
-   * 2. Completely skip them in the patching process.
-   */
-  function optimize$1(root, options) {
-    if (!root) return
-    isStaticKey = genStaticKeysCached(options.staticKeys || '')
-    isPlatformReservedTag$1 = options.isReservedTag || no
-    // first pass: mark all non-static nodes.
-    markStatic(root)
-    // second pass: mark static roots.
-    markStaticRoots(root, false)
-  }
-  function genStaticKeys(keys) {
-    return makeMap(
-      'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-        (keys ? ',' + keys : '')
-    )
-  }
-  function markStatic(node) {
-    node.static = isStatic(node)
-    if (node.type === 1) {
-      // do not make component slot content static. this avoids
-      // 1. components not able to mutate slot nodes
-      // 2. static slot content fails for hot-reloading
-      if (
-        !isPlatformReservedTag$1(node.tag) &&
-        node.tag !== 'slot' &&
-        node.attrsMap['inline-template'] == null
-      ) {
-        return
-      }
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i]
-        markStatic(child)
-        if (!child.static) {
-          node.static = false
-        }
-      }
-      if (node.ifConditions) {
-        for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-          var block = node.ifConditions[i].block
-          markStatic(block)
-          if (!block.static) {
-            node.static = false
-          }
-        }
-      }
-    }
-  }
-  function markStaticRoots(node, isInFor) {
-    if (node.type === 1) {
-      if (node.static || node.once) {
-        node.staticInFor = isInFor
-      }
-      // For a node to qualify as a static root, it should have children that
-      // are not just static text. Otherwise the cost of hoisting out will
-      // outweigh the benefits and it's better off to just always render it fresh.
-      if (
-        node.static &&
-        node.children.length &&
-        !(node.children.length === 1 && node.children[0].type === 3)
-      ) {
-        node.staticRoot = true
-        return
-      } else {
-        node.staticRoot = false
-      }
-      if (node.children) {
-        for (var i = 0, l = node.children.length; i < l; i++) {
-          markStaticRoots(node.children[i], isInFor || !!node.for)
-        }
-      }
-      if (node.ifConditions) {
-        for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-          markStaticRoots(node.ifConditions[i].block, isInFor)
-        }
-      }
-    }
-  }
-  function isStatic(node) {
-    if (node.type === 2) {
-      // expression
-      return false
-    }
-    if (node.type === 3) {
-      // text
-      return true
-    }
-    return !!(
-      node.pre ||
-      (!node.hasBindings && // no dynamic bindings
-        !node.if &&
-        !node.for && // not v-if or v-for or v-else
-        !isBuiltInTag(node.tag) && // not a built-in
-        isPlatformReservedTag$1(node.tag) && // not a component
-        !isDirectChildOfTemplateFor(node) &&
-        Object.keys(node).every(isStaticKey))
-    )
-  }
-  function isDirectChildOfTemplateFor(node) {
-    while (node.parent) {
-      node = node.parent
-      if (node.tag !== 'template') {
-        return false
-      }
-      if (node.for) {
-        return true
-      }
-    }
-    return false
-  }
-
-  var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
-  var fnInvokeRE = /\([^)]*?\);*$/
-  var simplePathRE =
-    /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
-  // KeyboardEvent.keyCode aliases
-  var keyCodes = {
-    esc: 27,
-    tab: 9,
-    enter: 13,
-    space: 32,
-    up: 38,
-    left: 37,
-    right: 39,
-    down: 40,
-    delete: [8, 46]
-  }
-  // KeyboardEvent.key aliases
-  var keyNames = {
-    // #7880: IE11 and Edge use `Esc` for Escape key name.
-    esc: ['Esc', 'Escape'],
-    tab: 'Tab',
-    enter: 'Enter',
-    // #9112: IE11 uses `Spacebar` for Space key name.
-    space: [' ', 'Spacebar'],
-    // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-    up: ['Up', 'ArrowUp'],
-    left: ['Left', 'ArrowLeft'],
-    right: ['Right', 'ArrowRight'],
-    down: ['Down', 'ArrowDown'],
-    // #9112: IE11 uses `Del` for Delete key name.
-    delete: ['Backspace', 'Delete', 'Del']
-  }
-  // #4868: modifiers that prevent the execution of the listener
-  // need to explicitly return null so that we can determine whether to remove
-  // the listener for .once
-  var genGuard = function (condition) {
-    return 'if('.concat(condition, ')return null;')
-  }
-  var modifierCode = {
-    stop: '$event.stopPropagation();',
-    prevent: '$event.preventDefault();',
-    self: genGuard('$event.target !== $event.currentTarget'),
-    ctrl: genGuard('!$event.ctrlKey'),
-    shift: genGuard('!$event.shiftKey'),
-    alt: genGuard('!$event.altKey'),
-    meta: genGuard('!$event.metaKey'),
-    left: genGuard("'button' in $event && $event.button !== 0"),
-    middle: genGuard("'button' in $event && $event.button !== 1"),
-    right: genGuard("'button' in $event && $event.button !== 2")
-  }
-  function genHandlers(events, isNative) {
-    var prefix = isNative ? 'nativeOn:' : 'on:'
-    var staticHandlers = ''
-    var dynamicHandlers = ''
-    for (var name_1 in events) {
-      var handlerCode = genHandler(events[name_1])
-      //@ts-expect-error
-      if (events[name_1] && events[name_1].dynamic) {
-        dynamicHandlers += ''.concat(name_1, ',').concat(handlerCode, ',')
-      } else {
-        staticHandlers += '"'.concat(name_1, '":').concat(handlerCode, ',')
-      }
-    }
-    staticHandlers = '{'.concat(staticHandlers.slice(0, -1), '}')
-    if (dynamicHandlers) {
-      return (
-        prefix +
-        '_d('
-          .concat(staticHandlers, ',[')
-          .concat(dynamicHandlers.slice(0, -1), '])')
-      )
-    } else {
-      return prefix + staticHandlers
-    }
-  }
-  function genHandler(handler) {
-    if (!handler) {
-      return 'function(){}'
-    }
-    if (Array.isArray(handler)) {
-      return '['.concat(
-        handler
-          .map(function (handler) {
-            return genHandler(handler)
-          })
-          .join(','),
-        ']'
-      )
-    }
-    var isMethodPath = simplePathRE.test(handler.value)
-    var isFunctionExpression = fnExpRE.test(handler.value)
-    var isFunctionInvocation = simplePathRE.test(
-      handler.value.replace(fnInvokeRE, '')
-    )
-    if (!handler.modifiers) {
-      if (isMethodPath || isFunctionExpression) {
-        return handler.value
-      }
-      return 'function($event){'.concat(
-        isFunctionInvocation ? 'return '.concat(handler.value) : handler.value,
-        '}'
-      ) // inline statement
-    } else {
-      var code = ''
-      var genModifierCode = ''
-      var keys = []
-      var _loop_1 = function (key) {
-        if (modifierCode[key]) {
-          genModifierCode += modifierCode[key]
-          // left/right
-          if (keyCodes[key]) {
-            keys.push(key)
-          }
-        } else if (key === 'exact') {
-          var modifiers_1 = handler.modifiers
-          genModifierCode += genGuard(
-            ['ctrl', 'shift', 'alt', 'meta']
-              .filter(function (keyModifier) {
-                return !modifiers_1[keyModifier]
-              })
-              .map(function (keyModifier) {
-                return '$event.'.concat(keyModifier, 'Key')
-              })
-              .join('||')
-          )
-        } else {
-          keys.push(key)
-        }
-      }
-      for (var key in handler.modifiers) {
-        _loop_1(key)
-      }
-      if (keys.length) {
-        code += genKeyFilter(keys)
-      }
-      // Make sure modifiers like prevent and stop get executed after key filtering
-      if (genModifierCode) {
-        code += genModifierCode
-      }
-      var handlerCode = isMethodPath
-        ? 'return '.concat(handler.value, '.apply(null, arguments)')
-        : isFunctionExpression
-        ? 'return ('.concat(handler.value, ').apply(null, arguments)')
-        : isFunctionInvocation
-        ? 'return '.concat(handler.value)
-        : handler.value
-      return 'function($event){'.concat(code).concat(handlerCode, '}')
-    }
-  }
-  function genKeyFilter(keys) {
-    return (
-      // make sure the key filters only apply to KeyboardEvents
-      // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-      // key events that do not have keyCode property...
-      "if(!$event.type.indexOf('key')&&" +
-      ''.concat(keys.map(genFilterCode).join('&&'), ')return null;')
-    )
-  }
-  function genFilterCode(key) {
-    var keyVal = parseInt(key, 10)
-    if (keyVal) {
-      return '$event.keyCode!=='.concat(keyVal)
-    }
-    var keyCode = keyCodes[key]
-    var keyName = keyNames[key]
-    return (
-      '_k($event.keyCode,' +
-      ''.concat(JSON.stringify(key), ',') +
-      ''.concat(JSON.stringify(keyCode), ',') +
-      '$event.key,' +
-      ''.concat(JSON.stringify(keyName)) +
-      ')'
-    )
-  }
-
-  function on(el, dir) {
-    if (dir.modifiers) {
-      warn$2('v-on without argument does not support modifiers.')
-    }
-    el.wrapListeners = function (code) {
-      return '_g('.concat(code, ',').concat(dir.value, ')')
-    }
-  }
-
-  function bind(el, dir) {
-    el.wrapData = function (code) {
-      return '_b('
-        .concat(code, ",'")
-        .concat(el.tag, "',")
-        .concat(dir.value, ',')
-        .concat(dir.modifiers && dir.modifiers.prop ? 'true' : 'false')
-        .concat(dir.modifiers && dir.modifiers.sync ? ',true' : '', ')')
-    }
-  }
-
-  var baseDirectives = {
-    on: on,
-    bind: bind,
-    cloak: noop
-  }
-
-  var CodegenState = /** @class */ (function () {
-    function CodegenState(options) {
-      this.options = options
-      this.warn = options.warn || baseWarn
-      //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-      this.transforms = pluckModuleFunction(options.modules, 'transformCode')
-      this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
-      this.directives = extend(extend({}, baseDirectives), options.directives)
-      var isReservedTag = options.isReservedTag || no
-      this.maybeComponent = function (el) {
-        return !!el.component || !isReservedTag(el.tag)
-      }
-      this.onceId = 0
-      this.staticRenderFns = []
-      this.pre = false
-    }
-    return CodegenState
-  })()
-  function generate$1(ast, options) {
-    var state = new CodegenState(options)
-    // fix #11483, Root level <script> tags should not be rendered.
-    var code = ast
-      ? ast.tag === 'script'
-        ? 'null'
-        : genElement(ast, state)
-      : '_c("div")'
-    return {
-      render: 'with(this){return '.concat(code, '}'),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-  function genElement(el, state) {
-    if (el.parent) {
-      el.pre = el.pre || el.parent.pre
-    }
-    if (el.staticRoot && !el.staticProcessed) {
-      return genStatic(el, state)
-    } else if (el.once && !el.onceProcessed) {
-      return genOnce(el, state)
-    } else if (el.for && !el.forProcessed) {
-      return genFor(el, state)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-      return genChildren(el, state) || 'void 0'
-    } else if (el.tag === 'slot') {
-      return genSlot(el, state)
-    } else {
-      // component or element
-      var code = void 0
-      if (el.component) {
-        code = genComponent(el.component, el, state)
-      } else {
-        var data = void 0
-        if (!el.plain || (el.pre && state.maybeComponent(el))) {
-          data = genData(el, state)
-        }
-        var children = el.inlineTemplate ? null : genChildren(el, state, true)
-        code = "_c('"
-          .concat(el.tag, "'")
-          .concat(
-            data ? ','.concat(data) : '' // data
-          )
-          .concat(
-            children ? ','.concat(children) : '', // children
-            ')'
-          )
-      }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code)
-      }
-      return code
-    }
-  }
-  // hoist static sub-trees out
-  function genStatic(el, state) {
-    el.staticProcessed = true
-    // Some elements (templates) need to behave differently inside of a v-pre
-    // node.  All pre nodes are static roots, so we can use this as a location to
-    // wrap a state change and reset it upon exiting the pre node.
-    var originalPreState = state.pre
-    if (el.pre) {
-      state.pre = el.pre
-    }
-    state.staticRenderFns.push(
-      'with(this){return '.concat(genElement(el, state), '}')
-    )
-    state.pre = originalPreState
-    return '_m('
-      .concat(state.staticRenderFns.length - 1)
-      .concat(el.staticInFor ? ',true' : '', ')')
-  }
-  // v-once
-  function genOnce(el, state) {
-    el.onceProcessed = true
-    if (el.if && !el.ifProcessed) {
-      return genIf(el, state)
-    } else if (el.staticInFor) {
-      var key = ''
-      var parent_1 = el.parent
-      while (parent_1) {
-        if (parent_1.for) {
-          key = parent_1.key
-          break
-        }
-        parent_1 = parent_1.parent
-      }
-      if (!key) {
-        state.warn(
-          'v-once can only be used inside v-for that is keyed. ',
-          el.rawAttrsMap['v-once']
-        )
-        return genElement(el, state)
-      }
-      return '_o('
-        .concat(genElement(el, state), ',')
-        .concat(state.onceId++, ',')
-        .concat(key, ')')
-    } else {
-      return genStatic(el, state)
-    }
-  }
-  function genIf(el, state, altGen, altEmpty) {
-    el.ifProcessed = true // avoid recursion
-    return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-  }
-  function genIfConditions(conditions, state, altGen, altEmpty) {
-    if (!conditions.length) {
-      return altEmpty || '_e()'
-    }
-    var condition = conditions.shift()
-    if (condition.exp) {
-      return '('
-        .concat(condition.exp, ')?')
-        .concat(genTernaryExp(condition.block), ':')
-        .concat(genIfConditions(conditions, state, altGen, altEmpty))
-    } else {
-      return ''.concat(genTernaryExp(condition.block))
-    }
-    // v-if with v-once should generate code like (a)?_m(0):_m(1)
-    function genTernaryExp(el) {
-      return altGen
-        ? altGen(el, state)
-        : el.once
-        ? genOnce(el, state)
-        : genElement(el, state)
-    }
-  }
-  function genFor(el, state, altGen, altHelper) {
-    var exp = el.for
-    var alias = el.alias
-    var iterator1 = el.iterator1 ? ','.concat(el.iterator1) : ''
-    var iterator2 = el.iterator2 ? ','.concat(el.iterator2) : ''
-    if (
-      state.maybeComponent(el) &&
-      el.tag !== 'slot' &&
-      el.tag !== 'template' &&
-      !el.key
-    ) {
-      state.warn(
-        '<'
-          .concat(el.tag, ' v-for="')
-          .concat(alias, ' in ')
-          .concat(exp, '">: component lists rendered with ') +
-          'v-for should have explicit keys. ' +
-          'See https://vuejs.org/guide/list.html#key for more info.',
-        el.rawAttrsMap['v-for'],
-        true /* tip */
-      )
-    }
-    el.forProcessed = true // avoid recursion
-    return (
-      ''.concat(altHelper || '_l', '((').concat(exp, '),') +
-      'function('.concat(alias).concat(iterator1).concat(iterator2, '){') +
-      'return '.concat((altGen || genElement)(el, state)) +
-      '})'
-    )
-  }
-  function genData(el, state) {
-    var data = '{'
-    // directives first.
-    // directives may mutate the el's other properties before they are generated.
-    var dirs = genDirectives(el, state)
-    if (dirs) data += dirs + ','
-    // key
-    if (el.key) {
-      data += 'key:'.concat(el.key, ',')
-    }
-    // ref
-    if (el.ref) {
-      data += 'ref:'.concat(el.ref, ',')
-    }
-    if (el.refInFor) {
-      data += 'refInFor:true,'
-    }
-    // pre
-    if (el.pre) {
-      data += 'pre:true,'
-    }
-    // record original tag name for components using "is" attribute
-    if (el.component) {
-      data += 'tag:"'.concat(el.tag, '",')
-    }
-    // module data generation functions
-    for (var i = 0; i < state.dataGenFns.length; i++) {
-      data += state.dataGenFns[i](el)
-    }
-    // attributes
-    if (el.attrs) {
-      data += 'attrs:'.concat(genProps(el.attrs), ',')
-    }
-    // DOM props
-    if (el.props) {
-      data += 'domProps:'.concat(genProps(el.props), ',')
-    }
-    // event handlers
-    if (el.events) {
-      data += ''.concat(genHandlers(el.events, false), ',')
-    }
-    if (el.nativeEvents) {
-      data += ''.concat(genHandlers(el.nativeEvents, true), ',')
-    }
-    // slot target
-    // only for non-scoped slots
-    if (el.slotTarget && !el.slotScope) {
-      data += 'slot:'.concat(el.slotTarget, ',')
-    }
-    // scoped slots
-    if (el.scopedSlots) {
-      data += ''.concat(genScopedSlots(el, el.scopedSlots, state), ',')
-    }
-    // component v-model
-    if (el.model) {
-      data += 'model:{value:'
-        .concat(el.model.value, ',callback:')
-        .concat(el.model.callback, ',expression:')
-        .concat(el.model.expression, '},')
-    }
-    // inline-template
-    if (el.inlineTemplate) {
-      var inlineTemplate = genInlineTemplate(el, state)
-      if (inlineTemplate) {
-        data += ''.concat(inlineTemplate, ',')
-      }
-    }
-    data = data.replace(/,$/, '') + '}'
-    // v-bind dynamic argument wrap
-    // v-bind with dynamic arguments must be applied using the same v-bind object
-    // merge helper so that class/style/mustUseProp attrs are handled correctly.
-    if (el.dynamicAttrs) {
-      data = '_b('
-        .concat(data, ',"')
-        .concat(el.tag, '",')
-        .concat(genProps(el.dynamicAttrs), ')')
-    }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data)
-    }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data)
-    }
-    return data
-  }
-  function genDirectives(el, state) {
-    var dirs = el.directives
-    if (!dirs) return
-    var res = 'directives:['
-    var hasRuntime = false
-    var i, l, dir, needRuntime
-    for (i = 0, l = dirs.length; i < l; i++) {
-      dir = dirs[i]
-      needRuntime = true
-      var gen = state.directives[dir.name]
-      if (gen) {
-        // compile-time directive that manipulates AST.
-        // returns true if it also needs a runtime counterpart.
-        needRuntime = !!gen(el, dir, state.warn)
-      }
-      if (needRuntime) {
-        hasRuntime = true
-        res += '{name:"'
-          .concat(dir.name, '",rawName:"')
-          .concat(dir.rawName, '"')
-          .concat(
-            dir.value
-              ? ',value:('
-                  .concat(dir.value, '),expression:')
-                  .concat(JSON.stringify(dir.value))
-              : ''
-          )
-          .concat(
-            dir.arg
-              ? ',arg:'.concat(
-                  dir.isDynamicArg ? dir.arg : '"'.concat(dir.arg, '"')
-                )
-              : ''
-          )
-          .concat(
-            dir.modifiers
-              ? ',modifiers:'.concat(JSON.stringify(dir.modifiers))
-              : '',
-            '},'
-          )
-      }
-    }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
-  }
-  function genInlineTemplate(el, state) {
-    var ast = el.children[0]
-    if (el.children.length !== 1 || ast.type !== 1) {
-      state.warn(
-        'Inline-template components must have exactly one child element.',
-        { start: el.start }
-      )
-    }
-    if (ast && ast.type === 1) {
-      var inlineRenderFns = generate$1(ast, state.options)
-      return 'inlineTemplate:{render:function(){'
-        .concat(inlineRenderFns.render, '},staticRenderFns:[')
-        .concat(
-          inlineRenderFns.staticRenderFns
-            .map(function (code) {
-              return 'function(){'.concat(code, '}')
-            })
-            .join(','),
-          ']}'
-        )
-    }
-  }
-  function genScopedSlots(el, slots, state) {
-    // by default scoped slots are considered "stable", this allows child
-    // components with only scoped slots to skip forced updates from parent.
-    // but in some cases we have to bail-out of this optimization
-    // for example if the slot contains dynamic names, has v-if or v-for on them...
-    var needsForceUpdate =
-      el.for ||
-      Object.keys(slots).some(function (key) {
-        var slot = slots[key]
-        return (
-          slot.slotTargetDynamic ||
-          slot.if ||
-          slot.for ||
-          containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-        )
-      })
-    // #9534: if a component with scoped slots is inside a conditional branch,
-    // it's possible for the same component to be reused but with different
-    // compiled slot content. To avoid that, we generate a unique key based on
-    // the generated code of all the slot contents.
-    var needsKey = !!el.if
-    // OR when it is inside another scoped slot or v-for (the reactivity may be
-    // disconnected due to the intermediate scope variable)
-    // #9438, #9506
-    // TODO: this can be further optimized by properly analyzing in-scope bindings
-    // and skip force updating ones that do not actually use scope variables.
-    if (!needsForceUpdate) {
-      var parent_2 = el.parent
-      while (parent_2) {
-        if (
-          (parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-          parent_2.for
-        ) {
-          needsForceUpdate = true
-          break
-        }
-        if (parent_2.if) {
-          needsKey = true
-        }
-        parent_2 = parent_2.parent
-      }
-    }
-    var generatedSlots = Object.keys(slots)
-      .map(function (key) {
-        return genScopedSlot(slots[key], state)
-      })
-      .join(',')
-    return 'scopedSlots:_u(['
-      .concat(generatedSlots, ']')
-      .concat(needsForceUpdate ? ',null,true' : '')
-      .concat(
-        !needsForceUpdate && needsKey
-          ? ',null,false,'.concat(hash(generatedSlots))
-          : '',
-        ')'
-      )
-  }
-  function hash(str) {
-    var hash = 5381
-    var i = str.length
-    while (i) {
-      hash = (hash * 33) ^ str.charCodeAt(--i)
-    }
-    return hash >>> 0
-  }
-  function containsSlotChild(el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
-      }
-      return el.children.some(containsSlotChild)
-    }
-    return false
-  }
-  function genScopedSlot(el, state) {
-    var isLegacySyntax = el.attrsMap['slot-scope']
-    if (el.if && !el.ifProcessed && !isLegacySyntax) {
-      return genIf(el, state, genScopedSlot, 'null')
-    }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
-    }
-    var slotScope =
-      el.slotScope === emptySlotScopeToken ? '' : String(el.slotScope)
-    var fn =
-      'function('.concat(slotScope, '){') +
-      'return '.concat(
-        el.tag === 'template'
-          ? el.if && isLegacySyntax
-            ? '('
-                .concat(el.if, ')?')
-                .concat(genChildren(el, state) || 'undefined', ':undefined')
-            : genChildren(el, state) || 'undefined'
-          : genElement(el, state),
-        '}'
-      )
-    // reverse proxy v-slot without scope on this.$slots
-    var reverseProxy = slotScope ? '' : ',proxy:true'
-    return '{key:'
-      .concat(el.slotTarget || '"default"', ',fn:')
-      .concat(fn)
-      .concat(reverseProxy, '}')
-  }
-  function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-    var children = el.children
-    if (children.length) {
-      var el_1 = children[0]
-      // optimize single v-for
-      if (
-        children.length === 1 &&
-        el_1.for &&
-        el_1.tag !== 'template' &&
-        el_1.tag !== 'slot'
-      ) {
-        var normalizationType_1 = checkSkip
-          ? state.maybeComponent(el_1)
-            ? ',1'
-            : ',0'
-          : ''
-        return ''
-          .concat((altGenElement || genElement)(el_1, state))
-          .concat(normalizationType_1)
-      }
-      var normalizationType = checkSkip
-        ? getNormalizationType(children, state.maybeComponent)
-        : 0
-      var gen_1 = altGenNode || genNode
-      return '['
-        .concat(
-          children
-            .map(function (c) {
-              return gen_1(c, state)
-            })
-            .join(','),
-          ']'
-        )
-        .concat(normalizationType ? ','.concat(normalizationType) : '')
-    }
-  }
-  // determine the normalization needed for the children array.
-  // 0: no normalization needed
-  // 1: simple normalization needed (possible 1-level deep nested array)
-  // 2: full normalization needed
-  function getNormalizationType(children, maybeComponent) {
-    var res = 0
-    for (var i = 0; i < children.length; i++) {
-      var el = children[i]
-      if (el.type !== 1) {
-        continue
-      }
-      if (
-        needsNormalization(el) ||
-        (el.ifConditions &&
-          el.ifConditions.some(function (c) {
-            return needsNormalization(c.block)
-          }))
-      ) {
-        res = 2
-        break
-      }
-      if (
-        maybeComponent(el) ||
-        (el.ifConditions &&
-          el.ifConditions.some(function (c) {
-            return maybeComponent(c.block)
-          }))
-      ) {
-        res = 1
-      }
-    }
-    return res
-  }
-  function needsNormalization(el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-  }
-  function genNode(node, state) {
-    if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
-    }
-  }
-  function genText(text) {
-    return '_v('.concat(
-      text.type === 2
-        ? text.expression // no need for () because already wrapped in _s()
-        : transformSpecialNewlines(JSON.stringify(text.text)),
-      ')'
-    )
-  }
-  function genComment(comment) {
-    return '_e('.concat(JSON.stringify(comment.text), ')')
-  }
-  function genSlot(el, state) {
-    var slotName = el.slotName || '"default"'
-    var children = genChildren(el, state)
-    var res = '_t('
-      .concat(slotName)
-      .concat(children ? ',function(){return '.concat(children, '}') : '')
-    var attrs =
-      el.attrs || el.dynamicAttrs
-        ? genProps(
-            (el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) {
-              return {
-                // slot props are camelized
-                name: camelize(attr.name),
-                value: attr.value,
-                dynamic: attr.dynamic
-              }
-            })
-          )
-        : null
-    var bind = el.attrsMap['v-bind']
-    if ((attrs || bind) && !children) {
-      res += ',null'
-    }
-    if (attrs) {
-      res += ','.concat(attrs)
-    }
-    if (bind) {
-      res += ''.concat(attrs ? '' : ',null', ',').concat(bind)
-    }
-    return res + ')'
-  }
-  // componentName is el.component, take it as argument to shun flow's pessimistic refinement
-  function genComponent(componentName, el, state) {
-    var children = el.inlineTemplate ? null : genChildren(el, state, true)
-    return '_c('
-      .concat(componentName, ',')
-      .concat(genData(el, state))
-      .concat(children ? ','.concat(children) : '', ')')
-  }
-  function genProps(props) {
-    var staticProps = ''
-    var dynamicProps = ''
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i]
-      var value = transformSpecialNewlines(prop.value)
-      if (prop.dynamic) {
-        dynamicProps += ''.concat(prop.name, ',').concat(value, ',')
-      } else {
-        staticProps += '"'.concat(prop.name, '":').concat(value, ',')
-      }
-    }
-    staticProps = '{'.concat(staticProps.slice(0, -1), '}')
-    if (dynamicProps) {
-      return '_d('
-        .concat(staticProps, ',[')
-        .concat(dynamicProps.slice(0, -1), '])')
-    } else {
-      return staticProps
-    }
-  }
-  // #3895, #4268
-  function transformSpecialNewlines(text) {
-    return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
-  }
-
-  // these keywords should not appear inside expressions, but operators like
-  // typeof, instanceof and in are allowed
-  var prohibitedKeywordRE = new RegExp(
-    '\\b' +
-      (
-        'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-        'super,throw,while,yield,delete,export,import,return,switch,default,' +
-        'extends,finally,continue,debugger,function,arguments'
-      )
-        .split(',')
-        .join('\\b|\\b') +
-      '\\b'
-  )
-  // these unary operators should not be used as property/method names
-  var unaryOperatorsRE = new RegExp(
-    '\\b' +
-      'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-      '\\s*\\([^\\)]*\\)'
-  )
-  // strip strings in expressions
-  var stripStringRE =
-    /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
-  // detect problematic expressions in a template
-  function detectErrors(ast, warn) {
-    if (ast) {
-      checkNode(ast, warn)
-    }
-  }
-  function checkNode(node, warn) {
-    if (node.type === 1) {
-      for (var name_1 in node.attrsMap) {
-        if (dirRE.test(name_1)) {
-          var value = node.attrsMap[name_1]
-          if (value) {
-            var range = node.rawAttrsMap[name_1]
-            if (name_1 === 'v-for') {
-              checkFor(node, 'v-for="'.concat(value, '"'), warn, range)
-            } else if (name_1 === 'v-slot' || name_1[0] === '#') {
-              checkFunctionParameterExpression(
-                value,
-                ''.concat(name_1, '="').concat(value, '"'),
-                warn,
-                range
-              )
-            } else if (onRE.test(name_1)) {
-              checkEvent(
-                value,
-                ''.concat(name_1, '="').concat(value, '"'),
-                warn,
-                range
-              )
-            } else {
-              checkExpression(
-                value,
-                ''.concat(name_1, '="').concat(value, '"'),
-                warn,
-                range
-              )
-            }
-          }
-        }
-      }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn)
-        }
-      }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node)
-    }
-  }
-  function checkEvent(exp, text, warn, range) {
-    var stripped = exp.replace(stripStringRE, '')
-    var keywordMatch = stripped.match(unaryOperatorsRE)
-    if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        'avoid using JavaScript unary operator as property name: ' +
-          '"'.concat(keywordMatch[0], '" in expression ').concat(text.trim()),
-        range
-      )
-    }
-    checkExpression(exp, text, warn, range)
-  }
-  function checkFor(node, text, warn, range) {
-    checkExpression(node.for || '', text, warn, range)
-    checkIdentifier(node.alias, 'v-for alias', text, warn, range)
-    checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
-    checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
-  }
-  function checkIdentifier(ident, type, text, warn, range) {
-    if (typeof ident === 'string') {
-      try {
-        new Function('var '.concat(ident, '=_'))
-      } catch (e) {
-        warn(
-          'invalid '
-            .concat(type, ' "')
-            .concat(ident, '" in expression: ')
-            .concat(text.trim()),
-          range
-        )
-      }
-    }
-  }
-  function checkExpression(exp, text, warn, range) {
-    try {
-      new Function('return '.concat(exp))
-    } catch (e) {
-      var keywordMatch = exp
-        .replace(stripStringRE, '')
-        .match(prohibitedKeywordRE)
-      if (keywordMatch) {
-        warn(
-          'avoid using JavaScript keyword as property name: ' +
-            '"'
-              .concat(keywordMatch[0], '"\n  Raw expression: ')
-              .concat(text.trim()),
-          range
-        )
-      } else {
-        warn(
-          'invalid expression: '.concat(e.message, ' in\n\n') +
-            '    '.concat(exp, '\n\n') +
-            '  Raw expression: '.concat(text.trim(), '\n'),
-          range
-        )
-      }
-    }
-  }
-  function checkFunctionParameterExpression(exp, text, warn, range) {
-    try {
-      new Function(exp, '')
-    } catch (e) {
-      warn(
-        'invalid function parameter expression: '.concat(e.message, ' in\n\n') +
-          '    '.concat(exp, '\n\n') +
-          '  Raw expression: '.concat(text.trim(), '\n'),
-        range
-      )
-    }
-  }
-
-  var range = 2
-  function generateCodeFrame(source, start, end) {
-    if (start === void 0) {
-      start = 0
-    }
-    if (end === void 0) {
-      end = source.length
-    }
-    var lines = source.split(/\r?\n/)
-    var count = 0
-    var res = []
-    for (var i = 0; i < lines.length; i++) {
-      count += lines[i].length + 1
-      if (count >= start) {
-        for (var j = i - range; j <= i + range || end > count; j++) {
-          if (j < 0 || j >= lines.length) continue
-          res.push(
-            ''
-              .concat(j + 1)
-              .concat(repeat(' ', 3 - String(j + 1).length), '|  ')
-              .concat(lines[j])
-          )
-          var lineLength = lines[j].length
-          if (j === i) {
-            // push underline
-            var pad = start - (count - lineLength) + 1
-            var length_1 = end > count ? lineLength - pad : end - start
-            res.push('   |  ' + repeat(' ', pad) + repeat('^', length_1))
-          } else if (j > i) {
-            if (end > count) {
-              var length_2 = Math.min(end - count, lineLength)
-              res.push('   |  ' + repeat('^', length_2))
-            }
-            count += lineLength + 1
-          }
-        }
-        break
-      }
-    }
-    return res.join('\n')
-  }
-  function repeat(str, n) {
-    var result = ''
-    if (n > 0) {
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        // eslint-disable-line
-        if (n & 1) result += str
-        n >>>= 1
-        if (n <= 0) break
-        str += str
-      }
-    }
-    return result
-  }
-
-  function createFunction(code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code })
-      return noop
-    }
-  }
-  function createCompileToFunctionFn(compile) {
-    var cache = Object.create(null)
-    return function compileToFunctions(template, options, vm) {
-      options = extend({}, options)
-      var warn = options.warn || warn$2
-      delete options.warn
-      /* istanbul ignore if */
-      {
-        // detect possible CSP restriction
-        try {
-          new Function('return 1')
-        } catch (e) {
-          if (e.toString().match(/unsafe-eval|CSP/)) {
-            warn(
-              'It seems you are using the standalone build of Vue.js in an ' +
-                'environment with Content Security Policy that prohibits unsafe-eval. ' +
-                'The template compiler cannot work in this environment. Consider ' +
-                'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-                'templates into render functions.'
-            )
-          }
-        }
-      }
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template
-      if (cache[key]) {
-        return cache[key]
-      }
-      // compile
-      var compiled = compile(template, options)
-      // check compilation errors/tips
-      {
-        if (compiled.errors && compiled.errors.length) {
-          if (options.outputSourceRange) {
-            compiled.errors.forEach(function (e) {
-              warn(
-                'Error compiling template:\n\n'.concat(e.msg, '\n\n') +
-                  generateCodeFrame(template, e.start, e.end),
-                vm
-              )
-            })
-          } else {
-            warn(
-              'Error compiling template:\n\n'.concat(template, '\n\n') +
-                compiled.errors
-                  .map(function (e) {
-                    return '- '.concat(e)
-                  })
-                  .join('\n') +
-                '\n',
-              vm
-            )
-          }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) {
-              return tip(e.msg, vm)
-            })
-          } else {
-            compiled.tips.forEach(function (msg) {
-              return tip(msg, vm)
-            })
-          }
-        }
-      }
-      // turn code into functions
-      var res = {}
-      var fnGenErrors = []
-      res.render = createFunction(compiled.render, fnGenErrors)
-      res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-        return createFunction(code, fnGenErrors)
-      })
-      // check function generation errors.
-      // this should only happen if there is a bug in the compiler itself.
-      // mostly for codegen development use
-      /* istanbul ignore if */
-      {
-        if (
-          (!compiled.errors || !compiled.errors.length) &&
-          fnGenErrors.length
-        ) {
-          warn(
-            'Failed to generate render function:\n\n' +
-              fnGenErrors
-                .map(function (_a) {
-                  var err = _a.err,
-                    code = _a.code
-                  return ''.concat(err.toString(), ' in\n\n').concat(code, '\n')
-                })
-                .join('\n'),
-            vm
-          )
-        }
-      }
-      return (cache[key] = res)
-    }
-  }
-
-  function createCompilerCreator(baseCompile) {
-    return function createCompiler(baseOptions) {
-      function compile(template, options) {
-        var finalOptions = Object.create(baseOptions)
-        var errors = []
-        var tips = []
-        var warn = function (msg, range, tip) {
-          ;(tip ? tips : errors).push(msg)
-        }
-        if (options) {
-          if (options.outputSourceRange) {
-            // $flow-disable-line
-            var leadingSpaceLength_1 = template.match(/^\s*/)[0].length
-            warn = function (msg, range, tip) {
-              var data = typeof msg === 'string' ? { msg: msg } : msg
-              if (range) {
-                if (range.start != null) {
-                  data.start = range.start + leadingSpaceLength_1
-                }
-                if (range.end != null) {
-                  data.end = range.end + leadingSpaceLength_1
-                }
-              }
-              ;(tip ? tips : errors).push(data)
-            }
-          }
-          // merge custom modules
-          if (options.modules) {
-            finalOptions.modules = (baseOptions.modules || []).concat(
-              options.modules
-            )
-          }
-          // merge custom directives
-          if (options.directives) {
-            finalOptions.directives = extend(
-              Object.create(baseOptions.directives || null),
-              options.directives
-            )
-          }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key]
-            }
-          }
-        }
-        finalOptions.warn = warn
-        var compiled = baseCompile(template.trim(), finalOptions)
-        {
-          detectErrors(compiled.ast, warn)
-        }
-        compiled.errors = errors
-        compiled.tips = tips
-        return compiled
-      }
-      return {
-        compile: compile,
-        compileToFunctions: createCompileToFunctionFn(compile)
-      }
-    }
-  }
-
-  // `createCompilerCreator` allows creating compilers that use alternative
-  // parser/optimizer/codegen, e.g the SSR optimizing compiler.
-  // Here we just export a default compiler using the default parts.
-  var createCompiler$1 = createCompilerCreator(function baseCompile(
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options)
-    if (options.optimize !== false) {
-      optimize$1(ast, options)
-    }
-    var code = generate$1(ast, options)
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
-  })
-
-  var _a$1 = createCompiler$1(baseOptions),
-    compile$1 = _a$1.compile,
-    compileToFunctions$1 = _a$1.compileToFunctions
-
-  var isAttr = makeMap(
-    'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-      'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-      'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-      'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-      'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-      'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-      'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-      'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-      'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-      'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-      'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-      'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-      'target,title,usemap,value,width,wrap'
-  )
-  /* istanbul ignore next */
-  var isRenderableAttr = function (name) {
-    return (
-      isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
-    )
-  }
-  var propsToAttrMap = {
-    acceptCharset: 'accept-charset',
-    className: 'class',
-    htmlFor: 'for',
-    httpEquiv: 'http-equiv'
-  }
-  var ESC = {
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    '&': '&amp;'
-  }
-  function escape(s) {
-    return s.replace(/[<>"&]/g, escapeChar)
-  }
-  function escapeChar(a) {
-    return ESC[a] || a
-  }
-
-  var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
-  // let the model AST transform translate v-model into appropriate
-  // props bindings
-  function applyModelTransform(el, state) {
-    if (el.directives) {
-      for (var i = 0; i < el.directives.length; i++) {
-        var dir = el.directives[i]
-        if (dir.name === 'model') {
-          state.directives.model(el, dir, state.warn)
-          // remove value for textarea as its converted to text
-          if (el.tag === 'textarea' && el.props) {
-            el.props = el.props.filter(function (p) {
-              return p.name !== 'value'
-            })
-          }
-          break
-        }
-      }
-    }
-  }
-  function genAttrSegments(attrs) {
-    return attrs.map(function (_a) {
-      var name = _a.name,
-        value = _a.value
-      return genAttrSegment(name, value)
-    })
-  }
-  function genDOMPropSegments(props, attrs) {
-    var segments = []
-    props.forEach(function (_a) {
-      var name = _a.name,
-        value = _a.value
-      name = propsToAttrMap[name] || name.toLowerCase()
-      if (
-        isRenderableAttr(name) &&
-        !(
-          attrs &&
-          attrs.some(function (a) {
-            return a.name === name
-          })
-        )
-      ) {
-        segments.push(genAttrSegment(name, value))
-      }
-    })
-    return segments
-  }
-  function genAttrSegment(name, value) {
-    if (plainStringRE.test(value)) {
-      // force double quote
-      value = value.replace(/^'|'$/g, '"')
-      // force enumerated attr to "true"
-      if (isEnumeratedAttr(name) && value !== '"false"') {
-        value = '"true"'
-      }
-      return {
-        type: RAW,
-        value: isBooleanAttr(name)
-          ? ' '.concat(name, '="').concat(name, '"')
-          : value === '""'
-          ? ' '.concat(name)
-          : ' '.concat(name, '="').concat(JSON.parse(value), '"')
-      }
-    } else {
-      return {
-        type: EXPRESSION,
-        value: '_ssrAttr('.concat(JSON.stringify(name), ',').concat(value, ')')
-      }
-    }
-  }
-  function genClassSegments(staticClass, classBinding) {
-    if (staticClass && !classBinding) {
-      return [
-        { type: RAW, value: ' class="'.concat(JSON.parse(staticClass), '"') }
-      ]
-    } else {
-      return [
-        {
-          type: EXPRESSION,
-          value: '_ssrClass('
-            .concat(staticClass || 'null', ',')
-            .concat(classBinding || 'null', ')')
-        }
-      ]
-    }
-  }
-  function genStyleSegments(
-    staticStyle,
-    parsedStaticStyle,
-    styleBinding,
-    vShowExpression
-  ) {
-    if (staticStyle && !styleBinding && !vShowExpression) {
-      return [
-        { type: RAW, value: ' style='.concat(JSON.stringify(staticStyle)) }
-      ]
-    } else {
-      return [
-        {
-          type: EXPRESSION,
-          value: '_ssrStyle('
-            .concat(parsedStaticStyle || 'null', ',')
-            .concat(styleBinding || 'null', ', ')
-            .concat(
-              vShowExpression
-                ? '{ display: ('.concat(vShowExpression, ") ? '' : 'none' }")
-                : 'null',
-              ')'
-            )
-        }
-      ]
-    }
-  }
-
-  /**
-   * In SSR, the vdom tree is generated only once and never patched, so
-   * we can optimize most element / trees into plain string render functions.
-   * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
-   *
-   * The criteria for SSR optimizability is quite a bit looser than static tree
-   * detection (which is designed for client re-render). In SSR we bail only for
-   * components/slots/custom directives.
-   */
-  // optimizability constants
-  var optimizability = {
-    FALSE: 0,
-    FULL: 1,
-    SELF: 2,
-    CHILDREN: 3,
-    PARTIAL: 4 // self un-optimizable with some un-optimizable children
-  }
-  var isPlatformReservedTag
-  function optimize(root, options) {
-    if (!root) return
-    isPlatformReservedTag = options.isReservedTag || no
-    walk(root, true)
-  }
-  function walk(node, isRoot) {
-    if (isUnOptimizableTree(node)) {
-      node.ssrOptimizability = optimizability.FALSE
-      return
-    }
-    // root node or nodes with custom directives should always be a VNode
-    var selfUnoptimizable = isRoot || hasCustomDirective(node)
-    var check = function (child) {
-      if (child.ssrOptimizability !== optimizability.FULL) {
-        node.ssrOptimizability = selfUnoptimizable
-          ? optimizability.PARTIAL
-          : optimizability.SELF
-      }
-    }
-    if (selfUnoptimizable) {
-      node.ssrOptimizability = optimizability.CHILDREN
-    }
-    if (node.type === 1) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        var child = node.children[i]
-        walk(child)
-        check(child)
-      }
-      if (node.ifConditions) {
-        for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-          var block = node.ifConditions[i].block
-          walk(block, isRoot)
-          check(block)
-        }
-      }
-      if (
-        node.ssrOptimizability == null ||
-        (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-      ) {
-        node.ssrOptimizability = optimizability.FULL
-      } else {
-        node.children = optimizeSiblings(node)
-      }
-    } else {
-      node.ssrOptimizability = optimizability.FULL
-    }
-  }
-  function optimizeSiblings(el) {
-    var children = el.children
-    var optimizedChildren = []
-    var currentOptimizableGroup = []
-    var pushGroup = function () {
-      if (currentOptimizableGroup.length) {
-        optimizedChildren.push({
-          type: 1,
-          parent: el,
-          tag: 'template',
-          attrsList: [],
-          attrsMap: {},
-          rawAttrsMap: {},
-          children: currentOptimizableGroup,
-          ssrOptimizability: optimizability.FULL
-        })
-      }
-      currentOptimizableGroup = []
-    }
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i]
-      if (c.ssrOptimizability === optimizability.FULL) {
-        currentOptimizableGroup.push(c)
-      } else {
-        // wrap fully-optimizable adjacent siblings inside a template tag
-        // so that they can be optimized into a single ssrNode by codegen
-        pushGroup()
-        optimizedChildren.push(c)
-      }
-    }
-    pushGroup()
-    return optimizedChildren
-  }
-  function isUnOptimizableTree(node) {
-    if (node.type === 2 || node.type === 3) {
-      // text or expression
-      return false
-    }
-    return (
-      isBuiltInTag(node.tag) || // built-in (slot, component)
-      !isPlatformReservedTag(node.tag) || // custom component
-      !!node.component || // "is" component
-      isSelectWithModel(node) // <select v-model> requires runtime inspection
-    )
-  }
-  var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
-  function hasCustomDirective(node) {
-    return (
-      node.type === 1 &&
-      node.directives &&
-      node.directives.some(function (d) {
-        return !isBuiltInDir(d.name)
-      })
-    )
-  }
-  // <select v-model> cannot be optimized because it requires a runtime check
-  // to determine proper selected option
-  function isSelectWithModel(node) {
-    return (
-      node.type === 1 &&
-      node.tag === 'select' &&
-      node.directives != null &&
-      node.directives.some(function (d) {
-        return d.name === 'model'
-      })
-    )
-  }
-
-  // The SSR codegen is essentially extending the default codegen to handle
-  // segment types
-  var RAW = 0
-  var INTERPOLATION = 1
-  var EXPRESSION = 2
-  function generate(ast, options) {
-    var state = new CodegenState(options)
-    var code = ast ? genSSRElement(ast, state) : '_c("div")'
-    return {
-      render: 'with(this){return '.concat(code, '}'),
-      staticRenderFns: state.staticRenderFns
-    }
-  }
-  function genSSRElement(el, state) {
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genSSRElement)
-    } else if (el.if && !el.ifProcessed) {
-      return genIf(el, state, genSSRElement)
-    } else if (el.tag === 'template' && !el.slotTarget) {
-      return el.ssrOptimizability === optimizability.FULL
-        ? genChildrenAsStringNode(el, state)
-        : genSSRChildren(el, state) || 'void 0'
-    }
-    switch (el.ssrOptimizability) {
-      case optimizability.FULL:
-        // stringify whole tree
-        return genStringElement(el, state)
-      case optimizability.SELF:
-        // stringify self and check children
-        return genStringElementWithChildren(el, state)
-      case optimizability.CHILDREN:
-        // generate self as VNode and stringify children
-        return genNormalElement(el, state, true)
-      case optimizability.PARTIAL:
-        // generate self as VNode and check children
-        return genNormalElement(el, state, false)
-      default:
-        // bail whole tree
-        return genElement(el, state)
-    }
-  }
-  function genNormalElement(el, state, stringifyChildren) {
-    var data = el.plain ? undefined : genData(el, state)
-    var children = stringifyChildren
-      ? '['.concat(genChildrenAsStringNode(el, state), ']')
-      : genSSRChildren(el, state, true)
-    return "_c('"
-      .concat(el.tag, "'")
-      .concat(data ? ','.concat(data) : '')
-      .concat(children ? ','.concat(children) : '', ')')
-  }
-  function genSSRChildren(el, state, checkSkip) {
-    return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-  }
-  function genSSRNode(el, state) {
-    return el.type === 1 ? genSSRElement(el, state) : genText(el)
-  }
-  function genChildrenAsStringNode(el, state) {
-    return el.children.length
-      ? '_ssrNode('.concat(flattenSegments(childrenToSegments(el, state)), ')')
-      : ''
-  }
-  function genStringElement(el, state) {
-    return '_ssrNode('.concat(elementToString(el, state), ')')
-  }
-  function genStringElementWithChildren(el, state) {
-    var children = genSSRChildren(el, state, true)
-    return '_ssrNode('
-      .concat(flattenSegments(elementToOpenTagSegments(el, state)), ',"</')
-      .concat(el.tag, '>"')
-      .concat(children ? ','.concat(children) : '', ')')
-  }
-  function elementToString(el, state) {
-    return '('.concat(flattenSegments(elementToSegments(el, state)), ')')
-  }
-  function elementToSegments(el, state) {
-    // v-for / v-if
-    if (el.for && !el.forProcessed) {
-      el.forProcessed = true
-      return [
-        {
-          type: EXPRESSION,
-          value: genFor(el, state, elementToString, '_ssrList')
-        }
-      ]
-    } else if (el.if && !el.ifProcessed) {
-      el.ifProcessed = true
-      return [
-        {
-          type: EXPRESSION,
-          value: genIf(el, state, elementToString, '"<!---->"')
-        }
-      ]
-    } else if (el.tag === 'template') {
-      return childrenToSegments(el, state)
-    }
-    var openSegments = elementToOpenTagSegments(el, state)
-    var childrenSegments = childrenToSegments(el, state)
-    var isUnaryTag = state.options.isUnaryTag
-    var close =
-      isUnaryTag && isUnaryTag(el.tag)
-        ? []
-        : [{ type: RAW, value: '</'.concat(el.tag, '>') }]
-    return openSegments.concat(childrenSegments, close)
-  }
-  function elementToOpenTagSegments(el, state) {
-    applyModelTransform(el, state)
-    var binding
-    var segments = [{ type: RAW, value: '<'.concat(el.tag) }]
-    // attrs
-    if (el.attrs) {
-      segments.push.apply(segments, genAttrSegments(el.attrs))
-    }
-    // domProps
-    if (el.props) {
-      segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs))
-    }
-    // v-bind="object"
-    if ((binding = el.attrsMap['v-bind'])) {
-      segments.push({
-        type: EXPRESSION,
-        value: '_ssrAttrs('.concat(binding, ')')
-      })
-    }
-    // v-bind.prop="object"
-    if ((binding = el.attrsMap['v-bind.prop'])) {
-      segments.push({
-        type: EXPRESSION,
-        value: '_ssrDOMProps('.concat(binding, ')')
-      })
-    }
-    // class
-    if (el.staticClass || el.classBinding) {
-      segments.push.apply(
-        segments,
-        genClassSegments(el.staticClass, el.classBinding)
-      )
-    }
-    // style & v-show
-    if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-      segments.push.apply(
-        segments,
-        genStyleSegments(
-          el.attrsMap.style,
-          el.staticStyle,
-          el.styleBinding,
-          el.attrsMap['v-show']
-        )
-      )
-    }
-    // _scopedId
-    if (state.options.scopeId) {
-      segments.push({ type: RAW, value: ' '.concat(state.options.scopeId) })
-    }
-    segments.push({ type: RAW, value: '>' })
-    return segments
-  }
-  function childrenToSegments(el, state) {
-    var binding
-    if ((binding = el.attrsMap['v-html'])) {
-      return [{ type: EXPRESSION, value: '_s('.concat(binding, ')') }]
-    }
-    if ((binding = el.attrsMap['v-text'])) {
-      return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
-    }
-    if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-      return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
-    }
-    return el.children ? nodesToSegments(el.children, state) : []
-  }
-  function nodesToSegments(children, state) {
-    var segments = []
-    for (var i = 0; i < children.length; i++) {
-      var c = children[i]
-      if (c.type === 1) {
-        segments.push.apply(segments, elementToSegments(c, state))
-      } else if (c.type === 2) {
-        segments.push({ type: INTERPOLATION, value: c.expression })
-      } else if (c.type === 3) {
-        var text = escape(c.text)
-        if (c.isComment) {
-          text = '<!--' + text + '-->'
-        }
-        segments.push({ type: RAW, value: text })
-      }
-    }
-    return segments
-  }
-  function flattenSegments(segments) {
-    var mergedSegments = []
-    var textBuffer = ''
-    var pushBuffer = function () {
-      if (textBuffer) {
-        mergedSegments.push(JSON.stringify(textBuffer))
-        textBuffer = ''
-      }
-    }
-    for (var i = 0; i < segments.length; i++) {
-      var s = segments[i]
-      if (s.type === RAW) {
-        textBuffer += s.value
-      } else if (s.type === INTERPOLATION) {
-        pushBuffer()
-        mergedSegments.push('_ssrEscape('.concat(s.value, ')'))
-      } else if (s.type === EXPRESSION) {
-        pushBuffer()
-        mergedSegments.push('('.concat(s.value, ')'))
-      }
-    }
-    pushBuffer()
-    return mergedSegments.join('+')
-  }
-
-  var createCompiler = createCompilerCreator(function baseCompile(
-    template,
-    options
-  ) {
-    var ast = parse(template.trim(), options)
-    optimize(ast, options)
-    var code = generate(ast, options)
-    return {
-      ast: ast,
-      render: code.render,
-      staticRenderFns: code.staticRenderFns
-    }
-  })
-
-  var _a = createCompiler(baseOptions),
-    compile = _a.compile,
-    compileToFunctions = _a.compileToFunctions
-
-  exports.compile = compile$1
-  exports.compileToFunctions = compileToFunctions$1
-  exports.generateCodeFrame = generateCodeFrame
-  exports.parseComponent = parseComponent
-  exports.ssrCompile = compile
-  exports.ssrCompileToFunctions = compileToFunctions
-
-  Object.defineProperty(exports, '__esModule', { value: true })
-})
diff --git a/packages/template-compiler/build.js b/packages/template-compiler/build.js
deleted file mode 100644
index 4178b15ca71..00000000000
--- a/packages/template-compiler/build.js
+++ /dev/null
@@ -1,5148 +0,0 @@
-'use strict'
-
-Object.defineProperty(exports, '__esModule', { value: true })
-
-var deindent = require('de-indent')
-var he = require('he')
-
-function _interopDefaultLegacy(e) {
-  return e && typeof e === 'object' && 'default' in e ? e : { default: e }
-}
-
-var deindent__default = /*#__PURE__*/ _interopDefaultLegacy(deindent)
-var he__default = /*#__PURE__*/ _interopDefaultLegacy(he)
-
-var emptyObject = Object.freeze({})
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-function isUndef(v) {
-  return v === undefined || v === null
-}
-/**
- * Check if value is primitive.
- */
-function isPrimitive(value) {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
-}
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-function isObject(obj) {
-  return obj !== null && typeof obj === 'object'
-}
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-var _toString = Object.prototype.toString
-function toRawType(value) {
-  return _toString.call(value).slice(8, -1)
-}
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-function isPlainObject(obj) {
-  return _toString.call(obj) === '[object Object]'
-}
-/**
- * Check if val is a valid array index.
- */
-function isValidArrayIndex(val) {
-  var n = parseFloat(String(val))
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
-}
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-function makeMap(str, expectsLowerCase) {
-  var map = Object.create(null)
-  var list = str.split(',')
-  for (var i = 0; i < list.length; i++) {
-    map[list[i]] = true
-  }
-  return expectsLowerCase
-    ? function (val) {
-        return map[val.toLowerCase()]
-      }
-    : function (val) {
-        return map[val]
-      }
-}
-/**
- * Check if a tag is a built-in tag.
- */
-var isBuiltInTag = makeMap('slot,component', true)
-/**
- * Check if an attribute is a reserved attribute.
- */
-makeMap('key,ref,slot,slot-scope,is')
-/**
- * Remove an item from an array.
- */
-function remove(arr, item) {
-  if (arr.length) {
-    var index = arr.indexOf(item)
-    if (index > -1) {
-      return arr.splice(index, 1)
-    }
-  }
-}
-/**
- * Check whether an object has the property.
- */
-var hasOwnProperty = Object.prototype.hasOwnProperty
-function hasOwn(obj, key) {
-  return hasOwnProperty.call(obj, key)
-}
-/**
- * Create a cached version of a pure function.
- */
-function cached(fn) {
-  var cache = Object.create(null)
-  return function cachedFn(str) {
-    var hit = cache[str]
-    return hit || (cache[str] = fn(str))
-  }
-}
-/**
- * Camelize a hyphen-delimited string.
- */
-var camelizeRE = /-(\w)/g
-var camelize = cached(function (str) {
-  return str.replace(camelizeRE, function (_, c) {
-    return c ? c.toUpperCase() : ''
-  })
-})
-/**
- * Hyphenate a camelCase string.
- */
-var hyphenateRE = /\B([A-Z])/g
-var hyphenate = cached(function (str) {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
-})
-/**
- * Mix properties into target object.
- */
-function extend(to, _from) {
-  for (var key in _from) {
-    to[key] = _from[key]
-  }
-  return to
-}
-/* eslint-disable no-unused-vars */
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-function noop(a, b, c) {}
-/**
- * Always return false.
- */
-var no = function (a, b, c) {
-  return false
-}
-/* eslint-enable no-unused-vars */
-/**
- * Return the same value.
- */
-var identity = function (_) {
-  return _
-}
-/**
- * Generate a string containing static keys from compiler modules.
- */
-function genStaticKeys$1(modules) {
-  return modules
-    .reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, [])
-    .join(',')
-}
-
-var isUnaryTag = makeMap(
-  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +
-    'link,meta,param,source,track,wbr'
-)
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
-var canBeLeftOpenTag = makeMap(
-  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'
-)
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-var isNonPhrasingTag = makeMap(
-  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +
-    'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +
-    'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +
-    'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +
-    'title,tr,track'
-)
-
-/**
- * unicode letters used for parsing html tags, component names and property paths.
- * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname
- * skipping \u10000-\uEFFFF due to it freezing up PhantomJS
- */
-var unicodeRegExp =
-  /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/
-/**
- * Define a property.
- */
-function def(obj, key, val, enumerable) {
-  Object.defineProperty(obj, key, {
-    value: val,
-    enumerable: !!enumerable,
-    writable: true,
-    configurable: true
-  })
-}
-
-/**
- * Not type-checking this file because it's mostly vendor code.
- */
-// Regular Expressions for parsing tags and attributes
-var attribute =
-  /^\s*([^\s"'<>\/=]+)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-var dynamicArgAttribute =
-  /^\s*((?:v-[\w-]+:|@|:|#)\[[^=]+?\][^\s"'<>\/=]*)(?:\s*(=)\s*(?:"([^"]*)"+|'([^']*)'+|([^\s"'=<>`]+)))?/
-var ncname = '[a-zA-Z_][\\-\\.0-9_a-zA-Z'.concat(unicodeRegExp.source, ']*')
-var qnameCapture = '((?:'.concat(ncname, '\\:)?').concat(ncname, ')')
-var startTagOpen = new RegExp('^<'.concat(qnameCapture))
-var startTagClose = /^\s*(\/?)>/
-var endTag = new RegExp('^<\\/'.concat(qnameCapture, '[^>]*>'))
-var doctype = /^<!DOCTYPE [^>]+>/i
-// #7298: escape - to avoid being passed as HTML comment when inlined in page
-var comment = /^<!\--/
-var conditionalComment = /^<!\[/
-// Special Elements (can contain anything)
-var isPlainTextElement = makeMap('script,style,textarea', true)
-var reCache = {}
-var decodingMap = {
-  '&lt;': '<',
-  '&gt;': '>',
-  '&quot;': '"',
-  '&amp;': '&',
-  '&#10;': '\n',
-  '&#9;': '\t',
-  '&#39;': "'"
-}
-var encodedAttr = /&(?:lt|gt|quot|amp|#39);/g
-var encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g
-// #5992
-var isIgnoreNewlineTag = makeMap('pre,textarea', true)
-var shouldIgnoreFirstNewline = function (tag, html) {
-  return tag && isIgnoreNewlineTag(tag) && html[0] === '\n'
-}
-function decodeAttr(value, shouldDecodeNewlines) {
-  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr
-  return value.replace(re, function (match) {
-    return decodingMap[match]
-  })
-}
-function parseHTML(html, options) {
-  var stack = []
-  var expectHTML = options.expectHTML
-  var isUnaryTag = options.isUnaryTag || no
-  var canBeLeftOpenTag = options.canBeLeftOpenTag || no
-  var index = 0
-  var last, lastTag
-  var _loop_1 = function () {
-    last = html
-    // Make sure we're not in a plaintext content element like script/style
-    if (!lastTag || !isPlainTextElement(lastTag)) {
-      var textEnd = html.indexOf('<')
-      if (textEnd === 0) {
-        // Comment:
-        if (comment.test(html)) {
-          var commentEnd = html.indexOf('-->')
-          if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
-              options.comment(
-                html.substring(4, commentEnd),
-                index,
-                index + commentEnd + 3
-              )
-            }
-            advance(commentEnd + 3)
-            return 'continue'
-          }
-        }
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-        if (conditionalComment.test(html)) {
-          var conditionalEnd = html.indexOf(']>')
-          if (conditionalEnd >= 0) {
-            advance(conditionalEnd + 2)
-            return 'continue'
-          }
-        }
-        // Doctype:
-        var doctypeMatch = html.match(doctype)
-        if (doctypeMatch) {
-          advance(doctypeMatch[0].length)
-          return 'continue'
-        }
-        // End tag:
-        var endTagMatch = html.match(endTag)
-        if (endTagMatch) {
-          var curIndex = index
-          advance(endTagMatch[0].length)
-          parseEndTag(endTagMatch[1], curIndex, index)
-          return 'continue'
-        }
-        // Start tag:
-        var startTagMatch = parseStartTag()
-        if (startTagMatch) {
-          handleStartTag(startTagMatch)
-          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-            advance(1)
-          }
-          return 'continue'
-        }
-      }
-      var text = void 0,
-        rest = void 0,
-        next = void 0
-      if (textEnd >= 0) {
-        rest = html.slice(textEnd)
-        while (
-          !endTag.test(rest) &&
-          !startTagOpen.test(rest) &&
-          !comment.test(rest) &&
-          !conditionalComment.test(rest)
-        ) {
-          // < in plain text, be forgiving and treat it as text
-          next = rest.indexOf('<', 1)
-          if (next < 0) break
-          textEnd += next
-          rest = html.slice(textEnd)
-        }
-        text = html.substring(0, textEnd)
-      }
-      if (textEnd < 0) {
-        text = html
-      }
-      if (text) {
-        advance(text.length)
-      }
-      if (options.chars && text) {
-        options.chars(text, index - text.length, index)
-      }
-    } else {
-      var endTagLength_1 = 0
-      var stackedTag_1 = lastTag.toLowerCase()
-      var reStackedTag =
-        reCache[stackedTag_1] ||
-        (reCache[stackedTag_1] = new RegExp(
-          '([\\s\\S]*?)(</' + stackedTag_1 + '[^>]*>)',
-          'i'
-        ))
-      var rest = html.replace(reStackedTag, function (all, text, endTag) {
-        endTagLength_1 = endTag.length
-        if (!isPlainTextElement(stackedTag_1) && stackedTag_1 !== 'noscript') {
-          text = text
-            .replace(/<!\--([\s\S]*?)-->/g, '$1') // #7298
-            .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1')
-        }
-        if (shouldIgnoreFirstNewline(stackedTag_1, text)) {
-          text = text.slice(1)
-        }
-        if (options.chars) {
-          options.chars(text)
-        }
-        return ''
-      })
-      index += html.length - rest.length
-      html = rest
-      parseEndTag(stackedTag_1, index - endTagLength_1, index)
-    }
-    if (html === last) {
-      options.chars && options.chars(html)
-      if (
-        process.env.NODE_ENV !== 'production' &&
-        !stack.length &&
-        options.warn
-      ) {
-        options.warn(
-          'Mal-formatted tag at end of template: "'.concat(html, '"'),
-          {
-            start: index + html.length
-          }
-        )
-      }
-      return 'break'
-    }
-  }
-  while (html) {
-    var state_1 = _loop_1()
-    if (state_1 === 'break') break
-  }
-  // Clean up any remaining tags
-  parseEndTag()
-  function advance(n) {
-    index += n
-    html = html.substring(n)
-  }
-  function parseStartTag() {
-    var start = html.match(startTagOpen)
-    if (start) {
-      var match = {
-        tagName: start[1],
-        attrs: [],
-        start: index
-      }
-      advance(start[0].length)
-      var end = void 0,
-        attr = void 0
-      while (
-        !(end = html.match(startTagClose)) &&
-        (attr = html.match(dynamicArgAttribute) || html.match(attribute))
-      ) {
-        attr.start = index
-        advance(attr[0].length)
-        attr.end = index
-        match.attrs.push(attr)
-      }
-      if (end) {
-        match.unarySlash = end[1]
-        advance(end[0].length)
-        match.end = index
-        return match
-      }
-    }
-  }
-  function handleStartTag(match) {
-    var tagName = match.tagName
-    var unarySlash = match.unarySlash
-    if (expectHTML) {
-      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-        parseEndTag(lastTag)
-      }
-      if (canBeLeftOpenTag(tagName) && lastTag === tagName) {
-        parseEndTag(tagName)
-      }
-    }
-    var unary = isUnaryTag(tagName) || !!unarySlash
-    var l = match.attrs.length
-    var attrs = new Array(l)
-    for (var i = 0; i < l; i++) {
-      var args = match.attrs[i]
-      var value = args[3] || args[4] || args[5] || ''
-      var shouldDecodeNewlines =
-        tagName === 'a' && args[1] === 'href'
-          ? options.shouldDecodeNewlinesForHref
-          : options.shouldDecodeNewlines
-      attrs[i] = {
-        name: args[1],
-        value: decodeAttr(value, shouldDecodeNewlines)
-      }
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        attrs[i].start = args.start + args[0].match(/^\s*/).length
-        attrs[i].end = args.end
-      }
-    }
-    if (!unary) {
-      stack.push({
-        tag: tagName,
-        lowerCasedTag: tagName.toLowerCase(),
-        attrs: attrs,
-        start: match.start,
-        end: match.end
-      })
-      lastTag = tagName
-    }
-    if (options.start) {
-      options.start(tagName, attrs, unary, match.start, match.end)
-    }
-  }
-  function parseEndTag(tagName, start, end) {
-    var pos, lowerCasedTagName
-    if (start == null) start = index
-    if (end == null) end = index
-    // Find the closest opened tag of the same type
-    if (tagName) {
-      lowerCasedTagName = tagName.toLowerCase()
-      for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].lowerCasedTag === lowerCasedTagName) {
-          break
-        }
-      }
-    } else {
-      // If no tag name is provided, clean shop
-      pos = 0
-    }
-    if (pos >= 0) {
-      // Close all the open elements, up the stack
-      for (var i = stack.length - 1; i >= pos; i--) {
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          (i > pos || !tagName) &&
-          options.warn
-        ) {
-          options.warn(
-            'tag <'.concat(stack[i].tag, '> has no matching end tag.'),
-            {
-              start: stack[i].start,
-              end: stack[i].end
-            }
-          )
-        }
-        if (options.end) {
-          options.end(stack[i].tag, start, end)
-        }
-      }
-      // Remove the open elements from the stack
-      stack.length = pos
-      lastTag = pos && stack[pos - 1].tag
-    } else if (lowerCasedTagName === 'br') {
-      if (options.start) {
-        options.start(tagName, [], true, start, end)
-      }
-    } else if (lowerCasedTagName === 'p') {
-      if (options.start) {
-        options.start(tagName, [], false, start, end)
-      }
-      if (options.end) {
-        options.end(tagName, start, end)
-      }
-    }
-  }
-}
-
-var splitRE = /\r?\n/g
-var replaceRE = /./g
-var isSpecialTag = makeMap('script,style,template', true)
-/**
- * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
- */
-function parseComponent(content, options) {
-  if (options === void 0) {
-    options = {}
-  }
-  var sfc = {
-    template: null,
-    script: null,
-    styles: [],
-    customBlocks: [],
-    errors: []
-  }
-  var depth = 0
-  var currentBlock = null
-  var warn = function (msg) {
-    sfc.errors.push(msg)
-  }
-  if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-    warn = function (msg, range) {
-      var data = { msg: msg }
-      if (range.start != null) {
-        data.start = range.start
-      }
-      if (range.end != null) {
-        data.end = range.end
-      }
-      sfc.errors.push(data)
-    }
-  }
-  function start(tag, attrs, unary, start, end) {
-    if (depth === 0) {
-      currentBlock = {
-        type: tag,
-        content: '',
-        start: end,
-        attrs: attrs.reduce(function (cumulated, _a) {
-          var name = _a.name,
-            value = _a.value
-          cumulated[name] = value || true
-          return cumulated
-        }, {})
-      }
-      if (isSpecialTag(tag)) {
-        checkAttrs(currentBlock, attrs)
-        if (tag === 'style') {
-          sfc.styles.push(currentBlock)
-        } else {
-          sfc[tag] = currentBlock
-        }
-      } else {
-        // custom blocks
-        sfc.customBlocks.push(currentBlock)
-      }
-    }
-    if (!unary) {
-      depth++
-    }
-  }
-  function checkAttrs(block, attrs) {
-    for (var i = 0; i < attrs.length; i++) {
-      var attr = attrs[i]
-      if (attr.name === 'lang') {
-        block.lang = attr.value
-      }
-      if (attr.name === 'scoped') {
-        block.scoped = true
-      }
-      if (attr.name === 'module') {
-        block.module = attr.value || true
-      }
-      if (attr.name === 'src') {
-        block.src = attr.value
-      }
-    }
-  }
-  function end(tag, start) {
-    if (depth === 1 && currentBlock) {
-      currentBlock.end = start
-      var text = content.slice(currentBlock.start, currentBlock.end)
-      if (options.deindent !== false) {
-        text = deindent__default['default'](text)
-      }
-      // pad content so that linters and pre-processors can output correct
-      // line numbers in errors and warnings
-      if (currentBlock.type !== 'template' && options.pad) {
-        text = padContent(currentBlock, options.pad) + text
-      }
-      currentBlock.content = text
-      currentBlock = null
-    }
-    depth--
-  }
-  function padContent(block, pad) {
-    if (pad === 'space') {
-      return content.slice(0, block.start).replace(replaceRE, ' ')
-    } else {
-      var offset = content.slice(0, block.start).split(splitRE).length
-      var padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
-      return Array(offset).join(padChar)
-    }
-  }
-  parseHTML(content, {
-    warn: warn,
-    start: start,
-    end: end,
-    outputSourceRange: options.outputSourceRange
-  })
-  return sfc
-}
-
-// can we use __proto__?
-var hasProto = '__proto__' in {}
-// Browser environment sniffing
-var inBrowser = typeof window !== 'undefined'
-var UA = inBrowser && window.navigator.userAgent.toLowerCase()
-var isIE = UA && /msie|trident/.test(UA)
-UA && UA.indexOf('msie 9.0') > 0
-var isEdge = UA && UA.indexOf('edge/') > 0
-UA && UA.indexOf('android') > 0
-UA && /iphone|ipad|ipod|ios/.test(UA)
-UA && /chrome\/\d+/.test(UA) && !isEdge
-UA && /phantomjs/.test(UA)
-UA && UA.match(/firefox\/(\d+)/)
-// Firefox has a "watch" function on Object.prototype...
-// @ts-expect-error firebox support
-var nativeWatch = {}.watch
-var supportsPassive = false
-if (inBrowser) {
-  try {
-    var opts = {}
-    Object.defineProperty(opts, 'passive', {
-      get: function () {
-        /* istanbul ignore next */
-        supportsPassive = true
-      }
-    }) // https://github.com/facebook/flow/issues/285
-    window.addEventListener('test-passive', null, opts)
-  } catch (e) {}
-}
-// this needs to be lazy-evaled because vue may be required before
-// vue-server-renderer can set VUE_ENV
-var _isServer
-var isServerRendering = function () {
-  if (_isServer === undefined) {
-    /* istanbul ignore if */
-    if (!inBrowser && typeof global !== 'undefined') {
-      // detect presence of vue-server-renderer and avoid
-      // Webpack shimming the process
-      _isServer =
-        global['process'] && global['process'].env.VUE_ENV === 'server'
-    } else {
-      _isServer = false
-    }
-  }
-  return _isServer
-}
-/* istanbul ignore next */
-function isNative(Ctor) {
-  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
-}
-var hasSymbol =
-  typeof Symbol !== 'undefined' &&
-  isNative(Symbol) &&
-  typeof Reflect !== 'undefined' &&
-  isNative(Reflect.ownKeys)
-/* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set));
-else {
-  // a non-standard Set polyfill that only works with primitive keys.
-  /** @class */ ;(function () {
-    function Set() {
-      this.set = Object.create(null)
-    }
-    Set.prototype.has = function (key) {
-      return this.set[key] === true
-    }
-    Set.prototype.add = function (key) {
-      this.set[key] = true
-    }
-    Set.prototype.clear = function () {
-      this.set = Object.create(null)
-    }
-    return Set
-  })()
-}
-
-var ASSET_TYPES = ['component', 'directive', 'filter']
-var LIFECYCLE_HOOKS = [
-  'beforeCreate',
-  'created',
-  'beforeMount',
-  'mounted',
-  'beforeUpdate',
-  'updated',
-  'beforeDestroy',
-  'destroyed',
-  'activated',
-  'deactivated',
-  'errorCaptured',
-  'serverPrefetch'
-]
-
-var config = {
-  /**
-   * Option merge strategies (used in core/util/options)
-   */
-  // $flow-disable-line
-  optionMergeStrategies: Object.create(null),
-  /**
-   * Whether to suppress warnings.
-   */
-  silent: false,
-  /**
-   * Show production mode tip message on boot?
-   */
-  productionTip: process.env.NODE_ENV !== 'production',
-  /**
-   * Whether to enable devtools
-   */
-  devtools: process.env.NODE_ENV !== 'production',
-  /**
-   * Whether to record perf
-   */
-  performance: false,
-  /**
-   * Error handler for watcher errors
-   */
-  errorHandler: null,
-  /**
-   * Warn handler for watcher warns
-   */
-  warnHandler: null,
-  /**
-   * Ignore certain custom elements
-   */
-  ignoredElements: [],
-  /**
-   * Custom user key aliases for v-on
-   */
-  // $flow-disable-line
-  keyCodes: Object.create(null),
-  /**
-   * Check if a tag is reserved so that it cannot be registered as a
-   * component. This is platform-dependent and may be overwritten.
-   */
-  isReservedTag: no,
-  /**
-   * Check if an attribute is reserved so that it cannot be used as a component
-   * prop. This is platform-dependent and may be overwritten.
-   */
-  isReservedAttr: no,
-  /**
-   * Check if a tag is an unknown element.
-   * Platform-dependent.
-   */
-  isUnknownElement: no,
-  /**
-   * Get the namespace of an element
-   */
-  getTagNamespace: noop,
-  /**
-   * Parse the real tag name for the specific platform.
-   */
-  parsePlatformTagName: identity,
-  /**
-   * Check if an attribute must be bound using property, e.g. value
-   * Platform-dependent.
-   */
-  mustUseProp: no,
-  /**
-   * Perform updates asynchronously. Intended to be used by Vue Test Utils
-   * This will significantly reduce performance if set to false.
-   */
-  async: true,
-  /**
-   * Exposed for legacy reasons
-   */
-  _lifecycleHooks: LIFECYCLE_HOOKS
-}
-
-var warn$2 = noop
-var tip = noop
-var generateComponentTrace // work around flow check
-var formatComponentName
-if (process.env.NODE_ENV !== 'production') {
-  var hasConsole_1 = typeof console !== 'undefined'
-  var classifyRE_1 = /(?:^|[-_])(\w)/g
-  var classify_1 = function (str) {
-    return str
-      .replace(classifyRE_1, function (c) {
-        return c.toUpperCase()
-      })
-      .replace(/[-_]/g, '')
-  }
-  warn$2 = function (msg, vm) {
-    var trace = vm ? generateComponentTrace(vm) : ''
-    if (hasConsole_1 && !config.silent) {
-      console.error('[Vue warn]: '.concat(msg).concat(trace))
-    }
-  }
-  tip = function (msg, vm) {
-    if (hasConsole_1 && !config.silent) {
-      console.warn(
-        '[Vue tip]: '.concat(msg) + (vm ? generateComponentTrace(vm) : '')
-      )
-    }
-  }
-  formatComponentName = function (vm, includeFile) {
-    if (vm.$root === vm) {
-      return '<Root>'
-    }
-    var options =
-      typeof vm === 'function' && vm.cid != null
-        ? vm.options
-        : vm._isVue
-        ? vm.$options || vm.constructor.options
-        : vm
-    var name = options.name || options._componentTag
-    var file = options.__file
-    if (!name && file) {
-      var match = file.match(/([^/\\]+)\.vue$/)
-      name = match && match[1]
-    }
-    return (
-      (name ? '<'.concat(classify_1(name), '>') : '<Anonymous>') +
-      (file && includeFile !== false ? ' at '.concat(file) : '')
-    )
-  }
-  var repeat_1 = function (str, n) {
-    var res = ''
-    while (n) {
-      if (n % 2 === 1) res += str
-      if (n > 1) str += str
-      n >>= 1
-    }
-    return res
-  }
-  generateComponentTrace = function (vm) {
-    if (vm._isVue && vm.$parent) {
-      var tree = []
-      var currentRecursiveSequence = 0
-      while (vm) {
-        if (tree.length > 0) {
-          var last = tree[tree.length - 1]
-          if (last.constructor === vm.constructor) {
-            currentRecursiveSequence++
-            vm = vm.$parent
-            continue
-          } else if (currentRecursiveSequence > 0) {
-            tree[tree.length - 1] = [last, currentRecursiveSequence]
-            currentRecursiveSequence = 0
-          }
-        }
-        tree.push(vm)
-        vm = vm.$parent
-      }
-      return (
-        '\n\nfound in\n\n' +
-        tree
-          .map(function (vm, i) {
-            return ''
-              .concat(i === 0 ? '---> ' : repeat_1(' ', 5 + i * 2))
-              .concat(
-                Array.isArray(vm)
-                  ? ''
-                      .concat(formatComponentName(vm[0]), '... (')
-                      .concat(vm[1], ' recursive calls)')
-                  : formatComponentName(vm)
-              )
-          })
-          .join('\n')
-      )
-    } else {
-      return '\n\n(found in '.concat(formatComponentName(vm), ')')
-    }
-  }
-}
-
-var uid = 0
-/**
- * A dep is an observable that can have multiple
- * directives subscribing to it.
- */
-var Dep = /** @class */ (function () {
-  function Dep() {
-    this.id = uid++
-    this.subs = []
-  }
-  Dep.prototype.addSub = function (sub) {
-    this.subs.push(sub)
-  }
-  Dep.prototype.removeSub = function (sub) {
-    remove(this.subs, sub)
-  }
-  Dep.prototype.depend = function () {
-    if (Dep.target) {
-      Dep.target.addDep(this)
-    }
-  }
-  Dep.prototype.notify = function () {
-    // stabilize the subscriber list first
-    var subs = this.subs.slice()
-    if (process.env.NODE_ENV !== 'production' && !config.async) {
-      // subs aren't sorted in scheduler if not running async
-      // we need to sort them now to make sure they fire in correct
-      // order
-      subs.sort(function (a, b) {
-        return a.id - b.id
-      })
-    }
-    for (var i = 0, l = subs.length; i < l; i++) {
-      subs[i].update()
-    }
-  }
-  return Dep
-})()
-// The current target watcher being evaluated.
-// This is globally unique because only one watcher
-// can be evaluated at a time.
-Dep.target = null
-
-var VNode = /** @class */ (function () {
-  function VNode(
-    tag,
-    data,
-    children,
-    text,
-    elm,
-    context,
-    componentOptions,
-    asyncFactory
-  ) {
-    this.tag = tag
-    this.data = data
-    this.children = children
-    this.text = text
-    this.elm = elm
-    this.ns = undefined
-    this.context = context
-    this.fnContext = undefined
-    this.fnOptions = undefined
-    this.fnScopeId = undefined
-    this.key = data && data.key
-    this.componentOptions = componentOptions
-    this.componentInstance = undefined
-    this.parent = undefined
-    this.raw = false
-    this.isStatic = false
-    this.isRootInsert = true
-    this.isComment = false
-    this.isCloned = false
-    this.isOnce = false
-    this.asyncFactory = asyncFactory
-    this.asyncMeta = undefined
-    this.isAsyncPlaceholder = false
-  }
-  Object.defineProperty(VNode.prototype, 'child', {
-    // DEPRECATED: alias for componentInstance for backwards compat.
-    /* istanbul ignore next */
-    get: function () {
-      return this.componentInstance
-    },
-    enumerable: false,
-    configurable: true
-  })
-  return VNode
-})()
-
-/*
- * not type checking this file because flow doesn't play well with
- * dynamically accessing methods on Array prototype
- */
-var arrayProto = Array.prototype
-var arrayMethods = Object.create(arrayProto)
-var methodsToPatch = [
-  'push',
-  'pop',
-  'shift',
-  'unshift',
-  'splice',
-  'sort',
-  'reverse'
-]
-/**
- * Intercept mutating methods and emit events
- */
-methodsToPatch.forEach(function (method) {
-  // cache original method
-  var original = arrayProto[method]
-  def(arrayMethods, method, function mutator() {
-    var args = []
-    for (var _i = 0; _i < arguments.length; _i++) {
-      args[_i] = arguments[_i]
-    }
-    var result = original.apply(this, args)
-    var ob = this.__ob__
-    var inserted
-    switch (method) {
-      case 'push':
-      case 'unshift':
-        inserted = args
-        break
-      case 'splice':
-        inserted = args.slice(2)
-        break
-    }
-    if (inserted) ob.observeArray(inserted)
-    // notify change
-    ob.dep.notify()
-    return result
-  })
-})
-
-var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
-/**
- * Observer class that is attached to each observed
- * object. Once attached, the observer converts the target
- * object's property keys into getter/setters that
- * collect dependencies and dispatch updates.
- */
-var Observer = /** @class */ (function () {
-  function Observer(value) {
-    this.value = value
-    this.dep = new Dep()
-    this.vmCount = 0
-    def(value, '__ob__', this)
-    if (Array.isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods)
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys)
-      }
-      this.observeArray(value)
-    } else {
-      this.walk(value)
-    }
-  }
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  Observer.prototype.walk = function (obj) {
-    var keys = Object.keys(obj)
-    for (var i = 0; i < keys.length; i++) {
-      defineReactive(obj, keys[i])
-    }
-  }
-  /**
-   * Observe a list of Array items.
-   */
-  Observer.prototype.observeArray = function (items) {
-    for (var i = 0, l = items.length; i < l; i++) {
-      observe(items[i])
-    }
-  }
-  return Observer
-})()
-// helpers
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src
-  /* eslint-enable no-proto */
-}
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target, src, keys) {
-  for (var i = 0, l = keys.length; i < l; i++) {
-    var key = keys[i]
-    def(target, key, src[key])
-  }
-}
-/**
- * Attempt to create an observer instance for a value,
- * returns the new observer if successfully observed,
- * or the existing observer if the value already has one.
- */
-function observe(value, asRootData) {
-  if (!isObject(value) || value instanceof VNode) {
-    return
-  }
-  var ob
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__
-  } else if (
-    !isServerRendering() &&
-    (Array.isArray(value) || isPlainObject(value)) &&
-    Object.isExtensible(value) &&
-    !value._isVue
-  ) {
-    ob = new Observer(value)
-  }
-  if (asRootData && ob) {
-    ob.vmCount++
-  }
-  return ob
-}
-/**
- * Define a reactive property on an Object.
- */
-function defineReactive(obj, key, val, customSetter, shallow) {
-  var dep = new Dep()
-  var property = Object.getOwnPropertyDescriptor(obj, key)
-  if (property && property.configurable === false) {
-    return
-  }
-  // cater for pre-defined getter/setters
-  var getter = property && property.get
-  var setter = property && property.set
-  if ((!getter || setter) && arguments.length === 2) {
-    val = obj[key]
-  }
-  var childOb = !shallow && observe(val)
-  Object.defineProperty(obj, key, {
-    enumerable: true,
-    configurable: true,
-    get: function reactiveGetter() {
-      var value = getter ? getter.call(obj) : val
-      if (Dep.target) {
-        dep.depend()
-        if (childOb) {
-          childOb.dep.depend()
-          if (Array.isArray(value)) {
-            dependArray(value)
-          }
-        }
-      }
-      return value
-    },
-    set: function reactiveSetter(newVal) {
-      var value = getter ? getter.call(obj) : val
-      /* eslint-disable no-self-compare */
-      if (newVal === value || (newVal !== newVal && value !== value)) {
-        return
-      }
-      /* eslint-enable no-self-compare */
-      if (process.env.NODE_ENV !== 'production' && customSetter) {
-        customSetter()
-      }
-      // #7981: for accessor properties without setter
-      if (getter && !setter) return
-      if (setter) {
-        setter.call(obj, newVal)
-      } else {
-        val = newVal
-      }
-      childOb = !shallow && observe(newVal)
-      dep.notify()
-    }
-  })
-}
-/**
- * Set a property on an object. Adds the new property and
- * triggers change notification if the property doesn't
- * already exist.
- */
-function set(target, key, val) {
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    (isUndef(target) || isPrimitive(target))
-  ) {
-    warn$2(
-      'Cannot set reactive property on undefined, null, or primitive value: '.concat(
-        target
-      )
-    )
-  }
-  if (Array.isArray(target) && isValidArrayIndex(key)) {
-    target.length = Math.max(target.length, key)
-    target.splice(key, 1, val)
-    return val
-  }
-  if (key in target && !(key in Object.prototype)) {
-    target[key] = val
-    return val
-  }
-  var ob = target.__ob__
-  if (target._isVue || (ob && ob.vmCount)) {
-    process.env.NODE_ENV !== 'production' &&
-      warn$2(
-        'Avoid adding reactive properties to a Vue instance or its root $data ' +
-          'at runtime - declare it upfront in the data option.'
-      )
-    return val
-  }
-  if (!ob) {
-    target[key] = val
-    return val
-  }
-  defineReactive(ob.value, key, val)
-  ob.dep.notify()
-  return val
-}
-/**
- * Collect dependencies on array elements when the array is touched, since
- * we cannot intercept array element access like property getters.
- */
-function dependArray(value) {
-  for (var e = void 0, i = 0, l = value.length; i < l; i++) {
-    e = value[i]
-    e && e.__ob__ && e.__ob__.dep.depend()
-    if (Array.isArray(e)) {
-      dependArray(e)
-    }
-  }
-}
-
-/**
- * Option overwriting strategies are functions that handle
- * how to merge a parent option value and a child option
- * value into the final value.
- */
-var strats = config.optionMergeStrategies
-/**
- * Options with restrictions
- */
-if (process.env.NODE_ENV !== 'production') {
-  strats.el = strats.propsData = function (parent, child, vm, key) {
-    if (!vm) {
-      warn$2(
-        'option "'.concat(key, '" can only be used during instance ') +
-          'creation with the `new` keyword.'
-      )
-    }
-    return defaultStrat(parent, child)
-  }
-}
-/**
- * Helper that recursively merges two data objects together.
- */
-function mergeData(to, from) {
-  if (!from) return to
-  var key, toVal, fromVal
-  var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from)
-  for (var i = 0; i < keys.length; i++) {
-    key = keys[i]
-    // in case the object is already observed...
-    if (key === '__ob__') continue
-    toVal = to[key]
-    fromVal = from[key]
-    if (!hasOwn(to, key)) {
-      set(to, key, fromVal)
-    } else if (
-      toVal !== fromVal &&
-      isPlainObject(toVal) &&
-      isPlainObject(fromVal)
-    ) {
-      mergeData(toVal, fromVal)
-    }
-  }
-  return to
-}
-/**
- * Data
- */
-function mergeDataOrFn(parentVal, childVal, vm) {
-  if (!vm) {
-    // in a Vue.extend merge, both should be functions
-    if (!childVal) {
-      return parentVal
-    }
-    if (!parentVal) {
-      return childVal
-    }
-    // when parentVal & childVal are both present,
-    // we need to return a function that returns the
-    // merged result of both functions... no need to
-    // check if parentVal is a function here because
-    // it has to be a function to pass previous merges.
-    return function mergedDataFn() {
-      return mergeData(
-        typeof childVal === 'function' ? childVal.call(this, this) : childVal,
-        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal
-      )
-    }
-  } else {
-    return function mergedInstanceDataFn() {
-      // instance merge
-      var instanceData =
-        typeof childVal === 'function' ? childVal.call(vm, vm) : childVal
-      var defaultData =
-        typeof parentVal === 'function' ? parentVal.call(vm, vm) : parentVal
-      if (instanceData) {
-        return mergeData(instanceData, defaultData)
-      } else {
-        return defaultData
-      }
-    }
-  }
-}
-strats.data = function (parentVal, childVal, vm) {
-  if (!vm) {
-    if (childVal && typeof childVal !== 'function') {
-      process.env.NODE_ENV !== 'production' &&
-        warn$2(
-          'The "data" option should be a function ' +
-            'that returns a per-instance value in component ' +
-            'definitions.',
-          vm
-        )
-      return parentVal
-    }
-    return mergeDataOrFn(parentVal, childVal)
-  }
-  return mergeDataOrFn(parentVal, childVal, vm)
-}
-/**
- * Hooks and props are merged as arrays.
- */
-function mergeHook(parentVal, childVal) {
-  var res = childVal
-    ? parentVal
-      ? parentVal.concat(childVal)
-      : Array.isArray(childVal)
-      ? childVal
-      : [childVal]
-    : parentVal
-  return res ? dedupeHooks(res) : res
-}
-function dedupeHooks(hooks) {
-  var res = []
-  for (var i = 0; i < hooks.length; i++) {
-    if (res.indexOf(hooks[i]) === -1) {
-      res.push(hooks[i])
-    }
-  }
-  return res
-}
-LIFECYCLE_HOOKS.forEach(function (hook) {
-  strats[hook] = mergeHook
-})
-/**
- * Assets
- *
- * When a vm is present (instance creation), we need to do
- * a three-way merge between constructor options, instance
- * options and parent options.
- */
-function mergeAssets(parentVal, childVal, vm, key) {
-  var res = Object.create(parentVal || null)
-  if (childVal) {
-    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm)
-    return extend(res, childVal)
-  } else {
-    return res
-  }
-}
-ASSET_TYPES.forEach(function (type) {
-  strats[type + 's'] = mergeAssets
-})
-/**
- * Watchers.
- *
- * Watchers hashes should not overwrite one
- * another, so we merge them as arrays.
- */
-strats.watch = function (parentVal, childVal, vm, key) {
-  // work around Firefox's Object.prototype.watch...
-  //@ts-expect-error work around
-  if (parentVal === nativeWatch) parentVal = undefined
-  //@ts-expect-error work around
-  if (childVal === nativeWatch) childVal = undefined
-  /* istanbul ignore if */
-  if (!childVal) return Object.create(parentVal || null)
-  if (process.env.NODE_ENV !== 'production') {
-    assertObjectType(key, childVal, vm)
-  }
-  if (!parentVal) return childVal
-  var ret = {}
-  extend(ret, parentVal)
-  for (var key_1 in childVal) {
-    var parent_1 = ret[key_1]
-    var child = childVal[key_1]
-    if (parent_1 && !Array.isArray(parent_1)) {
-      parent_1 = [parent_1]
-    }
-    ret[key_1] = parent_1
-      ? parent_1.concat(child)
-      : Array.isArray(child)
-      ? child
-      : [child]
-  }
-  return ret
-}
-/**
- * Other object hashes.
- */
-strats.props =
-  strats.methods =
-  strats.inject =
-  strats.computed =
-    function (parentVal, childVal, vm, key) {
-      if (childVal && process.env.NODE_ENV !== 'production') {
-        assertObjectType(key, childVal, vm)
-      }
-      if (!parentVal) return childVal
-      var ret = Object.create(null)
-      extend(ret, parentVal)
-      if (childVal) extend(ret, childVal)
-      return ret
-    }
-strats.provide = mergeDataOrFn
-/**
- * Default strategy.
- */
-var defaultStrat = function (parentVal, childVal) {
-  return childVal === undefined ? parentVal : childVal
-}
-function assertObjectType(name, value, vm) {
-  if (!isPlainObject(value)) {
-    warn$2(
-      'Invalid value for option "'.concat(name, '": expected an Object, ') +
-        'but got '.concat(toRawType(value), '.'),
-      vm
-    )
-  }
-}
-
-/* globals MutationObserver */
-var callbacks = []
-function flushCallbacks() {
-  var copies = callbacks.slice(0)
-  callbacks.length = 0
-  for (var i = 0; i < copies.length; i++) {
-    copies[i]()
-  }
-}
-// The nextTick behavior leverages the microtask queue, which can be accessed
-// via either native Promise.then or MutationObserver.
-// MutationObserver has wider support, however it is seriously bugged in
-// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
-// completely stops working after triggering a few times... so, if native
-// Promise is available, we will use it:
-/* istanbul ignore next, $flow-disable-line */
-if (typeof Promise !== 'undefined' && isNative(Promise)) {
-  Promise.resolve()
-} else if (
-  !isIE &&
-  typeof MutationObserver !== 'undefined' &&
-  (isNative(MutationObserver) ||
-    // PhantomJS and iOS 7.x
-    MutationObserver.toString() === '[object MutationObserverConstructor]')
-) {
-  // Use MutationObserver where native Promise is not available,
-  // e.g. PhantomJS, iOS7, Android 4.4
-  // (#6466 MutationObserver is unreliable in IE11)
-  var counter_1 = 1
-  var observer = new MutationObserver(flushCallbacks)
-  var textNode_1 = document.createTextNode(String(counter_1))
-  observer.observe(textNode_1, {
-    characterData: true
-  })
-} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate));
-else;
-
-// these are reserved for web because they are directly compiled away
-// during template compilation
-makeMap('style,class')
-// attributes that should be using props for binding
-var acceptValue = makeMap('input,textarea,option,select,progress')
-var mustUseProp = function (tag, type, attr) {
-  return (
-    (attr === 'value' && acceptValue(tag) && type !== 'button') ||
-    (attr === 'selected' && tag === 'option') ||
-    (attr === 'checked' && tag === 'input') ||
-    (attr === 'muted' && tag === 'video')
-  )
-}
-var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck')
-makeMap('events,caret,typing,plaintext-only')
-var isBooleanAttr = makeMap(
-  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
-    'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
-    'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
-    'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
-    'required,reversed,scoped,seamless,selected,sortable,' +
-    'truespeed,typemustmatch,visible'
-)
-
-var isHTMLTag = makeMap(
-  'html,body,base,head,link,meta,style,title,' +
-    'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
-    'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
-    'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
-    's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
-    'embed,object,param,source,canvas,script,noscript,del,ins,' +
-    'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
-    'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
-    'output,progress,select,textarea,' +
-    'details,dialog,menu,menuitem,summary,' +
-    'content,element,shadow,template,blockquote,iframe,tfoot'
-)
-// this map is intentionally selective, only covering SVG elements that may
-// contain child elements.
-var isSVG = makeMap(
-  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
-    'foreignobject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
-    'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
-  true
-)
-var isPreTag = function (tag) {
-  return tag === 'pre'
-}
-var isReservedTag = function (tag) {
-  return isHTMLTag(tag) || isSVG(tag)
-}
-function getTagNamespace(tag) {
-  if (isSVG(tag)) {
-    return 'svg'
-  }
-  // basic support for MathML
-  // note it doesn't support other MathML elements being component roots
-  if (tag === 'math') {
-    return 'math'
-  }
-}
-makeMap('text,number,password,search,email,tel,url')
-
-var validDivisionCharRE = /[\w).+\-_$\]]/
-function parseFilters(exp) {
-  var inSingle = false
-  var inDouble = false
-  var inTemplateString = false
-  var inRegex = false
-  var curly = 0
-  var square = 0
-  var paren = 0
-  var lastFilterIndex = 0
-  var c, prev, i, expression, filters
-  for (i = 0; i < exp.length; i++) {
-    prev = c
-    c = exp.charCodeAt(i)
-    if (inSingle) {
-      if (c === 0x27 && prev !== 0x5c) inSingle = false
-    } else if (inDouble) {
-      if (c === 0x22 && prev !== 0x5c) inDouble = false
-    } else if (inTemplateString) {
-      if (c === 0x60 && prev !== 0x5c) inTemplateString = false
-    } else if (inRegex) {
-      if (c === 0x2f && prev !== 0x5c) inRegex = false
-    } else if (
-      c === 0x7c && // pipe
-      exp.charCodeAt(i + 1) !== 0x7c &&
-      exp.charCodeAt(i - 1) !== 0x7c &&
-      !curly &&
-      !square &&
-      !paren
-    ) {
-      if (expression === undefined) {
-        // first filter, end of expression
-        lastFilterIndex = i + 1
-        expression = exp.slice(0, i).trim()
-      } else {
-        pushFilter()
-      }
-    } else {
-      switch (c) {
-        case 0x22:
-          inDouble = true
-          break // "
-        case 0x27:
-          inSingle = true
-          break // '
-        case 0x60:
-          inTemplateString = true
-          break // `
-        case 0x28:
-          paren++
-          break // (
-        case 0x29:
-          paren--
-          break // )
-        case 0x5b:
-          square++
-          break // [
-        case 0x5d:
-          square--
-          break // ]
-        case 0x7b:
-          curly++
-          break // {
-        case 0x7d:
-          curly--
-          break // }
-      }
-      if (c === 0x2f) {
-        // /
-        var j = i - 1
-        var p =
-          // find first non-whitespace prev char
-          void 0
-        // find first non-whitespace prev char
-        for (; j >= 0; j--) {
-          p = exp.charAt(j)
-          if (p !== ' ') break
-        }
-        if (!p || !validDivisionCharRE.test(p)) {
-          inRegex = true
-        }
-      }
-    }
-  }
-  if (expression === undefined) {
-    expression = exp.slice(0, i).trim()
-  } else if (lastFilterIndex !== 0) {
-    pushFilter()
-  }
-  function pushFilter() {
-    ;(filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim())
-    lastFilterIndex = i + 1
-  }
-  if (filters) {
-    for (i = 0; i < filters.length; i++) {
-      expression = wrapFilter(expression, filters[i])
-    }
-  }
-  return expression
-}
-function wrapFilter(exp, filter) {
-  var i = filter.indexOf('(')
-  if (i < 0) {
-    // _f: resolveFilter
-    return '_f("'.concat(filter, '")(').concat(exp, ')')
-  } else {
-    var name_1 = filter.slice(0, i)
-    var args = filter.slice(i + 1)
-    return '_f("'
-      .concat(name_1, '")(')
-      .concat(exp)
-      .concat(args !== ')' ? ',' + args : args)
-  }
-}
-
-var defaultTagRE = /\{\{((?:.|\r?\n)+?)\}\}/g
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
-var buildRegex = cached(function (delimiters) {
-  var open = delimiters[0].replace(regexEscapeRE, '\\$&')
-  var close = delimiters[1].replace(regexEscapeRE, '\\$&')
-  return new RegExp(open + '((?:.|\\n)+?)' + close, 'g')
-})
-function parseText(text, delimiters) {
-  //@ts-expect-error
-  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE
-  if (!tagRE.test(text)) {
-    return
-  }
-  var tokens = []
-  var rawTokens = []
-  var lastIndex = (tagRE.lastIndex = 0)
-  var match, index, tokenValue
-  while ((match = tagRE.exec(text))) {
-    index = match.index
-    // push text token
-    if (index > lastIndex) {
-      rawTokens.push((tokenValue = text.slice(lastIndex, index)))
-      tokens.push(JSON.stringify(tokenValue))
-    }
-    // tag token
-    var exp = parseFilters(match[1].trim())
-    tokens.push('_s('.concat(exp, ')'))
-    rawTokens.push({ '@binding': exp })
-    lastIndex = index + match[0].length
-  }
-  if (lastIndex < text.length) {
-    rawTokens.push((tokenValue = text.slice(lastIndex)))
-    tokens.push(JSON.stringify(tokenValue))
-  }
-  return {
-    expression: tokens.join('+'),
-    tokens: rawTokens
-  }
-}
-
-/* eslint-disable no-unused-vars */
-function baseWarn(msg, range) {
-  console.error('[Vue compiler]: '.concat(msg))
-}
-/* eslint-enable no-unused-vars */
-function pluckModuleFunction(modules, key) {
-  return modules
-    ? modules
-        .map(function (m) {
-          return m[key]
-        })
-        .filter(function (_) {
-          return _
-        })
-    : []
-}
-function addProp(el, name, value, range, dynamic) {
-  ;(el.props || (el.props = [])).push(
-    rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
-  )
-  el.plain = false
-}
-function addAttr(el, name, value, range, dynamic) {
-  var attrs = dynamic
-    ? el.dynamicAttrs || (el.dynamicAttrs = [])
-    : el.attrs || (el.attrs = [])
-  attrs.push(
-    rangeSetItem({ name: name, value: value, dynamic: dynamic }, range)
-  )
-  el.plain = false
-}
-// add a raw attr (use this in preTransforms)
-function addRawAttr(el, name, value, range) {
-  el.attrsMap[name] = value
-  el.attrsList.push(rangeSetItem({ name: name, value: value }, range))
-}
-function addDirective(
-  el,
-  name,
-  rawName,
-  value,
-  arg,
-  isDynamicArg,
-  modifiers,
-  range
-) {
-  ;(el.directives || (el.directives = [])).push(
-    rangeSetItem(
-      {
-        name: name,
-        rawName: rawName,
-        value: value,
-        arg: arg,
-        isDynamicArg: isDynamicArg,
-        modifiers: modifiers
-      },
-      range
-    )
-  )
-  el.plain = false
-}
-function prependModifierMarker(symbol, name, dynamic) {
-  return dynamic ? '_p('.concat(name, ',"').concat(symbol, '")') : symbol + name // mark the event as captured
-}
-function addHandler(
-  el,
-  name,
-  value,
-  modifiers,
-  important,
-  warn,
-  range,
-  dynamic
-) {
-  modifiers = modifiers || emptyObject
-  // warn prevent and passive modifier
-  /* istanbul ignore if */
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    warn &&
-    modifiers.prevent &&
-    modifiers.passive
-  ) {
-    warn(
-      "passive and prevent can't be used together. " +
-        "Passive handler can't prevent default event.",
-      range
-    )
-  }
-  // normalize click.right and click.middle since they don't actually fire
-  // this is technically browser-specific, but at least for now browsers are
-  // the only target envs that have right/middle clicks.
-  if (modifiers.right) {
-    if (dynamic) {
-      name = '('.concat(name, ")==='click'?'contextmenu':(").concat(name, ')')
-    } else if (name === 'click') {
-      name = 'contextmenu'
-      delete modifiers.right
-    }
-  } else if (modifiers.middle) {
-    if (dynamic) {
-      name = '('.concat(name, ")==='click'?'mouseup':(").concat(name, ')')
-    } else if (name === 'click') {
-      name = 'mouseup'
-    }
-  }
-  // check capture modifier
-  if (modifiers.capture) {
-    delete modifiers.capture
-    name = prependModifierMarker('!', name, dynamic)
-  }
-  if (modifiers.once) {
-    delete modifiers.once
-    name = prependModifierMarker('~', name, dynamic)
-  }
-  /* istanbul ignore if */
-  if (modifiers.passive) {
-    delete modifiers.passive
-    name = prependModifierMarker('&', name, dynamic)
-  }
-  var events
-  if (modifiers.native) {
-    delete modifiers.native
-    events = el.nativeEvents || (el.nativeEvents = {})
-  } else {
-    events = el.events || (el.events = {})
-  }
-  var newHandler = rangeSetItem(
-    { value: value.trim(), dynamic: dynamic },
-    range
-  )
-  if (modifiers !== emptyObject) {
-    newHandler.modifiers = modifiers
-  }
-  var handlers = events[name]
-  /* istanbul ignore if */
-  if (Array.isArray(handlers)) {
-    important ? handlers.unshift(newHandler) : handlers.push(newHandler)
-  } else if (handlers) {
-    events[name] = important ? [newHandler, handlers] : [handlers, newHandler]
-  } else {
-    events[name] = newHandler
-  }
-  el.plain = false
-}
-function getRawBindingAttr(el, name) {
-  return (
-    el.rawAttrsMap[':' + name] ||
-    el.rawAttrsMap['v-bind:' + name] ||
-    el.rawAttrsMap[name]
-  )
-}
-function getBindingAttr(el, name, getStatic) {
-  var dynamicValue =
-    getAndRemoveAttr(el, ':' + name) || getAndRemoveAttr(el, 'v-bind:' + name)
-  if (dynamicValue != null) {
-    return parseFilters(dynamicValue)
-  } else if (getStatic !== false) {
-    var staticValue = getAndRemoveAttr(el, name)
-    if (staticValue != null) {
-      return JSON.stringify(staticValue)
-    }
-  }
-}
-// note: this only removes the attr from the Array (attrsList) so that it
-// doesn't get processed by processAttrs.
-// By default it does NOT remove it from the map (attrsMap) because the map is
-// needed during codegen.
-function getAndRemoveAttr(el, name, removeFromMap) {
-  var val
-  if ((val = el.attrsMap[name]) != null) {
-    var list = el.attrsList
-    for (var i = 0, l = list.length; i < l; i++) {
-      if (list[i].name === name) {
-        list.splice(i, 1)
-        break
-      }
-    }
-  }
-  if (removeFromMap) {
-    delete el.attrsMap[name]
-  }
-  return val
-}
-function getAndRemoveAttrByRegex(el, name) {
-  var list = el.attrsList
-  for (var i = 0, l = list.length; i < l; i++) {
-    var attr = list[i]
-    if (name.test(attr.name)) {
-      list.splice(i, 1)
-      return attr
-    }
-  }
-}
-function rangeSetItem(item, range) {
-  if (range) {
-    if (range.start != null) {
-      item.start = range.start
-    }
-    if (range.end != null) {
-      item.end = range.end
-    }
-  }
-  return item
-}
-
-function transformNode$1(el, options) {
-  var warn = options.warn || baseWarn
-  var staticClass = getAndRemoveAttr(el, 'class')
-  if (process.env.NODE_ENV !== 'production' && staticClass) {
-    var res = parseText(staticClass, options.delimiters)
-    if (res) {
-      warn(
-        'class="'.concat(staticClass, '": ') +
-          'Interpolation inside attributes has been removed. ' +
-          'Use v-bind or the colon shorthand instead. For example, ' +
-          'instead of <div class="{{ val }}">, use <div :class="val">.',
-        el.rawAttrsMap['class']
-      )
-    }
-  }
-  if (staticClass) {
-    el.staticClass = JSON.stringify(staticClass.replace(/\s+/g, ' ').trim())
-  }
-  var classBinding = getBindingAttr(el, 'class', false /* getStatic */)
-  if (classBinding) {
-    el.classBinding = classBinding
-  }
-}
-function genData$2(el) {
-  var data = ''
-  if (el.staticClass) {
-    data += 'staticClass:'.concat(el.staticClass, ',')
-  }
-  if (el.classBinding) {
-    data += 'class:'.concat(el.classBinding, ',')
-  }
-  return data
-}
-var klass = {
-  staticKeys: ['staticClass'],
-  transformNode: transformNode$1,
-  genData: genData$2
-}
-
-var parseStyleText = cached(function (cssText) {
-  var res = {}
-  var listDelimiter = /;(?![^(]*\))/g
-  var propertyDelimiter = /:(.+)/
-  cssText.split(listDelimiter).forEach(function (item) {
-    if (item) {
-      var tmp = item.split(propertyDelimiter)
-      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim())
-    }
-  })
-  return res
-})
-
-function transformNode(el, options) {
-  var warn = options.warn || baseWarn
-  var staticStyle = getAndRemoveAttr(el, 'style')
-  if (staticStyle) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      var res = parseText(staticStyle, options.delimiters)
-      if (res) {
-        warn(
-          'style="'.concat(staticStyle, '": ') +
-            'Interpolation inside attributes has been removed. ' +
-            'Use v-bind or the colon shorthand instead. For example, ' +
-            'instead of <div style="{{ val }}">, use <div :style="val">.',
-          el.rawAttrsMap['style']
-        )
-      }
-    }
-    el.staticStyle = JSON.stringify(parseStyleText(staticStyle))
-  }
-  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */)
-  if (styleBinding) {
-    el.styleBinding = styleBinding
-  }
-}
-function genData$1(el) {
-  var data = ''
-  if (el.staticStyle) {
-    data += 'staticStyle:'.concat(el.staticStyle, ',')
-  }
-  if (el.styleBinding) {
-    data += 'style:('.concat(el.styleBinding, '),')
-  }
-  return data
-}
-var style = {
-  staticKeys: ['staticStyle'],
-  transformNode: transformNode,
-  genData: genData$1
-}
-
-/**
- * Cross-platform code generation for component v-model
- */
-function genComponentModel(el, value, modifiers) {
-  var _a = modifiers || {},
-    number = _a.number,
-    trim = _a.trim
-  var baseValueExpression = '$$v'
-  var valueExpression = baseValueExpression
-  if (trim) {
-    valueExpression =
-      '(typeof '.concat(baseValueExpression, " === 'string'") +
-      '? '.concat(baseValueExpression, '.trim()') +
-      ': '.concat(baseValueExpression, ')')
-  }
-  if (number) {
-    valueExpression = '_n('.concat(valueExpression, ')')
-  }
-  var assignment = genAssignmentCode(value, valueExpression)
-  el.model = {
-    value: '('.concat(value, ')'),
-    expression: JSON.stringify(value),
-    callback: 'function ('
-      .concat(baseValueExpression, ') {')
-      .concat(assignment, '}')
-  }
-}
-/**
- * Cross-platform codegen helper for generating v-model value assignment code.
- */
-function genAssignmentCode(value, assignment) {
-  var res = parseModel(value)
-  if (res.key === null) {
-    return ''.concat(value, '=').concat(assignment)
-  } else {
-    return '$set('
-      .concat(res.exp, ', ')
-      .concat(res.key, ', ')
-      .concat(assignment, ')')
-  }
-}
-/**
- * Parse a v-model expression into a base path and a final key segment.
- * Handles both dot-path and possible square brackets.
- *
- * Possible cases:
- *
- * - test
- * - test[key]
- * - test[test1[key]]
- * - test["a"][key]
- * - xxx.test[a[a].test1[key]]
- * - test.xxx.a["asa"][test1[key]]
- *
- */
-var len, str, chr, index, expressionPos, expressionEndPos
-function parseModel(val) {
-  // Fix https://github.com/vuejs/vue/pull/7730
-  // allow v-model="obj.val " (trailing whitespace)
-  val = val.trim()
-  len = val.length
-  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {
-    index = val.lastIndexOf('.')
-    if (index > -1) {
-      return {
-        exp: val.slice(0, index),
-        key: '"' + val.slice(index + 1) + '"'
-      }
-    } else {
-      return {
-        exp: val,
-        key: null
-      }
-    }
-  }
-  str = val
-  index = expressionPos = expressionEndPos = 0
-  while (!eof()) {
-    chr = next()
-    /* istanbul ignore if */
-    if (isStringStart(chr)) {
-      parseString(chr)
-    } else if (chr === 0x5b) {
-      parseBracket(chr)
-    }
-  }
-  return {
-    exp: val.slice(0, expressionPos),
-    key: val.slice(expressionPos + 1, expressionEndPos)
-  }
-}
-function next() {
-  return str.charCodeAt(++index)
-}
-function eof() {
-  return index >= len
-}
-function isStringStart(chr) {
-  return chr === 0x22 || chr === 0x27
-}
-function parseBracket(chr) {
-  var inBracket = 1
-  expressionPos = index
-  while (!eof()) {
-    chr = next()
-    if (isStringStart(chr)) {
-      parseString(chr)
-      continue
-    }
-    if (chr === 0x5b) inBracket++
-    if (chr === 0x5d) inBracket--
-    if (inBracket === 0) {
-      expressionEndPos = index
-      break
-    }
-  }
-}
-function parseString(chr) {
-  var stringQuote = chr
-  while (!eof()) {
-    chr = next()
-    if (chr === stringQuote) {
-      break
-    }
-  }
-}
-
-var onRE = /^@|^v-on:/
-var dirRE = /^v-|^@|^:|^#/
-var forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
-var forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/
-var stripParensRE = /^\(|\)$/g
-var dynamicArgRE = /^\[.*\]$/
-var argRE = /:(.*)$/
-var bindRE = /^:|^\.|^v-bind:/
-var modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
-var slotRE = /^v-slot(:|$)|^#/
-var lineBreakRE = /[\r\n]/
-var whitespaceRE = /[ \f\t\r\n]+/g
-var invalidAttributeRE = /[\s"'<>\/=]/
-var decodeHTMLCached = cached(he__default['default'].decode)
-var emptySlotScopeToken = '_empty_'
-// configurable state
-var warn$1
-var delimiters
-var transforms
-var preTransforms
-var postTransforms
-var platformIsPreTag
-var platformMustUseProp
-var platformGetTagNamespace
-var maybeComponent
-function createASTElement(tag, attrs, parent) {
-  return {
-    type: 1,
-    tag: tag,
-    attrsList: attrs,
-    attrsMap: makeAttrsMap(attrs),
-    rawAttrsMap: {},
-    parent: parent,
-    children: []
-  }
-}
-/**
- * Convert HTML string to AST.
- */
-function parse(template, options) {
-  warn$1 = options.warn || baseWarn
-  platformIsPreTag = options.isPreTag || no
-  platformMustUseProp = options.mustUseProp || no
-  platformGetTagNamespace = options.getTagNamespace || no
-  var isReservedTag = options.isReservedTag || no
-  maybeComponent = function (el) {
-    return !!(
-      el.component ||
-      el.attrsMap[':is'] ||
-      el.attrsMap['v-bind:is'] ||
-      !(el.attrsMap.is ? isReservedTag(el.attrsMap.is) : isReservedTag(el.tag))
-    )
-  }
-  transforms = pluckModuleFunction(options.modules, 'transformNode')
-  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode')
-  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode')
-  delimiters = options.delimiters
-  var stack = []
-  var preserveWhitespace = options.preserveWhitespace !== false
-  var whitespaceOption = options.whitespace
-  var root
-  var currentParent
-  var inVPre = false
-  var inPre = false
-  var warned = false
-  function warnOnce(msg, range) {
-    if (!warned) {
-      warned = true
-      warn$1(msg, range)
-    }
-  }
-  function closeElement(element) {
-    trimEndingWhitespace(element)
-    if (!inVPre && !element.processed) {
-      element = processElement(element, options)
-    }
-    // tree management
-    if (!stack.length && element !== root) {
-      // allow root elements with v-if, v-else-if and v-else
-      if (root.if && (element.elseif || element.else)) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(element)
-        }
-        addIfCondition(root, {
-          exp: element.elseif,
-          block: element
-        })
-      } else if (process.env.NODE_ENV !== 'production') {
-        warnOnce(
-          'Component template should contain exactly one root element. ' +
-            'If you are using v-if on multiple elements, ' +
-            'use v-else-if to chain them instead.',
-          { start: element.start }
-        )
-      }
-    }
-    if (currentParent && !element.forbidden) {
-      if (element.elseif || element.else) {
-        processIfConditions(element, currentParent)
-      } else {
-        if (element.slotScope) {
-          // scoped slot
-          // keep it in the children list so that v-else(-if) conditions can
-          // find it as the prev node.
-          var name_1 = element.slotTarget || '"default"'
-          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[
-            name_1
-          ] = element
-        }
-        currentParent.children.push(element)
-        element.parent = currentParent
-      }
-    }
-    // final children cleanup
-    // filter out scoped slots
-    element.children = element.children.filter(function (c) {
-      return !c.slotScope
-    })
-    // remove trailing whitespace node again
-    trimEndingWhitespace(element)
-    // check pre state
-    if (element.pre) {
-      inVPre = false
-    }
-    if (platformIsPreTag(element.tag)) {
-      inPre = false
-    }
-    // apply post-transforms
-    for (var i = 0; i < postTransforms.length; i++) {
-      postTransforms[i](element, options)
-    }
-  }
-  function trimEndingWhitespace(el) {
-    // remove trailing whitespace node
-    if (!inPre) {
-      var lastNode = void 0
-      while (
-        (lastNode = el.children[el.children.length - 1]) &&
-        lastNode.type === 3 &&
-        lastNode.text === ' '
-      ) {
-        el.children.pop()
-      }
-    }
-  }
-  function checkRootConstraints(el) {
-    if (el.tag === 'slot' || el.tag === 'template') {
-      warnOnce(
-        'Cannot use <'.concat(
-          el.tag,
-          '> as component root element because it may '
-        ) + 'contain multiple nodes.',
-        { start: el.start }
-      )
-    }
-    if (el.attrsMap.hasOwnProperty('v-for')) {
-      warnOnce(
-        'Cannot use v-for on stateful component root element because ' +
-          'it renders multiple elements.',
-        el.rawAttrsMap['v-for']
-      )
-    }
-  }
-  parseHTML(template, {
-    warn: warn$1,
-    expectHTML: options.expectHTML,
-    isUnaryTag: options.isUnaryTag,
-    canBeLeftOpenTag: options.canBeLeftOpenTag,
-    shouldDecodeNewlines: options.shouldDecodeNewlines,
-    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,
-    shouldKeepComment: options.comments,
-    outputSourceRange: options.outputSourceRange,
-    start: function (tag, attrs, unary, start, end) {
-      // check namespace.
-      // inherit parent ns if there is one
-      var ns =
-        (currentParent && currentParent.ns) || platformGetTagNamespace(tag)
-      // handle IE svg bug
-      /* istanbul ignore if */
-      if (isIE && ns === 'svg') {
-        attrs = guardIESVGBug(attrs)
-      }
-      var element = createASTElement(tag, attrs, currentParent)
-      if (ns) {
-        element.ns = ns
-      }
-      if (process.env.NODE_ENV !== 'production') {
-        if (options.outputSourceRange) {
-          element.start = start
-          element.end = end
-          element.rawAttrsMap = element.attrsList.reduce(function (
-            cumulated,
-            attr
-          ) {
-            cumulated[attr.name] = attr
-            return cumulated
-          },
-          {})
-        }
-        attrs.forEach(function (attr) {
-          if (invalidAttributeRE.test(attr.name)) {
-            warn$1(
-              'Invalid dynamic argument expression: attribute names cannot contain ' +
-                'spaces, quotes, <, >, / or =.',
-              {
-                start: attr.start + attr.name.indexOf('['),
-                end: attr.start + attr.name.length
-              }
-            )
-          }
-        })
-      }
-      if (isForbiddenTag(element) && !isServerRendering()) {
-        element.forbidden = true
-        process.env.NODE_ENV !== 'production' &&
-          warn$1(
-            'Templates should only be responsible for mapping the state to the ' +
-              'UI. Avoid placing tags with side-effects in your templates, such as ' +
-              '<'.concat(tag, '>') +
-              ', as they will not be parsed.',
-            { start: element.start }
-          )
-      }
-      // apply pre-transforms
-      for (var i = 0; i < preTransforms.length; i++) {
-        element = preTransforms[i](element, options) || element
-      }
-      if (!inVPre) {
-        processPre(element)
-        if (element.pre) {
-          inVPre = true
-        }
-      }
-      if (platformIsPreTag(element.tag)) {
-        inPre = true
-      }
-      if (inVPre) {
-        processRawAttrs(element)
-      } else if (!element.processed) {
-        // structural directives
-        processFor(element)
-        processIf(element)
-        processOnce(element)
-      }
-      if (!root) {
-        root = element
-        if (process.env.NODE_ENV !== 'production') {
-          checkRootConstraints(root)
-        }
-      }
-      if (!unary) {
-        currentParent = element
-        stack.push(element)
-      } else {
-        closeElement(element)
-      }
-    },
-    end: function (tag, start, end) {
-      var element = stack[stack.length - 1]
-      // pop stack
-      stack.length -= 1
-      currentParent = stack[stack.length - 1]
-      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {
-        element.end = end
-      }
-      closeElement(element)
-    },
-    chars: function (text, start, end) {
-      if (!currentParent) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (text === template) {
-            warnOnce(
-              'Component template requires a root element, rather than just text.',
-              { start: start }
-            )
-          } else if ((text = text.trim())) {
-            warnOnce(
-              'text "'.concat(text, '" outside root element will be ignored.'),
-              {
-                start: start
-              }
-            )
-          }
-        }
-        return
-      }
-      // IE textarea placeholder bug
-      /* istanbul ignore if */
-      if (
-        isIE &&
-        currentParent.tag === 'textarea' &&
-        currentParent.attrsMap.placeholder === text
-      ) {
-        return
-      }
-      var children = currentParent.children
-      if (inPre || text.trim()) {
-        text = isTextTag(currentParent) ? text : decodeHTMLCached(text)
-      } else if (!children.length) {
-        // remove the whitespace-only node right after an opening tag
-        text = ''
-      } else if (whitespaceOption) {
-        if (whitespaceOption === 'condense') {
-          // in condense mode, remove the whitespace node if it contains
-          // line break, otherwise condense to a single space
-          text = lineBreakRE.test(text) ? '' : ' '
-        } else {
-          text = ' '
-        }
-      } else {
-        text = preserveWhitespace ? ' ' : ''
-      }
-      if (text) {
-        if (!inPre && whitespaceOption === 'condense') {
-          // condense consecutive whitespaces into single space
-          text = text.replace(whitespaceRE, ' ')
-        }
-        var res = void 0
-        var child = void 0
-        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {
-          child = {
-            type: 2,
-            expression: res.expression,
-            tokens: res.tokens,
-            text: text
-          }
-        } else if (
-          text !== ' ' ||
-          !children.length ||
-          children[children.length - 1].text !== ' '
-        ) {
-          child = {
-            type: 3,
-            text: text
-          }
-        }
-        if (child) {
-          if (
-            process.env.NODE_ENV !== 'production' &&
-            options.outputSourceRange
-          ) {
-            child.start = start
-            child.end = end
-          }
-          children.push(child)
-        }
-      }
-    },
-    comment: function (text, start, end) {
-      // adding anything as a sibling to the root node is forbidden
-      // comments should still be allowed, but ignored
-      if (currentParent) {
-        var child = {
-          type: 3,
-          text: text,
-          isComment: true
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          options.outputSourceRange
-        ) {
-          child.start = start
-          child.end = end
-        }
-        currentParent.children.push(child)
-      }
-    }
-  })
-  return root
-}
-function processPre(el) {
-  if (getAndRemoveAttr(el, 'v-pre') != null) {
-    el.pre = true
-  }
-}
-function processRawAttrs(el) {
-  var list = el.attrsList
-  var len = list.length
-  if (len) {
-    var attrs = (el.attrs = new Array(len))
-    for (var i = 0; i < len; i++) {
-      attrs[i] = {
-        name: list[i].name,
-        value: JSON.stringify(list[i].value)
-      }
-      if (list[i].start != null) {
-        attrs[i].start = list[i].start
-        attrs[i].end = list[i].end
-      }
-    }
-  } else if (!el.pre) {
-    // non root node in pre blocks with no attributes
-    el.plain = true
-  }
-}
-function processElement(element, options) {
-  processKey(element)
-  // determine whether this is a plain element after
-  // removing structural attributes
-  element.plain =
-    !element.key && !element.scopedSlots && !element.attrsList.length
-  processRef(element)
-  processSlotContent(element)
-  processSlotOutlet(element)
-  processComponent(element)
-  for (var i = 0; i < transforms.length; i++) {
-    element = transforms[i](element, options) || element
-  }
-  processAttrs(element)
-  return element
-}
-function processKey(el) {
-  var exp = getBindingAttr(el, 'key')
-  if (exp) {
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.tag === 'template') {
-        warn$1(
-          '<template> cannot be keyed. Place the key on real elements instead.',
-          getRawBindingAttr(el, 'key')
-        )
-      }
-      if (el.for) {
-        var iterator = el.iterator2 || el.iterator1
-        var parent_1 = el.parent
-        if (
-          iterator &&
-          iterator === exp &&
-          parent_1 &&
-          parent_1.tag === 'transition-group'
-        ) {
-          warn$1(
-            'Do not use v-for index as key on <transition-group> children, ' +
-              'this is the same as not using keys.',
-            getRawBindingAttr(el, 'key'),
-            true /* tip */
-          )
-        }
-      }
-    }
-    el.key = exp
-  }
-}
-function processRef(el) {
-  var ref = getBindingAttr(el, 'ref')
-  if (ref) {
-    el.ref = ref
-    el.refInFor = checkInFor(el)
-  }
-}
-function processFor(el) {
-  var exp
-  if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-    var res = parseFor(exp)
-    if (res) {
-      extend(el, res)
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$1('Invalid v-for expression: '.concat(exp), el.rawAttrsMap['v-for'])
-    }
-  }
-}
-function parseFor(exp) {
-  var inMatch = exp.match(forAliasRE)
-  if (!inMatch) return
-  var res = {}
-  res.for = inMatch[2].trim()
-  var alias = inMatch[1].trim().replace(stripParensRE, '')
-  var iteratorMatch = alias.match(forIteratorRE)
-  if (iteratorMatch) {
-    res.alias = alias.replace(forIteratorRE, '').trim()
-    res.iterator1 = iteratorMatch[1].trim()
-    if (iteratorMatch[2]) {
-      res.iterator2 = iteratorMatch[2].trim()
-    }
-  } else {
-    res.alias = alias
-  }
-  return res
-}
-function processIf(el) {
-  var exp = getAndRemoveAttr(el, 'v-if')
-  if (exp) {
-    el.if = exp
-    addIfCondition(el, {
-      exp: exp,
-      block: el
-    })
-  } else {
-    if (getAndRemoveAttr(el, 'v-else') != null) {
-      el.else = true
-    }
-    var elseif = getAndRemoveAttr(el, 'v-else-if')
-    if (elseif) {
-      el.elseif = elseif
-    }
-  }
-}
-function processIfConditions(el, parent) {
-  var prev = findPrevElement(parent.children)
-  if (prev && prev.if) {
-    addIfCondition(prev, {
-      exp: el.elseif,
-      block: el
-    })
-  } else if (process.env.NODE_ENV !== 'production') {
-    warn$1(
-      'v-'.concat(el.elseif ? 'else-if="' + el.elseif + '"' : 'else', ' ') +
-        'used on element <'.concat(el.tag, '> without corresponding v-if.'),
-      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']
-    )
-  }
-}
-function findPrevElement(children) {
-  var i = children.length
-  while (i--) {
-    if (children[i].type === 1) {
-      return children[i]
-    } else {
-      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {
-        warn$1(
-          'text "'.concat(
-            children[i].text.trim(),
-            '" between v-if and v-else(-if) '
-          ) + 'will be ignored.',
-          children[i]
-        )
-      }
-      children.pop()
-    }
-  }
-}
-function addIfCondition(el, condition) {
-  if (!el.ifConditions) {
-    el.ifConditions = []
-  }
-  el.ifConditions.push(condition)
-}
-function processOnce(el) {
-  var once = getAndRemoveAttr(el, 'v-once')
-  if (once != null) {
-    el.once = true
-  }
-}
-// handle content being passed to a component as slot,
-// e.g. <template slot="xxx">, <div slot-scope="xxx">
-function processSlotContent(el) {
-  var slotScope
-  if (el.tag === 'template') {
-    slotScope = getAndRemoveAttr(el, 'scope')
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && slotScope) {
-      warn$1(
-        'the "scope" attribute for scoped slots have been deprecated and ' +
-          'replaced by "slot-scope" since 2.5. The new "slot-scope" attribute ' +
-          'can also be used on plain elements in addition to <template> to ' +
-          'denote scoped slots.',
-        el.rawAttrsMap['scope'],
-        true
-      )
-    }
-    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope')
-  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {
-      warn$1(
-        'Ambiguous combined usage of slot-scope and v-for on <'.concat(
-          el.tag,
-          '> '
-        ) +
-          '(v-for takes higher priority). Use a wrapper <template> for the ' +
-          'scoped slot to make it clearer.',
-        el.rawAttrsMap['slot-scope'],
-        true
-      )
-    }
-    el.slotScope = slotScope
-  }
-  // slot="xxx"
-  var slotTarget = getBindingAttr(el, 'slot')
-  if (slotTarget) {
-    el.slotTarget = slotTarget === '""' ? '"default"' : slotTarget
-    el.slotTargetDynamic = !!(
-      el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']
-    )
-    // preserve slot as an attribute for native shadow DOM compat
-    // only for non-scoped slots.
-    if (el.tag !== 'template' && !el.slotScope) {
-      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'))
-    }
-  }
-  // 2.6 v-slot syntax
-  {
-    if (el.tag === 'template') {
-      // v-slot on <template>
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (el.slotTarget || el.slotScope) {
-            warn$1('Unexpected mixed usage of different slot syntaxes.', el)
-          }
-          if (el.parent && !maybeComponent(el.parent)) {
-            warn$1(
-              '<template v-slot> can only appear at the root level inside ' +
-                'the receiving component',
-              el
-            )
-          }
-        }
-        var _a = getSlotName(slotBinding),
-          name_2 = _a.name,
-          dynamic = _a.dynamic
-        el.slotTarget = name_2
-        el.slotTargetDynamic = dynamic
-        el.slotScope = slotBinding.value || emptySlotScopeToken // force it into a scoped slot for perf
-      }
-    } else {
-      // v-slot on component, denotes default slot
-      var slotBinding = getAndRemoveAttrByRegex(el, slotRE)
-      if (slotBinding) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (!maybeComponent(el)) {
-            warn$1(
-              'v-slot can only be used on components or <template>.',
-              slotBinding
-            )
-          }
-          if (el.slotScope || el.slotTarget) {
-            warn$1('Unexpected mixed usage of different slot syntaxes.', el)
-          }
-          if (el.scopedSlots) {
-            warn$1(
-              'To avoid scope ambiguity, the default slot should also use ' +
-                '<template> syntax when there are other named slots.',
-              slotBinding
-            )
-          }
-        }
-        // add the component's children to its default slot
-        var slots = el.scopedSlots || (el.scopedSlots = {})
-        var _b = getSlotName(slotBinding),
-          name_3 = _b.name,
-          dynamic = _b.dynamic
-        var slotContainer_1 = (slots[name_3] = createASTElement(
-          'template',
-          [],
-          el
-        ))
-        slotContainer_1.slotTarget = name_3
-        slotContainer_1.slotTargetDynamic = dynamic
-        slotContainer_1.children = el.children.filter(function (c) {
-          if (!c.slotScope) {
-            c.parent = slotContainer_1
-            return true
-          }
-        })
-        slotContainer_1.slotScope = slotBinding.value || emptySlotScopeToken
-        // remove children as they are returned from scopedSlots now
-        el.children = []
-        // mark el non-plain so data gets generated
-        el.plain = false
-      }
-    }
-  }
-}
-function getSlotName(binding) {
-  var name = binding.name.replace(slotRE, '')
-  if (!name) {
-    if (binding.name[0] !== '#') {
-      name = 'default'
-    } else if (process.env.NODE_ENV !== 'production') {
-      warn$1('v-slot shorthand syntax requires a slot name.', binding)
-    }
-  }
-  return dynamicArgRE.test(name)
-    ? // dynamic [name]
-      { name: name.slice(1, -1), dynamic: true }
-    : // static name
-      { name: '"'.concat(name, '"'), dynamic: false }
-}
-// handle <slot/> outlets
-function processSlotOutlet(el) {
-  if (el.tag === 'slot') {
-    el.slotName = getBindingAttr(el, 'name')
-    if (process.env.NODE_ENV !== 'production' && el.key) {
-      warn$1(
-        '`key` does not work on <slot> because slots are abstract outlets ' +
-          'and can possibly expand into multiple elements. ' +
-          'Use the key on a wrapping element instead.',
-        getRawBindingAttr(el, 'key')
-      )
-    }
-  }
-}
-function processComponent(el) {
-  var binding
-  if ((binding = getBindingAttr(el, 'is'))) {
-    el.component = binding
-  }
-  if (getAndRemoveAttr(el, 'inline-template') != null) {
-    el.inlineTemplate = true
-  }
-}
-function processAttrs(el) {
-  var list = el.attrsList
-  var i, l, name, rawName, value, modifiers, syncGen, isDynamic
-  for (i = 0, l = list.length; i < l; i++) {
-    name = rawName = list[i].name
-    value = list[i].value
-    if (dirRE.test(name)) {
-      // mark element as dynamic
-      el.hasBindings = true
-      // modifiers
-      modifiers = parseModifiers(name.replace(dirRE, ''))
-      // support .foo shorthand syntax for the .prop modifier
-      if (modifiers) {
-        name = name.replace(modifierRE, '')
-      }
-      if (bindRE.test(name)) {
-        // v-bind
-        name = name.replace(bindRE, '')
-        value = parseFilters(value)
-        isDynamic = dynamicArgRE.test(name)
-        if (isDynamic) {
-          name = name.slice(1, -1)
-        }
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          value.trim().length === 0
-        ) {
-          warn$1(
-            'The value for a v-bind expression cannot be empty. Found in "v-bind:'.concat(
-              name,
-              '"'
-            )
-          )
-        }
-        if (modifiers) {
-          if (modifiers.prop && !isDynamic) {
-            name = camelize(name)
-            if (name === 'innerHtml') name = 'innerHTML'
-          }
-          if (modifiers.camel && !isDynamic) {
-            name = camelize(name)
-          }
-          if (modifiers.sync) {
-            syncGen = genAssignmentCode(value, '$event')
-            if (!isDynamic) {
-              addHandler(
-                el,
-                'update:'.concat(camelize(name)),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i]
-              )
-              if (hyphenate(name) !== camelize(name)) {
-                addHandler(
-                  el,
-                  'update:'.concat(hyphenate(name)),
-                  syncGen,
-                  null,
-                  false,
-                  warn$1,
-                  list[i]
-                )
-              }
-            } else {
-              // handler w/ dynamic event name
-              addHandler(
-                el,
-                '"update:"+('.concat(name, ')'),
-                syncGen,
-                null,
-                false,
-                warn$1,
-                list[i],
-                true // dynamic
-              )
-            }
-          }
-        }
-        if (
-          (modifiers && modifiers.prop) ||
-          (!el.component && platformMustUseProp(el.tag, el.attrsMap.type, name))
-        ) {
-          addProp(el, name, value, list[i], isDynamic)
-        } else {
-          addAttr(el, name, value, list[i], isDynamic)
-        }
-      } else if (onRE.test(name)) {
-        // v-on
-        name = name.replace(onRE, '')
-        isDynamic = dynamicArgRE.test(name)
-        if (isDynamic) {
-          name = name.slice(1, -1)
-        }
-        addHandler(
-          el,
-          name,
-          value,
-          modifiers,
-          false,
-          warn$1,
-          list[i],
-          isDynamic
-        )
-      } else {
-        // normal directives
-        name = name.replace(dirRE, '')
-        // parse arg
-        var argMatch = name.match(argRE)
-        var arg = argMatch && argMatch[1]
-        isDynamic = false
-        if (arg) {
-          name = name.slice(0, -(arg.length + 1))
-          if (dynamicArgRE.test(arg)) {
-            arg = arg.slice(1, -1)
-            isDynamic = true
-          }
-        }
-        addDirective(
-          el,
-          name,
-          rawName,
-          value,
-          arg,
-          isDynamic,
-          modifiers,
-          list[i]
-        )
-        if (process.env.NODE_ENV !== 'production' && name === 'model') {
-          checkForAliasModel(el, value)
-        }
-      }
-    } else {
-      // literal attribute
-      if (process.env.NODE_ENV !== 'production') {
-        var res = parseText(value, delimiters)
-        if (res) {
-          warn$1(
-            ''.concat(name, '="').concat(value, '": ') +
-              'Interpolation inside attributes has been removed. ' +
-              'Use v-bind or the colon shorthand instead. For example, ' +
-              'instead of <div id="{{ val }}">, use <div :id="val">.',
-            list[i]
-          )
-        }
-      }
-      addAttr(el, name, JSON.stringify(value), list[i])
-      // #6887 firefox doesn't update muted state if set via attribute
-      // even immediately after element creation
-      if (
-        !el.component &&
-        name === 'muted' &&
-        platformMustUseProp(el.tag, el.attrsMap.type, name)
-      ) {
-        addProp(el, name, 'true', list[i])
-      }
-    }
-  }
-}
-function checkInFor(el) {
-  var parent = el
-  while (parent) {
-    if (parent.for !== undefined) {
-      return true
-    }
-    parent = parent.parent
-  }
-  return false
-}
-function parseModifiers(name) {
-  var match = name.match(modifierRE)
-  if (match) {
-    var ret_1 = {}
-    match.forEach(function (m) {
-      ret_1[m.slice(1)] = true
-    })
-    return ret_1
-  }
-}
-function makeAttrsMap(attrs) {
-  var map = {}
-  for (var i = 0, l = attrs.length; i < l; i++) {
-    if (
-      process.env.NODE_ENV !== 'production' &&
-      map[attrs[i].name] &&
-      !isIE &&
-      !isEdge
-    ) {
-      warn$1('duplicate attribute: ' + attrs[i].name, attrs[i])
-    }
-    map[attrs[i].name] = attrs[i].value
-  }
-  return map
-}
-// for script (e.g. type="x/template") or style, do not decode content
-function isTextTag(el) {
-  return el.tag === 'script' || el.tag === 'style'
-}
-function isForbiddenTag(el) {
-  return (
-    el.tag === 'style' ||
-    (el.tag === 'script' &&
-      (!el.attrsMap.type || el.attrsMap.type === 'text/javascript'))
-  )
-}
-var ieNSBug = /^xmlns:NS\d+/
-var ieNSPrefix = /^NS\d+:/
-/* istanbul ignore next */
-function guardIESVGBug(attrs) {
-  var res = []
-  for (var i = 0; i < attrs.length; i++) {
-    var attr = attrs[i]
-    if (!ieNSBug.test(attr.name)) {
-      attr.name = attr.name.replace(ieNSPrefix, '')
-      res.push(attr)
-    }
-  }
-  return res
-}
-function checkForAliasModel(el, value) {
-  var _el = el
-  while (_el) {
-    if (_el.for && _el.alias === value) {
-      warn$1(
-        '<'.concat(el.tag, ' v-model="').concat(value, '">: ') +
-          'You are binding v-model directly to a v-for iteration alias. ' +
-          'This will not be able to modify the v-for source array because ' +
-          'writing to the alias is like modifying a function local variable. ' +
-          'Consider using an array of objects and use v-model on an object property instead.',
-        el.rawAttrsMap['v-model']
-      )
-    }
-    _el = _el.parent
-  }
-}
-
-/**
- * Expand input[v-model] with dynamic type bindings into v-if-else chains
- * Turn this:
- *   <input v-model="data[type]" :type="type">
- * into this:
- *   <input v-if="type === 'checkbox'" type="checkbox" v-model="data[type]">
- *   <input v-else-if="type === 'radio'" type="radio" v-model="data[type]">
- *   <input v-else :type="type" v-model="data[type]">
- */
-function preTransformNode(el, options) {
-  if (el.tag === 'input') {
-    var map = el.attrsMap
-    if (!map['v-model']) {
-      return
-    }
-    var typeBinding = void 0
-    if (map[':type'] || map['v-bind:type']) {
-      typeBinding = getBindingAttr(el, 'type')
-    }
-    if (!map.type && !typeBinding && map['v-bind']) {
-      typeBinding = '('.concat(map['v-bind'], ').type')
-    }
-    if (typeBinding) {
-      var ifCondition = getAndRemoveAttr(el, 'v-if', true)
-      var ifConditionExtra = ifCondition ? '&&('.concat(ifCondition, ')') : ''
-      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null
-      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true)
-      // 1. checkbox
-      var branch0 = cloneASTElement(el)
-      // process for on the main node
-      processFor(branch0)
-      addRawAttr(branch0, 'type', 'checkbox')
-      processElement(branch0, options)
-      branch0.processed = true // prevent it from double-processed
-      branch0.if = '('.concat(typeBinding, ")==='checkbox'") + ifConditionExtra
-      addIfCondition(branch0, {
-        exp: branch0.if,
-        block: branch0
-      })
-      // 2. add radio else-if condition
-      var branch1 = cloneASTElement(el)
-      getAndRemoveAttr(branch1, 'v-for', true)
-      addRawAttr(branch1, 'type', 'radio')
-      processElement(branch1, options)
-      addIfCondition(branch0, {
-        exp: '('.concat(typeBinding, ")==='radio'") + ifConditionExtra,
-        block: branch1
-      })
-      // 3. other
-      var branch2 = cloneASTElement(el)
-      getAndRemoveAttr(branch2, 'v-for', true)
-      addRawAttr(branch2, ':type', typeBinding)
-      processElement(branch2, options)
-      addIfCondition(branch0, {
-        exp: ifCondition,
-        block: branch2
-      })
-      if (hasElse) {
-        branch0.else = true
-      } else if (elseIfCondition) {
-        branch0.elseif = elseIfCondition
-      }
-      return branch0
-    }
-  }
-}
-function cloneASTElement(el) {
-  return createASTElement(el.tag, el.attrsList.slice(), el.parent)
-}
-var model$1 = {
-  preTransformNode: preTransformNode
-}
-
-var modules = [klass, style, model$1]
-
-var warn
-// in some cases, the event used has to be determined at runtime
-// so we used some reserved tokens during compile.
-var RANGE_TOKEN = '__r'
-function model(el, dir, _warn) {
-  warn = _warn
-  var value = dir.value
-  var modifiers = dir.modifiers
-  var tag = el.tag
-  var type = el.attrsMap.type
-  if (process.env.NODE_ENV !== 'production') {
-    // inputs with type="file" are read only and setting the input's
-    // value will throw an error.
-    if (tag === 'input' && type === 'file') {
-      warn(
-        '<'.concat(el.tag, ' v-model="').concat(value, '" type="file">:\n') +
-          'File inputs are read only. Use a v-on:change listener instead.',
-        el.rawAttrsMap['v-model']
-      )
-    }
-  }
-  if (el.component) {
-    genComponentModel(el, value, modifiers)
-    // component v-model doesn't need extra runtime
-    return false
-  } else if (tag === 'select') {
-    genSelect(el, value, modifiers)
-  } else if (tag === 'input' && type === 'checkbox') {
-    genCheckboxModel(el, value, modifiers)
-  } else if (tag === 'input' && type === 'radio') {
-    genRadioModel(el, value, modifiers)
-  } else if (tag === 'input' || tag === 'textarea') {
-    genDefaultModel(el, value, modifiers)
-  } else {
-    genComponentModel(el, value, modifiers)
-    // component v-model doesn't need extra runtime
-    return false
-  }
-  // ensure runtime directive metadata
-  return true
-}
-function genCheckboxModel(el, value, modifiers) {
-  var number = modifiers && modifiers.number
-  var valueBinding = getBindingAttr(el, 'value') || 'null'
-  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true'
-  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false'
-  addProp(
-    el,
-    'checked',
-    'Array.isArray('.concat(value, ')') +
-      '?_i('.concat(value, ',').concat(valueBinding, ')>-1') +
-      (trueValueBinding === 'true'
-        ? ':('.concat(value, ')')
-        : ':_q('.concat(value, ',').concat(trueValueBinding, ')'))
-  )
-  addHandler(
-    el,
-    'change',
-    'var $$a='.concat(value, ',') +
-      '$$el=$event.target,' +
-      '$$c=$$el.checked?('
-        .concat(trueValueBinding, '):(')
-        .concat(falseValueBinding, ');') +
-      'if(Array.isArray($$a)){' +
-      'var $$v='.concat(
-        number ? '_n(' + valueBinding + ')' : valueBinding,
-        ','
-      ) +
-      '$$i=_i($$a,$$v);' +
-      'if($$el.checked){$$i<0&&('.concat(
-        genAssignmentCode(value, '$$a.concat([$$v])'),
-        ')}'
-      ) +
-      'else{$$i>-1&&('.concat(
-        genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))'),
-        ')}'
-      ) +
-      '}else{'.concat(genAssignmentCode(value, '$$c'), '}'),
-    null,
-    true
-  )
-}
-function genRadioModel(el, value, modifiers) {
-  var number = modifiers && modifiers.number
-  var valueBinding = getBindingAttr(el, 'value') || 'null'
-  valueBinding = number ? '_n('.concat(valueBinding, ')') : valueBinding
-  addProp(el, 'checked', '_q('.concat(value, ',').concat(valueBinding, ')'))
-  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true)
-}
-function genSelect(el, value, modifiers) {
-  var number = modifiers && modifiers.number
-  var selectedVal =
-    'Array.prototype.filter' +
-    '.call($event.target.options,function(o){return o.selected})' +
-    '.map(function(o){var val = "_value" in o ? o._value : o.value;' +
-    'return '.concat(number ? '_n(val)' : 'val', '})')
-  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]'
-  var code = 'var $$selectedVal = '.concat(selectedVal, ';')
-  code = ''.concat(code, ' ').concat(genAssignmentCode(value, assignment))
-  addHandler(el, 'change', code, null, true)
-}
-function genDefaultModel(el, value, modifiers) {
-  var type = el.attrsMap.type
-  // warn if v-bind:value conflicts with v-model
-  // except for inputs with v-bind:type
-  if (process.env.NODE_ENV !== 'production') {
-    var value_1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value']
-    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type']
-    if (value_1 && !typeBinding) {
-      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value'
-      warn(
-        ''
-          .concat(binding, '="')
-          .concat(value_1, '" conflicts with v-model on the same element ') +
-          'because the latter already expands to a value binding internally',
-        el.rawAttrsMap[binding]
-      )
-    }
-  }
-  var _a = modifiers || {},
-    lazy = _a.lazy,
-    number = _a.number,
-    trim = _a.trim
-  var needCompositionGuard = !lazy && type !== 'range'
-  var event = lazy ? 'change' : type === 'range' ? RANGE_TOKEN : 'input'
-  var valueExpression = '$event.target.value'
-  if (trim) {
-    valueExpression = '$event.target.value.trim()'
-  }
-  if (number) {
-    valueExpression = '_n('.concat(valueExpression, ')')
-  }
-  var code = genAssignmentCode(value, valueExpression)
-  if (needCompositionGuard) {
-    code = 'if($event.target.composing)return;'.concat(code)
-  }
-  addProp(el, 'value', '('.concat(value, ')'))
-  addHandler(el, event, code, null, true)
-  if (trim || number) {
-    addHandler(el, 'blur', '$forceUpdate()')
-  }
-}
-
-function text(el, dir) {
-  if (dir.value) {
-    addProp(el, 'textContent', '_s('.concat(dir.value, ')'), dir)
-  }
-}
-
-function html(el, dir) {
-  if (dir.value) {
-    addProp(el, 'innerHTML', '_s('.concat(dir.value, ')'), dir)
-  }
-}
-
-var directives = {
-  model: model,
-  text: text,
-  html: html
-}
-
-var baseOptions = {
-  expectHTML: true,
-  modules: modules,
-  directives: directives,
-  isPreTag: isPreTag,
-  isUnaryTag: isUnaryTag,
-  mustUseProp: mustUseProp,
-  canBeLeftOpenTag: canBeLeftOpenTag,
-  isReservedTag: isReservedTag,
-  getTagNamespace: getTagNamespace,
-  staticKeys: genStaticKeys$1(modules)
-}
-
-var isStaticKey
-var isPlatformReservedTag$1
-var genStaticKeysCached = cached(genStaticKeys)
-/**
- * Goal of the optimizer: walk the generated template AST tree
- * and detect sub-trees that are purely static, i.e. parts of
- * the DOM that never needs to change.
- *
- * Once we detect these sub-trees, we can:
- *
- * 1. Hoist them into constants, so that we no longer need to
- *    create fresh nodes for them on each re-render;
- * 2. Completely skip them in the patching process.
- */
-function optimize$1(root, options) {
-  if (!root) return
-  isStaticKey = genStaticKeysCached(options.staticKeys || '')
-  isPlatformReservedTag$1 = options.isReservedTag || no
-  // first pass: mark all non-static nodes.
-  markStatic(root)
-  // second pass: mark static roots.
-  markStaticRoots(root, false)
-}
-function genStaticKeys(keys) {
-  return makeMap(
-    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +
-      (keys ? ',' + keys : '')
-  )
-}
-function markStatic(node) {
-  node.static = isStatic(node)
-  if (node.type === 1) {
-    // do not make component slot content static. this avoids
-    // 1. components not able to mutate slot nodes
-    // 2. static slot content fails for hot-reloading
-    if (
-      !isPlatformReservedTag$1(node.tag) &&
-      node.tag !== 'slot' &&
-      node.attrsMap['inline-template'] == null
-    ) {
-      return
-    }
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i]
-      markStatic(child)
-      if (!child.static) {
-        node.static = false
-      }
-    }
-    if (node.ifConditions) {
-      for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-        var block = node.ifConditions[i].block
-        markStatic(block)
-        if (!block.static) {
-          node.static = false
-        }
-      }
-    }
-  }
-}
-function markStaticRoots(node, isInFor) {
-  if (node.type === 1) {
-    if (node.static || node.once) {
-      node.staticInFor = isInFor
-    }
-    // For a node to qualify as a static root, it should have children that
-    // are not just static text. Otherwise the cost of hoisting out will
-    // outweigh the benefits and it's better off to just always render it fresh.
-    if (
-      node.static &&
-      node.children.length &&
-      !(node.children.length === 1 && node.children[0].type === 3)
-    ) {
-      node.staticRoot = true
-      return
-    } else {
-      node.staticRoot = false
-    }
-    if (node.children) {
-      for (var i = 0, l = node.children.length; i < l; i++) {
-        markStaticRoots(node.children[i], isInFor || !!node.for)
-      }
-    }
-    if (node.ifConditions) {
-      for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-        markStaticRoots(node.ifConditions[i].block, isInFor)
-      }
-    }
-  }
-}
-function isStatic(node) {
-  if (node.type === 2) {
-    // expression
-    return false
-  }
-  if (node.type === 3) {
-    // text
-    return true
-  }
-  return !!(
-    node.pre ||
-    (!node.hasBindings && // no dynamic bindings
-      !node.if &&
-      !node.for && // not v-if or v-for or v-else
-      !isBuiltInTag(node.tag) && // not a built-in
-      isPlatformReservedTag$1(node.tag) && // not a component
-      !isDirectChildOfTemplateFor(node) &&
-      Object.keys(node).every(isStaticKey))
-  )
-}
-function isDirectChildOfTemplateFor(node) {
-  while (node.parent) {
-    node = node.parent
-    if (node.tag !== 'template') {
-      return false
-    }
-    if (node.for) {
-      return true
-    }
-  }
-  return false
-}
-
-var fnExpRE = /^([\w$_]+|\([^)]*?\))\s*=>|^function(?:\s+[\w$]+)?\s*\(/
-var fnInvokeRE = /\([^)]*?\);*$/
-var simplePathRE =
-  /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\['[^']*?']|\["[^"]*?"]|\[\d+]|\[[A-Za-z_$][\w$]*])*$/
-// KeyboardEvent.keyCode aliases
-var keyCodes = {
-  esc: 27,
-  tab: 9,
-  enter: 13,
-  space: 32,
-  up: 38,
-  left: 37,
-  right: 39,
-  down: 40,
-  delete: [8, 46]
-}
-// KeyboardEvent.key aliases
-var keyNames = {
-  // #7880: IE11 and Edge use `Esc` for Escape key name.
-  esc: ['Esc', 'Escape'],
-  tab: 'Tab',
-  enter: 'Enter',
-  // #9112: IE11 uses `Spacebar` for Space key name.
-  space: [' ', 'Spacebar'],
-  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.
-  up: ['Up', 'ArrowUp'],
-  left: ['Left', 'ArrowLeft'],
-  right: ['Right', 'ArrowRight'],
-  down: ['Down', 'ArrowDown'],
-  // #9112: IE11 uses `Del` for Delete key name.
-  delete: ['Backspace', 'Delete', 'Del']
-}
-// #4868: modifiers that prevent the execution of the listener
-// need to explicitly return null so that we can determine whether to remove
-// the listener for .once
-var genGuard = function (condition) {
-  return 'if('.concat(condition, ')return null;')
-}
-var modifierCode = {
-  stop: '$event.stopPropagation();',
-  prevent: '$event.preventDefault();',
-  self: genGuard('$event.target !== $event.currentTarget'),
-  ctrl: genGuard('!$event.ctrlKey'),
-  shift: genGuard('!$event.shiftKey'),
-  alt: genGuard('!$event.altKey'),
-  meta: genGuard('!$event.metaKey'),
-  left: genGuard("'button' in $event && $event.button !== 0"),
-  middle: genGuard("'button' in $event && $event.button !== 1"),
-  right: genGuard("'button' in $event && $event.button !== 2")
-}
-function genHandlers(events, isNative) {
-  var prefix = isNative ? 'nativeOn:' : 'on:'
-  var staticHandlers = ''
-  var dynamicHandlers = ''
-  for (var name_1 in events) {
-    var handlerCode = genHandler(events[name_1])
-    //@ts-expect-error
-    if (events[name_1] && events[name_1].dynamic) {
-      dynamicHandlers += ''.concat(name_1, ',').concat(handlerCode, ',')
-    } else {
-      staticHandlers += '"'.concat(name_1, '":').concat(handlerCode, ',')
-    }
-  }
-  staticHandlers = '{'.concat(staticHandlers.slice(0, -1), '}')
-  if (dynamicHandlers) {
-    return (
-      prefix +
-      '_d('
-        .concat(staticHandlers, ',[')
-        .concat(dynamicHandlers.slice(0, -1), '])')
-    )
-  } else {
-    return prefix + staticHandlers
-  }
-}
-function genHandler(handler) {
-  if (!handler) {
-    return 'function(){}'
-  }
-  if (Array.isArray(handler)) {
-    return '['.concat(
-      handler
-        .map(function (handler) {
-          return genHandler(handler)
-        })
-        .join(','),
-      ']'
-    )
-  }
-  var isMethodPath = simplePathRE.test(handler.value)
-  var isFunctionExpression = fnExpRE.test(handler.value)
-  var isFunctionInvocation = simplePathRE.test(
-    handler.value.replace(fnInvokeRE, '')
-  )
-  if (!handler.modifiers) {
-    if (isMethodPath || isFunctionExpression) {
-      return handler.value
-    }
-    return 'function($event){'.concat(
-      isFunctionInvocation ? 'return '.concat(handler.value) : handler.value,
-      '}'
-    ) // inline statement
-  } else {
-    var code = ''
-    var genModifierCode = ''
-    var keys = []
-    var _loop_1 = function (key) {
-      if (modifierCode[key]) {
-        genModifierCode += modifierCode[key]
-        // left/right
-        if (keyCodes[key]) {
-          keys.push(key)
-        }
-      } else if (key === 'exact') {
-        var modifiers_1 = handler.modifiers
-        genModifierCode += genGuard(
-          ['ctrl', 'shift', 'alt', 'meta']
-            .filter(function (keyModifier) {
-              return !modifiers_1[keyModifier]
-            })
-            .map(function (keyModifier) {
-              return '$event.'.concat(keyModifier, 'Key')
-            })
-            .join('||')
-        )
-      } else {
-        keys.push(key)
-      }
-    }
-    for (var key in handler.modifiers) {
-      _loop_1(key)
-    }
-    if (keys.length) {
-      code += genKeyFilter(keys)
-    }
-    // Make sure modifiers like prevent and stop get executed after key filtering
-    if (genModifierCode) {
-      code += genModifierCode
-    }
-    var handlerCode = isMethodPath
-      ? 'return '.concat(handler.value, '.apply(null, arguments)')
-      : isFunctionExpression
-      ? 'return ('.concat(handler.value, ').apply(null, arguments)')
-      : isFunctionInvocation
-      ? 'return '.concat(handler.value)
-      : handler.value
-    return 'function($event){'.concat(code).concat(handlerCode, '}')
-  }
-}
-function genKeyFilter(keys) {
-  return (
-    // make sure the key filters only apply to KeyboardEvents
-    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake
-    // key events that do not have keyCode property...
-    "if(!$event.type.indexOf('key')&&" +
-    ''.concat(keys.map(genFilterCode).join('&&'), ')return null;')
-  )
-}
-function genFilterCode(key) {
-  var keyVal = parseInt(key, 10)
-  if (keyVal) {
-    return '$event.keyCode!=='.concat(keyVal)
-  }
-  var keyCode = keyCodes[key]
-  var keyName = keyNames[key]
-  return (
-    '_k($event.keyCode,' +
-    ''.concat(JSON.stringify(key), ',') +
-    ''.concat(JSON.stringify(keyCode), ',') +
-    '$event.key,' +
-    ''.concat(JSON.stringify(keyName)) +
-    ')'
-  )
-}
-
-function on(el, dir) {
-  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {
-    warn$2('v-on without argument does not support modifiers.')
-  }
-  el.wrapListeners = function (code) {
-    return '_g('.concat(code, ',').concat(dir.value, ')')
-  }
-}
-
-function bind(el, dir) {
-  el.wrapData = function (code) {
-    return '_b('
-      .concat(code, ",'")
-      .concat(el.tag, "',")
-      .concat(dir.value, ',')
-      .concat(dir.modifiers && dir.modifiers.prop ? 'true' : 'false')
-      .concat(dir.modifiers && dir.modifiers.sync ? ',true' : '', ')')
-  }
-}
-
-var baseDirectives = {
-  on: on,
-  bind: bind,
-  cloak: noop
-}
-
-var CodegenState = /** @class */ (function () {
-  function CodegenState(options) {
-    this.options = options
-    this.warn = options.warn || baseWarn
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
-    this.transforms = pluckModuleFunction(options.modules, 'transformCode')
-    this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
-    this.directives = extend(extend({}, baseDirectives), options.directives)
-    var isReservedTag = options.isReservedTag || no
-    this.maybeComponent = function (el) {
-      return !!el.component || !isReservedTag(el.tag)
-    }
-    this.onceId = 0
-    this.staticRenderFns = []
-    this.pre = false
-  }
-  return CodegenState
-})()
-function generate$1(ast, options) {
-  var state = new CodegenState(options)
-  // fix #11483, Root level <script> tags should not be rendered.
-  var code = ast
-    ? ast.tag === 'script'
-      ? 'null'
-      : genElement(ast, state)
-    : '_c("div")'
-  return {
-    render: 'with(this){return '.concat(code, '}'),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-function genElement(el, state) {
-  if (el.parent) {
-    el.pre = el.pre || el.parent.pre
-  }
-  if (el.staticRoot && !el.staticProcessed) {
-    return genStatic(el, state)
-  } else if (el.once && !el.onceProcessed) {
-    return genOnce(el, state)
-  } else if (el.for && !el.forProcessed) {
-    return genFor(el, state)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {
-    return genChildren(el, state) || 'void 0'
-  } else if (el.tag === 'slot') {
-    return genSlot(el, state)
-  } else {
-    // component or element
-    var code = void 0
-    if (el.component) {
-      code = genComponent(el.component, el, state)
-    } else {
-      var data = void 0
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
-        data = genData(el, state)
-      }
-      var children = el.inlineTemplate ? null : genChildren(el, state, true)
-      code = "_c('"
-        .concat(el.tag, "'")
-        .concat(
-          data ? ','.concat(data) : '' // data
-        )
-        .concat(
-          children ? ','.concat(children) : '', // children
-          ')'
-        )
-    }
-    // module transforms
-    for (var i = 0; i < state.transforms.length; i++) {
-      code = state.transforms[i](el, code)
-    }
-    return code
-  }
-}
-// hoist static sub-trees out
-function genStatic(el, state) {
-  el.staticProcessed = true
-  // Some elements (templates) need to behave differently inside of a v-pre
-  // node.  All pre nodes are static roots, so we can use this as a location to
-  // wrap a state change and reset it upon exiting the pre node.
-  var originalPreState = state.pre
-  if (el.pre) {
-    state.pre = el.pre
-  }
-  state.staticRenderFns.push(
-    'with(this){return '.concat(genElement(el, state), '}')
-  )
-  state.pre = originalPreState
-  return '_m('
-    .concat(state.staticRenderFns.length - 1)
-    .concat(el.staticInFor ? ',true' : '', ')')
-}
-// v-once
-function genOnce(el, state) {
-  el.onceProcessed = true
-  if (el.if && !el.ifProcessed) {
-    return genIf(el, state)
-  } else if (el.staticInFor) {
-    var key = ''
-    var parent_1 = el.parent
-    while (parent_1) {
-      if (parent_1.for) {
-        key = parent_1.key
-        break
-      }
-      parent_1 = parent_1.parent
-    }
-    if (!key) {
-      process.env.NODE_ENV !== 'production' &&
-        state.warn(
-          'v-once can only be used inside v-for that is keyed. ',
-          el.rawAttrsMap['v-once']
-        )
-      return genElement(el, state)
-    }
-    return '_o('
-      .concat(genElement(el, state), ',')
-      .concat(state.onceId++, ',')
-      .concat(key, ')')
-  } else {
-    return genStatic(el, state)
-  }
-}
-function genIf(el, state, altGen, altEmpty) {
-  el.ifProcessed = true // avoid recursion
-  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)
-}
-function genIfConditions(conditions, state, altGen, altEmpty) {
-  if (!conditions.length) {
-    return altEmpty || '_e()'
-  }
-  var condition = conditions.shift()
-  if (condition.exp) {
-    return '('
-      .concat(condition.exp, ')?')
-      .concat(genTernaryExp(condition.block), ':')
-      .concat(genIfConditions(conditions, state, altGen, altEmpty))
-  } else {
-    return ''.concat(genTernaryExp(condition.block))
-  }
-  // v-if with v-once should generate code like (a)?_m(0):_m(1)
-  function genTernaryExp(el) {
-    return altGen
-      ? altGen(el, state)
-      : el.once
-      ? genOnce(el, state)
-      : genElement(el, state)
-  }
-}
-function genFor(el, state, altGen, altHelper) {
-  var exp = el.for
-  var alias = el.alias
-  var iterator1 = el.iterator1 ? ','.concat(el.iterator1) : ''
-  var iterator2 = el.iterator2 ? ','.concat(el.iterator2) : ''
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    state.maybeComponent(el) &&
-    el.tag !== 'slot' &&
-    el.tag !== 'template' &&
-    !el.key
-  ) {
-    state.warn(
-      '<'
-        .concat(el.tag, ' v-for="')
-        .concat(alias, ' in ')
-        .concat(exp, '">: component lists rendered with ') +
-        'v-for should have explicit keys. ' +
-        'See https://vuejs.org/guide/list.html#key for more info.',
-      el.rawAttrsMap['v-for'],
-      true /* tip */
-    )
-  }
-  el.forProcessed = true // avoid recursion
-  return (
-    ''.concat(altHelper || '_l', '((').concat(exp, '),') +
-    'function('.concat(alias).concat(iterator1).concat(iterator2, '){') +
-    'return '.concat((altGen || genElement)(el, state)) +
-    '})'
-  )
-}
-function genData(el, state) {
-  var data = '{'
-  // directives first.
-  // directives may mutate the el's other properties before they are generated.
-  var dirs = genDirectives(el, state)
-  if (dirs) data += dirs + ','
-  // key
-  if (el.key) {
-    data += 'key:'.concat(el.key, ',')
-  }
-  // ref
-  if (el.ref) {
-    data += 'ref:'.concat(el.ref, ',')
-  }
-  if (el.refInFor) {
-    data += 'refInFor:true,'
-  }
-  // pre
-  if (el.pre) {
-    data += 'pre:true,'
-  }
-  // record original tag name for components using "is" attribute
-  if (el.component) {
-    data += 'tag:"'.concat(el.tag, '",')
-  }
-  // module data generation functions
-  for (var i = 0; i < state.dataGenFns.length; i++) {
-    data += state.dataGenFns[i](el)
-  }
-  // attributes
-  if (el.attrs) {
-    data += 'attrs:'.concat(genProps(el.attrs), ',')
-  }
-  // DOM props
-  if (el.props) {
-    data += 'domProps:'.concat(genProps(el.props), ',')
-  }
-  // event handlers
-  if (el.events) {
-    data += ''.concat(genHandlers(el.events, false), ',')
-  }
-  if (el.nativeEvents) {
-    data += ''.concat(genHandlers(el.nativeEvents, true), ',')
-  }
-  // slot target
-  // only for non-scoped slots
-  if (el.slotTarget && !el.slotScope) {
-    data += 'slot:'.concat(el.slotTarget, ',')
-  }
-  // scoped slots
-  if (el.scopedSlots) {
-    data += ''.concat(genScopedSlots(el, el.scopedSlots, state), ',')
-  }
-  // component v-model
-  if (el.model) {
-    data += 'model:{value:'
-      .concat(el.model.value, ',callback:')
-      .concat(el.model.callback, ',expression:')
-      .concat(el.model.expression, '},')
-  }
-  // inline-template
-  if (el.inlineTemplate) {
-    var inlineTemplate = genInlineTemplate(el, state)
-    if (inlineTemplate) {
-      data += ''.concat(inlineTemplate, ',')
-    }
-  }
-  data = data.replace(/,$/, '') + '}'
-  // v-bind dynamic argument wrap
-  // v-bind with dynamic arguments must be applied using the same v-bind object
-  // merge helper so that class/style/mustUseProp attrs are handled correctly.
-  if (el.dynamicAttrs) {
-    data = '_b('
-      .concat(data, ',"')
-      .concat(el.tag, '",')
-      .concat(genProps(el.dynamicAttrs), ')')
-  }
-  // v-bind data wrap
-  if (el.wrapData) {
-    data = el.wrapData(data)
-  }
-  // v-on data wrap
-  if (el.wrapListeners) {
-    data = el.wrapListeners(data)
-  }
-  return data
-}
-function genDirectives(el, state) {
-  var dirs = el.directives
-  if (!dirs) return
-  var res = 'directives:['
-  var hasRuntime = false
-  var i, l, dir, needRuntime
-  for (i = 0, l = dirs.length; i < l; i++) {
-    dir = dirs[i]
-    needRuntime = true
-    var gen = state.directives[dir.name]
-    if (gen) {
-      // compile-time directive that manipulates AST.
-      // returns true if it also needs a runtime counterpart.
-      needRuntime = !!gen(el, dir, state.warn)
-    }
-    if (needRuntime) {
-      hasRuntime = true
-      res += '{name:"'
-        .concat(dir.name, '",rawName:"')
-        .concat(dir.rawName, '"')
-        .concat(
-          dir.value
-            ? ',value:('
-                .concat(dir.value, '),expression:')
-                .concat(JSON.stringify(dir.value))
-            : ''
-        )
-        .concat(
-          dir.arg
-            ? ',arg:'.concat(
-                dir.isDynamicArg ? dir.arg : '"'.concat(dir.arg, '"')
-              )
-            : ''
-        )
-        .concat(
-          dir.modifiers
-            ? ',modifiers:'.concat(JSON.stringify(dir.modifiers))
-            : '',
-          '},'
-        )
-    }
-  }
-  if (hasRuntime) {
-    return res.slice(0, -1) + ']'
-  }
-}
-function genInlineTemplate(el, state) {
-  var ast = el.children[0]
-  if (
-    process.env.NODE_ENV !== 'production' &&
-    (el.children.length !== 1 || ast.type !== 1)
-  ) {
-    state.warn(
-      'Inline-template components must have exactly one child element.',
-      { start: el.start }
-    )
-  }
-  if (ast && ast.type === 1) {
-    var inlineRenderFns = generate$1(ast, state.options)
-    return 'inlineTemplate:{render:function(){'
-      .concat(inlineRenderFns.render, '},staticRenderFns:[')
-      .concat(
-        inlineRenderFns.staticRenderFns
-          .map(function (code) {
-            return 'function(){'.concat(code, '}')
-          })
-          .join(','),
-        ']}'
-      )
-  }
-}
-function genScopedSlots(el, slots, state) {
-  // by default scoped slots are considered "stable", this allows child
-  // components with only scoped slots to skip forced updates from parent.
-  // but in some cases we have to bail-out of this optimization
-  // for example if the slot contains dynamic names, has v-if or v-for on them...
-  var needsForceUpdate =
-    el.for ||
-    Object.keys(slots).some(function (key) {
-      var slot = slots[key]
-      return (
-        slot.slotTargetDynamic || slot.if || slot.for || containsSlotChild(slot) // is passing down slot from parent which may be dynamic
-      )
-    })
-  // #9534: if a component with scoped slots is inside a conditional branch,
-  // it's possible for the same component to be reused but with different
-  // compiled slot content. To avoid that, we generate a unique key based on
-  // the generated code of all the slot contents.
-  var needsKey = !!el.if
-  // OR when it is inside another scoped slot or v-for (the reactivity may be
-  // disconnected due to the intermediate scope variable)
-  // #9438, #9506
-  // TODO: this can be further optimized by properly analyzing in-scope bindings
-  // and skip force updating ones that do not actually use scope variables.
-  if (!needsForceUpdate) {
-    var parent_2 = el.parent
-    while (parent_2) {
-      if (
-        (parent_2.slotScope && parent_2.slotScope !== emptySlotScopeToken) ||
-        parent_2.for
-      ) {
-        needsForceUpdate = true
-        break
-      }
-      if (parent_2.if) {
-        needsKey = true
-      }
-      parent_2 = parent_2.parent
-    }
-  }
-  var generatedSlots = Object.keys(slots)
-    .map(function (key) {
-      return genScopedSlot(slots[key], state)
-    })
-    .join(',')
-  return 'scopedSlots:_u(['
-    .concat(generatedSlots, ']')
-    .concat(needsForceUpdate ? ',null,true' : '')
-    .concat(
-      !needsForceUpdate && needsKey
-        ? ',null,false,'.concat(hash(generatedSlots))
-        : '',
-      ')'
-    )
-}
-function hash(str) {
-  var hash = 5381
-  var i = str.length
-  while (i) {
-    hash = (hash * 33) ^ str.charCodeAt(--i)
-  }
-  return hash >>> 0
-}
-function containsSlotChild(el) {
-  if (el.type === 1) {
-    if (el.tag === 'slot') {
-      return true
-    }
-    return el.children.some(containsSlotChild)
-  }
-  return false
-}
-function genScopedSlot(el, state) {
-  var isLegacySyntax = el.attrsMap['slot-scope']
-  if (el.if && !el.ifProcessed && !isLegacySyntax) {
-    return genIf(el, state, genScopedSlot, 'null')
-  }
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genScopedSlot)
-  }
-  var slotScope =
-    el.slotScope === emptySlotScopeToken ? '' : String(el.slotScope)
-  var fn =
-    'function('.concat(slotScope, '){') +
-    'return '.concat(
-      el.tag === 'template'
-        ? el.if && isLegacySyntax
-          ? '('
-              .concat(el.if, ')?')
-              .concat(genChildren(el, state) || 'undefined', ':undefined')
-          : genChildren(el, state) || 'undefined'
-        : genElement(el, state),
-      '}'
-    )
-  // reverse proxy v-slot without scope on this.$slots
-  var reverseProxy = slotScope ? '' : ',proxy:true'
-  return '{key:'
-    .concat(el.slotTarget || '"default"', ',fn:')
-    .concat(fn)
-    .concat(reverseProxy, '}')
-}
-function genChildren(el, state, checkSkip, altGenElement, altGenNode) {
-  var children = el.children
-  if (children.length) {
-    var el_1 = children[0]
-    // optimize single v-for
-    if (
-      children.length === 1 &&
-      el_1.for &&
-      el_1.tag !== 'template' &&
-      el_1.tag !== 'slot'
-    ) {
-      var normalizationType_1 = checkSkip
-        ? state.maybeComponent(el_1)
-          ? ',1'
-          : ',0'
-        : ''
-      return ''
-        .concat((altGenElement || genElement)(el_1, state))
-        .concat(normalizationType_1)
-    }
-    var normalizationType = checkSkip
-      ? getNormalizationType(children, state.maybeComponent)
-      : 0
-    var gen_1 = altGenNode || genNode
-    return '['
-      .concat(
-        children
-          .map(function (c) {
-            return gen_1(c, state)
-          })
-          .join(','),
-        ']'
-      )
-      .concat(normalizationType ? ','.concat(normalizationType) : '')
-  }
-}
-// determine the normalization needed for the children array.
-// 0: no normalization needed
-// 1: simple normalization needed (possible 1-level deep nested array)
-// 2: full normalization needed
-function getNormalizationType(children, maybeComponent) {
-  var res = 0
-  for (var i = 0; i < children.length; i++) {
-    var el = children[i]
-    if (el.type !== 1) {
-      continue
-    }
-    if (
-      needsNormalization(el) ||
-      (el.ifConditions &&
-        el.ifConditions.some(function (c) {
-          return needsNormalization(c.block)
-        }))
-    ) {
-      res = 2
-      break
-    }
-    if (
-      maybeComponent(el) ||
-      (el.ifConditions &&
-        el.ifConditions.some(function (c) {
-          return maybeComponent(c.block)
-        }))
-    ) {
-      res = 1
-    }
-  }
-  return res
-}
-function needsNormalization(el) {
-  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
-}
-function genNode(node, state) {
-  if (node.type === 1) {
-    return genElement(node, state)
-  } else if (node.type === 3 && node.isComment) {
-    return genComment(node)
-  } else {
-    return genText(node)
-  }
-}
-function genText(text) {
-  return '_v('.concat(
-    text.type === 2
-      ? text.expression // no need for () because already wrapped in _s()
-      : transformSpecialNewlines(JSON.stringify(text.text)),
-    ')'
-  )
-}
-function genComment(comment) {
-  return '_e('.concat(JSON.stringify(comment.text), ')')
-}
-function genSlot(el, state) {
-  var slotName = el.slotName || '"default"'
-  var children = genChildren(el, state)
-  var res = '_t('
-    .concat(slotName)
-    .concat(children ? ',function(){return '.concat(children, '}') : '')
-  var attrs =
-    el.attrs || el.dynamicAttrs
-      ? genProps(
-          (el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) {
-            return {
-              // slot props are camelized
-              name: camelize(attr.name),
-              value: attr.value,
-              dynamic: attr.dynamic
-            }
-          })
-        )
-      : null
-  var bind = el.attrsMap['v-bind']
-  if ((attrs || bind) && !children) {
-    res += ',null'
-  }
-  if (attrs) {
-    res += ','.concat(attrs)
-  }
-  if (bind) {
-    res += ''.concat(attrs ? '' : ',null', ',').concat(bind)
-  }
-  return res + ')'
-}
-// componentName is el.component, take it as argument to shun flow's pessimistic refinement
-function genComponent(componentName, el, state) {
-  var children = el.inlineTemplate ? null : genChildren(el, state, true)
-  return '_c('
-    .concat(componentName, ',')
-    .concat(genData(el, state))
-    .concat(children ? ','.concat(children) : '', ')')
-}
-function genProps(props) {
-  var staticProps = ''
-  var dynamicProps = ''
-  for (var i = 0; i < props.length; i++) {
-    var prop = props[i]
-    var value = transformSpecialNewlines(prop.value)
-    if (prop.dynamic) {
-      dynamicProps += ''.concat(prop.name, ',').concat(value, ',')
-    } else {
-      staticProps += '"'.concat(prop.name, '":').concat(value, ',')
-    }
-  }
-  staticProps = '{'.concat(staticProps.slice(0, -1), '}')
-  if (dynamicProps) {
-    return '_d('
-      .concat(staticProps, ',[')
-      .concat(dynamicProps.slice(0, -1), '])')
-  } else {
-    return staticProps
-  }
-}
-// #3895, #4268
-function transformSpecialNewlines(text) {
-  return text.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029')
-}
-
-// these keywords should not appear inside expressions, but operators like
-// typeof, instanceof and in are allowed
-var prohibitedKeywordRE = new RegExp(
-  '\\b' +
-    (
-      'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +
-      'super,throw,while,yield,delete,export,import,return,switch,default,' +
-      'extends,finally,continue,debugger,function,arguments'
-    )
-      .split(',')
-      .join('\\b|\\b') +
-    '\\b'
-)
-// these unary operators should not be used as property/method names
-var unaryOperatorsRE = new RegExp(
-  '\\b' +
-    'delete,typeof,void'.split(',').join('\\s*\\([^\\)]*\\)|\\b') +
-    '\\s*\\([^\\)]*\\)'
-)
-// strip strings in expressions
-var stripStringRE =
-  /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g
-// detect problematic expressions in a template
-function detectErrors(ast, warn) {
-  if (ast) {
-    checkNode(ast, warn)
-  }
-}
-function checkNode(node, warn) {
-  if (node.type === 1) {
-    for (var name_1 in node.attrsMap) {
-      if (dirRE.test(name_1)) {
-        var value = node.attrsMap[name_1]
-        if (value) {
-          var range = node.rawAttrsMap[name_1]
-          if (name_1 === 'v-for') {
-            checkFor(node, 'v-for="'.concat(value, '"'), warn, range)
-          } else if (name_1 === 'v-slot' || name_1[0] === '#') {
-            checkFunctionParameterExpression(
-              value,
-              ''.concat(name_1, '="').concat(value, '"'),
-              warn,
-              range
-            )
-          } else if (onRE.test(name_1)) {
-            checkEvent(
-              value,
-              ''.concat(name_1, '="').concat(value, '"'),
-              warn,
-              range
-            )
-          } else {
-            checkExpression(
-              value,
-              ''.concat(name_1, '="').concat(value, '"'),
-              warn,
-              range
-            )
-          }
-        }
-      }
-    }
-    if (node.children) {
-      for (var i = 0; i < node.children.length; i++) {
-        checkNode(node.children[i], warn)
-      }
-    }
-  } else if (node.type === 2) {
-    checkExpression(node.expression, node.text, warn, node)
-  }
-}
-function checkEvent(exp, text, warn, range) {
-  var stripped = exp.replace(stripStringRE, '')
-  var keywordMatch = stripped.match(unaryOperatorsRE)
-  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {
-    warn(
-      'avoid using JavaScript unary operator as property name: ' +
-        '"'.concat(keywordMatch[0], '" in expression ').concat(text.trim()),
-      range
-    )
-  }
-  checkExpression(exp, text, warn, range)
-}
-function checkFor(node, text, warn, range) {
-  checkExpression(node.for || '', text, warn, range)
-  checkIdentifier(node.alias, 'v-for alias', text, warn, range)
-  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range)
-  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range)
-}
-function checkIdentifier(ident, type, text, warn, range) {
-  if (typeof ident === 'string') {
-    try {
-      new Function('var '.concat(ident, '=_'))
-    } catch (e) {
-      warn(
-        'invalid '
-          .concat(type, ' "')
-          .concat(ident, '" in expression: ')
-          .concat(text.trim()),
-        range
-      )
-    }
-  }
-}
-function checkExpression(exp, text, warn, range) {
-  try {
-    new Function('return '.concat(exp))
-  } catch (e) {
-    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE)
-    if (keywordMatch) {
-      warn(
-        'avoid using JavaScript keyword as property name: ' +
-          '"'
-            .concat(keywordMatch[0], '"\n  Raw expression: ')
-            .concat(text.trim()),
-        range
-      )
-    } else {
-      warn(
-        'invalid expression: '.concat(e.message, ' in\n\n') +
-          '    '.concat(exp, '\n\n') +
-          '  Raw expression: '.concat(text.trim(), '\n'),
-        range
-      )
-    }
-  }
-}
-function checkFunctionParameterExpression(exp, text, warn, range) {
-  try {
-    new Function(exp, '')
-  } catch (e) {
-    warn(
-      'invalid function parameter expression: '.concat(e.message, ' in\n\n') +
-        '    '.concat(exp, '\n\n') +
-        '  Raw expression: '.concat(text.trim(), '\n'),
-      range
-    )
-  }
-}
-
-var range = 2
-function generateCodeFrame(source, start, end) {
-  if (start === void 0) {
-    start = 0
-  }
-  if (end === void 0) {
-    end = source.length
-  }
-  var lines = source.split(/\r?\n/)
-  var count = 0
-  var res = []
-  for (var i = 0; i < lines.length; i++) {
-    count += lines[i].length + 1
-    if (count >= start) {
-      for (var j = i - range; j <= i + range || end > count; j++) {
-        if (j < 0 || j >= lines.length) continue
-        res.push(
-          ''
-            .concat(j + 1)
-            .concat(repeat(' ', 3 - String(j + 1).length), '|  ')
-            .concat(lines[j])
-        )
-        var lineLength = lines[j].length
-        if (j === i) {
-          // push underline
-          var pad = start - (count - lineLength) + 1
-          var length_1 = end > count ? lineLength - pad : end - start
-          res.push('   |  ' + repeat(' ', pad) + repeat('^', length_1))
-        } else if (j > i) {
-          if (end > count) {
-            var length_2 = Math.min(end - count, lineLength)
-            res.push('   |  ' + repeat('^', length_2))
-          }
-          count += lineLength + 1
-        }
-      }
-      break
-    }
-  }
-  return res.join('\n')
-}
-function repeat(str, n) {
-  var result = ''
-  if (n > 0) {
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      // eslint-disable-line
-      if (n & 1) result += str
-      n >>>= 1
-      if (n <= 0) break
-      str += str
-    }
-  }
-  return result
-}
-
-function createFunction(code, errors) {
-  try {
-    return new Function(code)
-  } catch (err) {
-    errors.push({ err: err, code: code })
-    return noop
-  }
-}
-function createCompileToFunctionFn(compile) {
-  var cache = Object.create(null)
-  return function compileToFunctions(template, options, vm) {
-    options = extend({}, options)
-    var warn = options.warn || warn$2
-    delete options.warn
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      // detect possible CSP restriction
-      try {
-        new Function('return 1')
-      } catch (e) {
-        if (e.toString().match(/unsafe-eval|CSP/)) {
-          warn(
-            'It seems you are using the standalone build of Vue.js in an ' +
-              'environment with Content Security Policy that prohibits unsafe-eval. ' +
-              'The template compiler cannot work in this environment. Consider ' +
-              'relaxing the policy to allow unsafe-eval or pre-compiling your ' +
-              'templates into render functions.'
-          )
-        }
-      }
-    }
-    // check cache
-    var key = options.delimiters
-      ? String(options.delimiters) + template
-      : template
-    if (cache[key]) {
-      return cache[key]
-    }
-    // compile
-    var compiled = compile(template, options)
-    // check compilation errors/tips
-    if (process.env.NODE_ENV !== 'production') {
-      if (compiled.errors && compiled.errors.length) {
-        if (options.outputSourceRange) {
-          compiled.errors.forEach(function (e) {
-            warn(
-              'Error compiling template:\n\n'.concat(e.msg, '\n\n') +
-                generateCodeFrame(template, e.start, e.end),
-              vm
-            )
-          })
-        } else {
-          warn(
-            'Error compiling template:\n\n'.concat(template, '\n\n') +
-              compiled.errors
-                .map(function (e) {
-                  return '- '.concat(e)
-                })
-                .join('\n') +
-              '\n',
-            vm
-          )
-        }
-      }
-      if (compiled.tips && compiled.tips.length) {
-        if (options.outputSourceRange) {
-          compiled.tips.forEach(function (e) {
-            return tip(e.msg, vm)
-          })
-        } else {
-          compiled.tips.forEach(function (msg) {
-            return tip(msg, vm)
-          })
-        }
-      }
-    }
-    // turn code into functions
-    var res = {}
-    var fnGenErrors = []
-    res.render = createFunction(compiled.render, fnGenErrors)
-    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {
-      return createFunction(code, fnGenErrors)
-    })
-    // check function generation errors.
-    // this should only happen if there is a bug in the compiler itself.
-    // mostly for codegen development use
-    /* istanbul ignore if */
-    if (process.env.NODE_ENV !== 'production') {
-      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {
-        warn(
-          'Failed to generate render function:\n\n' +
-            fnGenErrors
-              .map(function (_a) {
-                var err = _a.err,
-                  code = _a.code
-                return ''.concat(err.toString(), ' in\n\n').concat(code, '\n')
-              })
-              .join('\n'),
-          vm
-        )
-      }
-    }
-    return (cache[key] = res)
-  }
-}
-
-function createCompilerCreator(baseCompile) {
-  return function createCompiler(baseOptions) {
-    function compile(template, options) {
-      var finalOptions = Object.create(baseOptions)
-      var errors = []
-      var tips = []
-      var warn = function (msg, range, tip) {
-        ;(tip ? tips : errors).push(msg)
-      }
-      if (options) {
-        if (
-          process.env.NODE_ENV !== 'production' &&
-          options.outputSourceRange
-        ) {
-          // $flow-disable-line
-          var leadingSpaceLength_1 = template.match(/^\s*/)[0].length
-          warn = function (msg, range, tip) {
-            var data = typeof msg === 'string' ? { msg: msg } : msg
-            if (range) {
-              if (range.start != null) {
-                data.start = range.start + leadingSpaceLength_1
-              }
-              if (range.end != null) {
-                data.end = range.end + leadingSpaceLength_1
-              }
-            }
-            ;(tip ? tips : errors).push(data)
-          }
-        }
-        // merge custom modules
-        if (options.modules) {
-          finalOptions.modules = (baseOptions.modules || []).concat(
-            options.modules
-          )
-        }
-        // merge custom directives
-        if (options.directives) {
-          finalOptions.directives = extend(
-            Object.create(baseOptions.directives || null),
-            options.directives
-          )
-        }
-        // copy other options
-        for (var key in options) {
-          if (key !== 'modules' && key !== 'directives') {
-            finalOptions[key] = options[key]
-          }
-        }
-      }
-      finalOptions.warn = warn
-      var compiled = baseCompile(template.trim(), finalOptions)
-      if (process.env.NODE_ENV !== 'production') {
-        detectErrors(compiled.ast, warn)
-      }
-      compiled.errors = errors
-      compiled.tips = tips
-      return compiled
-    }
-    return {
-      compile: compile,
-      compileToFunctions: createCompileToFunctionFn(compile)
-    }
-  }
-}
-
-// `createCompilerCreator` allows creating compilers that use alternative
-// parser/optimizer/codegen, e.g the SSR optimizing compiler.
-// Here we just export a default compiler using the default parts.
-var createCompiler$1 = createCompilerCreator(function baseCompile(
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options)
-  if (options.optimize !== false) {
-    optimize$1(ast, options)
-  }
-  var code = generate$1(ast, options)
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
-})
-
-var _a$1 = createCompiler$1(baseOptions),
-  compile$1 = _a$1.compile,
-  compileToFunctions$1 = _a$1.compileToFunctions
-
-var isAttr = makeMap(
-  'accept,accept-charset,accesskey,action,align,alt,async,autocomplete,' +
-    'autofocus,autoplay,autosave,bgcolor,border,buffered,challenge,charset,' +
-    'checked,cite,class,code,codebase,color,cols,colspan,content,' +
-    'contenteditable,contextmenu,controls,coords,data,datetime,default,' +
-    'defer,dir,dirname,disabled,download,draggable,dropzone,enctype,for,' +
-    'form,formaction,headers,height,hidden,high,href,hreflang,http-equiv,' +
-    'icon,id,ismap,itemprop,keytype,kind,label,lang,language,list,loop,low,' +
-    'manifest,max,maxlength,media,method,GET,POST,min,multiple,email,file,' +
-    'muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,' +
-    'preload,radiogroup,readonly,rel,required,reversed,rows,rowspan,sandbox,' +
-    'scope,scoped,seamless,selected,shape,size,type,text,password,sizes,span,' +
-    'spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,' +
-    'target,title,usemap,value,width,wrap'
-)
-/* istanbul ignore next */
-var isRenderableAttr = function (name) {
-  return (
-    isAttr(name) || name.indexOf('data-') === 0 || name.indexOf('aria-') === 0
-  )
-}
-var propsToAttrMap = {
-  acceptCharset: 'accept-charset',
-  className: 'class',
-  htmlFor: 'for',
-  httpEquiv: 'http-equiv'
-}
-var ESC = {
-  '<': '&lt;',
-  '>': '&gt;',
-  '"': '&quot;',
-  '&': '&amp;'
-}
-function escape(s) {
-  return s.replace(/[<>"&]/g, escapeChar)
-}
-function escapeChar(a) {
-  return ESC[a] || a
-}
-
-var plainStringRE = /^"(?:[^"\\]|\\.)*"$|^'(?:[^'\\]|\\.)*'$/
-// let the model AST transform translate v-model into appropriate
-// props bindings
-function applyModelTransform(el, state) {
-  if (el.directives) {
-    for (var i = 0; i < el.directives.length; i++) {
-      var dir = el.directives[i]
-      if (dir.name === 'model') {
-        state.directives.model(el, dir, state.warn)
-        // remove value for textarea as its converted to text
-        if (el.tag === 'textarea' && el.props) {
-          el.props = el.props.filter(function (p) {
-            return p.name !== 'value'
-          })
-        }
-        break
-      }
-    }
-  }
-}
-function genAttrSegments(attrs) {
-  return attrs.map(function (_a) {
-    var name = _a.name,
-      value = _a.value
-    return genAttrSegment(name, value)
-  })
-}
-function genDOMPropSegments(props, attrs) {
-  var segments = []
-  props.forEach(function (_a) {
-    var name = _a.name,
-      value = _a.value
-    name = propsToAttrMap[name] || name.toLowerCase()
-    if (
-      isRenderableAttr(name) &&
-      !(
-        attrs &&
-        attrs.some(function (a) {
-          return a.name === name
-        })
-      )
-    ) {
-      segments.push(genAttrSegment(name, value))
-    }
-  })
-  return segments
-}
-function genAttrSegment(name, value) {
-  if (plainStringRE.test(value)) {
-    // force double quote
-    value = value.replace(/^'|'$/g, '"')
-    // force enumerated attr to "true"
-    if (isEnumeratedAttr(name) && value !== '"false"') {
-      value = '"true"'
-    }
-    return {
-      type: RAW,
-      value: isBooleanAttr(name)
-        ? ' '.concat(name, '="').concat(name, '"')
-        : value === '""'
-        ? ' '.concat(name)
-        : ' '.concat(name, '="').concat(JSON.parse(value), '"')
-    }
-  } else {
-    return {
-      type: EXPRESSION,
-      value: '_ssrAttr('.concat(JSON.stringify(name), ',').concat(value, ')')
-    }
-  }
-}
-function genClassSegments(staticClass, classBinding) {
-  if (staticClass && !classBinding) {
-    return [
-      { type: RAW, value: ' class="'.concat(JSON.parse(staticClass), '"') }
-    ]
-  } else {
-    return [
-      {
-        type: EXPRESSION,
-        value: '_ssrClass('
-          .concat(staticClass || 'null', ',')
-          .concat(classBinding || 'null', ')')
-      }
-    ]
-  }
-}
-function genStyleSegments(
-  staticStyle,
-  parsedStaticStyle,
-  styleBinding,
-  vShowExpression
-) {
-  if (staticStyle && !styleBinding && !vShowExpression) {
-    return [{ type: RAW, value: ' style='.concat(JSON.stringify(staticStyle)) }]
-  } else {
-    return [
-      {
-        type: EXPRESSION,
-        value: '_ssrStyle('
-          .concat(parsedStaticStyle || 'null', ',')
-          .concat(styleBinding || 'null', ', ')
-          .concat(
-            vShowExpression
-              ? '{ display: ('.concat(vShowExpression, ") ? '' : 'none' }")
-              : 'null',
-            ')'
-          )
-      }
-    ]
-  }
-}
-
-/**
- * In SSR, the vdom tree is generated only once and never patched, so
- * we can optimize most element / trees into plain string render functions.
- * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
- *
- * The criteria for SSR optimizability is quite a bit looser than static tree
- * detection (which is designed for client re-render). In SSR we bail only for
- * components/slots/custom directives.
- */
-// optimizability constants
-var optimizability = {
-  FALSE: 0,
-  FULL: 1,
-  SELF: 2,
-  CHILDREN: 3,
-  PARTIAL: 4 // self un-optimizable with some un-optimizable children
-}
-var isPlatformReservedTag
-function optimize(root, options) {
-  if (!root) return
-  isPlatformReservedTag = options.isReservedTag || no
-  walk(root, true)
-}
-function walk(node, isRoot) {
-  if (isUnOptimizableTree(node)) {
-    node.ssrOptimizability = optimizability.FALSE
-    return
-  }
-  // root node or nodes with custom directives should always be a VNode
-  var selfUnoptimizable = isRoot || hasCustomDirective(node)
-  var check = function (child) {
-    if (child.ssrOptimizability !== optimizability.FULL) {
-      node.ssrOptimizability = selfUnoptimizable
-        ? optimizability.PARTIAL
-        : optimizability.SELF
-    }
-  }
-  if (selfUnoptimizable) {
-    node.ssrOptimizability = optimizability.CHILDREN
-  }
-  if (node.type === 1) {
-    for (var i = 0, l = node.children.length; i < l; i++) {
-      var child = node.children[i]
-      walk(child)
-      check(child)
-    }
-    if (node.ifConditions) {
-      for (var i = 1, l = node.ifConditions.length; i < l; i++) {
-        var block = node.ifConditions[i].block
-        walk(block, isRoot)
-        check(block)
-      }
-    }
-    if (
-      node.ssrOptimizability == null ||
-      (!isRoot && (node.attrsMap['v-html'] || node.attrsMap['v-text']))
-    ) {
-      node.ssrOptimizability = optimizability.FULL
-    } else {
-      node.children = optimizeSiblings(node)
-    }
-  } else {
-    node.ssrOptimizability = optimizability.FULL
-  }
-}
-function optimizeSiblings(el) {
-  var children = el.children
-  var optimizedChildren = []
-  var currentOptimizableGroup = []
-  var pushGroup = function () {
-    if (currentOptimizableGroup.length) {
-      optimizedChildren.push({
-        type: 1,
-        parent: el,
-        tag: 'template',
-        attrsList: [],
-        attrsMap: {},
-        rawAttrsMap: {},
-        children: currentOptimizableGroup,
-        ssrOptimizability: optimizability.FULL
-      })
-    }
-    currentOptimizableGroup = []
-  }
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i]
-    if (c.ssrOptimizability === optimizability.FULL) {
-      currentOptimizableGroup.push(c)
-    } else {
-      // wrap fully-optimizable adjacent siblings inside a template tag
-      // so that they can be optimized into a single ssrNode by codegen
-      pushGroup()
-      optimizedChildren.push(c)
-    }
-  }
-  pushGroup()
-  return optimizedChildren
-}
-function isUnOptimizableTree(node) {
-  if (node.type === 2 || node.type === 3) {
-    // text or expression
-    return false
-  }
-  return (
-    isBuiltInTag(node.tag) || // built-in (slot, component)
-    !isPlatformReservedTag(node.tag) || // custom component
-    !!node.component || // "is" component
-    isSelectWithModel(node) // <select v-model> requires runtime inspection
-  )
-}
-var isBuiltInDir = makeMap('text,html,show,on,bind,model,pre,cloak,once')
-function hasCustomDirective(node) {
-  return (
-    node.type === 1 &&
-    node.directives &&
-    node.directives.some(function (d) {
-      return !isBuiltInDir(d.name)
-    })
-  )
-}
-// <select v-model> cannot be optimized because it requires a runtime check
-// to determine proper selected option
-function isSelectWithModel(node) {
-  return (
-    node.type === 1 &&
-    node.tag === 'select' &&
-    node.directives != null &&
-    node.directives.some(function (d) {
-      return d.name === 'model'
-    })
-  )
-}
-
-// The SSR codegen is essentially extending the default codegen to handle
-// segment types
-var RAW = 0
-var INTERPOLATION = 1
-var EXPRESSION = 2
-function generate(ast, options) {
-  var state = new CodegenState(options)
-  var code = ast ? genSSRElement(ast, state) : '_c("div")'
-  return {
-    render: 'with(this){return '.concat(code, '}'),
-    staticRenderFns: state.staticRenderFns
-  }
-}
-function genSSRElement(el, state) {
-  if (el.for && !el.forProcessed) {
-    return genFor(el, state, genSSRElement)
-  } else if (el.if && !el.ifProcessed) {
-    return genIf(el, state, genSSRElement)
-  } else if (el.tag === 'template' && !el.slotTarget) {
-    return el.ssrOptimizability === optimizability.FULL
-      ? genChildrenAsStringNode(el, state)
-      : genSSRChildren(el, state) || 'void 0'
-  }
-  switch (el.ssrOptimizability) {
-    case optimizability.FULL:
-      // stringify whole tree
-      return genStringElement(el, state)
-    case optimizability.SELF:
-      // stringify self and check children
-      return genStringElementWithChildren(el, state)
-    case optimizability.CHILDREN:
-      // generate self as VNode and stringify children
-      return genNormalElement(el, state, true)
-    case optimizability.PARTIAL:
-      // generate self as VNode and check children
-      return genNormalElement(el, state, false)
-    default:
-      // bail whole tree
-      return genElement(el, state)
-  }
-}
-function genNormalElement(el, state, stringifyChildren) {
-  var data = el.plain ? undefined : genData(el, state)
-  var children = stringifyChildren
-    ? '['.concat(genChildrenAsStringNode(el, state), ']')
-    : genSSRChildren(el, state, true)
-  return "_c('"
-    .concat(el.tag, "'")
-    .concat(data ? ','.concat(data) : '')
-    .concat(children ? ','.concat(children) : '', ')')
-}
-function genSSRChildren(el, state, checkSkip) {
-  return genChildren(el, state, checkSkip, genSSRElement, genSSRNode)
-}
-function genSSRNode(el, state) {
-  return el.type === 1 ? genSSRElement(el, state) : genText(el)
-}
-function genChildrenAsStringNode(el, state) {
-  return el.children.length
-    ? '_ssrNode('.concat(flattenSegments(childrenToSegments(el, state)), ')')
-    : ''
-}
-function genStringElement(el, state) {
-  return '_ssrNode('.concat(elementToString(el, state), ')')
-}
-function genStringElementWithChildren(el, state) {
-  var children = genSSRChildren(el, state, true)
-  return '_ssrNode('
-    .concat(flattenSegments(elementToOpenTagSegments(el, state)), ',"</')
-    .concat(el.tag, '>"')
-    .concat(children ? ','.concat(children) : '', ')')
-}
-function elementToString(el, state) {
-  return '('.concat(flattenSegments(elementToSegments(el, state)), ')')
-}
-function elementToSegments(el, state) {
-  // v-for / v-if
-  if (el.for && !el.forProcessed) {
-    el.forProcessed = true
-    return [
-      {
-        type: EXPRESSION,
-        value: genFor(el, state, elementToString, '_ssrList')
-      }
-    ]
-  } else if (el.if && !el.ifProcessed) {
-    el.ifProcessed = true
-    return [
-      {
-        type: EXPRESSION,
-        value: genIf(el, state, elementToString, '"<!---->"')
-      }
-    ]
-  } else if (el.tag === 'template') {
-    return childrenToSegments(el, state)
-  }
-  var openSegments = elementToOpenTagSegments(el, state)
-  var childrenSegments = childrenToSegments(el, state)
-  var isUnaryTag = state.options.isUnaryTag
-  var close =
-    isUnaryTag && isUnaryTag(el.tag)
-      ? []
-      : [{ type: RAW, value: '</'.concat(el.tag, '>') }]
-  return openSegments.concat(childrenSegments, close)
-}
-function elementToOpenTagSegments(el, state) {
-  applyModelTransform(el, state)
-  var binding
-  var segments = [{ type: RAW, value: '<'.concat(el.tag) }]
-  // attrs
-  if (el.attrs) {
-    segments.push.apply(segments, genAttrSegments(el.attrs))
-  }
-  // domProps
-  if (el.props) {
-    segments.push.apply(segments, genDOMPropSegments(el.props, el.attrs))
-  }
-  // v-bind="object"
-  if ((binding = el.attrsMap['v-bind'])) {
-    segments.push({
-      type: EXPRESSION,
-      value: '_ssrAttrs('.concat(binding, ')')
-    })
-  }
-  // v-bind.prop="object"
-  if ((binding = el.attrsMap['v-bind.prop'])) {
-    segments.push({
-      type: EXPRESSION,
-      value: '_ssrDOMProps('.concat(binding, ')')
-    })
-  }
-  // class
-  if (el.staticClass || el.classBinding) {
-    segments.push.apply(
-      segments,
-      genClassSegments(el.staticClass, el.classBinding)
-    )
-  }
-  // style & v-show
-  if (el.staticStyle || el.styleBinding || el.attrsMap['v-show']) {
-    segments.push.apply(
-      segments,
-      genStyleSegments(
-        el.attrsMap.style,
-        el.staticStyle,
-        el.styleBinding,
-        el.attrsMap['v-show']
-      )
-    )
-  }
-  // _scopedId
-  if (state.options.scopeId) {
-    segments.push({ type: RAW, value: ' '.concat(state.options.scopeId) })
-  }
-  segments.push({ type: RAW, value: '>' })
-  return segments
-}
-function childrenToSegments(el, state) {
-  var binding
-  if ((binding = el.attrsMap['v-html'])) {
-    return [{ type: EXPRESSION, value: '_s('.concat(binding, ')') }]
-  }
-  if ((binding = el.attrsMap['v-text'])) {
-    return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
-  }
-  if (el.tag === 'textarea' && (binding = el.attrsMap['v-model'])) {
-    return [{ type: INTERPOLATION, value: '_s('.concat(binding, ')') }]
-  }
-  return el.children ? nodesToSegments(el.children, state) : []
-}
-function nodesToSegments(children, state) {
-  var segments = []
-  for (var i = 0; i < children.length; i++) {
-    var c = children[i]
-    if (c.type === 1) {
-      segments.push.apply(segments, elementToSegments(c, state))
-    } else if (c.type === 2) {
-      segments.push({ type: INTERPOLATION, value: c.expression })
-    } else if (c.type === 3) {
-      var text = escape(c.text)
-      if (c.isComment) {
-        text = '<!--' + text + '-->'
-      }
-      segments.push({ type: RAW, value: text })
-    }
-  }
-  return segments
-}
-function flattenSegments(segments) {
-  var mergedSegments = []
-  var textBuffer = ''
-  var pushBuffer = function () {
-    if (textBuffer) {
-      mergedSegments.push(JSON.stringify(textBuffer))
-      textBuffer = ''
-    }
-  }
-  for (var i = 0; i < segments.length; i++) {
-    var s = segments[i]
-    if (s.type === RAW) {
-      textBuffer += s.value
-    } else if (s.type === INTERPOLATION) {
-      pushBuffer()
-      mergedSegments.push('_ssrEscape('.concat(s.value, ')'))
-    } else if (s.type === EXPRESSION) {
-      pushBuffer()
-      mergedSegments.push('('.concat(s.value, ')'))
-    }
-  }
-  pushBuffer()
-  return mergedSegments.join('+')
-}
-
-var createCompiler = createCompilerCreator(function baseCompile(
-  template,
-  options
-) {
-  var ast = parse(template.trim(), options)
-  optimize(ast, options)
-  var code = generate(ast, options)
-  return {
-    ast: ast,
-    render: code.render,
-    staticRenderFns: code.staticRenderFns
-  }
-})
-
-var _a = createCompiler(baseOptions),
-  compile = _a.compile,
-  compileToFunctions = _a.compileToFunctions
-
-exports.compile = compile$1
-exports.compileToFunctions = compileToFunctions$1
-exports.generateCodeFrame = generateCodeFrame
-exports.parseComponent = parseComponent
-exports.ssrCompile = compile
-exports.ssrCompileToFunctions = compileToFunctions
diff --git a/scripts/verify-commit-msg.js b/scripts/verify-commit-msg.js
index 6fdc5e32ef3..a5150a5f8e6 100644
--- a/scripts/verify-commit-msg.js
+++ b/scripts/verify-commit-msg.js
@@ -3,7 +3,7 @@ const msgPath = process.env.GIT_PARAMS
 const msg = require('fs').readFileSync(msgPath, 'utf-8').trim()
 
 const commitRE =
-  /^(revert: )?(wip|feat|fix|polish|docs|style|refactor|perf|test|workflow|ci|chore|types|build)(\(.+\))?: .{1,50}/
+  /^(revert: )?(wip|release|feat|fix|polish|docs|style|refactor|perf|test|workflow|ci|chore|types|build)(\(.+\))?: .{1,50}/
 
 if (!commitRE.test(msg)) {
   console.log()
@@ -18,12 +18,7 @@ if (!commitRE.test(msg)) {
       `    ${chalk.green(
         `fix(v-model): handle events on blur (close #28)`
       )}\n\n` +
-      chalk.red(`  See .github/COMMIT_CONVENTION.md for more details.\n`) +
-      chalk.red(
-        `  You can also use ${chalk.cyan(
-          `npm run commit`
-        )} to interactively generate a commit message.\n`
-      )
+      chalk.red(`  See .github/COMMIT_CONVENTION.md for more details.\n`)
   )
   process.exit(1)
 }

From 45b932b6e554b41599f034b347a8175efd69da88 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 31 May 2022 17:57:37 +0800
Subject: [PATCH 109/317] release: v2.7.0-alpha.1

---
 CHANGELOG.md                            | 14 ++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  6 ++++--
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7ba1cf54d6c..9f7aa3c5dc3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,17 @@
+# [2.7.0-alpha.1](https://github.com/vuejs/vue/compare/v2.6.14...v2.7.0-alpha.1) (2022-05-31)
+
+
+### Bug Fixes
+
+* **v-on:** add removing all dom event listeners when vnode destroyed ([#10085](https://github.com/vuejs/vue/issues/10085)) ([3d29ba8](https://github.com/vuejs/vue/commit/3d29ba863b89fd90dabd0856c0507eacdf5fef22))
+
+
+### Features
+
+* **compiler:** condenses staticClass whitespace (fix [#12113](https://github.com/vuejs/vue/issues/12113)) ([#12195](https://github.com/vuejs/vue/issues/12195)) ([515467a](https://github.com/vuejs/vue/commit/515467a618479792abedf01a7b1dcef2ac2a17ed))
+
+
+
 ## [2.6.14](https://github.com/vuejs/vue/compare/v2.6.13...v2.6.14) (2021-06-07)
 
 
diff --git a/package.json b/package.json
index 59c73d786cf..6b0049d5959 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.6.14",
+  "version": "2.7.0-alpha.1",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 59ce74c91f5..a8730ecf970 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,10 +1,12 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.6.14",
+  "version": "2.7.0-alpha.1",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "@babel/parser": "^7.16.4",
     "source-map": "^0.6.1",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 65886f2f824..5d9b13b64a9 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.6.14",
+  "version": "2.7.0-alpha.1",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index a23cd6f158e..47ef9be2a12 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.6.14",
+  "version": "2.7.0-alpha.1",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 5673363eda9e6082a9ff0300b8c4e79c9388891b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 09:44:06 +0800
Subject: [PATCH 110/317] feat: expose set/del as named exports

---
 src/core/observer/index.ts       |  8 ++++++--
 src/v3/index.ts                  |  1 +
 types/test/v3/reactivity-test.ts | 16 +++++++++++++++-
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index a32ed049ec3..ac1f2254f59 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -225,8 +225,10 @@ export function defineReactive(
  * triggers change notification if the property doesn't
  * already exist.
  */
+export function set<T>(array: T[], key: number, value: T): T
+export function set<T>(object: object, key: string | number, value: T): T
 export function set(
-  target: Array<any> | Record<string, any>,
+  target: any[] | Record<string, any>,
   key: any,
   val: any
 ): any {
@@ -279,7 +281,9 @@ export function set(
 /**
  * Delete a property and trigger change if necessary.
  */
-export function del(target: Array<any> | Object, key: any) {
+export function del<T>(array: T[], key: number): void
+export function del(object: object, key: string | number): void
+export function del(target: any[] | object, key: any) {
   if (__DEV__ && (isUndef(target) || isPrimitive(target))) {
     warn(
       `Cannot delete reactive property on undefined, null, or primitive value: ${target}`
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 4f3ce51dfa7..97fdc709b24 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -72,5 +72,6 @@ export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
 export { useSlots, useAttrs } from './apiSetup'
 export { nextTick } from 'core/util/next-tick'
+export { set, del } from 'core/observer'
 
 export * from './apiLifecycle'
diff --git a/types/test/v3/reactivity-test.ts b/types/test/v3/reactivity-test.ts
index c316a779641..dd1b2a4d8b6 100644
--- a/types/test/v3/reactivity-test.ts
+++ b/types/test/v3/reactivity-test.ts
@@ -11,7 +11,9 @@ import {
   shallowReactive,
   readonly,
   markRaw,
-  shallowReadonly
+  shallowReadonly,
+  set,
+  del
 } from '../../index'
 import { describe, expectType } from '../utils'
 
@@ -371,3 +373,15 @@ describe('shallowReadonly ref unwrap', () => {
   expectType<Ref>(r.count.n)
   r.count.n.value = 123
 })
+
+describe('set/del', () => {
+  set({}, 1, 'hi')
+  set([], 1, 'bye')
+  del({}, 'foo')
+  del([], 1)
+
+  // @ts-expect-error
+  set({}, 1)
+  // @ts-expect-error
+  del([], 'fse', 123)
+})

From d3172377e0c2df9e84244ede6fc9a091344e6f1c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 10:11:19 +0800
Subject: [PATCH 111/317] feat: add exports field + mjs build

---
 compiler-sfc/index.mjs    |  1 +
 compiler-sfc/package.json |  1 +
 package.json              | 16 ++++++++++++++++
 scripts/config.js         |  7 +++++++
 4 files changed, 25 insertions(+)
 create mode 100644 compiler-sfc/index.mjs

diff --git a/compiler-sfc/index.mjs b/compiler-sfc/index.mjs
new file mode 100644
index 00000000000..3c30abc8ccf
--- /dev/null
+++ b/compiler-sfc/index.mjs
@@ -0,0 +1 @@
+export * from '@vue/compiler-sfc'
diff --git a/compiler-sfc/package.json b/compiler-sfc/package.json
index d7ccd0a7b03..778c7ebf51c 100644
--- a/compiler-sfc/package.json
+++ b/compiler-sfc/package.json
@@ -1,4 +1,5 @@
 {
   "main": "index.js",
+  "module": "index.mjs",
   "types": "index.d.ts"
 }
diff --git a/package.json b/package.json
index 6b0049d5959..8b9e71fbba1 100644
--- a/package.json
+++ b/package.json
@@ -15,6 +15,22 @@
     "compiler-sfc",
     "packages/compiler-sfc"
   ],
+  "exports": {
+    ".": {
+      "import": {
+        "node": "./dist/vue.runtime.mjs",
+        "default": "./dist/vue.runtime.esm.js"
+      },
+      "require": "./dist/vue.runtime.common.js",
+      "types": "./types/index.d.ts"
+    },
+    "./compiler-sfc": {
+      "import": "./compiler-sfc/index.mjs",
+      "require": "./compiler-sfc/index.js"
+    },
+    "./dist/*": "./dist/*",
+    "./types/*": "./types/*"
+  },
   "sideEffects": false,
   "scripts": {
     "dev": "rollup -w -c scripts/config.js --environment TARGET:full-dev",
diff --git a/scripts/config.js b/scripts/config.js
index 2360c8026cf..610e8d0a9ee 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -65,6 +65,13 @@ const builds = {
     format: 'es',
     banner
   },
+  // Runtime only ES modules build (for Node)
+  'runtime-mjs': {
+    entry: resolve('web/entry-runtime-esm.ts'),
+    dest: resolve('dist/vue.runtime.mjs'),
+    format: 'es',
+    banner
+  },
   // Runtime+compiler ES modules build (for bundlers)
   'full-esm': {
     entry: resolve('web/entry-runtime-with-compiler-esm.ts'),

From 2b00084ee4562fd7b4d48bc01234b6b55571d9ef Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 10:25:22 +0800
Subject: [PATCH 112/317] chore: changelog [ci skip]

---
 CHANGELOG.md | 1388 ++++++++++++++++++++------------------------------
 1 file changed, 559 insertions(+), 829 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f7aa3c5dc3..0059b4062d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,1317 +1,1047 @@
 # [2.7.0-alpha.1](https://github.com/vuejs/vue/compare/v2.6.14...v2.7.0-alpha.1) (2022-05-31)
 
+This release includes full [Composition API](https://vuejs.org/guide/extras/composition-api-faq.html) support, including:
 
-### Bug Fixes
+- `setup()` support in components
+- Reactivity APIs (`ref()`, `reactive()` etc.)
+- Lifecycle hooks (`onMounted()` etc.)
+- `provide()` and `inject()`
+- `useSlots()` and `useAttrs()`
+- template refs with `setup()`
 
-* **v-on:** add removing all dom event listeners when vnode destroyed ([#10085](https://github.com/vuejs/vue/issues/10085)) ([3d29ba8](https://github.com/vuejs/vue/commit/3d29ba863b89fd90dabd0856c0507eacdf5fef22))
+### Behavior difference from Vue 3
 
+- The reactivity system is still getter/setter based and does not use Proxies, so all Vue 2 change detection caveats still apply.
+- `reactive()`, `ref()`, and `shallowReactive()` will directly convert original objects instead of creating proxies. They also do not convert properties with symbol keys.
+- Avoid using arrays as root values in `reactive()` because without property access the array's mutation won't be tracked (this will result in a warning).
+- `readonly()` **does** create a separate object, but it won't track newly added properties and does not work on arrays.
 
-### Features
+### Notes on API exposure
 
-* **compiler:** condenses staticClass whitespace (fix [#12113](https://github.com/vuejs/vue/issues/12113)) ([#12195](https://github.com/vuejs/vue/issues/12195)) ([515467a](https://github.com/vuejs/vue/commit/515467a618479792abedf01a7b1dcef2ac2a17ed))
+- In ESM builds, these APIs are provided as named exports (and named exports only):
 
+  ```js
+  import Vue, { ref } from 'vue'
 
+  Vue.ref // undefined, use named export instead
+  ```
 
-## [2.6.14](https://github.com/vuejs/vue/compare/v2.6.13...v2.6.14) (2021-06-07)
+- When bundling with CJS builds externalized, bundlers should be able to handle ESM interop when externalizing CJS builds.
 
+- In UMD builds, these APIs are exposed on the global `Vue` object.
 
-### Bug Fixes
+In addition:
+
+- `h()`, `set()`, `del()` and `nextTick()` are now also provided as named exports in ESM builds.
 
-* **types:** async Component types ([#11906](https://github.com/vuejs/vue/issues/11906)) ([c52427b](https://github.com/vuejs/vue/commit/c52427b0d2c1d203deea6eb69f2b4b181d56022c))
-* **v-slot:** fix scoped slot normalization combined with v-if ([#12104](https://github.com/vuejs/vue/issues/12104)) ([38f71de](https://github.com/vuejs/vue/commit/38f71de380d566e4eef60968a8eca6bd6f482dd5))
+### Bug Fixes
 
+- **v-on:** add removing all dom event listeners when vnode destroyed ([#10085](https://github.com/vuejs/vue/issues/10085)) ([3d29ba8](https://github.com/vuejs/vue/commit/3d29ba863b89fd90dabd0856c0507eacdf5fef22))
 
 ### Features
 
-* **ssr:** vue-ssr-webpack-plugin compatible with webpack 5 ([#12002](https://github.com/vuejs/vue/issues/12002)) ([80e7730](https://github.com/vuejs/vue/commit/80e7730946538e0371e213100a0fe81299c2f4b2))
+- **compiler:** condenses staticClass whitespace (fix [#12113](https://github.com/vuejs/vue/issues/12113)) ([#12195](https://github.com/vuejs/vue/issues/12195)) ([515467a](https://github.com/vuejs/vue/commit/515467a618479792abedf01a7b1dcef2ac2a17ed))
 
+## [2.6.14](https://github.com/vuejs/vue/compare/v2.6.13...v2.6.14) (2021-06-07)
 
+### Bug Fixes
 
-## [2.6.13](https://github.com/vuejs/vue/compare/v2.6.12...v2.6.13) (2021-06-01)
+- **types:** async Component types ([#11906](https://github.com/vuejs/vue/issues/11906)) ([c52427b](https://github.com/vuejs/vue/commit/c52427b0d2c1d203deea6eb69f2b4b181d56022c))
+- **v-slot:** fix scoped slot normalization combined with v-if ([#12104](https://github.com/vuejs/vue/issues/12104)) ([38f71de](https://github.com/vuejs/vue/commit/38f71de380d566e4eef60968a8eca6bd6f482dd5))
+
+### Features
 
+- **ssr:** vue-ssr-webpack-plugin compatible with webpack 5 ([#12002](https://github.com/vuejs/vue/issues/12002)) ([80e7730](https://github.com/vuejs/vue/commit/80e7730946538e0371e213100a0fe81299c2f4b2))
 
-### Bug Fixes
+## [2.6.13](https://github.com/vuejs/vue/compare/v2.6.12...v2.6.13) (2021-06-01)
 
-* **attrs:** do not consider translate attribute as boolean ([#11392](https://github.com/vuejs/vue/issues/11392)) ([cd57393](https://github.com/vuejs/vue/commit/cd57393fd3e2c169d450607bc4f03652d106bcc2)), closes [#11391](https://github.com/vuejs/vue/issues/11391)
-* **compiler:** Allow BigInt usage in templates ([#11152](https://github.com/vuejs/vue/issues/11152)) ([c42b706](https://github.com/vuejs/vue/commit/c42b7066cae7947e9fd877e495aeb38623c2354d))
-* **compiler:** avoid converting &nbps; to spaces ([#11065](https://github.com/vuejs/vue/issues/11065)) ([55a30cf](https://github.com/vuejs/vue/commit/55a30cf9db247eba2aca817439fdb3cd15e9184f))
-* **compiler:** event handlers with modifiers swallowing arguments (fix [#10867](https://github.com/vuejs/vue/issues/10867)) ([#10958](https://github.com/vuejs/vue/issues/10958)) ([8620706](https://github.com/vuejs/vue/commit/862070662dd4871cb834664435ec836df57c7d57))
-* **core:** fix sameVnode for async component ([#11107](https://github.com/vuejs/vue/issues/11107)) ([5260830](https://github.com/vuejs/vue/commit/52608302e9bca84fb9e9f0499e89acade78d3d07))
-* **core:** remove trailing comma in function signature ([#10845](https://github.com/vuejs/vue/issues/10845)) ([579e1ff](https://github.com/vuejs/vue/commit/579e1ff9df1d454f85fac386d098b7bf1a42c4f2)), closes [#10843](https://github.com/vuejs/vue/issues/10843)
-* **errorHandler:** async error handling for watchers ([#9484](https://github.com/vuejs/vue/issues/9484)) ([e4dea59](https://github.com/vuejs/vue/commit/e4dea59f84dfbf32cda1cdd832380dd90b1a6fd1))
-* force update between two components with and without slot ([#11795](https://github.com/vuejs/vue/issues/11795)) ([77b5330](https://github.com/vuejs/vue/commit/77b5330c5498a6b14a83197371e9a2dbf9939a9c))
-* give correct namespace in foreignObject ([#11576](https://github.com/vuejs/vue/issues/11576)) ([af5e05d](https://github.com/vuejs/vue/commit/af5e05d87ecd218f73302a1b08dcaedd2b46814a)), closes [#11575](https://github.com/vuejs/vue/issues/11575)
-* handle async placeholders in normalizeScopedSlot ([#11963](https://github.com/vuejs/vue/issues/11963)) ([af54514](https://github.com/vuejs/vue/commit/af54514cf97e724d224408c1ecc6c81ddccd4b75))
-* **keep-alive:** cache what is really needed not the whole VNode data ([#12015](https://github.com/vuejs/vue/issues/12015)) ([e7baaa1](https://github.com/vuejs/vue/commit/e7baaa12055231c9367fa1c7bf917e534bd8a739))
-* **parser:** allow multiple slots with new syntax ([#9785](https://github.com/vuejs/vue/issues/9785)) ([67825c2](https://github.com/vuejs/vue/commit/67825c24bcb0a9f64055bda1b1e4af66aad3c529)), closes [#9781](https://github.com/vuejs/vue/issues/9781)
-* pause dep collection during immediate watcher invocation ([#11943](https://github.com/vuejs/vue/issues/11943)) ([987f322](https://github.com/vuejs/vue/commit/987f322b8f419cc307f4294173f8792a706ed73f))
-* **props:** correctly warn when a provided prop is Symbol ([#10529](https://github.com/vuejs/vue/issues/10529)) ([abb5ef3](https://github.com/vuejs/vue/commit/abb5ef35dd02919dce19c895ad12113071712df0)), closes [#10519](https://github.com/vuejs/vue/issues/10519)
-* **props:** support BigInt in props type validation ([#11191](https://github.com/vuejs/vue/issues/11191)) ([fa1f81e](https://github.com/vuejs/vue/commit/fa1f81e91062e9de6161708209cd7354733aa354))
-* **slot:** add a function to return the slot fallback content ([#12014](https://github.com/vuejs/vue/issues/12014)) ([ce457f9](https://github.com/vuejs/vue/commit/ce457f9f4d48548d5e8763c47d013e23c2b65c12))
-* **ssr:** avoid missing files in manifest ([#11609](https://github.com/vuejs/vue/issues/11609)) ([b97606c](https://github.com/vuejs/vue/commit/b97606cdc658448b56518ac27af98fc82999d05f))
-* **ssr:** inheritAttrs false adds attributes to html ([#11706](https://github.com/vuejs/vue/issues/11706)) ([7e5dc6b](https://github.com/vuejs/vue/commit/7e5dc6bd9ebc1620624191804d2ace43cae557a8))
-* **ssr:** textarea keeps undefined/null values ([#11121](https://github.com/vuejs/vue/issues/11121)) ([b8bd149](https://github.com/vuejs/vue/commit/b8bd149d8aa3f175a1a656d62f7b6ec60c31a364))
-* **types:** add types for Vue.util.warn function ([#11964](https://github.com/vuejs/vue/issues/11964)) ([e0274e4](https://github.com/vuejs/vue/commit/e0274e4320f68bb93bd7f90bb1ef701ccf9b6f2a)), closes [/github.com/vuejs/vue/blob/v2.6.12/src/core/util/debug.js#L18-L26](https://github.com//github.com/vuejs/vue/blob/v2.6.12/src/core/util/debug.js/issues/L18-L26)
-* **types:** allow string for watch handlers in options ([#10396](https://github.com/vuejs/vue/issues/10396)) ([668e1e6](https://github.com/vuejs/vue/commit/668e1e637461ff630803e85bf99158415d276d4c))
-* **types:** allow symbol &  boolean for vnode key ([#11914](https://github.com/vuejs/vue/issues/11914)) ([5c459f0](https://github.com/vuejs/vue/commit/5c459f0fd6911daca09ad205aecf5423a9d05698))
-* **types:** changed expression type to optional string ([#11189](https://github.com/vuejs/vue/issues/11189)) ([7c75462](https://github.com/vuejs/vue/commit/7c754623541c492161f7976203f0b1697a9a0113)), closes [#10871](https://github.com/vuejs/vue/issues/10871)
-* **types:** make $refs undefined possible ([#11112](https://github.com/vuejs/vue/issues/11112)) ([2b93e86](https://github.com/vuejs/vue/commit/2b93e86aa1437168476cbb5100cfb3bbbac55efa))
-* **v-on:** avoid events with empty keyCode (autocomplete) ([#11326](https://github.com/vuejs/vue/issues/11326)) ([c6d7a6f](https://github.com/vuejs/vue/commit/c6d7a6fce795ffbd6b8a599787eca986bb260a25))
-* **v-pre:** do not alter attributes ([#10088](https://github.com/vuejs/vue/issues/10088)) ([0664cb0](https://github.com/vuejs/vue/commit/0664cb01434f3d52efd076b6aafe54066a2a762a)), closes [#10087](https://github.com/vuejs/vue/issues/10087)
-* **vdom:** avoid executing root level script tags ([#11487](https://github.com/vuejs/vue/issues/11487)) ([fb16d7b](https://github.com/vuejs/vue/commit/fb16d7bfa1e32c21a2f4b627fb8864d3c5c6b655)), closes [#11483](https://github.com/vuejs/vue/issues/11483)
-* **warn:** better message with no constructors props ([#9241](https://github.com/vuejs/vue/issues/9241)) ([6940131](https://github.com/vuejs/vue/commit/69401311f4bf55e58550a2134c33ceb8ae1f180e))
-* **warns:** modify `maybeComponent` function in parser ([#10167](https://github.com/vuejs/vue/issues/10167)) ([0603ff6](https://github.com/vuejs/vue/commit/0603ff695d2f41286239298210113cbe2b209e28)), closes [#10152](https://github.com/vuejs/vue/issues/10152)
+### Bug Fixes
 
+- **attrs:** do not consider translate attribute as boolean ([#11392](https://github.com/vuejs/vue/issues/11392)) ([cd57393](https://github.com/vuejs/vue/commit/cd57393fd3e2c169d450607bc4f03652d106bcc2)), closes [#11391](https://github.com/vuejs/vue/issues/11391)
+- **compiler:** Allow BigInt usage in templates ([#11152](https://github.com/vuejs/vue/issues/11152)) ([c42b706](https://github.com/vuejs/vue/commit/c42b7066cae7947e9fd877e495aeb38623c2354d))
+- **compiler:** avoid converting &nbps; to spaces ([#11065](https://github.com/vuejs/vue/issues/11065)) ([55a30cf](https://github.com/vuejs/vue/commit/55a30cf9db247eba2aca817439fdb3cd15e9184f))
+- **compiler:** event handlers with modifiers swallowing arguments (fix [#10867](https://github.com/vuejs/vue/issues/10867)) ([#10958](https://github.com/vuejs/vue/issues/10958)) ([8620706](https://github.com/vuejs/vue/commit/862070662dd4871cb834664435ec836df57c7d57))
+- **core:** fix sameVnode for async component ([#11107](https://github.com/vuejs/vue/issues/11107)) ([5260830](https://github.com/vuejs/vue/commit/52608302e9bca84fb9e9f0499e89acade78d3d07))
+- **core:** remove trailing comma in function signature ([#10845](https://github.com/vuejs/vue/issues/10845)) ([579e1ff](https://github.com/vuejs/vue/commit/579e1ff9df1d454f85fac386d098b7bf1a42c4f2)), closes [#10843](https://github.com/vuejs/vue/issues/10843)
+- **errorHandler:** async error handling for watchers ([#9484](https://github.com/vuejs/vue/issues/9484)) ([e4dea59](https://github.com/vuejs/vue/commit/e4dea59f84dfbf32cda1cdd832380dd90b1a6fd1))
+- force update between two components with and without slot ([#11795](https://github.com/vuejs/vue/issues/11795)) ([77b5330](https://github.com/vuejs/vue/commit/77b5330c5498a6b14a83197371e9a2dbf9939a9c))
+- give correct namespace in foreignObject ([#11576](https://github.com/vuejs/vue/issues/11576)) ([af5e05d](https://github.com/vuejs/vue/commit/af5e05d87ecd218f73302a1b08dcaedd2b46814a)), closes [#11575](https://github.com/vuejs/vue/issues/11575)
+- handle async placeholders in normalizeScopedSlot ([#11963](https://github.com/vuejs/vue/issues/11963)) ([af54514](https://github.com/vuejs/vue/commit/af54514cf97e724d224408c1ecc6c81ddccd4b75))
+- **keep-alive:** cache what is really needed not the whole VNode data ([#12015](https://github.com/vuejs/vue/issues/12015)) ([e7baaa1](https://github.com/vuejs/vue/commit/e7baaa12055231c9367fa1c7bf917e534bd8a739))
+- **parser:** allow multiple slots with new syntax ([#9785](https://github.com/vuejs/vue/issues/9785)) ([67825c2](https://github.com/vuejs/vue/commit/67825c24bcb0a9f64055bda1b1e4af66aad3c529)), closes [#9781](https://github.com/vuejs/vue/issues/9781)
+- pause dep collection during immediate watcher invocation ([#11943](https://github.com/vuejs/vue/issues/11943)) ([987f322](https://github.com/vuejs/vue/commit/987f322b8f419cc307f4294173f8792a706ed73f))
+- **props:** correctly warn when a provided prop is Symbol ([#10529](https://github.com/vuejs/vue/issues/10529)) ([abb5ef3](https://github.com/vuejs/vue/commit/abb5ef35dd02919dce19c895ad12113071712df0)), closes [#10519](https://github.com/vuejs/vue/issues/10519)
+- **props:** support BigInt in props type validation ([#11191](https://github.com/vuejs/vue/issues/11191)) ([fa1f81e](https://github.com/vuejs/vue/commit/fa1f81e91062e9de6161708209cd7354733aa354))
+- **slot:** add a function to return the slot fallback content ([#12014](https://github.com/vuejs/vue/issues/12014)) ([ce457f9](https://github.com/vuejs/vue/commit/ce457f9f4d48548d5e8763c47d013e23c2b65c12))
+- **ssr:** avoid missing files in manifest ([#11609](https://github.com/vuejs/vue/issues/11609)) ([b97606c](https://github.com/vuejs/vue/commit/b97606cdc658448b56518ac27af98fc82999d05f))
+- **ssr:** inheritAttrs false adds attributes to html ([#11706](https://github.com/vuejs/vue/issues/11706)) ([7e5dc6b](https://github.com/vuejs/vue/commit/7e5dc6bd9ebc1620624191804d2ace43cae557a8))
+- **ssr:** textarea keeps undefined/null values ([#11121](https://github.com/vuejs/vue/issues/11121)) ([b8bd149](https://github.com/vuejs/vue/commit/b8bd149d8aa3f175a1a656d62f7b6ec60c31a364))
+- **types:** add types for Vue.util.warn function ([#11964](https://github.com/vuejs/vue/issues/11964)) ([e0274e4](https://github.com/vuejs/vue/commit/e0274e4320f68bb93bd7f90bb1ef701ccf9b6f2a)), closes [/github.com/vuejs/vue/blob/v2.6.12/src/core/util/debug.js#L18-L26](https://github.com//github.com/vuejs/vue/blob/v2.6.12/src/core/util/debug.js/issues/L18-L26)
+- **types:** allow string for watch handlers in options ([#10396](https://github.com/vuejs/vue/issues/10396)) ([668e1e6](https://github.com/vuejs/vue/commit/668e1e637461ff630803e85bf99158415d276d4c))
+- **types:** allow symbol & boolean for vnode key ([#11914](https://github.com/vuejs/vue/issues/11914)) ([5c459f0](https://github.com/vuejs/vue/commit/5c459f0fd6911daca09ad205aecf5423a9d05698))
+- **types:** changed expression type to optional string ([#11189](https://github.com/vuejs/vue/issues/11189)) ([7c75462](https://github.com/vuejs/vue/commit/7c754623541c492161f7976203f0b1697a9a0113)), closes [#10871](https://github.com/vuejs/vue/issues/10871)
+- **types:** make $refs undefined possible ([#11112](https://github.com/vuejs/vue/issues/11112)) ([2b93e86](https://github.com/vuejs/vue/commit/2b93e86aa1437168476cbb5100cfb3bbbac55efa))
+- **v-on:** avoid events with empty keyCode (autocomplete) ([#11326](https://github.com/vuejs/vue/issues/11326)) ([c6d7a6f](https://github.com/vuejs/vue/commit/c6d7a6fce795ffbd6b8a599787eca986bb260a25))
+- **v-pre:** do not alter attributes ([#10088](https://github.com/vuejs/vue/issues/10088)) ([0664cb0](https://github.com/vuejs/vue/commit/0664cb01434f3d52efd076b6aafe54066a2a762a)), closes [#10087](https://github.com/vuejs/vue/issues/10087)
+- **vdom:** avoid executing root level script tags ([#11487](https://github.com/vuejs/vue/issues/11487)) ([fb16d7b](https://github.com/vuejs/vue/commit/fb16d7bfa1e32c21a2f4b627fb8864d3c5c6b655)), closes [#11483](https://github.com/vuejs/vue/issues/11483)
+- **warn:** better message with no constructors props ([#9241](https://github.com/vuejs/vue/issues/9241)) ([6940131](https://github.com/vuejs/vue/commit/69401311f4bf55e58550a2134c33ceb8ae1f180e))
+- **warns:** modify `maybeComponent` function in parser ([#10167](https://github.com/vuejs/vue/issues/10167)) ([0603ff6](https://github.com/vuejs/vue/commit/0603ff695d2f41286239298210113cbe2b209e28)), closes [#10152](https://github.com/vuejs/vue/issues/10152)
 
 ### Features
 
-* **warns:** avoid warning native modifiers on dynamic components ([#11052](https://github.com/vuejs/vue/issues/11052)) ([3d46692](https://github.com/vuejs/vue/commit/3d46692ee4e8ec67b5bc0f66cdabf4667fa4de88))
-* **warn:** warn computed conflict with methods ([#10119](https://github.com/vuejs/vue/issues/10119)) ([3ad60fe](https://github.com/vuejs/vue/commit/3ad60fea73d042fc9a127d19de8329948d3f2ef0))
-
+- **warns:** avoid warning native modifiers on dynamic components ([#11052](https://github.com/vuejs/vue/issues/11052)) ([3d46692](https://github.com/vuejs/vue/commit/3d46692ee4e8ec67b5bc0f66cdabf4667fa4de88))
+- **warn:** warn computed conflict with methods ([#10119](https://github.com/vuejs/vue/issues/10119)) ([3ad60fe](https://github.com/vuejs/vue/commit/3ad60fea73d042fc9a127d19de8329948d3f2ef0))
 
 ### Performance Improvements
 
-* preinitialize typeCheck RegExp ([#10990](https://github.com/vuejs/vue/issues/10990)) ([2488a6a](https://github.com/vuejs/vue/commit/2488a6a1e9779f0cca4a64163ef44ac30530a450))
-
-
+- preinitialize typeCheck RegExp ([#10990](https://github.com/vuejs/vue/issues/10990)) ([2488a6a](https://github.com/vuejs/vue/commit/2488a6a1e9779f0cca4a64163ef44ac30530a450))
 
 ## [2.6.12](https://github.com/vuejs/vue/compare/v2.6.11...v2.6.12) (2020-08-20)
 
-
 ### Bug Fixes
 
-* **security:** upgrade serialize-javascript ([#11434](https://github.com/vuejs/vue/issues/11434)) ([5b39961](https://github.com/vuejs/vue/commit/5b399612d8323ad0bb8b3f6fa8b2982ab73c0e6e))
-
-
+- **security:** upgrade serialize-javascript ([#11434](https://github.com/vuejs/vue/issues/11434)) ([5b39961](https://github.com/vuejs/vue/commit/5b399612d8323ad0bb8b3f6fa8b2982ab73c0e6e))
 
 ## [2.6.11](https://github.com/vuejs/vue/compare/v2.6.10...v2.6.11) (2019-12-13)
 
-
 ### Bug Fixes
 
-* **compiler:** Remove the warning for valid v-slot value ([#9917](https://github.com/vuejs/vue/issues/9917)) ([085d188](https://github.com/vuejs/vue/commit/085d188379af98e9f482d7e2009ebfd771bd7ca5))
-* fix function expression regex ([#9922](https://github.com/vuejs/vue/issues/9922)) ([569b728](https://github.com/vuejs/vue/commit/569b728ab19d1956bf935a98c9c65a03d92ac85f)), closes [#9920](https://github.com/vuejs/vue/issues/9920)
-* **types:** fix global namespace declaration for UMD bundle ([#9912](https://github.com/vuejs/vue/issues/9912)) ([ab50e8e](https://github.com/vuejs/vue/commit/ab50e8e1da2f4f944af683252481728485fedf16))
-* **types:** fix prop constructor type inference ([#10779](https://github.com/vuejs/vue/issues/10779)) ([4821149](https://github.com/vuejs/vue/commit/4821149b8bbd4650b1d9c9c3cfbb539ac1e24589))
-
-
+- **compiler:** Remove the warning for valid v-slot value ([#9917](https://github.com/vuejs/vue/issues/9917)) ([085d188](https://github.com/vuejs/vue/commit/085d188379af98e9f482d7e2009ebfd771bd7ca5))
+- fix function expression regex ([#9922](https://github.com/vuejs/vue/issues/9922)) ([569b728](https://github.com/vuejs/vue/commit/569b728ab19d1956bf935a98c9c65a03d92ac85f)), closes [#9920](https://github.com/vuejs/vue/issues/9920)
+- **types:** fix global namespace declaration for UMD bundle ([#9912](https://github.com/vuejs/vue/issues/9912)) ([ab50e8e](https://github.com/vuejs/vue/commit/ab50e8e1da2f4f944af683252481728485fedf16))
+- **types:** fix prop constructor type inference ([#10779](https://github.com/vuejs/vue/issues/10779)) ([4821149](https://github.com/vuejs/vue/commit/4821149b8bbd4650b1d9c9c3cfbb539ac1e24589))
 
 ## [2.6.10](https://github.com/vuejs/vue/compare/v2.6.9...v2.6.10) (2019-03-20)
 
-
 ### Bug Fixes
 
-* **codegen:** support named function expression in v-on ([#9709](https://github.com/vuejs/vue/issues/9709)) ([3433ba5](https://github.com/vuejs/vue/commit/3433ba5beef9a6dd97705943c3441ebbee222afd)), closes [#9707](https://github.com/vuejs/vue/issues/9707)
-* **core:** cleanup timeouts for async components ([#9649](https://github.com/vuejs/vue/issues/9649)) ([02d21c2](https://github.com/vuejs/vue/commit/02d21c265c239682e73b2b3f98028f2da5e7205d)), closes [#9648](https://github.com/vuejs/vue/issues/9648)
-* **core:** only unset dom prop when not present ([f11449d](https://github.com/vuejs/vue/commit/f11449d916a468651d4fd5024c37e3eebbc9941f)), closes [#9650](https://github.com/vuejs/vue/issues/9650)
-* **core:** use window.performance for compatibility in JSDOM ([#9700](https://github.com/vuejs/vue/issues/9700)) ([653c74e](https://github.com/vuejs/vue/commit/653c74e64e5ccd66cda94c77577984f8afa8386d)), closes [#9698](https://github.com/vuejs/vue/issues/9698)
-* **scheduler:** revert timeStamp check ([22790b2](https://github.com/vuejs/vue/commit/22790b250cd5239a8379b4ec8cc3a9b570dac4bc)), closes [#9729](https://github.com/vuejs/vue/issues/9729) [#9632](https://github.com/vuejs/vue/issues/9632)
-* **slots:** fix slots not updating when passing down normal slots as $scopedSlots ([ebc1893](https://github.com/vuejs/vue/commit/ebc1893faccd1a9d953a8e8feddcb49cf1b9004d)), closes [#9699](https://github.com/vuejs/vue/issues/9699)
-* **types:** allow using functions on the PropTypes ([#9733](https://github.com/vuejs/vue/issues/9733)) ([df4af4b](https://github.com/vuejs/vue/commit/df4af4bd1906b9f23b62816142fdfbd6336d3d2f)), closes [#9692](https://github.com/vuejs/vue/issues/9692)
-* **types:** support string type for style in VNode data ([#9728](https://github.com/vuejs/vue/issues/9728)) ([982d5a4](https://github.com/vuejs/vue/commit/982d5a492fb95577217e2dacaa044eabe78a8601)), closes [#9727](https://github.com/vuejs/vue/issues/9727)
-
-
+- **codegen:** support named function expression in v-on ([#9709](https://github.com/vuejs/vue/issues/9709)) ([3433ba5](https://github.com/vuejs/vue/commit/3433ba5beef9a6dd97705943c3441ebbee222afd)), closes [#9707](https://github.com/vuejs/vue/issues/9707)
+- **core:** cleanup timeouts for async components ([#9649](https://github.com/vuejs/vue/issues/9649)) ([02d21c2](https://github.com/vuejs/vue/commit/02d21c265c239682e73b2b3f98028f2da5e7205d)), closes [#9648](https://github.com/vuejs/vue/issues/9648)
+- **core:** only unset dom prop when not present ([f11449d](https://github.com/vuejs/vue/commit/f11449d916a468651d4fd5024c37e3eebbc9941f)), closes [#9650](https://github.com/vuejs/vue/issues/9650)
+- **core:** use window.performance for compatibility in JSDOM ([#9700](https://github.com/vuejs/vue/issues/9700)) ([653c74e](https://github.com/vuejs/vue/commit/653c74e64e5ccd66cda94c77577984f8afa8386d)), closes [#9698](https://github.com/vuejs/vue/issues/9698)
+- **scheduler:** revert timeStamp check ([22790b2](https://github.com/vuejs/vue/commit/22790b250cd5239a8379b4ec8cc3a9b570dac4bc)), closes [#9729](https://github.com/vuejs/vue/issues/9729) [#9632](https://github.com/vuejs/vue/issues/9632)
+- **slots:** fix slots not updating when passing down normal slots as $scopedSlots ([ebc1893](https://github.com/vuejs/vue/commit/ebc1893faccd1a9d953a8e8feddcb49cf1b9004d)), closes [#9699](https://github.com/vuejs/vue/issues/9699)
+- **types:** allow using functions on the PropTypes ([#9733](https://github.com/vuejs/vue/issues/9733)) ([df4af4b](https://github.com/vuejs/vue/commit/df4af4bd1906b9f23b62816142fdfbd6336d3d2f)), closes [#9692](https://github.com/vuejs/vue/issues/9692)
+- **types:** support string type for style in VNode data ([#9728](https://github.com/vuejs/vue/issues/9728)) ([982d5a4](https://github.com/vuejs/vue/commit/982d5a492fb95577217e2dacaa044eabe78a8601)), closes [#9727](https://github.com/vuejs/vue/issues/9727)
 
 ## [2.6.9](https://github.com/vuejs/vue/compare/v2.6.8...v2.6.9) (2019-03-14)
 
-
 ### Bug Fixes
 
-* **compiler:** whitespace: 'condense' should honor pre tag as well ([#9660](https://github.com/vuejs/vue/issues/9660)) ([f1bdd7f](https://github.com/vuejs/vue/commit/f1bdd7ff9d1fc86f7a8ad8d5cb6d9abc7b2e47f3))
-* event timeStamp check for Qt ([7591b9d](https://github.com/vuejs/vue/commit/7591b9dc6dde314f2d32dcd7a8355f696a330979)), closes [#9681](https://github.com/vuejs/vue/issues/9681)
-* **scheduler:** fix getNow check in IE9 ([#9647](https://github.com/vuejs/vue/issues/9647)) ([da77d6a](https://github.com/vuejs/vue/commit/da77d6a98bdccd8a2c8bfdfe6b9cb46efcb1193c)), closes [#9632](https://github.com/vuejs/vue/issues/9632)
-* **scheduler:** getNow detection can randomly fail ([#9667](https://github.com/vuejs/vue/issues/9667)) ([ef2a380](https://github.com/vuejs/vue/commit/ef2a380c6eb6bd1a7ff516c357dafa717e75a745))
-* should consider presence of normal slots when caching normalized scoped slots ([9313cf9](https://github.com/vuejs/vue/commit/9313cf91740e1d43c43cf9e73d905dbab913beb5)), closes [#9644](https://github.com/vuejs/vue/issues/9644)
-* should not swallow user catch on rejected promise in methods ([7186940](https://github.com/vuejs/vue/commit/7186940143704acc4ec046132f6a56e9c983e510)), closes [#9694](https://github.com/vuejs/vue/issues/9694)
-* should use fallback for scoped slots with single falsy v-if ([781c705](https://github.com/vuejs/vue/commit/781c70514e01bc402828946805bfad7437c7175e)), closes [#9658](https://github.com/vuejs/vue/issues/9658)
-* **ssr:** fix nested async functional componet rendering ([#9673](https://github.com/vuejs/vue/issues/9673)) ([8082d2f](https://github.com/vuejs/vue/commit/8082d2f910d963f14c151fb445e0fcc5c975cca9)), closes [#9643](https://github.com/vuejs/vue/issues/9643)
-* **ssr:** not push non-async css files into map ([#9677](https://github.com/vuejs/vue/issues/9677)) ([d282400](https://github.com/vuejs/vue/commit/d28240009c4c49fb2ef42a79206f0d9ad03f736c))
-* **transition:** fix appear check for transition wrapper components ([#9668](https://github.com/vuejs/vue/issues/9668)) ([4de4649](https://github.com/vuejs/vue/commit/4de4649d9637262a9b007720b59f80ac72a5620c))
-* v-bind object should be overridable by single bindings ([#9653](https://github.com/vuejs/vue/issues/9653)) ([0b57380](https://github.com/vuejs/vue/commit/0b57380f10986c6b07e3c240acc06bfd2eddfd1b)), closes [#9641](https://github.com/vuejs/vue/issues/9641)
-
-
+- **compiler:** whitespace: 'condense' should honor pre tag as well ([#9660](https://github.com/vuejs/vue/issues/9660)) ([f1bdd7f](https://github.com/vuejs/vue/commit/f1bdd7ff9d1fc86f7a8ad8d5cb6d9abc7b2e47f3))
+- event timeStamp check for Qt ([7591b9d](https://github.com/vuejs/vue/commit/7591b9dc6dde314f2d32dcd7a8355f696a330979)), closes [#9681](https://github.com/vuejs/vue/issues/9681)
+- **scheduler:** fix getNow check in IE9 ([#9647](https://github.com/vuejs/vue/issues/9647)) ([da77d6a](https://github.com/vuejs/vue/commit/da77d6a98bdccd8a2c8bfdfe6b9cb46efcb1193c)), closes [#9632](https://github.com/vuejs/vue/issues/9632)
+- **scheduler:** getNow detection can randomly fail ([#9667](https://github.com/vuejs/vue/issues/9667)) ([ef2a380](https://github.com/vuejs/vue/commit/ef2a380c6eb6bd1a7ff516c357dafa717e75a745))
+- should consider presence of normal slots when caching normalized scoped slots ([9313cf9](https://github.com/vuejs/vue/commit/9313cf91740e1d43c43cf9e73d905dbab913beb5)), closes [#9644](https://github.com/vuejs/vue/issues/9644)
+- should not swallow user catch on rejected promise in methods ([7186940](https://github.com/vuejs/vue/commit/7186940143704acc4ec046132f6a56e9c983e510)), closes [#9694](https://github.com/vuejs/vue/issues/9694)
+- should use fallback for scoped slots with single falsy v-if ([781c705](https://github.com/vuejs/vue/commit/781c70514e01bc402828946805bfad7437c7175e)), closes [#9658](https://github.com/vuejs/vue/issues/9658)
+- **ssr:** fix nested async functional componet rendering ([#9673](https://github.com/vuejs/vue/issues/9673)) ([8082d2f](https://github.com/vuejs/vue/commit/8082d2f910d963f14c151fb445e0fcc5c975cca9)), closes [#9643](https://github.com/vuejs/vue/issues/9643)
+- **ssr:** not push non-async css files into map ([#9677](https://github.com/vuejs/vue/issues/9677)) ([d282400](https://github.com/vuejs/vue/commit/d28240009c4c49fb2ef42a79206f0d9ad03f736c))
+- **transition:** fix appear check for transition wrapper components ([#9668](https://github.com/vuejs/vue/issues/9668)) ([4de4649](https://github.com/vuejs/vue/commit/4de4649d9637262a9b007720b59f80ac72a5620c))
+- v-bind object should be overridable by single bindings ([#9653](https://github.com/vuejs/vue/issues/9653)) ([0b57380](https://github.com/vuejs/vue/commit/0b57380f10986c6b07e3c240acc06bfd2eddfd1b)), closes [#9641](https://github.com/vuejs/vue/issues/9641)
 
 ## [2.6.8](https://github.com/vuejs/vue/compare/v2.6.7...v2.6.8) (2019-03-01)
 
-
 ### Bug Fixes
 
-* avoid compression of unicode sequences by using regexps ([#9595](https://github.com/vuejs/vue/issues/9595)) ([7912f75](https://github.com/vuejs/vue/commit/7912f75c5eb09e0aef3e4bfd8a3bb78cad7540d7)), closes [#9456](https://github.com/vuejs/vue/issues/9456)
-* **compiler:** set end location for incomplete elements ([#9598](https://github.com/vuejs/vue/issues/9598)) ([cbad54a](https://github.com/vuejs/vue/commit/cbad54aa52847cfc934bb925d53c53ee57fc153d))
-* fix modifier parsing for dynamic argument with deep path ([#9585](https://github.com/vuejs/vue/issues/9585)) ([060c3b9](https://github.com/vuejs/vue/commit/060c3b98efa44a9f21bcc038a2593b1cc3c782e9)), closes [#9577](https://github.com/vuejs/vue/issues/9577)
-* further adjust max stack size ([571a488](https://github.com/vuejs/vue/commit/571a4880fc06b491a280325b79fd4cbb59ceb47e)), closes [#9562](https://github.com/vuejs/vue/issues/9562)
-* handle async component when parent is toggled before resolve ([#9572](https://github.com/vuejs/vue/issues/9572)) ([ed34113](https://github.com/vuejs/vue/commit/ed341137b23315b76ba391db1b0e537950c091e1)), closes [#9571](https://github.com/vuejs/vue/issues/9571)
-* scoped slots dynamic check should include v-for on element itself ([2277b23](https://github.com/vuejs/vue/commit/2277b2322cf81b5830a5b85f6600e1896edc7aa9)), closes [#9596](https://github.com/vuejs/vue/issues/9596)
-* **types:** allow scoped slots to return a single VNode ([#9563](https://github.com/vuejs/vue/issues/9563)) ([241eea1](https://github.com/vuejs/vue/commit/241eea19a64550bfdb3f9d7e4197127997572842))
-* **types:** update this for nextTick api ([#9541](https://github.com/vuejs/vue/issues/9541)) ([f333016](https://github.com/vuejs/vue/commit/f33301619d18b9392597c5230af17921c0b42466))
-
-
+- avoid compression of unicode sequences by using regexps ([#9595](https://github.com/vuejs/vue/issues/9595)) ([7912f75](https://github.com/vuejs/vue/commit/7912f75c5eb09e0aef3e4bfd8a3bb78cad7540d7)), closes [#9456](https://github.com/vuejs/vue/issues/9456)
+- **compiler:** set end location for incomplete elements ([#9598](https://github.com/vuejs/vue/issues/9598)) ([cbad54a](https://github.com/vuejs/vue/commit/cbad54aa52847cfc934bb925d53c53ee57fc153d))
+- fix modifier parsing for dynamic argument with deep path ([#9585](https://github.com/vuejs/vue/issues/9585)) ([060c3b9](https://github.com/vuejs/vue/commit/060c3b98efa44a9f21bcc038a2593b1cc3c782e9)), closes [#9577](https://github.com/vuejs/vue/issues/9577)
+- further adjust max stack size ([571a488](https://github.com/vuejs/vue/commit/571a4880fc06b491a280325b79fd4cbb59ceb47e)), closes [#9562](https://github.com/vuejs/vue/issues/9562)
+- handle async component when parent is toggled before resolve ([#9572](https://github.com/vuejs/vue/issues/9572)) ([ed34113](https://github.com/vuejs/vue/commit/ed341137b23315b76ba391db1b0e537950c091e1)), closes [#9571](https://github.com/vuejs/vue/issues/9571)
+- scoped slots dynamic check should include v-for on element itself ([2277b23](https://github.com/vuejs/vue/commit/2277b2322cf81b5830a5b85f6600e1896edc7aa9)), closes [#9596](https://github.com/vuejs/vue/issues/9596)
+- **types:** allow scoped slots to return a single VNode ([#9563](https://github.com/vuejs/vue/issues/9563)) ([241eea1](https://github.com/vuejs/vue/commit/241eea19a64550bfdb3f9d7e4197127997572842))
+- **types:** update this for nextTick api ([#9541](https://github.com/vuejs/vue/issues/9541)) ([f333016](https://github.com/vuejs/vue/commit/f33301619d18b9392597c5230af17921c0b42466))
 
 ## [2.6.7](https://github.com/vuejs/vue/compare/v2.6.6...v2.6.7) (2019-02-21)
 
-
 ### Bug Fixes
 
-* **#9511:** avoid promise catch multiple times ([#9526](https://github.com/vuejs/vue/issues/9526)) ([2f3020e](https://github.com/vuejs/vue/commit/2f3020e9cc1ad5c878606b56bb73a30b1d9bb7d9)), closes [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511)
-* avoid errors thrown during dom props update ([8a80a23](https://github.com/vuejs/vue/commit/8a80a23ecba23f92f278d664388050ffcd121385)), closes [#9459](https://github.com/vuejs/vue/issues/9459)
-* avoid possible infinite loop by accessing observables in error handler ([#9489](https://github.com/vuejs/vue/issues/9489)) ([ee29e41](https://github.com/vuejs/vue/commit/ee29e41ef469b3ca3c793f04289075e3b128447f))
-* **compiler:** handle negative length in codeframe repeat ([7a8de91](https://github.com/vuejs/vue/commit/7a8de91cd78f523fabe8452652513250871a01c6))
-* ensure generated scoped slot code is compatible with 2.5 ([7ec4627](https://github.com/vuejs/vue/commit/7ec4627902020cccd7b3f4fbc63e1b0d6b9798cd)), closes [#9545](https://github.com/vuejs/vue/issues/9545)
-* ensure scoped slots update in conditional branches ([d9b27a9](https://github.com/vuejs/vue/commit/d9b27a92bd5277ee23a4e68a8bd31ecc72f4c99b)), closes [#9534](https://github.com/vuejs/vue/issues/9534)
-* scoped slots should update when inside v-for ([8f004ea](https://github.com/vuejs/vue/commit/8f004ea44e06d7764fa884212fa95c2033515928)), closes [#9506](https://github.com/vuejs/vue/issues/9506)
-
-
+- **#9511:** avoid promise catch multiple times ([#9526](https://github.com/vuejs/vue/issues/9526)) ([2f3020e](https://github.com/vuejs/vue/commit/2f3020e9cc1ad5c878606b56bb73a30b1d9bb7d9)), closes [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511) [#9511](https://github.com/vuejs/vue/issues/9511)
+- avoid errors thrown during dom props update ([8a80a23](https://github.com/vuejs/vue/commit/8a80a23ecba23f92f278d664388050ffcd121385)), closes [#9459](https://github.com/vuejs/vue/issues/9459)
+- avoid possible infinite loop by accessing observables in error handler ([#9489](https://github.com/vuejs/vue/issues/9489)) ([ee29e41](https://github.com/vuejs/vue/commit/ee29e41ef469b3ca3c793f04289075e3b128447f))
+- **compiler:** handle negative length in codeframe repeat ([7a8de91](https://github.com/vuejs/vue/commit/7a8de91cd78f523fabe8452652513250871a01c6))
+- ensure generated scoped slot code is compatible with 2.5 ([7ec4627](https://github.com/vuejs/vue/commit/7ec4627902020cccd7b3f4fbc63e1b0d6b9798cd)), closes [#9545](https://github.com/vuejs/vue/issues/9545)
+- ensure scoped slots update in conditional branches ([d9b27a9](https://github.com/vuejs/vue/commit/d9b27a92bd5277ee23a4e68a8bd31ecc72f4c99b)), closes [#9534](https://github.com/vuejs/vue/issues/9534)
+- scoped slots should update when inside v-for ([8f004ea](https://github.com/vuejs/vue/commit/8f004ea44e06d7764fa884212fa95c2033515928)), closes [#9506](https://github.com/vuejs/vue/issues/9506)
 
 ## [2.6.6](https://github.com/vuejs/vue/compare/v2.6.5...v2.6.6) (2019-02-12)
 
-
 ### Bug Fixes
 
-* ensure scoped slot containing passed down slot content updates properly ([21fca2f](https://github.com/vuejs/vue/commit/21fca2fffc3a75235a6656eb85ae40835e04bf69))
-* fix keyCode check for Chrome autofill fake key events ([29c348f](https://github.com/vuejs/vue/commit/29c348f3cf60c50a52cc98123f8c54fa8f5672fc)), closes [#9441](https://github.com/vuejs/vue/issues/9441)
-
-
+- ensure scoped slot containing passed down slot content updates properly ([21fca2f](https://github.com/vuejs/vue/commit/21fca2fffc3a75235a6656eb85ae40835e04bf69))
+- fix keyCode check for Chrome autofill fake key events ([29c348f](https://github.com/vuejs/vue/commit/29c348f3cf60c50a52cc98123f8c54fa8f5672fc)), closes [#9441](https://github.com/vuejs/vue/issues/9441)
 
 ## [2.6.5](https://github.com/vuejs/vue/compare/v2.6.4...v2.6.5) (2019-02-11)
 
-
 ### Bug Fixes
 
-* allow passing multiple arguments to scoped slot ([e7d49cd](https://github.com/vuejs/vue/commit/e7d49cdcf2fd9a612e0dac7a7bea318824210881)), closes [#9468](https://github.com/vuejs/vue/issues/9468)
-* bail out of event blocking for iOS bug ([0bad7e2](https://github.com/vuejs/vue/commit/0bad7e2a3508b55abaa8aec2a1bd9c1127305cb4)), closes [#9462](https://github.com/vuejs/vue/issues/9462)
-* do not cache scoped slots when mixed with normal slots ([060686d](https://github.com/vuejs/vue/commit/060686d6ea4d013129b4d2e93d7d2e5c93e09686))
-
-
+- allow passing multiple arguments to scoped slot ([e7d49cd](https://github.com/vuejs/vue/commit/e7d49cdcf2fd9a612e0dac7a7bea318824210881)), closes [#9468](https://github.com/vuejs/vue/issues/9468)
+- bail out of event blocking for iOS bug ([0bad7e2](https://github.com/vuejs/vue/commit/0bad7e2a3508b55abaa8aec2a1bd9c1127305cb4)), closes [#9462](https://github.com/vuejs/vue/issues/9462)
+- do not cache scoped slots when mixed with normal slots ([060686d](https://github.com/vuejs/vue/commit/060686d6ea4d013129b4d2e93d7d2e5c93e09686))
 
 ## [2.6.4](https://github.com/vuejs/vue/compare/v2.6.3...v2.6.4) (2019-02-08)
 
-
 ### Bug Fixes
 
-* avoid breaking avoriaz edge case ([9011b83](https://github.com/vuejs/vue/commit/9011b83db79cf2f3563f8fccb2e41b5b863c3ee9))
-* avoid logging same error twice when thrown by user in global handler ([ca57920](https://github.com/vuejs/vue/commit/ca57920edb56000bfc87bb64f4e5e3450c03e13a)), closes [#9445](https://github.com/vuejs/vue/issues/9445)
-* empty scoped slot should return undefined ([57bc80a](https://github.com/vuejs/vue/commit/57bc80a546acb2bd092edd393228324b453ae4e2)), closes [#9452](https://github.com/vuejs/vue/issues/9452)
-* expose v-slot slots without scope on this.$slots ([0e8560d](https://github.com/vuejs/vue/commit/0e8560d0fc1c0fbf3a52464939701e0e44543b00)), closes [#9421](https://github.com/vuejs/vue/issues/9421) [#9458](https://github.com/vuejs/vue/issues/9458)
-* new syntax slots without scope should also be exposed on functional slots() ([8a80086](https://github.com/vuejs/vue/commit/8a800867fe61e5aa642e1e3da91bb890d07312f7))
-
+- avoid breaking avoriaz edge case ([9011b83](https://github.com/vuejs/vue/commit/9011b83db79cf2f3563f8fccb2e41b5b863c3ee9))
+- avoid logging same error twice when thrown by user in global handler ([ca57920](https://github.com/vuejs/vue/commit/ca57920edb56000bfc87bb64f4e5e3450c03e13a)), closes [#9445](https://github.com/vuejs/vue/issues/9445)
+- empty scoped slot should return undefined ([57bc80a](https://github.com/vuejs/vue/commit/57bc80a546acb2bd092edd393228324b453ae4e2)), closes [#9452](https://github.com/vuejs/vue/issues/9452)
+- expose v-slot slots without scope on this.$slots ([0e8560d](https://github.com/vuejs/vue/commit/0e8560d0fc1c0fbf3a52464939701e0e44543b00)), closes [#9421](https://github.com/vuejs/vue/issues/9421) [#9458](https://github.com/vuejs/vue/issues/9458)
+- new syntax slots without scope should also be exposed on functional slots() ([8a80086](https://github.com/vuejs/vue/commit/8a800867fe61e5aa642e1e3da91bb890d07312f7))
 
 ### Performance Improvements
 
-* cache result from functional ctx.slots() calls ([7a0dfd0](https://github.com/vuejs/vue/commit/7a0dfd0badf3054c95ac1ec66cc6e213f1592c95))
-* skip scoped slots normalization when possible ([099f3ba](https://github.com/vuejs/vue/commit/099f3ba60085a089ff369442bdb835f3868e47c0))
-
-
+- cache result from functional ctx.slots() calls ([7a0dfd0](https://github.com/vuejs/vue/commit/7a0dfd0badf3054c95ac1ec66cc6e213f1592c95))
+- skip scoped slots normalization when possible ([099f3ba](https://github.com/vuejs/vue/commit/099f3ba60085a089ff369442bdb835f3868e47c0))
 
 ## [2.6.3](https://github.com/vuejs/vue/compare/v2.6.2...v2.6.3) (2019-02-06)
 
-
 ### Bug Fixes
 
-* async component should use render owner as force update context ([b9de23b](https://github.com/vuejs/vue/commit/b9de23b1008b52deca7e7df40843e318a42f3f53)), closes [#9432](https://github.com/vuejs/vue/issues/9432)
-* avoid exposing internal flags on $scopedSlots ([24b4640](https://github.com/vuejs/vue/commit/24b4640c1f268722f5ab8f03e68e2df897cfbdf6)), closes [#9443](https://github.com/vuejs/vue/issues/9443)
-* bail out scoped slot optimization when there are nested scopes ([4d4d22a](https://github.com/vuejs/vue/commit/4d4d22a3f6017c46d08b67afe46af43027b06629)), closes [#9438](https://github.com/vuejs/vue/issues/9438)
-* **compiler:** fix v-bind dynamic arguments on slot outlets ([96a09aa](https://github.com/vuejs/vue/commit/96a09aad99bdecbcc0e5c420077bf41893d4a745)), closes [#9444](https://github.com/vuejs/vue/issues/9444)
-* skip microtask fix if event is fired from different document ([dae7e41](https://github.com/vuejs/vue/commit/dae7e4182fbbb41e599953cc22e5d54dbb164070)), closes [#9448](https://github.com/vuejs/vue/issues/9448)
-* skip microtask fix in Firefix <= 53 ([7bc88f3](https://github.com/vuejs/vue/commit/7bc88f30c3eadded07dd5b460d1e7cb9342d017c)), closes [#9446](https://github.com/vuejs/vue/issues/9446)
-* **types:** add Vue.version to types ([#9431](https://github.com/vuejs/vue/issues/9431)) ([54e6a12](https://github.com/vuejs/vue/commit/54e6a121e992f20c03f104533caa4c59e59b1ee7))
-
+- async component should use render owner as force update context ([b9de23b](https://github.com/vuejs/vue/commit/b9de23b1008b52deca7e7df40843e318a42f3f53)), closes [#9432](https://github.com/vuejs/vue/issues/9432)
+- avoid exposing internal flags on $scopedSlots ([24b4640](https://github.com/vuejs/vue/commit/24b4640c1f268722f5ab8f03e68e2df897cfbdf6)), closes [#9443](https://github.com/vuejs/vue/issues/9443)
+- bail out scoped slot optimization when there are nested scopes ([4d4d22a](https://github.com/vuejs/vue/commit/4d4d22a3f6017c46d08b67afe46af43027b06629)), closes [#9438](https://github.com/vuejs/vue/issues/9438)
+- **compiler:** fix v-bind dynamic arguments on slot outlets ([96a09aa](https://github.com/vuejs/vue/commit/96a09aad99bdecbcc0e5c420077bf41893d4a745)), closes [#9444](https://github.com/vuejs/vue/issues/9444)
+- skip microtask fix if event is fired from different document ([dae7e41](https://github.com/vuejs/vue/commit/dae7e4182fbbb41e599953cc22e5d54dbb164070)), closes [#9448](https://github.com/vuejs/vue/issues/9448)
+- skip microtask fix in Firefix <= 53 ([7bc88f3](https://github.com/vuejs/vue/commit/7bc88f30c3eadded07dd5b460d1e7cb9342d017c)), closes [#9446](https://github.com/vuejs/vue/issues/9446)
+- **types:** add Vue.version to types ([#9431](https://github.com/vuejs/vue/issues/9431)) ([54e6a12](https://github.com/vuejs/vue/commit/54e6a121e992f20c03f104533caa4c59e59b1ee7))
 
 ### Reverts
 
-* feat: expose all scoped slots on this.$slots ([d5ade28](https://github.com/vuejs/vue/commit/d5ade28652b07303ac6b713813792752ae5e4e04))
-
-
+- feat: expose all scoped slots on this.$slots ([d5ade28](https://github.com/vuejs/vue/commit/d5ade28652b07303ac6b713813792752ae5e4e04))
 
 ## [2.6.2](https://github.com/vuejs/vue/compare/v2.6.1...v2.6.2) (2019-02-05)
 
-
 ### Bug Fixes
 
-* always set transformed model value on attrs ([b034abf](https://github.com/vuejs/vue/commit/b034abf48e793189ce8796c259eed2fbfb79bcd0))
-* restore slot-scope + v-if behavior ([44a4ca3](https://github.com/vuejs/vue/commit/44a4ca33b95070e9aa53c6924479519d86dd9b36)), closes [#9422](https://github.com/vuejs/vue/issues/9422)
-
+- always set transformed model value on attrs ([b034abf](https://github.com/vuejs/vue/commit/b034abf48e793189ce8796c259eed2fbfb79bcd0))
+- restore slot-scope + v-if behavior ([44a4ca3](https://github.com/vuejs/vue/commit/44a4ca33b95070e9aa53c6924479519d86dd9b36)), closes [#9422](https://github.com/vuejs/vue/issues/9422)
 
 ### Features
 
-* expose all scoped slots on this.$slots ([0129b0e](https://github.com/vuejs/vue/commit/0129b0eb12a1f98a722f100892bfc5e60b0f51ce)), closes [#9421](https://github.com/vuejs/vue/issues/9421)
-
-
+- expose all scoped slots on this.$slots ([0129b0e](https://github.com/vuejs/vue/commit/0129b0eb12a1f98a722f100892bfc5e60b0f51ce)), closes [#9421](https://github.com/vuejs/vue/issues/9421)
 
 ## [2.6.1](https://github.com/vuejs/vue/compare/v2.6.0...v2.6.1) (2019-02-04)
 
-
 ### Bug Fixes
 
-* avoid blocking first input event in IE when it shouldn't ([#9297](https://github.com/vuejs/vue/issues/9297)) ([0fb03b7](https://github.com/vuejs/vue/commit/0fb03b7831693b4abc90dd0bfe971c36c02d82a6)), closes [#7138](https://github.com/vuejs/vue/issues/7138) [#9042](https://github.com/vuejs/vue/issues/9042) [#9383](https://github.com/vuejs/vue/issues/9383)
-* avoid isPromise check when handler return value is Vue instance ([b6b42ca](https://github.com/vuejs/vue/commit/b6b42ca8c41963be292caa266ce4330603f4c4eb)), closes [#9418](https://github.com/vuejs/vue/issues/9418)
-* **compiler:** fix inline-template crashing ([#9365](https://github.com/vuejs/vue/issues/9365)) ([55bfb94](https://github.com/vuejs/vue/commit/55bfb94a33ecc9b33131ec0fb78bba2946e8fc75)), closes [#9361](https://github.com/vuejs/vue/issues/9361)
-* decode single quotes in html attributes ([#9341](https://github.com/vuejs/vue/issues/9341)) ([c27fe24](https://github.com/vuejs/vue/commit/c27fe24dc6088b517ab17c799a1852f97c22c076))
-* **template-compiler:** allow comments on the root node in templates ([#9408](https://github.com/vuejs/vue/issues/9408)) ([1922e7d](https://github.com/vuejs/vue/commit/1922e7d4d99d0397223b3919a1643aacb7afbbab)), closes [#9407](https://github.com/vuejs/vue/issues/9407)
-* **v-model:** add value to $attrs if not defined in props ([#9331](https://github.com/vuejs/vue/issues/9331)) ([66fd3c8](https://github.com/vuejs/vue/commit/66fd3c8dd1577d4b634731adf4be4d3db5bf1df6)), closes [#9330](https://github.com/vuejs/vue/issues/9330)
-
-
+- avoid blocking first input event in IE when it shouldn't ([#9297](https://github.com/vuejs/vue/issues/9297)) ([0fb03b7](https://github.com/vuejs/vue/commit/0fb03b7831693b4abc90dd0bfe971c36c02d82a6)), closes [#7138](https://github.com/vuejs/vue/issues/7138) [#9042](https://github.com/vuejs/vue/issues/9042) [#9383](https://github.com/vuejs/vue/issues/9383)
+- avoid isPromise check when handler return value is Vue instance ([b6b42ca](https://github.com/vuejs/vue/commit/b6b42ca8c41963be292caa266ce4330603f4c4eb)), closes [#9418](https://github.com/vuejs/vue/issues/9418)
+- **compiler:** fix inline-template crashing ([#9365](https://github.com/vuejs/vue/issues/9365)) ([55bfb94](https://github.com/vuejs/vue/commit/55bfb94a33ecc9b33131ec0fb78bba2946e8fc75)), closes [#9361](https://github.com/vuejs/vue/issues/9361)
+- decode single quotes in html attributes ([#9341](https://github.com/vuejs/vue/issues/9341)) ([c27fe24](https://github.com/vuejs/vue/commit/c27fe24dc6088b517ab17c799a1852f97c22c076))
+- **template-compiler:** allow comments on the root node in templates ([#9408](https://github.com/vuejs/vue/issues/9408)) ([1922e7d](https://github.com/vuejs/vue/commit/1922e7d4d99d0397223b3919a1643aacb7afbbab)), closes [#9407](https://github.com/vuejs/vue/issues/9407)
+- **v-model:** add value to $attrs if not defined in props ([#9331](https://github.com/vuejs/vue/issues/9331)) ([66fd3c8](https://github.com/vuejs/vue/commit/66fd3c8dd1577d4b634731adf4be4d3db5bf1df6)), closes [#9330](https://github.com/vuejs/vue/issues/9330)
 
 # [2.6.0](https://github.com/vuejs/vue/compare/v2.6.0-beta.3...v2.6.0) (2019-02-04)
 
-
 ### Bug Fixes
 
-* allow more enumerated values for contenteditable ([e632e9a](https://github.com/vuejs/vue/commit/e632e9a0759532e1d902871ca07b02c9ac267e7c)), closes [#9397](https://github.com/vuejs/vue/issues/9397)
-* fix child forceUpdate regression ([44a17ba](https://github.com/vuejs/vue/commit/44a17ba2cde7fb9a673486d44de7f29feb5c1882)), closes [#9396](https://github.com/vuejs/vue/issues/9396)
-* fix v-bind:style for camelCase properties with !important  ([#9386](https://github.com/vuejs/vue/issues/9386)) ([539e481](https://github.com/vuejs/vue/commit/539e481f38706a6202f0eacf54c579362fbd5bb4))
-* template v-slot should work with v-else conditions ([2807fd2](https://github.com/vuejs/vue/commit/2807fd24b0c17179336f84d1725b69cd3c7a0aca))
-
+- allow more enumerated values for contenteditable ([e632e9a](https://github.com/vuejs/vue/commit/e632e9a0759532e1d902871ca07b02c9ac267e7c)), closes [#9397](https://github.com/vuejs/vue/issues/9397)
+- fix child forceUpdate regression ([44a17ba](https://github.com/vuejs/vue/commit/44a17ba2cde7fb9a673486d44de7f29feb5c1882)), closes [#9396](https://github.com/vuejs/vue/issues/9396)
+- fix v-bind:style for camelCase properties with !important ([#9386](https://github.com/vuejs/vue/issues/9386)) ([539e481](https://github.com/vuejs/vue/commit/539e481f38706a6202f0eacf54c579362fbd5bb4))
+- template v-slot should work with v-else conditions ([2807fd2](https://github.com/vuejs/vue/commit/2807fd24b0c17179336f84d1725b69cd3c7a0aca))
 
 ### Features
 
-* move v-bind.prop shorthand behind flag ([64f863b](https://github.com/vuejs/vue/commit/64f863bbb9c8147819ef4547dfdadba0239c6d59))
-
-
+- move v-bind.prop shorthand behind flag ([64f863b](https://github.com/vuejs/vue/commit/64f863bbb9c8147819ef4547dfdadba0239c6d59))
 
 # [2.6.0-beta.3](https://github.com/vuejs/vue/compare/v2.6.0-beta.2...v2.6.0-beta.3) (2019-01-30)
 
-
 ### Features
 
-* detect and warn invalid dynamic argument expressions ([c9e3a5d](https://github.com/vuejs/vue/commit/c9e3a5d1d92500ac1e1d1eb6f3866a9df5eecf53))
-
-
+- detect and warn invalid dynamic argument expressions ([c9e3a5d](https://github.com/vuejs/vue/commit/c9e3a5d1d92500ac1e1d1eb6f3866a9df5eecf53))
 
 # [2.6.0-beta.2](https://github.com/vuejs/vue/compare/v2.6.0-beta.1...v2.6.0-beta.2) (2019-01-26)
 
-
 ### Bug Fixes
 
-* async edge case fix should apply to more browsers ([ba0ebd4](https://github.com/vuejs/vue/commit/ba0ebd4771ddb5c56c1261f82c842b57ca7163a6))
-* fix checkbox event edge case in Firefox ([1868561](https://github.com/vuejs/vue/commit/1868561442507690f07579c258f4db19a650fb9a))
-
+- async edge case fix should apply to more browsers ([ba0ebd4](https://github.com/vuejs/vue/commit/ba0ebd4771ddb5c56c1261f82c842b57ca7163a6))
+- fix checkbox event edge case in Firefox ([1868561](https://github.com/vuejs/vue/commit/1868561442507690f07579c258f4db19a650fb9a))
 
 ### Features
 
-* adjust v-slot per RFC + enable flag ([67e85de](https://github.com/vuejs/vue/commit/67e85deae2b9720624ed7b20223b905a882942a0))
-* dynamic directive arguments for v-on, v-bind and custom directives ([#9373](https://github.com/vuejs/vue/issues/9373)) ([dbc0582](https://github.com/vuejs/vue/commit/dbc0582587f90e78867809bb6ae683301cd0626b))
-* **ssr:** allow template option to be function in renderToString ([#9324](https://github.com/vuejs/vue/issues/9324)) ([b65f6d7](https://github.com/vuejs/vue/commit/b65f6d78e0e480601b0042b1b5e8259343b629fb))
-* update new slot syntax per RFC revision ([4fca045](https://github.com/vuejs/vue/commit/4fca0454bd716a5d3ba32057ff2ed510af933c8d))
-* warning for ambiguous v-slot usage ([8d84572](https://github.com/vuejs/vue/commit/8d8457246daac543c5935aa3cbf62d362431da43))
-
+- adjust v-slot per RFC + enable flag ([67e85de](https://github.com/vuejs/vue/commit/67e85deae2b9720624ed7b20223b905a882942a0))
+- dynamic directive arguments for v-on, v-bind and custom directives ([#9373](https://github.com/vuejs/vue/issues/9373)) ([dbc0582](https://github.com/vuejs/vue/commit/dbc0582587f90e78867809bb6ae683301cd0626b))
+- **ssr:** allow template option to be function in renderToString ([#9324](https://github.com/vuejs/vue/issues/9324)) ([b65f6d7](https://github.com/vuejs/vue/commit/b65f6d78e0e480601b0042b1b5e8259343b629fb))
+- update new slot syntax per RFC revision ([4fca045](https://github.com/vuejs/vue/commit/4fca0454bd716a5d3ba32057ff2ed510af933c8d))
+- warning for ambiguous v-slot usage ([8d84572](https://github.com/vuejs/vue/commit/8d8457246daac543c5935aa3cbf62d362431da43))
 
 ### Performance Improvements
 
-* improve scoped slots change detection accuracy ([#9371](https://github.com/vuejs/vue/issues/9371)) ([f219bed](https://github.com/vuejs/vue/commit/f219bedae8f9cab131eb5529769bcfdc91ce2912))
-
-
+- improve scoped slots change detection accuracy ([#9371](https://github.com/vuejs/vue/issues/9371)) ([f219bed](https://github.com/vuejs/vue/commit/f219bedae8f9cab131eb5529769bcfdc91ce2912))
 
 # [2.6.0-beta.1](https://github.com/vuejs/vue/compare/v2.5.22...v2.6.0-beta.1) (2019-01-16)
 
-
 ### Bug Fixes
 
-* allow _ in watch paths (element compat) ([8b382b3](https://github.com/vuejs/vue/commit/8b382b3efb14986e9ea5213d0b57c244b70ae0e7))
-* always use microtasks for nextTick ([#8450](https://github.com/vuejs/vue/issues/8450)) ([850555d](https://github.com/vuejs/vue/commit/850555d1faa9be7d8306adffd95c7dee5e58717f)), closes [#7109](https://github.com/vuejs/vue/issues/7109) [#7546](https://github.com/vuejs/vue/issues/7546) [#7707](https://github.com/vuejs/vue/issues/7707) [#7834](https://github.com/vuejs/vue/issues/7834) [#8109](https://github.com/vuejs/vue/issues/8109) [#6566](https://github.com/vuejs/vue/issues/6566)
-* **core:** dedupe lifecycle hooks during options merge ([edf7df0](https://github.com/vuejs/vue/commit/edf7df0c837557dd3ea8d7b42ad8d4b21858ade0)), closes [#9199](https://github.com/vuejs/vue/issues/9199)
-* **core:** fix merged twice bug when passing extended constructor to mixins ([#9199](https://github.com/vuejs/vue/issues/9199)) ([5371617](https://github.com/vuejs/vue/commit/537161779ea329c1d0a993997555f1c692b8cac1)), closes [#9198](https://github.com/vuejs/vue/issues/9198)
-* cover more cases in v-on inline return value ([9432737](https://github.com/vuejs/vue/commit/9432737cf871335c42ce0dc0a0baa21a4d8c3832))
-* ensure only nromalize a scoped slot when it is present ([5fb23d4](https://github.com/vuejs/vue/commit/5fb23d4e2971480d14fbee0146e3416a07bc0b9f))
-* ensure proxied normal slot uses correct key ([b32c4b6](https://github.com/vuejs/vue/commit/b32c4b693535c35ae10742eb3351cbc123b15941))
-* make transition-group key warning a tip to avoid breaking compilation ([d08b49f](https://github.com/vuejs/vue/commit/d08b49f520e0704f9d4e61be4f751e3b2cdac6a8))
-* **next-tick:** revert 60da366 ([080dd97](https://github.com/vuejs/vue/commit/080dd971f77f7c631650c4e3027d1802f4e804d8)), closes [#8436](https://github.com/vuejs/vue/issues/8436)
-* **provide/inject:** Merges symbol provides ([#7926](https://github.com/vuejs/vue/issues/7926)) ([1933ee8](https://github.com/vuejs/vue/commit/1933ee80ff808b81a691fa6a135c1588d218bc0a))
-* return inline invocation return value in v-on handlers ([0ebb0f3](https://github.com/vuejs/vue/commit/0ebb0f39dfee0a5c03adb2f312f617cca37b44d6)), closes [#7628](https://github.com/vuejs/vue/issues/7628)
-* **runtime:** DevTools recommendation shows for all browsers ([#8638](https://github.com/vuejs/vue/issues/8638)) ([22ad266](https://github.com/vuejs/vue/commit/22ad26615104c15fd09bc69692e3042bb1bb58e9)), closes [#8634](https://github.com/vuejs/vue/issues/8634)
-* **scoped-slots:** ensure $scopedSlots calls always return Arrays ([c7c13c2](https://github.com/vuejs/vue/commit/c7c13c2a156269d29fd9c9f8f6a3e53a2f2cac3d)), closes [#8056](https://github.com/vuejs/vue/issues/8056)
-* **ssr:** properly handle invalid and numeric style properties ([7d9cfeb](https://github.com/vuejs/vue/commit/7d9cfebe39ffd531e0948668e688474b276cdec1)), closes [#9231](https://github.com/vuejs/vue/issues/9231)
-* **ssr:** should not render invalid numeric style values ([17d8bcb](https://github.com/vuejs/vue/commit/17d8bcb60edc14b2c23f5e6cc92f030897092e21))
-* **ssr:** should render 0 as valid value for style property with unit ([aef5b4e](https://github.com/vuejs/vue/commit/aef5b4e47811cb842315bd27d6919650da45279b))
-
+- allow \_ in watch paths (element compat) ([8b382b3](https://github.com/vuejs/vue/commit/8b382b3efb14986e9ea5213d0b57c244b70ae0e7))
+- always use microtasks for nextTick ([#8450](https://github.com/vuejs/vue/issues/8450)) ([850555d](https://github.com/vuejs/vue/commit/850555d1faa9be7d8306adffd95c7dee5e58717f)), closes [#7109](https://github.com/vuejs/vue/issues/7109) [#7546](https://github.com/vuejs/vue/issues/7546) [#7707](https://github.com/vuejs/vue/issues/7707) [#7834](https://github.com/vuejs/vue/issues/7834) [#8109](https://github.com/vuejs/vue/issues/8109) [#6566](https://github.com/vuejs/vue/issues/6566)
+- **core:** dedupe lifecycle hooks during options merge ([edf7df0](https://github.com/vuejs/vue/commit/edf7df0c837557dd3ea8d7b42ad8d4b21858ade0)), closes [#9199](https://github.com/vuejs/vue/issues/9199)
+- **core:** fix merged twice bug when passing extended constructor to mixins ([#9199](https://github.com/vuejs/vue/issues/9199)) ([5371617](https://github.com/vuejs/vue/commit/537161779ea329c1d0a993997555f1c692b8cac1)), closes [#9198](https://github.com/vuejs/vue/issues/9198)
+- cover more cases in v-on inline return value ([9432737](https://github.com/vuejs/vue/commit/9432737cf871335c42ce0dc0a0baa21a4d8c3832))
+- ensure only nromalize a scoped slot when it is present ([5fb23d4](https://github.com/vuejs/vue/commit/5fb23d4e2971480d14fbee0146e3416a07bc0b9f))
+- ensure proxied normal slot uses correct key ([b32c4b6](https://github.com/vuejs/vue/commit/b32c4b693535c35ae10742eb3351cbc123b15941))
+- make transition-group key warning a tip to avoid breaking compilation ([d08b49f](https://github.com/vuejs/vue/commit/d08b49f520e0704f9d4e61be4f751e3b2cdac6a8))
+- **next-tick:** revert 60da366 ([080dd97](https://github.com/vuejs/vue/commit/080dd971f77f7c631650c4e3027d1802f4e804d8)), closes [#8436](https://github.com/vuejs/vue/issues/8436)
+- **provide/inject:** Merges symbol provides ([#7926](https://github.com/vuejs/vue/issues/7926)) ([1933ee8](https://github.com/vuejs/vue/commit/1933ee80ff808b81a691fa6a135c1588d218bc0a))
+- return inline invocation return value in v-on handlers ([0ebb0f3](https://github.com/vuejs/vue/commit/0ebb0f39dfee0a5c03adb2f312f617cca37b44d6)), closes [#7628](https://github.com/vuejs/vue/issues/7628)
+- **runtime:** DevTools recommendation shows for all browsers ([#8638](https://github.com/vuejs/vue/issues/8638)) ([22ad266](https://github.com/vuejs/vue/commit/22ad26615104c15fd09bc69692e3042bb1bb58e9)), closes [#8634](https://github.com/vuejs/vue/issues/8634)
+- **scoped-slots:** ensure $scopedSlots calls always return Arrays ([c7c13c2](https://github.com/vuejs/vue/commit/c7c13c2a156269d29fd9c9f8f6a3e53a2f2cac3d)), closes [#8056](https://github.com/vuejs/vue/issues/8056)
+- **ssr:** properly handle invalid and numeric style properties ([7d9cfeb](https://github.com/vuejs/vue/commit/7d9cfebe39ffd531e0948668e688474b276cdec1)), closes [#9231](https://github.com/vuejs/vue/issues/9231)
+- **ssr:** should not render invalid numeric style values ([17d8bcb](https://github.com/vuejs/vue/commit/17d8bcb60edc14b2c23f5e6cc92f030897092e21))
+- **ssr:** should render 0 as valid value for style property with unit ([aef5b4e](https://github.com/vuejs/vue/commit/aef5b4e47811cb842315bd27d6919650da45279b))
 
 ### Features
 
-* add browser ESM build ([861abf4](https://github.com/vuejs/vue/commit/861abf4bb940e89a6ae3c5c3e2dad4ed0bd53b3e))
-* add Vue.observable() for explicitly creating observable objects ([c50bbde](https://github.com/vuejs/vue/commit/c50bbde41c4a1868a8a0b33df3238346840bd37c))
-* **compiler/watch:** allow unicode characters in component names and watch paths ([#8666](https://github.com/vuejs/vue/issues/8666)) ([9c71852](https://github.com/vuejs/vue/commit/9c718522bac60d13d3b48d6b6512fccfd5cf8858)), closes [#8564](https://github.com/vuejs/vue/issues/8564)
-* **compiler:** add whitespace option, deprecate preserveWhitespace option ([e1abedb](https://github.com/vuejs/vue/commit/e1abedb9e66b21da8a7e93e175b9dabe334dfebd)), closes [#9208](https://github.com/vuejs/vue/issues/9208)
-* **compiler:** expose generateCodeFrame method ([a4ed58c](https://github.com/vuejs/vue/commit/a4ed58c076649a4536b40a9c98c974c77602c76b))
-* **compiler:** output codeframe in browser compiler ([325fc76](https://github.com/vuejs/vue/commit/325fc7693c1574e69fe542f1dbc334030a4b1ec3))
-* **compiler:** output source range for compiler errors ([#7127](https://github.com/vuejs/vue/issues/7127)) ([b31a1aa](https://github.com/vuejs/vue/commit/b31a1aa8870474b2ca782c45d55edac2932d4cc2)), closes [#6338](https://github.com/vuejs/vue/issues/6338)
-* **compiler:** support deindent: false in vue-template-compiler ([#7215](https://github.com/vuejs/vue/issues/7215)) ([bf0efb0](https://github.com/vuejs/vue/commit/bf0efb02b1f52cceb0bad8588cf6c90e22349049)), closes [#7054](https://github.com/vuejs/vue/issues/7054)
-* **config:** expose config.useEventDelegation and default to false ([3be1c5d](https://github.com/vuejs/vue/commit/3be1c5d67e8bdfc9387122317bf3779261010d45))
-* **core:** expose all slots on $scopedSlots as functions ([5d52262](https://github.com/vuejs/vue/commit/5d52262f1ce56d080c3438c4773a81dc5c8397aa))
-* **errors:** sync/async error handling for lifecycle hooks and v-on handlers ([#8395](https://github.com/vuejs/vue/issues/8395)) ([6e9fcfc](https://github.com/vuejs/vue/commit/6e9fcfc81d922a1b188268bf50d7e67c07d6d662)), closes [#6953](https://github.com/vuejs/vue/issues/6953) [#7653](https://github.com/vuejs/vue/issues/7653)
-* expose performance measures ([9ae80ac](https://github.com/vuejs/vue/commit/9ae80acde59d9d149ee5e4e2097f209eac6f834f)), closes [#7570](https://github.com/vuejs/vue/issues/7570)
-* **functional:** add scopedSlots to context in functional components ([#7941](https://github.com/vuejs/vue/issues/7941)) ([fb6aa06](https://github.com/vuejs/vue/commit/fb6aa0609045e69a0b6050bc7b6466b63be8d69d))
-* new scoped slot syntax implementation update per rfc ([c5c354d](https://github.com/vuejs/vue/commit/c5c354d593d6f6344e78ca098f1ae1fa3e83d6ed))
-* **ssr:** Add 'nonce' option to context for ssr outlet script ([#8047](https://github.com/vuejs/vue/issues/8047)) ([f036cce](https://github.com/vuejs/vue/commit/f036cce16377cec328bee03a3a4069275b320312)), closes [#7479](https://github.com/vuejs/vue/issues/7479)
-* **ssr:** add custom state serializer option ([4494012](https://github.com/vuejs/vue/commit/44940121eef4e2df5f3cb3c21f3f468af8b336bc)), closes [#6614](https://github.com/vuejs/vue/issues/6614)
-* **ssr:** allow opting-out of caching by returning false in serverCacheKey ([ab24285](https://github.com/vuejs/vue/commit/ab24285458c98e25d5749beb4edebef73672de4b)), closes [#8790](https://github.com/vuejs/vue/issues/8790)
-* **ssr:** ssrPrefetch option + context.rendered hook ([#9017](https://github.com/vuejs/vue/issues/9017)) ([d7a533d](https://github.com/vuejs/vue/commit/d7a533d6f85aae52aed03202fa5ccb774f0cb2ec))
-* support .property shorthand syntax for v-bind.prop modifier ([d2902ca](https://github.com/vuejs/vue/commit/d2902ca8ec5fd184fe81479fea1318553fdb8323)), closes [#7582](https://github.com/vuejs/vue/issues/7582)
-* support custom toString() in text interpolation and v-html ([#8217](https://github.com/vuejs/vue/issues/8217)) ([0e4e45e](https://github.com/vuejs/vue/commit/0e4e45ec741416e0042c29a53bbc0e58c8663f6e)), closes [#8093](https://github.com/vuejs/vue/issues/8093)
-* support slot-props and its shorthand ([584e89d](https://github.com/vuejs/vue/commit/584e89da4ab17e1ebdae0ae10be77ef9d230c7a0))
-* support v-html for SVG elements ([#8652](https://github.com/vuejs/vue/issues/8652)) ([a981c80](https://github.com/vuejs/vue/commit/a981c80d2aedb0d56f98865e39c981819fbf65d0))
-* **types:** add Prop to main type declaration file ([#6856](https://github.com/vuejs/vue/issues/6856)) ([5791072](https://github.com/vuejs/vue/commit/57910723c6ba68386c15e095e42c1ed9603c7bcf)), closes [#6850](https://github.com/vuejs/vue/issues/6850)
-* **types:** add types for vue-template-compiler ([#7918](https://github.com/vuejs/vue/issues/7918)) ([ced774b](https://github.com/vuejs/vue/commit/ced774be6ddbc53884d7a5d395514a9f62e32336))
-* use event delegation when possible ([b7f7f27](https://github.com/vuejs/vue/commit/b7f7f2756928f409950186c5d641034f362b392a)), closes [#6566](https://github.com/vuejs/vue/issues/6566)
-* v-bind.sync also listens for kebab-case update event ([#8297](https://github.com/vuejs/vue/issues/8297)) ([3fca527](https://github.com/vuejs/vue/commit/3fca52792ef83fa58a5c28882706d9e8a039790d)), closes [#6428](https://github.com/vuejs/vue/issues/6428)
-* **v-for:** support iterables in v-for ([#8179](https://github.com/vuejs/vue/issues/8179)) ([d40eb9c](https://github.com/vuejs/vue/commit/d40eb9c2880c8dd27fedb9fbc508823a15742274))
-
-
+- add browser ESM build ([861abf4](https://github.com/vuejs/vue/commit/861abf4bb940e89a6ae3c5c3e2dad4ed0bd53b3e))
+- add Vue.observable() for explicitly creating observable objects ([c50bbde](https://github.com/vuejs/vue/commit/c50bbde41c4a1868a8a0b33df3238346840bd37c))
+- **compiler/watch:** allow unicode characters in component names and watch paths ([#8666](https://github.com/vuejs/vue/issues/8666)) ([9c71852](https://github.com/vuejs/vue/commit/9c718522bac60d13d3b48d6b6512fccfd5cf8858)), closes [#8564](https://github.com/vuejs/vue/issues/8564)
+- **compiler:** add whitespace option, deprecate preserveWhitespace option ([e1abedb](https://github.com/vuejs/vue/commit/e1abedb9e66b21da8a7e93e175b9dabe334dfebd)), closes [#9208](https://github.com/vuejs/vue/issues/9208)
+- **compiler:** expose generateCodeFrame method ([a4ed58c](https://github.com/vuejs/vue/commit/a4ed58c076649a4536b40a9c98c974c77602c76b))
+- **compiler:** output codeframe in browser compiler ([325fc76](https://github.com/vuejs/vue/commit/325fc7693c1574e69fe542f1dbc334030a4b1ec3))
+- **compiler:** output source range for compiler errors ([#7127](https://github.com/vuejs/vue/issues/7127)) ([b31a1aa](https://github.com/vuejs/vue/commit/b31a1aa8870474b2ca782c45d55edac2932d4cc2)), closes [#6338](https://github.com/vuejs/vue/issues/6338)
+- **compiler:** support deindent: false in vue-template-compiler ([#7215](https://github.com/vuejs/vue/issues/7215)) ([bf0efb0](https://github.com/vuejs/vue/commit/bf0efb02b1f52cceb0bad8588cf6c90e22349049)), closes [#7054](https://github.com/vuejs/vue/issues/7054)
+- **config:** expose config.useEventDelegation and default to false ([3be1c5d](https://github.com/vuejs/vue/commit/3be1c5d67e8bdfc9387122317bf3779261010d45))
+- **core:** expose all slots on $scopedSlots as functions ([5d52262](https://github.com/vuejs/vue/commit/5d52262f1ce56d080c3438c4773a81dc5c8397aa))
+- **errors:** sync/async error handling for lifecycle hooks and v-on handlers ([#8395](https://github.com/vuejs/vue/issues/8395)) ([6e9fcfc](https://github.com/vuejs/vue/commit/6e9fcfc81d922a1b188268bf50d7e67c07d6d662)), closes [#6953](https://github.com/vuejs/vue/issues/6953) [#7653](https://github.com/vuejs/vue/issues/7653)
+- expose performance measures ([9ae80ac](https://github.com/vuejs/vue/commit/9ae80acde59d9d149ee5e4e2097f209eac6f834f)), closes [#7570](https://github.com/vuejs/vue/issues/7570)
+- **functional:** add scopedSlots to context in functional components ([#7941](https://github.com/vuejs/vue/issues/7941)) ([fb6aa06](https://github.com/vuejs/vue/commit/fb6aa0609045e69a0b6050bc7b6466b63be8d69d))
+- new scoped slot syntax implementation update per rfc ([c5c354d](https://github.com/vuejs/vue/commit/c5c354d593d6f6344e78ca098f1ae1fa3e83d6ed))
+- **ssr:** Add 'nonce' option to context for ssr outlet script ([#8047](https://github.com/vuejs/vue/issues/8047)) ([f036cce](https://github.com/vuejs/vue/commit/f036cce16377cec328bee03a3a4069275b320312)), closes [#7479](https://github.com/vuejs/vue/issues/7479)
+- **ssr:** add custom state serializer option ([4494012](https://github.com/vuejs/vue/commit/44940121eef4e2df5f3cb3c21f3f468af8b336bc)), closes [#6614](https://github.com/vuejs/vue/issues/6614)
+- **ssr:** allow opting-out of caching by returning false in serverCacheKey ([ab24285](https://github.com/vuejs/vue/commit/ab24285458c98e25d5749beb4edebef73672de4b)), closes [#8790](https://github.com/vuejs/vue/issues/8790)
+- **ssr:** ssrPrefetch option + context.rendered hook ([#9017](https://github.com/vuejs/vue/issues/9017)) ([d7a533d](https://github.com/vuejs/vue/commit/d7a533d6f85aae52aed03202fa5ccb774f0cb2ec))
+- support .property shorthand syntax for v-bind.prop modifier ([d2902ca](https://github.com/vuejs/vue/commit/d2902ca8ec5fd184fe81479fea1318553fdb8323)), closes [#7582](https://github.com/vuejs/vue/issues/7582)
+- support custom toString() in text interpolation and v-html ([#8217](https://github.com/vuejs/vue/issues/8217)) ([0e4e45e](https://github.com/vuejs/vue/commit/0e4e45ec741416e0042c29a53bbc0e58c8663f6e)), closes [#8093](https://github.com/vuejs/vue/issues/8093)
+- support slot-props and its shorthand ([584e89d](https://github.com/vuejs/vue/commit/584e89da4ab17e1ebdae0ae10be77ef9d230c7a0))
+- support v-html for SVG elements ([#8652](https://github.com/vuejs/vue/issues/8652)) ([a981c80](https://github.com/vuejs/vue/commit/a981c80d2aedb0d56f98865e39c981819fbf65d0))
+- **types:** add Prop to main type declaration file ([#6856](https://github.com/vuejs/vue/issues/6856)) ([5791072](https://github.com/vuejs/vue/commit/57910723c6ba68386c15e095e42c1ed9603c7bcf)), closes [#6850](https://github.com/vuejs/vue/issues/6850)
+- **types:** add types for vue-template-compiler ([#7918](https://github.com/vuejs/vue/issues/7918)) ([ced774b](https://github.com/vuejs/vue/commit/ced774be6ddbc53884d7a5d395514a9f62e32336))
+- use event delegation when possible ([b7f7f27](https://github.com/vuejs/vue/commit/b7f7f2756928f409950186c5d641034f362b392a)), closes [#6566](https://github.com/vuejs/vue/issues/6566)
+- v-bind.sync also listens for kebab-case update event ([#8297](https://github.com/vuejs/vue/issues/8297)) ([3fca527](https://github.com/vuejs/vue/commit/3fca52792ef83fa58a5c28882706d9e8a039790d)), closes [#6428](https://github.com/vuejs/vue/issues/6428)
+- **v-for:** support iterables in v-for ([#8179](https://github.com/vuejs/vue/issues/8179)) ([d40eb9c](https://github.com/vuejs/vue/commit/d40eb9c2880c8dd27fedb9fbc508823a15742274))
 
 ## [2.5.22](https://github.com/vuejs/vue/compare/v2.5.21...v2.5.22) (2019-01-11)
 
-
 ### Bug Fixes
 
-* **async component:** memory leak after synchronous async loading ([#9275](https://github.com/vuejs/vue/issues/9275)) ([d21e931](https://github.com/vuejs/vue/commit/d21e93139697be2c0a6fdc4ee74d30d2834a729f)), closes [#9229](https://github.com/vuejs/vue/issues/9229)
-* **core:** dedupe lifecycle hooks during options merge ([0d2e9c4](https://github.com/vuejs/vue/commit/0d2e9c46f16e9ec5bd0f3eebd2aa31c7f7493856)), closes [#9199](https://github.com/vuejs/vue/issues/9199)
-* **core:** fix merged twice bug when passing extended constructor to mixins ([#9199](https://github.com/vuejs/vue/issues/9199)) ([743edac](https://github.com/vuejs/vue/commit/743edacdb6fa0bb711e860b68373274f50c8baa5)), closes [#9198](https://github.com/vuejs/vue/issues/9198)
-* **ssr:** support rendering comment ([#9128](https://github.com/vuejs/vue/issues/9128)) ([b06c784](https://github.com/vuejs/vue/commit/b06c784b81a244e1bc2d028216fcd2ab873730b9))
-
-
+- **async component:** memory leak after synchronous async loading ([#9275](https://github.com/vuejs/vue/issues/9275)) ([d21e931](https://github.com/vuejs/vue/commit/d21e93139697be2c0a6fdc4ee74d30d2834a729f)), closes [#9229](https://github.com/vuejs/vue/issues/9229)
+- **core:** dedupe lifecycle hooks during options merge ([0d2e9c4](https://github.com/vuejs/vue/commit/0d2e9c46f16e9ec5bd0f3eebd2aa31c7f7493856)), closes [#9199](https://github.com/vuejs/vue/issues/9199)
+- **core:** fix merged twice bug when passing extended constructor to mixins ([#9199](https://github.com/vuejs/vue/issues/9199)) ([743edac](https://github.com/vuejs/vue/commit/743edacdb6fa0bb711e860b68373274f50c8baa5)), closes [#9198](https://github.com/vuejs/vue/issues/9198)
+- **ssr:** support rendering comment ([#9128](https://github.com/vuejs/vue/issues/9128)) ([b06c784](https://github.com/vuejs/vue/commit/b06c784b81a244e1bc2d028216fcd2ab873730b9))
 
 ## [2.5.21](https://github.com/vuejs/vue/compare/v2.5.20...v2.5.21) (2018-12-11)
 
-
 ### Bug Fixes
 
-* fix single v-for child optimization ([847e493](https://github.com/vuejs/vue/commit/847e493768371cec4718969e02bdb7f8463f4e03))
-* fix v-for component with undefined value ([4748760](https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d)), closes [#9181](https://github.com/vuejs/vue/issues/9181)
-* **lifecycle:** beforeUpdated should not be called if component is destroyed ([#9171](https://github.com/vuejs/vue/issues/9171)) ([87bad80](https://github.com/vuejs/vue/commit/87bad80f0cb9a30b95d9410120ff6e3e2022a723)), closes [#8076](https://github.com/vuejs/vue/issues/8076)
-* **types:** accept primatives and falsy values in createElement children ([#9154](https://github.com/vuejs/vue/issues/9154)) ([d780dd2](https://github.com/vuejs/vue/commit/d780dd2e2adcf71f40c086055a659a9a2b4a8282)), closes [#8498](https://github.com/vuejs/vue/issues/8498)
-* **v-model:** properly handle multiline v-model expressions ([#9184](https://github.com/vuejs/vue/issues/9184)) ([3d44937](https://github.com/vuejs/vue/commit/3d449376d557c4533a9664f95df3a168ecee9bfa)), closes [#9183](https://github.com/vuejs/vue/issues/9183)
-* **weex:** support data class type that is string ([#9139](https://github.com/vuejs/vue/issues/9139)) ([d8285c5](https://github.com/vuejs/vue/commit/d8285c57a613c42eddf2d4f2b75c1cea6aa4703a)), closes [#9124](https://github.com/vuejs/vue/issues/9124)
-
+- fix single v-for child optimization ([847e493](https://github.com/vuejs/vue/commit/847e493768371cec4718969e02bdb7f8463f4e03))
+- fix v-for component with undefined value ([4748760](https://github.com/vuejs/vue/commit/47487607fbb99339038cf84990ba341c25b5e20d)), closes [#9181](https://github.com/vuejs/vue/issues/9181)
+- **lifecycle:** beforeUpdated should not be called if component is destroyed ([#9171](https://github.com/vuejs/vue/issues/9171)) ([87bad80](https://github.com/vuejs/vue/commit/87bad80f0cb9a30b95d9410120ff6e3e2022a723)), closes [#8076](https://github.com/vuejs/vue/issues/8076)
+- **types:** accept primatives and falsy values in createElement children ([#9154](https://github.com/vuejs/vue/issues/9154)) ([d780dd2](https://github.com/vuejs/vue/commit/d780dd2e2adcf71f40c086055a659a9a2b4a8282)), closes [#8498](https://github.com/vuejs/vue/issues/8498)
+- **v-model:** properly handle multiline v-model expressions ([#9184](https://github.com/vuejs/vue/issues/9184)) ([3d44937](https://github.com/vuejs/vue/commit/3d449376d557c4533a9664f95df3a168ecee9bfa)), closes [#9183](https://github.com/vuejs/vue/issues/9183)
+- **weex:** support data class type that is string ([#9139](https://github.com/vuejs/vue/issues/9139)) ([d8285c5](https://github.com/vuejs/vue/commit/d8285c57a613c42eddf2d4f2b75c1cea6aa4703a)), closes [#9124](https://github.com/vuejs/vue/issues/9124)
 
 ### Performance Improvements
 
-* skip normalization on single child element v-for ([4074104](https://github.com/vuejs/vue/commit/4074104fac219e61e542f4da3a4800975a8063f2))
-
+- skip normalization on single child element v-for ([4074104](https://github.com/vuejs/vue/commit/4074104fac219e61e542f4da3a4800975a8063f2))
 
 ### Reverts
 
-* "chore: use keypress in TodoMVC example for IME input methods ([#9172](https://github.com/vuejs/vue/issues/9172))" ([80fb6b8](https://github.com/vuejs/vue/commit/80fb6b8da144bd9c2313702e23a35d72fa620135))
-
-
+- "chore: use keypress in TodoMVC example for IME input methods ([#9172](https://github.com/vuejs/vue/issues/9172))" ([80fb6b8](https://github.com/vuejs/vue/commit/80fb6b8da144bd9c2313702e23a35d72fa620135))
 
 ## [2.5.20](https://github.com/vuejs/vue/compare/v2.5.19...v2.5.20) (2018-12-10)
 
-
 ### Bug Fixes
 
-* **types:** avoid `this` in VueConstructor signature ([#9173](https://github.com/vuejs/vue/issues/9173)) ([e06d2af](https://github.com/vuejs/vue/commit/e06d2af276fc8d626a3b048f4d138a243aa690a4)), closes [/github.com/vuejs/vue-class-component/issues/294#issuecomment-445526936](https://github.com//github.com/vuejs/vue-class-component/issues/294/issues/issuecomment-445526936)
-
-
+- **types:** avoid `this` in VueConstructor signature ([#9173](https://github.com/vuejs/vue/issues/9173)) ([e06d2af](https://github.com/vuejs/vue/commit/e06d2af276fc8d626a3b048f4d138a243aa690a4)), closes [/github.com/vuejs/vue-class-component/issues/294#issuecomment-445526936](https://github.com//github.com/vuejs/vue-class-component/issues/294/issues/issuecomment-445526936)
 
 ## [2.5.19](https://github.com/vuejs/vue/compare/v2.5.18...v2.5.19) (2018-12-09)
 
-
 ### Bug Fixes
 
-* **ssr:** should not warn for custom directives that do not have ssr implementation ([780dac5](https://github.com/vuejs/vue/commit/780dac561b9cd6c3cec28f154f76e7d28352ebf3)), closes [#9167](https://github.com/vuejs/vue/issues/9167)
-* **vdom:** remove unnecessary sameVnode condition ([0d4b35f](https://github.com/vuejs/vue/commit/0d4b35f55975946cb0eb4f7f5f35efe3d078473e)), closes [#9168](https://github.com/vuejs/vue/issues/9168)
-
+- **ssr:** should not warn for custom directives that do not have ssr implementation ([780dac5](https://github.com/vuejs/vue/commit/780dac561b9cd6c3cec28f154f76e7d28352ebf3)), closes [#9167](https://github.com/vuejs/vue/issues/9167)
+- **vdom:** remove unnecessary sameVnode condition ([0d4b35f](https://github.com/vuejs/vue/commit/0d4b35f55975946cb0eb4f7f5f35efe3d078473e)), closes [#9168](https://github.com/vuejs/vue/issues/9168)
 
 ### Reverts
 
-* fix(sfc): avoid deindent when pad option is specified ([#7647](https://github.com/vuejs/vue/issues/7647)) ([5d721a4](https://github.com/vuejs/vue/commit/5d721a42b140865e50a78445fe21c5f270bde703))
-
-
+- fix(sfc): avoid deindent when pad option is specified ([#7647](https://github.com/vuejs/vue/issues/7647)) ([5d721a4](https://github.com/vuejs/vue/commit/5d721a42b140865e50a78445fe21c5f270bde703))
 
 ## [2.5.18](https://github.com/vuejs/vue/compare/v2.5.18-beta.0...v2.5.18) (2018-12-07)
 
-
 ### Bug Fixes
 
-* **compiler:** fix codegen for v-for component inside template ([1b4a8a0](https://github.com/vuejs/vue/commit/1b4a8a0c1edaf9c7eb129ba61bca94ba607bbf56)), closes [#9142](https://github.com/vuejs/vue/issues/9142)
-* fix keyName checking for space and delete in IE11 ([#9150](https://github.com/vuejs/vue/issues/9150)) ([0ed0aad](https://github.com/vuejs/vue/commit/0ed0aad77228b95e9a61a87386736938837527f8)), closes [#9112](https://github.com/vuejs/vue/issues/9112)
-* **ssr:** fix ssr template publicPath generation ([f077ed1](https://github.com/vuejs/vue/commit/f077ed17af14bb2675db64b2aa2d023769219624)), closes [#9145](https://github.com/vuejs/vue/issues/9145)
-* **transition-group:** fix activeInstance regression ([8a2dbf5](https://github.com/vuejs/vue/commit/8a2dbf50105ea729125a42fecfe2c2f0371d7836)), closes [#9151](https://github.com/vuejs/vue/issues/9151)
-* **types:** correct scopedSlot types ([#9131](https://github.com/vuejs/vue/issues/9131)) ([448ba65](https://github.com/vuejs/vue/commit/448ba65d2b139b29f1e6891add9925ac22ffe10b)), closes [#8946](https://github.com/vuejs/vue/issues/8946)
-* **types:** type support for advanced async components ([#8438](https://github.com/vuejs/vue/issues/8438)) ([dfaf9e2](https://github.com/vuejs/vue/commit/dfaf9e24361e10ae68ce3951eaf48262cf90f0ec))
-
-
+- **compiler:** fix codegen for v-for component inside template ([1b4a8a0](https://github.com/vuejs/vue/commit/1b4a8a0c1edaf9c7eb129ba61bca94ba607bbf56)), closes [#9142](https://github.com/vuejs/vue/issues/9142)
+- fix keyName checking for space and delete in IE11 ([#9150](https://github.com/vuejs/vue/issues/9150)) ([0ed0aad](https://github.com/vuejs/vue/commit/0ed0aad77228b95e9a61a87386736938837527f8)), closes [#9112](https://github.com/vuejs/vue/issues/9112)
+- **ssr:** fix ssr template publicPath generation ([f077ed1](https://github.com/vuejs/vue/commit/f077ed17af14bb2675db64b2aa2d023769219624)), closes [#9145](https://github.com/vuejs/vue/issues/9145)
+- **transition-group:** fix activeInstance regression ([8a2dbf5](https://github.com/vuejs/vue/commit/8a2dbf50105ea729125a42fecfe2c2f0371d7836)), closes [#9151](https://github.com/vuejs/vue/issues/9151)
+- **types:** correct scopedSlot types ([#9131](https://github.com/vuejs/vue/issues/9131)) ([448ba65](https://github.com/vuejs/vue/commit/448ba65d2b139b29f1e6891add9925ac22ffe10b)), closes [#8946](https://github.com/vuejs/vue/issues/8946)
+- **types:** type support for advanced async components ([#8438](https://github.com/vuejs/vue/issues/8438)) ([dfaf9e2](https://github.com/vuejs/vue/commit/dfaf9e24361e10ae68ce3951eaf48262cf90f0ec))
 
 ## [2.5.18-beta.0](https://github.com/vuejs/vue/compare/v2.5.17-beta.0...v2.5.18-beta.0) (2018-12-02)
 
-
 ### Bug Fixes
 
-* actually disable dep collection when invoking lifecycle hooks ([#9095](https://github.com/vuejs/vue/issues/9095)) ([0d62bb8](https://github.com/vuejs/vue/commit/0d62bb84ffa1af7a4826aecc11c429c7a020645c)), closes [#9046](https://github.com/vuejs/vue/issues/9046)
-* **compiler:**  wrap scoped slots v-if conditions in parens ([#9119](https://github.com/vuejs/vue/issues/9119)) ([ef8524a](https://github.com/vuejs/vue/commit/ef8524ab7db8d64ac449ce74f5858aa9d91357ad)), closes [#9114](https://github.com/vuejs/vue/issues/9114)
-* **compiler:** maybeComponent should return true when "is" attribute exists ([#8114](https://github.com/vuejs/vue/issues/8114)) ([aef2a5f](https://github.com/vuejs/vue/commit/aef2a5f3dbd5e52ec9d5ce026d7b858539057186)), closes [#8101](https://github.com/vuejs/vue/issues/8101)
-* **compiler:** normalize potential functional component children in v-for ([#8558](https://github.com/vuejs/vue/issues/8558)) ([d483a49](https://github.com/vuejs/vue/commit/d483a49c86874b2e75863b661f81feecd46ae721)), closes [#8468](https://github.com/vuejs/vue/issues/8468)
-* **compiler:** should keep newline after unary tags in <pre> ([#8965](https://github.com/vuejs/vue/issues/8965)) ([05001e6](https://github.com/vuejs/vue/commit/05001e695ebd0b0504d664197a4771463a0f5328)), closes [#8950](https://github.com/vuejs/vue/issues/8950)
-* **compiler:** templates inside v-pre should be rendered to HTML ([#8146](https://github.com/vuejs/vue/issues/8146)) ([ecac831](https://github.com/vuejs/vue/commit/ecac831691d27cf7a10ec73a004d3fbad7623d1a)), closes [#8041](https://github.com/vuejs/vue/issues/8041)
-* **component:** clean up memory leak after loading async component completes (fix [#8740](https://github.com/vuejs/vue/issues/8740)) ([#8755](https://github.com/vuejs/vue/issues/8755)) ([2e472c5](https://github.com/vuejs/vue/commit/2e472c5e5e559a7a4083b4164ffe0c3911ce0651))
-* **core:** avoid mutating original children when cloning vnode ([097f622](https://github.com/vuejs/vue/commit/097f6229dffc34af452b106ad2a3b58845588807)), closes [#7975](https://github.com/vuejs/vue/issues/7975)
-* **core:** properly handle reused vnodes ([530ca1b](https://github.com/vuejs/vue/commit/530ca1b2db315fbd0e360807b2031d26665c5d3d)), closes [#7913](https://github.com/vuejs/vue/issues/7913)
-* **core:** skip mixins and extends if child is already merged ([#8870](https://github.com/vuejs/vue/issues/8870)) ([80f17fa](https://github.com/vuejs/vue/commit/80f17fa498f5df0388412877799dbd7573c44b2d)), closes [#8865](https://github.com/vuejs/vue/issues/8865)
-* **data:** skip recursive call if values are identical ([#8967](https://github.com/vuejs/vue/issues/8967)) ([a7658e0](https://github.com/vuejs/vue/commit/a7658e03a16dc507f0abeba41aee705f773727d0))
-* **error handling:** handle errors on immediate watcher execution ([#8581](https://github.com/vuejs/vue/issues/8581)) ([2686818](https://github.com/vuejs/vue/commit/2686818beb5728e3b7aa22f47a3b3f0d39d90c8e)), closes [#8567](https://github.com/vuejs/vue/issues/8567)
-* fix potential xss vulnerability in ssr when using v-bind ([3d36a44](https://github.com/vuejs/vue/commit/3d36a443c755bf16f2656a8595dda9076f021a4a))
-* fix server env detection in wechat mini program ([#9075](https://github.com/vuejs/vue/issues/9075)) ([05e8bcf](https://github.com/vuejs/vue/commit/05e8bcfe5d308f280f3640df96bd170fbcf1a9b5))
-* **for:** use IE compatible regex in v-for regex ([#8048](https://github.com/vuejs/vue/issues/8048)) ([ecc239e](https://github.com/vuejs/vue/commit/ecc239e47516d7f9a93b2cd49da4a2000960b8f7)), closes [#7946](https://github.com/vuejs/vue/issues/7946)
-* handle undefined style properties in jsdom (fix [#7444](https://github.com/vuejs/vue/issues/7444)) ([#8281](https://github.com/vuejs/vue/issues/8281)) ([5cfdf1a](https://github.com/vuejs/vue/commit/5cfdf1a2484fa73b572eae4afd196dcf9e1912ba))
-* **lifecycle:** updated should not be called after component being destroyed ([#8381](https://github.com/vuejs/vue/issues/8381)) ([a64ff19](https://github.com/vuejs/vue/commit/a64ff1957c35270b818aa9cfdfb2acb6e42ce2a9)), closes [#8076](https://github.com/vuejs/vue/issues/8076)
-* make sure global state is restored in the case of an exception in macrotask callback ([#9093](https://github.com/vuejs/vue/issues/9093)) ([b111de4](https://github.com/vuejs/vue/commit/b111de486b1bdc747fe0f5795fe22697d151bb8c))
-* **parser:** allow CRLFs in string interpolations ([#8408](https://github.com/vuejs/vue/issues/8408)) ([8f04135](https://github.com/vuejs/vue/commit/8f04135dbaa5f5f0500d42c0968beba8043f5363)), closes [#8103](https://github.com/vuejs/vue/issues/8103)
-* replace hardcoded .parentNode with abstract ops, fix [#8713](https://github.com/vuejs/vue/issues/8713) ([#8714](https://github.com/vuejs/vue/issues/8714)) ([1e1ce0c](https://github.com/vuejs/vue/commit/1e1ce0cac7d6c22c980021cbd3cb207a47e85dfb))
-* **server:** use path.posix.join to generate public path ([#8177](https://github.com/vuejs/vue/issues/8177)) ([46b8d2c](https://github.com/vuejs/vue/commit/46b8d2c59dc259995a71662229ed52b8b8beeb38)), closes [#8167](https://github.com/vuejs/vue/issues/8167)
-* **sfc:** avoid deindent when pad option is specified ([#7647](https://github.com/vuejs/vue/issues/7647)) ([9d2f9a0](https://github.com/vuejs/vue/commit/9d2f9a034f9c40d5ba6d8b1e131b1bfb675dc1cf))
-* **shared:** check dates in looseEqual ([#7940](https://github.com/vuejs/vue/issues/7940)) ([db7287c](https://github.com/vuejs/vue/commit/db7287c23b11bdc032fb0786e6617f3c6c40c835)), closes [#7928](https://github.com/vuejs/vue/issues/7928)
-* **ssr:** adjust call stack size defer threshold ([e4b1b57](https://github.com/vuejs/vue/commit/e4b1b57fd7117a19cdb376dcb156606e0cc32a94)), closes [#8545](https://github.com/vuejs/vue/issues/8545)
-* **ssr:** check js assets more accurate in ssr webpack plugin ([#8639](https://github.com/vuejs/vue/issues/8639)) ([5624278](https://github.com/vuejs/vue/commit/5624278fbe5d85cfe578d749da12b1e73c3e61a9))
-* **ssr:** computed properties should pass vm as first argument in ssr ([#9090](https://github.com/vuejs/vue/issues/9090)) ([33e669b](https://github.com/vuejs/vue/commit/33e669b22f69a1f9c9147528360fe0bba85534f0)), closes [#8977](https://github.com/vuejs/vue/issues/8977)
-* **ssr:** fix double escaping of staticClass values ([#7859](https://github.com/vuejs/vue/issues/7859)) ([#8037](https://github.com/vuejs/vue/issues/8037)) ([c21b89e](https://github.com/vuejs/vue/commit/c21b89ebeda4c45024c2a71bc7a292d47ebc7ee1))
-* **ssr:** remove trailing hash in webpack module identifier when ([ae6dcd6](https://github.com/vuejs/vue/commit/ae6dcd63a017059644502f8741d8a514f3e9cf84))
-* **ssr:** render initial and used async css chunks ([#7902](https://github.com/vuejs/vue/issues/7902)) ([575b6e7](https://github.com/vuejs/vue/commit/575b6e77ab82b0bbc581aec3ea9b07135d2d1fcd)), closes [#7897](https://github.com/vuejs/vue/issues/7897)
-* **ssr:** resolve server directives the same as on client ([#9129](https://github.com/vuejs/vue/issues/9129)) ([3078352](https://github.com/vuejs/vue/commit/307835284a326569ea12c4a22c7dcb8f36d2d8ca)), closes [#8961](https://github.com/vuejs/vue/issues/8961)
-* support modifier combination of click.right + .once ([#8492](https://github.com/vuejs/vue/issues/8492)) ([eb60452](https://github.com/vuejs/vue/commit/eb604529c62e9954305889122f34499ad75b3b45))
-* **transition:** check existence of `el.parentNode` ([#8422](https://github.com/vuejs/vue/issues/8422)) ([0b16927](https://github.com/vuejs/vue/commit/0b16927c9d382b9cf134b131b898350340c2ee41)), closes [#8199](https://github.com/vuejs/vue/issues/8199)
-* **transition:** handle local-formatted floats in toMs function.  ([#8495](https://github.com/vuejs/vue/issues/8495)) ([59d4351](https://github.com/vuejs/vue/commit/59d4351ad8fc042bc263a16ed45a56e9ff5b013e)), closes [#4894](https://github.com/vuejs/vue/issues/4894)
-* **transition:** transition-group should only listen for first-level children's end events ([#8374](https://github.com/vuejs/vue/issues/8374)) ([504d5da](https://github.com/vuejs/vue/commit/504d5da7eff1c77117c2f57b0c4238e56de80fc5))
-* **types:** accept `number` type as key on Vue.set/delete ([#8707](https://github.com/vuejs/vue/issues/8707)) ([#8709](https://github.com/vuejs/vue/issues/8709)) ([0ba79e2](https://github.com/vuejs/vue/commit/0ba79e2588309ba386f570ed84d372611c4dd165))
-* **types:** fix `renderError`arguments type ([#8636](https://github.com/vuejs/vue/issues/8636)) ([ac217d2](https://github.com/vuejs/vue/commit/ac217d2472bb92ce901ef1f46595b44a1b5d1a18)), closes [#8635](https://github.com/vuejs/vue/issues/8635)
-* **types:** fix vm.$once argument type ([#8995](https://github.com/vuejs/vue/issues/8995)) ([97086f3](https://github.com/vuejs/vue/commit/97086f365808a040f6cf1ddb12e2b3f63d7769bf)), closes [#8983](https://github.com/vuejs/vue/issues/8983)
-* **types:** make VNodeDirective properties optional, fix [#8013](https://github.com/vuejs/vue/issues/8013) ([#8003](https://github.com/vuejs/vue/issues/8003)) ([99a51b4](https://github.com/vuejs/vue/commit/99a51b452fa13fc4392e87215a8c3024adf5f710))
-* **types:** relax the return type of props default option ([#8537](https://github.com/vuejs/vue/issues/8537)) ([a9eb198](https://github.com/vuejs/vue/commit/a9eb198413e7b1baaf364e93ec3c093734529fe8))
-* **types:** support chain call for Vue.use and Vue.mixin ([#8595](https://github.com/vuejs/vue/issues/8595)) ([c711ec1](https://github.com/vuejs/vue/commit/c711ec189aaf46399756e34d933ba5e0b6576c36))
-* **types:** support typing $el as SVGElement ([#8809](https://github.com/vuejs/vue/issues/8809)) ([3cd4af4](https://github.com/vuejs/vue/commit/3cd4af4af0a8a67f5887d5fc967147d433c8612c))
-* v-bind object should be overridable with kebab-cased props ([#8845](https://github.com/vuejs/vue/issues/8845)) ([7585241](https://github.com/vuejs/vue/commit/758524134e71ae025238e16a4c1f2b30a1310fe8))
-* **v-model:** avoid duplicate model transforms ([7b7164c](https://github.com/vuejs/vue/commit/7b7164c11cbb74ed44ee086f0a82acfcc1ff47a2)), closes [#8436](https://github.com/vuejs/vue/issues/8436)
-* **v-on:** correctly remove once listener ([#8036](https://github.com/vuejs/vue/issues/8036)) ([19c33a7](https://github.com/vuejs/vue/commit/19c33a7e4072b03069f803263ed0c49feb5f73a9)), closes [#8032](https://github.com/vuejs/vue/issues/8032)
-* **v-pre:** skip compiling custom component tags in v-pre blocks (fix [#8286](https://github.com/vuejs/vue/issues/8286)) ([#8376](https://github.com/vuejs/vue/issues/8376)) ([a71853b](https://github.com/vuejs/vue/commit/a71853bfc5b6ee117af05408f4d75c80893d44e2))
-
+- actually disable dep collection when invoking lifecycle hooks ([#9095](https://github.com/vuejs/vue/issues/9095)) ([0d62bb8](https://github.com/vuejs/vue/commit/0d62bb84ffa1af7a4826aecc11c429c7a020645c)), closes [#9046](https://github.com/vuejs/vue/issues/9046)
+- **compiler:** wrap scoped slots v-if conditions in parens ([#9119](https://github.com/vuejs/vue/issues/9119)) ([ef8524a](https://github.com/vuejs/vue/commit/ef8524ab7db8d64ac449ce74f5858aa9d91357ad)), closes [#9114](https://github.com/vuejs/vue/issues/9114)
+- **compiler:** maybeComponent should return true when "is" attribute exists ([#8114](https://github.com/vuejs/vue/issues/8114)) ([aef2a5f](https://github.com/vuejs/vue/commit/aef2a5f3dbd5e52ec9d5ce026d7b858539057186)), closes [#8101](https://github.com/vuejs/vue/issues/8101)
+- **compiler:** normalize potential functional component children in v-for ([#8558](https://github.com/vuejs/vue/issues/8558)) ([d483a49](https://github.com/vuejs/vue/commit/d483a49c86874b2e75863b661f81feecd46ae721)), closes [#8468](https://github.com/vuejs/vue/issues/8468)
+- **compiler:** should keep newline after unary tags in <pre> ([#8965](https://github.com/vuejs/vue/issues/8965)) ([05001e6](https://github.com/vuejs/vue/commit/05001e695ebd0b0504d664197a4771463a0f5328)), closes [#8950](https://github.com/vuejs/vue/issues/8950)
+- **compiler:** templates inside v-pre should be rendered to HTML ([#8146](https://github.com/vuejs/vue/issues/8146)) ([ecac831](https://github.com/vuejs/vue/commit/ecac831691d27cf7a10ec73a004d3fbad7623d1a)), closes [#8041](https://github.com/vuejs/vue/issues/8041)
+- **component:** clean up memory leak after loading async component completes (fix [#8740](https://github.com/vuejs/vue/issues/8740)) ([#8755](https://github.com/vuejs/vue/issues/8755)) ([2e472c5](https://github.com/vuejs/vue/commit/2e472c5e5e559a7a4083b4164ffe0c3911ce0651))
+- **core:** avoid mutating original children when cloning vnode ([097f622](https://github.com/vuejs/vue/commit/097f6229dffc34af452b106ad2a3b58845588807)), closes [#7975](https://github.com/vuejs/vue/issues/7975)
+- **core:** properly handle reused vnodes ([530ca1b](https://github.com/vuejs/vue/commit/530ca1b2db315fbd0e360807b2031d26665c5d3d)), closes [#7913](https://github.com/vuejs/vue/issues/7913)
+- **core:** skip mixins and extends if child is already merged ([#8870](https://github.com/vuejs/vue/issues/8870)) ([80f17fa](https://github.com/vuejs/vue/commit/80f17fa498f5df0388412877799dbd7573c44b2d)), closes [#8865](https://github.com/vuejs/vue/issues/8865)
+- **data:** skip recursive call if values are identical ([#8967](https://github.com/vuejs/vue/issues/8967)) ([a7658e0](https://github.com/vuejs/vue/commit/a7658e03a16dc507f0abeba41aee705f773727d0))
+- **error handling:** handle errors on immediate watcher execution ([#8581](https://github.com/vuejs/vue/issues/8581)) ([2686818](https://github.com/vuejs/vue/commit/2686818beb5728e3b7aa22f47a3b3f0d39d90c8e)), closes [#8567](https://github.com/vuejs/vue/issues/8567)
+- fix potential xss vulnerability in ssr when using v-bind ([3d36a44](https://github.com/vuejs/vue/commit/3d36a443c755bf16f2656a8595dda9076f021a4a))
+- fix server env detection in wechat mini program ([#9075](https://github.com/vuejs/vue/issues/9075)) ([05e8bcf](https://github.com/vuejs/vue/commit/05e8bcfe5d308f280f3640df96bd170fbcf1a9b5))
+- **for:** use IE compatible regex in v-for regex ([#8048](https://github.com/vuejs/vue/issues/8048)) ([ecc239e](https://github.com/vuejs/vue/commit/ecc239e47516d7f9a93b2cd49da4a2000960b8f7)), closes [#7946](https://github.com/vuejs/vue/issues/7946)
+- handle undefined style properties in jsdom (fix [#7444](https://github.com/vuejs/vue/issues/7444)) ([#8281](https://github.com/vuejs/vue/issues/8281)) ([5cfdf1a](https://github.com/vuejs/vue/commit/5cfdf1a2484fa73b572eae4afd196dcf9e1912ba))
+- **lifecycle:** updated should not be called after component being destroyed ([#8381](https://github.com/vuejs/vue/issues/8381)) ([a64ff19](https://github.com/vuejs/vue/commit/a64ff1957c35270b818aa9cfdfb2acb6e42ce2a9)), closes [#8076](https://github.com/vuejs/vue/issues/8076)
+- make sure global state is restored in the case of an exception in macrotask callback ([#9093](https://github.com/vuejs/vue/issues/9093)) ([b111de4](https://github.com/vuejs/vue/commit/b111de486b1bdc747fe0f5795fe22697d151bb8c))
+- **parser:** allow CRLFs in string interpolations ([#8408](https://github.com/vuejs/vue/issues/8408)) ([8f04135](https://github.com/vuejs/vue/commit/8f04135dbaa5f5f0500d42c0968beba8043f5363)), closes [#8103](https://github.com/vuejs/vue/issues/8103)
+- replace hardcoded .parentNode with abstract ops, fix [#8713](https://github.com/vuejs/vue/issues/8713) ([#8714](https://github.com/vuejs/vue/issues/8714)) ([1e1ce0c](https://github.com/vuejs/vue/commit/1e1ce0cac7d6c22c980021cbd3cb207a47e85dfb))
+- **server:** use path.posix.join to generate public path ([#8177](https://github.com/vuejs/vue/issues/8177)) ([46b8d2c](https://github.com/vuejs/vue/commit/46b8d2c59dc259995a71662229ed52b8b8beeb38)), closes [#8167](https://github.com/vuejs/vue/issues/8167)
+- **sfc:** avoid deindent when pad option is specified ([#7647](https://github.com/vuejs/vue/issues/7647)) ([9d2f9a0](https://github.com/vuejs/vue/commit/9d2f9a034f9c40d5ba6d8b1e131b1bfb675dc1cf))
+- **shared:** check dates in looseEqual ([#7940](https://github.com/vuejs/vue/issues/7940)) ([db7287c](https://github.com/vuejs/vue/commit/db7287c23b11bdc032fb0786e6617f3c6c40c835)), closes [#7928](https://github.com/vuejs/vue/issues/7928)
+- **ssr:** adjust call stack size defer threshold ([e4b1b57](https://github.com/vuejs/vue/commit/e4b1b57fd7117a19cdb376dcb156606e0cc32a94)), closes [#8545](https://github.com/vuejs/vue/issues/8545)
+- **ssr:** check js assets more accurate in ssr webpack plugin ([#8639](https://github.com/vuejs/vue/issues/8639)) ([5624278](https://github.com/vuejs/vue/commit/5624278fbe5d85cfe578d749da12b1e73c3e61a9))
+- **ssr:** computed properties should pass vm as first argument in ssr ([#9090](https://github.com/vuejs/vue/issues/9090)) ([33e669b](https://github.com/vuejs/vue/commit/33e669b22f69a1f9c9147528360fe0bba85534f0)), closes [#8977](https://github.com/vuejs/vue/issues/8977)
+- **ssr:** fix double escaping of staticClass values ([#7859](https://github.com/vuejs/vue/issues/7859)) ([#8037](https://github.com/vuejs/vue/issues/8037)) ([c21b89e](https://github.com/vuejs/vue/commit/c21b89ebeda4c45024c2a71bc7a292d47ebc7ee1))
+- **ssr:** remove trailing hash in webpack module identifier when ([ae6dcd6](https://github.com/vuejs/vue/commit/ae6dcd63a017059644502f8741d8a514f3e9cf84))
+- **ssr:** render initial and used async css chunks ([#7902](https://github.com/vuejs/vue/issues/7902)) ([575b6e7](https://github.com/vuejs/vue/commit/575b6e77ab82b0bbc581aec3ea9b07135d2d1fcd)), closes [#7897](https://github.com/vuejs/vue/issues/7897)
+- **ssr:** resolve server directives the same as on client ([#9129](https://github.com/vuejs/vue/issues/9129)) ([3078352](https://github.com/vuejs/vue/commit/307835284a326569ea12c4a22c7dcb8f36d2d8ca)), closes [#8961](https://github.com/vuejs/vue/issues/8961)
+- support modifier combination of click.right + .once ([#8492](https://github.com/vuejs/vue/issues/8492)) ([eb60452](https://github.com/vuejs/vue/commit/eb604529c62e9954305889122f34499ad75b3b45))
+- **transition:** check existence of `el.parentNode` ([#8422](https://github.com/vuejs/vue/issues/8422)) ([0b16927](https://github.com/vuejs/vue/commit/0b16927c9d382b9cf134b131b898350340c2ee41)), closes [#8199](https://github.com/vuejs/vue/issues/8199)
+- **transition:** handle local-formatted floats in toMs function. ([#8495](https://github.com/vuejs/vue/issues/8495)) ([59d4351](https://github.com/vuejs/vue/commit/59d4351ad8fc042bc263a16ed45a56e9ff5b013e)), closes [#4894](https://github.com/vuejs/vue/issues/4894)
+- **transition:** transition-group should only listen for first-level children's end events ([#8374](https://github.com/vuejs/vue/issues/8374)) ([504d5da](https://github.com/vuejs/vue/commit/504d5da7eff1c77117c2f57b0c4238e56de80fc5))
+- **types:** accept `number` type as key on Vue.set/delete ([#8707](https://github.com/vuejs/vue/issues/8707)) ([#8709](https://github.com/vuejs/vue/issues/8709)) ([0ba79e2](https://github.com/vuejs/vue/commit/0ba79e2588309ba386f570ed84d372611c4dd165))
+- **types:** fix `renderError`arguments type ([#8636](https://github.com/vuejs/vue/issues/8636)) ([ac217d2](https://github.com/vuejs/vue/commit/ac217d2472bb92ce901ef1f46595b44a1b5d1a18)), closes [#8635](https://github.com/vuejs/vue/issues/8635)
+- **types:** fix vm.$once argument type ([#8995](https://github.com/vuejs/vue/issues/8995)) ([97086f3](https://github.com/vuejs/vue/commit/97086f365808a040f6cf1ddb12e2b3f63d7769bf)), closes [#8983](https://github.com/vuejs/vue/issues/8983)
+- **types:** make VNodeDirective properties optional, fix [#8013](https://github.com/vuejs/vue/issues/8013) ([#8003](https://github.com/vuejs/vue/issues/8003)) ([99a51b4](https://github.com/vuejs/vue/commit/99a51b452fa13fc4392e87215a8c3024adf5f710))
+- **types:** relax the return type of props default option ([#8537](https://github.com/vuejs/vue/issues/8537)) ([a9eb198](https://github.com/vuejs/vue/commit/a9eb198413e7b1baaf364e93ec3c093734529fe8))
+- **types:** support chain call for Vue.use and Vue.mixin ([#8595](https://github.com/vuejs/vue/issues/8595)) ([c711ec1](https://github.com/vuejs/vue/commit/c711ec189aaf46399756e34d933ba5e0b6576c36))
+- **types:** support typing $el as SVGElement ([#8809](https://github.com/vuejs/vue/issues/8809)) ([3cd4af4](https://github.com/vuejs/vue/commit/3cd4af4af0a8a67f5887d5fc967147d433c8612c))
+- v-bind object should be overridable with kebab-cased props ([#8845](https://github.com/vuejs/vue/issues/8845)) ([7585241](https://github.com/vuejs/vue/commit/758524134e71ae025238e16a4c1f2b30a1310fe8))
+- **v-model:** avoid duplicate model transforms ([7b7164c](https://github.com/vuejs/vue/commit/7b7164c11cbb74ed44ee086f0a82acfcc1ff47a2)), closes [#8436](https://github.com/vuejs/vue/issues/8436)
+- **v-on:** correctly remove once listener ([#8036](https://github.com/vuejs/vue/issues/8036)) ([19c33a7](https://github.com/vuejs/vue/commit/19c33a7e4072b03069f803263ed0c49feb5f73a9)), closes [#8032](https://github.com/vuejs/vue/issues/8032)
+- **v-pre:** skip compiling custom component tags in v-pre blocks (fix [#8286](https://github.com/vuejs/vue/issues/8286)) ([#8376](https://github.com/vuejs/vue/issues/8376)) ([a71853b](https://github.com/vuejs/vue/commit/a71853bfc5b6ee117af05408f4d75c80893d44e2))
 
 ### Features
 
-* add async option ([#8240](https://github.com/vuejs/vue/issues/8240)) ([c944827](https://github.com/vuejs/vue/commit/c94482743c41e9bfc745aa06d63f7f83bdd56991))
-* **devtools:** store functional render context on vnode in development ([#8586](https://github.com/vuejs/vue/issues/8586)) ([4ecc21c](https://github.com/vuejs/vue/commit/4ecc21c29ec12bb33d3b426cb4d42c579e9b0f2d))
-* **server, webpack-plugin:** webpack 4 support ([#7839](https://github.com/vuejs/vue/issues/7839)) ([ef0b250](https://github.com/vuejs/vue/commit/ef0b25097957ae9ef9970be732d6e65cc78902e9))
-* **weex:** support object syntax of class ([#7930](https://github.com/vuejs/vue/issues/7930)) ([6226503](https://github.com/vuejs/vue/commit/62265035c0c400ad6ec213541dd7cca58dd71f6e))
-
+- add async option ([#8240](https://github.com/vuejs/vue/issues/8240)) ([c944827](https://github.com/vuejs/vue/commit/c94482743c41e9bfc745aa06d63f7f83bdd56991))
+- **devtools:** store functional render context on vnode in development ([#8586](https://github.com/vuejs/vue/issues/8586)) ([4ecc21c](https://github.com/vuejs/vue/commit/4ecc21c29ec12bb33d3b426cb4d42c579e9b0f2d))
+- **server, webpack-plugin:** webpack 4 support ([#7839](https://github.com/vuejs/vue/issues/7839)) ([ef0b250](https://github.com/vuejs/vue/commit/ef0b25097957ae9ef9970be732d6e65cc78902e9))
+- **weex:** support object syntax of class ([#7930](https://github.com/vuejs/vue/issues/7930)) ([6226503](https://github.com/vuejs/vue/commit/62265035c0c400ad6ec213541dd7cca58dd71f6e))
 
 ### Reverts
 
-* Revert "perf: avoid unnecessary re-renders when computed property value did not change (#7824)" ([6b1d431](https://github.com/vuejs/vue/commit/6b1d431a89f3f7438d01d8cc98546397f0983287)), closes [#7824](https://github.com/vuejs/vue/issues/7824)
-
-
+- Revert "perf: avoid unnecessary re-renders when computed property value did not change (#7824)" ([6b1d431](https://github.com/vuejs/vue/commit/6b1d431a89f3f7438d01d8cc98546397f0983287)), closes [#7824](https://github.com/vuejs/vue/issues/7824)
 
 ## [2.5.17-beta.0](https://github.com/vuejs/vue/compare/v2.5.16...v2.5.17-beta.0) (2018-03-23)
 
-
 ### Bug Fixes
 
-* add missing `asyncMeta` during VNode cloning ([#7861](https://github.com/vuejs/vue/issues/7861)) ([8227fb3](https://github.com/vuejs/vue/commit/8227fb35240ab1f301c30a6ad5d4d25071fa7996))
-* beforeUpdate should be called before render and allow state mutation ([#7822](https://github.com/vuejs/vue/issues/7822)) ([b7445a2](https://github.com/vuejs/vue/commit/b7445a2b945dcded287601ace8e711ab5cf35ab5)), closes [#7481](https://github.com/vuejs/vue/issues/7481)
-* **codegen:** support IE11 and Edge use of "Esc" key ([#7887](https://github.com/vuejs/vue/issues/7887)) ([1bd6196](https://github.com/vuejs/vue/commit/1bd6196fb234c28754d9a27095afe0b5b84990ad)), closes [#7880](https://github.com/vuejs/vue/issues/7880)
-* correct the `has` implementation in the `_renderProxy` ([#7878](https://github.com/vuejs/vue/issues/7878)) ([7b38739](https://github.com/vuejs/vue/commit/7b387390aa917edffc0eabce0b4186ea1ef40e2c))
-* ensure init/prepatch hooks are still repsected ([de42278](https://github.com/vuejs/vue/commit/de42278d34f6a800cec5c7eb781c1b8b83a829dd)), closes [vue-router#1338](https://github.com/vue-router/issues/1338)
-* invoke component node create hooks before insertion ([#7823](https://github.com/vuejs/vue/issues/7823)) ([f43ce3a](https://github.com/vuejs/vue/commit/f43ce3a5d8f73e273f2d03c9d86ea5662cda481a)), closes [#7531](https://github.com/vuejs/vue/issues/7531)
-* **observer:** invoke getters on initial observation if setter defined ([#7828](https://github.com/vuejs/vue/issues/7828)) ([7a145d8](https://github.com/vuejs/vue/commit/7a145d86430bad65271f4d6ab1344b215fefe52a))
-
+- add missing `asyncMeta` during VNode cloning ([#7861](https://github.com/vuejs/vue/issues/7861)) ([8227fb3](https://github.com/vuejs/vue/commit/8227fb35240ab1f301c30a6ad5d4d25071fa7996))
+- beforeUpdate should be called before render and allow state mutation ([#7822](https://github.com/vuejs/vue/issues/7822)) ([b7445a2](https://github.com/vuejs/vue/commit/b7445a2b945dcded287601ace8e711ab5cf35ab5)), closes [#7481](https://github.com/vuejs/vue/issues/7481)
+- **codegen:** support IE11 and Edge use of "Esc" key ([#7887](https://github.com/vuejs/vue/issues/7887)) ([1bd6196](https://github.com/vuejs/vue/commit/1bd6196fb234c28754d9a27095afe0b5b84990ad)), closes [#7880](https://github.com/vuejs/vue/issues/7880)
+- correct the `has` implementation in the `_renderProxy` ([#7878](https://github.com/vuejs/vue/issues/7878)) ([7b38739](https://github.com/vuejs/vue/commit/7b387390aa917edffc0eabce0b4186ea1ef40e2c))
+- ensure init/prepatch hooks are still repsected ([de42278](https://github.com/vuejs/vue/commit/de42278d34f6a800cec5c7eb781c1b8b83a829dd)), closes [vue-router#1338](https://github.com/vue-router/issues/1338)
+- invoke component node create hooks before insertion ([#7823](https://github.com/vuejs/vue/issues/7823)) ([f43ce3a](https://github.com/vuejs/vue/commit/f43ce3a5d8f73e273f2d03c9d86ea5662cda481a)), closes [#7531](https://github.com/vuejs/vue/issues/7531)
+- **observer:** invoke getters on initial observation if setter defined ([#7828](https://github.com/vuejs/vue/issues/7828)) ([7a145d8](https://github.com/vuejs/vue/commit/7a145d86430bad65271f4d6ab1344b215fefe52a))
 
 ### Performance Improvements
 
-* avoid unnecessary re-renders when computed property value did not change ([#7824](https://github.com/vuejs/vue/issues/7824)) ([653aac2](https://github.com/vuejs/vue/commit/653aac2c57d15f0e93a2c1cc7e6fad156658df19)), closes [#7767](https://github.com/vuejs/vue/issues/7767)
-
+- avoid unnecessary re-renders when computed property value did not change ([#7824](https://github.com/vuejs/vue/issues/7824)) ([653aac2](https://github.com/vuejs/vue/commit/653aac2c57d15f0e93a2c1cc7e6fad156658df19)), closes [#7767](https://github.com/vuejs/vue/issues/7767)
 
 ### Reverts
 
-* Revert "refactor: remove unnecessary checks (#7875)" ([903be9b](https://github.com/vuejs/vue/commit/903be9b91f7c41d40e228676df9d66d2c064fe23)), closes [#7875](https://github.com/vuejs/vue/issues/7875)
-
-
+- Revert "refactor: remove unnecessary checks (#7875)" ([903be9b](https://github.com/vuejs/vue/commit/903be9b91f7c41d40e228676df9d66d2c064fe23)), closes [#7875](https://github.com/vuejs/vue/issues/7875)
 
 ## [2.5.16](https://github.com/vuejs/vue/compare/v2.5.15...v2.5.16) (2018-03-13)
 
-
 ### Bug Fixes
 
-* allow multiline expression in v-for ([71b4b25](https://github.com/vuejs/vue/commit/71b4b25375fa4bcd929e1161c35cab133e4a7c23)), closes [#7792](https://github.com/vuejs/vue/issues/7792)
-* **core:** Make set/delete warning condition for undefined, null and ([#7818](https://github.com/vuejs/vue/issues/7818)) ([9084747](https://github.com/vuejs/vue/commit/9084747e307dc9b415ff8e2a788c6a585a2a8f6c)), closes [#7452](https://github.com/vuejs/vue/issues/7452)
-* fix keyName checking for arrow keys in IE11 ([4378fc5](https://github.com/vuejs/vue/commit/4378fc5124067c2b3a3517dd7f527edd9be2ad37)), closes [#7806](https://github.com/vuejs/vue/issues/7806)
-* fix regression on duplicate component init when using shared data objects ([984927a](https://github.com/vuejs/vue/commit/984927a1a98d10ad8af44f2accfb08d34d517610)), closes [#7805](https://github.com/vuejs/vue/issues/7805)
-* fix wrongly matched named slots in functional components ([62a922e](https://github.com/vuejs/vue/commit/62a922e865f5e578f67b386cb614abfc173d7851)), closes [#7817](https://github.com/vuejs/vue/issues/7817)
-* **keep-alive:** run prune after render for correct active component check ([215f877](https://github.com/vuejs/vue/commit/215f877d1b7eb6583f7adf15676ead8611f07379)), closes [#7566](https://github.com/vuejs/vue/issues/7566)
-* **model:** fix static input type being overwritten by v-bind object ([#7819](https://github.com/vuejs/vue/issues/7819)) ([a6169d1](https://github.com/vuejs/vue/commit/a6169d1eb71d64eacddf1738e72d21725e2bff00)), closes [#7811](https://github.com/vuejs/vue/issues/7811)
-* named slots for nested functional components ([6dd73e9](https://github.com/vuejs/vue/commit/6dd73e9ee44c09f04d3f616fcce18750a55e2e4f)), closes [#7710](https://github.com/vuejs/vue/issues/7710)
-* **ssr:** fix SSR for async functional components ([882e719](https://github.com/vuejs/vue/commit/882e7199fd8eee039291c4b9f7f324dcf46f32fd)), closes [#7784](https://github.com/vuejs/vue/issues/7784)
-* **ssr:** fix v-show inline style rendering when style binding is array ([#7814](https://github.com/vuejs/vue/issues/7814)) ([1a979c4](https://github.com/vuejs/vue/commit/1a979c44d6543d89f8a7e26ad7f995b1bf2aee3c)), closes [#7813](https://github.com/vuejs/vue/issues/7813)
-
-
+- allow multiline expression in v-for ([71b4b25](https://github.com/vuejs/vue/commit/71b4b25375fa4bcd929e1161c35cab133e4a7c23)), closes [#7792](https://github.com/vuejs/vue/issues/7792)
+- **core:** Make set/delete warning condition for undefined, null and ([#7818](https://github.com/vuejs/vue/issues/7818)) ([9084747](https://github.com/vuejs/vue/commit/9084747e307dc9b415ff8e2a788c6a585a2a8f6c)), closes [#7452](https://github.com/vuejs/vue/issues/7452)
+- fix keyName checking for arrow keys in IE11 ([4378fc5](https://github.com/vuejs/vue/commit/4378fc5124067c2b3a3517dd7f527edd9be2ad37)), closes [#7806](https://github.com/vuejs/vue/issues/7806)
+- fix regression on duplicate component init when using shared data objects ([984927a](https://github.com/vuejs/vue/commit/984927a1a98d10ad8af44f2accfb08d34d517610)), closes [#7805](https://github.com/vuejs/vue/issues/7805)
+- fix wrongly matched named slots in functional components ([62a922e](https://github.com/vuejs/vue/commit/62a922e865f5e578f67b386cb614abfc173d7851)), closes [#7817](https://github.com/vuejs/vue/issues/7817)
+- **keep-alive:** run prune after render for correct active component check ([215f877](https://github.com/vuejs/vue/commit/215f877d1b7eb6583f7adf15676ead8611f07379)), closes [#7566](https://github.com/vuejs/vue/issues/7566)
+- **model:** fix static input type being overwritten by v-bind object ([#7819](https://github.com/vuejs/vue/issues/7819)) ([a6169d1](https://github.com/vuejs/vue/commit/a6169d1eb71d64eacddf1738e72d21725e2bff00)), closes [#7811](https://github.com/vuejs/vue/issues/7811)
+- named slots for nested functional components ([6dd73e9](https://github.com/vuejs/vue/commit/6dd73e9ee44c09f04d3f616fcce18750a55e2e4f)), closes [#7710](https://github.com/vuejs/vue/issues/7710)
+- **ssr:** fix SSR for async functional components ([882e719](https://github.com/vuejs/vue/commit/882e7199fd8eee039291c4b9f7f324dcf46f32fd)), closes [#7784](https://github.com/vuejs/vue/issues/7784)
+- **ssr:** fix v-show inline style rendering when style binding is array ([#7814](https://github.com/vuejs/vue/issues/7814)) ([1a979c4](https://github.com/vuejs/vue/commit/1a979c44d6543d89f8a7e26ad7f995b1bf2aee3c)), closes [#7813](https://github.com/vuejs/vue/issues/7813)
 
 ## [2.5.15](https://github.com/vuejs/vue/compare/v2.5.14...v2.5.15) (2018-03-10)
 
-
 ### Bug Fixes
 
-* do not traverse VNodes when regsitering dependencies ([84a9a9d](https://github.com/vuejs/vue/commit/84a9a9d61057f6f40a9ad2bee456b39ef0a8f001)), closes [#7786](https://github.com/vuejs/vue/issues/7786)
-
-
+- do not traverse VNodes when regsitering dependencies ([84a9a9d](https://github.com/vuejs/vue/commit/84a9a9d61057f6f40a9ad2bee456b39ef0a8f001)), closes [#7786](https://github.com/vuejs/vue/issues/7786)
 
 ## [2.5.14](https://github.com/vuejs/vue/compare/v2.5.13...v2.5.14) (2018-03-09)
 
-
 ### Bug Fixes
 
-* address potential regex backtrack ([cd33407](https://github.com/vuejs/vue/commit/cd334070f3b82d3f5892c4999cc290ccd4f56fd8))
-* allow codebase to be inlined directly in HTML ([#7314](https://github.com/vuejs/vue/issues/7314)) ([dccd182](https://github.com/vuejs/vue/commit/dccd182b6763d8ef1871949029c85495ca958246)), closes [#7298](https://github.com/vuejs/vue/issues/7298)
-* always install composition event listeners ([f7ca21e](https://github.com/vuejs/vue/commit/f7ca21eab1e0d661945aa6070fc988028c90966f)), closes [#7367](https://github.com/vuejs/vue/issues/7367)
-* clean up custom events when patched component no longer have events ([d8b0838](https://github.com/vuejs/vue/commit/d8b08387a293c99b95c1efcf2517447335a618db)), closes [#7294](https://github.com/vuejs/vue/issues/7294)
-* **codegen:** support filters with () in older browsers ([#7545](https://github.com/vuejs/vue/issues/7545)) ([dc97a39](https://github.com/vuejs/vue/commit/dc97a39c2f41ce57431d42d8b41811866f8e105c)), closes [#7544](https://github.com/vuejs/vue/issues/7544)
-* **core:** disable dependency collection in lifecycle hooks and data getter ([#7596](https://github.com/vuejs/vue/issues/7596)) ([318f29f](https://github.com/vuejs/vue/commit/318f29fcdf3372ff57a09be6d1dc595d14c92e70)), closes [#7573](https://github.com/vuejs/vue/issues/7573)
-* **core:** handle edge cases for functional component returning arrays ([8335217](https://github.com/vuejs/vue/commit/8335217cb4bd13fb07e08a76c07df0fceed6c197)), closes [#7282](https://github.com/vuejs/vue/issues/7282)
-* do not special case attributes for custom elements ([50b711a](https://github.com/vuejs/vue/commit/50b711af43708426e63b4ea529436b49fafc3f2e)), closes [#6864](https://github.com/vuejs/vue/issues/6864) [#6885](https://github.com/vuejs/vue/issues/6885)
-* fix config.productionTip ([ced00b1](https://github.com/vuejs/vue/commit/ced00b1dec8326a653cce225133927fe5b4a3109)), closes [#7565](https://github.com/vuejs/vue/issues/7565)
-* fix ssr env detection in weex ([#7375](https://github.com/vuejs/vue/issues/7375)) ([3eb37ac](https://github.com/vuejs/vue/commit/3eb37acf98e2d9737de897ebe7bdb7e9576bcc21))
-* **inject:** use hasOwn instead of 'in' for provideKey check ([#7460](https://github.com/vuejs/vue/issues/7460)) ([733c1be](https://github.com/vuejs/vue/commit/733c1be7f5983cdd9e8089a8088b235ba21a4dee)), closes [#7284](https://github.com/vuejs/vue/issues/7284)
-* install ssr helpers for functional context during SSR ([9b22d86](https://github.com/vuejs/vue/commit/9b22d86ab315a3c6061a6a4776eab1964304f92e)), closes [#7443](https://github.com/vuejs/vue/issues/7443) [nuxt/nuxt.js#2565](https://github.com/nuxt/nuxt.js/issues/2565)
-* **model:** fix array index binding for v-model checkbox ([#7671](https://github.com/vuejs/vue/issues/7671)) ([550c3c0](https://github.com/vuejs/vue/commit/550c3c0d14af5485bb7e507c504664a7136e9bf9)), closes [#7670](https://github.com/vuejs/vue/issues/7670)
-* **observer:** do not invoke getters on initial observation  ([#7302](https://github.com/vuejs/vue/issues/7302)) ([7392dfc](https://github.com/vuejs/vue/commit/7392dfcc1d5fd7b257df5ae134f9eb2f0cc0a51e)), closes [#7280](https://github.com/vuejs/vue/issues/7280)
-* **ref:** allow ref key to be zero ([#7676](https://github.com/vuejs/vue/issues/7676)) ([e396eb3](https://github.com/vuejs/vue/commit/e396eb3445904f11232f2355f03e8356173d0e31)), closes [#7669](https://github.com/vuejs/vue/issues/7669)
-* respect type order when boolean casting multi-typed props ([81e1e47](https://github.com/vuejs/vue/commit/81e1e47cabbd479e2a285f03120944f1efffe749)), closes [#7485](https://github.com/vuejs/vue/issues/7485)
-* **show:** prevent transitions from starting on change truthy values ([#7524](https://github.com/vuejs/vue/issues/7524)) ([013d980](https://github.com/vuejs/vue/commit/013d98092868a0c6721831e91616c64f99119b74)), closes [#7523](https://github.com/vuejs/vue/issues/7523)
-* skip v-model & value binding collision check with dynamic type binding ([#7406](https://github.com/vuejs/vue/issues/7406)) ([1c0b4af](https://github.com/vuejs/vue/commit/1c0b4af5fd2f9e8173b8f4718018ee80a6313872)), closes [#7404](https://github.com/vuejs/vue/issues/7404)
-* support KeyboardEvent.key in built-in keyboard event modifiers ([#7121](https://github.com/vuejs/vue/issues/7121)) ([1c8e2e8](https://github.com/vuejs/vue/commit/1c8e2e88ed2d74a02178217b318564b73a096c18)), closes [#6900](https://github.com/vuejs/vue/issues/6900)
-* **transition:** should not add transition class when cancelled ([#7391](https://github.com/vuejs/vue/issues/7391)) ([5191f13](https://github.com/vuejs/vue/commit/5191f13472d1fc37bdd601079970201fde6bf13e)), closes [#7390](https://github.com/vuejs/vue/issues/7390)
-* **types:** add missing `listeners` type on RenderContext ([#7584](https://github.com/vuejs/vue/issues/7584)) ([db1b18c](https://github.com/vuejs/vue/commit/db1b18ceec51761f1bcd6160c51e02b36b86a9c2))
-* **types:** contravariant generic default in ComponentOption ([#7369](https://github.com/vuejs/vue/issues/7369)) ([6ee6849](https://github.com/vuejs/vue/commit/6ee684983b1f3384a4050d7c47cee7c6a325db8b))
-* **types:** fix wrong errorCaptured type ([#7712](https://github.com/vuejs/vue/issues/7712)) ([6b8516b](https://github.com/vuejs/vue/commit/6b8516b2dde52be643ee6855b45b253a17ed0461))
-* **types:** make render option in functional components to optional ([#7663](https://github.com/vuejs/vue/issues/7663)) ([b2092db](https://github.com/vuejs/vue/commit/b2092dbff9ab0ccfa8e59ed3ca540cca0715c683))
-* **types:** make VNodeChildrenArrayContents type more accurate ([#7287](https://github.com/vuejs/vue/issues/7287)) ([49aae6b](https://github.com/vuejs/vue/commit/49aae6bb157e0650507974b7a9a1b0f2215e400b))
-* **types:** prefer normal component over functional one ([#7687](https://github.com/vuejs/vue/issues/7687)) ([144bf5a](https://github.com/vuejs/vue/commit/144bf5a99e2ebd644f80bc8ab61cd1bf0366961a))
-* **v-model:** handle trailing whitespaces in expression ([#7737](https://github.com/vuejs/vue/issues/7737)) ([db58493](https://github.com/vuejs/vue/commit/db584931e20f9ad4b423cfc14d587f9d0240a565))
-* **v-on:** return handler value when using modifiers ([#7704](https://github.com/vuejs/vue/issues/7704)) ([6bc75ca](https://github.com/vuejs/vue/commit/6bc75cacb72c0cc7f3d1041b5d9ff447ac2f5f69))
-* **vdom:** svg inside foreignObject should be rendered with correct namespace (fix [#7330](https://github.com/vuejs/vue/issues/7330)) ([#7350](https://github.com/vuejs/vue/issues/7350)) ([0529961](https://github.com/vuejs/vue/commit/05299610ea3e89ddbcfe4d8ede0c298223766423))
-* **weex:** default value for editor, fix [#7165](https://github.com/vuejs/vue/issues/7165) ([#7286](https://github.com/vuejs/vue/issues/7286)) ([e055df8](https://github.com/vuejs/vue/commit/e055df82fec0e76e4bc65e5a265b42e208595430))
-
+- address potential regex backtrack ([cd33407](https://github.com/vuejs/vue/commit/cd334070f3b82d3f5892c4999cc290ccd4f56fd8))
+- allow codebase to be inlined directly in HTML ([#7314](https://github.com/vuejs/vue/issues/7314)) ([dccd182](https://github.com/vuejs/vue/commit/dccd182b6763d8ef1871949029c85495ca958246)), closes [#7298](https://github.com/vuejs/vue/issues/7298)
+- always install composition event listeners ([f7ca21e](https://github.com/vuejs/vue/commit/f7ca21eab1e0d661945aa6070fc988028c90966f)), closes [#7367](https://github.com/vuejs/vue/issues/7367)
+- clean up custom events when patched component no longer have events ([d8b0838](https://github.com/vuejs/vue/commit/d8b08387a293c99b95c1efcf2517447335a618db)), closes [#7294](https://github.com/vuejs/vue/issues/7294)
+- **codegen:** support filters with () in older browsers ([#7545](https://github.com/vuejs/vue/issues/7545)) ([dc97a39](https://github.com/vuejs/vue/commit/dc97a39c2f41ce57431d42d8b41811866f8e105c)), closes [#7544](https://github.com/vuejs/vue/issues/7544)
+- **core:** disable dependency collection in lifecycle hooks and data getter ([#7596](https://github.com/vuejs/vue/issues/7596)) ([318f29f](https://github.com/vuejs/vue/commit/318f29fcdf3372ff57a09be6d1dc595d14c92e70)), closes [#7573](https://github.com/vuejs/vue/issues/7573)
+- **core:** handle edge cases for functional component returning arrays ([8335217](https://github.com/vuejs/vue/commit/8335217cb4bd13fb07e08a76c07df0fceed6c197)), closes [#7282](https://github.com/vuejs/vue/issues/7282)
+- do not special case attributes for custom elements ([50b711a](https://github.com/vuejs/vue/commit/50b711af43708426e63b4ea529436b49fafc3f2e)), closes [#6864](https://github.com/vuejs/vue/issues/6864) [#6885](https://github.com/vuejs/vue/issues/6885)
+- fix config.productionTip ([ced00b1](https://github.com/vuejs/vue/commit/ced00b1dec8326a653cce225133927fe5b4a3109)), closes [#7565](https://github.com/vuejs/vue/issues/7565)
+- fix ssr env detection in weex ([#7375](https://github.com/vuejs/vue/issues/7375)) ([3eb37ac](https://github.com/vuejs/vue/commit/3eb37acf98e2d9737de897ebe7bdb7e9576bcc21))
+- **inject:** use hasOwn instead of 'in' for provideKey check ([#7460](https://github.com/vuejs/vue/issues/7460)) ([733c1be](https://github.com/vuejs/vue/commit/733c1be7f5983cdd9e8089a8088b235ba21a4dee)), closes [#7284](https://github.com/vuejs/vue/issues/7284)
+- install ssr helpers for functional context during SSR ([9b22d86](https://github.com/vuejs/vue/commit/9b22d86ab315a3c6061a6a4776eab1964304f92e)), closes [#7443](https://github.com/vuejs/vue/issues/7443) [nuxt/nuxt.js#2565](https://github.com/nuxt/nuxt.js/issues/2565)
+- **model:** fix array index binding for v-model checkbox ([#7671](https://github.com/vuejs/vue/issues/7671)) ([550c3c0](https://github.com/vuejs/vue/commit/550c3c0d14af5485bb7e507c504664a7136e9bf9)), closes [#7670](https://github.com/vuejs/vue/issues/7670)
+- **observer:** do not invoke getters on initial observation ([#7302](https://github.com/vuejs/vue/issues/7302)) ([7392dfc](https://github.com/vuejs/vue/commit/7392dfcc1d5fd7b257df5ae134f9eb2f0cc0a51e)), closes [#7280](https://github.com/vuejs/vue/issues/7280)
+- **ref:** allow ref key to be zero ([#7676](https://github.com/vuejs/vue/issues/7676)) ([e396eb3](https://github.com/vuejs/vue/commit/e396eb3445904f11232f2355f03e8356173d0e31)), closes [#7669](https://github.com/vuejs/vue/issues/7669)
+- respect type order when boolean casting multi-typed props ([81e1e47](https://github.com/vuejs/vue/commit/81e1e47cabbd479e2a285f03120944f1efffe749)), closes [#7485](https://github.com/vuejs/vue/issues/7485)
+- **show:** prevent transitions from starting on change truthy values ([#7524](https://github.com/vuejs/vue/issues/7524)) ([013d980](https://github.com/vuejs/vue/commit/013d98092868a0c6721831e91616c64f99119b74)), closes [#7523](https://github.com/vuejs/vue/issues/7523)
+- skip v-model & value binding collision check with dynamic type binding ([#7406](https://github.com/vuejs/vue/issues/7406)) ([1c0b4af](https://github.com/vuejs/vue/commit/1c0b4af5fd2f9e8173b8f4718018ee80a6313872)), closes [#7404](https://github.com/vuejs/vue/issues/7404)
+- support KeyboardEvent.key in built-in keyboard event modifiers ([#7121](https://github.com/vuejs/vue/issues/7121)) ([1c8e2e8](https://github.com/vuejs/vue/commit/1c8e2e88ed2d74a02178217b318564b73a096c18)), closes [#6900](https://github.com/vuejs/vue/issues/6900)
+- **transition:** should not add transition class when cancelled ([#7391](https://github.com/vuejs/vue/issues/7391)) ([5191f13](https://github.com/vuejs/vue/commit/5191f13472d1fc37bdd601079970201fde6bf13e)), closes [#7390](https://github.com/vuejs/vue/issues/7390)
+- **types:** add missing `listeners` type on RenderContext ([#7584](https://github.com/vuejs/vue/issues/7584)) ([db1b18c](https://github.com/vuejs/vue/commit/db1b18ceec51761f1bcd6160c51e02b36b86a9c2))
+- **types:** contravariant generic default in ComponentOption ([#7369](https://github.com/vuejs/vue/issues/7369)) ([6ee6849](https://github.com/vuejs/vue/commit/6ee684983b1f3384a4050d7c47cee7c6a325db8b))
+- **types:** fix wrong errorCaptured type ([#7712](https://github.com/vuejs/vue/issues/7712)) ([6b8516b](https://github.com/vuejs/vue/commit/6b8516b2dde52be643ee6855b45b253a17ed0461))
+- **types:** make render option in functional components to optional ([#7663](https://github.com/vuejs/vue/issues/7663)) ([b2092db](https://github.com/vuejs/vue/commit/b2092dbff9ab0ccfa8e59ed3ca540cca0715c683))
+- **types:** make VNodeChildrenArrayContents type more accurate ([#7287](https://github.com/vuejs/vue/issues/7287)) ([49aae6b](https://github.com/vuejs/vue/commit/49aae6bb157e0650507974b7a9a1b0f2215e400b))
+- **types:** prefer normal component over functional one ([#7687](https://github.com/vuejs/vue/issues/7687)) ([144bf5a](https://github.com/vuejs/vue/commit/144bf5a99e2ebd644f80bc8ab61cd1bf0366961a))
+- **v-model:** handle trailing whitespaces in expression ([#7737](https://github.com/vuejs/vue/issues/7737)) ([db58493](https://github.com/vuejs/vue/commit/db584931e20f9ad4b423cfc14d587f9d0240a565))
+- **v-on:** return handler value when using modifiers ([#7704](https://github.com/vuejs/vue/issues/7704)) ([6bc75ca](https://github.com/vuejs/vue/commit/6bc75cacb72c0cc7f3d1041b5d9ff447ac2f5f69))
+- **vdom:** svg inside foreignObject should be rendered with correct namespace (fix [#7330](https://github.com/vuejs/vue/issues/7330)) ([#7350](https://github.com/vuejs/vue/issues/7350)) ([0529961](https://github.com/vuejs/vue/commit/05299610ea3e89ddbcfe4d8ede0c298223766423))
+- **weex:** default value for editor, fix [#7165](https://github.com/vuejs/vue/issues/7165) ([#7286](https://github.com/vuejs/vue/issues/7286)) ([e055df8](https://github.com/vuejs/vue/commit/e055df82fec0e76e4bc65e5a265b42e208595430))
 
 ### Features
 
-* support v-model dynamic type binding for v-bind="object" ([41838c8](https://github.com/vuejs/vue/commit/41838c8e8632ba78791996fbc697080b2764bb6a)), closes [#7296](https://github.com/vuejs/vue/issues/7296)
-* **weex:** adjust framework entry APIs and add flow annotations ([#7272](https://github.com/vuejs/vue/issues/7272)) ([472a289](https://github.com/vuejs/vue/commit/472a2896bd4f156be168edfecb6ac432b853beb4))
-* **weex:** support parse object literal in binding attrs and styles ([#7291](https://github.com/vuejs/vue/issues/7291)) ([ff8fcd2](https://github.com/vuejs/vue/commit/ff8fcd2e2b95694527018f7836bab781f8600d25))
-* **weex:** update new syntax for <recycle-list> ([7cc0b55](https://github.com/vuejs/vue/commit/7cc0b559e9e57fcb3baeae5d8d4c8964aa335b5e))
-* **weex:** update weex recycle-list compiler ([#7610](https://github.com/vuejs/vue/issues/7610)) ([d6200d7](https://github.com/vuejs/vue/commit/d6200d70261c4a8943190900e0721ede1c4a4f2b))
-
-
+- support v-model dynamic type binding for v-bind="object" ([41838c8](https://github.com/vuejs/vue/commit/41838c8e8632ba78791996fbc697080b2764bb6a)), closes [#7296](https://github.com/vuejs/vue/issues/7296)
+- **weex:** adjust framework entry APIs and add flow annotations ([#7272](https://github.com/vuejs/vue/issues/7272)) ([472a289](https://github.com/vuejs/vue/commit/472a2896bd4f156be168edfecb6ac432b853beb4))
+- **weex:** support parse object literal in binding attrs and styles ([#7291](https://github.com/vuejs/vue/issues/7291)) ([ff8fcd2](https://github.com/vuejs/vue/commit/ff8fcd2e2b95694527018f7836bab781f8600d25))
+- **weex:** update new syntax for <recycle-list> ([7cc0b55](https://github.com/vuejs/vue/commit/7cc0b559e9e57fcb3baeae5d8d4c8964aa335b5e))
+- **weex:** update weex recycle-list compiler ([#7610](https://github.com/vuejs/vue/issues/7610)) ([d6200d7](https://github.com/vuejs/vue/commit/d6200d70261c4a8943190900e0721ede1c4a4f2b))
 
 ## [2.5.13](https://github.com/vuejs/vue/compare/v2.5.12...v2.5.13) (2017-12-19)
 
-
 ### Reverts
 
-* Revert "feat: auto cache inline prop literals to avoid child re-render" ([aac7634](https://github.com/vuejs/vue/commit/aac76349e70fe0971ee24a7a1f3dada0e3459fb8))
-
-
+- Revert "feat: auto cache inline prop literals to avoid child re-render" ([aac7634](https://github.com/vuejs/vue/commit/aac76349e70fe0971ee24a7a1f3dada0e3459fb8))
 
 ## [2.5.12](https://github.com/vuejs/vue/compare/v2.5.11...v2.5.12) (2017-12-19)
 
-
 ### Bug Fixes
 
-* **warning:** allow symbol as vdom key ([#7271](https://github.com/vuejs/vue/issues/7271)) ([bacb911](https://github.com/vuejs/vue/commit/bacb911f7df09ff4868b4c848a6d7778872dff5c))
-* **weex:** append as tree by default for recycle-list and cell-slot ([#7216](https://github.com/vuejs/vue/issues/7216)) ([d544d05](https://github.com/vuejs/vue/commit/d544d052a9c5ec113c253895211296120d58b6ab))
-* **weex:** update recycle-list v-for transform ([0ee81b2](https://github.com/vuejs/vue/commit/0ee81b24b5146bca315503e2f5aa3b01832735f1))
-
+- **warning:** allow symbol as vdom key ([#7271](https://github.com/vuejs/vue/issues/7271)) ([bacb911](https://github.com/vuejs/vue/commit/bacb911f7df09ff4868b4c848a6d7778872dff5c))
+- **weex:** append as tree by default for recycle-list and cell-slot ([#7216](https://github.com/vuejs/vue/issues/7216)) ([d544d05](https://github.com/vuejs/vue/commit/d544d052a9c5ec113c253895211296120d58b6ab))
+- **weex:** update recycle-list v-for transform ([0ee81b2](https://github.com/vuejs/vue/commit/0ee81b24b5146bca315503e2f5aa3b01832735f1))
 
 ### Features
 
-* **$compiler:** compile weex native directives in preTransformNode ([2d09ee3](https://github.com/vuejs/vue/commit/2d09ee3b8ce37e201d3973587d1cb442d5e08f31))
-* **$compiler:** supports compiling v-bind to the weex native directive in recycle-list ([8b893c1](https://github.com/vuejs/vue/commit/8b893c13d6ffa79f294fec76a228509ec48e4706))
-* **$compiler:** supports compiling v-else-if and v-else to the weex native directive ([2a1ce0d](https://github.com/vuejs/vue/commit/2a1ce0d92cb12c18f945f69ee5cb6914b389e35e))
-* **$compiler:** supports compiling v-for to the weex native directive ([9bd1483](https://github.com/vuejs/vue/commit/9bd1483803d046877bef4f7adf1d3a942085ea1b))
-* **$event:** support binding parameters on event handler within weex recycle-list ([acdc3c4](https://github.com/vuejs/vue/commit/acdc3c46e98919faa50b3e4cc308ab73b1a60bfe))
-* auto cache inline prop literals to avoid child re-render ([996eb00](https://github.com/vuejs/vue/commit/996eb00a0a0933376c9364c2d187e2bf0512ff0d))
-* **compile:** supports compiling v-if to the weex native directive ([7ad368e](https://github.com/vuejs/vue/commit/7ad368ebb6987bd4044f9df184d73ce14ca680f2))
-* **types:** extract VueConfiguration type for easy expansion ([#7273](https://github.com/vuejs/vue/issues/7273)) ([#7274](https://github.com/vuejs/vue/issues/7274)) ([c0d516c](https://github.com/vuejs/vue/commit/c0d516c283aa1a1c238b6eb8b8e55f64770d27e8))
-* **weex:** generate "[@render](https://github.com/render)" function for weex recycle-list ([#6987](https://github.com/vuejs/vue/issues/6987)) ([0c11aa8](https://github.com/vuejs/vue/commit/0c11aa8addf5ad852e37da358ce2887af72e4193))
-* **weex:** partially support lifecycles of virtual component ([#7242](https://github.com/vuejs/vue/issues/7242)) ([661bfe5](https://github.com/vuejs/vue/commit/661bfe552e16d3a7036012021ae3746cfc02710e))
-* **weex:** pass stateless component test case ([452a65c](https://github.com/vuejs/vue/commit/452a65c98a9354bb529185638475b72d8ca19543))
-* **weex:** recycle-list support stateful child component ([70b97ac](https://github.com/vuejs/vue/commit/70b97ac2f43099a57ce2fb0a23dea0553ba95189))
-* **weex:** recycle-list support WIP ([5254ee3](https://github.com/vuejs/vue/commit/5254ee31c481ac16cf8f822b0b4df0f7815ffff3))
-* **weex:** split text into separate module ([c104cc5](https://github.com/vuejs/vue/commit/c104cc582d647f5e10b90563cb80907b9e30ec12))
-* **weex:** support compiling `v-on` in the weex native directive ([#6892](https://github.com/vuejs/vue/issues/6892)) ([2cb8ea3](https://github.com/vuejs/vue/commit/2cb8ea3fee741807a15bf8f3049ab062a7d9508c))
-* **weex:** update weex utils ([#7115](https://github.com/vuejs/vue/issues/7115)) ([3b32652](https://github.com/vuejs/vue/commit/3b32652aa68a06d881e3149bb21ac8711887e7f6))
-* **weex:** WIP adjust component transform stage ([62e47c9](https://github.com/vuejs/vue/commit/62e47c9eb4446da79d66ad2385c199f31b4348d8))
-* **weex:** WIP fix flow + handle errors in recycle-list template render ([5c2ce00](https://github.com/vuejs/vue/commit/5c2ce0017ff8929e70ce9f701b91d950fb351adb))
-* **weex:** WIP implement virtual component ([#7165](https://github.com/vuejs/vue/issues/7165)) ([b8d33ec](https://github.com/vuejs/vue/commit/b8d33ecd9ab8b7a46d8558b4e2caf506235cd165))
-* **weex:** WIP invoke recycle-list child component with backing instance ([801f793](https://github.com/vuejs/vue/commit/801f793625273b39fd3f25abbaa04508d6651563))
-* **weex:** WIP mark recycle list child component root ([88f3889](https://github.com/vuejs/vue/commit/88f3889f19678981944339be8d22c3ebcd11f822))
-* **wip:** recycle list template inline expand ([ac99957](https://github.com/vuejs/vue/commit/ac999573ea6e4be3a421cdff79d66a5274ec58eb))
-
+- **$compiler:** compile weex native directives in preTransformNode ([2d09ee3](https://github.com/vuejs/vue/commit/2d09ee3b8ce37e201d3973587d1cb442d5e08f31))
+- **$compiler:** supports compiling v-bind to the weex native directive in recycle-list ([8b893c1](https://github.com/vuejs/vue/commit/8b893c13d6ffa79f294fec76a228509ec48e4706))
+- **$compiler:** supports compiling v-else-if and v-else to the weex native directive ([2a1ce0d](https://github.com/vuejs/vue/commit/2a1ce0d92cb12c18f945f69ee5cb6914b389e35e))
+- **$compiler:** supports compiling v-for to the weex native directive ([9bd1483](https://github.com/vuejs/vue/commit/9bd1483803d046877bef4f7adf1d3a942085ea1b))
+- **$event:** support binding parameters on event handler within weex recycle-list ([acdc3c4](https://github.com/vuejs/vue/commit/acdc3c46e98919faa50b3e4cc308ab73b1a60bfe))
+- auto cache inline prop literals to avoid child re-render ([996eb00](https://github.com/vuejs/vue/commit/996eb00a0a0933376c9364c2d187e2bf0512ff0d))
+- **compile:** supports compiling v-if to the weex native directive ([7ad368e](https://github.com/vuejs/vue/commit/7ad368ebb6987bd4044f9df184d73ce14ca680f2))
+- **types:** extract VueConfiguration type for easy expansion ([#7273](https://github.com/vuejs/vue/issues/7273)) ([#7274](https://github.com/vuejs/vue/issues/7274)) ([c0d516c](https://github.com/vuejs/vue/commit/c0d516c283aa1a1c238b6eb8b8e55f64770d27e8))
+- **weex:** generate "[@render](https://github.com/render)" function for weex recycle-list ([#6987](https://github.com/vuejs/vue/issues/6987)) ([0c11aa8](https://github.com/vuejs/vue/commit/0c11aa8addf5ad852e37da358ce2887af72e4193))
+- **weex:** partially support lifecycles of virtual component ([#7242](https://github.com/vuejs/vue/issues/7242)) ([661bfe5](https://github.com/vuejs/vue/commit/661bfe552e16d3a7036012021ae3746cfc02710e))
+- **weex:** pass stateless component test case ([452a65c](https://github.com/vuejs/vue/commit/452a65c98a9354bb529185638475b72d8ca19543))
+- **weex:** recycle-list support stateful child component ([70b97ac](https://github.com/vuejs/vue/commit/70b97ac2f43099a57ce2fb0a23dea0553ba95189))
+- **weex:** recycle-list support WIP ([5254ee3](https://github.com/vuejs/vue/commit/5254ee31c481ac16cf8f822b0b4df0f7815ffff3))
+- **weex:** split text into separate module ([c104cc5](https://github.com/vuejs/vue/commit/c104cc582d647f5e10b90563cb80907b9e30ec12))
+- **weex:** support compiling `v-on` in the weex native directive ([#6892](https://github.com/vuejs/vue/issues/6892)) ([2cb8ea3](https://github.com/vuejs/vue/commit/2cb8ea3fee741807a15bf8f3049ab062a7d9508c))
+- **weex:** update weex utils ([#7115](https://github.com/vuejs/vue/issues/7115)) ([3b32652](https://github.com/vuejs/vue/commit/3b32652aa68a06d881e3149bb21ac8711887e7f6))
+- **weex:** WIP adjust component transform stage ([62e47c9](https://github.com/vuejs/vue/commit/62e47c9eb4446da79d66ad2385c199f31b4348d8))
+- **weex:** WIP fix flow + handle errors in recycle-list template render ([5c2ce00](https://github.com/vuejs/vue/commit/5c2ce0017ff8929e70ce9f701b91d950fb351adb))
+- **weex:** WIP implement virtual component ([#7165](https://github.com/vuejs/vue/issues/7165)) ([b8d33ec](https://github.com/vuejs/vue/commit/b8d33ecd9ab8b7a46d8558b4e2caf506235cd165))
+- **weex:** WIP invoke recycle-list child component with backing instance ([801f793](https://github.com/vuejs/vue/commit/801f793625273b39fd3f25abbaa04508d6651563))
+- **weex:** WIP mark recycle list child component root ([88f3889](https://github.com/vuejs/vue/commit/88f3889f19678981944339be8d22c3ebcd11f822))
+- **wip:** recycle list template inline expand ([ac99957](https://github.com/vuejs/vue/commit/ac999573ea6e4be3a421cdff79d66a5274ec58eb))
 
 ### Reverts
 
-* revert prop object validation ([01c0750](https://github.com/vuejs/vue/commit/01c07503bf6af902dde06fafa8a0008ee3e303aa)), closes [#7279](https://github.com/vuejs/vue/issues/7279)
-* **weex:** remove the "receiveTasks" api and support component hook ([#7053](https://github.com/vuejs/vue/issues/7053)) ([0bf0cbe](https://github.com/vuejs/vue/commit/0bf0cbef76a9d107ea0d4fbd8f54f640a2c5b221))
-
-
+- revert prop object validation ([01c0750](https://github.com/vuejs/vue/commit/01c07503bf6af902dde06fafa8a0008ee3e303aa)), closes [#7279](https://github.com/vuejs/vue/issues/7279)
+- **weex:** remove the "receiveTasks" api and support component hook ([#7053](https://github.com/vuejs/vue/issues/7053)) ([0bf0cbe](https://github.com/vuejs/vue/commit/0bf0cbef76a9d107ea0d4fbd8f54f640a2c5b221))
 
 ## [2.5.11](https://github.com/vuejs/vue/compare/v2.5.10...v2.5.11) (2017-12-14)
 
-
 ### Bug Fixes
 
-* avoid unnecessary lowercase coersion in component name validation ([3f0c628](https://github.com/vuejs/vue/commit/3f0c628e2c0fe6bfaecc521c96c6cc12ff24c7c4)), closes [#7237](https://github.com/vuejs/vue/issues/7237)
-
+- avoid unnecessary lowercase coersion in component name validation ([3f0c628](https://github.com/vuejs/vue/commit/3f0c628e2c0fe6bfaecc521c96c6cc12ff24c7c4)), closes [#7237](https://github.com/vuejs/vue/issues/7237)
 
 ### Features
 
-* warn misspelled keys on prop validation object ([#7198](https://github.com/vuejs/vue/issues/7198)) ([d02bb37](https://github.com/vuejs/vue/commit/d02bb37efb3c4ee14b8cf9db22d1ab3340ba2c0f))
-
-
+- warn misspelled keys on prop validation object ([#7198](https://github.com/vuejs/vue/issues/7198)) ([d02bb37](https://github.com/vuejs/vue/commit/d02bb37efb3c4ee14b8cf9db22d1ab3340ba2c0f))
 
 ## [2.5.10](https://github.com/vuejs/vue/compare/v2.5.9...v2.5.10) (2017-12-12)
 
-
 ### Bug Fixes
 
-* **core:** warn duplicate keys in all cases ([#7200](https://github.com/vuejs/vue/issues/7200)) ([023f171](https://github.com/vuejs/vue/commit/023f171f58f7f1b36f0b3e69fc6d330366bfdf43)), closes [#7199](https://github.com/vuejs/vue/issues/7199)
-* data() should be called with vm as first argument in mixins ([bd4819e](https://github.com/vuejs/vue/commit/bd4819e6cf1c8d70d25aba2636e01f40faf59443)), closes [#7191](https://github.com/vuejs/vue/issues/7191)
-* more consistent component naming warnings across the API ([644274c](https://github.com/vuejs/vue/commit/644274cbd34e14e74e8931fa979b22dc2db04895)), closes [#7212](https://github.com/vuejs/vue/issues/7212)
-* revert shared static tree cache to avoid memory leak ([5875c7c](https://github.com/vuejs/vue/commit/5875c7c4906873c31b2feb66bb3ab6a19af6f5d7)), closes [#7184](https://github.com/vuejs/vue/issues/7184)
-* should not update in-focus input value with lazy modifier ([60da366](https://github.com/vuejs/vue/commit/60da366a2653a3984d79331d02ebb2ecf7e73a9a)), closes [#7153](https://github.com/vuejs/vue/issues/7153)
-* **ssr:** fix double escaping of ssrNode attribute values ([#7224](https://github.com/vuejs/vue/issues/7224)) ([73a89bf](https://github.com/vuejs/vue/commit/73a89bf9e53c0f7f00f193e1b1bb195a71ab761f)), closes [#7223](https://github.com/vuejs/vue/issues/7223)
-* **ssr:** properly handle errors in async component ([8936b8d](https://github.com/vuejs/vue/commit/8936b8d9c147441555fcfd4ac748d817ba5ff60e)), closes [#6778](https://github.com/vuejs/vue/issues/6778)
-* **v-for:** support array and nested destructuring in v-for ([f5ce6b5](https://github.com/vuejs/vue/commit/f5ce6b50cffef2e0eb8895c462b2433d8f8a701f))
-* **weex:** send createFinish signal after root component mounted ([#7154](https://github.com/vuejs/vue/issues/7154)) ([0da8bce](https://github.com/vuejs/vue/commit/0da8bced77654beb14c39ff3b4543b2ef37d1aff))
-
-
+- **core:** warn duplicate keys in all cases ([#7200](https://github.com/vuejs/vue/issues/7200)) ([023f171](https://github.com/vuejs/vue/commit/023f171f58f7f1b36f0b3e69fc6d330366bfdf43)), closes [#7199](https://github.com/vuejs/vue/issues/7199)
+- data() should be called with vm as first argument in mixins ([bd4819e](https://github.com/vuejs/vue/commit/bd4819e6cf1c8d70d25aba2636e01f40faf59443)), closes [#7191](https://github.com/vuejs/vue/issues/7191)
+- more consistent component naming warnings across the API ([644274c](https://github.com/vuejs/vue/commit/644274cbd34e14e74e8931fa979b22dc2db04895)), closes [#7212](https://github.com/vuejs/vue/issues/7212)
+- revert shared static tree cache to avoid memory leak ([5875c7c](https://github.com/vuejs/vue/commit/5875c7c4906873c31b2feb66bb3ab6a19af6f5d7)), closes [#7184](https://github.com/vuejs/vue/issues/7184)
+- should not update in-focus input value with lazy modifier ([60da366](https://github.com/vuejs/vue/commit/60da366a2653a3984d79331d02ebb2ecf7e73a9a)), closes [#7153](https://github.com/vuejs/vue/issues/7153)
+- **ssr:** fix double escaping of ssrNode attribute values ([#7224](https://github.com/vuejs/vue/issues/7224)) ([73a89bf](https://github.com/vuejs/vue/commit/73a89bf9e53c0f7f00f193e1b1bb195a71ab761f)), closes [#7223](https://github.com/vuejs/vue/issues/7223)
+- **ssr:** properly handle errors in async component ([8936b8d](https://github.com/vuejs/vue/commit/8936b8d9c147441555fcfd4ac748d817ba5ff60e)), closes [#6778](https://github.com/vuejs/vue/issues/6778)
+- **v-for:** support array and nested destructuring in v-for ([f5ce6b5](https://github.com/vuejs/vue/commit/f5ce6b50cffef2e0eb8895c462b2433d8f8a701f))
+- **weex:** send createFinish signal after root component mounted ([#7154](https://github.com/vuejs/vue/issues/7154)) ([0da8bce](https://github.com/vuejs/vue/commit/0da8bced77654beb14c39ff3b4543b2ef37d1aff))
 
 ## [2.5.9](https://github.com/vuejs/vue/compare/v2.5.8...v2.5.9) (2017-11-27)
 
-
 ### Bug Fixes
 
-* block unnecessary input event on textarea placeholder in IE ([0f7c443](https://github.com/vuejs/vue/commit/0f7c443dca800204bc2e00876365869ee79e2d7b)), closes [#7138](https://github.com/vuejs/vue/issues/7138)
-* ensure functionalContext is cloned during slot clones ([604e081](https://github.com/vuejs/vue/commit/604e081d0456ed136b24b5f759c608d153dfae93)), closes [#7106](https://github.com/vuejs/vue/issues/7106)
-* fix async component resolving in sibling mounted hook ([dd21eac](https://github.com/vuejs/vue/commit/dd21eacc33fee8f8e6151fe1dcb419644f8f98c2)), closes [#7107](https://github.com/vuejs/vue/issues/7107)
-* fix v-for iterator parsing destructuring + parens without index ([aa82625](https://github.com/vuejs/vue/commit/aa8262540ac0115d56b53863302b9f8e69f8a03d))
-* **keep-alive:** should not destroy active instance when pruning cache ([3932a45](https://github.com/vuejs/vue/commit/3932a451a1419a97ea0200c5cb8096afe9a3e7e7)), closes [#7105](https://github.com/vuejs/vue/issues/7105)
-* **types:** add missing ssr renderToString signature ([14e9908](https://github.com/vuejs/vue/commit/14e99086c02f4bcda55e639fb0baf2c664591448))
-* **types:** add Promise signature for bundleRenderer.renderToString ([#7098](https://github.com/vuejs/vue/issues/7098)) ([3554eb2](https://github.com/vuejs/vue/commit/3554eb27269e151a0ef3d8c4ad9b29ec6664c471))
-* **types:** bump ts version and fix typing bugs ([#7135](https://github.com/vuejs/vue/issues/7135)) ([a71e653](https://github.com/vuejs/vue/commit/a71e653108e4ba56a70107662f3ee30cead59c18))
-* **types:** improve and test bundleRenderer.renderToString Promise types ([fcc1229](https://github.com/vuejs/vue/commit/fcc122931b504655c8255645d57612bc74c0f594))
-* **types:** use object and string instead of Object and String ([#7126](https://github.com/vuejs/vue/issues/7126)) ([d2e1d49](https://github.com/vuejs/vue/commit/d2e1d49c41ac633ea9410e1062b8e3e01f9d6b6d))
-
-
+- block unnecessary input event on textarea placeholder in IE ([0f7c443](https://github.com/vuejs/vue/commit/0f7c443dca800204bc2e00876365869ee79e2d7b)), closes [#7138](https://github.com/vuejs/vue/issues/7138)
+- ensure functionalContext is cloned during slot clones ([604e081](https://github.com/vuejs/vue/commit/604e081d0456ed136b24b5f759c608d153dfae93)), closes [#7106](https://github.com/vuejs/vue/issues/7106)
+- fix async component resolving in sibling mounted hook ([dd21eac](https://github.com/vuejs/vue/commit/dd21eacc33fee8f8e6151fe1dcb419644f8f98c2)), closes [#7107](https://github.com/vuejs/vue/issues/7107)
+- fix v-for iterator parsing destructuring + parens without index ([aa82625](https://github.com/vuejs/vue/commit/aa8262540ac0115d56b53863302b9f8e69f8a03d))
+- **keep-alive:** should not destroy active instance when pruning cache ([3932a45](https://github.com/vuejs/vue/commit/3932a451a1419a97ea0200c5cb8096afe9a3e7e7)), closes [#7105](https://github.com/vuejs/vue/issues/7105)
+- **types:** add missing ssr renderToString signature ([14e9908](https://github.com/vuejs/vue/commit/14e99086c02f4bcda55e639fb0baf2c664591448))
+- **types:** add Promise signature for bundleRenderer.renderToString ([#7098](https://github.com/vuejs/vue/issues/7098)) ([3554eb2](https://github.com/vuejs/vue/commit/3554eb27269e151a0ef3d8c4ad9b29ec6664c471))
+- **types:** bump ts version and fix typing bugs ([#7135](https://github.com/vuejs/vue/issues/7135)) ([a71e653](https://github.com/vuejs/vue/commit/a71e653108e4ba56a70107662f3ee30cead59c18))
+- **types:** improve and test bundleRenderer.renderToString Promise types ([fcc1229](https://github.com/vuejs/vue/commit/fcc122931b504655c8255645d57612bc74c0f594))
+- **types:** use object and string instead of Object and String ([#7126](https://github.com/vuejs/vue/issues/7126)) ([d2e1d49](https://github.com/vuejs/vue/commit/d2e1d49c41ac633ea9410e1062b8e3e01f9d6b6d))
 
 ## [2.5.8](https://github.com/vuejs/vue/compare/v2.5.7...v2.5.8) (2017-11-21)
 
-
 ### Bug Fixes
 
-* fix v-for alias deconstruct regression ([ebcef58](https://github.com/vuejs/vue/commit/ebcef58645af1582ca3c8a19ec26967946970301)), closes [#7096](https://github.com/vuejs/vue/issues/7096)
-
-
+- fix v-for alias deconstruct regression ([ebcef58](https://github.com/vuejs/vue/commit/ebcef58645af1582ca3c8a19ec26967946970301)), closes [#7096](https://github.com/vuejs/vue/issues/7096)
 
 ## [2.5.7](https://github.com/vuejs/vue/compare/v2.5.6...v2.5.7) (2017-11-20)
 
-
 ### Bug Fixes
 
-* allow traversing reactive objects which are sealed ([#7080](https://github.com/vuejs/vue/issues/7080)) ([4c22d1d](https://github.com/vuejs/vue/commit/4c22d1d17ffd3a9340c3b17443c7989d04ab14c5))
-* fix <keep-alive> include/exclude logic for anonymous components ([a23b913](https://github.com/vuejs/vue/commit/a23b913796a7d18e76185607f250655e18a390c8))
-* improve error detector v-for identifier check ([d891cd1](https://github.com/vuejs/vue/commit/d891cd1761df22e1e0b1953c6ed7947fdb79d915)), closes [#6971](https://github.com/vuejs/vue/issues/6971)
-* **ssr:** fix bundle renderer require path on windows ([#7085](https://github.com/vuejs/vue/issues/7085)) ([063acb7](https://github.com/vuejs/vue/commit/063acb79ebc02344ab277196d4aea0577b113926))
-
+- allow traversing reactive objects which are sealed ([#7080](https://github.com/vuejs/vue/issues/7080)) ([4c22d1d](https://github.com/vuejs/vue/commit/4c22d1d17ffd3a9340c3b17443c7989d04ab14c5))
+- fix <keep-alive> include/exclude logic for anonymous components ([a23b913](https://github.com/vuejs/vue/commit/a23b913796a7d18e76185607f250655e18a390c8))
+- improve error detector v-for identifier check ([d891cd1](https://github.com/vuejs/vue/commit/d891cd1761df22e1e0b1953c6ed7947fdb79d915)), closes [#6971](https://github.com/vuejs/vue/issues/6971)
+- **ssr:** fix bundle renderer require path on windows ([#7085](https://github.com/vuejs/vue/issues/7085)) ([063acb7](https://github.com/vuejs/vue/commit/063acb79ebc02344ab277196d4aea0577b113926))
 
 ### Features
 
-* feat: add warning for ambiguous combined usage of slot-scope and v-for ([c264335](https://github.com/vuejs/vue/commit/c264335fbd1b1d838e3c1085b7d6dcd1c752aa43)), closes [#6817](https://github.com/vuejs/vue/issues/6817)
-
-
+- feat: add warning for ambiguous combined usage of slot-scope and v-for ([c264335](https://github.com/vuejs/vue/commit/c264335fbd1b1d838e3c1085b7d6dcd1c752aa43)), closes [#6817](https://github.com/vuejs/vue/issues/6817)
 
 ## [2.5.6](https://github.com/vuejs/vue/compare/v2.5.5...v2.5.6) (2017-11-18)
 
-
 ### Bug Fixes
 
-* fix v-model :value warning on custom component ([59dea37](https://github.com/vuejs/vue/commit/59dea374037ec2e6b1f5570a30774f2de0a44adc)), closes [#7084](https://github.com/vuejs/vue/issues/7084)
-
-
+- fix v-model :value warning on custom component ([59dea37](https://github.com/vuejs/vue/commit/59dea374037ec2e6b1f5570a30774f2de0a44adc)), closes [#7084](https://github.com/vuejs/vue/issues/7084)
 
 ## [2.5.5](https://github.com/vuejs/vue/compare/v2.5.4...v2.5.5) (2017-11-17)
 
-
 ### Bug Fixes
 
-* init _staticTrees to avoid runtime reference warning ([f5cd29e](https://github.com/vuejs/vue/commit/f5cd29e1d8197613c4dfb4013b240784c3b64e43)), closes [#7075](https://github.com/vuejs/vue/issues/7075)
-* keep-alive should not cache anonymous components ([4d8226f](https://github.com/vuejs/vue/commit/4d8226fb2c84fa2e13a2d8a86dea8a9a5c6ea95f)), closes [#6938](https://github.com/vuejs/vue/issues/6938)
-* should warn unknown components inside <keep-alive> ([6d6b373](https://github.com/vuejs/vue/commit/6d6b3739e132723915bc2209663db1b825307865))
-
+- init \_staticTrees to avoid runtime reference warning ([f5cd29e](https://github.com/vuejs/vue/commit/f5cd29e1d8197613c4dfb4013b240784c3b64e43)), closes [#7075](https://github.com/vuejs/vue/issues/7075)
+- keep-alive should not cache anonymous components ([4d8226f](https://github.com/vuejs/vue/commit/4d8226fb2c84fa2e13a2d8a86dea8a9a5c6ea95f)), closes [#6938](https://github.com/vuejs/vue/issues/6938)
+- should warn unknown components inside <keep-alive> ([6d6b373](https://github.com/vuejs/vue/commit/6d6b3739e132723915bc2209663db1b825307865))
 
 ### Features
 
-* warn if both v-model and v-bind:value used on same element ([#7056](https://github.com/vuejs/vue/issues/7056)) ([1e14603](https://github.com/vuejs/vue/commit/1e146037fa4280b502d0edf95936bc67e87fd339)), closes [#7048](https://github.com/vuejs/vue/issues/7048) [#7048](https://github.com/vuejs/vue/issues/7048) [#7048](https://github.com/vuejs/vue/issues/7048)
-
-
+- warn if both v-model and v-bind:value used on same element ([#7056](https://github.com/vuejs/vue/issues/7056)) ([1e14603](https://github.com/vuejs/vue/commit/1e146037fa4280b502d0edf95936bc67e87fd339)), closes [#7048](https://github.com/vuejs/vue/issues/7048) [#7048](https://github.com/vuejs/vue/issues/7048) [#7048](https://github.com/vuejs/vue/issues/7048)
 
 ## [2.5.4](https://github.com/vuejs/vue/compare/v2.5.3...v2.5.4) (2017-11-16)
 
-
 ### Bug Fixes
 
-* clone slot nodes for render fn usage as well ([13196b2](https://github.com/vuejs/vue/commit/13196b25b8a0a84b3936982177195d2e04f13f79)), closes [#7041](https://github.com/vuejs/vue/issues/7041)
-* normlaize [@click](https://github.com/click).right and [@click](https://github.com/click).middle ([daed1e7](https://github.com/vuejs/vue/commit/daed1e73557d57df244ad8d46c9afff7208c9a2d)), closes [#7020](https://github.com/vuejs/vue/issues/7020)
-* should warn unknown components during hydration ([df82aeb](https://github.com/vuejs/vue/commit/df82aeb0bf7454ac99d403000a1ac993e8d8d4de)), closes [#6998](https://github.com/vuejs/vue/issues/6998)
-* **ssr:** ensure hydrated class & style bindings are reactive ([5db86b4](https://github.com/vuejs/vue/commit/5db86b4e94857fdde3ae6b71e24da637bc116baa)), closes [#7063](https://github.com/vuejs/vue/issues/7063)
-* **transition:** fix out-in transition getting stuck with v-if ([#7023](https://github.com/vuejs/vue/issues/7023)) ([45d7ba8](https://github.com/vuejs/vue/commit/45d7ba842917a075d6cb2563c78210e3b9210a58)), closes [#6687](https://github.com/vuejs/vue/issues/6687)
-* **types:** expose VueConstructor ([#7002](https://github.com/vuejs/vue/issues/7002)) ([267ada0](https://github.com/vuejs/vue/commit/267ada04e8dd66f5c159dd6ba1b9f88fbbe78676))
-* **weex:** donot rethrow the captured error on weex platform ([#7024](https://github.com/vuejs/vue/issues/7024)) ([c2b1cfe](https://github.com/vuejs/vue/commit/c2b1cfe9ccd08835f2d99f6ce60f67b4de55187f))
-
+- clone slot nodes for render fn usage as well ([13196b2](https://github.com/vuejs/vue/commit/13196b25b8a0a84b3936982177195d2e04f13f79)), closes [#7041](https://github.com/vuejs/vue/issues/7041)
+- normlaize [@click](https://github.com/click).right and [@click](https://github.com/click).middle ([daed1e7](https://github.com/vuejs/vue/commit/daed1e73557d57df244ad8d46c9afff7208c9a2d)), closes [#7020](https://github.com/vuejs/vue/issues/7020)
+- should warn unknown components during hydration ([df82aeb](https://github.com/vuejs/vue/commit/df82aeb0bf7454ac99d403000a1ac993e8d8d4de)), closes [#6998](https://github.com/vuejs/vue/issues/6998)
+- **ssr:** ensure hydrated class & style bindings are reactive ([5db86b4](https://github.com/vuejs/vue/commit/5db86b4e94857fdde3ae6b71e24da637bc116baa)), closes [#7063](https://github.com/vuejs/vue/issues/7063)
+- **transition:** fix out-in transition getting stuck with v-if ([#7023](https://github.com/vuejs/vue/issues/7023)) ([45d7ba8](https://github.com/vuejs/vue/commit/45d7ba842917a075d6cb2563c78210e3b9210a58)), closes [#6687](https://github.com/vuejs/vue/issues/6687)
+- **types:** expose VueConstructor ([#7002](https://github.com/vuejs/vue/issues/7002)) ([267ada0](https://github.com/vuejs/vue/commit/267ada04e8dd66f5c159dd6ba1b9f88fbbe78676))
+- **weex:** donot rethrow the captured error on weex platform ([#7024](https://github.com/vuejs/vue/issues/7024)) ([c2b1cfe](https://github.com/vuejs/vue/commit/c2b1cfe9ccd08835f2d99f6ce60f67b4de55187f))
 
 ### Features
 
-* **weex:** support batch update styles and attributes ([#7046](https://github.com/vuejs/vue/issues/7046)) ([7cf188e](https://github.com/vuejs/vue/commit/7cf188e134fe7bfc9e8a16b763fb85b18eff1eac))
-
-
+- **weex:** support batch update styles and attributes ([#7046](https://github.com/vuejs/vue/issues/7046)) ([7cf188e](https://github.com/vuejs/vue/commit/7cf188e134fe7bfc9e8a16b763fb85b18eff1eac))
 
 ## [2.5.3](https://github.com/vuejs/vue/compare/v2.5.2...v2.5.3) (2017-11-03)
 
-
 ### Bug Fixes
 
-* $set should respect properties on prototype chain ([83ed926](https://github.com/vuejs/vue/commit/83ed92608d81349e1cac2e481ed079e51a490b2b)), closes [#6845](https://github.com/vuejs/vue/issues/6845)
-* also clone component slot children during deepClone ([1cf02ef](https://github.com/vuejs/vue/commit/1cf02efda206185cb72bbaafb00037fa6269e3f3)), closes [#6891](https://github.com/vuejs/vue/issues/6891) [#6915](https://github.com/vuejs/vue/issues/6915)
-* clean up target variables to avoid memory leaks ([#6932](https://github.com/vuejs/vue/issues/6932)) ([c355319](https://github.com/vuejs/vue/commit/c3553196b8b15a71f982bd5e04c61be52e87c828)), closes [#6931](https://github.com/vuejs/vue/issues/6931)
-* **core:** static trees should be cached on options ([#6826](https://github.com/vuejs/vue/issues/6826)) ([#6837](https://github.com/vuejs/vue/issues/6837)) ([b6c384d](https://github.com/vuejs/vue/commit/b6c384dd78b56bd247e6a34d5aea0d3903f5b7fd))
-* **events:** properly $off array of events ([#6949](https://github.com/vuejs/vue/issues/6949)) ([c24f3e4](https://github.com/vuejs/vue/commit/c24f3e4208cd045832002ee9916559f6fe0dc2b5))
-* handle encoded tabs and newlines in attributes for Chrome a[href] and IE/Edge ([cfd73c2](https://github.com/vuejs/vue/commit/cfd73c2386623341fdbb3ac636c4baf84ea89c2c)), closes [#6828](https://github.com/vuejs/vue/issues/6828) [#6916](https://github.com/vuejs/vue/issues/6916)
-* **keep-alive:** higher priority for exclude than include ([#6905](https://github.com/vuejs/vue/issues/6905)) ([604230f](https://github.com/vuejs/vue/commit/604230fe953f864be5dc70bd7d34f64ae43e4f7e))
-* **model:** correctly set select v-model initial value on patch ([#6910](https://github.com/vuejs/vue/issues/6910)) ([58a39df](https://github.com/vuejs/vue/commit/58a39dfa0e8c4a51959e9a84369dad8fbca0e6ac))
-* properly mark slot rendered flag in production mode ([4fe1a95](https://github.com/vuejs/vue/commit/4fe1a95d2953ecf765e27677fa70ebadb176d4c3)), closes [#6997](https://github.com/vuejs/vue/issues/6997)
-* **slots:** properly handle nested named slot passing ([5a9da95](https://github.com/vuejs/vue/commit/5a9da95b8a865416f082952a48416ffc091e4078)), closes [#6996](https://github.com/vuejs/vue/issues/6996)
-* special case for static muted attribute in firefox ([f2e00f7](https://github.com/vuejs/vue/commit/f2e00f756fb540fb09ce3414289c652ce172d85c)), closes [#6887](https://github.com/vuejs/vue/issues/6887)
-* **ssr:** properly render <select v-model> initial state ([e1657fd](https://github.com/vuejs/vue/commit/e1657fd7ce49bff3c3ecad3c56ae527347505c34)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
-* **ssr:** properly render textarea value ([79c0d7b](https://github.com/vuejs/vue/commit/79c0d7bcfbcd1ac492e7ceb77f5024d09efdc6b3)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
-* **ssr:** should not optimize root if conditions ([4ad9a56](https://github.com/vuejs/vue/commit/4ad9a56b229b156e633f3d575cd0e99ba5e474d9)), closes [#6907](https://github.com/vuejs/vue/issues/6907)
-* **types:** improve typing for better completion ([#6886](https://github.com/vuejs/vue/issues/6886)) ([98ea0a3](https://github.com/vuejs/vue/commit/98ea0a3b48e37719f278c10a8ee5fb94d7d5db4e))
-* **typing:** relax $options type for TS2.6+ ([#6819](https://github.com/vuejs/vue/issues/6819)) ([9caed00](https://github.com/vuejs/vue/commit/9caed00d20f37c750e39db4ec86d278b453f0e5d))
-* **v-model:** v-if / v-else not working with :type + v-model ([#6955](https://github.com/vuejs/vue/issues/6955)) ([0c703e3](https://github.com/vuejs/vue/commit/0c703e34d1a2083d9f162fcf0885deefb803182e)), closes [#6918](https://github.com/vuejs/vue/issues/6918)
-* **weex:** stop trim css units in richtext component ([#6927](https://github.com/vuejs/vue/issues/6927)) ([8a784d8](https://github.com/vuejs/vue/commit/8a784d8d2333f0a05569f6c11c5a0fb0ab3a164e))
-
-
+- $set should respect properties on prototype chain ([83ed926](https://github.com/vuejs/vue/commit/83ed92608d81349e1cac2e481ed079e51a490b2b)), closes [#6845](https://github.com/vuejs/vue/issues/6845)
+- also clone component slot children during deepClone ([1cf02ef](https://github.com/vuejs/vue/commit/1cf02efda206185cb72bbaafb00037fa6269e3f3)), closes [#6891](https://github.com/vuejs/vue/issues/6891) [#6915](https://github.com/vuejs/vue/issues/6915)
+- clean up target variables to avoid memory leaks ([#6932](https://github.com/vuejs/vue/issues/6932)) ([c355319](https://github.com/vuejs/vue/commit/c3553196b8b15a71f982bd5e04c61be52e87c828)), closes [#6931](https://github.com/vuejs/vue/issues/6931)
+- **core:** static trees should be cached on options ([#6826](https://github.com/vuejs/vue/issues/6826)) ([#6837](https://github.com/vuejs/vue/issues/6837)) ([b6c384d](https://github.com/vuejs/vue/commit/b6c384dd78b56bd247e6a34d5aea0d3903f5b7fd))
+- **events:** properly $off array of events ([#6949](https://github.com/vuejs/vue/issues/6949)) ([c24f3e4](https://github.com/vuejs/vue/commit/c24f3e4208cd045832002ee9916559f6fe0dc2b5))
+- handle encoded tabs and newlines in attributes for Chrome a[href] and IE/Edge ([cfd73c2](https://github.com/vuejs/vue/commit/cfd73c2386623341fdbb3ac636c4baf84ea89c2c)), closes [#6828](https://github.com/vuejs/vue/issues/6828) [#6916](https://github.com/vuejs/vue/issues/6916)
+- **keep-alive:** higher priority for exclude than include ([#6905](https://github.com/vuejs/vue/issues/6905)) ([604230f](https://github.com/vuejs/vue/commit/604230fe953f864be5dc70bd7d34f64ae43e4f7e))
+- **model:** correctly set select v-model initial value on patch ([#6910](https://github.com/vuejs/vue/issues/6910)) ([58a39df](https://github.com/vuejs/vue/commit/58a39dfa0e8c4a51959e9a84369dad8fbca0e6ac))
+- properly mark slot rendered flag in production mode ([4fe1a95](https://github.com/vuejs/vue/commit/4fe1a95d2953ecf765e27677fa70ebadb176d4c3)), closes [#6997](https://github.com/vuejs/vue/issues/6997)
+- **slots:** properly handle nested named slot passing ([5a9da95](https://github.com/vuejs/vue/commit/5a9da95b8a865416f082952a48416ffc091e4078)), closes [#6996](https://github.com/vuejs/vue/issues/6996)
+- special case for static muted attribute in firefox ([f2e00f7](https://github.com/vuejs/vue/commit/f2e00f756fb540fb09ce3414289c652ce172d85c)), closes [#6887](https://github.com/vuejs/vue/issues/6887)
+- **ssr:** properly render <select v-model> initial state ([e1657fd](https://github.com/vuejs/vue/commit/e1657fd7ce49bff3c3ecad3c56ae527347505c34)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
+- **ssr:** properly render textarea value ([79c0d7b](https://github.com/vuejs/vue/commit/79c0d7bcfbcd1ac492e7ceb77f5024d09efdc6b3)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
+- **ssr:** should not optimize root if conditions ([4ad9a56](https://github.com/vuejs/vue/commit/4ad9a56b229b156e633f3d575cd0e99ba5e474d9)), closes [#6907](https://github.com/vuejs/vue/issues/6907)
+- **types:** improve typing for better completion ([#6886](https://github.com/vuejs/vue/issues/6886)) ([98ea0a3](https://github.com/vuejs/vue/commit/98ea0a3b48e37719f278c10a8ee5fb94d7d5db4e))
+- **typing:** relax $options type for TS2.6+ ([#6819](https://github.com/vuejs/vue/issues/6819)) ([9caed00](https://github.com/vuejs/vue/commit/9caed00d20f37c750e39db4ec86d278b453f0e5d))
+- **v-model:** v-if / v-else not working with :type + v-model ([#6955](https://github.com/vuejs/vue/issues/6955)) ([0c703e3](https://github.com/vuejs/vue/commit/0c703e34d1a2083d9f162fcf0885deefb803182e)), closes [#6918](https://github.com/vuejs/vue/issues/6918)
+- **weex:** stop trim css units in richtext component ([#6927](https://github.com/vuejs/vue/issues/6927)) ([8a784d8](https://github.com/vuejs/vue/commit/8a784d8d2333f0a05569f6c11c5a0fb0ab3a164e))
 
 ## [2.5.2](https://github.com/vuejs/vue/compare/v2.5.1...v2.5.2) (2017-10-13)
 
-
 ### Bug Fixes
 
-* further adjust nextTick strategy ([4e0c485](https://github.com/vuejs/vue/commit/4e0c48511d49f331fde31fc87b6ca428330f32d1)), closes [#6813](https://github.com/vuejs/vue/issues/6813)
-
-
+- further adjust nextTick strategy ([4e0c485](https://github.com/vuejs/vue/commit/4e0c48511d49f331fde31fc87b6ca428330f32d1)), closes [#6813](https://github.com/vuejs/vue/issues/6813)
 
 ## [2.5.1](https://github.com/vuejs/vue/compare/v2.5.0...v2.5.1) (2017-10-13)
 
-
 ### Bug Fixes
 
-* backwards compat with checkbox code generated in < 2.5 ([5665eaf](https://github.com/vuejs/vue/commit/5665eaf985a56cfd183ce8ce93c4d813edbd2cf8)), closes [#6803](https://github.com/vuejs/vue/issues/6803)
-* fix empty array edge case in normalizeChildren ([1f84dd1](https://github.com/vuejs/vue/commit/1f84dd1c2488d12ef144d4b548b0e80647f9403c)), closes [#6790](https://github.com/vuejs/vue/issues/6790)
-* **ssr:** add semicolon before self-removal script ([#6794](https://github.com/vuejs/vue/issues/6794)) ([5a15a8d](https://github.com/vuejs/vue/commit/5a15a8d2089bb833b892123c31a2ca04a511c4c8))
-* **transition-group:** work around rollup tree shaking ([#6796](https://github.com/vuejs/vue/issues/6796)) ([60b1af9](https://github.com/vuejs/vue/commit/60b1af9e02b93d9223d2ed1f23e0a618537a4c96)), closes [#6792](https://github.com/vuejs/vue/issues/6792)
-* **v-model:** allow arbitrary naems for type binding ([#6802](https://github.com/vuejs/vue/issues/6802)) ([15031b8](https://github.com/vuejs/vue/commit/15031b85427df5409f0bc4c10589cc6259f8a5b2)), closes [#6800](https://github.com/vuejs/vue/issues/6800)
-* v-on="object" listeners should fire after high-priority ones ([08a7fb5](https://github.com/vuejs/vue/commit/08a7fb539f9d3ab5b08a3c6cec9a6628929be3be)), closes [#6805](https://github.com/vuejs/vue/issues/6805)
-
-
+- backwards compat with checkbox code generated in < 2.5 ([5665eaf](https://github.com/vuejs/vue/commit/5665eaf985a56cfd183ce8ce93c4d813edbd2cf8)), closes [#6803](https://github.com/vuejs/vue/issues/6803)
+- fix empty array edge case in normalizeChildren ([1f84dd1](https://github.com/vuejs/vue/commit/1f84dd1c2488d12ef144d4b548b0e80647f9403c)), closes [#6790](https://github.com/vuejs/vue/issues/6790)
+- **ssr:** add semicolon before self-removal script ([#6794](https://github.com/vuejs/vue/issues/6794)) ([5a15a8d](https://github.com/vuejs/vue/commit/5a15a8d2089bb833b892123c31a2ca04a511c4c8))
+- **transition-group:** work around rollup tree shaking ([#6796](https://github.com/vuejs/vue/issues/6796)) ([60b1af9](https://github.com/vuejs/vue/commit/60b1af9e02b93d9223d2ed1f23e0a618537a4c96)), closes [#6792](https://github.com/vuejs/vue/issues/6792)
+- **v-model:** allow arbitrary naems for type binding ([#6802](https://github.com/vuejs/vue/issues/6802)) ([15031b8](https://github.com/vuejs/vue/commit/15031b85427df5409f0bc4c10589cc6259f8a5b2)), closes [#6800](https://github.com/vuejs/vue/issues/6800)
+- v-on="object" listeners should fire after high-priority ones ([08a7fb5](https://github.com/vuejs/vue/commit/08a7fb539f9d3ab5b08a3c6cec9a6628929be3be)), closes [#6805](https://github.com/vuejs/vue/issues/6805)
 
 # [2.5.0](https://github.com/vuejs/vue/compare/v2.4.4...v2.5.0) (2017-10-13)
 
-
 ### Bug Fixes
 
-* add slot v-bind warning ([#6736](https://github.com/vuejs/vue/issues/6736)) ([514b90b](https://github.com/vuejs/vue/commit/514b90b64770cba9f905d2dff59dfa0e064e580c)), closes [#6677](https://github.com/vuejs/vue/issues/6677)
-* allow an object's Symbols to be observed ([#6704](https://github.com/vuejs/vue/issues/6704)) ([4fd2ce8](https://github.com/vuejs/vue/commit/4fd2ce813cd0a59bd544defe07f44a5731e45f84))
-* **compiler:** warn when inline-template component has no children (fix [#6703](https://github.com/vuejs/vue/issues/6703)) ([#6715](https://github.com/vuejs/vue/issues/6715)) ([baabd6d](https://github.com/vuejs/vue/commit/baabd6d14016c730fe40a4202ae9b8f75e80041c))
-* **core:** avoid observing VNodes ([4459b87](https://github.com/vuejs/vue/commit/4459b87de902cf3ba496a104304ca80d1c9824c1)), closes [#6610](https://github.com/vuejs/vue/issues/6610)
-* ensure nextTick are passed to errorHandler ([#6730](https://github.com/vuejs/vue/issues/6730)) ([ae347a5](https://github.com/vuejs/vue/commit/ae347a52259b24507a9c747c80d78a6beaa36de0))
-* fallback to Promise in non-DOM environments ([6d1f4cb](https://github.com/vuejs/vue/commit/6d1f4cb89a156bf5f84942b1031354aa93916cb7))
-* fix scoped CSS for nested nodes in functional components ([4216588](https://github.com/vuejs/vue/commit/421658884f7ca786747abf9b89e00925fdfdfba8))
-* handle errors in errorHandler ([2b5c83a](https://github.com/vuejs/vue/commit/2b5c83af6d8b15510424af4877d58c261ea02e16)), closes [#6714](https://github.com/vuejs/vue/issues/6714)
-* perperly handle v-if on <template> scoped slot ([68bdbf5](https://github.com/vuejs/vue/commit/68bdbf508b915872627676d6bf987bdac9e5fe97)), closes [#6725](https://github.com/vuejs/vue/issues/6725)
-* prevent memory leak due to circular reference in vnodes ([405d8e9](https://github.com/vuejs/vue/commit/405d8e9f4c3201db2ae0e397d9191d9b94edc219)), closes [#6759](https://github.com/vuejs/vue/issues/6759)
-* properly render value on <progress> in IE/Edge ([c64f9ae](https://github.com/vuejs/vue/commit/c64f9ae1649175ee8cac1c7ecf3283897c948202)), closes [#6666](https://github.com/vuejs/vue/issues/6666)
-* **ref:** preserve ref on components after removing root element ([#6718](https://github.com/vuejs/vue/issues/6718)) ([6ad44e1](https://github.com/vuejs/vue/commit/6ad44e13e990951ff152a0fd7042613c5a87f1c0)), closes [#6632](https://github.com/vuejs/vue/issues/6632) [#6641](https://github.com/vuejs/vue/issues/6641)
-* resolve async component default for native dynamic import ([2876ed8](https://github.com/vuejs/vue/commit/2876ed870c5368a1767fbeddf06e94b55ebd6234)), closes [#6751](https://github.com/vuejs/vue/issues/6751)
-* **ssr:** fix hydration mismatch with adjacent text node from slots ([b080a14](https://github.com/vuejs/vue/commit/b080a14138262f0f274d0888555a11bd7387d576)), closes [vuejs/vue-loader#974](https://github.com/vuejs/vue-loader/issues/974)
-* **ssr:** handle inline template compilation error ([dff85b2](https://github.com/vuejs/vue/commit/dff85b230abda63839ed6b80d56ccfc6068b9ae0)), closes [#6766](https://github.com/vuejs/vue/issues/6766)
-* use correct ns inside <foreignObject> as root node ([cf1ff5b](https://github.com/vuejs/vue/commit/cf1ff5b0dc3d15c1e16821cb5e4fc984c74f07c1)), closes [#6642](https://github.com/vuejs/vue/issues/6642)
-* use MessageChannel for nextTick ([6e41679](https://github.com/vuejs/vue/commit/6e41679a96582da3e0a60bdbf123c33ba0e86b31)), closes [#6566](https://github.com/vuejs/vue/issues/6566) [#6690](https://github.com/vuejs/vue/issues/6690)
-* warn slot-scope when used as a prop ([8295f71](https://github.com/vuejs/vue/commit/8295f716657ffe516f30e84f29ca94f4a0aefabf))
-* work around old Chrome bug ([0f2cb09](https://github.com/vuejs/vue/commit/0f2cb09444e8b2a5fa41aaf8c94e6f2f43e00c2f)), closes [#6601](https://github.com/vuejs/vue/issues/6601)
-
+- add slot v-bind warning ([#6736](https://github.com/vuejs/vue/issues/6736)) ([514b90b](https://github.com/vuejs/vue/commit/514b90b64770cba9f905d2dff59dfa0e064e580c)), closes [#6677](https://github.com/vuejs/vue/issues/6677)
+- allow an object's Symbols to be observed ([#6704](https://github.com/vuejs/vue/issues/6704)) ([4fd2ce8](https://github.com/vuejs/vue/commit/4fd2ce813cd0a59bd544defe07f44a5731e45f84))
+- **compiler:** warn when inline-template component has no children (fix [#6703](https://github.com/vuejs/vue/issues/6703)) ([#6715](https://github.com/vuejs/vue/issues/6715)) ([baabd6d](https://github.com/vuejs/vue/commit/baabd6d14016c730fe40a4202ae9b8f75e80041c))
+- **core:** avoid observing VNodes ([4459b87](https://github.com/vuejs/vue/commit/4459b87de902cf3ba496a104304ca80d1c9824c1)), closes [#6610](https://github.com/vuejs/vue/issues/6610)
+- ensure nextTick are passed to errorHandler ([#6730](https://github.com/vuejs/vue/issues/6730)) ([ae347a5](https://github.com/vuejs/vue/commit/ae347a52259b24507a9c747c80d78a6beaa36de0))
+- fallback to Promise in non-DOM environments ([6d1f4cb](https://github.com/vuejs/vue/commit/6d1f4cb89a156bf5f84942b1031354aa93916cb7))
+- fix scoped CSS for nested nodes in functional components ([4216588](https://github.com/vuejs/vue/commit/421658884f7ca786747abf9b89e00925fdfdfba8))
+- handle errors in errorHandler ([2b5c83a](https://github.com/vuejs/vue/commit/2b5c83af6d8b15510424af4877d58c261ea02e16)), closes [#6714](https://github.com/vuejs/vue/issues/6714)
+- perperly handle v-if on <template> scoped slot ([68bdbf5](https://github.com/vuejs/vue/commit/68bdbf508b915872627676d6bf987bdac9e5fe97)), closes [#6725](https://github.com/vuejs/vue/issues/6725)
+- prevent memory leak due to circular reference in vnodes ([405d8e9](https://github.com/vuejs/vue/commit/405d8e9f4c3201db2ae0e397d9191d9b94edc219)), closes [#6759](https://github.com/vuejs/vue/issues/6759)
+- properly render value on <progress> in IE/Edge ([c64f9ae](https://github.com/vuejs/vue/commit/c64f9ae1649175ee8cac1c7ecf3283897c948202)), closes [#6666](https://github.com/vuejs/vue/issues/6666)
+- **ref:** preserve ref on components after removing root element ([#6718](https://github.com/vuejs/vue/issues/6718)) ([6ad44e1](https://github.com/vuejs/vue/commit/6ad44e13e990951ff152a0fd7042613c5a87f1c0)), closes [#6632](https://github.com/vuejs/vue/issues/6632) [#6641](https://github.com/vuejs/vue/issues/6641)
+- resolve async component default for native dynamic import ([2876ed8](https://github.com/vuejs/vue/commit/2876ed870c5368a1767fbeddf06e94b55ebd6234)), closes [#6751](https://github.com/vuejs/vue/issues/6751)
+- **ssr:** fix hydration mismatch with adjacent text node from slots ([b080a14](https://github.com/vuejs/vue/commit/b080a14138262f0f274d0888555a11bd7387d576)), closes [vuejs/vue-loader#974](https://github.com/vuejs/vue-loader/issues/974)
+- **ssr:** handle inline template compilation error ([dff85b2](https://github.com/vuejs/vue/commit/dff85b230abda63839ed6b80d56ccfc6068b9ae0)), closes [#6766](https://github.com/vuejs/vue/issues/6766)
+- use correct ns inside <foreignObject> as root node ([cf1ff5b](https://github.com/vuejs/vue/commit/cf1ff5b0dc3d15c1e16821cb5e4fc984c74f07c1)), closes [#6642](https://github.com/vuejs/vue/issues/6642)
+- use MessageChannel for nextTick ([6e41679](https://github.com/vuejs/vue/commit/6e41679a96582da3e0a60bdbf123c33ba0e86b31)), closes [#6566](https://github.com/vuejs/vue/issues/6566) [#6690](https://github.com/vuejs/vue/issues/6690)
+- warn slot-scope when used as a prop ([8295f71](https://github.com/vuejs/vue/commit/8295f716657ffe516f30e84f29ca94f4a0aefabf))
+- work around old Chrome bug ([0f2cb09](https://github.com/vuejs/vue/commit/0f2cb09444e8b2a5fa41aaf8c94e6f2f43e00c2f)), closes [#6601](https://github.com/vuejs/vue/issues/6601)
 
 ### Features
 
-* add .exact event modifier ([#5977](https://github.com/vuejs/vue/issues/5977)) ([9734e87](https://github.com/vuejs/vue/commit/9734e878ec4efe59f40fc97d9ef86273ad58a430)), closes [#5976](https://github.com/vuejs/vue/issues/5976)
-* add catchError option ([b3cd9bc](https://github.com/vuejs/vue/commit/b3cd9bc3940eb1e01da7081450929557d9c1651e))
-* add in-browser build for vue-template-compiler ([a5e5b31](https://github.com/vuejs/vue/commit/a5e5b31455e0d64f834dd691b7488e0e105d32c3))
-* add max prop for <keep-alive> ([2cba6d4](https://github.com/vuejs/vue/commit/2cba6d4cb1db8273ee45cccb8e50ebd87191244e))
-* **core:** call data method with this value ([#6760](https://github.com/vuejs/vue/issues/6760)) ([3a5432a](https://github.com/vuejs/vue/commit/3a5432a9e3f470ebafcef905281b830537897037)), closes [#6739](https://github.com/vuejs/vue/issues/6739)
-* functional component support for compiled templates ([ea0d227](https://github.com/vuejs/vue/commit/ea0d227d2ddfa5fc5e1112acf9cd485b4eae62cb))
-* improve template expression error message ([e38d006](https://github.com/vuejs/vue/commit/e38d0067521eee85febedc5f3ed3c24b5454c3a9)), closes [#6771](https://github.com/vuejs/vue/issues/6771)
-* **inject:** support providing default values for injections ([#6322](https://github.com/vuejs/vue/issues/6322)) ([88423fc](https://github.com/vuejs/vue/commit/88423fc66a2a4917dcdb7631a4594f05446283b1))
-* make vue and basic server renderer compatible in pure js runtimes ([c5d0fa0](https://github.com/vuejs/vue/commit/c5d0fa0503631b53338e5255bc8640da4b2fd4cb))
-* rename catchError -> errorCaptured ([6dac3db](https://github.com/vuejs/vue/commit/6dac3dbe441302cebb945b675f78f8e7247e2a97))
-* rename inject alias from "name" to "from" ([6893499](https://github.com/vuejs/vue/commit/68934997444c0047c49e419761dfad7fbc043a5d))
-* scoped CSS support for functional components ([050bb33](https://github.com/vuejs/vue/commit/050bb33f9b02589357c037623ea8cbf8ff13555b))
-* **ssr:** add shouldPrefetch option ([7bc899c](https://github.com/vuejs/vue/commit/7bc899ce0ec10be3fbd4bd7e78b66dd357249c81)), closes [#5964](https://github.com/vuejs/vue/issues/5964)
-* **ssr:** auto-remove initial state script if prod ([#6763](https://github.com/vuejs/vue/issues/6763)) ([2d32b5d](https://github.com/vuejs/vue/commit/2d32b5d1b663fa331ec256b73e937af15eb6e3d5)), closes [#6761](https://github.com/vuejs/vue/issues/6761)
-* **ssr:** renderToString return Promise ([f881dd1](https://github.com/vuejs/vue/commit/f881dd175a6764f6f80077df20f950dba63ca447)), closes [#6160](https://github.com/vuejs/vue/issues/6160)
-* support denoting normal elements as scoped slot ([dae173d](https://github.com/vuejs/vue/commit/dae173d96d15f47de6ce6961354d5c05e4273005))
-* support RegExp in ignoredElements ([#6769](https://github.com/vuejs/vue/issues/6769)) ([795b908](https://github.com/vuejs/vue/commit/795b908095b29e76435479879c1ade7ef759ce7b))
-* **types:** further improve Vue type declarations for canonical usage ([#6391](https://github.com/vuejs/vue/issues/6391)) ([db138e2](https://github.com/vuejs/vue/commit/db138e2254d71f6b96e033acf66ba43ad269841a))
-* **v-model:** craete non-existent properties as reactive ([e1da0d5](https://github.com/vuejs/vue/commit/e1da0d585c797860533d6cb10ea3d09c7fb711fc)), closes [#5932](https://github.com/vuejs/vue/issues/5932)
-* **v-model:** support dynamic input type binding ([f3fe012](https://github.com/vuejs/vue/commit/f3fe012d5499f607656b152ce5fcb506c641f9f4))
-* v-on automatic key inference ([4987eeb](https://github.com/vuejs/vue/commit/4987eeb3a734a16a4978d1061f73039002d351e6))
-
+- add .exact event modifier ([#5977](https://github.com/vuejs/vue/issues/5977)) ([9734e87](https://github.com/vuejs/vue/commit/9734e878ec4efe59f40fc97d9ef86273ad58a430)), closes [#5976](https://github.com/vuejs/vue/issues/5976)
+- add catchError option ([b3cd9bc](https://github.com/vuejs/vue/commit/b3cd9bc3940eb1e01da7081450929557d9c1651e))
+- add in-browser build for vue-template-compiler ([a5e5b31](https://github.com/vuejs/vue/commit/a5e5b31455e0d64f834dd691b7488e0e105d32c3))
+- add max prop for <keep-alive> ([2cba6d4](https://github.com/vuejs/vue/commit/2cba6d4cb1db8273ee45cccb8e50ebd87191244e))
+- **core:** call data method with this value ([#6760](https://github.com/vuejs/vue/issues/6760)) ([3a5432a](https://github.com/vuejs/vue/commit/3a5432a9e3f470ebafcef905281b830537897037)), closes [#6739](https://github.com/vuejs/vue/issues/6739)
+- functional component support for compiled templates ([ea0d227](https://github.com/vuejs/vue/commit/ea0d227d2ddfa5fc5e1112acf9cd485b4eae62cb))
+- improve template expression error message ([e38d006](https://github.com/vuejs/vue/commit/e38d0067521eee85febedc5f3ed3c24b5454c3a9)), closes [#6771](https://github.com/vuejs/vue/issues/6771)
+- **inject:** support providing default values for injections ([#6322](https://github.com/vuejs/vue/issues/6322)) ([88423fc](https://github.com/vuejs/vue/commit/88423fc66a2a4917dcdb7631a4594f05446283b1))
+- make vue and basic server renderer compatible in pure js runtimes ([c5d0fa0](https://github.com/vuejs/vue/commit/c5d0fa0503631b53338e5255bc8640da4b2fd4cb))
+- rename catchError -> errorCaptured ([6dac3db](https://github.com/vuejs/vue/commit/6dac3dbe441302cebb945b675f78f8e7247e2a97))
+- rename inject alias from "name" to "from" ([6893499](https://github.com/vuejs/vue/commit/68934997444c0047c49e419761dfad7fbc043a5d))
+- scoped CSS support for functional components ([050bb33](https://github.com/vuejs/vue/commit/050bb33f9b02589357c037623ea8cbf8ff13555b))
+- **ssr:** add shouldPrefetch option ([7bc899c](https://github.com/vuejs/vue/commit/7bc899ce0ec10be3fbd4bd7e78b66dd357249c81)), closes [#5964](https://github.com/vuejs/vue/issues/5964)
+- **ssr:** auto-remove initial state script if prod ([#6763](https://github.com/vuejs/vue/issues/6763)) ([2d32b5d](https://github.com/vuejs/vue/commit/2d32b5d1b663fa331ec256b73e937af15eb6e3d5)), closes [#6761](https://github.com/vuejs/vue/issues/6761)
+- **ssr:** renderToString return Promise ([f881dd1](https://github.com/vuejs/vue/commit/f881dd175a6764f6f80077df20f950dba63ca447)), closes [#6160](https://github.com/vuejs/vue/issues/6160)
+- support denoting normal elements as scoped slot ([dae173d](https://github.com/vuejs/vue/commit/dae173d96d15f47de6ce6961354d5c05e4273005))
+- support RegExp in ignoredElements ([#6769](https://github.com/vuejs/vue/issues/6769)) ([795b908](https://github.com/vuejs/vue/commit/795b908095b29e76435479879c1ade7ef759ce7b))
+- **types:** further improve Vue type declarations for canonical usage ([#6391](https://github.com/vuejs/vue/issues/6391)) ([db138e2](https://github.com/vuejs/vue/commit/db138e2254d71f6b96e033acf66ba43ad269841a))
+- **v-model:** craete non-existent properties as reactive ([e1da0d5](https://github.com/vuejs/vue/commit/e1da0d585c797860533d6cb10ea3d09c7fb711fc)), closes [#5932](https://github.com/vuejs/vue/issues/5932)
+- **v-model:** support dynamic input type binding ([f3fe012](https://github.com/vuejs/vue/commit/f3fe012d5499f607656b152ce5fcb506c641f9f4))
+- v-on automatic key inference ([4987eeb](https://github.com/vuejs/vue/commit/4987eeb3a734a16a4978d1061f73039002d351e6))
 
 ### Reverts
 
-* fix(v-model): fix input listener with modifier blocking v-model update ([62405aa](https://github.com/vuejs/vue/commit/62405aa9035d5f547c0440263f16f21c1325f100))
-
-
+- fix(v-model): fix input listener with modifier blocking v-model update ([62405aa](https://github.com/vuejs/vue/commit/62405aa9035d5f547c0440263f16f21c1325f100))
 
 ## [2.4.4](https://github.com/vuejs/vue/compare/v2.4.3...v2.4.4) (2017-09-14)
 
-
 ### Bug Fixes
 
-* **ssr:** fix bundleRenderer Promise rejection regression ([0c9534f](https://github.com/vuejs/vue/commit/0c9534ff0069b5289ea9598bcb4f5e5ac346c979))
-* **ssr:** fix style injection regression ([a2f73f2](https://github.com/vuejs/vue/commit/a2f73f2c2e28771e6597334bd86f82851ce0955e)), closes [#6603](https://github.com/vuejs/vue/issues/6603) [#6353](https://github.com/vuejs/vue/issues/6353)
-
-
+- **ssr:** fix bundleRenderer Promise rejection regression ([0c9534f](https://github.com/vuejs/vue/commit/0c9534ff0069b5289ea9598bcb4f5e5ac346c979))
+- **ssr:** fix style injection regression ([a2f73f2](https://github.com/vuejs/vue/commit/a2f73f2c2e28771e6597334bd86f82851ce0955e)), closes [#6603](https://github.com/vuejs/vue/issues/6603) [#6353](https://github.com/vuejs/vue/issues/6353)
 
 ## [2.4.3](https://github.com/vuejs/vue/compare/v2.4.2...v2.4.3) (2017-09-13)
 
-
 ### Bug Fixes
 
-* $off should ignore undefined handler argument ([fa6a729](https://github.com/vuejs/vue/commit/fa6a7290e3b8cb62fb7f999389f476617b56503e)), closes [#6591](https://github.com/vuejs/vue/issues/6591)
-* computed properties should not be cached during SSR ([06741f3](https://github.com/vuejs/vue/commit/06741f326625e2db78d092e586923b97ba006906)), closes [vuejs/vuex#877](https://github.com/vuejs/vuex/issues/877)
-* deep clone slot vnodes on re-render ([0529040](https://github.com/vuejs/vue/commit/0529040c17b8632032a43d142aac88386f6b4a1f)), closes [#6372](https://github.com/vuejs/vue/issues/6372)
-* **directive:** should invoke unbind & inserted on inner component root element change ([538ad20](https://github.com/vuejs/vue/commit/538ad20d8a37fe7ee2463ff20ac9557af70e0d33)), closes [#6513](https://github.com/vuejs/vue/issues/6513)
-* do not use MutationObserver in IE11 ([844a540](https://github.com/vuejs/vue/commit/844a540c647dfa93dc714540953524830dd3475a)), closes [#6466](https://github.com/vuejs/vue/issues/6466)
-* ensure $attrs and $listeners are always objects ([#6441](https://github.com/vuejs/vue/issues/6441)) ([59dbd4a](https://github.com/vuejs/vue/commit/59dbd4a414394a3ce581f9fbd9554da9af9e4b1d)), closes [#6263](https://github.com/vuejs/vue/issues/6263)
-* ensure outer bindings on nested HOC are properly re-applied on inner root element change ([a744497](https://github.com/vuejs/vue/commit/a7444975343f7828004d90bfb0deeb98db0f46e7))
-* handle special case for allowfullscreen on <embed> ([d77b953](https://github.com/vuejs/vue/commit/d77b95317cedae299605fb692e2c7c67796b17cb)), closes [#6202](https://github.com/vuejs/vue/issues/6202)
-* inherit SVG ns on component root node ([#6511](https://github.com/vuejs/vue/issues/6511)) ([89f0d29](https://github.com/vuejs/vue/commit/89f0d29f2d541aa5a1ac9690258cd7c7ee576ef6)), closes [#6506](https://github.com/vuejs/vue/issues/6506)
-* **inject:** exclude not enumerable keys of inject object ([#6346](https://github.com/vuejs/vue/issues/6346)) ([3ee62fd](https://github.com/vuejs/vue/commit/3ee62fd59e20030dd63c08c2390e803d034928fe)), closes [#6574](https://github.com/vuejs/vue/issues/6574)
-* preserve slot attribute if not resolved by Vue ([684cd7d](https://github.com/vuejs/vue/commit/684cd7d21aa7cb9a40fb4a8542c4e08fb3801a86)), closes [#6553](https://github.com/vuejs/vue/issues/6553)
-* **provide:** provide should default to parentVal during merging ([#6473](https://github.com/vuejs/vue/issues/6473)) ([3c21675](https://github.com/vuejs/vue/commit/3c216755f6eb656c6d864265a8dc7b51b3ae971b)), closes [#6436](https://github.com/vuejs/vue/issues/6436)
-* set value as domProp for <progress> ([7116af4](https://github.com/vuejs/vue/commit/7116af4e07520040ed7328c39d0a456808bfe1e1)), closes [#6561](https://github.com/vuejs/vue/issues/6561)
-* **ssr:** address possible xss vector ([5091e2c](https://github.com/vuejs/vue/commit/5091e2c9847601e329ac36d17eae90bb5cb77a91))
-* **ssr:** better handle v-html hydration ([0f00f8f](https://github.com/vuejs/vue/commit/0f00f8fc2b83b964bb929b729a7c9e3675b52106)), closes [#6519](https://github.com/vuejs/vue/issues/6519)
-* **ssr:** expose context.styles when no lifecycle styles are injected ([1f52a2a](https://github.com/vuejs/vue/commit/1f52a2a9f433452c15715131ed74433a43d5cfb7)), closes [#6353](https://github.com/vuejs/vue/issues/6353)
-* **ssr:** fix cachedEscape memory issue ([02f8b80](https://github.com/vuejs/vue/commit/02f8b806768d70c589e646c384e592e93387b994)), closes [#6332](https://github.com/vuejs/vue/issues/6332)
-* **ssr:** handle v-text/v-html with non-string value ([09106f0](https://github.com/vuejs/vue/commit/09106f066a1ba71431e4f9f26246aaf619153e2e)), closes [#6572](https://github.com/vuejs/vue/issues/6572)
-* **ssr:** should also escape static text content ([172dbf9](https://github.com/vuejs/vue/commit/172dbf9faf4cb71dff72c77fdfe80fa1932d1ba3)), closes [#6345](https://github.com/vuejs/vue/issues/6345)
-* support prop type checking for primitive wrapper objects ([#6450](https://github.com/vuejs/vue/issues/6450)) ([679cd1f](https://github.com/vuejs/vue/commit/679cd1fef448989bf645313c391e4134ecd9f593)), closes [#6447](https://github.com/vuejs/vue/issues/6447)
-* **transition:** consider async placeholder as valid child to return ([#6369](https://github.com/vuejs/vue/issues/6369)) ([a43d667](https://github.com/vuejs/vue/commit/a43d66743be2bd62b2398090663e41eeaf0dc75f)), closes [#6256](https://github.com/vuejs/vue/issues/6256)
-* **types:** add `inject` option in functional component options type ([#6530](https://github.com/vuejs/vue/issues/6530)) ([1baa0a7](https://github.com/vuejs/vue/commit/1baa0a7884cfa147df7623a34ee277f7d39c7a21))
-* **types:** allow variadic plugin use ([#6363](https://github.com/vuejs/vue/issues/6363)) ([38d5218](https://github.com/vuejs/vue/commit/38d52182bf8915628314e2aea7d2cc41ec39a0d6)), closes [#6357](https://github.com/vuejs/vue/issues/6357)
-* **v-model:** Allow using array value with array v-model in checkboxes ([#6220](https://github.com/vuejs/vue/issues/6220)) ([d6e6f1d](https://github.com/vuejs/vue/commit/d6e6f1deb180a4f47e94496724623b9e6d8e08b3)), closes [#6219](https://github.com/vuejs/vue/issues/6219)
-* **v-model:** avoid unnecessary change event on select options change ([d4d553c](https://github.com/vuejs/vue/commit/d4d553ced75d8c73e75b85cec398be4b09f6f669)), closes [#6193](https://github.com/vuejs/vue/issues/6193) [#6194](https://github.com/vuejs/vue/issues/6194)
-* **v-model:** fix input listener with modifier blocking v-model update ([6f312d6](https://github.com/vuejs/vue/commit/6f312d636c3d6049dc9e60007f88ea871b8e8173)), closes [#6552](https://github.com/vuejs/vue/issues/6552)
-* **vdom:** avoid diff de-opt when both head/tail are different ([230c6ae](https://github.com/vuejs/vue/commit/230c6ae7822347b9b2a659503291e45fcc58fe41)), closes [#6502](https://github.com/vuejs/vue/issues/6502)
-* **vdom:** Don't replace input for text-like type change ([#6344](https://github.com/vuejs/vue/issues/6344)) ([f76d16e](https://github.com/vuejs/vue/commit/f76d16ed9507d4c2a90243ea3d77ccf00df29346)), closes [#6313](https://github.com/vuejs/vue/issues/6313)
-
+- $off should ignore undefined handler argument ([fa6a729](https://github.com/vuejs/vue/commit/fa6a7290e3b8cb62fb7f999389f476617b56503e)), closes [#6591](https://github.com/vuejs/vue/issues/6591)
+- computed properties should not be cached during SSR ([06741f3](https://github.com/vuejs/vue/commit/06741f326625e2db78d092e586923b97ba006906)), closes [vuejs/vuex#877](https://github.com/vuejs/vuex/issues/877)
+- deep clone slot vnodes on re-render ([0529040](https://github.com/vuejs/vue/commit/0529040c17b8632032a43d142aac88386f6b4a1f)), closes [#6372](https://github.com/vuejs/vue/issues/6372)
+- **directive:** should invoke unbind & inserted on inner component root element change ([538ad20](https://github.com/vuejs/vue/commit/538ad20d8a37fe7ee2463ff20ac9557af70e0d33)), closes [#6513](https://github.com/vuejs/vue/issues/6513)
+- do not use MutationObserver in IE11 ([844a540](https://github.com/vuejs/vue/commit/844a540c647dfa93dc714540953524830dd3475a)), closes [#6466](https://github.com/vuejs/vue/issues/6466)
+- ensure $attrs and $listeners are always objects ([#6441](https://github.com/vuejs/vue/issues/6441)) ([59dbd4a](https://github.com/vuejs/vue/commit/59dbd4a414394a3ce581f9fbd9554da9af9e4b1d)), closes [#6263](https://github.com/vuejs/vue/issues/6263)
+- ensure outer bindings on nested HOC are properly re-applied on inner root element change ([a744497](https://github.com/vuejs/vue/commit/a7444975343f7828004d90bfb0deeb98db0f46e7))
+- handle special case for allowfullscreen on <embed> ([d77b953](https://github.com/vuejs/vue/commit/d77b95317cedae299605fb692e2c7c67796b17cb)), closes [#6202](https://github.com/vuejs/vue/issues/6202)
+- inherit SVG ns on component root node ([#6511](https://github.com/vuejs/vue/issues/6511)) ([89f0d29](https://github.com/vuejs/vue/commit/89f0d29f2d541aa5a1ac9690258cd7c7ee576ef6)), closes [#6506](https://github.com/vuejs/vue/issues/6506)
+- **inject:** exclude not enumerable keys of inject object ([#6346](https://github.com/vuejs/vue/issues/6346)) ([3ee62fd](https://github.com/vuejs/vue/commit/3ee62fd59e20030dd63c08c2390e803d034928fe)), closes [#6574](https://github.com/vuejs/vue/issues/6574)
+- preserve slot attribute if not resolved by Vue ([684cd7d](https://github.com/vuejs/vue/commit/684cd7d21aa7cb9a40fb4a8542c4e08fb3801a86)), closes [#6553](https://github.com/vuejs/vue/issues/6553)
+- **provide:** provide should default to parentVal during merging ([#6473](https://github.com/vuejs/vue/issues/6473)) ([3c21675](https://github.com/vuejs/vue/commit/3c216755f6eb656c6d864265a8dc7b51b3ae971b)), closes [#6436](https://github.com/vuejs/vue/issues/6436)
+- set value as domProp for <progress> ([7116af4](https://github.com/vuejs/vue/commit/7116af4e07520040ed7328c39d0a456808bfe1e1)), closes [#6561](https://github.com/vuejs/vue/issues/6561)
+- **ssr:** address possible xss vector ([5091e2c](https://github.com/vuejs/vue/commit/5091e2c9847601e329ac36d17eae90bb5cb77a91))
+- **ssr:** better handle v-html hydration ([0f00f8f](https://github.com/vuejs/vue/commit/0f00f8fc2b83b964bb929b729a7c9e3675b52106)), closes [#6519](https://github.com/vuejs/vue/issues/6519)
+- **ssr:** expose context.styles when no lifecycle styles are injected ([1f52a2a](https://github.com/vuejs/vue/commit/1f52a2a9f433452c15715131ed74433a43d5cfb7)), closes [#6353](https://github.com/vuejs/vue/issues/6353)
+- **ssr:** fix cachedEscape memory issue ([02f8b80](https://github.com/vuejs/vue/commit/02f8b806768d70c589e646c384e592e93387b994)), closes [#6332](https://github.com/vuejs/vue/issues/6332)
+- **ssr:** handle v-text/v-html with non-string value ([09106f0](https://github.com/vuejs/vue/commit/09106f066a1ba71431e4f9f26246aaf619153e2e)), closes [#6572](https://github.com/vuejs/vue/issues/6572)
+- **ssr:** should also escape static text content ([172dbf9](https://github.com/vuejs/vue/commit/172dbf9faf4cb71dff72c77fdfe80fa1932d1ba3)), closes [#6345](https://github.com/vuejs/vue/issues/6345)
+- support prop type checking for primitive wrapper objects ([#6450](https://github.com/vuejs/vue/issues/6450)) ([679cd1f](https://github.com/vuejs/vue/commit/679cd1fef448989bf645313c391e4134ecd9f593)), closes [#6447](https://github.com/vuejs/vue/issues/6447)
+- **transition:** consider async placeholder as valid child to return ([#6369](https://github.com/vuejs/vue/issues/6369)) ([a43d667](https://github.com/vuejs/vue/commit/a43d66743be2bd62b2398090663e41eeaf0dc75f)), closes [#6256](https://github.com/vuejs/vue/issues/6256)
+- **types:** add `inject` option in functional component options type ([#6530](https://github.com/vuejs/vue/issues/6530)) ([1baa0a7](https://github.com/vuejs/vue/commit/1baa0a7884cfa147df7623a34ee277f7d39c7a21))
+- **types:** allow variadic plugin use ([#6363](https://github.com/vuejs/vue/issues/6363)) ([38d5218](https://github.com/vuejs/vue/commit/38d52182bf8915628314e2aea7d2cc41ec39a0d6)), closes [#6357](https://github.com/vuejs/vue/issues/6357)
+- **v-model:** Allow using array value with array v-model in checkboxes ([#6220](https://github.com/vuejs/vue/issues/6220)) ([d6e6f1d](https://github.com/vuejs/vue/commit/d6e6f1deb180a4f47e94496724623b9e6d8e08b3)), closes [#6219](https://github.com/vuejs/vue/issues/6219)
+- **v-model:** avoid unnecessary change event on select options change ([d4d553c](https://github.com/vuejs/vue/commit/d4d553ced75d8c73e75b85cec398be4b09f6f669)), closes [#6193](https://github.com/vuejs/vue/issues/6193) [#6194](https://github.com/vuejs/vue/issues/6194)
+- **v-model:** fix input listener with modifier blocking v-model update ([6f312d6](https://github.com/vuejs/vue/commit/6f312d636c3d6049dc9e60007f88ea871b8e8173)), closes [#6552](https://github.com/vuejs/vue/issues/6552)
+- **vdom:** avoid diff de-opt when both head/tail are different ([230c6ae](https://github.com/vuejs/vue/commit/230c6ae7822347b9b2a659503291e45fcc58fe41)), closes [#6502](https://github.com/vuejs/vue/issues/6502)
+- **vdom:** Don't replace input for text-like type change ([#6344](https://github.com/vuejs/vue/issues/6344)) ([f76d16e](https://github.com/vuejs/vue/commit/f76d16ed9507d4c2a90243ea3d77ccf00df29346)), closes [#6313](https://github.com/vuejs/vue/issues/6313)
 
 ### Features
 
-* **weex richtext:** support events and add more test cases ([d627161](https://github.com/vuejs/vue/commit/d627161a91b77ca15e0e30c0313abb33d6c17cbc))
-* **weex richtext:** support to parse styles and classList ([b609642](https://github.com/vuejs/vue/commit/b60964256c876de2516977c776201ef56ab13fb7))
-* **weex richtext:** treat richtext as runtime components ([3e4d926](https://github.com/vuejs/vue/commit/3e4d926336dfdbb5cc4f9d0daed44eb84b53b0de))
-* **weex:** add basic support of richtext ([f1c96e7](https://github.com/vuejs/vue/commit/f1c96e72b2369f3f8cc0078adb732a25cc7bfbfe))
-* **weex:** remove __weex_require_module__ api ([a8146c0](https://github.com/vuejs/vue/commit/a8146c0c1074cfd8214a62309c372b25035fd838))
-* **weex:** return instance in createInstance ([0dc27dc](https://github.com/vuejs/vue/commit/0dc27dcdec72c1c2e12fb49fb95dceca45e84115))
-* **weex:** support nested components in richtext ([0ea2bb4](https://github.com/vuejs/vue/commit/0ea2bb4fb4d9c4d846ae5852c871c472c17f4e34))
-* **weex:** wrap IFFE for appCode ([f975fac](https://github.com/vuejs/vue/commit/f975fac2a8657590dcc23ea8ccae791d125bc935))
-
+- **weex richtext:** support events and add more test cases ([d627161](https://github.com/vuejs/vue/commit/d627161a91b77ca15e0e30c0313abb33d6c17cbc))
+- **weex richtext:** support to parse styles and classList ([b609642](https://github.com/vuejs/vue/commit/b60964256c876de2516977c776201ef56ab13fb7))
+- **weex richtext:** treat richtext as runtime components ([3e4d926](https://github.com/vuejs/vue/commit/3e4d926336dfdbb5cc4f9d0daed44eb84b53b0de))
+- **weex:** add basic support of richtext ([f1c96e7](https://github.com/vuejs/vue/commit/f1c96e72b2369f3f8cc0078adb732a25cc7bfbfe))
+- **weex:** remove **weex_require_module** api ([a8146c0](https://github.com/vuejs/vue/commit/a8146c0c1074cfd8214a62309c372b25035fd838))
+- **weex:** return instance in createInstance ([0dc27dc](https://github.com/vuejs/vue/commit/0dc27dcdec72c1c2e12fb49fb95dceca45e84115))
+- **weex:** support nested components in richtext ([0ea2bb4](https://github.com/vuejs/vue/commit/0ea2bb4fb4d9c4d846ae5852c871c472c17f4e34))
+- **weex:** wrap IFFE for appCode ([f975fac](https://github.com/vuejs/vue/commit/f975fac2a8657590dcc23ea8ccae791d125bc935))
 
 ### Performance Improvements
 
-* **core:** prevent iteration of arrays that should not be observable ([#6467](https://github.com/vuejs/vue/issues/6467)) ([aa820cb](https://github.com/vuejs/vue/commit/aa820cba37b69772868c9cdb69235c424e23f529)), closes [#6284](https://github.com/vuejs/vue/issues/6284)
-* deep clone slot vnodes on re-render ([#6478](https://github.com/vuejs/vue/issues/6478)) ([5346361](https://github.com/vuejs/vue/commit/53463619e5d19d35dfad1a4245a8dc583681feb3))
-* optimize the performance of hyphenate method. ([#6274](https://github.com/vuejs/vue/issues/6274)) ([14ee9e7](https://github.com/vuejs/vue/commit/14ee9e74bf68024fcb53c305b1f15c6aab6e89d3))
-* **v-model:** tweak setSelected ([41d774d](https://github.com/vuejs/vue/commit/41d774d112946f986bf0b0e3f30fd962c01ceba2))
-
-
+- **core:** prevent iteration of arrays that should not be observable ([#6467](https://github.com/vuejs/vue/issues/6467)) ([aa820cb](https://github.com/vuejs/vue/commit/aa820cba37b69772868c9cdb69235c424e23f529)), closes [#6284](https://github.com/vuejs/vue/issues/6284)
+- deep clone slot vnodes on re-render ([#6478](https://github.com/vuejs/vue/issues/6478)) ([5346361](https://github.com/vuejs/vue/commit/53463619e5d19d35dfad1a4245a8dc583681feb3))
+- optimize the performance of hyphenate method. ([#6274](https://github.com/vuejs/vue/issues/6274)) ([14ee9e7](https://github.com/vuejs/vue/commit/14ee9e74bf68024fcb53c305b1f15c6aab6e89d3))
+- **v-model:** tweak setSelected ([41d774d](https://github.com/vuejs/vue/commit/41d774d112946f986bf0b0e3f30fd962c01ceba2))
 
 ## [2.4.2](https://github.com/vuejs/vue/compare/v2.4.1...v2.4.2) (2017-07-21)
 
-
 ### Bug Fixes
 
-* checkbox v-model="array" ignore false-value ([#6180](https://github.com/vuejs/vue/issues/6180)) ([3d14e85](https://github.com/vuejs/vue/commit/3d14e855e422b656859d1b419af43b94320fcfce)), closes [#6178](https://github.com/vuejs/vue/issues/6178)
-* **compile:** properly generate comments with special character ([#6156](https://github.com/vuejs/vue/issues/6156)) ([d03fa26](https://github.com/vuejs/vue/commit/d03fa26687605a43d9a0c3f395d1d32375f7eaee)), closes [#6150](https://github.com/vuejs/vue/issues/6150)
-* ensure looseEqual is not dependant on key enumeration order ([a8ac129](https://github.com/vuejs/vue/commit/a8ac129a5876a7eeae0137bf2f1b0968d4d6ffad)), closes [#5908](https://github.com/vuejs/vue/issues/5908)
-* include boolean in isPrimitive check ([#6127](https://github.com/vuejs/vue/issues/6127)) ([be3dc9c](https://github.com/vuejs/vue/commit/be3dc9c6e923248bcf81eb8240dd4f3c168fac59)), closes [#6126](https://github.com/vuejs/vue/issues/6126)
-* **parser:** only ignore the first newline in <pre> ([082fc39](https://github.com/vuejs/vue/commit/082fc3967db4d3290e901a38504dcd9bb698e561)), closes [#6146](https://github.com/vuejs/vue/issues/6146)
-* **provide/inject:** merge provide properly from mixins ([3036551](https://github.com/vuejs/vue/commit/303655116f8ec78f3b0ac99569637ad868dfe246)), closes [#6175](https://github.com/vuejs/vue/issues/6175)
-* **provide/inject:** resolve inject properly from mixins ([#6107](https://github.com/vuejs/vue/issues/6107)) ([b0f00e3](https://github.com/vuejs/vue/commit/b0f00e31e7d06edfdc733e2e7f24d5ca448759f9)), closes [#6093](https://github.com/vuejs/vue/issues/6093)
-* **transition:** should trigger transition hooks for v-show in ie9 ([9b4dbba](https://github.com/vuejs/vue/commit/9b4dbba384bc81a99abe429476729f80cb06d19a)), closes [#5525](https://github.com/vuejs/vue/issues/5525)
-* **v-bind:** respect .prop modifier on components ([#6159](https://github.com/vuejs/vue/issues/6159)) ([06b9b0b](https://github.com/vuejs/vue/commit/06b9b0bbadcc6c5afd300ed7748294e62ba00803))
-* **v-model:** use stricter check for <select> option update ([c70addf](https://github.com/vuejs/vue/commit/c70addf7d1a8e820ed80b6ab14aace5aa7b604c5)), closes [#6112](https://github.com/vuejs/vue/issues/6112)
-* **v-on:** revert component root data.on/data.nativeOn behavior for ([1713061](https://github.com/vuejs/vue/commit/17130611261fdbab70d0e5ab45036e4b612b17fe)), closes [#6109](https://github.com/vuejs/vue/issues/6109)
-* work around IE/Edge bug when accessing document.activeElement from iframe ([fc3d7cd](https://github.com/vuejs/vue/commit/fc3d7cd7a93534d76840418467f303d4b301fbcd)), closes [#6157](https://github.com/vuejs/vue/issues/6157)
-
+- checkbox v-model="array" ignore false-value ([#6180](https://github.com/vuejs/vue/issues/6180)) ([3d14e85](https://github.com/vuejs/vue/commit/3d14e855e422b656859d1b419af43b94320fcfce)), closes [#6178](https://github.com/vuejs/vue/issues/6178)
+- **compile:** properly generate comments with special character ([#6156](https://github.com/vuejs/vue/issues/6156)) ([d03fa26](https://github.com/vuejs/vue/commit/d03fa26687605a43d9a0c3f395d1d32375f7eaee)), closes [#6150](https://github.com/vuejs/vue/issues/6150)
+- ensure looseEqual is not dependant on key enumeration order ([a8ac129](https://github.com/vuejs/vue/commit/a8ac129a5876a7eeae0137bf2f1b0968d4d6ffad)), closes [#5908](https://github.com/vuejs/vue/issues/5908)
+- include boolean in isPrimitive check ([#6127](https://github.com/vuejs/vue/issues/6127)) ([be3dc9c](https://github.com/vuejs/vue/commit/be3dc9c6e923248bcf81eb8240dd4f3c168fac59)), closes [#6126](https://github.com/vuejs/vue/issues/6126)
+- **parser:** only ignore the first newline in <pre> ([082fc39](https://github.com/vuejs/vue/commit/082fc3967db4d3290e901a38504dcd9bb698e561)), closes [#6146](https://github.com/vuejs/vue/issues/6146)
+- **provide/inject:** merge provide properly from mixins ([3036551](https://github.com/vuejs/vue/commit/303655116f8ec78f3b0ac99569637ad868dfe246)), closes [#6175](https://github.com/vuejs/vue/issues/6175)
+- **provide/inject:** resolve inject properly from mixins ([#6107](https://github.com/vuejs/vue/issues/6107)) ([b0f00e3](https://github.com/vuejs/vue/commit/b0f00e31e7d06edfdc733e2e7f24d5ca448759f9)), closes [#6093](https://github.com/vuejs/vue/issues/6093)
+- **transition:** should trigger transition hooks for v-show in ie9 ([9b4dbba](https://github.com/vuejs/vue/commit/9b4dbba384bc81a99abe429476729f80cb06d19a)), closes [#5525](https://github.com/vuejs/vue/issues/5525)
+- **v-bind:** respect .prop modifier on components ([#6159](https://github.com/vuejs/vue/issues/6159)) ([06b9b0b](https://github.com/vuejs/vue/commit/06b9b0bbadcc6c5afd300ed7748294e62ba00803))
+- **v-model:** use stricter check for <select> option update ([c70addf](https://github.com/vuejs/vue/commit/c70addf7d1a8e820ed80b6ab14aace5aa7b604c5)), closes [#6112](https://github.com/vuejs/vue/issues/6112)
+- **v-on:** revert component root data.on/data.nativeOn behavior for ([1713061](https://github.com/vuejs/vue/commit/17130611261fdbab70d0e5ab45036e4b612b17fe)), closes [#6109](https://github.com/vuejs/vue/issues/6109)
+- work around IE/Edge bug when accessing document.activeElement from iframe ([fc3d7cd](https://github.com/vuejs/vue/commit/fc3d7cd7a93534d76840418467f303d4b301fbcd)), closes [#6157](https://github.com/vuejs/vue/issues/6157)
 
 ### Features
 
-* warn when assigning to computed property with no setter ([eb9168c](https://github.com/vuejs/vue/commit/eb9168cfc1816b53ddb1eccd6310173a37803897)), closes [#6078](https://github.com/vuejs/vue/issues/6078)
-
+- warn when assigning to computed property with no setter ([eb9168c](https://github.com/vuejs/vue/commit/eb9168cfc1816b53ddb1eccd6310173a37803897)), closes [#6078](https://github.com/vuejs/vue/issues/6078)
 
 ### Reverts
 
-* perf: remove src directory from npm module ([#6072](https://github.com/vuejs/vue/issues/6072)) ([ec4b1be](https://github.com/vuejs/vue/commit/ec4b1be42a30a452cca53bbdfdc8404c7a53e890))
-
-
+- perf: remove src directory from npm module ([#6072](https://github.com/vuejs/vue/issues/6072)) ([ec4b1be](https://github.com/vuejs/vue/commit/ec4b1be42a30a452cca53bbdfdc8404c7a53e890))
 
 ## [2.4.1](https://github.com/vuejs/vue/compare/v2.4.0...v2.4.1) (2017-07-13)
 
-
-
 # [2.4.0](https://github.com/vuejs/vue/compare/v2.3.3...v2.4.0) (2017-07-13)
 
-
 ### Bug Fixes
 
-* check enterToClass/leaveToClass existence before adding it ([#5912](https://github.com/vuejs/vue/issues/5912)) ([34d8c79](https://github.com/vuejs/vue/commit/34d8c796ac6a8e47bf23155bad71d07fafd1aa51)), closes [#5800](https://github.com/vuejs/vue/issues/5800)
-* **core:** add merge strategy for provide option ([#6025](https://github.com/vuejs/vue/issues/6025)) ([306997e](https://github.com/vuejs/vue/commit/306997eaf4ff36f4757c753c8a00ce3851e29cca)), closes [#6008](https://github.com/vuejs/vue/issues/6008)
-* **core:** should preserve reactivity-ness of injected objects ([8d66691](https://github.com/vuejs/vue/commit/8d66691ee264969447390822971b8caa029cac3e)), closes [#5913](https://github.com/vuejs/vue/issues/5913)
-* ensure cleanup in watcher.get ([#5988](https://github.com/vuejs/vue/issues/5988)) ([f6cd44c](https://github.com/vuejs/vue/commit/f6cd44c48b83640e5d3fbbea46d7b1b9cb439543)), closes [#5975](https://github.com/vuejs/vue/issues/5975)
-* handle arrays in v-on object syntax ([086e6d9](https://github.com/vuejs/vue/commit/086e6d98f4217542afcc2794717119c62dde89b8))
-* improve Vue.set/Vue.delete API to support multi type of array index ([#5973](https://github.com/vuejs/vue/issues/5973)) ([eea0920](https://github.com/vuejs/vue/commit/eea0920f14d0ea63d1b94c648eeb36ac7dfb4b05)), closes [#5884](https://github.com/vuejs/vue/issues/5884)
-* multiple merged vnode hooks not invoked properly ([91deb4f](https://github.com/vuejs/vue/commit/91deb4fd910afd51137820f120d4c26d0a99e629)), closes [#6076](https://github.com/vuejs/vue/issues/6076)
-* **parser:** the first newline following pre and textarea tag should be ignored ([#6022](https://github.com/vuejs/vue/issues/6022)) ([4d68079](https://github.com/vuejs/vue/commit/4d680794a5a345078827a3fee3db8658bd35ec3a))
-* prefetch should not have `as` attribute ([#5683](https://github.com/vuejs/vue/issues/5683)) ([ebca266](https://github.com/vuejs/vue/commit/ebca266d10febb5ab5ca0cfbcd0dfbff2f2c2170))
-* **ref:** refactor function registerRef ([#6039](https://github.com/vuejs/vue/issues/6039)) ([254d85c](https://github.com/vuejs/vue/commit/254d85cfc42d58bf9e3d0626ba959379bdc32d6f)), closes [#5997](https://github.com/vuejs/vue/issues/5997)
-* **ssr:** fix bundleRenderer mapped async chunks caching check ([#5963](https://github.com/vuejs/vue/issues/5963)) ([de42186](https://github.com/vuejs/vue/commit/de42186d52562a0ce506580484ff64fe86b765bd))
-* **ssr:** reference error when create $ssrContext for root component ([#5981](https://github.com/vuejs/vue/issues/5981)) ([5581654](https://github.com/vuejs/vue/commit/55816543c46e75aa53481ac95a89ff6f87a2d704)), closes [#5941](https://github.com/vuejs/vue/issues/5941)
-* support plugin with multi version vue ([#5985](https://github.com/vuejs/vue/issues/5985)) ([049f317](https://github.com/vuejs/vue/commit/049f3171a9d2e97f62c209a4b78a71ec9dae810f)), closes [#5970](https://github.com/vuejs/vue/issues/5970)
-* transition group should work with dynamic name ([#6006](https://github.com/vuejs/vue/issues/6006)) ([#6019](https://github.com/vuejs/vue/issues/6019)) ([d8d4ca6](https://github.com/vuejs/vue/commit/d8d4ca6763af55e1715bbc1e0fadd10e5be41db3))
-* v-bind object should not override props on scopedSlots ([#5995](https://github.com/vuejs/vue/issues/5995)) ([458030a](https://github.com/vuejs/vue/commit/458030ae19a51982d028dcacfc77ab2cfac8ac26))
-* **v-model:** fix input change check for type="number" ([0a9aab5](https://github.com/vuejs/vue/commit/0a9aab510bcca85c78ef06487b5dcf25d76d780d)), closes [#6069](https://github.com/vuejs/vue/issues/6069)
-* **v-model:** should generate component-specific code for tags with "is" attribute ([a1d1145](https://github.com/vuejs/vue/commit/a1d1145c9123f7175f3ac20b503cfa507ad455f4)), closes [#6066](https://github.com/vuejs/vue/issues/6066)
-* **v-model:** use consistent behavior during IME composition for other text-like input types (fix [#5902](https://github.com/vuejs/vue/issues/5902)) ([4acc8c8](https://github.com/vuejs/vue/commit/4acc8c8be1971112be45e0feb7fb7eddbfc9d247))
-
+- check enterToClass/leaveToClass existence before adding it ([#5912](https://github.com/vuejs/vue/issues/5912)) ([34d8c79](https://github.com/vuejs/vue/commit/34d8c796ac6a8e47bf23155bad71d07fafd1aa51)), closes [#5800](https://github.com/vuejs/vue/issues/5800)
+- **core:** add merge strategy for provide option ([#6025](https://github.com/vuejs/vue/issues/6025)) ([306997e](https://github.com/vuejs/vue/commit/306997eaf4ff36f4757c753c8a00ce3851e29cca)), closes [#6008](https://github.com/vuejs/vue/issues/6008)
+- **core:** should preserve reactivity-ness of injected objects ([8d66691](https://github.com/vuejs/vue/commit/8d66691ee264969447390822971b8caa029cac3e)), closes [#5913](https://github.com/vuejs/vue/issues/5913)
+- ensure cleanup in watcher.get ([#5988](https://github.com/vuejs/vue/issues/5988)) ([f6cd44c](https://github.com/vuejs/vue/commit/f6cd44c48b83640e5d3fbbea46d7b1b9cb439543)), closes [#5975](https://github.com/vuejs/vue/issues/5975)
+- handle arrays in v-on object syntax ([086e6d9](https://github.com/vuejs/vue/commit/086e6d98f4217542afcc2794717119c62dde89b8))
+- improve Vue.set/Vue.delete API to support multi type of array index ([#5973](https://github.com/vuejs/vue/issues/5973)) ([eea0920](https://github.com/vuejs/vue/commit/eea0920f14d0ea63d1b94c648eeb36ac7dfb4b05)), closes [#5884](https://github.com/vuejs/vue/issues/5884)
+- multiple merged vnode hooks not invoked properly ([91deb4f](https://github.com/vuejs/vue/commit/91deb4fd910afd51137820f120d4c26d0a99e629)), closes [#6076](https://github.com/vuejs/vue/issues/6076)
+- **parser:** the first newline following pre and textarea tag should be ignored ([#6022](https://github.com/vuejs/vue/issues/6022)) ([4d68079](https://github.com/vuejs/vue/commit/4d680794a5a345078827a3fee3db8658bd35ec3a))
+- prefetch should not have `as` attribute ([#5683](https://github.com/vuejs/vue/issues/5683)) ([ebca266](https://github.com/vuejs/vue/commit/ebca266d10febb5ab5ca0cfbcd0dfbff2f2c2170))
+- **ref:** refactor function registerRef ([#6039](https://github.com/vuejs/vue/issues/6039)) ([254d85c](https://github.com/vuejs/vue/commit/254d85cfc42d58bf9e3d0626ba959379bdc32d6f)), closes [#5997](https://github.com/vuejs/vue/issues/5997)
+- **ssr:** fix bundleRenderer mapped async chunks caching check ([#5963](https://github.com/vuejs/vue/issues/5963)) ([de42186](https://github.com/vuejs/vue/commit/de42186d52562a0ce506580484ff64fe86b765bd))
+- **ssr:** reference error when create $ssrContext for root component ([#5981](https://github.com/vuejs/vue/issues/5981)) ([5581654](https://github.com/vuejs/vue/commit/55816543c46e75aa53481ac95a89ff6f87a2d704)), closes [#5941](https://github.com/vuejs/vue/issues/5941)
+- support plugin with multi version vue ([#5985](https://github.com/vuejs/vue/issues/5985)) ([049f317](https://github.com/vuejs/vue/commit/049f3171a9d2e97f62c209a4b78a71ec9dae810f)), closes [#5970](https://github.com/vuejs/vue/issues/5970)
+- transition group should work with dynamic name ([#6006](https://github.com/vuejs/vue/issues/6006)) ([#6019](https://github.com/vuejs/vue/issues/6019)) ([d8d4ca6](https://github.com/vuejs/vue/commit/d8d4ca6763af55e1715bbc1e0fadd10e5be41db3))
+- v-bind object should not override props on scopedSlots ([#5995](https://github.com/vuejs/vue/issues/5995)) ([458030a](https://github.com/vuejs/vue/commit/458030ae19a51982d028dcacfc77ab2cfac8ac26))
+- **v-model:** fix input change check for type="number" ([0a9aab5](https://github.com/vuejs/vue/commit/0a9aab510bcca85c78ef06487b5dcf25d76d780d)), closes [#6069](https://github.com/vuejs/vue/issues/6069)
+- **v-model:** should generate component-specific code for tags with "is" attribute ([a1d1145](https://github.com/vuejs/vue/commit/a1d1145c9123f7175f3ac20b503cfa507ad455f4)), closes [#6066](https://github.com/vuejs/vue/issues/6066)
+- **v-model:** use consistent behavior during IME composition for other text-like input types (fix [#5902](https://github.com/vuejs/vue/issues/5902)) ([4acc8c8](https://github.com/vuejs/vue/commit/4acc8c8be1971112be45e0feb7fb7eddbfc9d247))
 
 ### Features
 
-* add .editorconfig ([#5691](https://github.com/vuejs/vue/issues/5691)) ([0cc0b07](https://github.com/vuejs/vue/commit/0cc0b0726d389fca535b35e4593a5ecca3dde6c9))
-* add `comments` option to allow preserving comments in template  ([#5951](https://github.com/vuejs/vue/issues/5951)) ([e4da249](https://github.com/vuejs/vue/commit/e4da249ab8ef32a0b8156c840c9d2b9773090f8a)), closes [#5392](https://github.com/vuejs/vue/issues/5392)
-* Add `defer` to body scripts ([#5704](https://github.com/vuejs/vue/issues/5704)) ([f3757eb](https://github.com/vuejs/vue/commit/f3757eb37bfe38cb2e8d87983a1f83d31ea9d30a))
-* **core:** $attrs, $listeners & inheritAttrs option ([6118759](https://github.com/vuejs/vue/commit/61187596b9af48f1cb7b1848ad3eccc02ac2509d)), closes [#5983](https://github.com/vuejs/vue/issues/5983)
-* **keep-alive:** support Array for include and exclude ([#5956](https://github.com/vuejs/vue/issues/5956)) ([51c595a](https://github.com/vuejs/vue/commit/51c595a7cef24e12094f66e0f8934fa41edde07d))
-* resolve ES module default when resolving async components ([0cd6ef3](https://github.com/vuejs/vue/commit/0cd6ef321b3168d6c46c7a870c3d2a53fd9d4bde))
-* **ssr:** inheritAttrs support in SSR ([6bf9772](https://github.com/vuejs/vue/commit/6bf97721f1e38713353d5ac9906c88dca2cdad9b))
-* support sync modifier for v-bind="object" ([#5943](https://github.com/vuejs/vue/issues/5943)) ([3965e50](https://github.com/vuejs/vue/commit/3965e5053a7d2f22e90f81d4a153d65c1c670897)), closes [#5937](https://github.com/vuejs/vue/issues/5937)
-* **types:** add declaration for inheritAttrs ([1f9e924](https://github.com/vuejs/vue/commit/1f9e924971d7894517075f7f0efeeb85994a7ba0))
-* **types:** expose $vnode ([1b7ddd7](https://github.com/vuejs/vue/commit/1b7ddd7a35fab8773508ed47f56d0716081cfa1a))
-* **v-on:** support v-on object syntax with no arguments ([11614d6](https://github.com/vuejs/vue/commit/11614d63b7862b68b11cc45c0891437c62a832d7))
-* **weex:** implement "weex.supports" api to support feature detection ([#6053](https://github.com/vuejs/vue/issues/6053)) ([b1512d8](https://github.com/vuejs/vue/commit/b1512d8b136e0a12aca8dde9e72bf5200d3afe09))
-
+- add .editorconfig ([#5691](https://github.com/vuejs/vue/issues/5691)) ([0cc0b07](https://github.com/vuejs/vue/commit/0cc0b0726d389fca535b35e4593a5ecca3dde6c9))
+- add `comments` option to allow preserving comments in template ([#5951](https://github.com/vuejs/vue/issues/5951)) ([e4da249](https://github.com/vuejs/vue/commit/e4da249ab8ef32a0b8156c840c9d2b9773090f8a)), closes [#5392](https://github.com/vuejs/vue/issues/5392)
+- Add `defer` to body scripts ([#5704](https://github.com/vuejs/vue/issues/5704)) ([f3757eb](https://github.com/vuejs/vue/commit/f3757eb37bfe38cb2e8d87983a1f83d31ea9d30a))
+- **core:** $attrs, $listeners & inheritAttrs option ([6118759](https://github.com/vuejs/vue/commit/61187596b9af48f1cb7b1848ad3eccc02ac2509d)), closes [#5983](https://github.com/vuejs/vue/issues/5983)
+- **keep-alive:** support Array for include and exclude ([#5956](https://github.com/vuejs/vue/issues/5956)) ([51c595a](https://github.com/vuejs/vue/commit/51c595a7cef24e12094f66e0f8934fa41edde07d))
+- resolve ES module default when resolving async components ([0cd6ef3](https://github.com/vuejs/vue/commit/0cd6ef321b3168d6c46c7a870c3d2a53fd9d4bde))
+- **ssr:** inheritAttrs support in SSR ([6bf9772](https://github.com/vuejs/vue/commit/6bf97721f1e38713353d5ac9906c88dca2cdad9b))
+- support sync modifier for v-bind="object" ([#5943](https://github.com/vuejs/vue/issues/5943)) ([3965e50](https://github.com/vuejs/vue/commit/3965e5053a7d2f22e90f81d4a153d65c1c670897)), closes [#5937](https://github.com/vuejs/vue/issues/5937)
+- **types:** add declaration for inheritAttrs ([1f9e924](https://github.com/vuejs/vue/commit/1f9e924971d7894517075f7f0efeeb85994a7ba0))
+- **types:** expose $vnode ([1b7ddd7](https://github.com/vuejs/vue/commit/1b7ddd7a35fab8773508ed47f56d0716081cfa1a))
+- **v-on:** support v-on object syntax with no arguments ([11614d6](https://github.com/vuejs/vue/commit/11614d63b7862b68b11cc45c0891437c62a832d7))
+- **weex:** implement "weex.supports" api to support feature detection ([#6053](https://github.com/vuejs/vue/issues/6053)) ([b1512d8](https://github.com/vuejs/vue/commit/b1512d8b136e0a12aca8dde9e72bf5200d3afe09))
 
 ### Performance Improvements
 
-* remove src directory from npm module ([#6072](https://github.com/vuejs/vue/issues/6072)) ([e761573](https://github.com/vuejs/vue/commit/e7615737f142e3350b53d09d3a46d7ec143d1ef4))
-
-
+- remove src directory from npm module ([#6072](https://github.com/vuejs/vue/issues/6072)) ([e761573](https://github.com/vuejs/vue/commit/e7615737f142e3350b53d09d3a46d7ec143d1ef4))
 
 ## [2.3.3](https://github.com/vuejs/vue/compare/v2.3.2...v2.3.3) (2017-05-09)
 
-
-
 ## [2.3.2](https://github.com/vuejs/vue/compare/v2.3.1...v2.3.2) (2017-05-02)
 
-
-
 ## [2.3.1](https://github.com/vuejs/vue/compare/v2.3.0...v2.3.1) (2017-05-02)
 
-
-
 # [2.3.0](https://github.com/vuejs/vue/compare/v2.3.0-beta.1...v2.3.0) (2017-04-27)
 
-
-
 # [2.3.0-beta.1](https://github.com/vuejs/vue/compare/v2.2.6...v2.3.0-beta.1) (2017-04-26)
 
-
-
 ## [2.2.6](https://github.com/vuejs/vue/compare/v2.2.5...v2.2.6) (2017-03-27)
 
-
-
 ## [2.2.5](https://github.com/vuejs/vue/compare/v2.2.4...v2.2.5) (2017-03-24)
 
-
 ### Bug Fixes
 
-* **inject:** change warn message when trying to mutate an injected value ([#5243](https://github.com/vuejs/vue/issues/5243)) ([23a058e](https://github.com/vuejs/vue/commit/23a058ed13e7faa667ada2b96e242eb7488b601c))
-
-
+- **inject:** change warn message when trying to mutate an injected value ([#5243](https://github.com/vuejs/vue/issues/5243)) ([23a058e](https://github.com/vuejs/vue/commit/23a058ed13e7faa667ada2b96e242eb7488b601c))
 
 ## [2.2.4](https://github.com/vuejs/vue/compare/v2.2.3...v2.2.4) (2017-03-13)
 
-
-
 ## [2.2.3](https://github.com/vuejs/vue/compare/v2.2.2...v2.2.3) (2017-03-13)
 
-
-
 ## [2.2.2](https://github.com/vuejs/vue/compare/v2.2.1...v2.2.2) (2017-03-09)
 
-
-
 ## [2.2.1](https://github.com/vuejs/vue/compare/v2.2.0...v2.2.1) (2017-02-26)
 
-
-
 # [2.2.0](https://github.com/vuejs/vue/compare/v2.2.0-beta.2...v2.2.0) (2017-02-26)
 
-
-
 # [2.2.0-beta.2](https://github.com/vuejs/vue/compare/v2.2.0-beta.1...v2.2.0-beta.2) (2017-02-25)
 
-
 ### Reverts
 
-* Revert "[WIP] Support for ref callback (#4807)" ([e7a2510](https://github.com/vuejs/vue/commit/e7a2510e631bd25f46b4e1125b83a9236a50ff1d)), closes [#4807](https://github.com/vuejs/vue/issues/4807)
-
-
+- Revert "[WIP] Support for ref callback (#4807)" ([e7a2510](https://github.com/vuejs/vue/commit/e7a2510e631bd25f46b4e1125b83a9236a50ff1d)), closes [#4807](https://github.com/vuejs/vue/issues/4807)
 
 # [2.2.0-beta.1](https://github.com/vuejs/vue/compare/v2.1.10...v2.2.0-beta.1) (2017-02-24)
 
-
 ### Bug Fixes
 
-* **sfc:** component contains '<' only ([#4753](https://github.com/vuejs/vue/issues/4753)) ([938fa4e](https://github.com/vuejs/vue/commit/938fa4efcc9bf6232bf5ace5920398dc2e128ac9))
-
+- **sfc:** component contains '<' only ([#4753](https://github.com/vuejs/vue/issues/4753)) ([938fa4e](https://github.com/vuejs/vue/commit/938fa4efcc9bf6232bf5ace5920398dc2e128ac9))
 
 ### Features
 
-* allow customization of component v-model prop/event via model option (close [#4515](https://github.com/vuejs/vue/issues/4515)) ([9d6c8ec](https://github.com/vuejs/vue/commit/9d6c8ec268f659a715e3b38c97a1e03964961703))
-* config.performance ([689c107](https://github.com/vuejs/vue/commit/689c107de4624879a5b6282ce43eed5ea3907b38))
-* implement template option for vue-server-renderer ([1c79592](https://github.com/vuejs/vue/commit/1c79592524339773d6397b264b2b489606cd55cb))
-* provide/inject (close [#4029](https://github.com/vuejs/vue/issues/4029)) ([f916bcf](https://github.com/vuejs/vue/commit/f916bcf37105903290ad2353db9a9436536d6859))
-* renderError ([1861ee9](https://github.com/vuejs/vue/commit/1861ee9570730149e01f225323c3a52392e5900f))
-* support multi-chunk bundles in ssr bundle renderer ([561447d](https://github.com/vuejs/vue/commit/561447d278da26e95c488ea75856823557b66c5e))
-
-
+- allow customization of component v-model prop/event via model option (close [#4515](https://github.com/vuejs/vue/issues/4515)) ([9d6c8ec](https://github.com/vuejs/vue/commit/9d6c8ec268f659a715e3b38c97a1e03964961703))
+- config.performance ([689c107](https://github.com/vuejs/vue/commit/689c107de4624879a5b6282ce43eed5ea3907b38))
+- implement template option for vue-server-renderer ([1c79592](https://github.com/vuejs/vue/commit/1c79592524339773d6397b264b2b489606cd55cb))
+- provide/inject (close [#4029](https://github.com/vuejs/vue/issues/4029)) ([f916bcf](https://github.com/vuejs/vue/commit/f916bcf37105903290ad2353db9a9436536d6859))
+- renderError ([1861ee9](https://github.com/vuejs/vue/commit/1861ee9570730149e01f225323c3a52392e5900f))
+- support multi-chunk bundles in ssr bundle renderer ([561447d](https://github.com/vuejs/vue/commit/561447d278da26e95c488ea75856823557b66c5e))
 
 ## [2.1.10](https://github.com/vuejs/vue/compare/v2.1.9...v2.1.10) (2017-01-17)
 
-
-
 ## [2.1.9](https://github.com/vuejs/vue/compare/v2.1.8...v2.1.9) (2017-01-16)
 
-
 ### Reverts
 
-* Revert "also bind static special attrs as props (fix #4530)" ([ab0a225](https://github.com/vuejs/vue/commit/ab0a2259e0ef3f4ebdc8d0d4b929fae3e3f579d8)), closes [#4530](https://github.com/vuejs/vue/issues/4530)
-* Revert "Mark node with static props as static (#4662)" ([4e830ba](https://github.com/vuejs/vue/commit/4e830ba3c3c92e78bf3ffbea82a583865deaa52a)), closes [#4662](https://github.com/vuejs/vue/issues/4662)
-
-
+- Revert "also bind static special attrs as props (fix #4530)" ([ab0a225](https://github.com/vuejs/vue/commit/ab0a2259e0ef3f4ebdc8d0d4b929fae3e3f579d8)), closes [#4530](https://github.com/vuejs/vue/issues/4530)
+- Revert "Mark node with static props as static (#4662)" ([4e830ba](https://github.com/vuejs/vue/commit/4e830ba3c3c92e78bf3ffbea82a583865deaa52a)), closes [#4662](https://github.com/vuejs/vue/issues/4662)
 
 ## [2.1.8](https://github.com/vuejs/vue/compare/v2.1.7...v2.1.8) (2016-12-28)
 
-
 ### Reverts
 
-* Revert "remove no longer necessary code" ([fcc98d5](https://github.com/vuejs/vue/commit/fcc98d52e21bb634c3f0c50eeb4ee87494a7196f))
-* Revert "ensure leave transitions and enter transitions are triggered in the same frame (fix #4510)" ([02e2d99](https://github.com/vuejs/vue/commit/02e2d99e277a1ba1bd42e1b81b2273903fdb7fbc)), closes [#4510](https://github.com/vuejs/vue/issues/4510)
-* Revert "fix enter transition flicker regression (fix #4576)" ([0bb2d4e](https://github.com/vuejs/vue/commit/0bb2d4e2b621950f5d44ed83b7e9ce15e282db68)), closes [#4576](https://github.com/vuejs/vue/issues/4576)
-
-
+- Revert "remove no longer necessary code" ([fcc98d5](https://github.com/vuejs/vue/commit/fcc98d52e21bb634c3f0c50eeb4ee87494a7196f))
+- Revert "ensure leave transitions and enter transitions are triggered in the same frame (fix #4510)" ([02e2d99](https://github.com/vuejs/vue/commit/02e2d99e277a1ba1bd42e1b81b2273903fdb7fbc)), closes [#4510](https://github.com/vuejs/vue/issues/4510)
+- Revert "fix enter transition flicker regression (fix #4576)" ([0bb2d4e](https://github.com/vuejs/vue/commit/0bb2d4e2b621950f5d44ed83b7e9ce15e282db68)), closes [#4576](https://github.com/vuejs/vue/issues/4576)
 
 ## [2.1.7](https://github.com/vuejs/vue/compare/v2.1.6...v2.1.7) (2016-12-24)
 
-
-
 ## [2.1.6](https://github.com/vuejs/vue/compare/v2.1.5...v2.1.6) (2016-12-13)
 
-
-
 ## [2.1.5](https://github.com/vuejs/vue/compare/v2.1.4...v2.1.5) (2016-12-13)
 
-
-
 ## [2.1.4](https://github.com/vuejs/vue/compare/v2.1.3...v2.1.4) (2016-12-02)
 
-
-
 ## [2.1.3](https://github.com/vuejs/vue/compare/v2.1.2...v2.1.3) (2016-11-24)
 
-
-
 ## [2.1.2](https://github.com/vuejs/vue/compare/v2.1.1...v2.1.2) (2016-11-23)
 
-
-
 ## [2.1.1](https://github.com/vuejs/vue/compare/v2.1.0...v2.1.1) (2016-11-23)
 
-
-
 # [2.1.0](https://github.com/vuejs/vue/compare/v2.0.8...v2.1.0) (2016-11-22)
 
-
-
 ## [2.0.8](https://github.com/vuejs/vue/compare/v2.0.7...v2.0.8) (2016-11-20)
 
-
-
 ## [2.0.7](https://github.com/vuejs/vue/compare/v2.0.6...v2.0.7) (2016-11-16)
 
-
-
 ## [2.0.6](https://github.com/vuejs/vue/compare/v2.0.5...v2.0.6) (2016-11-15)
 
-
 ### Reverts
 
-* Revert "fix #4041, warn overriding Vue's internal methods (#4111)" ([1bcc571](https://github.com/vuejs/vue/commit/1bcc571739d7228db0bc947ee67c20dde5aeb7e0)), closes [#4041](https://github.com/vuejs/vue/issues/4041) [#4111](https://github.com/vuejs/vue/issues/4111)
-
-
+- Revert "fix #4041, warn overriding Vue's internal methods (#4111)" ([1bcc571](https://github.com/vuejs/vue/commit/1bcc571739d7228db0bc947ee67c20dde5aeb7e0)), closes [#4041](https://github.com/vuejs/vue/issues/4041) [#4111](https://github.com/vuejs/vue/issues/4111)
 
 ## [2.0.5](https://github.com/vuejs/vue/compare/v2.0.4...v2.0.5) (2016-11-05)
 
-
-
 ## [2.0.4](https://github.com/vuejs/vue/compare/v2.0.3...v2.0.4) (2016-11-04)
 
-
-
 ## [2.0.3](https://github.com/vuejs/vue/compare/v2.0.2...v2.0.3) (2016-10-13)
 
-
-
 ## [2.0.2](https://github.com/vuejs/vue/compare/v2.0.1...v2.0.2) (2016-10-12)
 
-
 ### Reverts
 
-* Revert "fix select multiple first option auto-selected in Chrome/FF (fix #3852)" ([d0cfd54](https://github.com/vuejs/vue/commit/d0cfd549ba24edc7dced17ef7b8f410c4ea197f0)), closes [#3852](https://github.com/vuejs/vue/issues/3852)
-
-
+- Revert "fix select multiple first option auto-selected in Chrome/FF (fix #3852)" ([d0cfd54](https://github.com/vuejs/vue/commit/d0cfd549ba24edc7dced17ef7b8f410c4ea197f0)), closes [#3852](https://github.com/vuejs/vue/issues/3852)
 
 ## [2.0.1](https://github.com/vuejs/vue/compare/v2.0.0...v2.0.1) (2016-09-30)
 
-
-
 # [2.0.0](https://github.com/vuejs/vue/compare/v2.0.0-rc.8...v2.0.0) (2016-09-30)
 
-
-
 # [2.0.0-rc.8](https://github.com/vuejs/vue/compare/v2.0.0-rc.7...v2.0.0-rc.8) (2016-09-27)
 
-
-
 # [2.0.0-rc.7](https://github.com/vuejs/vue/compare/v2.0.0-rc.6...v2.0.0-rc.7) (2016-09-23)
 
-
-
 # [2.0.0-rc.6](https://github.com/vuejs/vue/compare/v2.0.0-rc.5...v2.0.0-rc.6) (2016-09-13)
 
-
-
 # [2.0.0-rc.5](https://github.com/vuejs/vue/compare/v2.0.0-rc.4...v2.0.0-rc.5) (2016-09-08)
 
-
-
 # [2.0.0-rc.4](https://github.com/vuejs/vue/compare/v2.0.0-rc.3...v2.0.0-rc.4) (2016-08-29)
 
-
-
 # [2.0.0-rc.3](https://github.com/vuejs/vue/compare/v2.0.0-rc.2...v2.0.0-rc.3) (2016-08-20)
 
-
-
 # [2.0.0-rc.2](https://github.com/vuejs/vue/compare/v2.0.0-rc.1...v2.0.0-rc.2) (2016-08-16)
 
-
 ### Reverts
 
-* Revert "support transition on component with v-show in root node (fix #3431)" ([68be112](https://github.com/vuejs/vue/commit/68be112652060f9a7123b594a3b18ca5fc31b033)), closes [#3431](https://github.com/vuejs/vue/issues/3431)
-
-
+- Revert "support transition on component with v-show in root node (fix #3431)" ([68be112](https://github.com/vuejs/vue/commit/68be112652060f9a7123b594a3b18ca5fc31b033)), closes [#3431](https://github.com/vuejs/vue/issues/3431)
 
 # [2.0.0-rc.1](https://github.com/vuejs/vue/compare/v2.0.0-beta.8...v2.0.0-rc.1) (2016-08-11)
 
-
-
 # [2.0.0-beta.8](https://github.com/vuejs/vue/compare/v2.0.0-beta.7...v2.0.0-beta.8) (2016-08-10)
 
-
-
 # [2.0.0-beta.7](https://github.com/vuejs/vue/compare/v2.0.0-beta.6...v2.0.0-beta.7) (2016-08-05)
 
-
-
 # [2.0.0-beta.6](https://github.com/vuejs/vue/compare/v2.0.0-beta.5...v2.0.0-beta.6) (2016-08-01)
 
-
-
 # [2.0.0-beta.5](https://github.com/vuejs/vue/compare/v2.0.0-beta.4...v2.0.0-beta.5) (2016-07-27)
 
-
 ### Reverts
 
-* Revert "remove parser pre/post transforms (not used)" ([bee95f8](https://github.com/vuejs/vue/commit/bee95f8c08af2dd5af653847ec569bd801112c90))
-
-
+- Revert "remove parser pre/post transforms (not used)" ([bee95f8](https://github.com/vuejs/vue/commit/bee95f8c08af2dd5af653847ec569bd801112c90))
 
 # [2.0.0-beta.4](https://github.com/vuejs/vue/compare/v2.0.0-beta.3...v2.0.0-beta.4) (2016-07-26)
 
-
-
 # [2.0.0-beta.3](https://github.com/vuejs/vue/compare/v2.0.0-beta.2...v2.0.0-beta.3) (2016-07-24)
 
-
-
 # [2.0.0-beta.2](https://github.com/vuejs/vue/compare/v2.0.0-beta.1...v2.0.0-beta.2) (2016-07-17)
 
-
-
 # [2.0.0-beta.1](https://github.com/vuejs/vue/compare/v2.0.0-alpha.8...v2.0.0-beta.1) (2016-07-07)
 
-
-
 # [2.0.0-alpha.8](https://github.com/vuejs/vue/compare/v2.0.0-alpha.7...v2.0.0-alpha.8) (2016-06-28)
 
-
-
 # [2.0.0-alpha.7](https://github.com/vuejs/vue/compare/v2.0.0-alpha.6...v2.0.0-alpha.7) (2016-06-28)
 
-
-
 # [2.0.0-alpha.6](https://github.com/vuejs/vue/compare/v2.0.0-alpha.5...v2.0.0-alpha.6) (2016-06-22)
 
-
-
 # [2.0.0-alpha.5](https://github.com/vuejs/vue/compare/v2.0.0-alpha.4...v2.0.0-alpha.5) (2016-06-17)
 
-
-
 # [2.0.0-alpha.4](https://github.com/vuejs/vue/compare/v2.0.0-alpha.3...v2.0.0-alpha.4) (2016-06-16)
 
-
-
 # [2.0.0-alpha.3](https://github.com/vuejs/vue/compare/v2.0.0-alpha.2...v2.0.0-alpha.3) (2016-06-15)
 
-
-
 # [2.0.0-alpha.2](https://github.com/vuejs/vue/compare/v2.0.0-alpha.1...v2.0.0-alpha.2) (2016-06-13)
 
-
-
 # [2.0.0-alpha.1](https://github.com/vuejs/vue/compare/5b30f3eab89db88cb61894de617bdce53e82393e...v2.0.0-alpha.1) (2016-06-10)
 
-
 ### Reverts
 
-* Revert "simplify array change detection" ([5b30f3e](https://github.com/vuejs/vue/commit/5b30f3eab89db88cb61894de617bdce53e82393e))
-
-
-
+- Revert "simplify array change detection" ([5b30f3e](https://github.com/vuejs/vue/commit/5b30f3eab89db88cb61894de617bdce53e82393e))

From 7ec896827f82cfb410f79aa709e4186a911bf995 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 10:37:17 +0800
Subject: [PATCH 113/317] release: v2.7.0-alpha.2

---
 CHANGELOG.md                            | 10 ++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0059b4062d1..abaaccc8c0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+# [2.7.0-alpha.2](https://github.com/vuejs/vue/compare/v2.7.0-alpha.1...v2.7.0-alpha.2) (2022-06-01)
+
+
+### Features
+
+* add exports field + mjs build ([d317237](https://github.com/vuejs/vue/commit/d3172377e0c2df9e84244ede6fc9a091344e6f1c))
+* expose set/del as named exports ([5673363](https://github.com/vuejs/vue/commit/5673363eda9e6082a9ff0300b8c4e79c9388891b))
+
+
+
 # [2.7.0-alpha.1](https://github.com/vuejs/vue/compare/v2.6.14...v2.7.0-alpha.1) (2022-05-31)
 
 This release includes full [Composition API](https://vuejs.org/guide/extras/composition-api-faq.html) support, including:
diff --git a/package.json b/package.json
index 8b9e71fbba1..f9b8ea6be60 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.1",
+  "version": "2.7.0-alpha.2",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index a8730ecf970..440b578b47e 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.1",
+  "version": "2.7.0-alpha.2",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 5d9b13b64a9..7628d1ff542 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.1",
+  "version": "2.7.0-alpha.2",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 47ef9be2a12..5776545a2d6 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.1",
+  "version": "2.7.0-alpha.2",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From bafb5d419d49ac60c431184160c8e74fe010fc25 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 11:12:20 +0800
Subject: [PATCH 114/317] chore: avoid generating unused dts

---
 api-extractor.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/api-extractor.json b/api-extractor.json
index 19fcd417f2b..b92115b8c62 100644
--- a/api-extractor.json
+++ b/api-extractor.json
@@ -11,6 +11,7 @@
 
   "dtsRollup": {
     "enabled": true,
+    "untrimmedFilePath": "",
     "publicTrimmedFilePath": "./types/v3-generated.d.ts"
   },
 

From a9a2fae970b43150895677fbf3ea6017977164c8 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 11:12:30 +0800
Subject: [PATCH 115/317] build: fix mjs build publish

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index f9b8ea6be60..b0ab85d8c2c 100644
--- a/package.json
+++ b/package.json
@@ -11,6 +11,7 @@
   "files": [
     "src",
     "dist/*.js",
+    "dist/*.mjs",
     "types/*.d.ts",
     "compiler-sfc",
     "packages/compiler-sfc"

From 5fbf2c99285664196694ecbcfd4db1f1e816813e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 11:13:29 +0800
Subject: [PATCH 116/317] release: v2.7.0-alpha.3

---
 CHANGELOG.md                            | 4 ++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abaaccc8c0f..3e0df66fb1e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# [2.7.0-alpha.3](https://github.com/vuejs/vue/compare/v2.7.0-alpha.2...v2.7.0-alpha.3) (2022-06-01)
+
+
+
 # [2.7.0-alpha.2](https://github.com/vuejs/vue/compare/v2.7.0-alpha.1...v2.7.0-alpha.2) (2022-06-01)
 
 
diff --git a/package.json b/package.json
index b0ab85d8c2c..84043ab9378 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.2",
+  "version": "2.7.0-alpha.3",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 440b578b47e..6cef8a85fda 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.2",
+  "version": "2.7.0-alpha.3",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 7628d1ff542..a7534185aa6 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.2",
+  "version": "2.7.0-alpha.3",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 5776545a2d6..cc275b3cd56 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.2",
+  "version": "2.7.0-alpha.3",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 72194a45917115f82f83969ff2cdce811fb8bea2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 14:27:29 +0800
Subject: [PATCH 117/317] build: use extended tsconfig

---
 api-extractor.tsconfig.json                 | 32 ++----------------
 packages/server-renderer/test/tsconfig.json |  7 ++++
 packages/server-renderer/tsconfig.json      | 37 ---------------------
 test/tsconfig.json                          | 34 ++-----------------
 tsconfig.json                               |  4 +--
 5 files changed, 13 insertions(+), 101 deletions(-)
 create mode 100644 packages/server-renderer/test/tsconfig.json
 delete mode 100644 packages/server-renderer/tsconfig.json

diff --git a/api-extractor.tsconfig.json b/api-extractor.tsconfig.json
index 0f6dfeaace5..39af6b8db04 100644
--- a/api-extractor.tsconfig.json
+++ b/api-extractor.tsconfig.json
@@ -1,36 +1,8 @@
 {
+  "extends": "./tsconfig.json",
   "compilerOptions": {
     "baseUrl": "./temp",
-    "outDir": "dist",
-    "sourceMap": true,
-    "target": "esnext",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "strict": true,
-
-    "allowJs": true,
-    "noImplicitAny": false,
-    "noImplicitThis": false,
-
-    "noUnusedLocals": true,
-    "experimentalDecorators": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "removeComments": false,
-    "jsx": "preserve",
-    "lib": ["esnext", "dom"],
-    "paths": {
-      "compiler/*": ["src/compiler/*"],
-      "core/*": ["src/core/*"],
-      "server/*": ["src/server/*"],
-      "sfc/*": ["src/sfc/*"],
-      "shared/*": ["src/shared/*"],
-      "web/*": ["src/platforms/web/*"],
-      "v3": ["src/v3/index"],
-      "v3/*": ["src/v3/*"],
-      "types/*": ["src/types/*"],
-      "vue": ["src/platforms/web/entry-runtime-with-compiler"]
-    }
+    "types": []
   },
   "include": ["src"]
 }
diff --git a/packages/server-renderer/test/tsconfig.json b/packages/server-renderer/test/tsconfig.json
new file mode 100644
index 00000000000..96cc3dcb9a0
--- /dev/null
+++ b/packages/server-renderer/test/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "types": ["node", "vitest/globals"]
+  },
+  "include": [".", "../../../test/test-env.d.ts"]
+}
diff --git a/packages/server-renderer/tsconfig.json b/packages/server-renderer/tsconfig.json
deleted file mode 100644
index a490aeb83cf..00000000000
--- a/packages/server-renderer/tsconfig.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-  "compilerOptions": {
-    "baseUrl": ".",
-    "outDir": "dist",
-    "sourceMap": true,
-    "target": "esnext",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "strict": true,
-
-    "allowJs": true,
-    "noImplicitAny": false,
-    "noImplicitThis": false,
-
-    "noUnusedLocals": true,
-    "experimentalDecorators": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "removeComments": false,
-    "jsx": "preserve",
-    "lib": ["esnext", "dom"],
-    "types": ["node", "vitest/globals"],
-    "paths": {
-      "compiler/*": ["../../src/compiler/*"],
-      "core/*": ["../../src/core/*"],
-      "server/*": ["./src/*"],
-      "sfc/*": ["../../src/sfc/*"],
-      "shared/*": ["../../src/shared/*"],
-      "web/*": ["../../src/platforms/web/*"],
-      "v3": ["../../src/v3/index"],
-      "v3/*": ["../../src/v3/*"],
-      "types/*": ["../../src/types/*"],
-      "vue": ["../../src/platforms/web/entry-runtime-with-compiler"]
-    }
-  },
-  "include": ["../../src", "../../test/test-env.d.ts", "."]
-}
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 8324fccbebe..594e420687c 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -1,37 +1,7 @@
 {
+  "extends": "../tsconfig.json",
   "compilerOptions": {
-    "baseUrl": ".",
-    "outDir": "dist",
-    "sourceMap": true,
-    "target": "esnext",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "strict": true,
-
-    "allowJs": true,
-    "noImplicitAny": false,
-    "noImplicitThis": false,
-
-    "noUnusedLocals": true,
-    "experimentalDecorators": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "removeComments": false,
-    "jsx": "preserve",
-    "lib": ["esnext", "dom"],
-    "types": ["node", "vitest/globals"],
-    "paths": {
-      "compiler/*": ["../src/compiler/*"],
-      "core/*": ["../src/core/*"],
-      "server/*": ["../packages/server-renderer/src/*"],
-      "sfc/*": ["../src/sfc/*"],
-      "shared/*": ["../src/shared/*"],
-      "web/*": ["../src/platforms/web/*"],
-      "v3": ["../src/v3/index"],
-      "v3/*": ["../src/v3/*"],
-      "types/*": ["../src/types/*"],
-      "vue": ["../src/platforms/web/entry-runtime-with-compiler"]
-    }
+    "types": ["node", "vitest/globals"]
   },
   "include": ["../src", "."]
 }
diff --git a/tsconfig.json b/tsconfig.json
index 26361cfe407..299b45f1861 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -24,7 +24,7 @@
       "compiler/*": ["src/compiler/*"],
       "core/*": ["src/core/*"],
       "server/*": ["packages/server-renderer/src/*"],
-      "sfc/*": ["src/sfc/*"],
+      "sfc/*": ["packages/compiler-sfc/src/*"],
       "shared/*": ["src/shared/*"],
       "web/*": ["src/platforms/web/*"],
       "v3": ["src/v3/index"],
@@ -33,5 +33,5 @@
       "vue": ["src/platforms/web/entry-runtime-with-compiler"]
     }
   },
-  "include": ["src", "packages/server-renderer/src"],
+  "include": ["src", "packages/*/src"]
 }

From 09beea9ae76f6f0fb90c7b6ba2b4b67058a60107 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 21:32:13 +0800
Subject: [PATCH 118/317] chore: move sfc parser

---
 {src/sfc => packages/compiler-sfc/src}/parser.ts | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {src/sfc => packages/compiler-sfc/src}/parser.ts (100%)

diff --git a/src/sfc/parser.ts b/packages/compiler-sfc/src/parser.ts
similarity index 100%
rename from src/sfc/parser.ts
rename to packages/compiler-sfc/src/parser.ts

From 206f8a7f0949a50ae062d9d71061716ae3c3a749 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 21:55:33 +0800
Subject: [PATCH 119/317] wip: defineComponent

---
 src/types/component.ts                 |   3 +-
 src/types/options.ts                   |  12 +-
 src/v3/apiSetup.ts                     |  10 +-
 src/v3/index.ts                        |   7 +
 types/common.d.ts                      |  15 ++
 types/index.d.ts                       |  37 ++++-
 types/options.d.ts                     |  38 +----
 types/test/v3/setup-test.ts            |  50 ++++++-
 types/tsconfig.json                    |   2 +-
 types/v3-component-options.d.ts        | 120 ++++++++++++++++
 types/v3-component-props.d.ts          | 100 +++++++++++++
 types/v3-component-proxy.d.ts          | 189 +++++++++++++++++++++++++
 types/v3-define-component.d.ts         | 119 ++++++++++++++++
 types/v3-directive.ts                  |  29 ++++
 types/{v3.d.ts => v3-manual-apis.d.ts} |   8 +-
 types/v3-setup-context.d.ts            |  42 ++++++
 16 files changed, 722 insertions(+), 59 deletions(-)
 create mode 100644 types/common.d.ts
 create mode 100644 types/v3-component-options.d.ts
 create mode 100644 types/v3-component-props.d.ts
 create mode 100644 types/v3-component-proxy.d.ts
 create mode 100644 types/v3-define-component.d.ts
 create mode 100644 types/v3-directive.ts
 rename types/{v3.d.ts => v3-manual-apis.d.ts} (54%)
 create mode 100644 types/v3-setup-context.d.ts

diff --git a/src/types/component.ts b/src/types/component.ts
index 538f7c3a1c7..f28f4460870 100644
--- a/src/types/component.ts
+++ b/src/types/component.ts
@@ -1,6 +1,7 @@
 import type VNode from 'core/vdom/vnode'
 import type Watcher from 'core/observer/watcher'
-import { ComponentOptions, SetupContext } from './options'
+import { ComponentOptions } from './options'
+import { SetupContext } from 'v3/apiSetup'
 import { ScopedSlotsData, VNodeChildren, VNodeData } from './vnode'
 import { GlobalAPI } from './global-api'
 import { EffectScope } from 'v3/reactivity/effectScope'
diff --git a/src/types/options.ts b/src/types/options.ts
index 76bebd1a7fe..ee4440db96a 100644
--- a/src/types/options.ts
+++ b/src/types/options.ts
@@ -1,5 +1,6 @@
 import VNode from 'core/vdom/vnode'
-import { DebuggerEvent } from 'v3'
+import { DebuggerEvent } from 'v3/debug'
+import { SetupContext } from 'v3/apiSetup'
 import { Component } from './component'
 
 export type InternalComponentOptions = {
@@ -12,15 +13,6 @@ export type InternalComponentOptions = {
 
 type InjectKey = string | Symbol
 
-/**
- * @internal
- */
-export interface SetupContext {
-  attrs: Record<string, any>
-  slots: Record<string, () => VNode[]>
-  emit: (event: string, ...args: any[]) => any
-}
-
 /**
  * @internal
  */
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index c1abe64f4ca..92c1425fd24 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -1,11 +1,19 @@
 import { Component } from 'types/component'
-import type { SetupContext } from 'types/options'
 import { def, invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
 import { bind, emptyObject, isFunction, isObject } from '../shared/util'
 import { currentInstance, setCurrentInstance } from './currentInstance'
 import { isRef } from './reactivity/ref'
 
+/**
+ * @internal
+ */
+export interface SetupContext {
+  attrs: Record<string, any>
+  slots: Record<string, () => VNode[]>
+  emit: (event: string, ...args: any[]) => any
+}
+
 export function initSetup(vm: Component) {
   const options = vm.$options
   const setup = options.setup
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 97fdc709b24..2e6a71c5bf2 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -74,4 +74,11 @@ export { useSlots, useAttrs } from './apiSetup'
 export { nextTick } from 'core/util/next-tick'
 export { set, del } from 'core/observer'
 
+/**
+ * @internal type is manually declared in <root>/types/v3-define-component.d.ts
+ */
+export function defineComponent(options: any) {
+  return options
+}
+
 export * from './apiLifecycle'
diff --git a/types/common.d.ts b/types/common.d.ts
new file mode 100644
index 00000000000..7b69ddd6473
--- /dev/null
+++ b/types/common.d.ts
@@ -0,0 +1,15 @@
+export type Data = { [key: string]: unknown }
+
+export type UnionToIntersection<U> = (
+  U extends any ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never
+
+// Conditional returns can enforce identical types.
+// See here: https://github.com/Microsoft/TypeScript/issues/27024#issuecomment-421529650
+// prettier-ignore
+type Equal<Left, Right> =
+  (<U>() => U extends Left ? 1 : 0) extends (<U>() => U extends Right ? 1 : 0) ? true : false;
+
+export type HasDefined<T> = Equal<T, unknown> extends true ? false : true
diff --git a/types/index.d.ts b/types/index.d.ts
index eea3c51c572..b724d798e98 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -11,8 +11,8 @@ export {
   ComponentOptions,
   FunctionalComponentOptions,
   RenderContext,
-  PropType,
-  PropOptions,
+  // PropType,
+  // PropOptions,
   ComputedOptions,
   WatchHandler,
   WatchOptions,
@@ -32,5 +32,36 @@ export {
   VNodeDirective
 } from './vnode'
 
-export * from './v3'
+export * from './v3-manual-apis'
 export * from './v3-generated'
+
+export { Data } from './common'
+export { SetupContext } from './v3-setup-context'
+export { defineComponent } from './v3-define-component'
+// export { defineAsyncComponent } from './defineAsyncComponent'
+export {
+  SetupFunction,
+  // v2 already has option with same name and it's for a single computed
+  ComputedOptions as ComponentComputedOptions,
+  MethodOptions as ComponentMethodOptions,
+  ComponentPropsOptions
+} from './v3-component-options'
+export {
+  ComponentInstance,
+  ComponentPublicInstance,
+  ComponentRenderProxy
+} from './v3-component-proxy'
+export {
+  PropType,
+  PropOptions,
+  ExtractPropTypes,
+  ExtractDefaultPropTypes
+} from './v3-component-props'
+export {
+  DirectiveModifiers,
+  DirectiveBinding,
+  DirectiveHook,
+  ObjectDirective,
+  FunctionDirective,
+  Directive
+} from './v3-directive'
diff --git a/types/options.d.ts b/types/options.d.ts
index e01c1ba6d3a..8868e7cf87c 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -1,6 +1,7 @@
 import { Vue, CreateElement, CombinedVueInstance } from './vue'
 import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from './vnode'
-import { SetupContext } from './v3'
+import { SetupContext } from './v3-setup-context'
+import { DebuggerEvent } from './v3-generated'
 
 type Constructor = {
   new (...args: any[]): any
@@ -249,22 +250,10 @@ export interface RenderContext<Props = DefaultProps> {
   injections: any
 }
 
-export type Prop<T> =
-  | { (): T }
-  | { new (...args: never[]): T & object }
-  | { new (...args: string[]): Function }
-
-export type PropType<T> = Prop<T> | Prop<T>[]
+import { PropOptions, PropType } from './v3-component-props'
 
 export type PropValidator<T> = PropOptions<T> | PropType<T>
 
-export interface PropOptions<T = any> {
-  type?: PropType<T>
-  required?: boolean
-  default?: T | null | undefined | (() => T | null | undefined)
-  validator?(value: T): boolean
-}
-
 export type RecordPropsDefinition<T> = {
   [K in keyof T]: PropValidator<T[K]>
 }
@@ -316,24 +305,3 @@ export type InjectOptions =
       [key: string]: InjectKey | { from?: InjectKey; default?: any }
     }
   | string[]
-
-export type DebuggerEvent = {
-  target: object
-  type: TrackOpTypes | TriggerOpTypes
-  key?: any
-  newValue?: any
-  oldValue?: any
-  oldTarget?: Map<any, any> | Set<any>
-}
-
-export const enum TrackOpTypes {
-  GET = 'get',
-  TOUCH = 'touch'
-}
-
-export const enum TriggerOpTypes {
-  SET = 'set',
-  ADD = 'add',
-  DELETE = 'delete',
-  ARRAY_MUTATION = 'array mutation'
-}
diff --git a/types/test/v3/setup-test.ts b/types/test/v3/setup-test.ts
index d09fdf278c2..8ad8eefe40c 100644
--- a/types/test/v3/setup-test.ts
+++ b/types/test/v3/setup-test.ts
@@ -1,4 +1,4 @@
-import Vue from '../../index'
+import Vue, { defineComponent } from '../../index'
 
 // object props
 Vue.extend({
@@ -30,3 +30,51 @@ Vue.extend({
     ctx.slots.default && ctx.slots.default()
   }
 })
+
+// object props
+defineComponent({
+  props: {
+    foo: String,
+    bar: Number
+  },
+  setup(props) {
+    // @ts-expect-error
+    props.foo.slice(1, 2)
+
+    props.foo?.slice(1, 2)
+
+    // @ts-expect-error
+    props.bar + 123
+
+    props.bar?.toFixed(2)
+  }
+})
+
+// array props
+defineComponent({
+  props: ['foo', 'bar'],
+  setup(props) {
+    props.foo
+    props.bar
+  }
+})
+
+// context
+defineComponent({
+  emits: ['foo'],
+  setup(_props, ctx) {
+    if (ctx.attrs.id) {
+    }
+    ctx.emit('foo')
+    // @ts-expect-error
+    ctx.emit('ok')
+    ctx.slots.default && ctx.slots.default()
+  },
+  methods: {
+    foo() {
+      this.$emit('foo')
+      // @ts-expect-error
+      this.$emit('bar')
+    }
+  }
+})
diff --git a/types/tsconfig.json b/types/tsconfig.json
index 55df2897175..d8c4327e7f9 100644
--- a/types/tsconfig.json
+++ b/types/tsconfig.json
@@ -12,6 +12,6 @@
       "vue": ["../index.d.ts"]
     }
   },
-  "include": ["./*.d.ts", "*.ts"],
+  "include": ["."],
   "compileOnSave": false
 }
diff --git a/types/v3-component-options.d.ts b/types/v3-component-options.d.ts
new file mode 100644
index 00000000000..d6e63ed87a0
--- /dev/null
+++ b/types/v3-component-options.d.ts
@@ -0,0 +1,120 @@
+import { Vue } from './vue'
+import { VNode } from './vnode'
+import { ComponentOptions as Vue2ComponentOptions } from './options'
+import { EmitsOptions, SetupContext } from './v3-setup-context'
+import { Data } from './common'
+import { ComponentPropsOptions, ExtractPropTypes } from './v3-component-props'
+import { ComponentRenderProxy } from './v3-component-proxy'
+export { ComponentPropsOptions } from './v3-component-props'
+
+export type ComputedGetter<T> = (ctx?: any) => T
+export type ComputedSetter<T> = (v: T) => void
+
+export interface WritableComputedOptions<T> {
+  get: ComputedGetter<T>
+  set: ComputedSetter<T>
+}
+
+export type ComputedOptions = Record<
+  string,
+  ComputedGetter<any> | WritableComputedOptions<any>
+>
+
+export interface MethodOptions {
+  [key: string]: Function
+}
+
+export type SetupFunction<
+  Props,
+  RawBindings = {},
+  Emits extends EmitsOptions = {}
+> = (
+  this: void,
+  props: Readonly<Props>,
+  ctx: SetupContext<Emits>
+) => RawBindings | (() => VNode | null) | void
+
+interface ComponentOptionsBase<
+  Props,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {}
+> extends Omit<
+    Vue2ComponentOptions<Vue, D, M, C, Props>,
+    'data' | 'computed' | 'method' | 'setup' | 'props'
+  > {
+  // allow any custom options
+  [key: string]: any
+
+  // rewrite options api types
+  data?: (this: Props & Vue, vm: Props) => D
+  computed?: C
+  methods?: M
+}
+
+export type ExtractComputedReturns<T extends any> = {
+  [key in keyof T]: T[key] extends { get: (...args: any[]) => infer TReturn }
+    ? TReturn
+    : T[key] extends (...args: any[]) => infer TReturn
+    ? TReturn
+    : never
+}
+
+export type ComponentOptionsWithProps<
+  PropsOptions = ComponentPropsOptions,
+  RawBindings = Data,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  EmitsNames extends string = string,
+  Props = ExtractPropTypes<PropsOptions>
+> = ComponentOptionsBase<Props, D, C, M> & {
+  props?: PropsOptions
+  emits?: (Emits | EmitsNames[]) & ThisType<void>
+  setup?: SetupFunction<Props, RawBindings, Emits>
+} & ThisType<
+    ComponentRenderProxy<Props, RawBindings, D, C, M, Mixin, Extends, Emits>
+  >
+
+export type ComponentOptionsWithArrayProps<
+  PropNames extends string = string,
+  RawBindings = Data,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  EmitsNames extends string = string,
+  Props = Readonly<{ [key in PropNames]?: any }>
+> = ComponentOptionsBase<Props, D, C, M> & {
+  props?: PropNames[]
+  emits?: (Emits | EmitsNames[]) & ThisType<void>
+  setup?: SetupFunction<Props, RawBindings, Emits>
+} & ThisType<
+    ComponentRenderProxy<Props, RawBindings, D, C, M, Mixin, Extends, Emits>
+  >
+
+export type ComponentOptionsWithoutProps<
+  Props = {},
+  RawBindings = Data,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  EmitsNames extends string = string
+> = ComponentOptionsBase<Props, D, C, M> & {
+  props?: undefined
+  emits?: (Emits | EmitsNames[]) & ThisType<void>
+  setup?: SetupFunction<Props, RawBindings, Emits>
+} & ThisType<
+    ComponentRenderProxy<Props, RawBindings, D, C, M, Mixin, Extends, Emits>
+  >
+
+export type WithLegacyAPI<T, D, C, M, Props> = T &
+  Omit<Vue2ComponentOptions<Vue, D, M, C, Props>, keyof T>
diff --git a/types/v3-component-props.d.ts b/types/v3-component-props.d.ts
new file mode 100644
index 00000000000..7abf0d4b8da
--- /dev/null
+++ b/types/v3-component-props.d.ts
@@ -0,0 +1,100 @@
+import { Data } from './common'
+
+export type ComponentPropsOptions<P = Data> =
+  | ComponentObjectPropsOptions<P>
+  | string[]
+
+export type ComponentObjectPropsOptions<P = Data> = {
+  [K in keyof P]: Prop<P[K]> | null
+}
+
+export type Prop<T, D = T> = PropOptions<T, D> | PropType<T>
+
+type DefaultFactory<T> = () => T | null | undefined
+
+export interface PropOptions<T = any, D = T> {
+  type?: PropType<T> | true | null
+  required?: boolean
+  default?: D | DefaultFactory<D> | null | undefined | object
+  validator?(value: unknown): boolean
+}
+
+export type PropType<T> = PropConstructor<T> | PropConstructor<T>[]
+
+type PropConstructor<T> =
+  | { new (...args: any[]): T & object }
+  | { (): T }
+  | { new (...args: string[]): Function }
+
+type RequiredKeys<T> = {
+  [K in keyof T]: T[K] extends
+    | { required: true }
+    | { default: any }
+    | BooleanConstructor
+    | { type: BooleanConstructor }
+    ? K
+    : never
+}[keyof T]
+
+type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>
+
+type ExtractFunctionPropType<
+  T extends Function,
+  TArgs extends Array<any> = any[],
+  TResult = any
+> = T extends (...args: TArgs) => TResult ? T : never
+
+type ExtractCorrectPropType<T> = T extends Function
+  ? ExtractFunctionPropType<T>
+  : Exclude<T, Function>
+
+// prettier-ignore
+type InferPropType<T> = T extends null
+  ? any // null & true would fail to infer
+  : T extends { type: null | true }
+    ? any // As TS issue https://github.com/Microsoft/TypeScript/issues/14829 // somehow `ObjectConstructor` when inferred from { (): T } becomes `any` // `BooleanConstructor` when inferred from PropConstructor(with PropMethod) becomes `Boolean`
+    : T extends ObjectConstructor | { type: ObjectConstructor }
+      ? Record<string, any>
+      : T extends BooleanConstructor | { type: BooleanConstructor }
+        ? boolean
+          : T extends DateConstructor | { type: DateConstructor}
+            ? Date
+              : T extends FunctionConstructor
+                ? Function
+                : T extends Prop<infer V, infer D>
+                  ? unknown extends V
+                    ? D extends null | undefined
+                      ? V
+                      : D
+                    : ExtractCorrectPropType<V>
+                  : T
+
+export type ExtractPropTypes<O> = {
+  // use `keyof Pick<O, RequiredKeys<O>>` instead of `RequiredKeys<O>` to support IDE features
+  [K in keyof Pick<O, RequiredKeys<O>>]: InferPropType<O[K]>
+} & {
+  // use `keyof Pick<O, OptionalKeys<O>>` instead of `OptionalKeys<O>` to support IDE features
+  [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>
+}
+
+type DefaultKeys<T> = {
+  [K in keyof T]: T[K] extends
+    | {
+        default: any
+      }
+    | BooleanConstructor
+    | { type: BooleanConstructor }
+    ? T[K] extends {
+        type: BooleanConstructor
+        required: true
+      }
+      ? never
+      : K
+    : never
+}[keyof T]
+
+// extract props which defined with default from prop options
+export type ExtractDefaultPropTypes<O> = O extends object
+  ? // use `keyof Pick<O, DefaultKeys<O>>` instead of `DefaultKeys<O>` to support IDE features
+    { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> }
+  : {}
diff --git a/types/v3-component-proxy.d.ts b/types/v3-component-proxy.d.ts
new file mode 100644
index 00000000000..d1f73452edf
--- /dev/null
+++ b/types/v3-component-proxy.d.ts
@@ -0,0 +1,189 @@
+import { ExtractDefaultPropTypes, ExtractPropTypes } from './v3-component-props'
+import {
+  nextTick,
+  ShallowUnwrapRef,
+  UnwrapNestedRefs,
+  WatchOptions,
+  WatchStopHandle
+} from './v3-generated'
+import { Data } from './common'
+
+import { Vue, VueConstructor } from './vue'
+import { ComponentOptions as Vue2ComponentOptions } from './options'
+import {
+  ComputedOptions,
+  MethodOptions,
+  ExtractComputedReturns
+} from './v3-component-options'
+import {
+  ComponentRenderEmitFn,
+  EmitFn,
+  EmitsOptions,
+  ObjectEmitsOptions,
+  Slots
+} from './v3-setup-context'
+
+type EmitsToProps<T extends EmitsOptions> = T extends string[]
+  ? {
+      [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any
+    }
+  : T extends ObjectEmitsOptions
+  ? {
+      [K in string &
+        `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}`
+        ? T[Uncapitalize<C>] extends null
+          ? (...args: any[]) => any
+          : (
+              ...args: T[Uncapitalize<C>] extends (...args: infer P) => any
+                ? P
+                : never
+            ) => any
+        : never
+    }
+  : {}
+
+export type ComponentInstance = InstanceType<VueConstructor>
+
+// public properties exposed on the proxy, which is used as the render context
+// in templates (as `this` in the render option)
+export type ComponentRenderProxy<
+  P = {}, // props type extracted from props option
+  B = {}, // raw bindings returned from setup()
+  D = {}, // return from data()
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  PublicProps = P,
+  Defaults = {},
+  MakeDefaultsOptional extends boolean = false
+> = {
+  $data: D
+  $props: Readonly<
+    MakeDefaultsOptional extends true
+      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
+      : P & PublicProps
+  >
+  $attrs: Record<string, string>
+  $emit: ComponentRenderEmitFn<
+    Emits,
+    keyof Emits,
+    ComponentRenderProxy<
+      P,
+      B,
+      D,
+      C,
+      M,
+      Mixin,
+      Extends,
+      Emits,
+      PublicProps,
+      Defaults,
+      MakeDefaultsOptional
+    >
+  >
+} & Readonly<P> &
+  ShallowUnwrapRef<B> &
+  D &
+  M &
+  ExtractComputedReturns<C> &
+  Omit<Vue, '$data' | '$props' | '$attrs' | '$emit'>
+
+// for Vetur and TSX support
+type VueConstructorProxy<
+  PropsOptions,
+  RawBindings,
+  Data,
+  Computed extends ComputedOptions,
+  Methods extends MethodOptions,
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  Props = ExtractPropTypes<PropsOptions> &
+    ({} extends Emits ? {} : EmitsToProps<Emits>)
+> = Omit<VueConstructor, never> & {
+  new (...args: any[]): ComponentRenderProxy<
+    Props,
+    ShallowUnwrapRef<RawBindings>,
+    Data,
+    Computed,
+    Methods,
+    Mixin,
+    Extends,
+    Emits,
+    Props,
+    ExtractDefaultPropTypes<PropsOptions>,
+    true
+  >
+}
+
+type DefaultData<V> = object | ((this: V) => object)
+type DefaultMethods<V> = { [key: string]: (this: V, ...args: any[]) => any }
+type DefaultComputed = { [key: string]: any }
+
+export type VueProxy<
+  PropsOptions,
+  RawBindings,
+  Data = DefaultData<Vue>,
+  Computed extends ComputedOptions = DefaultComputed,
+  Methods extends MethodOptions = DefaultMethods<Vue>,
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {}
+> = Vue2ComponentOptions<
+  Vue,
+  ShallowUnwrapRef<RawBindings> & Data,
+  Methods,
+  Computed,
+  PropsOptions,
+  ExtractPropTypes<PropsOptions>
+> &
+  VueConstructorProxy<
+    PropsOptions,
+    RawBindings,
+    Data,
+    Computed,
+    Methods,
+    Mixin,
+    Extends,
+    Emits
+  >
+
+// public properties exposed on the proxy, which is used as the render context
+// in templates (as `this` in the render option)
+export type ComponentPublicInstance<
+  P = {}, // props type extracted from props option
+  B = {}, // raw bindings returned from setup()
+  D = {}, // return from data()
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  E extends EmitsOptions = {},
+  PublicProps = P,
+  Defaults = {},
+  MakeDefaultsOptional extends boolean = false
+> = {
+  $data: D
+  $props: MakeDefaultsOptional extends true
+    ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
+    : P & PublicProps
+  $attrs: Data
+  $refs: Data
+  $slots: Slots
+  $root: ComponentPublicInstance | null
+  $parent: ComponentPublicInstance | null
+  $emit: EmitFn<E>
+  $el: any
+  // $options: Options & MergedComponentOptionsOverride
+  $forceUpdate: () => void
+  $nextTick: typeof nextTick
+  $watch(
+    source: string | Function,
+    cb: Function,
+    options?: WatchOptions
+  ): WatchStopHandle
+} & P &
+  ShallowUnwrapRef<B> &
+  UnwrapNestedRefs<D> &
+  ExtractComputedReturns<C> &
+  M
diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
new file mode 100644
index 00000000000..8d3a47805cf
--- /dev/null
+++ b/types/v3-define-component.d.ts
@@ -0,0 +1,119 @@
+import { ComponentPropsOptions } from './v3-component-props'
+import {
+  MethodOptions,
+  ComputedOptions,
+  ComponentOptionsWithoutProps,
+  ComponentOptionsWithArrayProps,
+  ComponentOptionsWithProps
+} from './v3-component-options'
+import { VueProxy } from './v3-component-proxy'
+import { Data, HasDefined } from './common'
+import { EmitsOptions } from './v3-setup-context'
+
+/**
+ * overload 1: object format with no props
+ */
+export function defineComponent<
+  RawBindings,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  EmitsNames extends string = string
+>(
+  options: ComponentOptionsWithoutProps<
+    {},
+    RawBindings,
+    D,
+    C,
+    M,
+    Mixin,
+    Extends,
+    Emits,
+    EmitsNames
+  >
+): VueProxy<{}, RawBindings, D, C, M, Mixin, Extends, Emits>
+/**
+ * overload 2: object format with array props declaration
+ * props inferred as `{ [key in PropNames]?: any }`
+ *
+ * return type is for Vetur and TSX support
+ */
+export function defineComponent<
+  PropNames extends string,
+  RawBindings = Data,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  EmitsNames extends string = string,
+  PropsOptions extends ComponentPropsOptions = ComponentPropsOptions
+>(
+  options: ComponentOptionsWithArrayProps<
+    PropNames,
+    RawBindings,
+    D,
+    C,
+    M,
+    Mixin,
+    Extends,
+    Emits,
+    EmitsNames
+  >
+): VueProxy<
+  Readonly<{ [key in PropNames]?: any }>,
+  RawBindings,
+  D,
+  C,
+  M,
+  Mixin,
+  Extends,
+  Emits
+>
+
+/**
+ * overload 3: object format with object props declaration
+ *
+ * see `ExtractPropTypes` in './componentProps.ts'
+ */
+export function defineComponent<
+  Props,
+  RawBindings = Data,
+  D = Data,
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin = {},
+  Extends = {},
+  Emits extends EmitsOptions = {},
+  EmitsNames extends string = string,
+  PropsOptions extends ComponentPropsOptions = ComponentPropsOptions
+>(
+  options: HasDefined<Props> extends true
+    ? ComponentOptionsWithProps<
+        PropsOptions,
+        RawBindings,
+        D,
+        C,
+        M,
+        Mixin,
+        Extends,
+        Emits,
+        EmitsNames,
+        Props
+      >
+    : ComponentOptionsWithProps<
+        PropsOptions,
+        RawBindings,
+        D,
+        C,
+        M,
+        Mixin,
+        Extends,
+        Emits,
+        EmitsNames
+      >
+): VueProxy<PropsOptions, RawBindings, D, C, M, Mixin, Extends, Emits>
diff --git a/types/v3-directive.ts b/types/v3-directive.ts
new file mode 100644
index 00000000000..f6b091f80e9
--- /dev/null
+++ b/types/v3-directive.ts
@@ -0,0 +1,29 @@
+import type { VNodeDirective, VNode } from './vnode'
+
+export type DirectiveModifiers = Record<string, boolean>
+
+export interface DirectiveBinding<V> extends Readonly<VNodeDirective> {
+  readonly modifiers: DirectiveModifiers
+  readonly value: V
+  readonly oldValue: V | null
+}
+
+export type DirectiveHook<T = any, Prev = VNode | null, V = any> = (
+  el: T,
+  binding: DirectiveBinding<V>,
+  vnode: VNode,
+  prevVNode: Prev
+) => void
+
+export interface ObjectDirective<T = any, V = any> {
+  bind?: DirectiveHook<T, any, V>
+  inserted?: DirectiveHook<T, any, V>
+  update?: DirectiveHook<T, any, V>
+  componentUpdated?: DirectiveHook<T, any, V>
+  unbind?: DirectiveHook<T, any, V>
+}
+export type FunctionDirective<T = any, V = any> = DirectiveHook<T, any, V>
+
+export type Directive<T = any, V = any> =
+  | ObjectDirective<T, V>
+  | FunctionDirective<T, V>
diff --git a/types/v3.d.ts b/types/v3-manual-apis.d.ts
similarity index 54%
rename from types/v3.d.ts
rename to types/v3-manual-apis.d.ts
index 464edd7f45a..901494d624d 100644
--- a/types/v3.d.ts
+++ b/types/v3-manual-apis.d.ts
@@ -1,12 +1,6 @@
-import { VNode } from './vnode'
+import { SetupContext } from './v3-setup-context'
 import { CreateElement, Vue } from './vue'
 
-export interface SetupContext {
-  attrs: Record<string, any>
-  slots: Record<string, (() => VNode[]) | undefined>
-  emit: (event: string, ...args: any[]) => any
-}
-
 export function getCurrentInstance(): { proxy: Vue } | null
 
 export const h: CreateElement
diff --git a/types/v3-setup-context.d.ts b/types/v3-setup-context.d.ts
new file mode 100644
index 00000000000..43c412e67c6
--- /dev/null
+++ b/types/v3-setup-context.d.ts
@@ -0,0 +1,42 @@
+import { VNode } from './vnode'
+import { Data, UnionToIntersection } from './common'
+import { Vue } from './vue'
+
+export type Slot = (...args: any[]) => VNode[]
+
+export type Slots = Record<string, Slot | undefined>
+
+export type ObjectEmitsOptions = Record<
+  string,
+  ((...args: any[]) => any) | null
+>
+
+export type EmitsOptions = ObjectEmitsOptions | string[]
+
+export type EmitFn<
+  Options = ObjectEmitsOptions,
+  Event extends keyof Options = keyof Options,
+  ReturnType extends void | Vue = void
+> = Options extends Array<infer V>
+  ? (event: V, ...args: any[]) => ReturnType
+  : {} extends Options // if the emit is empty object (usually the default value for emit) should be converted to function
+  ? (event: string, ...args: any[]) => ReturnType
+  : UnionToIntersection<
+      {
+        [key in Event]: Options[key] extends (...args: infer Args) => any
+          ? (event: key, ...args: Args) => ReturnType
+          : (event: key, ...args: any[]) => ReturnType
+      }[Event]
+    >
+
+export type ComponentRenderEmitFn<
+  Options = ObjectEmitsOptions,
+  Event extends keyof Options = keyof Options,
+  T extends Vue | void = void
+> = EmitFn<Options, Event, T>
+
+export interface SetupContext<E extends EmitsOptions = {}> {
+  attrs: Data
+  slots: Slots
+  emit: EmitFn<E>
+}

From ffaf81ba5f5d0cecb9eaa0b661685a13a20d0627 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 22:12:02 +0800
Subject: [PATCH 120/317] chore: fix type tests

---
 packages/server-renderer/package.json         |  5 ++-
 .../server-renderer/types/test.ts             | 13 +++---
 packages/server-renderer/types/tsconfig.json  |  1 +
 pnpm-lock.yaml                                | 44 ++++++++++++++++++-
 types/index.d.ts                              |  8 ++--
 types/options.d.ts                            | 14 +++++-
 types/test/v3/setup-test.ts                   | 17 ++++++-
 types/v3-component-props.d.ts                 |  2 +-
 8 files changed, 85 insertions(+), 19 deletions(-)
 rename types/test/ssr-test.ts => packages/server-renderer/types/test.ts (87%)

diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index a7534185aa6..fffcc771460 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -34,10 +34,11 @@
     "source-map": "0.5.6"
   },
   "devDependencies": {
+    "@types/webpack": "^4.41.32",
+    "file-loader": "^3.0.1",
     "memory-fs": "^0.5.0",
     "vue": "file:../..",
-    "webpack": "^4.46.0",
-    "file-loader": "^3.0.1"
+    "webpack": "^4.46.0"
   },
   "homepage": "https://github.com/vuejs/vue/tree/dev/packages/vue-server-renderer#readme"
 }
diff --git a/types/test/ssr-test.ts b/packages/server-renderer/types/test.ts
similarity index 87%
rename from types/test/ssr-test.ts
rename to packages/server-renderer/types/test.ts
index 37652b3324f..7a353066eda 100644
--- a/types/test/ssr-test.ts
+++ b/packages/server-renderer/types/test.ts
@@ -1,12 +1,9 @@
-import Vue, { VNode, VNodeDirective } from '../index'
-import VueSSRClientPlugin = require('../../packages/vue-server-renderer/client-plugin')
-import VueSSRServerPlugin = require('../../packages/vue-server-renderer/server-plugin')
-import webpack = require('webpack')
+import Vue, { VNode, VNodeDirective } from '../../../types/index'
+import VueSSRClientPlugin from '../client-plugin'
+import VueSSRServerPlugin from '../server-plugin'
+import webpack from 'webpack'
 import { readFileSync } from 'fs'
-import {
-  createRenderer,
-  createBundleRenderer
-} from '../../packages/vue-server-renderer'
+import { createRenderer, createBundleRenderer } from '.'
 
 function createApp(context: any) {
   return new Vue({
diff --git a/packages/server-renderer/types/tsconfig.json b/packages/server-renderer/types/tsconfig.json
index 5e89be1ef9d..465615893cd 100644
--- a/packages/server-renderer/types/tsconfig.json
+++ b/packages/server-renderer/types/tsconfig.json
@@ -5,6 +5,7 @@
     "moduleResolution": "node",
     "strict": true,
     "noEmit": true,
+    "allowSyntheticDefaultImports": true,
     "paths": {
       "vue": ["../../../types/index.d.ts"]
     }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fe5925c21e5..470c95c6d4d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -128,6 +128,7 @@ importers:
 
   packages/server-renderer:
     specifiers:
+      '@types/webpack': ^4.41.32
       chalk: ^4.0.0
       file-loader: ^3.0.1
       hash-sum: ^2.0.0
@@ -150,6 +151,7 @@ importers:
       serialize-javascript: 6.0.0
       source-map: 0.5.6
     devDependencies:
+      '@types/webpack': 4.41.32
       file-loader: 3.0.1_webpack@4.46.0
       memory-fs: 0.5.0
       vue: 'file:'
@@ -492,6 +494,39 @@ packages:
       '@types/node': 17.0.36
     dev: true
 
+  /@types/source-list-map/0.1.2:
+    resolution: {integrity: sha512-K5K+yml8LTo9bWJI/rECfIPrGgxdpeNbj+d53lwN4QjW1MCwlkhUms+gtdzigTeUyBr09+u8BwOIY3MXvHdcsA==}
+    dev: true
+
+  /@types/tapable/1.0.8:
+    resolution: {integrity: sha512-ipixuVrh2OdNmauvtT51o3d8z12p6LtFW9in7U79der/kwejjdNchQC5UMn5u/KxNoM7VHHOs/l8KS8uHxhODQ==}
+    dev: true
+
+  /@types/uglify-js/3.13.2:
+    resolution: {integrity: sha512-/xFrPIo+4zOeNGtVMbf9rUm0N+i4pDf1ynExomqtokIJmVzR3962lJ1UE+MmexMkA0cmN9oTzg5Xcbwge0Ij2Q==}
+    dependencies:
+      source-map: 0.6.1
+    dev: true
+
+  /@types/webpack-sources/3.2.0:
+    resolution: {integrity: sha512-Ft7YH3lEVRQ6ls8k4Ff1oB4jN6oy/XmU6tQISKdhfh+1mR+viZFphS6WL0IrtDOzvefmJg5a0s7ZQoRXwqTEFg==}
+    dependencies:
+      '@types/node': 17.0.36
+      '@types/source-list-map': 0.1.2
+      source-map: 0.7.3
+    dev: true
+
+  /@types/webpack/4.41.32:
+    resolution: {integrity: sha512-cb+0ioil/7oz5//7tZUSwbrSAN/NWHrQylz5cW8G0dWTcF/g+/dSdMlKVZspBYuMAN1+WnwHrkxiRrLcwd0Heg==}
+    dependencies:
+      '@types/node': 17.0.36
+      '@types/tapable': 1.0.8
+      '@types/uglify-js': 3.13.2
+      '@types/webpack-sources': 3.2.0
+      anymatch: 3.1.2
+      source-map: 0.6.1
+    dev: true
+
   /@types/yauzl/2.10.0:
     resolution: {integrity: sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==}
     requiresBuild: true
@@ -4083,7 +4118,7 @@ packages:
     dev: true
 
   /normalize-path/2.1.1:
-    resolution: {integrity: sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=}
+    resolution: {integrity: sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w==}
     engines: {node: '>=0.10.0'}
     dependencies:
       remove-trailing-separator: 1.1.0
@@ -5300,6 +5335,11 @@ packages:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
+  /source-map/0.7.3:
+    resolution: {integrity: sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==}
+    engines: {node: '>= 8'}
+    dev: true
+
   /sourcemap-codec/1.4.8:
     resolution: {integrity: sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==}
     dev: true
@@ -6375,7 +6415,7 @@ packages:
   'file:':
     resolution: {directory: '', type: directory}
     name: vue
-    version: 2.6.14
+    version: 2.7.0-alpha.3
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
     dev: true
diff --git a/types/index.d.ts b/types/index.d.ts
index b724d798e98..2e2bfdd052c 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -11,8 +11,8 @@ export {
   ComponentOptions,
   FunctionalComponentOptions,
   RenderContext,
-  // PropType,
-  // PropOptions,
+  PropType,
+  PropOptions,
   ComputedOptions,
   WatchHandler,
   WatchOptions,
@@ -52,8 +52,8 @@ export {
   ComponentRenderProxy
 } from './v3-component-proxy'
 export {
-  PropType,
-  PropOptions,
+  // PropType,
+  // PropOptions,
   ExtractPropTypes,
   ExtractDefaultPropTypes
 } from './v3-component-props'
diff --git a/types/options.d.ts b/types/options.d.ts
index 8868e7cf87c..80ab87ad0fa 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -250,10 +250,22 @@ export interface RenderContext<Props = DefaultProps> {
   injections: any
 }
 
-import { PropOptions, PropType } from './v3-component-props'
+export type Prop<T> =
+  | { (): T }
+  | { new (...args: never[]): T & object }
+  | { new (...args: string[]): Function }
+
+export type PropType<T> = Prop<T> | Prop<T>[]
 
 export type PropValidator<T> = PropOptions<T> | PropType<T>
 
+export interface PropOptions<T = any> {
+  type?: PropType<T>
+  required?: boolean
+  default?: T | null | undefined | (() => T | null | undefined)
+  validator?(value: unknown): boolean
+}
+
 export type RecordPropsDefinition<T> = {
   [K in keyof T]: PropValidator<T[K]>
 }
diff --git a/types/test/v3/setup-test.ts b/types/test/v3/setup-test.ts
index 8ad8eefe40c..15572f736e9 100644
--- a/types/test/v3/setup-test.ts
+++ b/types/test/v3/setup-test.ts
@@ -1,4 +1,4 @@
-import Vue, { defineComponent } from '../../index'
+import Vue, { defineComponent, PropType } from '../../index'
 
 // object props
 Vue.extend({
@@ -78,3 +78,18 @@ defineComponent({
     }
   }
 })
+
+defineComponent({
+  props: {
+    foo: null as any as PropType<{ a: number }>
+  },
+  data() {
+    this.foo?.a
+  },
+  setup(props) {
+    const res = props.foo?.a.toFixed(2)
+    // @ts-expect-error
+    res.charAt(1)
+    res?.charAt(1)
+  }
+})
diff --git a/types/v3-component-props.d.ts b/types/v3-component-props.d.ts
index 7abf0d4b8da..f4d0a787023 100644
--- a/types/v3-component-props.d.ts
+++ b/types/v3-component-props.d.ts
@@ -22,8 +22,8 @@ export interface PropOptions<T = any, D = T> {
 export type PropType<T> = PropConstructor<T> | PropConstructor<T>[]
 
 type PropConstructor<T> =
-  | { new (...args: any[]): T & object }
   | { (): T }
+  | { new (...args: never[]): T & object }
   | { new (...args: string[]): Function }
 
 type RequiredKeys<T> = {

From a00c63beb4a9acb0495729e9aa148c5d08d30a37 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 22:15:27 +0800
Subject: [PATCH 121/317] chore: fix test alias

---
 vitest.config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vitest.config.ts b/vitest.config.ts
index e021d886f01..fba8a8589f2 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -9,7 +9,7 @@ export default defineConfig({
       compiler: resolve('src/compiler'),
       core: resolve('src/core'),
       server: resolve('packages/server-renderer/src'),
-      sfc: resolve('src/sfc'),
+      sfc: resolve('packages/compiler-sfc/src'),
       shared: resolve('src/shared'),
       web: resolve('src/platforms/web'),
       v3: resolve('src/v3'),

From c319cc7a74a790414c33db74ad9f1070851de76b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 22:18:05 +0800
Subject: [PATCH 122/317] fix: guard against non-object provide value

---
 src/core/instance/inject.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index ea354ca9401..4c18909de8f 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,4 +1,4 @@
-import { warn, hasSymbol, isFunction } from '../util/index'
+import { warn, hasSymbol, isFunction, isObject } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
 import type { Component } from 'types/component'
 import { provide } from 'v3/apiInject'
@@ -10,6 +10,9 @@ export function initProvide(vm: Component) {
     const provided = isFunction(provideOption)
       ? provideOption.call(vm)
       : provideOption
+    if (!isObject(provided)) {
+      return
+    }
     const keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided)
     setCurrentInstance(vm)
     for (let i = 0; i < keys.length; i++) {

From 4dc0c6c4db6ccad28c414f165412b8e744a525bb Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 22:19:32 +0800
Subject: [PATCH 123/317] release: v2.7.0-alpha.4

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e0df66fb1e..44775fab39d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-alpha.4](https://github.com/vuejs/vue/compare/v2.7.0-alpha.3...v2.7.0-alpha.4) (2022-06-01)
+
+
+### Bug Fixes
+
+* guard against non-object provide value ([c319cc7](https://github.com/vuejs/vue/commit/c319cc7a74a790414c33db74ad9f1070851de76b))
+
+
+
 # [2.7.0-alpha.3](https://github.com/vuejs/vue/compare/v2.7.0-alpha.2...v2.7.0-alpha.3) (2022-06-01)
 
 
diff --git a/package.json b/package.json
index 84043ab9378..1fe6a75d434 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.3",
+  "version": "2.7.0-alpha.4",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 6cef8a85fda..14be6da3a96 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.3",
+  "version": "2.7.0-alpha.4",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index fffcc771460..01d610ff56d 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.3",
+  "version": "2.7.0-alpha.4",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index cc275b3cd56..8280bfe6b85 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.3",
+  "version": "2.7.0-alpha.4",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 8be5a871d4f9dfc5c8f2c6014a158e8b9efc5bc8 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 1 Jun 2022 22:26:15 +0800
Subject: [PATCH 124/317] chore: changelog [ci skip]

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44775fab39d..a19480694b0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,9 @@
 
 * guard against non-object provide value ([c319cc7](https://github.com/vuejs/vue/commit/c319cc7a74a790414c33db74ad9f1070851de76b))
 
+### Features
 
+* `defineComponent` [206f8a7f](https://github.com/vuejs/vue/commit/206f8a7f0949a50ae062d9d71061716ae3c3a749)
 
 # [2.7.0-alpha.3](https://github.com/vuejs/vue/compare/v2.7.0-alpha.2...v2.7.0-alpha.3) (2022-06-01)
 

From 642e7aa03b1f6ca5e8ba6f7c7d702b6401b3ca9e Mon Sep 17 00:00:00 2001
From: Haoqun Jiang <haoqunjiang@gmail.com>
Date: Mon, 6 Jun 2022 10:51:18 +0800
Subject: [PATCH 125/317] chore: exclude trivial refactors from `git blame`
 results (#12550)

See https://docs.github.com/en/repositories/working-with-files/using-files/viewing-a-file#ignore-commits-in-the-blame-view

Ideally all style-only-commits should be put into this list.

The "move to typescript" is not trivial by itself, but most of the
additions / deletions are style changes. So I think it's safe and more
reader-friendly to exclude it.
---
 .git-blame-ignore-revs | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 .git-blame-ignore-revs

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 00000000000..53dbf616c0a
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,4 @@
+# chore: move to typescript
+af9fc2bcff31d5baa413039818a9b3e011deccaf
+# workflow: remove eslint, apply prettier
+72aed6a149b94b5b929fb47370a7a6d4cb7491c5

From 4f2a04e6a8e1fc71080eed49fd4059d6a53afc1c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 6 Jun 2022 15:25:29 +0800
Subject: [PATCH 126/317] fix: fix scopedSlots regression

---
 src/core/instance/render.ts                   |  3 +-
 .../vdom/helpers/normalize-scoped-slots.ts    | 41 +++++++++++--------
 .../features/component/component-slot.spec.ts | 29 +++++++++++++
 3 files changed, 54 insertions(+), 19 deletions(-)

diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index 54bc07d9cea..e7ad14f0d73 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -102,7 +102,8 @@ export function renderMixin(Vue: typeof Component) {
       vm.$scopedSlots = normalizeScopedSlots(
         vm.$parent!,
         _parentVnode.data!.scopedSlots,
-        vm.$slots
+        vm.$slots,
+        vm.$scopedSlots
       )
       if (vm._slotsProxy) {
         syncSetupSlots(vm._slotsProxy, vm.$scopedSlots)
diff --git a/src/core/vdom/helpers/normalize-scoped-slots.ts b/src/core/vdom/helpers/normalize-scoped-slots.ts
index 388b5d5024a..10a0d1186e1 100644
--- a/src/core/vdom/helpers/normalize-scoped-slots.ts
+++ b/src/core/vdom/helpers/normalize-scoped-slots.ts
@@ -8,35 +8,40 @@ import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
 
 export function normalizeScopedSlots(
   ownerVm: Component,
-  slots: { [key: string]: Function } | void,
-  normalSlots: { [key: string]: VNode[] }
+  scopedSlots: { [key: string]: Function } | undefined,
+  normalSlots: { [key: string]: VNode[] },
+  prevScopedSlots?: { [key: string]: Function }
 ): any {
   let res
-  const prevSlots = ownerVm.$scopedSlots
   const hasNormalSlots = Object.keys(normalSlots).length > 0
-  const isStable = slots ? !!slots.$stable : !hasNormalSlots
-  const key = slots && slots.$key
-  if (!slots) {
+  const isStable = scopedSlots ? !!scopedSlots.$stable : !hasNormalSlots
+  const key = scopedSlots && scopedSlots.$key
+  if (!scopedSlots) {
     res = {}
-  } else if (slots._normalized) {
+  } else if (scopedSlots._normalized) {
     // fast path 1: child component re-render only, parent did not change
-    return slots._normalized
+    return scopedSlots._normalized
   } else if (
     isStable &&
-    prevSlots &&
-    prevSlots !== emptyObject &&
-    key === prevSlots.$key &&
+    prevScopedSlots &&
+    prevScopedSlots !== emptyObject &&
+    key === prevScopedSlots.$key &&
     !hasNormalSlots &&
-    !prevSlots.$hasNormal
+    !prevScopedSlots.$hasNormal
   ) {
     // fast path 2: stable scoped slots w/ no normal slots to proxy,
     // only need to normalize once
-    return prevSlots
+    return prevScopedSlots
   } else {
     res = {}
-    for (const key in slots) {
-      if (slots[key] && key[0] !== '$') {
-        res[key] = normalizeScopedSlot(ownerVm, normalSlots, key, slots[key])
+    for (const key in scopedSlots) {
+      if (scopedSlots[key] && key[0] !== '$') {
+        res[key] = normalizeScopedSlot(
+          ownerVm,
+          normalSlots,
+          key,
+          scopedSlots[key]
+        )
       }
     }
   }
@@ -48,8 +53,8 @@ export function normalizeScopedSlots(
   }
   // avoriaz seems to mock a non-extensible $scopedSlots object
   // and when that is passed down this would cause an error
-  if (slots && Object.isExtensible(slots)) {
-    slots._normalized = res
+  if (scopedSlots && Object.isExtensible(scopedSlots)) {
+    scopedSlots._normalized = res
   }
   def(res, '$stable', isStable)
   def(res, '$key', key)
diff --git a/test/unit/features/component/component-slot.spec.ts b/test/unit/features/component/component-slot.spec.ts
index a8042bf5700..da57d328aff 100644
--- a/test/unit/features/component/component-slot.spec.ts
+++ b/test/unit/features/component/component-slot.spec.ts
@@ -1044,4 +1044,33 @@ describe('Component slot', () => {
 
     expect(vm.$el.innerHTML).toBe(`<!----><span>b</span>`)
   })
+
+  // regression 2.7.0-alpha.4
+  it('passing scoped slots through nested parent chain', () => {
+    const Foo = {
+      template: `
+        <div><slot>foo default</slot></div>
+      `
+    }
+
+    const Bar = {
+      components: { Foo },
+      template: `<Foo><slot name="bar"/></Foo>`
+    }
+
+    const App = {
+      components: { Bar },
+      template: `<Bar>
+        <template #bar>
+          <span>App content for Bar#bar</span>
+        </template>
+      </Bar>`
+    }
+
+    const vm = new Vue({
+      render: h => h(App)
+    }).$mount()
+
+    expect(vm.$el.innerHTML).toMatch(`App content for Bar#bar`)
+  })
 })

From 9ce105aa10be6288e6ce9d26c1a5a6d16fee733b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 6 Jun 2022 15:33:20 +0800
Subject: [PATCH 127/317] release: v2.7.0-alpha.5

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a19480694b0..1f2a02f54a7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-alpha.5](https://github.com/vuejs/vue/compare/v2.7.0-alpha.4...v2.7.0-alpha.5) (2022-06-06)
+
+
+### Bug Fixes
+
+* fix scopedSlots regression ([4f2a04e](https://github.com/vuejs/vue/commit/4f2a04e6a8e1fc71080eed49fd4059d6a53afc1c))
+
+
+
 # [2.7.0-alpha.4](https://github.com/vuejs/vue/compare/v2.7.0-alpha.3...v2.7.0-alpha.4) (2022-06-01)
 
 
diff --git a/package.json b/package.json
index 1fe6a75d434..1e7597d3ae7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.4",
+  "version": "2.7.0-alpha.5",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 14be6da3a96..bace193a500 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.4",
+  "version": "2.7.0-alpha.5",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 01d610ff56d..fbfeae3ab63 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.4",
+  "version": "2.7.0-alpha.5",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 8280bfe6b85..9710a3871e4 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.4",
+  "version": "2.7.0-alpha.5",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From c43e64277f72d5e1b23ac483528cf78b02110e18 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 6 Jun 2022 15:34:55 +0800
Subject: [PATCH 128/317] build: fix build script alias

---
 scripts/alias.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/alias.js b/scripts/alias.js
index 08f0eb6e1c3..874686da40d 100644
--- a/scripts/alias.js
+++ b/scripts/alias.js
@@ -9,5 +9,5 @@ module.exports = {
   shared: resolve('src/shared'),
   web: resolve('src/platforms/web'),
   server: resolve('packages/server-renderer/src'),
-  sfc: resolve('src/sfc')
+  sfc: resolve('packages/compiler-sfc/src')
 }

From c678e3134b927645f79270b52d4d660a7e3654ce Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 9 Jun 2022 14:39:18 +0800
Subject: [PATCH 129/317] types: include jsx typing

---
 package.json               |    3 +-
 pnpm-lock.yaml             |    8 +-
 types/index.d.ts           |    1 +
 types/jsx.d.ts             | 1337 ++++++++++++++++++++++++++++++++++++
 types/test/v3/tsx-test.tsx |   53 ++
 types/tsconfig.json        |    2 +
 6 files changed, 1402 insertions(+), 2 deletions(-)
 create mode 100644 types/jsx.d.ts
 create mode 100644 types/test/v3/tsx-test.tsx

diff --git a/package.json b/package.json
index 1e7597d3ae7..ccfaa912e63 100644
--- a/package.json
+++ b/package.json
@@ -81,7 +81,8 @@
   },
   "homepage": "https://github.com/vuejs/vue#readme",
   "dependencies": {
-    "@vue/compiler-sfc": "workspace:*"
+    "@vue/compiler-sfc": "workspace:*",
+    "csstype": "^3.1.0"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.24.2",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 470c95c6d4d..5b09d64d5b0 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -15,6 +15,7 @@ importers:
       chalk: ^4.0.0
       conventional-changelog-cli: ^2.2.2
       cross-spawn: ^7.0.3
+      csstype: ^3.1.0
       de-indent: ^1.0.2
       enquirer: ^2.3.6
       esbuild: ^0.14.39
@@ -47,6 +48,7 @@ importers:
       yorkie: ^2.0.0
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
+      csstype: 3.1.0
     devDependencies:
       '@microsoft/api-extractor': 7.24.2
       '@rollup/plugin-alias': 3.1.9_rollup@2.75.3
@@ -1765,6 +1767,9 @@ packages:
       cssom: 0.3.8
     dev: true
 
+  /csstype/3.1.0:
+    resolution: {integrity: sha512-uX1KG+x9h5hIJsaKR9xHUeUraxf8IODOwq9JLNPq6BwB04a/xgpq3rcx47l5BZu5zBPlgD342tdke3Hom/nJRA==}
+
   /custom-event/1.0.1:
     resolution: {integrity: sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==}
     dev: true
@@ -6415,7 +6420,8 @@ packages:
   'file:':
     resolution: {directory: '', type: directory}
     name: vue
-    version: 2.7.0-alpha.3
+    version: 2.7.0-alpha.5
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
+      csstype: 3.1.0
     dev: true
diff --git a/types/index.d.ts b/types/index.d.ts
index 2e2bfdd052c..d8722c3b8db 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -1,5 +1,6 @@
 import { Vue } from './vue'
 import './umd'
+import './jsx'
 
 export default Vue
 
diff --git a/types/jsx.d.ts b/types/jsx.d.ts
new file mode 100644
index 00000000000..c79501ac40c
--- /dev/null
+++ b/types/jsx.d.ts
@@ -0,0 +1,1337 @@
+// This code is based on react definition in DefinitelyTyped published under the MIT license.
+//      Repository: https://github.com/DefinitelyTyped/DefinitelyTyped
+//      Path in the repository: types/react/index.d.ts
+//
+// Copyrights of original definition are:
+//      AssureSign <http://www.assuresign.com>
+//      Microsoft <https://microsoft.com>
+//      John Reilly <https://github.com/johnnyreilly>
+//      Benoit Benezech <https://github.com/bbenezech>
+//      Patricio Zavolinsky <https://github.com/pzavolinsky>
+//      Digiguru <https://github.com/digiguru>
+//      Eric Anderson <https://github.com/ericanderson>
+//      Dovydas Navickas <https://github.com/DovydasNavickas>
+//      Josh Rutherford <https://github.com/theruther4d>
+//      Guilherme Hübner <https://github.com/guilhermehubner>
+//      Ferdy Budhidharma <https://github.com/ferdaber>
+//      Johann Rakotoharisoa <https://github.com/jrakotoharisoa>
+//      Olivier Pascal <https://github.com/pascaloliv>
+//      Martin Hochel <https://github.com/hotell>
+//      Frank Li <https://github.com/franklixuefei>
+//      Jessica Franco <https://github.com/Jessidhia>
+//      Saransh Kataria <https://github.com/saranshkataria>
+//      Kanitkorn Sujautra <https://github.com/lukyth>
+//      Sebastian Silbermann <https://github.com/eps1lon>
+
+import * as CSS from 'csstype'
+
+export interface CSSProperties
+  extends CSS.Properties<string | number>,
+    CSS.PropertiesHyphen<string | number> {
+  /**
+   * The index signature was removed to enable closed typing for style
+   * using CSSType. You're able to use type assertion or module augmentation
+   * to add properties or an index signature of your own.
+   *
+   * For examples and more information, visit:
+   * https://github.com/frenic/csstype#what-should-i-do-when-i-get-type-errors
+   */
+  [v: `--${string}`]: string | number | undefined
+}
+
+type Booleanish = boolean | 'true' | 'false'
+type Numberish = number | string
+
+// All the WAI-ARIA 1.1 attributes from https://www.w3.org/TR/wai-aria-1.1/
+interface AriaAttributes {
+  /** Identifies the currently active element when DOM focus is on a composite widget, textbox, group, or application. */
+  'aria-activedescendant'?: string
+  /** Indicates whether assistive technologies will present all, or only parts of, the changed region based on the change notifications defined by the aria-relevant attribute. */
+  'aria-atomic'?: Booleanish
+  /**
+   * Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for an input and specifies how predictions would be
+   * presented if they are made.
+   */
+  'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both'
+  /** Indicates an element is being modified and that assistive technologies MAY want to wait until the modifications are complete before exposing them to the user. */
+  'aria-busy'?: Booleanish
+  /**
+   * Indicates the current "checked" state of checkboxes, radio buttons, and other widgets.
+   * @see aria-pressed @see aria-selected.
+   */
+  'aria-checked'?: Booleanish | 'mixed'
+  /**
+   * Defines the total number of columns in a table, grid, or treegrid.
+   * @see aria-colindex.
+   */
+  'aria-colcount'?: Numberish
+  /**
+   * Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid.
+   * @see aria-colcount @see aria-colspan.
+   */
+  'aria-colindex'?: Numberish
+  /**
+   * Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid.
+   * @see aria-colindex @see aria-rowspan.
+   */
+  'aria-colspan'?: Numberish
+  /**
+   * Identifies the element (or elements) whose contents or presence are controlled by the current element.
+   * @see aria-owns.
+   */
+  'aria-controls'?: string
+  /** Indicates the element that represents the current item within a container or set of related elements. */
+  'aria-current'?: Booleanish | 'page' | 'step' | 'location' | 'date' | 'time'
+  /**
+   * Identifies the element (or elements) that describes the object.
+   * @see aria-labelledby
+   */
+  'aria-describedby'?: string
+  /**
+   * Identifies the element that provides a detailed, extended description for the object.
+   * @see aria-describedby.
+   */
+  'aria-details'?: string
+  /**
+   * Indicates that the element is perceivable but disabled, so it is not editable or otherwise operable.
+   * @see aria-hidden @see aria-readonly.
+   */
+  'aria-disabled'?: Booleanish
+  /**
+   * Indicates what functions can be performed when a dragged object is released on the drop target.
+   * @deprecated in ARIA 1.1
+   */
+  'aria-dropeffect'?: 'none' | 'copy' | 'execute' | 'link' | 'move' | 'popup'
+  /**
+   * Identifies the element that provides an error message for the object.
+   * @see aria-invalid @see aria-describedby.
+   */
+  'aria-errormessage'?: string
+  /** Indicates whether the element, or another grouping element it controls, is currently expanded or collapsed. */
+  'aria-expanded'?: Booleanish
+  /**
+   * Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion,
+   * allows assistive technology to override the general default of reading in document source order.
+   */
+  'aria-flowto'?: string
+  /**
+   * Indicates an element's "grabbed" state in a drag-and-drop operation.
+   * @deprecated in ARIA 1.1
+   */
+  'aria-grabbed'?: Booleanish
+  /** Indicates the availability and type of interactive popup element, such as menu or dialog, that can be triggered by an element. */
+  'aria-haspopup'?: Booleanish | 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog'
+  /**
+   * Indicates whether the element is exposed to an accessibility API.
+   * @see aria-disabled.
+   */
+  'aria-hidden'?: Booleanish
+  /**
+   * Indicates the entered value does not conform to the format expected by the application.
+   * @see aria-errormessage.
+   */
+  'aria-invalid'?: Booleanish | 'grammar' | 'spelling'
+  /** Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. */
+  'aria-keyshortcuts'?: string
+  /**
+   * Defines a string value that labels the current element.
+   * @see aria-labelledby.
+   */
+  'aria-label'?: string
+  /**
+   * Identifies the element (or elements) that labels the current element.
+   * @see aria-describedby.
+   */
+  'aria-labelledby'?: string
+  /** Defines the hierarchical level of an element within a structure. */
+  'aria-level'?: Numberish
+  /** Indicates that an element will be updated, and describes the types of updates the user agents, assistive technologies, and user can expect from the live region. */
+  'aria-live'?: 'off' | 'assertive' | 'polite'
+  /** Indicates whether an element is modal when displayed. */
+  'aria-modal'?: Booleanish
+  /** Indicates whether a text box accepts multiple lines of input or only a single line. */
+  'aria-multiline'?: Booleanish
+  /** Indicates that the user may select more than one item from the current selectable descendants. */
+  'aria-multiselectable'?: Booleanish
+  /** Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. */
+  'aria-orientation'?: 'horizontal' | 'vertical'
+  /**
+   * Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship
+   * between DOM elements where the DOM hierarchy cannot be used to represent the relationship.
+   * @see aria-controls.
+   */
+  'aria-owns'?: string
+  /**
+   * Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value.
+   * A hint could be a sample value or a brief description of the expected format.
+   */
+  'aria-placeholder'?: string
+  /**
+   * Defines an element's number or position in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
+   * @see aria-setsize.
+   */
+  'aria-posinset'?: Numberish
+  /**
+   * Indicates the current "pressed" state of toggle buttons.
+   * @see aria-checked @see aria-selected.
+   */
+  'aria-pressed'?: Booleanish | 'mixed'
+  /**
+   * Indicates that the element is not editable, but is otherwise operable.
+   * @see aria-disabled.
+   */
+  'aria-readonly'?: Booleanish
+  /**
+   * Indicates what notifications the user agent will trigger when the accessibility tree within a live region is modified.
+   * @see aria-atomic.
+   */
+  'aria-relevant'?: 'additions' | 'additions text' | 'all' | 'removals' | 'text'
+  /** Indicates that user input is required on the element before a form may be submitted. */
+  'aria-required'?: Booleanish
+  /** Defines a human-readable, author-localized description for the role of an element. */
+  'aria-roledescription'?: string
+  /**
+   * Defines the total number of rows in a table, grid, or treegrid.
+   * @see aria-rowindex.
+   */
+  'aria-rowcount'?: Numberish
+  /**
+   * Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid.
+   * @see aria-rowcount @see aria-rowspan.
+   */
+  'aria-rowindex'?: Numberish
+  /**
+   * Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid.
+   * @see aria-rowindex @see aria-colspan.
+   */
+  'aria-rowspan'?: Numberish
+  /**
+   * Indicates the current "selected" state of various widgets.
+   * @see aria-checked @see aria-pressed.
+   */
+  'aria-selected'?: Booleanish
+  /**
+   * Defines the number of items in the current set of listitems or treeitems. Not required if all elements in the set are present in the DOM.
+   * @see aria-posinset.
+   */
+  'aria-setsize'?: Numberish
+  /** Indicates if items in a table or grid are sorted in ascending or descending order. */
+  'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other'
+  /** Defines the maximum allowed value for a range widget. */
+  'aria-valuemax'?: Numberish
+  /** Defines the minimum allowed value for a range widget. */
+  'aria-valuemin'?: Numberish
+  /**
+   * Defines the current value for a range widget.
+   * @see aria-valuetext.
+   */
+  'aria-valuenow'?: Numberish
+  /** Defines the human readable text alternative of aria-valuenow for a range widget. */
+  'aria-valuetext'?: string
+}
+
+// Vue's style normalization supports nested arrays
+export type StyleValue = string | CSSProperties | Array<StyleValue>
+
+export interface HTMLAttributes extends AriaAttributes, EventHandlers<Events> {
+  innerHTML?: string
+
+  class?: any
+  style?: StyleValue
+
+  // Standard HTML Attributes
+  accesskey?: string
+  contenteditable?: Booleanish | 'inherit'
+  contextmenu?: string
+  dir?: string
+  draggable?: Booleanish
+  hidden?: Booleanish
+  id?: string
+  lang?: string
+  placeholder?: string
+  spellcheck?: Booleanish
+  tabindex?: Numberish
+  title?: string
+  translate?: 'yes' | 'no'
+
+  // Unknown
+  radiogroup?: string // <command>, <menuitem>
+
+  // WAI-ARIA
+  role?: string
+
+  // RDFa Attributes
+  about?: string
+  datatype?: string
+  inlist?: any
+  prefix?: string
+  property?: string
+  resource?: string
+  typeof?: string
+  vocab?: string
+
+  // Non-standard Attributes
+  autocapitalize?: string
+  autocorrect?: string
+  autosave?: string
+  color?: string
+  itemprop?: string
+  itemscope?: Booleanish
+  itemtype?: string
+  itemid?: string
+  itemref?: string
+  results?: Numberish
+  security?: string
+  unselectable?: 'on' | 'off'
+
+  // Living Standard
+  /**
+   * Hints at the type of data that might be entered by the user while editing the element or its contents
+   * @see https://html.spec.whatwg.org/multipage/interaction.html#input-modalities:-the-inputmode-attribute
+   */
+  inputmode?:
+    | 'none'
+    | 'text'
+    | 'tel'
+    | 'url'
+    | 'email'
+    | 'numeric'
+    | 'decimal'
+    | 'search'
+  /**
+   * Specify that a standard HTML element should behave like a defined custom built-in element
+   * @see https://html.spec.whatwg.org/multipage/custom-elements.html#attr-is
+   */
+  is?: string
+}
+
+export interface AnchorHTMLAttributes extends HTMLAttributes {
+  download?: any
+  href?: string
+  hreflang?: string
+  media?: string
+  ping?: string
+  rel?: string
+  target?: string
+  type?: string
+  referrerpolicy?: string
+}
+
+export interface AreaHTMLAttributes extends HTMLAttributes {
+  alt?: string
+  coords?: string
+  download?: any
+  href?: string
+  hreflang?: string
+  media?: string
+  rel?: string
+  shape?: string
+  target?: string
+}
+
+export interface AudioHTMLAttributes extends MediaHTMLAttributes {}
+
+export interface BaseHTMLAttributes extends HTMLAttributes {
+  href?: string
+  target?: string
+}
+
+export interface BlockquoteHTMLAttributes extends HTMLAttributes {
+  cite?: string
+}
+
+export interface ButtonHTMLAttributes extends HTMLAttributes {
+  autofocus?: Booleanish
+  disabled?: Booleanish
+  form?: string
+  formaction?: string
+  formenctype?: string
+  formmethod?: string
+  formnovalidate?: Booleanish
+  formtarget?: string
+  name?: string
+  type?: 'submit' | 'reset' | 'button'
+  value?: string | string[] | number
+}
+
+export interface CanvasHTMLAttributes extends HTMLAttributes {
+  height?: Numberish
+  width?: Numberish
+}
+
+export interface ColHTMLAttributes extends HTMLAttributes {
+  span?: Numberish
+  width?: Numberish
+}
+
+export interface ColgroupHTMLAttributes extends HTMLAttributes {
+  span?: Numberish
+}
+
+export interface DataHTMLAttributes extends HTMLAttributes {
+  value?: string | string[] | number
+}
+
+export interface DetailsHTMLAttributes extends HTMLAttributes {
+  open?: Booleanish
+}
+
+export interface DelHTMLAttributes extends HTMLAttributes {
+  cite?: string
+  datetime?: string
+}
+
+export interface DialogHTMLAttributes extends HTMLAttributes {
+  open?: Booleanish
+}
+
+export interface EmbedHTMLAttributes extends HTMLAttributes {
+  height?: Numberish
+  src?: string
+  type?: string
+  width?: Numberish
+}
+
+export interface FieldsetHTMLAttributes extends HTMLAttributes {
+  disabled?: Booleanish
+  form?: string
+  name?: string
+}
+
+export interface FormHTMLAttributes extends HTMLAttributes {
+  acceptcharset?: string
+  action?: string
+  autocomplete?: string
+  enctype?: string
+  method?: string
+  name?: string
+  novalidate?: Booleanish
+  target?: string
+}
+
+export interface HtmlHTMLAttributes extends HTMLAttributes {
+  manifest?: string
+}
+
+export interface IframeHTMLAttributes extends HTMLAttributes {
+  allow?: string
+  allowfullscreen?: Booleanish
+  allowtransparency?: Booleanish
+  frameborder?: Numberish
+  height?: Numberish
+  marginheight?: Numberish
+  marginwidth?: Numberish
+  name?: string
+  referrerpolicy?: string
+  sandbox?: string
+  scrolling?: string
+  seamless?: Booleanish
+  src?: string
+  srcdoc?: string
+  width?: Numberish
+}
+
+export interface ImgHTMLAttributes extends HTMLAttributes {
+  alt?: string
+  crossorigin?: 'anonymous' | 'use-credentials' | ''
+  decoding?: 'async' | 'auto' | 'sync'
+  height?: Numberish
+  sizes?: string
+  src?: string
+  srcset?: string
+  usemap?: string
+  width?: Numberish
+}
+
+export interface InsHTMLAttributes extends HTMLAttributes {
+  cite?: string
+  datetime?: string
+}
+
+export interface InputHTMLAttributes extends HTMLAttributes {
+  accept?: string
+  alt?: string
+  autocomplete?: string
+  autofocus?: Booleanish
+  capture?: boolean | 'user' | 'environment' // https://www.w3.org/tr/html-media-capture/#the-capture-attribute
+  checked?: Booleanish | any[] | Set<any> // for IDE v-model multi-checkbox support
+  crossorigin?: string
+  disabled?: Booleanish
+  form?: string
+  formaction?: string
+  formenctype?: string
+  formmethod?: string
+  formnovalidate?: Booleanish
+  formtarget?: string
+  height?: Numberish
+  indeterminate?: boolean
+  list?: string
+  max?: Numberish
+  maxlength?: Numberish
+  min?: Numberish
+  minlength?: Numberish
+  multiple?: Booleanish
+  name?: string
+  pattern?: string
+  placeholder?: string
+  readonly?: Booleanish
+  required?: Booleanish
+  size?: Numberish
+  src?: string
+  step?: Numberish
+  type?: string
+  value?: any // we support :value to be bound to anything w/ v-model
+  width?: Numberish
+}
+
+export interface KeygenHTMLAttributes extends HTMLAttributes {
+  autofocus?: Booleanish
+  challenge?: string
+  disabled?: Booleanish
+  form?: string
+  keytype?: string
+  keyparams?: string
+  name?: string
+}
+
+export interface LabelHTMLAttributes extends HTMLAttributes {
+  for?: string
+  form?: string
+}
+
+export interface LiHTMLAttributes extends HTMLAttributes {
+  value?: string | string[] | number
+}
+
+export interface LinkHTMLAttributes extends HTMLAttributes {
+  as?: string
+  crossorigin?: string
+  href?: string
+  hreflang?: string
+  integrity?: string
+  media?: string
+  rel?: string
+  sizes?: string
+  type?: string
+}
+
+export interface MapHTMLAttributes extends HTMLAttributes {
+  name?: string
+}
+
+export interface MenuHTMLAttributes extends HTMLAttributes {
+  type?: string
+}
+
+export interface MediaHTMLAttributes extends HTMLAttributes {
+  autoplay?: Booleanish
+  controls?: Booleanish
+  controlslist?: string
+  crossorigin?: string
+  loop?: Booleanish
+  mediagroup?: string
+  muted?: Booleanish
+  playsinline?: Booleanish
+  preload?: string
+  src?: string
+}
+
+export interface MetaHTMLAttributes extends HTMLAttributes {
+  charset?: string
+  content?: string
+  httpequiv?: string
+  name?: string
+}
+
+export interface MeterHTMLAttributes extends HTMLAttributes {
+  form?: string
+  high?: Numberish
+  low?: Numberish
+  max?: Numberish
+  min?: Numberish
+  optimum?: Numberish
+  value?: string | string[] | number
+}
+
+export interface QuoteHTMLAttributes extends HTMLAttributes {
+  cite?: string
+}
+
+export interface ObjectHTMLAttributes extends HTMLAttributes {
+  classid?: string
+  data?: string
+  form?: string
+  height?: Numberish
+  name?: string
+  type?: string
+  usemap?: string
+  width?: Numberish
+  wmode?: string
+}
+
+export interface OlHTMLAttributes extends HTMLAttributes {
+  reversed?: Booleanish
+  start?: Numberish
+  type?: '1' | 'a' | 'A' | 'i' | 'I'
+}
+
+export interface OptgroupHTMLAttributes extends HTMLAttributes {
+  disabled?: Booleanish
+  label?: string
+}
+
+export interface OptionHTMLAttributes extends HTMLAttributes {
+  disabled?: Booleanish
+  label?: string
+  selected?: Booleanish
+  value?: any // we support :value to be bound to anything w/ v-model
+}
+
+export interface OutputHTMLAttributes extends HTMLAttributes {
+  for?: string
+  form?: string
+  name?: string
+}
+
+export interface ParamHTMLAttributes extends HTMLAttributes {
+  name?: string
+  value?: string | string[] | number
+}
+
+export interface ProgressHTMLAttributes extends HTMLAttributes {
+  max?: Numberish
+  value?: string | string[] | number
+}
+
+export interface ScriptHTMLAttributes extends HTMLAttributes {
+  async?: Booleanish
+  charset?: string
+  crossorigin?: string
+  defer?: Booleanish
+  integrity?: string
+  nomodule?: Booleanish
+  nonce?: string
+  src?: string
+  type?: string
+}
+
+export interface SelectHTMLAttributes extends HTMLAttributes {
+  autocomplete?: string
+  autofocus?: Booleanish
+  disabled?: Booleanish
+  form?: string
+  multiple?: Booleanish
+  name?: string
+  required?: Booleanish
+  size?: Numberish
+  value?: any // we support :value to be bound to anything w/ v-model
+}
+
+export interface SourceHTMLAttributes extends HTMLAttributes {
+  media?: string
+  sizes?: string
+  src?: string
+  srcset?: string
+  type?: string
+}
+
+export interface StyleHTMLAttributes extends HTMLAttributes {
+  media?: string
+  nonce?: string
+  scoped?: Booleanish
+  type?: string
+}
+
+export interface TableHTMLAttributes extends HTMLAttributes {
+  cellpadding?: Numberish
+  cellspacing?: Numberish
+  summary?: string
+}
+
+export interface TextareaHTMLAttributes extends HTMLAttributes {
+  autocomplete?: string
+  autofocus?: Booleanish
+  cols?: Numberish
+  dirname?: string
+  disabled?: Booleanish
+  form?: string
+  maxlength?: Numberish
+  minlength?: Numberish
+  name?: string
+  placeholder?: string
+  readonly?: boolean
+  required?: Booleanish
+  rows?: Numberish
+  value?: string | string[] | number
+  wrap?: string
+}
+
+export interface TdHTMLAttributes extends HTMLAttributes {
+  align?: 'left' | 'center' | 'right' | 'justify' | 'char'
+  colspan?: Numberish
+  headers?: string
+  rowspan?: Numberish
+  scope?: string
+  valign?: 'top' | 'middle' | 'bottom' | 'baseline'
+}
+
+export interface ThHTMLAttributes extends HTMLAttributes {
+  align?: 'left' | 'center' | 'right' | 'justify' | 'char'
+  colspan?: Numberish
+  headers?: string
+  rowspan?: Numberish
+  scope?: string
+}
+
+export interface TimeHTMLAttributes extends HTMLAttributes {
+  datetime?: string
+}
+
+export interface TrackHTMLAttributes extends HTMLAttributes {
+  default?: Booleanish
+  kind?: string
+  label?: string
+  src?: string
+  srclang?: string
+}
+
+export interface VideoHTMLAttributes extends MediaHTMLAttributes {
+  height?: Numberish
+  playsinline?: Booleanish
+  poster?: string
+  width?: Numberish
+  disablePictureInPicture?: Booleanish
+}
+
+export interface WebViewHTMLAttributes extends HTMLAttributes {
+  allowfullscreen?: Booleanish
+  allowpopups?: Booleanish
+  autoFocus?: Booleanish
+  autosize?: Booleanish
+  blinkfeatures?: string
+  disableblinkfeatures?: string
+  disableguestresize?: Booleanish
+  disablewebsecurity?: Booleanish
+  guestinstance?: string
+  httpreferrer?: string
+  nodeintegration?: Booleanish
+  partition?: string
+  plugins?: Booleanish
+  preload?: string
+  src?: string
+  useragent?: string
+  webpreferences?: string
+}
+
+export interface SVGAttributes extends AriaAttributes, EventHandlers<Events> {
+  innerHTML?: string
+
+  /**
+   * SVG Styling Attributes
+   * @see https://www.w3.org/TR/SVG/styling.html#ElementSpecificStyling
+   */
+  class?: any
+  style?: string | CSSProperties
+
+  color?: string
+  height?: Numberish
+  id?: string
+  lang?: string
+  max?: Numberish
+  media?: string
+  method?: string
+  min?: Numberish
+  name?: string
+  target?: string
+  type?: string
+  width?: Numberish
+
+  // Other HTML properties supported by SVG elements in browsers
+  role?: string
+  tabindex?: Numberish
+
+  // SVG Specific attributes
+  'accent-height'?: Numberish
+  accumulate?: 'none' | 'sum'
+  additive?: 'replace' | 'sum'
+  'alignment-baseline'?:
+    | 'auto'
+    | 'baseline'
+    | 'before-edge'
+    | 'text-before-edge'
+    | 'middle'
+    | 'central'
+    | 'after-edge'
+    | 'text-after-edge'
+    | 'ideographic'
+    | 'alphabetic'
+    | 'hanging'
+    | 'mathematical'
+    | 'inherit'
+  allowReorder?: 'no' | 'yes'
+  alphabetic?: Numberish
+  amplitude?: Numberish
+  'arabic-form'?: 'initial' | 'medial' | 'terminal' | 'isolated'
+  ascent?: Numberish
+  attributeName?: string
+  attributeType?: string
+  autoReverse?: Numberish
+  azimuth?: Numberish
+  baseFrequency?: Numberish
+  'baseline-shift'?: Numberish
+  baseProfile?: Numberish
+  bbox?: Numberish
+  begin?: Numberish
+  bias?: Numberish
+  by?: Numberish
+  calcMode?: Numberish
+  'cap-height'?: Numberish
+  clip?: Numberish
+  'clip-path'?: string
+  clipPathUnits?: Numberish
+  'clip-rule'?: Numberish
+  'color-interpolation'?: Numberish
+  'color-interpolation-filters'?: 'auto' | 'sRGB' | 'linearRGB' | 'inherit'
+  'color-profile'?: Numberish
+  'color-rendering'?: Numberish
+  contentScriptType?: Numberish
+  contentStyleType?: Numberish
+  cursor?: Numberish
+  cx?: Numberish
+  cy?: Numberish
+  d?: string
+  decelerate?: Numberish
+  descent?: Numberish
+  diffuseConstant?: Numberish
+  direction?: Numberish
+  display?: Numberish
+  divisor?: Numberish
+  'dominant-baseline'?: Numberish
+  dur?: Numberish
+  dx?: Numberish
+  dy?: Numberish
+  edgeMode?: Numberish
+  elevation?: Numberish
+  'enable-background'?: Numberish
+  end?: Numberish
+  exponent?: Numberish
+  externalResourcesRequired?: Numberish
+  fill?: string
+  'fill-opacity'?: Numberish
+  'fill-rule'?: 'nonzero' | 'evenodd' | 'inherit'
+  filter?: string
+  filterRes?: Numberish
+  filterUnits?: Numberish
+  'flood-color'?: Numberish
+  'flood-opacity'?: Numberish
+  focusable?: Numberish
+  'font-family'?: string
+  'font-size'?: Numberish
+  'font-size-adjust'?: Numberish
+  'font-stretch'?: Numberish
+  'font-style'?: Numberish
+  'font-variant'?: Numberish
+  'font-weight'?: Numberish
+  format?: Numberish
+  from?: Numberish
+  fx?: Numberish
+  fy?: Numberish
+  g1?: Numberish
+  g2?: Numberish
+  'glyph-name'?: Numberish
+  'glyph-orientation-horizontal'?: Numberish
+  'glyph-orientation-vertical'?: Numberish
+  glyphRef?: Numberish
+  gradientTransform?: string
+  gradientUnits?: string
+  hanging?: Numberish
+  'horiz-adv-x'?: Numberish
+  'horiz-origin-x'?: Numberish
+  href?: string
+  ideographic?: Numberish
+  'image-rendering'?: Numberish
+  in2?: Numberish
+  in?: string
+  intercept?: Numberish
+  k1?: Numberish
+  k2?: Numberish
+  k3?: Numberish
+  k4?: Numberish
+  k?: Numberish
+  kernelMatrix?: Numberish
+  kernelUnitLength?: Numberish
+  kerning?: Numberish
+  keyPoints?: Numberish
+  keySplines?: Numberish
+  keyTimes?: Numberish
+  lengthAdjust?: Numberish
+  'letter-spacing'?: Numberish
+  'lighting-color'?: Numberish
+  limitingConeAngle?: Numberish
+  local?: Numberish
+  'marker-end'?: string
+  markerHeight?: Numberish
+  'marker-mid'?: string
+  'marker-start'?: string
+  markerUnits?: Numberish
+  markerWidth?: Numberish
+  mask?: string
+  maskContentUnits?: Numberish
+  maskUnits?: Numberish
+  mathematical?: Numberish
+  mode?: Numberish
+  numOctaves?: Numberish
+  offset?: Numberish
+  opacity?: Numberish
+  operator?: Numberish
+  order?: Numberish
+  orient?: Numberish
+  orientation?: Numberish
+  origin?: Numberish
+  overflow?: Numberish
+  'overline-position'?: Numberish
+  'overline-thickness'?: Numberish
+  'paint-order'?: Numberish
+  'panose-1'?: Numberish
+  pathLength?: Numberish
+  patternContentUnits?: string
+  patternTransform?: Numberish
+  patternUnits?: string
+  'pointer-events'?: Numberish
+  points?: string
+  pointsAtX?: Numberish
+  pointsAtY?: Numberish
+  pointsAtZ?: Numberish
+  preserveAlpha?: Numberish
+  preserveAspectRatio?: string
+  primitiveUnits?: Numberish
+  r?: Numberish
+  radius?: Numberish
+  refX?: Numberish
+  refY?: Numberish
+  renderingIntent?: Numberish
+  repeatCount?: Numberish
+  repeatDur?: Numberish
+  requiredExtensions?: Numberish
+  requiredFeatures?: Numberish
+  restart?: Numberish
+  result?: string
+  rotate?: Numberish
+  rx?: Numberish
+  ry?: Numberish
+  scale?: Numberish
+  seed?: Numberish
+  'shape-rendering'?: Numberish
+  slope?: Numberish
+  spacing?: Numberish
+  specularConstant?: Numberish
+  specularExponent?: Numberish
+  speed?: Numberish
+  spreadMethod?: string
+  startOffset?: Numberish
+  stdDeviation?: Numberish
+  stemh?: Numberish
+  stemv?: Numberish
+  stitchTiles?: Numberish
+  'stop-color'?: string
+  'stop-opacity'?: Numberish
+  'strikethrough-position'?: Numberish
+  'strikethrough-thickness'?: Numberish
+  string?: Numberish
+  stroke?: string
+  'stroke-dasharray'?: Numberish
+  'stroke-dashoffset'?: Numberish
+  'stroke-linecap'?: 'butt' | 'round' | 'square' | 'inherit'
+  'stroke-linejoin'?: 'miter' | 'round' | 'bevel' | 'inherit'
+  'stroke-miterlimit'?: Numberish
+  'stroke-opacity'?: Numberish
+  'stroke-width'?: Numberish
+  surfaceScale?: Numberish
+  systemLanguage?: Numberish
+  tableValues?: Numberish
+  targetX?: Numberish
+  targetY?: Numberish
+  'text-anchor'?: string
+  'text-decoration'?: Numberish
+  textLength?: Numberish
+  'text-rendering'?: Numberish
+  to?: Numberish
+  transform?: string
+  u1?: Numberish
+  u2?: Numberish
+  'underline-position'?: Numberish
+  'underline-thickness'?: Numberish
+  unicode?: Numberish
+  'unicode-bidi'?: Numberish
+  'unicode-range'?: Numberish
+  'unitsPer-em'?: Numberish
+  'v-alphabetic'?: Numberish
+  values?: string
+  'vector-effect'?: Numberish
+  version?: string
+  'vert-adv-y'?: Numberish
+  'vert-origin-x'?: Numberish
+  'vert-origin-y'?: Numberish
+  'v-hanging'?: Numberish
+  'v-ideographic'?: Numberish
+  viewBox?: string
+  viewTarget?: Numberish
+  visibility?: Numberish
+  'v-mathematical'?: Numberish
+  widths?: Numberish
+  'word-spacing'?: Numberish
+  'writing-mode'?: Numberish
+  x1?: Numberish
+  x2?: Numberish
+  x?: Numberish
+  xChannelSelector?: string
+  'x-height'?: Numberish
+  xlinkActuate?: string
+  xlinkArcrole?: string
+  xlinkHref?: string
+  xlinkRole?: string
+  xlinkShow?: string
+  xlinkTitle?: string
+  xlinkType?: string
+  xmlns?: string
+  y1?: Numberish
+  y2?: Numberish
+  y?: Numberish
+  yChannelSelector?: string
+  z?: Numberish
+  zoomAndPan?: string
+}
+
+interface IntrinsicElementAttributes {
+  a: AnchorHTMLAttributes
+  abbr: HTMLAttributes
+  address: HTMLAttributes
+  area: AreaHTMLAttributes
+  article: HTMLAttributes
+  aside: HTMLAttributes
+  audio: AudioHTMLAttributes
+  b: HTMLAttributes
+  base: BaseHTMLAttributes
+  bdi: HTMLAttributes
+  bdo: HTMLAttributes
+  blockquote: BlockquoteHTMLAttributes
+  body: HTMLAttributes
+  br: HTMLAttributes
+  button: ButtonHTMLAttributes
+  canvas: CanvasHTMLAttributes
+  caption: HTMLAttributes
+  cite: HTMLAttributes
+  code: HTMLAttributes
+  col: ColHTMLAttributes
+  colgroup: ColgroupHTMLAttributes
+  data: DataHTMLAttributes
+  datalist: HTMLAttributes
+  dd: HTMLAttributes
+  del: DelHTMLAttributes
+  details: DetailsHTMLAttributes
+  dfn: HTMLAttributes
+  dialog: DialogHTMLAttributes
+  div: HTMLAttributes
+  dl: HTMLAttributes
+  dt: HTMLAttributes
+  em: HTMLAttributes
+  embed: EmbedHTMLAttributes
+  fieldset: FieldsetHTMLAttributes
+  figcaption: HTMLAttributes
+  figure: HTMLAttributes
+  footer: HTMLAttributes
+  form: FormHTMLAttributes
+  h1: HTMLAttributes
+  h2: HTMLAttributes
+  h3: HTMLAttributes
+  h4: HTMLAttributes
+  h5: HTMLAttributes
+  h6: HTMLAttributes
+  head: HTMLAttributes
+  header: HTMLAttributes
+  hgroup: HTMLAttributes
+  hr: HTMLAttributes
+  html: HtmlHTMLAttributes
+  i: HTMLAttributes
+  iframe: IframeHTMLAttributes
+  img: ImgHTMLAttributes
+  input: InputHTMLAttributes
+  ins: InsHTMLAttributes
+  kbd: HTMLAttributes
+  keygen: KeygenHTMLAttributes
+  label: LabelHTMLAttributes
+  legend: HTMLAttributes
+  li: LiHTMLAttributes
+  link: LinkHTMLAttributes
+  main: HTMLAttributes
+  map: MapHTMLAttributes
+  mark: HTMLAttributes
+  menu: MenuHTMLAttributes
+  meta: MetaHTMLAttributes
+  meter: MeterHTMLAttributes
+  nav: HTMLAttributes
+  noindex: HTMLAttributes
+  noscript: HTMLAttributes
+  object: ObjectHTMLAttributes
+  ol: OlHTMLAttributes
+  optgroup: OptgroupHTMLAttributes
+  option: OptionHTMLAttributes
+  output: OutputHTMLAttributes
+  p: HTMLAttributes
+  param: ParamHTMLAttributes
+  picture: HTMLAttributes
+  pre: HTMLAttributes
+  progress: ProgressHTMLAttributes
+  q: QuoteHTMLAttributes
+  rp: HTMLAttributes
+  rt: HTMLAttributes
+  ruby: HTMLAttributes
+  s: HTMLAttributes
+  samp: HTMLAttributes
+  script: ScriptHTMLAttributes
+  section: HTMLAttributes
+  select: SelectHTMLAttributes
+  small: HTMLAttributes
+  source: SourceHTMLAttributes
+  span: HTMLAttributes
+  strong: HTMLAttributes
+  style: StyleHTMLAttributes
+  sub: HTMLAttributes
+  summary: HTMLAttributes
+  sup: HTMLAttributes
+  table: TableHTMLAttributes
+  template: HTMLAttributes
+  tbody: HTMLAttributes
+  td: TdHTMLAttributes
+  textarea: TextareaHTMLAttributes
+  tfoot: HTMLAttributes
+  th: ThHTMLAttributes
+  thead: HTMLAttributes
+  time: TimeHTMLAttributes
+  title: HTMLAttributes
+  tr: HTMLAttributes
+  track: TrackHTMLAttributes
+  u: HTMLAttributes
+  ul: HTMLAttributes
+  var: HTMLAttributes
+  video: VideoHTMLAttributes
+  wbr: HTMLAttributes
+  webview: WebViewHTMLAttributes
+
+  // SVG
+  svg: SVGAttributes
+
+  animate: SVGAttributes
+  animateMotion: SVGAttributes
+  animateTransform: SVGAttributes
+  circle: SVGAttributes
+  clipPath: SVGAttributes
+  defs: SVGAttributes
+  desc: SVGAttributes
+  ellipse: SVGAttributes
+  feBlend: SVGAttributes
+  feColorMatrix: SVGAttributes
+  feComponentTransfer: SVGAttributes
+  feComposite: SVGAttributes
+  feConvolveMatrix: SVGAttributes
+  feDiffuseLighting: SVGAttributes
+  feDisplacementMap: SVGAttributes
+  feDistantLight: SVGAttributes
+  feDropShadow: SVGAttributes
+  feFlood: SVGAttributes
+  feFuncA: SVGAttributes
+  feFuncB: SVGAttributes
+  feFuncG: SVGAttributes
+  feFuncR: SVGAttributes
+  feGaussianBlur: SVGAttributes
+  feImage: SVGAttributes
+  feMerge: SVGAttributes
+  feMergeNode: SVGAttributes
+  feMorphology: SVGAttributes
+  feOffset: SVGAttributes
+  fePointLight: SVGAttributes
+  feSpecularLighting: SVGAttributes
+  feSpotLight: SVGAttributes
+  feTile: SVGAttributes
+  feTurbulence: SVGAttributes
+  filter: SVGAttributes
+  foreignObject: SVGAttributes
+  g: SVGAttributes
+  image: SVGAttributes
+  line: SVGAttributes
+  linearGradient: SVGAttributes
+  marker: SVGAttributes
+  mask: SVGAttributes
+  metadata: SVGAttributes
+  mpath: SVGAttributes
+  path: SVGAttributes
+  pattern: SVGAttributes
+  polygon: SVGAttributes
+  polyline: SVGAttributes
+  radialGradient: SVGAttributes
+  rect: SVGAttributes
+  stop: SVGAttributes
+  switch: SVGAttributes
+  symbol: SVGAttributes
+  text: SVGAttributes
+  textPath: SVGAttributes
+  tspan: SVGAttributes
+  use: SVGAttributes
+  view: SVGAttributes
+}
+
+export interface Events {
+  // clipboard events
+  onCopy: ClipboardEvent
+  onCut: ClipboardEvent
+  onPaste: ClipboardEvent
+
+  // composition events
+  onCompositionend: CompositionEvent
+  onCompositionstart: CompositionEvent
+  onCompositionupdate: CompositionEvent
+
+  // drag drop events
+  onDrag: DragEvent
+  onDragend: DragEvent
+  onDragenter: DragEvent
+  onDragexit: DragEvent
+  onDragleave: DragEvent
+  onDragover: DragEvent
+  onDragstart: DragEvent
+  onDrop: DragEvent
+
+  // focus events
+  onFocus: FocusEvent
+  onFocusin: FocusEvent
+  onFocusout: FocusEvent
+  onBlur: FocusEvent
+
+  // form events
+  onChange: Event
+  onBeforeinput: Event
+  onInput: Event
+  onReset: Event
+  onSubmit: Event
+  onInvalid: Event
+
+  // image events
+  onLoad: Event
+  onError: Event
+
+  // keyboard events
+  onKeydown: KeyboardEvent
+  onKeypress: KeyboardEvent
+  onKeyup: KeyboardEvent
+
+  // mouse events
+  onAuxclick: MouseEvent
+  onClick: MouseEvent
+  onContextmenu: MouseEvent
+  onDblclick: MouseEvent
+  onMousedown: MouseEvent
+  onMouseenter: MouseEvent
+  onMouseleave: MouseEvent
+  onMousemove: MouseEvent
+  onMouseout: MouseEvent
+  onMouseover: MouseEvent
+  onMouseup: MouseEvent
+
+  // media events
+  onAbort: Event
+  onCanplay: Event
+  onCanplaythrough: Event
+  onDurationchange: Event
+  onEmptied: Event
+  onEncrypted: Event
+  onEnded: Event
+  onLoadeddata: Event
+  onLoadedmetadata: Event
+  onLoadstart: Event
+  onPause: Event
+  onPlay: Event
+  onPlaying: Event
+  onProgress: Event
+  onRatechange: Event
+  onSeeked: Event
+  onSeeking: Event
+  onStalled: Event
+  onSuspend: Event
+  onTimeupdate: Event
+  onVolumechange: Event
+  onWaiting: Event
+
+  // selection events
+  onSelect: Event
+
+  // UI events
+  onScroll: UIEvent
+
+  // touch events
+  onTouchcancel: TouchEvent
+  onTouchend: TouchEvent
+  onTouchmove: TouchEvent
+  onTouchstart: TouchEvent
+
+  // pointer events
+  onPointerdown: PointerEvent
+  onPointermove: PointerEvent
+  onPointerup: PointerEvent
+  onPointercancel: PointerEvent
+  onPointerenter: PointerEvent
+  onPointerleave: PointerEvent
+  onPointerover: PointerEvent
+  onPointerout: PointerEvent
+
+  // wheel events
+  onWheel: WheelEvent
+
+  // animation events
+  onAnimationstart: AnimationEvent
+  onAnimationend: AnimationEvent
+  onAnimationiteration: AnimationEvent
+
+  // transition events
+  onTransitionend: TransitionEvent
+  onTransitionstart: TransitionEvent
+}
+
+type EventHandlers<E> = {
+  [K in keyof E]?: E[K] extends Function ? E[K] : (payload: E[K]) => void
+}
+
+type ReservedProps = {
+  key?: string | number | symbol
+  ref?: VNodeData['ref']
+}
+
+type ElementAttrs<T> = T & ReservedProps
+
+type NativeElements = {
+  [K in keyof IntrinsicElementAttributes]: ElementAttrs<
+    IntrinsicElementAttributes[K]
+  >
+}
+
+import { VNode, VNodeData } from './vnode'
+
+declare global {
+  namespace JSX {
+    interface Element extends VNode {}
+    interface ElementClass {
+      $props: {}
+    }
+    interface ElementAttributesProperty {
+      $props: {}
+    }
+    interface IntrinsicElements extends NativeElements {
+      // allow arbitrary elements
+      // @ts-ignore suppress ts:2374 = Duplicate string index signature.
+      [name: string]: any
+    }
+    interface IntrinsicAttributes extends ReservedProps {}
+  }
+}
+
+// suppress ts:2669
+export {}
diff --git a/types/test/v3/tsx-test.tsx b/types/test/v3/tsx-test.tsx
new file mode 100644
index 00000000000..f9c77b7183e
--- /dev/null
+++ b/types/test/v3/tsx-test.tsx
@@ -0,0 +1,53 @@
+import { VNode, defineComponent } from '../../index'
+import { expectType } from '../utils'
+
+expectType<VNode>(<div />)
+expectType<JSX.Element>(<div />)
+expectType<JSX.Element>(<div id="foo" />)
+expectType<JSX.Element>(<input value="foo" />)
+
+// @ts-expect-error style css property validation
+expectError(<div style={{ unknown: 123 }} />)
+
+// allow array styles and nested array styles
+expectType<JSX.Element>(<div style={[{ color: 'red' }]} />)
+expectType<JSX.Element>(
+  <div style={[{ color: 'red' }, [{ fontSize: '1em' }]]} />
+)
+
+// @ts-expect-error unknown prop
+expectError(<div foo="bar" />)
+
+// allow key/ref on arbitrary element
+expectType<JSX.Element>(<div key="foo" />)
+expectType<JSX.Element>(<div ref="bar" />)
+
+expectType<JSX.Element>(
+  <input
+    onInput={e => {
+      // infer correct event type
+      expectType<EventTarget | null>(e.target)
+    }}
+  />
+)
+
+const Foo = defineComponent({
+  props: {
+    foo: String,
+    bar: {
+      type: Number,
+      required: true
+    }
+  }
+})
+
+// @ts-expect-error
+;<Foo />
+// @ts-expect-error
+;<Foo bar="1" />
+// @ts-expect-error
+;<Foo bar={1} foo={2} />
+
+// working
+;<Foo bar={1} />
+;<Foo bar={1} foo="baz" />
diff --git a/types/tsconfig.json b/types/tsconfig.json
index d8c4327e7f9..07fef18f7ff 100644
--- a/types/tsconfig.json
+++ b/types/tsconfig.json
@@ -5,6 +5,8 @@
     "lib": ["dom", "esnext"],
     "types": ["node"],
     "module": "esnext",
+    "moduleResolution": "node",
+    "jsx": "preserve",
     "strict": true,
     "noEmit": true,
     "baseUrl": ".",

From 5d4c59be11ecc1b1c1e4fe2bbf5c9ffb77da9960 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 9 Jun 2022 14:47:01 +0800
Subject: [PATCH 130/317] release: v2.7.0-alpha.6

---
 CHANGELOG.md                            | 4 ++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1f2a02f54a7..10e57c86cd3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# [2.7.0-alpha.6](https://github.com/vuejs/vue/compare/v2.7.0-alpha.5...v2.7.0-alpha.6) (2022-06-09)
+
+
+
 # [2.7.0-alpha.5](https://github.com/vuejs/vue/compare/v2.7.0-alpha.4...v2.7.0-alpha.5) (2022-06-06)
 
 
diff --git a/package.json b/package.json
index ccfaa912e63..fc624f93e2a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.5",
+  "version": "2.7.0-alpha.6",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index bace193a500..7d6c91284b1 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.5",
+  "version": "2.7.0-alpha.6",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index fbfeae3ab63..6ac5fbf1992 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.5",
+  "version": "2.7.0-alpha.6",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 9710a3871e4..07e4b219b7b 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.5",
+  "version": "2.7.0-alpha.6",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 50f2870ff04e263ff8d252862087f165e7a01702 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 9 Jun 2022 15:08:51 +0800
Subject: [PATCH 131/317] chore: changelog [ci skip]

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10e57c86cd3..37fcb4fc152 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # [2.7.0-alpha.6](https://github.com/vuejs/vue/compare/v2.7.0-alpha.5...v2.7.0-alpha.6) (2022-06-09)
 
+### Features
+
+* Add JSX types for Volar integration. No longer requires `@vue/runtime-dom` for component props validation in templates.
 
 
 # [2.7.0-alpha.5](https://github.com/vuejs/vue/compare/v2.7.0-alpha.4...v2.7.0-alpha.5) (2022-06-06)

From 06594f68b7e2d983d995dfd67c083f04dd0c2b7b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 10 Jun 2022 16:35:46 +0800
Subject: [PATCH 132/317] wip: port @vue/component-compiler-utils

---
 .github/workflows/ci.yml                      |   5 +-
 api-extractor.tsconfig.json                   |   3 +-
 package.json                                  |  37 +-
 packages/compiler-sfc/api-extractor.json      |  64 +++
 packages/compiler-sfc/package.json            |  27 +-
 packages/compiler-sfc/src/compileStyle.ts     | 143 ++++++
 packages/compiler-sfc/src/compileTemplate.ts  | 203 ++++++++
 packages/compiler-sfc/src/index.ts            |  12 +
 packages/compiler-sfc/src/parse.ts            | 112 ++++
 .../src/{parser.ts => parseComponent.ts}      |  44 +-
 .../compiler-sfc/src/stylePlugins/scoped.ts   | 207 ++++++++
 .../compiler-sfc/src/stylePlugins/trim.ts     |  18 +
 .../compiler-sfc/src/stylePreprocessors.ts    | 135 +++++
 .../src/templateCompilerModules/assetUrl.ts   |  76 +++
 .../src/templateCompilerModules/srcset.ts     |  73 +++
 .../src/templateCompilerModules/utils.ts      |  74 +++
 packages/compiler-sfc/src/types.ts            |  52 ++
 packages/compiler-sfc/src/warn.ts             |  16 +
 .../compiler-sfc/test/compileStyle.spec.ts    | 203 ++++++++
 .../compiler-sfc/test/compileTemplate.spec.ts | 230 +++++++++
 .../compiler-sfc/test/parseComponent.spec.ts  |   3 +-
 .../test/stylePluginScoped.spec.ts            | 137 +++++
 packages/compiler-sfc/test/tsconfig.json      |   7 +
 packages/server-renderer/package.json         |   2 +-
 packages/template-compiler/package.json       |   4 +-
 pnpm-lock.yaml                                | 477 +++++++++++-------
 scripts/config.js                             |  25 +-
 src/platforms/web/entry-compiler-sfc.ts       |   1 -
 src/platforms/web/entry-compiler.ts           |   2 +-
 src/types/compiler.ts                         |  23 -
 30 files changed, 2164 insertions(+), 251 deletions(-)
 create mode 100644 packages/compiler-sfc/api-extractor.json
 create mode 100644 packages/compiler-sfc/src/compileStyle.ts
 create mode 100644 packages/compiler-sfc/src/compileTemplate.ts
 create mode 100644 packages/compiler-sfc/src/index.ts
 create mode 100644 packages/compiler-sfc/src/parse.ts
 rename packages/compiler-sfc/src/{parser.ts => parseComponent.ts} (78%)
 create mode 100644 packages/compiler-sfc/src/stylePlugins/scoped.ts
 create mode 100644 packages/compiler-sfc/src/stylePlugins/trim.ts
 create mode 100644 packages/compiler-sfc/src/stylePreprocessors.ts
 create mode 100644 packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
 create mode 100644 packages/compiler-sfc/src/templateCompilerModules/srcset.ts
 create mode 100644 packages/compiler-sfc/src/templateCompilerModules/utils.ts
 create mode 100644 packages/compiler-sfc/src/types.ts
 create mode 100644 packages/compiler-sfc/src/warn.ts
 create mode 100644 packages/compiler-sfc/test/compileStyle.spec.ts
 create mode 100644 packages/compiler-sfc/test/compileTemplate.spec.ts
 rename test/unit/modules/sfc/sfc-parser.spec.ts => packages/compiler-sfc/test/parseComponent.spec.ts (98%)
 create mode 100644 packages/compiler-sfc/test/stylePluginScoped.spec.ts
 create mode 100644 packages/compiler-sfc/test/tsconfig.json
 delete mode 100644 src/platforms/web/entry-compiler-sfc.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6d46c236f61..d06717034a5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -26,7 +26,7 @@ jobs:
       - name: Run unit tests
         run: pnpm run test:unit
 
-  ssr-test:
+  ssr-sfc-test:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -45,6 +45,9 @@ jobs:
       - name: Run SSR tests
         run: pnpm run test:ssr
 
+      - name: Run compiler-sfc tests
+        run: pnpm run test:sfc
+
   e2e-test:
     runs-on: ubuntu-latest
     steps:
diff --git a/api-extractor.tsconfig.json b/api-extractor.tsconfig.json
index 39af6b8db04..ba778b35435 100644
--- a/api-extractor.tsconfig.json
+++ b/api-extractor.tsconfig.json
@@ -3,6 +3,5 @@
   "compilerOptions": {
     "baseUrl": "./temp",
     "types": []
-  },
-  "include": ["src"]
+  }
 }
diff --git a/package.json b/package.json
index fc624f93e2a..120c05e244f 100644
--- a/package.json
+++ b/package.json
@@ -41,10 +41,11 @@
     "dev:compiler": "rollup -w -c scripts/config.js --environment TARGET:compiler ",
     "build": "node scripts/build.js",
     "build:ssr": "npm run build -- runtime-cjs,server-renderer",
-    "build:types": "rimraf temp && tsc --declaration --emitDeclarationOnly --outDir temp && api-extractor run",
-    "test": "npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e && npm run test:ssr",
+    "build:types": "rimraf temp && tsc --declaration --emitDeclarationOnly --outDir temp && api-extractor run && api-extractor run -c packages/compiler-sfc/api-extractor.json",
+    "test": "npm run ts-check && npm run test:types && npm run test:unit && npm run test:e2e && npm run test:ssr && npm run test:sfc",
     "test:unit": "vitest run test/unit",
     "test:ssr": "npm run build:ssr && vitest run server-renderer",
+    "test:sfc": "vitest run compiler-sfc",
     "test:e2e": "npm run build -- full-prod,server-renderer-basic && vitest run test/e2e",
     "test:transition": "karma start test/transition/karma.conf.js",
     "test:types": "npm run build:types && tsc -p ./types/tsconfig.json",
@@ -85,45 +86,45 @@
     "csstype": "^3.1.0"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.24.2",
+    "@microsoft/api-extractor": "^7.25.0",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-commonjs": "^22.0.0",
-    "@rollup/plugin-node-resolve": "^13.2.1",
+    "@rollup/plugin-node-resolve": "^13.3.0",
     "@rollup/plugin-replace": "^4.0.0",
     "@types/he": "^1.1.2",
-    "@types/node": "^17.0.30",
-    "chalk": "^4.0.0",
+    "@types/node": "^17.0.41",
+    "chalk": "^4.1.2",
     "conventional-changelog-cli": "^2.2.2",
     "cross-spawn": "^7.0.3",
-    "de-indent": "^1.0.2",
     "enquirer": "^2.3.6",
-    "esbuild": "^0.14.39",
-    "execa": "^4.0.0",
+    "esbuild": "^0.14.43",
+    "execa": "^4.1.0",
     "he": "^1.2.0",
-    "jasmine-core": "^4.1.1",
+    "jasmine-core": "^4.2.0",
     "jsdom": "^19.0.0",
     "karma": "^6.3.20",
     "karma-chrome-launcher": "^3.1.1",
     "karma-cli": "^2.0.0",
     "karma-esbuild": "^2.2.4",
     "karma-jasmine": "^5.0.1",
-    "lint-staged": "^12.4.1",
+    "lint-staged": "^12.5.0",
+    "postcss": "^8.4.14",
     "lodash": "^4.17.21",
-    "marked": "^4.0.6",
+    "marked": "^4.0.16",
     "minimist": "^1.2.6",
     "prettier": "^2.6.2",
-    "puppeteer": "^14.1.1",
+    "puppeteer": "^14.3.0",
     "rimraf": "^3.0.2",
-    "rollup": "^2.70.2",
+    "rollup": "^2.75.6",
     "rollup-plugin-typescript2": "^0.31.2",
     "semver": "^7.3.7",
     "shelljs": "^0.8.5",
-    "terser": "^5.13.1",
+    "terser": "^5.14.0",
     "todomvc-app-css": "^2.4.2",
-    "ts-node": "^10.7.0",
+    "ts-node": "^10.8.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.6.4",
-    "vitest": "^0.12.6",
+    "typescript": "^4.7.3",
+    "vitest": "^0.12.10",
     "yorkie": "^2.0.0"
   }
 }
diff --git a/packages/compiler-sfc/api-extractor.json b/packages/compiler-sfc/api-extractor.json
new file mode 100644
index 00000000000..eda03ee2119
--- /dev/null
+++ b/packages/compiler-sfc/api-extractor.json
@@ -0,0 +1,64 @@
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+
+  "projectFolder": ".",
+
+  "mainEntryPointFilePath": "../../temp/packages/compiler-sfc/src/index.d.ts",
+
+  "compiler": {
+    "tsconfigFilePath": "../../api-extractor.tsconfig.json"
+  },
+
+  "dtsRollup": {
+    "enabled": true,
+    "untrimmedFilePath": "",
+    "publicTrimmedFilePath": "./dist/compiler-sfc.d.ts"
+  },
+
+  "apiReport": {
+    "enabled": false
+  },
+
+  "docModel": {
+    "enabled": false
+  },
+
+  "tsdocMetadata": {
+    "enabled": false
+  },
+
+  "messages": {
+    "compilerMessageReporting": {
+      "default": {
+        "logLevel": "warning"
+      }
+    },
+
+    "extractorMessageReporting": {
+      "default": {
+        "logLevel": "warning",
+        "addToApiReportFile": true
+      },
+
+      "ae-missing-release-tag": {
+        "logLevel": "none"
+      },
+      "ae-internal-missing-underscore": {
+        "logLevel": "none"
+      },
+      "ae-forgotten-export": {
+        "logLevel": "none"
+      }
+    },
+
+    "tsdocMessageReporting": {
+      "default": {
+        "logLevel": "warning"
+      },
+
+      "tsdoc-undefined-tag": {
+        "logLevel": "none"
+      }
+    }
+  }
+}
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 7d6c91284b1..802bba8d19e 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -8,23 +8,28 @@
     "dist"
   ],
   "dependencies": {
-    "@babel/parser": "^7.16.4",
-    "source-map": "^0.6.1",
-    "postcss": "^8.1.10"
+    "@babel/parser": "^7.18.4",
+    "postcss": "^8.4.14",
+    "source-map": "^0.6.1"
   },
   "devDependencies": {
+    "@babel/types": "^7.18.4",
     "@types/estree": "^0.0.48",
-    "@babel/types": "^7.16.0",
-    "@types/lru-cache": "^5.1.0",
-    "estree-walker": "^2.0.2",
-    "magic-string": "^0.25.7",
-    "pug": "^3.0.1",
-    "sass": "^1.26.9",
+    "@types/hash-sum": "^1.0.0",
+    "@types/lru-cache": "^5.1.1",
     "@vue/consolidate": "^0.17.3",
+    "de-indent": "^1.0.2",
+    "estree-walker": "^2.0.2",
     "hash-sum": "^2.0.0",
+    "less": "^4.1.3",
     "lru-cache": "^5.1.1",
+    "magic-string": "^0.25.9",
     "merge-source-map": "^1.1.0",
-    "postcss-modules": "^4.0.0",
-    "postcss-selector-parser": "^6.0.4"
+    "postcss-modules": "^4.3.1",
+    "postcss-selector-parser": "^6.0.10",
+    "pug": "^3.0.2",
+    "sass": "^1.52.3",
+    "stylus": "^0.58.1",
+    "vue-template-es2015-compiler": "^1.9.1"
   }
 }
diff --git a/packages/compiler-sfc/src/compileStyle.ts b/packages/compiler-sfc/src/compileStyle.ts
new file mode 100644
index 00000000000..8418afc7483
--- /dev/null
+++ b/packages/compiler-sfc/src/compileStyle.ts
@@ -0,0 +1,143 @@
+const postcss = require('postcss')
+import { ProcessOptions, LazyResult } from 'postcss'
+import trimPlugin from './stylePlugins/trim'
+import scopedPlugin from './stylePlugins/scoped'
+import {
+  processors,
+  StylePreprocessor,
+  StylePreprocessorResults
+} from './stylePreprocessors'
+
+export interface StyleCompileOptions {
+  source: string
+  filename: string
+  id: string
+  map?: any
+  scoped?: boolean
+  trim?: boolean
+  preprocessLang?: string
+  preprocessOptions?: any
+  postcssOptions?: any
+  postcssPlugins?: any[]
+}
+
+export interface AsyncStyleCompileOptions extends StyleCompileOptions {
+  isAsync?: boolean
+}
+
+export interface StyleCompileResults {
+  code: string
+  map: any | void
+  rawResult: LazyResult | void
+  errors: string[]
+}
+
+export function compileStyle(
+  options: StyleCompileOptions
+): StyleCompileResults {
+  return doCompileStyle({ ...options, isAsync: false })
+}
+
+export function compileStyleAsync(
+  options: StyleCompileOptions
+): Promise<StyleCompileResults> {
+  return Promise.resolve(doCompileStyle({ ...options, isAsync: true }))
+}
+
+export function doCompileStyle(
+  options: AsyncStyleCompileOptions
+): StyleCompileResults {
+  const {
+    filename,
+    id,
+    scoped = true,
+    trim = true,
+    preprocessLang,
+    postcssOptions,
+    postcssPlugins
+  } = options
+  const preprocessor = preprocessLang && processors[preprocessLang]
+  const preProcessedSource = preprocessor && preprocess(options, preprocessor)
+  const map = preProcessedSource ? preProcessedSource.map : options.map
+  const source = preProcessedSource ? preProcessedSource.code : options.source
+
+  const plugins = (postcssPlugins || []).slice()
+  if (trim) {
+    plugins.push(trimPlugin())
+  }
+  if (scoped) {
+    plugins.push(scopedPlugin(id))
+  }
+
+  const postCSSOptions: ProcessOptions = {
+    ...postcssOptions,
+    to: filename,
+    from: filename
+  }
+  if (map) {
+    postCSSOptions.map = {
+      inline: false,
+      annotation: false,
+      prev: map
+    }
+  }
+
+  let result, code, outMap
+  const errors: any[] = []
+  if (preProcessedSource && preProcessedSource.errors.length) {
+    errors.push(...preProcessedSource.errors)
+  }
+  try {
+    result = postcss(plugins).process(source, postCSSOptions)
+
+    // In async mode, return a promise.
+    if (options.isAsync) {
+      return result
+        .then(
+          (result: LazyResult): StyleCompileResults => ({
+            code: result.css || '',
+            map: result.map && result.map.toJSON(),
+            errors,
+            rawResult: result
+          })
+        )
+        .catch(
+          (error: Error): StyleCompileResults => ({
+            code: '',
+            map: undefined,
+            errors: [...errors, error.message],
+            rawResult: undefined
+          })
+        )
+    }
+
+    // force synchronous transform (we know we only have sync plugins)
+    code = result.css
+    outMap = result.map
+  } catch (e) {
+    errors.push(e)
+  }
+
+  return {
+    code: code || ``,
+    map: outMap && outMap.toJSON(),
+    errors,
+    rawResult: result
+  }
+}
+
+function preprocess(
+  options: StyleCompileOptions,
+  preprocessor: StylePreprocessor
+): StylePreprocessorResults {
+  return preprocessor(
+    options.source,
+    options.map,
+    Object.assign(
+      {
+        filename: options.filename
+      },
+      options.preprocessOptions
+    )
+  )
+}
diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
new file mode 100644
index 00000000000..8d768aa97b4
--- /dev/null
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -0,0 +1,203 @@
+import {
+  VueTemplateCompiler,
+  VueTemplateCompilerOptions,
+  ErrorWithRange
+} from './types'
+import assetUrlsModule, {
+  AssetURLOptions,
+  TransformAssetUrlsOptions
+} from './templateCompilerModules/assetUrl'
+import srcsetModule from './templateCompilerModules/srcset'
+import consolidate from '@vue/consolidate'
+import * as _compiler from 'web/entry-compiler'
+import transpile from 'vue-template-es2015-compiler'
+
+export interface TemplateCompileOptions {
+  source: string
+  filename: string
+  compiler?: VueTemplateCompiler
+  compilerOptions?: VueTemplateCompilerOptions
+  transformAssetUrls?: AssetURLOptions | boolean
+  transformAssetUrlsOptions?: TransformAssetUrlsOptions
+  preprocessLang?: string
+  preprocessOptions?: any
+  transpileOptions?: any
+  isProduction?: boolean
+  isFunctional?: boolean
+  optimizeSSR?: boolean
+  prettify?: boolean
+}
+
+export interface TemplateCompileResult {
+  ast: Object | undefined
+  code: string
+  source: string
+  tips: (string | ErrorWithRange)[]
+  errors: (string | ErrorWithRange)[]
+}
+
+export function compileTemplate(
+  options: TemplateCompileOptions
+): TemplateCompileResult {
+  const { preprocessLang } = options
+  const preprocessor = preprocessLang && consolidate[preprocessLang]
+  if (preprocessor) {
+    return actuallyCompile(
+      Object.assign({}, options, {
+        source: preprocess(options, preprocessor)
+      })
+    )
+  } else if (preprocessLang) {
+    return {
+      ast: {},
+      code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
+      source: options.source,
+      tips: [
+        `Component ${options.filename} uses lang ${preprocessLang} for template. Please install the language preprocessor.`
+      ],
+      errors: [
+        `Component ${options.filename} uses lang ${preprocessLang} for template, however it is not installed.`
+      ]
+    }
+  } else {
+    return actuallyCompile(options)
+  }
+}
+
+function preprocess(
+  options: TemplateCompileOptions,
+  preprocessor: any
+): string {
+  const { source, filename, preprocessOptions } = options
+
+  const finalPreprocessOptions = Object.assign(
+    {
+      filename
+    },
+    preprocessOptions
+  )
+
+  // Consolidate exposes a callback based API, but the callback is in fact
+  // called synchronously for most templating engines. In our case, we have to
+  // expose a synchronous API so that it is usable in Jest transforms (which
+  // have to be sync because they are applied via Node.js require hooks)
+  let res: any, err
+  preprocessor.render(
+    source,
+    finalPreprocessOptions,
+    (_err: Error | null, _res: string) => {
+      if (_err) err = _err
+      res = _res
+    }
+  )
+
+  if (err) throw err
+  return res
+}
+
+function actuallyCompile(
+  options: TemplateCompileOptions
+): TemplateCompileResult {
+  const {
+    source,
+    compiler = _compiler,
+    compilerOptions = {},
+    transpileOptions = {},
+    transformAssetUrls,
+    transformAssetUrlsOptions,
+    isProduction = process.env.NODE_ENV === 'production',
+    isFunctional = false,
+    optimizeSSR = false,
+    prettify = true
+  } = options
+
+  const compile =
+    optimizeSSR && compiler.ssrCompile ? compiler.ssrCompile : compiler.compile
+
+  let finalCompilerOptions = compilerOptions
+  if (transformAssetUrls) {
+    const builtInModules = [
+      transformAssetUrls === true
+        ? assetUrlsModule(undefined, transformAssetUrlsOptions)
+        : assetUrlsModule(transformAssetUrls, transformAssetUrlsOptions),
+      srcsetModule(transformAssetUrlsOptions)
+    ]
+    finalCompilerOptions = Object.assign({}, compilerOptions, {
+      modules: [...builtInModules, ...(compilerOptions.modules || [])],
+      filename: options.filename
+    })
+  }
+
+  const { ast, render, staticRenderFns, tips, errors } = compile(
+    source,
+    finalCompilerOptions
+  )
+
+  if (errors && errors.length) {
+    return {
+      ast,
+      code: `var render = function () {}\n` + `var staticRenderFns = []\n`,
+      source,
+      tips,
+      errors
+    }
+  } else {
+    // TODO better transpile
+    const finalTranspileOptions = Object.assign({}, transpileOptions, {
+      transforms: Object.assign({}, transpileOptions.transforms, {
+        stripWithFunctional: isFunctional
+      })
+    })
+
+    const toFunction = (code: string): string => {
+      return `function (${isFunctional ? `_h,_vm` : ``}) {${code}}`
+    }
+
+    // transpile code with vue-template-es2015-compiler, which is a forked
+    // version of Buble that applies ES2015 transforms + stripping `with` usage
+    let code =
+      transpile(
+        `var __render__ = ${toFunction(render)}\n` +
+          `var __staticRenderFns__ = [${staticRenderFns.map(toFunction)}]`,
+        finalTranspileOptions
+      ) + `\n`
+
+    // #23 we use __render__ to avoid `render` not being prefixed by the
+    // transpiler when stripping with, but revert it back to `render` to
+    // maintain backwards compat
+    code = code.replace(/\s__(render|staticRenderFns)__\s/g, ' $1 ')
+
+    if (!isProduction) {
+      // mark with stripped (this enables Vue to use correct runtime proxy
+      // detection)
+      code += `render._withStripped = true`
+
+      if (prettify) {
+        try {
+          code = require('prettier').format(code, {
+            semi: false,
+            parser: 'babel'
+          })
+        } catch (e: any) {
+          if (e.code === 'MODULE_NOT_FOUND') {
+            tips.push(
+              'The `prettify` option is on, but the dependency `prettier` is not found.\n' +
+                'Please either turn off `prettify` or manually install `prettier`.'
+            )
+          }
+          tips.push(
+            `Failed to prettify component ${options.filename} template source after compilation.`
+          )
+        }
+      }
+    }
+
+    return {
+      ast,
+      code,
+      source,
+      tips,
+      errors
+    }
+  }
+}
diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
new file mode 100644
index 00000000000..b8dee97641c
--- /dev/null
+++ b/packages/compiler-sfc/src/index.ts
@@ -0,0 +1,12 @@
+// API
+export { parse } from './parse'
+export { compileTemplate } from './compileTemplate'
+export { compileStyle, compileStyleAsync } from './compileStyle'
+
+// types
+export { SFCBlock, SFCCustomBlock, SFCDescriptor } from './parseComponent'
+export {
+  TemplateCompileOptions,
+  TemplateCompileResult
+} from './compileTemplate'
+export { StyleCompileOptions, StyleCompileResults } from './compileStyle'
diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
new file mode 100644
index 00000000000..2c2aca2ea31
--- /dev/null
+++ b/packages/compiler-sfc/src/parse.ts
@@ -0,0 +1,112 @@
+import { SourceMapGenerator } from 'source-map'
+import { RawSourceMap, VueTemplateCompiler } from './types'
+import {
+  parseComponent,
+  VueTemplateCompilerParseOptions,
+  SFCDescriptor
+} from './parseComponent'
+
+import hash from 'hash-sum'
+import LRU from 'lru-cache'
+
+const cache = new LRU<string, SFCDescriptor>(100)
+
+const splitRE = /\r?\n/g
+const emptyRE = /^(?:\/\/)?\s*$/
+
+export interface ParseOptions {
+  source: string
+  filename?: string
+  compiler?: VueTemplateCompiler
+  compilerParseOptions?: VueTemplateCompilerParseOptions
+  sourceRoot?: string
+  needMap?: boolean
+}
+
+export function parse(options: ParseOptions): SFCDescriptor {
+  const {
+    source,
+    filename = '',
+    compiler,
+    compilerParseOptions = { pad: 'line' } as VueTemplateCompilerParseOptions,
+    sourceRoot = '',
+    needMap = true
+  } = options
+  const cacheKey = hash(
+    filename + source + JSON.stringify(compilerParseOptions)
+  )
+
+  let output = cache.get(cacheKey)
+  if (output) {
+    return output
+  }
+
+  if (compiler) {
+    // user-provided compiler
+    output = compiler.parseComponent(source, compilerParseOptions)
+  } else {
+    // use built-in compiler
+    output = parseComponent(source, compilerParseOptions)
+  }
+
+  if (needMap) {
+    if (output.script && !output.script.src) {
+      output.script.map = generateSourceMap(
+        filename,
+        source,
+        output.script.content,
+        sourceRoot,
+        compilerParseOptions.pad
+      )
+    }
+    if (output.styles) {
+      output.styles.forEach(style => {
+        if (!style.src) {
+          style.map = generateSourceMap(
+            filename,
+            source,
+            style.content,
+            sourceRoot,
+            compilerParseOptions.pad
+          )
+        }
+      })
+    }
+  }
+  cache.set(cacheKey, output)
+  return output
+}
+
+function generateSourceMap(
+  filename: string,
+  source: string,
+  generated: string,
+  sourceRoot: string,
+  pad?: 'line' | 'space' | boolean
+): RawSourceMap {
+  const map = new SourceMapGenerator({
+    file: filename.replace(/\\/g, '/'),
+    sourceRoot: sourceRoot.replace(/\\/g, '/')
+  })
+  let offset = 0
+  if (!pad) {
+    offset = source.split(generated).shift()!.split(splitRE).length - 1
+  }
+  map.setSourceContent(filename, source)
+  generated.split(splitRE).forEach((line, index) => {
+    if (!emptyRE.test(line)) {
+      map.addMapping({
+        source: filename,
+        original: {
+          line: index + 1 + offset,
+          column: 0
+        },
+        generated: {
+          line: index + 1,
+          column: 0
+        }
+      })
+    }
+  })
+  return JSON.parse(map.toString())
+}
diff --git a/packages/compiler-sfc/src/parser.ts b/packages/compiler-sfc/src/parseComponent.ts
similarity index 78%
rename from packages/compiler-sfc/src/parser.ts
rename to packages/compiler-sfc/src/parseComponent.ts
index b39d943245c..a911824062e 100644
--- a/packages/compiler-sfc/src/parser.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -1,23 +1,49 @@
 import deindent from 'de-indent'
 import { parseHTML } from 'compiler/parser/html-parser'
 import { makeMap } from 'shared/util'
-import {
-  ASTAttr,
-  SFCBlock,
-  SFCDescriptor,
-  WarningMessage
-} from 'types/compiler'
+import { ASTAttr, WarningMessage } from 'types/compiler'
+import { RawSourceMap } from './types'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
 const isSpecialTag = makeMap('script,style,template', true)
 
+export interface SFCCustomBlock {
+  type: string
+  content: string
+  attrs: { [key: string]: string | true }
+  start: number
+  end?: number
+  map?: RawSourceMap
+}
+
+export interface SFCBlock extends SFCCustomBlock {
+  lang?: string
+  src?: string
+  scoped?: boolean
+  module?: string | boolean
+}
+
+export interface SFCDescriptor {
+  template: SFCBlock | null
+  script: SFCBlock | null
+  styles: SFCBlock[]
+  customBlocks: SFCCustomBlock[]
+  errors: WarningMessage[]
+}
+
+export interface VueTemplateCompilerParseOptions {
+  pad?: 'line' | 'space' | boolean
+  deindent?: boolean
+  outputSourceRange?: boolean
+}
+
 /**
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
 export function parseComponent(
   content: string,
-  options: Record<string, any> = {}
+  options: VueTemplateCompilerParseOptions = {}
 ): SFCDescriptor {
   const sfc: SFCDescriptor = {
     template: null,
@@ -48,7 +74,7 @@ export function parseComponent(
 
   function start(
     tag: string,
-    attrs: Array<ASTAttr>,
+    attrs: ASTAttr[],
     unary: boolean,
     start: number,
     end: number
@@ -80,7 +106,7 @@ export function parseComponent(
     }
   }
 
-  function checkAttrs(block: SFCBlock, attrs: Array<ASTAttr>) {
+  function checkAttrs(block: SFCBlock, attrs: ASTAttr[]) {
     for (let i = 0; i < attrs.length; i++) {
       const attr = attrs[i]
       if (attr.name === 'lang') {
diff --git a/packages/compiler-sfc/src/stylePlugins/scoped.ts b/packages/compiler-sfc/src/stylePlugins/scoped.ts
new file mode 100644
index 00000000000..1dcc248ad71
--- /dev/null
+++ b/packages/compiler-sfc/src/stylePlugins/scoped.ts
@@ -0,0 +1,207 @@
+import { PluginCreator, Rule, AtRule } from 'postcss'
+import selectorParser from 'postcss-selector-parser'
+import { warn } from '../warn'
+
+const animationNameRE = /^(-\w+-)?animation-name$/
+const animationRE = /^(-\w+-)?animation$/
+
+const scopedPlugin: PluginCreator<string> = (id = '') => {
+  const keyframes = Object.create(null)
+  const shortId = id.replace(/^data-v-/, '')
+
+  return {
+    postcssPlugin: 'vue-sfc-scoped',
+    Rule(rule) {
+      processRule(id, rule)
+    },
+    AtRule(node) {
+      if (
+        /-?keyframes$/.test(node.name) &&
+        !node.params.endsWith(`-${shortId}`)
+      ) {
+        // register keyframes
+        keyframes[node.params] = node.params = node.params + '-' + shortId
+      }
+    },
+    OnceExit(root) {
+      if (Object.keys(keyframes).length) {
+        // If keyframes are found in this <style>, find and rewrite animation names
+        // in declarations.
+        // Caveat: this only works for keyframes and animation rules in the same
+        // <style> element.
+        // individual animation-name declaration
+        root.walkDecls(decl => {
+          if (animationNameRE.test(decl.prop)) {
+            decl.value = decl.value
+              .split(',')
+              .map(v => keyframes[v.trim()] || v.trim())
+              .join(',')
+          }
+          // shorthand
+          if (animationRE.test(decl.prop)) {
+            decl.value = decl.value
+              .split(',')
+              .map(v => {
+                const vals = v.trim().split(/\s+/)
+                const i = vals.findIndex(val => keyframes[val])
+                if (i !== -1) {
+                  vals.splice(i, 1, keyframes[vals[i]])
+                  return vals.join(' ')
+                } else {
+                  return v
+                }
+              })
+              .join(',')
+          }
+        })
+      }
+    }
+  }
+}
+
+const processedRules = new WeakSet<Rule>()
+
+function processRule(id: string, rule: Rule) {
+  if (
+    processedRules.has(rule) ||
+    (rule.parent &&
+      rule.parent.type === 'atrule' &&
+      /-?keyframes$/.test((rule.parent as AtRule).name))
+  ) {
+    return
+  }
+  processedRules.add(rule)
+  rule.selector = selectorParser(selectorRoot => {
+    selectorRoot.each(selector => {
+      rewriteSelector(id, selector, selectorRoot)
+    })
+  }).processSync(rule.selector)
+}
+
+function rewriteSelector(
+  id: string,
+  selector: selectorParser.Selector,
+  selectorRoot: selectorParser.Root,
+  slotted = false
+) {
+  let node: selectorParser.Node | null = null
+  let shouldInject = true
+  // find the last child node to insert attribute selector
+  selector.each(n => {
+    // DEPRECATED ">>>" and "/deep/" combinator
+    if (
+      n.type === 'combinator' &&
+      (n.value === '>>>' || n.value === '/deep/')
+    ) {
+      n.value = ' '
+      n.spaces.before = n.spaces.after = ''
+      warn(
+        `the >>> and /deep/ combinators have been deprecated. ` +
+          `Use :deep() instead.`
+      )
+      return false
+    }
+
+    if (n.type === 'pseudo') {
+      const { value } = n
+      // deep: inject [id] attribute at the node before the ::v-deep
+      // combinator.
+      if (value === ':deep' || value === '::v-deep') {
+        if (n.nodes.length) {
+          // .foo ::v-deep(.bar) -> .foo[xxxxxxx] .bar
+          // replace the current node with ::v-deep's inner selector
+          let last: selectorParser.Selector['nodes'][0] = n
+          n.nodes[0].each(ss => {
+            selector.insertAfter(last, ss)
+            last = ss
+          })
+          // insert a space combinator before if it doesn't already have one
+          const prev = selector.at(selector.index(n) - 1)
+          if (!prev || !isSpaceCombinator(prev)) {
+            selector.insertAfter(
+              n,
+              selectorParser.combinator({
+                value: ' '
+              })
+            )
+          }
+          selector.removeChild(n)
+        } else {
+          // DEPRECATED usage
+          // .foo ::v-deep .bar -> .foo[xxxxxxx] .bar
+          warn(
+            `::v-deep usage as a combinator has ` +
+              `been deprecated. Use :deep(<inner-selector>) instead.`
+          )
+          const prev = selector.at(selector.index(n) - 1)
+          if (prev && isSpaceCombinator(prev)) {
+            selector.removeChild(prev)
+          }
+          selector.removeChild(n)
+        }
+        return false
+      }
+
+      // slot: use selector inside `::v-slotted` and inject [id + '-s']
+      // instead.
+      // ::v-slotted(.foo) -> .foo[xxxxxxx-s]
+      if (value === ':slotted' || value === '::v-slotted') {
+        rewriteSelector(id, n.nodes[0], selectorRoot, true /* slotted */)
+        let last: selectorParser.Selector['nodes'][0] = n
+        n.nodes[0].each(ss => {
+          selector.insertAfter(last, ss)
+          last = ss
+        })
+        // selector.insertAfter(n, n.nodes[0])
+        selector.removeChild(n)
+        // since slotted attribute already scopes the selector there's no
+        // need for the non-slot attribute.
+        shouldInject = false
+        return false
+      }
+
+      // global: replace with inner selector and do not inject [id].
+      // ::v-global(.foo) -> .foo
+      if (value === ':global' || value === '::v-global') {
+        selectorRoot.insertAfter(selector, n.nodes[0])
+        selectorRoot.removeChild(selector)
+        return false
+      }
+    }
+
+    if (n.type !== 'pseudo' && n.type !== 'combinator') {
+      node = n
+    }
+  })
+
+  if (node) {
+    ;(node as selectorParser.Node).spaces.after = ''
+  } else {
+    // For deep selectors & standalone pseudo selectors,
+    // the attribute selectors are prepended rather than appended.
+    // So all leading spaces must be eliminated to avoid problems.
+    selector.first.spaces.before = ''
+  }
+
+  if (shouldInject) {
+    const idToAdd = slotted ? id + '-s' : id
+    selector.insertAfter(
+      // If node is null it means we need to inject [id] at the start
+      // insertAfter can handle `null` here
+      node as any,
+      selectorParser.attribute({
+        attribute: idToAdd,
+        value: idToAdd,
+        raws: {},
+        quoteMark: `"`
+      })
+    )
+  }
+}
+
+function isSpaceCombinator(node: selectorParser.Node) {
+  return node.type === 'combinator' && /^\s+$/.test(node.value)
+}
+
+scopedPlugin.postcss = true
+export default scopedPlugin
diff --git a/packages/compiler-sfc/src/stylePlugins/trim.ts b/packages/compiler-sfc/src/stylePlugins/trim.ts
new file mode 100644
index 00000000000..67c4a3f0f35
--- /dev/null
+++ b/packages/compiler-sfc/src/stylePlugins/trim.ts
@@ -0,0 +1,18 @@
+import { PluginCreator } from 'postcss'
+
+const trimPlugin: PluginCreator<{}> = () => {
+  return {
+    postcssPlugin: 'vue-sfc-trim',
+    Once(root) {
+      root.walk(({ type, raws }) => {
+        if (type === 'rule' || type === 'atrule') {
+          if (raws.before) raws.before = '\n'
+          if ('after' in raws && raws.after) raws.after = '\n'
+        }
+      })
+    }
+  }
+}
+
+trimPlugin.postcss = true
+export default trimPlugin
diff --git a/packages/compiler-sfc/src/stylePreprocessors.ts b/packages/compiler-sfc/src/stylePreprocessors.ts
new file mode 100644
index 00000000000..b59ea302e72
--- /dev/null
+++ b/packages/compiler-sfc/src/stylePreprocessors.ts
@@ -0,0 +1,135 @@
+import merge from 'merge-source-map'
+import { RawSourceMap } from 'source-map'
+import { isFunction } from 'shared/util'
+
+export type StylePreprocessor = (
+  source: string,
+  map: RawSourceMap | undefined,
+  options: {
+    [key: string]: any
+    additionalData?: string | ((source: string, filename: string) => string)
+    filename: string
+  }
+) => StylePreprocessorResults
+
+export interface StylePreprocessorResults {
+  code: string
+  map?: object
+  errors: Error[]
+  dependencies: string[]
+}
+
+// .scss/.sass processor
+const scss: StylePreprocessor = (source, map, options) => {
+  const nodeSass = require('sass')
+  const finalOptions = {
+    ...options,
+    data: getSource(source, options.filename, options.additionalData),
+    file: options.filename,
+    outFile: options.filename,
+    sourceMap: !!map
+  }
+
+  try {
+    const result = nodeSass.renderSync(finalOptions)
+    const dependencies = result.stats.includedFiles
+    if (map) {
+      return {
+        code: result.css.toString(),
+        map: merge(map, JSON.parse(result.map.toString())),
+        errors: [],
+        dependencies
+      }
+    }
+
+    return { code: result.css.toString(), errors: [], dependencies }
+  } catch (e: any) {
+    return { code: '', errors: [e], dependencies: [] }
+  }
+}
+
+const sass: StylePreprocessor = (source, map, options) =>
+  scss(source, map, {
+    ...options,
+    indentedSyntax: true
+  })
+
+// .less
+const less: StylePreprocessor = (source, map, options) => {
+  const nodeLess = require('less')
+
+  let result: any
+  let error: Error | null = null
+  nodeLess.render(
+    getSource(source, options.filename, options.additionalData),
+    { ...options, syncImport: true },
+    (err: Error | null, output: any) => {
+      error = err
+      result = output
+    }
+  )
+
+  if (error) return { code: '', errors: [error], dependencies: [] }
+  const dependencies = result.imports
+  if (map) {
+    return {
+      code: result.css.toString(),
+      map: merge(map, result.map),
+      errors: [],
+      dependencies: dependencies
+    }
+  }
+
+  return {
+    code: result.css.toString(),
+    errors: [],
+    dependencies: dependencies
+  }
+}
+
+// .styl
+const styl: StylePreprocessor = (source, map, options) => {
+  const nodeStylus = require('stylus')
+  try {
+    const ref = nodeStylus(source)
+    Object.keys(options).forEach(key => ref.set(key, options[key]))
+    if (map) ref.set('sourcemap', { inline: false, comment: false })
+
+    const result = ref.render()
+    const dependencies = ref.deps()
+    if (map) {
+      return {
+        code: result,
+        map: merge(map, ref.sourcemap),
+        errors: [],
+        dependencies
+      }
+    }
+
+    return { code: result, errors: [], dependencies }
+  } catch (e: any) {
+    return { code: '', errors: [e], dependencies: [] }
+  }
+}
+
+function getSource(
+  source: string,
+  filename: string,
+  additionalData?: string | ((source: string, filename: string) => string)
+) {
+  if (!additionalData) return source
+  if (isFunction(additionalData)) {
+    return additionalData(source, filename)
+  }
+  return additionalData + source
+}
+
+export type PreprocessLang = 'less' | 'sass' | 'scss' | 'styl' | 'stylus'
+
+export const processors: Record<PreprocessLang, StylePreprocessor> = {
+  less,
+  sass,
+  scss,
+  styl,
+  stylus: styl
+}
diff --git a/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts b/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
new file mode 100644
index 00000000000..3bc490af368
--- /dev/null
+++ b/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
@@ -0,0 +1,76 @@
+// vue compiler module for transforming `<tag>:<attribute>` to `require`
+
+import { urlToRequire, ASTNode, Attr } from './utils'
+
+export interface AssetURLOptions {
+  [name: string]: string | string[]
+}
+
+export interface TransformAssetUrlsOptions {
+  /**
+   * If base is provided, instead of transforming relative asset urls into
+   * imports, they will be directly rewritten to absolute urls.
+   */
+  base?: string
+}
+
+const defaultOptions: AssetURLOptions = {
+  audio: 'src',
+  video: ['src', 'poster'],
+  source: 'src',
+  img: 'src',
+  image: ['xlink:href', 'href'],
+  use: ['xlink:href', 'href']
+}
+
+export default (
+  userOptions?: AssetURLOptions,
+  transformAssetUrlsOption?: TransformAssetUrlsOptions
+) => {
+  const options = userOptions
+    ? Object.assign({}, defaultOptions, userOptions)
+    : defaultOptions
+
+  return {
+    postTransformNode: (node: ASTNode) => {
+      transform(node, options, transformAssetUrlsOption)
+    }
+  }
+}
+
+function transform(
+  node: ASTNode,
+  options: AssetURLOptions,
+  transformAssetUrlsOption?: TransformAssetUrlsOptions
+) {
+  for (const tag in options) {
+    if ((tag === '*' || node.tag === tag) && node.attrs) {
+      const attributes = options[tag]
+      if (typeof attributes === 'string') {
+        node.attrs.some(attr =>
+          rewrite(attr, attributes, transformAssetUrlsOption)
+        )
+      } else if (Array.isArray(attributes)) {
+        attributes.forEach(item =>
+          node.attrs.some(attr => rewrite(attr, item, transformAssetUrlsOption))
+        )
+      }
+    }
+  }
+}
+
+function rewrite(
+  attr: Attr,
+  name: string,
+  transformAssetUrlsOption?: TransformAssetUrlsOptions
+) {
+  if (attr.name === name) {
+    const value = attr.value
+    // only transform static URLs
+    if (value.charAt(0) === '"' && value.charAt(value.length - 1) === '"') {
+      attr.value = urlToRequire(value.slice(1, -1), transformAssetUrlsOption)
+      return true
+    }
+  }
+  return false
+}
diff --git a/packages/compiler-sfc/src/templateCompilerModules/srcset.ts b/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
new file mode 100644
index 00000000000..7f66ab347b3
--- /dev/null
+++ b/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
@@ -0,0 +1,73 @@
+// vue compiler module for transforming `img:srcset` to a number of `require`s
+
+import { urlToRequire, ASTNode } from './utils'
+import { TransformAssetUrlsOptions } from './assetUrl'
+
+interface ImageCandidate {
+  require: string
+  descriptor: string
+}
+
+export default (transformAssetUrlsOptions?: TransformAssetUrlsOptions) => ({
+  postTransformNode: (node: ASTNode) => {
+    transform(node, transformAssetUrlsOptions)
+  }
+})
+
+// http://w3c.github.io/html/semantics-embedded-content.html#ref-for-image-candidate-string-5
+const escapedSpaceCharacters = /( |\\t|\\n|\\f|\\r)+/g
+
+function transform(
+  node: ASTNode,
+  transformAssetUrlsOptions?: TransformAssetUrlsOptions
+) {
+  const tags = ['img', 'source']
+
+  if (tags.indexOf(node.tag) !== -1 && node.attrs) {
+    node.attrs.forEach(attr => {
+      if (attr.name === 'srcset') {
+        // same logic as in transform-require.js
+        const value = attr.value
+        const isStatic =
+          value.charAt(0) === '"' && value.charAt(value.length - 1) === '"'
+        if (!isStatic) {
+          return
+        }
+
+        const imageCandidates: ImageCandidate[] = value
+          .substr(1, value.length - 2)
+          .split(',')
+          .map(s => {
+            // The attribute value arrives here with all whitespace, except
+            // normal spaces, represented by escape sequences
+            const [url, descriptor] = s
+              .replace(escapedSpaceCharacters, ' ')
+              .trim()
+              .split(' ', 2)
+            return {
+              require: urlToRequire(url, transformAssetUrlsOptions),
+              descriptor
+            }
+          })
+
+        // "require(url1)"
+        // "require(url1) 1x"
+        // "require(url1), require(url2)"
+        // "require(url1), require(url2) 2x"
+        // "require(url1) 1x, require(url2)"
+        // "require(url1) 1x, require(url2) 2x"
+        const code = imageCandidates
+          .map(
+            ({ require, descriptor }) =>
+              `${require} + "${descriptor ? ' ' + descriptor : ''}, " + `
+          )
+          .join('')
+          .slice(0, -6)
+          .concat('"')
+          .replace(/ \+ ""$/, '')
+
+        attr.value = code
+      }
+    })
+  }
+}
diff --git a/packages/compiler-sfc/src/templateCompilerModules/utils.ts b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
new file mode 100644
index 00000000000..f81862cf82f
--- /dev/null
+++ b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
@@ -0,0 +1,74 @@
+import { TransformAssetUrlsOptions } from './assetUrl'
+import { UrlWithStringQuery, parse as uriParse } from 'url'
+import path from 'path'
+
+export interface Attr {
+  name: string
+  value: string
+}
+
+export interface ASTNode {
+  tag: string
+  attrs: Attr[]
+}
+
+export function urlToRequire(
+  url: string,
+  transformAssetUrlsOption: TransformAssetUrlsOptions = {}
+): string {
+  const returnValue = `"${url}"`
+  // same logic as in transform-require.js
+  const firstChar = url.charAt(0)
+  if (firstChar === '~') {
+    const secondChar = url.charAt(1)
+    url = url.slice(secondChar === '/' ? 2 : 1)
+  }
+
+  const uriParts = parseUriParts(url)
+
+  if (transformAssetUrlsOption.base) {
+    // explicit base - directly rewrite the url into absolute url
+    // does not apply to absolute urls or urls that start with `@`
+    // since they are aliases
+    if (firstChar === '.' || firstChar === '~') {
+      // when packaged in the browser, path will be using the posix-
+      // only version provided by rollup-plugin-node-builtins.
+      return `"${(path.posix || path).join(
+        transformAssetUrlsOption.base,
+        uriParts.path + (uriParts.hash || '')
+      )}"`
+    }
+    return returnValue
+  }
+
+  if (firstChar === '.' || firstChar === '~' || firstChar === '@') {
+    if (!uriParts.hash) {
+      return `require("${url}")`
+    } else {
+      // support uri fragment case by excluding it from
+      // the require and instead appending it as string;
+      // assuming that the path part is sufficient according to
+      // the above caseing(t.i. no protocol-auth-host parts expected)
+      return `require("${uriParts.path}") + "${uriParts.hash}"`
+    }
+  }
+  return returnValue
+}
+
+/**
+ * vuejs/component-compiler-utils#22 Support uri fragment in transformed require
+ * @param urlString an url as a string
+ */
+function parseUriParts(urlString: string): UrlWithStringQuery {
+  // initialize return value
+  const returnValue: UrlWithStringQuery = uriParse('')
+  if (urlString) {
+    // A TypeError is thrown if urlString is not a string
+    // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
+    if ('string' === typeof urlString) {
+      // check is an uri
+      return uriParse(urlString) // take apart the uri
+    }
+  }
+  return returnValue
+}
diff --git a/packages/compiler-sfc/src/types.ts b/packages/compiler-sfc/src/types.ts
new file mode 100644
index 00000000000..24b1d79f1e1
--- /dev/null
+++ b/packages/compiler-sfc/src/types.ts
@@ -0,0 +1,52 @@
+import { SFCDescriptor } from './parseComponent'
+
+export interface StartOfSourceMap {
+  file?: string
+  sourceRoot?: string
+}
+
+export interface RawSourceMap extends StartOfSourceMap {
+  version: string
+  sources: string[]
+  names: string[]
+  sourcesContent?: string[]
+  mappings: string
+}
+
+export interface VueTemplateCompiler {
+  parseComponent(source: string, options?: any): SFCDescriptor
+
+  compile(
+    template: string,
+    options: VueTemplateCompilerOptions
+  ): VueTemplateCompilerResults
+
+  ssrCompile(
+    template: string,
+    options: VueTemplateCompilerOptions
+  ): VueTemplateCompilerResults
+}
+
+// we'll just shim this much for now - in the future these types
+// should come from vue-template-compiler directly, or this package should be
+// part of the vue monorepo.
+export interface VueTemplateCompilerOptions {
+  modules?: Object[]
+  outputSourceRange?: boolean
+  whitespace?: 'preserve' | 'condense'
+  directives?: { [key: string]: Function }
+}
+
+export interface ErrorWithRange {
+  msg: string
+  start: number
+  end: number
+}
+
+export interface VueTemplateCompilerResults {
+  ast: Object | undefined
+  render: string
+  staticRenderFns: string[]
+  errors: (string | ErrorWithRange)[]
+  tips: (string | ErrorWithRange)[]
+}
diff --git a/packages/compiler-sfc/src/warn.ts b/packages/compiler-sfc/src/warn.ts
new file mode 100644
index 00000000000..e4b698dc4f5
--- /dev/null
+++ b/packages/compiler-sfc/src/warn.ts
@@ -0,0 +1,16 @@
+const hasWarned: Record<string, boolean> = {}
+
+export function warnOnce(msg: string) {
+  const isNodeProd =
+    typeof process !== 'undefined' && process.env.NODE_ENV === 'production'
+  if (!isNodeProd && !hasWarned[msg]) {
+    hasWarned[msg] = true
+    warn(msg)
+  }
+}
+
+export function warn(msg: string) {
+  console.warn(
+    `\x1b[1m\x1b[33m[@vue/compiler-sfc]\x1b[0m\x1b[33m ${msg}\x1b[0m\n`
+  )
+}
diff --git a/packages/compiler-sfc/test/compileStyle.spec.ts b/packages/compiler-sfc/test/compileStyle.spec.ts
new file mode 100644
index 00000000000..6f2a4f69013
--- /dev/null
+++ b/packages/compiler-sfc/test/compileStyle.spec.ts
@@ -0,0 +1,203 @@
+import { parse } from '../src/parse'
+import { compileStyle, compileStyleAsync } from '../src/compileStyle'
+
+test.only('preprocess less', () => {
+  const style = parse({
+    source:
+      '<style lang="less">\n' +
+      '@red: rgb(255, 0, 0);\n' +
+      '.color { color: @red; }\n' +
+      '</style>\n',
+    filename: 'example.vue',
+    needMap: true
+  }).styles[0]
+
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: style.content,
+    map: style.map,
+    scoped: false,
+    preprocessLang: style.lang
+  })
+
+  expect(result.errors.length).toBe(0)
+  expect(result.code).toEqual(expect.stringContaining('color: #ff0000;'))
+  expect(result.map).toBeTruthy()
+})
+
+test('preprocess scss', () => {
+  const style = parse({
+    source:
+      '<style lang="scss">\n' +
+      '$red: rgb(255, 0, 0);\n' +
+      '.color { color: $red; }\n' +
+      '</style>\n',
+    filename: 'example.vue',
+    needMap: true
+  }).styles[0]
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: style.content,
+    map: style.map,
+    scoped: false,
+    preprocessLang: style.lang
+  })
+
+  expect(result.errors.length).toBe(0)
+  expect(result.code).toEqual(expect.stringContaining('color: red;'))
+  expect(result.map).toBeTruthy()
+})
+
+test('preprocess sass', () => {
+  const style = parse({
+    source:
+      '<style lang="sass">\n' +
+      '$red: rgb(255, 0, 0)\n' +
+      '.color\n' +
+      '   color: $red\n' +
+      '</style>\n',
+    filename: 'example.vue',
+    needMap: true
+  }).styles[0]
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: style.content,
+    map: style.map,
+    scoped: false,
+    preprocessLang: style.lang
+  })
+
+  expect(result.errors.length).toBe(0)
+  expect(result.code).toEqual(expect.stringContaining('color: red;'))
+  expect(result.map).toBeTruthy()
+})
+
+test('preprocess stylus', () => {
+  const style = parse({
+    source:
+      '<style lang="styl">\n' +
+      'red-color = rgb(255, 0, 0);\n' +
+      '.color\n' +
+      '   color: red-color\n' +
+      '</style>\n',
+    filename: 'example.vue',
+    needMap: true
+  }).styles[0]
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: style.content,
+    map: style.map,
+    scoped: false,
+    preprocessLang: style.lang
+  })
+
+  expect(result.errors.length).toBe(0)
+  expect(result.code).toEqual(expect.stringContaining('color: #f00;'))
+  expect(result.map).toBeTruthy()
+})
+
+test('custom postcss plugin', () => {
+  const spy = vi.fn()
+
+  compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: '.foo { color: red }',
+    scoped: false,
+    postcssPlugins: [require('postcss').plugin('test-plugin', () => spy)()]
+  })
+
+  expect(spy).toHaveBeenCalled()
+})
+
+test('custom postcss options', () => {
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: '.foo { color: red }',
+    scoped: false,
+    postcssOptions: { random: 'foo' }
+  })
+
+  expect((result.rawResult as any).opts.random).toBe('foo')
+})
+
+test('async postcss plugin in sync mode', () => {
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: '.foo { color: red }',
+    scoped: false,
+    postcssPlugins: [
+      require('postcss').plugin(
+        'test-plugin',
+        () => async (result: any) => result
+      )
+    ]
+  })
+
+  expect(result.errors).toHaveLength(1)
+})
+
+test('async postcss plugin', async () => {
+  const promise = compileStyleAsync({
+    id: 'v-scope-xxx',
+    filename: 'example.vue',
+    source: '.foo { color: red }',
+    scoped: false,
+    postcssPlugins: [
+      require('postcss').plugin(
+        'test-plugin',
+        () => async (result: any) => result
+      )
+    ]
+  })
+
+  expect(promise instanceof Promise).toBe(true)
+
+  const result = await promise
+  expect(result.errors).toHaveLength(0)
+  expect(result.code).toEqual(expect.stringContaining('color: red'))
+})
+
+test('media query', () => {
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    scoped: true,
+    filename: 'example.vue',
+    source: `
+@media print {
+  .foo {
+    color: #000;
+  }
+}`
+  })
+
+  expect(result.errors).toHaveLength(0)
+  expect(result.code).toContain(
+    '@media print {\n.foo[v-scope-xxx] {\n    color: #000;\n}\n}'
+  )
+})
+
+test('supports query', () => {
+  const result = compileStyle({
+    id: 'v-scope-xxx',
+    scoped: true,
+    filename: 'example.vue',
+    source: `
+@supports ( color: #000 ) {
+  .foo {
+    color: #000;
+  }
+}`
+  })
+
+  expect(result.errors).toHaveLength(0)
+  expect(result.code).toContain(
+    '@supports ( color: #000 ) {\n.foo[v-scope-xxx] {\n    color: #000;\n}\n}'
+  )
+})
diff --git a/packages/compiler-sfc/test/compileTemplate.spec.ts b/packages/compiler-sfc/test/compileTemplate.spec.ts
new file mode 100644
index 00000000000..aa0e226c90e
--- /dev/null
+++ b/packages/compiler-sfc/test/compileTemplate.spec.ts
@@ -0,0 +1,230 @@
+import { parse } from '../src/parse'
+import { SFCBlock } from '../src/parseComponent'
+import { compileTemplate } from '../src/compileTemplate'
+import Vue from 'vue'
+
+function mockRender(code: string, mocks: Record<string, any> = {}) {
+  console.log(code)
+  const fn = new Function(
+    `require`,
+    `${code}; return { render, staticRenderFns }`
+  )
+  const vm = new Vue(
+    Object.assign(
+      {},
+      fn((id: string) => mocks[id])
+    )
+  )
+  vm.$mount()
+  return (vm as any)._vnode
+}
+
+test('should work', () => {
+  const source = `<div><p>{{ render }}</p></div>`
+
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source
+  })
+
+  expect(result.errors.length).toBe(0)
+  expect(result.source).toBe(source)
+  // should expose render fns
+  expect(result.code).toMatch(`var render = function`)
+  expect(result.code).toMatch(`var staticRenderFns = []`)
+  // should mark with stripped
+  expect(result.code).toMatch(`render._withStripped = true`)
+  // should prefix bindings
+  expect(result.code).toMatch(`_vm.render`)
+  expect(result.ast).not.toBeUndefined()
+})
+
+test('preprocess pug', () => {
+  const template = parse({
+    source:
+      '<template lang="pug">\n' +
+      'body\n' +
+      ' h1 Pug Examples\n' +
+      ' div.container\n' +
+      '   p Cool Pug example!\n' +
+      '</template>\n',
+    filename: 'example.vue',
+    needMap: true
+  }).template as SFCBlock
+
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source: template.content,
+    preprocessLang: template.lang
+  })
+
+  expect(result.errors.length).toBe(0)
+})
+
+/**
+ * vuejs/component-compiler-utils#22 Support uri fragment in transformed require
+ */
+test('supports uri fragment in transformed require', () => {
+  const source = '<svg>\
+    <use href="~@svg/file.svg#fragment"></use>\
+  </svg>' //
+  const result = compileTemplate({
+    filename: 'svgparticle.html',
+    source: source,
+    transformAssetUrls: {
+      use: 'href'
+    }
+  })
+  expect(result.errors.length).toBe(0)
+  expect(result.code).toMatch(
+    /href: require\("@svg\/file.svg"\) \+ "#fragment"/
+  )
+})
+
+/**
+ * vuejs/component-compiler-utils#22 Support uri fragment in transformed require
+ */
+test('when too short uri then empty require', () => {
+  const source = '<svg>\
+    <use href="~"></use>\
+  </svg>' //
+  const result = compileTemplate({
+    filename: 'svgparticle.html',
+    source: source,
+    transformAssetUrls: {
+      use: 'href'
+    }
+  })
+  expect(result.errors.length).toBe(0)
+  expect(result.code).toMatch(/href: require\(""\)/)
+})
+
+test('warn missing preprocessor', () => {
+  const template = parse({
+    source: '<template lang="unknownLang">\n' + '</template>\n',
+
+    filename: 'example.vue',
+    needMap: true
+  }).template as SFCBlock
+
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source: template.content,
+    preprocessLang: template.lang
+  })
+
+  expect(result.errors.length).toBe(1)
+})
+
+test.only('transform assetUrls', () => {
+  const source = `
+<div>
+  <img src="./logo.png">
+  <img src="~fixtures/logo.png">
+  <img src="~/fixtures/logo.png">
+</div>
+`
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source,
+    transformAssetUrls: true
+  })
+  expect(result.errors.length).toBe(0)
+
+  const vnode = mockRender(result.code, {
+    './logo.png': 'a',
+    'fixtures/logo.png': 'b'
+  })
+
+  expect(vnode.children[0].data.attrs.src).toBe('a')
+  expect(vnode.children[2].data.attrs.src).toBe('b')
+  expect(vnode.children[4].data.attrs.src).toBe('b')
+})
+
+test('transform srcset', () => {
+  // TODO:
+  const source = `
+<div>
+  <img src="./logo.png">
+  <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink= "http://www.w3.org/1999/xlink">
+    <image xlink:href="./logo.png" />
+  </svg>
+  <svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink= "http://www.w3.org/1999/xlink">
+    <use xlink:href="./logo.png"/>
+  </svg>
+  </svg>
+  <img src="./logo.png" srcset="./logo.png">
+  <img src="./logo.png" srcset="./logo.png 2x">
+  <img src="./logo.png" srcset="./logo.png, ./logo.png 2x">
+  <img src="./logo.png" srcset="./logo.png 2x, ./logo.png">
+  <img src="./logo.png" srcset="./logo.png 2x, ./logo.png 3x">
+  <img src="./logo.png" srcset="./logo.png, ./logo.png 2x, ./logo.png 3x">
+  <img
+    src="./logo.png"
+    srcset="
+      ./logo.png 2x,
+      ./logo.png 3x
+  ">
+</div>
+`
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source,
+    transformAssetUrls: true
+  })
+  expect(result.errors.length).toBe(0)
+
+  const vnode = mockRender(result.code, {
+    './logo.png': 'test-url'
+  })
+
+  // img tag
+  expect(vnode.children[0].data.attrs.src).toBe('test-url')
+  // image tag (SVG)
+  expect(vnode.children[2].children[0].data.attrs['xlink:href']).toBe(
+    'test-url'
+  )
+  // use tag (SVG)
+  expect(vnode.children[4].children[0].data.attrs['xlink:href']).toBe(
+    'test-url'
+  )
+
+  // image tag with srcset
+  expect(vnode.children[6].data.attrs.srcset).toBe('test-url')
+  expect(vnode.children[8].data.attrs.srcset).toBe('test-url 2x')
+  // image tag with multiline srcset
+  expect(vnode.children[10].data.attrs.srcset).toBe('test-url, test-url 2x')
+  expect(vnode.children[12].data.attrs.srcset).toBe('test-url 2x, test-url')
+  expect(vnode.children[14].data.attrs.srcset).toBe('test-url 2x, test-url 3x')
+  expect(vnode.children[16].data.attrs.srcset).toBe(
+    'test-url, test-url 2x, test-url 3x'
+  )
+  expect(vnode.children[18].data.attrs.srcset).toBe('test-url 2x, test-url 3x')
+})
+
+test('transform assetUrls and srcset with base option', () => {
+  const source = `
+<div>
+  <img src="./logo.png">
+  <img src="~fixtures/logo.png">
+  <img src="~/fixtures/logo.png">
+  <img src="./logo.png" srcset="./logo.png 2x, ./logo.png 3x">
+</div>
+`
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source,
+    transformAssetUrls: true,
+    transformAssetUrlsOptions: { base: '/base/' }
+  })
+
+  expect(result.errors.length).toBe(0)
+
+  const vnode = mockRender(result.code)
+  expect(vnode.children[0].data.attrs.src).toBe('/base/logo.png')
+  expect(vnode.children[2].data.attrs.src).toBe('/base/fixtures/logo.png')
+  expect(vnode.children[4].data.attrs.src).toBe('/base/fixtures/logo.png')
+  expect(vnode.children[6].data.attrs.srcset).toBe(
+    '/base/logo.png 2x, /base/logo.png 3x'
+  )
+})
diff --git a/test/unit/modules/sfc/sfc-parser.spec.ts b/packages/compiler-sfc/test/parseComponent.spec.ts
similarity index 98%
rename from test/unit/modules/sfc/sfc-parser.spec.ts
rename to packages/compiler-sfc/test/parseComponent.spec.ts
index 93db49c611b..b2ee8d633b2 100644
--- a/test/unit/modules/sfc/sfc-parser.spec.ts
+++ b/packages/compiler-sfc/test/parseComponent.spec.ts
@@ -1,4 +1,5 @@
-import { parseComponent } from 'sfc/parser'
+import { WarningMessage } from 'types/compiler'
+import { parseComponent } from '../src/parseComponent'
 
 describe('Single File Component parser', () => {
   it('should parse', () => {
diff --git a/packages/compiler-sfc/test/stylePluginScoped.spec.ts b/packages/compiler-sfc/test/stylePluginScoped.spec.ts
new file mode 100644
index 00000000000..46308e37466
--- /dev/null
+++ b/packages/compiler-sfc/test/stylePluginScoped.spec.ts
@@ -0,0 +1,137 @@
+import { compileStyle } from '../src/compileStyle'
+
+// vue-loader/#1370
+test('spaces after selector', () => {
+  const { code } = compileStyle({
+    source: `.foo , .bar { color: red; }`,
+    filename: 'test.css',
+    id: 'test'
+  })
+
+  expect(code).toMatch(`.foo[test], .bar[test] { color: red;`)
+})
+
+test('leading deep selector', () => {
+  const { code } = compileStyle({
+    source: `>>> .foo { color: red; }`,
+    filename: 'test.css',
+    id: 'test'
+  })
+
+  expect(code).toMatch(`[test] .foo { color: red;`)
+})
+
+test('scoped css', () => {
+  const { code: style } = compileStyle({
+    id: 'v-scope-xxx',
+    scoped: true,
+    filename: 'example.vue',
+    source: `
+.test {
+  color: yellow;
+}
+.test:after {
+  content: 'bye!';
+}
+h1 {
+  color: green;
+}
+.anim {
+  animation: color 5s infinite, other 5s;
+}
+.anim-2 {
+  animation-name: color;
+  animation-duration: 5s;
+}
+.anim-3 {
+  animation: 5s color infinite, 5s other;
+}
+.anim-multiple {
+  animation: color 5s infinite, opacity 2s;
+}
+.anim-multiple-2 {
+  animation-name: color, opacity;
+  animation-duration: 5s, 2s;
+}
+
+@keyframes color {
+  from { color: red; }
+  to { color: green; }
+}
+@-webkit-keyframes color {
+  from { color: red; }
+  to { color: green; }
+}
+@keyframes opacity {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+@-webkit-keyframes opacity {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+.foo p >>> .bar {
+  color: red;
+}
+.foo div /deep/ .bar {
+  color: red;
+}
+
+.foo span ::v-deep .bar {
+  color: red;
+}
+`
+  })
+
+  expect(style).toContain(`.test[v-scope-xxx] {\n  color: yellow;\n}`)
+  expect(style).toContain(`.test[v-scope-xxx]:after {\n  content: \'bye!\';\n}`)
+  expect(style).toContain(`h1[v-scope-xxx] {\n  color: green;\n}`)
+  // scoped keyframes
+  expect(style).toContain(
+    `.anim[v-scope-xxx] {\n  animation: color-v-scope-xxx 5s infinite, other 5s;`
+  )
+  expect(style).toContain(
+    `.anim-2[v-scope-xxx] {\n  animation-name: color-v-scope-xxx`
+  )
+  expect(style).toContain(
+    `.anim-3[v-scope-xxx] {\n  animation: 5s color-v-scope-xxx infinite, 5s other;`
+  )
+  expect(style).toContain(`@keyframes color-v-scope-xxx {`)
+  expect(style).toContain(`@-webkit-keyframes color-v-scope-xxx {`)
+
+  expect(style).toContain(
+    `.anim-multiple[v-scope-xxx] {\n  animation: color-v-scope-xxx 5s infinite,opacity-v-scope-xxx 2s;`
+  )
+  expect(style).toContain(
+    `.anim-multiple-2[v-scope-xxx] {\n  animation-name: color-v-scope-xxx,opacity-v-scope-xxx;`
+  )
+  expect(style).toContain(`@keyframes opacity-v-scope-xxx {`)
+  expect(style).toContain(`@-webkit-keyframes opacity-v-scope-xxx {`)
+  // >>> combinator
+  expect(style).toContain(`.foo p[v-scope-xxx] .bar {\n  color: red;\n}`)
+  // /deep/ alias for >>>
+  expect(style).toContain(`.foo div[v-scope-xxx] .bar {\n  color: red;\n}`)
+  // ::-v-deep alias for >>>
+  expect(style).toContain(`.foo span[v-scope-xxx] .bar {\n  color: red;\n}`)
+})
+
+test('pseudo element', () => {
+  const { code } = compileStyle({
+    source: '::selection { display: none; }',
+    filename: 'test.css',
+    id: 'test'
+  })
+
+  expect(code).toContain('[test]::selection {')
+})
+
+test('spaces before pseudo element', () => {
+  const { code } = compileStyle({
+    source: '.abc, ::selection { color: red; }',
+    filename: 'test.css',
+    id: 'test'
+  })
+
+  expect(code).toContain('.abc[test],')
+  expect(code).toContain('[test]::selection {')
+})
diff --git a/packages/compiler-sfc/test/tsconfig.json b/packages/compiler-sfc/test/tsconfig.json
new file mode 100644
index 00000000000..c0fca46c617
--- /dev/null
+++ b/packages/compiler-sfc/test/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["../src", "."]
+}
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 6ac5fbf1992..59370cfe2dd 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -24,7 +24,7 @@
     "url": "https://github.com/vuejs/vue/issues"
   },
   "dependencies": {
-    "chalk": "^4.0.0",
+    "chalk": "^4.1.2",
     "hash-sum": "^2.0.0",
     "he": "^1.2.0",
     "lodash.template": "^4.5.0",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 07e4b219b7b..0e4d434c706 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -26,8 +26,8 @@
   },
   "homepage": "https://github.com/vuejs/vue/tree/dev/packages/vue-template-compiler#readme",
   "dependencies": {
-    "he": "^1.2.0",
-    "de-indent": "^1.0.2"
+    "de-indent": "^1.0.2",
+    "he": "^1.2.0"
   },
   "devDependencies": {
     "vue": "file:../.."
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5b09d64d5b0..5ad8d78f393 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,111 +4,116 @@ importers:
 
   .:
     specifiers:
-      '@microsoft/api-extractor': ^7.24.2
+      '@microsoft/api-extractor': ^7.25.0
       '@rollup/plugin-alias': ^3.1.9
       '@rollup/plugin-commonjs': ^22.0.0
-      '@rollup/plugin-node-resolve': ^13.2.1
+      '@rollup/plugin-node-resolve': ^13.3.0
       '@rollup/plugin-replace': ^4.0.0
       '@types/he': ^1.1.2
-      '@types/node': ^17.0.30
+      '@types/node': ^17.0.41
       '@vue/compiler-sfc': workspace:*
-      chalk: ^4.0.0
+      chalk: ^4.1.2
       conventional-changelog-cli: ^2.2.2
       cross-spawn: ^7.0.3
       csstype: ^3.1.0
-      de-indent: ^1.0.2
       enquirer: ^2.3.6
-      esbuild: ^0.14.39
-      execa: ^4.0.0
+      esbuild: ^0.14.43
+      execa: ^4.1.0
       he: ^1.2.0
-      jasmine-core: ^4.1.1
+      jasmine-core: ^4.2.0
       jsdom: ^19.0.0
       karma: ^6.3.20
       karma-chrome-launcher: ^3.1.1
       karma-cli: ^2.0.0
       karma-esbuild: ^2.2.4
       karma-jasmine: ^5.0.1
-      lint-staged: ^12.4.1
+      lint-staged: ^12.5.0
       lodash: ^4.17.21
-      marked: ^4.0.6
+      marked: ^4.0.16
       minimist: ^1.2.6
+      postcss: ^8.4.14
       prettier: ^2.6.2
-      puppeteer: ^14.1.1
+      puppeteer: ^14.3.0
       rimraf: ^3.0.2
-      rollup: ^2.70.2
+      rollup: ^2.75.6
       rollup-plugin-typescript2: ^0.31.2
       semver: ^7.3.7
       shelljs: ^0.8.5
-      terser: ^5.13.1
+      terser: ^5.14.0
       todomvc-app-css: ^2.4.2
-      ts-node: ^10.7.0
+      ts-node: ^10.8.1
       tslib: ^2.4.0
-      typescript: ^4.6.4
-      vitest: ^0.12.6
+      typescript: ^4.7.3
+      vitest: ^0.12.10
       yorkie: ^2.0.0
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
       csstype: 3.1.0
     devDependencies:
-      '@microsoft/api-extractor': 7.24.2
-      '@rollup/plugin-alias': 3.1.9_rollup@2.75.3
-      '@rollup/plugin-commonjs': 22.0.0_rollup@2.75.3
-      '@rollup/plugin-node-resolve': 13.3.0_rollup@2.75.3
-      '@rollup/plugin-replace': 4.0.0_rollup@2.75.3
+      '@microsoft/api-extractor': 7.25.0
+      '@rollup/plugin-alias': 3.1.9_rollup@2.75.6
+      '@rollup/plugin-commonjs': 22.0.0_rollup@2.75.6
+      '@rollup/plugin-node-resolve': 13.3.0_rollup@2.75.6
+      '@rollup/plugin-replace': 4.0.0_rollup@2.75.6
       '@types/he': 1.1.2
-      '@types/node': 17.0.36
+      '@types/node': 17.0.41
       chalk: 4.1.2
       conventional-changelog-cli: 2.2.2
       cross-spawn: 7.0.3
-      de-indent: 1.0.2
       enquirer: 2.3.6
-      esbuild: 0.14.42
+      esbuild: 0.14.43
       execa: 4.1.0
       he: 1.2.0
-      jasmine-core: 4.1.1
+      jasmine-core: 4.2.0
       jsdom: 19.0.0
       karma: 6.3.20
       karma-chrome-launcher: 3.1.1
       karma-cli: 2.0.0
-      karma-esbuild: 2.2.4_esbuild@0.14.42
+      karma-esbuild: 2.2.4_esbuild@0.14.43
       karma-jasmine: 5.0.1_karma@6.3.20
-      lint-staged: 12.4.3_enquirer@2.3.6
+      lint-staged: 12.5.0_enquirer@2.3.6
       lodash: 4.17.21
       marked: 4.0.16
       minimist: 1.2.6
+      postcss: 8.4.14
       prettier: 2.6.2
-      puppeteer: 14.1.2
+      puppeteer: 14.3.0
       rimraf: 3.0.2
-      rollup: 2.75.3
-      rollup-plugin-typescript2: 0.31.2_nl2qxg2fxlgm6l264qcwjguuca
+      rollup: 2.75.6
+      rollup-plugin-typescript2: 0.31.2_fgms252lqu3rk7srzpqqayl4ya
       semver: 7.3.7
       shelljs: 0.8.5
       terser: 5.14.0
       todomvc-app-css: 2.4.2
-      ts-node: 10.8.0_w6gfxie3xfwntbz3mwbbvycbdq
+      ts-node: 10.8.1_f5eqjuxkorpjvs4z7mviievvou
       tslib: 2.4.0
-      typescript: 4.7.2
+      typescript: 4.7.3
       vitest: 0.12.10_jsdom@19.0.0
       yorkie: 2.0.0
 
   packages/compiler-sfc:
     specifiers:
-      '@babel/parser': ^7.16.4
-      '@babel/types': ^7.16.0
+      '@babel/parser': ^7.18.4
+      '@babel/types': ^7.18.4
       '@types/estree': ^0.0.48
-      '@types/lru-cache': ^5.1.0
+      '@types/hash-sum': ^1.0.0
+      '@types/lru-cache': ^5.1.1
       '@vue/consolidate': ^0.17.3
+      de-indent: ^1.0.2
       estree-walker: ^2.0.2
       hash-sum: ^2.0.0
+      less: ^4.1.3
       lru-cache: ^5.1.1
-      magic-string: ^0.25.7
+      magic-string: ^0.25.9
       merge-source-map: ^1.1.0
-      postcss: ^8.1.10
-      postcss-modules: ^4.0.0
-      postcss-selector-parser: ^6.0.4
-      pug: ^3.0.1
-      sass: ^1.26.9
+      postcss: ^8.4.14
+      postcss-modules: ^4.3.1
+      postcss-selector-parser: ^6.0.10
+      pug: ^3.0.2
+      sass: ^1.52.3
       source-map: ^0.6.1
+      stylus: ^0.58.1
+      vue-template-es2015-compiler: ^1.9.1
     dependencies:
       '@babel/parser': 7.18.4
       postcss: 8.4.14
@@ -116,22 +121,27 @@ importers:
     devDependencies:
       '@babel/types': 7.18.4
       '@types/estree': 0.0.48
+      '@types/hash-sum': 1.0.0
       '@types/lru-cache': 5.1.1
       '@vue/consolidate': 0.17.3
+      de-indent: 1.0.2
       estree-walker: 2.0.2
       hash-sum: 2.0.0
+      less: 4.1.3
       lru-cache: 5.1.1
       magic-string: 0.25.9
       merge-source-map: 1.1.0
       postcss-modules: 4.3.1_postcss@8.4.14
       postcss-selector-parser: 6.0.10
       pug: 3.0.2
-      sass: 1.52.1
+      sass: 1.52.3
+      stylus: 0.58.1
+      vue-template-es2015-compiler: 1.9.1
 
   packages/server-renderer:
     specifiers:
       '@types/webpack': ^4.41.32
-      chalk: ^4.0.0
+      chalk: ^4.1.2
       file-loader: ^3.0.1
       hash-sum: ^2.0.0
       he: ^1.2.0
@@ -267,19 +277,19 @@ packages:
       '@jridgewell/sourcemap-codec': 1.4.13
     dev: true
 
-  /@microsoft/api-extractor-model/7.17.3:
-    resolution: {integrity: sha512-ETslFxVEZTEK6mrOARxM34Ll2W/5H2aTk9Pe9dxsMCnthE8O/CaStV4WZAGsvvZKyjelSWgPVYGowxGVnwOMlQ==}
+  /@microsoft/api-extractor-model/7.18.0:
+    resolution: {integrity: sha512-Q7ZhD6zKQd/J5ayNNChFCCgHZ8tw3ibljm6nXP/JEmiEFFbpKKtWMPVCaN8Y+8/qFmrz7mblLrupcKmUu8cF4A==}
     dependencies:
       '@microsoft/tsdoc': 0.14.1
       '@microsoft/tsdoc-config': 0.16.1
       '@rushstack/node-core-library': 3.45.5
     dev: true
 
-  /@microsoft/api-extractor/7.24.2:
-    resolution: {integrity: sha512-QWZh9aQZvBAdRVK+Go8NiW8YNMN//OGiNqgA3iZ2sEy8imUqkRBCybXgmw2HkEYyPnn55CFoMKvnAHvV9+4B/A==}
+  /@microsoft/api-extractor/7.25.0:
+    resolution: {integrity: sha512-GS1XOY2RgLthUkfcTR4CLPvCIvpFYj+2MfJMZ3J4NX8H64BWSHGaDUvVV6QvjKNpt/RHdLyyJZ+j7dQveBAZnA==}
     hasBin: true
     dependencies:
-      '@microsoft/api-extractor-model': 7.17.3
+      '@microsoft/api-extractor-model': 7.18.0
       '@microsoft/tsdoc': 0.14.1
       '@microsoft/tsdoc-config': 0.16.1
       '@rushstack/node-core-library': 3.45.5
@@ -306,58 +316,58 @@ packages:
     resolution: {integrity: sha512-6Wci+Tp3CgPt/B9B0a3J4s3yMgLNSku6w5TV6mN+61C71UqsRBv2FUibBf3tPGlNxebgPHMEUzKpb1ggE8KCKw==}
     dev: true
 
-  /@rollup/plugin-alias/3.1.9_rollup@2.75.3:
+  /@rollup/plugin-alias/3.1.9_rollup@2.75.6:
     resolution: {integrity: sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==}
     engines: {node: '>=8.0.0'}
     peerDependencies:
       rollup: ^1.20.0||^2.0.0
     dependencies:
-      rollup: 2.75.3
+      rollup: 2.75.6
       slash: 3.0.0
     dev: true
 
-  /@rollup/plugin-commonjs/22.0.0_rollup@2.75.3:
+  /@rollup/plugin-commonjs/22.0.0_rollup@2.75.6:
     resolution: {integrity: sha512-Ktvf2j+bAO+30awhbYoCaXpBcyPmJbaEUYClQns/+6SNCYFURbvBiNbWgHITEsIgDDWCDUclWRKEuf8cwZCFoQ==}
     engines: {node: '>= 12.0.0'}
     peerDependencies:
       rollup: ^2.68.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.75.3
+      '@rollup/pluginutils': 3.1.0_rollup@2.75.6
       commondir: 1.0.1
       estree-walker: 2.0.2
       glob: 7.2.3
       is-reference: 1.2.1
       magic-string: 0.25.9
       resolve: 1.22.0
-      rollup: 2.75.3
+      rollup: 2.75.6
     dev: true
 
-  /@rollup/plugin-node-resolve/13.3.0_rollup@2.75.3:
+  /@rollup/plugin-node-resolve/13.3.0_rollup@2.75.6:
     resolution: {integrity: sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==}
     engines: {node: '>= 10.0.0'}
     peerDependencies:
       rollup: ^2.42.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.75.3
+      '@rollup/pluginutils': 3.1.0_rollup@2.75.6
       '@types/resolve': 1.17.1
       deepmerge: 4.2.2
       is-builtin-module: 3.1.0
       is-module: 1.0.0
       resolve: 1.22.0
-      rollup: 2.75.3
+      rollup: 2.75.6
     dev: true
 
-  /@rollup/plugin-replace/4.0.0_rollup@2.75.3:
+  /@rollup/plugin-replace/4.0.0_rollup@2.75.6:
     resolution: {integrity: sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==}
     peerDependencies:
       rollup: ^1.20.0 || ^2.0.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.75.3
+      '@rollup/pluginutils': 3.1.0_rollup@2.75.6
       magic-string: 0.25.9
-      rollup: 2.75.3
+      rollup: 2.75.6
     dev: true
 
-  /@rollup/pluginutils/3.1.0_rollup@2.75.3:
+  /@rollup/pluginutils/3.1.0_rollup@2.75.6:
     resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==}
     engines: {node: '>= 8.0.0'}
     peerDependencies:
@@ -366,7 +376,7 @@ packages:
       '@types/estree': 0.0.39
       estree-walker: 1.0.1
       picomatch: 2.3.1
-      rollup: 2.75.3
+      rollup: 2.75.6
     dev: true
 
   /@rollup/pluginutils/4.2.1:
@@ -466,6 +476,10 @@ packages:
     resolution: {integrity: sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==}
     dev: true
 
+  /@types/hash-sum/1.0.0:
+    resolution: {integrity: sha512-FdLBT93h3kcZ586Aee66HPCVJ6qvxVjBlDWNmxSGSbCZe9hTsjRKdSsl4y1T+3zfujxo9auykQMnFsfyHWD7wg==}
+    dev: true
+
   /@types/he/1.1.2:
     resolution: {integrity: sha512-kSJPcLO1x+oolc0R89pUl2kozldQ/fVQ1C1p5mp8fPoLdF/ZcBvckaTC2M8xXh3GYendXvCpy5m/a2eSbfgNgw==}
     dev: true
@@ -486,6 +500,10 @@ packages:
     resolution: {integrity: sha512-V3orv+ggDsWVHP99K3JlwtH20R7J4IhI1Kksgc+64q5VxgfRkQG8Ws3MFm/FZOKDYGy9feGFlZ70/HpCNe9QaA==}
     dev: true
 
+  /@types/node/17.0.41:
+    resolution: {integrity: sha512-xA6drNNeqb5YyV5fO3OAEsnXLfO7uF0whiOfPTz5AeDo8KeZFmODKnvwPymMNO8qE/an8pVY/O50tig2SQCrGw==}
+    dev: true
+
   /@types/normalize-package-data/2.4.1:
     resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
     dev: true
@@ -493,7 +511,7 @@ packages:
   /@types/resolve/1.17.1:
     resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==}
     dependencies:
-      '@types/node': 17.0.36
+      '@types/node': 17.0.41
     dev: true
 
   /@types/source-list-map/0.1.2:
@@ -533,7 +551,7 @@ packages:
     resolution: {integrity: sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==}
     requiresBuild: true
     dependencies:
-      '@types/node': 17.0.36
+      '@types/node': 17.0.41
     dev: true
     optional: true
 
@@ -1645,6 +1663,12 @@ packages:
     engines: {node: '>= 0.6'}
     dev: true
 
+  /copy-anything/2.0.6:
+    resolution: {integrity: sha512-1j20GZTsvKNkc4BY3NpMOM8tt///wY3FpIzozTOFO2ffuZcV61nojHXVKIy3WM+7ADCy5FVhdZYHYDdgTU0yJw==}
+    dependencies:
+      is-what: 3.14.1
+    dev: true
+
   /copy-concurrently/1.0.5:
     resolution: {integrity: sha512-f2domd9fsVDFtaFcbaRZuYXwtdmnzqbADSwhSWYxYB/Q8zsdUUFMXVRwXGDMWmbEzAn1kdRrtI1T/KTFOL4X2A==}
     dependencies:
@@ -1746,6 +1770,14 @@ packages:
       randomfill: 1.0.4
     dev: true
 
+  /css/3.0.0:
+    resolution: {integrity: sha512-DG9pFfwOrzc+hawpmqX/dHYHJG+Bsdb0klhyi1sDneOgGOXy9wQIC8hzyVp1e4NRYDBdxcylvywPkkXCHAzTyQ==}
+    dependencies:
+      inherits: 2.0.4
+      source-map: 0.6.1
+      source-map-resolve: 0.6.0
+    dev: true
+
   /cssesc/3.0.0:
     resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
     engines: {node: '>=4'}
@@ -1815,6 +1847,18 @@ packages:
       ms: 2.0.0
     dev: true
 
+  /debug/3.2.7:
+    resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.2
+    dev: true
+    optional: true
+
   /debug/4.3.4:
     resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
     engines: {node: '>=6.0'}
@@ -1922,8 +1966,8 @@ packages:
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
     dev: true
 
-  /devtools-protocol/0.0.982423:
-    resolution: {integrity: sha512-FnVW2nDbjGNw1uD/JRC+9U5768W7e1TfUwqbDTcSsAu1jXFjITSX8w3rkW5FEpHRMPPGpvNSmO1pOpqByiWscA==}
+  /devtools-protocol/0.0.1001819:
+    resolution: {integrity: sha512-G6OsIFnv/rDyxSqBa2lDLR6thp9oJioLsb2Gl+LbQlyoA9/OBAkrTU9jiCcQ8Pnh7z4d6slDiLaogR5hzgJLmQ==}
     dev: true
 
   /di/0.0.1:
@@ -2039,7 +2083,7 @@ packages:
     dependencies:
       '@types/cookie': 0.4.1
       '@types/cors': 2.8.12
-      '@types/node': 17.0.36
+      '@types/node': 17.0.41
       accepts: 1.3.8
       base64id: 2.0.0
       cookie: 0.4.2
@@ -2086,8 +2130,8 @@ packages:
       is-arrayish: 0.2.1
     dev: true
 
-  /esbuild-android-64/0.14.42:
-    resolution: {integrity: sha512-P4Y36VUtRhK/zivqGVMqhptSrFILAGlYp0Z8r9UQqHJ3iWztRCNWnlBzD9HRx0DbueXikzOiwyOri+ojAFfW6A==}
+  /esbuild-android-64/0.14.43:
+    resolution: {integrity: sha512-kqFXAS72K6cNrB6RiM7YJ5lNvmWRDSlpi7ZuRZ1hu1S3w0zlwcoCxWAyM23LQUyZSs1PbjHgdbbfYAN8IGh6xg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [android]
@@ -2095,8 +2139,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-android-arm64/0.14.42:
-    resolution: {integrity: sha512-0cOqCubq+RWScPqvtQdjXG3Czb3AWI2CaKw3HeXry2eoA2rrPr85HF7IpdU26UWdBXgPYtlTN1LUiuXbboROhg==}
+  /esbuild-android-arm64/0.14.43:
+    resolution: {integrity: sha512-bKS2BBFh+7XZY9rpjiHGRNA7LvWYbZWP87pLehggTG7tTaCDvj8qQGOU/OZSjCSKDYbgY7Q+oDw8RlYQ2Jt2BA==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [android]
@@ -2104,8 +2148,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-darwin-64/0.14.42:
-    resolution: {integrity: sha512-ipiBdCA3ZjYgRfRLdQwP82rTiv/YVMtW36hTvAN5ZKAIfxBOyPXY7Cejp3bMXWgzKD8B6O+zoMzh01GZsCuEIA==}
+  /esbuild-darwin-64/0.14.43:
+    resolution: {integrity: sha512-/3PSilx011ttoieRGkSZ0XV8zjBf2C9enV4ScMMbCT4dpx0mFhMOpFnCHkOK0pWGB8LklykFyHrWk2z6DENVUg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [darwin]
@@ -2113,8 +2157,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-darwin-arm64/0.14.42:
-    resolution: {integrity: sha512-bU2tHRqTPOaoH/4m0zYHbFWpiYDmaA0gt90/3BMEFaM0PqVK/a6MA2V/ypV5PO0v8QxN6gH5hBPY4YJ2lopXgA==}
+  /esbuild-darwin-arm64/0.14.43:
+    resolution: {integrity: sha512-1HyFUKs8DMCBOvw1Qxpr5Vv/ThNcVIFb5xgXWK3pyT40WPvgYIiRTwJCvNs4l8i5qWF8/CK5bQxJVDjQvtv0Yw==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [darwin]
@@ -2122,8 +2166,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-freebsd-64/0.14.42:
-    resolution: {integrity: sha512-75h1+22Ivy07+QvxHyhVqOdekupiTZVLN1PMwCDonAqyXd8TVNJfIRFrdL8QmSJrOJJ5h8H1I9ETyl2L8LQDaw==}
+  /esbuild-freebsd-64/0.14.43:
+    resolution: {integrity: sha512-FNWc05TPHYgaXjbPZO5/rJKSBslfG6BeMSs8GhwnqAKP56eEhvmzwnIz1QcC9cRVyO+IKqWNfmHFkCa1WJTULA==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [freebsd]
@@ -2131,8 +2175,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-freebsd-arm64/0.14.42:
-    resolution: {integrity: sha512-W6Jebeu5TTDQMJUJVarEzRU9LlKpNkPBbjqSu+GUPTHDCly5zZEQq9uHkmHHl7OKm+mQ2zFySN83nmfCeZCyNA==}
+  /esbuild-freebsd-arm64/0.14.43:
+    resolution: {integrity: sha512-amrYopclz3VohqisOPR6hA3GOWA3LZC1WDLnp21RhNmoERmJ/vLnOpnrG2P/Zao+/erKTCUqmrCIPVtj58DRoA==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [freebsd]
@@ -2140,8 +2184,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-32/0.14.42:
-    resolution: {integrity: sha512-Ooy/Bj+mJ1z4jlWcK5Dl6SlPlCgQB9zg1UrTCeY8XagvuWZ4qGPyYEWGkT94HUsRi2hKsXvcs6ThTOjBaJSMfg==}
+  /esbuild-linux-32/0.14.43:
+    resolution: {integrity: sha512-KoxoEra+9O3AKVvgDFvDkiuddCds6q71owSQEYwjtqRV7RwbPzKxJa6+uyzUulHcyGVq0g15K0oKG5CFBcvYDw==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [linux]
@@ -2149,8 +2193,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-64/0.14.42:
-    resolution: {integrity: sha512-2L0HbzQfbTuemUWfVqNIjOfaTRt9zsvjnme6lnr7/MO9toz/MJ5tZhjqrG6uDWDxhsaHI2/nsDgrv8uEEN2eoA==}
+  /esbuild-linux-64/0.14.43:
+    resolution: {integrity: sha512-EwINwGMyiJMgBby5/SbMqKcUhS5AYAZ2CpEBzSowsJPNBJEdhkCTtEjk757TN/wxgbu3QklqDM6KghY660QCUw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [linux]
@@ -2158,8 +2202,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-arm/0.14.42:
-    resolution: {integrity: sha512-STq69yzCMhdRaWnh29UYrLSr/qaWMm/KqwaRF1pMEK7kDiagaXhSL1zQGXbYv94GuGY/zAwzK98+6idCMUOOCg==}
+  /esbuild-linux-arm/0.14.43:
+    resolution: {integrity: sha512-e6YzQUoDxxtyamuF12eVzzRC7bbEFSZohJ6igQB9tBqnNmIQY3fI6Cns3z2wxtbZ3f2o6idkD2fQnlvs2902Dg==}
     engines: {node: '>=12'}
     cpu: [arm]
     os: [linux]
@@ -2167,8 +2211,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-arm64/0.14.42:
-    resolution: {integrity: sha512-c3Ug3e9JpVr8jAcfbhirtpBauLxzYPpycjWulD71CF6ZSY26tvzmXMJYooQ2YKqDY4e/fPu5K8bm7MiXMnyxuA==}
+  /esbuild-linux-arm64/0.14.43:
+    resolution: {integrity: sha512-UlSpjMWllAc70zYbHxWuDS3FJytyuR/gHJYBr8BICcTNb/TSOYVBg6U7b3jZ3mILTrgzwJUHwhEwK18FZDouUQ==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [linux]
@@ -2176,8 +2220,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-mips64le/0.14.42:
-    resolution: {integrity: sha512-QuvpHGbYlkyXWf2cGm51LBCHx6eUakjaSrRpUqhPwjh/uvNUYvLmz2LgPTTPwCqaKt0iwL+OGVL0tXA5aDbAbg==}
+  /esbuild-linux-mips64le/0.14.43:
+    resolution: {integrity: sha512-f+v8cInPEL1/SDP//CfSYzcDNgE4CY3xgDV81DWm3KAPWzhvxARrKxB1Pstf5mB56yAslJDxu7ryBUPX207EZA==}
     engines: {node: '>=12'}
     cpu: [mips64el]
     os: [linux]
@@ -2185,8 +2229,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-ppc64le/0.14.42:
-    resolution: {integrity: sha512-8ohIVIWDbDT+i7lCx44YCyIRrOW1MYlks9fxTo0ME2LS/fxxdoJBwHWzaDYhjvf8kNpA+MInZvyOEAGoVDrMHg==}
+  /esbuild-linux-ppc64le/0.14.43:
+    resolution: {integrity: sha512-5wZYMDGAL/K2pqkdIsW+I4IR41kyfHr/QshJcNpUfK3RjB3VQcPWOaZmc+74rm4ZjVirYrtz+jWw0SgxtxRanA==}
     engines: {node: '>=12'}
     cpu: [ppc64]
     os: [linux]
@@ -2194,8 +2238,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-riscv64/0.14.42:
-    resolution: {integrity: sha512-DzDqK3TuoXktPyG1Lwx7vhaF49Onv3eR61KwQyxYo4y5UKTpL3NmuarHSIaSVlTFDDpcIajCDwz5/uwKLLgKiQ==}
+  /esbuild-linux-riscv64/0.14.43:
+    resolution: {integrity: sha512-lYcAOUxp85hC7lSjycJUVSmj4/9oEfSyXjb/ua9bNl8afonaduuqtw7hvKMoKuYnVwOCDw4RSfKpcnIRDWq+Bw==}
     engines: {node: '>=12'}
     cpu: [riscv64]
     os: [linux]
@@ -2203,8 +2247,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-s390x/0.14.42:
-    resolution: {integrity: sha512-YFRhPCxl8nb//Wn6SiS5pmtplBi4z9yC2gLrYoYI/tvwuB1jldir9r7JwAGy1Ck4D7sE7wBN9GFtUUX/DLdcEQ==}
+  /esbuild-linux-s390x/0.14.43:
+    resolution: {integrity: sha512-27e43ZhHvhFE4nM7HqtUbMRu37I/4eNSUbb8FGZWszV+uLzMIsHDwLoBiJmw7G9N+hrehNPeQ4F5Ujad0DrUKQ==}
     engines: {node: '>=12'}
     cpu: [s390x]
     os: [linux]
@@ -2212,8 +2256,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-netbsd-64/0.14.42:
-    resolution: {integrity: sha512-QYSD2k+oT9dqB/4eEM9c+7KyNYsIPgzYOSrmfNGDIyJrbT1d+CFVKvnKahDKNJLfOYj8N4MgyFaU9/Ytc6w5Vw==}
+  /esbuild-netbsd-64/0.14.43:
+    resolution: {integrity: sha512-2mH4QF6hHBn5zzAfxEI/2eBC0mspVsZ6UVo821LpAJKMvLJPBk3XJO5xwg7paDqSqpl7p6IRrAenW999AEfJhQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [netbsd]
@@ -2221,8 +2265,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-openbsd-64/0.14.42:
-    resolution: {integrity: sha512-M2meNVIKWsm2HMY7+TU9AxM7ZVwI9havdsw6m/6EzdXysyCFFSoaTQ/Jg03izjCsK17FsVRHqRe26Llj6x0MNA==}
+  /esbuild-openbsd-64/0.14.43:
+    resolution: {integrity: sha512-ZhQpiZjvqCqO8jKdGp9+8k9E/EHSA+zIWOg+grwZasI9RoblqJ1QiZqqi7jfd6ZrrG1UFBNGe4m0NFxCFbMVbg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [openbsd]
@@ -2230,8 +2274,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-sunos-64/0.14.42:
-    resolution: {integrity: sha512-uXV8TAZEw36DkgW8Ak3MpSJs1ofBb3Smkc/6pZ29sCAN1KzCAQzsje4sUwugf+FVicrHvlamCOlFZIXgct+iqQ==}
+  /esbuild-sunos-64/0.14.43:
+    resolution: {integrity: sha512-DgxSi9DaHReL9gYuul2rrQCAapgnCJkh3LSHPKsY26zytYppG0HgkgVF80zjIlvEsUbGBP/GHQzBtrezj/Zq1Q==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [sunos]
@@ -2239,8 +2283,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-32/0.14.42:
-    resolution: {integrity: sha512-4iw/8qWmRICWi9ZOnJJf9sYt6wmtp3hsN4TdI5NqgjfOkBVMxNdM9Vt3626G1Rda9ya2Q0hjQRD9W1o+m6Lz6g==}
+  /esbuild-windows-32/0.14.43:
+    resolution: {integrity: sha512-Ih3+2O5oExiqm0mY6YYE5dR0o8+AspccQ3vIAtRodwFvhuyGLjb0Hbmzun/F3Lw19nuhPMu3sW2fqIJ5xBxByw==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [win32]
@@ -2248,8 +2292,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-64/0.14.42:
-    resolution: {integrity: sha512-j3cdK+Y3+a5H0wHKmLGTJcq0+/2mMBHPWkItR3vytp/aUGD/ua/t2BLdfBIzbNN9nLCRL9sywCRpOpFMx3CxzA==}
+  /esbuild-windows-64/0.14.43:
+    resolution: {integrity: sha512-8NsuNfI8xwFuJbrCuI+aBqNTYkrWErejFO5aYM+yHqyHuL8mmepLS9EPzAzk8rvfaJrhN0+RvKWAcymViHOKEw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [win32]
@@ -2257,8 +2301,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-arm64/0.14.42:
-    resolution: {integrity: sha512-+lRAARnF+hf8J0mN27ujO+VbhPbDqJ8rCcJKye4y7YZLV6C4n3pTRThAb388k/zqF5uM0lS5O201u0OqoWSicw==}
+  /esbuild-windows-arm64/0.14.43:
+    resolution: {integrity: sha512-7ZlD7bo++kVRblJEoG+cepljkfP8bfuTPz5fIXzptwnPaFwGS6ahvfoYzY7WCf5v/1nX2X02HDraVItTgbHnKw==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [win32]
@@ -2266,32 +2310,32 @@ packages:
     dev: true
     optional: true
 
-  /esbuild/0.14.42:
-    resolution: {integrity: sha512-V0uPZotCEHokJdNqyozH6qsaQXqmZEOiZWrXnds/zaH/0SyrIayRXWRB98CENO73MIZ9T3HBIOsmds5twWtmgw==}
+  /esbuild/0.14.43:
+    resolution: {integrity: sha512-Uf94+kQmy/5jsFwKWiQB4hfo/RkM9Dh7b79p8yqd1tshULdr25G2szLz631NoH3s2ujnKEKVD16RmOxvCNKRFA==}
     engines: {node: '>=12'}
     hasBin: true
     requiresBuild: true
     optionalDependencies:
-      esbuild-android-64: 0.14.42
-      esbuild-android-arm64: 0.14.42
-      esbuild-darwin-64: 0.14.42
-      esbuild-darwin-arm64: 0.14.42
-      esbuild-freebsd-64: 0.14.42
-      esbuild-freebsd-arm64: 0.14.42
-      esbuild-linux-32: 0.14.42
-      esbuild-linux-64: 0.14.42
-      esbuild-linux-arm: 0.14.42
-      esbuild-linux-arm64: 0.14.42
-      esbuild-linux-mips64le: 0.14.42
-      esbuild-linux-ppc64le: 0.14.42
-      esbuild-linux-riscv64: 0.14.42
-      esbuild-linux-s390x: 0.14.42
-      esbuild-netbsd-64: 0.14.42
-      esbuild-openbsd-64: 0.14.42
-      esbuild-sunos-64: 0.14.42
-      esbuild-windows-32: 0.14.42
-      esbuild-windows-64: 0.14.42
-      esbuild-windows-arm64: 0.14.42
+      esbuild-android-64: 0.14.43
+      esbuild-android-arm64: 0.14.43
+      esbuild-darwin-64: 0.14.43
+      esbuild-darwin-arm64: 0.14.43
+      esbuild-freebsd-64: 0.14.43
+      esbuild-freebsd-arm64: 0.14.43
+      esbuild-linux-32: 0.14.43
+      esbuild-linux-64: 0.14.43
+      esbuild-linux-arm: 0.14.43
+      esbuild-linux-arm64: 0.14.43
+      esbuild-linux-mips64le: 0.14.43
+      esbuild-linux-ppc64le: 0.14.43
+      esbuild-linux-riscv64: 0.14.43
+      esbuild-linux-s390x: 0.14.43
+      esbuild-netbsd-64: 0.14.43
+      esbuild-openbsd-64: 0.14.43
+      esbuild-sunos-64: 0.14.43
+      esbuild-windows-32: 0.14.43
+      esbuild-windows-64: 0.14.43
+      esbuild-windows-arm64: 0.14.43
     dev: true
 
   /escalade/3.1.1:
@@ -3051,6 +3095,14 @@ packages:
     resolution: {integrity: sha512-DUNFN5j7Tln0D+TxzloUjKB+CtVu6myn0JEFak6dG18mNt9YkQ6lzGCdafwofISZ1lLF3xRHJ98VKy9ynkcFaA==}
     dev: true
 
+  /image-size/0.5.5:
+    resolution: {integrity: sha512-6TDAlDPZxUFCv+fuOkIoXT/V/f3Qbq8e37p+YOiYrUv3v9cc3/6x78VdfPgFVaB9dZYeLUfKgHRebpkm/oP2VQ==}
+    engines: {node: '>=0.10.0'}
+    hasBin: true
+    requiresBuild: true
+    dev: true
+    optional: true
+
   /immutable/4.1.0:
     resolution: {integrity: sha512-oNkuqVTA8jqG1Q6c+UglTOD1xhC1BtjKI7XkCXRkZHrN5m18/XsnUp8Q89GkQO/z+0WjonSvl0FLhDYftp46nQ==}
     dev: true
@@ -3311,6 +3363,10 @@ packages:
       text-extensions: 1.9.0
     dev: true
 
+  /is-what/3.14.1:
+    resolution: {integrity: sha512-sNxgpk9793nzSs7bA6JQJGeIuRBQhAaNGG77kzYQgMkrID+lS6SlK07K5LaptscDlSaIgH+GPFzf+d75FVxozA==}
+    dev: true
+
   /is-windows/1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
     engines: {node: '>=0.10.0'}
@@ -3346,8 +3402,8 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /jasmine-core/4.1.1:
-    resolution: {integrity: sha512-lmUfT5XcK9KKvt3lLYzn93hc4MGzlUBowExFVgzbSW0ZCrdeyS574dfsyfRhxbg81Wj4gk+RxUiTnj7KBfDA1g==}
+  /jasmine-core/4.2.0:
+    resolution: {integrity: sha512-OcFpBrIhnbmb9wfI8cqPSJ50pv3Wg4/NSgoZIqHzIwO/2a9qivJWzv8hUvaREIMYYJBas6AvfXATFdVuzzCqVw==}
     dev: true
 
   /jju/1.4.0:
@@ -3467,13 +3523,13 @@ packages:
       resolve: 1.22.0
     dev: true
 
-  /karma-esbuild/2.2.4_esbuild@0.14.42:
+  /karma-esbuild/2.2.4_esbuild@0.14.43:
     resolution: {integrity: sha512-nt5+AJ0iFpgJXboBmXvwjM5LYTqTmFA9NuNGj9A442gCMJHwL4Eft4JUBVRc7ORSPoJAQ26Kgf5252Xt6GbkRw==}
     peerDependencies:
       esbuild: '>=0.8.45'
     dependencies:
       chokidar: 3.5.3
-      esbuild: 0.14.42
+      esbuild: 0.14.43
       source-map: 0.6.1
     dev: true
 
@@ -3483,7 +3539,7 @@ packages:
     peerDependencies:
       karma: ^6.0.0
     dependencies:
-      jasmine-core: 4.1.1
+      jasmine-core: 4.2.0
       karma: 6.3.20
     dev: true
 
@@ -3547,6 +3603,26 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /less/4.1.3:
+    resolution: {integrity: sha512-w16Xk/Ta9Hhyei0Gpz9m7VS8F28nieJaL/VyShID7cYvP6IL5oHeL6p4TXSDJqZE/lNv0oJ2pGVjJsRkfwm5FA==}
+    engines: {node: '>=6'}
+    hasBin: true
+    dependencies:
+      copy-anything: 2.0.6
+      parse-node-version: 1.0.1
+      tslib: 2.4.0
+    optionalDependencies:
+      errno: 0.1.8
+      graceful-fs: 4.2.10
+      image-size: 0.5.5
+      make-dir: 2.1.0
+      mime: 1.6.0
+      needle: 3.1.0
+      source-map: 0.6.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /levn/0.3.0:
     resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==}
     engines: {node: '>= 0.8.0'}
@@ -3564,8 +3640,8 @@ packages:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
     dev: true
 
-  /lint-staged/12.4.3_enquirer@2.3.6:
-    resolution: {integrity: sha512-eH6SKOmdm/ZwCRMTZAmM3q3dPkpq6vco/BfrOw8iGun4Xs/thYegPD/MLIwKO+iPkzibkLJuQcRhRLXKvaKreg==}
+  /lint-staged/12.5.0_enquirer@2.3.6:
+    resolution: {integrity: sha512-BKLUjWDsKquV/JuIcoQW4MSAI3ggwEImF1+sB4zaKvyVx1wBk3FsG7UK9bpnmBTN1pm7EH2BBcMwINJzCRv12g==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     hasBin: true
     dependencies:
@@ -3918,6 +3994,14 @@ packages:
       mime-db: 1.52.0
     dev: true
 
+  /mime/1.6.0:
+    resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
+    engines: {node: '>=4'}
+    hasBin: true
+    requiresBuild: true
+    dev: true
+    optional: true
+
   /mime/2.6.0:
     resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==}
     engines: {node: '>=4.0.0'}
@@ -4049,6 +4133,20 @@ packages:
       - supports-color
     dev: true
 
+  /needle/3.1.0:
+    resolution: {integrity: sha512-gCE9weDhjVGCRqS8dwDR/D3GTAeyXLXuqp7I8EzH6DllZGXSUyxuqqLh+YX9rMAWaaTFyVAg6rHGL25dqvczKw==}
+    engines: {node: '>= 4.4.x'}
+    hasBin: true
+    requiresBuild: true
+    dependencies:
+      debug: 3.2.7
+      iconv-lite: 0.6.3
+      sax: 1.2.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+    optional: true
+
   /negotiator/0.6.3:
     resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
     engines: {node: '>= 0.6'}
@@ -4136,7 +4234,7 @@ packages:
     dev: true
 
   /npm-run-path/2.0.2:
-    resolution: {integrity: sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=}
+    resolution: {integrity: sha512-lJxZYlT4DW/bRUtFh1MQIWqmLwQfAxnqWG4HhEdjMlkrJYnJn0Jrr2u3mgxqaWsdiBc76TYkTG/mhrnYTuzfHw==}
     engines: {node: '>=4'}
     dependencies:
       path-key: 2.0.1
@@ -4200,7 +4298,7 @@ packages:
     dev: true
 
   /once/1.4.0:
-    resolution: {integrity: sha1-WDsap3WWHUsROsF9nFC6753Xa9E=}
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
     dependencies:
       wrappy: 1.0.2
     dev: true
@@ -4339,6 +4437,11 @@ packages:
       lines-and-columns: 1.2.4
     dev: true
 
+  /parse-node-version/1.0.1:
+    resolution: {integrity: sha512-3YHlOa/JgH6Mnpr05jP9eDG254US9ek25LyIxZlDItp2iJtwyaXQb57lBYLdT3MowkUFYEV2XXNAYIPlESvJlA==}
+    engines: {node: '>= 0.10'}
+    dev: true
+
   /parse5/6.0.1:
     resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
     dev: true
@@ -4373,7 +4476,7 @@ packages:
     dev: true
 
   /path-is-absolute/1.0.1:
-    resolution: {integrity: sha1-F0uSaHNVNP+8es5r9TpanhtcX18=}
+    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -4384,7 +4487,7 @@ packages:
     dev: true
 
   /path-key/2.0.1:
-    resolution: {integrity: sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=}
+    resolution: {integrity: sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==}
     engines: {node: '>=4'}
     dev: true
 
@@ -4425,7 +4528,7 @@ packages:
     dev: true
 
   /pend/1.2.0:
-    resolution: {integrity: sha1-elfrVQpng/kRUzH89GY9XI4AelA=}
+    resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
     dev: true
 
   /picocolors/1.0.0:
@@ -4607,7 +4710,7 @@ packages:
     dev: true
 
   /prr/1.0.1:
-    resolution: {integrity: sha1-0/wRS6BplaRexok/SEzrHXj19HY=}
+    resolution: {integrity: sha512-yPw4Sng1gWghHQWj0B3ZggWUm4qVbPwPFcRG8KyxiU7J2OHFSoEHKS+EZ3fv5l1t9CyCiop6l/ZYeWbrgoQejw==}
     dev: true
 
   /pseudomap/1.0.2:
@@ -4755,14 +4858,14 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /puppeteer/14.1.2:
-    resolution: {integrity: sha512-Nsyy1f7pT2KyBb15u8DHi4q3FfrIqOptAV0r4Bd1lAp2pHz8T0o4DO+On1yWZ7jFbcx1w3AqZ/e7nKqnc3Vwyg==}
+  /puppeteer/14.3.0:
+    resolution: {integrity: sha512-pDtg1+vyw1UPIhUjh2/VW1HUdQnaZJHfMacrJciR3AVm+PBiqdCEcFeFb3UJ/CDEQlHOClm3/WFa7IjY25zIGg==}
     engines: {node: '>=14.1.0'}
     requiresBuild: true
     dependencies:
       cross-fetch: 3.1.5
       debug: 4.3.4
-      devtools-protocol: 0.0.982423
+      devtools-protocol: 0.0.1001819
       extract-zip: 2.0.1
       https-proxy-agent: 5.0.1
       pkg-dir: 4.2.0
@@ -4771,7 +4874,7 @@ packages:
       rimraf: 3.0.2
       tar-fs: 2.1.1
       unbzip2-stream: 1.4.3
-      ws: 8.6.0
+      ws: 8.7.0
     transitivePeerDependencies:
       - bufferutil
       - encoding
@@ -5026,7 +5129,7 @@ packages:
       inherits: 2.0.4
     dev: true
 
-  /rollup-plugin-typescript2/0.31.2_nl2qxg2fxlgm6l264qcwjguuca:
+  /rollup-plugin-typescript2/0.31.2_fgms252lqu3rk7srzpqqayl4ya:
     resolution: {integrity: sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==}
     peerDependencies:
       rollup: '>=1.26.3'
@@ -5037,13 +5140,13 @@ packages:
       find-cache-dir: 3.3.2
       fs-extra: 10.1.0
       resolve: 1.22.0
-      rollup: 2.75.3
+      rollup: 2.75.6
       tslib: 2.4.0
-      typescript: 4.7.2
+      typescript: 4.7.3
     dev: true
 
-  /rollup/2.75.3:
-    resolution: {integrity: sha512-YA29fLU6MAYSaDxIQYrGGOcbXlDmG96h0krGGYObroezcQ0KgEPM3+7MtKD/qeuUbFuAJXvKZee5dA1dpwq1PQ==}
+  /rollup/2.75.6:
+    resolution: {integrity: sha512-OEf0TgpC9vU6WGROJIk1JA3LR5vk/yvqlzxqdrE2CzzXnqKXNzbAwlWUXis8RS3ZPe7LAq+YUxsRa0l3r27MLA==}
     engines: {node: '>=10.0.0'}
     hasBin: true
     optionalDependencies:
@@ -5079,8 +5182,8 @@ packages:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
     dev: true
 
-  /sass/1.52.1:
-    resolution: {integrity: sha512-fSzYTbr7z8oQnVJ3Acp9hV80dM1fkMN7mSD/25mpcct9F7FPBMOI8krEYALgU1aZoqGhQNhTPsuSmxjnIvAm4Q==}
+  /sass/1.52.3:
+    resolution: {integrity: sha512-LNNPJ9lafx+j1ArtA7GyEJm9eawXN8KlA1+5dF6IZyoONg1Tyo/g+muOsENWJH/2Q1FHbbV4UwliU0cXMa/VIA==}
     engines: {node: '>=12.0.0'}
     hasBin: true
     dependencies:
@@ -5089,6 +5192,10 @@ packages:
       source-map-js: 1.0.2
     dev: true
 
+  /sax/1.2.4:
+    resolution: {integrity: sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==}
+    dev: true
+
   /saxes/5.0.1:
     resolution: {integrity: sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==}
     engines: {node: '>=10'}
@@ -5320,6 +5427,14 @@ packages:
       urix: 0.1.0
     dev: true
 
+  /source-map-resolve/0.6.0:
+    resolution: {integrity: sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==}
+    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
+    dependencies:
+      atob: 2.1.2
+      decode-uri-component: 0.2.0
+    dev: true
+
   /source-map-support/0.5.21:
     resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
     dependencies:
@@ -5391,7 +5506,7 @@ packages:
     dev: true
 
   /sprintf-js/1.0.3:
-    resolution: {integrity: sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=}
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
     dev: true
 
   /ssri/6.0.2:
@@ -5463,7 +5578,7 @@ packages:
     dev: true
 
   /string-hash/1.1.3:
-    resolution: {integrity: sha1-6Kr8CsGFW0Zmkp7X3RJ1311sgRs=}
+    resolution: {integrity: sha512-kJUvRUFK49aub+a7T1nNE66EJbZBMnBgoC1UbCZ5n6bsZKBRga4KgBRTMn/pFkeCZSYtNeSyMxPDM0AXWELk2A==}
     dev: true
 
   /string-width/4.2.3:
@@ -5542,6 +5657,19 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
+  /stylus/0.58.1:
+    resolution: {integrity: sha512-AYiCHm5ogczdCPMfe9aeQa4NklB2gcf4D/IhzYPddJjTgPc+k4D/EVE0yfQbZD43MHP3lPy+8NZ9fcFxkrgs/w==}
+    hasBin: true
+    dependencies:
+      css: 3.0.0
+      debug: 4.3.4
+      glob: 7.2.3
+      sax: 1.2.4
+      source-map: 0.7.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
   /supports-color/5.5.0:
     resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
     engines: {node: '>=4'}
@@ -5676,7 +5804,7 @@ packages:
     dev: true
 
   /timsort/0.3.0:
-    resolution: {integrity: sha1-QFQRqOfmM5/mTbmiNN4R3DHgK9Q=}
+    resolution: {integrity: sha512-qsdtZH+vMoCARQtyod4imc2nIJwg9Cc7lPRrw9CzF8ZKR0khdr8+2nX80PBhET3tcyTtJDxAffGh2rXH4tyU8A==}
     dev: true
 
   /tinypool/0.1.3:
@@ -5701,7 +5829,7 @@ packages:
     dev: true
 
   /to-fast-properties/2.0.0:
-    resolution: {integrity: sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=}
+    resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}
     engines: {node: '>=4'}
 
   /to-object-path/0.3.0:
@@ -5774,8 +5902,8 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /ts-node/10.8.0_w6gfxie3xfwntbz3mwbbvycbdq:
-    resolution: {integrity: sha512-/fNd5Qh+zTt8Vt1KbYZjRHCE9sI5i7nqfD/dzBBRDeVXZXS6kToW6R7tTU6Nd4XavFs0mAVCg29Q//ML7WsZYA==}
+  /ts-node/10.8.1_f5eqjuxkorpjvs4z7mviievvou:
+    resolution: {integrity: sha512-Wwsnao4DQoJsN034wePSg5nZiw4YKXf56mPIAeD6wVmiv+RytNSWqc2f3fKvcUoV+Yn2+yocD71VOfQHbmVX4g==}
     hasBin: true
     peerDependencies:
       '@swc/core': '>=1.2.50'
@@ -5793,14 +5921,14 @@ packages:
       '@tsconfig/node12': 1.0.9
       '@tsconfig/node14': 1.0.1
       '@tsconfig/node16': 1.0.2
-      '@types/node': 17.0.36
+      '@types/node': 17.0.41
       acorn: 8.7.1
       acorn-walk: 8.2.0
       arg: 4.1.3
       create-require: 1.1.1
       diff: 4.0.2
       make-error: 1.3.6
-      typescript: 4.7.2
+      typescript: 4.7.3
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
     dev: true
@@ -5863,8 +5991,8 @@ packages:
     hasBin: true
     dev: true
 
-  /typescript/4.7.2:
-    resolution: {integrity: sha512-Mamb1iX2FDUpcTRzltPxgWMKy3fhg0TN378ylbktPGPK/99KbDtMQ4W1hwgsbPAsG3a0xKa1vmw4VKZQbkvz5A==}
+  /typescript/4.7.3:
+    resolution: {integrity: sha512-WOkT3XYvrpXx4vMMqlD+8R8R37fZkjyLGlxavMc4iB8lrl8L0DeTcHbYgw/v0N/z9wAFsgBhcsF0ruoySS22mA==}
     engines: {node: '>=4.2.0'}
     hasBin: true
     dev: true
@@ -5942,7 +6070,7 @@ packages:
   /upath2/3.1.13:
     resolution: {integrity: sha512-M88uBoqgzrkXvXrF/+oSIPsTmL21uRwGhPVJKODrl+3lXkQ5NPKrTYuSBZVa+lgPGFoI6qYyHlSKACFHO0AoNw==}
     dependencies:
-      '@types/node': 17.0.36
+      '@types/node': 17.0.41
       path-is-network-drive: 1.0.15
       path-strip-sep: 1.0.12
       tslib: 2.4.0
@@ -6035,10 +6163,10 @@ packages:
       stylus:
         optional: true
     dependencies:
-      esbuild: 0.14.42
+      esbuild: 0.14.43
       postcss: 8.4.14
       resolve: 1.22.0
-      rollup: 2.75.3
+      rollup: 2.75.6
     optionalDependencies:
       fsevents: 2.3.2
     dev: true
@@ -6092,6 +6220,10 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
+  /vue-template-es2015-compiler/1.9.1:
+    resolution: {integrity: sha512-4gDntzrifFnCEvyoO8PqyJDmguXgVPxKiIxrBKjIowvL9l+N66196+72XVYR8BBf1Uv1Fgt3bGevJ+sEmxfZzw==}
+    dev: true
+
   /w3c-hr-time/1.0.2:
     resolution: {integrity: sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==}
     dependencies:
@@ -6293,19 +6425,6 @@ packages:
         optional: true
     dev: true
 
-  /ws/8.6.0:
-    resolution: {integrity: sha512-AzmM3aH3gk0aX7/rZLYvjdvZooofDu3fFOzGqcSnQ1tOcTWwhM/o+q++E8mAyVVIyUdajrkzWUGftaVSDLn1bw==}
-    engines: {node: '>=10.0.0'}
-    peerDependencies:
-      bufferutil: ^4.0.1
-      utf-8-validate: ^5.0.2
-    peerDependenciesMeta:
-      bufferutil:
-        optional: true
-      utf-8-validate:
-        optional: true
-    dev: true
-
   /ws/8.7.0:
     resolution: {integrity: sha512-c2gsP0PRwcLFzUiA8Mkr37/MI7ilIlHQxaEAtd0uNMbVMoy8puJyafRlm0bV9MbGSabUPeLrRRaqIBcFcA2Pqg==}
     engines: {node: '>=10.0.0'}
@@ -6420,7 +6539,7 @@ packages:
   'file:':
     resolution: {directory: '', type: directory}
     name: vue
-    version: 2.7.0-alpha.5
+    version: 2.7.0-alpha.6
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
       csstype: 3.1.0
diff --git a/scripts/config.js b/scripts/config.js
index 610e8d0a9ee..906077f0ec8 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -25,6 +25,12 @@ const resolve = p => {
   }
 }
 
+// we are bundling forked consolidate.js in compiler-sfc which dynamically
+// requires a ton of template engines which should be ignored.
+const consolidatePath = require.resolve('@vue/consolidate/package.json', {
+  paths: [path.resolve(__dirname, '../packages/compiler-sfc')]
+})
+
 const builds = {
   // Runtime only (CommonJS). Used by bundlers e.g. Webpack & Browserify
   'runtime-cjs-dev': {
@@ -202,12 +208,27 @@ const builds = {
     )
   },
   'compiler-sfc': {
-    entry: resolve('web/entry-compiler-sfc.ts'),
+    entry: resolve('packages/compiler-sfc/src/index.ts'),
     dest: resolve('packages/compiler-sfc/dist/compiler-sfc.js'),
     format: 'cjs',
     external: Object.keys(
       require('../packages/compiler-sfc/package.json').dependencies
-    )
+    ),
+    plugins: [
+      node({ preferBuiltins: true }),
+      cjs({
+        ignore: [
+          ...Object.keys(require(consolidatePath).devDependencies),
+          'vm',
+          'crypto',
+          'react-dom/server',
+          'teacup/lib/express',
+          'arc-templates/dist/es5',
+          'then-pug',
+          'then-jade'
+        ]
+      })
+    ]
   }
 }
 
diff --git a/src/platforms/web/entry-compiler-sfc.ts b/src/platforms/web/entry-compiler-sfc.ts
deleted file mode 100644
index eb846577ac0..00000000000
--- a/src/platforms/web/entry-compiler-sfc.ts
+++ /dev/null
@@ -1 +0,0 @@
-export function compile() {}
diff --git a/src/platforms/web/entry-compiler.ts b/src/platforms/web/entry-compiler.ts
index 679ccfaeb39..659766493d0 100644
--- a/src/platforms/web/entry-compiler.ts
+++ b/src/platforms/web/entry-compiler.ts
@@ -1,4 +1,4 @@
-export { parseComponent } from 'sfc/parser'
+export { parseComponent } from 'sfc/parseComponent'
 export { compile, compileToFunctions } from './compiler/index'
 export { ssrCompile, ssrCompileToFunctions } from 'server/compiler'
 export { generateCodeFrame } from 'compiler/codeframe'
diff --git a/src/types/compiler.ts b/src/types/compiler.ts
index fdb0aced8f3..639809ed259 100644
--- a/src/types/compiler.ts
+++ b/src/types/compiler.ts
@@ -199,26 +199,3 @@ export type ASTText = {
   start?: number
   end?: number
 }
-
-// SFC-parser related declarations
-
-// an object format describing a single-file component
-export type SFCDescriptor = {
-  template: SFCBlock | null
-  script: SFCBlock | null
-  styles: Array<SFCBlock>
-  customBlocks: Array<SFCBlock>
-  errors: Array<string | WarningMessage>
-}
-
-export type SFCBlock = {
-  type: string
-  content: string
-  attrs: { [attribute: string]: string }
-  start?: number
-  end?: number
-  lang?: string
-  src?: string
-  scoped?: boolean
-  module?: string | boolean
-}

From ed4bbed990364feafed79967e2e0cf5336ff67ce Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 10 Jun 2022 17:06:37 +0800
Subject: [PATCH 133/317] refactor: use existing types

---
 .../src/templateCompilerModules/assetUrl.ts        | 14 +++++++++-----
 .../src/templateCompilerModules/srcset.ts          |  9 ++++++---
 .../src/templateCompilerModules/utils.ts           | 10 ----------
 packages/compiler-sfc/test/compileTemplate.spec.ts |  1 -
 4 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts b/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
index 3bc490af368..07f8eb9fff8 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
@@ -1,6 +1,7 @@
 // vue compiler module for transforming `<tag>:<attribute>` to `require`
 
-import { urlToRequire, ASTNode, Attr } from './utils'
+import { urlToRequire } from './utils'
+import { ASTNode, ASTAttr } from 'types/compiler'
 
 export interface AssetURLOptions {
   [name: string]: string | string[]
@@ -43,16 +44,19 @@ function transform(
   options: AssetURLOptions,
   transformAssetUrlsOption?: TransformAssetUrlsOptions
 ) {
+  if (node.type !== 1 || !node.attrs) return
   for (const tag in options) {
-    if ((tag === '*' || node.tag === tag) && node.attrs) {
+    if (tag === '*' || node.tag === tag) {
       const attributes = options[tag]
       if (typeof attributes === 'string') {
-        node.attrs.some(attr =>
+        node.attrs!.some(attr =>
           rewrite(attr, attributes, transformAssetUrlsOption)
         )
       } else if (Array.isArray(attributes)) {
         attributes.forEach(item =>
-          node.attrs.some(attr => rewrite(attr, item, transformAssetUrlsOption))
+          node.attrs!.some(attr =>
+            rewrite(attr, item, transformAssetUrlsOption)
+          )
         )
       }
     }
@@ -60,7 +64,7 @@ function transform(
 }
 
 function rewrite(
-  attr: Attr,
+  attr: ASTAttr,
   name: string,
   transformAssetUrlsOption?: TransformAssetUrlsOptions
 ) {
diff --git a/packages/compiler-sfc/src/templateCompilerModules/srcset.ts b/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
index 7f66ab347b3..f0df692b828 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
@@ -1,7 +1,8 @@
 // vue compiler module for transforming `img:srcset` to a number of `require`s
 
-import { urlToRequire, ASTNode } from './utils'
+import { urlToRequire } from './utils'
 import { TransformAssetUrlsOptions } from './assetUrl'
+import { ASTNode } from 'types/compiler'
 
 interface ImageCandidate {
   require: string
@@ -21,9 +22,11 @@ function transform(
   node: ASTNode,
   transformAssetUrlsOptions?: TransformAssetUrlsOptions
 ) {
-  const tags = ['img', 'source']
+  if (node.type !== 1 || !node.attrs) {
+    return
+  }
 
-  if (tags.indexOf(node.tag) !== -1 && node.attrs) {
+  if (node.tag === 'img' || node.tag === 'source') {
     node.attrs.forEach(attr => {
       if (attr.name === 'srcset') {
         // same logic as in transform-require.js
diff --git a/packages/compiler-sfc/src/templateCompilerModules/utils.ts b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
index f81862cf82f..859c5f456b6 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/utils.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
@@ -2,16 +2,6 @@ import { TransformAssetUrlsOptions } from './assetUrl'
 import { UrlWithStringQuery, parse as uriParse } from 'url'
 import path from 'path'
 
-export interface Attr {
-  name: string
-  value: string
-}
-
-export interface ASTNode {
-  tag: string
-  attrs: Attr[]
-}
-
 export function urlToRequire(
   url: string,
   transformAssetUrlsOption: TransformAssetUrlsOptions = {}
diff --git a/packages/compiler-sfc/test/compileTemplate.spec.ts b/packages/compiler-sfc/test/compileTemplate.spec.ts
index aa0e226c90e..1f30c68e222 100644
--- a/packages/compiler-sfc/test/compileTemplate.spec.ts
+++ b/packages/compiler-sfc/test/compileTemplate.spec.ts
@@ -4,7 +4,6 @@ import { compileTemplate } from '../src/compileTemplate'
 import Vue from 'vue'
 
 function mockRender(code: string, mocks: Record<string, any> = {}) {
-  console.log(code)
   const fn = new Function(
     `require`,
     `${code}; return { render, staticRenderFns }`

From 22c457fe24f737505356edfb8696c7e50fd9d971 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 10 Jun 2022 18:38:09 +0800
Subject: [PATCH 134/317] wip: strip with

---
 packages/compiler-sfc/src/compileTemplate.ts  |  33 +-
 packages/compiler-sfc/src/stripWith.ts        | 452 ++++++++++++++++++
 .../compiler-sfc/test/compileStyle.spec.ts    |   2 +-
 .../compiler-sfc/test/compileTemplate.spec.ts |   2 +-
 packages/compiler-sfc/test/stripWith.spec.ts  |  55 +++
 5 files changed, 524 insertions(+), 20 deletions(-)
 create mode 100644 packages/compiler-sfc/src/stripWith.ts
 create mode 100644 packages/compiler-sfc/test/stripWith.spec.ts

diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index 8d768aa97b4..4b1933f9d38 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -10,7 +10,7 @@ import assetUrlsModule, {
 import srcsetModule from './templateCompilerModules/srcset'
 import consolidate from '@vue/consolidate'
 import * as _compiler from 'web/entry-compiler'
-import transpile from 'vue-template-es2015-compiler'
+import { stripWith } from './stripWith'
 
 export interface TemplateCompileOptions {
   source: string
@@ -26,6 +26,7 @@ export interface TemplateCompileOptions {
   isFunctional?: boolean
   optimizeSSR?: boolean
   prettify?: boolean
+  isTS?: boolean
 }
 
 export interface TemplateCompileResult {
@@ -108,7 +109,8 @@ function actuallyCompile(
     isProduction = process.env.NODE_ENV === 'production',
     isFunctional = false,
     optimizeSSR = false,
-    prettify = true
+    prettify = true,
+    isTS = false
   } = options
 
   const compile =
@@ -142,25 +144,20 @@ function actuallyCompile(
       errors
     }
   } else {
-    // TODO better transpile
-    const finalTranspileOptions = Object.assign({}, transpileOptions, {
-      transforms: Object.assign({}, transpileOptions.transforms, {
-        stripWithFunctional: isFunctional
-      })
-    })
-
-    const toFunction = (code: string): string => {
-      return `function (${isFunctional ? `_h,_vm` : ``}) {${code}}`
-    }
-
     // transpile code with vue-template-es2015-compiler, which is a forked
     // version of Buble that applies ES2015 transforms + stripping `with` usage
     let code =
-      transpile(
-        `var __render__ = ${toFunction(render)}\n` +
-          `var __staticRenderFns__ = [${staticRenderFns.map(toFunction)}]`,
-        finalTranspileOptions
-      ) + `\n`
+      `var __render__ = ${stripWith(
+        render,
+        `render`,
+        isFunctional,
+        isTS,
+        transpileOptions
+      )}\n` +
+      `var __staticRenderFns__ = [${staticRenderFns.map(code =>
+        stripWith(code, ``, isFunctional, isTS, transpileOptions)
+      )}]` +
+      `\n`
 
     // #23 we use __render__ to avoid `render` not being prefixed by the
     // transpiler when stripping with, but revert it back to `render` to
diff --git a/packages/compiler-sfc/src/stripWith.ts b/packages/compiler-sfc/src/stripWith.ts
new file mode 100644
index 00000000000..4f22e051b1f
--- /dev/null
+++ b/packages/compiler-sfc/src/stripWith.ts
@@ -0,0 +1,452 @@
+import MagicString from 'magic-string'
+import { parseExpression, ParserOptions, ParserPlugin } from '@babel/parser'
+import { walk } from 'estree-walker'
+import { makeMap } from 'shared/util'
+
+import type {
+  Identifier,
+  Node,
+  Function,
+  ObjectProperty,
+  BlockStatement,
+  Program
+} from '@babel/types'
+
+const doNotPrefix = makeMap(
+  'Infinity,undefined,NaN,isFinite,isNaN,' +
+    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
+    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
+    'require,' + // for webpack
+    'arguments,' + // parsed as identifier but is a special keyword...
+    '_c' // cached to save property access
+)
+
+/**
+ * The input is expected to be the render function code directly returned from
+ * `compile()` calls, e.g. `with(this){return ...}`
+ */
+export function stripWith(
+  source: string,
+  fnName = '',
+  isFunctional = false,
+  isTS = false,
+  babelOptions: ParserOptions = {}
+) {
+  source = `function ${fnName}(${isFunctional ? `_c,_vm` : ``}){${source}\n}`
+
+  const s = new MagicString(source)
+
+  const plugins: ParserPlugin[] = [
+    ...(isTS ? (['typescript'] as const) : []),
+    ...(babelOptions?.plugins || [])
+  ]
+
+  const ast = parseExpression(source, {
+    ...babelOptions,
+    plugins
+  })
+
+  const parentStack: Node[] = []
+  const knownIds: Record<string, number> = Object.create(null)
+
+  // based on https://github.com/vuejs/core/blob/main/packages/compiler-core/src/babelUtils.ts
+  ;(walk as any)(ast, {
+    enter(node: Node & { scopeIds?: Set<string> }, parent: Node | undefined) {
+      parent && parentStack.push(parent)
+      if (
+        parent &&
+        parent.type.startsWith('TS') &&
+        parent.type !== 'TSAsExpression' &&
+        parent.type !== 'TSNonNullExpression' &&
+        parent.type !== 'TSTypeAssertion'
+      ) {
+        return this.skip()
+      }
+
+      if (node.type === 'WithStatement') {
+        s.remove(node.start!, node.body.start! + 1)
+        s.remove(node.end! - 1, node.end!)
+        if (!isFunctional) {
+          s.prependRight(node.start!, `var _vm=this;var _c=_vm._self._c;`)
+        }
+      }
+
+      if (node.type === 'Identifier') {
+        const isLocal = !!knownIds[node.name]
+        const isRefed = isReferencedIdentifier(node, parent!, parentStack)
+        if (isRefed && !isLocal) {
+          if (doNotPrefix(node.name)) {
+            return
+          }
+          s.prependRight(node.start!, '_vm.')
+        }
+      } else if (
+        node.type === 'ObjectProperty' &&
+        parent!.type === 'ObjectPattern'
+      ) {
+        // mark property in destructure pattern
+        ;(node as any).inPattern = true
+      } else if (isFunctionType(node)) {
+        // walk function expressions and add its arguments to known identifiers
+        // so that we don't prefix them
+        walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds))
+      } else if (node.type === 'BlockStatement') {
+        // #3445 record block-level local variables
+        walkBlockDeclarations(node, id =>
+          markScopeIdentifier(node, id, knownIds)
+        )
+      }
+    },
+    leave(node: Node & { scopeIds?: Set<string> }, parent: Node | undefined) {
+      parent && parentStack.pop()
+      if (node !== ast && node.scopeIds) {
+        for (const id of node.scopeIds) {
+          knownIds[id]--
+          if (knownIds[id] === 0) {
+            delete knownIds[id]
+          }
+        }
+      }
+    }
+  })
+
+  return s.toString()
+}
+
+export function isReferencedIdentifier(
+  id: Identifier,
+  parent: Node | null,
+  parentStack: Node[]
+) {
+  if (!parent) {
+    return true
+  }
+
+  // is a special keyword but parsed as identifier
+  if (id.name === 'arguments') {
+    return false
+  }
+
+  if (isReferenced(id, parent)) {
+    return true
+  }
+
+  // babel's isReferenced check returns false for ids being assigned to, so we
+  // need to cover those cases here
+  switch (parent.type) {
+    case 'AssignmentExpression':
+    case 'AssignmentPattern':
+      return true
+    case 'ObjectPattern':
+    case 'ArrayPattern':
+      return isInDestructureAssignment(parent, parentStack)
+  }
+
+  return false
+}
+
+export function isInDestructureAssignment(
+  parent: Node,
+  parentStack: Node[]
+): boolean {
+  if (
+    parent &&
+    (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')
+  ) {
+    let i = parentStack.length
+    while (i--) {
+      const p = parentStack[i]
+      if (p.type === 'AssignmentExpression') {
+        return true
+      } else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
+        break
+      }
+    }
+  }
+  return false
+}
+
+export function walkFunctionParams(
+  node: Function,
+  onIdent: (id: Identifier) => void
+) {
+  for (const p of node.params) {
+    for (const id of extractIdentifiers(p)) {
+      onIdent(id)
+    }
+  }
+}
+
+export function walkBlockDeclarations(
+  block: BlockStatement | Program,
+  onIdent: (node: Identifier) => void
+) {
+  for (const stmt of block.body) {
+    if (stmt.type === 'VariableDeclaration') {
+      if (stmt.declare) continue
+      for (const decl of stmt.declarations) {
+        for (const id of extractIdentifiers(decl.id)) {
+          onIdent(id)
+        }
+      }
+    } else if (
+      stmt.type === 'FunctionDeclaration' ||
+      stmt.type === 'ClassDeclaration'
+    ) {
+      if (stmt.declare || !stmt.id) continue
+      onIdent(stmt.id)
+    }
+  }
+}
+
+export function extractIdentifiers(
+  param: Node,
+  nodes: Identifier[] = []
+): Identifier[] {
+  switch (param.type) {
+    case 'Identifier':
+      nodes.push(param)
+      break
+
+    case 'MemberExpression':
+      let object: any = param
+      while (object.type === 'MemberExpression') {
+        object = object.object
+      }
+      nodes.push(object)
+      break
+
+    case 'ObjectPattern':
+      for (const prop of param.properties) {
+        if (prop.type === 'RestElement') {
+          extractIdentifiers(prop.argument, nodes)
+        } else {
+          extractIdentifiers(prop.value, nodes)
+        }
+      }
+      break
+
+    case 'ArrayPattern':
+      param.elements.forEach(element => {
+        if (element) extractIdentifiers(element, nodes)
+      })
+      break
+
+    case 'RestElement':
+      extractIdentifiers(param.argument, nodes)
+      break
+
+    case 'AssignmentPattern':
+      extractIdentifiers(param.left, nodes)
+      break
+  }
+
+  return nodes
+}
+
+export function markScopeIdentifier(
+  node: Node & { scopeIds?: Set<string> },
+  child: Identifier,
+  knownIds: Record<string, number>
+) {
+  const { name } = child
+  if (node.scopeIds && node.scopeIds.has(name)) {
+    return
+  }
+  if (name in knownIds) {
+    knownIds[name]++
+  } else {
+    knownIds[name] = 1
+  }
+  ;(node.scopeIds || (node.scopeIds = new Set())).add(name)
+}
+
+export const isFunctionType = (node: Node): node is Function => {
+  return /Function(?:Expression|Declaration)$|Method$/.test(node.type)
+}
+
+export const isStaticProperty = (node: Node): node is ObjectProperty =>
+  node &&
+  (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
+  !node.computed
+
+export const isStaticPropertyKey = (node: Node, parent: Node) =>
+  isStaticProperty(parent) && parent.key === node
+
+/**
+ * Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts
+ * To avoid runtime dependency on @babel/types (which includes process references)
+ * This file should not change very often in babel but we may need to keep it
+ * up-to-date from time to time.
+ *
+ * https://github.com/babel/babel/blob/main/LICENSE
+ *
+ */
+function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean {
+  switch (parent.type) {
+    // yes: PARENT[NODE]
+    // yes: NODE.child
+    // no: parent.NODE
+    case 'MemberExpression':
+    case 'OptionalMemberExpression':
+      if (parent.property === node) {
+        return !!parent.computed
+      }
+      return parent.object === node
+
+    case 'JSXMemberExpression':
+      return parent.object === node
+    // no: let NODE = init;
+    // yes: let id = NODE;
+    case 'VariableDeclarator':
+      return parent.init === node
+
+    // yes: () => NODE
+    // no: (NODE) => {}
+    case 'ArrowFunctionExpression':
+      return parent.body === node
+
+    // no: class { #NODE; }
+    // no: class { get #NODE() {} }
+    // no: class { #NODE() {} }
+    // no: class { fn() { return this.#NODE; } }
+    case 'PrivateName':
+      return false
+
+    // no: class { NODE() {} }
+    // yes: class { [NODE]() {} }
+    // no: class { foo(NODE) {} }
+    case 'ClassMethod':
+    case 'ClassPrivateMethod':
+    case 'ObjectMethod':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+      return false
+
+    // yes: { [NODE]: "" }
+    // no: { NODE: "" }
+    // depends: { NODE }
+    // depends: { key: NODE }
+    case 'ObjectProperty':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+      // parent.value === node
+      return !grandparent || grandparent.type !== 'ObjectPattern'
+    // no: class { NODE = value; }
+    // yes: class { [NODE] = value; }
+    // yes: class { key = NODE; }
+    case 'ClassProperty':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+      return true
+    case 'ClassPrivateProperty':
+      return parent.key !== node
+
+    // no: class NODE {}
+    // yes: class Foo extends NODE {}
+    case 'ClassDeclaration':
+    case 'ClassExpression':
+      return parent.superClass === node
+
+    // yes: left = NODE;
+    // no: NODE = right;
+    case 'AssignmentExpression':
+      return parent.right === node
+
+    // no: [NODE = foo] = [];
+    // yes: [foo = NODE] = [];
+    case 'AssignmentPattern':
+      return parent.right === node
+
+    // no: NODE: for (;;) {}
+    case 'LabeledStatement':
+      return false
+
+    // no: try {} catch (NODE) {}
+    case 'CatchClause':
+      return false
+
+    // no: function foo(...NODE) {}
+    case 'RestElement':
+      return false
+
+    case 'BreakStatement':
+    case 'ContinueStatement':
+      return false
+
+    // no: function NODE() {}
+    // no: function foo(NODE) {}
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+      return false
+
+    // no: export NODE from "foo";
+    // no: export * as NODE from "foo";
+    case 'ExportNamespaceSpecifier':
+    case 'ExportDefaultSpecifier':
+      return false
+
+    // no: export { foo as NODE };
+    // yes: export { NODE as foo };
+    // no: export { NODE as foo } from "foo";
+    case 'ExportSpecifier':
+      // @ts-expect-error
+      if (grandparent?.source) {
+        return false
+      }
+      return parent.local === node
+
+    // no: import NODE from "foo";
+    // no: import * as NODE from "foo";
+    // no: import { NODE as foo } from "foo";
+    // no: import { foo as NODE } from "foo";
+    // no: import NODE from "bar";
+    case 'ImportDefaultSpecifier':
+    case 'ImportNamespaceSpecifier':
+    case 'ImportSpecifier':
+      return false
+
+    // no: import "foo" assert { NODE: "json" }
+    case 'ImportAttribute':
+      return false
+
+    // no: <div NODE="foo" />
+    case 'JSXAttribute':
+      return false
+
+    // no: [NODE] = [];
+    // no: ({ NODE }) = [];
+    case 'ObjectPattern':
+    case 'ArrayPattern':
+      return false
+
+    // no: new.NODE
+    // no: NODE.target
+    case 'MetaProperty':
+      return false
+
+    // yes: type X = { someProperty: NODE }
+    // no: type X = { NODE: OtherType }
+    case 'ObjectTypeProperty':
+      return parent.key !== node
+
+    // yes: enum X { Foo = NODE }
+    // no: enum X { NODE }
+    case 'TSEnumMember':
+      return parent.id !== node
+
+    // yes: { [NODE]: value }
+    // no: { NODE: value }
+    case 'TSPropertySignature':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+
+      return true
+  }
+
+  return true
+}
diff --git a/packages/compiler-sfc/test/compileStyle.spec.ts b/packages/compiler-sfc/test/compileStyle.spec.ts
index 6f2a4f69013..df13c6e634b 100644
--- a/packages/compiler-sfc/test/compileStyle.spec.ts
+++ b/packages/compiler-sfc/test/compileStyle.spec.ts
@@ -1,7 +1,7 @@
 import { parse } from '../src/parse'
 import { compileStyle, compileStyleAsync } from '../src/compileStyle'
 
-test.only('preprocess less', () => {
+test('preprocess less', () => {
   const style = parse({
     source:
       '<style lang="less">\n' +
diff --git a/packages/compiler-sfc/test/compileTemplate.spec.ts b/packages/compiler-sfc/test/compileTemplate.spec.ts
index 1f30c68e222..d679dc7b136 100644
--- a/packages/compiler-sfc/test/compileTemplate.spec.ts
+++ b/packages/compiler-sfc/test/compileTemplate.spec.ts
@@ -115,7 +115,7 @@ test('warn missing preprocessor', () => {
   expect(result.errors.length).toBe(1)
 })
 
-test.only('transform assetUrls', () => {
+test('transform assetUrls', () => {
   const source = `
 <div>
   <img src="./logo.png">
diff --git a/packages/compiler-sfc/test/stripWith.spec.ts b/packages/compiler-sfc/test/stripWith.spec.ts
new file mode 100644
index 00000000000..f6c0d82c6eb
--- /dev/null
+++ b/packages/compiler-sfc/test/stripWith.spec.ts
@@ -0,0 +1,55 @@
+import { stripWith } from '../src/stripWith'
+import { compile } from 'web/entry-compiler'
+import { format } from 'prettier'
+
+it('should work', () => {
+  const { render } = compile(`<div id="app">
+  <div>{{ foo }}</div>
+  <p v-for="i in list">{{ i }}</p>
+  <foo inline-template>
+    <div>{{ bar }}</div>
+  </foo>
+</div>`)
+
+  const result = format(stripWith(render, `render`), {
+    semi: false,
+    parser: 'babel'
+  })
+
+  expect(result).not.toMatch(`_vm._c`)
+  expect(result).toMatch(`_vm.foo`)
+  expect(result).toMatch(`_vm.list`)
+  expect(result).not.toMatch(`_vm.i`)
+  expect(result).not.toMatch(`with (this)`)
+
+  expect(result).toMatchInlineSnapshot(`
+    "function render() {
+      var _vm = this
+      var _c = _vm._self._c
+      return _c(
+        \\"div\\",
+        { attrs: { id: \\"app\\" } },
+        [
+          _c(\\"div\\", [_vm._v(_vm._s(_vm.foo))]),
+          _vm._v(\\" \\"),
+          _vm._l(_vm.list, function (i) {
+            return _c(\\"p\\", [_vm._v(_vm._s(i))])
+          }),
+          _vm._v(\\" \\"),
+          _c(\\"foo\\", {
+            inlineTemplate: {
+              render: function () {
+                var _vm = this
+                var _c = _vm._self._c
+                return _c(\\"div\\", [_vm._v(_vm._s(_vm.bar))])
+              },
+              staticRenderFns: [],
+            },
+          }),
+        ],
+        2
+      )
+    }
+    "
+  `)
+})

From 5bee34c6e1a215ae693351aad8f77b58e07b1d4f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 10 Jun 2022 18:40:13 +0800
Subject: [PATCH 135/317] chore: test pass

---
 packages/compiler-sfc/test/compileStyle.spec.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/packages/compiler-sfc/test/compileStyle.spec.ts b/packages/compiler-sfc/test/compileStyle.spec.ts
index df13c6e634b..9764779593e 100644
--- a/packages/compiler-sfc/test/compileStyle.spec.ts
+++ b/packages/compiler-sfc/test/compileStyle.spec.ts
@@ -30,7 +30,7 @@ test('preprocess scss', () => {
   const style = parse({
     source:
       '<style lang="scss">\n' +
-      '$red: rgb(255, 0, 0);\n' +
+      '$red: red;\n' +
       '.color { color: $red; }\n' +
       '</style>\n',
     filename: 'example.vue',
@@ -46,7 +46,7 @@ test('preprocess scss', () => {
   })
 
   expect(result.errors.length).toBe(0)
-  expect(result.code).toEqual(expect.stringContaining('color: red;'))
+  expect(result.code).toMatch('color: red;')
   expect(result.map).toBeTruthy()
 })
 
@@ -54,7 +54,7 @@ test('preprocess sass', () => {
   const style = parse({
     source:
       '<style lang="sass">\n' +
-      '$red: rgb(255, 0, 0)\n' +
+      '$red: red\n' +
       '.color\n' +
       '   color: $red\n' +
       '</style>\n',
@@ -71,7 +71,7 @@ test('preprocess sass', () => {
   })
 
   expect(result.errors.length).toBe(0)
-  expect(result.code).toEqual(expect.stringContaining('color: red;'))
+  expect(result.code).toMatch('color: red;')
   expect(result.map).toBeTruthy()
 })
 

From 4306cc67b9bfc464918acb446f5a6d1ce0156da1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 10 Jun 2022 22:51:41 +0800
Subject: [PATCH 136/317] build: fix compiler-sfc build

---
 package.json      | 3 ++-
 scripts/config.js | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 120c05e244f..690c92ceb2e 100644
--- a/package.json
+++ b/package.json
@@ -30,7 +30,8 @@
       "require": "./compiler-sfc/index.js"
     },
     "./dist/*": "./dist/*",
-    "./types/*": "./types/*"
+    "./types/*": "./types/*",
+    "./package.json": "./package.json"
   },
   "sideEffects": false,
   "scripts": {
diff --git a/scripts/config.js b/scripts/config.js
index 906077f0ec8..0fc581bb682 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -211,6 +211,7 @@ const builds = {
     entry: resolve('packages/compiler-sfc/src/index.ts'),
     dest: resolve('packages/compiler-sfc/dist/compiler-sfc.js'),
     format: 'cjs',
+    transpile: false,
     external: Object.keys(
       require('../packages/compiler-sfc/package.json').dependencies
     ),

From ba08e968772f74d1d63411c02a38146e613301cc Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 10 Jun 2022 23:46:47 +0800
Subject: [PATCH 137/317] wip: compileScript

---
 packages/compiler-sfc/src/babelUtils.ts      |  423 ++++
 packages/compiler-sfc/src/compileScript.ts   | 1949 ++++++++++++++++++
 packages/compiler-sfc/src/compileTemplate.ts |   11 +-
 packages/compiler-sfc/src/parseComponent.ts  |   37 +-
 packages/compiler-sfc/src/stripWith.ts       |  412 +---
 packages/compiler-sfc/src/types.ts           |   59 +-
 src/v3/apiSetup.ts                           |    2 +
 7 files changed, 2473 insertions(+), 420 deletions(-)
 create mode 100644 packages/compiler-sfc/src/babelUtils.ts
 create mode 100644 packages/compiler-sfc/src/compileScript.ts

diff --git a/packages/compiler-sfc/src/babelUtils.ts b/packages/compiler-sfc/src/babelUtils.ts
new file mode 100644
index 00000000000..306cb8077a7
--- /dev/null
+++ b/packages/compiler-sfc/src/babelUtils.ts
@@ -0,0 +1,423 @@
+// https://github.com/vuejs/core/blob/main/packages/compiler-core/src/babelUtils.ts
+
+// should only use types from @babel/types
+// do not import runtime methods
+import type {
+  Identifier,
+  Node,
+  Function,
+  ObjectProperty,
+  BlockStatement,
+  Program
+} from '@babel/types'
+import { walk } from 'estree-walker'
+
+export function walkIdentifiers(
+  root: Node,
+  onIdentifier: (
+    node: Identifier,
+    parent: Node,
+    parentStack: Node[],
+    isReference: boolean,
+    isLocal: boolean
+  ) => void,
+  onNode?: (node: Node) => void
+) {
+  const includeAll = false
+  const parentStack: Node[] = []
+  const knownIds: Record<string, number> = Object.create(null)
+
+  const rootExp =
+    root.type === 'Program' &&
+    root.body[0].type === 'ExpressionStatement' &&
+    root.body[0].expression
+
+  ;(walk as any)(root, {
+    enter(node: Node & { scopeIds?: Set<string> }, parent: Node | undefined) {
+      parent && parentStack.push(parent)
+      if (
+        parent &&
+        parent.type.startsWith('TS') &&
+        parent.type !== 'TSAsExpression' &&
+        parent.type !== 'TSNonNullExpression' &&
+        parent.type !== 'TSTypeAssertion'
+      ) {
+        return this.skip()
+      }
+
+      if (onNode) onNode(node)
+
+      if (node.type === 'Identifier') {
+        const isLocal = !!knownIds[node.name]
+        const isRefed = isReferencedIdentifier(node, parent!, parentStack)
+        if (includeAll || (isRefed && !isLocal)) {
+          onIdentifier(node, parent!, parentStack, isRefed, isLocal)
+        }
+      } else if (
+        node.type === 'ObjectProperty' &&
+        parent!.type === 'ObjectPattern'
+      ) {
+        // mark property in destructure pattern
+        ;(node as any).inPattern = true
+      } else if (isFunctionType(node)) {
+        // walk function expressions and add its arguments to known identifiers
+        // so that we don't prefix them
+        walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds))
+      } else if (node.type === 'BlockStatement') {
+        // #3445 record block-level local variables
+        walkBlockDeclarations(node, id =>
+          markScopeIdentifier(node, id, knownIds)
+        )
+      }
+    },
+    leave(node: Node & { scopeIds?: Set<string> }, parent: Node | undefined) {
+      parent && parentStack.pop()
+      if (node !== rootExp && node.scopeIds) {
+        for (const id of node.scopeIds) {
+          knownIds[id]--
+          if (knownIds[id] === 0) {
+            delete knownIds[id]
+          }
+        }
+      }
+    }
+  })
+}
+
+export function isReferencedIdentifier(
+  id: Identifier,
+  parent: Node | null,
+  parentStack: Node[]
+) {
+  if (!parent) {
+    return true
+  }
+
+  // is a special keyword but parsed as identifier
+  if (id.name === 'arguments') {
+    return false
+  }
+
+  if (isReferenced(id, parent)) {
+    return true
+  }
+
+  // babel's isReferenced check returns false for ids being assigned to, so we
+  // need to cover those cases here
+  switch (parent.type) {
+    case 'AssignmentExpression':
+    case 'AssignmentPattern':
+      return true
+    case 'ObjectPattern':
+    case 'ArrayPattern':
+      return isInDestructureAssignment(parent, parentStack)
+  }
+
+  return false
+}
+
+export function isInDestructureAssignment(
+  parent: Node,
+  parentStack: Node[]
+): boolean {
+  if (
+    parent &&
+    (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')
+  ) {
+    let i = parentStack.length
+    while (i--) {
+      const p = parentStack[i]
+      if (p.type === 'AssignmentExpression') {
+        return true
+      } else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
+        break
+      }
+    }
+  }
+  return false
+}
+
+export function walkFunctionParams(
+  node: Function,
+  onIdent: (id: Identifier) => void
+) {
+  for (const p of node.params) {
+    for (const id of extractIdentifiers(p)) {
+      onIdent(id)
+    }
+  }
+}
+
+export function walkBlockDeclarations(
+  block: BlockStatement | Program,
+  onIdent: (node: Identifier) => void
+) {
+  for (const stmt of block.body) {
+    if (stmt.type === 'VariableDeclaration') {
+      if (stmt.declare) continue
+      for (const decl of stmt.declarations) {
+        for (const id of extractIdentifiers(decl.id)) {
+          onIdent(id)
+        }
+      }
+    } else if (
+      stmt.type === 'FunctionDeclaration' ||
+      stmt.type === 'ClassDeclaration'
+    ) {
+      if (stmt.declare || !stmt.id) continue
+      onIdent(stmt.id)
+    }
+  }
+}
+
+export function extractIdentifiers(
+  param: Node,
+  nodes: Identifier[] = []
+): Identifier[] {
+  switch (param.type) {
+    case 'Identifier':
+      nodes.push(param)
+      break
+
+    case 'MemberExpression':
+      let object: any = param
+      while (object.type === 'MemberExpression') {
+        object = object.object
+      }
+      nodes.push(object)
+      break
+
+    case 'ObjectPattern':
+      for (const prop of param.properties) {
+        if (prop.type === 'RestElement') {
+          extractIdentifiers(prop.argument, nodes)
+        } else {
+          extractIdentifiers(prop.value, nodes)
+        }
+      }
+      break
+
+    case 'ArrayPattern':
+      param.elements.forEach(element => {
+        if (element) extractIdentifiers(element, nodes)
+      })
+      break
+
+    case 'RestElement':
+      extractIdentifiers(param.argument, nodes)
+      break
+
+    case 'AssignmentPattern':
+      extractIdentifiers(param.left, nodes)
+      break
+  }
+
+  return nodes
+}
+
+function markScopeIdentifier(
+  node: Node & { scopeIds?: Set<string> },
+  child: Identifier,
+  knownIds: Record<string, number>
+) {
+  const { name } = child
+  if (node.scopeIds && node.scopeIds.has(name)) {
+    return
+  }
+  if (name in knownIds) {
+    knownIds[name]++
+  } else {
+    knownIds[name] = 1
+  }
+  ;(node.scopeIds || (node.scopeIds = new Set())).add(name)
+}
+
+export const isFunctionType = (node: Node): node is Function => {
+  return /Function(?:Expression|Declaration)$|Method$/.test(node.type)
+}
+
+export const isStaticProperty = (node: Node): node is ObjectProperty =>
+  node &&
+  (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
+  !node.computed
+
+export const isStaticPropertyKey = (node: Node, parent: Node) =>
+  isStaticProperty(parent) && parent.key === node
+
+/**
+ * Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts
+ * To avoid runtime dependency on @babel/types (which includes process references)
+ * This file should not change very often in babel but we may need to keep it
+ * up-to-date from time to time.
+ *
+ * https://github.com/babel/babel/blob/main/LICENSE
+ *
+ */
+function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean {
+  switch (parent.type) {
+    // yes: PARENT[NODE]
+    // yes: NODE.child
+    // no: parent.NODE
+    case 'MemberExpression':
+    case 'OptionalMemberExpression':
+      if (parent.property === node) {
+        return !!parent.computed
+      }
+      return parent.object === node
+
+    case 'JSXMemberExpression':
+      return parent.object === node
+    // no: let NODE = init;
+    // yes: let id = NODE;
+    case 'VariableDeclarator':
+      return parent.init === node
+
+    // yes: () => NODE
+    // no: (NODE) => {}
+    case 'ArrowFunctionExpression':
+      return parent.body === node
+
+    // no: class { #NODE; }
+    // no: class { get #NODE() {} }
+    // no: class { #NODE() {} }
+    // no: class { fn() { return this.#NODE; } }
+    case 'PrivateName':
+      return false
+
+    // no: class { NODE() {} }
+    // yes: class { [NODE]() {} }
+    // no: class { foo(NODE) {} }
+    case 'ClassMethod':
+    case 'ClassPrivateMethod':
+    case 'ObjectMethod':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+      return false
+
+    // yes: { [NODE]: "" }
+    // no: { NODE: "" }
+    // depends: { NODE }
+    // depends: { key: NODE }
+    case 'ObjectProperty':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+      // parent.value === node
+      return !grandparent || grandparent.type !== 'ObjectPattern'
+    // no: class { NODE = value; }
+    // yes: class { [NODE] = value; }
+    // yes: class { key = NODE; }
+    case 'ClassProperty':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+      return true
+    case 'ClassPrivateProperty':
+      return parent.key !== node
+
+    // no: class NODE {}
+    // yes: class Foo extends NODE {}
+    case 'ClassDeclaration':
+    case 'ClassExpression':
+      return parent.superClass === node
+
+    // yes: left = NODE;
+    // no: NODE = right;
+    case 'AssignmentExpression':
+      return parent.right === node
+
+    // no: [NODE = foo] = [];
+    // yes: [foo = NODE] = [];
+    case 'AssignmentPattern':
+      return parent.right === node
+
+    // no: NODE: for (;;) {}
+    case 'LabeledStatement':
+      return false
+
+    // no: try {} catch (NODE) {}
+    case 'CatchClause':
+      return false
+
+    // no: function foo(...NODE) {}
+    case 'RestElement':
+      return false
+
+    case 'BreakStatement':
+    case 'ContinueStatement':
+      return false
+
+    // no: function NODE() {}
+    // no: function foo(NODE) {}
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+      return false
+
+    // no: export NODE from "foo";
+    // no: export * as NODE from "foo";
+    case 'ExportNamespaceSpecifier':
+    case 'ExportDefaultSpecifier':
+      return false
+
+    // no: export { foo as NODE };
+    // yes: export { NODE as foo };
+    // no: export { NODE as foo } from "foo";
+    case 'ExportSpecifier':
+      // @ts-expect-error
+      if (grandparent?.source) {
+        return false
+      }
+      return parent.local === node
+
+    // no: import NODE from "foo";
+    // no: import * as NODE from "foo";
+    // no: import { NODE as foo } from "foo";
+    // no: import { foo as NODE } from "foo";
+    // no: import NODE from "bar";
+    case 'ImportDefaultSpecifier':
+    case 'ImportNamespaceSpecifier':
+    case 'ImportSpecifier':
+      return false
+
+    // no: import "foo" assert { NODE: "json" }
+    case 'ImportAttribute':
+      return false
+
+    // no: <div NODE="foo" />
+    case 'JSXAttribute':
+      return false
+
+    // no: [NODE] = [];
+    // no: ({ NODE }) = [];
+    case 'ObjectPattern':
+    case 'ArrayPattern':
+      return false
+
+    // no: new.NODE
+    // no: NODE.target
+    case 'MetaProperty':
+      return false
+
+    // yes: type X = { someProperty: NODE }
+    // no: type X = { NODE: OtherType }
+    case 'ObjectTypeProperty':
+      return parent.key !== node
+
+    // yes: enum X { Foo = NODE }
+    // no: enum X { NODE }
+    case 'TSEnumMember':
+      return parent.id !== node
+
+    // yes: { [NODE]: value }
+    // no: { NODE: value }
+    case 'TSPropertySignature':
+      if (parent.key === node) {
+        return !!parent.computed
+      }
+
+      return true
+  }
+
+  return true
+}
diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
new file mode 100644
index 00000000000..1d565c02838
--- /dev/null
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -0,0 +1,1949 @@
+import MagicString from 'magic-string'
+import LRU from 'lru-cache'
+import { walkIdentifiers, isFunctionType } from './babelUtils'
+import { BindingMetadata, BindingTypes } from './types'
+import { SFCDescriptor, SFCScriptBlock } from './parseComponent'
+import {
+  parse as _parse,
+  parseExpression,
+  ParserOptions,
+  ParserPlugin
+} from '@babel/parser'
+import { generateCodeFrame } from 'compiler/codeframe'
+import { camelize, capitalize, makeMap } from 'shared/util'
+import {
+  Node,
+  Declaration,
+  ObjectPattern,
+  ObjectExpression,
+  ArrayPattern,
+  Identifier,
+  ExportSpecifier,
+  TSType,
+  TSTypeLiteral,
+  TSFunctionType,
+  ObjectProperty,
+  ArrayExpression,
+  Statement,
+  CallExpression,
+  RestElement,
+  TSInterfaceBody,
+  AwaitExpression,
+  Program,
+  ObjectMethod,
+  LVal,
+  Expression
+} from '@babel/types'
+import { walk } from 'estree-walker'
+import { RawSourceMap } from 'source-map'
+import { warnOnce } from './warn'
+
+// Special compiler macros
+const DEFINE_PROPS = 'defineProps'
+const DEFINE_EMITS = 'defineEmits'
+const DEFINE_EXPOSE = 'defineExpose'
+const WITH_DEFAULTS = 'withDefaults'
+
+// constants
+const DEFAULT_VAR = `__default__`
+
+const isBuiltInDir = makeMap(
+  `once,memo,if,for,else,else-if,slot,text,html,on,bind,model,show,cloak,is`
+)
+
+export interface SFCScriptCompileOptions {
+  filename: string
+  /**
+   * Production mode. Used to determine whether to generate hashed CSS variables
+   */
+  isProd?: boolean
+  /**
+   * Enable/disable source map. Defaults to true.
+   */
+  sourceMap?: boolean
+  /**
+   * https://babeljs.io/docs/en/babel-parser#plugins
+   */
+  babelParserPlugins?: ParserPlugin[]
+}
+
+export interface ImportBinding {
+  isType: boolean
+  imported: string
+  source: string
+  isFromSetup: boolean
+  isUsedInTemplate: boolean
+}
+
+/**
+ * Compile `<script setup>`
+ * It requires the whole SFC descriptor because we need to handle and merge
+ * normal `<script>` + `<script setup>` if both are present.
+ */
+export function compileScript(
+  sfc: SFCDescriptor,
+  options: SFCScriptCompileOptions
+): SFCScriptBlock {
+  let { script, scriptSetup, source } = sfc
+  const { filename } = options
+  const isProd = !!options.isProd
+  const genSourceMap = options.sourceMap !== false
+  let refBindings: string[] | undefined
+
+  // const cssVars = sfc.cssVars
+  const scriptLang = script && script.lang
+  const scriptSetupLang = scriptSetup && scriptSetup.lang
+  const isTS =
+    scriptLang === 'ts' ||
+    scriptLang === 'tsx' ||
+    scriptSetupLang === 'ts' ||
+    scriptSetupLang === 'tsx'
+
+  // resolve parser plugins
+  const plugins: ParserPlugin[] = []
+  if (!isTS || scriptLang === 'tsx' || scriptSetupLang === 'tsx') {
+    plugins.push('jsx')
+  } else {
+    // If don't match the case of adding jsx, should remove the jsx from the babelParserPlugins
+    if (options.babelParserPlugins)
+      options.babelParserPlugins = options.babelParserPlugins.filter(
+        n => n !== 'jsx'
+      )
+  }
+  if (options.babelParserPlugins) plugins.push(...options.babelParserPlugins)
+  if (isTS) plugins.push('typescript', 'decorators-legacy')
+
+  if (!scriptSetup) {
+    if (!script) {
+      throw new Error(`[@vue/compiler-sfc] SFC contains no <script> tags.`)
+    }
+    if (scriptLang && !isTS && scriptLang !== 'jsx') {
+      // do not process non js/ts script blocks
+      return script
+    }
+    try {
+      let content = script.content
+      let map = script.map
+      const scriptAst = _parse(content, {
+        plugins,
+        sourceType: 'module'
+      }).program
+      const bindings = analyzeScriptBindings(scriptAst.body)
+      return {
+        ...script,
+        content,
+        map,
+        bindings,
+        scriptAst: scriptAst.body
+      }
+    } catch (e: any) {
+      // silently fallback if parse fails since user may be using custom
+      // babel syntax
+      return script
+    }
+  }
+
+  if (script && scriptLang !== scriptSetupLang) {
+    throw new Error(
+      `[@vue/compiler-sfc] <script> and <script setup> must have the same ` +
+        `language type.`
+    )
+  }
+
+  if (scriptSetupLang && !isTS && scriptSetupLang !== 'jsx') {
+    // do not process non js/ts script blocks
+    return scriptSetup
+  }
+
+  // metadata that needs to be returned
+  const bindingMetadata: BindingMetadata = {}
+  const helperImports: Set<string> = new Set()
+  const userImports: Record<string, ImportBinding> = Object.create(null)
+  const userImportAlias: Record<string, string> = Object.create(null)
+  const scriptBindings: Record<string, BindingTypes> = Object.create(null)
+  const setupBindings: Record<string, BindingTypes> = Object.create(null)
+
+  let defaultExport: Node | undefined
+  let hasDefinePropsCall = false
+  let hasDefineEmitCall = false
+  let hasDefineExposeCall = false
+  let hasDefaultExportName = false
+  let propsRuntimeDecl: Node | undefined
+  let propsRuntimeDefaults: ObjectExpression | undefined
+  let propsDestructureDecl: Node | undefined
+  let propsDestructureRestId: string | undefined
+  let propsTypeDecl: TSTypeLiteral | TSInterfaceBody | undefined
+  let propsTypeDeclRaw: Node | undefined
+  let propsIdentifier: string | undefined
+  let emitsRuntimeDecl: Node | undefined
+  let emitsTypeDecl:
+    | TSFunctionType
+    | TSTypeLiteral
+    | TSInterfaceBody
+    | undefined
+  let emitsTypeDeclRaw: Node | undefined
+  let emitIdentifier: string | undefined
+  let hasAwait = false
+  let hasInlinedSsrRenderFn = false
+  // props/emits declared via types
+  const typeDeclaredProps: Record<string, PropTypeData> = {}
+  const typeDeclaredEmits: Set<string> = new Set()
+  // record declared types for runtime props type generation
+  const declaredTypes: Record<string, string[]> = {}
+  // props destructure data
+  const propsDestructuredBindings: Record<
+    string, // public prop key
+    {
+      local: string // local identifier, may be different
+      default?: Expression
+    }
+  > = Object.create(null)
+
+  // magic-string state
+  const s = new MagicString(source)
+  const startOffset = scriptSetup.loc.start.offset
+  const endOffset = scriptSetup.loc.end.offset
+  const scriptStartOffset = script && script.loc.start.offset
+  const scriptEndOffset = script && script.loc.end.offset
+
+  function helper(key: string): string {
+    helperImports.add(key)
+    return `_${key}`
+  }
+
+  function parse(
+    input: string,
+    options: ParserOptions,
+    offset: number
+  ): Program {
+    try {
+      return _parse(input, options).program
+    } catch (e: any) {
+      e.message = `[@vue/compiler-sfc] ${
+        e.message
+      }\n\n${filename}\n${generateCodeFrame(
+        source,
+        e.pos + offset,
+        e.pos + offset + 1
+      )}`
+      throw e
+    }
+  }
+
+  function error(
+    msg: string,
+    node: Node,
+    end: number = node.end! + startOffset
+  ): never {
+    throw new Error(
+      `[@vue/compiler-sfc] ${msg}\n\n${filename}\n${generateCodeFrame(
+        source,
+        node.start! + startOffset,
+        end
+      )}`
+    )
+  }
+
+  function registerUserImport(
+    source: string,
+    local: string,
+    imported: string | false,
+    isType: boolean,
+    isFromSetup: boolean,
+    needTemplateUsageCheck: boolean
+  ) {
+    if (source === 'vue' && imported) {
+      userImportAlias[imported] = local
+    }
+
+    // template usage check is only needed in non-inline mode, so we can skip
+    // the work if inlineTemplate is true.
+    let isUsedInTemplate = needTemplateUsageCheck
+    if (
+      needTemplateUsageCheck &&
+      isTS &&
+      sfc.template &&
+      !sfc.template.src &&
+      !sfc.template.lang
+    ) {
+      isUsedInTemplate = isImportUsed(local, sfc)
+    }
+
+    userImports[local] = {
+      isType,
+      imported: imported || 'default',
+      source,
+      isFromSetup,
+      isUsedInTemplate
+    }
+  }
+
+  function processDefineProps(node: Node, declId?: LVal): boolean {
+    if (!isCallOf(node, DEFINE_PROPS)) {
+      return false
+    }
+
+    if (hasDefinePropsCall) {
+      error(`duplicate ${DEFINE_PROPS}() call`, node)
+    }
+    hasDefinePropsCall = true
+
+    propsRuntimeDecl = node.arguments[0]
+
+    // call has type parameters - infer runtime types from it
+    if (node.typeParameters) {
+      if (propsRuntimeDecl) {
+        error(
+          `${DEFINE_PROPS}() cannot accept both type and non-type arguments ` +
+            `at the same time. Use one or the other.`,
+          node
+        )
+      }
+
+      propsTypeDeclRaw = node.typeParameters.params[0]
+      propsTypeDecl = resolveQualifiedType(
+        propsTypeDeclRaw,
+        node => node.type === 'TSTypeLiteral'
+      ) as TSTypeLiteral | TSInterfaceBody | undefined
+
+      if (!propsTypeDecl) {
+        error(
+          `type argument passed to ${DEFINE_PROPS}() must be a literal type, ` +
+            `or a reference to an interface or literal type.`,
+          propsTypeDeclRaw
+        )
+      }
+    }
+
+    if (declId) {
+      propsIdentifier = scriptSetup!.content.slice(declId.start!, declId.end!)
+    }
+
+    return true
+  }
+
+  function processWithDefaults(node: Node, declId?: LVal): boolean {
+    if (!isCallOf(node, WITH_DEFAULTS)) {
+      return false
+    }
+    if (processDefineProps(node.arguments[0], declId)) {
+      if (propsRuntimeDecl) {
+        error(
+          `${WITH_DEFAULTS} can only be used with type-based ` +
+            `${DEFINE_PROPS} declaration.`,
+          node
+        )
+      }
+      if (propsDestructureDecl) {
+        error(
+          `${WITH_DEFAULTS}() is unnecessary when using destructure with ${DEFINE_PROPS}().\n` +
+            `Prefer using destructure default values, e.g. const { foo = 1 } = defineProps(...).`,
+          node.callee
+        )
+      }
+      propsRuntimeDefaults = node.arguments[1] as ObjectExpression
+      if (
+        !propsRuntimeDefaults ||
+        propsRuntimeDefaults.type !== 'ObjectExpression'
+      ) {
+        error(
+          `The 2nd argument of ${WITH_DEFAULTS} must be an object literal.`,
+          propsRuntimeDefaults || node
+        )
+      }
+    } else {
+      error(
+        `${WITH_DEFAULTS}' first argument must be a ${DEFINE_PROPS} call.`,
+        node.arguments[0] || node
+      )
+    }
+    return true
+  }
+
+  function processDefineEmits(node: Node, declId?: LVal): boolean {
+    if (!isCallOf(node, DEFINE_EMITS)) {
+      return false
+    }
+    if (hasDefineEmitCall) {
+      error(`duplicate ${DEFINE_EMITS}() call`, node)
+    }
+    hasDefineEmitCall = true
+    emitsRuntimeDecl = node.arguments[0]
+    if (node.typeParameters) {
+      if (emitsRuntimeDecl) {
+        error(
+          `${DEFINE_EMITS}() cannot accept both type and non-type arguments ` +
+            `at the same time. Use one or the other.`,
+          node
+        )
+      }
+
+      emitsTypeDeclRaw = node.typeParameters.params[0]
+      emitsTypeDecl = resolveQualifiedType(
+        emitsTypeDeclRaw,
+        node => node.type === 'TSFunctionType' || node.type === 'TSTypeLiteral'
+      ) as TSFunctionType | TSTypeLiteral | TSInterfaceBody | undefined
+
+      if (!emitsTypeDecl) {
+        error(
+          `type argument passed to ${DEFINE_EMITS}() must be a function type, ` +
+            `a literal type with call signatures, or a reference to the above types.`,
+          emitsTypeDeclRaw
+        )
+      }
+    }
+
+    if (declId) {
+      emitIdentifier = scriptSetup!.content.slice(declId.start!, declId.end!)
+    }
+
+    return true
+  }
+
+  function resolveQualifiedType(
+    node: Node,
+    qualifier: (node: Node) => boolean
+  ) {
+    if (qualifier(node)) {
+      return node
+    }
+    if (
+      node.type === 'TSTypeReference' &&
+      node.typeName.type === 'Identifier'
+    ) {
+      const refName = node.typeName.name
+      const isQualifiedType = (node: Node): Node | undefined => {
+        if (
+          node.type === 'TSInterfaceDeclaration' &&
+          node.id.name === refName
+        ) {
+          return node.body
+        } else if (
+          node.type === 'TSTypeAliasDeclaration' &&
+          node.id.name === refName &&
+          qualifier(node.typeAnnotation)
+        ) {
+          return node.typeAnnotation
+        } else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+          return isQualifiedType(node.declaration)
+        }
+      }
+      const body = scriptAst
+        ? [...scriptSetupAst.body, ...scriptAst.body]
+        : scriptSetupAst.body
+      for (const node of body) {
+        const qualified = isQualifiedType(node)
+        if (qualified) {
+          return qualified
+        }
+      }
+    }
+  }
+
+  function processDefineExpose(node: Node): boolean {
+    if (isCallOf(node, DEFINE_EXPOSE)) {
+      if (hasDefineExposeCall) {
+        error(`duplicate ${DEFINE_EXPOSE}() call`, node)
+      }
+      hasDefineExposeCall = true
+      return true
+    }
+    return false
+  }
+
+  function checkInvalidScopeReference(node: Node | undefined, method: string) {
+    if (!node) return
+    walkIdentifiers(node, id => {
+      if (setupBindings[id.name]) {
+        error(
+          `\`${method}()\` in <script setup> cannot reference locally ` +
+            `declared variables because it will be hoisted outside of the ` +
+            `setup() function. If your component options require initialization ` +
+            `in the module scope, use a separate normal <script> to export ` +
+            `the options instead.`,
+          id
+        )
+      }
+    })
+  }
+
+  /**
+   * await foo()
+   * -->
+   * ;(
+   *   ([__temp,__restore] = withAsyncContext(() => foo())),
+   *   await __temp,
+   *   __restore()
+   * )
+   *
+   * const a = await foo()
+   * -->
+   * const a = (
+   *   ([__temp, __restore] = withAsyncContext(() => foo())),
+   *   __temp = await __temp,
+   *   __restore(),
+   *   __temp
+   * )
+   */
+  function processAwait(
+    node: AwaitExpression,
+    needSemi: boolean,
+    isStatement: boolean
+  ) {
+    const argumentStart =
+      node.argument.extra && node.argument.extra.parenthesized
+        ? (node.argument.extra.parenStart as number)
+        : node.argument.start!
+
+    const argumentStr = source.slice(
+      argumentStart + startOffset,
+      node.argument.end! + startOffset
+    )
+
+    const containsNestedAwait = /\bawait\b/.test(argumentStr)
+
+    s.overwrite(
+      node.start! + startOffset,
+      argumentStart + startOffset,
+      `${needSemi ? `;` : ``}(\n  ([__temp,__restore] = ${helper(
+        `withAsyncContext`
+      )}(${containsNestedAwait ? `async ` : ``}() => `
+    )
+    s.appendLeft(
+      node.end! + startOffset,
+      `)),\n  ${isStatement ? `` : `__temp = `}await __temp,\n  __restore()${
+        isStatement ? `` : `,\n  __temp`
+      }\n)`
+    )
+  }
+
+  /**
+   * check defaults. If the default object is an object literal with only
+   * static properties, we can directly generate more optimized default
+   * declarations. Otherwise we will have to fallback to runtime merging.
+   */
+  function hasStaticWithDefaults() {
+    return (
+      propsRuntimeDefaults &&
+      propsRuntimeDefaults.type === 'ObjectExpression' &&
+      propsRuntimeDefaults.properties.every(
+        node =>
+          (node.type === 'ObjectProperty' && !node.computed) ||
+          node.type === 'ObjectMethod'
+      )
+    )
+  }
+
+  function genRuntimeProps(props: Record<string, PropTypeData>) {
+    const keys = Object.keys(props)
+    if (!keys.length) {
+      return ``
+    }
+    const hasStaticDefaults = hasStaticWithDefaults()
+    const scriptSetupSource = scriptSetup!.content
+    let propsDecls = `{
+    ${keys
+      .map(key => {
+        let defaultString: string | undefined
+        const destructured = genDestructuredDefaultValue(key)
+        if (destructured) {
+          defaultString = `default: ${destructured}`
+        } else if (hasStaticDefaults) {
+          const prop = propsRuntimeDefaults!.properties.find(
+            (node: any) => node.key.name === key
+          ) as ObjectProperty | ObjectMethod
+          if (prop) {
+            if (prop.type === 'ObjectProperty') {
+              // prop has corresponding static default value
+              defaultString = `default: ${scriptSetupSource.slice(
+                prop.value.start!,
+                prop.value.end!
+              )}`
+            } else {
+              defaultString = `default() ${scriptSetupSource.slice(
+                prop.body.start!,
+                prop.body.end!
+              )}`
+            }
+          }
+        }
+
+        const { type, required } = props[key]
+        if (!isProd) {
+          return `${key}: { type: ${toRuntimeTypeString(
+            type
+          )}, required: ${required}${
+            defaultString ? `, ${defaultString}` : ``
+          } }`
+        } else if (
+          type.some(
+            el => el === 'Boolean' || (defaultString && el === 'Function')
+          )
+        ) {
+          // #4783 production: if boolean or defaultString and function exists, should keep the type.
+          return `${key}: { type: ${toRuntimeTypeString(type)}${
+            defaultString ? `, ${defaultString}` : ``
+          } }`
+        } else {
+          // production: checks are useless
+          return `${key}: ${defaultString ? `{ ${defaultString} }` : 'null'}`
+        }
+      })
+      .join(',\n    ')}\n  }`
+
+    if (propsRuntimeDefaults && !hasStaticDefaults) {
+      propsDecls = `${helper('mergeDefaults')}(${propsDecls}, ${source.slice(
+        propsRuntimeDefaults.start! + startOffset,
+        propsRuntimeDefaults.end! + startOffset
+      )})`
+    }
+
+    return `\n  props: ${propsDecls},`
+  }
+
+  function genDestructuredDefaultValue(key: string): string | undefined {
+    const destructured = propsDestructuredBindings[key]
+    if (destructured && destructured.default) {
+      const value = scriptSetup!.content.slice(
+        destructured.default.start!,
+        destructured.default.end!
+      )
+      const isLiteral = destructured.default.type.endsWith('Literal')
+      return isLiteral ? value : `() => (${value})`
+    }
+  }
+
+  function genSetupPropsType(node: TSTypeLiteral | TSInterfaceBody) {
+    const scriptSetupSource = scriptSetup!.content
+    if (hasStaticWithDefaults()) {
+      // if withDefaults() is used, we need to remove the optional flags
+      // on props that have default values
+      let res = `{ `
+      const members = node.type === 'TSTypeLiteral' ? node.members : node.body
+      for (const m of members) {
+        if (
+          (m.type === 'TSPropertySignature' ||
+            m.type === 'TSMethodSignature') &&
+          m.typeAnnotation &&
+          m.key.type === 'Identifier'
+        ) {
+          if (
+            propsRuntimeDefaults!.properties.some(
+              (p: any) => p.key.name === (m.key as Identifier).name
+            )
+          ) {
+            res +=
+              m.key.name +
+              (m.type === 'TSMethodSignature' ? '()' : '') +
+              scriptSetupSource.slice(
+                m.typeAnnotation.start!,
+                m.typeAnnotation.end!
+              ) +
+              ', '
+          } else {
+            res +=
+              scriptSetupSource.slice(m.start!, m.typeAnnotation.end!) + `, `
+          }
+        }
+      }
+      return (res.length ? res.slice(0, -2) : res) + ` }`
+    } else {
+      return scriptSetupSource.slice(node.start!, node.end!)
+    }
+  }
+
+  // 1. process normal <script> first if it exists
+  let scriptAst: Program | undefined
+  if (script) {
+    scriptAst = parse(
+      script.content,
+      {
+        plugins,
+        sourceType: 'module'
+      },
+      scriptStartOffset!
+    )
+
+    for (const node of scriptAst.body) {
+      if (node.type === 'ImportDeclaration') {
+        // record imports for dedupe
+        for (const specifier of node.specifiers) {
+          const imported =
+            specifier.type === 'ImportSpecifier' &&
+            specifier.imported.type === 'Identifier' &&
+            specifier.imported.name
+          registerUserImport(
+            node.source.value,
+            specifier.local.name,
+            imported,
+            node.importKind === 'type' ||
+              (specifier.type === 'ImportSpecifier' &&
+                specifier.importKind === 'type'),
+            false,
+            true
+          )
+        }
+      } else if (node.type === 'ExportDefaultDeclaration') {
+        // export default
+        defaultExport = node
+
+        // check if user has manually specified `name` or 'render` option in
+        // export default
+        // if has name, skip name inference
+        // if has render and no template, generate return object instead of
+        // empty render function (#4980)
+        let optionProperties
+        if (defaultExport.declaration.type === 'ObjectExpression') {
+          optionProperties = defaultExport.declaration.properties
+        } else if (
+          defaultExport.declaration.type === 'CallExpression' &&
+          defaultExport.declaration.arguments[0].type === 'ObjectExpression'
+        ) {
+          optionProperties = defaultExport.declaration.arguments[0].properties
+        }
+        if (optionProperties) {
+          for (const s of optionProperties) {
+            if (
+              s.type === 'ObjectProperty' &&
+              s.key.type === 'Identifier' &&
+              s.key.name === 'name'
+            ) {
+              hasDefaultExportName = true
+            }
+          }
+        }
+
+        // export default { ... } --> const __default__ = { ... }
+        const start = node.start! + scriptStartOffset!
+        const end = node.declaration.start! + scriptStartOffset!
+        s.overwrite(start, end, `const ${DEFAULT_VAR} = `)
+      } else if (node.type === 'ExportNamedDeclaration') {
+        const defaultSpecifier = node.specifiers.find(
+          s => s.exported.type === 'Identifier' && s.exported.name === 'default'
+        ) as ExportSpecifier
+        if (defaultSpecifier) {
+          defaultExport = node
+          // 1. remove specifier
+          if (node.specifiers.length > 1) {
+            s.remove(
+              defaultSpecifier.start! + scriptStartOffset!,
+              defaultSpecifier.end! + scriptStartOffset!
+            )
+          } else {
+            s.remove(
+              node.start! + scriptStartOffset!,
+              node.end! + scriptStartOffset!
+            )
+          }
+          if (node.source) {
+            // export { x as default } from './x'
+            // rewrite to `import { x as __default__ } from './x'` and
+            // add to top
+            s.prepend(
+              `import { ${defaultSpecifier.local.name} as ${DEFAULT_VAR} } from '${node.source.value}'\n`
+            )
+          } else {
+            // export { x as default }
+            // rewrite to `const __default__ = x` and move to end
+            s.appendLeft(
+              scriptEndOffset!,
+              `\nconst ${DEFAULT_VAR} = ${defaultSpecifier.local.name}\n`
+            )
+          }
+        }
+        if (node.declaration) {
+          walkDeclaration(node.declaration, scriptBindings, userImportAlias)
+        }
+      } else if (
+        (node.type === 'VariableDeclaration' ||
+          node.type === 'FunctionDeclaration' ||
+          node.type === 'ClassDeclaration' ||
+          node.type === 'TSEnumDeclaration') &&
+        !node.declare
+      ) {
+        walkDeclaration(node, scriptBindings, userImportAlias)
+      }
+    }
+
+    // apply reactivity transform
+    // if (enableReactivityTransform && shouldTransform(script.content)) {
+    //   const { rootRefs, importedHelpers } = transformAST(
+    //     scriptAst,
+    //     s,
+    //     scriptStartOffset!
+    //   )
+    //   refBindings = rootRefs
+    //   for (const h of importedHelpers) {
+    //     helperImports.add(h)
+    //   }
+    // }
+
+    // <script> after <script setup>
+    // we need to move the block up so that `const __default__` is
+    // declared before being used in the actual component definition
+    if (scriptStartOffset! > startOffset) {
+      // if content doesn't end with newline, add one
+      if (!/\n$/.test(script.content.trim())) {
+        s.appendLeft(scriptEndOffset!, `\n`)
+      }
+      s.move(scriptStartOffset!, scriptEndOffset!, 0)
+    }
+  }
+
+  // 2. parse <script setup> and  walk over top level statements
+  const scriptSetupAst = parse(
+    scriptSetup.content,
+    {
+      plugins: [
+        ...plugins,
+        // allow top level await but only inside <script setup>
+        'topLevelAwait'
+      ],
+      sourceType: 'module'
+    },
+    startOffset
+  )
+
+  for (const node of scriptSetupAst.body) {
+    const start = node.start! + startOffset
+    let end = node.end! + startOffset
+    // locate comment
+    if (node.trailingComments && node.trailingComments.length > 0) {
+      const lastCommentNode =
+        node.trailingComments[node.trailingComments.length - 1]
+      end = lastCommentNode.end + startOffset
+    }
+    // locate the end of whitespace between this statement and the next
+    while (end <= source.length) {
+      if (!/\s/.test(source.charAt(end))) {
+        break
+      }
+      end++
+    }
+
+    // (Dropped) `ref: x` bindings
+    if (
+      node.type === 'LabeledStatement' &&
+      node.label.name === 'ref' &&
+      node.body.type === 'ExpressionStatement'
+    ) {
+      error(
+        `ref sugar using the label syntax was an experimental proposal and ` +
+          `has been dropped based on community feedback. Please check out ` +
+          `the new proposal at https://github.com/vuejs/rfcs/discussions/369`,
+        node
+      )
+    }
+
+    if (node.type === 'ImportDeclaration') {
+      // import declarations are moved to top
+      s.move(start, end, 0)
+
+      // dedupe imports
+      let removed = 0
+      const removeSpecifier = (i: number) => {
+        const removeLeft = i > removed
+        removed++
+        const current = node.specifiers[i]
+        const next = node.specifiers[i + 1]
+        s.remove(
+          removeLeft
+            ? node.specifiers[i - 1].end! + startOffset
+            : current.start! + startOffset,
+          next && !removeLeft
+            ? next.start! + startOffset
+            : current.end! + startOffset
+        )
+      }
+
+      for (let i = 0; i < node.specifiers.length; i++) {
+        const specifier = node.specifiers[i]
+        const local = specifier.local.name
+        let imported =
+          specifier.type === 'ImportSpecifier' &&
+          specifier.imported.type === 'Identifier' &&
+          specifier.imported.name
+        if (specifier.type === 'ImportNamespaceSpecifier') {
+          imported = '*'
+        }
+        const source = node.source.value
+        const existing = userImports[local]
+        if (
+          source === 'vue' &&
+          (imported === DEFINE_PROPS ||
+            imported === DEFINE_EMITS ||
+            imported === DEFINE_EXPOSE)
+        ) {
+          warnOnce(
+            `\`${imported}\` is a compiler macro and no longer needs to be imported.`
+          )
+          removeSpecifier(i)
+        } else if (existing) {
+          if (existing.source === source && existing.imported === imported) {
+            // already imported in <script setup>, dedupe
+            removeSpecifier(i)
+          } else {
+            error(`different imports aliased to same local name.`, specifier)
+          }
+        } else {
+          registerUserImport(
+            source,
+            local,
+            imported,
+            node.importKind === 'type' ||
+              (specifier.type === 'ImportSpecifier' &&
+                specifier.importKind === 'type'),
+            true,
+            true
+          )
+        }
+      }
+      if (node.specifiers.length && removed === node.specifiers.length) {
+        s.remove(node.start! + startOffset, node.end! + startOffset)
+      }
+    }
+
+    if (node.type === 'ExpressionStatement') {
+      // process `defineProps` and `defineEmit(s)` calls
+      if (
+        processDefineProps(node.expression) ||
+        processDefineEmits(node.expression) ||
+        processWithDefaults(node.expression)
+      ) {
+        s.remove(node.start! + startOffset, node.end! + startOffset)
+      } else if (processDefineExpose(node.expression)) {
+        // defineExpose({}) -> expose({})
+        const callee = (node.expression as CallExpression).callee
+        s.overwrite(
+          callee.start! + startOffset,
+          callee.end! + startOffset,
+          'expose'
+        )
+      }
+    }
+
+    if (node.type === 'VariableDeclaration' && !node.declare) {
+      const total = node.declarations.length
+      let left = total
+      for (let i = 0; i < total; i++) {
+        const decl = node.declarations[i]
+        if (decl.init) {
+          // defineProps / defineEmits
+          const isDefineProps =
+            processDefineProps(decl.init, decl.id) ||
+            processWithDefaults(decl.init, decl.id)
+          const isDefineEmits = processDefineEmits(decl.init, decl.id)
+          if (isDefineProps || isDefineEmits) {
+            if (left === 1) {
+              s.remove(node.start! + startOffset, node.end! + startOffset)
+            } else {
+              let start = decl.start! + startOffset
+              let end = decl.end! + startOffset
+              if (i < total - 1) {
+                // not the last one, locate the start of the next
+                end = node.declarations[i + 1].start! + startOffset
+              } else {
+                // last one, locate the end of the prev
+                start = node.declarations[i - 1].end! + startOffset
+              }
+              s.remove(start, end)
+              left--
+            }
+          }
+        }
+      }
+    }
+
+    // walk declarations to record declared bindings
+    if (
+      (node.type === 'VariableDeclaration' ||
+        node.type === 'FunctionDeclaration' ||
+        node.type === 'ClassDeclaration') &&
+      !node.declare
+    ) {
+      walkDeclaration(node, setupBindings, userImportAlias)
+    }
+
+    // walk statements & named exports / variable declarations for top level
+    // await
+    if (
+      (node.type === 'VariableDeclaration' && !node.declare) ||
+      node.type.endsWith('Statement')
+    ) {
+      const scope: Statement[][] = [scriptSetupAst.body]
+      ;(walk as any)(node, {
+        enter(child: Node, parent: Node) {
+          if (isFunctionType(child)) {
+            this.skip()
+          }
+          if (child.type === 'BlockStatement') {
+            scope.push(child.body)
+          }
+          if (child.type === 'AwaitExpression') {
+            hasAwait = true
+            // if the await expression is an expression statement and
+            // - is in the root scope
+            // - or is not the first statement in a nested block scope
+            // then it needs a semicolon before the generated code.
+            const currentScope = scope[scope.length - 1]
+            const needsSemi = currentScope.some((n, i) => {
+              return (
+                (scope.length === 1 || i > 0) &&
+                n.type === 'ExpressionStatement' &&
+                n.start === child.start
+              )
+            })
+            processAwait(
+              child,
+              needsSemi,
+              parent.type === 'ExpressionStatement'
+            )
+          }
+        },
+        exit(node: Node) {
+          if (node.type === 'BlockStatement') scope.pop()
+        }
+      })
+    }
+
+    if (
+      (node.type === 'ExportNamedDeclaration' && node.exportKind !== 'type') ||
+      node.type === 'ExportAllDeclaration' ||
+      node.type === 'ExportDefaultDeclaration'
+    ) {
+      error(
+        `<script setup> cannot contain ES module exports. ` +
+          `If you are using a previous version of <script setup>, please ` +
+          `consult the updated RFC at https://github.com/vuejs/rfcs/pull/227.`,
+        node
+      )
+    }
+
+    if (isTS) {
+      // runtime enum
+      if (node.type === 'TSEnumDeclaration') {
+        registerBinding(setupBindings, node.id, BindingTypes.SETUP_CONST)
+      }
+
+      // move all Type declarations to outer scope
+      if (
+        node.type.startsWith('TS') ||
+        (node.type === 'ExportNamedDeclaration' &&
+          node.exportKind === 'type') ||
+        (node.type === 'VariableDeclaration' && node.declare)
+      ) {
+        recordType(node, declaredTypes)
+        s.move(start, end, 0)
+      }
+    }
+  }
+
+  // 3. Apply reactivity transform
+  // if (
+  //   (enableReactivityTransform &&
+  //     // normal <script> had ref bindings that maybe used in <script setup>
+  //     (refBindings || shouldTransform(scriptSetup.content))) ||
+  //   propsDestructureDecl
+  // ) {
+  //   const { rootRefs, importedHelpers } = transformAST(
+  //     scriptSetupAst,
+  //     s,
+  //     startOffset,
+  //     refBindings,
+  //     propsDestructuredBindings
+  //   )
+  //   refBindings = refBindings ? [...refBindings, ...rootRefs] : rootRefs
+  //   for (const h of importedHelpers) {
+  //     helperImports.add(h)
+  //   }
+  // }
+
+  // 4. extract runtime props/emits code from setup context type
+  if (propsTypeDecl) {
+    extractRuntimeProps(propsTypeDecl, typeDeclaredProps, declaredTypes, isProd)
+  }
+  if (emitsTypeDecl) {
+    extractRuntimeEmits(emitsTypeDecl, typeDeclaredEmits)
+  }
+
+  // 5. check useOptions args to make sure it doesn't reference setup scope
+  // variables
+  checkInvalidScopeReference(propsRuntimeDecl, DEFINE_PROPS)
+  checkInvalidScopeReference(propsRuntimeDefaults, DEFINE_PROPS)
+  checkInvalidScopeReference(propsDestructureDecl, DEFINE_PROPS)
+  checkInvalidScopeReference(emitsRuntimeDecl, DEFINE_EMITS)
+
+  // 6. remove non-script content
+  if (script) {
+    if (startOffset < scriptStartOffset!) {
+      // <script setup> before <script>
+      s.remove(0, startOffset)
+      s.remove(endOffset, scriptStartOffset!)
+      s.remove(scriptEndOffset!, source.length)
+    } else {
+      // <script> before <script setup>
+      s.remove(0, scriptStartOffset!)
+      s.remove(scriptEndOffset!, startOffset)
+      s.remove(endOffset, source.length)
+    }
+  } else {
+    // only <script setup>
+    s.remove(0, startOffset)
+    s.remove(endOffset, source.length)
+  }
+
+  // 7. analyze binding metadata
+  if (scriptAst) {
+    Object.assign(bindingMetadata, analyzeScriptBindings(scriptAst.body))
+  }
+  if (propsRuntimeDecl) {
+    for (const key of getObjectOrArrayExpressionKeys(propsRuntimeDecl)) {
+      bindingMetadata[key] = BindingTypes.PROPS
+    }
+  }
+  for (const key in typeDeclaredProps) {
+    bindingMetadata[key] = BindingTypes.PROPS
+  }
+  // props aliases
+  // if (propsDestructureDecl) {
+  //   if (propsDestructureRestId) {
+  //     bindingMetadata[propsDestructureRestId] =
+  //       BindingTypes.SETUP_REACTIVE_CONST
+  //   }
+  //   for (const key in propsDestructuredBindings) {
+  //     const { local } = propsDestructuredBindings[key]
+  //     if (local !== key) {
+  //       bindingMetadata[local] = BindingTypes.PROPS_ALIASED
+  //       ;(bindingMetadata.__propsAliases ||
+  //         (bindingMetadata.__propsAliases = {}))[local] = key
+  //     }
+  //   }
+  // }
+  for (const [key, { isType, imported, source }] of Object.entries(
+    userImports
+  )) {
+    if (isType) continue
+    bindingMetadata[key] =
+      imported === '*' ||
+      (imported === 'default' && source.endsWith('.vue')) ||
+      source === 'vue'
+        ? BindingTypes.SETUP_CONST
+        : BindingTypes.SETUP_MAYBE_REF
+  }
+  for (const key in scriptBindings) {
+    bindingMetadata[key] = scriptBindings[key]
+  }
+  for (const key in setupBindings) {
+    bindingMetadata[key] = setupBindings[key]
+  }
+  // known ref bindings
+  if (refBindings) {
+    for (const key of refBindings) {
+      bindingMetadata[key] = BindingTypes.SETUP_REF
+    }
+  }
+
+  // 8. inject `useCssVars` calls
+  // Not backported in Vue 2
+
+  // 9. finalize setup() argument signature
+  let args = `__props`
+  if (propsTypeDecl) {
+    // mark as any and only cast on assignment
+    // since the user defined complex types may be incompatible with the
+    // inferred type from generated runtime declarations
+    args += `: any`
+  }
+  // inject user assignment of props
+  // we use a default __props so that template expressions referencing props
+  // can use it directly
+  if (propsIdentifier) {
+    s.prependLeft(
+      startOffset,
+      `\nconst ${propsIdentifier} = __props${
+        propsTypeDecl ? ` as ${genSetupPropsType(propsTypeDecl)}` : ``
+      }\n`
+    )
+  }
+  if (propsDestructureRestId) {
+    s.prependLeft(
+      startOffset,
+      `\nconst ${propsDestructureRestId} = ${helper(
+        `createPropsRestProxy`
+      )}(__props, ${JSON.stringify(Object.keys(propsDestructuredBindings))})\n`
+    )
+  }
+  // inject temp variables for async context preservation
+  if (hasAwait) {
+    const any = isTS ? `: any` : ``
+    s.prependLeft(startOffset, `\nlet __temp${any}, __restore${any}\n`)
+  }
+
+  const destructureElements = [`expose`]
+  if (emitIdentifier) {
+    destructureElements.push(
+      emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`
+    )
+  }
+  if (destructureElements.length) {
+    args += `, { ${destructureElements.join(', ')} }`
+    if (emitsTypeDecl) {
+      args += `: { emit: (${scriptSetup.content.slice(
+        emitsTypeDecl.start!,
+        emitsTypeDecl.end!
+      )}), expose: any, slots: any, attrs: any }`
+    }
+  }
+
+  // 10. generate return statement
+  const allBindings: Record<string, any> = {
+    ...scriptBindings,
+    ...setupBindings
+  }
+  for (const key in userImports) {
+    if (!userImports[key].isType && userImports[key].isUsedInTemplate) {
+      allBindings[key] = true
+    }
+  }
+  const returned = `{ ${Object.keys(allBindings).join(', ')} }`
+
+  s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`)
+
+  // 11. finalize default export
+  let runtimeOptions = ``
+  if (!hasDefaultExportName && filename) {
+    const match = filename.match(/([^/\\]+)\.\w+$/)
+    if (match) {
+      runtimeOptions += `\n  __name: '${match[1]}',`
+    }
+  }
+  if (hasInlinedSsrRenderFn) {
+    runtimeOptions += `\n  __ssrInlineRender: true,`
+  }
+  if (propsRuntimeDecl) {
+    let declCode = scriptSetup.content
+      .slice(propsRuntimeDecl.start!, propsRuntimeDecl.end!)
+      .trim()
+    if (propsDestructureDecl) {
+      const defaults: string[] = []
+      for (const key in propsDestructuredBindings) {
+        const d = genDestructuredDefaultValue(key)
+        if (d) defaults.push(`${key}: ${d}`)
+      }
+      if (defaults.length) {
+        declCode = `${helper(
+          `mergeDefaults`
+        )}(${declCode}, {\n  ${defaults.join(',\n  ')}\n})`
+      }
+    }
+    runtimeOptions += `\n  props: ${declCode},`
+  } else if (propsTypeDecl) {
+    runtimeOptions += genRuntimeProps(typeDeclaredProps)
+  }
+  if (emitsRuntimeDecl) {
+    runtimeOptions += `\n  emits: ${scriptSetup.content
+      .slice(emitsRuntimeDecl.start!, emitsRuntimeDecl.end!)
+      .trim()},`
+  } else if (emitsTypeDecl) {
+    runtimeOptions += genRuntimeEmits(typeDeclaredEmits)
+  }
+
+  // <script setup> components are closed by default. If the user did not
+  // explicitly call `defineExpose`, call expose() with no args.
+  const exposeCall = hasDefineExposeCall ? `` : `  expose();\n`
+  // wrap setup code with function.
+  if (isTS) {
+    // for TS, make sure the exported type is still valid type with
+    // correct props information
+    // we have to use object spread for types to be merged properly
+    // user's TS setting should compile it down to proper targets
+    // export default defineComponent({ ...__default__, ... })
+    const def = defaultExport ? `\n  ...${DEFAULT_VAR},` : ``
+    s.prependLeft(
+      startOffset,
+      `\nexport default /*#__PURE__*/${helper(
+        `defineComponent`
+      )}({${def}${runtimeOptions}\n  ${
+        hasAwait ? `async ` : ``
+      }setup(${args}) {\n${exposeCall}`
+    )
+    s.appendRight(endOffset, `})`)
+  } else {
+    if (defaultExport) {
+      // without TS, can't rely on rest spread, so we use Object.assign
+      // export default Object.assign(__default__, { ... })
+      s.prependLeft(
+        startOffset,
+        `\nexport default /*#__PURE__*/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}\n  ` +
+          `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`
+      )
+      s.appendRight(endOffset, `})`)
+    } else {
+      s.prependLeft(
+        startOffset,
+        `\nexport default {${runtimeOptions}\n  ` +
+          `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`
+      )
+      s.appendRight(endOffset, `}`)
+    }
+  }
+
+  // 12. finalize Vue helper imports
+  if (helperImports.size > 0) {
+    s.prepend(
+      `import { ${[...helperImports]
+        .map(h => `${h} as _${h}`)
+        .join(', ')} } from 'vue'\n`
+    )
+  }
+
+  s.trim()
+
+  return {
+    ...scriptSetup,
+    bindings: bindingMetadata,
+    imports: userImports,
+    content: s.toString(),
+    map: genSourceMap
+      ? (s.generateMap({
+          source: filename,
+          hires: true,
+          includeContent: true
+        }) as unknown as RawSourceMap)
+      : undefined,
+    scriptAst: scriptAst?.body,
+    scriptSetupAst: scriptSetupAst?.body
+  }
+}
+
+function registerBinding(
+  bindings: Record<string, BindingTypes>,
+  node: Identifier,
+  type: BindingTypes
+) {
+  bindings[node.name] = type
+}
+
+function walkDeclaration(
+  node: Declaration,
+  bindings: Record<string, BindingTypes>,
+  userImportAlias: Record<string, string>
+) {
+  if (node.type === 'VariableDeclaration') {
+    const isConst = node.kind === 'const'
+    // export const foo = ...
+    for (const { id, init } of node.declarations) {
+      const isDefineCall = !!(
+        isConst &&
+        isCallOf(
+          init,
+          c => c === DEFINE_PROPS || c === DEFINE_EMITS || c === WITH_DEFAULTS
+        )
+      )
+      if (id.type === 'Identifier') {
+        let bindingType
+        const userReactiveBinding = userImportAlias['reactive'] || 'reactive'
+        if (isCallOf(init, userReactiveBinding)) {
+          // treat reactive() calls as let since it's meant to be mutable
+          bindingType = isConst
+            ? BindingTypes.SETUP_REACTIVE_CONST
+            : BindingTypes.SETUP_LET
+        } else if (
+          // if a declaration is a const literal, we can mark it so that
+          // the generated render fn code doesn't need to unref() it
+          isDefineCall ||
+          (isConst && canNeverBeRef(init!, userReactiveBinding))
+        ) {
+          bindingType = isCallOf(init, DEFINE_PROPS)
+            ? BindingTypes.SETUP_REACTIVE_CONST
+            : BindingTypes.SETUP_CONST
+        } else if (isConst) {
+          if (isCallOf(init, userImportAlias['ref'] || 'ref')) {
+            bindingType = BindingTypes.SETUP_REF
+          } else {
+            bindingType = BindingTypes.SETUP_MAYBE_REF
+          }
+        } else {
+          bindingType = BindingTypes.SETUP_LET
+        }
+        registerBinding(bindings, id, bindingType)
+      } else {
+        if (isCallOf(init, DEFINE_PROPS)) {
+          // skip walking props destructure
+          return
+        }
+        if (id.type === 'ObjectPattern') {
+          walkObjectPattern(id, bindings, isConst, isDefineCall)
+        } else if (id.type === 'ArrayPattern') {
+          walkArrayPattern(id, bindings, isConst, isDefineCall)
+        }
+      }
+    }
+  } else if (
+    node.type === 'TSEnumDeclaration' ||
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'ClassDeclaration'
+  ) {
+    // export function foo() {} / export class Foo {}
+    // export declarations must be named.
+    bindings[node.id!.name] = BindingTypes.SETUP_CONST
+  }
+}
+
+function walkObjectPattern(
+  node: ObjectPattern,
+  bindings: Record<string, BindingTypes>,
+  isConst: boolean,
+  isDefineCall = false
+) {
+  for (const p of node.properties) {
+    if (p.type === 'ObjectProperty') {
+      if (p.key.type === 'Identifier' && p.key === p.value) {
+        // shorthand: const { x } = ...
+        const type = isDefineCall
+          ? BindingTypes.SETUP_CONST
+          : isConst
+          ? BindingTypes.SETUP_MAYBE_REF
+          : BindingTypes.SETUP_LET
+        registerBinding(bindings, p.key, type)
+      } else {
+        walkPattern(p.value, bindings, isConst, isDefineCall)
+      }
+    } else {
+      // ...rest
+      // argument can only be identifier when destructuring
+      const type = isConst ? BindingTypes.SETUP_CONST : BindingTypes.SETUP_LET
+      registerBinding(bindings, p.argument as Identifier, type)
+    }
+  }
+}
+
+function walkArrayPattern(
+  node: ArrayPattern,
+  bindings: Record<string, BindingTypes>,
+  isConst: boolean,
+  isDefineCall = false
+) {
+  for (const e of node.elements) {
+    e && walkPattern(e, bindings, isConst, isDefineCall)
+  }
+}
+
+function walkPattern(
+  node: Node,
+  bindings: Record<string, BindingTypes>,
+  isConst: boolean,
+  isDefineCall = false
+) {
+  if (node.type === 'Identifier') {
+    const type = isDefineCall
+      ? BindingTypes.SETUP_CONST
+      : isConst
+      ? BindingTypes.SETUP_MAYBE_REF
+      : BindingTypes.SETUP_LET
+    registerBinding(bindings, node, type)
+  } else if (node.type === 'RestElement') {
+    // argument can only be identifier when destructuring
+    const type = isConst ? BindingTypes.SETUP_CONST : BindingTypes.SETUP_LET
+    registerBinding(bindings, node.argument as Identifier, type)
+  } else if (node.type === 'ObjectPattern') {
+    walkObjectPattern(node, bindings, isConst)
+  } else if (node.type === 'ArrayPattern') {
+    walkArrayPattern(node, bindings, isConst)
+  } else if (node.type === 'AssignmentPattern') {
+    if (node.left.type === 'Identifier') {
+      const type = isDefineCall
+        ? BindingTypes.SETUP_CONST
+        : isConst
+        ? BindingTypes.SETUP_MAYBE_REF
+        : BindingTypes.SETUP_LET
+      registerBinding(bindings, node.left, type)
+    } else {
+      walkPattern(node.left, bindings, isConst)
+    }
+  }
+}
+
+interface PropTypeData {
+  key: string
+  type: string[]
+  required: boolean
+}
+
+function recordType(node: Node, declaredTypes: Record<string, string[]>) {
+  if (node.type === 'TSInterfaceDeclaration') {
+    declaredTypes[node.id.name] = [`Object`]
+  } else if (node.type === 'TSTypeAliasDeclaration') {
+    declaredTypes[node.id.name] = inferRuntimeType(
+      node.typeAnnotation,
+      declaredTypes
+    )
+  } else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+    recordType(node.declaration, declaredTypes)
+  }
+}
+
+function extractRuntimeProps(
+  node: TSTypeLiteral | TSInterfaceBody,
+  props: Record<string, PropTypeData>,
+  declaredTypes: Record<string, string[]>,
+  isProd: boolean
+) {
+  const members = node.type === 'TSTypeLiteral' ? node.members : node.body
+  for (const m of members) {
+    if (
+      (m.type === 'TSPropertySignature' || m.type === 'TSMethodSignature') &&
+      m.key.type === 'Identifier'
+    ) {
+      let type
+      if (m.type === 'TSMethodSignature') {
+        type = ['Function']
+      } else if (m.typeAnnotation) {
+        type = inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes)
+      }
+      props[m.key.name] = {
+        key: m.key.name,
+        required: !m.optional,
+        type: type || [`null`]
+      }
+    }
+  }
+}
+
+function inferRuntimeType(
+  node: TSType,
+  declaredTypes: Record<string, string[]>
+): string[] {
+  switch (node.type) {
+    case 'TSStringKeyword':
+      return ['String']
+    case 'TSNumberKeyword':
+      return ['Number']
+    case 'TSBooleanKeyword':
+      return ['Boolean']
+    case 'TSObjectKeyword':
+      return ['Object']
+    case 'TSTypeLiteral':
+      // TODO (nice to have) generate runtime property validation
+      return ['Object']
+    case 'TSFunctionType':
+      return ['Function']
+    case 'TSArrayType':
+    case 'TSTupleType':
+      // TODO (nice to have) generate runtime element type/length checks
+      return ['Array']
+
+    case 'TSLiteralType':
+      switch (node.literal.type) {
+        case 'StringLiteral':
+          return ['String']
+        case 'BooleanLiteral':
+          return ['Boolean']
+        case 'NumericLiteral':
+        case 'BigIntLiteral':
+          return ['Number']
+        default:
+          return [`null`]
+      }
+
+    case 'TSTypeReference':
+      if (node.typeName.type === 'Identifier') {
+        if (declaredTypes[node.typeName.name]) {
+          return declaredTypes[node.typeName.name]
+        }
+        switch (node.typeName.name) {
+          case 'Array':
+          case 'Function':
+          case 'Object':
+          case 'Set':
+          case 'Map':
+          case 'WeakSet':
+          case 'WeakMap':
+          case 'Date':
+          case 'Promise':
+            return [node.typeName.name]
+          case 'Record':
+          case 'Partial':
+          case 'Readonly':
+          case 'Pick':
+          case 'Omit':
+          case 'Exclude':
+          case 'Extract':
+          case 'Required':
+          case 'InstanceType':
+            return ['Object']
+        }
+      }
+      return [`null`]
+
+    case 'TSParenthesizedType':
+      return inferRuntimeType(node.typeAnnotation, declaredTypes)
+    case 'TSUnionType':
+      return [
+        ...new Set(
+          [].concat(
+            ...(node.types.map(t => inferRuntimeType(t, declaredTypes)) as any)
+          )
+        )
+      ]
+    case 'TSIntersectionType':
+      return ['Object']
+
+    case 'TSSymbolKeyword':
+      return ['Symbol']
+
+    default:
+      return [`null`] // no runtime check
+  }
+}
+
+function toRuntimeTypeString(types: string[]) {
+  return types.length > 1 ? `[${types.join(', ')}]` : types[0]
+}
+
+function extractRuntimeEmits(
+  node: TSFunctionType | TSTypeLiteral | TSInterfaceBody,
+  emits: Set<string>
+) {
+  if (node.type === 'TSTypeLiteral' || node.type === 'TSInterfaceBody') {
+    const members = node.type === 'TSTypeLiteral' ? node.members : node.body
+    for (let t of members) {
+      if (t.type === 'TSCallSignatureDeclaration') {
+        extractEventNames(t.parameters[0], emits)
+      }
+    }
+    return
+  } else {
+    extractEventNames(node.parameters[0], emits)
+  }
+}
+
+function extractEventNames(
+  eventName: Identifier | RestElement,
+  emits: Set<string>
+) {
+  if (
+    eventName.type === 'Identifier' &&
+    eventName.typeAnnotation &&
+    eventName.typeAnnotation.type === 'TSTypeAnnotation'
+  ) {
+    const typeNode = eventName.typeAnnotation.typeAnnotation
+    if (typeNode.type === 'TSLiteralType') {
+      if (typeNode.literal.type !== 'UnaryExpression') {
+        emits.add(String(typeNode.literal.value))
+      }
+    } else if (typeNode.type === 'TSUnionType') {
+      for (const t of typeNode.types) {
+        if (
+          t.type === 'TSLiteralType' &&
+          t.literal.type !== 'UnaryExpression'
+        ) {
+          emits.add(String(t.literal.value))
+        }
+      }
+    }
+  }
+}
+
+function genRuntimeEmits(emits: Set<string>) {
+  return emits.size
+    ? `\n  emits: [${Array.from(emits)
+        .map(p => JSON.stringify(p))
+        .join(', ')}],`
+    : ``
+}
+
+function isCallOf(
+  node: Node | null | undefined,
+  test: string | ((id: string) => boolean)
+): node is CallExpression {
+  return !!(
+    node &&
+    node.type === 'CallExpression' &&
+    node.callee.type === 'Identifier' &&
+    (typeof test === 'string'
+      ? node.callee.name === test
+      : test(node.callee.name))
+  )
+}
+
+function canNeverBeRef(node: Node, userReactiveImport: string): boolean {
+  if (isCallOf(node, userReactiveImport)) {
+    return true
+  }
+  switch (node.type) {
+    case 'UnaryExpression':
+    case 'BinaryExpression':
+    case 'ArrayExpression':
+    case 'ObjectExpression':
+    case 'FunctionExpression':
+    case 'ArrowFunctionExpression':
+    case 'UpdateExpression':
+    case 'ClassExpression':
+    case 'TaggedTemplateExpression':
+      return true
+    case 'SequenceExpression':
+      return canNeverBeRef(
+        node.expressions[node.expressions.length - 1],
+        userReactiveImport
+      )
+    default:
+      if (node.type.endsWith('Literal')) {
+        return true
+      }
+      return false
+  }
+}
+
+/**
+ * Analyze bindings in normal `<script>`
+ * Note that `compileScriptSetup` already analyzes bindings as part of its
+ * compilation process so this should only be used on single `<script>` SFCs.
+ */
+function analyzeScriptBindings(ast: Statement[]): BindingMetadata {
+  for (const node of ast) {
+    if (
+      node.type === 'ExportDefaultDeclaration' &&
+      node.declaration.type === 'ObjectExpression'
+    ) {
+      return analyzeBindingsFromOptions(node.declaration)
+    }
+  }
+  return {}
+}
+
+function analyzeBindingsFromOptions(node: ObjectExpression): BindingMetadata {
+  const bindings: BindingMetadata = {}
+  // #3270, #3275
+  // mark non-script-setup so we don't resolve components/directives from these
+  Object.defineProperty(bindings, '__isScriptSetup', {
+    enumerable: false,
+    value: false
+  })
+  for (const property of node.properties) {
+    if (
+      property.type === 'ObjectProperty' &&
+      !property.computed &&
+      property.key.type === 'Identifier'
+    ) {
+      // props
+      if (property.key.name === 'props') {
+        // props: ['foo']
+        // props: { foo: ... }
+        for (const key of getObjectOrArrayExpressionKeys(property.value)) {
+          bindings[key] = BindingTypes.PROPS
+        }
+      }
+
+      // inject
+      else if (property.key.name === 'inject') {
+        // inject: ['foo']
+        // inject: { foo: {} }
+        for (const key of getObjectOrArrayExpressionKeys(property.value)) {
+          bindings[key] = BindingTypes.OPTIONS
+        }
+      }
+
+      // computed & methods
+      else if (
+        property.value.type === 'ObjectExpression' &&
+        (property.key.name === 'computed' || property.key.name === 'methods')
+      ) {
+        // methods: { foo() {} }
+        // computed: { foo() {} }
+        for (const key of getObjectExpressionKeys(property.value)) {
+          bindings[key] = BindingTypes.OPTIONS
+        }
+      }
+    }
+
+    // setup & data
+    else if (
+      property.type === 'ObjectMethod' &&
+      property.key.type === 'Identifier' &&
+      (property.key.name === 'setup' || property.key.name === 'data')
+    ) {
+      for (const bodyItem of property.body.body) {
+        // setup() {
+        //   return {
+        //     foo: null
+        //   }
+        // }
+        if (
+          bodyItem.type === 'ReturnStatement' &&
+          bodyItem.argument &&
+          bodyItem.argument.type === 'ObjectExpression'
+        ) {
+          for (const key of getObjectExpressionKeys(bodyItem.argument)) {
+            bindings[key] =
+              property.key.name === 'setup'
+                ? BindingTypes.SETUP_MAYBE_REF
+                : BindingTypes.DATA
+          }
+        }
+      }
+    }
+  }
+
+  return bindings
+}
+
+function getObjectExpressionKeys(node: ObjectExpression): string[] {
+  const keys: string[] = []
+  for (const prop of node.properties) {
+    if (
+      (prop.type === 'ObjectProperty' || prop.type === 'ObjectMethod') &&
+      !prop.computed
+    ) {
+      if (prop.key.type === 'Identifier') {
+        keys.push(prop.key.name)
+      } else if (prop.key.type === 'StringLiteral') {
+        keys.push(prop.key.value)
+      }
+    }
+  }
+  return keys
+}
+
+function getArrayExpressionKeys(node: ArrayExpression): string[] {
+  const keys: string[] = []
+  for (const element of node.elements) {
+    if (element && element.type === 'StringLiteral') {
+      keys.push(element.value)
+    }
+  }
+  return keys
+}
+
+function getObjectOrArrayExpressionKeys(value: Node): string[] {
+  if (value.type === 'ArrayExpression') {
+    return getArrayExpressionKeys(value)
+  }
+  if (value.type === 'ObjectExpression') {
+    return getObjectExpressionKeys(value)
+  }
+  return []
+}
+
+const templateUsageCheckCache = new LRU<string, string>(512)
+
+function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
+  const { content, ast } = sfc.template!
+  const cached = templateUsageCheckCache.get(content)
+  if (cached) {
+    return cached
+  }
+
+  let code = ''
+  transform(createRoot([ast]), {
+    nodeTransforms: [
+      node => {
+        if (node.type === NodeTypes.ELEMENT) {
+          if (
+            !parserOptions.isNativeTag!(node.tag) &&
+            !parserOptions.isBuiltInComponent!(node.tag)
+          ) {
+            code += `,${camelize(node.tag)},${capitalize(camelize(node.tag))}`
+          }
+          for (let i = 0; i < node.props.length; i++) {
+            const prop = node.props[i]
+            if (prop.type === NodeTypes.DIRECTIVE) {
+              if (!isBuiltInDir(prop.name)) {
+                code += `,v${capitalize(camelize(prop.name))}`
+              }
+              if (prop.exp) {
+                code += `,${processExp(
+                  (prop.exp as SimpleExpressionNode).content,
+                  prop.name
+                )}`
+              }
+            }
+          }
+        } else if (node.type === NodeTypes.INTERPOLATION) {
+          code += `,${processExp(
+            (node.content as SimpleExpressionNode).content
+          )}`
+        }
+      }
+    ]
+  })
+
+  code += ';'
+  templateUsageCheckCache.set(content, code)
+  return code
+}
+
+const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
+
+function processExp(exp: string, dir?: string): string {
+  if (/ as\s+\w|<.*>|:/.test(exp)) {
+    if (dir === 'slot') {
+      exp = `(${exp})=>{}`
+    } else if (dir === 'for') {
+      const inMatch = exp.match(forAliasRE)
+      if (inMatch) {
+        const [, LHS, RHS] = inMatch
+        return processExp(`(${LHS})=>{}`) + processExp(RHS)
+      }
+    }
+    let ret = ''
+    // has potential type cast or generic arguments that uses types
+    const ast = parseExpression(exp, { plugins: ['typescript'] })
+    walkIdentifiers(ast, node => {
+      ret += `,` + node.name
+    })
+    return ret
+  }
+  return stripStrings(exp)
+}
+
+function stripStrings(exp: string) {
+  return exp
+    .replace(/'[^']*'|"[^"]*"/g, '')
+    .replace(/`[^`]+`/g, stripTemplateString)
+}
+
+function stripTemplateString(str: string): string {
+  const interpMatch = str.match(/\${[^}]+}/g)
+  if (interpMatch) {
+    return interpMatch.map(m => m.slice(2, -1)).join(',')
+  }
+  return ''
+}
+
+function isImportUsed(local: string, sfc: SFCDescriptor): boolean {
+  return new RegExp(
+    // #4274 escape $ since it's a special char in regex
+    // (and is the only regex special char that is valid in identifiers)
+    `[^\\w$_]${local.replace(/\$/g, '\\$')}[^\\w$_]`
+  ).test(resolveTemplateUsageCheckString(sfc))
+}
+
+/**
+ * Note: this comparison assumes the prev/next script are already identical,
+ * and only checks the special case where <script setup lang="ts"> unused import
+ * pruning result changes due to template changes.
+ */
+export function hmrShouldReload(
+  prevImports: Record<string, ImportBinding>,
+  next: SFCDescriptor
+): boolean {
+  if (
+    !next.scriptSetup ||
+    (next.scriptSetup.lang !== 'ts' && next.scriptSetup.lang !== 'tsx')
+  ) {
+    return false
+  }
+
+  // for each previous import, check if its used status remain the same based on
+  // the next descriptor's template
+  for (const key in prevImports) {
+    // if an import was previous unused, but now is used, we need to force
+    // reload so that the script now includes that import.
+    if (!prevImports[key].isUsedInTemplate && isImportUsed(key, next)) {
+      return true
+    }
+  }
+
+  return false
+}
diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index 4b1933f9d38..44ea311f629 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -1,8 +1,4 @@
-import {
-  VueTemplateCompiler,
-  VueTemplateCompilerOptions,
-  ErrorWithRange
-} from './types'
+import { VueTemplateCompiler, VueTemplateCompilerOptions } from './types'
 import assetUrlsModule, {
   AssetURLOptions,
   TransformAssetUrlsOptions
@@ -11,6 +7,7 @@ import srcsetModule from './templateCompilerModules/srcset'
 import consolidate from '@vue/consolidate'
 import * as _compiler from 'web/entry-compiler'
 import { stripWith } from './stripWith'
+import { WarningMessage } from 'types/compiler'
 
 export interface TemplateCompileOptions {
   source: string
@@ -33,8 +30,8 @@ export interface TemplateCompileResult {
   ast: Object | undefined
   code: string
   source: string
-  tips: (string | ErrorWithRange)[]
-  errors: (string | ErrorWithRange)[]
+  tips: (string | WarningMessage)[]
+  errors: (string | WarningMessage)[]
 }
 
 export function compileTemplate(
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index a911824062e..38b2d088284 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -2,7 +2,8 @@ import deindent from 'de-indent'
 import { parseHTML } from 'compiler/parser/html-parser'
 import { makeMap } from 'shared/util'
 import { ASTAttr, WarningMessage } from 'types/compiler'
-import { RawSourceMap } from './types'
+import { BindingMetadata, RawSourceMap } from './types'
+import { hmrShouldReload, ImportBinding } from './compileScript'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
@@ -24,12 +25,39 @@ export interface SFCBlock extends SFCCustomBlock {
   module?: string | boolean
 }
 
+export interface SFCScriptBlock extends SFCBlock {
+  type: 'script'
+  setup?: string | boolean
+  bindings?: BindingMetadata
+  imports?: Record<string, ImportBinding>
+  /**
+   * import('\@babel/types').Statement
+   */
+  scriptAst?: any[]
+  /**
+   * import('\@babel/types').Statement
+   */
+  scriptSetupAst?: any[]
+}
+
 export interface SFCDescriptor {
+  source: string
   template: SFCBlock | null
-  script: SFCBlock | null
+  script: SFCScriptBlock | null
+  scriptSetup: SFCScriptBlock | null
   styles: SFCBlock[]
   customBlocks: SFCCustomBlock[]
   errors: WarningMessage[]
+
+  /**
+   * compare with an existing descriptor to determine whether HMR should perform
+   * a reload vs. re-render.
+   *
+   * Note: this comparison assumes the prev/next script are already identical,
+   * and only checks the special case where <script setup lang="ts"> unused import
+   * pruning result changes due to template changes.
+   */
+  shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean
 }
 
 export interface VueTemplateCompilerParseOptions {
@@ -46,11 +74,14 @@ export function parseComponent(
   options: VueTemplateCompilerParseOptions = {}
 ): SFCDescriptor {
   const sfc: SFCDescriptor = {
+    source: content,
     template: null,
     script: null,
+    scriptSetup: null, // TODO
     styles: [],
     customBlocks: [],
-    errors: []
+    errors: [],
+    shouldForceReload: prevImports => hmrShouldReload(prevImports, sfc)
   }
   let depth = 0
   let currentBlock: SFCBlock | null = null
diff --git a/packages/compiler-sfc/src/stripWith.ts b/packages/compiler-sfc/src/stripWith.ts
index 4f22e051b1f..ec4ff342962 100644
--- a/packages/compiler-sfc/src/stripWith.ts
+++ b/packages/compiler-sfc/src/stripWith.ts
@@ -1,16 +1,7 @@
 import MagicString from 'magic-string'
 import { parseExpression, ParserOptions, ParserPlugin } from '@babel/parser'
-import { walk } from 'estree-walker'
 import { makeMap } from 'shared/util'
-
-import type {
-  Identifier,
-  Node,
-  Function,
-  ObjectProperty,
-  BlockStatement,
-  Program
-} from '@babel/types'
+import { walkIdentifiers } from './babelUtils'
 
 const doNotPrefix = makeMap(
   'Infinity,undefined,NaN,isFinite,isNaN,' +
@@ -46,23 +37,15 @@ export function stripWith(
     plugins
   })
 
-  const parentStack: Node[] = []
-  const knownIds: Record<string, number> = Object.create(null)
-
-  // based on https://github.com/vuejs/core/blob/main/packages/compiler-core/src/babelUtils.ts
-  ;(walk as any)(ast, {
-    enter(node: Node & { scopeIds?: Set<string> }, parent: Node | undefined) {
-      parent && parentStack.push(parent)
-      if (
-        parent &&
-        parent.type.startsWith('TS') &&
-        parent.type !== 'TSAsExpression' &&
-        parent.type !== 'TSNonNullExpression' &&
-        parent.type !== 'TSTypeAssertion'
-      ) {
-        return this.skip()
+  walkIdentifiers(
+    ast,
+    ident => {
+      if (doNotPrefix(ident.name)) {
+        return
       }
-
+      s.prependRight(ident.start!, '_vm.')
+    },
+    node => {
       if (node.type === 'WithStatement') {
         s.remove(node.start!, node.body.start! + 1)
         s.remove(node.end! - 1, node.end!)
@@ -70,383 +53,8 @@ export function stripWith(
           s.prependRight(node.start!, `var _vm=this;var _c=_vm._self._c;`)
         }
       }
-
-      if (node.type === 'Identifier') {
-        const isLocal = !!knownIds[node.name]
-        const isRefed = isReferencedIdentifier(node, parent!, parentStack)
-        if (isRefed && !isLocal) {
-          if (doNotPrefix(node.name)) {
-            return
-          }
-          s.prependRight(node.start!, '_vm.')
-        }
-      } else if (
-        node.type === 'ObjectProperty' &&
-        parent!.type === 'ObjectPattern'
-      ) {
-        // mark property in destructure pattern
-        ;(node as any).inPattern = true
-      } else if (isFunctionType(node)) {
-        // walk function expressions and add its arguments to known identifiers
-        // so that we don't prefix them
-        walkFunctionParams(node, id => markScopeIdentifier(node, id, knownIds))
-      } else if (node.type === 'BlockStatement') {
-        // #3445 record block-level local variables
-        walkBlockDeclarations(node, id =>
-          markScopeIdentifier(node, id, knownIds)
-        )
-      }
-    },
-    leave(node: Node & { scopeIds?: Set<string> }, parent: Node | undefined) {
-      parent && parentStack.pop()
-      if (node !== ast && node.scopeIds) {
-        for (const id of node.scopeIds) {
-          knownIds[id]--
-          if (knownIds[id] === 0) {
-            delete knownIds[id]
-          }
-        }
-      }
     }
-  })
+  )
 
   return s.toString()
 }
-
-export function isReferencedIdentifier(
-  id: Identifier,
-  parent: Node | null,
-  parentStack: Node[]
-) {
-  if (!parent) {
-    return true
-  }
-
-  // is a special keyword but parsed as identifier
-  if (id.name === 'arguments') {
-    return false
-  }
-
-  if (isReferenced(id, parent)) {
-    return true
-  }
-
-  // babel's isReferenced check returns false for ids being assigned to, so we
-  // need to cover those cases here
-  switch (parent.type) {
-    case 'AssignmentExpression':
-    case 'AssignmentPattern':
-      return true
-    case 'ObjectPattern':
-    case 'ArrayPattern':
-      return isInDestructureAssignment(parent, parentStack)
-  }
-
-  return false
-}
-
-export function isInDestructureAssignment(
-  parent: Node,
-  parentStack: Node[]
-): boolean {
-  if (
-    parent &&
-    (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')
-  ) {
-    let i = parentStack.length
-    while (i--) {
-      const p = parentStack[i]
-      if (p.type === 'AssignmentExpression') {
-        return true
-      } else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
-        break
-      }
-    }
-  }
-  return false
-}
-
-export function walkFunctionParams(
-  node: Function,
-  onIdent: (id: Identifier) => void
-) {
-  for (const p of node.params) {
-    for (const id of extractIdentifiers(p)) {
-      onIdent(id)
-    }
-  }
-}
-
-export function walkBlockDeclarations(
-  block: BlockStatement | Program,
-  onIdent: (node: Identifier) => void
-) {
-  for (const stmt of block.body) {
-    if (stmt.type === 'VariableDeclaration') {
-      if (stmt.declare) continue
-      for (const decl of stmt.declarations) {
-        for (const id of extractIdentifiers(decl.id)) {
-          onIdent(id)
-        }
-      }
-    } else if (
-      stmt.type === 'FunctionDeclaration' ||
-      stmt.type === 'ClassDeclaration'
-    ) {
-      if (stmt.declare || !stmt.id) continue
-      onIdent(stmt.id)
-    }
-  }
-}
-
-export function extractIdentifiers(
-  param: Node,
-  nodes: Identifier[] = []
-): Identifier[] {
-  switch (param.type) {
-    case 'Identifier':
-      nodes.push(param)
-      break
-
-    case 'MemberExpression':
-      let object: any = param
-      while (object.type === 'MemberExpression') {
-        object = object.object
-      }
-      nodes.push(object)
-      break
-
-    case 'ObjectPattern':
-      for (const prop of param.properties) {
-        if (prop.type === 'RestElement') {
-          extractIdentifiers(prop.argument, nodes)
-        } else {
-          extractIdentifiers(prop.value, nodes)
-        }
-      }
-      break
-
-    case 'ArrayPattern':
-      param.elements.forEach(element => {
-        if (element) extractIdentifiers(element, nodes)
-      })
-      break
-
-    case 'RestElement':
-      extractIdentifiers(param.argument, nodes)
-      break
-
-    case 'AssignmentPattern':
-      extractIdentifiers(param.left, nodes)
-      break
-  }
-
-  return nodes
-}
-
-export function markScopeIdentifier(
-  node: Node & { scopeIds?: Set<string> },
-  child: Identifier,
-  knownIds: Record<string, number>
-) {
-  const { name } = child
-  if (node.scopeIds && node.scopeIds.has(name)) {
-    return
-  }
-  if (name in knownIds) {
-    knownIds[name]++
-  } else {
-    knownIds[name] = 1
-  }
-  ;(node.scopeIds || (node.scopeIds = new Set())).add(name)
-}
-
-export const isFunctionType = (node: Node): node is Function => {
-  return /Function(?:Expression|Declaration)$|Method$/.test(node.type)
-}
-
-export const isStaticProperty = (node: Node): node is ObjectProperty =>
-  node &&
-  (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
-  !node.computed
-
-export const isStaticPropertyKey = (node: Node, parent: Node) =>
-  isStaticProperty(parent) && parent.key === node
-
-/**
- * Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts
- * To avoid runtime dependency on @babel/types (which includes process references)
- * This file should not change very often in babel but we may need to keep it
- * up-to-date from time to time.
- *
- * https://github.com/babel/babel/blob/main/LICENSE
- *
- */
-function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean {
-  switch (parent.type) {
-    // yes: PARENT[NODE]
-    // yes: NODE.child
-    // no: parent.NODE
-    case 'MemberExpression':
-    case 'OptionalMemberExpression':
-      if (parent.property === node) {
-        return !!parent.computed
-      }
-      return parent.object === node
-
-    case 'JSXMemberExpression':
-      return parent.object === node
-    // no: let NODE = init;
-    // yes: let id = NODE;
-    case 'VariableDeclarator':
-      return parent.init === node
-
-    // yes: () => NODE
-    // no: (NODE) => {}
-    case 'ArrowFunctionExpression':
-      return parent.body === node
-
-    // no: class { #NODE; }
-    // no: class { get #NODE() {} }
-    // no: class { #NODE() {} }
-    // no: class { fn() { return this.#NODE; } }
-    case 'PrivateName':
-      return false
-
-    // no: class { NODE() {} }
-    // yes: class { [NODE]() {} }
-    // no: class { foo(NODE) {} }
-    case 'ClassMethod':
-    case 'ClassPrivateMethod':
-    case 'ObjectMethod':
-      if (parent.key === node) {
-        return !!parent.computed
-      }
-      return false
-
-    // yes: { [NODE]: "" }
-    // no: { NODE: "" }
-    // depends: { NODE }
-    // depends: { key: NODE }
-    case 'ObjectProperty':
-      if (parent.key === node) {
-        return !!parent.computed
-      }
-      // parent.value === node
-      return !grandparent || grandparent.type !== 'ObjectPattern'
-    // no: class { NODE = value; }
-    // yes: class { [NODE] = value; }
-    // yes: class { key = NODE; }
-    case 'ClassProperty':
-      if (parent.key === node) {
-        return !!parent.computed
-      }
-      return true
-    case 'ClassPrivateProperty':
-      return parent.key !== node
-
-    // no: class NODE {}
-    // yes: class Foo extends NODE {}
-    case 'ClassDeclaration':
-    case 'ClassExpression':
-      return parent.superClass === node
-
-    // yes: left = NODE;
-    // no: NODE = right;
-    case 'AssignmentExpression':
-      return parent.right === node
-
-    // no: [NODE = foo] = [];
-    // yes: [foo = NODE] = [];
-    case 'AssignmentPattern':
-      return parent.right === node
-
-    // no: NODE: for (;;) {}
-    case 'LabeledStatement':
-      return false
-
-    // no: try {} catch (NODE) {}
-    case 'CatchClause':
-      return false
-
-    // no: function foo(...NODE) {}
-    case 'RestElement':
-      return false
-
-    case 'BreakStatement':
-    case 'ContinueStatement':
-      return false
-
-    // no: function NODE() {}
-    // no: function foo(NODE) {}
-    case 'FunctionDeclaration':
-    case 'FunctionExpression':
-      return false
-
-    // no: export NODE from "foo";
-    // no: export * as NODE from "foo";
-    case 'ExportNamespaceSpecifier':
-    case 'ExportDefaultSpecifier':
-      return false
-
-    // no: export { foo as NODE };
-    // yes: export { NODE as foo };
-    // no: export { NODE as foo } from "foo";
-    case 'ExportSpecifier':
-      // @ts-expect-error
-      if (grandparent?.source) {
-        return false
-      }
-      return parent.local === node
-
-    // no: import NODE from "foo";
-    // no: import * as NODE from "foo";
-    // no: import { NODE as foo } from "foo";
-    // no: import { foo as NODE } from "foo";
-    // no: import NODE from "bar";
-    case 'ImportDefaultSpecifier':
-    case 'ImportNamespaceSpecifier':
-    case 'ImportSpecifier':
-      return false
-
-    // no: import "foo" assert { NODE: "json" }
-    case 'ImportAttribute':
-      return false
-
-    // no: <div NODE="foo" />
-    case 'JSXAttribute':
-      return false
-
-    // no: [NODE] = [];
-    // no: ({ NODE }) = [];
-    case 'ObjectPattern':
-    case 'ArrayPattern':
-      return false
-
-    // no: new.NODE
-    // no: NODE.target
-    case 'MetaProperty':
-      return false
-
-    // yes: type X = { someProperty: NODE }
-    // no: type X = { NODE: OtherType }
-    case 'ObjectTypeProperty':
-      return parent.key !== node
-
-    // yes: enum X { Foo = NODE }
-    // no: enum X { NODE }
-    case 'TSEnumMember':
-      return parent.id !== node
-
-    // yes: { [NODE]: value }
-    // no: { NODE: value }
-    case 'TSPropertySignature':
-      if (parent.key === node) {
-        return !!parent.computed
-      }
-
-      return true
-  }
-
-  return true
-}
diff --git a/packages/compiler-sfc/src/types.ts b/packages/compiler-sfc/src/types.ts
index 24b1d79f1e1..882db71538f 100644
--- a/packages/compiler-sfc/src/types.ts
+++ b/packages/compiler-sfc/src/types.ts
@@ -1,3 +1,4 @@
+import { WarningMessage } from 'types/compiler'
 import { SFCDescriptor } from './parseComponent'
 
 export interface StartOfSourceMap {
@@ -37,16 +38,58 @@ export interface VueTemplateCompilerOptions {
   directives?: { [key: string]: Function }
 }
 
-export interface ErrorWithRange {
-  msg: string
-  start: number
-  end: number
-}
-
 export interface VueTemplateCompilerResults {
   ast: Object | undefined
   render: string
   staticRenderFns: string[]
-  errors: (string | ErrorWithRange)[]
-  tips: (string | ErrorWithRange)[]
+  errors: (string | WarningMessage)[]
+  tips: (string | WarningMessage)[]
+}
+
+export const enum BindingTypes {
+  /**
+   * returned from data()
+   */
+  DATA = 'data',
+  /**
+   * declared as a prop
+   */
+  PROPS = 'props',
+  /**
+   * a local alias of a `<script setup>` destructured prop.
+   * the original is stored in __propsAliases of the bindingMetadata object.
+   */
+  PROPS_ALIASED = 'props-aliased',
+  /**
+   * a let binding (may or may not be a ref)
+   */
+  SETUP_LET = 'setup-let',
+  /**
+   * a const binding that can never be a ref.
+   * these bindings don't need `unref()` calls when processed in inlined
+   * template expressions.
+   */
+  SETUP_CONST = 'setup-const',
+  /**
+   * a const binding that does not need `unref()`, but may be mutated.
+   */
+  SETUP_REACTIVE_CONST = 'setup-reactive-const',
+  /**
+   * a const binding that may be a ref.
+   */
+  SETUP_MAYBE_REF = 'setup-maybe-ref',
+  /**
+   * bindings that are guaranteed to be refs
+   */
+  SETUP_REF = 'setup-ref',
+  /**
+   * declared by other options, e.g. computed, inject
+   */
+  OPTIONS = 'options'
+}
+
+export type BindingMetadata = {
+  [key: string]: BindingTypes | undefined
+} & {
+  __isScriptSetup?: boolean
 }
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index 92c1425fd24..619987fde45 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -46,6 +46,8 @@ export function initSetup(vm: Component) {
       for (const key in setupResult) {
         if (!isReserved(key)) {
           proxySetupProperty(vm, setupResult, key)
+        } else if (__DEV__) {
+          warn(`Avoid using variables that start with _ or $ in setup().`)
         }
       }
     } else if (__DEV__ && setupResult !== undefined) {

From 846e3165d85c968df3382dc0db6b0ec2c460b224 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 13:26:44 +0800
Subject: [PATCH 138/317] refactor: add types for html parser options

---
 packages/compiler-sfc/src/parseComponent.ts | 13 +++++++++++--
 src/compiler/parser/html-parser.ts          | 20 +++++++++++++++++---
 src/compiler/parser/index.ts                | 12 +++++++-----
 src/types/compiler.ts                       |  9 +++++----
 4 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 38b2d088284..13e580a4a5a 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -14,7 +14,7 @@ export interface SFCCustomBlock {
   content: string
   attrs: { [key: string]: string | true }
   start: number
-  end?: number
+  end: number
   map?: RawSourceMap
 }
 
@@ -115,6 +115,7 @@ export function parseComponent(
         type: tag,
         content: '',
         start: end,
+        end: 0, // will be set on tag close
         attrs: attrs.reduce((cumulated, { name, value }) => {
           cumulated[name] = value || true
           return cumulated
@@ -122,7 +123,15 @@ export function parseComponent(
       }
       if (isSpecialTag(tag)) {
         checkAttrs(currentBlock, attrs)
-        if (tag === 'style') {
+        if (tag === 'script') {
+          const block = currentBlock as SFCScriptBlock
+          if (block.attrs.setup) {
+            block.setup = currentBlock.attrs.setup
+            sfc.scriptSetup = block
+          } else {
+            sfc.script = block
+          }
+        } else if (tag === 'style') {
           sfc.styles.push(currentBlock)
         } else {
           sfc[tag] = currentBlock
diff --git a/src/compiler/parser/html-parser.ts b/src/compiler/parser/html-parser.ts
index 15c3d81ff62..ab24cb52ba7 100644
--- a/src/compiler/parser/html-parser.ts
+++ b/src/compiler/parser/html-parser.ts
@@ -12,6 +12,7 @@
 import { makeMap, no } from 'shared/util'
 import { isNonPhrasingTag } from 'web/compiler/util'
 import { unicodeRegExp } from 'core/util/lang'
+import { ASTAttr, CompilerOptions } from 'types/compiler'
 
 // Regular Expressions for parsing tags and attributes
 const attribute =
@@ -54,7 +55,20 @@ function decodeAttr(value, shouldDecodeNewlines) {
   return value.replace(re, match => decodingMap[match])
 }
 
-export function parseHTML(html, options) {
+export interface HTMLParserOptions extends CompilerOptions {
+  start?: (
+    tag: string,
+    attrs: ASTAttr[],
+    unary: boolean,
+    start: number,
+    end: number
+  ) => void
+  end?: (tag: string, start: number, end: number) => void
+  chars?: (text: string, start?: number, end?: number) => void
+  comment?: (content: string, start: number, end: number) => void
+}
+
+export function parseHTML(html, options: HTMLParserOptions) {
   const stack: any[] = []
   const expectHTML = options.expectHTML
   const isUnaryTag = options.isUnaryTag || no
@@ -72,7 +86,7 @@ export function parseHTML(html, options) {
           const commentEnd = html.indexOf('-->')
 
           if (commentEnd >= 0) {
-            if (options.shouldKeepComment) {
+            if (options.shouldKeepComment && options.comment) {
               options.comment(
                 html.substring(4, commentEnd),
                 index,
@@ -242,7 +256,7 @@ export function parseHTML(html, options) {
     const unary = isUnaryTag(tagName) || !!unarySlash
 
     const l = match.attrs.length
-    const attrs = new Array(l)
+    const attrs: ASTAttr[] = new Array(l)
     for (let i = 0; i < l; i++) {
       const args = match.attrs[i]
       const value = args[3] || args[4] || args[5] || ''
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index fed000892aa..c02379d0f14 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -252,10 +252,12 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
             warn(
               `Invalid dynamic argument expression: attribute names cannot contain ` +
                 `spaces, quotes, <, >, / or =.`,
-              {
-                start: attr.start + attr.name.indexOf(`[`),
-                end: attr.start + attr.name.length
-              }
+              options.outputSourceRange
+                ? {
+                    start: attr.start! + attr.name.indexOf(`[`),
+                    end: attr.start! + attr.name.length
+                  }
+                : undefined
             )
           }
         })
@@ -322,7 +324,7 @@ export function parse(template: string, options: CompilerOptions): ASTElement {
       closeElement(element)
     },
 
-    chars(text: string, start: number, end: number) {
+    chars(text: string, start?: number, end?: number) {
       if (!currentParent) {
         if (__DEV__) {
           if (text === template) {
diff --git a/src/types/compiler.ts b/src/types/compiler.ts
index 639809ed259..faa28758f8d 100644
--- a/src/types/compiler.ts
+++ b/src/types/compiler.ts
@@ -20,6 +20,7 @@ export type CompilerOptions = {
   shouldDecodeNewlines?: boolean
   shouldDecodeNewlinesForHref?: boolean
   outputSourceRange?: boolean
+  shouldKeepComment?: boolean
 
   // runtime user-configurable
   delimiters?: [string, string] // template delimiters
@@ -47,13 +48,13 @@ export type CompiledResult = {
 export type ModuleOptions = {
   // transform an AST node before any attributes are processed
   // returning an ASTElement from pre/transforms replaces the element
-  preTransformNode: (el: ASTElement) => ASTElement | null
+  preTransformNode?: (el: ASTElement) => ASTElement | null | void
   // transform an AST node after built-ins like v-if, v-for are processed
-  transformNode: (el: ASTElement) => ASTElement | null
+  transformNode?: (el: ASTElement) => ASTElement | null | void
   // transform an AST node after its children have been processed
   // cannot return replacement in postTransform because tree is already finalized
-  postTransformNode: (el: ASTElement) => void
-  genData: (el: ASTElement) => string // generate extra data string for an element
+  postTransformNode?: (el: ASTElement) => void
+  genData?: (el: ASTElement) => string // generate extra data string for an element
   transformCode?: (el: ASTElement, code: string) => string // further transform generated code for an element
   staticKeys?: Array<string> // AST properties to be considered static
 }

From d6c0c2a9923ec0cfcfd3f202aca0050c8c6ce72b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 15:26:57 +0800
Subject: [PATCH 139/317] wip: compileScript

---
 packages/compiler-sfc/src/compileScript.ts    |   75 +-
 packages/compiler-sfc/src/parse.ts            |    9 +-
 packages/compiler-sfc/src/parseComponent.ts   |   17 +-
 .../__snapshots__/compileScript.spec.ts.snap  | 1393 ++++++++++++++
 .../compiler-sfc/test/compileScript.spec.ts   | 1708 +++++++++++++++++
 src/compiler/codegen/index.ts                 |    1 -
 src/compiler/helpers.ts                       |    4 +-
 7 files changed, 3157 insertions(+), 50 deletions(-)
 create mode 100644 packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
 create mode 100644 packages/compiler-sfc/test/compileScript.spec.ts

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 1d565c02838..489077739d1 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -10,7 +10,9 @@ import {
   ParserPlugin
 } from '@babel/parser'
 import { generateCodeFrame } from 'compiler/codeframe'
-import { camelize, capitalize, makeMap } from 'shared/util'
+import { camelize, capitalize, isBuiltInTag, makeMap } from 'shared/util'
+import { parseHTML } from 'compiler/parser/html-parser'
+import { baseOptions as webCompilerOptions } from 'web/compiler/options'
 import {
   Node,
   Declaration,
@@ -37,6 +39,10 @@ import {
 import { walk } from 'estree-walker'
 import { RawSourceMap } from 'source-map'
 import { warnOnce } from './warn'
+import { isReservedTag } from 'web/util'
+import { dirRE } from 'compiler/parser'
+import { parseText } from 'compiler/parser/text-parser'
+import { DEFAULT_FILENAME } from './parse'
 
 // Special compiler macros
 const DEFINE_PROPS = 'defineProps'
@@ -52,7 +58,6 @@ const isBuiltInDir = makeMap(
 )
 
 export interface SFCScriptCompileOptions {
-  filename: string
   /**
    * Production mode. Used to determine whether to generate hashed CSS variables
    */
@@ -82,10 +87,9 @@ export interface ImportBinding {
  */
 export function compileScript(
   sfc: SFCDescriptor,
-  options: SFCScriptCompileOptions
+  options: SFCScriptCompileOptions = {}
 ): SFCScriptBlock {
-  let { script, scriptSetup, source } = sfc
-  const { filename } = options
+  let { filename, script, scriptSetup, source } = sfc
   const isProd = !!options.isProd
   const genSourceMap = options.sourceMap !== false
   let refBindings: string[] | undefined
@@ -201,10 +205,10 @@ export function compileScript(
 
   // magic-string state
   const s = new MagicString(source)
-  const startOffset = scriptSetup.loc.start.offset
-  const endOffset = scriptSetup.loc.end.offset
-  const scriptStartOffset = script && script.loc.start.offset
-  const scriptEndOffset = script && script.loc.end.offset
+  const startOffset = scriptSetup.start
+  const endOffset = scriptSetup.end
+  const scriptStartOffset = script && script.start
+  const scriptEndOffset = script && script.end
 
   function helper(key: string): string {
     helperImports.add(key)
@@ -1211,7 +1215,7 @@ export function compileScript(
 
   // 11. finalize default export
   let runtimeOptions = ``
-  if (!hasDefaultExportName && filename) {
+  if (!hasDefaultExportName && filename && filename !== DEFAULT_FILENAME) {
     const match = filename.match(/([^/\\]+)\.\w+$/)
     if (match) {
       runtimeOptions += `\n  __name: '${match[1]}',`
@@ -1828,44 +1832,39 @@ function getObjectOrArrayExpressionKeys(value: Node): string[] {
 const templateUsageCheckCache = new LRU<string, string>(512)
 
 function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
-  const { content, ast } = sfc.template!
+  const { content } = sfc.template!
   const cached = templateUsageCheckCache.get(content)
   if (cached) {
     return cached
   }
 
   let code = ''
-  transform(createRoot([ast]), {
-    nodeTransforms: [
-      node => {
-        if (node.type === NodeTypes.ELEMENT) {
-          if (
-            !parserOptions.isNativeTag!(node.tag) &&
-            !parserOptions.isBuiltInComponent!(node.tag)
-          ) {
-            code += `,${camelize(node.tag)},${capitalize(camelize(node.tag))}`
+
+  parseHTML(content, {
+    ...webCompilerOptions,
+    start(tag, attrs) {
+      if (!isBuiltInTag(tag) && !isReservedTag(tag)) {
+        code += `,${camelize(tag)},${capitalize(camelize(tag))}`
+      }
+      for (let i = 0; i < attrs.length; i++) {
+        const { name, value } = attrs[i]
+        if (dirRE.test(name)) {
+          const baseName = name.replace(dirRE, '')
+          if (!isBuiltInDir(baseName)) {
+            code += `,v${capitalize(camelize(baseName))}`
           }
-          for (let i = 0; i < node.props.length; i++) {
-            const prop = node.props[i]
-            if (prop.type === NodeTypes.DIRECTIVE) {
-              if (!isBuiltInDir(prop.name)) {
-                code += `,v${capitalize(camelize(prop.name))}`
-              }
-              if (prop.exp) {
-                code += `,${processExp(
-                  (prop.exp as SimpleExpressionNode).content,
-                  prop.name
-                )}`
-              }
-            }
+          if (value) {
+            code += `,${processExp(value, baseName)}`
           }
-        } else if (node.type === NodeTypes.INTERPOLATION) {
-          code += `,${processExp(
-            (node.content as SimpleExpressionNode).content
-          )}`
         }
       }
-    ]
+    },
+    chars(text) {
+      const res = parseText(text)
+      if (res) {
+        code += `,${processExp(res.expression)}`
+      }
+    }
   })
 
   code += ';'
diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index 2c2aca2ea31..dfc8faabd25 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -9,6 +9,8 @@ import {
 import hash from 'hash-sum'
 import LRU from 'lru-cache'
 
+export const DEFAULT_FILENAME = 'anonymous.vue'
+
 const cache = new LRU<string, SFCDescriptor>(100)
 
 const splitRE = /\r?\n/g
@@ -26,9 +28,9 @@ export interface ParseOptions {
 export function parse(options: ParseOptions): SFCDescriptor {
   const {
     source,
-    filename = '',
+    filename = DEFAULT_FILENAME,
     compiler,
-    compilerParseOptions = { pad: 'line' } as VueTemplateCompilerParseOptions,
+    compilerParseOptions = { pad: false } as VueTemplateCompilerParseOptions,
     sourceRoot = '',
     needMap = true
   } = options
@@ -49,6 +51,8 @@ export function parse(options: ParseOptions): SFCDescriptor {
     output = parseComponent(source, compilerParseOptions)
   }
 
+  output.filename = filename
+
   if (needMap) {
     if (output.script && !output.script.src) {
       output.script.map = generateSourceMap(
@@ -73,6 +77,7 @@ export function parse(options: ParseOptions): SFCDescriptor {
       })
     }
   }
+
   cache.set(cacheKey, output)
   return output
 }
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 13e580a4a5a..7c6e688d168 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -4,6 +4,7 @@ import { makeMap } from 'shared/util'
 import { ASTAttr, WarningMessage } from 'types/compiler'
 import { BindingMetadata, RawSourceMap } from './types'
 import { hmrShouldReload, ImportBinding } from './compileScript'
+import { DEFAULT_FILENAME } from './parse'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
@@ -42,6 +43,7 @@ export interface SFCScriptBlock extends SFCBlock {
 
 export interface SFCDescriptor {
   source: string
+  filename: string
   template: SFCBlock | null
   script: SFCScriptBlock | null
   scriptSetup: SFCScriptBlock | null
@@ -70,11 +72,12 @@ export interface VueTemplateCompilerParseOptions {
  * Parse a single-file component (*.vue) file into an SFC Descriptor Object.
  */
 export function parseComponent(
-  content: string,
+  source: string,
   options: VueTemplateCompilerParseOptions = {}
 ): SFCDescriptor {
   const sfc: SFCDescriptor = {
-    source: content,
+    source,
+    filename: DEFAULT_FILENAME,
     template: null,
     script: null,
     scriptSetup: null, // TODO
@@ -167,8 +170,8 @@ export function parseComponent(
   function end(tag: string, start: number) {
     if (depth === 1 && currentBlock) {
       currentBlock.end = start
-      let text = content.slice(currentBlock.start, currentBlock.end)
-      if (options.deindent !== false) {
+      let text = source.slice(currentBlock.start, currentBlock.end)
+      if (options.deindent) {
         text = deindent(text)
       }
       // pad content so that linters and pre-processors can output correct
@@ -184,15 +187,15 @@ export function parseComponent(
 
   function padContent(block: SFCBlock, pad: true | 'line' | 'space') {
     if (pad === 'space') {
-      return content.slice(0, block.start).replace(replaceRE, ' ')
+      return source.slice(0, block.start).replace(replaceRE, ' ')
     } else {
-      const offset = content.slice(0, block.start).split(splitRE).length
+      const offset = source.slice(0, block.start).split(splitRE).length
       const padChar = block.type === 'script' && !block.lang ? '//\n' : '\n'
       return Array(offset).join(padChar)
     }
   }
 
-  parseHTML(content, {
+  parseHTML(source, {
     warn,
     start,
     end,
diff --git a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
new file mode 100644
index 00000000000..e98ba898406
--- /dev/null
+++ b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
@@ -0,0 +1,1393 @@
+// Vitest Snapshot v1
+
+exports[`SFC analyze <script> bindings > auto name inference > basic 1`] = `
+"export default {
+  __name: 'FooBar',
+  setup(__props, { expose }) {
+  expose();
+const a = 1
+return { a }
+}
+
+}"
+`;
+
+exports[`SFC analyze <script> bindings > auto name inference > do not overwrite manual name (call) 1`] = `
+"import { defineComponent } from 'vue'
+        const __default__ = defineComponent({
+          name: 'Baz'
+        })
+        
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+const a = 1
+return { a, defineComponent }
+}
+
+})"
+`;
+
+exports[`SFC analyze <script> bindings > auto name inference > do not overwrite manual name (object) 1`] = `
+"const __default__ = {
+          name: 'Baz'
+        }
+        
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+const a = 1
+return { a }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > <script> after <script setup> the script content not end with \`\\n\` 1`] = `
+"const n = 1
+import { x } from './x'
+    
+export default {
+  setup(__props, { expose }) {
+  expose();
+
+    
+return { n, x }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > <script> and <script setup> co-usage > script first 1`] = `
+"import { x } from './x'
+      
+      export const n = 1
+
+      const __default__ = {}
+      
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+
+      x()
+      
+return { n, x }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > <script> and <script setup> co-usage > script setup first 1`] = `
+"export const n = 1
+      const __default__ = {}
+      
+import { x } from './x'
+      
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+
+      x()
+      
+return { n, x }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > <script> and <script setup> co-usage > script setup first, lang="ts", script block content export default 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+
+      const __default__ = {
+        name: \\"test\\"
+      }
+      
+import { x } from './x'
+      
+export default /*#__PURE__*/_defineComponent({
+  ...__default__,
+  setup(__props, { expose }) {
+  expose();
+
+      x()
+      
+return { x }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > <script> and <script setup> co-usage > script setup first, named default export 1`] = `
+"export const n = 1
+      const def = {}
+      
+      
+const __default__ = def
+
+import { x } from './x'
+      
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+
+      x()
+      
+return { n, def, x }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > <script> and <script setup> co-usage > spaces in ExportDefaultDeclaration node > with many spaces and newline 1`] = `
+"import { x } from './x'
+        
+        export const n = 1
+        const __default__ = {
+          some:'option'
+        }
+        
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+
+        x()
+        
+return { n, x }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > <script> and <script setup> co-usage > spaces in ExportDefaultDeclaration node > with minimal spaces 1`] = `
+"import { x } from './x'
+        
+        export const n = 1
+        const __default__ = {
+          some:'option'
+        }
+        
+export default /*#__PURE__*/Object.assign(__default__, {
+  setup(__props, { expose }) {
+  expose();
+
+        x()
+        
+return { n, x }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > expression statement 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+;(
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  await __temp,
+  __restore()
+)
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > multiple \`if for\` nested statements 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+if (ok) {
+        for (let a of [1,2,3]) {
+          (
+  ([__temp,__restore] = _withAsyncContext(() => a)),
+  await __temp,
+  __restore()
+)
+        }
+        for (let a of [1,2,3]) {
+          (
+  ([__temp,__restore] = _withAsyncContext(() => a)),
+  await __temp,
+  __restore()
+)
+          ;(
+  ([__temp,__restore] = _withAsyncContext(() => a)),
+  await __temp,
+  __restore()
+)
+        }
+      }
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > multiple \`if while\` nested statements 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+if (ok) {
+        while (d) {
+          (
+  ([__temp,__restore] = _withAsyncContext(() => 5)),
+  await __temp,
+  __restore()
+)
+        }
+        while (d) {
+          (
+  ([__temp,__restore] = _withAsyncContext(() => 5)),
+  await __temp,
+  __restore()
+)
+          ;(
+  ([__temp,__restore] = _withAsyncContext(() => 6)),
+  await __temp,
+  __restore()
+)
+          if (c) {
+            let f = 10
+            10 + (
+  ([__temp,__restore] = _withAsyncContext(() => 7)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)
+          } else {
+            (
+  ([__temp,__restore] = _withAsyncContext(() => 8)),
+  await __temp,
+  __restore()
+)
+            ;(
+  ([__temp,__restore] = _withAsyncContext(() => 9)),
+  await __temp,
+  __restore()
+)
+          }
+        }
+      }
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > multiple \`if\` nested statements 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+if (ok) {
+        let a = 'foo'
+        ;(
+  ([__temp,__restore] = _withAsyncContext(() => 0)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+) + (
+  ([__temp,__restore] = _withAsyncContext(() => 1)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)
+        ;(
+  ([__temp,__restore] = _withAsyncContext(() => 2)),
+  await __temp,
+  __restore()
+)
+      } else if (a) {
+        (
+  ([__temp,__restore] = _withAsyncContext(() => 10)),
+  await __temp,
+  __restore()
+)
+        if (b) {
+          (
+  ([__temp,__restore] = _withAsyncContext(() => 0)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+) + (
+  ([__temp,__restore] = _withAsyncContext(() => 1)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)
+        } else {
+          let a = 'foo'
+          ;(
+  ([__temp,__restore] = _withAsyncContext(() => 2)),
+  await __temp,
+  __restore()
+)
+        }
+        if (b) {
+          (
+  ([__temp,__restore] = _withAsyncContext(() => 3)),
+  await __temp,
+  __restore()
+)
+          ;(
+  ([__temp,__restore] = _withAsyncContext(() => 4)),
+  await __temp,
+  __restore()
+)
+        }
+      } else {
+        (
+  ([__temp,__restore] = _withAsyncContext(() => 5)),
+  await __temp,
+  __restore()
+)
+      }
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > nested await 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+;(
+  ([__temp,__restore] = _withAsyncContext(async () => ((
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)))),
+  await __temp,
+  __restore()
+)
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > nested await 2`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+;(
+  ([__temp,__restore] = _withAsyncContext(async () => (((
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+))))),
+  await __temp,
+  __restore()
+)
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > nested await 3`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+;(
+  ([__temp,__restore] = _withAsyncContext(async () => ((
+  ([__temp,__restore] = _withAsyncContext(async () => ((
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)))),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)))),
+  await __temp,
+  __restore()
+)
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > nested leading await in expression statement 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+foo()
+;(
+  ([__temp,__restore] = _withAsyncContext(() => 1)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+) + (
+  ([__temp,__restore] = _withAsyncContext(() => 2)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > nested statements 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+if (ok) { (
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  await __temp,
+  __restore()
+) } else { (
+  ([__temp,__restore] = _withAsyncContext(() => bar)),
+  await __temp,
+  __restore()
+) }
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > ref 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+let a = $ref(1 + ((
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+)))
+return { a }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 1`] = `
+"export default {
+  setup(__props, { expose }) {
+  expose();
+async function foo() { await bar }
+return { foo }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 2`] = `
+"export default {
+  setup(__props, { expose }) {
+  expose();
+const foo = async () => { await bar }
+return { foo }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 3`] = `
+"export default {
+  setup(__props, { expose }) {
+  expose();
+const obj = { async method() { await bar }}
+return { obj }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 4`] = `
+"export default {
+  setup(__props, { expose }) {
+  expose();
+const cls = class Foo { async method() { await bar }}
+return { cls }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > single line conditions 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+if (false) (
+  ([__temp,__restore] = _withAsyncContext(() => foo())),
+  await __temp,
+  __restore()
+)
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > async/await detection > variable 1`] = `
+"import { withAsyncContext as _withAsyncContext } from 'vue'
+
+export default {
+  async setup(__props, { expose }) {
+  expose();
+
+let __temp, __restore
+const a = 1 + ((
+  ([__temp,__restore] = _withAsyncContext(() => foo)),
+  __temp = await __temp,
+  __restore(),
+  __temp
+))
+return { a }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > binding analysis for destructure 1`] = `
+"export default {
+  setup(__props, { expose }) {
+  expose();
+
+      const { foo, b: bar, ['x' + 'y']: baz, x: { y, zz: { z }}} = {}
+      
+return { foo, bar, baz, y, z }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineEmits() 1`] = `
+"export default {
+  emits: ['foo', 'bar'],
+  setup(__props, { expose, emit: myEmit }) {
+  expose();
+
+
+
+return { myEmit }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineExpose() 1`] = `
+"export default {
+  setup(__props, { expose }) {
+
+expose({ foo: 123 })
+
+return {  }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineProps w/ external definition 1`] = `
+"import { propsModel } from './props'
+    
+export default {
+  props: propsModel,
+  setup(__props, { expose }) {
+  expose();
+
+const props = __props
+
+    
+    
+return { props, propsModel }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineProps w/ leading code 1`] = `
+"import { x } from './x'
+    
+export default {
+  props: {},
+  setup(__props, { expose }) {
+  expose();
+
+const props = __props
+
+    
+return { props, x }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineProps() 1`] = `
+"export default {
+  props: {
+  foo: String
+},
+  setup(__props, { expose }) {
+  expose();
+
+const props = __props
+
+
+const bar = 1
+
+return { props, bar }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineProps/defineEmits in multi-variable declaration (full removal) 1`] = `
+"export default {
+  props: ['item'],
+  emits: ['a'],
+  setup(__props, { expose, emit }) {
+  expose();
+
+const props = __props
+
+    
+    
+return { props, emit }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > defineProps/defineEmits in multi-variable declaration 1`] = `
+"export default {
+  props: ['item'],
+  emits: ['a'],
+  setup(__props, { expose, emit }) {
+  expose();
+
+const props = __props
+
+    const a = 1;
+    
+return { props, a, emit }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > TS annotations 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { Foo, Baz, Qux, Fred } from './x'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        const a = 1
+        function b() {}
+        
+return { a, b, Baz }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > attribute expressions 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { bar, baz } from './x'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        const cond = true
+        
+return { cond, bar, baz }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > components 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { FooBar, FooBaz, FooQux, foo } from './x'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        const fooBar: FooBar = 1
+        
+return { fooBar, FooBaz, FooQux, foo }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > directive 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { vMyDir } from './x'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { vMyDir }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > js template string interpolations 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { VAR, VAR2, VAR3 } from './x'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { VAR, VAR3 }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > last tag 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { FooBaz, Last } from './x'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { FooBaz, Last }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > dev mode import usage check > vue interpolations 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import { x, y, z, x$y } from './x'
+      
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+      
+return { x, z, x$y }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > errors > should allow defineProps/Emit() referencing imported binding 1`] = `
+"import { bar } from './bar'
+        
+export default {
+  props: {
+          foo: {
+            default: () => bar
+          }
+        },
+  emits: {
+          foo: () => bar > 1
+        },
+  setup(__props, { expose }) {
+  expose();
+
+        
+        
+        
+return { bar }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > errors > should allow defineProps/Emit() referencing scope var 1`] = `
+"export default {
+  props: {
+            foo: {
+              default: bar => bar + 1
+            }
+          },
+  emits: {
+            foo: bar => bar > 1
+          },
+  setup(__props, { expose }) {
+  expose();
+
+          const bar = 1
+          
+          
+        
+return { bar }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > imports > import dedupe between <script> and <script setup> 1`] = `
+"import { x } from './x'
+        
+export default {
+  setup(__props, { expose }) {
+  expose();
+
+        x()
+        
+return { x }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > imports > should allow defineProps/Emit at the start of imports 1`] = `
+"import { ref } from 'vue'
+      
+export default {
+  props: ['foo'],
+  emits: ['bar'],
+  setup(__props, { expose }) {
+  expose();
+
+      
+      
+      const r = ref(0)
+      
+return { r, ref }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > imports > should extract comment for import or type declarations 1`] = `
+"import a from 'a' // comment
+        import b from 'b'
+        
+export default {
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { a, b }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > imports > should hoist and expose imports 1`] = `
+"import { ref } from 'vue'
+          import 'foo/css'
+        
+export default {
+  setup(__props, { expose }) {
+  expose();
+
+          
+return { ref }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > should expose top level declarations 1`] = `
+"import { xx } from './x'
+      let aa = 1
+      const bb = 2
+      function cc() {}
+      class dd {}
+      
+import { x } from './x'
+      
+export default {
+  setup(__props, { expose }) {
+  expose();
+
+      let a = 1
+      const b = 2
+      function c() {}
+      class d {}
+      
+return { aa, bb, cc, dd, a, b, c, d, xx, x }
+}
+
+}"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > const Enum 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+const enum Foo { A = 123 }
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { Foo }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (exported interface) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+export interface Emits { (e: 'foo' | 'bar'): void }
+      
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (exported type alias) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+export type Emits = { (e: 'foo' | 'bar'): void }
+      
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (interface) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+interface Emits { (e: 'foo' | 'bar'): void }
+      
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (referenced exported function type) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+export type Emits = (e: 'foo' | 'bar') => void
+      
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (referenced function type) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+type Emits = (e: 'foo' | 'bar') => void
+      
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (type alias) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+type Emits = { (e: 'foo' | 'bar'): void }
+      
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (type literal w/ call signatures) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\", \\"baz\\"],
+  setup(__props, { expose, emit }: { emit: ({(e: 'foo' | 'bar'): void; (e: 'baz', id: number): void;}), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+
+export default /*#__PURE__*/_defineComponent({
+  emits: [\\"foo\\", \\"bar\\"],
+  setup(__props, { expose, emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
+  expose();
+
+      
+      
+return { emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps w/ exported interface 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+export interface Props { x?: number }
+      
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    x: { type: Number, required: false }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+      
+      
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps w/ exported interface in normal script 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+
+        export interface Props { x?: number }
+      
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    x: { type: Number, required: false }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+        
+      
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps w/ exported type alias 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+export type Props = { x?: number }
+      
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    x: { type: Number, required: false }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+      
+      
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps w/ interface 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+interface Props { x?: number }
+      
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    x: { type: Number, required: false }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+      
+      
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps w/ type 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+interface Test {}
+
+      type Alias = number[]
+
+      
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    string: { type: String, required: true },
+    number: { type: Number, required: true },
+    boolean: { type: Boolean, required: true },
+    object: { type: Object, required: true },
+    objectLiteral: { type: Object, required: true },
+    fn: { type: Function, required: true },
+    functionRef: { type: Function, required: true },
+    objectRef: { type: Object, required: true },
+    dateTime: { type: Date, required: true },
+    array: { type: Array, required: true },
+    arrayRef: { type: Array, required: true },
+    tuple: { type: Array, required: true },
+    set: { type: Set, required: true },
+    literal: { type: String, required: true },
+    optional: { type: null, required: false },
+    recordRef: { type: Object, required: true },
+    interface: { type: Object, required: true },
+    alias: { type: Array, required: true },
+    method: { type: Function, required: true },
+    symbol: { type: Symbol, required: true },
+    union: { type: [String, Number], required: true },
+    literalUnion: { type: String, required: true },
+    literalUnionNumber: { type: Number, required: true },
+    literalUnionMixed: { type: [String, Number, Boolean], required: true },
+    intersection: { type: Object, required: true },
+    foo: { type: [Function, null], required: true }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+      
+      
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps w/ type alias 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+type Props = { x?: number }
+      
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    x: { type: Number, required: false }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+      
+      
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > defineProps/Emit w/ runtime options 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+
+export default /*#__PURE__*/_defineComponent({
+  props: { foo: String },
+  emits: ['a', 'b'],
+  setup(__props, { expose, emit }) {
+  expose();
+
+const props = __props
+
+
+
+
+return { props, emit }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > hoist type declarations 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+export interface Foo {}
+        type Bar = {}
+      
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return {  }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > import type 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+import type { Foo } from './main.ts'
+        import { type Bar, Baz } from './main.ts'
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { Baz }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > runtime Enum 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+enum Foo { A = 123 }
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { Foo }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > runtime Enum in normal script 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+enum Foo { A = 123 }
+        
+          export enum D { D = \\"D\\" }
+          const enum C { C = \\"C\\" }
+          enum B { B = \\"B\\" }
+        
+export default /*#__PURE__*/_defineComponent({
+  setup(__props, { expose }) {
+  expose();
+
+        
+return { D, C, B, Foo }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > withDefaults (dynamic) 1`] = `
+"import { mergeDefaults as _mergeDefaults, defineComponent as _defineComponent } from 'vue'
+import { defaults } from './foo'
+      
+export default /*#__PURE__*/_defineComponent({
+  props: _mergeDefaults({
+    foo: { type: String, required: false },
+    bar: { type: Number, required: false },
+    baz: { type: Boolean, required: true }
+  }, { ...defaults }),
+  setup(__props: any, { expose }) {
+  expose();
+
+const props = __props as {
+        foo?: string
+        bar?: number
+        baz: boolean
+      }
+
+      
+      
+return { props, defaults }
+}
+
+})"
+`;
+
+exports[`SFC compile <script setup> > with TypeScript > withDefaults (static) 1`] = `
+"import { defineComponent as _defineComponent } from 'vue'
+
+export default /*#__PURE__*/_defineComponent({
+  props: {
+    foo: { type: String, required: false, default: 'hi' },
+    bar: { type: Number, required: false },
+    baz: { type: Boolean, required: true },
+    qux: { type: Function, required: false, default() { return 1 } }
+  },
+  setup(__props: any, { expose }) {
+  expose();
+
+const props = __props as { foo: string, bar?: number, baz: boolean, qux(): number }
+
+      
+      
+return { props }
+}
+
+})"
+`;
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
new file mode 100644
index 00000000000..54afae2e670
--- /dev/null
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -0,0 +1,1708 @@
+import { BindingTypes } from '../src/types'
+import { parse, ParseOptions } from '../src/parse'
+import { parse as babelParse } from '@babel/parser'
+import { compileScript, SFCScriptCompileOptions } from '../src/compileScript'
+
+function compile(
+  source: string,
+  options?: Partial<SFCScriptCompileOptions>,
+  parseOptions?: Partial<ParseOptions>
+) {
+  const sfc = parse({
+    ...parseOptions,
+    source
+  })
+  return compileScript(sfc, options)
+}
+
+function assertCode(code: string) {
+  // parse the generated code to make sure it is valid
+  try {
+    babelParse(code, {
+      sourceType: 'module',
+      plugins: ['typescript']
+    })
+  } catch (e: any) {
+    console.log(code)
+    throw e
+  }
+  expect(code).toMatchSnapshot()
+}
+
+describe('SFC compile <script setup>', () => {
+  test('should expose top level declarations', () => {
+    const { content, bindings } = compile(`
+      <script setup>
+      import { x } from './x'
+      let a = 1
+      const b = 2
+      function c() {}
+      class d {}
+      </script>
+
+      <script>
+      import { xx } from './x'
+      let aa = 1
+      const bb = 2
+      function cc() {}
+      class dd {}
+      </script>
+      `)
+    expect(content).toMatch('return { aa, bb, cc, dd, a, b, c, d, xx, x }')
+    expect(bindings).toStrictEqual({
+      x: BindingTypes.SETUP_MAYBE_REF,
+      a: BindingTypes.SETUP_LET,
+      b: BindingTypes.SETUP_CONST,
+      c: BindingTypes.SETUP_CONST,
+      d: BindingTypes.SETUP_CONST,
+      xx: BindingTypes.SETUP_MAYBE_REF,
+      aa: BindingTypes.SETUP_LET,
+      bb: BindingTypes.SETUP_CONST,
+      cc: BindingTypes.SETUP_CONST,
+      dd: BindingTypes.SETUP_CONST
+    })
+    assertCode(content)
+  })
+
+  test('binding analysis for destructure', () => {
+    const { content, bindings } = compile(`
+      <script setup>
+      const { foo, b: bar, ['x' + 'y']: baz, x: { y, zz: { z }}} = {}
+      </script>
+      `)
+    expect(content).toMatch('return { foo, bar, baz, y, z }')
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.SETUP_MAYBE_REF,
+      bar: BindingTypes.SETUP_MAYBE_REF,
+      baz: BindingTypes.SETUP_MAYBE_REF,
+      y: BindingTypes.SETUP_MAYBE_REF,
+      z: BindingTypes.SETUP_MAYBE_REF
+    })
+    assertCode(content)
+  })
+
+  test('defineProps()', () => {
+    const { content, bindings } = compile(`
+<script setup>
+const props = defineProps({
+  foo: String
+})
+const bar = 1
+</script>
+  `)
+    // should generate working code
+    assertCode(content)
+    // should analyze bindings
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.PROPS,
+      bar: BindingTypes.SETUP_CONST,
+      props: BindingTypes.SETUP_REACTIVE_CONST
+    })
+
+    // should remove defineOptions import and call
+    expect(content).not.toMatch('defineProps')
+    // should generate correct setup signature
+    expect(content).toMatch(`setup(__props, { expose }) {`)
+    // should assign user identifier to it
+    expect(content).toMatch(`const props = __props`)
+    // should include context options in default export
+    expect(content).toMatch(`export default {
+  props: {
+  foo: String
+},`)
+  })
+
+  test('defineProps w/ external definition', () => {
+    const { content } = compile(`
+    <script setup>
+    import { propsModel } from './props'
+    const props = defineProps(propsModel)
+    </script>
+      `)
+    assertCode(content)
+    expect(content).toMatch(`export default {
+  props: propsModel,`)
+  })
+
+  // #4764
+  test('defineProps w/ leading code', () => {
+    const { content } = compile(`
+    <script setup>import { x } from './x'
+    const props = defineProps({})
+    </script>
+    `)
+    // props declaration should be inside setup, not moved along with the import
+    expect(content).not.toMatch(`const props = __props\nimport`)
+    assertCode(content)
+  })
+
+  test('defineEmits()', () => {
+    const { content, bindings } = compile(`
+<script setup>
+const myEmit = defineEmits(['foo', 'bar'])
+</script>
+  `)
+    assertCode(content)
+    expect(bindings).toStrictEqual({
+      myEmit: BindingTypes.SETUP_CONST
+    })
+    // should remove defineOptions import and call
+    expect(content).not.toMatch('defineEmits')
+    // should generate correct setup signature
+    expect(content).toMatch(`setup(__props, { expose, emit: myEmit }) {`)
+    // should include context options in default export
+    expect(content).toMatch(`export default {
+  emits: ['foo', 'bar'],`)
+  })
+
+  test('defineProps/defineEmits in multi-variable declaration', () => {
+    const { content } = compile(`
+    <script setup>
+    const props = defineProps(['item']),
+      a = 1,
+      emit = defineEmits(['a']);
+    </script>
+  `)
+    assertCode(content)
+    expect(content).toMatch(`const a = 1;`) // test correct removal
+    expect(content).toMatch(`props: ['item'],`)
+    expect(content).toMatch(`emits: ['a'],`)
+  })
+
+  test('defineProps/defineEmits in multi-variable declaration (full removal)', () => {
+    const { content } = compile(`
+    <script setup>
+    const props = defineProps(['item']),
+          emit = defineEmits(['a']);
+    </script>
+  `)
+    assertCode(content)
+    expect(content).toMatch(`props: ['item'],`)
+    expect(content).toMatch(`emits: ['a'],`)
+  })
+
+  test('defineExpose()', () => {
+    const { content } = compile(`
+<script setup>
+defineExpose({ foo: 123 })
+</script>
+  `)
+    assertCode(content)
+    // should remove defineOptions import and call
+    expect(content).not.toMatch('defineExpose')
+    // should generate correct setup signature
+    expect(content).toMatch(`setup(__props, { expose }) {`)
+    // should replace callee
+    expect(content).toMatch(/\bexpose\(\{ foo: 123 \}\)/)
+  })
+
+  test('<script> after <script setup> the script content not end with `\\n`', () => {
+    const { content } = compile(`
+    <script setup>
+    import { x } from './x'
+    </script>
+    <script>const n = 1</script>
+    `)
+    assertCode(content)
+  })
+
+  describe('<script> and <script setup> co-usage', () => {
+    test('script first', () => {
+      const { content } = compile(`
+      <script>
+      export const n = 1
+
+      export default {}
+      </script>
+      <script setup>
+      import { x } from './x'
+      x()
+      </script>
+      `)
+      assertCode(content)
+    })
+
+    test('script setup first', () => {
+      const { content } = compile(`
+      <script setup>
+      import { x } from './x'
+      x()
+      </script>
+      <script>
+      export const n = 1
+      export default {}
+      </script>
+      `)
+      assertCode(content)
+    })
+
+    test('script setup first, named default export', () => {
+      const { content } = compile(`
+      <script setup>
+      import { x } from './x'
+      x()
+      </script>
+      <script>
+      export const n = 1
+      const def = {}
+      export { def as default }
+      </script>
+      `)
+      assertCode(content)
+    })
+
+    // #4395
+    test('script setup first, lang="ts", script block content export default', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      import { x } from './x'
+      x()
+      </script>
+      <script lang="ts">
+      export default {
+        name: "test"
+      }
+      </script>
+      `)
+      // ensure __default__ is declared before used
+      expect(content).toMatch(/const __default__[\S\s]*\.\.\.__default__/m)
+      assertCode(content)
+    })
+
+    describe('spaces in ExportDefaultDeclaration node', () => {
+      // #4371
+      test('with many spaces and newline', () => {
+        // #4371
+        const { content } = compile(`
+        <script>
+        export const n = 1
+        export        default
+        {
+          some:'option'
+        }
+        </script>
+        <script setup>
+        import { x } from './x'
+        x()
+        </script>
+        `)
+        assertCode(content)
+      })
+
+      test('with minimal spaces', () => {
+        const { content } = compile(`
+        <script>
+        export const n = 1
+        export default{
+          some:'option'
+        }
+        </script>
+        <script setup>
+        import { x } from './x'
+        x()
+        </script>
+        `)
+        assertCode(content)
+      })
+    })
+  })
+
+  describe('imports', () => {
+    test('should hoist and expose imports', () => {
+      assertCode(
+        compile(`<script setup>
+          import { ref } from 'vue'
+          import 'foo/css'
+        </script>`).content
+      )
+    })
+
+    test('should extract comment for import or type declarations', () => {
+      assertCode(
+        compile(`
+        <script setup>
+        import a from 'a' // comment
+        import b from 'b'
+        </script>
+        `).content
+      )
+    })
+
+    // #2740
+    test('should allow defineProps/Emit at the start of imports', () => {
+      assertCode(
+        compile(`<script setup>
+      import { ref } from 'vue'
+      defineProps(['foo'])
+      defineEmits(['bar'])
+      const r = ref(0)
+      </script>`).content
+      )
+    })
+
+    test('import dedupe between <script> and <script setup>', () => {
+      const { content } = compile(`
+        <script>
+        import { x } from './x'
+        </script>
+        <script setup>
+        import { x } from './x'
+        x()
+        </script>
+        `)
+      assertCode(content)
+      expect(content.indexOf(`import { x }`)).toEqual(
+        content.lastIndexOf(`import { x }`)
+      )
+    })
+  })
+
+  // in dev mode, declared bindings are returned as an object from setup()
+  // when using TS, users may import types which should not be returned as
+  // values, so we need to check import usage in the template to determine
+  // what to be returned.
+  describe('dev mode import usage check', () => {
+    test('components', () => {
+      const { content } = compile(`
+        <script setup lang="ts">
+        import { FooBar, FooBaz, FooQux, foo } from './x'
+        const fooBar: FooBar = 1
+        </script>
+        <template>
+          <FooBaz></FooBaz>
+          <foo-qux/>
+          <foo/>
+          FooBar
+        </template>
+        `)
+      // FooBar: should not be matched by plain text or incorrect case
+      // FooBaz: used as PascalCase component
+      // FooQux: used as kebab-case component
+      // foo: lowercase component
+      expect(content).toMatch(`return { fooBar, FooBaz, FooQux, foo }`)
+      assertCode(content)
+    })
+
+    test('directive', () => {
+      const { content } = compile(`
+        <script setup lang="ts">
+        import { vMyDir } from './x'
+        </script>
+        <template>
+          <div v-my-dir></div>
+        </template>
+        `)
+      expect(content).toMatch(`return { vMyDir }`)
+      assertCode(content)
+    })
+
+    // https://github.com/vuejs/core/issues/4599
+    test('attribute expressions', () => {
+      const { content } = compile(`
+        <script setup lang="ts">
+        import { bar, baz } from './x'
+        const cond = true
+        </script>
+        <template>
+          <div :class="[cond ? '' : bar(), 'default']" :style="baz"></div>
+        </template>
+        `)
+      expect(content).toMatch(`return { cond, bar, baz }`)
+      assertCode(content)
+    })
+
+    test('vue interpolations', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      import { x, y, z, x$y } from './x'
+      </script>
+      <template>
+        <div :id="z + 'y'">{{ x }} {{ yy }} {{ x$y }}</div>
+      </template>
+      `)
+      // x: used in interpolation
+      // y: should not be matched by {{ yy }} or 'y' in binding exps
+      // x$y: #4274 should escape special chars when creating Regex
+      expect(content).toMatch(`return { x, z, x$y }`)
+      assertCode(content)
+    })
+
+    // #4340 interpolations in template strings
+    test('js template string interpolations', () => {
+      const { content } = compile(`
+        <script setup lang="ts">
+        import { VAR, VAR2, VAR3 } from './x'
+        </script>
+        <template>
+          {{ \`\${VAR}VAR2\${VAR3}\` }}
+        </template>
+        `)
+      // VAR2 should not be matched
+      expect(content).toMatch(`return { VAR, VAR3 }`)
+      assertCode(content)
+    })
+
+    // edge case: last tag in template
+    test('last tag', () => {
+      const { content } = compile(`
+        <script setup lang="ts">
+        import { FooBaz, Last } from './x'
+        </script>
+        <template>
+          <FooBaz></FooBaz>
+          <Last/>
+        </template>
+        `)
+      expect(content).toMatch(`return { FooBaz, Last }`)
+      assertCode(content)
+    })
+
+    test('TS annotations', () => {
+      const { content } = compile(`
+        <script setup lang="ts">
+        import { Foo, Baz, Qux, Fred } from './x'
+        const a = 1
+        function b() {}
+        </script>
+        <template>
+          {{ a as Foo }}
+          {{ Baz }}
+          <Comp v-slot="{ data }: Qux">{{ data }}</Comp>
+          <div v-for="{ z = x as Qux } in list as Fred"/>
+        </template>
+        `)
+
+      expect(content).toMatch(`return { a, b, Baz }`)
+      assertCode(content)
+    })
+  })
+
+  // describe('inlineTemplate mode', () => {
+  //   test('should work', () => {
+  //     const { content } = compile(
+  //       `
+  //       <script setup>
+  //       import { ref } from 'vue'
+  //       const count = ref(0)
+  //       </script>
+  //       <template>
+  //         <div>{{ count }}</div>
+  //         <div>static</div>
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     // check snapshot and make sure helper imports and
+  //     // hoists are placed correctly.
+  //     assertCode(content)
+  //     // in inline mode, no need to call expose() since nothing is exposed
+  //     // anyway!
+  //     expect(content).not.toMatch(`expose()`)
+  //   })
+
+  //   test('with defineExpose()', () => {
+  //     const { content } = compile(
+  //       `
+  //       <script setup>
+  //       const count = ref(0)
+  //       defineExpose({ count })
+  //       </script>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     assertCode(content)
+  //     expect(content).toMatch(`setup(__props, { expose })`)
+  //     expect(content).toMatch(`expose({ count })`)
+  //   })
+
+  //   test('referencing scope components and directives', () => {
+  //     const { content } = compile(
+  //       `
+  //       <script setup>
+  //       import ChildComp from './Child.vue'
+  //       import SomeOtherComp from './Other.vue'
+  //       import vMyDir from './my-dir'
+  //       </script>
+  //       <template>
+  //         <div v-my-dir></div>
+  //         <ChildComp/>
+  //         <some-other-comp/>
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     expect(content).toMatch('[_unref(vMyDir)]')
+  //     expect(content).toMatch('_createVNode(ChildComp)')
+  //     // kebab-case component support
+  //     expect(content).toMatch('_createVNode(SomeOtherComp)')
+  //     assertCode(content)
+  //   })
+
+  //   test('avoid unref() when necessary', () => {
+  //     // function, const, component import
+  //     const { content } = compile(
+  //       `<script setup>
+  //       import { ref } from 'vue'
+  //       import Foo, { bar } from './Foo.vue'
+  //       import other from './util'
+  //       import * as tree from './tree'
+  //       const count = ref(0)
+  //       const constant = {}
+  //       const maybe = foo()
+  //       let lett = 1
+  //       function fn() {}
+  //       </script>
+  //       <template>
+  //         <Foo>{{ bar }}</Foo>
+  //         <div @click="fn">{{ count }} {{ constant }} {{ maybe }} {{ lett }} {{ other }}</div>
+  //         {{ tree.foo() }}
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     // no need to unref vue component import
+  //     expect(content).toMatch(`createVNode(Foo,`)
+  //     // #2699 should unref named imports from .vue
+  //     expect(content).toMatch(`unref(bar)`)
+  //     // should unref other imports
+  //     expect(content).toMatch(`unref(other)`)
+  //     // no need to unref constant literals
+  //     expect(content).not.toMatch(`unref(constant)`)
+  //     // should directly use .value for known refs
+  //     expect(content).toMatch(`count.value`)
+  //     // should unref() on const bindings that may be refs
+  //     expect(content).toMatch(`unref(maybe)`)
+  //     // should unref() on let bindings
+  //     expect(content).toMatch(`unref(lett)`)
+  //     // no need to unref namespace import (this also preserves tree-shaking)
+  //     expect(content).toMatch(`tree.foo()`)
+  //     // no need to unref function declarations
+  //     expect(content).toMatch(`{ onClick: fn }`)
+  //     // no need to mark constant fns in patch flag
+  //     expect(content).not.toMatch(`PROPS`)
+  //     assertCode(content)
+  //   })
+
+  //   test('v-model codegen', () => {
+  //     const { content } = compile(
+  //       `<script setup>
+  //       import { ref } from 'vue'
+  //       const count = ref(0)
+  //       const maybe = foo()
+  //       let lett = 1
+  //       </script>
+  //       <template>
+  //         <input v-model="count">
+  //         <input v-model="maybe">
+  //         <input v-model="lett">
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     // known const ref: set value
+  //     expect(content).toMatch(`(count).value = $event`)
+  //     // const but maybe ref: assign if ref, otherwise do nothing
+  //     expect(content).toMatch(`_isRef(maybe) ? (maybe).value = $event : null`)
+  //     // let: handle both cases
+  //     expect(content).toMatch(
+  //       `_isRef(lett) ? (lett).value = $event : lett = $event`
+  //     )
+  //     assertCode(content)
+  //   })
+
+  //   test('template assignment expression codegen', () => {
+  //     const { content } = compile(
+  //       `<script setup>
+  //       import { ref } from 'vue'
+  //       const count = ref(0)
+  //       const maybe = foo()
+  //       let lett = 1
+  //       let v = ref(1)
+  //       </script>
+  //       <template>
+  //         <div @click="count = 1"/>
+  //         <div @click="maybe = count"/>
+  //         <div @click="lett = count"/>
+  //         <div @click="v += 1"/>
+  //         <div @click="v -= 1"/>
+  //         <div @click="() => {
+  //             let a = '' + lett
+  //             v = a
+  //          }"/>
+  //          <div @click="() => {
+  //             // nested scopes
+  //             (()=>{
+  //               let x = a
+  //               (()=>{
+  //                 let z = x
+  //                 let z2 = z
+  //               })
+  //               let lz = z
+  //             })
+  //             v = a
+  //          }"/>
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     // known const ref: set value
+  //     expect(content).toMatch(`count.value = 1`)
+  //     // const but maybe ref: only assign after check
+  //     expect(content).toMatch(`maybe.value = count.value`)
+  //     // let: handle both cases
+  //     expect(content).toMatch(
+  //       `_isRef(lett) ? lett.value = count.value : lett = count.value`
+  //     )
+  //     expect(content).toMatch(`_isRef(v) ? v.value += 1 : v += 1`)
+  //     expect(content).toMatch(`_isRef(v) ? v.value -= 1 : v -= 1`)
+  //     expect(content).toMatch(`_isRef(v) ? v.value = a : v = a`)
+  //     expect(content).toMatch(`_isRef(v) ? v.value = _ctx.a : v = _ctx.a`)
+  //     assertCode(content)
+  //   })
+
+  //   test('template update expression codegen', () => {
+  //     const { content } = compile(
+  //       `<script setup>
+  //       import { ref } from 'vue'
+  //       const count = ref(0)
+  //       const maybe = foo()
+  //       let lett = 1
+  //       </script>
+  //       <template>
+  //         <div @click="count++"/>
+  //         <div @click="--count"/>
+  //         <div @click="maybe++"/>
+  //         <div @click="--maybe"/>
+  //         <div @click="lett++"/>
+  //         <div @click="--lett"/>
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     // known const ref: set value
+  //     expect(content).toMatch(`count.value++`)
+  //     expect(content).toMatch(`--count.value`)
+  //     // const but maybe ref (non-ref case ignored)
+  //     expect(content).toMatch(`maybe.value++`)
+  //     expect(content).toMatch(`--maybe.value`)
+  //     // let: handle both cases
+  //     expect(content).toMatch(`_isRef(lett) ? lett.value++ : lett++`)
+  //     expect(content).toMatch(`_isRef(lett) ? --lett.value : --lett`)
+  //     assertCode(content)
+  //   })
+
+  //   test('template destructure assignment codegen', () => {
+  //     const { content } = compile(
+  //       `<script setup>
+  //       import { ref } from 'vue'
+  //       const val = {}
+  //       const count = ref(0)
+  //       const maybe = foo()
+  //       let lett = 1
+  //       </script>
+  //       <template>
+  //         <div @click="({ count } = val)"/>
+  //         <div @click="[maybe] = val"/>
+  //         <div @click="({ lett } = val)"/>
+  //       </template>
+  //       `,
+  //       { inlineTemplate: true }
+  //     )
+  //     // known const ref: set value
+  //     expect(content).toMatch(`({ count: count.value } = val)`)
+  //     // const but maybe ref (non-ref case ignored)
+  //     expect(content).toMatch(`[maybe.value] = val`)
+  //     // let: assumes non-ref
+  //     expect(content).toMatch(`{ lett: lett } = val`)
+  //     assertCode(content)
+  //   })
+
+  //   test('ssr codegen', () => {
+  //     const { content } = compile(
+  //       `
+  //       <script setup>
+  //       import { ref } from 'vue'
+  //       const count = ref(0)
+  //       </script>
+  //       <template>
+  //         <div>{{ count }}</div>
+  //         <div>static</div>
+  //       </template>
+  //       <style>
+  //       div { color: v-bind(count) }
+  //       </style>
+  //       `,
+  //       {
+  //         inlineTemplate: true,
+  //         templateOptions: {
+  //           ssr: true
+  //         }
+  //       }
+  //     )
+  //     expect(content).toMatch(`\n  __ssrInlineRender: true,\n`)
+  //     expect(content).toMatch(`return (_ctx, _push`)
+  //     expect(content).toMatch(`ssrInterpolate`)
+  //     expect(content).not.toMatch(`useCssVars`)
+  //     expect(content).toMatch(`"--${mockId}-count": (count.value)`)
+  //     assertCode(content)
+  //   })
+  // })
+
+  describe('with TypeScript', () => {
+    test('hoist type declarations', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+        export interface Foo {}
+        type Bar = {}
+      </script>`)
+      assertCode(content)
+    })
+
+    test('defineProps/Emit w/ runtime options', () => {
+      const { content } = compile(`
+<script setup lang="ts">
+const props = defineProps({ foo: String })
+const emit = defineEmits(['a', 'b'])
+</script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`export default /*#__PURE__*/_defineComponent({
+  props: { foo: String },
+  emits: ['a', 'b'],
+  setup(__props, { expose, emit }) {`)
+    })
+
+    test('defineProps w/ type', () => {
+      const { content, bindings } = compile(`
+      <script setup lang="ts">
+      interface Test {}
+
+      type Alias = number[]
+
+      defineProps<{
+        string: string
+        number: number
+        boolean: boolean
+        object: object
+        objectLiteral: { a: number }
+        fn: (n: number) => void
+        functionRef: Function
+        objectRef: Object
+        dateTime: Date
+        array: string[]
+        arrayRef: Array<any>
+        tuple: [number, number]
+        set: Set<string>
+        literal: 'foo'
+        optional?: any
+        recordRef: Record<string, null>
+        interface: Test
+        alias: Alias
+        method(): void
+        symbol: symbol
+
+        union: string | number
+        literalUnion: 'foo' | 'bar'
+        literalUnionNumber: 1 | 2 | 3 | 4 | 5
+        literalUnionMixed: 'foo' | 1 | boolean
+        intersection: Test & {}
+        foo: ((item: any) => boolean) | null
+      }>()
+      </script>`)
+      assertCode(content)
+      expect(content).toMatch(`string: { type: String, required: true }`)
+      expect(content).toMatch(`number: { type: Number, required: true }`)
+      expect(content).toMatch(`boolean: { type: Boolean, required: true }`)
+      expect(content).toMatch(`object: { type: Object, required: true }`)
+      expect(content).toMatch(`objectLiteral: { type: Object, required: true }`)
+      expect(content).toMatch(`fn: { type: Function, required: true }`)
+      expect(content).toMatch(`functionRef: { type: Function, required: true }`)
+      expect(content).toMatch(`objectRef: { type: Object, required: true }`)
+      expect(content).toMatch(`dateTime: { type: Date, required: true }`)
+      expect(content).toMatch(`array: { type: Array, required: true }`)
+      expect(content).toMatch(`arrayRef: { type: Array, required: true }`)
+      expect(content).toMatch(`tuple: { type: Array, required: true }`)
+      expect(content).toMatch(`set: { type: Set, required: true }`)
+      expect(content).toMatch(`literal: { type: String, required: true }`)
+      expect(content).toMatch(`optional: { type: null, required: false }`)
+      expect(content).toMatch(`recordRef: { type: Object, required: true }`)
+      expect(content).toMatch(`interface: { type: Object, required: true }`)
+      expect(content).toMatch(`alias: { type: Array, required: true }`)
+      expect(content).toMatch(`method: { type: Function, required: true }`)
+      expect(content).toMatch(`symbol: { type: Symbol, required: true }`)
+      expect(content).toMatch(
+        `union: { type: [String, Number], required: true }`
+      )
+      expect(content).toMatch(`literalUnion: { type: String, required: true }`)
+      expect(content).toMatch(
+        `literalUnionNumber: { type: Number, required: true }`
+      )
+      expect(content).toMatch(
+        `literalUnionMixed: { type: [String, Number, Boolean], required: true }`
+      )
+      expect(content).toMatch(`intersection: { type: Object, required: true }`)
+      expect(content).toMatch(`foo: { type: [Function, null], required: true }`)
+      expect(bindings).toStrictEqual({
+        string: BindingTypes.PROPS,
+        number: BindingTypes.PROPS,
+        boolean: BindingTypes.PROPS,
+        object: BindingTypes.PROPS,
+        objectLiteral: BindingTypes.PROPS,
+        fn: BindingTypes.PROPS,
+        functionRef: BindingTypes.PROPS,
+        objectRef: BindingTypes.PROPS,
+        dateTime: BindingTypes.PROPS,
+        array: BindingTypes.PROPS,
+        arrayRef: BindingTypes.PROPS,
+        tuple: BindingTypes.PROPS,
+        set: BindingTypes.PROPS,
+        literal: BindingTypes.PROPS,
+        optional: BindingTypes.PROPS,
+        recordRef: BindingTypes.PROPS,
+        interface: BindingTypes.PROPS,
+        alias: BindingTypes.PROPS,
+        method: BindingTypes.PROPS,
+        symbol: BindingTypes.PROPS,
+        union: BindingTypes.PROPS,
+        literalUnion: BindingTypes.PROPS,
+        literalUnionNumber: BindingTypes.PROPS,
+        literalUnionMixed: BindingTypes.PROPS,
+        intersection: BindingTypes.PROPS,
+        foo: BindingTypes.PROPS
+      })
+    })
+
+    test('defineProps w/ interface', () => {
+      const { content, bindings } = compile(`
+      <script setup lang="ts">
+      interface Props { x?: number }
+      defineProps<Props>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`x: { type: Number, required: false }`)
+      expect(bindings).toStrictEqual({
+        x: BindingTypes.PROPS
+      })
+    })
+
+    test('defineProps w/ exported interface', () => {
+      const { content, bindings } = compile(`
+      <script setup lang="ts">
+      export interface Props { x?: number }
+      defineProps<Props>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`x: { type: Number, required: false }`)
+      expect(bindings).toStrictEqual({
+        x: BindingTypes.PROPS
+      })
+    })
+
+    test('defineProps w/ exported interface in normal script', () => {
+      const { content, bindings } = compile(`
+      <script lang="ts">
+        export interface Props { x?: number }
+      </script>
+      <script setup lang="ts">
+        defineProps<Props>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`x: { type: Number, required: false }`)
+      expect(bindings).toStrictEqual({
+        x: BindingTypes.PROPS
+      })
+    })
+
+    test('defineProps w/ type alias', () => {
+      const { content, bindings } = compile(`
+      <script setup lang="ts">
+      type Props = { x?: number }
+      defineProps<Props>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`x: { type: Number, required: false }`)
+      expect(bindings).toStrictEqual({
+        x: BindingTypes.PROPS
+      })
+    })
+
+    test('defineProps w/ exported type alias', () => {
+      const { content, bindings } = compile(`
+      <script setup lang="ts">
+      export type Props = { x?: number }
+      defineProps<Props>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`x: { type: Number, required: false }`)
+      expect(bindings).toStrictEqual({
+        x: BindingTypes.PROPS
+      })
+    })
+
+    test('withDefaults (static)', () => {
+      const { content, bindings } = compile(`
+      <script setup lang="ts">
+      const props = withDefaults(defineProps<{
+        foo?: string
+        bar?: number;
+        baz: boolean;
+        qux?(): number
+      }>(), {
+        foo: 'hi',
+        qux() { return 1 }
+      })
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(
+        `foo: { type: String, required: false, default: 'hi' }`
+      )
+      expect(content).toMatch(`bar: { type: Number, required: false }`)
+      expect(content).toMatch(`baz: { type: Boolean, required: true }`)
+      expect(content).toMatch(
+        `qux: { type: Function, required: false, default() { return 1 } }`
+      )
+      expect(content).toMatch(
+        `{ foo: string, bar?: number, baz: boolean, qux(): number }`
+      )
+      expect(content).toMatch(`const props = __props`)
+      expect(bindings).toStrictEqual({
+        foo: BindingTypes.PROPS,
+        bar: BindingTypes.PROPS,
+        baz: BindingTypes.PROPS,
+        qux: BindingTypes.PROPS,
+        props: BindingTypes.SETUP_CONST
+      })
+    })
+
+    test('withDefaults (dynamic)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      import { defaults } from './foo'
+      const props = withDefaults(defineProps<{
+        foo?: string
+        bar?: number
+        baz: boolean
+      }>(), { ...defaults })
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`import { mergeDefaults as _mergeDefaults`)
+      expect(content).toMatch(
+        `
+  _mergeDefaults({
+    foo: { type: String, required: false },
+    bar: { type: Number, required: false },
+    baz: { type: Boolean, required: true }
+  }, { ...defaults })`.trim()
+      )
+    })
+
+    test('defineEmits w/ type', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      const emit = defineEmits<(e: 'foo' | 'bar') => void>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ((e: 'foo' | 'bar') => void),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('defineEmits w/ type (union)', () => {
+      const type = `((e: 'foo' | 'bar') => void) | ((e: 'baz', id: number) => void)`
+      expect(() =>
+        compile(`
+      <script setup lang="ts">
+      const emit = defineEmits<${type}>()
+      </script>
+      `)
+      ).toThrow()
+    })
+
+    test('defineEmits w/ type (type literal w/ call signatures)', () => {
+      const type = `{(e: 'foo' | 'bar'): void; (e: 'baz', id: number): void;}`
+      const { content } = compile(`
+      <script setup lang="ts">
+      const emit = defineEmits<${type}>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: (${type}),`)
+      expect(content).toMatch(`emits: ["foo", "bar", "baz"]`)
+    })
+
+    test('defineEmits w/ type (interface)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      interface Emits { (e: 'foo' | 'bar'): void }
+      const emit = defineEmits<Emits>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ({ (e: 'foo' | 'bar'): void }),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('defineEmits w/ type (exported interface)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      export interface Emits { (e: 'foo' | 'bar'): void }
+      const emit = defineEmits<Emits>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ({ (e: 'foo' | 'bar'): void }),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('defineEmits w/ type (type alias)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      type Emits = { (e: 'foo' | 'bar'): void }
+      const emit = defineEmits<Emits>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ({ (e: 'foo' | 'bar'): void }),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('defineEmits w/ type (exported type alias)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      export type Emits = { (e: 'foo' | 'bar'): void }
+      const emit = defineEmits<Emits>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ({ (e: 'foo' | 'bar'): void }),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('defineEmits w/ type (referenced function type)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      type Emits = (e: 'foo' | 'bar') => void
+      const emit = defineEmits<Emits>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ((e: 'foo' | 'bar') => void),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('defineEmits w/ type (referenced exported function type)', () => {
+      const { content } = compile(`
+      <script setup lang="ts">
+      export type Emits = (e: 'foo' | 'bar') => void
+      const emit = defineEmits<Emits>()
+      </script>
+      `)
+      assertCode(content)
+      expect(content).toMatch(`emit: ((e: 'foo' | 'bar') => void),`)
+      expect(content).toMatch(`emits: ["foo", "bar"]`)
+    })
+
+    test('runtime Enum', () => {
+      const { content, bindings } = compile(
+        `<script setup lang="ts">
+        enum Foo { A = 123 }
+        </script>`
+      )
+      assertCode(content)
+      expect(bindings).toStrictEqual({
+        Foo: BindingTypes.SETUP_CONST
+      })
+    })
+
+    test('runtime Enum in normal script', () => {
+      const { content, bindings } = compile(
+        `<script lang="ts">
+          export enum D { D = "D" }
+          const enum C { C = "C" }
+          enum B { B = "B" }
+        </script>
+        <script setup lang="ts">
+        enum Foo { A = 123 }
+        </script>`
+      )
+      assertCode(content)
+      expect(bindings).toStrictEqual({
+        D: BindingTypes.SETUP_CONST,
+        C: BindingTypes.SETUP_CONST,
+        B: BindingTypes.SETUP_CONST,
+        Foo: BindingTypes.SETUP_CONST
+      })
+    })
+
+    test('const Enum', () => {
+      const { content, bindings } = compile(
+        `<script setup lang="ts">
+        const enum Foo { A = 123 }
+        </script>`
+      )
+      assertCode(content)
+      expect(bindings).toStrictEqual({
+        Foo: BindingTypes.SETUP_CONST
+      })
+    })
+
+    test('import type', () => {
+      const { content } = compile(
+        `<script setup lang="ts">
+        import type { Foo } from './main.ts'
+        import { type Bar, Baz } from './main.ts'
+        </script>`
+      )
+      expect(content).toMatch(`return { Baz }`)
+      assertCode(content)
+    })
+  })
+
+  describe('async/await detection', () => {
+    function assertAwaitDetection(code: string, shouldAsync = true) {
+      const { content } = compile(`<script setup>${code}</script>`)
+      if (shouldAsync) {
+        expect(content).toMatch(`let __temp, __restore`)
+      }
+      expect(content).toMatch(`${shouldAsync ? `async ` : ``}setup(`)
+      assertCode(content)
+      return content
+    }
+
+    test('expression statement', () => {
+      assertAwaitDetection(`await foo`)
+    })
+
+    test('variable', () => {
+      assertAwaitDetection(`const a = 1 + (await foo)`)
+    })
+
+    test('ref', () => {
+      assertAwaitDetection(`let a = $ref(1 + (await foo))`)
+    })
+
+    // #4448
+    test('nested await', () => {
+      assertAwaitDetection(`await (await foo)`)
+      assertAwaitDetection(`await ((await foo))`)
+      assertAwaitDetection(`await (await (await foo))`)
+    })
+
+    // should prepend semicolon
+    test('nested leading await in expression statement', () => {
+      const code = assertAwaitDetection(`foo()\nawait 1 + await 2`)
+      expect(code).toMatch(`foo()\n;(`)
+    })
+
+    // #4596 should NOT prepend semicolon
+    test('single line conditions', () => {
+      const code = assertAwaitDetection(`if (false) await foo()`)
+      expect(code).not.toMatch(`if (false) ;(`)
+    })
+
+    test('nested statements', () => {
+      assertAwaitDetection(`if (ok) { await foo } else { await bar }`)
+    })
+
+    test('multiple `if` nested statements', () => {
+      assertAwaitDetection(`if (ok) {
+        let a = 'foo'
+        await 0 + await 1
+        await 2
+      } else if (a) {
+        await 10
+        if (b) {
+          await 0 + await 1
+        } else {
+          let a = 'foo'
+          await 2
+        }
+        if (b) {
+          await 3
+          await 4
+        }
+      } else {
+        await 5
+      }`)
+    })
+
+    test('multiple `if while` nested statements', () => {
+      assertAwaitDetection(`if (ok) {
+        while (d) {
+          await 5
+        }
+        while (d) {
+          await 5
+          await 6
+          if (c) {
+            let f = 10
+            10 + await 7
+          } else {
+            await 8
+            await 9
+          }
+        }
+      }`)
+    })
+
+    test('multiple `if for` nested statements', () => {
+      assertAwaitDetection(`if (ok) {
+        for (let a of [1,2,3]) {
+          await a
+        }
+        for (let a of [1,2,3]) {
+          await a
+          await a
+        }
+      }`)
+    })
+
+    test('should ignore await inside functions', () => {
+      // function declaration
+      assertAwaitDetection(`async function foo() { await bar }`, false)
+      // function expression
+      assertAwaitDetection(`const foo = async () => { await bar }`, false)
+      // object method
+      assertAwaitDetection(`const obj = { async method() { await bar }}`, false)
+      // class method
+      assertAwaitDetection(
+        `const cls = class Foo { async method() { await bar }}`,
+        false
+      )
+    })
+  })
+
+  describe('errors', () => {
+    test('<script> and <script setup> must have same lang', () => {
+      expect(() =>
+        compile(`<script>foo()</script><script setup lang="ts">bar()</script>`)
+      ).toThrow(`<script> and <script setup> must have the same language type`)
+    })
+
+    const moduleErrorMsg = `cannot contain ES module exports`
+
+    test('non-type named exports', () => {
+      expect(() =>
+        compile(`<script setup>
+        export const a = 1
+        </script>`)
+      ).toThrow(moduleErrorMsg)
+
+      expect(() =>
+        compile(`<script setup>
+        export * from './foo'
+        </script>`)
+      ).toThrow(moduleErrorMsg)
+
+      expect(() =>
+        compile(`<script setup>
+          const bar = 1
+          export { bar as default }
+        </script>`)
+      ).toThrow(moduleErrorMsg)
+    })
+
+    test('defineProps/Emit() w/ both type and non-type args', () => {
+      expect(() => {
+        compile(`<script setup lang="ts">
+        defineProps<{}>({})
+        </script>`)
+      }).toThrow(`cannot accept both type and non-type arguments`)
+
+      expect(() => {
+        compile(`<script setup lang="ts">
+        defineEmits<{}>({})
+        </script>`)
+      }).toThrow(`cannot accept both type and non-type arguments`)
+    })
+
+    test('defineProps/Emit() referencing local var', () => {
+      expect(() =>
+        compile(`<script setup>
+        const bar = 1
+        defineProps({
+          foo: {
+            default: () => bar
+          }
+        })
+        </script>`)
+      ).toThrow(`cannot reference locally declared variables`)
+
+      expect(() =>
+        compile(`<script setup>
+        const bar = 'hello'
+        defineEmits([bar])
+        </script>`)
+      ).toThrow(`cannot reference locally declared variables`)
+
+      // #4644
+      expect(() =>
+        compile(`
+        <script>const bar = 1</script>
+        <script setup>
+        defineProps({
+          foo: {
+            default: () => bar
+          }
+        })
+        </script>`)
+      ).not.toThrow(`cannot reference locally declared variables`)
+    })
+
+    test('should allow defineProps/Emit() referencing scope var', () => {
+      assertCode(
+        compile(`<script setup>
+          const bar = 1
+          defineProps({
+            foo: {
+              default: bar => bar + 1
+            }
+          })
+          defineEmits({
+            foo: bar => bar > 1
+          })
+        </script>`).content
+      )
+    })
+
+    test('should allow defineProps/Emit() referencing imported binding', () => {
+      assertCode(
+        compile(`<script setup>
+        import { bar } from './bar'
+        defineProps({
+          foo: {
+            default: () => bar
+          }
+        })
+        defineEmits({
+          foo: () => bar > 1
+        })
+        </script>`).content
+      )
+    })
+  })
+})
+
+describe('SFC analyze <script> bindings', () => {
+  it('can parse decorators syntax in typescript block', () => {
+    const { scriptAst } = compile(`
+      <script lang="ts">
+        import { Options, Vue } from 'vue-class-component';
+        @Options({
+          components: {
+            HelloWorld,
+          },
+          props: ['foo', 'bar']
+        })
+        export default class Home extends Vue {}
+      </script>
+    `)
+
+    expect(scriptAst).toBeDefined()
+  })
+
+  it('recognizes props array declaration', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          props: ['foo', 'bar']
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.PROPS,
+      bar: BindingTypes.PROPS
+    })
+    expect(bindings!.__isScriptSetup).toBe(false)
+  })
+
+  it('recognizes props object declaration', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          props: {
+            foo: String,
+            bar: {
+              type: String,
+            },
+            baz: null,
+            qux: [String, Number]
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.PROPS,
+      bar: BindingTypes.PROPS,
+      baz: BindingTypes.PROPS,
+      qux: BindingTypes.PROPS
+    })
+    expect(bindings!.__isScriptSetup).toBe(false)
+  })
+
+  it('recognizes setup return', () => {
+    const { bindings } = compile(`
+      <script>
+        const bar = 2
+        export default {
+          setup() {
+            return {
+              foo: 1,
+              bar
+            }
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.SETUP_MAYBE_REF,
+      bar: BindingTypes.SETUP_MAYBE_REF
+    })
+    expect(bindings!.__isScriptSetup).toBe(false)
+  })
+
+  it('recognizes exported vars', () => {
+    const { bindings } = compile(`
+      <script>
+        export const foo = 2
+      </script>
+      <script setup>
+        console.log(foo)
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.SETUP_CONST
+    })
+  })
+
+  it('recognizes async setup return', () => {
+    const { bindings } = compile(`
+      <script>
+        const bar = 2
+        export default {
+          async setup() {
+            return {
+              foo: 1,
+              bar
+            }
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.SETUP_MAYBE_REF,
+      bar: BindingTypes.SETUP_MAYBE_REF
+    })
+    expect(bindings!.__isScriptSetup).toBe(false)
+  })
+
+  it('recognizes data return', () => {
+    const { bindings } = compile(`
+      <script>
+        const bar = 2
+        export default {
+          data() {
+            return {
+              foo: null,
+              bar
+            }
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.DATA,
+      bar: BindingTypes.DATA
+    })
+  })
+
+  it('recognizes methods', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          methods: {
+            foo() {}
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({ foo: BindingTypes.OPTIONS })
+  })
+
+  it('recognizes computeds', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          computed: {
+            foo() {},
+            bar: {
+              get() {},
+              set() {},
+            }
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.OPTIONS,
+      bar: BindingTypes.OPTIONS
+    })
+  })
+
+  it('recognizes injections array declaration', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          inject: ['foo', 'bar']
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.OPTIONS,
+      bar: BindingTypes.OPTIONS
+    })
+  })
+
+  it('recognizes injections object declaration', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          inject: {
+            foo: {},
+            bar: {},
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.OPTIONS,
+      bar: BindingTypes.OPTIONS
+    })
+  })
+
+  it('works for mixed bindings', () => {
+    const { bindings } = compile(`
+      <script>
+        export default {
+          inject: ['foo'],
+          props: {
+            bar: String,
+          },
+          setup() {
+            return {
+              baz: null,
+            }
+          },
+          data() {
+            return {
+              qux: null
+            }
+          },
+          methods: {
+            quux() {}
+          },
+          computed: {
+            quuz() {}
+          }
+        }
+      </script>
+    `)
+    expect(bindings).toStrictEqual({
+      foo: BindingTypes.OPTIONS,
+      bar: BindingTypes.PROPS,
+      baz: BindingTypes.SETUP_MAYBE_REF,
+      qux: BindingTypes.DATA,
+      quux: BindingTypes.OPTIONS,
+      quuz: BindingTypes.OPTIONS
+    })
+  })
+
+  it('works for script setup', () => {
+    const { bindings } = compile(`
+      <script setup>
+      import { ref as r } from 'vue'
+      defineProps({
+        foo: String
+      })
+
+      const a = r(1)
+      let b = 2
+      const c = 3
+      const { d } = someFoo()
+      let { e } = someBar()
+      </script>
+    `)
+
+    expect(bindings).toStrictEqual({
+      r: BindingTypes.SETUP_CONST,
+      a: BindingTypes.SETUP_REF,
+      b: BindingTypes.SETUP_LET,
+      c: BindingTypes.SETUP_CONST,
+      d: BindingTypes.SETUP_MAYBE_REF,
+      e: BindingTypes.SETUP_LET,
+      foo: BindingTypes.PROPS
+    })
+  })
+
+  describe('auto name inference', () => {
+    test('basic', () => {
+      const { content } = compile(
+        `<script setup>const a = 1</script>
+        <template>{{ a }}</template>`,
+        undefined,
+        {
+          filename: 'FooBar.vue'
+        }
+      )
+      expect(content).toMatch(`export default {
+  __name: 'FooBar'`)
+      assertCode(content)
+    })
+
+    test('do not overwrite manual name (object)', () => {
+      const { content } = compile(
+        `<script>
+        export default {
+          name: 'Baz'
+        }
+        </script>
+        <script setup>const a = 1</script>
+        <template>{{ a }}</template>`,
+        undefined,
+        {
+          filename: 'FooBar.vue'
+        }
+      )
+      expect(content).not.toMatch(`name: 'FooBar'`)
+      expect(content).toMatch(`name: 'Baz'`)
+      assertCode(content)
+    })
+
+    test('do not overwrite manual name (call)', () => {
+      const { content } = compile(
+        `<script>
+        import { defineComponent } from 'vue'
+        export default defineComponent({
+          name: 'Baz'
+        })
+        </script>
+        <script setup>const a = 1</script>
+        <template>{{ a }}</template>`,
+        undefined,
+        {
+          filename: 'FooBar.vue'
+        }
+      )
+      expect(content).not.toMatch(`name: 'FooBar'`)
+      expect(content).toMatch(`name: 'Baz'`)
+      assertCode(content)
+    })
+  })
+})
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 565a47fed6c..69d42094526 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -36,7 +36,6 @@ export class CodegenState {
   constructor(options: CompilerOptions) {
     this.options = options
     this.warn = options.warn || baseWarn
-    //@ts-expect-error `this.transforms ` is a different type than `options.modules.transformCode`
     this.transforms = pluckModuleFunction(options.modules, 'transformCode')
     this.dataGenFns = pluckModuleFunction(options.modules, 'genData')
     this.directives = extend(extend({}, baseDirectives), options.directives)
diff --git a/src/compiler/helpers.ts b/src/compiler/helpers.ts
index 7702de4173d..f07b28f35c8 100644
--- a/src/compiler/helpers.ts
+++ b/src/compiler/helpers.ts
@@ -13,8 +13,8 @@ export function baseWarn(msg: string, range?: Range) {
 export function pluckModuleFunction<T, K extends keyof T>(
   modules: Array<T> | undefined,
   key: K
-): Array<T[K]> {
-  return modules ? modules.map(m => m[key]).filter(_ => _) : []
+): Array<Exclude<T[K], undefined>> {
+  return modules ? (modules.map(m => m[key]).filter(_ => _) as any) : []
 }
 
 export function addProp(

From 53a5ac96387b57f50bd6587e77b371827a30ee4d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 15:35:30 +0800
Subject: [PATCH 140/317] chore: fix tests

---
 package.json                                  |  3 +-
 packages/compiler-sfc/src/parseComponent.ts   |  4 +-
 .../compiler-sfc/test/parseComponent.spec.ts  | 41 ++++++++++++++-----
 pnpm-lock.yaml                                |  2 +
 4 files changed, 37 insertions(+), 13 deletions(-)

diff --git a/package.json b/package.json
index 690c92ceb2e..73e0a4a6d5e 100644
--- a/package.json
+++ b/package.json
@@ -87,6 +87,7 @@
     "csstype": "^3.1.0"
   },
   "devDependencies": {
+    "@babel/parser": "^7.18.4",
     "@microsoft/api-extractor": "^7.25.0",
     "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-commonjs": "^22.0.0",
@@ -109,10 +110,10 @@
     "karma-esbuild": "^2.2.4",
     "karma-jasmine": "^5.0.1",
     "lint-staged": "^12.5.0",
-    "postcss": "^8.4.14",
     "lodash": "^4.17.21",
     "marked": "^4.0.16",
     "minimist": "^1.2.6",
+    "postcss": "^8.4.14",
     "prettier": "^2.6.2",
     "puppeteer": "^14.3.0",
     "rimraf": "^3.0.2",
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 7c6e688d168..a4194ce8f84 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -56,8 +56,8 @@ export interface SFCDescriptor {
    * a reload vs. re-render.
    *
    * Note: this comparison assumes the prev/next script are already identical,
-   * and only checks the special case where <script setup lang="ts"> unused import
-   * pruning result changes due to template changes.
+   * and only checks the special case where `<script setup lang="ts">` unused
+   * import pruning result changes due to template changes.
    */
   shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean
 }
diff --git a/packages/compiler-sfc/test/parseComponent.spec.ts b/packages/compiler-sfc/test/parseComponent.spec.ts
index b2ee8d633b2..206e55677e4 100644
--- a/packages/compiler-sfc/test/parseComponent.spec.ts
+++ b/packages/compiler-sfc/test/parseComponent.spec.ts
@@ -3,7 +3,8 @@ import { parseComponent } from '../src/parseComponent'
 
 describe('Single File Component parser', () => {
   it('should parse', () => {
-    const res = parseComponent(`
+    const res = parseComponent(
+      `
       <template>
         <div>hi</div>
       </template>
@@ -24,7 +25,9 @@ describe('Single File Component parser', () => {
       <div>
         <style>nested should be ignored</style>
       </div>
-    `)
+    `,
+      { deindent: true }
+    )
     expect(res.template!.content.trim()).toBe('<div>hi</div>')
     expect(res.styles.length).toBe(4)
     expect(res.styles[0].src).toBe('./test.css')
@@ -72,7 +75,10 @@ describe('Single File Component parser', () => {
         h1 { color: red }
       </style>
     `
-    const deindentDefault = parseComponent(content.trim(), { pad: false })
+    const deindentDefault = parseComponent(content.trim(), {
+      pad: false,
+      deindent: true
+    })
     const deindentEnabled = parseComponent(content.trim(), {
       pad: false,
       deindent: true
@@ -111,9 +117,18 @@ describe('Single File Component parser', () => {
         h1 { color: red }
       </style>
 `
-    const padDefault = parseComponent(content.trim(), { pad: true })
-    const padLine = parseComponent(content.trim(), { pad: 'line' })
-    const padSpace = parseComponent(content.trim(), { pad: 'space' })
+    const padDefault = parseComponent(content.trim(), {
+      pad: true,
+      deindent: true
+    })
+    const padLine = parseComponent(content.trim(), {
+      pad: 'line',
+      deindent: true
+    })
+    const padSpace = parseComponent(content.trim(), {
+      pad: 'space',
+      deindent: true
+    })
 
     expect(padDefault.script!.content).toBe(
       Array(3 + 1).join('//\n') + '\nexport default {}\n'
@@ -145,12 +160,15 @@ describe('Single File Component parser', () => {
   })
 
   it('should handle template blocks with lang as special text', () => {
-    const res = parseComponent(`
+    const res = parseComponent(
+      `
       <template lang="pug">
         div
           h1(v-if='1 < 2') hello
       </template>
-    `)
+    `,
+      { deindent: true }
+    )
     expect(res.template!.content.trim()).toBe(`div\n  h1(v-if='1 < 2') hello`)
   })
 
@@ -164,7 +182,8 @@ describe('Single File Component parser', () => {
   })
 
   it('should handle custom blocks without parsing them', () => {
-    const res = parseComponent(`
+    const res = parseComponent(
+      `
       <template>
         <div></div>
       </template>
@@ -183,7 +202,9 @@ describe('Single File Component parser', () => {
         }))
       }
       </test>
-    `)
+    `,
+      { deindent: true }
+    )
     expect(res.customBlocks.length).toBe(3)
 
     const simpleExample = res.customBlocks[0]
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5ad8d78f393..4041a8b1a18 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -4,6 +4,7 @@ importers:
 
   .:
     specifiers:
+      '@babel/parser': ^7.18.4
       '@microsoft/api-extractor': ^7.25.0
       '@rollup/plugin-alias': ^3.1.9
       '@rollup/plugin-commonjs': ^22.0.0
@@ -50,6 +51,7 @@ importers:
       '@vue/compiler-sfc': link:packages/compiler-sfc
       csstype: 3.1.0
     devDependencies:
+      '@babel/parser': 7.18.4
       '@microsoft/api-extractor': 7.25.0
       '@rollup/plugin-alias': 3.1.9_rollup@2.75.6
       '@rollup/plugin-commonjs': 22.0.0_rollup@2.75.6

From 2bb3659c05aaec156e98be511a1891372efada64 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 21:48:06 +0800
Subject: [PATCH 141/317] wip: expose compileScript

---
 packages/compiler-sfc/src/compileScript.ts       | 4 ++--
 packages/compiler-sfc/src/index.ts               | 2 ++
 packages/compiler-sfc/test/compileScript.spec.ts | 4 ++--
 src/v3/apiSetup.ts                               | 5 ++++-
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 489077739d1..e2589dc5f8b 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -57,7 +57,7 @@ const isBuiltInDir = makeMap(
   `once,memo,if,for,else,else-if,slot,text,html,on,bind,model,show,cloak,is`
 )
 
-export interface SFCScriptCompileOptions {
+export interface ScriptCompileOptions {
   /**
    * Production mode. Used to determine whether to generate hashed CSS variables
    */
@@ -87,7 +87,7 @@ export interface ImportBinding {
  */
 export function compileScript(
   sfc: SFCDescriptor,
-  options: SFCScriptCompileOptions = {}
+  options: ScriptCompileOptions = {}
 ): SFCScriptBlock {
   let { filename, script, scriptSetup, source } = sfc
   const isProd = !!options.isProd
diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index b8dee97641c..d13484303c5 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -2,6 +2,7 @@
 export { parse } from './parse'
 export { compileTemplate } from './compileTemplate'
 export { compileStyle, compileStyleAsync } from './compileStyle'
+export { compileScript } from './compileScript'
 
 // types
 export { SFCBlock, SFCCustomBlock, SFCDescriptor } from './parseComponent'
@@ -10,3 +11,4 @@ export {
   TemplateCompileResult
 } from './compileTemplate'
 export { StyleCompileOptions, StyleCompileResults } from './compileStyle'
+export { ScriptCompileOptions } from './compileScript'
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index 54afae2e670..8365756da84 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -1,11 +1,11 @@
 import { BindingTypes } from '../src/types'
 import { parse, ParseOptions } from '../src/parse'
 import { parse as babelParse } from '@babel/parser'
-import { compileScript, SFCScriptCompileOptions } from '../src/compileScript'
+import { compileScript, ScriptCompileOptions } from '../src/compileScript'
 
 function compile(
   source: string,
-  options?: Partial<SFCScriptCompileOptions>,
+  options?: Partial<ScriptCompileOptions>,
   parseOptions?: Partial<ParseOptions>
 ) {
   const sfc = parse({
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index 619987fde45..29ef7e48f19 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -83,7 +83,10 @@ function createSetupContext(vm: Component) {
     get slots() {
       return initSlotsProxy(vm)
     },
-    emit: bind(vm.$emit, vm) as any
+    emit: bind(vm.$emit, vm) as any,
+    expose() {
+      // TODO
+    }
   }
 }
 

From 4cb2b7bd33392933b8d8f767c75add4ef30446b0 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 22:17:10 +0800
Subject: [PATCH 142/317] wip: expose generateCodeFrame in compiler-sfc

---
 packages/compiler-sfc/src/index.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index d13484303c5..57f1af07152 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -3,6 +3,7 @@ export { parse } from './parse'
 export { compileTemplate } from './compileTemplate'
 export { compileStyle, compileStyleAsync } from './compileStyle'
 export { compileScript } from './compileScript'
+export { generateCodeFrame } from 'compiler/codeframe'
 
 // types
 export { SFCBlock, SFCCustomBlock, SFCDescriptor } from './parseComponent'

From 2ddd25926eb3abb2f70fad3e4d81348f63e15e74 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 23:28:58 +0800
Subject: [PATCH 143/317] release: v2.7.0-alpha.7

---
 CHANGELOG.md                            | 4 ++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 37fcb4fc152..17f306aa0c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# [2.7.0-alpha.7](https://github.com/vuejs/vue/compare/v2.7.0-alpha.6...v2.7.0-alpha.7) (2022-06-14)
+
+
+
 # [2.7.0-alpha.6](https://github.com/vuejs/vue/compare/v2.7.0-alpha.5...v2.7.0-alpha.6) (2022-06-09)
 
 ### Features
diff --git a/package.json b/package.json
index 73e0a4a6d5e..15a163828a4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.6",
+  "version": "2.7.0-alpha.7",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 802bba8d19e..a8540eb0427 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.6",
+  "version": "2.7.0-alpha.7",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 59370cfe2dd..4e20798fc27 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.6",
+  "version": "2.7.0-alpha.7",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 0e4d434c706..32cb3a444aa 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.6",
+  "version": "2.7.0-alpha.7",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From cda5176e95de3e550803cba57292de69df2dfe2e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 23:43:57 +0800
Subject: [PATCH 144/317] build: fix compiler build

---
 packages/compiler-sfc/src/compileScript.ts  | 2 +-
 packages/compiler-sfc/src/parse.ts          | 8 +++++---
 packages/compiler-sfc/src/parseComponent.ts | 7 ++++---
 scripts/config.js                           | 6 ++++--
 4 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index e2589dc5f8b..1c8c39e1a95 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -42,7 +42,7 @@ import { warnOnce } from './warn'
 import { isReservedTag } from 'web/util'
 import { dirRE } from 'compiler/parser'
 import { parseText } from 'compiler/parser/text-parser'
-import { DEFAULT_FILENAME } from './parse'
+import { DEFAULT_FILENAME } from './parseComponent'
 
 // Special compiler macros
 const DEFINE_PROPS = 'defineProps'
diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index dfc8faabd25..bd6381d13e5 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -3,13 +3,13 @@ import { RawSourceMap, VueTemplateCompiler } from './types'
 import {
   parseComponent,
   VueTemplateCompilerParseOptions,
-  SFCDescriptor
+  SFCDescriptor,
+  DEFAULT_FILENAME
 } from './parseComponent'
 
 import hash from 'hash-sum'
 import LRU from 'lru-cache'
-
-export const DEFAULT_FILENAME = 'anonymous.vue'
+import { hmrShouldReload } from './compileScript'
 
 const cache = new LRU<string, SFCDescriptor>(100)
 
@@ -52,6 +52,8 @@ export function parse(options: ParseOptions): SFCDescriptor {
   }
 
   output.filename = filename
+  output.shouldForceReload = prevImports =>
+    hmrShouldReload(prevImports, output!)
 
   if (needMap) {
     if (output.script && !output.script.src) {
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index a4194ce8f84..a396bbfe7b4 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -3,8 +3,9 @@ import { parseHTML } from 'compiler/parser/html-parser'
 import { makeMap } from 'shared/util'
 import { ASTAttr, WarningMessage } from 'types/compiler'
 import { BindingMetadata, RawSourceMap } from './types'
-import { hmrShouldReload, ImportBinding } from './compileScript'
-import { DEFAULT_FILENAME } from './parse'
+import type { ImportBinding } from './compileScript'
+
+export const DEFAULT_FILENAME = 'anonymous.vue'
 
 const splitRE = /\r?\n/g
 const replaceRE = /./g
@@ -84,7 +85,7 @@ export function parseComponent(
     styles: [],
     customBlocks: [],
     errors: [],
-    shouldForceReload: prevImports => hmrShouldReload(prevImports, sfc)
+    shouldForceReload: null as any // attached in parse() by compiler-sfc
   }
   let depth = 0
   let currentBlock: SFCBlock | null = null
diff --git a/scripts/config.js b/scripts/config.js
index 0fc581bb682..9d5914c2466 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -211,7 +211,6 @@ const builds = {
     entry: resolve('packages/compiler-sfc/src/index.ts'),
     dest: resolve('packages/compiler-sfc/dist/compiler-sfc.js'),
     format: 'cjs',
-    transpile: false,
     external: Object.keys(
       require('../packages/compiler-sfc/package.json').dependencies
     ),
@@ -251,7 +250,10 @@ function genConfig(name) {
           compilerOptions: {
             // if targeting browser, target es5
             // if targeting node, es2017 means Node 8
-            target: opts.transpile === false ? 'es2017' : 'es5'
+            target:
+              opts.transpile === false || opts.format === 'cjs'
+                ? 'es2017'
+                : 'es5'
           },
           exclude: ['test', 'test-dts']
         }

From b6b5239e6656f2dba386dcaf1c4a2543fc9962b6 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 23:46:46 +0800
Subject: [PATCH 145/317] release: v2.7.0-alpha.8

---
 CHANGELOG.md                            | 4 ++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17f306aa0c6..b942ce83a22 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# [2.7.0-alpha.8](https://github.com/vuejs/vue/compare/v2.7.0-alpha.7...v2.7.0-alpha.8) (2022-06-14)
+
+
+
 # [2.7.0-alpha.7](https://github.com/vuejs/vue/compare/v2.7.0-alpha.6...v2.7.0-alpha.7) (2022-06-14)
 
 
diff --git a/package.json b/package.json
index 15a163828a4..6ffe8fa6646 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.7",
+  "version": "2.7.0-alpha.8",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index a8540eb0427..256fea44750 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.7",
+  "version": "2.7.0-alpha.8",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 4e20798fc27..0dec62476b4 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.7",
+  "version": "2.7.0-alpha.8",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 32cb3a444aa..ad34d094102 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.7",
+  "version": "2.7.0-alpha.8",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 903d9b2eb67b3353f31eb7d36947d7a3462d25f3 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 14 Jun 2022 23:52:40 +0800
Subject: [PATCH 146/317] chore: changelog [ci skip]

---
 CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b942ce83a22..1cc9e170ca7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,10 @@
 # [2.7.0-alpha.8](https://github.com/vuejs/vue/compare/v2.7.0-alpha.7...v2.7.0-alpha.8) (2022-06-14)
 
+### Features
 
+- Basic `<script setup>` support. Requires `vue-loader@^15.10.0-beta.1`.
+  - Component resolution doesn't work yet
+  - Types for `defineXXX` macros not supported yet
 
 # [2.7.0-alpha.7](https://github.com/vuejs/vue/compare/v2.7.0-alpha.6...v2.7.0-alpha.7) (2022-06-14)
 

From 452aa9d29c848530d5d441652ef5a838312ac379 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 15 Jun 2022 10:07:42 +0800
Subject: [PATCH 147/317] wip: handle script analyzed bindings when prefixing
 identifiers

---
 packages/compiler-sfc/src/compileScript.ts    |  6 +++-
 packages/compiler-sfc/src/compileTemplate.ts  | 26 ++++++++++----
 .../{stripWith.ts => prefixIdentifiers.ts}    | 36 ++++++++++++++++---
 ...With.spec.ts => prefixIdentifiers.spec.ts} | 12 +++----
 scripts/config.js                             |  3 +-
 src/global.d.ts                               |  1 +
 src/types/compiler.ts                         |  4 +++
 src/types/component.ts                        |  1 +
 src/v3/apiSetup.ts                            | 31 ++++++++++------
 vitest.config.ts                              |  3 +-
 10 files changed, 92 insertions(+), 31 deletions(-)
 rename packages/compiler-sfc/src/{stripWith.ts => prefixIdentifiers.ts} (64%)
 rename packages/compiler-sfc/test/{stripWith.spec.ts => prefixIdentifiers.spec.ts} (82%)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 1c8c39e1a95..b12486823fa 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -1209,7 +1209,11 @@ export function compileScript(
       allBindings[key] = true
     }
   }
-  const returned = `{ ${Object.keys(allBindings).join(', ')} }`
+  // __sfc marker indicates these bindings are compiled from <script setup>
+  // and should not be proxied on `this`
+  const returned = `{ ${__TEST__ ? `` : `__sfc: true,`}${Object.keys(
+    allBindings
+  ).join(', ')} }`
 
   s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`)
 
diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index 44ea311f629..83a4251d44e 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -1,4 +1,8 @@
-import { VueTemplateCompiler, VueTemplateCompilerOptions } from './types'
+import {
+  BindingMetadata,
+  VueTemplateCompiler,
+  VueTemplateCompilerOptions
+} from './types'
 import assetUrlsModule, {
   AssetURLOptions,
   TransformAssetUrlsOptions
@@ -6,7 +10,7 @@ import assetUrlsModule, {
 import srcsetModule from './templateCompilerModules/srcset'
 import consolidate from '@vue/consolidate'
 import * as _compiler from 'web/entry-compiler'
-import { stripWith } from './stripWith'
+import { prefixIdentifiers } from './prefixIdentifiers'
 import { WarningMessage } from 'types/compiler'
 
 export interface TemplateCompileOptions {
@@ -24,6 +28,7 @@ export interface TemplateCompileOptions {
   optimizeSSR?: boolean
   prettify?: boolean
   isTS?: boolean
+  bindings?: BindingMetadata
 }
 
 export interface TemplateCompileResult {
@@ -107,7 +112,8 @@ function actuallyCompile(
     isFunctional = false,
     optimizeSSR = false,
     prettify = true,
-    isTS = false
+    isTS = false,
+    bindings
   } = options
 
   const compile =
@@ -144,15 +150,23 @@ function actuallyCompile(
     // transpile code with vue-template-es2015-compiler, which is a forked
     // version of Buble that applies ES2015 transforms + stripping `with` usage
     let code =
-      `var __render__ = ${stripWith(
+      `var __render__ = ${prefixIdentifiers(
         render,
         `render`,
         isFunctional,
         isTS,
-        transpileOptions
+        transpileOptions,
+        bindings
       )}\n` +
       `var __staticRenderFns__ = [${staticRenderFns.map(code =>
-        stripWith(code, ``, isFunctional, isTS, transpileOptions)
+        prefixIdentifiers(
+          code,
+          ``,
+          isFunctional,
+          isTS,
+          transpileOptions,
+          bindings
+        )
       )}]` +
       `\n`
 
diff --git a/packages/compiler-sfc/src/stripWith.ts b/packages/compiler-sfc/src/prefixIdentifiers.ts
similarity index 64%
rename from packages/compiler-sfc/src/stripWith.ts
rename to packages/compiler-sfc/src/prefixIdentifiers.ts
index ec4ff342962..2cce6850cbe 100644
--- a/packages/compiler-sfc/src/stripWith.ts
+++ b/packages/compiler-sfc/src/prefixIdentifiers.ts
@@ -2,6 +2,7 @@ import MagicString from 'magic-string'
 import { parseExpression, ParserOptions, ParserPlugin } from '@babel/parser'
 import { makeMap } from 'shared/util'
 import { walkIdentifiers } from './babelUtils'
+import { BindingMetadata } from './types'
 
 const doNotPrefix = makeMap(
   'Infinity,undefined,NaN,isFinite,isNaN,' +
@@ -16,12 +17,13 @@ const doNotPrefix = makeMap(
  * The input is expected to be the render function code directly returned from
  * `compile()` calls, e.g. `with(this){return ...}`
  */
-export function stripWith(
+export function prefixIdentifiers(
   source: string,
   fnName = '',
   isFunctional = false,
   isTS = false,
-  babelOptions: ParserOptions = {}
+  babelOptions: ParserOptions = {},
+  bindings?: BindingMetadata
 ) {
   source = `function ${fnName}(${isFunctional ? `_c,_vm` : ``}){${source}\n}`
 
@@ -40,17 +42,29 @@ export function stripWith(
   walkIdentifiers(
     ast,
     ident => {
-      if (doNotPrefix(ident.name)) {
+      const { name } = ident
+      if (doNotPrefix(name)) {
         return
       }
-      s.prependRight(ident.start!, '_vm.')
+
+      if (!bindings) {
+        s.prependRight(ident.start!, '_vm.')
+        return
+      }
+
+      s.overwrite(ident.start!, ident.end!, rewriteIdentifier(name, bindings))
     },
     node => {
       if (node.type === 'WithStatement') {
         s.remove(node.start!, node.body.start! + 1)
         s.remove(node.end! - 1, node.end!)
         if (!isFunctional) {
-          s.prependRight(node.start!, `var _vm=this;var _c=_vm._self._c;`)
+          s.prependRight(
+            node.start!,
+            `var _vm=this,_c=_vm._self._c${
+              bindings ? `,_setup=_vm._setupProxy;` : `;`
+            }`
+          )
         }
       }
     }
@@ -58,3 +72,15 @@ export function stripWith(
 
   return s.toString()
 }
+
+export function rewriteIdentifier(
+  name: string,
+  bindings: BindingMetadata
+): string {
+  const type = bindings[name]
+  if (type && type.startsWith('setup')) {
+    return `_setup.${name}`
+  } else {
+    return `_vm.${name}`
+  }
+}
diff --git a/packages/compiler-sfc/test/stripWith.spec.ts b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
similarity index 82%
rename from packages/compiler-sfc/test/stripWith.spec.ts
rename to packages/compiler-sfc/test/prefixIdentifiers.spec.ts
index f6c0d82c6eb..cfc60c88989 100644
--- a/packages/compiler-sfc/test/stripWith.spec.ts
+++ b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
@@ -1,4 +1,4 @@
-import { stripWith } from '../src/stripWith'
+import { prefixIdentifiers } from '../src/prefixIdentifiers'
 import { compile } from 'web/entry-compiler'
 import { format } from 'prettier'
 
@@ -11,7 +11,7 @@ it('should work', () => {
   </foo>
 </div>`)
 
-  const result = format(stripWith(render, `render`), {
+  const result = format(prefixIdentifiers(render, `render`), {
     semi: false,
     parser: 'babel'
   })
@@ -24,8 +24,8 @@ it('should work', () => {
 
   expect(result).toMatchInlineSnapshot(`
     "function render() {
-      var _vm = this
-      var _c = _vm._self._c
+      var _vm = this,
+        _c = _vm._self._c
       return _c(
         \\"div\\",
         { attrs: { id: \\"app\\" } },
@@ -39,8 +39,8 @@ it('should work', () => {
           _c(\\"foo\\", {
             inlineTemplate: {
               render: function () {
-                var _vm = this
-                var _c = _vm._self._c
+                var _vm = this,
+                  _c = _vm._self._c
                 return _c(\\"div\\", [_vm._v(_vm._s(_vm.bar))])
               },
               staticRenderFns: [],
diff --git a/scripts/config.js b/scripts/config.js
index 9d5914c2466..a1c871a6e95 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -278,7 +278,8 @@ function genConfig(name) {
   // built-in vars
   const vars = {
     __VERSION__: version,
-    __DEV__: `process.env.NODE_ENV !== 'production'`
+    __DEV__: `process.env.NODE_ENV !== 'production'`,
+    __TEST__: false
   }
   // feature flags
   Object.keys(featureFlags).forEach(key => {
diff --git a/src/global.d.ts b/src/global.d.ts
index 5a28776b988..1b88325cbdc 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,4 +1,5 @@
 declare const __DEV__: boolean
+declare const __TEST__: boolean
 
 interface Window {
   __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook
diff --git a/src/types/compiler.ts b/src/types/compiler.ts
index faa28758f8d..5da28145332 100644
--- a/src/types/compiler.ts
+++ b/src/types/compiler.ts
@@ -1,3 +1,5 @@
+import { BindingMetadata } from 'sfc/types'
+
 export type CompilerOptions = {
   warn?: Function // allow customizing warning in different environments; e.g. node
   modules?: Array<ModuleOptions> // platform specific modules; e.g. style; class
@@ -28,6 +30,8 @@ export type CompilerOptions = {
 
   // for ssr optimization compiler
   scopeId?: string
+
+  bindingMetadata?: BindingMetadata
 }
 
 export type WarningMessage = {
diff --git a/src/types/component.ts b/src/types/component.ts
index f28f4460870..23a4adb86e3 100644
--- a/src/types/component.ts
+++ b/src/types/component.ts
@@ -108,6 +108,7 @@ export declare class Component {
 
   // @v3
   _setupState?: Record<string, any>
+  _setupProxy?: Record<string, any>
   _setupContext?: SetupContext
   _attrsProxy?: Record<string, any>
   _slotsProxy?: Record<string, () => VNode[]>
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index 29ef7e48f19..de31d2f44c7 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -43,11 +43,20 @@ export function initSetup(vm: Component) {
         )
       }
       vm._setupState = setupResult
-      for (const key in setupResult) {
-        if (!isReserved(key)) {
-          proxySetupProperty(vm, setupResult, key)
-        } else if (__DEV__) {
-          warn(`Avoid using variables that start with _ or $ in setup().`)
+      // __sfc indicates compiled bindings from <script setup>
+      if (!setupResult.__sfc) {
+        for (const key in setupResult) {
+          if (!isReserved(key)) {
+            proxySetupProperty(vm, setupResult, key)
+          } else if (__DEV__) {
+            warn(`Avoid using variables that start with _ or $ in setup().`)
+          }
+        }
+      } else {
+        // exposed for compiled render fn
+        const proxy = (vm._setupProxy = {})
+        for (const key in setupResult) {
+          proxySetupProperty(proxy, setupResult, key)
         }
       }
     } else if (__DEV__ && setupResult !== undefined) {
@@ -61,17 +70,17 @@ export function initSetup(vm: Component) {
 }
 
 function proxySetupProperty(
-  vm: Component,
+  target: any,
   setupResult: Record<string, any>,
   key: string
 ) {
-  const raw = setupResult[key]
-  const unwrap = isRef(raw)
-  Object.defineProperty(vm, key, {
+  let raw = setupResult[key]
+  Object.defineProperty(target, key, {
     enumerable: true,
     configurable: true,
-    get: unwrap ? () => raw.value : () => setupResult[key],
-    set: unwrap ? v => (raw.value = v) : v => (setupResult[key] = v)
+    get: () => (isRef(raw) ? raw.value : raw),
+    set: newVal =>
+      isRef(raw) ? (raw.value = newVal) : (raw = setupResult[key] = newVal)
   })
 }
 
diff --git a/vitest.config.ts b/vitest.config.ts
index fba8a8589f2..14999481936 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -17,7 +17,8 @@ export default defineConfig({
     }
   },
   define: {
-    __DEV__: true
+    __DEV__: true,
+    __TEST__: true
   },
   test: {
     globals: true,

From d4787e53ef0958f4d2c9531c6c7f0c31fa0499f4 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 15 Jun 2022 10:18:55 +0800
Subject: [PATCH 148/317] test: test case for prefixIdentifiers w/ bindings

---
 .../test/prefixIdentifiers.spec.ts            | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
index cfc60c88989..0a1ee2351b2 100644
--- a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
+++ b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
@@ -1,6 +1,7 @@
 import { prefixIdentifiers } from '../src/prefixIdentifiers'
 import { compile } from 'web/entry-compiler'
 import { format } from 'prettier'
+import { BindingTypes } from '../src/types'
 
 it('should work', () => {
   const { render } = compile(`<div id="app">
@@ -53,3 +54,41 @@ it('should work', () => {
     "
   `)
 })
+
+it('setup bindings', () => {
+  const { render } = compile(`<div @click="count++">{{ count }}</div>`)
+
+  const result = format(
+    prefixIdentifiers(render, `render`, false, false, undefined, {
+      count: BindingTypes.SETUP_REF
+    }),
+    {
+      semi: false,
+      parser: 'babel'
+    }
+  )
+
+  expect(result).toMatch(`_setup = _vm._setupProxy`)
+  expect(result).toMatch(`_setup.count++`)
+  expect(result).toMatch(`_vm._s(_setup.count)`)
+
+  expect(result).toMatchInlineSnapshot(`
+    "function render() {
+      var _vm = this,
+        _c = _vm._self._c,
+        _setup = _vm._setupProxy
+      return _c(
+        \\"div\\",
+        {
+          on: {
+            click: function (\$event) {
+              _setup.count++
+            },
+          },
+        },
+        [_vm._v(_vm._s(_setup.count))]
+      )
+    }
+    "
+  `)
+})

From 4b193390fbc203cc5bae46fe288b1c20c442cc03 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 15 Jun 2022 10:39:45 +0800
Subject: [PATCH 149/317] feat: resolve components from `<script setup>`

---
 packages/compiler-sfc/src/compileTemplate.ts |  1 +
 packages/compiler-sfc/src/types.ts           | 17 +++------------
 src/compiler/codegen/index.ts                | 23 ++++++++++++++++++--
 src/types/compiler.ts                        |  3 ++-
 4 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index 83a4251d44e..69c4cdd5903 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -132,6 +132,7 @@ function actuallyCompile(
       filename: options.filename
     })
   }
+  finalCompilerOptions.bindings = bindings
 
   const { ast, render, staticRenderFns, tips, errors } = compile(
     source,
diff --git a/packages/compiler-sfc/src/types.ts b/packages/compiler-sfc/src/types.ts
index 882db71538f..93564db3ca3 100644
--- a/packages/compiler-sfc/src/types.ts
+++ b/packages/compiler-sfc/src/types.ts
@@ -1,4 +1,4 @@
-import { WarningMessage } from 'types/compiler'
+import { CompilerOptions, CompiledResult } from 'types/compiler'
 import { SFCDescriptor } from './parseComponent'
 
 export interface StartOfSourceMap {
@@ -31,20 +31,9 @@ export interface VueTemplateCompiler {
 // we'll just shim this much for now - in the future these types
 // should come from vue-template-compiler directly, or this package should be
 // part of the vue monorepo.
-export interface VueTemplateCompilerOptions {
-  modules?: Object[]
-  outputSourceRange?: boolean
-  whitespace?: 'preserve' | 'condense'
-  directives?: { [key: string]: Function }
-}
+export type VueTemplateCompilerOptions = CompilerOptions
 
-export interface VueTemplateCompilerResults {
-  ast: Object | undefined
-  render: string
-  staticRenderFns: string[]
-  errors: (string | WarningMessage)[]
-  tips: (string | WarningMessage)[]
-}
+export type VueTemplateCompilerResults = CompiledResult
 
 export const enum BindingTypes {
   /**
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 69d42094526..7d2e7c62bce 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -1,6 +1,6 @@
 import { genHandlers } from './events'
 import baseDirectives from '../directives/index'
-import { camelize, no, extend } from 'shared/util'
+import { camelize, no, extend, capitalize } from 'shared/util'
 import { baseWarn, pluckModuleFunction } from '../helpers'
 import { emptySlotScopeToken } from '../parser/index'
 import {
@@ -13,6 +13,7 @@ import {
   ASTText,
   CompilerOptions
 } from 'types/compiler'
+import { BindingMetadata } from 'sfc/types'
 
 type TransformFunction = (el: ASTElement, code: string) => string
 type DataGenFunction = (el: ASTElement) => string
@@ -98,8 +99,19 @@ export function genElement(el: ASTElement, state: CodegenState): string {
         data = genData(el, state)
       }
 
+      let tag: string | undefined
+      // check if this is a component in <script setup>
+      const bindings = state.options.bindings
+      if (bindings && !bindings.__isScriptSetup) {
+        tag =
+          checkBindingType(bindings, el.tag) ||
+          checkBindingType(bindings, camelize(el.tag)) ||
+          checkBindingType(bindings, capitalize(camelize(el.tag)))
+      }
+      if (!tag) tag = `'${el.tag}'`
+
       const children = el.inlineTemplate ? null : genChildren(el, state, true)
-      code = `_c('${el.tag}'${
+      code = `_c(${tag}${
         data ? `,${data}` : '' // data
       }${
         children ? `,${children}` : '' // children
@@ -113,6 +125,13 @@ export function genElement(el: ASTElement, state: CodegenState): string {
   }
 }
 
+function checkBindingType(bindings: BindingMetadata, key: string) {
+  const type = bindings[key]
+  if (type && type.startsWith('setup')) {
+    return key
+  }
+}
+
 // hoist static sub-trees out
 function genStatic(el: ASTElement, state: CodegenState): string {
   el.staticProcessed = true
diff --git a/src/types/compiler.ts b/src/types/compiler.ts
index 5da28145332..5c5059019f4 100644
--- a/src/types/compiler.ts
+++ b/src/types/compiler.ts
@@ -31,7 +31,8 @@ export type CompilerOptions = {
   // for ssr optimization compiler
   scopeId?: string
 
-  bindingMetadata?: BindingMetadata
+  // SFC analyzed script bindings from `compileScript()`
+  bindings?: BindingMetadata
 }
 
 export type WarningMessage = {

From aa2b1f4d93bdd257ae26a73994168709369aa6a0 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 15 Jun 2022 21:21:59 +0800
Subject: [PATCH 150/317] feat: directive resolution for `<script setup>`

---
 src/core/vdom/modules/directives.ts    |  5 ++++-
 test/unit/features/v3/apiSetup.spec.ts | 14 ++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 0dc61e92799..7d475de1fc5 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -102,7 +102,10 @@ function normalizeDirectives(
       dir.modifiers = emptyModifiers
     }
     res[getRawDirName(dir)] = dir
-    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true)
+    if (vm._setupState && vm._setupState.__sfc) {
+      dir.def = resolveAsset(vm, '_setupState', 'v-' + dir.name)
+    }
+    dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true)
   }
   // $flow-disable-line
   return res
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index f3c152b48cf..44044ed22b1 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -233,4 +233,18 @@ describe('api: setup context', () => {
     await nextTick()
     expect(vm.$el.outerHTML).toMatch(`<div>1</div>`)
   })
+
+  it('directive resolution', () => {
+    const spy = vi.fn()
+    new Vue({
+      setup: () => ({
+        __sfc: true,
+        vDir: {
+          inserted: spy
+        }
+      }),
+      template: `<div v-dir />`
+    }).$mount()
+    expect(spy).toHaveBeenCalled()
+  })
 })

From bd8409bc9873943a4a8d3838ac945fdfff1f3a51 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 15 Jun 2022 21:38:05 +0800
Subject: [PATCH 151/317] wip: fix component resolution check

---
 .../compiler-sfc/src/prefixIdentifiers.ts     |  6 +++--
 src/compiler/codegen/index.ts                 |  2 +-
 test/unit/modules/compiler/codegen.spec.ts    | 26 ++++++++++++++-----
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/packages/compiler-sfc/src/prefixIdentifiers.ts b/packages/compiler-sfc/src/prefixIdentifiers.ts
index 2cce6850cbe..a756b4ba6e5 100644
--- a/packages/compiler-sfc/src/prefixIdentifiers.ts
+++ b/packages/compiler-sfc/src/prefixIdentifiers.ts
@@ -39,6 +39,8 @@ export function prefixIdentifiers(
     plugins
   })
 
+  const isScriptSetup = bindings && bindings.__isScriptSetup !== false
+
   walkIdentifiers(
     ast,
     ident => {
@@ -47,7 +49,7 @@ export function prefixIdentifiers(
         return
       }
 
-      if (!bindings) {
+      if (!isScriptSetup) {
         s.prependRight(ident.start!, '_vm.')
         return
       }
@@ -62,7 +64,7 @@ export function prefixIdentifiers(
           s.prependRight(
             node.start!,
             `var _vm=this,_c=_vm._self._c${
-              bindings ? `,_setup=_vm._setupProxy;` : `;`
+              isScriptSetup ? `,_setup=_vm._setupProxy;` : `;`
             }`
           )
         }
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 7d2e7c62bce..823154e28a0 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -102,7 +102,7 @@ export function genElement(el: ASTElement, state: CodegenState): string {
       let tag: string | undefined
       // check if this is a component in <script setup>
       const bindings = state.options.bindings
-      if (bindings && !bindings.__isScriptSetup) {
+      if (bindings && bindings.__isScriptSetup !== false) {
         tag =
           checkBindingType(bindings, el.tag) ||
           checkBindingType(bindings, camelize(el.tag)) ||
diff --git a/test/unit/modules/compiler/codegen.spec.ts b/test/unit/modules/compiler/codegen.spec.ts
index e893a81920e..5e584c8fb90 100644
--- a/test/unit/modules/compiler/codegen.spec.ts
+++ b/test/unit/modules/compiler/codegen.spec.ts
@@ -4,11 +4,12 @@ import { generate } from 'compiler/codegen'
 import { isObject, isFunction, extend } from 'shared/util'
 import { isReservedTag } from 'web/util/index'
 import { baseOptions } from 'web/compiler/options'
+import { BindingTypes } from '../../../../packages/compiler-sfc/src/types'
 
 function assertCodegen(template, generatedCode, ...args) {
-  let staticRenderFnCodes = []
+  let staticRenderFnCodes: string[] = []
   let generateOptions = baseOptions
-  let proc = null
+  let proc: Function | null = null
   let len = args.length
   while (len--) {
     const arg = args[len]
@@ -28,7 +29,6 @@ function assertCodegen(template, generatedCode, ...args) {
   expect(res.staticRenderFns).toEqual(staticRenderFnCodes)
 }
 
-/* eslint-disable quotes */
 describe('codegen', () => {
   it('generate directive', () => {
     assertCodegen(
@@ -624,7 +624,7 @@ describe('codegen', () => {
     expect(
       'Inline-template components must have exactly one child element.'
     ).toHaveBeenWarned()
-    expect(console.error.mock.calls.length).toBe(3)
+    expect((console.error as any).mock.calls.length).toBe(3)
   })
 
   it('generate static trees inside v-for', () => {
@@ -689,7 +689,7 @@ describe('codegen', () => {
   })
 
   it('not specified ast type', () => {
-    const res = generate(null, baseOptions)
+    const res = generate(undefined, baseOptions)
     expect(res.render).toBe(`with(this){return _c("div")}`)
     expect(res.staticRenderFns).toEqual([])
   })
@@ -709,5 +709,19 @@ describe('codegen', () => {
       `with(this){return _c('div',[(ok)?_l((1),function(i){return _c('foo',{key:i})}):_e()],2)}`
     )
   })
+
+  it('component with bindings ', () => {
+    const ast = parse(`<div><Foo/><foo-bar></foo-bar></div>`, baseOptions)
+    optimize(ast, baseOptions)
+    const res = generate(ast, {
+      ...baseOptions,
+      bindings: {
+        Foo: BindingTypes.SETUP_CONST,
+        FooBar: BindingTypes.SETUP_CONST
+      }
+    })
+    expect(res.render).toMatchInlineSnapshot(
+      '"with(this){return _c(\'div\',[_c(Foo),_c(FooBar)],1)}"'
+    )
+  })
 })
-/* eslint-enable quotes */

From 3c2707b62e1a355f182c08f85cf7bc9bca1bb34e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 09:53:45 +0800
Subject: [PATCH 152/317] feat: defineExpose() support

---
 packages/compiler-sfc/src/compileScript.ts    |  11 +-
 .../__snapshots__/compileScript.spec.ts.snap  | 207 ++++++------------
 .../compiler-sfc/test/compileScript.spec.ts   |   6 +-
 src/core/config.ts                            |   4 +-
 src/core/util/debug.ts                        |   2 +-
 src/types/options.ts                          |   2 +-
 src/v3/apiSetup.ts                            |  30 ++-
 7 files changed, 101 insertions(+), 161 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index b12486823fa..354aa40b62b 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -1183,7 +1183,7 @@ export function compileScript(
     s.prependLeft(startOffset, `\nlet __temp${any}, __restore${any}\n`)
   }
 
-  const destructureElements = [`expose`]
+  const destructureElements = hasDefineExposeCall ? [`expose`] : []
   if (emitIdentifier) {
     destructureElements.push(
       emitIdentifier === `emit` ? `emit` : `emit: ${emitIdentifier}`
@@ -1256,9 +1256,6 @@ export function compileScript(
     runtimeOptions += genRuntimeEmits(typeDeclaredEmits)
   }
 
-  // <script setup> components are closed by default. If the user did not
-  // explicitly call `defineExpose`, call expose() with no args.
-  const exposeCall = hasDefineExposeCall ? `` : `  expose();\n`
   // wrap setup code with function.
   if (isTS) {
     // for TS, make sure the exported type is still valid type with
@@ -1273,7 +1270,7 @@ export function compileScript(
         `defineComponent`
       )}({${def}${runtimeOptions}\n  ${
         hasAwait ? `async ` : ``
-      }setup(${args}) {\n${exposeCall}`
+      }setup(${args}) {\n`
     )
     s.appendRight(endOffset, `})`)
   } else {
@@ -1283,14 +1280,14 @@ export function compileScript(
       s.prependLeft(
         startOffset,
         `\nexport default /*#__PURE__*/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}\n  ` +
-          `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`
+          `${hasAwait ? `async ` : ``}setup(${args}) {\n`
       )
       s.appendRight(endOffset, `})`)
     } else {
       s.prependLeft(
         startOffset,
         `\nexport default {${runtimeOptions}\n  ` +
-          `${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`
+          `${hasAwait ? `async ` : ``}setup(${args}) {\n`
       )
       s.appendRight(endOffset, `}`)
     }
diff --git a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
index e98ba898406..f1041a94019 100644
--- a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
+++ b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
@@ -3,8 +3,7 @@
 exports[`SFC analyze <script> bindings > auto name inference > basic 1`] = `
 "export default {
   __name: 'FooBar',
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 const a = 1
 return { a }
 }
@@ -19,8 +18,7 @@ exports[`SFC analyze <script> bindings > auto name inference > do not overwrite
         })
         
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 const a = 1
 return { a, defineComponent }
 }
@@ -34,8 +32,7 @@ exports[`SFC analyze <script> bindings > auto name inference > do not overwrite
         }
         
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 const a = 1
 return { a }
 }
@@ -48,8 +45,7 @@ exports[`SFC compile <script setup> > <script> after <script setup> the script c
 import { x } from './x'
     
 export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
     
 return { n, x }
@@ -66,8 +62,7 @@ exports[`SFC compile <script setup> > <script> and <script setup> co-usage > scr
       const __default__ = {}
       
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       x()
       
@@ -84,8 +79,7 @@ exports[`SFC compile <script setup> > <script> and <script setup> co-usage > scr
 import { x } from './x'
       
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       x()
       
@@ -106,8 +100,7 @@ import { x } from './x'
       
 export default /*#__PURE__*/_defineComponent({
   ...__default__,
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       x()
       
@@ -127,8 +120,7 @@ const __default__ = def
 import { x } from './x'
       
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       x()
       
@@ -147,8 +139,7 @@ exports[`SFC compile <script setup> > <script> and <script setup> co-usage > spa
         }
         
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         x()
         
@@ -167,8 +158,7 @@ exports[`SFC compile <script setup> > <script> and <script setup> co-usage > spa
         }
         
 export default /*#__PURE__*/Object.assign(__default__, {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         x()
         
@@ -182,8 +172,7 @@ exports[`SFC compile <script setup> > async/await detection > expression stateme
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 ;(
@@ -201,8 +190,7 @@ exports[`SFC compile <script setup> > async/await detection > multiple \`if for\
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 if (ok) {
@@ -236,8 +224,7 @@ exports[`SFC compile <script setup> > async/await detection > multiple \`if whil
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 if (ok) {
@@ -291,8 +278,7 @@ exports[`SFC compile <script setup> > async/await detection > multiple \`if\` ne
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 if (ok) {
@@ -368,8 +354,7 @@ exports[`SFC compile <script setup> > async/await detection > nested await 1`] =
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 ;(
@@ -392,8 +377,7 @@ exports[`SFC compile <script setup> > async/await detection > nested await 2`] =
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 ;(
@@ -416,8 +400,7 @@ exports[`SFC compile <script setup> > async/await detection > nested await 3`] =
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 ;(
@@ -445,8 +428,7 @@ exports[`SFC compile <script setup> > async/await detection > nested leading awa
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 foo()
@@ -471,8 +453,7 @@ exports[`SFC compile <script setup> > async/await detection > nested statements
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 if (ok) { (
@@ -494,8 +475,7 @@ exports[`SFC compile <script setup> > async/await detection > ref 1`] = `
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 let a = $ref(1 + ((
@@ -512,8 +492,7 @@ return { a }
 
 exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 1`] = `
 "export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 async function foo() { await bar }
 return { foo }
 }
@@ -523,8 +502,7 @@ return { foo }
 
 exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 2`] = `
 "export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 const foo = async () => { await bar }
 return { foo }
 }
@@ -534,8 +512,7 @@ return { foo }
 
 exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 3`] = `
 "export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 const obj = { async method() { await bar }}
 return { obj }
 }
@@ -545,8 +522,7 @@ return { obj }
 
 exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 4`] = `
 "export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 const cls = class Foo { async method() { await bar }}
 return { cls }
 }
@@ -558,8 +534,7 @@ exports[`SFC compile <script setup> > async/await detection > single line condit
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 if (false) (
@@ -577,8 +552,7 @@ exports[`SFC compile <script setup> > async/await detection > variable 1`] = `
 "import { withAsyncContext as _withAsyncContext } from 'vue'
 
 export default {
-  async setup(__props, { expose }) {
-  expose();
+  async setup(__props) {
 
 let __temp, __restore
 const a = 1 + ((
@@ -595,8 +569,7 @@ return { a }
 
 exports[`SFC compile <script setup> > binding analysis for destructure 1`] = `
 "export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       const { foo, b: bar, ['x' + 'y']: baz, x: { y, zz: { z }}} = {}
       
@@ -609,8 +582,7 @@ return { foo, bar, baz, y, z }
 exports[`SFC compile <script setup> > defineEmits() 1`] = `
 "export default {
   emits: ['foo', 'bar'],
-  setup(__props, { expose, emit: myEmit }) {
-  expose();
+  setup(__props, { emit: myEmit }) {
 
 
 
@@ -637,8 +609,7 @@ exports[`SFC compile <script setup> > defineProps w/ external definition 1`] = `
     
 export default {
   props: propsModel,
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
 const props = __props
 
@@ -655,8 +626,7 @@ exports[`SFC compile <script setup> > defineProps w/ leading code 1`] = `
     
 export default {
   props: {},
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
 const props = __props
 
@@ -672,8 +642,7 @@ exports[`SFC compile <script setup> > defineProps() 1`] = `
   props: {
   foo: String
 },
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
 const props = __props
 
@@ -690,8 +659,7 @@ exports[`SFC compile <script setup> > defineProps/defineEmits in multi-variable
 "export default {
   props: ['item'],
   emits: ['a'],
-  setup(__props, { expose, emit }) {
-  expose();
+  setup(__props, { emit }) {
 
 const props = __props
 
@@ -707,8 +675,7 @@ exports[`SFC compile <script setup> > defineProps/defineEmits in multi-variable
 "export default {
   props: ['item'],
   emits: ['a'],
-  setup(__props, { expose, emit }) {
-  expose();
+  setup(__props, { emit }) {
 
 const props = __props
 
@@ -725,8 +692,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > TS annotatio
 import { Foo, Baz, Qux, Fred } from './x'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         const a = 1
         function b() {}
@@ -742,8 +708,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > attribute ex
 import { bar, baz } from './x'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         const cond = true
         
@@ -758,8 +723,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > components 1
 import { FooBar, FooBaz, FooQux, foo } from './x'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         const fooBar: FooBar = 1
         
@@ -774,8 +738,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > directive 1`
 import { vMyDir } from './x'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { vMyDir }
@@ -789,8 +752,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > js template
 import { VAR, VAR2, VAR3 } from './x'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { VAR, VAR3 }
@@ -804,8 +766,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > last tag 1`]
 import { FooBaz, Last } from './x'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { FooBaz, Last }
@@ -819,8 +780,7 @@ exports[`SFC compile <script setup> > dev mode import usage check > vue interpol
 import { x, y, z, x$y } from './x'
       
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       
 return { x, z, x$y }
@@ -841,8 +801,7 @@ export default {
   emits: {
           foo: () => bar > 1
         },
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
         
@@ -863,8 +822,7 @@ exports[`SFC compile <script setup> > errors > should allow defineProps/Emit() r
   emits: {
             foo: bar => bar > 1
           },
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
           const bar = 1
           
@@ -880,8 +838,7 @@ exports[`SFC compile <script setup> > imports > import dedupe between <script> a
 "import { x } from './x'
         
 export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         x()
         
@@ -897,8 +854,7 @@ exports[`SFC compile <script setup> > imports > should allow defineProps/Emit at
 export default {
   props: ['foo'],
   emits: ['bar'],
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       
       
@@ -915,8 +871,7 @@ exports[`SFC compile <script setup> > imports > should extract comment for impor
         import b from 'b'
         
 export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { a, b }
@@ -930,8 +885,7 @@ exports[`SFC compile <script setup> > imports > should hoist and expose imports
           import 'foo/css'
         
 export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
           
 return { ref }
@@ -950,8 +904,7 @@ exports[`SFC compile <script setup> > should expose top level declarations 1`] =
 import { x } from './x'
       
 export default {
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
       let a = 1
       const b = 2
@@ -969,8 +922,7 @@ exports[`SFC compile <script setup> > with TypeScript > const Enum 1`] = `
 const enum Foo { A = 123 }
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { Foo }
@@ -985,8 +937,7 @@ export interface Emits { (e: 'foo' | 'bar'): void }
       
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1002,8 +953,7 @@ export type Emits = { (e: 'foo' | 'bar'): void }
       
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1019,8 +969,7 @@ interface Emits { (e: 'foo' | 'bar'): void }
       
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1036,8 +985,7 @@ export type Emits = (e: 'foo' | 'bar') => void
       
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1053,8 +1001,7 @@ type Emits = (e: 'foo' | 'bar') => void
       
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1070,8 +1017,7 @@ type Emits = { (e: 'foo' | 'bar'): void }
       
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ({ (e: 'foo' | 'bar'): void }), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1086,8 +1032,7 @@ exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type (typ
 
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\", \\"baz\\"],
-  setup(__props, { expose, emit }: { emit: ({(e: 'foo' | 'bar'): void; (e: 'baz', id: number): void;}), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ({(e: 'foo' | 'bar'): void; (e: 'baz', id: number): void;}), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1102,8 +1047,7 @@ exports[`SFC compile <script setup> > with TypeScript > defineEmits w/ type 1`]
 
 export default /*#__PURE__*/_defineComponent({
   emits: [\\"foo\\", \\"bar\\"],
-  setup(__props, { expose, emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
-  expose();
+  setup(__props, { emit }: { emit: ((e: 'foo' | 'bar') => void), expose: any, slots: any, attrs: any }) {
 
       
       
@@ -1121,8 +1065,7 @@ export default /*#__PURE__*/_defineComponent({
   props: {
     x: { type: Number, required: false }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
       
       
@@ -1141,8 +1084,7 @@ export default /*#__PURE__*/_defineComponent({
   props: {
     x: { type: Number, required: false }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
         
       
@@ -1160,8 +1102,7 @@ export default /*#__PURE__*/_defineComponent({
   props: {
     x: { type: Number, required: false }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
       
       
@@ -1179,8 +1120,7 @@ export default /*#__PURE__*/_defineComponent({
   props: {
     x: { type: Number, required: false }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
       
       
@@ -1226,8 +1166,7 @@ export default /*#__PURE__*/_defineComponent({
     intersection: { type: Object, required: true },
     foo: { type: [Function, null], required: true }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
       
       
@@ -1245,8 +1184,7 @@ export default /*#__PURE__*/_defineComponent({
   props: {
     x: { type: Number, required: false }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
       
       
@@ -1262,8 +1200,7 @@ exports[`SFC compile <script setup> > with TypeScript > defineProps/Emit w/ runt
 export default /*#__PURE__*/_defineComponent({
   props: { foo: String },
   emits: ['a', 'b'],
-  setup(__props, { expose, emit }) {
-  expose();
+  setup(__props, { emit }) {
 
 const props = __props
 
@@ -1282,8 +1219,7 @@ export interface Foo {}
         type Bar = {}
       
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return {  }
@@ -1298,8 +1234,7 @@ import type { Foo } from './main.ts'
         import { type Bar, Baz } from './main.ts'
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { Baz }
@@ -1313,8 +1248,7 @@ exports[`SFC compile <script setup> > with TypeScript > runtime Enum 1`] = `
 enum Foo { A = 123 }
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { Foo }
@@ -1332,8 +1266,7 @@ enum Foo { A = 123 }
           enum B { B = \\"B\\" }
         
 export default /*#__PURE__*/_defineComponent({
-  setup(__props, { expose }) {
-  expose();
+  setup(__props) {
 
         
 return { D, C, B, Foo }
@@ -1352,8 +1285,7 @@ export default /*#__PURE__*/_defineComponent({
     bar: { type: Number, required: false },
     baz: { type: Boolean, required: true }
   }, { ...defaults }),
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
 const props = __props as {
         foo?: string
@@ -1379,8 +1311,7 @@ export default /*#__PURE__*/_defineComponent({
     baz: { type: Boolean, required: true },
     qux: { type: Function, required: false, default() { return 1 } }
   },
-  setup(__props: any, { expose }) {
-  expose();
+  setup(__props: any) {
 
 const props = __props as { foo: string, bar?: number, baz: boolean, qux(): number }
 
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index 8365756da84..19ad17a2dfd 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -102,7 +102,7 @@ const bar = 1
     // should remove defineOptions import and call
     expect(content).not.toMatch('defineProps')
     // should generate correct setup signature
-    expect(content).toMatch(`setup(__props, { expose }) {`)
+    expect(content).toMatch(`setup(__props) {`)
     // should assign user identifier to it
     expect(content).toMatch(`const props = __props`)
     // should include context options in default export
@@ -149,7 +149,7 @@ const myEmit = defineEmits(['foo', 'bar'])
     // should remove defineOptions import and call
     expect(content).not.toMatch('defineEmits')
     // should generate correct setup signature
-    expect(content).toMatch(`setup(__props, { expose, emit: myEmit }) {`)
+    expect(content).toMatch(`setup(__props, { emit: myEmit }) {`)
     // should include context options in default export
     expect(content).toMatch(`export default {
   emits: ['foo', 'bar'],`)
@@ -769,7 +769,7 @@ const emit = defineEmits(['a', 'b'])
       expect(content).toMatch(`export default /*#__PURE__*/_defineComponent({
   props: { foo: String },
   emits: ['a', 'b'],
-  setup(__props, { expose, emit }) {`)
+  setup(__props, { emit }) {`)
     })
 
     test('defineProps w/ type', () => {
diff --git a/src/core/config.ts b/src/core/config.ts
index 1a0b8265d33..97b17adcf45 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -13,8 +13,8 @@ export interface Config {
   productionTip: boolean
   performance: boolean
   devtools: boolean
-  errorHandler?: (err: Error, vm: Component, info: string) => void
-  warnHandler?: (msg: string, vm: Component, trace: string) => void
+  errorHandler?: (err: Error, vm: Component | null, info: string) => void
+  warnHandler?: (msg: string, vm: Component | null, trace: string) => void
   ignoredElements: Array<string | RegExp>
   keyCodes: { [key: string]: number | Array<number> }
 
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index 401a47bba4d..8dbc1edb19a 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -3,7 +3,7 @@ import { noop, isArray, isFunction } from 'shared/util'
 import type { Component } from 'types/component'
 import { currentInstance } from 'v3/currentInstance'
 
-export let warn = noop
+export let warn: (msg: string, vm?: Component | null) => void = noop
 export let tip = noop
 export let generateComponentTrace: (vm: Component) => string // work around flow check
 export let formatComponentName: (vm: Component, includeFile?: false) => string
diff --git a/src/types/options.ts b/src/types/options.ts
index ee4440db96a..b5626acb259 100644
--- a/src/types/options.ts
+++ b/src/types/options.ts
@@ -90,7 +90,7 @@ export type ComponentOptions = {
   comments?: boolean
   inheritAttrs?: boolean
 
-  // Class API
+  // Legacy API
   abstract?: any
 
   // private
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index de31d2f44c7..e4cadb10678 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -12,6 +12,7 @@ export interface SetupContext {
   attrs: Record<string, any>
   slots: Record<string, () => VNode[]>
   emit: (event: string, ...args: any[]) => any
+  expose: (exposed: Record<string, any>) => void
 }
 
 export function initSetup(vm: Component) {
@@ -47,7 +48,7 @@ export function initSetup(vm: Component) {
       if (!setupResult.__sfc) {
         for (const key in setupResult) {
           if (!isReserved(key)) {
-            proxySetupProperty(vm, setupResult, key)
+            proxyWithRefUnwrap(vm, setupResult, key)
           } else if (__DEV__) {
             warn(`Avoid using variables that start with _ or $ in setup().`)
           }
@@ -56,7 +57,7 @@ export function initSetup(vm: Component) {
         // exposed for compiled render fn
         const proxy = (vm._setupProxy = {})
         for (const key in setupResult) {
-          proxySetupProperty(proxy, setupResult, key)
+          proxyWithRefUnwrap(proxy, setupResult, key)
         }
       }
     } else if (__DEV__ && setupResult !== undefined) {
@@ -69,22 +70,23 @@ export function initSetup(vm: Component) {
   }
 }
 
-function proxySetupProperty(
+export function proxyWithRefUnwrap(
   target: any,
-  setupResult: Record<string, any>,
+  source: Record<string, any>,
   key: string
 ) {
-  let raw = setupResult[key]
+  let raw = source[key]
   Object.defineProperty(target, key, {
     enumerable: true,
     configurable: true,
     get: () => (isRef(raw) ? raw.value : raw),
     set: newVal =>
-      isRef(raw) ? (raw.value = newVal) : (raw = setupResult[key] = newVal)
+      isRef(raw) ? (raw.value = newVal) : (raw = source[key] = newVal)
   })
 }
 
-function createSetupContext(vm: Component) {
+function createSetupContext(vm: Component): SetupContext {
+  let exposeCalled = false
   return {
     get attrs() {
       return initAttrsProxy(vm)
@@ -93,8 +95,18 @@ function createSetupContext(vm: Component) {
       return initSlotsProxy(vm)
     },
     emit: bind(vm.$emit, vm) as any,
-    expose() {
-      // TODO
+    expose(exposed?: Record<string, any>) {
+      if (__DEV__) {
+        if (exposeCalled) {
+          warn(`expose() should be called only once per setup().`, vm)
+        }
+        exposeCalled = true
+      }
+      if (exposed) {
+        Object.keys(exposed).forEach(key =>
+          proxyWithRefUnwrap(vm, exposed, key)
+        )
+      }
     }
   }
 }

From 7173ad42729fa0913c3e7de94d251341929ee7c6 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 10:19:01 +0800
Subject: [PATCH 153/317] feat: types for `<script setup>` macros

---
 src/core/util/options.ts         |   2 +-
 src/types/options.ts             |  12 +--
 src/v3/apiSetup.ts               |  41 ++++++++-
 src/v3/apiWatch.ts               |   6 +-
 src/v3/index.ts                  |   2 +-
 types/index.d.ts                 |   2 +
 types/test/setup-helpers-test.ts | 134 +++++++++++++++++++++++++++
 types/v3-setup-helpers.d.ts      | 150 +++++++++++++++++++++++++++++++
 8 files changed, 337 insertions(+), 12 deletions(-)
 create mode 100644 types/test/setup-helpers-test.ts
 create mode 100644 types/v3-setup-helpers.d.ts

diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index e9b7c489e16..baddeb09b6e 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -467,7 +467,7 @@ export function resolveAsset(
   // fallback to prototype chain
   const res = assets[id] || assets[camelizedId] || assets[PascalCaseId]
   if (__DEV__ && warnMissing && !res) {
-    warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id, options)
+    warn('Failed to resolve ' + type.slice(0, -1) + ': ' + id)
   }
   return res
 }
diff --git a/src/types/options.ts b/src/types/options.ts
index b5626acb259..27b3d7afc31 100644
--- a/src/types/options.ts
+++ b/src/types/options.ts
@@ -26,7 +26,9 @@ export type ComponentOptions = {
 
   // data
   data: object | Function | void
-  props?: { [key: string]: PropOptions }
+  props?:
+    | string[]
+    | Record<string, Function | Array<Function> | null | PropOptions>
   propsData?: object
   computed?: {
     [key: string]:
@@ -105,8 +107,8 @@ export type ComponentOptions = {
 }
 
 export type PropOptions = {
-  type: Function | Array<Function> | null
-  default: any
-  required: boolean | null
-  validator: Function | null
+  type?: Function | Array<Function> | null
+  default?: any
+  required?: boolean | null
+  validator?: Function | null
 }
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index e4cadb10678..811453b996a 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -1,7 +1,14 @@
 import { Component } from 'types/component'
+import { PropOptions } from 'types/options'
 import { def, invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
-import { bind, emptyObject, isFunction, isObject } from '../shared/util'
+import {
+  bind,
+  emptyObject,
+  isArray,
+  isFunction,
+  isObject
+} from '../shared/util'
 import { currentInstance, setCurrentInstance } from './currentInstance'
 import { isRef } from './reactivity/ref'
 
@@ -193,3 +200,35 @@ function getContext(): SetupContext {
   const vm = currentInstance!
   return vm._setupContext || (vm._setupContext = createSetupContext(vm))
 }
+
+/**
+ * Runtime helper for merging default declarations. Imported by compiled code
+ * only.
+ * @internal
+ */
+export function mergeDefaults(
+  raw: string[] | Record<string, PropOptions>,
+  defaults: Record<string, any>
+): Record<string, PropOptions> {
+  const props = isArray(raw)
+    ? raw.reduce(
+        (normalized, p) => ((normalized[p] = {}), normalized),
+        {} as Record<string, PropOptions>
+      )
+    : raw
+  for (const key in defaults) {
+    const opt = props[key]
+    if (opt) {
+      if (isArray(opt) || isFunction(opt)) {
+        props[key] = { type: opt, default: defaults[key] }
+      } else {
+        opt.default = defaults[key]
+      }
+    } else if (opt === null) {
+      props[key] = { default: defaults[key] }
+    } else if (__DEV__) {
+      warn(`props default key "${key}" has no corresponding declaration.`)
+    }
+  }
+  return props
+}
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 67aafc5fd12..909bd0258ec 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -179,10 +179,8 @@ function doWatch(
 
   const warnInvalidSource = (s: unknown) => {
     warn(
-      `Invalid watch source: `,
-      s,
-      `A watch source can only be a getter/effect function, a ref, ` +
-        `a reactive object, or an array of these types.`
+      `Invalid watch source: ${s}. A watch source can only be a getter/effect ` +
+        `function, a ref, a reactive object, or an array of these types.`
     )
   }
 
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 2e6a71c5bf2..7a9779eedb5 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -70,7 +70,7 @@ export { provide, inject, InjectionKey } from './apiInject'
 
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
-export { useSlots, useAttrs } from './apiSetup'
+export { useSlots, useAttrs, mergeDefaults } from './apiSetup'
 export { nextTick } from 'core/util/next-tick'
 export { set, del } from 'core/observer'
 
diff --git a/types/index.d.ts b/types/index.d.ts
index d8722c3b8db..dd5aab503d0 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -35,6 +35,8 @@ export {
 
 export * from './v3-manual-apis'
 export * from './v3-generated'
+// <script setup> helpers
+export * from './v3-setup-helpers'
 
 export { Data } from './common'
 export { SetupContext } from './v3-setup-context'
diff --git a/types/test/setup-helpers-test.ts b/types/test/setup-helpers-test.ts
new file mode 100644
index 00000000000..744c2a5336f
--- /dev/null
+++ b/types/test/setup-helpers-test.ts
@@ -0,0 +1,134 @@
+import { useAttrs, useSlots, SetupContext } from '../index'
+import { describe, expectType } from './utils'
+
+describe('defineProps w/ type declaration', () => {
+  // type declaration
+  const props = defineProps<{
+    foo: string
+  }>()
+  // explicitly declared type should be refined
+  expectType<string>(props.foo)
+  // @ts-expect-error
+  props.bar
+})
+
+describe('defineProps w/ type declaration + withDefaults', () => {
+  const res = withDefaults(
+    defineProps<{
+      number?: number
+      arr?: string[]
+      obj?: { x: number }
+      fn?: (e: string) => void
+      x?: string
+      genStr?: string
+    }>(),
+    {
+      number: 123,
+      arr: () => [],
+      obj: () => ({ x: 123 }),
+      fn: () => {},
+      genStr: () => ''
+    }
+  )
+
+  res.number + 1
+  res.arr.push('hi')
+  res.obj.x
+  res.fn('hi')
+  // @ts-expect-error
+  res.x.slice()
+  res.genStr.slice()
+})
+
+describe('defineProps w/ union type declaration + withDefaults', () => {
+  withDefaults(
+    defineProps<{
+      union1?: number | number[] | { x: number }
+      union2?: number | number[] | { x: number }
+      union3?: number | number[] | { x: number }
+      union4?: number | number[] | { x: number }
+    }>(),
+    {
+      union1: 123,
+      union2: () => [123],
+      union3: () => ({ x: 123 }),
+      union4: () => 123
+    }
+  )
+})
+
+describe('defineProps w/ runtime declaration', () => {
+  // runtime declaration
+  const props = defineProps({
+    foo: String,
+    bar: {
+      type: Number,
+      default: 1
+    },
+    baz: {
+      type: Array,
+      required: true
+    }
+  })
+  expectType<{
+    foo?: string
+    bar: number
+    baz: unknown[]
+  }>(props)
+
+  props.foo && props.foo + 'bar'
+  props.bar + 1
+  // @ts-expect-error should be readonly
+  props.bar++
+  props.baz.push(1)
+
+  const props2 = defineProps(['foo', 'bar'])
+  props2.foo + props2.bar
+  // @ts-expect-error
+  props2.baz
+})
+
+describe('defineEmits w/ type declaration', () => {
+  const emit = defineEmits<(e: 'change') => void>()
+  emit('change')
+  // @ts-expect-error
+  emit()
+  // @ts-expect-error
+  emit('bar')
+
+  type Emits = { (e: 'foo' | 'bar'): void; (e: 'baz', id: number): void }
+  const emit2 = defineEmits<Emits>()
+
+  emit2('foo')
+  emit2('bar')
+  emit2('baz', 123)
+  // @ts-expect-error
+  emit2('baz')
+})
+
+describe('defineEmits w/ runtime declaration', () => {
+  const emit = defineEmits({
+    foo: () => {},
+    bar: null
+  })
+  emit('foo')
+  emit('bar', 123)
+  // @ts-expect-error
+  emit('baz')
+
+  const emit2 = defineEmits(['foo', 'bar'])
+  emit2('foo')
+  emit2('bar', 123)
+  // @ts-expect-error
+  emit2('baz')
+})
+
+describe('useAttrs', () => {
+  const attrs = useAttrs()
+  expectType<Record<string, unknown>>(attrs)
+})
+
+describe('useSlots', () => {
+  const slots = useSlots()
+  expectType<SetupContext['slots']>(slots)
+})
diff --git a/types/v3-setup-helpers.d.ts b/types/v3-setup-helpers.d.ts
new file mode 100644
index 00000000000..6a62fd16fe1
--- /dev/null
+++ b/types/v3-setup-helpers.d.ts
@@ -0,0 +1,150 @@
+import { EmitFn, EmitsOptions } from './v3-setup-context'
+import {
+  ComponentObjectPropsOptions,
+  ExtractPropTypes
+} from './v3-component-props'
+
+/**
+ * Vue `<script setup>` compiler macro for declaring component props. The
+ * expected argument is the same as the component `props` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * // using Array syntax
+ * const props = defineProps(['foo', 'bar'])
+ * // using Object syntax
+ * const props = defineProps({
+ *   foo: String,
+ *   bar: {
+ *     type: Number,
+ *     required: true
+ *   }
+ * })
+ * ```
+ *
+ * Equivalent type-based declaration:
+ * ```ts
+ * // will be compiled into equivalent runtime declarations
+ * const props = defineProps<{
+ *   foo?: string
+ *   bar: number
+ * }>()
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+// overload 1: runtime props w/ array
+export function defineProps<PropNames extends string = string>(
+  props: PropNames[]
+): Readonly<{ [key in PropNames]?: any }>
+// overload 2: runtime props w/ object
+export function defineProps<
+  PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions
+>(props: PP): Readonly<ExtractPropTypes<PP>>
+// overload 3: typed-based declaration
+export function defineProps<TypeProps>(): Readonly<TypeProps>
+
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's emitted
+ * events. The expected argument is the same as the component `emits` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * const emit = defineEmits(['change', 'update'])
+ * ```
+ *
+ * Example type-based declaration:
+ * ```ts
+ * const emit = defineEmits<{
+ *   (event: 'change'): void
+ *   (event: 'update', id: number): void
+ * }>()
+ *
+ * emit('change')
+ * emit('update', 1)
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+// overload 1: runtime emits w/ array
+export function defineEmits<EE extends string = string>(
+  emitOptions: EE[]
+): EmitFn<EE[]>
+export function defineEmits<E extends EmitsOptions = EmitsOptions>(
+  emitOptions: E
+): EmitFn<E>
+export function defineEmits<TypeEmit>(): TypeEmit
+
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's exposed
+ * instance properties when it is accessed by a parent component via template
+ * refs.
+ *
+ * `<script setup>` components are closed by default - i.e. variables inside
+ * the `<script setup>` scope is not exposed to parent unless explicitly exposed
+ * via `defineExpose`.
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+export function defineExpose<
+  Exposed extends Record<string, any> = Record<string, any>
+>(exposed?: Exposed): void
+
+type NotUndefined<T> = T extends undefined ? never : T
+
+type InferDefaults<T> = {
+  [K in keyof T]?: InferDefault<T, NotUndefined<T[K]>>
+}
+
+type InferDefault<P, T> = T extends
+  | null
+  | number
+  | string
+  | boolean
+  | symbol
+  | Function
+  ? T | ((props: P) => T)
+  : (props: P) => T
+
+type PropsWithDefaults<Base, Defaults> = Base & {
+  [K in keyof Defaults]: K extends keyof Base ? NotUndefined<Base[K]> : never
+}
+
+/**
+ * Vue `<script setup>` compiler macro for providing props default values when
+ * using type-based `defineProps` declaration.
+ *
+ * Example usage:
+ * ```ts
+ * withDefaults(defineProps<{
+ *   size?: number
+ *   labels?: string[]
+ * }>(), {
+ *   size: 3,
+ *   labels: () => ['default label']
+ * })
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the output
+ * and should **not** be actually called at runtime.
+ */
+export function withDefaults<Props, Defaults extends InferDefaults<Props>>(
+  props: Props,
+  defaults: Defaults
+): PropsWithDefaults<Props, Defaults>
+
+// make them global
+type _defineProps = typeof defineProps
+type _defineEmits = typeof defineEmits
+type _defineExpose = typeof defineExpose
+type _withDefaults = typeof withDefaults
+
+declare global {
+  const defineProps: _defineProps
+  const defineEmits: _defineEmits
+  const defineExpose: _defineExpose
+  const withDefaults: _withDefaults
+}

From 5a0cc58b91f64f8f2f6088a456f0cf3a0a8f0be2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 10:36:19 +0800
Subject: [PATCH 154/317] release: v2.7.0-alpha.9

---
 CHANGELOG.md                            | 12 ++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1cc9e170ca7..cd4b276c722 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+# [2.7.0-alpha.9](https://github.com/vuejs/vue/compare/v2.7.0-alpha.8...v2.7.0-alpha.9) (2022-06-16)
+
+
+### Features
+
+* defineExpose() support ([3c2707b](https://github.com/vuejs/vue/commit/3c2707b62e1a355f182c08f85cf7bc9bca1bb34e))
+* directive resolution for `<script setup>` ([aa2b1f4](https://github.com/vuejs/vue/commit/aa2b1f4d93bdd257ae26a73994168709369aa6a0))
+* resolve components from `<script setup>` ([4b19339](https://github.com/vuejs/vue/commit/4b193390fbc203cc5bae46fe288b1c20c442cc03))
+* types for `<script setup>` macros ([7173ad4](https://github.com/vuejs/vue/commit/7173ad42729fa0913c3e7de94d251341929ee7c6))
+
+
+
 # [2.7.0-alpha.8](https://github.com/vuejs/vue/compare/v2.7.0-alpha.7...v2.7.0-alpha.8) (2022-06-14)
 
 ### Features
diff --git a/package.json b/package.json
index 6ffe8fa6646..9e4991e39a5 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.8",
+  "version": "2.7.0-alpha.9",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 256fea44750..8c5ef8affe0 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.8",
+  "version": "2.7.0-alpha.9",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 0dec62476b4..01cd134e0b7 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.8",
+  "version": "2.7.0-alpha.9",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index ad34d094102..9c31c53cd35 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.8",
+  "version": "2.7.0-alpha.9",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 749b96d84e6551c5187694a93c5493702035a239 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 11:17:09 +0800
Subject: [PATCH 155/317] feat: export version as named export

---
 src/core/index.ts | 3 ++-
 src/v3/index.ts   | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/core/index.ts b/src/core/index.ts
index 2ce6c9d604a..6dc63950ccb 100644
--- a/src/core/index.ts
+++ b/src/core/index.ts
@@ -2,6 +2,7 @@ import Vue from './instance/index'
 import { initGlobalAPI } from './global-api/index'
 import { isServerRendering } from 'core/util/env'
 import { FunctionalRenderContext } from 'core/vdom/create-functional-component'
+import { version } from 'v3'
 
 initGlobalAPI(Vue)
 
@@ -21,6 +22,6 @@ Object.defineProperty(Vue, 'FunctionalRenderContext', {
   value: FunctionalRenderContext
 })
 
-Vue.version = '__VERSION__'
+Vue.version = version
 
 export default Vue
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 7a9779eedb5..1c521e463c7 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -1,3 +1,5 @@
+export const version: string = '__VERSION__'
+
 export {
   ref,
   shallowRef,

From cdfd9f321e35981774785806bb1629a73ec58064 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 14:16:36 +0800
Subject: [PATCH 156/317] fix: avoid warning when accessing _setupProxy

---
 packages/compiler-sfc/src/prefixIdentifiers.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/src/prefixIdentifiers.ts b/packages/compiler-sfc/src/prefixIdentifiers.ts
index a756b4ba6e5..01ef3a3ad21 100644
--- a/packages/compiler-sfc/src/prefixIdentifiers.ts
+++ b/packages/compiler-sfc/src/prefixIdentifiers.ts
@@ -64,7 +64,7 @@ export function prefixIdentifiers(
           s.prependRight(
             node.start!,
             `var _vm=this,_c=_vm._self._c${
-              isScriptSetup ? `,_setup=_vm._setupProxy;` : `;`
+              isScriptSetup ? `,_setup=_vm._self._setupProxy;` : `;`
             }`
           )
         }

From b3432ffa8f18134f9564da79ddd909c23d6a6ce8 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 14:17:30 +0800
Subject: [PATCH 157/317] chore: fix snapshot

---
 packages/compiler-sfc/test/prefixIdentifiers.spec.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
index 0a1ee2351b2..f9bc93978c7 100644
--- a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
+++ b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
@@ -68,7 +68,7 @@ it('setup bindings', () => {
     }
   )
 
-  expect(result).toMatch(`_setup = _vm._setupProxy`)
+  expect(result).toMatch(`_setup = _vm._self._setupProxy`)
   expect(result).toMatch(`_setup.count++`)
   expect(result).toMatch(`_vm._s(_setup.count)`)
 
@@ -76,7 +76,7 @@ it('setup bindings', () => {
     "function render() {
       var _vm = this,
         _c = _vm._self._c,
-        _setup = _vm._setupProxy
+        _setup = _vm._self._setupProxy
       return _c(
         \\"div\\",
         {

From 457fe6d222dbdefadfd996a2f964e4d8df013144 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 17:16:33 +0800
Subject: [PATCH 158/317] types: align compiler-sfc type exports with v3

---
 packages/compiler-sfc/src/compileScript.ts   |  4 ++--
 packages/compiler-sfc/src/compileStyle.ts    | 24 ++++++++++----------
 packages/compiler-sfc/src/compileTemplate.ts | 14 ++++++------
 packages/compiler-sfc/src/index.ts           |  8 +++----
 4 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 354aa40b62b..bc078806f54 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -57,7 +57,7 @@ const isBuiltInDir = makeMap(
   `once,memo,if,for,else,else-if,slot,text,html,on,bind,model,show,cloak,is`
 )
 
-export interface ScriptCompileOptions {
+export interface SFCScriptCompileOptions {
   /**
    * Production mode. Used to determine whether to generate hashed CSS variables
    */
@@ -87,7 +87,7 @@ export interface ImportBinding {
  */
 export function compileScript(
   sfc: SFCDescriptor,
-  options: ScriptCompileOptions = {}
+  options: SFCScriptCompileOptions = {}
 ): SFCScriptBlock {
   let { filename, script, scriptSetup, source } = sfc
   const isProd = !!options.isProd
diff --git a/packages/compiler-sfc/src/compileStyle.ts b/packages/compiler-sfc/src/compileStyle.ts
index 8418afc7483..0b1e8a33cfe 100644
--- a/packages/compiler-sfc/src/compileStyle.ts
+++ b/packages/compiler-sfc/src/compileStyle.ts
@@ -8,7 +8,7 @@ import {
   StylePreprocessorResults
 } from './stylePreprocessors'
 
-export interface StyleCompileOptions {
+export interface SFCStyleCompileOptions {
   source: string
   filename: string
   id: string
@@ -21,11 +21,11 @@ export interface StyleCompileOptions {
   postcssPlugins?: any[]
 }
 
-export interface AsyncStyleCompileOptions extends StyleCompileOptions {
+export interface SFCAsyncStyleCompileOptions extends SFCStyleCompileOptions {
   isAsync?: boolean
 }
 
-export interface StyleCompileResults {
+export interface SFCStyleCompileResults {
   code: string
   map: any | void
   rawResult: LazyResult | void
@@ -33,20 +33,20 @@ export interface StyleCompileResults {
 }
 
 export function compileStyle(
-  options: StyleCompileOptions
-): StyleCompileResults {
+  options: SFCStyleCompileOptions
+): SFCStyleCompileResults {
   return doCompileStyle({ ...options, isAsync: false })
 }
 
 export function compileStyleAsync(
-  options: StyleCompileOptions
-): Promise<StyleCompileResults> {
+  options: SFCStyleCompileOptions
+): Promise<SFCStyleCompileResults> {
   return Promise.resolve(doCompileStyle({ ...options, isAsync: true }))
 }
 
 export function doCompileStyle(
-  options: AsyncStyleCompileOptions
-): StyleCompileResults {
+  options: SFCAsyncStyleCompileOptions
+): SFCStyleCompileResults {
   const {
     filename,
     id,
@@ -94,7 +94,7 @@ export function doCompileStyle(
     if (options.isAsync) {
       return result
         .then(
-          (result: LazyResult): StyleCompileResults => ({
+          (result: LazyResult): SFCStyleCompileResults => ({
             code: result.css || '',
             map: result.map && result.map.toJSON(),
             errors,
@@ -102,7 +102,7 @@ export function doCompileStyle(
           })
         )
         .catch(
-          (error: Error): StyleCompileResults => ({
+          (error: Error): SFCStyleCompileResults => ({
             code: '',
             map: undefined,
             errors: [...errors, error.message],
@@ -127,7 +127,7 @@ export function doCompileStyle(
 }
 
 function preprocess(
-  options: StyleCompileOptions,
+  options: SFCStyleCompileOptions,
   preprocessor: StylePreprocessor
 ): StylePreprocessorResults {
   return preprocessor(
diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index 69c4cdd5903..d88adc02593 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -13,7 +13,7 @@ import * as _compiler from 'web/entry-compiler'
 import { prefixIdentifiers } from './prefixIdentifiers'
 import { WarningMessage } from 'types/compiler'
 
-export interface TemplateCompileOptions {
+export interface SFCTemplateCompileOptions {
   source: string
   filename: string
   compiler?: VueTemplateCompiler
@@ -31,7 +31,7 @@ export interface TemplateCompileOptions {
   bindings?: BindingMetadata
 }
 
-export interface TemplateCompileResult {
+export interface SFCTemplateCompileResult {
   ast: Object | undefined
   code: string
   source: string
@@ -40,8 +40,8 @@ export interface TemplateCompileResult {
 }
 
 export function compileTemplate(
-  options: TemplateCompileOptions
-): TemplateCompileResult {
+  options: SFCTemplateCompileOptions
+): SFCTemplateCompileResult {
   const { preprocessLang } = options
   const preprocessor = preprocessLang && consolidate[preprocessLang]
   if (preprocessor) {
@@ -68,7 +68,7 @@ export function compileTemplate(
 }
 
 function preprocess(
-  options: TemplateCompileOptions,
+  options: SFCTemplateCompileOptions,
   preprocessor: any
 ): string {
   const { source, filename, preprocessOptions } = options
@@ -99,8 +99,8 @@ function preprocess(
 }
 
 function actuallyCompile(
-  options: TemplateCompileOptions
-): TemplateCompileResult {
+  options: SFCTemplateCompileOptions
+): SFCTemplateCompileResult {
   const {
     source,
     compiler = _compiler,
diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index 57f1af07152..083a3ba3498 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -8,8 +8,8 @@ export { generateCodeFrame } from 'compiler/codeframe'
 // types
 export { SFCBlock, SFCCustomBlock, SFCDescriptor } from './parseComponent'
 export {
-  TemplateCompileOptions,
-  TemplateCompileResult
+  SFCTemplateCompileOptions,
+  SFCTemplateCompileResult
 } from './compileTemplate'
-export { StyleCompileOptions, StyleCompileResults } from './compileStyle'
-export { ScriptCompileOptions } from './compileScript'
+export { SFCStyleCompileOptions, SFCStyleCompileResults } from './compileStyle'
+export { SFCScriptCompileOptions } from './compileScript'

From fa2115c0310037aa09d968de7f3bc604c53d343f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 17:18:28 +0800
Subject: [PATCH 159/317] release: v2.7.0-alpha.10

---
 CHANGELOG.md                            | 14 ++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cd4b276c722..26acc409a40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,17 @@
+# [2.7.0-alpha.10](https://github.com/vuejs/vue/compare/v2.7.0-alpha.9...v2.7.0-alpha.10) (2022-06-16)
+
+
+### Bug Fixes
+
+* avoid warning when accessing _setupProxy ([cdfd9f3](https://github.com/vuejs/vue/commit/cdfd9f321e35981774785806bb1629a73ec58064))
+
+
+### Features
+
+* export version as named export ([749b96d](https://github.com/vuejs/vue/commit/749b96d84e6551c5187694a93c5493702035a239))
+
+
+
 # [2.7.0-alpha.9](https://github.com/vuejs/vue/compare/v2.7.0-alpha.8...v2.7.0-alpha.9) (2022-06-16)
 
 
diff --git a/package.json b/package.json
index 9e4991e39a5..ad42cbfa3c8 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.9",
+  "version": "2.7.0-alpha.10",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 8c5ef8affe0..9d2606e3afb 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.9",
+  "version": "2.7.0-alpha.10",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 01cd134e0b7..08995207fac 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.9",
+  "version": "2.7.0-alpha.10",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 9c31c53cd35..382e081d486 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.9",
+  "version": "2.7.0-alpha.10",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 2726b6d9ff3030af63012a304c33781163461a23 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 17:45:33 +0800
Subject: [PATCH 160/317] fix: further align types with v3

---
 packages/compiler-sfc/src/compileTemplate.ts | 18 +++++++----------
 packages/compiler-sfc/src/index.ts           | 11 ++++++++--
 packages/compiler-sfc/src/parse.ts           |  4 ++--
 packages/compiler-sfc/src/types.ts           | 21 +++-----------------
 4 files changed, 21 insertions(+), 33 deletions(-)

diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index d88adc02593..68e5be350a0 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -1,8 +1,4 @@
-import {
-  BindingMetadata,
-  VueTemplateCompiler,
-  VueTemplateCompilerOptions
-} from './types'
+import { BindingMetadata, TemplateCompiler } from './types'
 import assetUrlsModule, {
   AssetURLOptions,
   TransformAssetUrlsOptions
@@ -11,13 +7,13 @@ import srcsetModule from './templateCompilerModules/srcset'
 import consolidate from '@vue/consolidate'
 import * as _compiler from 'web/entry-compiler'
 import { prefixIdentifiers } from './prefixIdentifiers'
-import { WarningMessage } from 'types/compiler'
+import { CompilerOptions, WarningMessage } from 'types/compiler'
 
 export interface SFCTemplateCompileOptions {
   source: string
   filename: string
-  compiler?: VueTemplateCompiler
-  compilerOptions?: VueTemplateCompilerOptions
+  compiler?: TemplateCompiler
+  compilerOptions?: CompilerOptions
   transformAssetUrls?: AssetURLOptions | boolean
   transformAssetUrlsOptions?: TransformAssetUrlsOptions
   preprocessLang?: string
@@ -31,7 +27,7 @@ export interface SFCTemplateCompileOptions {
   bindings?: BindingMetadata
 }
 
-export interface SFCTemplateCompileResult {
+export interface SFCTemplateCompileResults {
   ast: Object | undefined
   code: string
   source: string
@@ -41,7 +37,7 @@ export interface SFCTemplateCompileResult {
 
 export function compileTemplate(
   options: SFCTemplateCompileOptions
-): SFCTemplateCompileResult {
+): SFCTemplateCompileResults {
   const { preprocessLang } = options
   const preprocessor = preprocessLang && consolidate[preprocessLang]
   if (preprocessor) {
@@ -100,7 +96,7 @@ function preprocess(
 
 function actuallyCompile(
   options: SFCTemplateCompileOptions
-): SFCTemplateCompileResult {
+): SFCTemplateCompileResults {
   const {
     source,
     compiler = _compiler,
diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index 083a3ba3498..c682912768c 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -6,10 +6,17 @@ export { compileScript } from './compileScript'
 export { generateCodeFrame } from 'compiler/codeframe'
 
 // types
-export { SFCBlock, SFCCustomBlock, SFCDescriptor } from './parseComponent'
+export { CompilerOptions } from 'types/compiler'
+export { TemplateCompiler } from './types'
+export {
+  SFCBlock,
+  SFCCustomBlock,
+  SFCScriptBlock,
+  SFCDescriptor
+} from './parseComponent'
 export {
   SFCTemplateCompileOptions,
-  SFCTemplateCompileResult
+  SFCTemplateCompileResults
 } from './compileTemplate'
 export { SFCStyleCompileOptions, SFCStyleCompileResults } from './compileStyle'
 export { SFCScriptCompileOptions } from './compileScript'
diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index bd6381d13e5..48209e89853 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -1,5 +1,5 @@
 import { SourceMapGenerator } from 'source-map'
-import { RawSourceMap, VueTemplateCompiler } from './types'
+import { RawSourceMap, TemplateCompiler } from './types'
 import {
   parseComponent,
   VueTemplateCompilerParseOptions,
@@ -19,7 +19,7 @@ const emptyRE = /^(?:\/\/)?\s*$/
 export interface ParseOptions {
   source: string
   filename?: string
-  compiler?: VueTemplateCompiler
+  compiler?: TemplateCompiler
   compilerParseOptions?: VueTemplateCompilerParseOptions
   sourceRoot?: string
   needMap?: boolean
diff --git a/packages/compiler-sfc/src/types.ts b/packages/compiler-sfc/src/types.ts
index 93564db3ca3..c62f74c7bb7 100644
--- a/packages/compiler-sfc/src/types.ts
+++ b/packages/compiler-sfc/src/types.ts
@@ -14,27 +14,12 @@ export interface RawSourceMap extends StartOfSourceMap {
   mappings: string
 }
 
-export interface VueTemplateCompiler {
+export interface TemplateCompiler {
   parseComponent(source: string, options?: any): SFCDescriptor
-
-  compile(
-    template: string,
-    options: VueTemplateCompilerOptions
-  ): VueTemplateCompilerResults
-
-  ssrCompile(
-    template: string,
-    options: VueTemplateCompilerOptions
-  ): VueTemplateCompilerResults
+  compile(template: string, options: CompilerOptions): CompiledResult
+  ssrCompile(template: string, options: CompilerOptions): CompiledResult
 }
 
-// we'll just shim this much for now - in the future these types
-// should come from vue-template-compiler directly, or this package should be
-// part of the vue monorepo.
-export type VueTemplateCompilerOptions = CompilerOptions
-
-export type VueTemplateCompilerResults = CompiledResult
-
 export const enum BindingTypes {
   /**
    * returned from data()

From ac8882715cbdfd44c00066f65a2ff3557eb279f7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 17:53:41 +0800
Subject: [PATCH 161/317] release: v2.7.0-alpha.11

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 26acc409a40..9f0f7bdac02 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-alpha.11](https://github.com/vuejs/vue/compare/v2.7.0-alpha.10...v2.7.0-alpha.11) (2022-06-16)
+
+
+### Bug Fixes
+
+* further align types with v3 ([2726b6d](https://github.com/vuejs/vue/commit/2726b6d9ff3030af63012a304c33781163461a23))
+
+
+
 # [2.7.0-alpha.10](https://github.com/vuejs/vue/compare/v2.7.0-alpha.9...v2.7.0-alpha.10) (2022-06-16)
 
 
diff --git a/package.json b/package.json
index ad42cbfa3c8..abfd4ccf6d4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.10",
+  "version": "2.7.0-alpha.11",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 9d2606e3afb..ec32f7daee7 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.10",
+  "version": "2.7.0-alpha.11",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 08995207fac..ee4ff4ad327 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.10",
+  "version": "2.7.0-alpha.11",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 382e081d486..283ba0a3463 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.10",
+  "version": "2.7.0-alpha.11",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 8ce585d70c2e1adb04650801b03dcc9552cbaf95 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 21:28:02 +0800
Subject: [PATCH 162/317] feat: further align compiler-sfc api + expose
 rewriteDefault

---
 packages/compiler-sfc/src/index.ts          |   3 +-
 packages/compiler-sfc/src/parse.ts          |   6 +-
 packages/compiler-sfc/src/parseComponent.ts |   2 +-
 packages/compiler-sfc/src/rewriteDefault.ts | 110 ++++++++++++++++++++
 4 files changed, 116 insertions(+), 5 deletions(-)
 create mode 100644 packages/compiler-sfc/src/rewriteDefault.ts

diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index c682912768c..e98d4b6e22b 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -4,9 +4,10 @@ export { compileTemplate } from './compileTemplate'
 export { compileStyle, compileStyleAsync } from './compileStyle'
 export { compileScript } from './compileScript'
 export { generateCodeFrame } from 'compiler/codeframe'
+export { rewriteDefault } from './rewriteDefault'
 
 // types
-export { CompilerOptions } from 'types/compiler'
+export { CompilerOptions, WarningMessage } from 'types/compiler'
 export { TemplateCompiler } from './types'
 export {
   SFCBlock,
diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index 48209e89853..ba19739603a 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -22,7 +22,7 @@ export interface ParseOptions {
   compiler?: TemplateCompiler
   compilerParseOptions?: VueTemplateCompilerParseOptions
   sourceRoot?: string
-  needMap?: boolean
+  sourceMap?: boolean
 }
 
 export function parse(options: ParseOptions): SFCDescriptor {
@@ -32,7 +32,7 @@ export function parse(options: ParseOptions): SFCDescriptor {
     compiler,
     compilerParseOptions = { pad: false } as VueTemplateCompilerParseOptions,
     sourceRoot = '',
-    needMap = true
+    sourceMap = true
   } = options
   const cacheKey = hash(
     filename + source + JSON.stringify(compilerParseOptions)
@@ -55,7 +55,7 @@ export function parse(options: ParseOptions): SFCDescriptor {
   output.shouldForceReload = prevImports =>
     hmrShouldReload(prevImports, output!)
 
-  if (needMap) {
+  if (sourceMap) {
     if (output.script && !output.script.src) {
       output.script.map = generateSourceMap(
         filename,
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index a396bbfe7b4..aed55fd0083 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -17,12 +17,12 @@ export interface SFCCustomBlock {
   attrs: { [key: string]: string | true }
   start: number
   end: number
+  src?: string
   map?: RawSourceMap
 }
 
 export interface SFCBlock extends SFCCustomBlock {
   lang?: string
-  src?: string
   scoped?: boolean
   module?: string | boolean
 }
diff --git a/packages/compiler-sfc/src/rewriteDefault.ts b/packages/compiler-sfc/src/rewriteDefault.ts
new file mode 100644
index 00000000000..ced9f56d8a9
--- /dev/null
+++ b/packages/compiler-sfc/src/rewriteDefault.ts
@@ -0,0 +1,110 @@
+import { parse, ParserPlugin } from '@babel/parser'
+import MagicString from 'magic-string'
+
+const defaultExportRE = /((?:^|\n|;)\s*)export(\s*)default/
+const namedDefaultExportRE = /((?:^|\n|;)\s*)export(.+)(?:as)?(\s*)default/s
+const exportDefaultClassRE =
+  /((?:^|\n|;)\s*)export\s+default\s+class\s+([\w$]+)/
+
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export function rewriteDefault(
+  input: string,
+  as: string,
+  parserPlugins?: ParserPlugin[]
+): string {
+  if (!hasDefaultExport(input)) {
+    return input + `\nconst ${as} = {}`
+  }
+
+  let replaced: string | undefined
+
+  const classMatch = input.match(exportDefaultClassRE)
+  if (classMatch) {
+    replaced =
+      input.replace(exportDefaultClassRE, '$1class $2') +
+      `\nconst ${as} = ${classMatch[2]}`
+  } else {
+    replaced = input.replace(defaultExportRE, `$1const ${as} =`)
+  }
+  if (!hasDefaultExport(replaced)) {
+    return replaced
+  }
+
+  // if the script somehow still contains `default export`, it probably has
+  // multi-line comments or template strings. fallback to a full parse.
+  const s = new MagicString(input)
+  const ast = parse(input, {
+    sourceType: 'module',
+    plugins: parserPlugins
+  }).program.body
+  ast.forEach(node => {
+    if (node.type === 'ExportDefaultDeclaration') {
+      s.overwrite(node.start!, node.declaration.start!, `const ${as} = `)
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      for (const specifier of node.specifiers) {
+        if (
+          specifier.type === 'ExportSpecifier' &&
+          specifier.exported.type === 'Identifier' &&
+          specifier.exported.name === 'default'
+        ) {
+          if (node.source) {
+            if (specifier.local.name === 'default') {
+              const end = specifierEnd(input, specifier.local.end!, node.end)
+              s.prepend(
+                `import { default as __VUE_DEFAULT__ } from '${node.source.value}'\n`
+              )
+              s.overwrite(specifier.start!, end, ``)
+              s.append(`\nconst ${as} = __VUE_DEFAULT__`)
+              continue
+            } else {
+              const end = specifierEnd(input, specifier.exported.end!, node.end)
+              s.prepend(
+                `import { ${input.slice(
+                  specifier.local.start!,
+                  specifier.local.end!
+                )} } from '${node.source.value}'\n`
+              )
+              s.overwrite(specifier.start!, end, ``)
+              s.append(`\nconst ${as} = ${specifier.local.name}`)
+              continue
+            }
+          }
+          const end = specifierEnd(input, specifier.end!, node.end)
+          s.overwrite(specifier.start!, end, ``)
+          s.append(`\nconst ${as} = ${specifier.local.name}`)
+        }
+      }
+    }
+  })
+  return s.toString()
+}
+
+export function hasDefaultExport(input: string): boolean {
+  return defaultExportRE.test(input) || namedDefaultExportRE.test(input)
+}
+
+function specifierEnd(
+  input: string,
+  end: number,
+  nodeEnd: number | undefined | null
+) {
+  // export { default   , foo } ...
+  let hasCommas = false
+  let oldEnd = end
+  while (end < nodeEnd!) {
+    if (/\s/.test(input.charAt(end))) {
+      end++
+    } else if (input.charAt(end) === ',') {
+      end++
+      hasCommas = true
+      break
+    } else if (input.charAt(end) === '}') {
+      break
+    }
+  }
+  return hasCommas ? end : oldEnd
+}

From 96cd1d03fd8da5bcc975b82d39ce69383c1de0ab Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 21:52:59 +0800
Subject: [PATCH 163/317] release: v2.7.0-alpha.12

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f0f7bdac02..12d3bd46dc5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-alpha.12](https://github.com/vuejs/vue/compare/v2.7.0-alpha.11...v2.7.0-alpha.12) (2022-06-16)
+
+
+### Features
+
+* further align compiler-sfc api + expose rewriteDefault ([8ce585d](https://github.com/vuejs/vue/commit/8ce585d70c2e1adb04650801b03dcc9552cbaf95))
+
+
+
 # [2.7.0-alpha.11](https://github.com/vuejs/vue/compare/v2.7.0-alpha.10...v2.7.0-alpha.11) (2022-06-16)
 
 
diff --git a/package.json b/package.json
index abfd4ccf6d4..e7166e73b9a 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.11",
+  "version": "2.7.0-alpha.12",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index ec32f7daee7..ad50541ce10 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.11",
+  "version": "2.7.0-alpha.12",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index ee4ff4ad327..cf5e20bd141 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.11",
+  "version": "2.7.0-alpha.12",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 283ba0a3463..129f1d7b135 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.11",
+  "version": "2.7.0-alpha.12",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 8f5817a7c9a0664438e4299f82ac41a67f156f89 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 16 Jun 2022 22:59:14 +0800
Subject: [PATCH 164/317] feat(compiler-sfc): support includeAbsolute in
 transformAssetUrl

---
 .../compiler-sfc/src/templateCompilerModules/assetUrl.ts   | 4 ++++
 packages/compiler-sfc/src/templateCompilerModules/utils.ts | 7 ++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts b/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
index 07f8eb9fff8..71e3cfa2fe9 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/assetUrl.ts
@@ -13,6 +13,10 @@ export interface TransformAssetUrlsOptions {
    * imports, they will be directly rewritten to absolute urls.
    */
   base?: string
+  /**
+   * If true, also processes absolute urls.
+   */
+  includeAbsolute?: boolean
 }
 
 const defaultOptions: AssetURLOptions = {
diff --git a/packages/compiler-sfc/src/templateCompilerModules/utils.ts b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
index 859c5f456b6..d7831c84353 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/utils.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
@@ -31,7 +31,12 @@ export function urlToRequire(
     return returnValue
   }
 
-  if (firstChar === '.' || firstChar === '~' || firstChar === '@') {
+  if (
+    transformAssetUrlsOption.includeAbsolute ||
+    firstChar === '.' ||
+    firstChar === '~' ||
+    firstChar === '@'
+  ) {
     if (!uriParts.hash) {
       return `require("${url}")`
     } else {

From cdfc4c134ddadc33f3b50d53ec6316b0c96f4567 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 17 Jun 2022 09:36:34 +0800
Subject: [PATCH 165/317] fix(compiler-sfc): expose src on custom blocks as
 well

---
 packages/compiler-sfc/src/parseComponent.ts       | 8 +++++---
 packages/compiler-sfc/test/parseComponent.spec.ts | 6 +++++-
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index aed55fd0083..d17345df520 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -125,6 +125,11 @@ export function parseComponent(
           return cumulated
         }, {})
       }
+
+      if (typeof currentBlock.attrs.src === 'string') {
+        currentBlock.src = currentBlock.attrs.src
+      }
+
       if (isSpecialTag(tag)) {
         checkAttrs(currentBlock, attrs)
         if (tag === 'script') {
@@ -162,9 +167,6 @@ export function parseComponent(
       if (attr.name === 'module') {
         block.module = attr.value || true
       }
-      if (attr.name === 'src') {
-        block.src = attr.value
-      }
     }
   }
 
diff --git a/packages/compiler-sfc/test/parseComponent.spec.ts b/packages/compiler-sfc/test/parseComponent.spec.ts
index 206e55677e4..4624bb2040d 100644
--- a/packages/compiler-sfc/test/parseComponent.spec.ts
+++ b/packages/compiler-sfc/test/parseComponent.spec.ts
@@ -202,10 +202,11 @@ describe('Single File Component parser', () => {
         }))
       }
       </test>
+      <custom src="./x.json"></custom>
     `,
       { deindent: true }
     )
-    expect(res.customBlocks.length).toBe(3)
+    expect(res.customBlocks.length).toBe(4)
 
     const simpleExample = res.customBlocks[0]
     expect(simpleExample.type).toBe('example')
@@ -233,6 +234,9 @@ describe('Single File Component parser', () => {
 }`)
     expect(simpleTest.attrs.name).toBe('simple')
     expect(simpleTest.attrs.foo).toBe('bar')
+
+    const customWithSrc = res.customBlocks[3]
+    expect(customWithSrc.src).toBe('./x.json')
   })
 
   // Regression #4289

From efa8a749644cfd6a0d6e9e92a1f342e2eff77d5a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 17 Jun 2022 09:39:52 +0800
Subject: [PATCH 166/317] feat: warn top level await usage in `<script setup>`

---
 packages/compiler-sfc/src/compileScript.ts    |  86 +---
 .../__snapshots__/compileScript.spec.ts.snap  | 399 ------------------
 .../compiler-sfc/test/compileScript.spec.ts   | 118 +-----
 3 files changed, 8 insertions(+), 595 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index bc078806f54..942345ed2fb 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -30,7 +30,6 @@ import {
   CallExpression,
   RestElement,
   TSInterfaceBody,
-  AwaitExpression,
   Program,
   ObjectMethod,
   LVal,
@@ -187,7 +186,6 @@ export function compileScript(
     | undefined
   let emitsTypeDeclRaw: Node | undefined
   let emitIdentifier: string | undefined
-  let hasAwait = false
   let hasInlinedSsrRenderFn = false
   // props/emits declared via types
   const typeDeclaredProps: Record<string, PropTypeData> = {}
@@ -471,56 +469,6 @@ export function compileScript(
     })
   }
 
-  /**
-   * await foo()
-   * -->
-   * ;(
-   *   ([__temp,__restore] = withAsyncContext(() => foo())),
-   *   await __temp,
-   *   __restore()
-   * )
-   *
-   * const a = await foo()
-   * -->
-   * const a = (
-   *   ([__temp, __restore] = withAsyncContext(() => foo())),
-   *   __temp = await __temp,
-   *   __restore(),
-   *   __temp
-   * )
-   */
-  function processAwait(
-    node: AwaitExpression,
-    needSemi: boolean,
-    isStatement: boolean
-  ) {
-    const argumentStart =
-      node.argument.extra && node.argument.extra.parenthesized
-        ? (node.argument.extra.parenStart as number)
-        : node.argument.start!
-
-    const argumentStr = source.slice(
-      argumentStart + startOffset,
-      node.argument.end! + startOffset
-    )
-
-    const containsNestedAwait = /\bawait\b/.test(argumentStr)
-
-    s.overwrite(
-      node.start! + startOffset,
-      argumentStart + startOffset,
-      `${needSemi ? `;` : ``}(\n  ([__temp,__restore] = ${helper(
-        `withAsyncContext`
-      )}(${containsNestedAwait ? `async ` : ``}() => `
-    )
-    s.appendLeft(
-      node.end! + startOffset,
-      `)),\n  ${isStatement ? `` : `__temp = `}await __temp,\n  __restore()${
-        isStatement ? `` : `,\n  __temp`
-      }\n)`
-    )
-  }
-
   /**
    * check defaults. If the default object is an object literal with only
    * static properties, we can directly generate more optimized default
@@ -984,23 +932,9 @@ export function compileScript(
             scope.push(child.body)
           }
           if (child.type === 'AwaitExpression') {
-            hasAwait = true
-            // if the await expression is an expression statement and
-            // - is in the root scope
-            // - or is not the first statement in a nested block scope
-            // then it needs a semicolon before the generated code.
-            const currentScope = scope[scope.length - 1]
-            const needsSemi = currentScope.some((n, i) => {
-              return (
-                (scope.length === 1 || i > 0) &&
-                n.type === 'ExpressionStatement' &&
-                n.start === child.start
-              )
-            })
-            processAwait(
-              child,
-              needsSemi,
-              parent.type === 'ExpressionStatement'
+            error(
+              `Vue 2 does not support top level await in <script setup>.`,
+              child
             )
           }
         },
@@ -1177,11 +1111,6 @@ export function compileScript(
       )}(__props, ${JSON.stringify(Object.keys(propsDestructuredBindings))})\n`
     )
   }
-  // inject temp variables for async context preservation
-  if (hasAwait) {
-    const any = isTS ? `: any` : ``
-    s.prependLeft(startOffset, `\nlet __temp${any}, __restore${any}\n`)
-  }
 
   const destructureElements = hasDefineExposeCall ? [`expose`] : []
   if (emitIdentifier) {
@@ -1268,9 +1197,7 @@ export function compileScript(
       startOffset,
       `\nexport default /*#__PURE__*/${helper(
         `defineComponent`
-      )}({${def}${runtimeOptions}\n  ${
-        hasAwait ? `async ` : ``
-      }setup(${args}) {\n`
+      )}({${def}${runtimeOptions}\n  setup(${args}) {\n`
     )
     s.appendRight(endOffset, `})`)
   } else {
@@ -1280,14 +1207,13 @@ export function compileScript(
       s.prependLeft(
         startOffset,
         `\nexport default /*#__PURE__*/Object.assign(${DEFAULT_VAR}, {${runtimeOptions}\n  ` +
-          `${hasAwait ? `async ` : ``}setup(${args}) {\n`
+          `setup(${args}) {\n`
       )
       s.appendRight(endOffset, `})`)
     } else {
       s.prependLeft(
         startOffset,
-        `\nexport default {${runtimeOptions}\n  ` +
-          `${hasAwait ? `async ` : ``}setup(${args}) {\n`
+        `\nexport default {${runtimeOptions}\n  setup(${args}) {\n`
       )
       s.appendRight(endOffset, `}`)
     }
diff --git a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
index f1041a94019..6bad46addbc 100644
--- a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
+++ b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
@@ -168,405 +168,6 @@ return { n, x }
 })"
 `;
 
-exports[`SFC compile <script setup> > async/await detection > expression statement 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-;(
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  await __temp,
-  __restore()
-)
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > multiple \`if for\` nested statements 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-if (ok) {
-        for (let a of [1,2,3]) {
-          (
-  ([__temp,__restore] = _withAsyncContext(() => a)),
-  await __temp,
-  __restore()
-)
-        }
-        for (let a of [1,2,3]) {
-          (
-  ([__temp,__restore] = _withAsyncContext(() => a)),
-  await __temp,
-  __restore()
-)
-          ;(
-  ([__temp,__restore] = _withAsyncContext(() => a)),
-  await __temp,
-  __restore()
-)
-        }
-      }
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > multiple \`if while\` nested statements 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-if (ok) {
-        while (d) {
-          (
-  ([__temp,__restore] = _withAsyncContext(() => 5)),
-  await __temp,
-  __restore()
-)
-        }
-        while (d) {
-          (
-  ([__temp,__restore] = _withAsyncContext(() => 5)),
-  await __temp,
-  __restore()
-)
-          ;(
-  ([__temp,__restore] = _withAsyncContext(() => 6)),
-  await __temp,
-  __restore()
-)
-          if (c) {
-            let f = 10
-            10 + (
-  ([__temp,__restore] = _withAsyncContext(() => 7)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)
-          } else {
-            (
-  ([__temp,__restore] = _withAsyncContext(() => 8)),
-  await __temp,
-  __restore()
-)
-            ;(
-  ([__temp,__restore] = _withAsyncContext(() => 9)),
-  await __temp,
-  __restore()
-)
-          }
-        }
-      }
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > multiple \`if\` nested statements 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-if (ok) {
-        let a = 'foo'
-        ;(
-  ([__temp,__restore] = _withAsyncContext(() => 0)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-) + (
-  ([__temp,__restore] = _withAsyncContext(() => 1)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)
-        ;(
-  ([__temp,__restore] = _withAsyncContext(() => 2)),
-  await __temp,
-  __restore()
-)
-      } else if (a) {
-        (
-  ([__temp,__restore] = _withAsyncContext(() => 10)),
-  await __temp,
-  __restore()
-)
-        if (b) {
-          (
-  ([__temp,__restore] = _withAsyncContext(() => 0)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-) + (
-  ([__temp,__restore] = _withAsyncContext(() => 1)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)
-        } else {
-          let a = 'foo'
-          ;(
-  ([__temp,__restore] = _withAsyncContext(() => 2)),
-  await __temp,
-  __restore()
-)
-        }
-        if (b) {
-          (
-  ([__temp,__restore] = _withAsyncContext(() => 3)),
-  await __temp,
-  __restore()
-)
-          ;(
-  ([__temp,__restore] = _withAsyncContext(() => 4)),
-  await __temp,
-  __restore()
-)
-        }
-      } else {
-        (
-  ([__temp,__restore] = _withAsyncContext(() => 5)),
-  await __temp,
-  __restore()
-)
-      }
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > nested await 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-;(
-  ([__temp,__restore] = _withAsyncContext(async () => ((
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)))),
-  await __temp,
-  __restore()
-)
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > nested await 2`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-;(
-  ([__temp,__restore] = _withAsyncContext(async () => (((
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-))))),
-  await __temp,
-  __restore()
-)
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > nested await 3`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-;(
-  ([__temp,__restore] = _withAsyncContext(async () => ((
-  ([__temp,__restore] = _withAsyncContext(async () => ((
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)))),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)))),
-  await __temp,
-  __restore()
-)
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > nested leading await in expression statement 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-foo()
-;(
-  ([__temp,__restore] = _withAsyncContext(() => 1)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-) + (
-  ([__temp,__restore] = _withAsyncContext(() => 2)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > nested statements 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-if (ok) { (
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  await __temp,
-  __restore()
-) } else { (
-  ([__temp,__restore] = _withAsyncContext(() => bar)),
-  await __temp,
-  __restore()
-) }
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > ref 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-let a = $ref(1 + ((
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-)))
-return { a }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 1`] = `
-"export default {
-  setup(__props) {
-async function foo() { await bar }
-return { foo }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 2`] = `
-"export default {
-  setup(__props) {
-const foo = async () => { await bar }
-return { foo }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 3`] = `
-"export default {
-  setup(__props) {
-const obj = { async method() { await bar }}
-return { obj }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > should ignore await inside functions 4`] = `
-"export default {
-  setup(__props) {
-const cls = class Foo { async method() { await bar }}
-return { cls }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > single line conditions 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-if (false) (
-  ([__temp,__restore] = _withAsyncContext(() => foo())),
-  await __temp,
-  __restore()
-)
-return {  }
-}
-
-}"
-`;
-
-exports[`SFC compile <script setup> > async/await detection > variable 1`] = `
-"import { withAsyncContext as _withAsyncContext } from 'vue'
-
-export default {
-  async setup(__props) {
-
-let __temp, __restore
-const a = 1 + ((
-  ([__temp,__restore] = _withAsyncContext(() => foo)),
-  __temp = await __temp,
-  __restore(),
-  __temp
-))
-return { a }
-}
-
-}"
-`;
-
 exports[`SFC compile <script setup> > binding analysis for destructure 1`] = `
 "export default {
   setup(__props) {
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index 19ad17a2dfd..29c744b5f73 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -1,11 +1,11 @@
 import { BindingTypes } from '../src/types'
 import { parse, ParseOptions } from '../src/parse'
 import { parse as babelParse } from '@babel/parser'
-import { compileScript, ScriptCompileOptions } from '../src/compileScript'
+import { compileScript, SFCScriptCompileOptions } from '../src/compileScript'
 
 function compile(
   source: string,
-  options?: Partial<ScriptCompileOptions>,
+  options?: Partial<SFCScriptCompileOptions>,
   parseOptions?: Partial<ParseOptions>
 ) {
   const sfc = parse({
@@ -1165,120 +1165,6 @@ const emit = defineEmits(['a', 'b'])
     })
   })
 
-  describe('async/await detection', () => {
-    function assertAwaitDetection(code: string, shouldAsync = true) {
-      const { content } = compile(`<script setup>${code}</script>`)
-      if (shouldAsync) {
-        expect(content).toMatch(`let __temp, __restore`)
-      }
-      expect(content).toMatch(`${shouldAsync ? `async ` : ``}setup(`)
-      assertCode(content)
-      return content
-    }
-
-    test('expression statement', () => {
-      assertAwaitDetection(`await foo`)
-    })
-
-    test('variable', () => {
-      assertAwaitDetection(`const a = 1 + (await foo)`)
-    })
-
-    test('ref', () => {
-      assertAwaitDetection(`let a = $ref(1 + (await foo))`)
-    })
-
-    // #4448
-    test('nested await', () => {
-      assertAwaitDetection(`await (await foo)`)
-      assertAwaitDetection(`await ((await foo))`)
-      assertAwaitDetection(`await (await (await foo))`)
-    })
-
-    // should prepend semicolon
-    test('nested leading await in expression statement', () => {
-      const code = assertAwaitDetection(`foo()\nawait 1 + await 2`)
-      expect(code).toMatch(`foo()\n;(`)
-    })
-
-    // #4596 should NOT prepend semicolon
-    test('single line conditions', () => {
-      const code = assertAwaitDetection(`if (false) await foo()`)
-      expect(code).not.toMatch(`if (false) ;(`)
-    })
-
-    test('nested statements', () => {
-      assertAwaitDetection(`if (ok) { await foo } else { await bar }`)
-    })
-
-    test('multiple `if` nested statements', () => {
-      assertAwaitDetection(`if (ok) {
-        let a = 'foo'
-        await 0 + await 1
-        await 2
-      } else if (a) {
-        await 10
-        if (b) {
-          await 0 + await 1
-        } else {
-          let a = 'foo'
-          await 2
-        }
-        if (b) {
-          await 3
-          await 4
-        }
-      } else {
-        await 5
-      }`)
-    })
-
-    test('multiple `if while` nested statements', () => {
-      assertAwaitDetection(`if (ok) {
-        while (d) {
-          await 5
-        }
-        while (d) {
-          await 5
-          await 6
-          if (c) {
-            let f = 10
-            10 + await 7
-          } else {
-            await 8
-            await 9
-          }
-        }
-      }`)
-    })
-
-    test('multiple `if for` nested statements', () => {
-      assertAwaitDetection(`if (ok) {
-        for (let a of [1,2,3]) {
-          await a
-        }
-        for (let a of [1,2,3]) {
-          await a
-          await a
-        }
-      }`)
-    })
-
-    test('should ignore await inside functions', () => {
-      // function declaration
-      assertAwaitDetection(`async function foo() { await bar }`, false)
-      // function expression
-      assertAwaitDetection(`const foo = async () => { await bar }`, false)
-      // object method
-      assertAwaitDetection(`const obj = { async method() { await bar }}`, false)
-      // class method
-      assertAwaitDetection(
-        `const cls = class Foo { async method() { await bar }}`,
-        false
-      )
-    })
-  })
-
   describe('errors', () => {
     test('<script> and <script setup> must have same lang', () => {
       expect(() =>

From b2332faf04dc3cabd8dee2fdc53ced99441b87ed Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 17 Jun 2022 09:57:51 +0800
Subject: [PATCH 167/317] release: v2.7.0-beta.1

---
 CHANGELOG.md                            | 15 +++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 12d3bd46dc5..f3b58646f31 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,18 @@
+# [2.7.0-beta.1](https://github.com/vuejs/vue/compare/v2.7.0-alpha.12...v2.7.0-beta.1) (2022-06-17)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** expose src on custom blocks as well ([cdfc4c1](https://github.com/vuejs/vue/commit/cdfc4c134ddadc33f3b50d53ec6316b0c96f4567))
+
+
+### Features
+
+* **compiler-sfc:** support includeAbsolute in transformAssetUrl ([8f5817a](https://github.com/vuejs/vue/commit/8f5817a7c9a0664438e4299f82ac41a67f156f89))
+* warn top level await usage in `<script setup>` ([efa8a74](https://github.com/vuejs/vue/commit/efa8a749644cfd6a0d6e9e92a1f342e2eff77d5a))
+
+
+
 # [2.7.0-alpha.12](https://github.com/vuejs/vue/compare/v2.7.0-alpha.11...v2.7.0-alpha.12) (2022-06-16)
 
 
diff --git a/package.json b/package.json
index e7166e73b9a..d3e26dcedef 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-alpha.12",
+  "version": "2.7.0-beta.1",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index ad50541ce10..2f9fc15951f 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-alpha.12",
+  "version": "2.7.0-beta.1",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index cf5e20bd141..228291b706a 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-alpha.12",
+  "version": "2.7.0-beta.1",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 129f1d7b135..67f3318401b 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-alpha.12",
+  "version": "2.7.0-beta.1",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 328ebff04198143385371c857ad23f739be9509d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 17 Jun 2022 10:45:52 +0800
Subject: [PATCH 168/317] fix(compiler-sfc): do not transform external and data
 urls in templates

---
 .../src/templateCompilerModules/utils.ts      | 15 ++++++++-
 .../compiler-sfc/test/compileStyle.spec.ts    |  8 ++---
 .../compiler-sfc/test/compileTemplate.spec.ts | 31 +++++++++++++++++--
 3 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/packages/compiler-sfc/src/templateCompilerModules/utils.ts b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
index d7831c84353..fa02fd2bdc4 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/utils.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
@@ -14,8 +14,11 @@ export function urlToRequire(
     url = url.slice(secondChar === '/' ? 2 : 1)
   }
 
-  const uriParts = parseUriParts(url)
+  if (isExternalUrl(url) || isDataUrl(url) || firstChar === '#') {
+    return returnValue
+  }
 
+  const uriParts = parseUriParts(url)
   if (transformAssetUrlsOption.base) {
     // explicit base - directly rewrite the url into absolute url
     // does not apply to absolute urls or urls that start with `@`
@@ -67,3 +70,13 @@ function parseUriParts(urlString: string): UrlWithStringQuery {
   }
   return returnValue
 }
+
+const externalRE = /^(https?:)?\/\//
+function isExternalUrl(url: string): boolean {
+  return externalRE.test(url)
+}
+
+const dataUrlRE = /^\s*data:/i
+function isDataUrl(url: string): boolean {
+  return dataUrlRE.test(url)
+}
diff --git a/packages/compiler-sfc/test/compileStyle.spec.ts b/packages/compiler-sfc/test/compileStyle.spec.ts
index 9764779593e..8ad69ef42ff 100644
--- a/packages/compiler-sfc/test/compileStyle.spec.ts
+++ b/packages/compiler-sfc/test/compileStyle.spec.ts
@@ -9,7 +9,7 @@ test('preprocess less', () => {
       '.color { color: @red; }\n' +
       '</style>\n',
     filename: 'example.vue',
-    needMap: true
+    sourceMap: true
   }).styles[0]
 
   const result = compileStyle({
@@ -34,7 +34,7 @@ test('preprocess scss', () => {
       '.color { color: $red; }\n' +
       '</style>\n',
     filename: 'example.vue',
-    needMap: true
+    sourceMap: true
   }).styles[0]
   const result = compileStyle({
     id: 'v-scope-xxx',
@@ -59,7 +59,7 @@ test('preprocess sass', () => {
       '   color: $red\n' +
       '</style>\n',
     filename: 'example.vue',
-    needMap: true
+    sourceMap: true
   }).styles[0]
   const result = compileStyle({
     id: 'v-scope-xxx',
@@ -84,7 +84,7 @@ test('preprocess stylus', () => {
       '   color: red-color\n' +
       '</style>\n',
     filename: 'example.vue',
-    needMap: true
+    sourceMap: true
   }).styles[0]
   const result = compileStyle({
     id: 'v-scope-xxx',
diff --git a/packages/compiler-sfc/test/compileTemplate.spec.ts b/packages/compiler-sfc/test/compileTemplate.spec.ts
index d679dc7b136..bba5d032ddf 100644
--- a/packages/compiler-sfc/test/compileTemplate.spec.ts
+++ b/packages/compiler-sfc/test/compileTemplate.spec.ts
@@ -48,7 +48,7 @@ test('preprocess pug', () => {
       '   p Cool Pug example!\n' +
       '</template>\n',
     filename: 'example.vue',
-    needMap: true
+    sourceMap: true
   }).template as SFCBlock
 
   const result = compileTemplate({
@@ -103,7 +103,7 @@ test('warn missing preprocessor', () => {
     source: '<template lang="unknownLang">\n' + '</template>\n',
 
     filename: 'example.vue',
-    needMap: true
+    sourceMap: true
   }).template as SFCBlock
 
   const result = compileTemplate({
@@ -141,7 +141,6 @@ test('transform assetUrls', () => {
 })
 
 test('transform srcset', () => {
-  // TODO:
   const source = `
 <div>
   <img src="./logo.png">
@@ -227,3 +226,29 @@ test('transform assetUrls and srcset with base option', () => {
     '/base/logo.png 2x, /base/logo.png 3x'
   )
 })
+
+test('transform with includeAbsolute', () => {
+  const source = `
+  <div>
+    <img src="./logo.png">
+    <img src="/logo.png">
+    <img src="https://foo.com/logo.png">
+  </div>
+  `
+  const result = compileTemplate({
+    filename: 'example.vue',
+    source,
+    transformAssetUrls: true,
+    transformAssetUrlsOptions: { includeAbsolute: true }
+  })
+
+  expect(result.errors.length).toBe(0)
+
+  const vnode = mockRender(result.code, {
+    './logo.png': 'relative',
+    '/logo.png': 'absolute'
+  })
+  expect(vnode.children[0].data.attrs.src).toBe('relative')
+  expect(vnode.children[2].data.attrs.src).toBe('absolute')
+  expect(vnode.children[4].data.attrs.src).toBe('https://foo.com/logo.png')
+})

From 9b4e179873640389c1c3956d63f27b2f43ff9179 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 17 Jun 2022 10:57:11 +0800
Subject: [PATCH 169/317] release: v2.7.0-beta.2

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f3b58646f31..d3955240f46 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-beta.2](https://github.com/vuejs/vue/compare/v2.7.0-beta.1...v2.7.0-beta.2) (2022-06-17)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** do not transform external and data urls in templates ([328ebff](https://github.com/vuejs/vue/commit/328ebff04198143385371c857ad23f739be9509d))
+
+
+
 # [2.7.0-beta.1](https://github.com/vuejs/vue/compare/v2.7.0-alpha.12...v2.7.0-beta.1) (2022-06-17)
 
 
diff --git a/package.json b/package.json
index d3e26dcedef..ffc25629fa4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.1",
+  "version": "2.7.0-beta.2",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 2f9fc15951f..b3b63867f47 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.1",
+  "version": "2.7.0-beta.2",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 228291b706a..fdab5b63970 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.1",
+  "version": "2.7.0-beta.2",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 67f3318401b..b9da6a43a2a 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.1",
+  "version": "2.7.0-beta.2",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 0fabda7a3b016c1c0cb5d92f5d8efc35f0dbde40 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 18 Jun 2022 16:09:08 +0800
Subject: [PATCH 170/317] feat: useCssModules

---
 scripts/config.js                  |  3 ++-
 src/global.d.ts                    |  1 +
 src/v3/index.ts                    |  2 ++
 src/v3/sfc-helpers/useCssModule.ts | 24 ++++++++++++++++++++++++
 4 files changed, 29 insertions(+), 1 deletion(-)
 create mode 100644 src/v3/sfc-helpers/useCssModule.ts

diff --git a/scripts/config.js b/scripts/config.js
index a1c871a6e95..851dc22971c 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -279,7 +279,8 @@ function genConfig(name) {
   const vars = {
     __VERSION__: version,
     __DEV__: `process.env.NODE_ENV !== 'production'`,
-    __TEST__: false
+    __TEST__: false,
+    __GLOBAL__: opts.format === 'umd' || name.includes('browser')
   }
   // feature flags
   Object.keys(featureFlags).forEach(key => {
diff --git a/src/global.d.ts b/src/global.d.ts
index 1b88325cbdc..badbd1e02e8 100644
--- a/src/global.d.ts
+++ b/src/global.d.ts
@@ -1,5 +1,6 @@
 declare const __DEV__: boolean
 declare const __TEST__: boolean
+declare const __GLOBAL__: boolean
 
 interface Window {
   __VUE_DEVTOOLS_GLOBAL_HOOK__: DevtoolsHook
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 1c521e463c7..044fd27c43b 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -76,6 +76,8 @@ export { useSlots, useAttrs, mergeDefaults } from './apiSetup'
 export { nextTick } from 'core/util/next-tick'
 export { set, del } from 'core/observer'
 
+export { useCssModule } from './sfc-helpers/useCssModule'
+
 /**
  * @internal type is manually declared in <root>/types/v3-define-component.d.ts
  */
diff --git a/src/v3/sfc-helpers/useCssModule.ts b/src/v3/sfc-helpers/useCssModule.ts
new file mode 100644
index 00000000000..df49931af12
--- /dev/null
+++ b/src/v3/sfc-helpers/useCssModule.ts
@@ -0,0 +1,24 @@
+import { emptyObject, warn } from '../../core/util'
+import { currentInstance } from '../currentInstance'
+
+export function useCssModule(name = '$style'): Record<string, string> {
+  /* istanbul ignore else */
+  if (!__GLOBAL__) {
+    if (!currentInstance) {
+      __DEV__ && warn(`useCssModule must be called inside setup()`)
+      return emptyObject
+    }
+    const mod = currentInstance[name]
+    if (!mod) {
+      __DEV__ &&
+        warn(`Current instance does not have CSS module named "${name}".`)
+      return emptyObject
+    }
+    return mod as Record<string, string>
+  } else {
+    if (__DEV__) {
+      warn(`useCssModule() is not supported in the global build.`)
+    }
+    return emptyObject
+  }
+}

From 2533a360a838c41238dc9b9b840932f2957c65d4 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 12:42:32 +0800
Subject: [PATCH 171/317] fix(template-ref): preserve ref removal behavior in
 non-composition-api usage

close #12554
---
 src/core/vdom/modules/template-ref.ts   | 5 +++--
 test/unit/features/template-ref.spec.ts | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/core/vdom/modules/template-ref.ts b/src/core/vdom/modules/template-ref.ts
index f613435f2d2..0cbb2a46067 100644
--- a/src/core/vdom/modules/template-ref.ts
+++ b/src/core/vdom/modules/template-ref.ts
@@ -33,6 +33,7 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
   const vm = vnode.context
   const refValue = vnode.componentInstance || vnode.elm
   const value = isRemoval ? null : refValue
+  const $refsValue = isRemoval ? undefined : refValue
 
   if (isFunction(ref)) {
     invokeWithErrorHandling(ref, vm, [value], vm, `template ref function`)
@@ -67,14 +68,14 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
       if (isRemoval && refs[ref] !== refValue) {
         return
       }
-      refs[ref] = value
+      refs[ref] = $refsValue
       setSetupRef(vm, ref, value)
     } else if (_isRef) {
       if (isRemoval && ref.value !== refValue) {
         return
       }
       ref.value = value
-      if (setupRefKey) refs[setupRefKey] = value
+      if (setupRefKey) refs[setupRefKey] = $refsValue
     } else if (__DEV__) {
       warn(`Invalid template ref type: ${typeof ref}`)
     }
diff --git a/test/unit/features/template-ref.spec.ts b/test/unit/features/template-ref.spec.ts
index 00aeeb2f99f..ce3ee2b2034 100644
--- a/test/unit/features/template-ref.spec.ts
+++ b/test/unit/features/template-ref.spec.ts
@@ -58,7 +58,7 @@ describe('ref', () => {
     expect(vm.$refs.foo).toBe(vm.$el)
     vm.value = 'bar'
     waitForUpdate(() => {
-      expect(vm.$refs.foo).toBe(null)
+      expect(vm.$refs.foo).toBe(undefined)
       expect(vm.$refs.bar).toBe(vm.$el)
     }).then(done)
   })
@@ -101,7 +101,7 @@ describe('ref', () => {
       vm.test = ''
     })
       .then(() => {
-        expect(vm.$refs.test).toBe(null)
+        expect(vm.$refs.test).toBe(undefined)
       })
       .then(done)
   })

From 52cf912d855a7fae8d8c89452f0d275846e26a87 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 13:09:56 +0800
Subject: [PATCH 172/317] fix(setup): setup props should pass isReactive check

close #12561
---
 src/core/instance/state.ts             |  4 ++--
 src/v3/apiSetup.ts                     |  6 +++++-
 test/unit/features/v3/apiSetup.spec.ts | 22 +++++++++++++++++++++-
 3 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 4262e06475e..e22ec6705fb 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -30,7 +30,7 @@ import {
   isFunction
 } from '../util/index'
 import type { Component } from 'types/component'
-import { TrackOpTypes } from '../../v3'
+import { shallowReactive, TrackOpTypes } from 'v3'
 
 const sharedPropertyDefinition = {
   enumerable: true,
@@ -71,7 +71,7 @@ export function initState(vm: Component) {
 
 function initProps(vm: Component, propsOptions: Object) {
   const propsData = vm.$options.propsData || {}
-  const props = (vm._props = {})
+  const props = (vm._props = shallowReactive({}))
   // cache prop keys so that future props updates can iterate using Array
   // instead of dynamic object key enumeration.
   const keys: string[] = (vm.$options._propKeys = [])
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index 811453b996a..dcb263cb7f2 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -1,5 +1,6 @@
 import { Component } from 'types/component'
 import { PropOptions } from 'types/options'
+import { toggleObserving } from '../core/observer'
 import { def, invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
 import {
@@ -10,6 +11,7 @@ import {
   isObject
 } from '../shared/util'
 import { currentInstance, setCurrentInstance } from './currentInstance'
+import { shallowReactive } from './reactivity/reactive'
 import { isRef } from './reactivity/ref'
 
 /**
@@ -29,13 +31,15 @@ export function initSetup(vm: Component) {
     const ctx = (vm._setupContext = createSetupContext(vm))
 
     setCurrentInstance(vm)
+    toggleObserving(false)
     const setupResult = invokeWithErrorHandling(
       setup,
       null,
-      [vm._props, ctx],
+      [vm._props || shallowReactive({}), ctx],
       vm,
       `setup`
     )
+    toggleObserving(true)
     setCurrentInstance()
 
     if (isFunction(setupResult)) {
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 44044ed22b1..629e4885721 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -1,4 +1,4 @@
-import { h, ref, reactive } from 'v3'
+import { h, ref, reactive, isReactive, toRef, isRef } from 'v3'
 import { nextTick } from 'core/util'
 import { effect } from 'v3/reactivity/effect'
 import Vue from 'vue'
@@ -247,4 +247,24 @@ describe('api: setup context', () => {
     }).$mount()
     expect(spy).toHaveBeenCalled()
   })
+
+  // #12561
+  it.only('setup props should be reactive', () => {
+    const msg = ref('hi')
+
+    const Child = {
+      props: ['msg'],
+      setup: props => {
+        expect(isReactive(props)).toBe(true)
+        expect(isRef(toRef(props, 'foo'))).toBe(true)
+        return () => {}
+      }
+    }
+
+    new Vue({
+      setup() {
+        return h => h(Child, { props: { msg } })
+      }
+    }).$mount()
+  })
 })

From 769c053cff57fa04f78fc0c8f5af6437c74a02d2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 13:24:55 +0800
Subject: [PATCH 173/317] chore: remove code for non-supported :slotted feature

---
 .../compiler-sfc/src/stylePlugins/scoped.ts   | 39 +++++++++----------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/packages/compiler-sfc/src/stylePlugins/scoped.ts b/packages/compiler-sfc/src/stylePlugins/scoped.ts
index 1dcc248ad71..25332731ef6 100644
--- a/packages/compiler-sfc/src/stylePlugins/scoped.ts
+++ b/packages/compiler-sfc/src/stylePlugins/scoped.ts
@@ -81,8 +81,7 @@ function processRule(id: string, rule: Rule) {
 function rewriteSelector(
   id: string,
   selector: selectorParser.Selector,
-  selectorRoot: selectorParser.Root,
-  slotted = false
+  selectorRoot: selectorParser.Root
 ) {
   let node: selectorParser.Node | null = null
   let shouldInject = true
@@ -142,23 +141,22 @@ function rewriteSelector(
         return false
       }
 
-      // slot: use selector inside `::v-slotted` and inject [id + '-s']
-      // instead.
+      // !!! Vue 2 does not have :slotted support
       // ::v-slotted(.foo) -> .foo[xxxxxxx-s]
-      if (value === ':slotted' || value === '::v-slotted') {
-        rewriteSelector(id, n.nodes[0], selectorRoot, true /* slotted */)
-        let last: selectorParser.Selector['nodes'][0] = n
-        n.nodes[0].each(ss => {
-          selector.insertAfter(last, ss)
-          last = ss
-        })
-        // selector.insertAfter(n, n.nodes[0])
-        selector.removeChild(n)
-        // since slotted attribute already scopes the selector there's no
-        // need for the non-slot attribute.
-        shouldInject = false
-        return false
-      }
+      // if (value === ':slotted' || value === '::v-slotted') {
+      //   rewriteSelector(id, n.nodes[0], selectorRoot, true /* slotted */)
+      //   let last: selectorParser.Selector['nodes'][0] = n
+      //   n.nodes[0].each(ss => {
+      //     selector.insertAfter(last, ss)
+      //     last = ss
+      //   })
+      //   // selector.insertAfter(n, n.nodes[0])
+      //   selector.removeChild(n)
+      //   // since slotted attribute already scopes the selector there's no
+      //   // need for the non-slot attribute.
+      //   shouldInject = false
+      //   return false
+      // }
 
       // global: replace with inner selector and do not inject [id].
       // ::v-global(.foo) -> .foo
@@ -184,14 +182,13 @@ function rewriteSelector(
   }
 
   if (shouldInject) {
-    const idToAdd = slotted ? id + '-s' : id
     selector.insertAfter(
       // If node is null it means we need to inject [id] at the start
       // insertAfter can handle `null` here
       node as any,
       selectorParser.attribute({
-        attribute: idToAdd,
-        value: idToAdd,
+        attribute: id,
+        value: id,
         raws: {},
         quoteMark: `"`
       })

From 9d54f8bdfe9db75853befdc916bc85a18b337583 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 14:14:37 +0800
Subject: [PATCH 174/317] chore: remove .only from tests

---
 test/unit/features/v3/apiSetup.spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 629e4885721..1fd415fabff 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -249,7 +249,7 @@ describe('api: setup context', () => {
   })
 
   // #12561
-  it.only('setup props should be reactive', () => {
+  it('setup props should be reactive', () => {
     const msg = ref('hi')
 
     const Child = {

From 2d676416566c06d7c789899c92bf0f6924ec284a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 14:32:50 +0800
Subject: [PATCH 175/317] fix: remove wrong observe toggle, properly disable
 tracking in setup()

---
 src/v3/apiSetup.ts                     |  6 +++---
 test/unit/features/v3/apiSetup.spec.ts | 27 ++++++++++++++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index dcb263cb7f2..b3540fd75b5 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -1,6 +1,6 @@
 import { Component } from 'types/component'
 import { PropOptions } from 'types/options'
-import { toggleObserving } from '../core/observer'
+import { popTarget, pushTarget } from '../core/observer/dep'
 import { def, invokeWithErrorHandling, isReserved, warn } from '../core/util'
 import VNode from '../core/vdom/vnode'
 import {
@@ -31,7 +31,7 @@ export function initSetup(vm: Component) {
     const ctx = (vm._setupContext = createSetupContext(vm))
 
     setCurrentInstance(vm)
-    toggleObserving(false)
+    pushTarget()
     const setupResult = invokeWithErrorHandling(
       setup,
       null,
@@ -39,7 +39,7 @@ export function initSetup(vm: Component) {
       vm,
       `setup`
     )
-    toggleObserving(true)
+    popTarget()
     setCurrentInstance()
 
     if (isFunction(setupResult)) {
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 1fd415fabff..118686366e8 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -267,4 +267,31 @@ describe('api: setup context', () => {
       }
     }).$mount()
   })
+
+  it('should not track dep accessed in setup', async () => {
+    const spy = vi.fn()
+    const msg = ref('hi')
+
+    const Child = {
+      setup: () => {
+        msg.value
+        return () => {}
+      }
+    }
+
+    new Vue({
+      setup() {
+        return h => {
+          spy()
+          return h(Child)
+        }
+      }
+    }).$mount()
+
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    msg.value = 'bye'
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
 })

From 8ab0074bab83473fd025ae538a3455e3277320c4 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 15:46:57 +0800
Subject: [PATCH 176/317] feat(sfc): css v-bind

---
 examples/composition/todomvc.html             |   2 +-
 packages/compiler-sfc/src/compileScript.ts    |  34 ++-
 packages/compiler-sfc/src/compileStyle.ts     |   4 +
 packages/compiler-sfc/src/compileTemplate.ts  |   6 +-
 packages/compiler-sfc/src/cssVars.ts          | 179 +++++++++++++
 packages/compiler-sfc/src/index.ts            |   1 +
 packages/compiler-sfc/src/parse.ts            |   4 +-
 packages/compiler-sfc/src/parseComponent.ts   |   9 +-
 .../compiler-sfc/src/prefixIdentifiers.ts     |   6 +-
 .../test/__snapshots__/cssVars.spec.ts.snap   | 189 ++++++++++++++
 .../compiler-sfc/test/compileScript.spec.ts   |  30 +--
 packages/compiler-sfc/test/cssVars.spec.ts    | 247 ++++++++++++++++++
 .../test/prefixIdentifiers.spec.ts            |   6 +-
 packages/compiler-sfc/test/util.ts            |  35 +++
 src/v3/apiSetup.ts                            |  12 +-
 src/v3/index.ts                               |   1 +
 src/v3/sfc-helpers/useCssVars.ts              |  34 +++
 test/unit/features/v3/useCssVars.spec.ts      |  48 ++++
 vitest.config.ts                              |   3 +-
 19 files changed, 798 insertions(+), 52 deletions(-)
 create mode 100644 packages/compiler-sfc/src/cssVars.ts
 create mode 100644 packages/compiler-sfc/test/__snapshots__/cssVars.spec.ts.snap
 create mode 100644 packages/compiler-sfc/test/cssVars.spec.ts
 create mode 100644 packages/compiler-sfc/test/util.ts
 create mode 100644 src/v3/sfc-helpers/useCssVars.ts
 create mode 100644 test/unit/features/v3/useCssVars.spec.ts

diff --git a/examples/composition/todomvc.html b/examples/composition/todomvc.html
index ac806bc8369..c80f2fe3959 100644
--- a/examples/composition/todomvc.html
+++ b/examples/composition/todomvc.html
@@ -1,4 +1,4 @@
-<script src="../../dist/vue.min.js"></script>
+<script src="../../dist/vue.js"></script>
 <link
   rel="stylesheet"
   href="../../node_modules/todomvc-app-css/index.css"
diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 942345ed2fb..7af376bb9cc 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -42,6 +42,12 @@ import { isReservedTag } from 'web/util'
 import { dirRE } from 'compiler/parser'
 import { parseText } from 'compiler/parser/text-parser'
 import { DEFAULT_FILENAME } from './parseComponent'
+import {
+  CSS_VARS_HELPER,
+  genCssVarsCode,
+  genNormalScriptCssVarsCode
+} from './cssVars'
+import { rewriteDefault } from './rewriteDefault'
 
 // Special compiler macros
 const DEFINE_PROPS = 'defineProps'
@@ -57,6 +63,11 @@ const isBuiltInDir = makeMap(
 )
 
 export interface SFCScriptCompileOptions {
+  /**
+   * Scope ID for prefixing injected CSS variables.
+   * This must be consistent with the `id` passed to `compileStyle`.
+   */
+  id: string
   /**
    * Production mode. Used to determine whether to generate hashed CSS variables
    */
@@ -86,14 +97,15 @@ export interface ImportBinding {
  */
 export function compileScript(
   sfc: SFCDescriptor,
-  options: SFCScriptCompileOptions = {}
+  options: SFCScriptCompileOptions = { id: '' }
 ): SFCScriptBlock {
   let { filename, script, scriptSetup, source } = sfc
   const isProd = !!options.isProd
   const genSourceMap = options.sourceMap !== false
   let refBindings: string[] | undefined
 
-  // const cssVars = sfc.cssVars
+  const cssVars = sfc.cssVars
+  const scopeId = options.id ? options.id.replace(/^data-v-/, '') : ''
   const scriptLang = script && script.lang
   const scriptSetupLang = scriptSetup && scriptSetup.lang
   const isTS =
@@ -132,6 +144,16 @@ export function compileScript(
         sourceType: 'module'
       }).program
       const bindings = analyzeScriptBindings(scriptAst.body)
+      if (cssVars.length) {
+        content = rewriteDefault(content, DEFAULT_VAR, plugins)
+        content += genNormalScriptCssVarsCode(
+          cssVars,
+          bindings,
+          scopeId,
+          isProd
+        )
+        content += `\nexport default ${DEFAULT_VAR}`
+      }
       return {
         ...script,
         content,
@@ -1082,7 +1104,13 @@ export function compileScript(
   }
 
   // 8. inject `useCssVars` calls
-  // Not backported in Vue 2
+  if (cssVars.length) {
+    helperImports.add(CSS_VARS_HELPER)
+    s.prependRight(
+      startOffset,
+      `\n${genCssVarsCode(cssVars, bindingMetadata, scopeId, isProd)}\n`
+    )
+  }
 
   // 9. finalize setup() argument signature
   let args = `__props`
diff --git a/packages/compiler-sfc/src/compileStyle.ts b/packages/compiler-sfc/src/compileStyle.ts
index 0b1e8a33cfe..92698982664 100644
--- a/packages/compiler-sfc/src/compileStyle.ts
+++ b/packages/compiler-sfc/src/compileStyle.ts
@@ -7,6 +7,7 @@ import {
   StylePreprocessor,
   StylePreprocessorResults
 } from './stylePreprocessors'
+import { cssVarsPlugin } from './cssVars'
 
 export interface SFCStyleCompileOptions {
   source: string
@@ -19,6 +20,7 @@ export interface SFCStyleCompileOptions {
   preprocessOptions?: any
   postcssOptions?: any
   postcssPlugins?: any[]
+  isProd?: boolean
 }
 
 export interface SFCAsyncStyleCompileOptions extends SFCStyleCompileOptions {
@@ -52,6 +54,7 @@ export function doCompileStyle(
     id,
     scoped = true,
     trim = true,
+    isProd = false,
     preprocessLang,
     postcssOptions,
     postcssPlugins
@@ -62,6 +65,7 @@ export function doCompileStyle(
   const source = preProcessedSource ? preProcessedSource.code : options.source
 
   const plugins = (postcssPlugins || []).slice()
+  plugins.unshift(cssVarsPlugin({ id: id.replace(/^data-v-/, ''), isProd }))
   if (trim) {
     plugins.push(trimPlugin())
   }
diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index 68e5be350a0..fb5fa9ae180 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -148,8 +148,7 @@ function actuallyCompile(
     // version of Buble that applies ES2015 transforms + stripping `with` usage
     let code =
       `var __render__ = ${prefixIdentifiers(
-        render,
-        `render`,
+        `function render(${isFunctional ? `_c,_vm` : ``}){${render}\n}`,
         isFunctional,
         isTS,
         transpileOptions,
@@ -157,8 +156,7 @@ function actuallyCompile(
       )}\n` +
       `var __staticRenderFns__ = [${staticRenderFns.map(code =>
         prefixIdentifiers(
-          code,
-          ``,
+          `function (${isFunctional ? `_c,_vm` : ``}){${code}\n}`,
           isFunctional,
           isTS,
           transpileOptions,
diff --git a/packages/compiler-sfc/src/cssVars.ts b/packages/compiler-sfc/src/cssVars.ts
new file mode 100644
index 00000000000..48f8cb70244
--- /dev/null
+++ b/packages/compiler-sfc/src/cssVars.ts
@@ -0,0 +1,179 @@
+import { BindingMetadata } from './types'
+import { SFCDescriptor } from './parseComponent'
+import { PluginCreator } from 'postcss'
+import hash from 'hash-sum'
+import { prefixIdentifiers } from './prefixIdentifiers'
+
+export const CSS_VARS_HELPER = `useCssVars`
+
+export function genCssVarsFromList(
+  vars: string[],
+  id: string,
+  isProd: boolean,
+  isSSR = false
+): string {
+  return `{\n  ${vars
+    .map(
+      key => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd)}": (${key})`
+    )
+    .join(',\n  ')}\n}`
+}
+
+function genVarName(id: string, raw: string, isProd: boolean): string {
+  if (isProd) {
+    return hash(id + raw)
+  } else {
+    return `${id}-${raw.replace(/([^\w-])/g, '_')}`
+  }
+}
+
+function normalizeExpression(exp: string) {
+  exp = exp.trim()
+  if (
+    (exp[0] === `'` && exp[exp.length - 1] === `'`) ||
+    (exp[0] === `"` && exp[exp.length - 1] === `"`)
+  ) {
+    return exp.slice(1, -1)
+  }
+  return exp
+}
+
+const vBindRE = /v-bind\s*\(/g
+
+export function parseCssVars(sfc: SFCDescriptor): string[] {
+  const vars: string[] = []
+  sfc.styles.forEach(style => {
+    let match
+    // ignore v-bind() in comments /* ... */
+    const content = style.content.replace(/\/\*([\s\S]*?)\*\//g, '')
+    while ((match = vBindRE.exec(content))) {
+      const start = match.index + match[0].length
+      const end = lexBinding(content, start)
+      if (end !== null) {
+        const variable = normalizeExpression(content.slice(start, end))
+        if (!vars.includes(variable)) {
+          vars.push(variable)
+        }
+      }
+    }
+  })
+  return vars
+}
+
+const enum LexerState {
+  inParens,
+  inSingleQuoteString,
+  inDoubleQuoteString
+}
+
+function lexBinding(content: string, start: number): number | null {
+  let state: LexerState = LexerState.inParens
+  let parenDepth = 0
+
+  for (let i = start; i < content.length; i++) {
+    const char = content.charAt(i)
+    switch (state) {
+      case LexerState.inParens:
+        if (char === `'`) {
+          state = LexerState.inSingleQuoteString
+        } else if (char === `"`) {
+          state = LexerState.inDoubleQuoteString
+        } else if (char === `(`) {
+          parenDepth++
+        } else if (char === `)`) {
+          if (parenDepth > 0) {
+            parenDepth--
+          } else {
+            return i
+          }
+        }
+        break
+      case LexerState.inSingleQuoteString:
+        if (char === `'`) {
+          state = LexerState.inParens
+        }
+        break
+      case LexerState.inDoubleQuoteString:
+        if (char === `"`) {
+          state = LexerState.inParens
+        }
+        break
+    }
+  }
+  return null
+}
+
+// for compileStyle
+export interface CssVarsPluginOptions {
+  id: string
+  isProd: boolean
+}
+
+export const cssVarsPlugin: PluginCreator<CssVarsPluginOptions> = opts => {
+  const { id, isProd } = opts!
+  return {
+    postcssPlugin: 'vue-sfc-vars',
+    Declaration(decl) {
+      // rewrite CSS variables
+      const value = decl.value
+      if (vBindRE.test(value)) {
+        vBindRE.lastIndex = 0
+        let transformed = ''
+        let lastIndex = 0
+        let match
+        while ((match = vBindRE.exec(value))) {
+          const start = match.index + match[0].length
+          const end = lexBinding(value, start)
+          if (end !== null) {
+            const variable = normalizeExpression(value.slice(start, end))
+            transformed +=
+              value.slice(lastIndex, match.index) +
+              `var(--${genVarName(id, variable, isProd)})`
+            lastIndex = end + 1
+          }
+        }
+        decl.value = transformed + value.slice(lastIndex)
+      }
+    }
+  }
+}
+cssVarsPlugin.postcss = true
+
+export function genCssVarsCode(
+  vars: string[],
+  bindings: BindingMetadata,
+  id: string,
+  isProd: boolean
+) {
+  const varsExp = genCssVarsFromList(vars, id, isProd)
+  return `_${CSS_VARS_HELPER}((_vm, _setup) => ${prefixIdentifiers(
+    `(${varsExp})`,
+    false,
+    false,
+    undefined,
+    bindings
+  )})`
+}
+
+// <script setup> already gets the calls injected as part of the transform
+// this is only for single normal <script>
+export function genNormalScriptCssVarsCode(
+  cssVars: string[],
+  bindings: BindingMetadata,
+  id: string,
+  isProd: boolean
+): string {
+  return (
+    `\nimport { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'\n` +
+    `const __injectCSSVars__ = () => {\n${genCssVarsCode(
+      cssVars,
+      bindings,
+      id,
+      isProd
+    )}}\n` +
+    `const __setup__ = __default__.setup\n` +
+    `__default__.setup = __setup__\n` +
+    `  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }\n` +
+    `  : __injectCSSVars__\n`
+  )
+}
diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index e98d4b6e22b..7c665bddfab 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -7,6 +7,7 @@ export { generateCodeFrame } from 'compiler/codeframe'
 export { rewriteDefault } from './rewriteDefault'
 
 // types
+export { SFCParseOptions } from './parse'
 export { CompilerOptions, WarningMessage } from 'types/compiler'
 export { TemplateCompiler } from './types'
 export {
diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index ba19739603a..6901238117d 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -16,7 +16,7 @@ const cache = new LRU<string, SFCDescriptor>(100)
 const splitRE = /\r?\n/g
 const emptyRE = /^(?:\/\/)?\s*$/
 
-export interface ParseOptions {
+export interface SFCParseOptions {
   source: string
   filename?: string
   compiler?: TemplateCompiler
@@ -25,7 +25,7 @@ export interface ParseOptions {
   sourceMap?: boolean
 }
 
-export function parse(options: ParseOptions): SFCDescriptor {
+export function parse(options: SFCParseOptions): SFCDescriptor {
   const {
     source,
     filename = DEFAULT_FILENAME,
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index d17345df520..85d74560759 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -4,6 +4,7 @@ import { makeMap } from 'shared/util'
 import { ASTAttr, WarningMessage } from 'types/compiler'
 import { BindingMetadata, RawSourceMap } from './types'
 import type { ImportBinding } from './compileScript'
+import { parseCssVars } from './cssVars'
 
 export const DEFAULT_FILENAME = 'anonymous.vue'
 
@@ -50,7 +51,9 @@ export interface SFCDescriptor {
   scriptSetup: SFCScriptBlock | null
   styles: SFCBlock[]
   customBlocks: SFCCustomBlock[]
-  errors: WarningMessage[]
+  cssVars: string[]
+
+  errors: (string | WarningMessage)[]
 
   /**
    * compare with an existing descriptor to determine whether HMR should perform
@@ -84,6 +87,7 @@ export function parseComponent(
     scriptSetup: null, // TODO
     styles: [],
     customBlocks: [],
+    cssVars: [],
     errors: [],
     shouldForceReload: null as any // attached in parse() by compiler-sfc
   }
@@ -205,5 +209,8 @@ export function parseComponent(
     outputSourceRange: options.outputSourceRange
   })
 
+  // parse CSS vars
+  sfc.cssVars = parseCssVars(sfc)
+
   return sfc
 }
diff --git a/packages/compiler-sfc/src/prefixIdentifiers.ts b/packages/compiler-sfc/src/prefixIdentifiers.ts
index 01ef3a3ad21..d8dd1868cd9 100644
--- a/packages/compiler-sfc/src/prefixIdentifiers.ts
+++ b/packages/compiler-sfc/src/prefixIdentifiers.ts
@@ -14,19 +14,15 @@ const doNotPrefix = makeMap(
 )
 
 /**
- * The input is expected to be the render function code directly returned from
- * `compile()` calls, e.g. `with(this){return ...}`
+ * The input is expected to be a valid expression.
  */
 export function prefixIdentifiers(
   source: string,
-  fnName = '',
   isFunctional = false,
   isTS = false,
   babelOptions: ParserOptions = {},
   bindings?: BindingMetadata
 ) {
-  source = `function ${fnName}(${isFunctional ? `_c,_vm` : ``}){${source}\n}`
-
   const s = new MagicString(source)
 
   const plugins: ParserPlugin[] = [
diff --git a/packages/compiler-sfc/test/__snapshots__/cssVars.spec.ts.snap b/packages/compiler-sfc/test/__snapshots__/cssVars.spec.ts.snap
new file mode 100644
index 00000000000..b7d0a92d606
--- /dev/null
+++ b/packages/compiler-sfc/test/__snapshots__/cssVars.spec.ts.snap
@@ -0,0 +1,189 @@
+// Vitest Snapshot v1
+
+exports[`CSS vars injection > codegen > <script> w/ default export 1`] = `
+"const __default__ = { setup() {} }
+import { useCssVars as _useCssVars } from 'vue'
+const __injectCSSVars__ = () => {
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_vm.color)
+}))}
+const __setup__ = __default__.setup
+__default__.setup = __setup__
+  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
+  : __injectCSSVars__
+
+export default __default__"
+`;
+
+exports[`CSS vars injection > codegen > <script> w/ default export in strings/comments 1`] = `
+"
+          // export default {}
+          const __default__ = {}
+        
+import { useCssVars as _useCssVars } from 'vue'
+const __injectCSSVars__ = () => {
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_vm.color)
+}))}
+const __setup__ = __default__.setup
+__default__.setup = __setup__
+  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
+  : __injectCSSVars__
+
+export default __default__"
+`;
+
+exports[`CSS vars injection > codegen > <script> w/ no default export 1`] = `
+"const a = 1
+const __default__ = {}
+import { useCssVars as _useCssVars } from 'vue'
+const __injectCSSVars__ = () => {
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_vm.color)
+}))}
+const __setup__ = __default__.setup
+__default__.setup = __setup__
+  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
+  : __injectCSSVars__
+
+export default __default__"
+`;
+
+exports[`CSS vars injection > codegen > should ignore comments 1`] = `
+"import { useCssVars as _useCssVars } from 'vue'
+
+export default {
+  setup(__props) {
+
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-width\\": (_setup.width)
+}))
+const color = 'red';const width = 100
+return { color, width }
+}
+
+}"
+`;
+
+exports[`CSS vars injection > codegen > should work with w/ complex expression 1`] = `
+"import { useCssVars as _useCssVars } from 'vue'
+
+export default {
+  setup(__props) {
+
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-foo\\": (_setup.foo),
+  \\"xxxxxxxx-foo____px_\\": (_setup.foo + 'px'),
+  \\"xxxxxxxx-_a___b____2____px_\\": ((_setup.a + _setup.b) / 2 + 'px'),
+  \\"xxxxxxxx-__a___b______2___a_\\": (((_setup.a + _setup.b)) / (2 * _setup.a))
+}))
+
+        let a = 100
+        let b = 200
+        let foo = 300
+        
+return { a, b, foo }
+}
+
+}"
+`;
+
+exports[`CSS vars injection > codegen > w/ <script setup> 1`] = `
+"import { useCssVars as _useCssVars } from 'vue'
+
+export default {
+  setup(__props) {
+
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_setup.color)
+}))
+const color = 'red'
+return { color }
+}
+
+}"
+`;
+
+exports[`CSS vars injection > codegen > w/ <script setup> using the same var multiple times 1`] = `
+"import { useCssVars as _useCssVars } from 'vue'
+
+export default {
+  setup(__props) {
+
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_setup.color)
+}))
+
+        const color = 'red'
+        
+return { color }
+}
+
+}"
+`;
+
+exports[`CSS vars injection > generating correct code for nested paths 1`] = `
+"const a = 1
+const __default__ = {}
+import { useCssVars as _useCssVars } from 'vue'
+const __injectCSSVars__ = () => {
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_vm.color),
+  \\"xxxxxxxx-font_size\\": (_vm.font.size)
+}))}
+const __setup__ = __default__.setup
+__default__.setup = __setup__
+  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
+  : __injectCSSVars__
+
+export default __default__"
+`;
+
+exports[`CSS vars injection > w/ <script setup> binding analysis 1`] = `
+"import { useCssVars as _useCssVars } from 'vue'
+import { ref } from 'vue'
+        
+export default {
+  props: {
+          foo: String
+        },
+  setup(__props) {
+
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-color\\": (_setup.color),
+  \\"xxxxxxxx-size\\": (_setup.size),
+  \\"xxxxxxxx-foo\\": (_vm.foo)
+}))
+
+        const color = 'red'
+        const size = ref('10px')
+        
+        
+return { color, size, ref }
+}
+
+}"
+`;
+
+exports[`CSS vars injection > w/ normal <script> binding analysis 1`] = `
+"
+      const __default__ = {
+        setup() {
+          return {
+            size: ref('100px')
+          }
+        }
+      }
+      
+import { useCssVars as _useCssVars } from 'vue'
+const __injectCSSVars__ = () => {
+_useCssVars((_vm, _setup) => ({
+  \\"xxxxxxxx-size\\": (_vm.size)
+}))}
+const __setup__ = __default__.setup
+__default__.setup = __setup__
+  ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
+  : __injectCSSVars__
+
+export default __default__"
+`;
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index 29c744b5f73..05b7159cb2c 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -1,33 +1,5 @@
 import { BindingTypes } from '../src/types'
-import { parse, ParseOptions } from '../src/parse'
-import { parse as babelParse } from '@babel/parser'
-import { compileScript, SFCScriptCompileOptions } from '../src/compileScript'
-
-function compile(
-  source: string,
-  options?: Partial<SFCScriptCompileOptions>,
-  parseOptions?: Partial<ParseOptions>
-) {
-  const sfc = parse({
-    ...parseOptions,
-    source
-  })
-  return compileScript(sfc, options)
-}
-
-function assertCode(code: string) {
-  // parse the generated code to make sure it is valid
-  try {
-    babelParse(code, {
-      sourceType: 'module',
-      plugins: ['typescript']
-    })
-  } catch (e: any) {
-    console.log(code)
-    throw e
-  }
-  expect(code).toMatchSnapshot()
-}
+import { compile, assertCode } from './util'
 
 describe('SFC compile <script setup>', () => {
   test('should expose top level declarations', () => {
diff --git a/packages/compiler-sfc/test/cssVars.spec.ts b/packages/compiler-sfc/test/cssVars.spec.ts
new file mode 100644
index 00000000000..86f4e969c91
--- /dev/null
+++ b/packages/compiler-sfc/test/cssVars.spec.ts
@@ -0,0 +1,247 @@
+import { compileStyle, parse } from '../src'
+import { mockId, compile, assertCode } from './util'
+
+describe('CSS vars injection', () => {
+  test('generating correct code for nested paths', () => {
+    const { content } = compile(
+      `<script>const a = 1</script>\n` +
+        `<style>div{
+          color: v-bind(color);
+          font-size: v-bind('font.size');
+        }</style>`
+    )
+    expect(content).toMatch(`_useCssVars((_vm, _setup) => ({
+  "${mockId}-color": (_vm.color),
+  "${mockId}-font_size": (_vm.font.size)
+})`)
+    assertCode(content)
+  })
+
+  test('w/ normal <script> binding analysis', () => {
+    const { content } = compile(
+      `<script>
+      export default {
+        setup() {
+          return {
+            size: ref('100px')
+          }
+        }
+      }
+      </script>\n` +
+        `<style>
+          div {
+            font-size: v-bind(size);
+          }
+        </style>`
+    )
+    expect(content).toMatch(`_useCssVars((_vm, _setup) => ({
+  "${mockId}-size": (_vm.size)
+})`)
+    expect(content).toMatch(`import { useCssVars as _useCssVars } from 'vue'`)
+    assertCode(content)
+  })
+
+  test('w/ <script setup> binding analysis', () => {
+    const { content } = compile(
+      `<script setup>
+        import { defineProps, ref } from 'vue'
+        const color = 'red'
+        const size = ref('10px')
+        defineProps({
+          foo: String
+        })
+        </script>\n` +
+        `<style>
+          div {
+            color: v-bind(color);
+            font-size: v-bind(size);
+            border: v-bind(foo);
+          }
+        </style>`
+    )
+    // should handle:
+    // 1. local const bindings
+    // 2. local potential ref bindings
+    // 3. props bindings (analyzed)
+    expect(content).toMatch(`_useCssVars((_vm, _setup) => ({
+  "${mockId}-color": (_setup.color),
+  "${mockId}-size": (_setup.size),
+  "${mockId}-foo": (_vm.foo)
+})`)
+    expect(content).toMatch(`import { useCssVars as _useCssVars } from 'vue'`)
+    assertCode(content)
+  })
+
+  test('should rewrite CSS vars in compileStyle', () => {
+    const { code } = compileStyle({
+      source: `.foo {
+        color: v-bind(color);
+        font-size: v-bind('font.size');
+      }`,
+      filename: 'test.css',
+      id: 'data-v-test'
+    })
+    expect(code).toMatchInlineSnapshot(`
+      ".foo[data-v-test] {
+              color: var(--test-color);
+              font-size: var(--test-font_size);
+      }"
+    `)
+  })
+
+  test('prod mode', () => {
+    const { content } = compile(
+      `<script>const a = 1</script>\n` +
+        `<style>div{
+          color: v-bind(color);
+          font-size: v-bind('font.size');
+        }</style>`,
+      { isProd: true }
+    )
+    expect(content).toMatch(`_useCssVars((_vm, _setup) => ({
+  "4003f1a6": (_vm.color),
+  "41b6490a": (_vm.font.size)
+}))}`)
+
+    const { code } = compileStyle({
+      source: `.foo {
+        color: v-bind(color);
+        font-size: v-bind('font.size');
+      }`,
+      filename: 'test.css',
+      id: mockId,
+      isProd: true
+    })
+    expect(code).toMatchInlineSnapshot(`
+      ".foo[xxxxxxxx] {
+              color: var(--4003f1a6);
+              font-size: var(--41b6490a);
+      }"
+    `)
+  })
+
+  describe('codegen', () => {
+    test('<script> w/ no default export', () => {
+      assertCode(
+        compile(
+          `<script>const a = 1</script>\n` +
+            `<style>div{ color: v-bind(color); }</style>`
+        ).content
+      )
+    })
+
+    test('<script> w/ default export', () => {
+      assertCode(
+        compile(
+          `<script>export default { setup() {} }</script>\n` +
+            `<style>div{ color: v-bind(color); }</style>`
+        ).content
+      )
+    })
+
+    test('<script> w/ default export in strings/comments', () => {
+      assertCode(
+        compile(
+          `<script>
+          // export default {}
+          export default {}
+        </script>\n` + `<style>div{ color: v-bind(color); }</style>`
+        ).content
+      )
+    })
+
+    test('w/ <script setup>', () => {
+      assertCode(
+        compile(
+          `<script setup>const color = 'red'</script>\n` +
+            `<style>div{ color: v-bind(color); }</style>`
+        ).content
+      )
+    })
+
+    //#4185
+    test('should ignore comments', () => {
+      const { content } = compile(
+        `<script setup>const color = 'red';const width = 100</script>\n` +
+          `<style>
+            /* comment **/
+            div{ /* color: v-bind(color); */ width:20; }
+            div{ width: v-bind(width); }
+            /* comment */
+          </style>`
+      )
+
+      expect(content).not.toMatch(`"${mockId}-color": (_setup.color)`)
+      expect(content).toMatch(`"${mockId}-width": (_setup.width)`)
+      assertCode(content)
+    })
+
+    test('w/ <script setup> using the same var multiple times', () => {
+      const { content } = compile(
+        `<script setup>
+        const color = 'red'
+        </script>\n` +
+          `<style>
+          div {
+            color: v-bind(color);
+          }
+          p {
+            color: v-bind(color);
+          }
+        </style>`
+      )
+      // color should only be injected once, even if it is twice in style
+      expect(content).toMatch(`_useCssVars((_vm, _setup) => ({
+  "${mockId}-color": (_setup.color)
+})`)
+      assertCode(content)
+    })
+
+    test('should work with w/ complex expression', () => {
+      const { content } = compile(
+        `<script setup>
+        let a = 100
+        let b = 200
+        let foo = 300
+        </script>\n` +
+          `<style>
+          p{
+            width: calc(v-bind(foo) - 3px);
+            height: calc(v-bind('foo') - 3px);
+            top: calc(v-bind(foo + 'px') - 3px);
+          }
+          div {
+            color: v-bind((a + b) / 2 + 'px' );
+          }
+          div {
+            color: v-bind    ((a + b) / 2 + 'px' );
+          }
+          p {
+            color: v-bind(((a + b)) / (2 * a));
+          }
+        </style>`
+      )
+      expect(content).toMatch(`_useCssVars((_vm, _setup) => ({
+  "${mockId}-foo": (_setup.foo),
+  "${mockId}-foo____px_": (_setup.foo + 'px'),
+  "${mockId}-_a___b____2____px_": ((_setup.a + _setup.b) / 2 + 'px'),
+  "${mockId}-__a___b______2___a_": (((_setup.a + _setup.b)) / (2 * _setup.a))
+})`)
+      assertCode(content)
+    })
+
+    // #6022
+    test('should be able to parse incomplete expressions', () => {
+      const { cssVars } = parse({
+        source: `<script setup>let xxx = 1</script>
+        <style scoped>
+        label {
+          font-weight: v-bind("count.toString(");
+          font-weight: v-bind(xxx);
+        }
+        </style>`
+      })
+      expect(cssVars).toMatchObject([`count.toString(`, `xxx`])
+    })
+  })
+})
diff --git a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
index f9bc93978c7..8bc5d7722dc 100644
--- a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
+++ b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
@@ -3,6 +3,8 @@ import { compile } from 'web/entry-compiler'
 import { format } from 'prettier'
 import { BindingTypes } from '../src/types'
 
+const toFn = (source: string) => `function render(){${source}\n}`
+
 it('should work', () => {
   const { render } = compile(`<div id="app">
   <div>{{ foo }}</div>
@@ -12,7 +14,7 @@ it('should work', () => {
   </foo>
 </div>`)
 
-  const result = format(prefixIdentifiers(render, `render`), {
+  const result = format(prefixIdentifiers(toFn(render)), {
     semi: false,
     parser: 'babel'
   })
@@ -59,7 +61,7 @@ it('setup bindings', () => {
   const { render } = compile(`<div @click="count++">{{ count }}</div>`)
 
   const result = format(
-    prefixIdentifiers(render, `render`, false, false, undefined, {
+    prefixIdentifiers(toFn(render), false, false, undefined, {
       count: BindingTypes.SETUP_REF
     }),
     {
diff --git a/packages/compiler-sfc/test/util.ts b/packages/compiler-sfc/test/util.ts
new file mode 100644
index 00000000000..773158999de
--- /dev/null
+++ b/packages/compiler-sfc/test/util.ts
@@ -0,0 +1,35 @@
+import {
+  parse,
+  compileScript,
+  type SFCParseOptions,
+  type SFCScriptCompileOptions
+} from '../src'
+import { parse as babelParse } from '@babel/parser'
+
+export const mockId = 'xxxxxxxx'
+
+export function compile(
+  source: string,
+  options?: Partial<SFCScriptCompileOptions>,
+  parseOptions?: Partial<SFCParseOptions>
+) {
+  const sfc = parse({
+    ...parseOptions,
+    source
+  })
+  return compileScript(sfc, { id: mockId, ...options })
+}
+
+export function assertCode(code: string) {
+  // parse the generated code to make sure it is valid
+  try {
+    babelParse(code, {
+      sourceType: 'module',
+      plugins: ['typescript']
+    })
+  } catch (e: any) {
+    console.log(code)
+    throw e
+  }
+  expect(code).toMatchSnapshot()
+}
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index b3540fd75b5..123f921135a 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -86,13 +86,17 @@ export function proxyWithRefUnwrap(
   source: Record<string, any>,
   key: string
 ) {
-  let raw = source[key]
   Object.defineProperty(target, key, {
     enumerable: true,
     configurable: true,
-    get: () => (isRef(raw) ? raw.value : raw),
-    set: newVal =>
-      isRef(raw) ? (raw.value = newVal) : (raw = source[key] = newVal)
+    get: () => {
+      const raw = source[key]
+      return isRef(raw) ? raw.value : raw
+    },
+    set: newVal => {
+      const raw = source[key]
+      isRef(raw) ? (raw.value = newVal) : (source[key] = newVal)
+    }
   })
 }
 
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 044fd27c43b..e2bec70e8fe 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -77,6 +77,7 @@ export { nextTick } from 'core/util/next-tick'
 export { set, del } from 'core/observer'
 
 export { useCssModule } from './sfc-helpers/useCssModule'
+export { useCssVars } from './sfc-helpers/useCssVars'
 
 /**
  * @internal type is manually declared in <root>/types/v3-define-component.d.ts
diff --git a/src/v3/sfc-helpers/useCssVars.ts b/src/v3/sfc-helpers/useCssVars.ts
new file mode 100644
index 00000000000..cba7050a0e7
--- /dev/null
+++ b/src/v3/sfc-helpers/useCssVars.ts
@@ -0,0 +1,34 @@
+import { watchPostEffect } from '../'
+import { inBrowser, warn } from 'core/util'
+import { currentInstance } from '../currentInstance'
+
+/**
+ * Runtime helper for SFC's CSS variable injection feature.
+ * @private
+ */
+export function useCssVars(
+  getter: (
+    vm: Record<string, any>,
+    setupProxy: Record<string, any>
+  ) => Record<string, string>
+) {
+  if (!inBrowser && !__TEST__) return
+
+  const instance = currentInstance
+  if (!instance) {
+    __DEV__ &&
+      warn(`useCssVars is called without current active component instance.`)
+    return
+  }
+
+  watchPostEffect(() => {
+    const el = instance.$el
+    const vars = getter(instance, instance._setupProxy!)
+    if (el && el.nodeType === 1) {
+      const style = (el as HTMLElement).style
+      for (const key in vars) {
+        style.setProperty(`--${key}`, vars[key])
+      }
+    }
+  })
+}
diff --git a/test/unit/features/v3/useCssVars.spec.ts b/test/unit/features/v3/useCssVars.spec.ts
new file mode 100644
index 00000000000..76bb6cca6e2
--- /dev/null
+++ b/test/unit/features/v3/useCssVars.spec.ts
@@ -0,0 +1,48 @@
+import Vue from 'vue'
+import { useCssVars, h, reactive, nextTick } from 'v3'
+
+describe('useCssVars', () => {
+  async function assertCssVars(getApp: (state: any) => any) {
+    const state = reactive({ color: 'red' })
+    const App = getApp(state)
+    const vm = new Vue(App).$mount()
+    await nextTick()
+    expect((vm.$el as HTMLElement).style.getPropertyValue(`--color`)).toBe(
+      `red`
+    )
+
+    state.color = 'green'
+    await nextTick()
+    expect((vm.$el as HTMLElement).style.getPropertyValue(`--color`)).toBe(
+      `green`
+    )
+  }
+
+  test('basic', async () => {
+    await assertCssVars(state => ({
+      setup() {
+        // test receiving render context
+        useCssVars(vm => ({
+          color: vm.color
+        }))
+        return state
+      },
+      render() {
+        return h('div')
+      }
+    }))
+  })
+
+  test('on HOCs', async () => {
+    const Child = {
+      render: () => h('div')
+    }
+
+    await assertCssVars(state => ({
+      setup() {
+        useCssVars(() => state)
+        return () => h(Child)
+      }
+    }))
+  })
+})
diff --git a/vitest.config.ts b/vitest.config.ts
index 14999481936..52e5ea66489 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -13,7 +13,8 @@ export default defineConfig({
       shared: resolve('src/shared'),
       web: resolve('src/platforms/web'),
       v3: resolve('src/v3'),
-      vue: resolve('src/platforms/web/entry-runtime-with-compiler')
+      vue: resolve('src/platforms/web/entry-runtime-with-compiler'),
+      types: resolve('src/types')
     }
   },
   define: {

From d3916b69b491bb0964102b69a8bb2e9336f7677b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 15:48:54 +0800
Subject: [PATCH 177/317] feat(sfc): parse needMap compat

---
 packages/compiler-sfc/src/parse.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index 6901238117d..2203ab89ce3 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -23,6 +23,10 @@ export interface SFCParseOptions {
   compilerParseOptions?: VueTemplateCompilerParseOptions
   sourceRoot?: string
   sourceMap?: boolean
+  /**
+   * @deprecated use `sourceMap` instead.
+   */
+  needMap?: boolean
 }
 
 export function parse(options: SFCParseOptions): SFCDescriptor {
@@ -32,7 +36,8 @@ export function parse(options: SFCParseOptions): SFCDescriptor {
     compiler,
     compilerParseOptions = { pad: false } as VueTemplateCompilerParseOptions,
     sourceRoot = '',
-    sourceMap = true
+    needMap = true,
+    sourceMap = needMap
   } = options
   const cacheKey = hash(
     filename + source + JSON.stringify(compilerParseOptions)

From 0f2cede3748eab94d1f14333c079c9886cc194e5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 16:10:14 +0800
Subject: [PATCH 178/317] build: move cssVars logic into compiler-sfc entry

---
 packages/compiler-sfc/src/parse.ts          | 5 +++++
 packages/compiler-sfc/src/parseComponent.ts | 4 ----
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/packages/compiler-sfc/src/parse.ts b/packages/compiler-sfc/src/parse.ts
index 2203ab89ce3..4b73a7ab01f 100644
--- a/packages/compiler-sfc/src/parse.ts
+++ b/packages/compiler-sfc/src/parse.ts
@@ -10,6 +10,7 @@ import {
 import hash from 'hash-sum'
 import LRU from 'lru-cache'
 import { hmrShouldReload } from './compileScript'
+import { parseCssVars } from './cssVars'
 
 const cache = new LRU<string, SFCDescriptor>(100)
 
@@ -57,6 +58,10 @@ export function parse(options: SFCParseOptions): SFCDescriptor {
   }
 
   output.filename = filename
+
+  // parse CSS vars
+  output.cssVars = parseCssVars(output)
+
   output.shouldForceReload = prevImports =>
     hmrShouldReload(prevImports, output!)
 
diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 85d74560759..0849a649c2e 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -4,7 +4,6 @@ import { makeMap } from 'shared/util'
 import { ASTAttr, WarningMessage } from 'types/compiler'
 import { BindingMetadata, RawSourceMap } from './types'
 import type { ImportBinding } from './compileScript'
-import { parseCssVars } from './cssVars'
 
 export const DEFAULT_FILENAME = 'anonymous.vue'
 
@@ -209,8 +208,5 @@ export function parseComponent(
     outputSourceRange: options.outputSourceRange
   })
 
-  // parse CSS vars
-  sfc.cssVars = parseCssVars(sfc)
-
   return sfc
 }

From c9d0e3aee1a4cf2f7bda7d69b66972084b74b737 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 16:22:54 +0800
Subject: [PATCH 179/317] ci: e2e test fix

---
 examples/composition/todomvc.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/composition/todomvc.html b/examples/composition/todomvc.html
index c80f2fe3959..d95b39d2735 100644
--- a/examples/composition/todomvc.html
+++ b/examples/composition/todomvc.html
@@ -1,4 +1,4 @@
-<script src="../../dist/vue.js"></script>
+<script src="../../dist/vue.min.js"></script>
 <link
   rel="stylesheet"
   href="../../node_modules/todomvc-app-css/index.css"
@@ -90,7 +90,7 @@ <h1>todos</h1>
 <script>
   const { reactive, computed, watchEffect, onMounted, onUnmounted } = Vue
 
-  const STORAGE_KEY = 'todos-vuejs-3.x'
+  const STORAGE_KEY = 'todos-vuejs-3.x-composition'
   const todoStorage = {
     fetch() {
       const todos = JSON.parse(localStorage.getItem(STORAGE_KEY) || '[]')

From de03f69cd6780272e351efed743585ccf110be19 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 20 Jun 2022 16:34:23 +0800
Subject: [PATCH 180/317] release: v2.7.0-beta.3

---
 CHANGELOG.md                            | 18 ++++++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d3955240f46..9e8c7505a33 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,21 @@
+# [2.7.0-beta.3](https://github.com/vuejs/vue/compare/v2.7.0-beta.2...v2.7.0-beta.3) (2022-06-20)
+
+
+### Bug Fixes
+
+* remove wrong observe toggle, properly disable tracking in setup() ([2d67641](https://github.com/vuejs/vue/commit/2d676416566c06d7c789899c92bf0f6924ec284a))
+* **setup:** setup props should pass isReactive check ([52cf912](https://github.com/vuejs/vue/commit/52cf912d855a7fae8d8c89452f0d275846e26a87)), closes [#12561](https://github.com/vuejs/vue/issues/12561)
+* **template-ref:** preserve ref removal behavior in non-composition-api usage ([2533a36](https://github.com/vuejs/vue/commit/2533a360a838c41238dc9b9b840932f2957c65d4)), closes [#12554](https://github.com/vuejs/vue/issues/12554)
+
+
+### Features
+
+* **sfc:** css v-bind ([8ab0074](https://github.com/vuejs/vue/commit/8ab0074bab83473fd025ae538a3455e3277320c4))
+* **sfc:** parse needMap compat ([d3916b6](https://github.com/vuejs/vue/commit/d3916b69b491bb0964102b69a8bb2e9336f7677b))
+* useCssModules ([0fabda7](https://github.com/vuejs/vue/commit/0fabda7a3b016c1c0cb5d92f5d8efc35f0dbde40))
+
+
+
 # [2.7.0-beta.2](https://github.com/vuejs/vue/compare/v2.7.0-beta.1...v2.7.0-beta.2) (2022-06-17)
 
 
diff --git a/package.json b/package.json
index ffc25629fa4..ff48f1b15c7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.2",
+  "version": "2.7.0-beta.3",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index b3b63867f47..bf0c4619aba 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.2",
+  "version": "2.7.0-beta.3",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index fdab5b63970..b75153ba296 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.2",
+  "version": "2.7.0-beta.3",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index b9da6a43a2a..56deda28529 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.2",
+  "version": "2.7.0-beta.3",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 9b9f2bf1c8429136e7122d146e0e39bdeada5d1d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 21 Jun 2022 09:41:30 +0800
Subject: [PATCH 181/317] fix(compiler-sfc): properly handle shorthand property
 in template expressions

fix #12566
---
 .../compiler-sfc/src/prefixIdentifiers.ts     | 34 +++++++++----------
 .../test/prefixIdentifiers.spec.ts            |  5 +--
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/packages/compiler-sfc/src/prefixIdentifiers.ts b/packages/compiler-sfc/src/prefixIdentifiers.ts
index d8dd1868cd9..25ea5b9109b 100644
--- a/packages/compiler-sfc/src/prefixIdentifiers.ts
+++ b/packages/compiler-sfc/src/prefixIdentifiers.ts
@@ -1,7 +1,7 @@
 import MagicString from 'magic-string'
 import { parseExpression, ParserOptions, ParserPlugin } from '@babel/parser'
 import { makeMap } from 'shared/util'
-import { walkIdentifiers } from './babelUtils'
+import { isStaticProperty, walkIdentifiers } from './babelUtils'
 import { BindingMetadata } from './types'
 
 const doNotPrefix = makeMap(
@@ -39,18 +39,28 @@ export function prefixIdentifiers(
 
   walkIdentifiers(
     ast,
-    ident => {
+    (ident, parent) => {
       const { name } = ident
       if (doNotPrefix(name)) {
         return
       }
 
-      if (!isScriptSetup) {
-        s.prependRight(ident.start!, '_vm.')
-        return
+      let prefix = `_vm.`
+      if (isScriptSetup) {
+        const type = bindings[name]
+        if (type && type.startsWith('setup')) {
+          prefix = `_setup.`
+        }
       }
 
-      s.overwrite(ident.start!, ident.end!, rewriteIdentifier(name, bindings))
+      if (isStaticProperty(parent) && parent.shorthand) {
+        // property shorthand like { foo }, we need to add the key since
+        // we rewrite the value
+        // { foo } -> { foo: _vm.foo }
+        s.appendLeft(ident.end!, `: ${prefix}${name}`)
+      } else {
+        s.prependRight(ident.start!, prefix)
+      }
     },
     node => {
       if (node.type === 'WithStatement') {
@@ -70,15 +80,3 @@ export function prefixIdentifiers(
 
   return s.toString()
 }
-
-export function rewriteIdentifier(
-  name: string,
-  bindings: BindingMetadata
-): string {
-  const type = bindings[name]
-  if (type && type.startsWith('setup')) {
-    return `_setup.${name}`
-  } else {
-    return `_vm.${name}`
-  }
-}
diff --git a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
index 8bc5d7722dc..6d679d67933 100644
--- a/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
+++ b/packages/compiler-sfc/test/prefixIdentifiers.spec.ts
@@ -7,7 +7,7 @@ const toFn = (source: string) => `function render(){${source}\n}`
 
 it('should work', () => {
   const { render } = compile(`<div id="app">
-  <div>{{ foo }}</div>
+  <div :style="{ color }">{{ foo }}</div>
   <p v-for="i in list">{{ i }}</p>
   <foo inline-template>
     <div>{{ bar }}</div>
@@ -22,6 +22,7 @@ it('should work', () => {
   expect(result).not.toMatch(`_vm._c`)
   expect(result).toMatch(`_vm.foo`)
   expect(result).toMatch(`_vm.list`)
+  expect(result).toMatch(`{ color: _vm.color }`)
   expect(result).not.toMatch(`_vm.i`)
   expect(result).not.toMatch(`with (this)`)
 
@@ -33,7 +34,7 @@ it('should work', () => {
         \\"div\\",
         { attrs: { id: \\"app\\" } },
         [
-          _c(\\"div\\", [_vm._v(_vm._s(_vm.foo))]),
+          _c(\\"div\\", { style: { color: _vm.color } }, [_vm._v(_vm._s(_vm.foo))]),
           _vm._v(\\" \\"),
           _vm._l(_vm.list, function (i) {
             return _c(\\"p\\", [_vm._v(_vm._s(i))])

From a122bd25c3c453c91a7f35b54b2c75df8b0b1f24 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 21 Jun 2022 10:51:19 +0800
Subject: [PATCH 182/317] release: v2.7.0-beta.4

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e8c7505a33..39ea759de61 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-beta.4](https://github.com/vuejs/vue/compare/v2.7.0-beta.3...v2.7.0-beta.4) (2022-06-21)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** properly handle shorthand property in template expressions ([9b9f2bf](https://github.com/vuejs/vue/commit/9b9f2bf1c8429136e7122d146e0e39bdeada5d1d)), closes [#12566](https://github.com/vuejs/vue/issues/12566)
+
+
+
 # [2.7.0-beta.3](https://github.com/vuejs/vue/compare/v2.7.0-beta.2...v2.7.0-beta.3) (2022-06-20)
 
 
diff --git a/package.json b/package.json
index ff48f1b15c7..f20620fde7c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.3",
+  "version": "2.7.0-beta.4",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index bf0c4619aba..76d38193215 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.3",
+  "version": "2.7.0-beta.4",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index b75153ba296..b995077cb7a 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.3",
+  "version": "2.7.0-beta.4",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 56deda28529..907475ee5b7 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.3",
+  "version": "2.7.0-beta.4",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 65531f580314d832f44ecd5c782f79da3e977da7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 22 Jun 2022 09:44:41 +0800
Subject: [PATCH 183/317] fix(types): fix instance type inference for setup()
 with no return value

fix #12568
---
 types/test/v3/setup-test.ts | 8 ++++++++
 types/vue.d.ts              | 7 ++++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/types/test/v3/setup-test.ts b/types/test/v3/setup-test.ts
index 15572f736e9..4fdec92d92d 100644
--- a/types/test/v3/setup-test.ts
+++ b/types/test/v3/setup-test.ts
@@ -93,3 +93,11 @@ defineComponent({
     res?.charAt(1)
   }
 })
+
+// #12568
+const vm = new Vue({
+  setup() {},
+  render: h => h({})
+})
+
+vm.$mount('#app')
diff --git a/types/vue.d.ts b/types/vue.d.ts
index 696a2f75b46..afa66b5c2c5 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -85,7 +85,12 @@ export type CombinedVueInstance<
   Computed,
   Props,
   SetupBindings
-> = Data & Methods & Computed & Props & Instance & SetupBindings
+> = Data &
+  Methods &
+  Computed &
+  Props &
+  Instance &
+  (SetupBindings extends void ? {} : SetupBindings)
 
 export type ExtendedVue<
   Instance extends Vue,

From fb7f5f0b6741a33960946175c4d8d35e31eee9f6 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 22 Jun 2022 10:12:52 +0800
Subject: [PATCH 184/317] chore: remove unused code

Vue 2 has no inline mode so template ref ref_key logic is unnecessary
---
 src/core/vdom/modules/template-ref.ts         |  3 --
 .../unit/features/v3/setupTemplateRef.spec.ts | 46 +++++++++----------
 2 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/src/core/vdom/modules/template-ref.ts b/src/core/vdom/modules/template-ref.ts
index 0cbb2a46067..27461fd94ba 100644
--- a/src/core/vdom/modules/template-ref.ts
+++ b/src/core/vdom/modules/template-ref.ts
@@ -40,7 +40,6 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
     return
   }
 
-  const setupRefKey = vnode.data.ref_key
   const isFor = vnode.data.refInFor
   const _isString = typeof ref === 'string' || typeof ref === 'number'
   const _isRef = isRef(ref)
@@ -58,7 +57,6 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
             setSetupRef(vm, ref, refs[ref])
           } else {
             ref.value = [refValue]
-            if (setupRefKey) refs[setupRefKey] = ref.value as any
           }
         } else if (!existing.includes(refValue)) {
           existing.push(refValue)
@@ -75,7 +73,6 @@ export function registerRef(vnode: VNodeWithData, isRemoval?: boolean) {
         return
       }
       ref.value = value
-      if (setupRefKey) refs[setupRefKey] = $refsValue
     } else if (__DEV__) {
       warn(`Invalid template ref type: ${typeof ref}`)
     }
diff --git a/test/unit/features/v3/setupTemplateRef.spec.ts b/test/unit/features/v3/setupTemplateRef.spec.ts
index 189b3a1ed28..5ac6b879875 100644
--- a/test/unit/features/v3/setupTemplateRef.spec.ts
+++ b/test/unit/features/v3/setupTemplateRef.spec.ts
@@ -371,33 +371,33 @@ describe('api: setup() template refs', () => {
   //   expect(elRef1.value).toBe(elRef2.value)
   // })
 
-  // compiled output of <script setup> inline mode
-  test('raw ref with ref_key', () => {
-    let refs: any
+  // Vue 2 doesn't have inline mode
+  // test('raw ref with ref_key', () => {
+  //   let refs: any
 
-    const el = ref()
+  //   const el = ref()
 
-    const App = {
-      mounted() {
-        refs = (this as any).$refs
-      },
-      render() {
-        return h(
-          'div',
-          {
-            ref: el,
-            ref_key: 'el'
-          },
-          'hello'
-        )
-      }
-    }
+  //   const App = {
+  //     mounted() {
+  //       refs = (this as any).$refs
+  //     },
+  //     render() {
+  //       return h(
+  //         'div',
+  //         {
+  //           ref: el,
+  //           ref_key: 'el'
+  //         },
+  //         'hello'
+  //       )
+  //     }
+  //   }
 
-    new Vue(App).$mount()
+  //   new Vue(App).$mount()
 
-    expect(el.value.innerHTML).toBe('hello')
-    expect(refs.el.innerHTML).toBe('hello')
-  })
+  //   expect(el.value.innerHTML).toBe('hello')
+  //   expect(refs.el.innerHTML).toBe('hello')
+  // })
 
   // compiled output of v-for + template ref
   test('ref in v-for', async () => {

From 7a3aa3faac6b8eb066f32813788b4c1d16f34c6b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 22 Jun 2022 10:20:02 +0800
Subject: [PATCH 185/317] fix(watch): fix pre watchers not flushed on mount for
 nested component

fix #12569
---
 src/core/instance/lifecycle.ts         | 14 ++++++++------
 test/unit/features/v3/apiWatch.spec.ts | 17 +++++++++++++++++
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 5c559daaa23..171c4e5d9a5 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -218,15 +218,17 @@ export function mountComponent(
   )
   hydrating = false
 
+  // flush buffer for flush: "pre" watchers queued in setup()
+  const preWatchers = vm._preWatchers
+  if (preWatchers) {
+    for (let i = 0; i < preWatchers.length; i++) {
+      preWatchers[i].run()
+    }
+  }
+
   // manually mounted instance, call mounted on self
   // mounted is called for render-created child components in its inserted hook
   if (vm.$vnode == null) {
-    const preWatchers = vm._preWatchers
-    if (preWatchers) {
-      for (let i = 0; i < preWatchers.length; i++) {
-        preWatchers[i].run()
-      }
-    }
     vm._isMounted = true
     callHook(vm, 'mounted')
   }
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 9a7bcd9410f..85ee2ef8400 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -336,6 +336,23 @@ describe('api: watch', () => {
     expect(result2).toBe(true)
   })
 
+  // #12569
+  it('flush:pre watcher triggered before component mount (in child components)', () => {
+    const count = ref(0)
+    const spy = vi.fn()
+    const Comp = {
+      setup() {
+        watch(count, spy)
+        count.value++
+        return h => h('div')
+      }
+    }
+    new Vue({
+      render: h => h(Comp)
+    }).$mount()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
   it('flush timing: post', async () => {
     const count = ref(0)
     let result

From 530b56a36e4689249dce6eba6e5c50e3305346f4 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 22 Jun 2022 10:22:49 +0800
Subject: [PATCH 186/317] release: v2.7.0-beta.5

---
 CHANGELOG.md                            | 10 ++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 39ea759de61..34dacce5f0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+# [2.7.0-beta.5](https://github.com/vuejs/vue/compare/v2.7.0-beta.4...v2.7.0-beta.5) (2022-06-22)
+
+
+### Bug Fixes
+
+* **types:** fix instance type inference for setup() with no return value ([65531f5](https://github.com/vuejs/vue/commit/65531f580314d832f44ecd5c782f79da3e977da7)), closes [#12568](https://github.com/vuejs/vue/issues/12568)
+* **watch:** fix pre watchers not flushed on mount for nested component ([7a3aa3f](https://github.com/vuejs/vue/commit/7a3aa3faac6b8eb066f32813788b4c1d16f34c6b)), closes [#12569](https://github.com/vuejs/vue/issues/12569)
+
+
+
 # [2.7.0-beta.4](https://github.com/vuejs/vue/compare/v2.7.0-beta.3...v2.7.0-beta.4) (2022-06-21)
 
 
diff --git a/package.json b/package.json
index f20620fde7c..af772f02f25 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.4",
+  "version": "2.7.0-beta.5",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 76d38193215..4892e1d6f4c 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.4",
+  "version": "2.7.0-beta.5",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index b995077cb7a..395b2df7be2 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.4",
+  "version": "2.7.0-beta.5",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 907475ee5b7..94c6f107481 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.4",
+  "version": "2.7.0-beta.5",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 44ab1cda746252a1a81f88e1a9658d33f484ed41 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 23 Jun 2022 08:34:26 +0800
Subject: [PATCH 187/317] fix(reactivity): readonly() compat with classes

fix #12574
---
 src/v3/reactivity/readonly.ts                 |  2 +-
 .../features/v3/reactivity/readonly.spec.ts   | 21 +++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/v3/reactivity/readonly.ts b/src/v3/reactivity/readonly.ts
index 19179e02bba..933f910b69f 100644
--- a/src/v3/reactivity/readonly.ts
+++ b/src/v3/reactivity/readonly.ts
@@ -69,7 +69,7 @@ function createReadonly(target: any, shallow: boolean) {
     return existingProxy
   }
 
-  const proxy = {}
+  const proxy = Object.create(Object.getPrototypeOf(target))
   def(target, existingFlag, proxy)
 
   def(proxy, ReactiveFlags.IS_READONLY, true)
diff --git a/test/unit/features/v3/reactivity/readonly.spec.ts b/test/unit/features/v3/reactivity/readonly.spec.ts
index ab4c52f7ce7..11550ab56ed 100644
--- a/test/unit/features/v3/reactivity/readonly.spec.ts
+++ b/test/unit/features/v3/reactivity/readonly.spec.ts
@@ -499,4 +499,25 @@ describe('reactivity/readonly', () => {
     expect(obj.ror).toBe(true)
     expect(toRaw(obj).ror).not.toBe(ror) // ref successfully replaced
   })
+
+  test('compatiblity with classes', () => {
+    const spy = vi.fn()
+    class Foo {
+      x = 1
+      log() {
+        spy(this.x)
+      }
+      change() {
+        this.x++
+      }
+    }
+    const foo = new Foo()
+    const readonlyFoo = readonly(foo)
+    readonlyFoo.log()
+    expect(spy).toHaveBeenCalledWith(1)
+
+    readonlyFoo.change()
+    expect(readonlyFoo.x).toBe(1)
+    expect(`et operation on key "x" failed`).toHaveBeenWarned()
+  })
 })

From 089b27c30b470acd98286ffe072525beb2320dea Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 26 Jun 2022 16:36:47 +0800
Subject: [PATCH 188/317] fix(watch): template ref watcher should fire after
 owner instance mounted hook

fix #12578
---
 src/v3/apiWatch.ts                     |  7 ++++---
 test/unit/features/v3/apiWatch.spec.ts | 27 ++++++++++++++++++++++++--
 2 files changed, 29 insertions(+), 5 deletions(-)

diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 909bd0258ec..4d387dc1c1a 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -320,11 +320,12 @@ function doWatch(
   } else {
     // pre
     watcher.update = () => {
-      if (!instance || instance._isMounted) {
-        queueWatcher(watcher)
-      } else {
+      if (instance && instance === currentInstance) {
+        // pre-watcher triggered inside setup()
         const buffer = instance._preWatchers || (instance._preWatchers = [])
         if (buffer.indexOf(watcher) < 0) buffer.push(watcher)
+      } else {
+        queueWatcher(watcher)
       }
     }
   }
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 85ee2ef8400..82aba414ce0 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -628,9 +628,8 @@ describe('api: watch', () => {
     expect(calls).toMatchObject(['watch 3', 'mounted'])
   })
 
-  // TODO
   // vuejs/core#1852
-  it.skip('flush: post watcher should fire after template refs updated', async () => {
+  it('flush: post watcher should fire after template refs updated', async () => {
     const toggle = ref(false)
     let dom: HTMLElement | null = null
 
@@ -1093,4 +1092,28 @@ describe('api: watch', () => {
     // own update effect
     expect(instance!._scope.effects.length).toBe(1)
   })
+
+  // #12578
+  test('template ref triggered watcher should fire after component mount', async () => {
+    const order: string[] = []
+    const Child = { template: '<div/>' }
+    const App = {
+      setup() {
+        const child = ref<any>(null)
+        onMounted(() => {
+          order.push('mounted')
+        })
+        watch(child, () => {
+          order.push('watcher')
+        })
+        return { child }
+      },
+      components: { Child },
+      template: `<Child ref="child"/>`
+    }
+    new Vue(App).$mount()
+
+    await nextTick()
+    expect(order).toMatchObject([`mounted`, `watcher`])
+  })
 })

From 20e7e7e138070a2f0c85f64529c837f00255da1c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sun, 26 Jun 2022 16:41:54 +0800
Subject: [PATCH 189/317] release: v2.7.0-beta.6

---
 CHANGELOG.md                            | 10 ++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 34dacce5f0f..a1116cd8c7b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,13 @@
+# [2.7.0-beta.6](https://github.com/vuejs/vue/compare/v2.7.0-beta.5...v2.7.0-beta.6) (2022-06-26)
+
+
+### Bug Fixes
+
+* **reactivity:** readonly() compat with classes ([44ab1cd](https://github.com/vuejs/vue/commit/44ab1cda746252a1a81f88e1a9658d33f484ed41)), closes [#12574](https://github.com/vuejs/vue/issues/12574)
+* **watch:** template ref watcher should fire after owner instance mounted hook ([089b27c](https://github.com/vuejs/vue/commit/089b27c30b470acd98286ffe072525beb2320dea)), closes [#12578](https://github.com/vuejs/vue/issues/12578)
+
+
+
 # [2.7.0-beta.5](https://github.com/vuejs/vue/compare/v2.7.0-beta.4...v2.7.0-beta.5) (2022-06-22)
 
 
diff --git a/package.json b/package.json
index af772f02f25..31aa27f05bc 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.5",
+  "version": "2.7.0-beta.6",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 4892e1d6f4c..0307c1b8bac 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.5",
+  "version": "2.7.0-beta.6",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 395b2df7be2..9955664cb03 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.5",
+  "version": "2.7.0-beta.6",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 94c6f107481..77c7d54441e 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.5",
+  "version": "2.7.0-beta.6",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 11e4bfe806b574747495edfb9ba22f78676ceb7c Mon Sep 17 00:00:00 2001
From: lsdsjy <lsdsjy@163.com>
Date: Mon, 27 Jun 2022 14:50:41 +0800
Subject: [PATCH 190/317] fix: types/v3-directive not published (#12571)

---
 types/{v3-directive.ts => v3-directive.d.ts} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename types/{v3-directive.ts => v3-directive.d.ts} (100%)

diff --git a/types/v3-directive.ts b/types/v3-directive.d.ts
similarity index 100%
rename from types/v3-directive.ts
rename to types/v3-directive.d.ts

From 5b94562dcda45be330749400ab00e3037cc8d2a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=8D=89=E9=9E=8B=E6=B2=A1=E5=8F=B7?= <308487730@qq.com>
Date: Mon, 27 Jun 2022 14:52:28 +0800
Subject: [PATCH 191/317] chore: create build target dir if does not exist
 (#12581)

---
 scripts/build.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/scripts/build.js b/scripts/build.js
index 939bb2bffe8..2468512af4c 100644
--- a/scripts/build.js
+++ b/scripts/build.js
@@ -67,6 +67,9 @@ function write (dest, code, zip) {
       resolve()
     }
 
+    if (!fs.existsSync(path.dirname(dest))) {
+      fs.mkdirSync(path.dirname(dest), { recursive: true })
+    }
     fs.writeFile(dest, code, err => {
       if (err) return reject(err)
       if (zip) {

From bf64c4da5ca516924d940bb29f3e59b0fa5863c9 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 27 Jun 2022 15:00:30 +0800
Subject: [PATCH 192/317] release: v2.7.0-beta.7

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a1116cd8c7b..20f4b86b31d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-beta.7](https://github.com/vuejs/vue/compare/v2.7.0-beta.6...v2.7.0-beta.7) (2022-06-27)
+
+
+### Bug Fixes
+
+* types/v3-directive not published ([#12571](https://github.com/vuejs/vue/issues/12571)) ([11e4bfe](https://github.com/vuejs/vue/commit/11e4bfe806b574747495edfb9ba22f78676ceb7c))
+
+
+
 # [2.7.0-beta.6](https://github.com/vuejs/vue/compare/v2.7.0-beta.5...v2.7.0-beta.6) (2022-06-26)
 
 
diff --git a/package.json b/package.json
index 31aa27f05bc..24d6f936a84 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.6",
+  "version": "2.7.0-beta.7",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 0307c1b8bac..649ad64335b 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.6",
+  "version": "2.7.0-beta.7",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 9955664cb03..874bceff0b3 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.6",
+  "version": "2.7.0-beta.7",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 77c7d54441e..854f6d44d56 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.6",
+  "version": "2.7.0-beta.7",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 008d78bd7280716d2d70e150e3ed2ac5ee8497f2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 28 Jun 2022 09:57:19 +0800
Subject: [PATCH 193/317] fix(compiler-sfc): should transform non relative
 paths when base option is present

fix https://github.com/vitejs/vite-plugin-vue2/issues/14
---
 packages/compiler-sfc/src/templateCompilerModules/utils.ts | 1 -
 packages/compiler-sfc/test/compileTemplate.spec.ts         | 6 +++++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/packages/compiler-sfc/src/templateCompilerModules/utils.ts b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
index fa02fd2bdc4..3e635b00207 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/utils.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
@@ -31,7 +31,6 @@ export function urlToRequire(
         uriParts.path + (uriParts.hash || '')
       )}"`
     }
-    return returnValue
   }
 
   if (
diff --git a/packages/compiler-sfc/test/compileTemplate.spec.ts b/packages/compiler-sfc/test/compileTemplate.spec.ts
index bba5d032ddf..a405d644a47 100644
--- a/packages/compiler-sfc/test/compileTemplate.spec.ts
+++ b/packages/compiler-sfc/test/compileTemplate.spec.ts
@@ -207,6 +207,7 @@ test('transform assetUrls and srcset with base option', () => {
   <img src="~fixtures/logo.png">
   <img src="~/fixtures/logo.png">
   <img src="./logo.png" srcset="./logo.png 2x, ./logo.png 3x">
+  <img src="@/fixtures/logo.png">
 </div>
 `
   const result = compileTemplate({
@@ -218,13 +219,16 @@ test('transform assetUrls and srcset with base option', () => {
 
   expect(result.errors.length).toBe(0)
 
-  const vnode = mockRender(result.code)
+  const vnode = mockRender(result.code, {
+    '@/fixtures/logo.png': 'aliased'
+  })
   expect(vnode.children[0].data.attrs.src).toBe('/base/logo.png')
   expect(vnode.children[2].data.attrs.src).toBe('/base/fixtures/logo.png')
   expect(vnode.children[4].data.attrs.src).toBe('/base/fixtures/logo.png')
   expect(vnode.children[6].data.attrs.srcset).toBe(
     '/base/logo.png 2x, /base/logo.png 3x'
   )
+  expect(vnode.children[8].data.attrs.src).toBe('aliased')
 })
 
 test('transform with includeAbsolute', () => {

From 0ea6c366f5770f016183513792fce8765df47739 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 28 Jun 2022 10:00:08 +0800
Subject: [PATCH 194/317] release: v2.7.0-beta.8

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 20f4b86b31d..5933ea10a97 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0-beta.8](https://github.com/vuejs/vue/compare/v2.7.0-beta.7...v2.7.0-beta.8) (2022-06-28)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** should transform non relative paths when base option is present ([008d78b](https://github.com/vuejs/vue/commit/008d78bd7280716d2d70e150e3ed2ac5ee8497f2))
+
+
+
 # [2.7.0-beta.7](https://github.com/vuejs/vue/compare/v2.7.0-beta.6...v2.7.0-beta.7) (2022-06-27)
 
 
diff --git a/package.json b/package.json
index 24d6f936a84..ddd2b8224c1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.7",
+  "version": "2.7.0-beta.8",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 649ad64335b..d03422e3ace 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.7",
+  "version": "2.7.0-beta.8",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 874bceff0b3..e78adae5f78 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.7",
+  "version": "2.7.0-beta.8",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 854f6d44d56..f2bde139168 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.7",
+  "version": "2.7.0-beta.8",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 326d24a4e42b4f4fd243b36037e88b71963d963d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 30 Jun 2022 10:37:40 +0800
Subject: [PATCH 195/317] fix(sfc): only include legacy decorator parser plugin
 when new plugin is not used

---
 packages/compiler-sfc/src/compileScript.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 7af376bb9cc..d4b02663d06 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -126,7 +126,12 @@ export function compileScript(
       )
   }
   if (options.babelParserPlugins) plugins.push(...options.babelParserPlugins)
-  if (isTS) plugins.push('typescript', 'decorators-legacy')
+  if (isTS) {
+    plugins.push('typescript')
+    if (!plugins.includes('decorators')) {
+      plugins.push('decorators-legacy')
+    }
+  }
 
   if (!scriptSetup) {
     if (!script) {

From 8dc1b31cb8e08edbd5498ef98e7c911e039bc822 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 1 Jul 2022 12:20:29 +0800
Subject: [PATCH 196/317] chore: use v2-latest release tag

---
 scripts/release.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/release.js b/scripts/release.js
index 685b80bb4e5..03c5cf0ad26 100644
--- a/scripts/release.js
+++ b/scripts/release.js
@@ -168,7 +168,7 @@ async function publishPackage(pkgName, version, runIfNotDry) {
     if (releaseTag) {
       releaseTag = `v2-${releaseTag}`
     } else {
-      releaseTag = 'v2'
+      releaseTag = 'v2-latest'
     }
   }
 

From 1e3a0ceb26025868fa8ea9347c897b09307f58c2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 1 Jul 2022 12:22:26 +0800
Subject: [PATCH 197/317] release: v2.7.0

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5933ea10a97..1cac28ce072 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# [2.7.0](https://github.com/vuejs/vue/compare/v2.7.0-beta.8...v2.7.0) (2022-07-01)
+
+
+### Bug Fixes
+
+* **sfc:** only include legacy decorator parser plugin when new plugin is not used ([326d24a](https://github.com/vuejs/vue/commit/326d24a4e42b4f4fd243b36037e88b71963d963d))
+
+
+
 # [2.7.0-beta.8](https://github.com/vuejs/vue/compare/v2.7.0-beta.7...v2.7.0-beta.8) (2022-06-28)
 
 
diff --git a/package.json b/package.json
index ddd2b8224c1..b2e45290992 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0-beta.8",
+  "version": "2.7.0",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index d03422e3ace..da6703796e3 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0-beta.8",
+  "version": "2.7.0",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index e78adae5f78..077cfd53d2f 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0-beta.8",
+  "version": "2.7.0",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index f2bde139168..4db2b577930 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0-beta.8",
+  "version": "2.7.0",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 89bd1c20562181a376b88c630c86b3a20307652c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 1 Jul 2022 12:26:41 +0800
Subject: [PATCH 198/317] chore: changelog [ci skip]

---
 CHANGELOG.md | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1cac28ce072..65065b05e3c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,86 @@
 # [2.7.0](https://github.com/vuejs/vue/compare/v2.7.0-beta.8...v2.7.0) (2022-07-01)
 
+## Backported Features
+
+2.7 backports some of the most important features from Vue 3 so that Vue 2 users can benefit from them as well:
+
+- [Composition API](https://vuejs.org/guide/extras/composition-api-faq.html)
+- SFC [`<script setup>`](https://vuejs.org/api/sfc-script-setup.html)
+- SFC [CSS v-bind](https://vuejs.org/api/sfc-css-features.html#v-bind-in-css)
+
+In addition, the following APIs are also supported:
+
+- `defineComponent()` with improved type inference (compared to `Vue.extend`)
+- `h()`, `useSlot()`, `useAttrs()`, `useCssModules()`
+- `set()`, `del()` and `nextTick()` are also provided as named exports in ESM builds.
+- The `emits` option is also supported, but only for type-checking purposes (does not affect runtime behavior)
+
+  2.7 also supports using ESNext syntax in template expressions. When using a build system, the compiled template render function will go through the same loaders / plugins configured for normal JavaScript. This means if you have configured Babel for `.js` files, it will also apply to the expressions in your SFC templates.
+
+### Notes on API exposure
+
+- In ESM builds, these APIs are provided as named exports (and named exports only):
+
+  ```js
+  import Vue, { ref } from 'vue'
+
+  Vue.ref // undefined, use named export instead
+  ```
+
+- In UMD and CJS builds, these APIs are exposed as properties on the global `Vue` object.
+
+- When bundling with CJS builds externalized, bundlers should be able to handle ESM interop when externalizing CJS builds.
+
+### Behavior Differences from Vue 3
+
+The Composition API is backported using Vue 2's getter/setter-based reactivity system to ensure browser compatibility. This means there are some important behavior differences from Vue 3's proxy-based system:
+
+- All [Vue 2 change detection caveats](https://v2.vuejs.org/v2/guide/reactivity.html#Change-Detection-Caveats) still apply.
+
+- `reactive()`, `ref()`, and `shallowReactive()` will directly convert original objects instead of creating proxies. This means:
+
+  ```js
+  // true in 2.7, false in 3.x
+  reactive(foo) === foo
+  ```
+
+- `readonly()` **does** create a separate object, but it won't track newly added properties and does not work on arrays.
+
+- Avoid using arrays as root values in `reactive()` because without property access the array's mutation won't be tracked (this will result in a warning).
+
+- Reactivity APIs ignore properties with symbol keys.
+
+In addition, the following features are explicitly **NOT** ported:
+
+- ❌ `createApp()` (Vue 2 doesn't have isolated app scope)
+- ❌ Top-level `await` in `<script setup>` (Vue 2 does not support async component initialization)
+- ❌ TypeScript syntax in template expressions (incompatible w/ Vue 2 parser)
+- ❌ Reactivity transform (still experimental)
+- ❌ `expose` option is not supported for options components (but `defineExpose()` is supported in `<script setup>`).
+
+## Upgrade Guide
+
+### Vue CLI / webpack
+
+1. Upgrade local `@vue/cli-xxx` dependencies the latest version in your major version range (if applicable):
+
+   - `~4.5.18` for v4
+   - `~5.0.6` for v5
+
+2. Upgrade `vue` to `^2.7.0`. You can also remove `vue-template-compiler` from the dependencies - it is no longer needed in 2.7.
+
+   Note: if you are using `@vue/test-utils`, you may need to keep it in the dependencies for now, but this requirement will also be lifted in a new release of test utils.
+
+3. Check your package manager lockfile to ensure the following dependencies meet the version requirements. They may be transitive dependencies not listed in `package.json`.
+
+   - `vue-loader`: `^15.10.0`
+   - `vue-demi`: `^0.13.1`
+
+   If not, you will need to remove `node_modules` and the lockfile and perform a fresh install to ensure they are bumped to the latest version.
+
+4. If you were previously using [`@vue/composition-api`](https://github.com/vuejs/composition-api), update imports from it to `vue` instead. Note that some APIs exported by the plugin, e.g. `createApp`, are not ported in 2.7.
+
+5. The SFC compiler for 2.7 now uses PostCSS 8 (upgraded from 7). PostCSS 8 should be backwards compatible with most plugins, but the upgrade **may** cause issues if you were previously using a custom PostCSS plugin that can only work with PostCSS 7. In such cases, you will need to upgrade the relevant plugins to their PostCSS 8 compatible versions.
 
 ### Bug Fixes
 

From 8cdd0ac07e2222f344c2f0f4d7d2885b60435f7a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 1 Jul 2022 14:31:58 +0800
Subject: [PATCH 199/317] chore: update 2.7 changelog [ci skip]

---
 CHANGELOG.md | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65065b05e3c..82b2df61d7e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,8 +2,6 @@
 
 ## Backported Features
 
-2.7 backports some of the most important features from Vue 3 so that Vue 2 users can benefit from them as well:
-
 - [Composition API](https://vuejs.org/guide/extras/composition-api-faq.html)
 - SFC [`<script setup>`](https://vuejs.org/api/sfc-script-setup.html)
 - SFC [CSS v-bind](https://vuejs.org/api/sfc-css-features.html#v-bind-in-css)
@@ -80,7 +78,32 @@ In addition, the following features are explicitly **NOT** ported:
 
 4. If you were previously using [`@vue/composition-api`](https://github.com/vuejs/composition-api), update imports from it to `vue` instead. Note that some APIs exported by the plugin, e.g. `createApp`, are not ported in 2.7.
 
-5. The SFC compiler for 2.7 now uses PostCSS 8 (upgraded from 7). PostCSS 8 should be backwards compatible with most plugins, but the upgrade **may** cause issues if you were previously using a custom PostCSS plugin that can only work with PostCSS 7. In such cases, you will need to upgrade the relevant plugins to their PostCSS 8 compatible versions.
+5. Update `eslint-plugin-vue` to latest version (9+) if you run into unused variable lint errors when using `<script setup>`.
+
+6. The SFC compiler for 2.7 now uses PostCSS 8 (upgraded from 7). PostCSS 8 should be backwards compatible with most plugins, but the upgrade **may** cause issues if you were previously using a custom PostCSS plugin that can only work with PostCSS 7. In such cases, you will need to upgrade the relevant plugins to their PostCSS 8 compatible versions.
+
+### Vite
+
+2.7 support for Vite is provided via a new plugin: [@vitejs/plugin-vue2](https://github.com/vitejs/vite-plugin-vue2). This new plugin requires Vue 2.7 or above and supersedes the existing [vite-plugin-vue2](https://github.com/underfin/vite-plugin-vue2).
+
+Note that the new plugin does not handle Vue-specific JSX / TSX transform, which is intentional. Vue 2 JSX / TSX transform should be handled in a separate, dedicated plugin, which will be provided soon.
+
+### Volar Compatibility
+
+2.7 ships improved type definitions so it is no longer necessary to install `@vue/runtime-dom` just for Volar template type inference support. All you need now is the following config in `tsconfig.json`:
+
+```json
+{
+  // ...
+  "vueCompilerOptions": {
+    "target": 2.7
+  }
+}
+```
+
+### Devtools Support
+
+Vue Devtools 6.2.0 has added support for inspecting 2.7 Composition API state, but the extensions may still need a few days to go through review on respective publishing platforms.
 
 ### Bug Fixes
 

From 15b9b9b19dd3ae7cce5dcd89739e5cf719523fc5 Mon Sep 17 00:00:00 2001
From: Deft <62738469+deftliang@users.noreply.github.com>
Date: Mon, 4 Jul 2022 10:33:44 +0800
Subject: [PATCH 200/317] fix(reactivity):  shallowReactive should not unwrap
 refs (#12605)

fix #12597
---
 src/core/observer/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index ac1f2254f59..6180b8e904f 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -181,7 +181,7 @@ export function defineReactive(
           }
         }
       }
-      return isRef(value) ? value.value : value
+      return isRef(value) && !shallow ? value.value : value
     },
     set: function reactiveSetter(newVal) {
       const value = getter ? getter.call(obj) : val

From ff5acb12cfa64f975f216a55aafa976b07052665 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 4 Jul 2022 10:37:05 +0800
Subject: [PATCH 201/317] fix: fix NaN comparison on state change

fix #12595
---
 src/shared/util.ts                            |  2 +-
 .../features/v3/reactivity/reactive.spec.ts   | 25 +++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/shared/util.ts b/src/shared/util.ts
index a171a743c14..0b9cf7f06ec 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -361,6 +361,6 @@ export function hasChanged(x: unknown, y: unknown): boolean {
   if (x === y) {
     return x === 0 && 1 / x !== 1 / (y as number)
   } else {
-    return x === x && y === y
+    return x === x || y === y
   }
 }
diff --git a/test/unit/features/v3/reactivity/reactive.spec.ts b/test/unit/features/v3/reactivity/reactive.spec.ts
index e5e381d71df..f636d44d4a1 100644
--- a/test/unit/features/v3/reactivity/reactive.spec.ts
+++ b/test/unit/features/v3/reactivity/reactive.spec.ts
@@ -278,4 +278,29 @@ describe('reactivity/reactive', () => {
     const observed = reactive(original)
     expect(isReactive(observed)).toBe(false)
   })
+
+  // #12595
+  test(`should not trigger if value didn't change`, () => {
+    const state = reactive({
+      foo: 1
+    })
+    const spy = vi.fn()
+    effect(() => {
+      state.foo
+      spy()
+    })
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    state.foo = 1
+    expect(spy).toHaveBeenCalledTimes(1)
+
+    state.foo = NaN
+    expect(spy).toHaveBeenCalledTimes(2)
+
+    state.foo = NaN
+    expect(spy).toHaveBeenCalledTimes(2)
+
+    state.foo = 2
+    expect(spy).toHaveBeenCalledTimes(3)
+  })
 })

From bcb62d1a001125bfac91c1dd4f8bd51ac42b5a0f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 4 Jul 2022 10:39:36 +0800
Subject: [PATCH 202/317] test: test case for #12597

---
 .../features/v3/reactivity/shallowReactive.spec.ts    | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/unit/features/v3/reactivity/shallowReactive.spec.ts b/test/unit/features/v3/reactivity/shallowReactive.spec.ts
index 5d86bb85d82..1e2a0cbf808 100644
--- a/test/unit/features/v3/reactivity/shallowReactive.spec.ts
+++ b/test/unit/features/v3/reactivity/shallowReactive.spec.ts
@@ -1,7 +1,9 @@
 import {
   isReactive,
+  isRef,
   isShallow,
   reactive,
+  ref,
   shallowReactive,
   shallowReadonly
 } from 'v3'
@@ -34,6 +36,15 @@ describe('shallowReactive', () => {
     expect(isReactive(r.foo.bar)).toBe(false)
   })
 
+  // #12597
+  test('should not unwrap refs', () => {
+    const foo = shallowReactive({
+      bar: ref(123)
+    })
+    expect(isRef(foo.bar)).toBe(true)
+    expect(foo.bar.value).toBe(123)
+  })
+
   // @discrepancy no shallow/non-shallow versions from the same source -
   // cannot support this without real proxies
   // #2843

From e452e9d4368aaba173e8c942e5fd82f999cf65ae Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 4 Jul 2022 10:56:33 +0800
Subject: [PATCH 203/317] fix: export proxyRefs

close #12600
---
 src/v3/apiSetup.ts       | 25 ++++---------------------
 src/v3/index.ts          |  1 +
 src/v3/reactivity/ref.ts | 34 ++++++++++++++++++++++++++++++++++
 3 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index 123f921135a..e0573586413 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -12,7 +12,7 @@ import {
 } from '../shared/util'
 import { currentInstance, setCurrentInstance } from './currentInstance'
 import { shallowReactive } from './reactivity/reactive'
-import { isRef } from './reactivity/ref'
+import { proxyWithRefUnwrap } from './reactivity/ref'
 
 /**
  * @internal
@@ -68,7 +68,9 @@ export function initSetup(vm: Component) {
         // exposed for compiled render fn
         const proxy = (vm._setupProxy = {})
         for (const key in setupResult) {
-          proxyWithRefUnwrap(proxy, setupResult, key)
+          if (key !== '__sfc') {
+            proxyWithRefUnwrap(proxy, setupResult, key)
+          }
         }
       }
     } else if (__DEV__ && setupResult !== undefined) {
@@ -81,25 +83,6 @@ export function initSetup(vm: Component) {
   }
 }
 
-export function proxyWithRefUnwrap(
-  target: any,
-  source: Record<string, any>,
-  key: string
-) {
-  Object.defineProperty(target, key, {
-    enumerable: true,
-    configurable: true,
-    get: () => {
-      const raw = source[key]
-      return isRef(raw) ? raw.value : raw
-    },
-    set: newVal => {
-      const raw = source[key]
-      isRef(raw) ? (raw.value = newVal) : (source[key] = newVal)
-    }
-  })
-}
-
 function createSetupContext(vm: Component): SetupContext {
   let exposeCalled = false
   return {
diff --git a/src/v3/index.ts b/src/v3/index.ts
index e2bec70e8fe..75c21ad32f3 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -7,6 +7,7 @@ export {
   toRef,
   toRefs,
   unref,
+  proxyRefs,
   customRef,
   triggerRef,
   Ref,
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index c61e29b1c9b..3b8d2fc7d1e 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -93,6 +93,40 @@ export function unref<T>(ref: T | Ref<T>): T {
   return isRef(ref) ? (ref.value as any) : ref
 }
 
+export function proxyRefs<T extends object>(
+  objectWithRefs: T
+): ShallowUnwrapRef<T> {
+  if (isReactive(objectWithRefs)) {
+    return objectWithRefs as any
+  }
+  const proxy = {}
+  const keys = Object.keys(objectWithRefs)
+  for (let i = 0; i < keys.length; i++) {
+    proxyWithRefUnwrap(proxy, objectWithRefs, keys[i])
+  }
+  return proxy as any
+}
+
+export function proxyWithRefUnwrap(
+  target: any,
+  source: Record<string, any>,
+  key: string
+) {
+  Object.defineProperty(target, key, {
+    enumerable: true,
+    configurable: true,
+    get: () => unref(source[key]),
+    set: value => {
+      const oldValue = source[key]
+      if (isRef(oldValue) && !isRef(value)) {
+        oldValue.value = value
+      } else {
+        source[key] = value
+      }
+    }
+  })
+}
+
 export type CustomRefFactory<T> = (
   track: () => void,
   trigger: () => void

From 86fb6bd15174490509236eb85407125217569692 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=A0=81=E5=86=9C=E5=B0=8F=E4=BD=99?=
 <jouryjc0409@gmail.com>
Date: Mon, 4 Jul 2022 10:58:42 +0800
Subject: [PATCH 204/317] chore(benchmarks:ssr): createRenderer function path
 error (#12601)

---
 benchmarks/ssr/renderToStream.js | 2 +-
 benchmarks/ssr/renderToString.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/benchmarks/ssr/renderToStream.js b/benchmarks/ssr/renderToStream.js
index 74ca103f3f8..40dacef7811 100644
--- a/benchmarks/ssr/renderToStream.js
+++ b/benchmarks/ssr/renderToStream.js
@@ -5,7 +5,7 @@
 process.env.NODE_ENV = 'production'
 
 const Vue = require('../../dist/vue.runtime.common.js')
-const createRenderer = require('../../packages/vue-server-renderer').createRenderer
+const createRenderer = require('../../packages/server-renderer').createRenderer
 const renderToStream = createRenderer().renderToStream
 const gridComponent = require('./common.js')
 
diff --git a/benchmarks/ssr/renderToString.js b/benchmarks/ssr/renderToString.js
index a96373e0504..1988f730e73 100644
--- a/benchmarks/ssr/renderToString.js
+++ b/benchmarks/ssr/renderToString.js
@@ -3,7 +3,7 @@
 process.env.NODE_ENV = 'production'
 
 const Vue = require('../../dist/vue.runtime.common.js')
-const createRenderer = require('../../packages/vue-server-renderer').createRenderer
+const createRenderer = require('../../packages/server-renderer').createRenderer
 const renderToString = createRenderer().renderToString
 const gridComponent = require('./common.js')
 

From ff2d52f7ac45da410e0872a36bee807515e5219c Mon Sep 17 00:00:00 2001
From: webfansplz <308241863@qq.com>
Date: Mon, 4 Jul 2022 11:25:59 +0800
Subject: [PATCH 205/317] chore(types): remove unnecessary type assertion
 (#12563)

---
 src/v3/apiWatch.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 4d387dc1c1a..e1d7d018bf0 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -221,7 +221,7 @@ function doWatch(
   } else if (isFunction(source)) {
     if (cb) {
       // getter with cb
-      getter = () => call(source as Function, WATCHER_GETTER)
+      getter = () => call(source, WATCHER_GETTER)
     } else {
       // no cb -> simple effect
       getter = () => {
@@ -231,7 +231,7 @@ function doWatch(
         if (cleanup) {
           cleanup()
         }
-        return call(source as Function, WATCHER, [onCleanup])
+        return call(source, WATCHER, [onCleanup])
       }
     }
   } else {

From 6f0d2e6985a332d75ce93d29dd7031496196c1ac Mon Sep 17 00:00:00 2001
From: webfansplz <308241863@qq.com>
Date: Mon, 4 Jul 2022 11:26:18 +0800
Subject: [PATCH 206/317] chore(compiler-sfc): replace `substr` with `slice`
 (#12564)

---
 packages/compiler-sfc/src/templateCompilerModules/srcset.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/src/templateCompilerModules/srcset.ts b/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
index f0df692b828..bec3dcd7847 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/srcset.ts
@@ -38,7 +38,7 @@ function transform(
         }
 
         const imageCandidates: ImageCandidate[] = value
-          .substr(1, value.length - 2)
+          .slice(1, -1)
           .split(',')
           .map(s => {
             // The attribute value arrives here with all whitespace, except

From caceece8fa9b75c4832a91d3af0bc2958166d3f2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 4 Jul 2022 11:38:36 +0800
Subject: [PATCH 207/317] fix(compiler-sfc): fix template usage check edge case
 for v-on statements

fix #12591
---
 packages/compiler-sfc/src/compileScript.ts    | 27 +++++++++----------
 .../compiler-sfc/test/compileScript.spec.ts   | 12 +++++++++
 2 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index d4b02663d06..094120c38f7 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -39,7 +39,7 @@ import { walk } from 'estree-walker'
 import { RawSourceMap } from 'source-map'
 import { warnOnce } from './warn'
 import { isReservedTag } from 'web/util'
-import { dirRE } from 'compiler/parser'
+import { bindRE, dirRE, onRE } from 'compiler/parser'
 import { parseText } from 'compiler/parser/text-parser'
 import { DEFAULT_FILENAME } from './parseComponent'
 import {
@@ -278,8 +278,7 @@ export function compileScript(
     local: string,
     imported: string | false,
     isType: boolean,
-    isFromSetup: boolean,
-    needTemplateUsageCheck: boolean
+    isFromSetup: boolean
   ) {
     if (source === 'vue' && imported) {
       userImportAlias[imported] = local
@@ -287,14 +286,8 @@ export function compileScript(
 
     // template usage check is only needed in non-inline mode, so we can skip
     // the work if inlineTemplate is true.
-    let isUsedInTemplate = needTemplateUsageCheck
-    if (
-      needTemplateUsageCheck &&
-      isTS &&
-      sfc.template &&
-      !sfc.template.src &&
-      !sfc.template.lang
-    ) {
+    let isUsedInTemplate = true
+    if (isTS && sfc.template && !sfc.template.src && !sfc.template.lang) {
       isUsedInTemplate = isImportUsed(local, sfc)
     }
 
@@ -658,8 +651,7 @@ export function compileScript(
             node.importKind === 'type' ||
               (specifier.type === 'ImportSpecifier' &&
                 specifier.importKind === 'type'),
-            false,
-            true
+            false
           )
         }
       } else if (node.type === 'ExportDefaultDeclaration') {
@@ -872,7 +864,6 @@ export function compileScript(
             node.importKind === 'type' ||
               (specifier.type === 'ImportSpecifier' &&
                 specifier.importKind === 'type'),
-            true,
             true
           )
         }
@@ -1809,7 +1800,11 @@ function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
       for (let i = 0; i < attrs.length; i++) {
         const { name, value } = attrs[i]
         if (dirRE.test(name)) {
-          const baseName = name.replace(dirRE, '')
+          const baseName = onRE.test(name)
+            ? 'on'
+            : bindRE.test(name)
+            ? 'bind'
+            : name.replace(dirRE, '')
           if (!isBuiltInDir(baseName)) {
             code += `,v${capitalize(camelize(baseName))}`
           }
@@ -1838,6 +1833,8 @@ function processExp(exp: string, dir?: string): string {
   if (/ as\s+\w|<.*>|:/.test(exp)) {
     if (dir === 'slot') {
       exp = `(${exp})=>{}`
+    } else if (dir === 'on') {
+      exp = `()=>{${exp}}`
     } else if (dir === 'for') {
       const inMatch = exp.match(forAliasRE)
       if (inMatch) {
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index 05b7159cb2c..7924c83d4eb 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -1562,5 +1562,17 @@ describe('SFC analyze <script> bindings', () => {
       expect(content).toMatch(`name: 'Baz'`)
       assertCode(content)
     })
+
+    // #12591
+    test('should not error when performing ts expression check for v-on inline statement', () => {
+      compile(`
+      <script setup lang="ts">
+        import { foo } from './foo'
+      </script>
+      <template>
+        <div @click="$emit('update:a');"></div>
+      </tempalte>
+      `)
+    })
   })
 })

From 427028ad89a67b34006066c294ae0a3840a6403b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 4 Jul 2022 18:38:35 +0800
Subject: [PATCH 208/317] release: v2.7.1

---
 CHANGELOG.md                            | 12 ++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 82b2df61d7e..8970e47eee3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+## [2.7.1](https://github.com/vuejs/vue/compare/v2.7.0...v2.7.1) (2022-07-04)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** fix template usage check edge case for v-on statements ([caceece](https://github.com/vuejs/vue/commit/caceece8fa9b75c4832a91d3af0bc2958166d3f2)), closes [#12591](https://github.com/vuejs/vue/issues/12591)
+* export proxyRefs ([e452e9d](https://github.com/vuejs/vue/commit/e452e9d4368aaba173e8c942e5fd82f999cf65ae)), closes [#12600](https://github.com/vuejs/vue/issues/12600)
+* fix NaN comparison on state change ([ff5acb1](https://github.com/vuejs/vue/commit/ff5acb12cfa64f975f216a55aafa976b07052665)), closes [#12595](https://github.com/vuejs/vue/issues/12595)
+* **reactivity:**  shallowReactive should not unwrap refs ([#12605](https://github.com/vuejs/vue/issues/12605)) ([15b9b9b](https://github.com/vuejs/vue/commit/15b9b9b19dd3ae7cce5dcd89739e5cf719523fc5)), closes [#12597](https://github.com/vuejs/vue/issues/12597)
+
+
+
 # [2.7.0](https://github.com/vuejs/vue/compare/v2.7.0-beta.8...v2.7.0) (2022-07-01)
 
 ## Backported Features
diff --git a/package.json b/package.json
index b2e45290992..b89df04e9a7 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index da6703796e3..bce61b23e17 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 077cfd53d2f..a914acd43ab 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 4db2b577930..81aba7d0cfb 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From d45bbeac2710a5cf9185377abc2342295f0bb4e2 Mon Sep 17 00:00:00 2001
From: Kael <kaelwd@gmail.com>
Date: Mon, 4 Jul 2022 14:08:41 +1000
Subject: [PATCH 209/317] feat: allow passing directive definition directly to
 h() (#12590)

---
 src/core/vdom/modules/directives.ts | 4 ++--
 types/vnode.d.ts                    | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 7d475de1fc5..9e4a87f7f6e 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -94,7 +94,7 @@ function normalizeDirectives(
     // $flow-disable-line
     return res
   }
-  let i, dir
+  let i: number, dir: VNodeDirective
   for (i = 0; i < dirs.length; i++) {
     dir = dirs[i]
     if (!dir.modifiers) {
@@ -103,7 +103,7 @@ function normalizeDirectives(
     }
     res[getRawDirName(dir)] = dir
     if (vm._setupState && vm._setupState.__sfc) {
-      dir.def = resolveAsset(vm, '_setupState', 'v-' + dir.name)
+      dir.def = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name)
     }
     dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true)
   }
diff --git a/types/vnode.d.ts b/types/vnode.d.ts
index 59eeb032b77..fabfad44c97 100644
--- a/types/vnode.d.ts
+++ b/types/vnode.d.ts
@@ -1,4 +1,5 @@
 import { Vue } from './vue'
+import { DirectiveFunction, DirectiveOptions } from './options'
 
 export type ScopedSlot = (props: any) => ScopedSlotReturnValue
 type ScopedSlotReturnValue =
@@ -86,4 +87,5 @@ export interface VNodeDirective {
   arg?: string
   oldArg?: string
   modifiers?: { [key: string]: boolean }
+  def?: DirectiveFunction | DirectiveOptions
 }

From fb93c1be77f12ea1375c5e8b47d168e4d5ceb7be Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 5 Jul 2022 10:12:21 +0800
Subject: [PATCH 210/317] feat(types): define component improvements (#12612)

---
 src/core/util/next-tick.ts              |    3 +-
 types/common.d.ts                       |    6 +
 types/index.d.ts                        |   11 +-
 types/jsx.d.ts                          |   12 +-
 types/options.d.ts                      |    8 +-
 types/test/v3/define-component-test.tsx | 1080 +++++++++++++++++++++++
 types/v3-component-options.d.ts         |  195 +++-
 types/v3-component-props.d.ts           |   39 +-
 types/v3-component-proxy.d.ts           |  189 ----
 types/v3-component-public-instance.d.ts |  230 +++++
 types/v3-define-component.d.ts          |   82 +-
 types/v3-setup-context.d.ts             |    6 -
 types/vnode.d.ts                        |   13 +
 13 files changed, 1606 insertions(+), 268 deletions(-)
 create mode 100644 types/test/v3/define-component-test.tsx
 delete mode 100644 types/v3-component-proxy.d.ts
 create mode 100644 types/v3-component-public-instance.d.ts

diff --git a/src/core/util/next-tick.ts b/src/core/util/next-tick.ts
index e7a5b006408..5e67bd7d2e7 100644
--- a/src/core/util/next-tick.ts
+++ b/src/core/util/next-tick.ts
@@ -86,7 +86,8 @@ if (typeof Promise !== 'undefined' && isNative(Promise)) {
 }
 
 export function nextTick(): Promise<void>
-export function nextTick(cb: (...args: any[]) => any, ctx?: object): void
+export function nextTick<T>(this: T, cb: (this: T, ...args: any[]) => any): void
+export function nextTick<T>(cb: (this: T, ...args: any[]) => any, ctx: T): void
 /**
  * @internal
  */
diff --git a/types/common.d.ts b/types/common.d.ts
index 7b69ddd6473..3165711c702 100644
--- a/types/common.d.ts
+++ b/types/common.d.ts
@@ -13,3 +13,9 @@ type Equal<Left, Right> =
   (<U>() => U extends Left ? 1 : 0) extends (<U>() => U extends Right ? 1 : 0) ? true : false;
 
 export type HasDefined<T> = Equal<T, unknown> extends true ? false : true
+
+// If the the type T accepts type "any", output type Y, otherwise output type N.
+// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
+export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N
+
+export type LooseRequired<T> = { [P in string & keyof T]: T[P] }
diff --git a/types/index.d.ts b/types/index.d.ts
index dd5aab503d0..91807ae691c 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -30,7 +30,8 @@ export {
   VNode,
   VNodeComponentOptions,
   VNodeData,
-  VNodeDirective
+  VNodeDirective,
+  ComponentCustomProps
 } from './vnode'
 
 export * from './v3-manual-apis'
@@ -47,13 +48,15 @@ export {
   // v2 already has option with same name and it's for a single computed
   ComputedOptions as ComponentComputedOptions,
   MethodOptions as ComponentMethodOptions,
-  ComponentPropsOptions
+  ComponentPropsOptions,
+  ComponentCustomOptions
 } from './v3-component-options'
 export {
   ComponentInstance,
   ComponentPublicInstance,
-  ComponentRenderProxy
-} from './v3-component-proxy'
+  CreateComponentPublicInstance,
+  ComponentCustomProperties
+} from './v3-component-public-instance'
 export {
   // PropType,
   // PropOptions,
diff --git a/types/jsx.d.ts b/types/jsx.d.ts
index c79501ac40c..151a660be9f 100644
--- a/types/jsx.d.ts
+++ b/types/jsx.d.ts
@@ -1313,7 +1313,12 @@ type NativeElements = {
   >
 }
 
-import { VNode, VNodeData } from './vnode'
+import {
+  VNode,
+  VNodeData,
+  ComponentCustomProps,
+  AllowedComponentProps
+} from './vnode'
 
 declare global {
   namespace JSX {
@@ -1329,7 +1334,10 @@ declare global {
       // @ts-ignore suppress ts:2374 = Duplicate string index signature.
       [name: string]: any
     }
-    interface IntrinsicAttributes extends ReservedProps {}
+    interface IntrinsicAttributes
+      extends ReservedProps,
+        AllowedComponentProps,
+        ComponentCustomProps {}
   }
 }
 
diff --git a/types/options.d.ts b/types/options.d.ts
index 80ab87ad0fa..f1db523a04a 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -2,6 +2,7 @@ import { Vue, CreateElement, CombinedVueInstance } from './vue'
 import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from './vnode'
 import { SetupContext } from './v3-setup-context'
 import { DebuggerEvent } from './v3-generated'
+import { DefineComponent } from './v3-define-component'
 
 type Constructor = {
   new (...args: any[]): any
@@ -19,6 +20,7 @@ export type Component<
   | typeof Vue
   | FunctionalComponentOptions<Props>
   | ComponentOptions<never, Data, Methods, Computed, Props, SetupBindings>
+  | DefineComponent<any, any, any, any, any>
 
 type EsModule<T> = T | { default: T }
 
@@ -174,7 +176,10 @@ export interface ComponentOptions<
   el?: Element | string
   template?: string
   // hack is for functional component type inference, should not be used in user code
-  render?(createElement: CreateElement, hack: RenderContext<Props>): VNode
+  render?(
+    createElement: CreateElement,
+    hack: RenderContext<Props>
+  ): VNode | null | void
   renderError?(createElement: CreateElement, err: Error): VNode
   staticRenderFns?: ((createElement: CreateElement) => VNode)[]
 
@@ -198,6 +203,7 @@ export interface ComponentOptions<
     [key: string]:
       | Component<any, any, any, any>
       | AsyncComponent<any, any, any, any>
+      | DefineComponent<any, any, any, any, any, any, any, any, any, any>
   }
   transitions?: { [key: string]: object }
   filters?: { [key: string]: Function }
diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
new file mode 100644
index 00000000000..7bdbdb82444
--- /dev/null
+++ b/types/test/v3/define-component-test.tsx
@@ -0,0 +1,1080 @@
+import {
+  Component,
+  defineComponent,
+  PropType,
+  ref,
+  reactive,
+  ComponentPublicInstance
+} from '../../index'
+import { describe, test, expectType, expectError, IsUnion } from '../utils'
+
+defineComponent({
+  props: {
+    foo: Number
+  },
+  render() {
+    this.foo
+  }
+})
+
+describe('with object props', () => {
+  interface ExpectedProps {
+    a?: number | undefined
+    b: string
+    e?: Function
+    h: boolean
+    j: undefined | (() => string | undefined)
+    bb: string
+    bbb: string
+    bbbb: string | undefined
+    bbbbb: string | undefined
+    cc?: string[] | undefined
+    dd: { n: 1 }
+    ee?: () => string
+    ff?: (a: number, b: string) => { a: boolean }
+    ccc?: string[] | undefined
+    ddd: string[]
+    eee: () => { a: string }
+    fff: (a: number, b: string) => { a: boolean }
+    hhh: boolean
+    ggg: 'foo' | 'bar'
+    ffff: (a: number, b: string) => { a: boolean }
+    iii?: (() => string) | (() => number)
+    jjj: ((arg1: string) => string) | ((arg1: string, arg2: string) => string)
+    kkk?: any
+    validated?: string
+    date?: Date
+    l?: Date
+    ll?: Date | number
+    lll?: string | number
+  }
+
+  type GT = string & { __brand: unknown }
+
+  const props = {
+    a: Number,
+    // required should make property non-void
+    b: {
+      type: String,
+      required: true as true
+    },
+    e: Function,
+    h: Boolean,
+    j: Function as PropType<undefined | (() => string | undefined)>,
+    // default value should infer type and make it non-void
+    bb: {
+      default: 'hello'
+    },
+    bbb: {
+      // Note: default function value requires arrow syntax + explicit
+      // annotation
+      default: (props: any) => (props.bb as string) || 'foo'
+    },
+    bbbb: {
+      type: String,
+      default: undefined
+    },
+    bbbbb: {
+      type: String,
+      default: () => undefined
+    },
+    // explicit type casting
+    cc: Array as PropType<string[]>,
+    // required + type casting
+    dd: {
+      type: Object as PropType<{ n: 1 }>,
+      required: true as true
+    },
+    // return type
+    ee: Function as PropType<() => string>,
+    // arguments + object return
+    ff: Function as PropType<(a: number, b: string) => { a: boolean }>,
+    // explicit type casting with constructor
+    ccc: Array as () => string[],
+    // required + constructor type casting
+    ddd: {
+      type: Array as () => string[],
+      required: true as true
+    },
+    // required + object return
+    eee: {
+      type: Function as PropType<() => { a: string }>,
+      required: true as true
+    },
+    // required + arguments + object return
+    fff: {
+      type: Function as PropType<(a: number, b: string) => { a: boolean }>,
+      required: true as true
+    },
+    hhh: {
+      type: Boolean,
+      required: true as true
+    },
+    // default + type casting
+    ggg: {
+      type: String as PropType<'foo' | 'bar'>,
+      default: 'foo'
+    },
+    // default + function
+    ffff: {
+      type: Function as PropType<(a: number, b: string) => { a: boolean }>,
+      default: (a: number, b: string) => ({ a: a > +b })
+    },
+    // union + function with different return types
+    iii: Function as PropType<(() => string) | (() => number)>,
+    // union + function with different args & same return type
+    jjj: {
+      type: Function as PropType<
+        ((arg1: string) => string) | ((arg1: string, arg2: string) => string)
+      >,
+      required: true as true
+    },
+    kkk: null,
+    validated: {
+      type: String,
+      // validator requires explicit annotation
+      validator: (val: unknown) => val !== ''
+    },
+    date: Date,
+    l: [Date],
+    ll: [Date, Number],
+    lll: [String, Number]
+  }
+
+  const MyComponent = defineComponent({
+    props,
+    setup(props) {
+      // type assertion. See https://github.com/SamVerschueren/tsd
+      expectType<ExpectedProps['a']>(props.a)
+      expectType<ExpectedProps['b']>(props.b)
+      expectType<ExpectedProps['e']>(props.e)
+      expectType<ExpectedProps['h']>(props.h)
+      expectType<ExpectedProps['j']>(props.j)
+      expectType<ExpectedProps['bb']>(props.bb)
+      expectType<ExpectedProps['bbb']>(props.bbb)
+      expectType<ExpectedProps['bbbb']>(props.bbbb)
+      expectType<ExpectedProps['bbbbb']>(props.bbbbb)
+      expectType<ExpectedProps['cc']>(props.cc)
+      expectType<ExpectedProps['dd']>(props.dd)
+      expectType<ExpectedProps['ee']>(props.ee)
+      expectType<ExpectedProps['ff']>(props.ff)
+      expectType<ExpectedProps['ccc']>(props.ccc)
+      expectType<ExpectedProps['ddd']>(props.ddd)
+      expectType<ExpectedProps['eee']>(props.eee)
+      expectType<ExpectedProps['fff']>(props.fff)
+      expectType<ExpectedProps['hhh']>(props.hhh)
+      expectType<ExpectedProps['ggg']>(props.ggg)
+      expectType<ExpectedProps['ffff']>(props.ffff)
+      if (typeof props.iii !== 'function') {
+        expectType<undefined>(props.iii)
+      }
+      expectType<ExpectedProps['iii']>(props.iii)
+      expectType<IsUnion<typeof props.jjj>>(true)
+      expectType<ExpectedProps['jjj']>(props.jjj)
+      expectType<ExpectedProps['kkk']>(props.kkk)
+      expectType<ExpectedProps['validated']>(props.validated)
+      expectType<ExpectedProps['date']>(props.date)
+      expectType<ExpectedProps['l']>(props.l)
+      expectType<ExpectedProps['ll']>(props.ll)
+      expectType<ExpectedProps['lll']>(props.lll)
+
+      // @ts-expect-error props should be readonly
+      expectError((props.a = 1))
+
+      // setup context
+      return {
+        c: ref(1),
+        d: {
+          e: ref('hi')
+        },
+        f: reactive({
+          g: ref('hello' as GT)
+        })
+      }
+    },
+    provide() {
+      return {}
+    },
+    render() {
+      const props = this.$props
+      expectType<ExpectedProps['a']>(props.a)
+      expectType<ExpectedProps['b']>(props.b)
+      expectType<ExpectedProps['e']>(props.e)
+      expectType<ExpectedProps['h']>(props.h)
+      expectType<ExpectedProps['bb']>(props.bb)
+      expectType<ExpectedProps['cc']>(props.cc)
+      expectType<ExpectedProps['dd']>(props.dd)
+      expectType<ExpectedProps['ee']>(props.ee)
+      expectType<ExpectedProps['ff']>(props.ff)
+      expectType<ExpectedProps['ccc']>(props.ccc)
+      expectType<ExpectedProps['ddd']>(props.ddd)
+      expectType<ExpectedProps['eee']>(props.eee)
+      expectType<ExpectedProps['fff']>(props.fff)
+      expectType<ExpectedProps['hhh']>(props.hhh)
+      expectType<ExpectedProps['ggg']>(props.ggg)
+      if (typeof props.iii !== 'function') {
+        expectType<undefined>(props.iii)
+      }
+      expectType<ExpectedProps['iii']>(props.iii)
+      expectType<IsUnion<typeof props.jjj>>(true)
+      expectType<ExpectedProps['jjj']>(props.jjj)
+      expectType<ExpectedProps['kkk']>(props.kkk)
+
+      // @ts-expect-error props should be readonly
+      expectError((props.a = 1))
+
+      // should also expose declared props on `this`
+      expectType<ExpectedProps['a']>(this.a)
+      expectType<ExpectedProps['b']>(this.b)
+      expectType<ExpectedProps['e']>(this.e)
+      expectType<ExpectedProps['h']>(this.h)
+      expectType<ExpectedProps['bb']>(this.bb)
+      expectType<ExpectedProps['cc']>(this.cc)
+      expectType<ExpectedProps['dd']>(this.dd)
+      expectType<ExpectedProps['ee']>(this.ee)
+      expectType<ExpectedProps['ff']>(this.ff)
+      expectType<ExpectedProps['ccc']>(this.ccc)
+      expectType<ExpectedProps['ddd']>(this.ddd)
+      expectType<ExpectedProps['eee']>(this.eee)
+      expectType<ExpectedProps['fff']>(this.fff)
+      expectType<ExpectedProps['hhh']>(this.hhh)
+      expectType<ExpectedProps['ggg']>(this.ggg)
+      if (typeof this.iii !== 'function') {
+        expectType<undefined>(this.iii)
+      }
+      expectType<ExpectedProps['iii']>(this.iii)
+      const { jjj } = this
+      expectType<IsUnion<typeof jjj>>(true)
+      expectType<ExpectedProps['jjj']>(this.jjj)
+      expectType<ExpectedProps['kkk']>(this.kkk)
+
+      // @ts-expect-error props on `this` should be readonly
+      expectError((this.a = 1))
+
+      // assert setup context unwrapping
+      expectType<number>(this.c)
+      expectType<string>(this.d.e.value)
+      expectType<GT>(this.f.g)
+
+      // setup context properties should be mutable
+      this.c = 2
+
+      return null
+    }
+  })
+
+  expectType<Component>(MyComponent)
+
+  // Test TSX
+  expectType<JSX.Element>(
+    <MyComponent
+      a={1}
+      b="b"
+      bb="bb"
+      e={() => {}}
+      cc={['cc']}
+      dd={{ n: 1 }}
+      ee={() => 'ee'}
+      ccc={['ccc']}
+      ddd={['ddd']}
+      eee={() => ({ a: 'eee' })}
+      fff={(a, b) => ({ a: a > +b })}
+      hhh={false}
+      ggg="foo"
+      jjj={() => ''}
+      // should allow class/style as attrs
+      class="bar"
+      style={{ color: 'red' }}
+      // // should allow key
+      key={'foo'}
+      // // should allow ref
+      ref={'foo'}
+    />
+  )
+
+  // @ts-expect-error missing required props
+  expectError(<MyComponent />)
+  expectError(
+    // @ts-expect-error wrong prop types
+    <MyComponent a={'wrong type'} b="foo" dd={{ n: 1 }} ddd={['foo']} />
+  )
+  // @ts-expect-error wrong prop types
+  expectError(<MyComponent ggg="baz" />)
+  // @ts-expect-error
+  expectError(<MyComponent b="foo" dd={{ n: 'string' }} ddd={['foo']} />)
+})
+
+// describe('type inference w/ optional props declaration', () => {
+//   const MyComponent = defineComponent<{ a: string[]; msg: string }>({
+//     setup(props) {
+//       expectType<string>(props.msg)
+//       expectType<string[]>(props.a)
+//       return {
+//         b: 1
+//       }
+//     }
+//   })
+
+//   expectType<JSX.Element>(<MyComponent msg="1" a={['1']} />)
+//   // @ts-expect-error
+//   expectError(<MyComponent />)
+//   // @ts-expect-error
+//   expectError(<MyComponent msg="1" />)
+// })
+
+// describe('type inference w/ direct setup function', () => {
+//   const MyComponent = defineComponent((_props: { msg: string }) => {})
+//   expectType<JSX.Element>(<MyComponent msg="foo" />)
+//   // @ts-expect-error
+//   expectError(<MyComponent />)
+//   expectError(<MyComponent msg="1" />)
+// })
+
+describe('type inference w/ array props declaration', () => {
+  const MyComponent = defineComponent({
+    props: ['a', 'b'],
+    setup(props) {
+      // @ts-expect-error props should be readonly
+      expectError((props.a = 1))
+      expectType<any>(props.a)
+      expectType<any>(props.b)
+      return {
+        c: 1
+      }
+    },
+    render() {
+      expectType<any>(this.$props.a)
+      expectType<any>(this.$props.b)
+      // @ts-expect-error
+      expectError((this.$props.a = 1))
+      expectType<any>(this.a)
+      expectType<any>(this.b)
+      expectType<number>(this.c)
+    }
+  })
+  expectType<JSX.Element>(<MyComponent a={[1, 2]} b="b" />)
+  // @ts-expect-error
+  expectError(<MyComponent other="other" />)
+})
+
+describe('type inference w/ options API', () => {
+  defineComponent({
+    props: { a: Number },
+    setup() {
+      return {
+        b: 123
+      }
+    },
+    data() {
+      // Limitation: we cannot expose the return result of setup() on `this`
+      // here in data() - somehow that would mess up the inference
+      expectType<number | undefined>(this.a)
+      return {
+        c: this.a || 123,
+        someRef: ref(0)
+      }
+    },
+    computed: {
+      d() {
+        expectType<number>(this.b)
+        return this.b + 1
+      },
+      e: {
+        get() {
+          expectType<number>(this.b)
+          expectType<number>(this.d)
+
+          return this.b + this.d
+        },
+        set(v: number) {
+          expectType<number>(this.b)
+          expectType<number>(this.d)
+          expectType<number>(v)
+        }
+      }
+    },
+    watch: {
+      a() {
+        expectType<number>(this.b)
+        this.b + 1
+      }
+    },
+    created() {
+      // props
+      expectType<number | undefined>(this.a)
+      // returned from setup()
+      expectType<number>(this.b)
+      // returned from data()
+      expectType<number>(this.c)
+      // computed
+      expectType<number>(this.d)
+      // computed get/set
+      expectType<number>(this.e)
+      // expectType<number>(this.someRef)
+    },
+    methods: {
+      doSomething() {
+        // props
+        expectType<number | undefined>(this.a)
+        // returned from setup()
+        expectType<number>(this.b)
+        // returned from data()
+        expectType<number>(this.c)
+        // computed
+        expectType<number>(this.d)
+        // computed get/set
+        expectType<number>(this.e)
+      },
+      returnSomething() {
+        return this.a
+      }
+    },
+    render() {
+      // props
+      expectType<number | undefined>(this.a)
+      // returned from setup()
+      expectType<number>(this.b)
+      // returned from data()
+      expectType<number>(this.c)
+      // computed
+      expectType<number>(this.d)
+      // computed get/set
+      expectType<number>(this.e)
+      // method
+      expectType<() => number | undefined>(this.returnSomething)
+    }
+  })
+})
+
+describe('with mixins', () => {
+  const MixinA = defineComponent({
+    emits: ['bar'],
+    props: {
+      aP1: {
+        type: String,
+        default: 'aP1'
+      },
+      aP2: Boolean
+    },
+    data() {
+      return {
+        a: 1
+      }
+    }
+  })
+  const MixinB = defineComponent({
+    props: ['bP1', 'bP2'],
+    data() {
+      return {
+        b: 2
+      }
+    }
+  })
+  const MixinC = defineComponent({
+    data() {
+      return {
+        c: 3
+      }
+    }
+  })
+  const MixinD = defineComponent({
+    mixins: [MixinA],
+    data() {
+      //@ts-expect-error computed are not available on data()
+      expectError<number>(this.dC1)
+      //@ts-expect-error computed are not available on data()
+      expectError<string>(this.dC2)
+
+      return {
+        d: 4
+      }
+    },
+    setup(props) {
+      expectType<string>(props.aP1)
+    },
+    computed: {
+      dC1() {
+        return this.d + this.a
+      },
+      dC2() {
+        return this.aP1 + 'dC2'
+      }
+    }
+  })
+  const MyComponent = defineComponent({
+    mixins: [MixinA, MixinB, MixinC, MixinD],
+    emits: ['click'],
+    props: {
+      // required should make property non-void
+      z: {
+        type: String,
+        required: true
+      }
+    },
+
+    data(vm) {
+      expectType<number>(vm.a)
+      expectType<number>(vm.b)
+      expectType<number>(vm.c)
+      expectType<number>(vm.d)
+
+      // should also expose declared props on `this`
+      expectType<number>(this.a)
+      expectType<string>(this.aP1)
+      expectType<boolean | undefined>(this.aP2)
+      expectType<number>(this.b)
+      expectType<any>(this.bP1)
+      expectType<number>(this.c)
+      expectType<number>(this.d)
+
+      return {}
+    },
+
+    setup(props) {
+      expectType<string>(props.z)
+      // props
+      // expectType<((...args: any[]) => any) | undefined>(props.onClick)
+      // from Base
+      // expectType<((...args: any[]) => any) | undefined>(props.onBar)
+      expectType<string>(props.aP1)
+      expectType<boolean | undefined>(props.aP2)
+      expectType<any>(props.bP1)
+      expectType<any>(props.bP2)
+      expectType<string>(props.z)
+    },
+    render() {
+      const props = this.$props
+      // props
+      // expectType<((...args: any[]) => any) | undefined>(props.onClick)
+      // from Base
+      // expectType<((...args: any[]) => any) | undefined>(props.onBar)
+      expectType<string>(props.aP1)
+      expectType<boolean | undefined>(props.aP2)
+      expectType<any>(props.bP1)
+      expectType<any>(props.bP2)
+      expectType<string>(props.z)
+
+      const data = this.$data
+      expectType<number>(data.a)
+      expectType<number>(data.b)
+      expectType<number>(data.c)
+      expectType<number>(data.d)
+
+      // should also expose declared props on `this`
+      expectType<number>(this.a)
+      expectType<string>(this.aP1)
+      expectType<boolean | undefined>(this.aP2)
+      expectType<number>(this.b)
+      expectType<any>(this.bP1)
+      expectType<number>(this.c)
+      expectType<number>(this.d)
+      expectType<number>(this.dC1)
+      expectType<string>(this.dC2)
+
+      // props should be readonly
+      // @ts-expect-error
+      expectError((this.aP1 = 'new'))
+      // @ts-expect-error
+      expectError((this.z = 1))
+
+      // props on `this` should be readonly
+      // @ts-expect-error
+      expectError((this.bP1 = 1))
+
+      // string value can not assigned to number type value
+      // @ts-expect-error
+      expectError((this.c = '1'))
+
+      // setup context properties should be mutable
+      this.d = 5
+
+      return null
+    }
+  })
+
+  // Test TSX
+  expectType<JSX.Element>(
+    <MyComponent aP1={'aP'} aP2 bP1={1} bP2={[1, 2]} z={'z'} />
+  )
+
+  // missing required props
+  // @ts-expect-error
+  expectError(<MyComponent />)
+
+  // wrong prop types
+  // @ts-expect-error
+  expectError(<MyComponent aP1="ap" aP2={'wrong type'} bP1="b" z={'z'} />)
+  // @ts-expect-error
+  expectError(<MyComponent aP1={1} bP2={[1]} />)
+})
+
+describe('with extends', () => {
+  const Base = defineComponent({
+    props: {
+      aP1: Boolean,
+      aP2: {
+        type: Number,
+        default: 2
+      }
+    },
+    data() {
+      return {
+        a: 1
+      }
+    },
+    computed: {
+      c(): number {
+        return this.aP2 + this.a
+      }
+    }
+  })
+  const MyComponent = defineComponent({
+    extends: Base,
+    props: {
+      // required should make property non-void
+      z: {
+        type: String,
+        required: true
+      }
+    },
+    render() {
+      const props = this.$props
+      // props
+      expectType<boolean | undefined>(props.aP1)
+      expectType<number>(props.aP2)
+      expectType<string>(props.z)
+
+      const data = this.$data
+      expectType<number>(data.a)
+
+      // should also expose declared props on `this`
+      expectType<number>(this.a)
+      expectType<boolean | undefined>(this.aP1)
+      expectType<number>(this.aP2)
+
+      // setup context properties should be mutable
+      this.a = 5
+
+      return null
+    }
+  })
+
+  // Test TSX
+  expectType<JSX.Element>(<MyComponent aP2={3} aP1 z={'z'} />)
+
+  // missing required props
+  // @ts-expect-error
+  expectError(<MyComponent />)
+
+  // wrong prop types
+  // @ts-expect-error
+  expectError(<MyComponent aP2={'wrong type'} z={'z'} />)
+  // @ts-expect-error
+  expectError(<MyComponent aP1={3} />)
+})
+
+describe('extends with mixins', () => {
+  const Mixin = defineComponent({
+    emits: ['bar'],
+    props: {
+      mP1: {
+        type: String,
+        default: 'mP1'
+      },
+      mP2: Boolean,
+      mP3: {
+        type: Boolean,
+        required: true
+      }
+    },
+    data() {
+      return {
+        a: 1
+      }
+    }
+  })
+  const Base = defineComponent({
+    emits: ['foo'],
+    props: {
+      p1: Boolean,
+      p2: {
+        type: Number,
+        default: 2
+      },
+      p3: {
+        type: Boolean,
+        required: true
+      }
+    },
+    data() {
+      return {
+        b: 2
+      }
+    },
+    computed: {
+      c(): number {
+        return this.p2 + this.b
+      }
+    }
+  })
+  const MyComponent = defineComponent({
+    extends: Base,
+    mixins: [Mixin],
+    emits: ['click'],
+    props: {
+      // required should make property non-void
+      z: {
+        type: String,
+        required: true
+      }
+    },
+    render() {
+      const props = this.$props
+      // props
+      // expectType<((...args: any[]) => any) | undefined>(props.onClick)
+      // from Mixin
+      // expectType<((...args: any[]) => any) | undefined>(props.onBar)
+      // from Base
+      // expectType<((...args: any[]) => any) | undefined>(props.onFoo)
+      expectType<boolean | undefined>(props.p1)
+      expectType<number>(props.p2)
+      expectType<string>(props.z)
+      expectType<string>(props.mP1)
+      expectType<boolean | undefined>(props.mP2)
+
+      const data = this.$data
+      expectType<number>(data.a)
+      expectType<number>(data.b)
+
+      // should also expose declared props on `this`
+      expectType<number>(this.a)
+      expectType<number>(this.b)
+      expectType<boolean | undefined>(this.p1)
+      expectType<number>(this.p2)
+      expectType<string>(this.mP1)
+      expectType<boolean | undefined>(this.mP2)
+
+      // setup context properties should be mutable
+      this.a = 5
+
+      return null
+    }
+  })
+
+  // Test TSX
+  expectType<JSX.Element>(<MyComponent mP1="p1" mP2 mP3 p1 p2={1} p3 z={'z'} />)
+
+  // mP1, mP2, p1, and p2 have default value. these are not required
+  expectType<JSX.Element>(<MyComponent mP3 p3 z={'z'} />)
+
+  // missing required props
+  // @ts-expect-error
+  expectError(<MyComponent mP3 p3 /* z='z' */ />)
+  // missing required props from mixin
+  // @ts-expect-error
+  expectError(<MyComponent /* mP3 */ p3 z="z" />)
+  // missing required props from extends
+  // @ts-expect-error
+  expectError(<MyComponent mP3 /* p3 */ z="z" />)
+
+  // wrong prop types
+  // @ts-expect-error
+  expectError(<MyComponent p2={'wrong type'} z={'z'} />)
+  // @ts-expect-error
+  expectError(<MyComponent mP1={3} />)
+
+  // #3468
+  const CompWithD = defineComponent({
+    data() {
+      return { foo: 1 }
+    }
+  })
+  const CompWithC = defineComponent({
+    computed: {
+      foo() {
+        return 1
+      }
+    }
+  })
+  const CompWithM = defineComponent({ methods: { foo() {} } })
+  const CompEmpty = defineComponent({})
+
+  defineComponent({
+    mixins: [CompWithD, CompEmpty],
+    mounted() {
+      expectType<number>(this.foo)
+    }
+  })
+  defineComponent({
+    mixins: [CompWithC, CompEmpty],
+    mounted() {
+      expectType<number>(this.foo)
+    }
+  })
+  defineComponent({
+    mixins: [CompWithM, CompEmpty],
+    mounted() {
+      expectType<() => void>(this.foo)
+    }
+  })
+})
+
+describe('defineComponent', () => {
+  test('should accept components defined with defineComponent', () => {
+    const comp = defineComponent({})
+    defineComponent({
+      components: { comp }
+    })
+  })
+})
+
+describe('emits', () => {
+  // Note: for TSX inference, ideally we want to map emits to onXXX props,
+  // but that requires type-level string constant concatenation as suggested in
+  // https://github.com/Microsoft/TypeScript/issues/12754
+
+  // The workaround for TSX users is instead of using emits, declare onXXX props
+  // and call them instead. Since `v-on:click` compiles to an `onClick` prop,
+  // this would also support other users consuming the component in templates
+  // with `v-on` listeners.
+
+  // with object emits
+  defineComponent({
+    emits: {
+      click: (n: number) => typeof n === 'number',
+      input: (b: string) => b.length > 1
+    },
+    setup(props, { emit }) {
+      // expectType<((n: number) => boolean) | undefined>(props.onClick)
+      // expectType<((b: string) => boolean) | undefined>(props.onInput)
+      emit('click', 1)
+      emit('input', 'foo')
+      //  @ts-expect-error
+      expectError(emit('nope'))
+      //  @ts-expect-error
+      expectError(emit('click'))
+      //  @ts-expect-error
+      expectError(emit('click', 'foo'))
+      //  @ts-expect-error
+      expectError(emit('input'))
+      //  @ts-expect-error
+      expectError(emit('input', 1))
+    },
+    created() {
+      this.$emit('click', 1)
+      this.$emit('input', 'foo')
+      //  @ts-expect-error
+      expectError(this.$emit('nope'))
+      //  @ts-expect-error
+      expectError(this.$emit('click'))
+      //  @ts-expect-error
+      expectError(this.$emit('click', 'foo'))
+      //  @ts-expect-error
+      expectError(this.$emit('input'))
+      //  @ts-expect-error
+      expectError(this.$emit('input', 1))
+    },
+    mounted() {
+      // #3599
+      this.$nextTick(function () {
+        // this should be bound to this instance
+        this.$emit('click', 1)
+        this.$emit('input', 'foo')
+        //  @ts-expect-error
+        expectError(this.$emit('nope'))
+        //  @ts-expect-error
+        expectError(this.$emit('click'))
+        //  @ts-expect-error
+        expectError(this.$emit('click', 'foo'))
+        //  @ts-expect-error
+        expectError(this.$emit('input'))
+        //  @ts-expect-error
+        expectError(this.$emit('input', 1))
+      })
+    }
+  })
+
+  // with array emits
+  defineComponent({
+    emits: ['foo', 'bar'],
+    setup(props, { emit }) {
+      // expectType<((...args: any[]) => any) | undefined>(props.onFoo)
+      // expectType<((...args: any[]) => any) | undefined>(props.onBar)
+      emit('foo')
+      emit('foo', 123)
+      emit('bar')
+      //  @ts-expect-error
+      expectError(emit('nope'))
+    },
+    created() {
+      this.$emit('foo')
+      this.$emit('foo', 123)
+      this.$emit('bar')
+      //  @ts-expect-error
+      expectError(this.$emit('nope'))
+    }
+  })
+
+  // with tsx
+  const Component = defineComponent({
+    emits: {
+      click: (n: number) => typeof n === 'number'
+    },
+    setup(props, { emit }) {
+      // expectType<((n: number) => any) | undefined>(props.onClick)
+      emit('click', 1)
+      //  @ts-expect-error
+      expectError(emit('click'))
+      //  @ts-expect-error
+      expectError(emit('click', 'foo'))
+    }
+  })
+
+  // defineComponent({
+  //   render() {
+  //     return (
+  //       <Component
+  //         onClick={(n: number) => {
+  //           return n + 1
+  //         }}
+  //       />
+  //     )
+  //   }
+  // })
+
+  // without emits
+  defineComponent({
+    setup(props, { emit }) {
+      emit('test', 1)
+      emit('test')
+    }
+  })
+
+  // emit should be valid when ComponentPublicInstance is used.
+  const instance = {} as ComponentPublicInstance
+  instance.$emit('test', 1)
+  instance.$emit('test')
+
+  // `this` should be void inside of emits validators
+  defineComponent({
+    props: ['bar'],
+    emits: {
+      foo(): boolean {
+        // @ts-expect-error
+        return this.bar === 3
+      }
+    }
+  })
+})
+
+// describe('componentOptions setup should be `SetupContext`', () => {
+//   expectType<ComponentOptions['setup']>(
+//     {} as (props: Record<string, any>, ctx: SetupContext) => any
+//   )
+// })
+
+describe('extract instance type', () => {
+  const Base = defineComponent({
+    props: {
+      baseA: {
+        type: Number,
+        default: 1
+      }
+    }
+  })
+  const MixinA = defineComponent({
+    props: {
+      mA: {
+        type: String,
+        default: ''
+      }
+    }
+  })
+  const CompA = defineComponent({
+    extends: Base,
+    mixins: [MixinA],
+    props: {
+      a: {
+        type: Boolean,
+        default: false
+      },
+      b: {
+        type: String,
+        required: true
+      },
+      c: Number
+    }
+  })
+
+  const compA = {} as InstanceType<typeof CompA>
+
+  expectType<boolean>(compA.a)
+  expectType<string>(compA.b)
+  expectType<number | undefined>(compA.c)
+  // mixins
+  expectType<string>(compA.mA)
+  // extends
+  expectType<number>(compA.baseA)
+
+  //  @ts-expect-error
+  expectError((compA.a = true))
+  //  @ts-expect-error
+  expectError((compA.b = 'foo'))
+  //  @ts-expect-error
+  expectError((compA.c = 1))
+  //  @ts-expect-error
+  expectError((compA.mA = 'foo'))
+  //  @ts-expect-error
+  expectError((compA.baseA = 1))
+})
+
+// #5948
+describe('DefineComponent should infer correct types when assigning to Component', () => {
+  let component: Component
+  component = defineComponent({
+    setup(_, { attrs, slots }) {
+      // @ts-expect-error should not be any
+      expectType<[]>(attrs)
+      // @ts-expect-error should not be any
+      expectType<[]>(slots)
+    }
+  })
+  expectType<Component>(component)
+})
+
+// #5969
+describe('should allow to assign props', () => {
+  const Child = defineComponent({
+    props: {
+      bar: String
+    }
+  })
+
+  const Parent = defineComponent({
+    props: {
+      ...Child.props,
+      foo: String
+    }
+  })
+
+  const child = new Child()
+  expectType<JSX.Element>(<Parent {...child.$props} />)
+})
+
+// check if defineComponent can be exported
+export default {
+  // no props
+  b: defineComponent({
+    data() {
+      return {}
+    }
+  }),
+  c: defineComponent({
+    props: ['a']
+  }),
+  d: defineComponent({
+    props: {
+      a: Number
+    }
+  })
+}
diff --git a/types/v3-component-options.d.ts b/types/v3-component-options.d.ts
index d6e63ed87a0..d8c64ab13ab 100644
--- a/types/v3-component-options.d.ts
+++ b/types/v3-component-options.d.ts
@@ -2,11 +2,33 @@ import { Vue } from './vue'
 import { VNode } from './vnode'
 import { ComponentOptions as Vue2ComponentOptions } from './options'
 import { EmitsOptions, SetupContext } from './v3-setup-context'
-import { Data } from './common'
-import { ComponentPropsOptions, ExtractPropTypes } from './v3-component-props'
-import { ComponentRenderProxy } from './v3-component-proxy'
+import { Data, LooseRequired, UnionToIntersection } from './common'
+import {
+  ComponentPropsOptions,
+  ExtractDefaultPropTypes,
+  ExtractPropTypes
+} from './v3-component-props'
+import { CreateComponentPublicInstance } from './v3-component-public-instance'
 export { ComponentPropsOptions } from './v3-component-props'
 
+/**
+ * Interface for declaring custom options.
+ *
+ * @example
+ * ```ts
+ * declare module 'vue' {
+ *   interface ComponentCustomOptions {
+ *     beforeRouteUpdate?(
+ *       to: Route,
+ *       from: Route,
+ *       next: () => void
+ *     ): void
+ *   }
+ * }
+ * ```
+ */
+export interface ComponentCustomOptions {}
+
 export type ComputedGetter<T> = (ctx?: any) => T
 export type ComputedSetter<T> = (v: T) => void
 
@@ -34,24 +56,76 @@ export type SetupFunction<
   ctx: SetupContext<Emits>
 ) => RawBindings | (() => VNode | null) | void
 
-interface ComponentOptionsBase<
+type ExtractOptionProp<T> = T extends ComponentOptionsBase<
+  infer P, // Props
+  any, // RawBindings
+  any, // D
+  any, // C
+  any, // M
+  any, // Mixin
+  any, // Extends
+  any, // EmitsOptions
+  any // Defaults
+>
+  ? unknown extends P
+    ? {}
+    : P
+  : {}
+
+export interface ComponentOptionsBase<
   Props,
-  D = Data,
-  C extends ComputedOptions = {},
-  M extends MethodOptions = {}
+  RawBindings,
+  D,
+  C extends ComputedOptions,
+  M extends MethodOptions,
+  Mixin extends ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin,
+  Emits extends EmitsOptions,
+  EmitNames extends string = string,
+  Defaults = {}
 > extends Omit<
-    Vue2ComponentOptions<Vue, D, M, C, Props>,
-    'data' | 'computed' | 'method' | 'setup' | 'props'
-  > {
-  // allow any custom options
-  [key: string]: any
-
+      Vue2ComponentOptions<Vue, D, M, C, Props>,
+      'data' | 'computed' | 'methods' | 'setup' | 'props' | 'mixins' | 'extends'
+    >,
+    ComponentCustomOptions {
   // rewrite options api types
-  data?: (this: Props & Vue, vm: Props) => D
+  data?: (
+    this: CreateComponentPublicInstance<Props, {}, {}, {}, M, Mixin, Extends>,
+    vm: CreateComponentPublicInstance<Props, {}, {}, {}, M, Mixin, Extends>
+  ) => D
   computed?: C
   methods?: M
+  mixins?: Mixin[]
+  extends?: Extends
+  emits?: (Emits | EmitNames[]) & ThisType<void>
+  setup?: SetupFunction<
+    Readonly<
+      LooseRequired<
+        Props &
+          UnionToIntersection<ExtractOptionProp<Mixin>> &
+          UnionToIntersection<ExtractOptionProp<Extends>>
+      >
+    >,
+    RawBindings,
+    Emits
+  >
+
+  __defaults?: Defaults
 }
 
+export type ComponentOptionsMixin = ComponentOptionsBase<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>
+
 export type ExtractComputedReturns<T extends any> = {
   [key in keyof T]: T[key] extends { get: (...args: any[]) => infer TReturn }
     ? TReturn
@@ -66,17 +140,36 @@ export type ComponentOptionsWithProps<
   D = Data,
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string,
-  Props = ExtractPropTypes<PropsOptions>
-> = ComponentOptionsBase<Props, D, C, M> & {
+  Props = ExtractPropTypes<PropsOptions>,
+  Defaults = ExtractDefaultPropTypes<PropsOptions>
+> = ComponentOptionsBase<
+  Props,
+  RawBindings,
+  D,
+  C,
+  M,
+  Mixin,
+  Extends,
+  Emits,
+  EmitsNames,
+  Defaults
+> & {
   props?: PropsOptions
-  emits?: (Emits | EmitsNames[]) & ThisType<void>
-  setup?: SetupFunction<Props, RawBindings, Emits>
 } & ThisType<
-    ComponentRenderProxy<Props, RawBindings, D, C, M, Mixin, Extends, Emits>
+    CreateComponentPublicInstance<
+      Props,
+      RawBindings,
+      D,
+      C,
+      M,
+      Mixin,
+      Extends,
+      Emits
+    >
   >
 
 export type ComponentOptionsWithArrayProps<
@@ -85,17 +178,35 @@ export type ComponentOptionsWithArrayProps<
   D = Data,
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string,
   Props = Readonly<{ [key in PropNames]?: any }>
-> = ComponentOptionsBase<Props, D, C, M> & {
+> = ComponentOptionsBase<
+  Props,
+  RawBindings,
+  D,
+  C,
+  M,
+  Mixin,
+  Extends,
+  Emits,
+  EmitsNames,
+  {}
+> & {
   props?: PropNames[]
-  emits?: (Emits | EmitsNames[]) & ThisType<void>
-  setup?: SetupFunction<Props, RawBindings, Emits>
 } & ThisType<
-    ComponentRenderProxy<Props, RawBindings, D, C, M, Mixin, Extends, Emits>
+    CreateComponentPublicInstance<
+      Props,
+      RawBindings,
+      D,
+      C,
+      M,
+      Mixin,
+      Extends,
+      Emits
+    >
   >
 
 export type ComponentOptionsWithoutProps<
@@ -104,16 +215,34 @@ export type ComponentOptionsWithoutProps<
   D = Data,
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string
-> = ComponentOptionsBase<Props, D, C, M> & {
+> = ComponentOptionsBase<
+  Props,
+  RawBindings,
+  D,
+  C,
+  M,
+  Mixin,
+  Extends,
+  Emits,
+  EmitsNames,
+  {}
+> & {
   props?: undefined
-  emits?: (Emits | EmitsNames[]) & ThisType<void>
-  setup?: SetupFunction<Props, RawBindings, Emits>
 } & ThisType<
-    ComponentRenderProxy<Props, RawBindings, D, C, M, Mixin, Extends, Emits>
+    CreateComponentPublicInstance<
+      Props,
+      RawBindings,
+      D,
+      C,
+      M,
+      Mixin,
+      Extends,
+      Emits
+    >
   >
 
 export type WithLegacyAPI<T, D, C, M, Props> = T &
diff --git a/types/v3-component-props.d.ts b/types/v3-component-props.d.ts
index f4d0a787023..f0b2b706082 100644
--- a/types/v3-component-props.d.ts
+++ b/types/v3-component-props.d.ts
@@ -1,4 +1,4 @@
-import { Data } from './common'
+import { Data, IfAny } from './common'
 
 export type ComponentPropsOptions<P = Data> =
   | ComponentObjectPropsOptions<P>
@@ -48,26 +48,25 @@ type ExtractCorrectPropType<T> = T extends Function
   ? ExtractFunctionPropType<T>
   : Exclude<T, Function>
 
-// prettier-ignore
-type InferPropType<T> = T extends null
+type InferPropType<T> = [T] extends [null]
   ? any // null & true would fail to infer
-  : T extends { type: null | true }
-    ? any // As TS issue https://github.com/Microsoft/TypeScript/issues/14829 // somehow `ObjectConstructor` when inferred from { (): T } becomes `any` // `BooleanConstructor` when inferred from PropConstructor(with PropMethod) becomes `Boolean`
-    : T extends ObjectConstructor | { type: ObjectConstructor }
-      ? Record<string, any>
-      : T extends BooleanConstructor | { type: BooleanConstructor }
-        ? boolean
-          : T extends DateConstructor | { type: DateConstructor}
-            ? Date
-              : T extends FunctionConstructor
-                ? Function
-                : T extends Prop<infer V, infer D>
-                  ? unknown extends V
-                    ? D extends null | undefined
-                      ? V
-                      : D
-                    : ExtractCorrectPropType<V>
-                  : T
+  : [T] extends [{ type: null | true }]
+  ? any // As TS issue https://github.com/Microsoft/TypeScript/issues/14829 // somehow `ObjectConstructor` when inferred from { (): T } becomes `any` // `BooleanConstructor` when inferred from PropConstructor(with PropMethod) becomes `Boolean`
+  : [T] extends [ObjectConstructor | { type: ObjectConstructor }]
+  ? Record<string, any>
+  : [T] extends [BooleanConstructor | { type: BooleanConstructor }]
+  ? boolean
+  : [T] extends [DateConstructor | { type: DateConstructor }]
+  ? Date
+  : [T] extends [(infer U)[] | { type: (infer U)[] }]
+  ? U extends DateConstructor
+    ? Date | InferPropType<U>
+    : InferPropType<U>
+  : [T] extends [Prop<infer V, infer D>]
+  ? unknown extends V
+    ? IfAny<V, V, D>
+    : V
+  : T
 
 export type ExtractPropTypes<O> = {
   // use `keyof Pick<O, RequiredKeys<O>>` instead of `RequiredKeys<O>` to support IDE features
diff --git a/types/v3-component-proxy.d.ts b/types/v3-component-proxy.d.ts
deleted file mode 100644
index d1f73452edf..00000000000
--- a/types/v3-component-proxy.d.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-import { ExtractDefaultPropTypes, ExtractPropTypes } from './v3-component-props'
-import {
-  nextTick,
-  ShallowUnwrapRef,
-  UnwrapNestedRefs,
-  WatchOptions,
-  WatchStopHandle
-} from './v3-generated'
-import { Data } from './common'
-
-import { Vue, VueConstructor } from './vue'
-import { ComponentOptions as Vue2ComponentOptions } from './options'
-import {
-  ComputedOptions,
-  MethodOptions,
-  ExtractComputedReturns
-} from './v3-component-options'
-import {
-  ComponentRenderEmitFn,
-  EmitFn,
-  EmitsOptions,
-  ObjectEmitsOptions,
-  Slots
-} from './v3-setup-context'
-
-type EmitsToProps<T extends EmitsOptions> = T extends string[]
-  ? {
-      [K in string & `on${Capitalize<T[number]>}`]?: (...args: any[]) => any
-    }
-  : T extends ObjectEmitsOptions
-  ? {
-      [K in string &
-        `on${Capitalize<string & keyof T>}`]?: K extends `on${infer C}`
-        ? T[Uncapitalize<C>] extends null
-          ? (...args: any[]) => any
-          : (
-              ...args: T[Uncapitalize<C>] extends (...args: infer P) => any
-                ? P
-                : never
-            ) => any
-        : never
-    }
-  : {}
-
-export type ComponentInstance = InstanceType<VueConstructor>
-
-// public properties exposed on the proxy, which is used as the render context
-// in templates (as `this` in the render option)
-export type ComponentRenderProxy<
-  P = {}, // props type extracted from props option
-  B = {}, // raw bindings returned from setup()
-  D = {}, // return from data()
-  C extends ComputedOptions = {},
-  M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
-  Emits extends EmitsOptions = {},
-  PublicProps = P,
-  Defaults = {},
-  MakeDefaultsOptional extends boolean = false
-> = {
-  $data: D
-  $props: Readonly<
-    MakeDefaultsOptional extends true
-      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
-      : P & PublicProps
-  >
-  $attrs: Record<string, string>
-  $emit: ComponentRenderEmitFn<
-    Emits,
-    keyof Emits,
-    ComponentRenderProxy<
-      P,
-      B,
-      D,
-      C,
-      M,
-      Mixin,
-      Extends,
-      Emits,
-      PublicProps,
-      Defaults,
-      MakeDefaultsOptional
-    >
-  >
-} & Readonly<P> &
-  ShallowUnwrapRef<B> &
-  D &
-  M &
-  ExtractComputedReturns<C> &
-  Omit<Vue, '$data' | '$props' | '$attrs' | '$emit'>
-
-// for Vetur and TSX support
-type VueConstructorProxy<
-  PropsOptions,
-  RawBindings,
-  Data,
-  Computed extends ComputedOptions,
-  Methods extends MethodOptions,
-  Mixin = {},
-  Extends = {},
-  Emits extends EmitsOptions = {},
-  Props = ExtractPropTypes<PropsOptions> &
-    ({} extends Emits ? {} : EmitsToProps<Emits>)
-> = Omit<VueConstructor, never> & {
-  new (...args: any[]): ComponentRenderProxy<
-    Props,
-    ShallowUnwrapRef<RawBindings>,
-    Data,
-    Computed,
-    Methods,
-    Mixin,
-    Extends,
-    Emits,
-    Props,
-    ExtractDefaultPropTypes<PropsOptions>,
-    true
-  >
-}
-
-type DefaultData<V> = object | ((this: V) => object)
-type DefaultMethods<V> = { [key: string]: (this: V, ...args: any[]) => any }
-type DefaultComputed = { [key: string]: any }
-
-export type VueProxy<
-  PropsOptions,
-  RawBindings,
-  Data = DefaultData<Vue>,
-  Computed extends ComputedOptions = DefaultComputed,
-  Methods extends MethodOptions = DefaultMethods<Vue>,
-  Mixin = {},
-  Extends = {},
-  Emits extends EmitsOptions = {}
-> = Vue2ComponentOptions<
-  Vue,
-  ShallowUnwrapRef<RawBindings> & Data,
-  Methods,
-  Computed,
-  PropsOptions,
-  ExtractPropTypes<PropsOptions>
-> &
-  VueConstructorProxy<
-    PropsOptions,
-    RawBindings,
-    Data,
-    Computed,
-    Methods,
-    Mixin,
-    Extends,
-    Emits
-  >
-
-// public properties exposed on the proxy, which is used as the render context
-// in templates (as `this` in the render option)
-export type ComponentPublicInstance<
-  P = {}, // props type extracted from props option
-  B = {}, // raw bindings returned from setup()
-  D = {}, // return from data()
-  C extends ComputedOptions = {},
-  M extends MethodOptions = {},
-  E extends EmitsOptions = {},
-  PublicProps = P,
-  Defaults = {},
-  MakeDefaultsOptional extends boolean = false
-> = {
-  $data: D
-  $props: MakeDefaultsOptional extends true
-    ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
-    : P & PublicProps
-  $attrs: Data
-  $refs: Data
-  $slots: Slots
-  $root: ComponentPublicInstance | null
-  $parent: ComponentPublicInstance | null
-  $emit: EmitFn<E>
-  $el: any
-  // $options: Options & MergedComponentOptionsOverride
-  $forceUpdate: () => void
-  $nextTick: typeof nextTick
-  $watch(
-    source: string | Function,
-    cb: Function,
-    options?: WatchOptions
-  ): WatchStopHandle
-} & P &
-  ShallowUnwrapRef<B> &
-  UnwrapNestedRefs<D> &
-  ExtractComputedReturns<C> &
-  M
diff --git a/types/v3-component-public-instance.d.ts b/types/v3-component-public-instance.d.ts
new file mode 100644
index 00000000000..6734c596ac1
--- /dev/null
+++ b/types/v3-component-public-instance.d.ts
@@ -0,0 +1,230 @@
+import { ExtractDefaultPropTypes, ExtractPropTypes } from './v3-component-props'
+import {
+  DebuggerEvent,
+  nextTick,
+  ShallowUnwrapRef,
+  UnwrapNestedRefs,
+  WatchOptions,
+  WatchStopHandle
+} from './v3-generated'
+import { Data, UnionToIntersection } from './common'
+
+import { VueConstructor } from './vue'
+import {
+  ComputedOptions,
+  MethodOptions,
+  ExtractComputedReturns,
+  ComponentOptionsMixin,
+  ComponentOptionsBase
+} from './v3-component-options'
+import { EmitFn, EmitsOptions, Slots } from './v3-setup-context'
+
+/**
+ * Custom properties added to component instances in any way and can be accessed through `this`
+ *
+ * @example
+ * ```ts
+ * import { Router } from 'vue-router'
+ *
+ * declare module 'vue' {
+ *   interface ComponentCustomProperties {
+ *     $router: Router
+ *   }
+ * }
+ * ```
+ */
+export interface ComponentCustomProperties {}
+
+export type ComponentInstance = InstanceType<VueConstructor>
+
+export type OptionTypesKeys = 'P' | 'B' | 'D' | 'C' | 'M' | 'Defaults'
+
+export type OptionTypesType<
+  P = {},
+  B = {},
+  D = {},
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Defaults = {}
+> = {
+  P: P
+  B: B
+  D: D
+  C: C
+  M: M
+  Defaults: Defaults
+}
+
+type IsDefaultMixinComponent<T> = T extends ComponentOptionsMixin
+  ? ComponentOptionsMixin extends T
+    ? true
+    : false
+  : false
+
+type MixinToOptionTypes<T> = T extends ComponentOptionsBase<
+  infer P,
+  infer B,
+  infer D,
+  infer C,
+  infer M,
+  infer Mixin,
+  infer Extends,
+  any,
+  any,
+  infer Defaults
+>
+  ? OptionTypesType<P & {}, B & {}, D & {}, C & {}, M & {}, Defaults & {}> &
+      IntersectionMixin<Mixin> &
+      IntersectionMixin<Extends>
+  : never
+
+// ExtractMixin(map type) is used to resolve circularly references
+type ExtractMixin<T> = {
+  Mixin: MixinToOptionTypes<T>
+}[T extends ComponentOptionsMixin ? 'Mixin' : never]
+
+type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true
+  ? OptionTypesType<{}, {}, {}, {}, {}, {}>
+  : UnionToIntersection<ExtractMixin<T>>
+
+type UnwrapMixinsType<
+  T,
+  Type extends OptionTypesKeys
+> = T extends OptionTypesType ? T[Type] : never
+
+type EnsureNonVoid<T> = T extends void ? {} : T
+
+export type CreateComponentPublicInstance<
+  P = {},
+  B = {},
+  D = {},
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  E extends EmitsOptions = {},
+  PublicProps = P,
+  Defaults = {},
+  MakeDefaultsOptional extends boolean = false,
+  PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>,
+  PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>,
+  PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>,
+  PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>,
+  PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> &
+    EnsureNonVoid<C>,
+  PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> &
+    EnsureNonVoid<M>,
+  PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> &
+    EnsureNonVoid<Defaults>
+> = ComponentPublicInstance<
+  PublicP,
+  PublicB,
+  PublicD,
+  PublicC,
+  PublicM,
+  E,
+  PublicProps,
+  PublicDefaults,
+  MakeDefaultsOptional
+>
+
+// public properties exposed on the proxy, which is used as the render context
+// in templates (as `this` in the render option)
+export type ComponentPublicInstance<
+  P = {}, // props type extracted from props option
+  B = {}, // raw bindings returned from setup()
+  D = {}, // return from data()
+  C extends ComputedOptions = {},
+  M extends MethodOptions = {},
+  E extends EmitsOptions = {},
+  PublicProps = P,
+  Defaults = {},
+  MakeDefaultsOptional extends boolean = false,
+  Options = ComponentOptionsBase<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+> = {
+  // $: ComponentInternalInstance
+  $data: D
+  $props: Readonly<
+    MakeDefaultsOptional extends true
+      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
+      : P & PublicProps
+  >
+  $attrs: Data
+  $refs: Data
+  $slots: Slots
+  $root: ComponentPublicInstance | null
+  $parent: ComponentPublicInstance | null
+  $emit: EmitFn<E>
+  $el: any
+  $options: Options & MergedComponentOptionsOverride
+  $forceUpdate: () => void
+  $nextTick: typeof nextTick
+  $watch(
+    source: string | Function,
+    cb: Function,
+    options?: WatchOptions
+  ): WatchStopHandle
+} & Readonly<P> &
+  ShallowUnwrapRef<B> &
+  UnwrapNestedRefs<D> &
+  ExtractComputedReturns<C> &
+  M &
+  ComponentCustomProperties
+
+type MergedHook<T = () => void> = T | T[]
+
+export type MergedComponentOptionsOverride = {
+  beforeCreate?: MergedHook
+  created?: MergedHook
+  beforeMount?: MergedHook
+  mounted?: MergedHook
+  beforeUpdate?: MergedHook
+  updated?: MergedHook
+  activated?: MergedHook
+  deactivated?: MergedHook
+  /** @deprecated use `beforeUnmount` instead */
+  beforeDestroy?: MergedHook
+  beforeUnmount?: MergedHook
+  /** @deprecated use `unmounted` instead */
+  destroyed?: MergedHook
+  unmounted?: MergedHook
+  renderTracked?: MergedHook<DebuggerHook>
+  renderTriggered?: MergedHook<DebuggerHook>
+  errorCaptured?: MergedHook<ErrorCapturedHook>
+}
+
+export type DebuggerHook = (e: DebuggerEvent) => void
+
+export type ErrorCapturedHook<TError = unknown> = (
+  err: TError,
+  instance: ComponentPublicInstance | null,
+  info: string
+) => boolean | void
+
+export type ComponentPublicInstanceConstructor<
+  T extends ComponentPublicInstance<
+    Props,
+    RawBindings,
+    D,
+    C,
+    M
+  > = ComponentPublicInstance<any, any, any>,
+  Props = any,
+  RawBindings = any,
+  D = any,
+  C extends ComputedOptions = ComputedOptions,
+  M extends MethodOptions = MethodOptions
+> = {
+  new (...args: any[]): T
+}
diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
index 8d3a47805cf..d6e73914ff0 100644
--- a/types/v3-define-component.d.ts
+++ b/types/v3-define-component.d.ts
@@ -1,15 +1,72 @@
-import { ComponentPropsOptions } from './v3-component-props'
+import { Component } from '..'
+import {
+  ComponentPropsOptions,
+  ExtractDefaultPropTypes,
+  ExtractPropTypes
+} from './v3-component-props'
 import {
   MethodOptions,
   ComputedOptions,
   ComponentOptionsWithoutProps,
   ComponentOptionsWithArrayProps,
-  ComponentOptionsWithProps
+  ComponentOptionsWithProps,
+  ComponentOptionsMixin,
+  ComponentOptionsBase
 } from './v3-component-options'
-import { VueProxy } from './v3-component-proxy'
+import {
+  ComponentPublicInstanceConstructor,
+  CreateComponentPublicInstance
+} from './v3-component-public-instance'
 import { Data, HasDefined } from './common'
 import { EmitsOptions } from './v3-setup-context'
 
+type DefineComponent<
+  PropsOrPropOptions = {},
+  RawBindings = {},
+  D = {},
+  C extends ComputedOptions = ComputedOptions,
+  M extends MethodOptions = MethodOptions,
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  E extends EmitsOptions = {},
+  EE extends string = string,
+  Props = Readonly<
+    PropsOrPropOptions extends ComponentPropsOptions
+      ? ExtractPropTypes<PropsOrPropOptions>
+      : PropsOrPropOptions
+  >,
+  Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>
+> = ComponentPublicInstanceConstructor<
+  CreateComponentPublicInstance<
+    Props,
+    RawBindings,
+    D,
+    C,
+    M,
+    Mixin,
+    Extends,
+    E,
+    Props,
+    Defaults,
+    true
+  > &
+    Props
+> &
+  ComponentOptionsBase<
+    Props,
+    RawBindings,
+    D,
+    C,
+    M,
+    Mixin,
+    Extends,
+    E,
+    EE,
+    Defaults
+  > & {
+    props: PropsOrPropOptions
+  }
+
 /**
  * overload 1: object format with no props
  */
@@ -18,8 +75,8 @@ export function defineComponent<
   D = Data,
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string
 >(
@@ -34,7 +91,8 @@ export function defineComponent<
     Emits,
     EmitsNames
   >
-): VueProxy<{}, RawBindings, D, C, M, Mixin, Extends, Emits>
+): DefineComponent<{}, RawBindings, D, C, M, Mixin, Extends, Emits>
+
 /**
  * overload 2: object format with array props declaration
  * props inferred as `{ [key in PropNames]?: any }`
@@ -47,8 +105,8 @@ export function defineComponent<
   D = Data,
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string,
   PropsOptions extends ComponentPropsOptions = ComponentPropsOptions
@@ -64,7 +122,7 @@ export function defineComponent<
     Emits,
     EmitsNames
   >
-): VueProxy<
+): DefineComponent<
   Readonly<{ [key in PropNames]?: any }>,
   RawBindings,
   D,
@@ -86,8 +144,8 @@ export function defineComponent<
   D = Data,
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
-  Mixin = {},
-  Extends = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string,
   PropsOptions extends ComponentPropsOptions = ComponentPropsOptions
@@ -116,4 +174,4 @@ export function defineComponent<
         Emits,
         EmitsNames
       >
-): VueProxy<PropsOptions, RawBindings, D, C, M, Mixin, Extends, Emits>
+): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, Emits>
diff --git a/types/v3-setup-context.d.ts b/types/v3-setup-context.d.ts
index 43c412e67c6..8a0a7822e35 100644
--- a/types/v3-setup-context.d.ts
+++ b/types/v3-setup-context.d.ts
@@ -29,12 +29,6 @@ export type EmitFn<
       }[Event]
     >
 
-export type ComponentRenderEmitFn<
-  Options = ObjectEmitsOptions,
-  Event extends keyof Options = keyof Options,
-  T extends Vue | void = void
-> = EmitFn<Options, Event, T>
-
 export interface SetupContext<E extends EmitsOptions = {}> {
   attrs: Data
   slots: Slots
diff --git a/types/vnode.d.ts b/types/vnode.d.ts
index fabfad44c97..7a543f0a39b 100644
--- a/types/vnode.d.ts
+++ b/types/vnode.d.ts
@@ -1,6 +1,19 @@
 import { Vue } from './vue'
 import { DirectiveFunction, DirectiveOptions } from './options'
 
+/**
+ * For extending allowed non-declared props on components in TSX
+ */
+export interface ComponentCustomProps {}
+
+/**
+ * Default allowed non-declared props on component in TSX
+ */
+export interface AllowedComponentProps {
+  class?: unknown
+  style?: unknown
+}
+
 export type ScopedSlot = (props: any) => ScopedSlotReturnValue
 type ScopedSlotReturnValue =
   | VNode

From 1294385300742acbea5f05c166685bd4a1fab35a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 5 Jul 2022 10:32:56 +0800
Subject: [PATCH 211/317] fix(compiler-sfc): preserve old deindent behavior for
 pug

fix #12611
---
 packages/compiler-sfc/src/parseComponent.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 0849a649c2e..39322a3efd4 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -10,6 +10,7 @@ export const DEFAULT_FILENAME = 'anonymous.vue'
 const splitRE = /\r?\n/g
 const replaceRE = /./g
 const isSpecialTag = makeMap('script,style,template', true)
+const isNeedIndentLang = makeMap('pug,jade')
 
 export interface SFCCustomBlock {
   type: string
@@ -177,7 +178,11 @@ export function parseComponent(
     if (depth === 1 && currentBlock) {
       currentBlock.end = start
       let text = source.slice(currentBlock.start, currentBlock.end)
-      if (options.deindent) {
+      if (
+        options.deindent ||
+        // certain langs like pug are indent sensitive, preserve old behavior
+        (currentBlock.lang && isNeedIndentLang(currentBlock.lang))
+      ) {
         text = deindent(text)
       }
       // pad content so that linters and pre-processors can output correct

From e244687135dcd0fd55ad0423d5d5fbf2ba389c4e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 5 Jul 2022 10:54:47 +0800
Subject: [PATCH 212/317] release: v2.7.2

---
 CHANGELOG.md                            | 15 +++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8970e47eee3..6c9c799f3ee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,18 @@
+## [2.7.2](https://github.com/vuejs/vue/compare/v2.7.1...v2.7.2) (2022-07-05)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** preserve old deindent behavior for pug ([1294385](https://github.com/vuejs/vue/commit/1294385300742acbea5f05c166685bd4a1fab35a)), closes [#12611](https://github.com/vuejs/vue/issues/12611)
+
+
+### Features
+
+* allow passing directive definition directly to h() ([#12590](https://github.com/vuejs/vue/issues/12590)) ([d45bbea](https://github.com/vuejs/vue/commit/d45bbeac2710a5cf9185377abc2342295f0bb4e2))
+* **types:** define component improvements ([#12612](https://github.com/vuejs/vue/issues/12612)) ([fb93c1b](https://github.com/vuejs/vue/commit/fb93c1be77f12ea1375c5e8b47d168e4d5ceb7be))
+
+
+
 ## [2.7.1](https://github.com/vuejs/vue/compare/v2.7.0...v2.7.1) (2022-07-04)
 
 
diff --git a/package.json b/package.json
index b89df04e9a7..395fba3f030 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index bce61b23e17..8fc8525fdf5 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index a914acd43ab..d8277654275 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 81aba7d0cfb..acaac8b2992 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.1",
+  "version": "2.7.2",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 94ccca207c9c5fc0fc8985e0c103d8a1c9cff412 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 6 Jul 2022 11:17:33 +0800
Subject: [PATCH 213/317] fix(types): allow slot attribute

close #12617
---
 types/jsx.d.ts             | 6 ++++++
 types/test/v3/tsx-test.tsx | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/types/jsx.d.ts b/types/jsx.d.ts
index 151a660be9f..85c9c1df23d 100644
--- a/types/jsx.d.ts
+++ b/types/jsx.d.ts
@@ -1303,6 +1303,12 @@ type EventHandlers<E> = {
 type ReservedProps = {
   key?: string | number | symbol
   ref?: VNodeData['ref']
+  /**
+   * @deprecated Old named slot syntax has been deprecated, use the new syntax
+   * instead: `<template v-slot:name>`
+   * https://v2.vuejs.org/v2/guide/components-slots.html#Named-Slots
+   */
+  slot?: string
 }
 
 type ElementAttrs<T> = T & ReservedProps
diff --git a/types/test/v3/tsx-test.tsx b/types/test/v3/tsx-test.tsx
index f9c77b7183e..16a767acc5a 100644
--- a/types/test/v3/tsx-test.tsx
+++ b/types/test/v3/tsx-test.tsx
@@ -51,3 +51,5 @@ const Foo = defineComponent({
 // working
 ;<Foo bar={1} />
 ;<Foo bar={1} foo="baz" />
+
+;<div slot="x" />

From 360272bde32e93b1a8d611e4b97af1300c38e7a3 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 6 Jul 2022 12:49:30 +0800
Subject: [PATCH 214/317] fix(ssr/reactivity): fix composition api behavior in
 SSR

fix #12615
---
 .../test/ssr-reactivity.spec.ts               | 192 ++++++++++++++++++
 src/core/observer/index.ts                    | 109 +++++-----
 src/v3/reactivity/reactive.ts                 |  15 +-
 src/v3/reactivity/ref.ts                      |   8 +-
 4 files changed, 265 insertions(+), 59 deletions(-)
 create mode 100644 packages/server-renderer/test/ssr-reactivity.spec.ts

diff --git a/packages/server-renderer/test/ssr-reactivity.spec.ts b/packages/server-renderer/test/ssr-reactivity.spec.ts
new file mode 100644
index 00000000000..f9b145c7740
--- /dev/null
+++ b/packages/server-renderer/test/ssr-reactivity.spec.ts
@@ -0,0 +1,192 @@
+// @vitest-environment node
+
+import Vue from 'vue'
+import {
+  reactive,
+  ref,
+  isReactive,
+  shallowRef,
+  isRef,
+  set,
+  nextTick,
+  getCurrentInstance
+} from 'v3'
+import { createRenderer } from '../src'
+
+describe('SSR Reactive', () => {
+  beforeEach(() => {
+    // force SSR env
+    global.process.env.VUE_ENV = 'server'
+  })
+
+  it('should not affect non reactive APIs', () => {
+    expect(typeof window).toBe('undefined')
+    expect((Vue.observable({}) as any).__ob__).toBeUndefined()
+  })
+
+  it('reactive behavior should be consistent in SSR', () => {
+    const obj = reactive({
+      foo: ref(1),
+      bar: {
+        baz: ref(2)
+      },
+      arr: [{ foo: ref(3) }]
+    })
+    expect(isReactive(obj)).toBe(true)
+    expect(obj.foo).toBe(1)
+
+    expect(isReactive(obj.bar)).toBe(true)
+    expect(obj.bar.baz).toBe(2)
+
+    expect(isReactive(obj.arr)).toBe(true)
+    expect(isReactive(obj.arr[0])).toBe(true)
+    expect(obj.arr[0].foo).toBe(3)
+  })
+
+  it('ref value', () => {
+    const r = ref({})
+    expect(isReactive(r.value)).toBe(true)
+  })
+
+  it('should render', async () => {
+    const app = new Vue({
+      setup() {
+        return {
+          count: ref(42)
+        }
+      },
+      render(this: any, h) {
+        return h('div', this.count)
+      }
+    })
+
+    const serverRenderer = createRenderer()
+    const html = await serverRenderer.renderToString(app)
+    expect(html).toBe('<div data-server-rendered="true">42</div>')
+  })
+
+  it('reactive + isReactive', () => {
+    const state = reactive({})
+    expect(isReactive(state)).toBe(true)
+  })
+
+  it('shallowRef + isRef', () => {
+    const state = shallowRef({})
+    expect(isRef(state)).toBe(true)
+  })
+
+  it('should work on objects sets with set()', () => {
+    const state = ref<any>({})
+
+    set(state.value, 'a', {})
+    expect(isReactive(state.value.a)).toBe(true)
+
+    set(state.value, 'a', {})
+    expect(isReactive(state.value.a)).toBe(true)
+  })
+
+  it('should work on arrays sets with set()', () => {
+    const state = ref<any>([])
+
+    set(state.value, 1, {})
+    expect(isReactive(state.value[1])).toBe(true)
+
+    set(state.value, 1, {})
+    expect(isReactive(state.value[1])).toBe(true)
+  })
+
+  // #550
+  it('props should work with set', async done => {
+    let props: any
+
+    const app = new Vue({
+      render(this: any, h) {
+        return h('child', { attrs: { msg: this.msg } })
+      },
+      setup() {
+        return { msg: ref('hello') }
+      },
+      components: {
+        child: {
+          render(this: any, h: any) {
+            return h('span', this.data.msg)
+          },
+          props: ['msg'],
+          setup(_props) {
+            props = _props
+
+            return { data: _props }
+          }
+        }
+      }
+    })
+
+    const serverRenderer = createRenderer()
+    const html = await serverRenderer.renderToString(app)
+
+    expect(html).toBe('<span data-server-rendered="true">hello</span>')
+
+    expect(props.bar).toBeUndefined()
+    set(props, 'bar', 'bar')
+    expect(props.bar).toBe('bar')
+
+    done()
+  })
+
+  // #721
+  it('should behave correctly', () => {
+    const state = ref({ old: ref(false) })
+    set(state.value, 'new', ref(true))
+    // console.log(process.server, 'state.value', JSON.stringify(state.value))
+
+    expect(state.value).toMatchObject({
+      old: false,
+      new: true
+    })
+  })
+
+  // #721
+  it('should behave correctly for the nested ref in the object', () => {
+    const state = { old: ref(false) }
+    set(state, 'new', ref(true))
+    expect(JSON.stringify(state)).toBe(
+      '{"old":{"value":false},"new":{"value":true}}'
+    )
+  })
+
+  // #721
+  it('should behave correctly for ref of object', () => {
+    const state = ref({ old: ref(false) })
+    set(state.value, 'new', ref(true))
+    expect(JSON.stringify(state.value)).toBe('{"old":false,"new":true}')
+  })
+
+  it('ssr should not RangeError: Maximum call stack size exceeded', async () => {
+    new Vue({
+      setup() {
+        // @ts-expect-error
+        const app = getCurrentInstance().proxy
+        let mockNt: any = []
+        mockNt.__ob__ = {}
+        const test = reactive({
+          app,
+          mockNt
+        })
+        return {
+          test
+        }
+      }
+    })
+    await nextTick()
+    expect(
+      `"RangeError: Maximum call stack size exceeded"`
+    ).not.toHaveBeenWarned()
+  })
+
+  it('should work on objects sets with set()', () => {
+    const state = ref<any>({})
+    set(state.value, 'a', {})
+
+    expect(isReactive(state.value.a)).toBe(true)
+  })
+})
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 6180b8e904f..004a65fe6b5 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -13,7 +13,8 @@ import {
   isUndef,
   isValidArrayIndex,
   isServerRendering,
-  hasChanged
+  hasChanged,
+  noop
 } from '../util/index'
 import { isReadonly, isRef, TrackOpTypes, TriggerOpTypes } from '../../v3'
 
@@ -31,6 +32,14 @@ export function toggleObserving(value: boolean) {
   shouldObserve = value
 }
 
+// ssr mock dep
+const mockDep = {
+  notify: noop,
+  depend: noop,
+  addSub: noop,
+  removeSub: noop
+} as Dep
+
 /**
  * Observer class that is attached to each observed
  * object. Once attached, the observer converts the target
@@ -41,78 +50,63 @@ export class Observer {
   dep: Dep
   vmCount: number // number of vms that have this object as root $data
 
-  constructor(public value: any, public shallow = false) {
+  constructor(public value: any, public shallow = false, public mock = false) {
     // this.value = value
-    this.dep = new Dep()
+    this.dep = mock ? mockDep : new Dep()
     this.vmCount = 0
     def(value, '__ob__', this)
     if (isArray(value)) {
-      if (hasProto) {
-        protoAugment(value, arrayMethods)
-      } else {
-        copyAugment(value, arrayMethods, arrayKeys)
+      if (!mock) {
+        if (hasProto) {
+          /* eslint-disable no-proto */
+          ;(value as any).__proto__ = arrayMethods
+          /* eslint-enable no-proto */
+        } else {
+          for (let i = 0, l = arrayKeys.length; i < l; i++) {
+            const key = arrayKeys[i]
+            def(value, key, arrayMethods[key])
+          }
+        }
       }
       if (!shallow) {
         this.observeArray(value)
       }
     } else {
-      this.walk(value, shallow)
-    }
-  }
-
-  /**
-   * Walk through all properties and convert them into
-   * getter/setters. This method should only be called when
-   * value type is Object.
-   */
-  walk(obj: object, shallow: boolean) {
-    const keys = Object.keys(obj)
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i]
-      defineReactive(obj, key, NO_INIITIAL_VALUE, undefined, shallow)
+      /**
+       * Walk through all properties and convert them into
+       * getter/setters. This method should only be called when
+       * value type is Object.
+       */
+      const keys = Object.keys(value)
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i]
+        defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock)
+      }
     }
   }
 
   /**
    * Observe a list of Array items.
    */
-  observeArray(items: Array<any>) {
-    for (let i = 0, l = items.length; i < l; i++) {
-      observe(items[i])
+  observeArray(value: any[]) {
+    for (let i = 0, l = value.length; i < l; i++) {
+      observe(value[i], false, this.mock)
     }
   }
 }
 
 // helpers
 
-/**
- * Augment a target Object or Array by intercepting
- * the prototype chain using __proto__
- */
-function protoAugment(target, src: Object) {
-  /* eslint-disable no-proto */
-  target.__proto__ = src
-  /* eslint-enable no-proto */
-}
-
-/**
- * Augment a target Object or Array by defining
- * hidden properties.
- */
-/* istanbul ignore next */
-function copyAugment(target: Object, src: Object, keys: Array<string>) {
-  for (let i = 0, l = keys.length; i < l; i++) {
-    const key = keys[i]
-    def(target, key, src[key])
-  }
-}
-
 /**
  * Attempt to create an observer instance for a value,
  * returns the new observer if successfully observed,
  * or the existing observer if the value already has one.
  */
-export function observe(value: any, shallow?: boolean): Observer | void {
+export function observe(
+  value: any,
+  shallow?: boolean,
+  ssrMockReactivity?: boolean
+): Observer | void {
   if (!isObject(value) || isRef(value) || value instanceof VNode) {
     return
   }
@@ -121,12 +115,12 @@ export function observe(value: any, shallow?: boolean): Observer | void {
     ob = value.__ob__
   } else if (
     shouldObserve &&
-    !isServerRendering() &&
+    (ssrMockReactivity || !isServerRendering()) &&
     (isArray(value) || isPlainObject(value)) &&
     Object.isExtensible(value) &&
-    !value.__v_skip
+    !value.__v_skip /* ReactiveFlags.SKIP */
   ) {
-    ob = new Observer(value, shallow)
+    ob = new Observer(value, shallow, ssrMockReactivity)
   }
   return ob
 }
@@ -139,7 +133,8 @@ export function defineReactive(
   key: string,
   val?: any,
   customSetter?: Function | null,
-  shallow?: boolean
+  shallow?: boolean,
+  mock?: boolean
 ) {
   const dep = new Dep()
 
@@ -158,7 +153,7 @@ export function defineReactive(
     val = obj[key]
   }
 
-  let childOb = !shallow && observe(val)
+  let childOb = !shallow && observe(val, false, mock)
   Object.defineProperty(obj, key, {
     enumerable: true,
     configurable: true,
@@ -202,7 +197,7 @@ export function defineReactive(
       } else {
         val = newVal
       }
-      childOb = !shallow && observe(newVal)
+      childOb = !shallow && observe(newVal, false, mock)
       if (__DEV__) {
         dep.notify({
           type: TriggerOpTypes.SET,
@@ -241,16 +236,20 @@ export function set(
     __DEV__ && warn(`Set operation on key "${key}" failed: target is readonly.`)
     return
   }
+  const ob = (target as any).__ob__
   if (isArray(target) && isValidArrayIndex(key)) {
     target.length = Math.max(target.length, key)
     target.splice(key, 1, val)
+    // when mocking for SSR, array methods are not hijacked
+    if (!ob.shallow && ob.mock) {
+      observe(val, false, true)
+    }
     return val
   }
   if (key in target && !(key in Object.prototype)) {
     target[key] = val
     return val
   }
-  const ob = (target as any).__ob__
   if ((target as any)._isVue || (ob && ob.vmCount)) {
     __DEV__ &&
       warn(
@@ -263,7 +262,7 @@ export function set(
     target[key] = val
     return val
   }
-  defineReactive(ob.value, key, val)
+  defineReactive(ob.value, key, val, undefined, ob.shallow, ob.mock)
   if (__DEV__) {
     ob.dep.notify({
       type: TriggerOpTypes.ADD,
diff --git a/src/v3/reactivity/reactive.ts b/src/v3/reactivity/reactive.ts
index d750dd2c713..0ff682243a2 100644
--- a/src/v3/reactivity/reactive.ts
+++ b/src/v3/reactivity/reactive.ts
@@ -1,5 +1,12 @@
 import { observe, Observer } from 'core/observer'
-import { def, isArray, isPrimitive, warn, toRawType } from 'core/util'
+import {
+  def,
+  isArray,
+  isPrimitive,
+  warn,
+  toRawType,
+  isServerRendering
+} from 'core/util'
 import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
 
 export const enum ReactiveFlags {
@@ -67,7 +74,11 @@ function makeReactive(target: any, shallow: boolean) {
         )
       }
     }
-    const ob = observe(target, shallow)
+    const ob = observe(
+      target,
+      shallow,
+      isServerRendering() /* ssr mock reactivity */
+    )
     if (__DEV__ && !ob) {
       if (target == null || isPrimitive(target)) {
         warn(`value cannot be made reactive: ${String(target)}`)
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index 3b8d2fc7d1e..f7026df05a1 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -6,7 +6,7 @@ import {
 } from './reactive'
 import type { IfAny } from 'types/utils'
 import Dep from 'core/observer/dep'
-import { warn, isArray, def } from 'core/util'
+import { warn, isArray, def, isServerRendering } from 'core/util'
 import { TrackOpTypes, TriggerOpTypes } from './operations'
 
 declare const RefSymbol: unique symbol
@@ -69,7 +69,11 @@ function createRef(rawValue: unknown, shallow: boolean) {
   const ref: any = {}
   def(ref, RefFlag, true)
   def(ref, ReactiveFlags.IS_SHALLOW, true)
-  ref.dep = defineReactive(ref, 'value', rawValue, null, shallow)
+  def(
+    ref,
+    'dep',
+    defineReactive(ref, 'value', rawValue, null, shallow, isServerRendering())
+  )
   return ref
 }
 

From 6d1dbeee7ebd27a87c37393d8cabf2ef8253f3a4 Mon Sep 17 00:00:00 2001
From: Caleb Hearon <caleb@chearon.net>
Date: Wed, 6 Jul 2022 00:59:30 -0400
Subject: [PATCH 215/317] fix: add renderTracked/Triggered merge strategy
 (#12616)

---
 src/shared/constants.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/shared/constants.ts b/src/shared/constants.ts
index 990bfcb49be..660c4d90519 100644
--- a/src/shared/constants.ts
+++ b/src/shared/constants.ts
@@ -14,5 +14,7 @@ export const LIFECYCLE_HOOKS = [
   'activated',
   'deactivated',
   'errorCaptured',
-  'serverPrefetch'
+  'serverPrefetch',
+  'renderTracked',
+  'renderTriggered'
 ] as const

From 15e6f1dee47ea38af0ad541014e91df0ad9b062f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 6 Jul 2022 13:16:22 +0800
Subject: [PATCH 216/317] release: v2.7.3

---
 CHANGELOG.md                            | 11 +++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c9c799f3ee..7cfac15899c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+## [2.7.3](https://github.com/vuejs/vue/compare/v2.7.2...v2.7.3) (2022-07-06)
+
+
+### Bug Fixes
+
+* add renderTracked/Triggered merge strategy ([#12616](https://github.com/vuejs/vue/issues/12616)) ([6d1dbee](https://github.com/vuejs/vue/commit/6d1dbeee7ebd27a87c37393d8cabf2ef8253f3a4))
+* **ssr/reactivity:** fix composition api behavior in SSR ([360272b](https://github.com/vuejs/vue/commit/360272bde32e93b1a8d611e4b97af1300c38e7a3)), closes [#12615](https://github.com/vuejs/vue/issues/12615)
+* **types:** allow slot attribute ([94ccca2](https://github.com/vuejs/vue/commit/94ccca207c9c5fc0fc8985e0c103d8a1c9cff412)), closes [#12617](https://github.com/vuejs/vue/issues/12617)
+
+
+
 ## [2.7.2](https://github.com/vuejs/vue/compare/v2.7.1...v2.7.2) (2022-07-05)
 
 
diff --git a/package.json b/package.json
index 395fba3f030..29c5ec3b674 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 8fc8525fdf5..2cf6872ed9d 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index d8277654275..e791637f9c7 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index acaac8b2992..5d2a22ad2d4 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.2",
+  "version": "2.7.3",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From ca7daefaa15a192046d22d060220cd595a6a275f Mon Sep 17 00:00:00 2001
From: blackie <blackywkl@gmail.com>
Date: Fri, 8 Jul 2022 09:44:41 +0800
Subject: [PATCH 217/317] fix(ssr/reactivity): fix array setting error at
 created in ssr [#12632] (#12633)

fix #12632
---
 packages/server-renderer/test/ssr-reactivity.spec.ts | 4 ++++
 src/core/observer/index.ts                           | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/packages/server-renderer/test/ssr-reactivity.spec.ts b/packages/server-renderer/test/ssr-reactivity.spec.ts
index f9b145c7740..773fa9dd650 100644
--- a/packages/server-renderer/test/ssr-reactivity.spec.ts
+++ b/packages/server-renderer/test/ssr-reactivity.spec.ts
@@ -93,6 +93,10 @@ describe('SSR Reactive', () => {
 
     set(state.value, 1, {})
     expect(isReactive(state.value[1])).toBe(true)
+
+    const rawArr = []
+    set(rawArr, 1, {})
+    expect(isReactive(rawArr[1])).toBe(false)
   })
 
   // #550
diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 004a65fe6b5..84744dd85f9 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -241,7 +241,7 @@ export function set(
     target.length = Math.max(target.length, key)
     target.splice(key, 1, val)
     // when mocking for SSR, array methods are not hijacked
-    if (!ob.shallow && ob.mock) {
+    if (ob && !ob.shallow && ob.mock) {
       observe(val, false, true)
     }
     return val

From b70a2585fcd102def2bb5a3b2b589edf5311122d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 09:45:11 +0800
Subject: [PATCH 218/317] fix(compiler-sfc): use safer deindent default for
 compatibility with previous behavior

---
 packages/compiler-sfc/src/parseComponent.ts       | 11 +++++++----
 packages/compiler-sfc/test/parseComponent.spec.ts | 13 ++++++-------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 39322a3efd4..65b858c9fc0 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -10,7 +10,6 @@ export const DEFAULT_FILENAME = 'anonymous.vue'
 const splitRE = /\r?\n/g
 const replaceRE = /./g
 const isSpecialTag = makeMap('script,style,template', true)
-const isNeedIndentLang = makeMap('pug,jade')
 
 export interface SFCCustomBlock {
   type: string
@@ -179,9 +178,13 @@ export function parseComponent(
       currentBlock.end = start
       let text = source.slice(currentBlock.start, currentBlock.end)
       if (
-        options.deindent ||
-        // certain langs like pug are indent sensitive, preserve old behavior
-        (currentBlock.lang && isNeedIndentLang(currentBlock.lang))
+        options.deindent === true ||
+        // by default, deindent unless it's script with default lang or ts
+        (options.deindent !== false &&
+          !(
+            currentBlock.type === 'script' &&
+            (!currentBlock.lang || currentBlock.lang === 'ts')
+          ))
       ) {
         text = deindent(text)
       }
diff --git a/packages/compiler-sfc/test/parseComponent.spec.ts b/packages/compiler-sfc/test/parseComponent.spec.ts
index 4624bb2040d..83f73483e0c 100644
--- a/packages/compiler-sfc/test/parseComponent.spec.ts
+++ b/packages/compiler-sfc/test/parseComponent.spec.ts
@@ -25,8 +25,7 @@ describe('Single File Component parser', () => {
       <div>
         <style>nested should be ignored</style>
       </div>
-    `,
-      { deindent: true }
+    `
     )
     expect(res.template!.content.trim()).toBe('<div>hi</div>')
     expect(res.styles.length).toBe(4)
@@ -76,8 +75,7 @@ describe('Single File Component parser', () => {
       </style>
     `
     const deindentDefault = parseComponent(content.trim(), {
-      pad: false,
-      deindent: true
+      pad: false
     })
     const deindentEnabled = parseComponent(content.trim(), {
       pad: false,
@@ -89,7 +87,9 @@ describe('Single File Component parser', () => {
     })
 
     expect(deindentDefault.template!.content).toBe('\n<div></div>\n')
-    expect(deindentDefault.script!.content).toBe('\nexport default {}\n')
+    expect(deindentDefault.script!.content).toBe(
+      '\n        export default {}\n      '
+    )
     expect(deindentDefault.styles[0].content).toBe('\nh1 { color: red }\n')
     expect(deindentEnabled.template!.content).toBe('\n<div></div>\n')
     expect(deindentEnabled.script!.content).toBe('\nexport default {}\n')
@@ -203,8 +203,7 @@ describe('Single File Component parser', () => {
       }
       </test>
       <custom src="./x.json"></custom>
-    `,
-      { deindent: true }
+    `
     )
     expect(res.customBlocks.length).toBe(4)
 

From 26ff4bc0ed75d8bf7921523a2e546df24ec81d8f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 10:39:23 +0800
Subject: [PATCH 219/317] fix(types): global component registration type compat
 w/ defineComponent

fix #12622
---
 types/test/v3/define-component-test.tsx | 13 +++++++------
 types/vue.d.ts                          |  5 +++++
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 7bdbdb82444..9b01e3e45f4 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1,3 +1,4 @@
+import Vue, { VueConstructor } from '../../index'
 import {
   Component,
   defineComponent,
@@ -8,12 +9,12 @@ import {
 } from '../../index'
 import { describe, test, expectType, expectError, IsUnion } from '../utils'
 
-defineComponent({
-  props: {
-    foo: Number
-  },
-  render() {
-    this.foo
+describe('compat with v2 APIs', () => {
+  const comp = defineComponent({})
+
+  Vue.component('foo', comp)
+  function install(app: VueConstructor) {
+    app.component('foo', comp)
   }
 })
 
diff --git a/types/vue.d.ts b/types/vue.d.ts
index afa66b5c2c5..82cad69e793 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -14,6 +14,7 @@ import {
 } from './options'
 import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
 import { PluginFunction, PluginObject } from './plugin'
+import { DefineComponent } from './v3-define-component'
 
 export interface CreateElement {
   (
@@ -313,6 +314,10 @@ export interface VueConstructor<V extends Vue = Vue> {
     id: string,
     definition?: ComponentOptions<V>
   ): ExtendedVue<V, {}, {}, {}, {}, {}>
+  component<T extends DefineComponent<any, any, any, any, any, any, any, any>>(
+    id: string,
+    definition?: T
+  ): T
 
   use<T>(
     plugin: PluginObject<T> | PluginFunction<T>,

From 9d12106e211e0cbf33f9066606a8ff29f8cc8e8d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 10:55:23 +0800
Subject: [PATCH 220/317] feat: defineAsyncComponent

close #12608
---
 src/v3/apiAsyncComponent.ts                   | 117 +++++++++
 src/v3/index.ts                               |   2 +
 .../features/v3/apiAsyncComponent.spec.ts     | 241 ++++++++++++++++++
 types/test/v3/define-async-component-test.tsx |  19 ++
 types/v3-define-async-component.d.ts          |  26 ++
 types/v3-define-component.d.ts                |   1 -
 6 files changed, 405 insertions(+), 1 deletion(-)
 create mode 100644 src/v3/apiAsyncComponent.ts
 create mode 100644 test/unit/features/v3/apiAsyncComponent.spec.ts
 create mode 100644 types/test/v3/define-async-component-test.tsx
 create mode 100644 types/v3-define-async-component.d.ts

diff --git a/src/v3/apiAsyncComponent.ts b/src/v3/apiAsyncComponent.ts
new file mode 100644
index 00000000000..aca3a7a0ab8
--- /dev/null
+++ b/src/v3/apiAsyncComponent.ts
@@ -0,0 +1,117 @@
+import { warn, isFunction, isObject } from 'core/util'
+
+interface AsyncComponentOptions {
+  loader: Function
+  loadingComponent?: any
+  errorComponent?: any
+  delay?: number
+  timeout?: number
+  suspensible?: boolean
+  onError?: (
+    error: Error,
+    retry: () => void,
+    fail: () => void,
+    attempts: number
+  ) => any
+}
+
+type AsyncComponentFactory = () => {
+  component: Promise<any>
+  loading?: any
+  error?: any
+  delay?: number
+  timeout?: number
+}
+
+/**
+ * v3-compatible async component API.
+ * @internal the type is manually declared in <root>/types/v3-define-async-component.d.ts
+ * because it relies on existing manual types
+ */
+export function defineAsyncComponent(
+  source: (() => any) | AsyncComponentOptions
+): AsyncComponentFactory {
+  if (isFunction(source)) {
+    source = { loader: source } as AsyncComponentOptions
+  }
+
+  const {
+    loader,
+    loadingComponent,
+    errorComponent,
+    delay = 200,
+    timeout, // undefined = never times out
+    suspensible = false, // in Vue 3 default is true
+    onError: userOnError
+  } = source
+
+  if (__DEV__ && suspensible) {
+    warn(
+      `The suspensiblbe option for async components is not supported in Vue2. It is ignored.`
+    )
+  }
+
+  let pendingRequest: Promise<any> | null = null
+
+  let retries = 0
+  const retry = () => {
+    retries++
+    pendingRequest = null
+    return load()
+  }
+
+  const load = (): Promise<any> => {
+    let thisRequest: Promise<any>
+    return (
+      pendingRequest ||
+      (thisRequest = pendingRequest =
+        loader()
+          .catch(err => {
+            err = err instanceof Error ? err : new Error(String(err))
+            if (userOnError) {
+              return new Promise((resolve, reject) => {
+                const userRetry = () => resolve(retry())
+                const userFail = () => reject(err)
+                userOnError(err, userRetry, userFail, retries + 1)
+              })
+            } else {
+              throw err
+            }
+          })
+          .then((comp: any) => {
+            if (thisRequest !== pendingRequest && pendingRequest) {
+              return pendingRequest
+            }
+            if (__DEV__ && !comp) {
+              warn(
+                `Async component loader resolved to undefined. ` +
+                  `If you are using retry(), make sure to return its return value.`
+              )
+            }
+            // interop module default
+            if (
+              comp &&
+              (comp.__esModule || comp[Symbol.toStringTag] === 'Module')
+            ) {
+              comp = comp.default
+            }
+            if (__DEV__ && comp && !isObject(comp) && !isFunction(comp)) {
+              throw new Error(`Invalid async component load result: ${comp}`)
+            }
+            return comp
+          }))
+    )
+  }
+
+  return () => {
+    const component = load()
+
+    return {
+      component,
+      delay,
+      timeout,
+      error: errorComponent,
+      loading: loadingComponent
+    }
+  }
+}
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 75c21ad32f3..ec9d59e5444 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -87,4 +87,6 @@ export function defineComponent(options: any) {
   return options
 }
 
+export { defineAsyncComponent } from './apiAsyncComponent'
+
 export * from './apiLifecycle'
diff --git a/test/unit/features/v3/apiAsyncComponent.spec.ts b/test/unit/features/v3/apiAsyncComponent.spec.ts
new file mode 100644
index 00000000000..2970738f9d5
--- /dev/null
+++ b/test/unit/features/v3/apiAsyncComponent.spec.ts
@@ -0,0 +1,241 @@
+import Vue from 'vue'
+import { defineAsyncComponent, h, ref, nextTick, defineComponent } from 'v3'
+import { Component } from 'types/component'
+
+const timeout = (n: number = 0) => new Promise(r => setTimeout(r, n))
+
+const loadingComponent = defineComponent({
+  template: `<div>loading</div>`
+})
+
+const resolvedComponent = defineComponent({
+  template: `<div>resolved</div>`
+})
+
+describe('api: defineAsyncComponent', () => {
+  afterEach(() => {
+    Vue.config.errorHandler = undefined
+  })
+
+  test('simple usage', async () => {
+    let resolve: (comp: Component) => void
+    const Foo = defineAsyncComponent(
+      () =>
+        new Promise(r => {
+          resolve = r as any
+        })
+    )
+
+    const toggle = ref(true)
+
+    const vm = new Vue({
+      render: () => (toggle.value ? h(Foo) : null)
+    }).$mount()
+
+    expect(vm.$el.nodeType).toBe(8)
+
+    resolve!(resolvedComponent)
+    // first time resolve, wait for macro task since there are multiple
+    // microtasks / .then() calls
+    await timeout()
+    expect(vm.$el.innerHTML).toBe('resolved')
+
+    toggle.value = false
+    await nextTick()
+    expect(vm.$el.nodeType).toBe(8)
+
+    // already resolved component should update on nextTick
+    toggle.value = true
+    await nextTick()
+    expect(vm.$el.innerHTML).toBe('resolved')
+  })
+
+  test('with loading component', async () => {
+    let resolve: (comp: Component) => void
+    const Foo = defineAsyncComponent({
+      loader: () =>
+        new Promise(r => {
+          resolve = r as any
+        }),
+      loadingComponent,
+      delay: 1 // defaults to 200
+    })
+
+    const toggle = ref(true)
+
+    const vm = new Vue({
+      render: () => (toggle.value ? h(Foo) : null)
+    }).$mount()
+
+    // due to the delay, initial mount should be empty
+    expect(vm.$el.nodeType).toBe(8)
+
+    // loading show up after delay
+    await timeout(1)
+    expect(vm.$el.innerHTML).toBe('loading')
+
+    resolve!(resolvedComponent)
+    await timeout()
+    expect(vm.$el.innerHTML).toBe('resolved')
+
+    toggle.value = false
+    await nextTick()
+    expect(vm.$el.nodeType).toBe(8)
+
+    // already resolved component should update on nextTick without loading
+    // state
+    toggle.value = true
+    await nextTick()
+    expect(vm.$el.innerHTML).toBe('resolved')
+  })
+
+  test('error with error component', async () => {
+    let reject: (e: Error) => void
+    const Foo = defineAsyncComponent({
+      loader: () =>
+        new Promise((_resolve, _reject) => {
+          reject = _reject
+        }),
+      errorComponent: {
+        template: `<div>errored</div>`
+      }
+    })
+
+    const toggle = ref(true)
+
+    const vm = new Vue({
+      render: () => (toggle.value ? h(Foo) : null)
+    }).$mount()
+
+    expect(vm.$el.nodeType).toBe(8)
+
+    const err = new Error('errored')
+    reject!(err)
+    await timeout()
+    expect('Failed to resolve async').toHaveBeenWarned()
+    expect(vm.$el.innerHTML).toBe('errored')
+
+    toggle.value = false
+    await nextTick()
+    expect(vm.$el.nodeType).toBe(8)
+  })
+
+  test('retry (success)', async () => {
+    let loaderCallCount = 0
+    let resolve: (comp: Component) => void
+    let reject: (e: Error) => void
+
+    const Foo = defineAsyncComponent({
+      loader: () => {
+        loaderCallCount++
+        return new Promise((_resolve, _reject) => {
+          resolve = _resolve as any
+          reject = _reject
+        })
+      },
+      onError(error, retry, fail) {
+        if (error.message.match(/foo/)) {
+          retry()
+        } else {
+          fail()
+        }
+      }
+    })
+
+    const vm = new Vue({
+      render: () => h(Foo)
+    }).$mount()
+
+    expect(vm.$el.nodeType).toBe(8)
+    expect(loaderCallCount).toBe(1)
+
+    const err = new Error('foo')
+    reject!(err)
+    await timeout()
+    expect(loaderCallCount).toBe(2)
+    expect(vm.$el.nodeType).toBe(8)
+
+    // should render this time
+    resolve!(resolvedComponent)
+    await timeout()
+    expect(vm.$el.innerHTML).toBe('resolved')
+  })
+
+  test('retry (skipped)', async () => {
+    let loaderCallCount = 0
+    let reject: (e: Error) => void
+
+    const Foo = defineAsyncComponent({
+      loader: () => {
+        loaderCallCount++
+        return new Promise((_resolve, _reject) => {
+          reject = _reject
+        })
+      },
+      onError(error, retry, fail) {
+        if (error.message.match(/bar/)) {
+          retry()
+        } else {
+          fail()
+        }
+      }
+    })
+
+    const vm = new Vue({
+      render: () => h(Foo)
+    }).$mount()
+
+    expect(vm.$el.nodeType).toBe(8)
+    expect(loaderCallCount).toBe(1)
+
+    const err = new Error('foo')
+    reject!(err)
+    await timeout()
+    // should fail because retryWhen returns false
+    expect(loaderCallCount).toBe(1)
+    expect(vm.$el.nodeType).toBe(8)
+    expect('Failed to resolve async').toHaveBeenWarned()
+  })
+
+  test('retry (fail w/ max retry attempts)', async () => {
+    let loaderCallCount = 0
+    let reject: (e: Error) => void
+
+    const Foo = defineAsyncComponent({
+      loader: () => {
+        loaderCallCount++
+        return new Promise((_resolve, _reject) => {
+          reject = _reject
+        })
+      },
+      onError(error, retry, fail, attempts) {
+        if (error.message.match(/foo/) && attempts <= 1) {
+          retry()
+        } else {
+          fail()
+        }
+      }
+    })
+
+    const vm = new Vue({
+      render: () => h(Foo)
+    }).$mount()
+
+    expect(vm.$el.nodeType).toBe(8)
+    expect(loaderCallCount).toBe(1)
+
+    // first retry
+    const err = new Error('foo')
+    reject!(err)
+    await timeout()
+    expect(loaderCallCount).toBe(2)
+    expect(vm.$el.nodeType).toBe(8)
+
+    // 2nd retry, should fail due to reaching maxRetries
+    reject!(err)
+    await timeout()
+    expect(loaderCallCount).toBe(2)
+    expect(vm.$el.nodeType).toBe(8)
+    expect('Failed to resolve async').toHaveBeenWarned()
+  })
+})
diff --git a/types/test/v3/define-async-component-test.tsx b/types/test/v3/define-async-component-test.tsx
new file mode 100644
index 00000000000..f4fbe4ba452
--- /dev/null
+++ b/types/test/v3/define-async-component-test.tsx
@@ -0,0 +1,19 @@
+import { defineAsyncComponent } from '../../v3-define-async-component'
+import { defineComponent } from '../../v3-define-component'
+
+defineAsyncComponent(() => Promise.resolve({}))
+
+// @ts-expect-error
+defineAsyncComponent({})
+
+defineAsyncComponent({
+  loader: () => Promise.resolve({}),
+  loadingComponent: defineComponent({}),
+  errorComponent: defineComponent({}),
+  delay: 123,
+  timeout: 3000,
+  onError(err, retry, fail, attempts) {
+    retry()
+    fail()
+  }
+})
diff --git a/types/v3-define-async-component.d.ts b/types/v3-define-async-component.d.ts
new file mode 100644
index 00000000000..8648ef6229f
--- /dev/null
+++ b/types/v3-define-async-component.d.ts
@@ -0,0 +1,26 @@
+import { AsyncComponent, Component } from './options'
+
+export type AsyncComponentResolveResult<T = Component> = T | { default: T } // es modules
+
+export type AsyncComponentLoader<T = any> = () => Promise<
+  AsyncComponentResolveResult<T>
+>
+
+export interface AsyncComponentOptions {
+  loader: AsyncComponentLoader
+  loadingComponent?: Component
+  errorComponent?: Component
+  delay?: number
+  timeout?: number
+  // suspensible?: boolean
+  onError?: (
+    error: Error,
+    retry: () => void,
+    fail: () => void,
+    attempts: number
+  ) => any
+}
+
+export function defineAsyncComponent(
+  source: AsyncComponentLoader | AsyncComponentOptions
+): AsyncComponent
diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
index d6e73914ff0..f2d3ab1684c 100644
--- a/types/v3-define-component.d.ts
+++ b/types/v3-define-component.d.ts
@@ -1,4 +1,3 @@
-import { Component } from '..'
 import {
   ComponentPropsOptions,
   ExtractDefaultPropTypes,

From 559600f13d312915c0a1b54ed4edd41327dbedd6 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 11:18:36 +0800
Subject: [PATCH 221/317] feat: support functional components in
 defineComponent

close #12619
---
 types/test/v3/define-component-test.tsx | 36 +++++++++++++++++++++++++
 types/v3-define-component.d.ts          | 25 +++++++++++++++++
 2 files changed, 61 insertions(+)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 9b01e3e45f4..1b0847a3795 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1079,3 +1079,39 @@ export default {
     }
   })
 }
+
+describe('functional w/ array props', () => {
+  const Foo = defineComponent({
+    functional: true,
+    props: ['foo'],
+    render(h, ctx) {
+      ctx.props.foo
+      // @ts-expect-error
+      ctx.props.bar
+    }
+  })
+
+  ;<Foo foo="hi" />
+  // @ts-expect-error
+  ;<Foo bar={123} />
+})
+
+describe('functional w/ object props', () => {
+  const Foo = defineComponent({
+    functional: true,
+    props: {
+      foo: String
+    },
+    render(h, ctx) {
+      ctx.props.foo
+      // @ts-expect-error
+      ctx.props.bar
+    }
+  })
+
+  ;<Foo foo="hi" />
+  // @ts-expect-error
+  ;<Foo foo={123} />
+  // @ts-expect-error
+  ;<Foo bar={123} />
+})
diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
index f2d3ab1684c..30f7046e403 100644
--- a/types/v3-define-component.d.ts
+++ b/types/v3-define-component.d.ts
@@ -18,6 +18,7 @@ import {
 } from './v3-component-public-instance'
 import { Data, HasDefined } from './common'
 import { EmitsOptions } from './v3-setup-context'
+import { CreateElement, RenderContext } from './umd'
 
 type DefineComponent<
   PropsOrPropOptions = {},
@@ -66,6 +67,30 @@ type DefineComponent<
     props: PropsOrPropOptions
   }
 
+/**
+ * overload 0.0: functional component with array props
+ */
+export function defineComponent<
+  PropNames extends string,
+  Props = Readonly<{ [key in PropNames]?: any }>
+>(options: {
+  functional: true
+  props?: PropNames[]
+  render?: (h: CreateElement, context: RenderContext<Props>) => any
+}): DefineComponent<Props>
+
+/**
+ * overload 0.1: functional component with object props
+ */
+export function defineComponent<
+  PropsOptions extends ComponentPropsOptions = ComponentPropsOptions,
+  Props = ExtractPropTypes<PropsOptions>
+>(options: {
+  functional: true
+  props?: PropsOptions
+  render?: (h: CreateElement, context: RenderContext<Props>) => any
+}): DefineComponent<PropsOptions>
+
 /**
  * overload 1: object format with no props
  */

From 012e10c9ca13fcbc9bf67bf2835883edcd4faace Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 11:42:36 +0800
Subject: [PATCH 222/317] fix(build): fix mjs dual package hazard

close #12626
---
 dist/vue.runtime.mjs | 75 ++++++++++++++++++++++++++++++++++++++++++++
 scripts/config.js    |  7 -----
 src/v3/index.ts      |  4 +++
 3 files changed, 79 insertions(+), 7 deletions(-)
 create mode 100644 dist/vue.runtime.mjs

diff --git a/dist/vue.runtime.mjs b/dist/vue.runtime.mjs
new file mode 100644
index 00000000000..3ac875cdab6
--- /dev/null
+++ b/dist/vue.runtime.mjs
@@ -0,0 +1,75 @@
+import Vue from './vue.runtime.common.js'
+export default Vue
+
+// this should be kept in sync with src/v3/index.ts
+export const {
+  version,
+
+  // refs
+  ref,
+  shallowRef,
+  isRef,
+  toRef,
+  toRefs,
+  unref,
+  proxyRefs,
+  customRef,
+  triggerRef,
+  computed,
+
+  // reactive
+  reactive,
+  isReactive,
+  isReadonly,
+  isShallow,
+  isProxy,
+  shallowReactive,
+  markRaw,
+  toRaw,
+  readonly,
+  shallowReadonly,
+
+  // watch
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+
+  // effectScope
+  effectScope,
+  onScopeDispose,
+  getCurrentScope,
+
+  // provide / inject
+  provide,
+  inject,
+
+  // lifecycle
+  onBeforeMount,
+  onMounted,
+  onBeforeUpdate,
+  onUpdated,
+  onUnmounted,
+  onErrorCaptured,
+  onActivated,
+  onDeactivated,
+  onServerPrefetch,
+  onRenderTracked,
+  onRenderTriggered,
+
+  // v2 only
+  set,
+  del,
+
+  // v3 compat
+  h,
+  getCurrentInstance,
+  useSlots,
+  useAttrs,
+  mergeDefaults,
+  nextTick,
+  useCssModule,
+  useCssVars,
+  defineComponent,
+  defineAsyncComponent
+} = Vue
diff --git a/scripts/config.js b/scripts/config.js
index 851dc22971c..27a318499f9 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -71,13 +71,6 @@ const builds = {
     format: 'es',
     banner
   },
-  // Runtime only ES modules build (for Node)
-  'runtime-mjs': {
-    entry: resolve('web/entry-runtime-esm.ts'),
-    dest: resolve('dist/vue.runtime.mjs'),
-    format: 'es',
-    banner
-  },
   // Runtime+compiler ES modules build (for bundlers)
   'full-esm': {
     entry: resolve('web/entry-runtime-with-compiler-esm.ts'),
diff --git a/src/v3/index.ts b/src/v3/index.ts
index ec9d59e5444..30b89c3162e 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -1,3 +1,7 @@
+/**
+ * Note: also update dist/vue.runtime.mjs when adding new exports to this file.
+ */
+
 export const version: string = '__VERSION__'
 
 export {

From 8904ca77c2d675707728e6a50decd3ef3370a428 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 14:47:03 +0800
Subject: [PATCH 223/317] fix(watch): fix watchers triggered in mounted hook

fix #12624
---
 src/v3/apiWatch.ts                     |  4 ++--
 test/unit/features/v3/apiWatch.spec.ts | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index e1d7d018bf0..52be4d32e4c 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -320,8 +320,8 @@ function doWatch(
   } else {
     // pre
     watcher.update = () => {
-      if (instance && instance === currentInstance) {
-        // pre-watcher triggered inside setup()
+      if (instance && instance === currentInstance && !instance._isMounted) {
+        // pre-watcher triggered before
         const buffer = instance._preWatchers || (instance._preWatchers = [])
         if (buffer.indexOf(watcher) < 0) buffer.push(watcher)
       } else {
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 82aba414ce0..41870ad1d51 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -1116,4 +1116,24 @@ describe('api: watch', () => {
     await nextTick()
     expect(order).toMatchObject([`mounted`, `watcher`])
   })
+
+  // #12624
+  test('pre watch triggered in mounted hook', async () => {
+    const spy = vi.fn()
+    new Vue({
+      setup() {
+        const c = ref(0)
+
+        onMounted(() => {
+          c.value++
+        })
+
+        watchEffect(() => spy(c.value))
+        return () => {}
+      }
+    }).$mount()
+    expect(spy).toHaveBeenCalledTimes(1)
+    await nextTick()
+    expect(spy).toHaveBeenCalledTimes(2)
+  })
 })

From dc8a68e8c6c4e8ed4fdde094004fca272d71ef2e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 15:03:09 +0800
Subject: [PATCH 224/317] fix: pass element creation helper to static render
 fns for functional components

fix #12625
---
 src/core/instance/render-helpers/render-static.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/instance/render-helpers/render-static.ts b/src/core/instance/render-helpers/render-static.ts
index 4c7fb0b7777..9de7ab7ec70 100644
--- a/src/core/instance/render-helpers/render-static.ts
+++ b/src/core/instance/render-helpers/render-static.ts
@@ -18,7 +18,7 @@ export function renderStatic(
   // otherwise, render a fresh tree.
   tree = cached[index] = this.$options.staticRenderFns[index].call(
     this._renderProxy,
-    null,
+    this._c,
     this // for render fns generated for functional component templates
   )
   markStatic(tree, `__static__${index}`, false)

From 1d5a411c1e3aa062aa5080432cf3f852f1583ed2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 15:15:22 +0800
Subject: [PATCH 225/317] fix(types): fix type inference when using components
 option

---
 types/options.d.ts                      |  6 +++---
 types/test/v3/define-component-test.tsx | 23 +++++++++++++++++++++++
 2 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/types/options.d.ts b/types/options.d.ts
index f1db523a04a..736da7ade30 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -20,7 +20,7 @@ export type Component<
   | typeof Vue
   | FunctionalComponentOptions<Props>
   | ComponentOptions<never, Data, Methods, Computed, Props, SetupBindings>
-  | DefineComponent<any, any, any, any, any>
+  | DefineComponent<any, any, any, any, any, any, any, any, any, any, any>
 
 type EsModule<T> = T | { default: T }
 
@@ -201,9 +201,9 @@ export interface ComponentOptions<
   directives?: { [key: string]: DirectiveFunction | DirectiveOptions }
   components?: {
     [key: string]:
-      | Component<any, any, any, any>
+      | {}
+      | Component<any, any, any, any, any>
       | AsyncComponent<any, any, any, any>
-      | DefineComponent<any, any, any, any, any, any, any, any, any, any>
   }
   transitions?: { [key: string]: object }
   filters?: { [key: string]: Function }
diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 1b0847a3795..dc71b44e466 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1115,3 +1115,26 @@ describe('functional w/ object props', () => {
   // @ts-expect-error
   ;<Foo bar={123} />
 })
+
+// #12628
+defineComponent({
+  components: {
+    App: defineComponent({})
+  },
+  data() {
+    return {}
+  },
+  provide(): any {
+    return {
+      fetchData: this.fetchData
+    }
+  },
+  created() {
+    this.fetchData()
+  },
+  methods: {
+    fetchData() {
+      throw new Error('Not implemented.')
+    }
+  }
+})

From d3add06e6e18a78a3745240632fecd076eb49d19 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 15:17:22 +0800
Subject: [PATCH 226/317] fix(types): fix this.$slots type for defineComponent

---
 types/test/v3/define-component-test.tsx | 7 +++++++
 types/v3-component-public-instance.d.ts | 4 +++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index dc71b44e466..9c9a25bea80 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1138,3 +1138,10 @@ defineComponent({
     }
   }
 })
+
+// https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223
+defineComponent({
+  render(h) {
+    return h('div', {}, [...this.$slots.default!])
+  }
+})
diff --git a/types/v3-component-public-instance.d.ts b/types/v3-component-public-instance.d.ts
index 6734c596ac1..585f66de37a 100644
--- a/types/v3-component-public-instance.d.ts
+++ b/types/v3-component-public-instance.d.ts
@@ -18,6 +18,7 @@ import {
   ComponentOptionsBase
 } from './v3-component-options'
 import { EmitFn, EmitsOptions, Slots } from './v3-setup-context'
+import { VNode } from './vnode'
 
 /**
  * Custom properties added to component instances in any way and can be accessed through `this`
@@ -162,7 +163,8 @@ export type ComponentPublicInstance<
   >
   $attrs: Data
   $refs: Data
-  $slots: Slots
+  $slots: Record<string, VNode[] | undefined>
+  $scopedSlots: Slots
   $root: ComponentPublicInstance | null
   $parent: ComponentPublicInstance | null
   $emit: EmitFn<E>

From f8de4ca9d458a03378e848b1e62d6507f7124871 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 15:39:16 +0800
Subject: [PATCH 227/317] fix(types): fix missing instance properties on
 defineComponent this

ref https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223
---
 types/test/v3/define-component-test.tsx |  5 ++
 types/v3-component-public-instance.d.ts | 66 +++++++++++++------------
 types/vue.d.ts                          | 22 +++++----
 3 files changed, 51 insertions(+), 42 deletions(-)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 9c9a25bea80..b982a805787 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1139,9 +1139,14 @@ defineComponent({
   }
 })
 
+// Missing / mismatching Vue 2 properties
 // https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223
 defineComponent({
   render(h) {
+    this.$listeners
+    this.$on('foo', () => {})
+    this.$ssrContext
+    this.$isServer
     return h('div', {}, [...this.$slots.default!])
   }
 })
diff --git a/types/v3-component-public-instance.d.ts b/types/v3-component-public-instance.d.ts
index 585f66de37a..6c2770f8cf9 100644
--- a/types/v3-component-public-instance.d.ts
+++ b/types/v3-component-public-instance.d.ts
@@ -1,15 +1,11 @@
-import { ExtractDefaultPropTypes, ExtractPropTypes } from './v3-component-props'
 import {
   DebuggerEvent,
-  nextTick,
   ShallowUnwrapRef,
-  UnwrapNestedRefs,
-  WatchOptions,
-  WatchStopHandle
+  UnwrapNestedRefs
 } from './v3-generated'
-import { Data, UnionToIntersection } from './common'
+import { UnionToIntersection } from './common'
 
-import { VueConstructor } from './vue'
+import { Vue, Vue2Instance, VueConstructor } from './vue'
 import {
   ComputedOptions,
   MethodOptions,
@@ -153,37 +149,43 @@ export type ComponentPublicInstance<
     any,
     any
   >
-> = {
-  // $: ComponentInternalInstance
-  $data: D
-  $props: Readonly<
-    MakeDefaultsOptional extends true
-      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
-      : P & PublicProps
-  >
-  $attrs: Data
-  $refs: Data
-  $slots: Record<string, VNode[] | undefined>
-  $scopedSlots: Slots
-  $root: ComponentPublicInstance | null
-  $parent: ComponentPublicInstance | null
-  $emit: EmitFn<E>
-  $el: any
-  $options: Options & MergedComponentOptionsOverride
-  $forceUpdate: () => void
-  $nextTick: typeof nextTick
-  $watch(
-    source: string | Function,
-    cb: Function,
-    options?: WatchOptions
-  ): WatchStopHandle
-} & Readonly<P> &
+> = Vue3Instance<
+  D,
+  P,
+  PublicProps,
+  E,
+  Defaults,
+  MakeDefaultsOptional,
+  Options
+> &
+  Readonly<P> &
   ShallowUnwrapRef<B> &
   UnwrapNestedRefs<D> &
   ExtractComputedReturns<C> &
   M &
   ComponentCustomProperties
 
+interface Vue3Instance<
+  D,
+  P,
+  PublicProps,
+  E,
+  Defaults,
+  MakeDefaultsOptional,
+  Options
+> extends Vue2Instance {
+  $data: D
+  readonly $props: Readonly<
+    MakeDefaultsOptional extends true
+      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
+      : P & PublicProps
+  >
+  readonly $root: ComponentPublicInstance | null
+  readonly $parent: ComponentPublicInstance | null
+  readonly $emit: EmitFn<E>
+  readonly $options: Options & MergedComponentOptionsOverride
+}
+
 type MergedHook<T = () => void> = T | T[]
 
 export type MergedComponentOptionsOverride = {
diff --git a/types/vue.d.ts b/types/vue.d.ts
index 82cad69e793..ccc7702ace6 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -3,8 +3,6 @@ import {
   AsyncComponent,
   ComponentOptions,
   FunctionalComponentOptions,
-  WatchOptionsWithHandler,
-  WatchHandler,
   DirectiveOptions,
   DirectiveFunction,
   RecordPropsDefinition,
@@ -15,6 +13,7 @@ import {
 import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
 import { PluginFunction, PluginObject } from './plugin'
 import { DefineComponent } from './v3-define-component'
+import { nextTick } from './v3-generated'
 
 export interface CreateElement {
   (
@@ -36,20 +35,25 @@ export interface CreateElement {
   ): VNode
 }
 
-export interface Vue {
-  readonly $el: Element
-  readonly $options: ComponentOptions<Vue>
+export interface Vue extends Vue2Instance {
+  readonly $data: Record<string, any>
+  readonly $props: Record<string, any>
   readonly $parent: Vue
   readonly $root: Vue
   readonly $children: Vue[]
+  readonly $options: ComponentOptions<Vue>
+  $emit(event: string, ...args: any[]): this
+}
+
+export interface Vue2Instance {
+  readonly $el: Element
   readonly $refs: {
     [key: string]: Vue | Element | (Vue | Element)[] | undefined
   }
   readonly $slots: { [key: string]: VNode[] | undefined }
   readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined }
   readonly $isServer: boolean
-  readonly $data: Record<string, any>
-  readonly $props: Record<string, any>
+
   readonly $ssrContext: any
   readonly $vnode: VNode
   readonly $attrs: Record<string, string>
@@ -73,9 +77,7 @@ export interface Vue {
   $on(event: string | string[], callback: Function): this
   $once(event: string | string[], callback: Function): this
   $off(event?: string | string[], callback?: Function): this
-  $emit(event: string, ...args: any[]): this
-  $nextTick(callback: (this: this) => void): void
-  $nextTick(): Promise<void>
+  $nextTick: typeof nextTick
   $createElement: CreateElement
 }
 

From 018d29af5fa171b2d2f4793c5d471f21bb7cd1e7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 8 Jul 2022 15:46:21 +0800
Subject: [PATCH 228/317] release: v2.7.4

---
 CHANGELOG.md                            | 23 +++++++++++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7cfac15899c..e97c0c5540c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,26 @@
+## [2.7.4](https://github.com/vuejs/vue/compare/v2.7.3...v2.7.4) (2022-07-08)
+
+
+### Bug Fixes
+
+* **build:** fix mjs dual package hazard ([012e10c](https://github.com/vuejs/vue/commit/012e10c9ca13fcbc9bf67bf2835883edcd4faace)), closes [#12626](https://github.com/vuejs/vue/issues/12626)
+* **compiler-sfc:** use safer deindent default for compatibility with previous behavior ([b70a258](https://github.com/vuejs/vue/commit/b70a2585fcd102def2bb5a3b2b589edf5311122d))
+* pass element creation helper to static render fns for functional components ([dc8a68e](https://github.com/vuejs/vue/commit/dc8a68e8c6c4e8ed4fdde094004fca272d71ef2e)), closes [#12625](https://github.com/vuejs/vue/issues/12625)
+* **ssr/reactivity:** fix array setting error at created in ssr [[#12632](https://github.com/vuejs/vue/issues/12632)] ([#12633](https://github.com/vuejs/vue/issues/12633)) ([ca7daef](https://github.com/vuejs/vue/commit/ca7daefaa15a192046d22d060220cd595a6a275f))
+* **types:** fix missing instance properties on defineComponent this ([f8de4ca](https://github.com/vuejs/vue/commit/f8de4ca9d458a03378e848b1e62d6507f7124871)), closes [/github.com/vuejs/vue/issues/12628#issuecomment-1177258223](https://github.com//github.com/vuejs/vue/issues/12628/issues/issuecomment-1177258223)
+* **types:** fix this.$slots type for defineComponent ([d3add06](https://github.com/vuejs/vue/commit/d3add06e6e18a78a3745240632fecd076eb49d19))
+* **types:** fix type inference when using components option ([1d5a411](https://github.com/vuejs/vue/commit/1d5a411c1e3aa062aa5080432cf3f852f1583ed2))
+* **types:** global component registration type compat w/ defineComponent ([26ff4bc](https://github.com/vuejs/vue/commit/26ff4bc0ed75d8bf7921523a2e546df24ec81d8f)), closes [#12622](https://github.com/vuejs/vue/issues/12622)
+* **watch:** fix watchers triggered in mounted hook ([8904ca7](https://github.com/vuejs/vue/commit/8904ca77c2d675707728e6a50decd3ef3370a428)), closes [#12624](https://github.com/vuejs/vue/issues/12624)
+
+
+### Features
+
+* defineAsyncComponent ([9d12106](https://github.com/vuejs/vue/commit/9d12106e211e0cbf33f9066606a8ff29f8cc8e8d)), closes [#12608](https://github.com/vuejs/vue/issues/12608)
+* support functional components in defineComponent ([559600f](https://github.com/vuejs/vue/commit/559600f13d312915c0a1b54ed4edd41327dbedd6)), closes [#12619](https://github.com/vuejs/vue/issues/12619)
+
+
+
 ## [2.7.3](https://github.com/vuejs/vue/compare/v2.7.2...v2.7.3) (2022-07-06)
 
 
diff --git a/package.json b/package.json
index 29c5ec3b674..10d852d4db2 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.3",
+  "version": "2.7.4",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 2cf6872ed9d..eb5a5967197 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.3",
+  "version": "2.7.4",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index e791637f9c7..a296a8bfc32 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.3",
+  "version": "2.7.4",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 5d2a22ad2d4..2f8e92fa83b 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.3",
+  "version": "2.7.4",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 04b4703de72b1c1e686a3aa81d5b5b56799dabab Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 12 Jul 2022 17:39:45 +0800
Subject: [PATCH 229/317] fix(sfc): fix sfc name inference type check

fix #12637
---
 src/core/components/keep-alive.ts                        | 9 +++++----
 src/core/global-api/extend.ts                            | 4 +++-
 src/core/util/debug.ts                                   | 3 ++-
 src/core/vdom/create-component.ts                        | 6 +++++-
 src/platforms/web/runtime/components/transition-group.ts | 3 ++-
 types/options.d.ts                                       | 2 ++
 6 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/core/components/keep-alive.ts b/src/core/components/keep-alive.ts
index c2676a35574..2bb2206be37 100644
--- a/src/core/components/keep-alive.ts
+++ b/src/core/components/keep-alive.ts
@@ -3,6 +3,7 @@ import { getFirstComponentChild } from 'core/vdom/helpers/index'
 import type VNode from 'core/vdom/vnode'
 import type { VNodeComponentOptions } from 'types/vnode'
 import type { Component } from 'types/component'
+import { getComponentName } from '../vdom/create-component'
 
 type CacheEntry = {
   name?: string
@@ -12,8 +13,8 @@ type CacheEntry = {
 
 type CacheEntryMap = Record<string, CacheEntry | null>
 
-function getComponentName(opts?: VNodeComponentOptions): string | null {
-  return opts && (opts.Ctor.options.name || opts.tag)
+function _getComponentName(opts?: VNodeComponentOptions): string | null {
+  return opts && (getComponentName(opts.Ctor.options as any) || opts.tag)
 }
 
 function matches(
@@ -81,7 +82,7 @@ export default {
       if (vnodeToCache) {
         const { tag, componentInstance, componentOptions } = vnodeToCache
         cache[keyToCache] = {
-          name: getComponentName(componentOptions),
+          name: _getComponentName(componentOptions),
           tag,
           componentInstance
         }
@@ -126,7 +127,7 @@ export default {
     const componentOptions = vnode && vnode.componentOptions
     if (componentOptions) {
       // check pattern
-      const name = getComponentName(componentOptions)
+      const name = _getComponentName(componentOptions)
       const { include, exclude } = this
       if (
         // not included
diff --git a/src/core/global-api/extend.ts b/src/core/global-api/extend.ts
index 5fed6fe90a9..800e8c2329e 100644
--- a/src/core/global-api/extend.ts
+++ b/src/core/global-api/extend.ts
@@ -3,6 +3,7 @@ import type { Component } from 'types/component'
 import type { GlobalAPI } from 'types/global-api'
 import { defineComputed, proxy } from '../instance/state'
 import { extend, mergeOptions, validateComponentName } from '../util/index'
+import { getComponentName } from '../vdom/create-component'
 
 export function initExtend(Vue: GlobalAPI) {
   /**
@@ -25,7 +26,8 @@ export function initExtend(Vue: GlobalAPI) {
       return cachedCtors[SuperId]
     }
 
-    const name = extendOptions.name || Super.options.name
+    const name =
+      getComponentName(extendOptions) || getComponentName(Super.options)
     if (__DEV__ && name) {
       validateComponentName(name)
     }
diff --git a/src/core/util/debug.ts b/src/core/util/debug.ts
index 8dbc1edb19a..891f0177c68 100644
--- a/src/core/util/debug.ts
+++ b/src/core/util/debug.ts
@@ -2,6 +2,7 @@ import config from '../config'
 import { noop, isArray, isFunction } from 'shared/util'
 import type { Component } from 'types/component'
 import { currentInstance } from 'v3/currentInstance'
+import { getComponentName } from '../vdom/create-component'
 
 export let warn: (msg: string, vm?: Component | null) => void = noop
 export let tip = noop
@@ -40,7 +41,7 @@ if (__DEV__) {
         : vm._isVue
         ? vm.$options || (vm.constructor as any).options
         : vm
-    let name = options.name || options._componentTag
+    let name = getComponentName(options)
     const file = options.__file
     if (!name && file) {
       const match = file.match(/([^/\\]+)\.vue$/)
diff --git a/src/core/vdom/create-component.ts b/src/core/vdom/create-component.ts
index 7ec6d82038b..9e48c575230 100644
--- a/src/core/vdom/create-component.ts
+++ b/src/core/vdom/create-component.ts
@@ -28,6 +28,10 @@ import type {
 import type { Component } from 'types/component'
 import type { ComponentOptions, InternalComponentOptions } from 'types/options'
 
+export function getComponentName(options: ComponentOptions) {
+  return options.name || options.__name || options._componentTag
+}
+
 // inline hooks to be invoked on component VNodes during patch
 const componentVNodeHooks = {
   init(vnode: VNodeWithData, hydrating: boolean): boolean | void {
@@ -188,7 +192,7 @@ export function createComponent(
 
   // return a placeholder vnode
   // @ts-expect-error
-  const name = Ctor.options.name || tag
+  const name = getComponentName(Ctor.options) || tag
   const vnode = new VNode(
     // @ts-expect-error
     `vue-component-${Ctor.cid}${name ? `-${name}` : ''}`,
diff --git a/src/platforms/web/runtime/components/transition-group.ts b/src/platforms/web/runtime/components/transition-group.ts
index d7a454d3e19..8588ea80561 100644
--- a/src/platforms/web/runtime/components/transition-group.ts
+++ b/src/platforms/web/runtime/components/transition-group.ts
@@ -23,6 +23,7 @@ import {
 } from 'web/runtime/transition-util'
 import VNode from 'core/vdom/vnode'
 import { VNodeWithData } from 'types/vnode'
+import { getComponentName } from 'core/vdom/create-component'
 
 const props = extend(
   {
@@ -72,7 +73,7 @@ export default {
         } else if (__DEV__) {
           const opts = c.componentOptions
           const name: string = opts
-            ? opts.Ctor.options.name || opts.tag || ''
+            ? getComponentName(opts.Ctor.options as any) || opts.tag || ''
             : c.tag
           warn(`<transition-group> children must be keyed: <${name}>`)
         }
diff --git a/types/options.d.ts b/types/options.d.ts
index 736da7ade30..e11020f4948 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -219,6 +219,8 @@ export interface ComponentOptions<
   parent?: Vue
   mixins?: (ComponentOptions<Vue> | typeof Vue)[]
   name?: string
+  // for SFC auto name inference w/ ts-loader check
+  __name?: string
   // TODO: support properly inferred 'extends'
   extends?: ComponentOptions<Vue> | typeof Vue
   delimiters?: [string, string]

From 0825d3087f9f39435838329c16adc2a7bfccd51d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 12 Jul 2022 18:19:19 +0800
Subject: [PATCH 230/317] fix: do not set currentInstance in beforeCreate

fix #12636
---
 src/core/instance/init.ts      |  2 +-
 src/core/instance/lifecycle.ts | 11 ++++++++---
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 564dbf9fbbb..876c9ddbf96 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -58,7 +58,7 @@ export function initMixin(Vue: typeof Component) {
     initLifecycle(vm)
     initEvents(vm)
     initRender(vm)
-    callHook(vm, 'beforeCreate')
+    callHook(vm, 'beforeCreate', undefined, false /* setContext */)
     initInjections(vm) // resolve injections before data/props
     initState(vm)
     initProvide(vm) // resolve provide after data/props
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 171c4e5d9a5..0d1f0732087 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -375,11 +375,16 @@ export function deactivateChildComponent(vm: Component, direct?: boolean) {
   }
 }
 
-export function callHook(vm: Component, hook: string, args?: any[]) {
+export function callHook(
+  vm: Component,
+  hook: string,
+  args?: any[],
+  setContext = true
+) {
   // #7573 disable dep collection when invoking lifecycle hooks
   pushTarget()
   const prev = currentInstance
-  setCurrentInstance(vm)
+  setContext && setCurrentInstance(vm)
   const handlers = vm.$options[hook]
   const info = `${hook} hook`
   if (handlers) {
@@ -390,6 +395,6 @@ export function callHook(vm: Component, hook: string, args?: any[]) {
   if (vm._hasHookEvent) {
     vm.$emit('hook:' + hook)
   }
-  setCurrentInstance(prev)
+  setContext && setCurrentInstance(prev)
   popTarget()
 }

From 98fb01c79c41c3b9f9134f0abb77d233ce4e5b44 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 12 Jul 2022 18:50:01 +0800
Subject: [PATCH 231/317] fix(reactivity): fix watch behavior inconsistency +
 deep ref shallow check

fix #12643
---
 src/v3/apiWatch.ts                     | 10 ++++------
 src/v3/reactivity/ref.ts               |  2 +-
 test/unit/features/v3/apiWatch.spec.ts | 17 +++++++++++++++++
 3 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 52be4d32e4c..6a0b65fa298 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -196,12 +196,10 @@ function doWatch(
     getter = () => source.value
     forceTrigger = isShallow(source)
   } else if (isReactive(source)) {
-    getter = isArray(source)
-      ? () => {
-          ;(source as any).__ob__.dep.depend()
-          return source
-        }
-      : () => source
+    getter = () => {
+      ;(source as any).__ob__.dep.depend()
+      return source
+    }
     deep = true
   } else if (isArray(source)) {
     isMultiSource = true
diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index f7026df05a1..114e6f563d8 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -68,7 +68,7 @@ function createRef(rawValue: unknown, shallow: boolean) {
   }
   const ref: any = {}
   def(ref, RefFlag, true)
-  def(ref, ReactiveFlags.IS_SHALLOW, true)
+  def(ref, ReactiveFlags.IS_SHALLOW, shallow)
   def(
     ref,
     'dep',
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 41870ad1d51..52025afa96a 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -1136,4 +1136,21 @@ describe('api: watch', () => {
     await nextTick()
     expect(spy).toHaveBeenCalledTimes(2)
   })
+
+  // #12643
+  test('should trigger watch on reactive object when new property is added via set()', () => {
+    const spy = vi.fn()
+    const obj = reactive({})
+    watch(obj, spy, { flush: 'sync' })
+    set(obj, 'foo', 1)
+    expect(spy).toHaveBeenCalled()
+  })
+
+  test('should not trigger watch when calling set() on ref value', () => {
+    const spy = vi.fn()
+    const r = ref({})
+    watch(r, spy, { flush: 'sync' })
+    set(r.value, 'foo', 1)
+    expect(spy).not.toHaveBeenCalled()
+  })
 })

From a6e74985cf2eab6f16d03a8eda3bf3fc7950127c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 12 Jul 2022 18:59:26 +0800
Subject: [PATCH 232/317] fix: detect property add/deletion on reactive objects
 from setup when used in templates

---
 src/v3/reactivity/ref.ts | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/v3/reactivity/ref.ts b/src/v3/reactivity/ref.ts
index 114e6f563d8..244acc9b0d4 100644
--- a/src/v3/reactivity/ref.ts
+++ b/src/v3/reactivity/ref.ts
@@ -119,7 +119,16 @@ export function proxyWithRefUnwrap(
   Object.defineProperty(target, key, {
     enumerable: true,
     configurable: true,
-    get: () => unref(source[key]),
+    get: () => {
+      const val = source[key]
+      if (isRef(val)) {
+        return val.value
+      } else {
+        const ob = val && val.__ob__
+        if (ob) ob.dep.depend()
+        return val
+      }
+    },
     set: value => {
       const oldValue = source[key]
       if (isRef(oldValue) && !isRef(value)) {

From 0198f9f9eea728ceb45af92eb2952fa97c9abfe1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 13 Jul 2022 09:31:39 +0800
Subject: [PATCH 233/317] chore: document TS changes in changelog [ci skip]

---
 CHANGELOG.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e97c0c5540c..da649da33f3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -117,6 +117,12 @@ In addition, the following features are explicitly **NOT** ported:
 - ❌ Reactivity transform (still experimental)
 - ❌ `expose` option is not supported for options components (but `defineExpose()` is supported in `<script setup>`).
 
+### TypeScript Changes
+
+- `defineComponent` provides improved type inference similar to that of Vue 3. Note the type of `this` inside `defineComponent()` is not interoperable with `this` from `Vue.extend()`.
+
+- Similar to Vue 3, TSX support is now built-in. If your project previously had manual JSX type shims, make sure to remove them.
+
 ## Upgrade Guide
 
 ### Vue CLI / webpack

From 498dc1d89f14504c5e14b43a77c23039163e93a3 Mon Sep 17 00:00:00 2001
From: Wang Weitao <softweitao@126.com>
Date: Wed, 13 Jul 2022 09:47:20 +0800
Subject: [PATCH 234/317] chore(changelog): fix dead link (#12646) [ci skip]

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index da649da33f3..cae19e77897 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,7 @@
 * **compiler-sfc:** use safer deindent default for compatibility with previous behavior ([b70a258](https://github.com/vuejs/vue/commit/b70a2585fcd102def2bb5a3b2b589edf5311122d))
 * pass element creation helper to static render fns for functional components ([dc8a68e](https://github.com/vuejs/vue/commit/dc8a68e8c6c4e8ed4fdde094004fca272d71ef2e)), closes [#12625](https://github.com/vuejs/vue/issues/12625)
 * **ssr/reactivity:** fix array setting error at created in ssr [[#12632](https://github.com/vuejs/vue/issues/12632)] ([#12633](https://github.com/vuejs/vue/issues/12633)) ([ca7daef](https://github.com/vuejs/vue/commit/ca7daefaa15a192046d22d060220cd595a6a275f))
-* **types:** fix missing instance properties on defineComponent this ([f8de4ca](https://github.com/vuejs/vue/commit/f8de4ca9d458a03378e848b1e62d6507f7124871)), closes [/github.com/vuejs/vue/issues/12628#issuecomment-1177258223](https://github.com//github.com/vuejs/vue/issues/12628/issues/issuecomment-1177258223)
+* **types:** fix missing instance properties on defineComponent this ([f8de4ca](https://github.com/vuejs/vue/commit/f8de4ca9d458a03378e848b1e62d6507f7124871)), closes [#12628](https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223)
 * **types:** fix this.$slots type for defineComponent ([d3add06](https://github.com/vuejs/vue/commit/d3add06e6e18a78a3745240632fecd076eb49d19))
 * **types:** fix type inference when using components option ([1d5a411](https://github.com/vuejs/vue/commit/1d5a411c1e3aa062aa5080432cf3f852f1583ed2))
 * **types:** global component registration type compat w/ defineComponent ([26ff4bc](https://github.com/vuejs/vue/commit/26ff4bc0ed75d8bf7921523a2e546df24ec81d8f)), closes [#12622](https://github.com/vuejs/vue/issues/12622)

From 08fb4a222c016c79af77ab96817d2ed9b7abbd80 Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Wed, 13 Jul 2022 02:47:38 +0100
Subject: [PATCH 235/317] fix: add missing export from `vue.runtime.mjs`
 (#12648)

---
 dist/vue.runtime.mjs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dist/vue.runtime.mjs b/dist/vue.runtime.mjs
index 3ac875cdab6..886d9f163ca 100644
--- a/dist/vue.runtime.mjs
+++ b/dist/vue.runtime.mjs
@@ -49,6 +49,7 @@ export const {
   onMounted,
   onBeforeUpdate,
   onUpdated,
+  onBeforeUnmount,
   onUnmounted,
   onErrorCaptured,
   onActivated,

From 005e52d0b6f1a5bf9679789c5c4b90afd442d86b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 13 Jul 2022 10:44:57 +0800
Subject: [PATCH 236/317] fix(types): support Vue interface augmentations in
 defineComponent

fix #12642
---
 types/test/augmentation-test.ts         |  9 +++++++-
 types/test/v3/define-component-test.tsx |  1 +
 types/v3-component-public-instance.d.ts | 30 ++++++++++++-------------
 types/vue.d.ts                          | 26 +++++++++++++--------
 4 files changed, 41 insertions(+), 25 deletions(-)

diff --git a/types/test/augmentation-test.ts b/types/test/augmentation-test.ts
index 77c616f18d7..6e165857893 100644
--- a/types/test/augmentation-test.ts
+++ b/types/test/augmentation-test.ts
@@ -1,4 +1,4 @@
-import Vue from '../index'
+import Vue, { defineComponent } from '../index'
 
 declare module '../vue' {
   // add instance property and method
@@ -44,3 +44,10 @@ vm.$instanceMethod()
 
 Vue.staticProperty
 Vue.staticMethod()
+
+defineComponent({
+  mounted() {
+    this.$instanceMethod
+    this.$instanceProperty
+  }
+})
diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index b982a805787..2d6fca73d75 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1143,6 +1143,7 @@ defineComponent({
 // https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223
 defineComponent({
   render(h) {
+    // vue 2
     this.$listeners
     this.$on('foo', () => {})
     this.$ssrContext
diff --git a/types/v3-component-public-instance.d.ts b/types/v3-component-public-instance.d.ts
index 6c2770f8cf9..a5bf670139f 100644
--- a/types/v3-component-public-instance.d.ts
+++ b/types/v3-component-public-instance.d.ts
@@ -5,7 +5,7 @@ import {
 } from './v3-generated'
 import { UnionToIntersection } from './common'
 
-import { Vue, Vue2Instance, VueConstructor } from './vue'
+import { Vue, VueConstructor } from './vue'
 import {
   ComputedOptions,
   MethodOptions,
@@ -13,8 +13,7 @@ import {
   ComponentOptionsMixin,
   ComponentOptionsBase
 } from './v3-component-options'
-import { EmitFn, EmitsOptions, Slots } from './v3-setup-context'
-import { VNode } from './vnode'
+import { EmitFn, EmitsOptions } from './v3-setup-context'
 
 /**
  * Custom properties added to component instances in any way and can be accessed through `this`
@@ -173,18 +172,19 @@ interface Vue3Instance<
   Defaults,
   MakeDefaultsOptional,
   Options
-> extends Vue2Instance {
-  $data: D
-  readonly $props: Readonly<
-    MakeDefaultsOptional extends true
-      ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
-      : P & PublicProps
-  >
-  readonly $root: ComponentPublicInstance | null
-  readonly $parent: ComponentPublicInstance | null
-  readonly $emit: EmitFn<E>
-  readonly $options: Options & MergedComponentOptionsOverride
-}
+> extends Vue<
+    D,
+    Readonly<
+      MakeDefaultsOptional extends true
+        ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
+        : P & PublicProps
+    >,
+    ComponentPublicInstance | null,
+    ComponentPublicInstance,
+    ComponentPublicInstance[],
+    Options & MergedComponentOptionsOverride,
+    EmitFn<E>
+  > {}
 
 type MergedHook<T = () => void> = T | T[]
 
diff --git a/types/vue.d.ts b/types/vue.d.ts
index ccc7702ace6..b57c5016dd3 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -35,17 +35,25 @@ export interface CreateElement {
   ): VNode
 }
 
-export interface Vue extends Vue2Instance {
-  readonly $data: Record<string, any>
-  readonly $props: Record<string, any>
-  readonly $parent: Vue
-  readonly $root: Vue
-  readonly $children: Vue[]
+export interface Vue<
+  Data = Record<string, any>,
+  Props = Record<string, any>,
+  Parent = never,
+  Root = never,
+  Children = never,
+  Options = never,
+  Emit = (event: string, ...args: any[]) => Vue
+> {
+  // properties with different types in defineComponent()
+  readonly $data: Data
+  readonly $props: Props
+  readonly $parent: Parent extends never ? Vue : Parent
+  readonly $root: Root extends never ? Vue : Root
+  readonly $children: Children extends never ? Vue[] : Children
   readonly $options: ComponentOptions<Vue>
-  $emit(event: string, ...args: any[]): this
-}
+  $emit: Emit
 
-export interface Vue2Instance {
+  // Vue 2 only or shared
   readonly $el: Element
   readonly $refs: {
     [key: string]: Vue | Element | (Vue | Element)[] | undefined

From 1a2c3c2d77ba96ef496f4c86329b7798026511ae Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 13 Jul 2022 11:01:10 +0800
Subject: [PATCH 237/317] fix(watch): fix deep watch for structures containing
 raw refs

fix #12652
---
 src/core/observer/traverse.ts          |  3 +++
 test/unit/features/v3/apiWatch.spec.ts | 14 ++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/src/core/observer/traverse.ts b/src/core/observer/traverse.ts
index 0fe671c06cf..5f4e378b194 100644
--- a/src/core/observer/traverse.ts
+++ b/src/core/observer/traverse.ts
@@ -1,6 +1,7 @@
 import { _Set as Set, isObject, isArray } from '../util/index'
 import type { SimpleSet } from '../util/index'
 import VNode from '../vdom/vnode'
+import { isRef } from '../../v3'
 
 const seenObjects = new Set()
 
@@ -35,6 +36,8 @@ function _traverse(val: any, seen: SimpleSet) {
   if (isA) {
     i = val.length
     while (i--) _traverse(val[i], seen)
+  } else if (isRef(val)) {
+    _traverse(val.value, seen)
   } else {
     keys = Object.keys(val)
     i = keys.length
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 52025afa96a..c1b301ae9e8 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -144,6 +144,20 @@ describe('api: watch', () => {
     expect(dummy).toBe(1)
   })
 
+  it('deep watch w/ raw refs', async () => {
+    const count = ref(0)
+    const src = reactive({
+      arr: [count]
+    })
+    let dummy
+    watch(src, ({ arr: [{ value }] }) => {
+      dummy = value
+    })
+    count.value++
+    await nextTick()
+    expect(dummy).toBe(1)
+  })
+
   it('watching multiple sources', async () => {
     const state = reactive({ count: 1 })
     const count = ref(1)

From cdd2df6171963096abb94600987f1706e40d2ab6 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 13 Jul 2022 11:08:37 +0800
Subject: [PATCH 238/317] release: v2.7.5

---
 CHANGELOG.md                            | 15 +++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cae19e77897..aac2405f82f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,18 @@
+## [2.7.5](https://github.com/vuejs/vue/compare/v2.7.4...v2.7.5) (2022-07-13)
+
+
+### Bug Fixes
+
+* add missing export from `vue.runtime.mjs` ([#12648](https://github.com/vuejs/vue/issues/12648)) ([08fb4a2](https://github.com/vuejs/vue/commit/08fb4a222c016c79af77ab96817d2ed9b7abbd80))
+* detect property add/deletion on reactive objects from setup when used in templates ([a6e7498](https://github.com/vuejs/vue/commit/a6e74985cf2eab6f16d03a8eda3bf3fc7950127c))
+* do not set currentInstance in beforeCreate ([0825d30](https://github.com/vuejs/vue/commit/0825d3087f9f39435838329c16adc2a7bfccd51d)), closes [#12636](https://github.com/vuejs/vue/issues/12636)
+* **reactivity:** fix watch behavior inconsistency + deep ref shallow check ([98fb01c](https://github.com/vuejs/vue/commit/98fb01c79c41c3b9f9134f0abb77d233ce4e5b44)), closes [#12643](https://github.com/vuejs/vue/issues/12643)
+* **sfc:** fix sfc name inference type check ([04b4703](https://github.com/vuejs/vue/commit/04b4703de72b1c1e686a3aa81d5b5b56799dabab)), closes [#12637](https://github.com/vuejs/vue/issues/12637)
+* **types:** support Vue interface augmentations in defineComponent ([005e52d](https://github.com/vuejs/vue/commit/005e52d0b6f1a5bf9679789c5c4b90afd442d86b)), closes [#12642](https://github.com/vuejs/vue/issues/12642)
+* **watch:** fix deep watch for structures containing raw refs ([1a2c3c2](https://github.com/vuejs/vue/commit/1a2c3c2d77ba96ef496f4c86329b7798026511ae)), closes [#12652](https://github.com/vuejs/vue/issues/12652)
+
+
+
 ## [2.7.4](https://github.com/vuejs/vue/compare/v2.7.3...v2.7.4) (2022-07-08)
 
 
diff --git a/package.json b/package.json
index 10d852d4db2..803ecd417a9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index eb5a5967197..27b334025ea 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index a296a8bfc32..fabed381fc8 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 2f8e92fa83b..9b4704910ea 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.4",
+  "version": "2.7.5",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 52a59790a5b6e16c9f8cc737fcd784413dda282d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 15 Jul 2022 16:52:27 +0800
Subject: [PATCH 239/317] fix(types): fix $children and $root instance types

fix #12655
---
 types/test/v3/define-component-test.tsx |  1 +
 types/test/vue-test.ts                  |  1 +
 types/vue.d.ts                          | 10 ++++++----
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 2d6fca73d75..fde804c400b 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1148,6 +1148,7 @@ defineComponent({
     this.$on('foo', () => {})
     this.$ssrContext
     this.$isServer
+    this.$children[0].$root.$children
     return h('div', {}, [...this.$slots.default!])
   }
 })
diff --git a/types/test/vue-test.ts b/types/test/vue-test.ts
index 45e7bc7a719..8489f3ae8ed 100644
--- a/types/test/vue-test.ts
+++ b/types/test/vue-test.ts
@@ -16,6 +16,7 @@ class Test extends Vue {
     this.$isServer
     this.$ssrContext
     this.$vnode
+    this.$root.$children[0].$children[0]
   }
 
   // test property reification
diff --git a/types/vue.d.ts b/types/vue.d.ts
index b57c5016dd3..a86e2eebf3f 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -35,6 +35,8 @@ export interface CreateElement {
   ): VNode
 }
 
+type NeverFallback<T, D> = [T] extends [never] ? D : T
+
 export interface Vue<
   Data = Record<string, any>,
   Props = Record<string, any>,
@@ -47,10 +49,10 @@ export interface Vue<
   // properties with different types in defineComponent()
   readonly $data: Data
   readonly $props: Props
-  readonly $parent: Parent extends never ? Vue : Parent
-  readonly $root: Root extends never ? Vue : Root
-  readonly $children: Children extends never ? Vue[] : Children
-  readonly $options: ComponentOptions<Vue>
+  readonly $parent: NeverFallback<Parent, Vue>
+  readonly $root: NeverFallback<Root, Vue>
+  readonly $children: NeverFallback<Children, Vue[]>
+  readonly $options: NeverFallback<Options, ComponentOptions<Vue>>
   $emit: Emit
 
   // Vue 2 only or shared

From e0a9546ef32fa4bbfc4bede3002b2d6a5be8cf72 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 15 Jul 2022 16:58:01 +0800
Subject: [PATCH 240/317] fix(types): fix missing expose() type on setup
 context

fix #12660
---
 types/test/v3/setup-test.ts | 3 +++
 types/v3-setup-context.d.ts | 1 +
 2 files changed, 4 insertions(+)

diff --git a/types/test/v3/setup-test.ts b/types/test/v3/setup-test.ts
index 4fdec92d92d..328941fd0b4 100644
--- a/types/test/v3/setup-test.ts
+++ b/types/test/v3/setup-test.ts
@@ -28,6 +28,9 @@ Vue.extend({
     }
     ctx.emit('foo')
     ctx.slots.default && ctx.slots.default()
+    ctx.expose({
+      a: 123
+    })
   }
 })
 
diff --git a/types/v3-setup-context.d.ts b/types/v3-setup-context.d.ts
index 8a0a7822e35..7e11fe095a4 100644
--- a/types/v3-setup-context.d.ts
+++ b/types/v3-setup-context.d.ts
@@ -33,4 +33,5 @@ export interface SetupContext<E extends EmitsOptions = {}> {
   attrs: Data
   slots: Slots
   emit: EmitFn<E>
+  expose(exposed?: Record<string, any>): void
 }

From fffbb9e856de5e4b3053a6b4d01d1404bfb6f85e Mon Sep 17 00:00:00 2001
From: Nikhil Verma <nikhilgotmail@gmail.com>
Date: Fri, 15 Jul 2022 14:35:04 +0530
Subject: [PATCH 241/317] fix(types): $refs can also contain
 ComponentPublicInstance (#12659)

---
 types/vue.d.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/types/vue.d.ts b/types/vue.d.ts
index a86e2eebf3f..ed5b1817453 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -14,6 +14,7 @@ import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
 import { PluginFunction, PluginObject } from './plugin'
 import { DefineComponent } from './v3-define-component'
 import { nextTick } from './v3-generated'
+import { ComponentPublicInstance } from 'v3-component-public-instance'
 
 export interface CreateElement {
   (
@@ -58,7 +59,12 @@ export interface Vue<
   // Vue 2 only or shared
   readonly $el: Element
   readonly $refs: {
-    [key: string]: Vue | Element | (Vue | Element)[] | undefined
+    [key: string]:
+      | Vue
+      | Element
+      | ComponentPublicInstance
+      | (Vue | Element | ComponentPublicInstance)[]
+      | undefined
   }
   readonly $slots: { [key: string]: VNode[] | undefined }
   readonly $scopedSlots: { [key: string]: NormalizedScopedSlot | undefined }

From 9ed684785f868db5b154c4a09642b2b7d33dd6f3 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 15 Jul 2022 17:07:19 +0800
Subject: [PATCH 242/317] test: add test for type casting $refs to
 defineComponent instance type

---
 types/test/v3/define-component-test.tsx | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index fde804c400b..42d0f32eb0d 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1139,6 +1139,14 @@ defineComponent({
   }
 })
 
+const X = defineComponent({
+  methods: {
+    foo() {
+      return 123
+    }
+  }
+})
+
 // Missing / mismatching Vue 2 properties
 // https://github.com/vuejs/vue/issues/12628#issuecomment-1177258223
 defineComponent({
@@ -1149,6 +1157,11 @@ defineComponent({
     this.$ssrContext
     this.$isServer
     this.$children[0].$root.$children
+
+    // type casting refs
+    const foo = this.$refs.foo as InstanceType<typeof X>
+    foo.foo().toExponential()
+
     return h('div', {}, [...this.$slots.default!])
   }
 })

From 7d4a7722e3a8bc52a0a9b9660b75efa2ff479f39 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 15 Jul 2022 17:12:28 +0800
Subject: [PATCH 243/317] release: v2.7.6

---
 CHANGELOG.md                            | 11 +++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index aac2405f82f..4b6769a61ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+## [2.7.6](https://github.com/vuejs/vue/compare/v2.7.5...v2.7.6) (2022-07-15)
+
+
+### Bug Fixes
+
+* **types:** $refs can also contain ComponentPublicInstance ([#12659](https://github.com/vuejs/vue/issues/12659)) ([fffbb9e](https://github.com/vuejs/vue/commit/fffbb9e856de5e4b3053a6b4d01d1404bfb6f85e))
+* **types:** fix $children and $root instance types ([52a5979](https://github.com/vuejs/vue/commit/52a59790a5b6e16c9f8cc737fcd784413dda282d)), closes [#12655](https://github.com/vuejs/vue/issues/12655)
+* **types:** fix missing expose() type on setup context ([e0a9546](https://github.com/vuejs/vue/commit/e0a9546ef32fa4bbfc4bede3002b2d6a5be8cf72)), closes [#12660](https://github.com/vuejs/vue/issues/12660)
+
+
+
 ## [2.7.5](https://github.com/vuejs/vue/compare/v2.7.4...v2.7.5) (2022-07-13)
 
 
diff --git a/package.json b/package.json
index 803ecd417a9..4e00644d413 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.5",
+  "version": "2.7.6",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 27b334025ea..7340ab5fe70 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.5",
+  "version": "2.7.6",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index fabed381fc8..a15d306d3c9 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.5",
+  "version": "2.7.6",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 9b4704910ea..691c6ad0aed 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.5",
+  "version": "2.7.6",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 46ec64869479393f95b6abda7a4adecf19867d06 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Sat, 16 Jul 2022 05:21:07 -0700
Subject: [PATCH 244/317] fix(types): vue.d.ts should use relative import to
 v3-component-public-instance (#12668)

fix #12666
---
 types/tsconfig.json | 1 -
 types/vue.d.ts      | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/types/tsconfig.json b/types/tsconfig.json
index 07fef18f7ff..36c5afee057 100644
--- a/types/tsconfig.json
+++ b/types/tsconfig.json
@@ -9,7 +9,6 @@
     "jsx": "preserve",
     "strict": true,
     "noEmit": true,
-    "baseUrl": ".",
     "paths": {
       "vue": ["../index.d.ts"]
     }
diff --git a/types/vue.d.ts b/types/vue.d.ts
index ed5b1817453..aaf471dd2c1 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -14,7 +14,7 @@ import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
 import { PluginFunction, PluginObject } from './plugin'
 import { DefineComponent } from './v3-define-component'
 import { nextTick } from './v3-generated'
-import { ComponentPublicInstance } from 'v3-component-public-instance'
+import { ComponentPublicInstance } from './v3-component-public-instance'
 
 export interface CreateElement {
   (

From 25ffdb62d22fe8688aca144d945671d5c82a8887 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 16 Jul 2022 20:46:39 +0800
Subject: [PATCH 245/317] fix(watch): fix queueing multiple post watchers

fix #12664
---
 src/core/observer/scheduler.ts         | 11 ++++++++-
 src/core/observer/watcher.ts           |  2 ++
 src/v3/apiWatch.ts                     |  2 +-
 test/unit/features/v3/apiWatch.spec.ts | 33 ++++++++++++++++++++++++++
 4 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index 24e711c36fd..b019d9f6873 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -59,6 +59,15 @@ if (inBrowser && !isIE) {
   }
 }
 
+const sortCompareFn = (a: Watcher, b: Watcher): number => {
+  if (a.post) {
+    if (!b.post) return 1
+  } else if (b.post) {
+    return -1
+  }
+  return a.id - b.id
+}
+
 /**
  * Flush both queues and run the watchers.
  */
@@ -75,7 +84,7 @@ function flushSchedulerQueue() {
   //    user watchers are created before the render watcher)
   // 3. If a component is destroyed during a parent component's watcher run,
   //    its watchers can be skipped.
-  queue.sort((a, b) => a.id - b.id)
+  queue.sort(sortCompareFn)
 
   // do not cache length because more watchers might be pushed
   // as we run existing watchers
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index f07b0fd379c..b1f491acb33 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -58,6 +58,7 @@ export default class Watcher implements DepTarget {
   noRecurse?: boolean
   getter: Function
   value: any
+  post: boolean
 
   // dev only
   onTrack?: ((event: DebuggerEvent) => void) | undefined
@@ -93,6 +94,7 @@ export default class Watcher implements DepTarget {
     this.cb = cb
     this.id = ++uid // uid for batching
     this.active = true
+    this.post = false
     this.dirty = this.lazy // for lazy watchers
     this.deps = []
     this.newDeps = []
diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 6a0b65fa298..7fe5eeb9dcc 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -313,7 +313,7 @@ function doWatch(
   if (flush === 'sync') {
     watcher.update = watcher.run
   } else if (flush === 'post') {
-    watcher.id = Infinity
+    watcher.post = true
     watcher.update = () => queueWatcher(watcher)
   } else {
     // pre
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index c1b301ae9e8..0206e8df3bf 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -1167,4 +1167,37 @@ describe('api: watch', () => {
     set(r.value, 'foo', 1)
     expect(spy).not.toHaveBeenCalled()
   })
+
+  // #12664
+  it('queueing multiple flush: post watchers', async () => {
+    const parentSpy = vi.fn()
+    const childSpy = vi.fn()
+
+    const Child = {
+      setup() {
+        const el = ref()
+        watch(el, childSpy, { flush: 'post' })
+        return { el }
+      },
+      template: `<div><span ref="el">hello child</span></div>`
+    }
+    const App = {
+      components: { Child },
+      setup() {
+        const el = ref()
+        watch(el, parentSpy, { flush: 'post' })
+        return { el }
+      },
+      template: `<div><Child /><span ref="el">hello app1</span></div>`
+    }
+
+    const container = document.createElement('div')
+    const root = document.createElement('div')
+    container.appendChild(root)
+    new Vue(App).$mount(root)
+
+    await nextTick()
+    expect(parentSpy).toHaveBeenCalledTimes(1)
+    expect(childSpy).toHaveBeenCalledTimes(1)
+  })
 })

From ea5d0f3fbfd983cb0275457cbcef344f926381ea Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 16 Jul 2022 21:33:48 +0800
Subject: [PATCH 246/317] fix(inject): fix edge case of provided with
 async-mutated getters

fix #12667
---
 src/core/instance/inject.ts               | 15 ++++++---
 src/v3/apiInject.ts                       | 29 ++++++++++--------
 test/unit/features/options/inject.spec.ts | 37 ++++++++++++++++++++++-
 3 files changed, 63 insertions(+), 18 deletions(-)

diff --git a/src/core/instance/inject.ts b/src/core/instance/inject.ts
index 4c18909de8f..d5fa2b5ba71 100644
--- a/src/core/instance/inject.ts
+++ b/src/core/instance/inject.ts
@@ -1,8 +1,7 @@
 import { warn, hasSymbol, isFunction, isObject } from '../util/index'
 import { defineReactive, toggleObserving } from '../observer/index'
 import type { Component } from 'types/component'
-import { provide } from 'v3/apiInject'
-import { setCurrentInstance } from '../../v3/currentInstance'
+import { resolveProvided } from 'v3/apiInject'
 
 export function initProvide(vm: Component) {
   const provideOption = vm.$options.provide
@@ -13,12 +12,18 @@ export function initProvide(vm: Component) {
     if (!isObject(provided)) {
       return
     }
+    const source = resolveProvided(vm)
+    // IE9 doesn't support Object.getOwnPropertyDescriptors so we have to
+    // iterate the keys ourselves.
     const keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided)
-    setCurrentInstance(vm)
     for (let i = 0; i < keys.length; i++) {
-      provide(keys[i], provided[keys[i]])
+      const key = keys[i]
+      Object.defineProperty(
+        source,
+        key,
+        Object.getOwnPropertyDescriptor(provided, key)!
+      )
     }
-    setCurrentInstance()
   }
 }
 
diff --git a/src/v3/apiInject.ts b/src/v3/apiInject.ts
index 3644c56ab46..76928268b13 100644
--- a/src/v3/apiInject.ts
+++ b/src/v3/apiInject.ts
@@ -1,5 +1,6 @@
 import { isFunction, warn } from 'core/util'
 import { currentInstance } from './currentInstance'
+import type { Component } from 'types/component'
 
 export interface InjectionKey<T> extends Symbol {}
 
@@ -9,19 +10,23 @@ export function provide<T>(key: InjectionKey<T> | string | number, value: T) {
       warn(`provide() can only be used inside setup().`)
     }
   } else {
-    let provides = currentInstance._provided
-    // by default an instance inherits its parent's provides object
-    // but when it needs to provide values of its own, it creates its
-    // own provides object using parent provides object as prototype.
-    // this way in `inject` we can simply look up injections from direct
-    // parent and let the prototype chain do the work.
-    const parentProvides =
-      currentInstance.$parent && currentInstance.$parent._provided
-    if (parentProvides === provides) {
-      provides = currentInstance._provided = Object.create(parentProvides)
-    }
     // TS doesn't allow symbol as index type
-    provides[key as string] = value
+    resolveProvided(currentInstance)[key as string] = value
+  }
+}
+
+export function resolveProvided(vm: Component): Record<string, any> {
+  // by default an instance inherits its parent's provides object
+  // but when it needs to provide values of its own, it creates its
+  // own provides object using parent provides object as prototype.
+  // this way in `inject` we can simply look up injections from direct
+  // parent and let the prototype chain do the work.
+  const existing = vm._provided
+  const parentProvides = vm.$parent && vm.$parent._provided
+  if (parentProvides === existing) {
+    return (vm._provided = Object.create(parentProvides))
+  } else {
+    return existing
   }
 }
 
diff --git a/test/unit/features/options/inject.spec.ts b/test/unit/features/options/inject.spec.ts
index 399061f9768..983367b6126 100644
--- a/test/unit/features/options/inject.spec.ts
+++ b/test/unit/features/options/inject.spec.ts
@@ -1,6 +1,6 @@
 import Vue from 'vue'
 import { Observer } from 'core/observer/index'
-import { isNative, isObject, hasOwn } from 'core/util/index'
+import { isNative, isObject, hasOwn, nextTick } from 'core/util/index'
 import testObjectOption from '../../../helpers/test-object-option'
 
 describe('Options provide/inject', () => {
@@ -677,4 +677,39 @@ describe('Options provide/inject', () => {
     })
     expect(`Injection "constructor" not found`).toHaveBeenWarned()
   })
+
+  // #12667
+  test('provide with getters', async () => {
+    const spy = vi.fn()
+    const Child = {
+      render() {},
+      inject: ['foo'],
+      mounted() {
+        spy(this.foo)
+      }
+    }
+
+    let val = 1
+    const vm = new Vue({
+      components: { Child },
+      template: `<Child v-if="ok" />`,
+      data() {
+        return {
+          ok: false
+        }
+      },
+      provide() {
+        return {
+          get foo() {
+            return val
+          }
+        }
+      }
+    }).$mount()
+
+    val = 2
+    vm.ok = true
+    await nextTick()
+    expect(spy).toHaveBeenCalledWith(2)
+  })
 })

From 67760f8d30778f58afeada3589d4ac4493329ad5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 16 Jul 2022 21:45:03 +0800
Subject: [PATCH 247/317] fix(setup): ensure setup context slots can be
 accessed immediately

fix #12672
---
 src/core/instance/render.ts            | 10 ++++++++--
 test/unit/features/v3/apiSetup.spec.ts |  3 +++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/core/instance/render.ts b/src/core/instance/render.ts
index e7ad14f0d73..b71125b275d 100644
--- a/src/core/instance/render.ts
+++ b/src/core/instance/render.ts
@@ -25,7 +25,13 @@ export function initRender(vm: Component) {
   const parentVnode = (vm.$vnode = options._parentVnode!) // the placeholder node in parent tree
   const renderContext = parentVnode && (parentVnode.context as Component)
   vm.$slots = resolveSlots(options._renderChildren, renderContext)
-  vm.$scopedSlots = emptyObject
+  vm.$scopedSlots = parentVnode
+    ? normalizeScopedSlots(
+        vm.$parent!,
+        parentVnode.data!.scopedSlots,
+        vm.$slots
+      )
+    : emptyObject
   // bind the createElement fn to this instance
   // so that we get proper render context inside it.
   // args order: tag, data, children, normalizationType, alwaysNormalize
@@ -98,7 +104,7 @@ export function renderMixin(Vue: typeof Component) {
     const vm: Component = this
     const { render, _parentVnode } = vm.$options
 
-    if (_parentVnode) {
+    if (_parentVnode && vm._isMounted) {
       vm.$scopedSlots = normalizeScopedSlots(
         vm.$parent!,
         _parentVnode.data!.scopedSlots,
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 118686366e8..4ae9e739e91 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -165,6 +165,9 @@ describe('api: setup context', () => {
 
     const Child = {
       setup(_props: any, { slots }: any) {
+        // #12672 behavior consistency with Vue 3: should be able to access
+        // slots directly in setup()
+        expect(slots.foo()).toBeTruthy()
         return () => h('div', [...slots.foo(), ...slots.bar()])
       }
     }

From e8d3a7d7a17f9e66d592fb1ddc4a603af9958d36 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 16 Jul 2022 22:03:44 +0800
Subject: [PATCH 248/317] fix(codegen): script setup should not attempt to
 resolve native elements as component

fix #12674
---
 src/compiler/codegen/index.ts              |  5 +++--
 test/unit/modules/compiler/codegen.spec.ts | 16 ++++++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 823154e28a0..5992859eba1 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -95,14 +95,15 @@ export function genElement(el: ASTElement, state: CodegenState): string {
       code = genComponent(el.component, el, state)
     } else {
       let data
-      if (!el.plain || (el.pre && state.maybeComponent(el))) {
+      const maybeComponent = state.maybeComponent(el)
+      if (!el.plain || (el.pre && maybeComponent)) {
         data = genData(el, state)
       }
 
       let tag: string | undefined
       // check if this is a component in <script setup>
       const bindings = state.options.bindings
-      if (bindings && bindings.__isScriptSetup !== false) {
+      if (maybeComponent && bindings && bindings.__isScriptSetup !== false) {
         tag =
           checkBindingType(bindings, el.tag) ||
           checkBindingType(bindings, camelize(el.tag)) ||
diff --git a/test/unit/modules/compiler/codegen.spec.ts b/test/unit/modules/compiler/codegen.spec.ts
index 5e584c8fb90..aab2505f254 100644
--- a/test/unit/modules/compiler/codegen.spec.ts
+++ b/test/unit/modules/compiler/codegen.spec.ts
@@ -724,4 +724,20 @@ describe('codegen', () => {
       '"with(this){return _c(\'div\',[_c(Foo),_c(FooBar)],1)}"'
     )
   })
+
+  // #12674
+  it('component with bindings: should not resolve native elements', () => {
+    const ast = parse(`<div><form>{{ n }}</form></div>`, baseOptions)
+    optimize(ast, baseOptions)
+    const res = generate(ast, {
+      ...baseOptions,
+      bindings: {
+        form: BindingTypes.SETUP_CONST
+      }
+    })
+    expect(res.render).toMatch(`_c('form'`)
+    expect(res.render).toMatchInlineSnapshot(
+      "\"with(this){return _c('div',[_c('form',[_v(_s(n))])])}\""
+    )
+  })
 })

From fc16281cf5bd1506e8cfe62eee1ef02dac82bad5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 16 Jul 2022 22:45:31 +0800
Subject: [PATCH 249/317] release: v2.7.7

---
 CHANGELOG.md                            | 13 +++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4b6769a61ca..cf52be06131 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,16 @@
+## [2.7.7](https://github.com/vuejs/vue/compare/v2.7.6...v2.7.7) (2022-07-16)
+
+
+### Bug Fixes
+
+* **codegen:** script setup should not attempt to resolve native elements as component ([e8d3a7d](https://github.com/vuejs/vue/commit/e8d3a7d7a17f9e66d592fb1ddc4a603af9958d36)), closes [#12674](https://github.com/vuejs/vue/issues/12674)
+* **inject:** fix edge case of provided with async-mutated getters ([ea5d0f3](https://github.com/vuejs/vue/commit/ea5d0f3fbfd983cb0275457cbcef344f926381ea)), closes [#12667](https://github.com/vuejs/vue/issues/12667)
+* **setup:** ensure setup context slots can be accessed immediately ([67760f8](https://github.com/vuejs/vue/commit/67760f8d30778f58afeada3589d4ac4493329ad5)), closes [#12672](https://github.com/vuejs/vue/issues/12672)
+* **types:** vue.d.ts should use relative import to v3-component-public-instance ([#12668](https://github.com/vuejs/vue/issues/12668)) ([46ec648](https://github.com/vuejs/vue/commit/46ec64869479393f95b6abda7a4adecf19867d06)), closes [#12666](https://github.com/vuejs/vue/issues/12666)
+* **watch:** fix queueing multiple post watchers ([25ffdb6](https://github.com/vuejs/vue/commit/25ffdb62d22fe8688aca144d945671d5c82a8887)), closes [#12664](https://github.com/vuejs/vue/issues/12664)
+
+
+
 ## [2.7.6](https://github.com/vuejs/vue/compare/v2.7.5...v2.7.6) (2022-07-15)
 
 
diff --git a/package.json b/package.json
index 4e00644d413..fac4eec9ac3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.6",
+  "version": "2.7.7",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 7340ab5fe70..b1f34a6b089 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.6",
+  "version": "2.7.7",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index a15d306d3c9..ed7716f0d5c 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.6",
+  "version": "2.7.7",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 691c6ad0aed..8d9aa5577ac 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.6",
+  "version": "2.7.7",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 135d07442acd04f64fc470581a4e8b6feaba1f81 Mon Sep 17 00:00:00 2001
From: troy351 <914053923@qq.com>
Date: Wed, 20 Jul 2022 11:16:01 +0800
Subject: [PATCH 250/317] chore(sfc): remove useless
 vue-template-es2015-compiler (#12677)

---
 packages/compiler-sfc/package.json            | 3 +--
 packages/compiler-sfc/src/compileTemplate.ts  | 3 +--
 pnpm-lock.yaml                                | 6 ------
 test/unit/features/options/functional.spec.ts | 1 -
 4 files changed, 2 insertions(+), 11 deletions(-)

diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index b1f34a6b089..d2b01fc5dc9 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -29,7 +29,6 @@
     "postcss-selector-parser": "^6.0.10",
     "pug": "^3.0.2",
     "sass": "^1.52.3",
-    "stylus": "^0.58.1",
-    "vue-template-es2015-compiler": "^1.9.1"
+    "stylus": "^0.58.1"
   }
 }
diff --git a/packages/compiler-sfc/src/compileTemplate.ts b/packages/compiler-sfc/src/compileTemplate.ts
index fb5fa9ae180..ebc6f6c6f2a 100644
--- a/packages/compiler-sfc/src/compileTemplate.ts
+++ b/packages/compiler-sfc/src/compileTemplate.ts
@@ -144,8 +144,7 @@ function actuallyCompile(
       errors
     }
   } else {
-    // transpile code with vue-template-es2015-compiler, which is a forked
-    // version of Buble that applies ES2015 transforms + stripping `with` usage
+    // stripping `with` usage
     let code =
       `var __render__ = ${prefixIdentifiers(
         `function render(${isFunctional ? `_c,_vm` : ``}){${render}\n}`,
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 4041a8b1a18..c7a00de93b5 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -115,7 +115,6 @@ importers:
       sass: ^1.52.3
       source-map: ^0.6.1
       stylus: ^0.58.1
-      vue-template-es2015-compiler: ^1.9.1
     dependencies:
       '@babel/parser': 7.18.4
       postcss: 8.4.14
@@ -138,7 +137,6 @@ importers:
       pug: 3.0.2
       sass: 1.52.3
       stylus: 0.58.1
-      vue-template-es2015-compiler: 1.9.1
 
   packages/server-renderer:
     specifiers:
@@ -6222,10 +6220,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /vue-template-es2015-compiler/1.9.1:
-    resolution: {integrity: sha512-4gDntzrifFnCEvyoO8PqyJDmguXgVPxKiIxrBKjIowvL9l+N66196+72XVYR8BBf1Uv1Fgt3bGevJ+sEmxfZzw==}
-    dev: true
-
   /w3c-hr-time/1.0.2:
     resolution: {integrity: sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==}
     dependencies:
diff --git a/test/unit/features/options/functional.spec.ts b/test/unit/features/options/functional.spec.ts
index bd1d300561e..c26930b203c 100644
--- a/test/unit/features/options/functional.spec.ts
+++ b/test/unit/features/options/functional.spec.ts
@@ -269,7 +269,6 @@ describe('Options functional', () => {
   })
 
   it('should work with render fns compiled from template', done => {
-    // code generated via vue-template-es2015-compiler
     const render = function (_h, _vm) {
       const _c = _vm._c
       return _c(

From adf3ac8adcf204dcc34b851da6ab4d914bd11cf9 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 20 Jul 2022 12:13:04 +0800
Subject: [PATCH 251/317] feat(setup): support listeners on setup context +
 `useListeners()` helper

These are added because Vue 2 does not include listeners in
`context.attrs` so there is no way to access the equivalent of
`this.$listeners` in `setup()`.
---
 src/core/instance/lifecycle.ts         | 28 +++++++++-----
 src/types/component.ts                 |  1 +
 src/v3/apiSetup.ts                     | 52 ++++++++++++++++----------
 src/v3/index.ts                        |  2 +-
 test/unit/features/v3/apiSetup.spec.ts | 23 ++++++++++++
 types/v3-manual-apis.d.ts              |  2 -
 types/v3-setup-context.d.ts            |  4 ++
 7 files changed, 80 insertions(+), 32 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index 0d1f0732087..df70b7113fd 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -18,7 +18,7 @@ import {
   invokeWithErrorHandling
 } from '../util/index'
 import { currentInstance, setCurrentInstance } from 'v3/currentInstance'
-import { syncSetupAttrs } from 'v3/apiSetup'
+import { syncSetupProxy } from 'v3/apiSetup'
 
 export let activeInstance: any = null
 export let isUpdatingChildComponent: boolean = false
@@ -288,11 +288,12 @@ export function updateChildComponent(
     // force update if attrs are accessed and has changed since it may be
     // passed to a child component.
     if (
-      syncSetupAttrs(
+      syncSetupProxy(
         vm._attrsProxy,
         attrs,
         (prevVNode.data && prevVNode.data.attrs) || emptyObject,
-        vm
+        vm,
+        '$attrs'
       )
     ) {
       needsForceUpdate = true
@@ -300,7 +301,20 @@ export function updateChildComponent(
   }
   vm.$attrs = attrs
 
-  vm.$listeners = listeners || emptyObject
+  // update listeners
+  listeners = listeners || emptyObject
+  const prevListeners = vm.$options._parentListeners
+  if (vm._listenersProxy) {
+    syncSetupProxy(
+      vm._listenersProxy,
+      listeners,
+      prevListeners || emptyObject,
+      vm,
+      '$listeners'
+    )
+  }
+  vm.$listeners = vm.$options._parentListeners = listeners
+  updateComponentListeners(vm, listeners, prevListeners)
 
   // update props
   if (propsData && vm.$options.props) {
@@ -317,12 +331,6 @@ export function updateChildComponent(
     vm.$options.propsData = propsData
   }
 
-  // update listeners
-  listeners = listeners || emptyObject
-  const oldListeners = vm.$options._parentListeners
-  vm.$options._parentListeners = listeners
-  updateComponentListeners(vm, listeners, oldListeners)
-
   // resolve slots + force update if has children
   if (needsForceUpdate) {
     vm.$slots = resolveSlots(renderChildren, parentVnode.context)
diff --git a/src/types/component.ts b/src/types/component.ts
index 23a4adb86e3..5d16fa15f7a 100644
--- a/src/types/component.ts
+++ b/src/types/component.ts
@@ -111,6 +111,7 @@ export declare class Component {
   _setupProxy?: Record<string, any>
   _setupContext?: SetupContext
   _attrsProxy?: Record<string, any>
+  _listenersProxy?: Record<string, Function | Function[]>
   _slotsProxy?: Record<string, () => VNode[]>
   _preWatchers?: Watcher[]
 
diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index e0573586413..ea8448072c2 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -19,6 +19,7 @@ import { proxyWithRefUnwrap } from './reactivity/ref'
  */
 export interface SetupContext {
   attrs: Record<string, any>
+  listeners: Record<string, Function | Function[]>
   slots: Record<string, () => VNode[]>
   emit: (event: string, ...args: any[]) => any
   expose: (exposed: Record<string, any>) => void
@@ -87,7 +88,19 @@ function createSetupContext(vm: Component): SetupContext {
   let exposeCalled = false
   return {
     get attrs() {
-      return initAttrsProxy(vm)
+      if (!vm._attrsProxy) {
+        const proxy = (vm._attrsProxy = {})
+        def(proxy, '_v_attr_proxy', true)
+        syncSetupProxy(proxy, vm.$attrs, emptyObject, vm, '$attrs')
+      }
+      return vm._attrsProxy
+    },
+    get listeners() {
+      if (!vm._listenersProxy) {
+        const proxy = (vm._listenersProxy = {})
+        syncSetupProxy(proxy, vm.$listeners, emptyObject, vm, '$listeners')
+      }
+      return vm._listenersProxy
     },
     get slots() {
       return initSlotsProxy(vm)
@@ -109,26 +122,18 @@ function createSetupContext(vm: Component): SetupContext {
   }
 }
 
-function initAttrsProxy(vm: Component) {
-  if (!vm._attrsProxy) {
-    const proxy = (vm._attrsProxy = {})
-    def(proxy, '_v_attr_proxy', true)
-    syncSetupAttrs(proxy, vm.$attrs, emptyObject, vm)
-  }
-  return vm._attrsProxy
-}
-
-export function syncSetupAttrs(
+export function syncSetupProxy(
   to: any,
   from: any,
   prev: any,
-  instance: Component
+  instance: Component,
+  type: string
 ) {
   let changed = false
   for (const key in from) {
     if (!(key in to)) {
       changed = true
-      defineProxyAttr(to, key, instance)
+      defineProxyAttr(to, key, instance, type)
     } else if (from[key] !== prev[key]) {
       changed = true
     }
@@ -142,12 +147,17 @@ export function syncSetupAttrs(
   return changed
 }
 
-function defineProxyAttr(proxy: any, key: string, instance: Component) {
+function defineProxyAttr(
+  proxy: any,
+  key: string,
+  instance: Component,
+  type: string
+) {
   Object.defineProperty(proxy, key, {
     enumerable: true,
     configurable: true,
     get() {
-      return instance.$attrs[key]
+      return instance[type][key]
     }
   })
 }
@@ -171,19 +181,23 @@ export function syncSetupSlots(to: any, from: any) {
 }
 
 /**
- * @internal use manual type def
+ * @internal use manual type def because it relies on legacy VNode types
  */
 export function useSlots(): SetupContext['slots'] {
   return getContext().slots
 }
 
-/**
- * @internal use manual type def
- */
 export function useAttrs(): SetupContext['attrs'] {
   return getContext().attrs
 }
 
+/**
+ * Vue 2 only
+ */
+export function useListeners(): SetupContext['listeners'] {
+  return getContext().listeners
+}
+
 function getContext(): SetupContext {
   if (__DEV__ && !currentInstance) {
     warn(`useContext() called without active instance.`)
diff --git a/src/v3/index.ts b/src/v3/index.ts
index 30b89c3162e..90dfacc17ed 100644
--- a/src/v3/index.ts
+++ b/src/v3/index.ts
@@ -77,7 +77,7 @@ export { provide, inject, InjectionKey } from './apiInject'
 
 export { h } from './h'
 export { getCurrentInstance } from './currentInstance'
-export { useSlots, useAttrs, mergeDefaults } from './apiSetup'
+export { useSlots, useAttrs, useListeners, mergeDefaults } from './apiSetup'
 export { nextTick } from 'core/util/next-tick'
 export { set, del } from 'core/observer'
 
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 4ae9e739e91..7c69d06d1c4 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -297,4 +297,27 @@ describe('api: setup context', () => {
     await nextTick()
     expect(spy).toHaveBeenCalledTimes(1)
   })
+
+  it('context.listeners', async () => {
+    let _listeners
+    const Child = {
+      setup(_, { listeners }) {
+        _listeners = listeners
+        return () => {}
+      }
+    }
+
+    const Parent = {
+      data: () => ({ log: () => 1 }),
+      template: `<Child @foo="log" />`,
+      components: { Child }
+    }
+
+    const vm = new Vue(Parent).$mount()
+
+    expect(_listeners.foo()).toBe(1)
+    vm.log = () => 2
+    await nextTick()
+    expect(_listeners.foo()).toBe(2)
+  })
 })
diff --git a/types/v3-manual-apis.d.ts b/types/v3-manual-apis.d.ts
index 901494d624d..2f8e94b113c 100644
--- a/types/v3-manual-apis.d.ts
+++ b/types/v3-manual-apis.d.ts
@@ -5,6 +5,4 @@ export function getCurrentInstance(): { proxy: Vue } | null
 
 export const h: CreateElement
 
-export function useAttrs(): SetupContext['attrs']
-
 export function useSlots(): SetupContext['slots']
diff --git a/types/v3-setup-context.d.ts b/types/v3-setup-context.d.ts
index 7e11fe095a4..77b49bed8a6 100644
--- a/types/v3-setup-context.d.ts
+++ b/types/v3-setup-context.d.ts
@@ -31,6 +31,10 @@ export type EmitFn<
 
 export interface SetupContext<E extends EmitsOptions = {}> {
   attrs: Data
+  /**
+   * Equivalent of `this.$listeners`, which is Vue 2 only.
+   */
+  listeners: Record<string, Function | Function[]>
   slots: Slots
   emit: EmitFn<E>
   expose(exposed?: Record<string, any>): void

From ce6fc149e3a60d811e19f7b100a5f80fed18018d Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 22 Jul 2022 10:05:35 +0800
Subject: [PATCH 252/317] types: fix manual api types for useAttrs/useListeners

---
 src/v3/apiSetup.ts        | 9 ++++++++-
 types/v3-manual-apis.d.ts | 2 ++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/v3/apiSetup.ts b/src/v3/apiSetup.ts
index ea8448072c2..064e15dc75f 100644
--- a/src/v3/apiSetup.ts
+++ b/src/v3/apiSetup.ts
@@ -181,18 +181,25 @@ export function syncSetupSlots(to: any, from: any) {
 }
 
 /**
- * @internal use manual type def because it relies on legacy VNode types
+ * @internal use manual type def because public setup context type relies on
+ * legacy VNode types
  */
 export function useSlots(): SetupContext['slots'] {
   return getContext().slots
 }
 
+/**
+ * @internal use manual type def because public setup context type relies on
+ * legacy VNode types
+ */
 export function useAttrs(): SetupContext['attrs'] {
   return getContext().attrs
 }
 
 /**
  * Vue 2 only
+ * @internal use manual type def because public setup context type relies on
+ * legacy VNode types
  */
 export function useListeners(): SetupContext['listeners'] {
   return getContext().listeners
diff --git a/types/v3-manual-apis.d.ts b/types/v3-manual-apis.d.ts
index 2f8e94b113c..8636c11d6b2 100644
--- a/types/v3-manual-apis.d.ts
+++ b/types/v3-manual-apis.d.ts
@@ -6,3 +6,5 @@ export function getCurrentInstance(): { proxy: Vue } | null
 export const h: CreateElement
 
 export function useSlots(): SetupContext['slots']
+export function useAttrs(): SetupContext['attrs']
+export function useListeners(): SetupContext['listeners']

From fabc1cf89f55dd7f3f95fa7890d2540f40e9f845 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 22 Jul 2022 10:06:43 +0800
Subject: [PATCH 253/317] fix(types): avoid circular type inference between v2
 and v3 instance types

fix #12683
---
 types/v3-component-public-instance.d.ts |  2 --
 types/vue.d.ts                          | 15 ++++++---------
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/types/v3-component-public-instance.d.ts b/types/v3-component-public-instance.d.ts
index a5bf670139f..3586f4031e8 100644
--- a/types/v3-component-public-instance.d.ts
+++ b/types/v3-component-public-instance.d.ts
@@ -179,9 +179,7 @@ interface Vue3Instance<
         ? Partial<Defaults> & Omit<P & PublicProps, keyof Defaults>
         : P & PublicProps
     >,
-    ComponentPublicInstance | null,
     ComponentPublicInstance,
-    ComponentPublicInstance[],
     Options & MergedComponentOptionsOverride,
     EmitFn<E>
   > {}
diff --git a/types/vue.d.ts b/types/vue.d.ts
index aaf471dd2c1..74bce2c8a45 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -14,7 +14,6 @@ import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
 import { PluginFunction, PluginObject } from './plugin'
 import { DefineComponent } from './v3-define-component'
 import { nextTick } from './v3-generated'
-import { ComponentPublicInstance } from './v3-component-public-instance'
 
 export interface CreateElement {
   (
@@ -41,18 +40,16 @@ type NeverFallback<T, D> = [T] extends [never] ? D : T
 export interface Vue<
   Data = Record<string, any>,
   Props = Record<string, any>,
-  Parent = never,
-  Root = never,
-  Children = never,
+  Instance = never,
   Options = never,
   Emit = (event: string, ...args: any[]) => Vue
 > {
   // properties with different types in defineComponent()
   readonly $data: Data
   readonly $props: Props
-  readonly $parent: NeverFallback<Parent, Vue>
-  readonly $root: NeverFallback<Root, Vue>
-  readonly $children: NeverFallback<Children, Vue[]>
+  readonly $parent: NeverFallback<Instance, Vue> | null
+  readonly $root: NeverFallback<Instance, Vue>
+  readonly $children: NeverFallback<Instance, Vue>[]
   readonly $options: NeverFallback<Options, ComponentOptions<Vue>>
   $emit: Emit
 
@@ -60,10 +57,10 @@ export interface Vue<
   readonly $el: Element
   readonly $refs: {
     [key: string]:
+      | NeverFallback<Instance, Vue>
       | Vue
       | Element
-      | ComponentPublicInstance
-      | (Vue | Element | ComponentPublicInstance)[]
+      | (NeverFallback<Instance, Vue> | Vue | Element)[]
       | undefined
   }
   readonly $slots: { [key: string]: VNode[] | undefined }

From a695c5a6df415101a5f728e87dbe087b4fbb0b7b Mon Sep 17 00:00:00 2001
From: edison <daiwei521@126.com>
Date: Fri, 22 Jul 2022 10:18:27 +0800
Subject: [PATCH 254/317] fix(sfc): align `<script setup>` component resolution
 edge case with v3 (#12687)

fix #12685
---
 src/compiler/codegen/index.ts | 36 +++++++++++++++++++++++++++--------
 1 file changed, 28 insertions(+), 8 deletions(-)

diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index 5992859eba1..e3d5935b8d6 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -13,7 +13,7 @@ import {
   ASTText,
   CompilerOptions
 } from 'types/compiler'
-import { BindingMetadata } from 'sfc/types'
+import { BindingMetadata, BindingTypes } from 'sfc/types'
 
 type TransformFunction = (el: ASTElement, code: string) => string
 type DataGenFunction = (el: ASTElement) => string
@@ -104,10 +104,7 @@ export function genElement(el: ASTElement, state: CodegenState): string {
       // check if this is a component in <script setup>
       const bindings = state.options.bindings
       if (maybeComponent && bindings && bindings.__isScriptSetup !== false) {
-        tag =
-          checkBindingType(bindings, el.tag) ||
-          checkBindingType(bindings, camelize(el.tag)) ||
-          checkBindingType(bindings, capitalize(camelize(el.tag)))
+        tag = checkBindingType(bindings, el.tag)
       }
       if (!tag) tag = `'${el.tag}'`
 
@@ -127,9 +124,32 @@ export function genElement(el: ASTElement, state: CodegenState): string {
 }
 
 function checkBindingType(bindings: BindingMetadata, key: string) {
-  const type = bindings[key]
-  if (type && type.startsWith('setup')) {
-    return key
+  const camelName = camelize(key)
+  const PascalName = capitalize(camelName)
+  const checkType = (type) => {
+    if (bindings[key] === type) {
+      return key
+    }
+    if (bindings[camelName] === type) {
+      return camelName
+    }
+    if (bindings[PascalName] === type) {
+      return PascalName
+    }
+  }
+  const fromConst =
+    checkType(BindingTypes.SETUP_CONST) ||
+    checkType(BindingTypes.SETUP_REACTIVE_CONST)
+  if (fromConst) {
+    return fromConst
+  }
+
+  const fromMaybeRef =
+    checkType(BindingTypes.SETUP_LET) ||
+    checkType(BindingTypes.SETUP_REF) ||
+    checkType(BindingTypes.SETUP_MAYBE_REF)
+  if (fromMaybeRef) {
+    return fromMaybeRef
   }
 }
 

From ba7dd2c4ed62dba30bde7c1d521f7bfbab529102 Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Fri, 22 Jul 2022 03:18:52 +0100
Subject: [PATCH 255/317] fix(types): export `defineAsyncComponent` type
 (#12684)

---
 types/index.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/types/index.d.ts b/types/index.d.ts
index 91807ae691c..2b5d3a89da2 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -42,7 +42,7 @@ export * from './v3-setup-helpers'
 export { Data } from './common'
 export { SetupContext } from './v3-setup-context'
 export { defineComponent } from './v3-define-component'
-// export { defineAsyncComponent } from './defineAsyncComponent'
+export { defineAsyncComponent } from './v3-define-async-component'
 export {
   SetupFunction,
   // v2 already has option with same name and it's for a single computed

From 2af751b6efa0cd9cb817ed96af41948e92599837 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 22 Jul 2022 11:19:34 +0800
Subject: [PATCH 256/317] fix(reactivity): fix shallowReactive nested ref
 setting edge cases

ref #12688
---
 src/core/observer/index.ts                       |  2 +-
 .../unit/features/v3/reactivity/readonly.spec.ts | 15 ++++++++++-----
 test/unit/features/v3/reactivity/ref.spec.ts     | 16 +++++++++++++++-
 .../v3/reactivity/shallowReactive.spec.ts        | 13 +++++++++++++
 4 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 84744dd85f9..3770c489a9f 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -191,7 +191,7 @@ export function defineReactive(
       } else if (getter) {
         // #7981: for accessor properties without setter
         return
-      } else if (isRef(value) && !isRef(newVal)) {
+      } else if (!shallow && isRef(value) && !isRef(newVal)) {
         value.value = newVal
         return
       } else {
diff --git a/test/unit/features/v3/reactivity/readonly.spec.ts b/test/unit/features/v3/reactivity/readonly.spec.ts
index 11550ab56ed..012e142d451 100644
--- a/test/unit/features/v3/reactivity/readonly.spec.ts
+++ b/test/unit/features/v3/reactivity/readonly.spec.ts
@@ -483,7 +483,6 @@ describe('reactivity/readonly', () => {
     const ror = readonly(r)
     const obj = reactive({ ror })
     obj.ror = true
-
     expect(obj.ror).toBe(false)
     expect(`Set operation on key "value" failed`).toHaveBeenWarned()
   })
@@ -492,14 +491,20 @@ describe('reactivity/readonly', () => {
     const r = ref(false)
     const ror = readonly(r)
     const obj = reactive({ ror })
-    try {
-      obj.ror = ref(true) as unknown as boolean
-    } catch (e) {}
-
+    obj.ror = ref(true) as unknown as boolean
     expect(obj.ror).toBe(true)
     expect(toRaw(obj).ror).not.toBe(ror) // ref successfully replaced
   })
 
+  test('setting readonly object to writable nested ref', () => {
+    const r = ref<any>()
+    const obj = reactive({ r })
+    const ro = readonly({})
+    obj.r = ro
+    expect(obj.r).toBe(ro)
+    expect(r.value).toBe(ro)
+  })
+
   test('compatiblity with classes', () => {
     const spy = vi.fn()
     class Foo {
diff --git a/test/unit/features/v3/reactivity/ref.spec.ts b/test/unit/features/v3/reactivity/ref.spec.ts
index c61aaa71027..96212975359 100644
--- a/test/unit/features/v3/reactivity/ref.spec.ts
+++ b/test/unit/features/v3/reactivity/ref.spec.ts
@@ -11,7 +11,8 @@ import {
   isReactive,
   isShallow,
   reactive,
-  computed
+  computed,
+  readonly
 } from 'v3'
 import { effect } from 'v3/reactivity/effect'
 
@@ -404,4 +405,17 @@ describe('reactivity/ref', () => {
     b.value = obj
     expect(spy2).toBeCalledTimes(1)
   })
+
+  test('ref should preserve value readonly-ness', () => {
+    const original = {}
+    const r = reactive(original)
+    const rr = readonly(original)
+    const a = ref(original)
+
+    expect(a.value).toBe(r)
+
+    a.value = rr
+    expect(a.value).toBe(rr)
+    expect(a.value).not.toBe(r)
+  })
 })
diff --git a/test/unit/features/v3/reactivity/shallowReactive.spec.ts b/test/unit/features/v3/reactivity/shallowReactive.spec.ts
index 1e2a0cbf808..d1125771b90 100644
--- a/test/unit/features/v3/reactivity/shallowReactive.spec.ts
+++ b/test/unit/features/v3/reactivity/shallowReactive.spec.ts
@@ -3,6 +3,7 @@ import {
   isRef,
   isShallow,
   reactive,
+  Ref,
   ref,
   shallowReactive,
   shallowReadonly
@@ -45,6 +46,18 @@ describe('shallowReactive', () => {
     expect(foo.bar.value).toBe(123)
   })
 
+  // #12688
+  test('should not mutate refs', () => {
+    const original = ref(123)
+    const foo = shallowReactive<{ bar: Ref<number> | number }>({
+      bar: original
+    })
+    expect(foo.bar).toBe(original)
+    foo.bar = 234
+    expect(foo.bar).toBe(234)
+    expect(original.value).toBe(123)
+  })
+
   // @discrepancy no shallow/non-shallow versions from the same source -
   // cannot support this without real proxies
   // #2843

From 1d8b892fcd9edcef1feeed74ad586beabb9f6df2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 22 Jul 2022 11:24:39 +0800
Subject: [PATCH 257/317] release: v2.7.8

---
 CHANGELOG.md                            | 17 +++++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cf52be06131..bc98f138f33 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,20 @@
+## [2.7.8](https://github.com/vuejs/vue/compare/v2.7.7...v2.7.8) (2022-07-22)
+
+
+### Bug Fixes
+
+* **reactivity:** fix shallowReactive nested ref setting edge cases ([2af751b](https://github.com/vuejs/vue/commit/2af751b6efa0cd9cb817ed96af41948e92599837)), closes [#12688](https://github.com/vuejs/vue/issues/12688)
+* **sfc:** align `<script setup>` component resolution edge case with v3 ([#12687](https://github.com/vuejs/vue/issues/12687)) ([a695c5a](https://github.com/vuejs/vue/commit/a695c5a6df415101a5f728e87dbe087b4fbb0b7b)), closes [#12685](https://github.com/vuejs/vue/issues/12685)
+* **types:** avoid circular type inference between v2 and v3 instance types ([fabc1cf](https://github.com/vuejs/vue/commit/fabc1cf89f55dd7f3f95fa7890d2540f40e9f845)), closes [#12683](https://github.com/vuejs/vue/issues/12683)
+* **types:** export `defineAsyncComponent` type ([#12684](https://github.com/vuejs/vue/issues/12684)) ([ba7dd2c](https://github.com/vuejs/vue/commit/ba7dd2c4ed62dba30bde7c1d521f7bfbab529102))
+
+
+### Features
+
+* **setup:** support listeners on setup context + `useListeners()` helper ([adf3ac8](https://github.com/vuejs/vue/commit/adf3ac8adcf204dcc34b851da6ab4d914bd11cf9))
+
+
+
 ## [2.7.7](https://github.com/vuejs/vue/compare/v2.7.6...v2.7.7) (2022-07-16)
 
 
diff --git a/package.json b/package.json
index fac4eec9ac3..039c8882375 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.7",
+  "version": "2.7.8",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index d2b01fc5dc9..6a6037a3111 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.7",
+  "version": "2.7.8",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index ed7716f0d5c..5e8adfd83f6 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.7",
+  "version": "2.7.8",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 8d9aa5577ac..d1be678cdfb 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.7",
+  "version": "2.7.8",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 00458cd38d209410d3c675729230a42a0a34a4b9 Mon Sep 17 00:00:00 2001
From: jf-paradis <89814003+jf-paradis@users.noreply.github.com>
Date: Mon, 8 Aug 2022 17:50:53 -0700
Subject: [PATCH 258/317] fix(types): Make SetupBindings optional on
 ExtendedVue and CombinedVueInstance (#12727)

fix #12726
fix #12717
---
 types/vue.d.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/types/vue.d.ts b/types/vue.d.ts
index 74bce2c8a45..8c91bc88a2f 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -100,7 +100,7 @@ export type CombinedVueInstance<
   Methods,
   Computed,
   Props,
-  SetupBindings
+  SetupBindings = {}
 > = Data &
   Methods &
   Computed &
@@ -114,7 +114,7 @@ export type ExtendedVue<
   Methods,
   Computed,
   Props,
-  SetupBindings
+  SetupBindings = {}
 > = VueConstructor<
   CombinedVueInstance<Instance, Data, Methods, Computed, Props, SetupBindings> &
     Vue

From 5c742eb2e0d8dad268fb29ed4f92d286b5e0f4b5 Mon Sep 17 00:00:00 2001
From: Jonas <30421456+jonaskuske@users.noreply.github.com>
Date: Mon, 15 Aug 2022 03:37:08 +0200
Subject: [PATCH 259/317] fix(compiler-sfc): allow full hostnames in asset url
 base (#12732)

fix #12731
---
 .../compiler-sfc/src/templateCompilerModules/utils.ts | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/packages/compiler-sfc/src/templateCompilerModules/utils.ts b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
index 3e635b00207..8a2d19c6ce7 100644
--- a/packages/compiler-sfc/src/templateCompilerModules/utils.ts
+++ b/packages/compiler-sfc/src/templateCompilerModules/utils.ts
@@ -24,10 +24,15 @@ export function urlToRequire(
     // does not apply to absolute urls or urls that start with `@`
     // since they are aliases
     if (firstChar === '.' || firstChar === '~') {
+      // Allow for full hostnames provided in options.base
+      const base = parseUriParts(transformAssetUrlsOption.base)
+      const protocol = base.protocol || ''
+      const host = base.host ? protocol + '//' + base.host : ''
+      const basePath = base.path || '/'
       // when packaged in the browser, path will be using the posix-
       // only version provided by rollup-plugin-node-builtins.
-      return `"${(path.posix || path).join(
-        transformAssetUrlsOption.base,
+      return `"${host}${(path.posix || path).join(
+        basePath,
         uriParts.path + (uriParts.hash || '')
       )}"`
     }
@@ -64,7 +69,7 @@ function parseUriParts(urlString: string): UrlWithStringQuery {
     // @see https://nodejs.org/api/url.html#url_url_parse_urlstring_parsequerystring_slashesdenotehost
     if ('string' === typeof urlString) {
       // check is an uri
-      return uriParse(urlString) // take apart the uri
+      return uriParse(urlString, false, true) // take apart the uri
     }
   }
   return returnValue

From 4b37b568c7c3fd238aa61fcc956f882223f8e87f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 15 Aug 2022 09:53:12 +0800
Subject: [PATCH 260/317] fix(types): fix options suggestions when using
 defineComponent

functional component overloads should be moved last

fix #12736
---
 types/v3-define-component.d.ts | 56 +++++++++++++++++-----------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
index 30f7046e403..a2c47322b49 100644
--- a/types/v3-define-component.d.ts
+++ b/types/v3-define-component.d.ts
@@ -67,30 +67,6 @@ type DefineComponent<
     props: PropsOrPropOptions
   }
 
-/**
- * overload 0.0: functional component with array props
- */
-export function defineComponent<
-  PropNames extends string,
-  Props = Readonly<{ [key in PropNames]?: any }>
->(options: {
-  functional: true
-  props?: PropNames[]
-  render?: (h: CreateElement, context: RenderContext<Props>) => any
-}): DefineComponent<Props>
-
-/**
- * overload 0.1: functional component with object props
- */
-export function defineComponent<
-  PropsOptions extends ComponentPropsOptions = ComponentPropsOptions,
-  Props = ExtractPropTypes<PropsOptions>
->(options: {
-  functional: true
-  props?: PropsOptions
-  render?: (h: CreateElement, context: RenderContext<Props>) => any
-}): DefineComponent<PropsOptions>
-
 /**
  * overload 1: object format with no props
  */
@@ -104,7 +80,7 @@ export function defineComponent<
   Emits extends EmitsOptions = {},
   EmitsNames extends string = string
 >(
-  options: ComponentOptionsWithoutProps<
+  options: { functional?: never } & ComponentOptionsWithoutProps<
     {},
     RawBindings,
     D,
@@ -135,7 +111,7 @@ export function defineComponent<
   EmitsNames extends string = string,
   PropsOptions extends ComponentPropsOptions = ComponentPropsOptions
 >(
-  options: ComponentOptionsWithArrayProps<
+  options: { functional?: never } & ComponentOptionsWithArrayProps<
     PropNames,
     RawBindings,
     D,
@@ -175,7 +151,7 @@ export function defineComponent<
   PropsOptions extends ComponentPropsOptions = ComponentPropsOptions
 >(
   options: HasDefined<Props> extends true
-    ? ComponentOptionsWithProps<
+    ? { functional?: never } & ComponentOptionsWithProps<
         PropsOptions,
         RawBindings,
         D,
@@ -187,7 +163,7 @@ export function defineComponent<
         EmitsNames,
         Props
       >
-    : ComponentOptionsWithProps<
+    : { functional?: never } & ComponentOptionsWithProps<
         PropsOptions,
         RawBindings,
         D,
@@ -199,3 +175,27 @@ export function defineComponent<
         EmitsNames
       >
 ): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, Emits>
+
+/**
+ * overload 4.1: functional component with array props
+ */
+export function defineComponent<
+  PropNames extends string,
+  Props = Readonly<{ [key in PropNames]?: any }>
+>(options: {
+  functional: true
+  props?: PropNames[]
+  render?: (h: CreateElement, context: RenderContext<Props>) => any
+}): DefineComponent<Props>
+
+/**
+ * overload 4.2: functional component with object props
+ */
+export function defineComponent<
+  PropsOptions extends ComponentPropsOptions = ComponentPropsOptions,
+  Props = ExtractPropTypes<PropsOptions>
+>(options: {
+  functional: true
+  props?: PropsOptions
+  render?: (h: CreateElement, context: RenderContext<Props>) => any
+}): DefineComponent<PropsOptions>

From bd89ce53a9de417a9372630bb5d433a40acc1a53 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 15 Aug 2022 15:37:13 +0800
Subject: [PATCH 261/317] fix: ensure render watcher of manually created
 instance is correctly tracked in owner scope

fix #12701
---
 src/core/instance/lifecycle.ts | 2 ++
 src/core/observer/watcher.ts   | 6 ++----
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index df70b7113fd..fec330ad5fc 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -209,6 +209,7 @@ export function mountComponent(
   // we set this to vm._watcher inside the watcher's constructor
   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
   // component's mounted hook), which relies on vm._watcher being already defined
+  vm._scope.on()
   new Watcher(
     vm,
     updateComponent,
@@ -216,6 +217,7 @@ export function mountComponent(
     watcherOptions,
     true /* isRenderWatcher */
   )
+  vm._scope.off()
   hydrating = false
 
   // flush buffer for flush: "pre" watchers queued in setup()
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index b1f491acb33..00bf19b9123 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -72,10 +72,8 @@ export default class Watcher implements DepTarget {
     isRenderWatcher?: boolean
   ) {
     recordEffectScope(this, activeEffectScope || (vm ? vm._scope : undefined))
-    if ((this.vm = vm)) {
-      if (isRenderWatcher) {
-        vm._watcher = this
-      }
+    if ((this.vm = vm) && isRenderWatcher) {
+      vm._watcher = this
     }
     // options
     if (options) {

From f0057b101e6451d5095cdb7fd6308fd31ac0450c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 15 Aug 2022 19:06:38 +0800
Subject: [PATCH 262/317] fix(watch): avoid pre watcher firing on unmount

fix #12703
---
 src/v3/apiWatch.ts                     | 5 +----
 test/unit/features/v3/apiWatch.spec.ts | 4 ++--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/v3/apiWatch.ts b/src/v3/apiWatch.ts
index 7fe5eeb9dcc..141a58eb686 100644
--- a/src/v3/apiWatch.ts
+++ b/src/v3/apiWatch.ts
@@ -274,10 +274,7 @@ function doWatch(
   let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE
   // overwrite default run
   watcher.run = () => {
-    if (
-      !watcher.active &&
-      !(flush === 'pre' && instance && instance._isBeingDestroyed)
-    ) {
+    if (!watcher.active) {
       return
     }
     if (cb) {
diff --git a/test/unit/features/v3/apiWatch.spec.ts b/test/unit/features/v3/apiWatch.spec.ts
index 0206e8df3bf..c92bc150ae7 100644
--- a/test/unit/features/v3/apiWatch.spec.ts
+++ b/test/unit/features/v3/apiWatch.spec.ts
@@ -542,7 +542,7 @@ describe('api: watch', () => {
     expect(cb).not.toHaveBeenCalled()
   })
 
-  it('should fire on component unmount w/ flush: pre', async () => {
+  it('should not fire on component unmount w/ flush: pre', async () => {
     const toggle = ref(true)
     const cb = vi.fn()
     const Comp = {
@@ -560,7 +560,7 @@ describe('api: watch', () => {
     expect(cb).not.toHaveBeenCalled()
     toggle.value = false
     await nextTick()
-    expect(cb).toHaveBeenCalledTimes(1)
+    expect(cb).not.toHaveBeenCalled()
   })
 
   // vuejs/core#1763

From 80d1baf92050da411fb1bfe714401c498001dd36 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 18 Aug 2022 15:23:47 +0800
Subject: [PATCH 263/317] feat(types): export DefineComponent

close #12748
---
 types/index.d.ts               | 2 +-
 types/v3-define-component.d.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/types/index.d.ts b/types/index.d.ts
index 2b5d3a89da2..19fce98726f 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -41,7 +41,7 @@ export * from './v3-setup-helpers'
 
 export { Data } from './common'
 export { SetupContext } from './v3-setup-context'
-export { defineComponent } from './v3-define-component'
+export { defineComponent, DefineComponent } from './v3-define-component'
 export { defineAsyncComponent } from './v3-define-async-component'
 export {
   SetupFunction,
diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
index a2c47322b49..69f65a2ec35 100644
--- a/types/v3-define-component.d.ts
+++ b/types/v3-define-component.d.ts
@@ -20,7 +20,7 @@ import { Data, HasDefined } from './common'
 import { EmitsOptions } from './v3-setup-context'
 import { CreateElement, RenderContext } from './umd'
 
-type DefineComponent<
+export type DefineComponent<
   PropsOrPropOptions = {},
   RawBindings = {},
   D = {},

From b4bf4c52ad31e02307cfd4d643dc5610c893e3ba Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 18 Aug 2022 15:32:12 +0800
Subject: [PATCH 264/317] fix(types): allow attaching unknown options to
 defined component

fix #12742
---
 types/test/v3/define-component-test.tsx | 4 ++++
 types/v3-component-options.d.ts         | 3 +++
 2 files changed, 7 insertions(+)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 42d0f32eb0d..481a2d11ac7 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1165,3 +1165,7 @@ defineComponent({
     return h('div', {}, [...this.$slots.default!])
   }
 })
+
+// #12742 allow attaching custom properties (consistent with v3)
+const Foo = defineComponent({})
+Foo.foobar = 123
diff --git a/types/v3-component-options.d.ts b/types/v3-component-options.d.ts
index d8c64ab13ab..e2da34e753f 100644
--- a/types/v3-component-options.d.ts
+++ b/types/v3-component-options.d.ts
@@ -88,6 +88,9 @@ export interface ComponentOptionsBase<
       'data' | 'computed' | 'methods' | 'setup' | 'props' | 'mixins' | 'extends'
     >,
     ComponentCustomOptions {
+  // allow any options
+  [key: string]: any
+
   // rewrite options api types
   data?: (
     this: CreateComponentPublicInstance<Props, {}, {}, {}, M, Mixin, Extends>,

From 89a6b5e8658a6e3ae2cf649829901784ac9deb3c Mon Sep 17 00:00:00 2001
From: gu <11851303+gulewei@users.noreply.github.com>
Date: Thu, 18 Aug 2022 15:56:37 +0800
Subject: [PATCH 265/317] feat(types): support mixins inference for new Vue()
 (#12737)

close #12730
---
 types/options.d.ts                      |  33 +++++--
 types/test/vue-test.ts                  |  39 +++++++-
 types/v3-component-public-instance.d.ts |   4 +-
 types/vue.d.ts                          | 124 +++++++++++++++++++-----
 4 files changed, 166 insertions(+), 34 deletions(-)

diff --git a/types/options.d.ts b/types/options.d.ts
index e11020f4948..c82c6c5f8ae 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -3,6 +3,7 @@ import { VNode, VNodeData, VNodeDirective, NormalizedScopedSlot } from './vnode'
 import { SetupContext } from './v3-setup-context'
 import { DebuggerEvent } from './v3-generated'
 import { DefineComponent } from './v3-define-component'
+import { ComponentOptionsMixin } from './v3-component-options'
 
 type Constructor = {
   new (...args: any[]): any
@@ -93,7 +94,9 @@ export type ThisTypedComponentOptionsWithArrayProps<
   Methods,
   Computed,
   PropNames extends string,
-  SetupBindings
+  SetupBindings,
+  Mixin,
+  Extends
 > = object &
   ComponentOptions<
     V,
@@ -102,7 +105,9 @@ export type ThisTypedComponentOptionsWithArrayProps<
     Computed,
     PropNames[],
     Record<PropNames, any>,
-    SetupBindings
+    SetupBindings,
+    Mixin,
+    Extends
   > &
   ThisType<
     CombinedVueInstance<
@@ -111,7 +116,9 @@ export type ThisTypedComponentOptionsWithArrayProps<
       Methods,
       Computed,
       Readonly<Record<PropNames, any>>,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   >
 
@@ -124,7 +131,9 @@ export type ThisTypedComponentOptionsWithRecordProps<
   Methods,
   Computed,
   Props,
-  SetupBindings
+  SetupBindings,
+  Mixin,
+  Extends
 > = object &
   ComponentOptions<
     V,
@@ -133,7 +142,9 @@ export type ThisTypedComponentOptionsWithRecordProps<
     Computed,
     RecordPropsDefinition<Props>,
     Props,
-    SetupBindings
+    SetupBindings,
+    Mixin,
+    Extends
   > &
   ThisType<
     CombinedVueInstance<
@@ -142,7 +153,9 @@ export type ThisTypedComponentOptionsWithRecordProps<
       Methods,
       Computed,
       Readonly<Props>,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   >
 
@@ -158,7 +171,9 @@ export interface ComponentOptions<
   Computed = DefaultComputed,
   PropsDef = PropsDefinition<DefaultProps>,
   Props = DefaultProps,
-  RawBindings = {}
+  RawBindings = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin
 > {
   data?: Data
   props?: PropsDef
@@ -217,12 +232,12 @@ export interface ComponentOptions<
   }
 
   parent?: Vue
-  mixins?: (ComponentOptions<Vue> | typeof Vue)[]
+  mixins?: (Mixin | ComponentOptions<Vue> | typeof Vue)[]
   name?: string
   // for SFC auto name inference w/ ts-loader check
   __name?: string
   // TODO: support properly inferred 'extends'
-  extends?: ComponentOptions<Vue> | typeof Vue
+  extends?: Extends | ComponentOptions<Vue> | typeof Vue
   delimiters?: [string, string]
   comments?: boolean
   inheritAttrs?: boolean
diff --git a/types/test/vue-test.ts b/types/test/vue-test.ts
index 8489f3ae8ed..b792cec583d 100644
--- a/types/test/vue-test.ts
+++ b/types/test/vue-test.ts
@@ -1,4 +1,4 @@
-import Vue, { VNode } from '../index'
+import Vue, { VNode, defineComponent } from '../index'
 import { ComponentOptions } from '../options'
 
 class Test extends Vue {
@@ -246,3 +246,40 @@ const ComponentWithStyleInVNodeData = Vue.extend({
     ])
   }
 })
+
+// infer mixin type with new Vue() #12730
+new Vue({
+  mixins: [
+    defineComponent({
+      props: {
+        p1: String,
+        p2: {
+          type: Number,
+          default: 0
+        }
+      },
+      data() {
+        return {
+          foo: 123
+        }
+      },
+      computed: {
+        bar() {
+          return 123
+        }
+      }
+    }),
+    {
+      methods: {
+        hello(n: number) {}
+      }
+    }
+  ],
+  created() {
+    this.hello(this.foo)
+    this.hello(this.bar)
+    // @ts-expect-error
+    this.hello(this.p1)
+    this.hello(this.p2)
+  }
+})
diff --git a/types/v3-component-public-instance.d.ts b/types/v3-component-public-instance.d.ts
index 3586f4031e8..1c55908ac73 100644
--- a/types/v3-component-public-instance.d.ts
+++ b/types/v3-component-public-instance.d.ts
@@ -79,11 +79,11 @@ type ExtractMixin<T> = {
   Mixin: MixinToOptionTypes<T>
 }[T extends ComponentOptionsMixin ? 'Mixin' : never]
 
-type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true
+export type IntersectionMixin<T> = IsDefaultMixinComponent<T> extends true
   ? OptionTypesType<{}, {}, {}, {}, {}, {}>
   : UnionToIntersection<ExtractMixin<T>>
 
-type UnwrapMixinsType<
+export type UnwrapMixinsType<
   T,
   Type extends OptionTypesKeys
 > = T extends OptionTypesType ? T[Type] : never
diff --git a/types/vue.d.ts b/types/vue.d.ts
index 8c91bc88a2f..5a2027a0179 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -13,7 +13,15 @@ import {
 import { VNode, VNodeData, VNodeChildren, NormalizedScopedSlot } from './vnode'
 import { PluginFunction, PluginObject } from './plugin'
 import { DefineComponent } from './v3-define-component'
-import { nextTick } from './v3-generated'
+import { nextTick, UnwrapNestedRefs, ShallowUnwrapRef } from './v3-generated'
+import {
+  UnwrapMixinsType,
+  IntersectionMixin
+} from './v3-component-public-instance'
+import {
+  ExtractComputedReturns,
+  ComponentOptionsMixin
+} from './v3-component-options'
 
 export interface CreateElement {
   (
@@ -100,12 +108,20 @@ export type CombinedVueInstance<
   Methods,
   Computed,
   Props,
-  SetupBindings = {}
-> = Data &
+  SetupBindings = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin,
+  PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>
+> = UnwrapNestedRefs<UnwrapMixinsType<PublicMixin, 'D'>> &
+  Data &
+  UnwrapMixinsType<PublicMixin, 'M'> &
   Methods &
+  ExtractComputedReturns<UnwrapMixinsType<PublicMixin, 'C'>> &
   Computed &
+  UnwrapMixinsType<PublicMixin, 'P'> &
   Props &
   Instance &
+  ShallowUnwrapRef<UnwrapMixinsType<PublicMixin, 'B'>> &
   (SetupBindings extends void ? {} : SetupBindings)
 
 export type ExtendedVue<
@@ -114,9 +130,20 @@ export type ExtendedVue<
   Methods,
   Computed,
   Props,
-  SetupBindings = {}
+  SetupBindings = {},
+  Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin = ComponentOptionsMixin
 > = VueConstructor<
-  CombinedVueInstance<Instance, Data, Methods, Computed, Props, SetupBindings> &
+  CombinedVueInstance<
+    Instance,
+    Data,
+    Methods,
+    Computed,
+    Props,
+    SetupBindings,
+    Mixin,
+    Extends
+  > &
     Vue
 >
 
@@ -142,7 +169,9 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods = object,
     Computed = object,
     PropNames extends string = never,
-    SetupBindings = {}
+    SetupBindings = {},
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin
   >(
     options?: ThisTypedComponentOptionsWithArrayProps<
       V,
@@ -150,7 +179,9 @@ export interface VueConstructor<V extends Vue = Vue> {
       Methods,
       Computed,
       PropNames,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   ): CombinedVueInstance<
     V,
@@ -158,7 +189,9 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods,
     Computed,
     Record<PropNames, any>,
-    SetupBindings
+    SetupBindings,
+    Mixin,
+    Extends
   >
 
   /**
@@ -172,7 +205,9 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods = object,
     Computed = object,
     Props = object,
-    SetupBindings = {}
+    SetupBindings = {},
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin
   >(
     options?: ThisTypedComponentOptionsWithRecordProps<
       V,
@@ -180,7 +215,9 @@ export interface VueConstructor<V extends Vue = Vue> {
       Methods,
       Computed,
       Props,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   ): CombinedVueInstance<
     V,
@@ -188,7 +225,9 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods,
     Computed,
     Record<keyof Props, any>,
-    SetupBindings
+    SetupBindings,
+    Mixin,
+    Extends
   >
 
   /**
@@ -211,7 +250,9 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods,
     Computed,
     PropNames extends string = never,
-    SetupBindings = {}
+    SetupBindings = {},
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin
   >(
     options?: ThisTypedComponentOptionsWithArrayProps<
       V,
@@ -219,7 +260,9 @@ export interface VueConstructor<V extends Vue = Vue> {
       Methods,
       Computed,
       PropNames,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   ): ExtendedVue<
     V,
@@ -227,22 +270,43 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods,
     Computed,
     Record<PropNames, any>,
-    SetupBindings
+    SetupBindings,
+    Mixin,
+    Extends
   >
 
   /**
    * extend with object props
    */
-  extend<Data, Methods, Computed, Props, SetupBindings = {}>(
+  extend<
+    Data,
+    Methods,
+    Computed,
+    Props,
+    SetupBindings = {},
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin
+  >(
     options?: ThisTypedComponentOptionsWithRecordProps<
       V,
       Data,
       Methods,
       Computed,
       Props,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
-  ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
+  ): ExtendedVue<
+    V,
+    Data,
+    Methods,
+    Computed,
+    Props,
+    SetupBindings,
+    Mixin,
+    Extends
+  >
 
   /**
    * extend with functional + array props
@@ -287,7 +351,9 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods,
     Computed,
     PropNames extends string = never,
-    SetupBindings = {}
+    SetupBindings = {},
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin
   >(
     id: string,
     definition?: ThisTypedComponentOptionsWithArrayProps<
@@ -296,7 +362,9 @@ export interface VueConstructor<V extends Vue = Vue> {
       Methods,
       Computed,
       PropNames,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   ): ExtendedVue<
     V,
@@ -304,9 +372,19 @@ export interface VueConstructor<V extends Vue = Vue> {
     Methods,
     Computed,
     Record<PropNames, any>,
-    SetupBindings
+    SetupBindings,
+    Mixin,
+    Extends
   >
-  component<Data, Methods, Computed, Props, SetupBindings>(
+  component<
+    Data,
+    Methods,
+    Computed,
+    Props,
+    SetupBindings,
+    Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
+    Extends extends ComponentOptionsMixin = ComponentOptionsMixin
+  >(
     id: string,
     definition?: ThisTypedComponentOptionsWithRecordProps<
       V,
@@ -314,7 +392,9 @@ export interface VueConstructor<V extends Vue = Vue> {
       Methods,
       Computed,
       Props,
-      SetupBindings
+      SetupBindings,
+      Mixin,
+      Extends
     >
   ): ExtendedVue<V, Data, Methods, Computed, Props, SetupBindings>
   component<PropNames extends string>(

From 5221d4d3b6049c87d196d99dbb64bcd3f3b07279 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9E=97=E7=83=81=E5=A3=95?= <1138674510@qq.com>
Date: Thu, 18 Aug 2022 16:01:00 +0800
Subject: [PATCH 266/317] fix(compiler-sfc): rewriteDefault for class with
 decorators (#12747)

---
 packages/compiler-sfc/src/rewriteDefault.ts   |   7 +-
 .../compiler-sfc/test/rewriteDefault.spec.ts  | 245 ++++++++++++++++++
 2 files changed, 251 insertions(+), 1 deletion(-)
 create mode 100644 packages/compiler-sfc/test/rewriteDefault.spec.ts

diff --git a/packages/compiler-sfc/src/rewriteDefault.ts b/packages/compiler-sfc/src/rewriteDefault.ts
index ced9f56d8a9..e61cf691bba 100644
--- a/packages/compiler-sfc/src/rewriteDefault.ts
+++ b/packages/compiler-sfc/src/rewriteDefault.ts
@@ -42,7 +42,12 @@ export function rewriteDefault(
   }).program.body
   ast.forEach(node => {
     if (node.type === 'ExportDefaultDeclaration') {
-      s.overwrite(node.start!, node.declaration.start!, `const ${as} = `)
+      if (node.declaration.type === 'ClassDeclaration') {
+        s.overwrite(node.start!, node.declaration.id.start!, `class `)
+        s.append(`\nconst ${as} = ${node.declaration.id.name}`)
+      } else {
+        s.overwrite(node.start!, node.declaration.start!, `const ${as} = `)
+      }
     }
     if (node.type === 'ExportNamedDeclaration') {
       for (const specifier of node.specifiers) {
diff --git a/packages/compiler-sfc/test/rewriteDefault.spec.ts b/packages/compiler-sfc/test/rewriteDefault.spec.ts
new file mode 100644
index 00000000000..9fb4c64bbb3
--- /dev/null
+++ b/packages/compiler-sfc/test/rewriteDefault.spec.ts
@@ -0,0 +1,245 @@
+import { rewriteDefault } from '../src'
+
+describe('compiler sfc: rewriteDefault', () => {
+  test('without export default', () => {
+    expect(rewriteDefault(`export  a = {}`, 'script')).toMatchInlineSnapshot(`
+      "export  a = {}
+      const script = {}"
+    `)
+  })
+
+  test('rewrite export default', () => {
+    expect(
+      rewriteDefault(`export  default {}`, 'script')
+    ).toMatchInlineSnapshot(`"const script = {}"`)
+  })
+
+  test('rewrite export named default', () => {
+    expect(
+      rewriteDefault(
+        `const a = 1 \n export { a as b, a as default, a as c}`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "const a = 1 
+       export { a as b,  a as c}
+      const script = a"
+    `)
+
+    expect(
+      rewriteDefault(
+        `const a = 1 \n export { a as b, a as default    , a as c}`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "const a = 1 
+       export { a as b,  a as c}
+      const script = a"
+    `)
+  })
+
+  test('w/ comments', async () => {
+    expect(rewriteDefault(`// export default\nexport default {}`, 'script'))
+      .toMatchInlineSnapshot(`
+      "// export default
+      const script = {}"
+    `)
+  })
+
+  test('export named default multiline', () => {
+    expect(
+      rewriteDefault(`let App = {}\n export {\nApp as default\n}`, '_sfc_main')
+    ).toMatchInlineSnapshot(`
+      "let App = {}
+       export {
+      
+      }
+      const _sfc_main = App"
+    `)
+  })
+
+  test('export named default multiline /w comments', () => {
+    expect(
+      rewriteDefault(
+        `const a = 1 \n export {\n a as b,\n a as default,\n a as c}\n` +
+          `// export { myFunction as default }`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "const a = 1 
+       export {
+       a as b,
+       
+       a as c}
+      // export { myFunction as default }
+      const script = a"
+    `)
+
+    expect(
+      rewriteDefault(
+        `const a = 1 \n export {\n a as b,\n a as default      ,\n a as c}\n` +
+          `// export { myFunction as default }`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "const a = 1 
+       export {
+       a as b,
+       
+       a as c}
+      // export { myFunction as default }
+      const script = a"
+    `)
+  })
+
+  test(`export { default } from '...'`, async () => {
+    expect(
+      rewriteDefault(`export { default, foo } from './index.js'`, 'script')
+    ).toMatchInlineSnapshot(`
+    "import { default as __VUE_DEFAULT__ } from './index.js'
+    export {  foo } from './index.js'
+    const script = __VUE_DEFAULT__"
+    `)
+
+    expect(
+      rewriteDefault(`export { default    , foo } from './index.js'`, 'script')
+    ).toMatchInlineSnapshot(`
+    "import { default as __VUE_DEFAULT__ } from './index.js'
+    export {  foo } from './index.js'
+    const script = __VUE_DEFAULT__"
+    `)
+
+    expect(
+      rewriteDefault(`export { foo,   default } from './index.js'`, 'script')
+    ).toMatchInlineSnapshot(`
+    "import { default as __VUE_DEFAULT__ } from './index.js'
+    export { foo,    } from './index.js'
+    const script = __VUE_DEFAULT__"
+    `)
+
+    expect(
+      rewriteDefault(
+        `export { foo as default, bar } from './index.js'`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+    "import { foo } from './index.js'
+    export {  bar } from './index.js'
+    const script = foo"
+    `)
+
+    expect(
+      rewriteDefault(
+        `export { foo as default     , bar } from './index.js'`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+    "import { foo } from './index.js'
+    export {  bar } from './index.js'
+    const script = foo"
+    `)
+
+    expect(
+      rewriteDefault(
+        `export { bar,   foo as default } from './index.js'`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+    "import { foo } from './index.js'
+    export { bar,    } from './index.js'
+    const script = foo"
+    `)
+  })
+
+  test('export default class', async () => {
+    expect(rewriteDefault(`export default class Foo {}`, 'script'))
+      .toMatchInlineSnapshot(`
+      "class Foo {}
+      const script = Foo"
+    `)
+  })
+
+  test('export default class w/ comments', async () => {
+    expect(
+      rewriteDefault(`// export default\nexport default class Foo {}`, 'script')
+    ).toMatchInlineSnapshot(`
+      "// export default
+      class Foo {}
+      const script = Foo"
+    `)
+  })
+
+  test('export default class w/ comments 2', async () => {
+    expect(
+      rewriteDefault(
+        `export default {}\n` + `// export default class Foo {}`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "const script = {}
+      // export default class Foo {}"
+    `)
+  })
+
+  test('export default class w/ comments 3', async () => {
+    expect(
+      rewriteDefault(
+        `/*\nexport default class Foo {}*/\n` + `export default class Bar {}`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "/*
+      export default class Foo {}*/
+      class Bar {}
+      const script = Bar"
+    `)
+  })
+
+  test('@Component\nexport default class', async () => {
+    expect(rewriteDefault(`@Component\nexport default class Foo {}`, 'script'))
+      .toMatchInlineSnapshot(`
+      "@Component
+      class Foo {}
+      const script = Foo"
+    `)
+  })
+
+  test('@Component\nexport default class w/ comments', async () => {
+    expect(
+      rewriteDefault(`// export default\n@Component\nexport default class Foo {}`, 'script')
+    ).toMatchInlineSnapshot(`
+      "// export default
+      @Component
+      class Foo {}
+      const script = Foo"
+    `)
+  })
+
+  test('@Component\nexport default class w/ comments 2', async () => {
+    expect(
+      rewriteDefault(
+        `export default {}\n` + `// @Component\n// export default class Foo {}`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "const script = {}
+      // @Component
+      // export default class Foo {}"
+    `)
+  })
+
+  test('@Component\nexport default class w/ comments 3', async () => {
+    expect(
+      rewriteDefault(
+        `/*\n@Component\nexport default class Foo {}*/\n` + `export default class Bar {}`,
+        'script'
+      )
+    ).toMatchInlineSnapshot(`
+      "/*
+      @Component
+      export default class Foo {}*/
+      class Bar {}
+      const script = Bar"
+    `)
+  })
+})

From 2263948c249e7486403bc5880712e6d9fd15c17f Mon Sep 17 00:00:00 2001
From: JuniorTour <juniortour@qq.com>
Date: Thu, 18 Aug 2022 16:11:47 +0800
Subject: [PATCH 267/317] fix: directives shorthand normalize error (#12744)

fix #12743
---
 src/core/vdom/modules/directives.ts    | 10 +++++++++-
 test/unit/features/v3/apiSetup.spec.ts | 13 +++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/core/vdom/modules/directives.ts b/src/core/vdom/modules/directives.ts
index 9e4a87f7f6e..853b20021e7 100644
--- a/src/core/vdom/modules/directives.ts
+++ b/src/core/vdom/modules/directives.ts
@@ -103,7 +103,15 @@ function normalizeDirectives(
     }
     res[getRawDirName(dir)] = dir
     if (vm._setupState && vm._setupState.__sfc) {
-      dir.def = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name)
+      const setupDef = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name)
+      if (typeof setupDef === 'function') {
+        dir.def = {
+          bind: setupDef,
+          update: setupDef,
+        }
+      } else {
+        dir.def = setupDef
+      }
     }
     dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true)
   }
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 7c69d06d1c4..11757878e9c 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -251,6 +251,19 @@ describe('api: setup context', () => {
     expect(spy).toHaveBeenCalled()
   })
 
+  // #12743
+  it('directive resolution for shorthand', () => {
+    const spy = vi.fn()
+    new Vue({
+      setup: () => ({
+        __sfc: true,
+        vDir: spy
+      }),
+      template: `<div v-dir />`
+    }).$mount()
+    expect(spy).toHaveBeenCalled()
+  })
+  
   // #12561
   it('setup props should be reactive', () => {
     const msg = ref('hi')

From 9eb8ea5b63eec2b09f268738e9d0e311d9eafb19 Mon Sep 17 00:00:00 2001
From: GU Yiling <justice360@gmail.com>
Date: Thu, 18 Aug 2022 16:12:20 +0800
Subject: [PATCH 268/317] chore: fix some legacy doc urls in warnings and
 readme (#12725) [ci skip]

---
 README.md                  | 2 +-
 src/core/instance/proxy.ts | 4 ++--
 src/core/instance/state.ts | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 5a3f576d716..5eef53d3fa0 100644
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ Vue.js supports all browsers that are [ES5-compliant](https://kangax.github.io/c
 
 ## Documentation
 
-To check out [live examples](https://vuejs.org/v2/examples/) and docs, visit [vuejs.org](https://vuejs.org).
+To check out [live examples](https://v2.vuejs.org/v2/examples/) and docs, visit [vuejs.org](https://v2.vuejs.org).
 
 ## Questions
 
diff --git a/src/core/instance/proxy.ts b/src/core/instance/proxy.ts
index 3543d74954a..685d9651fcc 100644
--- a/src/core/instance/proxy.ts
+++ b/src/core/instance/proxy.ts
@@ -19,7 +19,7 @@ if (__DEV__) {
         'referenced during render. Make sure that this property is reactive, ' +
         'either in the data option, or for class-based components, by ' +
         'initializing the property. ' +
-        'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
+        'See: https://v2.vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',
       target
     )
   }
@@ -29,7 +29,7 @@ if (__DEV__) {
       `Property "${key}" must be accessed with "$data.${key}" because ` +
         'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
         'prevent conflicts with Vue internals. ' +
-        'See: https://vuejs.org/v2/api/#data',
+        'See: https://v2.vuejs.org/v2/api/#data',
       target
     )
   }
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index e22ec6705fb..aedb72555c9 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -127,7 +127,7 @@ function initData(vm: Component) {
     __DEV__ &&
       warn(
         'data functions should return an object:\n' +
-          'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
+          'https://v2.vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
         vm
       )
   }

From bba6b3d6b4e3e26d28abbf20e74ec2f3e64f1a92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B8=8D=E8=A7=81=E6=9C=88?=
 <61452855+nooooooom@users.noreply.github.com>
Date: Thu, 18 Aug 2022 16:20:27 +0800
Subject: [PATCH 269/317] feat(types): enhance type for onErrorCaptured
 (#12735)

---
 src/v3/apiLifecycle.ts | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/v3/apiLifecycle.ts b/src/v3/apiLifecycle.ts
index dc47bc4652b..31e0542920c 100644
--- a/src/v3/apiLifecycle.ts
+++ b/src/v3/apiLifecycle.ts
@@ -42,7 +42,6 @@ export const onBeforeUpdate = createLifeCycle('beforeUpdate')
 export const onUpdated = createLifeCycle('updated')
 export const onBeforeUnmount = createLifeCycle('beforeDestroy')
 export const onUnmounted = createLifeCycle('destroyed')
-export const onErrorCaptured = createLifeCycle('errorCaptured')
 export const onActivated = createLifeCycle('activated')
 export const onDeactivated = createLifeCycle('deactivated')
 export const onServerPrefetch = createLifeCycle('serverPrefetch')
@@ -51,3 +50,19 @@ export const onRenderTracked =
   createLifeCycle<(e: DebuggerEvent) => any>('renderTracked')
 export const onRenderTriggered =
   createLifeCycle<(e: DebuggerEvent) => any>('renderTriggered')
+
+export type ErrorCapturedHook<TError = unknown> = (
+  err: TError,
+  instance: any,
+  info: string
+) => boolean | void
+
+const injectErrorCapturedHook =
+  createLifeCycle<ErrorCapturedHook<any>>('errorCaptured')
+
+export function onErrorCaptured<TError = Error>(
+  hook: ErrorCapturedHook<TError>,
+  target: any = currentInstance
+) {
+  injectErrorCapturedHook(hook, target)
+}

From 165a14a6c6c406176037465d2961259c5c980399 Mon Sep 17 00:00:00 2001
From: Alexander Lichter <github@lichter.io>
Date: Thu, 18 Aug 2022 10:22:55 +0200
Subject: [PATCH 270/317] fix(ssr): fix on-component directives rendering
 (#12661)

fix #10733
---
 packages/server-renderer/src/render.ts        | 10 +-
 .../server-renderer/test/ssr-string.spec.ts   | 94 ++++++++++++++++++-
 src/core/vdom/vnode.ts                        |  1 +
 3 files changed, 103 insertions(+), 2 deletions(-)

diff --git a/packages/server-renderer/src/render.ts b/packages/server-renderer/src/render.ts
index 907b795d797..b1116840ed5 100644
--- a/packages/server-renderer/src/render.ts
+++ b/packages/server-renderer/src/render.ts
@@ -206,6 +206,11 @@ function renderComponentInner(node, isRoot, context) {
       type: 'Component',
       prevActive
     })
+    if (isDef(node.data) && isDef(node.data.directives)) {
+      childNode.data = childNode.data || {}
+      childNode.data.directives = node.data.directives
+      childNode.isComponentRootElement = true
+    }
     renderNode(childNode, isRoot, context)
   }
 
@@ -372,7 +377,10 @@ function renderStartingTag(node: VNode, context) {
           if (dirRenderer) {
             // directives mutate the node's data
             // which then gets rendered by modules
-            dirRenderer(node, dirs[i])
+            dirRenderer(
+              node.isComponentRootElement ? node.parent : node,
+              dirs[i]
+            )
           }
         }
       }
diff --git a/packages/server-renderer/test/ssr-string.spec.ts b/packages/server-renderer/test/ssr-string.spec.ts
index 35810c8ed58..391671c1e52 100644
--- a/packages/server-renderer/test/ssr-string.spec.ts
+++ b/packages/server-renderer/test/ssr-string.spec.ts
@@ -1086,7 +1086,7 @@ describe('SSR: renderToString', () => {
     )
   })
 
-  it('custom directives', done => {
+  it('custom directives on raw element', done => {
     const renderer = createRenderer({
       directives: {
         'class-prefixer': (node, dir) => {
@@ -1129,6 +1129,98 @@ describe('SSR: renderToString', () => {
     )
   })
 
+  it('custom directives on component', done => {
+    const Test = {
+      template: '<span>hello world</span>'
+    }
+    const renderer = createRenderer({
+      directives: {
+        'class-prefixer': (node, dir) => {
+          if (node.data.class) {
+            node.data.class = `${dir.value}-${node.data.class}`
+          }
+          if (node.data.staticClass) {
+            node.data.staticClass = `${dir.value}-${node.data.staticClass}`
+          }
+        }
+      }
+    })
+    renderer.renderToString(
+      new Vue({
+        template:
+          '<p><Test v-class-prefixer="\'my\'" class="class1" :class="\'class2\'" /></p>',
+        components: { Test }
+      }),
+      (err, result) => {
+        expect(err).toBeNull()
+        expect(result).toContain(
+          '<p data-server-rendered="true"><span class="my-class1 my-class2">hello world</span></p>'
+        )
+        done()
+      }
+    )
+  })
+
+  it('custom directives on element root of a component', done => {
+    const Test = {
+      template:
+        '<span v-class-prefixer="\'my\'" class="class1" :class="\'class2\'">hello world</span>'
+    }
+    const renderer = createRenderer({
+      directives: {
+        'class-prefixer': (node, dir) => {
+          if (node.data.class) {
+            node.data.class = `${dir.value}-${node.data.class}`
+          }
+          if (node.data.staticClass) {
+            node.data.staticClass = `${dir.value}-${node.data.staticClass}`
+          }
+        }
+      }
+    })
+    renderer.renderToString(
+      new Vue({
+        template: '<p><Test /></p>',
+        components: { Test }
+      }),
+      (err, result) => {
+        expect(err).toBeNull()
+        expect(result).toContain(
+          '<p data-server-rendered="true"><span class="my-class1 my-class2">hello world</span></p>'
+        )
+        done()
+      }
+    )
+  })
+
+  it('custom directives on element with parent element', done => {
+    const renderer = createRenderer({
+      directives: {
+        'class-prefixer': (node, dir) => {
+          if (node.data.class) {
+            node.data.class = `${dir.value}-${node.data.class}`
+          }
+          if (node.data.staticClass) {
+            node.data.staticClass = `${dir.value}-${node.data.staticClass}`
+          }
+        }
+      }
+    })
+    renderer.renderToString(
+      new Vue({
+        template:
+          '<p><span v-class-prefixer="\'my\'" class="class1" :class="\'class2\'">hello world</span></p>'
+      }),
+      (err, result) => {
+        expect(err).toBeNull()
+        expect(result).toContain(
+          '<p data-server-rendered="true"><span class="my-class1 my-class2">hello world</span></p>'
+        )
+        done()
+      }
+    )
+  })
+
   it('should not warn for custom directives that do not have server-side implementation', done => {
     renderToString(
       new Vue({
diff --git a/src/core/vdom/vnode.ts b/src/core/vdom/vnode.ts
index 80f784167ba..3b57f9aca0c 100644
--- a/src/core/vdom/vnode.ts
+++ b/src/core/vdom/vnode.ts
@@ -33,6 +33,7 @@ export default class VNode {
   fnOptions?: ComponentOptions | null // for SSR caching
   devtoolsMeta?: Object | null // used to store functional render context for devtools
   fnScopeId?: string | null // functional scope id support
+  isComponentRootElement?: boolean | null // for SSR directives
 
   constructor(
     tag?: string,

From 7161176cd0dff10d65ab58e266018aff2660610f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 18 Aug 2022 18:14:50 +0800
Subject: [PATCH 271/317] fix: fix effect scope tracking for manually created
 instances

fix #12705
---
 src/core/instance/init.ts        |  1 +
 src/core/instance/lifecycle.ts   |  2 --
 src/core/observer/watcher.ts     | 11 ++++++++++-
 src/v3/reactivity/effectScope.ts |  6 +++++-
 4 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 876c9ddbf96..91456c21920 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -34,6 +34,7 @@ export function initMixin(Vue: typeof Component) {
     vm.__v_skip = true
     // effect scope
     vm._scope = new EffectScope(true /* detached */)
+    vm._scope._vm = true
     // merge options
     if (options && options._isComponent) {
       // optimize internal component instantiation
diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index fec330ad5fc..df70b7113fd 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -209,7 +209,6 @@ export function mountComponent(
   // we set this to vm._watcher inside the watcher's constructor
   // since the watcher's initial patch may call $forceUpdate (e.g. inside child
   // component's mounted hook), which relies on vm._watcher being already defined
-  vm._scope.on()
   new Watcher(
     vm,
     updateComponent,
@@ -217,7 +216,6 @@ export function mountComponent(
     watcherOptions,
     true /* isRenderWatcher */
   )
-  vm._scope.off()
   hydrating = false
 
   // flush buffer for flush: "pre" watchers queued in setup()
diff --git a/src/core/observer/watcher.ts b/src/core/observer/watcher.ts
index 00bf19b9123..b2989b53772 100644
--- a/src/core/observer/watcher.ts
+++ b/src/core/observer/watcher.ts
@@ -71,7 +71,16 @@ export default class Watcher implements DepTarget {
     options?: WatcherOptions | null,
     isRenderWatcher?: boolean
   ) {
-    recordEffectScope(this, activeEffectScope || (vm ? vm._scope : undefined))
+    recordEffectScope(
+      this,
+      // if the active effect scope is manually created (not a component scope),
+      // prioritize it
+      activeEffectScope && !activeEffectScope._vm
+        ? activeEffectScope
+        : vm
+        ? vm._scope
+        : undefined
+    )
     if ((this.vm = vm) && isRenderWatcher) {
       vm._watcher = this
     }
diff --git a/src/v3/reactivity/effectScope.ts b/src/v3/reactivity/effectScope.ts
index bc15380eb4a..2ba50cd9ca8 100644
--- a/src/v3/reactivity/effectScope.ts
+++ b/src/v3/reactivity/effectScope.ts
@@ -27,10 +27,14 @@ export class EffectScope {
    * @internal
    */
   scopes: EffectScope[] | undefined
+  /**
+   * indicates this being a component root scope
+   * @internal
+   */
+  _vm?: boolean
   /**
    * track a child scope's index in its parent's scopes array for optimized
    * removal
-   * @internal
    */
   private index: number | undefined
 

From 8521f9d3f63d26bde99b747f0cb14d0ac5ba5971 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 19 Aug 2022 12:22:51 +0800
Subject: [PATCH 272/317] fix(types): fix missing error for accessing undefined
 instance properties

fix #12718
---
 types/test/v3/define-component-test.tsx | 62 +++++++++++++++++++++++--
 types/v3-define-component.d.ts          | 10 ++--
 2 files changed, 64 insertions(+), 8 deletions(-)

diff --git a/types/test/v3/define-component-test.tsx b/types/test/v3/define-component-test.tsx
index 481a2d11ac7..7e6d1968ca3 100644
--- a/types/test/v3/define-component-test.tsx
+++ b/types/test/v3/define-component-test.tsx
@@ -1166,6 +1166,62 @@ defineComponent({
   }
 })
 
-// #12742 allow attaching custom properties (consistent with v3)
-const Foo = defineComponent({})
-Foo.foobar = 123
+describe('constructor attach custom properties', () => {
+  // #12742 allow attaching custom properties (consistent with v3)
+  const Foo = defineComponent({})
+  Foo.foobar = 123
+})
+
+describe('constructor instance type', () => {
+  const Comp = defineComponent({
+    data() {
+      return {
+        a: 1
+      }
+    },
+
+    computed: {
+      ac() {
+        return 1
+      }
+    },
+
+    methods: {
+      callA(b: number) {
+        return b
+      }
+    },
+
+    setup() {
+      return {
+        sa: '1'
+      }
+    }
+  })
+
+  const comp = new Comp()
+
+  expectType<number>(comp.a)
+  expectType<number>(comp.ac)
+  expectType<string>(comp.sa)
+  expectType<(b: number) => number>(comp.callA)
+})
+
+describe('should report non-existent properties in instance', () => {
+  const Foo = defineComponent({})
+  const instance = new Foo()
+  // @ts-expect-error
+  instance.foo
+
+  const Foo2 = defineComponent({
+    data() {
+      return {}
+    },
+    methods: {
+      example() {}
+    }
+  })
+  const instance2 = new Foo2()
+  // @ts-expect-error
+  instance2.foo
+})
diff --git a/types/v3-define-component.d.ts b/types/v3-define-component.d.ts
index 69f65a2ec35..03ef52d1856 100644
--- a/types/v3-define-component.d.ts
+++ b/types/v3-define-component.d.ts
@@ -72,7 +72,7 @@ export type DefineComponent<
  */
 export function defineComponent<
   RawBindings,
-  D = Data,
+  D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
   Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
@@ -101,8 +101,8 @@ export function defineComponent<
  */
 export function defineComponent<
   PropNames extends string,
-  RawBindings = Data,
-  D = Data,
+  RawBindings = {},
+  D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
   Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,
@@ -140,8 +140,8 @@ export function defineComponent<
  */
 export function defineComponent<
   Props,
-  RawBindings = Data,
-  D = Data,
+  RawBindings = {},
+  D = {},
   C extends ComputedOptions = {},
   M extends MethodOptions = {},
   Mixin extends ComponentOptionsMixin = ComponentOptionsMixin,

From 15618888cb6aae2b6f0151b32c261b1fc19db1b8 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 19 Aug 2022 12:27:12 +0800
Subject: [PATCH 273/317] release: v2.7.9

---
 CHANGELOG.md                            | 26 +++++++++++++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc98f138f33..b5d38472209 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,29 @@
+## [2.7.9](https://github.com/vuejs/vue/compare/v2.7.8...v2.7.9) (2022-08-19)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** allow full hostnames in asset url base ([#12732](https://github.com/vuejs/vue/issues/12732)) ([5c742eb](https://github.com/vuejs/vue/commit/5c742eb2e0d8dad268fb29ed4f92d286b5e0f4b5)), closes [#12731](https://github.com/vuejs/vue/issues/12731)
+* **compiler-sfc:** rewriteDefault for class with decorators ([#12747](https://github.com/vuejs/vue/issues/12747)) ([5221d4d](https://github.com/vuejs/vue/commit/5221d4d3b6049c87d196d99dbb64bcd3f3b07279))
+* directives shorthand normalize error ([#12744](https://github.com/vuejs/vue/issues/12744)) ([2263948](https://github.com/vuejs/vue/commit/2263948c249e7486403bc5880712e6d9fd15c17f)), closes [#12743](https://github.com/vuejs/vue/issues/12743)
+* ensure render watcher of manually created instance is correctly tracked in owner scope ([bd89ce5](https://github.com/vuejs/vue/commit/bd89ce53a9de417a9372630bb5d433a40acc1a53)), closes [#12701](https://github.com/vuejs/vue/issues/12701)
+* fix effect scope tracking for manually created instances ([7161176](https://github.com/vuejs/vue/commit/7161176cd0dff10d65ab58e266018aff2660610f)), closes [#12705](https://github.com/vuejs/vue/issues/12705)
+* **ssr:** fix on-component directives rendering ([#12661](https://github.com/vuejs/vue/issues/12661)) ([165a14a](https://github.com/vuejs/vue/commit/165a14a6c6c406176037465d2961259c5c980399)), closes [#10733](https://github.com/vuejs/vue/issues/10733)
+* **types:** allow attaching unknown options to defined component ([b4bf4c5](https://github.com/vuejs/vue/commit/b4bf4c52ad31e02307cfd4d643dc5610c893e3ba)), closes [#12742](https://github.com/vuejs/vue/issues/12742)
+* **types:** fix missing error for accessing undefined instance properties ([8521f9d](https://github.com/vuejs/vue/commit/8521f9d3f63d26bde99b747f0cb14d0ac5ba5971)), closes [#12718](https://github.com/vuejs/vue/issues/12718)
+* **types:** fix options suggestions when using defineComponent ([4b37b56](https://github.com/vuejs/vue/commit/4b37b568c7c3fd238aa61fcc956f882223f8e87f)), closes [#12736](https://github.com/vuejs/vue/issues/12736)
+* **types:** Make SetupBindings optional on ExtendedVue and CombinedVueInstance ([#12727](https://github.com/vuejs/vue/issues/12727)) ([00458cd](https://github.com/vuejs/vue/commit/00458cd38d209410d3c675729230a42a0a34a4b9)), closes [#12726](https://github.com/vuejs/vue/issues/12726) [#12717](https://github.com/vuejs/vue/issues/12717)
+* **watch:** avoid pre watcher firing on unmount ([f0057b1](https://github.com/vuejs/vue/commit/f0057b101e6451d5095cdb7fd6308fd31ac0450c)), closes [#12703](https://github.com/vuejs/vue/issues/12703)
+
+
+### Features
+
+* **types:** enhance type for onErrorCaptured ([#12735](https://github.com/vuejs/vue/issues/12735)) ([bba6b3d](https://github.com/vuejs/vue/commit/bba6b3d6b4e3e26d28abbf20e74ec2f3e64f1a92))
+* **types:** export DefineComponent ([80d1baf](https://github.com/vuejs/vue/commit/80d1baf92050da411fb1bfe714401c498001dd36)), closes [#12748](https://github.com/vuejs/vue/issues/12748)
+* **types:** support mixins inference for new Vue() ([#12737](https://github.com/vuejs/vue/issues/12737)) ([89a6b5e](https://github.com/vuejs/vue/commit/89a6b5e8658a6e3ae2cf649829901784ac9deb3c)), closes [#12730](https://github.com/vuejs/vue/issues/12730)
+
+
+
 ## [2.7.8](https://github.com/vuejs/vue/compare/v2.7.7...v2.7.8) (2022-07-22)
 
 
diff --git a/package.json b/package.json
index 039c8882375..0bbc17d6b0b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 6a6037a3111..3e88b96778c 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 5e8adfd83f6..784b7838cbe 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index d1be678cdfb..26bf6586f94 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 810f6d12edea47cde7f39eaf7ec3ae1b7300d40c Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Sun, 21 Aug 2022 19:28:39 -0700
Subject: [PATCH 274/317] fix(types): Add missing type parameter constraints
 (#12754)

---
 types/options.d.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/types/options.d.ts b/types/options.d.ts
index c82c6c5f8ae..9fcdaca624f 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -95,8 +95,8 @@ export type ThisTypedComponentOptionsWithArrayProps<
   Computed,
   PropNames extends string,
   SetupBindings,
-  Mixin,
-  Extends
+  Mixin extends ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin
 > = object &
   ComponentOptions<
     V,
@@ -132,8 +132,8 @@ export type ThisTypedComponentOptionsWithRecordProps<
   Computed,
   Props,
   SetupBindings,
-  Mixin,
-  Extends
+  Mixin extends ComponentOptionsMixin,
+  Extends extends ComponentOptionsMixin
 > = object &
   ComponentOptions<
     V,

From 46ca7bcddc06c50796ccff82d8c45693f1f14f47 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 23 Aug 2022 09:18:36 +0800
Subject: [PATCH 275/317] fix(compiler-sfc): avoid deindent when lang is
 jsx/tsx

fix #12755
---
 packages/compiler-sfc/src/parseComponent.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/compiler-sfc/src/parseComponent.ts b/packages/compiler-sfc/src/parseComponent.ts
index 65b858c9fc0..05489280e63 100644
--- a/packages/compiler-sfc/src/parseComponent.ts
+++ b/packages/compiler-sfc/src/parseComponent.ts
@@ -179,11 +179,11 @@ export function parseComponent(
       let text = source.slice(currentBlock.start, currentBlock.end)
       if (
         options.deindent === true ||
-        // by default, deindent unless it's script with default lang or ts
+        // by default, deindent unless it's script with default lang or (j/t)sx?
         (options.deindent !== false &&
           !(
             currentBlock.type === 'script' &&
-            (!currentBlock.lang || currentBlock.lang === 'ts')
+            (!currentBlock.lang || /^(j|t)sx?$/.test(currentBlock.lang))
           ))
       ) {
         text = deindent(text)

From e0b26c483a1ba407a818b1fcba1a439df24e84a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B8=8D=E8=A7=81=E6=9C=88?=
 <61452855+nooooooom@users.noreply.github.com>
Date: Tue, 23 Aug 2022 09:22:45 +0800
Subject: [PATCH 276/317] fix: fix parent of multi-nested HOC $el not updating
 (#12757)

fix #12589
---
 src/core/instance/lifecycle.ts                  | 11 +++++++++--
 test/unit/modules/vdom/patch/edge-cases.spec.ts |  4 ++++
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/core/instance/lifecycle.ts b/src/core/instance/lifecycle.ts
index df70b7113fd..94f42e27eb5 100644
--- a/src/core/instance/lifecycle.ts
+++ b/src/core/instance/lifecycle.ts
@@ -83,8 +83,15 @@ export function lifecycleMixin(Vue: typeof Component) {
       vm.$el.__vue__ = vm
     }
     // if parent is an HOC, update its $el as well
-    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
-      vm.$parent.$el = vm.$el
+    let wrapper: Component | undefined = vm
+    while (
+      wrapper &&
+      wrapper.$vnode &&
+      wrapper.$parent &&
+      wrapper.$vnode === wrapper.$parent._vnode
+    ) {
+      wrapper.$parent.$el = wrapper.$el
+      wrapper = wrapper.$parent
     }
     // updated hook is called by the scheduler to ensure that children are
     // updated in a parent's updated hook.
diff --git a/test/unit/modules/vdom/patch/edge-cases.spec.ts b/test/unit/modules/vdom/patch/edge-cases.spec.ts
index 10b8ad8179d..f9295533b1e 100644
--- a/test/unit/modules/vdom/patch/edge-cases.spec.ts
+++ b/test/unit/modules/vdom/patch/edge-cases.spec.ts
@@ -257,11 +257,15 @@ describe('vdom patch: edge cases', () => {
 
     expect(vm.$refs.foo.$refs.bar.$el.tagName).toBe('DIV')
     expect(vm.$refs.foo.$refs.bar.$el.className).toBe(`hello`)
+    expect(vm.$el.tagName).toBe('DIV')
+    expect(vm.$el.className).toBe(`hello`)
 
     vm.$refs.foo.$refs.bar.ok = false
     waitForUpdate(() => {
       expect(vm.$refs.foo.$refs.bar.$el.tagName).toBe('SPAN')
       expect(vm.$refs.foo.$refs.bar.$el.className).toBe(`hello`)
+      expect(vm.$el.tagName).toBe('SPAN')
+      expect(vm.$el.className).toBe(`hello`)
     }).then(done)
   })
 

From ee57d9fd1d51abe245c6c37e6f8f2d45977b929e Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 23 Aug 2022 09:29:42 +0800
Subject: [PATCH 277/317] release: v2.7.10

---
 CHANGELOG.md                            | 11 +++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b5d38472209..3ccae2540a9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+## [2.7.10](https://github.com/vuejs/vue/compare/v2.7.9...v2.7.10) (2022-08-23)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** avoid deindent when lang is jsx/tsx ([46ca7bc](https://github.com/vuejs/vue/commit/46ca7bcddc06c50796ccff82d8c45693f1f14f47)), closes [#12755](https://github.com/vuejs/vue/issues/12755)
+* fix parent of multi-nested HOC $el not updating ([#12757](https://github.com/vuejs/vue/issues/12757)) ([e0b26c4](https://github.com/vuejs/vue/commit/e0b26c483a1ba407a818b1fcba1a439df24e84a8)), closes [#12589](https://github.com/vuejs/vue/issues/12589)
+* **types:** Add missing type parameter constraints ([#12754](https://github.com/vuejs/vue/issues/12754)) ([810f6d1](https://github.com/vuejs/vue/commit/810f6d12edea47cde7f39eaf7ec3ae1b7300d40c))
+
+
+
 ## [2.7.9](https://github.com/vuejs/vue/compare/v2.7.8...v2.7.9) (2022-08-19)
 
 
diff --git a/package.json b/package.json
index 0bbc17d6b0b..e8750ff7385 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.9",
+  "version": "2.7.10",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 3e88b96778c..115ae6e775b 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.9",
+  "version": "2.7.10",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 784b7838cbe..5470ebfaca3 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.9",
+  "version": "2.7.10",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 26bf6586f94..75285bc0e85 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.9",
+  "version": "2.7.10",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From d189b4beaa90b9fe58fd3f66ba9e09d340755196 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 1 Sep 2022 14:30:09 +0800
Subject: [PATCH 278/317] chore: special sponsor [ci skip]

---
 README.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/README.md b/README.md
index 5eef53d3fa0..cfaef3e361e 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,16 @@ You are looking at the repository for Vue 2. The repo for Vue 3 is [vuejs/core](
 
 Vue.js is an MIT-licensed open source project with its ongoing development made possible entirely by the support of these awesome [backers](https://github.com/vuejs/core/blob/main/BACKERS.md). If you'd like to join them, please consider [ sponsor Vue's development](https://vuejs.org/sponsor/).
 
+<p align="center">
+  <h3 align="center">Special Sponsor</h3>
+</p>
+
+<p align="center">
+  <a target="_blank" href="https://github.com/appwrite/appwrite">
+  <img alt="special sponsor appwrite" src="https://sponsors.vuejs.org/images/appwrite.svg" width="300">
+  </a>
+</p>
+
 <p align="center">
   <a target="_blank" href="https://vuejs.org/sponsor/">
     <img alt="sponsors" src="https://sponsors.vuejs.org/sponsors.svg">

From 60d268c4261a0b9c5125f308468b31996a8145ad Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Thu, 1 Sep 2022 14:31:31 +0800
Subject: [PATCH 279/317] chore: cache bust svg [ci skip]

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index cfaef3e361e..bca41a49405 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@ Vue.js is an MIT-licensed open source project with its ongoing development made
 
 <p align="center">
   <a target="_blank" href="https://vuejs.org/sponsor/">
-    <img alt="sponsors" src="https://sponsors.vuejs.org/sponsors.svg">
+    <img alt="sponsors" src="https://sponsors.vuejs.org/sponsors.svg?v2">
   </a>
 </p>
 

From 2f335b2f9d09b962f40e38740826d444e4fff073 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 11:41:31 +0800
Subject: [PATCH 280/317] fix(sfc): remove sfc scoped deep syntax deprecation
 warnings

---
 .../compiler-sfc/src/stylePlugins/scoped.ts   | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/packages/compiler-sfc/src/stylePlugins/scoped.ts b/packages/compiler-sfc/src/stylePlugins/scoped.ts
index 25332731ef6..55f17c386f3 100644
--- a/packages/compiler-sfc/src/stylePlugins/scoped.ts
+++ b/packages/compiler-sfc/src/stylePlugins/scoped.ts
@@ -1,6 +1,5 @@
 import { PluginCreator, Rule, AtRule } from 'postcss'
 import selectorParser from 'postcss-selector-parser'
-import { warn } from '../warn'
 
 const animationNameRE = /^(-\w+-)?animation-name$/
 const animationRE = /^(-\w+-)?animation$/
@@ -94,10 +93,10 @@ function rewriteSelector(
     ) {
       n.value = ' '
       n.spaces.before = n.spaces.after = ''
-      warn(
-        `the >>> and /deep/ combinators have been deprecated. ` +
-          `Use :deep() instead.`
-      )
+      // warn(
+      //   `the >>> and /deep/ combinators have been deprecated. ` +
+      //     `Use :deep() instead.`
+      // )
       return false
     }
 
@@ -126,12 +125,12 @@ function rewriteSelector(
           }
           selector.removeChild(n)
         } else {
-          // DEPRECATED usage
+          // DEPRECATED usage in v3
           // .foo ::v-deep .bar -> .foo[xxxxxxx] .bar
-          warn(
-            `::v-deep usage as a combinator has ` +
-              `been deprecated. Use :deep(<inner-selector>) instead.`
-          )
+          // warn(
+          //   `::v-deep usage as a combinator has ` +
+          //     `been deprecated. Use :deep(<inner-selector>) instead.`
+          // )
           const prev = selector.at(selector.index(n) - 1)
           if (prev && isSpaceCombinator(prev)) {
             selector.removeChild(prev)

From 27eed829ccf9978a63b8cd989ff4c03897276bc2 Mon Sep 17 00:00:00 2001
From: ZHAO Jinxiang <xiaoxiangmoe@gmail.com>
Date: Mon, 10 Oct 2022 20:51:05 -0700
Subject: [PATCH 281/317] fix(types): vue 3 directive type compatibility
 (#12792)

---
 types/options.d.ts | 7 +++++++
 types/vue.d.ts     | 5 +++++
 2 files changed, 12 insertions(+)

diff --git a/types/options.d.ts b/types/options.d.ts
index 9fcdaca624f..93379edbef2 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -4,6 +4,7 @@ import { SetupContext } from './v3-setup-context'
 import { DebuggerEvent } from './v3-generated'
 import { DefineComponent } from './v3-define-component'
 import { ComponentOptionsMixin } from './v3-component-options'
+import { ObjectDirective, FunctionDirective } from './v3-directive'
 
 type Constructor = {
   new (...args: any[]): any
@@ -318,6 +319,9 @@ export interface DirectiveBinding extends Readonly<VNodeDirective> {
   readonly modifiers: { [key: string]: boolean }
 }
 
+/**
+ * @deprecated use {@link FunctionDirective} instead
+ */
 export type DirectiveFunction = (
   el: HTMLElement,
   binding: DirectiveBinding,
@@ -325,6 +329,9 @@ export type DirectiveFunction = (
   oldVnode: VNode
 ) => void
 
+/**
+ * @deprecated use {@link ObjectDirective} instead
+ */
 export interface DirectiveOptions {
   bind?: DirectiveFunction
   inserted?: DirectiveFunction
diff --git a/types/vue.d.ts b/types/vue.d.ts
index 5a2027a0179..f158cf01716 100644
--- a/types/vue.d.ts
+++ b/types/vue.d.ts
@@ -22,6 +22,7 @@ import {
   ExtractComputedReturns,
   ComponentOptionsMixin
 } from './v3-component-options'
+import { Directive, ObjectDirective } from './v3-directive'
 
 export interface CreateElement {
   (
@@ -338,6 +339,10 @@ export interface VueConstructor<V extends Vue = Vue> {
     id: string,
     definition?: DirectiveOptions | DirectiveFunction
   ): DirectiveOptions
+  directive(
+    id: string,
+    definition?: Directive
+  ): ObjectDirective
   filter(id: string, definition?: Function): Function
 
   component(id: string): VueConstructor

From 4a0d88e46e4180edc7f22e36c25df3f8ac5d60d2 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 12:26:19 +0800
Subject: [PATCH 282/317] fix(reactivity): use WeakMap for proxy/raw checks,
 compat with non-extensible objects

fix #12799
close #12798
---
 src/core/observer/index.ts                        |  4 +++-
 src/v3/reactivity/reactive.ts                     |  9 +++++++--
 src/v3/reactivity/readonly.ts                     | 10 +++++-----
 test/unit/features/v3/reactivity/reactive.spec.ts |  6 ++++++
 test/unit/features/v3/reactivity/readonly.spec.ts |  7 +++++++
 5 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 3770c489a9f..dcf6bde1e76 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -17,6 +17,7 @@ import {
   noop
 } from '../util/index'
 import { isReadonly, isRef, TrackOpTypes, TriggerOpTypes } from '../../v3'
+import { rawMap } from '../../v3/reactivity/reactive'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
@@ -118,7 +119,8 @@ export function observe(
     (ssrMockReactivity || !isServerRendering()) &&
     (isArray(value) || isPlainObject(value)) &&
     Object.isExtensible(value) &&
-    !value.__v_skip /* ReactiveFlags.SKIP */
+    !value.__v_skip /* ReactiveFlags.SKIP */ &&
+    !rawMap.has(value)
   ) {
     ob = new Observer(value, shallow, ssrMockReactivity)
   }
diff --git a/src/v3/reactivity/reactive.ts b/src/v3/reactivity/reactive.ts
index 0ff682243a2..c65f25e67d8 100644
--- a/src/v3/reactivity/reactive.ts
+++ b/src/v3/reactivity/reactive.ts
@@ -5,10 +5,13 @@ import {
   isPrimitive,
   warn,
   toRawType,
-  isServerRendering
+  isServerRendering,
+  isObject
 } from 'core/util'
 import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
 
+export const rawMap = new WeakMap()
+
 export const enum ReactiveFlags {
   SKIP = '__v_skip',
   IS_READONLY = '__v_isReadonly',
@@ -119,7 +122,9 @@ export function toRaw<T>(observed: T): T {
 export function markRaw<T extends object>(
   value: T
 ): T & { [RawSymbol]?: true } {
-  def(value, ReactiveFlags.SKIP, true)
+  if (isObject(value)) {
+    rawMap.set(value, true)
+  }
   return value
 }
 
diff --git a/src/v3/reactivity/readonly.ts b/src/v3/reactivity/readonly.ts
index 933f910b69f..c3794bb53b3 100644
--- a/src/v3/reactivity/readonly.ts
+++ b/src/v3/reactivity/readonly.ts
@@ -32,8 +32,8 @@ export type DeepReadonly<T> = T extends Builtin
   ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
   : Readonly<T>
 
-const rawToReadonlyFlag = `__v_rawToReadonly`
-const rawToShallowReadonlyFlag = `__v_rawToShallowReadonly`
+const rawToReadonlyMap = new WeakMap()
+const rawToShallowReadonlyMap = new WeakMap()
 
 export function readonly<T extends object>(
   target: T
@@ -63,14 +63,14 @@ function createReadonly(target: any, shallow: boolean) {
   }
 
   // already has a readonly proxy
-  const existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag
-  const existingProxy = target[existingFlag]
+  const map = shallow ? rawToShallowReadonlyMap : rawToReadonlyMap
+  const existingProxy = map.get(target)
   if (existingProxy) {
     return existingProxy
   }
 
   const proxy = Object.create(Object.getPrototypeOf(target))
-  def(target, existingFlag, proxy)
+  map.set(target, proxy)
 
   def(proxy, ReactiveFlags.IS_READONLY, true)
   def(proxy, ReactiveFlags.RAW, target)
diff --git a/test/unit/features/v3/reactivity/reactive.spec.ts b/test/unit/features/v3/reactivity/reactive.spec.ts
index f636d44d4a1..a8a30e0353c 100644
--- a/test/unit/features/v3/reactivity/reactive.spec.ts
+++ b/test/unit/features/v3/reactivity/reactive.spec.ts
@@ -258,6 +258,12 @@ describe('reactivity/reactive', () => {
     expect(isReactive(obj.bar)).toBe(false)
   })
 
+  test('markRaw on non-extensible objects', () => {
+    const foo = Object.freeze({})
+    markRaw(foo)
+    expect(isReactive(reactive(foo))).toBe(false)
+  })
+
   test('should not observe non-extensible objects', () => {
     const obj = reactive({
       foo: Object.preventExtensions({ a: 1 }),
diff --git a/test/unit/features/v3/reactivity/readonly.spec.ts b/test/unit/features/v3/reactivity/readonly.spec.ts
index 012e142d451..fab99bbfbcb 100644
--- a/test/unit/features/v3/reactivity/readonly.spec.ts
+++ b/test/unit/features/v3/reactivity/readonly.spec.ts
@@ -525,4 +525,11 @@ describe('reactivity/readonly', () => {
     expect(readonlyFoo.x).toBe(1)
     expect(`et operation on key "x" failed`).toHaveBeenWarned()
   })
+
+  test('compatibility with non-extensible objects', () => {
+    const foo = Object.freeze({ a: 1 })
+    const bar = readonly(foo)
+    expect(isReadonly(bar)).toBe(true)
+    expect(readonly(foo)).toBe(bar)
+  })
 })

From 5d26f815c643d41e6ca6f29329593223b981fc24 Mon Sep 17 00:00:00 2001
From: Xiersa <ltymxty@gmail.com>
Date: Tue, 11 Oct 2022 13:26:20 +0800
Subject: [PATCH 283/317] fix(reactivity): check skip first before checking ref
 when creating observer (#12813)

fix #12812
---
 src/core/observer/index.ts | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index dcf6bde1e76..51f928c5c24 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -7,7 +7,6 @@ import {
   hasOwn,
   isArray,
   hasProto,
-  isObject,
   isPlainObject,
   isPrimitive,
   isUndef,
@@ -108,23 +107,21 @@ export function observe(
   shallow?: boolean,
   ssrMockReactivity?: boolean
 ): Observer | void {
-  if (!isObject(value) || isRef(value) || value instanceof VNode) {
-    return
+  if (value && hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
+    return value.__ob__
   }
-  let ob: Observer | void
-  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
-    ob = value.__ob__
-  } else if (
+  if (
     shouldObserve &&
     (ssrMockReactivity || !isServerRendering()) &&
     (isArray(value) || isPlainObject(value)) &&
     Object.isExtensible(value) &&
     !value.__v_skip /* ReactiveFlags.SKIP */ &&
-    !rawMap.has(value)
+    !rawMap.has(value) &&
+    !isRef(value) &&
+    !(value instanceof VNode)
   ) {
-    ob = new Observer(value, shallow, ssrMockReactivity)
+    return new Observer(value, shallow, ssrMockReactivity)
   }
-  return ob
 }
 
 /**

From 87f69aa26f195390b948fbb0ff62cf954b58c82c Mon Sep 17 00:00:00 2001
From: Shiluo34 <shiluo34ccy@163.com>
Date: Tue, 11 Oct 2022 13:36:50 +0800
Subject: [PATCH 284/317] fix(types): support Ref and function types in tsx ref
 attribute (#12759)

fix #12758
---
 types/test/v3/tsx-test.tsx |  7 ++++++-
 types/vnode.d.ts           | 12 +++++++++++-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/types/test/v3/tsx-test.tsx b/types/test/v3/tsx-test.tsx
index 16a767acc5a..286c16997a0 100644
--- a/types/test/v3/tsx-test.tsx
+++ b/types/test/v3/tsx-test.tsx
@@ -1,4 +1,4 @@
-import { VNode, defineComponent } from '../../index'
+import { VNode, defineComponent, ref } from '../../index'
 import { expectType } from '../utils'
 
 expectType<VNode>(<div />)
@@ -22,6 +22,11 @@ expectError(<div foo="bar" />)
 expectType<JSX.Element>(<div key="foo" />)
 expectType<JSX.Element>(<div ref="bar" />)
 
+// allow Ref type type on arbitrary element
+const fooRef = ref<HTMLElement>()
+expectType<JSX.Element>(<div ref={fooRef} />)
+expectType<JSX.Element>(<div ref={(el) => {fooRef.value = el as HTMLElement}} />)
+
 expectType<JSX.Element>(
   <input
     onInput={e => {
diff --git a/types/vnode.d.ts b/types/vnode.d.ts
index 7a543f0a39b..29bdb398c1c 100644
--- a/types/vnode.d.ts
+++ b/types/vnode.d.ts
@@ -1,5 +1,7 @@
 import { Vue } from './vue'
 import { DirectiveFunction, DirectiveOptions } from './options'
+import { Ref } from './v3-generated'
+import { ComponentPublicInstance } from './v3-component-public-instance'
 
 /**
  * For extending allowed non-declared props on components in TSX
@@ -65,11 +67,19 @@ export interface VNodeComponentOptions {
   tag?: string
 }
 
+export type VNodeRef =
+  | string
+  | Ref
+  | ((
+      ref: Element | ComponentPublicInstance | null,
+      refs: Record<string, any>
+    ) => void)
+
 export interface VNodeData {
   key?: string | number
   slot?: string
   scopedSlots?: { [key: string]: ScopedSlot | undefined }
-  ref?: string
+  ref?: VNodeRef
   refInFor?: boolean
   tag?: string
   staticClass?: string

From fb1393009660b38046b1f6dfb532b481cc53b3b7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 14:09:10 +0800
Subject: [PATCH 285/317] fix(sfc): prune returned bindings for non-TS as well

In Vue 3, pruning is only done for TS to produce valid code and
tree-shaking is done by inlining the template for production.
In Vue 2 we do not inline the template in production, so return binding
pruning is needed in all cases.

fix #12765
---
 packages/compiler-sfc/src/compileScript.ts    | 36 +++++++++----------
 .../__snapshots__/compileScript.spec.ts.snap  |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 094120c38f7..7d171a9b78a 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -284,11 +284,9 @@ export function compileScript(
       userImportAlias[imported] = local
     }
 
-    // template usage check is only needed in non-inline mode, so we can skip
-    // the work if inlineTemplate is true.
     let isUsedInTemplate = true
-    if (isTS && sfc.template && !sfc.template.src && !sfc.template.lang) {
-      isUsedInTemplate = isImportUsed(local, sfc)
+    if (sfc.template && !sfc.template.src && !sfc.template.lang) {
+      isUsedInTemplate = isImportUsed(local, sfc, isTS)
     }
 
     userImports[local] = {
@@ -1782,7 +1780,7 @@ function getObjectOrArrayExpressionKeys(value: Node): string[] {
 
 const templateUsageCheckCache = new LRU<string, string>(512)
 
-function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
+function resolveTemplateUsageCheckString(sfc: SFCDescriptor, isTS: boolean) {
   const { content } = sfc.template!
   const cached = templateUsageCheckCache.get(content)
   if (cached) {
@@ -1809,7 +1807,7 @@ function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
             code += `,v${capitalize(camelize(baseName))}`
           }
           if (value) {
-            code += `,${processExp(value, baseName)}`
+            code += `,${processExp(value, isTS, baseName)}`
           }
         }
       }
@@ -1817,7 +1815,7 @@ function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
     chars(text) {
       const res = parseText(text)
       if (res) {
-        code += `,${processExp(res.expression)}`
+        code += `,${processExp(res.expression, isTS)}`
       }
     }
   })
@@ -1829,8 +1827,8 @@ function resolveTemplateUsageCheckString(sfc: SFCDescriptor) {
 
 const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/
 
-function processExp(exp: string, dir?: string): string {
-  if (/ as\s+\w|<.*>|:/.test(exp)) {
+function processExp(exp: string, isTS: boolean, dir?: string): string {
+  if (isTS && / as\s+\w|<.*>|:/.test(exp)) {
     if (dir === 'slot') {
       exp = `(${exp})=>{}`
     } else if (dir === 'on') {
@@ -1839,7 +1837,7 @@ function processExp(exp: string, dir?: string): string {
       const inMatch = exp.match(forAliasRE)
       if (inMatch) {
         const [, LHS, RHS] = inMatch
-        return processExp(`(${LHS})=>{}`) + processExp(RHS)
+        return processExp(`(${LHS})=>{}`, true) + processExp(RHS, true)
       }
     }
     let ret = ''
@@ -1867,36 +1865,38 @@ function stripTemplateString(str: string): string {
   return ''
 }
 
-function isImportUsed(local: string, sfc: SFCDescriptor): boolean {
+function isImportUsed(
+  local: string,
+  sfc: SFCDescriptor,
+  isTS: boolean
+): boolean {
   return new RegExp(
     // #4274 escape $ since it's a special char in regex
     // (and is the only regex special char that is valid in identifiers)
     `[^\\w$_]${local.replace(/\$/g, '\\$')}[^\\w$_]`
-  ).test(resolveTemplateUsageCheckString(sfc))
+  ).test(resolveTemplateUsageCheckString(sfc, isTS))
 }
 
 /**
  * Note: this comparison assumes the prev/next script are already identical,
- * and only checks the special case where <script setup lang="ts"> unused import
+ * and only checks the special case where <script setup> unused import
  * pruning result changes due to template changes.
  */
 export function hmrShouldReload(
   prevImports: Record<string, ImportBinding>,
   next: SFCDescriptor
 ): boolean {
-  if (
-    !next.scriptSetup ||
-    (next.scriptSetup.lang !== 'ts' && next.scriptSetup.lang !== 'tsx')
-  ) {
+  if (!next.scriptSetup) {
     return false
   }
 
+  const isTS = next.scriptSetup.lang === 'ts' || next.scriptSetup.lang === 'tsx'
   // for each previous import, check if its used status remain the same based on
   // the next descriptor's template
   for (const key in prevImports) {
     // if an import was previous unused, but now is used, we need to force
     // reload so that the script now includes that import.
-    if (!prevImports[key].isUsedInTemplate && isImportUsed(key, next)) {
+    if (!prevImports[key].isUsedInTemplate && isImportUsed(key, next, isTS)) {
       return true
     }
   }
diff --git a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
index 6bad46addbc..bb52a66b907 100644
--- a/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
+++ b/packages/compiler-sfc/test/__snapshots__/compileScript.spec.ts.snap
@@ -20,7 +20,7 @@ exports[`SFC analyze <script> bindings > auto name inference > do not overwrite
 export default /*#__PURE__*/Object.assign(__default__, {
   setup(__props) {
 const a = 1
-return { a, defineComponent }
+return { a }
 }
 
 })"

From bc5b92adde147436f2adb25e457f0c967829467f Mon Sep 17 00:00:00 2001
From: fukang wang <ssswfk@163.com>
Date: Tue, 11 Oct 2022 14:43:33 +0800
Subject: [PATCH 286/317] fix(types): fix error with options watch (#12779)

fix #12780
---
 types/options.d.ts         | 2 +-
 types/test/options-test.ts | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/types/options.d.ts b/types/options.d.ts
index 93379edbef2..19c339f7450 100644
--- a/types/options.d.ts
+++ b/types/options.d.ts
@@ -181,7 +181,7 @@ export interface ComponentOptions<
   propsData?: object
   computed?: Accessors<Computed>
   methods?: Methods
-  watch?: Record<string, WatchOptionsWithHandler<any> | WatchHandler<any>>
+  watch?: Record<string, WatchOptionsWithHandler<any> | WatchHandler<any> | Array<WatchOptionsWithHandler<any> | WatchHandler<any>>>
 
   setup?: (
     this: void,
diff --git a/types/test/options-test.ts b/types/test/options-test.ts
index 49deeb9ef44..8b724083709 100644
--- a/types/test/options-test.ts
+++ b/types/test/options-test.ts
@@ -172,7 +172,14 @@ Vue.component('component', {
     d: {
       handler: 'someMethod',
       immediate: true
-    }
+    },
+    e: [
+      'handle1',
+      function handle2 (val, oldVal) {},
+      {
+        handler: function handle3 (val, oldVal) {},
+      }
+    ],
   },
   el: '#app',
   template: '<div>{{ message }}</div>',

From 0d6d972b32521fd18eb853b1073c0a19859a499a Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 14:58:24 +0800
Subject: [PATCH 287/317] fix(compiler-sfc): export parseComponent for compat
 with fork-ts-checker-webpack-plugin

fix #12719
---
 packages/compiler-sfc/src/index.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/packages/compiler-sfc/src/index.ts b/packages/compiler-sfc/src/index.ts
index 7c665bddfab..fc050c52e57 100644
--- a/packages/compiler-sfc/src/index.ts
+++ b/packages/compiler-sfc/src/index.ts
@@ -6,6 +6,13 @@ export { compileScript } from './compileScript'
 export { generateCodeFrame } from 'compiler/codeframe'
 export { rewriteDefault } from './rewriteDefault'
 
+// For backwards compat only. Some existing tools like
+// fork-ts-checker-webpack-plugin relies on its presence for differentiating
+// between Vue 2 and Vue 3.
+// ref #12719
+// ref https://github.com/TypeStrong/fork-ts-checker-webpack-plugin/issues/765
+export { parseComponent } from './parseComponent'
+
 // types
 export { SFCParseOptions } from './parse'
 export { CompilerOptions, WarningMessage } from 'types/compiler'

From e1342df7847a51c75192fec74e94378178e046b0 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 16:23:08 +0800
Subject: [PATCH 288/317] fix(setup): setup hook should be called before
 beforeCreate

fix #12802

Note this commit moves the initialization of injections and props to
before the invocation of beforeCreate. This should not cause breakage
because props and inject normalization has always been done before
beforeCreate, so code that attempts to modifiy props/inject options
inside beforeCreate should have never worked.
---
 src/core/instance/init.ts              |  9 +++++++--
 src/core/instance/state.ts             |  9 ++-------
 test/unit/features/v3/apiSetup.spec.ts | 28 +++++++++++++++++++++++++-
 3 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 91456c21920..3fdfcf4f0cf 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -1,6 +1,6 @@
 import config from '../config'
 import { initProxy } from './proxy'
-import { initState } from './state'
+import { initProps, initState } from './state'
 import { initRender } from './render'
 import { initEvents } from './events'
 import { mark, measure } from '../util/perf'
@@ -10,6 +10,7 @@ import { extend, mergeOptions, formatComponentName } from '../util/index'
 import type { Component } from 'types/component'
 import type { InternalComponentOptions } from 'types/options'
 import { EffectScope } from 'v3/reactivity/effectScope'
+import { initSetup } from '../../v3/apiSetup'
 
 let uid = 0
 
@@ -59,8 +60,12 @@ export function initMixin(Vue: typeof Component) {
     initLifecycle(vm)
     initEvents(vm)
     initRender(vm)
-    callHook(vm, 'beforeCreate', undefined, false /* setContext */)
+
+    const opts = vm.$options
     initInjections(vm) // resolve injections before data/props
+    initProps(vm, opts.props)
+    initSetup(vm)
+    callHook(vm, 'beforeCreate', undefined, false /* setContext */)
     initState(vm)
     initProvide(vm) // resolve provide after data/props
     callHook(vm, 'created')
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index aedb72555c9..52b23cfd430 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -2,7 +2,6 @@ import config from '../config'
 import Watcher from '../observer/watcher'
 import Dep, { pushTarget, popTarget } from '../observer/dep'
 import { isUpdatingChildComponent } from './lifecycle'
-import { initSetup } from 'v3/apiSetup'
 
 import {
   set,
@@ -51,11 +50,6 @@ export function proxy(target: Object, sourceKey: string, key: string) {
 
 export function initState(vm: Component) {
   const opts = vm.$options
-  if (opts.props) initProps(vm, opts.props)
-
-  // Composition API
-  initSetup(vm)
-
   if (opts.methods) initMethods(vm, opts.methods)
   if (opts.data) {
     initData(vm)
@@ -69,7 +63,8 @@ export function initState(vm: Component) {
   }
 }
 
-function initProps(vm: Component, propsOptions: Object) {
+export function initProps(vm: Component, propsOptions: Object | undefined) {
+  if (!propsOptions) return
   const propsData = vm.$options.propsData || {}
   const props = (vm._props = shallowReactive({}))
   // cache prop keys so that future props updates can iterate using Array
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 11757878e9c..21b83769402 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -263,7 +263,7 @@ describe('api: setup context', () => {
     }).$mount()
     expect(spy).toHaveBeenCalled()
   })
-  
+
   // #12561
   it('setup props should be reactive', () => {
     const msg = ref('hi')
@@ -333,4 +333,30 @@ describe('api: setup context', () => {
     await nextTick()
     expect(_listeners.foo()).toBe(2)
   })
+
+  // #12802
+  it('should be called before all lifecycle hooks', () => {
+    const calls: string[] = []
+
+    Vue.mixin({
+      beforeCreate() {
+        calls.push('global beforeCreate')
+      }
+    })
+
+    new Vue({
+      beforeCreate() {
+        calls.push('component beforeCreate')
+      },
+      setup() {
+        calls.push('setup')
+      }
+    })
+
+    expect(calls).toEqual([
+      'setup',
+      'global beforeCreate',
+      'component beforeCreate'
+    ])
+  })
 })

From cc14d4452c66e90341b7f9a5cdd2b7acffa529e9 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 17:39:59 +0800
Subject: [PATCH 289/317] chore: bump build deps

---
 package.json                               |    6 +-
 packages/compiler-sfc/package.json         |    2 +-
 packages/compiler-sfc/src/compileScript.ts |   10 +-
 pnpm-lock.yaml                             | 1086 ++++++++++----------
 scripts/config.js                          |    9 +-
 5 files changed, 553 insertions(+), 560 deletions(-)

diff --git a/package.json b/package.json
index e8750ff7385..45728658733 100644
--- a/package.json
+++ b/package.json
@@ -117,15 +117,15 @@
     "prettier": "^2.6.2",
     "puppeteer": "^14.3.0",
     "rimraf": "^3.0.2",
-    "rollup": "^2.75.6",
-    "rollup-plugin-typescript2": "^0.31.2",
+    "rollup": "^2.79.1",
+    "rollup-plugin-typescript2": "^0.32.0",
     "semver": "^7.3.7",
     "shelljs": "^0.8.5",
     "terser": "^5.14.0",
     "todomvc-app-css": "^2.4.2",
     "ts-node": "^10.8.1",
     "tslib": "^2.4.0",
-    "typescript": "^4.7.3",
+    "typescript": "^4.8.4",
     "vitest": "^0.12.10",
     "yorkie": "^2.0.0"
   }
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 115ae6e775b..1cad61c2ec8 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -13,7 +13,7 @@
     "source-map": "^0.6.1"
   },
   "devDependencies": {
-    "@babel/types": "^7.18.4",
+    "@babel/types": "^7.19.4",
     "@types/estree": "^0.0.48",
     "@types/hash-sum": "^1.0.0",
     "@types/lru-cache": "^5.1.1",
diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 7d171a9b78a..548fc592423 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -780,7 +780,7 @@ export function compileScript(
     if (node.trailingComments && node.trailingComments.length > 0) {
       const lastCommentNode =
         node.trailingComments[node.trailingComments.length - 1]
-      end = lastCommentNode.end + startOffset
+      end = lastCommentNode.end! + startOffset
     }
     // locate the end of whitespace between this statement and the next
     while (end <= source.length) {
@@ -1582,14 +1582,18 @@ function extractEventNames(
   ) {
     const typeNode = eventName.typeAnnotation.typeAnnotation
     if (typeNode.type === 'TSLiteralType') {
-      if (typeNode.literal.type !== 'UnaryExpression') {
+      if (
+        typeNode.literal.type !== 'UnaryExpression' &&
+        typeNode.literal.type !== 'TemplateLiteral'
+      ) {
         emits.add(String(typeNode.literal.value))
       }
     } else if (typeNode.type === 'TSUnionType') {
       for (const t of typeNode.types) {
         if (
           t.type === 'TSLiteralType' &&
-          t.literal.type !== 'UnaryExpression'
+          t.literal.type !== 'UnaryExpression' &&
+          t.literal.type !== 'TemplateLiteral'
         ) {
           emits.add(String(t.literal.value))
         }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c7a00de93b5..41ea5a717eb 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -36,67 +36,67 @@ importers:
       prettier: ^2.6.2
       puppeteer: ^14.3.0
       rimraf: ^3.0.2
-      rollup: ^2.75.6
-      rollup-plugin-typescript2: ^0.31.2
+      rollup: ^2.79.1
+      rollup-plugin-typescript2: ^0.32.0
       semver: ^7.3.7
       shelljs: ^0.8.5
       terser: ^5.14.0
       todomvc-app-css: ^2.4.2
       ts-node: ^10.8.1
       tslib: ^2.4.0
-      typescript: ^4.7.3
+      typescript: ^4.8.4
       vitest: ^0.12.10
       yorkie: ^2.0.0
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
-      csstype: 3.1.0
+      csstype: 3.1.1
     devDependencies:
-      '@babel/parser': 7.18.4
-      '@microsoft/api-extractor': 7.25.0
-      '@rollup/plugin-alias': 3.1.9_rollup@2.75.6
-      '@rollup/plugin-commonjs': 22.0.0_rollup@2.75.6
-      '@rollup/plugin-node-resolve': 13.3.0_rollup@2.75.6
-      '@rollup/plugin-replace': 4.0.0_rollup@2.75.6
+      '@babel/parser': 7.19.4
+      '@microsoft/api-extractor': 7.32.1
+      '@rollup/plugin-alias': 3.1.9_rollup@2.79.1
+      '@rollup/plugin-commonjs': 22.0.2_rollup@2.79.1
+      '@rollup/plugin-node-resolve': 13.3.0_rollup@2.79.1
+      '@rollup/plugin-replace': 4.0.0_rollup@2.79.1
       '@types/he': 1.1.2
-      '@types/node': 17.0.41
+      '@types/node': 17.0.45
       chalk: 4.1.2
       conventional-changelog-cli: 2.2.2
       cross-spawn: 7.0.3
       enquirer: 2.3.6
-      esbuild: 0.14.43
+      esbuild: 0.14.54
       execa: 4.1.0
       he: 1.2.0
-      jasmine-core: 4.2.0
+      jasmine-core: 4.4.0
       jsdom: 19.0.0
-      karma: 6.3.20
+      karma: 6.4.1
       karma-chrome-launcher: 3.1.1
       karma-cli: 2.0.0
-      karma-esbuild: 2.2.4_esbuild@0.14.43
-      karma-jasmine: 5.0.1_karma@6.3.20
+      karma-esbuild: 2.2.5_esbuild@0.14.54
+      karma-jasmine: 5.1.0_karma@6.4.1
       lint-staged: 12.5.0_enquirer@2.3.6
       lodash: 4.17.21
-      marked: 4.0.16
-      minimist: 1.2.6
-      postcss: 8.4.14
-      prettier: 2.6.2
-      puppeteer: 14.3.0
+      marked: 4.1.1
+      minimist: 1.2.7
+      postcss: 8.4.17
+      prettier: 2.7.1
+      puppeteer: 14.4.1
       rimraf: 3.0.2
-      rollup: 2.75.6
-      rollup-plugin-typescript2: 0.31.2_fgms252lqu3rk7srzpqqayl4ya
-      semver: 7.3.7
+      rollup: 2.79.1
+      rollup-plugin-typescript2: 0.32.1_gypgyaqhine6mwjfvh7icfhviq
+      semver: 7.3.8
       shelljs: 0.8.5
-      terser: 5.14.0
+      terser: 5.15.1
       todomvc-app-css: 2.4.2
-      ts-node: 10.8.1_f5eqjuxkorpjvs4z7mviievvou
+      ts-node: 10.9.1_ksn4eycaeggbrckn3ykh37hwf4
       tslib: 2.4.0
-      typescript: 4.7.3
+      typescript: 4.8.4
       vitest: 0.12.10_jsdom@19.0.0
       yorkie: 2.0.0
 
   packages/compiler-sfc:
     specifiers:
       '@babel/parser': ^7.18.4
-      '@babel/types': ^7.18.4
+      '@babel/types': ^7.19.4
       '@types/estree': ^0.0.48
       '@types/hash-sum': ^1.0.0
       '@types/lru-cache': ^5.1.1
@@ -116,11 +116,11 @@ importers:
       source-map: ^0.6.1
       stylus: ^0.58.1
     dependencies:
-      '@babel/parser': 7.18.4
-      postcss: 8.4.14
+      '@babel/parser': 7.19.4
+      postcss: 8.4.17
       source-map: 0.6.1
     devDependencies:
-      '@babel/types': 7.18.4
+      '@babel/types': 7.19.4
       '@types/estree': 0.0.48
       '@types/hash-sum': 1.0.0
       '@types/lru-cache': 5.1.1
@@ -132,10 +132,10 @@ importers:
       lru-cache: 5.1.1
       magic-string: 0.25.9
       merge-source-map: 1.1.0
-      postcss-modules: 4.3.1_postcss@8.4.14
+      postcss-modules: 4.3.1_postcss@8.4.17
       postcss-selector-parser: 6.0.10
       pug: 3.0.2
-      sass: 1.52.3
+      sass: 1.55.0
       stylus: 0.58.1
 
   packages/server-renderer:
@@ -159,7 +159,7 @@ importers:
       he: 1.2.0
       lodash.template: 4.5.0
       lodash.uniq: 4.5.0
-      resolve: 1.22.0
+      resolve: 1.22.1
       serialize-javascript: 6.0.0
       source-map: 0.5.6
     devDependencies:
@@ -182,38 +182,43 @@ importers:
 
 packages:
 
-  /@babel/code-frame/7.16.7:
-    resolution: {integrity: sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg==}
+  /@babel/code-frame/7.18.6:
+    resolution: {integrity: sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/highlight': 7.17.12
+      '@babel/highlight': 7.18.6
     dev: true
 
-  /@babel/helper-validator-identifier/7.16.7:
-    resolution: {integrity: sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw==}
+  /@babel/helper-string-parser/7.19.4:
+    resolution: {integrity: sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw==}
     engines: {node: '>=6.9.0'}
 
-  /@babel/highlight/7.17.12:
-    resolution: {integrity: sha512-7yykMVF3hfZY2jsHZEEgLc+3x4o1O+fYyULu11GynEUQNwB6lua+IIQn1FiJxNucd5UlyJryrwsOh8PL9Sn8Qg==}
+  /@babel/helper-validator-identifier/7.19.1:
+    resolution: {integrity: sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==}
+    engines: {node: '>=6.9.0'}
+
+  /@babel/highlight/7.18.6:
+    resolution: {integrity: sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/helper-validator-identifier': 7.16.7
+      '@babel/helper-validator-identifier': 7.19.1
       chalk: 2.4.2
       js-tokens: 4.0.0
     dev: true
 
-  /@babel/parser/7.18.4:
-    resolution: {integrity: sha512-FDge0dFazETFcxGw/EXzOkN8uJp0PC7Qbm+Pe9T+av2zlBpOgunFHkQPPn+eRuClU73JF+98D531UgayY89tow==}
+  /@babel/parser/7.19.4:
+    resolution: {integrity: sha512-qpVT7gtuOLjWeDTKLkJ6sryqLliBaFpAtGeqw5cs5giLldvh+Ch0plqnUMKoVAUS6ZEueQQiZV+p5pxtPitEsA==}
     engines: {node: '>=6.0.0'}
     hasBin: true
     dependencies:
-      '@babel/types': 7.18.4
+      '@babel/types': 7.19.4
 
-  /@babel/types/7.18.4:
-    resolution: {integrity: sha512-ThN1mBcMq5pG/Vm2IcBmPPfyPXbd8S02rS+OBIDENdufvqC7Z/jHPCv9IcP01277aKtDI8g/2XysBN4hA8niiw==}
+  /@babel/types/7.19.4:
+    resolution: {integrity: sha512-M5LK7nAeS6+9j7hAq+b3fQs+pNfUtTGq+yFFfHnauFA8zQtLRfmuipmsKDKKLuyG+wC8ABW43A153YNawNTEtw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/helper-validator-identifier': 7.16.7
+      '@babel/helper-string-parser': 7.19.4
+      '@babel/helper-validator-identifier': 7.19.1
       to-fast-properties: 2.0.0
 
   /@colors/colors/1.5.0:
@@ -228,85 +233,94 @@ packages:
       '@jridgewell/trace-mapping': 0.3.9
     dev: true
 
+  /@esbuild/linux-loong64/0.14.54:
+    resolution: {integrity: sha512-bZBrLAIX1kpWelV0XemxBZllyRmM6vgFQQG2GdNb+r3Fkp0FOh1NJSvekXDs7jq70k4euu1cryLMfU+mTXlEpw==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
   /@hutson/parse-repository-url/3.0.2:
     resolution: {integrity: sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q==}
     engines: {node: '>=6.9.0'}
     dev: true
 
-  /@jridgewell/gen-mapping/0.3.1:
-    resolution: {integrity: sha512-GcHwniMlA2z+WFPWuY8lp3fsza0I8xPFMWL5+n8LYyP6PSvPrXf4+n8stDHZY2DM0zy9sVkRDy1jDI4XGzYVqg==}
+  /@jridgewell/gen-mapping/0.3.2:
+    resolution: {integrity: sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==}
     engines: {node: '>=6.0.0'}
     dependencies:
-      '@jridgewell/set-array': 1.1.1
-      '@jridgewell/sourcemap-codec': 1.4.13
-      '@jridgewell/trace-mapping': 0.3.13
+      '@jridgewell/set-array': 1.1.2
+      '@jridgewell/sourcemap-codec': 1.4.14
+      '@jridgewell/trace-mapping': 0.3.16
     dev: true
 
-  /@jridgewell/resolve-uri/3.0.7:
-    resolution: {integrity: sha512-8cXDaBBHOr2pQ7j77Y6Vp5VDT2sIqWyWQ56TjEq4ih/a4iST3dItRe8Q9fp0rrIl9DoKhWQtUQz/YpOxLkXbNA==}
+  /@jridgewell/resolve-uri/3.1.0:
+    resolution: {integrity: sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==}
     engines: {node: '>=6.0.0'}
     dev: true
 
-  /@jridgewell/set-array/1.1.1:
-    resolution: {integrity: sha512-Ct5MqZkLGEXTVmQYbGtx9SVqD2fqwvdubdps5D3djjAkgkKwT918VNOz65pEHFaYTeWcukmJmH5SwsA9Tn2ObQ==}
+  /@jridgewell/set-array/1.1.2:
+    resolution: {integrity: sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==}
     engines: {node: '>=6.0.0'}
     dev: true
 
   /@jridgewell/source-map/0.3.2:
     resolution: {integrity: sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==}
     dependencies:
-      '@jridgewell/gen-mapping': 0.3.1
-      '@jridgewell/trace-mapping': 0.3.13
+      '@jridgewell/gen-mapping': 0.3.2
+      '@jridgewell/trace-mapping': 0.3.16
     dev: true
 
-  /@jridgewell/sourcemap-codec/1.4.13:
-    resolution: {integrity: sha512-GryiOJmNcWbovBxTfZSF71V/mXbgcV3MewDe3kIMCLyIh5e7SKAeUZs+rMnJ8jkMolZ/4/VsdBmMrw3l+VdZ3w==}
+  /@jridgewell/sourcemap-codec/1.4.14:
+    resolution: {integrity: sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==}
     dev: true
 
-  /@jridgewell/trace-mapping/0.3.13:
-    resolution: {integrity: sha512-o1xbKhp9qnIAoHJSWd6KlCZfqslL4valSF81H8ImioOAxluWYWOpWkpyktY2vnt4tbrX9XYaxovq6cgowaJp2w==}
+  /@jridgewell/trace-mapping/0.3.16:
+    resolution: {integrity: sha512-LCQ+NeThyJ4k1W2d+vIKdxuSt9R3pQSZ4P92m7EakaYuXcVWbHuT5bjNcqLd4Rdgi6xYWYDvBJZJLZSLanjDcA==}
     dependencies:
-      '@jridgewell/resolve-uri': 3.0.7
-      '@jridgewell/sourcemap-codec': 1.4.13
+      '@jridgewell/resolve-uri': 3.1.0
+      '@jridgewell/sourcemap-codec': 1.4.14
     dev: true
 
   /@jridgewell/trace-mapping/0.3.9:
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
     dependencies:
-      '@jridgewell/resolve-uri': 3.0.7
-      '@jridgewell/sourcemap-codec': 1.4.13
+      '@jridgewell/resolve-uri': 3.1.0
+      '@jridgewell/sourcemap-codec': 1.4.14
     dev: true
 
-  /@microsoft/api-extractor-model/7.18.0:
-    resolution: {integrity: sha512-Q7ZhD6zKQd/J5ayNNChFCCgHZ8tw3ibljm6nXP/JEmiEFFbpKKtWMPVCaN8Y+8/qFmrz7mblLrupcKmUu8cF4A==}
+  /@microsoft/api-extractor-model/7.24.4:
+    resolution: {integrity: sha512-xYzRQqxurZVrmEM14BJ2aZqAUq+K46EAFj2Qlf0GkVPSFy1vP4Qf3sa2AbBi26Up2QsSicEVdqcd44eeVt9k9Q==}
     dependencies:
       '@microsoft/tsdoc': 0.14.1
-      '@microsoft/tsdoc-config': 0.16.1
-      '@rushstack/node-core-library': 3.45.5
+      '@microsoft/tsdoc-config': 0.16.2
+      '@rushstack/node-core-library': 3.53.1
     dev: true
 
-  /@microsoft/api-extractor/7.25.0:
-    resolution: {integrity: sha512-GS1XOY2RgLthUkfcTR4CLPvCIvpFYj+2MfJMZ3J4NX8H64BWSHGaDUvVV6QvjKNpt/RHdLyyJZ+j7dQveBAZnA==}
+  /@microsoft/api-extractor/7.32.1:
+    resolution: {integrity: sha512-bHijLt3MVIjrk7Uzu1mjvfM6IVt0kwZdBRLrYEnCLBnUqp4dxurV8NeKAovjUV68I70wVz/DMUlEofc4qh1CUA==}
     hasBin: true
     dependencies:
-      '@microsoft/api-extractor-model': 7.18.0
+      '@microsoft/api-extractor-model': 7.24.4
       '@microsoft/tsdoc': 0.14.1
-      '@microsoft/tsdoc-config': 0.16.1
-      '@rushstack/node-core-library': 3.45.5
-      '@rushstack/rig-package': 0.3.11
-      '@rushstack/ts-command-line': 4.11.0
+      '@microsoft/tsdoc-config': 0.16.2
+      '@rushstack/node-core-library': 3.53.1
+      '@rushstack/rig-package': 0.3.17
+      '@rushstack/ts-command-line': 4.12.5
       colors: 1.2.5
       lodash: 4.17.21
       resolve: 1.17.0
-      semver: 7.3.7
+      semver: 7.3.8
       source-map: 0.6.1
-      typescript: 4.6.4
+      typescript: 4.8.4
     dev: true
 
-  /@microsoft/tsdoc-config/0.16.1:
-    resolution: {integrity: sha512-2RqkwiD4uN6MLnHFljqBlZIXlt/SaUT6cuogU1w2ARw4nKuuppSmR0+s+NC+7kXBQykd9zzu0P4HtBpZT5zBpQ==}
+  /@microsoft/tsdoc-config/0.16.2:
+    resolution: {integrity: sha512-OGiIzzoBLgWWR0UdRJX98oYO+XKGf7tiK4Zk6tQ/E4IJqGCe7dvkTvgDZV5cFJUzLGDOjeAXrnZoA6QkVySuxw==}
     dependencies:
-      '@microsoft/tsdoc': 0.14.1
+      '@microsoft/tsdoc': 0.14.2
       ajv: 6.12.6
       jju: 1.4.0
       resolve: 1.19.0
@@ -316,58 +330,62 @@ packages:
     resolution: {integrity: sha512-6Wci+Tp3CgPt/B9B0a3J4s3yMgLNSku6w5TV6mN+61C71UqsRBv2FUibBf3tPGlNxebgPHMEUzKpb1ggE8KCKw==}
     dev: true
 
-  /@rollup/plugin-alias/3.1.9_rollup@2.75.6:
+  /@microsoft/tsdoc/0.14.2:
+    resolution: {integrity: sha512-9b8mPpKrfeGRuhFH5iO1iwCLeIIsV6+H1sRfxbkoGXIyQE2BTsPd9zqSqQJ+pv5sJ/hT5M1zvOFL02MnEezFug==}
+    dev: true
+
+  /@rollup/plugin-alias/3.1.9_rollup@2.79.1:
     resolution: {integrity: sha512-QI5fsEvm9bDzt32k39wpOwZhVzRcL5ydcffUHMyLVaVaLeC70I8TJZ17F1z1eMoLu4E/UOcH9BWVkKpIKdrfiw==}
     engines: {node: '>=8.0.0'}
     peerDependencies:
       rollup: ^1.20.0||^2.0.0
     dependencies:
-      rollup: 2.75.6
+      rollup: 2.79.1
       slash: 3.0.0
     dev: true
 
-  /@rollup/plugin-commonjs/22.0.0_rollup@2.75.6:
-    resolution: {integrity: sha512-Ktvf2j+bAO+30awhbYoCaXpBcyPmJbaEUYClQns/+6SNCYFURbvBiNbWgHITEsIgDDWCDUclWRKEuf8cwZCFoQ==}
+  /@rollup/plugin-commonjs/22.0.2_rollup@2.79.1:
+    resolution: {integrity: sha512-//NdP6iIwPbMTcazYsiBMbJW7gfmpHom33u1beiIoHDEM0Q9clvtQB1T0efvMqHeKsGohiHo97BCPCkBXdscwg==}
     engines: {node: '>= 12.0.0'}
     peerDependencies:
       rollup: ^2.68.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.75.6
+      '@rollup/pluginutils': 3.1.0_rollup@2.79.1
       commondir: 1.0.1
       estree-walker: 2.0.2
       glob: 7.2.3
       is-reference: 1.2.1
       magic-string: 0.25.9
-      resolve: 1.22.0
-      rollup: 2.75.6
+      resolve: 1.22.1
+      rollup: 2.79.1
     dev: true
 
-  /@rollup/plugin-node-resolve/13.3.0_rollup@2.75.6:
+  /@rollup/plugin-node-resolve/13.3.0_rollup@2.79.1:
     resolution: {integrity: sha512-Lus8rbUo1eEcnS4yTFKLZrVumLPY+YayBdWXgFSHYhTT2iJbMhoaaBL3xl5NCdeRytErGr8tZ0L71BMRmnlwSw==}
     engines: {node: '>= 10.0.0'}
     peerDependencies:
       rollup: ^2.42.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.75.6
+      '@rollup/pluginutils': 3.1.0_rollup@2.79.1
       '@types/resolve': 1.17.1
       deepmerge: 4.2.2
-      is-builtin-module: 3.1.0
+      is-builtin-module: 3.2.0
       is-module: 1.0.0
-      resolve: 1.22.0
-      rollup: 2.75.6
+      resolve: 1.22.1
+      rollup: 2.79.1
     dev: true
 
-  /@rollup/plugin-replace/4.0.0_rollup@2.75.6:
+  /@rollup/plugin-replace/4.0.0_rollup@2.79.1:
     resolution: {integrity: sha512-+rumQFiaNac9y64OHtkHGmdjm7us9bo1PlbgQfdihQtuNxzjpaB064HbRnewUOggLQxVCCyINfStkgmBeQpv1g==}
     peerDependencies:
       rollup: ^1.20.0 || ^2.0.0
     dependencies:
-      '@rollup/pluginutils': 3.1.0_rollup@2.75.6
+      '@rollup/pluginutils': 3.1.0_rollup@2.79.1
       magic-string: 0.25.9
-      rollup: 2.75.6
+      rollup: 2.79.1
     dev: true
 
-  /@rollup/pluginutils/3.1.0_rollup@2.75.6:
+  /@rollup/pluginutils/3.1.0_rollup@2.79.1:
     resolution: {integrity: sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==}
     engines: {node: '>= 8.0.0'}
     peerDependencies:
@@ -376,7 +394,7 @@ packages:
       '@types/estree': 0.0.39
       estree-walker: 1.0.1
       picomatch: 2.3.1
-      rollup: 2.75.6
+      rollup: 2.79.1
     dev: true
 
   /@rollup/pluginutils/4.2.1:
@@ -387,8 +405,8 @@ packages:
       picomatch: 2.3.1
     dev: true
 
-  /@rushstack/node-core-library/3.45.5:
-    resolution: {integrity: sha512-KbN7Hp9vH3bD3YJfv6RnVtzzTAwGYIBl7y2HQLY4WEQqRbvE3LgI78W9l9X+cTAXCX//p0EeoiUYNTFdqJrMZg==}
+  /@rushstack/node-core-library/3.53.1:
+    resolution: {integrity: sha512-hBpZmYNoyayl5H/SW7qLMIgylZvrf0BHKVA27gX43C7HB6e3AFNKGnj2dN/qKBXCwdhxw9OFYM+Gz5sqT3xeMw==}
     dependencies:
       '@types/node': 12.20.24
       colors: 1.2.5
@@ -396,20 +414,19 @@ packages:
       import-lazy: 4.0.0
       jju: 1.4.0
       resolve: 1.17.0
-      semver: 7.3.7
-      timsort: 0.3.0
-      z-schema: 5.0.3
+      semver: 7.3.8
+      z-schema: 5.0.4
     dev: true
 
-  /@rushstack/rig-package/0.3.11:
-    resolution: {integrity: sha512-uI1/g5oQPtyrT9nStoyX/xgZSLa2b+srRFaDk3r1eqC7zA5th4/bvTGl2QfV3C9NcP+coSqmk5mFJkUfH6i3Lw==}
+  /@rushstack/rig-package/0.3.17:
+    resolution: {integrity: sha512-nxvAGeIMnHl1LlZSQmacgcRV4y1EYtgcDIrw6KkeVjudOMonlxO482PhDj3LVZEp6L7emSf6YSO2s5JkHlwfZA==}
     dependencies:
       resolve: 1.17.0
       strip-json-comments: 3.1.1
     dev: true
 
-  /@rushstack/ts-command-line/4.11.0:
-    resolution: {integrity: sha512-ptG9L0mjvJ5QtK11GsAFY+jGfsnqHDS6CY6Yw1xT7a9bhjfNYnf6UPwjV+pF6UgiucfNcMDNW9lkDLxvZKKxMg==}
+  /@rushstack/ts-command-line/4.12.5:
+    resolution: {integrity: sha512-PCKrOu4RXKXPHcswHEQ9MYDW7Z7iQ+vbkvPtqHC46zFxD67ZCBXkm9P8QNOtED0cQzXh5nCtFnSOMuaOQf0GaQ==}
     dependencies:
       '@types/argparse': 1.0.38
       argparse: 1.0.10
@@ -417,25 +434,29 @@ packages:
       string-argv: 0.3.1
     dev: true
 
+  /@socket.io/component-emitter/3.1.0:
+    resolution: {integrity: sha512-+9jVqKhRSpsc591z5vX+X5Yyw+he/HCB4iQ/RYxw35CEPaY1gnsNE43nf9n9AaYjAQrTiI/mOwKUKdUs9vf7Xg==}
+    dev: true
+
   /@tootallnate/once/2.0.0:
     resolution: {integrity: sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==}
     engines: {node: '>= 10'}
     dev: true
 
-  /@tsconfig/node10/1.0.8:
-    resolution: {integrity: sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg==}
+  /@tsconfig/node10/1.0.9:
+    resolution: {integrity: sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==}
     dev: true
 
-  /@tsconfig/node12/1.0.9:
-    resolution: {integrity: sha512-/yBMcem+fbvhSREH+s14YJi18sp7J9jpuhYByADT2rypfajMZZN4WQ6zBGgBKp53NKmqI36wFYDb3yaMPurITw==}
+  /@tsconfig/node12/1.0.11:
+    resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==}
     dev: true
 
-  /@tsconfig/node14/1.0.1:
-    resolution: {integrity: sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg==}
+  /@tsconfig/node14/1.0.3:
+    resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==}
     dev: true
 
-  /@tsconfig/node16/1.0.2:
-    resolution: {integrity: sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA==}
+  /@tsconfig/node16/1.0.3:
+    resolution: {integrity: sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==}
     dev: true
 
   /@types/argparse/1.0.38:
@@ -445,15 +466,11 @@ packages:
   /@types/chai-subset/1.3.3:
     resolution: {integrity: sha512-frBecisrNGz+F4T6bcc+NLeolfiojh5FxW2klu669+8BARtyQv2C/GkNW6FUodVe4BroGMP/wER/YDGc7rEllw==}
     dependencies:
-      '@types/chai': 4.3.1
+      '@types/chai': 4.3.3
     dev: true
 
-  /@types/chai/4.3.1:
-    resolution: {integrity: sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ==}
-    dev: true
-
-  /@types/component-emitter/1.2.11:
-    resolution: {integrity: sha512-SRXjM+tfsSlA9VuG8hGO2nft2p8zjXCK1VcC6N4NXbBbYbSia9kzCChYQajIjzIqOOOuh5Ock6MmV2oux4jDZQ==}
+  /@types/chai/4.3.3:
+    resolution: {integrity: sha512-hC7OMnszpxhZPduX+m+nrx+uFoLkWOMiR4oa/AZF3MuSETYTZmFfJAHqZEM8MVlvfG7BEUcgvtwoCTxBp6hm3g==}
     dev: true
 
   /@types/cookie/0.4.1:
@@ -472,8 +489,8 @@ packages:
     resolution: {integrity: sha512-LfZwXoGUDo0C3me81HXgkBg5CTQYb6xzEl+fNmbO4JdRiSKQ8A0GD1OBBvKAIsbCUgoyAty7m99GqqMQe784ew==}
     dev: true
 
-  /@types/estree/0.0.51:
-    resolution: {integrity: sha512-CuPgU6f3eT/XgKKPqKd/gLZV1Xmvf1a2R5POBOGQa6uv82xpls89HU5zKeVoyR8XzHd1RGNOlQlvUe3CFkjWNQ==}
+  /@types/estree/1.0.0:
+    resolution: {integrity: sha512-WulqXMDUTYAXCjZnk6JtIHPigp55cVtDgDrO2gHRwhyJto21+1zbVCtOYB2L1F9w4qCQ0rOGWBnBe0FNTiEJIQ==}
     dev: true
 
   /@types/hash-sum/1.0.0:
@@ -496,12 +513,12 @@ packages:
     resolution: {integrity: sha512-yxDeaQIAJlMav7fH5AQqPH1u8YIuhYJXYBzxaQ4PifsU0GDO38MSdmEDeRlIxrKbC6NbEaaEHDanWb+y30U8SQ==}
     dev: true
 
-  /@types/node/17.0.36:
-    resolution: {integrity: sha512-V3orv+ggDsWVHP99K3JlwtH20R7J4IhI1Kksgc+64q5VxgfRkQG8Ws3MFm/FZOKDYGy9feGFlZ70/HpCNe9QaA==}
+  /@types/node/17.0.45:
+    resolution: {integrity: sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==}
     dev: true
 
-  /@types/node/17.0.41:
-    resolution: {integrity: sha512-xA6drNNeqb5YyV5fO3OAEsnXLfO7uF0whiOfPTz5AeDo8KeZFmODKnvwPymMNO8qE/an8pVY/O50tig2SQCrGw==}
+  /@types/node/18.8.4:
+    resolution: {integrity: sha512-WdlVphvfR/GJCLEMbNA8lJ0lhFNBj4SW3O+O5/cEGw9oYrv0al9zTwuQsq+myDUXgNx2jgBynoVgZ2MMJ6pbow==}
     dev: true
 
   /@types/normalize-package-data/2.4.1:
@@ -511,7 +528,7 @@ packages:
   /@types/resolve/1.17.1:
     resolution: {integrity: sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==}
     dependencies:
-      '@types/node': 17.0.41
+      '@types/node': 17.0.45
     dev: true
 
   /@types/source-list-map/0.1.2:
@@ -522,8 +539,8 @@ packages:
     resolution: {integrity: sha512-ipixuVrh2OdNmauvtT51o3d8z12p6LtFW9in7U79der/kwejjdNchQC5UMn5u/KxNoM7VHHOs/l8KS8uHxhODQ==}
     dev: true
 
-  /@types/uglify-js/3.13.2:
-    resolution: {integrity: sha512-/xFrPIo+4zOeNGtVMbf9rUm0N+i4pDf1ynExomqtokIJmVzR3962lJ1UE+MmexMkA0cmN9oTzg5Xcbwge0Ij2Q==}
+  /@types/uglify-js/3.17.0:
+    resolution: {integrity: sha512-3HO6rm0y+/cqvOyA8xcYLweF0TKXlAxmQASjbOi49Co51A1N4nR4bEwBgRoD9kNM+rqFGArjKr654SLp2CoGmQ==}
     dependencies:
       source-map: 0.6.1
     dev: true
@@ -531,17 +548,17 @@ packages:
   /@types/webpack-sources/3.2.0:
     resolution: {integrity: sha512-Ft7YH3lEVRQ6ls8k4Ff1oB4jN6oy/XmU6tQISKdhfh+1mR+viZFphS6WL0IrtDOzvefmJg5a0s7ZQoRXwqTEFg==}
     dependencies:
-      '@types/node': 17.0.36
+      '@types/node': 18.8.4
       '@types/source-list-map': 0.1.2
-      source-map: 0.7.3
+      source-map: 0.7.4
     dev: true
 
   /@types/webpack/4.41.32:
     resolution: {integrity: sha512-cb+0ioil/7oz5//7tZUSwbrSAN/NWHrQylz5cW8G0dWTcF/g+/dSdMlKVZspBYuMAN1+WnwHrkxiRrLcwd0Heg==}
     dependencies:
-      '@types/node': 17.0.36
+      '@types/node': 18.8.4
       '@types/tapable': 1.0.8
-      '@types/uglify-js': 3.13.2
+      '@types/uglify-js': 3.17.0
       '@types/webpack-sources': 3.2.0
       anymatch: 3.1.2
       source-map: 0.6.1
@@ -551,7 +568,7 @@ packages:
     resolution: {integrity: sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==}
     requiresBuild: true
     dependencies:
-      '@types/node': 17.0.41
+      '@types/node': 17.0.45
     dev: true
     optional: true
 
@@ -695,14 +712,6 @@ packages:
     resolution: {integrity: sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==}
     dev: true
 
-  /@yarn-tool/resolve-package/1.0.47:
-    resolution: {integrity: sha512-Zaw58gQxjQceJqhqybJi1oUDaORT8i2GTgwICPs8v/X/Pkx35FXQba69ldHVg5pQZ6YLKpROXgyHvBaCJOFXiA==}
-    dependencies:
-      pkg-dir: 5.0.0
-      tslib: 2.4.0
-      upath2: 3.1.13
-    dev: true
-
   /JSONStream/1.3.5:
     resolution: {integrity: sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==}
     hasBin: true
@@ -752,8 +761,8 @@ packages:
     hasBin: true
     dev: true
 
-  /acorn/8.7.1:
-    resolution: {integrity: sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A==}
+  /acorn/8.8.0:
+    resolution: {integrity: sha512-QOxyigPVrpZ2GXT+PFyZTl6TtOFc5egxHIP9IlQ+RbupQuX4RkT/Bee4/kQuC02Xkzg84JcT7oLYtDIQxp+v7w==}
     engines: {node: '>=0.4.0'}
     hasBin: true
     dev: true
@@ -839,8 +848,8 @@ packages:
     dependencies:
       color-convert: 2.0.1
 
-  /ansi-styles/6.1.0:
-    resolution: {integrity: sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ==}
+  /ansi-styles/6.2.0:
+    resolution: {integrity: sha512-3MWBO/XxbkDtc/qpECaUwDM0DQ++ujBjdjs0ElZvChUoPv/P7GOnl3x+R2RF2My5UJHEW5R87q556MiR8U3PLw==}
     engines: {node: '>=12'}
     dev: true
 
@@ -962,7 +971,7 @@ packages:
     resolution: {integrity: sha512-GAwkz0AihzY5bkwIY5QDR+LvsRQgB/B+1foMPvi0FZPMl5fjD7ICiznUiBdLYMH1QYe6vqu4gWYytZOccLouFw==}
     engines: {node: '>= 10.0.0'}
     dependencies:
-      '@babel/types': 7.18.4
+      '@babel/types': 7.19.4
     dev: true
 
   /balanced-match/1.0.2:
@@ -1033,8 +1042,8 @@ packages:
     resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==}
     dev: true
 
-  /body-parser/1.20.0:
-    resolution: {integrity: sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg==}
+  /body-parser/1.20.1:
+    resolution: {integrity: sha512-jWi7abTbYwajOytWCQc37VulmWiRae5RyTpaCyDcS5/lMdtwSz5lOpDE67srw/HYe35f1z3fDQw+3txg7gNtWw==}
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
     dependencies:
       bytes: 3.1.2
@@ -1045,7 +1054,7 @@ packages:
       http-errors: 2.0.0
       iconv-lite: 0.4.24
       on-finished: 2.4.1
-      qs: 6.10.3
+      qs: 6.11.0
       raw-body: 2.5.1
       type-is: 1.6.18
       unpipe: 1.0.0
@@ -1228,7 +1237,7 @@ packages:
     resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
     dependencies:
       function-bind: 1.1.1
-      get-intrinsic: 1.1.1
+      get-intrinsic: 1.1.3
     dev: true
 
   /camelcase-keys/6.2.2:
@@ -1414,8 +1423,8 @@ packages:
   /color-name/1.1.4:
     resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
 
-  /colorette/2.0.16:
-    resolution: {integrity: sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g==}
+  /colorette/2.0.19:
+    resolution: {integrity: sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==}
     dev: true
 
   /colors/1.2.5:
@@ -1434,8 +1443,8 @@ packages:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
     dev: true
 
-  /commander/9.3.0:
-    resolution: {integrity: sha512-hv95iU5uXPbK83mjrJKuZyFM/LBAoCV/XhVGkS5Je6tl7sxr6A0ITMw5WoRV46/UaJ46Nllm3Xt7IaJhXTIkzw==}
+  /commander/9.4.1:
+    resolution: {integrity: sha512-5EEkTNyHNGFPD2H+c/dXXfQZYa/scCKasxWcXJaWnNJ99pnQN9Vnmqow+p+PlFPE63Q6mThaZws1T+HxfpgtPw==}
     engines: {node: ^12.20.0 || >=14}
     dev: true
 
@@ -1487,8 +1496,8 @@ packages:
   /constantinople/4.0.1:
     resolution: {integrity: sha512-vCrqcSIq4//Gx74TXXCGnHpulY1dskqLTFGDmhrGxzeXL8lF8kvXv6mpNWlJj1uD4DW23D4ljAqbY4RRaaUZIw==}
     dependencies:
-      '@babel/parser': 7.18.4
-      '@babel/types': 7.18.4
+      '@babel/parser': 7.19.4
+      '@babel/types': 7.19.4
     dev: true
 
   /constants-browserify/1.0.0:
@@ -1650,8 +1659,8 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
-      is-text-path: 1.0.1
       JSONStream: 1.3.5
+      is-text-path: 1.0.1
       lodash: 4.17.21
       meow: 8.1.2
       split2: 3.2.2
@@ -1799,8 +1808,8 @@ packages:
       cssom: 0.3.8
     dev: true
 
-  /csstype/3.1.0:
-    resolution: {integrity: sha512-uX1KG+x9h5hIJsaKR9xHUeUraxf8IODOwq9JLNPq6BwB04a/xgpq3rcx47l5BZu5zBPlgD342tdke3Hom/nJRA==}
+  /csstype/3.1.1:
+    resolution: {integrity: sha512-DJR/VvkAvSZW9bTouZue2sSxDwdTN92uHjqeKVm+0dAqdfNykRzQ95tay8aXMBAAPpUiq4Qcug2L7neoRh2Egw==}
 
   /custom-event/1.0.1:
     resolution: {integrity: sha512-GAj5FOq0Hd+RsCGVJxZuKaIDXDf3h6GQoNEjFgbLLI/trgtavwUbSnZ5pVfg27DVCaWjIohryS0JFwIJyT2cMg==}
@@ -1824,8 +1833,8 @@ packages:
       whatwg-url: 11.0.0
     dev: true
 
-  /date-format/4.0.10:
-    resolution: {integrity: sha512-RuMIHocrVjF84bUSTcd1uokIsLsOsk1Awb7TexNOI3f48ukCu39mjslWquDTA08VaDMF2umr3MB9ow5EyJTWyA==}
+  /date-format/4.0.14:
+    resolution: {integrity: sha512-39BOQLs9ZjKh0/patS9nrT8wc3ioX3/eA/zgbKNopnF2wCqJEoxywwwElATYvRsXdnOxA/OQeQoFZ3rFjVajhg==}
     engines: {node: '>=4.0'}
     dev: true
 
@@ -1855,7 +1864,7 @@ packages:
       supports-color:
         optional: true
     dependencies:
-      ms: 2.1.2
+      ms: 2.1.3
     dev: true
     optional: true
 
@@ -1871,7 +1880,7 @@ packages:
       ms: 2.1.2
     dev: true
 
-  /debug/4.3.4_supports-color@9.2.2:
+  /debug/4.3.4_supports-color@9.2.3:
     resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
     engines: {node: '>=6.0'}
     peerDependencies:
@@ -1881,7 +1890,7 @@ packages:
         optional: true
     dependencies:
       ms: 2.1.2
-      supports-color: 9.2.2
+      supports-color: 9.2.3
     dev: true
 
   /decamelize-keys/1.1.0:
@@ -1897,8 +1906,8 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /decimal.js/10.3.1:
-    resolution: {integrity: sha512-V0pfhfr8suzyPGOx3nmq4aHqabehUZn6Ch9kyFpV79TGDTWFmHqUqXdabR7QHqxzrYolF4+tVmJhUG4OURg5dQ==}
+  /decimal.js/10.4.1:
+    resolution: {integrity: sha512-F29o+vci4DodHYT9UrR5IEbfBw9pE5eSapIJdTqXK5+6hq+t8VRxwQyKlW2i+KDKFkkJQRvFyI/QXD83h8LyQw==}
     dev: true
 
   /decode-uri-component/0.2.0:
@@ -2083,7 +2092,7 @@ packages:
     dependencies:
       '@types/cookie': 0.4.1
       '@types/cors': 2.8.12
-      '@types/node': 17.0.41
+      '@types/node': 17.0.45
       accepts: 1.3.8
       base64id: 2.0.0
       cookie: 0.4.2
@@ -2130,8 +2139,8 @@ packages:
       is-arrayish: 0.2.1
     dev: true
 
-  /esbuild-android-64/0.14.43:
-    resolution: {integrity: sha512-kqFXAS72K6cNrB6RiM7YJ5lNvmWRDSlpi7ZuRZ1hu1S3w0zlwcoCxWAyM23LQUyZSs1PbjHgdbbfYAN8IGh6xg==}
+  /esbuild-android-64/0.14.54:
+    resolution: {integrity: sha512-Tz2++Aqqz0rJ7kYBfz+iqyE3QMycD4vk7LBRyWaAVFgFtQ/O8EJOnVmTOiDWYZ/uYzB4kvP+bqejYdVKzE5lAQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [android]
@@ -2139,8 +2148,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-android-arm64/0.14.43:
-    resolution: {integrity: sha512-bKS2BBFh+7XZY9rpjiHGRNA7LvWYbZWP87pLehggTG7tTaCDvj8qQGOU/OZSjCSKDYbgY7Q+oDw8RlYQ2Jt2BA==}
+  /esbuild-android-arm64/0.14.54:
+    resolution: {integrity: sha512-F9E+/QDi9sSkLaClO8SOV6etqPd+5DgJje1F9lOWoNncDdOBL2YF59IhsWATSt0TLZbYCf3pNlTHvVV5VfHdvg==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [android]
@@ -2148,8 +2157,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-darwin-64/0.14.43:
-    resolution: {integrity: sha512-/3PSilx011ttoieRGkSZ0XV8zjBf2C9enV4ScMMbCT4dpx0mFhMOpFnCHkOK0pWGB8LklykFyHrWk2z6DENVUg==}
+  /esbuild-darwin-64/0.14.54:
+    resolution: {integrity: sha512-jtdKWV3nBviOd5v4hOpkVmpxsBy90CGzebpbO9beiqUYVMBtSc0AL9zGftFuBon7PNDcdvNCEuQqw2x0wP9yug==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [darwin]
@@ -2157,8 +2166,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-darwin-arm64/0.14.43:
-    resolution: {integrity: sha512-1HyFUKs8DMCBOvw1Qxpr5Vv/ThNcVIFb5xgXWK3pyT40WPvgYIiRTwJCvNs4l8i5qWF8/CK5bQxJVDjQvtv0Yw==}
+  /esbuild-darwin-arm64/0.14.54:
+    resolution: {integrity: sha512-OPafJHD2oUPyvJMrsCvDGkRrVCar5aVyHfWGQzY1dWnzErjrDuSETxwA2HSsyg2jORLY8yBfzc1MIpUkXlctmw==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [darwin]
@@ -2166,8 +2175,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-freebsd-64/0.14.43:
-    resolution: {integrity: sha512-FNWc05TPHYgaXjbPZO5/rJKSBslfG6BeMSs8GhwnqAKP56eEhvmzwnIz1QcC9cRVyO+IKqWNfmHFkCa1WJTULA==}
+  /esbuild-freebsd-64/0.14.54:
+    resolution: {integrity: sha512-OKwd4gmwHqOTp4mOGZKe/XUlbDJ4Q9TjX0hMPIDBUWWu/kwhBAudJdBoxnjNf9ocIB6GN6CPowYpR/hRCbSYAg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [freebsd]
@@ -2175,8 +2184,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-freebsd-arm64/0.14.43:
-    resolution: {integrity: sha512-amrYopclz3VohqisOPR6hA3GOWA3LZC1WDLnp21RhNmoERmJ/vLnOpnrG2P/Zao+/erKTCUqmrCIPVtj58DRoA==}
+  /esbuild-freebsd-arm64/0.14.54:
+    resolution: {integrity: sha512-sFwueGr7OvIFiQT6WeG0jRLjkjdqWWSrfbVwZp8iMP+8UHEHRBvlaxL6IuKNDwAozNUmbb8nIMXa7oAOARGs1Q==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [freebsd]
@@ -2184,8 +2193,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-32/0.14.43:
-    resolution: {integrity: sha512-KoxoEra+9O3AKVvgDFvDkiuddCds6q71owSQEYwjtqRV7RwbPzKxJa6+uyzUulHcyGVq0g15K0oKG5CFBcvYDw==}
+  /esbuild-linux-32/0.14.54:
+    resolution: {integrity: sha512-1ZuY+JDI//WmklKlBgJnglpUL1owm2OX+8E1syCD6UAxcMM/XoWd76OHSjl/0MR0LisSAXDqgjT3uJqT67O3qw==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [linux]
@@ -2193,8 +2202,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-64/0.14.43:
-    resolution: {integrity: sha512-EwINwGMyiJMgBby5/SbMqKcUhS5AYAZ2CpEBzSowsJPNBJEdhkCTtEjk757TN/wxgbu3QklqDM6KghY660QCUw==}
+  /esbuild-linux-64/0.14.54:
+    resolution: {integrity: sha512-EgjAgH5HwTbtNsTqQOXWApBaPVdDn7XcK+/PtJwZLT1UmpLoznPd8c5CxqsH2dQK3j05YsB3L17T8vE7cp4cCg==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [linux]
@@ -2202,8 +2211,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-arm/0.14.43:
-    resolution: {integrity: sha512-e6YzQUoDxxtyamuF12eVzzRC7bbEFSZohJ6igQB9tBqnNmIQY3fI6Cns3z2wxtbZ3f2o6idkD2fQnlvs2902Dg==}
+  /esbuild-linux-arm/0.14.54:
+    resolution: {integrity: sha512-qqz/SjemQhVMTnvcLGoLOdFpCYbz4v4fUo+TfsWG+1aOu70/80RV6bgNpR2JCrppV2moUQkww+6bWxXRL9YMGw==}
     engines: {node: '>=12'}
     cpu: [arm]
     os: [linux]
@@ -2211,8 +2220,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-arm64/0.14.43:
-    resolution: {integrity: sha512-UlSpjMWllAc70zYbHxWuDS3FJytyuR/gHJYBr8BICcTNb/TSOYVBg6U7b3jZ3mILTrgzwJUHwhEwK18FZDouUQ==}
+  /esbuild-linux-arm64/0.14.54:
+    resolution: {integrity: sha512-WL71L+0Rwv+Gv/HTmxTEmpv0UgmxYa5ftZILVi2QmZBgX3q7+tDeOQNqGtdXSdsL8TQi1vIaVFHUPDe0O0kdig==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [linux]
@@ -2220,8 +2229,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-mips64le/0.14.43:
-    resolution: {integrity: sha512-f+v8cInPEL1/SDP//CfSYzcDNgE4CY3xgDV81DWm3KAPWzhvxARrKxB1Pstf5mB56yAslJDxu7ryBUPX207EZA==}
+  /esbuild-linux-mips64le/0.14.54:
+    resolution: {integrity: sha512-qTHGQB8D1etd0u1+sB6p0ikLKRVuCWhYQhAHRPkO+OF3I/iSlTKNNS0Lh2Oc0g0UFGguaFZZiPJdJey3AGpAlw==}
     engines: {node: '>=12'}
     cpu: [mips64el]
     os: [linux]
@@ -2229,8 +2238,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-ppc64le/0.14.43:
-    resolution: {integrity: sha512-5wZYMDGAL/K2pqkdIsW+I4IR41kyfHr/QshJcNpUfK3RjB3VQcPWOaZmc+74rm4ZjVirYrtz+jWw0SgxtxRanA==}
+  /esbuild-linux-ppc64le/0.14.54:
+    resolution: {integrity: sha512-j3OMlzHiqwZBDPRCDFKcx595XVfOfOnv68Ax3U4UKZ3MTYQB5Yz3X1mn5GnodEVYzhtZgxEBidLWeIs8FDSfrQ==}
     engines: {node: '>=12'}
     cpu: [ppc64]
     os: [linux]
@@ -2238,8 +2247,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-riscv64/0.14.43:
-    resolution: {integrity: sha512-lYcAOUxp85hC7lSjycJUVSmj4/9oEfSyXjb/ua9bNl8afonaduuqtw7hvKMoKuYnVwOCDw4RSfKpcnIRDWq+Bw==}
+  /esbuild-linux-riscv64/0.14.54:
+    resolution: {integrity: sha512-y7Vt7Wl9dkOGZjxQZnDAqqn+XOqFD7IMWiewY5SPlNlzMX39ocPQlOaoxvT4FllA5viyV26/QzHtvTjVNOxHZg==}
     engines: {node: '>=12'}
     cpu: [riscv64]
     os: [linux]
@@ -2247,8 +2256,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-linux-s390x/0.14.43:
-    resolution: {integrity: sha512-27e43ZhHvhFE4nM7HqtUbMRu37I/4eNSUbb8FGZWszV+uLzMIsHDwLoBiJmw7G9N+hrehNPeQ4F5Ujad0DrUKQ==}
+  /esbuild-linux-s390x/0.14.54:
+    resolution: {integrity: sha512-zaHpW9dziAsi7lRcyV4r8dhfG1qBidQWUXweUjnw+lliChJqQr+6XD71K41oEIC3Mx1KStovEmlzm+MkGZHnHA==}
     engines: {node: '>=12'}
     cpu: [s390x]
     os: [linux]
@@ -2256,8 +2265,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-netbsd-64/0.14.43:
-    resolution: {integrity: sha512-2mH4QF6hHBn5zzAfxEI/2eBC0mspVsZ6UVo821LpAJKMvLJPBk3XJO5xwg7paDqSqpl7p6IRrAenW999AEfJhQ==}
+  /esbuild-netbsd-64/0.14.54:
+    resolution: {integrity: sha512-PR01lmIMnfJTgeU9VJTDY9ZerDWVFIUzAtJuDHwwceppW7cQWjBBqP48NdeRtoP04/AtO9a7w3viI+PIDr6d+w==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [netbsd]
@@ -2265,8 +2274,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-openbsd-64/0.14.43:
-    resolution: {integrity: sha512-ZhQpiZjvqCqO8jKdGp9+8k9E/EHSA+zIWOg+grwZasI9RoblqJ1QiZqqi7jfd6ZrrG1UFBNGe4m0NFxCFbMVbg==}
+  /esbuild-openbsd-64/0.14.54:
+    resolution: {integrity: sha512-Qyk7ikT2o7Wu76UsvvDS5q0amJvmRzDyVlL0qf5VLsLchjCa1+IAvd8kTBgUxD7VBUUVgItLkk609ZHUc1oCaw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [openbsd]
@@ -2274,8 +2283,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-sunos-64/0.14.43:
-    resolution: {integrity: sha512-DgxSi9DaHReL9gYuul2rrQCAapgnCJkh3LSHPKsY26zytYppG0HgkgVF80zjIlvEsUbGBP/GHQzBtrezj/Zq1Q==}
+  /esbuild-sunos-64/0.14.54:
+    resolution: {integrity: sha512-28GZ24KmMSeKi5ueWzMcco6EBHStL3B6ubM7M51RmPwXQGLe0teBGJocmWhgwccA1GeFXqxzILIxXpHbl9Q/Kw==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [sunos]
@@ -2283,8 +2292,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-32/0.14.43:
-    resolution: {integrity: sha512-Ih3+2O5oExiqm0mY6YYE5dR0o8+AspccQ3vIAtRodwFvhuyGLjb0Hbmzun/F3Lw19nuhPMu3sW2fqIJ5xBxByw==}
+  /esbuild-windows-32/0.14.54:
+    resolution: {integrity: sha512-T+rdZW19ql9MjS7pixmZYVObd9G7kcaZo+sETqNH4RCkuuYSuv9AGHUVnPoP9hhuE1WM1ZimHz1CIBHBboLU7w==}
     engines: {node: '>=12'}
     cpu: [ia32]
     os: [win32]
@@ -2292,8 +2301,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-64/0.14.43:
-    resolution: {integrity: sha512-8NsuNfI8xwFuJbrCuI+aBqNTYkrWErejFO5aYM+yHqyHuL8mmepLS9EPzAzk8rvfaJrhN0+RvKWAcymViHOKEw==}
+  /esbuild-windows-64/0.14.54:
+    resolution: {integrity: sha512-AoHTRBUuYwXtZhjXZbA1pGfTo8cJo3vZIcWGLiUcTNgHpJJMC1rVA44ZereBHMJtotyN71S8Qw0npiCIkW96cQ==}
     engines: {node: '>=12'}
     cpu: [x64]
     os: [win32]
@@ -2301,8 +2310,8 @@ packages:
     dev: true
     optional: true
 
-  /esbuild-windows-arm64/0.14.43:
-    resolution: {integrity: sha512-7ZlD7bo++kVRblJEoG+cepljkfP8bfuTPz5fIXzptwnPaFwGS6ahvfoYzY7WCf5v/1nX2X02HDraVItTgbHnKw==}
+  /esbuild-windows-arm64/0.14.54:
+    resolution: {integrity: sha512-M0kuUvXhot1zOISQGXwWn6YtS+Y/1RT9WrVIOywZnJHo3jCDyewAc79aKNQWFCQm+xNHVTq9h8dZKvygoXQQRg==}
     engines: {node: '>=12'}
     cpu: [arm64]
     os: [win32]
@@ -2310,32 +2319,33 @@ packages:
     dev: true
     optional: true
 
-  /esbuild/0.14.43:
-    resolution: {integrity: sha512-Uf94+kQmy/5jsFwKWiQB4hfo/RkM9Dh7b79p8yqd1tshULdr25G2szLz631NoH3s2ujnKEKVD16RmOxvCNKRFA==}
+  /esbuild/0.14.54:
+    resolution: {integrity: sha512-Cy9llcy8DvET5uznocPyqL3BFRrFXSVqbgpMJ9Wz8oVjZlh/zUSNbPRbov0VX7VxN2JH1Oa0uNxZ7eLRb62pJA==}
     engines: {node: '>=12'}
     hasBin: true
     requiresBuild: true
     optionalDependencies:
-      esbuild-android-64: 0.14.43
-      esbuild-android-arm64: 0.14.43
-      esbuild-darwin-64: 0.14.43
-      esbuild-darwin-arm64: 0.14.43
-      esbuild-freebsd-64: 0.14.43
-      esbuild-freebsd-arm64: 0.14.43
-      esbuild-linux-32: 0.14.43
-      esbuild-linux-64: 0.14.43
-      esbuild-linux-arm: 0.14.43
-      esbuild-linux-arm64: 0.14.43
-      esbuild-linux-mips64le: 0.14.43
-      esbuild-linux-ppc64le: 0.14.43
-      esbuild-linux-riscv64: 0.14.43
-      esbuild-linux-s390x: 0.14.43
-      esbuild-netbsd-64: 0.14.43
-      esbuild-openbsd-64: 0.14.43
-      esbuild-sunos-64: 0.14.43
-      esbuild-windows-32: 0.14.43
-      esbuild-windows-64: 0.14.43
-      esbuild-windows-arm64: 0.14.43
+      '@esbuild/linux-loong64': 0.14.54
+      esbuild-android-64: 0.14.54
+      esbuild-android-arm64: 0.14.54
+      esbuild-darwin-64: 0.14.54
+      esbuild-darwin-arm64: 0.14.54
+      esbuild-freebsd-64: 0.14.54
+      esbuild-freebsd-arm64: 0.14.54
+      esbuild-linux-32: 0.14.54
+      esbuild-linux-64: 0.14.54
+      esbuild-linux-arm: 0.14.54
+      esbuild-linux-arm64: 0.14.54
+      esbuild-linux-mips64le: 0.14.54
+      esbuild-linux-ppc64le: 0.14.54
+      esbuild-linux-riscv64: 0.14.54
+      esbuild-linux-s390x: 0.14.54
+      esbuild-netbsd-64: 0.14.54
+      esbuild-openbsd-64: 0.14.54
+      esbuild-sunos-64: 0.14.54
+      esbuild-windows-32: 0.14.54
+      esbuild-windows-64: 0.14.54
+      esbuild-windows-arm64: 0.14.54
     dev: true
 
   /escalade/3.1.1:
@@ -2642,16 +2652,8 @@ packages:
       path-exists: 4.0.0
     dev: true
 
-  /find-up/5.0.0:
-    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
-    engines: {node: '>=10'}
-    dependencies:
-      locate-path: 6.0.0
-      path-exists: 4.0.0
-    dev: true
-
-  /flatted/3.2.5:
-    resolution: {integrity: sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg==}
+  /flatted/3.2.7:
+    resolution: {integrity: sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==}
     dev: true
 
   /flush-write-stream/1.1.1:
@@ -2661,8 +2663,8 @@ packages:
       readable-stream: 2.3.7
     dev: true
 
-  /follow-redirects/1.15.1:
-    resolution: {integrity: sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA==}
+  /follow-redirects/1.15.2:
+    resolution: {integrity: sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==}
     engines: {node: '>=4.0'}
     peerDependencies:
       debug: '*'
@@ -2721,6 +2723,15 @@ packages:
       universalify: 0.1.2
     dev: true
 
+  /fs-extra/8.1.0:
+    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
+    engines: {node: '>=6 <7 || >=8'}
+    dependencies:
+      graceful-fs: 4.2.10
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+    dev: true
+
   /fs-write-stream-atomic/1.0.10:
     resolution: {integrity: sha512-gehEzmPn2nAwr39eay+x3X34Ra+M2QlVUTLhkXPjWdeO8RF9kszk116avgBJM3ZyNHgHXBNx+VmPaFC36k0PzA==}
     dependencies:
@@ -2742,7 +2753,7 @@ packages:
     requiresBuild: true
     dependencies:
       bindings: 1.5.0
-      nan: 2.16.0
+      nan: 2.17.0
     dev: true
     optional: true
 
@@ -2772,8 +2783,8 @@ packages:
     resolution: {integrity: sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==}
     dev: true
 
-  /get-intrinsic/1.1.1:
-    resolution: {integrity: sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==}
+  /get-intrinsic/1.1.3:
+    resolution: {integrity: sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A==}
     dependencies:
       function-bind: 1.1.1
       has: 1.0.3
@@ -2883,12 +2894,12 @@ packages:
     engines: {node: '>=0.4.7'}
     hasBin: true
     dependencies:
-      minimist: 1.2.6
+      minimist: 1.2.7
       neo-async: 2.6.2
       source-map: 0.6.1
       wordwrap: 1.0.0
     optionalDependencies:
-      uglify-js: 3.15.5
+      uglify-js: 3.17.3
     dev: true
 
   /hard-rejection/2.1.0:
@@ -3030,7 +3041,7 @@ packages:
     engines: {node: '>=8.0.0'}
     dependencies:
       eventemitter3: 4.0.7
-      follow-redirects: 1.15.1
+      follow-redirects: 1.15.2
       requires-port: 1.0.0
     transitivePeerDependencies:
       - debug
@@ -3078,13 +3089,13 @@ packages:
     resolution: {integrity: sha512-chIaY3Vh2mh2Q3RGXttaDIzeiPvaVXJ+C4DAh/w3c37SKZ/U6PGMmuicR2EQQp9bKG8zLMCl7I+PtIoOOPp8Gg==}
     dev: true
 
-  /icss-utils/5.1.0_postcss@8.4.14:
+  /icss-utils/5.1.0_postcss@8.4.17:
     resolution: {integrity: sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==}
     engines: {node: ^10 || ^12 || >= 14}
     peerDependencies:
       postcss: ^8.1.0
     dependencies:
-      postcss: 8.4.14
+      postcss: 8.4.17
     dev: true
 
   /ieee754/1.2.1:
@@ -3191,8 +3202,8 @@ packages:
     resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==}
     dev: true
 
-  /is-builtin-module/3.1.0:
-    resolution: {integrity: sha512-OV7JjAgOTfAFJmHZLvpSTb4qi0nIILDV1gWPYDnDJUTNFM5aGlRAhk4QcT8i7TuAleeEV5Fdkqn3t4mS+Q11fg==}
+  /is-builtin-module/3.2.0:
+    resolution: {integrity: sha512-phDA4oSGt7vl1n5tJvTWooWWAsXLY+2xCnxNqvKhGEzujg+A43wPlPOyDg3C8XQHN+6k/JTQWJ/j0dQh/qr+Hw==}
     engines: {node: '>=6'}
     dependencies:
       builtin-modules: 3.3.0
@@ -3205,8 +3216,8 @@ packages:
       ci-info: 1.6.0
     dev: true
 
-  /is-core-module/2.9.0:
-    resolution: {integrity: sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A==}
+  /is-core-module/2.10.0:
+    resolution: {integrity: sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==}
     dependencies:
       has: 1.0.3
 
@@ -3335,7 +3346,7 @@ packages:
   /is-reference/1.2.1:
     resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
     dependencies:
-      '@types/estree': 0.0.51
+      '@types/estree': 1.0.0
     dev: true
 
   /is-regex/1.1.4:
@@ -3402,8 +3413,8 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /jasmine-core/4.2.0:
-    resolution: {integrity: sha512-OcFpBrIhnbmb9wfI8cqPSJ50pv3Wg4/NSgoZIqHzIwO/2a9qivJWzv8hUvaREIMYYJBas6AvfXATFdVuzzCqVw==}
+  /jasmine-core/4.4.0:
+    resolution: {integrity: sha512-+l482uImx5BVd6brJYlaHe2UwfKoZBqQfNp20ZmdNfsjGFTemGfqHLsXjKEW23w9R/m8WYeFc9JmIgjj6dUtAA==}
     dev: true
 
   /jju/1.4.0:
@@ -3428,12 +3439,12 @@ packages:
         optional: true
     dependencies:
       abab: 2.0.6
-      acorn: 8.7.1
+      acorn: 8.8.0
       acorn-globals: 6.0.0
       cssom: 0.5.0
       cssstyle: 2.3.0
       data-urls: 3.0.2
-      decimal.js: 10.3.1
+      decimal.js: 10.4.1
       domexception: 4.0.0
       escodegen: 2.0.0
       form-data: 4.0.0
@@ -3441,18 +3452,18 @@ packages:
       http-proxy-agent: 5.0.0
       https-proxy-agent: 5.0.1
       is-potential-custom-element-name: 1.0.1
-      nwsapi: 2.2.0
+      nwsapi: 2.2.2
       parse5: 6.0.1
       saxes: 5.0.1
       symbol-tree: 3.2.4
-      tough-cookie: 4.0.0
+      tough-cookie: 4.1.2
       w3c-hr-time: 1.0.2
       w3c-xmlserializer: 3.0.0
       webidl-conversions: 7.0.0
       whatwg-encoding: 2.0.0
       whatwg-mimetype: 3.0.0
       whatwg-url: 10.0.0
-      ws: 8.7.0
+      ws: 8.9.0
       xml-name-validator: 4.0.0
     transitivePeerDependencies:
       - bufferutil
@@ -3480,7 +3491,7 @@ packages:
     resolution: {integrity: sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow==}
     hasBin: true
     dependencies:
-      minimist: 1.2.6
+      minimist: 1.2.7
     dev: true
 
   /jsonfile/4.0.0:
@@ -3520,36 +3531,36 @@ packages:
     engines: {node: '>= 6'}
     hasBin: true
     dependencies:
-      resolve: 1.22.0
+      resolve: 1.22.1
     dev: true
 
-  /karma-esbuild/2.2.4_esbuild@0.14.43:
-    resolution: {integrity: sha512-nt5+AJ0iFpgJXboBmXvwjM5LYTqTmFA9NuNGj9A442gCMJHwL4Eft4JUBVRc7ORSPoJAQ26Kgf5252Xt6GbkRw==}
+  /karma-esbuild/2.2.5_esbuild@0.14.54:
+    resolution: {integrity: sha512-+NiRmZhUm/MqOsL1cAu8+RmiOMvIxWDaeYDLBB5upxHF9Hh3Og8YH43EAmDan40pxt2FKDcOjupgqIe4Tx2szQ==}
     peerDependencies:
       esbuild: '>=0.8.45'
     dependencies:
       chokidar: 3.5.3
-      esbuild: 0.14.43
+      esbuild: 0.14.54
       source-map: 0.6.1
     dev: true
 
-  /karma-jasmine/5.0.1_karma@6.3.20:
-    resolution: {integrity: sha512-FkL1Kk+JAKmim8VWU8RXKZBpl0lLI7J8LijM0/q7oP7emfB6QMZV1Az+JgqGKSLpF0tYaav+KUVFQroZUxQTHA==}
+  /karma-jasmine/5.1.0_karma@6.4.1:
+    resolution: {integrity: sha512-i/zQLFrfEpRyQoJF9fsCdTMOF5c2dK7C7OmsuKg2D0YSsuZSfQDiLuaiktbuio6F2wiCsZSnSnieIQ0ant/uzQ==}
     engines: {node: '>=12'}
     peerDependencies:
       karma: ^6.0.0
     dependencies:
-      jasmine-core: 4.2.0
-      karma: 6.3.20
+      jasmine-core: 4.4.0
+      karma: 6.4.1
     dev: true
 
-  /karma/6.3.20:
-    resolution: {integrity: sha512-HRNQhMuKOwKpjYlWiJP0DUrJOh+QjaI/DTaD8b9rEm4Il3tJ8MijutVZH4ts10LuUFst/CedwTS6vieCN8yTSw==}
+  /karma/6.4.1:
+    resolution: {integrity: sha512-Cj57NKOskK7wtFWSlMvZf459iX+kpYIPXmkNUzP2WAFcA7nhr/ALn5R7sw3w+1udFDcpMx/tuB8d5amgm3ijaA==}
     engines: {node: '>= 10'}
     hasBin: true
     dependencies:
       '@colors/colors': 1.5.0
-      body-parser: 1.20.0
+      body-parser: 1.20.1
       braces: 3.0.2
       chokidar: 3.5.3
       connect: 3.7.0
@@ -3560,14 +3571,14 @@ packages:
       http-proxy: 1.18.1
       isbinaryfile: 4.0.10
       lodash: 4.17.21
-      log4js: 6.5.2
+      log4js: 6.7.0
       mime: 2.6.0
       minimatch: 3.1.2
       mkdirp: 0.5.6
       qjobs: 1.2.0
       range-parser: 1.2.1
       rimraf: 3.0.2
-      socket.io: 4.5.1
+      socket.io: 4.5.2
       source-map: 0.6.1
       tmp: 0.2.1
       ua-parser-js: 0.7.31
@@ -3646,9 +3657,9 @@ packages:
     hasBin: true
     dependencies:
       cli-truncate: 3.1.0
-      colorette: 2.0.16
-      commander: 9.3.0
-      debug: 4.3.4_supports-color@9.2.2
+      colorette: 2.0.19
+      commander: 9.4.1
+      debug: 4.3.4_supports-color@9.2.3
       execa: 5.1.1
       lilconfig: 2.0.5
       listr2: 4.0.5_enquirer@2.3.6
@@ -3657,7 +3668,7 @@ packages:
       object-inspect: 1.12.2
       pidtree: 0.5.0
       string-argv: 0.3.1
-      supports-color: 9.2.2
+      supports-color: 9.2.3
       yaml: 1.10.2
     transitivePeerDependencies:
       - enquirer
@@ -3673,12 +3684,12 @@ packages:
         optional: true
     dependencies:
       cli-truncate: 2.1.0
-      colorette: 2.0.16
+      colorette: 2.0.19
       enquirer: 2.3.6
       log-update: 4.0.0
       p-map: 4.0.0
       rfdc: 1.3.0
-      rxjs: 7.5.5
+      rxjs: 7.5.7
       through: 2.3.8
       wrap-ansi: 7.0.0
     dev: true
@@ -3712,8 +3723,8 @@ packages:
     engines: {node: '>= 12.13.0'}
     dev: true
 
-  /local-pkg/0.4.1:
-    resolution: {integrity: sha512-lL87ytIGP2FU5PWwNDo0w3WhIo2gopIAxPg9RxDYF7m4rr5ahuZxP22xnJHIvaLTe4Z9P6uKKY2UHiwyB4pcrw==}
+  /local-pkg/0.4.2:
+    resolution: {integrity: sha512-mlERgSPrbxU3BP4qBqAvvwlgW4MTg78iwJdGGnv7kibKjWcJksrG3t6LB5lXI93wXRDvG4NpUgJFmTG4T6rdrg==}
     engines: {node: '>=14'}
     dev: true
 
@@ -3740,13 +3751,6 @@ packages:
       p-locate: 4.1.0
     dev: true
 
-  /locate-path/6.0.0:
-    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
-    engines: {node: '>=10'}
-    dependencies:
-      p-locate: 5.0.0
-    dev: true
-
   /lodash._reinterpolate/3.0.0:
     resolution: {integrity: sha512-xYHt68QRoYGjeeM/XOE1uJtvXQAgvszfBhjV4yvsQH0u2i9I6cI6c6/eG4Hh3UAOVn0y/xAXwmTzEay49Q//HA==}
     dev: false
@@ -3798,15 +3802,15 @@ packages:
       wrap-ansi: 6.2.0
     dev: true
 
-  /log4js/6.5.2:
-    resolution: {integrity: sha512-DXtpNtt+KDOMT7RHUDIur/WsSA3rntlUh9Zg4XCdV42wUuMmbFkl38+LZ92Z5QvQA7mD5kAVkLiBSEH/tvUB8A==}
+  /log4js/6.7.0:
+    resolution: {integrity: sha512-KA0W9ffgNBLDj6fZCq/lRbgR6ABAodRIDHrZnS48vOtfKa4PzWImb0Md1lmGCdO3n3sbCm/n1/WmrNlZ8kCI3Q==}
     engines: {node: '>=8.0'}
     dependencies:
-      date-format: 4.0.10
+      date-format: 4.0.14
       debug: 4.3.4
-      flatted: 3.2.5
+      flatted: 3.2.7
       rfdc: 1.3.0
-      streamroller: 3.1.1
+      streamroller: 3.1.3
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -3884,8 +3888,8 @@ packages:
       object-visit: 1.0.1
     dev: true
 
-  /marked/4.0.16:
-    resolution: {integrity: sha512-wahonIQ5Jnyatt2fn8KqF/nIqZM8mh3oRu2+l5EANGMhu6RFjiSG52QNE2eWzFMI94HqYSgN184NurgNG6CztA==}
+  /marked/4.1.1:
+    resolution: {integrity: sha512-0cNMnTcUJPxbA6uWmCmjWz4NJRe/0Xfk2NhXCUHjew9qJzFN20krFnsUe7QynwqOwa5m1fZ4UDg0ycKFVC0ccw==}
     engines: {node: '>= 12'}
     hasBin: true
     dev: true
@@ -4041,8 +4045,8 @@ packages:
       kind-of: 6.0.3
     dev: true
 
-  /minimist/1.2.6:
-    resolution: {integrity: sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q==}
+  /minimist/1.2.7:
+    resolution: {integrity: sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g==}
     dev: true
 
   /mississippi/3.0.0:
@@ -4077,7 +4081,7 @@ packages:
     resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
     hasBin: true
     dependencies:
-      minimist: 1.2.6
+      minimist: 1.2.7
     dev: true
 
   /modify-values/1.0.1:
@@ -4097,15 +4101,20 @@ packages:
     dev: true
 
   /ms/2.0.0:
-    resolution: {integrity: sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=}
+    resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}
     dev: true
 
   /ms/2.1.2:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
     dev: true
 
-  /nan/2.16.0:
-    resolution: {integrity: sha512-UdAqHyFngu7TfQKsCBgAA6pWDkT8MAO7d0jyOecVhN5354xbLqdn8mV9Tat9gepAupm0bt2DbeaSC8vS52MuFA==}
+  /ms/2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+    dev: true
+    optional: true
+
+  /nan/2.17.0:
+    resolution: {integrity: sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ==}
     dev: true
     optional: true
 
@@ -4200,7 +4209,7 @@ packages:
     resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
     dependencies:
       hosted-git-info: 2.8.9
-      resolve: 1.22.0
+      resolve: 1.22.1
       semver: 5.7.1
       validate-npm-package-license: 3.0.4
     dev: true
@@ -4210,13 +4219,13 @@ packages:
     engines: {node: '>=10'}
     dependencies:
       hosted-git-info: 4.1.0
-      is-core-module: 2.9.0
-      semver: 7.3.7
+      is-core-module: 2.10.0
+      semver: 7.3.8
       validate-npm-package-license: 3.0.4
     dev: true
 
   /normalize-path/1.0.0:
-    resolution: {integrity: sha1-MtDkcvkf80VwHBWoMRAY07CpA3k=}
+    resolution: {integrity: sha512-7WyT0w8jhpDStXRq5836AMmihQwq2nrUVQrgjvUo/p/NZf9uy/MeJ246lBJVmWuYXMlJuG9BNZHF0hWjfTbQUA==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -4247,17 +4256,17 @@ packages:
       path-key: 3.1.1
     dev: true
 
-  /nwsapi/2.2.0:
-    resolution: {integrity: sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ==}
+  /nwsapi/2.2.2:
+    resolution: {integrity: sha512-90yv+6538zuvUMnN+zCr8LuV6bPFdq50304114vJYJ8RDyK8D5O9Phpbd6SZWgI7PwzmmfN1upeOJlvybDSgCw==}
     dev: true
 
   /object-assign/4.1.1:
-    resolution: {integrity: sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=}
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /object-copy/0.1.0:
-    resolution: {integrity: sha1-fn2Fi3gb18mRpBupde04EnVOmYw=}
+    resolution: {integrity: sha512-79LYn6VAb63zgtmAteVOWo9Vdj71ZVBy3Pbse+VqxDpEP83XuujMrGqHIwAXJ5I/aM0zU7dIyIAhifVTPrNItQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       copy-descriptor: 0.1.1
@@ -4270,21 +4279,21 @@ packages:
     dev: true
 
   /object-visit/1.0.1:
-    resolution: {integrity: sha1-95xEk68MU3e1n+OdOV5BBC3QRbs=}
+    resolution: {integrity: sha512-GBaMwwAVK9qbQN3Scdo0OyvgPW7l3lnaVMj84uTOZlswkX0KpF6fyDBJhtTthf7pymztoN36/KEr1DyhF96zEA==}
     engines: {node: '>=0.10.0'}
     dependencies:
       isobject: 3.0.1
     dev: true
 
   /object.pick/1.3.0:
-    resolution: {integrity: sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=}
+    resolution: {integrity: sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       isobject: 3.0.1
     dev: true
 
   /on-finished/2.3.0:
-    resolution: {integrity: sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=}
+    resolution: {integrity: sha512-ikqdkGAAyf/X/gPhXGvfgAytDZtDbr+bkNUJ0N9h5MI/dmdgCs3l6hoHrcUv41sRKew3jIwrp4qQDXiK99Utww==}
     engines: {node: '>= 0.8'}
     dependencies:
       ee-first: 1.1.1
@@ -4323,11 +4332,11 @@ packages:
     dev: true
 
   /os-browserify/0.3.0:
-    resolution: {integrity: sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=}
+    resolution: {integrity: sha512-gjcpUc3clBf9+210TRaDWbf+rZZZEshZ+DlXMRCeAjp0xhTrnQsKHypIy1J3d5hKdUzj69t708EHtU8P6bUn0A==}
     dev: true
 
   /p-finally/1.0.0:
-    resolution: {integrity: sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=}
+    resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==}
     engines: {node: '>=4'}
     dev: true
 
@@ -4345,15 +4354,8 @@ packages:
       p-try: 2.2.0
     dev: true
 
-  /p-limit/3.1.0:
-    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
-    engines: {node: '>=10'}
-    dependencies:
-      yocto-queue: 0.1.0
-    dev: true
-
   /p-locate/2.0.0:
-    resolution: {integrity: sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=}
+    resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==}
     engines: {node: '>=4'}
     dependencies:
       p-limit: 1.3.0
@@ -4373,13 +4375,6 @@ packages:
       p-limit: 2.3.0
     dev: true
 
-  /p-locate/5.0.0:
-    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
-    engines: {node: '>=10'}
-    dependencies:
-      p-limit: 3.1.0
-    dev: true
-
   /p-map/4.0.0:
     resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==}
     engines: {node: '>=10'}
@@ -4388,7 +4383,7 @@ packages:
     dev: true
 
   /p-try/1.0.0:
-    resolution: {integrity: sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=}
+    resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==}
     engines: {node: '>=4'}
     dev: true
 
@@ -4420,7 +4415,7 @@ packages:
     dev: true
 
   /parse-json/4.0.0:
-    resolution: {integrity: sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA=}
+    resolution: {integrity: sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw==}
     engines: {node: '>=4'}
     dependencies:
       error-ex: 1.3.2
@@ -4431,7 +4426,7 @@ packages:
     resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
     engines: {node: '>=8'}
     dependencies:
-      '@babel/code-frame': 7.16.7
+      '@babel/code-frame': 7.18.6
       error-ex: 1.3.2
       json-parse-even-better-errors: 2.3.1
       lines-and-columns: 1.2.4
@@ -4452,7 +4447,7 @@ packages:
     dev: true
 
   /pascalcase/0.1.1:
-    resolution: {integrity: sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ=}
+    resolution: {integrity: sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -4461,12 +4456,12 @@ packages:
     dev: true
 
   /path-dirname/1.0.2:
-    resolution: {integrity: sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=}
+    resolution: {integrity: sha512-ALzNPpyNq9AqXMBjeymIjFDAkAFH06mHJH/cSBHAgU0s4vfpBn6b2nf8tiRLvagKD8RbTpq2FKTBg7cl9l3c7Q==}
     dev: true
     optional: true
 
   /path-exists/3.0.0:
-    resolution: {integrity: sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=}
+    resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==}
     engines: {node: '>=4'}
     dev: true
 
@@ -4480,12 +4475,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /path-is-network-drive/1.0.15:
-    resolution: {integrity: sha512-bJGs1SxUne+q29P1xCLMkNBhMetku+vPN+yVQu8FGL/7diHesCSSIKoF4Wq42tcbwm7rK72XrGfK8FUXN00LLQ==}
-    dependencies:
-      tslib: 2.4.0
-    dev: true
-
   /path-key/2.0.1:
     resolution: {integrity: sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw==}
     engines: {node: '>=4'}
@@ -4499,12 +4488,6 @@ packages:
   /path-parse/1.0.7:
     resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
 
-  /path-strip-sep/1.0.12:
-    resolution: {integrity: sha512-EJZSC5WBjVlA9XHLCiluiyisYg6yzeMJ4nY3BQVCuedyEHA/I2crcHWdwuQ74h3V599U9nEbEZUTvvSxOK3vbQ==}
-    dependencies:
-      tslib: 2.4.0
-    dev: true
-
   /path-type/3.0.0:
     resolution: {integrity: sha512-T2ZUsdZFHgA3u4e5PfPbjd7HDDpxPnQb5jN0SrDsjNSuVXHJqtwTnWqG0B1jZrgmJ/7lj1EmVIByWt1gxGkWvg==}
     engines: {node: '>=4'}
@@ -4546,12 +4529,12 @@ packages:
     dev: true
 
   /pify/2.3.0:
-    resolution: {integrity: sha1-7RQaasBDqEnqWISY59yosVMw6Qw=}
+    resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /pify/3.0.0:
-    resolution: {integrity: sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=}
+    resolution: {integrity: sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==}
     engines: {node: '>=4'}
     dev: true
 
@@ -4574,60 +4557,53 @@ packages:
       find-up: 4.1.0
     dev: true
 
-  /pkg-dir/5.0.0:
-    resolution: {integrity: sha512-NPE8TDbzl/3YQYY7CSS228s3g2ollTFnc+Qi3tqmqJp9Vg2ovUpixcJEo2HJScN2Ez+kEaal6y70c0ehqJBJeA==}
-    engines: {node: '>=10'}
-    dependencies:
-      find-up: 5.0.0
-    dev: true
-
   /posix-character-classes/0.1.1:
-    resolution: {integrity: sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=}
+    resolution: {integrity: sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg==}
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /postcss-modules-extract-imports/3.0.0_postcss@8.4.14:
+  /postcss-modules-extract-imports/3.0.0_postcss@8.4.17:
     resolution: {integrity: sha512-bdHleFnP3kZ4NYDhuGlVK+CMrQ/pqUm8bx/oGL93K6gVwiclvX5x0n76fYMKuIGKzlABOy13zsvqjb0f92TEXw==}
     engines: {node: ^10 || ^12 || >= 14}
     peerDependencies:
       postcss: ^8.1.0
     dependencies:
-      postcss: 8.4.14
+      postcss: 8.4.17
     dev: true
 
-  /postcss-modules-local-by-default/4.0.0_postcss@8.4.14:
+  /postcss-modules-local-by-default/4.0.0_postcss@8.4.17:
     resolution: {integrity: sha512-sT7ihtmGSF9yhm6ggikHdV0hlziDTX7oFoXtuVWeDd3hHObNkcHRo9V3yg7vCAY7cONyxJC/XXCmmiHHcvX7bQ==}
     engines: {node: ^10 || ^12 || >= 14}
     peerDependencies:
       postcss: ^8.1.0
     dependencies:
-      icss-utils: 5.1.0_postcss@8.4.14
-      postcss: 8.4.14
+      icss-utils: 5.1.0_postcss@8.4.17
+      postcss: 8.4.17
       postcss-selector-parser: 6.0.10
       postcss-value-parser: 4.2.0
     dev: true
 
-  /postcss-modules-scope/3.0.0_postcss@8.4.14:
+  /postcss-modules-scope/3.0.0_postcss@8.4.17:
     resolution: {integrity: sha512-hncihwFA2yPath8oZ15PZqvWGkWf+XUfQgUGamS4LqoP1anQLOsOJw0vr7J7IwLpoY9fatA2qiGUGmuZL0Iqlg==}
     engines: {node: ^10 || ^12 || >= 14}
     peerDependencies:
       postcss: ^8.1.0
     dependencies:
-      postcss: 8.4.14
+      postcss: 8.4.17
       postcss-selector-parser: 6.0.10
     dev: true
 
-  /postcss-modules-values/4.0.0_postcss@8.4.14:
+  /postcss-modules-values/4.0.0_postcss@8.4.17:
     resolution: {integrity: sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==}
     engines: {node: ^10 || ^12 || >= 14}
     peerDependencies:
       postcss: ^8.1.0
     dependencies:
-      icss-utils: 5.1.0_postcss@8.4.14
-      postcss: 8.4.14
+      icss-utils: 5.1.0_postcss@8.4.17
+      postcss: 8.4.17
     dev: true
 
-  /postcss-modules/4.3.1_postcss@8.4.14:
+  /postcss-modules/4.3.1_postcss@8.4.17:
     resolution: {integrity: sha512-ItUhSUxBBdNamkT3KzIZwYNNRFKmkJrofvC2nWab3CPKhYBQ1f27XXh1PAPE27Psx58jeelPsxWB/+og+KEH0Q==}
     peerDependencies:
       postcss: ^8.0.0
@@ -4635,11 +4611,11 @@ packages:
       generic-names: 4.0.0
       icss-replace-symbols: 1.1.0
       lodash.camelcase: 4.3.0
-      postcss: 8.4.14
-      postcss-modules-extract-imports: 3.0.0_postcss@8.4.14
-      postcss-modules-local-by-default: 4.0.0_postcss@8.4.14
-      postcss-modules-scope: 3.0.0_postcss@8.4.14
-      postcss-modules-values: 4.0.0_postcss@8.4.14
+      postcss: 8.4.17
+      postcss-modules-extract-imports: 3.0.0_postcss@8.4.17
+      postcss-modules-local-by-default: 4.0.0_postcss@8.4.17
+      postcss-modules-scope: 3.0.0_postcss@8.4.17
+      postcss-modules-values: 4.0.0_postcss@8.4.17
       string-hash: 1.1.3
     dev: true
 
@@ -4655,8 +4631,8 @@ packages:
     resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
     dev: true
 
-  /postcss/8.4.14:
-    resolution: {integrity: sha512-E398TUmfAYFPBSdzgeieK2Y1+1cpdxJx8yXbK/m57nRhKSmk1GB2tO4lbLBtlkfPQTDKfe4Xqv1ASWPpayPEig==}
+  /postcss/8.4.17:
+    resolution: {integrity: sha512-UNxNOLQydcOFi41yHNMcKRZ39NeXlr8AxGuZJsdub8vIb12fHzcq37DTU/QtbI6WLxNg2gF9Z+8qtRwTj1UI1Q==}
     engines: {node: ^10 || ^12 || >=14}
     dependencies:
       nanoid: 3.3.4
@@ -4664,12 +4640,12 @@ packages:
       source-map-js: 1.0.2
 
   /prelude-ls/1.1.2:
-    resolution: {integrity: sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=}
+    resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==}
     engines: {node: '>= 0.8.0'}
     dev: true
 
-  /prettier/2.6.2:
-    resolution: {integrity: sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew==}
+  /prettier/2.7.1:
+    resolution: {integrity: sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==}
     engines: {node: '>=10.13.0'}
     hasBin: true
     dev: true
@@ -4679,7 +4655,7 @@ packages:
     dev: true
 
   /process/0.11.10:
-    resolution: {integrity: sha1-czIwDoQBYb2j5podHZGn1LwW8YI=}
+    resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
     engines: {node: '>= 0.6.0'}
     dev: true
 
@@ -4689,7 +4665,7 @@ packages:
     dev: true
 
   /promise-inflight/1.0.1_bluebird@3.7.2:
-    resolution: {integrity: sha1-mEcocL8igTL8vdhoEputEsPAKeM=}
+    resolution: {integrity: sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==}
     peerDependencies:
       bluebird: '*'
     peerDependenciesMeta:
@@ -4714,11 +4690,11 @@ packages:
     dev: true
 
   /pseudomap/1.0.2:
-    resolution: {integrity: sha1-8FKijacOYYkX7wqKw0wa5aaChrM=}
+    resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==}
     dev: true
 
-  /psl/1.8.0:
-    resolution: {integrity: sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==}
+  /psl/1.9.0:
+    resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==}
     dev: true
 
   /public-encrypt/4.0.3:
@@ -4764,7 +4740,7 @@ packages:
       jstransformer: 1.0.0
       pug-error: 2.0.0
       pug-walk: 2.0.0
-      resolve: 1.22.0
+      resolve: 1.22.1
     dev: true
 
   /pug-lexer/5.0.1:
@@ -4846,11 +4822,11 @@ packages:
     dev: true
 
   /punycode/1.3.2:
-    resolution: {integrity: sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=}
+    resolution: {integrity: sha512-RofWgt/7fL5wP1Y7fxE7/EmTLzQVnB0ycyibJ0OOHIlJqTNzglYFxVwETOcIoJqJmpDXJ9xImDv+Fq34F/d4Dw==}
     dev: true
 
   /punycode/1.4.1:
-    resolution: {integrity: sha1-wNWmOycYgArY4esPpSachN1BhF4=}
+    resolution: {integrity: sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==}
     dev: true
 
   /punycode/2.1.1:
@@ -4858,8 +4834,8 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /puppeteer/14.3.0:
-    resolution: {integrity: sha512-pDtg1+vyw1UPIhUjh2/VW1HUdQnaZJHfMacrJciR3AVm+PBiqdCEcFeFb3UJ/CDEQlHOClm3/WFa7IjY25zIGg==}
+  /puppeteer/14.4.1:
+    resolution: {integrity: sha512-+H0Gm84aXUvSLdSiDROtLlOofftClgw2TdceMvvCU9UvMryappoeS3+eOLfKvoy4sm8B8MWnYmPhWxVFudAOFQ==}
     engines: {node: '>=14.1.0'}
     requiresBuild: true
     dependencies:
@@ -4883,7 +4859,7 @@ packages:
     dev: true
 
   /q/1.5.1:
-    resolution: {integrity: sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=}
+    resolution: {integrity: sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==}
     engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
     dev: true
 
@@ -4892,24 +4868,28 @@ packages:
     engines: {node: '>=0.9'}
     dev: true
 
-  /qs/6.10.3:
-    resolution: {integrity: sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ==}
+  /qs/6.11.0:
+    resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==}
     engines: {node: '>=0.6'}
     dependencies:
       side-channel: 1.0.4
     dev: true
 
   /querystring-es3/0.2.1:
-    resolution: {integrity: sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=}
+    resolution: {integrity: sha512-773xhDQnZBMFobEiztv8LIl70ch5MSF/jUQVlhwFyBILqq96anmoctVIYz+ZRp0qbCKATTn6ev02M3r7Ga5vqA==}
     engines: {node: '>=0.4.x'}
     dev: true
 
   /querystring/0.2.0:
-    resolution: {integrity: sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=}
+    resolution: {integrity: sha512-X/xY82scca2tau62i9mDyU9K+I+djTMUsvwf7xnUX5GLvVzgJybOJf4Y6o9Zx3oJK/LSXg5tTZBjwzqVPaPO2g==}
     engines: {node: '>=0.4.x'}
     deprecated: The querystring API is considered Legacy. new code should use the URLSearchParams API instead.
     dev: true
 
+  /querystringify/2.2.0:
+    resolution: {integrity: sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==}
+    dev: true
+
   /quick-lru/4.0.1:
     resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==}
     engines: {node: '>=8'}
@@ -4943,7 +4923,7 @@ packages:
     dev: true
 
   /read-pkg-up/3.0.0:
-    resolution: {integrity: sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc=}
+    resolution: {integrity: sha512-YFzFrVvpC6frF1sz8psoHDBGF7fLPc+llq/8NB43oagqWkx8ar5zYtsTORtOjw9W2RHLpWP+zTWwBvf1bCmcSw==}
     engines: {node: '>=4'}
     dependencies:
       find-up: 2.1.0
@@ -4960,7 +4940,7 @@ packages:
     dev: true
 
   /read-pkg/3.0.0:
-    resolution: {integrity: sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k=}
+    resolution: {integrity: sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==}
     engines: {node: '>=4'}
     dependencies:
       load-json-file: 4.0.0
@@ -5019,10 +4999,10 @@ packages:
     dev: true
 
   /rechoir/0.6.2:
-    resolution: {integrity: sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q=}
+    resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==}
     engines: {node: '>= 0.10'}
     dependencies:
-      resolve: 1.22.0
+      resolve: 1.22.1
     dev: true
 
   /redent/3.0.0:
@@ -5042,7 +5022,7 @@ packages:
     dev: true
 
   /remove-trailing-separator/1.1.0:
-    resolution: {integrity: sha1-wkvOKig62tW8P1jg1IJJuSN52O8=}
+    resolution: {integrity: sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw==}
     dev: true
     optional: true
 
@@ -5052,21 +5032,21 @@ packages:
     dev: true
 
   /repeat-string/1.6.1:
-    resolution: {integrity: sha1-jcrkcOHIirwtYA//Sndihtp15jc=}
+    resolution: {integrity: sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==}
     engines: {node: '>=0.10'}
     dev: true
 
   /require-directory/2.1.1:
-    resolution: {integrity: sha1-jGStX9MNqxyXbiNE/+f3kqam30I=}
+    resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /requires-port/1.0.0:
-    resolution: {integrity: sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=}
+    resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==}
     dev: true
 
   /resolve-url/0.2.1:
-    resolution: {integrity: sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=}
+    resolution: {integrity: sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg==}
     deprecated: https://github.com/lydell/resolve-url#deprecated
     dev: true
 
@@ -5079,15 +5059,15 @@ packages:
   /resolve/1.19.0:
     resolution: {integrity: sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==}
     dependencies:
-      is-core-module: 2.9.0
+      is-core-module: 2.10.0
       path-parse: 1.0.7
     dev: true
 
-  /resolve/1.22.0:
-    resolution: {integrity: sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw==}
+  /resolve/1.22.1:
+    resolution: {integrity: sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==}
     hasBin: true
     dependencies:
-      is-core-module: 2.9.0
+      is-core-module: 2.10.0
       path-parse: 1.0.7
       supports-preserve-symlinks-flag: 1.0.0
 
@@ -5129,24 +5109,31 @@ packages:
       inherits: 2.0.4
     dev: true
 
-  /rollup-plugin-typescript2/0.31.2_fgms252lqu3rk7srzpqqayl4ya:
-    resolution: {integrity: sha512-hRwEYR1C8xDGVVMFJQdEVnNAeWRvpaY97g5mp3IeLnzhNXzSVq78Ye/BJ9PAaUfN4DXa/uDnqerifMOaMFY54Q==}
+  /rollup-plugin-typescript2/0.32.1_gypgyaqhine6mwjfvh7icfhviq:
+    resolution: {integrity: sha512-RanO8bp1WbeMv0bVlgcbsFNCn+Y3rX7wF97SQLDxf0fMLsg0B/QFF005t4AsGUcDgF3aKJHoqt4JF2xVaABeKw==}
     peerDependencies:
       rollup: '>=1.26.3'
       typescript: '>=2.4.0'
     dependencies:
       '@rollup/pluginutils': 4.2.1
-      '@yarn-tool/resolve-package': 1.0.47
       find-cache-dir: 3.3.2
       fs-extra: 10.1.0
-      resolve: 1.22.0
-      rollup: 2.75.6
+      resolve: 1.22.1
+      rollup: 2.79.1
       tslib: 2.4.0
-      typescript: 4.7.3
+      typescript: 4.8.4
+    dev: true
+
+  /rollup/2.77.3:
+    resolution: {integrity: sha512-/qxNTG7FbmefJWoeeYJFbHehJ2HNWnjkAFRKzWN/45eNBBF/r8lo992CwcJXEzyVxs5FmfId+vTSTQDb+bxA+g==}
+    engines: {node: '>=10.0.0'}
+    hasBin: true
+    optionalDependencies:
+      fsevents: 2.3.2
     dev: true
 
-  /rollup/2.75.6:
-    resolution: {integrity: sha512-OEf0TgpC9vU6WGROJIk1JA3LR5vk/yvqlzxqdrE2CzzXnqKXNzbAwlWUXis8RS3ZPe7LAq+YUxsRa0l3r27MLA==}
+  /rollup/2.79.1:
+    resolution: {integrity: sha512-uKxbd0IhMZOhjAiD5oAFp7BqvkA4Dv47qpOCtaNvng4HBwdbWtdOh8f5nZNuk2rp51PMGk3bzfWu5oayNEuYnw==}
     engines: {node: '>=10.0.0'}
     hasBin: true
     optionalDependencies:
@@ -5154,13 +5141,13 @@ packages:
     dev: true
 
   /run-queue/1.0.3:
-    resolution: {integrity: sha1-6Eg5bwV9Ij8kOGkkYY4laUFh7Ec=}
+    resolution: {integrity: sha512-ntymy489o0/QQplUDnpYAYUsO50K9SBrIVaKCWDOJzYJts0f9WH9RFJkyagebkw5+y1oi00R7ynNW/d12GBumg==}
     dependencies:
       aproba: 1.2.0
     dev: true
 
-  /rxjs/7.5.5:
-    resolution: {integrity: sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw==}
+  /rxjs/7.5.7:
+    resolution: {integrity: sha512-z9MzKh/UcOqB3i20H6rtrlaE/CgjLOvheWK/9ILrbhROGTweAi1BaFsTT9FbwZi5Trr1qNRs+MXkhmR06awzQA==}
     dependencies:
       tslib: 2.4.0
     dev: true
@@ -5173,7 +5160,7 @@ packages:
     resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
 
   /safe-regex/1.1.0:
-    resolution: {integrity: sha1-QKNmnzsHfR6UPURinhV91IAjvy4=}
+    resolution: {integrity: sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg==}
     dependencies:
       ret: 0.1.15
     dev: true
@@ -5182,8 +5169,8 @@ packages:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
     dev: true
 
-  /sass/1.52.3:
-    resolution: {integrity: sha512-LNNPJ9lafx+j1ArtA7GyEJm9eawXN8KlA1+5dF6IZyoONg1Tyo/g+muOsENWJH/2Q1FHbbV4UwliU0cXMa/VIA==}
+  /sass/1.55.0:
+    resolution: {integrity: sha512-Pk+PMy7OGLs9WaxZGJMn7S96dvlyVBwwtToX895WmCpAOr5YiJYEUJfiJidMuKb613z2xNWcXCHEuOvjZbqC6A==}
     engines: {node: '>=12.0.0'}
     hasBin: true
     dependencies:
@@ -5222,8 +5209,8 @@ packages:
     hasBin: true
     dev: true
 
-  /semver/7.3.7:
-    resolution: {integrity: sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==}
+  /semver/7.3.8:
+    resolution: {integrity: sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A==}
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
@@ -5253,7 +5240,7 @@ packages:
     dev: true
 
   /setimmediate/1.0.5:
-    resolution: {integrity: sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=}
+    resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==}
     dev: true
 
   /setprototypeof/1.2.0:
@@ -5269,7 +5256,7 @@ packages:
     dev: true
 
   /shebang-command/1.2.0:
-    resolution: {integrity: sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=}
+    resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       shebang-regex: 1.0.0
@@ -5283,7 +5270,7 @@ packages:
     dev: true
 
   /shebang-regex/1.0.0:
-    resolution: {integrity: sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=}
+    resolution: {integrity: sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -5306,7 +5293,7 @@ packages:
     resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==}
     dependencies:
       call-bind: 1.0.2
-      get-intrinsic: 1.1.1
+      get-intrinsic: 1.1.3
       object-inspect: 1.12.2
     dev: true
 
@@ -5341,7 +5328,7 @@ packages:
     resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==}
     engines: {node: '>=12'}
     dependencies:
-      ansi-styles: 6.1.0
+      ansi-styles: 6.2.0
       is-fullwidth-code-point: 4.0.0
     dev: true
 
@@ -5381,19 +5368,18 @@ packages:
     resolution: {integrity: sha512-W4N+o69rkMEGVuk2D/cvca3uYsvGlMwsySWV447y99gUPghxq42BxqLNMndb+a1mm/5/7NeXVQS7RLa2XyXvYg==}
     dev: true
 
-  /socket.io-parser/4.0.4:
-    resolution: {integrity: sha512-t+b0SS+IxG7Rxzda2EVvyBZbvFPBCjJoyHuE0P//7OAsN23GItzDRdWa6ALxZI/8R5ygK7jAR6t028/z+7295g==}
+  /socket.io-parser/4.2.1:
+    resolution: {integrity: sha512-V4GrkLy+HeF1F/en3SpUaM+7XxYXpuMUWLGde1kSSh5nQMN4hLrbPIkD+otwh6q9R6NOQBN4AMaOZ2zVjui82g==}
     engines: {node: '>=10.0.0'}
     dependencies:
-      '@types/component-emitter': 1.2.11
-      component-emitter: 1.3.0
+      '@socket.io/component-emitter': 3.1.0
       debug: 4.3.4
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /socket.io/4.5.1:
-    resolution: {integrity: sha512-0y9pnIso5a9i+lJmsCdtmTTgJFFSvNQKDnPQRz28mGNnxbmqYg2QPtJTLFxhymFZhAIn50eHAKzJeiNaKr+yUQ==}
+  /socket.io/4.5.2:
+    resolution: {integrity: sha512-6fCnk4ARMPZN448+SQcnn1u8OHUC72puJcNtSgg2xS34Cu7br1gQ09YKkO1PFfDn/wyUE9ZgMAwosJed003+NQ==}
     engines: {node: '>=10.0.0'}
     dependencies:
       accepts: 1.3.8
@@ -5401,7 +5387,7 @@ packages:
       debug: 4.3.4
       engine.io: 6.2.0
       socket.io-adapter: 2.4.0
-      socket.io-parser: 4.0.4
+      socket.io-parser: 4.2.1
     transitivePeerDependencies:
       - bufferutil
       - supports-color
@@ -5448,15 +5434,15 @@ packages:
     dev: true
 
   /source-map/0.5.6:
-    resolution: {integrity: sha1-dc449SvwczxafwwRjYEzSiu19BI=}
+    resolution: {integrity: sha512-MjZkVp0NHr5+TPihLcadqnlVoGIoWo4IBHptutGh9wI3ttUYvCG26HkSuDi+K6lsZ25syXJXcctwgyVCt//xqA==}
     engines: {node: '>=0.10.0'}
 
   /source-map/0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
-  /source-map/0.7.3:
-    resolution: {integrity: sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==}
+  /source-map/0.7.4:
+    resolution: {integrity: sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==}
     engines: {node: '>= 8'}
     dev: true
 
@@ -5468,7 +5454,7 @@ packages:
     resolution: {integrity: sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==}
     dependencies:
       spdx-expression-parse: 3.0.1
-      spdx-license-ids: 3.0.11
+      spdx-license-ids: 3.0.12
     dev: true
 
   /spdx-exceptions/2.3.0:
@@ -5479,11 +5465,11 @@ packages:
     resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==}
     dependencies:
       spdx-exceptions: 2.3.0
-      spdx-license-ids: 3.0.11
+      spdx-license-ids: 3.0.12
     dev: true
 
-  /spdx-license-ids/3.0.11:
-    resolution: {integrity: sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g==}
+  /spdx-license-ids/3.0.12:
+    resolution: {integrity: sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==}
     dev: true
 
   /split-string/3.1.0:
@@ -5516,7 +5502,7 @@ packages:
     dev: true
 
   /static-extend/0.1.2:
-    resolution: {integrity: sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY=}
+    resolution: {integrity: sha512-72E9+uLc27Mt718pMHt9VMNiAL4LMsmDbBva8mxWUCkT07fSzEGMYUCk0XWY6lp0j6RBAG4cJ3mWuZv2OE3s0g==}
     engines: {node: '>=0.10.0'}
     dependencies:
       define-property: 0.2.5
@@ -5524,7 +5510,7 @@ packages:
     dev: true
 
   /statuses/1.5.0:
-    resolution: {integrity: sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=}
+    resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==}
     engines: {node: '>= 0.6'}
     dev: true
 
@@ -5561,13 +5547,13 @@ packages:
     resolution: {integrity: sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==}
     dev: true
 
-  /streamroller/3.1.1:
-    resolution: {integrity: sha512-iPhtd9unZ6zKdWgMeYGfSBuqCngyJy1B/GPi/lTpwGpa3bajuX30GjUVd0/Tn/Xhg0mr4DOSENozz9Y06qyonQ==}
+  /streamroller/3.1.3:
+    resolution: {integrity: sha512-CphIJyFx2SALGHeINanjFRKQ4l7x2c+rXYJ4BMq0gd+ZK0gi4VT8b+eHe2wi58x4UayBAKx4xtHpXT/ea1cz8w==}
     engines: {node: '>=8.0'}
     dependencies:
-      date-format: 4.0.10
+      date-format: 4.0.14
       debug: 4.3.4
-      fs-extra: 10.1.0
+      fs-extra: 8.1.0
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -5626,12 +5612,12 @@ packages:
     dev: true
 
   /strip-bom/3.0.0:
-    resolution: {integrity: sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=}
+    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
     engines: {node: '>=4'}
     dev: true
 
   /strip-eof/1.0.0:
-    resolution: {integrity: sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=}
+    resolution: {integrity: sha512-7FCwGGmx8mD5xQd3RPUvnSpUXHM3BWuzjtpD4TXsfcZ9EL4azvVVUscFYwD9nx8Kh+uCBC00XBtAykoMHwTh8Q==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -5641,7 +5627,7 @@ packages:
     dev: true
 
   /strip-indent/2.0.0:
-    resolution: {integrity: sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=}
+    resolution: {integrity: sha512-RsSNPLpq6YUL7QYy44RnPVTn/lcVZtb48Uof3X5JLbF4zD/Gs7ZFDv2HWol+leoQN2mT86LAzSshGfkTlSOpsA==}
     engines: {node: '>=4'}
     dev: true
 
@@ -5665,7 +5651,7 @@ packages:
       debug: 4.3.4
       glob: 7.2.3
       sax: 1.2.4
-      source-map: 0.7.3
+      source-map: 0.7.4
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -5683,8 +5669,8 @@ packages:
     dependencies:
       has-flag: 4.0.0
 
-  /supports-color/9.2.2:
-    resolution: {integrity: sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA==}
+  /supports-color/9.2.3:
+    resolution: {integrity: sha512-aszYUX/DVK/ed5rFLb/dDinVJrQjG/vmU433wtqVSD800rYsJNWxh2R3USV90aLSU+UsyQkbNeffVLzc6B6foA==}
     engines: {node: '>=12'}
     dev: true
 
@@ -5746,30 +5732,30 @@ packages:
       schema-utils: 1.0.0
       serialize-javascript: 4.0.0
       source-map: 0.6.1
-      terser: 4.8.0
+      terser: 4.8.1
       webpack: 4.46.0
       webpack-sources: 1.4.3
       worker-farm: 1.7.0
     dev: true
 
-  /terser/4.8.0:
-    resolution: {integrity: sha512-EAPipTNeWsb/3wLPeup1tVPaXfIaU68xMnVdPafIL1TV05OhASArYyIfFvnvJCNrR2NIOvDVNNTFRa+Re2MWyw==}
+  /terser/4.8.1:
+    resolution: {integrity: sha512-4GnLC0x667eJG0ewJTa6z/yXrbLGv80D9Ru6HIpCQmO+Q4PfEtBFi0ObSckqwL6VyQv/7ENJieXHo2ANmdQwgw==}
     engines: {node: '>=6.0.0'}
     hasBin: true
     dependencies:
-      acorn: 8.7.1
+      acorn: 8.8.0
       commander: 2.20.3
       source-map: 0.6.1
       source-map-support: 0.5.21
     dev: true
 
-  /terser/5.14.0:
-    resolution: {integrity: sha512-JC6qfIEkPBd9j1SMO3Pfn+A6w2kQV54tv+ABQLgZr7dA3k/DL/OBoYSWxzVpZev3J+bUHXfr55L8Mox7AaNo6g==}
+  /terser/5.15.1:
+    resolution: {integrity: sha512-K1faMUvpm/FBxjBXud0LWVAGxmvoPbZbfTCYbSgaaYQaIXI3/TdI7a7ZGA73Zrou6Q8Zmz3oeUTsp/dj+ag2Xw==}
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
       '@jridgewell/source-map': 0.3.2
-      acorn: 8.7.1
+      acorn: 8.8.0
       commander: 2.20.3
       source-map-support: 0.5.21
     dev: true
@@ -5780,7 +5766,7 @@ packages:
     dev: true
 
   /through/2.3.8:
-    resolution: {integrity: sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=}
+    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
     dev: true
 
   /through2/2.0.5:
@@ -5803,17 +5789,13 @@ packages:
       setimmediate: 1.0.5
     dev: true
 
-  /timsort/0.3.0:
-    resolution: {integrity: sha512-qsdtZH+vMoCARQtyod4imc2nIJwg9Cc7lPRrw9CzF8ZKR0khdr8+2nX80PBhET3tcyTtJDxAffGh2rXH4tyU8A==}
-    dev: true
-
   /tinypool/0.1.3:
     resolution: {integrity: sha512-2IfcQh7CP46XGWGGbdyO4pjcKqsmVqFAPcXfPxcPXmOWt9cYkTP9HcDmGgsfijYoAEc4z9qcpM/BaBz46Y9/CQ==}
     engines: {node: '>=14.0.0'}
     dev: true
 
-  /tinyspy/0.3.2:
-    resolution: {integrity: sha512-2+40EP4D3sFYy42UkgkFFB+kiX2Tg3URG/lVvAZFfLxgGpnWl5qQJuBw1gaLttq8UOS+2p3C0WrhJnQigLTT2Q==}
+  /tinyspy/0.3.3:
+    resolution: {integrity: sha512-gRiUR8fuhUf0W9lzojPf1N1euJYA30ISebSfgca8z76FOvXtVXqd5ojEIaKLWbDQhAaC3ibxZIjqbyi4ybjcTw==}
     engines: {node: '>=14.0.0'}
     dev: true
 
@@ -5825,7 +5807,7 @@ packages:
     dev: true
 
   /to-arraybuffer/1.0.1:
-    resolution: {integrity: sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=}
+    resolution: {integrity: sha512-okFlQcoGTi4LQBG/PgSYblw9VOyptsz2KJZqc6qtgGdes8VktzUQkj4BI2blit072iS8VODNcMA+tvnS9dnuMA==}
     dev: true
 
   /to-fast-properties/2.0.0:
@@ -5833,14 +5815,14 @@ packages:
     engines: {node: '>=4'}
 
   /to-object-path/0.3.0:
-    resolution: {integrity: sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68=}
+    resolution: {integrity: sha512-9mWHdnGRuh3onocaHzukyvCZhzvr6tiflAy/JRFXcJX0TjgfWA9pk9t8CMbzmBE4Jfw58pXbkngtBtqYxzNEyg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       kind-of: 3.2.2
     dev: true
 
   /to-regex-range/2.1.1:
-    resolution: {integrity: sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=}
+    resolution: {integrity: sha512-ZZWNfCjUokXXDGXFpZehJIkZqq91BcULFq/Pi7M5i4JnxXdhMKAK682z8bCW3o8Hj1wuuzoKcW3DfVzaP6VuNg==}
     engines: {node: '>=0.10.0'}
     dependencies:
       is-number: 3.0.0
@@ -5877,17 +5859,18 @@ packages:
     resolution: {integrity: sha1-zCAOqyYT9BZtJ/+a/HylbUnfbrQ=}
     dev: true
 
-  /tough-cookie/4.0.0:
-    resolution: {integrity: sha512-tHdtEpQCMrc1YLrMaqXXcj6AxhYi/xgit6mZu1+EDWUn+qhUf8wMQoFIy9NXuq23zAwtcB0t/MjACGR18pcRbg==}
+  /tough-cookie/4.1.2:
+    resolution: {integrity: sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ==}
     engines: {node: '>=6'}
     dependencies:
-      psl: 1.8.0
+      psl: 1.9.0
       punycode: 2.1.1
-      universalify: 0.1.2
+      universalify: 0.2.0
+      url-parse: 1.5.10
     dev: true
 
   /tr46/0.0.3:
-    resolution: {integrity: sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=}
+    resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
     dev: true
 
   /tr46/3.0.0:
@@ -5902,8 +5885,8 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /ts-node/10.8.1_f5eqjuxkorpjvs4z7mviievvou:
-    resolution: {integrity: sha512-Wwsnao4DQoJsN034wePSg5nZiw4YKXf56mPIAeD6wVmiv+RytNSWqc2f3fKvcUoV+Yn2+yocD71VOfQHbmVX4g==}
+  /ts-node/10.9.1_ksn4eycaeggbrckn3ykh37hwf4:
+    resolution: {integrity: sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==}
     hasBin: true
     peerDependencies:
       '@swc/core': '>=1.2.50'
@@ -5917,18 +5900,18 @@ packages:
         optional: true
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
-      '@tsconfig/node10': 1.0.8
-      '@tsconfig/node12': 1.0.9
-      '@tsconfig/node14': 1.0.1
-      '@tsconfig/node16': 1.0.2
-      '@types/node': 17.0.41
-      acorn: 8.7.1
+      '@tsconfig/node10': 1.0.9
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.3
+      '@types/node': 17.0.45
+      acorn: 8.8.0
       acorn-walk: 8.2.0
       arg: 4.1.3
       create-require: 1.1.1
       diff: 4.0.2
       make-error: 1.3.6
-      typescript: 4.7.3
+      typescript: 4.8.4
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
     dev: true
@@ -5942,7 +5925,7 @@ packages:
     dev: true
 
   /type-check/0.3.2:
-    resolution: {integrity: sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=}
+    resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==}
     engines: {node: '>= 0.8.0'}
     dependencies:
       prelude-ls: 1.1.2
@@ -5982,17 +5965,11 @@ packages:
     dev: true
 
   /typedarray/0.0.6:
-    resolution: {integrity: sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=}
-    dev: true
-
-  /typescript/4.6.4:
-    resolution: {integrity: sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg==}
-    engines: {node: '>=4.2.0'}
-    hasBin: true
+    resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==}
     dev: true
 
-  /typescript/4.7.3:
-    resolution: {integrity: sha512-WOkT3XYvrpXx4vMMqlD+8R8R37fZkjyLGlxavMc4iB8lrl8L0DeTcHbYgw/v0N/z9wAFsgBhcsF0ruoySS22mA==}
+  /typescript/4.8.4:
+    resolution: {integrity: sha512-QCh+85mCy+h0IGff8r5XWzOVSbBO+KfeYrMQh7NJ58QujwcE22u+NUSmUxqF+un70P9GXKxa2HCNiTTMJknyjQ==}
     engines: {node: '>=4.2.0'}
     hasBin: true
     dev: true
@@ -6001,8 +5978,8 @@ packages:
     resolution: {integrity: sha512-qLK/Xe9E2uzmYI3qLeOmI0tEOt+TBBQyUIAh4aAgU05FVYzeZrKUdkAZfBNVGRaHVgV0TDkdEngJSw/SyQchkQ==}
     dev: true
 
-  /uglify-js/3.15.5:
-    resolution: {integrity: sha512-hNM5q5GbBRB5xB+PMqVRcgYe4c8jbyZ1pzZhS6jbq54/4F2gFK869ZheiE5A8/t+W5jtTNpWef/5Q9zk639FNQ==}
+  /uglify-js/3.17.3:
+    resolution: {integrity: sha512-JmMFDME3iufZnBpyKL+uS78LRiC+mK55zWfM5f/pWBJfpOttXAqYfdDGRukYhJuyRinvPVAtUhvy7rlDybNtFg==}
     engines: {node: '>=0.8.0'}
     hasBin: true
     requiresBuild: true
@@ -6043,18 +6020,23 @@ packages:
     engines: {node: '>= 4.0.0'}
     dev: true
 
+  /universalify/0.2.0:
+    resolution: {integrity: sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==}
+    engines: {node: '>= 4.0.0'}
+    dev: true
+
   /universalify/2.0.0:
     resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==}
     engines: {node: '>= 10.0.0'}
     dev: true
 
   /unpipe/1.0.0:
-    resolution: {integrity: sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=}
+    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
     engines: {node: '>= 0.8'}
     dev: true
 
   /unset-value/1.0.0:
-    resolution: {integrity: sha1-g3aHP30jNRef+x5vw6jtDfyKtVk=}
+    resolution: {integrity: sha512-PcA2tsuGSF9cnySLHTLSh2qrQiJ70mn+r+Glzxv2TWZblxsxCC52BDlZoPCsz7STd9pN7EZetkWZBAvk4cgZdQ==}
     engines: {node: '>=0.10.0'}
     dependencies:
       has-value: 0.3.1
@@ -6067,15 +6049,6 @@ packages:
     dev: true
     optional: true
 
-  /upath2/3.1.13:
-    resolution: {integrity: sha512-M88uBoqgzrkXvXrF/+oSIPsTmL21uRwGhPVJKODrl+3lXkQ5NPKrTYuSBZVa+lgPGFoI6qYyHlSKACFHO0AoNw==}
-    dependencies:
-      '@types/node': 17.0.41
-      path-is-network-drive: 1.0.15
-      path-strip-sep: 1.0.12
-      tslib: 2.4.0
-    dev: true
-
   /uri-js/4.4.1:
     resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
     dependencies:
@@ -6083,12 +6056,19 @@ packages:
     dev: true
 
   /urix/0.1.0:
-    resolution: {integrity: sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI=}
+    resolution: {integrity: sha512-Am1ousAhSLBeB9cG/7k7r2R0zj50uDRlZHPGbazid5s9rlF1F/QKYObEKSIunSjIOkJZqwRRLpvewjEkM7pSqg==}
     deprecated: Please see https://github.com/lydell/urix#deprecated
     dev: true
 
+  /url-parse/1.5.10:
+    resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==}
+    dependencies:
+      querystringify: 2.2.0
+      requires-port: 1.0.0
+    dev: true
+
   /url/0.11.0:
-    resolution: {integrity: sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=}
+    resolution: {integrity: sha512-kbailJa29QrtXnxgq+DdCEGlbTeYM2eJUxsz6vjZavrCYPMIFHMKQmSKYAIuUK2i7hgPm28a8piX5NTUtM/LKQ==}
     dependencies:
       punycode: 1.3.2
       querystring: 0.2.0
@@ -6100,11 +6080,11 @@ packages:
     dev: true
 
   /util-deprecate/1.0.2:
-    resolution: {integrity: sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=}
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
     dev: true
 
   /util/0.10.3:
-    resolution: {integrity: sha1-evsa/lCAUkZInj23/g7TeTNqwPk=}
+    resolution: {integrity: sha512-5KiHfsmkqacuKjkRkdV7SsfDJ2EGiPsK92s2MhNSY0craxjTdKTtqKsJaCWp4LW33ZZ0OPUv1WO/TFvNQRiQxQ==}
     dependencies:
       inherits: 2.0.1
     dev: true
@@ -6116,7 +6096,7 @@ packages:
     dev: true
 
   /utils-merge/1.0.1:
-    resolution: {integrity: sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=}
+    resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}
     engines: {node: '>= 0.4.0'}
     dev: true
 
@@ -6143,12 +6123,12 @@ packages:
     dev: true
 
   /vary/1.1.2:
-    resolution: {integrity: sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=}
+    resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
     engines: {node: '>= 0.8'}
     dev: true
 
-  /vite/2.9.9:
-    resolution: {integrity: sha512-ffaam+NgHfbEmfw/Vuh6BHKKlI/XIAhxE5QSS7gFLIngxg171mg1P3a4LSRME0z2ZU1ScxoKzphkipcYwSD5Ew==}
+  /vite/2.9.15:
+    resolution: {integrity: sha512-fzMt2jK4vQ3yK56te3Kqpkaeq9DkcZfBbzHwYpobasvgYmP2SoAr6Aic05CsB4CzCZbsDv4sujX3pkEGhLabVQ==}
     engines: {node: '>=12.2.0'}
     hasBin: true
     peerDependencies:
@@ -6163,10 +6143,10 @@ packages:
       stylus:
         optional: true
     dependencies:
-      esbuild: 0.14.43
-      postcss: 8.4.14
-      resolve: 1.22.0
-      rollup: 2.75.6
+      esbuild: 0.14.54
+      postcss: 8.4.17
+      resolve: 1.22.1
+      rollup: 2.77.3
     optionalDependencies:
       fsevents: 2.3.2
     dev: true
@@ -6190,15 +6170,15 @@ packages:
       jsdom:
         optional: true
     dependencies:
-      '@types/chai': 4.3.1
+      '@types/chai': 4.3.3
       '@types/chai-subset': 1.3.3
       chai: 4.3.6
       debug: 4.3.4
       jsdom: 19.0.0
-      local-pkg: 0.4.1
+      local-pkg: 0.4.2
       tinypool: 0.1.3
-      tinyspy: 0.3.2
-      vite: 2.9.9
+      tinyspy: 0.3.3
+      vite: 2.9.15
     transitivePeerDependencies:
       - less
       - sass
@@ -6211,12 +6191,12 @@ packages:
     dev: true
 
   /void-elements/2.0.1:
-    resolution: {integrity: sha1-wGavtYK7HLQSjWDqkjkulNXp2+w=}
+    resolution: {integrity: sha512-qZKX4RnBzH2ugr8Lxa7x+0V6XD9Sb/ouARtiasEQCHB1EVU4NXtmHsDDrx1dO4ne5fc3J6EW05BP1Dl0z0iung==}
     engines: {node: '>=0.10.0'}
     dev: true
 
   /void-elements/3.1.0:
-    resolution: {integrity: sha1-YU9/v42AHwu18GYfWy9XhXUOTwk=}
+    resolution: {integrity: sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w==}
     engines: {node: '>=0.10.0'}
     dev: true
 
@@ -6256,7 +6236,7 @@ packages:
     dev: true
 
   /webidl-conversions/3.0.1:
-    resolution: {integrity: sha1-JFNCdeKnvGvnvIZhHMFq4KVlSHE=}
+    resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
     dev: true
 
   /webidl-conversions/7.0.0:
@@ -6340,7 +6320,7 @@ packages:
     dev: true
 
   /whatwg-url/5.0.0:
-    resolution: {integrity: sha1-lmRU6HZUYuN2RNNib2dCzotwll0=}
+    resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
     dependencies:
       tr46: 0.0.3
       webidl-conversions: 3.0.1
@@ -6365,8 +6345,8 @@ packages:
     resolution: {integrity: sha512-RNGKj82nUPg3g5ygxkQl0R937xLyho1J24ItRCBTr/m1YnZkzJy1hUiHUJrc/VlsDQzsCnInEGSg3bci0Lmd4w==}
     engines: {node: '>= 10.0.0'}
     dependencies:
-      '@babel/parser': 7.18.4
-      '@babel/types': 7.18.4
+      '@babel/parser': 7.19.4
+      '@babel/types': 7.19.4
       assert-never: 1.2.1
       babel-walk: 3.0.0-canary-5
     dev: true
@@ -6377,7 +6357,7 @@ packages:
     dev: true
 
   /wordwrap/1.0.0:
-    resolution: {integrity: sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=}
+    resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==}
     dev: true
 
   /worker-farm/1.7.0:
@@ -6405,7 +6385,7 @@ packages:
     dev: true
 
   /wrappy/1.0.2:
-    resolution: {integrity: sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=}
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
     dev: true
 
   /ws/8.2.3:
@@ -6434,6 +6414,19 @@ packages:
         optional: true
     dev: true
 
+  /ws/8.9.0:
+    resolution: {integrity: sha512-Ja7nszREasGaYUYCI2k4lCKIRTt+y7XuqVoHR44YpI49TtryyqbqvDMn5eqfW7e6HzTukDRIsXqzVHScqRcafg==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: ^5.0.2
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+    dev: true
+
   /xml-name-validator/4.0.0:
     resolution: {integrity: sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==}
     engines: {node: '>=12'}
@@ -6458,7 +6451,7 @@ packages:
     dev: true
 
   /yallist/2.1.2:
-    resolution: {integrity: sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=}
+    resolution: {integrity: sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A==}
     dev: true
 
   /yallist/3.1.1:
@@ -6493,7 +6486,7 @@ packages:
     dev: true
 
   /yauzl/2.10.0:
-    resolution: {integrity: sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=}
+    resolution: {integrity: sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==}
     dependencies:
       buffer-crc32: 0.2.13
       fd-slicer: 1.1.0
@@ -6504,11 +6497,6 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /yocto-queue/0.1.0:
-    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
-    engines: {node: '>=10'}
-    dev: true
-
   /yorkie/2.0.0:
     resolution: {integrity: sha512-jcKpkthap6x63MB4TxwCyuIGkV0oYP/YRyuQU5UO0Yz/E/ZAu+653/uov+phdmO54n6BcvFRyyt0RRrWdN2mpw==}
     engines: {node: '>=4'}
@@ -6520,8 +6508,8 @@ packages:
       strip-indent: 2.0.0
     dev: true
 
-  /z-schema/5.0.3:
-    resolution: {integrity: sha512-sGvEcBOTNum68x9jCpCVGPFJ6mWnkD0YxOcddDlJHRx3tKdB2q8pCHExMVZo/AV/6geuVJXG7hljDaWG8+5GDw==}
+  /z-schema/5.0.4:
+    resolution: {integrity: sha512-gm/lx3hDzJNcLwseIeQVm1UcwhWIKpSB4NqH89pTBtFns4k/HDHudsICtvG05Bvw/Mv3jMyk700y5dadueLHdA==}
     engines: {node: '>=8.0.0'}
     hasBin: true
     dependencies:
@@ -6535,8 +6523,8 @@ packages:
   'file:':
     resolution: {directory: '', type: directory}
     name: vue
-    version: 2.7.0-alpha.6
+    version: 2.7.10
     dependencies:
       '@vue/compiler-sfc': link:packages/compiler-sfc
-      csstype: 3.1.0
+      csstype: 3.1.1
     dev: true
diff --git a/scripts/config.js b/scripts/config.js
index 27a318499f9..e9f519853f1 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -227,6 +227,9 @@ const builds = {
 
 function genConfig(name) {
   const opts = builds[name]
+  const isTargetingBrowser = !(
+    opts.transpile === false || opts.format === 'cjs'
+  )
 
   // console.log('__dir', __dirname)
   const config = {
@@ -243,11 +246,9 @@ function genConfig(name) {
           compilerOptions: {
             // if targeting browser, target es5
             // if targeting node, es2017 means Node 8
-            target:
-              opts.transpile === false || opts.format === 'cjs'
-                ? 'es2017'
-                : 'es5'
+            target: isTargetingBrowser ? 'es5' : 'es2017'
           },
+          include: isTargetingBrowser ? ['src'] : ['src', 'packages/*/src'],
           exclude: ['test', 'test-dts']
         }
       })

From 738f4b3c570dc3a1818924a203a9f8e4b1ec90f0 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 17:51:46 +0800
Subject: [PATCH 290/317] fix(build): enforce LF line ending in built files

fix #12819
---
 dist/vue.runtime.mjs | 152 +++++++++++++++++++++----------------------
 tsconfig.json        |   1 +
 2 files changed, 77 insertions(+), 76 deletions(-)

diff --git a/dist/vue.runtime.mjs b/dist/vue.runtime.mjs
index 886d9f163ca..83d889271bd 100644
--- a/dist/vue.runtime.mjs
+++ b/dist/vue.runtime.mjs
@@ -1,76 +1,76 @@
-import Vue from './vue.runtime.common.js'
-export default Vue
-
-// this should be kept in sync with src/v3/index.ts
-export const {
-  version,
-
-  // refs
-  ref,
-  shallowRef,
-  isRef,
-  toRef,
-  toRefs,
-  unref,
-  proxyRefs,
-  customRef,
-  triggerRef,
-  computed,
-
-  // reactive
-  reactive,
-  isReactive,
-  isReadonly,
-  isShallow,
-  isProxy,
-  shallowReactive,
-  markRaw,
-  toRaw,
-  readonly,
-  shallowReadonly,
-
-  // watch
-  watch,
-  watchEffect,
-  watchPostEffect,
-  watchSyncEffect,
-
-  // effectScope
-  effectScope,
-  onScopeDispose,
-  getCurrentScope,
-
-  // provide / inject
-  provide,
-  inject,
-
-  // lifecycle
-  onBeforeMount,
-  onMounted,
-  onBeforeUpdate,
-  onUpdated,
-  onBeforeUnmount,
-  onUnmounted,
-  onErrorCaptured,
-  onActivated,
-  onDeactivated,
-  onServerPrefetch,
-  onRenderTracked,
-  onRenderTriggered,
-
-  // v2 only
-  set,
-  del,
-
-  // v3 compat
-  h,
-  getCurrentInstance,
-  useSlots,
-  useAttrs,
-  mergeDefaults,
-  nextTick,
-  useCssModule,
-  useCssVars,
-  defineComponent,
-  defineAsyncComponent
-} = Vue
+import Vue from './vue.runtime.common.js'
+export default Vue
+
+// this should be kept in sync with src/v3/index.ts
+export const {
+  version,
+
+  // refs
+  ref,
+  shallowRef,
+  isRef,
+  toRef,
+  toRefs,
+  unref,
+  proxyRefs,
+  customRef,
+  triggerRef,
+  computed,
+
+  // reactive
+  reactive,
+  isReactive,
+  isReadonly,
+  isShallow,
+  isProxy,
+  shallowReactive,
+  markRaw,
+  toRaw,
+  readonly,
+  shallowReadonly,
+
+  // watch
+  watch,
+  watchEffect,
+  watchPostEffect,
+  watchSyncEffect,
+
+  // effectScope
+  effectScope,
+  onScopeDispose,
+  getCurrentScope,
+
+  // provide / inject
+  provide,
+  inject,
+
+  // lifecycle
+  onBeforeMount,
+  onMounted,
+  onBeforeUpdate,
+  onUpdated,
+  onBeforeUnmount,
+  onUnmounted,
+  onErrorCaptured,
+  onActivated,
+  onDeactivated,
+  onServerPrefetch,
+  onRenderTracked,
+  onRenderTriggered,
+
+  // v2 only
+  set,
+  del,
+
+  // v3 compat
+  h,
+  getCurrentInstance,
+  useSlots,
+  useAttrs,
+  mergeDefaults,
+  nextTick,
+  useCssModule,
+  useCssVars,
+  defineComponent,
+  defineAsyncComponent
+} = Vue
diff --git a/tsconfig.json b/tsconfig.json
index 299b45f1861..214cb46c7c0 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,6 +6,7 @@
     "target": "esnext",
     "module": "ESNext",
     "moduleResolution": "node",
+    "newLine": "LF",
     "strict": true,
 
     "allowJs": true,

From 8880b55d52f8d873f79ef67436217c8752cddef5 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 19:02:47 +0800
Subject: [PATCH 291/317] perf: improve unsub perf for deps with massive amount
 of subs

close #12696
---
 src/core/observer/dep.ts               | 32 +++++++++++++++++++++-----
 src/core/observer/scheduler.ts         |  3 ++-
 src/shared/util.ts                     |  8 ++++++-
 test/unit/modules/observer/dep.spec.ts | 11 ++++++---
 4 files changed, 43 insertions(+), 11 deletions(-)

diff --git a/src/core/observer/dep.ts b/src/core/observer/dep.ts
index e18729cfde9..205efbbf5a0 100644
--- a/src/core/observer/dep.ts
+++ b/src/core/observer/dep.ts
@@ -1,9 +1,19 @@
-import { remove } from '../util/index'
 import config from '../config'
 import { DebuggerOptions, DebuggerEventExtraInfo } from 'v3'
 
 let uid = 0
 
+const pendingCleanupDeps: Dep[] = []
+
+export const cleanupDeps = () => {
+  for (let i = 0; i < pendingCleanupDeps.length; i++) {
+    const dep = pendingCleanupDeps[i]
+    dep.subs = dep.subs.filter(s => s)
+    dep._pending = false
+  }
+  pendingCleanupDeps.length = 0
+}
+
 /**
  * @internal
  */
@@ -21,7 +31,9 @@ export interface DepTarget extends DebuggerOptions {
 export default class Dep {
   static target?: DepTarget | null
   id: number
-  subs: Array<DepTarget>
+  subs: Array<DepTarget | null>
+  // pending subs cleanup
+  _pending = false
 
   constructor() {
     this.id = uid++
@@ -33,7 +45,15 @@ export default class Dep {
   }
 
   removeSub(sub: DepTarget) {
-    remove(this.subs, sub)
+    // #12696 deps with massive amount of subscribers are extremely slow to
+    // clean up in Chromium
+    // to workaround this, we unset the sub for now, and clear them on
+    // next scheduler flush.
+    this.subs[this.subs.indexOf(sub)] = null
+    if (!this._pending) {
+      this._pending = true
+      pendingCleanupDeps.push(this)
+    }
   }
 
   depend(info?: DebuggerEventExtraInfo) {
@@ -50,7 +70,7 @@ export default class Dep {
 
   notify(info?: DebuggerEventExtraInfo) {
     // stabilize the subscriber list first
-    const subs = this.subs.slice()
+    const subs = this.subs.filter(s => s) as DepTarget[]
     if (__DEV__ && !config.async) {
       // subs aren't sorted in scheduler if not running async
       // we need to sort them now to make sure they fire in correct
@@ -58,15 +78,15 @@ export default class Dep {
       subs.sort((a, b) => a.id - b.id)
     }
     for (let i = 0, l = subs.length; i < l; i++) {
+      const sub = subs[i]
       if (__DEV__ && info) {
-        const sub = subs[i]
         sub.onTrigger &&
           sub.onTrigger({
             effect: subs[i],
             ...info
           })
       }
-      subs[i].update()
+      sub.update()
     }
   }
 }
diff --git a/src/core/observer/scheduler.ts b/src/core/observer/scheduler.ts
index b019d9f6873..8fc82b48cf4 100644
--- a/src/core/observer/scheduler.ts
+++ b/src/core/observer/scheduler.ts
@@ -1,6 +1,6 @@
 import type Watcher from './watcher'
 import config from '../config'
-import Dep from './dep'
+import Dep, { cleanupDeps } from './dep'
 import { callHook, activateChildComponent } from '../instance/lifecycle'
 
 import { warn, nextTick, devtools, inBrowser, isIE } from '../util/index'
@@ -121,6 +121,7 @@ function flushSchedulerQueue() {
   // call component updated and activated hooks
   callActivatedHooks(activatedQueue)
   callUpdatedHooks(updatedQueue)
+  cleanupDeps()
 
   // devtool hook
   /* istanbul ignore if */
diff --git a/src/shared/util.ts b/src/shared/util.ts
index 0b9cf7f06ec..6eb54fdb4ef 100644
--- a/src/shared/util.ts
+++ b/src/shared/util.ts
@@ -133,7 +133,13 @@ export const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
  * Remove an item from an array.
  */
 export function remove(arr: Array<any>, item: any): Array<any> | void {
-  if (arr.length) {
+  const len = arr.length
+  if (len) {
+    // fast path for the only / last item
+    if (item === arr[len - 1]) {
+      arr.length = len - 1
+      return
+    }
     const index = arr.indexOf(item)
     if (index > -1) {
       return arr.splice(index, 1)
diff --git a/test/unit/modules/observer/dep.spec.ts b/test/unit/modules/observer/dep.spec.ts
index b851ccb2a49..de226812caf 100644
--- a/test/unit/modules/observer/dep.spec.ts
+++ b/test/unit/modules/observer/dep.spec.ts
@@ -1,4 +1,4 @@
-import Dep from 'core/observer/dep'
+import Dep, { cleanupDeps } from 'core/observer/dep'
 
 describe('Dep', () => {
   let dep
@@ -24,8 +24,13 @@ describe('Dep', () => {
 
   describe('removeSub()', () => {
     it('should remove sub', () => {
-      dep.subs.push(null)
-      dep.removeSub(null)
+      const sub = {}
+      dep.subs.push(sub)
+      dep.removeSub(sub)
+      expect(dep.subs.includes(sub)).toBe(false)
+
+      // nulled subs are cleared on next flush
+      cleanupDeps()
       expect(dep.subs.length).toBe(0)
     })
   })

From c61395d3f1ed926d2783d8460970ed20ea01dc4f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 11 Oct 2022 19:13:06 +0800
Subject: [PATCH 292/317] release: v2.7.11

---
 CHANGELOG.md                            | 23 +++++++++++++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3ccae2540a9..6fb79445878 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,26 @@
+## [2.7.11](https://github.com/vuejs/vue/compare/v2.7.10...v2.7.11) (2022-10-11)
+
+
+### Bug Fixes
+
+* **build:** enforce LF line ending in built files ([738f4b3](https://github.com/vuejs/vue/commit/738f4b3c570dc3a1818924a203a9f8e4b1ec90f0)), closes [#12819](https://github.com/vuejs/vue/issues/12819)
+* **compiler-sfc:** export parseComponent for compat with fork-ts-checker-webpack-plugin ([0d6d972](https://github.com/vuejs/vue/commit/0d6d972b32521fd18eb853b1073c0a19859a499a)), closes [#12719](https://github.com/vuejs/vue/issues/12719)
+* **reactivity:** check skip first before checking ref when creating observer ([#12813](https://github.com/vuejs/vue/issues/12813)) ([5d26f81](https://github.com/vuejs/vue/commit/5d26f815c643d41e6ca6f29329593223b981fc24)), closes [#12812](https://github.com/vuejs/vue/issues/12812)
+* **reactivity:** use WeakMap for proxy/raw checks, compat with non-extensible objects ([4a0d88e](https://github.com/vuejs/vue/commit/4a0d88e46e4180edc7f22e36c25df3f8ac5d60d2)), closes [#12799](https://github.com/vuejs/vue/issues/12799) [#12798](https://github.com/vuejs/vue/issues/12798)
+* **setup:** setup hook should be called before beforeCreate ([e1342df](https://github.com/vuejs/vue/commit/e1342df7847a51c75192fec74e94378178e046b0)), closes [#12802](https://github.com/vuejs/vue/issues/12802)
+* **sfc:** prune returned bindings for non-TS as well ([fb13930](https://github.com/vuejs/vue/commit/fb1393009660b38046b1f6dfb532b481cc53b3b7)), closes [#12765](https://github.com/vuejs/vue/issues/12765)
+* **sfc:** remove sfc scoped deep syntax deprecation warnings ([2f335b2](https://github.com/vuejs/vue/commit/2f335b2f9d09b962f40e38740826d444e4fff073))
+* **types:** fix error with options watch ([#12779](https://github.com/vuejs/vue/issues/12779)) ([bc5b92a](https://github.com/vuejs/vue/commit/bc5b92adde147436f2adb25e457f0c967829467f)), closes [#12780](https://github.com/vuejs/vue/issues/12780)
+* **types:** support Ref and function types in tsx ref attribute ([#12759](https://github.com/vuejs/vue/issues/12759)) ([87f69aa](https://github.com/vuejs/vue/commit/87f69aa26f195390b948fbb0ff62cf954b58c82c)), closes [#12758](https://github.com/vuejs/vue/issues/12758)
+* **types:** vue 3 directive type compatibility ([#12792](https://github.com/vuejs/vue/issues/12792)) ([27eed82](https://github.com/vuejs/vue/commit/27eed829ccf9978a63b8cd989ff4c03897276bc2))
+
+
+### Performance Improvements
+
+* improve unsub perf for deps with massive amount of subs ([8880b55](https://github.com/vuejs/vue/commit/8880b55d52f8d873f79ef67436217c8752cddef5)), closes [#12696](https://github.com/vuejs/vue/issues/12696)
+
+
+
 ## [2.7.10](https://github.com/vuejs/vue/compare/v2.7.9...v2.7.10) (2022-08-23)
 
 
diff --git a/package.json b/package.json
index 45728658733..d2210465745 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.10",
+  "version": "2.7.11",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 1cad61c2ec8..89cabf64059 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.10",
+  "version": "2.7.11",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 5470ebfaca3..ea9d4326d3d 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.10",
+  "version": "2.7.11",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 75285bc0e85..3f612871fc1 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.10",
+  "version": "2.7.11",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From e80cd09fff570df57d608f8f5aaccee6d7f31917 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 12 Oct 2022 21:22:26 +0800
Subject: [PATCH 293/317] Revert "fix(setup): setup hook should be called
 before beforeCreate"

This reverts commit e1342df7847a51c75192fec74e94378178e046b0.

reopen #12802
close #12821
close #12822
---
 src/core/instance/init.ts              |  9 ++-------
 src/core/instance/state.ts             |  9 +++++++--
 test/unit/features/v3/apiSetup.spec.ts | 28 +-------------------------
 3 files changed, 10 insertions(+), 36 deletions(-)

diff --git a/src/core/instance/init.ts b/src/core/instance/init.ts
index 3fdfcf4f0cf..91456c21920 100644
--- a/src/core/instance/init.ts
+++ b/src/core/instance/init.ts
@@ -1,6 +1,6 @@
 import config from '../config'
 import { initProxy } from './proxy'
-import { initProps, initState } from './state'
+import { initState } from './state'
 import { initRender } from './render'
 import { initEvents } from './events'
 import { mark, measure } from '../util/perf'
@@ -10,7 +10,6 @@ import { extend, mergeOptions, formatComponentName } from '../util/index'
 import type { Component } from 'types/component'
 import type { InternalComponentOptions } from 'types/options'
 import { EffectScope } from 'v3/reactivity/effectScope'
-import { initSetup } from '../../v3/apiSetup'
 
 let uid = 0
 
@@ -60,12 +59,8 @@ export function initMixin(Vue: typeof Component) {
     initLifecycle(vm)
     initEvents(vm)
     initRender(vm)
-
-    const opts = vm.$options
-    initInjections(vm) // resolve injections before data/props
-    initProps(vm, opts.props)
-    initSetup(vm)
     callHook(vm, 'beforeCreate', undefined, false /* setContext */)
+    initInjections(vm) // resolve injections before data/props
     initState(vm)
     initProvide(vm) // resolve provide after data/props
     callHook(vm, 'created')
diff --git a/src/core/instance/state.ts b/src/core/instance/state.ts
index 52b23cfd430..aedb72555c9 100644
--- a/src/core/instance/state.ts
+++ b/src/core/instance/state.ts
@@ -2,6 +2,7 @@ import config from '../config'
 import Watcher from '../observer/watcher'
 import Dep, { pushTarget, popTarget } from '../observer/dep'
 import { isUpdatingChildComponent } from './lifecycle'
+import { initSetup } from 'v3/apiSetup'
 
 import {
   set,
@@ -50,6 +51,11 @@ export function proxy(target: Object, sourceKey: string, key: string) {
 
 export function initState(vm: Component) {
   const opts = vm.$options
+  if (opts.props) initProps(vm, opts.props)
+
+  // Composition API
+  initSetup(vm)
+
   if (opts.methods) initMethods(vm, opts.methods)
   if (opts.data) {
     initData(vm)
@@ -63,8 +69,7 @@ export function initState(vm: Component) {
   }
 }
 
-export function initProps(vm: Component, propsOptions: Object | undefined) {
-  if (!propsOptions) return
+function initProps(vm: Component, propsOptions: Object) {
   const propsData = vm.$options.propsData || {}
   const props = (vm._props = shallowReactive({}))
   // cache prop keys so that future props updates can iterate using Array
diff --git a/test/unit/features/v3/apiSetup.spec.ts b/test/unit/features/v3/apiSetup.spec.ts
index 21b83769402..11757878e9c 100644
--- a/test/unit/features/v3/apiSetup.spec.ts
+++ b/test/unit/features/v3/apiSetup.spec.ts
@@ -263,7 +263,7 @@ describe('api: setup context', () => {
     }).$mount()
     expect(spy).toHaveBeenCalled()
   })
-
+  
   // #12561
   it('setup props should be reactive', () => {
     const msg = ref('hi')
@@ -333,30 +333,4 @@ describe('api: setup context', () => {
     await nextTick()
     expect(_listeners.foo()).toBe(2)
   })
-
-  // #12802
-  it('should be called before all lifecycle hooks', () => {
-    const calls: string[] = []
-
-    Vue.mixin({
-      beforeCreate() {
-        calls.push('global beforeCreate')
-      }
-    })
-
-    new Vue({
-      beforeCreate() {
-        calls.push('component beforeCreate')
-      },
-      setup() {
-        calls.push('setup')
-      }
-    })
-
-    expect(calls).toEqual([
-      'setup',
-      'global beforeCreate',
-      'component beforeCreate'
-    ])
-  })
 })

From 4cad41007174a7eeebf4472ddbd7b3b693db03f1 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 12 Oct 2022 21:41:36 +0800
Subject: [PATCH 294/317] release: v2.7.12

---
 CHANGELOG.md                            | 9 +++++++++
 package.json                            | 2 +-
 packages/compiler-sfc/package.json      | 2 +-
 packages/server-renderer/package.json   | 2 +-
 packages/template-compiler/package.json | 2 +-
 5 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6fb79445878..4d831fa047c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+## [2.7.12](https://github.com/vuejs/vue/compare/v2.7.11...v2.7.12) (2022-10-12)
+
+
+### Reverts
+
+* Revert "fix(setup): setup hook should be called before beforeCreate" ([e80cd09](https://github.com/vuejs/vue/commit/e80cd09fff570df57d608f8f5aaccee6d7f31917)), closes [#12802](https://github.com/vuejs/vue/issues/12802) [#12821](https://github.com/vuejs/vue/issues/12821) [#12822](https://github.com/vuejs/vue/issues/12822)
+
+
+
 ## [2.7.11](https://github.com/vuejs/vue/compare/v2.7.10...v2.7.11) (2022-10-11)
 
 
diff --git a/package.json b/package.json
index d2210465745..2bb114433f4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.11",
+  "version": "2.7.12",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 89cabf64059..e8ee4ecf382 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.11",
+  "version": "2.7.12",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index ea9d4326d3d..cfda873a1c8 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.11",
+  "version": "2.7.12",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 3f612871fc1..fd22b64d90b 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.11",
+  "version": "2.7.12",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 8e262618cdc3251ca9630b17de4a000567ffb007 Mon Sep 17 00:00:00 2001
From: Blake Newman <blake.newman@askattest.com>
Date: Wed, 12 Oct 2022 14:24:26 +0100
Subject: [PATCH 295/317] fix(types): style attribute svg (#12800)

Set style attribute on svg to use `StyleValue`
---
 types/jsx.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/types/jsx.d.ts b/types/jsx.d.ts
index 85c9c1df23d..4924f4c643c 100644
--- a/types/jsx.d.ts
+++ b/types/jsx.d.ts
@@ -731,7 +731,7 @@ export interface SVGAttributes extends AriaAttributes, EventHandlers<Events> {
    * @see https://www.w3.org/TR/SVG/styling.html#ElementSpecificStyling
    */
   class?: any
-  style?: string | CSSProperties
+  style?: StyleValue
 
   color?: string
   height?: Numberish

From 5960f05c69099c174062b6672c7a21d717a3bccf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E4=B8=8D=E8=A7=81=E6=9C=88?=
 <61452855+nooooooom@users.noreply.github.com>
Date: Wed, 12 Oct 2022 21:25:26 +0800
Subject: [PATCH 296/317] fix(watch): avoid traversing objects that are marked
 non-reactive (#12806)

---
 src/core/observer/traverse.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/core/observer/traverse.ts b/src/core/observer/traverse.ts
index 5f4e378b194..c681e0c9285 100644
--- a/src/core/observer/traverse.ts
+++ b/src/core/observer/traverse.ts
@@ -21,6 +21,7 @@ function _traverse(val: any, seen: SimpleSet) {
   const isA = isArray(val)
   if (
     (!isA && !isObject(val)) ||
+    val.__v_skip /* ReactiveFlags.SKIP */ ||
     Object.isFrozen(val) ||
     val instanceof VNode
   ) {

From 800207c473c7d6dfcdc883100a3d443fc5ad2e39 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 14 Oct 2022 10:51:07 +0800
Subject: [PATCH 297/317] fix(effectScope): calling off() of a detached scope
 should not break currentScope

fix #12825
---
 src/v3/reactivity/effectScope.ts                     |  9 ++++-----
 test/unit/features/v3/reactivity/effectScope.spec.ts | 11 +++++++++++
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/v3/reactivity/effectScope.ts b/src/v3/reactivity/effectScope.ts
index 2ba50cd9ca8..f60e5fccf23 100644
--- a/src/v3/reactivity/effectScope.ts
+++ b/src/v3/reactivity/effectScope.ts
@@ -16,9 +16,7 @@ export class EffectScope {
    * @internal
    */
   cleanups: (() => void)[] = []
-
   /**
-   * only assigned by undetached scope
    * @internal
    */
   parent: EffectScope | undefined
@@ -38,9 +36,9 @@ export class EffectScope {
    */
   private index: number | undefined
 
-  constructor(detached = false) {
+  constructor(public detached = false) {
+    this.parent = activeEffectScope
     if (!detached && activeEffectScope) {
-      this.parent = activeEffectScope
       this.index =
         (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
           this
@@ -93,7 +91,7 @@ export class EffectScope {
         }
       }
       // nested scope, dereference from parent to avoid memory leaks
-      if (this.parent && !fromParent) {
+      if (!this.detached && this.parent && !fromParent) {
         // optimized O(1) removal
         const last = this.parent.scopes!.pop()
         if (last && last !== this) {
@@ -101,6 +99,7 @@ export class EffectScope {
           last.index = this.index!
         }
       }
+      this.parent = undefined
       this.active = false
     }
   }
diff --git a/test/unit/features/v3/reactivity/effectScope.spec.ts b/test/unit/features/v3/reactivity/effectScope.spec.ts
index b82127cdc76..6b837e67cdc 100644
--- a/test/unit/features/v3/reactivity/effectScope.spec.ts
+++ b/test/unit/features/v3/reactivity/effectScope.spec.ts
@@ -279,4 +279,15 @@ describe('reactivity/effectScope', () => {
       expect(getCurrentScope()).toBe(currentScope)
     })
   })
+
+  it('calling .off() of a detached scope inside an active scope should not break currentScope', () => {
+    const parentScope = new EffectScope()
+
+    parentScope.run(() => {
+      const childScope = new EffectScope(true)
+      childScope.on()
+      childScope.off()
+      expect(getCurrentScope()).toBe(parentScope)
+    })
+  })
 })

From df281b0e4c400be18df8bcf4e83df8b25a81e21b Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 14 Oct 2022 11:41:56 +0800
Subject: [PATCH 298/317] release: v2.7.13

---
 CHANGELOG.md                            | 11 +++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d831fa047c..4c75474b8d6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+## [2.7.13](https://github.com/vuejs/vue/compare/v2.7.12...v2.7.13) (2022-10-14)
+
+
+### Bug Fixes
+
+* **effectScope:** calling off() of a detached scope should not break currentScope ([800207c](https://github.com/vuejs/vue/commit/800207c473c7d6dfcdc883100a3d443fc5ad2e39)), closes [#12825](https://github.com/vuejs/vue/issues/12825)
+* **types:** style attribute svg ([#12800](https://github.com/vuejs/vue/issues/12800)) ([8e26261](https://github.com/vuejs/vue/commit/8e262618cdc3251ca9630b17de4a000567ffb007))
+* **watch:** avoid traversing objects that are marked non-reactive ([#12806](https://github.com/vuejs/vue/issues/12806)) ([5960f05](https://github.com/vuejs/vue/commit/5960f05c69099c174062b6672c7a21d717a3bccf))
+
+
+
 ## [2.7.12](https://github.com/vuejs/vue/compare/v2.7.11...v2.7.12) (2022-10-12)
 
 
diff --git a/package.json b/package.json
index 2bb114433f4..33eff56cac0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.12",
+  "version": "2.7.13",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index e8ee4ecf382..5159c5cce04 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.12",
+  "version": "2.7.13",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index cfda873a1c8..194d6e9f765 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.12",
+  "version": "2.7.13",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index fd22b64d90b..79515498d03 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.12",
+  "version": "2.7.13",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From 259c7060da72ea3040fc8c3de4ecb823ad5059f4 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 15 Oct 2022 17:39:04 +0800
Subject: [PATCH 299/317] chore: fix changelog rendering [ci skip]

---
 CHANGELOG.md | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4c75474b8d6..a2432812ed0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -888,7 +888,7 @@ In addition:
 - **compiler:** wrap scoped slots v-if conditions in parens ([#9119](https://github.com/vuejs/vue/issues/9119)) ([ef8524a](https://github.com/vuejs/vue/commit/ef8524ab7db8d64ac449ce74f5858aa9d91357ad)), closes [#9114](https://github.com/vuejs/vue/issues/9114)
 - **compiler:** maybeComponent should return true when "is" attribute exists ([#8114](https://github.com/vuejs/vue/issues/8114)) ([aef2a5f](https://github.com/vuejs/vue/commit/aef2a5f3dbd5e52ec9d5ce026d7b858539057186)), closes [#8101](https://github.com/vuejs/vue/issues/8101)
 - **compiler:** normalize potential functional component children in v-for ([#8558](https://github.com/vuejs/vue/issues/8558)) ([d483a49](https://github.com/vuejs/vue/commit/d483a49c86874b2e75863b661f81feecd46ae721)), closes [#8468](https://github.com/vuejs/vue/issues/8468)
-- **compiler:** should keep newline after unary tags in <pre> ([#8965](https://github.com/vuejs/vue/issues/8965)) ([05001e6](https://github.com/vuejs/vue/commit/05001e695ebd0b0504d664197a4771463a0f5328)), closes [#8950](https://github.com/vuejs/vue/issues/8950)
+- **compiler:** should keep newline after unary tags in `<pre>`  ([#8965](https://github.com/vuejs/vue/issues/8965)) ([05001e6](https://github.com/vuejs/vue/commit/05001e695ebd0b0504d664197a4771463a0f5328)), closes [#8950](https://github.com/vuejs/vue/issues/8950)
 - **compiler:** templates inside v-pre should be rendered to HTML ([#8146](https://github.com/vuejs/vue/issues/8146)) ([ecac831](https://github.com/vuejs/vue/commit/ecac831691d27cf7a10ec73a004d3fbad7623d1a)), closes [#8041](https://github.com/vuejs/vue/issues/8041)
 - **component:** clean up memory leak after loading async component completes (fix [#8740](https://github.com/vuejs/vue/issues/8740)) ([#8755](https://github.com/vuejs/vue/issues/8755)) ([2e472c5](https://github.com/vuejs/vue/commit/2e472c5e5e559a7a4083b4164ffe0c3911ce0651))
 - **core:** avoid mutating original children when cloning vnode ([097f622](https://github.com/vuejs/vue/commit/097f6229dffc34af452b106ad2a3b58845588807)), closes [#7975](https://github.com/vuejs/vue/issues/7975)
@@ -1176,7 +1176,7 @@ In addition:
 - properly mark slot rendered flag in production mode ([4fe1a95](https://github.com/vuejs/vue/commit/4fe1a95d2953ecf765e27677fa70ebadb176d4c3)), closes [#6997](https://github.com/vuejs/vue/issues/6997)
 - **slots:** properly handle nested named slot passing ([5a9da95](https://github.com/vuejs/vue/commit/5a9da95b8a865416f082952a48416ffc091e4078)), closes [#6996](https://github.com/vuejs/vue/issues/6996)
 - special case for static muted attribute in firefox ([f2e00f7](https://github.com/vuejs/vue/commit/f2e00f756fb540fb09ce3414289c652ce172d85c)), closes [#6887](https://github.com/vuejs/vue/issues/6887)
-- **ssr:** properly render <select v-model> initial state ([e1657fd](https://github.com/vuejs/vue/commit/e1657fd7ce49bff3c3ecad3c56ae527347505c34)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
+- **ssr:** properly render `<select v-model>` initial state ([e1657fd](https://github.com/vuejs/vue/commit/e1657fd7ce49bff3c3ecad3c56ae527347505c34)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
 - **ssr:** properly render textarea value ([79c0d7b](https://github.com/vuejs/vue/commit/79c0d7bcfbcd1ac492e7ceb77f5024d09efdc6b3)), closes [#6986](https://github.com/vuejs/vue/issues/6986)
 - **ssr:** should not optimize root if conditions ([4ad9a56](https://github.com/vuejs/vue/commit/4ad9a56b229b156e633f3d575cd0e99ba5e474d9)), closes [#6907](https://github.com/vuejs/vue/issues/6907)
 - **types:** improve typing for better completion ([#6886](https://github.com/vuejs/vue/issues/6886)) ([98ea0a3](https://github.com/vuejs/vue/commit/98ea0a3b48e37719f278c10a8ee5fb94d7d5db4e))
@@ -1213,14 +1213,14 @@ In addition:
 - fallback to Promise in non-DOM environments ([6d1f4cb](https://github.com/vuejs/vue/commit/6d1f4cb89a156bf5f84942b1031354aa93916cb7))
 - fix scoped CSS for nested nodes in functional components ([4216588](https://github.com/vuejs/vue/commit/421658884f7ca786747abf9b89e00925fdfdfba8))
 - handle errors in errorHandler ([2b5c83a](https://github.com/vuejs/vue/commit/2b5c83af6d8b15510424af4877d58c261ea02e16)), closes [#6714](https://github.com/vuejs/vue/issues/6714)
-- perperly handle v-if on <template> scoped slot ([68bdbf5](https://github.com/vuejs/vue/commit/68bdbf508b915872627676d6bf987bdac9e5fe97)), closes [#6725](https://github.com/vuejs/vue/issues/6725)
+- properly handle v-if on `<template>` scoped slot ([68bdbf5](https://github.com/vuejs/vue/commit/68bdbf508b915872627676d6bf987bdac9e5fe97)), closes [#6725](https://github.com/vuejs/vue/issues/6725)
 - prevent memory leak due to circular reference in vnodes ([405d8e9](https://github.com/vuejs/vue/commit/405d8e9f4c3201db2ae0e397d9191d9b94edc219)), closes [#6759](https://github.com/vuejs/vue/issues/6759)
-- properly render value on <progress> in IE/Edge ([c64f9ae](https://github.com/vuejs/vue/commit/c64f9ae1649175ee8cac1c7ecf3283897c948202)), closes [#6666](https://github.com/vuejs/vue/issues/6666)
+- properly render value on `<progress>` in IE/Edge ([c64f9ae](https://github.com/vuejs/vue/commit/c64f9ae1649175ee8cac1c7ecf3283897c948202)), closes [#6666](https://github.com/vuejs/vue/issues/6666)
 - **ref:** preserve ref on components after removing root element ([#6718](https://github.com/vuejs/vue/issues/6718)) ([6ad44e1](https://github.com/vuejs/vue/commit/6ad44e13e990951ff152a0fd7042613c5a87f1c0)), closes [#6632](https://github.com/vuejs/vue/issues/6632) [#6641](https://github.com/vuejs/vue/issues/6641)
 - resolve async component default for native dynamic import ([2876ed8](https://github.com/vuejs/vue/commit/2876ed870c5368a1767fbeddf06e94b55ebd6234)), closes [#6751](https://github.com/vuejs/vue/issues/6751)
 - **ssr:** fix hydration mismatch with adjacent text node from slots ([b080a14](https://github.com/vuejs/vue/commit/b080a14138262f0f274d0888555a11bd7387d576)), closes [vuejs/vue-loader#974](https://github.com/vuejs/vue-loader/issues/974)
 - **ssr:** handle inline template compilation error ([dff85b2](https://github.com/vuejs/vue/commit/dff85b230abda63839ed6b80d56ccfc6068b9ae0)), closes [#6766](https://github.com/vuejs/vue/issues/6766)
-- use correct ns inside <foreignObject> as root node ([cf1ff5b](https://github.com/vuejs/vue/commit/cf1ff5b0dc3d15c1e16821cb5e4fc984c74f07c1)), closes [#6642](https://github.com/vuejs/vue/issues/6642)
+- use correct ns inside `<foreignObject>` as root node ([cf1ff5b](https://github.com/vuejs/vue/commit/cf1ff5b0dc3d15c1e16821cb5e4fc984c74f07c1)), closes [#6642](https://github.com/vuejs/vue/issues/6642)
 - use MessageChannel for nextTick ([6e41679](https://github.com/vuejs/vue/commit/6e41679a96582da3e0a60bdbf123c33ba0e86b31)), closes [#6566](https://github.com/vuejs/vue/issues/6566) [#6690](https://github.com/vuejs/vue/issues/6690)
 - warn slot-scope when used as a prop ([8295f71](https://github.com/vuejs/vue/commit/8295f716657ffe516f30e84f29ca94f4a0aefabf))
 - work around old Chrome bug ([0f2cb09](https://github.com/vuejs/vue/commit/0f2cb09444e8b2a5fa41aaf8c94e6f2f43e00c2f)), closes [#6601](https://github.com/vuejs/vue/issues/6601)
@@ -1271,12 +1271,12 @@ In addition:
 - do not use MutationObserver in IE11 ([844a540](https://github.com/vuejs/vue/commit/844a540c647dfa93dc714540953524830dd3475a)), closes [#6466](https://github.com/vuejs/vue/issues/6466)
 - ensure $attrs and $listeners are always objects ([#6441](https://github.com/vuejs/vue/issues/6441)) ([59dbd4a](https://github.com/vuejs/vue/commit/59dbd4a414394a3ce581f9fbd9554da9af9e4b1d)), closes [#6263](https://github.com/vuejs/vue/issues/6263)
 - ensure outer bindings on nested HOC are properly re-applied on inner root element change ([a744497](https://github.com/vuejs/vue/commit/a7444975343f7828004d90bfb0deeb98db0f46e7))
-- handle special case for allowfullscreen on <embed> ([d77b953](https://github.com/vuejs/vue/commit/d77b95317cedae299605fb692e2c7c67796b17cb)), closes [#6202](https://github.com/vuejs/vue/issues/6202)
+- handle special case for allowfullscreen on `<embed>` ([d77b953](https://github.com/vuejs/vue/commit/d77b95317cedae299605fb692e2c7c67796b17cb)), closes [#6202](https://github.com/vuejs/vue/issues/6202)
 - inherit SVG ns on component root node ([#6511](https://github.com/vuejs/vue/issues/6511)) ([89f0d29](https://github.com/vuejs/vue/commit/89f0d29f2d541aa5a1ac9690258cd7c7ee576ef6)), closes [#6506](https://github.com/vuejs/vue/issues/6506)
 - **inject:** exclude not enumerable keys of inject object ([#6346](https://github.com/vuejs/vue/issues/6346)) ([3ee62fd](https://github.com/vuejs/vue/commit/3ee62fd59e20030dd63c08c2390e803d034928fe)), closes [#6574](https://github.com/vuejs/vue/issues/6574)
 - preserve slot attribute if not resolved by Vue ([684cd7d](https://github.com/vuejs/vue/commit/684cd7d21aa7cb9a40fb4a8542c4e08fb3801a86)), closes [#6553](https://github.com/vuejs/vue/issues/6553)
 - **provide:** provide should default to parentVal during merging ([#6473](https://github.com/vuejs/vue/issues/6473)) ([3c21675](https://github.com/vuejs/vue/commit/3c216755f6eb656c6d864265a8dc7b51b3ae971b)), closes [#6436](https://github.com/vuejs/vue/issues/6436)
-- set value as domProp for <progress> ([7116af4](https://github.com/vuejs/vue/commit/7116af4e07520040ed7328c39d0a456808bfe1e1)), closes [#6561](https://github.com/vuejs/vue/issues/6561)
+- set value as domProp for `<progress>` ([7116af4](https://github.com/vuejs/vue/commit/7116af4e07520040ed7328c39d0a456808bfe1e1)), closes [#6561](https://github.com/vuejs/vue/issues/6561)
 - **ssr:** address possible xss vector ([5091e2c](https://github.com/vuejs/vue/commit/5091e2c9847601e329ac36d17eae90bb5cb77a91))
 - **ssr:** better handle v-html hydration ([0f00f8f](https://github.com/vuejs/vue/commit/0f00f8fc2b83b964bb929b729a7c9e3675b52106)), closes [#6519](https://github.com/vuejs/vue/issues/6519)
 - **ssr:** expose context.styles when no lifecycle styles are injected ([1f52a2a](https://github.com/vuejs/vue/commit/1f52a2a9f433452c15715131ed74433a43d5cfb7)), closes [#6353](https://github.com/vuejs/vue/issues/6353)
@@ -1319,12 +1319,12 @@ In addition:
 - **compile:** properly generate comments with special character ([#6156](https://github.com/vuejs/vue/issues/6156)) ([d03fa26](https://github.com/vuejs/vue/commit/d03fa26687605a43d9a0c3f395d1d32375f7eaee)), closes [#6150](https://github.com/vuejs/vue/issues/6150)
 - ensure looseEqual is not dependant on key enumeration order ([a8ac129](https://github.com/vuejs/vue/commit/a8ac129a5876a7eeae0137bf2f1b0968d4d6ffad)), closes [#5908](https://github.com/vuejs/vue/issues/5908)
 - include boolean in isPrimitive check ([#6127](https://github.com/vuejs/vue/issues/6127)) ([be3dc9c](https://github.com/vuejs/vue/commit/be3dc9c6e923248bcf81eb8240dd4f3c168fac59)), closes [#6126](https://github.com/vuejs/vue/issues/6126)
-- **parser:** only ignore the first newline in <pre> ([082fc39](https://github.com/vuejs/vue/commit/082fc3967db4d3290e901a38504dcd9bb698e561)), closes [#6146](https://github.com/vuejs/vue/issues/6146)
+- **parser:** only ignore the first newline in `<pre>` ([082fc39](https://github.com/vuejs/vue/commit/082fc3967db4d3290e901a38504dcd9bb698e561)), closes [#6146](https://github.com/vuejs/vue/issues/6146)
 - **provide/inject:** merge provide properly from mixins ([3036551](https://github.com/vuejs/vue/commit/303655116f8ec78f3b0ac99569637ad868dfe246)), closes [#6175](https://github.com/vuejs/vue/issues/6175)
 - **provide/inject:** resolve inject properly from mixins ([#6107](https://github.com/vuejs/vue/issues/6107)) ([b0f00e3](https://github.com/vuejs/vue/commit/b0f00e31e7d06edfdc733e2e7f24d5ca448759f9)), closes [#6093](https://github.com/vuejs/vue/issues/6093)
 - **transition:** should trigger transition hooks for v-show in ie9 ([9b4dbba](https://github.com/vuejs/vue/commit/9b4dbba384bc81a99abe429476729f80cb06d19a)), closes [#5525](https://github.com/vuejs/vue/issues/5525)
 - **v-bind:** respect .prop modifier on components ([#6159](https://github.com/vuejs/vue/issues/6159)) ([06b9b0b](https://github.com/vuejs/vue/commit/06b9b0bbadcc6c5afd300ed7748294e62ba00803))
-- **v-model:** use stricter check for <select> option update ([c70addf](https://github.com/vuejs/vue/commit/c70addf7d1a8e820ed80b6ab14aace5aa7b604c5)), closes [#6112](https://github.com/vuejs/vue/issues/6112)
+- **v-model:** use stricter check for `<select>` option update ([c70addf](https://github.com/vuejs/vue/commit/c70addf7d1a8e820ed80b6ab14aace5aa7b604c5)), closes [#6112](https://github.com/vuejs/vue/issues/6112)
 - **v-on:** revert component root data.on/data.nativeOn behavior for ([1713061](https://github.com/vuejs/vue/commit/17130611261fdbab70d0e5ab45036e4b612b17fe)), closes [#6109](https://github.com/vuejs/vue/issues/6109)
 - work around IE/Edge bug when accessing document.activeElement from iframe ([fc3d7cd](https://github.com/vuejs/vue/commit/fc3d7cd7a93534d76840418467f303d4b301fbcd)), closes [#6157](https://github.com/vuejs/vue/issues/6157)
 

From a7a71ad99071c8c48ae9c106a19f81e70ded4898 Mon Sep 17 00:00:00 2001
From: Jinjiang <zhaojinjiang@me.com>
Date: Sun, 16 Oct 2022 20:13:22 +0800
Subject: [PATCH 300/317] Update the dev to main in the PR template (#12834)

---
 .github/PULL_REQUEST_TEMPLATE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 7bda0561856..21f32de041a 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -24,7 +24,7 @@ If yes, please describe the impact and migration path for existing applications:
 
 **The PR fulfills these requirements:**
 
-- [ ] It's submitted to the `dev` branch for v2.x (or to a previous version branch), _not_ the `master` branch
+- [ ] It's submitted to the `main` branch for v2.x (or to a previous version branch)
 - [ ] When resolving a specific issue, it's referenced in the PR's title (e.g. `fix #xxx[,#xxx]`, where "xxx" is the issue number)
 - [ ] All tests are passing: https://github.com/vuejs/vue/blob/dev/.github/CONTRIBUTING.md#development-setup
 - [ ] New/updated tests are included

From 6d9aac8bd38f6d30a6db70b51fa46f27cbeac559 Mon Sep 17 00:00:00 2001
From: Jinjiang <zhaojinjiang@me.com>
Date: Wed, 19 Oct 2022 12:45:59 +0800
Subject: [PATCH 301/317] chore: fix some broken links to v2 docs (#12839)

---
 examples/classic/elastic-header/index.html |  2 +-
 examples/classic/todomvc/app.js            |  4 ++--
 examples/classic/todomvc/readme.md         | 10 +++++-----
 src/compiler/codegen/index.ts              |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/examples/classic/elastic-header/index.html b/examples/classic/elastic-header/index.html
index 3ba66367de6..095c1beeb20 100644
--- a/examples/classic/elastic-header/index.html
+++ b/examples/classic/elastic-header/index.html
@@ -32,7 +32,7 @@
       <draggable-header-view>
         <template slot="header">
           <h1>Elastic Draggable SVG Header</h1>
-          <p>with <a href="https://vuejs.org">Vue.js</a> + <a href="http://dynamicsjs.com">dynamics.js</a></p>
+          <p>with <a href="https://v2.vuejs.org">Vue.js</a> + <a href="http://dynamicsjs.com">dynamics.js</a></p>
         </template>
         <template slot="content">
           <p>Note this is just an effect demo - there are of course many additional details if you want to use this in production, e.g. handling responsive sizes, reload threshold and content scrolling. Those are out of scope for this quick little hack. However, the idea is that you can hide them as internal details of a Vue.js component and expose a simple Web-Component-like interface.</p>
diff --git a/examples/classic/todomvc/app.js b/examples/classic/todomvc/app.js
index f8bfeb1ea61..7a1a65486a3 100644
--- a/examples/classic/todomvc/app.js
+++ b/examples/classic/todomvc/app.js
@@ -55,7 +55,7 @@ var app = new Vue({
   },
 
   // computed properties
-  // https://vuejs.org/guide/computed.html
+  // https://v2.vuejs.org/v2/guide/computed.html
   computed: {
     filteredTodos: function () {
       return filters[this.visibility](this.todos)
@@ -129,7 +129,7 @@ var app = new Vue({
 
   // a custom directive to wait for the DOM to be updated
   // before focusing on the input field.
-  // https://vuejs.org/guide/custom-directive.html
+  // https://v2.vuejs.org/v2/guide/custom-directive.html
   directives: {
     'todo-focus': function (el, binding) {
       if (binding.value) {
diff --git a/examples/classic/todomvc/readme.md b/examples/classic/todomvc/readme.md
index 3155b80944d..64277f62e9a 100644
--- a/examples/classic/todomvc/readme.md
+++ b/examples/classic/todomvc/readme.md
@@ -3,16 +3,16 @@
 > Vue.js is a library for building interactive web interfaces. 
 It provides data-driven, nestable view components with a simple and flexible API.
 
-> _[Vue.js - vuejs.org](https://vuejs.org)_
+> _[Vue.js - v2.vuejs.org](https://v2.vuejs.org)_
 
 ## Learning Vue.js
-The [Vue.js website](https://vuejs.org/) is a great resource to get started.
+The [Vue.js website](https://v2.vuejs.org/) is a great resource to get started.
 
 Here are some links you may find helpful:
 
-* [Official Guide](https://vuejs.org/guide/)
-* [API Reference](https://vuejs.org/api/)
-* [Examples](https://vuejs.org/examples/)
+* [Official Guide](https://v2.vuejs.org/guide/)
+* [API Reference](https://v2.vuejs.org/api/)
+* [Examples](https://v2.vuejs.org/examples/)
 
 Get help from other Vue.js users:
 
diff --git a/src/compiler/codegen/index.ts b/src/compiler/codegen/index.ts
index e3d5935b8d6..b0daf352f82 100644
--- a/src/compiler/codegen/index.ts
+++ b/src/compiler/codegen/index.ts
@@ -259,7 +259,7 @@ export function genFor(
     state.warn(
       `<${el.tag} v-for="${alias} in ${exp}">: component lists rendered with ` +
         `v-for should have explicit keys. ` +
-        `See https://vuejs.org/guide/list.html#key for more info.`,
+        `See https://v2.vuejs.org/v2/guide/list.html#key for more info.`,
       el.rawAttrsMap['v-for'],
       true /* tip */
     )

From a5afc4d0a4bfb9a777ac39b942edb932aad71097 Mon Sep 17 00:00:00 2001
From: webfansplz <308241863@qq.com>
Date: Wed, 9 Nov 2022 16:07:36 +0800
Subject: [PATCH 302/317] chore: fix typo (#12863)

---
 packages/compiler-sfc/test/compileScript.spec.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index 7924c83d4eb..a67e27058c4 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -1571,7 +1571,7 @@ describe('SFC analyze <script> bindings', () => {
       </script>
       <template>
         <div @click="$emit('update:a');"></div>
-      </tempalte>
+      </template>
       `)
     })
   })

From 0b3cf7dda9ac605b2b9f799acacd2793e974f225 Mon Sep 17 00:00:00 2001
From: webfansplz <308241863@qq.com>
Date: Wed, 9 Nov 2022 17:25:28 +0800
Subject: [PATCH 303/317] fix(types): stricter type condition for
 `EventHandlers` (#12840)

fix #12832
---
 types/jsx.d.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/types/jsx.d.ts b/types/jsx.d.ts
index 4924f4c643c..845cfdcb030 100644
--- a/types/jsx.d.ts
+++ b/types/jsx.d.ts
@@ -1297,7 +1297,9 @@ export interface Events {
 }
 
 type EventHandlers<E> = {
-  [K in keyof E]?: E[K] extends Function ? E[K] : (payload: E[K]) => void
+  [K in keyof E]?: E[K] extends (...args: any) => any
+    ? E[K]
+    : (payload: E[K]) => void
 }
 
 type ReservedProps = {

From f7db7f361b6356591781b9f33abbb0d5b7f9b97c Mon Sep 17 00:00:00 2001
From: k-furusho <88301866+k-furusho@users.noreply.github.com>
Date: Wed, 9 Nov 2022 18:34:55 +0900
Subject: [PATCH 304/317] fix(types): fix spreading VNodeData in tsx (#12789)

fix #12778
---
 types/test/vue-test.ts | 14 +++++++-------
 types/vnode.d.ts       |  3 ++-
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/types/test/vue-test.ts b/types/test/vue-test.ts
index b792cec583d..fdf37b52abb 100644
--- a/types/test/vue-test.ts
+++ b/types/test/vue-test.ts
@@ -228,21 +228,21 @@ obj.a++
 const ComponentWithStyleInVNodeData = Vue.extend({
   render(h) {
     const elementWithStyleAsString = h('div', {
-      style: 'background-color: red;'
+      style: '--theme-color: black;'
     })
 
-    const elementWithStyleAsObject = h('div', {
-      style: { backgroundColor: 'green' }
+    const elementWithStyleCSSProperties = h('div', {
+      style: { ['--theme-color' as any]: 'black' }
     })
 
-    const elementWithStyleAsArrayOfObjects = h('div', {
-      style: [{ backgroundColor: 'blue' }]
+    const elementWithStyleAsArrayOfStyleValues = h('div', {
+      style: [{ ['--theme-color' as any]: 'black' }]
     })
 
     return h('div', undefined, [
       elementWithStyleAsString,
-      elementWithStyleAsObject,
-      elementWithStyleAsArrayOfObjects
+      elementWithStyleCSSProperties,
+      elementWithStyleAsArrayOfStyleValues
     ])
   }
 })
diff --git a/types/vnode.d.ts b/types/vnode.d.ts
index 29bdb398c1c..d6f23ec3b67 100644
--- a/types/vnode.d.ts
+++ b/types/vnode.d.ts
@@ -1,3 +1,4 @@
+import { StyleValue } from './jsx'
 import { Vue } from './vue'
 import { DirectiveFunction, DirectiveOptions } from './options'
 import { Ref } from './v3-generated'
@@ -85,7 +86,7 @@ export interface VNodeData {
   staticClass?: string
   class?: any
   staticStyle?: { [key: string]: any }
-  style?: string | object[] | object
+  style?: StyleValue
   props?: { [key: string]: any }
   attrs?: { [key: string]: any }
   domProps?: { [key: string]: any }

From 5aed733ab6b6605314cc5f24cc1b1dd9aa4413c8 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 9 Nov 2022 17:35:45 +0800
Subject: [PATCH 305/317] test: add test case for #12778

---
 types/test/v3/tsx-test.tsx | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/types/test/v3/tsx-test.tsx b/types/test/v3/tsx-test.tsx
index 286c16997a0..6a9dcce4fc1 100644
--- a/types/test/v3/tsx-test.tsx
+++ b/types/test/v3/tsx-test.tsx
@@ -1,4 +1,4 @@
-import { VNode, defineComponent, ref } from '../../index'
+import { VNode, defineComponent, ref, RenderContext } from '../../index'
 import { expectType } from '../utils'
 
 expectType<VNode>(<div />)
@@ -25,7 +25,13 @@ expectType<JSX.Element>(<div ref="bar" />)
 // allow Ref type type on arbitrary element
 const fooRef = ref<HTMLElement>()
 expectType<JSX.Element>(<div ref={fooRef} />)
-expectType<JSX.Element>(<div ref={(el) => {fooRef.value = el as HTMLElement}} />)
+expectType<JSX.Element>(
+  <div
+    ref={el => {
+      fooRef.value = el as HTMLElement
+    }}
+  />
+)
 
 expectType<JSX.Element>(
   <input
@@ -56,5 +62,8 @@ const Foo = defineComponent({
 // working
 ;<Foo bar={1} />
 ;<Foo bar={1} foo="baz" />
-
 ;<div slot="x" />
+
+export default ({ data }: RenderContext) => {
+  return <button {...data} />
+}

From 5e3d4e90cdf92ec0a72bbb2bd44125f1faafae1d Mon Sep 17 00:00:00 2001
From: a161803398 <a161803398@gmail.com>
Date: Wed, 9 Nov 2022 17:52:35 +0800
Subject: [PATCH 306/317] fix(compiler-sfc): fix template usage check edge case
 for v-slot destructured default value (#12842)

fix #12841
---
 packages/compiler-sfc/src/compileScript.ts       |  4 +++-
 packages/compiler-sfc/test/compileScript.spec.ts | 16 ++++++++++++++++
 src/compiler/parser/index.ts                     |  2 +-
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/packages/compiler-sfc/src/compileScript.ts b/packages/compiler-sfc/src/compileScript.ts
index 548fc592423..db04dbef333 100644
--- a/packages/compiler-sfc/src/compileScript.ts
+++ b/packages/compiler-sfc/src/compileScript.ts
@@ -39,7 +39,7 @@ import { walk } from 'estree-walker'
 import { RawSourceMap } from 'source-map'
 import { warnOnce } from './warn'
 import { isReservedTag } from 'web/util'
-import { bindRE, dirRE, onRE } from 'compiler/parser'
+import { bindRE, dirRE, onRE, slotRE } from 'compiler/parser'
 import { parseText } from 'compiler/parser/text-parser'
 import { DEFAULT_FILENAME } from './parseComponent'
 import {
@@ -1804,6 +1804,8 @@ function resolveTemplateUsageCheckString(sfc: SFCDescriptor, isTS: boolean) {
         if (dirRE.test(name)) {
           const baseName = onRE.test(name)
             ? 'on'
+            : slotRE.test(name)
+            ? 'slot'
             : bindRE.test(name)
             ? 'bind'
             : name.replace(dirRE, '')
diff --git a/packages/compiler-sfc/test/compileScript.spec.ts b/packages/compiler-sfc/test/compileScript.spec.ts
index a67e27058c4..11077b2aacc 100644
--- a/packages/compiler-sfc/test/compileScript.spec.ts
+++ b/packages/compiler-sfc/test/compileScript.spec.ts
@@ -1574,5 +1574,21 @@ describe('SFC analyze <script> bindings', () => {
       </template>
       `)
     })
+
+    // #12841
+    test('should not error when performing ts expression check for v-slot destructured default value', () => {
+      compile(`
+      <script setup lang="ts">
+        import FooComp from './Foo.vue'
+      </script>
+      <template>
+        <FooComp>
+          <template #bar="{ bar = { baz: '' } }">
+            {{ bar.baz }}
+          </template>
+        </FooComp>
+      </template>
+      `)
+    })
   })
 })
diff --git a/src/compiler/parser/index.ts b/src/compiler/parser/index.ts
index c02379d0f14..148cc0110f5 100644
--- a/src/compiler/parser/index.ts
+++ b/src/compiler/parser/index.ts
@@ -42,7 +42,7 @@ export const bindRE = /^:|^\.|^v-bind:/
 const propBindRE = /^\./
 const modifierRE = /\.[^.\]]+(?=[^\]]*$)/g
 
-const slotRE = /^v-slot(:|$)|^#/
+export const slotRE = /^v-slot(:|$)|^#/
 
 const lineBreakRE = /[\r\n]/
 const whitespaceRE = /[ \f\t\r\n]+/g

From d1899caf688de961e63e7a0d56f806fc4a12efd9 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 9 Nov 2022 20:04:25 +0800
Subject: [PATCH 307/317] fix(provide/inject): do not mutate original provide
 options during merge

fix #12854
---
 src/core/util/options.ts                  | 22 +++++++++++++++++++---
 test/unit/features/options/inject.spec.ts |  8 ++++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/core/util/options.ts b/src/core/util/options.ts
index baddeb09b6e..ef6a10342a9 100644
--- a/src/core/util/options.ts
+++ b/src/core/util/options.ts
@@ -51,7 +51,8 @@ if (__DEV__) {
  */
 function mergeData(
   to: Record<string | symbol, any>,
-  from: Record<string | symbol, any> | null
+  from: Record<string | symbol, any> | null,
+  recursive = true
 ): Record<PropertyKey, any> {
   if (!from) return to
   let key, toVal, fromVal
@@ -66,7 +67,7 @@ function mergeData(
     if (key === '__ob__') continue
     toVal = to[key]
     fromVal = from[key]
-    if (!hasOwn(to, key)) {
+    if (!recursive || !hasOwn(to, key)) {
       set(to, key, fromVal)
     } else if (
       toVal !== fromVal &&
@@ -262,7 +263,22 @@ strats.props =
       if (childVal) extend(ret, childVal)
       return ret
     }
-strats.provide = mergeDataOrFn
+
+strats.provide = function (parentVal: Object | null, childVal: Object | null) {
+  if (!parentVal) return childVal
+  return function () {
+    const ret = Object.create(null)
+    mergeData(ret, isFunction(parentVal) ? parentVal.call(this) : parentVal)
+    if (childVal) {
+      mergeData(
+        ret,
+        isFunction(childVal) ? childVal.call(this) : childVal,
+        false // non-recursive
+      )
+    }
+    return ret
+  }
+}
 
 /**
  * Default strategy.
diff --git a/test/unit/features/options/inject.spec.ts b/test/unit/features/options/inject.spec.ts
index 983367b6126..b4c295e3f51 100644
--- a/test/unit/features/options/inject.spec.ts
+++ b/test/unit/features/options/inject.spec.ts
@@ -712,4 +712,12 @@ describe('Options provide/inject', () => {
     await nextTick()
     expect(spy).toHaveBeenCalledWith(2)
   })
+
+  // #12854
+  test('should not mutate original provide options', () => {
+    const hairMixin = { provide: { hair: 'red' } }
+    const eyesMixin = { provide: { eyes: 'brown' } }
+    new Vue({ mixins: [hairMixin, eyesMixin], render() {} }).$mount()
+    expect(eyesMixin.provide).toStrictEqual({ eyes: 'brown' })
+  })
 })

From 29b5f588032600baae9854ac9a4105916a5aa648 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 9 Nov 2022 20:33:05 +0800
Subject: [PATCH 308/317] fix(reactivity): avoid using WeakMap for IE
 compatibility

Using a WeakMap polyfill isn't ideal because the reason we tried to use
WeakMap was to work with non-extensible objects. However, WeakMap
polyfill for non-extensible objects are non-weak and could lead to
memory leaks.

The trade-off is that we remove support for `readonly()` on
non-extensible objects, which seems reasonable.

close #12837
---
 src/core/observer/index.ts                       |  2 --
 src/v3/reactivity/reactive.ts                    | 10 ++++------
 src/v3/reactivity/readonly.ts                    | 16 +++++++++++-----
 .../unit/features/v3/reactivity/reactive.spec.ts |  2 +-
 .../unit/features/v3/reactivity/readonly.spec.ts | 11 +++++++----
 5 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index 51f928c5c24..ef7296567c7 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -16,7 +16,6 @@ import {
   noop
 } from '../util/index'
 import { isReadonly, isRef, TrackOpTypes, TriggerOpTypes } from '../../v3'
-import { rawMap } from '../../v3/reactivity/reactive'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
@@ -116,7 +115,6 @@ export function observe(
     (isArray(value) || isPlainObject(value)) &&
     Object.isExtensible(value) &&
     !value.__v_skip /* ReactiveFlags.SKIP */ &&
-    !rawMap.has(value) &&
     !isRef(value) &&
     !(value instanceof VNode)
   ) {
diff --git a/src/v3/reactivity/reactive.ts b/src/v3/reactivity/reactive.ts
index c65f25e67d8..da9a1bf0c1c 100644
--- a/src/v3/reactivity/reactive.ts
+++ b/src/v3/reactivity/reactive.ts
@@ -5,13 +5,10 @@ import {
   isPrimitive,
   warn,
   toRawType,
-  isServerRendering,
-  isObject
+  isServerRendering
 } from 'core/util'
 import type { Ref, UnwrapRefSimple, RawSymbol } from './ref'
 
-export const rawMap = new WeakMap()
-
 export const enum ReactiveFlags {
   SKIP = '__v_skip',
   IS_READONLY = '__v_isReadonly',
@@ -122,8 +119,9 @@ export function toRaw<T>(observed: T): T {
 export function markRaw<T extends object>(
   value: T
 ): T & { [RawSymbol]?: true } {
-  if (isObject(value)) {
-    rawMap.set(value, true)
+  // non-extensible objects won't be observed anyway
+  if (Object.isExtensible(value)) {
+    def(value, ReactiveFlags.SKIP, true)
   }
   return value
 }
diff --git a/src/v3/reactivity/readonly.ts b/src/v3/reactivity/readonly.ts
index c3794bb53b3..e3a83930301 100644
--- a/src/v3/reactivity/readonly.ts
+++ b/src/v3/reactivity/readonly.ts
@@ -32,8 +32,8 @@ export type DeepReadonly<T> = T extends Builtin
   ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
   : Readonly<T>
 
-const rawToReadonlyMap = new WeakMap()
-const rawToShallowReadonlyMap = new WeakMap()
+const rawToReadonlyFlag = `__v_rawToReadonly`
+const rawToShallowReadonlyFlag = `__v_rawToShallowReadonly`
 
 export function readonly<T extends object>(
   target: T
@@ -57,20 +57,26 @@ function createReadonly(target: any, shallow: boolean) {
     return target as any
   }
 
+  if (__DEV__ && !Object.isExtensible(target)) {
+    warn(
+      `Vue 2 does not support creating readonly proxy for non-extensible object.`
+    )
+  }
+
   // already a readonly object
   if (isReadonly(target)) {
     return target as any
   }
 
   // already has a readonly proxy
-  const map = shallow ? rawToShallowReadonlyMap : rawToReadonlyMap
-  const existingProxy = map.get(target)
+  const existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag
+  const existingProxy = target[existingFlag]
   if (existingProxy) {
     return existingProxy
   }
 
   const proxy = Object.create(Object.getPrototypeOf(target))
-  map.set(target, proxy)
+  def(target, existingFlag, proxy)
 
   def(proxy, ReactiveFlags.IS_READONLY, true)
   def(proxy, ReactiveFlags.RAW, target)
diff --git a/test/unit/features/v3/reactivity/reactive.spec.ts b/test/unit/features/v3/reactivity/reactive.spec.ts
index a8a30e0353c..aa49f103f6e 100644
--- a/test/unit/features/v3/reactivity/reactive.spec.ts
+++ b/test/unit/features/v3/reactivity/reactive.spec.ts
@@ -259,7 +259,7 @@ describe('reactivity/reactive', () => {
   })
 
   test('markRaw on non-extensible objects', () => {
-    const foo = Object.freeze({})
+    const foo = Object.seal({})
     markRaw(foo)
     expect(isReactive(reactive(foo))).toBe(false)
   })
diff --git a/test/unit/features/v3/reactivity/readonly.spec.ts b/test/unit/features/v3/reactivity/readonly.spec.ts
index fab99bbfbcb..252fb9884b7 100644
--- a/test/unit/features/v3/reactivity/readonly.spec.ts
+++ b/test/unit/features/v3/reactivity/readonly.spec.ts
@@ -526,10 +526,13 @@ describe('reactivity/readonly', () => {
     expect(`et operation on key "x" failed`).toHaveBeenWarned()
   })
 
-  test('compatibility with non-extensible objects', () => {
+  test('warn non-extensible objects', () => {
     const foo = Object.freeze({ a: 1 })
-    const bar = readonly(foo)
-    expect(isReadonly(bar)).toBe(true)
-    expect(readonly(foo)).toBe(bar)
+    try {
+      readonly(foo)
+    } catch (e) {}
+    expect(
+      `Vue 2 does not support creating readonly proxy for non-extensible object`
+    ).toHaveBeenWarned()
   })
 })

From 9dd006b481b4299462e044741bac0861c0b1775c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 9 Nov 2022 20:39:52 +0800
Subject: [PATCH 309/317] release: v2.7.14

---
 CHANGELOG.md                            | 13 +++++++++++++
 package.json                            |  2 +-
 packages/compiler-sfc/package.json      |  2 +-
 packages/server-renderer/package.json   |  2 +-
 packages/template-compiler/package.json |  2 +-
 5 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a2432812ed0..05577cb11d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,16 @@
+## [2.7.14](https://github.com/vuejs/vue/compare/v2.7.13...v2.7.14) (2022-11-09)
+
+
+### Bug Fixes
+
+* **compiler-sfc:** fix template usage check edge case for v-slot destructured default value ([#12842](https://github.com/vuejs/vue/issues/12842)) ([5e3d4e9](https://github.com/vuejs/vue/commit/5e3d4e90cdf92ec0a72bbb2bd44125f1faafae1d)), closes [#12841](https://github.com/vuejs/vue/issues/12841)
+* **provide/inject:** do not mutate original provide options during merge ([d1899ca](https://github.com/vuejs/vue/commit/d1899caf688de961e63e7a0d56f806fc4a12efd9)), closes [#12854](https://github.com/vuejs/vue/issues/12854)
+* **reactivity:** avoid using WeakMap for IE compatibility ([29b5f58](https://github.com/vuejs/vue/commit/29b5f588032600baae9854ac9a4105916a5aa648)), closes [#12837](https://github.com/vuejs/vue/issues/12837)
+* **types:** fix spreading VNodeData in tsx ([#12789](https://github.com/vuejs/vue/issues/12789)) ([f7db7f3](https://github.com/vuejs/vue/commit/f7db7f361b6356591781b9f33abbb0d5b7f9b97c)), closes [#12778](https://github.com/vuejs/vue/issues/12778)
+* **types:** stricter type condition for `EventHandlers` ([#12840](https://github.com/vuejs/vue/issues/12840)) ([0b3cf7d](https://github.com/vuejs/vue/commit/0b3cf7dda9ac605b2b9f799acacd2793e974f225)), closes [#12832](https://github.com/vuejs/vue/issues/12832)
+
+
+
 ## [2.7.13](https://github.com/vuejs/vue/compare/v2.7.12...v2.7.13) (2022-10-14)
 
 
diff --git a/package.json b/package.json
index 33eff56cac0..9fc45db9652 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue",
-  "version": "2.7.13",
+  "version": "2.7.14",
   "packageManager": "pnpm@7.1.0",
   "description": "Reactive, component-oriented view layer for modern web interfaces.",
   "main": "dist/vue.runtime.common.js",
diff --git a/packages/compiler-sfc/package.json b/packages/compiler-sfc/package.json
index 5159c5cce04..637c2568fc5 100644
--- a/packages/compiler-sfc/package.json
+++ b/packages/compiler-sfc/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "2.7.13",
+  "version": "2.7.14",
   "description": "compiler-sfc for Vue 2",
   "main": "dist/compiler-sfc.js",
   "types": "dist/compiler-sfc.d.ts",
diff --git a/packages/server-renderer/package.json b/packages/server-renderer/package.json
index 194d6e9f765..79c78175f51 100644
--- a/packages/server-renderer/package.json
+++ b/packages/server-renderer/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-server-renderer",
-  "version": "2.7.13",
+  "version": "2.7.14",
   "description": "server renderer for Vue 2.0",
   "main": "index.js",
   "types": "types/index.d.ts",
diff --git a/packages/template-compiler/package.json b/packages/template-compiler/package.json
index 79515498d03..7e7d506ed93 100644
--- a/packages/template-compiler/package.json
+++ b/packages/template-compiler/package.json
@@ -1,6 +1,6 @@
 {
   "name": "vue-template-compiler",
-  "version": "2.7.13",
+  "version": "2.7.14",
   "description": "template compiler for Vue 2.0",
   "main": "index.js",
   "unpkg": "browser.js",

From ca11dc6a86f26accc893c1ce5b611dc84a2e7c2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=91=A3=E9=9B=A8=E8=88=AA?= <dong_yu_hang@126.com>
Date: Tue, 6 Dec 2022 22:35:28 +0800
Subject: [PATCH 310/317] chore: fix typo (#12894)

---
 src/core/observer/index.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/core/observer/index.ts b/src/core/observer/index.ts
index ef7296567c7..9988fb8687f 100644
--- a/src/core/observer/index.ts
+++ b/src/core/observer/index.ts
@@ -19,7 +19,7 @@ import { isReadonly, isRef, TrackOpTypes, TriggerOpTypes } from '../../v3'
 
 const arrayKeys = Object.getOwnPropertyNames(arrayMethods)
 
-const NO_INIITIAL_VALUE = {}
+const NO_INITIAL_VALUE = {}
 
 /**
  * In some cases we may want to disable observation inside a component's
@@ -79,7 +79,7 @@ export class Observer {
       const keys = Object.keys(value)
       for (let i = 0; i < keys.length; i++) {
         const key = keys[i]
-        defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock)
+        defineReactive(value, key, NO_INITIAL_VALUE, undefined, shallow, mock)
       }
     }
   }
@@ -145,7 +145,7 @@ export function defineReactive(
   const setter = property && property.set
   if (
     (!getter || setter) &&
-    (val === NO_INIITIAL_VALUE || arguments.length === 2)
+    (val === NO_INITIAL_VALUE || arguments.length === 2)
   ) {
     val = obj[key]
   }

From 2e570617666983ababcfd167dfa50208f5dfd45a Mon Sep 17 00:00:00 2001
From: Caichong <951412526@qq.com>
Date: Wed, 14 Dec 2022 16:43:02 +0800
Subject: [PATCH 311/317] chore: comment typos (#12878)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: 方恒 <fangheng@shwpg.com>
---
 types/common.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/types/common.d.ts b/types/common.d.ts
index 3165711c702..01d1efbfc7a 100644
--- a/types/common.d.ts
+++ b/types/common.d.ts
@@ -14,7 +14,7 @@ type Equal<Left, Right> =
 
 export type HasDefined<T> = Equal<T, unknown> extends true ? false : true
 
-// If the the type T accepts type "any", output type Y, otherwise output type N.
+// If the type T accepts type "any", output type Y, otherwise output type N.
 // https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
 export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N
 

From 34c6192f4a5d0471da5655ebcf111653fd920172 Mon Sep 17 00:00:00 2001
From: Ihor Sychevskyi <arhell333@gmail.com>
Date: Tue, 27 Dec 2022 11:19:37 +0200
Subject: [PATCH 312/317] chore: update links (http=https) (#12911)

---
 .github/CODE_OF_CONDUCT.md          | 2 +-
 .github/CONTRIBUTING.md             | 2 +-
 examples/classic/todomvc/index.html | 4 ++--
 examples/classic/todomvc/readme.md  | 4 ++--
 src/compiler/parser/html-parser.ts  | 2 +-
 src/platforms/web/util/element.ts   | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md
index b39f08e2d28..82effcdc869 100644
--- a/.github/CODE_OF_CONDUCT.md
+++ b/.github/CODE_OF_CONDUCT.md
@@ -10,4 +10,4 @@ Project maintainers have the right and responsibility to remove, edit, or reject
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
 
-This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)
+This Code of Conduct is adapted from the [Contributor Covenant](https://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 3f3302a572e..e4ecadaea68 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -36,7 +36,7 @@ Hi! I'm really excited that you are interested in contributing to Vue.js. Before
 
 ## Development Setup
 
-You will need [Node.js](http://nodejs.org) **version 12+** and [pnpm](https://pnpm.io/).
+You will need [Node.js](https://nodejs.org) **version 12+** and [pnpm](https://pnpm.io/).
 
 After cloning the repo, run:
 
diff --git a/examples/classic/todomvc/index.html b/examples/classic/todomvc/index.html
index 504d93597d7..3d9557edf99 100644
--- a/examples/classic/todomvc/index.html
+++ b/examples/classic/todomvc/index.html
@@ -54,8 +54,8 @@ <h1>todos</h1>
     </section>
     <footer class="info">
       <p>Double-click to edit a todo</p>
-      <p>Written by <a href="http://evanyou.me">Evan You</a></p>
-      <p>Part of <a href="http://todomvc.com">TodoMVC</a></p>
+      <p>Written by <a href="https://evanyou.me">Evan You</a></p>
+      <p>Part of <a href="https://todomvc.com">TodoMVC</a></p>
     </footer>
 
     <script>
diff --git a/examples/classic/todomvc/readme.md b/examples/classic/todomvc/readme.md
index 64277f62e9a..db6affe8af7 100644
--- a/examples/classic/todomvc/readme.md
+++ b/examples/classic/todomvc/readme.md
@@ -16,7 +16,7 @@ Here are some links you may find helpful:
 
 Get help from other Vue.js users:
 
-* [Vue.js official forum](http://forum.vuejs.org)
+* [Vue.js official forum](https://forum.vuejs.org)
 * [Vue.js on Twitter](https://twitter.com/vuejs)
 * [Vue.js on Gitter](https://gitter.im/vuejs/vue)
 
@@ -24,4 +24,4 @@ _If you have other helpful links to share, or find any of the links above no lon
 
 ## Credit
 
-This TodoMVC application was created by [Evan You](http://evanyou.me).
+This TodoMVC application was created by [Evan You](https://evanyou.me).
diff --git a/src/compiler/parser/html-parser.ts b/src/compiler/parser/html-parser.ts
index ab24cb52ba7..29acbfc8fc5 100644
--- a/src/compiler/parser/html-parser.ts
+++ b/src/compiler/parser/html-parser.ts
@@ -98,7 +98,7 @@ export function parseHTML(html, options: HTMLParserOptions) {
           }
         }
 
-        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+        // https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
         if (conditionalComment.test(html)) {
           const conditionalEnd = html.indexOf(']>')
 
diff --git a/src/platforms/web/util/element.ts b/src/platforms/web/util/element.ts
index e5788c4a029..f1df261a355 100644
--- a/src/platforms/web/util/element.ts
+++ b/src/platforms/web/util/element.ts
@@ -62,7 +62,7 @@ export function isUnknownElement(tag: string): boolean {
   }
   const el = document.createElement(tag)
   if (tag.indexOf('-') > -1) {
-    // http://stackoverflow.com/a/28210364/1070244
+    // https://stackoverflow.com/a/28210364/1070244
     return (unknownElementCache[tag] =
       el.constructor === window.HTMLUnknownElement ||
       el.constructor === window.HTMLElement)

From 0e8511a8becf627e00443bd799dd99e5fd1b8a35 Mon Sep 17 00:00:00 2001
From: Vadim <vadimgerasimenko101@gmail.com>
Date: Wed, 28 Dec 2022 00:38:05 +0300
Subject: [PATCH 313/317] chore: fix typo in apiAsyncComponent.ts (#12912)

---
 src/v3/apiAsyncComponent.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/v3/apiAsyncComponent.ts b/src/v3/apiAsyncComponent.ts
index aca3a7a0ab8..888a0681cb6 100644
--- a/src/v3/apiAsyncComponent.ts
+++ b/src/v3/apiAsyncComponent.ts
@@ -47,7 +47,7 @@ export function defineAsyncComponent(
 
   if (__DEV__ && suspensible) {
     warn(
-      `The suspensiblbe option for async components is not supported in Vue2. It is ignored.`
+      `The suspensible option for async components is not supported in Vue2. It is ignored.`
     )
   }
 

From d52fbff7a77d8d9c032a74a21c34e2c122add5d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=98=9F=E5=AE=BF=E5=90=9B?= <huxinfeng1024@qq.com>
Date: Thu, 12 Jan 2023 22:47:00 +0800
Subject: [PATCH 314/317] chore: fix typo in utils.ts (#12927) [skip ci]

---
 src/types/utils.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/types/utils.ts b/src/types/utils.ts
index 8c77093f5ee..6f7eeeeaba6 100644
--- a/src/types/utils.ts
+++ b/src/types/utils.ts
@@ -1,3 +1,3 @@
-// If the the type T accepts type "any", output type Y, otherwise output type N.
+// If the type T accepts type "any", output type Y, otherwise output type N.
 // https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
 export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N

From a9ca2d85193e435e668ba25ace481bfb176b0c6e Mon Sep 17 00:00:00 2001
From: rj1 <rj1@riseup.net>
Date: Sat, 4 Feb 2023 12:16:38 -0600
Subject: [PATCH 315/317] chore: typos (#12949)

---
 test/unit/modules/compiler/parser.spec.ts | 2 +-
 types/test/async-component-test.ts        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/unit/modules/compiler/parser.spec.ts b/test/unit/modules/compiler/parser.spec.ts
index 4fb272f3b0e..1efba124146 100644
--- a/test/unit/modules/compiler/parser.spec.ts
+++ b/test/unit/modules/compiler/parser.spec.ts
@@ -767,7 +767,7 @@ describe('parser', () => {
     expect(ast.directives[0].arg).toBe('field1')
   })
 
-  it('attribute with modifiered directive', () => {
+  it('attribute with modified directive', () => {
     const ast = parse(
       '<input type="text" name="field1" :value="msg" v-validate.on.off>',
       baseOptions
diff --git a/types/test/async-component-test.ts b/types/test/async-component-test.ts
index d139157b5c5..79978ddf8de 100644
--- a/types/test/async-component-test.ts
+++ b/types/test/async-component-test.ts
@@ -41,4 +41,4 @@ const e: AsyncComponent = () => ({
 })
 
 // Test that Vue.component accepts any AsyncComponent
-Vue.component('async-compponent1', a)
+Vue.component('async-component1', a)

From 30fd4b59c981f806f862bcf8621c0b71da5890af Mon Sep 17 00:00:00 2001
From: BeiYuShuiGuoLvDeKongQi <958414905@qq.com>
Date: Sun, 26 Apr 2020 21:38:53 +0800
Subject: [PATCH 316/317] fix(namespace): apply every namespace in slot when
 call applyNS (#11315)

---
 src/core/vdom/create-element.ts               | 11 +++++
 test/unit/modules/vdom/create-element.spec.ts | 43 +++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index 62dd004c34a..bad54d97fa0 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -157,6 +157,17 @@ function applyNS(vnode, ns, force?: boolean) {
       }
     }
   }
+
+  // #11315
+  if (isObject(vnode.componentOptions) && isDef(vnode.componentOptions.children)) {
+    for (var i = 0, l = vnode.componentOptions.children.length; i < l; i++) {
+      var child = vnode.componentOptions.children[i]
+      if (isDef(child.tag) && (
+        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
+        applyNS(child, ns, force)
+      }
+    }
+  }
 }
 
 // ref #5318
diff --git a/test/unit/modules/vdom/create-element.spec.ts b/test/unit/modules/vdom/create-element.spec.ts
index f97b4bc07cf..7ba8730c42c 100644
--- a/test/unit/modules/vdom/create-element.spec.ts
+++ b/test/unit/modules/vdom/create-element.spec.ts
@@ -147,6 +147,49 @@ describe('create-element', () => {
     expect(vnode.children[0].children[1].ns).toBe('svg')
   })
 
+  // #11315
+  it('render svg foreignObject nested component slot with correct namespace', () => {
+    const vm = new Vue({
+      template: `
+        <svg>
+          <box></box>
+        </svg>
+      `,
+      components: {
+        'box': {
+          template: `
+            <foreignObject>
+              <comp-with-slot>
+                <p></p><svg></svg>
+              </comp-with-slot>
+            </foreignObject>
+          `,
+          components: {
+            'comp-with-slot': {
+              template: `
+                <div>
+                  <slot />
+                </div>
+              `
+            }
+          }
+        }
+      }
+    }).$mount()
+    const box = vm.$children[0]
+    const compWithSlot = box.$children[0]
+    expect(box.$vnode.ns).toBe('svg')
+    expect(box._vnode.tag).toBe('foreignObject')
+    expect(box._vnode.ns).toBe('svg')
+    expect(compWithSlot.$vnode.ns).toBeUndefined()
+    expect(compWithSlot._vnode.tag).toBe('div')
+    expect(compWithSlot._vnode.ns).toBeUndefined()
+    expect(compWithSlot._vnode.children[0].tag).toBe('p')
+    expect(compWithSlot._vnode.children[0].ns).toBeUndefined()
+    expect(compWithSlot._vnode.children[1].tag).toBe('svg')
+    expect(compWithSlot._vnode.children[1].ns).toBe('svg')
+  })
+
   // #6642
   it('render svg foreignObject component with correct namespace', () => {
     const vm = new Vue({

From 446b2ce9ec5ebff3bb03d59c66c6c154c79339a3 Mon Sep 17 00:00:00 2001
From: Rairn <958414905@qq.com>
Date: Mon, 2 Jan 2023 15:34:24 +0800
Subject: [PATCH 317/317] refactor: extract variable

---
 src/core/vdom/create-element.ts | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/src/core/vdom/create-element.ts b/src/core/vdom/create-element.ts
index bad54d97fa0..6abade56757 100644
--- a/src/core/vdom/create-element.ts
+++ b/src/core/vdom/create-element.ts
@@ -146,9 +146,14 @@ function applyNS(vnode, ns, force?: boolean) {
     ns = undefined
     force = true
   }
-  if (isDef(vnode.children)) {
-    for (let i = 0, l = vnode.children.length; i < l; i++) {
-      const child = vnode.children[i]
+  const children =
+    vnode.children ||
+    // #11315
+    (vnode.componentOptions && vnode.componentOptions.children)
+
+  if (isDef(children)) {
+    for (let i = 0, l = children.length; i < l; i++) {
+      const child = children[i]
       if (
         isDef(child.tag) &&
         (isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))
@@ -157,17 +162,6 @@ function applyNS(vnode, ns, force?: boolean) {
       }
     }
   }
-
-  // #11315
-  if (isObject(vnode.componentOptions) && isDef(vnode.componentOptions.children)) {
-    for (var i = 0, l = vnode.componentOptions.children.length; i < l; i++) {
-      var child = vnode.componentOptions.children[i]
-      if (isDef(child.tag) && (
-        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {
-        applyNS(child, ns, force)
-      }
-    }
-  }
 }
 
 // ref #5318